diff --git a/.clang-tidy b/.clang-tidy
index 5b36ac93d48..880a8ae9d97 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -1,20 +1,26 @@
 Checks: >
   *,
   -abseil-*,
+  -altera-struct-pack-align,
+  -altera-unroll-loops,
   -android-*,
-  -cert-err58-cpp,
+  -boost-use-ranges,
+  -bugprone-easily-swappable-parameters,
   -cert-err58-cpp,
   -clang-analyzer-osx-*,
   -cppcoreguidelines-avoid-c-arrays,
+  -cppcoreguidelines-avoid-const-or-ref-data-members,
+  -cppcoreguidelines-avoid-do-while,
   -cppcoreguidelines-avoid-goto,
   -cppcoreguidelines-avoid-magic-numbers,
   -cppcoreguidelines-avoid-non-const-global-variables,
+  -cppcoreguidelines-non-private-member-variables-in-classes,
   -cppcoreguidelines-owning-memory,
   -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
+  -cppcoreguidelines-pro-bounds-constant-array-index,
   -cppcoreguidelines-pro-bounds-pointer-arithmetic,
   -cppcoreguidelines-pro-type-reinterpret-cast,
   -cppcoreguidelines-pro-type-vararg,
-  -cppcoreguidelines-pro-type-vararg,
   -cppcoreguidelines-special-member-functions,
   -fuchsia-*,
   -google-*,
@@ -25,25 +31,32 @@ Checks: >
   -hicpp-special-member-functions,
   -hicpp-use-equals-default,
   -hicpp-vararg,
-  -hicpp-vararg,
   -llvm-header-guard,
   -llvm-include-order,
+  -llvm-qualified-auto,
   -llvmlibc-*,
-  -misc-no-recursion,
+  -misc-include-cleaner,
   -misc-no-recursion,
   -misc-non-private-member-variables-in-classes,
   -misc-unused-parameters,
   -modernize-avoid-c-arrays,
   -modernize-deprecated-headers,
+  -modernize-use-designated-initializers,
   -modernize-use-nodiscard,
   -modernize-use-trailing-return-type,
   -mpi-*,
   -objc-*,
   -openmp-*,
+  -performance-avoid-endl,
+  -performance-enum-size,
   -readability-avoid-const-params-in-decls,
   -readability-convert-member-functions-to-static,
+  -readability-function-cognitive-complexity,
+  -readability-identifier-length,
   -readability-implicit-bool-conversion,
   -readability-magic-numbers,
+  -readability-math-missing-parentheses,
+  -readability-qualified-auto,
   -zircon-*,
 
 HeaderFilterRegex: '.*'
diff --git a/.claude/CLAUDE.md b/.claude/CLAUDE.md
new file mode 100644
index 00000000000..be69dad6ea7
--- /dev/null
+++ b/.claude/CLAUDE.md
@@ -0,0 +1,235 @@
+# CLAUDE.md
+
+Guidance for Claude Code when working in the Velox repository.
+
+## Branch Hygiene
+
+Before creating a new feature branch, always:
+
+1. `git checkout main`
+2. `git fetch upstream && git rebase upstream/main`
+3. Delete stale feature branches.
+4. Push main to origin if behind upstream.
+5. `git checkout -b <new-branch>`
+
+## PR Review
+
+When asked to review a PR (via `/pr-review`), always use the /pr-review skill.
+
+### Review scripts
+
+Use `scripts/review/fetch.py` and `scripts/review/post.py` for PR reviews
+instead of raw `gh api` calls.
+
+```bash
+# Fetch PR metadata, diff, comments, and reviews in one shot.
+python3 scripts/review/fetch.py <owner/repo> <pr-number>
+python3 scripts/review/fetch.py <github-pr-url>
+
+# Post a review from a file.
+python3 scripts/review/post.py <owner/repo> <pr-number> <event> <body-file>
+python3 scripts/review/post.py <github-pr-url> <event> <body-file>
+# Events: APPROVE, REQUEST_CHANGES, COMMENT
+```
+
+Always draft the review body in `/tmp/` and get approval before calling
+`post.py`.
+
+### Review style
+
+See [scripts/review/REVIEW_GUIDE.md](../scripts/review/REVIEW_GUIDE.md).
+
+## Queries
+
+When asked a question about the PR or codebase (via `/query`), use the /query skill.
+
+## Overview
+
+Velox is an open source C++ library for composable data processing and
+query execution. Licensed under Apache 2.0. Requires C++20, GCC 11+ or
+Clang 15+.
+
+## Build
+
+```bash
+make debug    # debug build
+make release  # optimized build
+```
+
+## Testing
+
+```bash
+make unittest                    # run all tests
+cd _build/debug && ctest -j 8   # run all tests in parallel
+ctest -R ExprTest                # run tests matching a pattern
+```
+
+Test files live in `tests/` subdirectories alongside source.
+
+### Grouped tests
+
+Four test suites use `velox_add_grouped_tests` to reduce link times on Linux CI
+by batching source files into shared binaries:
+- `velox/exec/tests` (`velox_exec_test`, `velox_exec_util_test`)
+- `velox/functions/prestosql/aggregates/tests`
+- `velox/common/caching/tests`
+- `velox/serializers/tests`
+
+All other test suites use individual binaries on all platforms.
+
+On macOS, grouping is off by default (`VELOX_ENABLE_GROUPED_TESTS=OFF`) and each
+test file gets its own binary (e.g., `ValuesTest.cpp` → `velox_exec_test_ValuesTest`).
+On Linux CI, grouping is on (`velox_exec_test_group0` through `_group7`).
+Override with `-DVELOX_ENABLE_GROUPED_TESTS=ON/OFF`.
+
+### Common test workflows
+
+```bash
+# Run all test binaries whose ctest name matches a regex.
+# On Linux this matches velox_exec_test_group0 … _group7.
+# On macOS this matches velox_exec_test_ValuesTest,
+# velox_exec_test_HashJoinTest, etc.
+cd _build/debug && ctest -R velox_exec
+
+# Run a specific test file (macOS — individual binary)
+_build/debug/velox/exec/tests/velox_exec_test_ValuesTest --gtest_filter="ValuesTest.*"
+
+# Run a specific test case (Linux — grouped binary)
+_build/debug/velox/exec/tests/velox_exec_test_group3 --gtest_filter="ValuesTest.empty"
+```
+
+**Re-running a CI failure locally:** CI reports a failure in
+`velox_exec_test_group3` with `ValuesTest.empty`. On Linux, run the grouped
+binary directly. On macOS, the grouped binary does not exist — use the
+per-file binary instead: `velox_exec_test_ValuesTest --gtest_filter="ValuesTest.empty"`.
+
+**Adding a new test to a grouped suite:** Add the source file to the `SOURCES`
+list in the relevant `velox_add_grouped_tests()` call in `CMakeLists.txt`. It
+is automatically assigned to a group on Linux and gets its own binary on macOS.
+
+**Creating a new test suite:** Use `velox_add_grouped_tests` for suites with
+many test files (10+) that link against large libraries like velox core — each
+individual binary pays the full link cost, so grouping them into shared binaries
+significantly reduces total CI build time. For suites with only a few test files
+or lightweight dependencies, use `add_executable` / `add_test`.
+
+## Formatting
+
+```bash
+make format  # format all changed files
+```
+
+## Coding Style
+
+Read [CODING_STYLE.md](../CODING_STYLE.md) for the complete guide. Key rules
+are summarized below.
+
+### Comments
+
+- Use `///` for public API documentation (classes, public methods, public members).
+- Use `//` for private/protected members and comments inside code blocks.
+- Start comments with active verbs, not "This class…" or "This method…".
+  - ❌ `/// This class builds query plans.`
+  - ✅ `/// Builds query plans.`
+- Comments should be full English sentences starting with a capital letter and ending with a period.
+- Comment every class, every non-trivial method, every member variable.
+- Do not restate the variable name. Either explain the semantic meaning or omit the comment.
+  - ❌ `// A simple counter.` above `size_t count_{0};`
+- Avoid redundant comments that repeat what the code already says. Comments should explain *why*, not *what*.
+- Use `// TODO: Description.` for future work. Do not include author's username.
+- Do not duplicate comments between `.h` and `.cpp`. Document the function in the header; the implementation should not repeat the same comment. Duplicated comments diverge over time.
+
+### Naming Conventions
+
+- **PascalCase** for types and file names.
+- **camelCase** for functions, member and local variables.
+- **camelCase_** for private and protected member variables.
+- **snake_case** for namespace names and build targets.
+- **UPPER_SNAKE_CASE** for macros.
+- **kPascalCase** for static constants and enumerators.
+- Do not abbreviate. Use full, descriptive names. Well-established abbreviations (`id`, `url`, `sql`, `expr`) are acceptable.
+- Prefer `numXxx` over `xxxCount` (e.g. `numRows`, `numKeys`).
+- Never name a file or class `*Utils`, `*Helpers`, or `*Common`. These generic
+  names attract unrelated functions over time and lose cohesion. Name files and
+  classes after the concept they represent. Use a class with static methods to
+  group related operations, and shorten method names since the class name
+  provides context.
+
+### Asserts and CHECKs
+
+- Use `VELOX_CHECK_*` for internal errors, `VELOX_USER_CHECK_*` for user errors.
+- Prefer two-argument forms: `VELOX_CHECK_LT(idx, size)` over `VELOX_CHECK(idx < size)`.
+- Use `VELOX_FAIL()` / `VELOX_USER_FAIL()` to throw unconditionally.
+- Use `VELOX_UNREACHABLE()` for impossible branches, `VELOX_NYI()` for unimplemented paths.
+- Put runtime information (names, values, types) at the **end** of error messages, after the static description.
+  - ❌ `VELOX_USER_FAIL("Column '{}' is ambiguous", name);`
+  - ✅ `VELOX_USER_FAIL("Column is ambiguous: {}", name);`
+
+### Variables
+
+- Prefer value types, then `std::optional`, then `std::unique_ptr`.
+- Prefer `std::string_view` over `const std::string&` for function parameters.
+- Use uniform initialization: `size_t size{0}` over `size_t size = 0`.
+- Declare variables in the smallest scope, as close to usage as possible.
+- Use digit separators (`'`) for numeric literals with 4 or more digits: `10'000`, not `10000`.
+- Use trailing commas in multi-line initializer lists, enum definitions, and
+  function-call argument lists that span multiple lines. This produces cleaner
+  diffs when items are added or reordered.
+
+### API Design
+
+- Keep the public API surface small.
+- Prefer free functions in `.cpp` (anonymous namespace) over private/static class methods.
+- Define free functions close to where they are used, not grouped together at the top or bottom of the file.
+- Keep method implementations in `.cpp` except for trivial one-liners.
+- Avoid default arguments when all callers can pass values explicitly.
+- Never use `friend`, `FRIEND_TEST`, or any friend declarations. If a test needs access to private members, redesign the API or test through public methods instead.
+
+### Tests
+
+- Place new tests next to related existing tests, not at the end of the file. Group tests by topic (e.g., place `tryCast` next to `types`, `notBetween` next to `ifClause` which uses `between`).
+
+Use gtest container matchers (`testing::ElementsAre`, etc.) for verifying collections:
+
+```cpp
+// ❌ Avoid - multiple individual assertions
+EXPECT_EQ(result.size(), 3);
+EXPECT_EQ(result[0], "a");
+EXPECT_EQ(result[1], "b");
+EXPECT_EQ(result[2], "c");
+
+// ✅ Prefer - single matcher assertion
+EXPECT_THAT(result, testing::ElementsAre("a", "b", "c"));
+```
+
+Common matchers:
+- `ElementsAre(...)` - exact ordered match
+- `UnorderedElementsAre(...)` - exact unordered match
+- `Contains(...)` - at least one element matches
+- `IsEmpty()` - collection is empty
+- `SizeIs(n)` - collection has n elements
+
+Requires `#include <gmock/gmock.h>`.
+
+## Common Mistakes
+
+These are frequently violated rules. Check every new or modified line against
+this list before finishing.
+
+- **Bug fixes without a failing test first.** Write the test first, confirm it fails, then fix. A test that passes with and without the fix proves nothing.
+- **`///` vs `//` wrong comment style.** `///` is only for public API in headers. Everything else uses `//`.
+- **One-letter and abbreviated variable names.** Use full, descriptive names. Only loop indices (`i`, `j`) are acceptable.
+- **Undocumented APIs in headers.** Every class, method, and member variable in a `.h` file must have a comment.
+- **Non-trivial implementations in headers.** If a method body has more than one statement, it belongs in the `.cpp` file.
+- **`goto` statements.** Never use `goto`. Use early returns, helper functions, or duplicated code paths.
+- **Fitting tests to buggy code.** Never update test expectations to match buggy output without verifying correctness first.
+- **Generic file and class names.** Never name a file or class `*Utils`, `*Helpers`, or `*Common`.
+- **Verify causation before asserting it.** Do not attribute failures to a commit based on its message alone. Verify empirically.
+- **Silently simplifying an approved plan.** If a step is harder than expected, say so and get approval before reducing scope.
+- **Working around infrastructure bugs.** Do not silently work around bugs in shared infrastructure. Report and discuss.
+
+## Design Documents
+
+Design (including proposals) live in `docs/designs/`.  When creating new
+designs, place them there with a descriptive filename (e.g.,
+`column-extraction-pushdown.md`).
diff --git a/.claude/skills/ci-failure-analysis/SKILL.md b/.claude/skills/ci-failure-analysis/SKILL.md
new file mode 100644
index 00000000000..e088f9af705
--- /dev/null
+++ b/.claude/skills/ci-failure-analysis/SKILL.md
@@ -0,0 +1,137 @@
+You are a CI failure analyst for the Velox C++ project. A CI run has failed
+on PR #{{PR_NUMBER}} in the {{REPOSITORY}} repo.
+The workflow run ID is {{RUN_ID}}.
+
+Failure metadata (JSON array of failed jobs):
+{{FAILURE_METADATA}}
+
+Each entry has: "job" (job name), "type" ("build", "test", or "unknown"), and
+optionally "failed_tests" (newline-separated test names). A type of "unknown"
+means no structured failure metadata was available (e.g., Fuzzer Jobs) — you
+must determine the failure type from the job logs.
+
+Your task:
+1. Use `gh api` to download the logs for the failed jobs in this workflow run.
+   - List jobs: `gh api repos/{{REPOSITORY}}/actions/runs/{{RUN_ID}}/jobs`
+   - For each job, save its `id` and note the step numbers from the `steps` array.
+     Find the step that ran the tests or build (usually named "Run Tests", "Build",
+     or similar — look for the step whose logs contain the failure output, not the
+     status-reporting step). You need the job `id` and step `number` to build a
+     direct link: `https://github.com/{{REPOSITORY}}/actions/runs/{{RUN_ID}}/job/{job_id}#step:{step_number}:{ui_line}`
+     To compute `ui_line`: the raw log numbers lines across all steps, but the
+     GitHub UI numbers lines per-step starting from 1. To convert, find the line
+     in the raw log where the test step begins (search for "Test project /__w/")
+     and call that `start_line`. Then find the `[  FAILED  ]` line and call that
+     `failed_line`. The UI line number is `failed_line - start_line + 1`.
+     For build failures, use the first `error:` line instead of `[  FAILED  ]`.
+   - Download job logs: `gh api repos/{{REPOSITORY}}/actions/jobs/{job_id}/logs` (returns plain text)
+   - If job logs API fails, try: `gh run view {{RUN_ID}} --repo {{REPOSITORY}} --log-failed`
+
+2. For TEST failures: Find the gtest failure output — the lines between `[ RUN      ]` and
+   `[  FAILED  ]` for each failing test. Extract the assertion message, expected vs actual
+   values, file path, and line number. Also find the test binary name from the ctest output
+   (look for lines like `Start N: <test_name>` followed by the binary path, or search for
+   the binary path in the test output). You will need this for the reproduce command.
+
+3. For BUILD failures: Find compiler `error:` lines with file paths and error messages.
+
+4. For FUZZER failures (from the "Fuzzer Jobs" workflow): Fuzzers run via
+   `run-fuzzer-parallel.sh` which launches multiple instances in parallel.
+   Look for crash reports, assertion failures (VELOX_CHECK, VELOX_FAIL),
+   segfaults, or timeouts in the logs. Key information to extract:
+   - The fuzzer name (e.g., "Presto Fuzzer", "Join Fuzzer", "Spark Expression Fuzzer")
+   - The error message or assertion failure
+   - The seed value (from `--seed` flag or log output) for reproduction
+   - The file and line number from stack traces
+   - The reproduce command uses the fuzzer binary with `--seed <seed>` flag
+
+5. Get the PR diff: `gh pr diff {{PR_NUMBER}} --repo {{REPOSITORY}}`
+   Determine if the failures are likely caused by the PR changes.
+
+6. Search open issues for known failures:
+   `gh issue list --repo {{REPOSITORY}} --search "<test_name>" --state open --limit 5`
+   Check if any failing test has a known open issue.
+
+7. Check if the same failures occur on the main branch (pre-existing/flaky):
+   `gh run list --repo {{REPOSITORY}} --branch main --workflow "<workflow_name>" --limit 3 --json conclusion,databaseId`
+   Use the appropriate workflow name: "Linux Build using GCC" for build/test
+   failures, "Fuzzer Jobs" for fuzzer failures.
+
+8. Post a SINGLE comment on the PR with your analysis. Use update-or-create
+   behavior so re-runs replace the prior analysis instead of stacking new
+   comments. Look up the prior comment by its heading, then edit that
+   specific comment ID via the GitHub API.
+
+   Write the body to a file first (e.g., `/tmp/ci-failure-comment.md`) so
+   multi-line markdown round-trips correctly, then:
+   - Find any prior comment with this workflow's heading:
+     `gh api "repos/{{REPOSITORY}}/issues/{{PR_NUMBER}}/comments" --paginate \
+        --jq '[.[] | select(.body | contains("## CI Failure Analysis")) | .id] | first'`
+   - If a comment ID is returned, edit that specific comment in place by
+     piping a JSON body in via `--input -`:
+     `jq -Rs '{body: .}' /tmp/ci-failure-comment.md \
+        | gh api -X PATCH "repos/{{REPOSITORY}}/issues/comments/<comment_id>" --input -`
+   - Otherwise, create a new comment:
+     `gh pr comment {{PR_NUMBER}} --repo {{REPOSITORY}} --body-file /tmp/ci-failure-comment.md`
+
+   The `## CI Failure Analysis` heading must remain in the body so this
+   lookup keeps working across re-runs.
+
+Format the comment as follows (use markdown):
+```
+## CI Failure Analysis
+
+> _Auto-generated by the CI Failure Analysis workflow. This comment is updated in place each time CI fails on a new commit, so it always reflects the latest run — re-pushing or re-running CI will refresh the analysis below. Last updated <UTC_TIMESTAMP> from [workflow run {{RUN_ID}}](https://github.com/{{REPOSITORY}}/actions/runs/{{RUN_ID}})._
+
+### <STATUS_EMOJI> <Job Name> — <BUILD|TEST> Failure  [View logs](<step-level link>)
+
+**Failed tests:** (or **Build errors:** for build failures)
+
+For each failing test, show:
+- Test name
+- The assertion error (expected vs actual, or the error message)
+- Source file and line number
+
+For build failures, show:
+- The compiler error message
+- Source file and line number
+
+Keep failure details in a code block for readability.
+
+(Repeat the above section for each failed job, each with its own step-level link)
+
+---
+
+**Correlation with PR changes:**
+- State whether the failure appears related to the PR diff or not
+- If related, point to the specific file/function in the diff that likely caused it
+- If unrelated, explain why (e.g., "This test modifies X but the PR only touches Y")
+
+**Known issues:**
+- If an open issue tracks this failure, link to it
+- If the same test fails on main, note it as a pre-existing/flaky failure
+
+**Reproduce locally:** (for test failures)
+- Show the command to reproduce, e.g.:
+  `./_build/debug/velox/exec/tests/velox_exec_test_group0 --gtest_filter="TestSuite.testCase"`
+  Use the actual binary path from the ctest log output.
+
+**Recommended fix:** (if the failure is related to the PR)
+- Brief suggestion of what to fix
+```
+
+The blockquote line directly under the heading MUST be present on every
+posted comment. Use the current UTC time in `YYYY-MM-DD HH:MM:SS UTC`
+format (run `date -u +'%Y-%m-%d %H:%M:%S UTC'`). Because the comment is
+overwritten in place on re-runs, this line is the only visible signal
+that the analysis was refreshed — it changes on every update and stays
+static if no re-run has happened. It sits directly under the heading
+(not as a footer) so reviewers see it without scrolling past the
+analysis.
+
+Important rules:
+- Be concise. Show only the relevant failure output, not the entire log.
+- If many tests fail (>5), show the first 3-5 in detail and summarize the rest.
+- Cap the comment at 60,000 characters (GitHub limit is 65,536).
+- Use the `gh pr comment` command to post. Do NOT use any other method.
+- If you cannot determine the cause, say so honestly rather than guessing.
diff --git a/.claude/skills/pr-review/SKILL.md b/.claude/skills/pr-review/SKILL.md
new file mode 100644
index 00000000000..28833194377
--- /dev/null
+++ b/.claude/skills/pr-review/SKILL.md
@@ -0,0 +1,187 @@
+---
+name: pr-review
+description: Review Velox pull requests for code quality, memory safety, performance, and correctness. Use when reviewing PRs, when asked to review code changes, or when the user mentions "/pr-review".
+---
+
+# Velox PR Review Skill
+
+Review Velox pull requests focusing on what CI cannot check: code quality, memory
+safety, concurrency, performance, and correctness. This is performance-critical C++
+code for a database execution engine where bugs can cause data corruption, crashes,
+or security vulnerabilities.
+
+## Usage Modes
+
+### GitHub Actions Mode
+
+When invoked via `/pr-review [additional context]` on a GitHub PR, the action
+pre-fetches PR metadata and injects it into the prompt. Detect this mode by the
+presence of `<formatted_context>`, `<pr_or_issue_body>`, and `<comments>` tags in
+the prompt.
+
+The prompt already contains:
+- PR metadata (title, author, branch names, additions/deletions, file count)
+- PR body/description
+- All comments and review comments (with file/line references)
+- List of changed files with paths and change types
+
+Use git commands to get the diff and commit history. The base branch name is in the prompt context (look for PR Branch: <head> -> <base> or the baseBranch field).
+
+```bash
+# Get the full diff against the base branch
+git diff origin/<baseBranch>...HEAD
+
+# Get diff stats
+git diff --stat origin/<baseBranch>...HEAD
+
+# Get commit history for this PR
+git log origin/<baseBranch>..HEAD --oneline
+
+# If the base branch ref is not available, fetch it first
+git fetch origin <baseBranch> --depth=1
+```
+
+Do NOT use `gh` CLI commands in this mode -- only git commands are available.
+All PR metadata, comments, and reviews are already in the prompt context;
+only the diff and commit log need to be fetched via git.
+
+If the reviewer provided additional context or instructions after the `/pr-review`
+command, incorporate those into your review focus.
+
+### Local CLI Mode
+
+The user provides a PR number or URL:
+
+```
+/pr-review 12345
+/pr-review https://github.com/facebookincubator/velox/pull/12345
+```
+
+Use `gh` CLI to fetch PR data:
+
+```bash
+gh pr view <PR_NUMBER> --json title,body,author,baseRefName,headRefName,files,additions,deletions,commits
+gh pr diff <PR_NUMBER>
+gh pr view <PR_NUMBER> --json comments,reviews
+```
+
+## Review Workflow
+
+### Step 1: Read Project Guidelines
+
+**Before reviewing, you MUST Read `CODING_STYLE.md` at the repo root in
+full.** Do not skim, do not skip — every modified line in the diff must be
+checked against it.
+
+The "Common Mistakes" section is the authoritative checklist for the
+highest-volume real review hits (`///` vs `//`, abbreviations, `*Utils`,
+undocumented headers, header-body weight, `goto`, test-first for bug
+fixes, naming conventions, assert forms, etc.).
+
+This skill does not maintain a duplicate checklist — `CODING_STYLE.md`
+is the single source of truth. If anything in this skill ever appears to
+contradict `CODING_STYLE.md`, prefer `CODING_STYLE.md`.
+
+### Step 2: Analyze Changes and Prior Review
+
+Read through the diff systematically:
+1. Identify the purpose of the change from title/description
+2. Group changes by type (new code, tests, config, docs)
+3. Note the scope of changes (files affected, lines changed)
+
+The `<comments>` block in the prompt context contains all prior review
+comments — including any from earlier `/pr-review` invocations on this PR.
+Read them before reviewing:
+- Do **not** re-flag issues already raised by a prior reviewer (human or
+  Claude). Re-flagging trains authors to ignore Claude reviews.
+- If a prior comment was addressed by a follow-up commit, verify the fix in
+  the diff rather than restating the original concern.
+- If `/pr-review` was invoked in reply to a specific comment thread, focus
+  the review on that thread's concerns instead of re-reviewing the whole PR.
+
+### Step 3: Deep Review
+
+Trace the logic step by step. For each change, consider boundary conditions
+(empty, null, max size, first/last iteration), failure modes (allocation
+failures, exceptions, partial state), concurrency (race conditions, lock
+ordering), and memory safety (ownership, lifetimes, dangling references). Be
+strict — better to flag a potential issue than miss a real bug. The Review
+Areas table below enumerates what to check; do not duplicate it as narrative.
+
+## Review Areas
+
+Analyze each of these areas thoroughly:
+
+| Area | Focus |
+|------|-------|
+| Correctness & Edge Cases | Logic errors, off-by-one, null/empty handling, boundary conditions, integer overflow, floating point edge cases (NaN, Inf, negative zero) |
+| Memory Safety | Use-after-free, double-free, leaks, dangling pointers/references, buffer overflows, ownership/lifetime issues, exception safety |
+| Concurrency | Race conditions, data races, deadlocks, lock ordering, thread-safety of shared state |
+| Performance | Unnecessary copies (move semantics?), inefficient algorithms, cache-unfriendly access, excessive allocations in hot paths |
+| Error Handling | All error paths handled? Exceptions caught appropriately? Informative error messages? Correct use of VELOX_CHECK_* vs VELOX_USER_CHECK_*? |
+| Code Quality | RAII, const-correctness, smart pointers, naming conventions, clear structure |
+| Testing | Sufficient tests? Edge cases covered? Error paths tested? Using gtest matchers? **Bug-fix PRs**: does the diff add a test that would fail without the fix? Flag bug fixes that ship code-only. |
+
+## Output Format
+
+The output should be a markdown-formatted summary and should follow the following markdown format exactly:
+
+```markdown
+### Summary
+Brief overall assessment (1-2 sentences)
+
+### Issues Found
+List any issue, categorized by severity:
+ - 🔴 **Critical**: Must fix before merge
+ - 🟡 **Suggestion**: Should consider
+ - 🟢 **Nitpick**: Minor style issues
+
+Each issue should also include:
+- File and line reference
+- Description of the issue
+- Suggested fix if applicable
+
+### Positive Observations
+Note any particularly good patterns or improvements.
+```
+
+## Inline Comments
+
+Use the `mcp__github_inline_comment__create_inline_comment` tool to post
+comments directly on specific lines in the PR diff. Inline comments should
+be used whenever pointing at the exact line adds clarity beyond the summary
+comment.
+
+**Use inline comments for:**
+- Concrete bugs or incorrect logic
+- Memory safety issues (use-after-free, dangling references, leaks)
+- Off-by-one errors or boundary condition mistakes
+- Incorrect use of VELOX_CHECK_* vs VELOX_USER_CHECK_*
+
+**Do NOT use inline comments for:**
+- Style nitpicks or naming suggestions
+- General architectural feedback
+- Positive observations
+- Anything that applies broadly rather than to a specific line
+
+**Always post a summary comment** with the overall review. Inline comments
+supplement the summary — they do not replace it.
+
+## Key Principles
+
+1. **No repetition** - Each observation appears in exactly one place
+2. **Focus on what CI cannot check** - Don't comment on formatting, linting, or type errors
+3. **Be specific** - Reference file paths and line numbers
+4. **Be actionable** - Provide concrete suggestions, not vague concerns
+5. **Be proportionate** - Minor issues shouldn't block, but note them
+6. **Assume competence** - The author knows C++; explain only non-obvious context
+7. **Permission to be quiet** - If the PR has no meaningful issues, post a
+   short LGTM (one or two sentences) and stop. Do not manufacture nitpicks
+   to fill space — padding trains authors to ignore Claude reviews. A clean
+   PR getting a clean and high-signal review is the correct outcome.
+
+## Files to Reference
+
+When reviewing, consult these project files for context:
+- `CLAUDE.md` - Coding style and project guidelines
+- `CODING_STYLE.md` - Complete coding style guide
diff --git a/.claude/skills/query/SKILL.md b/.claude/skills/query/SKILL.md
new file mode 100644
index 00000000000..35ed47dff51
--- /dev/null
+++ b/.claude/skills/query/SKILL.md
@@ -0,0 +1,24 @@
+---
+name: query
+description: Answer questions about the Velox codebase or pull requests. Use when asked a question via "/query" or when the user wants to understand code, architecture, or implementation details.
+---
+
+# Velox Query Skill
+
+Answer questions about the Velox project codebase or specific pull requests.
+
+## Key Context
+
+- Velox is a C++ execution engine library for analytical data processing
+- Uses C++20 standard with heavy use of templates and SFINAE
+- Custom memory management with MemoryPool
+- Vectorized execution with custom Vector types
+- Follows Google C++ style with some modifications
+
+## Guidelines
+
+- Read CLAUDE.md and CODING_STYLE.md for project-specific conventions
+- Answer thoroughly and accurately
+- If the question is about PR changes, analyze the diff carefully
+- If it's about the codebase, explore relevant files to provide a complete answer
+- Be specific and reference exact file paths and line numbers when relevant
diff --git a/.github/actions/generate-dependency-graph/action.yml b/.github/actions/generate-dependency-graph/action.yml
new file mode 100644
index 00000000000..d3efe53335a
--- /dev/null
+++ b/.github/actions/generate-dependency-graph/action.yml
@@ -0,0 +1,59 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+name: Generate Dependency Graph
+description: >
+  Configure CMake with File API and compile_commands.json, then generate
+  the dependency graph JSON (file_to_targets, header_to_sources, target_deps).
+
+runs:
+  using: composite
+  steps:
+    - name: Fix git permissions
+      shell: bash
+      run: git config --global --add safe.directory ${GITHUB_WORKSPACE}
+
+    - name: Set up File API query
+      shell: bash
+      run: |
+        mkdir -p _build/release/.cmake/api/v1/query
+        echo '{}' > _build/release/.cmake/api/v1/query/codemodel-v2
+
+    - name: CMake configure
+      shell: bash
+      env:
+        MAKEFLAGS: NUM_THREADS=8
+      run: |
+        source /opt/rh/gcc-toolset-14/enable
+        cmake -B _build/release -GNinja \
+          -DCMAKE_EXPORT_COMPILE_COMMANDS=ON \
+          -DVELOX_MONO_LIBRARY=OFF \
+          -DVELOX_ENABLE_BENCHMARKS=ON \
+          -DVELOX_ENABLE_EXAMPLES=ON \
+          -DVELOX_ENABLE_ARROW=ON \
+          -DVELOX_ENABLE_GEO=ON \
+          -DVELOX_ENABLE_PARQUET=ON \
+          -DVELOX_ENABLE_HDFS=ON \
+          -DVELOX_ENABLE_S3=ON \
+          -DVELOX_ENABLE_GCS=ON \
+          -DVELOX_ENABLE_ABFS=ON \
+          -DVELOX_ENABLE_WAVE=ON
+
+    - name: Generate dependency graph
+      shell: bash
+      run: |
+        python3 .github/scripts/generate-dependency-graph.py \
+          --build-dir _build/release \
+          --source-dir . \
+          --output dependency-graph.json
diff --git a/.github/copy-pr-bot.yaml b/.github/copy-pr-bot.yaml
index 895ba83ee54..b28d1fe0a0c 100644
--- a/.github/copy-pr-bot.yaml
+++ b/.github/copy-pr-bot.yaml
@@ -1,3 +1,16 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
 # Configuration file for `copy-pr-bot` GitHub App
 # https://docs.gha-runners.nvidia.com/apps/copy-pr-bot/
 
diff --git a/.github/disabled-workflows/breeze.yml b/.github/disabled-workflows/breeze.yml
index 66eaaa480c1..bc77bc24811 100644
--- a/.github/disabled-workflows/breeze.yml
+++ b/.github/disabled-workflows/breeze.yml
@@ -54,13 +54,13 @@ jobs:
         working-directory: velox
     steps:
 
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
           path: velox
           persist-credentials: false
 
       - name: Install uv
-        uses: astral-sh/setup-uv@4959332f0f014c5280e7eac8b70c90cb574c9f9b # v6.6.0
+        uses: astral-sh/setup-uv@85856786d1ce8acfbcc2f13a5f3fbd6b938f9f41 # v7.1.2
 
       - name: Install Dependencies
         run: |
@@ -88,20 +88,20 @@ jobs:
     if: ${{ github.repository == 'facebookincubator/velox' }}
     name: Ubuntu GPU debug
     env:
-      CUDA_VERSION: '12.8'
+      CUDA_VERSION: '12.9'
     defaults:
       run:
         shell: bash
         working-directory: velox
     steps:
 
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
           path: velox
           persist-credentials: false
 
       - name: Install uv
-        uses: astral-sh/setup-uv@4959332f0f014c5280e7eac8b70c90cb574c9f9b # v6.6.0
+        uses: astral-sh/setup-uv@85856786d1ce8acfbcc2f13a5f3fbd6b938f9f41 # v7.1.2
 
       - name: Install Dependencies
         run: |
diff --git a/.github/disabled-workflows/build-impact-comment.yml b/.github/disabled-workflows/build-impact-comment.yml
new file mode 100644
index 00000000000..a96944ed399
--- /dev/null
+++ b/.github/disabled-workflows/build-impact-comment.yml
@@ -0,0 +1,97 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+name: Build Impact Comment
+
+# zizmor:disable:dangerous-triggers -- only reads an artifact and posts a comment, no PR code execution.
+on:
+  workflow_run:
+    workflows: [Build Impact Analysis]
+    types:
+      - completed
+
+permissions:
+  pull-requests: write
+  issues: write
+  actions: read
+
+jobs:
+  post-comment:
+    if: >
+      github.event.workflow_run.event == 'pull_request' &&
+      github.event.workflow_run.conclusion == 'success'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download comment artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: build-impact-comment
+          github-token: ${{ github.token }}
+          run-id: ${{ github.event.workflow_run.id }}
+
+      - name: Get PR number
+        id: pr
+        env:
+          GH_TOKEN: ${{ github.token }}
+          REPO: ${{ github.repository }}
+          HEAD_OWNER: ${{ github.event.workflow_run.head_repository.owner.login }}
+          HEAD_BRANCH: ${{ github.event.workflow_run.head_branch }}
+        run: |
+          pr_number=$(gh api \
+            "/repos/${REPO}/pulls?head=${HEAD_OWNER}:${HEAD_BRANCH}&state=open" \
+            -q '.[0].number // empty')
+
+          if [ -z "$pr_number" ]; then
+            echo "No open PR found for branch ${HEAD_BRANCH}"
+            exit 0
+          fi
+          echo "number=$pr_number" >> "$GITHUB_OUTPUT"
+
+      - name: Post or update PR comment
+        if: steps.pr.outputs.number
+        uses: actions/github-script@v7
+        env:
+          PR_NUMBER: ${{ steps.pr.outputs.number }}
+        with:
+          script: |
+            const fs = require('fs');
+            const comment = fs.readFileSync('comment.md', 'utf8');
+            const marker = '## Build Impact Analysis';
+            const prNumber = parseInt(process.env.PR_NUMBER, 10);
+
+            const { data: comments } = await github.rest.issues.listComments({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: prNumber,
+            });
+
+            const existing = comments.find(c =>
+              c.user.login === 'github-actions[bot]' && c.body.includes(marker)
+            );
+
+            if (existing) {
+              await github.rest.issues.updateComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                comment_id: existing.id,
+                body: comment,
+              });
+            } else {
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: prNumber,
+                body: comment,
+              });
+            }
diff --git a/.github/disabled-workflows/build-impact.yml b/.github/disabled-workflows/build-impact.yml
new file mode 100644
index 00000000000..65cb5b08ac6
--- /dev/null
+++ b/.github/disabled-workflows/build-impact.yml
@@ -0,0 +1,217 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+name: Build Impact Analysis
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - velox/**
+      - CMakeLists.txt
+      - CMake/**
+      - .github/workflows/build-impact.yml
+      - .github/scripts/generate-dependency-graph.py
+      - .github/scripts/detect-build-impact.py
+
+  pull_request:
+    paths:
+      - velox/**
+      - '!velox/docs/**'
+      - CMakeLists.txt
+      - CMake/**
+      # TODO: Remove after testing comment workflow
+      - .github/**
+
+permissions:
+  contents: read
+  actions: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.repository }}-${{ github.head_ref || github.sha }}
+  cancel-in-progress: true
+
+jobs:
+  # ==========================================================================
+  # Push to main: generate and upload the dependency graph artifact.
+  # ==========================================================================
+  generate-graph:
+    if: github.event_name == 'push'
+    runs-on: 8-core-ubuntu
+    container: ghcr.io/facebookincubator/velox-dev:adapters
+    env:
+      VELOX_DEPENDENCY_SOURCE: SYSTEM
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
+
+      - uses: ./.github/actions/generate-dependency-graph
+
+      - name: Upload dependency graph
+        uses: actions/upload-artifact@v4
+        with:
+          name: dependency-graph
+          path: dependency-graph.json
+          retention-days: 90
+
+  # ==========================================================================
+  # Pull request: check what changed and whether the graph artifact exists.
+  # ==========================================================================
+  check-changes:
+    if: github.event_name == 'pull_request'
+    runs-on: ubuntu-latest
+    outputs:
+      cmake-changed: ${{ steps.check.outputs.cmake_changed }}
+      graph-available: ${{ steps.artifact.outputs.available }}
+      graph-run-id: ${{ steps.artifact.outputs.run_id }}
+      use-slow-path: ${{ steps.decide.outputs.slow }}
+    steps:
+      - name: Get changed files
+        id: check
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          # Use the GitHub API to get the changed files directly.
+          # This avoids issues with fork PRs where HEAD_SHA may not
+          # be available in the local clone.
+          gh api --paginate \
+            "/repos/${{ github.repository }}/pulls/${{ github.event.pull_request.number }}/files" \
+            -q '.[].filename' > changed_files.txt
+          cat changed_files.txt
+
+          # Check if any CMake files changed.
+          if grep -qE '(CMakeLists\.txt|CMake/.+\.cmake)$' changed_files.txt; then
+            echo "cmake_changed=true" >> "$GITHUB_OUTPUT"
+            echo "CMake files changed — slow path needed."
+          else
+            echo "cmake_changed=false" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Check if graph artifact exists
+        id: artifact
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          # Find the latest successful generate-graph run on main.
+          run_id=$(gh api \
+            "/repos/${{ github.repository }}/actions/workflows/build-impact.yml/runs?branch=main&status=success&per_page=5" \
+            -q '.workflow_runs[0].id // empty')
+
+          if [ -z "$run_id" ]; then
+            echo "available=false" >> "$GITHUB_OUTPUT"
+            echo "No graph artifact found — slow path needed."
+          else
+            echo "available=true" >> "$GITHUB_OUTPUT"
+            echo "run_id=$run_id" >> "$GITHUB_OUTPUT"
+            echo "Graph artifact available from run $run_id."
+          fi
+
+      - name: Decide fast or slow path
+        id: decide
+        env:
+          CMAKE_CHANGED: ${{ steps.check.outputs.cmake_changed }}
+          GRAPH_AVAILABLE: ${{ steps.artifact.outputs.available }}
+        run: |
+          if [[ "$CMAKE_CHANGED" == "true" ]] || \
+             [[ "$GRAPH_AVAILABLE" == "false" ]]; then
+            echo "slow=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "slow=false" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Upload changed files list
+        uses: actions/upload-artifact@v4
+        with:
+          name: changed-files
+          path: changed_files.txt
+
+  # ==========================================================================
+  # Fast path: download pre-computed graph, run impact detection.
+  # ==========================================================================
+  fast-detect:
+    needs: check-changes
+    if: needs.check-changes.outputs.use-slow-path == 'false'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
+
+      - name: Download changed files
+        uses: actions/download-artifact@v4
+        with:
+          name: changed-files
+
+      - name: Download dependency graph
+        uses: actions/download-artifact@v4
+        with:
+          name: dependency-graph
+          github-token: ${{ github.token }}
+          repository: ${{ github.repository }}
+          run-id: ${{ needs.check-changes.outputs.graph-run-id }}
+
+      - name: Run impact detection
+        run: |
+          python3 .github/scripts/detect-build-impact.py \
+            --graph dependency-graph.json \
+            --changed-files changed_files.txt \
+            --build-type release \
+            --graph-source "Fast path • Graph from main@${{ github.event.pull_request.base.sha }}" \
+            --output comment.md
+
+      - name: Upload comment
+        uses: actions/upload-artifact@v4
+        with:
+          name: build-impact-comment
+          path: comment.md
+
+  # ==========================================================================
+  # Slow path: generate graph from PR branch, then run impact detection.
+  # ==========================================================================
+  slow-detect:
+    needs: check-changes
+    if: needs.check-changes.outputs.use-slow-path == 'true'
+    runs-on: 8-core-ubuntu
+    container: ghcr.io/facebookincubator/velox-dev:adapters
+    env:
+      VELOX_DEPENDENCY_SOURCE: SYSTEM
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+
+      - name: Download changed files
+        uses: actions/download-artifact@v4
+        with:
+          name: changed-files
+
+      - uses: ./.github/actions/generate-dependency-graph
+
+      - name: Run impact detection
+        run: |
+          python3 .github/scripts/detect-build-impact.py \
+            --graph dependency-graph.json \
+            --changed-files changed_files.txt \
+            --build-type release \
+            --graph-source "Slow path • Graph generated from PR branch" \
+            --output comment.md
+
+      - name: Upload comment
+        uses: actions/upload-artifact@v4
+        with:
+          name: build-impact-comment
+          path: comment.md
diff --git a/.github/disabled-workflows/build-metrics.yml b/.github/disabled-workflows/build-metrics.yml
index 2bf62b4352e..c709b13ae30 100644
--- a/.github/disabled-workflows/build-metrics.yml
+++ b/.github/disabled-workflows/build-metrics.yml
@@ -36,7 +36,10 @@ permissions:
 jobs:
   metrics:
     name: Linux ${{ matrix.link-type }} - ${{ matrix.type }} with adapters
-    if: ${{ github.repository == 'facebookincubator/velox' }}
+    # Disabled: the conbench service at velox-conbench.voltrondata.run is no
+    # longer available (DNS resolution fails). The scheduled runs have been
+    # failing since late 2025. Re-enable once a replacement service is set up.
+    if: false #${{ github.repository == 'facebookincubator/velox' }}
     runs-on: ${{ matrix.runner }}
     container: ghcr.io/facebookincubator/velox-dev:adapters
     strategy:
@@ -49,7 +52,7 @@ jobs:
       run:
         shell: bash
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
           ref: ${{ inputs.ref || github.sha }}
           persist-credentials: false
@@ -101,7 +104,7 @@ jobs:
           cat $sizes_file
           echo "::endgroup::"
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v6
         with:
           path: ${{ env.sizes_file }}
           name: ${{ matrix.type }}-${{ matrix.link-type }}-sizes
@@ -145,7 +148,7 @@ jobs:
     needs: metrics
     steps:
       - name: Checkout
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           fetch-depth: 0
           persist-credentials: true
@@ -174,7 +177,7 @@ jobs:
           nix-shell --run "quarto render report.qmd"
 
       - name: Upload Report Artifact
-        uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882 # v4.4.3
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: report
           path: scripts/ci/bm-report/report.html
diff --git a/.github/disabled-workflows/build_pyvelox.yml b/.github/disabled-workflows/build_pyvelox.yml
index 168e017e802..a37ea7b1af3 100644
--- a/.github/disabled-workflows/build_pyvelox.yml
+++ b/.github/disabled-workflows/build_pyvelox.yml
@@ -50,14 +50,14 @@ jobs:
       matrix:
         os: [8-core-ubuntu, macos-13, macos-14]
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           ref: ${{ inputs.ref || github.ref }}
           fetch-depth: 0
 
           persist-credentials: false
 
-      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+      - uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
         with:
           python-version: '3.10'
 
@@ -115,7 +115,7 @@ jobs:
           uv build --sdist --out-dir wheelhouse
 
       - name: Build wheels
-        uses: pypa/cibuildwheel@5f22145df44122af0f5a201f93cf0207171beca7 # v3.0.0
+        uses: pypa/cibuildwheel@63fd63b352a9a8bdcc24791c9dbee952ee9a8abc # v3.3.0
         env:
           BUILD_VERSION: ${{ inputs.version }}
           CIBW_BUILD: cp310-* cp311-* cp312-* cp313-*
@@ -140,7 +140,7 @@ jobs:
           cd wheelhouse
           rename 's/11_0/10_15/g' *.whl
 
-      - uses: actions/upload-artifact@4cec3d8aa04e39d1a68397de0c4cd6fb9dce8ec1 # v4.6.1
+      - uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: wheels-${{ matrix.os }}
           retention-days: 5
@@ -154,7 +154,7 @@ jobs:
     needs: build_wheels
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+      - uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           pattern: wheels-*
           merge-multiple: true
@@ -162,12 +162,12 @@ jobs:
 
       - run: ls wheelhouse
 
-      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+      - uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
         with:
           python-version: '3.10'
 
       - name: Publish a Python distribution to PyPI
-        uses: pypa/gh-action-pypi-publish@76f52bc884231f62b9a034ebfe128415bbaabdfc # v1.12.4
+        uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # v1.13.0
         with:
           password: ${{ secrets.PYPI_API_TOKEN }}
           packages_dir: wheelhouse
diff --git a/.github/disabled-workflows/ci-failure-comment.yml b/.github/disabled-workflows/ci-failure-comment.yml
new file mode 100644
index 00000000000..3e21114e799
--- /dev/null
+++ b/.github/disabled-workflows/ci-failure-comment.yml
@@ -0,0 +1,187 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+name: CI Failure Comment
+
+# This workflow runs in the context of the base repo (not the fork) and has
+# write access to post PR comments. It is triggered when the Linux Build or
+# Fuzzer Jobs workflow completes with a failure and uses Claude to analyze
+# failure logs, correlate with the PR diff and open issues, and post a rich
+# diagnostic comment.
+#
+# Security: This workflow never checks out or executes PR code. It reads
+# failure metadata from artifacts uploaded by our own status jobs, then uses
+# Claude with read-only gh CLI access to fetch logs and produce comments.
+#
+# zizmor:disable:dangerous-triggers -- only reads artifacts and posts comments, no PR code execution.
+on:
+  workflow_dispatch:
+    inputs:
+      run_id:
+        description: Workflow run ID to analyze (from a failed CI run)
+        required: true
+      pr_number:
+        description: PR number to comment on
+        required: true
+  workflow_run:
+    workflows: [Linux Build using GCC, Fuzzer Jobs]
+    types:
+      - completed
+
+permissions:
+  contents: read
+  pull-requests: write
+  issues: write
+  actions: read
+  id-token: write
+
+jobs:
+  analyze-and-comment:
+    if: >
+      github.repository == 'facebookincubator/velox' &&
+      (github.event_name == 'workflow_dispatch' ||
+       (github.event.workflow_run.event == 'pull_request' &&
+        github.event.workflow_run.conclusion == 'failure'))
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get PR number
+        id: pr
+        env:
+          GH_TOKEN: ${{ github.token }}
+          REPO: ${{ github.repository }}
+          HEAD_OWNER: ${{ github.event.workflow_run.head_repository.owner.login }}
+          HEAD_BRANCH: ${{ github.event.workflow_run.head_branch }}
+          INPUT_PR_NUMBER: ${{ inputs.pr_number }}
+        run: |
+          # For workflow_dispatch, use the provided PR number directly.
+          if [ -n "$INPUT_PR_NUMBER" ]; then
+            echo "number=$INPUT_PR_NUMBER" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+
+          pr_number=$(gh api \
+            "/repos/${REPO}/pulls?head=${HEAD_OWNER}:${HEAD_BRANCH}&state=open" \
+            -q '.[0].number // empty')
+
+          if [ -z "$pr_number" ]; then
+            echo "No open PR found for branch ${HEAD_BRANCH}"
+            exit 0
+          fi
+          echo "number=$pr_number" >> "$GITHUB_OUTPUT"
+
+      - name: Download failure artifacts
+        if: steps.pr.outputs.number
+        uses: actions/download-artifact@v4
+        with:
+          github-token: ${{ github.token }}
+          run-id: ${{ inputs.run_id || github.event.workflow_run.id }}
+          pattern: ci-failure-*
+          path: /tmp/ci-failures
+          merge-multiple: false
+
+      - name: Collect failure metadata
+        if: steps.pr.outputs.number
+        id: metadata
+        env:
+          GH_TOKEN: ${{ github.token }}
+          REPO: ${{ github.repository }}
+          RUN_ID: ${{ inputs.run_id || github.event.workflow_run.id }}
+        run: |
+          FAILURES_DIR="/tmp/ci-failures"
+          if [ -d "$FAILURES_DIR" ] && [ -n "$(ls -A "$FAILURES_DIR" 2>/dev/null)" ]; then
+            # Collect all failure.json contents into a single JSON array.
+            METADATA="["
+            FIRST=true
+            for entry in "$FAILURES_DIR"/ci-failure-*/failure.json; do
+              if [ -f "$entry" ]; then
+                if [ "$FIRST" = true ]; then
+                  FIRST=false
+                else
+                  METADATA="$METADATA,"
+                fi
+                METADATA="$METADATA$(cat "$entry")"
+              fi
+            done
+            METADATA="$METADATA]"
+          else
+            # No failure artifacts — build metadata from failed jobs in the run.
+            # This handles workflows (e.g., Fuzzer Jobs) that don't upload
+            # ci-failure-* artifacts.
+            METADATA=$(gh api "repos/${REPO}/actions/runs/${RUN_ID}/jobs" \
+              --paginate --jq '[.jobs[] | select(.conclusion == "failure") | {job: .name, type: "unknown"}]')
+            if [ "$METADATA" = "[]" ] || [ -z "$METADATA" ]; then
+              echo "No failure artifacts or failed jobs found."
+              echo "has_failures=false" >> "$GITHUB_OUTPUT"
+              exit 0
+            fi
+          fi
+
+          echo "has_failures=true" >> "$GITHUB_OUTPUT"
+          {
+            echo 'failure_metadata<<EOF'
+            echo "$METADATA"
+            echo 'EOF'
+          } >> "$GITHUB_OUTPUT"
+
+      - name: Checkout for Claude context and prompt
+        if: steps.metadata.outputs.has_failures == 'true'
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          sparse-checkout: |
+            CLAUDE.md
+            .claude/CLAUDE.md
+            .claude/skills/ci-failure-analysis/SKILL.md
+          persist-credentials: false
+
+      - name: Prepare analysis prompt
+        if: steps.metadata.outputs.has_failures == 'true'
+        id: prompt
+        env:
+          PR_NUMBER: ${{ steps.pr.outputs.number }}
+          REPOSITORY: ${{ github.repository }}
+          RUN_ID: ${{ inputs.run_id || github.event.workflow_run.id }}
+          FAILURE_METADATA: ${{ steps.metadata.outputs.failure_metadata }}
+        run: |
+          # Read the prompt template and interpolate variables.
+          PROMPT=$(sed \
+            -e "s|{{PR_NUMBER}}|${PR_NUMBER}|g" \
+            -e "s|{{REPOSITORY}}|${REPOSITORY}|g" \
+            -e "s|{{RUN_ID}}|${RUN_ID}|g" \
+            .claude/skills/ci-failure-analysis/SKILL.md)
+
+          # Failure metadata may contain newlines/special chars — use bash
+          # parameter expansion instead of sed to handle multiline content.
+          PROMPT="${PROMPT//\{\{FAILURE_METADATA\}\}/${FAILURE_METADATA}}"
+
+          {
+            echo 'value<<EOF'
+            echo "$PROMPT"
+            echo 'EOF'
+          } >> "$GITHUB_OUTPUT"
+
+      - name: Analyze failures with Claude
+        if: steps.metadata.outputs.has_failures == 'true'
+        uses: izaitsevfb/claude-code-action@ececd56fb999d06b4dd2477437bc408938295d76 # forked-pr-fix
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          github_token: ${{ github.token }}
+          claude_args: --model claude-opus-4-6 --allowedTools Bash Read Grep Glob
+          prompt: ${{ steps.prompt.outputs.value }}
+          # Most Velox PRs are exported from Phabricator and pushed to GitHub
+          # by the meta-codesync bot, so the upstream workflow_run's `actor`
+          # is a Bot. Without this allowlist, claude-code-action refuses to
+          # run for those PRs and the failure analysis is silently dropped.
+          allowed_bots: meta-codesync
+        env:
+          GH_TOKEN: ${{ github.token }}
diff --git a/.github/disabled-workflows/claude-review.yml b/.github/disabled-workflows/claude-review.yml
new file mode 100644
index 00000000000..b34f637369f
--- /dev/null
+++ b/.github/disabled-workflows/claude-review.yml
@@ -0,0 +1,643 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Claude Assistant for PRs
+#
+# This workflow enables Claude-powered interactions on pull requests from forks.
+# Since secrets are not available to workflows triggered by fork PRs (for security),
+# this uses a comment-triggered approach where a maintainer must explicitly request
+# assistance by commenting on the PR.
+#
+# Supported Commands:
+# - /claude-review [additional context] : Perform a thorough code review of the PR.
+#     Optionally provide additional context or instructions after the command.
+#     Example: /claude-review Please focus on memory safety and thread safety.
+# - /claude-query <question> : Ask Claude a question about the PR or codebase
+#
+# Security Model:
+# - Only authorized users can trigger Claude (verified before any code access)
+# - Code is fetched as text only (never executed)
+# - Claude uses read-only tools (no Bash, no file writes)
+# - All operations run in the context of the base repository
+
+name: Claude Assistant
+
+on:
+  issue_comment:
+    types: [created]
+
+  # Manual trigger for testing - can be removed after validation
+  workflow_dispatch:
+    inputs:
+      pr_number:
+        description: PR number to review
+        required: true
+        type: number
+      dry_run:
+        description: Dry run (skip posting comment)
+        required: false
+        type: boolean
+        default: true
+      model:
+        description: Claude model to use
+        required: false
+        type: choice
+        options:
+          - claude-opus-4-6
+          - claude-opus-4-1-20250805
+          - claude-sonnet-4-20250514
+          - claude-4-0-sonnet-20250805
+        default: claude-opus-4-6
+
+# Restrict default permissions
+permissions:
+  contents: read
+
+jobs:
+  claude-assistant:
+    name: Claude Assistant
+    runs-on: ubuntu-latest
+
+    # Job-level permissions - only what's needed for this job
+    permissions:
+      contents: read
+      pull-requests: write
+      issues: write
+
+    # Run if:
+    # A) workflow_dispatch: Manual trigger for testing
+    # B) issue_comment: PR comment with /claude-review or /claude-query from authorized user
+    if: >-
+      github.event_name == 'workflow_dispatch' ||
+      (
+        github.event.issue.pull_request &&
+        (contains(github.event.comment.body, '/claude-review') || contains(github.event.comment.body, '/claude-query')) &&
+        contains(fromJSON('["kgpai", "mbasmanova", "pedroerp", "yuhta", "kagamiori", "bikramSingh91", "kevinwilfong", "xiaoxmeng", "kKPulla", "juwentus1234", "penescu", "srsuryadev", "jainxrohit"]'), github.event.comment.user.login)
+      )
+
+    steps:
+      # Step 1: Acknowledge the request (skip for workflow_dispatch)
+      - name: Add reaction to comment
+        if: github.event_name == 'issue_comment'
+        uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
+        with:
+          script: |
+            await github.rest.reactions.createForIssueComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              comment_id: context.payload.comment.id,
+              content: 'eyes'
+            });
+
+      # Step 2: Detect command type and extract query
+      - name: Detect command type
+        id: command
+        if: github.event_name == 'issue_comment'
+        uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
+        with:
+          script: |
+            const body = context.payload.comment.body;
+
+            if (body.includes('/claude-review')) {
+              core.setOutput('type', 'review');
+              // Extract optional additional context after /claude-review
+              const reviewMatch = body.match(/\/claude-review\s+([\s\S]*)/);
+              const additionalContext = reviewMatch ? reviewMatch[1].trim() : '';
+              core.setOutput('query', additionalContext);
+            } else if (body.includes('/claude-query')) {
+              // Extract everything after /claude-query
+              const match = body.match(/\/claude-query\s+([\s\S]*)/);
+              const query = match ? match[1].trim() : '';
+              if (!query) {
+                core.setFailed('No query provided after /claude-query. Usage: /claude-query <your question>');
+                return;
+              }
+              core.setOutput('type', 'query');
+              core.setOutput('query', query);
+            } else {
+              core.setFailed('Unknown command');
+            }
+
+      # Step 3: Get PR information (set command type for workflow_dispatch)
+      - name: Set command type for workflow_dispatch
+        id: command_dispatch
+        if: github.event_name == 'workflow_dispatch'
+        run: |
+          echo "type=review" >> "$GITHUB_OUTPUT"
+          echo "query=" >> "$GITHUB_OUTPUT"
+
+      # Step 4: Get PR information
+      - name: Get PR details
+        id: pr_info
+        uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
+        env:
+          # Pass input via env to avoid template injection
+          INPUT_PR_NUMBER: ${{ inputs.pr_number }}
+        with:
+          script: |
+            // Get PR number from either issue_comment or workflow_dispatch input
+            const prNumber = context.eventName === 'workflow_dispatch'
+              ? parseInt(process.env.INPUT_PR_NUMBER, 10)
+              : context.issue.number;
+
+            const pr = await github.rest.pulls.get({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              pull_number: prNumber
+            });
+
+            core.setOutput('head_repo', pr.data.head.repo.clone_url);
+            core.setOutput('head_ref', pr.data.head.ref);
+            core.setOutput('head_sha', pr.data.head.sha);
+            core.setOutput('base_sha', pr.data.base.sha);
+            core.setOutput('base_ref', pr.data.base.ref);
+            core.setOutput('pr_title', pr.data.title);
+            core.setOutput('pr_body', pr.data.body || '');
+            core.setOutput('pr_author', pr.data.user.login);
+
+      # Step 3: Checkout base repository (safe - this is our own code)
+      - name: Checkout base repository
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          ref: ${{ steps.pr_info.outputs.base_ref }}
+          fetch-depth: 0
+          persist-credentials: false
+
+      # Step 4: Fetch PR branch and generate diff (read-only, no execution)
+      - name: Generate PR diff
+        id: generate_diff
+        env:
+          HEAD_REPO: ${{ steps.pr_info.outputs.head_repo }}
+          HEAD_REF: ${{ steps.pr_info.outputs.head_ref }}
+          HEAD_SHA: ${{ steps.pr_info.outputs.head_sha }}
+          BASE_SHA: ${{ steps.pr_info.outputs.base_sha }}
+        run: |
+          # Fetch the PR branch from the fork (read-only)
+          git remote add fork "${HEAD_REPO}" || true
+          git fetch fork "${HEAD_REF}" --depth=100
+
+          # Generate the diff as text
+          git diff "${BASE_SHA}...${HEAD_SHA}" > /tmp/pr.diff
+
+          # Get diff stats for context
+          DIFF_STATS=$(git diff --stat "${BASE_SHA}...${HEAD_SHA}" | tail -1)
+          echo "diff_stats=${DIFF_STATS}" >> "$GITHUB_OUTPUT"
+
+          # Check diff size (limit to ~100KB to avoid token limits)
+          DIFF_SIZE=$(wc -c < /tmp/pr.diff)
+          echo "diff_size=${DIFF_SIZE}" >> "$GITHUB_OUTPUT"
+
+          if [ "$DIFF_SIZE" -gt 100000 ]; then
+            echo "⚠️ Diff is large (${DIFF_SIZE} bytes). Review may be truncated."
+            # Truncate to first 100KB
+            head -c 100000 /tmp/pr.diff > /tmp/pr_truncated.diff
+            mv /tmp/pr_truncated.diff /tmp/pr.diff
+            echo "is_truncated=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "is_truncated=false" >> "$GITHUB_OUTPUT"
+          fi
+
+      # Step 7: Create the prompt (review or query)
+      - name: Create review prompt
+        if: steps.command.outputs.type == 'review' || github.event_name == 'workflow_dispatch'
+        env:
+          PR_TITLE: ${{ steps.pr_info.outputs.pr_title }}
+          PR_BODY: ${{ steps.pr_info.outputs.pr_body }}
+          PR_AUTHOR: ${{ steps.pr_info.outputs.pr_author }}
+          DIFF_STATS: ${{ steps.generate_diff.outputs.diff_stats }}
+          IS_TRUNCATED: ${{ steps.generate_diff.outputs.is_truncated }}
+          ADDITIONAL_CONTEXT: ${{ steps.command.outputs.query }}
+        run: |
+          # Create system context first (no variable expansion needed)
+          cat > /tmp/prompt.txt << 'PROMPT_EOF'
+          You are an expert C++ code reviewer for the Velox project. Your role is to perform
+          a thorough, rigorous code review that catches issues before they reach production.
+
+          **IMPORTANT**: First, read the CLAUDE.md file in the repository root. It contains:
+          - Project overview and architecture
+          - Build commands and environment setup
+          - Code style and naming conventions
+          - PR title format requirements
+          - Testing guidelines
+          - Function addition requirements
+
+          Use CLAUDE.md as your primary reference for project-specific standards.
+
+          Key things to know about Velox:
+          - Uses C++20 standard
+          - Heavy use of templates and SFINAE
+          - Custom memory management with MemoryPool
+          - Vectorized execution with custom Vector types
+          - Follows Google C++ style with some modifications
+
+          ## Review Approach
+
+          **Think deeply and carefully about this code.** Take your time to:
+          - Trace through the logic step by step
+          - Consider what happens at boundary conditions (empty inputs, null values, max sizes)
+          - Think about concurrency issues if multiple threads could access this code
+          - Consider memory safety: ownership, lifetimes, dangling references
+          - Look for off-by-one errors, integer overflow, and other subtle bugs
+          - Examine error handling paths - what happens when things fail?
+          - Consider how this code interacts with existing code in the codebase
+
+          **Be thorough and strict.** This is a high-performance database engine where bugs can
+          cause data corruption, crashes, or security vulnerabilities. It's better to flag a
+          potential issue that turns out to be fine than to miss a real bug.
+
+          **Explore edge cases exhaustively:**
+          - What if the input is empty? Null? Maximum size?
+          - What if allocation fails? What if an exception is thrown?
+          - What happens on the first iteration? The last iteration?
+          - Are there race conditions if called concurrently?
+          - What assumptions does this code make? Are they documented and validated?
+
+          Provide actionable, specific feedback. Reference exact file paths and line numbers.
+          Be constructive and educational in your feedback.
+          If the diff looks good after thorough analysis, say so - but only after genuinely
+          examining edge cases and potential issues.
+
+          ---
+
+          PROMPT_EOF
+
+          # Note: Using unquoted PROMPT_EOF to enable variable expansion
+          cat >> /tmp/prompt.txt << PROMPT_EOF
+          Please review the following pull request for the Velox project.
+
+          ## Pull Request Information
+          - **Title:** ${PR_TITLE}
+          - **Author:** ${PR_AUTHOR}
+          - **Changes:** ${DIFF_STATS}
+          PROMPT_EOF
+
+          if [ "${IS_TRUNCATED}" = "true" ]; then
+            echo "- **Note:** This diff was truncated due to size. Focus on the visible changes." >> /tmp/prompt.txt
+          fi
+
+          # Using quoted 'PROMPT_EOF' here since this section has no variables to expand
+          cat >> /tmp/prompt.txt << 'PROMPT_EOF'
+
+          ## PR Description
+          PROMPT_EOF
+
+          # PR body may contain special characters, write it safely
+          printf '%s\n' "${PR_BODY}" >> /tmp/prompt.txt
+
+          # Add additional context/instructions if provided via /claude-review <context>
+          if [ -n "${ADDITIONAL_CONTEXT}" ]; then
+            cat >> /tmp/prompt.txt << 'PROMPT_EOF'
+
+          ## Additional Instructions from Reviewer
+
+          PROMPT_EOF
+            printf '%s\n' "${ADDITIONAL_CONTEXT}" >> /tmp/prompt.txt
+          fi
+
+          cat >> /tmp/prompt.txt << 'PROMPT_EOF'
+
+          ## Review Guidelines
+
+          Velox is a C++ execution engine library for analytical data processing. This is
+          performance-critical code that must be correct, efficient, and robust.
+
+          **Analyze each of these areas thoroughly:**
+
+          1. **Correctness & Edge Cases**
+             - Logic errors, off-by-one bugs, incorrect conditions
+             - Null/empty input handling
+             - Boundary conditions (first element, last element, single element, max size)
+             - Integer overflow/underflow
+             - Floating point edge cases (NaN, Inf, negative zero)
+
+          2. **Memory Safety**
+             - Use-after-free, double-free, memory leaks
+             - Dangling pointers/references
+             - Buffer overflows/underflows
+             - Ownership and lifetime issues
+             - Exception safety (what happens if an exception is thrown mid-operation?)
+
+          3. **Concurrency**
+             - Race conditions, data races
+             - Deadlocks, lock ordering
+             - Thread-safety of shared state
+
+          4. **Performance**
+             - Unnecessary copies (should use move semantics?)
+             - Inefficient algorithms (O(n²) when O(n) is possible?)
+             - Cache-unfriendly access patterns
+             - Excessive allocations in hot paths
+
+          5. **Error Handling**
+             - Are all error paths handled?
+             - Are exceptions caught appropriately?
+             - Are error messages informative?
+
+          6. **Code Quality**
+             - RAII, const-correctness, proper use of smart pointers
+             - Following Velox naming conventions (PascalCase for types, camelCase for functions)
+             - Clear, maintainable code structure
+
+          7. **Testing**
+             - Are there sufficient tests for the new/changed code?
+             - Are edge cases covered in tests?
+             - Are error paths tested?
+
+          ## Format Your Review As
+
+          ### Summary
+          Brief overall assessment (1-2 sentences)
+
+          ### Issues Found
+          List any problems, categorized by severity:
+          - 🔴 **Critical**: Must fix before merge
+          - 🟡 **Suggestion**: Should consider
+          - 🟢 **Nitpick**: Minor style issues
+
+          For each issue, include:
+          - File and line reference
+          - Description of the issue
+          - Suggested fix if applicable
+
+          ### Positive Observations
+          Note any particularly good patterns or improvements.
+
+          ---
+
+          ## Diff to Review
+
+          PROMPT_EOF
+
+          cat /tmp/pr.diff >> /tmp/prompt.txt
+
+      # Step 8: Create query prompt (for /claude-query)
+      - name: Create query prompt
+        if: steps.command.outputs.type == 'query'
+        env:
+          PR_TITLE: ${{ steps.pr_info.outputs.pr_title }}
+          PR_BODY: ${{ steps.pr_info.outputs.pr_body }}
+          PR_AUTHOR: ${{ steps.pr_info.outputs.pr_author }}
+          DIFF_STATS: ${{ steps.generate_diff.outputs.diff_stats }}
+          USER_QUERY: ${{ steps.command.outputs.query }}
+        run: |
+          cat > /tmp/prompt.txt << 'PROMPT_EOF'
+          You are an expert C++ engineer helping with questions about the Velox project.
+
+          **IMPORTANT**: First, read the CLAUDE.md file in the repository root for project context.
+
+          Key things to know about Velox:
+          - Velox is a C++ execution engine library for analytical data processing
+          - Uses C++20 standard with heavy use of templates and SFINAE
+          - Custom memory management with MemoryPool
+          - Vectorized execution with custom Vector types
+          - Follows Google C++ style with some modifications
+
+          You have access to:
+          - The PR diff (changes being proposed)
+          - The full codebase via View, GlobTool, and GrepTool
+          - The CLAUDE.md file with project guidelines
+
+          Answer the user's question thoroughly and accurately. If the question is about
+          the PR changes, analyze them carefully. If it's about the codebase, explore
+          relevant files to provide a complete answer.
+
+          Be specific and reference exact file paths and line numbers when relevant.
+
+          ---
+
+          PROMPT_EOF
+
+          cat >> /tmp/prompt.txt << PROMPT_EOF
+          ## Pull Request Context
+          - **Title:** ${PR_TITLE}
+          - **Author:** ${PR_AUTHOR}
+          - **Changes:** ${DIFF_STATS}
+
+          ## PR Description
+          PROMPT_EOF
+
+          printf '%s\n' "${PR_BODY}" >> /tmp/prompt.txt
+
+          cat >> /tmp/prompt.txt << 'PROMPT_EOF'
+
+          ## User Question
+
+          PROMPT_EOF
+
+          printf '%s\n' "${USER_QUERY}" >> /tmp/prompt.txt
+
+          cat >> /tmp/prompt.txt << 'PROMPT_EOF'
+
+          ---
+
+          ## PR Diff (for reference)
+
+          PROMPT_EOF
+
+          cat /tmp/pr.diff >> /tmp/prompt.txt
+
+      # Step 9: Run Claude
+      - name: Run Claude
+        id: claude_review
+        uses: anthropics/claude-code-base-action@e8132bc5e637a42c27763fc757faa37e1ee43b34 # beta
+        env:
+          CLAUDE_MODEL: ${{ github.event_name == 'workflow_dispatch' && inputs.model || 'claude-opus-4-6' }}
+        with:
+          prompt_file: /tmp/prompt.txt
+          # Use configurable model for thorough analysis, with read-only tools
+          claude_args: >-
+            --model ${{ github.event_name == 'workflow_dispatch' && inputs.model || 'claude-opus-4-6' }}
+            --max-turns 25
+            --allowedTools View,GlobTool,GrepTool
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+
+      # Step 7: Save execution log as artifact for debugging
+      - name: Upload execution log
+        if: always()
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: claude-execution-log-${{ github.event_name == 'workflow_dispatch' && inputs.pr_number || github.event.issue.number }}
+          path: ${{ steps.claude_review.outputs.execution_file }}
+          retention-days: 7
+          if-no-files-found: warn
+
+      # Step 11: Post response as PR comment (skip if dry_run)
+      - name: Post Claude response
+        if: ${{ !(github.event_name == 'workflow_dispatch' && inputs.dry_run) }}
+        uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
+        env:
+          EXECUTION_FILE: ${{ steps.claude_review.outputs.execution_file }}
+          CONCLUSION: ${{ steps.claude_review.outputs.conclusion }}
+          REVIEWER: ${{ github.event_name == 'workflow_dispatch' && github.actor || github.event.comment.user.login }}
+          PR_NUMBER: ${{ github.event_name == 'workflow_dispatch' && inputs.pr_number || github.event.issue.number }}
+          COMMAND_TYPE: ${{ steps.command.outputs.type || 'review' }}
+        with:
+          script: |
+            const fs = require('fs');
+
+            let responseBody = '';
+            const commandType = process.env.COMMAND_TYPE;
+            const isReview = commandType === 'review';
+
+            try {
+              // Read the execution log (array of messages from claude-code-base-action)
+              const executionLog = JSON.parse(fs.readFileSync(process.env.EXECUTION_FILE, 'utf8'));
+
+              if (!Array.isArray(executionLog)) {
+                throw new Error('Expected array format from claude-code-base-action');
+              }
+
+              // Find the "result" message which contains the final response
+              const resultMessage = executionLog.find(m => m.type === 'result');
+
+              if (!resultMessage) {
+                responseBody = '⚠️ No result message found in execution log.';
+              } else if (resultMessage.subtype === 'success' && resultMessage.result) {
+                responseBody = resultMessage.result;
+              } else if (resultMessage.is_error || resultMessage.subtype === 'error') {
+                const errorInfo = resultMessage.result || resultMessage.error || 'Unknown error';
+                responseBody = `❌ **Claude encountered an error:**\n\n${errorInfo}`;
+              } else if (resultMessage.result) {
+                responseBody = `⚠️ **Completed with status: ${resultMessage.subtype}**\n\n${resultMessage.result}`;
+              } else {
+                responseBody = '⚠️ Claude completed but produced no output.';
+              }
+            } catch (error) {
+              console.error('Error parsing execution log:', error);
+              responseBody = '❌ Error parsing Claude response. Please check the workflow logs.';
+            }
+
+            // Add header and footer based on command type
+            const conclusion = process.env.CONCLUSION === 'success' ? '✅' : '⚠️';
+            const headerTitle = isReview ? 'Claude Code Review' : 'Claude Response';
+            const aboutText = isReview
+              ? 'This review was generated by [Claude Code](https://github.com/anthropics/claude-code-action). It analyzed the PR diff and codebase to provide feedback.'
+              : 'This response was generated by [Claude Code](https://github.com/anthropics/claude-code-action). It analyzed the PR and codebase to answer your question.';
+
+            const fullComment = `## ${conclusion} ${headerTitle}
+
+            *Requested by @${process.env.REVIEWER}*
+
+            ---
+
+            ${responseBody}
+
+            ---
+
+            <details>
+            <summary>ℹ️ About this response</summary>
+
+            ${aboutText}
+
+            **Limitations:**
+            - Claude may miss context from files not in the diff
+            - Large PRs may be truncated
+            - Always apply human judgment to AI suggestions
+
+            **Available commands:**
+            - \`/claude-review [additional context]\` - Request a code review. Optionally provide additional instructions (e.g., \`/claude-review Please focus on memory safety\`)
+            - \`/claude-query <question>\` - Ask a question about the PR or codebase
+            </details>`;
+
+            await github.rest.issues.createComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: parseInt(process.env.PR_NUMBER),
+              body: fullComment
+            });
+
+      # Step 8b: Print review to logs if dry_run
+      - name: Print review to logs (dry run)
+        if: ${{ github.event_name == 'workflow_dispatch' && inputs.dry_run }}
+        env:
+          EXECUTION_FILE: ${{ steps.claude_review.outputs.execution_file }}
+        run: |
+          echo "=== DRY RUN - Review would be posted as comment ==="
+          echo ""
+          echo "=== Extracting review from result message ==="
+          # Find the "result" message and extract based on subtype
+          RESULT_MSG=$(jq '[.[] | select(.type == "result")] | .[0]' "$EXECUTION_FILE" 2>/dev/null)
+          if [ "$RESULT_MSG" = "null" ] || [ -z "$RESULT_MSG" ]; then
+            echo "⚠️ No result message found"
+          else
+            SUBTYPE=$(echo "$RESULT_MSG" | jq -r '.subtype // "unknown"')
+            echo "Status: $SUBTYPE"
+            echo ""
+            if [ "$SUBTYPE" = "success" ]; then
+              echo "$RESULT_MSG" | jq -r '.result // "No result field"'
+            elif [ "$SUBTYPE" = "error" ]; then
+              echo "❌ Error:"
+              echo "$RESULT_MSG" | jq -r '.result // .error // "Unknown error"'
+            else
+              echo "⚠️ Status: $SUBTYPE"
+              echo "$RESULT_MSG" | jq -r '.result // "No result"'
+            fi
+          fi
+          echo ""
+          echo "=== End of review ==="
+
+      # Step 9: Update reaction on completion (only for issue_comment trigger)
+      - name: Update reaction on success
+        if: success() && github.event_name == 'issue_comment'
+        uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
+        with:
+          script: |
+            await github.rest.reactions.createForIssueComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              comment_id: context.payload.comment.id,
+              content: 'rocket'
+            });
+
+      - name: Update reaction on failure
+        if: failure() && github.event_name == 'issue_comment'
+        uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
+        with:
+          script: |
+            await github.rest.reactions.createForIssueComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              comment_id: context.payload.comment.id,
+              content: 'confused'
+            });
+
+  # Job to handle unauthorized users attempting to trigger Claude (issue_comment only)
+  unauthorized-notice:
+    name: Unauthorized Notice
+    runs-on: ubuntu-latest
+
+    # Job-level permissions
+    permissions:
+      issues: write
+      pull-requests: write
+
+    if: >-
+      github.event_name == 'issue_comment' &&
+      github.event.issue.pull_request &&
+      (contains(github.event.comment.body, '/claude-review') || contains(github.event.comment.body, '/claude-query')) &&
+      !contains(fromJSON('["kgpai", "mbasmanova", "pedroerp", "yuhta", "kagamiori", "bikramSingh91", "kevinwilfong", "xiaoxmeng", "kKPulla", "juwentus1234", "penescu", "srsuryadev", "jainxrohit"]'), github.event.comment.user.login)
+
+    steps:
+      - name: Post unauthorized notice
+        uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
+        with:
+          script: |
+            await github.rest.issues.createComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.issue.number,
+              body: `👋 @${context.payload.comment.user.login}, the \`/claude-review\` and \`/claude-query\` commands are currently restricted to a small group of users during this initial rollout.
+
+            If you'd like a Claude review, please ask a maintainer to run this command.`
+            });
diff --git a/.github/disabled-workflows/claude.yml b/.github/disabled-workflows/claude.yml
new file mode 100644
index 00000000000..2b7b2cb31a5
--- /dev/null
+++ b/.github/disabled-workflows/claude.yml
@@ -0,0 +1,198 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Claude — skill-based PR assistant (replaces claude-review.yml)
+#
+# This workflow uses izaitsevfb/claude-code-action (a fork that fixes
+# forked-PR handling) with Claude Skills instead of inline prompts.
+# Review logic lives in .claude/skills/pr-review/SKILL.md.
+#
+# Supported commands (comment on a PR):
+#   @claude /pr-review [context] — thorough code review
+#   @claude /query <question> — ask about the PR or codebase
+#
+# Differences from claude-review.yml (the legacy workflow):
+#   - Uses claude-code-action (higher-level) instead of claude-code-base-action
+#   - Review/query instructions are in Skills, not inline heredocs
+#   - Trigger phrase is @claude (not /claude-review or /claude-query)
+#   - Tag mode handles PR context, diff, and comment posting automatically
+#
+# Security model:
+#   - Hardcoded user allowlist gates workflow execution
+#   - Read-only tools enforced via --allowedTools
+#   - Fork PRs handled securely by the action fork
+
+name: Claude
+
+on:
+  # Tag mode: action detects @claude in comments and responds inline
+  issue_comment:
+    types: [created]
+
+  # Agent mode: manual trigger for testing (log-only when dry_run is true)
+  workflow_dispatch:
+    inputs:
+      pr_number:
+        description: PR number to review
+        required: true
+        type: number
+      model:
+        description: Claude model to use
+        required: false
+        type: choice
+        options:
+          - claude-opus-4-6
+          - claude-opus-4-1-20250805
+          - claude-sonnet-4-20250514
+          - claude-4-0-sonnet-20250805
+        default: claude-opus-4-6
+      additional_context:
+        description: Additional instructions for the review (e.g. focus on memory safety)
+        required: false
+        type: string
+        default: ''
+      dry_run:
+        description: Log review output only — do not post a comment on the PR
+        required: false
+        type: boolean
+        default: false
+
+# Restrict default permissions — jobs declare only what they need
+permissions:
+  contents: read
+
+jobs:
+  claude-assistant:
+    name: Claude Assistant
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+      issues: write
+      actions: read
+      id-token: write
+    # Gate: workflow_dispatch always runs; issue_comment requires PR context,
+    # @claude mention, and an authorized user
+    if: >-
+      github.event_name == 'workflow_dispatch' ||
+      (
+        github.event_name == 'issue_comment' &&
+        github.event.issue.pull_request &&
+        contains(github.event.comment.body, '@claude') &&
+        contains(fromJSON('["kgpai", "mbasmanova", "pedroerp", "yuhta", "kagamiori", "bikramSingh91", "kevinwilfong", "xiaoxmeng", "kKPulla", "juwentus1234", "penescu", "srsuryadev", "jainxrohit", "pratikpugalia"]'), github.event.comment.user.login)
+      )
+
+    steps:
+      # For workflow_dispatch, checkout the PR merge ref so Claude has the
+      # PR code. For issue_comment, default ref is fine — the action handles
+      # diff fetching internally.
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          fetch-depth: 1
+          ref: ${{ github.event_name == 'workflow_dispatch' && format('refs/pull/{0}/merge', inputs.pr_number) || '' }}
+          persist-credentials: false
+
+      # Build prompt and claude_args in bash to avoid format() curly-brace
+      # issues with user-supplied additional_context, and to keep the logic
+      # readable. Outputs are only set for workflow_dispatch; for
+      # issue_comment (tag mode), prompt stays empty so the action uses
+      # tag mode and CLAUDE.md provides skill routing.
+      - name: Build prompt and args
+        id: config
+        if: github.event_name == 'workflow_dispatch'
+        env:
+          INPUT_PR_NUMBER: ${{ inputs.pr_number }}
+          INPUT_MODEL: ${{ inputs.model }}
+          INPUT_DRY_RUN: ${{ inputs.dry_run }}
+          INPUT_ADDITIONAL_CONTEXT: ${{ inputs.additional_context }}
+        run: |
+          # --- Prompt ---
+          PROMPT="Review the PR currently checked out in the Velox project current workspace. Use the /pr-review skill."
+
+          if [ "$INPUT_DRY_RUN" = "true" ]; then
+            PROMPT="$PROMPT Output the review to the workflow log only. Do NOT post any comments on the PR."
+          else
+            PROMPT="$PROMPT Post the final output as a comment on the original PR ${INPUT_PR_NUMBER}."
+          fi
+
+          if [ -n "$INPUT_ADDITIONAL_CONTEXT" ]; then
+            PROMPT="$PROMPT Additional reviewer instructions: ${INPUT_ADDITIONAL_CONTEXT}"
+          fi
+
+          # Write multi-line safe output
+          {
+            echo "prompt<<PROMPT_EOF"
+            echo "$PROMPT"
+            echo "PROMPT_EOF"
+          } >> "$GITHUB_OUTPUT"
+
+          # --- Allowed tools ---
+          TOOLS="Skill"
+
+          # Comment-posting tools only when NOT dry_run
+          if [ "$INPUT_DRY_RUN" != "true" ]; then
+            TOOLS="$TOOLS,Bash(gh pr comment:*)"
+            TOOLS="$TOOLS,mcp__github_inline_comment__create_inline_comment"
+          fi
+
+          # Read-only PR tools (always available for workflow_dispatch)
+          TOOLS="$TOOLS,Bash(gh pr diff:*),Bash(gh pr view:*)"
+
+          # Codebase exploration tools
+          TOOLS="$TOOLS,Read,Glob,Grep"
+
+          ARGS="--model ${INPUT_MODEL:-claude-opus-4-6} --allowedTools ${TOOLS}"
+          echo "claude_args=$ARGS" >> "$GITHUB_OUTPUT"
+
+      - name: Run Claude Code
+        uses: izaitsevfb/claude-code-action@ececd56fb999d06b4dd2477437bc408938295d76 # forked-pr-fix
+        with:
+          trigger_phrase: "@claude"
+          # prompt is only set for workflow_dispatch (agent mode).
+          # For issue_comment (tag mode), prompt must be empty so the action
+          # uses tag mode; CLAUDE.md provides skill routing instead.
+          prompt: ${{ steps.config.outputs.prompt || '' }}
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          # Tool access (workflow_dispatch uses computed args from setup step):
+          #   - Skill: invoke /pr-review and /query skills
+          #   - Read,Glob,Grep: codebase exploration (used by skills)
+          #   - mcp__github_inline_comment: post inline comments (excluded in dry_run)
+          #   - Bash(gh pr comment/diff/view): gh CLI for PR data (comment excluded in dry_run)
+          claude_args: ${{ steps.config.outputs.claude_args || '--model claude-opus-4-6 --allowedTools Skill,mcp__github_inline_comment__create_inline_comment,Read,Glob,Grep' }}
+          settings: '{"alwaysThinkingEnabled": true}'
+
+  # Notify unauthorized users who try to invoke @claude
+  unauthorized-notice:
+    name: Unauthorized Notice
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
+    if: >-
+      github.event_name == 'issue_comment' &&
+      github.event.issue.pull_request &&
+      contains(github.event.comment.body, '@claude') &&
+      !contains(fromJSON('["kgpai", "mbasmanova", "pedroerp", "yuhta", "kagamiori", "bikramSingh91", "kevinwilfong", "xiaoxmeng", "kKPulla", "juwentus1234", "penescu", "srsuryadev", "jainxrohit", "pratikpugalia"]'), github.event.comment.user.login)
+
+    steps:
+      - name: Post unauthorized notice
+        uses: actions/github-script@v7
+        with:
+          script: |
+            await github.rest.issues.createComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.issue.number,
+              body: `👋 @${context.payload.comment.user.login}, \`@claude\` commands are currently restricted to a small group of users during this initial rollout.\n\nIf you'd like a Claude review, please ask a maintainer to run this command.`
+            });
diff --git a/.github/disabled-workflows/docker.yml b/.github/disabled-workflows/docker.yml
index b01751579c0..00a3da83f1f 100644
--- a/.github/disabled-workflows/docker.yml
+++ b/.github/disabled-workflows/docker.yml
@@ -37,6 +37,7 @@ permissions:
 
 env:
   BASE_NAME: ghcr.io/facebookincubator
+  DOCKER_UPLOAD_CACHE: ${{ github.repository == 'facebookincubator/velox' && github.event_name != 'pull_request'}}
 
 jobs:
   multi-arch-base:
@@ -55,16 +56,56 @@ jobs:
     steps:
       - name: Free Disk Space
         run: |
-          # 15G
-          sudo rm -rf /usr/local/lib/android || :
-          # 5.3GB
-          sudo rm -rf /opt/hostedtoolcache/CodeQL || :
+          # Re-used from free-disk-space github action.
+          getAvailableSpace() { echo $(df -a $1 | awk 'NR > 1 {avail+=$4} END {print avail}'); }
+          # Show before
+          echo "Original available disk space: " $(getAvailableSpace)
+          # Remove DotNet.
+          sudo rm -rf /usr/share/dotnet || true
+          # Remove android
+          sudo rm -rf /usr/local/lib/android || true
+          # Remove CodeQL
+          sudo rm -rf /opt/hostedtoolcache/CodeQL || true
+          # Remove Haskell
+          sudo rm -rf /opt/ghc || true
+          sudo rm -rf /usr/local/.ghcup || true
+          # Remove Powershell
+          sudo rm -rf /usr/local/share/powershell || true
+          # Remove Node
+          sudo rm -rf /usr/local/lib/node_modules || true
+          # Remove Go
+          sudo rm -rf /opt/hostedtoolcache/go || true
+          # Remove PyPy
+          sudo rm -rf /opt/hostedtoolcache/PyPy || true
+          # Remove chromium
+          sudo rm -rf /usr/local/share/chromium || true
+          # Remove azure
+          sudo rm -rf /opt/az || true
+          # Remove miscellaneous
+          sudo rm -rf \
+            /usr/local/bin/aliyun \
+            /usr/local/bin/azcopy \
+            /usr/local/bin/bicep \
+            /usr/local/bin/cmake-gui \
+            /usr/local/bin/cpack \
+            /usr/local/bin/helm \
+            /usr/local/bin/hub \
+            /usr/local/bin/kubectl \
+            /usr/local/bin/minikube \
+            /usr/local/bin/node \
+            /usr/local/bin/packer \
+            /usr/local/bin/pulumi* \
+            /usr/local/bin/sam \
+            /usr/local/bin/stack \
+            /usr/local/bin/terraform || true
+          # Show after
+          echo "New available disk space: " $(getAvailableSpace)
 
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@e468171a9de216ec08956ac3ada2f0791b6bd435 # v3.11.1
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@184bdaa0721073962dff0199f1fb9940f07167d1 # v3.5.0
+        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
@@ -73,8 +114,6 @@ jobs:
       - name: Bake Images
         id: bake
         uses: docker/bake-action@3acf805d94d93a86cce4ca44798a76464a75b88c # v6.9.0
-        env:
-          DOCKER_UPLOAD_CACHE: ${{ github.repository == 'facebookincubator/velox' && github.event_name != 'pull_request'}}
         with:
           targets: ${{ matrix.target }}-${{ matrix.os.platform }}
           push: ${{ github.repository == 'facebookincubator/velox' && github.event_name != 'pull_request'}}
@@ -92,7 +131,7 @@ jobs:
 
       - name: Upload Base Image
         if: ${{ github.event_name == 'pull_request' && matrix.target == 'ci' && matrix.os.platform == 'amd64' }}
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           path: centos9.tar
           name: centos9-amd64
@@ -108,7 +147,8 @@ jobs:
           # Add the target for any images that shouldn't be build as multi-platform
           # into the skip list
           echo "$METADATA" | jq -r 'def skip: ["ubuntu", "fedora"];
-            . | to_entries[] | .key | split("-")[0] |
+            . | to_entries[] | select(.value | has("image.name")) |
+            .key | split("-")[0] |
             if . as $name | skip | index($name) != null then empty else . end' | \
             while read -r image_name; do
               touch "$image_name"
@@ -116,7 +156,7 @@ jobs:
           ls -la
 
       - name: Upload digest
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: digests-${{ matrix.target }}-${{ matrix.os.platform }}
           path: ${{ runner.temp }}/digests/*
@@ -130,14 +170,14 @@ jobs:
       packages: write
     steps:
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@184bdaa0721073962dff0199f1fb9940f07167d1 # v3.5.0
+        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Download digests
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           path: ${{ runner.temp }}/digests
           pattern: digests-*
@@ -168,7 +208,7 @@ jobs:
         target: [java]
     steps:
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@184bdaa0721073962dff0199f1fb9940f07167d1 # v3.5.0
+        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
@@ -182,7 +222,7 @@ jobs:
 
       - name: Download Base Image
         if: ${{ github.event_name == 'pull_request' }}
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           pattern: centos9-amd64
           path: /tmp
diff --git a/.github/disabled-workflows/docs.yml b/.github/disabled-workflows/docs.yml
index 523fda54dcf..dd4156c1d9a 100644
--- a/.github/disabled-workflows/docs.yml
+++ b/.github/disabled-workflows/docs.yml
@@ -35,7 +35,7 @@ concurrency:
 jobs:
   build_docs:
     name: Build and Push
-    runs-on: 8-core-ubuntu
+    runs-on: 16-core-ubuntu
     container: ghcr.io/facebookincubator/velox-dev:centos9
     env:
       CCACHE_DIR: /tmp/ccache
@@ -48,14 +48,17 @@ jobs:
         id: restore-cache
         with:
           path: ${{ env.CCACHE_DIR }}
-          key: ccache-docs-8-core-ubuntu
+          key: ccache-docs-16-core-ubuntu
 
       - name: Checkout
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           fetch-depth: 0
           persist-credentials: true
 
+      - name: Configure git safe directory
+        run: git config --global --add safe.directory ${GITHUB_WORKSPACE}
+
       - name: Install System Dependencies
         run: |
           dnf install -y --setopt=install_weak_deps=False pandoc
@@ -63,10 +66,53 @@ jobs:
       - name: CCache Stats Before
         run: ccache -sz
 
+      - name: Install uv
+        run: |
+          pip install --upgrade uv
+          uv --version
+
+      - name: Check for pyvelox changes
+        id: check-pyvelox
+        run: |
+          if [ "${{ github.event_name }}" = "pull_request" ]; then
+            CHANGED=$(git diff --name-only ${{ github.event.pull_request.base.sha }}..HEAD)
+          else
+            CHANGED=$(git diff --name-only HEAD~1..HEAD)
+          fi
+          if echo "$CHANGED" | grep -qE '^(python/|velox/python/)'; then
+            echo "Building pyvelox: python/ files changed."
+            echo "changed=true" >> $GITHUB_OUTPUT
+          else
+            echo "Skipping pyvelox build: no python/ files changed."
+            echo "changed=false" >> $GITHUB_OUTPUT
+          fi
+
       - name: Install Python Dependencies
+        timeout-minutes: 30
+        env:
+          PYVELOX_CHANGED: ${{ steps.check-pyvelox.outputs.changed }}
         run: |
-          # Install pyvelox to generate it's docs
-          uv sync --extra docs
+          # When python/ files haven't changed, skip building pyvelox
+          # from C++ source (slow) and only install doc dependencies.
+          EXTRA_FLAGS=""
+          if [ "$PYVELOX_CHANGED" != "true" ]; then
+            echo "Skipping pyvelox C++ build (no changes in python/)."
+            EXTRA_FLAGS="--no-install-project"
+          fi
+          # Retry up to 3 times to handle transient network issues
+          # (pip/uv hangs, registry timeouts).
+          for attempt in 1 2 3; do
+            echo "Attempt $attempt of 3..."
+            if uv sync --extra docs $EXTRA_FLAGS --verbose; then
+              echo "Python dependencies installed successfully."
+              exit 0
+            fi
+            echo "Attempt $attempt failed. Cleaning up and retrying in 10 seconds..."
+            rm -rf .venv uv.lock
+            sleep 10
+          done
+          echo "All 3 attempts failed."
+          exit 1
 
       - name: CCache Stats After
         run: ccache -s
@@ -75,7 +121,7 @@ jobs:
         uses: apache/infrastructure-actions/stash/save@3354c1565d4b0e335b78a76aedd82153a9e144d4
         with:
           path: ${{ env.CCACHE_DIR }}
-          key: ccache-docs-8-core-ubuntu
+          key: ccache-docs-16-core-ubuntu
 
       - name: Build Documentation
         run: |
@@ -92,7 +138,6 @@ jobs:
         run: |
           git config --global user.email "velox@users.noreply.github.com"
           git config --global user.name "velox"
-          git config --global --add safe.directory ${GITHUB_WORKSPACE}
 
       - name: Push Documentation
         if: ${{ github.event_name == 'push' && github.repository == 'facebookincubator/velox'}}
@@ -109,7 +154,7 @@ jobs:
 
       - name: Upload Documentation
         if: github.event_name == 'pull_request'
-        uses: actions/upload-artifact@5d5d22a31266ced268874388b861e4b58bb5c2f3 # v4.3.1
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           path: velox/docs/_build/html
           retention-days: 3
diff --git a/.github/disabled-workflows/linux-build-base.yml b/.github/disabled-workflows/linux-build-base.yml
index 2f08b94319c..34b800dd398 100644
--- a/.github/disabled-workflows/linux-build-base.yml
+++ b/.github/disabled-workflows/linux-build-base.yml
@@ -24,11 +24,63 @@ on:
         type: boolean
 
 jobs:
+
+  get-changes:
+    runs-on: ubuntu-latest
+    outputs:
+      run-clang-tidy: ${{ steps.changes.outputs.run_clang_tidy }}
+      changed-files: ${{ steps.changes.outputs.files}}
+      diff-range: ${{ steps.changes.outputs.range }}
+      merge-base-commit: ${{ steps.changes.outputs.merge_base_commit }}
+    steps:
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+          fetch-depth: 0
+
+      - name: Get changed files
+        id: changes
+        env:
+          GH_TOKEN: ${{ github.token }}
+          BASE_REF: ${{ github.base_ref }}
+          HEAD_REF: ${{ github.head_ref }}
+          PR_OWNER: ${{ github.event.pull_request.head.repo.owner.login }}
+          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+          JOB_TRIGGER: ${{ github.event_name }}
+        run: |
+          echo "JOB_TRIGGER: $JOB_TRIGGER"
+          if [[ "$JOB_TRIGGER" == "pull_request" ]]; then
+            merge_base_commit=$(gh api -q '.merge_base_commit.sha' \
+              /repos/facebookincubator/velox/compare/facebookincubator:$BASE_REF...$PR_OWNER:$HEAD_REF \
+            )
+
+            range="$merge_base_commit..$HEAD_SHA"
+            echo "range=$range" >> "$GITHUB_OUTPUT"
+            echo "merge_base_commit=$merge_base_commit" >> "$GITHUB_OUTPUT"
+
+            git diff --name-only $range > changed_files.txt
+
+            cpp_files='.+\.(cpp|h|hpp)$'
+
+            {
+              echo 'files<<EOF'
+              cat changed_files.txt
+              echo 'EOF'
+            } >> "$GITHUB_OUTPUT"
+
+            if grep -qE $cpp_files changed_files.txt; then
+              echo "run_clang_tidy=true" >> "$GITHUB_OUTPUT"
+            fi
+          else
+            echo "run_clang_tidy=false" >> "$GITHUB_OUTPUT"
+          fi
+
   adapters:
     name: Linux release with adapters
+    needs: get-changes
     # prevent errors when forks ff their main branch
     if: ${{ github.repository == 'facebookincubator/velox' }}
-    runs-on: 8-core-ubuntu-22.04
+    runs-on: 32-core-ubuntu
     container: ghcr.io/facebookincubator/velox-dev:adapters
     defaults:
       run:
@@ -36,13 +88,21 @@ jobs:
     env:
       CCACHE_DIR: ${{ github.workspace }}/ccache
       VELOX_DEPENDENCY_SOURCE: SYSTEM
-      GTest_SOURCE: BUNDLED
       cudf_SOURCE: BUNDLED
-      CUDA_VERSION: '12.8'
+      CUDA_VERSION: '12.9'
       faiss_SOURCE: BUNDLED
       USE_CLANG: "${{ inputs.use-clang && 'true' || 'false' }}"
+    outputs:
+      cudf-changes: ${{ steps.changes.outputs.cudf }}
+      build-outcome: ${{ steps.build.outcome }}
+      build-failure-details: ${{ steps.build-errors.outputs.build-failure-details }}
+      test-outcome: ${{ steps.retry-tests.outcome != 'skipped' && steps.retry-tests.outcome || steps.tests.outcome }}
+      flaky: ${{ steps.retry-tests.outputs.flaky }}
+      failed-tests: ${{ steps.retry-tests.outputs.failed-tests }}
+      failed-cases: ${{ steps.retry-tests.outputs.failed-cases }}
+      failure-details: ${{ steps.retry-tests.outputs.failure-details }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
           fetch-depth: 2
           persist-credentials: false
@@ -58,6 +118,9 @@ jobs:
           VELOX_ARROW_CMAKE_PATCH: ${{ github.workspace }}/CMake/resolve_dependency_modules/arrow/cmake-compatibility.patch
         run: |
           if git diff --name-only HEAD^1 HEAD | grep -q "scripts/setup-"; then
+            echo "Removing previous AWS SDK and s2n installations to avoid conflicts..."
+            rm -rf /usr/local/include/s2n /usr/local/lib64/s2n
+            rm -rf /usr/local/include/aws
             # Overwrite old setup scripts with changed versions
             cp scripts/setup-* /
 
@@ -83,12 +146,13 @@ jobs:
           ccache -sz
 
       - name: Make Release Build
+        id: build
         env:
-          MAKEFLAGS: NUM_THREADS=8 MAX_HIGH_MEM_JOBS=4 MAX_LINK_JOBS=4
+          MAKEFLAGS: NUM_THREADS=32 MAX_HIGH_MEM_JOBS=12 MAX_LINK_JOBS=12
           CUDA_ARCHITECTURES: 70
           CUDA_COMPILER: /usr/local/cuda-${CUDA_VERSION}/bin/nvcc
-          # Set compiler to GCC 12
-          CUDA_FLAGS: -ccbin /opt/rh/gcc-toolset-12/root/usr/bin
+          # Set compiler to GCC 14
+          CUDA_FLAGS: -ccbin /opt/rh/gcc-toolset-14/root/usr/bin
         run: |
           EXTRA_CMAKE_FLAGS=(
             "-DVELOX_ENABLE_BENCHMARKS=ON"
@@ -102,19 +166,38 @@ jobs:
             "-DVELOX_ENABLE_ABFS=ON"
             "-DVELOX_ENABLE_WAVE=ON"
             "-DVELOX_MONO_LIBRARY=ON"
-            "-DVELOX_BUILD_SHARED=ON"
           )
           if [[ "${USE_CLANG}" = "true" ]]; then
              scripts/setup-centos9.sh install_clang15; export CC=/usr/bin/clang-15; export CXX=/usr/bin/clang++-15; CUDA_FLAGS="-ccbin /usr/lib64/llvm15/bin/clang++-15";
           else
             # cuDF (unsupported for Clang) and Faiss (link issue when using Clang)
             # are excluded for Clang compilation and need to be added back when using GCC.
-            EXTRA_CMAKE_FLAGS+="-DVELOX_ENABLE_CUDF=ON"
-            EXTRA_CMAKE_FLAGS+="-DVELOX_ENABLE_FAISS=ON"
+            EXTRA_CMAKE_FLAGS+=("-DVELOX_ENABLE_CUDF=ON")
+            EXTRA_CMAKE_FLAGS+=("-DVELOX_ENABLE_FAISS=ON")
             # Investigate issues with remote function service: Issue #13897
-            EXTRA_CMAKE_FLAGS+="-DVELOX_ENABLE_REMOTE_FUNCTIONS=ON"
+            EXTRA_CMAKE_FLAGS+=("-DVELOX_ENABLE_REMOTE_FUNCTIONS=ON")
+          fi
+          source /opt/rh/gcc-toolset-14/enable
+          g++ --version
+          # CC/CXX are set to GCC12 in the adapters image build and it needs to be overridden
+          # after sourcing GCC14.
+          CC=gcc CXX=g++ make release EXTRA_CMAKE_FLAGS="${EXTRA_CMAKE_FLAGS[*]}" 2>&1 | tee /tmp/build-output.log
+
+      - name: Extract build errors
+        id: build-errors
+        if: failure() && steps.build.outcome == 'failure'
+        run: |
+          # Strip ANSI escape sequences before grepping — the build uses
+          # -fdiagnostics-color=always which embeds SGR and erase (ESC[K)
+          # codes that prevent matching literal ': error:'.
+          BUILD_ERRORS=$(sed 's/\x1b\[[0-9;]*[a-zA-Z]//g' /tmp/build-output.log | grep -E ' (error|fatal error):' | head -50 || true)
+          if [[ -n $BUILD_ERRORS ]]; then
+            {
+              echo 'build-failure-details<<EOF'
+              echo "$BUILD_ERRORS"
+              echo 'EOF'
+            } >> "$GITHUB_OUTPUT"
           fi
-          make release EXTRA_CMAKE_FLAGS="${EXTRA_CMAKE_FLAGS[*]}"
 
       - name: Ccache after
         run: ccache -s
@@ -125,32 +208,295 @@ jobs:
           key: ccache-linux-adapters-${{ inputs.use-clang && 'clang' || 'gcc' }}
 
       - name: Run Tests
+        id: tests
+        continue-on-error: true
+        if: steps.build.outcome == 'success'
         env:
           LIBHDFS3_CONF: ${{ github.workspace }}/scripts/ci/hdfs-client.xml
         working-directory: _build/release
         run: |
-          # Can be removed after images are rebuild
-          if [ -f "/opt/miniforge/etc/profile.d/conda.sh" ]; then
-            source "/opt/miniforge/etc/profile.d/conda.sh"
-            conda activate adapters
+          source /setup-classpath.sh
+          ulimit -n 65536
+          ctest -j 24 --timeout 900 --label-exclude cuda_driver \
+            --output-on-failure --no-tests=error \
+            --output-junit test-results.xml 2>&1 | tee /tmp/ctest-output.log
+
+      - name: Retry Flaky Tests
+        id: retry-tests
+        continue-on-error: true
+        if: steps.tests.outcome == 'failure'
+        env:
+          LIBHDFS3_CONF: ${{ github.workspace }}/scripts/ci/hdfs-client.xml
+        working-directory: _build/release
+        run: |
+          source /setup-classpath.sh
+          echo "::warning::Some tests failed. Retrying failed tests..."
+          if ctest --rerun-failed -j 4 --timeout 900 \
+               --output-on-failure --output-junit retry-results.xml; then
+            echo "::warning::All failed tests passed on retry — these are flaky tests."
+            echo "flaky=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "::error::Tests failed consistently on retry."
+            "$GITHUB_WORKSPACE/.github/scripts/extract-test-failures.sh" /tmp/ctest-output.log
+            exit 1
+          fi
+
+      # Clang-tidy needs a complete build because some files are only generated during the build
+      # that clang tidy will not find and report errors otherwise.
+      # When clang is used a number of dependencies are excluded from the build so we don't
+      # need to run clang-tidy for that.
+      # Let's also run this as last step so that if skipped it doesn't affect subsequent steps.
+      - name: Install and run clang-tidy
+        if: ${{ steps.build.outcome == 'success' && ! inputs.use-clang && needs.get-changes.outputs.run-clang-tidy == 'true' }}
+        env:
+          FILES: ${{ needs.get-changes.outputs.changed-files }}
+          RANGE: ${{ needs.get-changes.outputs.diff-range }}
+          MERGE_BASE_COMMIT: ${{ needs.get-changes.outputs.merge-base-commit }}
+        run: |
+          git config --global --add safe.directory /__w/velox/velox
+          uv tool install clang-tidy==18.1.8
+          git fetch origin $MERGE_BASE_COMMIT
+          # The usage of GCC14 adds compiler warnings not understood by Clang/Clang-tidy.
+          # We replace them for now but eventually move Clang-tidy to the Clang based build.
+          BUILD_PATH=$(realpath ./_build/release)
+          sed -i 's/-Wno-error=template-id-cdtor//g' $BUILD_PATH/compile_commands.json
+          sed -i 's/-Wno-class-memaccess//g' $BUILD_PATH/compile_commands.json
+          sed -i 's/-Wno-maybe-uninitialized//g' $BUILD_PATH/compile_commands.json
+          sed -i 's/-fcoroutines//g' $BUILD_PATH/compile_commands.json
+          python ./scripts/checks/run-clang-tidy.py -p $BUILD_PATH --commit $RANGE $FILES
+
+      - name: Check cuDF Changes
+        uses: dorny/paths-filter@de90cc6fb38fc0963ad72b210f1f284cd68cea36 # v3.0.2
+        id: changes
+        if: ${{ ! inputs.use-clang && always() }}
+        with:
+          filters: |
+            cudf:
+              - 'velox/experimental/cudf/**'
+              - 'CMake/resolve_dependency_modules/cudf.cmake'
+
+      - name: Copy Shared Libraries for cuDF Test Binaries
+        if: ${{ ! inputs.use-clang && steps.changes.outputs.cudf && always() }}
+        env:
+          CUDF_DIR: _build/release/velox/experimental/cudf
+        run: |
+          mkdir -p "$CUDF_DIR/cudf-libs"
+          deps=$(
+            find "$CUDF_DIR/tests" -name "velox_cudf_*" -type f -executable |
+            xargs ldd 2>/dev/null |
+            sed -n 's/[^\/]*\(\/[^ ]*\) .*/\1/p' |
+            grep -vE '^/(lib|usr/lib|lib64)/(libcuda|librt\.so|libm\.so|libstdc\+\+\.so|ld-linux-x86-64\.so|libc\.so)' |
+            sort -u
+          )
+          if [ -z "$deps" ]; then
+            echo "Error: No dependencies found"
+            exit 1
+          fi
+          # copy all "real" files and symlink targets to "$CUDF_DIR/cudf-libs"
+          (
+            echo "$deps" |
+            xargs readlink -f |
+            xargs -I {} cp {} "$CUDF_DIR/cudf-libs/"
+          )
+          # filter out which libraries are symlinks
+          lndeps=$(echo "$deps" | xargs -I {} bash -c '[ -L "$1" ] && echo "$1" || true' bash {})
+          # write new symlinks to the same folder, with targets in the same folder
+          (
+            if [[ -d "$CUDF_DIR/cudf-libs" ]]; then
+              cd "$CUDF_DIR/cudf-libs" || exit 1
+              while IFS= read -r link; do
+                [[ -L "$link" ]] || continue
+                target=$(readlink -f "$link") || continue
+                target_basename=$(basename "$target") || continue
+                link_basename=$(basename "$link") || continue
+                ln -sf "$target_basename" "$link_basename" || echo "Warning: Failed to create symlink $link_basename"
+              done <<< "$lndeps"
+            else
+              echo "Error: Directory $CUDF_DIR/cudf-libs not found"
+              exit 1
+            fi
+          )
+          tar -cvf "$CUDF_DIR/cudf-libs.tar" -C "$CUDF_DIR" cudf-libs
+
+      - name: Upload cuDF Test Binaries
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        if: ${{ ! inputs.use-clang && steps.changes.outputs.cudf && always() }}
+        with:
+          name: cudftestbinaries
+          path: |
+            velox/dwio/parquet/tests/examples/int.parquet
+            velox/experimental/cudf/tests/CMakeLists.txt
+            _build/release/velox/experimental/cudf/tests/velox_cudf_*
+            _build/release/velox/experimental/cudf/tests/CTestTestfile.cmake
+            _build/release/velox/experimental/cudf/cudf-libs.tar
+          retention-days: ${{ env.RETENTION }}
+
+  adapters-build-status:
+    if: always()
+    needs: adapters
+    runs-on: ubuntu-latest
+    name: "BUILD: Linux release with adapters"
+    steps:
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          sparse-checkout: .github/scripts
+          persist-credentials: false
+
+      - name: Report build status
+        run: .github/scripts/report-build-status.sh "Linux release with adapters"
+        env:
+          BUILD_OUTCOME: ${{ needs.adapters.outputs.build-outcome }}
+          BUILD_FAILURE_DETAILS: ${{ needs.adapters.outputs.build-failure-details }}
+
+      - name: Upload failure artifact
+        if: failure()
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: ci-failure-adapters-build
+          path: /tmp/ci-failure/failure.json
+          retention-days: 1
+          if-no-files-found: ignore
+
+  adapters-test-status:
+    if: always()
+    needs: adapters
+    runs-on: ubuntu-latest
+    name: "TEST: Linux release with adapters"
+    steps:
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          sparse-checkout: .github/scripts
+          persist-credentials: false
+
+      - name: Report test status
+        run: .github/scripts/report-test-status.sh "Linux release with adapters" "Linux adapters release"
+        env:
+          BUILD_OUTCOME: ${{ needs.adapters.outputs.build-outcome }}
+          TEST_OUTCOME: ${{ needs.adapters.outputs.test-outcome }}
+          FLAKY: ${{ needs.adapters.outputs.flaky }}
+          FAILED_TESTS: ${{ needs.adapters.outputs.failed-tests }}
+          FAILED_CASES: ${{ needs.adapters.outputs.failed-cases }}
+          FAILURE_DETAILS: ${{ needs.adapters.outputs.failure-details }}
+
+      - name: Upload failure artifact
+        if: failure()
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: ci-failure-adapters-test
+          path: /tmp/ci-failure/failure.json
+          retention-days: 1
+          if-no-files-found: ignore
+
+  cudf-tests:
+    runs-on: 4-core-ubuntu-gpu-t4
+    needs: adapters
+    if: ${{ ! inputs.use-clang && needs.adapters.outputs.cudf-changes == 'true' && needs.adapters.result == 'success' && always() }}
+    timeout-minutes: 30
+    env:
+      CUDF_DIR: _build/release/velox/experimental/cudf
+    steps:
+      - name: Install Packages
+        run: |
+          sudo apt-get update && sudo apt-get install -y cmake patchelf cuda-toolkit-12-9
+          export MINIO_VERSION="2022-05-26T05-48-41Z"
+          export MINIO_BINARY_NAME="minio-2022-05-26"
+          wget https://dl.min.io/server/minio/release/linux-amd64/archive/minio.RELEASE."${MINIO_VERSION}" -O "${MINIO_BINARY_NAME}"
+          sudo mv ./"${MINIO_BINARY_NAME}" /usr/local/bin/
+          sudo chmod +x /usr/local/bin/"${MINIO_BINARY_NAME}"
+
+      - name: Check NVIDIA Driver Version
+        run: |
+          nvidia-smi
+
+      - name: Download cuDF Test Binaries
+        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        with:
+          name: cudftestbinaries
+
+      - name: Adapt Downloaded Files
+        run: |
+          # Change hardcoded workspace path in CTestTestfile.cmake to the runner workspace
+          if [[ -f "$CUDF_DIR/tests/CTestTestfile.cmake" ]]; then
+            workspace_escaped=$(printf '%s\n' "${{ github.workspace }}" | sed 's/[[\.*^$()+?{|]/\\&/g')
+            sed -i "s|/__w/velox/velox|${workspace_escaped}|g" "$CUDF_DIR/tests/CTestTestfile.cmake"
+            # Verify the replacement worked
+            if grep -q "${{ github.workspace }}" "$CUDF_DIR/tests/CTestTestfile.cmake"; then
+              echo "Successfully updated paths in CTestTestfile.cmake"
+            else
+              echo "Warning: Path replacement may have failed"
+            fi
+          else
+            echo "Error: CTestTestfile.cmake not found"
+            exit 1
           fi
+          sed -i 's|/__w/velox/velox|${{ github.workspace }}|g' $CUDF_DIR/tests/CTestTestfile.cmake
+          grep "Source directory" $CUDF_DIR/tests/CTestTestfile.cmake
+          grep "Build directory" $CUDF_DIR/tests/CTestTestfile.cmake
+          (cd  $CUDF_DIR && tar -xf cudf-libs.tar)
+          # Patch test executables.
+          # ldfconfig causes system wide changes. Since we are copying some system libraries from
+          # the build machine, we need to use patchelf to add the copied libraries path only to
+          # the test executables.
+          for exe in $CUDF_DIR/tests/velox_cudf_*; do
+            patchelf --force-rpath --set-rpath '$ORIGIN/../cudf-libs' "$exe"
+            chmod +x "$exe"
+            ls -l "$exe"
+          done
 
-          export CLASSPATH=`/usr/local/hadoop/bin/hdfs classpath --glob`
-          ctest -j 8 --label-exclude cuda_driver --output-on-failure --no-tests=error
+      - name: Run cuDF Tests
+        run: |
+          cd $CUDF_DIR/tests/
+          ctest --output-on-failure
 
   ubuntu-debug:
-    runs-on: 8-core-ubuntu-22.04
+    runs-on: 32-core-ubuntu
+    container: ghcr.io/facebookincubator/velox-dev:ubuntu-22.04
     # prevent errors when forks ff their main branch
     if: ${{ github.repository == 'facebookincubator/velox' }}
-    name: Ubuntu debug with resolve_dependency
+    name: Ubuntu debug with system dependencies
     env:
       CCACHE_DIR: ${{ github.workspace }}/ccache
       USE_CLANG: ${{ inputs.use-clang && 'true' || 'false' }}
+    outputs:
+      build-outcome: ${{ steps.build.outcome }}
+      build-failure-details: ${{ steps.build-errors.outputs.build-failure-details }}
+      test-outcome: ${{ steps.retry-tests.outcome != 'skipped' && steps.retry-tests.outcome || steps.tests.outcome }}
+      flaky: ${{ steps.retry-tests.outputs.flaky }}
+      failed-tests: ${{ steps.retry-tests.outputs.failed-tests }}
+      failed-cases: ${{ steps.retry-tests.outputs.failed-cases }}
+      failure-details: ${{ steps.retry-tests.outputs.failure-details }}
     defaults:
       run:
         shell: bash
         working-directory: velox
     steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 2
+          path: velox
+          persist-credentials: false
+
+      - name: Fix git permissions
+        # Usually actions/checkout does this but as we run in a container
+        # it doesn't work
+        run: git config --global --add safe.directory ${GITHUB_WORKSPACE}
+
+      - name: Install Dependencies
+        env:
+          VELOX_ARROW_CMAKE_PATCH: ${{ github.workspace }}/velox/CMake/resolve_dependency_modules/arrow/cmake-compatibility.patch
+        run: |
+          if git diff --name-only HEAD^1 HEAD | grep -q "scripts/setup-"; then
+            # Overwrite old setup scripts with changed versions
+            cp scripts/setup-* /
+
+            mkdir /tmp/build
+            cd /tmp/build
+
+            USE_CLANG=false bash /setup-ubuntu.sh
+
+            cd /
+            rm -rf /tmp/build # cleanup to avoid issues with disk space
+          fi
 
       - name: Get Ccache Stash
         uses: apache/infrastructure-actions/stash/restore@3354c1565d4b0e335b78a76aedd82153a9e144d4
@@ -163,35 +509,229 @@ jobs:
         run: |
           mkdir -p "$CCACHE_DIR"
 
-      - uses: actions/checkout@v4
+      - name: Clear CCache Statistics
+        run: |
+          ccache -sz
+
+      - name: Make Debug Build
+        id: build
+        env:
+          VELOX_DEPENDENCY_SOURCE: SYSTEM
+          ICU_SOURCE: SYSTEM
+          # Use BUNDLED gflags to provide PIC static gflags for .so plugins.
+          # The container's folly is built with -DGFLAGS_SHARED=FALSE so its
+          # exported config references gflags_static which BUNDLED gflags provides.
+          gflags_SOURCE: BUNDLED
+          # Keep system glog (container's glog is built against the same gflags
+          # version). Without this, BUNDLED gflags cascades to BUNDLED glog
+          # which conflicts with system glog loaded transitively.
+          glog_SOURCE: SYSTEM
+          MAKEFLAGS: NUM_THREADS=32 MAX_HIGH_MEM_JOBS=8 MAX_LINK_JOBS=6
+        run: |
+          EXTRA_CMAKE_FLAGS=(
+            "-DCMAKE_LINK_LIBRARIES_STRATEGY=REORDER_FREELY"
+            "-DVELOX_BUILD_SHARED=ON"
+            "-DVELOX_ENABLE_BENCHMARKS=ON"
+            "-DVELOX_ENABLE_EXAMPLES=ON"
+            "-DVELOX_ENABLE_ARROW=ON"
+            "-DVELOX_ENABLE_GEO=ON"
+            "-DVELOX_ENABLE_PARQUET=ON"
+            "-DVELOX_MONO_LIBRARY=ON"
+          )
+          if [[ "${USE_CLANG}" = "true" ]]; then
+             export CC=/usr/bin/clang-15; export CXX=/usr/bin/clang++-15;
+          else
+            EXTRA_CMAKE_FLAGS+=("-DVELOX_ENABLE_FAISS=ON")
+            EXTRA_CMAKE_FLAGS+=("-DVELOX_ENABLE_REMOTE_FUNCTIONS=ON")
+          fi
+          export EXTRA_CMAKE_FLAGS="${EXTRA_CMAKE_FLAGS[*]}"
+          make debug 2>&1 | tee /tmp/build-output.log
+
+      - name: Extract build errors
+        id: build-errors
+        if: failure() && steps.build.outcome == 'failure'
+        run: |
+          # Strip ANSI escape sequences before grepping — the build uses
+          # -fdiagnostics-color=always which embeds SGR and erase (ESC[K)
+          # codes that prevent matching literal ': error:'.
+          BUILD_ERRORS=$(sed 's/\x1b\[[0-9;]*[a-zA-Z]//g' /tmp/build-output.log | grep -E ' (error|fatal error):' | head -50 || true)
+          if [[ -n $BUILD_ERRORS ]]; then
+            {
+              echo 'build-failure-details<<EOF'
+              echo "$BUILD_ERRORS"
+              echo 'EOF'
+            } >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: CCache after
+        run: |
+          ccache -vs
+
+      - uses: apache/infrastructure-actions/stash/save@3354c1565d4b0e335b78a76aedd82153a9e144d4
+        with:
+          path: ${{ env.CCACHE_DIR }}
+          key: ccache-ubuntu-debug-default-${{ inputs.use-clang && 'clang' || 'gcc' }}
+
+      - name: Run Tests
+        id: tests
+        continue-on-error: true
+        if: steps.build.outcome == 'success'
+        run: |
+          ulimit -n 65536
+          cd _build/debug
+          ctest -j 24 --timeout 1800 --output-on-failure --no-tests=error \
+            --output-junit test-results.xml 2>&1 | tee /tmp/ctest-output.log
+
+      - name: Retry Flaky Tests
+        id: retry-tests
+        continue-on-error: true
+        if: steps.tests.outcome == 'failure'
+        run: |
+          cd _build/debug
+          echo "::warning::Some tests failed. Retrying failed tests..."
+          if ctest --rerun-failed -j 4 --timeout 1800 \
+               --output-on-failure --output-junit retry-results.xml; then
+            echo "::warning::All failed tests passed on retry — these are flaky tests."
+            echo "flaky=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "::error::Tests failed consistently on retry."
+            "$GITHUB_WORKSPACE/velox/.github/scripts/extract-test-failures.sh" /tmp/ctest-output.log
+            exit 1
+          fi
+
+  ubuntu-debug-build-status:
+    if: always()
+    needs: ubuntu-debug
+    runs-on: ubuntu-latest
+    name: "BUILD: Ubuntu debug with system dependencies"
+    steps:
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          sparse-checkout: .github/scripts
+          persist-credentials: false
+
+      - name: Report build status
+        run: .github/scripts/report-build-status.sh "Ubuntu debug with system dependencies"
+        env:
+          BUILD_OUTCOME: ${{ needs.ubuntu-debug.outputs.build-outcome }}
+          BUILD_FAILURE_DETAILS: ${{ needs.ubuntu-debug.outputs.build-failure-details }}
+
+      - name: Upload failure artifact
+        if: failure()
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
+          name: ci-failure-ubuntu-debug-build
+          path: /tmp/ci-failure/failure.json
+          retention-days: 1
+          if-no-files-found: ignore
+
+  ubuntu-debug-test-status:
+    if: always()
+    needs: ubuntu-debug
+    runs-on: ubuntu-latest
+    name: "TEST: Ubuntu debug with system dependencies"
+    steps:
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          sparse-checkout: .github/scripts
+          persist-credentials: false
+
+      - name: Report test status
+        run: .github/scripts/report-test-status.sh "Ubuntu debug with system dependencies" "Ubuntu debug"
+        env:
+          BUILD_OUTCOME: ${{ needs.ubuntu-debug.outputs.build-outcome }}
+          TEST_OUTCOME: ${{ needs.ubuntu-debug.outputs.test-outcome }}
+          FLAKY: ${{ needs.ubuntu-debug.outputs.flaky }}
+          FAILED_TESTS: ${{ needs.ubuntu-debug.outputs.failed-tests }}
+          FAILED_CASES: ${{ needs.ubuntu-debug.outputs.failed-cases }}
+          FAILURE_DETAILS: ${{ needs.ubuntu-debug.outputs.failure-details }}
+
+      - name: Upload failure artifact
+        if: failure()
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: ci-failure-ubuntu-debug-test
+          path: /tmp/ci-failure/failure.json
+          retention-days: 1
+          if-no-files-found: ignore
+
+  fedora-debug:
+    runs-on: 32-core-ubuntu
+    container: ghcr.io/facebookincubator/velox-dev:fedora
+    # prevent errors when forks ff their main branch
+    if: ${{ github.repository == 'facebookincubator/velox' }}
+    name: Fedora debug
+    env:
+      CCACHE_DIR: ${{ github.workspace }}/ccache
+    outputs:
+      build-outcome: ${{ steps.build.outcome }}
+    defaults:
+      run:
+        shell: bash
+        working-directory: velox
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 2
           path: velox
           persist-credentials: false
 
+      - name: Fix git permissions
+        # Usually actions/checkout does this but as we run in a container
+        # it doesn't work
+        run: git config --global --add safe.directory ${GITHUB_WORKSPACE}
+
       - name: Install Dependencies
+        env:
+          VELOX_BUILD_SHARED: "ON"
+          VELOX_ARROW_CMAKE_PATCH: ${{ github.workspace }}/velox/CMake/resolve_dependency_modules/arrow/cmake-compatibility.patch
         run: |
-          source scripts/setup-ubuntu.sh && install_apt_deps && install_faiss_deps
+          if git diff --name-only HEAD^1 HEAD | grep -q "scripts/setup-"; then
+            # Overwrite old setup scripts with changed versions
+            cp scripts/setup-* /
+
+            mkdir /tmp/build
+            cd /tmp/build
+
+            # Install basic deps with GCC.
+            USE_CLANG=false bash /setup-fedora.sh
+
+            cd /
+            rm -rf /tmp/build # cleanup to avoid issues with disk space
+          fi
+
+      - name: Get Ccache Stash
+        uses: apache/infrastructure-actions/stash/restore@3354c1565d4b0e335b78a76aedd82153a9e144d4
+        with:
+          path: ${{ env.CCACHE_DIR }}
+          key: ccache-fedora-debug-default-gcc
+
+      - name: Ensure Stash Dirs Exists
+        working-directory: ${{ github.workspace }}
+        run: |
+          mkdir -p "$CCACHE_DIR"
 
       - name: Clear CCache Statistics
         run: |
           ccache -sz
 
       - name: Make Debug Build
+        id: build
         env:
-          VELOX_DEPENDENCY_SOURCE: BUNDLED
-          ICU_SOURCE: SYSTEM
-          MAKEFLAGS: NUM_THREADS=8 MAX_HIGH_MEM_JOBS=4 MAX_LINK_JOBS=3
+          VELOX_DEPENDENCY_SOURCE: SYSTEM
+          faiss_SOURCE: BUNDLED
+          fmt_SOURCE: BUNDLED
+          simdjson_SOURCE: BUNDLED
+          gRPC_SOURCE: SYSTEM
+          MAKEFLAGS: NUM_THREADS=32 MAX_HIGH_MEM_JOBS=8 MAX_LINK_JOBS=6
           EXTRA_CMAKE_FLAGS: >-
-            -DCMAKE_LINK_LIBRARIES_STRATEGY=REORDER_FREELY
             -DVELOX_ENABLE_PARQUET=ON
+            -DARROW_THRIFT_USE_SHARED=ON
             -DVELOX_ENABLE_EXAMPLES=ON
         run: |
-          # Faiss (link issue when using Clang) is excluded for Clang compilation and needs to be added back when using GCC.
-          if [[ "${USE_CLANG}" = "true" ]]; then
-            export CC=/usr/bin/clang-15; export CXX=/usr/bin/clang++-15;
-          else
-            export EXTRA_CMAKE_FLAGS="${EXTRA_CMAKE_FLAGS} -DVELOX_ENABLE_FAISS=ON"
-          fi
+          uv tool install --force cmake@3.31.1
+          dnf install -y -q --setopt=install_weak_deps=False grpc-devel grpc-plugins
+          export EXTRA_CMAKE_FLAGS="${EXTRA_CMAKE_FLAGS} -DVELOX_ENABLE_FAISS=ON"
           make debug
 
       - name: CCache after
@@ -201,8 +741,39 @@ jobs:
       - uses: apache/infrastructure-actions/stash/save@3354c1565d4b0e335b78a76aedd82153a9e144d4
         with:
           path: ${{ env.CCACHE_DIR }}
-          key: ccache-ubuntu-debug-default-${{ inputs.use-clang && 'clang' || 'gcc' }}
+          key: ccache-fedora-debug-default-gcc
 
-      - name: Run Tests
+  fedora-debug-build-status:
+    if: always()
+    needs: fedora-debug
+    runs-on: ubuntu-latest
+    name: "BUILD: Fedora debug"
+    steps:
+      - run: |
+          if [[ -z "$BUILD_OUTCOME" || "$BUILD_OUTCOME" == "cancelled" ]]; then
+            echo "Build was cancelled (likely superseded by a newer push). Skipping."
+            exit 0
+          fi
+          if [[ "$BUILD_OUTCOME" != "success" ]]; then
+            echo "::error::Fedora debug build failed. Do not land this PR until the build is fixed."
+            exit 1
+          fi
+          echo "Build succeeded."
+        env:
+          BUILD_OUTCOME: ${{ needs.fedora-debug.outputs.build-outcome }}
+
+      - name: Upload build failure artifact
+        if: failure()
         run: |
-          cd _build/debug && ctest -j 8 --output-on-failure --no-tests=error
+          mkdir -p /tmp/ci-failure
+          jq -n --arg job "Fedora debug" --arg type "build" \
+            '{job: $job, type: $type}' \
+            > /tmp/ci-failure/failure.json
+
+      - name: Upload failure comment artifact
+        if: failure()
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: ci-failure-fedora-build
+          path: /tmp/ci-failure/failure.json
+          retention-days: 1
diff --git a/.github/disabled-workflows/macos.yml b/.github/disabled-workflows/macos.yml
index f2db45237cb..2fb94f0f836 100644
--- a/.github/disabled-workflows/macos.yml
+++ b/.github/disabled-workflows/macos.yml
@@ -22,6 +22,9 @@ on:
       - CMakeLists.txt
       - CMake/**
       - scripts/setup-macos.sh
+      - scripts/setup-common.sh
+      - scripts/setup-versions.sh
+      - scripts/setup-helper-functions.sh
       - .github/workflows/macos.yml
 
   pull_request:
@@ -31,6 +34,9 @@ on:
       - CMakeLists.txt
       - CMake/**
       - scripts/setup-macos.sh
+      - scripts/setup-common.sh
+      - scripts/setup-versions.sh
+      - scripts/setup-helper-functions.sh
       - .github/workflows/macos.yml
 
 permissions:
@@ -43,22 +49,20 @@ concurrency:
 jobs:
   macos-build:
     if: ${{ github.repository == 'facebookincubator/velox' }}
-    name: ${{ matrix.os }}
+    name: macos-15-${{ matrix.type }}
     strategy:
       fail-fast: false
       matrix:
-        # macos-13 = x86_64 Mac
-        # macos-15 = arm64 Mac and cmake 4.0
-        os: [macos-13, macos-15]
-    runs-on: ${{ matrix.os }}
+        # macos-15 = arm64 Mac and cmake 4.0 with 7GB RAM
+        type: [debug, release]
+    runs-on: macos-15
     env:
       CCACHE_DIR: ${{ github.workspace }}/ccache
-      # The arm runners have only 7GB RAM
-      BUILD_TYPE: ${{ matrix.os == 'macos-15' && 'Release' || 'Debug' }}
+      BUILD_TYPE: ${{ matrix.type }}
       INSTALL_PREFIX: /tmp/deps-install
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           persist-credentials: false
 
@@ -70,6 +74,9 @@ jobs:
           source scripts/setup-macos.sh
           install_build_prerequisites
           install_velox_deps_from_brew
+          install_gflags
+          install_glog
+          install_protobuf
           # Needed for faiss to find BLAS
           install_faiss_deps
           install_double_conversion
@@ -86,7 +93,7 @@ jobs:
         uses: apache/infrastructure-actions/stash/restore@3354c1565d4b0e335b78a76aedd82153a9e144d4
         with:
           path: ${{ env.CCACHE_DIR }}
-          key: ccache-macos-1-${{ matrix.os }}
+          key: ccache-macos-1-macos-15-${{ matrix.type }}
 
       - name: Configure Build
         env:
@@ -114,7 +121,7 @@ jobs:
       - uses: apache/infrastructure-actions/stash/save@3354c1565d4b0e335b78a76aedd82153a9e144d4
         with:
           path: ${{ env.CCACHE_DIR }}
-          key: ccache-macos-1-${{ matrix.os }}
+          key: ccache-macos-1-macos-15-${{ matrix.type }}
 
       - name: Run Tests
         if: false
diff --git a/.github/disabled-workflows/scheduled.yml b/.github/disabled-workflows/scheduled.yml
index 17eb81ca190..429e174fac4 100644
--- a/.github/disabled-workflows/scheduled.yml
+++ b/.github/disabled-workflows/scheduled.yml
@@ -82,8 +82,10 @@ concurrency:
   cancel-in-progress: true
 
 env:
-  # Run for 15 minute on PRs
-  DURATION: ${{ inputs.duration || ( github.event_name != 'schedule' && 900 || 1800 )}}
+  # Per-instance fuzzer duration. With 4 parallel instances at 300s each,
+  # total fuzzer coverage is 1200s (20 min) vs the previous 900s (15 min).
+  DURATION: ${{ inputs.duration || ( github.event_name != 'schedule' && 300 || 600 )}}
+  NUM_FUZZER_INSTANCES: 4
   # minimize artifact duration for PRs, keep them a bit longer for nightly runs
   RETENTION: ${{ github.event_name == 'pull_request' && 1 || 3 }}
 
@@ -97,9 +99,9 @@ jobs:
     timeout-minutes: 120
     env:
       CCACHE_DIR: ${{ github.workspace }}/ccache
-      NUM_THREADS: ${{ inputs.numThreads || 16 }}
+      NUM_THREADS: ${{ inputs.numThreads || 32 }}
       MAX_HIGH_MEM_JOBS: ${{ inputs.maxHighMemJobs || 8 }}
-      MAX_LINK_JOBS: ${{ inputs.maxLinkJobs || 4 }}
+      MAX_LINK_JOBS: ${{ inputs.maxLinkJobs || 6 }}
       SKBUILD_BUILD_DIR: _build/debug
       PYVELOX_LEGACY_ONLY: 'ON'
       CMAKE_POLICY_VERSION_MINIMUM: "3.5"
@@ -115,6 +117,7 @@ jobs:
       spark_error: ${{ steps.sig-check.outputs.spark_error }}
       presto_aggregate_bias: ${{ steps.sig-check.outputs.presto_aggregate_functions }}
       presto_aggregate_error: ${{ steps.sig-check.outputs.presto_aggregate_error }}
+      signatures_checked: ${{ steps.sig-paths.outputs.signatures }}
 
     steps:
 
@@ -170,22 +173,39 @@ jobs:
           mkdir -p '$CCACHE_DIR'
           mkdir -p /tmp/signatures
 
+      - name: Check for signature-relevant changes
+        uses: dorny/paths-filter@de90cc6fb38fc0963ad72b210f1f284cd68cea36 # v3.0.2
+        if: github.event_name == 'pull_request'
+        id: sig-paths
+        with:
+          filters: |
+            signatures:
+              - 'velox/functions/prestosql/**'
+              - 'velox/functions/sparksql/**'
+              - 'velox/functions/lib/**'
+              - 'velox/expression/**'
+              - 'velox/exec/Aggregate.h'
+              - 'velox/exec/Aggregate.cpp'
+              - 'velox/type/**'
+              - 'velox/python/**'
+              - 'pyproject.toml'
+
       - name: Checkout Main
-        if: ${{ github.event_name != 'schedule' && steps.get-sig.outputs.stash-hit != 'true' }}
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        if: ${{ github.event_name != 'schedule' && steps.get-sig.outputs.stash-hit != 'true' && (github.event_name != 'pull_request' || steps.sig-paths.outputs.signatures == 'true') }}
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           ref: ${{ steps.get-merge-base.outputs.head_main || 'main' }}
           path: velox_main
           persist-credentials: false
 
       - name: Build PyVelox
-        if: ${{ github.event_name != 'schedule' && steps.get-sig.outputs.stash-hit != 'true' }}
+        if: ${{ github.event_name != 'schedule' && steps.get-sig.outputs.stash-hit != 'true' && (github.event_name != 'pull_request' || steps.sig-paths.outputs.signatures == 'true') }}
         working-directory: velox_main
         run: |
           make python-build
 
       - name: Create Baseline Signatures
-        if: ${{ github.event_name != 'schedule' && steps.get-sig.outputs.stash-hit != 'true' }}
+        if: ${{ github.event_name != 'schedule' && steps.get-sig.outputs.stash-hit != 'true' && (github.event_name != 'pull_request' || steps.sig-paths.outputs.signatures == 'true') }}
         working-directory: velox_main
         run: |
           # TODO convert to uv with script defined deps after 14046 is merged
@@ -197,14 +217,14 @@ jobs:
           python3 scripts/ci/signature.py export_aggregates --presto /tmp/signatures/presto_aggregate_signatures_main.json
 
       - name: Save Function Signature Stash
-        if: ${{ github.event_name == 'pull_request' && steps.get-sig.outputs.stash-hit != 'true' }}
+        if: ${{ github.event_name == 'pull_request' && steps.get-sig.outputs.stash-hit != 'true' && steps.sig-paths.outputs.signatures == 'true' }}
         uses: apache/infrastructure-actions/stash/save@3354c1565d4b0e335b78a76aedd82153a9e144d4
         with:
           path: /tmp/signatures
           key: function-signatures-${{ steps.get-merge-base.outputs.head_main }}
 
       - name: Checkout Contender
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           path: velox
           ref: ${{ inputs.ref }}
@@ -214,19 +234,35 @@ jobs:
         run: |
           ccache -sz
 
-      - name: Build
+      - name: Build Fuzzer Targets
         env:
           EXTRA_CMAKE_FLAGS: >
             -DVELOX_ENABLE_ARROW=ON
             -DVELOX_ENABLE_GEO=ON
             -DVELOX_MONO_LIBRARY=ON
+            -DVELOX_BUILD_SHARED=ON
             -DVELOX_BUILD_PYTHON_PACKAGE=ON
             -DVELOX_PYTHON_LEGACY_ONLY=ON
             ${{ inputs.extraCMakeFlags }}
         run: |
           make python-venv
           source .venv/bin/activate
-          make debug
+          make cmake BUILD_DIR=debug BUILD_TYPE=Debug
+          cmake --build _build/debug -j ${NUM_THREADS} --target \
+            velox_expression_fuzzer_test \
+            spark_expression_fuzzer_test \
+            spark_aggregation_fuzzer_test \
+            velox_aggregation_fuzzer_test \
+            velox_join_fuzzer \
+            velox_exchange_fuzzer \
+            velox_window_fuzzer_test \
+            velox_cache_fuzzer \
+            velox_table_evolution_fuzzer_test \
+            velox_memory_arbitration_fuzzer \
+            velox_row_number_fuzzer \
+            velox_topn_row_number_fuzzer \
+            velox_writer_fuzzer_test \
+            velox_spatial_join_fuzzer
 
       - name: Ccache after
         run: ccache -s
@@ -241,12 +277,12 @@ jobs:
           key: ccache-fuzzer-centos
 
       - name: Build PyVelox
-        if: ${{ github.event_name != 'schedule' }}
+        if: ${{ github.event_name != 'schedule' && (github.event_name != 'pull_request' || steps.sig-paths.outputs.signatures == 'true') }}
         run: |
           make python-build
 
       - name: Create and test new function signatures
-        if: ${{ github.event_name != 'schedule' }}
+        if: ${{ github.event_name != 'schedule' && (github.event_name != 'pull_request' || steps.sig-paths.outputs.signatures == 'true') }}
         id: sig-check
         run: |
           source .venv/bin/activate
@@ -259,8 +295,8 @@ jobs:
            /tmp/signatures/presto_aggregate_errors
 
       - name: Upload Signature Artifacts
-        if: ${{ github.event_name != 'schedule' }}
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        if: ${{ github.event_name != 'schedule' && (github.event_name != 'pull_request' || steps.sig-paths.outputs.signatures == 'true') }}
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: signatures
           path: /tmp/signatures
@@ -285,104 +321,125 @@ jobs:
           path: /tmp/signatures
           key: function-signatures-${{ github.sha }}
 
+      - name: Upload fuzzer scripts
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+        with:
+          name: fuzzer-scripts
+          path: velox/scripts/ci/run-fuzzer-parallel.sh
+          retention-days: ${{ env.RETENTION }}
+
       - name: Upload presto fuzzer
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: presto
           path: velox/_build/debug/velox/expression/fuzzer/velox_expression_fuzzer_test
           retention-days: ${{ env.RETENTION }}
 
       - name: Upload spark expression fuzzer
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: spark_expression_fuzzer
           path: velox/_build/debug/velox/expression/fuzzer/spark_expression_fuzzer_test
           retention-days: ${{ env.RETENTION }}
 
       - name: Upload spark aggregation fuzzer
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: spark_aggregation_fuzzer
           path: velox/_build/debug/velox/functions/sparksql/fuzzer/spark_aggregation_fuzzer_test
           retention-days: ${{ env.RETENTION }}
 
       - name: Upload aggregation fuzzer
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: aggregation
           path: velox/_build/debug/velox/functions/prestosql/fuzzer/velox_aggregation_fuzzer_test
           retention-days: ${{ env.RETENTION }}
 
       - name: Upload join fuzzer
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: join
           path: velox/_build/debug/velox/exec/fuzzer/velox_join_fuzzer
           retention-days: ${{ env.RETENTION }}
 
       - name: Upload exchange fuzzer
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: exchange
           path: velox/_build/debug//velox/exec/fuzzer/velox_exchange_fuzzer
           retention-days: ${{ env.RETENTION }}
 
       - name: Upload window fuzzer
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: window
           path: velox/_build/debug/velox/functions/prestosql/fuzzer/velox_window_fuzzer_test
           retention-days: ${{ env.RETENTION }}
 
       - name: Upload cache fuzzer
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: cache_fuzzer
           path: velox/_build/debug/velox/exec/fuzzer/velox_cache_fuzzer
           retention-days: ${{ env.RETENTION }}
 
       - name: Upload table evolution fuzzer
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: table_evolution_fuzzer
           path: velox/_build/debug/velox/exec/tests/velox_table_evolution_fuzzer_test
           retention-days: ${{ env.RETENTION }}
 
       - name: Upload memory arbitration fuzzer
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: memory_arbitration_fuzzer
           path: velox/_build/debug/velox/exec/fuzzer/velox_memory_arbitration_fuzzer
           retention-days: ${{ env.RETENTION }}
 
       - name: Upload row number fuzzer
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: row_number
           path: velox/_build/debug//velox/exec/fuzzer/velox_row_number_fuzzer
           retention-days: ${{ env.RETENTION }}
 
       - name: Upload topn row number fuzzer
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: topn_row_number
           path: velox/_build/debug//velox/exec/fuzzer/velox_topn_row_number_fuzzer
           retention-days: ${{ env.RETENTION }}
 
       - name: Upload writer fuzzer
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: writer
           path: velox/_build/debug/velox/functions/prestosql/fuzzer/velox_writer_fuzzer_test
           retention-days: ${{ env.RETENTION }}
 
+      - name: Upload spatial join fuzzer
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+        with:
+          name: spatial_join_fuzzer
+          path: velox/_build/debug/velox/exec/fuzzer/velox_spatial_join_fuzzer
+          retention-days: ${{ env.RETENTION }}
+
+      - name: Upload shared library
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+        with:
+          name: libvelox
+          path: velox/_build/debug/lib/libvelox.so
+          retention-days: ${{ env.RETENTION }}
+
   presto-fuzzer-run:
     name: Presto Fuzzer
     if: ${{ needs.compile.outputs.presto_bias  != 'true' }}
-    runs-on: ubuntu-latest
+    runs-on: 4-core-ubuntu
     container: ghcr.io/facebookincubator/velox-dev:centos9
     needs: compile
-    timeout-minutes: 120
+    timeout-minutes: 30
     steps:
       - uses: dorny/paths-filter@de90cc6fb38fc0963ad72b210f1f284cd68cea36 # v3.0.2
         if: github.event_name == 'pull_request'
@@ -398,10 +455,10 @@ jobs:
 
       - name: Set presto specific fuzzer duration
         env:
-          # Run for 30 minutes instead of 15, when files relevant to presto are touched
-          pr_duration: ${{ steps.changes.outputs.presto == 'true' && 1800 || 900 }}
-          # Run for 60 minutes if its a scheduled run
-          other_duration: ${{ inputs.duration || (github.event_name == 'push' && 1800 || 3600) }}
+          # Run for 10 minutes per instance instead of 5, when files relevant to presto are touched
+          pr_duration: ${{ steps.changes.outputs.presto == 'true' && 600 || 300 }}
+          # Run for 20 minutes per instance if its a scheduled run
+          other_duration: ${{ inputs.duration || (github.event_name == 'push' && 600 || 1200) }}
           is_pr: ${{ github.event_name == 'pull_request' }}
         run: |
           if [ "$is_pr" == "true" ]; then
@@ -413,19 +470,27 @@ jobs:
           echo "DURATION=$duration" >> $GITHUB_ENV
 
       - name: Download presto fuzzer
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: presto
 
+      - name: Download libvelox
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: libvelox
+
+      - name: Download fuzzer scripts
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: fuzzer-scripts
+
       - name: Run Presto Fuzzer
         run: |
-          mkdir -p /tmp/fuzzer_repro/logs/
-          chmod -R 777 /tmp/fuzzer_repro
-          chmod +x velox_expression_fuzzer_test
-          random_seed=${RANDOM}
-          echo "Random seed: ${random_seed}"
-          ./velox_expression_fuzzer_test \
-                --seed ${random_seed} \
+          export LD_LIBRARY_PATH=$(pwd):$LD_LIBRARY_PATH
+          chmod +x velox_expression_fuzzer_test run-fuzzer-parallel.sh
+          ./run-fuzzer-parallel.sh $NUM_FUZZER_INSTANCES /tmp/fuzzer_repro \
+            ./velox_expression_fuzzer_test \
+                --seed __SEED__ \
                 --enable_variadic_signatures \
                 --velox_fuzzer_enable_complex_types \
                 --velox_fuzzer_enable_decimal_type \
@@ -435,17 +500,17 @@ jobs:
                 --velox_fuzzer_enable_expression_reuse \
                 --max_expression_trees_per_step 2 \
                 --retry_with_try \
+                --special_forms="and,or,cast,coalesce" \
                 --enable_dereference \
                 --duration_sec $DURATION \
                 --minloglevel=0 \
                 --stderrthreshold=2 \
-                --log_dir=/tmp/fuzzer_repro/logs \
-                --repro_persist_path=/tmp/fuzzer_repro \
-          && echo -e "\n\nFuzzer run finished successfully."
+                --log_dir=__LOG_DIR__ \
+                --repro_persist_path=__REPRO_DIR__
 
       - name: Archive production artifacts
-        if: ${{ !cancelled() }}
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        if: ${{ always() }}
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: presto-fuzzer-failure-artifacts
           path: |
@@ -454,21 +519,31 @@ jobs:
   presto-sot-fuzzer-run:
     name: Expression Fuzzer with Presto SOT
     needs: compile
-    runs-on: ubuntu-latest
+    runs-on: 4-core-ubuntu
     container: ghcr.io/facebookincubator/velox-dev:presto-java
-    timeout-minutes: 120
+    timeout-minutes: 30
     env:
       CCACHE_DIR: ${{ github.workspace }}/ccache/
       LINUX_DISTRO: centos
     steps:
 
       - name: Download Presto expression fuzzer
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: presto
 
+      - name: Download libvelox
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: libvelox
+
+      - name: Download fuzzer scripts
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: fuzzer-scripts
+
       - name: Checkout Repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           path: velox
           ref: ${{ inputs.ref }}
@@ -484,18 +559,16 @@ jobs:
           cd velox
           cp ./scripts/ci/presto/etc/hive.properties $PRESTO_HOME/etc/catalog
           ls -lR $PRESTO_HOME/etc
-          $PRESTO_HOME/bin/launcher run -v > /tmp/server.log 2>&1 &
+          $PRESTO_HOME/bin/launcher run > /tmp/server.log 2>&1 &
           # Sleep for 60 seconds to allow Presto server to start.
           sleep 60
           /opt/presto-cli --server 127.0.0.1:8080 --execute 'CREATE SCHEMA IF NOT EXISTS hive.tpch;'
           cd -
-          mkdir -p /tmp/fuzzer_repro/logs/
-          chmod -R 777 /tmp/fuzzer_repro
-          chmod +x velox_expression_fuzzer_test
-          random_seed=${RANDOM}
-          echo "Random seed: ${random_seed}"
-          ./velox_expression_fuzzer_test \
-                --seed ${random_seed} \
+          export LD_LIBRARY_PATH=$(pwd):$LD_LIBRARY_PATH
+          chmod +x velox_expression_fuzzer_test run-fuzzer-parallel.sh
+          ./run-fuzzer-parallel.sh $NUM_FUZZER_INSTANCES /tmp/fuzzer_repro \
+            ./velox_expression_fuzzer_test \
+                --seed __SEED__ \
                 --enable_variadic_signatures \
                 --velox_fuzzer_enable_complex_types \
                 --lazy_vector_generation_ratio 0.2 \
@@ -503,19 +576,19 @@ jobs:
                 --velox_fuzzer_enable_column_reuse \
                 --velox_fuzzer_enable_expression_reuse \
                 --enable_dereference \
-                --duration_sec 900 \
+                --duration_sec $DURATION \
                 --minloglevel=0 \
                 --stderrthreshold=2 \
-                --log_dir=/tmp/fuzzer_repro/logs \
-                --repro_persist_path=/tmp/fuzzer_repro \
+                --log_dir=__LOG_DIR__ \
+                --repro_persist_path=__REPRO_DIR__ \
                 --special_forms="cast,coalesce,if" \
                 --velox_fuzzer_max_level_of_nesting=1 \
                 --presto_url=http://127.0.0.1:8080 \
-          && echo -e "\n\nFuzzer run finished successfully."
+                --table_name_prefix=i__INSTANCE_ID__
 
       - name: Archive expression production artifacts
-        if: ${{ !cancelled() }}
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        if: ${{ always() }}
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: presto-sot-fuzzer-failure-artifacts
           path: |
@@ -531,12 +604,21 @@ jobs:
     steps:
 
       - name: Download presto expression fuzzer
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: presto
 
+      - name: Download libvelox
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: libvelox
+      - name: Download fuzzer scripts
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: fuzzer-scripts
+
       - name: Download Signatures
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: signatures
           path: /tmp/signatures
@@ -546,9 +628,11 @@ jobs:
           ls /tmp/signatures
           mkdir -p /tmp/presto_bias_fuzzer_repro/logs/
           chmod -R 777 /tmp/presto_bias_fuzzer_repro
+          export LD_LIBRARY_PATH=$(pwd):$LD_LIBRARY_PATH
           chmod +x velox_expression_fuzzer_test
           random_seed=${RANDOM}
           echo "Random seed: ${random_seed}"
+          echo "Biased functions: $(< /tmp/signatures/presto_bias_functions)"
           ./velox_expression_fuzzer_test \
                 --seed ${random_seed} \
                 --lazy_vector_generation_ratio 0.2 \
@@ -570,8 +654,8 @@ jobs:
             && echo -e "\n\nPresto Fuzzer run finished successfully."
 
       - name: Archive Presto Bias expression production artifacts
-        if: ${{ !cancelled() }}
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        if: ${{ always() }}
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: presto-bias-fuzzer-failure-artifacts
           path: |
@@ -579,40 +663,48 @@ jobs:
 
   spark-aggregate-fuzzer-run:
     name: Spark Aggregate Fuzzer
-    runs-on: ubuntu-latest
+    runs-on: 4-core-ubuntu
     container: ghcr.io/facebookincubator/velox-dev:spark-server
     needs: compile
-    timeout-minutes: 60
+    timeout-minutes: 30
     steps:
 
       - name: Download spark aggregation fuzzer
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: spark_aggregation_fuzzer
 
+      - name: Download libvelox
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: libvelox
+      - name: Download fuzzer scripts
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: fuzzer-scripts
+
       - name: Run Spark Aggregate Fuzzer
         run: |
           bash /opt/start-spark.sh
-          # Sleep for 60 seconds to allow Spark server to start.
-          sleep 60
-          mkdir -p /tmp/spark_aggregate_fuzzer_repro/logs/
-          chmod -R 777 /tmp/spark_aggregate_fuzzer_repro
-          chmod +x spark_aggregation_fuzzer_test
-          random_seed=${RANDOM}
-          echo "Random seed: ${random_seed}"
-          ./spark_aggregation_fuzzer_test \
-                --seed ${random_seed} \
+          # Sleep for 120 seconds to allow Spark server to start.
+          sleep 120
+          export LD_LIBRARY_PATH=$(pwd):$LD_LIBRARY_PATH
+          chmod +x spark_aggregation_fuzzer_test run-fuzzer-parallel.sh
+          ./run-fuzzer-parallel.sh $NUM_FUZZER_INSTANCES /tmp/spark_aggregate_fuzzer_repro \
+            ./spark_aggregation_fuzzer_test \
+                --seed __SEED__ \
                 --duration_sec $DURATION \
                 --enable_sorted_aggregations=false \
+                --enable_streaming_aggregations=false \
                 --minloglevel=0 \
                 --stderrthreshold=2 \
-                --log_dir=/tmp/spark_aggregate_fuzzer_repro/logs \
-                --repro_persist_path=/tmp/spark_aggregate_fuzzer_repro \
-          && echo -e "\n\nSpark Aggregation Fuzzer run finished successfully."
+                --log_dir=__LOG_DIR__ \
+                --repro_persist_path=__REPRO_DIR__ \
+                --table_name_prefix=i__INSTANCE_ID__
 
       - name: Archive Spark aggregate production artifacts
-        if: ${{ !cancelled() }}
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        if: ${{ always() }}
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: spark-agg-fuzzer-failure-artifacts
           path: |
@@ -628,12 +720,21 @@ jobs:
     steps:
 
       - name: Download spark expression fuzzer
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: spark_expression_fuzzer
 
+      - name: Download libvelox
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: libvelox
+      - name: Download fuzzer scripts
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: fuzzer-scripts
+
       - name: Download Signatures
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: signatures
           path: /tmp/signatures
@@ -643,9 +744,11 @@ jobs:
           ls /tmp/signatures
           mkdir -p /tmp/spark_bias_fuzzer_repro/logs/
           chmod -R 777 /tmp/spark_bias_fuzzer_repro
+          export LD_LIBRARY_PATH=$(pwd):$LD_LIBRARY_PATH
           chmod +x spark_expression_fuzzer_test
           random_seed=${RANDOM}
           echo "Random seed: ${random_seed}"
+          echo "Biased functions: $(< /tmp/signatures/spark_bias_functions)"
           ./spark_expression_fuzzer_test \
                 --seed ${random_seed} \
                 --duration_sec $DURATION \
@@ -658,8 +761,8 @@ jobs:
             && echo -e "\n\nSpark Fuzzer run finished successfully."
 
       - name: Archive Spark expression production artifacts
-        if: ${{ !cancelled() }}
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        if: ${{ always() }}
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: spark-fuzzer-failure-artifacts
           path: |
@@ -668,26 +771,33 @@ jobs:
   spark-fuzzer:
     name: Spark Fuzzer
     if: ${{ needs.compile.outputs.spark_bias  != 'true' }}
-    runs-on: ubuntu-latest
+    runs-on: 4-core-ubuntu
     container: ghcr.io/facebookincubator/velox-dev:centos9
     needs: compile
-    timeout-minutes: 120
+    timeout-minutes: 30
     steps:
 
       - name: Download spark expression fuzzer
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: spark_expression_fuzzer
 
+      - name: Download libvelox
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: libvelox
+      - name: Download fuzzer scripts
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: fuzzer-scripts
+
       - name: Run Spark Expression Fuzzer
         run: |
-          mkdir -p /tmp/spark_fuzzer_repro/logs/
-          chmod -R 777 /tmp/spark_fuzzer_repro
-          chmod +x spark_expression_fuzzer_test
-          random_seed=${RANDOM}
-          echo "Random seed: ${random_seed}"
-          ./spark_expression_fuzzer_test \
-                --seed ${random_seed} \
+          export LD_LIBRARY_PATH=$(pwd):$LD_LIBRARY_PATH
+          chmod +x spark_expression_fuzzer_test run-fuzzer-parallel.sh
+          ./run-fuzzer-parallel.sh $NUM_FUZZER_INSTANCES /tmp/spark_fuzzer_repro \
+            ./spark_expression_fuzzer_test \
+                --seed __SEED__ \
                 --enable_variadic_signatures \
                 --lazy_vector_generation_ratio 0.2 \
                 --velox_fuzzer_enable_column_reuse \
@@ -696,16 +806,16 @@ jobs:
                 --retry_with_try \
                 --enable_dereference \
                 --velox_fuzzer_enable_decimal_type \
+                --special_forms="and,or,cast,coalesce" \
                 --duration_sec $DURATION \
                 --minloglevel=0 \
                 --stderrthreshold=2 \
-                --log_dir=/tmp/spark_fuzzer_repro/logs \
-                --repro_persist_path=/tmp/spark_fuzzer_repro \
-            && echo -e "\n\nSpark Fuzzer run finished successfully."
+                --log_dir=__LOG_DIR__ \
+                --repro_persist_path=__REPRO_DIR__
 
       - name: Archive Spark expression production artifacts
-        if: ${{ !cancelled() }}
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        if: ${{ always() }}
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: spark-fuzzer-failure-artifacts
           path: |
@@ -713,22 +823,31 @@ jobs:
 
   presto-java-join-fuzzer-run:
     name: Join Fuzzer
-    runs-on: ubuntu-latest
+    runs-on: 4-core-ubuntu
     container: ghcr.io/facebookincubator/velox-dev:presto-java
     needs: compile
-    timeout-minutes: 120
+    timeout-minutes: 30
     env:
       CCACHE_DIR: ${{ github.workspace }}/ccache/
       LINUX_DISTRO: centos
     steps:
 
       - name: Download join fuzzer
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: join
 
+      - name: Download libvelox
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: libvelox
+      - name: Download fuzzer scripts
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: fuzzer-scripts
+
       - name: Checkout Repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           path: velox
           ref: ${{ inputs.ref }}
@@ -744,29 +863,27 @@ jobs:
           cd  velox
           cp ./scripts/ci/presto/etc/hive.properties $PRESTO_HOME/etc/catalog
           ls -lR $PRESTO_HOME/etc
-          $PRESTO_HOME/bin/launcher run -v > /tmp/server.log 2>&1 &
+          $PRESTO_HOME/bin/launcher run > /tmp/server.log 2>&1 &
           # Sleep for 60 seconds to allow Presto server to start.
           sleep 60
           /opt/presto-cli --server 127.0.0.1:8080 --execute 'CREATE SCHEMA IF NOT EXISTS hive.tpch;'
           cd -
-          mkdir -p /tmp/join_fuzzer_repro/logs/
-          chmod -R 777 /tmp/join_fuzzer_repro
-          chmod +x velox_join_fuzzer
-          random_seed=${RANDOM}
-          echo "Random seed: ${random_seed}"
-          ./velox_join_fuzzer \
-                --seed ${random_seed} \
+          export LD_LIBRARY_PATH=$(pwd):$LD_LIBRARY_PATH
+          chmod +x velox_join_fuzzer run-fuzzer-parallel.sh
+          ./run-fuzzer-parallel.sh $NUM_FUZZER_INSTANCES /tmp/join_fuzzer_repro \
+            ./velox_join_fuzzer \
+                --seed __SEED__ \
                 --duration_sec $DURATION \
                 --minloglevel=0 \
                 --stderrthreshold=2 \
-                --log_dir=/tmp/join_fuzzer_repro/logs \
+                --log_dir=__LOG_DIR__ \
                 --presto_url=http://127.0.0.1:8080 \
-                --req_timeout_ms=2000 \
-            && echo -e "\n\nJoin fuzzer run finished successfully."
+                --req_timeout_ms=10000 \
+                --table_name_prefix=i__INSTANCE_ID__
 
       - name: Archive join production artifacts
-        if: ${{ !cancelled() }}
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        if: ${{ always() }}
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: presto-sot-join-fuzzer-failure-artifacts
           path: |
@@ -778,34 +895,42 @@ jobs:
     runs-on: ubuntu-latest
     container: ghcr.io/facebookincubator/velox-dev:centos9
     needs: compile
-    timeout-minutes: 120
+    timeout-minutes: 30
     steps:
 
       - name: Download exchange fuzzer
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: exchange
 
+      - name: Download libvelox
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: libvelox
+      - name: Download fuzzer scripts
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: fuzzer-scripts
+
       - name: Run exchange Fuzzer
         run: |
           cat /proc/sys/vm/max_map_count
-          mkdir -p /tmp/exchange_fuzzer_repro/logs/
-          chmod -R 777 /tmp/exchange_fuzzer_repro
-          chmod +x velox_exchange_fuzzer
-          random_seed=${RANDOM}
-          echo "Random seed: ${random_seed}"
-          ./velox_exchange_fuzzer \
-                --seed ${random_seed} \
-                --duration_sec $DURATION \
+          export LD_LIBRARY_PATH=$(pwd):$LD_LIBRARY_PATH
+          chmod +x velox_exchange_fuzzer run-fuzzer-parallel.sh
+          # Exchange fuzzer is multi-threaded and memory-heavy; run 1 instance
+          # on ubuntu-latest with an extended duration.
+          ./run-fuzzer-parallel.sh 1 /tmp/exchange_fuzzer_repro \
+            ./velox_exchange_fuzzer \
+                --seed __SEED__ \
+                --duration_sec 480 \
                 --minloglevel=0 \
                 --stderrthreshold=2 \
-                --log_dir=/tmp/exchange_fuzzer_repro/logs \
-                --repro_path=/tmp/exchange_fuzzer_repro \
-            && echo -e "\n\Exchange fuzzer run finished successfully."
+                --log_dir=__LOG_DIR__ \
+                --repro_path=__REPRO_DIR__
 
       - name: Archive Exchange production artifacts
-        if: ${{ !cancelled() }}
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        if: ${{ always() }}
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: exchange-fuzzer-failure-artifacts
           path: |
@@ -813,10 +938,10 @@ jobs:
 
   presto-java-row-number-fuzzer-run:
     name: RowNumber Fuzzer
-    runs-on: ubuntu-latest
+    runs-on: 4-core-ubuntu
     container: ghcr.io/facebookincubator/velox-dev:presto-java
     needs: compile
-    timeout-minutes: 120
+    timeout-minutes: 30
     env:
       CCACHE_DIR: ${{ github.workspace }}/ccache/
       LINUX_DISTRO: centos
@@ -824,12 +949,21 @@ jobs:
     steps:
 
       - name: Download row number fuzzer
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: row_number
 
+      - name: Download libvelox
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: libvelox
+      - name: Download fuzzer scripts
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: fuzzer-scripts
+
       - name: Checkout Repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           path: velox
           ref: ${{ inputs.ref }}
@@ -845,29 +979,27 @@ jobs:
           cd velox
           cp ./scripts/ci/presto/etc/hive.properties $PRESTO_HOME/etc/catalog
           ls -lR $PRESTO_HOME/etc
-          $PRESTO_HOME/bin/launcher run -v > /tmp/server.log 2>&1 &
+          $PRESTO_HOME/bin/launcher run > /tmp/server.log 2>&1 &
           # Sleep for 60 seconds to allow Presto server to start.
           sleep 60
           /opt/presto-cli --server 127.0.0.1:8080 --execute 'CREATE SCHEMA IF NOT EXISTS hive.tpch;'
           cd -
-          cat /proc/sys/vm/max_map_count
-          mkdir -p /tmp/row_fuzzer_repro/logs/
-          chmod -R 777 /tmp/row_fuzzer_repro
-          chmod +x velox_row_number_fuzzer
-          random_seed=${RANDOM}
-          echo "Random seed: ${random_seed}"
-          ./velox_row_number_fuzzer \
-                --seed ${random_seed} \
+          export LD_LIBRARY_PATH=$(pwd):$LD_LIBRARY_PATH
+          chmod +x velox_row_number_fuzzer run-fuzzer-parallel.sh
+          ./run-fuzzer-parallel.sh $NUM_FUZZER_INSTANCES /tmp/row_fuzzer_repro \
+            ./velox_row_number_fuzzer \
+                --seed __SEED__ \
                 --duration_sec $DURATION \
                 --minloglevel=0 \
                 --stderrthreshold=2 \
-                --log_dir=/tmp/row_fuzzer_repro/logs \
+                --log_dir=__LOG_DIR__ \
                 --presto_url=http://127.0.0.1:8080 \
-            && echo -e "\n\Row number fuzzer run finished successfully."
+                --req_timeout_ms=10000 \
+                --table_name_prefix=i__INSTANCE_ID__
 
       - name: Archive row number production artifacts
-        if: ${{ !cancelled() }}
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        if: ${{ always() }}
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: row-fuzzer-failure-artifacts
           path: |
@@ -875,10 +1007,10 @@ jobs:
 
   presto-java-topn-row-number-fuzzer-run:
     name: TopNRowNumber Fuzzer
-    runs-on: ubuntu-latest
+    runs-on: 4-core-ubuntu
     container: ghcr.io/facebookincubator/velox-dev:presto-java
     needs: compile
-    timeout-minutes: 120
+    timeout-minutes: 30
     env:
       CCACHE_DIR: ${{ github.workspace }}/ccache/
       LINUX_DISTRO: centos
@@ -886,12 +1018,21 @@ jobs:
     steps:
 
       - name: Download topn row number fuzzer
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: topn_row_number
 
+      - name: Download libvelox
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: libvelox
+      - name: Download fuzzer scripts
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: fuzzer-scripts
+
       - name: Checkout Repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           path: velox
           ref: ${{ inputs.ref }}
@@ -907,30 +1048,27 @@ jobs:
           cd velox
           cp ./scripts/ci/presto/etc/hive.properties $PRESTO_HOME/etc/catalog
           ls -lR $PRESTO_HOME/etc
-          $PRESTO_HOME/bin/launcher run -v > /tmp/server.log 2>&1 &
+          $PRESTO_HOME/bin/launcher run > /tmp/server.log 2>&1 &
           # Sleep for 60 seconds to allow Presto server to start.
           sleep 60
           /opt/presto-cli --server 127.0.0.1:8080 --execute 'CREATE SCHEMA IF NOT EXISTS hive.tpch;'
           cd -
-          cat /proc/sys/vm/max_map_count
-          mkdir -p /tmp/topn_row_fuzzer_repro/logs/
-          chmod -R 777 /tmp/topn_row_fuzzer_repro
-          chmod +x velox_topn_row_number_fuzzer
-          random_seed=${RANDOM}
-          echo "Random seed: ${random_seed}"
-          ./velox_topn_row_number_fuzzer \
-                --seed ${random_seed} \
+          export LD_LIBRARY_PATH=$(pwd):$LD_LIBRARY_PATH
+          chmod +x velox_topn_row_number_fuzzer run-fuzzer-parallel.sh
+          ./run-fuzzer-parallel.sh $NUM_FUZZER_INSTANCES /tmp/topn_row_fuzzer_repro \
+            ./velox_topn_row_number_fuzzer \
+                --seed __SEED__ \
                 --duration_sec $DURATION \
                 --minloglevel=0 \
                 --stderrthreshold=2 \
                 --req_timeout_ms 50000 \
-                --log_dir=/tmp/topn_row_fuzzer_repro/logs \
+                --log_dir=__LOG_DIR__ \
                 --presto_url=http://127.0.0.1:8080 \
-            && echo -e "\n\TopN Row number fuzzer run finished successfully."
+                --table_name_prefix=i__INSTANCE_ID__
 
       - name: Archive topn row number production artifacts
-        if: ${{ !cancelled() }}
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        if: ${{ always() }}
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: topn-row-fuzzer-failure-artifacts
           path: |
@@ -938,35 +1076,43 @@ jobs:
 
   cache-fuzzer-run:
     name: Cache Fuzzer
-    runs-on: ubuntu-latest
+    runs-on: 4-core-ubuntu
     container: ghcr.io/facebookincubator/velox-dev:centos9
     needs: compile
-    timeout-minutes: 120
+    timeout-minutes: 30
     # Temporarily disable on PRs till flakiness is fixed #12167
     if: ${{ github.event_name != 'pull_request' }}
     steps:
 
       - name: Download cache fuzzer
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: cache_fuzzer
 
+      - name: Download libvelox
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: libvelox
+      - name: Download fuzzer scripts
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: fuzzer-scripts
+
       - name: Run Cache Fuzzer
         run: |
-          mkdir -p /tmp/cache_fuzzer/logs/
-          chmod -R 777 /tmp/cache_fuzzer
-          chmod +x velox_cache_fuzzer
-          ./velox_cache_fuzzer \
-                --seed ${RANDOM} \
+          export LD_LIBRARY_PATH=$(pwd):$LD_LIBRARY_PATH
+          chmod +x velox_cache_fuzzer run-fuzzer-parallel.sh
+          ./run-fuzzer-parallel.sh $NUM_FUZZER_INSTANCES /tmp/cache_fuzzer \
+            ./velox_cache_fuzzer \
+                --seed __SEED__ \
                 --duration_sec $DURATION \
                 --minloglevel=0 \
                 --stderrthreshold=2 \
-                --log_dir=/tmp/cache_fuzzer/logs \
-            && echo -e "\n\Cache fuzzer run finished successfully."
+                --log_dir=__LOG_DIR__
 
       - name: Archive Cache production artifacts
-        if: ${{ !cancelled() }}
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        if: ${{ always() }}
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: cache-fuzzer-logs
           path: |
@@ -974,33 +1120,41 @@ jobs:
 
   table-evolution-fuzzer-run:
     name: Table Evolution Fuzzer
-    runs-on: ubuntu-latest
+    runs-on: 4-core-ubuntu
     container: ghcr.io/facebookincubator/velox-dev:centos9
     needs: compile
-    timeout-minutes: 120
+    timeout-minutes: 30
     steps:
 
       - name: Download table evolution fuzzer
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: table_evolution_fuzzer
 
+      - name: Download libvelox
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: libvelox
+      - name: Download fuzzer scripts
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: fuzzer-scripts
+
       - name: Run Table Evolution Fuzzer
         run: |
-          mkdir -p /tmp/table_evolution_fuzzer_test/logs/
-          chmod -R 777 /tmp/table_evolution_fuzzer_test
-          chmod +x velox_table_evolution_fuzzer_test
-          ./velox_table_evolution_fuzzer_test \
-                --seed ${RANDOM} \
+          export LD_LIBRARY_PATH=$(pwd):$LD_LIBRARY_PATH
+          chmod +x velox_table_evolution_fuzzer_test run-fuzzer-parallel.sh
+          ./run-fuzzer-parallel.sh $NUM_FUZZER_INSTANCES /tmp/table_evolution_fuzzer_test \
+            ./velox_table_evolution_fuzzer_test \
+                --seed __SEED__ \
                 --table_evolution_fuzzer_duration_sec $DURATION \
                 --minloglevel=0 \
                 --stderrthreshold=2 \
-                --log_dir=/tmp/table_evolution_fuzzer_test/logs \
-            && echo -e "\n\Table evolution fuzzer run finished successfully."
+                --log_dir=__LOG_DIR__
 
       - name: Archive table evolution production artifacts
-        if: ${{ !cancelled() }}
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        if: ${{ always() }}
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: table-evolution-fuzzer-test-logs
           path: |
@@ -1008,56 +1162,73 @@ jobs:
 
   memory-arbitration-fuzzer-run:
     name: Memory Arbitration Fuzzer
-    runs-on: ubuntu-latest
+    runs-on: 4-core-ubuntu
     container: ghcr.io/facebookincubator/velox-dev:centos9
     needs: compile
-    timeout-minutes: 120
+    timeout-minutes: 30
     steps:
 
       - name: Download memory arbitration fuzzer
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: memory_arbitration_fuzzer
 
+      - name: Download libvelox
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: libvelox
+      - name: Download fuzzer scripts
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: fuzzer-scripts
+
       - name: Run Memory Arbitration Fuzzer
         run: |
-          mkdir -p /tmp/memory_arbitration_fuzzer/logs/
-          chmod -R 777 /tmp/memory_arbitration_fuzzer
-          chmod +x velox_memory_arbitration_fuzzer
-          ./velox_memory_arbitration_fuzzer \
-                --seed ${RANDOM} \
+          export LD_LIBRARY_PATH=$(pwd):$LD_LIBRARY_PATH
+          chmod +x velox_memory_arbitration_fuzzer run-fuzzer-parallel.sh
+          ./run-fuzzer-parallel.sh $NUM_FUZZER_INSTANCES /tmp/memory_arbitration_fuzzer \
+            ./velox_memory_arbitration_fuzzer \
+                --seed __SEED__ \
                 --duration_sec $DURATION \
                 --minloglevel=0 \
                 --stderrthreshold=2 \
-                --log_dir=/tmp/memory_arbitration_fuzzer/logs \
-            && echo -e "\n\Memory arbitration fuzzer run finished successfully."
+                --log_dir=__LOG_DIR__
 
       - name: Archive memory arbitration production artifacts
-        if: ${{ !cancelled() }}
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        if: ${{ always() }}
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: memory-arbitration-fuzzer-test-logs
           path: |
-            /tmp/memory_arbitration_fuzzer_test
+            /tmp/memory_arbitration_fuzzer
 
   presto-java-aggregation-fuzzer-run:
     name: Aggregation Fuzzer with Presto as source of truth
     needs: compile
-    runs-on: ubuntu-latest
+    runs-on: 4-core-ubuntu
     container: ghcr.io/facebookincubator/velox-dev:presto-java
-    timeout-minutes: 120
+    timeout-minutes: 30
     env:
       CCACHE_DIR: ${{ github.workspace }}/ccache/
       LINUX_DISTRO: centos
     steps:
 
       - name: Download aggregation fuzzer
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: aggregation
 
+      - name: Download libvelox
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: libvelox
+      - name: Download fuzzer scripts
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: fuzzer-scripts
+
       - name: Checkout Repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           path: velox
           ref: ${{ inputs.ref }}
@@ -1073,30 +1244,29 @@ jobs:
           cd  velox
           cp ./scripts/ci/presto/etc/hive.properties $PRESTO_HOME/etc/catalog
           ls -lR $PRESTO_HOME/etc
-          $PRESTO_HOME/bin/launcher run -v > /tmp/server.log 2>&1 &
+          $PRESTO_HOME/bin/launcher run > /tmp/server.log 2>&1 &
           # Sleep for 60 seconds to allow Presto server to start.
           sleep 60
           /opt/presto-cli --server 127.0.0.1:8080 --execute 'CREATE SCHEMA IF NOT EXISTS hive.tpch;'
           cd -
-          mkdir -p /tmp/aggregate_fuzzer_repro/logs/
-          chmod -R 777 /tmp/aggregate_fuzzer_repro
-          chmod +x velox_aggregation_fuzzer_test
-          random_seed=${RANDOM}
-          echo "Random seed: ${random_seed}"
-          ./velox_aggregation_fuzzer_test \
-                --seed ${random_seed} \
+          export LD_LIBRARY_PATH=$(pwd):$LD_LIBRARY_PATH
+          chmod +x velox_aggregation_fuzzer_test run-fuzzer-parallel.sh
+          ./run-fuzzer-parallel.sh $NUM_FUZZER_INSTANCES /tmp/aggregate_fuzzer_repro \
+            ./velox_aggregation_fuzzer_test \
+                --seed __SEED__ \
                 --duration_sec $DURATION \
                 --minloglevel=0 \
                 --stderrthreshold=2 \
-                --log_dir=/tmp/aggregate_fuzzer_repro/logs \
-                --repro_persist_path=/tmp/aggregate_fuzzer_repro \
+                --log_dir=__LOG_DIR__ \
+                --repro_persist_path=__REPRO_DIR__ \
                 --enable_sorted_aggregations=true \
                 --presto_url=http://127.0.0.1:8080 \
-          && echo -e "\n\nAggregation fuzzer run finished successfully."
+                --req_timeout_ms=10000 \
+                --table_name_prefix=i__INSTANCE_ID__
 
       - name: Archive aggregate production artifacts
-        if: ${{ !cancelled() }}
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        if: ${{ always() }}
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: presto-sot-aggregate-fuzzer-failure-artifacts
           path: |
@@ -1116,12 +1286,21 @@ jobs:
     steps:
 
       - name: Download presto expression fuzzer
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: presto
 
+      - name: Download libvelox
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: libvelox
+      - name: Download fuzzer scripts
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: fuzzer-scripts
+
       - name: Checkout Repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           path: velox
           ref: ${{ inputs.ref }}
@@ -1133,7 +1312,7 @@ jobs:
         run: git config --global --add safe.directory ${GITHUB_WORKSPACE}/velox
 
       - name: Download Signatures
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: signatures
           path: /tmp/signatures
@@ -1143,13 +1322,14 @@ jobs:
           cd  velox
           cp ./scripts/ci/presto/etc/hive.properties $PRESTO_HOME/etc/catalog
           ls -lR $PRESTO_HOME/etc
-          $PRESTO_HOME/bin/launcher run -v > /tmp/server.log 2>&1 &
+          $PRESTO_HOME/bin/launcher run > /tmp/server.log 2>&1 &
           # Sleep for 60 seconds to allow Presto server to start.
           sleep 60
           /opt/presto-cli --server 127.0.0.1:8080 --execute 'CREATE SCHEMA IF NOT EXISTS hive.tpch;'
           cd -
           mkdir -p /tmp/presto_only_bias_function_fuzzer_repro/logs/
           chmod -R 777 /tmp/presto_only_bias_function_fuzzer_repro
+          export LD_LIBRARY_PATH=$(pwd):$LD_LIBRARY_PATH
           chmod +x velox_expression_fuzzer_test
           echo "Biased functions: $(< /tmp/signatures/presto_bias_functions)"
           # Convert the list of function names with tickets into a list of function names only.
@@ -1185,8 +1365,8 @@ jobs:
                 --repro_persist_path=/tmp/presto_only_bias_function_fuzzer_repro \
           && echo -e "\n\nPresto Fuzzer run finished successfully."
       - name: Archive Presto only-bias-function expression fuzzer production artifacts
-        if: ${{ !cancelled() }}
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        if: ${{ always() }}
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: presto-only-bias-function-fuzzer-failure-artifacts
           path: |
@@ -1205,12 +1385,21 @@ jobs:
     steps:
 
       - name: Download aggregation fuzzer
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: aggregation
 
+      - name: Download libvelox
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: libvelox
+      - name: Download fuzzer scripts
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: fuzzer-scripts
+
       - name: Checkout Repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           path: velox
           ref: ${{ inputs.ref }}
@@ -1222,7 +1411,7 @@ jobs:
         run: git config --global --add safe.directory ${GITHUB_WORKSPACE}/velox
 
       - name: Download Signatures
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: signatures
           path: /tmp/signatures
@@ -1232,13 +1421,14 @@ jobs:
           cd  velox
           cp ./scripts/ci/presto/etc/hive.properties $PRESTO_HOME/etc/catalog
           ls -lR $PRESTO_HOME/etc
-          $PRESTO_HOME/bin/launcher run -v > /tmp/server.log 2>&1 &
+          $PRESTO_HOME/bin/launcher run > /tmp/server.log 2>&1 &
           # Sleep for 60 seconds to allow Presto server to start.
           sleep 60
           /opt/presto-cli --server 127.0.0.1:8080 --execute 'CREATE SCHEMA IF NOT EXISTS hive.tpch;'
           cd -
           mkdir -p /tmp/aggregate_fuzzer_repro/logs/
           chmod -R 777 /tmp/aggregate_fuzzer_repro
+          export LD_LIBRARY_PATH=$(pwd):$LD_LIBRARY_PATH
           chmod +x velox_aggregation_fuzzer_test
           echo "signatures folder"
           ls /tmp/signatures/
@@ -1259,8 +1449,8 @@ jobs:
           && echo -e "\n\nAggregation fuzzer run finished successfully."
 
       - name: Archive bias aggregate production artifacts
-        if: ${{ !cancelled() }}
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        if: ${{ always() }}
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: presto-bias-sot-aggregate-fuzzer-failure-artifacts
           path: |
@@ -1269,12 +1459,12 @@ jobs:
 
   surface-signature-errors:
     name: Signature Changes
-    if: ${{ github.event_name != 'schedule' }}
+    if: ${{ github.event_name != 'schedule' && needs.compile.outputs.signatures_checked != 'false' }}
     needs: compile
     runs-on: ubuntu-latest
     steps:
       - name: Download Signatures
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: signatures
           path: /tmp/signatures
@@ -1294,21 +1484,30 @@ jobs:
   presto-java-window-fuzzer-run:
     name: Window Fuzzer with Presto as source of truth
     needs: compile
-    runs-on: ubuntu-latest
+    runs-on: 4-core-ubuntu
     container: ghcr.io/facebookincubator/velox-dev:presto-java
-    timeout-minutes: 120
+    timeout-minutes: 30
     env:
       CCACHE_DIR: ${{ github.workspace }}/ccache/
       LINUX_DISTRO: centos
     steps:
 
       - name: Download window fuzzer
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: window
 
+      - name: Download libvelox
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: libvelox
+      - name: Download fuzzer scripts
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: fuzzer-scripts
+
       - name: Checkout Repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           path: velox
           ref: ${{ inputs.ref }}
@@ -1324,31 +1523,30 @@ jobs:
           cd  velox
           cp ./scripts/ci/presto/etc/hive.properties $PRESTO_HOME/etc/catalog
           ls -lR $PRESTO_HOME/etc
-          $PRESTO_HOME/bin/launcher run -v > /tmp/server.log 2>&1 &
+          $PRESTO_HOME/bin/launcher run > /tmp/server.log 2>&1 &
           # Sleep for 60 seconds to allow Presto server to start.
           sleep 60
           /opt/presto-cli --server 127.0.0.1:8080 --execute 'CREATE SCHEMA IF NOT EXISTS hive.tpch;'
           cd -
-          mkdir -p /tmp/window_fuzzer_repro/logs/
-          chmod -R 777 /tmp/window_fuzzer_repro
-          chmod +x velox_window_fuzzer_test
-          random_seed=${RANDOM}
-          echo "Random seed: ${random_seed}"
-          ./velox_window_fuzzer_test \
-                --seed ${random_seed} \
+          export LD_LIBRARY_PATH=$(pwd):$LD_LIBRARY_PATH
+          chmod +x velox_window_fuzzer_test run-fuzzer-parallel.sh
+          ./run-fuzzer-parallel.sh $NUM_FUZZER_INSTANCES /tmp/window_fuzzer_repro \
+            ./velox_window_fuzzer_test \
+                --seed __SEED__ \
                 --duration_sec $DURATION \
                 --batch_size=50 \
                 --minloglevel=0 \
                 --stderrthreshold=2 \
-                --log_dir=/tmp/window_fuzzer_repro/logs \
-                --repro_persist_path=/tmp/window_fuzzer_repro \
+                --log_dir=__LOG_DIR__ \
+                --repro_persist_path=__REPRO_DIR__ \
                 --enable_window_reference_verification \
                 --presto_url=http://127.0.0.1:8080 \
-          && echo -e "\n\nWindow fuzzer run finished successfully."
+                --req_timeout_ms=10000 \
+                --table_name_prefix=i__INSTANCE_ID__
 
       - name: Archive window production artifacts
-        if: ${{ !cancelled() }}
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        if: ${{ always() }}
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: presto-sot-window-fuzzer-failure-artifacts
           path: |
@@ -1358,21 +1556,30 @@ jobs:
   presto-java-writer-fuzzer-run:
     name: Writer Fuzzer with Presto as source of truth
     needs: compile
-    runs-on: ubuntu-latest
+    runs-on: 4-core-ubuntu
     container: ghcr.io/facebookincubator/velox-dev:presto-java
-    timeout-minutes: 120
+    timeout-minutes: 30
     env:
       CCACHE_DIR: ${{ github.workspace }}/ccache/
       LINUX_DISTRO: centos
     steps:
 
       - name: Download writer fuzzer
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: writer
 
+      - name: Download libvelox
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: libvelox
+      - name: Download fuzzer scripts
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: fuzzer-scripts
+
       - name: Checkout Repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           path: velox
           ref: ${{ inputs.ref }}
@@ -1390,31 +1597,29 @@ jobs:
           ls -lR $PRESTO_HOME/etc
           echo "jvm config content:"
           cat $PRESTO_HOME/etc/jvm.config
-          $PRESTO_HOME/bin/launcher run -v > /tmp/server.log 2>&1 &
+          $PRESTO_HOME/bin/launcher run > /tmp/server.log 2>&1 &
           ls -lR /var/log
           # Sleep for 60 seconds to allow Presto server to start.
           sleep 60
           /opt/presto-cli --version
           /opt/presto-cli --server 127.0.0.1:8080 --execute 'CREATE SCHEMA IF NOT EXISTS hive.tpch;'
           cd -
-          mkdir -p /tmp/writer_fuzzer_repro/logs/
-          chmod -R 777 /tmp/writer_fuzzer_repro
-          chmod +x velox_writer_fuzzer_test
-          random_seed=${RANDOM}
-          echo "Random seed: ${random_seed}"
-          ./velox_writer_fuzzer_test \
-                --seed ${random_seed} \
+          export LD_LIBRARY_PATH=$(pwd):$LD_LIBRARY_PATH
+          chmod +x velox_writer_fuzzer_test run-fuzzer-parallel.sh
+          ./run-fuzzer-parallel.sh $NUM_FUZZER_INSTANCES /tmp/writer_fuzzer_repro \
+            ./velox_writer_fuzzer_test \
+                --seed __SEED__ \
                 --duration_sec $DURATION \
                 --minloglevel=0 \
                 --stderrthreshold=2 \
                 --req_timeout_ms 60000 \
-                --log_dir=/tmp/writer_fuzzer_repro/logs \
+                --log_dir=__LOG_DIR__ \
                 --presto_url=http://127.0.0.1:8080 \
-          && echo -e "\n\Writer fuzzer run finished successfully."
+                --table_name_prefix=i__INSTANCE_ID__
 
       - name: Archive writer production artifacts
-        if: ${{ !cancelled() }}
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        if: ${{ always() }}
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: presto-sot-writer-fuzzer-failure-artifacts
           path: |
@@ -1422,6 +1627,48 @@ jobs:
             /tmp/server.log
             /var/log
 
+  spatial-join-fuzzer-run:
+    name: Spatial Join Fuzzer
+    runs-on: 4-core-ubuntu
+    container: ghcr.io/facebookincubator/velox-dev:centos9
+    needs: compile
+    timeout-minutes: 30
+    steps:
+
+      - name: Download spatial join fuzzer
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: spatial_join_fuzzer
+
+      - name: Download libvelox
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: libvelox
+      - name: Download fuzzer scripts
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: fuzzer-scripts
+
+      - name: Run Spatial Join Fuzzer
+        run: |
+          export LD_LIBRARY_PATH=$(pwd):$LD_LIBRARY_PATH
+          chmod +x velox_spatial_join_fuzzer run-fuzzer-parallel.sh
+          ./run-fuzzer-parallel.sh $NUM_FUZZER_INSTANCES /tmp/spatial_join_fuzzer_repro \
+            ./velox_spatial_join_fuzzer \
+                --seed __SEED__ \
+                --duration_sec $DURATION \
+                --minloglevel=0 \
+                --stderrthreshold=2 \
+                --log_dir=__LOG_DIR__
+
+      - name: Archive spatial join fuzzer production artifacts
+        if: ${{ always() }}
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+        with:
+          name: spatial-join-fuzzer-failure-artifacts
+          path: |
+            /tmp/spatial_join_fuzzer_repro
+
   linux-clang:
     if: ${{ (github.event_name == 'schedule') || (github.event_name == 'workflow_dispatch') }}
     name: Build with Clang
diff --git a/.github/disabled-workflows/tag.yml b/.github/disabled-workflows/tag.yml
new file mode 100644
index 00000000000..7710960fc78
--- /dev/null
+++ b/.github/disabled-workflows/tag.yml
@@ -0,0 +1,76 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+name: Weekly Date Tag
+
+on:
+  schedule:
+    # Runs every Friday at 09:23 UTC, using a odd time avoids jobs
+    # from being skipped during peak hours.
+    - cron: 23 9 * * 5
+  workflow_dispatch:
+    inputs:
+      commit:
+        description: Which commit to tag
+        required: true
+
+      patch-version:
+        description: Additional version component
+        required: false
+        default: '00'
+
+permissions: {}
+
+jobs:
+  create-date-tag:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write # required to push tag
+      checks: read
+    env:
+      COMMIT: ${{ inputs.commit || github.sha }}
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          fetch-depth: 0
+          persist-credentials: true
+
+      - name: Set up Git
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+      - name: Check CI Status
+        # Allow manual triggered workflows to circumvent the check
+        if: ${{ github.event_name != 'workflow_dispatch' }}
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          # This `gh` invocation returns a json array with the workflow status like this
+          # [ { "status": "completed" } ]
+          # If the workflow wasn't success full the array will be empty which we check for
+          # using `grep` -q = set exit code -v = invert match
+          gh run list --commit "$COMMIT" \
+            --workflow "Linux Build using GCC" \
+            --status success --json status | grep -qv '\[\]'
+
+      - name: Create and push date-version tag
+        env:
+          PATCH_VERSION: ${{ inputs.patch-version || '00' }}
+        run: |
+          MESSAGE="This is convenience tag, not a full release."
+          DATE_TAG=$(date -u +"v%Y.%m.%d.$PATCH_VERSION")
+            git tag -m "$MESSAGE" "$DATE_TAG" "$COMMIT"
+            git push origin "$DATE_TAG"
diff --git a/.github/disabled-workflows/ubuntu-bundled-deps.yml b/.github/disabled-workflows/ubuntu-bundled-deps.yml
new file mode 100644
index 00000000000..801e93d7d14
--- /dev/null
+++ b/.github/disabled-workflows/ubuntu-bundled-deps.yml
@@ -0,0 +1,110 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Tests the BUNDLED dependency resolution path on a plain Ubuntu runner
+# (no container). Triggered on PRs that change dependency scripts or
+# CMake modules, and on a nightly schedule.
+
+name: Ubuntu Bundled Dependencies
+
+on:
+  schedule:
+    - cron: 0 5 * * *
+  workflow_dispatch: {}
+  pull_request:
+    paths:
+      - scripts/setup-*.sh
+      - scripts/setup-common.sh
+      - scripts/setup-versions.sh
+      - scripts/setup-helper-functions.sh
+      - CMake/**
+      - CMakeLists.txt
+      - .github/workflows/ubuntu-bundled-deps.yml
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.repository }}-${{ github.head_ref || github.sha }}
+  cancel-in-progress: true
+
+jobs:
+  ubuntu-debug-bundled-deps:
+    runs-on: 16-core-ubuntu
+    if: ${{ github.repository == 'facebookincubator/velox' }}
+    name: Ubuntu debug with bundled dependencies
+    env:
+      CCACHE_DIR: ${{ github.workspace }}/ccache
+    defaults:
+      run:
+        shell: bash
+        working-directory: velox
+    steps:
+
+      - name: Get Ccache Stash
+        uses: apache/infrastructure-actions/stash/restore@3354c1565d4b0e335b78a76aedd82153a9e144d4
+        with:
+          path: ${{ env.CCACHE_DIR }}
+          key: ccache-ubuntu-debug-bundled-deps
+
+      - name: Ensure Stash Dirs Exists
+        working-directory: ${{ github.workspace }}
+        run: |
+          mkdir -p "$CCACHE_DIR"
+
+      - uses: actions/checkout@v5
+        with:
+          path: velox
+          persist-credentials: false
+
+      - name: Install Dependencies
+        run: |
+          source scripts/setup-ubuntu.sh && install_apt_deps && install_faiss_deps
+
+      - name: Clear CCache Statistics
+        run: |
+          ccache -sz
+
+      - name: Make Debug Build
+        env:
+          VELOX_DEPENDENCY_SOURCE: BUNDLED
+          ICU_SOURCE: SYSTEM
+          MAKEFLAGS: NUM_THREADS=16 MAX_HIGH_MEM_JOBS=4 MAX_LINK_JOBS=2
+        run: |
+          EXTRA_CMAKE_FLAGS=(
+            "-DCMAKE_LINK_LIBRARIES_STRATEGY=REORDER_FREELY"
+            "-DVELOX_ENABLE_BENCHMARKS=ON"
+            "-DVELOX_ENABLE_EXAMPLES=ON"
+            "-DVELOX_ENABLE_ARROW=ON"
+            "-DVELOX_ENABLE_GEO=ON"
+            "-DVELOX_ENABLE_PARQUET=ON"
+            "-DVELOX_MONO_LIBRARY=ON"
+            "-DVELOX_BUILD_SHARED=ON"
+            "-DVELOX_ENABLE_FAISS=ON"
+            "-DVELOX_ENABLE_REMOTE_FUNCTIONS=ON"
+          )
+          make debug
+
+      - name: CCache after
+        run: |
+          ccache -vs
+
+      - uses: apache/infrastructure-actions/stash/save@3354c1565d4b0e335b78a76aedd82153a9e144d4
+        with:
+          path: ${{ env.CCACHE_DIR }}
+          key: ccache-ubuntu-debug-bundled-deps
+
+      - name: Run Tests
+        run: |
+          cd _build/debug && ctest -j 8 --output-on-failure --no-tests=error
diff --git a/.github/matchers/clang-tidy.json b/.github/matchers/clang-tidy.json
new file mode 100644
index 00000000000..1ae1bffc022
--- /dev/null
+++ b/.github/matchers/clang-tidy.json
@@ -0,0 +1,17 @@
+{
+    "problemMatcher": [
+        {
+            "owner": "clang-tidy",
+            "pattern": [
+                {
+                    "regexp": "^(.*):(\\d+):(\\d+):\\s+(error|warning):\\s+(.*) \\[([a-z0-9,\\-]+)\\]\\s*$",
+                    "file": 1,
+                    "line": 2,
+                    "column": 3,
+                    "severity": 4,
+                    "message": 5
+                }
+            ]
+        }
+    ]
+}
diff --git a/.github/matchers/gcc.json b/.github/matchers/gcc.json
new file mode 100644
index 00000000000..899239f8160
--- /dev/null
+++ b/.github/matchers/gcc.json
@@ -0,0 +1,18 @@
+{
+  "problemMatcher": [
+    {
+      "owner": "gcc",
+      "severity": "error",
+      "pattern": [
+        {
+          "regexp": "^(.*):(\\d+):(\\d+):\\s+(?:fatal\\s+)?(warning|error):\\s+(.*)$",
+          "file": 1,
+          "line": 2,
+          "column": 3,
+          "severity": 4,
+          "message": 5
+        }
+      ]
+    }
+  ]
+}
diff --git a/.github/matchers/shellcheck.json b/.github/matchers/shellcheck.json
new file mode 100644
index 00000000000..431d91ddd9f
--- /dev/null
+++ b/.github/matchers/shellcheck.json
@@ -0,0 +1,18 @@
+{
+  "problemMatcher": [
+    {
+      "owner": "shellcheck",
+      "severity": "error",
+      "pattern": [
+        {
+          "regexp": "^(.*):(\\d+):(\\d+):\\s+(?:fatal\\s+)?(warning|error):\\s+(.*)$",
+          "file": 1,
+          "line": 2,
+          "column": 3,
+          "severity": 4,
+          "message": 5
+        }
+      ]
+    }
+  ]
+}
diff --git a/.github/scripts/detect-build-impact.py b/.github/scripts/detect-build-impact.py
new file mode 100755
index 00000000000..6d6e31bbc22
--- /dev/null
+++ b/.github/scripts/detect-build-impact.py
@@ -0,0 +1,363 @@
+#!/usr/bin/env python3
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Detect build impact of changed files using the pre-computed dependency graph.
+
+Early exits:
+  - velox/experimental/ or velox/external/ changes → full build recommended
+    (CUDA-only and vendored code outside the dependency graph).
+
+File resolution:
+  For each changed file under velox/, resolves to affected CMake targets:
+  1. File API exact match (source file directly mapped to a target)
+  2. Header scan match (header → source files via g++ -MM → targets)
+  For headers, both results are unioned: exact match provides the owning
+  target, header scan provides all targets whose sources include the header.
+  Files that match neither are reported as unresolved.
+
+Then computes the transitive reverse dependency closure and identifies the
+minimal set of selective build targets.
+
+Usage:
+    python detect-build-impact.py \\
+        --graph dependency-graph.json \\
+        --changed-files changed_files.txt \\
+        --build-type release \\
+        --output comment.md
+"""
+
+import argparse
+import json
+import os
+from collections import defaultdict, deque
+
+
+def load_graph(graph_path: str) -> dict:
+    """Load the dependency graph JSON."""
+    with open(graph_path) as fp:
+        return json.load(fp)
+
+
+def resolve_file_to_targets(
+    file_path: str,
+    file_to_targets: dict[str, list[str]],
+    header_to_sources: dict[str, list[str]],
+) -> tuple[set[str], str]:
+    """Resolve a changed file to its affected targets.
+
+    Returns:
+        A tuple of (set of target names, resolution method string).
+    """
+    # Step 1: File API exact match (source or header directly in a target).
+    # Step 2: Header scan match (header → source files → targets).
+    # For headers, union both: exact gives the owning target, scan gives includers.
+    exact_targets = set(file_to_targets.get(file_path, []))
+    scan_targets: set[str] = set()
+
+    if file_path.endswith((".h", ".hpp", ".cuh")):
+        for source in header_to_sources.get(file_path, []):
+            scan_targets.update(file_to_targets.get(source, []))
+
+    combined = exact_targets | scan_targets
+    if combined:
+        if exact_targets and scan_targets:
+            method = "exact+header-scan"
+        elif exact_targets:
+            method = "exact"
+        else:
+            method = "header-scan"
+        return combined, method
+
+    return set(), "unresolved"
+
+
+def compute_reverse_deps(target_deps: dict[str, list[str]]) -> dict[str, set[str]]:
+    """Invert the dependency graph to get reverse dependencies."""
+    reverse: dict[str, set[str]] = defaultdict(set)
+    for target, deps in target_deps.items():
+        for dep in deps:
+            reverse[dep].add(target)
+    return reverse
+
+
+def compute_transitive_closure(
+    start_targets: set[str], reverse_deps: dict[str, set[str]]
+) -> set[str]:
+    """BFS from start_targets through reverse_deps to find all affected targets."""
+    visited = set()
+    queue = deque(start_targets)
+    while queue:
+        target = queue.popleft()
+        if target in visited:
+            continue
+        visited.add(target)
+        for dependent in reverse_deps.get(target, set()):
+            if dependent not in visited:
+                queue.append(dependent)
+    return visited
+
+
+def compute_selective_build_targets(
+    affected: set[str], target_deps: dict[str, list[str]]
+) -> set[str]:
+    """Find the minimal set of root targets that cover all affected targets.
+
+    These are affected targets that are not a dependency of any other
+    affected target.
+    """
+    depended_upon = set()
+    for target in affected:
+        for dep in target_deps.get(target, []):
+            if dep in affected:
+                depended_upon.add(dep)
+
+    return affected - depended_upon
+
+
+def generate_comment(
+    changed_targets: dict[str, dict],
+    all_affected: set[str],
+    selective_targets: set[str],
+    total_targets: int,
+    build_type: str,
+    graph_source: str,
+    unresolved_files: list[str],
+) -> str:
+    """Generate the PR comment markdown."""
+    total_affected = len(all_affected)
+
+    lines = []
+    lines.append("## Build Impact Analysis\n")
+
+    # Group changed files by target.
+    target_files: dict[str, list[str]] = defaultdict(list)
+    for file_path, info in changed_targets.items():
+        for target in info["targets"]:
+            target_files[target].append(os.path.basename(file_path))
+
+    # Selective build targets.
+    selective_sorted = sorted(selective_targets)
+    lines.append(
+        f"### Selective Build Targets "
+        f"(building these covers all {total_affected} affected)"
+    )
+    targets_str = " ".join(selective_sorted)
+    lines.append("```")
+    lines.append(f"cmake --build _build/{build_type} --target {targets_str}")
+    lines.append("```")
+    lines.append("")
+
+    lines.append(f"**Total affected:** {total_affected}/{total_targets} targets")
+    lines.append("")
+
+    # Unresolved files warning.
+    if unresolved_files:
+        lines.append(
+            f"> **Warning:** {len(unresolved_files)} file(s) could not be "
+            f"mapped to any target. A full build may be needed."
+        )
+        lines.append(">")
+        for f in unresolved_files[:10]:
+            lines.append(f"> - `{f}`")
+        if len(unresolved_files) > 10:
+            lines.append(f"> - ... and {len(unresolved_files) - 10} more")
+        lines.append("")
+
+    # Collapsible affected targets breakdown.
+    transitive_only = all_affected - set(target_files.keys())
+    lines.append("<details>")
+    lines.append(f"<summary>Affected targets ({total_affected})</summary>")
+    lines.append("")
+    lines.append(f"#### Directly changed ({len(target_files)})")
+    lines.append("")
+    lines.append("| Target | Changed Files |")
+    lines.append("|--------|--------------|")
+    for target in sorted(target_files.keys()):
+        files_list = sorted(set(target_files[target]))
+        files = ", ".join(files_list[:5])
+        if len(files_list) > 5:
+            files += f", ... (+{len(files_list) - 5} more)"
+        lines.append(f"| `{target}` | {files} |")
+    lines.append("")
+    if transitive_only:
+        lines.append(f"#### Transitively affected ({len(transitive_only)})")
+        lines.append("")
+        for target in sorted(transitive_only):
+            lines.append(f"- `{target}`")
+        lines.append("")
+    lines.append("</details>")
+    lines.append("")
+
+    # Footer.
+    lines.append("---")
+    lines.append(f"*{graph_source}*")
+
+    return "\n".join(lines)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Detect build impact of changed files."
+    )
+    parser.add_argument(
+        "--graph",
+        required=True,
+        help="Path to the dependency graph JSON file.",
+    )
+    parser.add_argument(
+        "--changed-files",
+        required=True,
+        help="Path to a file listing changed files (one per line).",
+    )
+    parser.add_argument(
+        "--build-type",
+        default="release",
+        help="Build type for the cmake command (default: release).",
+    )
+    parser.add_argument(
+        "--graph-source",
+        default="",
+        help="Description of graph source for the comment footer.",
+    )
+    parser.add_argument(
+        "--output",
+        default="comment.md",
+        help="Output file for the PR comment markdown (default: comment.md).",
+    )
+    args = parser.parse_args()
+
+    # Load inputs.
+    graph = load_graph(args.graph)
+    file_to_targets = graph["file_to_targets"]
+    header_to_sources = graph.get("header_to_sources", {})
+    target_deps = graph["target_deps"]
+    total_targets = len(target_deps)
+
+    with open(args.changed_files) as fp:
+        changed_files = [
+            line.strip() for line in fp if line.strip() and not line.startswith("#")
+        ]
+
+    # Check for experimental/ or external/ changes — these are outside
+    # the dependency graph (CUDA-only, vendored code) and need a full build.
+    full_build_prefixes = ("velox/experimental/", "velox/external/")
+    full_build_files = [f for f in changed_files if f.startswith(full_build_prefixes)]
+    if full_build_files:
+        comment = (
+            "## Build Impact Analysis\n\n"
+            "**Full build recommended.** Files outside the dependency graph changed:\n\n"
+        )
+        for f in full_build_files[:10]:
+            comment += f"- `{f}`\n"
+        if len(full_build_files) > 10:
+            comment += f"- ... and {len(full_build_files) - 10} more\n"
+        comment += (
+            "\nThese directories are not fully covered by the dependency graph. "
+            "A full build is the safest option.\n\n"
+            "```\n"
+            f"cmake --build _build/{args.build_type}\n"
+            "```\n\n"
+            "---\n"
+            f"*{args.graph_source or 'Build impact analysis'}*"
+        )
+        with open(args.output, "w") as fp:
+            fp.write(comment)
+        print("experimental/external files changed — full build recommended.")
+        return
+
+    # Only keep files under velox/ that can affect build targets.
+    source_files = []
+    skipped_files = []
+    for f in changed_files:
+        if f.startswith("velox/"):
+            source_files.append(f)
+        else:
+            skipped_files.append(f)
+    if skipped_files:
+        print(f"  Skipped {len(skipped_files)} non-source files")
+    changed_files = source_files
+
+    # Build lookup structures.
+    reverse_deps = compute_reverse_deps(target_deps)
+
+    # Resolve each changed file.
+    directly_affected: set[str] = set()
+    changed_targets: dict[str, dict] = {}
+    unresolved_files: list[str] = []
+
+    for file_path in changed_files:
+        targets, method = resolve_file_to_targets(
+            file_path,
+            file_to_targets,
+            header_to_sources,
+        )
+        if targets:
+            directly_affected.update(targets)
+            changed_targets[file_path] = {
+                "targets": sorted(targets),
+                "method": method,
+            }
+        else:
+            unresolved_files.append(file_path)
+
+    if not directly_affected:
+        comment = (
+            "## Build Impact Analysis\n\n"
+            "No build targets affected by this change.\n\n"
+            "---\n"
+            f"*{args.graph_source or 'Build impact analysis'}*"
+        )
+        with open(args.output, "w") as fp:
+            fp.write(comment)
+        print("No targets affected.")
+        return
+
+    # Compute transitive closure.
+    all_affected = compute_transitive_closure(directly_affected, reverse_deps)
+
+    # Compute selective build targets.
+    selective_targets = compute_selective_build_targets(all_affected, target_deps)
+
+    # Generate comment.
+    graph_source = args.graph_source or "Build impact analysis"
+    comment = generate_comment(
+        changed_targets,
+        all_affected,
+        selective_targets,
+        total_targets,
+        args.build_type,
+        graph_source,
+        unresolved_files,
+    )
+
+    with open(args.output, "w") as fp:
+        fp.write(comment)
+
+    print(f"Comment written to {args.output}")
+    print(f"  Directly affected targets: {len(directly_affected)}")
+    print(f"  Total affected (transitive): {len(all_affected)}")
+    print(f"  Selective build targets: {len(selective_targets)}")
+    if unresolved_files:
+        print(f"  Unresolved files: {len(unresolved_files)}")
+
+    # Also output the selective build targets as a simple list for CI use.
+    targets_file = os.path.splitext(args.output)[0] + "-targets.txt"
+    with open(targets_file, "w") as fp:
+        fp.write("\n".join(sorted(selective_targets)))
+    print(f"  Selective targets list: {targets_file}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.github/scripts/extract-test-failures.sh b/.github/scripts/extract-test-failures.sh
new file mode 100755
index 00000000000..ee2e29b37f8
--- /dev/null
+++ b/.github/scripts/extract-test-failures.sh
@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Extract failed test names, gtest cases, and failure details from ctest output.
+# Writes results to $GITHUB_OUTPUT as failed-tests, failed-cases, and
+# failure-details.
+#
+# Usage: extract-test-failures.sh <ctest-log-path>
+
+set -euo pipefail
+
+CTEST_LOG="$1"
+
+FAILED_TESTS=$(grep -A 1000 'The following tests FAILED:' "$CTEST_LOG" | grep -E '^\s+[0-9]+ - ' | sed 's/.*- \(.*\) (.*/\1/' | head -20 || true)
+FAILED_CASES=$(grep -E '^\[  FAILED  \]' "$CTEST_LOG" | sed 's/\[  FAILED  \] //' | sed 's/ (.*//' | grep '\.' | sort -u | head -20 || true)
+FAILURE_DETAILS=$(awk '/^\[ RUN      \]/{buf=$0; next} buf{buf=buf"\n"$0} /^\[  FAILED  \]/ && buf{print buf; buf=""} /^\[       OK \]/{buf=""}' "$CTEST_LOG" | head -200 || true)
+
+if [[ -n $FAILED_TESTS ]]; then
+  {
+    echo 'failed-tests<<EOF'
+    echo "$FAILED_TESTS"
+    echo 'EOF'
+  } >>"$GITHUB_OUTPUT"
+fi
+
+if [[ -n $FAILED_CASES ]]; then
+  {
+    echo 'failed-cases<<EOF'
+    echo "$FAILED_CASES"
+    echo 'EOF'
+  } >>"$GITHUB_OUTPUT"
+fi
+
+if [[ -n $FAILURE_DETAILS ]]; then
+  {
+    echo 'failure-details<<EOF'
+    echo "$FAILURE_DETAILS"
+    echo 'EOF'
+  } >>"$GITHUB_OUTPUT"
+fi
diff --git a/.github/scripts/generate-dependency-graph.py b/.github/scripts/generate-dependency-graph.py
new file mode 100755
index 00000000000..1e2f17d8c10
--- /dev/null
+++ b/.github/scripts/generate-dependency-graph.py
@@ -0,0 +1,341 @@
+#!/usr/bin/env python3
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Parse CMake File API codemodel output and generate a dependency graph JSON.
+
+This script reads the CMake File API reply directory (codemodel-v2) and
+produces a JSON file containing:
+  - file_to_targets: mapping of source file paths to their owning targets
+  - target_deps: mapping of each target to its direct dependencies
+  - header_to_sources: mapping of header file paths to source files that
+    include them (via g++ -MM scanning of compile_commands.json)
+
+The total target count can be derived from len(target_deps).
+
+Usage:
+    python generate-dependency-graph.py \\
+        --build-dir _build/release \\
+        --source-dir . \\
+        --output dependency-graph.json
+"""
+
+import argparse
+import json
+import os
+import re
+import shlex
+import subprocess
+import sys
+from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+
+def find_codemodel_reply(reply_dir: Path) -> dict:
+    """Find and parse the codemodel reply index file."""
+    for f in sorted(reply_dir.iterdir()):
+        if f.name.startswith("codemodel-v2-") and f.suffix == ".json":
+            with open(f) as fp:
+                return json.load(fp)
+    print("ERROR: No codemodel-v2 reply found in", reply_dir, file=sys.stderr)
+    sys.exit(1)
+
+
+def parse_target_file(reply_dir: Path, target_json_file: str) -> dict:
+    """Parse a single target JSON file from the file API reply."""
+    target_path = reply_dir / target_json_file
+    with open(target_path) as fp:
+        return json.load(fp)
+
+
+def build_dependency_graph(
+    build_dir: str, source_dir: str
+) -> tuple[dict[str, list[str]], dict[str, list[str]]]:
+    """Build the dependency graph from CMake File API output.
+
+    Returns:
+        file_to_targets: maps relative source file paths to list of target names
+        target_deps: maps each target name to its direct dependency target names
+    """
+    reply_dir = Path(build_dir) / ".cmake" / "api" / "v1" / "reply"
+    if not reply_dir.exists():
+        print("ERROR: File API reply directory not found:", reply_dir, file=sys.stderr)
+        print(
+            "Ensure cmake was configured with the file API query file.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    source_dir = os.path.realpath(source_dir)
+    build_dir_real = os.path.realpath(build_dir)
+
+    codemodel = find_codemodel_reply(reply_dir)
+
+    file_to_targets: dict[str, list[str]] = {}
+    target_deps: dict[str, list[str]] = {}
+
+    configurations = codemodel.get("configurations", [])
+    if not configurations:
+        print("ERROR: No configurations found in codemodel reply.", file=sys.stderr)
+        sys.exit(1)
+
+    config = configurations[0]
+    targets = config.get("targets", [])
+
+    # Build an ID-to-name lookup to avoid re-parsing target files for deps.
+    id_to_name: dict[str, str] = {}
+    target_data_cache: dict[str, dict] = {}
+    for target_ref in targets:
+        target_json_file = target_ref["jsonFile"]
+        target_data = parse_target_file(reply_dir, target_json_file)
+        target_id = target_ref.get("id", "")
+        target_name = target_data["name"]
+        id_to_name[target_id] = target_name
+        target_data_cache[target_id] = target_data
+
+    for target_ref in targets:
+        target_id = target_ref.get("id", "")
+        target_data = target_data_cache[target_id]
+        target_name = id_to_name[target_id]
+
+        # Extract source files.
+        for source in target_data.get("sources", []):
+            source_path = source.get("path", "")
+            if not source_path:
+                continue
+
+            # Resolve to absolute then make relative to source dir.
+            if not os.path.isabs(source_path):
+                abs_path = os.path.normpath(os.path.join(source_dir, source_path))
+            else:
+                abs_path = os.path.normpath(source_path)
+
+            # Skip generated files (those in the build directory).
+            if abs_path.startswith(build_dir_real):
+                continue
+
+            # Make path relative to source directory.
+            try:
+                rel_path = os.path.relpath(abs_path, source_dir)
+            except ValueError:
+                continue
+
+            # Skip paths outside the source tree.
+            if rel_path.startswith(".."):
+                continue
+
+            if rel_path not in file_to_targets:
+                file_to_targets[rel_path] = []
+            if target_name not in file_to_targets[rel_path]:
+                file_to_targets[rel_path].append(target_name)
+
+        # Extract dependencies.
+        dep_names = []
+        for dep in target_data.get("dependencies", []):
+            dep_id = dep.get("id", "")
+            if dep_id in id_to_name:
+                dep_names.append(id_to_name[dep_id])
+        target_deps[target_name] = dep_names
+
+    return file_to_targets, target_deps
+
+
+def extract_flags(command: str) -> list[str]:
+    """Extract include paths, defines, and std flag from a compile command."""
+    flags = []
+    try:
+        tokens = shlex.split(command)
+    except ValueError:
+        return flags
+
+    i = 0
+    while i < len(tokens):
+        tok = tokens[i]
+        if tok in ("-I", "-isystem", "-D") and i + 1 < len(tokens):
+            flags.extend([tok, tokens[i + 1]])
+            i += 2
+        elif tok.startswith(("-I", "-isystem", "-D")):
+            flags.append(tok)
+            i += 1
+        elif re.match(r"-std=", tok):
+            flags.append(tok)
+            i += 1
+        else:
+            i += 1
+    return flags
+
+
+def scan_one_file(
+    entry: dict,
+) -> tuple[str, list[str]]:
+    """Run g++ -MM -MG on a single compile_commands.json entry.
+
+    Returns (source_file_path, [header_paths]) or (source_file_path, [])
+    on failure.
+    """
+    source_file = entry["file"]
+    directory = entry.get("directory", ".")
+    command = entry.get("command", "")
+    if not command:
+        args = entry.get("arguments", [])
+        command = " ".join(shlex.quote(a) for a in args)
+
+    flags = extract_flags(command)
+    cmd = ["g++", "-MM", "-MG"] + flags + [source_file]
+
+    try:
+        result = subprocess.run(
+            cmd,
+            cwd=directory,
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+    except (subprocess.TimeoutExpired, OSError) as e:
+        print(f"  WARNING: g++ -MM failed for {source_file}: {e}", file=sys.stderr)
+        return source_file, []
+
+    if result.returncode != 0:
+        return source_file, []
+
+    # Parse make-style output: target.o: source.cpp header1.h header2.h ...
+    output = result.stdout.replace("\\\n", " ")
+    colon_idx = output.find(":")
+    if colon_idx == -1:
+        return source_file, []
+
+    deps_str = output[colon_idx + 1 :]
+    deps = deps_str.split()
+    # First entry is the source file itself; remaining are headers.
+    headers = deps[1:] if len(deps) > 1 else []
+    return source_file, headers
+
+
+def scan_header_deps(build_dir: str, source_dir: str) -> dict[str, list[str]]:
+    """Scan compile_commands.json with g++ -MM to build header_to_sources map."""
+    compile_commands_path = os.path.join(build_dir, "compile_commands.json")
+    if not os.path.exists(compile_commands_path):
+        print(
+            "WARNING: compile_commands.json not found, skipping header scan.",
+            file=sys.stderr,
+        )
+        return {}
+
+    with open(compile_commands_path) as fp:
+        entries = json.load(fp)
+
+    print(f"  Scanning {len(entries)} compilation units with g++ -MM ...")
+    source_dir_real = os.path.realpath(source_dir)
+    build_dir_real = os.path.realpath(build_dir)
+
+    header_to_sources: dict[str, set[str]] = defaultdict(set)
+    workers = os.cpu_count() or 4
+
+    with ThreadPoolExecutor(max_workers=workers) as executor:
+        results = executor.map(scan_one_file, entries)
+        scanned = 0
+        failed = 0
+        for source_file, headers in results:
+            if not headers:
+                failed += 1
+                continue
+            scanned += 1
+
+            # Normalize source path relative to source dir.
+            if os.path.isabs(source_file):
+                source_abs = os.path.normpath(source_file)
+            else:
+                # Resolve relative to the entry's directory — but we
+                # don't have it here.  The source_file in
+                # compile_commands.json is typically absolute.
+                source_abs = os.path.normpath(
+                    os.path.join(source_dir_real, source_file)
+                )
+
+            if source_abs.startswith(build_dir_real):
+                continue
+            try:
+                rel_source = os.path.relpath(source_abs, source_dir_real)
+            except ValueError:
+                continue
+            if rel_source.startswith(".."):
+                continue
+
+            for header in headers:
+                header_abs = os.path.normpath(header)
+                if not os.path.isabs(header_abs):
+                    continue
+                if header_abs.startswith(build_dir_real):
+                    continue
+                try:
+                    rel_header = os.path.relpath(header_abs, source_dir_real)
+                except ValueError:
+                    continue
+                if rel_header.startswith(".."):
+                    continue
+                header_to_sources[rel_header].add(rel_source)
+
+    # Convert sets to sorted lists for JSON serialization.
+    result = {k: sorted(v) for k, v in header_to_sources.items()}
+    print(f"  Header scan complete: {scanned} succeeded, {failed} failed")
+    print(f"  Headers mapped: {len(result)}")
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate dependency graph from CMake File API output."
+    )
+    parser.add_argument(
+        "--build-dir",
+        required=True,
+        help="Path to the CMake build directory.",
+    )
+    parser.add_argument(
+        "--source-dir",
+        default=".",
+        help="Path to the source directory (default: current directory).",
+    )
+    parser.add_argument(
+        "--output",
+        default="dependency-graph.json",
+        help="Output JSON file path (default: dependency-graph.json).",
+    )
+    args = parser.parse_args()
+
+    file_to_targets, target_deps = build_dependency_graph(
+        args.build_dir, args.source_dir
+    )
+
+    # Phase 2: Scan header dependencies via g++ -MM.
+    header_to_sources = scan_header_deps(args.build_dir, args.source_dir)
+
+    graph = {
+        "file_to_targets": file_to_targets,
+        "header_to_sources": header_to_sources,
+        "target_deps": target_deps,
+    }
+
+    with open(args.output, "w") as fp:
+        json.dump(graph, fp, indent=2, sort_keys=True)
+
+    print(f"Dependency graph written to {args.output}")
+    print(f"  Files mapped: {len(file_to_targets)}")
+    print(f"  Headers mapped: {len(header_to_sources)}")
+    print(f"  Targets: {len(target_deps)}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.github/scripts/report-build-status.sh b/.github/scripts/report-build-status.sh
new file mode 100755
index 00000000000..2e95cd645bd
--- /dev/null
+++ b/.github/scripts/report-build-status.sh
@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Report build status and create failure metadata artifact.
+#
+# Usage: report-build-status.sh <job-name>
+#
+# Required environment variables:
+#   BUILD_OUTCOME         - build step outcome (success/failure/cancelled)
+#   BUILD_FAILURE_DETAILS - compiler errors extracted from build output (optional)
+
+set -euo pipefail
+
+JOB_NAME="$1"
+
+if [[ -z $BUILD_OUTCOME || $BUILD_OUTCOME == "cancelled" ]]; then
+  echo "Build was cancelled (likely superseded by a newer push). Skipping."
+  exit 0
+fi
+
+if [[ $BUILD_OUTCOME != "success" ]]; then
+  echo "::error::${JOB_NAME} build failed. Do not land this PR until the build is fixed."
+
+  if [[ -n ${BUILD_FAILURE_DETAILS:-} ]]; then
+    echo ""
+    echo "Build errors:"
+    echo "----------------------------------------"
+    echo "$BUILD_FAILURE_DETAILS"
+    echo "----------------------------------------"
+  fi
+
+  # Write failure metadata for the CI failure analysis workflow.
+  mkdir -p /tmp/ci-failure
+  jq -n --arg job "$JOB_NAME" --arg type "build" \
+    '{job: $job, type: $type}' \
+    >/tmp/ci-failure/failure.json
+
+  exit 1
+fi
+
+echo "Build succeeded."
diff --git a/.github/scripts/report-test-status.sh b/.github/scripts/report-test-status.sh
new file mode 100755
index 00000000000..553c3fcc9f9
--- /dev/null
+++ b/.github/scripts/report-test-status.sh
@@ -0,0 +1,95 @@
+#!/usr/bin/env bash
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Report test status and create failure metadata artifact.
+#
+# Usage: report-test-status.sh <job-name> <config-name>
+#
+# Required environment variables:
+#   BUILD_OUTCOME  - build step outcome (success/failure/cancelled)
+#   TEST_OUTCOME   - test step outcome (success/failure/cancelled)
+#   FLAKY          - "true" if tests were flaky (failed then passed on retry)
+#   FAILED_TESTS    - newline-separated list of failed ctest targets (optional)
+#   FAILED_CASES    - newline-separated list of failed gtest cases (optional)
+#   FAILURE_DETAILS - gtest output for failing tests (optional)
+
+set -euo pipefail
+
+JOB_NAME="$1"
+CONFIG_NAME="$2"
+
+if [[ -z $BUILD_OUTCOME || $BUILD_OUTCOME == "cancelled" ]]; then
+  echo "Run was cancelled (likely superseded by a newer push). Skipping."
+  exit 0
+fi
+
+if [[ $BUILD_OUTCOME != "success" ]]; then
+  echo "::error::Build failed — tests did not run. Check the '${JOB_NAME}' build job for compiler errors and build logs."
+  exit 1
+fi
+
+if [[ -z $TEST_OUTCOME || $TEST_OUTCOME == "cancelled" ]]; then
+  echo "Tests were cancelled (likely superseded by a newer push). Skipping."
+  exit 0
+fi
+
+if [[ $TEST_OUTCOME != "success" ]]; then
+  if [[ -n $FAILED_CASES ]]; then
+    CASE_LIST=$(echo "$FAILED_CASES" | sed 's/^/  - /')
+    CASE_COUNT=$(echo "$FAILED_CASES" | wc -l | tr -d ' ')
+    echo "::error::${CASE_COUNT} test case(s) failed in the ${CONFIG_NAME} configuration. Failed: $(echo "$FAILED_CASES" | tr '\n' ', ' | sed 's/,$//'). To see the full test output with failure details, click the '${JOB_NAME}' job in the workflow run, then expand the 'Run Tests' step."
+    echo ""
+    echo "Failed test cases:"
+    echo "$CASE_LIST"
+  elif [[ -n $FAILED_TESTS ]]; then
+    TEST_LIST=$(echo "$FAILED_TESTS" | sed 's/^/  - /')
+    TEST_COUNT=$(echo "$FAILED_TESTS" | wc -l | tr -d ' ')
+    echo "::error::${TEST_COUNT} test(s) failed in the ${CONFIG_NAME} configuration. Failed tests: $(echo "$FAILED_TESTS" | tr '\n' ', ' | sed 's/,$//'). To see the full test output with failure details, click the '${JOB_NAME}' job in the workflow run, then expand the 'Run Tests' step."
+    echo ""
+    echo "Failed tests:"
+    echo "$TEST_LIST"
+  else
+    echo "::error::Tests failed in the ${CONFIG_NAME} configuration but no specific test names were captured. Check the 'Run Tests' step in the '${JOB_NAME}' job for details."
+  fi
+  if [[ -n ${FAILURE_DETAILS:-} ]]; then
+    echo ""
+    echo "Failure details:"
+    echo "$FAILURE_DETAILS"
+  fi
+  echo ""
+  echo "To investigate, click the '${JOB_NAME}' job in the workflow run, then expand the 'Run Tests' step for the full ctest output with assertion failures and stack traces."
+
+  # Write failure metadata for the CI failure analysis workflow.
+  mkdir -p /tmp/ci-failure
+  if [[ -n $FAILED_CASES ]]; then
+    TESTS="$FAILED_CASES"
+  elif [[ -n $FAILED_TESTS ]]; then
+    TESTS="$FAILED_TESTS"
+  else
+    TESTS=""
+  fi
+  jq -n --arg job "$JOB_NAME" \
+    --arg type "test" \
+    --arg failed_tests "$TESTS" \
+    '{job: $job, type: $type, failed_tests: $failed_tests}' \
+    >/tmp/ci-failure/failure.json
+
+  exit 1
+fi
+
+if [[ $FLAKY == "true" ]]; then
+  echo "::warning::Some tests were flaky (failed then passed on retry)."
+fi
+echo "All tests passed in ${CONFIG_NAME}."
diff --git a/.github/workflows/README.md b/.github/workflows/README.md
new file mode 100644
index 00000000000..2e36c71c0a6
--- /dev/null
+++ b/.github/workflows/README.md
@@ -0,0 +1,152 @@
+# CI Workflows
+
+Velox CI validates builds and tests across Linux (GCC and optionally Clang) and macOS (Apple Clang). Linux workflows run full unit test suites in Docker containers on 32-core runners; macOS workflows verify compilation only. Fuzzer workflows stress-test functions and operators with randomized inputs.
+
+### Why Docker containers?
+
+Velox has a [large dependency footprint](../../CMake/resolve_dependency_modules/README.md) — over 20 third-party libraries. Installing and version-pinning these on bare runners would be fragile and slow. Instead, the `docker.yml` workflow builds pre-configured Docker images (`ghcr.io/facebookincubator/velox-dev`) with all dependencies pre-installed. CI build jobs run inside these containers, ensuring reproducible environments and fast startup. The images come in several variants:
+
+- **`centos9`** — Base CentOS Stream 9 environment used by fuzzer workflows
+- **`adapters`** — Full environment with cloud storage adapters (S3, GCS, ABFS, HDFS) and GPU support
+- **`ubuntu`** — Standard Ubuntu 22.04 build environment
+- **`fedora`** — Fedora environment for testing against different system package versions (e.g., system-provided gRPC, Arrow, Thrift)
+- **`presto-java`** / **`spark-server`** — Images with Presto/Spark servers for fuzzer reference result verification
+
+The `centos9` and `adapters` images are multi-architecture (amd64 + arm64); the `ubuntu` and `fedora` images are amd64-only. Images are rebuilt automatically when Dockerfiles or setup scripts change on `main`. On macOS, dependencies are installed directly via `setup-macos.sh` using Homebrew since Docker is not used.
+
+For current build times and performance trends, see the [CI performance metrics](https://github.com/facebookincubator/velox/actions/metrics/performance).
+
+| Workflow | File | Triggers | Purpose |
+|----------|------|----------|---------|
+| Linux Build using GCC | `linux-build.yml` + `linux-build-base.yml` | push to main, PRs | Main build & test (3 configs) |
+| macOS Build | `macos.yml` | push, PRs | Compilation check (debug + release) |
+| Breeze Linux Build | `breeze.yml` | push to main, PRs | Tracing module with sanitizers |
+| Fuzzer Jobs | `scheduled.yml` | PRs, push to main, daily cron, manual | Randomized correctness testing |
+| Run Checks | `preliminary_checks.yml` | PRs | Formatting, linting, PR title |
+| Build Impact Analysis | `build-impact.yml` + `build-impact-comment.yml` | push to main, PRs | CMake dependency impact |
+| CI Failure Comment | `ci-failure-comment.yml` | workflow_run (on Linux Build / Fuzzer failure) | AI-powered failure analysis on PRs |
+| Claude PR Assistants | `claude.yml` + `claude-review.yml` | PR comments (`@claude`) | AI code review |
+| Build Pyvelox Wheels | `build_pyvelox.yml` | manual | Python wheel packaging |
+| Docker Images | `docker.yml` | push to main, manual | Multi-arch Docker images |
+| Weekly Date Tag | `tag.yml` | weekly cron, manual | Version tagging |
+| Update Documentation | `docs.yml` | push (docs changes), PRs | Sphinx docs + GitHub Pages |
+| Collect Build Metrics | `build-metrics.yml` | PRs, daily, manual | Binary size tracking (disabled) |
+| Ubuntu Bundled Deps | `ubuntu-bundled-deps.yml` | nightly, manual, PRs (dep scripts) | Build-from-source validation |
+
+## Core Build & Test
+
+### Linux Build using GCC (`linux-build.yml` + `linux-build-base.yml`)
+
+The main CI workflow for Velox. Triggered on pushes to `main` and on pull requests when relevant files change (source code, CMake files, setup scripts, or the workflow files themselves). The entry point `linux-build.yml` delegates to the reusable `linux-build-base.yml` template, which builds and tests three configurations in parallel on 32-core Ubuntu runners:
+
+- **Linux adapters release** — Release build using the `velox-dev:adapters` Docker image. Enables cloud storage adapters (S3, GCS, ABFS, HDFS), Parquet, Arrow, geospatial functions, and GPU support (WAVE, cuDF). Tests run with `ctest -j 24` and a 900-second timeout. When cuDF-related files change, a separate cuDF test job runs on a `4-core-ubuntu-gpu-t4` GPU runner.
+- **Ubuntu debug** — Debug build using the `velox-dev:ubuntu-22.04` Docker image. Enables benchmarks, examples, Arrow, geospatial, Parquet, shared library (`VELOX_BUILD_SHARED=ON`), and mono library modes. Tests run with `ctest -j 24` and a 1800-second timeout.
+- **Fedora debug** — Debug build using the `velox-dev:fedora` Docker image. Validates compilation compatibility with Fedora's system packages including system-provided gRPC and Arrow/Thrift shared libraries. This configuration focuses on compiler and OS compatibility rather than test coverage — it does not have a separate test status job.
+
+All configurations use ccache for build acceleration (persisted via Apache infrastructure stash). The adapters and ubuntu-debug configurations include a flaky test retry mechanism: if any tests fail on the first run, they are automatically retried with `ctest --rerun-failed`. If the retry passes, the tests are marked as flaky; if it fails again, the specific failed test case names are extracted and reported.
+
+#### BUILD / TEST status jobs and `continue-on-error`
+
+Each configuration has separate BUILD and TEST status jobs that appear as independent checks on PRs. This design solves a specific problem: developers need to immediately see whether a CI failure is a build failure (absolute blocker) or a test failure (could be flaky, needs investigation).
+
+The obvious approach — splitting build and test into separate GitHub Actions jobs — is impractical for Velox because the build artifacts are too large to transfer between jobs. Test binaries are ~3GB each (8 grouped binaries totaling ~24GB), plus the shared `libvelox.so` mono library. We tried multiple compression strategies in PR #16938 (tar+gzip, pigz, zstd, direct upload) and all either exceeded the test runtime or were incompatible with the container environment. Stripping debug symbols would defeat the purpose of a debug build. The sequential overhead of packaging, uploading, downloading, and extracting artifacts negates any parallelism gains.
+
+Instead, the test step uses `continue-on-error: true` so the main job always completes, and lightweight status jobs read the step outcomes to provide separate pass/fail signals. The main job (which contains the full test output) appears green even when tests fail, but the status jobs compensate in two ways: (1) failed test names, gtest case names, and failure details (assertion messages, compiler errors) are forwarded to the status jobs via job output variables and displayed directly in the status job logs and as `::error::` annotations, so developers clicking the red check see the specific failures immediately; (2) the `ci-failure-comment.yml` workflow uses Claude to analyze the full logs and post a rich diagnostic comment directly on the PR.
+
+Status jobs handle cancelled runs gracefully — when a job is cancelled (e.g., superseded by a newer push), status jobs exit cleanly without false "build failed" reports.
+
+### macOS Build (`macos.yml`)
+
+Builds Velox on macOS 15 (ARM64/Apple Silicon) with both debug and release configurations. Triggered on pushes to any branch and on pull requests when relevant files change. Uses the Ninja build generator and ccache for faster builds. Tests are currently disabled on macOS — the workflow focuses on ensuring compilation compatibility with Apple's toolchain rather than full test coverage. Dependencies are installed via the `setup-macos.sh` script.
+
+### Breeze Linux Build (`breeze.yml`)
+
+Experimental workflow for the Breeze tracing/profiling module and Perfetto integration. Builds two configurations: a debug build with Address Sanitizer (ASAN) and Undefined Behavior Sanitizer (UBSAN) enabled for memory safety testing, and a RelWithDebInfo build with CUDA support for the Breeze module. Unlike the main Linux build, Breeze uses `VELOX_DEPENDENCY_SOURCE=BUNDLED` to build dependencies from source rather than using system packages. Tests run with `ctest -j 8` under sanitizers.
+
+## Fuzzing (`scheduled.yml`)
+
+A comprehensive fuzzing suite that tests Velox functions and operators against random inputs to catch correctness issues. Triggered on pull requests, pushes to `main`, a daily cron schedule (`0 3 * * *` UTC), and manual `workflow_dispatch`. The daily and main-push triggers are particularly important as they catch regressions that may not be exercised by PR-level test coverage.
+
+The workflow first compiles all fuzzer binaries in a shared `compile` job, then runs 12+ independent fuzzer targets in parallel:
+
+- **Presto Fuzzer** and **Spark Fuzzer** — Test Presto and Spark SQL function implementations with random inputs and verify results against reference implementations (DuckDB for Presto, Spark for Spark functions).
+- **Aggregation Fuzzers** — Test aggregate functions with random grouping keys and inputs, with Presto as source of truth.
+- **Join Fuzzer** — Tests hash join, merge join, and nested loop join operators with random schemas and data.
+- **Exchange Fuzzer** — Tests the data exchange/shuffle operator.
+- **Window Fuzzer** — Tests window function implementations.
+- **Writer Fuzzer** — Tests file format writers (Parquet, DWRF).
+- **RowNumber and TopNRowNumber Fuzzers** — Test row numbering operators.
+- **Table Evolution Fuzzer** — Tests schema evolution scenarios.
+- **Memory Arbitration Fuzzer** — Tests memory management under pressure.
+- **Spatial Join Fuzzer** — Tests geospatial join operations.
+- **Cache Fuzzer** — Tests caching infrastructure.
+
+The workflow also includes bias fuzzers that focus specifically on newly added or recently updated functions, and a signature check job that validates function signatures match expected interfaces.
+
+## PR Checks & Feedback
+
+### Run Checks (`preliminary_checks.yml`)
+
+Runs early validation on pull requests before the heavier build workflows. Executes `pre-commit run --all-files` to check code formatting (clang-format), linting (yamllint, zizmor), license headers, and other code quality rules. Also validates the PR title against the conventional commits format (`type(scope): description`), which is required for all PRs.
+
+### Build Impact Analysis (`build-impact.yml` + `build-impact-comment.yml`)
+
+Analyzes which build targets are affected by the files changed in a PR using the CMake dependency graph. On pushes to `main`, the workflow generates and caches a fresh dependency graph. On PRs, it uses a two-path strategy: a fast path that reuses the cached graph from `main`, and a slow path that regenerates the graph when CMake files change. The companion `build-impact-comment.yml` workflow posts the analysis results as a PR comment, updating the existing comment if one already exists.
+
+### CI Failure Comment (`ci-failure-comment.yml`)
+
+Analyzes CI failures and posts diagnostic comments on PRs. Triggered via `workflow_run` when the "Linux Build using GCC" or "Fuzzer Jobs" workflow completes with a failure. The workflow finds the associated PR, downloads failure metadata artifacts uploaded by the status jobs in `linux-build-base.yml` (or, for fuzzer failures, queries the GitHub API for failed job names), then uses Claude to analyze the failures. Claude fetches the full job logs via the GitHub API, reads the PR diff, searches open issues for known failures, and checks recent main branch CI runs for pre-existing flaky tests. The resulting PR comment includes specific failure details (assertion errors, compiler diagnostics), correlation analysis with the PR changes, links to known issues, and recommended fixes. Also supports manual triggering via `workflow_dispatch` with a run ID and PR number.
+
+Uses the `workflow_run` pattern because fork PRs have read-only tokens and cannot post comments directly.
+
+### Claude PR Assistants (`claude.yml` + `claude-review.yml`)
+
+Two AI-powered code review workflows. The newer `claude.yml` uses a skill-based approach triggered by `@claude` mentions in PR comments, restricted to an authorized user allowlist. The legacy `claude-review.yml` supports `/claude-review` (full code review) and `/claude-query` (targeted questions) commands, parsing PR diffs and generating detailed review feedback with file-by-file analysis, risk assessment, and testing recommendations.
+
+## Packaging & Release
+
+### Build Pyvelox Wheels (`build_pyvelox.yml`)
+
+Builds Python wheel packages for PyVelox across multiple Python versions (3.10–3.13) and platforms (Ubuntu, macOS Intel, macOS ARM). Uses `cibuildwheel` for cross-platform wheel building. Triggered via `workflow_dispatch` and on PRs that modify the workflow file. Optionally publishes to PyPI on success.
+
+### Docker Images (`docker.yml`)
+
+Builds and pushes the Docker images described in the [Why Docker containers?](#why-docker-containers) section above. Uses Docker Buildx with BuildKit for multi-arch support (amd64 + arm64) and registry-based layer caching. Triggered on pushes to `main` when Dockerfiles or setup scripts change, and on manual dispatch.
+
+### Weekly Date Tag (`tag.yml`)
+
+Automatically creates weekly date-based version tags (e.g., `v2026.04.03.00`) every Friday at 09:23 UTC. Checks CI status before tagging to ensure only successful builds are released. Also supports manual triggering via `workflow_dispatch`.
+
+## Documentation & Metrics
+
+### Update Documentation (`docs.yml`)
+
+Builds Sphinx documentation when files under `velox/docs/` change on pushes or pull requests. Publishes to GitHub Pages only on pushes to the official `facebookincubator/velox` repository. Includes PyVelox Python API documentation. On pull requests, validates that documentation builds without errors but does not deploy.
+
+### Collect Build Metrics (`build-metrics.yml`)
+
+Measures binary sizes across four build configurations (debug/release x shared/static) and was designed to upload metrics to conbench for performance regression tracking. Currently disabled because the conbench service is unavailable. Triggered on PRs, daily schedule, and manual dispatch.
+
+## Dependency Testing
+
+### Ubuntu Bundled Dependencies (`ubuntu-bundled-deps.yml`)
+
+Tests that Velox can be built entirely from source on a plain Ubuntu system without pre-installed dependencies (except ICU). Uses `VELOX_DEPENDENCY_SOURCE=BUNDLED` to build all dependencies from source, validating the bundled dependency resolution scripts. Runs on a 16-core runner (no Docker container) with 16 build threads. Includes a comprehensive set of feature flags: benchmarks, examples, Arrow, geospatial, Parquet, mono library, shared library, FAISS, and remote functions. Tests run with `ctest -j 8`. Runs nightly at 5 AM UTC, on manual dispatch, and on PRs that modify dependency scripts. Only runs on the official `facebookincubator/velox` repository, not forks.
+
+## Architecture Notes
+
+### Fork PR Permissions
+
+GitHub restricts fork PR tokens to read-only for security. Workflows that need to post PR comments use the **`workflow_run` pattern**: the main workflow uploads results as artifacts, and a separate `workflow_run`-triggered workflow downloads them and posts comments using the base repo's write permissions.
+
+This pattern is used by:
+- `build-impact-comment.yml` (posts build impact analysis)
+- `ci-failure-comment.yml` (posts CI failure analysis)
+
+### Build Caching
+
+All build workflows use ccache for compiler output caching, persisted across runs using Apache infrastructure stash actions. Cache keys include the platform, build type, and compiler to avoid cache collisions.
+
+### Concurrency
+
+Most workflows use concurrency groups keyed on `workflow + repository + branch/SHA` to automatically cancel in-progress runs when new commits are pushed to the same branch, avoiding wasted CI resources.
diff --git a/.github/workflows/linux-build.yml b/.github/workflows/linux-build.yml
index c2885d2fb56..0b9020be107 100644
--- a/.github/workflows/linux-build.yml
+++ b/.github/workflows/linux-build.yml
@@ -30,7 +30,7 @@ concurrency:
 jobs:
   adapters:
     name: Linux release with adapters
-    runs-on: linux-amd64-gpu-l4-latest-1
+    runs-on: linux-amd64-cpu16
     container: ghcr.io/facebookincubator/velox-dev:adapters
     defaults:
       run:
@@ -44,46 +44,38 @@ jobs:
       Arrow_SOURCE: BUNDLED
       Thrift_SOURCE: BUNDLED
       cudf_SOURCE: BUNDLED
-      CUDA_VERSION: "12.8"
+      CUDA_VERSION: "12.9"
     steps:
       - uses: actions/checkout@v4
         with:
           persist-credentials: false
 
       - name: Fix git permissions
-        # Usually actions/checkout does this but as we run in a container
-        # it doesn't work
         run: git config --global --add safe.directory ${GITHUB_WORKSPACE}
 
       - name: Install Dependencies
         run: |
-          # Allows to install arbitrary cuda-version whithout needing to update
-          # docker container before. It simplifies testing new/different versions
           if ! yum list installed cuda-nvcc-$(echo ${CUDA_VERSION} | tr '.' '-') 1>/dev/null || \
              ! yum list installed libnvjitlink-devel-$(echo ${CUDA_VERSION} | tr '.' '-') 1>/dev/null; then
             source scripts/setup-centos-adapters.sh
             install_cuda ${CUDA_VERSION}
           fi
-
-          # TODO: Install a newer cmake here until we update the images upstream
           pip install cmake==3.30.4
 
       - uses: apache/infrastructure-actions/stash/restore@3354c1565d4b0e335b78a76aedd82153a9e144d4
         with:
-          path: '${{ env.CCACHE_DIR }}'
+          path: "${{ env.CCACHE_DIR }}"
           key: ccache-linux-adapters
 
       - name: Zero Ccache Statistics
-        run: |
-          ccache -sz
+        run: ccache -sz
 
       - name: Make Release Build
         env:
           MAKEFLAGS: TREAT_WARNINGS_AS_ERRORS=0 NUM_THREADS=16 MAX_HIGH_MEM_JOBS=4
           CUDA_ARCHITECTURES: 70
           CUDA_COMPILER: /usr/local/cuda-${CUDA_VERSION}/bin/nvcc
-          # Set compiler to GCC 12
-          CUDA_FLAGS: -ccbin /opt/rh/gcc-toolset-12/root/usr/bin
+          CUDA_FLAGS: -ccbin /opt/rh/gcc-toolset-14/root/usr/bin
         run: |
           EXTRA_CMAKE_FLAGS=(
             "-DVELOX_ENABLE_BENCHMARKS=ON"
@@ -98,29 +90,117 @@ jobs:
             "-DVELOX_ENABLE_CUDF=ON"
             "-DVELOX_MONO_LIBRARY=ON"
           )
-          make release EXTRA_CMAKE_FLAGS="${EXTRA_CMAKE_FLAGS[*]}"
+          source /opt/rh/gcc-toolset-14/enable
+          CC=gcc CXX=g++ make release EXTRA_CMAKE_FLAGS="${EXTRA_CMAKE_FLAGS[*]}"
 
       - name: Ccache after
         run: ccache -s
 
       - uses: apache/infrastructure-actions/stash/save@3354c1565d4b0e335b78a76aedd82153a9e144d4
         with:
-          path: '${{ env.CCACHE_DIR }}'
+          path: "${{ env.CCACHE_DIR }}"
           key: ccache-linux-adapters
 
-      - name: Run Tests
+      - name: Run non-GPU tests
         env:
           LIBHDFS3_CONF: "${{ github.workspace }}/scripts/hdfs-client.xml"
         working-directory: _build/release
         run: |
-          # Can be removed after images are rebuild
           if [ -f "/opt/miniforge/etc/profile.d/conda.sh" ]; then
             source "/opt/miniforge/etc/profile.d/conda.sh"
             conda activate adapters
           fi
 
           export CLASSPATH=`/usr/local/hadoop/bin/hdfs classpath --glob`
-          ctest -j 8 --output-on-failure --no-tests=error -E "velox_exec_test|velox_hdfs_file_test|velox_s3"
+          ctest -j 8 --output-on-failure --no-tests=error \
+            -E "velox_exec_test|velox_hdfs_file_test|velox_s3|velox_cudf_"
+
+      - name: Copy Shared Libraries for cuDF Test Binaries
+        env:
+          CUDF_DIR: _build/release/velox/experimental/cudf
+        run: |
+          mkdir -p "$CUDF_DIR/cudf-libs"
+          deps=$(
+            find "$CUDF_DIR/tests" -name "velox_cudf_*" -type f -executable |
+            xargs ldd 2>/dev/null |
+            sed -n 's/[^\/]*\(\/[^ ]*\) .*/\1/p' |
+            grep -vE '^/(lib|usr/lib|lib64)/(libcuda|librt\.so|libm\.so|libstdc\+\+\.so|ld-linux-x86-64\.so|libc\.so)' |
+            sort -u
+          )
+          if [ -z "$deps" ]; then
+            echo "Error: No dependencies found"
+            exit 1
+          fi
+          (
+            echo "$deps" |
+            xargs readlink -f |
+            xargs -I {} cp {} "$CUDF_DIR/cudf-libs/"
+          )
+          lndeps=$(echo "$deps" | xargs -I {} bash -c '[ -L "$1" ] && echo "$1" || true' bash {})
+          (
+            cd "$CUDF_DIR/cudf-libs" || exit 1
+            while IFS= read -r link; do
+              [[ -L "$link" ]] || continue
+              target=$(readlink -f "$link") || continue
+              target_basename=$(basename "$target") || continue
+              link_basename=$(basename "$link") || continue
+              ln -sf "$target_basename" "$link_basename"
+            done <<< "$lndeps"
+          )
+          tar -cvf "$CUDF_DIR/cudf-libs.tar" -C "$CUDF_DIR" cudf-libs
+
+      - name: Upload cuDF Test Binaries
+        uses: actions/upload-artifact@v4
+        with:
+          name: cudftestbinaries
+          path: |
+            velox/dwio/parquet/tests/examples/int.parquet
+            velox/experimental/cudf/tests/CMakeLists.txt
+            _build/release/velox/experimental/cudf/tests/velox_cudf_*
+            _build/release/velox/experimental/cudf/tests/CTestTestfile.cmake
+            _build/release/velox/experimental/cudf/cudf-libs.tar
+
+  cudf-tests:
+    name: cuDF GPU tests
+    runs-on: linux-amd64-gpu-l4-latest-1
+    needs: adapters
+    timeout-minutes: 30
+    env:
+      CUDF_DIR: _build/release/velox/experimental/cudf
+    steps:
+      - name: Install Packages
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y cmake patchelf cuda-toolkit-12-9
+          export MINIO_VERSION="2022-05-26T05-48-41Z"
+          export MINIO_BINARY_NAME="minio-2022-05-26"
+          wget https://dl.min.io/server/minio/release/linux-amd64/archive/minio.RELEASE."${MINIO_VERSION}" -O "${MINIO_BINARY_NAME}"
+          sudo mv ./"${MINIO_BINARY_NAME}" /usr/local/bin/
+          sudo chmod +x /usr/local/bin/"${MINIO_BINARY_NAME}"
+
+      - name: Check NVIDIA Driver Version
+        run: nvidia-smi
+
+      - name: Download cuDF Test Binaries
+        uses: actions/download-artifact@v4
+        with:
+          name: cudftestbinaries
+
+      - name: Adapt Downloaded Files
+        run: |
+          sed -i 's|/__w/velox/velox|${{ github.workspace }}|g' $CUDF_DIR/tests/CTestTestfile.cmake
+          grep "Source directory" $CUDF_DIR/tests/CTestTestfile.cmake
+          grep "Build directory" $CUDF_DIR/tests/CTestTestfile.cmake
+          (cd $CUDF_DIR && tar -xf cudf-libs.tar)
+          for exe in $CUDF_DIR/tests/velox_cudf_*; do
+            patchelf --force-rpath --set-rpath '$ORIGIN/../cudf-libs' "$exe"
+            chmod +x "$exe"
+          done
+
+      - name: Run cuDF Tests
+        run: |
+          cd $CUDF_DIR/tests/
+          ctest --output-on-failure
 
 # ubuntu-debug:
 #   runs-on: linux-amd64-cpu16
diff --git a/.github/zizmor.yml b/.github/zizmor.yml
index a1baabf91cf..a3dc69a0b9f 100644
--- a/.github/zizmor.yml
+++ b/.github/zizmor.yml
@@ -15,3 +15,7 @@ rules:
   use-trusted-publishing:
     ignore:
       - build_pyvelox.yml
+  dangerous-triggers:
+    ignore:
+      - build-impact-comment.yml
+      - ci-failure-comment.yml
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 9c31eee8fb2..3124eae3d29 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -37,15 +37,35 @@ repos:
     hooks:
       - id: clang-tidy
         name: clang-tidy
-        description: Run clang-tidy on C/C++ files
+        description: >-
+          Run clang-tidy on C/C++ files, requires 'compile_commands.json'
+          to be available in the repo root (e.g. symlinked) or BUILD_PATH
+          set to it's path e.g. _build/release.
         stages:
-          - manual # Needs compile_commands.json
-        entry: clang-tidy
+          - pre-commit
+        entry: ./scripts/checks/run-clang-tidy.py
+        args: [--commit, HEAD]
         language: python
         types_or: [c++, c]
         additional_dependencies: [clang-tidy==18.1.8]
         require_serial: true
 
+      - id: check-header-ownership
+        name: check-header-ownership
+        description: Verify every .h file is tracked by a CMakeLists.txt target.
+        entry: python3 scripts/checks/check-header-ownership.py velox
+        language: python
+        pass_filenames: false
+        files: (\.h|CMakeLists\.txt)$
+
+      - id: check-readme-blogs
+        name: check-readme-blogs
+        description: Ensure README lists the 3 most recent blog posts.
+        entry: ./scripts/checks/check-readme-blogs.sh
+        language: script
+        files: ^(README\.md|website/blog/.*)$
+        pass_filenames: false
+
       - id: license-header
         name: license-header
         description: Add missing license headers.
@@ -73,7 +93,7 @@ repos:
         name: CMake formatter
 
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v18.1.3
+    rev: v21.1.2
     hooks:
       - id: clang-format
         # types_or: [c++, c, cuda, metal, objective-c]
diff --git a/CMake/FindSnappy.cmake b/CMake/FindSnappy.cmake
deleted file mode 100644
index 2d65b3d1766..00000000000
--- a/CMake/FindSnappy.cmake
+++ /dev/null
@@ -1,41 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-# - Try to find snappy
-# Once done, this will define
-#
-# SNAPPY_FOUND - system has Glog
-# SNAPPY_INCLUDE_DIRS - deprecated
-# SNAPPY_LIBRARIES -  deprecated
-# Snappy::snappy will be defined based on CMAKE_FIND_LIBRARY_SUFFIXES priority
-
-include(FindPackageHandleStandardArgs)
-include(SelectLibraryConfigurations)
-
-find_library(SNAPPY_LIBRARY_RELEASE snappy PATHS $SNAPPY_LIBRARYDIR})
-find_library(SNAPPY_LIBRARY_DEBUG snappyd PATHS ${SNAPPY_LIBRARYDIR})
-
-find_path(SNAPPY_INCLUDE_DIR snappy.h PATHS ${SNAPPY_INCLUDEDIR})
-
-select_library_configurations(SNAPPY)
-
-find_package_handle_standard_args(Snappy DEFAULT_MSG SNAPPY_LIBRARY SNAPPY_INCLUDE_DIR)
-
-mark_as_advanced(SNAPPY_LIBRARY SNAPPY_INCLUDE_DIR)
-
-get_filename_component(libsnappy_ext ${SNAPPY_LIBRARY} EXT)
-if(libsnappy_ext STREQUAL ".a")
-  set(libsnappy_type STATIC)
-else()
-  set(libsnappy_type SHARED)
-endif()
-
-if(NOT TARGET Snappy::snappy)
-  add_library(Snappy::snappy ${libsnappy_type} IMPORTED)
-  set_target_properties(
-    Snappy::snappy
-    PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${SNAPPY_INCLUDE_DIR}"
-  )
-  set_target_properties(
-    Snappy::snappy
-    PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES "C" IMPORTED_LOCATION "${SNAPPY_LIBRARIES}"
-  )
-endif()
diff --git a/CMake/Findc-ares.cmake b/CMake/Findc-ares.cmake
index 58087c018fa..8c3fa68222a 100644
--- a/CMake/Findc-ares.cmake
+++ b/CMake/Findc-ares.cmake
@@ -20,7 +20,7 @@ if(c-ares_FOUND)
 endif()
 
 find_path(C_ARES_INCLUDE_DIR NAMES ares.h PATH_SUFFIXES c-ares)
-find_library(C_ARES_LIBRARY NAMES c-ares)
+find_library(C_ARES_LIBRARY NAMES c-ares cares)
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(c-ares DEFAULT_MSG C_ARES_LIBRARY C_ARES_INCLUDE_DIR)
diff --git a/CMake/Findlz4.cmake b/CMake/Findlz4.cmake
index 2840d017479..8a43e8ea856 100644
--- a/CMake/Findlz4.cmake
+++ b/CMake/Findlz4.cmake
@@ -23,7 +23,7 @@
 include(FindPackageHandleStandardArgs)
 include(SelectLibraryConfigurations)
 
-find_library(LZ4_LIBRARY_RELEASE lz4 PATHS $LZ4_LIBRARYDIR})
+find_library(LZ4_LIBRARY_RELEASE lz4 PATHS ${LZ4_LIBRARYDIR})
 find_library(LZ4_LIBRARY_DEBUG lz4d PATHS ${LZ4_LIBRARYDIR})
 
 find_path(LZ4_INCLUDE_DIR lz4.h PATHS ${LZ4_INCLUDEDIR})
diff --git a/CMake/VeloxConfig.cmake.in b/CMake/VeloxConfig.cmake.in
index 0164099c886..158f47277b4 100644
--- a/CMake/VeloxConfig.cmake.in
+++ b/CMake/VeloxConfig.cmake.in
@@ -57,7 +57,7 @@ block()
   if("@simdjson_SOURCE@" STREQUAL "SYSTEM")
     find_dependency(simdjson)
   endif()
-  if("@THRIFT_SOURCE@" STREQUAL "SYSTEM")
+  if("@Thrift_FOUND@")
     find_dependency(Thrift)
   endif()
   if("@xsimd_SOURCE@" STREQUAL "SYSTEM")
diff --git a/CMake/VeloxUtils.cmake b/CMake/VeloxUtils.cmake
index 8d80d374579..47cdeb7f795 100644
--- a/CMake/VeloxUtils.cmake
+++ b/CMake/VeloxUtils.cmake
@@ -42,7 +42,8 @@ function(pyvelox_add_module TARGET)
   install(TARGETS ${TARGET} LIBRARY DESTINATION pyvelox COMPONENT pyvelox_libraries)
 endfunction()
 
-# TODO use file sets
+# Glob-based header install fallback. Kept for directories that have not yet
+# migrated to the HEADERS keyword in velox_add_library (which uses FILE_SET).
 function(velox_install_library_headers)
   # Find any headers and install them relative to the source tree in include.
   file(GLOB _hdrs "*.h")
@@ -57,6 +58,28 @@ function(velox_install_library_headers)
   endif()
 endfunction()
 
+# Associate headers with test/benchmark/fuzzer targets via FILE_SET for CMake
+# File API discoverability. For production libraries use the HEADERS keyword
+# in velox_add_library() instead.
+function(velox_add_test_headers TARGET)
+  get_target_property(_type ${TARGET} TYPE)
+  if(_type STREQUAL "INTERFACE_LIBRARY")
+    set(_scope INTERFACE)
+  else()
+    set(_scope PUBLIC)
+  endif()
+
+  target_sources(
+    ${TARGET}
+    ${_scope}
+    FILE_SET HEADERS
+    BASE_DIRS
+    ${PROJECT_SOURCE_DIR}
+    FILES
+    ${ARGN}
+  )
+endfunction()
+
 # Base add velox library call to add a library and install it.
 function(velox_base_add_library TARGET)
   add_library(${TARGET} ${ARGN})
@@ -68,10 +91,9 @@ endfunction()
 function(velox_add_library TARGET)
   set(options OBJECT STATIC SHARED INTERFACE)
   set(oneValueArgs)
-  set(multiValueArgs)
+  set(multiValueArgs HEADERS)
   cmake_parse_arguments(VELOX "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
-  # Remove library type specifiers from ARGN
   set(library_type)
   if(VELOX_OBJECT)
     set(library_type OBJECT)
@@ -83,23 +105,23 @@ function(velox_add_library TARGET)
     set(library_type INTERFACE)
   endif()
 
-  list(REMOVE_ITEM ARGN OBJECT)
-  list(REMOVE_ITEM ARGN STATIC)
-  list(REMOVE_ITEM ARGN SHARED)
-  list(REMOVE_ITEM ARGN INTERFACE)
+  set(_sources ${VELOX_UNPARSED_ARGUMENTS})
+
   # Propagate to the underlying add_library and then install the target.
   if(VELOX_MONO_LIBRARY)
     if(TARGET velox)
       # Target already exists, append sources to it.
-      target_sources(velox PRIVATE ${ARGN})
-      install(TARGETS velox LIBRARY DESTINATION pyvelox COMPONENT pyvelox_libraries)
+      target_sources(velox PRIVATE ${_sources})
+      if(VELOX_BUILD_PYTHON_PACKAGE)
+        install(TARGETS velox LIBRARY DESTINATION pyvelox COMPONENT pyvelox_libraries)
+      endif()
     else()
       set(_type STATIC)
       if(VELOX_BUILD_SHARED)
         set(_type SHARED)
       endif()
       # Create the target if this is the first invocation.
-      add_library(velox ${_type} ${ARGN})
+      add_library(velox ${_type} ${_sources})
       set_target_properties(velox PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
       set_target_properties(velox PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
       install(TARGETS velox DESTINATION lib/velox EXPORT velox_targets)
@@ -133,10 +155,10 @@ function(velox_add_library TARGET)
           list(APPEND system_dependencies Snappy zstd)
         endif()
         foreach(system_dependency ${system_dependencies})
-          install(
-            FILES "${PROJECT_SOURCE_DIR}/CMake/Find${system_dependency}.cmake"
-            DESTINATION "${package_cmake_dir}"
-          )
+          set(velox_find_module "${PROJECT_SOURCE_DIR}/CMake/Find${system_dependency}.cmake")
+          if(EXISTS "${velox_find_module}")
+            install(FILES "${velox_find_module}" DESTINATION "${package_cmake_dir}")
+          endif()
         endforeach()
         # TODO: We can enable this once we add version to Velox.
         # set(version_cmake "${PROJECT_BINARY_DIR}/CMake/VeloxConfigVersion.cmake")
@@ -157,8 +179,36 @@ function(velox_add_library TARGET)
     endif()
   else()
     # Create a library for each invocation.
-    velox_base_add_library(${TARGET} ${library_type} ${ARGN})
+    velox_base_add_library(${TARGET} ${library_type} ${_sources})
   endif()
+
+  # Associate headers with the target via FILE_SET for tracking and IDE
+  # integration. The glob-based velox_install_library_headers() remains as
+  # fallback for directories that have not yet listed their headers explicitly.
+  if(VELOX_HEADERS)
+    if(VELOX_MONO_LIBRARY)
+      set(_header_target velox)
+      # The velox target is a real (non-INTERFACE) library, so always use PUBLIC.
+      set(_header_scope PUBLIC)
+    else()
+      set(_header_target ${TARGET})
+      if(VELOX_INTERFACE)
+        set(_header_scope INTERFACE)
+      else()
+        set(_header_scope PUBLIC)
+      endif()
+    endif()
+    target_sources(
+      ${_header_target}
+      ${_header_scope}
+      FILE_SET HEADERS
+      BASE_DIRS
+      ${PROJECT_SOURCE_DIR}
+      FILES
+      ${VELOX_HEADERS}
+    )
+  endif()
+
   velox_install_library_headers()
 endfunction()
 
@@ -218,3 +268,78 @@ function(velox_sources TARGET)
     target_sources(${TARGET} ${ARGN})
   endif()
 endfunction()
+
+# Group test sources into batched binaries to reduce link target count on CI.
+# On macOS, defaults to OFF so each test source gets its own binary and
+# individual tests are discoverable via 'ctest -R <TestName>'.
+if(APPLE)
+  option(VELOX_ENABLE_GROUPED_TESTS "Group test sources into batched binaries" OFF)
+else()
+  option(VELOX_ENABLE_GROUPED_TESTS "Group test sources into batched binaries" ON)
+endif()
+
+# Number of test source files per grouped test binary. Controls the trade-off
+# between link time (fewer groups = faster linking) and ctest parallelism
+# (more groups = more parallel test processes). Ignored when
+# VELOX_ENABLE_GROUPED_TESTS is OFF.
+set(VELOX_TESTS_PER_GROUP 10 CACHE STRING "Number of test source files per grouped test binary")
+
+# Creates grouped test binaries from a list of test sources. Groups tests into
+# batches of VELOX_TESTS_PER_GROUP to reduce link target count while
+# maintaining ctest parallelism. When VELOX_ENABLE_GROUPED_TESTS is OFF, each
+# source file becomes its own binary named after the source file (without
+# extension), making individual tests discoverable via 'ctest -R <TestName>'.
+#
+# Usage:
+#   velox_add_grouped_tests(
+#     PREFIX velox_exec
+#     SOURCES ${MY_SOURCES}
+#     DEPS ${MY_DEPS}
+#     [EXTRA_SOURCES Main.cpp]
+#     [WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}]
+#   )
+function(velox_add_grouped_tests)
+  cmake_parse_arguments(ARG "" "PREFIX;WORKING_DIRECTORY" "SOURCES;DEPS;EXTRA_SOURCES" ${ARGN})
+
+  if(NOT ARG_WORKING_DIRECTORY)
+    set(ARG_WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  endif()
+
+  if(NOT VELOX_ENABLE_GROUPED_TESTS)
+    # Create one binary per source file, named after the source file.
+    foreach(_source IN LISTS ARG_SOURCES)
+      get_filename_component(_name ${_source} NAME_WE)
+      set(_target "${ARG_PREFIX}_${_name}")
+      add_executable(${_target} ${_source} ${ARG_EXTRA_SOURCES})
+      add_test(NAME ${_target} COMMAND ${_target} WORKING_DIRECTORY ${ARG_WORKING_DIRECTORY})
+      target_link_libraries(${_target} ${ARG_DEPS})
+    endforeach()
+    return()
+  endif()
+
+  list(LENGTH ARG_SOURCES _num_sources)
+  math(
+    EXPR
+    _num_groups
+    "(${_num_sources} + ${VELOX_TESTS_PER_GROUP} - 1) / ${VELOX_TESTS_PER_GROUP}"
+  )
+
+  set(_idx 0)
+  set(_group 0)
+  set(_current_sources "")
+
+  foreach(_source IN LISTS ARG_SOURCES)
+    list(APPEND _current_sources ${_source})
+    math(EXPR _idx "${_idx} + 1")
+    math(EXPR _group_end "(${_group} + 1) * ${VELOX_TESTS_PER_GROUP}")
+
+    if(_idx GREATER_EQUAL _group_end OR _idx EQUAL _num_sources)
+      set(_target "${ARG_PREFIX}_group${_group}")
+      add_executable(${_target} ${_current_sources} ${ARG_EXTRA_SOURCES})
+      add_test(NAME ${_target} COMMAND ${_target} WORKING_DIRECTORY ${ARG_WORKING_DIRECTORY})
+      target_link_libraries(${_target} ${ARG_DEPS})
+      set(_current_sources "")
+      math(EXPR _group "${_group} + 1")
+    endif()
+  endforeach()
+endfunction()
diff --git a/CMake/resolve_dependency_modules/README.md b/CMake/resolve_dependency_modules/README.md
index b6fb9dab55a..7c94995e209 100644
--- a/CMake/resolve_dependency_modules/README.md
+++ b/CMake/resolve_dependency_modules/README.md
@@ -6,46 +6,45 @@ The versions of certain libraries is the default provided by
 the platform's package manager. Some libraries can be bundled
 by Velox. See details on bundling below.
 
-| Library Name      | Minimum Version | Bundled? |
-|-------------------|-----------------|----------|
-| ninja             | default         | No       |
-| ccache            | default         | No       |
-| icu4c             | default         | Yes      |
-| gflags            | default         | Yes      |
-| glog              | default         | Yes      |
-| gtest (testing)   | default         | Yes      |
-| libevent          | default         | No       |
-| libcudf           | default         | Yes      |
-| libsodium         | default         | No       |
-| lz4               | default         | No       |
-| snappy            | default         | No       |
-| xz                | default         | No       |
-| zstd              | default         | No       |
-| openssl           | default         | No       |
-| protobuf          | 21.7 >= x < 22  | Yes      |
-| boost             | 1.77.0          | Yes      |
-| flex              | 2.5.13          | No       |
-| bison             | 3.0.4           | No       |
-| cmake             | 3.28            | No       |
-| double-conversion | 3.1.5           | No       |
-| xsimd             | 10.0.0          | Yes      |
-| re2               | 2024-07-02      | Yes      |
-| fmt               | 10.1.1          | Yes      |
-| simdjson          | 3.9.3           | Yes      |
-| faiss             | 1.11.0          | Yes      |
-| folly             | v2025.04.28.00  | Yes      |
-| fizz              | v2025.04.28.00  | No       |
-| wangle            | v2025.04.28.00  | No       |
-| mvfst             | v2025.04.28.00  | No       |
-| fbthrift          | v2025.04.28.00  | No       |
-| libstemmer        | 2.2.0           | Yes      |
-| DuckDB (testing)  | 0.8.1           | Yes      |
-| cpr (testing)     | 1.10.15         | Yes      |
-| arrow             | 15.0.0          | Yes      |
-| geos              | 3.10.7          | Yes      |
-| fast_float        | v8.0.2          | Yes      |
-| xxhash            | default         | No       |
-| thrift            | 0.16            | No       |
+| Library Name      | Minimum Version | Bundled? | Comment |
+|-------------------|-----------------|----------|---------|
+| ninja             | default         | No       ||
+| ccache            | default         | No       ||
+| icu4c             | default         | Yes      ||
+| gflags            | default         | Yes      ||
+| glog              | default         | Yes      ||
+| gtest (testing)   | default         | Yes      ||
+| libevent          | default         | No       ||
+| libsodium         | default         | No       ||
+| lz4               | default         | No       ||
+| snappy            | default         | No       ||
+| xz                | default         | No       ||
+| zstd              | default         | No       ||
+| openssl           | default         | No       ||
+| protobuf          | 21.7 >= x < 22  | Yes      ||
+| boost             | 1.77.0          | Yes      ||
+| flex              | 2.5.13          | No       ||
+| bison             | 3.0.4           | No       ||
+| cmake             | 3.28            | No       ||
+| double-conversion | 3.1.5           | No       ||
+| xsimd             | 10.0.0          | Yes      ||
+| re2               | 2024-07-02      | Yes      ||
+| fmt               | 11.2.0          | Yes      | Used API must be fmt 9 compatible |
+| simdjson          | 4.1.0           | Yes      ||
+| faiss             | 1.11.0          | Yes      ||
+| folly             | v2026.01.05.00  | Yes      ||
+| fizz              | v2026.01.05.00  | No       ||
+| wangle            | v2026.01.05.00  | No       ||
+| mvfst             | v2026.01.05.00  | No       ||
+| fbthrift          | v2026.01.05.00  | No       ||
+| libstemmer        | 2.2.0           | Yes      ||
+| DuckDB (testing)  | 0.8.1           | Yes      ||
+| arrow             | 15.0.0          | Yes      ||
+| geos              | 3.10.7          | Yes      ||
+| s2geometry        | 0.12.0          | Yes      ||
+| fast_float        | v8.0.2          | Yes      ||
+| xxhash            | default         | No       ||
+| thrift            | 0.16            | No       ||
 
 # Bundled Dependency Management
 This module provides a dependency management system that allows us to automatically fetch and build dependencies from source if needed.
diff --git a/CMake/resolve_dependency_modules/arrow/CMakeLists.txt b/CMake/resolve_dependency_modules/arrow/CMakeLists.txt
index 2d421827ab5..4f4e4031934 100644
--- a/CMake/resolve_dependency_modules/arrow/CMakeLists.txt
+++ b/CMake/resolve_dependency_modules/arrow/CMakeLists.txt
@@ -20,6 +20,19 @@ if(VELOX_ENABLE_ARROW)
     set(THRIFT_SOURCE "BUNDLED")
   endif()
 
+  # Avoid issues in finding the boost headers and libraries
+  # by setting the BOOST_ROOT to the install prefix.
+  # The same logic is used in the setup script-common.sh to install boost.
+  if(NOT DEFINED ENV{BOOST_ROOT} OR "$ENV{BOOST_ROOT}" STREQUAL "")
+    if(DEFINED ENV{INSTALL_PREFIX} AND NOT "$ENV{INSTALL_PREFIX}" STREQUAL "")
+      set(BOOST_ROOT "$ENV{INSTALL_PREFIX}")
+    else()
+      set(BOOST_ROOT "/usr/local")
+    endif()
+  else()
+    set(BOOST_ROOT "$ENV{BOOST_ROOT}")
+  endif()
+  message(STATUS "Using BOOST_ROOT: ${BOOST_ROOT}")
   set(ARROW_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/arrow_ep")
   set(
     ARROW_CMAKE_ARGS
@@ -35,16 +48,18 @@ if(VELOX_ENABLE_ARROW)
     -DARROW_RUNTIME_SIMD_LEVEL=NONE
     -DARROW_WITH_UTF8PROC=OFF
     -DARROW_TESTING=ON
+    -DCMAKE_INSTALL_LIBDIR=lib
     -DCMAKE_INSTALL_PREFIX=${ARROW_PREFIX}/install
     -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
     -DARROW_BUILD_STATIC=ON
     -DThrift_SOURCE=${THRIFT_SOURCE}
     -DCMAKE_PREFIX_PATH=${CMAKE_PREFIX_PATH}
+    -DBOOST_ROOT=${BOOST_ROOT}
     -DCMAKE_POLICY_VERSION_MINIMUM=3.5
     # Remove with Arrow upgrade to Arrow 20.
     -DARROW_CXXFLAGS=-Wno-documentation
   )
-  set(ARROW_LIBDIR ${ARROW_PREFIX}/install/${CMAKE_INSTALL_LIBDIR})
+  set(ARROW_LIBDIR ${ARROW_PREFIX}/install/lib)
 
   add_library(thrift STATIC IMPORTED GLOBAL)
   if(NOT Thrift_FOUND)
@@ -58,10 +73,10 @@ if(VELOX_ENABLE_ARROW)
   set_property(TARGET thrift PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${THRIFT_INCLUDE_DIR})
   set_property(TARGET thrift PROPERTY IMPORTED_LOCATION ${THRIFT_LIB})
 
-  set(VELOX_ARROW_BUILD_VERSION 15.0.0)
+  set(VELOX_ARROW_BUILD_VERSION 18.0.0)
   set(
     VELOX_ARROW_BUILD_SHA256_CHECKSUM
-    ab74c60c46938505c8cd7599b1d2826c68450645d5860d0ff40f67e371a5d0b5
+    9c473f2c9914c59ab571761c9497cf0e5cfd3ea335f7782ccc6121f5cb99ae9b
   )
   set(
     VELOX_ARROW_SOURCE_URL
@@ -79,8 +94,8 @@ if(VELOX_ENABLE_ARROW)
     CMAKE_ARGS ${ARROW_CMAKE_ARGS}
     BUILD_BYPRODUCTS ${ARROW_LIBDIR}/libarrow.a ${ARROW_LIBDIR}/libarrow_testing.a ${THRIFT_LIB}
     PATCH_COMMAND
-      git apply ${CMAKE_CURRENT_LIST_DIR}/thrift-download.patch && git apply
-      ${CMAKE_CURRENT_LIST_DIR}/cmake-compatibility.patch
+      git apply ${CMAKE_CURRENT_LIST_DIR}/cmake-compatibility.patch && git apply
+      ${CMAKE_CURRENT_LIST_DIR}/thrift-download.patch
   )
 
   add_library(arrow STATIC IMPORTED GLOBAL)
diff --git a/CMake/resolve_dependency_modules/arrow/cmake-compatibility.patch b/CMake/resolve_dependency_modules/arrow/cmake-compatibility.patch
index 249ea609048..41b0528390d 100644
--- a/CMake/resolve_dependency_modules/arrow/cmake-compatibility.patch
+++ b/CMake/resolve_dependency_modules/arrow/cmake-compatibility.patch
@@ -14,7 +14,7 @@
 
 --- a/cpp/cmake_modules/ThirdpartyToolchain.cmake
 +++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake
-@@ -971,7 +971,8 @@
+@@ -979,7 +979,8 @@
      -DCMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY=${CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY}
      -DCMAKE_INSTALL_LIBDIR=lib
      -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
@@ -22,9 +22,9 @@
 +    -DCMAKE_VERBOSE_MAKEFILE=${CMAKE_VERBOSE_MAKEFILE}
 +    -DCMAKE_POLICY_VERSION_MINIMUM=3.5)
 
- # Enable s/ccache if set by parent.
- if(CMAKE_C_COMPILER_LAUNCHER AND CMAKE_CXX_COMPILER_LAUNCHER)
-@@ -1026,6 +1027,7 @@
+ # if building with a toolchain file, pass that through
+ if(CMAKE_TOOLCHAIN_FILE)
+@@ -1045,6 +1046,7 @@
    set(CMAKE_COMPILE_WARNING_AS_ERROR FALSE)
    set(CMAKE_EXPORT_NO_PACKAGE_REGISTRY TRUE)
    set(CMAKE_MACOSX_RPATH ${ARROW_INSTALL_NAME_RPATH})
diff --git a/CMake/resolve_dependency_modules/arrow/thrift-download.patch b/CMake/resolve_dependency_modules/arrow/thrift-download.patch
index 421b2a1253c..92b8d87dd08 100644
--- a/CMake/resolve_dependency_modules/arrow/thrift-download.patch
+++ b/CMake/resolve_dependency_modules/arrow/thrift-download.patch
@@ -28,13 +28,13 @@
    "ARROW_S2N_TLS_URL s2n-${ARROW_S2N_TLS_BUILD_VERSION}.tar.gz https://github.com/aws/s2n-tls/archive/${ARROW_S2N_TLS_BUILD_VERSION}.tar.gz"
    "ARROW_SNAPPY_URL snappy-${ARROW_SNAPPY_BUILD_VERSION}.tar.gz https://github.com/google/snappy/archive/${ARROW_SNAPPY_BUILD_VERSION}.tar.gz"
 -  "ARROW_THRIFT_URL thrift-${ARROW_THRIFT_BUILD_VERSION}.tar.gz https://archive.apache.org/dist/thrift/${ARROW_THRIFT_BUILD_VERSION}/thrift-${ARROW_THRIFT_BUILD_VERSION}.tar.gz"
-+  "ARROW_THRIFT_URL thrift-${ARROW_THRIFT_BUILD_VERSION}.tar.gz https://github.com/apache/thrift/archive/refs/tags/v${ARROW_THRIFT_BUILD_VERSION}.tar.gz
++  "ARROW_THRIFT_URL thrift-${ARROW_THRIFT_BUILD_VERSION}.tar.gz https://github.com/apache/thrift/archive/refs/tags/v${ARROW_THRIFT_BUILD_VERSION}.tar.gz"
    "ARROW_UCX_URL ucx-${ARROW_UCX_BUILD_VERSION}.tar.gz https://github.com/openucx/ucx/archive/v${ARROW_UCX_BUILD_VERSION}.tar.gz"
    "ARROW_UTF8PROC_URL utf8proc-${ARROW_UTF8PROC_BUILD_VERSION}.tar.gz https://github.com/JuliaStrings/utf8proc/archive/${ARROW_UTF8PROC_BUILD_VERSION}.tar.gz"
    "ARROW_XSIMD_URL xsimd-${ARROW_XSIMD_BUILD_VERSION}.tar.gz https://github.com/xtensor-stack/xsimd/archive/${ARROW_XSIMD_BUILD_VERSION}.tar.gz"
 --- a/cpp/cmake_modules/ThirdpartyToolchain.cmake
 +++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake
-@@ -809,20 +809,7 @@
+@@ -817,20 +817,7 @@
    set(THRIFT_SOURCE_URL "$ENV{ARROW_THRIFT_URL}")
  else()
    set_urls(THRIFT_SOURCE_URL
diff --git a/CMake/resolve_dependency_modules/boost.cmake b/CMake/resolve_dependency_modules/boost.cmake
index 842cba6f133..dfbc6169847 100644
--- a/CMake/resolve_dependency_modules/boost.cmake
+++ b/CMake/resolve_dependency_modules/boost.cmake
@@ -15,13 +15,6 @@ include_guard(GLOBAL)
 
 add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/boost)
 
-if(ICU_SOURCE)
-  if(${ICU_SOURCE} STREQUAL "BUNDLED")
-    # ensure ICU is built before Boost
-    add_dependencies(boost_regex ICU ICU::i18n)
-  endif()
-endif()
-
 # This prevents system boost from leaking in
 set(Boost_NO_SYSTEM_PATHS ON)
 # We have to keep the FindBoost.cmake in an subfolder to prevent it from
diff --git a/CMake/resolve_dependency_modules/cpr.cmake b/CMake/resolve_dependency_modules/cpr.cmake
deleted file mode 100644
index 37cacac79cb..00000000000
--- a/CMake/resolve_dependency_modules/cpr.cmake
+++ /dev/null
@@ -1,51 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-include_guard(GLOBAL)
-
-set(VELOX_CPR_VERSION 1.10.5)
-set(
-  VELOX_CPR_BUILD_SHA256_CHECKSUM
-  c8590568996cea918d7cf7ec6845d954b9b95ab2c4980b365f582a665dea08d8
-)
-set(
-  VELOX_CPR_SOURCE_URL
-  "https://github.com/libcpr/cpr/archive/refs/tags/${VELOX_CPR_VERSION}.tar.gz"
-)
-
-# Add the dependency for curl, so that we can define the source URL for curl in
-# curl.cmake. This will override the curl version declared by cpr.
-set(curl_SOURCE BUNDLED)
-velox_resolve_dependency(curl)
-
-velox_resolve_dependency_url(CPR)
-
-message(STATUS "Building cpr from source")
-FetchContent_Declare(
-  cpr
-  URL ${VELOX_CPR_SOURCE_URL}
-  URL_HASH ${VELOX_CPR_BUILD_SHA256_CHECKSUM}
-  PATCH_COMMAND
-    git apply ${CMAKE_CURRENT_LIST_DIR}/cpr/cpr-libcurl-compatible.patch && git apply
-    ${CMAKE_CURRENT_LIST_DIR}/cpr/cpr-remove-sancheck.patch
-)
-set(BUILD_SHARED_LIBS ${VELOX_BUILD_SHARED})
-set(CPR_USE_SYSTEM_CURL OFF)
-# ZLIB has already been found by find_package(ZLIB, REQUIRED), set CURL_ZLIB=OFF
-# to save compile time.
-set(CURL_ZLIB OFF)
-FetchContent_MakeAvailable(cpr)
-# libcpr in its CMakeLists.txt file disables the BUILD_TESTING globally when
-# CPR_USE_SYSTEM_CURL=OFF. unset BUILD_TESTING here.
-unset(BUILD_TESTING)
-unset(BUILD_SHARED_LIBS)
diff --git a/CMake/resolve_dependency_modules/cpr/cpr-libcurl-compatible.patch b/CMake/resolve_dependency_modules/cpr/cpr-libcurl-compatible.patch
deleted file mode 100644
index 49821889f2b..00000000000
--- a/CMake/resolve_dependency_modules/cpr/cpr-libcurl-compatible.patch
+++ /dev/null
@@ -1,41 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# This can be removed once we upgrade to curl >= 7.68.0
---- a/cpr/multiperform.cpp
-+++ b/cpr/multiperform.cpp
-@@ -97,9 +97,9 @@ void MultiPerform::DoMultiPerform() {
-
-         if (still_running) {
-             const int timeout_ms{250};
--            error_code = curl_multi_poll(multicurl_->handle, nullptr, 0, timeout_ms, nullptr);
-+            error_code = curl_multi_wait(multicurl_->handle, nullptr, 0, timeout_ms, nullptr);
-             if (error_code) {
--                std::cerr << "curl_multi_poll() failed, code " << static_cast<int>(error_code) << std::endl;
-+                std::cerr << "curl_multi_wait() failed, code " << static_cast<int>(error_code) << std::endl;
-                 break;
-             }
-         }
-
---- a/include/cpr/util.h
-+++ b/include/cpr/util.h
-@@ -23,7 +23,7 @@ size_t writeUserFunction(char* ptr, size_t size, size_t nmemb, const WriteCallba
- template <typename T = ProgressCallback>
- int progressUserFunction(const T* progress, cpr_pf_arg_t dltotal, cpr_pf_arg_t dlnow, cpr_pf_arg_t ultotal, cpr_pf_arg_t ulnow) {
-     const int cancel_retval{1};
--    static_assert(cancel_retval != CURL_PROGRESSFUNC_CONTINUE);
-+    static_assert(cancel_retval != 0x10000001);
-     return (*progress)(dltotal, dlnow, ultotal, ulnow) ? 0 : cancel_retval;
- }
- int debugUserFunction(CURL* handle, curl_infotype type, char* data, size_t size, const DebugCallback* debug);
diff --git a/CMake/resolve_dependency_modules/cudf.cmake b/CMake/resolve_dependency_modules/cudf.cmake
index 278744e9d43..a945660f8e7 100644
--- a/CMake/resolve_dependency_modules/cudf.cmake
+++ b/CMake/resolve_dependency_modules/cudf.cmake
@@ -17,49 +17,50 @@ include_guard(GLOBAL)
 # 3.30.4 is the minimum version required by cudf
 cmake_minimum_required(VERSION 3.30.4)
 
-set(VELOX_rapids_cmake_VERSION 25.10)
+# rapids_cmake commit d79e071 from 2026-05-01
+set(VELOX_rapids_cmake_VERSION 26.06)
+set(VELOX_rapids_cmake_COMMIT d79e071f805e709771b80008d50a8b3a5bed93ca)
 set(
   VELOX_rapids_cmake_BUILD_SHA256_CHECKSUM
-  635aff67e017c64021bf3d225d31f843e9541f3bf9c3d07bac72466dc57c917b
+  d0f9eea4feaef1cc325e86eac787052ec951659fdcf21abdfb06efc337a63179
 )
 set(
   VELOX_rapids_cmake_SOURCE_URL
-  "https://github.com/rapidsai/rapids-cmake/archive/0b111489d1e6f8400e1fc88297623a2a9915fa77.tar.gz"
+  "https://github.com/rapidsai/rapids-cmake/archive/${VELOX_rapids_cmake_COMMIT}.tar.gz"
 )
 velox_resolve_dependency_url(rapids_cmake)
 
-set(VELOX_rmm_VERSION 25.10)
+# rmm commit 2357ddd from 2026-05-04
+set(VELOX_rmm_VERSION 26.06)
+set(VELOX_rmm_COMMIT 2357ddddcff042ba378e8de6f89e4a995a23b2db)
 set(
   VELOX_rmm_BUILD_SHA256_CHECKSUM
-  72dd6a26a1a75e193723571ec7ba8bcb040ea9a38592eb0809e64ebdbf291d76
-)
-set(
-  VELOX_rmm_SOURCE_URL
-  "https://github.com/rapidsai/rmm/archive/7cef2f5f30e962e9f3b27a3a3f2753a40277c093.tar.gz"
+  61492c2da88e7f6a6a4edc7101cce4698c156704d135db0b80119f4b9a2c575c
 )
+set(VELOX_rmm_SOURCE_URL "https://github.com/rapidsai/rmm/archive/${VELOX_rmm_COMMIT}.tar.gz")
 velox_resolve_dependency_url(rmm)
 
-set(VELOX_kvikio_VERSION 25.10)
+# kvikio commit 247b64e from 2026-05-02
+set(VELOX_kvikio_VERSION 26.06)
+set(VELOX_kvikio_COMMIT 247b64e97ecb7cb9ccb06ab123aea87ac571c5b4)
 set(
   VELOX_kvikio_BUILD_SHA256_CHECKSUM
-  76c217bd925f7665246135311697393b5118185d4bdd4291e8ff4506e4feb6af
+  6419490de95e412cefdbafffc73fac6b2162bc2200076611883fe41637028198
 )
 set(
   VELOX_kvikio_SOURCE_URL
-  "https://github.com/rapidsai/kvikio/archive/6efd22dc6ae3389caea7d3e736c7f954b9db0619.tar.gz"
+  "https://github.com/rapidsai/kvikio/archive/${VELOX_kvikio_COMMIT}.tar.gz"
 )
 velox_resolve_dependency_url(kvikio)
 
-set(VELOX_cudf_VERSION 25.10 CACHE STRING "cudf version")
-
+# cudf commit d09d10d from 2026-05-04
+set(VELOX_cudf_VERSION 26.06 CACHE STRING "cudf version")
+set(VELOX_cudf_COMMIT d09d10d14d3ed932b8de93638809101af5c7fec3)
 set(
   VELOX_cudf_BUILD_SHA256_CHECKSUM
-  c7dfb333ee0cb9f86d5ee94aaa34985ae6cf45d4ed8658d850707cc8e0db8e16
-)
-set(
-  VELOX_cudf_SOURCE_URL
-  "https://github.com/rapidsai/cudf/archive/2bfd896b4e0c1f0b66402c1e067b4904dbd15c5e.tar.gz"
+  5042ec46beb8260eb60d13b9cd44f26357b9756628f7d58659c77e88c67e15d5
 )
+set(VELOX_cudf_SOURCE_URL "https://github.com/rapidsai/cudf/archive/${VELOX_cudf_COMMIT}.tar.gz")
 velox_resolve_dependency_url(cudf)
 
 # Use block so we don't leak variables
@@ -114,4 +115,5 @@ block(SCOPE_FOR VARIABLES)
   )
 
   unset(BUILD_SHARED_LIBS)
+  unset(BUILD_TESTING CACHE)
 endblock()
diff --git a/CMake/resolve_dependency_modules/curl.cmake b/CMake/resolve_dependency_modules/curl.cmake
index c749c06a23f..fd4b51adf2b 100644
--- a/CMake/resolve_dependency_modules/curl.cmake
+++ b/CMake/resolve_dependency_modules/curl.cmake
@@ -13,19 +13,4 @@
 # limitations under the License.
 include_guard(GLOBAL)
 
-set(VELOX_CURL_VERSION 8.4.0)
-string(REPLACE "." "_" VELOX_CURL_VERSION_UNDERSCORES ${VELOX_CURL_VERSION})
-set(
-  VELOX_CURL_BUILD_SHA256_CHECKSUM
-  16c62a9c4af0f703d28bda6d7bbf37ba47055ad3414d70dec63e2e6336f2a82d
-)
-string(
-  CONCAT
-  VELOX_CURL_SOURCE_URL
-  "https://github.com/curl/curl/releases/download/"
-  "curl-${VELOX_CURL_VERSION_UNDERSCORES}/curl-${VELOX_CURL_VERSION}.tar.xz"
-)
-
-velox_resolve_dependency_url(CURL)
-
-FetchContent_Declare(curl URL ${VELOX_CURL_SOURCE_URL} URL_HASH ${VELOX_CURL_BUILD_SHA256_CHECKSUM})
+add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/curl)
diff --git a/CMake/resolve_dependency_modules/curl/CMakeLists.txt b/CMake/resolve_dependency_modules/curl/CMakeLists.txt
new file mode 100644
index 00000000000..867c19cf242
--- /dev/null
+++ b/CMake/resolve_dependency_modules/curl/CMakeLists.txt
@@ -0,0 +1,42 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set(VELOX_CURL_VERSION 8.4.0)
+string(REPLACE "." "_" VELOX_CURL_VERSION_UNDERSCORES ${VELOX_CURL_VERSION})
+set(
+  VELOX_CURL_BUILD_SHA256_CHECKSUM
+  16c62a9c4af0f703d28bda6d7bbf37ba47055ad3414d70dec63e2e6336f2a82d
+)
+string(
+  CONCAT
+  VELOX_CURL_SOURCE_URL
+  "https://github.com/curl/curl/releases/download/"
+  "curl-${VELOX_CURL_VERSION_UNDERSCORES}/curl-${VELOX_CURL_VERSION}.tar.xz"
+)
+
+set(BUILD_TESTING OFF)
+set(BUILD_SHARED_LIBS ON)
+
+velox_resolve_dependency_url(CURL)
+
+message(STATUS "Building CURL from source")
+
+FetchContent_Declare(curl URL ${VELOX_CURL_SOURCE_URL} URL_HASH ${VELOX_CURL_BUILD_SHA256_CHECKSUM})
+
+FetchContent_MakeAvailable(curl)
+
+# Curl uses CMake option for BUILD_TESTING and BUILD_SHARED_LIBS
+# See CMake option semantics.
+unset(BUILD_TESTING CACHE)
+unset(BUILD_SHARED_LIBS CACHE)
diff --git a/CMake/resolve_dependency_modules/duckdb.cmake b/CMake/resolve_dependency_modules/duckdb.cmake
index 8859ccb6ac5..bd3fbd7e14f 100644
--- a/CMake/resolve_dependency_modules/duckdb.cmake
+++ b/CMake/resolve_dependency_modules/duckdb.cmake
@@ -44,6 +44,7 @@ FetchContent_Declare(
 # that.
 set(GIT_COMMIT_HASH "6536a77")
 set(BUILD_UNITTESTS OFF)
+set(BUILD_TESTING OFF)
 set(ENABLE_SANITIZER OFF)
 set(ENABLE_UBSAN OFF)
 set(BUILD_SHELL OFF)
@@ -65,3 +66,5 @@ endif()
 
 set(CMAKE_CXX_FLAGS ${PREVIOUS_CMAKE_CXX_FLAGS})
 set(CMAKE_BUILD_TYPE ${PREVIOUS_BUILD_TYPE})
+# Some DuckDB third-party package sets this flags. We cannot control that.
+unset(BUILD_TESTING)
diff --git a/CMake/resolve_dependency_modules/faiss.cmake b/CMake/resolve_dependency_modules/faiss.cmake
index 911ba5c8ef9..db158dbe65d 100644
--- a/CMake/resolve_dependency_modules/faiss.cmake
+++ b/CMake/resolve_dependency_modules/faiss.cmake
@@ -60,10 +60,14 @@ FetchContent_Declare(
 # Set build options
 block()
   set(BUILD_SHARED_LIBS OFF)
+  set(BUILD_TESTING OFF)
   set(CMAKE_BUILD_TYPE Release)
   set(FAISS_ENABLE_GPU OFF)
   set(FAISS_ENABLE_PYTHON OFF)
   set(FAISS_ENABLE_GPU_TESTS OFF)
   # Make FAISS available
   FetchContent_MakeAvailable(faiss)
+  add_library(FAISS::faiss ALIAS faiss)
+  unset(BUILD_TESTING CACHE)
+  unset(BUILD_SHARED_LIBS CACHE)
 endblock()
diff --git a/CMake/resolve_dependency_modules/fmt.cmake b/CMake/resolve_dependency_modules/fmt.cmake
index fc69a934a83..9e8087f1da0 100644
--- a/CMake/resolve_dependency_modules/fmt.cmake
+++ b/CMake/resolve_dependency_modules/fmt.cmake
@@ -13,10 +13,10 @@
 # limitations under the License.
 include_guard(GLOBAL)
 
-set(VELOX_FMT_VERSION 10.1.1)
+set(VELOX_FMT_VERSION 11.2.0)
 set(
   VELOX_FMT_BUILD_SHA256_CHECKSUM
-  78b8c0a72b1c35e4443a7e308df52498252d1cefc2b08c9a97bc9ee6cfe61f8b
+  bc23066d87ab3168f27cef3e97d545fa63314f5c79df5ea444d41d56f962c6af
 )
 set(VELOX_FMT_SOURCE_URL "https://github.com/fmtlib/fmt/archive/${VELOX_FMT_VERSION}.tar.gz")
 
diff --git a/CMake/resolve_dependency_modules/folly/CMakeLists.txt b/CMake/resolve_dependency_modules/folly/CMakeLists.txt
index 28af264cfaa..8139c11a57e 100644
--- a/CMake/resolve_dependency_modules/folly/CMakeLists.txt
+++ b/CMake/resolve_dependency_modules/folly/CMakeLists.txt
@@ -14,13 +14,13 @@
 project(Folly)
 cmake_minimum_required(VERSION 3.28)
 
-velox_set_source(fastfloat)
-velox_resolve_dependency(fastfloat CONFIG REQUIRED)
+velox_set_source(FastFloat)
+velox_resolve_dependency(FastFloat CONFIG REQUIRED)
 
-set(VELOX_FOLLY_BUILD_VERSION v2025.04.28.00)
+set(VELOX_FOLLY_BUILD_VERSION v2026.01.05.00)
 set(
   VELOX_FOLLY_BUILD_SHA256_CHECKSUM
-  ccbb7eac662023f9f5beba94e51350d527f33d8a7a036eb5e3d8a5cf1b49d3bc
+  8b41494b664fcde3d02f652d6a27381ec5e938ef58cf986d8ce4958d424af101
 )
 set(
   VELOX_FOLLY_SOURCE_URL
@@ -54,8 +54,6 @@ set(BUILD_SHARED_LIBS ${VELOX_BUILD_SHARED})
 
 # Enable INT128 support
 set(FOLLY_HAVE_INT128_T ON)
-set(PREVIOUS_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DFOLLY_CFG_NO_COROUTINES")
 
 FetchContent_MakeAvailable(folly)
 
@@ -66,4 +64,3 @@ add_library(Folly::follybenchmark ALIAS follybenchmark)
 if(gflags_SOURCE STREQUAL "BUNDLED")
   add_dependencies(folly glog::glog gflags::gflags fmt::fmt)
 endif()
-set(CMAKE_CXX_FLAGS ${PREVIOUS_CMAKE_CXX_FLAGS})
diff --git a/CMake/resolve_dependency_modules/geos.cmake b/CMake/resolve_dependency_modules/geos.cmake
index f092ba823b1..6037d7ac20e 100644
--- a/CMake/resolve_dependency_modules/geos.cmake
+++ b/CMake/resolve_dependency_modules/geos.cmake
@@ -19,13 +19,13 @@ block()
   set(VELOX_GEOS_BUILD_VERSION 3.10.7)
   set(
     VELOX_GEOS_BUILD_SHA256_CHECKSUM
-    8b2ab4d04d660e27f2006550798f49dd11748c3767455cae9f71967dc437da1f
+    fcde02913159711fd3188afccf9ba78008ecced089d7e6cb6ff9a4bc1eed10a1
   )
   string(
     CONCAT
     VELOX_GEOS_SOURCE_URL
-    "https://download.osgeo.org/geos/"
-    "geos-${VELOX_GEOS_BUILD_VERSION}.tar.bz2"
+    "https://github.com/libgeos/geos/archive/refs/tags/"
+    "${VELOX_GEOS_BUILD_VERSION}.tar.gz"
   )
 
   velox_resolve_dependency_url(GEOS)
diff --git a/CMake/resolve_dependency_modules/re2.cmake b/CMake/resolve_dependency_modules/re2.cmake
index b31bed33b6e..738e0564b7c 100644
--- a/CMake/resolve_dependency_modules/re2.cmake
+++ b/CMake/resolve_dependency_modules/re2.cmake
@@ -60,3 +60,5 @@ set(re2_INCLUDE_DIRS ${re2_SOURCE_DIR})
 
 set(RE2_ROOT ${re2_BINARY_DIR})
 set(re2_ROOT ${re2_BINARY_DIR})
+
+unset(BUILD_TESTING CACHE)
diff --git a/CMake/resolve_dependency_modules/s2geometry.cmake b/CMake/resolve_dependency_modules/s2geometry.cmake
new file mode 100644
index 00000000000..a7f39397578
--- /dev/null
+++ b/CMake/resolve_dependency_modules/s2geometry.cmake
@@ -0,0 +1,66 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+include_guard(GLOBAL)
+
+list(PREPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/s2geometry)
+
+# This creates a separate scope so any changed variables don't affect
+# the rest of the build.
+block()
+  # s2geometry needs absl.
+  if(NOT TARGET absl::base)
+    velox_set_source(absl)
+    velox_resolve_dependency(absl)
+  endif()
+
+  set(VELOX_S2GEOMETRY_BUILD_VERSION 0.12.0)
+  set(
+    VELOX_S2GEOMETRY_BUILD_SHA256_CHECKSUM
+    c09ec751c3043965a0d441e046a73c456c995e6063439a72290f661c1054d611
+  )
+  string(
+    CONCAT
+    VELOX_S2GEOMETRY_SOURCE_URL
+    "https://github.com/google/s2geometry/archive/refs/tags/"
+    "v${VELOX_S2GEOMETRY_BUILD_VERSION}.tar.gz"
+  )
+
+  velox_resolve_dependency_url(S2GEOMETRY)
+
+  FetchContent_Declare(
+    s2geometry
+    URL ${VELOX_S2GEOMETRY_SOURCE_URL}
+    URL_HASH ${VELOX_S2GEOMETRY_BUILD_SHA256_CHECKSUM}
+    OVERRIDE_FIND_PACKAGE
+    SYSTEM
+    EXCLUDE_FROM_ALL
+    PATCH_COMMAND git apply ${CMAKE_CURRENT_LIST_DIR}/s2geometry/s2geometry-gcc12-max.patch
+  )
+
+  list(APPEND CMAKE_MODULE_PATH "${s2geometry_SOURCE_DIR}/cmake")
+  set(BUILD_SHARED_LIBS OFF)
+  set(BUILD_TESTING OFF)
+  set(BUILD_TESTS OFF)
+  set(CMAKE_BUILD_TYPE Release)
+
+  FetchContent_MakeAvailable(s2geometry)
+
+  # Clang does not enable C++14 sized deallocation by default, unlike GCC.
+  # s2geometry's port.h uses ::operator delete(ptr, size) which requires it.
+  if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    target_compile_options(s2 PRIVATE -fsized-deallocation)
+  endif()
+
+  add_library(s2::s2 ALIAS s2)
+endblock()
diff --git a/CMake/resolve_dependency_modules/s2geometry/Finds2geometry.cmake b/CMake/resolve_dependency_modules/s2geometry/Finds2geometry.cmake
new file mode 100644
index 00000000000..a93b3edaf82
--- /dev/null
+++ b/CMake/resolve_dependency_modules/s2geometry/Finds2geometry.cmake
@@ -0,0 +1,23 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Find the s2geometry library installed on the system.
+# s2geometry installs its CMake config as "s2Config.cmake" with the s2::s2
+# target. This shim bridges the package name difference so that
+# find_package(s2geometry) works.
+
+find_package(s2 CONFIG QUIET)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(s2geometry DEFAULT_MSG s2_FOUND)
diff --git a/CMake/resolve_dependency_modules/s2geometry/s2geometry-gcc12-max.patch b/CMake/resolve_dependency_modules/s2geometry/s2geometry-gcc12-max.patch
new file mode 100644
index 00000000000..185756c399c
--- /dev/null
+++ b/CMake/resolve_dependency_modules/s2geometry/s2geometry-gcc12-max.patch
@@ -0,0 +1,11 @@
+--- a/src/s2/s2cell_id.cc
++++ b/src/s2/s2cell_id.cc
+@@ -195,7 +195,7 @@ int S2CellId::GetCommonAncestorLevel(S2CellId other) const {
+   // Compute the position of the most significant bit, and then map the bit
+   // position as follows:
+   // {0} -> 30, {1,2} -> 29, {3,4} -> 28, ... , {59,60} -> 0, {61,62,63} -> -1.
+-  return max(61 - absl::bit_width(bits), -1) >> 1;
++  return std::max<int>(61 - absl::bit_width(bits), -1) >> 1;
+ }
+
+ // Print the num_digits low order hex digits.
diff --git a/CMake/resolve_dependency_modules/simdjson.cmake b/CMake/resolve_dependency_modules/simdjson.cmake
index 962a76fadf1..59894896c8b 100644
--- a/CMake/resolve_dependency_modules/simdjson.cmake
+++ b/CMake/resolve_dependency_modules/simdjson.cmake
@@ -13,10 +13,10 @@
 # limitations under the License.
 include_guard(GLOBAL)
 
-set(VELOX_SIMDJSON_VERSION 3.9.3)
+set(VELOX_SIMDJSON_VERSION 4.1.0)
 set(
   VELOX_SIMDJSON_BUILD_SHA256_CHECKSUM
-  2e3d10abcde543d3dd8eba9297522cafdcebdd1db4f51b28f3bc95bf1d6ad23c
+  78115e37b2e88ec63e6ae20bb148063a9112c55bcd71404c8572078fd8a6ac3e
 )
 set(
   VELOX_SIMDJSON_SOURCE_URL
diff --git a/CMake/third-party/FBThriftCppLibrary.cmake b/CMake/third-party/FBThriftCppLibrary.cmake
index 0d05546a26f..416a88b752f 100644
--- a/CMake/third-party/FBThriftCppLibrary.cmake
+++ b/CMake/third-party/FBThriftCppLibrary.cmake
@@ -4,22 +4,29 @@ include(FBCMakeParseArgs)
 
 # Generate a C++ library from a thrift file
 #
-# Parameters: - SERVICES <svc1> [<svc2> ...] The names of the services defined
-# in the thrift file. - DEPENDS <dep1> [<dep2> ...] A list of other thrift C++
-# libraries that this library depends on. - OPTIONS <opt1> [<opt2> ...] A list
-# of options to pass to the thrift compiler. - INCLUDE_DIR <path> The
-# sub-directory where generated headers will be installed. Defaults to "include"
-# if not specified.  The caller must still call install() to install the thrift
-# library if desired. - THRIFT_INCLUDE_DIR <path> The sub-directory where
-# generated headers will be installed. Defaults to "${INCLUDE_DIR}/thrift-files"
-# if not specified. The caller must still call install() to install the thrift
-# library if desired.
+# Parameters:
+# - SERVICES <svc1> [<svc2> ...]
+#   The names of the services defined in the thrift file.
+# - DEPENDS <dep1> [<dep2> ...]
+#   A list of other thrift C++ libraries that this library depends on.
+# - OPTIONS <opt1> [<opt2> ...]
+#   A list of options to pass to the thrift compiler.
+# - INCLUDE_DIR <path>
+#   The sub-directory where generated headers will be installed.
+#   Defaults to "include" if not specified.  The caller must still call
+#   install() to install the thrift library if desired.
+# - THRIFT_INCLUDE_DIR <path>
+#   The sub-directory where generated headers will be installed.
+#   Defaults to "${INCLUDE_DIR}/thrift-files" if not specified.
+#   The caller must still call install() to install the thrift library if
+#   desired.
 function(add_fbthrift_cpp_library LIB_NAME THRIFT_FILE)
   # Parse the arguments
   set(one_value_args INCLUDE_DIR THRIFT_INCLUDE_DIR)
   set(multi_value_args SERVICES DEPENDS OPTIONS)
-  fb_cmake_parse_args(ARG "" "${one_value_args}" "${multi_value_args}"
-                      "${ARGN}")
+  fb_cmake_parse_args(
+    ARG "" "${one_value_args}" "${multi_value_args}" "${ARGN}"
+  )
   if(NOT DEFINED ARG_INCLUDE_DIR)
     set(ARG_INCLUDE_DIR "include")
   endif()
@@ -28,134 +35,168 @@ function(add_fbthrift_cpp_library LIB_NAME THRIFT_FILE)
   endif()
 
   get_filename_component(base ${THRIFT_FILE} NAME_WE)
-  get_filename_component(output_dir ${CMAKE_CURRENT_BINARY_DIR}/${THRIFT_FILE}
-                         DIRECTORY)
+  get_filename_component(
+    output_dir
+    ${CMAKE_CURRENT_BINARY_DIR}/${THRIFT_FILE}
+    DIRECTORY
+  )
 
   # Generate relative paths in #includes
-  file(RELATIVE_PATH include_prefix "${CMAKE_SOURCE_DIR}"
-       "${CMAKE_CURRENT_SOURCE_DIR}/${THRIFT_FILE}")
+  file(
+    RELATIVE_PATH include_prefix
+    "${CMAKE_SOURCE_DIR}"
+    "${CMAKE_CURRENT_SOURCE_DIR}/${THRIFT_FILE}"
+  )
   get_filename_component(include_prefix ${include_prefix} DIRECTORY)
 
-  if(NOT "${include_prefix}" STREQUAL "")
+  if (NOT "${include_prefix}" STREQUAL "")
     list(APPEND ARG_OPTIONS "include_prefix=${include_prefix}")
   endif()
-  # CMake 3.12 is finally getting a list(JOIN) function, but until then treating
-  # the list as a string and replacing the semicolons is good enough.
+  # CMake 3.12 is finally getting a list(JOIN) function, but until then
+  # treating the list as a string and replacing the semicolons is good enough.
   string(REPLACE ";" "," GEN_ARG_STR "${ARG_OPTIONS}")
 
   # Compute the list of generated files
-  list(
-    APPEND
-    generated_headers
+  list(APPEND generated_headers
     "${output_dir}/gen-cpp2/${base}_constants.h"
     "${output_dir}/gen-cpp2/${base}_types.h"
     "${output_dir}/gen-cpp2/${base}_types.tcc"
     "${output_dir}/gen-cpp2/${base}_types_custom_protocol.h"
-    "${output_dir}/gen-cpp2/${base}_metadata.h")
-  list(
-    APPEND
-    generated_sources
+    "${output_dir}/gen-cpp2/${base}_metadata.h"
+  )
+  list(APPEND generated_sources
     "${output_dir}/gen-cpp2/${base}_constants.cpp"
     "${output_dir}/gen-cpp2/${base}_data.h"
     "${output_dir}/gen-cpp2/${base}_data.cpp"
     "${output_dir}/gen-cpp2/${base}_types.cpp"
-    "${output_dir}/gen-cpp2/${base}_metadata.cpp")
+    "${output_dir}/gen-cpp2/${base}_types_binary.cpp"
+    "${output_dir}/gen-cpp2/${base}_types_compact.cpp"
+    "${output_dir}/gen-cpp2/${base}_types_serialization.cpp"
+    "${output_dir}/gen-cpp2/${base}_metadata.cpp"
+  )
   foreach(service IN LISTS ARG_SERVICES)
-    list(
-      APPEND
-      generated_headers
+    list(APPEND generated_headers
       "${output_dir}/gen-cpp2/${service}.h"
       "${output_dir}/gen-cpp2/${service}.tcc"
       "${output_dir}/gen-cpp2/${service}AsyncClient.h"
-      "${output_dir}/gen-cpp2/${service}_custom_protocol.h")
-    list(
-      APPEND
-      generated_sources
+      "${output_dir}/gen-cpp2/${service}_custom_protocol.h"
+    )
+    list(APPEND generated_sources
       "${output_dir}/gen-cpp2/${service}.cpp"
       "${output_dir}/gen-cpp2/${service}AsyncClient.cpp"
       "${output_dir}/gen-cpp2/${service}_processmap_binary.cpp"
-      "${output_dir}/gen-cpp2/${service}_processmap_compact.cpp")
+      "${output_dir}/gen-cpp2/${service}_processmap_compact.cpp"
+    )
   endforeach()
 
-  # This generator expression gets the list of include directories required for
-  # all of our dependencies. It requires using COMMAND_EXPAND_LISTS in the
-  # add_custom_command() call below.  COMMAND_EXPAND_LISTS is only available in
-  # CMake 3.8+ If we really had to support older versions of CMake we would
-  # probably need to use a wrapper script around the thrift compiler that could
-  # take the include list as a single argument and split it up before invoking
-  # the thrift compiler.
-  if(NOT POLICY CMP0067)
+  # This generator expression gets the list of include directories required
+  # for all of our dependencies.
+  # It requires using COMMAND_EXPAND_LISTS in the add_custom_command() call
+  # below.  COMMAND_EXPAND_LISTS is only available in CMake 3.8+
+  # If we really had to support older versions of CMake we would probably need
+  # to use a wrapper script around the thrift compiler that could take the
+  # include list as a single argument and split it up before invoking the
+  # thrift compiler.
+  if (NOT POLICY CMP0067)
     message(FATAL_ERROR "add_fbthrift_cpp_library() requires CMake 3.8+")
   endif()
-  set(thrift_include_options
-      "-I;$<JOIN:$<TARGET_PROPERTY:${LIB_NAME}.thrift_includes,INTERFACE_INCLUDE_DIRECTORIES>,;-I;>"
+  set(
+    thrift_include_options
+    "-I;$<JOIN:$<TARGET_PROPERTY:${LIB_NAME}.thrift_includes,INTERFACE_INCLUDE_DIRECTORIES>,;-I;>"
   )
 
   # Emit the rule to run the thrift compiler
   add_custom_command(
-    OUTPUT ${generated_headers} ${generated_sources}
+    OUTPUT
+      ${generated_headers}
+      ${generated_sources}
     COMMAND_EXPAND_LISTS
-    COMMAND "${CMAKE_COMMAND}" -E make_directory "${output_dir}"
+    COMMAND
+      "${CMAKE_COMMAND}" -E make_directory "${output_dir}"
     COMMAND
       "${FBTHRIFT_COMPILER}"
-      # TODO: this flag does not exist in all fbthrift versions. --legacy-strict
-      --gen "mstch_cpp2:${GEN_ARG_STR}" "${thrift_include_options}" -I
-      "${FBTHRIFT_INCLUDE_DIR}" -o "${output_dir}"
+      --legacy-strict
+      --gen "mstch_cpp2:${GEN_ARG_STR}"
+      "${thrift_include_options}"
+      -I "${FBTHRIFT_INCLUDE_DIR}"
+      -o "${output_dir}"
       "${CMAKE_CURRENT_SOURCE_DIR}/${THRIFT_FILE}"
-    WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
-    MAIN_DEPENDENCY "${THRIFT_FILE}"
-    DEPENDS ${ARG_DEPENDS} "${FBTHRIFT_COMPILER}")
+    WORKING_DIRECTORY
+      "${CMAKE_BINARY_DIR}"
+    MAIN_DEPENDENCY
+      "${THRIFT_FILE}"
+    DEPENDS
+      ${ARG_DEPENDS}
+      "${FBTHRIFT_COMPILER}"
+  )
 
   # Now emit the library rule to compile the sources
-  if(BUILD_SHARED_LIBS)
+  if (BUILD_SHARED_LIBS)
     set(LIB_TYPE SHARED)
-  else()
+  else ()
     set(LIB_TYPE STATIC)
-  endif()
+  endif ()
 
-  add_library("${LIB_NAME}" ${LIB_TYPE} ${generated_sources})
+  add_library(
+    "${LIB_NAME}" ${LIB_TYPE}
+    ${generated_sources}
+  )
 
   target_include_directories(
-    "${LIB_NAME}" PUBLIC "$<BUILD_INTERFACE:${CMAKE_BINARY_DIR}>"
-                         "$<INSTALL_INTERFACE:${ARG_INCLUDE_DIR}>")
+    "${LIB_NAME}"
+    PUBLIC
+      "$<BUILD_INTERFACE:${CMAKE_BINARY_DIR}>"
+      "$<INSTALL_INTERFACE:${ARG_INCLUDE_DIR}>"
+      ${Xxhash_INCLUDE_DIR}
+  )
   target_link_libraries(
     "${LIB_NAME}"
-    PUBLIC ${ARG_DEPENDS}
-           Folly::folly
-           FBThrift::thriftcpp2
-           # TODO: these symbols require other dependencies that need to be
-           # correctly handle by Velox's build system before they can be
-           # enabled. mvfst::mvfst_server_async_tran mvfst::mvfst_server
+    PUBLIC
+      ${ARG_DEPENDS}
+      FBThrift::thriftcpp2
+      Folly::folly
+      mvfst::mvfst_server_async_tran
+      mvfst::mvfst_server
+      ${Xxhash_LIBRARY}
   )
 
   # Add ${generated_headers} to the PUBLIC_HEADER property for ${LIB_NAME}
   #
-  # This allows callers to install it using "install(TARGETS ${LIB_NAME}
-  # PUBLIC_HEADER)" However, note that CMake's PUBLIC_HEADER behavior is rather
-  # inflexible, and does have any way to preserve header directory structure.
-  # Callers must be careful to use the correct PUBLIC_HEADER DESTINATION
-  # parameter when doing this, to put the files the correct directory
-  # themselves. We define a HEADER_INSTALL_DIR property with the include
-  # directory prefix, so typically callers should specify the PUBLIC_HEADER
-  # DESTINATION as "$<TARGET_PROPERTY:${LIB_NAME},HEADER_INSTALL_DIR>"
-  set_property(TARGET "${LIB_NAME}" PROPERTY PUBLIC_HEADER ${generated_headers})
+  # This allows callers to install it using
+  # "install(TARGETS ${LIB_NAME} PUBLIC_HEADER)"
+  # However, note that CMake's PUBLIC_HEADER behavior is rather inflexible,
+  # and does have any way to preserve header directory structure.  Callers
+  # must be careful to use the correct PUBLIC_HEADER DESTINATION parameter
+  # when doing this, to put the files the correct directory themselves.
+  # We define a HEADER_INSTALL_DIR property with the include directory prefix,
+  # so typically callers should specify the PUBLIC_HEADER DESTINATION as
+  # "$<TARGET_PROPERTY:${LIB_NAME},HEADER_INSTALL_DIR>"
+  set_property(
+    TARGET "${LIB_NAME}"
+    PROPERTY PUBLIC_HEADER ${generated_headers}
+  )
 
   # Define a dummy interface library to help propagate the thrift include
   # directories between dependencies.
   add_library("${LIB_NAME}.thrift_includes" INTERFACE)
   target_include_directories(
     "${LIB_NAME}.thrift_includes"
-    INTERFACE "$<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>"
-              "$<INSTALL_INTERFACE:${ARG_THRIFT_INCLUDE_DIR}>")
+    INTERFACE
+      "$<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>"
+      "$<INSTALL_INTERFACE:${ARG_THRIFT_INCLUDE_DIR}>"
+  )
   foreach(dep IN LISTS ARG_DEPENDS)
-    target_link_libraries("${LIB_NAME}.thrift_includes"
-                          INTERFACE "${dep}.thrift_includes")
+    target_link_libraries(
+      "${LIB_NAME}.thrift_includes"
+      INTERFACE "${dep}.thrift_includes"
+    )
   endforeach()
 
   set_target_properties(
     "${LIB_NAME}"
-    PROPERTIES EXPORT_PROPERTIES "THRIFT_INSTALL_DIR"
-               THRIFT_INSTALL_DIR "${ARG_THRIFT_INCLUDE_DIR}/${include_prefix}"
-               HEADER_INSTALL_DIR
-               "${ARG_INCLUDE_DIR}/${include_prefix}/gen-cpp2")
+    PROPERTIES
+      EXPORT_PROPERTIES "THRIFT_INSTALL_DIR"
+      THRIFT_INSTALL_DIR "${ARG_THRIFT_INCLUDE_DIR}/${include_prefix}"
+      HEADER_INSTALL_DIR "${ARG_INCLUDE_DIR}/${include_prefix}/gen-cpp2"
+  )
 endfunction()
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4b048a59739..bd6d45055ed 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -111,7 +111,7 @@ endif()
 if(VELOX_BUILD_SHARED)
   message(
     WARNING
-    "When building Velox as a shared library it's recommended to build against a shared build of folly to avoid issues with linking of gflags."
+    "When building Velox as a shared library it's recommended to build against a shared build of folly to avoid issues with linking of gflags. "
     "This is currently NOT being enforced so user discretion is advised."
   )
 endif()
@@ -156,7 +156,7 @@ option(VELOX_ENABLE_ABFS "Build Abfs Connector" OFF)
 option(VELOX_ENABLE_HDFS "Build Hdfs Connector" OFF)
 option(VELOX_ENABLE_PARQUET "Enable Parquet support" ON)
 option(VELOX_ENABLE_ARROW "Enable Arrow support" OFF)
-option(VELOX_ENABLE_GEO "Enable Geospatial support" OFF)
+option(VELOX_ENABLE_GEO "Enable Geospatial support" ON)
 option(VELOX_ENABLE_REMOTE_FUNCTIONS "Enable remote function support" OFF)
 option(VELOX_ENABLE_CCACHE "Use ccache if installed." ON)
 option(VELOX_ENABLE_COMPRESSION_LZ4 "Enable Lz4 compression support." OFF)
@@ -212,9 +212,24 @@ if(VELOX_ENABLE_BENCHMARKS_BASIC)
   set(VELOX_BUILD_TEST_UTILS ON)
 endif()
 
+if(VELOX_ENABLE_CUDF)
+  if(NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    message(FATAL_ERROR "cuDF requires GCC. Found ${CMAKE_CXX_COMPILER_ID}.")
+  elseif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 13.3)
+    message(FATAL_ERROR "cuDF requires GCC >= 13.3. Found GCC ${CMAKE_CXX_COMPILER_VERSION}.")
+  endif()
+  message(STATUS "Building curl from source to satisfy cuDF curl version requirement")
+  set(CURL_SOURCE BUNDLED)
+  velox_resolve_dependency(CURL)
+endif()
+
 if(VELOX_BUILD_TESTING OR VELOX_BUILD_TEST_UTILS)
-  set(cpr_SOURCE BUNDLED)
-  velox_resolve_dependency(cpr)
+  # cuDF bundles curl since it needs a specific version.
+  # Use bundled or system curl otherwise.
+  if(NOT VELOX_ENABLE_CUDF)
+    velox_set_source(CURL)
+    velox_resolve_dependency(CURL)
+  endif()
   set(VELOX_ENABLE_DUCKDB ON)
   set(VELOX_ENABLE_PARSE ON)
 endif()
@@ -300,7 +315,7 @@ if(VELOX_ENABLE_S3)
   if(AWSSDK_ROOT_DIR)
     list(APPEND CMAKE_PREFIX_PATH ${AWSSDK_ROOT_DIR})
   endif()
-  find_package(AWSSDK REQUIRED COMPONENTS s3;identity-management)
+  find_package(AWSSDK 1.11.654 REQUIRED COMPONENTS s3;identity-management)
   add_definitions(-DVELOX_ENABLE_S3)
 endif()
 
@@ -396,13 +411,6 @@ if(${CMAKE_SYSTEM_PROCESSOR} MATCHES "aarch64")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsigned-char")
 endif()
 
-# Ensure that we don't bring in headers that might have coroutines enabled. The
-# dependencies turn off coroutines in folly and the other FBOS dependencies. If
-# not explicitly turned off differences in the build using GCC cause libray
-# incompatibilities of the thrift server and the remote functions library
-# causing SEGVs in the tests.
-string(APPEND CMAKE_CXX_FLAGS " -DFOLLY_CFG_NO_COROUTINES")
-
 # Under Ninja, we are able to designate certain targets large enough to require
 # restricted parallelism.
 if("${MAX_HIGH_MEM_JOBS}")
@@ -445,7 +453,8 @@ if(ENABLE_ALL_WARNINGS)
     endif()
     if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "14.0.0")
       string(APPEND KNOWN_COMPILER_SPECIFIC_WARNINGS " -Wno-error=template-id-cdtor")
-      string(APPEND KNOWN_COMPILER_SPECIFIC_WARNINGS " -Wno-error=overloaded-virtual")
+      string(APPEND KNOWN_COMPILER_SPECIFIC_WARNINGS " -Wno-overloaded-virtual")
+      string(APPEND KNOWN_COMPILER_SPECIFIC_WARNINGS " -Wno-error=tautological-compare")
     endif()
   endif()
 
@@ -472,9 +481,16 @@ if(VELOX_ENABLE_WAVE OR VELOX_ENABLE_CUDF)
     message(FATAL_ERROR "-DCMAKE_CUDA_ARCHITECTURES= must be set")
   endif()
   if(CMAKE_BUILD_TYPE MATCHES Debug)
-    add_compile_options("$<$<COMPILE_LANGUAGE:CUDA>:-G>")
+    set(VELOX_CUDA_DEBUG_FLAGS "$<$<COMPILE_LANGUAGE:CUDA>:-G>")
   endif()
   find_package(CUDAToolkit REQUIRED)
+  # Suppress deprecated GPU targets warning for CUDA 12.8.x
+  if(
+    CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 12.8.0
+    AND CMAKE_CUDA_COMPILER_VERSION VERSION_LESS 13.0.0
+  )
+    string(APPEND CMAKE_CUDA_FLAGS " -Wno-deprecated-gpu-targets")
+  endif()
   if(VELOX_ENABLE_CUDF)
     foreach(arch ${CMAKE_CUDA_ARCHITECTURES})
       if(arch LESS 70)
@@ -487,6 +503,16 @@ if(VELOX_ENABLE_WAVE OR VELOX_ENABLE_CUDF)
     set(VELOX_ENABLE_ARROW ON)
     velox_set_source(cudf)
     velox_resolve_dependency(cudf)
+    if(TARGET aws-cpp-sdk-core)
+      # Fix for AWS SDK CPP using hardcoded system curl instead of soft link to curl
+      get_target_property(override_curl_lib aws-cpp-sdk-core INTERFACE_LINK_LIBRARIES)
+      list(REMOVE_ITEM override_curl_lib "/usr/lib64/libcurl.so")
+      list(APPEND override_curl_lib "\$<LINK_ONLY:CURL::libcurl>")
+      set_target_properties(
+        aws-cpp-sdk-core
+        PROPERTIES INTERFACE_LINK_LIBRARIES "${override_curl_lib}"
+      )
+    endif()
   endif()
 endif()
 
@@ -546,15 +572,17 @@ if(NOT TARGET gflags::gflags)
   # target even when velox is built as a subproject which uses
   # `find_package(gflags)` which does not create a globally imported target that
   # we can ALIAS.
-  add_library(gflags_gflags INTERFACE)
-  target_link_libraries(gflags_gflags INTERFACE gflags)
-  add_library(gflags::gflags ALIAS gflags_gflags)
+  add_library(gflags::gflags ALIAS gflags)
 endif()
 
 if(${gflags_SOURCE} STREQUAL "BUNDLED")
-  # we force glog from source to avoid issues with a system version built
-  # against another gflags version (which is likely)
-  set(glog_SOURCE BUNDLED)
+  # Allow explicit glog_SOURCE override (e.g. when system glog is built
+  # against the same gflags version as BUNDLED).
+  if(DEFINED ENV{glog_SOURCE})
+    set(glog_SOURCE $ENV{glog_SOURCE})
+  else()
+    set(glog_SOURCE BUNDLED)
+  endif()
 else()
   set(glog_SOURCE SYSTEM)
 endif()
@@ -574,13 +602,16 @@ if(${VELOX_BUILD_MINIMAL_WITH_DWIO} OR ${VELOX_ENABLE_HIVE_CONNECTOR})
   find_package(ZLIB REQUIRED)
   find_package(zstd REQUIRED)
   find_package(Snappy REQUIRED)
+  # Ensure zstd::zstd target exists - handle different zstd package configurations
   if(NOT TARGET zstd::zstd)
     if(TARGET zstd::libzstd_static)
-      set(ZSTD_TYPE static)
+      add_library(zstd::zstd ALIAS zstd::libzstd_static)
+    elseif(TARGET zstd::libzstd_shared)
+      add_library(zstd::zstd ALIAS zstd::libzstd_shared)
     else()
-      set(ZSTD_TYPE shared)
+      # Fallback: use Findzstd.cmake to create the target
+      include(Findzstd)
     endif()
-    add_library(zstd::zstd ALIAS zstd::libzstd_${ZSTD_TYPE})
   endif()
 endif()
 
@@ -602,7 +633,10 @@ if(${VELOX_BUILD_MINIMAL_WITH_DWIO} OR ${VELOX_ENABLE_HIVE_CONNECTOR} OR VELOX_E
 endif()
 
 velox_set_source(simdjson)
-velox_resolve_dependency(simdjson 3.9.3)
+velox_resolve_dependency(simdjson 4.1.0)
+
+velox_set_source(FastFloat)
+velox_resolve_dependency(FastFloat)
 
 velox_set_source(folly)
 velox_resolve_dependency(folly)
@@ -636,9 +670,15 @@ if(VELOX_ENABLE_GCS)
 endif()
 
 # GCC needs to link a library to enable std::filesystem.
+# GCC needs to enable co-routines. We only support compiler that
+# support coroutines.
 if("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
   # Find Threads library
   find_package(Threads REQUIRED)
+  add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-fcoroutines>)
+  # Explicitly enable folly coroutines when compiler supports them.
+  # This is required for folly::coro::AsyncGenerator to work correctly.
+  add_compile_definitions(FOLLY_HAS_COROUTINES=1)
 endif()
 
 if(VELOX_BUILD_TESTING AND NOT VELOX_ENABLE_DUCKDB)
@@ -706,10 +746,6 @@ endif()
 
 include_directories(.)
 
-# TODO: Include all other installation files. For now just making sure this
-# generates an installable makefile.
-install(FILES velox/type/Type.h DESTINATION "include/velox")
-
 # Adding this down here prevents warnings in dependencies from stopping the
 # build
 if("${TREAT_WARNINGS_AS_ERRORS}")
@@ -728,4 +764,10 @@ if(VELOX_ENABLE_GEO)
   velox_resolve_dependency(geos)
 endif()
 
+if(VELOX_ENABLE_GEO)
+  list(PREPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/CMake/resolve_dependency_modules/s2geometry)
+  velox_set_source(s2geometry)
+  velox_resolve_dependency(s2geometry)
+endif()
+
 add_subdirectory(velox)
diff --git a/CODING_STYLE.md b/CODING_STYLE.md
index 43947192cd7..1942d7096ce 100644
--- a/CODING_STYLE.md
+++ b/CODING_STYLE.md
@@ -83,6 +83,46 @@ line width, indentation and ordering (for includes, using directives and etc). 
   code paths, and are not recommended for use in production environments. For
   example, `debug_disable_expression_with_peeling` is used to disable peeling
   optimization employed in expression evaluation.
+* **Never name a file or class `*Utils`, `*Helpers`, or `*Common`.** These
+  generic names attract unrelated functions over time and lose cohesion.
+  Instead, name files and classes after the concept they represent. When
+  extracting shared functions, ask: "What do these functions have in common
+  beyond being useful?" The answer is the name. Use a class with static methods
+  to group related operations, and shorten method names since the class name
+  provides context.
+
+  ```cpp
+  // ❌ Wrong — generic name, will attract unrelated functions.
+  class ParserUtils {
+    static std::vector<size_t> widenProjectionsForSort(...);
+    static void sortAndTrimProjections(...);
+  };
+
+  // ✅ Correct — named after the concept (sorting + projections).
+  class SortProjection {
+    static std::vector<size_t> widenProjections(...);
+    static void sortAndTrim(...);
+  };
+  ```
+
+* **Do not abbreviate** variable, function, or class names. Use full,
+  descriptive names. Clarity is more important than brevity.
+
+  | ❌ Avoid | ✅ Prefer |
+  |----------|-----------|
+  | `outputCol` | `outputColumn` |
+  | `val` | `value` |
+  | `idx` | `index` |
+  | `agg` | `aggregation` |
+  | `sel` | `selectivity` |
+  | `rowCount` | `numRows` |
+
+  * Well-established abbreviations in the domain are acceptable (e.g., `id`,
+    `url`, `sql`, `expr`).
+  * Loop indices like `i`, `j`, `k` are acceptable for simple loops.
+  * Iterator variables named `it` are acceptable.
+  * `numXxx` naming pattern is acceptable and preferred over `xxxCount` or
+    `xxxCnt` (e.g., `numRows`, `numKeys`).
 
 ## Comments
 
@@ -154,8 +194,40 @@ About comment style:
 
   * Include enough context in the comment itself to make clear what will be
     done, without requiring any references from outside the code.
-  * Do not include the author’s username. If required, this can always be
+  * Do not include the author's username. If required, this can always be
     retrieved from git blame.
+* **Start comments with active verbs**, not "This class…" or "This method…".
+
+  | ❌ Avoid | ✅ Prefer |
+  |----------|-----------|
+  | `/// This class builds query plans.` | `/// Builds query plans.` |
+  | `/// This method computes selectivity.` | `/// Computes selectivity.` |
+  | `/// This function returns the cost.` | `/// Returns the cost.` |
+
+* **Avoid redundant comments** that simply repeat what the code already says.
+  Comments should explain *why*, not *what*.
+
+```cpp
+// ❌ Avoid - comment just repeats the code
+// Increment the counter.
+++counter;
+
+// ❌ Avoid - comment states the obvious
+// Return the result.
+return result;
+
+// ✅ Prefer - no comment needed when code is self-explanatory
+++counter;
+return result;
+
+// ✅ Prefer - comment explains WHY, not WHAT
+// Use a larger buffer to avoid repeated reallocations for typical queries.
+buffer.reserve(1024);
+```
+
+* **Do not duplicate comments between `.h` and `.cpp`.** Document the function
+  in the header; the implementation should not repeat the same comment.
+  Duplicated comments diverge over time.
 
 ## Asserts and CHECKs
 
@@ -187,6 +259,12 @@ About comment style:
       i)`
     * Note that the values of v1 and v2 are already included in the exception
       message by default.
+* Put runtime information (names, values, types) at the **end** of error
+  messages, after the static description.
+
+  | ❌ Avoid | ✅ Prefer |
+  |----------|-----------|
+  | `VELOX_USER_FAIL("Column '{}' is ambiguous", name);` | `VELOX_USER_FAIL("Column is ambiguous: {}", name);` |
 
 ## Variables
 
@@ -208,6 +286,9 @@ About comment style:
   * `int* foo;` `const Bar& bar;` NOT `int *foo;` `const Bar &bar`;
   * Beware that `int* foo, bar;` will be parsed as declaring `foo` as an `int*`
     and `bar` as an `int`. Note that multiple declaration is discouraged.
+* Use trailing commas in multi-line initializer lists, enum definitions, and
+  function-call argument lists that span multiple lines. This produces cleaner
+  diffs when items are added or reordered.
 * For member variables:
   * Group member variable and methods based on their visibility (public,
     protected and private)
@@ -234,8 +315,14 @@ About comment style:
 
 * Always use `nullptr` if you need a constant that represents a null pointer
   (`T*` for some `T`); use `0` otherwise for a zero value.
-* For large literal numbers, use ‘ to make it more readable, e.g:  `1’000’000`
-  instead of `1000000`.
+* For large literal numbers, use `'` to improve readability. Use digit
+  separators for numbers with 4 or more digits.
+
+  | ❌ Avoid | ✅ Prefer |
+  |----------|-----------|
+  | `10000` | `10'000` |
+  | `1000000` | `1'000'000` |
+  | `100` | `100` (no separator needed) |
 * For floating point literals, never omit the initial 0 before the decimal
   point (always `0.5`, not `.5`).
 * File level variables and constants should be defined in an anonymous
@@ -246,16 +333,17 @@ About comment style:
 * As a general rule, do not use string literals without declaring a named
   constant for them.
   * The best way to make a constant string literal is to use constexpr
-    `std::string_view`/`folly::StringPiece`
+    `std::string_view`
   * **NEVER** use `std::string` - this makes your code more prone to SIOF bugs.
   * Avoid `const char* const` and `const char*` - these are less efficient to
     convert to `std::string` later on in your program if you ever need to
-    because `std::string_view`/ `folly::StringPiece` knows its size and can use
-    a more efficient constructor. `std::string_view`/ `folly::StringPiece` also
-    has richer interfaces and often works as a drop-in replacement to
-    `std::string`.
+    because `std::string_view` knows its size and can use a more efficient
+    constructor. `std::string_view` also has richer interfaces and often
+    works as a drop-in replacement to `std::string`.
   * Need compile-time string concatenation? You can use `folly::FixedString`
     for that.
+  * Do not use `folly::StringPiece` in new code, use `std::string_view`
+    instead.
 
 ## Macros
 
@@ -300,6 +388,20 @@ macro names are always upper-snake-case. Also:
     should opening the `-inl.h` be necessary (or the .cpp file, for that
     matter).
 
+### CMake Header Ownership
+
+Every `.h` file in the Velox codebase must be associated with a CMake target.
+This ensures headers are discoverable through the CMake File API, enabling
+build impact analysis and selective builds.
+
+* When adding headers to a `velox_add_library()` target, list them under the
+  `HEADERS` keyword.
+* When adding headers to test, benchmark, or fuzzer targets that use
+  `add_library()` or `add_executable()`, use
+  `velox_add_test_headers(<target> <header>)`.
+* The `check-header-ownership` pre-commit hook will flag any `.h` file that
+  is not tracked by a CMake target.
+
 ## Function Arguments
 
 * Const
@@ -415,3 +517,160 @@ using TypePtr = std::shared_ptr<const Type>;
 using ContinueFuture = folly::SemiFuture<bool>;
 using ContinuePromise = VeloxPromise<bool>;
 ```
+
+## API Design
+
+* **Keep the public API surface small.** Do not expose methods or types that
+  callers don't need. Fewer public symbols mean less coupling and easier
+  evolution.
+* **Prefer free functions in .cpp over class methods.** If a helper doesn't
+  need access to class state or doesn't need to be called from outside the
+  translation unit, make it a free function (typically in an anonymous
+  namespace) rather than a static or private method.
+* **Define free functions close to where they are used**, not grouped together
+  at the top or bottom of the file.
+* **Keep method implementations in .cpp.** Except for trivial one-liners,
+  define methods in the .cpp file to keep headers small and reduce build times.
+* **Avoid default arguments** when all callers can pass values explicitly.
+* **Never use `friend`, `FRIEND_TEST`, or any friend declarations.** If a test
+  needs access to private members, redesign the API or test through public
+  methods instead.
+
+## Tests
+
+* **Place new tests next to related existing tests**, not at the end of the
+  file. Group tests by topic (e.g., place `tryCast` next to `types`,
+  `notBetween` next to `ifClause` which uses `between`).
+* **Use gtest container matchers** (`testing::ElementsAre`, etc.) for
+  verifying collections:
+
+  ```cpp
+  // ❌ Avoid - multiple individual assertions
+  EXPECT_EQ(result.size(), 3);
+  EXPECT_EQ(result[0], "a");
+  EXPECT_EQ(result[1], "b");
+  EXPECT_EQ(result[2], "c");
+
+  // ✅ Prefer - single matcher assertion
+  EXPECT_THAT(result, testing::ElementsAre("a", "b", "c"));
+  ```
+
+  Common matchers:
+  * `ElementsAre(...)` - exact ordered match
+  * `UnorderedElementsAre(...)` - exact unordered match
+  * `Contains(...)` - at least one element matches
+  * `IsEmpty()` - collection is empty
+  * `SizeIs(n)` - collection has n elements
+
+  Requires `#include <gmock/gmock.h>`.
+
+## Common Mistakes
+
+These are frequently violated rules. Check every new or modified line against
+this list before finishing.
+
+### Bug fixes without a failing test first
+
+When fixing a bug, write the test **first**, run it, and confirm it **fails**
+before applying the fix. Then apply the fix and confirm the test passes. If you
+wrote the test after the fix, temporarily revert the fix and verify the test
+fails. A test that passes both with and without the fix proves nothing. This is
+the single most important workflow rule for bug fixes.
+
+### `///` vs `//` — wrong comment style
+
+`///` is **only** for public API: public classes, public methods, public member
+variables. Everything else uses `//`: private/protected members, anonymous
+namespace functions and types, comments inside function bodies.
+
+```cpp
+// ❌ Wrong — anonymous-namespace function is not public API.
+namespace {
+/// Returns true if 'a' is a prefix of 'b'.
+bool isPrefix(const ExprVector& a, const ExprVector& b);
+} // namespace
+
+// ✅ Correct.
+namespace {
+// Returns true if 'a' is a prefix of 'b'.
+bool isPrefix(const ExprVector& a, const ExprVector& b);
+} // namespace
+```
+
+### One-letter and abbreviated variable names
+
+Do not abbreviate. Use full, descriptive names. Loop indices (`i`, `j`) are
+acceptable. Everything else — function parameters, lambda parameters, local
+variables — must be descriptive.
+
+```cpp
+// ❌ Wrong — one-letter names and abbreviations.
+bool sameKeys(const ExprVector& a, const ExprVector& b);
+std::sort(groups.begin(), groups.end(), [](const auto& a, const auto& b) { ... });
+
+// ✅ Correct — descriptive names.
+bool sameKeys(const ExprVector& lhs, const ExprVector& rhs);
+std::sort(groups.begin(), groups.end(), [](const auto& lhs, const auto& rhs) { ... });
+```
+
+### Undocumented APIs in headers
+
+Every class, every non-trivial method declaration, and every member variable in
+a `.h` file must have a comment. Trivial one-liner getters may be left
+undocumented if the name is self-explanatory.
+
+```cpp
+// ❌ Wrong — no comment on method declaration.
+  ExprPtr translate(const PlanNode* node);
+
+// ✅ Correct.
+  // Translates a logical plan node to an executable expression.
+  ExprPtr translate(const PlanNode* node);
+```
+
+### Non-trivial implementations in headers
+
+Keep method implementations in `.cpp` except for trivial one-liners. If a
+method body has more than one statement, it belongs in the `.cpp` file.
+
+### `goto` statements
+
+Never use `goto`. Restructure the code using early returns, helper functions, or
+duplicated code paths instead. `goto` makes control flow hard to follow and is
+never necessary in C++.
+
+### Fitting tests to buggy code
+
+When a test fails, **never** update the test expectation to match what the code
+produces without first verifying that the code is correct. The default
+assumption should be that the code is wrong, not the test.
+
+### Generic file and class names (`*Utils`, `*Helpers`, `*Common`)
+
+Never name a file or class `*Utils`, `*Helpers`, or `*Common`. These generic
+names attract unrelated functions over time and lose cohesion. Instead, name
+files and classes after the concept they represent. When extracting shared
+functions, ask: "What do these functions have in common beyond being useful?"
+The answer is the name.
+
+### Verify causation before asserting it
+
+When investigating a test failure or regression, do not attribute it to a
+specific commit based on the commit message alone. Verify empirically by
+checking out the parent commit and running the test. Incorrect attribution
+leads to wrong fixes — e.g., updating test expectations when the real problem
+is a bug introduced by a different commit.
+
+### Silently simplifying an approved plan
+
+Never silently simplify or skip parts of an approved implementation plan. If a
+step turns out to be harder than expected, or you want to defer it, say so
+explicitly and get approval before proceeding with a reduced scope. Reporting
+"done" when a key piece was dropped is worse than asking for help.
+
+### Working around infrastructure bugs
+
+When you discover a bug in test infrastructure, shared helpers, or common
+utilities, do **not** silently work around it. Stop, report the finding, and
+discuss whether to fix the root cause or work around it. Workarounds accumulate
+into technical debt and mask real problems.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index a76dd9e334c..751e9f8c960 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -137,6 +137,7 @@ where:
 * *Type* can be any of the following keywords:
   * **feat** when new features are being added.
   * **fix** for bug fixes.
+  * **perf** for performance improvements.
   * **build** for build or CI-related improvements.
   * **test** for adding tests (only).
   * **docs** for enhancements to documentation (only).
@@ -224,6 +225,47 @@ following best practices:
    your PR. If a component or API does not have a corresponding
    unit test suite, please consider improving the codebase by first adding a
    new unit test suite to ensure the existing behavior is correct.
+   * **Common test workflows**:
+     ```bash
+     # Run all tests in parallel.
+     cd _build/debug && ctest -j 8
+
+     # Run all test binaries whose ctest name matches a regex.
+     # On Linux this matches velox_exec_test_group0 … _group7.
+     # On macOS this matches velox_exec_test_ValuesTest,
+     # velox_exec_test_HashJoinTest, etc.
+     cd _build/debug && ctest -R velox_exec
+
+     # Run a single test binary by name (works on macOS where each
+     # test file produces its own binary).
+     cd _build/debug && ctest -R ValuesTest
+     ```
+   * **Re-running a CI failure locally**: CI reports a failure in
+   `velox_exec_test_group3` with `ValuesTest.empty`. On Linux, run the grouped
+   binary directly. On macOS, the grouped binary does not exist — use the
+   per-file binary instead:
+     ```bash
+     # Linux (grouped binary)
+     _build/debug/velox/exec/tests/velox_exec_test_group3 --gtest_filter="ValuesTest.empty"
+     # macOS (per-file binary)
+     _build/debug/velox/exec/tests/velox_exec_test_ValuesTest --gtest_filter="ValuesTest.empty"
+     ```
+   * **Test binary structure**: Four test suites (`velox/exec/tests`,
+   `velox/functions/prestosql/aggregates/tests`, `velox/common/caching/tests`,
+   `velox/serializers/tests`) use grouped binaries on Linux CI (e.g.,
+   `velox_exec_test_group0` through `_group7`) to reduce link times. All other
+   suites use individual binaries on all platforms. On macOS, grouping is off
+   by default and each test file gets its own binary (e.g.,
+   `velox_exec_test_ValuesTest`). To disable grouping on Linux, pass
+   `-DVELOX_ENABLE_GROUPED_TESTS=OFF` to CMake.
+   * **Adding a test to a grouped suite**: Add the source file to the `SOURCES`
+   list in the relevant `velox_add_grouped_tests()` call in `CMakeLists.txt`.
+   It is automatically assigned to a group on Linux and gets its own binary on
+   macOS. For new test suites, use `velox_add_grouped_tests` when the suite
+   has many test files (10+) that link against large libraries like velox
+   core — each individual binary pays the full link cost, so grouping
+   significantly reduces total CI build time. For suites with only a few
+   test files or lightweight dependencies, use `add_executable` / `add_test`.
 
 4. **Code Comments**: Appropriately add comments to your code and document APIs.
    * As a library, Velox code is optimized for the reader, not the writer.
diff --git a/README.md b/README.md
index 4880335989e..2043c7ca65b 100644
--- a/README.md
+++ b/README.md
@@ -20,6 +20,9 @@
 
 <img src="static/logo.svg" alt="Velox logo" width="50%" align="center" />
 
+[![Linux Build using GCC](https://github.com/facebookincubator/velox/actions/workflows/linux-build.yml/badge.svg)](https://github.com/facebookincubator/velox/actions/workflows/linux-build.yml)
+[![macOS Build](https://github.com/facebookincubator/velox/actions/workflows/macos.yml/badge.svg)](https://github.com/facebookincubator/velox/actions/workflows/macos.yml)
+
 Velox is a composable execution engine distributed as an open source C++
 library. It provides reusable, extensible, and high-performance data processing
 components that can be (re-)used to build data management systems focused on
@@ -88,7 +91,11 @@ found here](velox/examples)
 Developer guides detailing many aspects of the library, in addition to the list
 of available functions [can be found here.](https://facebookincubator.github.io/velox)
 
-Blog posts are available [here](https://velox-lib.io/blog).
+Recent blog posts ([all posts](https://velox-lib.io/blog)):
+
+- [FlatMapVector Adoption for Scaling High-Performance AI/ML Data Pre-Processing](https://velox-lib.io/blog/flatmapvector) (2026-05-01)
+- [Nimble Cluster Index: Efficient Indexed Lookups on Columnar Data](https://velox-lib.io/blog/nimble-cluster-index) (2026-04-27)
+- [Axiom: Composable Query Engines Built on Velox](https://velox-lib.io/blog/axiom-composable-query-engines) (2026-04-23)
 
 ## Community
 
@@ -171,7 +178,7 @@ Using the default install location `/usr/local` on macOS is discouraged since th
 location is used by certain Homebrew versions.
 
 Manually add the `INSTALL_PREFIX` value in the IDE or bash environment,
-say `export INSTALL_PREFIX=/Users/$USERNAME/velox/deps-install` to `~/.zshrc` so that
+say `export INSTALL_PREFIX=/Users/$USER/velox/deps-install` to `~/.zshrc` so that
 subsequent Velox builds can use the installed packages.
 
 *You can reuse `DEPENDENCY_INSTALL` and `INSTALL_PREFIX` for Velox clients such as Prestissimo
@@ -252,6 +259,13 @@ Run `make` in the root directory to compile the sources. For development, use
 `make debug` to build a non-optimized debug version, or `make release` to build
 an optimized version.  Use `make unittest` to build and run tests.
 
+Four test suites use grouped binaries on Linux CI to reduce link times
+(`velox/exec/tests`, `velox/functions/prestosql/aggregates/tests`,
+`velox/common/caching/tests`, `velox/serializers/tests`). All other suites use
+individual binaries on all platforms. On macOS, grouping is off by default. To
+disable grouping on Linux, pass `-DVELOX_ENABLE_GROUPED_TESTS=OFF` via
+`EXTRA_CMAKE_FLAGS`.
+
 Note that,
 * Velox requires a compiler at the minimum GCC 11.0 or Clang 15.0.
 * Velox requires the CPU to support instruction sets:
diff --git a/docker-bake.hcl b/docker-bake.hcl
index 3a63980522a..26a62dcb9ee 100644
--- a/docker-bake.hcl
+++ b/docker-bake.hcl
@@ -68,6 +68,13 @@ target "pyvelox" {
   args = {
     image              = "quay.io/pypa/manylinux_2_28:latest"
     VELOX_BUILD_SHARED = "OFF"
+    # pyvelox uses a manylinux base which is el8, not el9. The
+    # dockerfile's CENTOS_TZDATA_VERSION default is el9 (correct for
+    # the centos9/adapters targets); override here to the el8 build of
+    # the same upstream tzdata release. Keep the upstream version
+    # (2026a) in sync with CENTOS_TZDATA_VERSION at the top of
+    # scripts/docker/centos-multi.dockerfile.
+    CENTOS_TZDATA_VERSION = "2026a-1.el8"
   }
   matrix = {
     arch = ["amd64", "arm64"]
diff --git a/docker-compose.yml b/docker-compose.yml
index 5457efe33b7..c7c47c575f3 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -77,13 +77,17 @@ services:
             - driver: nvidia
               count: 1
               capabilities: [gpu]
+    environment:
+      CC: /opt/rh/gcc-toolset-14/root/bin/gcc # Default to gcc-14
+      CXX: /opt/rh/gcc-toolset-14/root/bin/g++ # Default to gcc-14
+      CUDAHOSTCXX: /opt/rh/gcc-toolset-14/root/bin/g++ # Default to gcc-14
 
   presto-java:
     extends: base-block
     image: ghcr.io/facebookincubator/velox-dev:presto-java
     build:
       args:
-        - PRESTO_VERSION=0.293
+        - PRESTO_VERSION=0.295
       dockerfile: scripts/docker/java.dockerfile
 
   spark-server:
@@ -93,6 +97,7 @@ services:
       args:
         - SPARK_VERSION=3.5.1
       dockerfile: scripts/docker/java.dockerfile
+      target: spark-server
 
   fedora:
     extends: base-block
diff --git a/python/test/test_debugger_runner.py b/python/test/test_debugger_runner.py
new file mode 100644
index 00000000000..5f33c10b31f
--- /dev/null
+++ b/python/test/test_debugger_runner.py
@@ -0,0 +1,313 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import unittest
+
+import pyarrow
+from pyvelox.arrow import to_velox
+from pyvelox.plan_builder import PlanBuilder
+from pyvelox.runner import (
+    LocalDebuggerRunner,
+)
+
+
+class TestPyVeloxDebuggerRunner(unittest.TestCase):
+    def setUp(self) -> None:
+        self._batch_size = 20
+        self._num_batches = 10
+        self._num_projections = 10
+
+        array = pyarrow.array(list(range(self._batch_size)))
+        # type: ignore
+        batch = pyarrow.record_batch([array], names=["c0"])
+
+        vector = to_velox(batch)
+        vectors = [vector] * self._num_batches
+
+        plan_builder = PlanBuilder().values(vectors)
+        self._node_ids = []
+
+        for _ in range(self._num_projections):
+            plan_builder.project(["c0 * 10 as c0"])
+            self._node_ids.append(plan_builder.get_plan_node().id())
+
+        self._plan_node = plan_builder.get_plan_node()
+
+    def _count_next(self, runner):
+        total_size = 0
+        it = runner.execute()
+
+        while True:
+            try:
+                vector = it.next()
+                total_size += vector.size()
+            except StopIteration:
+                break
+        return total_size
+
+    def _count_step(self, runner):
+        total_size = 0
+        it = runner.execute()
+
+        while True:
+            try:
+                vector = it.step()
+                total_size += vector.size()
+            except StopIteration:
+                break
+        return total_size
+
+    def test_undrained(self):
+        """Ensure tasks won't hang or fail if they are not completely drained."""
+        runner = LocalDebuggerRunner(self._plan_node)
+        runner.execute()
+
+    def test_next_no_breakpoints(self):
+        runner = LocalDebuggerRunner(self._plan_node)
+        self.assertEqual(self._count_next(runner), self._batch_size * self._num_batches)
+
+    def test_step_no_breakpoints(self):
+        runner = LocalDebuggerRunner(self._plan_node)
+        self.assertEqual(self._count_step(runner), self._batch_size * self._num_batches)
+
+    def test_next_with_breakpoints(self):
+        runner = LocalDebuggerRunner(self._plan_node)
+        runner.set_breakpoint(self._node_ids[3])
+        runner.set_breakpoint(self._node_ids[5])
+        self.assertEqual(self._count_next(runner), self._batch_size * self._num_batches)
+
+    def test_step_with_breakpoints(self):
+        runner = LocalDebuggerRunner(self._plan_node)
+        runner.set_breakpoint(self._node_ids[3])
+        runner.set_breakpoint(self._node_ids[5])
+        runner.set_breakpoint(self._node_ids[8])
+        self.assertEqual(
+            self._count_step(runner), self._batch_size * self._num_batches * 4
+        )
+
+    def test_step_all_breakpoints(self):
+        runner = LocalDebuggerRunner(self._plan_node)
+        [runner.set_breakpoint(i) for i in self._node_ids]
+        self.assertEqual(
+            self._count_step(runner),
+            self._batch_size * self._num_batches * (self._num_projections + 1),
+        )
+
+    def test_breakpoint_with_aggregate(self):
+        """Set a breakpoint before aggregation to see pre-aggregated data."""
+        batch_size = 100
+
+        # Create data with some duplicates for aggregation.
+        values = [i % 10 for i in range(batch_size)]
+        array = pyarrow.array(values)
+        batch = pyarrow.record_batch([array], names=["c0"])
+        vector = to_velox(batch)
+
+        # Produce the input vector 3 times.
+        plan_builder = PlanBuilder().values([vector, vector, vector])
+
+        plan_builder.aggregate(grouping_keys=["c0"], aggregations=["count(1) as cnt"])
+        agg_node_id = plan_builder.get_plan_node().id()
+
+        runner = LocalDebuggerRunner(plan_builder.get_plan_node())
+        runner.set_breakpoint(agg_node_id)
+
+        it = runner.execute()
+
+        # Get aggregate first input, 100 records.
+        it.step()
+        self.assertEqual(it.current().size(), 100)
+
+        # Get aggregate second input, 100 records.
+        it.step()
+        self.assertEqual(it.current().size(), 100)
+
+        # Ignore next aggregate input and move to the task output, 10 records.
+        it.next()
+        self.assertEqual(it.current().size(), 10)
+
+        # Should be done now.
+        with self.assertRaises(StopIteration):
+            it.next()
+
+    def test_iterator_at(self):
+        runner = LocalDebuggerRunner(self._plan_node)
+        runner.set_breakpoint(self._node_ids[3])
+        runner.set_breakpoint(self._node_ids[8])
+
+        it = runner.execute()
+        self.assertEqual(it.at(), "")
+
+        it.step()
+        self.assertEqual(it.at(), self._node_ids[3])
+
+        it.step()
+        self.assertEqual(it.at(), self._node_ids[8])
+
+        it.step()
+        self.assertEqual(it.at(), "")
+
+        it.step()
+        self.assertEqual(it.at(), self._node_ids[3])
+
+        it.next()
+        self.assertEqual(it.at(), "")
+
+        it.next()
+        self.assertEqual(it.at(), "")
+
+        it.step()
+        self.assertEqual(it.at(), self._node_ids[3])
+
+    def test_hook_always_stop(self):
+        """Hook that always returns True should behave like set_breakpoint."""
+        runner = LocalDebuggerRunner(self._plan_node)
+        runner.set_hook(self._node_ids[3], lambda v: True)
+        runner.set_hook(self._node_ids[5], lambda v: True)
+        runner.set_hook(self._node_ids[8], lambda v: True)
+        self.assertEqual(
+            self._count_step(runner), self._batch_size * self._num_batches * 4
+        )
+
+    def test_hook_never_stop(self):
+        """Hook that always returns False should skip the breakpoint."""
+        runner = LocalDebuggerRunner(self._plan_node)
+        runner.set_hook(self._node_ids[3], lambda v: False)
+        runner.set_hook(self._node_ids[5], lambda v: False)
+        runner.set_hook(self._node_ids[8], lambda v: False)
+        # Since all hooks return False, step() should behave like next()
+        self.assertEqual(self._count_step(runner), self._batch_size * self._num_batches)
+
+    def test_hook_conditional(self):
+        """Hook that conditionally stops based on vector content."""
+        runner = LocalDebuggerRunner(self._plan_node)
+
+        # Track how many times the hook is called.
+        call_count = 0
+
+        def conditional_hook(vector):
+            nonlocal call_count
+            call_count += 1
+            # Stop only on odd calls.
+            return call_count % 2 == 1
+
+        runner.set_hook(self._node_ids[5], conditional_hook)
+
+        # The hook is called for each batch (10 batches).
+        # It stops on odd calls (1, 3, 5, 7, 9) = 5 stops.
+        # Plus 10 task outputs = 15 total vectors.
+        self.assertEqual(self._count_step(runner), self._batch_size * 15)
+        self.assertEqual(call_count, self._num_batches)
+
+    def test_hook_mixed_with_breakpoint(self):
+        """Mix set_breakpoint and set_hook."""
+        runner = LocalDebuggerRunner(self._plan_node)
+
+        # set_breakpoint always stops.
+        runner.set_breakpoint(self._node_ids[3])
+
+        # set_hook that never stops.
+        runner.set_hook(self._node_ids[5], lambda v: False)
+
+        # set_hook that always stops.
+        runner.set_hook(self._node_ids[8], lambda v: True)
+
+        # node_ids[3] stops (10 batches), node_ids[8] stops (10 batches),
+        # plus 10 task outputs = 30 total vectors.
+        self.assertEqual(
+            self._count_step(runner), self._batch_size * self._num_batches * 3
+        )
+
+    def test_hook_inspects_vector(self):
+        """Verify the hook receives a valid vector."""
+        runner = LocalDebuggerRunner(self._plan_node)
+
+        received_sizes = []
+
+        def inspect_hook(vector):
+            received_sizes.append(vector.size())
+            return True
+
+        runner.set_hook(self._node_ids[5], inspect_hook)
+
+        it = runner.execute()
+
+        # Consume all output.
+        while True:
+            try:
+                it.step()
+            except StopIteration:
+                break
+
+        # Hook should have been called for each batch.
+        self.assertEqual(len(received_sizes), self._num_batches)
+        # Each vector should have batch_size rows.
+        self.assertTrue(all(s == self._batch_size for s in received_sizes))
+
+    def test_step_with_plan_id(self):
+        """step(plan_id) should only stop at the matching breakpoint."""
+        runner = LocalDebuggerRunner(self._plan_node)
+        runner.set_breakpoint(self._node_ids[3])
+        runner.set_breakpoint(self._node_ids[5])
+        runner.set_breakpoint(self._node_ids[8])
+
+        it = runner.execute()
+
+        # Step targeting node_ids[5] should skip node_ids[3] and stop at
+        # node_ids[5].
+        it.step(self._node_ids[5])
+        self.assertEqual(it.at(), self._node_ids[5])
+
+        # Step targeting node_ids[8] should skip node_ids[5] (remaining) and
+        # stop at node_ids[8].
+        it.step(self._node_ids[8])
+        self.assertEqual(it.at(), self._node_ids[8])
+
+        # Step with no filter (default) stops at the next breakpoint or task
+        # output.
+        it.step()
+        self.assertEqual(it.at(), "")
+
+    def test_step_with_plan_id_counts(self):
+        """step(plan_id) should only produce vectors from the matching
+        breakpoint plus task outputs."""
+        runner = LocalDebuggerRunner(self._plan_node)
+        runner.set_breakpoint(self._node_ids[3])
+        runner.set_breakpoint(self._node_ids[5])
+
+        it = runner.execute()
+        total_size = 0
+
+        # Only step to node_ids[5], skipping node_ids[3].
+        while True:
+            try:
+                vector = it.step(self._node_ids[5])
+                total_size += vector.size()
+            except StopIteration:
+                break
+
+        # We expect node_ids[5] breakpoint hits (num_batches) plus task outputs
+        # (num_batches) = 2 * num_batches vectors, each of batch_size rows.
+        self.assertEqual(total_size, self._batch_size * self._num_batches * 2)
+
+    def test_step_with_plan_id_default_behavior(self):
+        """step() with no argument should preserve original behavior."""
+        runner = LocalDebuggerRunner(self._plan_node)
+        runner.set_breakpoint(self._node_ids[3])
+        runner.set_breakpoint(self._node_ids[5])
+
+        # step() with no plan_id should hit both breakpoints + task output.
+        self.assertEqual(
+            self._count_step(runner), self._batch_size * self._num_batches * 3
+        )
diff --git a/python/test/test_plan_builder.py b/python/test/test_plan_builder.py
index c0c1c8d1ec4..f2d1c23d69d 100644
--- a/python/test/test_plan_builder.py
+++ b/python/test/test_plan_builder.py
@@ -100,3 +100,19 @@ def test_plan_serialization(self):
         )
         self.assertEqual(str(plan_node), str(plan_clone))
         self.assertEqual(plan_node.to_string(), plan_clone.to_string())
+
+    def test_mark_sorted(self):
+        plan_builder = PlanBuilder()
+        plan_builder.table_scan(ROW(["c0", "c1"], [BIGINT(), BIGINT()]))
+
+        plan_builder.mark_sorted(
+            marker_key="is_sorted",
+            sorting_keys=["c0", "c1 DESC"],
+        )
+        mark_sorted_node = plan_builder.get_plan_node()
+        self.assertEqual(mark_sorted_node.name(), "MarkSorted")
+
+        self.assertEqual(
+            str(mark_sorted_node),
+            "-- MarkSorted[1]\n  -- TableScan[0]\n",
+        )
diff --git a/python/test/test_runner.py b/python/test/test_runner.py
index 59a5baf4a43..1f668c68fd4 100644
--- a/python/test/test_runner.py
+++ b/python/test/test_runner.py
@@ -54,12 +54,24 @@ def test_not_executed(self):
         plan_builder = PlanBuilder().values()
         LocalRunner(plan_builder.get_plan_node())
 
-    def test_executed_twice(self):
-        # Ensure the runner fails if it is executed twice.
-        plan_builder = PlanBuilder().values()
+    def test_execute_twice(self):
+        # Ensure a runner can be executed twice.
+        vector = to_velox(
+            pyarrow.record_batch([pyarrow.array(list(range(10)))], names=["c0"])
+        )
+
+        plan_builder = PlanBuilder().values([vector])
         runner = LocalRunner(plan_builder.get_plan_node())
-        runner.execute()
-        self.assertRaises(RuntimeError, runner.execute)
+
+        total_size = 0
+        for vector in runner.execute():
+            total_size += vector.size()
+        self.assertEqual(total_size, 10)
+
+        total_size = 0
+        for vector in runner.execute():
+            total_size += vector.size()
+        self.assertEqual(total_size, 10)
 
     def test_values(self):
         vectors = []
@@ -103,6 +115,55 @@ def test_values_order_limit(self):
         )
         self.assertEqual(output, expected_result)
 
+    def test_mark_sorted(self):
+        # Sorted data: marker column should be all True.
+        vector = to_velox(
+            pyarrow.record_batch([pyarrow.array([1, 2, 3, 4, 5])], names=["c0"])
+        )
+
+        plan_builder = (
+            PlanBuilder()
+            .values([vector])
+            .mark_sorted(
+                marker_key="is_sorted",
+                sorting_keys=["c0"],
+            )
+        )
+        runner = LocalRunner(plan_builder.get_plan_node())
+        iterator = runner.execute()
+        output = next(iterator)
+        self.assertRaises(StopIteration, next, iterator)
+
+        self.assertEqual(output.size(), 5)
+        # Marker column is at index 1 (after c0).
+        marker = output.child_at(1)
+        for i in range(5):
+            self.assertEqual(marker[i], "true")
+
+    def test_mark_sorted_unsorted(self):
+        # Unsorted data: row at index 2 breaks sort order (3 -> 2).
+        vector = to_velox(
+            pyarrow.record_batch([pyarrow.array([1, 3, 2, 4, 5])], names=["c0"])
+        )
+
+        plan_builder = (
+            PlanBuilder()
+            .values([vector])
+            .mark_sorted(
+                marker_key="is_sorted",
+                sorting_keys=["c0"],
+            )
+        )
+        runner = LocalRunner(plan_builder.get_plan_node())
+        iterator = runner.execute()
+        output = next(iterator)
+        self.assertRaises(StopIteration, next, iterator)
+
+        marker = output.child_at(1)
+        expected = ["true", "true", "false", "true", "true"]
+        for i in range(5):
+            self.assertEqual(marker[i], expected[i])
+
     def test_hash_join(self):
         batch_size = 100
         probe = list(range(batch_size))
diff --git a/python/test/test_type.py b/python/test/test_type.py
index ff079cd1cb1..b059ee58723 100644
--- a/python/test/test_type.py
+++ b/python/test/test_type.py
@@ -26,6 +26,7 @@
     DOUBLE,
     VARCHAR,
     VARBINARY,
+    JSON,
     ARRAY,
     MAP,
     ROW,
@@ -43,6 +44,7 @@ def test_simple_types(self):
         self.assertTrue(isinstance(DOUBLE(), Type))
         self.assertTrue(isinstance(VARCHAR(), Type))
         self.assertTrue(isinstance(VARBINARY(), Type))
+        self.assertTrue(isinstance(JSON(), Type))
 
     def test_complex_types(self):
         self.assertTrue(isinstance(ARRAY(VARCHAR()), Type))
@@ -86,3 +88,5 @@ def test_equality(self):
 
         self.assertNotEqual(BIGINT(), INTEGER())
         self.assertNotEqual(ARRAY(BIGINT()), REAL())
+        self.assertNotEqual(VARBINARY(), VARCHAR())
+        self.assertNotEqual(JSON(), VARCHAR())
diff --git a/scripts/checks/check-header-ownership.py b/scripts/checks/check-header-ownership.py
new file mode 100755
index 00000000000..9d6da3f650a
--- /dev/null
+++ b/scripts/checks/check-header-ownership.py
@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+CI check: verify every .h file under velox/ is listed in a CMakeLists.txt target.
+
+Exits with code 1 if orphan headers are found.
+
+Usage:
+    python3 .github/scripts/check-header-ownership.py [velox_source_dir]
+
+The velox_source_dir defaults to "velox" (relative to repo root).
+"""
+
+import os
+import re
+import sys
+
+SKIP_DIRS = {
+    "external",
+    "experimental",
+    "facebook",
+    "public_tld",
+    "python",
+}
+
+SKIP_PATHS = {
+    "tpcds/gen/dsdgen/include",
+    "tpch/gen/dbgen/include",
+}
+
+
+def collect_cmake_headers(velox_dir):
+    """Walk CMakeLists.txt files and collect all .h filenames mentioned."""
+    tracked = set()
+
+    for root, _dirs, files in os.walk(velox_dir):
+        if "CMakeLists.txt" not in files:
+            continue
+
+        rel_root = os.path.relpath(root, velox_dir)
+
+        cmake_path = os.path.join(root, "CMakeLists.txt")
+        with open(cmake_path) as f:
+            content = f.read()
+
+        # Find all .h references in any target call or HEADERS block
+        for h in re.findall(r"([\w][\w/\-]*\.h)", content):
+            # Resolve relative to CMakeLists.txt directory
+            tracked.add(os.path.normpath(os.path.join(rel_root, h)))
+
+    return tracked
+
+
+def collect_fs_headers(velox_dir):
+    """Walk filesystem for all .h files, respecting skip rules."""
+    headers = set()
+
+    for root, dirs, files in os.walk(velox_dir):
+        rel_root = os.path.relpath(root, velox_dir)
+
+        # Skip entire directories
+        parts = rel_root.split(os.sep)
+        if any(p in SKIP_DIRS for p in parts):
+            dirs.clear()
+            continue
+
+        if any(rel_root.startswith(sp) for sp in SKIP_PATHS):
+            dirs.clear()
+            continue
+
+        for f in files:
+            if f.endswith(".h"):
+                headers.add(os.path.normpath(os.path.join(rel_root, f)))
+
+    return headers
+
+
+def main():
+    velox_dir = sys.argv[1] if len(sys.argv) > 1 else "velox"
+
+    if not os.path.isdir(velox_dir):
+        print(f"Error: {velox_dir} is not a directory", file=sys.stderr)
+        sys.exit(2)
+
+    tracked = collect_cmake_headers(velox_dir)
+    fs_headers = collect_fs_headers(velox_dir)
+
+    orphans = sorted(fs_headers - tracked)
+
+    if orphans:
+        print(
+            f"Found {len(orphans)} header(s) not tracked by any CMakeLists.txt target:"
+        )
+        for h in orphans:
+            print(f"  {h}")
+        print()
+        print("To fix, add each header to the appropriate CMakeLists.txt:")
+        print("  - For velox_add_library() targets: add to the HEADERS list")
+        print(
+            "  - For test/benchmark/fuzzer targets: use velox_add_test_headers(<target> <header>)"
+        )
+        sys.exit(1)
+    else:
+        print(f"All {len(fs_headers)} headers are tracked by CMakeLists.txt targets.")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/checks/check-readme-blogs.sh b/scripts/checks/check-readme-blogs.sh
new file mode 100755
index 00000000000..46cdb8c209d
--- /dev/null
+++ b/scripts/checks/check-readme-blogs.sh
@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Ensures the "Recent blog posts" section in README.md lists the 3 most recent
+# blog posts from website/blog/. Auto-fixes if out of date.
+
+set -euo pipefail
+
+BLOG_DIR="website/blog"
+NUM_POSTS=3
+
+# Build expected blog list lines from the most recent .mdx files.
+EXPECTED_LINES=()
+for f in $(ls -1 "$BLOG_DIR"/*.mdx | sort -r | head -$NUM_POSTS); do
+  DATE=$(basename "$f" | grep -oE '^[0-9]{4}-[0-9]{2}-[0-9]{2}')
+  TITLE=$(grep '^title:' "$f" | sed 's/title: *//; s/"//g')
+  SLUG=$(grep '^slug:' "$f" | sed 's/slug: *//')
+  EXPECTED_LINES+=("- [$TITLE](https://velox-lib.io/blog/$SLUG) ($DATE)")
+done
+
+# Extract current blog list: everything between "Recent blog posts" header and
+# the next markdown section (##).
+CURRENT=$(sed -n '/^Recent blog posts/,/^##/{/^Recent blog posts/d;/^##/d;/^$/d;p;}' README.md)
+EXPECTED=$(printf '%s\n' "${EXPECTED_LINES[@]}")
+
+if [ "$CURRENT" = "$EXPECTED" ]; then
+  exit 0
+fi
+
+# Auto-fix: replace everything between "Recent blog posts" header and the next
+# section with the expected blog list.
+TEMP=$(mktemp)
+IN_SECTION=false
+while IFS= read -r line; do
+  if [[ $line == "Recent blog posts"* ]]; then
+    echo "$line" >>"$TEMP"
+    echo "" >>"$TEMP"
+    printf '%s\n' "${EXPECTED_LINES[@]}" >>"$TEMP"
+    IN_SECTION=true
+    continue
+  fi
+  if $IN_SECTION; then
+    # Skip until the next section header.
+    if [[ $line == "##"* ]]; then
+      IN_SECTION=false
+      echo "" >>"$TEMP"
+      echo "$line" >>"$TEMP"
+    fi
+    continue
+  fi
+  echo "$line" >>"$TEMP"
+done <README.md
+mv "$TEMP" README.md
+
+echo "Updated recent blog posts in README.md"
+exit 1
diff --git a/scripts/checks/license-header.py b/scripts/checks/license-header.py
index 6f2ebb52e80..fb8f8ac1b6b 100755
--- a/scripts/checks/license-header.py
+++ b/scripts/checks/license-header.py
@@ -100,7 +100,7 @@ def wrapper_hash(header, args):
         "*.cmake": attrdict({"wrapper": wrapper_hash, "hashbang": False}),
         "*.cpp": attrdict({"wrapper": wrapper_chpp, "hashbang": False}),
         "*.hpp": attrdict({"wrapper": wrapper_chpp, "hashbang": False}),
-        "*.dockfile": attrdict({"wrapper": wrapper_hash, "hashbang": False}),
+        "*.dockerfile": attrdict({"wrapper": wrapper_hash, "hashbang": False}),
         "*.h": attrdict({"wrapper": wrapper_chpp, "hashbang": False}),
         "*.inc": attrdict({"wrapper": wrapper_chpp, "hashbang": False}),
         "*.java": attrdict({"wrapper": wrapper_chpp, "hashbang": False}),
@@ -110,6 +110,7 @@ def wrapper_hash(header, args):
         "*.thrift": attrdict({"wrapper": wrapper_chpp, "hashbang": False}),
         "*.txt": attrdict({"wrapper": wrapper_hash, "hashbang": True}),
         "*.yml": attrdict({"wrapper": wrapper_hash, "hashbang": False}),
+        "*.yaml": attrdict({"wrapper": wrapper_hash, "hashbang": False}),
         "*.cu": attrdict({"wrapper": wrapper_chpp, "hashbang": False}),
         "*.cuh": attrdict({"wrapper": wrapper_chpp, "hashbang": False}),
         "*.clcpp": attrdict({"wrapper": wrapper_chpp, "hashbang": False}),
@@ -119,7 +120,12 @@ def wrapper_hash(header, args):
 )
 
 file_pattern = regex.compile(
-    "|".join(["^" + fnmatch.translate(type) + "$" for type in file_types.keys()])
+    "|".join(
+        [
+            "^" + fnmatch.translate(type).replace(r"\z", r"\Z") + "$"
+            for type in file_types.keys()
+        ]
+    )
 )
 
 
@@ -228,7 +234,13 @@ def main():
             # If removing the header text, zero it out there.
             header_comment = ""
 
-        message(log_to, "Fix  : " + filepath)
+        if os.environ.get("GITHUB_ACTIONS"):
+            print(
+                f"::error file={filepath},line=1,endLine=1,title=Missing license header::"
+                + "Please add the properly commented license header."
+            )
+        else:
+            message(log_to, "Fix  : " + filepath)
 
         if args.check:
             fail = True
diff --git a/scripts/checks/run-clang-tidy.py b/scripts/checks/run-clang-tidy.py
index 5d7016c3d9e..183f19ba456 100755
--- a/scripts/checks/run-clang-tidy.py
+++ b/scripts/checks/run-clang-tidy.py
@@ -15,75 +15,12 @@
 
 import argparse
 import json
-import regex
+import re
 import sys
+import os
 
 import util
 
-CODE_CHECKS = """*
-    -abseil-*
-    -android-*
-    -cert-err58-cpp
-    -clang-analyzer-osx-*
-    -cppcoreguidelines-avoid-c-arrays
-    -cppcoreguidelines-avoid-magic-numbers
-    -cppcoreguidelines-pro-bounds-array-to-pointer-decay
-    -cppcoreguidelines-pro-bounds-pointer-arithmetic
-    -cppcoreguidelines-pro-type-reinterpret-cast
-    -cppcoreguidelines-pro-type-vararg
-    -fuchsia-*
-    -google-*
-    -hicpp-avoid-c-arrays
-    -hicpp-deprecated-headers
-    -hicpp-no-array-decay
-    -hicpp-use-equals-default
-    -hicpp-vararg
-    -llvmlibc-*
-    -llvm-header-guard
-    -llvm-include-order
-    -mpi-*
-    -misc-non-private-member-variables-in-classes
-    -misc-no-recursion
-    -misc-unused-parameters
-    -modernize-avoid-c-arrays
-    -modernize-deprecated-headers
-    -modernize-use-nodiscard
-    -modernize-use-trailing-return-type
-    -objc-*
-    -openmp-*
-    -readability-avoid-const-params-in-decls
-    -readability-convert-member-functions-to-static
-    -readability-magic-numbers
-    -zircon-*
-"""
-
-# Additional opt-outs because googletest macros trip too many things.
-#
-TEST_CHECKS = (
-    CODE_CHECKS
-    + """
-    -cert-err58-cpp
-    -cppcoreguidelines-avoid-goto
-    -cppcoreguidelines-avoid-non-const-global-variables
-    -cppcoreguidelines-owning-memory
-    -cppcoreguidelines-pro-type-vararg
-    -cppcoreguidelines-special-member-functions
-    -hicpp-avoid-goto
-    -hicpp-special-member-functions
-    -hicpp-vararg
-    -misc-no-recursion
-    -readability-implicit-bool-conversion
-"""
-)
-
-
-def check_list(check_string):
-    return ",".join([check.strip() for check in check_string.strip().splitlines()])
-
-
-CODE_CHECKS = check_list(CODE_CHECKS)
-TEST_CHECKS = check_list(TEST_CHECKS)
-
 
 class Multimap(dict):
     def __setitem__(self, key, value):
@@ -101,76 +38,113 @@ def git_changed_lines(commit):
         line = line.rstrip("\n")
         fields = line.split()
 
-        match = regex.match(r"^\+\+\+ b/.*", line)
+        match = re.match(r"^\+\+\+ b/.*", line)
         if match:
             file = ""
 
-        match = regex.match(r"^\+\+\+ b/(.*(\.cpp|\.h))$", line)
+        match = re.match(r"^\+\+\+ b/(.*(\.cpp|\.h|\.hpp))$", line)
         if match:
-            file = match.group(1)
-
-        match = regex.match(r"^@@", line)
-        if match and file != "":
+            matched_file = match.group(1)
+            # Exclude files in cudf, wave, and torchwave directories
+            # as clang-tidy doesn't support CUDA compiler flags and CUDA
+            # headers. Exclude *-inl.h files: they are designed to be
+            # included from their corresponding header and cannot be
+            # compiled as standalone translation units.
+            if (
+                "cudf/" not in matched_file
+                and "wave/" not in matched_file
+                and not matched_file.endswith("-inl.h")
+            ):
+                file = matched_file
+
+        match = re.match(r"^@@", line)
+        if match and file != "" and len(fields) >= 3:
             lspan = fields[2].split(",")
             if len(lspan) <= 1:
-                lspan.append(0)
-
-            changed_lines[file] = [int(lspan[0]), int(lspan[0]) + int(lspan[1])]
+                lspan.append("0")
 
-    return json.dumps(
-        [{"name": key, "lines": value} for key, value in changed_lines.items()]
-    )
+            start_line = int(lspan[0])
+            line_count = int(lspan[1])
 
+            # Skip invalid line ranges (e.g., +0,0 from deleted files)
+            if start_line > 0 or line_count > 0:
+                changed_lines[file] = [start_line, start_line + line_count]
 
-def checks(args):
-    status, stdout, stderr = util.run(
-        f"clang-tidy -checks='{CODE_CHECKS}' --list-checks"
-    )
-    print(stdout)
+    return changed_lines
 
 
 def check_output(output):
-    return regex.match(r"^/.* warning: ", output)
+    return re.match(r"(^/.* warning: |^$)", output)
 
 
 def tidy(args):
     files = util.input_files(args.files)
+    files = [file for file in files if re.match(r".*(\.cpp|\.h|\.hpp)$", file)]
 
-    groups = Multimap()
+    # Exclude files in cudf, wave, and torchwave directories
+    # as clang-tidy doesn't support CUDA compiler flags and CUDA headers
+    files = [file for file in files if "cudf/" not in file and "wave/" not in file]
 
-    for file in files:
-        groups["test" if "/tests/" in file else "main"] = file
+    # Exclude *-inl.h files: they are designed to be included from their
+    # corresponding header and cannot be compiled as standalone translation
+    # units (see git_changed_lines for rationale).
+    files = [file for file in files if not file.endswith("-inl.h")]
 
-    fix = "--fix" if args.fix == "fix" else ""
-    lines = (
-        ("'--line-filter=" + git_changed_lines(args.commit)) + "'"
-        if args.commit is not None
-        else ""
+    in_gha = os.environ.get("GITHUB_ACTIONS") is not None
+    changed_lines = git_changed_lines(args.commit)
+
+    line_filter = json.dumps(
+        [{"name": key, "lines": value} for key, value in changed_lines.items()]
     )
+    filtered_files = [*changed_lines.keys()]
+    if len(filtered_files) == 0:
+        return 0
+
+    fix = "--fix" if args.fix == "fix" else ""
+    lines = f"'--line-filter={line_filter}'" if args.commit is not None else ""
 
     ok = True
-    if groups.get("main", None):
-        status, stdout, stderr = util.run(
-            f"xargs clang-tidy -p=build/release/ --format-style=file -header-filter='.*' --checks='{CODE_CHECKS}' --quiet {fix} {lines}",
-            input=groups["main"],
-        )
-        ok = check_output(stdout) and ok
+    build_path = args.p or os.getenv("BUILD_PATH")
+    build_path_str = f"-p {build_path}" if build_path else ""
 
-    if groups.get("test", None):
-        status, stdout, stderr = util.run(
-            f"xargs clang-tidy -p=build/release/ --format-style=file -header-filter='.*' --checks='{TEST_CHECKS}' --quiet {fix} {lines}",
-            input=groups["test"],
+    if build_path_str == "" and not os.path.isfile(
+        os.getcwd().join("compile_commands.json")
+    ):
+        print("compile_commands.json not found, skipping clang-tidy")
+        return 0
+
+    status, stdout, stderr = util.run(
+        f"xargs clang-tidy --format-style=file -header-filter='.*' --quiet {build_path_str} {fix} {lines}",
+        input=filtered_files,
+    )
+
+    if in_gha:
+        clang_tidy_pattern = (
+            r"^(.*):(\d+):(\d+):\s+(error|warning):\s+(.*) \[([a-z0-9,\-]+)\]\s*$"
         )
-        ok = check_output(stdout) and ok
+
+        for stdout_line in stdout.split("\n"):
+            m = re.match(clang_tidy_pattern, stdout_line)
+            if m is not None:
+                file, line, col, severity, message, rule = m.groups()
+                file = file.removeprefix("/__w/velox/velox/")
+                print(
+                    f"::{severity} file={file},line={line},col={col},title={rule}::{message}"
+                )
+
+    ok = check_output(stdout)
+    if not ok:
+        print(stdout)
 
     return 0 if ok else 1
 
 
 def parse_args():
     global parser
-    parser = argparse.ArgumentParser(description="CircliCi Utility")
+    parser = argparse.ArgumentParser(description="Clang Tidy Utility")
     parser.add_argument("--commit")
     parser.add_argument("--fix")
+    parser.add_argument("-p", help="Path containing 'compile_commands.json'")
 
     parser.add_argument("files", metavar="FILES", nargs="+", help="files to process")
 
diff --git a/scripts/checks/util.py b/scripts/checks/util.py
index c0b34532a94..fe7f05c86dd 100644
--- a/scripts/checks/util.py
+++ b/scripts/checks/util.py
@@ -15,7 +15,7 @@
 import gzip
 import json
 import os
-import regex
+import re
 import subprocess
 import sys
 
@@ -27,7 +27,7 @@ class attrdict(dict):
 
 class string(str):
     def extract(self, rexp):
-        return regex.match(rexp, self).group(1)
+        return re.match(rexp, self).group(1)
 
     def json(self):
         return json.loads(self, object_hook=attrdict)
diff --git a/scripts/ci/benchmark-alert.py b/scripts/ci/benchmark-alert.py
deleted file mode 100755
index a4e7c9f9582..00000000000
--- a/scripts/ci/benchmark-alert.py
+++ /dev/null
@@ -1,160 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-import os
-import re
-from pprint import pprint
-from typing import Optional, Tuple
-
-import benchalerts.pipeline_steps as steps
-import requests
-from benchalerts import AlertPipeline
-from benchclients import log
-
-DESCRIPTION = """
-Analyze benchmark runs, post a GitHub Check whether there were regressions or not, and
-if it's a merge-commit, post a comment back to the PR that merged the commit in.
-
-Required environment variables:
-    GITHUB_REPOSITORY - the default GITHUB_REPOSITORY given in GitHub Actions
-    GITHUB_APP_ID - the ID of a GitHub App installed to this repo
-    GITHUB_APP_PRIVATE_KEY - the private key file contents of the GitHub App
-    CONBENCH_URL - the URL to the Conbench server where benchmark results are stored
-"""
-
-
-def parse_args() -> Tuple[str, str, str, float]:
-    parser = argparse.ArgumentParser(
-        description=DESCRIPTION, formatter_class=argparse.RawDescriptionHelpFormatter
-    )
-    parser.add_argument(
-        "--contender-sha",
-        type=str,
-        required=True,
-        help="The SHA hash of the contender commit. The script will download benchmark "
-        "information about this commit and post a GitHub Check of the full report to "
-        "this commit.",
-    )
-    parser.add_argument(
-        "--merge-commit-message",
-        type=str,
-        required=True,
-        help="If the contender commit is a merge-commit, its message. If not, an empty "
-        "string.",
-    )
-    parser.add_argument(
-        "--z-score-threshold",
-        type=float,
-        required=True,
-        help="The (positive) z-score threshold. Benchmarks with a z-score more extreme "
-        "than this threshold will be marked as regressions.",
-    )
-    args = parser.parse_args()
-
-    repo = os.environ["GITHUB_REPOSITORY"]
-
-    return (
-        repo,
-        args.contender_sha,
-        args.merge_commit_message,
-        args.z_score_threshold,
-    )
-
-
-def _merge_commit_pr_number(commit_message: str) -> Optional[int]:
-    """If this is a merge-commit run, get the number of the PR that was merged by
-    grepping the commit message.
-
-    Other alternatives to this strategy:
-
-    - Hit /repos/{owner}/{repo}/commits/{commit_sha}/pulls to get the number. This
-      doesn't work because of the way facebook-github-bot merges PRs.
-    - Use the GitHub GraphQL API to search through recent "PR closed" events until you
-      find the one that's associated with this commit. This does work but actually feels
-      *more* likely to break than grepping.
-    """
-    if not commit_message:
-        print("Merge-commit message not given; this must be a PR commit")
-        return None
-
-    # Look for e.g. (#123) at the end of the first line
-    res = re.search(r"\(#(\d+)\)$", commit_message.split("\n")[0])
-
-    if not res:
-        print("Could not find the PR number in the following merge-commit message:")
-        print(commit_message)
-        return None
-
-    print(f"Found a PR number (in the given merge-commit message): {repr(res[1])}")
-    return int(res[1])
-
-
-def main(
-    repo: str,
-    contender_sha: str,
-    merge_commit_message: str,
-    z_score_threshold: float,
-):
-    log.setLevel("DEBUG")
-
-    if merge_commit_message:
-        # Compare against the parent commit of the merge-commit
-        baseline_run_type = steps.BaselineRunCandidates.parent
-    else:
-        # Compare against the default-branch commit from which the PR was forked
-        baseline_run_type = steps.BaselineRunCandidates.fork_point
-
-    pipeline_steps = [
-        steps.GetConbenchZComparisonStep(
-            commit_hash=contender_sha,
-            baseline_run_type=baseline_run_type,
-            z_score_threshold=z_score_threshold,
-            step_name="z_comparison",
-        ),
-        steps.GitHubCheckStep(
-            commit_hash=contender_sha, comparison_step_name="z_comparison", repo=repo
-        ),
-    ]
-
-    # Only post a comment on merge-commits
-    if merge_commit_message:
-        pr_number = _merge_commit_pr_number(merge_commit_message)
-        pipeline_steps.append(
-            steps.GitHubPRCommentAboutCheckStep(pr_number=pr_number, repo=repo)
-        )
-
-    pipeline = AlertPipeline(steps=pipeline_steps)
-    pprint(pipeline.run_pipeline())
-
-
-def test_grepping():
-    """This is never called. Use for local dev."""
-    _merge_commit_pr_number("")
-    for commit in requests.get(
-        "https://api.github.com/repos/facebookincubator/velox/commits"
-    ).json():
-        print(commit["sha"][:7])
-        _merge_commit_pr_number(commit["commit"]["message"])
-
-
-if __name__ == "__main__":
-    repo, contender_sha, merge_commit_message, z_score_threshold = parse_args()
-    main(
-        repo=repo,
-        contender_sha=contender_sha,
-        merge_commit_message=merge_commit_message,
-        z_score_threshold=z_score_threshold,
-    )
diff --git a/scripts/ci/bm-report/report.qmd b/scripts/ci/bm-report/report.qmd
index a91a116a6b9..b9ad14c79a4 100644
--- a/scripts/ci/bm-report/report.qmd
+++ b/scripts/ci/bm-report/report.qmd
@@ -50,7 +50,7 @@ run_shas <- runs |>
   jsonlite::fromJSON()
 
 run_ids <- mruns(run_shas) |>
-  filter(commit.branch == "facebookincubator:main", substr(id, 1, 2) == "BM") |>
+  filter(substr(id, 1, 2) == "BM") |>
   pull(id)
 
 # Speed up local dev by saving 'results' as conbench requests can't be memoised
diff --git a/scripts/ci/gersemi_cmd_definitions.py b/scripts/ci/gersemi_cmd_definitions.py
index 78aca426e6a..32f1ebe2dd8 100644
--- a/scripts/ci/gersemi_cmd_definitions.py
+++ b/scripts/ci/gersemi_cmd_definitions.py
@@ -45,6 +45,10 @@
     "pyvelox_add_module": pyvelox_add_module,
     "velox_add_library": velox_add_library,
     "velox_base_add_library": velox_base_add_library,
+    "velox_add_test_headers": {
+        "front_positional_arguments": ["target_name"],
+        "back_positional_arguments": ["headers"],
+    },
     "velox_build_dependency": {
         "front_positional_arguments": ["dependency_name"],
     },
@@ -60,4 +64,8 @@
         "front_positional_arguments": ["var_name", "envvar_name", "default"]
     },
     "velox_sources": builtin_commands["target_sources"],
+    "velox_add_cudf_test": {
+        "one_value_keywords": ["NAME", "TIMEOUT"],
+        "multi_value_keywords": ["SOURCES", "LIBS"],
+    },
 }
diff --git a/scripts/ci/run-fuzzer-parallel.sh b/scripts/ci/run-fuzzer-parallel.sh
new file mode 100755
index 00000000000..c62509378a0
--- /dev/null
+++ b/scripts/ci/run-fuzzer-parallel.sh
@@ -0,0 +1,113 @@
+#!/bin/bash
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Run multiple fuzzer instances in parallel with different seeds.
+#
+# Usage: run-fuzzer-parallel.sh <num_instances> <repro_base_dir> <binary> [args...]
+#
+# In the fuzzer arguments, use these placeholders which are replaced per instance:
+#   __SEED__         -> unique random seed per instance
+#   __INSTANCE_ID__  -> instance number (1, 2, ...)
+#   __REPRO_DIR__    -> per-instance repro directory (<repro_base_dir>/instance_N)
+#   __LOG_DIR__      -> per-instance log directory (<repro_base_dir>/instance_N/logs)
+
+set -euo pipefail
+
+NUM_INSTANCES=$1
+REPRO_BASE=$2
+BINARY=$3
+shift 3
+
+PIDS=()
+SEEDS=()
+FAILED=0
+
+dump_instance() {
+  local idx=$1
+  echo "=== Instance ${idx} stdout (last 200 lines) ==="
+  tail -200 "${REPRO_BASE}/instance_${idx}/stdout.log" 2>/dev/null ||
+    echo "(no stdout.log)"
+  echo "=== End instance ${idx} ==="
+}
+
+# When the GH Actions step timeout fires it sends SIGTERM. Without this trap
+# `wait` blocks indefinitely, the per-instance stdout is never surfaced, and
+# the only signal in the job log is "context canceled" with no diagnostics.
+on_signal() {
+  local sig=$1
+  echo "::warning::run-fuzzer-parallel.sh received ${sig}; dumping per-instance state"
+  for i in "${!PIDS[@]}"; do
+    local idx=$((i + 1))
+    local pid=${PIDS[$i]}
+    if kill -0 "$pid" 2>/dev/null; then
+      echo "::error::Instance ${idx} (PID ${pid}, seed=${SEEDS[$i]}) still running at ${sig}; sending SIGTERM"
+      kill -TERM "$pid" 2>/dev/null || true
+    fi
+  done
+  sleep 5
+  for i in "${!PIDS[@]}"; do
+    local idx=$((i + 1))
+    local pid=${PIDS[$i]}
+    if kill -0 "$pid" 2>/dev/null; then
+      kill -KILL "$pid" 2>/dev/null || true
+    fi
+    dump_instance "$idx"
+  done
+  exit 124
+}
+trap 'on_signal SIGTERM' TERM
+trap 'on_signal SIGINT' INT
+
+for i in $(seq 1 "$NUM_INSTANCES"); do
+  REPRO_DIR="${REPRO_BASE}/instance_${i}"
+  LOG_DIR="${REPRO_DIR}/logs"
+  mkdir -p "${LOG_DIR}"
+  SEED=$((RANDOM * 32768 + RANDOM + i))
+
+  # Replace placeholders in arguments
+  INSTANCE_ARGS=()
+  for arg in "$@"; do
+    arg="${arg//__SEED__/$SEED}"
+    arg="${arg//__INSTANCE_ID__/$i}"
+    arg="${arg//__REPRO_DIR__/$REPRO_DIR}"
+    arg="${arg//__LOG_DIR__/$LOG_DIR}"
+    INSTANCE_ARGS+=("$arg")
+  done
+
+  echo "Starting instance ${i}: seed=${SEED}, repro=${REPRO_DIR}"
+  "$BINARY" "${INSTANCE_ARGS[@]}" >"${REPRO_DIR}/stdout.log" 2>&1 &
+  PIDS+=($!)
+  SEEDS+=("$SEED")
+done
+
+echo "Waiting for ${NUM_INSTANCES} instances to complete..."
+
+for i in "${!PIDS[@]}"; do
+  IDX=$((i + 1))
+  if ! wait "${PIDS[$i]}"; then
+    echo "::error::Fuzzer instance ${IDX} FAILED (PID ${PIDS[$i]}, seed=${SEEDS[$i]})"
+    dump_instance "$IDX"
+    FAILED=$((FAILED + 1))
+  else
+    echo "Instance ${IDX} passed (seed=${SEEDS[$i]})"
+  fi
+done
+
+if [ "$FAILED" -gt 0 ]; then
+  echo "${FAILED} of ${NUM_INSTANCES} instance(s) failed"
+  exit 1
+fi
+
+echo "All ${NUM_INSTANCES} instances passed"
diff --git a/scripts/ci/signature.py b/scripts/ci/signature.py
index daa876942f1..f9534e88d0c 100644
--- a/scripts/ci/signature.py
+++ b/scripts/ci/signature.py
@@ -337,7 +337,7 @@ def parse_args(args):
     bias_command_parser.add_argument("contender", type=str)
     bias_command_parser.add_argument("output_path", type=str)
     bias_command_parser.add_argument(
-        "ticket_value", type=get_tickets, default=10, nargs="?"
+        "ticket_value", type=get_tickets, default=20, nargs="?"
     )
     bias_command_parser.add_argument("error_path", type=str, default="")
 
diff --git a/scripts/ci/spark/conf/spark-defaults.conf.example b/scripts/ci/spark/conf/spark-defaults.conf.example
index 5b008b44801..55a356aa01b 100644
--- a/scripts/ci/spark/conf/spark-defaults.conf.example
+++ b/scripts/ci/spark/conf/spark-defaults.conf.example
@@ -1 +1,3 @@
-spark.master local[*]
+spark.master local[1]
+spark.driver.cores 1
+spark.sql.shuffle.partitions 1
diff --git a/scripts/ci/spark/conf/spark-env.sh.example b/scripts/ci/spark/conf/spark-env.sh.example
index 8cd004a8613..4df23910796 100644
--- a/scripts/ci/spark/conf/spark-env.sh.example
+++ b/scripts/ci/spark/conf/spark-env.sh.example
@@ -1 +1,2 @@
 export SPARK_DAEMON_MEMORY=5g
+export SPARK_DAEMON_JAVA_OPTS="-XX:+UseG1GC -XX:MaxGCPauseMillis=200"
diff --git a/scripts/docker/centos-multi.dockerfile b/scripts/docker/centos-multi.dockerfile
index d957e70d511..cdd97603dae 100644
--- a/scripts/docker/centos-multi.dockerfile
+++ b/scripts/docker/centos-multi.dockerfile
@@ -17,6 +17,14 @@
 #   - centos9: Our base CI build
 #   - adapters: Based on centos9 with all optional dependencies installed
 #   - pyvelox: Image used by cibuildwheel to build pyvelox
+#
+# tzdata is pinned to a known-good version across every stage. Without
+# the pin, each docker rebuild silently picks up the latest tzdata from
+# the CentOS repos — tzdata 2026b's encoding of British Columbia's
+# permanent-PDT change broke Velox's bundled libc++ chrono::tzdb parser
+# (issue #17522). To bump intentionally: change the default below and
+# re-run the Presto-SOT fuzzers locally to confirm before merging.
+ARG CENTOS_TZDATA_VERSION=2026a-1.el9
 
 ########################
 # Stage 1: Base Build  #
@@ -24,6 +32,12 @@
 ARG image=quay.io/centos/centos:stream9
 FROM $image AS base-build
 
+ARG CENTOS_TZDATA_VERSION
+# Pin tzdata. `dnf install` is a no-op if already at the pinned version,
+# and falls through to `downgrade` when the base image ships a newer one.
+RUN dnf -y install "tzdata-${CENTOS_TZDATA_VERSION}.noarch" || \
+      dnf -y downgrade "tzdata-${CENTOS_TZDATA_VERSION}.noarch"
+
 COPY scripts/setup-helper-functions.sh /
 COPY scripts/setup-versions.sh /
 COPY scripts/setup-common.sh /
@@ -32,8 +46,12 @@ COPY CMake/resolve_dependency_modules/arrow/cmake-compatibility.patch /
 
 ARG VELOX_BUILD_SHARED=ON
 # Building libvelox.so requires folly and gflags to be built shared as well for now
+# gflags is always both shared and static turned on.
 ENV VELOX_BUILD_SHARED=${VELOX_BUILD_SHARED}
 
+ARG ARM_BUILD_TARGET=local
+ENV ARM_BUILD_TARGET=${ARM_BUILD_TARGET}
+
 RUN mkdir build
 WORKDIR /build
 
@@ -46,6 +64,11 @@ ENV UV_TOOL_BIN_DIR=/usr/local/bin \
 ENV CMAKE_POLICY_VERSION_MINIMUM="3.5" \
     VELOX_ARROW_CMAKE_PATCH=/cmake-compatibility.patch
 
+# Ensure libraries installed to INSTALL_PREFIX are found at runtime (e.g.
+# thrift1 needs libgflags.so.2.2 when folly links gflags statically but
+# other tools still use shared gflags).
+ENV LD_LIBRARY_PATH="${INSTALL_PREFIX}/lib:${INSTALL_PREFIX}/lib64"
+
 # Some CMake configs contain the hard coded prefix '/deps', we need to replace that with
 # the future location to avoid build errors in the base-image
 RUN bash /setup-centos9.sh && \
@@ -56,6 +79,12 @@ RUN bash /setup-centos9.sh && \
 ########################
 FROM $image AS base-image
 
+ARG CENTOS_TZDATA_VERSION
+# Pin tzdata — see top of file for rationale. Inherited by centos9,
+# pyvelox, and (transitively, via the centos9 tag) the java images.
+RUN dnf -y install "tzdata-${CENTOS_TZDATA_VERSION}.noarch" || \
+      dnf -y downgrade "tzdata-${CENTOS_TZDATA_VERSION}.noarch"
+
 COPY scripts/setup-helper-functions.sh /
 COPY scripts/setup-versions.sh /
 COPY scripts/setup-common.sh /
@@ -97,19 +126,29 @@ CMD ["/bin/bash"]
 ########################
 FROM base-image AS pyvelox
 
-ENV LD_LIBRARY_PATH="/usr/local/lib:/usr/local/lib64:$LD_LIBRARY_PATH"
+RUN echo "/usr/local/lib" > /etc/ld.so.conf.d/velox_deps.conf \
+ && echo "/usr/local/lib64" >> /etc/ld.so.conf.d/velox_deps.conf \
+ && ldconfig
 
 ########################
 # Stage: Adapters Build#
 ########################
 FROM $image AS adapters-build
 
+ARG CENTOS_TZDATA_VERSION
+# Pin tzdata — see top of file for rationale.
+RUN dnf -y install "tzdata-${CENTOS_TZDATA_VERSION}.noarch" || \
+      dnf -y downgrade "tzdata-${CENTOS_TZDATA_VERSION}.noarch"
+
 COPY scripts/setup-helper-functions.sh /
 COPY scripts/setup-versions.sh /
 COPY scripts/setup-common.sh /
 COPY scripts/setup-centos9.sh /
 COPY scripts/setup-centos-adapters.sh /
 
+ARG ARM_BUILD_TARGET=local
+ENV ARM_BUILD_TARGET=${ARM_BUILD_TARGET}
+
 RUN mkdir build
 WORKDIR /build
 
@@ -129,12 +168,22 @@ FROM centos9 AS adapters
 
 COPY scripts/setup-centos-adapters.sh /
 
+ARG CUDA_VERSION
+ENV CUDA_VERSION=${CUDA_VERSION:-12.9}
+
 RUN bash /setup-centos-adapters.sh install_cuda && \
       dnf clean all
 
 RUN bash /setup-centos-adapters.sh install_adapters_deps_from_dnf && \
       dnf clean all
 
+ARG CENTOS_TZDATA_VERSION
+# tzdata-java is pulled in by the Java install above. Pin it to match
+# the OS tzdata pinned in centos9 so the JDK and Velox C++ see the
+# same timezone rules — issue #17522 was caused by this drift.
+RUN dnf -y install "tzdata-java-${CENTOS_TZDATA_VERSION}.noarch" || \
+      dnf -y downgrade "tzdata-java-${CENTOS_TZDATA_VERSION}.noarch"
+
 # put CUDA binaries on the PATH
 ENV PATH=/usr/local/cuda/bin:${PATH}
 
@@ -161,6 +210,11 @@ ENV HADOOP_HOME=/usr/local/hadoop \
 
 COPY --from=adapters-build /deps /usr/local
 
+# thrift1 requires shared libraries copied from /deps to /usr/local.
+RUN echo "/usr/local/lib" > /etc/ld.so.conf.d/velox_deps.conf \
+ && echo "/usr/local/lib64" >> /etc/ld.so.conf.d/velox_deps.conf \
+ && ldconfig
+
 COPY scripts/setup-classpath.sh /
 ENTRYPOINT ["/bin/bash", "-c", "source /setup-classpath.sh && source /opt/rh/gcc-toolset-12/enable && exec \"$@\"", "--"]
 CMD ["/bin/bash"]
diff --git a/scripts/docker/fedora.dockerfile b/scripts/docker/fedora.dockerfile
index d098c03f721..586b6a02133 100644
--- a/scripts/docker/fedora.dockerfile
+++ b/scripts/docker/fedora.dockerfile
@@ -12,12 +12,25 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# tzdata is pinned to a known-good version so docker rebuilds (any time
+# scripts/docker/*.dockerfile or scripts/setup-*.sh changes) don't
+# silently bump tzdata in the image. See issue #17522 for the bug class
+# this prevents — version mismatch between OS tzdata and consumers'
+# bundled tzdb code can produce silent 1-hour offsets in TIMESTAMP
+# WITH TIME ZONE values. To bump intentionally: change the default and
+# rebuild locally to confirm before merging.
+ARG FEDORA_TZDATA_VERSION=2025c-1.fc42
+
 ########################
 # Stage 1: Base Build  #
 ########################
 ARG base=quay.io/fedora/fedora:42-x86_64
 FROM $base AS base-build
 
+ARG FEDORA_TZDATA_VERSION
+RUN dnf -y install "tzdata-${FEDORA_TZDATA_VERSION}.noarch" || \
+      dnf -y downgrade "tzdata-${FEDORA_TZDATA_VERSION}.noarch"
+
 COPY scripts/setup-helper-functions.sh /
 COPY scripts/setup-versions.sh /
 COPY scripts/setup-common.sh /
@@ -51,6 +64,10 @@ RUN bash /setup-fedora.sh && \
 ########################
 FROM $base AS fedora
 
+ARG FEDORA_TZDATA_VERSION
+RUN dnf -y install "tzdata-${FEDORA_TZDATA_VERSION}.noarch" || \
+      dnf -y downgrade "tzdata-${FEDORA_TZDATA_VERSION}.noarch"
+
 COPY scripts/setup-helper-functions.sh /
 COPY scripts/setup-versions.sh /
 COPY scripts/setup-common.sh /
@@ -64,6 +81,7 @@ ENV UV_TOOL_BIN_DIR=/usr/local/bin \
 RUN /bin/bash -c 'source /setup-fedora.sh && \
       install_build_prerequisites && \
       install_velox_deps_from_dnf && \
+      dnf_install jq gh &&\
       dnf clean all'
 
 RUN ln -s $(which python3) /usr/bin/python
diff --git a/scripts/docker/java.dockerfile b/scripts/docker/java.dockerfile
index c51508af98b..be9ad58e140 100644
--- a/scripts/docker/java.dockerfile
+++ b/scripts/docker/java.dockerfile
@@ -15,7 +15,11 @@
 
 # Global arg default to share across stages
 ARG SPARK_VERSION=3.5.1
-ARG PRESTO_VERSION=0.293
+ARG PRESTO_VERSION=0.295
+# tzdata version pin — see scripts/docker/centos-multi.dockerfile for the
+# rationale. Keep this string in sync with CENTOS_TZDATA_VERSION there so
+# the OS tzdata and JDK tzdata-java agree on timezone rules. Issue #17522.
+ARG CENTOS_TZDATA_VERSION=2026a-1.el9
 
 #########################
 # Stage: Spark Download #
@@ -40,7 +44,7 @@ ARG PRESTO_VERSION
 RUN wget -O presto-server.tar.gz \
     https://repo1.maven.org/maven2/com/facebook/presto/presto-server/${PRESTO_VERSION}/presto-server-${PRESTO_VERSION}.tar.gz
 RUN wget -O presto-cli \
-    https://repo1.maven.org/maven2/com/facebook/presto/presto-cli/${PRESTO_VERSION}/presto-cli-${PRESTO_VERSION}-executable.jar
+    https://github.com/prestodb/presto/releases/download/${PRESTO_VERSION}/presto-cli-${PRESTO_VERSION}-executable.jar
 
 RUN tar -xzf presto-server.tar.gz
 
@@ -49,7 +53,17 @@ RUN tar -xzf presto-server.tar.gz
 #########################
 FROM ghcr.io/facebookincubator/velox-dev:centos9 AS java-base
 
-RUN dnf install -y -q --setopt=install_weak_deps=False java-11-openjdk less procps tzdata
+ARG CENTOS_TZDATA_VERSION
+# Pin tzdata-java to the same version as the OS tzdata pinned in the
+# centos9 base. The base image already has tzdata pinned; we re-pin
+# here as a defensive `install || downgrade` so this stage builds
+# correctly even before the centos9 image has been rebuilt with the pin.
+RUN dnf install -y -q --setopt=install_weak_deps=False \
+      java-17-openjdk less procps tzdata && \
+    (dnf -y install "tzdata-java-${CENTOS_TZDATA_VERSION}.noarch" || \
+     dnf -y downgrade "tzdata-java-${CENTOS_TZDATA_VERSION}.noarch") && \
+    (dnf -y install "tzdata-${CENTOS_TZDATA_VERSION}.noarch" || \
+     dnf -y downgrade "tzdata-${CENTOS_TZDATA_VERSION}.noarch")
 
 # We set the timezone to America/Los_Angeles due to issue
 # detailed here : https://github.com/facebookincubator/velox/issues/8127
diff --git a/scripts/docker/ubuntu-22.04-cpp.dockerfile b/scripts/docker/ubuntu-22.04-cpp.dockerfile
index 8175ecd6823..e96efe33733 100644
--- a/scripts/docker/ubuntu-22.04-cpp.dockerfile
+++ b/scripts/docker/ubuntu-22.04-cpp.dockerfile
@@ -11,9 +11,23 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+# tzdata is pinned to a known-good version so docker rebuilds (any time
+# scripts/docker/*.dockerfile or scripts/setup-*.sh changes) don't
+# silently bump tzdata in the image. See issue #17522 for the bug class
+# this prevents — version mismatch between OS tzdata and consumers'
+# bundled tzdb code can produce silent 1-hour offsets in TIMESTAMP
+# WITH TIME ZONE values. To bump intentionally: change the default and
+# rebuild locally to confirm before merging.
+ARG UBUNTU_TZDATA_VERSION=2026a-0ubuntu0.22.04.1
+
 ARG base=ubuntu:22.04
 FROM ${base}
 
+ARG UBUNTU_TZDATA_VERSION
+ARG DEBIAN_FRONTEND="noninteractive"
+RUN apt-get update && \
+      apt-get install -y --allow-downgrades "tzdata=${UBUNTU_TZDATA_VERSION}"
+
 RUN apt update && \
       apt install -y sudo \
             lsb-release \
@@ -37,4 +51,19 @@ ARG tz="Etc/UTC"
 ENV TZ=${tz}
 RUN /bin/bash -o pipefail /velox/scripts/setup-ubuntu.sh
 
+# Install tools needed for CI (gh for GitHub Actions stash, jq for JSON parsing)
+RUN apt-get update && \
+      apt-get install -y -q --no-install-recommends jq && \
+      curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg \
+        | dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg && \
+      echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" \
+        | tee /etc/apt/sources.list.d/github-cli.list > /dev/null && \
+      apt-get update && apt-get install -y -q --no-install-recommends gh && \
+      apt-get clean && rm -rf /var/lib/apt/lists/*
+
+# Pre-download gflags source for BUNDLED builds to avoid downloading at build time.
+RUN mkdir -p /velox/deps-sources && \
+    curl -fsSL -o /velox/deps-sources/gflags-v2.2.2.tar.gz \
+      https://github.com/gflags/gflags/archive/refs/tags/v2.2.2.tar.gz
+
 WORKDIR /velox
diff --git a/scripts/review/REVIEW_GUIDE.md b/scripts/review/REVIEW_GUIDE.md
new file mode 100644
index 00000000000..591d764b236
--- /dev/null
+++ b/scripts/review/REVIEW_GUIDE.md
@@ -0,0 +1,106 @@
+# PR Review Style Guide
+
+## Procedure
+
+1. Fetch PR using `scripts/review/fetch.py`. This is the only fetch needed —
+   work from its output for all subsequent analysis. Do not make additional
+   `gh api` or `gh pr diff` calls.
+2. Draft review to `~/.claude/review-drafts/pr-XXXXX-r1-v1.md`.
+3. Show draft and get approval before posting.
+4. Post using `scripts/review/post.py`.
+
+## First rule
+
+Before writing anything, ask: "Do I understand what this PR does end-to-end,
+and have I verified the claims?" If the answer is no, dig deeper before
+drafting. The most common mistake is focusing on code details before
+understanding the change.
+
+## Tone
+
+- **Opening:** "Thank you for the fix/contribution!" — then straight to the
+  points. Don't elaborate on what the PR does or praise specific design choices.
+- **Don't restate the PR description.** The author knows what they wrote.
+- **Skip "Thank you" when the PR needs fundamental clarification.** Lead with
+  the question instead.
+- **Be extra respectful when asking contributors to engage upstream.** They're
+  volunteering their time. Suggest filing an issue first — it shows respect for
+  upstream maintainers' expertise.
+- **Be encouraging with new contributors.** Acknowledge the value of the
+  capability they're adding.
+
+## Structure
+
+- Reviews should be concise and actionable. The author wants to get their work
+  done — don't waste their time with fluff.
+- **Order: big picture first.** Documentation, design questions, then code,
+  then tests. The most impactful feedback should come first.
+- **Every point must be actionable.** No observations without asks. If it
+  doesn't require the author to change something, don't include it.
+- **Drop qualifiers when the fix is obvious.** Don't explain why something is
+  wrong if the fix is self-evident.
+
+## Rigor
+
+- **Verify before claiming.** Don't assert facts about the codebase, other
+  projects, or behavior without checking. When in doubt, read the code.
+- **Verify author claims.** When an author says an API doesn't support
+  something, or references another PR/diff/external behavior, check the source.
+  Don't accept at face value.
+- **Check terminology.** Use precise terms. Don't conflate catalog/connector,
+  function/method, etc.
+
+## Re-reviews
+
+When the author says "addressed comments", re-review the full diff — don't
+just check the boxes from the previous round. Docs, naming, design choices,
+and new code added while addressing feedback all need fresh eyes.
+
+## What to check
+
+### Correctness
+
+- **PR title and description.** Are they clear, succinct, accurate? Does the
+  title describe what changed (not the symptom)? Does the description match
+  what the code actually does?
+- **CI status.** Is CI green? If red, is it related to the PR or pre-existing?
+- **Design.** Question design choices, don't just document them. Flag
+  surprising behavior (e.g., auto-selection), unnecessary complexity, or
+  features that could be simpler.
+- **API design.** Flag anti-patterns: setter injection when constructor params
+  would work, bypassing existing methods with inline boilerplate, unnecessary
+  type aliases. When a PR adds API surface for an external consumer, question
+  the consumer's architecture — "why does the caller need this?" matters more
+  than "what's the cleanest way to expose it?"
+- **Registries.** New registries should follow existing patterns (e.g.,
+  query-scoped registries design in #16993).
+
+### Code quality
+
+- **Velox coding conventions.** Ensure code follows
+  [CODING_STYLE.md](../../CODING_STYLE.md) and the rules in
+  [.claude/CLAUDE.md](../../.claude/CLAUDE.md).
+- **Comments.** Flag verbose code comments that restate the code, duplicate
+  docs elsewhere, or explain obvious behavior. Remove references to other
+  implementations ("like Java Presto") — logic should stand on its own.
+- **Naming.** Check variable names, file names, class names against coding
+  style conventions. Do not abbreviate parameter names.
+- **Enums.** `kPascalCase` enumerators, trailing commas, `VELOX_DEFINE_ENUM_NAME`.
+
+### Testing
+
+- **Tests.** Are they sufficient? Do they reproduce the bug? Is there an
+  integration test, not just a unit test? Are expected values hand-computed
+  (fragile) or derived from the test input? Are test helpers used to reduce
+  duplication? Do test names follow conventions?
+- **Test files.** Each test file should have one test suite with a matching
+  name. Empty test fixtures should use `TEST()` instead of `TEST_F()`.
+
+### Documentation
+
+- Are new functions/features documented? Are docs updated for changed behavior?
+  Are README changes accurate (not removing still-valid content)?
+- Check if **existing** doc pages need updating — e.g., a change to plan output
+  may require updating the print-plan-with-stats page, a dependency version
+  bump may require updating the dependency table.
+- **When unsure about conventions**, CC the maintainer rather than guessing.
diff --git a/scripts/review/fetch.py b/scripts/review/fetch.py
new file mode 100755
index 00000000000..54ecf9b8340
--- /dev/null
+++ b/scripts/review/fetch.py
@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Fetch all review-relevant information for a GitHub PR in one shot.
+
+Usage: fetch.py <owner/repo> <pr-number>
+       fetch.py <github-pr-url>
+
+Examples:
+    fetch.py facebookincubator/velox 17495
+    fetch.py https://github.com/facebookincubator/velox/pull/17495
+"""
+
+import json
+import re
+import subprocess
+import sys
+
+
+def run_gh(*args):
+    result = subprocess.run(["gh"] + list(args), capture_output=True, text=True)
+    if result.returncode != 0:
+        print(f"Error: {result.stderr.strip()}", file=sys.stderr)
+        return None
+    return result.stdout.strip()
+
+
+def parse_args():
+    if len(sys.argv) == 2:
+        match = re.match(r"https?://github\.com/([^/]+/[^/]+)/pull/(\d+)", sys.argv[1])
+        if match:
+            return match.group(1), match.group(2)
+        print(f"Invalid URL: {sys.argv[1]}", file=sys.stderr)
+        sys.exit(1)
+    elif len(sys.argv) == 3:
+        return sys.argv[1], sys.argv[2]
+    else:
+        print(__doc__.strip(), file=sys.stderr)
+        sys.exit(1)
+
+
+def fetch_pr_metadata(repo, pr):
+    raw = run_gh(
+        "pr",
+        "view",
+        pr,
+        "--repo",
+        repo,
+        "--json",
+        "title,body,author,state,files,additions,deletions,baseRefName,headRefName",
+    )
+    if not raw:
+        return None
+    return json.loads(raw)
+
+
+def fetch_diff(repo, pr):
+    return run_gh("pr", "diff", pr, "--repo", repo)
+
+
+def fetch_issue_comments(repo, pr):
+    raw = run_gh(
+        "api",
+        f"repos/{repo}/issues/{pr}/comments",
+        "--paginate",
+    )
+    if not raw:
+        return []
+    return json.loads(raw)
+
+
+def fetch_review_comments(repo, pr):
+    raw = run_gh(
+        "api",
+        f"repos/{repo}/pulls/{pr}/comments",
+        "--paginate",
+    )
+    if not raw:
+        return []
+    return json.loads(raw)
+
+
+def fetch_reviews(repo, pr):
+    raw = run_gh(
+        "api",
+        f"repos/{repo}/pulls/{pr}/reviews",
+    )
+    if not raw:
+        return []
+    return json.loads(raw)
+
+
+def print_section(title, content):
+    print(f"\n{'=' * 60}")
+    print(f" {title}")
+    print(f"{'=' * 60}\n")
+    print(content)
+
+
+def main():
+    repo, pr = parse_args()
+
+    metadata = fetch_pr_metadata(repo, pr)
+    if not metadata:
+        sys.exit(1)
+
+    print_section(
+        f"PR #{pr}: {metadata['title']}",
+        f"Author: {metadata['author']['login']}\n"
+        f"State: {metadata['state']}\n"
+        f"Branch: {metadata['headRefName']} -> {metadata['baseRefName']}\n"
+        f"+{metadata['additions']} -{metadata['deletions']}\n"
+        f"Files: {', '.join(f['path'] for f in metadata['files'])}\n"
+        f"\n{metadata['body']}",
+    )
+
+    diff = fetch_diff(repo, pr)
+    if diff:
+        print_section("Diff", diff)
+
+    skip = {"netlify[bot]", "github-actions[bot]"}
+
+    comments = fetch_issue_comments(repo, pr)
+    visible = [c for c in comments if c["user"]["login"] not in skip]
+    if visible:
+        lines = []
+        for c in visible:
+            lines.append(f"--- {c['user']['login']} ({c['created_at']}) ---")
+            lines.append(c["body"])
+            lines.append("")
+        print_section("Comments", "\n".join(lines))
+
+    reviews = fetch_reviews(repo, pr)
+    visible_reviews = [r for r in reviews if r.get("body")]
+    if visible_reviews:
+        lines = []
+        for r in visible_reviews:
+            lines.append(
+                f"--- {r['user']['login']} ({r['state']}, {r['submitted_at']}) ---"
+            )
+            lines.append(r["body"])
+            lines.append("")
+        print_section("Reviews", "\n".join(lines))
+
+    inline = fetch_review_comments(repo, pr)
+    if inline:
+        lines = []
+        for c in inline:
+            loc = f"{c['path']}:{c.get('line', c.get('original_line', '?'))}"
+            lines.append(f"--- {c['user']['login']} on {loc} ({c['created_at']}) ---")
+            lines.append(c["body"])
+            lines.append("")
+        print_section("Inline Comments", "\n".join(lines))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/review/post.py b/scripts/review/post.py
new file mode 100755
index 00000000000..1f461daa50a
--- /dev/null
+++ b/scripts/review/post.py
@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Post a GitHub PR review from a file.
+
+Usage: post.py <owner/repo> <pr-number> <event> <body-file>
+       post.py <github-pr-url> <event> <body-file>
+
+Events: APPROVE, REQUEST_CHANGES, COMMENT
+
+Examples:
+    post.py facebookincubator/velox 17495 REQUEST_CHANGES /tmp/review.md
+    post.py https://github.com/facebookincubator/velox/pull/17495 APPROVE /tmp/review.md
+"""
+
+import json
+import re
+import subprocess
+import sys
+
+VALID_EVENTS = {"APPROVE", "REQUEST_CHANGES", "COMMENT"}
+
+
+def run_gh(*args, stdin=None):
+    result = subprocess.run(
+        ["gh"] + list(args),
+        input=stdin,
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        print(f"Error: {result.stderr.strip()}", file=sys.stderr)
+        sys.exit(1)
+    return result.stdout.strip()
+
+
+def parse_args():
+    if len(sys.argv) == 4:
+        match = re.match(r"https?://github\.com/([^/]+/[^/]+)/pull/(\d+)", sys.argv[1])
+        if match:
+            return match.group(1), match.group(2), sys.argv[2], sys.argv[3]
+        print(f"Invalid URL: {sys.argv[1]}", file=sys.stderr)
+        sys.exit(1)
+    elif len(sys.argv) == 5:
+        return sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4]
+    else:
+        print(__doc__.strip(), file=sys.stderr)
+        sys.exit(1)
+
+
+def main():
+    repo, pr, event, body_file = parse_args()
+
+    event = event.upper()
+    if event not in VALID_EVENTS:
+        print(
+            f"Invalid event: {event}. Must be one of: {', '.join(sorted(VALID_EVENTS))}",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    with open(body_file) as f:
+        body = f.read()
+
+    if not body.strip():
+        print("Error: review body is empty", file=sys.stderr)
+        sys.exit(1)
+
+    payload = json.dumps({"event": event, "body": body, "comments": []})
+
+    result = run_gh(
+        "api",
+        f"repos/{repo}/pulls/{pr}/reviews",
+        "--method",
+        "POST",
+        "--input",
+        "-",
+        stdin=payload,
+    )
+
+    data = json.loads(result)
+    print(data.get("html_url", "Review submitted"))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/setup-centos-adapters.sh b/scripts/setup-centos-adapters.sh
index 6e8276c4848..ded2cd556d3 100755
--- a/scripts/setup-centos-adapters.sh
+++ b/scripts/setup-centos-adapters.sh
@@ -23,15 +23,51 @@
 # * INSTALL_PREREQUISITES="N": Skip installation of packages for build.
 # * PROMPT_ALWAYS_RESPOND="n": Automatically respond to interactive prompts.
 #     Use "n" to never wipe directories.
-# * VELOX_CUDA_VERSION="12.8": Which version of CUDA to install, will pick up
+# * VELOX_CUDA_VERSION="12.9": Which version of CUDA to install, will pick up
 #   CUDA_VERSION from the env
+# * VELOX_UCX_VERSION="1.19.0": Which version of ucx to install, will pick up
+#   UCX_VERSION from the env
 
 set -efx -o pipefail
 
-VELOX_CUDA_VERSION=${CUDA_VERSION:-"12.8"}
+VELOX_CUDA_VERSION=${CUDA_VERSION:-"12.9"}
+VELOX_UCX_VERSION=${UCX_VERSION:-"1.19.0"}
 SCRIPT_DIR=$(dirname "${BASH_SOURCE[0]}")
 source "$SCRIPT_DIR"/setup-centos9.sh
 
+function install_ucx {
+  dnf_install rdma-core-devel
+  local UCX_REPO_NAME="openucx/ucx"
+  local NEEDS_AUTOGEN=false
+
+  if [ "${VELOX_UCX_VERSION}" == "master" ]; then
+    github_checkout "${UCX_REPO_NAME}" "${VELOX_UCX_VERSION}"
+    NEEDS_AUTOGEN=true
+  else
+    wget_and_untar https://github.com/openucx/ucx/releases/download/v"${VELOX_UCX_VERSION}"/ucx-"${VELOX_UCX_VERSION}".tar.gz ucx
+  fi
+
+  (
+    cd "${DEPENDENCY_DIR}"/ucx || exit
+    if [ "${NEEDS_AUTOGEN}" = true ]; then
+      ./autogen.sh
+    fi
+
+    local CUDA_FLAG=""
+    if [ -d "/usr/local/cuda" ]; then
+      CUDA_FLAG="--with-cuda=/usr/local/cuda"
+    fi
+
+    mkdir build-linux && cd build-linux
+
+    ../contrib/configure-release --prefix="${INSTALL_PREFIX}" --with-sysroot --enable-cma \
+      --enable-mt --with-gnu-ld --with-rdmacm --with-verbs \
+      --without-go --without-java ${CUDA_FLAG}
+    make "-j${NPROC}"
+    make install
+  )
+}
+
 function install_cuda {
   # See https://developer.nvidia.com/cuda-downloads
   local arch
@@ -52,14 +88,15 @@ function install_cuda {
   dnf config-manager --add-repo "$repo_url"
   local dashed
   dashed="$(echo "$version" | tr '.' '-')"
-  dnf_install --repo cuda-rhel9-"$arch" \
+  dnf_install \
     cuda-compat-"$dashed" \
     cuda-driver-devel-"$dashed" \
     cuda-minimal-build-"$dashed" \
     cuda-nvrtc-devel-"$dashed" \
     libcufile-devel-"$dashed" \
     libnvjitlink-devel-"$dashed" \
-    numactl-libs
+    cuda-nvml-devel-"$dashed" \
+    numactl-devel
 }
 
 function install_adapters_deps_from_dnf {
@@ -79,8 +116,8 @@ function install_s3 {
 function install_adapters {
   run_and_time install_adapters_deps_from_dnf
   run_and_time install_s3
-  run_and_time install_gcs-sdk-cpp
-  run_and_time install_azure-storage-sdk-cpp
+  run_and_time install_gcs_sdk_cpp
+  run_and_time install_azure_storage_sdk_cpp
   run_and_time install_hdfs_deps
 }
 
diff --git a/scripts/setup-centos9.sh b/scripts/setup-centos9.sh
index b1dd08b0d88..44b60be2151 100755
--- a/scripts/setup-centos9.sh
+++ b/scripts/setup-centos9.sh
@@ -56,11 +56,12 @@ function install_build_prerequisites {
     dnf config-manager --set-enabled crb
     dnf update -y
   fi
-  dnf_install autoconf automake ccache gcc-toolset-12 git libtool \
-    ninja-build python3-pip python3-devel wget which
+  dnf_install autoconf automake ccache clang compiler-rt \
+    gcc-toolset-12 gcc-toolset-14 git libtool \
+    llvm ninja-build python3-pip python3-devel wget which
 
   install_uv
-  uv_install cmake
+  uv_install cmake@3.31.1
 
   if [[ ${USE_CLANG} != "false" ]]; then
     install_clang15
@@ -85,7 +86,12 @@ function install_gflags {
   # Remove an older version if present.
   dnf remove -y gflags
   wget_and_untar https://github.com/gflags/gflags/archive/"${GFLAGS_VERSION}".tar.gz gflags
-  cmake_install_dir gflags -DBUILD_SHARED_LIBS=ON -DBUILD_STATIC_LIBS=ON -DBUILD_gflags_LIB=ON -DLIB_SUFFIX=64
+  cmake_install_dir gflags -DBUILD_SHARED_LIBS=ON -DBUILD_STATIC_LIBS=ON -DBUILD_gflags_LIB=ON
+  # CentOS 9 does not include ${INSTALL_PREFIX}/lib in the default ldconfig
+  # search paths. Register it so that downstream builds (e.g. fbthrift's
+  # thrift1 compiler) can find libgflags.so at runtime.
+  echo "${INSTALL_PREFIX}/lib" >/etc/ld.so.conf.d/usr-local.conf
+  ldconfig
 }
 
 function install_faiss_deps {
@@ -114,6 +120,7 @@ function install_velox_deps {
   run_and_time install_xsimd
   run_and_time install_simdjson
   run_and_time install_geos
+  run_and_time install_s2geometry
   run_and_time install_faiss
 }
 
diff --git a/scripts/setup-common.sh b/scripts/setup-common.sh
index 59461664942..9699939d2af 100755
--- a/scripts/setup-common.sh
+++ b/scripts/setup-common.sh
@@ -24,9 +24,12 @@ VELOX_ARROW_CMAKE_PATCH=${VELOX_ARROW_CMAKE_PATCH:-""} # avoid error due to +u
 CMAKE_BUILD_TYPE="${BUILD_TYPE:-Release}"
 DEPENDENCY_DIR=${DEPENDENCY_DIR:-$(pwd)}
 BUILD_GEOS="${BUILD_GEOS:-true}"
+BUILD_S2GEOMETRY="${BUILD_S2GEOMETRY:-true}"
 BUILD_FAISS="${BUILD_FAISS:-true}"
 BUILD_DUCKDB="${BUILD_DUCKDB:-true}"
 EXTRA_ARROW_OPTIONS=${EXTRA_ARROW_OPTIONS:-""}
+EXTRA_ARROW_PATCH=${EXTRA_ARROW_PATCH:-""}
+SIMDJSON_SKIPUTF8VALIDATION=${SIMDJSON_SKIPUTF8VALIDATION:-"OFF"}
 
 USE_CLANG="${USE_CLANG:-false}"
 
@@ -44,19 +47,18 @@ function install_fmt {
 }
 
 function install_folly {
-  # Folly Portability.h being used to decide whether or not support coroutines
-  # causes issues (build, link) if the selection is not consistent across users of folly.
-  # shellcheck disable=SC2034
-  EXTRA_PKG_CXXFLAGS=" -DFOLLY_CFG_NO_COROUTINES"
   wget_and_untar https://github.com/facebook/folly/archive/refs/tags/"${FB_OS_VERSION}".tar.gz folly
-  cmake_install_dir folly -DBUILD_SHARED_LIBS="$VELOX_BUILD_SHARED" -DBUILD_TESTS=OFF -DFOLLY_HAVE_INT128_T=ON
+  local FOLLY_FLAGS=(-DBUILD_SHARED_LIBS="$VELOX_BUILD_SHARED" -DBUILD_TESTS=OFF -DFOLLY_HAVE_INT128_T=ON)
+  # When folly is static, use static gflags to avoid dual gflags flag
+  # registration when .so plugins are dlopen'd (both the binary and plugin
+  # would register the same flags in a shared gflags registry).
+  if [[ ${VELOX_BUILD_SHARED} != "ON" ]]; then
+    FOLLY_FLAGS+=(-DGFLAGS_SHARED=FALSE)
+  fi
+  cmake_install_dir folly "${FOLLY_FLAGS[@]}"
 }
 
 function install_fizz {
-  # Folly Portability.h being used to decide whether or not support coroutines
-  # causes issues (build, link) if the selection is not consistent across users of folly.
-  # shellcheck disable=SC2034
-  EXTRA_PKG_CXXFLAGS=" -DFOLLY_CFG_NO_COROUTINES"
   wget_and_untar https://github.com/facebookincubator/fizz/archive/refs/tags/"${FB_OS_VERSION}".tar.gz fizz
   cmake_install_dir fizz/fizz -DBUILD_TESTS=OFF
 }
@@ -67,28 +69,16 @@ function install_fast_float {
 }
 
 function install_wangle {
-  # Folly Portability.h being used to decide whether or not support coroutines
-  # causes issues (build, link) if the selection is not consistent across users of folly.
-  # shellcheck disable=SC2034
-  EXTRA_PKG_CXXFLAGS=" -DFOLLY_CFG_NO_COROUTINES"
   wget_and_untar https://github.com/facebook/wangle/archive/refs/tags/"${FB_OS_VERSION}".tar.gz wangle
   cmake_install_dir wangle/wangle -DBUILD_TESTS=OFF
 }
 
 function install_mvfst {
-  # Folly Portability.h being used to decide whether or not support coroutines
-  # causes issues (build, link) if the selection is not consistent across users of folly.
-  # shellcheck disable=SC2034
-  EXTRA_PKG_CXXFLAGS=" -DFOLLY_CFG_NO_COROUTINES"
   wget_and_untar https://github.com/facebook/mvfst/archive/refs/tags/"${FB_OS_VERSION}".tar.gz mvfst
   cmake_install_dir mvfst -DBUILD_TESTS=OFF
 }
 
 function install_fbthrift {
-  # Folly Portability.h being used to decide whether or not support coroutines
-  # causes issues (build, link) if the selection is not consistent across users of folly.
-  # shellcheck disable=SC2034
-  EXTRA_PKG_CXXFLAGS=" -DFOLLY_CFG_NO_COROUTINES"
   wget_and_untar https://github.com/facebook/fbthrift/archive/refs/tags/"${FB_OS_VERSION}".tar.gz fbthrift
   cmake_install_dir fbthrift -Denable_tests=OFF -DBUILD_TESTS=OFF -DBUILD_SHARED_LIBS=OFF
 }
@@ -125,10 +115,25 @@ function install_boost {
 }
 
 function install_protobuf {
+  install_abseil
+
   wget_and_untar https://github.com/protocolbuffers/protobuf/releases/download/v"${PROTOBUF_VERSION}"/protobuf-all-"${PROTOBUF_VERSION}".tar.gz protobuf
   cmake_install_dir protobuf -Dprotobuf_BUILD_TESTS=OFF -Dprotobuf_ABSL_PROVIDER=package
 }
 
+function install_grpc {
+  wget_and_untar https://github.com/grpc/grpc/archive/refs/tags/v"${GRPC_VERSION}".tar.gz grpc
+  cmake_install_dir grpc \
+    -DgRPC_BUILD_TESTS=OFF \
+    -DgRPC_ABSL_PROVIDER=package \
+    -DgRPC_ZLIB_PROVIDER=package \
+    -DgRPC_CARES_PROVIDER=package \
+    -DgRPC_RE2_PROVIDER=package \
+    -DgRPC_SSL_PROVIDER=package \
+    -DgRPC_PROTOBUF_PROVIDER=package \
+    -DgRPC_INSTALL=ON
+}
+
 function install_double_conversion {
   wget_and_untar https://github.com/google/double-conversion/archive/refs/tags/"${DOUBLE_CONVERSION_VERSION}".tar.gz double-conversion
   cmake_install_dir double-conversion -DBUILD_TESTING=OFF
@@ -139,9 +144,29 @@ function install_ranges_v3 {
   cmake_install_dir ranges_v3 -DRANGES_ENABLE_WERROR=OFF -DRANGE_V3_TESTS=OFF -DRANGE_V3_EXAMPLES=OFF
 }
 
+function install_abseil {
+  wget_and_untar https://github.com/abseil/abseil-cpp/archive/refs/tags/"${ABSEIL_VERSION}".tar.gz abseil-cpp
+  local OS
+  OS=$(uname)
+  if [[ $OS == "Darwin" ]]; then
+    ABSOLUTE_SCRIPTDIR=$(realpath "$SCRIPT_DIR")
+    (
+      cd "${DEPENDENCY_DIR}/abseil-cpp" || exit 1
+      git apply $ABSOLUTE_SCRIPTDIR/../CMake/resolve_dependency_modules/absl/absl-macos.patch
+    )
+  fi
+  cmake_install_dir abseil-cpp \
+    -DABSL_BUILD_TESTING=OFF \
+    -DCMAKE_CXX_STANDARD=17 \
+    -DABSL_PROPAGATE_CXX_STD=ON \
+    -DABSL_ENABLE_INSTALL=ON
+}
+
 function install_re2 {
+  install_abseil
+
   wget_and_untar https://github.com/google/re2/archive/refs/tags/"${RE2_VERSION}".tar.gz re2
-  cmake_install_dir re2 -DRE2_BUILD_TESTING=OFF
+  cmake_install_dir re2 -DRE2_BUILD_TESTING=OFF -Dabsl_DIR="${INSTALL_PREFIX}/lib/cmake/absl"
 }
 
 function install_glog {
@@ -150,7 +175,7 @@ function install_glog {
 }
 
 function install_lzo {
-  wget_and_untar http://www.oberhumer.com/opensource/lzo/download/lzo-"${LZO_VERSION}".tar.gz lzo
+  wget_and_untar https://www.oberhumer.com/opensource/lzo/download/lzo-"${LZO_VERSION}".tar.gz lzo
   (
     cd "${DEPENDENCY_DIR}"/lzo || exit
     ./configure --prefix="${INSTALL_PREFIX}" --enable-shared --disable-static --docdir=/usr/share/doc/lzo-"${LZO_VERSION}"
@@ -171,7 +196,7 @@ function install_xsimd {
 
 function install_simdjson {
   wget_and_untar https://github.com/simdjson/simdjson/archive/refs/tags/v"${SIMDJSON_VERSION}".tar.gz simdjson
-  cmake_install_dir simdjson
+  cmake_install_dir simdjson -DSIMDJSON_SKIPUTF8VALIDATION=${SIMDJSON_SKIPUTF8VALIDATION}
 }
 
 function install_arrow {
@@ -186,6 +211,10 @@ function install_arrow {
 
     cd "$DEPENDENCY_DIR"/arrow || exit 1
     git apply "$VELOX_ARROW_CMAKE_PATCH"
+    # Presto needs this for Arrow Flight
+    if [[ -n $EXTRA_ARROW_PATCH ]]; then
+      git apply "$EXTRA_ARROW_PATCH"
+    fi
   ) || exit 1
 
   cmake_install_dir arrow/cpp \
@@ -252,6 +281,16 @@ function install_geos {
   fi
 }
 
+function install_s2geometry {
+  if [[ $BUILD_S2GEOMETRY == "true" ]]; then
+    wget_and_untar https://github.com/google/s2geometry/archive/refs/tags/v"${S2GEOMETRY_VERSION}".tar.gz s2geometry
+    # Apply the same GCC 12 patch used by the BUNDLED CMake resolver.
+    patch -p1 -d "${DEPENDENCY_DIR}/s2geometry" < \
+      "${SCRIPT_DIR}/../CMake/resolve_dependency_modules/s2geometry/s2geometry-gcc12-max.patch" || true
+    cmake_install_dir s2geometry -DBUILD_TESTING=OFF -DBUILD_TESTS=OFF -DBUILD_SHARED_LIBS=OFF
+  fi
+}
+
 function install_faiss_deps {
   echo "Unsupported platform for faiss"
 }
@@ -277,7 +316,7 @@ function install_aws_deps {
   local AWS_REPO_NAME="aws/aws-sdk-cpp"
 
   github_checkout $AWS_REPO_NAME "$AWS_SDK_VERSION" --depth 1 --recurse-submodules
-  cmake_install -DCMAKE_BUILD_TYPE="${CMAKE_BUILD_TYPE}" -DBUILD_SHARED_LIBS:BOOL=OFF -DMINIMIZE_SIZE:BOOL=ON -DENABLE_TESTING:BOOL=OFF -DBUILD_ONLY:STRING="s3;identity-management"
+  cmake_install_dir aws-sdk-cpp -DCMAKE_BUILD_TYPE="${CMAKE_BUILD_TYPE}" -DBUILD_SHARED_LIBS:BOOL=OFF -DMINIMIZE_SIZE:BOOL=ON -DENABLE_TESTING:BOOL=OFF -DBUILD_ONLY:STRING="s3;identity-management"
 }
 
 function install_minio {
@@ -298,62 +337,41 @@ function install_minio {
   ${SUDO} mv ./"${MINIO_BINARY_NAME}" "$INSTALL_PREFIX"/bin/
 }
 
-function install_gcs-sdk-cpp {
+function install_gcs_sdk_cpp {
   # Install gcs dependencies
   # https://github.com/googleapis/google-cloud-cpp/blob/main/doc/packaging.md#required-libraries
 
-  # abseil-cpp
-  github_checkout abseil/abseil-cpp "${ABSEIL_VERSION}" --depth 1
-  cmake_install \
-    -DABSL_BUILD_TESTING=OFF \
-    -DCMAKE_CXX_STANDARD=17 \
-    -DABSL_PROPAGATE_CXX_STD=ON \
-    -DABSL_ENABLE_INSTALL=ON
-
-  # protobuf
-  github_checkout protocolbuffers/protobuf v"${PROTOBUF_VERSION}" --depth 1
-  cmake_install \
-    -Dprotobuf_BUILD_TESTS=OFF \
-    -Dprotobuf_ABSL_PROVIDER=package
-
-  # grpc
-  github_checkout grpc/grpc "${GRPC_VERSION}" --depth 1
-  cmake_install \
-    -DgRPC_BUILD_TESTS=OFF \
-    -DgRPC_ABSL_PROVIDER=package \
-    -DgRPC_ZLIB_PROVIDER=package \
-    -DgRPC_CARES_PROVIDER=package \
-    -DgRPC_RE2_PROVIDER=package \
-    -DgRPC_SSL_PROVIDER=package \
-    -DgRPC_PROTOBUF_PROVIDER=package \
-    -DgRPC_INSTALL=ON
+  # abseil-cpp, protobuf, grpc
+  install_protobuf
+  install_grpc
 
   # crc32
-  github_checkout google/crc32c "${CRC32_VERSION}" --depth 1
-  cmake_install \
+  wget_and_untar https://github.com/google/crc32c/archive/refs/tags/"${CRC32_VERSION}".tar.gz crc32c
+  cmake_install_dir crc32c \
     -DCRC32C_BUILD_TESTS=OFF \
     -DCRC32C_BUILD_BENCHMARKS=OFF \
     -DCRC32C_USE_GLOG=OFF
 
   # nlohmann json
-  github_checkout nlohmann/json "${NLOHMAN_JSON_VERSION}" --depth 1
-  cmake_install \
+  wget_and_untar https://github.com/nlohmann/json/archive/refs/tags/v"${NLOHMAN_JSON_VERSION}".tar.gz json
+  cmake_install_dir json \
     -DJSON_BuildTests=OFF
 
   # google-cloud-cpp
-  github_checkout googleapis/google-cloud-cpp "${GOOGLE_CLOUD_CPP_VERSION}" --depth 1
-  cmake_install \
+  wget_and_untar https://github.com/googleapis/google-cloud-cpp/archive/refs/tags/v"${GOOGLE_CLOUD_CPP_VERSION}".tar.gz google-cloud-cpp
+  cmake_install_dir google-cloud-cpp \
     -DGOOGLE_CLOUD_CPP_ENABLE_EXAMPLES=OFF \
     -DGOOGLE_CLOUD_CPP_ENABLE=storage
 }
 
-function install_azure-storage-sdk-cpp {
+function install_azure_storage_sdk_cpp {
   # Disable VCPKG to install additional static dependencies under the VCPKG installed path
   # instead of using system pre-installed dependencies.
   export AZURE_SDK_DISABLE_AUTO_VCPKG=ON
   vcpkg_commit_id=7a6f366cefd27210f6a8309aed10c31104436509
   github_checkout azure/azure-sdk-for-cpp azure-storage-files-datalake_"${AZURE_SDK_VERSION}"
-  sed -i "s/set(VCPKG_COMMIT_STRING .*)/set(VCPKG_COMMIT_STRING $vcpkg_commit_id)/" cmake-modules/AzureVcpkg.cmake
+  pushd azure-sdk-for-cpp || exit
+  sed -i='' "s/set(VCPKG_COMMIT_STRING .*)/set(VCPKG_COMMIT_STRING $vcpkg_commit_id)/" cmake-modules/AzureVcpkg.cmake
 
   azure_core_dir="sdk/core/azure-core"
   if ! grep -q "baseline" $azure_core_dir/vcpkg.json; then
@@ -362,8 +380,8 @@ function install_azure-storage-sdk-cpp {
     if [[ $openssl_version == 1.1.1* ]]; then
       openssl_version="1.1.1n"
     fi
-    sed -i "s/\"version-string\"/\"builtin-baseline\": \"$vcpkg_commit_id\",\"version-string\"/" $azure_core_dir/vcpkg.json
-    sed -i "s/\"version-string\"/\"overrides\": [{ \"name\": \"openssl\", \"version-string\": \"$openssl_version\" }],\"version-string\"/" $azure_core_dir/vcpkg.json
+    sed -i='' "s/\"version-string\"/\"builtin-baseline\": \"$vcpkg_commit_id\",\"version-string\"/" $azure_core_dir/vcpkg.json
+    sed -i='' "s/\"version-string\"/\"overrides\": [{ \"name\": \"openssl\", \"version-string\": \"$openssl_version\" }],\"version-string\"/" $azure_core_dir/vcpkg.json
   fi
   (
     cd $azure_core_dir || exit
@@ -389,13 +407,16 @@ function install_azure-storage-sdk-cpp {
     cd sdk/storage/azure-storage-files-datalake || exit
     cmake_install -DCMAKE_BUILD_TYPE="${CMAKE_BUILD_TYPE}" -DBUILD_SHARED_LIBS=OFF
   )
+  popd || exit
 }
 
 function install_hdfs_deps {
   # Dependencies for Hadoop testing
-  wget_and_untar https://archive.apache.org/dist/hadoop/common/hadoop-"${HADOOP_VERSION}"/hadoop-"${HADOOP_VERSION}".tar.gz hadoop
+  wget_and_untar https://dlcdn.apache.org/hadoop/common/hadoop-"${HADOOP_VERSION}"/hadoop-"${HADOOP_VERSION}".tar.gz hadoop
   cp -a "${DEPENDENCY_DIR}"/hadoop "$INSTALL_PREFIX"
   wget "${WGET_OPTS[@]}" -P "$INSTALL_PREFIX"/hadoop/share/hadoop/common/lib/ https://repo1.maven.org/maven2/junit/junit/4.11/junit-4.11.jar
+  # Needed for HADOOP 3.3.6 minicluster. Can remove after updating to 3.4.2.
+  wget "${WGET_OPTS[@]}" -P "$INSTALL_PREFIX"/hadoop/share/hadoop/mapreduce/ https://repo1.maven.org/maven2/org/mockito/mockito-core/2.23.4/mockito-core-2.23.4.jar
 }
 
 function install_uv {
diff --git a/scripts/setup-fedora.sh b/scripts/setup-fedora.sh
index 619be70ec89..0164bee9a85 100755
--- a/scripts/setup-fedora.sh
+++ b/scripts/setup-fedora.sh
@@ -55,6 +55,36 @@ function install_build_prerequisites {
   fi
 }
 
+function install_velox_deps_from_dnf {
+  dnf_install \
+    bison boost-devel c-ares-devel curl-devel double-conversion-devel \
+    elfutils-libelf-devel flex fmt-devel gflags-devel glog-devel gmock-devel \
+    gtest-devel libdwarf-devel libevent-devel libicu-devel \
+    libsodium-devel libzstd-devel lz4-devel openssl-devel-engine \
+    re2-devel snappy-devel thrift-devel xxhash-devel zlib-devel grpc-devel grpc-plugins
+
+  install_faiss_deps
+}
+
+function install_velox_deps {
+  run_and_time install_velox_deps_from_dnf
+  run_and_time install_gcs_sdk_cpp #grpc, abseil, protobuf
+  run_and_time install_fast_float
+  run_and_time install_folly
+  run_and_time install_fizz
+  run_and_time install_wangle
+  run_and_time install_mvfst
+  run_and_time install_fbthrift
+  run_and_time install_duckdb
+  run_and_time install_stemmer
+  run_and_time install_arrow
+  run_and_time install_xsimd    # to new in fedora repos
+  run_and_time install_simdjson # to new in fedora repos
+  run_and_time install_geos     # to new in fedora repos
+  run_and_time install_s2geometry
+  run_and_time install_faiss
+}
+
 (return 2>/dev/null) && return # If script was sourced, don't run commands.
 
 (
@@ -90,6 +120,8 @@ function install_build_prerequisites {
       set -u
     fi
     install_velox_deps
+    # BUILD_TESTING requires grpc
+    dnf_install grpc
     echo "All dependencies for Velox installed!"
     if [[ ${USE_CLANG} != "false" ]]; then
       echo "To use clang for the Velox build set the CC and CXX environment variables in your session."
diff --git a/scripts/setup-helper-functions.sh b/scripts/setup-helper-functions.sh
index 078454f8ca2..a50fb02ae0e 100755
--- a/scripts/setup-helper-functions.sh
+++ b/scripts/setup-helper-functions.sh
@@ -49,6 +49,7 @@ function prompt {
     done
   ) 2>/dev/null
 }
+
 function github_checkout {
   local REPO=$1
   shift
@@ -69,7 +70,6 @@ function github_checkout {
   if [ ! -d "${DIRNAME}" ]; then
     git clone -q -b "$VERSION" "${GIT_CLONE_PARAMS[@]}" "https://github.com/${REPO}.git"
   fi
-  cd "${DIRNAME}" || exit
 }
 
 # get_cxx_flags [$CPU_ARCH]
diff --git a/scripts/setup-macos.sh b/scripts/setup-macos.sh
index 5c05c0dcbb8..fbd45af7801 100755
--- a/scripts/setup-macos.sh
+++ b/scripts/setup-macos.sh
@@ -41,8 +41,9 @@ export OS_CXXFLAGS
 export CMAKE_POLICY_VERSION_MINIMUM="3.5"
 
 DEPENDENCY_DIR=${DEPENDENCY_DIR:-$(pwd)}
-MACOS_VELOX_DEPS="bison flex gflags glog googletest icu4c libevent libsodium lz4 openssl protobuf@21 simdjson snappy xz xxhash zstd"
-
+# gflags and glog are installed from source to ensure version compatibility.
+# Homebrew's glog 0.7.x has breaking API changes that are incompatible with folly.
+MACOS_VELOX_DEPS="bison flex googletest icu4c libevent libsodium lz4 openssl simdjson snappy xz xxhash zstd"
 MACOS_BUILD_DEPS="ninja cmake"
 
 SUDO="${SUDO:-""}"
@@ -103,6 +104,11 @@ function install_velox_deps_from_brew {
   done
 }
 
+function install_gflags {
+  wget_and_untar https://github.com/gflags/gflags/archive/"${GFLAGS_VERSION}".tar.gz gflags
+  cmake_install_dir gflags -DBUILD_SHARED_LIBS=ON -DBUILD_STATIC_LIBS=ON -DBUILD_gflags_LIB=ON
+}
+
 function install_s3 {
   install_aws_deps
 
@@ -111,11 +117,11 @@ function install_s3 {
 }
 
 function install_gcs {
-  install_gcs-sdk-cpp
+  install_gcs_sdk_cpp
 }
 
 function install_abfs {
-  install_azure-storage-sdk-cpp
+  install_azure_storage_sdk_cpp
 }
 
 function install_hdfs {
@@ -151,7 +157,6 @@ function install_faiss {
     install_faiss_deps
 
     wget_and_untar "https://github.com/facebookresearch/faiss/archive/refs/tags/v${FAISS_VERSION}.tar.gz" faiss
-
     local cmake_args
     cmake_args=(
       -DFAISS_ENABLE_GPU=OFF
@@ -177,7 +182,10 @@ function install_velox_deps {
   run_and_time install_ranges_v3
   run_and_time install_double_conversion
   run_and_time install_re2
+  run_and_time install_gflags
+  run_and_time install_glog
   run_and_time install_boost
+  run_and_time install_protobuf
   run_and_time install_fmt
   run_and_time install_fast_float
   run_and_time install_folly
@@ -193,6 +201,7 @@ function install_velox_deps {
   run_and_time install_arrow
   run_and_time install_duckdb_clang
   run_and_time install_geos
+  run_and_time install_s2geometry
   run_and_time install_faiss
 }
 
diff --git a/scripts/setup-ubuntu.sh b/scripts/setup-ubuntu.sh
index 339b129bb85..4bb68643678 100755
--- a/scripts/setup-ubuntu.sh
+++ b/scripts/setup-ubuntu.sh
@@ -189,7 +189,7 @@ function install_cuda {
     cuda-minimal-build-"$dashed" \
     cuda-nvrtc-dev-"$dashed" \
     libcufile-dev-"$dashed" \
-    libnvjitlink-devel-"$dashed" \
+    libnvjitlink-dev-"$dashed" \
     libnuma1
 }
 
@@ -202,18 +202,18 @@ function install_s3 {
 
 function install_gcs {
   # Dependencies of GCS, probably a workaround until the docker image is rebuilt
-  apt install -y --no-install-recommends libc-ares-dev libcurl4-openssl-dev
-  install_gcs-sdk-cpp
+  ${SUDO} apt install -y --no-install-recommends libc-ares-dev libcurl4-openssl-dev
+  install_gcs_sdk_cpp
 }
 
 function install_abfs {
   # Dependencies of Azure Storage Blob cpp
-  apt install -y openssl libxml2-dev
-  install_azure-storage-sdk-cpp
+  ${SUDO} apt install -y openssl libxml2-dev
+  install_azure_storage_sdk_cpp
 }
 
 function install_hdfs {
-  apt install -y --no-install-recommends libxml2-dev libgsasl7-dev uuid-dev openjdk-8-jdk
+  ${SUDO} apt install -y --no-install-recommends libxml2-dev libgsasl7-dev uuid-dev openjdk-8-jdk
   install_hdfs_deps
 }
 
@@ -225,13 +225,14 @@ function install_adapters {
 }
 
 function install_faiss_deps {
-  sudo apt-get install -y libopenblas-dev libomp-dev
+  ${SUDO} apt-get install -y libopenblas-dev libomp-dev
 }
 
 function install_velox_deps {
   run_and_time install_velox_deps_from_apt
   run_and_time install_fmt
   run_and_time install_protobuf
+  run_and_time install_grpc
   run_and_time install_boost
   run_and_time install_fast_float
   run_and_time install_folly
@@ -247,6 +248,7 @@ function install_velox_deps {
   run_and_time install_xsimd
   run_and_time install_simdjson
   run_and_time install_geos
+  run_and_time install_s2geometry
   run_and_time install_faiss
 }
 
diff --git a/scripts/setup-versions.sh b/scripts/setup-versions.sh
index 43428a7f4d8..a14a631df76 100755
--- a/scripts/setup-versions.sh
+++ b/scripts/setup-versions.sh
@@ -19,14 +19,20 @@
 # The versions should match the declared versions in this file.
 
 # Build dependencies versions.
-FB_OS_VERSION="v2025.04.28.00"
-FMT_VERSION="10.1.1"
+# Note: When updating FB_OS_VERSION, ensure that
+# CMake/third-party/FBThriftCppLibrary.cmake is updated
+# with the matching version from fbthrift:
+# <fbthrift_github>/build/fbcode_builder/CMake/FBThriftCppLibrary.cmake
+# The new FB_OS version of fbthrift might require changes such that thrift
+# files are generated properly on all platforms.
+FB_OS_VERSION="v2026.01.05.00"
+FMT_VERSION="11.2.0"
 BOOST_VERSION="boost-1.84.0"
-ARROW_VERSION="15.0.0"
+ARROW_VERSION="18.0.0"
 DUCKDB_VERSION="v0.8.1"
 PROTOBUF_VERSION="21.8"
 XSIMD_VERSION="10.0.0"
-SIMDJSON_VERSION="3.9.3"
+SIMDJSON_VERSION="4.1.0"
 CPR_VERSION="1.10.5"
 DOUBLE_CONVERSION_VERSION="v3.1.5"
 RANGE_V3_VERSION="0.12.0"
@@ -38,6 +44,7 @@ SNAPPY_VERSION="1.1.8"
 THRIFT_VERSION="${THRIFT_VERSION:-v0.16.0}"
 STEMMER_VERSION="2.2.0"
 GEOS_VERSION="3.10.7"
+S2GEOMETRY_VERSION="0.12.0"
 # shellcheck disable=SC2034
 FAISS_VERSION="1.11.0"
 FAST_FLOAT_VERSION="v8.0.2"
@@ -45,12 +52,12 @@ CCACHE_VERSION="4.11.3"
 
 # Adapter related versions.
 ABSEIL_VERSION="20240116.2"
-GRPC_VERSION="v1.48.1"
+GRPC_VERSION="1.48.1"
 CRC32_VERSION="1.1.2"
-NLOHMAN_JSON_VERSION="v3.11.3"
-GOOGLE_CLOUD_CPP_VERSION="v2.22.0"
-HADOOP_VERSION="3.3.0"
+NLOHMAN_JSON_VERSION="3.11.3"
+GOOGLE_CLOUD_CPP_VERSION="2.22.0"
+HADOOP_VERSION="3.3.6"
 AZURE_SDK_VERSION="12.8.0"
 MINIO_VERSION="2022-05-26T05-48-41Z"
 MINIO_BINARY_NAME="minio-2022-05-26"
-AWS_SDK_VERSION="1.11.321"
+AWS_SDK_VERSION="1.11.654"
diff --git a/scripts/update-cudf-deps.sh b/scripts/update-cudf-deps.sh
new file mode 100755
index 00000000000..a7048f23177
--- /dev/null
+++ b/scripts/update-cudf-deps.sh
@@ -0,0 +1,250 @@
+#!/usr/bin/env bash
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set -euo pipefail
+
+usage() {
+  cat <<EOF
+Usage: $0 --branch <branch>
+       $0 --pr <pr-number>
+       $0 --commit <sha>
+
+Options:
+  --branch <branch>    Update all cudf dependencies to latest from branch
+  --pr <pr-number>     Update only cudf from a specific PR
+  --commit <sha>       Update all dependencies using cudf commit and compatible versions
+
+Environment Variables:
+  GH_TOKEN         GitHub personal access token for higher API rate limits via curl (optional)
+
+Examples:
+  $0 --branch main
+  $0 --branch release/26.02
+  $0 --pr 12345
+  $0 --commit abc123def456
+  GH_TOKEN=github_pat_xxx $0 --branch main
+EOF
+}
+
+[[ $# -eq 0 ]] && usage && exit 1
+
+MODE="$1"
+ARG="${2:-}"
+[[ -z $ARG ]] && echo "Error: $MODE requires an argument" && usage && exit 1
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CMAKE_FILE="$SCRIPT_DIR/../CMake/resolve_dependency_modules/cudf.cmake"
+
+# Use gh CLI if available or fall back to curl supporting GitHub token for higher rate limits.
+GH_TOKEN="${GH_TOKEN:-}"
+
+fetch_github_api() {
+  local endpoint=$1
+  local response http_code
+  if command -v gh &>/dev/null; then
+    if response=$(gh api "${endpoint}" 2>&1); then
+      echo "$response"
+      return 0
+    fi
+    echo "Error: gh api failed" >&2
+    echo "Response: $response" >&2
+  else
+    local curl_opts=(-s --max-time 30 -w '%{http_code}')
+    if [[ -n $GH_TOKEN ]]; then
+      curl_opts+=(-H "Authorization: token $GH_TOKEN")
+    fi
+    local raw
+    raw=$(curl "${curl_opts[@]}" "https://api.github.com/${endpoint}" 2>&1)
+    http_code="${raw: -3}"
+    response="${raw%???}"
+    if [[ $http_code == "200" ]]; then
+      echo "$response"
+      return 0
+    fi
+    echo "Error: GitHub API returned HTTP $http_code for $endpoint" >&2
+  fi
+  echo "" >&2
+  echo "SOLUTION: Authenticate to get 5,000 requests/hour:" >&2
+  if command -v gh &>/dev/null; then
+    echo "  gh auth login" >&2
+  else
+    echo "  export GH_TOKEN=gh_pat_xx" >&2
+    echo "  Get a token at: https://github.com/settings/personal-access-tokens/new  (access: public repo)" >&2
+  fi
+  return 1
+}
+
+get_commit_info() {
+  local repo=$1 branch=$2
+  local response
+  response=$(fetch_github_api "repos/rapidsai/${repo}/commits/${branch}") || return 1
+  echo "$response" | jq -r '[.sha, .commit.committer.date[:10]] | join(" ")' 2>/dev/null || {
+    echo "Error: Failed to parse JSON response from $repo" >&2
+    return 1
+  }
+}
+
+get_commit_before_date() {
+  local repo=$1 until_date=$2
+  local response
+  response=$(fetch_github_api "repos/rapidsai/${repo}/commits?sha=main&until=${until_date}&per_page=1") || return 1
+  echo "$response" | jq -r '.[0] | [.sha, .commit.committer.date[:10]] | join(" ")' 2>/dev/null || {
+    echo "Error: Failed to parse response for $repo before $until_date" >&2
+    return 1
+  }
+}
+
+get_sha256() {
+  curl -sL --max-time 30 "https://github.com/rapidsai/$1/archive/$2.tar.gz" | sha256sum | cut -d' ' -f1 || {
+    echo "Error: Failed to compute SHA256 for $1:$2" >&2
+    return 1
+  }
+}
+
+get_version() {
+  local branch=$1
+  if [[ $branch =~ ^release/([0-9]+\.[0-9]+)$ ]]; then
+    echo "${BASH_REMATCH[1]}"
+  else
+    local response
+    response=$(fetch_github_api "repos/rapidsai/cudf/contents/VERSION?ref=${branch}") || return 1
+    echo "$response" | jq -r '.content' | base64 -d | grep -oP '^[0-9]+\.[0-9]+' || {
+      echo "Error: Failed to parse VERSION file from branch $branch" >&2
+      return 1
+    }
+  fi
+}
+
+update_dependency() {
+  local var=$1 commit=$2 date=$3 checksum=$4
+  sed -i "s/# ${var} commit [a-f0-9]* from [0-9-]*/# ${var} commit ${commit:0:7} from ${date}/" "$CMAKE_FILE"
+  sed -i "s/set(VELOX_${var}_COMMIT [a-f0-9]*)/set(VELOX_${var}_COMMIT ${commit})/" "$CMAKE_FILE"
+
+  if [[ $var == "cudf" ]]; then
+    sed -i "s/set(VELOX_${var}_VERSION [0-9.]* CACHE/set(VELOX_${var}_VERSION ${VERSION} CACHE/" "$CMAKE_FILE"
+  else
+    sed -i "s/set(VELOX_${var}_VERSION [0-9.]*)/set(VELOX_${var}_VERSION ${VERSION})/" "$CMAKE_FILE"
+  fi
+
+  awk -v var="VELOX_${var}_BUILD_SHA256_CHECKSUM" -v sum="$checksum" '
+    $0 ~ var { found=1 }
+    found && /^[[:space:]]*[a-f0-9]{64}[[:space:]]*$/ { sub(/[a-f0-9]{64}/, sum); found=0 }
+    { print }
+  ' "$CMAKE_FILE" >"${CMAKE_FILE}.tmp" && mv "${CMAKE_FILE}.tmp" "$CMAKE_FILE"
+}
+
+if [[ $MODE == "--pr" ]]; then
+  echo "Fetching cuDF PR #${ARG}..."
+  PR_INFO=$(fetch_github_api "repos/rapidsai/cudf/pulls/${ARG}") || exit 1
+  SHA=$(echo "$PR_INFO" | jq -r '.head.sha')
+  BASE=$(echo "$PR_INFO" | jq -r '.base.ref')
+  VERSION=$(get_version "$BASE") || exit 1
+  DATE=$(fetch_github_api "repos/rapidsai/cudf/commits/${SHA}" | jq -r '.commit.committer.date[:10]') || exit 1
+
+  echo "  Base: $BASE (version $VERSION)"
+  echo "  Commit: ${SHA:0:7} from $DATE"
+  echo "  Computing SHA256..."
+  CHECKSUM=$(get_sha256 "cudf" "$SHA") || exit 1
+  echo "  SHA256: $CHECKSUM"
+  echo
+
+  update_dependency "cudf" "$SHA" "$DATE" "$CHECKSUM"
+  echo "Done! Updated cudf to PR #${ARG}: ${SHA:0:7} ($DATE)"
+
+elif [[ $MODE == "--commit" ]]; then
+  echo "Fetching cuDF commit ${ARG:0:7}..."
+  COMMIT_INFO=$(fetch_github_api "repos/rapidsai/cudf/commits/${ARG}") || exit 1
+  SHA=$(echo "$COMMIT_INFO" | jq -r '.sha')
+  DATE=$(echo "$COMMIT_INFO" | jq -r '.commit.committer.date[:10]')
+  TIMESTAMP=$(echo "$COMMIT_INFO" | jq -r '.commit.committer.date')
+  VERSION=$(fetch_github_api "repos/rapidsai/cudf/contents/VERSION?ref=${SHA}" | jq -r '.content' | base64 -d | grep -oP '^[0-9]+\.[0-9]+') || exit 1
+
+  echo "  Commit: ${SHA:0:7} from $DATE"
+  echo "  Version: $VERSION"
+  echo
+
+  declare -A COMMITS DATES CHECKSUMS
+  COMMITS[cudf]=$SHA
+  DATES[cudf]=$DATE
+
+  echo "Finding compatible dependency versions (main branch commits before $TIMESTAMP)..."
+  echo
+
+  for dep in rapids_cmake rmm kvikio; do
+    repo=${dep//_/-}
+    echo "Fetching $repo..."
+    read -r commit date < <(get_commit_before_date "$repo" "$TIMESTAMP") || exit 1
+    echo "  Commit: ${commit:0:7} from $date"
+    echo "  Computing SHA256..."
+    checksum=$(get_sha256 "$repo" "$commit") || exit 1
+    echo "  SHA256: $checksum"
+
+    COMMITS[$dep]=$commit
+    DATES[$dep]=$date
+    CHECKSUMS[$dep]=$checksum
+    echo
+  done
+
+  echo "Computing SHA256 for cudf..."
+  CHECKSUMS[cudf]=$(get_sha256 "cudf" "$SHA") || exit 1
+  echo "  SHA256: ${CHECKSUMS[cudf]}"
+  echo
+
+  echo "Updating $CMAKE_FILE..."
+  for dep in rapids_cmake rmm kvikio cudf; do
+    update_dependency "$dep" "${COMMITS[$dep]}" "${DATES[$dep]}" "${CHECKSUMS[$dep]}"
+  done
+
+  echo "Done! Updated dependencies:"
+  for dep in rapids_cmake rmm kvikio cudf; do
+    echo "  $dep: ${COMMITS[$dep]:0:7} (${DATES[$dep]})"
+  done
+
+elif [[ $MODE == "--branch" ]]; then
+  VERSION=$(get_version "$ARG") || exit 1
+  echo "Updating cuDF dependencies from branch $ARG (version $VERSION)"
+  echo
+
+  declare -A COMMITS DATES CHECKSUMS
+
+  for dep in rapids_cmake rmm kvikio cudf; do
+    repo=${dep//_/-}
+    echo "Fetching $repo..."
+
+    read -r commit date < <(get_commit_info "$repo" "$ARG") || exit 1
+    echo "  Commit: ${commit:0:7} from $date"
+    echo "  Computing SHA256..."
+    checksum=$(get_sha256 "$repo" "$commit") || exit 1
+    echo "  SHA256: $checksum"
+
+    COMMITS[$dep]=$commit
+    DATES[$dep]=$date
+    CHECKSUMS[$dep]=$checksum
+    echo
+  done
+
+  echo "Updating $CMAKE_FILE..."
+  for dep in rapids_cmake rmm kvikio cudf; do
+    update_dependency "$dep" "${COMMITS[$dep]}" "${DATES[$dep]}" "${CHECKSUMS[$dep]}"
+  done
+
+  echo "Done! Updated dependencies:"
+  for dep in rapids_cmake rmm kvikio cudf; do
+    echo "  $dep: ${COMMITS[$dep]:0:7} (${DATES[$dep]})"
+  done
+else
+  usage
+  exit 1
+fi
diff --git a/velox/benchmarks/CMakeLists.txt b/velox/benchmarks/CMakeLists.txt
index 48dc1fde93f..44da32311e3 100644
--- a/velox/benchmarks/CMakeLists.txt
+++ b/velox/benchmarks/CMakeLists.txt
@@ -31,12 +31,14 @@ if(${VELOX_BUILD_TEST_UTILS})
   )
 
   add_library(velox_benchmark_builder ExpressionBenchmarkBuilder.cpp)
-  target_link_libraries(velox_benchmark_builder ${velox_benchmark_deps})
+  velox_add_test_headers(velox_benchmark_builder ExpressionBenchmarkBuilder.h)
+  target_link_libraries(velox_benchmark_builder ${velox_benchmark_deps} velox_vector_test_lib)
 
   # This is a workaround for the use of VectorTestBase.h which includes gtest.h
   target_link_libraries(velox_benchmark_builder GTest::gtest)
 
   add_library(velox_query_benchmark QueryBenchmarkBase.cpp)
+  velox_add_test_headers(velox_query_benchmark QueryBenchmarkBase.h)
 
   target_link_libraries(
     velox_query_benchmark
@@ -69,5 +71,6 @@ endif()
 
 if(${VELOX_ENABLE_BENCHMARKS})
   add_subdirectory(tpch)
+  add_subdirectory(tpcds)
   add_subdirectory(filesystem)
 endif()
diff --git a/velox/benchmarks/QueryBenchmarkBase.cpp b/velox/benchmarks/QueryBenchmarkBase.cpp
index d1cd5d21dfc..2e9a16035c1 100644
--- a/velox/benchmarks/QueryBenchmarkBase.cpp
+++ b/velox/benchmarks/QueryBenchmarkBase.cpp
@@ -18,6 +18,7 @@
 #include <iostream>
 #include "velox/common/base/SuccinctPrinter.h"
 #include "velox/common/file/FileSystems.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/dwio/dwrf/RegisterDwrfReader.h"
 #include "velox/dwio/parquet/RegisterParquetReader.h"
@@ -204,25 +205,32 @@ void QueryBenchmarkBase::initialize() {
       std::make_unique<folly::IOThreadPoolExecutor>(FLAGS_num_io_threads);
 
   // Add new values into the hive configuration...
-  auto configurationValues = std::unordered_map<std::string, std::string>();
-  configurationValues[connector::hive::HiveConfig::kMaxCoalescedBytes] =
-      std::to_string(FLAGS_max_coalesced_bytes);
-  configurationValues[connector::hive::HiveConfig::kMaxCoalescedDistance] =
-      FLAGS_max_coalesced_distance_bytes;
-  configurationValues[connector::hive::HiveConfig::kPrefetchRowGroups] =
-      std::to_string(FLAGS_parquet_prefetch_rowgroups);
-  auto properties = std::make_shared<const config::ConfigBase>(
-      std::move(configurationValues));
+  auto properties = makeConnectorProperties();
 
   // Create hive connector with config...
   connector::hive::HiveConnectorFactory factory;
   auto hiveConnector =
       factory.newConnector(kHiveConnectorId, properties, ioExecutor_.get());
-  connector::registerConnector(hiveConnector);
+  connector::ConnectorRegistry::global().insert(
+      hiveConnector->connectorId(), hiveConnector);
   parquet::registerParquetReaderFactory();
   dwrf::registerDwrfReaderFactory();
 }
 
+std::shared_ptr<config::ConfigBase>
+QueryBenchmarkBase::makeConnectorProperties() {
+  // Default behaviour identical to the original hard-coded version.
+  auto configurationValues = std::unordered_map<std::string, std::string>();
+  configurationValues[connector::hive::HiveConfig::kMaxCoalescedBytes] =
+      std::to_string(FLAGS_max_coalesced_bytes);
+  configurationValues[connector::hive::HiveConfig::kMaxCoalescedDistance] =
+      FLAGS_max_coalesced_distance_bytes;
+  configurationValues[connector::hive::HiveConfig::kPrefetchRowGroups] =
+      std::to_string(FLAGS_parquet_prefetch_rowgroups);
+  return std::make_shared<config::ConfigBase>(
+      std::move(configurationValues), true);
+}
+
 std::vector<std::shared_ptr<connector::ConnectorSplit>>
 QueryBenchmarkBase::listSplits(
     const std::string& path,
@@ -244,13 +252,16 @@ void QueryBenchmarkBase::shutdown() {
 }
 
 std::pair<std::unique_ptr<TaskCursor>, std::vector<RowVectorPtr>>
-QueryBenchmarkBase::run(const TpchPlan& tpchPlan) {
+QueryBenchmarkBase::run(
+    const TpchPlan& tpchPlan,
+    const std::unordered_map<std::string, std::string>& queryConfigs) {
   int32_t repeat = 0;
   try {
     for (;;) {
       CursorParameters params;
       params.maxDrivers = FLAGS_num_drivers;
       params.planNode = tpchPlan.plan;
+      params.queryConfigs = queryConfigs;
       params.queryConfigs[core::QueryConfig::kMaxSplitPreloadPerDriver] =
           std::to_string(FLAGS_split_preload_per_driver);
       const int numSplitsPerFile = FLAGS_num_splits_per_file;
diff --git a/velox/benchmarks/QueryBenchmarkBase.h b/velox/benchmarks/QueryBenchmarkBase.h
index e450430f6da..755b67d36a9 100644
--- a/velox/benchmarks/QueryBenchmarkBase.h
+++ b/velox/benchmarks/QueryBenchmarkBase.h
@@ -55,9 +55,10 @@ class QueryBenchmarkBase {
  public:
   virtual ~QueryBenchmarkBase() = default;
   virtual void initialize();
-  void shutdown();
+  virtual void shutdown();
   std::pair<std::unique_ptr<exec::TaskCursor>, std::vector<RowVectorPtr>> run(
-      const exec::test::TpchPlan& tpchPlan);
+      const exec::test::TpchPlan& tpchPlan,
+      const std::unordered_map<std::string, std::string>& queryConfigs = {});
 
   virtual std::vector<std::shared_ptr<connector::ConnectorSplit>> listSplits(
       const std::string& path,
@@ -81,6 +82,8 @@ class QueryBenchmarkBase {
 
   void runAllCombinations();
 
+  virtual std::shared_ptr<config::ConfigBase> makeConnectorProperties();
+
  protected:
   std::unique_ptr<folly::IOThreadPoolExecutor> ioExecutor_;
   std::unique_ptr<folly::IOThreadPoolExecutor> cacheExecutor_;
diff --git a/velox/benchmarks/basic/CMakeLists.txt b/velox/benchmarks/basic/CMakeLists.txt
index 7ba8c8fee60..22614f0bd2a 100644
--- a/velox/benchmarks/basic/CMakeLists.txt
+++ b/velox/benchmarks/basic/CMakeLists.txt
@@ -107,12 +107,30 @@ target_link_libraries(
 add_executable(velox_cast_benchmark CastBenchmark.cpp)
 target_link_libraries(velox_cast_benchmark ${velox_benchmark_deps} velox_vector_test_lib)
 
+add_executable(velox_numeric_upcast_benchmark NumericUpcastBenchmark.cpp)
+target_link_libraries(velox_numeric_upcast_benchmark ${velox_benchmark_deps} velox_vector_test_lib)
+
+add_executable(velox_benchmark_expr_flat_no_nulls ExprFlatNoNullsBenchmark.cpp)
+target_link_libraries(
+  velox_benchmark_expr_flat_no_nulls
+  ${velox_benchmark_deps}
+  velox_functions_prestosql
+)
+
 add_executable(velox_format_datetime_benchmark FormatDateTimeBenchmark.cpp)
 target_link_libraries(
   velox_format_datetime_benchmark
   ${velox_benchmark_deps}
   velox_vector_test_lib
-  velox_functions_spark
   velox_functions_prestosql
   velox_row_fast
 )
+
+add_executable(velox_date_extract_benchmark DateExtractBenchmark.cpp)
+target_link_libraries(
+  velox_date_extract_benchmark
+  ${velox_benchmark_deps}
+  velox_vector_test_lib
+  velox_functions_prestosql
+  velox_functions_spark
+)
diff --git a/velox/benchmarks/basic/CastBenchmark.cpp b/velox/benchmarks/basic/CastBenchmark.cpp
index a06f75db8e4..314788df030 100644
--- a/velox/benchmarks/basic/CastBenchmark.cpp
+++ b/velox/benchmarks/basic/CastBenchmark.cpp
@@ -63,6 +63,11 @@ int main(int argc, char** argv) {
       [&](auto j) { return 123456789 * j; },
       nullptr,
       DECIMAL(18, 6));
+  auto smallDecimalInput = vectorMaker.flatVector<int64_t>(
+      vectorSize,
+      [&](auto j) { return 123456789 * j; },
+      nullptr,
+      DECIMAL(18, 17));
   auto longDecimalInput = vectorMaker.flatVector<int128_t>(
       vectorSize,
       [&](auto j) {
@@ -160,6 +165,7 @@ int main(int argc, char** argv) {
                "bigint",
                "decimal",
                "short_decimal",
+               "small_decimal",
                "long_decimal",
                "large_real",
                "small_real",
@@ -172,6 +178,7 @@ int main(int argc, char** argv) {
                bigintInput,
                decimalInput,
                shortDecimalInput,
+               smallDecimalInput,
                longDecimalInput,
                largeRealInput,
                smallRealInput,
@@ -189,6 +196,7 @@ int main(int argc, char** argv) {
       .addExpression(
           "cast_decimal_to_inline_string", "cast (decimal as varchar)")
       .addExpression("cast_short_decimal", "cast (short_decimal as varchar)")
+      .addExpression("cast_small_decimal", "cast (small_decimal as varchar)")
       .addExpression("cast_long_decimal", "cast (long_decimal as varchar)")
       .addExpression(
           "cast_large_real_to_scientific_notation",
diff --git a/velox/benchmarks/basic/DateExtractBenchmark.cpp b/velox/benchmarks/basic/DateExtractBenchmark.cpp
new file mode 100644
index 00000000000..cec32691684
--- /dev/null
+++ b/velox/benchmarks/basic/DateExtractBenchmark.cpp
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+#include "velox/benchmarks/ExpressionBenchmarkBuilder.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/functions/sparksql/registration/Register.h"
+
+using namespace facebook;
+using namespace facebook::velox;
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+  memory::MemoryManager::initialize(memory::MemoryManager::Options{});
+  functions::prestosql::registerDateTimeFunctions("");
+  functions::sparksql::registerFunctions("spark_");
+
+  ExpressionBenchmarkBuilder benchmarkBuilder;
+  VectorFuzzer::Options options;
+  options.vectorSize = 1024;
+  options.nullRatio = 0;
+  auto* pool = benchmarkBuilder.pool();
+  VectorFuzzer fuzzer(options, pool);
+  auto vectorMaker = benchmarkBuilder.vectorMaker();
+
+  // Each set runs a different extraction expression on the same fuzzed input,
+  // exercising Timestamp::epochToCalendarUtc through getDateTime in
+  // velox/functions/lib/TimeUtils.h.
+
+  // DATE inputs (int32 days since epoch).
+  benchmarkBuilder
+      .addBenchmarkSet(
+          "year_date", vectorMaker.rowVector({fuzzer.fuzz(DATE())}))
+      .addExpression("year", "year(c0)")
+      .disableTesting();
+
+  benchmarkBuilder
+      .addBenchmarkSet(
+          "month_date", vectorMaker.rowVector({fuzzer.fuzz(DATE())}))
+      .addExpression("month", "month(c0)")
+      .disableTesting();
+
+  benchmarkBuilder
+      .addBenchmarkSet("day_date", vectorMaker.rowVector({fuzzer.fuzz(DATE())}))
+      .addExpression("day", "day(c0)")
+      .disableTesting();
+
+  benchmarkBuilder
+      .addBenchmarkSet(
+          "quarter_date", vectorMaker.rowVector({fuzzer.fuzz(DATE())}))
+      .addExpression("quarter", "quarter(c0)")
+      .disableTesting();
+
+  benchmarkBuilder
+      .addBenchmarkSet(
+          "day_of_year_date", vectorMaker.rowVector({fuzzer.fuzz(DATE())}))
+      .addExpression("day_of_year", "day_of_year(c0)")
+      .disableTesting();
+
+  benchmarkBuilder
+      .addBenchmarkSet(
+          "last_day_of_month_date",
+          vectorMaker.rowVector({fuzzer.fuzz(DATE())}))
+      .addExpression("last_day_of_month", "last_day_of_month(c0)")
+      .disableTesting();
+
+  // TIMESTAMP inputs (seconds + nanos).
+  benchmarkBuilder
+      .addBenchmarkSet(
+          "year_timestamp", vectorMaker.rowVector({fuzzer.fuzz(TIMESTAMP())}))
+      .addExpression("year", "year(c0)")
+      .disableTesting();
+
+  benchmarkBuilder
+      .addBenchmarkSet(
+          "month_timestamp", vectorMaker.rowVector({fuzzer.fuzz(TIMESTAMP())}))
+      .addExpression("month", "month(c0)")
+      .disableTesting();
+
+  benchmarkBuilder
+      .addBenchmarkSet(
+          "day_timestamp", vectorMaker.rowVector({fuzzer.fuzz(TIMESTAMP())}))
+      .addExpression("day", "day(c0)")
+      .disableTesting();
+
+  // Inverse direction: (year, month, day) -> Date via Spark make_date.
+  // Three INTEGER columns of small valid year/month/day values.
+  VectorFuzzer::Options yearOpts = options;
+  yearOpts.dataSpec.includeNaN = false;
+  VectorFuzzer yearFuzzer(yearOpts, pool);
+  benchmarkBuilder
+      .addBenchmarkSet(
+          "make_date",
+          vectorMaker.rowVector(
+              {"y", "m", "d"},
+              {vectorMaker.flatVector<int32_t>(
+                   1024, [](auto i) { return 1970 + (int)(i % 80); }),
+               vectorMaker.flatVector<int32_t>(
+                   1024, [](auto i) { return 1 + (int)(i % 12); }),
+               vectorMaker.flatVector<int32_t>(
+                   1024, [](auto i) { return 1 + (int)(i % 28); })}))
+      .addExpression("make_date", "spark_make_date(y, m, d)")
+      .disableTesting();
+
+  benchmarkBuilder.registerBenchmarks();
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/benchmarks/basic/ExprFlatNoNullsBenchmark.cpp b/velox/benchmarks/basic/ExprFlatNoNullsBenchmark.cpp
new file mode 100644
index 00000000000..8694c6dd3fc
--- /dev/null
+++ b/velox/benchmarks/basic/ExprFlatNoNullsBenchmark.cpp
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/// Benchmark comparing expression evaluation with FlatNoNulls fast path
+/// enabled vs disabled via the expression.eval_flat_no_nulls config.
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include "velox/benchmarks/ExpressionBenchmarkBuilder.h"
+#include "velox/core/QueryConfig.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+
+using namespace facebook;
+using namespace facebook::velox;
+
+namespace {
+
+void addArithmeticBenchmarks(
+    ExpressionBenchmarkBuilder& builder,
+    const std::string& prefix) {
+  for (auto vectorSize : {1'024, 4'096, 40'960, 99'999}) {
+    builder
+        .addBenchmarkSet(
+            fmt::format("{}_arith_batch{}", prefix, vectorSize),
+            ROW({"a", "b", "c", "d"}, {DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE()}))
+        .withFuzzerOptions(
+            {.vectorSize = static_cast<size_t>(vectorSize), .nullRatio = 0.0})
+        // Simple arithmetic — 1 node.
+        .addExpression("add_ab", "a + b")
+        // Complex arithmetic — 7 nodes.
+        .addExpression("complex_7n", "(a + b) * c + (a - d) * b")
+        // Deep tree — 15 nodes, depth 8 (left-skewed chain).
+        .addExpression(
+            "deep_15n_d8", "((((((a + b) * c - d) + a) * b - c) + d) * a - b)")
+        .withIterations(1'000);
+  }
+}
+
+void addComparisonBenchmarks(
+    ExpressionBenchmarkBuilder& builder,
+    const std::string& prefix) {
+  for (auto vectorSize : {1'024, 4'096, 40'960, 99'999}) {
+    builder
+        .addBenchmarkSet(
+            fmt::format("{}_cmp_batch{}", prefix, vectorSize),
+            ROW({"a", "b"}, {DOUBLE(), DOUBLE()}))
+        .withFuzzerOptions(
+            {.vectorSize = static_cast<size_t>(vectorSize), .nullRatio = 0.0})
+        // Comparison — 1 node.
+        .addExpression("eq_ab", "a = b")
+        .withIterations(1'000);
+  }
+}
+
+void addConstMixedBenchmarks(
+    ExpressionBenchmarkBuilder& builder,
+    const std::string& prefix) {
+  for (auto vectorSize : {1'024, 4'096, 40'960, 99'999}) {
+    builder
+        .addBenchmarkSet(
+            fmt::format("{}_const_batch{}", prefix, vectorSize),
+            ROW({"a", "b"}, {DOUBLE(), DOUBLE()}))
+        .withFuzzerOptions(
+            {.vectorSize = static_cast<size_t>(vectorSize), .nullRatio = 0.0})
+        // 1 constant.
+        .addExpression("const_1", "a + 1.5")
+        // 2 constants.
+        .addExpression("const_2", "(a + 1.5) * 2.0")
+        // 3 constants mixed with columns — 7 nodes.
+        .addExpression("const_3_7n", "(a + 1.5) * 2.0 + (a - 3.0) * b")
+        .withIterations(1'000);
+  }
+}
+
+/// Extends ExpressionBenchmarkBuilder to allow setting query config.
+class ConfigurableBenchmarkBuilder : public ExpressionBenchmarkBuilder {
+ public:
+  void setConfig(const std::string& key, const std::string& value) {
+    queryCtx_->testingOverrideConfigUnsafe({{key, value}});
+  }
+};
+
+} // namespace
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+  memory::MemoryManager::initialize(memory::MemoryManager::Options{});
+  functions::prestosql::registerAllScalarFunctions();
+
+  // Fast path ON (default).
+  ConfigurableBenchmarkBuilder fastPathOn;
+  addArithmeticBenchmarks(fastPathOn, "on");
+  addComparisonBenchmarks(fastPathOn, "on");
+  addConstMixedBenchmarks(fastPathOn, "on");
+
+  // Fast path OFF via config.
+  ConfigurableBenchmarkBuilder fastPathOff;
+  fastPathOff.setConfig(core::QueryConfig::kExprEvalFlatNoNulls, "false");
+  addArithmeticBenchmarks(fastPathOff, "off");
+  addComparisonBenchmarks(fastPathOff, "off");
+  addConstMixedBenchmarks(fastPathOff, "off");
+
+  fastPathOn.registerBenchmarks();
+  fastPathOff.registerBenchmarks();
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/benchmarks/basic/LikeTpchBenchmark.cpp b/velox/benchmarks/basic/LikeTpchBenchmark.cpp
index 1f4dab648f9..d904ae5118b 100644
--- a/velox/benchmarks/basic/LikeTpchBenchmark.cpp
+++ b/velox/benchmarks/basic/LikeTpchBenchmark.cpp
@@ -127,8 +127,9 @@ class LikeFunctionsBenchmark : public FunctionBaseTest,
         return tpchSupplier->childAt(6);
       }
       default:
-        VELOX_FAIL(fmt::format(
-            "Tpch data generation for case {} is not supported", tpchCase));
+        VELOX_FAIL(
+            fmt::format(
+                "Tpch data generation for case {} is not supported", tpchCase));
     }
   }
 
diff --git a/velox/benchmarks/basic/NumericUpcastBenchmark.cpp b/velox/benchmarks/basic/NumericUpcastBenchmark.cpp
new file mode 100644
index 00000000000..931828846a6
--- /dev/null
+++ b/velox/benchmarks/basic/NumericUpcastBenchmark.cpp
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include "velox/benchmarks/ExpressionBenchmarkBuilder.h"
+
+using namespace facebook;
+using namespace facebook::velox;
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+  memory::MemoryManager::initialize(memory::MemoryManager::Options{});
+
+  ExpressionBenchmarkBuilder benchmarkBuilder;
+  const vector_size_t vectorSize = 300'000'000;
+  auto vectorMaker = benchmarkBuilder.vectorMaker();
+
+  auto tinyIntInputNullable = vectorMaker.flatVector<int8_t>(
+      vectorSize,
+      [](auto j) { return j % std::numeric_limits<int8_t>::max(); },
+      [](auto j) { return j % 5 == 0; });
+  auto tinyIntInput = vectorMaker.flatVector<int8_t>(
+      vectorSize,
+      [](auto j) { return j % std::numeric_limits<int8_t>::max(); },
+      nullptr);
+
+  auto smallIntInputNullable = vectorMaker.flatVector<int16_t>(
+      vectorSize,
+      [](auto j) { return j % std::numeric_limits<int16_t>::max(); },
+      [](auto j) { return j % 5 == 0; });
+  auto smallIntInput = vectorMaker.flatVector<int16_t>(
+      vectorSize,
+      [](auto j) { return j % std::numeric_limits<int16_t>::max(); },
+      nullptr);
+
+  auto integerInputNullable = vectorMaker.flatVector<int32_t>(
+      vectorSize,
+      [](auto j) { return j * 2 + 1; },
+      [](auto j) { return j % 5 == 0; });
+  auto integerInput = vectorMaker.flatVector<int32_t>(
+      vectorSize, [](auto j) { return j * 2 + 1; }, nullptr);
+
+  auto bigintInputNullable = vectorMaker.flatVector<int64_t>(
+      vectorSize,
+      [](auto j) { return j * 2 + 1; },
+      [](auto j) { return j % 5 == 0; });
+  auto bigintInput = vectorMaker.flatVector<int64_t>(
+      vectorSize, [](auto j) { return j * 2 + 1; }, nullptr);
+
+  auto realInputNullable = vectorMaker.flatVector<float>(
+      vectorSize,
+      [](auto j) { return j * 9.9999; },
+      [](auto j) { return j % 5 == 0; });
+  auto realInput = vectorMaker.flatVector<float>(
+      vectorSize, [](auto j) { return j * 9.9999; }, nullptr);
+
+  benchmarkBuilder
+      .addBenchmarkSet(
+          "numeric_upcast",
+          vectorMaker.rowVector(
+              {
+                  "tinyint_column_nullable",
+                  "tinyint_column",
+                  "smallint_column_nullable",
+                  "smallint_column",
+                  "integer_column_nullable",
+                  "integer_column",
+                  "bigint_column_nullable",
+                  "bigint_column",
+                  "real_column_nullable",
+                  "real_column",
+              },
+              {
+                  tinyIntInputNullable,
+                  tinyIntInput,
+                  smallIntInputNullable,
+                  smallIntInput,
+                  integerInputNullable,
+                  integerInput,
+                  bigintInputNullable,
+                  bigintInput,
+                  realInputNullable,
+                  realInput,
+              }))
+      // Cast from tinyint.
+      .addExpression(
+          "cast_tinyint_nullable_as_smallint",
+          "cast(tinyint_column_nullable as smallint)")
+      .addExpression(
+          "cast_tinyint_as_smallint", "cast(tinyint_column as smallint)")
+
+      .addExpression(
+          "cast_tinyint_nullable_as_integer",
+          "cast(tinyint_column_nullable as integer)")
+      .addExpression(
+          "cast_tinyint_as_integer", "cast(tinyint_column as integer)")
+
+      .addExpression(
+          "cast_tinyint_nullable_as_bigint",
+          "cast(tinyint_column_nullable as bigint)")
+      .addExpression("cast_tinyint_as_bigint", "cast(tinyint_column as bigint)")
+
+      .addExpression(
+          "cast_tinyint_nullable_as_real",
+          "cast(tinyint_column_nullable as real)")
+      .addExpression("cast_tinyint_as_real", "cast(tinyint_column as real)")
+
+      .addExpression(
+          "cast_tinyint_nullable_as_double",
+          "cast(tinyint_column_nullable as double)")
+      .addExpression("cast_tinyint_as_double", "cast(tinyint_column as double)")
+
+      // Cast from smallint.
+      .addExpression(
+          "cast_smallint_nullable_as_integer",
+          "cast(smallint_column_nullable as integer)")
+      .addExpression(
+          "cast_smallint_as_integer", "cast(smallint_column as integer)")
+
+      .addExpression(
+          "cast_smallint_nullable_as_bigint",
+          "cast(smallint_column_nullable as bigint)")
+      .addExpression(
+          "cast_smallint_as_bigint", "cast(smallint_column as bigint)")
+
+      .addExpression(
+          "cast_smallint_nullable_as_real",
+          "cast(smallint_column_nullable as real)")
+      .addExpression("cast_smallint_as_real", "cast(smallint_column as real)")
+
+      .addExpression(
+          "cast_smallint_nullable_as_double",
+          "cast(smallint_column_nullable as double)")
+      .addExpression(
+          "cast_smallint_as_double", "cast(smallint_column as double)")
+
+      // Cast from integer.
+      .addExpression(
+          "cast_integer_nullable_as_bigint",
+          "cast(integer_column_nullable as bigint)")
+      .addExpression("cast_integer_as_bigint", "cast(integer_column as bigint)")
+
+      .addExpression(
+          "cast_integer_nullable_as_real",
+          "cast(integer_column_nullable as real)")
+      .addExpression("cast_integer_as_real", "cast(integer_column as real)")
+
+      .addExpression(
+          "cast_integer_nullable_as_double",
+          "cast(integer_column_nullable as double)")
+      .addExpression("cast_integer_as_double", "cast(integer_column as double)")
+
+      // Cast from bigint.
+      .addExpression(
+          "cast_bigint_nullable_as_real",
+          "cast(bigint_column_nullable as real)")
+      .addExpression("cast_bigint_as_real", "cast(bigint_column as real)")
+
+      .addExpression(
+          "cast_bigint_nullable_as_double",
+          "cast(bigint_column_nullable as double)")
+      .addExpression("cast_bigint_as_double", "cast(bigint_column as double)")
+
+      // Cast from real.
+      .addExpression(
+          "cast_real_nullable_as_double",
+          "cast(real_column_nullable as double)")
+      .addExpression("cast_real_as_double", "cast(real_column as double)")
+      .withIterations(100)
+      .disableTesting();
+
+  benchmarkBuilder.registerBenchmarks();
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/benchmarks/basic/Preproc.cpp b/velox/benchmarks/basic/Preproc.cpp
index f3fbca54b4f..e7fdc72e320 100644
--- a/velox/benchmarks/basic/Preproc.cpp
+++ b/velox/benchmarks/basic/Preproc.cpp
@@ -186,11 +186,12 @@ std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
   std::vector<std::shared_ptr<exec::FunctionSignature>> signatures;
   for (auto type :
        {"tinyint", "smallint", "integer", "bigint", "real", "double"}) {
-    signatures.push_back(exec::FunctionSignatureBuilder()
-                             .returnType(type)
-                             .argumentType(type)
-                             .argumentType(type)
-                             .build());
+    signatures.push_back(
+        exec::FunctionSignatureBuilder()
+            .returnType(type)
+            .argumentType(type)
+            .argumentType(type)
+            .build());
   }
   return signatures;
 }
@@ -258,15 +259,7 @@ class PreprocBenchmark : public functions::test::FunctionBenchmarkBase {
   }
 
   exec::ExprSet compile(const std::vector<std::string>& texts) {
-    std::vector<core::TypedExprPtr> typedExprs;
-    parse::ParseOptions options;
-    for (const auto& text : texts) {
-      auto untyped = parse::parseExpr(text, options);
-      auto typed = core::Expressions::inferTypes(
-          untyped, ROW({"c0"}, {REAL()}), execCtx_.pool());
-      typedExprs.push_back(typed);
-    }
-    return exec::ExprSet(typedExprs, &execCtx_);
+    return compileExpressions(texts, ROW({{"c0", REAL()}}));
   }
 
   std::string makeExpression(int n, RunConfig config, bool withNulls) {
diff --git a/velox/benchmarks/basic/VectorSlice.cpp b/velox/benchmarks/basic/VectorSlice.cpp
index 44ad91f8200..54b706265e7 100644
--- a/velox/benchmarks/basic/VectorSlice.cpp
+++ b/velox/benchmarks/basic/VectorSlice.cpp
@@ -37,9 +37,10 @@ constexpr int kVectorSize = 16 << 10;
 
 struct BenchmarkData {
   BenchmarkData()
-      : pool_(memory::memoryManager()->addLeafPool(
-            "BenchmarkData",
-            FLAGS_use_thread_safe_memory_usage_track)) {
+      : pool_(
+            memory::memoryManager()->addLeafPool(
+                "BenchmarkData",
+                FLAGS_use_thread_safe_memory_usage_track)) {
     VectorFuzzer::Options opts;
     opts.nullRatio = 0.01;
     opts.vectorSize = kVectorSize;
diff --git a/velox/benchmarks/filesystem/CMakeLists.txt b/velox/benchmarks/filesystem/CMakeLists.txt
index 5f5b411b94a..9b272573ba3 100644
--- a/velox/benchmarks/filesystem/CMakeLists.txt
+++ b/velox/benchmarks/filesystem/CMakeLists.txt
@@ -13,6 +13,7 @@
 # limitations under the License.
 
 add_library(velox_read_benchmark_lib ReadBenchmark.cpp)
+velox_add_test_headers(velox_read_benchmark_lib ReadBenchmark.h)
 
 target_link_libraries(
   velox_read_benchmark_lib
diff --git a/velox/benchmarks/filesystem/ReadBenchmark.h b/velox/benchmarks/filesystem/ReadBenchmark.h
index e033bc953ac..69b26082d64 100644
--- a/velox/benchmarks/filesystem/ReadBenchmark.h
+++ b/velox/benchmarks/filesystem/ReadBenchmark.h
@@ -180,8 +180,9 @@ class ReadBenchmark {
             } else {
               std::vector<folly::Range<char*>> ranges;
               for (auto start = 0; start < rangeSize; start += size + gap) {
-                ranges.push_back(folly::Range<char*>(
-                    globalScratch.buffer.data() + start, size));
+                ranges.push_back(
+                    folly::Range<char*>(
+                        globalScratch.buffer.data() + start, size));
                 if (gap && start + gap < rangeSize) {
                   ranges.push_back(folly::Range<char*>(nullptr, gap));
                 }
diff --git a/velox/benchmarks/tpcds/CMakeLists.txt b/velox/benchmarks/tpcds/CMakeLists.txt
new file mode 100644
index 00000000000..15a216eca8b
--- /dev/null
+++ b/velox/benchmarks/tpcds/CMakeLists.txt
@@ -0,0 +1,44 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_library(velox_tpcds_benchmark_lib TpcdsBenchmark.cpp)
+velox_add_test_headers(velox_tpcds_benchmark_lib TpcdsBenchmark.h)
+
+target_link_libraries(
+  velox_tpcds_benchmark_lib
+  velox_query_benchmark
+  velox_aggregates
+  velox_window
+  velox_exec
+  velox_exec_test_lib
+  velox_dwio_common
+  velox_dwio_parquet_reader
+  velox_dwio_common_test_utils
+  velox_hive_connector
+  velox_exception
+  velox_memory
+  velox_process
+  velox_serialization
+  velox_encode
+  velox_type
+  velox_caching
+  velox_vector_test_lib
+  Folly::follybenchmark
+  Folly::folly
+  fmt::fmt
+)
+
+add_executable(velox_tpcds_benchmark TpcdsBenchmarkMain.cpp)
+
+target_link_libraries(velox_tpcds_benchmark velox_tpcds_benchmark_lib)
diff --git a/velox/benchmarks/tpcds/TpcdsBenchmark.cpp b/velox/benchmarks/tpcds/TpcdsBenchmark.cpp
new file mode 100644
index 00000000000..c07b3d7342c
--- /dev/null
+++ b/velox/benchmarks/tpcds/TpcdsBenchmark.cpp
@@ -0,0 +1,523 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/benchmarks/tpcds/TpcdsBenchmark.h"
+
+#include "velox/connectors/ConnectorRegistry.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/exec/PartitionFunction.h"
+#include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/TpchQueryBuilder.h"
+#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/functions/prestosql/window/WindowFunctionsRegistration.h"
+#include "velox/parse/TypeResolver.h"
+
+#include <iostream>
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::dwio::common;
+
+DEFINE_string(
+    data_path,
+    "",
+    "Root path of TPC-DS data. Data layout must follow Hive-style partitioning. "
+    "Example layout for '--data_path=/data/tpcds_sf100'\n"
+    "       /data/tpcds_sf100/store_sales\n"
+    "       /data/tpcds_sf100/customer\n"
+    "       /data/tpcds_sf100/date_dim\n"
+    "       /data/tpcds_sf100/store\n"
+    "       ...\n"
+    "Each directory contains data files (e.g. parquet) for the table.");
+
+namespace {
+static bool notEmpty(const char* /*flagName*/, const std::string& value) {
+  return !value.empty();
+}
+} // namespace
+
+DEFINE_validator(data_path, &notEmpty);
+
+DEFINE_string(
+    plan_path,
+    "",
+    "Directory containing Velox plan JSON files (Q1.json, Q2.json, ...). "
+    "These are typically dumped from a Presto worker's plan-dump-dir.");
+
+DEFINE_validator(plan_path, &notEmpty);
+
+DEFINE_int32(
+    run_query_verbose,
+    -1,
+    "Run a given query and print execution statistics");
+
+void TpcdsBenchmark::initQueryBuilder() {
+  queryBuilder_ =
+      std::make_unique<TpcdsQueryBuilder>(toFileFormat(FLAGS_data_format));
+  queryBuilder_->initialize(FLAGS_data_path);
+}
+
+void TpcdsBenchmark::initialize() {
+  QueryBenchmarkBase::initialize();
+
+  const std::string prestoPrefix{kPrestoFunctionNamespacePrefix};
+  functions::prestosql::registerAllScalarFunctions(prestoPrefix);
+  aggregate::prestosql::registerAllAggregateFunctions(prestoPrefix);
+  window::prestosql::registerAllWindowFunctions(prestoPrefix);
+
+  // Register serialization/deserialization for plan nodes.
+  Type::registerSerDe();
+  common::Filter::registerSerDe();
+  connector::hive::HiveConnector::registerSerDe();
+  core::PlanNode::registerSerDe();
+  core::ITypedExpr::registerSerDe();
+  exec::registerPartitionFunctionSerDe();
+
+  // Presto-dumped plans use connector ID "hive", while the base class
+  // registers under kHiveConnectorId ("test-hive"). Register a properly
+  // configured connector under "hive" so both the plan and splits match.
+  const std::string prestoConnectorId{kPrestoHiveConnectorId};
+  if (connector::ConnectorRegistry::tryGet(prestoConnectorId) == nullptr) {
+    auto properties = makeConnectorProperties();
+    connector::hive::HiveConnectorFactory factory;
+    auto hiveConnector =
+        factory.newConnector(prestoConnectorId, properties, ioExecutor_.get());
+    connector::ConnectorRegistry::global().insert(
+        hiveConnector->connectorId(), hiveConnector);
+  }
+
+  planDir_ = FLAGS_plan_path;
+  pool_ = memory::memoryManager()->addLeafPool("TpcdsBenchmark");
+
+  initQueryBuilder();
+}
+
+void TpcdsBenchmark::shutdown() {
+  if (queryBuilder_) {
+    queryBuilder_->shutdown();
+    queryBuilder_.reset();
+  }
+  const std::string prestoConnectorId{kPrestoHiveConnectorId};
+  if (connector::ConnectorRegistry::tryGet(prestoConnectorId) != nullptr) {
+    connector::ConnectorRegistry::global().erase(prestoConnectorId);
+  }
+  pool_.reset();
+  QueryBenchmarkBase::shutdown();
+}
+
+std::vector<std::shared_ptr<connector::ConnectorSplit>>
+TpcdsBenchmark::listSplits(
+    const std::string& path,
+    int32_t numSplitsPerFile,
+    const exec::test::TpchPlan& plan) {
+  // The base class creates splits with the default (empty) connector ID,
+  // which doesn't match the plan's connector ID (e.g. "hive" from Presto).
+  // Re-create splits with the correct connector ID from the query builder.
+  auto baseSplits =
+      QueryBenchmarkBase::listSplits(path, numSplitsPerFile, plan);
+
+  const auto& cid =
+      queryBuilder_ ? queryBuilder_->connectorId() : std::string();
+  if (cid.empty()) {
+    return baseSplits;
+  }
+
+  // Rebuild each split with the plan's connector ID.
+  std::vector<std::shared_ptr<connector::ConnectorSplit>> result;
+  result.reserve(baseSplits.size());
+  for (const auto& baseSplit : baseSplits) {
+    auto hiveSplit =
+        std::dynamic_pointer_cast<connector::hive::HiveConnectorSplit>(
+            baseSplit);
+    if (hiveSplit) {
+      result.push_back(
+          connector::hive::HiveConnectorSplitBuilder(hiveSplit->filePath)
+              .connectorId(cid)
+              .fileFormat(hiveSplit->fileFormat)
+              .start(hiveSplit->start)
+              .length(hiveSplit->length)
+              .build());
+    } else {
+      result.push_back(baseSplit);
+    }
+  }
+  return result;
+}
+
+void TpcdsBenchmark::runQuery(int32_t queryId) {
+  auto plan = queryBuilder_->getQueryPlan(queryId, planDir_, pool_.get());
+  run(plan, queryConfigs_);
+}
+
+void TpcdsBenchmark::runMain(
+    std::ostream& out,
+    facebook::velox::RunStats& runStats) {
+  if (FLAGS_run_query_verbose == -1) {
+    folly::runBenchmarks();
+  } else {
+    auto plan = queryBuilder_->getQueryPlan(
+        FLAGS_run_query_verbose, planDir_, pool_.get());
+
+    auto [cursor, actualResults] = run(plan, queryConfigs_);
+    VELOX_CHECK(cursor, "Query terminated with error. Exiting");
+    auto task = cursor->task();
+    ensureTaskCompletion(task.get());
+    if (FLAGS_include_results) {
+      printResults(actualResults, out);
+      out << std::endl;
+    }
+    const auto stats = task->taskStats();
+    int64_t rawInputBytes = 0;
+    for (auto& pipeline : stats.pipelineStats) {
+      auto& first = pipeline.operatorStats[0];
+      if (first.operatorType == "TableScan") {
+        rawInputBytes += first.rawInputBytes;
+      }
+    }
+    runStats.rawInputBytes = rawInputBytes;
+    out << fmt::format(
+               "Execution time: {}",
+               facebook::velox::succinctMillis(
+                   stats.executionEndTimeMs - stats.executionStartTimeMs))
+        << std::endl;
+    out << fmt::format(
+               "Splits total: {}, finished: {}",
+               stats.numTotalSplits,
+               stats.numFinishedSplits)
+        << std::endl;
+    out << printPlanWithStats(*plan.plan, stats, FLAGS_include_custom_stats)
+        << std::endl;
+  }
+}
+
+std::unique_ptr<TpcdsBenchmark> tpcdsBenchmark;
+
+// TPC-DS has 99 queries. Define BENCHMARK macros for each.
+// Only a subset may have plan JSONs available; missing plans will cause
+// a runtime error for that specific query.
+BENCHMARK(tpcds_q1) {
+  tpcdsBenchmark->runQuery(1);
+}
+BENCHMARK(tpcds_q2) {
+  tpcdsBenchmark->runQuery(2);
+}
+BENCHMARK(tpcds_q3) {
+  tpcdsBenchmark->runQuery(3);
+}
+BENCHMARK(tpcds_q4) {
+  tpcdsBenchmark->runQuery(4);
+}
+BENCHMARK(tpcds_q5) {
+  tpcdsBenchmark->runQuery(5);
+}
+BENCHMARK(tpcds_q6) {
+  tpcdsBenchmark->runQuery(6);
+}
+BENCHMARK(tpcds_q7) {
+  tpcdsBenchmark->runQuery(7);
+}
+BENCHMARK(tpcds_q8) {
+  tpcdsBenchmark->runQuery(8);
+}
+BENCHMARK(tpcds_q9) {
+  tpcdsBenchmark->runQuery(9);
+}
+BENCHMARK(tpcds_q10) {
+  tpcdsBenchmark->runQuery(10);
+}
+BENCHMARK(tpcds_q11) {
+  tpcdsBenchmark->runQuery(11);
+}
+BENCHMARK(tpcds_q12) {
+  tpcdsBenchmark->runQuery(12);
+}
+BENCHMARK(tpcds_q13) {
+  tpcdsBenchmark->runQuery(13);
+}
+BENCHMARK(tpcds_q14) {
+  tpcdsBenchmark->runQuery(14);
+}
+BENCHMARK(tpcds_q15) {
+  tpcdsBenchmark->runQuery(15);
+}
+BENCHMARK(tpcds_q16) {
+  tpcdsBenchmark->runQuery(16);
+}
+BENCHMARK(tpcds_q17) {
+  tpcdsBenchmark->runQuery(17);
+}
+BENCHMARK(tpcds_q18) {
+  tpcdsBenchmark->runQuery(18);
+}
+BENCHMARK(tpcds_q19) {
+  tpcdsBenchmark->runQuery(19);
+}
+BENCHMARK(tpcds_q20) {
+  tpcdsBenchmark->runQuery(20);
+}
+BENCHMARK(tpcds_q21) {
+  tpcdsBenchmark->runQuery(21);
+}
+BENCHMARK(tpcds_q22) {
+  tpcdsBenchmark->runQuery(22);
+}
+BENCHMARK(tpcds_q23) {
+  tpcdsBenchmark->runQuery(23);
+}
+BENCHMARK(tpcds_q24) {
+  tpcdsBenchmark->runQuery(24);
+}
+BENCHMARK(tpcds_q25) {
+  tpcdsBenchmark->runQuery(25);
+}
+BENCHMARK(tpcds_q26) {
+  tpcdsBenchmark->runQuery(26);
+}
+BENCHMARK(tpcds_q27) {
+  tpcdsBenchmark->runQuery(27);
+}
+BENCHMARK(tpcds_q28) {
+  tpcdsBenchmark->runQuery(28);
+}
+BENCHMARK(tpcds_q29) {
+  tpcdsBenchmark->runQuery(29);
+}
+BENCHMARK(tpcds_q30) {
+  tpcdsBenchmark->runQuery(30);
+}
+BENCHMARK(tpcds_q31) {
+  tpcdsBenchmark->runQuery(31);
+}
+BENCHMARK(tpcds_q32) {
+  tpcdsBenchmark->runQuery(32);
+}
+BENCHMARK(tpcds_q33) {
+  tpcdsBenchmark->runQuery(33);
+}
+BENCHMARK(tpcds_q34) {
+  tpcdsBenchmark->runQuery(34);
+}
+BENCHMARK(tpcds_q35) {
+  tpcdsBenchmark->runQuery(35);
+}
+BENCHMARK(tpcds_q36) {
+  tpcdsBenchmark->runQuery(36);
+}
+BENCHMARK(tpcds_q37) {
+  tpcdsBenchmark->runQuery(37);
+}
+BENCHMARK(tpcds_q38) {
+  tpcdsBenchmark->runQuery(38);
+}
+BENCHMARK(tpcds_q39) {
+  tpcdsBenchmark->runQuery(39);
+}
+BENCHMARK(tpcds_q40) {
+  tpcdsBenchmark->runQuery(40);
+}
+BENCHMARK(tpcds_q41) {
+  tpcdsBenchmark->runQuery(41);
+}
+BENCHMARK(tpcds_q42) {
+  tpcdsBenchmark->runQuery(42);
+}
+BENCHMARK(tpcds_q43) {
+  tpcdsBenchmark->runQuery(43);
+}
+BENCHMARK(tpcds_q44) {
+  tpcdsBenchmark->runQuery(44);
+}
+BENCHMARK(tpcds_q45) {
+  tpcdsBenchmark->runQuery(45);
+}
+BENCHMARK(tpcds_q46) {
+  tpcdsBenchmark->runQuery(46);
+}
+BENCHMARK(tpcds_q47) {
+  tpcdsBenchmark->runQuery(47);
+}
+BENCHMARK(tpcds_q48) {
+  tpcdsBenchmark->runQuery(48);
+}
+BENCHMARK(tpcds_q49) {
+  tpcdsBenchmark->runQuery(49);
+}
+BENCHMARK(tpcds_q50) {
+  tpcdsBenchmark->runQuery(50);
+}
+BENCHMARK(tpcds_q51) {
+  tpcdsBenchmark->runQuery(51);
+}
+BENCHMARK(tpcds_q52) {
+  tpcdsBenchmark->runQuery(52);
+}
+BENCHMARK(tpcds_q53) {
+  tpcdsBenchmark->runQuery(53);
+}
+BENCHMARK(tpcds_q54) {
+  tpcdsBenchmark->runQuery(54);
+}
+BENCHMARK(tpcds_q55) {
+  tpcdsBenchmark->runQuery(55);
+}
+BENCHMARK(tpcds_q56) {
+  tpcdsBenchmark->runQuery(56);
+}
+BENCHMARK(tpcds_q57) {
+  tpcdsBenchmark->runQuery(57);
+}
+BENCHMARK(tpcds_q58) {
+  tpcdsBenchmark->runQuery(58);
+}
+BENCHMARK(tpcds_q59) {
+  tpcdsBenchmark->runQuery(59);
+}
+BENCHMARK(tpcds_q60) {
+  tpcdsBenchmark->runQuery(60);
+}
+BENCHMARK(tpcds_q61) {
+  tpcdsBenchmark->runQuery(61);
+}
+BENCHMARK(tpcds_q62) {
+  tpcdsBenchmark->runQuery(62);
+}
+BENCHMARK(tpcds_q63) {
+  tpcdsBenchmark->runQuery(63);
+}
+BENCHMARK(tpcds_q64) {
+  tpcdsBenchmark->runQuery(64);
+}
+BENCHMARK(tpcds_q65) {
+  tpcdsBenchmark->runQuery(65);
+}
+BENCHMARK(tpcds_q66) {
+  tpcdsBenchmark->runQuery(66);
+}
+BENCHMARK(tpcds_q67) {
+  tpcdsBenchmark->runQuery(67);
+}
+BENCHMARK(tpcds_q68) {
+  tpcdsBenchmark->runQuery(68);
+}
+BENCHMARK(tpcds_q69) {
+  tpcdsBenchmark->runQuery(69);
+}
+BENCHMARK(tpcds_q70) {
+  tpcdsBenchmark->runQuery(70);
+}
+BENCHMARK(tpcds_q71) {
+  tpcdsBenchmark->runQuery(71);
+}
+BENCHMARK(tpcds_q72) {
+  tpcdsBenchmark->runQuery(72);
+}
+BENCHMARK(tpcds_q73) {
+  tpcdsBenchmark->runQuery(73);
+}
+BENCHMARK(tpcds_q74) {
+  tpcdsBenchmark->runQuery(74);
+}
+BENCHMARK(tpcds_q75) {
+  tpcdsBenchmark->runQuery(75);
+}
+BENCHMARK(tpcds_q76) {
+  tpcdsBenchmark->runQuery(76);
+}
+BENCHMARK(tpcds_q77) {
+  tpcdsBenchmark->runQuery(77);
+}
+BENCHMARK(tpcds_q78) {
+  tpcdsBenchmark->runQuery(78);
+}
+BENCHMARK(tpcds_q79) {
+  tpcdsBenchmark->runQuery(79);
+}
+BENCHMARK(tpcds_q80) {
+  tpcdsBenchmark->runQuery(80);
+}
+BENCHMARK(tpcds_q81) {
+  tpcdsBenchmark->runQuery(81);
+}
+BENCHMARK(tpcds_q82) {
+  tpcdsBenchmark->runQuery(82);
+}
+BENCHMARK(tpcds_q83) {
+  tpcdsBenchmark->runQuery(83);
+}
+BENCHMARK(tpcds_q84) {
+  tpcdsBenchmark->runQuery(84);
+}
+BENCHMARK(tpcds_q85) {
+  tpcdsBenchmark->runQuery(85);
+}
+BENCHMARK(tpcds_q86) {
+  tpcdsBenchmark->runQuery(86);
+}
+BENCHMARK(tpcds_q87) {
+  tpcdsBenchmark->runQuery(87);
+}
+BENCHMARK(tpcds_q88) {
+  tpcdsBenchmark->runQuery(88);
+}
+BENCHMARK(tpcds_q89) {
+  tpcdsBenchmark->runQuery(89);
+}
+BENCHMARK(tpcds_q90) {
+  tpcdsBenchmark->runQuery(90);
+}
+BENCHMARK(tpcds_q91) {
+  tpcdsBenchmark->runQuery(91);
+}
+BENCHMARK(tpcds_q92) {
+  tpcdsBenchmark->runQuery(92);
+}
+BENCHMARK(tpcds_q93) {
+  tpcdsBenchmark->runQuery(93);
+}
+BENCHMARK(tpcds_q94) {
+  tpcdsBenchmark->runQuery(94);
+}
+BENCHMARK(tpcds_q95) {
+  tpcdsBenchmark->runQuery(95);
+}
+BENCHMARK(tpcds_q96) {
+  tpcdsBenchmark->runQuery(96);
+}
+BENCHMARK(tpcds_q97) {
+  tpcdsBenchmark->runQuery(97);
+}
+BENCHMARK(tpcds_q98) {
+  tpcdsBenchmark->runQuery(98);
+}
+BENCHMARK(tpcds_q99) {
+  tpcdsBenchmark->runQuery(99);
+}
+
+void tpcdsBenchmarkMain() {
+  VELOX_CHECK_NOT_NULL(tpcdsBenchmark);
+  tpcdsBenchmark->initialize();
+  if (FLAGS_test_flags_file.empty()) {
+    RunStats ignore;
+    tpcdsBenchmark->runMain(std::cout, ignore);
+  } else {
+    tpcdsBenchmark->runAllCombinations();
+  }
+  tpcdsBenchmark->shutdown();
+}
diff --git a/velox/benchmarks/tpcds/TpcdsBenchmark.h b/velox/benchmarks/tpcds/TpcdsBenchmark.h
new file mode 100644
index 00000000000..dc7809e851f
--- /dev/null
+++ b/velox/benchmarks/tpcds/TpcdsBenchmark.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <string>
+#include <string_view>
+
+#include "velox/benchmarks/QueryBenchmarkBase.h"
+#include "velox/exec/tests/utils/TpcdsQueryBuilder.h"
+
+DECLARE_string(plan_path);
+
+inline constexpr std::string_view kPrestoHiveConnectorId = "hive";
+
+inline constexpr std::string_view kPrestoFunctionNamespacePrefix =
+    "presto.default.";
+
+class TpcdsBenchmark : public facebook::velox::QueryBenchmarkBase {
+ public:
+  void initialize() override;
+
+  void shutdown() override;
+
+  void runMain(std::ostream& out, facebook::velox::RunStats& runStats) override;
+
+  void runQuery(int32_t queryId);
+
+  /// Override to stamp splits with the plan's connector ID (e.g. "hive")
+  /// instead of the default "test-hive" used by the base class.
+  std::vector<std::shared_ptr<facebook::velox::connector::ConnectorSplit>>
+  listSplits(
+      const std::string& path,
+      int32_t numSplitsPerFile,
+      const facebook::velox::exec::test::TpchPlan& plan) override;
+
+ protected:
+  /// Override to create a different query builder (e.g. CudfTpcdsQueryBuilder).
+  virtual void initQueryBuilder();
+
+  std::unique_ptr<facebook::velox::exec::test::TpcdsQueryBuilder> queryBuilder_;
+  std::unordered_map<std::string, std::string> queryConfigs_;
+  std::string planDir_;
+  std::shared_ptr<facebook::velox::memory::MemoryPool> pool_;
+};
+
+extern std::unique_ptr<TpcdsBenchmark> tpcdsBenchmark;
+
+void tpcdsBenchmarkMain();
diff --git a/velox/benchmarks/tpcds/TpcdsBenchmarkMain.cpp b/velox/benchmarks/tpcds/TpcdsBenchmarkMain.cpp
new file mode 100644
index 00000000000..49eecd8baeb
--- /dev/null
+++ b/velox/benchmarks/tpcds/TpcdsBenchmarkMain.cpp
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/init/Init.h>
+#include <gflags/gflags.h>
+
+#include "velox/benchmarks/tpcds/TpcdsBenchmark.h"
+
+int main(int argc, char** argv) {
+  std::string kUsage(
+      "This program benchmarks TPC-DS queries. Run "
+      "'velox_tpcds_benchmark -helpon=TpcdsBenchmark' for available options.\n");
+  gflags::SetUsageMessage(kUsage);
+  folly::Init init{&argc, &argv, false};
+  tpcdsBenchmark = std::make_unique<TpcdsBenchmark>();
+  tpcdsBenchmarkMain();
+}
diff --git a/velox/benchmarks/tpch/CMakeLists.txt b/velox/benchmarks/tpch/CMakeLists.txt
index 1dbe29ea7d2..326fe814d40 100644
--- a/velox/benchmarks/tpch/CMakeLists.txt
+++ b/velox/benchmarks/tpch/CMakeLists.txt
@@ -13,6 +13,7 @@
 # limitations under the License.
 
 add_library(velox_tpch_benchmark_lib TpchBenchmark.cpp)
+velox_add_test_headers(velox_tpch_benchmark_lib TpchBenchmark.h)
 
 target_link_libraries(
   velox_tpch_benchmark_lib
diff --git a/velox/benchmarks/tpch/TpchBenchmark.cpp b/velox/benchmarks/tpch/TpchBenchmark.cpp
index 1f149f068ec..96935d9b7c6 100644
--- a/velox/benchmarks/tpch/TpchBenchmark.cpp
+++ b/velox/benchmarks/tpch/TpchBenchmark.cpp
@@ -14,8 +14,9 @@
  * limitations under the License.
  */
 
+#include "velox/benchmarks/tpch/TpchBenchmark.h"
 #include <iostream>
-#include "velox/benchmarks/QueryBenchmarkBase.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/PlanNodeStats.h"
 
 using namespace facebook::velox;
@@ -59,178 +60,165 @@ DEFINE_int32(
     "include in IO meter query. The columns are sorted by name and the n% first "
     "are scanned");
 
-std::shared_ptr<TpchQueryBuilder> queryBuilder;
-
-class TpchBenchmark : public QueryBenchmarkBase {
- public:
-  void runMain(std::ostream& out, RunStats& runStats) override {
-    if (FLAGS_run_query_verbose == -1 && FLAGS_io_meter_column_pct == 0) {
-      folly::runBenchmarks();
-    } else {
-      const auto queryPlan = FLAGS_io_meter_column_pct > 0
-          ? queryBuilder->getIoMeterPlan(FLAGS_io_meter_column_pct)
-          : queryBuilder->getQueryPlan(FLAGS_run_query_verbose);
-      auto [cursor, actualResults] = run(queryPlan);
-      if (!cursor) {
-        LOG(ERROR) << "Query terminated with error. Exiting";
-        exit(1);
-      }
-      auto task = cursor->task();
-      ensureTaskCompletion(task.get());
-      if (FLAGS_include_results) {
-        printResults(actualResults, out);
-        out << std::endl;
-      }
-      const auto stats = task->taskStats();
-      int64_t rawInputBytes = 0;
-      for (auto& pipeline : stats.pipelineStats) {
-        auto& first = pipeline.operatorStats[0];
-        if (first.operatorType == "TableScan") {
-          rawInputBytes += first.rawInputBytes;
-        }
+void TpchBenchmark::initQueryBuilder() {
+  queryBuilder_ =
+      std::make_shared<TpchQueryBuilder>(toFileFormat(FLAGS_data_format));
+  queryBuilder_->initialize(FLAGS_data_path);
+}
+
+void TpchBenchmark::initialize() {
+  QueryBenchmarkBase::initialize();
+  initQueryBuilder();
+}
+
+void TpchBenchmark::shutdown() {
+  QueryBenchmarkBase::shutdown();
+  queryBuilder_.reset();
+}
+
+void TpchBenchmark::runMain(
+    std::ostream& out,
+    facebook::velox::RunStats& runStats) {
+  if (FLAGS_run_query_verbose == -1 && FLAGS_io_meter_column_pct == 0) {
+    folly::runBenchmarks();
+  } else {
+    auto queryPlan = FLAGS_io_meter_column_pct > 0
+        ? queryBuilder_->getIoMeterPlan(FLAGS_io_meter_column_pct)
+        : queryBuilder_->getQueryPlan(FLAGS_run_query_verbose);
+    auto [cursor, actualResults] = run(queryPlan, queryConfigs_);
+    if (!cursor) {
+      LOG(ERROR) << "Query terminated with error. Exiting";
+      exit(1);
+    }
+    auto task = cursor->task();
+    ensureTaskCompletion(task.get());
+    if (FLAGS_include_results) {
+      printResults(actualResults, out);
+      out << std::endl;
+    }
+    const auto stats = task->taskStats();
+    int64_t rawInputBytes = 0;
+    for (auto& pipeline : stats.pipelineStats) {
+      auto& first = pipeline.operatorStats[0];
+      if (first.operatorType == OperatorType::kTableScan) {
+        rawInputBytes += first.rawInputBytes;
       }
-      runStats.rawInputBytes = rawInputBytes;
-      out << fmt::format(
-                 "Execution time: {}",
-                 succinctMillis(
-                     stats.executionEndTimeMs - stats.executionStartTimeMs))
-          << std::endl;
-      out << fmt::format(
-                 "Splits total: {}, finished: {}",
-                 stats.numTotalSplits,
-                 stats.numFinishedSplits)
-          << std::endl;
-      out << printPlanWithStats(
-                 *queryPlan.plan, stats, FLAGS_include_custom_stats)
-          << std::endl;
     }
+    runStats.rawInputBytes = rawInputBytes;
+    out << fmt::format(
+               "Execution time: {}",
+               facebook::velox::succinctMillis(
+                   stats.executionEndTimeMs - stats.executionStartTimeMs))
+        << std::endl;
+    out << fmt::format(
+               "Splits total: {}, finished: {}",
+               stats.numTotalSplits,
+               stats.numFinishedSplits)
+        << std::endl;
+    out << printPlanWithStats(
+               *queryPlan.plan, stats, FLAGS_include_custom_stats)
+        << std::endl;
   }
-};
+}
 
-TpchBenchmark benchmark;
+std::unique_ptr<TpchBenchmark> benchmark;
 
 BENCHMARK(q1) {
-  const auto planContext = queryBuilder->getQueryPlan(1);
-  benchmark.run(planContext);
+  benchmark->runQuery(1);
 }
 
 BENCHMARK(q2) {
-  const auto planContext = queryBuilder->getQueryPlan(2);
-  benchmark.run(planContext);
+  benchmark->runQuery(2);
 }
 
 BENCHMARK(q3) {
-  const auto planContext = queryBuilder->getQueryPlan(3);
-  benchmark.run(planContext);
+  benchmark->runQuery(3);
 }
 
 BENCHMARK(q4) {
-  const auto planContext = queryBuilder->getQueryPlan(4);
-  benchmark.run(planContext);
+  benchmark->runQuery(4);
 }
 
 BENCHMARK(q5) {
-  const auto planContext = queryBuilder->getQueryPlan(5);
-  benchmark.run(planContext);
+  benchmark->runQuery(5);
 }
 
 BENCHMARK(q6) {
-  const auto planContext = queryBuilder->getQueryPlan(6);
-  benchmark.run(planContext);
+  benchmark->runQuery(6);
 }
 
 BENCHMARK(q7) {
-  const auto planContext = queryBuilder->getQueryPlan(7);
-  benchmark.run(planContext);
+  benchmark->runQuery(7);
 }
 
 BENCHMARK(q8) {
-  const auto planContext = queryBuilder->getQueryPlan(8);
-  benchmark.run(planContext);
+  benchmark->runQuery(8);
 }
 
 BENCHMARK(q9) {
-  const auto planContext = queryBuilder->getQueryPlan(9);
-  benchmark.run(planContext);
+  benchmark->runQuery(9);
 }
 
 BENCHMARK(q10) {
-  const auto planContext = queryBuilder->getQueryPlan(10);
-  benchmark.run(planContext);
+  benchmark->runQuery(10);
 }
 
 BENCHMARK(q11) {
-  const auto planContext = queryBuilder->getQueryPlan(11);
-  benchmark.run(planContext);
+  benchmark->runQuery(11);
 }
 
 BENCHMARK(q12) {
-  const auto planContext = queryBuilder->getQueryPlan(12);
-  benchmark.run(planContext);
+  benchmark->runQuery(12);
 }
 
 BENCHMARK(q13) {
-  const auto planContext = queryBuilder->getQueryPlan(13);
-  benchmark.run(planContext);
+  benchmark->runQuery(13);
 }
 
 BENCHMARK(q14) {
-  const auto planContext = queryBuilder->getQueryPlan(14);
-  benchmark.run(planContext);
+  benchmark->runQuery(14);
 }
 
 BENCHMARK(q15) {
-  const auto planContext = queryBuilder->getQueryPlan(15);
-  benchmark.run(planContext);
+  benchmark->runQuery(15);
 }
 
 BENCHMARK(q16) {
-  const auto planContext = queryBuilder->getQueryPlan(16);
-  benchmark.run(planContext);
+  benchmark->runQuery(16);
 }
 
 BENCHMARK(q17) {
-  const auto planContext = queryBuilder->getQueryPlan(17);
-  benchmark.run(planContext);
+  benchmark->runQuery(17);
 }
 
 BENCHMARK(q18) {
-  const auto planContext = queryBuilder->getQueryPlan(18);
-  benchmark.run(planContext);
+  benchmark->runQuery(18);
 }
 
 BENCHMARK(q19) {
-  const auto planContext = queryBuilder->getQueryPlan(19);
-  benchmark.run(planContext);
+  benchmark->runQuery(19);
 }
 
 BENCHMARK(q20) {
-  const auto planContext = queryBuilder->getQueryPlan(20);
-  benchmark.run(planContext);
+  benchmark->runQuery(20);
 }
 
 BENCHMARK(q21) {
-  const auto planContext = queryBuilder->getQueryPlan(21);
-  benchmark.run(planContext);
+  benchmark->runQuery(21);
 }
 
 BENCHMARK(q22) {
-  const auto planContext = queryBuilder->getQueryPlan(22);
-  benchmark.run(planContext);
+  benchmark->runQuery(22);
 }
 
-int tpchBenchmarkMain() {
-  benchmark.initialize();
-  queryBuilder =
-      std::make_shared<TpchQueryBuilder>(toFileFormat(FLAGS_data_format));
-  queryBuilder->initialize(FLAGS_data_path);
+void tpchBenchmarkMain() {
+  VELOX_CHECK_NOT_NULL(benchmark);
+  benchmark->initialize();
   if (FLAGS_test_flags_file.empty()) {
     RunStats ignore;
-    benchmark.runMain(std::cout, ignore);
+    benchmark->runMain(std::cout, ignore);
   } else {
-    benchmark.runAllCombinations();
+    benchmark->runAllCombinations();
   }
-  benchmark.shutdown();
-  queryBuilder.reset();
-  return 0;
+  benchmark->shutdown();
 }
diff --git a/velox/benchmarks/tpch/TpchBenchmark.h b/velox/benchmarks/tpch/TpchBenchmark.h
index e66e7c53cbc..7297f7db17a 100644
--- a/velox/benchmarks/tpch/TpchBenchmark.h
+++ b/velox/benchmarks/tpch/TpchBenchmark.h
@@ -15,4 +15,31 @@
  */
 #pragma once
 
+#include "velox/benchmarks/QueryBenchmarkBase.h"
+#include "velox/exec/tests/utils/TpchQueryBuilder.h"
+
+class TpchBenchmark : public facebook::velox::QueryBenchmarkBase {
+ public:
+  void initialize() override;
+
+  void shutdown() override;
+
+  void runMain(std::ostream& out, facebook::velox::RunStats& runStats) override;
+
+  void runQuery(int32_t queryId) {
+    const auto planContext = queryBuilder_->getQueryPlan(queryId);
+    run(planContext, queryConfigs_);
+  }
+
+ protected:
+  std::unordered_map<std::string, std::string> queryConfigs_;
+
+ private:
+  void initQueryBuilder();
+
+  std::shared_ptr<facebook::velox::exec::test::TpchQueryBuilder> queryBuilder_;
+};
+
+extern std::unique_ptr<TpchBenchmark> benchmark;
+
 void tpchBenchmarkMain();
diff --git a/velox/benchmarks/tpch/TpchBenchmarkMain.cpp b/velox/benchmarks/tpch/TpchBenchmarkMain.cpp
index 4477455d8f3..0fa9718ca7b 100644
--- a/velox/benchmarks/tpch/TpchBenchmarkMain.cpp
+++ b/velox/benchmarks/tpch/TpchBenchmarkMain.cpp
@@ -24,5 +24,6 @@ int main(int argc, char** argv) {
       "This program benchmarks TPC-H queries. Run 'velox_tpch_benchmark -helpon=TpchBenchmark' for available options.\n");
   gflags::SetUsageMessage(kUsage);
   folly::Init init{&argc, &argv, false};
+  benchmark = std::make_unique<TpchBenchmark>();
   tpchBenchmarkMain();
 }
diff --git a/velox/buffer/Buffer.cpp b/velox/buffer/Buffer.cpp
index 80695929540..abb7a3f09d6 100644
--- a/velox/buffer/Buffer.cpp
+++ b/velox/buffer/Buffer.cpp
@@ -18,9 +18,24 @@
 
 namespace facebook::velox {
 
+std::string Buffer::typeString(Type type) {
+  switch (type) {
+    case Type::kPOD:
+      return "kPOD";
+    case Type::kNonPOD:
+      return "kNonPOD";
+    case Type::kPODView:
+      return "kPODView";
+    case Type::kNonPODView:
+      return "kNonPODView";
+    default:
+      return fmt::format("Unknown({})", static_cast<int>(type));
+  }
+}
+
 namespace {
 struct BufferReleaser {
-  explicit BufferReleaser(const BufferPtr& parent) : parent_(parent) {}
+  explicit BufferReleaser(BufferPtr parent) : parent_{std::move(parent)} {}
   void addRef() const {}
   void release() const {}
 
diff --git a/velox/buffer/Buffer.h b/velox/buffer/Buffer.h
index 48cd0a62909..85ceab56712 100644
--- a/velox/buffer/Buffer.h
+++ b/velox/buffer/Buffer.h
@@ -19,6 +19,8 @@
 #include <iomanip>
 
 #include <boost/intrusive_ptr.hpp>
+#include <fmt/format.h>
+#include <utility>
 #include "velox/common/base/BitUtil.h"
 #include "velox/common/base/CheckedArithmetic.h"
 #include "velox/common/base/Exceptions.h"
@@ -26,8 +28,7 @@
 #include "velox/common/base/SimdUtil.h"
 #include "velox/common/memory/Memory.h"
 
-namespace facebook {
-namespace velox {
+namespace facebook::velox {
 
 class Buffer;
 class AlignedBuffer;
@@ -58,21 +59,40 @@ class Buffer {
   // type. Thus the conditions are: trivial destructor (no resources to release)
   // and trivially copyable (so memcpy works)
   template <typename T>
-  static inline constexpr bool is_pod_like_v =
+  static constexpr bool is_pod_like_v =
       std::is_trivially_destructible_v<T> && std::is_trivially_copyable_v<T>;
 
-  virtual ~Buffer() {}
+  virtual ~Buffer() = default;
 
-  void addRef() {
-    referenceCount_.fetch_add(1);
+  static constexpr uint8_t kPODBit = 0;
+  static constexpr uint8_t kPODMask = 1 << kPODBit;
+  static constexpr uint8_t kViewBit = 1;
+  static constexpr uint8_t kViewMask = 1 << kViewBit;
+  static_assert(kPODBit != kViewBit);
+
+  enum class Type : uint8_t {
+    kNonPOD = 0 << kPODBit | 0 << kViewBit,
+    kPOD = 1 << kPODBit | 0 << kViewBit,
+    kNonPODView = 0 << kPODBit | 1 << kViewBit,
+    kPODView = 1 << kPODBit | 1 << kViewBit,
+  };
+
+  static std::string typeString(Type type);
+
+  Type type() const {
+    return type_;
+  }
+
+  void addRef() noexcept {
+    referenceCount_.fetch_add(1, std::memory_order_acq_rel);
   }
 
-  int refCount() const {
-    return referenceCount_;
+  int refCount() const noexcept {
+    return referenceCount_.load(std::memory_order_acquire);
   }
 
   void release() {
-    if (referenceCount_.fetch_sub(1) == 1) {
+    if (referenceCount_.fetch_sub(1, std::memory_order_acq_rel) == 1) {
       releaseResources();
       if (pool_) {
         freeToPool();
@@ -86,13 +106,13 @@ class Buffer {
   const T* as() const {
     // We can't check actual types, but we can sanity-check POD/non-POD
     // conversion. `void` is special as it's used in type-erased contexts
-    VELOX_DCHECK((std::is_same_v<T, void>) || podType_ == is_pod_like_v<T>);
+    VELOX_DCHECK(std::is_void_v<T> || isPOD() == is_pod_like_v<T>);
     return reinterpret_cast<const T*>(data_);
   }
 
   template <typename T>
   Range<T> asRange() {
-    return Range<T>(as<T>(), 0, size() / sizeof(T));
+    return {as<T>(), 0, static_cast<int32_t>(size() / sizeof(T))};
   }
 
   template <typename T>
@@ -102,16 +122,16 @@ class Buffer {
     VELOX_CHECK(!isView());
     // We can't check actual types, but we can sanity-check POD/non-POD
     // conversion. `void` is special as it's used in type-erased contexts
-    VELOX_DCHECK((std::is_same_v<T, void>) || podType_ == is_pod_like_v<T>);
+    VELOX_DCHECK(std::is_void_v<T> || isPOD() == is_pod_like_v<T>);
     return reinterpret_cast<T*>(data_);
   }
 
   template <typename T>
   MutableRange<T> asMutableRange() {
-    return MutableRange<T>(asMutable<T>(), 0, size() / sizeof(T));
+    return {asMutable<T>(), 0, static_cast<int32_t>(size() / sizeof(T))};
   }
 
-  size_t size() const {
+  size_t size() const noexcept {
     return size_;
   }
 
@@ -126,24 +146,28 @@ class Buffer {
     checkEndGuard();
   }
 
-  uint64_t capacity() const {
+  uint64_t capacity() const noexcept {
     return capacity_;
   }
 
-  bool unique() const {
-    return referenceCount_ == 1;
+  bool unique() const noexcept {
+    return refCount() == 1;
   }
 
-  velox::memory::MemoryPool* pool() const {
+  velox::memory::MemoryPool* pool() const noexcept {
     return pool_;
   }
 
-  bool isMutable() const {
+  bool isMutable() const noexcept {
     return !isView() && unique();
   }
 
-  virtual bool isView() const {
-    return false;
+  bool isView() const {
+    return (static_cast<uint8_t>(type_) & kViewMask) != 0;
+  }
+
+  bool isPOD() const {
+    return (static_cast<uint8_t>(type_) & kPODMask) != 0;
   }
 
   friend std::ostream& operator<<(std::ostream& os, const Buffer& buffer) {
@@ -199,6 +223,14 @@ class Buffer {
         sizeof(T), is_pod_like_v<T>, buffer, offset, length);
   }
 
+  /// Transfers this buffer to 'pool'. Returns true if the transfer succeeds, or
+  /// false if the transfer fails. A buffer can be transferred to 'pool' if its
+  /// original pool and 'pool' are from the same MemoryAllocator and the buffer
+  /// is not a BufferView.
+  virtual bool transferTo(velox::memory::MemoryPool* /*pool*/) {
+    VELOX_NYI("{} unsupported", __FUNCTION__);
+  }
+
  protected:
   // Writes a magic word at 'capacity_'. No-op for a BufferView. The actual
   // logic is inside a separate virtual function, allowing override by derived
@@ -241,7 +273,7 @@ class Buffer {
   virtual void copyFrom(const Buffer* other, size_t bytes) {
     VELOX_CHECK(!isView());
     VELOX_CHECK_GE(capacity_, bytes);
-    VELOX_CHECK(podType_);
+    VELOX_CHECK_EQ(type_, Type::kPOD);
     memcpy(data_, other->data_, bytes);
   }
 
@@ -252,27 +284,24 @@ class Buffer {
   }
 
   Buffer(
-      velox::memory::MemoryPool* pool,
+      Type type,
       uint8_t* data,
       size_t capacity,
-      bool podType)
-      : pool_(pool),
-        data_(data),
-        capacity_(capacity),
-        referenceCount_(0),
-        podType_(podType) {}
+      velox::memory::MemoryPool* pool)
+      : pool_{pool}, data_{data}, capacity_{capacity}, type_{type} {}
 
   velox::memory::MemoryPool* const pool_;
   uint8_t* const data_;
-  uint64_t size_ = 0;
-  uint64_t capacity_ = 0;
-  std::atomic<int32_t> referenceCount_;
-  bool podType_ = true;
-  // Pad to 64 bytes. If using as int32_t[], guarantee that value at index -1 ==
-  // -1.
-  uint64_t padding_[2] = {static_cast<uint64_t>(-1), static_cast<uint64_t>(-1)};
-  // Needs to use setCapacity() from static method reallocate().
-  friend class AlignedBuffer;
+
+  uint64_t size_{0};
+  uint64_t capacity_;
+  std::atomic_int32_t referenceCount_{0};
+
+  const Type type_;
+
+  // Pad to 64 bytes.
+  // If using as int32_t[], guarantee that value at index -1 == -1.
+  uint64_t padding_[2]{static_cast<uint64_t>(-1), static_cast<uint64_t>(-1)};
 
  private:
   static BufferPtr sliceBufferZeroCopy(
@@ -281,6 +310,9 @@ class Buffer {
       const BufferPtr& buffer,
       size_t offset,
       size_t length);
+
+  // Needs to use setCapacity() from static method reallocate().
+  friend class AlignedBuffer;
 };
 
 static_assert(
@@ -289,12 +321,12 @@ static_assert(
 
 template <>
 inline Range<bool> Buffer::asRange<bool>() {
-  return Range<bool>(as<uint64_t>(), 0, size() * 8);
+  return {as<uint64_t>(), 0, static_cast<int32_t>(size() * 8)};
 }
 
 template <>
 inline MutableRange<bool> Buffer::asMutableRange<bool>() {
-  return MutableRange<bool>(asMutable<uint64_t>(), 0, size() * 8);
+  return {asMutable<uint64_t>(), 0, static_cast<int32_t>(size() * 8)};
 }
 
 template <>
@@ -304,11 +336,11 @@ BufferPtr Buffer::slice<bool>(
     size_t length,
     memory::MemoryPool* pool);
 
-static inline void intrusive_ptr_add_ref(Buffer* buffer) {
+FOLLY_ALWAYS_INLINE void intrusive_ptr_add_ref(Buffer* buffer) noexcept {
   buffer->addRef();
 }
 
-static inline void intrusive_ptr_release(Buffer* buffer) {
+FOLLY_ALWAYS_INLINE void intrusive_ptr_release(Buffer* buffer) noexcept {
   buffer->release();
 }
 
@@ -325,7 +357,7 @@ class AlignedBuffer : public Buffer {
   static constexpr int32_t kSizeofAlignedBuffer = 64;
   static constexpr int32_t kPaddedSize = kSizeofAlignedBuffer + simd::kPadding;
 
-  ~AlignedBuffer() {
+  ~AlignedBuffer() override {
     // This may throw, which is expected to signal an error to the
     // user. This is better for distributed debugging than killing the
     // process. In concept this indicates the possibility of memory
@@ -337,10 +369,8 @@ class AlignedBuffer : public Buffer {
   // It's almost like partial specialization, but we redirect all POD types to
   // the same non-templated class
   template <typename T>
-  using ImplClass = typename std::conditional<
-      is_pod_like_v<T>,
-      AlignedBuffer,
-      NonPODAlignedBuffer<T>>::type;
+  using ImplClass = std::
+      conditional_t<is_pod_like_v<T>, AlignedBuffer, NonPODAlignedBuffer<T>>;
 
   /**
    * Allocates enough memory to store numElements of type T.  May
@@ -368,7 +398,7 @@ class AlignedBuffer : public Buffer {
 
     void* memory = pool->allocate(preferredSize);
     VELOX_CHECK_NOT_NULL(memory);
-    auto* buffer = new (memory) ImplClass<T>(pool, preferredSize - kPaddedSize);
+    auto* buffer = new (memory) ImplClass<T>{pool, preferredSize - kPaddedSize};
     // set size explicitly instead of setSize because `fillNewMemory` already
     // called the constructors
     buffer->size_ = size;
@@ -377,6 +407,18 @@ class AlignedBuffer : public Buffer {
     return result;
   }
 
+  /// A verbose version of the allocate() with the exact size.
+  /// May allocate slightly more memory than strictly necessary. Guarantees that
+  /// simd::kPadding bytes past capacity() are addressable and asserts that
+  /// these do not get overrun.
+  template <typename T>
+  static BufferPtr allocateExact(
+      size_t numElements,
+      velox::memory::MemoryPool* pool,
+      const std::optional<T>& initValue = std::nullopt) {
+    return allocate<T>(numElements, pool, initValue, true);
+  }
+
   // Changes the capacity of '*buffer'. The buffer may grow/shrink in
   // place or may change addresses. The content is copied up to the
   // old size() or the new size, whichever is smaller. If the buffer grows, the
@@ -418,34 +460,32 @@ class AlignedBuffer : public Buffer {
       // called the constructors
       newBuffer->size_ = size;
       *buffer = std::move(newBuffer);
-      return;
-    }
-    if (!old->unique()) {
+    } else if (!old->unique()) {
       auto newBuffer = allocate<T>(numElements, pool);
       newBuffer->copyFrom(old, std::min(size, old->size()));
       reinterpret_cast<AlignedBuffer*>(newBuffer.get())
           ->template fillNewMemory<T>(old->size(), size, initValue);
       newBuffer->size_ = size;
       *buffer = std::move(newBuffer);
-      return;
-    }
-    auto oldCapacity = checkedPlus<size_t>(old->capacity(), kPaddedSize);
-    auto preferredSize =
-        pool->preferredSize(checkedPlus<size_t>(size, kPaddedSize));
+    } else {
+      auto oldCapacity = checkedPlus<size_t>(old->capacity(), kPaddedSize);
+      auto preferredSize =
+          pool->preferredSize(checkedPlus<size_t>(size, kPaddedSize));
 
-    void* newPtr = pool->reallocate(old, oldCapacity, preferredSize);
+      void* newPtr = pool->reallocate(old, oldCapacity, preferredSize);
 
-    // Make the old buffer no longer owned by '*buffer' because reallocate
-    // freed the old buffer. Reassigning the new buffer to
-    // '*buffer' would be a double free if we didn't do this.
-    buffer->detach();
+      // Make the old buffer no longer owned by '*buffer' because reallocate
+      // freed the old buffer. Reassigning the new buffer to
+      // '*buffer' would be a double free if we didn't do this.
+      buffer->detach();
 
-    auto newBuffer =
-        new (newPtr) AlignedBuffer(pool, preferredSize - kPaddedSize);
-    newBuffer->setSize(size);
-    newBuffer->fillNewMemory<T>(oldSize, size, initValue);
+      auto newBuffer =
+          new (newPtr) AlignedBuffer{pool, preferredSize - kPaddedSize};
+      newBuffer->setSize(size);
+      newBuffer->fillNewMemory<T>(oldSize, size, initValue);
 
-    *buffer = newBuffer;
+      *buffer = newBuffer;
+    }
   }
 
   // Appends bytes starting at 'items' for a length of 'sizeof(T) *
@@ -480,7 +520,7 @@ class AlignedBuffer : public Buffer {
     }
 
     VELOX_CHECK(
-        bufferPtr->podType_, "Support for non POD types not implemented yet");
+        bufferPtr->isPOD(), "Support for non POD types not implemented yet");
 
     // The reason we use uint8_t is because mutableNulls()->size() will return
     // in byte count. We also don't bother initializing since copyFrom will be
@@ -492,13 +532,49 @@ class AlignedBuffer : public Buffer {
     return newBuffer;
   }
 
+  template <typename T>
+  static BufferPtr copy(
+      const BufferPtr& buffer,
+      velox::memory::MemoryPool* pool) {
+    if (buffer == nullptr) {
+      return nullptr;
+    }
+
+    // The reason we use uint8_t is because mutableNulls()->size() will return
+    // in byte count. We also don't bother initializing since copyFrom will be
+    // overwriting anyway.
+    BufferPtr newBuffer;
+    if constexpr (std::is_same_v<T, bool>) {
+      newBuffer = AlignedBuffer::allocate<uint8_t>(buffer->size(), pool);
+    } else {
+      const auto numElements = checkedDivide(buffer->size(), sizeof(T));
+      newBuffer = AlignedBuffer::allocate<T>(numElements, pool);
+    }
+
+    newBuffer->copyFrom(buffer.get(), newBuffer->size());
+
+    return newBuffer;
+  }
+
+  bool transferTo(velox::memory::MemoryPool* pool) override {
+    if (pool_ == pool) {
+      return true;
+    }
+    if (pool_->transferTo(
+            pool, this, checkedPlus<size_t>(kPaddedSize, capacity_))) {
+      setPool(pool);
+      return true;
+    }
+    return false;
+  }
+
  protected:
   AlignedBuffer(velox::memory::MemoryPool* pool, size_t capacity)
-      : Buffer(
-            pool,
+      : Buffer{
+            Type::kPOD,
             reinterpret_cast<uint8_t*>(this) + sizeof(*this),
             capacity,
-            true /*podType*/) {
+            pool} {
     static_assert(sizeof(*this) == kAlignment);
     static_assert(sizeof(*this) == kSizeofAlignedBuffer);
     setEndGuard();
@@ -532,7 +608,12 @@ class AlignedBuffer : public Buffer {
     }
   }
 
- protected:
+  void setPool(velox::memory::MemoryPool* pool) {
+    velox::memory::MemoryPool** poolPtr =
+        const_cast<velox::memory::MemoryPool**>(&pool_);
+    *poolPtr = pool;
+  }
+
   void setEndGuardImpl() override {
     *reinterpret_cast<uint64_t*>(data_ + capacity_) = kEndGuard;
   }
@@ -597,13 +678,30 @@ class NonPODAlignedBuffer : public Buffer {
     }
   }
 
+  bool transferTo(velox::memory::MemoryPool* pool) override {
+    if (pool_ == pool) {
+      return true;
+    }
+
+    if (pool_->transferTo(
+            pool,
+            this,
+            checkedPlus<size_t>(AlignedBuffer::kPaddedSize, capacity_))) {
+      velox::memory::MemoryPool** poolPtr =
+          const_cast<velox::memory::MemoryPool**>(&pool_);
+      *poolPtr = pool;
+      return true;
+    }
+    return false;
+  }
+
  protected:
   NonPODAlignedBuffer(velox::memory::MemoryPool* pool, size_t capacity)
-      : Buffer(
-            pool,
+      : Buffer{
+            Type::kNonPOD,
             reinterpret_cast<uint8_t*>(this) + sizeof(*this),
             capacity,
-            false /*podType*/) {
+            pool} {
     static_assert(sizeof(*this) == AlignedBuffer::kAlignment);
     static_assert(sizeof(*this) == sizeof(AlignedBuffer));
   }
@@ -611,8 +709,8 @@ class NonPODAlignedBuffer : public Buffer {
   void releaseResources() override {
     VELOX_CHECK_EQ(size_ % sizeof(T), 0);
     size_t numValues = size_ / sizeof(T);
-    // we can't use asMutable because it checks isMutable and we wan't to
-    // destroy regardless
+    // we can't use asMutable because it checks isMutable and we wan't
+    // to destroy regardless
     T* ptr = reinterpret_cast<T*>(data_);
     for (int i = 0; i < numValues; ++i) {
       ptr[i].~T();
@@ -620,6 +718,8 @@ class NonPODAlignedBuffer : public Buffer {
   }
 
   void copyFrom(const Buffer* other, size_t bytes) override {
+    // TODO: change this to isMutable(). See
+    // https://github.com/facebookincubator/velox/issues/6562.
     VELOX_CHECK(!isView());
     VELOX_CHECK_GE(size_, bytes);
     VELOX_DCHECK(
@@ -676,47 +776,60 @@ class NonPODAlignedBuffer : public Buffer {
 template <typename Releaser>
 class BufferView : public Buffer {
  public:
-  static BufferPtr create(
-      const uint8_t* data,
-      size_t size,
-      Releaser releaser,
-      bool podType = true) {
-    BufferView<Releaser>* view = new BufferView(data, size, releaser, podType);
-    BufferPtr result(view);
+  template <typename R = Releaser>
+  static BufferPtr
+  create(const uint8_t* data, size_t size, R&& releaser, bool podType = true) {
+    auto* view = new BufferView{data, size, std::forward<R>(releaser), podType};
+    BufferPtr result{view};
     return result;
   }
 
   // Helper method to create a buffer view referencing another existing Buffer.
+  template <typename R = Releaser>
   static BufferPtr
-  create(BufferPtr innerBuffer, Releaser releaser, bool podType = true) {
+  create(const BufferPtr& innerBuffer, R&& releaser, bool podType = true) {
     return create(
-        innerBuffer->as<uint8_t>(), innerBuffer->size(), releaser, podType);
+        innerBuffer->as<uint8_t>(),
+        innerBuffer->size(),
+        std::forward<R>(releaser),
+        podType);
   }
 
   ~BufferView() override {
     releaser_.release();
   }
 
-  bool isView() const override {
-    return true;
+  bool transferTo(velox::memory::MemoryPool* pool) override {
+    if (pool_ == pool) {
+      return true;
+    }
+    return false;
   }
 
  private:
-  BufferView(const uint8_t* data, size_t size, Releaser releaser, bool podType)
+  template <typename R>
+  BufferView(const uint8_t* data, size_t size, R&& releaser, bool podType)
       // A BufferView must be created over the data held by a cache
       // pin, which is typically const. The Buffer enforces const-ness
       // when returning the pointer. We cast away the const here to
       // avoid a separate code path for const and non-const Buffer
       // payloads.
-      : Buffer(nullptr, const_cast<uint8_t*>(data), size, podType),
-        releaser_(releaser) {
+      : Buffer{podType ? Type::kPODView : Type::kNonPODView, const_cast<uint8_t*>(data), size, nullptr},
+        releaser_{std::forward<R>(releaser)} {
     size_ = size;
-    capacity_ = size;
     releaser_.addRef();
   }
 
-  Releaser const releaser_;
+  [[no_unique_address]] const Releaser releaser_;
 };
 
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox
+
+// fmt formatter specialization for Buffer::Type
+template <>
+struct fmt::formatter<facebook::velox::Buffer::Type> : formatter<std::string> {
+  auto format(facebook::velox::Buffer::Type s, format_context& ctx) const {
+    return formatter<std::string>::format(
+        facebook::velox::Buffer::typeString(s), ctx);
+  }
+};
diff --git a/velox/buffer/BufferPool.cpp b/velox/buffer/BufferPool.cpp
new file mode 100644
index 00000000000..71525c80176
--- /dev/null
+++ b/velox/buffer/BufferPool.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/buffer/BufferPool.h"
+
+namespace facebook::velox {
+
+BufferPtr BufferPool::get(uint64_t minBytes) {
+  for (size_t i = 0; i < buffers_.size(); ++i) {
+    if (buffers_[i]->capacity() >= minBytes) {
+      auto result = std::move(buffers_[i]);
+      buffers_[i] = std::move(buffers_.back());
+      buffers_.pop_back();
+      return result;
+    }
+  }
+  return nullptr;
+}
+
+BufferPtr BufferPool::get() {
+  if (buffers_.empty()) {
+    return nullptr;
+  }
+  auto result = std::move(buffers_.back());
+  buffers_.pop_back();
+  return result;
+}
+
+void BufferPool::release(BufferPtr&& buffer) {
+  if (buffer == nullptr || !buffer->unique() || buffers_.size() >= kMaxCached) {
+    return;
+  }
+  buffers_.push_back(std::move(buffer));
+}
+
+size_t BufferPool::size() const {
+  return buffers_.size();
+}
+
+} // namespace facebook::velox
diff --git a/velox/buffer/BufferPool.h b/velox/buffer/BufferPool.h
new file mode 100644
index 00000000000..bf5c1081e89
--- /dev/null
+++ b/velox/buffer/BufferPool.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <vector>
+
+#include "velox/buffer/Buffer.h"
+
+namespace facebook::velox {
+
+/// Caches BufferPtr objects for reuse across encoding lifetimes.
+/// When encoding objects are destroyed, their scratch buffers can be returned
+/// to the pool instead of being freed. New encodings can then grab
+/// pre-allocated buffers from the pool, avoiding MemoryPool allocation
+/// overhead (including mutex contention).
+///
+/// Thread safety: NOT thread-safe. Intended for use within a single
+/// deserialization stream.
+class BufferPool {
+ public:
+  /// Returns a cached buffer with capacity >= minBytes, or nullptr if none
+  /// available.
+  BufferPtr get(uint64_t minBytes);
+
+  /// Returns a cached buffer (any size), or nullptr if none available.
+  BufferPtr get();
+
+  /// Returns a buffer to the pool for future reuse. Drops the buffer if the
+  /// pool is full or if 'buffer' is null. The buffer must have a unique
+  /// reference (refcount == 1) to ensure safe reuse.
+  void release(BufferPtr&& buffer);
+
+  /// Returns the number of cached buffers currently in the pool.
+  size_t size() const;
+
+ private:
+  // Maximum number of BufferPtr objects retained in the pool.
+  static constexpr size_t kMaxCached = 32;
+  // Cached buffers available for reuse.
+  std::vector<BufferPtr> buffers_;
+};
+
+} // namespace facebook::velox
diff --git a/velox/buffer/CMakeLists.txt b/velox/buffer/CMakeLists.txt
index ec15197d4f5..01d59ef258e 100644
--- a/velox/buffer/CMakeLists.txt
+++ b/velox/buffer/CMakeLists.txt
@@ -12,7 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_buffer Buffer.cpp StringViewBufferHolder.cpp)
+velox_add_library(
+  velox_buffer
+  Buffer.cpp
+  BufferPool.cpp
+  StringViewBufferHolder.cpp
+  HEADERS
+  Buffer.h
+  BufferPool.h
+  StringViewBufferHolder.h
+)
 
 velox_link_libraries(velox_buffer velox_memory velox_common_base Folly::folly)
 
diff --git a/velox/buffer/StringViewBufferHolder.cpp b/velox/buffer/StringViewBufferHolder.cpp
index 83479bba0a7..750b011b2c1 100644
--- a/velox/buffer/StringViewBufferHolder.cpp
+++ b/velox/buffer/StringViewBufferHolder.cpp
@@ -26,8 +26,9 @@ StringView StringViewBufferHolder::getOwnedStringView(
   if (stringBuffers_.empty() ||
       stringBuffers_.back()->size() + size >
           stringBuffers_.back()->capacity()) {
-    stringBuffers_.push_back(AlignedBuffer::allocate<char>(
-        std::max(size, kInitialStringReservation), pool_));
+    stringBuffers_.push_back(
+        AlignedBuffer::allocate<char>(
+            std::max(size, kInitialStringReservation), pool_));
     stringBuffers_.back()->setSize(0);
   }
   auto stringBuffer = stringBuffers_.back().get();
diff --git a/velox/buffer/StringViewBufferHolder.h b/velox/buffer/StringViewBufferHolder.h
index 99a1f3276ce..962b484fd9e 100644
--- a/velox/buffer/StringViewBufferHolder.h
+++ b/velox/buffer/StringViewBufferHolder.h
@@ -33,7 +33,7 @@ class StringViewBufferHolder {
 
   /// Return a copy of the StringView where the StringView is copied to this
   /// StringViewBufferHolder if the StringView is not inlined. std::string and
-  /// folly::StringPiece are also copied to the internal buffers (see the
+  /// std::string_view are also copied to the internal buffers (see the
   /// specializations below).
   ///
   /// NOTE: Out of convenience, we allow different types to be passed in, but
@@ -52,8 +52,8 @@ class StringViewBufferHolder {
     return getOwnedStringView(value.data(), value.size());
   }
 
-  /// Specialization for folly::StringPiece type.
-  StringView getOwnedValue(folly::StringPiece value) {
+  /// Specialization for std::string_view type.
+  StringView getOwnedValue(std::string_view value) {
     return getOwnedStringView(value.data(), value.size());
   }
 
diff --git a/velox/buffer/tests/BufferPoolTest.cpp b/velox/buffer/tests/BufferPoolTest.cpp
new file mode 100644
index 00000000000..07ff3468cf3
--- /dev/null
+++ b/velox/buffer/tests/BufferPoolTest.cpp
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/buffer/BufferPool.h"
+
+#include <gtest/gtest.h>
+
+#include "velox/common/memory/Memory.h"
+
+namespace facebook::velox::test {
+
+class BufferPoolTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    pool_ = memoryManager_.addLeafPool("BufferPoolTest");
+  }
+
+  memory::MemoryManager memoryManager_;
+  std::shared_ptr<memory::MemoryPool> pool_;
+};
+
+TEST_F(BufferPoolTest, emptyPool) {
+  BufferPool bufferPool;
+  EXPECT_EQ(bufferPool.size(), 0);
+  EXPECT_EQ(bufferPool.get(), nullptr);
+  EXPECT_EQ(bufferPool.get(100), nullptr);
+}
+
+TEST_F(BufferPoolTest, recycleAndGet) {
+  BufferPool bufferPool;
+  auto buffer = AlignedBuffer::allocate<char>(1'024, pool_.get());
+  auto* rawPtr = buffer.get();
+  const auto capacity = buffer->capacity();
+
+  bufferPool.release(std::move(buffer));
+  EXPECT_EQ(bufferPool.size(), 1);
+
+  auto retrieved = bufferPool.get();
+  EXPECT_NE(retrieved, nullptr);
+  EXPECT_EQ(retrieved.get(), rawPtr);
+  EXPECT_EQ(retrieved->capacity(), capacity);
+  EXPECT_EQ(bufferPool.size(), 0);
+}
+
+TEST_F(BufferPoolTest, getWithMinBytes) {
+  BufferPool bufferPool;
+
+  auto small = AlignedBuffer::allocate<char>(128, pool_.get());
+  auto large = AlignedBuffer::allocate<char>(4'096, pool_.get());
+  auto* largePtr = large.get();
+
+  bufferPool.release(std::move(small));
+  bufferPool.release(std::move(large));
+  EXPECT_EQ(bufferPool.size(), 2);
+
+  // Request minBytes that only the large buffer satisfies.
+  auto retrieved = bufferPool.get(1'024);
+  EXPECT_NE(retrieved, nullptr);
+  EXPECT_EQ(retrieved.get(), largePtr);
+  EXPECT_EQ(bufferPool.size(), 1);
+
+  // The small buffer is still there.
+  auto remaining = bufferPool.get();
+  EXPECT_NE(remaining, nullptr);
+  EXPECT_EQ(bufferPool.size(), 0);
+}
+
+TEST_F(BufferPoolTest, getWithMinBytesNoMatch) {
+  BufferPool bufferPool;
+
+  auto small = AlignedBuffer::allocate<char>(128, pool_.get());
+  bufferPool.release(std::move(small));
+
+  auto retrieved = bufferPool.get(1'000'000);
+  EXPECT_EQ(retrieved, nullptr);
+  EXPECT_EQ(bufferPool.size(), 1);
+}
+
+TEST_F(BufferPoolTest, recycleNullptr) {
+  BufferPool bufferPool;
+  BufferPtr nullBuffer;
+  bufferPool.release(std::move(nullBuffer));
+  EXPECT_EQ(bufferPool.size(), 0);
+}
+
+TEST_F(BufferPoolTest, releaseNonUniqueBuffer) {
+  BufferPool bufferPool;
+  auto buffer = AlignedBuffer::allocate<char>(1'024, pool_.get());
+  auto copy = buffer;
+  EXPECT_FALSE(buffer->unique());
+  bufferPool.release(std::move(buffer));
+  EXPECT_EQ(bufferPool.size(), 0);
+}
+
+TEST_F(BufferPoolTest, releaseMoveSemantics) {
+  BufferPool bufferPool;
+  auto buffer = AlignedBuffer::allocate<char>(1'024, pool_.get());
+  auto* rawPtr = buffer.get();
+  EXPECT_TRUE(buffer->unique());
+  // NOLINTNEXTLINE(bugprone-use-after-move)
+  bufferPool.release(std::move(buffer));
+  EXPECT_EQ(buffer, nullptr);
+  EXPECT_EQ(bufferPool.size(), 1);
+  auto retrieved = bufferPool.get();
+  EXPECT_EQ(retrieved.get(), rawPtr);
+}
+
+TEST_F(BufferPoolTest, maxCachedLimit) {
+  BufferPool bufferPool;
+
+  // Fill beyond the max cached limit.
+  for (size_t i = 0; i < 40; ++i) {
+    auto buffer = AlignedBuffer::allocate<char>(64, pool_.get());
+    bufferPool.release(std::move(buffer));
+  }
+
+  // Should be capped at 32.
+  EXPECT_EQ(bufferPool.size(), 32);
+}
+
+TEST_F(BufferPoolTest, multipleRecycleAndGet) {
+  BufferPool bufferPool;
+
+  for (int i = 0; i < 5; ++i) {
+    auto buffer = AlignedBuffer::allocate<char>((i + 1) * 256, pool_.get());
+    bufferPool.release(std::move(buffer));
+  }
+  EXPECT_EQ(bufferPool.size(), 5);
+
+  // Get all back out.
+  for (int i = 0; i < 5; ++i) {
+    auto retrieved = bufferPool.get();
+    EXPECT_NE(retrieved, nullptr);
+  }
+  EXPECT_EQ(bufferPool.size(), 0);
+  EXPECT_EQ(bufferPool.get(), nullptr);
+}
+
+} // namespace facebook::velox::test
diff --git a/velox/buffer/tests/BufferTest.cpp b/velox/buffer/tests/BufferTest.cpp
index 9db4963221d..a45eeff2472 100644
--- a/velox/buffer/tests/BufferTest.cpp
+++ b/velox/buffer/tests/BufferTest.cpp
@@ -143,6 +143,20 @@ TEST_F(BufferTest, testAlignedBufferExact) {
   EXPECT_GE(buffer4->capacity(), oneMBMinusPad + 1);
 }
 
+TEST_F(BufferTest, testAllocateExact) {
+  const int32_t oneMBMinusPad = 1024 * 1024 - AlignedBuffer::kPaddedSize;
+
+  BufferPtr buffer1 = AlignedBuffer::allocateExact<char>(
+      oneMBMinusPad + 1, pool_.get(), std::nullopt);
+  EXPECT_EQ(buffer1->size(), oneMBMinusPad + 1);
+  EXPECT_GE(buffer1->capacity(), oneMBMinusPad + 1);
+
+  BufferPtr buffer2 = AlignedBuffer::allocateExact<char>(3, pool_.get(), 'i');
+  for (size_t i = 0; i < buffer2->size(); i++) {
+    EXPECT_EQ(buffer2->as<char>()[i], 'i');
+  }
+}
+
 TEST_F(BufferTest, testAsRange) {
   // Simple 2 element vector.
   std::vector<uint8_t> testData({5, 255});
@@ -484,7 +498,9 @@ TEST_F(BufferTest, testNonPOD) {
 TEST_F(BufferTest, testNonPODMemoryUsage) {
   using T = std::shared_ptr<void>;
   const int64_t currentBytes = pool_->usedBytes();
-  { auto buffer = AlignedBuffer::allocate<T>(0, pool_.get()); }
+  {
+    auto buffer = AlignedBuffer::allocate<T>(0, pool_.get());
+  }
   EXPECT_EQ(pool_->usedBytes(), currentBytes);
 }
 
@@ -535,5 +551,34 @@ TEST_F(BufferTest, sliceBooleanBuffer) {
       Buffer::slice<bool>(bufferPtr, 5, 6, nullptr), "Pool must not be null.");
 }
 
+TEST_F(BufferTest, testType) {
+  // Test AlignedBuffer type
+  auto alignedBuffer = AlignedBuffer::allocate<char>(100, pool_.get());
+  EXPECT_EQ(alignedBuffer->type(), Buffer::Type::kPOD);
+  EXPECT_TRUE(alignedBuffer->isPOD());
+  EXPECT_FALSE(alignedBuffer->isView());
+
+  // Test NonPODAlignedBuffer type
+  auto nonPODBuffer = AlignedBuffer::allocate<NonPOD>(10, pool_.get());
+  EXPECT_EQ(nonPODBuffer->type(), Buffer::Type::kNonPOD);
+  EXPECT_FALSE(nonPODBuffer->isPOD());
+  EXPECT_FALSE(nonPODBuffer->isView());
+
+  // Test BufferView type
+  MockCachePin pin;
+  const char* data = "test data";
+  auto podBufferView = BufferView<MockCachePin&>::create(
+      reinterpret_cast<const uint8_t*>(data), 9, pin);
+  EXPECT_EQ(podBufferView->type(), Buffer::Type::kPODView);
+  EXPECT_TRUE(podBufferView->isPOD());
+  EXPECT_TRUE(podBufferView->isView());
+
+  auto nonPodBufferView = BufferView<MockCachePin&>::create(
+      reinterpret_cast<const uint8_t*>(data), 9, pin, false);
+  EXPECT_EQ(nonPodBufferView->type(), Buffer::Type::kNonPODView);
+  EXPECT_FALSE(nonPodBufferView->isPOD());
+  EXPECT_TRUE(nonPodBufferView->isView());
+}
+
 } // namespace velox
 } // namespace facebook
diff --git a/velox/buffer/tests/CMakeLists.txt b/velox/buffer/tests/CMakeLists.txt
index 9ca02cf2545..eabc16c6911 100644
--- a/velox/buffer/tests/CMakeLists.txt
+++ b/velox/buffer/tests/CMakeLists.txt
@@ -11,7 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-add_executable(velox_buffer_test BufferTest.cpp StringViewBufferHolderTest.cpp)
+add_executable(velox_buffer_test BufferPoolTest.cpp BufferTest.cpp StringViewBufferHolderTest.cpp)
 
 add_test(velox_buffer_test velox_buffer_test)
 
diff --git a/velox/buffer/tests/StringViewBufferHolderTest.cpp b/velox/buffer/tests/StringViewBufferHolderTest.cpp
index 2f5c3fc3024..4ae7ece1a38 100644
--- a/velox/buffer/tests/StringViewBufferHolderTest.cpp
+++ b/velox/buffer/tests/StringViewBufferHolderTest.cpp
@@ -161,23 +161,21 @@ TEST_F(StringViewBufferHolderTest, getOwnedValueCanBeCalledWithStringType) {
   ASSERT_EQ(1, holder.buffers().size());
 }
 
-TEST_F(
-    StringViewBufferHolderTest,
-    getOwnedValueCanBeCalledWithStringPieceType) {
+TEST_F(StringViewBufferHolderTest, getOwnedValueCanBeCalledWithStringViewType) {
   const char* buf = "abcdefghijklmnopqrstuvxz";
   StringView result;
-  folly::StringPiece piece;
+  std::string_view view;
 
   auto holder = makeHolder();
   ASSERT_EQ(0, holder.buffers().size());
 
   {
     std::string str = buf;
-    piece = str;
-    result = holder.getOwnedValue(piece);
+    view = str;
+    result = holder.getOwnedValue(view);
   }
 
-  // `str` is already destructed and piece is invalid.
+  // `str` is already destructed and `view` is invalid.
   ASSERT_EQ(StringView(buf), result);
   ASSERT_EQ(1, holder.buffers().size());
 }
diff --git a/velox/common/CMakeLists.txt b/velox/common/CMakeLists.txt
index 6661427654b..0e8925038b8 100644
--- a/velox/common/CMakeLists.txt
+++ b/velox/common/CMakeLists.txt
@@ -18,11 +18,29 @@ add_subdirectory(config)
 add_subdirectory(dynamic_registry)
 add_subdirectory(encode)
 add_subdirectory(file)
+add_subdirectory(future)
+add_subdirectory(geospatial)
 add_subdirectory(hyperloglog)
 add_subdirectory(io)
 add_subdirectory(memory)
 add_subdirectory(process)
+add_subdirectory(rpc)
 add_subdirectory(serialization)
 add_subdirectory(time)
 add_subdirectory(testutil)
 add_subdirectory(fuzzer)
+
+if(${VELOX_BUILD_TESTING})
+  add_subdirectory(tests)
+endif()
+
+velox_add_library(velox_enum_declare INTERFACE HEADERS EnumDeclare.h)
+
+velox_add_library(velox_enum_define INTERFACE HEADERS EnumDefine.h)
+
+velox_add_library(velox_casts INTERFACE HEADERS Casts.h)
+
+velox_add_library(velox_scoped_registry INTERFACE HEADERS ScopedRegistry.h)
+velox_link_libraries(velox_scoped_registry INTERFACE velox_exception Folly::folly)
+
+velox_install_library_headers()
diff --git a/velox/common/Casts.h b/velox/common/Casts.h
index 013a60a3b89..8687d56c149 100644
--- a/velox/common/Casts.h
+++ b/velox/common/Casts.h
@@ -40,13 +40,13 @@ void ensureCastSucceeded(To* casted, From* original) {
 
 } // namespace detail
 
-// `checked_pointer_cast` is a dynamic casting tool to throw a Velox exception
+// `checkedPointerCast` is a dynamic casting tool to throw a Velox exception
 // when the casting failed. Use this instead of `std::dynamic_pointer_cast`
 // when:
 //   1) Casting must happen
 //   2) We want a stack trace if it failed.
 template <typename To, typename From>
-std::shared_ptr<To> checked_pointer_cast(const std::shared_ptr<From>& input) {
+std::shared_ptr<To> checkedPointerCast(const std::shared_ptr<From>& input) {
   VELOX_CHECK_NOT_NULL(input.get());
   auto casted = std::dynamic_pointer_cast<To>(input);
   detail::ensureCastSucceeded(casted.get(), input.get());
@@ -54,7 +54,7 @@ std::shared_ptr<To> checked_pointer_cast(const std::shared_ptr<From>& input) {
 }
 
 template <typename To, typename From>
-std::unique_ptr<To> checked_pointer_cast(std::unique_ptr<From> input) {
+std::unique_ptr<To> checkedPointerCast(std::unique_ptr<From> input) {
   VELOX_CHECK_NOT_NULL(input.get());
   auto* released = input.release();
   To* casted{nullptr};
@@ -69,7 +69,7 @@ std::unique_ptr<To> checked_pointer_cast(std::unique_ptr<From> input) {
 }
 
 template <typename To, typename From>
-To* checked_pointer_cast(From* input) {
+To* checkedPointerCast(From* input) {
   VELOX_CHECK_NOT_NULL(input);
   auto* casted = dynamic_cast<To*>(input);
   detail::ensureCastSucceeded(casted, input);
@@ -77,7 +77,7 @@ To* checked_pointer_cast(From* input) {
 }
 
 template <typename To, typename From>
-std::unique_ptr<To> static_unique_pointer_cast(std::unique_ptr<From> input) {
+std::unique_ptr<To> staticUniquePointerCast(std::unique_ptr<From> input) {
   VELOX_CHECK_NOT_NULL(input.get());
   auto* released = input.release();
   auto* casted = static_cast<To*>(released);
@@ -85,24 +85,23 @@ std::unique_ptr<To> static_unique_pointer_cast(std::unique_ptr<From> input) {
 }
 
 template <typename To, typename From>
-bool is_instance_of(const std::shared_ptr<From>& input) {
+bool isInstanceOf(const std::shared_ptr<From>& input) {
   VELOX_CHECK_NOT_NULL(input.get());
   auto* casted = dynamic_cast<const To*>(input.get());
   return casted != nullptr;
 }
 
 template <typename To, typename From>
-bool is_instance_of(const std::unique_ptr<From>& input) {
+bool isInstanceOf(const std::unique_ptr<From>& input) {
   VELOX_CHECK_NOT_NULL(input.get());
   auto* casted = dynamic_cast<const To*>(input.get());
   return casted != nullptr;
 }
 
 template <typename To, typename From>
-bool is_instance_of(const From* input) {
+bool isInstanceOf(const From* input) {
   VELOX_CHECK_NOT_NULL(input);
   auto* casted = dynamic_cast<const To*>(input);
   return casted != nullptr;
 }
-
 } // namespace facebook::velox
diff --git a/velox/common/EnumDeclare.h b/velox/common/EnumDeclare.h
new file mode 100644
index 00000000000..e9ea89a714d
--- /dev/null
+++ b/velox/common/EnumDeclare.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <iosfwd>
+#include <optional>
+#include <string_view>
+
+/// Lightweight declaration macros for enum-to-name mappings.
+///
+/// Include this header in .h files. Include EnumDefine.h only in .cpp files
+/// that use the DEFINE macros. EnumDefine.h pulls in heavy transitive includes
+/// (folly/F14Map.h, Exceptions.h, ~8M preprocessed) that propagate to every
+/// file that includes your header.
+///
+/// Usage:
+///
+/// In the header file, define the enum and declare its name mapping:
+///
+/// #include "velox/common/EnumDeclare.h"
+///
+/// enum class Foo {...};
+///
+/// VELOX_DECLARE_ENUM_NAME(Foo);
+///
+/// In the .cpp file, define the mapping:
+///
+/// #include "velox/common/EnumDefine.h"
+///
+/// namespace {
+/// const auto& fooNames() {
+///   static const folly::F14FastMap<Foo, std::string_view> kNames = {
+///       {Foo::kFirst, "FIRST"},
+///       {Foo::kSecond, "SECOND"},
+///        ...
+///   };
+///   return kNames;
+/// }
+/// } // namespace
+///
+/// VELOX_DEFINE_ENUM_NAME(Foo, fooNames);
+///
+/// In client code, use FooName::toName(Foo::kFirst) to get the name of the
+/// enum and FooName::toFoo("FIRST") or FooName::tryToFoo("FIRST") to get the
+/// enum value. toFoo throws an exception if the input is not a valid name,
+/// while tryToFoo returns std::nullopt.
+///
+/// Use _EMBEDDED_ versions of the macros to define enums embedded in other
+/// classes.
+
+#define VELOX_DECLARE_ENUM_NAME(EnumType)                                  \
+  struct EnumType##Name {                                                  \
+    static std::string_view toName(EnumType value);                        \
+    static EnumType to##EnumType(std::string_view name);                   \
+    static std::optional<EnumType> tryTo##EnumType(std::string_view name); \
+  };                                                                       \
+  std::ostream& operator<<(std::ostream& os, const EnumType& value);
+
+#define VELOX_DECLARE_EMBEDDED_ENUM_NAME(EnumType)     \
+  static std::string_view toName(EnumType value);      \
+  static EnumType to##EnumType(std::string_view name); \
+  static std::optional<EnumType> tryTo##EnumType(std::string_view name);
diff --git a/velox/common/Enums.h b/velox/common/EnumDefine.h
similarity index 76%
rename from velox/common/Enums.h
rename to velox/common/EnumDefine.h
index 8f844ea1b05..c883f93a5f8 100644
--- a/velox/common/Enums.h
+++ b/velox/common/EnumDefine.h
@@ -37,49 +37,9 @@ struct Enums {
 
 } // namespace facebook::velox
 
-/// Helper macros to implement bi-direction mappings between enum values and
-/// names.
+/// DEFINE macros for enum-to-name mappings. Include only in .cpp files.
 ///
-/// Usage:
-///
-/// In the header file, define the enum:
-///
-/// #include "velox/common/Enums.h"
-///
-/// enum class Foo {...};
-///
-/// VELOX_DECLARE_ENUM_NAME(Foo);
-///
-/// In the cpp file, define the mapping:
-///
-/// namespace {
-/// const auto& fooNames() {
-///   static const folly::F14FastMap<Foo, std::string_view> kNames = {
-///       {Foo::kFirst, "FIRST"},
-///       {Foo::kSecond, "SECOND"},
-///        ...
-///   };
-///   return kNames;
-/// }
-/// } // namespace
-///
-/// VELOX_DEFINE_ENUM_NAME(Foo, fooNames);
-///
-/// In the client code, use FooName::toName(Foo::kFirst) to get the name of the
-/// enum and FooName::toFoo("FIRST") or FooName::tryToFoo("FIRST") to get the
-/// enum value. toFoo throws an exception if input is not a valid name, while
-/// tryToFoo returns a std::nullopt.
-///
-/// Use _EMBEDDED_ versions of the macros to define enums embedded in other
-/// classes.
-
-#define VELOX_DECLARE_ENUM_NAME(EnumType)                                  \
-  struct EnumType##Name {                                                  \
-    static std::string_view toName(EnumType value);                        \
-    static EnumType to##EnumType(std::string_view name);                   \
-    static std::optional<EnumType> tryTo##EnumType(std::string_view name); \
-  };                                                                       \
-  std::ostream& operator<<(std::ostream& os, const EnumType& value);
+/// See EnumDeclare.h for full usage documentation and the DECLARE macros.
 
 #define VELOX_DEFINE_ENUM_NAME(EnumType, Names)                             \
   std::string_view EnumType##Name::toName(EnumType value) {                 \
@@ -113,11 +73,6 @@ struct Enums {
     return *maybeType;                                                      \
   }
 
-#define VELOX_DECLARE_EMBEDDED_ENUM_NAME(EnumType)     \
-  static std::string_view toName(EnumType value);      \
-  static EnumType to##EnumType(std::string_view name); \
-  static std::optional<EnumType> tryTo##EnumType(std::string_view name);
-
 #define VELOX_DEFINE_EMBEDDED_ENUM_NAME(Class, EnumType, Names)             \
   std::string_view Class::toName(Class::EnumType value) {                   \
     const auto& names = Names();                                            \
diff --git a/velox/common/ScopedRegistry.h b/velox/common/ScopedRegistry.h
new file mode 100644
index 00000000000..0ed1cb61582
--- /dev/null
+++ b/velox/common/ScopedRegistry.h
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "folly/Synchronized.h"
+#include "folly/container/F14Map.h"
+#include "folly/container/F14Set.h"
+#include "velox/common/base/Exceptions.h"
+
+namespace facebook::velox {
+
+/// Layered key-value registry. Lookups check the local scope first, then fall
+/// back to the parent chain. Supports arbitrary nesting (e.g., global ->
+/// session -> query). All operations are synchronized.
+///
+/// Two usage modes:
+///
+/// - Override mode (parent != nullptr): The registry inherits all entries from
+///   the parent and selectively overrides specific entries. Lookups that miss
+///   locally fall through to the parent.
+///
+/// - Isolation mode (parent == nullptr): The registry is self-contained. Only
+///   explicitly registered entries are visible.
+///
+/// Thread safety: Each scope has its own lock. Lookups and snapshots acquire
+/// locks one scope at a time while walking the parent chain. This is safe and
+/// consistent as long as parent registries are not mutated while child scopes
+/// exist. Mutations should be limited to leaf scopes (e.g., per-query
+/// overrides). Parent scopes may be freely mutated before children are created
+/// and after all children are destroyed.
+///
+/// @tparam K Key type. Must be copyable, hashable, and equality-comparable.
+/// @tparam V Value type. Stored as shared_ptr<V>.
+template <typename K, typename V>
+class ScopedRegistry {
+ public:
+  using ValuePtr = std::shared_ptr<V>;
+
+  /// Create a root registry (no parent).
+  ScopedRegistry() : parent_{nullptr} {}
+
+  /// Create a derived scope that falls back to 'parent' when a key is not
+  /// found locally. The parent must outlive this registry.
+  explicit ScopedRegistry(const ScopedRegistry* parent) : parent_{parent} {}
+
+  /// Insert an entry in the local scope. Returns true if the key was newly
+  /// inserted. Throws if the key already exists unless 'overwrite' is true,
+  /// in which case the existing entry is replaced and false is returned.
+  bool insert(K key, ValuePtr value, bool overwrite = false) {
+    return local_.withWLock([&](auto& map) {
+      auto [it, inserted] = map.emplace(std::move(key), value);
+      if (!inserted) {
+        VELOX_CHECK(overwrite, "Key already registered: {}", it->first);
+        it->second = std::move(value);
+      }
+      return inserted;
+    });
+  }
+
+  /// Look up a key. Checks local scope first, then walks the parent chain.
+  /// Returns nullptr if not found.
+  ValuePtr find(const K& key) const {
+    auto result = local_.withRLock([&](const auto& map) -> ValuePtr {
+      auto it = map.find(key);
+      return it != map.end() ? it->second : nullptr;
+    });
+    if (result) {
+      return result;
+    }
+    return parent_ ? parent_->find(key) : nullptr;
+  }
+
+  /// Remove an entry from the local scope. Returns true if the entry was
+  /// removed, false if the key was not found locally. Does not affect parent
+  /// scopes.
+  bool erase(const K& key) {
+    return local_.withWLock([&](auto& map) { return map.erase(key) > 0; });
+  }
+
+  /// Remove all entries from the local scope. Does not affect parent scopes.
+  /// Entries are moved out under the lock and destroyed outside to avoid
+  /// holding the lock during potentially slow destructors.
+  void clear() {
+    folly::F14FastMap<K, ValuePtr> entries;
+    local_.withWLock([&](auto& map) { entries.swap(map); });
+  }
+
+  /// Return a snapshot of all visible entries. Local entries take precedence
+  /// over parent entries with the same key. The snapshot is a copy — no locks
+  /// are held after this returns.
+  std::vector<std::pair<K, ValuePtr>> snapshot() const {
+    // Collect local entries.
+    std::vector<std::pair<K, ValuePtr>> result;
+    local_.withRLock([&](const auto& map) {
+      result.reserve(map.size());
+      for (const auto& [key, value] : map) {
+        result.emplace_back(key, value);
+      }
+    });
+
+    if (!parent_) {
+      return result;
+    }
+
+    // Merge parent entries, skipping keys already present locally.
+    auto parentEntries = parent_->snapshot();
+    folly::F14FastSet<K> localKeys;
+    localKeys.reserve(result.size());
+    for (const auto& [key, _] : result) {
+      localKeys.insert(key);
+    }
+    for (auto& [key, value] : parentEntries) {
+      if (!localKeys.contains(key)) {
+        result.emplace_back(std::move(key), std::move(value));
+      }
+    }
+    return result;
+  }
+
+ private:
+  folly::Synchronized<folly::F14FastMap<K, ValuePtr>> local_;
+  const ScopedRegistry* parent_;
+};
+
+} // namespace facebook::velox
diff --git a/velox/common/base/AdmissionController.cpp b/velox/common/base/AdmissionController.cpp
index c7e1b71ea5a..e1dae70a402 100644
--- a/velox/common/base/AdmissionController.cpp
+++ b/velox/common/base/AdmissionController.cpp
@@ -32,12 +32,10 @@ void AdmissionController::accept(uint64_t resourceUnits) {
   {
     std::lock_guard<std::mutex> l(mu_);
     if (unitsUsed_ + resourceUnits > config_.maxLimit) {
-      auto [unblockPromise, unblockFuture] = makeVeloxContinuePromiseContract();
       Request req;
       req.unitsRequested = resourceUnits;
-      req.promise = std::move(unblockPromise);
+      future = req.promise.getSemiFuture();
       queue_.push_back(std::move(req));
-      future = std::move(unblockFuture);
     } else {
       updatedValue = unitsUsed_ += resourceUnits;
     }
diff --git a/velox/common/base/AsyncSource.h b/velox/common/base/AsyncSource.h
index 76740dd8681..e6ff198705e 100644
--- a/velox/common/base/AsyncSource.h
+++ b/velox/common/base/AsyncSource.h
@@ -16,11 +16,14 @@
 
 #pragma once
 
+#include <fmt/core.h>
 #include <folly/Unit.h>
 #include <folly/executors/QueuedImmediateExecutor.h>
 #include <folly/futures/Future.h>
+#include <atomic>
 #include <functional>
 #include <memory>
+#include <vector>
 #include "velox/common/time/CpuWallTimer.h"
 
 #include "velox/common/base/Exceptions.h"
@@ -31,22 +34,23 @@
 
 namespace facebook::velox {
 
-// A future-like object that prefabricates Items on an executor and
-// allows consumer threads to pick items as they are ready. If the
-// consumer needs the item before the executor started making it, the
-// consumer will make it instead. If multiple consumers request the
-// same item, exactly one gets it. Propagates exceptions to the
-// consumer.
+/// A future-like object that prefabricates Items on an executor and
+/// allows consumer threads to pick items as they are ready. If the
+/// consumer needs the item before the executor started making it, the
+/// consumer will make it instead. If multiple consumers request the
+/// same item, exactly one gets it. Propagates exceptions to the
+/// consumer.
 template <typename Item>
 class AsyncSource {
  public:
-  explicit AsyncSource(std::function<std::unique_ptr<Item>()> make)
-      : make_(std::move(make)) {
+  explicit AsyncSource(std::function<std::unique_ptr<Item>()> itemMaker)
+      : itemMaker_(std::move(itemMaker)) {
+    VELOX_CHECK_NOT_NULL(itemMaker_);
     if (process::GetThreadDebugInfo() != nullptr) {
       auto* currentThreadDebugInfo = process::GetThreadDebugInfo();
       // We explicitly leave out the callback when copying the ThreadDebugInfo
       // as that may have captured state that goes out of scope by the time
-      // _make is called.
+      // itemMaker_ is called.
       threadDebugInfo_ = std::make_optional<process::ThreadDebugInfo>(
           {currentThreadDebugInfo->queryId_,
            currentThreadDebugInfo->taskId_,
@@ -55,167 +59,348 @@ class AsyncSource {
   }
 
   ~AsyncSource() {
+    const auto currentState = state();
     VELOX_CHECK(
-        moved_ || closed_,
-        "AsyncSource should be properly consumed or closed.");
+        currentState == State::kFinished || currentState == State::kCancelled ||
+            currentState == State::kFailed,
+        "AsyncSource should be properly finished, cancelled, or failed, unexpected state: {}",
+        stateName(currentState));
   }
 
-  // Makes an item if it is not already made. To be called on a background
-  // executor.
+  /// Makes an item if it is not already made. To be called on a background
+  /// executor.
   void prepare() {
     common::testutil::TestValue::adjust(
         "facebook::velox::AsyncSource::prepare", this);
-    std::function<std::unique_ptr<Item>()> make = nullptr;
+    std::function<std::unique_ptr<Item>()> itemMaker{nullptr};
     {
       std::lock_guard<std::mutex> l(mutex_);
-      if (!make_) {
+      if (state() != State::kInit) {
+        VELOX_CHECK_NULL(itemMaker_);
         return;
       }
-      making_ = true;
-      std::swap(make, make_);
-    }
-    std::unique_ptr<Item> item;
-    try {
-      CpuWallTimer timer(timing_);
-      item = runMake(make);
-    } catch (std::exception&) {
-      std::lock_guard<std::mutex> l(mutex_);
-      exception_ = std::current_exception();
-    }
-    std::unique_ptr<ContinuePromise> promise;
-    {
-      std::lock_guard<std::mutex> l(mutex_);
-      VELOX_CHECK_NULL(item_);
-      if (FOLLY_LIKELY(exception_ == nullptr)) {
-        item_ = std::move(item);
-      }
-      making_ = false;
-      promise.swap(promise_);
-    }
-    if (promise != nullptr) {
-      promise->setValue();
+      setState(State::kMaking);
+      std::swap(itemMaker, itemMaker_);
     }
+    makeItem(std::move(itemMaker));
   }
 
-  // Returns the item to the first caller and nullptr to subsequent callers.
-  // If the item is preparing on the executor, waits for the item and
-  // otherwise makes it on the caller thread.
+  /// Returns the item to the first caller and nullptr to subsequent callers.
+  /// If the item is preparing on the executor, waits for the item and
+  /// otherwise makes it on the caller thread.
   std::unique_ptr<Item> move() {
     common::testutil::TestValue::adjust(
         "facebook::velox::AsyncSource::move", this);
-    std::function<std::unique_ptr<Item>()> make = nullptr;
+    std::function<std::unique_ptr<Item>()> itemMaker{nullptr};
     ContinueFuture wait;
     {
       std::lock_guard<std::mutex> l(mutex_);
-      moved_ = true;
-      // 'making_' can be read atomically, 'exception' maybe not. So test
-      // 'making' so as not to read half-assigned 'exception_'.
-      if (!making_ && exception_) {
-        std::rethrow_exception(exception_);
-      }
-      if (item_) {
-        return std::move(item_);
-      }
-      if (promise_) {
-        // Somebody else is now waiting for the item to be made.
-        return nullptr;
-      }
-      if (making_) {
-        promise_ = std::make_unique<ContinuePromise>();
-        wait = promise_->getSemiFuture();
-      } else {
-        if (!make_) {
+      const auto currentState = state();
+      switch (currentState) {
+        case State::kFinished:
+        case State::kCancelled:
           return nullptr;
-        }
-        std::swap(make, make_);
+        case State::kFailed:
+          VELOX_CHECK_NOT_NULL(exception_);
+          std::rethrow_exception(exception_);
+        case State::kPrepared:
+          VELOX_CHECK(promises_.empty());
+          setState(State::kFinished);
+          return std::move(item_);
+        case State::kMaking:
+          VELOX_CHECK_NULL(itemMaker_);
+          VELOX_CHECK_NULL(item_);
+          if (!promises_.empty()) {
+            // Somebody else is already waiting for the item to be made.
+            return nullptr;
+          }
+          promises_.emplace_back("AsyncSource::move");
+          wait = promises_.back().getSemiFuture();
+          break;
+        case State::kInit:
+          VELOX_CHECK_NOT_NULL(itemMaker_);
+          VELOX_CHECK_NULL(item_);
+          setState(State::kMaking);
+          std::swap(itemMaker, itemMaker_);
+          break;
       }
     }
     // Outside of mutex_.
-    if (make) {
-      try {
-        return runMake(make);
-      } catch (const std::exception&) {
-        std::lock_guard<std::mutex> l(mutex_);
-        exception_ = std::current_exception();
-        throw;
-      }
+    if (itemMaker != nullptr) {
+      makeItem(std::move(itemMaker));
     }
-    auto& exec = folly::QueuedImmediateExecutor::instance();
-    std::move(wait).via(&exec).wait();
+
+    makeWait(std::move(wait));
+
     std::lock_guard<std::mutex> l(mutex_);
-    if (exception_) {
+    const auto currentState = state();
+    if (exception_ != nullptr) {
+      checkState(currentState, State::kFailed);
       std::rethrow_exception(exception_);
     }
+    if (currentState == State::kFinished) {
+      // Another move() or close() might have grabbed the item first.
+      return nullptr;
+    }
+    checkState(currentState, State::kPrepared);
+    setState(State::kFinished);
     return std::move(item_);
   }
 
-  // If true, move() will not block. But there is no guarantee that somebody
-  // else will not get the item first.
+  /// If true, move() will not block. But there is no guarantee that somebody
+  /// else will not get the item first.
   bool hasValue() const {
     tsan_lock_guard<std::mutex> l(mutex_);
     return item_ != nullptr || exception_ != nullptr;
   }
 
-  /// Returns the timing of prepare(). If the item was made on the calling
-  /// thread, the timing is 0 since only off-thread activity needs to be added
-  /// to the caller's timing.
-  const CpuWallTiming& prepareTiming() {
-    return timing_;
+  /// Returns the timing of making the item. If the item was made on the
+  /// calling thread, the timing is 0 since only off-thread activity needs to
+  /// be added to the caller's timing.
+  const CpuWallTiming& prepareTiming() const {
+    return makeTiming_;
+  }
+
+  /// Cancels the task if it hasn't started yet or if item is already prepared.
+  /// If the task is making, the task will continue but AsyncSource
+  /// is marked as cancelled to allow proper cleanup in destructor.
+  void cancel() {
+    std::lock_guard<std::mutex> l(mutex_);
+    const auto currentState = state();
+    switch (currentState) {
+      case State::kInit:
+        VELOX_CHECK_NOT_NULL(itemMaker_);
+        VELOX_CHECK_NULL(item_);
+        itemMaker_ = nullptr;
+        setState(State::kCancelled);
+        return;
+      case State::kPrepared:
+        VELOX_CHECK_NULL(itemMaker_);
+        item_ = nullptr;
+        setState(State::kCancelled);
+        return;
+      default:
+        return;
+    }
   }
 
   /// This function assists the caller in ensuring that resources allocated in
   /// AsyncSource are promptly released:
-  /// 1. Waits for the completion of the 'make_' function if it is executing
-  /// in the thread pool.
-  /// 2. Resets the 'make_' function if it has not started yet.
-  /// 3. Cleans up the 'item_' if 'make_' has completed, but the result
+  /// 1. Waits for the completion of the 'itemMaker_' function if it is
+  /// executing in the thread pool.
+  /// 2. Resets the 'itemMaker_' function if it has not started yet.
+  /// 3. Cleans up the 'item_' if 'itemMaker_' has completed, but the result
   /// 'item_' has not been returned to the caller.
   void close() {
-    if (closed_ || moved_) {
+    auto currentState = state();
+    if (currentState == State::kFinished || currentState == State::kFailed ||
+        currentState == State::kCancelled) {
       return;
     }
     ContinueFuture wait;
     {
       std::lock_guard<std::mutex> l(mutex_);
-      if (making_) {
-        promise_ = std::make_unique<ContinuePromise>();
-        wait = promise_->getSemiFuture();
-      } else if (make_) {
-        make_ = nullptr;
+      if (tryCloseLocked()) {
+        return;
       }
+      checkState(state(), State::kMaking);
+      promises_.emplace_back("AsyncSource::close");
+      wait = promises_.back().getSemiFuture();
     }
 
-    auto& exec = folly::QueuedImmediateExecutor::instance();
-    std::move(wait).via(&exec).wait();
+    makeWait(std::move(wait));
+
     {
       std::lock_guard<std::mutex> l(mutex_);
-      if (item_) {
-        item_ = nullptr;
-      }
-      closed_ = true;
+      const auto closed = tryCloseLocked();
+      VELOX_CHECK(closed, "Unexpected close failure");
     }
   }
 
  private:
-  std::unique_ptr<Item> runMake(std::function<std::unique_ptr<Item>()>& make) {
-    process::ScopedThreadDebugInfo threadDebugInfo(
-        threadDebugInfo_.has_value() ? &threadDebugInfo_.value() : nullptr);
-    return make();
+  // State transition diagram:
+  //
+  //     ┌───────┐   prepare()   ┌─────────┐   success   ┌──────────┐
+  //     │ kInit │ ────────────► │ kMaking │ ──────────► │kPrepared │
+  //     └───────┘    move()     └─────────┘             └──────────┘
+  //       │   │                      │                     │    │
+  //       │   │ close()              │ exception           │    │ cancel()
+  //       │   │                      ▼                     │    │
+  //       │   │                ┌──────────┐   move()       │    │
+  //       │   │                │ kFailed  │   close()      │    │
+  //       │   │                └──────────┘                │    │
+  //       │   │                                            │    │
+  //       │   └──────────────────────┬─────────────────────┘    │
+  //       │                          ▼                          │
+  //       │ cancel()           ┌───────────┐                    │
+  //       │                    │ kFinished │                    │
+  //       │                    └───────────┘                    │
+  //       │                                                     │
+  //       └──────────────────────────┬──────────────────────────┘
+  //                                  ▼
+  //                            ┌───────────┐
+  //                            │kCancelled │
+  //                            └───────────┘
+  //
+  enum class State : uint8_t {
+    // Initial state before prepare() or move() is called.
+    kInit = 0,
+    // prepare() is executing.
+    kMaking = 1,
+    // prepare() has completed and item is ready.
+    kPrepared = 2,
+    // prepare() has failed with an exception.
+    kFailed = 3,
+    // move() or close() has been called and the AsyncSource is finished.
+    kFinished = 4,
+    // cancel() has been called.
+    kCancelled = 5,
+  };
+
+  State state() const {
+    return state_.load(std::memory_order_acquire);
+  }
+
+  static std::string stateName(State state) {
+    switch (state) {
+      case State::kInit:
+        return "INIT";
+      case State::kMaking:
+        return "MAKING";
+      case State::kPrepared:
+        return "PREPARED";
+      case State::kFailed:
+        return "FAILED";
+      case State::kFinished:
+        return "FINISHED";
+      case State::kCancelled:
+        return "CANCELLED";
+      default:
+        VELOX_UNREACHABLE("Unknown state: {}", static_cast<int>(state));
+    }
+  }
+
+  inline void checkState(State actualState, State expectedState) const {
+    VELOX_CHECK(
+        actualState == expectedState,
+        "Unexpected state: {}, expected: {}",
+        stateName(actualState),
+        stateName(expectedState));
+  }
+
+  inline void setState(State newState) {
+    const auto oldState = state();
+    VELOX_CHECK(
+        isValidStateTransition(oldState, newState),
+        "Invalid state transition from {} to {}",
+        stateName(oldState),
+        stateName(newState));
+    state_.store(newState, std::memory_order_release);
+  }
+
+  static bool isValidStateTransition(State oldState, State newState) {
+    switch (oldState) {
+      case State::kInit:
+        return newState == State::kMaking || newState == State::kFinished ||
+            newState == State::kCancelled;
+      case State::kMaking:
+        return newState == State::kPrepared || newState == State::kFailed;
+      case State::kPrepared:
+        return newState == State::kFinished || newState == State::kCancelled;
+      case State::kFailed:
+      case State::kFinished:
+      case State::kCancelled:
+        return false;
+      default:
+        VELOX_UNREACHABLE("Unknown state: {}", stateName(oldState));
+    }
+  }
+
+  // Makes item with timing, handles exceptions, state transitions, and promise
+  // signaling.
+  void makeItem(std::function<std::unique_ptr<Item>()>&& itemMaker) {
+    VELOX_CHECK_NOT_NULL(itemMaker);
+    std::unique_ptr<Item> item;
+    std::exception_ptr exceptionPtr;
+    try {
+      CpuWallTimer timer(makeTiming_);
+      process::ScopedThreadDebugInfo threadDebugInfo(
+          threadDebugInfo_.has_value() ? &threadDebugInfo_.value() : nullptr);
+      item = itemMaker();
+    } catch (std::exception&) {
+      exceptionPtr = std::current_exception();
+    }
+
+    std::vector<ContinuePromise> promises;
+    {
+      std::lock_guard<std::mutex> l(mutex_);
+      VELOX_CHECK_NULL(item_);
+      VELOX_CHECK_NULL(itemMaker_);
+      checkState(state(), State::kMaking);
+      if (FOLLY_LIKELY(exceptionPtr == nullptr)) {
+        item_ = std::move(item);
+        setState(State::kPrepared);
+      } else {
+        setExceptionLocked(std::move(exceptionPtr));
+      }
+      promises.swap(promises_);
+    }
+    for (auto& promise : promises) {
+      promise.setValue();
+    }
   }
 
-  // Stored context (if present upon construction) so they can be restored when
-  // make_ is invoked.
+  inline void setExceptionLocked(std::exception_ptr exception) {
+    VELOX_CHECK_NULL(exception_);
+    exception_ = std::move(exception);
+    setState(State::kFailed);
+  }
+
+  // Waits for the promise to be fulfilled and injects a TestValue for testing
+  // race conditions.
+  inline void makeWait(ContinueFuture&& wait) {
+    common::testutil::TestValue::adjust(
+        "facebook::velox::AsyncSource::makeWait", this);
+    auto& exec = folly::QueuedImmediateExecutor::instance();
+    std::move(wait).via(&exec).wait();
+  }
+
+  // Attempts to close immediately while holding the lock. Returns true if
+  // close completed, false if caller needs to wait for making to complete.
+  inline bool tryCloseLocked() {
+    const auto currentState = state();
+    switch (currentState) {
+      case State::kInit:
+        VELOX_CHECK_NOT_NULL(itemMaker_);
+        VELOX_CHECK_NULL(item_);
+        itemMaker_ = nullptr;
+        setState(State::kFinished);
+        return true;
+      case State::kPrepared:
+        VELOX_CHECK_NULL(itemMaker_);
+        item_ = nullptr;
+        setState(State::kFinished);
+        return true;
+      case State::kMaking:
+        return false;
+      default:
+        VELOX_CHECK_NULL(itemMaker_);
+        VELOX_CHECK_NULL(item_);
+        return true;
+    }
+  }
+
+  // Stored context (if present upon construction) so they can be restored
+  // when itemMaker_ is invoked.
   std::optional<process::ThreadDebugInfo> threadDebugInfo_;
 
+  std::atomic<State> state_{State::kInit};
+  CpuWallTiming makeTiming_;
   mutable std::mutex mutex_;
-  // True if 'prepare() is making the item.
-  bool making_{false};
-  std::unique_ptr<ContinuePromise> promise_;
+  std::vector<ContinuePromise> promises_;
   std::unique_ptr<Item> item_;
-  std::function<std::unique_ptr<Item>()> make_;
+  std::function<std::unique_ptr<Item>()> itemMaker_;
   std::exception_ptr exception_;
-  CpuWallTiming timing_;
-  bool closed_{false};
-  bool moved_{false};
 };
+
 } // namespace facebook::velox
diff --git a/velox/common/base/BigintIdMap.h b/velox/common/base/BigintIdMap.h
index e63445f4d12..97d3abfdb51 100644
--- a/velox/common/base/BigintIdMap.h
+++ b/velox/common/base/BigintIdMap.h
@@ -31,8 +31,10 @@ class BigintIdMap {
   static constexpr int64_t kMaxCapacity = 1 << 30; // 1G entries, 12GB
 
   BigintIdMap(int32_t capacity, memory::MemoryPool& pool) : pool_(pool) {
-    makeTable(std::max<int32_t>(
-        2 * sizeof(xsimd::batch<int64_t, A>), bits::nextPowerOfTwo(capacity)));
+    makeTable(
+        std::max<int32_t>(
+            2 * sizeof(xsimd::batch<int64_t, A>),
+            bits::nextPowerOfTwo(capacity)));
   }
 
   BigintIdMap(const BigintIdMap& other) = delete;
diff --git a/velox/common/base/BitUtil.cpp b/velox/common/base/BitUtil.cpp
index 686bce02b1a..82aa286719c 100644
--- a/velox/common/base/BitUtil.cpp
+++ b/velox/common/base/BitUtil.cpp
@@ -219,4 +219,102 @@ uint64_t hashBytes(uint64_t seed, const char* data, size_t size) {
   }
   return a0 ^ ((a1 * kMul)) ^ (a2 * kMul);
 }
+
+void packBitmap(std::span<const bool> bools, char* bitmap) {
+  uint64_t* word = reinterpret_cast<uint64_t*>(bitmap);
+  const uint64_t loopCount = bools.size() >> 6;
+  const uint64_t remainder = bools.size() - (loopCount << 6);
+  const bool* rawBools = bools.data();
+  for (uint64_t i = 0; i < loopCount; ++i) {
+    for (int j = 0; j < 64; ++j) {
+      *word |= static_cast<uint64_t>(*rawBools++) << j;
+    }
+    ++word;
+  }
+  for (int j = 0; j < remainder; ++j) {
+    *word |= static_cast<uint64_t>(*rawBools++) << j;
+  }
+}
+
+uint32_t
+findSetBit(const char* bitmap, uint32_t begin, uint32_t end, uint32_t n) {
+  if (begin >= end || n == 0) {
+    return begin;
+  }
+
+  const uint64_t* wordPtr = reinterpret_cast<const uint64_t*>(bitmap);
+
+  // Handle bits in the first partial word
+  uint32_t wordIdx = begin >> 6;
+  uint32_t bitOffset = begin & 63;
+  uint64_t word = wordPtr[wordIdx];
+
+  // Mask out bits before 'begin'
+  word &= ~((1ULL << bitOffset) - 1);
+
+  while (true) {
+    // Count set bits in current word
+    uint32_t setBitsInWord = __builtin_popcountll(word);
+
+    if (setBitsInWord >= n) {
+      // The n'th set bit is in this word
+      while (n > 0) {
+        uint32_t firstSetBit = __builtin_ffsll(static_cast<long long>(word));
+        if (firstSetBit == 0) {
+          break; // No more set bits
+        }
+
+        // __builtin_ffsll returns the index plus one, so subtract 1
+        --firstSetBit;
+
+        word &= ~(1ULL << firstSetBit);
+        --n;
+
+        if (n == 0) {
+          uint32_t result = (wordIdx << 6) + firstSetBit;
+          return result < end ? result : end;
+        }
+      }
+    }
+
+    // Move to next word
+    n -= setBitsInWord;
+    ++wordIdx;
+    bitOffset = 0;
+
+    // Check if we've reached the end
+    uint32_t nextWordStart = wordIdx << 6;
+    if (nextWordStart >= end) {
+      return end;
+    }
+
+    word = wordPtr[wordIdx];
+
+    // Mask out bits beyond 'end' if this is the last word
+    if (nextWordStart + 64 > end) {
+      word &= (1ULL << (end - nextWordStart)) - 1;
+    }
+
+    // If no bits set in this word, continue to next word
+    if (word == 0) {
+      continue;
+    }
+  }
+}
+
+void BitmapBuilder::copy(const Bitmap& other, uint32_t begin, uint32_t end) {
+  auto source = static_cast<const char*>(other.bits());
+  auto dest = static_cast<char*>(bitmap_);
+  auto firstByte = begin / 8;
+  if (begin % 8) {
+    uint8_t mask = (1 << (begin % 8)) - 1;
+    dest[firstByte] = static_cast<char>(
+        (dest[firstByte] & mask) | (source[firstByte] & ~mask));
+    ++firstByte;
+  }
+  // @lint-ignore CLANGSECURITY facebook-security-vulnerable-memcpy
+  std::memcpy(
+      dest + firstByte, source + firstByte, bits::nbytes(end) - firstByte);
+}
+
 } // namespace facebook::velox::bits
diff --git a/velox/common/base/BitUtil.h b/velox/common/base/BitUtil.h
index 3257cbe4b0f..164c4b85cd4 100644
--- a/velox/common/base/BitUtil.h
+++ b/velox/common/base/BitUtil.h
@@ -24,6 +24,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
+#include <span>
 #include <string>
 
 #ifdef __BMI2__
@@ -94,6 +95,14 @@ inline void setBit(T* bits, uint64_t idx, bool value) {
   value ? setBit(bits, idx) : clearBit(bits, idx);
 }
 
+/// Branchless: sets the bit at idx if value is true, no-op if false.
+/// Assumes target memory is pre-zeroed for unset bits.
+template <typename T>
+inline void maybeSetBit(T* bits, uint64_t idx, bool value) {
+  auto* bitsAs8Bit = reinterpret_cast<uint8_t*>(bits);
+  bitsAs8Bit[idx / 8] |= (static_cast<uint8_t>(value) << (idx % 8));
+}
+
 inline void negateBit(void* bits, uint64_t idx) {
   auto* bitsAs8Bit = reinterpret_cast<uint8_t*>(bits);
   bitsAs8Bit[idx / 8] ^= (1 << (idx % 8));
@@ -125,7 +134,7 @@ constexpr inline T divRoundUp(T value, U factor) {
 }
 
 constexpr inline uint64_t lowMask(int32_t bits) {
-  return (1UL << bits) - 1;
+  return (1ULL << bits) - 1;
 }
 
 constexpr inline uint64_t highMask(int32_t bits) {
@@ -753,7 +762,7 @@ inline uint64_t nextPowerOfTwo(uint64_t size) {
   return 2 * lower;
 }
 
-inline bool isPowerOfTwo(uint64_t size) {
+constexpr bool isPowerOfTwo(uint64_t size) {
   return (size & (size - 1)) == 0;
 }
 
@@ -1027,6 +1036,100 @@ void storeBitsToByte(uint8_t bits, uint8_t* bytes, unsigned index) {
   }
 }
 
+/// Returns the number of bits required to store the value.
+/// For a value of 0, returns 1.
+inline int bitsRequired(uint64_t value) noexcept {
+  return 64 - __builtin_clzll(value | 1);
+}
+
+/// Packs bools into bitmap. bitmap must point to a region large enough.
+/// Does not clear bitmap first — bit i is set if bools[i] is true OR
+/// bit i was already set.
+void packBitmap(std::span<const bool> bools, char* bitmap);
+
+/// Finds the index of the n'th set bit in [begin, end) in bitmap.
+/// Returns end if not found. Returns begin if begin >= end or n == 0.
+uint32_t
+findSetBit(const char* bitmap, uint32_t begin, uint32_t end, uint32_t n);
+
+/// Debug: prints bits of a numeric type in nibble groups.
+template <typename T>
+std::string printBits(T c) {
+  std::string result;
+  for (int i = 0; i < (sizeof(T) << 3); ++i) {
+    if (i > 0 && i % 4 == 0) {
+      result += ' ';
+    }
+    if (c & 1) {
+      result += '1';
+    } else {
+      result += '0';
+    }
+    c >>= 1;
+  }
+  // We actually want little endian order.
+  std::reverse(result.begin(), result.end());
+  return result;
+}
+
+/// Read-only view over a bitmap stored as char*.
+class Bitmap {
+ public:
+  Bitmap(const void* bitmap, uint32_t size)
+      : bitmap_{static_cast<char*>(const_cast<void*>(bitmap))}, size_{size} {}
+
+  bool test(uint32_t pos) const {
+    return isBitSet(reinterpret_cast<const uint8_t*>(bitmap_), pos);
+  }
+
+  uint32_t size() const {
+    return size_;
+  }
+
+  const void* bits() const {
+    return bitmap_;
+  }
+
+ protected:
+  char* bitmap_;
+  uint32_t size_;
+};
+
+/// Mutable bitmap builder.
+class BitmapBuilder : public Bitmap {
+ public:
+  BitmapBuilder(void* bitmap, uint32_t size) : Bitmap{bitmap, size} {}
+
+  void set(uint32_t pos) {
+    setBit(reinterpret_cast<uint8_t*>(bitmap_), pos);
+  }
+
+  void maybeSet(uint32_t pos, bool bit) {
+    maybeSetBit(bitmap_, pos, bit);
+  }
+
+  void set(uint32_t begin, uint32_t end) {
+    fillBits(
+        reinterpret_cast<uint64_t*>(bitmap_),
+        static_cast<int32_t>(begin),
+        static_cast<int32_t>(end),
+        true);
+  }
+
+  void clear(uint32_t begin, uint32_t end) {
+    fillBits(
+        reinterpret_cast<uint64_t*>(bitmap_),
+        static_cast<int32_t>(begin),
+        static_cast<int32_t>(end),
+        false);
+  }
+
+  /// Copy the specified range from the source bitmap into this one. It
+  /// guarantees |begin| is the beginning bit offset, but may copy more beyond
+  /// |end|.
+  void copy(const Bitmap& other, uint32_t begin, uint32_t end);
+};
+
 } // namespace bits
 } // namespace velox
 } // namespace facebook
diff --git a/velox/common/base/BloomFilter.h b/velox/common/base/BloomFilter.h
index 6fab5a4376c..73c421442f9 100644
--- a/velox/common/base/BloomFilter.h
+++ b/velox/common/base/BloomFilter.h
@@ -80,6 +80,7 @@ class BloomFilter {
     auto version = stream.read<int8_t>();
     VELOX_USER_CHECK_EQ(kBloomFilterV1, version);
     auto size = stream.read<int32_t>();
+    VELOX_CHECK_GE(size, 0, "Invalid BloomFilter size: {}", size);
     bits_.resize(size);
     auto bitsdata =
         reinterpret_cast<const uint64_t*>(serialized + stream.offset());
@@ -110,6 +111,34 @@ class BloomFilter {
     }
   }
 
+  /// Computes m (total bits of Bloom filter) which is expected to achieve,
+  /// for the specified expected insertions, the required false positive
+  /// probability.
+  ///
+  /// See
+  /// http://en.wikipedia.org/wiki/Bloom_filter#Probability_of_false_positives
+  /// for the formula.
+  ///
+  /// @param n expected insertions (must be positive).
+  /// @param p false positive rate (must be 0 < p < 1).
+  static int64_t optimalNumOfBits(int64_t n, double p) {
+    return static_cast<int64_t>(
+        -n * std::log(p) / (std::log(2.0) * std::log(2.0)));
+  }
+
+  /// Computes m (total bits of Bloom filter) which is expected to achieve.
+  /// The smaller the expectedNumItems, the smaller the fpp.
+  ///
+  /// @param expectedNumItems expected number of items to insert.
+  /// @param maxNumItems maximum number of items.
+  static int64_t optimalNumOfBits(
+      int64_t expectedNumItems,
+      int64_t maxNumItems) {
+    double ratio = static_cast<double>(expectedNumItems) / maxNumItems;
+    double fpp = kDefaultFpp * std::min(ratio, 1.0);
+    return optimalNumOfBits(expectedNumItems, fpp);
+  }
+
  private:
   // We use 4 independent hash functions by taking 24 bits of
   // the hash code and breaking these up into 4 groups of 6 bits. Each group
@@ -142,6 +171,8 @@ class BloomFilter {
   }
 
   static constexpr int8_t kBloomFilterV1 = 1;
+  static constexpr double kDefaultFpp = 0.03;
+
   std::vector<uint64_t, Allocator> bits_;
 };
 
diff --git a/velox/common/base/CMakeLists.txt b/velox/common/base/CMakeLists.txt
index b93691f67fe..c158ea872b5 100644
--- a/velox/common/base/CMakeLists.txt
+++ b/velox/common/base/CMakeLists.txt
@@ -12,7 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_exception Exceptions.cpp VeloxException.cpp Exceptions.h)
+velox_add_library(
+  velox_exception
+  Exceptions.cpp
+  VeloxException.cpp
+  Exceptions.h
+  HEADERS
+  FmtStdFormatters.h
+  VeloxException.h
+)
 velox_link_libraries(
   velox_exception
   PUBLIC velox_flag_definitions velox_process Folly::folly fmt::fmt gflags::gflags glog::glog
@@ -30,10 +38,47 @@ velox_add_library(
   SimdUtil.cpp
   SkewedPartitionBalancer.cpp
   SpillConfig.cpp
-  SpillStats.cpp
+  SplitBlockBloomFilter.cpp
   StatsReporter.cpp
   SuccinctPrinter.cpp
-  TraceConfig.cpp
+  HEADERS
+  AdmissionController.h
+  BitSet.h
+  BitUtil.h
+  BloomFilter.h
+  CheckedArithmetic.h
+  ClassName.h
+  CoalesceIo.h
+  ConcurrentCounter.h
+  CountBits.h
+  Counters.h
+  Crc.h
+  Doubles.h
+  Fs.h
+  GTestMacros.h
+  IOUtils.h
+  IndexedPriorityQueue.h
+  Nulls.h
+  PeriodicStatsReporter.h
+  Pointers.h
+  Portability.h
+  PrefixSortConfig.h
+  RandomUtil.h
+  Range.h
+  RuntimeMetrics.h
+  ScopedLock.h
+  SelectivityInfo.h
+  Semaphore.h
+  SimdUtil-inl.h
+  SimdUtil.h
+  SkewedPartitionBalancer.h
+  SortingNetwork.h
+  SpillConfig.h
+  SplitBlockBloomFilter.h
+  StatsReporter.h
+  SuccinctPrinter.h
+  TreeOfLosers.h
+  XxHashInline.h
 )
 
 velox_link_libraries(
@@ -50,7 +95,7 @@ if(${VELOX_ENABLE_BENCHMARKS})
   add_subdirectory(benchmarks)
 endif()
 
-velox_add_library(velox_id_map BigintIdMap.cpp)
+velox_add_library(velox_id_map BigintIdMap.cpp HEADERS BigintIdMap.h)
 velox_link_libraries(
   velox_id_map
   velox_memory
@@ -61,5 +106,15 @@ velox_link_libraries(
   fmt::fmt
 )
 
-velox_add_library(velox_status Status.cpp)
+velox_add_library(velox_status Status.cpp HEADERS Status.h)
 velox_link_libraries(velox_status PUBLIC fmt::fmt Folly::folly PRIVATE glog::glog)
+
+velox_add_library(velox_compare_flags INTERFACE HEADERS CompareFlags.h)
+
+velox_add_library(velox_macros INTERFACE HEADERS Macros.h)
+
+velox_add_library(velox_async_source INTERFACE HEADERS AsyncSource.h)
+
+velox_add_library(velox_lazy_cpu_thread_pool_executor INTERFACE HEADERS LazyCPUThreadPoolExecutor.h)
+
+velox_add_library(velox_exception_helper INTERFACE HEADERS ExceptionHelper.h)
diff --git a/velox/common/base/CoalesceIo.h b/velox/common/base/CoalesceIo.h
index f5f58ba1092..7ad405cf290 100644
--- a/velox/common/base/CoalesceIo.h
+++ b/velox/common/base/CoalesceIo.h
@@ -65,14 +65,13 @@ CoalesceIoStats coalesceIo(
     AddRanges addRanges,
     SkipRange skipRange,
     IoFunc ioFunc) {
-  std::vector<Range> buffers;
   int32_t startItem = 0;
   auto startOffset = offsetFunc(startItem);
   auto lastEndOffset = startOffset;
   std::vector<Range> ranges;
   CoalesceIoStats result;
   for (int32_t i = 0; i < items.size(); ++i) {
-    auto& item = items[i];
+    const auto& item = items[i];
     const auto itemOffset = offsetFunc(i);
     const auto itemSize = sizeFunc(i);
     result.payloadBytes += itemSize;
diff --git a/velox/common/base/CompareFlags.h b/velox/common/base/CompareFlags.h
index 705c1ed8729..f7873ab330d 100644
--- a/velox/common/base/CompareFlags.h
+++ b/velox/common/base/CompareFlags.h
@@ -84,7 +84,7 @@ struct CompareFlags {
     ///       ex: (null, 1) = (null, 1) is indeterminate.
     ///
     ///       - If all fields compare results are true, then result is true.
-    ///       ex: (1, 1) = (1, 1) is indeterminate.
+    ///       ex: (1, 1) = (1, 1) is true.
     ///
     ///   4. Maps:
     ///     - Keys are compared first, if keys are not equal values are not
diff --git a/velox/common/base/ConcurrentCounter.h b/velox/common/base/ConcurrentCounter.h
index 689c91d1525..5fd16f9771d 100644
--- a/velox/common/base/ConcurrentCounter.h
+++ b/velox/common/base/ConcurrentCounter.h
@@ -19,6 +19,7 @@
 #include <stddef.h>
 #include <stdint.h>
 #include <new>
+#include <thread>
 
 #include "velox/common/base/BitUtil.h"
 #include "velox/common/base/Exceptions.h"
diff --git a/velox/common/base/CountBits.h b/velox/common/base/CountBits.h
index b267d2f636e..f40fb95355e 100644
--- a/velox/common/base/CountBits.h
+++ b/velox/common/base/CountBits.h
@@ -16,6 +16,8 @@
 
 #pragma once
 
+#include <folly/CPortability.h>
+
 namespace facebook::velox {
 
 // Copied from format.h of fmt.
diff --git a/velox/common/base/Counters.cpp b/velox/common/base/Counters.cpp
index d3353656789..6e88aa653e8 100644
--- a/velox/common/base/Counters.cpp
+++ b/velox/common/base/Counters.cpp
@@ -45,6 +45,9 @@ void registerVeloxMetrics() {
   DEFINE_HISTOGRAM_METRIC(
       kMetricTaskBarrierProcessTimeMs, 1'000, 0, 30'000, 50, 90, 99, 100);
 
+  // Tracks the total number of splits received by all tasks.
+  DEFINE_METRIC(kMetricTaskSplitsCount, facebook::velox::StatType::COUNT);
+
   /// ================== Cache Counters =================
 
   // Tracks hive handle generation latency in range of [0, 100s] and reports
@@ -107,8 +110,13 @@ void registerVeloxMetrics() {
   // was opened to load the cache.
   DEFINE_METRIC(kMetricCacheMaxAgeSecs, facebook::velox::StatType::AVG);
 
-  // Total number of cache entries.
-  DEFINE_METRIC(kMetricMemoryCacheNumEntries, facebook::velox::StatType::AVG);
+  // Total number of tiny cache entries.
+  DEFINE_METRIC(
+      kMetricMemoryCacheNumTinyEntries, facebook::velox::StatType::AVG);
+
+  // Total number of large cache entries.
+  DEFINE_METRIC(
+      kMetricMemoryCacheNumLargeEntries, facebook::velox::StatType::AVG);
 
   // Total number of cache entries that do not cache anything.
   DEFINE_METRIC(
@@ -249,6 +257,10 @@ void registerVeloxMetrics() {
   // Total number of error while writing to SSD cache files.
   DEFINE_METRIC(kMetricSsdCacheWriteSsdErrors, facebook::velox::StatType::SUM);
 
+  // Total number of errors due to SSD no space for writes.
+  DEFINE_METRIC(
+      kMetricSsdCacheWriteNoSpaceErrors, facebook::velox::StatType::SUM);
+
   // Total number of errors while writing SSD checkpoint file.
   DEFINE_METRIC(
       kMetricSsdCacheWriteCheckpointErrors, facebook::velox::StatType::SUM);
@@ -256,6 +268,10 @@ void registerVeloxMetrics() {
   // Total number of writes dropped due to no cache space.
   DEFINE_METRIC(kMetricSsdCacheWriteSsdDropped, facebook::velox::StatType::SUM);
 
+  // Total number of writes dropped due to entry limit exceeded.
+  DEFINE_METRIC(
+      kMetricSsdCacheWriteExceedEntryLimit, facebook::velox::StatType::SUM);
+
   // Total number of errors while reading from SSD cache files.
   DEFINE_METRIC(kMetricSsdCacheReadSsdErrors, facebook::velox::StatType::SUM);
 
@@ -365,9 +381,6 @@ void registerVeloxMetrics() {
       kMetricTaskMemoryReclaimWaitTimeoutCount,
       facebook::velox::StatType::COUNT);
 
-  // Tracks the total number of splits received by all tasks.
-  DEFINE_METRIC(kMetricTaskSplitsCount, facebook::velox::StatType::COUNT);
-
   // The number of times that the memory reclaim fails because the operator is
   // executing a non-reclaimable section where it is expected to have reserved
   // enough memory to execute without asking for more. Therefore, it is an
@@ -644,6 +657,10 @@ void registerVeloxMetrics() {
   DEFINE_HISTOGRAM_METRIC(
       kMetricIndexLookupBlockedWaitTimeMs, 32, 0, 16L << 10, 50, 90, 99, 100);
 
+  // The number of index lookup results with error.
+  DEFINE_METRIC(
+      kMetricIndexLookupErrorResultCount, facebook::velox::StatType::COUNT);
+
   /// ================== Table Scan Counters =================
   // Tracks the averaged table scan batch processing time in milliseconds.
   DEFINE_METRIC(
diff --git a/velox/common/base/Counters.h b/velox/common/base/Counters.h
index a936a871546..3a144f1bc88 100644
--- a/velox/common/base/Counters.h
+++ b/velox/common/base/Counters.h
@@ -23,373 +23,374 @@ namespace facebook::velox {
 /// Velox metrics Registration.
 void registerVeloxMetrics();
 
-constexpr folly::StringPiece kMetricHiveFileHandleGenerateLatencyMs{
+constexpr std::string_view kMetricHiveFileHandleGenerateLatencyMs{
     "velox.hive_file_handle_generate_latency_ms"};
 
-constexpr folly::StringPiece kMetricCacheShrinkCount{
-    "velox.cache_shrink_count"};
+constexpr std::string_view kMetricCacheShrinkCount{"velox.cache_shrink_count"};
 
-constexpr folly::StringPiece kMetricCacheShrinkTimeMs{"velox.cache_shrink_ms"};
+constexpr std::string_view kMetricCacheShrinkTimeMs{"velox.cache_shrink_ms"};
 
-constexpr folly::StringPiece kMetricMaxSpillLevelExceededCount{
+constexpr std::string_view kMetricMaxSpillLevelExceededCount{
     "velox.spill_max_level_exceeded_count"};
 
-constexpr folly::StringPiece kMetricQueryMemoryReclaimTimeMs{
+constexpr std::string_view kMetricQueryMemoryReclaimTimeMs{
     "velox.query_memory_reclaim_time_ms"};
 
-constexpr folly::StringPiece kMetricQueryMemoryReclaimedBytes{
+constexpr std::string_view kMetricQueryMemoryReclaimedBytes{
     "velox.query_memory_reclaim_bytes"};
 
-constexpr folly::StringPiece kMetricQueryMemoryReclaimCount{
+constexpr std::string_view kMetricQueryMemoryReclaimCount{
     "velox.query_memory_reclaim_count"};
 
-constexpr folly::StringPiece kMetricTaskMemoryReclaimCount{
+constexpr std::string_view kMetricTaskMemoryReclaimCount{
     "velox.task_memory_reclaim_count"};
 
-constexpr folly::StringPiece kMetricTaskMemoryReclaimWaitTimeMs{
+constexpr std::string_view kMetricTaskMemoryReclaimWaitTimeMs{
     "velox.task_memory_reclaim_wait_ms"};
 
-constexpr folly::StringPiece kMetricTaskMemoryReclaimExecTimeMs{
+constexpr std::string_view kMetricTaskMemoryReclaimExecTimeMs{
     "velox.task_memory_reclaim_exec_ms"};
 
-constexpr folly::StringPiece kMetricTaskMemoryReclaimWaitTimeoutCount{
+constexpr std::string_view kMetricTaskMemoryReclaimWaitTimeoutCount{
     "velox.task_memory_reclaim_wait_timeout_count"};
 
-constexpr folly::StringPiece kMetricTaskSplitsCount{"velox.task_splits_count"};
+constexpr std::string_view kMetricTaskSplitsCount{"velox.task_splits_count"};
 
-constexpr folly::StringPiece kMetricOpMemoryReclaimTimeMs{
+constexpr std::string_view kMetricOpMemoryReclaimTimeMs{
     "velox.op_memory_reclaim_time_ms"};
 
-constexpr folly::StringPiece kMetricOpMemoryReclaimedBytes{
+constexpr std::string_view kMetricOpMemoryReclaimedBytes{
     "velox.op_memory_reclaim_bytes"};
 
-constexpr folly::StringPiece kMetricOpMemoryReclaimCount{
+constexpr std::string_view kMetricOpMemoryReclaimCount{
     "velox.op_memory_reclaim_count"};
 
-constexpr folly::StringPiece kMetricMemoryNonReclaimableCount{
+constexpr std::string_view kMetricMemoryNonReclaimableCount{
     "velox.memory_non_reclaimable_count"};
 
-constexpr folly::StringPiece kMetricMemoryPoolInitialCapacityBytes{
+constexpr std::string_view kMetricMemoryPoolInitialCapacityBytes{
     "velox.memory_pool_initial_capacity_bytes"};
 
-constexpr folly::StringPiece kMetricMemoryPoolCapacityGrowCount{
+constexpr std::string_view kMetricMemoryPoolCapacityGrowCount{
     "velox.memory_pool_capacity_growth_count"};
 
-constexpr folly::StringPiece kMetricMemoryPoolUsageLeakBytes{
+constexpr std::string_view kMetricMemoryPoolUsageLeakBytes{
     "velox.memory_pool_usage_leak_bytes"};
 
-constexpr folly::StringPiece kMetricMemoryPoolReservationLeakBytes{
+constexpr std::string_view kMetricMemoryPoolReservationLeakBytes{
     "velox.memory_pool_reservation_leak_bytes"};
 
-constexpr folly::StringPiece kMetricMemoryAllocatorDoubleFreeCount{
+constexpr std::string_view kMetricMemoryAllocatorDoubleFreeCount{
     "velox.memory_allocator_double_free_count"};
 
-constexpr folly::StringPiece kMetricArbitratorLocalArbitrationCount{
+constexpr std::string_view kMetricArbitratorLocalArbitrationCount{
     "velox.arbitrator_local_arbitration_count"};
 
-constexpr folly::StringPiece kMetricArbitratorGlobalArbitrationCount{
+constexpr std::string_view kMetricArbitratorGlobalArbitrationCount{
     "velox.arbitrator_global_arbitration_count"};
 
-constexpr folly::StringPiece
-    kMetricArbitratorGlobalArbitrationNumReclaimVictims{
-        "velox.arbitrator_global_arbitration_num_reclaim_victims"};
+constexpr std::string_view kMetricArbitratorGlobalArbitrationNumReclaimVictims{
+    "velox.arbitrator_global_arbitration_num_reclaim_victims"};
 
-constexpr folly::StringPiece
-    kMetricArbitratorGlobalArbitrationFailedVictimCount{
-        "velox.arbitrator_global_arbitration_failed_victim_count"};
+constexpr std::string_view kMetricArbitratorGlobalArbitrationFailedVictimCount{
+    "velox.arbitrator_global_arbitration_failed_victim_count"};
 
-constexpr folly::StringPiece kMetricArbitratorGlobalArbitrationBytes{
+constexpr std::string_view kMetricArbitratorGlobalArbitrationBytes{
     "velox.arbitrator_global_arbitration_bytes"};
 
-constexpr folly::StringPiece kMetricArbitratorGlobalArbitrationTimeMs{
+constexpr std::string_view kMetricArbitratorGlobalArbitrationTimeMs{
     "velox.arbitrator_global_arbitration_time_ms"};
 
-constexpr folly::StringPiece kMetricArbitratorGlobalArbitrationWaitCount{
+constexpr std::string_view kMetricArbitratorGlobalArbitrationWaitCount{
     "velox.arbitrator_global_arbitration_wait_count"};
 
-constexpr folly::StringPiece kMetricArbitratorGlobalArbitrationWaitTimeMs{
+constexpr std::string_view kMetricArbitratorGlobalArbitrationWaitTimeMs{
     "velox.arbitrator_global_arbitration_wait_time_ms"};
 
-constexpr folly::StringPiece kMetricArbitratorAbortedCount{
+constexpr std::string_view kMetricArbitratorAbortedCount{
     "velox.arbitrator_aborted_count"};
 
-constexpr folly::StringPiece kMetricArbitratorFailuresCount{
+constexpr std::string_view kMetricArbitratorFailuresCount{
     "velox.arbitrator_failures_count"};
 
-constexpr folly::StringPiece kMetricArbitratorOpExecTimeMs{
+constexpr std::string_view kMetricArbitratorOpExecTimeMs{
     "velox.arbitrator_op_exec_time_ms"};
 
-constexpr folly::StringPiece kMetricArbitratorFreeCapacityBytes{
+constexpr std::string_view kMetricArbitratorFreeCapacityBytes{
     "velox.arbitrator_free_capacity_bytes"};
 
-constexpr folly::StringPiece kMetricArbitratorFreeReservedCapacityBytes{
+constexpr std::string_view kMetricArbitratorFreeReservedCapacityBytes{
     "velox.arbitrator_free_reserved_capacity_bytes"};
 
-constexpr folly::StringPiece kMetricDriverYieldCount{
-    "velox.driver_yield_count"};
+constexpr std::string_view kMetricDriverYieldCount{"velox.driver_yield_count"};
 
-constexpr folly::StringPiece kMetricDriverQueueTimeMs{
+constexpr std::string_view kMetricDriverQueueTimeMs{
     "velox.driver_queue_time_ms"};
 
-constexpr folly::StringPiece kMetricDriverExecTimeMs{
-    "velox.driver_exec_time_ms"};
+constexpr std::string_view kMetricDriverExecTimeMs{"velox.driver_exec_time_ms"};
 
-constexpr folly::StringPiece kMetricSpilledInputBytes{
-    "velox.spill_input_bytes"};
+constexpr std::string_view kMetricSpilledInputBytes{"velox.spill_input_bytes"};
 
-constexpr folly::StringPiece kMetricSpilledBytes{"velox.spill_bytes"};
+constexpr std::string_view kMetricSpilledBytes{"velox.spill_bytes"};
 
-constexpr folly::StringPiece kMetricSpilledRowsCount{"velox.spill_rows_count"};
+constexpr std::string_view kMetricSpilledRowsCount{"velox.spill_rows_count"};
 
-constexpr folly::StringPiece kMetricSpilledFilesCount{
-    "velox.spill_files_count"};
+constexpr std::string_view kMetricSpilledFilesCount{"velox.spill_files_count"};
 
-constexpr folly::StringPiece kMetricSpillFillTimeMs{"velox.spill_fill_time_ms"};
+constexpr std::string_view kMetricSpillFillTimeMs{"velox.spill_fill_time_ms"};
 
-constexpr folly::StringPiece kMetricSpillSortTimeMs{"velox.spill_sort_time_ms"};
+constexpr std::string_view kMetricSpillSortTimeMs{"velox.spill_sort_time_ms"};
 
-constexpr folly::StringPiece kMetricSpillExtractVectorTimeMs{
+constexpr std::string_view kMetricSpillExtractVectorTimeMs{
     "velox.spill_extract_vector_time_ms"};
 
-constexpr folly::StringPiece kMetricSpillSerializationTimeMs{
+constexpr std::string_view kMetricSpillSerializationTimeMs{
     "velox.spill_serialization_time_ms"};
 
-constexpr folly::StringPiece kMetricSpillWritesCount{
-    "velox.spill_writes_count"};
+constexpr std::string_view kMetricSpillWritesCount{"velox.spill_writes_count"};
 
-constexpr folly::StringPiece kMetricSpillFlushTimeMs{
-    "velox.spill_flush_time_ms"};
+constexpr std::string_view kMetricSpillFlushTimeMs{"velox.spill_flush_time_ms"};
 
-constexpr folly::StringPiece kMetricSpillWriteTimeMs{
-    "velox.spill_write_time_ms"};
+constexpr std::string_view kMetricSpillWriteTimeMs{"velox.spill_write_time_ms"};
 
-constexpr folly::StringPiece kMetricSpillMemoryBytes{
-    "velox.spill_memory_bytes"};
+constexpr std::string_view kMetricSpillMemoryBytes{"velox.spill_memory_bytes"};
 
-constexpr folly::StringPiece kMetricSpillPeakMemoryBytes{
+constexpr std::string_view kMetricSpillPeakMemoryBytes{
     "velox.spill_peak_memory_bytes"};
 
-constexpr folly::StringPiece kMetricFileWriterEarlyFlushedRawBytes{
+constexpr std::string_view kMetricFileWriterEarlyFlushedRawBytes{
     "velox.file_writer_early_flushed_raw_bytes"};
 
-constexpr folly::StringPiece kMetricHiveSortWriterFinishTimeMs{
+constexpr std::string_view kMetricHiveSortWriterFinishTimeMs{
     "velox.hive_sort_writer_finish_time_ms"};
 
-constexpr folly::StringPiece kMetricArbitratorRequestsCount{
+constexpr std::string_view kMetricArbitratorRequestsCount{
     "velox.arbitrator_requests_count"};
 
-constexpr folly::StringPiece kMetricMemoryAllocatorMappedBytes{
+constexpr std::string_view kMetricMemoryAllocatorMappedBytes{
     "velox.memory_allocator_mapped_bytes"};
 
-constexpr folly::StringPiece kMetricMemoryAllocatorExternalMappedBytes{
+constexpr std::string_view kMetricMemoryAllocatorExternalMappedBytes{
     "velox.memory_allocator_external_mapped_bytes"};
 
-constexpr folly::StringPiece kMetricMemoryAllocatorAllocatedBytes{
+constexpr std::string_view kMetricMemoryAllocatorAllocatedBytes{
     "velox.memory_allocator_allocated_bytes"};
 
-constexpr folly::StringPiece kMetricMemoryAllocatorTotalUsedBytes{
+constexpr std::string_view kMetricMemoryAllocatorTotalUsedBytes{
     "velox.memory_allocator_total_used_bytes"};
 
-constexpr folly::StringPiece kMetricMmapAllocatorDelegatedAllocatedBytes{
+constexpr std::string_view kMetricMmapAllocatorDelegatedAllocatedBytes{
     "velox.mmap_allocator_delegated_allocated_bytes"};
 
-constexpr folly::StringPiece kMetricCacheMaxAgeSecs{"velox.cache_max_age_secs"};
+constexpr std::string_view kMetricCacheMaxAgeSecs{"velox.cache_max_age_secs"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumEntries{
-    "velox.memory_cache_num_entries"};
+constexpr std::string_view kMetricMemoryCacheNumTinyEntries{
+    "velox.memory_cache_num_tiny_entries"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumEmptyEntries{
+constexpr std::string_view kMetricMemoryCacheNumLargeEntries{
+    "velox.memory_cache_num_large_entries"};
+
+constexpr std::string_view kMetricMemoryCacheNumEmptyEntries{
     "velox.memory_cache_num_empty_entries"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumSharedEntries{
+constexpr std::string_view kMetricMemoryCacheNumSharedEntries{
     "velox.memory_cache_num_shared_entries"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumExclusiveEntries{
+constexpr std::string_view kMetricMemoryCacheNumExclusiveEntries{
     "velox.memory_cache_num_exclusive_entries"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumPrefetchedEntries{
+constexpr std::string_view kMetricMemoryCacheNumPrefetchedEntries{
     "velox.memory_cache_num_prefetched_entries"};
 
-constexpr folly::StringPiece kMetricMemoryCacheTotalTinyBytes{
+constexpr std::string_view kMetricMemoryCacheTotalTinyBytes{
     "velox.memory_cache_total_tiny_bytes"};
 
-constexpr folly::StringPiece kMetricMemoryCacheTotalLargeBytes{
+constexpr std::string_view kMetricMemoryCacheTotalLargeBytes{
     "velox.memory_cache_total_large_bytes"};
 
-constexpr folly::StringPiece kMetricMemoryCacheTotalTinyPaddingBytes{
+constexpr std::string_view kMetricMemoryCacheTotalTinyPaddingBytes{
     "velox.memory_cache_total_tiny_padding_bytes"};
 
-constexpr folly::StringPiece kMetricMemoryCacheTotalLargePaddingBytes{
+constexpr std::string_view kMetricMemoryCacheTotalLargePaddingBytes{
     "velox.memory_cache_total_large_padding_bytes"};
 
-constexpr folly::StringPiece kMetricMemoryCacheTotalPrefetchBytes{
+constexpr std::string_view kMetricMemoryCacheTotalPrefetchBytes{
     "velox.memory_cache_total_prefetched_bytes"};
 
-constexpr folly::StringPiece kMetricMemoryCacheSumEvictScore{
+constexpr std::string_view kMetricMemoryCacheSumEvictScore{
     "velox.memory_cache_sum_evict_score"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumHits{
+constexpr std::string_view kMetricMemoryCacheNumHits{
     "velox.memory_cache_num_hits"};
 
-constexpr folly::StringPiece kMetricMemoryCacheHitBytes{
+constexpr std::string_view kMetricMemoryCacheHitBytes{
     "velox.memory_cache_hit_bytes"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumNew{
+constexpr std::string_view kMetricMemoryCacheNumNew{
     "velox.memory_cache_num_new"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumEvicts{
+constexpr std::string_view kMetricMemoryCacheNumEvicts{
     "velox.memory_cache_num_evicts"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumSavableEvicts{
+constexpr std::string_view kMetricMemoryCacheNumSavableEvicts{
     "velox.memory_cache_num_savable_evicts"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumEvictChecks{
+constexpr std::string_view kMetricMemoryCacheNumEvictChecks{
     "velox.memory_cache_num_evict_checks"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumWaitExclusive{
+constexpr std::string_view kMetricMemoryCacheNumWaitExclusive{
     "velox.memory_cache_num_wait_exclusive"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumAllocClocks{
+constexpr std::string_view kMetricMemoryCacheNumAllocClocks{
     "velox.memory_cache_num_alloc_clocks"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumAgedOutEntries{
+constexpr std::string_view kMetricMemoryCacheNumAgedOutEntries{
     "velox.memory_cache_num_aged_out_entries"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumStaleEntries{
+constexpr std::string_view kMetricMemoryCacheNumStaleEntries{
     "velox.memory_cache_num_stale_entries"};
 
-constexpr folly::StringPiece kMetricSsdCacheCachedRegions{
+constexpr std::string_view kMetricSsdCacheCachedRegions{
     "velox.ssd_cache_cached_regions"};
 
-constexpr folly::StringPiece kMetricSsdCacheCachedEntries{
+constexpr std::string_view kMetricSsdCacheCachedEntries{
     "velox.ssd_cache_cached_entries"};
 
-constexpr folly::StringPiece kMetricSsdCacheCachedBytes{
+constexpr std::string_view kMetricSsdCacheCachedBytes{
     "velox.ssd_cache_cached_bytes"};
 
-constexpr folly::StringPiece kMetricSsdCacheReadEntries{
+constexpr std::string_view kMetricSsdCacheReadEntries{
     "velox.ssd_cache_read_entries"};
 
-constexpr folly::StringPiece kMetricSsdCacheReadBytes{
+constexpr std::string_view kMetricSsdCacheReadBytes{
     "velox.ssd_cache_read_bytes"};
 
-constexpr folly::StringPiece kMetricSsdCacheWrittenEntries{
+constexpr std::string_view kMetricSsdCacheWrittenEntries{
     "velox.ssd_cache_written_entries"};
 
-constexpr folly::StringPiece kMetricSsdCacheWrittenBytes{
+constexpr std::string_view kMetricSsdCacheWrittenBytes{
     "velox.ssd_cache_written_bytes"};
 
-constexpr folly::StringPiece kMetricSsdCacheAgedOutEntries{
+constexpr std::string_view kMetricSsdCacheAgedOutEntries{
     "velox.ssd_cache_aged_out_entries"};
 
-constexpr folly::StringPiece kMetricSsdCacheAgedOutRegions{
+constexpr std::string_view kMetricSsdCacheAgedOutRegions{
     "velox.ssd_cache_aged_out_regions"};
 
-constexpr folly::StringPiece kMetricSsdCacheOpenSsdErrors{
+constexpr std::string_view kMetricSsdCacheOpenSsdErrors{
     "velox.ssd_cache_open_ssd_errors"};
 
-constexpr folly::StringPiece kMetricSsdCacheOpenCheckpointErrors{
+constexpr std::string_view kMetricSsdCacheOpenCheckpointErrors{
     "velox.ssd_cache_open_checkpoint_errors"};
 
-constexpr folly::StringPiece kMetricSsdCacheOpenLogErrors{
+constexpr std::string_view kMetricSsdCacheOpenLogErrors{
     "velox.ssd_cache_open_log_errors"};
 
-constexpr folly::StringPiece kMetricSsdCacheMetaFileDeleteErrors{
+constexpr std::string_view kMetricSsdCacheMetaFileDeleteErrors{
     "velox.ssd_cache_delete_meta_file_errors"};
 
-constexpr folly::StringPiece kMetricSsdCacheGrowFileErrors{
+constexpr std::string_view kMetricSsdCacheGrowFileErrors{
     "velox.ssd_cache_grow_file_errors"};
 
-constexpr folly::StringPiece kMetricSsdCacheWriteSsdErrors{
+constexpr std::string_view kMetricSsdCacheWriteSsdErrors{
     "velox.ssd_cache_write_ssd_errors"};
 
-constexpr folly::StringPiece kMetricSsdCacheWriteSsdDropped{
+constexpr std::string_view kMetricSsdCacheWriteNoSpaceErrors{
+    "velox.ssd_cache_write_no_space_errors"};
+
+constexpr std::string_view kMetricSsdCacheWriteSsdDropped{
     "velox.ssd_cache_write_ssd_dropped"};
 
-constexpr folly::StringPiece kMetricSsdCacheWriteCheckpointErrors{
+constexpr std::string_view kMetricSsdCacheWriteExceedEntryLimit{
+    "velox.ssd_cache_write_exceed_entry_limit"};
+
+constexpr std::string_view kMetricSsdCacheWriteCheckpointErrors{
     "velox.ssd_cache_write_checkpoint_errors"};
 
-constexpr folly::StringPiece kMetricSsdCacheReadCorruptions{
+constexpr std::string_view kMetricSsdCacheReadCorruptions{
     "velox.ssd_cache_read_corruptions"};
 
-constexpr folly::StringPiece kMetricSsdCacheReadSsdErrors{
+constexpr std::string_view kMetricSsdCacheReadSsdErrors{
     "velox.ssd_cache_read_ssd_errors"};
 
-constexpr folly::StringPiece kMetricSsdCacheReadCheckpointErrors{
+constexpr std::string_view kMetricSsdCacheReadCheckpointErrors{
     "velox.ssd_cache_read_checkpoint_errors"};
 
-constexpr folly::StringPiece kMetricSsdCacheReadWithoutChecksum{
+constexpr std::string_view kMetricSsdCacheReadWithoutChecksum{
     "velox.ssd_cache_read_without_checksum"};
 
-constexpr folly::StringPiece kMetricSsdCacheCheckpointsRead{
+constexpr std::string_view kMetricSsdCacheCheckpointsRead{
     "velox.ssd_cache_checkpoints_read"};
 
-constexpr folly::StringPiece kMetricSsdCacheCheckpointsWritten{
+constexpr std::string_view kMetricSsdCacheCheckpointsWritten{
     "velox.ssd_cache_checkpoints_written"};
 
-constexpr folly::StringPiece kMetricSsdCacheRegionsEvicted{
+constexpr std::string_view kMetricSsdCacheRegionsEvicted{
     "velox.ssd_cache_regions_evicted"};
 
-constexpr folly::StringPiece kMetricSsdCacheRecoveredEntries{
+constexpr std::string_view kMetricSsdCacheRecoveredEntries{
     "velox.ssd_cache_recovered_entries"};
 
-constexpr folly::StringPiece kMetricExchangeTransactionCreateDelay{
+constexpr std::string_view kMetricExchangeTransactionCreateDelay{
     "velox.exchange.transaction_create_delay_ms"};
 
-constexpr folly::StringPiece kMetricExchangeDataTimeMs{
+constexpr std::string_view kMetricExchangeDataTimeMs{
     "velox.exchange_data_time_ms"};
 
-constexpr folly::StringPiece kMetricExchangeDataBytes{
+constexpr std::string_view kMetricExchangeDataBytes{
     "velox.exchange_data_bytes"};
 
-constexpr folly::StringPiece kMetricExchangeDataSize{
-    "velox.exchange_data_size"};
+constexpr std::string_view kMetricExchangeDataSize{"velox.exchange_data_size"};
 
-constexpr folly::StringPiece kMetricExchangeDataCount{
+constexpr std::string_view kMetricExchangeDataCount{
     "velox.exchange_data_count"};
 
-constexpr folly::StringPiece kMetricExchangeDataSizeTimeMs{
+constexpr std::string_view kMetricExchangeDataSizeTimeMs{
     "velox.exchange_data_size_time_ms"};
 
-constexpr folly::StringPiece kMetricExchangeDataSizeCount{
+constexpr std::string_view kMetricExchangeDataSizeCount{
     "velox.exchange_data_size_count"};
 
-constexpr folly::StringPiece kMetricStorageThrottledDurationMs{
+constexpr std::string_view kMetricStorageThrottledDurationMs{
     "velox.storage_throttled_duration_ms"};
 
-constexpr folly::StringPiece kMetricStorageLocalThrottled{
+constexpr std::string_view kMetricStorageLocalThrottled{
     "velox.storage_local_throttled_count"};
 
-constexpr folly::StringPiece kMetricStorageGlobalThrottled{
+constexpr std::string_view kMetricStorageGlobalThrottled{
     "velox.storage_global_throttled_count"};
 
-constexpr folly::StringPiece kMetricStorageNetworkThrottled{
+constexpr std::string_view kMetricStorageNetworkThrottled{
     "velox.storage_network_throttled_count"};
 
-constexpr folly::StringPiece kMetricIndexLookupResultRawBytes{
+constexpr std::string_view kMetricIndexLookupResultRawBytes{
     "velox.index_lookup_result_raw_bytes"};
 
-constexpr folly::StringPiece kMetricIndexLookupResultBytes{
+constexpr std::string_view kMetricIndexLookupResultBytes{
     "velox.index_lookup_result_bytes"};
 
-constexpr folly::StringPiece kMetricIndexLookupTimeMs{
+constexpr std::string_view kMetricIndexLookupTimeMs{
     "velox.index_lookup_time_ms"};
 
-constexpr folly::StringPiece kMetricIndexLookupWaitTimeMs{
+constexpr std::string_view kMetricIndexLookupWaitTimeMs{
     "velox.index_lookup_wait_time_ms"};
 
-constexpr folly::StringPiece kMetricIndexLookupBlockedWaitTimeMs{
+constexpr std::string_view kMetricIndexLookupBlockedWaitTimeMs{
     "velox.index_lookup_blocked_wait_time_ms"};
 
-constexpr folly::StringPiece kMetricTableScanBatchProcessTimeMs{
+constexpr std::string_view kMetricIndexLookupErrorResultCount{
+    "velox.index_lookup_error_result_count"};
+
+constexpr std::string_view kMetricTableScanBatchProcessTimeMs{
     "velox.table_scan_batch_process_time_ms"};
 
-constexpr folly::StringPiece kMetricTableScanBatchBytes{
+constexpr std::string_view kMetricTableScanBatchBytes{
     "velox.table_scan_batch_bytes"};
 
-constexpr folly::StringPiece kMetricTaskBatchProcessTimeMs{
+constexpr std::string_view kMetricTaskBatchProcessTimeMs{
     "velox.task_batch_process_time_ms"};
 
-constexpr folly::StringPiece kMetricTaskBarrierProcessTimeMs{
+constexpr std::string_view kMetricTaskBarrierProcessTimeMs{
     "velox.task_barrier_process_time_ms"};
+
 } // namespace facebook::velox
diff --git a/velox/common/base/ExceptionHelper.h b/velox/common/base/ExceptionHelper.h
index 193641ce63a..ad9b21c9471 100644
--- a/velox/common/base/ExceptionHelper.h
+++ b/velox/common/base/ExceptionHelper.h
@@ -34,6 +34,24 @@ struct CompileTimeEmptyString {
   }
 };
 
+/// Wraps a const char* that must originate from a string literal (or other
+/// compile-time constant). Provides a distinct type to resolve overload
+/// ambiguity with std::string_view parameters in exception constructors.
+class CompileTimeStringLiteral {
+  const char* data_;
+
+ public:
+  /* implicit */ constexpr CompileTimeStringLiteral(const char* data)
+      : data_{data} {}
+
+  constexpr operator const char*() const {
+    return data_;
+  }
+  constexpr operator std::string_view() const {
+    return data_ ? std::string_view(data_) : std::string_view();
+  }
+};
+
 // When there is no message passed, we can statically detect this case
 // and avoid passing even a single unnecessary argument pointer,
 // minimizing size and thus maximizing eligibility for inlining.
diff --git a/velox/common/base/Exceptions.h b/velox/common/base/Exceptions.h
index 4485b8b006a..92be6d30989 100644
--- a/velox/common/base/Exceptions.h
+++ b/velox/common/base/Exceptions.h
@@ -44,6 +44,8 @@ struct VeloxCheckFailArgs {
 // inline it when it is large. Having an out-of-line error path helps
 // otherwise-small functions that call error-checking macros stay
 // small and thus stay eligible for inlining.
+
+// Overload without messageTemplate: message IS the template (0 or 1 args).
 template <typename Exception, typename StringType>
 [[noreturn]] void veloxCheckFail(const VeloxCheckFailArgs& args, StringType s) {
   static_assert(
@@ -69,6 +71,39 @@ template <typename Exception, typename StringType>
       args.isRetriable);
 }
 
+// Overload with messageTemplate: template is the format string before
+// interpolation (>=2 args, format string + arguments). The template should
+// be a string literal; for runtime format strings, use the single-arg
+// VELOX_FAIL("{}", runtimeStr) pattern instead.
+template <typename Exception, typename StringType>
+[[noreturn]] void veloxCheckFail(
+    const VeloxCheckFailArgs& args,
+    StringType s,
+    CompileTimeStringLiteral messageTemplate) {
+  static_assert(
+      !std::is_same_v<StringType, std::string>,
+      "BUG: we should not pass std::string by value to veloxCheckFail");
+  if constexpr (!std::is_same_v<Exception, VeloxUserError>) {
+    LOG(ERROR) << "Line: " << args.file << ":" << args.line
+               << ", Function:" << args.function
+               << ", Expression: " << args.expression << " " << s
+               << ", Source: " << args.errorSource
+               << ", ErrorCode: " << args.errorCode;
+  }
+
+  ++threadNumVeloxThrow();
+  throw Exception(
+      args.file,
+      args.line,
+      args.function,
+      args.expression,
+      s,
+      args.errorSource,
+      args.errorCode,
+      args.isRetriable,
+      messageTemplate);
+}
+
 // VeloxCheckFailStringType helps us pass by reference to
 // veloxCheckFail exactly when the string type is std::string.
 template <typename T>
@@ -106,21 +141,99 @@ struct VeloxCheckFailStringType<std::string> {
   extern template void veloxCheckFail<exception_type, const std::string&>(     \
       const VeloxCheckFailArgs& args,                                          \
       const std::string&);                                                     \
+  extern template void veloxCheckFail<exception_type, CompileTimeEmptyString>( \
+      const VeloxCheckFailArgs& args,                                          \
+      CompileTimeEmptyString,                                                  \
+      CompileTimeStringLiteral);                                               \
+  extern template void veloxCheckFail<exception_type, const char*>(            \
+      const VeloxCheckFailArgs& args,                                          \
+      const char*,                                                             \
+      CompileTimeStringLiteral);                                               \
+  extern template void veloxCheckFail<exception_type, const std::string&>(     \
+      const VeloxCheckFailArgs& args,                                          \
+      const std::string&,                                                      \
+      CompileTimeStringLiteral);                                               \
   } // namespace detail
 
 // Definitions corresponding to DECLARE_CHECK_FAIL_TEMPLATES. Should
 // only be used in Exceptions.cpp.
-#define DEFINE_CHECK_FAIL_TEMPLATES(exception_type)                     \
-  template void veloxCheckFail<exception_type, CompileTimeEmptyString>( \
-      const VeloxCheckFailArgs& args, CompileTimeEmptyString);          \
-  template void veloxCheckFail<exception_type, const char*>(            \
-      const VeloxCheckFailArgs& args, const char*);                     \
-  template void veloxCheckFail<exception_type, const std::string&>(     \
-      const VeloxCheckFailArgs& args, const std::string&);
+#define DEFINE_CHECK_FAIL_TEMPLATES(exception_type)                           \
+  template void veloxCheckFail<exception_type, CompileTimeEmptyString>(       \
+      const VeloxCheckFailArgs& args, CompileTimeEmptyString);                \
+  template void veloxCheckFail<exception_type, const char*>(                  \
+      const VeloxCheckFailArgs& args, const char*);                           \
+  template void veloxCheckFail<exception_type, const std::string&>(           \
+      const VeloxCheckFailArgs& args, const std::string&);                    \
+  template void veloxCheckFail<exception_type, CompileTimeEmptyString>(       \
+      const VeloxCheckFailArgs& args,                                         \
+      CompileTimeEmptyString,                                                 \
+      CompileTimeStringLiteral);                                              \
+  template void veloxCheckFail<exception_type, const char*>(                  \
+      const VeloxCheckFailArgs& args, const char*, CompileTimeStringLiteral); \
+  template void veloxCheckFail<exception_type, const std::string&>(           \
+      const VeloxCheckFailArgs& args,                                         \
+      const std::string&,                                                     \
+      CompileTimeStringLiteral);
 
 } // namespace detail
 
-#define _VELOX_THROW_IMPL(                                            \
+// Macro arg-count detection for dispatching between the no-template
+// and with-template overloads of veloxCheckFail.
+// 0 or 1 args: message IS the template (no-template overload).
+// >=2 args: first arg is the format string template (with-template overload).
+#define _VELOX_NARGS_IMPL( \
+    _0,                    \
+    _1,                    \
+    _2,                    \
+    _3,                    \
+    _4,                    \
+    _5,                    \
+    _6,                    \
+    _7,                    \
+    _8,                    \
+    _9,                    \
+    _10,                   \
+    _11,                   \
+    _12,                   \
+    _13,                   \
+    _14,                   \
+    _15,                   \
+    _16,                   \
+    N,                     \
+    ...)                   \
+  N
+#define _VELOX_NARGS(...) \
+  _VELOX_NARGS_IMPL(      \
+      dummy,              \
+      ##__VA_ARGS__,      \
+      16,                 \
+      15,                 \
+      14,                 \
+      13,                 \
+      12,                 \
+      11,                 \
+      10,                 \
+      9,                  \
+      8,                  \
+      7,                  \
+      6,                  \
+      5,                  \
+      4,                  \
+      3,                  \
+      2,                  \
+      1,                  \
+      0)
+
+// Extract the first argument from __VA_ARGS__ (the format string) as a
+// CompileTimeStringLiteral. Only used for >=2 args path.
+#define _VELOX_MSG_TEMPLATE_PICK(_1, _2, ...) _2
+#define _VELOX_MSG_TEMPLATE(...)               \
+  ::facebook::velox::CompileTimeStringLiteral( \
+      _VELOX_MSG_TEMPLATE_PICK("", ##__VA_ARGS__, ""))
+
+// _VELOX_THROW_IMPL dispatches to the no-template or with-template path
+// based on the number of user-supplied message arguments.
+#define _VELOX_THROW_IMPL_BODY_NO_TEMPLATE(                           \
     exception, exprStr, errorSource, errorCode, isRetriable, ...)     \
   do {                                                                \
     /* GCC 9.2.1 doesn't accept this code with constexpr. */          \
@@ -140,6 +253,54 @@ struct VeloxCheckFailStringType<std::string> {
             decltype(message)>::type>(veloxCheckFailArgs, message);   \
   } while (0)
 
+#define _VELOX_THROW_IMPL_BODY_WITH_TEMPLATE(                           \
+    exception, exprStr, errorSource, errorCode, isRetriable, ...)       \
+  do {                                                                  \
+    /* GCC 9.2.1 doesn't accept this code with constexpr. */            \
+    static const ::facebook::velox::detail::VeloxCheckFailArgs          \
+        veloxCheckFailArgs = {                                          \
+            __FILE__,                                                   \
+            __LINE__,                                                   \
+            __FUNCTION__,                                               \
+            exprStr,                                                    \
+            errorSource,                                                \
+            errorCode,                                                  \
+            isRetriable};                                               \
+    auto message = ::facebook::velox::errorMessage(__VA_ARGS__);        \
+    ::facebook::velox::detail::veloxCheckFail<                          \
+        exception,                                                      \
+        typename ::facebook::velox::detail::VeloxCheckFailStringType<   \
+            decltype(message)>::type>(                                  \
+        veloxCheckFailArgs, message, _VELOX_MSG_TEMPLATE(__VA_ARGS__)); \
+  } while (0)
+
+#define _VELOX_THROW_DISPATCH_0 _VELOX_THROW_IMPL_BODY_NO_TEMPLATE
+#define _VELOX_THROW_DISPATCH_1 _VELOX_THROW_IMPL_BODY_NO_TEMPLATE
+#define _VELOX_THROW_DISPATCH_2 _VELOX_THROW_IMPL_BODY_WITH_TEMPLATE
+#define _VELOX_THROW_DISPATCH_3 _VELOX_THROW_IMPL_BODY_WITH_TEMPLATE
+#define _VELOX_THROW_DISPATCH_4 _VELOX_THROW_IMPL_BODY_WITH_TEMPLATE
+#define _VELOX_THROW_DISPATCH_5 _VELOX_THROW_IMPL_BODY_WITH_TEMPLATE
+#define _VELOX_THROW_DISPATCH_6 _VELOX_THROW_IMPL_BODY_WITH_TEMPLATE
+#define _VELOX_THROW_DISPATCH_7 _VELOX_THROW_IMPL_BODY_WITH_TEMPLATE
+#define _VELOX_THROW_DISPATCH_8 _VELOX_THROW_IMPL_BODY_WITH_TEMPLATE
+#define _VELOX_THROW_DISPATCH_9 _VELOX_THROW_IMPL_BODY_WITH_TEMPLATE
+#define _VELOX_THROW_DISPATCH_10 _VELOX_THROW_IMPL_BODY_WITH_TEMPLATE
+#define _VELOX_THROW_DISPATCH_11 _VELOX_THROW_IMPL_BODY_WITH_TEMPLATE
+#define _VELOX_THROW_DISPATCH_12 _VELOX_THROW_IMPL_BODY_WITH_TEMPLATE
+#define _VELOX_THROW_DISPATCH_13 _VELOX_THROW_IMPL_BODY_WITH_TEMPLATE
+#define _VELOX_THROW_DISPATCH_14 _VELOX_THROW_IMPL_BODY_WITH_TEMPLATE
+#define _VELOX_THROW_DISPATCH_15 _VELOX_THROW_IMPL_BODY_WITH_TEMPLATE
+#define _VELOX_THROW_DISPATCH_16 _VELOX_THROW_IMPL_BODY_WITH_TEMPLATE
+
+#define _VELOX_THROW_CONCAT2(a, b) a##b
+#define _VELOX_THROW_CONCAT(a, b) _VELOX_THROW_CONCAT2(a, b)
+#define _VELOX_THROW_SELECT(n) _VELOX_THROW_CONCAT(_VELOX_THROW_DISPATCH_, n)
+
+#define _VELOX_THROW_IMPL(                                        \
+    exception, exprStr, errorSource, errorCode, isRetriable, ...) \
+  _VELOX_THROW_SELECT(_VELOX_NARGS(__VA_ARGS__))(                 \
+      exception, exprStr, errorSource, errorCode, isRetriable, ##__VA_ARGS__)
+
 #define _VELOX_CHECK_AND_THROW_IMPL(                                    \
     expr, exprStr, exception, errorSource, errorCode, isRetriable, ...) \
   do {                                                                  \
@@ -334,6 +495,14 @@ DECLARE_CHECK_FAIL_TEMPLATES(::facebook::velox::VeloxRuntimeError)
       /* isRetriable */ false,                                             \
       ##__VA_ARGS__)
 
+#define VELOX_TRACE_LIMIT_EXCEEDED(...)                             \
+  _VELOX_THROW(                                                     \
+      ::facebook::velox::VeloxRuntimeError,                         \
+      ::facebook::velox::error_source::kErrorSourceRuntime.c_str(), \
+      ::facebook::velox::error_code::kTraceLimitExceeded.c_str(),   \
+      /* isRetriable */ true,                                       \
+      ##__VA_ARGS__)
+
 DECLARE_CHECK_FAIL_TEMPLATES(::facebook::velox::VeloxUserError)
 
 // For all below macros, an additional message can be passed using a
diff --git a/velox/common/base/Macros.h b/velox/common/base/Macros.h
index 62664a488f5..2af0303c423 100644
--- a/velox/common/base/Macros.h
+++ b/velox/common/base/Macros.h
@@ -28,6 +28,21 @@
   _Pragma("GCC diagnostic pop");
 #endif
 
+// Disable deprecated-declarations for Clang and GCC
+#ifdef __clang__
+#define VELOX_SUPPRESS_DEPRECATED_WARNING \
+  _Pragma("clang diagnostic push");       \
+  _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
+
+#define VELOX_UNSUPPRESS_DEPRECATED_WARNING _Pragma("clang diagnostic pop")
+#else
+#define VELOX_SUPPRESS_DEPRECATED_WARNING \
+  _Pragma("GCC diagnostic push");         \
+  _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+
+#define VELOX_UNSUPPRESS_DEPRECATED_WARNING _Pragma("GCC diagnostic pop")
+#endif
+
 #define VELOX_CONCAT(x, y) x##y
 // Need this extra layer to expand __COUNTER__.
 #define VELOX_VARNAME_IMPL(x, y) VELOX_CONCAT(x, y)
diff --git a/velox/common/base/PeriodicStatsReporter.cpp b/velox/common/base/PeriodicStatsReporter.cpp
index 8afbabd59c3..fb07906dcfe 100644
--- a/velox/common/base/PeriodicStatsReporter.cpp
+++ b/velox/common/base/PeriodicStatsReporter.cpp
@@ -139,7 +139,10 @@ void PeriodicStatsReporter::reportCacheStats() {
   const auto cacheStats = cache_->refreshStats();
 
   // Memory cache snapshot stats.
-  RECORD_METRIC_VALUE(kMetricMemoryCacheNumEntries, cacheStats.numEntries);
+  RECORD_METRIC_VALUE(
+      kMetricMemoryCacheNumTinyEntries, cacheStats.numTinyEntries);
+  RECORD_METRIC_VALUE(
+      kMetricMemoryCacheNumLargeEntries, cacheStats.numLargeEntries);
   RECORD_METRIC_VALUE(
       kMetricMemoryCacheNumEmptyEntries, cacheStats.numEmptyEntries);
   RECORD_METRIC_VALUE(kMetricMemoryCacheNumSharedEntries, cacheStats.numShared);
@@ -208,8 +211,13 @@ void PeriodicStatsReporter::reportCacheStats() {
         kMetricSsdCacheGrowFileErrors, deltaSsdStats.growFileErrors);
     REPORT_IF_NOT_ZERO(
         kMetricSsdCacheWriteSsdErrors, deltaSsdStats.writeSsdErrors);
+    REPORT_IF_NOT_ZERO(
+        kMetricSsdCacheWriteNoSpaceErrors, deltaSsdStats.writeSsdNoSpaceErrors);
     REPORT_IF_NOT_ZERO(
         kMetricSsdCacheWriteSsdDropped, deltaSsdStats.writeSsdDropped);
+    REPORT_IF_NOT_ZERO(
+        kMetricSsdCacheWriteExceedEntryLimit,
+        deltaSsdStats.writeSsdExceedEntryLimit);
     REPORT_IF_NOT_ZERO(
         kMetricSsdCacheWriteCheckpointErrors,
         deltaSsdStats.writeCheckpointErrors);
diff --git a/velox/common/base/Portability.h b/velox/common/base/Portability.h
index 60049fcc54c..bd8daf71e77 100644
--- a/velox/common/base/Portability.h
+++ b/velox/common/base/Portability.h
@@ -19,7 +19,7 @@
 #include <atomic>
 #include <cstddef>
 #include <cstdint>
-#include <vector>
+#include <mutex>
 
 inline size_t count_trailing_zeros(uint64_t x) {
   return x == 0 ? 64 : __builtin_ctzll(x);
@@ -88,15 +88,4 @@ using tsan_lock_guard = TsanEmptyLockGuard<T>;
 
 #endif
 
-template <typename T>
-inline void resizeTsanAtomic(
-    std::vector<tsan_atomic<T>>& vector,
-    int32_t newSize) {
-  std::vector<tsan_atomic<T>> newVector(newSize);
-  auto numCopy = std::min<int32_t>(newSize, vector.size());
-  for (auto i = 0; i < numCopy; ++i) {
-    newVector[i] = tsanAtomicValue(vector[i]);
-  }
-  vector = std::move(newVector);
-}
 } // namespace facebook::velox
diff --git a/velox/common/base/RuntimeMetrics.cpp b/velox/common/base/RuntimeMetrics.cpp
index 3130cbcabef..f72b396ce91 100644
--- a/velox/common/base/RuntimeMetrics.cpp
+++ b/velox/common/base/RuntimeMetrics.cpp
@@ -30,7 +30,7 @@ void RuntimeMetric::addValue(int64_t value) {
 }
 
 void RuntimeMetric::aggregate() {
-  count = std::min(count, static_cast<int64_t>(1));
+  count = std::min(count, static_cast<uint64_t>(1));
   min = max = sum;
 }
 
@@ -113,7 +113,7 @@ BaseRuntimeStatWriter* getThreadLocalRunTimeStatWriter() {
 }
 
 void addThreadLocalRuntimeStat(
-    const std::string& name,
+    std::string_view name,
     const RuntimeCounter& value) {
   if (localRuntimeStatWriter) {
     localRuntimeStatWriter->addRuntimeStat(name, value);
diff --git a/velox/common/base/RuntimeMetrics.h b/velox/common/base/RuntimeMetrics.h
index 5b699a41a99..579e54a1435 100644
--- a/velox/common/base/RuntimeMetrics.h
+++ b/velox/common/base/RuntimeMetrics.h
@@ -19,9 +19,17 @@
 #include <fmt/format.h>
 #include <folly/CppAttributes.h>
 #include <limits>
+#include <string_view>
 
 namespace facebook::velox {
 
+/// Converts unsigned bigint to signed, capping at int64_t max if overflow
+/// happens. Could be replaced by 'std::saturate_cast' since C++26.
+inline int64_t saturateCast(uint64_t value) {
+  return static_cast<int64_t>(std::min(
+      value, static_cast<uint64_t>(std::numeric_limits<int64_t>::max())));
+}
+
 struct RuntimeCounter {
   enum class Unit { kNone, kNanos, kBytes };
   int64_t value;
@@ -35,7 +43,7 @@ struct RuntimeMetric {
   // Sum, min, max have the same unit, count has kNone.
   RuntimeCounter::Unit unit;
   int64_t sum{0};
-  int64_t count{0};
+  uint64_t count{0};
   int64_t min{std::numeric_limits<int64_t>::max()};
   int64_t max{std::numeric_limits<int64_t>::min()};
 
@@ -48,6 +56,14 @@ struct RuntimeMetric {
       RuntimeCounter::Unit _unit = RuntimeCounter::Unit::kNone)
       : unit(_unit), sum{value}, count{1}, min{value}, max{value} {}
 
+  explicit RuntimeMetric(
+      int64_t _sum,
+      uint64_t _count,
+      int64_t _min,
+      int64_t _max,
+      RuntimeCounter::Unit _unit = RuntimeCounter::Unit::kNone)
+      : unit(_unit), sum{_sum}, count{_count}, min{_min}, max{_max} {}
+
   void addValue(int64_t value);
 
   /// Aggregate sets 'min' and 'max' to 'sum', also sets 'count' to 1 if
@@ -69,7 +85,7 @@ class BaseRuntimeStatWriter {
   virtual ~BaseRuntimeStatWriter() = default;
 
   virtual void addRuntimeStat(
-      const std::string& /* name */,
+      std::string_view /* name */,
       const RuntimeCounter& /* value */) {}
 };
 
@@ -85,7 +101,7 @@ BaseRuntimeStatWriter* getThreadLocalRunTimeStatWriter();
 
 /// Writes runtime counter to the current Operator running on that thread.
 void addThreadLocalRuntimeStat(
-    const std::string& name,
+    std::string_view name,
     const RuntimeCounter& value);
 
 /// Scope guard to conveniently set and revert back the current stat writer.
diff --git a/velox/common/base/SimdUtil-inl.h b/velox/common/base/SimdUtil-inl.h
index 937c86d9f7e..d46c4f21b95 100644
--- a/velox/common/base/SimdUtil-inl.h
+++ b/velox/common/base/SimdUtil-inl.h
@@ -91,10 +91,24 @@ struct BitMask<T, A, 1> {
 
 #if XSIMD_WITH_NEON
   static int toBitMask(xsimd::batch_bool<T, A> mask, const xsimd::neon&) {
-    alignas(A::alignment()) static const int8_t kShift[] = {
-        -7, -6, -5, -4, -3, -2, -1, 0, -7, -6, -5, -4, -3, -2, -1, 0};
-    int8x16_t vshift = vld1q_s8(kShift);
-    uint8x16_t vmask = vshlq_u8(vandq_u8(mask, vdupq_n_u8(0x80)), vshift);
+    static constexpr uint8x16_t vmask_const = {
+        0x01,
+        0x02,
+        0x04,
+        0x08,
+        0x10,
+        0x20,
+        0x40,
+        0x80, // lower half
+        0x01,
+        0x02,
+        0x04,
+        0x08,
+        0x10,
+        0x20,
+        0x40,
+        0x80}; // upper half
+    uint8x16_t vmask = vandq_u8(mask.data, vmask_const);
     return (vaddv_u8(vget_high_u8(vmask)) << 8) | vaddv_u8(vget_low_u8(vmask));
   }
 #endif
@@ -125,6 +139,15 @@ struct BitMask<T, A, 2> {
   }
 #endif
 
+#if XSIMD_WITH_NEON
+  static int toBitMask(xsimd::batch_bool<T, A> mask, const xsimd::neon&) {
+    static constexpr uint16x8_t vmask_const = {
+        0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
+    uint16x8_t vmask = vandq_u16(mask.data, vmask_const);
+    return vaddvq_u16(vmask);
+  }
+#endif
+
   static int toBitMask(xsimd::batch_bool<T, A> mask, const xsimd::generic&) {
     return genericToBitMask(mask);
   }
@@ -146,6 +169,14 @@ struct BitMask<T, A, 4> {
   }
 #endif
 
+#if XSIMD_WITH_NEON
+  static int toBitMask(xsimd::batch_bool<T, A> mask, const xsimd::neon&) {
+    static constexpr uint32x4_t vmask_const = {0x1, 0x2, 0x4, 0x8};
+    uint32x4_t vmask = vandq_u32(mask.data, vmask_const);
+    return vaddvq_u32(vmask);
+  }
+#endif
+
   static int toBitMask(xsimd::batch_bool<T, A> mask, const xsimd::generic&) {
     return genericToBitMask(mask);
   }
@@ -173,6 +204,14 @@ struct BitMask<T, A, 8> {
   }
 #endif
 
+#if XSIMD_WITH_NEON
+  static int toBitMask(xsimd::batch_bool<T, A> mask, const xsimd::neon&) {
+    static constexpr uint64x2_t vmask_const = {0x1, 0x2};
+    const uint64x2_t vmask = vandq_u64(mask.data, vmask_const);
+    return vaddvq_u64(vmask);
+  }
+#endif
+
   static int toBitMask(xsimd::batch_bool<T, A> mask, const xsimd::generic&) {
     return genericToBitMask(mask);
   }
@@ -1346,6 +1385,19 @@ struct Filter<T, A, 8> {
 
 template <typename A>
 struct Crc32<uint64_t, A> {
+  static uint32_t
+  apply(uint32_t checksum, uint64_t value, const xsimd::generic&) {
+    checksum ^= static_cast<uint32_t>(value);
+    for (int i = 0; i < 32; ++i) {
+      checksum = (checksum >> 1) ^ (0x82F63B78 & -(checksum & 1));
+    }
+    checksum ^= static_cast<uint32_t>(value >> 32);
+    for (int i = 0; i < 32; ++i) {
+      checksum = (checksum >> 1) ^ (0x82F63B78 & -(checksum & 1));
+    }
+    return checksum;
+  }
+
 #if XSIMD_WITH_SSE4_2
   static uint32_t
   apply(uint32_t checksum, uint64_t value, const xsimd::sse4_2&) {
diff --git a/velox/common/base/SimdUtil.h b/velox/common/base/SimdUtil.h
index 1aabc0f2952..176b3acae43 100644
--- a/velox/common/base/SimdUtil.h
+++ b/velox/common/base/SimdUtil.h
@@ -16,7 +16,10 @@
 
 #pragma once
 
+#include <algorithm>
 #include <cstdint>
+#include <type_traits>
+
 #include "velox/common/base/BitUtil.h"
 #include "velox/common/base/Exceptions.h"
 
@@ -364,6 +367,29 @@ auto toBitMask(xsimd::batch_bool<T, A> mask, const A& arch = {}) {
   return detail::BitMask<T, A>::toBitMask(mask, arch);
 }
 
+/// Returns true if at least one lane in the mask is true.
+template <typename T, typename A = xsimd::default_arch>
+inline bool any(xsimd::batch_bool<T, A> mask, const A& arch = {}) {
+#if XSIMD_WITH_AVX2
+  // x86 bitmasks perform better than xsimd reductions.
+  return toBitMask<T, A>(mask, arch) != 0;
+#else
+  (void)arch;
+  return xsimd::any<T, A>(mask);
+#endif
+}
+
+/// Returns true if no lanes in the mask are true.
+template <typename T, typename A = xsimd::default_arch>
+inline bool none(xsimd::batch_bool<T, A> mask, const A& arch = {}) {
+#if XSIMD_WITH_AVX2
+  return toBitMask<T, A>(mask, arch) == 0;
+#else
+  (void)arch;
+  return xsimd::none<T, A>(mask);
+#endif
+}
+
 // Get a vector mask from bit mask.
 template <typename T, typename BitMaskType, typename A = xsimd::default_arch>
 xsimd::batch_bool<T, A> fromBitMask(BitMaskType bitMask, const A& arch = {}) {
@@ -377,6 +403,17 @@ auto allSetBitMask(const A& = {}) {
   return detail::BitMask<T, A>::kAllSet;
 }
 
+/// Returns true if every lane in the mask is true.
+template <typename T, typename A = xsimd::default_arch>
+inline bool all(xsimd::batch_bool<T, A> mask, const A& arch = {}) {
+#if XSIMD_WITH_AVX2
+  return toBitMask<T, A>(mask, arch) == allSetBitMask<T>(arch);
+#else
+  (void)arch;
+  return xsimd::all<T, A>(mask);
+#endif
+}
+
 namespace detail {
 template <typename T, typename A, size_t kSizeT = sizeof(T)>
 struct Filter;
@@ -430,6 +467,7 @@ uint32_t crc32U64(uint32_t checksum, uint64_t value, const A& arch = {}) {
 template <typename T, typename A = xsimd::default_arch>
 xsimd::batch<T, A> iota(const A& = {});
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
 // Returns a batch with all elements set to value.  For batch<bool> we
 // use one bit to represent one element.
 template <typename T, typename A = xsimd::default_arch>
@@ -445,6 +483,7 @@ xsimd::batch<T, A> setAll(T value, const A& = {}) {
     return xsimd::broadcast<T, A>(value);
   }
 }
+#endif
 
 // Stores 'data' into 'destination' for the lanes in 'mask'. 'mask' is expected
 // to specify contiguous lower lanes of 'batch'. For non-SIMD cases, 'mask' is
@@ -529,6 +568,43 @@ inline void memcpy(void* to, const void* from, int64_t bytes, const A& = {});
 template <typename A = xsimd::default_arch>
 void memset(void* to, char data, int32_t bytes, const A& = {});
 
+// Fills 'count' elements of 'output' with 'value' using SIMD broadcast+store
+// for types that support it (int32_t, uint32_t, int64_t, uint64_t, float,
+// double), and falls back to std::fill for other types.
+//
+// Uses a simpler structure than std::fill's auto-vectorized code — broadcast +
+// tight store loop + overlapping tail — that performs better for repeated calls
+// with small variable-length fills.
+template <typename T>
+inline void simdFill(T* output, T value, uint32_t count) {
+  if constexpr (
+      std::is_same_v<T, int32_t> || std::is_same_v<T, uint32_t> ||
+      std::is_same_v<T, int64_t> || std::is_same_v<T, uint64_t> ||
+      std::is_same_v<T, float> || std::is_same_v<T, double>) {
+    constexpr auto kBatchSize = xsimd::batch<T>::size;
+    if (count >= kBatchSize) {
+      auto batch = xsimd::broadcast<T>(value);
+      uint32_t i = 0;
+      for (; i + kBatchSize <= count; i += kBatchSize) {
+        batch.store_unaligned(output + i);
+      }
+      // Handle tail with an overlapping store. Safe because we're filling
+      // with a constant value, so re-writing already-written positions is
+      // harmless. The outer 'count >= kBatchSize' guard ensures
+      // 'count - kBatchSize' never underflows.
+      if (i < count) {
+        batch.store_unaligned(output + count - kBatchSize);
+      }
+    } else {
+      for (uint32_t i = 0; i < count; ++i) {
+        output[i] = value;
+      }
+    }
+  } else {
+    std::fill(output, output + count, value);
+  }
+}
+
 // Calls a different instantiation of a template function according to
 // 'numBytes'.
 #define VELOX_WIDTH_DISPATCH(numBytes, TEMPLATE_FUNC, ...) \
diff --git a/velox/common/base/SkewedPartitionBalancer.cpp b/velox/common/base/SkewedPartitionBalancer.cpp
index 52ea170d0c6..7a1b4a6efa3 100644
--- a/velox/common/base/SkewedPartitionBalancer.cpp
+++ b/velox/common/base/SkewedPartitionBalancer.cpp
@@ -30,9 +30,10 @@ SkewedPartitionRebalancer::SkewedPartitionRebalancer(
       numTasks_(numTasks),
       minProcessedBytesRebalanceThresholdPerPartition_(
           minProcessedBytesRebalanceThresholdPerPartition),
-      minProcessedBytesRebalanceThreshold_(std::max(
-          minProcessedBytesRebalanceThreshold,
-          minProcessedBytesRebalanceThresholdPerPartition_)),
+      minProcessedBytesRebalanceThreshold_(
+          std::max(
+              minProcessedBytesRebalanceThreshold,
+              minProcessedBytesRebalanceThresholdPerPartition_)),
       partitionRowCount_(numPartitions_),
       partitionAssignments_(numPartitions_) {
   VELOX_CHECK_GT(numPartitions_, 0);
diff --git a/velox/common/base/SkewedPartitionBalancer.h b/velox/common/base/SkewedPartitionBalancer.h
index 3c998920c1e..e145fa47381 100644
--- a/velox/common/base/SkewedPartitionBalancer.h
+++ b/velox/common/base/SkewedPartitionBalancer.h
@@ -15,6 +15,8 @@
  */
 #pragma once
 
+#include <folly/SharedMutex.h>
+
 #include "velox/common/base/IndexedPriorityQueue.h"
 
 namespace facebook::velox::common {
diff --git a/velox/common/base/SpillConfig.cpp b/velox/common/base/SpillConfig.cpp
index dd428a41ec7..caf55d77386 100644
--- a/velox/common/base/SpillConfig.cpp
+++ b/velox/common/base/SpillConfig.cpp
@@ -34,8 +34,10 @@ SpillConfig::SpillConfig(
     uint64_t _maxSpillRunRows,
     uint64_t _writerFlushThresholdSize,
     const std::string& _compressionKind,
+    uint32_t _numMaxMergeFiles,
     std::optional<PrefixSortConfig> _prefixSortConfig,
-    const std::string& _fileCreateConfig)
+    const std::string& _fileCreateConfig,
+    uint32_t _windowMinReadBatchRows)
     : getSpillDirPathCb(std::move(_getSpillDirPathCb)),
       updateAndCheckSpillLimitCb(std::move(_updateAndCheckSpillLimitCb)),
       fileNamePrefix(std::move(_fileNamePrefix)),
@@ -53,12 +55,18 @@ SpillConfig::SpillConfig(
       maxSpillRunRows(_maxSpillRunRows),
       writerFlushThresholdSize(_writerFlushThresholdSize),
       compressionKind(common::stringToCompressionKind(_compressionKind)),
+      numMaxMergeFiles(_numMaxMergeFiles),
       prefixSortConfig(_prefixSortConfig),
-      fileCreateConfig(_fileCreateConfig) {
+      fileCreateConfig(_fileCreateConfig),
+      windowMinReadBatchRows(_windowMinReadBatchRows) {
   VELOX_USER_CHECK_GE(
       spillableReservationGrowthPct,
       minSpillableReservationPct,
       "Spillable memory reservation growth pct should not be lower than minimum available pct");
+  VELOX_CHECK_NE(
+      numMaxMergeFiles,
+      1,
+      "NumMaxMergeFiles should not be 1 as merging should take at least 2 files to make progress");
 }
 
 int32_t SpillConfig::spillLevel(uint8_t startBitOffset) const {
diff --git a/velox/common/base/SpillConfig.h b/velox/common/base/SpillConfig.h
index 7f30bc6e614..adec0274e9d 100644
--- a/velox/common/base/SpillConfig.h
+++ b/velox/common/base/SpillConfig.h
@@ -52,6 +52,13 @@ using GetSpillDirectoryPathCB = std::function<std::string_view()>;
 /// bytes exceed the set limit.
 using UpdateAndCheckSpillLimitCB = std::function<void(uint64_t)>;
 
+/// Specifies the options for spill to disk.
+struct SpillDiskOptions {
+  std::string spillDirPath;
+  bool spillDirCreated{true};
+  std::function<std::string()> spillDirCreateCb{nullptr};
+};
+
 /// Specifies the config for spilling.
 struct SpillConfig {
   SpillConfig() = default;
@@ -71,8 +78,10 @@ struct SpillConfig {
       uint64_t _maxSpillRunRows,
       uint64_t _writerFlushThresholdSize,
       const std::string& _compressionKind,
+      uint32_t numMaxMergeFiles,
       std::optional<PrefixSortConfig> _prefixSortConfig = std::nullopt,
-      const std::string& _fileCreateConfig = {});
+      const std::string& _fileCreateConfig = {},
+      uint32_t _windowMinReadBatchRows = 1'000);
 
   /// Returns the spilling level with given 'startBitOffset' and
   /// 'numPartitionBits'.
@@ -151,11 +160,22 @@ struct SpillConfig {
   /// CompressionKind when spilling, CompressionKind_NONE means no compression.
   common::CompressionKind compressionKind;
 
+  /// The max number of files to merge at a time when merging sorted files into
+  /// a single ordered stream. 0 means unlimited. This is used to reduce memory
+  /// pressure by capping the number of open files when merging spilled sorted
+  /// files to avoid using too much memory and causing OOM. Note that this is
+  /// only applicable for ordered spill, is not applicable for spill scenarios
+  /// that don't need sorting, e.g. HashJoin.
+  uint32_t numMaxMergeFiles{0};
+
   /// Prefix sort config when spilling, enable prefix sort when this config is
   /// set, otherwise, fallback to timsort.
   std::optional<PrefixSortConfig> prefixSortConfig;
 
   /// Custom options passed to velox::FileSystem to create spill WriteFile.
   std::string fileCreateConfig;
+
+  /// The minimum number of rows to read when processing spilled window data.
+  uint32_t windowMinReadBatchRows;
 };
 } // namespace facebook::velox::common
diff --git a/velox/common/base/SpillStats.cpp b/velox/common/base/SpillStats.cpp
deleted file mode 100644
index 07b60692db0..00000000000
--- a/velox/common/base/SpillStats.cpp
+++ /dev/null
@@ -1,267 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/common/base/SpillStats.h"
-#include "velox/common/base/Counters.h"
-#include "velox/common/base/Exceptions.h"
-#include "velox/common/base/StatsReporter.h"
-#include "velox/common/base/SuccinctPrinter.h"
-
-namespace facebook::velox::common {
-namespace {
-std::vector<folly::Synchronized<SpillStats>>& allSpillStats() {
-  static std::vector<folly::Synchronized<SpillStats>> spillStatsList(
-      std::thread::hardware_concurrency());
-  return spillStatsList;
-}
-
-folly::Synchronized<SpillStats>& localSpillStats() {
-  const auto idx = std::hash<std::thread::id>{}(std::this_thread::get_id());
-  auto& spillStatsVector = allSpillStats();
-  return spillStatsVector[idx % spillStatsVector.size()];
-}
-} // namespace
-
-SpillStats::SpillStats(
-    uint64_t _spillRuns,
-    uint64_t _spilledInputBytes,
-    uint64_t _spilledBytes,
-    uint64_t _spilledRows,
-    uint32_t _spilledPartitions,
-    uint64_t _spilledFiles,
-    uint64_t _spillFillTimeNanos,
-    uint64_t _spillSortTimeNanos,
-    uint64_t _spillExtractVectorTimeNanos,
-    uint64_t _spillSerializationTimeNanos,
-    uint64_t _spillWrites,
-    uint64_t _spillFlushTimeNanos,
-    uint64_t _spillWriteTimeNanos,
-    uint64_t _spillMaxLevelExceededCount,
-    uint64_t _spillReadBytes,
-    uint64_t _spillReads,
-    uint64_t _spillReadTimeNanos,
-    uint64_t _spillDeserializationTimeNanos)
-    : spillRuns(_spillRuns),
-      spilledInputBytes(_spilledInputBytes),
-      spilledBytes(_spilledBytes),
-      spilledRows(_spilledRows),
-      spilledPartitions(_spilledPartitions),
-      spilledFiles(_spilledFiles),
-      spillFillTimeNanos(_spillFillTimeNanos),
-      spillSortTimeNanos(_spillSortTimeNanos),
-      spillExtractVectorTimeNanos(_spillExtractVectorTimeNanos),
-      spillSerializationTimeNanos(_spillSerializationTimeNanos),
-      spillWrites(_spillWrites),
-      spillFlushTimeNanos(_spillFlushTimeNanos),
-      spillWriteTimeNanos(_spillWriteTimeNanos),
-      spillMaxLevelExceededCount(_spillMaxLevelExceededCount),
-      spillReadBytes(_spillReadBytes),
-      spillReads(_spillReads),
-      spillReadTimeNanos(_spillReadTimeNanos),
-      spillDeserializationTimeNanos(_spillDeserializationTimeNanos) {}
-
-SpillStats& SpillStats::operator+=(const SpillStats& other) {
-  spillRuns += other.spillRuns;
-  spilledInputBytes += other.spilledInputBytes;
-  spilledBytes += other.spilledBytes;
-  spilledRows += other.spilledRows;
-  spilledPartitions += other.spilledPartitions;
-  spilledFiles += other.spilledFiles;
-  spillFillTimeNanos += other.spillFillTimeNanos;
-  spillSortTimeNanos += other.spillSortTimeNanos;
-  spillExtractVectorTimeNanos += other.spillExtractVectorTimeNanos;
-  spillSerializationTimeNanos += other.spillSerializationTimeNanos;
-  spillWrites += other.spillWrites;
-  spillFlushTimeNanos += other.spillFlushTimeNanos;
-  spillWriteTimeNanos += other.spillWriteTimeNanos;
-  spillMaxLevelExceededCount += other.spillMaxLevelExceededCount;
-  spillReadBytes += other.spillReadBytes;
-  spillReads += other.spillReads;
-  spillReadTimeNanos += other.spillReadTimeNanos;
-  spillDeserializationTimeNanos += other.spillDeserializationTimeNanos;
-  return *this;
-}
-
-SpillStats SpillStats::operator-(const SpillStats& other) const {
-  SpillStats result;
-  result.spillRuns = spillRuns - other.spillRuns;
-  result.spilledInputBytes = spilledInputBytes - other.spilledInputBytes;
-  result.spilledBytes = spilledBytes - other.spilledBytes;
-  result.spilledRows = spilledRows - other.spilledRows;
-  result.spilledPartitions = spilledPartitions - other.spilledPartitions;
-  result.spilledFiles = spilledFiles - other.spilledFiles;
-  result.spillFillTimeNanos = spillFillTimeNanos - other.spillFillTimeNanos;
-  result.spillSortTimeNanos = spillSortTimeNanos - other.spillSortTimeNanos;
-  result.spillExtractVectorTimeNanos =
-      spillExtractVectorTimeNanos - other.spillExtractVectorTimeNanos;
-  result.spillDeserializationTimeNanos =
-      spillExtractVectorTimeNanos - other.spillExtractVectorTimeNanos;
-  result.spillSerializationTimeNanos =
-      spillSerializationTimeNanos - other.spillSerializationTimeNanos;
-  result.spillWrites = spillWrites - other.spillWrites;
-  result.spillFlushTimeNanos = spillFlushTimeNanos - other.spillFlushTimeNanos;
-  result.spillWriteTimeNanos = spillWriteTimeNanos - other.spillWriteTimeNanos;
-  result.spillMaxLevelExceededCount =
-      spillMaxLevelExceededCount - other.spillMaxLevelExceededCount;
-  result.spillReadBytes = spillReadBytes - other.spillReadBytes;
-  result.spillReads = spillReads - other.spillReads;
-  result.spillReadTimeNanos = spillReadTimeNanos - other.spillReadTimeNanos;
-  result.spillDeserializationTimeNanos =
-      spillDeserializationTimeNanos - other.spillDeserializationTimeNanos;
-  return result;
-}
-
-void SpillStats::reset() {
-  spillRuns = 0;
-  spilledInputBytes = 0;
-  spilledBytes = 0;
-  spilledRows = 0;
-  spilledPartitions = 0;
-  spilledFiles = 0;
-  spillFillTimeNanos = 0;
-  spillSortTimeNanos = 0;
-  spillExtractVectorTimeNanos = 0;
-  spillSerializationTimeNanos = 0;
-  spillWrites = 0;
-  spillFlushTimeNanos = 0;
-  spillWriteTimeNanos = 0;
-  spillMaxLevelExceededCount = 0;
-  spillReadBytes = 0;
-  spillReads = 0;
-  spillReadTimeNanos = 0;
-  spillDeserializationTimeNanos = 0;
-}
-
-std::string SpillStats::toString() const {
-  return fmt::format(
-      "spillRuns[{}] spilledInputBytes[{}] spilledBytes[{}] spilledRows[{}] "
-      "spilledPartitions[{}] spilledFiles[{}] spillFillTimeNanos[{}] "
-      "spillSortTimeNanos[{}] spillExtractVectorTime[{}] spillSerializationTimeNanos[{}] spillWrites[{}] "
-      "spillFlushTimeNanos[{}] spillWriteTimeNanos[{}] maxSpillExceededLimitCount[{}] "
-      "spillReadBytes[{}] spillReads[{}] spillReadTimeNanos[{}] "
-      "spillReadDeserializationTimeNanos[{}]",
-      spillRuns,
-      succinctBytes(spilledInputBytes),
-      succinctBytes(spilledBytes),
-      spilledRows,
-      spilledPartitions,
-      spilledFiles,
-      succinctNanos(spillFillTimeNanos),
-      succinctNanos(spillSortTimeNanos),
-      succinctNanos(spillExtractVectorTimeNanos),
-      succinctNanos(spillSerializationTimeNanos),
-      spillWrites,
-      succinctNanos(spillFlushTimeNanos),
-      succinctNanos(spillWriteTimeNanos),
-      spillMaxLevelExceededCount,
-      succinctBytes(spillReadBytes),
-      spillReads,
-      succinctNanos(spillReadTimeNanos),
-      succinctNanos(spillDeserializationTimeNanos));
-}
-
-void updateGlobalSpillRunStats(uint64_t numRuns) {
-  auto statsLocked = localSpillStats().wlock();
-  statsLocked->spillRuns += numRuns;
-}
-
-void updateGlobalSpillAppendStats(
-    uint64_t numRows,
-    uint64_t serializationTimeNs) {
-  RECORD_METRIC_VALUE(kMetricSpilledRowsCount, numRows);
-  RECORD_HISTOGRAM_METRIC_VALUE(
-      kMetricSpillSerializationTimeMs, serializationTimeNs / 1'000'000);
-  auto statsLocked = localSpillStats().wlock();
-  statsLocked->spilledRows += numRows;
-  statsLocked->spillSerializationTimeNanos += serializationTimeNs;
-}
-
-void incrementGlobalSpilledPartitionStats() {
-  ++localSpillStats().wlock()->spilledPartitions;
-}
-
-void updateGlobalSpillFillTime(uint64_t timeNs) {
-  RECORD_HISTOGRAM_METRIC_VALUE(kMetricSpillFillTimeMs, timeNs / 1'000'000);
-  localSpillStats().wlock()->spillFillTimeNanos += timeNs;
-}
-
-void updateGlobalSpillSortTime(uint64_t timeNs) {
-  RECORD_HISTOGRAM_METRIC_VALUE(kMetricSpillSortTimeMs, timeNs / 1'000'000);
-  localSpillStats().wlock()->spillSortTimeNanos += timeNs;
-}
-
-void updateGlobalSpillExtractVectorTime(uint64_t timeNs) {
-  RECORD_HISTOGRAM_METRIC_VALUE(
-      kMetricSpillExtractVectorTimeMs, timeNs / 1'000'000);
-  localSpillStats().wlock()->spillExtractVectorTimeNanos += timeNs;
-}
-
-void updateGlobalSpillWriteStats(
-    uint64_t spilledBytes,
-    uint64_t flushTimeNs,
-    uint64_t writeTimeNs) {
-  RECORD_METRIC_VALUE(kMetricSpillWritesCount);
-  RECORD_METRIC_VALUE(kMetricSpilledBytes, spilledBytes);
-  RECORD_HISTOGRAM_METRIC_VALUE(
-      kMetricSpillFlushTimeMs, flushTimeNs / 1'000'000);
-  RECORD_HISTOGRAM_METRIC_VALUE(
-      kMetricSpillWriteTimeMs, writeTimeNs / 1'000'000);
-  auto statsLocked = localSpillStats().wlock();
-  ++statsLocked->spillWrites;
-  statsLocked->spilledBytes += spilledBytes;
-  statsLocked->spillFlushTimeNanos += flushTimeNs;
-  statsLocked->spillWriteTimeNanos += writeTimeNs;
-}
-
-void updateGlobalSpillReadStats(
-    uint64_t spillReads,
-    uint64_t spillReadBytes,
-    uint64_t spillReadTimeNs) {
-  auto statsLocked = localSpillStats().wlock();
-  statsLocked->spillReads += spillReads;
-  statsLocked->spillReadBytes += spillReadBytes;
-  statsLocked->spillReadTimeNanos += spillReadTimeNs;
-}
-
-void updateGlobalSpillMemoryBytes(uint64_t spilledInputBytes) {
-  RECORD_METRIC_VALUE(kMetricSpilledInputBytes, spilledInputBytes);
-  auto statsLocked = localSpillStats().wlock();
-  statsLocked->spilledInputBytes += spilledInputBytes;
-}
-
-void incrementGlobalSpilledFiles() {
-  RECORD_METRIC_VALUE(kMetricSpilledFilesCount);
-  ++localSpillStats().wlock()->spilledFiles;
-}
-
-void updateGlobalMaxSpillLevelExceededCount(
-    uint64_t maxSpillLevelExceededCount) {
-  localSpillStats().wlock()->spillMaxLevelExceededCount +=
-      maxSpillLevelExceededCount;
-}
-
-void updateGlobalSpillDeserializationTimeNs(uint64_t timeNs) {
-  localSpillStats().wlock()->spillDeserializationTimeNanos += timeNs;
-}
-
-SpillStats globalSpillStats() {
-  SpillStats gSpillStats;
-  for (auto& spillStats : allSpillStats()) {
-    gSpillStats += spillStats.copy();
-  }
-  return gSpillStats;
-}
-} // namespace facebook::velox::common
diff --git a/velox/common/base/SplitBlockBloomFilter.cpp b/velox/common/base/SplitBlockBloomFilter.cpp
new file mode 100644
index 00000000000..ef4d5e87c56
--- /dev/null
+++ b/velox/common/base/SplitBlockBloomFilter.cpp
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/SplitBlockBloomFilter.h"
+
+#include "velox/common/base/BitUtil.h"
+#include "velox/common/base/Exceptions.h"
+
+#include <bit>
+#include <sstream>
+
+namespace facebook::velox {
+
+int64_t SplitBlockBloomFilter::numBlocks(
+    int64_t numElements,
+    double falsePositive) {
+  constexpr int K = xsimd::batch<uint32_t>::size;
+  int64_t numBits = std::ceil(
+      -K * numElements / std::log(1 - std::pow(falsePositive, 1.0 / K)));
+  return bits::divRoundUp(numBits, 8 * sizeof(Block));
+}
+
+SplitBlockBloomFilter::SplitBlockBloomFilter(const std::span<Block>& blocks)
+    : blocks_(blocks) {
+  VELOX_CHECK_EQ(reinterpret_cast<uintptr_t>(blocks.data()) % sizeof(Block), 0);
+}
+
+std::string SplitBlockBloomFilter::debugString() const {
+  std::ostringstream out;
+  out << "numBlocks=" << blocks_.size() << '\n';
+  int64_t byBlockSetBits[1 + 8 * sizeof(Block)]{};
+  int64_t byBitPosition[8 * sizeof(Block)]{};
+  for (auto& block : blocks_) {
+    int numSetBits = 0;
+    for (int i = 0; i < xsimd::batch<uint32_t>::size; ++i) {
+      auto n = std::popcount(block.data[i]);
+      numSetBits += n;
+      for (int j = 0; j < 32; ++j) {
+        byBitPosition[j + i * 32] += 1 & (block.data[i] >> j);
+      }
+    }
+    ++byBlockSetBits[numSetBits];
+  }
+  for (int i = 0; i <= 8 * sizeof(Block); ++i) {
+    out << "Block set bits " << i << ": " << byBlockSetBits[i] << '\n';
+  }
+  for (int i = 0; i < 8 * sizeof(Block); ++i) {
+    out << "Bit " << i << ": " << byBitPosition[i] << '\n';
+  }
+  return out.str();
+}
+
+} // namespace facebook::velox
diff --git a/velox/common/base/SplitBlockBloomFilter.h b/velox/common/base/SplitBlockBloomFilter.h
new file mode 100644
index 00000000000..b5a40f88c3b
--- /dev/null
+++ b/velox/common/base/SplitBlockBloomFilter.h
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/base/SimdUtil.h"
+
+#include <cstdint>
+#include <span>
+
+namespace facebook::velox {
+
+/// SIMDized bloom filter implementation.  We take 8 or 4 (depending on the SIMD
+/// register size) bits from the inserted value, and split them into a block.  A
+/// block is the same size of a SIMD register.
+///
+/// This data structure is not responsible for memory management or hashing.
+///
+/// A detailed explanation about how the data structure works can be found here:
+/// https://parquet.apache.org/docs/file-format/bloomfilter/
+class SplitBlockBloomFilter {
+ public:
+  /// A block is basically a SIMD register.  Made public so user can calculate
+  /// the size needed for memory allocation; otherwise it's implementation
+  /// detail.
+  struct alignas(sizeof(xsimd::batch<uint32_t>)) Block {
+    uint32_t data[xsimd::batch<uint32_t>::size];
+  };
+
+  /// Calculate the number of blocks needed to satisfy certain number of inserts
+  /// and false positive rate.  A rough estimation between the memory usage and
+  /// false positive rate can be found below:
+  ///
+  /// | Bits of space per insert | False positive probability |
+  /// |--------------------------|----------------------------|
+  /// |                      6.0 |                        10% |
+  /// |                     10.5 |                         1% |
+  /// |                     16.9 |                       0.1% |
+  /// |                     26.4 |                      0.01% |
+  /// |                       41 |                     0.001% |
+  static int64_t numBlocks(int64_t numElements, double falsePositive);
+
+  /// Construct the bloom filter using the blocks memory passed as parameter.
+  /// The block memory address must be aligned with block size (i.e. SIMD
+  /// register size).  It is recommended to use numBlocks() to calculate the
+  /// number of block for allocation.
+  explicit SplitBlockBloomFilter(const std::span<Block>& blocks);
+
+  /// Delete copy constructor and assignment to avoid accidentally mutating the
+  /// same underlying block data from multiple places.
+  SplitBlockBloomFilter(const SplitBlockBloomFilter&) = delete;
+  SplitBlockBloomFilter& operator=(const SplitBlockBloomFilter&) = delete;
+
+  SplitBlockBloomFilter(SplitBlockBloomFilter&&) = default;
+
+  /// Insert a hash into the bloom filter.  The function used to generate this
+  /// hash should be avalanching.
+  void insert(uint64_t hash) {
+    auto mask = makeMask(hash);
+    auto* block = blocks_[blockIndex(hash)].data;
+    (xsimd::load_aligned(block) | mask).store_aligned(block);
+  }
+
+  /// Check whether a hash has been inserted before.  Could return true when it
+  /// has not been inserted.  Never return false when the hash has been
+  /// inserted.
+  bool mayContain(uint64_t hash) const {
+    auto mask = makeMask(hash);
+    auto block = xsimd::load_aligned(blocks_[blockIndex(hash)].data);
+#if XSIMD_WITH_AVX
+    return _mm256_testc_si256(block, mask);
+#else
+    return xsimd::all(xsimd::bitwise_andnot(mask, block) == 0);
+#endif
+  }
+
+  /// Return the block index of the given hash.
+  uint64_t blockIndex(uint64_t hash) const {
+    return ((hash >> 32) * blocks_.size()) >> 32;
+  }
+
+  std::string debugString() const;
+
+ private:
+  static_assert(64 % sizeof(Block) == 0);
+
+  template <typename A = xsimd::default_arch>
+  static xsimd::batch<uint32_t, A> makeSaltsVec() {
+    constexpr uint32_t kSalts[] = {
+        0x2df1424bU,
+        0x44974d91U,
+        0x47b6137bU,
+        0x5c6bfb31U,
+        0x705495c7U,
+        0x8824ad5bU,
+        0x9efc4947U,
+        0xa2b7289dU,
+    };
+    if constexpr (xsimd::batch<uint32_t, A>::size == 8) {
+      return xsimd::batch<uint32_t, A>(
+          kSalts[0],
+          kSalts[1],
+          kSalts[2],
+          kSalts[3],
+          kSalts[4],
+          kSalts[5],
+          kSalts[6],
+          kSalts[7]);
+    } else {
+      static_assert(xsimd::batch<uint32_t, A>::size == 4);
+      return xsimd::batch<uint32_t, A>(
+          kSalts[0], kSalts[2], kSalts[4], kSalts[6]);
+    }
+  }
+
+  static xsimd::batch<uint32_t> makeMask(uint32_t hash) {
+    auto shifts = (makeSaltsVec() * xsimd::broadcast(hash)) >> 27;
+    return xsimd::broadcast<uint32_t>(1) << shifts;
+  }
+
+  std::span<Block> const blocks_;
+};
+
+} // namespace facebook::velox
diff --git a/velox/common/base/StatsReporter.h b/velox/common/base/StatsReporter.h
index 94d0bd32c4f..9df453a75db 100644
--- a/velox/common/base/StatsReporter.h
+++ b/velox/common/base/StatsReporter.h
@@ -63,7 +63,7 @@ enum class StatType {
   HISTOGRAM,
 };
 
-inline std::string statTypeString(StatType stat) {
+inline std::string_view statTypeString(StatType stat) {
   switch (stat) {
     case StatType::AVG:
       return "Avg";
@@ -76,7 +76,7 @@ inline std::string statTypeString(StatType stat) {
     case StatType::HISTOGRAM:
       return "Histogram";
     default:
-      return fmt::format("UNKNOWN: {}", static_cast<int>(stat));
+      return "Unknown";
   }
 }
 
@@ -84,17 +84,17 @@ inline std::string statTypeString(StatType stat) {
 /// different implementations.
 class BaseStatsReporter {
  public:
-  virtual ~BaseStatsReporter() {}
+  virtual ~BaseStatsReporter() = default;
 
   /// Register a stat of the given stat type.
   /// @param key The key to identify the stat.
   /// @param statType How the stat is aggregated.
   virtual void registerMetricExportType(const char* key, StatType statType)
-      const = 0;
+      const {}
 
   virtual void registerMetricExportType(
       folly::StringPiece key,
-      StatType statType) const = 0;
+      StatType statType) const {}
 
   /// Register a histogram with a list of percentiles defined.
   /// @param key The key to identify the histogram.
@@ -107,14 +107,14 @@ class BaseStatsReporter {
       int64_t bucketWidth,
       int64_t min,
       int64_t max,
-      const std::vector<int32_t>& pcts) const = 0;
+      const std::vector<int32_t>& pcts) const {}
 
   virtual void registerHistogramMetricExportType(
       folly::StringPiece key,
       int64_t bucketWidth,
       int64_t min,
       int64_t max,
-      const std::vector<int32_t>& pcts) const = 0;
+      const std::vector<int32_t>& pcts) const {}
 
   /// Register a quantile metric for quantile stats with export types,
   /// quantiles, and sliding window periods.
@@ -127,13 +127,13 @@ class BaseStatsReporter {
       const char* key,
       const std::vector<StatType>& statTypes,
       const std::vector<double>& pcts,
-      const std::vector<size_t>& slidingWindowsSeconds = {60}) const = 0;
+      const std::vector<size_t>& slidingWindowsSeconds = {60}) const {}
 
   virtual void registerQuantileMetricExportType(
       folly::StringPiece key,
       const std::vector<StatType>& statTypes,
       const std::vector<double>& pcts,
-      const std::vector<size_t>& slidingWindowsSeconds = {60}) const = 0;
+      const std::vector<size_t>& slidingWindowsSeconds = {60}) const {}
 
   /// Register a dynamic quantile metric with a template key pattern that
   /// supports runtime substitution.
@@ -145,60 +145,60 @@ class BaseStatsReporter {
       const char* keyPattern,
       const std::vector<StatType>& statTypes,
       const std::vector<double>& pcts,
-      const std::vector<size_t>& slidingWindowsSeconds = {60}) const = 0;
+      const std::vector<size_t>& slidingWindowsSeconds = {60}) const {}
 
   virtual void registerDynamicQuantileMetricExportType(
       folly::StringPiece keyPattern,
       const std::vector<StatType>& statTypes,
       const std::vector<double>& pcts,
-      const std::vector<size_t>& slidingWindowsSeconds = {60}) const = 0;
+      const std::vector<size_t>& slidingWindowsSeconds = {60}) const {}
 
   /// Add the given value to the stat.
-  virtual void addMetricValue(const std::string& key, size_t value = 1)
-      const = 0;
+  virtual void addMetricValue(const std::string& key, size_t value = 1) const {}
 
-  virtual void addMetricValue(const char* key, size_t value = 1) const = 0;
+  virtual void addMetricValue(const char* key, size_t value = 1) const {}
 
-  virtual void addMetricValue(folly::StringPiece key, size_t value = 1)
-      const = 0;
+  virtual void addMetricValue(folly::StringPiece key, size_t value = 1) const {}
 
   /// Add the given value to the histogram.
   virtual void addHistogramMetricValue(const std::string& key, size_t value)
-      const = 0;
+      const {}
 
-  virtual void addHistogramMetricValue(const char* key, size_t value) const = 0;
+  virtual void addHistogramMetricValue(const char* key, size_t value) const {}
 
   virtual void addHistogramMetricValue(folly::StringPiece key, size_t value)
-      const = 0;
+      const {}
 
   /// Add the given value to a quantile metric.
   virtual void addQuantileMetricValue(const std::string& key, size_t value = 1)
-      const = 0;
+      const {}
 
-  virtual void addQuantileMetricValue(const char* key, size_t value = 1)
-      const = 0;
+  virtual void addQuantileMetricValue(const char* key, size_t value = 1) const {
+  }
 
   virtual void addQuantileMetricValue(folly::StringPiece key, size_t value = 1)
-      const = 0;
+      const {}
 
   /// Add the given value to a quantile metric.
   virtual void addDynamicQuantileMetricValue(
       const std::string& key,
       folly::Range<const folly::StringPiece*> subkeys,
-      size_t value = 1) const = 0;
+      size_t value = 1) const {}
 
   virtual void addDynamicQuantileMetricValue(
       const char* key,
       folly::Range<const folly::StringPiece*> subkeys,
-      size_t value = 1) const = 0;
+      size_t value = 1) const {}
 
   virtual void addDynamicQuantileMetricValue(
       folly::StringPiece key,
       folly::Range<const folly::StringPiece*> subkeys,
-      size_t value = 1) const = 0;
+      size_t value = 1) const {}
 
   /// Return the aggregated metrics in a serialized string format.
-  virtual std::string fetchMetrics() = 0;
+  virtual std::string fetchMetrics() {
+    return "";
+  }
 
   static bool registered;
 };
diff --git a/velox/common/base/Status.h b/velox/common/base/Status.h
index 72ec5447618..1cf42673bc8 100644
--- a/velox/common/base/Status.h
+++ b/velox/common/base/Status.h
@@ -530,6 +530,9 @@ void Status::moveFrom(Status& s) {
 #define _VELOX_RETURN_IMPL(expr, exprStr, error, ...)                    \
   do {                                                                   \
     if (FOLLY_UNLIKELY(expr)) {                                          \
+      if (::facebook::velox::threadSkipErrorDetails()) {                 \
+        return error();                                                  \
+      }                                                                  \
       auto message = ::facebook::velox::errorMessage(__VA_ARGS__);       \
       return error(                                                      \
           ::facebook::velox::internal::generateError(message, exprStr)); \
diff --git a/velox/exec/TreeOfLosers.h b/velox/common/base/TreeOfLosers.h
similarity index 100%
rename from velox/exec/TreeOfLosers.h
rename to velox/common/base/TreeOfLosers.h
diff --git a/velox/common/base/VeloxException.cpp b/velox/common/base/VeloxException.cpp
index 735953d169a..3f0d0dec5db 100644
--- a/velox/common/base/VeloxException.cpp
+++ b/velox/common/base/VeloxException.cpp
@@ -16,9 +16,11 @@
 
 #include "velox/common/base/VeloxException.h"
 
-#include <folly/synchronization/AtomicStruct.h>
+#include <chrono>
 #include <exception>
 
+#include <folly/synchronization/AtomicStruct.h>
+
 namespace facebook {
 namespace velox {
 
@@ -102,6 +104,35 @@ VeloxException::VeloxException(
         state.isRetriable = isRetriable;
       })) {}
 
+VeloxException::VeloxException(
+    const char* file,
+    size_t line,
+    const char* function,
+    std::string_view failingExpression,
+    std::string_view message,
+    std::string_view errorSource,
+    std::string_view errorCode,
+    bool isRetriable,
+    CompileTimeStringLiteral messageTemplate,
+    Type exceptionType,
+    std::string_view exceptionName)
+    : VeloxException(State::make(exceptionType, [&](auto& state) {
+        state.exceptionType = exceptionType;
+        state.exceptionName = exceptionName;
+        state.file = file;
+        state.line = line;
+        state.function = function;
+        state.failingExpression = failingExpression;
+        state.message = message;
+        state.messageTemplate = messageTemplate;
+        state.errorSource = errorSource;
+        state.errorCode = errorCode;
+        state.context = getExceptionContext().message(exceptionType);
+        state.additionalContext =
+            getAdditionalExceptionContextString(exceptionType, state.context);
+        state.isRetriable = isRetriable;
+      })) {}
+
 VeloxException::VeloxException(
     const std::exception_ptr& e,
     std::string_view message,
@@ -169,6 +200,18 @@ bool isStackTraceEnabled(VeloxException::Type type) {
   return last->compare_exchange_strong(latest, now, std::memory_order_relaxed);
 }
 
+void stringAppendNumber(std::string& str, size_t number) {
+  // Manual implementation of itoa to avoid the cost of std::to_string.
+  const auto numberStartOffset = str.end() -
+      str.begin(); // Not `size()`. We need distance. The type is different.
+  size_t remaining = number;
+  do {
+    str += static_cast<char>('0' + remaining % 10);
+    remaining /= 10;
+  } while (remaining);
+  reverse(str.begin() + numberStartOffset, str.end());
+}
+
 } // namespace
 
 template <typename F>
@@ -248,13 +291,7 @@ void VeloxException::State::finalize() const {
 
   if (line) {
     elaborateMessage += "Line: ";
-    auto len = elaborateMessage.size();
-    size_t t = line;
-    do {
-      elaborateMessage += static_cast<char>('0' + t % 10);
-      t /= 10;
-    } while (t);
-    reverse(elaborateMessage.begin() + len, elaborateMessage.end());
+    stringAppendNumber(elaborateMessage, line);
     elaborateMessage += '\n';
   }
 
diff --git a/velox/common/base/VeloxException.h b/velox/common/base/VeloxException.h
index b9ffb813f4f..44d08cdd285 100644
--- a/velox/common/base/VeloxException.h
+++ b/velox/common/base/VeloxException.h
@@ -28,6 +28,8 @@
 
 #include "velox/common/process/StackTrace.h"
 
+#include "velox/common/base/ExceptionHelper.h"
+
 DECLARE_bool(velox_exception_user_stacktrace_enabled);
 DECLARE_bool(velox_exception_system_stacktrace_enabled);
 
@@ -139,6 +141,8 @@ class VeloxException : public std::exception {
  public:
   enum class Type { kUser = 0, kSystem = 1 };
 
+  /// Construct without an explicit message template. messageTemplate() will
+  /// return the message itself (the message IS the template).
   VeloxException(
       const char* file,
       size_t line,
@@ -151,6 +155,21 @@ class VeloxException : public std::exception {
       Type exceptionType = Type::kSystem,
       std::string_view exceptionName = "VeloxException");
 
+  /// Construct with an explicit message template (the format string before
+  /// fmt::format interpolation).
+  VeloxException(
+      const char* file,
+      size_t line,
+      const char* function,
+      std::string_view expression,
+      std::string_view message,
+      std::string_view errorSource,
+      std::string_view errorCode,
+      bool isRetriable,
+      CompileTimeStringLiteral messageTemplate,
+      Type exceptionType = Type::kSystem,
+      std::string_view exceptionName = "VeloxException");
+
   /// Wrap an std::exception.
   VeloxException(
       const std::exception_ptr& e,
@@ -202,6 +221,14 @@ class VeloxException : public std::exception {
     return state_->message;
   }
 
+  /// Returns the format template before fmt::format interpolation. Useful for
+  /// grouping exceptions by error category in monitoring systems. When no
+  /// explicit template was provided, returns the message itself.
+  std::string_view messageTemplate() const {
+    return state_->messageTemplate ? std::string_view(state_->messageTemplate)
+                                   : std::string_view(state_->message);
+  }
+
   const std::string& errorCode() const {
     return state_->errorCode;
   }
@@ -248,6 +275,10 @@ class VeloxException : public std::exception {
     const char* function = nullptr;
     std::string failingExpression;
     std::string message;
+    // The format template before fmt::format interpolation. Points to a
+    // string literal (static lifetime) when set explicitly, or nullptr when
+    // the message itself serves as the template.
+    const char* messageTemplate{nullptr};
     std::string errorSource;
     std::string errorCode;
     // The current exception context.
@@ -284,6 +315,8 @@ class VeloxException : public std::exception {
 
 class VeloxUserError : public VeloxException {
  public:
+  static constexpr std::string_view kDefaultName = "VeloxUserError";
+
   VeloxUserError(
       const char* file,
       size_t line,
@@ -293,7 +326,7 @@ class VeloxUserError : public VeloxException {
       std::string_view /* errorSource */,
       std::string_view errorCode,
       bool isRetriable,
-      std::string_view exceptionName = "VeloxUserError")
+      std::string_view exceptionName = kDefaultName)
       : VeloxException(
             file,
             line,
@@ -306,12 +339,36 @@ class VeloxUserError : public VeloxException {
             Type::kUser,
             exceptionName) {}
 
+  VeloxUserError(
+      const char* file,
+      size_t line,
+      const char* function,
+      std::string_view expression,
+      std::string_view message,
+      std::string_view /* errorSource */,
+      std::string_view errorCode,
+      bool isRetriable,
+      CompileTimeStringLiteral messageTemplate,
+      std::string_view exceptionName = kDefaultName)
+      : VeloxException(
+            file,
+            line,
+            function,
+            expression,
+            message,
+            error_source::kErrorSourceUser,
+            errorCode,
+            isRetriable,
+            messageTemplate,
+            Type::kUser,
+            exceptionName) {}
+
   /// Wrap an std::exception.
   VeloxUserError(
       const std::exception_ptr& e,
       std::string_view message,
       bool isRetriable,
-      std::string_view exceptionName = "VeloxUserError")
+      std::string_view exceptionName = kDefaultName)
       : VeloxException(
             e,
             message,
@@ -324,6 +381,30 @@ class VeloxUserError : public VeloxException {
 
 class VeloxRuntimeError final : public VeloxException {
  public:
+  static constexpr std::string_view kDefaultName = "VeloxRuntimeError";
+
+  VeloxRuntimeError(
+      const char* file,
+      size_t line,
+      const char* function,
+      std::string_view expression,
+      std::string_view message,
+      std::string_view /* errorSource */,
+      std::string_view errorCode,
+      bool isRetriable,
+      std::string_view exceptionName = kDefaultName)
+      : VeloxException(
+            file,
+            line,
+            function,
+            expression,
+            message,
+            error_source::kErrorSourceRuntime,
+            errorCode,
+            isRetriable,
+            Type::kSystem,
+            exceptionName) {}
+
   VeloxRuntimeError(
       const char* file,
       size_t line,
@@ -333,7 +414,8 @@ class VeloxRuntimeError final : public VeloxException {
       std::string_view /* errorSource */,
       std::string_view errorCode,
       bool isRetriable,
-      std::string_view exceptionName = "VeloxRuntimeError")
+      CompileTimeStringLiteral messageTemplate,
+      std::string_view exceptionName = kDefaultName)
       : VeloxException(
             file,
             line,
@@ -343,6 +425,7 @@ class VeloxRuntimeError final : public VeloxException {
             error_source::kErrorSourceRuntime,
             errorCode,
             isRetriable,
+            messageTemplate,
             Type::kSystem,
             exceptionName) {}
 
@@ -351,7 +434,7 @@ class VeloxRuntimeError final : public VeloxException {
       const std::exception_ptr& e,
       std::string_view message,
       bool isRetriable,
-      std::string_view exceptionName = "VeloxRuntimeError")
+      std::string_view exceptionName = kDefaultName)
       : VeloxException(
             e,
             message,
diff --git a/velox/common/base/XxHashInline.h b/velox/common/base/XxHashInline.h
new file mode 100644
index 00000000000..77b6b20ee4f
--- /dev/null
+++ b/velox/common/base/XxHashInline.h
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#define XXH_INLINE_ALL
+#include <xxhash.h> // @manual=third-party//xxHash:xxhash
diff --git a/velox/common/base/benchmarks/CMakeLists.txt b/velox/common/base/benchmarks/CMakeLists.txt
index cb7dcb1ab55..b4ffaf2f60a 100644
--- a/velox/common/base/benchmarks/CMakeLists.txt
+++ b/velox/common/base/benchmarks/CMakeLists.txt
@@ -42,3 +42,11 @@ target_link_libraries(
   PUBLIC Folly::follybenchmark
   PRIVATE velox_common_base Folly::folly
 )
+
+add_executable(velox_common_split_block_bloom_filter_benchmark SplitBlockBloomFilterBenchmark.cpp)
+
+target_link_libraries(
+  velox_common_split_block_bloom_filter_benchmark
+  PUBLIC Folly::follybenchmark
+  PRIVATE velox_common_base Folly::folly
+)
diff --git a/velox/common/base/benchmarks/SplitBlockBloomFilterBenchmark.cpp b/velox/common/base/benchmarks/SplitBlockBloomFilterBenchmark.cpp
new file mode 100644
index 00000000000..6706be84ab2
--- /dev/null
+++ b/velox/common/base/benchmarks/SplitBlockBloomFilterBenchmark.cpp
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/SplitBlockBloomFilter.h"
+
+#include <folly/Benchmark.h>
+#include <folly/Random.h>
+#include <folly/init/Init.h>
+
+#define VELOX_BENCHMARK(_make, _name, ...) \
+  [[maybe_unused]] auto _name = _make(FOLLY_PP_STRINGIZE(_name), __VA_ARGS__)
+
+namespace facebook::velox {
+namespace {
+
+template <typename T, typename Hasher>
+class SplitBlockBloomFilterBenchmark {
+ public:
+  SplitBlockBloomFilterBenchmark(
+      const char* name,
+      Hasher hasher,
+      double falsePositive,
+      int numInserts,
+      int numTests)
+      : hasher_(std::move(hasher)),
+        numTests_(numTests),
+        blocks_(SplitBlockBloomFilter::numBlocks(numInserts, falsePositive)),
+        filter_(blocks_) {
+    for (int i = 0; i < numInserts; ++i) {
+      filter_.insert(hasher_(generateValue()));
+    }
+    folly::addBenchmark(__FILE__, name, [this] { return run(); });
+  }
+
+ private:
+  static T generateValue() {
+    if constexpr (sizeof(T) == 8) {
+      return folly::Random::rand64();
+    } else {
+      static_assert(sizeof(T) == 4);
+      return folly::Random::rand32();
+    }
+  }
+
+  unsigned run() const {
+    int numHits = 0;
+    for (int i = 0; i < numTests_; ++i) {
+      numHits += filter_.mayContain(hasher_(generateValue()));
+    }
+    folly::doNotOptimizeAway(numHits);
+    return numTests_;
+  }
+
+  const Hasher hasher_;
+  const double numTests_;
+  std::vector<SplitBlockBloomFilter::Block> blocks_;
+  SplitBlockBloomFilter filter_;
+};
+
+template <typename T, typename Hasher>
+SplitBlockBloomFilterBenchmark<T, Hasher> makeBenchmark(
+    const char* name,
+    Hasher hasher,
+    double falsePositive,
+    int numInserts,
+    int numTests) {
+  return SplitBlockBloomFilterBenchmark<T, Hasher>(
+      name, std::move(hasher), falsePositive, numInserts, numTests);
+}
+
+} // namespace
+} // namespace facebook::velox
+
+int main(int argc, char* argv[]) {
+  using namespace facebook::velox;
+  folly::Init follyInit(&argc, &argv);
+  VELOX_BENCHMARK(
+      makeBenchmark<int32_t>,
+      int32,
+      folly::hasher<int64_t>(),
+      0.01,
+      5'000'000,
+      10'000'000);
+  VELOX_BENCHMARK(
+      makeBenchmark<int64_t>,
+      int64,
+      folly::hasher<int64_t>(),
+      0.01,
+      5'000'000,
+      10'000'000);
+  VELOX_BENCHMARK(
+      makeBenchmark<int64_t>,
+      int64_nohash,
+      folly::identity,
+      0.01,
+      5'000'000,
+      10'000'000);
+  VELOX_BENCHMARK(
+      makeBenchmark<int32_t>,
+      int32_small,
+      folly::hasher<int64_t>(),
+      0.01,
+      500'000,
+      1'000'000);
+  VELOX_BENCHMARK(
+      makeBenchmark<int64_t>,
+      int64_small,
+      folly::hasher<int64_t>(),
+      0.01,
+      500'000,
+      1'000'000);
+  VELOX_BENCHMARK(
+      makeBenchmark<int64_t>,
+      int64_nohash_small,
+      folly::identity,
+      0.01,
+      500'000,
+      1'000'000);
+  VELOX_BENCHMARK(
+      makeBenchmark<int32_t>,
+      int32_large,
+      folly::hasher<int64_t>(),
+      0.01,
+      50'000'000,
+      100'000'000);
+  VELOX_BENCHMARK(
+      makeBenchmark<int64_t>,
+      int64_large,
+      folly::hasher<int64_t>(),
+      0.01,
+      50'000'000,
+      100'000'000);
+  VELOX_BENCHMARK(
+      makeBenchmark<int64_t>,
+      int64_nohash_large,
+      folly::identity,
+      0.01,
+      50'000'000,
+      100'000'000);
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/common/base/benchmarks/StringSearchBenchmark.cpp b/velox/common/base/benchmarks/StringSearchBenchmark.cpp
index 5fee996709a..cad51cb56fa 100644
--- a/velox/common/base/benchmarks/StringSearchBenchmark.cpp
+++ b/velox/common/base/benchmarks/StringSearchBenchmark.cpp
@@ -105,11 +105,12 @@ class TestStringSearch {
   void runSearching(size_t iters) const {
     if constexpr (alg == SIMD) {
       FOR_EACH_RANGE (i, 0, iters)
-        doNotOptimizeAway(simd::simdStrstr(
-            heyStack_.data(),
-            heyStack_.size(),
-            needle_.data(),
-            needle_.size()));
+        doNotOptimizeAway(
+            simd::simdStrstr(
+                heyStack_.data(),
+                heyStack_.size(),
+                needle_.data(),
+                needle_.size()));
     } else if constexpr (alg == STD) {
       FOR_EACH_RANGE (i, 0, iters)
         doNotOptimizeAway(
diff --git a/velox/common/base/tests/AsyncSourceTest.cpp b/velox/common/base/tests/AsyncSourceTest.cpp
index 657a7ba8e08..a94cec99f9d 100644
--- a/velox/common/base/tests/AsyncSourceTest.cpp
+++ b/velox/common/base/tests/AsyncSourceTest.cpp
@@ -22,18 +22,76 @@
 #include <gtest/gtest.h>
 #include <thread>
 #include "velox/common/base/Exceptions.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TestValue.h"
 
 using namespace facebook::velox;
 using namespace std::chrono_literals;
 
-// A sample class to be constructed via AsyncSource.
+namespace {
 struct Gizmo {
   explicit Gizmo(int32_t _id) : id(_id) {}
 
   const int32_t id;
 };
 
-TEST(AsyncSourceTest, basic) {
+class DataCounter {
+ public:
+  DataCounter() {
+    objectNumber_ = ++numCreatedDataCounters_;
+  }
+
+  ~DataCounter() {
+    ++numDeletedDataCounters_;
+  }
+
+  static uint64_t numCreatedDataCounters() {
+    return numCreatedDataCounters_;
+  }
+
+  static uint64_t numDeletedDataCounters() {
+    return numDeletedDataCounters_;
+  }
+
+  static void reset() {
+    numCreatedDataCounters_ = 0;
+    numDeletedDataCounters_ = 0;
+  }
+
+  uint64_t objectNumber() const {
+    return objectNumber_;
+  }
+
+ private:
+  inline static std::atomic<uint64_t> numCreatedDataCounters_{0};
+  inline static std::atomic<uint64_t> numDeletedDataCounters_{0};
+
+  uint64_t objectNumber_{0};
+};
+
+void verifyContexts(
+    const std::string& expectedPoolName,
+    const std::string& expectedTaskId) {
+  EXPECT_EQ(process::GetThreadDebugInfo()->taskId_, expectedTaskId);
+}
+} // namespace
+
+class AsyncSourceTest : public ::testing::Test {
+ protected:
+  static void SetUpTestSuite() {
+    common::testutil::TestValue::enable();
+  }
+
+  void SetUp() override {
+    DataCounter::reset();
+  }
+
+  void TearDown() override {
+    DataCounter::reset();
+  }
+};
+
+TEST_F(AsyncSourceTest, basic) {
   AsyncSource<Gizmo> gizmo([]() { return std::make_unique<Gizmo>(11); });
   EXPECT_FALSE(gizmo.hasValue());
   gizmo.prepare();
@@ -45,15 +103,247 @@ TEST(AsyncSourceTest, basic) {
 
   AsyncSource<Gizmo> error(
       []() -> std::unique_ptr<Gizmo> { VELOX_USER_FAIL("Testing error"); });
-  EXPECT_THROW(error.move(), VeloxException);
+  VELOX_ASSERT_USER_THROW(error.move(), "Testing error");
   EXPECT_TRUE(error.hasValue());
 }
 
-TEST(AsyncSourceTest, threads) {
+TEST_F(AsyncSourceTest, close) {
+  {
+    auto dateCounter = std::make_shared<DataCounter>();
+    AsyncSource<uint64_t> countAsyncSource([dateCounter]() {
+      return std::make_unique<uint64_t>(dateCounter->objectNumber());
+    });
+    dateCounter.reset();
+    EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
+    EXPECT_EQ(DataCounter::numDeletedDataCounters(), 0);
+    EXPECT_EQ(0, countAsyncSource.prepareTiming().count);
+
+    countAsyncSource.close();
+
+    EXPECT_EQ(0, countAsyncSource.prepareTiming().count);
+    EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
+    EXPECT_EQ(DataCounter::numDeletedDataCounters(), 1);
+  }
+  DataCounter::reset();
+
+  {
+    auto asyncSource = std::make_shared<AsyncSource<DataCounter>>(
+        []() { return std::make_unique<DataCounter>(); });
+    asyncSource->prepare();
+    EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
+    EXPECT_EQ(DataCounter::numDeletedDataCounters(), 0);
+    EXPECT_EQ(1, asyncSource->prepareTiming().count);
+
+    asyncSource->close();
+    EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
+    EXPECT_EQ(DataCounter::numDeletedDataCounters(), 1);
+    EXPECT_EQ(1, asyncSource->prepareTiming().count);
+  }
+  DataCounter::reset();
+
+  {
+    folly::Baton<> baton;
+    auto sleepAsyncSource =
+        std::make_shared<AsyncSource<DataCounter>>([&baton]() {
+          baton.post();
+          return std::make_unique<DataCounter>();
+        });
+    auto thread =
+        std::thread([&sleepAsyncSource] { sleepAsyncSource->prepare(); });
+    EXPECT_TRUE(baton.try_wait_for(1s));
+    sleepAsyncSource->close();
+    EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
+    EXPECT_EQ(DataCounter::numDeletedDataCounters(), 1);
+    EXPECT_EQ(1, sleepAsyncSource->prepareTiming().count);
+    thread.join();
+  }
+}
+
+TEST_F(AsyncSourceTest, emptyContexts) {
+  EXPECT_EQ(process::GetThreadDebugInfo(), nullptr);
+
+  AsyncSource<bool> src([]() {
+    verifyContexts("test", "task_id");
+    return std::make_unique<bool>(true);
+  });
+
+  process::ThreadDebugInfo debugInfo{"query_id", "task_id", nullptr};
+  process::ScopedThreadDebugInfo scopedDebugInfo(debugInfo);
+
+  verifyContexts("test", "task_id");
+
+  ASSERT_TRUE(*src.move());
+
+  verifyContexts("test", "task_id");
+}
+
+TEST_F(AsyncSourceTest, setContexts) {
+  process::ThreadDebugInfo debugInfo1{"query_id1", "task_id1", nullptr};
+
+  std::unique_ptr<AsyncSource<bool>> src;
+  process::ScopedThreadDebugInfo scopedDebugInfo1(debugInfo1);
+
+  verifyContexts("test1", "task_id1");
+
+  src = std::make_unique<AsyncSource<bool>>(([]() {
+    verifyContexts("test1", "task_id1");
+    return std::make_unique<bool>(true);
+  }));
+
+  process::ThreadDebugInfo debugInfo2{"query_id2", "task_id2", nullptr};
+  process::ScopedThreadDebugInfo scopedDebugInfo2(debugInfo2);
+
+  verifyContexts("test2", "task_id2");
+
+  ASSERT_TRUE(*src->move());
+
+  verifyContexts("test2", "task_id2");
+}
+
+TEST_F(AsyncSourceTest, cancel) {
+  {
+    auto dataCounter = std::make_shared<DataCounter>();
+    auto asyncSource = std::make_shared<AsyncSource<uint64_t>>([dataCounter]() {
+      return std::make_unique<uint64_t>(dataCounter->objectNumber());
+    });
+    dataCounter.reset();
+
+    asyncSource->cancel();
+    EXPECT_EQ(DataCounter::numDeletedDataCounters(), 1);
+  }
+  DataCounter::reset();
+
+  {
+    folly::Baton<> startBaton;
+    folly::Baton<> finishBaton;
+    auto asyncSource = std::make_shared<AsyncSource<DataCounter>>(
+        [&startBaton, &finishBaton]() {
+          startBaton.post();
+          finishBaton.wait();
+          return std::make_unique<DataCounter>();
+        });
+
+    auto thread = std::thread([&asyncSource] { asyncSource->prepare(); });
+    EXPECT_TRUE(startBaton.try_wait_for(1s));
+
+    asyncSource->cancel();
+
+    finishBaton.post();
+    thread.join();
+
+    EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
+    EXPECT_TRUE(asyncSource->hasValue());
+    asyncSource->close();
+    EXPECT_EQ(1, asyncSource->prepareTiming().count);
+  }
+  DataCounter::reset();
+
+  {
+    auto asyncSource = std::make_shared<AsyncSource<DataCounter>>(
+        []() { return std::make_unique<DataCounter>(); });
+    asyncSource->prepare();
+
+    asyncSource->cancel();
+
+    EXPECT_FALSE(asyncSource->hasValue());
+    EXPECT_EQ(asyncSource->move(), nullptr);
+    EXPECT_EQ(1, asyncSource->prepareTiming().count);
+  }
+  DataCounter::reset();
+
+  {
+    std::atomic_bool taskExecuted{false};
+    auto asyncSource =
+        std::make_shared<AsyncSource<DataCounter>>([&taskExecuted]() {
+          taskExecuted = true;
+          return std::make_unique<DataCounter>();
+        });
+
+    asyncSource->cancel();
+    asyncSource->prepare();
+    EXPECT_FALSE(taskExecuted);
+    EXPECT_FALSE(asyncSource->hasValue());
+
+    EXPECT_EQ(asyncSource->move(), nullptr);
+    EXPECT_FALSE(taskExecuted);
+  }
+
+  {
+    auto dataCounter = std::make_shared<DataCounter>();
+    auto asyncSource = std::make_shared<AsyncSource<uint64_t>>([dataCounter]() {
+      return std::make_unique<uint64_t>(dataCounter->objectNumber());
+    });
+    dataCounter.reset();
+
+    asyncSource->cancel();
+    asyncSource->cancel();
+    EXPECT_EQ(DataCounter::numDeletedDataCounters(), 1);
+    EXPECT_EQ(0, asyncSource->prepareTiming().count);
+  }
+  DataCounter::reset();
+
+  {
+    folly::Baton<> moveStarted;
+    folly::Baton<> continueMove;
+    auto asyncSource = std::make_shared<AsyncSource<DataCounter>>(
+        [&moveStarted, &continueMove]() {
+          moveStarted.post();
+          continueMove.wait();
+          return std::make_unique<DataCounter>();
+        });
+
+    auto moveThread = std::thread([&asyncSource] {
+      auto result = asyncSource->move();
+      EXPECT_NE(result, nullptr);
+    });
+
+    EXPECT_TRUE(moveStarted.try_wait_for(1s));
+
+    asyncSource->cancel();
+
+    continueMove.post();
+    moveThread.join();
+    EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
+  }
+  DataCounter::reset();
+
+  {
+    auto asyncSource = std::make_shared<AsyncSource<DataCounter>>(
+        []() { return std::make_unique<DataCounter>(); });
+
+    auto result = asyncSource->move();
+    EXPECT_NE(result, nullptr);
+    EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
+
+    asyncSource->cancel();
+
+    EXPECT_EQ(1, asyncSource->prepareTiming().count);
+    EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
+  }
+  DataCounter::reset();
+
+  // Cancel called after close() - should be no-op.
+  {
+    auto asyncSource = std::make_shared<AsyncSource<DataCounter>>(
+        []() { return std::make_unique<DataCounter>(); });
+    asyncSource->prepare();
+    EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
+
+    asyncSource->close();
+    EXPECT_EQ(DataCounter::numDeletedDataCounters(), 1);
+
+    asyncSource->cancel();
+    EXPECT_EQ(DataCounter::numDeletedDataCounters(), 1);
+    EXPECT_EQ(1, asyncSource->prepareTiming().count);
+  }
+}
+
+TEST_F(AsyncSourceTest, multithreadedPrepareAndMove) {
   constexpr int32_t kNumThreads = 10;
   constexpr int32_t kNumGizmos = 2000;
   folly::Synchronized<std::unordered_set<int32_t>> results;
   std::vector<std::shared_ptr<AsyncSource<Gizmo>>> gizmos;
+  gizmos.reserve(kNumGizmos);
   for (auto i = 0; i < kNumGizmos; ++i) {
     gizmos.push_back(std::make_shared<AsyncSource<Gizmo>>([i]() {
       std::this_thread::sleep_for(std::chrono::milliseconds(1)); // NOLINT
@@ -64,16 +354,12 @@ TEST(AsyncSourceTest, threads) {
   std::vector<std::thread> threads;
   threads.reserve(kNumThreads);
   for (int32_t threadIndex = 0; threadIndex < kNumThreads; ++threadIndex) {
-    threads.push_back(std::thread([threadIndex, &gizmos, &results]() {
+    threads.emplace_back([threadIndex, &gizmos, &results]() {
       if (threadIndex < kNumThreads / 2) {
-        // The first half of the threads prepare Gizmos in the background.
         for (auto i = 0; i < kNumGizmos; ++i) {
           gizmos[i]->prepare();
         }
       } else {
-        // The rest of the threads first get random Gizmos and then do a pass
-        // over all the Gizmos to make sure all get collected. We assert that
-        // each Gizmo is obtained once.
         folly::Random::DefaultGenerator rng;
         for (auto i = 0; i < kNumGizmos / 3; ++i) {
           auto gizmo =
@@ -95,7 +381,7 @@ TEST(AsyncSourceTest, threads) {
           }
         }
       }
-    }));
+    });
   }
   for (auto& thread : threads) {
     thread.join();
@@ -107,11 +393,12 @@ TEST(AsyncSourceTest, threads) {
   });
 }
 
-TEST(AsyncSourceTest, errorsWithThreads) {
+TEST_F(AsyncSourceTest, multithreadedErrorHandling) {
   constexpr int32_t kNumGizmos = 50;
   constexpr int32_t kNumThreads = 10;
   std::vector<std::shared_ptr<AsyncSource<Gizmo>>> gizmos;
   std::atomic<int32_t> numErrors{0};
+  gizmos.reserve(kNumGizmos);
   for (auto i = 0; i < kNumGizmos; ++i) {
     gizmos.push_back(
         std::make_shared<AsyncSource<Gizmo>>([]() -> std::unique_ptr<Gizmo> {
@@ -123,16 +410,12 @@ TEST(AsyncSourceTest, errorsWithThreads) {
   std::vector<std::thread> threads;
   threads.reserve(kNumThreads);
   for (int32_t threadIndex = 0; threadIndex < kNumThreads; ++threadIndex) {
-    threads.push_back(std::thread([threadIndex, &gizmos, &numErrors]() {
+    threads.emplace_back([threadIndex, &gizmos, &numErrors]() {
       if (threadIndex < kNumThreads / 2) {
-        // The first half of the threads prepare Gizmos in the background.
         for (auto i = 0; i < kNumGizmos; ++i) {
           gizmos[i]->prepare();
         }
       } else {
-        // The rest of the threads get random gizmos. They are
-        // expected to produce an error or nullptr in the event
-        // another thread is already waiting for the same gizmo.
         folly::Random::DefaultGenerator rng;
         for (auto i = 0; i < kNumGizmos / 3; ++i) {
           try {
@@ -144,155 +427,253 @@ TEST(AsyncSourceTest, errorsWithThreads) {
           }
         }
       }
-    }));
+    });
   }
   for (auto& thread : threads) {
     thread.join();
   }
-  // There will always be errors since the first to wait for any given
-  // gizmo is sure to get an error.
   EXPECT_LT(0, numErrors);
   for (auto& source : gizmos) {
     source->close();
   }
 }
 
-class DataCounter {
- public:
-  DataCounter() {
-    objectNumber_ = ++numCreatedDataCounters_;
-  }
+DEBUG_ONLY_TEST_F(AsyncSourceTest, concurrentMoveSteal) {
+  // Test scenario: first move() waits for making
+  // it gets signaled through promises, but a second move() comes in
+  // between the wait completion and lock re-acquisition and steals the item.
+  // The first move() should get nothing.
+  folly::Baton<> makingStarted;
+  folly::Baton<> makingContinue;
+  folly::Baton<> firstMoveWaiting;
+  folly::Baton<> secondMoveComplete;
+
+  auto asyncSource =
+      std::make_shared<AsyncSource<Gizmo>>([&makingStarted, &makingContinue]() {
+        makingStarted.post();
+        makingContinue.wait();
+        return std::make_unique<Gizmo>(42);
+      });
 
-  ~DataCounter() {
-    ++numDeletedDataCounters_;
-  }
+  std::atomic<Gizmo*> firstMoveResult{nullptr};
+  std::atomic<Gizmo*> secondMoveResult{nullptr};
+  std::unique_ptr<Gizmo> firstMoveHolder;
+  std::unique_ptr<Gizmo> secondMoveHolder;
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::AsyncSource::makeWait",
+      std::function<void(AsyncSource<Gizmo>*)>([&](AsyncSource<Gizmo>* source) {
+        // Signal that first move is about to re-acquire lock.
+        firstMoveWaiting.post();
+        // Wait for second move to complete and steal the item.
+        secondMoveComplete.wait();
+      }));
+
+  // Thread 1: First move() - will wait for making and then get blocked by
+  // TestValue.
+  auto firstMoveThread = std::thread([&]() {
+    firstMoveHolder = asyncSource->move();
+    firstMoveResult = firstMoveHolder.get();
+  });
 
-  static uint64_t numCreatedDataCounters() {
-    return numCreatedDataCounters_;
-  }
+  // Thread 2: prepare() - starts making the item.
+  auto prepareThread = std::thread([&]() { asyncSource->prepare(); });
 
-  static uint64_t numDeletedDataCounters() {
-    return numDeletedDataCounters_;
-  }
+  // Wait for making to start.
+  ASSERT_TRUE(makingStarted.try_wait_for(1s));
 
-  static void reset() {
-    numCreatedDataCounters_ = 0;
-    numDeletedDataCounters_ = 0;
-  }
+  // Let making complete - this will signal the first move's promise.
+  makingContinue.post();
 
-  uint64_t objectNumber() const {
-    return objectNumber_;
-  }
+  // Wait for first move to be signaled and about to re-acquire lock.
+  ASSERT_TRUE(firstMoveWaiting.try_wait_for(1s));
 
- private:
-  static std::atomic<uint64_t> numCreatedDataCounters_;
-  static std::atomic<uint64_t> numDeletedDataCounters_;
+  // Thread 3: Second move() - steals the item while first move is blocked.
+  auto secondMoveThread = std::thread([&]() {
+    secondMoveHolder = asyncSource->move();
+    secondMoveResult = secondMoveHolder.get();
+    secondMoveComplete.post();
+  });
 
-  uint64_t objectNumber_{0};
-};
+  firstMoveThread.join();
+  secondMoveThread.join();
+  prepareThread.join();
 
-std::atomic<uint64_t> DataCounter::numCreatedDataCounters_ = 0;
+  // Second move should have stolen the item.
+  EXPECT_NE(secondMoveResult.load(), nullptr);
+  EXPECT_EQ(secondMoveResult.load()->id, 42);
 
-std::atomic<uint64_t> DataCounter::numDeletedDataCounters_ = 0;
+  // First move should get nothing because second move stole the item.
+  EXPECT_EQ(firstMoveResult.load(), nullptr);
+}
 
-TEST(AsyncSourceTest, close) {
-  // If 'prepare()' is not executed within the thread pool, invoking 'close()'
-  // will set 'make_' to nullptr. The deletion of 'dateCounter' is used as a
-  // verification for this behavior.
-  auto dateCounter = std::make_shared<DataCounter>();
-  AsyncSource<uint64_t> countAsyncSource([dateCounter]() {
-    return std::make_unique<uint64_t>(dateCounter->objectNumber());
+DEBUG_ONLY_TEST_F(AsyncSourceTest, concurrentMoveCloseRace) {
+  // Test scenario: Tests the race condition where move()
+  // preparation and close() sneaks in to grab the item first.
+  //
+  // Timeline:
+  //   1. prepare() starts making the item in a background thread
+  //   2. move() enters and waits for preparation to complete (blocked on
+  //   promise)
+  //   3. prepare() completes and signals the promise
+  //   4. move() wakes up but TestValue blocks it before re-acquiring the lock
+  //   5. close() runs and transitions state to kFinished, clearing the item
+  //   6. move() finally re-acquires lock but finds state is kFinished
+  //   7. move() returns nullptr
+  //
+  // Expected: move() gets nullptr because close() grabbed the item first.
+  folly::Baton<> makingStarted;
+  folly::Baton<> makingContinue;
+  folly::Baton<> moveWaiting;
+  folly::Baton<> closeComplete;
+
+  auto asyncSource =
+      std::make_shared<AsyncSource<Gizmo>>([&makingStarted, &makingContinue]() {
+        makingStarted.post();
+        makingContinue.wait();
+        return std::make_unique<Gizmo>(42);
+      });
+
+  std::atomic<Gizmo*> moveResult{nullptr};
+  std::unique_ptr<Gizmo> moveHolder;
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::AsyncSource::makeWait",
+      std::function<void(AsyncSource<Gizmo>*)>([&](AsyncSource<Gizmo>* source) {
+        // Signal that move is about to re-acquire lock.
+        moveWaiting.post();
+        // Wait for close to complete.
+        closeComplete.wait();
+      }));
+
+  // Thread 1: move() - will wait for making and then get blocked by TestValue.
+  auto moveThread = std::thread([&]() {
+    moveHolder = asyncSource->move();
+    moveResult = moveHolder.get();
   });
-  dateCounter.reset();
-  EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
-  EXPECT_EQ(DataCounter::numDeletedDataCounters(), 0);
 
-  countAsyncSource.close();
-  EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
-  EXPECT_EQ(DataCounter::numDeletedDataCounters(), 1);
-  DataCounter::reset();
+  // Thread 2: prepare() - starts making the item.
+  auto prepareThread = std::thread([&]() { asyncSource->prepare(); });
 
-  // If 'prepare()' is executed within the thread pool but 'move()' is not
-  // invoked, invoking 'close()' will set 'item_' to nullptr. The deletion of
-  // 'dateCounter' is used as a verification for this behavior.
-  auto asyncSource = std::make_shared<AsyncSource<DataCounter>>(
-      []() { return std::make_unique<DataCounter>(); });
-  asyncSource->prepare();
-  EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
-  EXPECT_EQ(DataCounter::numDeletedDataCounters(), 0);
+  // Wait for making to start.
+  ASSERT_TRUE(makingStarted.try_wait_for(1s));
 
+  // Let making complete - this will signal move's promise.
+  makingContinue.post();
+
+  // Wait for move to be signaled and about to re-acquire lock.
+  ASSERT_TRUE(moveWaiting.try_wait_for(1s));
+
+  // close() comes in and closes the item while move is blocked.
   asyncSource->close();
-  EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
-  EXPECT_EQ(DataCounter::numDeletedDataCounters(), 1);
-  DataCounter::reset();
+  closeComplete.post();
 
-  // If 'prepare()' is currently being executed within the thread pool,
-  // 'close()' should wait for the completion of 'prepare()' and set 'item_' to
-  // nullptr.
-  folly::Baton<> baton;
-  auto sleepAsyncSource =
-      std::make_shared<AsyncSource<DataCounter>>([&baton]() {
-        baton.post();
-        return std::make_unique<DataCounter>();
-      });
-  auto thread1 =
-      std::thread([&sleepAsyncSource] { sleepAsyncSource->prepare(); });
-  EXPECT_TRUE(baton.try_wait_for(1s));
-  sleepAsyncSource->close();
-  EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
-  EXPECT_EQ(DataCounter::numDeletedDataCounters(), 1);
-  thread1.join();
-}
+  moveThread.join();
+  prepareThread.join();
 
-void verifyContexts(
-    const std::string& expectedPoolName,
-    const std::string& expectedTaskId) {
-  EXPECT_EQ(process::GetThreadDebugInfo()->taskId_, expectedTaskId);
+  // move() should get nothing because close() grabbed the item first.
+  EXPECT_EQ(moveResult.load(), nullptr);
 }
 
-TEST(AsyncSourceTest, emptyContexts) {
-  EXPECT_EQ(process::GetThreadDebugInfo(), nullptr);
+DEBUG_ONLY_TEST_F(AsyncSourceTest, concurrentCloseMoveRace) {
+  // Test scenario: Tests the race condition where close()
+  // preparation and move() sneaks in to grab the item first.
+  //
+  // Timeline:
+  //   1. prepare() starts making the item in a background thread
+  //   2. close() enters and waits for preparation to complete (blocked on
+  //   promise)
+  //   3. prepare() completes and signals the promise
+  //   4. close() wakes up but TestValue blocks it before re-acquiring the lock
+  //   5. move() runs and transitions state to kFinished, taking the item
+  //   6. close() finally re-acquires lock and finds state is kFinished
+  //   7. close() completes successfully (nothing to close)
+  //
+  // Expected: move() gets the item, close() finds nothing to close.
+  folly::Baton<> makingStarted;
+  folly::Baton<> makingContinue;
+  folly::Baton<> closeWaiting;
+  folly::Baton<> moveComplete;
+
+  auto asyncSource =
+      std::make_shared<AsyncSource<Gizmo>>([&makingStarted, &makingContinue]() {
+        makingStarted.post();
+        makingContinue.wait();
+        return std::make_unique<Gizmo>(42);
+      });
 
-  AsyncSource<bool> src([]() {
-    // The Contexts at the time this was created were null so we should inherit
-    // them from the caller.
-    verifyContexts("test", "task_id");
+  std::atomic<Gizmo*> moveResult{nullptr};
+  std::unique_ptr<Gizmo> moveHolder;
 
-    return std::make_unique<bool>(true);
-  });
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::AsyncSource::makeWait",
+      std::function<void(AsyncSource<Gizmo>*)>([&](AsyncSource<Gizmo>* source) {
+        // Signal that close is about to re-acquire lock.
+        closeWaiting.post();
+        // Wait for move to complete and take the item.
+        moveComplete.wait();
+      }));
 
-  process::ThreadDebugInfo debugInfo{"query_id", "task_id", nullptr};
-  process::ScopedThreadDebugInfo scopedDebugInfo(debugInfo);
+  // Thread 1: prepare() - starts making the item.
+  auto prepareThread = std::thread([&]() { asyncSource->prepare(); });
 
-  verifyContexts("test", "task_id");
+  // Wait for making to start.
+  ASSERT_TRUE(makingStarted.try_wait_for(1s));
 
-  ASSERT_TRUE(*src.move());
+  // Thread 2: close() - will wait for making and then get blocked by TestValue.
+  auto closeThread = std::thread([&]() { asyncSource->close(); });
 
-  verifyContexts("test", "task_id");
-}
+  // Wait for close to be signaled and about to re-acquire lock.
+  ASSERT_TRUE(closeWaiting.try_wait_for(1s));
 
-TEST(AsyncSourceTest, setContexts) {
-  process::ThreadDebugInfo debugInfo1{"query_id1", "task_id1", nullptr};
+  // Let making complete - this will signal close's promise.
+  makingContinue.post();
 
-  std::unique_ptr<AsyncSource<bool>> src;
-  process::ScopedThreadDebugInfo scopedDebugInfo1(debugInfo1);
+  std::this_thread::sleep_for(std::chrono::seconds(1)); // NOLINT
 
-  verifyContexts("test1", "task_id1");
+  // move() comes in and takes the item while close is blocked.
+  moveHolder = asyncSource->move();
+  moveResult = moveHolder.get();
+  moveComplete.post();
 
-  src = std::make_unique<AsyncSource<bool>>(([]() {
-    // The Contexts at the time this was created were set so we should have
-    // the same contexts when this is executed.
-    verifyContexts("test1", "task_id1");
+  closeThread.join();
+  prepareThread.join();
 
-    return std::make_unique<bool>(true);
-  }));
+  // move() should have taken the item.
+  EXPECT_NE(moveResult.load(), nullptr);
+  EXPECT_EQ(moveResult.load()->id, 42);
+}
 
-  process::ThreadDebugInfo debugInfo2{"query_id2", "task_id2", nullptr};
-  process::ScopedThreadDebugInfo scopedDebugInfo2(debugInfo2);
+TEST_F(AsyncSourceTest, prepareTiming) {
+  auto asyncSource = std::make_shared<AsyncSource<Gizmo>>([]() {
+    std::this_thread::sleep_for(1s);
+    return std::make_unique<Gizmo>(42);
+  });
 
-  verifyContexts("test2", "task_id2");
+  asyncSource->prepare();
 
-  ASSERT_TRUE(*src->move());
+  const auto& timing = asyncSource->prepareTiming();
+  EXPECT_EQ(timing.count, 1);
+  EXPECT_GE(timing.wallNanos, 1'000'000'000);
+  asyncSource->close();
+}
 
-  verifyContexts("test2", "task_id2");
+TEST_F(AsyncSourceTest, itemMakerReturnsNull) {
+  // Test when itemMaker returns nullptr via prepare().
+  {
+    auto asyncSource = std::make_shared<AsyncSource<Gizmo>>(
+        []() -> std::unique_ptr<Gizmo> { return nullptr; });
+    asyncSource->prepare();
+    EXPECT_FALSE(asyncSource->hasValue());
+    auto result = asyncSource->move();
+    EXPECT_EQ(result, nullptr);
+  }
+
+  // Test when itemMaker returns nullptr via move() (inline making).
+  {
+    auto asyncSource = std::make_shared<AsyncSource<Gizmo>>(
+        []() -> std::unique_ptr<Gizmo> { return nullptr; });
+    auto result = asyncSource->move();
+    EXPECT_EQ(result, nullptr);
+  }
 }
diff --git a/velox/common/base/tests/BitUtilTest.cpp b/velox/common/base/tests/BitUtilTest.cpp
index 4450a5145ca..10a9ce911ad 100644
--- a/velox/common/base/tests/BitUtilTest.cpp
+++ b/velox/common/base/tests/BitUtilTest.cpp
@@ -18,7 +18,9 @@
 #include "velox/common/base/Crc.h"
 #include "velox/type/HugeInt.h"
 
-#include <unordered_set>
+#include <cstring>
+#include <limits>
+#include <span>
 
 #include <boost/crc.hpp>
 #include <fmt/format.h>
@@ -946,6 +948,291 @@ TEST_F(BitUtilTest, divRoundUp) {
         bits::divRoundUp(testData.value, testData.factor), testData.expected);
   }
 }
+TEST_F(BitUtilTest, bitsRequired) {
+  EXPECT_EQ(bitsRequired(0), 1);
+  EXPECT_EQ(bitsRequired(1), 1);
+  EXPECT_EQ(bitsRequired(2), 2);
+  EXPECT_EQ(bitsRequired(3), 2);
+  EXPECT_EQ(bitsRequired(4), 3);
+  EXPECT_EQ(bitsRequired(7), 3);
+  EXPECT_EQ(bitsRequired(8), 4);
+  EXPECT_EQ(bitsRequired(15), 4);
+  EXPECT_EQ(bitsRequired(16), 5);
+  EXPECT_EQ(bitsRequired(255), 8);
+  EXPECT_EQ(bitsRequired(256), 9);
+  EXPECT_EQ(bitsRequired(0xFFFFFFFF), 32);
+  EXPECT_EQ(bitsRequired(0x100000000ULL), 33);
+  EXPECT_EQ(bitsRequired(std::numeric_limits<uint64_t>::max()), 64);
+  // Powers of two.
+  for (int i = 0; i < 63; ++i) {
+    EXPECT_EQ(bitsRequired(1ULL << i), i + 1);
+  }
+}
+
+TEST_F(BitUtilTest, maybeSetBit) {
+  uint8_t bytes[16];
+  memset(bytes, 0, sizeof(bytes));
+
+  // Setting with value=true should set the bit.
+  maybeSetBit(bytes, 0, true);
+  EXPECT_TRUE(isBitSet(bytes, 0));
+
+  maybeSetBit(bytes, 7, true);
+  EXPECT_TRUE(isBitSet(bytes, 7));
+
+  maybeSetBit(bytes, 64, true);
+  EXPECT_TRUE(isBitSet(bytes, 64));
+
+  // Setting with value=false should be a no-op (bit stays as-is).
+  maybeSetBit(bytes, 5, false);
+  EXPECT_FALSE(isBitSet(bytes, 5));
+
+  // Already-set bit stays set even with value=false (OR semantics).
+  maybeSetBit(bytes, 0, false);
+  EXPECT_TRUE(isBitSet(bytes, 0));
+
+  // Verify untouched bits are still clear.
+  EXPECT_FALSE(isBitSet(bytes, 1));
+  EXPECT_FALSE(isBitSet(bytes, 6));
+
+  // Test with uint64_t pointer type.
+  uint64_t words[2] = {0, 0};
+  maybeSetBit(words, 3, true);
+  EXPECT_TRUE(isBitSet(words, 3));
+  maybeSetBit(words, 3, false);
+  EXPECT_TRUE(isBitSet(words, 3)); // OR semantics, stays set.
+  maybeSetBit(words, 100, true);
+  EXPECT_TRUE(isBitSet(words, 100));
+}
+
+TEST_F(BitUtilTest, packBitmap) {
+  // Pack 128 bools into a bitmap.
+  bool boolArray[128];
+  for (int i = 0; i < 128; ++i) {
+    boolArray[i] = (i % 3 == 0);
+  }
+
+  char bitmap[16];
+  memset(bitmap, 0, sizeof(bitmap));
+  packBitmap(std::span<const bool>(boolArray, 128), bitmap);
+
+  for (int i = 0; i < 128; ++i) {
+    EXPECT_EQ(
+        isBitSet(reinterpret_cast<const uint8_t*>(bitmap), i), (i % 3 == 0))
+        << "at bit " << i;
+  }
+
+  // Test empty span.
+  char emptyBitmap[8];
+  memset(emptyBitmap, 0, sizeof(emptyBitmap));
+  packBitmap(std::span<const bool>(), emptyBitmap);
+  for (int i = 0; i < 64; ++i) {
+    EXPECT_FALSE(isBitSet(reinterpret_cast<const uint8_t*>(emptyBitmap), i));
+  }
+
+  // Test non-64-aligned count (e.g., 100 bools).
+  bool bools100[100];
+  for (int i = 0; i < 100; ++i) {
+    bools100[i] = (i % 7 == 0);
+  }
+  char bitmap100[16];
+  memset(bitmap100, 0, sizeof(bitmap100));
+  packBitmap(std::span<const bool>(bools100, 100), bitmap100);
+  for (int i = 0; i < 100; ++i) {
+    EXPECT_EQ(
+        isBitSet(reinterpret_cast<const uint8_t*>(bitmap100), i), (i % 7 == 0))
+        << "at bit " << i;
+  }
+
+  // Test OR semantics: pre-existing bits are preserved.
+  char bitmapOr[8];
+  memset(bitmapOr, 0, sizeof(bitmapOr));
+  setBit(reinterpret_cast<uint8_t*>(bitmapOr), 1);
+  bool boolsOr[8] = {true, false, false, true, false, false, false, false};
+  packBitmap(std::span<const bool>(boolsOr, 8), bitmapOr);
+  EXPECT_TRUE(isBitSet(reinterpret_cast<const uint8_t*>(bitmapOr), 0));
+  EXPECT_TRUE(
+      isBitSet(reinterpret_cast<const uint8_t*>(bitmapOr), 1)); // preserved
+  EXPECT_TRUE(isBitSet(reinterpret_cast<const uint8_t*>(bitmapOr), 3));
+}
+
+TEST_F(BitUtilTest, findSetBit) {
+  // Build a bitmap with known set bits.
+  uint64_t words[4] = {0, 0, 0, 0};
+  auto bitmap = reinterpret_cast<char*>(words);
+
+  // Set bits at positions 5, 10, 15, 64, 100, 200.
+  setBit(words, 5);
+  setBit(words, 10);
+  setBit(words, 15);
+  setBit(words, 64);
+  setBit(words, 100);
+  setBit(words, 200);
+
+  // Find the 1st set bit starting from 0.
+  EXPECT_EQ(findSetBit(bitmap, 0, 256, 1), 5u);
+  // Find the 2nd set bit.
+  EXPECT_EQ(findSetBit(bitmap, 0, 256, 2), 10u);
+  // Find the 3rd set bit.
+  EXPECT_EQ(findSetBit(bitmap, 0, 256, 3), 15u);
+  // Find the 4th set bit.
+  EXPECT_EQ(findSetBit(bitmap, 0, 256, 4), 64u);
+  // Find the 5th set bit.
+  EXPECT_EQ(findSetBit(bitmap, 0, 256, 5), 100u);
+  // Find the 6th set bit.
+  EXPECT_EQ(findSetBit(bitmap, 0, 256, 6), 200u);
+  // 7th set bit doesn't exist.
+  EXPECT_EQ(findSetBit(bitmap, 0, 256, 7), 256u);
+
+  // Search starting from a non-zero begin.
+  EXPECT_EQ(findSetBit(bitmap, 6, 256, 1), 10u);
+  EXPECT_EQ(findSetBit(bitmap, 11, 256, 1), 15u);
+  EXPECT_EQ(findSetBit(bitmap, 16, 256, 1), 64u);
+
+  // Search with restricted end.
+  EXPECT_EQ(findSetBit(bitmap, 0, 14, 3), 14u); // Only 2 set bits in [0,14)
+
+  // Edge cases.
+  EXPECT_EQ(findSetBit(bitmap, 0, 256, 0), 0u); // n=0 returns begin
+  EXPECT_EQ(findSetBit(bitmap, 10, 10, 1), 10u); // begin==end returns begin
+  EXPECT_EQ(findSetBit(bitmap, 20, 10, 1), 20u); // begin>end returns begin
+
+  // All bits set in a word.
+  uint64_t allSet[2] = {~0ULL, ~0ULL};
+  auto allSetBitmap = reinterpret_cast<char*>(allSet);
+  EXPECT_EQ(findSetBit(allSetBitmap, 0, 128, 1), 0u);
+  EXPECT_EQ(findSetBit(allSetBitmap, 0, 128, 64), 63u);
+  EXPECT_EQ(findSetBit(allSetBitmap, 0, 128, 65), 64u);
+  EXPECT_EQ(findSetBit(allSetBitmap, 0, 128, 128), 127u);
+  EXPECT_EQ(findSetBit(allSetBitmap, 0, 128, 129), 128u);
+}
+
+TEST_F(BitUtilTest, printBitsTest) {
+  // uint8_t: 0 should be all zeros.
+  EXPECT_EQ(printBits(static_cast<uint8_t>(0)), "0000 0000");
+  // uint8_t: 0xFF should be all ones.
+  EXPECT_EQ(printBits(static_cast<uint8_t>(0xFF)), "1111 1111");
+  // uint8_t: 0xA5 = 1010 0101.
+  EXPECT_EQ(printBits(static_cast<uint8_t>(0xA5)), "1010 0101");
+  // uint16_t.
+  EXPECT_EQ(printBits(static_cast<uint16_t>(0x00FF)), "0000 0000 1111 1111");
+  // uint32_t: 1.
+  EXPECT_EQ(
+      printBits(static_cast<uint32_t>(1)),
+      "0000 0000 0000 0000 0000 0000 0000 0001");
+}
+
+TEST_F(BitUtilTest, bitmap) {
+  uint8_t data[16];
+  memset(data, 0, sizeof(data));
+  setBit(data, 0);
+  setBit(data, 7);
+  setBit(data, 8);
+  setBit(data, 63);
+  setBit(data, 64);
+  setBit(data, 127);
+
+  Bitmap bm(data, 128);
+  EXPECT_EQ(bm.size(), 128u);
+  EXPECT_EQ(bm.bits(), data);
+  EXPECT_TRUE(bm.test(0));
+  EXPECT_FALSE(bm.test(1));
+  EXPECT_TRUE(bm.test(7));
+  EXPECT_TRUE(bm.test(8));
+  EXPECT_FALSE(bm.test(9));
+  EXPECT_TRUE(bm.test(63));
+  EXPECT_TRUE(bm.test(64));
+  EXPECT_FALSE(bm.test(65));
+  EXPECT_TRUE(bm.test(127));
+}
+
+TEST_F(BitUtilTest, bitmapBuilder) {
+  uint8_t data[16];
+  memset(data, 0, sizeof(data));
+
+  BitmapBuilder builder(data, 128);
+
+  // Test single-bit set.
+  builder.set(5);
+  EXPECT_TRUE(builder.test(5));
+  EXPECT_FALSE(builder.test(4));
+
+  // Test maybeSet.
+  builder.maybeSet(10, true);
+  EXPECT_TRUE(builder.test(10));
+  builder.maybeSet(11, false);
+  EXPECT_FALSE(builder.test(11));
+
+  // Test range set.
+  builder.set(20, 30);
+  for (uint32_t i = 20; i < 30; ++i) {
+    EXPECT_TRUE(builder.test(i)) << "at " << i;
+  }
+  EXPECT_FALSE(builder.test(19));
+  EXPECT_FALSE(builder.test(30));
+
+  // Test range clear.
+  builder.clear(22, 28);
+  EXPECT_TRUE(builder.test(20));
+  EXPECT_TRUE(builder.test(21));
+  for (uint32_t i = 22; i < 28; ++i) {
+    EXPECT_FALSE(builder.test(i)) << "at " << i;
+  }
+  EXPECT_TRUE(builder.test(28));
+  EXPECT_TRUE(builder.test(29));
+}
+
+TEST_F(BitUtilTest, bitmapBuilderCopy) {
+  uint8_t src[16];
+  uint8_t dst[16];
+  memset(src, 0, sizeof(src));
+  memset(dst, 0, sizeof(dst));
+
+  // Set some bits in src.
+  setBit(src, 0);
+  setBit(src, 3);
+  setBit(src, 7);
+  setBit(src, 8);
+  setBit(src, 15);
+  setBit(src, 50);
+  setBit(src, 63);
+  setBit(src, 64);
+  setBit(src, 100);
+
+  // Set a bit in dst that is before the copy range; it should be preserved.
+  setBit(dst, 1);
+
+  Bitmap srcBm(src, 128);
+  BitmapBuilder dstBuilder(dst, 128);
+
+  // Copy range [3, 101).
+  dstBuilder.copy(srcBm, 3, 101);
+
+  // Bit 1 in dst should still be set (before copy range).
+  EXPECT_TRUE(isBitSet(dst, 1));
+  // Bits from src in [3, 101) should now be in dst.
+  EXPECT_TRUE(isBitSet(dst, 3));
+  EXPECT_TRUE(isBitSet(dst, 7));
+  EXPECT_TRUE(isBitSet(dst, 8));
+  EXPECT_TRUE(isBitSet(dst, 15));
+  EXPECT_TRUE(isBitSet(dst, 50));
+  EXPECT_TRUE(isBitSet(dst, 63));
+  EXPECT_TRUE(isBitSet(dst, 64));
+  EXPECT_TRUE(isBitSet(dst, 100));
+
+  // Bits that are not set in src within the range should be clear in dst.
+  EXPECT_FALSE(isBitSet(dst, 4));
+  EXPECT_FALSE(isBitSet(dst, 9));
+  EXPECT_FALSE(isBitSet(dst, 65));
+
+  // Copy byte-aligned range.
+  memset(dst, 0xFF, sizeof(dst));
+  dstBuilder.copy(srcBm, 0, 128);
+  for (int i = 0; i < 128; ++i) {
+    EXPECT_EQ(isBitSet(dst, i), isBitSet(src, i)) << "at bit " << i;
+  }
+}
+
 } // namespace bits
 } // namespace velox
 } // namespace facebook
diff --git a/velox/common/base/tests/BloomFilterTest.cpp b/velox/common/base/tests/BloomFilterTest.cpp
index 85dcec0cb47..28cf5585c98 100644
--- a/velox/common/base/tests/BloomFilterTest.cpp
+++ b/velox/common/base/tests/BloomFilterTest.cpp
@@ -75,8 +75,9 @@ TEST_F(BloomFilterTest, staticMayContain) {
   bloom.serialize(serializedBloom.data());
   int32_t numFalsePositives = 0;
   for (auto i = 0; i < kSize; ++i) {
-    EXPECT_TRUE(BloomFilter<>::mayContain(
-        serializedBloom.data(), folly::hasher<int32_t>()(i)));
+    EXPECT_TRUE(
+        BloomFilter<>::mayContain(
+            serializedBloom.data(), folly::hasher<int32_t>()(i)));
 
     const uint64_t smallValueHash = folly::hasher<int32_t>()(i + kSize);
     const bool isFalsePositiveForSmallValue =
@@ -121,3 +122,41 @@ TEST_F(BloomFilterTest, merge) {
 
   EXPECT_EQ(bloom.serializedSize(), merge.serializedSize());
 }
+
+TEST_F(BloomFilterTest, corruptMergeSize) {
+  // Serialization format: int8_t version (1) + int32_t size.
+  // Craft data with negative size to verify validation.
+  std::string data(5, '\0');
+  data[0] = 1; // kBloomFilterV1
+  // Write size = -1 as little-endian int32_t at offset 1.
+  int32_t badSize = -1;
+  memcpy(&data[1], &badSize, sizeof(badSize));
+
+  BloomFilter bloom;
+  EXPECT_THROW(bloom.merge(data.data()), VeloxRuntimeError);
+}
+
+TEST_F(BloomFilterTest, optimalNumOfBitsWithFpp) {
+  EXPECT_EQ(BloomFilter<>::optimalNumOfBits(1000, 0.03), 7298);
+  EXPECT_EQ(BloomFilter<>::optimalNumOfBits(1000000, 0.01), 9585058);
+  EXPECT_EQ(BloomFilter<>::optimalNumOfBits(1, 0.5), 1);
+  EXPECT_EQ(BloomFilter<>::optimalNumOfBits(1000, 0.001), 14377);
+}
+
+TEST_F(BloomFilterTest, optimalNumOfBitsWithMaxItems) {
+  constexpr int64_t kMaxNumItems = 4'000'000L;
+
+  EXPECT_EQ(
+      BloomFilter<>::optimalNumOfBits(kMaxNumItems, kMaxNumItems), 29'193'763);
+
+  EXPECT_EQ(
+      BloomFilter<>::optimalNumOfBits(1'000'000L, kMaxNumItems), 10'183'830);
+
+  EXPECT_EQ(BloomFilter<>::optimalNumOfBits(100L, kMaxNumItems), 2935);
+
+  EXPECT_EQ(
+      BloomFilter<>::optimalNumOfBits(5'000'000L, kMaxNumItems), 36'492'204);
+
+  EXPECT_EQ(
+      BloomFilter<>::optimalNumOfBits(10'000'000L, kMaxNumItems), 72'984'408);
+}
diff --git a/velox/common/base/tests/CMakeLists.txt b/velox/common/base/tests/CMakeLists.txt
index aae21a5355c..4eb30c7c57a 100644
--- a/velox/common/base/tests/CMakeLists.txt
+++ b/velox/common/base/tests/CMakeLists.txt
@@ -31,11 +31,12 @@ add_executable(
   SimdUtilTest.cpp
   SkewedPartitionBalancerTest.cpp
   SpillConfigTest.cpp
-  SpillStatsTest.cpp
+  SplitBlockBloomFilterTest.cpp
   StatsReporterTest.cpp
   StatusTest.cpp
   SuccinctPrinterTest.cpp
 )
+velox_add_test_headers(velox_base_test GTestUtils.h)
 
 add_test(velox_base_test velox_base_test)
 
@@ -48,7 +49,7 @@ target_link_libraries(
     velox_time
     velox_status
     velox_exception
-    velox_temp_path
+    velox_test_util
     Boost::filesystem
     Boost::headers
     Folly::folly
@@ -80,3 +81,9 @@ target_link_libraries(
   velox_memcpy_meter
   PRIVATE velox_common_base velox_exception velox_time Folly::folly gflags::gflags
 )
+
+velox_add_library(velox_gtest_utils INTERFACE HEADERS GTestUtils.h)
+
+velox_add_library(velox_stats_reporter_utils INTERFACE HEADERS StatsReporterUtils.h)
+
+velox_add_library(velox_float_constants INTERFACE HEADERS FloatConstants.h)
diff --git a/velox/common/base/tests/ConcurrentCounterTest.cpp b/velox/common/base/tests/ConcurrentCounterTest.cpp
index c96fc1ac957..7945cb7e6c8 100644
--- a/velox/common/base/tests/ConcurrentCounterTest.cpp
+++ b/velox/common/base/tests/ConcurrentCounterTest.cpp
@@ -18,6 +18,7 @@
 
 #include <fmt/format.h>
 #include <folly/Random.h>
+#include <folly/system/HardwareConcurrency.h>
 #include <gtest/gtest.h>
 #include "velox/common/base/tests/GTestUtils.h"
 
@@ -48,7 +49,7 @@ class ConcurrentCounterTest : public testing::TestWithParam<bool> {
 
   void setupCounter() {
     counter_ = std::make_unique<ConcurrentCounter<int64_t>>(
-        std::thread::hardware_concurrency());
+        folly::available_concurrency());
   }
 
   const bool useUpdateFn_{GetParam()};
@@ -72,8 +73,8 @@ TEST_P(ConcurrentCounterTest, multithread) {
   const int32_t numUpdatesPerThread = 5'000;
   std::vector<int> numThreads;
   numThreads.push_back(1);
-  numThreads.push_back(std::thread::hardware_concurrency());
-  numThreads.push_back(std::thread::hardware_concurrency() * 2);
+  numThreads.push_back(folly::available_concurrency());
+  numThreads.push_back(folly::available_concurrency() * 2);
   for (int numThreads : numThreads) {
     SCOPED_TRACE(fmt::format("numThreads: {}", numThreads));
     counter_->testingClear();
diff --git a/velox/common/base/tests/ExceptionTest.cpp b/velox/common/base/tests/ExceptionTest.cpp
index d057eb2dae3..c58ca70539b 100644
--- a/velox/common/base/tests/ExceptionTest.cpp
+++ b/velox/common/base/tests/ExceptionTest.cpp
@@ -16,6 +16,7 @@
 
 #include <fmt/format.h>
 #include <folly/Random.h>
+#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 #include "velox/common/base/Exceptions.h"
@@ -65,7 +66,7 @@ void verifyVeloxException(
     std::function<void()> f,
     const std::string& messagePrefix) {
   verifyException<VeloxException>(f, [&messagePrefix](const auto& e) {
-    EXPECT_TRUE(folly::StringPiece{e.what()}.startsWith(messagePrefix))
+    EXPECT_TRUE(std::string_view{e.what()}.starts_with(messagePrefix))
         << "\nException message prefix mismatch.\n\nExpected prefix: "
         << messagePrefix << "\n\nActual message: " << e.what();
   });
@@ -106,11 +107,12 @@ void testExceptionTraceCollectionControl(bool userException, bool enabled) {
           false);
     }
   } catch (VeloxException& e) {
-    SCOPED_TRACE(fmt::format(
-        "enabled: {}, user flag: {}, sys flag: {}",
-        enabled,
-        FLAGS_velox_exception_user_stacktrace_enabled,
-        FLAGS_velox_exception_system_stacktrace_enabled));
+    SCOPED_TRACE(
+        fmt::format(
+            "enabled: {}, user flag: {}, sys flag: {}",
+            enabled,
+            FLAGS_velox_exception_user_stacktrace_enabled,
+            FLAGS_velox_exception_system_stacktrace_enabled));
     ASSERT_EQ(userException, e.exceptionType() == VeloxException::Type::kUser);
     ASSERT_EQ(enabled, e.stackTrace() != nullptr);
   }
@@ -170,12 +172,13 @@ void testExceptionTraceCollectionRateControl(
             false);
       }
     } catch (VeloxException& e) {
-      SCOPED_TRACE(fmt::format(
-          "userException: {}, hasRateLimit: {}, user limit: {}ms, sys limit: {}ms",
-          userException,
-          hasRateLimit,
-          FLAGS_velox_exception_user_stacktrace_rate_limit_ms,
-          FLAGS_velox_exception_system_stacktrace_rate_limit_ms));
+      SCOPED_TRACE(
+          fmt::format(
+              "userException: {}, hasRateLimit: {}, user limit: {}ms, sys limit: {}ms",
+              userException,
+              hasRateLimit,
+              FLAGS_velox_exception_user_stacktrace_rate_limit_ms,
+              FLAGS_velox_exception_system_stacktrace_rate_limit_ms));
       ASSERT_EQ(
           userException, e.exceptionType() == VeloxException::Type::kUser);
       ASSERT_EQ(!hasRateLimit || ((iter % 2) == 0), e.stackTrace() != nullptr);
@@ -1009,12 +1012,123 @@ TEST(ExceptionTest, exceptionMacroInlining) {
   } catch (const VeloxUserError& ve) {
     ASSERT_EQ(ve.message(), errorStr);
   }
+}
+
+TEST(ExceptionTest, messageTemplate) {
+  using testing::Property;
+  using testing::StrEq;
+  using testing::Throws;
+
+  auto noMsg = [] { VELOX_FAIL(); };
+  EXPECT_THAT(
+      noMsg,
+      Throws<VeloxException>(
+          Property(&VeloxException::messageTemplate, StrEq(""))));
+
+  auto plainMsg = [] { VELOX_FAIL("Something went wrong"); };
+  EXPECT_THAT(
+      plainMsg,
+      Throws<VeloxException>(Property(
+          &VeloxException::messageTemplate, StrEq("Something went wrong"))));
+
+  // message() is interpolated, messageTemplate() is not.
+  auto fmtMsg = [] { VELOX_FAIL("Error: {} vs {}", 42, 99); };
+  EXPECT_THAT(
+      fmtMsg,
+      Throws<VeloxException>(Property(
+          &VeloxException::messageTemplate, StrEq("Error: {} vs {}"))));
+  EXPECT_THAT(
+      fmtMsg,
+      Throws<VeloxException>(
+          Property(&VeloxException::message, StrEq("Error: 42 vs 99"))));
+
+  auto userFail = [] { VELOX_USER_FAIL("Not supported: {}", "rank"); };
+  EXPECT_THAT(
+      userFail,
+      Throws<VeloxException>(Property(
+          &VeloxException::messageTemplate, StrEq("Not supported: {}"))));
+
+  auto checkFail = [] { VELOX_CHECK(false, "Bad state: {}", "disconnected"); };
+  EXPECT_THAT(
+      checkFail,
+      Throws<VeloxException>(
+          Property(&VeloxException::messageTemplate, StrEq("Bad state: {}"))));
+
+  auto checkEq = [] { VELOX_CHECK_EQ(1, 2); };
+  EXPECT_THAT(
+      checkEq,
+      Throws<VeloxException>(
+          Property(&VeloxException::messageTemplate, StrEq("({} vs. {})"))));
+
+  auto checkLt = [] { VELOX_CHECK_LT(10, 5, "Expected smaller"); };
+  EXPECT_THAT(
+      checkLt,
+      Throws<VeloxException>(Property(
+          &VeloxException::messageTemplate,
+          StrEq("({} vs. {}) Expected smaller"))));
+
+  auto unsupported = [] { VELOX_UNSUPPORTED("{} not supported", "merge"); };
+  EXPECT_THAT(
+      unsupported,
+      Throws<VeloxException>(Property(
+          &VeloxException::messageTemplate, StrEq("{} not supported"))));
+
+  auto nyi = [] { VELOX_NYI("{} not implemented", "windowing"); };
+  EXPECT_THAT(
+      nyi,
+      Throws<VeloxException>(Property(
+          &VeloxException::messageTemplate, StrEq("{} not implemented"))));
+
+  // Wrapped exception has no explicit template, so messageTemplate() returns
+  // the message itself.
+  {
+    auto exceptionPtr =
+        std::make_exception_ptr(std::invalid_argument("wrapped"));
+    VeloxUserError ve(exceptionPtr, "wrapped", false);
+    EXPECT_EQ(ve.messageTemplate(), "wrapped");
+  }
 
-  // Inlined with the method that passes the errorStr and the next argument via
-  // fmt::vformat. Should throw format_error.
+  // messageTemplate not in what().
   try {
-    VELOX_USER_FAIL(errorStr, "definitely");
-  } catch (const std::exception& e) {
-    ASSERT_TRUE(folly::StringPiece{e.what()}.startsWith("argument not found"));
+    VELOX_FAIL("Count: {}", 42);
+    FAIL() << "Expected an exception";
+  } catch (const VeloxException& e) {
+    EXPECT_EQ(e.messageTemplate(), "Count: {}");
+    EXPECT_EQ(
+        std::string(e.what()).find("Message Template:"), std::string::npos);
+  }
+
+  // No message arg.
+  auto checkNotNull = [] {
+    int* ptr = nullptr;
+    VELOX_CHECK_NOT_NULL(ptr);
+  };
+  EXPECT_THAT(
+      checkNotNull,
+      Throws<VeloxException>(
+          Property(&VeloxException::messageTemplate, StrEq(""))));
+
+  // VELOX_CHECK_EQ with user-provided format args.
+  auto checkEqFmt = [] { VELOX_CHECK_EQ(1, 2, "Expected {} == {}", 1, 2); };
+  EXPECT_THAT(
+      checkEqFmt,
+      Throws<VeloxException>(Property(
+          &VeloxException::messageTemplate,
+          StrEq("({} vs. {}) Expected {} == {}"))));
+
+  // Exception copy preserves messageTemplate.
+  try {
+    VELOX_FAIL("Copy test: {}", 42);
+    FAIL() << "Expected an exception";
+  } catch (const VeloxException& e) {
+    const VeloxException& copy = e;
+    EXPECT_EQ(copy.messageTemplate(), "Copy test: {}");
+
+    auto rethrown = std::current_exception();
+    try {
+      std::rethrow_exception(rethrown);
+    } catch (const VeloxException& e2) {
+      EXPECT_EQ(e2.messageTemplate(), "Copy test: {}");
+    }
   }
 }
diff --git a/velox/common/base/tests/FsTest.cpp b/velox/common/base/tests/FsTest.cpp
index 10e4dafee67..e50f1639b4d 100644
--- a/velox/common/base/tests/FsTest.cpp
+++ b/velox/common/base/tests/FsTest.cpp
@@ -17,14 +17,16 @@
 #include "velox/common/base/Fs.h"
 #include <gtest/gtest.h>
 #include "boost/filesystem.hpp"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
+
+using namespace facebook::velox::common::testutil;
 
 namespace facebook::velox::common {
 
 class FsTest : public testing::Test {};
 
 TEST_F(FsTest, createDirectory) {
-  auto dir = exec::test::TempDirectoryPath::create();
+  auto dir = TempDirectoryPath::create();
   auto rootPath = dir->getPath();
   auto tmpDirectoryPath = rootPath + "/first/second/third";
   // First time should generate directory successfully.
diff --git a/velox/common/base/tests/GTestUtils.h b/velox/common/base/tests/GTestUtils.h
index ce88abf0e05..42ec23513c4 100644
--- a/velox/common/base/tests/GTestUtils.h
+++ b/velox/common/base/tests/GTestUtils.h
@@ -117,6 +117,22 @@
     }                                                                   \
   }
 
+#define VELOX_ASSERT_EQ_TYPES(actual, expected)                         \
+  {                                                                     \
+    auto _actualType = (actual);                                        \
+    auto _expectedType = (expected);                                    \
+    if (_expectedType != nullptr) {                                     \
+      ASSERT_TRUE(_actualType != nullptr)                               \
+          << "Expected: " << _expectedType->toString() << ", got null"; \
+      ASSERT_EQ(*_actualType, *_expectedType)                           \
+          << "Expected: " << _expectedType->toString() << ", got "      \
+          << _actualType->toString();                                   \
+    } else {                                                            \
+      ASSERT_EQ(_actualType, nullptr)                                   \
+          << "Expected null, got " << _actualType->toString();          \
+    }                                                                   \
+  }
+
 #ifndef NDEBUG
 #define DEBUG_ONLY_TEST(test_fixture, test_name) TEST(test_fixture, test_name)
 #define DEBUG_ONLY_TEST_F(test_fixture, test_name) \
diff --git a/velox/common/base/tests/RuntimeMetricsTest.cpp b/velox/common/base/tests/RuntimeMetricsTest.cpp
index 7180f682a80..29a5ffe65ae 100644
--- a/velox/common/base/tests/RuntimeMetricsTest.cpp
+++ b/velox/common/base/tests/RuntimeMetricsTest.cpp
@@ -24,7 +24,7 @@ class RuntimeMetricsTest : public testing::Test {
   static void testMetric(
       const RuntimeMetric& rm1,
       int64_t expectedSum,
-      int64_t expectedCount,
+      uint64_t expectedCount,
       int64_t expectedMin = std::numeric_limits<int64_t>::max(),
       int64_t expectedMax = std::numeric_limits<int64_t>::min()) {
     EXPECT_EQ(expectedSum, rm1.sum);
@@ -84,4 +84,19 @@ TEST_F(RuntimeMetricsTest, basic) {
       "sum:2.00us, count:1, min:2.00us, max:2.00us, avg: 2.00us");
 }
 
+TEST_F(RuntimeMetricsTest, saturateCast) {
+  auto maxUint64 = std::numeric_limits<uint64_t>::max();
+  RuntimeMetric rm{
+      saturateCast(maxUint64),
+      maxUint64,
+      saturateCast(maxUint64),
+      saturateCast(maxUint64)};
+
+  auto maxInt64 = std::numeric_limits<int64_t>::max();
+  EXPECT_EQ(rm.sum, maxInt64);
+  EXPECT_EQ(rm.count, maxUint64);
+  EXPECT_EQ(rm.min, maxInt64);
+  EXPECT_EQ(rm.max, maxInt64);
+}
+
 } // namespace facebook::velox
diff --git a/velox/common/base/tests/SimdUtilTest.cpp b/velox/common/base/tests/SimdUtilTest.cpp
index 447cc55a6e2..5573df46028 100644
--- a/velox/common/base/tests/SimdUtilTest.cpp
+++ b/velox/common/base/tests/SimdUtilTest.cpp
@@ -126,6 +126,7 @@ class SimdUtilTest : public testing::Test {
   folly::Random::DefaultGenerator rng_;
 };
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
 TEST_F(SimdUtilTest, setAll) {
   auto bits = simd::setAll(true);
   auto words = reinterpret_cast<int64_t*>(&bits);
@@ -133,6 +134,7 @@ TEST_F(SimdUtilTest, setAll) {
     EXPECT_EQ(words[i], -1ll);
   }
 }
+#endif
 
 TEST_F(SimdUtilTest, bitIndices) {
   testIndices(1);
@@ -385,6 +387,10 @@ TEST_F(SimdUtilTest, crc32) {
   EXPECT_EQ(checksum, 3531890030);
   checksum = simd::crc32U64(0, 987654321);
   EXPECT_EQ(checksum, 121285919);
+  checksum = simd::crc32U64(0, 123456789, xsimd::generic{});
+  EXPECT_EQ(checksum, 3531890030);
+  checksum = simd::crc32U64(0, 987654321, xsimd::generic{});
+  EXPECT_EQ(checksum, 121285919);
 }
 
 TEST_F(SimdUtilTest, Batch64_assign) {
@@ -654,4 +660,76 @@ TEST_F(SimdUtilTest, randomStringStrStr) {
   }
 }
 
+TEST_F(SimdUtilTest, simdFill) {
+  // Test supported types: SIMD path (int32_t, uint32_t, int64_t, uint64_t,
+  // float, double).
+  auto testFill = [](auto value) {
+    using T = decltype(value);
+    struct TestParam {
+      uint32_t count;
+      std::string debugString() const {
+        return fmt::format("count {}", count);
+      }
+    };
+    std::vector<TestParam> testSettings = {
+        {0},
+        {1},
+        {3},
+        {7},
+        {8},
+        {9},
+        {15},
+        {16},
+        {17},
+        {31},
+        {32},
+        {33},
+        {63},
+        {64},
+        {100},
+        {255},
+        {256},
+        {1'000},
+        {10'000}};
+    for (const auto& testData : testSettings) {
+      SCOPED_TRACE(testData.debugString());
+      std::vector<T> output(testData.count, T{});
+      simd::simdFill(output.data(), value, testData.count);
+      for (uint32_t i = 0; i < testData.count; ++i) {
+        ASSERT_EQ(output[i], value) << "at index " << i;
+      }
+    }
+  };
+
+  testFill(static_cast<int32_t>(42));
+  testFill(static_cast<uint32_t>(42));
+  testFill(static_cast<int64_t>(123'456'789));
+  testFill(static_cast<uint64_t>(123'456'789));
+  testFill(3.14f);
+  testFill(2.718281828);
+
+  // Test unsupported types: fallback to std::fill (int8_t, int16_t, bool).
+  {
+    std::vector<int8_t> output(100, 0);
+    simd::simdFill(output.data(), static_cast<int8_t>(7), 100u);
+    for (auto v : output) {
+      ASSERT_EQ(v, 7);
+    }
+  }
+  {
+    std::vector<int16_t> output(100, 0);
+    simd::simdFill(output.data(), static_cast<int16_t>(1'234), 100u);
+    for (auto v : output) {
+      ASSERT_EQ(v, 1'234);
+    }
+  }
+  {
+    bool output[100] = {};
+    simd::simdFill(output, true, 100u);
+    for (int i = 0; i < 100; ++i) {
+      ASSERT_EQ(output[i], true);
+    }
+  }
+}
+
 } // namespace
diff --git a/velox/common/base/tests/SkewedPartitionBalancerTest.cpp b/velox/common/base/tests/SkewedPartitionBalancerTest.cpp
index 5edb57563c6..52e592f9351 100644
--- a/velox/common/base/tests/SkewedPartitionBalancerTest.cpp
+++ b/velox/common/base/tests/SkewedPartitionBalancerTest.cpp
@@ -19,7 +19,7 @@
 #include <gtest/gtest.h>
 
 #include "folly/Random.h"
-#include "folly/experimental/EventCount.h"
+#include "folly/synchronization/EventCount.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/testutil/TestValue.h"
 
@@ -76,6 +76,10 @@ class SkewedPartitionRebalancerTestHelper {
 
 class SkewedPartitionRebalancerTest : public testing::Test {
  protected:
+  static void SetUpTestSuite() {
+    TestValue::enable();
+  }
+
   std::unique_ptr<SkewedPartitionRebalancer> createBalancer(
       uint32_t numPartitions = 128,
       uint32_t numTasks = 8,
@@ -330,10 +334,18 @@ DEBUG_ONLY_TEST_F(SkewedPartitionRebalancerTest, serializedRebalanceExecution) {
   SkewedPartitionRebalancerTestHelper helper(balancer.get());
   folly::EventCount rebalanceWait;
   std::atomic_bool rebalanceWaitFlag{true};
+
+  // Used to signal that the background thread has entered the test value
+  // callback.
+  folly::EventCount mainThreadRebalancerWait;
+  std::atomic_bool mainThreadRebalancerWaitFlag{true};
   SCOPED_TESTVALUE_SET(
       "facebook::velox::common::SkewedPartitionRebalancer::rebalancePartitions",
       std::function<void(SkewedPartitionRebalancer*)>(
           [&](SkewedPartitionRebalancer*) {
+            // Signal that we've entered the callback.
+            mainThreadRebalancerWaitFlag = false;
+            mainThreadRebalancerWait.notifyAll();
             rebalanceWait.await([&] { return !rebalanceWaitFlag.load(); });
           }));
 
@@ -344,6 +356,12 @@ DEBUG_ONLY_TEST_F(SkewedPartitionRebalancerTest, serializedRebalanceExecution) {
 
   std::thread rebalanceThread([&]() { balancer->rebalance(); });
 
+  // Wait for the background thread to enter the test value callback and block
+  // there. This ensures that when we call rebalance() from the main thread,
+  // rebalancing_ is already true and our rebalance() call will return early.
+  mainThreadRebalancerWait.await(
+      [&] { return !mainThreadRebalancerWaitFlag.load(); });
+
   balancer->rebalance();
 
   rebalanceWaitFlag = false;
@@ -409,8 +427,9 @@ TEST_F(SkewedPartitionRebalancerTest, concurrentFuzz) {
         threads.emplace_back([&]() {
           std::mt19937 localRng{200};
           for (int iteration = 0; iteration < 1'000; ++iteration) {
-            SCOPED_TRACE(fmt::format(
-                "taskCount {}, iteration {}", taskCount, iteration));
+            SCOPED_TRACE(
+                fmt::format(
+                    "taskCount {}, iteration {}", taskCount, iteration));
             const uint64_t processedBytes =
                 1 + folly::Random::rand32(512, localRng);
             balancer->addProcessedBytes(processedBytes);
diff --git a/velox/common/base/tests/SpillConfigTest.cpp b/velox/common/base/tests/SpillConfigTest.cpp
index 9949486a486..30251da5c9b 100644
--- a/velox/common/base/tests/SpillConfigTest.cpp
+++ b/velox/common/base/tests/SpillConfigTest.cpp
@@ -48,6 +48,7 @@ TEST_P(SpillConfigTest, spillLevel) {
       0,
       0,
       "none",
+      0,
       prefixSortConfig_);
   struct {
     uint8_t bitOffset;
@@ -134,6 +135,7 @@ TEST_P(SpillConfigTest, spillLevelLimit) {
         0,
         0,
         "none",
+        0,
         prefixSortConfig_);
 
     ASSERT_EQ(
@@ -181,6 +183,7 @@ TEST_P(SpillConfigTest, spillableReservationPercentages) {
           1'000'000,
           0,
           "none",
+          0,
           prefixSortConfig_);
     };
 
diff --git a/velox/common/base/tests/SplitBlockBloomFilterTest.cpp b/velox/common/base/tests/SplitBlockBloomFilterTest.cpp
new file mode 100644
index 00000000000..2a98ea75634
--- /dev/null
+++ b/velox/common/base/tests/SplitBlockBloomFilterTest.cpp
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/SplitBlockBloomFilter.h"
+#include "velox/common/testutil/RandomSeed.h"
+
+#include <folly/container/F14Set.h>
+#include <gtest/gtest.h>
+
+#include <random>
+
+namespace facebook::velox::test {
+namespace {
+
+template <typename Hasher>
+SplitBlockBloomFilter makeFilter(
+    const folly::F14FastSet<int64_t>& values,
+    const Hasher& hasher,
+    std::vector<SplitBlockBloomFilter::Block>& blocks) {
+  blocks.resize(SplitBlockBloomFilter::numBlocks(values.size(), 0.01));
+  bzero(blocks.data(), blocks.size() * sizeof(SplitBlockBloomFilter::Block));
+  SplitBlockBloomFilter filter(blocks);
+  for (auto& value : values) {
+    filter.insert(hasher(value));
+  }
+  return filter;
+}
+
+TEST(SplitBlockBloomFilterTest, numBlocks) {
+  ASSERT_EQ(
+      SplitBlockBloomFilter::numBlocks(50'000'000, 0.01) *
+          sizeof(SplitBlockBloomFilter::Block),
+      xsimd::batch<uint32_t>::size == 8 ? 60509568 : 65766912);
+  ASSERT_EQ(
+      SplitBlockBloomFilter::numBlocks(45'523'964, 0.1) *
+          sizeof(SplitBlockBloomFilter::Block),
+      xsimd::batch<uint32_t>::size == 8 ? 32848640 : 27546352);
+}
+
+TEST(SplitBlockBloomFilterTest, contiguous) {
+  constexpr int kSize = 100'000;
+  std::default_random_engine gen(common::testutil::getRandomSeed(42));
+  std::uniform_int_distribution<> dist(0, 9);
+  folly::F14FastSet<int64_t> values;
+  values.reserve(kSize / 10);
+  for (int i = 0; i < kSize; ++i) {
+    if (dist(gen) == 0) {
+      values.insert(i);
+    }
+  }
+  std::vector<SplitBlockBloomFilter::Block> blocks;
+  auto test = [&](auto hasher) {
+    auto filter = makeFilter(values, hasher, blocks);
+    int numFalsePositive = 0;
+    for (int i = 0; i < kSize; ++i) {
+      if (values.contains(i)) {
+        ASSERT_TRUE(filter.mayContain(hasher(i)));
+      } else {
+        numFalsePositive += filter.mayContain(hasher(i));
+      }
+    }
+    ASSERT_LT(1.0 * numFalsePositive / kSize, 0.03);
+  };
+  {
+    SCOPED_TRACE("Folly");
+    test(folly::hasher<int64_t>());
+  }
+  {
+    SCOPED_TRACE("Multiplication");
+    test([](auto x) { return x * 0xc6a4a7935bd1e995L; });
+  }
+}
+
+TEST(SplitBlockBloomFilterTest, random) {
+  constexpr int kSize = 100'000;
+  std::default_random_engine gen(common::testutil::getRandomSeed(42));
+  std::uniform_int_distribution<int64_t> dist;
+  folly::F14FastSet<int64_t> values;
+  values.reserve(kSize);
+  for (int i = 0; i < kSize; ++i) {
+    values.insert(dist(gen));
+  }
+  std::vector<SplitBlockBloomFilter::Block> blocks;
+  auto test = [&](auto hasher) {
+    auto filter = makeFilter(values, hasher, blocks);
+    for (auto value : values) {
+      ASSERT_TRUE(filter.mayContain(hasher(value)));
+    }
+    int numFalsePositive = 0;
+    for (int i = 0; i < kSize; ++i) {
+      auto value = dist(gen);
+      if (!values.contains(value)) {
+        numFalsePositive += filter.mayContain(hasher(value));
+      }
+    }
+    ASSERT_LT(1.0 * numFalsePositive / kSize, 0.03);
+  };
+  {
+    SCOPED_TRACE("Folly");
+    test(folly::hasher<int64_t>());
+  }
+  {
+    SCOPED_TRACE("Multiplication");
+    test([](auto x) { return x * 0xc6a4a7935bd1e995L; });
+  }
+}
+
+} // namespace
+} // namespace facebook::velox::test
diff --git a/velox/common/base/tests/StatsReporterTest.cpp b/velox/common/base/tests/StatsReporterTest.cpp
index 773c52db6c8..d76827d32f9 100644
--- a/velox/common/base/tests/StatsReporterTest.cpp
+++ b/velox/common/base/tests/StatsReporterTest.cpp
@@ -28,7 +28,7 @@
 #include "velox/common/caching/SsdCache.h"
 #include "velox/common/memory/MmapAllocator.h"
 
-namespace facebook::velox {
+namespace facebook::velox::test {
 
 struct QuantileConfig {
   std::vector<StatType> statTypes;
@@ -409,69 +409,109 @@ TEST_F(PeriodicStatsReporterTest, basic) {
   const auto& counterMap = reporter_->counterMap;
   {
     std::lock_guard<std::mutex> l(reporter_->m);
-    ASSERT_EQ(counterMap.count(kMetricArbitratorFreeCapacityBytes.str()), 1);
-    ASSERT_EQ(
-        counterMap.count(kMetricArbitratorFreeReservedCapacityBytes.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumEntries.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumEmptyEntries.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumSharedEntries.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumExclusiveEntries.str()), 1);
-    ASSERT_EQ(
-        counterMap.count(kMetricMemoryCacheNumPrefetchedEntries.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheTotalTinyBytes.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheTotalLargeBytes.str()), 1);
-    ASSERT_EQ(
-        counterMap.count(kMetricMemoryCacheTotalTinyPaddingBytes.str()), 1);
-    ASSERT_EQ(
-        counterMap.count(kMetricMemoryCacheTotalLargePaddingBytes.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheTotalPrefetchBytes.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheCachedEntries.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheCachedRegions.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheCachedBytes.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricCacheMaxAgeSecs.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricMemoryAllocatorMappedBytes.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricMemoryAllocatorAllocatedBytes.str()), 1);
-    ASSERT_EQ(
-        counterMap.count(kMetricMmapAllocatorDelegatedAllocatedBytes.str()), 1);
-    ASSERT_EQ(
-        counterMap.count(kMetricMemoryAllocatorExternalMappedBytes.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSpillMemoryBytes.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSpillPeakMemoryBytes.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricMemoryAllocatorTotalUsedBytes.str()), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricArbitratorFreeCapacityBytes)), 1);
+    ASSERT_EQ(
+        counterMap.count(
+            std::string(kMetricArbitratorFreeReservedCapacityBytes)),
+        1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumTinyEntries)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumLargeEntries)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumEmptyEntries)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumSharedEntries)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumExclusiveEntries)),
+        1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumPrefetchedEntries)),
+        1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheTotalTinyBytes)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheTotalLargeBytes)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheTotalTinyPaddingBytes)),
+        1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheTotalLargePaddingBytes)),
+        1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheTotalPrefetchBytes)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheCachedEntries)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheCachedRegions)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheCachedBytes)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricCacheMaxAgeSecs)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryAllocatorMappedBytes)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryAllocatorAllocatedBytes)), 1);
+    ASSERT_EQ(
+        counterMap.count(
+            std::string(kMetricMmapAllocatorDelegatedAllocatedBytes)),
+        1);
+    ASSERT_EQ(
+        counterMap.count(
+            std::string(kMetricMemoryAllocatorExternalMappedBytes)),
+        1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSpillMemoryBytes)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSpillPeakMemoryBytes)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryAllocatorTotalUsedBytes)), 1);
     // Check deltas are not reported
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumHits.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheHitBytes.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumNew.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumEvicts.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumSavableEvicts.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumEvictChecks.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumWaitExclusive.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumAllocClocks.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumAgedOutEntries.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheSumEvictScore.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadEntries.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadBytes.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheWrittenEntries.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheWrittenBytes.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheOpenSsdErrors.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheOpenCheckpointErrors.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheOpenLogErrors.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheMetaFileDeleteErrors.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheGrowFileErrors.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheWriteSsdErrors.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheWriteSsdDropped.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheWriteCheckpointErrors.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadSsdErrors.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadCorruptions.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadCheckpointErrors.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheCheckpointsRead.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheCheckpointsWritten.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheRegionsEvicted.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheAgedOutEntries.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheAgedOutRegions.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheRecoveredEntries.str()), 0);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadWithoutChecksum.str()), 0);
-    ASSERT_EQ(counterMap.size(), 23);
+    ASSERT_EQ(counterMap.count(std::string(kMetricMemoryCacheNumHits)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricMemoryCacheHitBytes)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricMemoryCacheNumNew)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricMemoryCacheNumEvicts)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumSavableEvicts)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumEvictChecks)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumWaitExclusive)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumAllocClocks)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumAgedOutEntries)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheSumEvictScore)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheReadEntries)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheReadBytes)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheWrittenEntries)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheWrittenBytes)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheOpenSsdErrors)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheOpenCheckpointErrors)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheOpenLogErrors)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheMetaFileDeleteErrors)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheGrowFileErrors)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheWriteSsdErrors)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheWriteNoSpaceErrors)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheWriteSsdDropped)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheWriteExceedEntryLimit)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheWriteCheckpointErrors)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheReadSsdErrors)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheReadCorruptions)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheReadCheckpointErrors)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheCheckpointsRead)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheCheckpointsWritten)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheRegionsEvicted)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheAgedOutEntries)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheAgedOutRegions)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheRecoveredEntries)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheReadWithoutChecksum)), 0);
+    ASSERT_EQ(counterMap.size(), 24);
   }
 
   // Update stats
@@ -492,7 +532,9 @@ TEST_F(PeriodicStatsReporterTest, basic) {
   newSsdStats->deleteMetaFileErrors = 10;
   newSsdStats->growFileErrors = 10;
   newSsdStats->writeSsdErrors = 10;
+  newSsdStats->writeSsdNoSpaceErrors = 1;
   newSsdStats->writeSsdDropped = 10;
+  newSsdStats->writeSsdExceedEntryLimit = 10;
   newSsdStats->writeCheckpointErrors = 10;
   newSsdStats->readSsdErrors = 10;
   newSsdStats->readSsdCorruptions = 10;
@@ -511,8 +553,9 @@ TEST_F(PeriodicStatsReporterTest, basic) {
        .allocClocks = 10,
        .sumEvictScore = 10,
        .ssdStats = newSsdStats});
-  arbitrator.updateStats(memory::MemoryArbitrator::Stats(
-      10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10));
+  arbitrator.updateStats(
+      memory::MemoryArbitrator::Stats(
+          10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10));
   std::this_thread::sleep_for(std::chrono::milliseconds(4'000));
 
   // Stop right after sufficient wait to ensure the following reads from main
@@ -522,39 +565,56 @@ TEST_F(PeriodicStatsReporterTest, basic) {
   // Check delta stats are reported
   {
     std::lock_guard<std::mutex> l(reporter_->m);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumHits.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheHitBytes.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumNew.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumEvicts.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumSavableEvicts.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumEvictChecks.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumWaitExclusive.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumAllocClocks.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumAgedOutEntries.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricMemoryCacheSumEvictScore.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadEntries.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadBytes.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheWrittenEntries.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheWrittenBytes.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheOpenSsdErrors.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheOpenCheckpointErrors.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheOpenLogErrors.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheMetaFileDeleteErrors.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheGrowFileErrors.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheWriteSsdErrors.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheWriteSsdDropped.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheWriteCheckpointErrors.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadSsdErrors.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadCorruptions.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadCheckpointErrors.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheCheckpointsRead.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheCheckpointsWritten.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheRegionsEvicted.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheAgedOutEntries.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheAgedOutRegions.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheRecoveredEntries.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadWithoutChecksum.str()), 1);
-    ASSERT_EQ(counterMap.size(), 55);
+    ASSERT_EQ(counterMap.count(std::string(kMetricMemoryCacheNumHits)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricMemoryCacheHitBytes)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricMemoryCacheNumNew)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricMemoryCacheNumEvicts)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumSavableEvicts)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumEvictChecks)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumWaitExclusive)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumAllocClocks)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumAgedOutEntries)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheSumEvictScore)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheReadEntries)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheReadBytes)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheWrittenEntries)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheWrittenBytes)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheOpenSsdErrors)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheOpenCheckpointErrors)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheOpenLogErrors)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheMetaFileDeleteErrors)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheGrowFileErrors)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheWriteSsdErrors)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheWriteNoSpaceErrors)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheWriteSsdDropped)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheWriteExceedEntryLimit)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheWriteCheckpointErrors)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheReadSsdErrors)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheReadCorruptions)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheReadCheckpointErrors)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheCheckpointsRead)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheCheckpointsWritten)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheRegionsEvicted)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheAgedOutEntries)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheAgedOutRegions)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheRecoveredEntries)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheReadWithoutChecksum)), 1);
+    ASSERT_EQ(counterMap.size(), 58);
   }
 }
 
@@ -903,7 +963,7 @@ folly::Singleton<BaseStatsReporter> reporter([]() {
   return new TestReporter();
 });
 
-} // namespace facebook::velox
+} // namespace facebook::velox::test
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
diff --git a/velox/common/base/tests/StatsReporterUtils.h b/velox/common/base/tests/StatsReporterUtils.h
index b65bee056e2..f58111c3e29 100644
--- a/velox/common/base/tests/StatsReporterUtils.h
+++ b/velox/common/base/tests/StatsReporterUtils.h
@@ -26,13 +26,11 @@
 #include <vector>
 #include "velox/common/base/StatsReporter.h"
 
-namespace facebook::velox {
+namespace facebook::velox::test {
 
-/**
- * A test implementation of BaseStatsReporter for use in unit tests.
- * This class provides a mock implementation that captures all metric
- * registrations and values for verification in tests.
- */
+/// A test implementation of BaseStatsReporter for use in unit tests.
+/// This class provides a mock implementation that captures all metric
+/// registrations and values for verification in tests.
 class TestReporter : public BaseStatsReporter {
  public:
   mutable std::mutex m;
@@ -239,10 +237,8 @@ class TestReporter : public BaseStatsReporter {
     return ss.str();
   }
 
-  /**
-   * Get the current counter value for a specific key.
-   * Returns 0 if the key doesn't exist.
-   */
+  // Get the current counter value for a specific key.
+  // Returns 0 if the key doesn't exist.
   size_t getCounterValue(const std::string& key) const {
     std::lock_guard<std::mutex> l(m);
     auto it = counterMap.find(key);
@@ -250,4 +246,4 @@ class TestReporter : public BaseStatsReporter {
   }
 };
 
-} // namespace facebook::velox
+} // namespace facebook::velox::test
diff --git a/velox/common/base/tests/StatusTest.cpp b/velox/common/base/tests/StatusTest.cpp
index 282563d142f..1501c18dd30 100644
--- a/velox/common/base/tests/StatusTest.cpp
+++ b/velox/common/base/tests/StatusTest.cpp
@@ -211,6 +211,22 @@ TEST(StatusTest, statusMacros) {
           "Reason: User error occurred.\nExpression: status != nullptr\n"));
 }
 
+TEST(StatusTest, statusMacrosSkipDetails) {
+  ScopedThreadSkipErrorDetails skipErrorDetails(true);
+  ASSERT_EQ(returnMacroCheck(), Status::UserError());
+  ASSERT_EQ(returnMacroEmptyMessage(), Status::UserError());
+  ASSERT_EQ(returnMacroFormat(), Status::UserError());
+  ASSERT_EQ(returnMacroGT(), Status::UserError());
+  ASSERT_EQ(returnMacroGE(), Status::UserError());
+  ASSERT_EQ(returnMacroLT(), Status::UserError());
+  ASSERT_EQ(returnMacroLE(), Status::UserError());
+  ASSERT_EQ(returnMacroEQ(), Status::UserError());
+  ASSERT_EQ(returnMacroNE(), Status::UserError());
+  ASSERT_EQ(returnMacroNULL(), Status::UserError());
+  Status status = Status::OK();
+  ASSERT_EQ(returnNotNull(&status), Status::UserError());
+}
+
 Expected<int> modulo(int a, int b) {
   if (b == 0) {
     return folly::makeUnexpected(Status::UserError("division by zero"));
diff --git a/velox/common/caching/AsyncDataCache.cpp b/velox/common/caching/AsyncDataCache.cpp
index 717107416d5..9ff5b382323 100644
--- a/velox/common/caching/AsyncDataCache.cpp
+++ b/velox/common/caching/AsyncDataCache.cpp
@@ -23,7 +23,6 @@
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/StatsReporter.h"
 #include "velox/common/base/SuccinctPrinter.h"
-#include "velox/common/caching/FileIds.h"
 
 #define VELOX_CACHE_ERROR(errorMessage)                             \
   _VELOX_THROW(                                                     \
@@ -44,7 +43,34 @@ AsyncDataCacheEntry::AsyncDataCacheEntry(CacheShard* shard) : shard_(shard) {
 }
 
 AsyncDataCacheEntry::~AsyncDataCacheEntry() {
-  shard_->cache()->allocator()->freeNonContiguous(data_);
+  freeData();
+}
+
+void AsyncDataCacheEntry::freeData() {
+  auto* cache = shard_->cache();
+  const auto nonContiguousPages = nonContiguousData_.numPages();
+  if (nonContiguousPages > 0) {
+    VELOX_CHECK_NULL(
+        contiguousData_,
+        "Entry cannot have both non-contiguous and contiguous data");
+    VELOX_CHECK(
+        tinyData_.empty(),
+        "Entry cannot have both non-contiguous and tiny data");
+    cache->incrementCachedPages(-nonContiguousPages);
+    ClockTimer t(shard_->allocClocks());
+    cache->allocator()->freeNonContiguous(nonContiguousData_);
+  }
+  if (contiguousData_ != nullptr) {
+    VELOX_CHECK(
+        tinyData_.empty(), "Entry cannot have both contiguous and tiny data");
+    cache->incrementCachedPages(-memory::AllocationTraits::numPages(size_));
+    ClockTimer t(shard_->allocClocks());
+    cache->allocator()->freeBytes(contiguousData_, size_);
+    contiguousData_ = nullptr;
+  }
+  tinyData_.clear();
+  tinyData_.shrink_to_fit();
+  size_ = 0;
 }
 
 void AsyncDataCacheEntry::setExclusiveToShared(bool ssdSavable) {
@@ -111,7 +137,7 @@ memory::MachinePageCount AsyncDataCacheEntry::setPrefetch(bool flag) {
   return shard_->cache()->incrementPrefetchPages(flag ? numPages : -numPages);
 }
 
-void AsyncDataCacheEntry::initialize(FileCacheKey key) {
+void AsyncDataCacheEntry::initialize(FileCacheKey key, bool contiguous) {
   VELOX_CHECK(isExclusive());
   setSsdFile(nullptr, 0);
   key_ = std::move(key);
@@ -120,20 +146,78 @@ void AsyncDataCacheEntry::initialize(FileCacheKey key) {
   if (size_ < AsyncDataCacheEntry::kTinyDataSize) {
     tinyData_.resize(size_);
     tinyData_.shrink_to_fit();
-  } else {
-    tinyData_.clear();
-    tinyData_.shrink_to_fit();
-    const auto sizePages = memory::AllocationTraits::numPages(size_);
-    if (cache->allocator()->allocateNonContiguous(sizePages, data_)) {
-      cache->incrementCachedPages(data().numPages());
-    } else {
-      // No memory to cover 'this'.
-      release();
-      VELOX_CACHE_ERROR(fmt::format(
+    return;
+  }
+
+  tinyData_.clear();
+  tinyData_.shrink_to_fit();
+  if (contiguous) {
+    contiguousData_ = cache->allocator()->allocateBytes(size_);
+    if (contiguousData_ != nullptr) {
+      cache->incrementCachedPages(memory::AllocationTraits::numPages(size_));
+      return;
+    }
+    release();
+    VELOX_CACHE_ERROR(
+        fmt::format(
+            "Failed to allocate {} for contiguous cache: {}",
+            succinctBytes(size_),
+            cache->allocator()->getAndClearFailureMessage()));
+  }
+
+  const auto sizePages = memory::AllocationTraits::numPages(size_);
+  if (cache->allocator()->allocateNonContiguous(
+          sizePages, nonContiguousData_)) {
+    cache->incrementCachedPages(nonContiguousData().numPages());
+    return;
+  }
+  release();
+  VELOX_CACHE_ERROR(
+      fmt::format(
           "Failed to allocate {} pages for cache: {}",
           sizePages,
           cache->allocator()->getAndClearFailureMessage()));
-    }
+}
+
+std::vector<folly::Range<char*>> AsyncDataCacheEntry::dataRanges(
+    size_t length) {
+  std::vector<folly::Range<char*>> buffers;
+  if (hasContiguousData()) {
+    buffers.emplace_back(contiguousData(), std::min<size_t>(length, size_));
+    return buffers;
+  }
+  buffers.reserve(nonContiguousData_.numRuns());
+  uint64_t offsetInRuns = 0;
+  for (int i = 0; i < nonContiguousData_.numRuns(); ++i) {
+    auto run = nonContiguousData_.runAt(i);
+    const uint64_t bytes = run.numBytes();
+    const uint64_t readSize = std::min(bytes, length - offsetInRuns);
+    buffers.emplace_back(run.data<char>(), readSize);
+    offsetInRuns += readSize;
+  }
+  return buffers;
+}
+
+int64_t AsyncDataCacheEntry::dataCapacity() const {
+  return tinyData_.capacity() + (contiguousData_ != nullptr ? size_ : 0) +
+      nonContiguousData_.byteSize();
+}
+
+void AsyncDataCacheEntry::updateDataStats(CacheStats& stats) const {
+  if (!tinyData_.empty()) {
+    VELOX_CHECK_NULL(contiguousData_);
+    VELOX_CHECK(nonContiguousData_.empty());
+    stats.tinySize += tinyData_.size();
+    stats.tinyPadding += tinyData_.capacity() - tinyData_.size();
+    ++stats.numTinyEntries;
+  } else if (contiguousData_ != nullptr) {
+    VELOX_CHECK(nonContiguousData_.empty());
+    stats.largeSize += size_;
+    ++stats.numLargeEntries;
+  } else {
+    stats.largeSize += size_;
+    stats.largePadding += nonContiguousData_.byteSize() - size_;
+    ++stats.numLargeEntries;
   }
 }
 
@@ -151,7 +235,7 @@ std::string AsyncDataCacheEntry::toString() const {
       numPins_);
 }
 
-std::unique_ptr<AsyncDataCacheEntry> CacheShard::getFreeEntry() {
+std::unique_ptr<AsyncDataCacheEntry> CacheShard::getFreeEntryLocked() {
   std::unique_ptr<AsyncDataCacheEntry> newEntry;
   if (freeEntries_.empty()) {
     newEntry = std::make_unique<AsyncDataCacheEntry>(this);
@@ -162,57 +246,64 @@ std::unique_ptr<AsyncDataCacheEntry> CacheShard::getFreeEntry() {
   return newEntry;
 }
 
+std::optional<CachePin> CacheShard::lookupLocked(
+    RawFileCacheKey key,
+    uint64_t size,
+    folly::SemiFuture<bool>* wait) {
+  ++eventCounter_;
+  auto it = entryMap_.find(key);
+  if (it == entryMap_.end()) {
+    return std::nullopt;
+  }
+  auto* foundEntry = it->second;
+  if (foundEntry->isExclusive()) {
+    ++numWaitExclusive_;
+    if (wait != nullptr) {
+      *wait = foundEntry->getFutureLocked();
+    }
+    return CachePin{};
+  }
+  // size=0 (from find()) always passes since entry size is non-negative.
+  if (foundEntry->size() < size) {
+    // This can happen if different load quanta apply to access via different
+    // connectors. This is not an error but still worth logging.
+    VELOX_CACHE_LOG_EVERY_MS(WARNING, 1'000)
+        << "Requested larger entry. Found size " << foundEntry->size()
+        << " requested size " << size;
+    RECORD_METRIC_VALUE(kMetricMemoryCacheNumStaleEntries);
+    ++numStales_;
+    foundEntry->key_.fileNum.clear();
+    entryMap_.erase(it);
+    return std::nullopt;
+  }
+  foundEntry->touch();
+  if (foundEntry->isPrefetch()) {
+    foundEntry->isFirstUse_ = true;
+    foundEntry->setPrefetch(false);
+  } else {
+    ++numHit_;
+    hitBytes_ += foundEntry->size();
+  }
+  ++foundEntry->numPins_;
+  CachePin pin;
+  pin.setEntry(foundEntry);
+  return pin;
+}
+
 CachePin CacheShard::findOrCreate(
     RawFileCacheKey key,
     uint64_t size,
+    bool contiguous,
     folly::SemiFuture<bool>* wait) {
   AsyncDataCacheEntry* entryToInit = nullptr;
   {
     std::lock_guard<std::mutex> l(mutex_);
-    ++eventCounter_;
-    auto it = entryMap_.find(key);
-    if (it != entryMap_.end()) {
-      auto* foundEntry = it->second;
-      if (foundEntry->isExclusive()) {
-        ++numWaitExclusive_;
-        if (wait != nullptr) {
-          *wait = foundEntry->getFuture();
-        }
-        return CachePin();
-      }
-
-      if (foundEntry->size() >= size) {
-        foundEntry->touch();
-        // The entry is in a readable state. Add a pin.
-        if (foundEntry->isPrefetch()) {
-          foundEntry->isFirstUse_ = true;
-          foundEntry->setPrefetch(false);
-        } else {
-          ++numHit_;
-          hitBytes_ += foundEntry->size();
-        }
-        ++foundEntry->numPins_;
-        CachePin pin;
-        pin.setEntry(foundEntry);
-        return pin;
-      }
-
-      // TODO: add stats to report or send alert in production.
-
-      // This can happen if different load quanta apply to access via different
-      // connectors. This is not an error but still worth logging.
-      VELOX_CACHE_LOG_EVERY_MS(WARNING, 1'000)
-          << "Requested larger entry. Found size " << foundEntry->size()
-          << " requested size " << size;
-      // The old entry is superseded. Possible readers of the old entry still
-      // retain a valid read pin.
-      RECORD_METRIC_VALUE(kMetricMemoryCacheNumStaleEntries);
-      ++numStales_;
-      foundEntry->key_.fileNum.clear();
-      entryMap_.erase(it);
+    auto result = lookupLocked(key, size, wait);
+    if (result.has_value()) {
+      return std::move(result.value());
     }
 
-    auto newEntry = getFreeEntry();
+    auto newEntry = getFreeEntryLocked();
     // Initialize the members that must be set inside 'mutex_'.
     newEntry->numPins_ = AsyncDataCacheEntry::kExclusive;
     newEntry->promise_ = nullptr;
@@ -231,7 +322,16 @@ CachePin CacheShard::findOrCreate(
     entryToInit->size_ = size;
     entryToInit->isFirstUse_ = true;
   }
-  return initEntry(key, entryToInit);
+  return initEntry(key, contiguous, entryToInit);
+}
+
+std::optional<CachePin> CacheShard::find(
+    RawFileCacheKey key,
+    folly::SemiFuture<bool>* wait) {
+  std::lock_guard<std::mutex> l(mutex_);
+  // size=0 means any cached entry size is acceptable, so lookupLocked will
+  // never trigger the stale-entry eviction path.
+  return lookupLocked(key, 0, wait);
 }
 
 void CacheShard::makeEvictable(RawFileCacheKey key) {
@@ -253,8 +353,18 @@ bool CacheShard::exists(RawFileCacheKey key) const {
   return false;
 }
 
+bool CacheShard::testingIsEvictable(RawFileCacheKey key) const {
+  std::lock_guard<std::mutex> l(mutex_);
+  auto it = entryMap_.find(key);
+  if (it == entryMap_.end()) {
+    return false;
+  }
+  return it->second->testingIsEvictable();
+}
+
 CachePin CacheShard::initEntry(
     RawFileCacheKey key,
+    bool contiguous,
     AsyncDataCacheEntry* entry) {
   // The new entry is in the map and is in exclusive mode and is otherwise
   // uninitialized. Other threads may find it and may add a promise or wait for
@@ -262,7 +372,8 @@ CachePin CacheShard::initEntry(
   // and uninterpretable except for this thread. Non access serializing members
   // can be set outside of 'mutex_'.
   entry->initialize(
-      FileCacheKey{StringIdLease(fileIds(), key.fileNum), key.offset});
+      FileCacheKey{StringIdLease(fileIds(), key.fileNum), key.offset},
+      contiguous);
   cache_->incrementNew(entry->size());
   CachePin pin;
   pin.setEntry(entry);
@@ -278,6 +389,8 @@ bool CoalescedLoad::loadOrFuture(
     folly::SemiFuture<bool>* wait,
     bool ssdSavable) {
   {
+    common::testutil::TestValue::adjust(
+        "facebook::velox::cache::CoalescedLoad::loadOrFuture", this);
     std::lock_guard<std::mutex> l(mutex_);
     if (state_ == State::kCancelled || state_ == State::kLoaded) {
       return true;
@@ -298,6 +411,8 @@ bool CoalescedLoad::loadOrFuture(
   }
 
   // Outside of 'mutex_'.
+  common::testutil::TestValue::adjust(
+      "facebook::velox::cache::CoalescedLoad::loadOrFuture::loading", this);
   try {
     const auto pins = loadData(/*prefetch=*/wait == nullptr);
     for (const auto& pin : pins) {
@@ -336,7 +451,7 @@ std::unique_ptr<folly::SharedPromise<bool>> CacheShard::removeEntry(
   removeEntryLocked(entry);
   // After the entry is removed from the hash table, a promise can no longer
   // be made. It is safe to move the promise and realize it.
-  return entry->movePromise();
+  return entry->movePromiseLocked();
 }
 
 void CacheShard::removeEntryLocked(AsyncDataCacheEntry* entry) {
@@ -355,27 +470,58 @@ void CacheShard::removeEntryLocked(AsyncDataCacheEntry* entry) {
   // to fill it. Free the data and account for the difference. In
   // eviction, the data of the evicted entries is moved away, so
   // that freeing while holding the shard mutex is exceptional.
-  const auto numPages = entry->data().numPages();
-  if (numPages > 0) {
-    cache_->incrementCachedPages(-numPages);
-    ClockTimer t(allocClocks_);
-    cache_->allocator()->freeNonContiguous(entry->data());
+  entry->freeData();
+}
+
+void CacheShard::acquireEvictedData(
+    AsyncDataCacheEntry* entry,
+    uint64_t& bytesToAcquire,
+    AcquiredMemory& acquired,
+    AcquiredMemory& toFree,
+    int64_t& largeEvicted,
+    int64_t& tinyEvicted) {
+  if (entry->contiguousData_ != nullptr) {
+    VELOX_CHECK(entry->tinyData_.empty());
+    VELOX_CHECK(entry->nonContiguousData_.empty());
+    const uint64_t bytes = entry->size_;
+    if (bytesToAcquire > 0) {
+      bytesToAcquire = bytes > bytesToAcquire ? 0 : bytesToAcquire - bytes;
+      acquired.byteAllocations.emplace_back(entry->contiguousData_, bytes);
+    } else {
+      toFree.byteAllocations.emplace_back(entry->contiguousData_, bytes);
+    }
+    entry->contiguousData_ = nullptr;
+    largeEvicted += memory::AllocationTraits::pageBytes(
+        memory::AllocationTraits::numPages(bytes));
+  } else if (entry->nonContiguousData_.numPages() > 0) {
+    VELOX_CHECK(entry->tinyData_.empty());
+    const auto bytes = entry->nonContiguousData_.byteSize();
+    if (bytesToAcquire > 0) {
+      bytesToAcquire = bytes > bytesToAcquire ? 0 : bytesToAcquire - bytes;
+      acquired.nonContiguousAllocs.appendMove(entry->nonContiguousData());
+    } else {
+      toFree.nonContiguousAllocs.appendMove(entry->nonContiguousData());
+    }
+    VELOX_DCHECK(entry->nonContiguousData().empty());
+    largeEvicted += bytes;
+  } else {
+    tinyEvicted += entry->tinyData_.size();
+    entry->tinyData_.clear();
+    entry->tinyData_.shrink_to_fit();
   }
-  entry->tinyData_.clear();
-  entry->tinyData_.shrink_to_fit();
   entry->size_ = 0;
 }
 
 uint64_t CacheShard::evict(
     uint64_t bytesToFree,
     bool evictAllUnpinned,
-    MachinePageCount pagesToAcquire,
-    memory::Allocation& acquired) {
+    uint64_t bytesToAcquire,
+    AcquiredMemory& acquired) {
   auto* ssdCache = cache_->ssdCache();
   const bool skipSsdSaveable =
       (ssdCache != nullptr) && ssdCache->writeInProgress();
   auto now = accessTime();
-  std::vector<memory::Allocation> toFree;
+  AcquiredMemory toFree;
   int64_t tinyEvicted = 0;
   int64_t largeEvicted = 0;
   int32_t evictSaveableSkipped = 0;
@@ -409,7 +555,7 @@ uint64_t CacheShard::evict(
           eventCounter_ > entries_.size() / 4 ||
           numChecked > entries_.size() / 8) {
         now = accessTime();
-        calibrateThreshold();
+        calibrateThresholdLocked();
         numChecked = 0;
         eventCounter_ = 0;
       }
@@ -425,21 +571,13 @@ uint64_t CacheShard::evict(
         if (candidate->ssdSaveable()) {
           ++numSavableEvict_;
         }
-        largeEvicted += candidate->data_.byteSize();
-        if (pagesToAcquire > 0) {
-          const auto candidatePages = candidate->data().numPages();
-          pagesToAcquire = candidatePages > pagesToAcquire
-              ? 0
-              : pagesToAcquire - candidatePages;
-          acquired.appendMove(candidate->data());
-          VELOX_CHECK(candidate->data().empty());
-        } else {
-          toFree.push_back(std::move(candidate->data()));
-        }
-        tinyEvicted += candidate->tinyData_.size();
-        candidate->tinyData_.clear();
-        candidate->tinyData_.shrink_to_fit();
-        candidate->size_ = 0;
+        acquireEvictedData(
+            candidate,
+            bytesToAcquire,
+            acquired,
+            toFree,
+            largeEvicted,
+            tinyEvicted);
 
         removeEntryLocked(candidate);
         emptySlots_.push_back(entryIndex);
@@ -456,7 +594,7 @@ uint64_t CacheShard::evict(
   }
 
   ClockTimer t(allocClocks_);
-  freeAllocations(toFree);
+  toFree.free(cache_->allocator());
   cache_->incrementCachedPages(
       -memory::AllocationTraits::numPages(largeEvicted));
   if (evictSaveableSkipped) {
@@ -483,15 +621,8 @@ void CacheShard::tryAddFreeEntry(std::unique_ptr<AsyncDataCacheEntry>&& entry) {
   }
 }
 
-void CacheShard::freeAllocations(std::vector<memory::Allocation>& allocations) {
-  for (auto& allocation : allocations) {
-    cache_->allocator()->freeNonContiguous(allocation);
-  }
-  allocations.clear();
-}
-
-void CacheShard::calibrateThreshold() {
-  auto numSamples = std::min<int32_t>(10, entries_.size());
+void CacheShard::calibrateThresholdLocked() {
+  auto numSamples = std::min<int32_t>(kMaxEvictionSamples, entries_.size());
   auto now = accessTime();
   auto entryIndex = (clockHand_ % entries_.size());
   auto step = entries_.size() / numSamples;
@@ -510,24 +641,33 @@ void CacheShard::calibrateThreshold() {
         return score;
       },
       numSamples,
-      80);
+      kEvictionPercentile);
 }
 
 void CacheShard::updateStats(CacheStats& stats) {
   std::lock_guard<std::mutex> l(mutex_);
   for (auto& entry : entries_) {
-    if (!entry || !entry->key_.fileNum.hasValue()) {
+    if (!entry) {
       ++stats.numEmptyEntries;
       continue;
     }
 
     if (entry->isExclusive()) {
-      stats.exclusivePinnedBytes +=
-          entry->data().byteSize() + entry->tinyData_.capacity();
+      // We cannot read data() or tinyData_ which are being allocated during
+      // initialize(). Use size_ as an approximation of the pinned bytes.
+      stats.exclusivePinnedBytes += entry->size_;
       ++stats.numExclusive;
-    } else if (entry->isShared()) {
-      stats.sharedPinnedBytes +=
-          entry->data().byteSize() + entry->tinyData_.capacity();
+      // Skip rest of the field accesses while entry is being initialized.
+      continue;
+    }
+
+    if (!entry->key_.fileNum.hasValue()) {
+      ++stats.numEmptyEntries;
+      continue;
+    }
+
+    if (entry->isShared()) {
+      stats.sharedPinnedBytes += entry->dataCapacity();
       ++stats.numShared;
     }
 
@@ -537,12 +677,7 @@ void CacheShard::updateStats(CacheStats& stats) {
     }
 
     ++stats.numEntries;
-    stats.tinySize += entry->tinyData_.size();
-    stats.tinyPadding += entry->tinyData_.capacity() - entry->tinyData_.size();
-    if (entry->tinyData_.empty()) {
-      stats.largeSize += entry->size_;
-      stats.largePadding += entry->data_.byteSize() - entry->size_;
-    }
+    entry->updateDataStats(stats);
   }
   stats.numHit += numHit_;
   stats.hitBytes += hitBytes_;
@@ -591,8 +726,9 @@ bool CacheShard::removeFileEntries(
     return true;
   }
 
+  int32_t numRemoved = 0;
   int64_t pagesRemoved = 0;
-  std::vector<memory::Allocation> toFree;
+  AcquiredMemory toFree;
   {
     std::lock_guard<std::mutex> l(mutex_);
 
@@ -610,22 +746,28 @@ bool CacheShard::removeFileEntries(
         continue;
       }
 
-      numAgedOut_++;
-      pagesRemoved += static_cast<int64_t>(cacheEntry->data().numPages());
-
-      toFree.push_back(std::move(cacheEntry->data()));
+      ++numAgedOut_;
+      ++numRemoved;
+      if (cacheEntry->contiguousData_ != nullptr) {
+        pagesRemoved += memory::AllocationTraits::numPages(cacheEntry->size_);
+        toFree.byteAllocations.emplace_back(
+            cacheEntry->contiguousData_, cacheEntry->size_);
+        cacheEntry->contiguousData_ = nullptr;
+      } else {
+        pagesRemoved += cacheEntry->nonContiguousData().numPages();
+        toFree.nonContiguousAllocs.appendMove(cacheEntry->nonContiguousData());
+      }
       removeEntryLocked(cacheEntry.get());
       emptySlots_.push_back(entryIndex);
       tryAddFreeEntry(std::move(cacheEntry));
       cacheEntry = nullptr;
     }
   }
-  VELOX_CACHE_LOG(INFO) << "Removed " << toFree.size()
+  VELOX_CACHE_LOG(INFO) << "Removed " << numRemoved
                         << " AsyncDataCache entries.";
 
-  // Free the memory allocation out of the cache shard lock.
   ClockTimer t(allocClocks_);
-  freeAllocations(toFree);
+  toFree.free(cache_->allocator());
   cache_->incrementCachedPages(-pagesRemoved);
 
   return true;
@@ -658,17 +800,25 @@ CacheStats CacheStats::operator-(const CacheStats& other) const {
 AsyncDataCache::AsyncDataCache(
     memory::MemoryAllocator* allocator,
     std::unique_ptr<SsdCache> ssdCache)
-    : AsyncDataCache({}, allocator, std::move(ssdCache)){};
+    : AsyncDataCache({}, allocator, std::move(ssdCache)) {}
 
 AsyncDataCache::AsyncDataCache(
     const Options& options,
     memory::MemoryAllocator* allocator,
     std::unique_ptr<SsdCache> ssdCache)
     : opts_(options),
+      numShards_(opts_.numShards),
+      shardMask_(numShards_ - 1),
       allocator_(allocator),
       ssdCache_(std::move(ssdCache)),
       cachedPages_(0) {
-  for (auto i = 0; i < kNumShards; ++i) {
+  VELOX_CHECK_GT(numShards_, 0, "numShards must be positive");
+  VELOX_CHECK_EQ(
+      numShards_ & shardMask_,
+      0,
+      "numShards must be a power of 2, got {}",
+      numShards_);
+  for (auto i = 0; i < numShards_; ++i) {
     shards_.push_back(std::make_unique<CacheShard>(this, opts_.maxWriteRatio));
   }
 }
@@ -719,24 +869,37 @@ void CacheShard::shutdown() {
 CachePin AsyncDataCache::findOrCreate(
     RawFileCacheKey key,
     uint64_t size,
+    bool contiguous,
     folly::SemiFuture<bool>* wait) {
-  const int shard = std::hash<RawFileCacheKey>()(key) & (kShardMask);
-  return shards_[shard]->findOrCreate(key, size, wait);
+  const int shard = std::hash<RawFileCacheKey>()(key) & shardMask_;
+  return shards_[shard]->findOrCreate(key, size, contiguous, wait);
+}
+
+std::optional<CachePin> AsyncDataCache::find(
+    RawFileCacheKey key,
+    folly::SemiFuture<bool>* waitFuture) {
+  const int shard = std::hash<RawFileCacheKey>()(key) & shardMask_;
+  return shards_[shard]->find(key, waitFuture);
 }
 
 void AsyncDataCache::makeEvictable(RawFileCacheKey key) {
-  const int shard = std::hash<RawFileCacheKey>()(key) & (kShardMask);
+  const int shard = std::hash<RawFileCacheKey>()(key) & shardMask_;
   return shards_[shard]->makeEvictable(key);
 }
 
 bool AsyncDataCache::exists(RawFileCacheKey key) const {
-  int shard = std::hash<RawFileCacheKey>()(key) & (kShardMask);
+  const int shard = std::hash<RawFileCacheKey>()(key) & shardMask_;
   return shards_[shard]->exists(key);
 }
 
+bool AsyncDataCache::testingIsEvictable(RawFileCacheKey key) const {
+  const int shard = std::hash<RawFileCacheKey>()(key) & shardMask_;
+  return shards_[shard]->testingIsEvictable(key);
+}
+
 bool AsyncDataCache::makeSpace(
     MachinePageCount numPages,
-    std::function<bool(memory::Allocation& allocation)> allocate) {
+    std::function<bool(AcquiredMemory&)> allocate) {
   // Try to allocate and if failed, evict the desired amount and
   // retry. This is without synchronization, so that other threads may
   // get what one thread evicted but this will usually work in a
@@ -749,25 +912,25 @@ bool AsyncDataCache::makeSpace(
   // serialize with a mutex because memory arbitration must not be
   // called from inside a global mutex.
 
-  constexpr int32_t kMaxAttempts = kNumShards * 4;
+  const int32_t kMaxAttempts = numShards_ * 4;
   // Evict at least 1MB even for small allocations to avoid constantly hitting
   // the mutex protected evict loop.
   constexpr int32_t kMinEvictPages = 256;
   // If requesting less than kSmallSizePages try up to 4x more if
   // first try failed.
   constexpr int32_t kSmallSizePages = 2048; // 8MB
+  const auto requestBytes = memory::AllocationTraits::pageBytes(numPages);
   float sizeMultiplier = 1.2;
   // True if this thread is counted in 'numThreadsInAllocate_'.
   bool isCounted = false;
   // If more than half the allowed retries are needed, this is the rank in
   // arrival order of this.
   int32_t rank = 0;
-  // Allocation into which evicted pages are moved.
-  memory::Allocation acquired;
-  // 'acquired' is not managed by a pool. Make sure it is freed on throw.
-  // Destruct without pool and non-empty kills the process.
+  // Memory collected from evicted entries, freed by the allocate callback.
+  AcquiredMemory acquired;
   auto guard = folly::makeGuard([&]() {
-    allocator_->freeNonContiguous(acquired);
+    // Free on exception or early exit. Normal path frees inside allocate.
+    acquired.free(allocator_);
     if (isCounted) {
       --numThreadsInAllocate_;
     }
@@ -781,10 +944,12 @@ bool AsyncDataCache::makeSpace(
     isCounted = true;
   }
   for (auto nthAttempt = 0; nthAttempt < kMaxAttempts; ++nthAttempt) {
-    if (canTryAllocate(numPages, acquired)) {
+    if (canTryAllocate(requestBytes, acquired)) {
       if (allocate(acquired)) {
+        VELOX_CHECK(acquired.empty());
         return true;
       }
+      VELOX_CHECK(acquired.empty());
     }
 
     if (nthAttempt > 2 && ssdCache_ && ssdCache_->writeInProgress()) {
@@ -799,25 +964,26 @@ bool AsyncDataCache::makeSpace(
       }
     }
     if (rank) {
-      // Free the grabbed allocation before sleep so the contender can make
+      // Free the acquired memory before sleep so the contender can make
       // progress. This is only on heavy contention, after 8 missed tries.
-      allocator_->freeNonContiguous(acquired);
+      acquired.free(allocator_);
       backoff(nthAttempt + rank);
       // If some of the competing threads are done, maybe give this thread a
       // better rank.
       rank = std::min<int32_t>(rank, numThreadsInAllocate_);
     }
     ++shardCounter_;
-    int32_t numPagesToAcquire =
-        acquired.numPages() < numPages ? numPages - acquired.numPages() : 0;
+    const auto acquiredBytes = acquired.totalBytes();
+    const uint64_t bytesToAcquire =
+        acquiredBytes < requestBytes ? requestBytes - acquiredBytes : 0;
     // Evict from next shard. If we have gone through all shards once
     // and still have not made the allocation, we go to desperate mode
     // with 'evictAllUnpinned' set to true.
-    shards_[shardCounter_ & (kShardMask)]->evict(
+    shards_[shardCounter_ & shardMask_]->evict(
         memory::AllocationTraits::pageBytes(
             std::max<uint64_t>(kMinEvictPages, numPages) * sizeMultiplier),
-        nthAttempt >= kNumShards,
-        numPagesToAcquire,
+        nthAttempt >= numShards_,
+        bytesToAcquire,
         acquired);
     if (numPages < kSmallSizePages && sizeMultiplier < 4) {
       sizeMultiplier *= 2;
@@ -835,22 +1001,22 @@ uint64_t AsyncDataCache::shrink(uint64_t targetBytes) {
   LOG(INFO) << "Try to shrink cache to free up "
             << velox::succinctBytes(targetBytes) << "  memory";
 
-  const uint64_t minBytesToEvict = 8UL << 20;
   uint64_t evictedBytes{0};
   uint64_t shrinkTimeUs{0};
   {
     MicrosecondTimer timer(&shrinkTimeUs);
     for (int shard = 0; shard < shards_.size(); ++shard) {
-      memory::Allocation unused;
-      evictedBytes += shards_[shardCounter_++ & (kShardMask)]->evict(
-          std::max<uint64_t>(minBytesToEvict, targetBytes - evictedBytes),
+      AcquiredMemory acquired;
+      evictedBytes += shards_[shardCounter_++ & shardMask_]->evict(
+          std::max<uint64_t>(
+              CacheShard::kMinBytesToEvict, targetBytes - evictedBytes),
           // Cache shrink is triggered when server is under low memory pressure
           // so need to free up memory as soon as possible. So we always avoid
           // triggering ssd save to accelerate the cache evictions.
           true,
           0,
-          unused);
-      VELOX_CHECK(unused.empty());
+          acquired);
+      VELOX_CHECK(acquired.empty());
       if (evictedBytes >= targetBytes) {
         break;
       }
@@ -869,14 +1035,16 @@ uint64_t AsyncDataCache::shrink(uint64_t targetBytes) {
 }
 
 bool AsyncDataCache::canTryAllocate(
-    MachinePageCount numPages,
-    const memory::Allocation& acquired) const {
-  if (numPages <= acquired.numPages()) {
+    uint64_t requestBytes,
+    const AcquiredMemory& acquired) const {
+  const auto acquiredBytes = acquired.totalBytes();
+  if (requestBytes <= acquiredBytes) {
     return true;
   }
-  return numPages - acquired.numPages() <=
-      (memory::AllocationTraits::numPages(allocator_->capacity())) -
-      allocator_->numAllocated();
+  return requestBytes - acquiredBytes <=
+      memory::AllocationTraits::pageBytes(
+             memory::AllocationTraits::numPages(allocator_->capacity()) -
+             allocator_->numAllocated());
 }
 
 void AsyncDataCache::backoff(int32_t counter) {
@@ -909,11 +1077,15 @@ void AsyncDataCache::possibleSsdSave(uint64_t bytes) {
 
   ssdSaveable_ += bytes;
   if (memory::AllocationTraits::numPages(ssdSaveable_) >
-      std::max<int32_t>(
-          static_cast<int32_t>(
-              memory::AllocationTraits::numPages(opts_.minSsdSavableBytes)),
-          static_cast<int32_t>(
-              static_cast<double>(cachedPages_) * opts_.ssdSavableRatio))) {
+          std::max<int32_t>(
+              static_cast<int32_t>(
+                  memory::AllocationTraits::numPages(opts_.minSsdSavableBytes)),
+              static_cast<int32_t>(
+                  static_cast<double>(cachedPages_) * opts_.ssdSavableRatio)) ||
+      (opts_.ssdFlushThresholdBytes > 0 &&
+       memory::AllocationTraits::numPages(ssdSaveable_) >
+           static_cast<int32_t>(memory::AllocationTraits::numPages(
+               opts_.ssdFlushThresholdBytes)))) {
     // Do not start a new save if another one is in progress.
     if (!ssdCache_->startWrite()) {
       return;
@@ -925,7 +1097,7 @@ void AsyncDataCache::possibleSsdSave(uint64_t bytes) {
 void AsyncDataCache::saveToSsd(bool saveAll) {
   std::vector<CachePin> pins;
   VELOX_CHECK(ssdCache_->writeInProgress());
-  ssdSaveable_ = 0;
+  ssdSaveable_ = false;
   for (auto& shard : shards_) {
     shard->appendSsdSaveable(saveAll, pins);
   }
@@ -966,9 +1138,9 @@ CacheStats AsyncDataCache::refreshStats() const {
 
 void AsyncDataCache::clear() {
   for (auto& shard : shards_) {
-    memory::Allocation unused;
-    shard->evict(std::numeric_limits<uint64_t>::max(), true, 0, unused);
-    VELOX_CHECK(unused.empty());
+    AcquiredMemory acquired;
+    shard->evict(std::numeric_limits<uint64_t>::max(), true, 0, acquired);
+    VELOX_CHECK(acquired.empty());
   }
 }
 
@@ -1039,33 +1211,34 @@ CoalesceIoStats readPins(
       [&](int32_t index) { return pins[index].checkedEntry()->size(); },
       [&](int32_t index) {
         return std::max<int32_t>(
-            1, pins[index].checkedEntry()->data().numRuns());
+            1, pins[index].checkedEntry()->nonContiguousData().numRuns());
       },
       [&](const CachePin& pin, std::vector<folly::Range<char*>>& ranges) {
         auto* entry = pin.checkedEntry();
-        auto& data = entry->data();
+        const auto size = entry->size();
+        if (entry->hasContiguousData()) {
+          VELOX_CHECK_EQ(entry->contiguousDataSize(), size);
+          ranges.push_back(folly::Range<char*>(entry->contiguousData(), size));
+          return;
+        }
+        const auto& data = entry->nonContiguousData();
+        VELOX_CHECK_GT(data.numPages(), 0);
         uint64_t offsetInRuns = 0;
-        auto size = entry->size();
-        if (data.numPages() == 0) {
-          ranges.push_back(
-              folly::Range<char*>(pin.checkedEntry()->tinyData(), size));
-          offsetInRuns = size;
-        } else {
-          for (int i = 0; i < data.numRuns(); ++i) {
-            const auto run = data.runAt(i);
-            const uint64_t bytes = run.numBytes();
-            const uint64_t readSize = std::min(bytes, size - offsetInRuns);
-            ranges.push_back(folly::Range<char*>(run.data<char>(), readSize));
-            offsetInRuns += readSize;
-          }
+        for (int i = 0; i < data.numRuns(); ++i) {
+          const auto run = data.runAt(i);
+          const uint64_t readSize =
+              std::min<uint64_t>(run.numBytes(), size - offsetInRuns);
+          ranges.push_back(folly::Range<char*>(run.data<char>(), readSize));
+          offsetInRuns += readSize;
         }
         VELOX_CHECK_EQ(offsetInRuns, size);
       },
       [&](int32_t size, std::vector<folly::Range<char*>>& ranges) {
         // This hack allows us to store the size of the gap in the Range,
         // without actually allocating a buffer for it.
-        ranges.push_back(folly::Range<char*>(
-            nullptr, reinterpret_cast<char*>(static_cast<uint64_t>(size))));
+        ranges.push_back(
+            folly::Range<char*>(
+                nullptr, reinterpret_cast<char*>(static_cast<uint64_t>(size))));
       },
       std::move(readFunc));
 }
diff --git a/velox/common/caching/AsyncDataCache.h b/velox/common/caching/AsyncDataCache.h
index 605e95cd568..40d9a4b4ed1 100644
--- a/velox/common/caching/AsyncDataCache.h
+++ b/velox/common/caching/AsyncDataCache.h
@@ -44,6 +44,7 @@ namespace facebook::velox::cache {
 
 class AsyncDataCache;
 class CacheShard;
+struct CacheStats;
 class SsdCache;
 struct SsdCacheStats;
 class SsdFile;
@@ -160,27 +161,59 @@ class AsyncDataCacheEntry {
   explicit AsyncDataCacheEntry(CacheShard* shard);
   ~AsyncDataCacheEntry();
 
-  /// Sets the key and allocates the entry's memory.  Resets
-  ///  all other state. The entry must be held exclusively and must
-  ///  hold no memory when calling this.
-  void initialize(FileCacheKey key);
+  /// Sets the key and allocates the entry's memory. Resets all other state.
+  /// The entry must be held exclusively and must hold no memory when calling
+  /// this. If 'contiguous' is true, allocates a single contiguous region
+  /// instead of a potentially non-contiguous Allocation.
+  void initialize(FileCacheKey key, bool contiguous = false);
 
-  memory::Allocation& data() {
-    return data_;
+  memory::Allocation& nonContiguousData() {
+    return nonContiguousData_;
   }
 
-  const memory::Allocation& data() const {
-    return data_;
+  const memory::Allocation& nonContiguousData() const {
+    return nonContiguousData_;
   }
 
-  const char* tinyData() const {
-    return tinyData_.empty() ? nullptr : tinyData_.data();
+  /// Returns a pointer to contiguous data. Valid for entries created
+  /// with contiguous=true. Covers both tinyData_ (small) and
+  /// contiguousData_ (larger) paths. Throws if the entry has no
+  /// contiguous data.
+  char* contiguousData() {
+    if (!tinyData_.empty()) {
+      VELOX_CHECK_NULL(contiguousData_);
+      return tinyData_.data();
+    }
+    VELOX_CHECK_NOT_NULL(
+        contiguousData_, "Entry does not have contiguous data");
+    return static_cast<char*>(contiguousData_);
+  }
+
+  const char* contiguousData() const {
+    if (!tinyData_.empty()) {
+      VELOX_CHECK_NULL(contiguousData_);
+      return tinyData_.data();
+    }
+    VELOX_CHECK_NOT_NULL(
+        contiguousData_, "Entry does not have contiguous data");
+    return static_cast<const char*>(contiguousData_);
+  }
+
+  /// Returns true if this entry has contiguous data.
+  bool hasContiguousData() const {
+    return contiguousData_ != nullptr || !tinyData_.empty();
   }
 
-  char* tinyData() {
-    return tinyData_.empty() ? nullptr : tinyData_.data();
+  uint64_t contiguousDataSize() const {
+    return size_;
   }
 
+  // Returns writable buffer ranges covering the first 'length' bytes of
+  // this entry's data. For small entries (tinyData), returns a single range.
+  // For contiguous entries, returns a single range.
+  // For larger entries (allocation-backed), returns one range per run.
+  std::vector<folly::Range<char*>> dataRanges(size_t length);
+
   const FileCacheKey& key() const {
     return key_;
   }
@@ -193,6 +226,13 @@ class AsyncDataCacheEntry {
     return size_;
   }
 
+  /// Returns the allocated capacity in bytes for this entry's data,
+  /// including any padding from the allocator.
+  int64_t dataCapacity() const;
+
+  /// Updates the data-type-specific size and padding fields in 'stats'.
+  void updateDataStats(CacheStats& stats) const;
+
   void touch() {
     accessStats_.touch();
   }
@@ -263,11 +303,10 @@ class AsyncDataCacheEntry {
   /// Sets access stats so that this is immediately evictable.
   void makeEvictable();
 
-  /// Moves the promise out of 'this'. Used in order to handle the
-  /// promise within the lock of the cache shard, so not within private
-  /// methods of 'this'.
-  std::unique_ptr<folly::SharedPromise<bool>> movePromise() {
-    return std::move(promise_);
+  /// Returns true if this entry has been marked as immediately evictable
+  /// (lastUse == 0).
+  bool testingIsEvictable() const {
+    return accessStats_.lastUse == 0;
   }
 
   std::string toString() const;
@@ -276,9 +315,19 @@ class AsyncDataCacheEntry {
   void release();
   void addReference();
 
+  // Frees all data storage (non-contiguous, contiguous, and tiny) with
+  // cache page accounting and resets size to zero.
+  void freeData();
+
+  // Moves the promise out of 'this'. Must be called inside the mutex of
+  // 'shard_'.
+  std::unique_ptr<folly::SharedPromise<bool>> movePromiseLocked() {
+    return std::move(promise_);
+  }
+
   // Returns a future that will be realized when a caller can retry getting
   // 'this'. Must be called inside the mutex of 'shard_'.
-  folly::SemiFuture<bool> getFuture() {
+  folly::SemiFuture<bool> getFutureLocked() {
     if (promise_ == nullptr) {
       promise_ = std::make_unique<folly::SharedPromise<bool>>();
     }
@@ -290,8 +339,12 @@ class AsyncDataCacheEntry {
 
   CacheShard* const shard_;
 
-  // The data being cached.
-  memory::Allocation data_;
+  // The data being cached (non-contiguous page runs).
+  memory::Allocation nonContiguousData_;
+
+  // Contiguous bytes allocated via allocateBytes. Populated when the entry is
+  // created with contiguous=true and size >= kTinyDataSize.
+  void* contiguousData_{nullptr};
 
   // Contains the cached data if this is much smaller than a MemoryAllocator
   // page (kTinyDataSize).
@@ -308,7 +361,7 @@ class AsyncDataCacheEntry {
   // True if 'this' is speculatively loaded. This is reset on first hit. Allows
   // catching a situation where prefetched entries get evicted before they are
   // hit.
-  bool isPrefetch_{false};
+  tsan_atomic<bool> isPrefetch_{false};
 
   // Sets after first use of a prefetched entry. Cleared by
   // getAndClearFirstUseFlag(). Does not require synchronization since used for
@@ -457,6 +510,10 @@ class CoalescedLoad {
     return "<CoalescedLoad>";
   }
 
+  /// Returns true if this is a load from SSD cache, false if from remote
+  /// storage.
+  virtual bool isSsdLoad() const = 0;
+
  protected:
   // Makes entries for 'keys_' and loads their content. Elements of 'keys_' that
   // are already loaded or loading are expected to be left out. The returned
@@ -488,14 +545,18 @@ struct CacheStats {
 
   /// Total size in 'tinyData_'
   int64_t tinySize{0};
-  /// Total size in 'data_'
+  /// Total size in 'nonContiguousData_'
   int64_t largeSize{0};
   /// Unused capacity in 'tinyData_'.
   int64_t tinyPadding{0};
-  /// Unused capacity in 'data_'.
+  /// Unused capacity in 'nonContiguousData_'.
   int64_t largePadding{0};
   /// Total number of entries.
   int32_t numEntries{0};
+  /// Total number of tiny entries.
+  int32_t numTinyEntries{0};
+  /// Total number of large entries.
+  int32_t numLargeEntries{0};
   /// Number of entries that do not cache anything.
   int32_t numEmptyEntries{0};
   /// Number of entries pinned for shared access.
@@ -550,20 +611,35 @@ struct CacheStats {
   std::string toString() const;
 };
 
+using AcquiredMemory = memory::AcquiredMemory;
+
 /// Collection of cache entries whose key hashes to the same shard of
 /// the hash number space.  The cache population is divided into shards
 /// to decrease contention on the mutex for the key to entry mapping
 /// and other housekeeping.
 class CacheShard {
  public:
+  static constexpr uint64_t kMinBytesToEvict = 8UL << 20; // 8MB
+
   CacheShard(AsyncDataCache* cache, double maxWriteRatio)
       : cache_(cache), maxWriteRatio_(maxWriteRatio) {}
 
-  /// See AsyncDataCache::findOrCreate.
+  /// See AsyncDataCache::findOrCreate. If 'contiguous' is true, the
+  /// entry's data is allocated as a single contiguous region.
   CachePin findOrCreate(
       RawFileCacheKey key,
       uint64_t size,
-      folly::SemiFuture<bool>* readyFuture);
+      bool contiguous = false,
+      folly::SemiFuture<bool>* readyFuture = nullptr);
+
+  /// Finds a cache entry for 'key'. Returns a shared-mode pin if the entry
+  /// exists and is not exclusive. Returns an empty pin (inside optional) if
+  /// the entry is exclusive; if 'waitFuture' is not nullptr it is set to a
+  /// future realized when the entry is no longer exclusive. Returns
+  /// std::nullopt on miss. Does not create entries.
+  std::optional<CachePin> find(
+      RawFileCacheKey key,
+      folly::SemiFuture<bool>* waitFuture = nullptr);
 
   /// Marks the cache entry with given cache 'key' as immediate evictable.
   void makeEvictable(RawFileCacheKey key);
@@ -571,6 +647,8 @@ class CacheShard {
   /// Returns true if there is an entry for 'key'. Updates access time.
   bool exists(RawFileCacheKey key) const;
 
+  bool testingIsEvictable(RawFileCacheKey key) const;
+
   AsyncDataCache* cache() const {
     return cache_;
   }
@@ -586,15 +664,15 @@ class CacheShard {
   /// Removes 'bytesToFree' worth of entries or as many entries as are not
   /// pinned. This favors first removing older and less frequently used entries.
   /// If 'evictAllUnpinned' is true, anything that is not pinned is evicted at
-  /// first sight. This is for out of memory emergencies. If 'pagesToAcquire' is
-  /// set, up to this amount is added to 'allocation'. A smaller amount can be
-  /// added if not enough evictable data is found. The function returns the
-  /// total evicted bytes.
+  /// first sight. This is for out of memory emergencies. If
+  /// 'bytesToAcquire' is set, up to this amount of non-contiguous pages
+  /// is moved into 'acquired'. A smaller amount can be added if not enough
+  /// evictable data is found. The function returns the total evicted bytes.
   uint64_t evict(
       uint64_t bytesToFree,
       bool evictAllUnpinned,
-      memory::MachinePageCount pagesToAcquire,
-      memory::Allocation& acquiredAllocation);
+      uint64_t bytesToAcquire,
+      AcquiredMemory& acquired);
 
   /// Removes 'entry' from 'this'. Removes a possible promise from the entry
   /// inside the shard mutex and returns it so that it can be realized outside
@@ -629,8 +707,10 @@ class CacheShard {
  private:
   static constexpr uint32_t kMaxFreeEntries = 1 << 10;
   static constexpr int32_t kNoThreshold = std::numeric_limits<int32_t>::max();
+  static constexpr int32_t kMaxEvictionSamples = 10;
+  static constexpr int32_t kEvictionPercentile = 80;
 
-  void calibrateThreshold();
+  void calibrateThresholdLocked();
 
   void removeEntryLocked(AsyncDataCacheEntry* entry);
 
@@ -638,14 +718,35 @@ class CacheShard {
   //
   // TODO: consider to pass a size hint so as to select the a free entry which
   // already has the right amount of memory associated with it.
-  std::unique_ptr<AsyncDataCacheEntry> getFreeEntry();
+  std::unique_ptr<AsyncDataCacheEntry> getFreeEntryLocked();
 
-  CachePin initEntry(RawFileCacheKey key, AsyncDataCacheEntry* entry);
+  CachePin
+  initEntry(RawFileCacheKey key, bool contiguous, AsyncDataCacheEntry* entry);
 
-  void freeAllocations(std::vector<memory::Allocation>& allocations);
+  // Looks up 'key' in the cache under mutex_. 'size' is the minimum acceptable
+  // entry size: pass 0 from find() to accept any size, or the required size
+  // from findOrCreate() to trigger stale-entry eviction when too small.
+  // Returns std::nullopt on miss (or after evicting a stale entry),
+  // an empty CachePin if the entry is exclusive, or a shared CachePin on hit.
+  std::optional<CachePin> lookupLocked(
+      RawFileCacheKey key,
+      uint64_t size,
+      folly::SemiFuture<bool>* waitFuture);
 
   void tryAddFreeEntry(std::unique_ptr<AsyncDataCacheEntry>&& entry);
 
+  // Acquires or frees evicted data from 'entry', including tiny data
+  // cleanup. If 'bytesToAcquire' > 0, moves data into 'acquired' and
+  // decrements 'bytesToAcquire'; otherwise moves data into 'toFree'.
+  // Increments 'largeEvicted' and 'tinyEvicted' accordingly.
+  void acquireEvictedData(
+      AsyncDataCacheEntry* entry,
+      uint64_t& bytesToAcquire,
+      AcquiredMemory& acquired,
+      AcquiredMemory& toFree,
+      int64_t& largeEvicted,
+      int64_t& tinyEvicted);
+
   AsyncDataCache* const cache_;
   const double maxWriteRatio_;
 
@@ -696,14 +797,20 @@ class CacheShard {
 
 class AsyncDataCache : public memory::Cache {
  public:
+  static constexpr int32_t kDefaultNumShards = 4;
+
   struct Options {
     Options(
         double _maxWriteRatio = 0.7,
         double _ssdSavableRatio = 0.125,
-        int32_t _minSsdSavableBytes = 1 << 24)
+        int32_t _minSsdSavableBytes = 1 << 24,
+        int32_t _numShards = kDefaultNumShards,
+        uint64_t _ssdFlushThresholdBytes = 0)
         : maxWriteRatio(_maxWriteRatio),
           ssdSavableRatio(_ssdSavableRatio),
-          minSsdSavableBytes(_minSsdSavableBytes) {}
+          minSsdSavableBytes(_minSsdSavableBytes),
+          numShards(_numShards),
+          ssdFlushThresholdBytes(_ssdFlushThresholdBytes) {}
 
     /// The max ratio of the number of in-memory cache entries being written to
     /// SSD cache over the total number of cache entries. This is to control SSD
@@ -722,6 +829,16 @@ class AsyncDataCache : public memory::Cache {
     /// NOTE: we only write to SSD cache when both above conditions satisfy. The
     /// default is 16MB.
     int32_t minSsdSavableBytes;
+
+    /// The number of shards for the cache. The cache population is divided into
+    /// shards to decrease contention on the mutex for the key to entry mapping
+    /// and other housekeeping. Must be a power of 2.
+    int32_t numShards;
+
+    /// The maximum threshold in bytes for triggering SSD flush. When the
+    /// accumulated SSD-savable bytes exceed this value, a flush to SSD is
+    /// triggered. Set to 0 to disable this threshold (default).
+    uint64_t ssdFlushThresholdBytes;
   };
 
   AsyncDataCache(
@@ -757,7 +874,7 @@ class AsyncDataCache : public memory::Cache {
   /// for memory arbitration to work.
   bool makeSpace(
       memory::MachinePageCount numPages,
-      std::function<bool(memory::Allocation& allocation)> allocate) override;
+      std::function<bool(memory::AcquiredMemory&)> allocate) override;
 
   uint64_t shrink(uint64_t targetBytes) override;
 
@@ -767,18 +884,30 @@ class AsyncDataCache : public memory::Cache {
 
   /// Finds or creates a cache entry corresponding to 'key'. The entry
   /// is returned in 'pin'. If the entry is new, it is pinned in
-  /// exclusive mode and its 'data_' has uninitialized space for at
-  /// least 'size' bytes. If the entry is in cache and already filled,
-  /// the pin is in shared mode.  If the entry is in exclusive mode for
-  /// some other pin, the pin is empty. If 'waitFuture' is not nullptr
-  /// and the pin is exclusive on some other pin, this is set to a
-  /// future that is realized when the pin is no longer exclusive. When
-  /// the future is realized, the caller may retry findOrCreate().
-  /// runtime error with code kNoCacheSpace if there is no space to create the
-  /// new entry after evicting any unpinned content.
+  /// exclusive mode and its data has uninitialized space for at least
+  /// 'size' bytes. If 'contiguous' is true, the data is allocated as a
+  /// single contiguous region; otherwise it is allocated as potentially
+  /// non-contiguous page runs. If the entry is in cache and already
+  /// filled, the pin is in shared mode. If the entry is in exclusive
+  /// mode for some other pin, the pin is empty. If 'waitFuture' is not
+  /// nullptr and the pin is exclusive on some other pin, this is set to
+  /// a future that is realized when the pin is no longer exclusive.
+  /// When the future is realized, the caller may retry findOrCreate().
+  /// runtime error with code kNoCacheSpace if there is no space to
+  /// create the new entry after evicting any unpinned content.
   CachePin findOrCreate(
       RawFileCacheKey key,
       uint64_t size,
+      bool contiguous = false,
+      folly::SemiFuture<bool>* waitFuture = nullptr);
+
+  /// Finds a cache entry for 'key'. Returns a shared-mode pin if the entry
+  /// exists and is not exclusive. Returns an empty pin (inside optional) if
+  /// the entry is exclusive; if 'waitFuture' is not nullptr it is set to a
+  /// future realized when the entry is no longer exclusive. Returns
+  /// std::nullopt on miss.
+  std::optional<CachePin> find(
+      RawFileCacheKey key,
       folly::SemiFuture<bool>* waitFuture = nullptr);
 
   /// Marks the cache entry with given cache 'key' as immediate evictable.
@@ -787,6 +916,11 @@ class AsyncDataCache : public memory::Cache {
   /// Returns true if there is an entry for 'key'. Updates access time.
   bool exists(RawFileCacheKey key) const;
 
+  /// Returns true if the entry for 'key' exists and has been marked as
+  /// immediately evictable (lastUse == 0). Returns false if entry does not
+  /// exist or is not evictable. Does not update access stats.
+  bool testingIsEvictable(RawFileCacheKey key) const;
+
 #if defined(__has_feature)
 #if __has_feature(thread_sanitizer)
   __attribute__((__no_sanitize__("thread")))
@@ -794,16 +928,14 @@ class AsyncDataCache : public memory::Cache {
 #endif
   /// Returns snapshot of the aggregated stats from all shards and the stats of
   /// SSD cache if used.
-  virtual CacheStats
-  refreshStats() const;
+  virtual CacheStats refreshStats() const;
 
   /// If 'details' is true, returns the stats of the backing memory allocator
   /// and ssd cache. Otherwise, only returns the cache stats.
   std::string toString(bool details = true) const;
 
-  memory::MachinePageCount incrementCachedPages(int64_t pages) {
-    // The counter is unsigned and the increment is signed.
-    return cachedPages_.fetch_add(pages) + pages;
+  memory::MachinePageCount cachedPages() const {
+    return cachedPages_.load();
   }
 
   memory::MachinePageCount incrementPrefetchPages(int64_t pages) {
@@ -839,14 +971,16 @@ class AsyncDataCache : public memory::Cache {
   /// Looks up a pin for each in 'keys' and skips all loading or loaded pins.
   /// Calls processPin for each exclusive pin. processPin must move its argument
   /// if it wants to use it afterwards. sizeFunc(i) returns the size of the ith
-  /// item in 'keys'.
+  /// item in 'keys'. If 'contiguous' is true, new entries are allocated as
+  /// single contiguous regions instead of non-contiguous page runs.
   template <typename SizeFunc, typename ProcessPin>
   void makePins(
       const std::vector<RawFileCacheKey>& keys,
       const SizeFunc& sizeFunc,
-      const ProcessPin& processPin) {
+      const ProcessPin& processPin,
+      bool contiguous = false) {
     for (size_t i = 0; i < keys.size(); ++i) {
-      auto pin = findOrCreate(keys[i], sizeFunc(i), nullptr);
+      auto pin = findOrCreate(keys[i], sizeFunc(i), contiguous);
       if (pin.empty() || pin.checkedEntry()->isShared()) {
         continue;
       }
@@ -876,14 +1010,14 @@ class AsyncDataCache : public memory::Cache {
   void clear();
 
  private:
-  static constexpr int32_t kNumShards = 4; // Must be power of 2.
-  static constexpr int32_t kShardMask = kNumShards - 1;
+  // True if acquired bytes plus available allocator capacity is enough
+  // for 'requestBytes'.
+  bool canTryAllocate(uint64_t requestBytes, const AcquiredMemory& acquired)
+      const;
 
-  // True if 'acquired' has more pages than 'numPages' or allocator has space
-  // for numPages - acquired pages of more allocation.
-  bool canTryAllocate(
-      memory::MachinePageCount numPages,
-      const memory::Allocation& acquired) const;
+  memory::MachinePageCount incrementCachedPages(int64_t pages) {
+    return cachedPages_.fetch_add(pages) + pages;
+  }
 
   static AsyncDataCache** getInstancePtr();
 
@@ -891,6 +1025,10 @@ class AsyncDataCache : public memory::Cache {
   void backoff(int32_t counter);
 
   const Options opts_;
+  // Number of shards. Must be a power of 2.
+  const int32_t numShards_;
+  // Bitmask for efficient shard index calculation (numShards_ - 1).
+  const int32_t shardMask_;
   memory::MemoryAllocator* const allocator_;
   std::unique_ptr<SsdCache> ssdCache_;
   std::vector<std::unique_ptr<CacheShard>> shards_;
@@ -926,6 +1064,8 @@ class AsyncDataCache : public memory::Cache {
   // for setting staggered backoff. Mutexes are not allowed for this.
   std::atomic<int32_t> numThreadsInAllocate_{0};
 
+  friend class AsyncDataCacheEntry;
+  friend class CacheShard;
   friend class test::AsyncDataCacheTestHelper;
 };
 
diff --git a/velox/common/caching/CMakeLists.txt b/velox/common/caching/CMakeLists.txt
index bc09b5552c8..2829d2c798b 100644
--- a/velox/common/caching/CMakeLists.txt
+++ b/velox/common/caching/CMakeLists.txt
@@ -16,17 +16,31 @@ velox_add_library(
   velox_caching
   AsyncDataCache.cpp
   CacheTTLController.cpp
+  FileHandle.cpp
   FileIds.cpp
   ScanTracker.cpp
   SsdCache.cpp
   SsdFile.cpp
   SsdFileTracker.cpp
   StringIdMap.cpp
+  HEADERS
+  AsyncDataCache.h
+  CacheTTLController.h
+  FileGroupStats.h
+  FileHandle.h
+  FileIds.h
+  FileProperties.h
+  ScanTracker.h
+  SsdCache.h
+  SsdFile.h
+  SsdFileTracker.h
+  StringIdMap.h
 )
 velox_link_libraries(
   velox_caching
   PUBLIC
     velox_common_base
+    velox_common_config
     velox_exception
     velox_file
     velox_memory
@@ -40,3 +54,7 @@ velox_link_libraries(
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
 endif()
+
+velox_add_library(velox_simple_lru_cache INTERFACE HEADERS SimpleLRUCache.h)
+
+velox_add_library(velox_cached_factory INTERFACE HEADERS CachedFactory.h)
diff --git a/velox/common/caching/FileHandle.cpp b/velox/common/caching/FileHandle.cpp
new file mode 100644
index 00000000000..93190caad72
--- /dev/null
+++ b/velox/common/caching/FileHandle.cpp
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/caching/FileHandle.h"
+#include "velox/common/base/Counters.h"
+#include "velox/common/base/StatsReporter.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/common/time/Timer.h"
+
+#include <atomic>
+
+namespace facebook::velox {
+
+uint64_t FileHandleSizer::operator()(const FileHandle& fileHandle) {
+  // TODO: add to support variable file cache size support when the file system
+  // underneath supports.
+  return 1;
+}
+
+namespace {
+// The group tracking is at the level of the directory, i.e. Hive partition.
+std::string groupName(const std::string& filename) {
+  const char* slash = strrchr(filename.c_str(), '/');
+  return slash ? std::string(filename.data(), slash - filename.data())
+               : filename;
+}
+} // namespace
+
+std::unique_ptr<FileHandle> FileHandleGenerator::operator()(
+    const FileHandleKey& key,
+    const FileProperties* properties,
+    IoStats* stats) {
+  // We have seen cases where drivers are stuck when creating file handles.
+  // Adding a trace here to spot this more easily in future.
+  process::TraceContext trace("FileHandleGenerator::operator()");
+  uint64_t elapsedTimeUs{0};
+  std::unique_ptr<FileHandle> fileHandle;
+  {
+    MicrosecondTimer timer(&elapsedTimeUs);
+    fileHandle = std::make_unique<FileHandle>();
+    filesystems::FileOptions options;
+    options.stats = stats;
+    options.tokenProvider = key.tokenProvider;
+    if (properties) {
+      options.fileSize = properties->fileSize;
+      options.readRangeHint = properties->readRangeHint;
+      options.extraFileInfo = properties->extraFileInfo;
+      options.fileReadOps = properties->fileReadOps;
+    }
+    const auto& filename = key.filename;
+    fileHandle->file = filesystems::getFileSystem(filename, properties_)
+                           ->openFileForRead(filename, options);
+    fileHandle->uuid = StringIdLease(fileIds(), filename);
+    fileHandle->groupId = StringIdLease(fileIds(), groupName(filename));
+    VLOG(1) << "Generating file handle for: " << filename
+            << " uuid: " << fileHandle->uuid.id();
+  }
+  RECORD_HISTOGRAM_METRIC_VALUE(
+      kMetricHiveFileHandleGenerateLatencyMs, elapsedTimeUs / 1000);
+  return fileHandle;
+}
+
+} // namespace facebook::velox
diff --git a/velox/common/caching/FileHandle.h b/velox/common/caching/FileHandle.h
new file mode 100644
index 00000000000..71a00ff5db0
--- /dev/null
+++ b/velox/common/caching/FileHandle.h
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string_view>
+
+#include "velox/common/base/BitUtil.h"
+#include "velox/common/caching/CachedFactory.h"
+#include "velox/common/caching/FileIds.h"
+#include "velox/common/caching/FileProperties.h"
+#include "velox/common/config/Config.h"
+#include "velox/common/file/File.h"
+#include "velox/common/file/TokenProvider.h"
+
+namespace facebook::velox {
+
+/// fileReadOps keys for passing table identity (db and table name)
+/// through the file handle layer. Written by the connector (FileSplitReader)
+/// and read by storage implementations to build per-table access token keys.
+constexpr std::string_view kDbNameKey = "dbName";
+constexpr std::string_view kTableNameKey = "tableName";
+
+/// File pointer plus cache-friendly identifiers for downstream caching.
+struct FileHandle {
+  std::shared_ptr<ReadFile> file;
+
+  // Each time we make a new FileHandle we assign it a uuid and use that id as
+  // the identifier in downstream data caching structures. This saves a lot of
+  // memory compared to using the filename as the identifier.
+  StringIdLease uuid;
+
+  // Id for the group of files this belongs to, e.g. its
+  // directory. Used for coarse granularity access tracking, for
+  // example to decide placing on SSD.
+  StringIdLease groupId;
+};
+
+/// Estimates the memory usage of a FileHandle object.
+struct FileHandleSizer {
+  uint64_t operator()(const FileHandle& a);
+};
+
+struct FileHandleKey {
+  std::string filename;
+  std::shared_ptr<filesystems::TokenProvider> tokenProvider{nullptr};
+
+  bool operator==(const FileHandleKey& other) const {
+    if (filename != other.filename) {
+      return false;
+    }
+
+    if (tokenProvider == other.tokenProvider) {
+      return true;
+    }
+
+    if (!tokenProvider || !other.tokenProvider) {
+      return false;
+    }
+
+    return tokenProvider->equals(*other.tokenProvider);
+  }
+};
+
+} // namespace facebook::velox
+
+namespace std {
+template <>
+struct hash<facebook::velox::FileHandleKey> {
+  size_t operator()(const facebook::velox::FileHandleKey& key) const noexcept {
+    size_t filenameHash = std::hash<std::string>()(key.filename);
+    return key.tokenProvider ? facebook::velox::bits::hashMix(
+                                   filenameHash, key.tokenProvider->hash())
+                             : filenameHash;
+  }
+};
+} // namespace std
+
+namespace facebook::velox {
+using FileHandleCache =
+    SimpleLRUCache<facebook::velox::FileHandleKey, FileHandle>;
+
+/// Creates FileHandles via the Generator interface the CachedFactory requires.
+class FileHandleGenerator {
+ public:
+  FileHandleGenerator() {}
+  FileHandleGenerator(std::shared_ptr<const config::ConfigBase> properties)
+      : properties_(std::move(properties)) {}
+  std::unique_ptr<FileHandle> operator()(
+      const FileHandleKey& filename,
+      const FileProperties* properties,
+      IoStats* stats);
+
+ private:
+  const std::shared_ptr<const config::ConfigBase> properties_;
+};
+
+using FileHandleFactory = CachedFactory<
+    FileHandleKey,
+    FileHandle,
+    FileHandleGenerator,
+    FileProperties,
+    IoStats,
+    FileHandleSizer>;
+
+using FileHandleCachedPtr = CachedPtr<FileHandleKey, FileHandle>;
+
+using FileHandleCacheStats = SimpleLRUCacheStats;
+
+} // namespace facebook::velox
diff --git a/velox/common/caching/FileProperties.h b/velox/common/caching/FileProperties.h
new file mode 100644
index 00000000000..9827a7e71f9
--- /dev/null
+++ b/velox/common/caching/FileProperties.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <optional>
+
+#include <folly/container/F14Map.h>
+
+namespace facebook::velox {
+
+struct FileProperties {
+  std::optional<int64_t> fileSize;
+  std::optional<int64_t> modificationTime;
+  std::optional<int64_t> readRangeHint{std::nullopt};
+  std::shared_ptr<std::string> extraFileInfo{nullptr};
+  folly::F14FastMap<std::string, std::string> fileReadOps{};
+};
+
+} // namespace facebook::velox
diff --git a/velox/common/caching/SsdCache.cpp b/velox/common/caching/SsdCache.cpp
index 2347b45982f..50d32d6ba3e 100644
--- a/velox/common/caching/SsdCache.cpp
+++ b/velox/common/caching/SsdCache.cpp
@@ -32,7 +32,8 @@ SsdCache::SsdCache(const Config& config)
     : filePrefix_(config.filePrefix),
       numShards_(config.numShards),
       groupStats_(std::make_unique<FileGroupStats>()),
-      executor_(config.executor) {
+      executor_(config.executor),
+      maxEntries_(config.maxEntries) {
   // Make sure the given path of Ssd files has the prefix for local file system.
   // Local file system would be derived based on the prefix.
   VELOX_CHECK(
@@ -58,6 +59,9 @@ SsdCache::SsdCache(const Config& config)
   const uint64_t sizeQuantum = numShards_ * SsdFile::kRegionSize;
   const int32_t fileMaxRegions =
       bits::roundUp(config.maxBytes, sizeQuantum) / sizeQuantum;
+  // Distribute maxEntries across shards
+  const uint64_t maxEntriesPerShard =
+      maxEntries_ == 0 ? 0 : bits::divRoundUp(maxEntries_, numShards_);
   for (auto i = 0; i < numShards_; ++i) {
     const auto fileConfig = SsdFile::Config(
         fmt::format("{}{}", filePrefix_, i),
@@ -67,6 +71,7 @@ SsdCache::SsdCache(const Config& config)
         config.disableFileCow,
         config.checksumEnabled,
         checksumReadVerificationEnabled,
+        maxEntriesPerShard,
         executor_);
     files_.push_back(std::make_unique<SsdFile>(fileConfig));
   }
@@ -90,7 +95,8 @@ bool SsdCache::startWrite() {
 }
 
 void SsdCache::write(std::vector<CachePin> pins) {
-  VELOX_CHECK_EQ(numShards_, writesInProgress_);
+  VELOX_CHECK_EQ(
+      numShards_, writesInProgress_, "startWrite() have not been called");
 
   TestValue::adjust("facebook::velox::cache::SsdCache::write", this);
 
@@ -98,7 +104,7 @@ void SsdCache::write(std::vector<CachePin> pins) {
 
   uint64_t bytes = 0;
   std::vector<std::vector<CachePin>> shards(numShards_);
-  for (auto& pin : pins) {
+  for (const auto& pin : pins) {
     bytes += pin.checkedEntry()->size();
     const auto& target = file(pin.checkedEntry()->key().fileNum.id());
     shards[target.shardId()].push_back(std::move(pin));
@@ -135,9 +141,10 @@ void SsdCache::write(std::vector<CachePin> pins) {
         // Typically occurs every few GB. Allows detecting unusually slow rates
         // from failing devices.
         VELOX_SSD_CACHE_LOG(INFO) << fmt::format(
-            "Wrote {}, {} bytes/s",
+            "Wrote {} to SSD, {} bytes/s",
             succinctBytes(bytes),
-            static_cast<float>(bytes) / (getCurrentTimeMicro() - startTimeUs));
+            static_cast<double>(bytes) * 1'000'000 /
+                (getCurrentTimeMicro() - startTimeUs));
       }
     });
   }
@@ -191,7 +198,11 @@ std::string SsdCache::toString() const {
   out << "Ssd cache IO: Write " << succinctBytes(data.bytesWritten) << " read "
       << succinctBytes(data.bytesRead) << " Size " << succinctBytes(capacity)
       << " Occupied " << succinctBytes(data.bytesCached);
-  out << " " << (data.entriesCached >> 10) << "K entries.";
+  out << " " << (data.entriesCached >> 10) << "K entries";
+  if (maxEntries_ > 0) {
+    out << " (max " << (maxEntries_ >> 10) << "K)";
+  }
+  out << ".";
   out << "\nGroupStats: " << groupStats_->toString(capacity);
   return out.str();
 }
@@ -207,7 +218,7 @@ void SsdCache::shutdown() {
 
   VELOX_SSD_CACHE_LOG(INFO) << "SSD cache is shutting down";
   while (writesInProgress_) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // NOLINT
+    std::this_thread::sleep_for(kWriteWaitMs);
   }
   for (auto& file : files_) {
     file->checkpoint(true);
@@ -223,7 +234,7 @@ void SsdCache::clear() {
 
 void SsdCache::waitForWriteToFinish() {
   while (writesInProgress_ != 0) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // NOLINT
+    std::this_thread::sleep_for(kWriteWaitMs);
   }
 }
 
diff --git a/velox/common/caching/SsdCache.h b/velox/common/caching/SsdCache.h
index e4670594948..2ec837958c1 100644
--- a/velox/common/caching/SsdCache.h
+++ b/velox/common/caching/SsdCache.h
@@ -23,6 +23,8 @@ namespace facebook::velox::cache {
 #define VELOX_SSD_CACHE_LOG_PREFIX "[SSDCA] "
 #define VELOX_SSD_CACHE_LOG(severity) \
   LOG(severity) << VELOX_SSD_CACHE_LOG_PREFIX
+#define VELOX_SSD_CACHE_LOG_EVERY_MS(severity, ms) \
+  FB_LOG_EVERY_MS(severity, ms) << VELOX_SSD_CACHE_LOG_PREFIX
 
 namespace test {
 class SsdCacheTestHelper;
@@ -41,7 +43,8 @@ class SsdCache {
         uint64_t _checkpointIntervalBytes = 0,
         bool _disableFileCow = false,
         bool _checksumEnabled = false,
-        bool _checksumReadVerificationEnabled = false)
+        bool _checksumReadVerificationEnabled = false,
+        uint64_t _maxEntries = 0)
         : filePrefix(_filePrefix),
           maxBytes(_maxBytes),
           numShards(_numShards),
@@ -49,7 +52,8 @@ class SsdCache {
           disableFileCow(_disableFileCow),
           checksumEnabled(_checksumEnabled),
           checksumReadVerificationEnabled(_checksumReadVerificationEnabled),
-          executor(_executor){};
+          executor(_executor),
+          maxEntries(_maxEntries) {}
 
     std::string filePrefix;
     uint64_t maxBytes;
@@ -71,6 +75,10 @@ class SsdCache {
     /// Executor for async fsync in checkpoint.
     folly::Executor* executor;
 
+    /// Maximum number of SSD cache entries allowed. A value of 0 means no
+    /// limit. When the limit is reached, new entry writes will be skipped.
+    uint64_t maxEntries;
+
     std::string toString() const {
       return fmt::format(
           "{} shards, capacity {}, checkpoint size {}, file cow {}, checksum {}, read verification {}",
@@ -169,6 +177,9 @@ class SsdCache {
   void waitForWriteToFinish();
 
  private:
+  // Polling interval for waiting on write completion
+  static constexpr auto kWriteWaitMs = std::chrono::milliseconds(100);
+
   void checkNotShutdownLocked() {
     VELOX_CHECK(
         !shutdown_, "Unexpected write after SSD cache has been shutdown");
@@ -179,6 +190,9 @@ class SsdCache {
   // Stats for selecting entries to save from AsyncDataCache.
   const std::unique_ptr<FileGroupStats> groupStats_;
   folly::Executor* const executor_;
+  // Maximum number of SSD cache entries allowed. 0 means no limit.
+  const uint64_t maxEntries_;
+
   mutable std::mutex mutex_;
 
   std::vector<std::unique_ptr<SsdFile>> files_;
diff --git a/velox/common/caching/SsdFile.cpp b/velox/common/caching/SsdFile.cpp
index fa5c46f22da..0044b152e37 100644
--- a/velox/common/caching/SsdFile.cpp
+++ b/velox/common/caching/SsdFile.cpp
@@ -42,11 +42,12 @@ namespace facebook::velox::cache {
 namespace {
 
 void addEntryToIovecs(AsyncDataCacheEntry& entry, std::vector<iovec>& iovecs) {
-  if (entry.tinyData() != nullptr) {
-    iovecs.push_back({entry.tinyData(), static_cast<size_t>(entry.size())});
+  if (entry.hasContiguousData()) {
+    iovecs.push_back(
+        {entry.contiguousData(), static_cast<size_t>(entry.size())});
     return;
   }
-  const auto& data = entry.data();
+  const auto& data = entry.nonContiguousData();
   iovecs.reserve(iovecs.size() + data.numRuns());
   int64_t bytesLeft = entry.size();
   for (auto i = 0; i < data.numRuns(); ++i) {
@@ -60,12 +61,11 @@ void addEntryToIovecs(AsyncDataCacheEntry& entry, std::vector<iovec>& iovecs) {
   }
 }
 
-// Returns the number of entries in a cache 'entry'.
 uint32_t numIoVectorsFromEntry(AsyncDataCacheEntry& entry) {
-  if (entry.tinyData() != nullptr) {
+  if (entry.hasContiguousData()) {
     return 1;
   }
-  return entry.data().numRuns();
+  return entry.nonContiguousData().numRuns();
 }
 } // namespace
 
@@ -112,9 +112,10 @@ SsdFile::SsdFile(const Config& config)
       checksumReadVerificationEnabled_(
           config.checksumEnabled && config.checksumReadVerificationEnabled),
       shardId_(config.shardId),
+      maxEntries_(config.maxEntries),
+      executor_(config.executor),
       fs_(filesystems::getFileSystem(fileName_, nullptr)),
-      checkpointIntervalBytes_(config.checkpointIntervalBytes),
-      executor_(config.executor) {
+      checkpointIntervalBytes_(config.checkpointIntervalBytes) {
   process::TraceContext trace("SsdFile::SsdFile");
   filesystems::FileOptions fileOptions;
   fileOptions.shouldThrowOnFileAlreadyExists = false;
@@ -137,6 +138,8 @@ SsdFile::SsdFile(const Config& config)
   regionPins_.resize(maxRegions_, 0);
   if (checkpointEnabled()) {
     initializeCheckpoint();
+  } else {
+    removeStaleRecoveryFiles();
   }
 
   if (disableFileCow_) {
@@ -231,6 +234,9 @@ CoalesceIoStats SsdFile::load(
         read(offset, buffers);
       });
 
+  common::testutil::TestValue::adjust(
+      "facebook::velox::cache::SsdFile::load", this);
+
   for (auto i = 0; i < ssdPins.size(); ++i) {
     pins[i].checkedEntry()->setSsdFile(this, ssdPins[i].run().offset());
     auto* entry = pins[i].checkedEntry();
@@ -307,8 +313,19 @@ bool SsdFile::growOrEvictLocked() {
     }
   }
 
-  auto candidates =
-      tracker_.findEvictionCandidates(3, numRegions_, regionPins_);
+  // If SSD is in no space state and future eviction logging cannot go through,
+  // skip eviction, to avoid data inconsistency for checkpointing. Eviction log
+  // is up to date. Separately when SSD is in no space state,
+  // growOrEvictLocked() would not be invoked by write() in the first place.
+  if (state_.load() == State::kNoSpace) {
+    VELOX_SSD_CACHE_LOG_EVERY_MS(WARNING, 1'000)
+        << "Failed to grow cache file " << fileName_
+        << " due to SSD in no space state.";
+    return false;
+  }
+
+  auto candidates = tracker_.findEvictionCandidates(
+      kNumEvictionCandidates, numRegions_, regionPins_);
   if (candidates.empty()) {
     suspended_ = true;
     return false;
@@ -345,6 +362,23 @@ void SsdFile::clearRegionEntriesLocked(const std::vector<int32_t>& regions) {
 
 void SsdFile::write(std::vector<CachePin>& pins) {
   process::TraceContext trace("SsdFile::write");
+
+  if (state_.load() == State::kNoSpace) {
+    ++stats_.writeSsdDropped;
+    VELOX_SSD_CACHE_LOG_EVERY_MS(WARNING, 10'000)
+        << "SSD file write is dropped in no space state.";
+    return;
+  }
+
+  // Check entry count limit before writing
+  if (maxEntries_ > 0) {
+    std::shared_lock<std::shared_mutex> l(mutex_);
+    if (entries_.size() + pins.size() >= maxEntries_) {
+      ++stats_.writeSsdExceedEntryLimit;
+      return;
+    }
+  }
+
   // Sorts the pins by their file/offset. In this way what is adjacent in
   // storage is likely adjacent on SSD.
   std::sort(pins.begin(), pins.end());
@@ -438,16 +472,29 @@ bool SsdFile::write(
     int64_t offset,
     int64_t length,
     const std::vector<iovec>& iovecs) {
+  VELOX_DCHECK_NE(state_.load(), State::kNoSpace);
+
   try {
     writeFile_->write(iovecs, offset, length);
     return true;
   } catch (const std::exception&) {
+    const int err = errno;
     VELOX_SSD_CACHE_LOG(ERROR)
         << "Failed to write to SSD, file name: " << fileName_
         << ", size: " << iovecs.size() << ", offset: " << offset
-        << ", error code: " << errno
-        << ", error string: " << folly::errnoStr(errno);
+        << ", error code: " << err
+        << ", error string: " << folly::errnoStr(err);
     ++stats_.writeSsdErrors;
+
+    if (err == ENOSPC) {
+      if (state_.exchange(State::kNoSpace) != State::kNoSpace) {
+        VELOX_SSD_CACHE_LOG(WARNING)
+            << "State of cache file " << fileName_ << " transits to "
+            << stateString(State::kNoSpace);
+      }
+      ++stats_.writeSsdNoSpaceErrors;
+    }
+
     return false;
   }
 }
@@ -469,12 +516,12 @@ void SsdFile::verifyWrite(AsyncDataCacheEntry& entry, SsdRun ssdRun) {
   const auto rc =
       readFile_->pread(ssdRun.offset(), entry.size(), testData.get());
   VELOX_CHECK_EQ(rc.size(), entry.size());
-  if (entry.tinyData() != nullptr) {
-    if (::memcmp(testData.get(), entry.tinyData(), entry.size()) != 0) {
+  if (entry.hasContiguousData()) {
+    if (::memcmp(testData.get(), entry.contiguousData(), entry.size()) != 0) {
       VELOX_FAIL("bad read back");
     }
   } else {
-    const auto& data = entry.data();
+    const auto& data = entry.nonContiguousData();
     int64_t bytesLeft = entry.size();
     int64_t offset = 0;
     for (auto i = 0; i < data.numRuns(); ++i) {
@@ -520,6 +567,9 @@ void SsdFile::updateStats(SsdCacheStats& stats) const {
   stats.deleteMetaFileErrors += stats_.deleteMetaFileErrors;
   stats.growFileErrors += stats_.growFileErrors;
   stats.writeSsdErrors += stats_.writeSsdErrors;
+  stats.writeSsdNoSpaceErrors += stats_.writeSsdNoSpaceErrors;
+  stats.writeSsdDropped += stats_.writeSsdDropped;
+  stats.writeSsdExceedEntryLimit += stats_.writeSsdExceedEntryLimit;
   stats.writeCheckpointErrors += stats_.writeCheckpointErrors;
   stats.readSsdErrors += stats_.readSsdErrors;
   stats.readCheckpointErrors += stats_.readCheckpointErrors;
@@ -668,6 +718,28 @@ void SsdFile::deleteFile(std::unique_ptr<WriteFile> file) {
   }
 }
 
+void SsdFile::removeStaleRecoveryFiles() {
+  const auto checkpointPath = checkpointFilePath();
+  if (fs_->exists(checkpointPath)) {
+    try {
+      fs_->remove(checkpointPath);
+    } catch (const std::exception& e) {
+      VELOX_SSD_CACHE_LOG(WARNING) << "Failed to remove stale checkpoint file "
+                                   << checkpointPath << ": " << e.what();
+    }
+  }
+  const auto logPath = evictLogFilePath();
+  if (fs_->exists(logPath)) {
+    try {
+      fs_->remove(logPath);
+    } catch (const std::exception& e) {
+      VELOX_SSD_CACHE_LOG(WARNING)
+          << "Failed to remove stale eviction log file " << logPath << ": "
+          << e.what();
+    }
+  }
+}
+
 void SsdFile::checkpointError(int32_t rc, const std::string& error) {
   VELOX_SSD_CACHE_LOG(ERROR)
       << error << " with rc=" << rc
@@ -711,9 +783,10 @@ void SsdFile::maybeFlushCheckpointBuffer(uint32_t appendBytes, bool force) {
       (force ||
        checkpointBufferedDataSize_ + appendBytes >= kCheckpointBufferSize)) {
     VELOX_CHECK_NOT_NULL(checkpointBuffer_);
-    checkpointWriteFile_->append(std::string_view(
-        static_cast<const char*>(checkpointBuffer_),
-        checkpointBufferedDataSize_));
+    checkpointWriteFile_->append(
+        std::string_view(
+            static_cast<const char*>(checkpointBuffer_),
+            checkpointBufferedDataSize_));
     checkpointBufferedDataSize_ = 0;
   }
 }
@@ -830,6 +903,23 @@ void SsdFile::checkpoint(bool force) {
   }
 }
 
+// static
+std::string SsdFile::stateString(State state) {
+  switch (state) {
+    case State::kActive:
+      return "Active";
+    case State::kNoSpace:
+      return "NoSpace";
+    default:
+      return fmt::format("UNKNOWN: {}", static_cast<uint8_t>(state));
+  }
+}
+
+std::ostream& operator<<(std::ostream& out, const SsdFile::State& state) {
+  out << SsdFile::stateString(state);
+  return out;
+}
+
 void SsdFile::initializeCheckpoint() {
   if (!checkpointEnabled()) {
     return;
@@ -875,11 +965,11 @@ void SsdFile::initializeCheckpoint() {
 
 uint32_t SsdFile::checksumEntry(const AsyncDataCacheEntry& entry) const {
   bits::Crc32 crc;
-  if (entry.tinyData()) {
-    crc.process_bytes(entry.tinyData(), entry.size());
+  if (entry.hasContiguousData()) {
+    crc.process_bytes(entry.contiguousData(), entry.size());
   } else {
     int64_t bytesLeft = entry.size();
-    const auto& data = entry.data();
+    const auto& data = entry.nonContiguousData();
     for (auto i = 0; i < data.numRuns() && bytesLeft > 0; ++i) {
       const auto run = data.runAt(i);
       const auto bytesToProcess = std::min<size_t>(bytesLeft, run.numBytes());
@@ -964,7 +1054,7 @@ void SsdFile::readCheckpoint() {
     auto checkpointReadFile = fs_->openFileForRead(checkpointPath);
     stream = std::make_unique<common::FileInputStream>(
         std::move(checkpointReadFile),
-        1 << 20,
+        kCheckpointReadBufferSize,
         memory::memoryManager()->cachePool());
   } catch (std::exception& e) {
     ++stats_.openCheckpointErrors;
diff --git a/velox/common/caching/SsdFile.h b/velox/common/caching/SsdFile.h
index c9ab1f5b301..e729d836527 100644
--- a/velox/common/caching/SsdFile.h
+++ b/velox/common/caching/SsdFile.h
@@ -32,16 +32,18 @@ class SsdFileTestHelper;
 class SsdCacheTestHelper;
 } // namespace test
 
-/// A 64 bit word describing a SSD cache entry in an SsdFile. The low 23 bits
-/// are the size, for a maximum entry size of 8MB. The high bits are the offset.
+/// The 'fileBits_' field is a 64 bit word describing a SSD cache entry in an
+/// SsdFile. The low 23 bits are the size, for a maximum entry size of 8MB. The
+/// high 41 bits are the offset. The 'checksum_' field is optional and is used
+/// only when the checksum feature is enabled, otherwise, its value is always 0.
 class SsdRun {
  public:
   static constexpr int32_t kSizeBits = 23;
 
-  SsdRun() : fileBits_(0) {}
+  SsdRun() = default;
 
   SsdRun(uint64_t offset, uint32_t size, uint32_t checksum)
-      : fileBits_((offset << kSizeBits) | ((size - 1))), checksum_(checksum) {
+      : fileBits_((offset << kSizeBits) | (size - 1)), checksum_(checksum) {
     VELOX_CHECK_LT(offset, 1L << (64 - kSizeBits));
     VELOX_CHECK_NE(size, 0);
     VELOX_CHECK_LE(size, 1 << kSizeBits);
@@ -58,9 +60,11 @@ class SsdRun {
     checksum_ = other.checksum_;
   }
 
-  void operator=(SsdRun&& other) {
+  void operator=(SsdRun&& other) noexcept {
     fileBits_ = other.fileBits_;
     checksum_ = other.checksum_;
+    other.fileBits_ = 0;
+    other.checksum_ = 0;
   }
 
   uint64_t offset() const {
@@ -83,8 +87,8 @@ class SsdRun {
 
  private:
   // Contains the file offset and size.
-  uint64_t fileBits_;
-  uint32_t checksum_;
+  uint64_t fileBits_{0};
+  uint32_t checksum_{0};
 };
 
 /// Represents an SsdFile entry that is planned for load or being loaded. This
@@ -164,7 +168,9 @@ struct SsdCacheStats {
     deleteMetaFileErrors = tsanAtomicValue(other.deleteMetaFileErrors);
     growFileErrors = tsanAtomicValue(other.growFileErrors);
     writeSsdErrors = tsanAtomicValue(other.writeSsdErrors);
+    writeSsdNoSpaceErrors = tsanAtomicValue(other.writeSsdNoSpaceErrors);
     writeSsdDropped = tsanAtomicValue(other.writeSsdDropped);
+    writeSsdExceedEntryLimit = tsanAtomicValue(other.writeSsdExceedEntryLimit);
     writeCheckpointErrors = tsanAtomicValue(other.writeCheckpointErrors);
     readSsdErrors = tsanAtomicValue(other.readSsdErrors);
     readCheckpointErrors = tsanAtomicValue(other.readCheckpointErrors);
@@ -193,7 +199,11 @@ struct SsdCacheStats {
         deleteMetaFileErrors - other.deleteMetaFileErrors;
     result.growFileErrors = growFileErrors - other.growFileErrors;
     result.writeSsdErrors = writeSsdErrors - other.writeSsdErrors;
+    result.writeSsdNoSpaceErrors =
+        writeSsdNoSpaceErrors - other.writeSsdNoSpaceErrors;
     result.writeSsdDropped = writeSsdDropped - other.writeSsdDropped;
+    result.writeSsdExceedEntryLimit =
+        writeSsdExceedEntryLimit - other.writeSsdExceedEntryLimit;
     result.writeCheckpointErrors =
         writeCheckpointErrors - other.writeCheckpointErrors;
     result.readSsdCorruptions = readSsdCorruptions - other.readSsdCorruptions;
@@ -232,7 +242,9 @@ struct SsdCacheStats {
   tsan_atomic<uint32_t> deleteMetaFileErrors{0};
   tsan_atomic<uint32_t> growFileErrors{0};
   tsan_atomic<uint32_t> writeSsdErrors{0};
+  tsan_atomic<uint32_t> writeSsdNoSpaceErrors{0};
   tsan_atomic<uint32_t> writeSsdDropped{0};
+  tsan_atomic<uint32_t> writeSsdExceedEntryLimit{0};
   tsan_atomic<uint32_t> writeCheckpointErrors{0};
   tsan_atomic<uint32_t> readSsdErrors{0};
   tsan_atomic<uint32_t> readCheckpointErrors{0};
@@ -257,6 +269,7 @@ class SsdFile {
         bool _disableFileCow = false,
         bool _checksumEnabled = false,
         bool _checksumReadVerificationEnabled = false,
+        uint64_t _maxEntries = 0,
         folly::Executor* _executor = nullptr)
         : fileName(_fileName),
           shardId(_shardId),
@@ -266,7 +279,8 @@ class SsdFile {
           checksumEnabled(_checksumEnabled),
           checksumReadVerificationEnabled(
               _checksumEnabled && _checksumReadVerificationEnabled),
-          executor(_executor){};
+          maxEntries(_maxEntries),
+          executor(_executor) {}
 
     /// Name of cache file, used as prefix for checkpoint files.
     const std::string fileName;
@@ -279,19 +293,28 @@ class SsdFile {
 
     /// Checkpoint after every 'checkpointIntervalBytes' written into this
     /// file. 0 means no checkpointing. This is set to 0 if checkpointing fails.
-    uint64_t checkpointIntervalBytes;
+    const uint64_t checkpointIntervalBytes;
 
     /// True if copy on write should be disabled.
-    bool disableFileCow;
+    const bool disableFileCow;
 
     /// If true, checksum write to SSD is enabled.
-    bool checksumEnabled;
+    const bool checksumEnabled;
 
     /// If true, checksum read verification from SSD is enabled.
-    bool checksumReadVerificationEnabled;
+    const bool checksumReadVerificationEnabled;
+
+    /// Maximum number of SSD cache entries allowed. A value of 0 means no
+    /// limit. When the limit is reached, new entry writes will be skipped.
+    const uint64_t maxEntries;
 
     /// Executor for async fsync in checkpoint.
-    folly::Executor* executor;
+    folly::Executor* const executor;
+  };
+
+  enum class State : uint8_t {
+    kActive,
+    kNoSpace,
   };
 
   static constexpr uint64_t kRegionSize = 1 << 26; // 64MB
@@ -300,6 +323,9 @@ class SsdFile {
   /// filename.
   SsdFile(const Config& config);
 
+  /// Convert State to std::string.
+  static std::string stateString(State state);
+
   /// Adds entries of 'pins' to this file. 'pins' must be in read mode and
   /// those pins that are successfully added to SSD are marked as being on SSD.
   /// The file of the entries must be a file that is backed by 'this'.
@@ -310,6 +336,7 @@ class SsdFile {
 
   /// Erases 'key'
   bool erase(RawFileCacheKey key);
+
   /// Copies the data in 'ssdPins' into 'pins'. Coalesces IO for nearby
   /// entries if they are in ascending order and near enough.
   CoalesceIoStats load(
@@ -386,8 +413,19 @@ class SsdFile {
   // Magic number at end of completed checkpoint file.
   static constexpr int64_t kCheckpointEndMarker = 0xcbedf11e;
 
+  // Maximum percentage of erased entries in a region before it becomes
+  // eligible for clearing and reuse. When more than 50% of a region's
+  // entries have been erased (e.g., via TTL eviction), the region can be
+  // cleared and added back to the writable regions pool.
   static constexpr int kMaxErasedSizePct = 50;
 
+  // Number of eviction candidates to consider when selecting regions to
+  // evict.
+  static constexpr int32_t kNumEvictionCandidates = 3;
+
+  // Buffer size for reading checkpoint files during recovery.
+  static constexpr int32_t kCheckpointReadBufferSize = 1 << 20; // 1MB
+
   // Updates the read count of a region.
   void regionRead(int32_t region, int32_t size) {
     tracker_.regionRead(region, size);
@@ -473,6 +511,10 @@ class SsdFile {
     if (!checkpointEnabled()) {
       return false;
     }
+    // Once no SSD space, skip the subsequent checkpointing.
+    if (state_.load() == State::kNoSpace) {
+      return false;
+    }
     return force || (bytesAfterCheckpoint_ >= checkpointIntervalBytes_);
   }
 
@@ -490,6 +532,22 @@ class SsdFile {
   // Deletes the given file if it exists.
   void deleteFile(std::unique_ptr<WriteFile> file);
 
+  // Removes the checkpoint and eviction-log files left behind by a previous
+  // SsdFile instance using this same data file. Called from the constructor
+  // when this instance has checkpointing disabled.
+  //
+  // The checkpoint and log together describe which logical keys live at
+  // which offsets in the data file; recovery on startup reads them to
+  // rebuild 'entries_'. They are trustworthy only while every write to the
+  // data file also keeps them up to date. With checkpointing off this
+  // instance writes into the existing data file but never touches the
+  // meta files, so a later instance with checkpointing re-enabled would
+  // recover from a stale checkpoint pointing at overwritten regions and
+  // silently return wrong bytes. Removing them here keeps the on-disk
+  // state to either {data + matching checkpoint} or {data alone}; the
+  // {data + stale checkpoint} state becomes unreachable.
+  void removeStaleRecoveryFiles();
+
   // Allocates 'kCheckpointBufferSize' buffer from cache memory pool for
   // checkpointing.
   void allocateCheckpointBuffer();
@@ -548,6 +606,12 @@ class SsdFile {
   // Shard index within 'cache_'.
   const int32_t shardId_;
 
+  // Maximum number of SSD cache entries allowed in this file. 0 means no limit.
+  const uint64_t maxEntries_;
+
+  // Executor for async fsync in checkpoint.
+  folly::Executor* const executor_;
+
   // Serializes access to all private data members.
   mutable std::shared_mutex mutex_;
 
@@ -578,6 +642,8 @@ class SsdFile {
   // Map of file number and offset to location in file.
   folly::F14FastMap<FileCacheKey, SsdRun> entries_;
 
+  std::atomic<State> state_{State::kActive};
+
   // File system.
   std::shared_ptr<filesystems::FileSystem> fs_;
 
@@ -603,9 +669,6 @@ class SsdFile {
   // means no checkpointing. This is set to 0 if checkpointing fails.
   int64_t checkpointIntervalBytes_{0};
 
-  // Executor for async fsync in checkpoint.
-  folly::Executor* executor_;
-
   // Count of bytes written after last checkpoint.
   std::atomic<uint64_t> bytesAfterCheckpoint_{0};
 
@@ -622,4 +685,16 @@ class SsdFile {
   friend class test::SsdCacheTestHelper;
 };
 
+std::ostream& operator<<(std::ostream& out, const SsdFile::State& state);
+
 } // namespace facebook::velox::cache
+
+template <>
+struct fmt::formatter<facebook::velox::cache::SsdFile::State>
+    : formatter<std::string> {
+  auto format(facebook::velox::cache::SsdFile::State state, format_context& ctx)
+      const {
+    return formatter<std::string>::format(
+        facebook::velox::cache::SsdFile::stateString(state), ctx);
+  }
+};
diff --git a/velox/common/caching/SsdFileTracker.h b/velox/common/caching/SsdFileTracker.h
index 5ab825f50b8..e9eed9720dc 100644
--- a/velox/common/caching/SsdFileTracker.h
+++ b/velox/common/caching/SsdFileTracker.h
@@ -30,7 +30,12 @@ namespace facebook::velox::cache {
 class SsdFileTracker {
  public:
   void resize(int32_t numRegions) {
-    resizeTsanAtomic(regionScores_, numRegions);
+    std::vector<tsan_atomic<double>> newScores(numRegions);
+    auto numCopy = std::min<int32_t>(numRegions, regionScores_.size());
+    for (auto i = 0; i < numCopy; ++i) {
+      newScores[i] = tsanAtomicValue(regionScores_[i]);
+    }
+    regionScores_ = std::move(newScores);
   }
 
   void regionRead(int32_t region, int32_t bytes) {
diff --git a/velox/common/caching/StringIdMap.cpp b/velox/common/caching/StringIdMap.cpp
index c8c88542da1..e991c5a750e 100644
--- a/velox/common/caching/StringIdMap.cpp
+++ b/velox/common/caching/StringIdMap.cpp
@@ -31,8 +31,8 @@ void StringIdMap::release(uint64_t id) {
   std::lock_guard<std::mutex> l(mutex_);
   auto it = idToEntry_.find(id);
   if (it != idToEntry_.end()) {
-    VELOX_CHECK_LT(
-        0, it->second.numInUse, "Extra release of id in StringIdMap");
+    VELOX_CHECK_GT(
+        it->second.numInUse, 0, "Extra release of id in StringIdMap");
     if (--it->second.numInUse == 0) {
       pinnedSize_ -= it->second.string.size();
       auto strIter = stringToId_.find(it->second.string);
@@ -60,11 +60,11 @@ uint64_t StringIdMap::makeId(std::string_view string) {
   if (it != stringToId_.end()) {
     auto entry = idToEntry_.find(it->second);
     VELOX_CHECK(entry != idToEntry_.end());
-    if (++entry->second.numInUse == 1) {
-      pinnedSize_ += entry->second.string.size();
-    }
+    VELOX_CHECK_GE(entry->second.numInUse, 1);
+    ++entry->second.numInUse;
     return it->second;
   }
+
   Entry entry;
   entry.string = string;
   // Check that we do not use an id twice. In practice this never
@@ -91,9 +91,8 @@ uint64_t StringIdMap::recoverId(uint64_t id, std::string_view string) {
         id, it->second, "Multiple recover ids assigned to {}", string);
     auto entry = idToEntry_.find(it->second);
     VELOX_CHECK(entry != idToEntry_.end());
-    if (++entry->second.numInUse == 1) {
-      pinnedSize_ += entry->second.string.size();
-    }
+    VELOX_CHECK_GE(entry->second.numInUse, 1);
+    ++entry->second.numInUse;
     return id;
   }
 
diff --git a/velox/common/caching/tests/AsyncDataCacheTest.cpp b/velox/common/caching/tests/AsyncDataCacheTest.cpp
index f60da8f4ba5..7df81482038 100644
--- a/velox/common/caching/tests/AsyncDataCacheTest.cpp
+++ b/velox/common/caching/tests/AsyncDataCacheTest.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "folly/experimental/EventCount.h"
+#include "folly/synchronization/EventCount.h"
 #include "velox/common/base/Semaphore.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/caching/CacheTTLController.h"
@@ -25,8 +25,8 @@
 #include "velox/common/memory/Memory.h"
 #include "velox/common/memory/MmapAllocator.h"
 #include "velox/common/testutil/ScopedTestTime.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/common/testutil/TestValue.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 #include <folly/executors/IOThreadPoolExecutor.h>
 #include <folly/executors/QueuedImmediateExecutor.h>
@@ -144,7 +144,7 @@ class AsyncDataCacheTest : public ::testing::TestWithParam<TestParam> {
       // second creation of cache must find the checkpoint of the
       // previous one.
       if (tempDirectory_ == nullptr || eraseCheckpoint) {
-        tempDirectory_ = exec::test::TempDirectoryPath::create();
+        tempDirectory_ = TempDirectoryPath::create();
       }
       SsdCache::Config config(
           fmt::format("{}/cache", tempDirectory_->getPath()),
@@ -158,7 +158,7 @@ class AsyncDataCacheTest : public ::testing::TestWithParam<TestParam> {
       ssdCache = std::make_unique<SsdCache>(config);
       if (ssdCache != nullptr) {
         ssdCacheHelper_ =
-            std::make_unique<test::SsdCacheTestHelper>(ssdCache.get());
+            std::make_unique<cache::test::SsdCacheTestHelper>(ssdCache.get());
         ASSERT_EQ(ssdCacheHelper_->numShards(), kNumSsdShards);
       }
     }
@@ -173,7 +173,7 @@ class AsyncDataCacheTest : public ::testing::TestWithParam<TestParam> {
     cache_ =
         AsyncDataCache::create(allocator_, std::move(ssdCache), cacheOptions);
     asyncDataCacheHelper_ =
-        std::make_unique<test::AsyncDataCacheTestHelper>(cache_.get());
+        std::make_unique<cache::test::AsyncDataCacheTestHelper>(cache_.get());
     if (filenames_.empty()) {
       for (auto i = 0; i < kNumFiles; ++i) {
         auto name = fmt::format("testing_file_{}", i);
@@ -244,7 +244,7 @@ class AsyncDataCacheTest : public ::testing::TestWithParam<TestParam> {
   // Checks that the contents are consistent with what is set in
   // initializeContents.
   static void checkContents(const AsyncDataCacheEntry& entry) {
-    const auto& alloc = entry.data();
+    const auto& alloc = entry.nonContiguousData();
     const int32_t numBytes = entry.size();
     const int64_t expectedSequence = entry.key().fileNum.id() + entry.offset();
     int32_t bytesChecked = sizeof(int64_t);
@@ -274,7 +274,7 @@ class AsyncDataCacheTest : public ::testing::TestWithParam<TestParam> {
     folly::SemiFuture<bool> wait(false);
     try {
       RawFileCacheKey key{filenames_[0].id(), offset};
-      auto pin = cache_->findOrCreate(key, size, &wait);
+      auto pin = cache_->findOrCreate(key, size, /*contiguous=*/false, &wait);
       EXPECT_FALSE(pin.empty());
       EXPECT_TRUE(pin.entry()->isExclusive());
       pin.entry()->setPrefetch();
@@ -313,12 +313,12 @@ class AsyncDataCacheTest : public ::testing::TestWithParam<TestParam> {
     }
   }
 
-  std::shared_ptr<exec::test::TempDirectoryPath> tempDirectory_;
+  std::shared_ptr<TempDirectoryPath> tempDirectory_;
   std::unique_ptr<memory::MemoryManager> manager_;
   memory::MemoryAllocator* allocator_;
   std::shared_ptr<AsyncDataCache> cache_;
-  std::unique_ptr<test::AsyncDataCacheTestHelper> asyncDataCacheHelper_;
-  std::unique_ptr<test::SsdCacheTestHelper> ssdCacheHelper_;
+  std::unique_ptr<cache::test::AsyncDataCacheTestHelper> asyncDataCacheHelper_;
+  std::unique_ptr<cache::test::SsdCacheTestHelper> ssdCacheHelper_;
   std::vector<StringIdLease> filenames_;
   std::unique_ptr<folly::IOThreadPoolExecutor> loadExecutor_;
   std::unique_ptr<folly::IOThreadPoolExecutor> ssdExecutor_;
@@ -346,7 +346,7 @@ class TestingCoalescedLoad : public CoalescedLoad {
           pins.push_back(std::move(pin));
         });
     for (const auto& pin : pins) {
-      auto& buffer = pin.entry()->data();
+      auto& buffer = pin.entry()->nonContiguousData();
       AsyncDataCacheTest::initializeContents(
           pin.entry()->key().offset + pin.entry()->key().fileNum.id(), buffer);
     }
@@ -362,6 +362,10 @@ class TestingCoalescedLoad : public CoalescedLoad {
     return sum;
   }
 
+  bool isSsdLoad() const override {
+    return false;
+  }
+
  protected:
   const std::shared_ptr<AsyncDataCache> cache_;
   const std::vector<Request> requests_;
@@ -415,6 +419,10 @@ class TestingCoalescedSsdLoad : public TestingCoalescedLoad {
     return pins;
   }
 
+  bool isSsdLoad() const override {
+    return true;
+  }
+
  private:
   std::vector<SsdPin> ssdPins_;
 };
@@ -433,7 +441,8 @@ void AsyncDataCacheTest::loadOne(
   RawFileCacheKey key{fileNum, request.offset};
   for (;;) {
     folly::SemiFuture<bool> loadFuture(false);
-    auto pin = cache_->findOrCreate(key, request.size, &loadFuture);
+    auto pin = cache_->findOrCreate(
+        key, request.size, /*contiguous=*/false, &loadFuture);
     if (pin.empty()) {
       // The pin was exclusive on another thread. Wait until it is no longer so
       // and retry.
@@ -467,7 +476,8 @@ void AsyncDataCacheTest::loadOne(
     }
     // Load from storage.
     initializeContents(
-        entry->key().offset + entry->key().fileNum.id(), entry->data());
+        entry->key().offset + entry->key().fileNum.id(),
+        entry->nonContiguousData());
     entry->setExclusiveToShared();
     return;
   }
@@ -661,35 +671,36 @@ TEST_P(AsyncDataCacheTest, pin) {
   uint64_t offset = 1000;
   folly::SemiFuture<bool> wait(false);
   RawFileCacheKey key{file.id(), offset};
-  auto pin = cache_->findOrCreate(key, kSize, &wait);
+  auto pin = cache_->findOrCreate(key, kSize, /*contiguous=*/false, &wait);
   EXPECT_FALSE(pin.empty());
   EXPECT_TRUE(wait.isReady());
   EXPECT_TRUE(pin.entry()->isExclusive());
   pin.entry()->setPrefetch();
-  EXPECT_LE(kSize, pin.entry()->data().byteSize());
+  EXPECT_LE(kSize, pin.entry()->nonContiguousData().byteSize());
   EXPECT_LT(0, cache_->incrementPrefetchPages(0));
   auto stats = cache_->refreshStats();
   EXPECT_EQ(1, stats.numExclusive);
-  EXPECT_LE(kSize, stats.largeSize);
+  EXPECT_EQ(0, stats.largeSize);
 
   CachePin otherPin;
   EXPECT_THROW(otherPin = pin, VeloxException);
   EXPECT_TRUE(otherPin.empty());
 
   // Second reference to an exclusive entry.
-  otherPin = cache_->findOrCreate(key, kSize, &wait);
+  otherPin = cache_->findOrCreate(key, kSize, /*contiguous=*/false, &wait);
   EXPECT_FALSE(wait.isReady());
   EXPECT_TRUE(otherPin.empty());
   bool noLongerExclusive = false;
   std::move(wait).via(&exec).thenValue([&](bool) { noLongerExclusive = true; });
-  initializeContents(key.fileNum + key.offset, pin.checkedEntry()->data());
+  initializeContents(
+      key.fileNum + key.offset, pin.checkedEntry()->nonContiguousData());
   pin.checkedEntry()->setExclusiveToShared();
   pin.clear();
   EXPECT_TRUE(pin.empty());
 
   EXPECT_TRUE(noLongerExclusive);
 
-  pin = cache_->findOrCreate(key, kSize, &wait);
+  pin = cache_->findOrCreate(key, kSize, /*contiguous=*/false, &wait);
   EXPECT_TRUE(pin.entry()->isShared());
   EXPECT_TRUE(pin.entry()->getAndClearFirstUseFlag());
   EXPECT_FALSE(pin.entry()->getAndClearFirstUseFlag());
@@ -697,7 +708,8 @@ TEST_P(AsyncDataCacheTest, pin) {
   otherPin = pin;
   EXPECT_EQ(2, pin.entry()->numPins());
   EXPECT_FALSE(pin.entry()->isPrefetch());
-  auto largerPin = cache_->findOrCreate(key, kSize * 2, &wait);
+  auto largerPin =
+      cache_->findOrCreate(key, kSize * 2, /*contiguous=*/false, &wait);
   // We expect a new uninitialized entry with a larger size to displace the
   // previous one.
 
@@ -719,6 +731,223 @@ TEST_P(AsyncDataCacheTest, pin) {
   EXPECT_EQ(0, cache_->incrementPrefetchPages(0));
 }
 
+TEST_P(AsyncDataCacheTest, contiguousPin) {
+  initializeCache(1 << 20);
+  auto& exec = folly::QueuedImmediateExecutor::instance();
+
+  StringIdLease file(fileIds(), std::string_view("testingfile_contiguous"));
+
+  struct TestParam {
+    int64_t size;
+    bool expectTiny;
+    std::string debugString() const {
+      return fmt::format("size {}, expectTiny {}", size, expectTiny);
+    }
+  };
+
+  std::vector<TestParam> testSettings = {
+      {AsyncDataCacheEntry::kTinyDataSize / 2, true},
+      {AsyncDataCacheEntry::kTinyDataSize - 1, true},
+      {AsyncDataCacheEntry::kTinyDataSize, false},
+      {AsyncDataCacheEntry::kTinyDataSize * 4, false},
+      {25'000, false},
+  };
+
+  uint64_t offset = 1'000;
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    folly::SemiFuture<bool> wait(false);
+    RawFileCacheKey key{file.id(), offset};
+    offset += testData.size;
+
+    auto pin =
+        cache_->findOrCreate(key, testData.size, /*contiguous=*/true, &wait);
+    ASSERT_FALSE(pin.empty());
+    ASSERT_TRUE(wait.isReady());
+    auto* entry = pin.checkedEntry();
+    ASSERT_TRUE(entry->isExclusive());
+    ASSERT_TRUE(entry->hasContiguousData());
+    ASSERT_TRUE(entry->nonContiguousData().empty());
+    ASSERT_EQ(entry->contiguousDataSize(), testData.size);
+
+    test::AsyncDataCacheEntryTestHelper entryHelper(entry);
+    if (testData.expectTiny) {
+      ASSERT_TRUE(entryHelper.isTinyData());
+      ASSERT_FALSE(entryHelper.isContiguousData());
+    } else {
+      ASSERT_FALSE(entryHelper.isTinyData());
+      ASSERT_TRUE(entryHelper.isContiguousData());
+    }
+
+    ::memset(entry->contiguousData(), 0xCD, testData.size);
+    entry->setExclusiveToShared();
+
+    // Verify stats include the contiguous allocation.
+    {
+      auto stats = cache_->refreshStats();
+      ASSERT_EQ(stats.numEntries, 1);
+      if (testData.expectTiny) {
+        ASSERT_EQ(stats.numTinyEntries, 1);
+        ASSERT_EQ(stats.tinySize, testData.size);
+      } else {
+        ASSERT_EQ(stats.numLargeEntries, 1);
+        ASSERT_EQ(stats.largeSize, testData.size);
+      }
+      if (!testData.expectTiny) {
+        ASSERT_EQ(
+            cache_->cachedPages(),
+            memory::AllocationTraits::numPages(testData.size));
+      }
+    }
+
+    auto pin2 =
+        cache_->findOrCreate(key, testData.size, /*contiguous=*/true, &wait);
+    ASSERT_FALSE(pin2.empty());
+    ASSERT_TRUE(pin2.checkedEntry()->isShared());
+    ASSERT_TRUE(pin2.checkedEntry()->hasContiguousData());
+    ASSERT_EQ(
+        static_cast<uint8_t>(pin2.checkedEntry()->contiguousData()[0]), 0xCD);
+    pin2.clear();
+
+    // Lookup with contiguous=false should return the same contiguous entry.
+    auto pin3 =
+        cache_->findOrCreate(key, testData.size, /*contiguous=*/false, &wait);
+    ASSERT_FALSE(pin3.empty());
+    ASSERT_TRUE(pin3.checkedEntry()->isShared());
+    ASSERT_TRUE(pin3.checkedEntry()->hasContiguousData());
+    pin.clear();
+    pin3.clear();
+
+    // Wait-future: concurrent access to an exclusive entry.
+    RawFileCacheKey key2{file.id(), offset};
+    offset += testData.size;
+    auto exclusivePin =
+        cache_->findOrCreate(key2, testData.size, /*contiguous=*/true, &wait);
+    ASSERT_FALSE(exclusivePin.empty());
+    ASSERT_TRUE(exclusivePin.checkedEntry()->isExclusive());
+
+    auto waitingPin =
+        cache_->findOrCreate(key2, testData.size, /*contiguous=*/true, &wait);
+    ASSERT_TRUE(waitingPin.empty());
+    ASSERT_FALSE(wait.isReady());
+
+    bool notified = false;
+    std::move(wait).via(&exec).thenValue([&](bool) { notified = true; });
+    exclusivePin.checkedEntry()->setExclusiveToShared();
+    exclusivePin.clear();
+    ASSERT_TRUE(notified);
+
+    auto retryPin =
+        cache_->findOrCreate(key2, testData.size, /*contiguous=*/true, &wait);
+    ASSERT_FALSE(retryPin.empty());
+    ASSERT_TRUE(retryPin.checkedEntry()->isShared());
+    retryPin.clear();
+
+    cache_->clear();
+    auto stats = cache_->refreshStats();
+    ASSERT_EQ(stats.numEntries, 0);
+    ASSERT_EQ(stats.largeSize, 0);
+    ASSERT_EQ(stats.tinySize, 0);
+    ASSERT_EQ(cache_->cachedPages(), 0);
+  }
+}
+
+TEST_P(AsyncDataCacheTest, nonContiguousPin) {
+  initializeCache(1 << 20);
+
+  StringIdLease file(fileIds(), std::string_view("testingfile_noncontiguous"));
+
+  struct TestParam {
+    int64_t size;
+    bool expectTiny;
+    std::string debugString() const {
+      return fmt::format("size {}, expectTiny {}", size, expectTiny);
+    }
+  };
+
+  std::vector<TestParam> testSettings = {
+      {AsyncDataCacheEntry::kTinyDataSize / 2, true},
+      {AsyncDataCacheEntry::kTinyDataSize - 1, true},
+      {AsyncDataCacheEntry::kTinyDataSize, false},
+      {AsyncDataCacheEntry::kTinyDataSize * 4, false},
+      {25'000, false},
+  };
+
+  uint64_t offset = 1'000;
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    folly::SemiFuture<bool> wait(false);
+    RawFileCacheKey key{file.id(), offset};
+    offset += testData.size;
+
+    auto pin =
+        cache_->findOrCreate(key, testData.size, /*contiguous=*/false, &wait);
+    ASSERT_FALSE(pin.empty());
+    ASSERT_TRUE(wait.isReady());
+    auto* entry = pin.checkedEntry();
+    ASSERT_TRUE(entry->isExclusive());
+
+    test::AsyncDataCacheEntryTestHelper entryHelper(entry);
+    if (testData.expectTiny) {
+      ASSERT_TRUE(entryHelper.isTinyData());
+      ASSERT_FALSE(entryHelper.isContiguousData());
+      ASSERT_TRUE(entry->hasContiguousData());
+      ASSERT_TRUE(entry->nonContiguousData().empty());
+    } else {
+      ASSERT_FALSE(entryHelper.isTinyData());
+      ASSERT_FALSE(entryHelper.isContiguousData());
+      ASSERT_FALSE(entry->hasContiguousData());
+      ASSERT_FALSE(entry->nonContiguousData().empty());
+    }
+
+    entry->setExclusiveToShared();
+
+    // Verify stats.
+    {
+      auto stats = cache_->refreshStats();
+      ASSERT_EQ(stats.numEntries, 1);
+      if (testData.expectTiny) {
+        ASSERT_EQ(stats.numTinyEntries, 1);
+        ASSERT_EQ(stats.tinySize, testData.size);
+      } else {
+        ASSERT_EQ(stats.numLargeEntries, 1);
+      }
+      if (!testData.expectTiny) {
+        ASSERT_EQ(
+            cache_->cachedPages(),
+            memory::AllocationTraits::numPages(testData.size));
+      }
+    }
+
+    // Shared hit with same flag.
+    auto pin2 =
+        cache_->findOrCreate(key, testData.size, /*contiguous=*/false, &wait);
+    ASSERT_FALSE(pin2.empty());
+    ASSERT_TRUE(pin2.checkedEntry()->isShared());
+    pin2.clear();
+
+    // Lookup with contiguous=true should return the same non-contiguous entry.
+    auto pin3 =
+        cache_->findOrCreate(key, testData.size, /*contiguous=*/true, &wait);
+    ASSERT_FALSE(pin3.empty());
+    ASSERT_TRUE(pin3.checkedEntry()->isShared());
+    if (testData.expectTiny) {
+      ASSERT_TRUE(pin3.checkedEntry()->hasContiguousData());
+    } else {
+      ASSERT_FALSE(pin3.checkedEntry()->hasContiguousData());
+    }
+    pin.clear();
+    pin3.clear();
+
+    cache_->clear();
+    auto stats = cache_->refreshStats();
+    ASSERT_EQ(stats.numEntries, 0);
+    ASSERT_EQ(cache_->cachedPages(), 0);
+  }
+}
+
 TEST_P(AsyncDataCacheTest, replace) {
   constexpr int64_t kMaxBytes = 64 << 20;
   FLAGS_velox_exception_user_stacktrace_enabled = false;
@@ -733,8 +962,7 @@ TEST_P(AsyncDataCacheTest, replace) {
   EXPECT_LT(0, stats.hitBytes);
   EXPECT_LT(0, stats.numEvict);
   EXPECT_GE(
-      kMaxBytes / memory::AllocationTraits::kPageSize,
-      cache_->incrementCachedPages(0));
+      kMaxBytes / memory::AllocationTraits::kPageSize, cache_->cachedPages());
 }
 
 TEST_P(AsyncDataCacheTest, evictAccounting) {
@@ -776,8 +1004,7 @@ TEST_P(AsyncDataCacheTest, largeEvict) {
   auto stats = cache_->refreshStats();
   EXPECT_LT(0, stats.numEvict);
   EXPECT_GE(
-      kMaxBytes / memory::AllocationTraits::kPageSize,
-      cache_->incrementCachedPages(0));
+      kMaxBytes / memory::AllocationTraits::kPageSize, cache_->cachedPages());
   LOG(INFO) << "Reties after failed evict: " << numLargeRetries_;
 }
 
@@ -805,7 +1032,7 @@ TEST_P(AsyncDataCacheTest, outOfCapacity) {
   ASSERT_FALSE(allocator_->allocateNonContiguous(kSizeInPages, allocation));
   // One 4 page entry below the max size of 4K 4 page entries in 16MB of
   // capacity.
-  ASSERT_EQ(16384, cache_->incrementCachedPages(0));
+  ASSERT_EQ(16384, cache_->cachedPages());
   ASSERT_EQ(16384, cache_->incrementPrefetchPages(0));
   pins.clear();
 
@@ -816,7 +1043,7 @@ TEST_P(AsyncDataCacheTest, outOfCapacity) {
     }
     allocations.push_back(std::move(allocation));
   }
-  EXPECT_EQ(0, cache_->incrementCachedPages(0));
+  EXPECT_EQ(0, cache_->cachedPages());
   EXPECT_EQ(0, cache_->incrementPrefetchPages(0));
   EXPECT_EQ(16384, allocator_->numAllocated());
   clearAllocations(allocations);
@@ -1044,7 +1271,7 @@ TEST_P(AsyncDataCacheTest, staleEntry) {
   const uint64_t size = 200;
   folly::SemiFuture<bool> wait(false);
   RawFileCacheKey key{file.id(), offset};
-  auto pin = cache_->findOrCreate(key, size, &wait);
+  auto pin = cache_->findOrCreate(key, size, /*contiguous=*/false, &wait);
   ASSERT_FALSE(pin.empty());
   ASSERT_TRUE(wait.isReady());
   ASSERT_TRUE(pin.entry()->isExclusive());
@@ -1055,7 +1282,7 @@ TEST_P(AsyncDataCacheTest, staleEntry) {
   ASSERT_EQ(stats.numEntries, 1);
   ASSERT_EQ(stats.numHit, 0);
 
-  auto validPin = cache_->findOrCreate(key, size, &wait);
+  auto validPin = cache_->findOrCreate(key, size, /*contiguous=*/false, &wait);
   ASSERT_FALSE(validPin.empty());
   ASSERT_TRUE(wait.isReady());
   ASSERT_FALSE(validPin.entry()->isExclusive());
@@ -1065,7 +1292,8 @@ TEST_P(AsyncDataCacheTest, staleEntry) {
   ASSERT_EQ(stats.numHit, 1);
 
   // Stale cache access with large cache size.
-  auto stalePin = cache_->findOrCreate(key, 2 * size, &wait);
+  auto stalePin =
+      cache_->findOrCreate(key, 2 * size, /*contiguous=*/false, &wait);
   ASSERT_FALSE(stalePin.empty());
   ASSERT_TRUE(wait.isReady());
   ASSERT_TRUE(stalePin.entry()->isExclusive());
@@ -1125,26 +1353,26 @@ TEST_P(AsyncDataCacheTest, shrinkCache) {
     for (int i = 0; i < numEntries; ++i) {
       auto tinyPin = cache_->findOrCreate(tinyCacheKeys[i], kTinyDataSize);
       ASSERT_FALSE(tinyPin.empty());
-      ASSERT_TRUE(tinyPin.entry()->tinyData() != nullptr);
-      ASSERT_TRUE(tinyPin.entry()->data().empty());
+      ASSERT_TRUE(tinyPin.entry()->hasContiguousData());
+      ASSERT_TRUE(tinyPin.entry()->nonContiguousData().empty());
       ASSERT_FALSE(tinyPin.entry()->isPrefetch());
       ASSERT_FALSE(tinyPin.entry()->ssdSaveable());
       pins.push_back(std::move(tinyPin));
       auto largePin = cache_->findOrCreate(largeCacheKeys[i], kLargeDataSize);
-      ASSERT_FALSE(largePin.entry()->tinyData() != nullptr);
-      ASSERT_FALSE(largePin.entry()->data().empty());
+      ASSERT_FALSE(largePin.entry()->hasContiguousData());
+      ASSERT_FALSE(largePin.entry()->nonContiguousData().empty());
       ASSERT_FALSE(largePin.entry()->isPrefetch());
       ASSERT_FALSE(largePin.entry()->ssdSaveable());
       pins.push_back(std::move(largePin));
     }
     auto stats = cache_->refreshStats();
-    ASSERT_EQ(stats.numEntries, numEntries * 2);
+    ASSERT_EQ(stats.numEntries, 0);
     ASSERT_EQ(stats.numEmptyEntries, 0);
     ASSERT_EQ(stats.numExclusive, numEntries * 2);
     ASSERT_EQ(stats.numEvict, 0);
     ASSERT_EQ(stats.numHit, 0);
-    ASSERT_EQ(stats.tinySize, kTinyDataSize * numEntries);
-    ASSERT_EQ(stats.largeSize, kLargeDataSize * numEntries);
+    ASSERT_EQ(stats.tinySize, 0);
+    ASSERT_EQ(stats.largeSize, 0);
     ASSERT_EQ(stats.sharedPinnedBytes, 0);
     ASSERT_GE(
         stats.exclusivePinnedBytes,
@@ -1402,9 +1630,10 @@ TEST_P(AsyncDataCacheTest, makeEvictable) {
       std::vector<RawFileCacheKey> keys;
       keys.reserve(cachePins.size());
       for (const auto& pin : cachePins) {
-        keys.push_back(RawFileCacheKey{
-            pin.checkedEntry()->key().fileNum.id(),
-            pin.checkedEntry()->key().offset});
+        keys.push_back(
+            RawFileCacheKey{
+                pin.checkedEntry()->key().fileNum.id(),
+                pin.checkedEntry()->key().offset});
       }
       cachePins.clear();
       for (const auto& key : keys) {
@@ -1414,7 +1643,7 @@ TEST_P(AsyncDataCacheTest, makeEvictable) {
     const auto cacheEntries = asyncDataCacheHelper_->cacheEntries();
     for (const auto& cacheEntry : cacheEntries) {
       const auto cacheEntryHelper =
-          test::AsyncDataCacheEntryTestHelper(cacheEntry);
+          cache::test::AsyncDataCacheEntryTestHelper(cacheEntry);
       ASSERT_EQ(cacheEntry->ssdSaveable(), !evictable);
       ASSERT_EQ(cacheEntryHelper.accessStats().numUses, 0);
       if (evictable) {
@@ -1495,6 +1724,65 @@ TEST_P(AsyncDataCacheTest, ssdWriteOptions) {
   }
 }
 
+TEST_P(AsyncDataCacheTest, ssdFlushThresholdBytes) {
+  constexpr uint64_t kRamBytes = 16UL << 20; // 16 MB
+  constexpr uint64_t kSsdBytes = 64UL << 20; // 64 MB
+
+  struct {
+    double maxWriteRatio;
+    double ssdSavableRatio;
+    int32_t minSsdSavableBytes;
+    uint64_t ssdFlushThresholdBytes;
+    bool expectedSaveToSsd;
+
+    std::string debugString() const {
+      return fmt::format(
+          "maxWriteRatio {}, ssdSavableRatio {}, minSsdSavableBytes {}, ssdFlushThresholdBytes {}, expectedSaveToSsd {}",
+          maxWriteRatio,
+          ssdSavableRatio,
+          minSsdSavableBytes,
+          ssdFlushThresholdBytes,
+          expectedSaveToSsd);
+    }
+  } testSettings[] = {
+      // Ratio-based threshold not met, ssdFlushThresholdBytes disabled (0).
+      // No flush expected.
+      {0.8, 0.95, 32 << 20, 0, false},
+      // Ratio-based threshold not met, but ssdFlushThresholdBytes is small
+      // (1MB).
+      // Flush expected due to absolute threshold.
+      {0.8, 0.95, 32 << 20, 1UL << 20, true},
+      // Ratio-based threshold met. ssdFlushThresholdBytes disabled.
+      // Flush expected due to ratio.
+      {0.8, 0.3, 4 << 20, 0, true},
+      // Both thresholds could trigger. Flush expected.
+      {0.8, 0.3, 4 << 20, 1UL << 20, true}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    initializeCache(
+        kRamBytes,
+        kSsdBytes,
+        0,
+        true,
+        AsyncDataCache::Options(
+            testData.maxWriteRatio,
+            testData.ssdSavableRatio,
+            testData.minSsdSavableBytes,
+            AsyncDataCache::kDefaultNumShards,
+            testData.ssdFlushThresholdBytes));
+    // Load data half of the in-memory capacity.
+    loadLoop(0, kRamBytes / 2);
+    waitForPendingLoads();
+    auto stats = cache_->refreshStats();
+    if (testData.expectedSaveToSsd) {
+      EXPECT_GT(stats.ssdStats->entriesWritten, 0);
+    } else {
+      EXPECT_EQ(stats.ssdStats->entriesWritten, 0);
+    }
+  }
+}
+
 TEST_P(AsyncDataCacheTest, appendSsdSaveable) {
   constexpr uint64_t kRamBytes = 64UL << 20; // 64 MB
   constexpr uint64_t kSsdBytes = 128UL << 20; // 128 MB
@@ -1572,6 +1860,810 @@ TEST_P(AsyncDataCacheTest, checkpoint) {
 
 // TODO: add concurrent fuzzer test.
 
+TEST_P(AsyncDataCacheTest, numShardsDefault) {
+  constexpr uint64_t kRamBytes = 16UL << 20;
+
+  initializeCache(kRamBytes);
+  ASSERT_EQ(
+      asyncDataCacheHelper_->numShards(), AsyncDataCache::kDefaultNumShards);
+}
+
+TEST_P(AsyncDataCacheTest, numShardsInvalid) {
+  constexpr uint64_t kRamBytes = 16UL << 20;
+
+  // Non-power-of-2 should fail.
+  for (int32_t numShards : {3, 5, 6, 7, 9, 10}) {
+    AsyncDataCache::Options options;
+    options.numShards = numShards;
+    VELOX_ASSERT_THROW(
+        initializeCache(kRamBytes, 0, 0, false, options),
+        "numShards must be a power of 2");
+  }
+
+  // Zero should fail.
+  {
+    AsyncDataCache::Options options;
+    options.numShards = 0;
+    VELOX_ASSERT_THROW(
+        initializeCache(kRamBytes, 0, 0, false, options),
+        "numShards must be positive");
+  }
+
+  // Negative should fail.
+  {
+    AsyncDataCache::Options options;
+    options.numShards = -1;
+    VELOX_ASSERT_THROW(
+        initializeCache(kRamBytes, 0, 0, false, options),
+        "numShards must be positive");
+  }
+}
+
+TEST_P(AsyncDataCacheTest, findMiss) {
+  constexpr int64_t kRamBytes = 32 << 20;
+  initializeMemoryManager(kRamBytes);
+  initializeCache(kRamBytes);
+
+  RawFileCacheKey key{filenames_[0].id(), 0};
+  auto result = cache_->find(key);
+  ASSERT_FALSE(result.has_value());
+}
+
+TEST_P(AsyncDataCacheTest, findHit) {
+  constexpr int64_t kRamBytes = 32 << 20;
+  constexpr int32_t kEntrySize = 4096;
+  initializeMemoryManager(kRamBytes);
+  initializeCache(kRamBytes);
+
+  RawFileCacheKey key{filenames_[0].id(), 1000};
+
+  // Populate the entry via findOrCreate.
+  {
+    auto pin = cache_->findOrCreate(key, kEntrySize);
+    ASSERT_FALSE(pin.empty());
+    ASSERT_TRUE(pin.entry()->isExclusive());
+    initializeContents(
+        key.offset + key.fileNum, pin.entry()->nonContiguousData());
+    pin.entry()->setExclusiveToShared();
+  }
+
+  // find should return a shared pin with correct data.
+  auto result = cache_->find(key);
+  ASSERT_TRUE(result.has_value());
+  ASSERT_FALSE(result->empty());
+  auto* entry = result->checkedEntry();
+  ASSERT_TRUE(entry->isShared());
+  ASSERT_EQ(entry->size(), kEntrySize);
+  checkContents(*entry);
+}
+
+TEST_P(AsyncDataCacheTest, findExclusiveWithWait) {
+  constexpr int64_t kRamBytes = 32 << 20;
+  constexpr int32_t kEntrySize = 4096;
+  initializeMemoryManager(kRamBytes);
+  initializeCache(kRamBytes);
+
+  RawFileCacheKey key{filenames_[0].id(), 2000};
+
+  // Create an exclusive entry.
+  auto exclusivePin = cache_->findOrCreate(key, kEntrySize);
+  ASSERT_FALSE(exclusivePin.empty());
+  ASSERT_TRUE(exclusivePin.entry()->isExclusive());
+
+  // find without wait returns empty pin (entry exists but is exclusive).
+  {
+    auto result = cache_->find(key);
+    ASSERT_TRUE(result.has_value());
+    ASSERT_TRUE(result->empty());
+  }
+
+  // find with wait returns empty pin and sets a future.
+  folly::SemiFuture<bool> waitFuture(false);
+  {
+    auto result = cache_->find(key, &waitFuture);
+    ASSERT_TRUE(result.has_value());
+    ASSERT_TRUE(result->empty());
+  }
+
+  // The future should not be ready while the entry is exclusive.
+  ASSERT_FALSE(waitFuture.isReady());
+
+  // Timed wait should time out while the entry is still exclusive.
+  {
+    auto waitCopy = std::move(waitFuture);
+    auto timedResult =
+        std::move(waitCopy).via(&folly::QueuedImmediateExecutor::instance());
+    ASSERT_FALSE(
+        std::move(timedResult).wait(std::chrono::seconds(1)).isReady());
+  }
+
+  // Re-issue find with wait after the timed-out future was consumed.
+  waitFuture = folly::SemiFuture<bool>(false);
+  {
+    auto result = cache_->find(key, &waitFuture);
+    ASSERT_TRUE(result.has_value());
+    ASSERT_TRUE(result->empty());
+  }
+  ASSERT_FALSE(waitFuture.isReady());
+
+  // Transition to shared makes the future ready.
+  initializeContents(
+      key.offset + key.fileNum, exclusivePin.entry()->nonContiguousData());
+  exclusivePin.entry()->setExclusiveToShared();
+  exclusivePin.clear();
+
+  auto& exec = folly::QueuedImmediateExecutor::instance();
+  ASSERT_TRUE(std::move(waitFuture).via(&exec).wait().isReady());
+
+  // Now find should return a shared pin.
+  auto result = cache_->find(key);
+  ASSERT_TRUE(result.has_value());
+  ASSERT_FALSE(result->empty());
+  checkContents(*result->checkedEntry());
+}
+
+TEST_P(AsyncDataCacheTest, fuzz) {
+  constexpr int64_t kRamBytes = 64 << 20;
+  constexpr int32_t kNumThreads = 8;
+  constexpr int32_t kNumFiles = 10;
+  constexpr int32_t kNumOffsets = 20;
+  constexpr int32_t kEntrySize = 4096;
+  constexpr int32_t kTestDurationMs = 10'000;
+
+  initializeMemoryManager(kRamBytes);
+  initializeCache(kRamBytes);
+
+  std::atomic_bool stop{false};
+
+  // Worker threads: findOrCreate/find entries, verify content.
+  auto workerFunc = [&](int32_t threadId) {
+    std::mt19937 rng(threadId);
+    while (!stop.load(std::memory_order_relaxed)) {
+      const auto fileIdx = rng() % kNumFiles;
+      const auto offsetIdx = rng() % kNumOffsets;
+      const uint64_t offset = offsetIdx * kEntrySize;
+      RawFileCacheKey key{filenames_[fileIdx].id(), offset};
+
+      // Randomly choose between find and findOrCreate.
+      if (rng() % 3 == 0) {
+        // find: lookup only.
+        auto result = cache_->find(key);
+        if (result.has_value() && !result->empty()) {
+          checkContents(*result->checkedEntry());
+        }
+      } else {
+        // findOrCreate: populate if new.
+        folly::SemiFuture<bool> waitFuture(false);
+        auto pin = cache_->findOrCreate(
+            key, kEntrySize, /*contiguous=*/false, &waitFuture);
+        if (pin.empty()) {
+          auto& exec = folly::QueuedImmediateExecutor::instance();
+          std::move(waitFuture).via(&exec).wait();
+          continue;
+        }
+        auto* entry = pin.checkedEntry();
+        if (entry->isExclusive()) {
+          initializeContents(
+              key.offset + key.fileNum, entry->nonContiguousData());
+          entry->setExclusiveToShared();
+        }
+        checkContents(*entry);
+      }
+    }
+  };
+
+  // Eviction thread: periodically remove a subset of files.
+  auto evictFunc = [&]() {
+    std::mt19937 rng(kNumThreads + 1);
+    while (!stop.load(std::memory_order_relaxed)) {
+      std::this_thread::sleep_for(std::chrono::milliseconds(50)); // NOLINT
+      folly::F14FastSet<uint64_t> filesToRemove;
+      // Remove a random subset of files.
+      const auto numToRemove = (rng() % kNumFiles) + 1;
+      for (uint32_t i = 0; i < numToRemove; ++i) {
+        filesToRemove.insert(filenames_[rng() % kNumFiles].id());
+      }
+      folly::F14FastSet<uint64_t> filesRetained;
+      cache_->removeFileEntries(filesToRemove, filesRetained);
+    }
+  };
+
+  std::vector<std::thread> threads;
+  for (int32_t i = 0; i < kNumThreads; ++i) {
+    threads.emplace_back(workerFunc, i);
+  }
+  threads.emplace_back(evictFunc);
+
+  std::this_thread::sleep_for(
+      std::chrono::milliseconds(kTestDurationMs)); // NOLINT
+  stop.store(true, std::memory_order_relaxed);
+
+  for (auto& thread : threads) {
+    thread.join();
+  }
+
+  auto stats = cache_->refreshStats();
+  LOG(INFO) << "fuzz stats: " << stats.numEntries << " entries, "
+            << stats.numHit << " hits, " << stats.numNew << " new, "
+            << stats.numEvict << " evicts";
+}
+
+TEST_P(AsyncDataCacheTest, dataRanges) {
+  constexpr uint64_t kRamBytes = 64UL << 20;
+  initializeCache(kRamBytes);
+
+  struct TestParam {
+    int32_t size;
+    std::string debugString() const {
+      return fmt::format("size {}", size);
+    }
+  };
+
+  std::vector<TestParam> testSettings = {
+      // Tiny entry (< kTinyDataSize).
+      {AsyncDataCacheEntry::kTinyDataSize - 1},
+      // Allocation-backed entry (>= kTinyDataSize).
+      {AsyncDataCacheEntry::kTinyDataSize * 4},
+  };
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    auto pin = newEntry(testData.size, testData.size);
+    ASSERT_FALSE(pin.empty());
+    auto* entry = pin.checkedEntry();
+    ASSERT_TRUE(entry->isExclusive());
+
+    auto ranges = entry->dataRanges(testData.size);
+    ASSERT_FALSE(ranges.empty());
+
+    // Verify total bytes across all ranges covers the entry size.
+    uint64_t totalBytes = 0;
+    for (const auto& range : ranges) {
+      ASSERT_GT(range.size(), 0);
+      totalBytes += range.size();
+    }
+    ASSERT_EQ(totalBytes, testData.size);
+
+    // Verify ranges are writable by writing a pattern and reading it back.
+    uint8_t pattern = 0;
+    for (auto& range : ranges) {
+      ::memset(range.data(), pattern, range.size());
+      ++pattern;
+    }
+    pattern = 0;
+    for (const auto& range : ranges) {
+      for (size_t i = 0; i < range.size(); ++i) {
+        ASSERT_EQ(static_cast<uint8_t>(range.data()[i]), pattern);
+      }
+      ++pattern;
+    }
+
+    if (testData.size < AsyncDataCacheEntry::kTinyDataSize) {
+      // Tiny entry: single range backed by tinyData.
+      ASSERT_EQ(ranges.size(), 1);
+      ASSERT_TRUE(entry->hasContiguousData());
+      ASSERT_EQ(ranges[0].data(), entry->contiguousData());
+    } else {
+      // Allocation-backed: one range per run.
+      ASSERT_EQ(ranges.size(), entry->nonContiguousData().numRuns());
+    }
+
+    entry->setExclusiveToShared();
+  }
+}
+
+TEST_P(AsyncDataCacheTest, acquiredMemory) {
+  constexpr uint64_t kRamBytes = 64UL << 20;
+  initializeCache(kRamBytes);
+  auto* allocator = cache_->allocator();
+
+  // Default is empty with zero bytes.
+  {
+    AcquiredMemory acquired;
+    ASSERT_TRUE(acquired.empty());
+    ASSERT_EQ(acquired.totalBytes(), 0);
+    acquired.free(allocator);
+    ASSERT_TRUE(acquired.empty());
+  }
+
+  // Non-contiguous only.
+  {
+    AcquiredMemory acquired;
+    memory::Allocation allocation;
+    ASSERT_TRUE(allocator->allocateNonContiguous(10, allocation));
+    const auto expectedBytes = allocation.byteSize();
+    acquired.nonContiguousAllocs.appendMove(allocation);
+
+    ASSERT_FALSE(acquired.empty());
+    ASSERT_EQ(acquired.totalBytes(), expectedBytes);
+
+    acquired.free(allocator);
+    ASSERT_TRUE(acquired.empty());
+    ASSERT_EQ(acquired.totalBytes(), 0);
+  }
+
+  // Byte allocations only.
+  {
+    AcquiredMemory acquired;
+    auto* ptr1 = allocator->allocateBytes(1'024);
+    auto* ptr2 = allocator->allocateBytes(2'048);
+    ASSERT_NE(ptr1, nullptr);
+    ASSERT_NE(ptr2, nullptr);
+    acquired.byteAllocations.emplace_back(ptr1, 1'024);
+    acquired.byteAllocations.emplace_back(ptr2, 2'048);
+
+    ASSERT_FALSE(acquired.empty());
+    ASSERT_EQ(acquired.totalBytes(), 3'072);
+
+    acquired.free(allocator);
+    ASSERT_TRUE(acquired.empty());
+    ASSERT_EQ(acquired.totalBytes(), 0);
+  }
+
+  // Mixed non-contiguous and byte allocations.
+  {
+    AcquiredMemory acquired;
+    memory::Allocation allocation;
+    ASSERT_TRUE(allocator->allocateNonContiguous(10, allocation));
+    const auto nonContiguousBytes = allocation.byteSize();
+    acquired.nonContiguousAllocs.appendMove(allocation);
+
+    constexpr uint64_t kByteAllocSize = 4'096;
+    auto* ptr = allocator->allocateBytes(kByteAllocSize);
+    ASSERT_NE(ptr, nullptr);
+    acquired.byteAllocations.emplace_back(ptr, kByteAllocSize);
+
+    ASSERT_FALSE(acquired.empty());
+    ASSERT_EQ(acquired.totalBytes(), nonContiguousBytes + kByteAllocSize);
+
+    acquired.free(allocator);
+    ASSERT_TRUE(acquired.empty());
+    ASSERT_EQ(acquired.totalBytes(), 0);
+  }
+}
+
+TEST_P(AsyncDataCacheTest, eviction) {
+  constexpr uint64_t kRamBytes = 64UL << 20;
+  initializeCache(kRamBytes);
+
+  constexpr int32_t kEntrySize = 64 * 1'024;
+  constexpr int32_t kNumEntries = 32;
+
+  enum class EntryType { kContiguous, kNonContiguous, kMixed };
+
+  struct TestParam {
+    EntryType entryType;
+    std::string debugString() const {
+      switch (entryType) {
+        case EntryType::kContiguous:
+          return "contiguous";
+        case EntryType::kNonContiguous:
+          return "nonContiguous";
+        case EntryType::kMixed:
+          return "mixed";
+      }
+      VELOX_UNREACHABLE();
+    }
+  };
+
+  std::vector<TestParam> testSettings = {
+      {EntryType::kContiguous},
+      {EntryType::kNonContiguous},
+      {EntryType::kMixed},
+  };
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    std::vector<CachePin> pins;
+    for (int i = 0; i < kNumEntries; ++i) {
+      bool contiguous = false;
+      switch (testData.entryType) {
+        case EntryType::kContiguous:
+          contiguous = true;
+          break;
+        case EntryType::kNonContiguous:
+          contiguous = false;
+          break;
+        case EntryType::kMixed:
+          contiguous = (i % 2 == 0);
+          break;
+      }
+      RawFileCacheKey key{
+          filenames_[0].id(), static_cast<uint64_t>(i) * kEntrySize};
+      auto pin = cache_->findOrCreate(key, kEntrySize, contiguous);
+      ASSERT_FALSE(pin.empty());
+      auto* entry = pin.checkedEntry();
+      ASSERT_TRUE(entry->isExclusive());
+      if (contiguous) {
+        ASSERT_TRUE(entry->hasContiguousData());
+        ::memset(entry->contiguousData(), static_cast<int>(i), kEntrySize);
+      }
+      entry->setExclusiveToShared();
+      pins.push_back(std::move(pin));
+    }
+    ASSERT_EQ(pins.size(), kNumEntries);
+
+    auto statsBefore = cache_->refreshStats();
+    ASSERT_EQ(statsBefore.numEntries, kNumEntries);
+    const auto evictsBefore = statsBefore.numEvict;
+
+    pins.clear();
+
+    auto freed = cache_->shrink(kRamBytes);
+    ASSERT_GT(freed, 0);
+
+    auto statsAfter = cache_->refreshStats();
+    ASSERT_EQ(statsAfter.numEntries, 0);
+    ASSERT_GE(statsAfter.numEvict - evictsBefore, kNumEntries);
+  }
+}
+
+TEST_P(AsyncDataCacheTest, retryAllocation) {
+  constexpr uint64_t kRamBytes = 64UL << 20;
+  initializeCache(kRamBytes);
+
+  constexpr int32_t kEntrySize = 64 * 1'024;
+  constexpr int32_t kNumEntries = 512;
+
+  enum class EntryType { kContiguous, kNonContiguous, kMixed };
+
+  struct TestParam {
+    EntryType entryType;
+    std::string debugString() const {
+      switch (entryType) {
+        case EntryType::kContiguous:
+          return "contiguous";
+        case EntryType::kNonContiguous:
+          return "nonContiguous";
+        case EntryType::kMixed:
+          return "mixed";
+      }
+      VELOX_UNREACHABLE();
+    }
+  };
+
+  std::vector<TestParam> testSettings = {
+      {EntryType::kContiguous},
+      {EntryType::kNonContiguous},
+      {EntryType::kMixed},
+  };
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    // Fill the cache with entries.
+    std::vector<CachePin> pins;
+    for (int i = 0; i < kNumEntries; ++i) {
+      bool contiguous = false;
+      switch (testData.entryType) {
+        case EntryType::kContiguous:
+          contiguous = true;
+          break;
+        case EntryType::kNonContiguous:
+          contiguous = false;
+          break;
+        case EntryType::kMixed:
+          contiguous = (i % 2 == 0);
+          break;
+      }
+      RawFileCacheKey key{
+          filenames_[0].id(), static_cast<uint64_t>(i) * kEntrySize};
+      auto pin = cache_->findOrCreate(key, kEntrySize, contiguous);
+      ASSERT_FALSE(pin.empty());
+      auto* entry = pin.checkedEntry();
+      if (contiguous) {
+        ::memset(entry->contiguousData(), 0xAB, kEntrySize);
+      }
+      entry->setExclusiveToShared();
+      pins.push_back(std::move(pin));
+    }
+
+    // Unpin so entries are evictable.
+    pins.clear();
+
+    auto statsBefore = cache_->refreshStats();
+    ASSERT_EQ(statsBefore.numEntries, kNumEntries);
+
+    auto* allocator = cache_->allocator();
+
+    // Allocate non-contiguous pages through the allocator directly.
+    // Request more than what's free to force eviction via makeSpace.
+    constexpr uint64_t kAllocBytes = 48UL << 20;
+    memory::Allocation allocation;
+    ASSERT_TRUE(allocator->allocateNonContiguous(
+        memory::AllocationTraits::numPages(kAllocBytes), allocation));
+
+    auto statsAfter = cache_->refreshStats();
+    ASSERT_GT(statsAfter.numEvict, statsBefore.numEvict);
+
+    allocator->freeNonContiguous(allocation);
+
+    cache_->clear();
+    auto statsFinal = cache_->refreshStats();
+    ASSERT_EQ(statsFinal.numEntries, 0);
+  }
+}
+
+TEST_P(AsyncDataCacheTest, makePins) {
+  constexpr uint64_t kRamBytes = 64UL << 20;
+  initializeCache(kRamBytes);
+
+  constexpr int32_t kEntrySize = 8'192;
+
+  struct TestParam {
+    int numEntries;
+    bool contiguous;
+    std::string debugString() const {
+      return fmt::format(
+          "numEntries {}, contiguous {}", numEntries, contiguous);
+    }
+  };
+
+  std::vector<TestParam> testSettings = {
+      {1, false},
+      {1, true},
+      {10, false},
+      {10, true},
+      {100, false},
+      {100, true},
+  };
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    std::vector<RawFileCacheKey> keys;
+    keys.reserve(testData.numEntries);
+    for (int i = 0; i < testData.numEntries; ++i) {
+      keys.push_back(
+          {filenames_[0].id(), static_cast<uint64_t>(i) * kEntrySize});
+    }
+
+    std::vector<CachePin> pins;
+    cache_->makePins(
+        keys,
+        [&](size_t /*i*/) { return kEntrySize; },
+        [&](size_t /*i*/, CachePin&& pin) { pins.push_back(std::move(pin)); },
+        testData.contiguous);
+
+    ASSERT_EQ(pins.size(), testData.numEntries);
+    for (auto& pin : pins) {
+      auto* entry = pin.checkedEntry();
+      ASSERT_TRUE(entry->isExclusive());
+      test::AsyncDataCacheEntryTestHelper entryHelper(entry);
+      if (testData.contiguous) {
+        ASSERT_TRUE(entryHelper.isContiguousData());
+        ASSERT_TRUE(entry->hasContiguousData());
+        ASSERT_EQ(entry->contiguousDataSize(), kEntrySize);
+      } else {
+        ASSERT_FALSE(entryHelper.isContiguousData());
+        ASSERT_FALSE(entry->hasContiguousData());
+      }
+      entry->setExclusiveToShared();
+    }
+    pins.clear();
+    cache_->clear();
+  }
+}
+
+TEST_P(AsyncDataCacheTest, removeFileEntries) {
+  constexpr uint64_t kRamBytes = 64UL << 20;
+  initializeCache(kRamBytes);
+
+  constexpr int32_t kEntrySize = 8'192;
+  constexpr int kNumEntries = 10;
+
+  struct TestParam {
+    bool contiguous;
+    std::string debugString() const {
+      return fmt::format("contiguous {}", contiguous);
+    }
+  };
+
+  std::vector<TestParam> testSettings = {{false}, {true}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    for (int i = 0; i < kNumEntries; ++i) {
+      RawFileCacheKey key{
+          filenames_[0].id(), static_cast<uint64_t>(i) * kEntrySize};
+      auto pin = cache_->findOrCreate(key, kEntrySize, testData.contiguous);
+      ASSERT_FALSE(pin.empty());
+      auto* entry = pin.checkedEntry();
+      if (testData.contiguous) {
+        ::memset(entry->contiguousData(), 0xCD, kEntrySize);
+      }
+      entry->setExclusiveToShared();
+    }
+
+    auto statsBefore = cache_->refreshStats();
+    ASSERT_EQ(statsBefore.numEntries, kNumEntries);
+    ASSERT_GT(statsBefore.largeSize, 0);
+
+    folly::F14FastSet<uint64_t> filesToRemove;
+    filesToRemove.insert(filenames_[0].id());
+    folly::F14FastSet<uint64_t> filesRetained;
+    cache_->removeFileEntries(filesToRemove, filesRetained);
+    ASSERT_TRUE(filesRetained.empty());
+
+    auto statsAfter = cache_->refreshStats();
+    ASSERT_EQ(statsAfter.numEntries, 0);
+    ASSERT_EQ(statsAfter.largeSize, 0);
+    ASSERT_EQ(statsAfter.tinySize, 0);
+  }
+}
+
+TEST_P(AsyncDataCacheTest, mixedBufferFuzz) {
+  constexpr uint64_t kRamBytes = 256UL << 20;
+  constexpr int32_t kNumThreads = 8;
+  constexpr int32_t kNumKeys = 200;
+  constexpr int32_t kTestDurationMs = 20'000;
+
+  initializeCache(kRamBytes);
+
+  // Per-key properties are deterministic so all threads agree.
+  struct KeyProps {
+    int64_t size;
+    bool contiguous;
+  };
+  std::vector<KeyProps> keyProps(kNumKeys);
+  {
+    std::mt19937 rng(42);
+    for (int i = 0; i < kNumKeys; ++i) {
+      switch (i % 3) {
+        case 0:
+          keyProps[i].size = 512 + (rng() % 1'024);
+          break;
+        case 1:
+          keyProps[i].size =
+              AsyncDataCacheEntry::kTinyDataSize + (rng() % (64 * 1'024));
+          break;
+        default:
+          // Large entries ensure total data exceeds cache capacity,
+          // triggering eviction.
+          keyProps[i].size = 1'024 * 1'024 + (rng() % (3 * 1'024 * 1'024));
+          break;
+      }
+      keyProps[i].contiguous = (i % 2 == 0);
+    }
+  }
+
+  struct EntryState {
+    uint8_t pattern{0};
+  };
+
+  std::mutex stateMutex;
+  std::unordered_map<uint64_t, EntryState> entryStates;
+
+  std::atomic_bool stop{false};
+
+  auto workerFunc = [&](int32_t threadId) {
+    std::mt19937 rng(threadId * 7 + 13);
+    while (!stop.load(std::memory_order_relaxed)) {
+      const auto keyIdx = rng() % kNumKeys;
+      const uint64_t offset = keyIdx * 128 * 1'024;
+      RawFileCacheKey key{filenames_[0].id(), offset};
+
+      const auto& props = keyProps[keyIdx];
+      const uint8_t pattern = static_cast<uint8_t>(rng());
+
+      folly::SemiFuture<bool> waitFuture(false);
+      auto pin =
+          cache_->findOrCreate(key, props.size, props.contiguous, &waitFuture);
+      if (pin.empty()) {
+        continue;
+      }
+      auto* entry = pin.checkedEntry();
+      ASSERT_EQ(entry->size(), props.size);
+
+      if (entry->isExclusive()) {
+        if (entry->hasContiguousData()) {
+          ::memset(entry->contiguousData(), pattern, entry->size());
+        } else {
+          for (auto& range : entry->dataRanges(entry->size())) {
+            ::memset(range.data(), pattern, range.size());
+          }
+        }
+        {
+          // Record state before making shared so other threads always
+          // find the state when they get a shared pin.
+          std::lock_guard<std::mutex> l(stateMutex);
+          entryStates[offset] = {pattern};
+        }
+        entry->setExclusiveToShared();
+      } else {
+        EntryState expected;
+        {
+          std::lock_guard<std::mutex> l(stateMutex);
+          auto it = entryStates.find(offset);
+          ASSERT_NE(it, entryStates.end());
+          expected = it->second;
+        }
+
+        if (entry->hasContiguousData()) {
+          const auto* data = entry->contiguousData();
+          for (int i = 0; i < entry->size(); ++i) {
+            ASSERT_EQ(static_cast<uint8_t>(data[i]), expected.pattern)
+                << "Data mismatch at offset " << offset << " byte " << i;
+          }
+        } else {
+          int byteIdx = 0;
+          for (const auto& range : entry->dataRanges(entry->size())) {
+            for (size_t i = 0; i < range.size(); ++i) {
+              ASSERT_EQ(static_cast<uint8_t>(range.data()[i]), expected.pattern)
+                  << "Data mismatch at offset " << offset << " byte "
+                  << byteIdx;
+              ++byteIdx;
+            }
+          }
+        }
+      }
+      // Release pin immediately so eviction can reclaim it.
+    }
+  };
+
+  std::vector<std::thread> threads;
+  for (int32_t i = 0; i < kNumThreads; ++i) {
+    threads.emplace_back(workerFunc, i);
+  }
+
+  std::this_thread::sleep_for(
+      std::chrono::milliseconds(kTestDurationMs)); // NOLINT
+  stop.store(true, std::memory_order_relaxed);
+
+  for (auto& thread : threads) {
+    thread.join();
+  }
+
+  auto stats = cache_->refreshStats();
+  LOG(INFO) << "contiguousFuzz stats: " << stats.numEntries << " entries, "
+            << stats.numHit << " hits, " << stats.numNew << " new, "
+            << stats.numEvict << " evicts";
+
+  // Verify remaining entries have correct data.
+  int32_t verified = 0;
+  int32_t evicted = 0;
+  {
+    std::lock_guard<std::mutex> l(stateMutex);
+    for (const auto& [offset, expected] : entryStates) {
+      RawFileCacheKey key{filenames_[0].id(), offset};
+      auto result = cache_->find(key);
+      if (!result.has_value()) {
+        ++evicted;
+        continue;
+      }
+      ASSERT_FALSE(result->empty());
+      auto* entry = result->checkedEntry();
+      // Verify the data pattern.
+      if (entry->hasContiguousData()) {
+        const auto* data = entry->contiguousData();
+        for (int i = 0; i < entry->size(); ++i) {
+          ASSERT_EQ(static_cast<uint8_t>(data[i]), expected.pattern);
+        }
+      } else {
+        for (const auto& range : entry->dataRanges(entry->size())) {
+          for (size_t i = 0; i < range.size(); ++i) {
+            ASSERT_EQ(static_cast<uint8_t>(range.data()[i]), expected.pattern);
+          }
+        }
+      }
+      ++verified;
+    }
+  }
+
+  LOG(INFO) << "Verified " << verified << " entries, " << evicted
+            << " evicted from tracked state";
+  if (evicted > 0) {
+    ASSERT_GT(stats.numEvict, 0);
+  }
+
+  cache_->clear();
+  auto finalStats = cache_->refreshStats();
+  ASSERT_EQ(finalStats.numEntries, 0);
+}
+
 INSTANTIATE_TEST_SUITE_P(
     AsyncDataCacheTest,
     AsyncDataCacheTest,
diff --git a/velox/common/caching/tests/CMakeLists.txt b/velox/common/caching/tests/CMakeLists.txt
index c80dacb3396..2124e9cb7d1 100644
--- a/velox/common/caching/tests/CMakeLists.txt
+++ b/velox/common/caching/tests/CMakeLists.txt
@@ -19,28 +19,34 @@ target_link_libraries(
   PRIVATE velox_common_base Folly::folly velox_time glog::glog GTest::gtest GTest::gtest_main
 )
 
-add_executable(
-  velox_cache_test
+# Split velox_cache_test into individual test binaries for parallel execution.
+set(
+  VELOX_CACHE_TEST_SOURCES
   AsyncDataCacheTest.cpp
   CacheTTLControllerTest.cpp
   SsdFileTest.cpp
   SsdFileTrackerTest.cpp
   StringIdMapTest.cpp
 )
-add_test(velox_cache_test velox_cache_test)
-target_link_libraries(
-  velox_cache_test
-  PRIVATE
-    velox_caching
-    velox_file
-    velox_file_test_utils
-    velox_memory
-    velox_temp_path
-    velox_flag_definitions
-    Folly::folly
-    glog::glog
-    GTest::gtest
-    GTest::gtest_main
+
+set(
+  VELOX_CACHE_TEST_DEPS
+  velox_caching
+  velox_file
+  velox_file_test_utils
+  velox_memory
+  velox_test_util
+  velox_flag_definitions
+  Folly::folly
+  glog::glog
+  GTest::gtest
+  GTest::gtest_main
+)
+
+velox_add_grouped_tests(
+  PREFIX velox_cache_test
+  SOURCES ${VELOX_CACHE_TEST_SOURCES}
+  DEPS ${VELOX_CACHE_TEST_DEPS}
 )
 
 add_executable(cached_factory_test CachedFactoryTest.cpp)
@@ -49,3 +55,5 @@ target_link_libraries(
   cached_factory_test
   PRIVATE velox_common_base Folly::folly velox_time glog::glog GTest::gtest GTest::gtest_main
 )
+
+velox_add_library(velox_caching_test_util INTERFACE HEADERS CacheTestUtil.h)
diff --git a/velox/common/caching/tests/CacheTTLControllerTest.cpp b/velox/common/caching/tests/CacheTTLControllerTest.cpp
index 6f7f39454af..dad3c0ed504 100644
--- a/velox/common/caching/tests/CacheTTLControllerTest.cpp
+++ b/velox/common/caching/tests/CacheTTLControllerTest.cpp
@@ -31,7 +31,7 @@ class CacheTTLControllerTest : public ::testing::Test {
  protected:
   void SetUp() override {
     allocator_ = std::make_shared<MmapAllocator>(
-        MmapAllocator::Options{.capacity = 1024L * 1024L});
+        MemoryAllocator::Options{.capacity = 1024L * 1024L});
     cache_ = AsyncDataCache::create(allocator_.get());
   }
 
diff --git a/velox/common/caching/tests/CacheTestUtil.h b/velox/common/caching/tests/CacheTestUtil.h
index 731da4e876a..d848f1007c9 100644
--- a/velox/common/caching/tests/CacheTestUtil.h
+++ b/velox/common/caching/tests/CacheTestUtil.h
@@ -59,6 +59,18 @@ class SsdFileTestHelper {
     return ssdFile_->checksumReadVerificationEnabled_;
   }
 
+  SsdFile::State state() const {
+    return ssdFile_->state_.load();
+  }
+
+  void setState(SsdFile::State state) {
+    ssdFile_->state_ = state;
+  }
+
+  int32_t maxRegions() const {
+    return ssdFile_->maxRegions_;
+  }
+
   /// Deletes the backing file.
   void deleteFile() {
     process::TraceContext trace("SsdFile::testingDeleteFile");
@@ -135,6 +147,14 @@ class AsyncDataCacheEntryTestHelper {
     return asyncDataCacheEntry_->isFirstUse_;
   }
 
+  bool isTinyData() const {
+    return !asyncDataCacheEntry_->tinyData_.empty();
+  }
+
+  bool isContiguousData() const {
+    return asyncDataCacheEntry_->contiguousData_ != nullptr;
+  }
+
  private:
   AsyncDataCacheEntry* const asyncDataCacheEntry_;
 };
diff --git a/velox/common/caching/tests/SsdFileTest.cpp b/velox/common/caching/tests/SsdFileTest.cpp
index bf4f2a94fbf..c971ebc87ca 100644
--- a/velox/common/caching/tests/SsdFileTest.cpp
+++ b/velox/common/caching/tests/SsdFileTest.cpp
@@ -20,7 +20,7 @@
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/file/tests/FaultyFileSystem.h"
 #include "velox/common/memory/Memory.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 
 #include <fcntl.h>
 #include <folly/executors/IOThreadPoolExecutor.h>
@@ -31,6 +31,7 @@
 
 using namespace facebook::velox;
 using namespace facebook::velox::cache;
+using namespace facebook::velox::common::testutil;
 using namespace facebook::velox::tests::utils;
 
 using facebook::velox::memory::MemoryAllocator;
@@ -79,10 +80,9 @@ class SsdFileTest : public testing::Test {
     FLAGS_velox_ssd_odirect = false;
     cache_ = AsyncDataCache::create(memory::memoryManager()->allocator());
     cacheHelper_ =
-        std::make_unique<test::AsyncDataCacheTestHelper>(cache_.get());
+        std::make_unique<cache::test::AsyncDataCacheTestHelper>(cache_.get());
     fileName_ = StringIdLease(fileIds(), "fileInStorage");
-    tempDirectory_ =
-        exec::test::TempDirectoryPath::create(enableFaultInjection);
+    tempDirectory_ = TempDirectoryPath::create(enableFaultInjection);
     initializeSsdFile(
         ssdBytes,
         checkpointIntervalBytes,
@@ -96,7 +96,8 @@ class SsdFileTest : public testing::Test {
       uint64_t checkpointIntervalBytes = 0,
       bool checksumEnabled = false,
       bool checksumReadVerificationEnabled = false,
-      bool disableFileCow = false) {
+      bool disableFileCow = false,
+      uint64_t maxEntries = 0) {
     SsdFile::Config config(
         fmt::format("{}/ssdtest", tempDirectory_->getPath()),
         0, // shardId
@@ -105,11 +106,12 @@ class SsdFileTest : public testing::Test {
         disableFileCow,
         checksumEnabled,
         checksumReadVerificationEnabled,
+        maxEntries,
         ssdExecutor());
     ssdFile_ = std::make_unique<SsdFile>(config);
     if (ssdFile_ != nullptr) {
       ssdFileHelper_ =
-          std::make_unique<test::SsdFileTestHelper>(ssdFile_.get());
+          std::make_unique<cache::test::SsdFileTestHelper>(ssdFile_.get());
     }
   }
 
@@ -197,12 +199,12 @@ class SsdFileTest : public testing::Test {
     std::vector<CachePin> pins;
     while (bytesFromCache < totalSize) {
       pins.push_back(
-          cache_->findOrCreate(RawFileCacheKey{fileId, offset}, size, nullptr));
+          cache_->findOrCreate(RawFileCacheKey{fileId, offset}, size));
       bytesFromCache += size;
       EXPECT_FALSE(pins.back().empty());
       auto entry = pins.back().entry();
       if (entry && entry->isExclusive()) {
-        initializeContents(fileId + offset, entry->data());
+        initializeContents(fileId + offset, entry->nonContiguousData());
       }
       offset += size;
       size *= 2;
@@ -231,13 +233,14 @@ class SsdFileTest : public testing::Test {
     std::vector<SsdPin> ssdPins;
     ssdPins.reserve(pins.size());
     for (auto& pin : pins) {
-      ssdPins.push_back(ssdFile_->find(RawFileCacheKey{
-          pin.entry()->key().fileNum.id(), pin.entry()->key().offset}));
+      ssdPins.push_back(ssdFile_->find(
+          RawFileCacheKey{
+              pin.entry()->key().fileNum.id(), pin.entry()->key().offset}));
       EXPECT_FALSE(ssdPins.back().empty());
     }
     ssdFile_->load(ssdPins, pins);
     for (auto& pin : pins) {
-      checkContents(pin.entry()->data(), pin.entry()->size());
+      checkContents(pin.entry()->nonContiguousData(), pin.entry()->size());
     }
   }
 
@@ -273,7 +276,7 @@ class SsdFileTest : public testing::Test {
     EXPECT_FALSE(
         ssdFile_->find(RawFileCacheKey{fileName_.id(), ssdSize}).empty());
 
-    pins.erase(pins.begin(), pins.begin() + numWritten);
+    pins.erase(pins.cbegin(), pins.cbegin() + numWritten);
     ssdFile_->write(pins);
     for (auto& pin : pins) {
       if (pin.entry()->ssdFile()) {
@@ -299,8 +302,7 @@ class SsdFileTest : public testing::Test {
       std::vector<CachePin> pins;
       pins.push_back(cache_->findOrCreate(
           RawFileCacheKey{entry.key.fileNum.id(), entry.key.offset},
-          entry.size,
-          nullptr));
+          entry.size));
       if (pins.back().entry()->isExclusive()) {
         std::vector<SsdPin> ssdPins;
         ssdPins.push_back(ssdFile_->find(
@@ -309,21 +311,23 @@ class SsdFileTest : public testing::Test {
           ++numFound;
           ssdFile_->load(ssdPins, pins);
           checkContents(
-              pins[0].entry()->data(), pins[0].entry()->size(), expectEqual);
+              pins[0].entry()->nonContiguousData(),
+              pins[0].entry()->size(),
+              expectEqual);
         }
       }
     }
     return numFound;
   }
 
-  std::shared_ptr<exec::test::TempDirectoryPath> tempDirectory_;
+  std::shared_ptr<TempDirectoryPath> tempDirectory_;
 
   std::shared_ptr<AsyncDataCache> cache_;
-  std::unique_ptr<test::AsyncDataCacheTestHelper> cacheHelper_;
+  std::unique_ptr<cache::test::AsyncDataCacheTestHelper> cacheHelper_;
   StringIdLease fileName_;
 
   std::unique_ptr<SsdFile> ssdFile_;
-  std::unique_ptr<test::SsdFileTestHelper> ssdFileHelper_;
+  std::unique_ptr<cache::test::SsdFileTestHelper> ssdFileHelper_;
 };
 
 TEST_F(SsdFileTest, writeAndRead) {
@@ -375,9 +379,7 @@ TEST_F(SsdFileTest, writeAndRead) {
     std::vector<CachePin> pins;
 
     pins.push_back(cache_->findOrCreate(
-        RawFileCacheKey{fileName_.id(), entry.key.offset},
-        entry.size,
-        nullptr));
+        RawFileCacheKey{fileName_.id(), entry.key.offset}, entry.size));
     if (pins.back().entry()->isExclusive()) {
       std::vector<SsdPin> ssdPins;
 
@@ -385,7 +387,8 @@ TEST_F(SsdFileTest, writeAndRead) {
           ssdFile_->find(RawFileCacheKey{fileName_.id(), entry.key.offset}));
       if (!ssdPins.back().empty()) {
         ssdFile_->load(ssdPins, pins);
-        checkContents(pins[0].entry()->data(), pins[0].entry()->size());
+        checkContents(
+            pins[0].entry()->nonContiguousData(), pins[0].entry()->size());
       }
     }
   }
@@ -415,9 +418,7 @@ TEST_F(SsdFileTest, checkpoint) {
         makePins(fileName_.id(), startOffset, 4096, 2048 * 1025, 62 * kMB);
     // Each region has one entry from `fileNameAlt`.
     pins.push_back(cache_->findOrCreate(
-        RawFileCacheKey{fileNameAlt.id(), (uint64_t)startOffset},
-        1024,
-        nullptr));
+        RawFileCacheKey{fileNameAlt.id(), (uint64_t)startOffset}, 1024));
     ssdFile_->write(pins);
     for (auto& pin : pins) {
       EXPECT_EQ(ssdFile_.get(), pin.entry()->ssdFile());
@@ -442,9 +443,7 @@ TEST_F(SsdFileTest, checkpoint) {
     auto pins =
         makePins(fileName_.id(), startOffset, 4096, 2048 * 1025, 62 * kMB);
     pins.push_back(cache_->findOrCreate(
-        RawFileCacheKey{fileNameAlt.id(), (uint64_t)startOffset},
-        1024,
-        nullptr));
+        RawFileCacheKey{fileNameAlt.id(), (uint64_t)startOffset}, 1024));
     readAndCheckPins(pins);
   }
   // All entries can be found.
@@ -820,6 +819,110 @@ TEST_F(SsdFileTest, ssdReadWithoutChecksumCheck) {
 #endif
 }
 
+TEST_F(SsdFileTest, writeInNoSpaceState) {
+  constexpr int64_t kSsdSize = 16 * SsdFile::kRegionSize;
+  initializeCache(kSsdSize);
+
+  // Verify the initial state is kActive.
+  EXPECT_EQ(ssdFileHelper_->state(), SsdFile::State::kActive);
+
+  // Verify the cache write is successful in the initial kActiveState.
+  auto pins = makePins(fileName_.id(), 0, 4096, 4096, 4096 * 10);
+  ssdFile_->write(pins);
+  SsdCacheStats statsBeforeNoSpace;
+  ssdFile_->updateStats(statsBeforeNoSpace);
+  EXPECT_GT(statsBeforeNoSpace.entriesWritten, 0);
+  EXPECT_EQ(statsBeforeNoSpace.writeSsdDropped, 0);
+
+  // Set the state to kNoSpace to simulate the SSD running out of space.
+  ssdFileHelper_->setState(SsdFile::State::kNoSpace);
+  EXPECT_EQ(ssdFileHelper_->state(), SsdFile::State::kNoSpace);
+
+  // Verify that writes are dropped and no new entries are written in the
+  // kNoSpace state.
+  auto morePins = makePins(fileName_.id(), 4096 * 10, 4096, 4096, 4096 * 5);
+  ssdFile_->write(morePins);
+  SsdCacheStats statsAfterNoSpace;
+  ssdFile_->updateStats(statsAfterNoSpace);
+  EXPECT_GT(
+      statsAfterNoSpace.writeSsdDropped, statsBeforeNoSpace.writeSsdDropped);
+  EXPECT_EQ(
+      statsAfterNoSpace.entriesWritten, statsBeforeNoSpace.entriesWritten);
+
+  // Verify none of the new entries have ssdFile set.
+  for (const auto& pin : morePins) {
+    EXPECT_EQ(pin.entry()->ssdFile(), nullptr);
+  }
+}
+
+TEST_F(SsdFileTest, checkpointInNoSpaceState) {
+  constexpr int64_t kSsdSize = 4 * SsdFile::kRegionSize;
+  const uint64_t checkpointIntervalBytes = 2 * SsdFile::kRegionSize;
+  initializeCache(kSsdSize, checkpointIntervalBytes);
+
+  // Write some entries to trigger checkpoint eligibility.
+  auto pins = makePins(fileName_.id(), 0, 4096, 4096, 3 * SsdFile::kRegionSize);
+  ssdFile_->write(pins);
+
+  SsdCacheStats statsBeforeNoSpace;
+  ssdFile_->updateStats(statsBeforeNoSpace);
+
+  // Set the state to kNoSpace.
+  ssdFileHelper_->setState(SsdFile::State::kNoSpace);
+  EXPECT_EQ(ssdFileHelper_->state(), SsdFile::State::kNoSpace);
+
+  // Verify checkpointing is skipped in the kNoSpace state.
+  ssdFile_->checkpoint(true);
+
+  SsdCacheStats statsAfterNoSpace;
+  ssdFile_->updateStats(statsAfterNoSpace);
+  EXPECT_EQ(
+      statsAfterNoSpace.checkpointsWritten,
+      statsBeforeNoSpace.checkpointsWritten);
+}
+
+TEST_F(SsdFileTest, growOrEvictBlockedInNoSpaceState) {
+  constexpr int64_t kSsdSize = 4 * SsdFile::kRegionSize;
+  const uint64_t checkpointIntervalBytes = kSsdSize;
+  initializeCache(kSsdSize, checkpointIntervalBytes);
+
+  // Fill up the SSD cache to trigger eviction on subsequent writes.
+  for (auto startOffset = 0; startOffset <= kSsdSize - SsdFile::kRegionSize;
+       startOffset += SsdFile::kRegionSize) {
+    auto pins = makePins(
+        fileName_.id(), startOffset, 4096, 4096, SsdFile::kRegionSize - 1024);
+    ssdFile_->write(pins);
+  }
+
+  // The SSD cache is at max regins.
+  SsdCacheStats statsBeforeNoSpace;
+  ssdFile_->updateStats(statsBeforeNoSpace);
+  EXPECT_EQ(statsBeforeNoSpace.regionsCached, ssdFileHelper_->maxRegions());
+
+  ssdFileHelper_->setState(SsdFile::State::kNoSpace);
+  EXPECT_EQ(ssdFileHelper_->state(), SsdFile::State::kNoSpace);
+
+  // Verify the eviction should not happen since write was dropped before
+  // eviction.
+  auto newPins = makePins(fileName_.id(), kSsdSize * 2, 4096, 4096, 4096 * 5);
+  ssdFile_->write(newPins);
+
+  SsdCacheStats statsAfterNoSpace;
+  ssdFile_->updateStats(statsAfterNoSpace);
+
+  EXPECT_EQ(
+      statsAfterNoSpace.regionsEvicted, statsBeforeNoSpace.regionsEvicted);
+  EXPECT_GT(
+      statsAfterNoSpace.writeSsdDropped, statsBeforeNoSpace.writeSsdDropped);
+  EXPECT_EQ(
+      statsAfterNoSpace.entriesWritten, statsBeforeNoSpace.entriesWritten);
+
+  // Verify none of the new entries have ssdFile set.
+  for (const auto& pin : newPins) {
+    EXPECT_EQ(pin.entry()->ssdFile(), nullptr);
+  }
+}
+
 TEST_F(SsdFileTest, dataFileErrorInjection) {
   constexpr int64_t kSsdSize = 16 * SsdFile::kRegionSize;
   initializeCache(kSsdSize, 0, false, false, false, true);
@@ -868,8 +971,9 @@ TEST_F(SsdFileTest, dataFileErrorInjection) {
   std::vector<SsdPin> ssdPins;
   ssdPins.reserve(pins.size());
   for (auto& pin : pins) {
-    ssdPins.push_back(ssdFile_->find(RawFileCacheKey{
-        pin.entry()->key().fileNum.id(), pin.entry()->key().offset}));
+    ssdPins.push_back(ssdFile_->find(
+        RawFileCacheKey{
+            pin.entry()->key().fileNum.id(), pin.entry()->key().offset}));
   }
 
   SsdCacheStats statsWithReadErrorInjected;
@@ -954,6 +1058,65 @@ TEST_F(SsdFileTest, evictlogFileErrorInjection) {
   ASSERT_GT(statsAfterRecovery.readCheckpointErrors, 0);
 }
 
+TEST_F(SsdFileTest, maxEntriesLimit) {
+  constexpr int64_t kSsdSize = 16 * SsdFile::kRegionSize;
+  constexpr uint64_t kMaxEntries = 100;
+  FLAGS_velox_ssd_verify_write = true;
+
+  initializeCache(kSsdSize);
+  // Re-initialize SSD file with maxEntries limit
+  initializeSsdFile(kSsdSize, 0, false, false, false, kMaxEntries);
+
+  // Write more entries than the limit
+  auto pins = makePins(fileName_.id(), 0, 4096, 2048 * 1025, 62 * kMB);
+  ASSERT_GT(pins.size(), kMaxEntries);
+
+  ssdFile_->write(pins);
+
+  SsdCacheStats stats;
+  ssdFile_->updateStats(stats);
+
+  // The SSD file should have at most maxEntries
+  EXPECT_LE(stats.entriesCached, kMaxEntries);
+  // Some writes should have been dropped due to the entry limit
+  EXPECT_GT(stats.writeSsdExceedEntryLimit, 0);
+}
+
+TEST_F(SsdFileTest, noWritesDroppedWithinMaxEntriesLimit) {
+  constexpr int64_t kSsdSize = 16 * SsdFile::kRegionSize;
+  constexpr uint64_t kMaxEntries = 200;
+  FLAGS_velox_ssd_verify_write = true;
+
+  initializeCache(kSsdSize);
+  // Re-initialize SSD file with maxEntries limit
+  initializeSsdFile(kSsdSize, 0, false, false, false, kMaxEntries);
+
+  // Write fewer entries than the limit
+  auto pins = makePins(fileName_.id(), 0, 4096, 4096, 4096 * 50);
+  ASSERT_LT(pins.size(), kMaxEntries);
+  const auto numPins = pins.size();
+
+  ssdFile_->write(pins);
+
+  SsdCacheStats stats;
+  ssdFile_->updateStats(stats);
+
+  // All entries should be cached since we're within the limit
+  EXPECT_EQ(stats.entriesCached, numPins);
+  // No writes should be dropped due to exceeding entry limit
+  EXPECT_EQ(stats.writeSsdExceedEntryLimit, 0);
+  // No writes should be dropped due to lack of space
+  EXPECT_EQ(stats.writeSsdDropped, 0);
+  // All entries should have been written
+  EXPECT_EQ(stats.entriesWritten, numPins);
+
+  // Verify all entries are readable
+  for (auto& pin : pins) {
+    EXPECT_EQ(ssdFile_.get(), pin.entry()->ssdFile());
+  }
+  readAndCheckPins(pins);
+}
+
 #ifdef VELOX_SSD_FILE_TEST_SET_NO_COW_FLAG
 TEST_F(SsdFileTest, disabledCow) {
   constexpr int64_t kSsdSize = 16 * SsdFile::kRegionSize;
diff --git a/velox/common/caching/tests/StringIdMapTest.cpp b/velox/common/caching/tests/StringIdMapTest.cpp
index 59d95af2e88..1a1d006748a 100644
--- a/velox/common/caching/tests/StringIdMapTest.cpp
+++ b/velox/common/caching/tests/StringIdMapTest.cpp
@@ -22,7 +22,7 @@
 using namespace facebook::velox;
 
 TEST(StringIdMapTest, basic) {
-  constexpr const char* kFile1 = "file_1";
+  constexpr std::string_view kFile1 = "file_1";
   StringIdMap map;
   uint64_t id = 0;
   {
@@ -33,7 +33,7 @@ TEST(StringIdMapTest, basic) {
     id = lease2.id();
     lease1 = lease2;
     EXPECT_EQ(id, lease1.id());
-    EXPECT_EQ(strlen(kFile1), map.pinnedSize());
+    EXPECT_EQ(kFile1.size(), map.pinnedSize());
   }
   StringIdLease lease3(map, kFile1);
   EXPECT_NE(lease3.id(), id);
@@ -56,50 +56,48 @@ TEST(StringIdMapTest, rehash) {
 }
 
 TEST(StringIdMapTest, recover) {
-  constexpr const char* kRecoverFile1 = "file_1";
-  constexpr const char* kRecoverFile2 = "file_2";
-  constexpr const char* kRecoverFile3 = "file_3";
+  constexpr std::string_view kRecoverFile1("file_1");
+  constexpr std::string_view kRecoverFile2("file_2");
+  constexpr std::string_view kRecoverFile3("file_3");
   StringIdMap map;
   const uint64_t recoverId1{10};
   const uint64_t recoverId2{20};
   {
     StringIdLease lease(map, recoverId1, kRecoverFile1);
     ASSERT_TRUE(lease.hasValue());
-    ASSERT_EQ(map.pinnedSize(), ::strlen(kRecoverFile1));
+    ASSERT_EQ(map.pinnedSize(), kRecoverFile1.size());
     ASSERT_EQ(map.testingLastId(), recoverId1);
     VELOX_ASSERT_THROW(
-        std::make_unique<StringIdLease>(map, recoverId1, kRecoverFile2),
+        StringIdLease(map, recoverId1, kRecoverFile2),
         "(1 vs. 0) Reused recover id 10 assigned to file_2");
     VELOX_ASSERT_THROW(
-        std::make_unique<StringIdLease>(map, recoverId2, kRecoverFile1),
+        StringIdLease(map, recoverId2, kRecoverFile1),
         "(20 vs. 10) Multiple recover ids assigned to file_1");
   }
   ASSERT_EQ(map.pinnedSize(), 0);
 
   StringIdLease lease1(map, kRecoverFile1);
-  ASSERT_EQ(map.pinnedSize(), ::strlen(kRecoverFile1));
+  ASSERT_EQ(map.pinnedSize(), kRecoverFile1.size());
   ASSERT_EQ(map.testingLastId(), recoverId1 + 1);
 
   {
     StringIdLease lease(map, recoverId2, kRecoverFile2);
     ASSERT_TRUE(lease.hasValue());
     ASSERT_EQ(lease.id(), recoverId2);
-    ASSERT_EQ(
-        map.pinnedSize(), ::strlen(kRecoverFile1) + ::strlen(kRecoverFile2));
+    ASSERT_EQ(map.pinnedSize(), kRecoverFile1.size() + kRecoverFile2.size());
     ASSERT_EQ(map.testingLastId(), recoverId2);
     VELOX_ASSERT_THROW(
-        std::make_unique<StringIdLease>(map, recoverId2, kRecoverFile3),
+        StringIdLease(map, recoverId2, kRecoverFile3),
         "(1 vs. 0) Reused recover id 20 assigned to file_3");
     VELOX_ASSERT_THROW(
-        std::make_unique<StringIdLease>(map, recoverId2, kRecoverFile1),
+        StringIdLease(map, recoverId2, kRecoverFile1),
         "(20 vs. 11) Multiple recover ids assigned to file_1");
     StringIdLease dupLease(map, recoverId2, kRecoverFile2);
     ASSERT_TRUE(lease.hasValue());
     ASSERT_EQ(lease.id(), recoverId2);
-    ASSERT_EQ(
-        map.pinnedSize(), ::strlen(kRecoverFile1) + ::strlen(kRecoverFile2));
+    ASSERT_EQ(map.pinnedSize(), kRecoverFile1.size() + kRecoverFile2.size());
   }
 
   ASSERT_EQ(map.testingLastId(), recoverId2);
-  ASSERT_EQ(map.pinnedSize(), ::strlen(kRecoverFile1));
+  ASSERT_EQ(map.pinnedSize(), kRecoverFile1.size());
 }
diff --git a/velox/common/compression/CMakeLists.txt b/velox/common/compression/CMakeLists.txt
index d8743ce3860..bea6c0ad4e9 100644
--- a/velox/common/compression/CMakeLists.txt
+++ b/velox/common/compression/CMakeLists.txt
@@ -16,7 +16,16 @@ if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
 endif()
 
-velox_add_library(velox_common_compression Compression.cpp LzoDecompressor.cpp)
+velox_add_library(
+  velox_common_compression
+  Compression.cpp
+  LzoDecompressor.cpp
+  HEADERS
+  Compression.h
+  HadoopCompressionFormat.h
+  Lz4Compression.h
+  LzoDecompressor.h
+)
 velox_link_libraries(
   velox_common_compression
   PUBLIC velox_status Folly::folly
diff --git a/velox/common/compression/Compression.cpp b/velox/common/compression/Compression.cpp
index 8473b4fe119..4dde4b95a89 100644
--- a/velox/common/compression/Compression.cpp
+++ b/velox/common/compression/Compression.cpp
@@ -122,9 +122,10 @@ Expected<std::unique_ptr<Codec>> Codec::create(
     const CodecOptions& codecOptions) {
   if (!isAvailable(kind)) {
     auto name = compressionKindToString(kind);
-    return folly::makeUnexpected(Status::Invalid(
-        "Support for codec '{}' is either not built or not implemented.",
-        name));
+    return folly::makeUnexpected(
+        Status::Invalid(
+            "Support for codec '{}' is either not built or not implemented.",
+            name));
   }
 
   auto compressionLevel = codecOptions.compressionLevel;
@@ -155,9 +156,10 @@ Expected<std::unique_ptr<Codec>> Codec::create(
   }
   VELOX_RETURN_UNEXPECTED_IF(
       codec == nullptr,
-      Status::Invalid(fmt::format(
-          "Support for codec '{}' is either not built or not implemented.",
-          compressionKindToString(kind))));
+      Status::Invalid(
+          fmt::format(
+              "Support for codec '{}' is either not built or not implemented.",
+              compressionKindToString(kind))));
 
   VELOX_RETURN_UNEXPECTED_NOT_OK(codec->init());
 
@@ -184,8 +186,9 @@ bool Codec::isAvailable(CompressionKind kind) {
 Expected<uint64_t> Codec::getUncompressedLength(
     const uint8_t* input,
     uint64_t inputLength) const {
-  return folly::makeUnexpected(Status::Invalid(
-      "getUncompressedLength is unsupported with {} format.", name()));
+  return folly::makeUnexpected(
+      Status::Invalid(
+          "getUncompressedLength is unsupported with {} format.", name()));
 }
 
 Expected<uint64_t> Codec::compressFixedLength(
@@ -203,14 +206,16 @@ bool Codec::supportsStreamingCompression() const {
 
 Expected<std::shared_ptr<StreamingCompressor>>
 Codec::makeStreamingCompressor() {
-  return folly::makeUnexpected(Status::Invalid(
-      "Streaming compression is unsupported with {} format.", name()));
+  return folly::makeUnexpected(
+      Status::Invalid(
+          "Streaming compression is unsupported with {} format.", name()));
 }
 
 Expected<std::shared_ptr<StreamingDecompressor>>
 Codec::makeStreamingDecompressor() {
-  return folly::makeUnexpected(Status::Invalid(
-      "Streaming decompression is unsupported with {} format.", name()));
+  return folly::makeUnexpected(
+      Status::Invalid(
+          "Streaming decompression is unsupported with {} format.", name()));
 }
 
 int32_t Codec::compressionLevel() const {
diff --git a/velox/common/compression/Lz4Compression.cpp b/velox/common/compression/Lz4Compression.cpp
index 58c6ed6662f..f7bf7a66db0 100644
--- a/velox/common/compression/Lz4Compression.cpp
+++ b/velox/common/compression/Lz4Compression.cpp
@@ -588,8 +588,9 @@ Expected<uint64_t> Lz4HadoopCodec::compress(
             folly::Endian::big(static_cast<uint32_t>(inputLength));
         const uint32_t compressedLength =
             folly::Endian::big(static_cast<uint32_t>(compressedSize));
-        folly::storeUnaligned(output, decompressedLength);
-        folly::storeUnaligned(output + sizeof(uint32_t), compressedLength);
+        folly::storeUnaligned<uint32_t>(output, decompressedLength);
+        folly::storeUnaligned<uint32_t>(
+            output + sizeof(uint32_t), compressedLength);
         return kPrefixLength + compressedSize;
       });
 }
diff --git a/velox/common/config/CMakeLists.txt b/velox/common/config/CMakeLists.txt
index c2d2acd82b9..9b90fb2a890 100644
--- a/velox/common/config/CMakeLists.txt
+++ b/velox/common/config/CMakeLists.txt
@@ -16,5 +16,17 @@ if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
 endif()
 
-velox_add_library(velox_common_config Config.cpp)
+velox_add_library(velox_common_config Config.cpp HEADERS Config.h IConfig.h)
 velox_link_libraries(velox_common_config PUBLIC velox_common_base velox_exception PRIVATE re2::re2)
+
+velox_add_library(
+  velox_config_property
+  ConfigProperty.cpp
+  HEADERS
+  ConfigProperty.h
+  ConfigProvider.h
+)
+velox_link_libraries(
+  velox_config_property
+  PUBLIC velox_enum_declare velox_enum_define velox_exception
+)
diff --git a/velox/common/config/Config.cpp b/velox/common/config/Config.cpp
index 9a37fa65a08..aae7ed5ab00 100644
--- a/velox/common/config/Config.cpp
+++ b/velox/common/config/Config.cpp
@@ -15,6 +15,7 @@
  */
 
 #include <re2/re2.h>
+#include <algorithm>
 
 #include "velox/common/config/Config.h"
 
@@ -138,13 +139,18 @@ std::unordered_map<std::string, std::string> ConfigBase::rawConfigsCopy()
   return configs_;
 }
 
-std::optional<std::string> ConfigBase::get(const std::string& key) const {
-  std::optional<std::string> val;
-  std::shared_lock<std::shared_mutex> l(mutex_);
-  auto it = configs_.find(key);
-  if (it != configs_.end()) {
-    val = it->second;
+std::string ConfigBase::toConfigKey(std::string_view sessionKey) {
+  std::string configKey{sessionKey};
+  std::replace(configKey.begin(), configKey.end(), '_', '-');
+  return configKey;
+}
+
+std::optional<std::string> ConfigBase::access(const std::string& key) const {
+  std::shared_lock l{mutex_};
+  if (auto it = configs_.find(key); it != configs_.end()) {
+    return it->second;
   }
-  return val;
+  return std::nullopt;
 }
+
 } // namespace facebook::velox::config
diff --git a/velox/common/config/Config.h b/velox/common/config/Config.h
index 7aea6575a03..92985e76f4e 100644
--- a/velox/common/config/Config.h
+++ b/velox/common/config/Config.h
@@ -18,11 +18,13 @@
 
 #include <functional>
 #include <map>
+#include <mutex>
 #include <shared_mutex>
 #include <unordered_map>
 
 #include "folly/Conv.h"
 #include "velox/common/base/Exceptions.h"
+#include "velox/common/config/IConfig.h"
 
 namespace facebook::velox::config {
 
@@ -47,7 +49,7 @@ std::chrono::duration<double> toDuration(const std::string& str);
 
 /// The concrete config class should inherit the config base and define all the
 /// entries.
-class ConfigBase {
+class ConfigBase : public IConfig {
  public:
   template <typename T>
   struct Entry {
@@ -111,49 +113,51 @@ class ConfigBase {
                                   : entry.defaultVal;
   }
 
+  using IConfig::get;
+
+  bool valueExists(const std::string& key) const;
+
+  const std::unordered_map<std::string, std::string>& rawConfigs() const;
+
+  std::unordered_map<std::string, std::string> rawConfigsCopy() const final;
+
+  /// Converts a session key to another config key by replacing
+  /// '_' with '-'.
+  static std::string toConfigKey(std::string_view sessionKey);
+
+  /// Returns the value for 'key' if present; otherwise checks 'fallback'.
+  /// Fallback key is derived from 'key' by replacing '_' with '-'.
   template <typename T>
-  std::optional<T> get(
-      const std::string& key,
-      std::function<T(std::string, std::string)> toT = [](auto /* unused */,
-                                                          auto value) {
-        return folly::to<T>(value);
-      }) const {
-    auto val = get(key);
-    if (val.has_value()) {
-      return toT(key, val.value());
-    } else {
-      return std::nullopt;
+  std::optional<T> getWithFallback(
+      std::string_view key,
+      const ConfigBase& fallback) const {
+    if (auto value = get<T>(std::string(key))) {
+      return value;
     }
+    return fallback.get<T>(toConfigKey(key));
   }
 
+  /// Deprecated: Do not use in new code.
+  /// Legacy helper for key pairs that don't follow the standard
+  /// session-key('_') <-> config-key('-') naming convention.
+  /// Prefer getWithFallback(key, fallback) instead.
   template <typename T>
-  T get(
-      const std::string& key,
-      const T& defaultValue,
-      std::function<T(std::string, std::string)> toT = [](auto /* unused */,
-                                                          auto value) {
-        return folly::to<T>(value);
-      }) const {
-    auto val = get(key);
-    if (val.has_value()) {
-      return toT(key, val.value());
-    } else {
-      return defaultValue;
+  std::optional<T> getLegacyWithFallback(
+      std::string_view key,
+      const ConfigBase& fallback,
+      std::string_view fallbackKey) const {
+    if (auto value = get<T>(std::string(key))) {
+      return value;
     }
+    return fallback.get<T>(std::string(fallbackKey));
   }
 
-  bool valueExists(const std::string& key) const;
-
-  const std::unordered_map<std::string, std::string>& rawConfigs() const;
-
-  std::unordered_map<std::string, std::string> rawConfigsCopy() const;
-
  protected:
   mutable std::shared_mutex mutex_;
   std::unordered_map<std::string, std::string> configs_;
 
  private:
-  std::optional<std::string> get(const std::string& key) const;
+  std::optional<std::string> access(const std::string& key) const final;
 
   const bool mutable_;
 };
diff --git a/velox/common/config/ConfigProperty.cpp b/velox/common/config/ConfigProperty.cpp
new file mode 100644
index 00000000000..d2bee05eab6
--- /dev/null
+++ b/velox/common/config/ConfigProperty.cpp
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/config/ConfigProperty.h"
+
+#include <fmt/format.h>
+#include "velox/common/EnumDefine.h"
+
+namespace facebook::velox::config {
+
+namespace {
+
+const auto& configPropertyTypeNames() {
+  static const folly::F14FastMap<ConfigPropertyType, std::string_view> kNames =
+      {
+          {ConfigPropertyType::kBoolean, "BOOLEAN"},
+          {ConfigPropertyType::kInteger, "INTEGER"},
+          {ConfigPropertyType::kDouble, "DOUBLE"},
+          {ConfigPropertyType::kString, "STRING"},
+      };
+  return kNames;
+}
+
+} // namespace
+
+VELOX_DEFINE_ENUM_NAME(ConfigPropertyType, configPropertyTypeNames);
+
+namespace detail {
+
+std::string toStringValue(double value) {
+  return fmt::format("{}", value);
+}
+
+} // namespace detail
+
+} // namespace facebook::velox::config
diff --git a/velox/common/config/ConfigProperty.h b/velox/common/config/ConfigProperty.h
new file mode 100644
index 00000000000..09085b02507
--- /dev/null
+++ b/velox/common/config/ConfigProperty.h
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <optional>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#include "velox/common/EnumDeclare.h"
+
+namespace facebook::velox::config {
+
+enum class ConfigPropertyType {
+  kBoolean,
+  kInteger,
+  kDouble,
+  kString,
+};
+
+VELOX_DECLARE_ENUM_NAME(ConfigPropertyType);
+
+/// Describes a single configuration property: name, type, default, and
+/// human-readable description.
+struct ConfigProperty {
+  /// Property name, e.g. "session_timezone".
+  std::string name;
+
+  ConfigPropertyType type;
+
+  /// Default value as a string, or nullopt if the property has no default.
+  std::optional<std::string> defaultValue;
+
+  /// Human-readable description of the property.
+  std::string description;
+};
+
+namespace detail {
+
+std::string toStringValue(double value);
+
+template <typename T>
+constexpr ConfigPropertyType configPropertyTypeOf() {
+  if constexpr (std::is_same_v<T, bool>) {
+    return ConfigPropertyType::kBoolean;
+  } else if constexpr (std::is_integral_v<T>) {
+    return ConfigPropertyType::kInteger;
+  } else if constexpr (std::is_floating_point_v<T>) {
+    return ConfigPropertyType::kDouble;
+  } else {
+    return ConfigPropertyType::kString;
+  }
+}
+
+template <typename T>
+std::string configPropertyDefaultToString(const T& value) {
+  if constexpr (std::is_same_v<T, bool>) {
+    return value ? "true" : "false";
+  } else if constexpr (std::is_arithmetic_v<T>) {
+    if constexpr (std::is_floating_point_v<T>) {
+      return toStringValue(static_cast<double>(value));
+    } else {
+      static_assert(!std::is_same_v<T, char>, "Use int, not char.");
+      return std::to_string(value);
+    }
+  } else {
+    return std::string(value);
+  }
+}
+
+} // namespace detail
+
+/// Registers a property from a traits struct into a vector.
+/// The traits struct must have: key, type, defaultValue, description.
+template <typename PropertyTraits>
+void registerConfigProperty(std::vector<ConfigProperty>& registry) {
+  registry.push_back({
+      PropertyTraits::key,
+      detail::configPropertyTypeOf<typename PropertyTraits::type>(),
+      detail::configPropertyDefaultToString<typename PropertyTraits::type>(
+          PropertyTraits::defaultValue),
+      PropertyTraits::description,
+  });
+}
+
+} // namespace facebook::velox::config
diff --git a/velox/common/config/ConfigProvider.h b/velox/common/config/ConfigProvider.h
new file mode 100644
index 00000000000..ddc5e39c971
--- /dev/null
+++ b/velox/common/config/ConfigProvider.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/common/config/ConfigProperty.h"
+
+namespace facebook::velox::config {
+
+/// Declares and normalizes configuration properties for a component.
+/// A ConfigProvider is shared and stateless — it does not hold per-session
+/// values. It knows only its own property names (e.g., "session_timezone"),
+/// not how they are exposed to the user.
+class ConfigProvider {
+ public:
+  virtual ~ConfigProvider() = default;
+
+  /// Returns the list of supported configuration properties.
+  virtual std::vector<ConfigProperty> properties() const = 0;
+
+  /// Validates and returns the canonical form of the value. Called after
+  /// type validation. Throws if the property name is unknown or the value
+  /// is invalid.
+  virtual std::string normalize(std::string_view name, std::string_view value)
+      const = 0;
+};
+
+} // namespace facebook::velox::config
diff --git a/velox/common/config/IConfig.h b/velox/common/config/IConfig.h
new file mode 100644
index 00000000000..11cba5cc029
--- /dev/null
+++ b/velox/common/config/IConfig.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <folly/Conv.h>
+#include <optional>
+#include <string>
+#include <unordered_map>
+
+namespace facebook::velox::config {
+
+/// IConfig - Read-only config interface
+/// for accessing key-value parameters.
+/// Supports value retrieval by key and
+/// duplication of the raw configuration data.
+/// Can be used by velox::QueryConfig to access
+/// externally managed system configuration.
+class IConfig {
+ public:
+  // Do not inline this member function as lambda. Otherwise, a GCC bug
+  // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=103186 might be triggered
+  // with GCC 11.1 and 11.2.
+  // This is currently a required workaround specifically for Apache Gluten
+  // that still relies on GCC 11.2:
+  // https://github.com/apache/gluten/issues/11991. The workaround is needed
+  // until Apache Gluten migrates away from the old compiler.
+  template <typename T>
+  static T defaultToT(std::string /* unused */, std::string value) {
+    return folly::to<T>(value);
+  }
+
+  template <typename T>
+  std::optional<T> get(
+      const std::string& key,
+      const std::function<T(std::string, std::string)>& toT =
+          defaultToT<T>) const {
+    if (auto val = access(key)) {
+      return toT(key, *val);
+    }
+    return std::nullopt;
+  }
+
+  template <typename T>
+  T get(
+      const std::string& key,
+      const T& defaultValue,
+      const std::function<T(std::string, std::string)>& toT =
+          defaultToT<T>) const {
+    if (auto val = access(key)) {
+      return toT(key, *val);
+    }
+    return defaultValue;
+  }
+
+  virtual std::unordered_map<std::string, std::string> rawConfigsCopy()
+      const = 0;
+
+  virtual ~IConfig() = default;
+
+ private:
+  virtual std::optional<std::string> access(const std::string& key) const = 0;
+};
+
+} // namespace facebook::velox::config
diff --git a/velox/common/dynamic_registry/CMakeLists.txt b/velox/common/dynamic_registry/CMakeLists.txt
index 31b37df7083..0b8a256b7b4 100644
--- a/velox/common/dynamic_registry/CMakeLists.txt
+++ b/velox/common/dynamic_registry/CMakeLists.txt
@@ -12,7 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_dynamic_library_loader DynamicLibraryLoader.cpp)
+velox_add_library(
+  velox_dynamic_library_loader
+  DynamicLibraryLoader.cpp
+  HEADERS
+  DynamicLibraryLoader.h
+)
 
 velox_link_libraries(velox_dynamic_library_loader PRIVATE velox_exception)
 
diff --git a/velox/common/dynamic_registry/tests/DynamicLinkTest.cpp b/velox/common/dynamic_registry/tests/DynamicLinkTest.cpp
index 97672761bb8..fbade514dbd 100644
--- a/velox/common/dynamic_registry/tests/DynamicLinkTest.cpp
+++ b/velox/common/dynamic_registry/tests/DynamicLinkTest.cpp
@@ -152,8 +152,8 @@ TEST_F(DynamicLinkTest, dynamicLoadErrFunc) {
       dynamicFunctionFail(0, 0),
       "Scalar function signature is not supported: dynamic_err(BIGINT). Supported signatures: (array(bigint)) -> bigint.");
 
-  auto check = makeRowVector(
-      {makeNullableArrayVector(std::vector<std::vector<std::optional<int64_t>>>{
+  auto check = makeRowVector({makeNullableArrayVector(
+      std::vector<std::vector<std::optional<int64_t>>>{
           {0, 1, 3, 4, 5, 6, 7, 8, 9}})});
 
   // Expecting a success because we are passing in an array.
diff --git a/velox/common/encode/Base32.cpp b/velox/common/encode/Base32.cpp
new file mode 100644
index 00000000000..b43a2b03f0a
--- /dev/null
+++ b/velox/common/encode/Base32.cpp
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/encode/Base32.h"
+
+#include <folly/Expected.h>
+#include <cctype>
+#include <cstdint>
+
+#include "velox/common/base/CheckedArithmetic.h"
+#include "velox/common/base/Exceptions.h"
+
+namespace facebook::velox::encoding {
+
+// Reverse lookup table for decoding. 255 means invalid character.
+// Only uppercase letters (A-Z) and digits 2-7 are valid per RFC 4648.
+// Lowercase letters are NOT supported (matching Google Guava's
+// BaseEncoding.base32()).
+constexpr const Base32::ReverseIndex kBase32ReverseIndexTable = {
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 0-15
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 16-31
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 32-47
+    255, 255, 26,  27,  28,  29,  30,  31,  255,
+    255, 255, 255, 255, 255, 255, 255, // 48-63 ('2'-'7')
+    255, 0,   1,   2,   3,   4,   5,   6,   7,
+    8,   9,   10,  11,  12,  13,  14, // 64-79 ('A'-'O')
+    15,  16,  17,  18,  19,  20,  21,  22,  23,
+    24,  25,  255, 255, 255, 255, 255, // 80-95 ('P'-'Z')
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 96-111 (lowercase 'a'-'o' - INVALID)
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 112-127 (lowercase 'p'-'z' - INVALID)
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 128-143
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 144-159
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 160-175
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 176-191
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 192-207
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 208-223
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 224-239
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255 // 240-255
+};
+
+// static
+folly::Expected<uint8_t, Status> Base32::base32ReverseLookup(
+    char encodedChar,
+    const ReverseIndex& reverseIndex) {
+  auto index = reverseIndex[static_cast<uint8_t>(encodedChar)];
+  if (index >= 32) {
+    return folly::makeUnexpected(
+        Status::UserError("Unrecognized character: {}", encodedChar));
+  }
+  return index;
+}
+
+// static
+folly::Expected<size_t, Status> Base32::calculateDecodedSize(
+    const char* input,
+    const size_t inputSize) {
+  if (inputSize == 0) {
+    return 0;
+  }
+
+  // Count valid (non-padding, non-whitespace) characters and validate them
+  size_t validCharCount = 0;
+  for (size_t i = 0; i < inputSize; ++i) {
+    char c = input[i];
+    if (c == Base32::kPadding || std::isspace(static_cast<unsigned char>(c))) {
+      continue;
+    }
+
+    // Validate character first
+    auto index = kBase32ReverseIndexTable[static_cast<uint8_t>(c)];
+    if (index >= 32) {
+      return folly::makeUnexpected(
+          Status::UserError("Unrecognized character: {}", c));
+    }
+    validCharCount++;
+  }
+
+  // Validate input length matches Google Guava's Base32 behavior.
+  // Base32 encoding groups characters into quantums of 8 characters (40 bits).
+  // Valid character counts (mod 8) are: 0, 2, 4, 5, 7
+  // Invalid character counts (mod 8) are: 1, 3, 6
+  // These invalid counts leave too many incomplete bits that cannot form
+  // complete bytes.
+  if (validCharCount > 0) {
+    size_t remainder = validCharCount % 8;
+    if (remainder == 1 || remainder == 3 || remainder == 6) {
+      return folly::makeUnexpected(
+          Status::UserError("Invalid input length {}", validCharCount));
+    }
+  }
+
+  // Calculate decoded size
+  // Each base32 character represents 5 bits
+  // We need to convert to bytes (8 bits each)
+  size_t totalBits = checkedMultiply(validCharCount, size_t(5));
+  size_t decodedSize = totalBits / 8;
+
+  return decodedSize;
+}
+
+// static
+Status Base32::decode(
+    const char* input,
+    size_t inputSize,
+    char* outputBuffer,
+    size_t outputSize) {
+  auto decodedSize = decodeImpl(
+      input, inputSize, outputBuffer, outputSize, kBase32ReverseIndexTable);
+  if (decodedSize.hasError()) {
+    return decodedSize.error();
+  }
+  return Status::OK();
+}
+
+// Decodes Base32 input using the provided reverse lookup table.
+// This is the core decoding implementation that accumulates 5-bit values
+// from Base32 characters and outputs 8-bit bytes.
+// static
+folly::Expected<size_t, Status> Base32::decodeImpl(
+    const char* input,
+    size_t inputSize,
+    char* outputBuffer,
+    size_t outputSize,
+    const ReverseIndex& reverseIndex) {
+  if (inputSize == 0) {
+    return 0;
+  }
+
+  size_t outputPos = 0;
+  uint64_t accumulator = 0;
+  size_t bitsAccumulated = 0;
+
+  for (size_t i = 0; i < inputSize; ++i) {
+    char c = input[i];
+
+    // Skip padding and whitespace (RFC 4648 allows whitespace in encoded data)
+    if (c == Base32::kPadding || std::isspace(static_cast<unsigned char>(c))) {
+      continue;
+    }
+
+    // Validate and convert character to 5-bit value
+    auto value = base32ReverseLookup(c, reverseIndex);
+    if (value.hasError()) {
+      return folly::makeUnexpected(value.error());
+    }
+
+    // Accumulate 5 bits from each Base32 character
+    // Each character contributes 5 bits to the bit accumulator
+    accumulator = (accumulator << 5) | value.value();
+    bitsAccumulated += 5;
+
+    // Extract full bytes (8 bits) when we have accumulated enough bits
+    if (bitsAccumulated >= 8) {
+      if (outputPos >= outputSize) {
+        return folly::makeUnexpected(
+            Status::UserError("Output buffer too small"));
+      }
+      outputBuffer[outputPos++] =
+          static_cast<char>((accumulator >> (bitsAccumulated - 8)) & 0xFF);
+      bitsAccumulated -= 8;
+    }
+  }
+
+  return outputPos;
+}
+
+} // namespace facebook::velox::encoding
diff --git a/velox/common/encode/Base32.h b/velox/common/encode/Base32.h
new file mode 100644
index 00000000000..246a60d7994
--- /dev/null
+++ b/velox/common/encode/Base32.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <folly/Range.h>
+
+#include <array>
+#include <string>
+
+#include "velox/common/base/Status.h"
+
+namespace facebook::velox::encoding {
+
+class Base32 {
+ public:
+  static const size_t kCharsetSize = 32;
+  static const size_t kReverseIndexSize = 256;
+
+  /// Character set used for Base32 encoding.
+  /// Contains specific characters that form the encoding scheme.
+  using Charset = std::array<char, kCharsetSize>;
+
+  /// Reverse lookup table for decoding.
+  /// Maps each possible encoded character to its corresponding numeric value
+  /// within the encoding base.
+  using ReverseIndex = std::array<uint8_t, kReverseIndexSize>;
+
+  /// Decodes the specified number of characters from the 'input' and writes the
+  /// result to the 'outputBuffer'.
+  static Status decode(
+      const char* input,
+      size_t inputSize,
+      char* outputBuffer,
+      size_t outputSize);
+
+  /// Calculates the decoded size based on encoded input.
+  static folly::Expected<size_t, Status> calculateDecodedSize(
+      const char* input,
+      const size_t inputSize);
+
+  // Padding character used in encoding.
+  static const char kPadding = '=';
+
+  // Constants defining the size in bytes of binary and encoded blocks for
+  // Base32 encoding. Size of a binary block in bytes (5 bytes = 40 bits)
+  static const int kBinaryBlockByteSize = 5;
+  // Size of an encoded block in bytes (8 bytes = 40 bits)
+  static const int kEncodedBlockByteSize = 8;
+
+ private:
+  // Reverse lookup helper function to get the original index of a Base32
+  // character.
+  static folly::Expected<uint8_t, Status> base32ReverseLookup(
+      char encodedChar,
+      const ReverseIndex& reverseIndex);
+
+  // Decodes the specified data using the provided reverse lookup table.
+  static folly::Expected<size_t, Status> decodeImpl(
+      const char* input,
+      size_t inputSize,
+      char* outputBuffer,
+      size_t outputSize,
+      const ReverseIndex& reverseIndex);
+};
+
+} // namespace facebook::velox::encoding
diff --git a/velox/common/encode/Base64.cpp b/velox/common/encode/Base64.cpp
index aa521a57d47..2b87fd141ab 100644
--- a/velox/common/encode/Base64.cpp
+++ b/velox/common/encode/Base64.cpp
@@ -187,14 +187,13 @@ size_t Base64::calculateEncodedSize(size_t inputSize, bool withPadding) {
 
 // static
 void Base64::encode(const char* input, size_t inputSize, char* output) {
-  encodeImpl(
-      folly::StringPiece(input, inputSize), kBase64Charset, true, output);
+  encodeImpl(std::string_view(input, inputSize), kBase64Charset, true, output);
 }
 
 // static
 void Base64::encodeUrl(const char* input, size_t inputSize, char* output) {
   encodeImpl(
-      folly::StringPiece(input, inputSize), kBase64UrlCharset, true, output);
+      std::string_view(input, inputSize), kBase64UrlCharset, true, output);
 }
 
 // static
@@ -249,13 +248,13 @@ void Base64::encodeImpl(
 }
 
 // static
-std::string Base64::encode(folly::StringPiece text) {
+std::string Base64::encode(std::string_view text) {
   return encodeImpl(text, kBase64Charset, true);
 }
 
 // static
 std::string Base64::encode(const char* input, size_t inputSize) {
-  return encode(folly::StringPiece(input, inputSize));
+  return encode(std::string_view(input, inputSize));
 }
 
 namespace {
@@ -308,7 +307,7 @@ std::string Base64::encode(const folly::IOBuf* inputBuffer) {
 }
 
 // static
-std::string Base64::decode(folly::StringPiece encodedText) {
+std::string Base64::decode(std::string_view encodedText) {
   std::string decodedResult;
   decode(std::make_pair(encodedText.data(), encodedText.size()), decodedResult);
   return decodedResult;
@@ -346,9 +345,10 @@ Expected<uint8_t> Base64::base64ReverseLookup(
     const ReverseIndex& reverseIndex) {
   auto reverseLookupValue = reverseIndex[static_cast<uint8_t>(encodedChar)];
   if (reverseLookupValue >= 0x40) {
-    return folly::makeUnexpected(Status::UserError(
-        "decode() - invalid input string: invalid character '{}'",
-        encodedChar));
+    return folly::makeUnexpected(
+        Status::UserError(
+            "decode() - invalid input string: invalid character '{}'",
+            encodedChar));
   }
   return reverseLookupValue;
 }
@@ -381,8 +381,9 @@ Expected<size_t> Base64::calculateDecodedSize(
     // block size
     if (inputSize % kEncodedBlockByteSize != 0) {
       return folly::makeUnexpected(
-          Status::UserError("Base64::decode() - invalid input string: "
-                            "string length is not a multiple of 4."));
+          Status::UserError(
+              "Base64::decode() - invalid input string: "
+              "string length is not a multiple of 4."));
     }
 
     auto decodedSize =
@@ -403,9 +404,10 @@ Expected<size_t> Base64::calculateDecodedSize(
   // Adjust the needed size for extra bytes, if present
   if (extraBytes) {
     if (extraBytes == 1) {
-      return folly::makeUnexpected(Status::UserError(
-          "Base64::decode() - invalid input string: "
-          "string length cannot be 1 more than a multiple of 4."));
+      return folly::makeUnexpected(
+          Status::UserError(
+              "Base64::decode() - invalid input string: "
+              "string length cannot be 1 more than a multiple of 4."));
     }
     decodedSize += (extraBytes * kBinaryBlockByteSize) / kEncodedBlockByteSize;
   }
@@ -431,8 +433,9 @@ Expected<size_t> Base64::decodeImpl(
 
   if (outputSize < decodedSize.value()) {
     return folly::makeUnexpected(
-        Status::UserError("Base64::decode() - invalid output string: "
-                          "output string is too small."));
+        Status::UserError(
+            "Base64::decode() - invalid output string: "
+            "output string is too small."));
   }
   outputSize = decodedSize.value();
 
@@ -492,13 +495,13 @@ Expected<size_t> Base64::decodeImpl(
 }
 
 // static
-std::string Base64::encodeUrl(folly::StringPiece text) {
+std::string Base64::encodeUrl(std::string_view text) {
   return encodeImpl(text, kBase64UrlCharset, false);
 }
 
 // static
 std::string Base64::encodeUrl(const char* input, size_t inputSize) {
-  return encodeUrl(folly::StringPiece(input, inputSize));
+  return encodeUrl(std::string_view(input, inputSize));
 }
 
 // static
@@ -521,7 +524,7 @@ Status Base64::decodeUrl(
 }
 
 // static
-std::string Base64::decodeUrl(folly::StringPiece encodedText) {
+std::string Base64::decodeUrl(std::string_view encodedText) {
   std::string decodedOutput;
   decodeUrl(
       std::make_pair(encodedText.data(), encodedText.size()), decodedOutput);
@@ -628,8 +631,9 @@ Expected<size_t> Base64::calculateMimeDecodedSize(
     if (kBase64ReverseIndexTable[static_cast<uint8_t>(input[0])] >= 0x40) {
       return 0;
     }
-    return folly::makeUnexpected(Status::UserError(
-        "Input should at least have 2 bytes for base64 bytes."));
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Input should at least have 2 bytes for base64 bytes."));
   }
   auto decodedSize = inputSize;
   // Compute how many true Base64 chars.
diff --git a/velox/common/encode/Base64.h b/velox/common/encode/Base64.h
index 073cc49cd4f..7dca7d2fdbc 100644
--- a/velox/common/encode/Base64.h
+++ b/velox/common/encode/Base64.h
@@ -16,7 +16,6 @@
 
 #pragma once
 
-#include <folly/Range.h>
 #include <folly/io/IOBuf.h>
 
 #include <array>
@@ -45,7 +44,7 @@ class Base64 {
   static std::string encode(const char* input, size_t inputSize);
 
   /// Encodes the specified text.
-  static std::string encode(folly::StringPiece text);
+  static std::string encode(std::string_view text);
 
   /// Encodes the specified IOBuf data.
   static std::string encode(const folly::IOBuf* inputBuffer);
@@ -60,7 +59,7 @@ class Base64 {
   static std::string encodeUrl(const char* input, size_t inputSize);
 
   /// Encodes the specified text using URL encoding.
-  static std::string encodeUrl(folly::StringPiece text);
+  static std::string encodeUrl(std::string_view text);
 
   /// Encodes the specified IOBuf data using URL encoding.
   static std::string encodeUrl(const folly::IOBuf* inputBuffer);
@@ -72,7 +71,7 @@ class Base64 {
   encodeUrl(const char* input, size_t inputSize, char* outputBuffer);
 
   /// Decodes the input Base64 encoded string.
-  static std::string decode(folly::StringPiece encodedText);
+  static std::string decode(std::string_view encodedText);
 
   /// Decodes the specified encoded payload and writes the result to the
   /// 'output'.
@@ -94,7 +93,7 @@ class Base64 {
       size_t outputSize);
 
   /// Decodes the input Base64 URL encoded string.
-  static std::string decodeUrl(folly::StringPiece encodedText);
+  static std::string decodeUrl(std::string_view encodedText);
 
   /// Decodes the specified URL encoded payload and writes the result to the
   /// 'output'.
diff --git a/velox/common/encode/ByteStream.h b/velox/common/encode/ByteStream.h
index 70bd2502513..9ebbee1054d 100644
--- a/velox/common/encode/ByteStream.h
+++ b/velox/common/encode/ByteStream.h
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #pragma once
 
 /**
@@ -26,7 +27,6 @@
 #include <glog/logging.h>
 
 #include <folly/FBString.h>
-#include <folly/Range.h>
 
 namespace facebook::velox::strings {
 
@@ -86,28 +86,28 @@ class ByteSink {
    * append() will return 0).  In particular, this may not be used for
    * non-blocking behavior.
    */
-  virtual size_t append(folly::StringPiece str) = 0;
+  virtual size_t append(std::string_view str) = 0;
   size_t append(const void* data, size_t size) {
-    return append(folly::StringPiece(static_cast<const char*>(data), size));
+    return append(std::string_view(static_cast<const char*>(data), size));
   }
 
   /**
-   * Append the given string to this ByteSink.  The string must remain
+   * Append the given string to this ByteSink. The string must remain
    * allocated (and unchanged) until the ByteSink is destroyed.
    */
-  virtual size_t appendAllocated(folly::StringPiece str) {
+  virtual size_t appendAllocated(std::string_view str) {
     return append(str);
   }
 
   /**
    * Convenience function that appends the bitwise representation of count
-   * objects starting at address obj.  The usual caveats about endianness,
+   * objects starting at address obj. The usual caveats about endianness,
    * padding apply.
    */
   template <class T>
   size_t appendBitwise(const T* obj, size_t count) {
     const size_t sz = count * sizeof(T);
-    return append(folly::StringPiece(reinterpret_cast<const char*>(obj), sz));
+    return append(std::string_view(reinterpret_cast<const char*>(obj), sz));
   }
 
   /**
@@ -185,8 +185,8 @@ class SByteSink : public ByteSink {
  public:
   explicit SByteSink(S* str) : str_(str) {}
 
-  size_t append(folly::StringPiece s) override {
-    str_->append(s.start(), s.size());
+  size_t append(std::string_view s) override {
+    str_->append(s.data(), s.size());
     return s.size();
   }
 
@@ -237,7 +237,7 @@ class ByteSource {
    * next() will return false, but bad() will also return false.  On error,
    * next() returns false, and bad() returns true.
    */
-  virtual bool next(folly::StringPiece* chunk) = 0;
+  virtual bool next(std::string_view* chunk) = 0;
 
   /**
    * Push back the last numBytes returned by the last next() call, so
@@ -316,7 +316,7 @@ class ByteSourceBuffer : public std::basic_streambuf<char> {
 class StringByteSource : public ByteSource {
  public:
   explicit StringByteSource(
-      const folly::StringPiece& str,
+      const std::string_view& str,
       size_t maxBytes = kSizeMax)
       : str_(str),
         offset_(0),
@@ -326,15 +326,17 @@ class StringByteSource : public ByteSource {
   bool bad() const override {
     return false;
   }
-  bool next(folly::StringPiece* chunk) override {
+
+  bool next(std::string_view* chunk) override {
     if (offset_ == str_.size()) {
       return false;
     }
     size_t len = std::min(str_.size() - offset_, maxBytes_);
-    chunk->reset(str_.start() + offset_, len);
+    *chunk = std::string_view(str_.data() + offset_, len);
     offset_ += len;
     return true;
   }
+
   void backUp(size_t numBytes) override {
     CHECK_LE(numBytes, maxBytes_);
     CHECK_GE(offset_, numBytes);
@@ -342,7 +344,7 @@ class StringByteSource : public ByteSource {
   }
 
  private:
-  folly::StringPiece str_;
+  std::string_view str_;
   size_t offset_;
   size_t maxBytes_;
 };
diff --git a/velox/common/encode/CMakeLists.txt b/velox/common/encode/CMakeLists.txt
index 15acfcc232a..f3ed80bb042 100644
--- a/velox/common/encode/CMakeLists.txt
+++ b/velox/common/encode/CMakeLists.txt
@@ -16,5 +16,14 @@ if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
 endif()
 
-velox_add_library(velox_encode Base64.cpp)
+velox_add_library(
+  velox_encode
+  Base64.cpp
+  Base32.cpp
+  HEADERS
+  Base32.h
+  Base64.h
+)
 velox_link_libraries(velox_encode PUBLIC velox_status Folly::folly)
+
+velox_add_library(velox_common_encode INTERFACE HEADERS ByteStream.h Coding.h UInt128.h)
diff --git a/velox/common/encode/Coding.h b/velox/common/encode/Coding.h
index 55e66d3ce91..e4edaac4bcd 100644
--- a/velox/common/encode/Coding.h
+++ b/velox/common/encode/Coding.h
@@ -109,20 +109,20 @@ class Varint {
     char buf[kMaxSize64];
     char* p = buf;
     encode(val, &p);
-    sink->append(folly::StringPiece(buf, p - buf));
+    sink->append(std::string_view(buf, p - buf));
   }
 
   static void encode128ToByteSink(UInt128 val, strings::ByteSink* sink) {
     char buf[kMaxSize128];
     char* p = buf;
     encode128(val, &p);
-    sink->append(folly::StringPiece(buf, p - buf));
+    sink->append(std::string_view(buf, p - buf));
   }
 
   // Returns true if decode can be called without causing a CHECK failure.
   // The pointers are not adjusted at all
-  static bool canDecode(folly::StringPiece src) {
-    src = src.subpiece(0, kMaxSize64);
+  static bool canDecode(std::string_view src) {
+    src = src.substr(0, kMaxSize64);
     return std::any_of(
         src.begin(), src.end(), [](char v) { return ~v & 0x80; });
   }
@@ -187,18 +187,18 @@ class Varint {
     return val;
   }
 
-  // Decode a value from a StringPiece, and advance the StringPiece.
-  static uint64_t decode(folly::StringPiece* data) {
-    const char* p = data->start();
+  // Decode a value from a string_view, and advance it.
+  static uint64_t decode(std::string_view* data) {
+    const char* p = data->data();
     uint64_t val = decode(&p, data->size());
-    data->advance(p - data->start());
+    data->remove_prefix(p - data->data());
     return val;
   }
 
-  static UInt128 decode128(folly::StringPiece* data) {
-    const char* p = data->start();
+  static UInt128 decode128(std::string_view* data) {
+    const char* p = data->data();
     UInt128 val = decode128(&p, data->size());
-    data->advance(p - data->start());
+    data->remove_prefix(p - data->data());
     return val;
   }
 
@@ -207,13 +207,13 @@ class Varint {
     uint64_t val = 0;
     int32_t shift = 0;
     int32_t max_size = kMaxSize64;
-    folly::StringPiece chunk;
+    std::string_view chunk;
     int32_t remaining = 0;
     const char* p = nullptr;
     for (;;) {
       if (remaining == 0) {
         CHECK(src->next(&chunk));
-        p = chunk.start();
+        p = chunk.data();
         remaining = chunk.size();
         DCHECK_GT(remaining, 0);
       }
@@ -238,13 +238,13 @@ class Varint {
     UInt128 val = 0;
     int32_t shift = 0;
     int32_t max_size = kMaxSize128;
-    folly::StringPiece chunk;
+    std::string_view chunk;
     int32_t remaining = 0;
     const char* p = nullptr;
     for (;;) {
       if (remaining == 0) {
         CHECK(src->next(&chunk));
-        p = chunk.start();
+        p = chunk.data();
         remaining = chunk.size();
         DCHECK_GT(remaining, 0);
       }
@@ -292,7 +292,7 @@ namespace detail {
 class ByteSinkAppender {
  public:
   /* implicit */ ByteSinkAppender(strings::ByteSink* out) : out_(out) {}
-  void operator()(folly::StringPiece sp) {
+  void operator()(std::string_view sp) {
     out_->append(sp.data(), sp.size());
   }
 
diff --git a/velox/common/encode/tests/Base64Test.cpp b/velox/common/encode/tests/Base64Test.cpp
index 91b0fcab908..bc78bd6c501 100644
--- a/velox/common/encode/tests/Base64Test.cpp
+++ b/velox/common/encode/tests/Base64Test.cpp
@@ -25,27 +25,20 @@ namespace facebook::velox::encoding {
 class Base64Test : public ::testing::Test {};
 
 TEST_F(Base64Test, fromBase64) {
-  EXPECT_EQ(
-      "Hello, World!",
-      Base64::decode(folly::StringPiece("SGVsbG8sIFdvcmxkIQ==")));
+  EXPECT_EQ("Hello, World!", Base64::decode("SGVsbG8sIFdvcmxkIQ=="));
   EXPECT_EQ(
       "Base64 encoding is fun.",
-      Base64::decode(folly::StringPiece("QmFzZTY0IGVuY29kaW5nIGlzIGZ1bi4=")));
-  EXPECT_EQ(
-      "Simple text", Base64::decode(folly::StringPiece("U2ltcGxlIHRleHQ=")));
-  EXPECT_EQ(
-      "1234567890", Base64::decode(folly::StringPiece("MTIzNDU2Nzg5MA==")));
+      Base64::decode("QmFzZTY0IGVuY29kaW5nIGlzIGZ1bi4="));
+  EXPECT_EQ("Simple text", Base64::decode("U2ltcGxlIHRleHQ="));
+  EXPECT_EQ("1234567890", Base64::decode("MTIzNDU2Nzg5MA=="));
 
   // Check encoded strings without padding
-  EXPECT_EQ(
-      "Hello, World!",
-      Base64::decode(folly::StringPiece("SGVsbG8sIFdvcmxkIQ")));
+  EXPECT_EQ("Hello, World!", Base64::decode("SGVsbG8sIFdvcmxkIQ"));
   EXPECT_EQ(
       "Base64 encoding is fun.",
-      Base64::decode(folly::StringPiece("QmFzZTY0IGVuY29kaW5nIGlzIGZ1bi4")));
-  EXPECT_EQ(
-      "Simple text", Base64::decode(folly::StringPiece("U2ltcGxlIHRleHQ")));
-  EXPECT_EQ("1234567890", Base64::decode(folly::StringPiece("MTIzNDU2Nzg5MA")));
+      Base64::decode("QmFzZTY0IGVuY29kaW5nIGlzIGZ1bi4"));
+  EXPECT_EQ("Simple text", Base64::decode("U2ltcGxlIHRleHQ"));
+  EXPECT_EQ("1234567890", Base64::decode("MTIzNDU2Nzg5MA"));
 }
 
 TEST_F(Base64Test, calculateDecodedSizeProperSize) {
diff --git a/velox/common/file/CMakeLists.txt b/velox/common/file/CMakeLists.txt
index b89a4e3a38e..27cba975037 100644
--- a/velox/common/file/CMakeLists.txt
+++ b/velox/common/file/CMakeLists.txt
@@ -14,7 +14,23 @@
 
 # for generated headers
 include_directories(.)
-velox_add_library(velox_file File.cpp FileInputStream.cpp FileSystems.cpp Utils.cpp)
+velox_add_library(
+  velox_file
+  File.cpp
+  FileInputStream.cpp
+  FileIoTracer.cpp
+  FileSystems.cpp
+  FileUtils.cpp
+  HEADERS
+  File.h
+  FileInputStream.h
+  FileIoTracer.h
+  FileSystems.h
+  FileUtils.h
+  PlainUserNameTokenProvider.h
+  Region.h
+  TokenProvider.h
+)
 velox_link_libraries(
   velox_file
   PUBLIC velox_exception Folly::folly
diff --git a/velox/common/file/File.cpp b/velox/common/file/File.cpp
index c1f1e898273..6c098636d32 100644
--- a/velox/common/file/File.cpp
+++ b/velox/common/file/File.cpp
@@ -30,6 +30,36 @@
 
 namespace facebook::velox {
 
+void IoStats::addCounter(const std::string& name, RuntimeCounter counter) {
+  auto locked = stats_.wlock();
+  auto it = locked->find(name);
+  if (it == locked->end()) {
+    auto [ptr, inserted] = locked->emplace(name, RuntimeMetric(counter.unit));
+    VELOX_CHECK(inserted);
+    ptr->second.addValue(counter.value);
+  } else {
+    VELOX_CHECK_EQ(it->second.unit, counter.unit);
+    it->second.addValue(counter.value);
+  }
+}
+
+void IoStats::merge(const IoStats& other) {
+  auto otherStats = other.stats();
+  auto locked = stats_.wlock();
+  for (const auto& [name, metric] : otherStats) {
+    auto it = locked->find(name);
+    if (it == locked->end()) {
+      locked->emplace(name, metric);
+    } else {
+      it->second.merge(metric);
+    }
+  }
+}
+
+folly::F14FastMap<std::string, RuntimeMetric> IoStats::stats() const {
+  return stats_.copy();
+}
+
 #define RETURN_IF_ERROR(func, result) \
   result = func;                      \
   if (result < 0) {                   \
@@ -60,10 +90,10 @@ T getAttribute(
 std::string ReadFile::pread(
     uint64_t offset,
     uint64_t length,
-    filesystems::File::IoStats* stats) const {
+    const FileIoContext& context) const {
   std::string buf;
   buf.resize(length);
-  auto res = pread(offset, length, buf.data(), stats);
+  auto res = pread(offset, length, buf.data(), context);
   buf.resize(res.size());
   return buf;
 }
@@ -71,7 +101,7 @@ std::string ReadFile::pread(
 uint64_t ReadFile::preadv(
     uint64_t offset,
     const std::vector<folly::Range<char*>>& buffers,
-    filesystems::File::IoStats* stats) const {
+    const FileIoContext& context) const {
   auto fileSize = size();
   uint64_t numRead = 0;
   if (offset >= fileSize) {
@@ -81,7 +111,7 @@ uint64_t ReadFile::preadv(
     auto copySize = std::min<size_t>(range.size(), fileSize - offset);
     // NOTE: skip the gap in case of coalesce io.
     if (range.data() != nullptr) {
-      pread(offset, copySize, range.data(), stats);
+      pread(offset, copySize, range.data(), context);
     }
     offset += copySize;
     numRead += copySize;
@@ -92,18 +122,17 @@ uint64_t ReadFile::preadv(
 uint64_t ReadFile::preadv(
     folly::Range<const common::Region*> regions,
     folly::Range<folly::IOBuf*> iobufs,
-    filesystems::File::IoStats* stats) const {
+    const FileIoContext& context) const {
   VELOX_CHECK_EQ(regions.size(), iobufs.size());
   uint64_t length = 0;
   for (size_t i = 0; i < regions.size(); ++i) {
     const auto& region = regions[i];
     auto& output = iobufs[i];
     output = folly::IOBuf(folly::IOBuf::CREATE, region.length);
-    pread(region.offset, region.length, output.writableData(), stats);
+    pread(region.offset, region.length, output.writableData(), context);
     output.append(region.length);
     length += region.length;
   }
-
   return length;
 }
 
@@ -111,7 +140,7 @@ std::string_view InMemoryReadFile::pread(
     uint64_t offset,
     uint64_t length,
     void* buf,
-    filesystems::File::IoStats* stats) const {
+    const FileIoContext& context) const {
   bytesRead_ += length;
   memcpy(buf, file_.data() + offset, length);
   return {static_cast<char*>(buf), length};
@@ -120,7 +149,7 @@ std::string_view InMemoryReadFile::pread(
 std::string InMemoryReadFile::pread(
     uint64_t offset,
     uint64_t length,
-    filesystems::File::IoStats* stats) const {
+    const FileIoContext& context) const {
   bytesRead_ += length;
   return std::string(file_.data() + offset, length);
 }
@@ -202,7 +231,7 @@ std::string_view LocalReadFile::pread(
     uint64_t offset,
     uint64_t length,
     void* buf,
-    filesystems::File::IoStats* stats) const {
+    const FileIoContext& context) const {
   preadInternal(offset, length, static_cast<char*>(buf));
   return {static_cast<char*>(buf), length};
 }
@@ -210,7 +239,7 @@ std::string_view LocalReadFile::pread(
 uint64_t LocalReadFile::preadv(
     uint64_t offset,
     const std::vector<folly::Range<char*>>& buffers,
-    filesystems::File::IoStats* stats) const {
+    const FileIoContext& context) const {
   // Dropped bytes sized so that a typical dropped range of 50K is not
   // too many iovecs.
   static thread_local std::vector<char> droppedBytes(16 * 1024);
@@ -267,17 +296,17 @@ uint64_t LocalReadFile::preadv(
 folly::SemiFuture<uint64_t> LocalReadFile::preadvAsync(
     uint64_t offset,
     const std::vector<folly::Range<char*>>& buffers,
-    filesystems::File::IoStats* stats) const {
+    const FileIoContext& context) const {
   if (!executor_) {
-    return ReadFile::preadvAsync(offset, buffers, stats);
+    return ReadFile::preadvAsync(offset, buffers, context);
   }
   auto [promise, future] = folly::makePromiseContract<uint64_t>();
   executor_->add([this,
                   _promise = std::move(promise),
                   _offset = offset,
                   _buffers = buffers,
-                  _stats = stats]() mutable {
-    auto delegateFuture = ReadFile::preadvAsync(_offset, _buffers, _stats);
+                  _context = context]() mutable {
+    auto delegateFuture = ReadFile::preadvAsync(_offset, _buffers, _context);
     _promise.setTry(std::move(delegateFuture).getTry());
   });
   return std::move(future);
diff --git a/velox/common/file/File.h b/velox/common/file/File.h
index 18d1c264ca7..c41451d912d 100644
--- a/velox/common/file/File.h
+++ b/velox/common/file/File.h
@@ -36,15 +36,65 @@
 
 #include <folly/Executor.h>
 #include <folly/Range.h>
+#include <folly/Synchronized.h>
+#include <folly/container/F14Map.h>
 #include <folly/futures/Future.h>
+#include <folly/io/IOBuf.h>
 
 #include "velox/common/base/Exceptions.h"
+#include "velox/common/base/RuntimeMetrics.h"
+#include "velox/common/file/FileIoTracer.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/file/Region.h"
 #include "velox/common/io/IoStatistics.h"
 
 namespace facebook::velox {
 
+/// Free form statistics for file I/O operations. The keys are arbitrary
+/// strings, and values are RuntimeMetric. This class can be used to record
+/// observability about filesystem operations.
+class IoStats {
+ public:
+  IoStats() = default;
+
+  void addCounter(const std::string& name, RuntimeCounter counter);
+
+  void merge(const IoStats& other);
+
+  folly::F14FastMap<std::string, RuntimeMetric> stats() const;
+
+ private:
+  folly::Synchronized<folly::F14FastMap<std::string, RuntimeMetric>> stats_;
+};
+
+struct FileIoContext {
+  /// Stats for IO operations.
+  IoStats* ioStats{nullptr};
+
+  /// Options for file read operations.
+  folly::F14FastMap<std::string, std::string> fileOpts;
+
+  /// Tracer for IO operations, providing call stack context.
+  std::shared_ptr<FileIoTracer> ioTracer;
+
+  /// When false, hints to the storage layer that this read should not be cached
+  /// or should be evicted soon after reading. This is useful for one-time reads
+  /// where caching would waste resources.
+  bool cacheable{false};
+
+  FileIoContext() = default;
+
+  explicit FileIoContext(
+      IoStats* stats,
+      folly::F14FastMap<std::string, std::string> fileOpts = {},
+      std::shared_ptr<FileIoTracer> tracer = nullptr,
+      bool cacheable = false)
+      : ioStats(stats),
+        fileOpts(std::move(fileOpts)),
+        ioTracer(std::move(tracer)),
+        cacheable(cacheable) {}
+};
+
 // A read-only file.  All methods in this object should be thread safe.
 class ReadFile {
  public:
@@ -52,16 +102,12 @@ class ReadFile {
 
   // Reads the data at [offset, offset + length) into the provided pre-allocated
   // buffer 'buf'. The bytes are returned as a string_view pointing to 'buf'.
-  //
-  // 'stats' is an IoStatistics pointer passed in by the caller to collect stats
-  // for this read operation.
-  //
   // This method should be thread safe.
   virtual std::string_view pread(
       uint64_t offset,
       uint64_t length,
       void* buf,
-      filesystems::File::IoStats* stats = nullptr) const = 0;
+      const FileIoContext& context = {}) const = 0;
 
   // Same as above, but returns owned data directly.
   //
@@ -69,20 +115,16 @@ class ReadFile {
   virtual std::string pread(
       uint64_t offset,
       uint64_t length,
-      filesystems::File::IoStats* stats = nullptr) const;
+      const FileIoContext& context = {}) const;
 
   // Reads starting at 'offset' into the memory referenced by the
   // Ranges in 'buffers'. The buffers are filled left to right. A
   // buffer with nullptr data will cause its size worth of bytes to be skipped.
-  //
-  // 'stats' is an IoStatistics pointer passed in by the caller to collect stats
-  // for this read operation.
-  //
   // This method should be thread safe.
   virtual uint64_t preadv(
       uint64_t /*offset*/,
       const std::vector<folly::Range<char*>>& /*buffers*/,
-      filesystems::File::IoStats* stats = nullptr) const;
+      const FileIoContext& context = {}) const;
 
   // Vectorized read API. Implementations can coalesce and parallelize.
   // The offsets don't need to be sorted.
@@ -93,30 +135,22 @@ class ReadFile {
   // by the preadv.
   // Returns the total number of bytes read, which might be different than the
   // sum of all buffer sizes (for example, if coalescing was used).
-  //
-  // 'stats' is an IoStatistics pointer passed in by the caller to collect stats
-  // for this read operation.
-  //
   // This method should be thread safe.
   virtual uint64_t preadv(
       folly::Range<const common::Region*> regions,
       folly::Range<folly::IOBuf*> iobufs,
-      filesystems::File::IoStats* stats = nullptr) const;
+      const FileIoContext& context = {}) const;
 
   /// Like preadv but may execute asynchronously and returns the read size or
   /// exception via SemiFuture. Use hasPreadvAsync() to check if the
   /// implementation is in fact asynchronous.
-  ///
-  /// 'stats' is an IoStatistics pointer passed in by the caller to collect
-  /// stats for this read operation.
-  ///
   /// This method should be thread safe.
   virtual folly::SemiFuture<uint64_t> preadvAsync(
       uint64_t offset,
       const std::vector<folly::Range<char*>>& buffers,
-      filesystems::File::IoStats* stats = nullptr) const {
+      const FileIoContext& context = {}) const {
     try {
-      return folly::SemiFuture<uint64_t>(preadv(offset, buffers, stats));
+      return folly::SemiFuture<uint64_t>(preadv(offset, buffers, context));
     } catch (const std::exception& e) {
       return folly::makeSemiFuture<uint64_t>(e);
     }
@@ -240,12 +274,12 @@ class InMemoryReadFile : public ReadFile {
       uint64_t offset,
       uint64_t length,
       void* buf,
-      filesystems::File::IoStats* stats = nullptr) const override;
+      const FileIoContext& context = {}) const override;
 
   std::string pread(
       uint64_t offset,
       uint64_t length,
-      filesystems::File::IoStats* stats) const override;
+      const FileIoContext& context = {}) const override;
 
   uint64_t size() const final {
     return file_.size();
@@ -259,6 +293,7 @@ class InMemoryReadFile : public ReadFile {
   void setShouldCoalesce(bool shouldCoalesce) {
     shouldCoalesce_ = shouldCoalesce;
   }
+
   bool shouldCoalesce() const final {
     return shouldCoalesce_;
   }
@@ -311,19 +346,19 @@ class LocalReadFile final : public ReadFile {
       uint64_t offset,
       uint64_t length,
       void* buf,
-      filesystems::File::IoStats* stats = nullptr) const final;
+      const FileIoContext& context = {}) const final;
 
   uint64_t size() const final;
 
   uint64_t preadv(
       uint64_t offset,
       const std::vector<folly::Range<char*>>& buffers,
-      filesystems::File::IoStats* stats = nullptr) const final;
+      const FileIoContext& context = {}) const final;
 
   folly::SemiFuture<uint64_t> preadvAsync(
       uint64_t offset,
       const std::vector<folly::Range<char*>>& buffers,
-      filesystems::File::IoStats* stats = nullptr) const override;
+      const FileIoContext& context = {}) const override;
 
   bool hasPreadvAsync() const override {
     return executor_ != nullptr;
diff --git a/velox/common/file/FileIoTracer.cpp b/velox/common/file/FileIoTracer.cpp
new file mode 100644
index 00000000000..b8b4a418ceb
--- /dev/null
+++ b/velox/common/file/FileIoTracer.cpp
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/file/FileIoTracer.h"
+
+#include <glog/logging.h>
+
+namespace facebook::velox {
+
+std::string IoTag::toString() const {
+  if (parent == nullptr) {
+    return name;
+  }
+  return parent->toString() + " -> " + name;
+}
+
+size_t IoTag::depth() const {
+  size_t d = 1;
+  const IoTag* p = parent;
+  while (p != nullptr) {
+    ++d;
+    p = p->parent;
+  }
+  return d;
+}
+
+const IoTag*& threadIoTag() {
+  thread_local const IoTag* tag = nullptr;
+  return tag;
+}
+
+ScopedIoTag::ScopedIoTag(std::string_view name) : tag_(name, threadIoTag()) {
+  threadIoTag() = &tag_;
+}
+
+ScopedIoTag::~ScopedIoTag() {
+  threadIoTag() = tag_.parent;
+}
+
+const IoTag& ScopedIoTag::tag() const {
+  return tag_;
+}
+
+std::string toString(IoType type) {
+  switch (type) {
+    case IoType::Read:
+      return "Read";
+    case IoType::AsyncRead:
+      return "AsyncRead";
+    case IoType::Write:
+      return "Write";
+    case IoType::AsyncWrite:
+      return "AsyncWrite";
+  }
+  return "Unknown";
+}
+
+std::ostream& operator<<(std::ostream& os, IoType type) {
+  return os << toString(type);
+}
+
+InMemoryFileIoTracer::InMemoryFileIoTracer(std::vector<IoRecord>& records)
+    : records_(records) {
+  records_.reserve(4096);
+}
+
+std::shared_ptr<InMemoryFileIoTracer> InMemoryFileIoTracer::create(
+    std::vector<IoRecord>& records) {
+  return std::shared_ptr<InMemoryFileIoTracer>(
+      new InMemoryFileIoTracer(records));
+}
+
+void InMemoryFileIoTracer::record(
+    IoType type,
+    uint64_t offset,
+    uint64_t length) {
+  IoRecord record;
+  record.type = type;
+  record.offset = offset;
+  record.length = length;
+  const IoTag* tag = threadIoTag();
+  record.tag = tag != nullptr ? tag->toString() : "";
+
+  std::lock_guard<std::mutex> lock(mutex_);
+  records_.push_back(std::move(record));
+}
+
+void InMemoryFileIoTracer::finish() {
+  LOG(INFO) << "InMemoryFileIoTracer recorded " << records_.size()
+            << " IO operations";
+}
+
+std::string IoRecord::toString() const {
+  std::string result = velox::toString(type);
+  result += " [" + std::to_string(offset) + ", " + std::to_string(length) + "]";
+  if (!tag.empty()) {
+    result += " " + tag;
+  }
+  return result;
+}
+
+} // namespace facebook::velox
diff --git a/velox/common/file/FileIoTracer.h b/velox/common/file/FileIoTracer.h
new file mode 100644
index 00000000000..a81fb7f6cb5
--- /dev/null
+++ b/velox/common/file/FileIoTracer.h
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <fmt/format.h>
+#include <cstdint>
+#include <memory>
+#include <mutex>
+#include <ostream>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace facebook::velox {
+
+/// Represents a tag in the IO call stack. Tags are linked together to form
+/// a stack trace of IO operations, useful for debugging and tracing.
+struct IoTag {
+  /// The name/label for this tag in the call stack.
+  std::string name;
+
+  /// Pointer to the parent tag in the call stack. nullptr if this is the root.
+  const IoTag* parent{nullptr};
+
+  IoTag() = default;
+
+  explicit IoTag(std::string_view tagName, const IoTag* parentTag = nullptr)
+      : name(tagName), parent(parentTag) {}
+
+  /// Returns the full call stack as a string, with tags separated by " -> ".
+  /// Example: "TableScan -> ColumnReader -> PrefixEncoding"
+  std::string toString() const;
+
+  /// Returns the depth of this tag in the call stack (1-based).
+  size_t depth() const;
+};
+
+/// Thread-local IO tag for the current call stack.
+/// Use ScopedIoTag to automatically push/pop tags.
+const IoTag*& threadIoTag();
+
+/// RAII helper to push/pop IoTag onto the thread-local stack automatically.
+/// Usage:
+///   ScopedIoTag scopedTag("ColumnReader");
+///   // threadIoTag() now points to the new tag
+///   // When scopedTag goes out of scope, threadIoTag() is restored
+class ScopedIoTag {
+ public:
+  explicit ScopedIoTag(std::string_view name);
+
+  ~ScopedIoTag();
+
+  ScopedIoTag(const ScopedIoTag&) = delete;
+  ScopedIoTag& operator=(const ScopedIoTag&) = delete;
+
+  const IoTag& tag() const;
+
+ private:
+  IoTag tag_;
+};
+
+/// Type of IO operation.
+enum class IoType {
+  Read,
+  AsyncRead,
+  Write,
+  AsyncWrite,
+};
+
+/// Returns a string representation of the IoType.
+std::string toString(IoType type);
+
+/// Stream output operator for IoType.
+std::ostream& operator<<(std::ostream& os, IoType type);
+
+/// Abstract tracer for file IO operations. Implementations can record IO
+/// operations for debugging, performance analysis, or monitoring purposes.
+/// The IO tag is captured from thread-local storage via threadIoTag().
+class FileIoTracer {
+ public:
+  virtual ~FileIoTracer() = default;
+
+  /// Records an IO operation.
+  /// @param type The type of IO operation (read, asyncRead, write, asyncWrite).
+  /// @param offset The byte offset in the file where the IO starts.
+  /// @param length The number of bytes involved in the IO operation.
+  /// Note: The IO tag is captured from threadIoTag() by the implementation.
+  virtual void record(IoType type, uint64_t offset, uint64_t length) = 0;
+
+  /// Called when all IO operations are complete.
+  /// Implementations can use this to flush buffers, finalize reports, etc.
+  virtual void finish() = 0;
+};
+
+/// Record of a single IO operation captured by InMemoryFileIoTracer.
+struct IoRecord {
+  IoType type;
+  uint64_t offset{};
+  uint64_t length{};
+  std::string tag;
+
+  /// Returns a string representation of the record.
+  /// Format: "<IoType> [<offset>, <length>] <tag>"
+  std::string toString() const;
+};
+
+/// In-memory file IO tracer that records IO operations to a vector.
+/// Useful for testing and debugging. Thread-safe.
+class InMemoryFileIoTracer : public FileIoTracer {
+ public:
+  /// Creates a new InMemoryFileIoTracer with a reference to a vector for
+  /// recording.
+  /// @param records The vector to record IO operations to.
+  static std::shared_ptr<InMemoryFileIoTracer> create(
+      std::vector<IoRecord>& records);
+
+  void record(IoType type, uint64_t offset, uint64_t length) override;
+
+  void finish() override;
+
+ private:
+  explicit InMemoryFileIoTracer(std::vector<IoRecord>& records);
+
+  std::mutex mutex_;
+  std::vector<IoRecord>& records_;
+};
+
+} // namespace facebook::velox
+
+/// fmt::formatter specialization for IoType.
+template <>
+struct fmt::formatter<facebook::velox::IoType> : fmt::formatter<std::string> {
+  auto format(facebook::velox::IoType type, fmt::format_context& ctx) const {
+    return fmt::formatter<std::string>::format(
+        facebook::velox::toString(type), ctx);
+  }
+};
diff --git a/velox/common/file/FileSystems.cpp b/velox/common/file/FileSystems.cpp
index 4c420afd4e4..ed7658e572c 100644
--- a/velox/common/file/FileSystems.cpp
+++ b/velox/common/file/FileSystems.cpp
@@ -17,6 +17,7 @@
 #include "velox/common/file/FileSystems.h"
 #include <folly/executors/CPUThreadPoolExecutor.h>
 #include <folly/synchronization/CallOnce.h>
+#include <folly/system/HardwareConcurrency.h>
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/file/File.h"
 
@@ -90,7 +91,7 @@ class LocalFileSystem : public FileSystem {
                       std::max(
                           1,
                           static_cast<int32_t>(
-                              std::thread::hardware_concurrency() / 2)),
+                              folly::available_concurrency() / 2)),
                       std::make_shared<folly::NamedThreadFactory>(
                           "LocalReadahead"))
                 : nullptr) {}
diff --git a/velox/common/file/FileSystems.h b/velox/common/file/FileSystems.h
index 337478be63b..e5c74fb5e26 100644
--- a/velox/common/file/FileSystems.h
+++ b/velox/common/file/FileSystems.h
@@ -28,11 +28,9 @@ namespace facebook::velox {
 namespace config {
 class ConfigBase;
 }
+class IoStats;
 class ReadFile;
 class WriteFile;
-namespace filesystems::File {
-class IoStats;
-}
 } // namespace facebook::velox
 
 namespace facebook::velox::filesystems {
@@ -48,10 +46,10 @@ struct FileOptions {
   /// etc.
   static constexpr folly::StringPiece kFileCreateConfig{"file-create-config"};
 
-  std::unordered_map<std::string, std::string> values;
+  std::unordered_map<std::string, std::string> values{};
   memory::MemoryPool* pool{nullptr};
   /// If specified then can be trusted to be the file size.
-  std::optional<int64_t> fileSize;
+  std::optional<int64_t> fileSize{};
 
   /// Whether to create parent directories if they don't exist.
   ///
@@ -74,7 +72,7 @@ struct FileOptions {
   std::optional<std::unordered_map<std::string, std::string>> properties{
       std::nullopt};
 
-  File::IoStats* stats{nullptr};
+  IoStats* stats{nullptr};
 
   /// A raw string that client can encode as anything they want to describe the
   /// file. For example, extraFileInfo can contain serialized file descriptors
@@ -88,6 +86,10 @@ struct FileOptions {
 
   /// A token provider that can be used to get tokens for accessing the file.
   std::shared_ptr<TokenProvider> tokenProvider{nullptr};
+
+  /// File read operations metadata that can be passed to the underlying file
+  /// system for tracking and logging purposes.
+  folly::F14FastMap<std::string, std::string> fileReadOps{};
 };
 
 /// Defines directory options
@@ -110,49 +112,6 @@ struct FileSystemOptions {
   bool readAheadEnabled{false};
 };
 
-/// Free form statistics for a file system. The keys are arbitrary strings, and
-/// values are RuntimeMetric. The underlying filesystem implementation can use
-/// this class to record observability about filesystem operations.
-namespace File {
-class IoStats {
- public:
-  IoStats() = default;
-
-  void addCounter(const std::string& name, RuntimeCounter counter) {
-    auto locked = stats_.wlock();
-    auto it = locked->find(name);
-    if (it == locked->end()) {
-      auto [ptr, inserted] = locked->emplace(name, RuntimeMetric(counter.unit));
-      VELOX_CHECK(inserted);
-      ptr->second.addValue(counter.value);
-    } else {
-      VELOX_CHECK_EQ(it->second.unit, counter.unit);
-      it->second.addValue(counter.value);
-    }
-  }
-
-  void merge(const IoStats& other) {
-    auto otherStats = other.stats();
-    auto locked = stats_.wlock();
-    for (const auto& [name, metric] : otherStats) {
-      auto it = locked->find(name);
-      if (it == locked->end()) {
-        locked->emplace(name, metric);
-      } else {
-        it->second.merge(metric);
-      }
-    }
-  }
-
-  folly::F14FastMap<std::string, RuntimeMetric> stats() const {
-    return stats_.copy();
-  }
-
- private:
-  folly::Synchronized<folly::F14FastMap<std::string, RuntimeMetric>> stats_;
-};
-} // namespace File
-
 /// An abstract FileSystem
 class FileSystem {
  public:
diff --git a/velox/common/file/Utils.cpp b/velox/common/file/FileUtils.cpp
similarity index 96%
rename from velox/common/file/Utils.cpp
rename to velox/common/file/FileUtils.cpp
index bd9bfea9dcb..74a1a7da39e 100644
--- a/velox/common/file/Utils.cpp
+++ b/velox/common/file/FileUtils.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "velox/common/file/Utils.h"
+#include "velox/common/file/FileUtils.h"
 #include "velox/common/base/Exceptions.h"
 
 namespace facebook::velox::file::utils {
diff --git a/velox/common/file/Utils.h b/velox/common/file/FileUtils.h
similarity index 100%
rename from velox/common/file/Utils.h
rename to velox/common/file/FileUtils.h
diff --git a/velox/common/file/Region.h b/velox/common/file/Region.h
index ae2ef9c8a2b..5d588479b76 100644
--- a/velox/common/file/Region.h
+++ b/velox/common/file/Region.h
@@ -17,8 +17,13 @@
 #pragma once
 
 #include <cstdint>
+#include <string>
 #include <string_view>
 
+#include <fmt/format.h>
+
+#include "velox/common/base/SuccinctPrinter.h"
+
 namespace facebook::velox::common {
 
 /// Defines a disk region to read.
@@ -35,6 +40,14 @@ struct Region {
     return offset < other.offset ||
         (offset == other.offset && length < other.length);
   }
+
+  std::string toString() const {
+    return fmt::format(
+        "Region{{offset: {}, length: {}, label: {}}}",
+        offset,
+        succinctBytes(length),
+        label);
+  }
 };
 
 } // namespace facebook::velox::common
diff --git a/velox/common/file/tests/CMakeLists.txt b/velox/common/file/tests/CMakeLists.txt
index 47b3c11e3d2..2cf06039bc6 100644
--- a/velox/common/file/tests/CMakeLists.txt
+++ b/velox/common/file/tests/CMakeLists.txt
@@ -13,10 +13,23 @@
 # limitations under the License.
 
 add_library(velox_file_test_utils TestUtils.cpp FaultyFile.cpp FaultyFileSystem.cpp)
+velox_add_test_headers(
+  velox_file_test_utils
+  FaultyFile.h
+  FaultyFileSystem.h
+  FaultyFileSystemOperations.h
+  TestUtils.h
+)
 
 target_link_libraries(velox_file_test_utils PUBLIC velox_file)
 
-add_executable(velox_file_test FileTest.cpp FileInputStreamTest.cpp UtilsTest.cpp)
+add_executable(
+  velox_file_test
+  FileTest.cpp
+  FileInputStreamTest.cpp
+  FileIoTracerTest.cpp
+  FileUtilsTest.cpp
+)
 add_test(velox_file_test velox_file_test)
 target_link_libraries(
   velox_file_test
@@ -24,7 +37,7 @@ target_link_libraries(
     velox_buffer
     velox_file
     velox_file_test_utils
-    velox_temp_path
+    velox_test_util
     GTest::gmock
     GTest::gtest
     GTest::gtest_main
diff --git a/velox/common/file/tests/FaultyFile.cpp b/velox/common/file/tests/FaultyFile.cpp
index 17897fa9921..23f59ea886f 100644
--- a/velox/common/file/tests/FaultyFile.cpp
+++ b/velox/common/file/tests/FaultyFile.cpp
@@ -34,7 +34,7 @@ std::string_view FaultyReadFile::pread(
     uint64_t offset,
     uint64_t length,
     void* buf,
-    filesystems::File::IoStats* stats) const {
+    const FileIoContext& context) const {
   if (injectionHook_ != nullptr) {
     FaultFileReadOperation op(path_, offset, length, buf);
     injectionHook_(&op);
@@ -42,13 +42,13 @@ std::string_view FaultyReadFile::pread(
       return std::string_view(static_cast<char*>(op.buf), op.length);
     }
   }
-  return delegatedFile_->pread(offset, length, buf, stats);
+  return delegatedFile_->pread(offset, length, buf, context);
 }
 
 uint64_t FaultyReadFile::preadv(
     uint64_t offset,
     const std::vector<folly::Range<char*>>& buffers,
-    filesystems::File::IoStats* stats) const {
+    const FileIoContext& context) const {
   if (injectionHook_ != nullptr) {
     FaultFileReadvOperation op(path_, offset, buffers);
     injectionHook_(&op);
@@ -56,16 +56,16 @@ uint64_t FaultyReadFile::preadv(
       return op.readBytes;
     }
   }
-  return delegatedFile_->preadv(offset, buffers, stats);
+  return delegatedFile_->preadv(offset, buffers, context);
 }
 
 folly::SemiFuture<uint64_t> FaultyReadFile::preadvAsync(
     uint64_t offset,
     const std::vector<folly::Range<char*>>& buffers,
-    filesystems::File::IoStats* stats) const {
+    const FileIoContext& context) const {
   // TODO: add fault injection for async read later.
   if (delegatedFile_->hasPreadvAsync() || executor_ == nullptr) {
-    return delegatedFile_->preadvAsync(offset, buffers, stats);
+    return delegatedFile_->preadvAsync(offset, buffers, context);
   }
   auto promise = std::make_unique<folly::Promise<uint64_t>>();
   folly::SemiFuture<uint64_t> future = promise->getSemiFuture();
@@ -73,9 +73,9 @@ folly::SemiFuture<uint64_t> FaultyReadFile::preadvAsync(
                   _promise = std::move(promise),
                   _offset = offset,
                   _buffers = buffers,
-                  _stats = stats]() {
+                  _context = context]() {
     auto delegateFuture =
-        delegatedFile_->preadvAsync(_offset, _buffers, _stats);
+        delegatedFile_->preadvAsync(_offset, _buffers, _context);
     _promise->setValue(delegateFuture.wait().value());
   });
   return future;
diff --git a/velox/common/file/tests/FaultyFile.h b/velox/common/file/tests/FaultyFile.h
index 2b4818bd7a1..7986064b9e4 100644
--- a/velox/common/file/tests/FaultyFile.h
+++ b/velox/common/file/tests/FaultyFile.h
@@ -29,7 +29,7 @@ class FaultyReadFile : public ReadFile {
       FileFaultInjectionHook injectionHook,
       folly::Executor* executor);
 
-  ~FaultyReadFile() override{};
+  ~FaultyReadFile() override {}
 
   uint64_t size() const override {
     return delegatedFile_->size();
@@ -39,12 +39,12 @@ class FaultyReadFile : public ReadFile {
       uint64_t offset,
       uint64_t length,
       void* buf,
-      filesystems::File::IoStats* stats = nullptr) const override;
+      const FileIoContext& context = {}) const override;
 
   uint64_t preadv(
       uint64_t offset,
       const std::vector<folly::Range<char*>>& buffers,
-      filesystems::File::IoStats* stats = nullptr) const override;
+      const FileIoContext& context = {}) const override;
 
   uint64_t memoryUsage() const override {
     return delegatedFile_->memoryUsage();
@@ -72,7 +72,7 @@ class FaultyReadFile : public ReadFile {
   folly::SemiFuture<uint64_t> preadvAsync(
       uint64_t offset,
       const std::vector<folly::Range<char*>>& buffers,
-      filesystems::File::IoStats* stats = nullptr) const override;
+      const FileIoContext& context = {}) const override;
 
  private:
   const std::string path_;
@@ -88,7 +88,7 @@ class FaultyWriteFile : public WriteFile {
       std::shared_ptr<WriteFile> delegatedFile,
       FileFaultInjectionHook injectionHook);
 
-  ~FaultyWriteFile() override{};
+  ~FaultyWriteFile() override {}
 
   void append(std::string_view data) override;
 
diff --git a/velox/common/file/tests/FaultyFileSystem.h b/velox/common/file/tests/FaultyFileSystem.h
index 1dbd698df66..c14cc7201ee 100644
--- a/velox/common/file/tests/FaultyFileSystem.h
+++ b/velox/common/file/tests/FaultyFileSystem.h
@@ -176,7 +176,7 @@ class FaultyFileSystem : public FileSystem {
   mutable std::mutex mu_;
   std::optional<FileInjections> fileInjections_;
   std::optional<FileSystemInjections> fsInjections_;
-  folly::Executor* executor_;
+  folly::Executor* executor_{nullptr};
 };
 
 /// Registers the faulty filesystem.
diff --git a/velox/common/file/tests/FileInputStreamTest.cpp b/velox/common/file/tests/FileInputStreamTest.cpp
index 5727b302571..4d9bc680236 100644
--- a/velox/common/file/tests/FileInputStreamTest.cpp
+++ b/velox/common/file/tests/FileInputStreamTest.cpp
@@ -19,11 +19,12 @@
 #include "velox/common/file/FileInputStream.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/memory/MmapAllocator.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 
 #include <gtest/gtest.h>
 
 using namespace facebook::velox;
+using namespace facebook::velox::common::testutil;
 using namespace facebook::velox::memory;
 
 class FileInputStreamTest : public testing::Test {
@@ -42,7 +43,7 @@ class FileInputStreamTest : public testing::Test {
     mmapAllocator_ = static_cast<MmapAllocator*>(memoryManager_->allocator());
     pool_ = memoryManager_->addLeafPool("ByteStreamTest");
     rng_.seed(124);
-    tempDirPath_ = exec::test::TempDirectoryPath::create();
+    tempDirPath_ = TempDirectoryPath::create();
     fs_ = filesystems::getFileSystem(tempDirPath_->getPath(), nullptr);
   }
 
@@ -70,7 +71,7 @@ class FileInputStreamTest : public testing::Test {
   MmapAllocator* mmapAllocator_;
   std::shared_ptr<memory::MemoryPool> pool_;
   std::atomic_uint64_t fileId_{0};
-  std::shared_ptr<exec::test::TempDirectoryPath> tempDirPath_;
+  std::shared_ptr<TempDirectoryPath> tempDirPath_;
   std::shared_ptr<filesystems::FileSystem> fs_;
 };
 
diff --git a/velox/common/file/tests/FileIoTracerTest.cpp b/velox/common/file/tests/FileIoTracerTest.cpp
new file mode 100644
index 00000000000..28429f0122d
--- /dev/null
+++ b/velox/common/file/tests/FileIoTracerTest.cpp
@@ -0,0 +1,346 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/file/FileIoTracer.h"
+
+#include <random>
+#include <thread>
+#include <unordered_map>
+
+#include "gtest/gtest.h"
+
+using namespace facebook::velox;
+
+class FileIoTracerTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    // Reset thread-local tag before each test
+    threadIoTag() = nullptr;
+  }
+
+  void TearDown() override {
+    // Ensure thread-local tag is reset after each test
+    threadIoTag() = nullptr;
+  }
+};
+
+TEST_F(FileIoTracerTest, ioTag) {
+  {
+    IoTag tag("TestTag");
+    EXPECT_EQ(tag.name, "TestTag");
+    EXPECT_EQ(tag.parent, nullptr);
+    EXPECT_EQ(tag.toString(), "TestTag");
+    EXPECT_EQ(tag.depth(), 1);
+  }
+
+  {
+    IoTag parent("Parent");
+    IoTag child("Child", &parent);
+
+    EXPECT_EQ(child.name, "Child");
+    EXPECT_EQ(child.parent, &parent);
+    EXPECT_EQ(child.toString(), "Parent -> Child");
+    EXPECT_EQ(child.depth(), 2);
+  }
+
+  {
+    IoTag tag1("Level1");
+    IoTag tag2("Level2", &tag1);
+    IoTag tag3("Level3", &tag2);
+    IoTag tag4("Level4", &tag3);
+
+    EXPECT_EQ(tag4.toString(), "Level1 -> Level2 -> Level3 -> Level4");
+    EXPECT_EQ(tag4.depth(), 4);
+    EXPECT_EQ(tag3.depth(), 3);
+    EXPECT_EQ(tag2.depth(), 2);
+    EXPECT_EQ(tag1.depth(), 1);
+  }
+}
+
+TEST_F(FileIoTracerTest, threadIoTag) {
+  {
+    EXPECT_EQ(threadIoTag(), nullptr);
+  }
+
+  {
+    EXPECT_EQ(threadIoTag(), nullptr);
+
+    {
+      ScopedIoTag tag1("Tag1");
+      EXPECT_NE(threadIoTag(), nullptr);
+      EXPECT_EQ(threadIoTag()->name, "Tag1");
+      EXPECT_EQ(threadIoTag()->parent, nullptr);
+      EXPECT_EQ(threadIoTag()->toString(), "Tag1");
+    }
+
+    EXPECT_EQ(threadIoTag(), nullptr);
+  }
+
+  {
+    EXPECT_EQ(threadIoTag(), nullptr);
+
+    {
+      ScopedIoTag tag1("TableScan");
+      EXPECT_EQ(threadIoTag()->toString(), "TableScan");
+      EXPECT_EQ(threadIoTag()->depth(), 1);
+
+      {
+        ScopedIoTag tag2("ColumnReader");
+        EXPECT_EQ(threadIoTag()->toString(), "TableScan -> ColumnReader");
+        EXPECT_EQ(threadIoTag()->depth(), 2);
+
+        {
+          ScopedIoTag tag3("PrefixEncoding");
+          EXPECT_EQ(
+              threadIoTag()->toString(),
+              "TableScan -> ColumnReader -> PrefixEncoding");
+          EXPECT_EQ(threadIoTag()->depth(), 3);
+        }
+
+        EXPECT_EQ(threadIoTag()->toString(), "TableScan -> ColumnReader");
+        EXPECT_EQ(threadIoTag()->depth(), 2);
+      }
+
+      EXPECT_EQ(threadIoTag()->toString(), "TableScan");
+      EXPECT_EQ(threadIoTag()->depth(), 1);
+    }
+
+    EXPECT_EQ(threadIoTag(), nullptr);
+  }
+
+  {
+    ScopedIoTag tag("TestTag");
+    EXPECT_EQ(tag.tag().name, "TestTag");
+    EXPECT_EQ(tag.tag().parent, nullptr);
+  }
+}
+
+TEST_F(FileIoTracerTest, threadLocalIsolation) {
+  // Verify that thread-local tags are isolated between threads
+  std::atomic_bool stop{false};
+
+  std::thread thread1([&]() {
+    ScopedIoTag tag("Thread1Tag");
+    while (!stop) {
+      EXPECT_EQ(threadIoTag()->name, "Thread1Tag");
+      std::this_thread::sleep_for(std::chrono::microseconds(100));
+    }
+  });
+
+  std::thread thread2([&]() {
+    ScopedIoTag tag("Thread2Tag");
+    while (!stop) {
+      EXPECT_EQ(threadIoTag()->name, "Thread2Tag");
+      std::this_thread::sleep_for(std::chrono::microseconds(100));
+    }
+  });
+
+  std::this_thread::sleep_for(std::chrono::seconds(2));
+  stop = true;
+
+  thread1.join();
+  thread2.join();
+}
+
+TEST_F(FileIoTracerTest, inMemoryFileIoTracer) {
+  {
+    std::vector<IoRecord> records;
+    auto tracer = InMemoryFileIoTracer::create(records);
+
+    tracer->record(IoType::Read, 100, 200);
+    ASSERT_EQ(records.size(), 1);
+    EXPECT_EQ(records[0].type, IoType::Read);
+    EXPECT_EQ(records[0].offset, 100);
+    EXPECT_EQ(records[0].length, 200);
+    EXPECT_EQ(records[0].tag, "");
+    tracer->finish();
+    ASSERT_EQ(records.size(), 1);
+    EXPECT_EQ(records[0].type, IoType::Read);
+    EXPECT_EQ(records[0].offset, 100);
+    EXPECT_EQ(records[0].length, 200);
+    EXPECT_EQ(records[0].tag, "");
+  }
+
+  {
+    std::vector<IoRecord> records;
+    auto tracer = InMemoryFileIoTracer::create(records);
+
+    {
+      ScopedIoTag tag1("TableScan");
+      tracer->record(IoType::Read, 0, 100);
+
+      {
+        ScopedIoTag tag2("ColumnReader");
+        tracer->record(IoType::AsyncRead, 100, 200);
+      }
+
+      tracer->record(IoType::Write, 300, 50);
+    }
+
+    tracer->record(IoType::AsyncWrite, 400, 75);
+
+    ASSERT_EQ(records.size(), 4);
+
+    EXPECT_EQ(records[0].type, IoType::Read);
+    EXPECT_EQ(records[0].offset, 0);
+    EXPECT_EQ(records[0].length, 100);
+    EXPECT_EQ(records[0].tag, "TableScan");
+
+    EXPECT_EQ(records[1].type, IoType::AsyncRead);
+    EXPECT_EQ(records[1].offset, 100);
+    EXPECT_EQ(records[1].length, 200);
+    EXPECT_EQ(records[1].tag, "TableScan -> ColumnReader");
+
+    EXPECT_EQ(records[2].type, IoType::Write);
+    EXPECT_EQ(records[2].offset, 300);
+    EXPECT_EQ(records[2].length, 50);
+    EXPECT_EQ(records[2].tag, "TableScan");
+
+    EXPECT_EQ(records[3].type, IoType::AsyncWrite);
+    EXPECT_EQ(records[3].offset, 400);
+    EXPECT_EQ(records[3].length, 75);
+    EXPECT_EQ(records[3].tag, "");
+  }
+}
+
+TEST_F(FileIoTracerTest, ioType) {
+  // Verify enum values exist and are distinct
+  EXPECT_NE(IoType::Read, IoType::AsyncRead);
+  EXPECT_NE(IoType::Read, IoType::Write);
+  EXPECT_NE(IoType::Read, IoType::AsyncWrite);
+  EXPECT_NE(IoType::AsyncRead, IoType::Write);
+  EXPECT_NE(IoType::AsyncRead, IoType::AsyncWrite);
+  EXPECT_NE(IoType::Write, IoType::AsyncWrite);
+}
+
+TEST_F(FileIoTracerTest, ioRecord) {
+  {
+    IoRecord record;
+    record.type = IoType::Read;
+    record.offset = 1024;
+    record.length = 4096;
+    record.tag = "TableScan -> ColumnReader";
+
+    EXPECT_EQ(record.toString(), "Read [1024, 4096] TableScan -> ColumnReader");
+  }
+
+  {
+    IoRecord record;
+    record.type = IoType::AsyncRead;
+    record.offset = 0;
+    record.length = 512;
+    record.tag = "";
+
+    EXPECT_EQ(record.toString(), "AsyncRead [0, 512]");
+  }
+
+  {
+    IoRecord record;
+    record.type = IoType::Write;
+    record.offset = 100;
+    record.length = 200;
+    record.tag = "Writer";
+
+    EXPECT_EQ(record.toString(), "Write [100, 200] Writer");
+  }
+
+  {
+    IoRecord record;
+    record.type = IoType::AsyncWrite;
+    record.offset = 500;
+    record.length = 1000;
+    record.tag = "AsyncWriter";
+
+    EXPECT_EQ(record.toString(), "AsyncWrite [500, 1000] AsyncWriter");
+  }
+}
+
+TEST_F(FileIoTracerTest, inMemoryFileIoTracerFuzz) {
+  constexpr int kNumThreads = 8;
+  constexpr int kMaxRecordsPerThread = 1'000;
+
+  std::vector<IoRecord> sharedRecords;
+  auto tracer = InMemoryFileIoTracer::create(sharedRecords);
+
+  std::vector<std::thread> threads;
+  std::vector<std::vector<IoRecord>> perThreadRecords(kNumThreads);
+  std::vector<IoType> ioTypes = {
+      IoType::Read, IoType::AsyncRead, IoType::Write, IoType::AsyncWrite};
+
+  threads.reserve(kNumThreads);
+  for (int threadIdx = 0; threadIdx < kNumThreads; ++threadIdx) {
+    threads.emplace_back([&, threadIdx]() {
+      std::mt19937 rng(threadIdx);
+      std::uniform_int_distribution<int> countDist(1, kMaxRecordsPerThread);
+      std::uniform_int_distribution<uint64_t> offsetDist(0, 1000000);
+      std::uniform_int_distribution<uint64_t> lengthDist(1, 10000);
+      std::uniform_int_distribution<int> typeDist(0, 3);
+
+      const std::string tagName = "Thread" + std::to_string(threadIdx);
+      ScopedIoTag tag(tagName);
+
+      const int numRecords = countDist(rng);
+      for (int i = 0; i < numRecords; ++i) {
+        IoRecord localRecord;
+        localRecord.type = ioTypes[typeDist(rng)];
+        localRecord.offset = offsetDist(rng);
+        localRecord.length = lengthDist(rng);
+        localRecord.tag = tagName;
+
+        perThreadRecords[threadIdx].push_back(localRecord);
+        tracer->record(
+            localRecord.type, localRecord.offset, localRecord.length);
+      }
+    });
+  }
+
+  for (auto& thread : threads) {
+    thread.join();
+  }
+
+  tracer->finish();
+
+  size_t expectedTotalRecords = 0;
+  for (const auto& threadRecords : perThreadRecords) {
+    expectedTotalRecords += threadRecords.size();
+  }
+  EXPECT_EQ(sharedRecords.size(), expectedTotalRecords);
+
+  std::unordered_map<std::string, std::vector<IoRecord>> recordsByTag;
+  for (const auto& record : sharedRecords) {
+    recordsByTag[record.tag].push_back(record);
+  }
+
+  for (int threadIdx = 0; threadIdx < kNumThreads; ++threadIdx) {
+    const std::string tagName = "Thread" + std::to_string(threadIdx);
+    const auto& expected = perThreadRecords[threadIdx];
+    const auto& actual = recordsByTag[tagName];
+
+    ASSERT_EQ(actual.size(), expected.size())
+        << "Thread " << threadIdx << " record count mismatch";
+
+    for (size_t i = 0; i < expected.size(); ++i) {
+      EXPECT_EQ(actual[i].type, expected[i].type)
+          << "Thread " << threadIdx << " record " << i << " type mismatch";
+      EXPECT_EQ(actual[i].offset, expected[i].offset)
+          << "Thread " << threadIdx << " record " << i << " offset mismatch";
+      EXPECT_EQ(actual[i].length, expected[i].length)
+          << "Thread " << threadIdx << " record " << i << " length mismatch";
+      EXPECT_EQ(actual[i].tag, expected[i].tag)
+          << "Thread " << threadIdx << " record " << i << " tag mismatch";
+    }
+  }
+}
diff --git a/velox/common/file/tests/FileTest.cpp b/velox/common/file/tests/FileTest.cpp
index 6194fbcc35b..7da4b360356 100644
--- a/velox/common/file/tests/FileTest.cpp
+++ b/velox/common/file/tests/FileTest.cpp
@@ -16,17 +16,19 @@
 
 #include <fcntl.h>
 #include <folly/executors/CPUThreadPoolExecutor.h>
+#include <folly/system/HardwareConcurrency.h>
 
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/File.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/file/tests/FaultyFileSystem.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
-#include "velox/exec/tests/utils/TempFilePath.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
+#include "velox/common/testutil/TempFilePath.h"
 
 #include "gtest/gtest.h"
 
 using namespace facebook::velox;
+using namespace facebook::velox::common::testutil;
 using facebook::velox::common::Region;
 using namespace facebook::velox::tests::utils;
 
@@ -49,6 +51,17 @@ void writeData(WriteFile* writeFile, bool useIOBuf = false) {
   }
 }
 
+TEST(FileIoContextTest, defaultCacheableIsFalse) {
+  FileIoContext defaultContext;
+  EXPECT_FALSE(defaultContext.cacheable);
+
+  FileIoContext explicitContext(nullptr);
+  EXPECT_FALSE(explicitContext.cacheable);
+
+  FileIoContext cacheableContext(nullptr, {}, nullptr, true);
+  EXPECT_TRUE(cacheableContext.cacheable);
+}
+
 void writeDataWithOffset(WriteFile* writeFile) {
   ASSERT_EQ(writeFile->size(), 0);
   writeFile->truncate(15 + kOneMB);
@@ -168,8 +181,9 @@ TEST(InMemoryFile, preadv) {
   std::vector<std::string> values;
   values.reserve(iobufs.size());
   for (auto& iobuf : iobufs) {
-    values.push_back(std::string{
-        reinterpret_cast<const char*>(iobuf.data()), iobuf.length()});
+    values.push_back(
+        std::string{
+            reinterpret_cast<const char*>(iobuf.data()), iobuf.length()});
   }
 
   EXPECT_EQ(expected, values);
@@ -187,9 +201,7 @@ class LocalFileTest : public ::testing::TestWithParam<bool> {
   const bool useFaultyFs_;
   const std::unique_ptr<folly::CPUThreadPoolExecutor> executor_ =
       std::make_unique<folly::CPUThreadPoolExecutor>(
-          std::max(
-              1,
-              static_cast<int32_t>(std::thread::hardware_concurrency() / 2)),
+          std::max(1, static_cast<int32_t>(folly::available_concurrency() / 2)),
           std::make_shared<folly::NamedThreadFactory>(
               "LocalFileReadAheadTest"));
 };
@@ -206,7 +218,7 @@ TEST_P(LocalFileTest, writeAndRead) {
   for (auto testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
 
-    auto tempFile = exec::test::TempFilePath::create(useFaultyFs_);
+    auto tempFile = TempFilePath::create(useFaultyFs_);
     const auto& filename = tempFile->getPath();
     auto fs = filesystems::getFileSystem(filename, {});
     fs->remove(filename);
@@ -234,7 +246,7 @@ TEST_P(LocalFileTest, writeAndRead) {
 }
 
 TEST_P(LocalFileTest, viaRegistry) {
-  auto tempFile = exec::test::TempFilePath::create(useFaultyFs_);
+  auto tempFile = TempFilePath::create(useFaultyFs_);
   const auto& filename = tempFile->getPath();
   auto fs = filesystems::getFileSystem(filename, {});
   fs->remove(filename);
@@ -250,7 +262,7 @@ TEST_P(LocalFileTest, viaRegistry) {
 }
 
 TEST_P(LocalFileTest, rename) {
-  const auto tempFolder = ::exec::test::TempDirectoryPath::create(useFaultyFs_);
+  const auto tempFolder = TempDirectoryPath::create(useFaultyFs_);
   const auto a = fmt::format("{}/a", tempFolder->getPath());
   const auto b = fmt::format("{}/b", tempFolder->getPath());
   const auto newA = fmt::format("{}/newA", tempFolder->getPath());
@@ -277,7 +289,7 @@ TEST_P(LocalFileTest, rename) {
 }
 
 TEST_P(LocalFileTest, exists) {
-  auto tempFolder = ::exec::test::TempDirectoryPath::create(useFaultyFs_);
+  auto tempFolder = TempDirectoryPath::create(useFaultyFs_);
   auto a = fmt::format("{}/a", tempFolder->getPath());
   auto b = fmt::format("{}/b", tempFolder->getPath());
   auto localFs = filesystems::getFileSystem(a, nullptr);
@@ -296,7 +308,7 @@ TEST_P(LocalFileTest, exists) {
 }
 
 TEST_P(LocalFileTest, isDirectory) {
-  auto tempFolder = ::exec::test::TempDirectoryPath::create(useFaultyFs_);
+  auto tempFolder = TempDirectoryPath::create(useFaultyFs_);
   auto a = fmt::format("{}/a", tempFolder->getPath());
   auto localFs = filesystems::getFileSystem(a, nullptr);
   auto writeFile = localFs->openFileForWrite(a);
@@ -305,7 +317,7 @@ TEST_P(LocalFileTest, isDirectory) {
 }
 
 TEST_P(LocalFileTest, list) {
-  const auto tempFolder = ::exec::test::TempDirectoryPath::create(useFaultyFs_);
+  const auto tempFolder = TempDirectoryPath::create(useFaultyFs_);
   const auto a = fmt::format("{}/1", tempFolder->getPath());
   const auto b = fmt::format("{}/2", tempFolder->getPath());
   auto localFs = filesystems::getFileSystem(a, nullptr);
@@ -328,7 +340,7 @@ TEST_P(LocalFileTest, readFileDestructor) {
   if (useFaultyFs_) {
     return;
   }
-  auto tempFile = exec::test::TempFilePath::create(useFaultyFs_);
+  auto tempFile = TempFilePath::create(useFaultyFs_);
   const auto& filename = tempFile->getPath();
   auto fs = filesystems::getFileSystem(filename, {});
   fs->remove(filename);
@@ -362,7 +374,7 @@ TEST_P(LocalFileTest, readFileDestructor) {
 }
 
 TEST_P(LocalFileTest, mkdirFailIfPresent) {
-  auto tempFolder = exec::test::TempDirectoryPath::create(useFaultyFs_);
+  auto tempFolder = TempDirectoryPath::create(useFaultyFs_);
   std::string path = tempFolder->getPath();
   auto localFs = filesystems::getFileSystem(path, nullptr);
 
@@ -384,7 +396,7 @@ TEST_P(LocalFileTest, mkdirFailIfPresent) {
 }
 
 TEST_P(LocalFileTest, mkdir) {
-  auto tempFolder = exec::test::TempDirectoryPath::create(useFaultyFs_);
+  auto tempFolder = TempDirectoryPath::create(useFaultyFs_);
 
   std::string path = tempFolder->getPath();
   auto localFs = filesystems::getFileSystem(path, nullptr);
@@ -409,7 +421,7 @@ TEST_P(LocalFileTest, mkdir) {
 }
 
 TEST_P(LocalFileTest, rmdir) {
-  auto tempFolder = exec::test::TempDirectoryPath::create(useFaultyFs_);
+  auto tempFolder = TempDirectoryPath::create(useFaultyFs_);
 
   std::string path = tempFolder->getPath();
   auto localFs = filesystems::getFileSystem(path, nullptr);
@@ -442,7 +454,7 @@ TEST_P(LocalFileTest, rmdir) {
 }
 
 TEST_P(LocalFileTest, fileNotFound) {
-  auto tempFolder = exec::test::TempDirectoryPath::create(useFaultyFs_);
+  auto tempFolder = TempDirectoryPath::create(useFaultyFs_);
   auto path = fmt::format("{}/file", tempFolder->getPath());
   auto localFs = filesystems::getFileSystem(path, nullptr);
   VELOX_ASSERT_RUNTIME_THROW_CODE(
@@ -452,7 +464,7 @@ TEST_P(LocalFileTest, fileNotFound) {
 }
 
 TEST_P(LocalFileTest, attributes) {
-  auto tempFile = exec::test::TempFilePath::create(useFaultyFs_);
+  auto tempFile = TempFilePath::create(useFaultyFs_);
   const auto& filename = tempFile->getPath();
   auto fs = filesystems::getFileSystem(filename, {});
   fs->remove(filename);
@@ -486,7 +498,7 @@ class FaultyFsTest : public ::testing::Test {
   }
 
   void SetUp() {
-    dir_ = exec::test::TempDirectoryPath::create(true);
+    dir_ = TempDirectoryPath::create(true);
     fs_ = std::dynamic_pointer_cast<tests::utils::FaultyFileSystem>(
         filesystems::getFileSystem(dir_->getPath(), {}));
     VELOX_CHECK_NOT_NULL(fs_);
@@ -535,7 +547,7 @@ class FaultyFsTest : public ::testing::Test {
     }
   }
 
-  std::shared_ptr<exec::test::TempDirectoryPath> dir_;
+  std::shared_ptr<TempDirectoryPath> dir_;
   std::string readFilePath_;
   std::string writeFilePath_;
   std::shared_ptr<tests::utils::FaultyFileSystem> fs_;
diff --git a/velox/common/file/tests/UtilsTest.cpp b/velox/common/file/tests/FileUtilsTest.cpp
similarity index 91%
rename from velox/common/file/tests/UtilsTest.cpp
rename to velox/common/file/tests/FileUtilsTest.cpp
index a2b2d6ee5a0..eaa2b72cb94 100644
--- a/velox/common/file/tests/UtilsTest.cpp
+++ b/velox/common/file/tests/FileUtilsTest.cpp
@@ -17,7 +17,8 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-#include "velox/common/file/Utils.h"
+#include "velox/common/file/FileUtils.h"
+#include "velox/common/file/Region.h"
 #include "velox/common/file/tests/TestUtils.h"
 
 using namespace ::testing;
@@ -98,11 +99,12 @@ auto getReader(
           /* minTailRoom*/ 0);
 
       for (size_t i = 1; i < size; ++i) {
-        head->appendToChain(folly::IOBuf::copyBuffer(
-            buf.data() + offset + i,
-            /* size */ 1,
-            /* headroom */ 0,
-            /* minTailRoom*/ 0));
+        head->appendToChain(
+            folly::IOBuf::copyBuffer(
+                buf.data() + offset + i,
+                /* size */ 1,
+                /* headroom */ 0,
+                /* minTailRoom*/ 0));
       }
       return head;
     } else {
@@ -289,3 +291,19 @@ INSTANTIATE_TEST_SUITE_P(
     ReadToIOBufsTest,
     ValuesIn(
         std::vector<bool /* Should generated chained IOBuf */>({false, true})));
+
+TEST(RegionTest, toString) {
+  EXPECT_EQ(Region(0, 0).toString(), "Region{offset: 0, length: 0B, label: }");
+  EXPECT_EQ(
+      Region(100, 256).toString(),
+      "Region{offset: 100, length: 256B, label: }");
+  EXPECT_EQ(
+      Region(1024, 1024, "test").toString(),
+      "Region{offset: 1024, length: 1.00KB, label: test}");
+  EXPECT_EQ(
+      Region(0, 1'048'576, "stream").toString(),
+      "Region{offset: 0, length: 1.00MB, label: stream}");
+  EXPECT_EQ(
+      Region(12345, 1'073'741'824).toString(),
+      "Region{offset: 12345, length: 1.00GB, label: }");
+}
diff --git a/velox/common/file/tests/TestUtils.h b/velox/common/file/tests/TestUtils.h
index 43355958f52..f0883e29d11 100644
--- a/velox/common/file/tests/TestUtils.h
+++ b/velox/common/file/tests/TestUtils.h
@@ -23,4 +23,26 @@ namespace facebook::velox::tests::utils {
 std::vector<std::string> iobufsToStrings(
     const std::vector<folly::IOBuf>& iobufs);
 
+/// Wraps InMemoryReadFile with pread call counting for test assertions.
+class CountingReadFile : public InMemoryReadFile {
+ public:
+  using InMemoryReadFile::InMemoryReadFile;
+
+  std::string_view pread(
+      uint64_t offset,
+      uint64_t length,
+      void* buf,
+      const FileIoContext& context = {}) const override {
+    ++numReads_;
+    return InMemoryReadFile::pread(offset, length, buf, context);
+  }
+
+  uint64_t numReads() const {
+    return numReads_;
+  }
+
+ private:
+  mutable std::atomic_uint64_t numReads_{0};
+};
+
 } // namespace facebook::velox::tests::utils
diff --git a/CMake/resolve_dependency_modules/cpr/cpr-remove-sancheck.patch b/velox/common/future/CMakeLists.txt
similarity index 66%
rename from CMake/resolve_dependency_modules/cpr/cpr-remove-sancheck.patch
rename to velox/common/future/CMakeLists.txt
index 4fca92831a2..c9ca4266c65 100644
--- a/CMake/resolve_dependency_modules/cpr/cpr-remove-sancheck.patch
+++ b/velox/common/future/CMakeLists.txt
@@ -11,14 +11,6 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-# This hangs on CI and is not needed #9116
---- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -84,7 +84,6 @@ endif()
- include(GNUInstallDirs)
- include(FetchContent)
- include(cmake/code_coverage.cmake)
--include(cmake/sanitizer.cmake)
- include(cmake/clear_variable.cmake)
+velox_add_library(velox_future INTERFACE HEADERS VeloxPromise.h)
 
- # So CMake can find FindMbedTLS.cmake
+velox_install_library_headers()
diff --git a/velox/common/future/VeloxPromise.h b/velox/common/future/VeloxPromise.h
index ba8fbdfbce3..7ac170a2fc1 100644
--- a/velox/common/future/VeloxPromise.h
+++ b/velox/common/future/VeloxPromise.h
@@ -28,12 +28,15 @@ class VeloxPromise : public folly::Promise<T> {
   VeloxPromise() : folly::Promise<T>() {}
 
   explicit VeloxPromise(const std::string& context)
-      : folly::Promise<T>(), context_(context) {}
+      : folly::Promise<T>(), context_(context) {
+    if (context.empty()) {
+      LOG(WARNING)
+          << "PROMISE: VeloxPromise must be constructed with a context.";
+    }
+  }
 
-  VeloxPromise(
-      folly::futures::detail::EmptyConstruct,
-      const std::string& context) noexcept
-      : folly::Promise<T>(folly::Promise<T>::makeEmpty()), context_(context) {}
+  explicit VeloxPromise(folly::futures::detail::EmptyConstruct) noexcept
+      : folly::Promise<T>(folly::Promise<T>::makeEmpty()) {}
 
   ~VeloxPromise() {
     if (!this->isFulfilled()) {
@@ -52,8 +55,8 @@ class VeloxPromise : public folly::Promise<T> {
     return *this;
   }
 
-  static VeloxPromise makeEmpty(const std::string& context = "") noexcept {
-    return VeloxPromise<T>(folly::futures::detail::EmptyConstruct{}, context);
+  static VeloxPromise makeEmpty() noexcept {
+    return VeloxPromise<T>(folly::futures::detail::EmptyConstruct{});
   }
 
  private:
@@ -65,8 +68,14 @@ using ContinuePromise = VeloxPromise<folly::Unit>;
 using ContinueFuture = folly::SemiFuture<folly::Unit>;
 
 /// Equivalent of folly's makePromiseContract for VeloxPromise.
+///
+/// NOTE: When you already have a valid promise, just call
+/// Promise::getSemiFuture() on it to get the future, instead of using this
+/// function to overwrite the promise.  Overwriting valid promise would cause
+/// exception throwing and stack unwinding thus performance issue.  See
+/// https://github.com/prestodb/presto/issues/26094 for details.
 static inline std::pair<ContinuePromise, ContinueFuture>
-makeVeloxContinuePromiseContract(const std::string& promiseContext = "") {
+makeVeloxContinuePromiseContract(const std::string& promiseContext) {
   auto p = ContinuePromise(promiseContext);
   auto f = p.getSemiFuture();
   return std::make_pair(std::move(p), std::move(f));
diff --git a/velox/common/fuzzer/CMakeLists.txt b/velox/common/fuzzer/CMakeLists.txt
index d2e3663b73d..3391f989d02 100644
--- a/velox/common/fuzzer/CMakeLists.txt
+++ b/velox/common/fuzzer/CMakeLists.txt
@@ -12,11 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_common_fuzzer_util Utils.cpp)
+velox_add_library(velox_common_fuzzer_util Utils.cpp HEADERS Utils.h)
 
 velox_link_libraries(velox_common_fuzzer_util velox_type velox_exception)
 
-velox_add_library(velox_constrained_input_generators ConstrainedGenerators.cpp)
+velox_add_library(
+  velox_constrained_input_generators
+  ConstrainedGenerators.cpp
+  HEADERS
+  ConstrainedGenerators.h
+)
 
 velox_link_libraries(
   velox_constrained_input_generators
diff --git a/velox/common/fuzzer/ConstrainedGenerators.cpp b/velox/common/fuzzer/ConstrainedGenerators.cpp
index 708e5ee8721..4334e8cb3bd 100644
--- a/velox/common/fuzzer/ConstrainedGenerators.cpp
+++ b/velox/common/fuzzer/ConstrainedGenerators.cpp
@@ -17,6 +17,8 @@
 #include "velox/common/fuzzer/ConstrainedGenerators.h"
 #include <boost/random/uniform_int_distribution.hpp>
 #include "velox/common/fuzzer/Utils.h"
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/functions/lib/SetDigest.h"
 #include "velox/functions/lib/TDigest.h"
 #include "velox/functions/prestosql/types/BingTileType.h"
 
@@ -282,10 +284,84 @@ variant TDigestInputGenerator::generate() {
   size_t byteSize = digest.serializedByteSize();
   std::string serializedDigest(byteSize, '\0');
   digest.serialize(&serializedDigest[0]);
-  StringView serializedView(serializedDigest.data(), serializedDigest.size());
   return variant::create<TypeKind::VARBINARY>(serializedDigest);
 }
 
+SetDigestInputGenerator::SetDigestInputGenerator(
+    size_t seed,
+    const TypePtr& type,
+    double nullRatio)
+    : AbstractInputGenerator(seed, type, nullptr, nullRatio),
+      pool_(velox::memory::memoryManager()->addLeafPool()),
+      allocator_(std::make_unique<HashStringAllocator>(pool_.get())) {
+  // SetDigest supports int64_t and StringView
+  static const std::vector<TypePtr> kBaseTypes{BIGINT(), VARCHAR()};
+  baseType_ = kBaseTypes[rand<size_t>(rng_, 0, kBaseTypes.size() - 1)];
+}
+
+SetDigestInputGenerator::~SetDigestInputGenerator() = default;
+
+template <typename T>
+variant SetDigestInputGenerator::generateTyped() {
+  velox::functions::SetDigest<int64_t> digest(allocator_.get());
+
+  // SetDigest defaults to maxHashes=8192. Usually generate small datasets
+  // (exact mode), but occasionally generate >8192 values to test approximate
+  // mode.
+  int numValues = coinToss(rng_, 0.1) ? rand<int>(rng_, 8500, 10000)
+                                      : rand<int>(rng_, 10, 100);
+  for (int i = 0; i < numValues; ++i) {
+    int64_t value = rand<int64_t>(rng_);
+    digest.add(value);
+  }
+
+  size_t byteSize = digest.estimatedSerializedSize();
+  std::string serializedDigest(byteSize, '\0');
+  digest.serialize(&serializedDigest[0]);
+  return variant::create<TypeKind::VARBINARY>(serializedDigest);
+}
+
+template <>
+variant SetDigestInputGenerator::generateTyped<std::string>() {
+  velox::functions::SetDigest<StringView> digest(allocator_.get());
+
+  int numValues = coinToss(rng_, 0.1) ? rand<int>(rng_, 8500, 10000)
+                                      : rand<int>(rng_, 10, 100);
+  static const std::vector<UTF8CharList> encodings{
+      UTF8CharList::ASCII,
+      UTF8CharList::UNICODE_CASE_SENSITIVE,
+      UTF8CharList::EXTENDED_UNICODE,
+      UTF8CharList::MATHEMATICAL_SYMBOLS};
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+  std::wstring_convert<std::codecvt_utf8<char16_t>, char16_t> converter;
+#pragma GCC diagnostic pop
+
+  for (int i = 0; i < numValues; ++i) {
+    auto size = rand<int32_t>(rng_, 0, 100);
+    std::string result;
+    auto str = randString(rng_, size, encodings, result, converter);
+    digest.add(StringView(str));
+  }
+
+  size_t byteSize = digest.estimatedSerializedSize();
+  std::string serializedDigest(byteSize, '\0');
+  digest.serialize(&serializedDigest[0]);
+  return variant::create<TypeKind::VARBINARY>(serializedDigest);
+}
+
+variant SetDigestInputGenerator::generate() {
+  if (coinToss(rng_, nullRatio_)) {
+    return variant::null(type_->kind());
+  }
+
+  if (baseType_->isBigint()) {
+    return generateTyped<int64_t>();
+  } else {
+    return generateTyped<std::string>();
+  }
+}
+
 // BingTileInputGenerator
 
 BingTileInputGenerator::BingTileInputGenerator(
@@ -537,7 +613,6 @@ CastVarcharInputGenerator::CastVarcharInputGenerator(
 
 CastVarcharInputGenerator::~CastVarcharInputGenerator() = default;
 
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 std::string CastVarcharInputGenerator::generateValidPrimitiveAsString() {
   switch (castToType_->kind()) {
     case TypeKind::BOOLEAN: {
@@ -575,7 +650,10 @@ std::string CastVarcharInputGenerator::generateValidPrimitiveAsString() {
     case TypeKind::VARCHAR: {
       // Generate random string.
       std::string input;
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
       std::wstring_convert<std::codecvt_utf8<char16_t>, char16_t> converter;
+#pragma GCC diagnostic pop
       auto randomStr = randString(
           rng_,
           rand<size_t>(rng_, 0, 20),
@@ -586,9 +664,10 @@ std::string CastVarcharInputGenerator::generateValidPrimitiveAsString() {
     }
     default:
       // cast from varchar doesn't support complex types
-      VELOX_FAIL_UNSUPPORTED_INPUT_UNCATCHABLE(fmt::format(
-          "Type `{}` not supported for cast varchar custom generator",
-          castToType_->kind()));
+      VELOX_FAIL_UNSUPPORTED_INPUT_UNCATCHABLE(
+          fmt::format(
+              "Type `{}` not supported for cast varchar custom generator",
+              castToType_->kind()));
   }
 }
 
diff --git a/velox/common/fuzzer/ConstrainedGenerators.h b/velox/common/fuzzer/ConstrainedGenerators.h
index 8d694eb40e0..20d9565e38c 100644
--- a/velox/common/fuzzer/ConstrainedGenerators.h
+++ b/velox/common/fuzzer/ConstrainedGenerators.h
@@ -21,6 +21,7 @@
 #include "folly/json.h"
 
 #include "velox/common/fuzzer/Utils.h"
+#include "velox/common/memory/HashStringAllocator.h"
 #include "velox/functions/lib/QuantileDigest.h"
 #include "velox/type/Type.h"
 #include "velox/type/Variant.h"
@@ -61,6 +62,10 @@ class RandomInputGenerator : public AbstractInputGenerator {
     if (type_->isDate()) {
       return variant(randDate(rng_));
     }
+    if (type_->isTime()) {
+      VELOX_DCHECK(type_->equivalent(*TIME()));
+      return variant(randTime(rng_));
+    }
     return variant(rand<T>(rng_));
   }
 };
@@ -527,6 +532,23 @@ class TDigestInputGenerator : public AbstractInputGenerator {
   variant generate() override;
 };
 
+class SetDigestInputGenerator : public AbstractInputGenerator {
+ public:
+  SetDigestInputGenerator(size_t seed, const TypePtr& type, double nullRatio);
+
+  ~SetDigestInputGenerator() override;
+
+  variant generate() override;
+
+ private:
+  template <typename T>
+  variant generateTyped();
+
+  TypePtr baseType_;
+  std::shared_ptr<memory::MemoryPool> pool_;
+  std::unique_ptr<HashStringAllocator> allocator_;
+};
+
 class BingTileInputGenerator : public AbstractInputGenerator {
  public:
   BingTileInputGenerator(size_t seed, const TypePtr& type, double nullRatio);
diff --git a/velox/common/fuzzer/Utils.cpp b/velox/common/fuzzer/Utils.cpp
index 36f86be60ff..2e5580396e5 100644
--- a/velox/common/fuzzer/Utils.cpp
+++ b/velox/common/fuzzer/Utils.cpp
@@ -15,6 +15,8 @@
  */
 
 #include "velox/common/fuzzer/Utils.h"
+#include <fmt/format.h>
+#include "velox/type/Time.h"
 
 namespace facebook::velox::fuzzer {
 
@@ -117,6 +119,10 @@ int32_t randDate(FuzzerGenerator& rng) {
   return rand<int32_t>(rng, min, max);
 }
 
+int32_t randTime(FuzzerGenerator& rng) {
+  return rand<int64_t>(rng, TIME()->getMin(), TIME()->getMax());
+}
+
 /// Unicode character ranges. Ensure the vector indexes match the UTF8CharList
 /// enum values.
 ///
@@ -202,4 +208,38 @@ std::string randString(
 }
 #pragma GCC diagnostic pop
 
+int16_t generateRandomTimezoneOffset(
+    FuzzerGenerator& rng,
+    double frequentlyUsedProbability) {
+  // 25% probability: pick from frequently used offsets
+  // 75% probability: generate random offset in range [-840, 840]
+  if (coinToss(rng, frequentlyUsedProbability)) {
+    auto index =
+        rand<size_t>(rng, 0, kFrequentlyUsedTimezoneOffsets.size() - 1);
+    return kFrequentlyUsedTimezoneOffsets[index];
+  } else {
+    return rand<int16_t>(rng, -util::kTimeZoneBias, util::kTimeZoneBias);
+  }
+}
+
+std::string timezoneOffsetToString(int16_t offsetMinutes) {
+  // Validate range [-840, 840]
+  VELOX_USER_CHECK(
+      offsetMinutes >= -util::kTimeZoneBias &&
+          offsetMinutes <= util::kTimeZoneBias,
+      "Timezone offset {} minutes is out of range [-840, 840]",
+      offsetMinutes);
+
+  // Determine sign
+  char sign = (offsetMinutes >= 0) ? '+' : '-';
+
+  // Calculate hours and minutes using absolute value
+  int16_t absOffset = std::abs(offsetMinutes);
+  int16_t hours = absOffset / util::kMinutesInHour;
+  int16_t minutes = absOffset % util::kMinutesInHour;
+
+  // Format as "+HH:mm" or "-HH:mm" with zero-padding
+  return fmt::format("{}{:02d}:{:02d}", sign, hours, minutes);
+}
+
 } // namespace facebook::velox::fuzzer
diff --git a/velox/common/fuzzer/Utils.h b/velox/common/fuzzer/Utils.h
index db910007c31..a9b5cdc2309 100644
--- a/velox/common/fuzzer/Utils.h
+++ b/velox/common/fuzzer/Utils.h
@@ -31,6 +31,17 @@ namespace facebook::velox::fuzzer {
 
 using FuzzerGenerator = folly::detail::DefaultGenerator;
 
+// Frequently used timezone offsets in minutes (US timezones including DST)
+// -240 = UTC-4:00 (EDT)
+// -300 = UTC-5:00 (EST/CDT)
+// -360 = UTC-6:00 (CST/MDT)
+// -420 = UTC-7:00 (MST/PDT)
+// -480 = UTC-8:00 (PST)
+// -540 = UTC-9:00 (AKST)
+// -600 = UTC-10:00 (HST)
+constexpr std::array<int16_t, 7> kFrequentlyUsedTimezoneOffsets =
+    {-240, -300, -360, -420, -480, -540, -600};
+
 enum UTF8CharList {
   ASCII = 0, // Ascii character set.
   UNICODE_CASE_SENSITIVE = 1, // Unicode scripts that support case.
@@ -167,6 +178,35 @@ inline Timestamp rand(FuzzerGenerator& rng, DataSpec /*dataSpec*/) {
 
 int32_t randDate(FuzzerGenerator& rng);
 
+int32_t randTime(FuzzerGenerator& rng);
+
+/// Generate random timezone offset using biased distribution
+/// 25% probability: picks from frequently used offsets
+/// 75% probability: generates random offset from [-840, 840]
+///
+/// @param rng Random number generator
+/// @param frequentlyUsedProbability Probability of selecting from frequently
+///        used offsets (default 0.25 for 25%)
+/// @return Timezone offset in minutes [-840, 840]
+int16_t generateRandomTimezoneOffset(
+    FuzzerGenerator& rng,
+    double frequentlyUsedProbability = 0.25);
+
+/// Convert timezone offset in minutes to "+HH:mm" or "-HH:mm" format
+/// Always uses Presto-compatible +HH:mm format (never +HH or +HHmm)
+///
+/// Examples:
+/// - 0 → "+00:00"
+/// - 330 → "+05:30"
+/// - -300 → "-05:00"
+/// - 840 → "+14:00"
+/// - -840 → "-14:00"
+///
+/// @param offsetMinutes Timezone offset in minutes [-840, 840]
+/// @return Timezone offset string in "+HH:mm" or "-HH:mm" format
+/// @throws VeloxException if offsetMinutes is out of range [-840, 840]
+std::string timezoneOffsetToString(int16_t offsetMinutes);
+
 template <
     typename T,
     typename std::enable_if_t<std::is_arithmetic_v<T>, int> = 0>
diff --git a/velox/common/fuzzer/tests/ConstrainedGeneratorsTest.cpp b/velox/common/fuzzer/tests/ConstrainedGeneratorsTest.cpp
index 5b6c70f15bb..1defe5db7b2 100644
--- a/velox/common/fuzzer/tests/ConstrainedGeneratorsTest.cpp
+++ b/velox/common/fuzzer/tests/ConstrainedGeneratorsTest.cpp
@@ -22,6 +22,7 @@
 #include "velox/functions/prestosql/json/JsonExtractor.h"
 #include "velox/functions/prestosql/types/JsonType.h"
 #include "velox/functions/prestosql/types/QDigestType.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
 #include "velox/functions/prestosql/types/TDigestType.h"
 #include "velox/type/Variant.h"
 
@@ -405,9 +406,10 @@ TEST_F(ConstrainedGeneratorsTest, jsonPath) {
     const auto jsonPath = jsonPathGenerator->generate();
     if (jsonPath.hasValue()) {
       if (json.hasValue()) {
-        EXPECT_NO_THROW(functions::jsonExtract(
-            json.value<TypeKind::VARCHAR>(),
-            jsonPath.value<TypeKind::VARCHAR>()));
+        EXPECT_NO_THROW(
+            functions::jsonExtract(
+                json.value<TypeKind::VARCHAR>(),
+                jsonPath.value<TypeKind::VARCHAR>()));
       }
     } else {
       hasNull = true;
@@ -423,6 +425,13 @@ TEST_F(ConstrainedGeneratorsTest, tdigest) {
   EXPECT_EQ(value.kind(), TypeKind::VARBINARY);
 }
 
+TEST_F(ConstrainedGeneratorsTest, setdigest) {
+  std::unique_ptr<SetDigestInputGenerator> generator =
+      std::make_unique<SetDigestInputGenerator>(0, SETDIGEST(), 0.4);
+  auto value = generator->generate();
+  EXPECT_EQ(value.kind(), TypeKind::VARBINARY);
+}
+
 TEST_F(ConstrainedGeneratorsTest, qdigest) {
   std::unique_ptr<QDigestInputGenerator> generator =
       std::make_unique<QDigestInputGenerator>(
diff --git a/velox/common/fuzzer/tests/UtilsTest.cpp b/velox/common/fuzzer/tests/UtilsTest.cpp
index ba21bf93a1a..5e82bdc85d6 100644
--- a/velox/common/fuzzer/tests/UtilsTest.cpp
+++ b/velox/common/fuzzer/tests/UtilsTest.cpp
@@ -26,23 +26,25 @@ namespace facebook::velox::fuzzer::test {
 class UtilsTest : public testing::Test {};
 
 TEST_F(UtilsTest, testRuleList) {
-  auto simple = RuleList(std::vector<std::shared_ptr<Rule>>{
-      std::make_shared<ConstantRule>("Hello"),
-      std::make_shared<ConstantRule>(","),
-      std::make_shared<ConstantRule>(" "),
-      std::make_shared<ConstantRule>("world"),
-      std::make_shared<ConstantRule>("!"),
-  });
+  auto simple = RuleList(
+      std::vector<std::shared_ptr<Rule>>{
+          std::make_shared<ConstantRule>("Hello"),
+          std::make_shared<ConstantRule>(","),
+          std::make_shared<ConstantRule>(" "),
+          std::make_shared<ConstantRule>("world"),
+          std::make_shared<ConstantRule>("!"),
+      });
   ASSERT_EQ(simple.generate(), "Hello, world!");
 
   FuzzerGenerator rng;
-  auto fuzz = RuleList(std::vector<std::shared_ptr<Rule>>{
-      std::make_shared<ConstantRule>("Hello"),
-      std::make_shared<ConstantRule>(","),
-      std::make_shared<ConstantRule>(" "),
-      std::make_shared<WordRule>(rng),
-      std::make_shared<ConstantRule>("!"),
-  });
+  auto fuzz = RuleList(
+      std::vector<std::shared_ptr<Rule>>{
+          std::make_shared<ConstantRule>("Hello"),
+          std::make_shared<ConstantRule>(","),
+          std::make_shared<ConstantRule>(" "),
+          std::make_shared<WordRule>(rng),
+          std::make_shared<ConstantRule>("!"),
+      });
   ASSERT_TRUE(
       std::regex_match(fuzz.generate(), std::regex("Hello, \\w{1,20}!")));
 }
@@ -83,36 +85,43 @@ TEST_F(UtilsTest, testConstantRule) {
   auto rule = std::make_shared<ConstantRule>("a");
   ASSERT_EQ(rule->generate(), "a");
 
-  auto rule_list = RuleList(std::vector<std::shared_ptr<Rule>>{
-      std::make_shared<ConstantRule>("a"),
-      std::make_shared<ConstantRule>("b"),
-      std::make_shared<ConstantRule>("c")});
+  auto rule_list = RuleList(
+      std::vector<std::shared_ptr<Rule>>{
+          std::make_shared<ConstantRule>("a"),
+          std::make_shared<ConstantRule>("b"),
+          std::make_shared<ConstantRule>("c")});
   ASSERT_EQ(rule_list.generate(), "abc");
 }
 
 TEST_F(UtilsTest, testStringRule) {
   FuzzerGenerator rng;
   auto simple = std::make_shared<StringRule>(rng);
-  ASSERT_TRUE(std::regex_match(
-      simple->generate(), std::regex("^[\x21-\x7F]+$"))); // printable ascii
+  ASSERT_TRUE(
+      std::regex_match(
+          simple->generate(), std::regex("^[\x21-\x7F]+$"))); // printable ascii
   ASSERT_FALSE(std::regex_match(simple->generate(), std::regex("^\\w+$")));
   ASSERT_FALSE(std::regex_match(simple->generate(), std::regex("^\\d+$")));
 
   auto specified_flexible = std::make_shared<StringRule>(
       rng, std::vector<UTF8CharList>{UTF8CharList::ASCII}, 3, 7, true);
-  ASSERT_TRUE(std::regex_match(
-      specified_flexible->generate(), std::regex("^[\\x21-\\x7F]{3,7}$")));
-  ASSERT_FALSE(std::regex_match(
-      specified_flexible->generate(), std::regex("^[\\x21-\\x7F]{0,2}$")));
-  ASSERT_FALSE(std::regex_match(
-      specified_flexible->generate(), std::regex("^[\\x21-\\x7F]{8,}$")));
+  ASSERT_TRUE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^[\\x21-\\x7F]{3,7}$")));
+  ASSERT_FALSE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^[\\x21-\\x7F]{0,2}$")));
+  ASSERT_FALSE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^[\\x21-\\x7F]{8,}$")));
 
   auto specified_strict = std::make_shared<StringRule>(
       rng, std::vector<UTF8CharList>{UTF8CharList::ASCII}, 3, 7, false);
-  ASSERT_TRUE(std::regex_match(
-      specified_strict->generate(), std::regex("^[\x21-\x7F]{7}$")));
-  ASSERT_FALSE(std::regex_match(
-      specified_strict->generate(), std::regex("^[\x21-\x7F]{8}$")));
+  ASSERT_TRUE(
+      std::regex_match(
+          specified_strict->generate(), std::regex("^[\x21-\x7F]{7}$")));
+  ASSERT_FALSE(
+      std::regex_match(
+          specified_strict->generate(), std::regex("^[\x21-\x7F]{8}$")));
 }
 
 TEST_F(UtilsTest, testWordRule) {
@@ -124,16 +133,21 @@ TEST_F(UtilsTest, testWordRule) {
   ASSERT_FALSE(std::regex_match(simple->generate(), std::regex("^\\W+$")));
 
   auto specified_flexible = std::make_shared<WordRule>(rng, 3, 7, true);
-  ASSERT_TRUE(std::regex_match(
-      specified_flexible->generate(), std::regex("^[a-zA-Z]{3,7}$")));
-  ASSERT_TRUE(std::regex_match(
-      specified_flexible->generate(), std::regex("^\\w{3,7}$")));
-  ASSERT_FALSE(std::regex_match(
-      specified_flexible->generate(), std::regex("^\\d{3,7}$")));
-  ASSERT_FALSE(std::regex_match(
-      specified_flexible->generate(), std::regex("^\\w{0,2}$")));
-  ASSERT_FALSE(std::regex_match(
-      specified_flexible->generate(), std::regex("^\\w{8,}$")));
+  ASSERT_TRUE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^[a-zA-Z]{3,7}$")));
+  ASSERT_TRUE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^\\w{3,7}$")));
+  ASSERT_FALSE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^\\d{3,7}$")));
+  ASSERT_FALSE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^\\w{0,2}$")));
+  ASSERT_FALSE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^\\w{8,}$")));
 
   auto specified_strict = std::make_shared<WordRule>(rng, 3, 7, false);
   ASSERT_TRUE(
@@ -149,16 +163,21 @@ TEST_F(UtilsTest, testNumRule) {
   ASSERT_FALSE(std::regex_match(simple->generate(), std::regex("^\\D+$")));
 
   auto specified_flexible = std::make_shared<NumRule>(rng, 3, 7, true);
-  ASSERT_TRUE(std::regex_match(
-      specified_flexible->generate(), std::regex("^\\d{3,7}$")));
-  ASSERT_TRUE(std::regex_match(
-      specified_flexible->generate(), std::regex("^\\w{3,7}$")));
-  ASSERT_FALSE(std::regex_match(
-      specified_flexible->generate(), std::regex("^\\D{3,7}$")));
-  ASSERT_FALSE(std::regex_match(
-      specified_flexible->generate(), std::regex("^\\d{0,2}$")));
-  ASSERT_FALSE(std::regex_match(
-      specified_flexible->generate(), std::regex("^\\d{8,}$")));
+  ASSERT_TRUE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^\\d{3,7}$")));
+  ASSERT_TRUE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^\\w{3,7}$")));
+  ASSERT_FALSE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^\\D{3,7}$")));
+  ASSERT_FALSE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^\\d{0,2}$")));
+  ASSERT_FALSE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^\\d{8,}$")));
 
   auto specified_strict = std::make_shared<NumRule>(rng, 3, 7, false);
   ASSERT_TRUE(
diff --git a/velox/common/geospatial/CMakeLists.txt b/velox/common/geospatial/CMakeLists.txt
new file mode 100644
index 00000000000..375f99efeff
--- /dev/null
+++ b/velox/common/geospatial/CMakeLists.txt
@@ -0,0 +1,26 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+if(VELOX_ENABLE_GEO)
+  velox_add_library(velox_common_geospatial_serde GeometrySerde.cpp HEADERS GeometrySerde.h)
+  velox_link_libraries(velox_common_geospatial_serde velox_expression GEOS::geos)
+endif()
+
+velox_install_library_headers()
+
+if(${VELOX_BUILD_TESTING})
+  add_subdirectory(tests)
+endif()
+
+velox_add_library(velox_geospatial_constants INTERFACE HEADERS GeometryConstants.h)
diff --git a/velox/common/geospatial/GeometryConstants.h b/velox/common/geospatial/GeometryConstants.h
new file mode 100644
index 00000000000..d598f29e026
--- /dev/null
+++ b/velox/common/geospatial/GeometryConstants.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+
+// This file contains constats for working with geospatial queries.
+// They _must not_ require the GEOS library (or any 3p library).
+
+namespace facebook::velox::common::geospatial {
+
+enum class GeometrySerializationType : uint8_t {
+  POINT = 0,
+  MULTI_POINT = 1,
+  LINE_STRING = 2,
+  MULTI_LINE_STRING = 3,
+  POLYGON = 4,
+  MULTI_POLYGON = 5,
+  GEOMETRY_COLLECTION = 6,
+  ENVELOPE = 7
+};
+
+enum class EsriShapeType : uint32_t {
+  POINT = 1,
+  POLYLINE = 3,
+  POLYGON = 5,
+  MULTI_POINT = 8
+};
+
+/// Latitude/Longitude range constraints for spherical coordinates.
+constexpr double kMinLatitude = -90.0;
+constexpr double kMaxLatitude = 90.0;
+constexpr double kMinLongitude = -180.0;
+constexpr double kMaxLongitude = 180.0;
+
+/// BingTile-specific latitude constraints (narrower than standard lat/long).
+constexpr double kMinBingTileLatitude = -85.05112878;
+constexpr double kMaxBingTileLatitude = 85.05112878;
+
+} // namespace facebook::velox::common::geospatial
diff --git a/velox/functions/prestosql/geospatial/GeometrySerde.cpp b/velox/common/geospatial/GeometrySerde.cpp
similarity index 84%
rename from velox/functions/prestosql/geospatial/GeometrySerde.cpp
rename to velox/common/geospatial/GeometrySerde.cpp
index 4c0d98903f8..ac9921441b1 100644
--- a/velox/functions/prestosql/geospatial/GeometrySerde.cpp
+++ b/velox/common/geospatial/GeometrySerde.cpp
@@ -20,11 +20,20 @@
 #include <geos/geom/Point.h>
 
 #include "velox/common/base/IOUtils.h"
-#include "velox/functions/prestosql/geospatial/GeometrySerde.h"
+#include "velox/common/geospatial/GeometrySerde.h"
 
 using facebook::velox::common::InputByteStream;
+using facebook::velox::common::geospatial::EsriShapeType;
+using facebook::velox::common::geospatial::GeometrySerializationType;
+
+namespace facebook::velox::common::geospatial {
+
+geos::geom::GeometryFactory* GeometryDeserializer::getGeometryFactory() {
+  thread_local static geos::geom::GeometryFactory::Ptr geometryFactory =
+      geos::geom::GeometryFactory::create();
+  return geometryFactory.get();
+}
 
-namespace facebook::velox::functions::geospatial {
 std::unique_ptr<geos::geom::Geometry> GeometryDeserializer::readGeometry(
     velox::common::InputByteStream& stream,
     size_t size) {
@@ -53,6 +62,15 @@ std::unique_ptr<geos::geom::Geometry> GeometryDeserializer::readGeometry(
   }
 }
 
+std::unique_ptr<geos::geom::Geometry> GeometryDeserializer::deserializeNonEmpty(
+    const StringView& geometry) {
+  auto envelope = deserializeEnvelope(geometry);
+  if (envelope->isNull()) {
+    return nullptr;
+  }
+  return deserialize(geometry);
+}
+
 const std::unique_ptr<geos::geom::Envelope>
 GeometryDeserializer::deserializeEnvelope(const StringView& geometry) {
   velox::common::InputByteStream inputStream(geometry.data());
@@ -174,8 +192,9 @@ std::unique_ptr<geos::geom::Geometry> GeometryDeserializer::readPolyline(
   std::vector<std::unique_ptr<geos::geom::LineString>> lineStrings;
   lineStrings.reserve(partCount);
   for (size_t i = 0; i < partCount; ++i) {
-    lineStrings.push_back(getGeometryFactory()->createLineString(
-        readCoordinates(input, partLengths[i])));
+    lineStrings.push_back(
+        getGeometryFactory()->createLineString(
+            readCoordinates(input, partLengths[i])));
   }
 
   if (multiType) {
@@ -222,22 +241,35 @@ std::unique_ptr<geos::geom::Geometry> GeometryDeserializer::readPolygon(
   std::vector<std::unique_ptr<geos::geom::LinearRing>> holes;
   std::vector<std::unique_ptr<geos::geom::Polygon>> polygons;
 
+  // Shells _should_ be clockwise and holes _should_ be counter-clockwise,
+  // but this doesn't always happen for single Polygons. For single Polygons,
+  // we read the first ring as a shell and the rest as holes. For MultiPolygons,
+  // we read the first ring as a shell, and any counter-clockwise rings as
+  // holes, then push a polygon and reset if a clockwise ring is encountered.
   for (size_t i = 0; i < partCount; i++) {
     auto coordinates = readCoordinates(input, partLengths[i]);
 
-    if (isClockwise(coordinates, 0, coordinates->size())) {
-      // next polygon has started
-      if (shell) {
-        polygons.push_back(getGeometryFactory()->createPolygon(
-            std::move(shell), std::move(holes)));
+    if (multiType) {
+      bool clockwiseFlag =
+          GeometrySerializer::isClockwise(coordinates, 0, coordinates->size());
+      if (shell && clockwiseFlag) {
+        // next polygon has started
+        polygons.push_back(
+            getGeometryFactory()->createPolygon(
+                std::move(shell), std::move(holes)));
         holes.clear();
+        shell = nullptr;
       }
-      shell = getGeometryFactory()->createLinearRing(std::move(coordinates));
+    }
+
+    auto ring = getGeometryFactory()->createLinearRing(std::move(coordinates));
+    if (shell == nullptr) {
+      shell = std::move(ring);
     } else {
-      holes.push_back(
-          getGeometryFactory()->createLinearRing(std::move(coordinates)));
+      holes.push_back(std::move(ring));
     }
   }
+
   polygons.push_back(
       getGeometryFactory()->createPolygon(std::move(shell), std::move(holes)));
 
@@ -297,4 +329,4 @@ GeometryDeserializer::readGeometryCollection(
       getGeometryFactory()->createGeometryCollection(rawGeometries));
 }
 
-} // namespace facebook::velox::functions::geospatial
+} // namespace facebook::velox::common::geospatial
diff --git a/velox/functions/prestosql/geospatial/GeometrySerde.h b/velox/common/geospatial/GeometrySerde.h
similarity index 72%
rename from velox/functions/prestosql/geospatial/GeometrySerde.h
rename to velox/common/geospatial/GeometrySerde.h
index e85c00acbd1..e65bd4bb0c2 100644
--- a/velox/functions/prestosql/geospatial/GeometrySerde.h
+++ b/velox/common/geospatial/GeometrySerde.h
@@ -16,32 +16,17 @@
 
 #pragma once
 
+#include <folly/Likely.h>
+#include <geos/geom/CoordinateArraySequence.h>
 #include <geos/geom/Geometry.h>
 #include <geos/geom/GeometryFactory.h>
 
 #include "velox/common/base/IOUtils.h"
-#include "velox/functions/prestosql/geospatial/GeometryUtils.h"
+#include "velox/common/geospatial/GeometryConstants.h"
+#include "velox/expression/ComplexViewTypes.h"
 #include "velox/type/StringView.h"
 
-namespace facebook::velox::functions::geospatial {
-
-enum class GeometrySerializationType : uint8_t {
-  POINT = 0,
-  MULTI_POINT = 1,
-  LINE_STRING = 2,
-  MULTI_LINE_STRING = 3,
-  POLYGON = 4,
-  MULTI_POLYGON = 5,
-  GEOMETRY_COLLECTION = 6,
-  ENVELOPE = 7
-};
-
-enum class EsriShapeType : uint32_t {
-  POINT = 1,
-  POLYLINE = 3,
-  POLYGON = 5,
-  MULTI_POINT = 8
-};
+namespace facebook::velox::common::geospatial {
 
 /**
  * VarbinaryWriter is a utility for serializing raw binary data to a
@@ -55,7 +40,8 @@ enum class EsriShapeType : uint32_t {
 template <typename StringWriter>
 class VarbinaryWriter {
  public:
-  VarbinaryWriter(StringWriter& stringWriter) : stringWriter_(stringWriter) {}
+  /* implicit */ VarbinaryWriter(StringWriter& stringWriter)
+      : stringWriter_(stringWriter) {}
   VarbinaryWriter() = delete;
 
   void write(const char* data, size_t size) {
@@ -122,6 +108,70 @@ class GeometrySerializer {
     }
   }
 
+  /// Determines if a ring of coordinates (from `start` to `end`) is oriented
+  /// clockwise.
+  FOLLY_ALWAYS_INLINE static bool isClockwise(
+      const std::unique_ptr<geos::geom::CoordinateSequence>& coordinates,
+      size_t start,
+      size_t end) {
+    double sum = 0.0;
+    for (size_t i = start; i < end - 1; i++) {
+      const auto& p1 = coordinates->getAt(i);
+      const auto& p2 = coordinates->getAt(i + 1);
+      sum += (p2.x - p1.x) * (p2.y + p1.y);
+    }
+    return sum > 0.0;
+  }
+
+  /// Reverses the order of coordinates in the sequence between `start` and
+  /// `end`
+  FOLLY_ALWAYS_INLINE static void reverse(
+      const std::unique_ptr<geos::geom::CoordinateSequence>& coordinates,
+      size_t start,
+      size_t end) {
+    for (size_t i = 0; i < (end - start) / 2; ++i) {
+      auto temp = coordinates->getAt(start + i);
+      coordinates->setAt(coordinates->getAt(end - 1 - i), start + i);
+      coordinates->setAt(temp, end - 1 - i);
+    }
+  }
+
+  /// Ensures that a polygon ring has the canonical orientation:
+  /// - Exterior rings (shells) must be clockwise.
+  /// - Interior rings (holes) must be counter-clockwise.
+  FOLLY_ALWAYS_INLINE static void canonicalizePolygonCoordinates(
+      const std::unique_ptr<geos::geom::CoordinateSequence>& coordinates,
+      size_t start,
+      size_t end,
+      bool isShell) {
+    bool isClockwiseFlag = isClockwise(coordinates, start, end);
+
+    if ((isShell && !isClockwiseFlag) || (!isShell && isClockwiseFlag)) {
+      reverse(coordinates, start, end);
+    }
+  }
+
+  /// Applies `canonicalizePolygonCoordinates` to all rings in a polygon.
+  FOLLY_ALWAYS_INLINE static void canonicalizePolygonCoordinates(
+      const std::unique_ptr<geos::geom::CoordinateSequence>& coordinates,
+      const std::vector<size_t>& partIndexes,
+      const std::vector<bool>& shellPart) {
+    for (size_t part = 0; part < partIndexes.size() - 1; part++) {
+      canonicalizePolygonCoordinates(
+          coordinates,
+          partIndexes[part],
+          partIndexes[part + 1],
+          shellPart[part]);
+    }
+    if (!partIndexes.empty()) {
+      canonicalizePolygonCoordinates(
+          coordinates,
+          partIndexes.back(),
+          coordinates->size(),
+          shellPart.back());
+    }
+  }
+
  private:
   template <typename T>
   static void writeGeometry(
@@ -359,6 +409,68 @@ class GeometryDeserializer {
   static const std::unique_ptr<geos::geom::Envelope> deserializeEnvelope(
       const StringView& geometry);
 
+  /// Deserializes a geometry, returning nullptr for empty geometries
+  /// (those with null envelopes).
+  static std::unique_ptr<geos::geom::Geometry> deserializeNonEmpty(
+      const StringView& geometry);
+
+  template <typename T>
+  static std::unique_ptr<geos::geom::CoordinateArraySequence>
+  deserializePointsToCoordinate(
+      const exec::ArrayView<true, T>& input,
+      const std::string& functionName,
+      bool forbidDuplicates) {
+    std::unique_ptr<geos::geom::CoordinateArraySequence> coords =
+        std::make_unique<geos::geom::CoordinateArraySequence>(input.size(), 2);
+
+    double lastX = std::numeric_limits<double>::signaling_NaN();
+    double lastY = std::numeric_limits<double>::signaling_NaN();
+    for (int i = 0; i < input.size(); i++) {
+      if (!input[i].has_value()) {
+        VELOX_USER_FAIL(
+            fmt::format(
+                "Invalid input to {}: input array contains null at index {}.",
+                functionName,
+                i));
+      }
+
+      StringView view = *input[i];
+
+      velox::common::InputByteStream inputStream(view.data());
+      auto geometryType = inputStream.read<GeometrySerializationType>();
+      if (geometryType != GeometrySerializationType::POINT) {
+        VELOX_USER_FAIL(
+            fmt::format(
+                "Non-point geometry in {} input at index {}.",
+                functionName,
+                i));
+      }
+      auto x = inputStream.read<double>();
+      auto y = inputStream.read<double>();
+      if (std::isnan(x) || std::isnan(y)) {
+        VELOX_USER_FAIL(
+            fmt::format(
+                "Empty point in {} input at index {}.", functionName, i));
+      }
+      if (forbidDuplicates && x == lastX && y == lastY) {
+        VELOX_USER_FAIL(
+            fmt::format(
+                "Repeated point sequence in {}: point {},{} at index {}.",
+                functionName,
+                x,
+                y,
+                i));
+      }
+      lastX = x;
+      lastY = y;
+      coords->setAt({x, y}, i);
+    }
+    return coords;
+  }
+
+  /// Returns the thread-local GEOS geometry factory.
+  static geos::geom::GeometryFactory* getGeometryFactory();
+
  private:
   static std::unique_ptr<geos::geom::Geometry> readGeometry(
       velox::common::InputByteStream& stream,
@@ -408,4 +520,4 @@ class GeometryDeserializer {
       size_t size);
 };
 
-} // namespace facebook::velox::functions::geospatial
+} // namespace facebook::velox::common::geospatial
diff --git a/velox/common/geospatial/tests/CMakeLists.txt b/velox/common/geospatial/tests/CMakeLists.txt
new file mode 100644
index 00000000000..55b2f76cde5
--- /dev/null
+++ b/velox/common/geospatial/tests/CMakeLists.txt
@@ -0,0 +1,29 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+if(VELOX_ENABLE_GEO)
+  add_executable(velox_common_geospatial_serde_test GeometrySerdeTest.cpp)
+
+  add_test(velox_common_geospatial_serde_test velox_common_geospatial_serde_test)
+
+  target_link_libraries(
+    velox_common_geospatial_serde_test
+    velox_common_geospatial_serde
+    GTest::gtest
+    GTest::gtest_main
+    GTest::gmock
+    GTest::gmock_main
+    GEOS::geos
+  )
+endif()
diff --git a/velox/functions/prestosql/geospatial/tests/GeometrySerdeTest.cpp b/velox/common/geospatial/tests/GeometrySerdeTest.cpp
similarity index 76%
rename from velox/functions/prestosql/geospatial/tests/GeometrySerdeTest.cpp
rename to velox/common/geospatial/tests/GeometrySerdeTest.cpp
index 3dba74c756f..14ee6186a68 100644
--- a/velox/functions/prestosql/geospatial/tests/GeometrySerdeTest.cpp
+++ b/velox/common/geospatial/tests/GeometrySerdeTest.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "velox/functions/prestosql/geospatial/GeometrySerde.h"
+#include "velox/common/geospatial/GeometrySerde.h"
 #include <geos/geom/Geometry.h>
 #include <geos/io/WKTReader.h>
 #include <geos/io/WKTWriter.h>
@@ -23,7 +23,7 @@
 
 using namespace ::testing;
 
-using namespace facebook::velox::functions::geospatial;
+using namespace facebook::velox::common::geospatial;
 
 void assertRoundtrip(const std::string& wkt) {
   geos::io::WKTReader reader;
@@ -100,3 +100,8 @@ TEST(GeometrySerdeTest, testComplexSerde) {
   assertRoundtrip(
       "GEOMETRYCOLLECTION (POLYGON EMPTY, GEOMETRYCOLLECTION ( POINT (1 2), POLYGON ((0 0, 4 0, 4 4, 0 4, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1)), GEOMETRYCOLLECTION EMPTY, MULTIPOLYGON ( ((10 10, 14 10, 14 14, 10 14, 10 10), (11 11, 12 11, 12 12, 11 12, 11 11)), ((-1 -1, -2 -2, -1 -2, -1 -1)) ) ))");
 }
+
+TEST(GeometrySerdeTest, testSmallAreaRing) {
+  assertRoundtrip(
+      "MULTIPOLYGON (((18.6317421 49.9605785, 18.6318832 49.9607979, 18.6324683 49.9607312, 18.6332842 49.9605658, 18.6332003 49.9603557, 18.6339711 49.9602283, 18.6341994 49.9601905, 18.6343455 49.96016, 18.6344167 49.9601452, 18.6346696 49.9600919, 18.6349643 49.9600567, 18.6352271 49.9601455, 18.6354493 49.9600501, 18.6358024 49.9601071, 18.6358911 49.9600263, 18.6336542 49.9592453, 18.6334794 49.9591838, 18.6337483 49.9581339, 18.6335303 49.9580562, 18.6331284 49.9579122, 18.6324931 49.9576885, 18.6322503 49.9575998, 18.6321381 49.9581593, 18.6321172 49.9582692, 18.6324683 49.9583852, 18.6325255 49.9584004, 18.6327588 49.958489, 18.6324792 49.9588351, 18.6323941 49.9588049, 18.6323261 49.9587807, 18.6320354 49.9586789, 18.6319443 49.9592903, 18.6326731 49.9595648, 18.6331388 49.9594836, 18.6335981 49.959673, 18.6333065 49.9597934, 18.6328096 49.9600844, 18.6330209 49.9601348, 18.633424 49.9602597, 18.6332263 49.960317, 18.6315633 49.9597642, 18.6309331 49.9600741, 18.6317421 49.9605785)), ((18.6298591 49.9606201, 18.6298592 49.96062, 18.6298589 49.9606193, 18.6298591 49.9606201)))");
+}
diff --git a/velox/common/hyperloglog/CMakeLists.txt b/velox/common/hyperloglog/CMakeLists.txt
index 649d1bc9851..6a03daed873 100644
--- a/velox/common/hyperloglog/CMakeLists.txt
+++ b/velox/common/hyperloglog/CMakeLists.txt
@@ -17,6 +17,12 @@ velox_add_library(
   DenseHll.cpp
   SparseHll.cpp
   Murmur3Hash128.cpp
+  HEADERS
+  BiasCorrection.h
+  DenseHll.h
+  HllUtils.h
+  Murmur3Hash128.h
+  SparseHll.h
 )
 
 velox_link_libraries(velox_common_hyperloglog PUBLIC velox_memory PRIVATE velox_exception)
diff --git a/velox/common/hyperloglog/DenseHll.cpp b/velox/common/hyperloglog/DenseHll.cpp
index f3a3f54b2d2..b7b7a31fe78 100644
--- a/velox/common/hyperloglog/DenseHll.cpp
+++ b/velox/common/hyperloglog/DenseHll.cpp
@@ -15,13 +15,13 @@
  */
 #include "velox/common/hyperloglog/DenseHll.h"
 
-#include <exception>
-#include <sstream>
+#include "velox/common/base/BitUtil.h"
 #include "velox/common/base/IOUtils.h"
 #include "velox/common/hyperloglog/BiasCorrection.h"
 #include "velox/common/hyperloglog/HllUtils.h"
 
 namespace facebook::velox::common::hll {
+
 namespace {
 const int kBitsPerBucket = 4;
 const int8_t kMaxDelta = (1 << kBitsPerBucket) - 1;
@@ -119,14 +119,26 @@ double correctBias(double rawEstimate, int8_t indexBitLength) {
 }
 } // namespace
 
-DenseHll::DenseHll(int8_t indexBitLength, HashStringAllocator* allocator)
-    : deltas_{StlAllocator<int8_t>(allocator)},
-      overflowBuckets_{StlAllocator<uint16_t>(allocator)},
-      overflowValues_{StlAllocator<int8_t>(allocator)} {
+template <typename TAllocator>
+DenseHll<TAllocator>::DenseHll(int8_t indexBitLength, TAllocator* allocator)
+    : allocator_(allocator),
+      deltas_{TStlAllocator<int8_t>(allocator)},
+      overflowBuckets_{TStlAllocator<uint16_t>(allocator)},
+      overflowValues_{TStlAllocator<int8_t>(allocator)} {
   initialize(indexBitLength);
 }
 
-void DenseHll::initialize(int8_t indexBitLength) {
+template <typename TAllocator>
+DenseHll<TAllocator>::DenseHll(TAllocator* allocator)
+    : indexBitLength_(-1),
+      baselineCount_(0),
+      allocator_(allocator),
+      deltas_{TStlAllocator<int8_t>(allocator)},
+      overflowBuckets_{TStlAllocator<uint16_t>(allocator)},
+      overflowValues_{TStlAllocator<int8_t>(allocator)} {}
+
+template <typename TAllocator>
+void DenseHll<TAllocator>::initialize(int8_t indexBitLength) {
   VELOX_CHECK_GE(indexBitLength, 4, "indexBitLength must be in [4, 16] range");
   VELOX_CHECK_LE(indexBitLength, 16, "indexBitLength must be in [4, 16] range");
 
@@ -137,13 +149,15 @@ void DenseHll::initialize(int8_t indexBitLength) {
   deltas_.resize(numBuckets * kBitsPerBucket / 8);
 }
 
-void DenseHll::insertHash(uint64_t hash) {
+template <typename TAllocator>
+void DenseHll<TAllocator>::insertHash(uint64_t hash) {
   auto index = computeIndex(hash, indexBitLength_);
   auto value = numberOfLeadingZeros(hash, indexBitLength_) + 1;
   insert(index, value);
 }
 
-void DenseHll::insert(int32_t index, int8_t value) {
+template <typename TAllocator>
+void DenseHll<TAllocator>::insert(int32_t index, int8_t value) {
   auto delta = value - baseline_;
   auto oldDelta = getDelta(index);
 
@@ -238,6 +252,9 @@ DenseHllView deserialize(const char* serialized) {
   VELOX_CHECK_EQ(kPrestoDenseV2, version);
 
   auto indexBitLength = stream.read<int8_t>();
+  VELOX_CHECK_GE(indexBitLength, 4, "indexBitLength must be in [4, 16] range");
+  VELOX_CHECK_LE(indexBitLength, 16, "indexBitLength must be in [4, 16] range");
+
   auto baseline = stream.read<int8_t>();
 
   auto numBuckets = 1 << indexBitLength;
@@ -245,6 +262,8 @@ DenseHllView deserialize(const char* serialized) {
   const int8_t* deltas = stream.read<int8_t>(numBuckets / 2);
 
   auto overflows = stream.read<int16_t>();
+  VELOX_CHECK_GE(
+      overflows, 0, "Invalid DenseHll overflow count: {}", overflows);
 
   const uint16_t* overflowBuckets =
       overflows ? stream.read<uint16_t>(overflows) : nullptr;
@@ -261,7 +280,8 @@ DenseHllView deserialize(const char* serialized) {
 }
 } // namespace
 
-int64_t DenseHll::cardinality() const {
+template <typename TAllocator>
+int64_t DenseHll<TAllocator>::cardinality() const {
   DenseHllView hll{
       indexBitLength_,
       baseline_,
@@ -272,18 +292,14 @@ int64_t DenseHll::cardinality() const {
   return cardinalityImpl(hll);
 }
 
-// static
-int64_t DenseHll::cardinality(const char* serialized) {
-  auto hll = deserialize(serialized);
-  return cardinalityImpl(hll);
-}
-
-int8_t DenseHll::getDelta(int32_t index) const {
+template <typename TAllocator>
+int8_t DenseHll<TAllocator>::getDelta(int32_t index) const {
   int slot = index >> 1;
   return (deltas_[slot] >> shiftForBucket(index)) & kBucketMask;
 }
 
-void DenseHll::setDelta(int32_t index, int8_t value) {
+template <typename TAllocator>
+void DenseHll<TAllocator>::setDelta(int32_t index, int8_t value) {
   int slot = index >> 1;
 
   // Clear the old value.
@@ -295,12 +311,14 @@ void DenseHll::setDelta(int32_t index, int8_t value) {
   deltas_[slot] |= setMask;
 }
 
-int8_t DenseHll::getOverflow(int32_t index) const {
+template <typename TAllocator>
+int8_t DenseHll<TAllocator>::getOverflow(int32_t index) const {
   return getOverflowImpl(
       index, overflows_, overflowBuckets_.data(), overflowValues_.data());
 }
 
-int DenseHll::findOverflowEntry(int32_t index) const {
+template <typename TAllocator>
+int DenseHll<TAllocator>::findOverflowEntry(int32_t index) const {
   for (auto i = 0; i < overflows_; i++) {
     if (overflowBuckets_[i] == index) {
       return i;
@@ -309,7 +327,8 @@ int DenseHll::findOverflowEntry(int32_t index) const {
   return -1;
 }
 
-void DenseHll::adjustBaselineIfNeeded() {
+template <typename TAllocator>
+void DenseHll<TAllocator>::adjustBaselineIfNeeded() {
   auto numBuckets = 1 << indexBitLength_;
 
   while (baselineCount_ == 0) {
@@ -359,7 +378,8 @@ void DenseHll::adjustBaselineIfNeeded() {
   }
 }
 
-void DenseHll::sortOverflows() {
+template <typename TAllocator>
+void DenseHll<TAllocator>::sortOverflows() {
   // traditional insertion sort (ok for small arrays)
   for (int i = 1; i < overflows_; i++) {
     auto bucket = overflowBuckets_[i];
@@ -385,7 +405,8 @@ void DenseHll::sortOverflows() {
   }
 }
 
-int32_t DenseHll::serializedSize() const {
+template <typename TAllocator>
+int32_t DenseHll<TAllocator>::serializedSize() const {
   return 1 /* type + version */
       + 1 /* indexBitLength */
       + 1 /* baseline */
@@ -395,13 +416,17 @@ int32_t DenseHll::serializedSize() const {
       + overflows_ /* overflow bucket values */;
 }
 
-// static
-bool DenseHll::canDeserialize(const char* input) {
+int64_t DenseHlls::cardinality(const char* serialized) {
+  auto hll = deserialize(serialized);
+  return cardinalityImpl(hll);
+}
+
+bool DenseHlls::canDeserialize(const char* input) {
   return *reinterpret_cast<const int8_t*>(input) == kPrestoDenseV2;
 }
 
 // static
-bool DenseHll::canDeserialize(const char* input, int size) {
+bool DenseHlls::canDeserialize(const char* input, int size) {
   if (size < 5) {
     // Min serialized sparse HLL size is 5 bytes.
     return false;
@@ -459,22 +484,23 @@ bool DenseHll::canDeserialize(const char* input, int size) {
   return true;
 }
 
-// static
-int8_t DenseHll::deserializeIndexBitLength(const char* input) {
+int8_t DenseHlls::deserializeIndexBitLength(const char* input) {
   common::InputByteStream stream(input);
   stream.read<int8_t>();
   return stream.read<int8_t>();
 }
 
-// static
-int32_t DenseHll::estimateInMemorySize(int8_t indexBitLength) {
+int32_t DenseHlls::estimateInMemorySize(int8_t indexBitLength) {
   // Note: we don't take into account overflow entries since their number can
   // vary.
-  return sizeof(indexBitLength_) + sizeof(baseline_) + sizeof(baselineCount_) +
+  // return sizeof(indexBitLength_) + sizeof(baseline_) +
+  // sizeof(baselineCount_) + (1 << indexBitLength) / 2;
+  return sizeof(int8_t) + sizeof(int8_t) + sizeof(int32_t) +
       (1 << indexBitLength) / 2;
 }
 
-void DenseHll::serialize(char* output) {
+template <typename TAllocator>
+void DenseHll<TAllocator>::serialize(char* output) {
   // sort overflow arrays to get consistent serialization for equivalent HLLs
   sortOverflows();
 
@@ -492,10 +518,12 @@ void DenseHll::serialize(char* output) {
   }
 }
 
-DenseHll::DenseHll(const char* serialized, HashStringAllocator* allocator)
-    : deltas_{StlAllocator<int8_t>(allocator)},
-      overflowBuckets_{StlAllocator<uint16_t>(allocator)},
-      overflowValues_{StlAllocator<int8_t>(allocator)} {
+template <typename TAllocator>
+DenseHll<TAllocator>::DenseHll(const char* serialized, TAllocator* allocator)
+    : allocator_(allocator),
+      deltas_{TStlAllocator<int8_t>(allocator)},
+      overflowBuckets_{TStlAllocator<uint16_t>(allocator)},
+      overflowValues_{TStlAllocator<int8_t>(allocator)} {
   auto hll = deserialize(serialized);
   initialize(hll.indexBitLength);
   baseline_ = hll.baseline;
@@ -525,7 +553,8 @@ DenseHll::DenseHll(const char* serialized, HashStringAllocator* allocator)
   }
 }
 
-void DenseHll::mergeWith(const DenseHll& other) {
+template <typename TAllocator>
+void DenseHll<TAllocator>::mergeWith(const DenseHll& other) {
   VELOX_CHECK_EQ(
       indexBitLength_,
       other.indexBitLength_,
@@ -539,7 +568,8 @@ void DenseHll::mergeWith(const DenseHll& other) {
        other.overflowValues_.data()});
 }
 
-void DenseHll::mergeWith(const char* serialized) {
+template <typename TAllocator>
+void DenseHll<TAllocator>::mergeWith(const char* serialized) {
   common::InputByteStream stream(serialized);
 
   auto version = stream.read<int8_t>();
@@ -561,7 +591,8 @@ void DenseHll::mergeWith(const char* serialized) {
   mergeWith({baseline, deltas, overflows, overflowBuckets, overflowValues});
 }
 
-std::pair<int8_t, int16_t> DenseHll::computeNewValue(
+template <typename TAllocator>
+std::pair<int8_t, int16_t> DenseHll<TAllocator>::computeNewValue(
     int8_t delta,
     int8_t otherDelta,
     int32_t bucket,
@@ -585,7 +616,8 @@ std::pair<int8_t, int16_t> DenseHll::computeNewValue(
   return {std::max(value1, value2), overflowEntry};
 }
 
-void DenseHll::mergeWith(const HllView& other) {
+template <typename TAllocator>
+void DenseHll<TAllocator>::mergeWith(const HllView& other) {
   // Number of 'delta' bytes that fit in a single SIMD batch. Each 'delta' byte
   // stores 2 4-bit deltas.
   constexpr auto batchSize = xsimd::batch<int8_t>::size;
@@ -611,7 +643,10 @@ void DenseHll::mergeWith(const HllView& other) {
   adjustBaselineIfNeeded();
 }
 
-int32_t DenseHll::mergeWithSimd(const HllView& other, int8_t newBaseline) {
+template <typename TAllocator>
+int32_t DenseHll<TAllocator>::mergeWithSimd(
+    const HllView& other,
+    int8_t newBaseline) {
   const auto batchSize = xsimd::batch<int8_t>::size;
 
   const auto bucketMaskBatch = xsimd::broadcast(kBucketMask);
@@ -751,7 +786,10 @@ int32_t DenseHll::mergeWithSimd(const HllView& other, int8_t newBaseline) {
   return baselineCount;
 }
 
-int32_t DenseHll::mergeWithScalar(const HllView& other, int8_t newBaseline) {
+template <typename TAllocator>
+int32_t DenseHll<TAllocator>::mergeWithScalar(
+    const HllView& other,
+    int8_t newBaseline) {
   int32_t baselineCount = 0;
 
   int bucket = 0;
@@ -787,8 +825,11 @@ int32_t DenseHll::mergeWithScalar(const HllView& other, int8_t newBaseline) {
   return baselineCount;
 }
 
-int8_t
-DenseHll::updateOverflow(int32_t index, int overflowEntry, int8_t delta) {
+template <typename TAllocator>
+int8_t DenseHll<TAllocator>::updateOverflow(
+    int32_t index,
+    int overflowEntry,
+    int8_t delta) {
   if (delta > kMaxDelta) {
     if (overflowEntry != -1) {
       // update existing overflow
@@ -804,7 +845,8 @@ DenseHll::updateOverflow(int32_t index, int overflowEntry, int8_t delta) {
   return delta;
 }
 
-void DenseHll::addOverflow(int32_t index, int8_t overflow) {
+template <typename TAllocator>
+void DenseHll<TAllocator>::addOverflow(int32_t index, int8_t overflow) {
   overflowBuckets_.resize(overflows_ + 1);
   overflowValues_.resize(overflows_ + 1);
 
@@ -813,10 +855,17 @@ void DenseHll::addOverflow(int32_t index, int8_t overflow) {
   overflows_++;
 }
 
-void DenseHll::removeOverflow(int overflowEntry) {
+template <typename TAllocator>
+void DenseHll<TAllocator>::removeOverflow(int overflowEntry) {
   // Remove existing overflow.
   overflowBuckets_[overflowEntry] = overflowBuckets_[overflows_ - 1];
   overflowValues_[overflowEntry] = overflowValues_[overflows_ - 1];
   overflows_--;
 }
+
+// Explicit template instantiation for both HashStringAllocator (default) and
+// memory::MemoryPool
+template class DenseHll<HashStringAllocator>;
+template class DenseHll<memory::MemoryPool>;
+
 } // namespace facebook::velox::common::hll
diff --git a/velox/common/hyperloglog/DenseHll.h b/velox/common/hyperloglog/DenseHll.h
index b6b5f03f8cd..6936b6d8085 100644
--- a/velox/common/hyperloglog/DenseHll.h
+++ b/velox/common/hyperloglog/DenseHll.h
@@ -17,7 +17,45 @@
 #include "velox/common/memory/HashStringAllocator.h"
 
 namespace facebook::velox::common::hll {
-class SparseHll;
+
+class DenseHlls {
+ public:
+  /// Returns cardinality estimate from the specified serialized digest.
+  /// @param serialized Pointer to serialized DenseHll data
+  /// @return Estimated cardinality of the HyperLogLog
+  static int64_t cardinality(const char* serialized);
+
+  /// Returns true if 'input' contains Presto DenseV2 format indicator.
+  /// @param input Pointer to serialized data to check
+  /// @return True if the data is in DenseV2 format, false otherwise
+  static bool canDeserialize(const char* input);
+
+  /// Returns true if 'input' contains Presto DenseV2 format indicator and the
+  /// rest of the data matches HLL format:
+  /// 1 byte for version
+  /// 1 byte for index bit length, index bit length must be in [4,16]
+  /// 1 byte for baseline value
+  /// 2^(n-1) bytes for buckets, values in buckets must be in [0,63]
+  /// 2 bytes for # overflow buckets
+  /// 3 * #overflow buckets bytes for overflow buckets/values
+  /// More information here:
+  /// https://engineering.fb.com/2018/12/13/data-infrastructure/hyperloglog/
+  /// @param input Pointer to serialized data to validate
+  /// @param size Size of the serialized data in bytes
+  /// @return True if the data is valid DenseV2 format, false otherwise
+  static bool canDeserialize(const char* input, int size);
+
+  /// Extracts the index bit length from serialized DenseHll data.
+  /// @param input Pointer to serialized DenseHll data
+  /// @return The index bit length used in the serialized HLL
+  static int8_t deserializeIndexBitLength(const char* input);
+
+  /// Returns an estimate of memory usage for DenseHll instance with the
+  /// specified number of bits per bucket.
+  /// @param indexBitLength Number of bits per bucket (must be in [4,16])
+  /// @return Estimated memory usage in bytes
+  static int32_t estimateInMemorySize(int8_t indexBitLength);
+};
 
 /// HyperLogLog implementation using dense storage layout.
 /// The number of bits to use as bucket (indexBitLength) is specified by the
@@ -26,18 +64,19 @@ class SparseHll;
 ///
 /// Memory usage: 2 ^ (indexBitLength - 1) bytes. 2KB for indexBitLength of 12
 /// which provides max standard error of 0.023.
+template <typename TAllocator = HashStringAllocator>
 class DenseHll {
  public:
-  DenseHll(int8_t indexBitLength, HashStringAllocator* allocator);
+  template <typename U>
+  using TStlAllocator = typename TAllocator::template TStlAllocator<U>;
+
+  DenseHll(int8_t indexBitLength, TAllocator* allocator);
 
-  DenseHll(const char* serialized, HashStringAllocator* allocator);
+  DenseHll(const char* serialized, TAllocator* allocator);
 
   /// Creates an uninitialized instance that doesn't allcate any significant
   /// memory. The caller must call initialize before using the HLL.
-  explicit DenseHll(HashStringAllocator* allocator)
-      : deltas_{StlAllocator<int8_t>(allocator)},
-        overflowBuckets_{StlAllocator<uint16_t>(allocator)},
-        overflowValues_{StlAllocator<int8_t>(allocator)} {}
+  explicit DenseHll(TAllocator* allocator);
 
   /// Allocates memory that can fit 2 ^ indexBitLength buckets.
   void initialize(int8_t indexBitLength);
@@ -55,28 +94,9 @@ class DenseHll {
 
   int64_t cardinality() const;
 
-  static int64_t cardinality(const char* serialized);
-
   /// Serializes internal state using Presto DenseV2 format.
   void serialize(char* output);
 
-  /// Returns true if 'input' contains Presto DenseV2 format indicator.
-  static bool canDeserialize(const char* input);
-
-  /// Returns true if 'input' contains Presto DenseV2 format indicator and the
-  /// rest of the data matches HLL format:
-  /// 1 byte for version
-  /// 1 byte for index bit length, index bit length must be in [4,16]
-  /// 1 byte for baseline value
-  /// 2^(n-1) bytes for buckets, values in buckets must be in [0,63]
-  /// 2 bytes for # overflow buckets
-  /// 3 * #overflow buckets bytes for overflow buckets/values
-  /// More information here:
-  /// https://engineering.fb.com/2018/12/13/data-infrastructure/hyperloglog/
-  static bool canDeserialize(const char* input, int size);
-
-  static int8_t deserializeIndexBitLength(const char* input);
-
   /// Returns the size of the serialized state without serialising.
   int32_t serializedSize() const;
 
@@ -86,10 +106,6 @@ class DenseHll {
 
   void mergeWith(const char* serialized);
 
-  /// Returns an estimate of memory usage for DenseHll instance with the
-  /// specified number of bits per bucket.
-  static int32_t estimateInMemorySize(int8_t indexBitLength);
-
  private:
   int8_t getDelta(int32_t index) const;
 
@@ -147,20 +163,19 @@ class DenseHll {
   /// Number of zero deltas.
   int32_t baselineCount_;
 
+  TAllocator* allocator_;
+
   /// Per-bucket values represented as deltas from the baseline_. Each entry
   /// stores 2 values, 4 bits each. The maximum value that can be stored is 15.
   /// Larger values are stored in a separate overflow list.
-  std::vector<int8_t, StlAllocator<int8_t>> deltas_;
-
-  /// Number of overflowing values, e.g. values where delta from baseline is
-  /// greater than 15.
+  std::vector<int8_t, TStlAllocator<int8_t>> deltas_;
   int16_t overflows_{0};
 
   /// List of buckets with overflowing values.
-  std::vector<uint16_t, StlAllocator<uint16_t>> overflowBuckets_;
+  std::vector<uint16_t, TStlAllocator<uint16_t>> overflowBuckets_;
 
   /// Overflowing values stored as deltas from the deltas: value - 15 -
   /// baseline.
-  std::vector<int8_t, StlAllocator<int8_t>> overflowValues_;
+  std::vector<int8_t, TStlAllocator<int8_t>> overflowValues_;
 };
 } // namespace facebook::velox::common::hll
diff --git a/velox/common/hyperloglog/SparseHll.cpp b/velox/common/hyperloglog/SparseHll.cpp
index 27d290dd10e..ab29f9d0e88 100644
--- a/velox/common/hyperloglog/SparseHll.cpp
+++ b/velox/common/hyperloglog/SparseHll.cpp
@@ -34,9 +34,8 @@ inline uint32_t decodeValue(uint32_t entry) {
   return entry & ((1 << kValueBitLength) - 1);
 }
 
-int searchIndex(
-    uint32_t index,
-    const std::vector<uint32_t, StlAllocator<uint32_t>>& entries) {
+template <typename VectorType>
+int searchIndex(uint32_t index, const VectorType& entries) {
   int low = 0;
   int high = entries.size() - 1;
 
@@ -69,7 +68,66 @@ common::InputByteStream initializeInputStream(const char* serialized) {
 }
 } // namespace
 
-bool SparseHll::insertHash(uint64_t hash) {
+// Static utility functions implementation
+int64_t SparseHlls::cardinality(const char* serialized) {
+  static const int kTotalBuckets = 1 << kIndexBitLength;
+
+  auto stream = initializeInputStream(serialized);
+  auto size = stream.read<int16_t>();
+
+  int zeroBuckets = kTotalBuckets - size;
+  return std::round(linearCounting(zeroBuckets, kTotalBuckets));
+}
+
+std::string SparseHlls::serializeEmpty(int8_t indexBitLength) {
+  static const size_t kSize = 4;
+
+  std::string serialized;
+  serialized.resize(kSize);
+
+  common::OutputByteStream stream(serialized.data());
+  stream.appendOne(kPrestoSparseV2);
+  stream.appendOne(indexBitLength);
+  stream.appendOne(static_cast<int16_t>(0));
+  return serialized;
+}
+
+bool SparseHlls::canDeserialize(const char* input) {
+  return *reinterpret_cast<const int8_t*>(input) == kPrestoSparseV2;
+}
+
+int8_t SparseHlls::deserializeIndexBitLength(const char* input) {
+  common::InputByteStream stream(input);
+  stream.read<int8_t>(); // Skip version
+  return stream.read<int8_t>(); // Return indexBitLength
+}
+
+// Template method implementations
+template <typename TAllocator>
+SparseHll<TAllocator>::SparseHll(TAllocator* allocator)
+    : allocator_(allocator), entries_{TStlAllocator<uint32_t>(allocator)} {}
+
+template <typename TAllocator>
+SparseHll<TAllocator>::SparseHll(const char* serialized, TAllocator* allocator)
+    : allocator_(allocator), entries_{TStlAllocator<uint32_t>(allocator)} {
+  common::InputByteStream stream(serialized);
+  auto version = stream.read<int8_t>();
+  VELOX_CHECK_EQ(kPrestoSparseV2, version);
+
+  // Skip indexBitLength from serialized data - we use fixed kIndexBitLength
+  // internally
+  stream.read<int8_t>();
+
+  auto size = stream.read<int16_t>();
+  VELOX_CHECK_GE(size, 0, "Invalid SparseHll entry count: {}", size);
+  entries_.resize(size);
+  for (auto i = 0; i < size; i++) {
+    entries_[i] = stream.read<uint32_t>();
+  }
+}
+
+template <typename TAllocator>
+bool SparseHll<TAllocator>::insertHash(uint64_t hash) {
   auto index = computeIndex(hash, kIndexBitLength);
   auto value = numberOfLeadingZeros(hash, kIndexBitLength);
 
@@ -88,29 +146,21 @@ bool SparseHll::insertHash(uint64_t hash) {
   return overLimit();
 }
 
-int64_t SparseHll::cardinality() const {
+template <typename TAllocator>
+int64_t SparseHll<TAllocator>::cardinality() const {
   // Estimate the cardinality using linear counting over the theoretical
   // 2^kIndexBitLength buckets available due to the fact that we're
   // recording the raw leading kIndexBitLength of the hash. This produces
   // much better precision while in the sparse regime.
-  static const int kTotalBuckets = 1 << kIndexBitLength;
+  const int kTotalBuckets = 1 << kIndexBitLength;
 
   int zeroBuckets = kTotalBuckets - entries_.size();
   return std::round(linearCounting(zeroBuckets, kTotalBuckets));
 }
 
-// static
-int64_t SparseHll::cardinality(const char* serialized) {
-  static const int kTotalBuckets = 1 << kIndexBitLength;
-
-  auto stream = initializeInputStream(serialized);
-  auto size = stream.read<int16_t>();
-
-  int zeroBuckets = kTotalBuckets - size;
-  return std::round(linearCounting(zeroBuckets, kTotalBuckets));
-}
-
-void SparseHll::serialize(int8_t indexBitLength, char* output) const {
+template <typename TAllocator>
+void SparseHll<TAllocator>::serialize(int8_t indexBitLength, char* output)
+    const {
   common::OutputByteStream stream(output);
   stream.appendOne(kPrestoSparseV2);
   stream.appendOne(indexBitLength);
@@ -120,75 +170,54 @@ void SparseHll::serialize(int8_t indexBitLength, char* output) const {
   }
 }
 
-// static
-std::string SparseHll::serializeEmpty(int8_t indexBitLength) {
-  static const size_t kSize = 4;
-
-  std::string serialized;
-  serialized.resize(kSize);
-
-  common::OutputByteStream stream(serialized.data());
-  stream.appendOne(kPrestoSparseV2);
-  stream.appendOne(indexBitLength);
-  stream.appendOne(static_cast<int16_t>(0));
-  return serialized;
-}
-
-// static
-bool SparseHll::canDeserialize(const char* input) {
-  return *reinterpret_cast<const int8_t*>(input) == kPrestoSparseV2;
-}
-
-int32_t SparseHll::serializedSize() const {
+template <typename TAllocator>
+int32_t SparseHll<TAllocator>::serializedSize() const {
   return 1 /* version */
       + 1 /* indexBitLength */
       + 2 /* number of entries */
       + entries_.size() * 4;
 }
 
-int32_t SparseHll::inMemorySize() const {
+template <typename TAllocator>
+int32_t SparseHll<TAllocator>::inMemorySize() const {
   return sizeof(uint32_t) * entries_.size();
 }
 
-SparseHll::SparseHll(const char* serialized, HashStringAllocator* allocator)
-    : entries_{StlAllocator<uint32_t>(allocator)} {
-  auto stream = initializeInputStream(serialized);
-
-  auto size = stream.read<int16_t>();
-  entries_.resize(size);
-  for (auto i = 0; i < size; i++) {
-    entries_[i] = stream.read<uint32_t>();
-  }
-}
-
-void SparseHll::mergeWith(const SparseHll& other) {
+template <typename TAllocator>
+void SparseHll<TAllocator>::mergeWith(const SparseHll<TAllocator>& other) {
   auto size = other.entries_.size();
   // This check prevents merge aggregation from being performed on
-  // empty_approx_set(), an empty HyperLogLog. The merge function typically does
-  // not take an empty HyperLogLog structure as an argument.
+  // empty_approx_set(), an empty HyperLogLog. The merge function typically
+  // does not take an empty HyperLogLog structure as an argument.
   if (size) {
     mergeWith(size, other.entries_.data());
   }
 }
 
-void SparseHll::mergeWith(const char* serialized) {
+template <typename TAllocator>
+void SparseHll<TAllocator>::mergeWith(const char* serialized) {
   auto stream = initializeInputStream(serialized);
 
   auto size = stream.read<int16_t>();
   // This check prevents merge aggregation from being performed on
-  // empty_approx_set(), an empty HyperLogLog. The merge function typically does
-  // not take an empty HyperLogLog structure as an argument.
+  // empty_approx_set(), an empty HyperLogLog. The merge function typically
+  // does not take an empty HyperLogLog structure as an argument.
   if (size) {
     mergeWith(
         size, reinterpret_cast<const uint32_t*>(serialized + stream.offset()));
   }
 }
 
-void SparseHll::mergeWith(size_t otherSize, const uint32_t* otherEntries) {
+template <typename TAllocator>
+void SparseHll<TAllocator>::mergeWith(
+    size_t otherSize,
+    const uint32_t* otherEntries) {
   VELOX_CHECK_GT(otherSize, 0);
 
   auto size = entries_.size();
-  std::vector<uint32_t> merged(size + otherSize);
+
+  auto merged = std::vector<uint32_t, TStlAllocator<uint32_t>>(
+      size + otherSize, TStlAllocator<uint32_t>(allocator_));
 
   int pos = 0;
   int leftPos = 0;
@@ -223,7 +252,8 @@ void SparseHll::mergeWith(size_t otherSize, const uint32_t* otherEntries) {
   }
 }
 
-void SparseHll::verify() const {
+template <typename TAllocator>
+void SparseHll<TAllocator>::verify() const {
   if (entries_.size() <= 1) {
     return;
   }
@@ -236,11 +266,11 @@ void SparseHll::verify() const {
   }
 }
 
-void SparseHll::toDense(DenseHll& denseHll) const {
+template <typename TAllocator>
+void SparseHll<TAllocator>::toDense(DenseHll<TAllocator>& denseHll) const {
   auto indexBitLength = denseHll.indexBitLength();
 
-  for (auto i = 0; i < entries_.size(); i++) {
-    auto entry = entries_[i];
+  for (auto entry : entries_) {
     auto index = entry >> (32 - indexBitLength);
     auto shiftedValue = entry << indexBitLength;
     auto zeros = shiftedValue == 0 ? 32 : __builtin_clz(shiftedValue);
@@ -257,4 +287,9 @@ void SparseHll::toDense(DenseHll& denseHll) const {
   }
 }
 
+// Explicit template instantiation for HashStringAllocator (default)
+template class SparseHll<HashStringAllocator>;
+// Explicit template instantiation for memory::MemoryPool
+template class SparseHll<memory::MemoryPool>;
+
 } // namespace facebook::velox::common::hll
diff --git a/velox/common/hyperloglog/SparseHll.h b/velox/common/hyperloglog/SparseHll.h
index e881b577627..61a3cb8cb29 100644
--- a/velox/common/hyperloglog/SparseHll.h
+++ b/velox/common/hyperloglog/SparseHll.h
@@ -18,15 +18,42 @@
 #include "velox/common/memory/HashStringAllocator.h"
 
 namespace facebook::velox::common::hll {
+
+class SparseHlls {
+ public:
+  /// Returns cardinality estimate from the specified serialized digest.
+  /// @param serialized Pointer to serialized SparseHll data
+  /// @return Estimated cardinality of the HyperLogLog
+  static int64_t cardinality(const char* serialized);
+
+  /// Returns true if 'input' has Presto SparseV2 format.
+  /// @param input Pointer to serialized data to check
+  /// @return True if the data is in SparseV2 format, false otherwise
+  static bool canDeserialize(const char* input);
+
+  /// Creates an empty serialized SparseHll with the specified index bit length.
+  /// @param indexBitLength Number of bits for indexing (must be in [4,16])
+  /// @return Serialized empty SparseHll as a string
+  static std::string serializeEmpty(int8_t indexBitLength);
+
+  /// Extracts the index bit length from serialized SparseHll data.
+  /// @param input Pointer to serialized SparseHll data
+  /// @return The index bit length used in the serialized HLL
+  static int8_t deserializeIndexBitLength(const char* input);
+};
+
 /// HyperLogLog implementation using sparse storage layout.
 /// It uses 26-bit buckets and provides high accuracy for low cardinalities.
 /// Memory usage: 4 bytes for each observed bucket.
+template <typename TAllocator = HashStringAllocator>
 class SparseHll {
  public:
-  explicit SparseHll(HashStringAllocator* allocator)
-      : entries_{StlAllocator<uint32_t>(allocator)} {}
+  template <typename U>
+  using TStlAllocator = typename TAllocator::template TStlAllocator<U>;
+
+  explicit SparseHll(TAllocator* allocator);
 
-  SparseHll(const char* serialized, HashStringAllocator* allocator);
+  SparseHll(const char* serialized, TAllocator* allocator);
 
   void setSoftMemoryLimit(uint32_t softMemoryLimit) {
     softNumEntriesLimit_ = softMemoryLimit / 4;
@@ -42,17 +69,9 @@ class SparseHll {
 
   int64_t cardinality() const;
 
-  /// Returns cardinality estimate from the specified serialized digest.
-  static int64_t cardinality(const char* serialized);
-
   /// Serializes internal state using Presto SparseV2 format.
   void serialize(int8_t indexBitLength, char* output) const;
 
-  static std::string serializeEmpty(int8_t indexBitLength);
-
-  /// Returns true if 'input' has Presto SparseV2 format.
-  static bool canDeserialize(const char* input);
-
   /// Returns the size of the serialized state without serialising.
   int32_t serializedSize() const;
 
@@ -63,7 +82,7 @@ class SparseHll {
   void mergeWith(const char* serialized);
 
   /// Merges state into provided instance of DenseHll.
-  void toDense(DenseHll& denseHll) const;
+  void toDense(DenseHll<TAllocator>& denseHll) const;
 
   /// Returns current memory usage.
   int32_t inMemorySize() const;
@@ -84,8 +103,8 @@ class SparseHll {
   /// A list of observed buckets. Each entry is a 32 bit integer encoding 26-bit
   /// bucket and 6-bit value (number of zeros in the input hash after the bucket
   /// + 1).
-  std::vector<uint32_t, StlAllocator<uint32_t>> entries_;
-
+  TAllocator* allocator_;
+  std::vector<uint32_t, TStlAllocator<uint32_t>> entries_;
   /// Number of entries that can be stored before reaching soft memory limit.
   uint32_t softNumEntriesLimit_{0};
 };
diff --git a/velox/common/hyperloglog/benchmarks/DenseHll.cpp b/velox/common/hyperloglog/benchmarks/DenseHll.cpp
index 7233280f1d6..ecda97fac0f 100644
--- a/velox/common/hyperloglog/benchmarks/DenseHll.cpp
+++ b/velox/common/hyperloglog/benchmarks/DenseHll.cpp
@@ -18,8 +18,7 @@
 #include <folly/init/Init.h>
 #include "velox/common/memory/HashStringAllocator.h"
 
-#define XXH_INLINE_ALL
-#include <xxhash.h>
+#include "velox/common/base/XxHashInline.h"
 
 using namespace facebook::velox;
 
@@ -49,7 +48,7 @@ class DenseHllBenchmark {
     folly::BenchmarkSuspender suspender;
 
     HashStringAllocator allocator(pool_);
-    common::hll::DenseHll hll(hashBits, &allocator);
+    common::hll::DenseHll<> hll(hashBits, &allocator);
 
     suspender.dismiss();
 
@@ -61,7 +60,7 @@ class DenseHllBenchmark {
  private:
   std::string makeSerializedHll(int hashBits, int32_t step) {
     HashStringAllocator allocator(pool_);
-    common::hll::DenseHll hll(hashBits, &allocator);
+    common::hll::DenseHll<> hll(hashBits, &allocator);
     for (int32_t i = 0; i < 1'000'000; ++i) {
       auto hash = hashOne(i * step);
       hll.insertHash(hash);
@@ -69,7 +68,7 @@ class DenseHllBenchmark {
     return serialize(hll);
   }
 
-  static std::string serialize(common::hll::DenseHll& denseHll) {
+  static std::string serialize(common::hll::DenseHll<>& denseHll) {
     auto size = denseHll.serializedSize();
     std::string serialized;
     serialized.resize(size);
diff --git a/velox/common/hyperloglog/tests/DenseHllTest.cpp b/velox/common/hyperloglog/tests/DenseHllTest.cpp
index c688a6918c4..c206a7870ff 100644
--- a/velox/common/hyperloglog/tests/DenseHllTest.cpp
+++ b/velox/common/hyperloglog/tests/DenseHllTest.cpp
@@ -15,13 +15,11 @@
  */
 #include "velox/common/hyperloglog/DenseHll.h"
 
+#include <gtest/gtest-typed-test.h>
 #include <gtest/gtest.h>
-#include <algorithm>
-#include <map>
 #include <vector>
 
-#define XXH_INLINE_ALL
-#include <xxhash.h>
+#include "velox/common/base/XxHashInline.h"
 
 #include "velox/common/encode/Base64.h"
 
@@ -34,22 +32,27 @@ uint64_t hashOne(T value) {
   return XXH64(&value, sizeof(value), 0);
 }
 
-class DenseHllTest : public ::testing::TestWithParam<int8_t> {
+template <typename TAllocator>
+class DenseHllTest : public ::testing::Test {
  protected:
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   }
 
-  DenseHll roundTrip(DenseHll& hll) {
-    auto size = hll.serializedSize();
-    std::string serialized;
-    serialized.resize(size);
-    hll.serialize(serialized.data());
+  void SetUp() override {
+    if constexpr (std::is_same_v<TAllocator, HashStringAllocator>) {
+      allocator_ = &hsa_;
+    } else {
+      allocator_ = pool_.get();
+    }
+  }
 
-    return DenseHll(serialized.data(), &allocator_);
+  DenseHll<TAllocator> roundTrip(DenseHll<TAllocator>& hll) {
+    auto serialized = this->serialize(hll);
+    return DenseHll(serialized.data(), allocator_);
   }
 
-  std::string serialize(DenseHll& denseHll) {
+  std::string serialize(DenseHll<TAllocator>& denseHll) {
     auto size = denseHll.serializedSize();
     std::string serialized;
     serialized.resize(size);
@@ -58,23 +61,19 @@ class DenseHllTest : public ::testing::TestWithParam<int8_t> {
   }
 
   template <typename T>
-  void testMergeWith(
-      int8_t indexBitLength,
-      const std::vector<T>& left,
-      const std::vector<T>& right) {
-    testMergeWith(indexBitLength, left, right, false);
-    testMergeWith(indexBitLength, left, right, true);
+  void testMergeWith(const std::vector<T>& left, const std::vector<T>& right) {
+    testMergeWith(left, right, false);
+    testMergeWith(left, right, true);
   }
 
   template <typename T>
   void testMergeWith(
-      int8_t indexBitLength,
       const std::vector<T>& left,
       const std::vector<T>& right,
       bool serialized) {
-    DenseHll hllLeft{indexBitLength, &allocator_};
-    DenseHll hllRight{indexBitLength, &allocator_};
-    DenseHll expected{indexBitLength, &allocator_};
+    DenseHll hllLeft{11, allocator_};
+    DenseHll hllRight{11, allocator_};
+    DenseHll expected{11, allocator_};
 
     for (auto value : left) {
       auto hash = hashOne(value);
@@ -89,30 +88,51 @@ class DenseHllTest : public ::testing::TestWithParam<int8_t> {
     }
 
     if (serialized) {
-      auto serializedRight = serialize(hllRight);
+      auto serializedRight = this->serialize(hllRight);
       hllLeft.mergeWith(serializedRight.data());
     } else {
       hllLeft.mergeWith(hllRight);
     }
 
     ASSERT_EQ(hllLeft.cardinality(), expected.cardinality());
-    ASSERT_EQ(serialize(hllLeft), serialize(expected));
+    ASSERT_EQ(this->serialize(hllLeft), this->serialize(expected));
 
-    auto hllLeftSerialized = serialize(hllLeft);
+    auto hllLeftSerialized = this->serialize(hllLeft);
     ASSERT_EQ(
-        DenseHll::cardinality(hllLeftSerialized.data()),
+        DenseHlls::cardinality(hllLeftSerialized.data()),
         expected.cardinality());
   }
 
   std::shared_ptr<memory::MemoryPool> pool_{
       memory::memoryManager()->addLeafPool()};
-  HashStringAllocator allocator_{pool_.get()};
+  HashStringAllocator hsa_{pool_.get()};
+  TAllocator* allocator_;
 };
 
-TEST_P(DenseHllTest, basic) {
-  int8_t indexBitLength = GetParam();
+using AllocatorTypes =
+    ::testing::Types<HashStringAllocator, memory::MemoryPool>;
+
+class NameGenerator {
+ public:
+  template <typename TAllocator>
+  static std::string GetName(int) {
+    if constexpr (std::is_same_v<TAllocator, HashStringAllocator>) {
+      return "hsa";
+    } else if constexpr (std::is_same_v<TAllocator, memory::MemoryPool>) {
+      return "pool";
+    } else {
+      VELOX_UNREACHABLE(
+          "Only HashStringAllocator and MemoryPool are supported allocator types.");
+    }
+  }
+};
+
+TYPED_TEST_SUITE(DenseHllTest, AllocatorTypes, NameGenerator);
+
+TYPED_TEST(DenseHllTest, basic) {
+  int8_t indexBitLength = 11;
+  DenseHll denseHll{indexBitLength, this->allocator_};
 
-  DenseHll denseHll{indexBitLength, &allocator_};
   for (int i = 0; i < 1'000; i++) {
     auto value = i % 17;
     auto hash = hashOne(value);
@@ -131,31 +151,29 @@ TEST_P(DenseHllTest, basic) {
 
   ASSERT_EQ(expectedCardinality, denseHll.cardinality());
 
-  DenseHll deserialized = roundTrip(denseHll);
+  DenseHll deserialized = this->roundTrip(denseHll);
   ASSERT_EQ(expectedCardinality, deserialized.cardinality());
 
-  auto serialized = serialize(denseHll);
-  ASSERT_EQ(expectedCardinality, DenseHll::cardinality(serialized.data()));
+  auto serialized = this->serialize(denseHll);
+  ASSERT_EQ(expectedCardinality, DenseHlls::cardinality(serialized.data()));
 }
 
-TEST_P(DenseHllTest, highCardinality) {
-  int8_t indexBitLength = GetParam();
+TYPED_TEST(DenseHllTest, highCardinality) {
+  int8_t indexBitLength = 11;
+  DenseHll denseHll{indexBitLength, this->allocator_};
 
-  DenseHll denseHll{indexBitLength, &allocator_};
   for (int i = 0; i < 10'000'000; i++) {
     auto hash = hashOne(i);
     denseHll.insertHash(hash);
   }
 
-  if (indexBitLength >= 11) {
-    ASSERT_NEAR(10'000'000, denseHll.cardinality(), 150'000);
-  }
+  ASSERT_NEAR(10'000'000, denseHll.cardinality(), 150'000);
 
-  DenseHll deserialized = roundTrip(denseHll);
+  auto deserialized = this->roundTrip(denseHll);
   ASSERT_EQ(denseHll.cardinality(), deserialized.cardinality());
 
-  auto serialized = serialize(denseHll);
-  ASSERT_EQ(denseHll.cardinality(), DenseHll::cardinality(serialized.data()));
+  auto serialized = this->serialize(denseHll);
+  ASSERT_EQ(denseHll.cardinality(), DenseHlls::cardinality(serialized.data()));
 }
 
 namespace {
@@ -170,62 +188,234 @@ std::vector<T> sequence(T start, T end) {
 }
 } // namespace
 
-TEST_P(DenseHllTest, canDeserialize) {
+TYPED_TEST(DenseHllTest, mergeWith) {
+  // small, non-overlapping
+  this->testMergeWith(sequence(0, 100), sequence(100, 200));
+  this->testMergeWith(sequence(100, 200), sequence(0, 100));
+
+  // small, overlapping
+  this->testMergeWith(sequence(0, 100), sequence(50, 150));
+  this->testMergeWith(sequence(50, 150), sequence(0, 100));
+
+  // small, same
+  this->testMergeWith(sequence(0, 100), sequence(0, 100));
+
+  // large, non-overlapping
+  this->testMergeWith(sequence(0, 20'000), sequence(20'000, 40'000));
+  this->testMergeWith(sequence(20'000, 40'000), sequence(0, 20'000));
+
+  // large, overlapping
+  this->testMergeWith(sequence(0, 2'000'000), sequence(1'000'000, 3'000'000));
+  this->testMergeWith(sequence(1'000'000, 3'000'000), sequence(0, 2'000'000));
+
+  // large, same
+  this->testMergeWith(sequence(0, 2'000'000), sequence(0, 2'000'000));
+}
+
+// Separate test class for testing various index bit lengths
+template <typename TAllocator, int8_t IndexBitLength>
+struct AllocatorWithIndexBits {
+  using AllocatorType = TAllocator;
+  static constexpr int8_t indexBitLength() {
+    return IndexBitLength;
+  }
+};
+
+template <typename TParam>
+class DenseHllMergeTest : public ::testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    if constexpr (std::is_same_v<
+                      typename TParam::AllocatorType,
+                      HashStringAllocator>) {
+      allocator_ = &hsa_;
+    } else {
+      allocator_ = pool_.get();
+    }
+  }
+
+  std::string serialize(DenseHll<typename TParam::AllocatorType>& denseHll) {
+    auto size = denseHll.serializedSize();
+    std::string serialized;
+    serialized.resize(size);
+    denseHll.serialize(serialized.data());
+    return serialized;
+  }
+
+  template <typename T>
+  void testMergeWith(
+      int8_t indexBitLength,
+      const std::vector<T>& left,
+      const std::vector<T>& right) {
+    testMergeWith(indexBitLength, left, right, false);
+    testMergeWith(indexBitLength, left, right, true);
+  }
+
+  template <typename T>
+  void testMergeWith(
+      int8_t indexBitLength,
+      const std::vector<T>& left,
+      const std::vector<T>& right,
+      bool serialized) {
+    DenseHll hllLeft{indexBitLength, allocator_};
+    DenseHll hllRight{indexBitLength, allocator_};
+    DenseHll expected{indexBitLength, allocator_};
+
+    for (auto value : left) {
+      auto hash = hashOne(value);
+      hllLeft.insertHash(hash);
+      expected.insertHash(hash);
+    }
+
+    for (auto value : right) {
+      auto hash = hashOne(value);
+      hllRight.insertHash(hash);
+      expected.insertHash(hash);
+    }
+
+    if (serialized) {
+      auto serializedRight = this->serialize(hllRight);
+      hllLeft.mergeWith(serializedRight.data());
+    } else {
+      hllLeft.mergeWith(hllRight);
+    }
+
+    ASSERT_EQ(hllLeft.cardinality(), expected.cardinality());
+    ASSERT_EQ(this->serialize(hllLeft), this->serialize(expected));
+
+    auto hllLeftSerialized = this->serialize(hllLeft);
+    ASSERT_EQ(
+        DenseHlls::cardinality(hllLeftSerialized.data()),
+        expected.cardinality());
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
+  HashStringAllocator hsa_{pool_.get()};
+  typename TParam::AllocatorType* allocator_;
+};
+
+using DenseHllMergeTestParams = ::testing::Types<
+    // HashStringAllocator with all index bit lengths
+    AllocatorWithIndexBits<HashStringAllocator, 4>,
+    AllocatorWithIndexBits<HashStringAllocator, 5>,
+    AllocatorWithIndexBits<HashStringAllocator, 6>,
+    AllocatorWithIndexBits<HashStringAllocator, 7>,
+    AllocatorWithIndexBits<HashStringAllocator, 8>,
+    AllocatorWithIndexBits<HashStringAllocator, 9>,
+    AllocatorWithIndexBits<HashStringAllocator, 10>,
+    AllocatorWithIndexBits<HashStringAllocator, 11>,
+    AllocatorWithIndexBits<HashStringAllocator, 12>,
+    AllocatorWithIndexBits<HashStringAllocator, 13>,
+    AllocatorWithIndexBits<HashStringAllocator, 14>,
+    AllocatorWithIndexBits<HashStringAllocator, 15>,
+    AllocatorWithIndexBits<HashStringAllocator, 16>,
+    // MemoryPool with all index bit lengths
+    AllocatorWithIndexBits<memory::MemoryPool, 4>,
+    AllocatorWithIndexBits<memory::MemoryPool, 5>,
+    AllocatorWithIndexBits<memory::MemoryPool, 6>,
+    AllocatorWithIndexBits<memory::MemoryPool, 7>,
+    AllocatorWithIndexBits<memory::MemoryPool, 8>,
+    AllocatorWithIndexBits<memory::MemoryPool, 9>,
+    AllocatorWithIndexBits<memory::MemoryPool, 10>,
+    AllocatorWithIndexBits<memory::MemoryPool, 11>,
+    AllocatorWithIndexBits<memory::MemoryPool, 12>,
+    AllocatorWithIndexBits<memory::MemoryPool, 13>,
+    AllocatorWithIndexBits<memory::MemoryPool, 14>,
+    AllocatorWithIndexBits<memory::MemoryPool, 15>,
+    AllocatorWithIndexBits<memory::MemoryPool, 16>>;
+
+class ComprehensiveNameGenerator {
+ public:
+  template <typename TParam>
+  static std::string GetName(int) {
+    std::string allocatorName;
+    if constexpr (std::is_same_v<
+                      typename TParam::AllocatorType,
+                      HashStringAllocator>) {
+      allocatorName = "hsa";
+    } else if constexpr (std::is_same_v<
+                             typename TParam::AllocatorType,
+                             memory::MemoryPool>) {
+      allocatorName = "pool";
+    } else {
+      VELOX_UNREACHABLE(
+          "Only HashStringAllocator and MemoryPool are supported allocator types.");
+    }
+    return fmt::format("{}_{}", allocatorName, TParam::indexBitLength());
+  }
+};
+
+TYPED_TEST_SUITE(
+    DenseHllMergeTest,
+    DenseHllMergeTestParams,
+    ComprehensiveNameGenerator);
+
+class DenseHllCanDeserializeTest : public ::testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+};
+
+TEST_F(DenseHllCanDeserializeTest, canDeserialize) {
   // These are not valid HLL but all pass canDeserialize version only check.
-  std::vector<folly::StringPiece> invalidStrings{
+  std::vector<std::string_view> invalidStrings{
       "AxIRESUhEzNBFCQWYxEjIzI1ISURNidCMlViIjOSNyATBhYSIiJDUyMBIlcSMDUiEUEiESM1ITckQkQTMSMhMyQx",
       "Aw==",
       "AyAAABEQAgAlAgAQAQAlMgAhQQABAwAAERAAAAEQACA=",
       "AwDuUjGFaQ==",
       "AwkLD8BYTA9BXyg="};
 
-  for (folly::StringPiece& invalidString : invalidStrings) {
+  for (const auto invalidString : invalidStrings) {
     auto invalidHll = Base64::decode(invalidString);
-    EXPECT_TRUE(DenseHll::canDeserialize(invalidHll.c_str()));
+    EXPECT_TRUE(DenseHlls::canDeserialize(invalidHll.c_str()));
     EXPECT_FALSE(
-        DenseHll::canDeserialize(invalidHll.c_str(), invalidHll.length()));
+        DenseHlls::canDeserialize(invalidHll.c_str(), invalidHll.length()));
   }
 
-  std::vector<folly::StringPiece> validStrings{
+  std::vector<std::string_view> validStrings{
       "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",
   };
 
-  for (folly::StringPiece& validString : validStrings) {
+  for (const auto validString : validStrings) {
     auto validHll = Base64::decode(validString);
-    EXPECT_TRUE(DenseHll::canDeserialize(validHll.c_str()));
-    EXPECT_TRUE(DenseHll::canDeserialize(validHll.c_str(), validHll.length()));
+    EXPECT_TRUE(DenseHlls::canDeserialize(validHll.c_str()));
+    EXPECT_TRUE(DenseHlls::canDeserialize(validHll.c_str(), validHll.length()));
   }
 }
 
-TEST_P(DenseHllTest, mergeWith) {
-  int8_t indexBitLength = GetParam();
+TYPED_TEST(DenseHllMergeTest, mergeWith) {
+  int8_t indexBitLength = TypeParam::indexBitLength();
 
   // small, non-overlapping
-  testMergeWith(indexBitLength, sequence(0, 100), sequence(100, 200));
-  testMergeWith(indexBitLength, sequence(100, 200), sequence(0, 100));
+  this->testMergeWith(indexBitLength, sequence(0, 100), sequence(100, 200));
+  this->testMergeWith(indexBitLength, sequence(100, 200), sequence(0, 100));
 
   // small, overlapping
-  testMergeWith(indexBitLength, sequence(0, 100), sequence(50, 150));
-  testMergeWith(indexBitLength, sequence(50, 150), sequence(0, 100));
+  this->testMergeWith(indexBitLength, sequence(0, 100), sequence(50, 150));
+  this->testMergeWith(indexBitLength, sequence(50, 150), sequence(0, 100));
 
   // small, same
-  testMergeWith(indexBitLength, sequence(0, 100), sequence(0, 100));
+  this->testMergeWith(indexBitLength, sequence(0, 100), sequence(0, 100));
 
   // large, non-overlapping
-  testMergeWith(indexBitLength, sequence(0, 20'000), sequence(20'000, 40'000));
-  testMergeWith(indexBitLength, sequence(20'000, 40'000), sequence(0, 20'000));
+  this->testMergeWith(
+      indexBitLength, sequence(0, 20'000), sequence(20'000, 40'000));
+  this->testMergeWith(
+      indexBitLength, sequence(20'000, 40'000), sequence(0, 20'000));
 
   // large, overlapping
-  testMergeWith(
+  this->testMergeWith(
       indexBitLength, sequence(0, 2'000'000), sequence(1'000'000, 3'000'000));
-  testMergeWith(
+  this->testMergeWith(
       indexBitLength, sequence(1'000'000, 3'000'000), sequence(0, 2'000'000));
 
   // large, same
-  testMergeWith(indexBitLength, sequence(0, 2'000'000), sequence(0, 2'000'000));
+  this->testMergeWith(
+      indexBitLength, sequence(0, 2'000'000), sequence(0, 2'000'000));
 }
-
-INSTANTIATE_TEST_SUITE_P(
-    DenseHllTest,
-    DenseHllTest,
-    ::testing::Values(4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16));
diff --git a/velox/common/hyperloglog/tests/SparseHllTest.cpp b/velox/common/hyperloglog/tests/SparseHllTest.cpp
index 299e2c8aebd..b0f1e697872 100644
--- a/velox/common/hyperloglog/tests/SparseHllTest.cpp
+++ b/velox/common/hyperloglog/tests/SparseHllTest.cpp
@@ -15,9 +15,9 @@
  */
 #include "velox/common/hyperloglog/SparseHll.h"
 
-#define XXH_INLINE_ALL
-#include <xxhash.h>
+#include "velox/common/base/XxHashInline.h"
 
+#include <gtest/gtest-typed-test.h>
 #include <gtest/gtest.h>
 
 using namespace facebook::velox;
@@ -28,12 +28,21 @@ uint64_t hashOne(T value) {
   return XXH64(&value, sizeof(value), 0);
 }
 
+template <typename TAllocator>
 class SparseHllTest : public ::testing::Test {
  protected:
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   }
 
+  void SetUp() override {
+    if constexpr (std::is_same_v<TAllocator, HashStringAllocator>) {
+      allocator_ = &hsa_;
+    } else {
+      allocator_ = pool_.get();
+    }
+  }
+
   template <typename T>
   void testMergeWith(const std::vector<T>& left, const std::vector<T>& right) {
     testMergeWith(left, right, false);
@@ -45,9 +54,9 @@ class SparseHllTest : public ::testing::Test {
       const std::vector<T>& left,
       const std::vector<T>& right,
       bool serialized) {
-    SparseHll hllLeft{&allocator_};
-    SparseHll hllRight{&allocator_};
-    SparseHll expected{&allocator_};
+    SparseHll hllLeft{allocator_};
+    SparseHll hllRight{allocator_};
+    SparseHll expected{allocator_};
 
     for (auto value : left) {
       auto hash = hashOne(value);
@@ -77,16 +86,20 @@ class SparseHllTest : public ::testing::Test {
 
     auto hllLeftSerialized = serialize(11, hllLeft);
     ASSERT_EQ(
-        SparseHll::cardinality(hllLeftSerialized.data()),
+        SparseHlls::cardinality(hllLeftSerialized.data()),
         expected.cardinality());
   }
 
-  SparseHll roundTrip(SparseHll& hll) {
-    auto serialized = serialize(11, hll);
-    return SparseHll(serialized.data(), &allocator_);
+  SparseHll<TAllocator> roundTrip(
+      SparseHll<TAllocator>& hll,
+      int8_t indexBitLength = 11) {
+    auto serialized = serialize(indexBitLength, hll);
+    return SparseHll(serialized.data(), allocator_);
   }
 
-  std::string serialize(int8_t indexBitLength, const SparseHll& sparseHll) {
+  std::string serialize(
+      int8_t indexBitLength,
+      const SparseHll<TAllocator>& sparseHll) {
     auto size = sparseHll.serializedSize();
     std::string serialized;
     serialized.resize(size);
@@ -94,7 +107,7 @@ class SparseHllTest : public ::testing::Test {
     return serialized;
   }
 
-  std::string serialize(DenseHll& denseHll) {
+  std::string serialize(DenseHll<TAllocator>& denseHll) {
     auto size = denseHll.serializedSize();
     std::string serialized;
     serialized.resize(size);
@@ -104,11 +117,46 @@ class SparseHllTest : public ::testing::Test {
 
   std::shared_ptr<memory::MemoryPool> pool_{
       memory::memoryManager()->addLeafPool()};
-  HashStringAllocator allocator_{pool_.get()};
+  HashStringAllocator hsa_{pool_.get()};
+  TAllocator* allocator_;
 };
 
-TEST_F(SparseHllTest, basic) {
-  SparseHll sparseHll{&allocator_};
+using AllocatorTypes =
+    ::testing::Types<HashStringAllocator, memory::MemoryPool>;
+
+class NameGenerator {
+ public:
+  template <typename TAllocator>
+  static std::string GetName(int) {
+    if constexpr (std::is_same_v<TAllocator, HashStringAllocator>) {
+      return "hsa";
+    } else if constexpr (std::is_same_v<TAllocator, memory::MemoryPool>) {
+      return "pool";
+    } else {
+      VELOX_UNREACHABLE(
+          "Only HashStringAllocator and MemoryPool are supported allocator types.");
+    }
+  }
+};
+
+TYPED_TEST_SUITE(SparseHllTest, AllocatorTypes, NameGenerator);
+
+TYPED_TEST(SparseHllTest, corruptEntryCount) {
+  // SparseHll format: int8_t version (2) + int8_t indexBitLength + int16_t
+  // size.  A negative size causes std::terminate in vector::resize due to
+  // fbcode's noexcept _M_check_len.
+  std::string serialized(4, '\0');
+  serialized[0] = 2; // kPrestoSparseV2
+  serialized[1] = 11; // indexBitLength
+  // Write size = -1 as little-endian int16_t.
+  serialized[2] = static_cast<char>(0xFF);
+  serialized[3] = static_cast<char>(0xFF);
+
+  EXPECT_ANY_THROW(SparseHll(serialized.data(), this->allocator_));
+}
+
+TYPED_TEST(SparseHllTest, basic) {
+  SparseHll sparseHll{this->allocator_};
   for (int i = 0; i < 1'000; i++) {
     auto value = i % 17;
     auto hash = hashOne(value);
@@ -118,16 +166,16 @@ TEST_F(SparseHllTest, basic) {
   sparseHll.verify();
   ASSERT_EQ(17, sparseHll.cardinality());
 
-  auto deserialized = roundTrip(sparseHll);
+  auto deserialized = this->roundTrip(sparseHll);
   deserialized.verify();
   ASSERT_EQ(17, deserialized.cardinality());
 
-  auto serialized = serialize(11, sparseHll);
-  ASSERT_EQ(17, SparseHll::cardinality(serialized.data()));
+  auto serialized = this->serialize(11, sparseHll);
+  ASSERT_EQ(17, SparseHlls::cardinality(serialized.data()));
 }
 
-TEST_F(SparseHllTest, highCardinality) {
-  SparseHll sparseHll{&allocator_};
+TYPED_TEST(SparseHllTest, highCardinality) {
+  SparseHll sparseHll{this->allocator_};
   for (int i = 0; i < 1'000; i++) {
     auto hash = hashOne(i);
     sparseHll.insertHash(hash);
@@ -136,12 +184,12 @@ TEST_F(SparseHllTest, highCardinality) {
   sparseHll.verify();
   ASSERT_EQ(1'000, sparseHll.cardinality());
 
-  auto deserialized = roundTrip(sparseHll);
+  auto deserialized = this->roundTrip(sparseHll);
   deserialized.verify();
   ASSERT_EQ(1'000, deserialized.cardinality());
 
-  auto serialized = serialize(11, sparseHll);
-  ASSERT_EQ(1'000, SparseHll::cardinality(serialized.data()));
+  auto serialized = this->serialize(11, sparseHll);
+  ASSERT_EQ(1'000, SparseHlls::cardinality(serialized.data()));
 }
 
 namespace {
@@ -156,30 +204,80 @@ std::vector<T> sequence(T start, T end) {
 }
 } // namespace
 
-TEST_F(SparseHllTest, mergeWith) {
+TYPED_TEST(SparseHllTest, mergeWith) {
   // with overlap
-  testMergeWith(sequence(0, 100), sequence(50, 150));
-  testMergeWith(sequence(50, 150), sequence(0, 100));
+  this->testMergeWith(sequence(0, 100), sequence(50, 150));
+  this->testMergeWith(sequence(50, 150), sequence(0, 100));
 
   // no overlap
-  testMergeWith(sequence(0, 100), sequence(200, 300));
-  testMergeWith(sequence(200, 300), sequence(0, 100));
+  this->testMergeWith(sequence(0, 100), sequence(200, 300));
+  this->testMergeWith(sequence(200, 300), sequence(0, 100));
 
   // idempotent
-  testMergeWith(sequence(0, 100), sequence(0, 100));
+  this->testMergeWith(sequence(0, 100), sequence(0, 100));
 
   // empty sequence
-  testMergeWith(sequence(0, 100), {});
-  testMergeWith({}, sequence(100, 300));
+  this->testMergeWith(sequence(0, 100), {});
+  this->testMergeWith({}, sequence(100, 300));
 }
 
-class SparseHllToDenseTest : public ::testing::TestWithParam<int8_t> {
+TYPED_TEST(SparseHllTest, toDense) {
+  int8_t indexBitLength = 11;
+
+  SparseHll sparseHll{this->allocator_};
+  DenseHll expectedHll{indexBitLength, this->allocator_};
+  for (int i = 0; i < 1'000; i++) {
+    auto hash = hashOne(i);
+    sparseHll.insertHash(hash);
+    expectedHll.insertHash(hash);
+  }
+
+  DenseHll denseHll{indexBitLength, this->allocator_};
+  sparseHll.toDense(denseHll);
+  ASSERT_EQ(denseHll.cardinality(), expectedHll.cardinality());
+  ASSERT_EQ(this->serialize(denseHll), this->serialize(expectedHll));
+}
+
+TYPED_TEST(SparseHllTest, testNumberOfZeros) {
+  int8_t indexBitLength = 11;
+  for (int i = 0; i < 64 - indexBitLength; ++i) {
+    auto hash = 1ull << i;
+    SparseHll sparseHll(this->allocator_);
+    sparseHll.insertHash(hash);
+    DenseHll expectedHll(indexBitLength, this->allocator_);
+    expectedHll.insertHash(hash);
+    DenseHll denseHll(indexBitLength, this->allocator_);
+    sparseHll.toDense(denseHll);
+    ASSERT_EQ(this->serialize(denseHll), this->serialize(expectedHll));
+  }
+}
+
+template <typename TAllocator, int8_t IndexBitLength>
+struct AllocatorWithIndexBits {
+  using AllocatorType = TAllocator;
+  static constexpr int8_t indexBitLength() {
+    return IndexBitLength;
+  }
+};
+
+template <typename TParam>
+class SparseHllToDenseTest : public ::testing::Test {
  protected:
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   }
 
-  std::string serialize(DenseHll& denseHll) {
+  void SetUp() override {
+    if constexpr (std::is_same_v<
+                      typename TParam::AllocatorType,
+                      HashStringAllocator>) {
+      allocator_ = &hsa_;
+    } else {
+      allocator_ = pool_.get();
+    }
+  }
+
+  std::string serialize(DenseHll<typename TParam::AllocatorType>& denseHll) {
     auto size = denseHll.serializedSize();
     std::string serialized;
     serialized.resize(size);
@@ -189,41 +287,93 @@ class SparseHllToDenseTest : public ::testing::TestWithParam<int8_t> {
 
   std::shared_ptr<memory::MemoryPool> pool_{
       memory::memoryManager()->addLeafPool()};
-  HashStringAllocator allocator_{pool_.get()};
+  HashStringAllocator hsa_{pool_.get()};
+  typename TParam::AllocatorType* allocator_;
+};
+
+using SparseHllToDenseTestParams = ::testing::Types<
+    // HashStringAllocator with various index bit lengths
+    AllocatorWithIndexBits<HashStringAllocator, 4>,
+    AllocatorWithIndexBits<HashStringAllocator, 5>,
+    AllocatorWithIndexBits<HashStringAllocator, 6>,
+    AllocatorWithIndexBits<HashStringAllocator, 7>,
+    AllocatorWithIndexBits<HashStringAllocator, 8>,
+    AllocatorWithIndexBits<HashStringAllocator, 9>,
+    AllocatorWithIndexBits<HashStringAllocator, 10>,
+    AllocatorWithIndexBits<HashStringAllocator, 11>,
+    AllocatorWithIndexBits<HashStringAllocator, 12>,
+    AllocatorWithIndexBits<HashStringAllocator, 13>,
+    AllocatorWithIndexBits<HashStringAllocator, 14>,
+    AllocatorWithIndexBits<HashStringAllocator, 15>,
+    AllocatorWithIndexBits<HashStringAllocator, 16>,
+    // MemoryPool with various index bit lengths
+    AllocatorWithIndexBits<memory::MemoryPool, 4>,
+    AllocatorWithIndexBits<memory::MemoryPool, 5>,
+    AllocatorWithIndexBits<memory::MemoryPool, 6>,
+    AllocatorWithIndexBits<memory::MemoryPool, 7>,
+    AllocatorWithIndexBits<memory::MemoryPool, 8>,
+    AllocatorWithIndexBits<memory::MemoryPool, 9>,
+    AllocatorWithIndexBits<memory::MemoryPool, 10>,
+    AllocatorWithIndexBits<memory::MemoryPool, 11>,
+    AllocatorWithIndexBits<memory::MemoryPool, 12>,
+    AllocatorWithIndexBits<memory::MemoryPool, 13>,
+    AllocatorWithIndexBits<memory::MemoryPool, 14>,
+    AllocatorWithIndexBits<memory::MemoryPool, 15>,
+    AllocatorWithIndexBits<memory::MemoryPool, 16>>;
+
+class ToDenseNameGenerator {
+ public:
+  template <typename TParam>
+  static std::string GetName(int) {
+    std::string allocatorName;
+    if constexpr (std::is_same_v<
+                      typename TParam::AllocatorType,
+                      HashStringAllocator>) {
+      allocatorName = "hsa";
+    } else if constexpr (std::is_same_v<
+                             typename TParam::AllocatorType,
+                             memory::MemoryPool>) {
+      allocatorName = "pool";
+    } else {
+      VELOX_UNREACHABLE(
+          "Only HashStringAllocator and MemoryPool are supported allocator types.");
+    }
+    return fmt::format("{}_{}", allocatorName, TParam::indexBitLength());
+  }
 };
 
-TEST_P(SparseHllToDenseTest, toDense) {
-  int8_t indexBitLength = GetParam();
+TYPED_TEST_SUITE(
+    SparseHllToDenseTest,
+    SparseHllToDenseTestParams,
+    ToDenseNameGenerator);
+
+TYPED_TEST(SparseHllToDenseTest, toDense) {
+  int8_t indexBitLength = TypeParam::indexBitLength();
 
-  SparseHll sparseHll{&allocator_};
-  DenseHll expectedHll{indexBitLength, &allocator_};
+  SparseHll sparseHll{this->allocator_};
+  DenseHll expectedHll{indexBitLength, this->allocator_};
   for (int i = 0; i < 1'000; i++) {
     auto hash = hashOne(i);
     sparseHll.insertHash(hash);
     expectedHll.insertHash(hash);
   }
 
-  DenseHll denseHll{indexBitLength, &allocator_};
+  DenseHll denseHll{indexBitLength, this->allocator_};
   sparseHll.toDense(denseHll);
   ASSERT_EQ(denseHll.cardinality(), expectedHll.cardinality());
-  ASSERT_EQ(serialize(denseHll), serialize(expectedHll));
+  ASSERT_EQ(this->serialize(denseHll), this->serialize(expectedHll));
 }
 
-TEST_P(SparseHllToDenseTest, testNumberOfZeros) {
-  auto indexBitLength = GetParam();
+TYPED_TEST(SparseHllToDenseTest, testNumberOfZeros) {
+  auto indexBitLength = TypeParam::indexBitLength();
   for (int i = 0; i < 64 - indexBitLength; ++i) {
     auto hash = 1ull << i;
-    SparseHll sparseHll(&allocator_);
+    SparseHll sparseHll(this->allocator_);
     sparseHll.insertHash(hash);
-    DenseHll expectedHll(indexBitLength, &allocator_);
+    DenseHll expectedHll(indexBitLength, this->allocator_);
     expectedHll.insertHash(hash);
-    DenseHll denseHll(indexBitLength, &allocator_);
+    DenseHll denseHll(indexBitLength, this->allocator_);
     sparseHll.toDense(denseHll);
-    ASSERT_EQ(serialize(denseHll), serialize(expectedHll));
+    ASSERT_EQ(this->serialize(denseHll), this->serialize(expectedHll));
   }
 }
-
-INSTANTIATE_TEST_SUITE_P(
-    SparseHllToDenseTest,
-    SparseHllToDenseTest,
-    ::testing::Values(4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16));
diff --git a/velox/common/io/CMakeLists.txt b/velox/common/io/CMakeLists.txt
index 3498214b4fd..4031afb8780 100644
--- a/velox/common/io/CMakeLists.txt
+++ b/velox/common/io/CMakeLists.txt
@@ -12,6 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_common_io IoStatistics.cpp)
+velox_add_library(velox_common_io IoStatistics.cpp HEADERS IoStatistics.h Options.h)
 
 velox_link_libraries(velox_common_io Folly::folly glog::glog)
diff --git a/velox/common/io/IoStatistics.cpp b/velox/common/io/IoStatistics.cpp
index 74d8383c308..21423486324 100644
--- a/velox/common/io/IoStatistics.cpp
+++ b/velox/common/io/IoStatistics.cpp
@@ -42,8 +42,8 @@ uint64_t IoStatistics::outputBatchSize() const {
   return outputBatchSize_.load(std::memory_order_relaxed);
 }
 
-uint64_t IoStatistics::totalScanTime() const {
-  return totalScanTime_.load(std::memory_order_relaxed);
+uint64_t IoStatistics::totalScanTimeNs() const {
+  return totalScanTimeNs_.load(std::memory_order_relaxed);
 }
 
 uint64_t IoStatistics::writeIOTimeUs() const {
@@ -70,8 +70,8 @@ uint64_t IoStatistics::incRawOverreadBytes(int64_t v) {
   return rawOverreadBytes_.fetch_add(v, std::memory_order_relaxed);
 }
 
-uint64_t IoStatistics::incTotalScanTime(int64_t v) {
-  return totalScanTime_.fetch_add(v, std::memory_order_relaxed);
+uint64_t IoStatistics::incTotalScanTimeNs(int64_t v) {
+  return totalScanTimeNs_.fetch_add(v, std::memory_order_relaxed);
 }
 
 uint64_t IoStatistics::incWriteIOTimeUs(int64_t v) {
@@ -111,14 +111,19 @@ IoStatistics::operationStats() const {
 void IoStatistics::merge(const IoStatistics& other) {
   rawBytesRead_ += other.rawBytesRead_;
   rawBytesWritten_ += other.rawBytesWritten_;
-  totalScanTime_ += other.totalScanTime_;
+  totalScanTimeNs_ += other.totalScanTimeNs_;
 
   rawOverreadBytes_ += other.rawOverreadBytes_;
   prefetch_.merge(other.prefetch_);
   read_.merge(other.read_);
   ramHit_.merge(other.ramHit_);
   ssdRead_.merge(other.ssdRead_);
-  queryThreadIoLatency_.merge(other.queryThreadIoLatency_);
+  queryThreadIoLatencyUs_.merge(other.queryThreadIoLatencyUs_);
+  storageReadLatencyUs_.merge(other.storageReadLatencyUs_);
+  ssdCacheReadLatencyUs_.merge(other.ssdCacheReadLatencyUs_);
+  cacheWaitLatencyUs_.merge(other.cacheWaitLatencyUs_);
+  coalescedSsdLoadLatencyUs_.merge(other.coalescedSsdLoadLatencyUs_);
+  coalescedStorageLoadLatencyUs_.merge(other.coalescedStorageLoadLatencyUs_);
   {
     const auto& otherOperationStats = other.operationStats();
     std::lock_guard<std::mutex> l(operationStatsMutex_);
diff --git a/velox/common/io/IoStatistics.h b/velox/common/io/IoStatistics.h
index 2111a8877b4..97d39e358e7 100644
--- a/velox/common/io/IoStatistics.h
+++ b/velox/common/io/IoStatistics.h
@@ -43,6 +43,24 @@ struct OperationCounters {
 
 class IoCounter {
  public:
+  IoCounter& operator=(const IoCounter& other) noexcept {
+    if (this != &other) {
+      count_.store(
+          other.count_.load(std::memory_order_relaxed),
+          std::memory_order_relaxed);
+      sum_.store(
+          other.sum_.load(std::memory_order_relaxed),
+          std::memory_order_relaxed);
+      min_.store(
+          other.min_.load(std::memory_order_relaxed),
+          std::memory_order_relaxed);
+      max_.store(
+          other.max_.load(std::memory_order_relaxed),
+          std::memory_order_relaxed);
+    }
+    return *this;
+  }
+
   uint64_t count() const {
     return count_;
   }
@@ -96,7 +114,7 @@ class IoStatistics {
   uint64_t rawBytesWritten() const;
   uint64_t inputBatchSize() const;
   uint64_t outputBatchSize() const;
-  uint64_t totalScanTime() const;
+  uint64_t totalScanTimeNs() const;
   uint64_t writeIOTimeUs() const;
 
   uint64_t incRawBytesRead(int64_t);
@@ -104,7 +122,7 @@ class IoStatistics {
   uint64_t incRawBytesWritten(int64_t);
   uint64_t incInputBatchSize(int64_t);
   uint64_t incOutputBatchSize(int64_t);
-  uint64_t incTotalScanTime(int64_t);
+  uint64_t incTotalScanTimeNs(int64_t);
   uint64_t incWriteIOTimeUs(int64_t);
 
   IoCounter& prefetch() {
@@ -123,8 +141,28 @@ class IoStatistics {
     return ramHit_;
   }
 
-  IoCounter& queryThreadIoLatency() {
-    return queryThreadIoLatency_;
+  IoCounter& queryThreadIoLatencyUs() {
+    return queryThreadIoLatencyUs_;
+  }
+
+  IoCounter& storageReadLatencyUs() {
+    return storageReadLatencyUs_;
+  }
+
+  IoCounter& ssdCacheReadLatencyUs() {
+    return ssdCacheReadLatencyUs_;
+  }
+
+  IoCounter& cacheWaitLatencyUs() {
+    return cacheWaitLatencyUs_;
+  }
+
+  IoCounter& coalescedSsdLoadLatencyUs() {
+    return coalescedSsdLoadLatencyUs_;
+  }
+
+  IoCounter& coalescedStorageLoadLatencyUs() {
+    return coalescedStorageLoadLatencyUs_;
   }
 
   void incOperationCounters(
@@ -151,7 +189,7 @@ class IoStatistics {
   std::atomic<uint64_t> inputBatchSize_{0};
   std::atomic<uint64_t> outputBatchSize_{0};
   std::atomic<uint64_t> rawOverreadBytes_{0};
-  std::atomic<uint64_t> totalScanTime_{0};
+  std::atomic<uint64_t> totalScanTimeNs_{0};
   std::atomic<uint64_t> writeIOTimeUs_{0};
 
   // Planned read from storage or SSD.
@@ -169,7 +207,24 @@ class IoStatistics {
 
   // Time spent by a query processing thread waiting for synchronously issued IO
   // or for an in-progress read-ahead to finish.
-  IoCounter queryThreadIoLatency_;
+  IoCounter queryThreadIoLatencyUs_;
+
+  // Breakdown of queryThreadIoLatencyUs_ by I/O type:
+
+  // Time spent waiting for remote storage reads (S3, HDFS, etc.)
+  IoCounter storageReadLatencyUs_;
+
+  // Time spent waiting for SSD cache reads
+  IoCounter ssdCacheReadLatencyUs_;
+
+  // Time spent waiting for EXCLUSIVE cache entries (another thread is loading)
+  IoCounter cacheWaitLatencyUs_;
+
+  // Time spent waiting for coalesced loads from SSD cache
+  IoCounter coalescedSsdLoadLatencyUs_;
+
+  // Time spent waiting for coalesced loads from remote storage
+  IoCounter coalescedStorageLoadLatencyUs_;
 
   std::unordered_map<std::string, OperationCounters> operationStats_;
   mutable std::mutex operationStatsMutex_;
diff --git a/velox/common/io/Options.h b/velox/common/io/Options.h
index 32cb2387868..568c581cdfc 100644
--- a/velox/common/io/Options.h
+++ b/velox/common/io/Options.h
@@ -16,6 +16,10 @@
 
 #pragma once
 
+#include <folly/Executor.h>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/io/IoStatistics.h"
 #include "velox/common/memory/Memory.h"
 
 namespace facebook::velox::io {
@@ -63,14 +67,25 @@ class ReaderOptions {
   static constexpr int32_t kDefaultCoalesceBytes = 128 << 20; // 128M
   static constexpr int32_t kDefaultPrefetchRowGroups = 1;
 
-  explicit ReaderOptions(velox::memory::MemoryPool* pool)
-      : memoryPool_(pool),
-        autoPreloadLength_(DEFAULT_AUTO_PRELOAD_SIZE),
-        prefetchMode_(PrefetchMode::PREFETCH) {}
+  explicit ReaderOptions(velox::memory::MemoryPool* pool) : pool_{pool} {
+    VELOX_CHECK_NOT_NULL(pool_);
+  }
+
+  ReaderOptions& setDataIoStats(std::shared_ptr<IoStatistics> stats) {
+    VELOX_CHECK_NULL(dataIoStats_, "dataIoStats already set");
+    dataIoStats_ = std::move(stats);
+    return *this;
+  }
+
+  ReaderOptions& setMetadataIoStats(std::shared_ptr<IoStatistics> stats) {
+    VELOX_CHECK_NULL(metadataIoStats_, "metadataIoStats already set");
+    metadataIoStats_ = std::move(stats);
+    return *this;
+  }
 
-  /// Sets the memory pool for allocation.
-  ReaderOptions& setMemoryPool(velox::memory::MemoryPool& pool) {
-    memoryPool_ = &pool;
+  ReaderOptions& setIndexIoStats(std::shared_ptr<IoStatistics> stats) {
+    VELOX_CHECK_NULL(indexIoStats_, "indexIoStats already set");
+    indexIoStats_ = std::move(stats);
     return *this;
   }
 
@@ -112,7 +127,7 @@ class ReaderOptions {
 
   /// Gets the memory allocator.
   velox::memory::MemoryPool& memoryPool() const {
-    return *memoryPool_;
+    return *pool_;
   }
 
   uint64_t autoPreloadLength() const {
@@ -139,22 +154,52 @@ class ReaderOptions {
     return prefetchRowGroups_;
   }
 
-  bool noCacheRetention() const {
-    return noCacheRetention_;
+  bool cacheable() const {
+    return cacheable_;
+  }
+
+  void setCacheable(bool cacheable) {
+    cacheable_ = cacheable;
   }
 
-  void setNoCacheRetention(bool noCacheRetention) {
-    noCacheRetention_ = noCacheRetention;
+  const std::shared_ptr<folly::Executor>& ioExecutor() const {
+    return ioExecutor_;
+  }
+
+  void setIOExecutor(std::shared_ptr<folly::Executor> ioExecutor) {
+    ioExecutor_ = std::move(ioExecutor);
+  }
+
+  /// IO statistics for tracking storage reads, SSD reads, RAM cache hits,
+  /// and overread bytes for data stream IO.
+  const std::shared_ptr<IoStatistics>& dataIoStats() const {
+    return dataIoStats_;
+  }
+
+  /// IO statistics for tracking storage reads, SSD reads, RAM cache hits,
+  /// and overread bytes for metadata IO (footer, stripe groups, index).
+  const std::shared_ptr<IoStatistics>& metadataIoStats() const {
+    return metadataIoStats_;
+  }
+
+  const std::shared_ptr<IoStatistics>& indexIoStats() const {
+    return indexIoStats_;
   }
 
  protected:
-  velox::memory::MemoryPool* memoryPool_;
-  uint64_t autoPreloadLength_;
-  PrefetchMode prefetchMode_;
+  velox::memory::MemoryPool* pool_;
+  std::shared_ptr<IoStatistics> dataIoStats_;
+  std::shared_ptr<IoStatistics> metadataIoStats_;
+  std::shared_ptr<IoStatistics> indexIoStats_;
+
+  std::shared_ptr<folly::Executor> ioExecutor_;
+
+  uint64_t autoPreloadLength_{DEFAULT_AUTO_PRELOAD_SIZE};
+  PrefetchMode prefetchMode_{PrefetchMode::PREFETCH};
   int32_t loadQuantum_{kDefaultLoadQuantum};
   int32_t maxCoalesceDistance_{kDefaultCoalesceDistance};
   int64_t maxCoalesceBytes_{kDefaultCoalesceBytes};
   int32_t prefetchRowGroups_{kDefaultPrefetchRowGroups};
-  bool noCacheRetention_{false};
+  bool cacheable_{true};
 };
 } // namespace facebook::velox::io
diff --git a/velox/common/io/tests/IoStatisticsTest.cpp b/velox/common/io/tests/IoStatisticsTest.cpp
new file mode 100644
index 00000000000..72a9d051e58
--- /dev/null
+++ b/velox/common/io/tests/IoStatisticsTest.cpp
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/io/IoStatistics.h"
+#include <gtest/gtest.h>
+
+namespace facebook::velox::io {
+
+TEST(IoStatisticsTest, latencyBreakdown) {
+  IoStatistics stats;
+
+  stats.storageReadLatencyUs().increment(100);
+  stats.ssdCacheReadLatencyUs().increment(50);
+  stats.cacheWaitLatencyUs().increment(25);
+  stats.coalescedSsdLoadLatencyUs().increment(30);
+  stats.coalescedStorageLoadLatencyUs().increment(45);
+
+  EXPECT_EQ(stats.storageReadLatencyUs().count(), 1);
+  EXPECT_EQ(stats.storageReadLatencyUs().sum(), 100);
+  EXPECT_EQ(stats.ssdCacheReadLatencyUs().sum(), 50);
+  EXPECT_EQ(stats.cacheWaitLatencyUs().sum(), 25);
+  EXPECT_EQ(stats.coalescedSsdLoadLatencyUs().sum(), 30);
+  EXPECT_EQ(stats.coalescedStorageLoadLatencyUs().sum(), 45);
+
+  IoStatistics stats2;
+  stats2.storageReadLatencyUs().increment(200);
+  stats.merge(stats2);
+
+  EXPECT_EQ(stats.storageReadLatencyUs().count(), 2);
+  EXPECT_EQ(stats.storageReadLatencyUs().sum(), 300);
+}
+
+TEST(IoStatisticsTest, totalScanTimeNs) {
+  IoStatistics stats;
+  EXPECT_EQ(stats.totalScanTimeNs(), 0);
+
+  stats.incTotalScanTimeNs(1'000);
+  EXPECT_EQ(stats.totalScanTimeNs(), 1'000);
+
+  stats.incTotalScanTimeNs(2'500);
+  EXPECT_EQ(stats.totalScanTimeNs(), 3'500);
+
+  IoStatistics stats2;
+  stats2.incTotalScanTimeNs(500);
+  stats.merge(stats2);
+  EXPECT_EQ(stats.totalScanTimeNs(), 4'000);
+}
+
+} // namespace facebook::velox::io
diff --git a/velox/common/io/tests/ReaderOptionsTest.cpp b/velox/common/io/tests/ReaderOptionsTest.cpp
new file mode 100644
index 00000000000..80ff4831c87
--- /dev/null
+++ b/velox/common/io/tests/ReaderOptionsTest.cpp
@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/io/Options.h"
+
+#include <folly/executors/CPUThreadPoolExecutor.h>
+#include <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+
+namespace facebook::velox::io {
+
+class ReaderOptionsTest : public ::testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  const std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool("ReaderOptionsTest")};
+  std::shared_ptr<IoStatistics> dataIoStats_{std::make_shared<IoStatistics>()};
+  std::shared_ptr<IoStatistics> metadataIoStats_{
+      std::make_shared<IoStatistics>()};
+  std::shared_ptr<IoStatistics> indexIoStats_{std::make_shared<IoStatistics>()};
+};
+
+TEST_F(ReaderOptionsTest, constructor) {
+  ReaderOptions options(pool_.get());
+
+  EXPECT_EQ(&options.memoryPool(), pool_.get());
+  EXPECT_EQ(options.dataIoStats(), nullptr);
+  EXPECT_EQ(options.metadataIoStats(), nullptr);
+  EXPECT_EQ(options.indexIoStats(), nullptr);
+  EXPECT_EQ(options.ioExecutor(), nullptr);
+  EXPECT_EQ(options.autoPreloadLength(), DEFAULT_AUTO_PRELOAD_SIZE);
+  EXPECT_EQ(options.prefetchMode(), PrefetchMode::PREFETCH);
+  EXPECT_EQ(options.loadQuantum(), ReaderOptions::kDefaultLoadQuantum);
+  EXPECT_EQ(
+      options.maxCoalesceDistance(), ReaderOptions::kDefaultCoalesceDistance);
+  EXPECT_EQ(options.maxCoalesceBytes(), ReaderOptions::kDefaultCoalesceBytes);
+  EXPECT_EQ(
+      options.prefetchRowGroups(), ReaderOptions::kDefaultPrefetchRowGroups);
+  EXPECT_TRUE(options.cacheable());
+}
+
+TEST_F(ReaderOptionsTest, setters) {
+  ReaderOptions options(pool_.get());
+
+  options.setAutoPreloadLength(1'024);
+  EXPECT_EQ(options.autoPreloadLength(), 1'024);
+
+  options.setPrefetchMode(PrefetchMode::NOT_SET);
+  EXPECT_EQ(options.prefetchMode(), PrefetchMode::NOT_SET);
+
+  options.setLoadQuantum(4 << 20);
+  EXPECT_EQ(options.loadQuantum(), 4 << 20);
+
+  options.setMaxCoalesceDistance(1 << 20);
+  EXPECT_EQ(options.maxCoalesceDistance(), 1 << 20);
+
+  options.setMaxCoalesceBytes(64 << 20);
+  EXPECT_EQ(options.maxCoalesceBytes(), 64 << 20);
+
+  options.setPrefetchRowGroups(4);
+  EXPECT_EQ(options.prefetchRowGroups(), 4);
+
+  options.setCacheable(false);
+  EXPECT_FALSE(options.cacheable());
+}
+
+TEST_F(ReaderOptionsTest, ioExecutor) {
+  ReaderOptions options(pool_.get());
+  EXPECT_EQ(options.ioExecutor(), nullptr);
+
+  auto executor = std::make_shared<folly::CPUThreadPoolExecutor>(2);
+  options.setIOExecutor(executor);
+  EXPECT_EQ(options.ioExecutor(), executor);
+
+  options.setIOExecutor(nullptr);
+  EXPECT_EQ(options.ioExecutor(), nullptr);
+}
+
+TEST_F(ReaderOptionsTest, ioStats) {
+  ReaderOptions options(pool_.get());
+  options.setDataIoStats(dataIoStats_);
+  options.setMetadataIoStats(metadataIoStats_);
+  options.setIndexIoStats(indexIoStats_);
+
+  EXPECT_EQ(options.dataIoStats(), dataIoStats_);
+  EXPECT_EQ(options.metadataIoStats(), metadataIoStats_);
+  EXPECT_EQ(options.indexIoStats(), indexIoStats_);
+
+  options.dataIoStats()->read().increment(100);
+  EXPECT_EQ(dataIoStats_->read().count(), 1);
+  EXPECT_EQ(dataIoStats_->read().sum(), 100);
+
+  options.metadataIoStats()->read().increment(50);
+  EXPECT_EQ(metadataIoStats_->read().count(), 1);
+  EXPECT_EQ(metadataIoStats_->read().sum(), 50);
+
+  options.indexIoStats()->read().increment(25);
+  EXPECT_EQ(indexIoStats_->read().count(), 1);
+  EXPECT_EQ(indexIoStats_->read().sum(), 25);
+}
+
+TEST_F(ReaderOptionsTest, chainingSetters) {
+  ReaderOptions options(pool_.get());
+  auto& result = options.setDataIoStats(dataIoStats_)
+                     .setMetadataIoStats(metadataIoStats_)
+                     .setIndexIoStats(indexIoStats_)
+                     .setAutoPreloadLength(1'024)
+                     .setPrefetchMode(PrefetchMode::PRELOAD)
+                     .setLoadQuantum(4 << 20)
+                     .setMaxCoalesceDistance(1 << 20)
+                     .setMaxCoalesceBytes(64 << 20)
+                     .setPrefetchRowGroups(4);
+
+  EXPECT_EQ(&result, &options);
+  EXPECT_EQ(options.dataIoStats(), dataIoStats_);
+  EXPECT_EQ(options.metadataIoStats(), metadataIoStats_);
+  EXPECT_EQ(options.indexIoStats(), indexIoStats_);
+  EXPECT_EQ(options.autoPreloadLength(), 1'024);
+  EXPECT_EQ(options.prefetchMode(), PrefetchMode::PRELOAD);
+  EXPECT_EQ(options.loadQuantum(), 4 << 20);
+  EXPECT_EQ(options.maxCoalesceDistance(), 1 << 20);
+  EXPECT_EQ(options.maxCoalesceBytes(), 64 << 20);
+  EXPECT_EQ(options.prefetchRowGroups(), 4);
+}
+
+TEST_F(ReaderOptionsTest, doubleSetIoStatsThrows) {
+  ReaderOptions options(pool_.get());
+  options.setDataIoStats(dataIoStats_);
+  VELOX_ASSERT_THROW(
+      options.setDataIoStats(dataIoStats_), "dataIoStats already set");
+
+  ReaderOptions options2(pool_.get());
+  options2.setMetadataIoStats(metadataIoStats_);
+  VELOX_ASSERT_THROW(
+      options2.setMetadataIoStats(metadataIoStats_),
+      "metadataIoStats already set");
+
+  ReaderOptions options3(pool_.get());
+  options3.setIndexIoStats(indexIoStats_);
+  VELOX_ASSERT_THROW(
+      options3.setIndexIoStats(indexIoStats_), "indexIoStats already set");
+}
+
+TEST_F(ReaderOptionsTest, copyConstruct) {
+  ReaderOptions options(pool_.get());
+  options.setDataIoStats(dataIoStats_);
+  options.setMetadataIoStats(metadataIoStats_);
+  options.setLoadQuantum(4 << 20);
+
+  ReaderOptions copy(options);
+  EXPECT_EQ(&copy.memoryPool(), pool_.get());
+  EXPECT_EQ(copy.dataIoStats(), dataIoStats_);
+  EXPECT_EQ(copy.metadataIoStats(), metadataIoStats_);
+  EXPECT_EQ(copy.indexIoStats(), nullptr);
+  EXPECT_EQ(copy.loadQuantum(), 4 << 20);
+}
+
+} // namespace facebook::velox::io
diff --git a/velox/common/memory/Allocation.cpp b/velox/common/memory/Allocation.cpp
index 884af7c82cf..63fb4db4baa 100644
--- a/velox/common/memory/Allocation.cpp
+++ b/velox/common/memory/Allocation.cpp
@@ -35,10 +35,11 @@ void Allocation::append(uint8_t* address, MachinePageCount numPages) {
       runs_.empty() || address != runs_.back().data(),
       "Appending a duplicate address into a PageRun");
   if (FOLLY_UNLIKELY(numPages > Allocation::PageRun::kMaxPagesInRun)) {
-    VELOX_MEM_ALLOC_ERROR(fmt::format(
-        "The number of pages to append {} exceeds the PageRun limit {}",
-        numPages,
-        Allocation::PageRun::kMaxPagesInRun));
+    VELOX_MEM_ALLOC_ERROR(
+        fmt::format(
+            "The number of pages to append {} exceeds the PageRun limit {}",
+            numPages,
+            Allocation::PageRun::kMaxPagesInRun));
   }
   numPages_ += numPages;
   runs_.emplace_back(address, numPages);
diff --git a/velox/common/memory/ArbitrationParticipant.cpp b/velox/common/memory/ArbitrationParticipant.cpp
index dd679f81b06..7d74c98c731 100644
--- a/velox/common/memory/ArbitrationParticipant.cpp
+++ b/velox/common/memory/ArbitrationParticipant.cpp
@@ -441,8 +441,9 @@ ArbitrationTimedLock::ArbitrationTimedLock(
     uint64_t timeoutNs)
     : mutex_(mutex) {
   if (!mutex_.try_lock_for(std::chrono::nanoseconds(timeoutNs))) {
-    VELOX_MEM_ARBITRATION_TIMEOUT(fmt::format(
-        "Memory arbitration lock timed out when reclaiming from arbitration participant."));
+    VELOX_MEM_ARBITRATION_TIMEOUT(
+        fmt::format(
+            "Memory arbitration lock timed out when reclaiming from arbitration participant."));
   }
 }
 
diff --git a/velox/common/memory/ByteStream.cpp b/velox/common/memory/ByteStream.cpp
index 4fe93b56921..ebae051fc3a 100644
--- a/velox/common/memory/ByteStream.cpp
+++ b/velox/common/memory/ByteStream.cpp
@@ -16,19 +16,21 @@
 
 #include "velox/common/memory/ByteStream.h"
 
+#include <algorithm>
+
 namespace facebook::velox {
 
+static ByteRange convByteRange(folly::ByteRange br) {
+  return {const_cast<uint8_t*>(br.data()), folly::to_signed(br.size()), 0};
+}
+
 std::vector<ByteRange> byteRangesFromIOBuf(folly::IOBuf* iobuf) {
   if (iobuf == nullptr) {
     return {};
   }
   std::vector<ByteRange> byteRanges;
-  auto* current = iobuf;
-  do {
-    byteRanges.push_back(
-        {current->writableData(), static_cast<int32_t>(current->length()), 0});
-    current = current->next();
-  } while (current != iobuf);
+  auto dst = std::back_inserter(byteRanges);
+  std::transform(iobuf->begin(), iobuf->end(), dst, convByteRange);
   return byteRanges;
 }
 
@@ -55,9 +57,7 @@ std::string BufferInputStream::toString() const {
 }
 
 bool BufferInputStream::atEnd() const {
-  if (current_ == nullptr) {
-    return false;
-  }
+  VELOX_DCHECK_NOT_NULL(current_);
   if (current_->position < current_->size) {
     return false;
   }
@@ -75,9 +75,7 @@ size_t BufferInputStream::size() const {
 }
 
 size_t BufferInputStream::remainingSize() const {
-  if (ranges_.empty()) {
-    return 0;
-  }
+  VELOX_DCHECK(!ranges_.empty());
   const auto* lastRange = &ranges_.back();
   auto* cur = current_;
   size_t remainingBytes = cur->availableBytes();
@@ -88,10 +86,8 @@ size_t BufferInputStream::remainingSize() const {
 }
 
 std::streampos BufferInputStream::tellp() const {
-  if (ranges_.empty()) {
-    return 0;
-  }
-  assert(current_);
+  VELOX_DCHECK(!ranges_.empty());
+  VELOX_DCHECK_NOT_NULL(current_);
   int64_t size = 0;
   for (auto& range : ranges_) {
     if (&range == current_) {
@@ -103,9 +99,7 @@ std::streampos BufferInputStream::tellp() const {
 }
 
 void BufferInputStream::seekp(std::streampos position) {
-  if (ranges_.empty() && position == 0) {
-    return;
-  }
+  VELOX_DCHECK(!ranges_.empty());
   int64_t toSkip = position;
   for (auto& range : ranges_) {
     if (toSkip <= range.size) {
diff --git a/velox/common/memory/ByteStream.h b/velox/common/memory/ByteStream.h
index fee24a1f2e8..b8bfc1b20f9 100644
--- a/velox/common/memory/ByteStream.h
+++ b/velox/common/memory/ByteStream.h
@@ -259,6 +259,8 @@ class BufferInputStream : public ByteInputStream {
     return ranges_;
   }
 
+  // The byte ranges backing this stream. Guaranteed to be non-empty after
+  // construction.
   std::vector<ByteRange> ranges_;
 };
 
@@ -361,9 +363,10 @@ class ByteOutputStream {
     }
 
     if (current_->position + sizeof(T) * values.size() > current_->size) {
-      appendStringView(std::string_view(
-          reinterpret_cast<const char*>(&values[0]),
-          values.size() * sizeof(T)));
+      appendStringView(
+          std::string_view(
+              reinterpret_cast<const char*>(&values[0]),
+              values.size() * sizeof(T)));
       return;
     }
     auto* target = current_->buffer + current_->position;
@@ -414,7 +417,7 @@ class ByteOutputStream {
         auto* buffer = current_->buffer + (position >> 3);
         auto value = folly::loadUnaligned<uint64_t>(buffer);
         value = (value & mask) | (bits[0] << offset);
-        folly::storeUnaligned(buffer, value);
+        folly::storeUnaligned<uint64_t>(buffer, value);
         current_->position += end;
         return;
       }
@@ -537,9 +540,10 @@ class AppendWindow {
   ~AppendWindow() noexcept {
     if (scratchPtr_.size()) {
       try {
-        stream_.appendStringView(std::string_view(
-            reinterpret_cast<const char*>(scratchPtr_.get()),
-            scratchPtr_.size() * sizeof(T)));
+        stream_.appendStringView(
+            std::string_view(
+                reinterpret_cast<const char*>(scratchPtr_.get()),
+                scratchPtr_.size() * sizeof(T)));
       } catch (const std::exception& e) {
         // This is impossible because construction ensures there is space for
         // the bytes in the stream.
diff --git a/velox/common/memory/CMakeLists.txt b/velox/common/memory/CMakeLists.txt
index a36e0f06a6b..d6353c696cc 100644
--- a/velox/common/memory/CMakeLists.txt
+++ b/velox/common/memory/CMakeLists.txt
@@ -33,6 +33,25 @@ velox_add_library(
   RawVector.cpp
   SharedArbitrator.cpp
   StreamArena.cpp
+  HEADERS
+  Allocation.h
+  AllocationPool.h
+  ArbitrationOperation.h
+  ArbitrationParticipant.h
+  ByteStream.h
+  CompactDoubleList.h
+  HashStringAllocator.h
+  MallocAllocator.h
+  Memory.h
+  MemoryAllocator.h
+  MemoryArbitrator.h
+  MemoryPool.h
+  MmapAllocator.h
+  MmapArena.h
+  RawVector.h
+  Scratch.h
+  SharedArbitrator.h
+  StreamArena.h
 )
 
 velox_link_libraries(
diff --git a/velox/common/memory/HashStringAllocator.h b/velox/common/memory/HashStringAllocator.h
index 253bc4f27a1..6e153894dfc 100644
--- a/velox/common/memory/HashStringAllocator.h
+++ b/velox/common/memory/HashStringAllocator.h
@@ -19,7 +19,6 @@
 #include "velox/common/memory/AllocationPool.h"
 #include "velox/common/memory/ByteStream.h"
 #include "velox/common/memory/CompactDoubleList.h"
-#include "velox/common/memory/Memory.h"
 #include "velox/common/memory/StreamArena.h"
 #include "velox/type/StringView.h"
 
@@ -27,6 +26,9 @@
 
 namespace facebook::velox {
 
+template <class T>
+struct StlAllocator;
+
 /// Implements an arena backed by memory::Allocation. This is for backing
 /// ByteOutputStream or for allocating single blocks. Blocks can be individually
 /// freed. Adjacent frees are coalesced and free blocks are kept in a free list.
@@ -41,6 +43,9 @@ namespace facebook::velox {
 /// backing a HashStringAllocator is set to kArenaEnd.
 class HashStringAllocator : public StreamArena {
  public:
+  template <typename T>
+  using TStlAllocator = StlAllocator<T>;
+
   /// The minimum allocation must have space after the header for the free list
   /// pointers and the trailing length.
   static constexpr int32_t kMinAlloc =
@@ -659,8 +664,8 @@ class RowSizeTracker {
         counter_(counter) {}
 
   ~RowSizeTracker() {
-    auto delta = allocator_->currentBytes() - size_;
-    if (delta) {
+    const auto delta = allocator_->currentBytes() - size_;
+    if (delta != 0) {
       saturatingIncrement(&counter_, delta);
     }
   }
@@ -668,7 +673,7 @@ class RowSizeTracker {
  private:
   // Increments T at *pointer without wrapping around at overflow.
   void saturatingIncrement(T* pointer, int64_t delta) {
-    auto value = *reinterpret_cast<TCounter*>(pointer) + delta;
+    const auto value = *reinterpret_cast<TCounter*>(pointer) + delta;
     *reinterpret_cast<TCounter*>(pointer) =
         std::min<uint64_t>(value, std::numeric_limits<TCounter>::max());
   }
@@ -688,8 +693,12 @@ struct StlAllocator {
     VELOX_CHECK_NOT_NULL(allocator);
   }
 
+  // We can use "explicit" here based on the C++ standard. But
+  // libstdc++ 12 or older doesn't work for std::vector<bool> and
+  // "explicit". We can avoid it by not using "explicit" here.
+  // See also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115854
   template <class U>
-  explicit StlAllocator(const StlAllocator<U>& allocator)
+  StlAllocator(const StlAllocator<U>& allocator)
       : allocator_{allocator.allocator()} {
     VELOX_CHECK_NOT_NULL(allocator_);
   }
diff --git a/velox/common/memory/MallocAllocator.cpp b/velox/common/memory/MallocAllocator.cpp
index 297b2a2781c..dc6da02c6e6 100644
--- a/velox/common/memory/MallocAllocator.cpp
+++ b/velox/common/memory/MallocAllocator.cpp
@@ -15,15 +15,17 @@
  */
 
 #include "velox/common/memory/MallocAllocator.h"
+#include <folly/system/HardwareConcurrency.h>
 #include "velox/common/memory/Memory.h"
 
 #include <sys/mman.h>
 
 namespace facebook::velox::memory {
-MallocAllocator::MallocAllocator(size_t capacity, uint32_t reservationByteLimit)
+MallocAllocator::MallocAllocator(const Options& options)
     : kind_(MemoryAllocator::Kind::kMalloc),
-      capacity_(capacity),
-      reservationByteLimit_(reservationByteLimit),
+      mallocContiguousEnabled_(options.mallocContiguousEnabled),
+      capacity_(options.capacity),
+      reservationByteLimit_(options.reservationByteLimit),
       reserveFunc_(
           [this](uint32_t& counter, uint32_t increment, std::mutex& lock) {
             return incrementUsageWithReservationFunc(counter, increment, lock);
@@ -33,7 +35,7 @@ MallocAllocator::MallocAllocator(size_t capacity, uint32_t reservationByteLimit)
             decrementUsageWithReservationFunc(counter, decrement, lock);
             return true;
           }),
-      reservations_(std::thread::hardware_concurrency()) {}
+      reservations_(folly::available_concurrency()) {}
 
 MallocAllocator::~MallocAllocator() {
   // TODO: Remove the check when memory leak issue is resolved.
@@ -144,11 +146,7 @@ bool MallocAllocator::allocateContiguousImpl(
   }
   auto numContiguousCollateralPages = allocation.numPages();
   if (numContiguousCollateralPages > 0) {
-    useHugePages(allocation, false);
-    if (::munmap(allocation.data(), allocation.maxSize()) < 0) {
-      VELOX_MEM_LOG(ERROR) << "munmap got " << folly::errnoStr(errno) << "for "
-                           << allocation.data() << ", " << allocation.size();
-    }
+    dispatchFreeContiguous(allocation);
     numMapped_.fetch_sub(numContiguousCollateralPages);
     numAllocated_.fetch_sub(numContiguousCollateralPages);
     numExternalMapped_.fetch_sub(numContiguousCollateralPages);
@@ -174,19 +172,23 @@ bool MallocAllocator::allocateContiguousImpl(
   numAllocated_.fetch_add(numPages);
   numMapped_.fetch_add(numPages);
   numExternalMapped_.fetch_add(numPages);
-  void* data = ::mmap(
-      nullptr,
-      AllocationTraits::pageBytes(maxPages),
-      PROT_READ | PROT_WRITE,
-      MAP_PRIVATE | MAP_ANONYMOUS,
-      -1,
-      0);
-  // TODO: add handling of MAP_FAILED.
-  allocation.set(
-      data,
-      AllocationTraits::pageBytes(numPages),
-      AllocationTraits::pageBytes(maxPages));
-  useHugePages(allocation, true);
+  const auto maxBytes = AllocationTraits::pageBytes(maxPages);
+  void* data = dispatchAllocateContiguous(maxBytes);
+  if (FOLLY_UNLIKELY(data == nullptr)) {
+    numAllocated_.fetch_sub(numPages);
+    numMapped_.fetch_sub(numPages);
+    numExternalMapped_.fetch_sub(numPages);
+    decrementUsage(static_cast<int64_t>(AllocationTraits::pageBytes(numPages)));
+    const auto errorMsg = fmt::format(
+        "Failed to allocate {} of contiguous memory", succinctBytes(maxBytes));
+    VELOX_MEM_LOG(WARNING) << errorMsg;
+    setAllocatorFailureMessage(errorMsg);
+    return false;
+  }
+  allocation.set(data, AllocationTraits::pageBytes(numPages), maxBytes);
+  if (!mallocContiguousEnabled_) {
+    useHugePages(allocation, true);
+  }
   return true;
 }
 
@@ -221,14 +223,9 @@ void MallocAllocator::freeContiguousImpl(ContiguousAllocation& allocation) {
   if (allocation.empty()) {
     return;
   }
-  useHugePages(allocation, false);
   const auto bytes = allocation.size();
   const auto numPages = allocation.numPages();
-  if (::munmap(allocation.data(), allocation.maxSize()) < 0) {
-    VELOX_MEM_LOG(ERROR) << "Error for munmap(" << allocation.data() << ", "
-                         << succinctBytes(bytes) << "): '"
-                         << folly::errnoStr(errno) << "'";
-  }
+  dispatchFreeContiguous(allocation);
   numMapped_.fetch_sub(numPages);
   numAllocated_.fetch_sub(numPages);
   numExternalMapped_.fetch_sub(numPages);
@@ -236,6 +233,36 @@ void MallocAllocator::freeContiguousImpl(ContiguousAllocation& allocation) {
   allocation.clear();
 }
 
+void* MallocAllocator::dispatchAllocateContiguous(size_t maxBytes) {
+  if (testingHasInjectedFailure(InjectedFailure::kAllocate)) {
+    return nullptr;
+  }
+  if (mallocContiguousEnabled_) {
+    return ::aligned_alloc(AllocationTraits::kPageSize, maxBytes);
+  }
+  // TODO: add handling of MAP_FAILED.
+  return ::mmap(
+      nullptr,
+      maxBytes,
+      PROT_READ | PROT_WRITE,
+      MAP_PRIVATE | MAP_ANONYMOUS,
+      -1,
+      0);
+}
+
+void MallocAllocator::dispatchFreeContiguous(ContiguousAllocation& allocation) {
+  if (mallocContiguousEnabled_) {
+    ::free(allocation.data());
+  } else {
+    useHugePages(allocation, false);
+    if (::munmap(allocation.data(), allocation.maxSize()) < 0) {
+      VELOX_MEM_LOG(ERROR) << "Error for munmap(" << allocation.data() << ", "
+                           << succinctBytes(allocation.size()) << "): '"
+                           << folly::errnoStr(errno) << "'";
+    }
+  }
+}
+
 bool MallocAllocator::growContiguousWithoutRetry(
     MachinePageCount increment,
     ContiguousAllocation& allocation) {
@@ -308,6 +335,61 @@ void* MallocAllocator::allocateZeroFilledWithoutRetry(uint64_t bytes) {
   return result;
 }
 
+void* MallocAllocator::reallocateBytesWithoutRetry(
+    void* p,
+    uint64_t oldSize,
+    uint64_t newSize,
+    uint16_t alignment) {
+  if (p == nullptr || alignment > kMinAlignment ||
+      (reinterpret_cast<uintptr_t>(p) % alignment) != 0) {
+    return nullptr;
+  }
+  if (!isAlignmentValid(newSize, alignment)) {
+    VELOX_FAIL(
+        "Alignment check failed, reallocateBytes {}, alignmentBytes {}",
+        newSize,
+        alignment);
+  }
+  const auto delta =
+      static_cast<int64_t>(newSize) - static_cast<int64_t>(oldSize);
+  if (delta > 0 && !incrementUsage(delta)) {
+    auto errorMsg = fmt::format(
+        "Failed to reallocate: exceeded memory allocator limit of {}. "
+        "Old size: {}, new size: {}",
+        succinctBytes(capacity_),
+        succinctBytes(oldSize),
+        succinctBytes(newSize));
+    VELOX_MEM_LOG_EVERY_MS(WARNING, 1000) << errorMsg;
+    setAllocatorFailureMessage(errorMsg);
+    return nullptr;
+  }
+  void* result = ::realloc(p, newSize); // NOLINT
+  if (result == nullptr) {
+    // realloc failed. The original pointer is still valid.
+    if (delta > 0) {
+      decrementUsage(delta);
+    }
+    VELOX_MEM_LOG(ERROR) << "Failed to reallocateBytes from "
+                         << succinctBytes(oldSize) << " to "
+                         << succinctBytes(newSize);
+    return nullptr;
+  }
+  // ::realloc() must return a pointer aligned to the requested alignment.
+  // The C standard guarantees alignof(max_align_t), and we already enforced
+  // alignment <= kMinAlignment above, so this should always hold for a
+  // conformant allocator. Fail loudly if it doesn't (e.g., a non-conformant
+  // LD_PRELOAD interposer).
+  VELOX_CHECK_EQ(
+      reinterpret_cast<uintptr_t>(result) % alignment,
+      0,
+      "::realloc returned a pointer not aligned to requested alignment: {}",
+      alignment);
+  if (delta < 0) {
+    decrementUsage(-delta);
+  }
+  return result;
+}
+
 void MallocAllocator::freeBytes(void* p, uint64_t bytes) noexcept {
   ::free(p); // NOLINT
   decrementUsage(bytes);
diff --git a/velox/common/memory/MallocAllocator.h b/velox/common/memory/MallocAllocator.h
index aadeb5518b7..f3d020e05ac 100644
--- a/velox/common/memory/MallocAllocator.h
+++ b/velox/common/memory/MallocAllocator.h
@@ -26,7 +26,7 @@ namespace facebook::velox::memory {
 /// The implementation of MemoryAllocator using malloc.
 class MallocAllocator : public MemoryAllocator {
  public:
-  MallocAllocator(size_t capacity, uint32_t reservationByteLimit);
+  explicit MallocAllocator(const Options& options);
 
   ~MallocAllocator() override;
 
@@ -102,12 +102,40 @@ class MallocAllocator : public MemoryAllocator {
       ContiguousAllocation& allocation,
       MachinePageCount maxPages);
 
+  // Allocates 'maxBytes' of contiguous memory using malloc or mmap depending
+  // on 'mallocContiguousEnabled_'. Returns the allocated pointer, or nullptr
+  // on failure.
+  void* dispatchAllocateContiguous(size_t maxBytes);
+
+  // Frees contiguous memory previously allocated by
+  // dispatchAllocateContiguous.
+  void dispatchFreeContiguous(ContiguousAllocation& allocation);
+
   void freeContiguousImpl(ContiguousAllocation& allocation);
 
   void* allocateBytesWithoutRetry(uint64_t bytes, uint16_t alignment) override;
 
   void* allocateZeroFilledWithoutRetry(uint64_t bytes) override;
 
+  /// Attempts in-place reallocation via ::realloc(). Returns nullptr when
+  /// ::realloc() cannot satisfy the request, in which case the caller falls
+  /// back to allocate + memcpy + free. Preconditions for using ::realloc():
+  /// 1. p must be non-null. ::realloc(nullptr, n) would behave like malloc,
+  ///    but we route nullptr through allocateBytes so the caller picks up
+  ///    cache eviction on the fallback.
+  /// 2. The requested alignment must be at most kMinAlignment. ::realloc()
+  ///    guarantees only kMinAlignment on the returned pointer (and may move
+  ///    the data to a new address), so larger alignments cannot be honored.
+  /// 3. p must already be aligned to the requested alignment. MemoryAllocator
+  ///    is a standalone module that may be used outside MemoryPool, so we
+  ///    cannot rely on the caller to pass an alignment matching the original
+  ///    allocation.
+  void* reallocateBytesWithoutRetry(
+      void* p,
+      uint64_t oldSize,
+      uint64_t newSize,
+      uint16_t alignment) override;
+
   // Increments current usage and check current 'allocatedBytes_' counter to
   // make sure current usage does not go above 'capacity_'. If it goes above
   // 'capacity_', the increment will not be applied. Returns true if within
@@ -206,16 +234,20 @@ class MallocAllocator : public MemoryAllocator {
     if (originalBytes - bytes < 0) {
       // In case of inconsistency while freeing memory, do not revert in this
       // case because free is guaranteed to happen.
-      VELOX_MEM_ALLOC_ERROR(fmt::format(
-          "Trying to free {} bytes, which is larger than current allocated "
-          "bytes {}",
-          bytes,
-          originalBytes))
+      VELOX_MEM_ALLOC_ERROR(
+          fmt::format(
+              "Trying to free {} bytes, which is larger than current allocated "
+              "bytes {}",
+              bytes,
+              originalBytes))
     }
   }
 
   const Kind kind_;
 
+  // If true, use malloc for contiguous allocations instead of mmap/munmap.
+  const bool mallocContiguousEnabled_;
+
   // Capacity in bytes. Total allocation byte is not allowed to exceed this
   // value.
   const size_t capacity_;
diff --git a/velox/common/memory/Memory.cpp b/velox/common/memory/Memory.cpp
index 01de413c830..45a185cae7e 100644
--- a/velox/common/memory/Memory.cpp
+++ b/velox/common/memory/Memory.cpp
@@ -46,17 +46,21 @@ SingletonState& singletonState() {
 
 std::shared_ptr<MemoryAllocator> createAllocator(
     const MemoryManager::Options& options) {
+  MemoryAllocator::Options allocatorOptions;
+  allocatorOptions.capacity = options.allocatorCapacity;
   if (options.useMmapAllocator) {
-    MmapAllocator::Options mmapOptions;
-    mmapOptions.capacity = options.allocatorCapacity;
-    mmapOptions.largestSizeClass = options.largestSizeClassPages;
-    mmapOptions.useMmapArena = options.useMmapArena;
-    mmapOptions.mmapArenaCapacityRatio = options.mmapArenaCapacityRatio;
-    return std::make_shared<MmapAllocator>(mmapOptions);
+    allocatorOptions.largestSizeClass = options.largestSizeClassPages;
+    allocatorOptions.useMmapArena = options.useMmapArena;
+    allocatorOptions.mmapArenaCapacityRatio = options.mmapArenaCapacityRatio;
+    allocatorOptions.smallAllocationReservePct =
+        options.smallAllocationReservePct;
+    allocatorOptions.maxMallocBytes = options.maxMallocBytes;
+    return std::make_shared<MmapAllocator>(allocatorOptions);
   } else {
-    return std::make_shared<MallocAllocator>(
-        options.allocatorCapacity,
-        options.allocationSizeThresholdWithReservation);
+    allocatorOptions.reservationByteLimit =
+        options.allocationSizeThresholdWithReservation;
+    allocatorOptions.mallocContiguousEnabled = options.mallocContiguousEnabled;
+    return std::make_shared<MallocAllocator>(allocatorOptions);
   }
 }
 
@@ -382,23 +386,23 @@ std::string MemoryManager::toString(bool detail) const {
                                           : succinctBytes(allocatorCapacity))
       << " alignment " << succinctBytes(alignment_) << " usedBytes "
       << succinctBytes(getTotalBytes()) << " number of pools " << numPools()
-      << "\n";
+      << '\n';
   out << "List of root pools:\n";
   if (detail) {
     out << sysRoot_->treeMemoryUsage(false);
   } else {
-    out << "\t" << sysRoot_->name() << "\n";
+    out << '\t' << sysRoot_->name() << '\n';
   }
   std::vector<std::shared_ptr<MemoryPool>> pools = getAlivePools();
   for (const auto& pool : pools) {
     if (detail) {
       out << pool->treeMemoryUsage(false);
     } else {
-      out << "\t" << pool->name() << "\n";
+      out << '\t' << pool->name() << '\n';
     }
-    out << "\trefcount " << pool.use_count() << "\n";
+    out << "\trefcount " << pool.use_count() << '\n';
   }
-  out << allocator_->toString() << "\n";
+  out << allocator_->toString() << '\n';
   out << arbitrator_->toString();
   out << "]";
   return out.str();
diff --git a/velox/common/memory/Memory.h b/velox/common/memory/Memory.h
index ce8caf1821f..675f72a3fcc 100644
--- a/velox/common/memory/Memory.h
+++ b/velox/common/memory/Memory.h
@@ -41,7 +41,6 @@
 #include "velox/common/memory/MemoryPool.h"
 
 DECLARE_bool(velox_memory_leak_check_enabled);
-DECLARE_bool(velox_memory_pool_debug_enabled);
 DECLARE_bool(velox_enable_memory_usage_track_in_default_memory_pool);
 
 namespace facebook::velox::memory {
@@ -140,6 +139,12 @@ class MemoryManager {
     /// NOTE: this only applies for MallocAllocator.
     uint32_t allocationSizeThresholdWithReservation{1 << 20};
 
+    /// If true, MallocAllocator uses malloc for contiguous allocations instead
+    /// of mmap/munmap.
+    ///
+    /// NOTE: this only applies for MallocAllocator.
+    bool mallocContiguousEnabled{false};
+
     /// ================== 'MemoryArbitrator' settings =================
 
     /// Memory capacity available for query/task memory pools. This capacity
diff --git a/velox/common/memory/MemoryAllocator.cpp b/velox/common/memory/MemoryAllocator.cpp
index 2a997ad0045..21aae7906e3 100644
--- a/velox/common/memory/MemoryAllocator.cpp
+++ b/velox/common/memory/MemoryAllocator.cpp
@@ -15,10 +15,11 @@
  */
 
 #include "velox/common/memory/MemoryAllocator.h"
-#include "velox/common/memory/MallocAllocator.h"
 
 #include <sys/mman.h>
 #include <sys/resource.h>
+#include <algorithm>
+#include <cstring>
 #include <iostream>
 #include <numeric>
 
@@ -29,6 +30,14 @@ DECLARE_bool(velox_memory_use_hugepages);
 
 namespace facebook::velox::memory {
 
+void AcquiredMemory::free(MemoryAllocator* allocator) {
+  allocator->freeNonContiguous(nonContiguousAllocs);
+  for (auto& [ptr, size] : byteAllocations) {
+    allocator->freeBytes(ptr, size);
+  }
+  byteAllocations.clear();
+}
+
 // static
 std::vector<MachinePageCount> MemoryAllocator::makeSizeClassSizes(
     MachinePageCount largest) {
@@ -218,8 +227,9 @@ bool MemoryAllocator::allocateNonContiguous(
     success = allocateNonContiguousWithoutRetry(mix, out);
   } else {
     success = cache()->makeSpace(
-        pagesToAcquire(numPages, out.numPages()), [&](Allocation& acquired) {
-          freeNonContiguous(acquired);
+        pagesToAcquire(numPages, out.numPages()),
+        [&](AcquiredMemory& acquired) {
+          acquired.free(this);
           return allocateNonContiguousWithoutRetry(mix, out);
         });
   }
@@ -286,8 +296,8 @@ bool MemoryAllocator::allocateContiguous(
   } else {
     success = cache()->makeSpace(
         pagesToAcquire(numPages, numCollateralPages),
-        [&](Allocation& acquired) {
-          freeNonContiguous(acquired);
+        [&](AcquiredMemory& acquired) {
+          acquired.free(this);
           return allocateContiguousWithoutRetry(
               numPages, collateral, allocation, maxPages);
         });
@@ -320,8 +330,8 @@ bool MemoryAllocator::growContiguous(
   if (cache() == nullptr) {
     success = growContiguousWithoutRetry(increment, allocation);
   } else {
-    success = cache()->makeSpace(increment, [&](Allocation& acquired) {
-      freeNonContiguous(acquired);
+    success = cache()->makeSpace(increment, [&](AcquiredMemory& acquired) {
+      acquired.free(this);
       return growContiguousWithoutRetry(increment, allocation);
     });
   }
@@ -337,8 +347,8 @@ void* MemoryAllocator::allocateBytes(uint64_t bytes, uint16_t alignment) {
   }
   void* result = nullptr;
   cache()->makeSpace(
-      AllocationTraits::numPages(bytes), [&](Allocation& acquired) {
-        freeNonContiguous(acquired);
+      AllocationTraits::numPages(bytes), [&](AcquiredMemory& acquired) {
+        acquired.free(this);
         result = allocateBytesWithoutRetry(bytes, alignment);
         return result != nullptr;
       });
@@ -351,8 +361,8 @@ void* MemoryAllocator::allocateZeroFilled(uint64_t bytes) {
   }
   void* result = nullptr;
   cache()->makeSpace(
-      AllocationTraits::numPages(bytes), [&](Allocation& acquired) {
-        freeNonContiguous(acquired);
+      AllocationTraits::numPages(bytes), [&](AcquiredMemory& acquired) {
+        acquired.free(this);
         result = allocateZeroFilledWithoutRetry(bytes);
         return result != nullptr;
       });
@@ -367,6 +377,40 @@ void* MemoryAllocator::allocateZeroFilledWithoutRetry(uint64_t bytes) {
   return result;
 }
 
+void* MemoryAllocator::reallocateBytes(
+    void* p,
+    uint64_t oldSize,
+    uint64_t newSize,
+    uint16_t alignment) {
+  // Try in-place reallocation first (supported by MallocAllocator via
+  // ::realloc(), which jemalloc can often service without moving data).
+  void* result = reallocateBytesWithoutRetry(p, oldSize, newSize, alignment);
+  if (result != nullptr) {
+    return result;
+  }
+  // Fallback: allocate new + memcpy + free old. This path also handles
+  // cache eviction via allocateBytes.
+  void* newP = allocateBytes(newSize, alignment);
+  if (newP == nullptr) {
+    return nullptr;
+  }
+  if (p != nullptr) {
+    ::memcpy(newP, p, std::min(oldSize, newSize));
+    freeBytes(p, oldSize);
+  }
+  return newP;
+}
+
+void* MemoryAllocator::reallocateBytesWithoutRetry(
+    void* /*p*/,
+    uint64_t /*oldSize*/,
+    uint64_t /*newSize*/,
+    uint16_t /*alignment*/) {
+  // Default: in-place reallocation not supported. Caller will fall back to
+  // allocateBytes + memcpy + freeBytes.
+  return nullptr;
+}
+
 Stats Stats::operator-(const Stats& other) const {
   Stats result;
   for (auto i = 0; i < sizes.size(); ++i) {
diff --git a/velox/common/memory/MemoryAllocator.h b/velox/common/memory/MemoryAllocator.h
index 621fe2e2a88..bfa5dde7857 100644
--- a/velox/common/memory/MemoryAllocator.h
+++ b/velox/common/memory/MemoryAllocator.h
@@ -140,23 +140,44 @@ struct Stats {
 
 class MemoryAllocator;
 
+/// Memory collected from evicted cache entries. Non-contiguous page
+/// allocations and byte allocations (from allocateBytes()) are tracked
+/// separately so they can be freed back to the allocator before retrying
+/// allocation.
+struct AcquiredMemory {
+  Allocation nonContiguousAllocs;
+  // Byte allocations from allocateBytes().
+  std::vector<std::pair<void*, uint64_t>> byteAllocations;
+
+  uint64_t totalBytes() const {
+    uint64_t bytes = nonContiguousAllocs.byteSize();
+    for (const auto& [_, size] : byteAllocations) {
+      bytes += size;
+    }
+    return bytes;
+  }
+
+  void free(MemoryAllocator* allocator);
+
+  bool empty() const {
+    return nonContiguousAllocs.empty() && byteAllocations.empty();
+  }
+};
+
 /// A general cache interface using 'MemoryAllocator' to allocate memory, that
 /// is also able to free up memory upon request by shrinking itself.
 class Cache {
  public:
   virtual ~Cache() = default;
 
-  /// This method should be implemented so that it tries to
-  /// accommodate the passed in 'allocate' by freeing up space from
-  /// 'this' if needed. 'numPages' is the number of pages 'allocate
-  /// needs to be free for allocate to succeed. This should return
-  /// true if 'allocate' succeeds, and false otherwise. 'numPages' can
-  /// be less than the planned allocation, even 0 but not
-  /// negative. This is possible if 'allocate' brings its own memory
-  /// that is exchanged for the new allocation.
+  /// Tries to accommodate 'allocate' by freeing up space from 'this'
+  /// if needed. 'numPages' is the number of pages 'allocate' needs to
+  /// be free to succeed. Returns true if 'allocate' succeeds.
+  /// 'allocate' receives an 'AcquiredMemory' containing evicted memory
+  /// that should be freed before retrying allocation.
   virtual bool makeSpace(
       memory::MachinePageCount numPages,
-      std::function<bool(Allocation&)> allocate) = 0;
+      std::function<bool(AcquiredMemory&)> allocate) = 0;
 
   /// This method is implemented to shrink the cache space with the specified
   /// 'targetBytes'. The method returns the actually freed cache space in bytes.
@@ -191,6 +212,45 @@ std::string getAndClearCacheFailureMessage();
 /// tracking while delegating the allocation to a root allocator.
 class MemoryAllocator : public std::enable_shared_from_this<MemoryAllocator> {
  public:
+  struct Options {
+    /// Capacity in bytes, default unlimited.
+    /// Applies to: MallocAllocator, MmapAllocator.
+    size_t capacity{static_cast<size_t>(std::numeric_limits<int64_t>::max())};
+
+    /// --- MallocAllocator-only options ---
+
+    /// Allocation size threshold below which allocations use sharded local
+    /// counters instead of updating the global counter. Default 1MB.
+    uint32_t reservationByteLimit{1 << 20};
+
+    /// If true, use malloc for contiguous allocations instead of mmap/munmap.
+    bool mallocContiguousEnabled{false};
+
+    /// --- MmapAllocator-only options ---
+
+    /// Number of pages in the largest size class.
+    int32_t largestSizeClass{256};
+
+    /// If set true, allocations larger than largest size class size will be
+    /// delegated to ManagedMmapArena. Otherwise a system mmap call will be
+    /// issued for each such allocation.
+    bool useMmapArena{false};
+
+    /// Used to determine MmapArena capacity. The ratio represents system
+    /// memory capacity to single MmapArena capacity ratio.
+    int32_t mmapArenaCapacityRatio{10};
+
+    /// If not zero, reserve 'smallAllocationReservePct'% of space from
+    /// 'capacity' for ad hoc small allocations delegated to std::malloc.
+    /// If 'maxMallocBytes' is 0, this value will be disregarded.
+    uint32_t smallAllocationReservePct{0};
+
+    /// The allocation threshold less than which an allocation is delegated
+    /// to std::malloc(). If zero, no allocations are delegated to malloc
+    /// and 'smallAllocationReservePct' is automatically set to 0.
+    int32_t maxMallocBytes{3072};
+  };
+
   /// Defines the memory allocator kinds.
   enum class Kind {
     /// The default memory allocator kind which is implemented by
@@ -311,6 +371,20 @@ class MemoryAllocator : public std::enable_shared_from_this<MemoryAllocator> {
   /// 'cache()' if registered. But sufficient space is not guaranteed.
   void* allocateZeroFilled(uint64_t bytes);
 
+  /// Reallocates contiguous memory. Tries in-place reallocation first (via the
+  /// allocator-specific reallocateBytesWithoutRetry), falling back to
+  /// allocateBytes + memcpy + freeBytes if the allocator does not support
+  /// in-place reallocation. Returns nullptr on failure.
+  ///
+  /// When the underlying allocator is MallocAllocator (backed by jemalloc),
+  /// this uses ::realloc() which can often expand the allocation in-place,
+  /// avoiding the expensive memcpy.
+  void* reallocateBytes(
+      void* p,
+      uint64_t oldSize,
+      uint64_t newSize,
+      uint16_t alignment = kMinAlignment);
+
   /// Frees contiguous memory allocated by allocateBytes, allocateZeroFilled,
   /// reallocateBytes.
   virtual void freeBytes(void* p, uint64_t size) noexcept = 0;
@@ -451,6 +525,16 @@ class MemoryAllocator : public std::enable_shared_from_this<MemoryAllocator> {
 
   virtual void* allocateZeroFilledWithoutRetry(uint64_t bytes);
 
+  // Attempts to reallocate 'p' from 'oldSize' to 'newSize' bytes without
+  // retry through cache eviction. Returns nullptr if in-place reallocation
+  // is not supported or fails. The default implementation always returns
+  // nullptr; MallocAllocator overrides this to use ::realloc().
+  virtual void* reallocateBytesWithoutRetry(
+      void* p,
+      uint64_t oldSize,
+      uint64_t newSize,
+      uint16_t alignment);
+
   virtual bool growContiguousWithoutRetry(
       MachinePageCount increment,
       ContiguousAllocation& allocation) = 0;
diff --git a/velox/common/memory/MemoryArbitrator.cpp b/velox/common/memory/MemoryArbitrator.cpp
index eb817300608..da6f1a812a1 100644
--- a/velox/common/memory/MemoryArbitrator.cpp
+++ b/velox/common/memory/MemoryArbitrator.cpp
@@ -99,7 +99,11 @@ class NoopArbitrator : public MemoryArbitrator {
   }
 
   void removePool(MemoryPool* pool) override {
-    VELOX_CHECK_EQ(pool->reservedBytes(), 0);
+    VELOX_CHECK_EQ(
+        pool->reservedBytes(),
+        0,
+        "Memory pool has unexpected reserved bytes on removal: {}",
+        pool->name());
   }
 
   // Noop arbitrator has no memory capacity limit so no operation needed for
@@ -263,9 +267,10 @@ uint64_t MemoryReclaimer::reclaim(
           nonReclaimableCandidates.push_back(Candidate{std::move(child), 0});
           continue;
         }
-        candidates.push_back(Candidate{
-            std::move(child),
-            static_cast<int64_t>(reclaimableBytesOpt.value())});
+        candidates.push_back(
+            Candidate{
+                std::move(child),
+                static_cast<int64_t>(reclaimableBytesOpt.value())});
       }
     }
   }
@@ -539,10 +544,14 @@ ScopedReclaimedBytesRecorder::~ScopedReclaimedBytesRecorder() {
   const int64_t reservedBytesAfterReclaim = pool_->reservedBytes();
   if (reservedBytesAfterReclaim > reservedBytesBeforeReclaim_) {
     LOG(ERROR) << "Unexpected reserved bytes growth from " << pool_->name()
+               << ", root pool: " << pool_->root()->name()
                << " after memory reclaim from "
                << succinctBytes(reservedBytesBeforeReclaim_) << " to "
-               << succinctBytes(reservedBytesAfterReclaim) << ", current usage "
-               << succinctBytes(pool_->usedBytes());
+               << succinctBytes(reservedBytesAfterReclaim)
+               << ", used: " << succinctBytes(pool_->usedBytes())
+               << ", reservation: " << succinctBytes(pool_->reservedBytes())
+               << ", root pool reservation: "
+               << succinctBytes(pool_->root()->reservedBytes());
   }
   *reclaimedBytes_ = reservedBytesBeforeReclaim_ - reservedBytesAfterReclaim;
 }
diff --git a/velox/common/memory/MemoryPool.cpp b/velox/common/memory/MemoryPool.cpp
index 2a05c4774c5..1a902589bd3 100644
--- a/velox/common/memory/MemoryPool.cpp
+++ b/velox/common/memory/MemoryPool.cpp
@@ -18,6 +18,7 @@
 
 #include <signal.h>
 
+#include "velox/common/Casts.h"
 #include "velox/common/base/Counters.h"
 #include "velox/common/base/StatsReporter.h"
 #include "velox/common/base/SuccinctPrinter.h"
@@ -31,6 +32,13 @@ DEFINE_bool(
     false,
     "Whether allow to memory capacity transfer between memory pools from different tasks, which might happen in use case like Spark-Gluten");
 
+DEFINE_bool(
+    velox_enable_inplace_realloc,
+    true,
+    "If true, MemoryPool::reallocate uses MemoryAllocator::reallocateBytes "
+    "which tries in-place reallocation via ::realloc() (jemalloc can often "
+    "expand without memcpy). If false, uses the legacy alloc+memcpy+free path.");
+
 DECLARE_bool(velox_suppress_memory_capacity_exceeding_error_message);
 
 using facebook::velox::common::testutil::TestValue;
@@ -38,14 +46,14 @@ using facebook::velox::common::testutil::TestValue;
 namespace facebook::velox::memory {
 namespace {
 // Check if memory operation is allowed and increment the named stats.
-#define CHECK_AND_INC_MEM_OP_STATS(stats)                             \
+#define CHECK_AND_INC_MEM_OP_STATS(pool, stats)                       \
   do {                                                                \
-    if (FOLLY_UNLIKELY(kind_ != Kind::kLeaf)) {                       \
+    if (FOLLY_UNLIKELY(pool->kind_ != Kind::kLeaf)) {                 \
       VELOX_FAIL(                                                     \
           "Memory operation is only allowed on leaf memory pool: {}", \
-          toString());                                                \
+          pool->toString());                                          \
     }                                                                 \
-    ++num##stats##_;                                                  \
+    ++pool->num##stats##_;                                            \
   } while (0)
 
 // Check if memory operation is allowed and increment the named stats.
@@ -153,9 +161,9 @@ std::string capacityToString(int64_t capacity) {
   return capacity == kMaxMemory ? "UNLIMITED" : succinctBytes(capacity);
 }
 
-#define DEBUG_RECORD_ALLOC(...)         \
-  if (FOLLY_UNLIKELY(debugEnabled())) { \
-    recordAllocDbg(__VA_ARGS__);        \
+#define DEBUG_RECORD_ALLOC(pool, ...)         \
+  if (FOLLY_UNLIKELY(pool->debugEnabled())) { \
+    pool->recordAllocDbg(__VA_ARGS__);        \
   }
 #define DEBUG_RECORD_FREE(...)          \
   if (FOLLY_UNLIKELY(debugEnabled())) { \
@@ -521,60 +529,93 @@ void* MemoryPoolImpl::allocate(
     }
   }
 
-  CHECK_AND_INC_MEM_OP_STATS(Allocs);
+  CHECK_AND_INC_MEM_OP_STATS(this, Allocs);
   const auto alignedSize = sizeAlign(size);
   reserve(alignedSize);
   void* buffer = allocator_->allocateBytes(alignedSize, alignment_);
   if (FOLLY_UNLIKELY(buffer == nullptr)) {
     release(alignedSize);
-    handleAllocationFailure(fmt::format(
-        "{} failed with {} from {} {}",
-        __FUNCTION__,
-        succinctBytes(size),
-        toString(),
-        allocator_->getAndClearFailureMessage()));
-  }
-  DEBUG_RECORD_ALLOC(buffer, size);
+    handleAllocationFailure(
+        fmt::format(
+            "{} failed with {} from {} {}",
+            __FUNCTION__,
+            succinctBytes(size),
+            toString(),
+            allocator_->getAndClearFailureMessage()));
+  }
+  DEBUG_RECORD_ALLOC(this, buffer, size);
   return buffer;
 }
 
 void* MemoryPoolImpl::allocateZeroFilled(int64_t numEntries, int64_t sizeEach) {
-  CHECK_AND_INC_MEM_OP_STATS(Allocs);
+  CHECK_AND_INC_MEM_OP_STATS(this, Allocs);
   const auto size = sizeEach * numEntries;
   const auto alignedSize = sizeAlign(size);
   reserve(alignedSize);
   void* buffer = allocator_->allocateZeroFilled(alignedSize);
   if (FOLLY_UNLIKELY(buffer == nullptr)) {
     release(alignedSize);
-    handleAllocationFailure(fmt::format(
-        "{} failed with {} entries and {} each from {} {}",
-        __FUNCTION__,
-        numEntries,
-        succinctBytes(sizeEach),
-        toString(),
-        allocator_->getAndClearFailureMessage()));
-  }
-  DEBUG_RECORD_ALLOC(buffer, size);
+    handleAllocationFailure(
+        fmt::format(
+            "{} failed with {} entries and {} each from {} {}",
+            __FUNCTION__,
+            numEntries,
+            succinctBytes(sizeEach),
+            toString(),
+            allocator_->getAndClearFailureMessage()));
+  }
+  DEBUG_RECORD_ALLOC(this, buffer, size);
   return buffer;
 }
 
 void* MemoryPoolImpl::reallocate(void* p, int64_t size, int64_t newSize) {
-  CHECK_AND_INC_MEM_OP_STATS(Allocs);
+  CHECK_AND_INC_MEM_OP_STATS(this, Allocs);
   const auto alignedNewSize = sizeAlign(newSize);
+  const auto alignedOldSize = sizeAlign(size);
   reserve(alignedNewSize);
 
-  void* newP = allocator_->allocateBytes(alignedNewSize, alignment_);
+  // Two fully separate branches are kept here intentionally so the legacy
+  // path can be deleted as a single block once the in-place path is rolled
+  // out and FLAGS_velox_enable_inplace_realloc is removed.
+  if (FLAGS_velox_enable_inplace_realloc) {
+    // In-place path: try ::realloc() via reallocateBytes, which jemalloc can
+    // often service without moving data (avoiding the expensive memcpy).
+    void* const newP = allocator_->reallocateBytes(
+        p, alignedOldSize, alignedNewSize, alignment_);
+    if (newP == nullptr) {
+      release(alignedNewSize);
+      handleAllocationFailure(
+          fmt::format(
+              "{} failed with new {} and old {} from {} {}",
+              __FUNCTION__,
+              succinctBytes(newSize),
+              succinctBytes(size),
+              toString(),
+              allocator_->getAndClearFailureMessage()));
+    }
+    if (p != nullptr) {
+      INC_MEM_OP_STATS(Frees);
+      DEBUG_RECORD_FREE(p, size);
+      release(alignedOldSize);
+    }
+    DEBUG_RECORD_ALLOC(this, newP, newSize);
+    return newP;
+  }
+
+  // Legacy path: allocate new + memcpy + free old.
+  void* const newP = allocator_->allocateBytes(alignedNewSize, alignment_);
   if (FOLLY_UNLIKELY(newP == nullptr)) {
     release(alignedNewSize);
-    handleAllocationFailure(fmt::format(
-        "{} failed with new {} and old {} from {} {}",
-        __FUNCTION__,
-        succinctBytes(newSize),
-        succinctBytes(size),
-        toString(),
-        allocator_->getAndClearFailureMessage()));
-  }
-  DEBUG_RECORD_ALLOC(newP, newSize);
+    handleAllocationFailure(
+        fmt::format(
+            "{} failed with new {} and old {} from {} {}",
+            __FUNCTION__,
+            succinctBytes(newSize),
+            succinctBytes(size),
+            toString(),
+            allocator_->getAndClearFailureMessage()));
+  }
+  DEBUG_RECORD_ALLOC(this, newP, newSize);
   if (p != nullptr) {
     ::memcpy(newP, p, std::min(size, newSize));
     free(p, size);
@@ -583,18 +624,40 @@ void* MemoryPoolImpl::reallocate(void* p, int64_t size, int64_t newSize) {
 }
 
 void MemoryPoolImpl::free(void* p, int64_t size) {
-  CHECK_AND_INC_MEM_OP_STATS(Frees);
+  CHECK_AND_INC_MEM_OP_STATS(this, Frees);
   const auto alignedSize = sizeAlign(size);
   DEBUG_RECORD_FREE(p, size);
   allocator_->freeBytes(p, alignedSize);
   release(alignedSize);
 }
 
+bool MemoryPoolImpl::transferTo(MemoryPool* dest, void* buffer, uint64_t size) {
+  if (!isLeaf() || !dest->isLeaf()) {
+    return false;
+  }
+  VELOX_CHECK_NOT_NULL(dest);
+  auto* destImpl = checkedPointerCast<MemoryPoolImpl, MemoryPool>(dest);
+  if (allocator_ != destImpl->allocator_) {
+    return false;
+  }
+
+  CHECK_AND_INC_MEM_OP_STATS(destImpl, Allocs);
+  const auto alignedSize = sizeAlign(size);
+  destImpl->reserve(alignedSize);
+  DEBUG_RECORD_ALLOC(destImpl, buffer, size);
+
+  CHECK_AND_INC_MEM_OP_STATS(this, Frees);
+  DEBUG_RECORD_FREE(buffer, size);
+  release(alignedSize);
+
+  return true;
+}
+
 void MemoryPoolImpl::allocateNonContiguous(
     MachinePageCount numPages,
     Allocation& out,
     MachinePageCount minSizeClass) {
-  CHECK_AND_INC_MEM_OP_STATS(Allocs);
+  CHECK_AND_INC_MEM_OP_STATS(this, Allocs);
   if (!out.empty()) {
     INC_MEM_OP_STATS(Frees);
   }
@@ -615,21 +678,22 @@ void MemoryPoolImpl::allocateNonContiguous(
           },
           minSizeClass)) {
     VELOX_CHECK(out.empty());
-    handleAllocationFailure(fmt::format(
-        "{} failed with {} pages from {} {}",
-        __FUNCTION__,
-        numPages,
-        toString(),
-        allocator_->getAndClearFailureMessage()));
-  }
-  DEBUG_RECORD_ALLOC(out);
+    handleAllocationFailure(
+        fmt::format(
+            "{} failed with {} pages from {} {}",
+            __FUNCTION__,
+            numPages,
+            toString(),
+            allocator_->getAndClearFailureMessage()));
+  }
+  DEBUG_RECORD_ALLOC(this, out);
   VELOX_CHECK(!out.empty());
   VELOX_CHECK_NULL(out.pool());
   out.setPool(this);
 }
 
 void MemoryPoolImpl::freeNonContiguous(Allocation& allocation) {
-  CHECK_AND_INC_MEM_OP_STATS(Frees);
+  CHECK_AND_INC_MEM_OP_STATS(this, Frees);
   DEBUG_RECORD_FREE(allocation);
   const int64_t freedBytes = allocator_->freeNonContiguous(allocation);
   VELOX_CHECK(allocation.empty());
@@ -648,7 +712,7 @@ void MemoryPoolImpl::allocateContiguous(
     MachinePageCount numPages,
     ContiguousAllocation& out,
     MachinePageCount maxPages) {
-  CHECK_AND_INC_MEM_OP_STATS(Allocs);
+  CHECK_AND_INC_MEM_OP_STATS(this, Allocs);
   if (!out.empty()) {
     INC_MEM_OP_STATS(Frees);
   }
@@ -667,21 +731,22 @@ void MemoryPoolImpl::allocateContiguous(
           },
           maxPages)) {
     VELOX_CHECK(out.empty());
-    handleAllocationFailure(fmt::format(
-        "{} failed with {} pages from {} {}",
-        __FUNCTION__,
-        numPages,
-        toString(),
-        allocator_->getAndClearFailureMessage()));
-  }
-  DEBUG_RECORD_ALLOC(out);
+    handleAllocationFailure(
+        fmt::format(
+            "{} failed with {} pages from {} {}",
+            __FUNCTION__,
+            numPages,
+            toString(),
+            allocator_->getAndClearFailureMessage()));
+  }
+  DEBUG_RECORD_ALLOC(this, out);
   VELOX_CHECK(!out.empty());
   VELOX_CHECK_NULL(out.pool());
   out.setPool(this);
 }
 
 void MemoryPoolImpl::freeContiguous(ContiguousAllocation& allocation) {
-  CHECK_AND_INC_MEM_OP_STATS(Frees);
+  CHECK_AND_INC_MEM_OP_STATS(this, Frees);
   const int64_t bytesToFree = allocation.size();
   DEBUG_RECORD_FREE(allocation);
   allocator_->freeContiguous(allocation);
@@ -700,12 +765,13 @@ void MemoryPoolImpl::growContiguous(
               release(allocBytes);
             }
           })) {
-    handleAllocationFailure(fmt::format(
-        "{} failed with {} pages from {} {}",
-        __FUNCTION__,
-        increment,
-        toString(),
-        allocator_->getAndClearFailureMessage()));
+    handleAllocationFailure(
+        fmt::format(
+            "{} failed with {} pages from {} {}",
+            __FUNCTION__,
+            increment,
+            toString(),
+            allocator_->getAndClearFailureMessage()));
   }
   if (FOLLY_UNLIKELY(debugEnabled())) {
     recordGrowDbg(allocation.data(), allocation.size());
@@ -775,7 +841,7 @@ std::shared_ptr<MemoryPool> MemoryPoolImpl::genChild(
 }
 
 bool MemoryPoolImpl::maybeReserve(uint64_t increment) {
-  CHECK_AND_INC_MEM_OP_STATS(Reserves);
+  CHECK_AND_INC_MEM_OP_STATS(this, Reserves);
   TestValue::adjust(
       "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve", this);
   // TODO: make this a configurable memory pool option.
@@ -881,9 +947,16 @@ void MemoryPoolImpl::growCapacity(MemoryPool* requestor, uint64_t size) {
   VELOX_CHECK(requestor->isLeaf());
   ++numCapacityGrowths_;
 
-  {
+  try {
     MemoryPoolArbitrationSection arbitrationSection(requestor);
     arbitrator_->growCapacity(this, size);
+  } catch (const VeloxRuntimeError& veloxError) {
+    if (FOLLY_UNLIKELY(
+            debugEnabled() &&
+            veloxError.errorCode() == error_code::kMemCapExceeded)) {
+      std::rethrow_exception(wrapExceptionDbg(veloxError));
+    }
+    throw;
   }
   // The memory pool might have been aborted during the time it leaves the
   // arbitration no matter the arbitration succeed or not.
@@ -923,7 +996,7 @@ void MemoryPoolImpl::incrementReservationLocked(uint64_t bytes) {
 }
 
 void MemoryPoolImpl::release() {
-  CHECK_AND_INC_MEM_OP_STATS(Releases);
+  CHECK_AND_INC_MEM_OP_STATS(this, Releases);
   release(0, true);
 }
 
@@ -980,6 +1053,21 @@ void MemoryPoolImpl::decrementReservation(uint64_t size) noexcept {
   sanityCheckLocked();
 }
 
+std::string MemoryPoolImpl::toString(bool detail) const {
+  std::string result;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    result = toStringLocked();
+  }
+  if (detail) {
+    result += "\n" + treeMemoryUsage();
+  }
+  if (FOLLY_UNLIKELY(debugEnabled())) {
+    result += "\n" + dumpRecordsDbg();
+  }
+  return result;
+}
+
 std::string MemoryPoolImpl::treeMemoryUsage(bool skipEmptyPool) const {
   if (parent_ != nullptr) {
     return parent_->treeMemoryUsage(skipEmptyPool);
@@ -1208,10 +1296,7 @@ void MemoryPoolImpl::recordAllocDbg(const void* addr, uint64_t size) {
       debugWarnThresholdExceeded_) {
     return;
   }
-  const auto usedBytes = [this]() -> int64_t {
-    std::lock_guard<std::mutex> l(mutex_);
-    return reservedBytes();
-  }();
+  const auto usedBytes = reservedBytes();
   if (usedBytes >= debugOptions_->debugPoolWarnThresholdBytes) {
     debugWarnThresholdExceeded_ = true;
     VELOX_MEM_LOG(WARNING) << fmt::format(
@@ -1225,7 +1310,7 @@ void MemoryPoolImpl::recordAllocDbg(const void* addr, uint64_t size) {
         succinctBytes(size),
         succinctBytes(usedBytes),
         it->second.callStack.toString(),
-        dumpRecordsDbg());
+        dumpRecordsDbgLocked());
   }
 }
 
@@ -1259,16 +1344,17 @@ void MemoryPoolImpl::recordFreeDbg(const void* addr, uint64_t size) {
   const auto allocRecord = allocResult->second;
   if (allocRecord.size != size) {
     const auto freeStackTrace = process::StackTrace().toString();
-    VELOX_FAIL(fmt::format(
-        "[MemoryPool] Trying to free {} bytes on an allocation of {} bytes.\n"
-        "======== Allocation Stack ========\n"
-        "{}\n"
-        "============ Free Stack ==========\n"
-        "{}\n",
-        size,
-        allocRecord.size,
-        allocRecord.callStack.toString(),
-        freeStackTrace));
+    VELOX_FAIL(
+        fmt::format(
+            "[MemoryPool] Trying to free {} bytes on an allocation of {} bytes.\n"
+            "======== Allocation Stack ========\n"
+            "{}\n"
+            "============ Free Stack ==========\n"
+            "{}\n",
+            size,
+            allocRecord.size,
+            allocRecord.callStack.toString(),
+            freeStackTrace));
   }
   debugAllocRecords_.erase(addrUint64);
 }
@@ -1308,16 +1394,79 @@ void MemoryPoolImpl::leakCheckDbg() {
   if (debugAllocRecords_.empty()) {
     return;
   }
-  VELOX_FAIL(fmt::format(
-      "[MemoryPool] Leak check failed for '{}' pool - {}",
-      name_,
-      dumpRecordsDbg()));
+  VELOX_FAIL(
+      fmt::format(
+          "[MemoryPool] Leak check failed for '{}' pool - {}",
+          name_,
+          dumpRecordsDbg()));
+}
+
+void MemoryPoolImpl::treeAllocationRecordsDbg(
+    std::vector<MemoryPoolDump>& poolDumps) const {
+  VELOX_CHECK(debugEnabled());
+  {
+    std::lock_guard<std::mutex> debugAllocLock(debugAllocMutex_);
+    if (!debugAllocRecords_.empty()) {
+      MemoryPoolDump dump{
+          .dumpedRecords = fmt::format(
+              "Memory pool '{}' - {}", name(), dumpRecordsDbgLocked()),
+          .bytes = reservedBytes(),
+      };
+      poolDumps.emplace_back(std::move(dump));
+    }
+  }
+  if (isLeaf()) {
+    return;
+  }
+  visitChildren([&poolDumps](MemoryPool* pool) {
+    toImpl(pool)->treeAllocationRecordsDbg(poolDumps);
+    return true;
+  });
 }
 
-std::string MemoryPoolImpl::dumpRecordsDbg() {
+std::exception_ptr MemoryPoolImpl::wrapExceptionDbg(
+    const VeloxRuntimeError& veloxError) const {
+  VELOX_CHECK(debugEnabled());
+  VELOX_CHECK(isRoot());
+  std::vector<MemoryPoolDump> poolAllocationsSorted;
+  treeAllocationRecordsDbg(poolAllocationsSorted);
+  std::stringstream oss;
+  if (poolAllocationsSorted.empty()) {
+    oss << "No allocation records found.";
+  } else {
+    std::sort(
+        poolAllocationsSorted.begin(),
+        poolAllocationsSorted.end(),
+        [](const auto& a, const auto& b) { return a.bytes > b.bytes; });
+    for (const auto& record : poolAllocationsSorted) {
+      oss << record.dumpedRecords << "\n\n";
+    }
+  }
+  const auto wrappedMessage = fmt::format(
+      "{}\n\n"
+      "======= Current Allocations ======\n"
+      "{}",
+      veloxError.message(),
+      oss.str());
+  return std::make_exception_ptr(VeloxRuntimeError(
+      veloxError.file(),
+      veloxError.line(),
+      veloxError.function(),
+      veloxError.failingExpression(),
+      wrappedMessage,
+      veloxError.errorSource(),
+      veloxError.errorCode(),
+      veloxError.isRetriable(),
+      veloxError.exceptionName()));
+}
+
+std::string MemoryPoolImpl::dumpRecordsDbgLocked() const {
   VELOX_CHECK(debugEnabled());
   std::stringstream oss;
-  oss << fmt::format("Found {} allocations:\n", debugAllocRecords_.size());
+  oss << fmt::format(
+      "Found {} allocations with {} total size:\n",
+      debugAllocRecords_.size(),
+      succinctBytes(reservedBytes()));
   struct AllocationStats {
     uint64_t size{0};
     uint64_t numAllocations{0};
diff --git a/velox/common/memory/MemoryPool.h b/velox/common/memory/MemoryPool.h
index 601f3ed272b..a24edfbb4b7 100644
--- a/velox/common/memory/MemoryPool.h
+++ b/velox/common/memory/MemoryPool.h
@@ -29,8 +29,8 @@
 #include "velox/common/memory/MemoryArbitrator.h"
 
 DECLARE_bool(velox_memory_leak_check_enabled);
-DECLARE_bool(velox_memory_pool_debug_enabled);
 DECLARE_bool(velox_memory_pool_capacity_transfer_across_tasks);
+DECLARE_bool(velox_enable_inplace_realloc);
 
 namespace facebook::velox::exec {
 class ParallelMemoryReclaimer;
@@ -42,6 +42,9 @@ class MemoryManager;
 
 constexpr int64_t kMaxMemory = std::numeric_limits<int64_t>::max();
 
+template <typename T>
+class StlAllocator;
+
 /// This class provides the memory allocation interfaces for a query execution.
 /// Each query execution entity creates a dedicated memory pool object. The
 /// memory pool objects from a query are organized as a tree with four levels
@@ -91,6 +94,9 @@ constexpr int64_t kMaxMemory = std::numeric_limits<int64_t>::max();
 /// also provides memory usage accounting.
 class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
  public:
+  template <typename T>
+  using TStlAllocator = StlAllocator<T>;
+
   /// Defines the kinds of a memory pool.
   enum class Kind {
     /// The leaf memory pool is used for memory allocation. User can allocate
@@ -246,6 +252,13 @@ class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
   /// Frees an allocated buffer.
   virtual void free(void* p, int64_t size) = 0;
 
+  /// Transfer the ownership of memory at 'buffer' for 'size' bytes to the
+  /// memory pool 'dest'. Returns true if the transfer succeeds.
+  virtual bool
+  transferTo(MemoryPool* /*dest*/, void* /*buffer*/, uint64_t /*size*/) {
+    return false;
+  }
+
   /// Allocates one or more runs that add up to at least 'numPages', with the
   /// smallest run being at least 'minSizeClass' pages. 'minSizeClass' must be
   /// <= the size of the largest size class. The new memory is returned in 'out'
@@ -610,6 +623,8 @@ class MemoryPoolImpl : public MemoryPool {
 
   void free(void* p, int64_t size) override;
 
+  bool transferTo(MemoryPool* dest, void* buffer, uint64_t size) override;
+
   void allocateNonContiguous(
       MachinePageCount numPages,
       Allocation& out,
@@ -673,17 +688,7 @@ class MemoryPoolImpl : public MemoryPool {
 
   void setDestructionCallback(const DestructionCallback& callback);
 
-  std::string toString(bool detail = false) const override {
-    std::string result;
-    {
-      std::lock_guard<std::mutex> l(mutex_);
-      result = toStringLocked();
-    }
-    if (detail) {
-      result += "\n" + treeMemoryUsage();
-    }
-    return result;
-  }
+  std::string toString(bool detail = false) const override;
 
   /// Detailed debug pool state printout by traversing the pool structure from
   /// the root memory pool.
@@ -779,8 +784,7 @@ class MemoryPoolImpl : public MemoryPool {
   }
 
   FOLLY_ALWAYS_INLINE int64_t sizeAlign(int64_t size) const {
-    const auto remainder = size & (alignment_ - 1);
-    return (remainder == 0) ? size : (size + alignment_ - remainder);
+    return (size + alignment_ - 1) & ~(alignment_ - 1);
   }
 
   // Returns a rounded up delta based on adding 'delta' to 'size'. Adding the
@@ -1003,9 +1007,32 @@ class MemoryPoolImpl : public MemoryPool {
   // pool is enabled.
   void leakCheckDbg();
 
+  // Holds formatted string of dumped allocation records for a leaf memory pool,
+  // along with the total pool size in bytes.
+  struct MemoryPoolDump {
+    std::string dumpedRecords;
+    int64_t bytes;
+  };
+
+  // Recursively collects 'MemoryPoolDump' records for this memory pool and
+  // all its descendants in the tree. Called during memory capacity-exceeded
+  // exceptions to extend the error message with additional debug information.
+  void treeAllocationRecordsDbg(std::vector<MemoryPoolDump>& poolDumps) const;
+
+  // Wraps the message of a memory capacity exceeded exception with debug
+  // allocation records from all memory pools in the subtree. This function is
+  // called from the root memory pool.
+  std::exception_ptr wrapExceptionDbg(
+      const VeloxRuntimeError& veloxError) const;
+
   // Dump the recorded call sites of the memory allocations in
   // 'debugAllocRecords_' to the string.
-  std::string dumpRecordsDbg();
+  std::string dumpRecordsDbgLocked() const;
+
+  std::string dumpRecordsDbg() const {
+    std::lock_guard<std::mutex> l(debugAllocMutex_);
+    return dumpRecordsDbgLocked();
+  }
 
   void handleAllocationFailure(const std::string& failureMessage);
 
@@ -1070,7 +1097,7 @@ class MemoryPoolImpl : public MemoryPool {
   std::atomic_uint64_t numCapacityGrowths_{0};
 
   // Mutex for 'debugAllocRecords_'.
-  std::mutex debugAllocMutex_;
+  mutable std::mutex debugAllocMutex_;
 
   // Map from address to 'AllocationRecord'.
   std::unordered_map<uint64_t, AllocationRecord> debugAllocRecords_;
@@ -1084,25 +1111,29 @@ template <typename T>
 class StlAllocator {
  public:
   typedef T value_type;
-  MemoryPool& pool;
+  MemoryPool* pool;
 
-  /* implicit */ StlAllocator(MemoryPool& pool) : pool{pool} {}
+  /* implicit */ StlAllocator(MemoryPool& pool) : pool{&pool} {}
+
+  explicit StlAllocator(MemoryPool* pool) : pool{pool} {
+    VELOX_CHECK_NOT_NULL(pool);
+  }
 
   template <typename U>
   /* implicit */ StlAllocator(const StlAllocator<U>& a) : pool{a.pool} {}
 
   T* allocate(size_t n) {
-    return static_cast<T*>(pool.allocate(checkedMultiply(n, sizeof(T))));
+    return static_cast<T*>(pool->allocate(checkedMultiply(n, sizeof(T))));
   }
 
   void deallocate(T* p, size_t n) {
-    pool.free(p, checkedMultiply(n, sizeof(T)));
+    pool->free(p, checkedMultiply(n, sizeof(T)));
   }
 
   template <typename T1>
   bool operator==(const StlAllocator<T1>& rhs) const {
     if constexpr (std::is_same_v<T, T1>) {
-      return &this->pool == &rhs.pool;
+      return this->pool == rhs.pool;
     }
     return false;
   }
diff --git a/velox/common/memory/MmapAllocator.cpp b/velox/common/memory/MmapAllocator.cpp
index 178ed8b7a50..23676255267 100644
--- a/velox/common/memory/MmapAllocator.cpp
+++ b/velox/common/memory/MmapAllocator.cpp
@@ -33,9 +33,11 @@ MmapAllocator::MmapAllocator(const Options& options)
           maxMallocBytes_ == 0
               ? 0
               : options.capacity * options.smallAllocationReservePct / 100),
-      capacity_(bits::roundUp(
-          AllocationTraits::numPages(options.capacity - mallocReservedBytes_),
-          64 * sizeClassSizes_.back())) {
+      capacity_(
+          bits::roundUp(
+              AllocationTraits::numPages(
+                  options.capacity - mallocReservedBytes_),
+              64 * sizeClassSizes_.back())) {
   for (const auto& size : sizeClassSizes_) {
     sizeClasses_.push_back(std::make_unique<SizeClass>(capacity_ / size, size));
   }
@@ -675,8 +677,7 @@ bool MmapAllocator::SizeClass::allocateLocked(
 
 namespace {
 bool isAllZero(xsimd::batch<uint64_t> bits) {
-  return simd::allSetBitMask<uint64_t>() ==
-      simd::toBitMask(bits == xsimd::broadcast<uint64_t>(0));
+  return simd::all(bits == xsimd::broadcast<uint64_t>(0));
 }
 } // namespace
 
diff --git a/velox/common/memory/MmapAllocator.h b/velox/common/memory/MmapAllocator.h
index f771db0071d..2568ca45863 100644
--- a/velox/common/memory/MmapAllocator.h
+++ b/velox/common/memory/MmapAllocator.h
@@ -51,37 +51,6 @@ using ClassPageCount = int32_t;
 /// malloc.
 class MmapAllocator : public MemoryAllocator {
  public:
-  struct Options {
-    ///  Capacity in bytes, default unlimited.
-    uint64_t capacity{kMaxMemory};
-
-    int32_t largestSizeClass{256};
-
-    /// If set true, allocations larger than largest size class size will be
-    /// delegated to ManagedMmapArena. Otherwise a system mmap call will be
-    /// issued for each such allocation.
-    bool useMmapArena = false;
-
-    /// Used to determine MmapArena capacity. The ratio represents system memory
-    /// capacity to single MmapArena capacity ratio.
-    int32_t mmapArenaCapacityRatio = 10;
-
-    /// If not zero, reserve 'smallAllocationReservePct'% of space from
-    /// 'capacity' for ad hoc small allocations. And those allocations are
-    /// delegated to std::malloc.
-    ///
-    /// NOTE: if 'maxMallocBytes' is 0, this value will be disregarded.
-    uint32_t smallAllocationReservePct = 0;
-
-    /// The allocation threshold less than which an allocation is delegated to
-    /// std::malloc().
-    ///
-    /// NOTE: if it is zero, then we don't delegate any allocation std::malloc,
-    /// and 'smallAllocationReservePct' will be automatically set to 0
-    /// disregarding any passed in value.
-    int32_t maxMallocBytes = 3072;
-  };
-
   explicit MmapAllocator(const Options& options);
 
   ~MmapAllocator();
diff --git a/velox/common/memory/RawVector.cpp b/velox/common/memory/RawVector.cpp
index 2463d8d3da3..c1ec915d094 100644
--- a/velox/common/memory/RawVector.cpp
+++ b/velox/common/memory/RawVector.cpp
@@ -24,7 +24,7 @@ namespace {
 raw_vector<int32_t> iotaData;
 
 bool initializeIota() {
-  iotaData.resize(10000);
+  iotaData.resize(1'000'000);
   iotaData.resize(iotaData.capacity());
   std::iota(iotaData.begin(), iotaData.end(), 0);
   return true;
diff --git a/velox/common/memory/RawVector.h b/velox/common/memory/RawVector.h
index a55c57c17ee..686edbf56f9 100644
--- a/velox/common/memory/RawVector.h
+++ b/velox/common/memory/RawVector.h
@@ -135,6 +135,22 @@ class raw_vector {
     size_ = 0;
   }
 
+  /// Releases unused capacity. If empty, frees all memory.
+  void shrink_to_fit() {
+    if (size_ == 0) {
+      free();
+      capacity_ = 0;
+      return;
+    }
+    if (calculateCapacity(size_) < capacity_) {
+      auto* newData = allocateData(size_);
+      memcpy(newData, data_, size_ * sizeof(T));
+      free();
+      data_ = newData;
+      capacity_ = calculateCapacity(size_);
+    }
+  }
+
   void resize(int64_t size) {
     if (LIKELY(size <= capacity_)) {
       size_ = size;
@@ -212,9 +228,12 @@ class raw_vector {
     // Clear the word below the pointer so that we do not get read of
     // uninitialized when reading a partial word that extends below
     // the pointer.
+    // Suppress GCC14 warning. "error: writing 8 bytes into a region of size 0"
+    VELOX_SUPPRESS_STRINGOP_OVERFLOW_WARNING
     *reinterpret_cast<int64_t*>(
         reinterpret_cast<uint8_t*>(getDataFromBuffer(buffer)) -
         sizeof(int64_t)) = 0;
+    VELOX_UNSUPPRESS_STRINGOP_OVERFLOW_WARNING
     return getDataFromBuffer(buffer);
   }
 
diff --git a/velox/common/memory/Scratch.h b/velox/common/memory/Scratch.h
index dcde26e90d9..bed226a0f94 100644
--- a/velox/common/memory/Scratch.h
+++ b/velox/common/memory/Scratch.h
@@ -79,14 +79,17 @@ class Scratch {
     // stringop-overflow warning when 'newCapacity' is 0.
     folly::assume(capacity_ >= 0);
     if (newCapacity > capacity_) {
-      Item* newItems =
-          reinterpret_cast<Item*>(::malloc(sizeof(Item) * newCapacity));
+      auto* newItems =
+          reinterpret_cast<uint8_t*>(::malloc(sizeof(Item) * newCapacity));
       if (fill_ > 0) {
         ::memcpy(newItems, items_, fill_ * sizeof(Item));
       }
-      ::memset(newItems + fill_, 0, (newCapacity - fill_) * sizeof(Item));
+      ::memset(
+          newItems + fill_ * sizeof(Item),
+          0,
+          (newCapacity - fill_) * sizeof(Item));
       ::free(items_);
-      items_ = newItems;
+      items_ = reinterpret_cast<Item*>(newItems);
       capacity_ = newCapacity;
     }
     fill_ = std::min(fill_, newCapacity);
diff --git a/velox/common/memory/SharedArbitrator.cpp b/velox/common/memory/SharedArbitrator.cpp
index e726d76222e..bd98f4e9f4d 100644
--- a/velox/common/memory/SharedArbitrator.cpp
+++ b/velox/common/memory/SharedArbitrator.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/common/memory/SharedArbitrator.h"
+#include <folly/system/HardwareConcurrency.h>
 #include <folly/system/ThreadName.h>
 #include <pthread.h>
 #include <mutex>
@@ -58,25 +59,28 @@ namespace {
   }
 
 #define MEM_POOL_CAP_EXCEEDED(errorMessage, requestPool) \
-  VELOX_MEM_POOL_CAP_EXCEEDED(fmt::format(               \
-      "Exceeded memory pool capacity. {}\n{}\n\n{}",     \
-      errorMessage,                                      \
-      this->toString(),                                  \
-      requestPool->toString(true)));
+  VELOX_MEM_POOL_CAP_EXCEEDED(                           \
+      fmt::format(                                       \
+          "Exceeded memory pool capacity. {}\n{}\n\n{}", \
+          errorMessage,                                  \
+          this->toString(),                              \
+          requestPool->toString(true)));
 
 #define LOCAL_MEM_ARBITRATION_FAILED(errorMessage, requestPool) \
-  VELOX_MEM_ARBITRATION_FAILED(fmt::format(                     \
-      "Local arbitration failure. {}\n{}\n\n{}",                \
-      errorMessage,                                             \
-      this->toString(),                                         \
-      requestPool->toString(true)));
+  VELOX_MEM_ARBITRATION_FAILED(                                 \
+      fmt::format(                                              \
+          "Local arbitration failure. {}\n{}\n\n{}",            \
+          errorMessage,                                         \
+          this->toString(),                                     \
+          requestPool->toString(true)));
 
 #define GLOBAL_MEM_ARBITRATION_FAILED(errorMessage, requestPool) \
-  VELOX_MEM_ARBITRATION_FAILED(fmt::format(                      \
-      "Global arbitration failure. {}\n{}\n\n{}",                \
-      errorMessage,                                              \
-      this->toString(),                                          \
-      requestPool->toString(true)));
+  VELOX_MEM_ARBITRATION_FAILED(                                  \
+      fmt::format(                                               \
+          "Global arbitration failure. {}\n{}\n\n{}",            \
+          errorMessage,                                          \
+          this->toString(),                                      \
+          requestPool->toString(true)));
 
 template <typename T>
 T getConfig(
@@ -126,10 +130,11 @@ uint64_t SharedArbitrator::ExtraConfig::memoryPoolReservedCapacity(
 uint64_t SharedArbitrator::ExtraConfig::maxMemoryArbitrationTimeNs(
     const std::unordered_map<std::string, std::string>& configs) {
   return std::chrono::duration_cast<std::chrono::nanoseconds>(
-             config::toDuration(getConfig<std::string>(
-                 configs,
-                 kMaxMemoryArbitrationTime,
-                 std::string(kDefaultMaxMemoryArbitrationTime))))
+             config::toDuration(
+                 getConfig<std::string>(
+                     configs,
+                     kMaxMemoryArbitrationTime,
+                     std::string(kDefaultMaxMemoryArbitrationTime))))
       .count();
 }
 
@@ -292,8 +297,7 @@ SharedArbitrator::SharedArbitrator(const Config& config)
       "memoryReclaimThreadsHwMultiplier_ needs to be positive");
 
   const uint64_t numReclaimThreads = std::max<size_t>(
-      1,
-      std::thread::hardware_concurrency() * memoryReclaimThreadsHwMultiplier_);
+      1, folly::available_concurrency() * memoryReclaimThreadsHwMultiplier_);
   memoryReclaimExecutor_ = std::make_unique<folly::CPUThreadPoolExecutor>(
       numReclaimThreads,
       std::make_shared<folly::NamedThreadFactory>("MemoryReclaim"));
@@ -539,14 +543,14 @@ void SharedArbitrator::addPool(const std::shared_ptr<MemoryPool>& pool) {
 }
 
 void SharedArbitrator::removePool(MemoryPool* pool) {
-  VELOX_CHECK_EQ(pool->reservedBytes(), 0);
+  VELOX_CHECK_EQ(pool->reservedBytes(), 0, "{}", pool->name());
   const uint64_t freedBytes = shrinkPool(pool, 0);
-  VELOX_CHECK_EQ(pool->capacity(), 0);
+  VELOX_CHECK_EQ(pool->capacity(), 0, "{}", pool->name());
   freeCapacity(freedBytes);
 
   std::unique_lock guard{participantLock_};
   const auto ret = participants_.erase(pool->name());
-  VELOX_CHECK_EQ(ret, 1);
+  VELOX_CHECK_EQ(ret, 1, "{}", pool->name());
 }
 
 std::vector<ArbitrationCandidate> SharedArbitrator::getCandidates(
@@ -893,13 +897,16 @@ void SharedArbitrator::growCapacity(ArbitrationOperation& op) {
   RETURN_IF_TRUE(maybeGrowFromSelf(op));
 
   if (!ensureCapacity(op)) {
+    const auto maxCapacity = op.participant()->maxCapacity();
     MEM_POOL_CAP_EXCEEDED(
         fmt::format(
-            "Can't grow {} capacity with {}. This will exceed its max capacity "
+            "Can't grow {} capacity with {}. This will exceed its {} "
             "{}, current capacity {}.",
             op.participant()->name(),
             succinctBytes(op.requestBytes()),
-            succinctBytes(op.participant()->maxCapacity()),
+            capacity_ < maxCapacity ? "arbitrator capacity"
+                                    : "memory pool capacity",
+            succinctBytes(std::min(capacity_, maxCapacity)),
             succinctBytes(op.participant()->capacity())),
         op.participant()->pool());
   }
@@ -1139,10 +1146,11 @@ void SharedArbitrator::checkIfAborted(ArbitrationOperation& op) {
 
 void SharedArbitrator::checkIfTimeout(ArbitrationOperation& op) {
   if (FOLLY_UNLIKELY(op.hasTimeout())) {
-    VELOX_MEM_ARBITRATION_TIMEOUT(fmt::format(
-        "Memory arbitration timed out on memory pool: {} after running {}",
-        op.participant()->name(),
-        succinctNanos(op.executionTimeNs())));
+    VELOX_MEM_ARBITRATION_TIMEOUT(
+        fmt::format(
+            "Memory arbitration timed out on memory pool: {} after running {}",
+            op.participant()->name(),
+            succinctNanos(op.executionTimeNs())));
   }
 }
 
@@ -1354,14 +1362,15 @@ uint64_t SharedArbitrator::reclaimUsedMemoryByAbort(bool force) {
   // after abort operation.
   const auto currentCapacity = victim.participant->pool()->capacity();
   try {
-    VELOX_MEM_POOL_ABORTED(fmt::format(
-        "Memory pool aborted to reclaim used memory, current capacity {}, "
-        "requesting capacity from global arbitration {} memory pool "
-        "stats:\n{}\n{}",
-        succinctBytes(currentCapacity),
-        succinctBytes(victim.participant->globalArbitrationGrowCapacity()),
-        victim.participant->pool()->toString(),
-        victim.participant->pool()->treeMemoryUsage()));
+    VELOX_MEM_POOL_ABORTED(
+        fmt::format(
+            "Memory pool aborted to reclaim used memory, current capacity {}, "
+            "requesting capacity from global arbitration {} memory pool "
+            "stats:\n{}\n{}",
+            succinctBytes(currentCapacity),
+            succinctBytes(victim.participant->globalArbitrationGrowCapacity()),
+            victim.participant->pool()->toString(),
+            victim.participant->pool()->treeMemoryUsage()));
   } catch (VeloxRuntimeError&) {
     abort(victim.participant, std::current_exception());
     return currentCapacity;
@@ -1395,7 +1404,6 @@ uint64_t SharedArbitrator::reclaim(
   if (participant->aborted()) {
     removeGlobalArbitrationWaiter(participant->id());
   }
-  freeCapacity(reclaimedBytes);
 
   updateMemoryReclaimStats(
       reclaimedBytes, reclaimTimeNs, localArbitration, stats);
@@ -1407,6 +1415,8 @@ uint64_t SharedArbitrator::reclaim(
                       << " stats " << succinctBytes(stats.reclaimedBytes)
                       << " numNonReclaimableAttempts "
                       << stats.numNonReclaimableAttempts;
+
+  freeCapacity(reclaimedBytes);
   if (reclaimedBytes == 0) {
     FB_LOG_EVERY_MS(WARNING, 1'000) << fmt::format(
         "Nothing reclaimed from memory pool {} with reclaim target {},  memory pool stats:\n{}\n{}",
diff --git a/velox/common/memory/SharedArbitrator.h b/velox/common/memory/SharedArbitrator.h
index 16efd247110..e9ab03e6b5b 100644
--- a/velox/common/memory/SharedArbitrator.h
+++ b/velox/common/memory/SharedArbitrator.h
@@ -284,17 +284,17 @@ class SharedArbitrator : public memory::MemoryArbitrator {
 
   /// Operator level runtime stats reported for an arbitration operation
   /// execution.
-  static inline const std::string kMemoryArbitrationWallNanos{
+  static constexpr std::string_view kMemoryArbitrationWallNanos{
       "memoryArbitrationWallNanos"};
-  static inline const std::string kLocalArbitrationCount{
+  static constexpr std::string_view kLocalArbitrationCount{
       "localArbitrationCount"};
-  static inline const std::string kLocalArbitrationWaitWallNanos{
+  static constexpr std::string_view kLocalArbitrationWaitWallNanos{
       "localArbitrationWaitWallNanos"};
-  static inline const std::string kLocalArbitrationExecutionWallNanos{
+  static constexpr std::string_view kLocalArbitrationExecutionWallNanos{
       "localArbitrationExecutionWallNanos"};
-  static inline const std::string kGlobalArbitrationWaitCount{
+  static constexpr std::string_view kGlobalArbitrationWaitCount{
       "globalArbitrationWaitCount"};
-  static inline const std::string kGlobalArbitrationWaitWallNanos{
+  static constexpr std::string_view kGlobalArbitrationWaitWallNanos{
       "globalArbitrationWaitWallNanos"};
 
  private:
diff --git a/velox/common/memory/StreamArena.cpp b/velox/common/memory/StreamArena.cpp
index 15b74ea2a96..a9b50097686 100644
--- a/velox/common/memory/StreamArena.cpp
+++ b/velox/common/memory/StreamArena.cpp
@@ -43,11 +43,12 @@ void StreamArena::newRange(
   const int32_t numRuns = allocation_.numRuns();
   if (currentRun_ >= numRuns) {
     if (numRuns > 0) {
+      // No need to push an empty Allocation into 'allocations_'.
       allocations_.push_back(
           std::make_unique<memory::Allocation>(std::move(allocation_)));
     }
     pool_->allocateNonContiguous(
-        std::max(allocationQuantum_, numPages), allocation_);
+        std::max(kAllocationQuantum, numPages), allocation_);
     currentRun_ = 0;
     currentOffset_ = 0;
     size_ += allocation_.byteSize();
@@ -61,7 +62,7 @@ void StreamArena::newRange(
   VELOX_DCHECK_LE(currentOffset_, run.numBytes());
   if (currentOffset_ == run.numBytes()) {
     ++currentRun_;
-    ++currentOffset_ = 0;
+    currentOffset_ = 0;
   }
 }
 
diff --git a/velox/common/memory/StreamArena.h b/velox/common/memory/StreamArena.h
index b00b9dff950..fcf09e855c9 100644
--- a/velox/common/memory/StreamArena.h
+++ b/velox/common/memory/StreamArena.h
@@ -14,6 +14,10 @@
  * limitations under the License.
  */
 #pragma once
+
+#include <memory>
+#include <vector>
+
 #include "velox/common/memory/Memory.h"
 
 namespace facebook::velox {
@@ -30,20 +34,18 @@ class StreamArena {
 
   virtual ~StreamArena() = default;
 
-  /// Sets range to the request 'bytes' of writable memory owned by
-  /// 'this'.  We allocate non-contiguous memory to store range bytes
-  /// if requested 'bytes' is equal or less than the largest class
-  /// page size. Otherwise, we allocate from contiguous
-  /// memory. 'range' is set to point to the allocated memory. If
-  /// 'lastRange' is non-nullptr, it is the last range of the stream
-  /// to which we are adding the new range. 'lastRange' is nullptr if
-  /// adding the first range to a stream. The memory is stays owned by
-  /// 'this' in all cases. Used by HashStringAllocator when extending
-  /// a multipart entry. The previously last part has its last 8 bytes
-  /// moved to the next part and gets a pointer to the next part as
-  /// its last 8 bytes. When extending, we need to update the entry so
-  /// that the next pointer is not seen when reading the content and
-  /// is also not counted in the payload size of the multipart entry.
+  /// Sets range to the request 'bytes' of writable memory owned by 'this'. We
+  /// allocate non-contiguous memory to store range bytes if requested 'bytes'
+  /// is equal or less than the largest class page size. Otherwise, we allocate
+  /// from contiguous memory. 'range' is set to point to the allocated memory.
+  /// If 'lastRange' is non-nullptr, it is the last range of the stream to which
+  /// we are adding the new range. 'lastRange' is nullptr if adding the first
+  /// range to a stream. The memory is stays owned by 'this' in all cases. Used
+  /// by HashStringAllocator when extending a multipart entry. The previously
+  /// last part has its last 8 bytes moved to the next part and gets a pointer
+  /// to the next part as its last 8 bytes. When extending, we need to update
+  /// the entry so that the next pointer is not seen when reading the content
+  /// and is also not counted in the payload size of the multipart entry.
   ///
   /// NOTE: The method does not guarantee returned 'range' has size of 'bytes',
   /// it is caller's responsibility to check.
@@ -63,13 +65,13 @@ class StreamArena {
   virtual void clear();
 
   memory::MachinePageCount testingAllocationQuantum() const {
-    return allocationQuantum_;
+    return kAllocationQuantum;
   }
 
  private:
-  memory::MemoryPool* const pool_;
+  static constexpr memory::MachinePageCount kAllocationQuantum{2};
 
-  const memory::MachinePageCount allocationQuantum_{2};
+  memory::MemoryPool* const pool_;
 
   // All non-contiguous allocations.
   std::vector<std::unique_ptr<memory::Allocation>> allocations_;
diff --git a/velox/common/memory/tests/AllocationTest.cpp b/velox/common/memory/tests/AllocationTest.cpp
index ea6d3e58115..351cb5dfcec 100644
--- a/velox/common/memory/tests/AllocationTest.cpp
+++ b/velox/common/memory/tests/AllocationTest.cpp
@@ -14,13 +14,11 @@
  * limitations under the License.
  */
 
+#include "velox/common/memory/Allocation.h"
+
 #include <gtest/gtest.h>
 
 #include "velox/common/base/tests/GTestUtils.h"
-#include "velox/common/memory/Memory.h"
-
-using namespace ::testing;
-using namespace facebook::velox::memory;
 
 namespace facebook::velox::memory {
 
@@ -105,7 +103,6 @@ TEST_F(AllocationTest, maxPageRunLimit) {
       "The number of pages to append 131070 exceeds the PageRun limit 65535");
   ASSERT_EQ(allocation.numPages(), Allocation::PageRun::kMaxPagesInRun);
   ASSERT_EQ(allocation.numRuns(), 1);
-  LOG(ERROR) << "here";
   allocation.clear();
 }
 
diff --git a/velox/common/memory/tests/ArbitrationParticipantTest.cpp b/velox/common/memory/tests/ArbitrationParticipantTest.cpp
index 148fdf773f3..fab25762ca9 100644
--- a/velox/common/memory/tests/ArbitrationParticipantTest.cpp
+++ b/velox/common/memory/tests/ArbitrationParticipantTest.cpp
@@ -21,8 +21,8 @@
 #include <deque>
 #include <vector>
 
-#include "folly/experimental/EventCount.h"
 #include "folly/futures/Barrier.h"
+#include "folly/synchronization/EventCount.h"
 
 #include "gmock/gmock-matchers.h"
 #include "velox/common/base/SuccinctPrinter.h"
@@ -33,10 +33,10 @@
 #include "velox/common/memory/Memory.h"
 #include "velox/common/memory/MemoryArbitrator.h"
 #include "velox/common/memory/SharedArbitrator.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 DECLARE_bool(velox_memory_leak_check_enabled);
 DECLARE_bool(velox_suppress_memory_capacity_exceeding_error_message);
@@ -233,11 +233,12 @@ class MockTask : public std::enable_shared_from_this<MockTask> {
       ReclaimInjectionCallback reclaimInjectCb,
       ArbitrationInjectionCallback arbitrationInjectCb) {
     root_->setReclaimer(RootMemoryReclaimer::create(shared_from_this()));
-    pool_->setReclaimer(std::make_unique<LeafMemoryReclaimer>(
-        shared_from_this(),
-        reclaimable,
-        std::move(reclaimInjectCb),
-        std::move(arbitrationInjectCb)));
+    pool_->setReclaimer(
+        std::make_unique<LeafMemoryReclaimer>(
+            shared_from_this(),
+            reclaimable,
+            std::move(reclaimInjectCb),
+            std::move(arbitrationInjectCb)));
   }
 
   const std::shared_ptr<MemoryPool>& pool() const {
diff --git a/velox/common/memory/tests/ByteStreamTest.cpp b/velox/common/memory/tests/ByteStreamTest.cpp
index 7ef7eff64b3..1ff755bc18b 100644
--- a/velox/common/memory/tests/ByteStreamTest.cpp
+++ b/velox/common/memory/tests/ByteStreamTest.cpp
@@ -19,11 +19,12 @@
 #include "velox/common/file/FileInputStream.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/memory/MmapAllocator.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 
 #include <gtest/gtest.h>
 
 using namespace facebook::velox;
+using namespace facebook::velox::common::testutil;
 using namespace facebook::velox::memory;
 
 class ByteStreamTest : public testing::Test {
@@ -248,10 +249,11 @@ TEST_F(ByteStreamTest, newRangeAllocation) {
     byteStream.startWrite(0);
     for (int i = 0; i < testData.newRangeSizes.size(); ++i) {
       const auto newRangeSize = testData.newRangeSizes[i];
-      SCOPED_TRACE(fmt::format(
-          "iteration {} allocation size {}",
-          i,
-          succinctBytes(testData.newRangeSizes[i])));
+      SCOPED_TRACE(
+          fmt::format(
+              "iteration {} allocation size {}",
+              i,
+              succinctBytes(testData.newRangeSizes[i])));
       std::string value(newRangeSize, 'a');
       byteStream.appendStringView(value);
       ASSERT_EQ(arena->size(), testData.expectedArenaAllocationSizes[i]);
@@ -456,7 +458,7 @@ class InputByteStreamTest : public ByteStreamTest,
 
   void SetUp() override {
     ByteStreamTest::SetUp();
-    tempDirPath_ = exec::test::TempDirectoryPath::create();
+    tempDirPath_ = TempDirectoryPath::create();
     fs_ = filesystems::getFileSystem(tempDirPath_->getPath(), nullptr);
   }
 
@@ -470,8 +472,9 @@ class InputByteStreamTest : public ByteStreamTest,
           fmt::format("{}/{}", tempDirPath_->getPath(), fileId_++);
       auto writeFile = fs_->openFileForWrite(filePath);
       for (auto& byteRange : byteRanges) {
-        writeFile->append(std::string_view(
-            reinterpret_cast<char*>(byteRange.buffer), byteRange.size));
+        writeFile->append(
+            std::string_view(
+                reinterpret_cast<char*>(byteRange.buffer), byteRange.size));
       }
       writeFile->close();
       return std::make_unique<common::FileInputStream>(
@@ -480,7 +483,7 @@ class InputByteStreamTest : public ByteStreamTest,
   }
 
   std::atomic_uint64_t fileId_{0};
-  std::shared_ptr<exec::test::TempDirectoryPath> tempDirPath_;
+  std::shared_ptr<TempDirectoryPath> tempDirPath_;
   std::shared_ptr<filesystems::FileSystem> fs_;
 };
 
diff --git a/velox/common/memory/tests/CMakeLists.txt b/velox/common/memory/tests/CMakeLists.txt
index bb07501386c..77ce4489f9d 100644
--- a/velox/common/memory/tests/CMakeLists.txt
+++ b/velox/common/memory/tests/CMakeLists.txt
@@ -42,7 +42,6 @@ target_link_libraries(
     velox_exec
     velox_exec_test_lib
     velox_memory
-    velox_temp_path
     velox_test_util
     velox_vector_fuzzer
     Folly::folly
@@ -69,3 +68,5 @@ if(VELOX_ENABLE_BENCHMARKS)
 
   target_link_libraries(velox_concurrent_allocation_benchmark PRIVATE velox_memory velox_time)
 endif()
+
+velox_add_library(velox_memory_test_util INTERFACE HEADERS SharedArbitratorTestUtil.h)
diff --git a/velox/common/memory/tests/FragmentationBenchmark.cpp b/velox/common/memory/tests/FragmentationBenchmark.cpp
index eb9124f2235..9d5910114c0 100644
--- a/velox/common/memory/tests/FragmentationBenchmark.cpp
+++ b/velox/common/memory/tests/FragmentationBenchmark.cpp
@@ -150,7 +150,7 @@ class FragmentationTest {
   }
 
   void initMemory(size_t sizeCap) {
-    MmapAllocator::Options options;
+    MemoryAllocator::Options options;
     options.capacity = sizeCap + (64 << 20);
     memory_ = std::make_shared<MmapAllocator>(options);
   }
diff --git a/velox/common/memory/tests/MemoryAllocatorTest.cpp b/velox/common/memory/tests/MemoryAllocatorTest.cpp
index 7b9f123f96a..1526a59ab89 100644
--- a/velox/common/memory/tests/MemoryAllocatorTest.cpp
+++ b/velox/common/memory/tests/MemoryAllocatorTest.cpp
@@ -258,8 +258,9 @@ class MemoryAllocatorTest : public testing::TestWithParam<int> {
     allocations.clear();
   }
 
-  void clearAllocations(std::vector<std::vector<std::unique_ptr<Allocation>>>&
-                            allocationsVector) {
+  void clearAllocations(
+      std::vector<std::vector<std::unique_ptr<Allocation>>>&
+          allocationsVector) {
     for (auto& allocations : allocationsVector) {
       for (auto& allocation : allocations) {
         instance_->freeNonContiguous(*allocation);
@@ -431,7 +432,7 @@ TEST_P(MemoryAllocatorTest, mmapAllocatorInit) {
     return;
   }
   {
-    MmapAllocator::Options options;
+    MemoryAllocator::Options options;
     options.capacity = kCapacityBytes;
     options.smallAllocationReservePct = 39;
     options.maxMallocBytes = 2999;
@@ -447,7 +448,7 @@ TEST_P(MemoryAllocatorTest, mmapAllocatorInit) {
     EXPECT_EQ(smallAllocationBytes, mmapAllocator->mallocReservedBytes());
   }
   {
-    MmapAllocator::Options options;
+    MemoryAllocator::Options options;
     options.capacity = kCapacityBytes;
     options.smallAllocationReservePct = 39;
     options.maxMallocBytes = 0;
@@ -461,7 +462,7 @@ TEST_P(MemoryAllocatorTest, mmapAllocatorInit) {
     EXPECT_EQ(0, mmapAllocator->mallocReservedBytes());
   }
   {
-    MmapAllocator::Options options;
+    MemoryAllocator::Options options;
     options.capacity = 64 * 256 * AllocationTraits::kPageSize - 100;
     options.smallAllocationReservePct = 10;
     options.maxMallocBytes = 3072;
@@ -831,65 +832,66 @@ TEST_P(MemoryAllocatorTest, nonContiguousFailure) {
           static_cast<uint64_t>(numNewPages),
           injectedFailure);
     }
-  } testSettings[] = {// Cap failure injection.
-                      {0, 100, MemoryAllocator::InjectedFailure::kCap},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {100, 100, MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun / 2,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {200, 100, MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun - 1,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      // Allocate failure injection.
-                      {0, 100, MemoryAllocator::InjectedFailure::kAllocate},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kAllocate},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {100, 100, MemoryAllocator::InjectedFailure::kAllocate},
-                      {Allocation::PageRun::kMaxPagesInRun / 2,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kAllocate},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kAllocate},
-                      {200, 100, MemoryAllocator::InjectedFailure::kAllocate},
-                      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kAllocate},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun - 1,
-                       MemoryAllocator::InjectedFailure::kAllocate},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kAllocate},
-                      // Madvise failure injection.
-                      {0, 100, MemoryAllocator::InjectedFailure::kMadvise},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {200, 100, MemoryAllocator::InjectedFailure::kMadvise}};
+  } testSettings[] = {
+      // Cap failure injection.
+      {0, 100, MemoryAllocator::InjectedFailure::kCap},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kCap},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kCap},
+      {100, 100, MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kCap},
+      {200, 100, MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun - 1,
+       MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kCap},
+      // Allocate failure injection.
+      {0, 100, MemoryAllocator::InjectedFailure::kAllocate},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kAllocate},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kCap},
+      {100, 100, MemoryAllocator::InjectedFailure::kAllocate},
+      {Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kAllocate},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kAllocate},
+      {200, 100, MemoryAllocator::InjectedFailure::kAllocate},
+      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kAllocate},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun - 1,
+       MemoryAllocator::InjectedFailure::kAllocate},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kAllocate},
+      // Madvise failure injection.
+      {0, 100, MemoryAllocator::InjectedFailure::kMadvise},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {200, 100, MemoryAllocator::InjectedFailure::kMadvise}};
   std::unordered_map<MemoryAllocator::InjectedFailure, std::string>
       expectedErrorMsg = {
           {MemoryAllocator::InjectedFailure::kAllocate,
@@ -1249,6 +1251,109 @@ TEST_P(MemoryAllocatorTest, allocateBytes) {
   ASSERT_TRUE(instance_->checkConsistency());
 }
 
+TEST_P(MemoryAllocatorTest, reallocateBytes) {
+  // Test grow: allocate, fill, reallocate larger, verify data preserved.
+  {
+    const uint64_t kInitialSize = 1024;
+    const uint64_t kNewSize = 4096;
+    void* p = instance_->allocateBytes(kInitialSize);
+    ASSERT_NE(nullptr, p);
+    ::memset(p, 0xAB, kInitialSize);
+
+    auto usedBefore = instance_->totalUsedBytes();
+    void* newP = instance_->reallocateBytes(p, kInitialSize, kNewSize);
+    ASSERT_NE(nullptr, newP);
+    // Verify original data is preserved.
+    for (uint64_t i = 0; i < kInitialSize; ++i) {
+      ASSERT_EQ(static_cast<uint8_t>(0xAB), static_cast<uint8_t*>(newP)[i])
+          << "at byte " << i;
+    }
+    // Verify memory accounting: usage should have increased by the delta.
+    if (!useMmap_) {
+      ASSERT_EQ(
+          usedBefore + (kNewSize - kInitialSize), instance_->totalUsedBytes());
+    }
+    instance_->freeBytes(newP, kNewSize);
+  }
+
+  // Test shrink: allocate, fill, reallocate smaller, verify data preserved.
+  {
+    const uint64_t kInitialSize = 4096;
+    const uint64_t kNewSize = 1024;
+    void* p = instance_->allocateBytes(kInitialSize);
+    ASSERT_NE(nullptr, p);
+    ::memset(p, 0xCD, kInitialSize);
+
+    void* newP = instance_->reallocateBytes(p, kInitialSize, kNewSize);
+    ASSERT_NE(nullptr, newP);
+    for (uint64_t i = 0; i < kNewSize; ++i) {
+      ASSERT_EQ(static_cast<uint8_t>(0xCD), static_cast<uint8_t*>(newP)[i])
+          << "at byte " << i;
+    }
+    instance_->freeBytes(newP, kNewSize);
+  }
+
+  // Test with nullptr input: should behave like allocateBytes.
+  {
+    const uint64_t kSize = 2048;
+    void* newP = instance_->reallocateBytes(nullptr, 0, kSize);
+    ASSERT_NE(nullptr, newP);
+    ::memset(newP, 0xEF, kSize);
+    instance_->freeBytes(newP, kSize);
+  }
+
+  // Test memory accounting after full cycle.
+  if (!useMmap_) {
+    ASSERT_EQ(0, instance_->totalUsedBytes());
+  }
+  ASSERT_TRUE(instance_->checkConsistency());
+}
+
+TEST_P(MemoryAllocatorTest, reallocateBytesWithAlignment) {
+  // Non-default alignment should fall back to allocate+memcpy+free
+  // (MallocAllocator's reallocateBytesWithoutRetry returns nullptr for
+  // non-default alignment since ::realloc() cannot guarantee it).
+  const uint64_t kInitialSize = 1024;
+  const uint64_t kNewSize = 4096;
+  const uint16_t kAlignment = MemoryAllocator::kMaxAlignment;
+  void* p = instance_->allocateBytes(kInitialSize, kAlignment);
+  ASSERT_NE(nullptr, p);
+  ASSERT_EQ(0, reinterpret_cast<uintptr_t>(p) % kAlignment);
+  ::memset(p, 0x42, kInitialSize);
+
+  void* newP =
+      instance_->reallocateBytes(p, kInitialSize, kNewSize, kAlignment);
+  ASSERT_NE(nullptr, newP);
+  ASSERT_EQ(0, reinterpret_cast<uintptr_t>(newP) % kAlignment);
+  for (uint64_t i = 0; i < kInitialSize; ++i) {
+    ASSERT_EQ(static_cast<uint8_t>(0x42), static_cast<uint8_t*>(newP)[i])
+        << "at byte " << i;
+  }
+  instance_->freeBytes(newP, kNewSize);
+  ASSERT_TRUE(instance_->checkConsistency());
+}
+
+TEST_P(MemoryAllocatorTest, reallocateBytesCapacityExceeded) {
+  if (useMmap_) {
+    // MmapAllocator has different capacity semantics; skip.
+    return;
+  }
+  // Allocate most of capacity, then try to reallocate beyond it.
+  const uint64_t kInitialSize = 1024;
+  const uint64_t kOverCapacity = kCapacityBytes + 1;
+  void* p = instance_->allocateBytes(kInitialSize);
+  ASSERT_NE(nullptr, p);
+
+  void* newP = instance_->reallocateBytes(p, kInitialSize, kOverCapacity);
+  ASSERT_EQ(nullptr, newP);
+  // Original pointer should still be valid after failed reallocation.
+  // Memory accounting should be unchanged.
+  ASSERT_EQ(kInitialSize, instance_->totalUsedBytes());
+  instance_->freeBytes(p, kInitialSize);
+  ASSERT_EQ(0, instance_->totalUsedBytes());
+  ASSERT_TRUE(instance_->checkConsistency());
+}
+
 TEST_P(MemoryAllocatorTest, allocateBytesWithAlignment) {
   struct {
     uint64_t allocateBytes;
@@ -1991,4 +2096,263 @@ TEST_F(MmapConfigTest, sizeClasses) {
   }
 }
 
+class MallocContiguousTest : public testing::TestWithParam<bool> {
+ protected:
+  static void SetUpTestCase() {
+    FLAGS_velox_memory_leak_check_enabled = true;
+  }
+
+  void SetUp() override {
+    MemoryAllocator::Options options;
+    options.capacity = kCapacityBytes;
+    options.reservationByteLimit = 0;
+    options.mallocContiguousEnabled = GetParam();
+    allocator_ = std::make_shared<MallocAllocator>(options);
+  }
+
+  std::shared_ptr<MallocAllocator> allocator_;
+};
+
+TEST_P(MallocContiguousTest, allocateAndFreeContiguous) {
+  constexpr MachinePageCount kNumPages = 16;
+  ContiguousAllocation allocation;
+  ASSERT_TRUE(allocator_->allocateContiguous(kNumPages, nullptr, allocation));
+  ASSERT_FALSE(allocation.empty());
+  ASSERT_EQ(allocation.numPages(), kNumPages);
+  ASSERT_NE(allocation.data(), nullptr);
+
+  // Verify we can write and read from the allocated memory.
+  auto* data = reinterpret_cast<int64_t*>(allocation.data());
+  for (int64_t i = 0; i < kNumPages; ++i) {
+    data[i] = i * 42;
+  }
+  for (int64_t i = 0; i < kNumPages; ++i) {
+    ASSERT_EQ(data[i], i * 42);
+  }
+
+  allocator_->freeContiguous(allocation);
+  ASSERT_TRUE(allocation.empty());
+  ASSERT_EQ(allocator_->numAllocated(), 0);
+  ASSERT_EQ(allocator_->numMapped(), 0);
+}
+
+TEST_P(MallocContiguousTest, allocateContiguousWithMaxPages) {
+  constexpr MachinePageCount kNumPages = 8;
+  constexpr MachinePageCount kMaxPages = 32;
+  ContiguousAllocation allocation;
+  ASSERT_TRUE(allocator_->allocateContiguous(
+      kNumPages, nullptr, allocation, nullptr, kMaxPages));
+  ASSERT_EQ(allocation.numPages(), kNumPages);
+  ASSERT_EQ(allocation.maxSize(), AllocationTraits::pageBytes(kMaxPages));
+
+  allocator_->freeContiguous(allocation);
+  ASSERT_TRUE(allocation.empty());
+}
+
+TEST_P(MallocContiguousTest, growContiguous) {
+  constexpr MachinePageCount kNumPages = 8;
+  constexpr MachinePageCount kMaxPages = 32;
+  ContiguousAllocation allocation;
+  ASSERT_TRUE(allocator_->allocateContiguous(
+      kNumPages, nullptr, allocation, nullptr, kMaxPages));
+
+  // Write data before growing.
+  auto* data = reinterpret_cast<int64_t*>(allocation.data());
+  const auto numWords = static_cast<int64_t>(
+      AllocationTraits::pageBytes(kNumPages) / sizeof(int64_t));
+  for (int64_t i = 0; i < numWords; ++i) {
+    data[i] = i + 1;
+  }
+
+  // Grow within maxPages.
+  constexpr MachinePageCount kIncrement = 8;
+  ASSERT_TRUE(allocator_->growContiguousWithoutRetry(kIncrement, allocation));
+  ASSERT_EQ(allocation.numPages(), kNumPages + kIncrement);
+
+  // Verify original data is intact after grow.
+  data = reinterpret_cast<int64_t*>(allocation.data());
+  for (int64_t i = 0; i < numWords; ++i) {
+    ASSERT_EQ(data[i], i + 1);
+  }
+
+  allocator_->freeContiguous(allocation);
+  ASSERT_TRUE(allocation.empty());
+}
+
+TEST_P(MallocContiguousTest, freeContiguousCollateral) {
+  constexpr MachinePageCount kFirstPages = 16;
+  constexpr MachinePageCount kSecondPages = 8;
+  ContiguousAllocation allocation;
+  ASSERT_TRUE(allocator_->allocateContiguous(kFirstPages, nullptr, allocation));
+  ASSERT_EQ(allocation.numPages(), kFirstPages);
+  ASSERT_EQ(allocator_->numAllocated(), kFirstPages);
+
+  // Allocate again into the same allocation — old allocation is freed as
+  // contiguous collateral.
+  ASSERT_TRUE(
+      allocator_->allocateContiguous(kSecondPages, nullptr, allocation));
+  ASSERT_EQ(allocation.numPages(), kSecondPages);
+  ASSERT_EQ(allocator_->numAllocated(), kSecondPages);
+
+  allocator_->freeContiguous(allocation);
+  ASSERT_EQ(allocator_->numAllocated(), 0);
+}
+
+TEST_P(MallocContiguousTest, allocateContiguousFailure) {
+  constexpr MachinePageCount kNumPages = 16;
+  ContiguousAllocation allocation;
+
+  // Inject allocation failure so dispatchAllocateContiguous returns nullptr.
+  allocator_->testingSetFailureInjection(
+      MemoryAllocator::InjectedFailure::kAllocate, true);
+
+  ASSERT_FALSE(allocator_->allocateContiguous(kNumPages, nullptr, allocation));
+  ASSERT_TRUE(allocation.empty());
+  // Verify all counter increments are properly rolled back.
+  ASSERT_EQ(allocator_->numAllocated(), 0);
+  ASSERT_EQ(allocator_->numMapped(), 0);
+  auto failureMsg = allocator_->getAndClearFailureMessage();
+  EXPECT_THAT(failureMsg, testing::HasSubstr("Failed to allocate"));
+  ASSERT_TRUE(allocator_->checkConsistency());
+}
+
+TEST_P(MallocContiguousTest, allocContiguous) {
+  struct {
+    MachinePageCount nonContiguousPages;
+    MachinePageCount oldContiguousPages;
+    MachinePageCount newContiguousPages;
+  } testSettings[] = {
+      {100, 100, 200},
+      {100, 200, 200},
+      {200, 100, 200},
+      {200, 100, 400},
+      {0, 100, 100},
+      {0, 200, 100},
+      {0, 100, 200},
+      {100, 0, 100},
+      {200, 0, 100},
+      {100, 0, 200}};
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(
+        fmt::format(
+            "nonContiguousPages:{} oldContiguousPages:{} newContiguousPages:{}",
+            testData.nonContiguousPages,
+            testData.oldContiguousPages,
+            testData.newContiguousPages));
+    SetUp();
+    Allocation allocation;
+    if (testData.nonContiguousPages != 0) {
+      allocator_->allocateNonContiguous(
+          testData.nonContiguousPages, allocation);
+    }
+    ContiguousAllocation contiguousAllocation;
+    if (testData.oldContiguousPages != 0) {
+      allocator_->allocateContiguous(
+          testData.oldContiguousPages, nullptr, contiguousAllocation);
+    }
+    allocator_->allocateContiguous(
+        testData.newContiguousPages, &allocation, contiguousAllocation);
+    ASSERT_EQ(allocator_->numAllocated(), testData.newContiguousPages);
+    ASSERT_EQ(allocator_->numMapped(), testData.newContiguousPages);
+
+    allocator_->freeContiguous(contiguousAllocation);
+    ASSERT_EQ(allocator_->numMapped(), 0);
+    ASSERT_EQ(allocator_->numAllocated(), 0);
+    ASSERT_TRUE(allocator_->checkConsistency());
+  }
+}
+
+TEST_P(MallocContiguousTest, allocContiguousFail) {
+  struct {
+    MachinePageCount nonContiguousPages;
+    MachinePageCount oldContiguousPages;
+    MachinePageCount newContiguousPages;
+  } testSettings[] = {{200, 100, 400}, {0, 100, 200}, {100, 0, 200}};
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(
+        fmt::format(
+            "nonContiguousPages:{} oldContiguousPages:{} newContiguousPages:{}",
+            testData.nonContiguousPages,
+            testData.oldContiguousPages,
+            testData.newContiguousPages));
+    SetUp();
+    Allocation allocation;
+    if (testData.nonContiguousPages != 0) {
+      allocator_->allocateNonContiguous(
+          testData.nonContiguousPages, allocation);
+    }
+    ContiguousAllocation contiguousAllocation;
+    if (testData.oldContiguousPages != 0) {
+      allocator_->allocateContiguous(
+          testData.oldContiguousPages, nullptr, contiguousAllocation);
+    }
+    ASSERT_EQ(
+        allocator_->numAllocated(),
+        testData.oldContiguousPages + testData.nonContiguousPages);
+
+    allocator_->testingSetFailureInjection(
+        MemoryAllocator::InjectedFailure::kCap, true);
+
+    ASSERT_FALSE(allocator_->allocateContiguous(
+        testData.newContiguousPages, &allocation, contiguousAllocation));
+    auto failureMsg = allocator_->getAndClearFailureMessage();
+    EXPECT_THAT(
+        failureMsg, testing::HasSubstr("Exceeded memory allocator limit"));
+    ASSERT_EQ(allocator_->numAllocated(), 0);
+    ASSERT_EQ(allocator_->numMapped(), 0);
+    ASSERT_TRUE(allocator_->checkConsistency());
+  }
+}
+
+TEST_P(MallocContiguousTest, allocContiguousGrow) {
+  auto largestClass = allocator_->sizeClasses().back();
+  constexpr int32_t kInitialLarge = 1024;
+  constexpr int32_t kMinGrow = 1024;
+  MachinePageCount numPages = 0;
+  std::vector<Allocation> small;
+  auto freeSmall = [&](int32_t toFree) {
+    int32_t freed = 0;
+    while (!small.empty() && freed < toFree) {
+      freed += small.back().numPages();
+      allocator_->freeNonContiguous(small.back());
+      small.pop_back();
+    }
+  };
+
+  for (; numPages < kCapacityPages - kInitialLarge; numPages += largestClass) {
+    Allocation temp;
+    allocator_->allocateNonContiguous(largestClass, temp);
+    small.push_back(std::move(temp));
+  }
+  ContiguousAllocation large;
+  EXPECT_FALSE(allocator_->allocateContiguous(
+      kInitialLarge * 2, nullptr, large, nullptr, kCapacityPages));
+  EXPECT_TRUE(allocator_->allocateContiguous(
+      kInitialLarge, nullptr, large, nullptr, kCapacityPages));
+  EXPECT_FALSE(allocator_->growContiguous(kMinGrow, large));
+  auto failureMsg = allocator_->getAndClearFailureMessage();
+  EXPECT_THAT(
+      failureMsg, testing::HasSubstr("Exceeded memory allocator limit"));
+  freeSmall(kMinGrow);
+  EXPECT_TRUE(allocator_->growContiguous(kMinGrow, large));
+  EXPECT_EQ(allocator_->numAllocated(), kCapacityPages);
+  freeSmall(4 * kMinGrow);
+  EXPECT_TRUE(allocator_->growContiguous(4 * kMinGrow, large));
+  EXPECT_THROW(
+      allocator_->growContiguous(100000 * kMinGrow, large), VeloxException);
+  allocator_->freeContiguous(large);
+  EXPECT_EQ(
+      kCapacityPages - kInitialLarge - 5 * kMinGrow,
+      allocator_->numAllocated());
+  freeSmall(kCapacityPages);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    MallocContiguousTests,
+    MallocContiguousTest,
+    testing::Bool(),
+    [](const testing::TestParamInfo<bool>& info) {
+      return info.param ? "mallocContiguous" : "mmapContiguous";
+    });
+
 } // namespace facebook::velox::memory
diff --git a/velox/common/memory/tests/MemoryArbitratorTest.cpp b/velox/common/memory/tests/MemoryArbitratorTest.cpp
index 4cf4c492059..5fd819033fe 100644
--- a/velox/common/memory/tests/MemoryArbitratorTest.cpp
+++ b/velox/common/memory/tests/MemoryArbitratorTest.cpp
@@ -713,12 +713,16 @@ TEST_F(MemoryReclaimerTest, scopedReclaimedBytesRecorder) {
   auto childPool = root->addLeafChild("memoryReclaimRecorder", true);
   ASSERT_EQ(childPool->reservedBytes(), 0);
   int64_t reclaimedBytes{0};
-  { ScopedReclaimedBytesRecorder recorder(childPool.get(), &reclaimedBytes); }
+  {
+    ScopedReclaimedBytesRecorder recorder(childPool.get(), &reclaimedBytes);
+  }
   ASSERT_EQ(reclaimedBytes, 0);
 
   void* buffer = childPool->allocate(1 << 20);
   ASSERT_EQ(childPool->reservedBytes(), 1 << 20);
-  { ScopedReclaimedBytesRecorder recorder(childPool.get(), &reclaimedBytes); }
+  {
+    ScopedReclaimedBytesRecorder recorder(childPool.get(), &reclaimedBytes);
+  }
   ASSERT_EQ(reclaimedBytes, 0);
 
   reclaimedBytes = 0;
diff --git a/velox/common/memory/tests/MemoryCapExceededTest.cpp b/velox/common/memory/tests/MemoryCapExceededTest.cpp
index 48eab65ba81..38c739f27f1 100644
--- a/velox/common/memory/tests/MemoryCapExceededTest.cpp
+++ b/velox/common/memory/tests/MemoryCapExceededTest.cpp
@@ -69,7 +69,7 @@ TEST_P(MemoryCapExceededTest, singleDriver) {
   // why).
   std::vector<std::string> expectedTexts = {
       "Can't grow ",
-      "capacity with 2.00MB. This will exceed its max capacity 5.00MB, current "
+      "capacity with 2.00MB. This will exceed its memory pool capacity 5.00MB, current "
       "capacity 5.00MB.\n"
       "ARBITRATOR[SHARED CAPACITY[6.00GB] STATS[numRequests 1 numRunning 1 "
       "numSucceded 0 numAborted 0 numFailures 0 numNonReclaimableAttempts 0 "
@@ -113,8 +113,9 @@ TEST_P(MemoryCapExceededTest, singleDriver) {
                   .orderBy({"c0"}, false)
                   .planNode();
   auto queryCtx = core::QueryCtx::create(executor_.get());
-  queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-      queryCtx->queryId(), kMaxBytes, exec::MemoryReclaimer::create()));
+  queryCtx->testingOverrideMemoryPool(
+      memory::memoryManager()->addRootPool(
+          queryCtx->queryId(), kMaxBytes, exec::MemoryReclaimer::create()));
   CursorParameters params;
   params.planNode = plan;
   params.queryCtx = queryCtx;
@@ -171,8 +172,9 @@ TEST_P(MemoryCapExceededTest, multipleDrivers) {
                   .singleAggregation({"c0"}, {"sum(c1)"})
                   .planNode();
   auto queryCtx = core::QueryCtx::create(executor_.get());
-  queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-      queryCtx->queryId(), kMaxBytes, exec::MemoryReclaimer::create()));
+  queryCtx->testingOverrideMemoryPool(
+      memory::memoryManager()->addRootPool(
+          queryCtx->queryId(), kMaxBytes, exec::MemoryReclaimer::create()));
 
   const int32_t numDrivers = 10;
   CursorParameters params;
diff --git a/velox/common/memory/tests/MemoryManagerTest.cpp b/velox/common/memory/tests/MemoryManagerTest.cpp
index 6cc3ef797a7..f1862a03673 100644
--- a/velox/common/memory/tests/MemoryManagerTest.cpp
+++ b/velox/common/memory/tests/MemoryManagerTest.cpp
@@ -31,13 +31,14 @@ DECLARE_bool(velox_enable_memory_usage_track_in_default_memory_pool);
 using namespace ::testing;
 
 namespace facebook::velox::memory {
-
 namespace {
-constexpr folly::StringPiece kSysRootName{"__sys_root__"};
+
+constexpr std::string_view kSysRootName{"__sys_root__"};
 
 MemoryManager& toMemoryManager(MemoryManager& manager) {
   return *static_cast<MemoryManager*>(&manager);
 }
+
 } // namespace
 
 class MemoryManagerTest : public testing::Test {
@@ -221,14 +222,18 @@ TEST_F(MemoryManagerTest, addPool) {
   auto rootPool = manager.addRootPool("duplicateRootPool", kMaxMemory);
   ASSERT_EQ(rootPool->capacity(), kMaxMemory);
   ASSERT_EQ(rootPool->maxCapacity(), kMaxMemory);
-  { ASSERT_ANY_THROW(manager.addRootPool("duplicateRootPool", kMaxMemory)); }
+  {
+    ASSERT_ANY_THROW(manager.addRootPool("duplicateRootPool", kMaxMemory));
+  }
   auto threadSafeLeafPool = manager.addLeafPool("leafPool", true);
   ASSERT_EQ(threadSafeLeafPool->capacity(), kMaxMemory);
   ASSERT_EQ(threadSafeLeafPool->maxCapacity(), kMaxMemory);
   auto nonThreadSafeLeafPool = manager.addLeafPool("duplicateLeafPool", true);
   ASSERT_EQ(nonThreadSafeLeafPool->capacity(), kMaxMemory);
   ASSERT_EQ(nonThreadSafeLeafPool->maxCapacity(), kMaxMemory);
-  { ASSERT_ANY_THROW(manager.addLeafPool("duplicateLeafPool")); }
+  {
+    ASSERT_ANY_THROW(manager.addLeafPool("duplicateLeafPool"));
+  }
   const int64_t poolCapacity = 1 << 20;
   auto rootPoolWithMaxCapacity =
       manager.addRootPool("rootPoolWithCapacity", poolCapacity);
@@ -273,7 +278,9 @@ TEST_F(MemoryManagerTest, addPoolWithArbitrator) {
   auto nonThreadSafeLeafPool = manager.addLeafPool("duplicateLeafPool", true);
   ASSERT_EQ(nonThreadSafeLeafPool->capacity(), kMaxMemory);
   ASSERT_EQ(nonThreadSafeLeafPool->maxCapacity(), kMaxMemory);
-  { ASSERT_ANY_THROW(manager.addLeafPool("duplicateLeafPool")); }
+  {
+    ASSERT_ANY_THROW(manager.addLeafPool("duplicateLeafPool"));
+  }
   const int64_t poolCapacity = 1 << 30;
   auto rootPoolWithMaxCapacity = manager.addRootPool(
       "rootPoolWithCapacity", poolCapacity, MemoryReclaimer::create());
@@ -346,8 +353,9 @@ TEST_F(MemoryManagerTest, defaultMemoryManager) {
   for (int i = 0; i < 32; ++i) {
     ASSERT_THAT(
         managerA.toString(true),
-        testing::HasSubstr(fmt::format(
-            "__sys_shared_leaf__{} usage 0B reserved 0B peak 0B\n", i)));
+        testing::HasSubstr(
+            fmt::format(
+                "__sys_shared_leaf__{} usage 0B reserved 0B peak 0B\n", i)));
   }
 }
 
@@ -487,7 +495,7 @@ TEST_F(MemoryManagerTest, globalMemoryManager) {
     auto childII = manager->addLeafPool("another_child");
     ASSERT_EQ(childII->kind(), MemoryPool::Kind::kLeaf);
     ASSERT_EQ(rootI.getChildCount(), kSharedPoolCount + 2);
-    ASSERT_EQ(childII->parent()->name(), kSysRootName.str());
+    ASSERT_EQ(childII->parent()->name(), kSysRootName);
     childII.reset();
     ASSERT_EQ(rootI.getChildCount(), kSharedPoolCount + 1);
     ASSERT_EQ(rootII.getChildCount(), kSharedPoolCount + 1);
diff --git a/velox/common/memory/tests/MemoryPoolTest.cpp b/velox/common/memory/tests/MemoryPoolTest.cpp
index 9b9ea02985a..f57e28d0659 100644
--- a/velox/common/memory/tests/MemoryPoolTest.cpp
+++ b/velox/common/memory/tests/MemoryPoolTest.cpp
@@ -31,7 +31,6 @@
 #include "velox/common/testutil/TestValue.h"
 
 DECLARE_bool(velox_memory_leak_check_enabled);
-DECLARE_bool(velox_memory_pool_debug_enabled);
 DECLARE_int32(velox_memory_num_shared_leaf_pools);
 
 using namespace ::testing;
@@ -61,15 +60,16 @@ struct TestParam {
 class MemoryPoolTest : public testing::TestWithParam<TestParam> {
  public:
   static const std::vector<TestParam> getTestParams() {
-    std::vector<TestParam> params;
-    params.push_back({true, true, false});
-    params.push_back({true, false, false});
-    params.push_back({false, true, false});
-    params.push_back({false, false, false});
-    params.push_back({true, true, true});
-    params.push_back({true, false, true});
-    params.push_back({false, true, true});
-    params.push_back({false, false, true});
+    std::vector<TestParam> params = {
+        {true, true, false},
+        {true, false, false},
+        {false, true, false},
+        {false, false, false},
+        {true, true, true},
+        {true, false, true},
+        {false, true, true},
+        {false, false, true},
+    };
     return params;
   }
 
@@ -165,13 +165,14 @@ TEST_P(MemoryPoolTest, ctor) {
     auto fakeRoot = std::make_shared<MemoryPoolImpl>(
         &manager, "fake_root", MemoryPool::Kind::kAggregate, nullptr, nullptr);
     // We can't construct an aggregate memory pool with non-thread safe.
-    ASSERT_ANY_THROW(std::make_shared<MemoryPoolImpl>(
-        &manager,
-        "fake_root",
-        MemoryPool::Kind::kAggregate,
-        nullptr,
-        nullptr,
-        MemoryPool::Options{.threadSafe = false}));
+    ASSERT_ANY_THROW(
+        std::make_shared<MemoryPoolImpl>(
+            &manager,
+            "fake_root",
+            MemoryPool::Kind::kAggregate,
+            nullptr,
+            nullptr,
+            MemoryPool::Options{.threadSafe = false}));
     ASSERT_EQ("fake_root", fakeRoot->name());
     ASSERT_EQ(
         static_cast<MemoryPoolImpl*>(root.get())->testingAllocator(),
@@ -1061,6 +1062,22 @@ TEST_P(MemoryPoolTest, allocatorOverflow) {
   EXPECT_THROW(alloc.deallocate(nullptr, 1ULL << 62), VeloxException);
 }
 
+TEST_P(MemoryPoolTest, allocatorSwap) {
+  MemoryManager& manager = *getMemoryManager();
+  auto root = manager.addRootPool("swapRoot");
+  auto leaf1 = root->addLeafChild("leaf1");
+  auto leaf2 = root->addLeafChild("leaf2");
+
+  StlAllocator<int64_t> alloc1(*leaf1);
+  StlAllocator<int64_t> alloc2(*leaf2);
+  ASSERT_EQ(alloc1.pool, leaf1.get());
+  ASSERT_EQ(alloc2.pool, leaf2.get());
+
+  std::swap(alloc1, alloc2);
+  EXPECT_EQ(alloc1.pool, leaf2.get());
+  EXPECT_EQ(alloc2.pool, leaf1.get());
+}
+
 TEST_P(MemoryPoolTest, contiguousAllocate) {
   auto manager = getMemoryManager();
   auto pool = manager->addLeafPool("contiguousAllocate");
@@ -1402,71 +1419,73 @@ TEST_P(MemoryPoolTest, persistentNonContiguousAllocateFailure) {
           static_cast<uint64_t>(numNewPages),
           injectedFailure);
     }
-  } testSettings[] = {// Cap failure injection.
-                      {0, 100, MemoryAllocator::InjectedFailure::kCap},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {100, 100, MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun / 2,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {200, 100, MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun - 1,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      // Allocate failure injection.
-                      {0, 100, MemoryAllocator::InjectedFailure::kAllocate},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kAllocate},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {100, 100, MemoryAllocator::InjectedFailure::kAllocate},
-                      {Allocation::PageRun::kMaxPagesInRun / 2,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kAllocate},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kAllocate},
-                      {200, 100, MemoryAllocator::InjectedFailure::kAllocate},
-                      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kAllocate},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun - 1,
-                       MemoryAllocator::InjectedFailure::kAllocate},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kAllocate},
-                      // Madvise failure injection.
-                      {0, 100, MemoryAllocator::InjectedFailure::kMadvise},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {200, 100, MemoryAllocator::InjectedFailure::kMadvise}};
+  } testSettings[] = {
+      // Cap failure injection.
+      {0, 100, MemoryAllocator::InjectedFailure::kCap},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kCap},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kCap},
+      {100, 100, MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kCap},
+      {200, 100, MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun - 1,
+       MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kCap},
+      // Allocate failure injection.
+      {0, 100, MemoryAllocator::InjectedFailure::kAllocate},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kAllocate},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kCap},
+      {100, 100, MemoryAllocator::InjectedFailure::kAllocate},
+      {Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kAllocate},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kAllocate},
+      {200, 100, MemoryAllocator::InjectedFailure::kAllocate},
+      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kAllocate},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun - 1,
+       MemoryAllocator::InjectedFailure::kAllocate},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kAllocate},
+      // Madvise failure injection.
+      {0, 100, MemoryAllocator::InjectedFailure::kMadvise},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {200, 100, MemoryAllocator::InjectedFailure::kMadvise}};
   for (const auto& testData : testSettings) {
-    SCOPED_TRACE(fmt::format(
-        "{}, useMmap:{}, useCache:{}",
-        testData.debugString(),
-        useMmap_,
-        useCache_));
+    SCOPED_TRACE(
+        fmt::format(
+            "{}, useMmap:{}, useCache:{}",
+            testData.debugString(),
+            useMmap_,
+            useCache_));
     if ((testData.injectedFailure !=
          MemoryAllocator::InjectedFailure::kAllocate) &&
         !useMmap_) {
@@ -1584,11 +1603,12 @@ TEST_P(MemoryPoolTest, transientNonContiguousAllocateFailure) {
        MemoryAllocator::InjectedFailure::kMadvise},
       {200, 100, 100, MemoryAllocator::InjectedFailure::kMadvise}};
   for (const auto& testData : testSettings) {
-    SCOPED_TRACE(fmt::format(
-        "{}, useMmap:{}, useCache:{}",
-        testData.debugString(),
-        useMmap_,
-        useCache_));
+    SCOPED_TRACE(
+        fmt::format(
+            "{}, useMmap:{}, useCache:{}",
+            testData.debugString(),
+            useMmap_,
+            useCache_));
     if ((testData.injectedFailure !=
          MemoryAllocator::InjectedFailure::kAllocate) &&
         !useMmap_) {
@@ -1672,81 +1692,82 @@ TEST_P(MemoryPoolTest, persistentContiguousAllocateFailure) {
           numNewPages,
           injectedFailure);
     }
-  } testSettings[] = {// Cap failure injection.
-                      {0, 100, MemoryAllocator::InjectedFailure::kCap},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {100, 100, MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun / 2,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {200, 100, MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun - 1,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      // Mmap failure injection.
-                      {0, 100, MemoryAllocator::InjectedFailure::kMmap},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {100, 100, MemoryAllocator::InjectedFailure::kMmap},
-                      {Allocation::PageRun::kMaxPagesInRun / 2,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      {200, 100, MemoryAllocator::InjectedFailure::kMmap},
-                      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun - 1,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      // Madvise failure injection.
-                      {0, 100, MemoryAllocator::InjectedFailure::kMadvise},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {100, 100, MemoryAllocator::InjectedFailure::kMadvise},
-                      {Allocation::PageRun::kMaxPagesInRun / 2,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {200, 100, MemoryAllocator::InjectedFailure::kMadvise},
-                      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun - 1,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMadvise}};
+  } testSettings[] = {
+      // Cap failure injection.
+      {0, 100, MemoryAllocator::InjectedFailure::kCap},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kCap},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kCap},
+      {100, 100, MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kCap},
+      {200, 100, MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun - 1,
+       MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kCap},
+      // Mmap failure injection.
+      {0, 100, MemoryAllocator::InjectedFailure::kMmap},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMmap},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kCap},
+      {100, 100, MemoryAllocator::InjectedFailure::kMmap},
+      {Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMmap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kMmap},
+      {200, 100, MemoryAllocator::InjectedFailure::kMmap},
+      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMmap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun - 1,
+       MemoryAllocator::InjectedFailure::kMmap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMmap},
+      // Madvise failure injection.
+      {0, 100, MemoryAllocator::InjectedFailure::kMadvise},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {100, 100, MemoryAllocator::InjectedFailure::kMadvise},
+      {Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {200, 100, MemoryAllocator::InjectedFailure::kMadvise},
+      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun - 1,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMadvise}};
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
     if (!useMmap_) {
@@ -1790,87 +1811,89 @@ TEST_P(MemoryPoolTest, transientContiguousAllocateFailure) {
           numNewPages,
           injectedFailure);
     }
-  } testSettings[] = {// Cap failure injection.
-                      {0, 100, MemoryAllocator::InjectedFailure::kCap},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {100, 100, MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun / 2,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {200, 100, MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun - 1,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      // Mmap failure injection.
-                      {0, 100, MemoryAllocator::InjectedFailure::kMmap},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {100, 100, MemoryAllocator::InjectedFailure::kMmap},
-                      {Allocation::PageRun::kMaxPagesInRun / 2,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      {200, 100, MemoryAllocator::InjectedFailure::kMmap},
-                      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun - 1,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      // Madvise failure injection.
-                      {0, 100, MemoryAllocator::InjectedFailure::kMadvise},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {100, 100, MemoryAllocator::InjectedFailure::kMadvise},
-                      {Allocation::PageRun::kMaxPagesInRun / 2,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {200, 100, MemoryAllocator::InjectedFailure::kMadvise},
-                      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun - 1,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMadvise}};
+  } testSettings[] = {
+      // Cap failure injection.
+      {0, 100, MemoryAllocator::InjectedFailure::kCap},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kCap},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kCap},
+      {100, 100, MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kCap},
+      {200, 100, MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun - 1,
+       MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kCap},
+      // Mmap failure injection.
+      {0, 100, MemoryAllocator::InjectedFailure::kMmap},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMmap},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kCap},
+      {100, 100, MemoryAllocator::InjectedFailure::kMmap},
+      {Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMmap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kMmap},
+      {200, 100, MemoryAllocator::InjectedFailure::kMmap},
+      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMmap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun - 1,
+       MemoryAllocator::InjectedFailure::kMmap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMmap},
+      // Madvise failure injection.
+      {0, 100, MemoryAllocator::InjectedFailure::kMadvise},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {100, 100, MemoryAllocator::InjectedFailure::kMadvise},
+      {Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {200, 100, MemoryAllocator::InjectedFailure::kMadvise},
+      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun - 1,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMadvise}};
   for (const auto& testData : testSettings) {
-    SCOPED_TRACE(fmt::format(
-        "{}, useCache:{} , useMmap:{}",
-        testData.debugString(),
-        useCache_,
-        useMmap_));
+    SCOPED_TRACE(
+        fmt::format(
+            "{}, useCache:{} , useMmap:{}",
+            testData.debugString(),
+            useCache_,
+            useMmap_));
     if (!useMmap_) {
       // No failure injections supported for contiguous allocation of
       // MallocAllocator.
@@ -1944,33 +1967,34 @@ TEST_P(MemoryPoolTest, persistentContiguousGrowAllocateFailure) {
           injectedFailure,
           expectedErrorMessage);
     }
-  } testSettings[] = {// Cap failure injection.
-                      {10,
-                       100,
-                       MemoryAllocator::InjectedFailure::kCap,
-                       "growContiguous failed with 100 pages from Memory Pool"},
-                      {100,
-                       10,
-                       MemoryAllocator::InjectedFailure::kCap,
-                       "growContiguous failed with 10 pages from Memory Pool"},
-                      // Mmap failure injection.
-                      {10,
-                       100,
-                       MemoryAllocator::InjectedFailure::kMmap,
-                       "growContiguous failed with 100 pages from Memory Pool"},
-                      {100,
-                       10,
-                       MemoryAllocator::InjectedFailure::kMmap,
-                       "growContiguous failed with 10 pages from Memory Pool"},
-                      // Madvise failure injection.
-                      {10,
-                       100,
-                       MemoryAllocator::InjectedFailure::kMadvise,
-                       "growContiguous failed with 100 pages from Memory Pool"},
-                      {100,
-                       10,
-                       MemoryAllocator::InjectedFailure::kMadvise,
-                       "growContiguous failed with 10 pages from Memory Pool"}};
+  } testSettings[] = {
+      // Cap failure injection.
+      {10,
+       100,
+       MemoryAllocator::InjectedFailure::kCap,
+       "growContiguous failed with 100 pages from Memory Pool"},
+      {100,
+       10,
+       MemoryAllocator::InjectedFailure::kCap,
+       "growContiguous failed with 10 pages from Memory Pool"},
+      // Mmap failure injection.
+      {10,
+       100,
+       MemoryAllocator::InjectedFailure::kMmap,
+       "growContiguous failed with 100 pages from Memory Pool"},
+      {100,
+       10,
+       MemoryAllocator::InjectedFailure::kMmap,
+       "growContiguous failed with 10 pages from Memory Pool"},
+      // Madvise failure injection.
+      {10,
+       100,
+       MemoryAllocator::InjectedFailure::kMadvise,
+       "growContiguous failed with 100 pages from Memory Pool"},
+      {100,
+       10,
+       MemoryAllocator::InjectedFailure::kMadvise,
+       "growContiguous failed with 10 pages from Memory Pool"}};
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
     if (!useMmap_) {
@@ -2014,21 +2038,23 @@ TEST_P(MemoryPoolTest, transientContiguousGrowAllocateFailure) {
           numGrowPages,
           injectedFailure);
     }
-  } testSettings[] = {// Cap failure injection.
-                      {10, 100, MemoryAllocator::InjectedFailure::kCap},
-                      {100, 10, MemoryAllocator::InjectedFailure::kCap},
-                      // Mmap failure injection.
-                      {10, 100, MemoryAllocator::InjectedFailure::kMmap},
-                      {100, 10, MemoryAllocator::InjectedFailure::kMmap},
-                      // Madvise failure injection.
-                      {10, 100, MemoryAllocator::InjectedFailure::kMadvise},
-                      {100, 10, MemoryAllocator::InjectedFailure::kMadvise}};
+  } testSettings[] = {
+      // Cap failure injection.
+      {10, 100, MemoryAllocator::InjectedFailure::kCap},
+      {100, 10, MemoryAllocator::InjectedFailure::kCap},
+      // Mmap failure injection.
+      {10, 100, MemoryAllocator::InjectedFailure::kMmap},
+      {100, 10, MemoryAllocator::InjectedFailure::kMmap},
+      // Madvise failure injection.
+      {10, 100, MemoryAllocator::InjectedFailure::kMadvise},
+      {100, 10, MemoryAllocator::InjectedFailure::kMadvise}};
   for (const auto& testData : testSettings) {
-    SCOPED_TRACE(fmt::format(
-        "{}, useCache:{} , useMmap:{}",
-        testData.debugString(),
-        useCache_,
-        useMmap_));
+    SCOPED_TRACE(
+        fmt::format(
+            "{}, useCache:{} , useMmap:{}",
+            testData.debugString(),
+            useCache_,
+            useMmap_));
     if (!useMmap_) {
       // No failure injections supported for contiguous allocation of
       // MallocAllocator.
@@ -2520,7 +2546,6 @@ TEST_P(MemoryPoolTest, concurrentUpdateToDifferentPools) {
 }
 
 TEST_P(MemoryPoolTest, concurrentUpdatesToTheSamePool) {
-  FLAGS_velox_memory_pool_debug_enabled = true;
   if (!isLeafThreadSafe_) {
     return;
   }
@@ -2706,7 +2731,6 @@ TEST(MemoryPoolTest, visitChildren) {
 }
 
 TEST(MemoryPoolTest, debugMode) {
-  FLAGS_velox_memory_pool_debug_enabled = true;
   constexpr int64_t kMaxMemory = 10 * GB;
   constexpr int64_t kNumIterations = 100;
   const std::vector<int64_t> kAllocSizes = {128, 8 * KB, 2 * MB};
@@ -2726,12 +2750,23 @@ TEST(MemoryPoolTest, debugMode) {
                   ->addLeafChild("child");
   const auto& allocRecords = std::dynamic_pointer_cast<MemoryPoolImpl>(pool)
                                  ->testingDebugAllocRecords();
+
   std::vector<void*> smallAllocs;
+  smallAllocs.reserve(kNumIterations);
   for (int32_t i = 0; i < kNumIterations; i++) {
     smallAllocs.push_back(pool->allocate(kAllocSizes[0]));
   }
   EXPECT_EQ(allocRecords.size(), kNumIterations);
   checkAllocs(allocRecords, kAllocSizes[0]);
+
+  // Check toString() works with debug mode enabled
+  const auto poolString = pool->toString();
+  EXPECT_FALSE(poolString.empty());
+  EXPECT_TRUE(
+      poolString.find(
+          "======== 100 allocations of 12.50KB total size ========") !=
+      std::string::npos);
+
   for (int32_t i = 0; i < kNumIterations; i++) {
     pool->free(smallAllocs[i], kAllocSizes[0]);
   }
@@ -2779,14 +2814,16 @@ TEST(MemoryPoolTest, debugModeWithFilter) {
         "root0",
         kMaxMemory,
         nullptr,
-        debugEnabled ? std::optional(MemoryPool::DebugOptions{
-                           .debugPoolNameRegex = "NO-MATCH"})
-                     : std::nullopt);
+        debugEnabled
+            ? std::optional(
+                  MemoryPool::DebugOptions{.debugPoolNameRegex = "NO-MATCH"})
+            : std::nullopt);
     auto pool0_0 = root0->addLeafChild("PartialAggregation.0.0");
     auto* buffer0 = pool0_0->allocate(1 * KB);
-    EXPECT_TRUE(std::dynamic_pointer_cast<MemoryPoolImpl>(pool0_0)
-                    ->testingDebugAllocRecords()
-                    .empty());
+    EXPECT_TRUE(
+        std::dynamic_pointer_cast<MemoryPoolImpl>(pool0_0)
+            ->testingDebugAllocRecords()
+            .empty());
     pool0_0->free(buffer0, 1 * KB);
 
     // leaf child created from MemoryPool, match filter
@@ -2794,8 +2831,9 @@ TEST(MemoryPoolTest, debugModeWithFilter) {
         "root1",
         kMaxMemory,
         nullptr,
-        debugEnabled ? std::optional(MemoryPool::DebugOptions{
-                           .debugPoolNameRegex = ".*PartialAggregation.*"})
+        debugEnabled ? std::optional(
+                           MemoryPool::DebugOptions{
+                               .debugPoolNameRegex = ".*PartialAggregation.*"})
                      : std::nullopt);
     auto pool1_0 = root1->addLeafChild("PartialAggregation.0.1");
     auto* buffer1 = pool1_0->allocate(1 * KB);
@@ -2816,9 +2854,10 @@ TEST(MemoryPoolTest, debugModeWithFilter) {
 
     // old pool from root0 should not be affected by root1
     buffer0 = pool0_0->allocate(1 * KB);
-    EXPECT_TRUE(std::dynamic_pointer_cast<MemoryPoolImpl>(pool0_0)
-                    ->testingDebugAllocRecords()
-                    .empty());
+    EXPECT_TRUE(
+        std::dynamic_pointer_cast<MemoryPoolImpl>(pool0_0)
+            ->testingDebugAllocRecords()
+            .empty());
     pool0_0->free(buffer0, 1 * KB);
 
     // leaf child created from MemoryPool, match filter
@@ -2826,9 +2865,10 @@ TEST(MemoryPoolTest, debugModeWithFilter) {
         "root2",
         kMaxMemory,
         nullptr,
-        debugEnabled ? std::optional(MemoryPool::DebugOptions{
-                           .debugPoolNameRegex = ".*OrderBy.*"})
-                     : std::nullopt);
+        debugEnabled
+            ? std::optional(
+                  MemoryPool::DebugOptions{.debugPoolNameRegex = ".*OrderBy.*"})
+            : std::nullopt);
     auto pool2_0 = root2->addLeafChild("OrderBy.0.0");
     auto* buffer2 = pool2_0->allocate(1 * KB);
     if (!debugEnabled) {
@@ -2879,13 +2919,51 @@ TEST(MemoryPoolTest, debugModeWithFilter) {
     // leaf child created from MemoryManager, not match filter
     auto sysLeaf = manager.addLeafPool("Arbitrator.0.0");
     auto* buffer5 = sysLeaf->allocate(1 * KB);
-    EXPECT_TRUE(std::dynamic_pointer_cast<MemoryPoolImpl>(sysLeaf)
-                    ->testingDebugAllocRecords()
-                    .empty());
+    EXPECT_TRUE(
+        std::dynamic_pointer_cast<MemoryPoolImpl>(sysLeaf)
+            ->testingDebugAllocRecords()
+            .empty());
     sysLeaf->free(buffer5, 1 * KB);
   }
 }
 
+TEST_P(MemoryPoolTest, debugModeWrapCapException) {
+  const uint64_t kMaxCap = 128L * MB;
+  MemoryManager::Options options;
+  options.allocatorCapacity = kMaxCap;
+  options.arbitratorCapacity = kMaxCap;
+  options.extraArbitratorConfigs = {
+      {std::string(SharedArbitrator::ExtraConfig::kReservedCapacity),
+       folly::to<std::string>(kMaxCap / 2) + "B"}};
+  setupMemory(options);
+  auto manager = getMemoryManager();
+  auto root =
+      manager->addRootPool("MemoryCapExceptions", kMaxCap, nullptr, {{".*"}});
+  auto pool1 = root->addLeafChild("static_quota_1", isLeafThreadSafe_);
+  auto pool2 = root->addLeafChild("static_quota_2", isLeafThreadSafe_);
+  {
+    std::vector<void*> buffers{
+        pool1->allocate(64L * MB), pool1->allocate(64L * MB)};
+    try {
+      pool2->allocate(1L * MB);
+    } catch (const velox::VeloxRuntimeError& ex) {
+      ASSERT_EQ(error_source::kErrorSourceRuntime.c_str(), ex.errorSource());
+      ASSERT_EQ(error_code::kMemCapExceeded.c_str(), ex.errorCode());
+      EXPECT_TRUE(
+          ex.message().find(
+              "Exceeded memory pool capacity.\n\n"
+              "======= Current Allocations ======\n"
+              "Memory pool 'static_quota_1' - Found 2 allocations with 128.00MB total size:\n"
+              "======== 2 allocations of 128.00MB total size ========") !=
+          std::string::npos)
+          << "Actual error message: " << ex.message();
+    }
+    for (auto buffer : buffers) {
+      pool1->free(buffer, 64L * MB);
+    }
+  }
+}
+
 TEST_P(MemoryPoolTest, shrinkAndGrowAPIs) {
   MemoryManager& manager = *getMemoryManager();
   std::vector<uint64_t> capacities = {kMaxMemory, 128 * MB};
@@ -3968,9 +4046,13 @@ TEST_P(MemoryPoolTest, abort) {
       ASSERT_TRUE(rootPool->aborted());
 
       // Allocate more buffer to trigger reservation increment at the root.
-      { VELOX_ASSERT_THROW(leafPool->allocate(capacity / 2), ""); }
+      {
+        VELOX_ASSERT_THROW(leafPool->allocate(capacity / 2), "");
+      }
       // Allocate more buffer to trigger memory arbitration at the root.
-      { VELOX_ASSERT_THROW(leafPool->allocate(capacity * 2), ""); }
+      {
+        VELOX_ASSERT_THROW(leafPool->allocate(capacity * 2), "");
+      }
       // Allocate without trigger memory reservation increment.
       void* buf2 = leafPool->allocate(128);
       ASSERT_EQ(leafPool->usedBytes(), 256);
@@ -4037,6 +4119,213 @@ TEST_P(MemoryPoolTest, allocationWithCoveredCollateral) {
   pool->freeContiguous(contiguousAllocation);
 }
 
+TEST_P(MemoryPoolTest, transferTo) {
+  MemoryManager::Options options;
+  options.alignment = MemoryAllocator::kMinAlignment;
+  options.allocatorCapacity = kDefaultCapacity;
+  setupMemory(options);
+  auto manager = getMemoryManager();
+
+  auto largestSizeClass = manager->allocator()->largestSizeClass();
+  std::vector<MachinePageCount> pageCounts{
+      largestSizeClass,
+      largestSizeClass + 1,
+      largestSizeClass / 10,
+      1,
+      largestSizeClass * 2,
+      largestSizeClass * 3 + 1};
+
+  auto assertEqualBytes = [](const memory::MemoryPool* pool,
+                             int64_t usedBytes,
+                             int64_t peakBytes,
+                             int64_t reservedBytes) {
+    EXPECT_EQ(pool->usedBytes(), usedBytes);
+    EXPECT_EQ(pool->peakBytes(), peakBytes);
+    EXPECT_EQ(pool->reservedBytes(), reservedBytes);
+  };
+
+  auto assertZeroByte = [](const memory::MemoryPool* pool) {
+    EXPECT_EQ(pool->usedBytes(), 0);
+    EXPECT_EQ(pool->reservedBytes(), 0);
+  };
+
+  auto getMemoryBytes = [](const memory::MemoryPool* pool) {
+    return std::make_tuple(
+        pool->usedBytes(), pool->peakBytes(), pool->reservedBytes());
+  };
+
+  auto createPools = [&manager](bool betweenDifferentRoots) {
+    auto root1 = manager->addRootPool("root1");
+    auto root2 = manager->addRootPool("root2");
+    std::shared_ptr<MemoryPool> from;
+    std::shared_ptr<MemoryPool> to;
+    if (betweenDifferentRoots) {
+      from = root1->addLeafChild("from");
+      to = root2->addLeafChild("to");
+    } else {
+      from = root1->addLeafChild("from");
+      to = root1->addLeafChild("to");
+    }
+    return std::make_tuple(root1, root2, from, to);
+  };
+
+  auto testTransferAllocate = [&assertZeroByte,
+                               &assertEqualBytes,
+                               &getMemoryBytes,
+                               &createPools](bool betweenDifferentRoots) {
+    auto [root1, root2, from, to] = createPools(betweenDifferentRoots);
+    assertZeroByte(from.get());
+    assertZeroByte(to.get());
+    assertZeroByte(from->root());
+    assertZeroByte(to->root());
+
+    const auto kSize = 1024;
+    int64_t usedBytes, rootUsedBytes;
+    int64_t peakBytes, rootPeakBytes;
+    int64_t reservedBytes, rootReservedBytes;
+    auto buffer = from->allocate(kSize);
+    // Transferring between non-leaf pools is not allowed.
+    EXPECT_FALSE(from->root()->transferTo(to.get(), buffer, kSize));
+    EXPECT_FALSE(from->transferTo(to->root(), buffer, kSize));
+
+    std::tie(usedBytes, peakBytes, reservedBytes) = getMemoryBytes(from.get());
+    std::tie(rootUsedBytes, rootPeakBytes, rootReservedBytes) =
+        getMemoryBytes(from->root());
+    from->transferTo(to.get(), buffer, kSize);
+    assertEqualBytes(to.get(), usedBytes, peakBytes, reservedBytes);
+    if (from->root() == to->root()) {
+      rootPeakBytes *= 2;
+    }
+    assertEqualBytes(
+        to->root(), rootUsedBytes, rootPeakBytes, rootReservedBytes);
+    to->free(buffer, kSize);
+    assertZeroByte(from.get());
+    assertZeroByte(to.get());
+    assertZeroByte(from->root());
+    assertZeroByte(to->root());
+  };
+
+  auto testTransferAllocateZeroFilled =
+      [&assertZeroByte, &assertEqualBytes, &getMemoryBytes, &createPools](
+          bool betweenDifferentRoots) {
+        auto [root1, root2, from, to] = createPools(betweenDifferentRoots);
+        assertZeroByte(from.get());
+        assertZeroByte(to.get());
+        assertZeroByte(from->root());
+        assertZeroByte(to->root());
+
+        const auto kSize = 1024;
+        int64_t usedBytes, rootUsedBytes;
+        int64_t peakBytes, rootPeakBytes;
+        int64_t reservedBytes, rootReservedBytes;
+        auto buffer = from->allocateZeroFilled(8, kSize / 8);
+        std::tie(usedBytes, peakBytes, reservedBytes) =
+            getMemoryBytes(from.get());
+        std::tie(rootUsedBytes, rootPeakBytes, rootReservedBytes) =
+            getMemoryBytes(from->root());
+        from->transferTo(to.get(), buffer, kSize);
+        assertEqualBytes(to.get(), usedBytes, peakBytes, reservedBytes);
+        if (from->root() == to->root()) {
+          rootPeakBytes *= 2;
+        }
+        assertEqualBytes(
+            to->root(), rootUsedBytes, rootPeakBytes, rootReservedBytes);
+        to->free(buffer, kSize);
+        assertZeroByte(from.get());
+        assertZeroByte(to.get());
+        assertZeroByte(from->root());
+        assertZeroByte(to->root());
+      };
+
+  auto testTransferAllocateContiguous =
+      [&assertZeroByte, &assertEqualBytes, &getMemoryBytes, &createPools](
+          uint64_t pageCount, bool betweenDifferentRoots) {
+        auto [root1, root2, from, to] = createPools(betweenDifferentRoots);
+        assertZeroByte(from.get());
+        assertZeroByte(to.get());
+        assertZeroByte(from->root());
+        assertZeroByte(to->root());
+
+        int64_t usedBytes, rootUsedBytes;
+        int64_t peakBytes, rootPeakBytes;
+        int64_t reservedBytes, rootReservedBytes;
+        ContiguousAllocation out;
+        from->allocateContiguous(pageCount, out);
+        std::tie(usedBytes, peakBytes, reservedBytes) =
+            getMemoryBytes(from.get());
+        std::tie(rootUsedBytes, rootPeakBytes, rootReservedBytes) =
+            getMemoryBytes(from->root());
+        from->transferTo(to.get(), out.data(), out.size());
+        assertEqualBytes(to.get(), usedBytes, peakBytes, reservedBytes);
+        if (from->root() == to->root()) {
+          rootPeakBytes *= 2;
+        }
+        assertEqualBytes(
+            to->root(), rootUsedBytes, rootPeakBytes, rootReservedBytes);
+        to->freeContiguous(out);
+        assertZeroByte(from.get());
+        assertZeroByte(to.get());
+        assertZeroByte(from->root());
+        assertZeroByte(to->root());
+      };
+
+  auto testTransferAllocateNonContiguous =
+      [&assertZeroByte, &assertEqualBytes, &getMemoryBytes, &createPools](
+          uint64_t pageCount, bool betweenDifferentRoots) {
+        auto [root1, root2, from, to] = createPools(betweenDifferentRoots);
+        assertZeroByte(from.get());
+        assertZeroByte(to.get());
+        assertZeroByte(from->root());
+        assertZeroByte(to->root());
+
+        int64_t usedBytes, rootUsedBytes;
+        int64_t peakBytes, rootPeakBytes;
+        int64_t reservedBytes, rootReservedBytes;
+        Allocation out;
+        from->allocateNonContiguous(pageCount, out);
+        std::tie(usedBytes, peakBytes, reservedBytes) =
+            getMemoryBytes(from.get());
+        std::tie(rootUsedBytes, rootPeakBytes, rootReservedBytes) =
+            getMemoryBytes(from->root());
+        for (auto i = 0; i < out.numRuns(); ++i) {
+          const auto& run = out.runAt(i);
+          from->transferTo(to.get(), run.data(), run.numBytes());
+        }
+        assertEqualBytes(to.get(), usedBytes, peakBytes, reservedBytes);
+        if (from->root() == to->root()) {
+          EXPECT_EQ(to->root()->usedBytes(), rootUsedBytes);
+          // We reserve and release memory run-by-run, so the peak bytes would
+          // be no greater than twice of the original peak bytes.
+          EXPECT_LE(to->root()->peakBytes(), rootPeakBytes * 2);
+          EXPECT_EQ(to->root()->reservedBytes(), rootReservedBytes);
+        } else {
+          assertEqualBytes(
+              to->root(), rootUsedBytes, rootPeakBytes, rootReservedBytes);
+        }
+        to->freeNonContiguous(out);
+        assertZeroByte(from.get());
+        assertZeroByte(to.get());
+        assertZeroByte(from->root());
+        assertZeroByte(to->root());
+      };
+
+  // Test transfer between siblings of the same root pool.
+  testTransferAllocate(false);
+  testTransferAllocateZeroFilled(false);
+  for (auto pageCount : pageCounts) {
+    testTransferAllocateContiguous(pageCount, false);
+    testTransferAllocateNonContiguous(pageCount, false);
+  }
+
+  // Test transfer between different root pools.
+  testTransferAllocate(true);
+  testTransferAllocateZeroFilled(true);
+  for (auto pageCount : pageCounts) {
+    testTransferAllocateContiguous(pageCount, true);
+    testTransferAllocateNonContiguous(pageCount, true);
+  }
+}
+
 VELOX_INSTANTIATE_TEST_SUITE_P(
     MemoryPoolTestSuite,
     MemoryPoolTest,
diff --git a/velox/common/memory/tests/MockSharedArbitratorTest.cpp b/velox/common/memory/tests/MockSharedArbitratorTest.cpp
index a1569f547cf..830aa1e699b 100644
--- a/velox/common/memory/tests/MockSharedArbitratorTest.cpp
+++ b/velox/common/memory/tests/MockSharedArbitratorTest.cpp
@@ -21,17 +21,17 @@
 #include <re2/re2.h>
 #include <deque>
 #include <vector>
-#include "folly/experimental/EventCount.h"
+#include "folly/synchronization/EventCount.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/memory/MallocAllocator.h"
 #include "velox/common/memory/Memory.h"
 #include "velox/common/memory/MemoryArbitrator.h"
 #include "velox/common/memory/SharedArbitrator.h"
 #include "velox/common/memory/tests/SharedArbitratorTestUtil.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 DECLARE_bool(velox_memory_leak_check_enabled);
 DECLARE_bool(velox_suppress_memory_capacity_exceeding_error_message);
@@ -49,7 +49,7 @@ class TestRuntimeStatWriter : public BaseRuntimeStatWriter {
       std::unordered_map<std::string, RuntimeMetric>& stats)
       : stats_{stats} {}
 
-  void addRuntimeStat(const std::string& name, const RuntimeCounter& value)
+  void addRuntimeStat(std::string_view name, const RuntimeCounter& value)
       override {
     addOperatorRuntimeStats(name, value, stats_);
   }
@@ -1451,12 +1451,21 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, localArbitrationsFromSameQuery) {
     setThreadLocalRunTimeStatWriter(statsWriter.get());
     runPool->allocate(memoryCapacity / 2);
     ASSERT_EQ(
-        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
+        runtimeStats[std::string(SharedArbitrator::kMemoryArbitrationWallNanos)]
+            .count,
+        1);
     ASSERT_GT(
-        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+        runtimeStats[std::string(SharedArbitrator::kMemoryArbitrationWallNanos)]
+            .sum,
+        0);
+    ASSERT_EQ(
+        runtimeStats[std::string(SharedArbitrator::kGlobalArbitrationWaitCount)]
+            .count,
+        0);
     ASSERT_EQ(
-        runtimeStats[SharedArbitrator::kGlobalArbitrationWaitCount].count, 0);
-    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 0);
+        runtimeStats[std::string(SharedArbitrator::kLocalArbitrationCount)]
+            .count,
+        0);
     ++allocationCount;
   });
 
@@ -1467,13 +1476,24 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, localArbitrationsFromSameQuery) {
     setThreadLocalRunTimeStatWriter(statsWriter.get());
     waitPool->allocate(memoryCapacity / 2 + MB);
     ASSERT_EQ(
-        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
+        runtimeStats[std::string(SharedArbitrator::kMemoryArbitrationWallNanos)]
+            .count,
+        1);
     ASSERT_GT(
-        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+        runtimeStats[std::string(SharedArbitrator::kMemoryArbitrationWallNanos)]
+            .sum,
+        0);
     ASSERT_EQ(
-        runtimeStats[SharedArbitrator::kGlobalArbitrationWaitCount].count, 0);
-    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 1);
-    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].sum, 1);
+        runtimeStats[std::string(SharedArbitrator::kGlobalArbitrationWaitCount)]
+            .count,
+        0);
+    ASSERT_EQ(
+        runtimeStats[std::string(SharedArbitrator::kLocalArbitrationCount)]
+            .count,
+        1);
+    ASSERT_EQ(
+        runtimeStats[std::string(SharedArbitrator::kLocalArbitrationCount)].sum,
+        1);
     ++allocationCount;
   });
 
@@ -1534,12 +1554,21 @@ DEBUG_ONLY_TEST_F(
     op1->allocate(MB);
     ASSERT_EQ(task1->capacity(), 8 * MB);
     ASSERT_EQ(
-        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
+        runtimeStats[std::string(SharedArbitrator::kMemoryArbitrationWallNanos)]
+            .count,
+        1);
     ASSERT_GT(
-        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+        runtimeStats[std::string(SharedArbitrator::kMemoryArbitrationWallNanos)]
+            .sum,
+        0);
+    ASSERT_EQ(
+        runtimeStats[std::string(SharedArbitrator::kGlobalArbitrationWaitCount)]
+            .count,
+        0);
     ASSERT_EQ(
-        runtimeStats[SharedArbitrator::kGlobalArbitrationWaitCount].count, 0);
-    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 1);
+        runtimeStats[std::string(SharedArbitrator::kLocalArbitrationCount)]
+            .count,
+        1);
     ++allocationCount;
   });
 
@@ -1550,12 +1579,21 @@ DEBUG_ONLY_TEST_F(
     op2->allocate(MB);
     ASSERT_EQ(task2->capacity(), 8 * MB);
     ASSERT_EQ(
-        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
+        runtimeStats[std::string(SharedArbitrator::kMemoryArbitrationWallNanos)]
+            .count,
+        1);
     ASSERT_GT(
-        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+        runtimeStats[std::string(SharedArbitrator::kMemoryArbitrationWallNanos)]
+            .sum,
+        0);
     ASSERT_EQ(
-        runtimeStats[SharedArbitrator::kGlobalArbitrationWaitCount].count, 0);
-    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 1);
+        runtimeStats[std::string(SharedArbitrator::kGlobalArbitrationWaitCount)]
+            .count,
+        0);
+    ASSERT_EQ(
+        runtimeStats[std::string(SharedArbitrator::kLocalArbitrationCount)]
+            .count,
+        1);
     ++allocationCount;
   });
 
@@ -1780,20 +1818,37 @@ DEBUG_ONLY_TEST_F(
     }
     // We expect global arbitration has been triggered.
     ASSERT_GE(
-        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
+        runtimeStats[std::string(SharedArbitrator::kMemoryArbitrationWallNanos)]
+            .count,
+        1);
     ASSERT_GT(
-        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+        runtimeStats[std::string(SharedArbitrator::kMemoryArbitrationWallNanos)]
+            .sum,
+        0);
     ASSERT_GT(
-        runtimeStats[SharedArbitrator::kGlobalArbitrationWaitCount].count, 0);
+        runtimeStats[std::string(SharedArbitrator::kGlobalArbitrationWaitCount)]
+            .count,
+        0);
     ASSERT_GT(
-        runtimeStats[SharedArbitrator::kGlobalArbitrationWaitCount].sum, 0);
-    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 0);
-    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].sum, 0);
+        runtimeStats[std::string(SharedArbitrator::kGlobalArbitrationWaitCount)]
+            .sum,
+        0);
+    ASSERT_EQ(
+        runtimeStats[std::string(SharedArbitrator::kLocalArbitrationCount)]
+            .count,
+        0);
+    ASSERT_EQ(
+        runtimeStats[std::string(SharedArbitrator::kLocalArbitrationCount)].sum,
+        0);
     ASSERT_GT(
-        runtimeStats[SharedArbitrator::kGlobalArbitrationWaitWallNanos].count,
+        runtimeStats[std::string(
+                         SharedArbitrator::kGlobalArbitrationWaitWallNanos)]
+            .count,
         0);
     ASSERT_GT(
-        runtimeStats[SharedArbitrator::kGlobalArbitrationWaitWallNanos].sum,
+        runtimeStats[std::string(
+                         SharedArbitrator::kGlobalArbitrationWaitWallNanos)]
+            .sum,
         1'000'000'000);
   });
 
@@ -1845,6 +1900,26 @@ DEBUG_ONLY_TEST_F(
   auto* localArbitrationOp = localArbitrationTask->addMemoryOp(true);
   localArbitrationOp->allocate(memoryPoolCapacity);
 
+  // Install the test value callback BEFORE spawning the thread to avoid a race
+  // condition where the thread triggers global arbitration before the callback
+  // is registered, causing the main thread to deadlock. (GitHub issue #15336)
+  std::atomic_bool globalArbitrationStarted{false};
+  folly::EventCount globalArbitrationStartWait;
+  std::atomic_bool globalArbitrationWaitFlag{true};
+  folly::EventCount globalArbitrationWait;
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::memory::SharedArbitrator::runGlobalArbitration",
+      std::function<void(const SharedArbitrator*)>(
+          ([&](const SharedArbitrator* /*unused*/) {
+            if (globalArbitrationStarted.exchange(true)) {
+              return;
+            }
+            globalArbitrationStartWait.notifyAll();
+
+            globalArbitrationWait.await(
+                [&]() { return !globalArbitrationWaitFlag.load(); });
+          })));
+
   auto globalArbitrationTriggerThread = std::thread([&]() {
     std::unordered_map<std::string, RuntimeMetric> runtimeStats;
     auto statsWriter = std::make_unique<TestRuntimeStatWriter>(runtimeStats);
@@ -1863,39 +1938,40 @@ DEBUG_ONLY_TEST_F(
     }
     // We expect global arbitration has been triggered.
     ASSERT_GE(
-        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
+        runtimeStats[std::string(SharedArbitrator::kMemoryArbitrationWallNanos)]
+            .count,
+        1);
     ASSERT_GT(
-        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+        runtimeStats[std::string(SharedArbitrator::kMemoryArbitrationWallNanos)]
+            .sum,
+        0);
     ASSERT_GE(
-        runtimeStats[SharedArbitrator::kGlobalArbitrationWaitCount].count, 1);
+        runtimeStats[std::string(SharedArbitrator::kGlobalArbitrationWaitCount)]
+            .count,
+        1);
     ASSERT_GE(
-        runtimeStats[SharedArbitrator::kGlobalArbitrationWaitCount].sum, 1);
-    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 0);
-    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].sum, 0);
+        runtimeStats[std::string(SharedArbitrator::kGlobalArbitrationWaitCount)]
+            .sum,
+        1);
+    ASSERT_EQ(
+        runtimeStats[std::string(SharedArbitrator::kLocalArbitrationCount)]
+            .count,
+        0);
+    ASSERT_EQ(
+        runtimeStats[std::string(SharedArbitrator::kLocalArbitrationCount)].sum,
+        0);
     ASSERT_GE(
-        runtimeStats[SharedArbitrator::kGlobalArbitrationWaitWallNanos].count,
+        runtimeStats[std::string(
+                         SharedArbitrator::kGlobalArbitrationWaitWallNanos)]
+            .count,
         1);
     ASSERT_GT(
-        runtimeStats[SharedArbitrator::kGlobalArbitrationWaitWallNanos].sum, 1);
+        runtimeStats[std::string(
+                         SharedArbitrator::kGlobalArbitrationWaitWallNanos)]
+            .sum,
+        1);
   });
 
-  std::atomic_bool globalArbitrationStarted{false};
-  folly::EventCount globalArbitrationStartWait;
-  std::atomic_bool globalArbitrationWaitFlag{true};
-  folly::EventCount globalArbitrationWait;
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::memory::SharedArbitrator::runGlobalArbitration",
-      std::function<void(const SharedArbitrator*)>(
-          ([&](const SharedArbitrator* /*unused*/) {
-            if (globalArbitrationStarted.exchange(true)) {
-              return;
-            }
-            globalArbitrationStartWait.notifyAll();
-
-            globalArbitrationWait.await(
-                [&]() { return !globalArbitrationWaitFlag.load(); });
-          })));
-
   globalArbitrationStartWait.await(
       [&]() { return globalArbitrationStarted.load(); });
 
@@ -1912,10 +1988,19 @@ DEBUG_ONLY_TEST_F(
   globalArbitrationTriggerThread.join();
   ASSERT_EQ(localArbitrationOp->capacity(), memoryPoolReservedCapacity);
   ASSERT_EQ(
-      runtimeStats[SharedArbitrator::kGlobalArbitrationWaitCount].count, 0);
-  ASSERT_EQ(runtimeStats[SharedArbitrator::kGlobalArbitrationWaitCount].sum, 0);
-  ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 1);
-  ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].sum, 1);
+      runtimeStats[std::string(SharedArbitrator::kGlobalArbitrationWaitCount)]
+          .count,
+      0);
+  ASSERT_EQ(
+      runtimeStats[std::string(SharedArbitrator::kGlobalArbitrationWaitCount)]
+          .sum,
+      0);
+  ASSERT_EQ(
+      runtimeStats[std::string(SharedArbitrator::kLocalArbitrationCount)].count,
+      1);
+  ASSERT_EQ(
+      runtimeStats[std::string(SharedArbitrator::kLocalArbitrationCount)].sum,
+      1);
 
   // Global arbitration thread may still be running in the background,
   // triggerring ASAN failure. Wait until it exits.
@@ -1966,14 +2051,25 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, globalArbitrationAbortTimeRatio) {
     op1->allocate(memoryCapacity / 2);
 
     ASSERT_EQ(
-        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
+        runtimeStats[std::string(SharedArbitrator::kMemoryArbitrationWallNanos)]
+            .count,
+        1);
     ASSERT_GT(
-        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+        runtimeStats[std::string(SharedArbitrator::kMemoryArbitrationWallNanos)]
+            .sum,
+        0);
     ASSERT_EQ(
-        runtimeStats[SharedArbitrator::kGlobalArbitrationWaitCount].count, 1);
+        runtimeStats[std::string(SharedArbitrator::kGlobalArbitrationWaitCount)]
+            .count,
+        1);
     ASSERT_EQ(
-        runtimeStats[SharedArbitrator::kGlobalArbitrationWaitCount].sum, 1);
-    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 0);
+        runtimeStats[std::string(SharedArbitrator::kGlobalArbitrationWaitCount)]
+            .sum,
+        1);
+    ASSERT_EQ(
+        runtimeStats[std::string(SharedArbitrator::kLocalArbitrationCount)]
+            .count,
+        0);
     ASSERT_TRUE(task1->error() == nullptr);
     ASSERT_EQ(task1->capacity(), memoryCapacity);
     ASSERT_TRUE(task2->error() != nullptr);
@@ -2019,12 +2115,24 @@ TEST_F(MockSharedArbitrationTest, globalArbitrationWithoutSpill) {
   triggerOp->allocate(memoryCapacity / 2);
 
   ASSERT_EQ(
-      runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
-  ASSERT_GT(runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+      runtimeStats[std::string(SharedArbitrator::kMemoryArbitrationWallNanos)]
+          .count,
+      1);
+  ASSERT_GT(
+      runtimeStats[std::string(SharedArbitrator::kMemoryArbitrationWallNanos)]
+          .sum,
+      0);
   ASSERT_EQ(
-      runtimeStats[SharedArbitrator::kGlobalArbitrationWaitCount].count, 1);
-  ASSERT_EQ(runtimeStats[SharedArbitrator::kGlobalArbitrationWaitCount].sum, 1);
-  ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 0);
+      runtimeStats[std::string(SharedArbitrator::kGlobalArbitrationWaitCount)]
+          .count,
+      1);
+  ASSERT_EQ(
+      runtimeStats[std::string(SharedArbitrator::kGlobalArbitrationWaitCount)]
+          .sum,
+      1);
+  ASSERT_EQ(
+      runtimeStats[std::string(SharedArbitrator::kLocalArbitrationCount)].count,
+      0);
 
   ASSERT_TRUE(triggerTask->error() == nullptr);
   ASSERT_EQ(triggerTask->capacity(), memoryCapacity);
@@ -2066,12 +2174,24 @@ TEST_F(MockSharedArbitrationTest, globalArbitrationSmallParticipantLargeGrow) {
   VELOX_ASSERT_THROW(op0->allocate(kMemoryCapacity / 2), "aborted");
 
   ASSERT_EQ(
-      runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
-  ASSERT_GT(runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+      runtimeStats[std::string(SharedArbitrator::kMemoryArbitrationWallNanos)]
+          .count,
+      1);
+  ASSERT_GT(
+      runtimeStats[std::string(SharedArbitrator::kMemoryArbitrationWallNanos)]
+          .sum,
+      0);
+  ASSERT_EQ(
+      runtimeStats[std::string(SharedArbitrator::kGlobalArbitrationWaitCount)]
+          .count,
+      1);
+  ASSERT_EQ(
+      runtimeStats[std::string(SharedArbitrator::kGlobalArbitrationWaitCount)]
+          .sum,
+      1);
   ASSERT_EQ(
-      runtimeStats[SharedArbitrator::kGlobalArbitrationWaitCount].count, 1);
-  ASSERT_EQ(runtimeStats[SharedArbitrator::kGlobalArbitrationWaitCount].sum, 1);
-  ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 0);
+      runtimeStats[std::string(SharedArbitrator::kLocalArbitrationCount)].count,
+      0);
 
   ASSERT_TRUE(task1->error() == nullptr);
   ASSERT_EQ(task1->capacity(), kMemoryCapacity / 2);
@@ -2277,14 +2397,25 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, multipleGlobalRuns) {
     setThreadLocalRunTimeStatWriter(statsWriter.get());
     waitPool->allocate(memoryCapacity / 2);
     ASSERT_EQ(
-        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
+        runtimeStats[std::string(SharedArbitrator::kMemoryArbitrationWallNanos)]
+            .count,
+        1);
     ASSERT_GT(
-        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+        runtimeStats[std::string(SharedArbitrator::kMemoryArbitrationWallNanos)]
+            .sum,
+        0);
     ASSERT_EQ(
-        runtimeStats[SharedArbitrator::kGlobalArbitrationWaitCount].count, 1);
+        runtimeStats[std::string(SharedArbitrator::kGlobalArbitrationWaitCount)]
+            .count,
+        1);
     ASSERT_EQ(
-        runtimeStats[SharedArbitrator::kGlobalArbitrationWaitCount].sum, 1);
-    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 0);
+        runtimeStats[std::string(SharedArbitrator::kGlobalArbitrationWaitCount)]
+            .sum,
+        1);
+    ASSERT_EQ(
+        runtimeStats[std::string(SharedArbitrator::kLocalArbitrationCount)]
+            .count,
+        0);
     ++allocations;
   });
 
@@ -2294,14 +2425,25 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, multipleGlobalRuns) {
     setThreadLocalRunTimeStatWriter(statsWriter.get());
     runPool->allocate(memoryCapacity / 2);
     ASSERT_EQ(
-        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
+        runtimeStats[std::string(SharedArbitrator::kMemoryArbitrationWallNanos)]
+            .count,
+        1);
     ASSERT_GT(
-        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+        runtimeStats[std::string(SharedArbitrator::kMemoryArbitrationWallNanos)]
+            .sum,
+        0);
+    ASSERT_EQ(
+        runtimeStats[std::string(SharedArbitrator::kGlobalArbitrationWaitCount)]
+            .count,
+        1);
     ASSERT_EQ(
-        runtimeStats[SharedArbitrator::kGlobalArbitrationWaitCount].count, 1);
+        runtimeStats[std::string(SharedArbitrator::kGlobalArbitrationWaitCount)]
+            .sum,
+        1);
     ASSERT_EQ(
-        runtimeStats[SharedArbitrator::kGlobalArbitrationWaitCount].sum, 1);
-    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 0);
+        runtimeStats[std::string(SharedArbitrator::kLocalArbitrationCount)]
+            .count,
+        0);
     ++allocations;
   });
 
diff --git a/velox/common/memory/tests/RawVectorTest.cpp b/velox/common/memory/tests/RawVectorTest.cpp
index cfd9611b57c..21cbb9bc464 100644
--- a/velox/common/memory/tests/RawVectorTest.cpp
+++ b/velox/common/memory/tests/RawVectorTest.cpp
@@ -26,6 +26,10 @@ struct TestParam {
   bool useMemoryPool{false};
 };
 
+inline void PrintTo(const TestParam& param, std::ostream* os) {
+  *os << (param.useMemoryPool ? "withPool" : "noPool");
+}
+
 class RawVectorTest : public testing::WithParamInterface<TestParam>,
                       public testing::Test {
  protected:
@@ -148,12 +152,18 @@ TEST_P(RawVectorTest, copyAndMove) {
 }
 
 TEST_P(RawVectorTest, iota) {
+  constexpr int kSizeThreshold = 1'000'000;
   raw_vector<int32_t> storage =
       makeRawVector(0, GetParam().useMemoryPool ? pool_.get() : nullptr);
   // Small sizes are preallocated.
   EXPECT_EQ(11, iota(12, storage)[11]);
+  EXPECT_EQ(6, iota(12, storage, 5)[1]);
+  EXPECT_EQ(
+      kSizeThreshold - 1, iota(kSizeThreshold, storage)[kSizeThreshold - 1]);
   EXPECT_TRUE(storage.empty());
-  EXPECT_EQ(110000, iota(110001, storage)[110000]);
+  EXPECT_EQ(
+      2 * kSizeThreshold - 1,
+      iota(2 * kSizeThreshold, storage)[2 * kSizeThreshold - 1]);
   // Larger sizes are allocated in 'storage'.
   EXPECT_FALSE(storage.empty());
 }
@@ -185,6 +195,74 @@ TEST_P(RawVectorTest, toStdVector) {
   }
 }
 
+TEST_P(RawVectorTest, shrinkToFit) {
+  raw_vector<int> data =
+      makeRawVector(0, GetParam().useMemoryPool ? pool_.get() : nullptr);
+
+  // Empty vector — shrink should be a no-op.
+  data.shrink_to_fit();
+  EXPECT_EQ(0, data.size());
+  EXPECT_EQ(0, data.capacity());
+  EXPECT_EQ(nullptr, data.data());
+
+  // Shrink after clear should free all memory.
+  for (int i = 0; i < 100; ++i) {
+    data.push_back(i);
+  }
+  EXPECT_EQ(100, data.size());
+  EXPECT_GE(data.capacity(), 100);
+  data.clear();
+  data.shrink_to_fit();
+  EXPECT_EQ(0, data.size());
+  EXPECT_EQ(0, data.capacity());
+  EXPECT_EQ(nullptr, data.data());
+
+  // Size equals capacity — shrink should be a no-op preserving data.
+  for (int i = 0; i < 10; ++i) {
+    data.push_back(i * 10);
+  }
+  const auto exactCapacity = data.capacity();
+  data.shrink_to_fit();
+  EXPECT_EQ(10, data.size());
+  EXPECT_EQ(exactCapacity, data.capacity());
+  for (int i = 0; i < 10; ++i) {
+    EXPECT_EQ(i * 10, data[i]);
+  }
+
+  // Capacity larger than size — shrink should reduce capacity.
+  data.reserve(10'000);
+  const auto largeCapacity = data.capacity();
+  EXPECT_GT(largeCapacity, exactCapacity);
+  data.shrink_to_fit();
+  EXPECT_EQ(10, data.size());
+  EXPECT_LT(data.capacity(), largeCapacity);
+  EXPECT_LE(data.capacity(), exactCapacity);
+  for (int i = 0; i < 10; ++i) {
+    EXPECT_EQ(i * 10, data[i]);
+  }
+
+  // Push back after shrink should work correctly.
+  for (int i = 10; i < 20; ++i) {
+    data.push_back(i * 10);
+  }
+  EXPECT_EQ(20, data.size());
+  for (int i = 0; i < 20; ++i) {
+    EXPECT_EQ(i * 10, data[i]);
+  }
+
+  // Push back after shrink from empty should work correctly.
+  data.clear();
+  data.shrink_to_fit();
+  EXPECT_EQ(nullptr, data.data());
+  for (int i = 0; i < 5; ++i) {
+    data.push_back(i * 100);
+  }
+  EXPECT_EQ(5, data.size());
+  for (int i = 0; i < 5; ++i) {
+    EXPECT_EQ(i * 100, data[i]);
+  }
+}
+
 VELOX_INSTANTIATE_TEST_SUITE_P(
     RawVectorTest,
     RawVectorTest,
diff --git a/velox/common/memory/tests/SharedArbitratorTest.cpp b/velox/common/memory/tests/SharedArbitratorTest.cpp
index f01cc043da5..69a84e66dc5 100644
--- a/velox/common/memory/tests/SharedArbitratorTest.cpp
+++ b/velox/common/memory/tests/SharedArbitratorTest.cpp
@@ -22,7 +22,7 @@
 #include <folly/init/Init.h>
 #include <functional>
 #include <optional>
-#include "folly/experimental/EventCount.h"
+#include "folly/synchronization/EventCount.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/memory/MallocAllocator.h"
@@ -292,23 +292,30 @@ class SharedArbitrationTest : public testing::WithParamInterface<TestParam>,
     if (expectGlobalArbitration) {
       VELOX_CHECK_EQ(
           stats.customStats.count(
-              SharedArbitrator::kGlobalArbitrationWaitCount),
+              std::string(SharedArbitrator::kGlobalArbitrationWaitCount)),
           1);
       VELOX_CHECK_GE(
-          stats.customStats.at(SharedArbitrator::kGlobalArbitrationWaitCount)
+          stats.customStats
+              .at(std::string(SharedArbitrator::kGlobalArbitrationWaitCount))
               .sum,
           1);
       VELOX_CHECK_EQ(
-          stats.customStats.count(SharedArbitrator::kLocalArbitrationCount), 0);
+          stats.customStats.count(
+              std::string(SharedArbitrator::kLocalArbitrationCount)),
+          0);
     } else {
       VELOX_CHECK_EQ(
-          stats.customStats.count(SharedArbitrator::kLocalArbitrationCount), 1);
+          stats.customStats.count(
+              std::string(SharedArbitrator::kLocalArbitrationCount)),
+          1);
       VELOX_CHECK_EQ(
-          stats.customStats.at(SharedArbitrator::kLocalArbitrationCount).sum,
+          stats.customStats
+              .at(std::string(SharedArbitrator::kLocalArbitrationCount))
+              .sum,
           1);
       VELOX_CHECK_EQ(
           stats.customStats.count(
-              SharedArbitrator::kGlobalArbitrationWaitCount),
+              std::string(SharedArbitrator::kGlobalArbitrationWaitCount)),
           0);
     }
   }
@@ -358,18 +365,19 @@ DEBUG_ONLY_TEST_P(
         queryCtxStateChecked = true;
       })));
 
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  const auto spillDirectory = TempDirectoryPath::create();
   TestScopedSpillInjection scopedSpillInjection(100);
   core::PlanNodeId aggregationNodeId;
   newQueryBuilder()
       .queryCtx(queryCtx)
       .spillDirectory(spillDirectory->getPath())
       .config(core::QueryConfig::kSpillEnabled, "true")
-      .plan(PlanBuilder()
-                .values(vectors)
-                .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                .capturePlanNodeId(aggregationNodeId)
-                .planNode())
+      .plan(
+          PlanBuilder()
+              .values(vectors)
+              .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+              .capturePlanNodeId(aggregationNodeId)
+              .planNode())
       .assertResults("SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
   ASSERT_TRUE(queryCtxStateChecked);
   ASSERT_FALSE(queryCtx->testingUnderArbitration());
@@ -406,7 +414,7 @@ DEBUG_ONLY_TEST_P(
       })));
 
   std::thread queryThread([&] {
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto spillDirectory = TempDirectoryPath::create();
     core::PlanNodeId aggregationNodeId;
     auto plan = PlanBuilder()
                     .values(vectors)
@@ -485,7 +493,7 @@ DEBUG_ONLY_TEST_P(
                              .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
                              .planNode();
   std::thread spillableThread([&]() {
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto spillDirectory = TempDirectoryPath::create();
     newQueryBuilder(spillPlan)
         .queryCtx(queryCtx)
         .spillDirectory(spillDirectory->getPath())
@@ -590,11 +598,12 @@ DEBUG_ONLY_TEST_P(SharedArbitrationTestWithThreadingModes, reclaimToOrderBy) {
           newQueryBuilder()
               .queryCtx(orderByQueryCtx)
               .serialExecution(isSerialExecutionMode_)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .orderBy({"c0 ASC NULLS LAST"}, false)
-                        .capturePlanNodeId(orderByNodeId)
-                        .planNode())
+              .plan(
+                  PlanBuilder()
+                      .values(vectors)
+                      .orderBy({"c0 ASC NULLS LAST"}, false)
+                      .capturePlanNodeId(orderByNodeId)
+                      .planNode())
               .assertResults("SELECT * FROM tmp ORDER BY c0 ASC NULLS LAST");
       auto taskStats = exec::toPlanStats(task->taskStats());
       auto& stats = taskStats.at(orderByNodeId);
@@ -607,12 +616,13 @@ DEBUG_ONLY_TEST_P(SharedArbitrationTestWithThreadingModes, reclaimToOrderBy) {
           newQueryBuilder()
               .queryCtx(fakeMemoryQueryCtx)
               .serialExecution(isSerialExecutionMode_)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .addNode([&](std::string id, core::PlanNodePtr input) {
-                          return std::make_shared<FakeMemoryNode>(id, input);
-                        })
-                        .planNode())
+              .plan(
+                  PlanBuilder()
+                      .values(vectors)
+                      .addNode([&](std::string id, core::PlanNodePtr input) {
+                        return std::make_shared<FakeMemoryNode>(id, input);
+                      })
+                      .planNode())
               .assertResults("SELECT * FROM tmp");
     });
 
@@ -691,11 +701,12 @@ DEBUG_ONLY_TEST_P(
           newQueryBuilder()
               .queryCtx(aggregationQueryCtx)
               .serialExecution(isSerialExecutionMode_)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                        .capturePlanNodeId(aggregationNodeId)
-                        .planNode())
+              .plan(
+                  PlanBuilder()
+                      .values(vectors)
+                      .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                      .capturePlanNodeId(aggregationNodeId)
+                      .planNode())
               .assertResults(
                   "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
       auto taskStats = exec::toPlanStats(task->taskStats());
@@ -709,12 +720,13 @@ DEBUG_ONLY_TEST_P(
           newQueryBuilder()
               .queryCtx(fakeMemoryQueryCtx)
               .serialExecution(isSerialExecutionMode_)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .addNode([&](std::string id, core::PlanNodePtr input) {
-                          return std::make_shared<FakeMemoryNode>(id, input);
-                        })
-                        .planNode())
+              .plan(
+                  PlanBuilder()
+                      .values(vectors)
+                      .addNode([&](std::string id, core::PlanNodePtr input) {
+                        return std::make_shared<FakeMemoryNode>(id, input);
+                      })
+                      .planNode())
               .assertResults("SELECT * FROM tmp");
     });
 
@@ -755,7 +767,7 @@ DEBUG_ONLY_TEST_P(
     folly::EventCount taskPauseWait;
     auto taskPauseWaitKey = taskPauseWait.prepareWait();
 
-    const auto fakeAllocationSize = kMemoryCapacity - (32L << 20);
+    const auto fakeAllocationSize = kMemoryCapacity - (2L << 20);
 
     std::atomic<bool> injectAllocationOnce{true};
     fakeOperatorFactory_->setAllocationCallback([&](Operator* op) {
@@ -822,12 +834,13 @@ DEBUG_ONLY_TEST_P(
           newQueryBuilder()
               .queryCtx(fakeMemoryQueryCtx)
               .serialExecution(isSerialExecutionMode_)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .addNode([&](std::string id, core::PlanNodePtr input) {
-                          return std::make_shared<FakeMemoryNode>(id, input);
-                        })
-                        .planNode())
+              .plan(
+                  PlanBuilder()
+                      .values(vectors)
+                      .addNode([&](std::string id, core::PlanNodePtr input) {
+                        return std::make_shared<FakeMemoryNode>(id, input);
+                      })
+                      .planNode())
               .assertResults("SELECT * FROM tmp");
     });
 
@@ -940,7 +953,7 @@ DEBUG_ONLY_TEST_P(
       })));
 
   const int numDrivers = 1;
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  const auto spillDirectory = TempDirectoryPath::create();
   std::thread queryThread([&]() {
     VELOX_ASSERT_THROW(
         newQueryBuilder()
@@ -950,12 +963,13 @@ DEBUG_ONLY_TEST_P(
             .config(core::QueryConfig::kJoinSpillEnabled, "true")
             .config(core::QueryConfig::kSpillNumPartitionBits, "2")
             .maxDrivers(numDrivers)
-            .plan(PlanBuilder()
-                      .values(vectors)
-                      .localPartition({"c0", "c1"})
-                      .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                      .localPartition(std::vector<std::string>{})
-                      .planNode())
+            .plan(
+                PlanBuilder()
+                    .values(vectors)
+                    .localPartition({"c0", "c1"})
+                    .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                    .localPartition(std::vector<std::string>{})
+                    .planNode())
             .assertResults(
                 "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1"),
         "Aborted for external error");
@@ -1013,7 +1027,7 @@ DEBUG_ONLY_TEST_P(
             [&]() { return aggregationAllocationUnblocked.load(); });
       })));
 
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  const auto spillDirectory = TempDirectoryPath::create();
   std::shared_ptr<Task> task;
   std::thread queryThread([&]() {
     task = newQueryBuilder()
@@ -1022,12 +1036,13 @@ DEBUG_ONLY_TEST_P(
                .config(core::QueryConfig::kSpillEnabled, "true")
                .config(core::QueryConfig::kJoinSpillEnabled, "true")
                .config(core::QueryConfig::kSpillNumPartitionBits, "2")
-               .plan(PlanBuilder()
-                         .values(vectors)
-                         .localPartition({"c0", "c1"})
-                         .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                         .localPartition(std::vector<std::string>{})
-                         .planNode())
+               .plan(
+                   PlanBuilder()
+                       .values(vectors)
+                       .localPartition({"c0", "c1"})
+                       .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                       .localPartition(std::vector<std::string>{})
+                       .planNode())
                .assertResults(
                    "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
   });
@@ -1083,7 +1098,7 @@ DEBUG_ONLY_TEST_P(SharedArbitrationTestWithThreadingModes, runtimeStats) {
             values->pool()->free(buffer, fakeAllocationSize);
           })));
 
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  const auto spillDirectory = TempDirectoryPath::create();
   const auto outputDirectory = TempDirectoryPath::create();
   const auto queryCtx =
       newQueryCtx(memoryManager_.get(), executor_.get(), memoryCapacity);
@@ -1194,23 +1209,25 @@ DEBUG_ONLY_TEST_P(
       if (sameDriver) {
         task = newQueryBuilder()
                    .queryCtx(queryCtx)
-                   .plan(PlanBuilder()
-                             .values(vectors)
-                             .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                             .capturePlanNodeId(aggregationNodeId)
-                             .localPartition(std::vector<std::string>{})
-                             .planNode())
+                   .plan(
+                       PlanBuilder()
+                           .values(vectors)
+                           .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                           .capturePlanNodeId(aggregationNodeId)
+                           .localPartition(std::vector<std::string>{})
+                           .planNode())
                    .assertResults(
                        "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
       } else {
         task = newQueryBuilder()
                    .queryCtx(queryCtx)
-                   .plan(PlanBuilder()
-                             .values(vectors)
-                             .localPartition({"c0", "c1"})
-                             .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                             .capturePlanNodeId(aggregationNodeId)
-                             .planNode())
+                   .plan(
+                       PlanBuilder()
+                           .values(vectors)
+                           .localPartition({"c0", "c1"})
+                           .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                           .capturePlanNodeId(aggregationNodeId)
+                           .planNode())
                    .assertResults(
                        "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
       }
@@ -1369,6 +1386,7 @@ TEST_P(
           if (e.errorCode() != error_code::kMemCapExceeded.c_str() &&
               e.errorCode() != error_code::kMemAborted.c_str() &&
               e.errorCode() != error_code::kMemAllocError.c_str() &&
+              e.errorCode() != error_code::kMemArbitrationTimeout.c_str() &&
               (e.message() != "Aborted for external error")) {
             std::rethrow_exception(std::current_exception());
           }
@@ -1424,12 +1442,20 @@ TEST_P(SharedArbitrationTestWithThreadingModes, reserveReleaseCounters) {
 VELOX_INSTANTIATE_TEST_SUITE_P(
     SharedArbitrationTest,
     SharedArbitrationTestWithParallelExecutionModeOnly,
-    testing::ValuesIn(std::vector<TestParam>{{false}}));
+    testing::ValuesIn(std::vector<TestParam>{{false}}),
+    [](const testing::TestParamInfo<TestParam>& info) {
+      return fmt::format(
+          "{}", info.param.isSerialExecutionMode ? "serial" : "parallel");
+    });
 
 VELOX_INSTANTIATE_TEST_SUITE_P(
     SharedArbitrationTest,
     SharedArbitrationTestWithThreadingModes,
-    testing::ValuesIn(std::vector<TestParam>{{false}, {true}}));
+    testing::ValuesIn(std::vector<TestParam>{{false}, {true}}),
+    [](const testing::TestParamInfo<TestParam>& info) {
+      return fmt::format(
+          "{}", info.param.isSerialExecutionMode ? "serial" : "parallel");
+    });
 } // namespace facebook::velox::memory
 
 int main(int argc, char** argv) {
diff --git a/velox/common/memory/tests/StreamArenaTest.cpp b/velox/common/memory/tests/StreamArenaTest.cpp
index d8db86a468b..9caa06a6ef3 100644
--- a/velox/common/memory/tests/StreamArenaTest.cpp
+++ b/velox/common/memory/tests/StreamArenaTest.cpp
@@ -127,9 +127,11 @@ TEST_F(StreamArenaTest, randomRange) {
   ByteRange range;
   for (int i = 0; i < numRanges; ++i) {
     if (folly::Random::oneIn(3)) {
-      const int requestSize =
-          AllocationTraits::pageBytes(pool_->largestSizeClass()) +
-          (folly::Random::rand32() % (4 << 20));
+      const int requestSize = std::min(
+          static_cast<int>(
+              AllocationTraits::pageBytes(pool_->largestSizeClass()) +
+              (folly::Random::rand32() % (4 << 20))),
+          2 << 20);
       arena->newRange(requestSize, nullptr, &range);
       ASSERT_EQ(AllocationTraits::roundUpPageBytes(requestSize), range.size);
     } else {
diff --git a/velox/common/process/CMakeLists.txt b/velox/common/process/CMakeLists.txt
index 2fb856caa54..2c4dc583a53 100644
--- a/velox/common/process/CMakeLists.txt
+++ b/velox/common/process/CMakeLists.txt
@@ -19,6 +19,13 @@ velox_add_library(
   ThreadDebugInfo.cpp
   TraceContext.cpp
   TraceHistory.cpp
+  HEADERS
+  ProcessBase.h
+  StackTrace.h
+  ThreadDebugInfo.h
+  ThreadLocalRegistry.h
+  TraceContext.h
+  TraceHistory.h
 )
 
 velox_link_libraries(
@@ -29,6 +36,7 @@ velox_link_libraries(
 
 # Profiler need not be part of the core Velox library
 add_library(velox_profiler OBJECT Profiler.cpp)
+velox_add_test_headers(velox_profiler Profiler.h)
 target_link_libraries(
   velox_profiler
   PUBLIC velox_flag_definitions Folly::folly
diff --git a/velox/common/process/Profiler.cpp b/velox/common/process/Profiler.cpp
index 82a5e836526..012c3ce3524 100644
--- a/velox/common/process/Profiler.cpp
+++ b/velox/common/process/Profiler.cpp
@@ -153,12 +153,13 @@ void Profiler::copyToResult(const std::string* data) {
     auto now = nowSeconds();
     auto elapsed = (now - sampleStartTime_);
     auto cpu = cpuSeconds();
-    out->append(fmt::format(
-        "Profile from {} to {} at {}% CPU\n\n",
+    out->append(
+        fmt::format(
+            "Profile from {} to {} at {}% CPU\n\n",
 
-        timeString(sampleStartTime_),
-        timeString(now),
-        100 * (cpu - cpuAtSampleStart_) / std::max<int64_t>(1, elapsed)));
+            timeString(sampleStartTime_),
+            timeString(now),
+            100 * (cpu - cpuAtSampleStart_) / std::max<int64_t>(1, elapsed)));
     out->append(std::string_view(buffer, resultSize));
     if (extraReport_) {
       std::string extra = extraReport_();
@@ -191,18 +192,19 @@ std::thread Profiler::startSample() {
     // and killing it with SIGINT produces a corrupt perf.data
     // file. The perf.data file generated when called via system() is
     // good, though. Unsolved mystery.
-    system(fmt::format(
-               "(cd {}; /usr/bin/perf record --pid {} {};"
-               "perf report --sort symbol > perf ;"
-               "sed --in-place 's/          / /'g perf;"
-               "sed --in-place 's/        / /'g perf; date) "
-               ">> {}/perftrace 2>>{}/perftrace2",
-               FLAGS_profiler_tmp_dir,
-               getpid(),
-               FLAGS_profiler_perf_flags,
-               FLAGS_profiler_tmp_dir,
-               FLAGS_profiler_tmp_dir)
-               .c_str()); // NOLINT
+    system(
+        fmt::format(
+            "(cd {}; /usr/bin/perf record --pid {} {};"
+            "perf report --sort symbol > perf ;"
+            "sed --in-place 's/          / /'g perf;"
+            "sed --in-place 's/        / /'g perf; date) "
+            ">> {}/perftrace 2>>{}/perftrace2",
+            FLAGS_profiler_tmp_dir,
+            getpid(),
+            FLAGS_profiler_perf_flags,
+            FLAGS_profiler_tmp_dir,
+            FLAGS_profiler_tmp_dir)
+            .c_str()); // NOLINT
     if (shouldSaveResult_) {
       copyToResult();
     }
diff --git a/velox/common/process/StackTrace.cpp b/velox/common/process/StackTrace.cpp
index 05da291a4c9..30738249985 100644
--- a/velox/common/process/StackTrace.cpp
+++ b/velox/common/process/StackTrace.cpp
@@ -30,12 +30,12 @@
 #include <fmt/format.h>
 #include <folly/Indestructible.h>
 #include <folly/String.h>
-#include <folly/experimental/symbolizer/StackTrace.h>
+#include <folly/debugging/symbolizer/StackTrace.h>
 
 #include "velox/common/process/ProcessBase.h"
 
 #ifdef __linux__
-#include <folly/experimental/symbolizer/Symbolizer.h> // @manual
+#include <folly/debugging/symbolizer/Symbolizer.h> // @manual
 #include <folly/fibers/FiberManager.h> // @manual
 #endif
 
@@ -96,7 +96,7 @@ const std::vector<std::string>& StackTrace::toStrVector() const {
     btVector_.reserve(btPtrs_.size());
     for (auto ptr : btPtrs_) {
       auto framename = translateFrame(ptr);
-      if (folly::StringPiece(framename).startsWith(*myname)) {
+      if (framename.starts_with(*myname)) {
         continue; // ignore frames in the StackTrace class
       }
       btVector_.push_back(fmt::format("# {:<2d} {}", frame++, framename));
diff --git a/velox/common/process/ThreadDebugInfo.cpp b/velox/common/process/ThreadDebugInfo.cpp
index ae681a2dcc4..2502572c7c3 100644
--- a/velox/common/process/ThreadDebugInfo.cpp
+++ b/velox/common/process/ThreadDebugInfo.cpp
@@ -16,7 +16,7 @@
 
 #include "velox/common/process/ThreadDebugInfo.h"
 
-#include <folly/experimental/symbolizer/SignalHandler.h>
+#include <folly/debugging/symbolizer/SignalHandler.h>
 #include <glog/logging.h>
 
 namespace facebook::velox::process {
diff --git a/velox/common/rpc/CMakeLists.txt b/velox/common/rpc/CMakeLists.txt
new file mode 100644
index 00000000000..c19c3927ac1
--- /dev/null
+++ b/velox/common/rpc/CMakeLists.txt
@@ -0,0 +1,31 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+velox_install_library_headers()
+
+velox_add_library(velox_rpc_types INTERFACE RPCTypes.h)
+
+velox_add_library(velox_rpc_client INTERFACE IRPCClient.h)
+
+velox_link_libraries(velox_rpc_client INTERFACE velox_rpc_types Folly::folly)
+
+velox_add_library(velox_mock_rpc_client clients/MockRPCClient.cpp HEADERS clients/MockRPCClient.h)
+
+velox_link_libraries(
+  velox_mock_rpc_client
+  velox_rpc_client
+  velox_common_base
+  velox_exception
+  Folly::folly
+)
diff --git a/velox/common/rpc/IRPCClient.h b/velox/common/rpc/IRPCClient.h
new file mode 100644
index 00000000000..02e2666fb32
--- /dev/null
+++ b/velox/common/rpc/IRPCClient.h
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <folly/futures/Future.h>
+
+#include "velox/common/rpc/RPCTypes.h"
+
+namespace facebook::velox::core {
+class QueryConfig;
+} // namespace facebook::velox::core
+
+namespace facebook::velox::rpc {
+
+/// Interface for RPC clients (transport layer).
+///
+/// IRPCClient is concerned with how to send requests and receive responses
+/// over the network. It is decoupled from the business logic — domain-specific
+/// request/response formatting is handled by AsyncRPCFunction (in
+/// velox/expression/rpc/).
+///
+/// Implementations provide the actual transport (e.g., Thrift, gRPC, mock).
+///
+/// Thread safety: Implementations MUST be thread-safe for concurrent calls.
+/// The operator may dispatch multiple RPCs concurrently from a single thread,
+/// and completion callbacks run on the client's executor threads.
+class IRPCClient {
+ public:
+  virtual ~IRPCClient() = default;
+
+  /// Execute a single RPC call asynchronously.
+  /// @param request The request to send.
+  /// @return A SemiFuture that will contain the response when complete.
+  virtual folly::SemiFuture<RPCResponse> call(const RPCRequest& request) = 0;
+
+  /// Execute a batch of RPC calls as a single request.
+  /// Default implementation fans out to individual call()s.
+  /// Override for backends that support native batching (e.g., batch
+  /// inference).
+  /// @param requests The batch of requests to send.
+  /// @return A SemiFuture that will contain all responses when complete.
+  virtual folly::SemiFuture<std::vector<RPCResponse>> callBatch(
+      const std::vector<RPCRequest>& requests) {
+    std::vector<folly::SemiFuture<RPCResponse>> futures;
+    futures.reserve(requests.size());
+    for (const auto& request : requests) {
+      futures.push_back(call(request));
+    }
+    // Capture rowIds to preserve them in error responses.
+    std::vector<int64_t> rowIds;
+    rowIds.reserve(requests.size());
+    for (const auto& request : requests) {
+      rowIds.push_back(request.rowId);
+    }
+    return folly::collectAll(std::move(futures))
+        .deferValue([rowIds = std::move(rowIds)](
+                        std::vector<folly::Try<RPCResponse>> tries) {
+          std::vector<RPCResponse> responses;
+          responses.reserve(tries.size());
+          for (size_t i = 0; i < tries.size(); ++i) {
+            if (tries[i].hasValue()) {
+              responses.push_back(std::move(tries[i].value()));
+            } else {
+              RPCResponse errorResp;
+              errorResp.rowId = rowIds[i];
+              errorResp.error = tries[i].exception().what().toStdString();
+              responses.push_back(std::move(errorResp));
+            }
+          }
+          return responses;
+        });
+  }
+
+  /// Returns the service tier key for rate limiting (e.g.,
+  /// "service.backend.prod"). Requests from clients sharing the same tier key
+  /// share a concurrency budget in RPCRateLimiter.
+  /// Empty string means "no tier configured" — uses the global default limit.
+  virtual std::string tierKey() const {
+    return "";
+  }
+
+  /// Set the query config for session-level parameters.
+  /// Called by the operator before dispatching RPCs.
+  virtual void setQueryConfig(const core::QueryConfig* /*config*/) {}
+};
+
+} // namespace facebook::velox::rpc
diff --git a/velox/common/rpc/RPCTypes.h b/velox/common/rpc/RPCTypes.h
new file mode 100644
index 00000000000..f2ffbfccccc
--- /dev/null
+++ b/velox/common/rpc/RPCTypes.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <map>
+#include <optional>
+#include <string>
+#include <string_view>
+
+#include "velox/vector/TypeAliases.h"
+
+namespace facebook::velox::rpc {
+
+/// Well-known option key constants for RPCRequest.options.
+/// Use these instead of raw string literals to prevent typo bugs.
+namespace keys {
+inline constexpr std::string_view kModel = "model";
+inline constexpr std::string_view kTemperature = "temperature";
+inline constexpr std::string_view kMaxTokens = "max_tokens";
+inline constexpr std::string_view kSystemPrompt = "systemPrompt";
+inline constexpr std::string_view kJsonSchema = "json_schema";
+inline constexpr std::string_view kMetagenKey = "metagen_key";
+inline constexpr std::string_view kTierOverride = "tier_override";
+inline constexpr std::string_view kCatToken = "cat_token";
+inline constexpr std::string_view kPollIntervalMs = "poll_interval_ms";
+inline constexpr std::string_view kOwnerUnixname = "owner_unixname";
+inline constexpr std::string_view kIsQuery = "is_query";
+inline constexpr std::string_view kPrefixDim = "prefix_dim";
+} // namespace keys
+
+/// Streaming mode for RPC execution.
+/// Controls how RPC results are emitted to downstream operators.
+enum class RPCStreamingMode {
+  /// Emit rows as they complete individually (default).
+  /// Lower tail latency for high-variance workloads (e.g., LLM).
+  kPerRow,
+
+  /// Wait for all rows in batch before emitting.
+  /// Lower overhead, useful for uniform-latency workloads.
+  kBatch
+};
+
+/// Parse streaming mode from config string.
+/// Returns kPerRow (default) unless explicitly set to "batch".
+inline RPCStreamingMode parseStreamingMode(const std::string& value) {
+  if (value == "batch") {
+    return RPCStreamingMode::kBatch;
+  }
+  return RPCStreamingMode::kPerRow;
+}
+
+/// Generic request structure for RPC calls.
+/// This is a minimal, domain-agnostic structure that works for any backend.
+/// Domain-specific formatting (e.g., LLM prompts, embedding inputs) is handled
+/// by the plan node's buildRequests() method.
+struct RPCRequest {
+  /// Row ID for tracking which row this request belongs to.
+  /// This is a globally unique ID assigned by the operator.
+  int64_t rowId{0};
+
+  /// Original row index in the input batch.
+  /// This is used to slice the correct row from input columns when storing
+  /// passthrough data. Unlike rowId (which is globally unique across batches),
+  /// this is the index within the current input batch and is set by
+  /// prepareRequests() based on the SelectivityVector iteration.
+  /// CRITICAL: When prepareRequests() skips null rows, originalRowIndex
+  /// tracks the actual input position to avoid slicing mismatch.
+  vector_size_t originalRowIndex{0};
+
+  /// Whether this row has a null primary input.
+  /// When true, the transport should short-circuit and return an error
+  /// response so that buildOutput() produces SQL NULL for this row.
+  /// Replaces the former "__null_input" magic string in options.
+  bool isNull{false};
+
+  /// The request payload (opaque to the framework).
+  std::string payload;
+
+  /// Type-safe options for backend-specific parameters.
+  std::map<std::string, std::string> options;
+};
+
+/// Generic response structure from RPC calls.
+/// This is a minimal, domain-agnostic structure that works for any backend.
+struct RPCResponse {
+  /// Row ID for correlating response with the original request.
+  int64_t rowId{0};
+
+  /// The response result (opaque to the framework).
+  std::string result;
+
+  /// Type-safe metadata from the backend.
+  std::map<std::string, std::string> metadata;
+
+  /// Error message if the request failed.
+  std::optional<std::string> error;
+
+  /// Returns true if this response represents an error.
+  bool hasError() const {
+    return error.has_value();
+  }
+};
+
+} // namespace facebook::velox::rpc
diff --git a/velox/common/rpc/clients/MockRPCClient.cpp b/velox/common/rpc/clients/MockRPCClient.cpp
new file mode 100644
index 00000000000..2a266a2c686
--- /dev/null
+++ b/velox/common/rpc/clients/MockRPCClient.cpp
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/rpc/clients/MockRPCClient.h"
+
+#include <folly/futures/Future.h>
+#include <folly/futures/Promise.h>
+
+namespace facebook::velox::rpc {
+
+namespace {
+// Function-local static pattern for thread-local RNG to avoid
+// NonPodStaticDeclaration lint warning.
+std::mt19937& threadLocalRng() {
+  thread_local std::mt19937 rng{std::random_device{}()};
+  return rng;
+}
+} // namespace
+
+MockRPCClient::MockRPCClient(
+    std::chrono::milliseconds latency,
+    double errorRate,
+    std::shared_ptr<folly::CPUThreadPoolExecutor> executor)
+    : latency_(latency), errorRate_(errorRate) {
+  if (executor) {
+    executor_ = std::move(executor);
+  } else {
+    ownedExecutor_ = std::make_shared<folly::CPUThreadPoolExecutor>(4);
+    executor_ = ownedExecutor_;
+  }
+}
+
+MockRPCClient::~MockRPCClient() = default;
+
+RPCResponse MockRPCClient::generateResponse(
+    const RPCRequest& request,
+    bool isError) {
+  if (isError) {
+    return RPCResponse{
+        .rowId = request.rowId,
+        .result = "",
+        .metadata = {},
+        .error = "Simulated error for row " + std::to_string(request.rowId)};
+  }
+
+  // Generate a mock response
+  std::string responseText = "Response for: ";
+  if (request.payload.size() > 30) {
+    responseText += request.payload.substr(0, 30) + "...";
+  } else {
+    responseText += request.payload;
+  }
+
+  return RPCResponse{
+      .rowId = request.rowId,
+      .result = std::move(responseText),
+      .metadata = {},
+      .error = std::nullopt};
+}
+
+folly::SemiFuture<RPCResponse> MockRPCClient::call(const RPCRequest& request) {
+  callCount_.fetch_add(1);
+
+  // Determine if this request should fail
+  std::uniform_real_distribution<double> dist(0.0, 1.0);
+  bool shouldError = dist(threadLocalRng()) < errorRate_;
+
+  // Use folly::via with the thread pool executor for safe async execution
+  return folly::via(
+      executor_.get(),
+      [this, request = request, shouldError, latency = latency_]()
+          -> RPCResponse {
+        // Simulate network latency
+        /* sleep override */ std::this_thread::sleep_for(latency);
+        // Generate and return the response
+        return generateResponse(request, shouldError);
+      });
+}
+
+folly::SemiFuture<std::vector<RPCResponse>> MockRPCClient::callBatch(
+    const std::vector<RPCRequest>& requests) {
+  // Capture error rate for thread safety
+  double errorRate = errorRate_;
+
+  // Use folly::via with the thread pool executor for safe async execution
+  return folly::via(
+      executor_.get(),
+      [this, requests, errorRate, latency = latency_]()
+          -> std::vector<RPCResponse> {
+        // Simulate network latency (single batch = single latency)
+        /* sleep override */ std::this_thread::sleep_for(latency);
+
+        std::vector<RPCResponse> responses;
+        responses.reserve(requests.size());
+
+        // Create RNG inside lambda to avoid thread-local access issues.
+        // Each executor thread will have its own properly initialized RNG.
+        thread_local std::mt19937 localRng{std::random_device{}()};
+        std::uniform_real_distribution<double> dist(0.0, 1.0);
+
+        for (const auto& request : requests) {
+          callCount_.fetch_add(1);
+          bool shouldError = dist(localRng) < errorRate;
+          responses.push_back(generateResponse(request, shouldError));
+        }
+
+        return responses;
+      });
+}
+
+} // namespace facebook::velox::rpc
diff --git a/velox/common/rpc/clients/MockRPCClient.h b/velox/common/rpc/clients/MockRPCClient.h
new file mode 100644
index 00000000000..417196701cb
--- /dev/null
+++ b/velox/common/rpc/clients/MockRPCClient.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <atomic>
+#include <chrono>
+#include <random>
+
+#include <folly/executors/CPUThreadPoolExecutor.h>
+
+#include "velox/common/rpc/IRPCClient.h"
+
+namespace facebook::velox::rpc {
+
+/// Mock RPC client that simulates backend latency for testing.
+/// Thread-safe for concurrent use. Uses a thread pool executor for async
+/// execution — either a shared executor passed in, or a local one created
+/// per-client.
+class MockRPCClient : public IRPCClient {
+ public:
+  /// Creates a mock client with configurable latency and error rate.
+  /// @param latency Simulated RPC latency (default 200ms).
+  /// @param errorRate Probability of error per request (0.0-1.0, default 0).
+  /// @param executor Shared executor for async work. If nullptr, creates a
+  ///   local thread pool. Pass a shared executor for global throttling across
+  ///   query instances.
+  explicit MockRPCClient(
+      std::chrono::milliseconds latency = std::chrono::milliseconds(200),
+      double errorRate = 0.0,
+      std::shared_ptr<folly::CPUThreadPoolExecutor> executor = nullptr);
+
+  ~MockRPCClient() override;
+
+  folly::SemiFuture<RPCResponse> call(const RPCRequest& request) override;
+
+  folly::SemiFuture<std::vector<RPCResponse>> callBatch(
+      const std::vector<RPCRequest>& requests) override;
+
+  /// Returns the total number of RPC calls made.
+  int64_t callCount() const {
+    return callCount_.load();
+  }
+
+  /// Resets the call counter.
+  void resetCallCount() {
+    callCount_.store(0);
+  }
+
+ private:
+  RPCResponse generateResponse(const RPCRequest& request, bool isError);
+
+  const std::chrono::milliseconds latency_;
+  const double errorRate_;
+  std::atomic<int64_t> callCount_{0};
+
+  /// Shared executor (may be shared across clients for global throttling).
+  std::shared_ptr<folly::CPUThreadPoolExecutor> executor_;
+  /// Locally-owned executor (created when no shared executor is provided).
+  std::shared_ptr<folly::CPUThreadPoolExecutor> ownedExecutor_;
+};
+
+} // namespace facebook::velox::rpc
diff --git a/velox/common/serialization/CMakeLists.txt b/velox/common/serialization/CMakeLists.txt
index 772987a61f3..9aad6dc4b26 100644
--- a/velox/common/serialization/CMakeLists.txt
+++ b/velox/common/serialization/CMakeLists.txt
@@ -12,7 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_serialization DeserializationRegistry.cpp)
+velox_add_library(
+  velox_serialization
+  DeserializationRegistry.cpp
+  HEADERS
+  DeserializationRegistry.h
+  Registry.h
+  Serializable.h
+)
 
 velox_link_libraries(velox_serialization PUBLIC velox_exception Folly::folly glog::glog)
 
diff --git a/velox/common/serialization/DeserializationRegistry.h b/velox/common/serialization/DeserializationRegistry.h
index 78cbf41a9e2..c96b499ed52 100644
--- a/velox/common/serialization/DeserializationRegistry.h
+++ b/velox/common/serialization/DeserializationRegistry.h
@@ -53,6 +53,16 @@ struct is_templated_create<
     T,
     std::void_t<decltype(T::template create<T>(
         std::declval<folly::dynamic>()))>> : std::true_type {};
+
+template <class, class = void>
+struct is_templated_create_with_context : std::false_type {};
+
+template <class T>
+struct is_templated_create_with_context<
+    T,
+    std::void_t<decltype(T::template create<T>(
+        std::declval<folly::dynamic>(),
+        std::declval<void*>()))>> : std::true_type {};
 } // namespace detail
 
 template <class T>
@@ -66,5 +76,16 @@ void registerDeserializer() {
   }
 }
 
+template <class T>
+void registerDeserializerWithContext() {
+  if constexpr (detail::is_templated_create_with_context<T>::value) {
+    DeserializationWithContextRegistryForSharedPtr().Register(
+        T::getClassName(), T::template create<T>);
+  } else {
+    DeserializationWithContextRegistryForSharedPtr().Register(
+        T::getClassName(), T::create);
+  }
+}
+
 } // namespace velox
 } // namespace facebook
diff --git a/velox/common/serialization/Registry.h b/velox/common/serialization/Registry.h
index a290dd7ecd9..7029a2eda1f 100644
--- a/velox/common/serialization/Registry.h
+++ b/velox/common/serialization/Registry.h
@@ -114,7 +114,7 @@ class Registry {
         }
 
         VELOX_UNSUPPORTED(
-            typeid(ReturnType).name(), " is not nullable return type");
+            "{} is not nullable return type", typeid(ReturnType).name());
       }
       return it->second(types...);
     }
diff --git a/velox/common/serialization/Serializable.h b/velox/common/serialization/Serializable.h
index 3db8daf1976..148d12ae2c7 100644
--- a/velox/common/serialization/Serializable.h
+++ b/velox/common/serialization/Serializable.h
@@ -298,8 +298,7 @@ class ISerializable {
   }
 
   template <
-      template <typename, typename, typename...>
-      typename TMap,
+      template <typename, typename, typename...> typename TMap,
       typename TKey,
       typename TMapped,
       typename... TArgs,
diff --git a/velox/common/serialization/tests/SerializableTest.cpp b/velox/common/serialization/tests/SerializableTest.cpp
index 90b60852b9b..a9692a8da16 100644
--- a/velox/common/serialization/tests/SerializableTest.cpp
+++ b/velox/common/serialization/tests/SerializableTest.cpp
@@ -160,8 +160,7 @@ TEST(SerializableTest, context) {
 }
 
 template <
-    template <typename, typename, typename...>
-    typename TMap,
+    template <typename, typename, typename...> typename TMap,
     typename TKey,
     typename TMapped,
     typename TIt,
diff --git a/velox/functions/prestosql/geospatial/tests/CMakeLists.txt b/velox/common/tests/CMakeLists.txt
similarity index 77%
rename from velox/functions/prestosql/geospatial/tests/CMakeLists.txt
rename to velox/common/tests/CMakeLists.txt
index b2b460f3acc..a36ecf629bc 100644
--- a/velox/functions/prestosql/geospatial/tests/CMakeLists.txt
+++ b/velox/common/tests/CMakeLists.txt
@@ -11,17 +11,14 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
-if(VELOX_ENABLE_GEO)
-  add_executable(velox_geospatial_test GeometryFunctionsTest.cpp)
-endif()
-
-add_test(velox_geospatial_test velox_geospatial_test)
+add_executable(velox_scoped_registry_test ScopedRegistryTest.cpp)
+add_test(velox_scoped_registry_test velox_scoped_registry_test)
 
 target_link_libraries(
-  velox_geospatial_test
+  velox_scoped_registry_test
+  velox_common_base
+  GTest::gmock
   GTest::gtest
   GTest::gtest_main
-  GTest::gmock
-  GTest::gmock_main
+  Folly::folly
 )
diff --git a/velox/common/tests/ScopedRegistryTest.cpp b/velox/common/tests/ScopedRegistryTest.cpp
new file mode 100644
index 00000000000..2844fffdd67
--- /dev/null
+++ b/velox/common/tests/ScopedRegistryTest.cpp
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/ScopedRegistry.h"
+
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <utility>
+
+#include <gtest/gtest.h>
+
+namespace facebook::velox {
+namespace {
+
+// Minimal value type for testing.
+class TestEntry {
+ public:
+  explicit TestEntry(std::string name) : name_{std::move(name)} {}
+
+  const std::string& name() const {
+    return name_;
+  }
+
+ private:
+  std::string name_;
+};
+
+TEST(ScopedRegistryTest, insertAndFind) {
+  ScopedRegistry<std::string, TestEntry> registry;
+  auto entry = std::make_shared<TestEntry>("test-1");
+  registry.insert("test-1", entry);
+
+  EXPECT_EQ(registry.find("test-1"), entry);
+  EXPECT_EQ(registry.find("nonexistent"), nullptr);
+}
+
+TEST(ScopedRegistryTest, insertDuplicateThrows) {
+  ScopedRegistry<std::string, TestEntry> registry;
+  registry.insert("key", std::make_shared<TestEntry>("key"));
+
+  EXPECT_THROW(
+      registry.insert("key", std::make_shared<TestEntry>("key")),
+      VeloxRuntimeError);
+}
+
+TEST(ScopedRegistryTest, insertOverwrite) {
+  ScopedRegistry<std::string, TestEntry> registry;
+  auto first = std::make_shared<TestEntry>("first");
+  auto second = std::make_shared<TestEntry>("second");
+  registry.insert("key", first);
+  registry.insert("key", second, /*overwrite=*/true);
+
+  EXPECT_EQ(registry.find("key"), second);
+}
+
+TEST(ScopedRegistryTest, erase) {
+  ScopedRegistry<std::string, TestEntry> registry;
+  registry.insert("key", std::make_shared<TestEntry>("key"));
+
+  EXPECT_TRUE(registry.erase("key"));
+  EXPECT_EQ(registry.find("key"), nullptr);
+  EXPECT_FALSE(registry.erase("key"));
+}
+
+TEST(ScopedRegistryTest, clear) {
+  ScopedRegistry<std::string, TestEntry> registry;
+  registry.insert("a", std::make_shared<TestEntry>("a"));
+  registry.insert("b", std::make_shared<TestEntry>("b"));
+  registry.clear();
+
+  EXPECT_EQ(registry.find("a"), nullptr);
+  EXPECT_EQ(registry.find("b"), nullptr);
+}
+
+TEST(ScopedRegistryTest, snapshot) {
+  ScopedRegistry<std::string, TestEntry> registry;
+  registry.insert("a", std::make_shared<TestEntry>("a"));
+  registry.insert("b", std::make_shared<TestEntry>("b"));
+
+  auto entries = registry.snapshot();
+  EXPECT_EQ(entries.size(), 2);
+
+  std::set<std::string> keys;
+  for (const auto& [key, _] : entries) {
+    keys.insert(key);
+  }
+  EXPECT_EQ(keys.size(), 2);
+  EXPECT_TRUE(keys.count("a"));
+  EXPECT_TRUE(keys.count("b"));
+}
+
+TEST(ScopedRegistryTest, parentFallback) {
+  ScopedRegistry<std::string, TestEntry> parent;
+  auto entry = std::make_shared<TestEntry>("from-parent");
+  parent.insert("key", entry);
+
+  const ScopedRegistry<std::string, TestEntry> child(&parent);
+  EXPECT_EQ(child.find("key"), entry);
+}
+
+TEST(ScopedRegistryTest, childOverridesParent) {
+  ScopedRegistry<std::string, TestEntry> parent;
+  auto parentEntry = std::make_shared<TestEntry>("parent");
+  parent.insert("key", parentEntry);
+
+  ScopedRegistry<std::string, TestEntry> child(&parent);
+  auto childEntry = std::make_shared<TestEntry>("child");
+  child.insert("key", childEntry);
+
+  EXPECT_EQ(child.find("key"), childEntry);
+  EXPECT_EQ(parent.find("key"), parentEntry);
+}
+
+TEST(ScopedRegistryTest, childEraseDoesNotAffectParent) {
+  ScopedRegistry<std::string, TestEntry> parent;
+  auto entry = std::make_shared<TestEntry>("parent");
+  parent.insert("key", entry);
+
+  ScopedRegistry<std::string, TestEntry> child(&parent);
+  child.insert("key", std::make_shared<TestEntry>("child"));
+  child.erase("key");
+
+  // Child erased its own override; parent entry is still visible via fallback.
+  EXPECT_EQ(child.find("key"), entry);
+  EXPECT_EQ(parent.find("key"), entry);
+}
+
+TEST(ScopedRegistryTest, snapshotMergesParent) {
+  ScopedRegistry<std::string, TestEntry> parent;
+  parent.insert("a", std::make_shared<TestEntry>("a"));
+  parent.insert("b", std::make_shared<TestEntry>("b-parent"));
+
+  ScopedRegistry<std::string, TestEntry> child(&parent);
+  child.insert("b", std::make_shared<TestEntry>("b-child"));
+  child.insert("c", std::make_shared<TestEntry>("c"));
+
+  auto entries = child.snapshot();
+  EXPECT_EQ(entries.size(), 3);
+
+  std::map<std::string, std::string> snapshot;
+  for (const auto& [key, value] : entries) {
+    snapshot[key] = value->name();
+  }
+  EXPECT_EQ(snapshot["a"], "a");
+  EXPECT_EQ(snapshot["b"], "b-child");
+  EXPECT_EQ(snapshot["c"], "c");
+}
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/common/testutil/CMakeLists.txt b/velox/common/testutil/CMakeLists.txt
index 5b5dca326d9..efe4631817c 100644
--- a/velox/common/testutil/CMakeLists.txt
+++ b/velox/common/testutil/CMakeLists.txt
@@ -12,9 +12,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_test_util ScopedTestTime.cpp TestValue.cpp RandomSeed.cpp)
+velox_add_library(
+  velox_test_util
+  ScopedTestTime.cpp
+  TestValue.cpp
+  RandomSeed.cpp
+  TempFilePath.cpp
+  TempDirectoryPath.cpp
+  HEADERS
+  OptionalEmpty.h
+  RandomSeed.h
+  ScopedTestTime.h
+  TempDirectoryPath.h
+  TempFilePath.h
+  TestValue.h
+)
 
-velox_link_libraries(velox_test_util PUBLIC velox_exception PRIVATE glog::glog Folly::folly)
+velox_link_libraries(velox_test_util PUBLIC velox_exception Folly::folly PRIVATE glog::glog)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/exec/tests/utils/TempDirectoryPath.cpp b/velox/common/testutil/TempDirectoryPath.cpp
similarity index 90%
rename from velox/exec/tests/utils/TempDirectoryPath.cpp
rename to velox/common/testutil/TempDirectoryPath.cpp
index 358aa322964..5e63ac777df 100644
--- a/velox/exec/tests/utils/TempDirectoryPath.cpp
+++ b/velox/common/testutil/TempDirectoryPath.cpp
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 
 #include "boost/filesystem.hpp"
 
-namespace facebook::velox::exec::test {
+namespace facebook::velox::common::testutil {
 
 std::shared_ptr<TempDirectoryPath> TempDirectoryPath::create(bool injectFault) {
   auto* tempDirPath = new TempDirectoryPath(injectFault);
@@ -42,4 +42,4 @@ std::string TempDirectoryPath::createTempDirectory() {
   return tempDirectoryPath;
 }
 
-} // namespace facebook::velox::exec::test
+} // namespace facebook::velox::common::testutil
diff --git a/velox/common/testutil/TempDirectoryPath.h b/velox/common/testutil/TempDirectoryPath.h
new file mode 100644
index 00000000000..fb2476a8a6b
--- /dev/null
+++ b/velox/common/testutil/TempDirectoryPath.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <unistd.h>
+#include <cstdlib>
+#include <memory>
+#include <string>
+
+#include "velox/common/base/Exceptions.h"
+
+namespace facebook::velox::common::testutil {
+
+/// Manages the lifetime of a temporary directory.
+class TempDirectoryPath {
+ public:
+  /// If 'enableFaultInjection' is true, we enable fault injection on the
+  /// created file directory.
+  static std::shared_ptr<TempDirectoryPath> create(
+      bool enableFaultInjection = false);
+
+  virtual ~TempDirectoryPath();
+
+  TempDirectoryPath(const TempDirectoryPath&) = delete;
+  TempDirectoryPath& operator=(const TempDirectoryPath&) = delete;
+
+  /// If fault injection is enabled, the returned file path will have the faulty
+  /// file system prefix scheme. The velox fs then opens the directory through
+  /// the faulty file system. The file operation will then either fail or be
+  /// delegated to the actual file.
+  const std::string& getPath() const {
+    return path_;
+  }
+
+  /// The actual file path if fault injection is enabled.
+  const std::string& getDelegatePath() const {
+    return tempPath_;
+  }
+
+ private:
+  static std::string createTempDirectory();
+
+  explicit TempDirectoryPath(bool enableFaultInjection)
+      : enableFaultInjection_(enableFaultInjection),
+        tempPath_(createTempDirectory()),
+        path_(
+            enableFaultInjection_ ? fmt::format("faulty:{}", tempPath_)
+                                  : tempPath_) {}
+
+  const bool enableFaultInjection_{false};
+  const std::string tempPath_;
+  const std::string path_;
+};
+} // namespace facebook::velox::common::testutil
diff --git a/velox/exec/tests/utils/TempFilePath.cpp b/velox/common/testutil/TempFilePath.cpp
similarity index 88%
rename from velox/exec/tests/utils/TempFilePath.cpp
rename to velox/common/testutil/TempFilePath.cpp
index 263abce930e..bb3ddd02edb 100644
--- a/velox/exec/tests/utils/TempFilePath.cpp
+++ b/velox/common/testutil/TempFilePath.cpp
@@ -14,13 +14,15 @@
  * limitations under the License.
  */
 
-#include "velox/exec/tests/utils/TempFilePath.h"
+#include "velox/common/testutil/TempFilePath.h"
 
-namespace facebook::velox::exec::test {
+namespace facebook::velox::common::testutil {
 
 TempFilePath::~TempFilePath() {
   ::unlink(tempPath_.c_str());
-  ::close(fd_);
+  if (fd_ != -1) {
+    ::close(fd_);
+  }
 }
 
 std::shared_ptr<TempFilePath> TempFilePath::create(bool enableFaultInjection) {
@@ -46,4 +48,4 @@ std::vector<std::string> toFilePaths(
   }
   return filePaths;
 }
-} // namespace facebook::velox::exec::test
+} // namespace facebook::velox::common::testutil
diff --git a/velox/common/testutil/TempFilePath.h b/velox/common/testutil/TempFilePath.h
new file mode 100644
index 00000000000..17a19be09ea
--- /dev/null
+++ b/velox/common/testutil/TempFilePath.h
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <sys/stat.h>
+#include <unistd.h>
+#include <cstdlib>
+#include <fstream>
+#include <memory>
+#include <string>
+
+#include "velox/common/base/Exceptions.h"
+
+namespace facebook::velox::common::testutil {
+
+/// Manages the lifetime of a temporary file.
+class TempFilePath {
+ public:
+  /// If 'enableFaultInjection' is true, we enable fault injection on the
+  /// created file.
+  static std::shared_ptr<TempFilePath> create(
+      bool enableFaultInjection = false);
+
+  ~TempFilePath();
+
+  TempFilePath(const TempFilePath&) = delete;
+  TempFilePath& operator=(const TempFilePath&) = delete;
+
+  void append(const std::string& data) {
+    std::ofstream file(tempPath_, std::ios_base::app);
+    file << data;
+    file.flush();
+    file.close();
+  }
+
+  int64_t fileSize() {
+    struct stat st{};
+    ::stat(tempPath_.data(), &st);
+    return st.st_size;
+  }
+
+  int64_t fileModifiedTime() {
+    struct stat st{};
+    ::stat(tempPath_.data(), &st);
+    return st.st_mtime;
+  }
+
+  /// If fault injection is enabled, the returned the file path has the faulty
+  /// file system prefix scheme. The velox fs then opens the file through the
+  /// faulty file system. The actual file operation might either fails or
+  /// delegate to the actual file.
+  const std::string& getPath() const {
+    return path_;
+  }
+
+  // Returns the delegated file path if fault injection is enabled.
+  const std::string& tempFilePath() const {
+    return tempPath_;
+  }
+
+ private:
+  static std::string createTempFile(TempFilePath* tempFilePath);
+
+  explicit TempFilePath(bool enableFaultInjection)
+      : enableFaultInjection_(enableFaultInjection),
+        tempPath_(createTempFile(this)),
+        path_(
+            enableFaultInjection_ ? fmt::format("faulty:{}", tempPath_)
+                                  : tempPath_) {
+    VELOX_CHECK_NE(fd_, -1);
+  }
+
+  const bool enableFaultInjection_;
+  // initialized to -1 before tempPath_ is initialized,
+  // since members are initialized in declaration order
+  int fd_{-1};
+  const std::string tempPath_;
+  const std::string path_;
+};
+
+std::vector<std::string> toFilePaths(
+    const std::vector<std::shared_ptr<TempFilePath>>& tempFiles);
+
+} // namespace facebook::velox::common::testutil
diff --git a/velox/common/testutil/TestValue.cpp b/velox/common/testutil/TestValue.cpp
index b833b980ac4..bf14f66d807 100644
--- a/velox/common/testutil/TestValue.cpp
+++ b/velox/common/testutil/TestValue.cpp
@@ -20,7 +20,7 @@ namespace facebook::velox::common::testutil {
 
 std::mutex TestValue::mutex_;
 bool TestValue::enabled_ = false;
-std::unordered_map<std::string, TestValue::Callback> TestValue::injectionMap_;
+folly::F14FastMap<std::string, TestValue::Callback> TestValue::injectionMap_;
 
 #ifndef NDEBUG
 void TestValue::enable() {
@@ -38,12 +38,12 @@ bool TestValue::enabled() {
   return enabled_;
 }
 
-void TestValue::clear(const std::string& injectionPoint) {
+void TestValue::clear(std::string_view injectionPoint) {
   std::lock_guard<std::mutex> l(mutex_);
   injectionMap_.erase(injectionPoint);
 }
 
-void TestValue::adjust(const std::string& injectionPoint, void* testData) {
+void TestValue::adjust(std::string_view injectionPoint, void* testData) {
   Callback injectionCb;
   {
     std::lock_guard<std::mutex> l(mutex_);
@@ -60,7 +60,7 @@ void TestValue::disable() {}
 bool TestValue::enabled() {
   return false;
 }
-void TestValue::clear(const std::string& injectionPoint) {}
+void TestValue::clear(std::string_view injectionPoint) {}
 #endif
 
 } // namespace facebook::velox::common::testutil
diff --git a/velox/common/testutil/TestValue.h b/velox/common/testutil/TestValue.h
index ba988a6935b..321936bd67c 100644
--- a/velox/common/testutil/TestValue.h
+++ b/velox/common/testutil/TestValue.h
@@ -15,9 +15,10 @@
  */
 #pragma once
 
+#include <folly/container/F14Map.h>
 #include <mutex>
 #include <string>
-#include <unordered_map>
+#include <string_view>
 
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/Macros.h"
@@ -45,24 +46,24 @@ class TestValue {
   /// injected callback hook.
   template <typename T>
   static void set(
-      const std::string& injectionPoint,
+      std::string_view injectionPoint,
       std::function<void(T*)> injectionCb);
 
   /// Invoked by the test code to unregister a callback hook at the specified
   /// execution point.
-  static void clear(const std::string& injectionPoint);
+  static void clear(std::string_view injectionPoint);
 
   /// Invoked by the production code to try to invoke the test callback hook
   /// with 'testData' if there is one registered at the specified execution
   /// point. 'testData' capture the mutable production execution state.
-  static void adjust(const std::string& injectionPoint, void* testData);
+  static void adjust(std::string_view injectionPoint, void* testData);
 
  private:
   using Callback = std::function<void(void*)>;
 
   static std::mutex mutex_;
   static bool enabled_;
-  static std::unordered_map<std::string, Callback> injectionMap_;
+  static folly::F14FastMap<std::string, Callback> injectionMap_;
 };
 
 class ScopedTestValue {
@@ -79,13 +80,13 @@ class ScopedTestValue {
   }
 
  private:
-  const std::string point_;
+  std::string point_;
 };
 
 #ifndef NDEBUG
 template <typename T>
 void TestValue::set(
-    const std::string& injectionPoint,
+    std::string_view injectionPoint,
     std::function<void(T*)> injectionCb) {
   std::lock_guard<std::mutex> l(mutex_);
   if (!enabled_) {
@@ -99,15 +100,14 @@ void TestValue::set(
 #else
 template <typename T>
 void TestValue::set(
-    const std::string& injectionPoint,
+    std::string_view injectionPoint,
     std::function<void(T*)> injectionCb) {}
 #endif
 
 #ifdef NDEBUG
 // Keep the definition in header so that it can be inlined (elided).
-inline void TestValue::adjust(
-    const std::string& injectionPoint,
-    void* testData) {}
+inline void TestValue::adjust(std::string_view injectionPoint, void* testData) {
+}
 #endif
 
 #define SCOPED_TESTVALUE_SET(point, ...)                              \
diff --git a/velox/common/testutil/tests/CastsTest.cpp b/velox/common/testutil/tests/CastsTest.cpp
index 182c73ebeb6..b5a9cf60052 100644
--- a/velox/common/testutil/tests/CastsTest.cpp
+++ b/velox/common/testutil/tests/CastsTest.cpp
@@ -93,16 +93,16 @@ class CastsTest : public ::testing::Test {
   DerivedClass* derivedRawPtr_;
 };
 
-// Tests for checked_pointer_cast with shared_ptr
+// Tests for checkedPointerCast with shared_ptr
 TEST_F(CastsTest, checkedPointerCastSharedPtrSuccess) {
   // Cast derived to base (should always work)
-  auto result = checked_pointer_cast<BaseClass>(derivedPtr_);
+  auto result = checkedPointerCast<BaseClass>(derivedPtr_);
   EXPECT_NE(result, nullptr);
   EXPECT_EQ(result->getValue(), 100);
 
   // Cast base to derived when it actually is derived
   std::shared_ptr<BaseClass> basePtrToDerived = derivedPtr_;
-  auto derivedResult = checked_pointer_cast<DerivedClass>(basePtrToDerived);
+  auto derivedResult = checkedPointerCast<DerivedClass>(basePtrToDerived);
   EXPECT_NE(derivedResult, nullptr);
   EXPECT_EQ(derivedResult->getValue(), 100);
   EXPECT_EQ(derivedResult->getDerivedValue(), 200);
@@ -110,22 +110,22 @@ TEST_F(CastsTest, checkedPointerCastSharedPtrSuccess) {
 
 TEST_F(CastsTest, checkedPointerCastSharedPtrFailure) {
   // Try to cast base to derived when it's not actually derived
-  VELOX_ASSERT_THROW(checked_pointer_cast<DerivedClass>(basePtr_), "");
+  VELOX_ASSERT_THROW(checkedPointerCast<DerivedClass>(basePtr_), "");
 
   // Try to cast to unrelated class
-  VELOX_ASSERT_THROW(checked_pointer_cast<UnrelatedClass>(derivedPtr_), "");
+  VELOX_ASSERT_THROW(checkedPointerCast<UnrelatedClass>(derivedPtr_), "");
 }
 
 TEST_F(CastsTest, checkedPointerCastSharedPtrNullInput) {
   std::shared_ptr<BaseClass> nullPtr;
-  VELOX_ASSERT_THROW(checked_pointer_cast<DerivedClass>(nullPtr), "");
+  VELOX_ASSERT_THROW(checkedPointerCast<DerivedClass>(nullPtr), "");
 }
 
-// Tests for checked_pointer_cast with unique_ptr
+// Tests for checkedPointerCast with unique_ptr
 TEST_F(CastsTest, checkedPointerCastUniquePtrSuccess) {
   // Cast derived to base
   auto derivedForCast = std::make_unique<DerivedClass>();
-  auto result = checked_pointer_cast<BaseClass>(std::move(derivedForCast));
+  auto result = checkedPointerCast<BaseClass>(std::move(derivedForCast));
   EXPECT_NE(result, nullptr);
   EXPECT_EQ(result->getValue(), 100);
 
@@ -133,7 +133,7 @@ TEST_F(CastsTest, checkedPointerCastUniquePtrSuccess) {
   std::unique_ptr<BaseClass> basePtrToDerived =
       std::make_unique<DerivedClass>();
   auto derivedResult =
-      checked_pointer_cast<DerivedClass>(std::move(basePtrToDerived));
+      checkedPointerCast<DerivedClass>(std::move(basePtrToDerived));
   EXPECT_NE(derivedResult, nullptr);
   EXPECT_EQ(derivedResult->getValue(), 100);
   EXPECT_EQ(derivedResult->getDerivedValue(), 200);
@@ -143,25 +143,24 @@ TEST_F(CastsTest, checkedPointerCastUniquePtrFailure) {
   // Try to cast base to derived when it's not actually derived
   auto baseForCast = std::make_unique<BaseClass>();
   VELOX_ASSERT_THROW(
-      checked_pointer_cast<DerivedClass>(std::move(baseForCast)), "");
+      checkedPointerCast<DerivedClass>(std::move(baseForCast)), "");
 }
 
 TEST_F(CastsTest, checkedPointerCastUniquePtrNullInput) {
   std::unique_ptr<BaseClass> nullPtr;
-  VELOX_ASSERT_THROW(
-      checked_pointer_cast<DerivedClass>(std::move(nullPtr)), "");
+  VELOX_ASSERT_THROW(checkedPointerCast<DerivedClass>(std::move(nullPtr)), "");
 }
 
-// Tests for checked_pointer_cast with raw pointers
+// Tests for checkedPointerCast with raw pointers
 TEST_F(CastsTest, checkedPointerCastRawPtrSuccess) {
   // Cast derived to base
-  auto result = checked_pointer_cast<BaseClass>(derivedRawPtr_);
+  auto result = checkedPointerCast<BaseClass>(derivedRawPtr_);
   EXPECT_NE(result, nullptr);
   EXPECT_EQ(result->getValue(), 100);
 
   // Cast base to derived when it actually is derived
   BaseClass* basePtrToDerived = derivedRawPtr_;
-  auto derivedResult = checked_pointer_cast<DerivedClass>(basePtrToDerived);
+  auto derivedResult = checkedPointerCast<DerivedClass>(basePtrToDerived);
   EXPECT_NE(derivedResult, nullptr);
   EXPECT_EQ(derivedResult->getValue(), 100);
   EXPECT_EQ(derivedResult->getDerivedValue(), 200);
@@ -169,21 +168,20 @@ TEST_F(CastsTest, checkedPointerCastRawPtrSuccess) {
 
 TEST_F(CastsTest, checkedPointerCastRawPtrFailure) {
   // Try to cast base to derived when it's not actually derived
-  VELOX_ASSERT_THROW(checked_pointer_cast<DerivedClass>(baseRawPtr_), "");
+  VELOX_ASSERT_THROW(checkedPointerCast<DerivedClass>(baseRawPtr_), "");
 }
 
 TEST_F(CastsTest, checkedPointerCastRawPtrNullInput) {
   BaseClass* nullPtr = nullptr;
-  VELOX_ASSERT_THROW(checked_pointer_cast<DerivedClass>(nullPtr), "");
+  VELOX_ASSERT_THROW(checkedPointerCast<DerivedClass>(nullPtr), "");
 }
 
-// Tests for static_unique_pointer_cast
+// Tests for staticUniquePointerCast
 TEST_F(CastsTest, staticUniquePointerCastSuccess) {
   // Create a unique_ptr to derived and cast to base
   auto derivedForCast = std::make_unique<DerivedClass>();
   auto originalPtr = derivedForCast.get();
-  auto result =
-      static_unique_pointer_cast<BaseClass>(std::move(derivedForCast));
+  auto result = staticUniquePointerCast<BaseClass>(std::move(derivedForCast));
 
   EXPECT_NE(result, nullptr);
   EXPECT_EQ(result.get(), originalPtr); // Should be the same pointer
@@ -193,65 +191,65 @@ TEST_F(CastsTest, staticUniquePointerCastSuccess) {
 TEST_F(CastsTest, staticUniquePointerCastNullInput) {
   std::unique_ptr<DerivedClass> nullPtr;
   VELOX_ASSERT_THROW(
-      static_unique_pointer_cast<BaseClass>(std::move(nullPtr)), "");
+      staticUniquePointerCast<BaseClass>(std::move(nullPtr)), "");
 }
 
-// Tests for is_instance_of with shared_ptr
+// Tests for isInstanceOf with shared_ptr
 TEST_F(CastsTest, isInstanceOfSharedPtr) {
   // Test positive cases
-  EXPECT_TRUE(is_instance_of<BaseClass>(derivedPtr_));
-  EXPECT_TRUE(is_instance_of<DerivedClass>(derivedPtr_));
-  EXPECT_TRUE(is_instance_of<BaseClass>(anotherDerivedPtr_));
-  EXPECT_TRUE(is_instance_of<AnotherDerivedClass>(anotherDerivedPtr_));
+  EXPECT_TRUE(isInstanceOf<BaseClass>(derivedPtr_));
+  EXPECT_TRUE(isInstanceOf<DerivedClass>(derivedPtr_));
+  EXPECT_TRUE(isInstanceOf<BaseClass>(anotherDerivedPtr_));
+  EXPECT_TRUE(isInstanceOf<AnotherDerivedClass>(anotherDerivedPtr_));
 
   // Test negative cases
-  EXPECT_FALSE(is_instance_of<DerivedClass>(basePtr_));
-  EXPECT_FALSE(is_instance_of<AnotherDerivedClass>(derivedPtr_));
-  EXPECT_FALSE(is_instance_of<DerivedClass>(anotherDerivedPtr_));
-  EXPECT_FALSE(is_instance_of<UnrelatedClass>(derivedPtr_));
+  EXPECT_FALSE(isInstanceOf<DerivedClass>(basePtr_));
+  EXPECT_FALSE(isInstanceOf<AnotherDerivedClass>(derivedPtr_));
+  EXPECT_FALSE(isInstanceOf<DerivedClass>(anotherDerivedPtr_));
+  EXPECT_FALSE(isInstanceOf<UnrelatedClass>(derivedPtr_));
 }
 
 TEST_F(CastsTest, isInstanceOfSharedPtrNullInput) {
   std::shared_ptr<BaseClass> nullPtr;
-  VELOX_ASSERT_THROW(is_instance_of<DerivedClass>(nullPtr), "");
+  VELOX_ASSERT_THROW(isInstanceOf<DerivedClass>(nullPtr), "");
 }
 
-// Tests for is_instance_of with unique_ptr
+// Tests for isInstanceOf with unique_ptr
 TEST_F(CastsTest, isInstanceOfUniquePtr) {
   // Test positive cases
-  EXPECT_TRUE(is_instance_of<BaseClass>(derivedUniquePtr_));
-  EXPECT_TRUE(is_instance_of<DerivedClass>(derivedUniquePtr_));
+  EXPECT_TRUE(isInstanceOf<BaseClass>(derivedUniquePtr_));
+  EXPECT_TRUE(isInstanceOf<DerivedClass>(derivedUniquePtr_));
 
   // Test negative cases
-  EXPECT_FALSE(is_instance_of<DerivedClass>(baseUniquePtr_));
-  EXPECT_FALSE(is_instance_of<AnotherDerivedClass>(derivedUniquePtr_));
+  EXPECT_FALSE(isInstanceOf<DerivedClass>(baseUniquePtr_));
+  EXPECT_FALSE(isInstanceOf<AnotherDerivedClass>(derivedUniquePtr_));
 }
 
 TEST_F(CastsTest, isInstanceOfUniquePtrNullInput) {
   std::unique_ptr<BaseClass> nullPtr;
-  VELOX_ASSERT_THROW(is_instance_of<DerivedClass>(nullPtr), "");
+  VELOX_ASSERT_THROW(isInstanceOf<DerivedClass>(nullPtr), "");
 }
 
-// Tests for is_instance_of with raw pointers
+// Tests for isInstanceOf with raw pointers
 TEST_F(CastsTest, isInstanceOfRawPtr) {
   // Test positive cases
-  EXPECT_TRUE(is_instance_of<BaseClass>(derivedRawPtr_));
-  EXPECT_TRUE(is_instance_of<DerivedClass>(derivedRawPtr_));
+  EXPECT_TRUE(isInstanceOf<BaseClass>(derivedRawPtr_));
+  EXPECT_TRUE(isInstanceOf<DerivedClass>(derivedRawPtr_));
 
   // Test negative cases
-  EXPECT_FALSE(is_instance_of<DerivedClass>(baseRawPtr_));
-  EXPECT_FALSE(is_instance_of<AnotherDerivedClass>(derivedRawPtr_));
+  EXPECT_FALSE(isInstanceOf<DerivedClass>(baseRawPtr_));
+  EXPECT_FALSE(isInstanceOf<AnotherDerivedClass>(derivedRawPtr_));
 }
 
 TEST_F(CastsTest, isInstanceOfRawPtrNullInput) {
   BaseClass* nullPtr = nullptr;
-  VELOX_ASSERT_THROW(is_instance_of<DerivedClass>(nullPtr), "");
+  VELOX_ASSERT_THROW(isInstanceOf<DerivedClass>(nullPtr), "");
 }
 
 // Test error messages contain useful information
 TEST_F(CastsTest, errorMessageContent) {
   try {
-    checked_pointer_cast<DerivedClass>(basePtr_);
+    checkedPointerCast<DerivedClass>(basePtr_);
     FAIL() << "Expected VeloxException to be thrown";
   } catch (const VeloxException& e) {
     const std::string& message = e.message();
@@ -266,12 +264,12 @@ TEST_F(CastsTest, errorMessageContent) {
 TEST_F(CastsTest, objectIdentityPreserved) {
   // For shared_ptr
   std::shared_ptr<BaseClass> basePtrToDerived = derivedPtr_;
-  auto castedShared = checked_pointer_cast<DerivedClass>(basePtrToDerived);
+  auto castedShared = checkedPointerCast<DerivedClass>(basePtrToDerived);
   EXPECT_EQ(castedShared.get(), derivedPtr_.get());
 
   // For raw ptr
   BaseClass* basePtrToDerivedRaw = derivedRawPtr_;
-  auto castedRaw = checked_pointer_cast<DerivedClass>(basePtrToDerivedRaw);
+  auto castedRaw = checkedPointerCast<DerivedClass>(basePtrToDerivedRaw);
   EXPECT_EQ(castedRaw, derivedRawPtr_);
 }
 
@@ -280,7 +278,7 @@ TEST_F(CastsTest, uniquePtrExceptionSafety) {
   auto baseForCast = std::make_unique<BaseClass>();
 
   try {
-    checked_pointer_cast<DerivedClass>(std::move(baseForCast));
+    checkedPointerCast<DerivedClass>(std::move(baseForCast));
     FAIL() << "Expected VeloxException to be thrown";
   } catch (const VeloxException&) {
     // The unique_ptr should have been restored and the object should still
diff --git a/velox/common/time/CMakeLists.txt b/velox/common/time/CMakeLists.txt
index 46c878968f0..fff0f5b52af 100644
--- a/velox/common/time/CMakeLists.txt
+++ b/velox/common/time/CMakeLists.txt
@@ -15,5 +15,18 @@ if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
 endif()
 
-velox_add_library(velox_time CpuWallTimer.cpp Timer.cpp)
+velox_add_library(
+  velox_time
+  CpuWallTimer.cpp
+  Timer.cpp
+  HEADERS
+  CpuWallTimer.h
+  Timer.h
+)
 velox_link_libraries(velox_time PUBLIC velox_process velox_test_util Folly::folly fmt::fmt)
+
+velox_add_library(velox_hierarchical_timer HierarchicalTimer.cpp HEADERS HierarchicalTimer.h)
+velox_link_libraries(
+  velox_hierarchical_timer
+  PUBLIC velox_exception velox_common_base Folly::folly fmt::fmt glog::glog
+)
diff --git a/velox/common/time/CpuWallTimer.h b/velox/common/time/CpuWallTimer.h
index 231c15f66c2..06feb989848 100644
--- a/velox/common/time/CpuWallTimer.h
+++ b/velox/common/time/CpuWallTimer.h
@@ -18,6 +18,7 @@
 #include <fmt/format.h>
 #include <chrono>
 
+#include "velox/common/base/Macros.h"
 #include "velox/common/base/SuccinctPrinter.h"
 #include "velox/common/process/ProcessBase.h"
 
@@ -29,8 +30,13 @@ struct CpuWallTiming {
   uint64_t wallNanos = 0;
   uint64_t cpuNanos = 0;
 
+  auto operator<=>(const CpuWallTiming&) const = default;
+
   void add(const CpuWallTiming& other) {
+    // Suppress spurious warnings in GCC 13.
+    VELOX_SUPPRESS_STRINGOP_OVERFLOW_WARNING
     count += other.count;
+    VELOX_UNSUPPRESS_STRINGOP_OVERFLOW_WARNING
     cpuNanos += other.cpuNanos;
     wallNanos += other.wallNanos;
   }
diff --git a/velox/common/time/HierarchicalTimer.cpp b/velox/common/time/HierarchicalTimer.cpp
new file mode 100644
index 00000000000..398ca337308
--- /dev/null
+++ b/velox/common/time/HierarchicalTimer.cpp
@@ -0,0 +1,556 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/time/HierarchicalTimer.h"
+
+#include <chrono>
+#include <ctime>
+#include <iomanip>
+
+#include <fmt/core.h>
+#include <glog/logging.h>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/base/SuccinctPrinter.h"
+
+#ifdef ENABLE_HW_TIMER
+#if !defined(__x86_64__)
+#error "HierarchicalTimer RDTSCP mode requires x86-64 architecture"
+#endif
+#include <immintrin.h>
+#include "folly/chrono/Hardware.h"
+#endif
+
+namespace facebook::velox {
+
+namespace {
+
+#ifdef ENABLE_HW_TIMER
+double estimateTscFreqGhz(
+    std::chrono::milliseconds window = std::chrono::milliseconds(100)) {
+  static const double cached = [&]() {
+    using clock = std::chrono::steady_clock;
+    // Warm-up (reduces first-use noise).
+    (void)folly::hardware_timestamp();
+    auto t0 = clock::now();
+    uint64_t c0 = folly::hardware_timestamp();
+    // Busy-wait until window elapsed (less jitter than sleep).
+    while (clock::now() - t0 < window) {
+      _mm_pause();
+    }
+    auto t1 = clock::now();
+    uint64_t c1 = folly::hardware_timestamp();
+    std::chrono::duration<double> seconds = t1 - t0;
+    return (static_cast<double>(c1 - c0) / seconds.count()) / 1e9;
+  }();
+  return cached;
+}
+#endif
+
+/// Tracks the currently active TimerNode for stack-based auto-nesting.
+thread_local TimerNode* activeNode_ =
+    nullptr; // NOLINT(facebook-avoid-non-const-global-variables)
+
+/// Section column width for the formatted tree output.
+/// Must accommodate prefix (4 chars per depth level) plus node name.
+constexpr int kSectionWidth = 60;
+
+std::string buildPrefix(const std::vector<bool>& ancestorIsLast) {
+  if (ancestorIsLast.empty()) {
+    return "";
+  }
+  std::string prefix;
+  // Draw continuation lines for ancestors (all but the current node).
+  for (size_t i = 0; i + 1 < ancestorIsLast.size(); ++i) {
+    prefix += ancestorIsLast[i] ? "    " : "│   ";
+  }
+  // Draw the branch for the current node.
+  prefix += ancestorIsLast.back() ? "└── " : "├── ";
+  return prefix;
+}
+
+/// Computes display width by counting UTF-8 codepoints (not bytes).
+/// Box-drawing chars (│├└─) are 3 bytes each but 1 display column.
+int displayWidth(const std::string& s) {
+  int width = 0;
+  for (unsigned char c : s) {
+    // Count only non-continuation bytes (not 0x80-0xBF).
+    if ((c & 0xC0) != 0x80) {
+      ++width;
+    }
+  }
+  return width;
+}
+
+/// Pads the section string to kSectionWidth display columns for alignment.
+std::string padSection(const std::string& section) {
+  const int dw = displayWidth(section);
+  if (dw >= kSectionWidth) {
+    return section;
+  }
+  return section + std::string(kSectionWidth - dw, ' ');
+}
+
+} // namespace
+
+// --- TimerNode ---
+
+TimerNode::TimerNode(const std::string& name, TimerNode* parent)
+    : name_{name}, parent_{parent} {}
+
+TimerNode* TimerNode::getOrCreateChild(const std::string& childName) {
+  auto it = childrenByName_.find(childName);
+  if (it != childrenByName_.end()) {
+    return it->second;
+  }
+  auto child = std::make_unique<TimerNode>(childName, this);
+  auto* raw = child.get();
+  childrenByName_[childName] = raw;
+  children_.push_back(std::move(child));
+  return raw;
+}
+
+void TimerNode::addTime(uint64_t ns) {
+  totalTimeNs_ += ns;
+  if (ns < minTimeNs_) {
+    minTimeNs_ = ns;
+  }
+  if (ns > maxTimeNs_) {
+    maxTimeNs_ = ns;
+  }
+}
+
+void TimerNode::addCpuTime(uint64_t ns) {
+  totalCpuNs_ += ns;
+  if (ns < minCpuNs_) {
+    minCpuNs_ = ns;
+  }
+  if (ns > maxCpuNs_) {
+    maxCpuNs_ = ns;
+  }
+}
+
+void TimerNode::incrementCallCount() {
+  ++callCount_;
+}
+
+void TimerNode::reset() {
+  totalTimeNs_ = 0;
+  totalCpuNs_ = 0;
+  callCount_ = 0;
+  minTimeNs_ = std::numeric_limits<uint64_t>::max();
+  maxTimeNs_ = 0;
+  minCpuNs_ = std::numeric_limits<uint64_t>::max();
+  maxCpuNs_ = 0;
+  for (auto& child : children_) {
+    child->reset();
+  }
+}
+
+uint64_t TimerNode::totalTimeNs() const {
+  return totalTimeNs_;
+}
+
+uint64_t TimerNode::totalCpuNs() const {
+  return totalCpuNs_;
+}
+
+uint64_t TimerNode::callCount() const {
+  return callCount_;
+}
+
+uint64_t TimerNode::averageTimeNs() const {
+  if (callCount_ == 0) {
+    return 0;
+  }
+  return totalTimeNs_ / callCount_;
+}
+
+uint64_t TimerNode::minTimeNs() const {
+  return minTimeNs_;
+}
+
+uint64_t TimerNode::maxTimeNs() const {
+  return maxTimeNs_;
+}
+
+uint64_t TimerNode::averageCpuNs() const {
+  if (callCount_ == 0) {
+    return 0;
+  }
+  return totalCpuNs_ / callCount_;
+}
+
+uint64_t TimerNode::minCpuNs() const {
+  return minCpuNs_;
+}
+
+uint64_t TimerNode::maxCpuNs() const {
+  return maxCpuNs_;
+}
+
+const std::string& TimerNode::name() const {
+  return name_;
+}
+
+TimerNode* TimerNode::parent() const {
+  return parent_;
+}
+
+const std::vector<std::unique_ptr<TimerNode>>& TimerNode::children() const {
+  return children_;
+}
+
+void TimerNode::format(
+    std::string& out,
+    int depth,
+    bool isLast,
+    uint64_t parentTimeNs,
+    uint64_t parentCpuTimeNs,
+    bool verbose) const {
+  std::vector<bool> ancestorTrail;
+  formatImpl(
+      out,
+      depth,
+      isLast,
+      parentTimeNs,
+      parentCpuTimeNs,
+      verbose,
+      ancestorTrail);
+}
+
+void TimerNode::formatImpl(
+    std::string& out,
+    int depth,
+    bool isLast,
+    uint64_t parentTimeNs,
+    uint64_t parentCpuTimeNs,
+    bool verbose,
+    std::vector<bool>& ancestorTrail) const {
+  if (depth > 0) {
+    ancestorTrail.push_back(isLast);
+  }
+  const auto prefix = buildPrefix(ancestorTrail);
+  const auto wall = succinctNanos(totalTimeNs_);
+  const auto cpu = succinctNanos(totalCpuNs_);
+  const auto calls =
+      callCount_ > 0 ? std::to_string(callCount_) : std::string{"-"};
+
+  std::string wallPct;
+  if (parentTimeNs > 0 && depth > 0) {
+    wallPct = fmt::format(
+        "{:.1f}%",
+        100.0 * static_cast<double>(totalTimeNs_) /
+            static_cast<double>(parentTimeNs));
+  } else {
+    wallPct = "-";
+  }
+
+  std::string cpuPct;
+  if (parentCpuTimeNs > 0 && depth > 0) {
+    cpuPct = fmt::format(
+        "{:.1f}%",
+        100.0 * static_cast<double>(totalCpuNs_) /
+            static_cast<double>(parentCpuTimeNs));
+  } else {
+    cpuPct = "-";
+  }
+
+  const auto section = padSection(prefix + name_);
+
+  out += fmt::format(
+      "{} {:>10s} {:>8s} {:>10s} {:>8s} {:>8s}",
+      section,
+      wall,
+      wallPct,
+      cpu,
+      cpuPct,
+      calls);
+
+  if (verbose) {
+    std::string avgWall, minWall, maxWall;
+    std::string avgCpu, minCpu, maxCpu;
+    if (callCount_ > 0) {
+      avgWall = succinctNanos(averageTimeNs());
+      minWall = succinctNanos(minTimeNs_);
+      maxWall = succinctNanos(maxTimeNs_);
+      avgCpu = succinctNanos(averageCpuNs());
+      minCpu = succinctNanos(maxCpuNs_ > 0 ? minCpuNs_ : 0);
+      maxCpu = succinctNanos(maxCpuNs_);
+    } else {
+      avgWall = "-";
+      minWall = "-";
+      maxWall = "-";
+      avgCpu = "-";
+      minCpu = "-";
+      maxCpu = "-";
+    }
+    out += fmt::format(
+        " {:>10s} {:>10s} {:>10s} {:>10s} {:>10s} {:>10s}",
+        avgWall,
+        minWall,
+        maxWall,
+        avgCpu,
+        minCpu,
+        maxCpu);
+  }
+  out += "\n";
+
+  // Determine if "(other)" row will be shown so we can set isLast correctly
+  // for the final real child.
+  uint64_t childrenSum = 0;
+  uint64_t childrenCpuSum = 0;
+  for (const auto& child : children_) {
+    childrenSum += child->totalTimeNs();
+    childrenCpuSum += child->totalCpuNs();
+  }
+  const bool hasOther = !children_.empty() && totalTimeNs_ > childrenSum;
+
+  // Format children.
+  for (size_t i = 0; i < children_.size(); ++i) {
+    const bool lastChild = (i == children_.size() - 1) && !hasOther;
+    children_[i]->formatImpl(
+        out,
+        depth + 1,
+        lastChild,
+        totalTimeNs_,
+        totalCpuNs_,
+        verbose,
+        ancestorTrail);
+  }
+
+  // Show unaccounted time if this node has children and time exceeds children
+  // sum.
+  if (hasOther) {
+    const uint64_t other = totalTimeNs_ - childrenSum;
+    const uint64_t cpuOther =
+        (totalCpuNs_ > childrenCpuSum) ? totalCpuNs_ - childrenCpuSum : 0;
+    ancestorTrail.push_back(true);
+    const auto otherPrefix = buildPrefix(ancestorTrail);
+    const auto otherSection = padSection(otherPrefix + "(other)");
+    const auto otherWallPct = fmt::format(
+        "{:.1f}%",
+        100.0 * static_cast<double>(other) / static_cast<double>(totalTimeNs_));
+    std::string otherCpuPct;
+    if (totalCpuNs_ > 0) {
+      otherCpuPct = fmt::format(
+          "{:.1f}%",
+          100.0 * static_cast<double>(cpuOther) /
+              static_cast<double>(totalCpuNs_));
+    } else {
+      otherCpuPct = "-";
+    }
+    out += fmt::format(
+        "{} {:>10s} {:>8s} {:>10s} {:>8s} {:>8s}",
+        otherSection,
+        succinctNanos(other),
+        otherWallPct,
+        succinctNanos(cpuOther),
+        otherCpuPct,
+        "-");
+    if (verbose) {
+      out += fmt::format(
+          " {:>10s} {:>10s} {:>10s} {:>10s} {:>10s} {:>10s}",
+          "-",
+          "-",
+          "-",
+          "-",
+          "-",
+          "-");
+    }
+    out += "\n";
+    ancestorTrail.pop_back();
+  }
+
+  if (depth > 0 && !ancestorTrail.empty()) {
+    ancestorTrail.pop_back();
+  }
+}
+
+// --- TimerTree ---
+
+TimerTree::TimerTree(const std::string& name)
+    : name_{name}, root_{std::make_unique<TimerNode>("root")} {}
+
+TimerTree::~TimerTree() {
+  printStats();
+}
+
+uint64_t TimerTree::now() const {
+#ifdef ENABLE_HW_TIMER
+  return static_cast<uint64_t>(
+      static_cast<double>(folly::hardware_timestamp()) / estimateTscFreqGhz());
+#else
+  return std::chrono::duration_cast<std::chrono::nanoseconds>(
+             std::chrono::steady_clock::now().time_since_epoch())
+      .count();
+#endif
+}
+
+uint64_t TimerTree::cpuNow() const {
+  struct timespec ts{};
+  clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts);
+  return static_cast<uint64_t>(ts.tv_sec) * 1'000'000'000ULL +
+      static_cast<uint64_t>(ts.tv_nsec);
+}
+
+TimerNode* TimerTree::getOrCreateNode(const std::string& path) {
+  TimerNode* current = root_.get();
+  size_t start = 0;
+  while (start < path.size()) {
+    auto pos = path.find('/', start);
+    if (pos == std::string::npos) {
+      pos = path.size();
+    }
+    const auto segment = path.substr(start, pos - start);
+    if (!segment.empty()) {
+      current = current->getOrCreateChild(segment);
+    }
+    start = pos + 1;
+  }
+  return current;
+}
+
+void TimerTree::reset() {
+  root_->reset();
+}
+
+void TimerTree::clear() {
+  root_ = std::make_unique<TimerNode>("root");
+}
+
+std::string TimerTree::toString(bool verbose) const {
+  const auto& topChildren = root_->children();
+  if (topChildren.empty()) {
+    return "(no timers recorded)\n";
+  }
+
+  // Compact: Section(60) + Wall(10) + Wall%(8) + CPU(10) + CPU%(8) + Calls(8)
+  //          + 6 separating spaces = 110.
+  // Verbose adds: AvgWall(10) + MinWall(10) + MaxWall(10) + AvgCPU(10) +
+  //               MinCPU(10) + MaxCPU(10) + 6 separating spaces = 66.
+  constexpr int kCompactWidth = 110;
+  constexpr int kVerboseWidth = 176;
+  const int totalWidth = verbose ? kVerboseWidth : kCompactWidth;
+
+  std::string out;
+  const std::string separator(totalWidth, '=');
+  const std::string dashSeparator(totalWidth, '-');
+
+  out += separator + "\n";
+  if (!name_.empty()) {
+    out += fmt::format("{:^{}s}\n", name_, totalWidth);
+  }
+  out += fmt::format("{:^{}s}\n", "HIERARCHICAL TIMING BREAKDOWN", totalWidth);
+  out += separator + "\n\n";
+
+  out += fmt::format(
+      "{:<60s} {:>10s} {:>8s} {:>10s} {:>8s} {:>8s}",
+      "Section",
+      "Wall",
+      "Wall %",
+      "CPU",
+      "CPU %",
+      "Calls");
+  if (verbose) {
+    out += fmt::format(
+        " {:>10s} {:>10s} {:>10s} {:>10s} {:>10s} {:>10s}",
+        "Avg Wall",
+        "Min Wall",
+        "Max Wall",
+        "Avg CPU",
+        "Min CPU",
+        "Max CPU");
+  }
+  out += "\n";
+  out += dashSeparator + "\n";
+
+  for (size_t i = 0; i < topChildren.size(); ++i) {
+    topChildren[i]->format(
+        out,
+        /*depth=*/0,
+        /*isLast=*/false,
+        /*parentTimeNs=*/0,
+        /*parentCpuTimeNs=*/0,
+        verbose);
+  }
+
+  out += separator + "\n";
+  return out;
+}
+
+void TimerTree::printStats(bool verbose) {
+  const auto& topChildren = root_->children();
+  if (topChildren.empty()) {
+    return;
+  }
+  LOG(INFO) << "\n" << toString(verbose);
+  clear();
+}
+
+const TimerNode& TimerTree::root() const {
+  return *root_;
+}
+
+const std::string& TimerTree::name() const {
+  return name_;
+}
+
+TimerTree& TimerTree::threadInstance() {
+  static thread_local TimerTree instance;
+  return instance;
+}
+
+// --- ScopedTimer ---
+
+ScopedTimer::ScopedTimer(const std::string& name)
+    : tree_(TimerTree::threadInstance()),
+      restoreActive_(true),
+      startNs_(tree_.now()),
+      cpuStartNs_(tree_.cpuNow()) {
+  previousActive_ = activeNode_;
+  if (activeNode_) {
+    node_ = activeNode_->getOrCreateChild(name);
+  } else {
+    node_ = tree_.root_->getOrCreateChild(name);
+  }
+  activeNode_ = node_;
+  node_->incrementCallCount();
+}
+
+ScopedTimer::ScopedTimer(TimerTree& tree, const std::string& path)
+    : tree_(tree),
+      node_(tree.getOrCreateNode(path)),
+      restoreActive_(false),
+      startNs_(tree.now()),
+      cpuStartNs_(tree.cpuNow()) {
+  node_->incrementCallCount();
+}
+
+ScopedTimer::~ScopedTimer() {
+  const uint64_t endNs = tree_.now();
+  const uint64_t cpuEndNs = tree_.cpuNow();
+  VELOX_CHECK_GE(endNs, startNs_);
+  node_->addTime(endNs - startNs_);
+  if (cpuEndNs >= cpuStartNs_) {
+    node_->addCpuTime(cpuEndNs - cpuStartNs_);
+  }
+  if (restoreActive_) {
+    activeNode_ = previousActive_;
+  }
+}
+
+} // namespace facebook::velox
diff --git a/velox/common/time/HierarchicalTimer.h b/velox/common/time/HierarchicalTimer.h
new file mode 100644
index 00000000000..4246dacecb9
--- /dev/null
+++ b/velox/common/time/HierarchicalTimer.h
@@ -0,0 +1,262 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace facebook::velox {
+
+/// A node in the hierarchical timer tree.
+///
+/// Each node tracks cumulative wall time, CPU time, and call count for a named
+/// section. Nodes form a tree: "parent/child" creates a "child" node under
+/// "parent". Tracks wall total, CPU total, count, min, and max time per node.
+///
+/// Not thread-safe. All access must be from a single thread.
+class TimerNode {
+ public:
+  explicit TimerNode(const std::string& name, TimerNode* parent = nullptr);
+
+  /// Returns or creates a direct child with the given name.
+  TimerNode* getOrCreateChild(const std::string& childName);
+
+  /// Adds elapsed nanoseconds to this node's wall time total, updates min/max.
+  void addTime(uint64_t ns);
+
+  /// Adds elapsed nanoseconds to this node's CPU time total, updates min/max.
+  void addCpuTime(uint64_t ns);
+
+  /// Increments the call counter by one.
+  void incrementCallCount();
+
+  /// Zeros all counters for this node and all descendants.
+  /// Keeps the tree structure intact.
+  void reset();
+
+  uint64_t totalTimeNs() const;
+  uint64_t totalCpuNs() const;
+  uint64_t callCount() const;
+  uint64_t averageTimeNs() const;
+  uint64_t minTimeNs() const;
+  uint64_t maxTimeNs() const;
+  uint64_t averageCpuNs() const;
+  uint64_t minCpuNs() const;
+  uint64_t maxCpuNs() const;
+  const std::string& name() const;
+  TimerNode* parent() const;
+  const std::vector<std::unique_ptr<TimerNode>>& children() const;
+
+  /// Formats this node (and descendants) into a human-readable table row.
+  /// `depth` controls indentation; `isLast` controls tree-drawing glyphs.
+  void format(
+      std::string& out,
+      int depth,
+      bool isLast,
+      uint64_t parentTimeNs,
+      uint64_t parentCpuTimeNs,
+      bool verbose) const;
+
+ private:
+  /// Internal recursive formatter that tracks ancestor isLast flags for
+  /// drawing proper │ continuation lines in the tree.
+  void formatImpl(
+      std::string& out,
+      int depth,
+      bool isLast,
+      uint64_t parentTimeNs,
+      uint64_t parentCpuTimeNs,
+      bool verbose,
+      std::vector<bool>& ancestorTrail) const;
+  std::string name_;
+  TimerNode* parent_;
+  std::vector<std::unique_ptr<TimerNode>> children_;
+  std::unordered_map<std::string, TimerNode*> childrenByName_;
+  uint64_t totalTimeNs_{0};
+  uint64_t totalCpuNs_{0};
+  uint64_t callCount_{0};
+  uint64_t minTimeNs_{std::numeric_limits<uint64_t>::max()};
+  uint64_t maxTimeNs_{0};
+  uint64_t minCpuNs_{std::numeric_limits<uint64_t>::max()};
+  uint64_t maxCpuNs_{0};
+};
+
+/// Owns a forest of TimerNode trees and provides path-based access.
+///
+/// Paths are `/`-separated: "a/b/c" resolves to root -> a -> b -> c.
+/// Multiple top-level names create separate subtrees.
+///
+/// Uses RDTSCP for high-precision timing when `ENABLE_HW_TIMER` is defined,
+/// automatically falls back to `steady_clock` otherwise.
+///
+/// Uses ScopedTimer for RAII timing. On destruction (or when printStats() is
+/// called), prints a hierarchical timing breakdown and clears all data.
+///
+/// Not thread-safe. All access must be from a single thread.
+///
+/// ## Usage
+///
+/// ### Thread-local (recommended) -- auto-nesting via call stack:
+///
+///   void Reader::loadStripe(int i) {
+///     ScopedTimer t("loadStripe");
+///     {
+///       ScopedTimer t2("readIO");     // auto-nested under loadStripe
+///       readIO(i);
+///     }
+///     {
+///       ScopedTimer t3("decode");     // auto-nested under loadStripe
+///       decode(i);
+///     }
+///   }
+///
+///   void Writer::flush() {
+///     ScopedTimer t("flush");
+///     doFlush();
+///   }
+///
+///   // Print results at any point:
+///   TimerTree::threadInstance().printStats();
+///
+/// ### Explicit tree -- for isolated profiling sessions:
+///
+///   TimerTree tree("my benchmark");
+///   for (int i = 0; i < numStripes; ++i) {
+///     ScopedTimer t(tree, "loadStripe");
+///     loadStripe(i);
+///   }
+///   // Destructor prints results, or call tree.printStats() explicitly.
+///
+/// ## Example output
+///
+///   =============================================================...=========
+///                        HIERARCHICAL TIMING BREAKDOWN
+///   =============================================================...=========
+///
+///   Section                                                      Wall
+///      CPU    Calls  Avg Wall  ...  % Parent
+///   -------------------------------------------------------------...---------
+///   loadStripe                                               120.50ms
+///    45.20ms        5   24.10ms  ...        -
+///   ├── readIO                                                80.20ms
+///    10.50ms        5   16.04ms  ...    66.6%
+///   ├── decode                                                35.10ms
+///    30.00ms        5    7.02ms  ...    29.1%
+///   └── (other)                                                5.20ms
+///     4.70ms        -        -  ...     4.3%
+///   flush                                                     15.30ms
+///    14.80ms        1   15.30ms  ...        -
+///   =============================================================...=========
+class TimerTree {
+ public:
+  explicit TimerTree(const std::string& name = "");
+
+  TimerTree(const TimerTree&) = delete;
+  TimerTree& operator=(const TimerTree&) = delete;
+  TimerTree(TimerTree&&) = delete;
+  TimerTree& operator=(TimerTree&&) = delete;
+
+  /// Prints the results table if any entries were recorded.
+  ~TimerTree();
+
+  /// Returns the current wall timestamp in nanoseconds.
+  /// Uses RDTSCP when ENABLE_HW_TIMER is defined, steady_clock otherwise.
+  uint64_t now() const;
+
+  /// Returns the current thread CPU time in nanoseconds.
+  /// Uses clock_gettime(CLOCK_THREAD_CPUTIME_ID) to measure user+system CPU
+  /// time for the calling thread.
+  uint64_t cpuNow() const;
+
+  /// Walks (or creates) the node addressed by a `/`-separated path.
+  TimerNode* getOrCreateNode(const std::string& path);
+
+  /// Zeros all counters but keeps the tree structure.
+  void reset();
+
+  /// Destroys the entire tree (removes all nodes).
+  void clear();
+
+  /// Returns a formatted hierarchical summary table.
+  std::string toString(bool verbose = false) const;
+
+  /// Prints the results table via LOG(INFO) and clears all data.
+  void printStats(bool verbose = false);
+
+  /// Access root node for inspection.
+  const TimerNode& root() const;
+
+  /// Returns the timer name.
+  const std::string& name() const;
+
+  /// Returns the thread-local TimerTree instance. Creates one on first access
+  /// per thread. Results are printed when the thread exits (thread_local
+  /// destructor). Call printStats() to print and reset intermediate results.
+  static TimerTree& threadInstance();
+
+ private:
+  friend class ScopedTimer;
+
+  std::string name_;
+  std::unique_ptr<TimerNode> root_;
+};
+
+/// RAII timer that measures a scoped block and records it into a TimerTree.
+///
+/// On construction, records the current wall and CPU time and increments the
+/// call count for the node. On destruction, computes elapsed wall and CPU
+/// nanoseconds and adds them to the node.
+///
+/// Two constructors:
+/// - ScopedTimer(name): records into TimerTree::threadInstance() with
+///   stack-based auto-nesting. Nested ScopedTimers automatically form
+///   parent-child relationships based on the call stack. The name is treated
+///   as a simple child name (no path splitting).
+/// - ScopedTimer(tree, path): records into an explicit TimerTree using
+///   path-based node resolution (splits on '/').
+///
+/// Not thread-safe. The referenced TimerTree must outlive this object.
+class ScopedTimer {
+ public:
+  /// Records into the thread-local TimerTree with stack-based auto-nesting.
+  /// The name is used as a direct child name under the currently active node
+  /// (or root if no timer is active).
+  explicit ScopedTimer(const std::string& name);
+
+  /// Records into an explicit TimerTree using path-based node resolution.
+  ScopedTimer(TimerTree& tree, const std::string& path);
+  ~ScopedTimer();
+
+  ScopedTimer(const ScopedTimer&) = delete;
+  ScopedTimer& operator=(const ScopedTimer&) = delete;
+  ScopedTimer(ScopedTimer&&) = delete;
+  ScopedTimer& operator=(ScopedTimer&&) = delete;
+
+ private:
+  TimerTree& tree_;
+  TimerNode* node_;
+  TimerNode* previousActive_{nullptr};
+  bool restoreActive_;
+  uint64_t startNs_;
+  uint64_t cpuStartNs_;
+};
+
+} // namespace facebook::velox
diff --git a/velox/common/time/tests/CMakeLists.txt b/velox/common/time/tests/CMakeLists.txt
index cb602e651a3..2330d095bae 100644
--- a/velox/common/time/tests/CMakeLists.txt
+++ b/velox/common/time/tests/CMakeLists.txt
@@ -18,3 +18,19 @@ add_executable(velox_time_test CpuWallTimerTest.cpp)
 target_link_libraries(velox_time_test PRIVATE velox_time glog::glog GTest::gtest GTest::gtest_main)
 
 gtest_add_tests(velox_time_test "" AUTO)
+
+add_executable(velox_hierarchical_timer_test HierarchicalTimerTest.cpp)
+
+target_link_libraries(
+  velox_hierarchical_timer_test
+  PRIVATE
+    velox_hierarchical_timer
+    velox_exception
+    velox_common_base
+    fmt::fmt
+    glog::glog
+    GTest::gtest
+    GTest::gtest_main
+)
+
+gtest_add_tests(velox_hierarchical_timer_test "" AUTO)
diff --git a/velox/common/time/tests/HierarchicalTimerTest.cpp b/velox/common/time/tests/HierarchicalTimerTest.cpp
new file mode 100644
index 00000000000..ea30945eec7
--- /dev/null
+++ b/velox/common/time/tests/HierarchicalTimerTest.cpp
@@ -0,0 +1,1029 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <fmt/core.h>
+#include <glog/logging.h>
+#include <gtest/gtest.h>
+
+#include "velox/common/base/SuccinctPrinter.h"
+#include "velox/common/base/VeloxException.h"
+#include "velox/common/time/HierarchicalTimer.h"
+
+using namespace facebook::velox;
+
+namespace facebook::velox::test {
+
+namespace {
+
+// Intercepts glog INFO messages so tests can inspect logged output.
+class LogCapture : public google::LogSink {
+ public:
+  LogCapture() {
+    google::AddLogSink(this);
+  }
+
+  ~LogCapture() override {
+    google::RemoveLogSink(this);
+  }
+
+  void send(
+      google::LogSeverity /*severity*/,
+      const char* /*full_filename*/,
+      const char* /*base_filename*/,
+      int /*line*/,
+      const struct ::tm* /*tm_time*/,
+      const char* message,
+      size_t message_len) override {
+    captured_ += std::string(message, message_len);
+  }
+
+  LogCapture(const LogCapture&) = delete;
+  LogCapture& operator=(const LogCapture&) = delete;
+
+  const std::string& captured() const {
+    return captured_;
+  }
+
+ private:
+  std::string captured_;
+};
+
+void doWork() {
+  int x = 0;
+  for (int i = 0; i < 100; ++i) {
+    x += i;
+  }
+  // Prevent the compiler from optimizing away the loop.
+  EXPECT_GE(x, 0);
+}
+
+/// Builds the expected header block for toString() output.
+std::string expectedHeader(
+    const std::string& title = "",
+    bool verbose = false) {
+  constexpr int kCompactWidth = 110;
+  constexpr int kVerboseWidth = 176;
+  const int totalWidth = verbose ? kVerboseWidth : kCompactWidth;
+
+  std::string out;
+  out += std::string(totalWidth, '=') + "\n";
+  if (!title.empty()) {
+    out += fmt::format("{:^{}s}\n", title, totalWidth);
+  }
+  out += fmt::format("{:^{}s}\n", "HIERARCHICAL TIMING BREAKDOWN", totalWidth);
+  out += std::string(totalWidth, '=') + "\n\n";
+  out += fmt::format(
+      "{:<60s} {:>10s} {:>8s} {:>10s} {:>8s} {:>8s}",
+      "Section",
+      "Wall",
+      "Wall %",
+      "CPU",
+      "CPU %",
+      "Calls");
+  if (verbose) {
+    out += fmt::format(
+        " {:>10s} {:>10s} {:>10s} {:>10s} {:>10s} {:>10s}",
+        "Avg Wall",
+        "Min Wall",
+        "Max Wall",
+        "Avg CPU",
+        "Min CPU",
+        "Max CPU");
+  }
+  out += "\n";
+  out += std::string(totalWidth, '-') + "\n";
+  return out;
+}
+
+/// Builds a single expected compact node line (Section, Wall, Wall%, CPU, CPU%,
+/// Calls).
+std::string expectedLine(
+    const std::string& prefix,
+    const std::string& name,
+    const std::string& wall,
+    const std::string& wallPct,
+    const std::string& cpu,
+    const std::string& cpuPct,
+    const std::string& calls) {
+  auto section = prefix + name;
+  constexpr int kSectionWidth = 60;
+  // Use display width for padding (UTF-8 aware).
+  int dw = 0;
+  for (unsigned char c : section) {
+    if ((c & 0xC0) != 0x80) {
+      ++dw;
+    }
+  }
+  if (dw < kSectionWidth) {
+    section += std::string(kSectionWidth - dw, ' ');
+  }
+  return fmt::format(
+      "{} {:>10s} {:>8s} {:>10s} {:>8s} {:>8s}\n",
+      section,
+      wall,
+      wallPct,
+      cpu,
+      cpuPct,
+      calls);
+}
+
+/// Builds a single expected verbose node line (compact columns + avg/min/max).
+std::string expectedVerboseLine(
+    const std::string& prefix,
+    const std::string& name,
+    const std::string& wall,
+    const std::string& wallPct,
+    const std::string& cpu,
+    const std::string& cpuPct,
+    const std::string& calls,
+    const std::string& avgWall,
+    const std::string& minWall,
+    const std::string& maxWall,
+    const std::string& avgCpu,
+    const std::string& minCpu,
+    const std::string& maxCpu) {
+  auto section = prefix + name;
+  constexpr int kSectionWidth = 60;
+  int dw = 0;
+  for (unsigned char c : section) {
+    if ((c & 0xC0) != 0x80) {
+      ++dw;
+    }
+  }
+  if (dw < kSectionWidth) {
+    section += std::string(kSectionWidth - dw, ' ');
+  }
+  return fmt::format(
+      "{} {:>10s} {:>8s} {:>10s} {:>8s} {:>8s} {:>10s} {:>10s} {:>10s} {:>10s} {:>10s} {:>10s}\n",
+      section,
+      wall,
+      wallPct,
+      cpu,
+      cpuPct,
+      calls,
+      avgWall,
+      minWall,
+      maxWall,
+      avgCpu,
+      minCpu,
+      maxCpu);
+}
+
+std::string expectedFooter(bool verbose = false) {
+  constexpr int kCompactWidth = 110;
+  constexpr int kVerboseWidth = 176;
+  const int totalWidth = verbose ? kVerboseWidth : kCompactWidth;
+  return std::string(totalWidth, '=') + "\n";
+}
+
+} // namespace
+
+// =====================================================================
+// Tests - Tree structure tests
+// =====================================================================
+
+class HierarchicalTimerTest : public ::testing::Test {
+ protected:
+  TimerTree tree_;
+};
+
+TEST_F(HierarchicalTimerTest, hierarchicalNesting) {
+  auto* node = tree_.getOrCreateNode("a/b/c");
+
+  const auto& roots = tree_.root().children();
+  ASSERT_EQ(1, roots.size());
+  EXPECT_EQ("a", roots[0]->name());
+
+  const auto& bChildren = roots[0]->children();
+  ASSERT_EQ(1, bChildren.size());
+  EXPECT_EQ("b", bChildren[0]->name());
+
+  const auto& cChildren = bChildren[0]->children();
+  ASSERT_EQ(1, cChildren.size());
+  EXPECT_EQ("c", cChildren[0]->name());
+  EXPECT_EQ(node, cChildren[0].get());
+}
+
+TEST_F(HierarchicalTimerTest, multipleRoots) {
+  tree_.getOrCreateNode("alpha");
+  tree_.getOrCreateNode("beta");
+  tree_.getOrCreateNode("gamma");
+
+  const auto& roots = tree_.root().children();
+  ASSERT_EQ(3, roots.size());
+  EXPECT_EQ("alpha", roots[0]->name());
+  EXPECT_EQ("beta", roots[1]->name());
+  EXPECT_EQ("gamma", roots[2]->name());
+}
+
+TEST_F(HierarchicalTimerTest, resetZerosCountersKeepsStructure) {
+  tree_.getOrCreateNode("a/b");
+  auto* node = tree_.getOrCreateNode("a/b");
+  node->addTime(100);
+  node->addCpuTime(50);
+  node->incrementCallCount();
+
+  tree_.reset();
+
+  const auto& roots = tree_.root().children();
+  ASSERT_EQ(1, roots.size());
+  EXPECT_EQ("a", roots[0]->name());
+  ASSERT_EQ(1, roots[0]->children().size());
+
+  const auto& b = *roots[0]->children()[0];
+  EXPECT_EQ(0, b.totalTimeNs());
+  EXPECT_EQ(0, b.totalCpuNs());
+  EXPECT_EQ(0, b.callCount());
+}
+
+TEST_F(HierarchicalTimerTest, clearDestroysTree) {
+  tree_.getOrCreateNode("a/b/c");
+  tree_.clear();
+
+  EXPECT_TRUE(tree_.root().children().empty());
+}
+
+TEST_F(HierarchicalTimerTest, averageTimeIsZeroWhenNoCallsRecorded) {
+  auto* node = tree_.getOrCreateNode("empty");
+  EXPECT_EQ(0, node->averageTimeNs());
+}
+
+TEST_F(HierarchicalTimerTest, emptyTreeToString) {
+  const auto output = tree_.toString();
+  EXPECT_NE(std::string::npos, output.find("no timers recorded"));
+}
+
+// =====================================================================
+// Tests - ScopedTimer tests (explicit tree, path-based)
+// =====================================================================
+
+TEST_F(HierarchicalTimerTest, basicSingleTimer) {
+  {
+    ScopedTimer timer(tree_, "op");
+    doWork();
+  }
+
+  const auto& topChildren = tree_.root().children();
+  ASSERT_EQ(1, topChildren.size());
+
+  const auto& node = *topChildren[0];
+  EXPECT_EQ("op", node.name());
+  EXPECT_EQ(1, node.callCount());
+  EXPECT_GT(node.totalTimeNs(), 0);
+  EXPECT_GT(node.totalCpuNs(), 0);
+  EXPECT_EQ(node.totalTimeNs(), node.averageTimeNs());
+}
+
+TEST_F(HierarchicalTimerTest, multipleCallsAccumulate) {
+  constexpr int kNumCalls = 5;
+  for (int i = 0; i < kNumCalls; ++i) {
+    ScopedTimer timer(tree_, "repeated");
+    doWork();
+  }
+
+  const auto& node = *tree_.root().children()[0];
+  EXPECT_EQ(kNumCalls, node.callCount());
+  EXPECT_GT(node.totalTimeNs(), 0);
+}
+
+TEST_F(HierarchicalTimerTest, nestedScopedTimers) {
+  {
+    ScopedTimer outer(tree_, "loadStripe");
+    doWork();
+    {
+      ScopedTimer inner(tree_, "loadStripe/readIO");
+      doWork();
+    }
+    {
+      ScopedTimer inner(tree_, "loadStripe/decode");
+      doWork();
+    }
+  }
+
+  const auto& roots = tree_.root().children();
+  ASSERT_EQ(1, roots.size());
+
+  const auto& loadStripe = *roots[0];
+  EXPECT_EQ("loadStripe", loadStripe.name());
+  EXPECT_EQ(1, loadStripe.callCount());
+  EXPECT_GT(loadStripe.totalTimeNs(), 0);
+
+  const auto& topChildren = loadStripe.children();
+  ASSERT_EQ(2, topChildren.size());
+  EXPECT_EQ("readIO", topChildren[0]->name());
+  EXPECT_EQ("decode", topChildren[1]->name());
+  EXPECT_EQ(1, topChildren[0]->callCount());
+  EXPECT_EQ(1, topChildren[1]->callCount());
+
+  const uint64_t childrenSum =
+      topChildren[0]->totalTimeNs() + topChildren[1]->totalTimeNs();
+  EXPECT_GE(loadStripe.totalTimeNs(), childrenSum);
+}
+
+TEST_F(HierarchicalTimerTest, deeplyNestedScopedTimers) {
+  {
+    ScopedTimer t1(tree_, "a");
+    {
+      ScopedTimer t2(tree_, "a/b");
+      {
+        ScopedTimer t3(tree_, "a/b/c");
+        doWork();
+      }
+    }
+  }
+
+  const auto& a = *tree_.root().children()[0];
+  EXPECT_EQ("a", a.name());
+  EXPECT_EQ(1, a.callCount());
+
+  const auto& b = *a.children()[0];
+  EXPECT_EQ("b", b.name());
+  EXPECT_EQ(1, b.callCount());
+
+  const auto& c = *b.children()[0];
+  EXPECT_EQ("c", c.name());
+  EXPECT_EQ(1, c.callCount());
+  EXPECT_GT(c.totalTimeNs(), 0);
+
+  EXPECT_GE(b.totalTimeNs(), c.totalTimeNs());
+  EXPECT_GE(a.totalTimeNs(), b.totalTimeNs());
+}
+
+TEST_F(HierarchicalTimerTest, nestedScopedTimersMultipleIterations) {
+  constexpr int kIterations = 3;
+  for (int i = 0; i < kIterations; ++i) {
+    ScopedTimer outer(tree_, "loop");
+    {
+      ScopedTimer inner(tree_, "loop/work");
+      doWork();
+    }
+  }
+
+  const auto& loop = *tree_.root().children()[0];
+  EXPECT_EQ(kIterations, loop.callCount());
+
+  const auto& work = *loop.children()[0];
+  EXPECT_EQ(kIterations, work.callCount());
+  EXPECT_GE(loop.totalTimeNs(), work.totalTimeNs());
+}
+
+TEST_F(HierarchicalTimerTest, multipleSameLevelScopedTimers) {
+  {
+    ScopedTimer outer(tree_, "process");
+    {
+      ScopedTimer s1(tree_, "process/parse");
+      doWork();
+    }
+    {
+      ScopedTimer s2(tree_, "process/validate");
+      doWork();
+    }
+    {
+      ScopedTimer s3(tree_, "process/transform");
+      doWork();
+    }
+    {
+      ScopedTimer s4(tree_, "process/serialize");
+      doWork();
+    }
+  }
+
+  const auto& process = *tree_.root().children()[0];
+  EXPECT_EQ("process", process.name());
+  EXPECT_EQ(1, process.callCount());
+
+  const auto& topChildren = process.children();
+  ASSERT_EQ(4, topChildren.size());
+
+  const std::vector<std::string> kExpectedNames{
+      "parse", "validate", "transform", "serialize"};
+  for (size_t i = 0; i < topChildren.size(); ++i) {
+    EXPECT_EQ(kExpectedNames[i], topChildren[i]->name());
+    EXPECT_EQ(1, topChildren[i]->callCount());
+    EXPECT_GT(topChildren[i]->totalTimeNs(), 0);
+  }
+
+  uint64_t childrenSum = 0;
+  for (const auto& child : topChildren) {
+    childrenSum += child->totalTimeNs();
+  }
+  EXPECT_GE(process.totalTimeNs(), childrenSum);
+}
+
+TEST_F(HierarchicalTimerTest, sameLevelScopedTimersWithNesting) {
+  {
+    ScopedTimer outer(tree_, "root");
+    {
+      ScopedTimer s1(tree_, "root/io");
+      {
+        ScopedTimer s1a(tree_, "root/io/read");
+        doWork();
+      }
+      {
+        ScopedTimer s1b(tree_, "root/io/write");
+        doWork();
+      }
+    }
+    {
+      ScopedTimer s2(tree_, "root/compute");
+      {
+        ScopedTimer s2a(tree_, "root/compute/map");
+        doWork();
+      }
+      {
+        ScopedTimer s2b(tree_, "root/compute/reduce");
+        doWork();
+      }
+    }
+  }
+
+  const auto& rootNode = *tree_.root().children()[0];
+  const auto& topChildren = rootNode.children();
+  ASSERT_EQ(2, topChildren.size());
+
+  const auto& io = *topChildren[0];
+  EXPECT_EQ("io", io.name());
+  ASSERT_EQ(2, io.children().size());
+  EXPECT_EQ("read", io.children()[0]->name());
+  EXPECT_EQ("write", io.children()[1]->name());
+
+  const auto& compute = *topChildren[1];
+  EXPECT_EQ("compute", compute.name());
+  ASSERT_EQ(2, compute.children().size());
+  EXPECT_EQ("map", compute.children()[0]->name());
+  EXPECT_EQ("reduce", compute.children()[1]->name());
+
+  const uint64_t ioChildrenSum =
+      io.children()[0]->totalTimeNs() + io.children()[1]->totalTimeNs();
+  EXPECT_GE(io.totalTimeNs(), ioChildrenSum);
+
+  const uint64_t computeChildrenSum = compute.children()[0]->totalTimeNs() +
+      compute.children()[1]->totalTimeNs();
+  EXPECT_GE(compute.totalTimeNs(), computeChildrenSum);
+}
+
+TEST_F(HierarchicalTimerTest, scopedTimerIsNonCopyableNonMovable) {
+  EXPECT_FALSE(std::is_copy_constructible_v<ScopedTimer>);
+  EXPECT_FALSE(std::is_copy_assignable_v<ScopedTimer>);
+  EXPECT_FALSE(std::is_move_constructible_v<ScopedTimer>);
+  EXPECT_FALSE(std::is_move_assignable_v<ScopedTimer>);
+}
+
+// =====================================================================
+// Tests - toString exact output tests
+// =====================================================================
+
+TEST_F(HierarchicalTimerTest, toStringFormattedOutputSingleNode) {
+  auto* node = tree_.getOrCreateNode("op");
+  node->addTime(5'000'000); // 5ms
+  node->incrementCallCount();
+
+  std::string expected = expectedHeader();
+  expected += expectedLine("", "op", "5.00ms", "-", "0ns", "-", "1");
+  expected += expectedFooter();
+
+  EXPECT_EQ(expected, tree_.toString());
+}
+
+TEST_F(HierarchicalTimerTest, toStringFormattedOutputWithChildren) {
+  auto* parent = tree_.getOrCreateNode("loadStripe");
+  parent->addTime(100'000'000); // 100ms
+  parent->incrementCallCount();
+
+  auto* child1 = tree_.getOrCreateNode("loadStripe/readIO");
+  child1->addTime(60'000'000); // 60ms
+  child1->incrementCallCount();
+
+  auto* child2 = tree_.getOrCreateNode("loadStripe/decode");
+  child2->addTime(30'000'000); // 30ms
+  child2->incrementCallCount();
+
+  std::string expected = expectedHeader();
+  expected += expectedLine("", "loadStripe", "100.00ms", "-", "0ns", "-", "1");
+  expected +=
+      expectedLine("├── ", "readIO", "60.00ms", "60.0%", "0ns", "-", "1");
+  expected +=
+      expectedLine("├── ", "decode", "30.00ms", "30.0%", "0ns", "-", "1");
+  expected +=
+      expectedLine("└── ", "(other)", "10.00ms", "10.0%", "0ns", "-", "-");
+  expected += expectedFooter();
+
+  EXPECT_EQ(expected, tree_.toString());
+}
+
+TEST_F(HierarchicalTimerTest, toStringFormattedOutputDeepNesting) {
+  auto* a = tree_.getOrCreateNode("a");
+  a->addTime(1'000'000'000); // 1s
+  a->incrementCallCount();
+
+  auto* b = tree_.getOrCreateNode("a/b");
+  b->addTime(500'000'000); // 500ms
+  b->incrementCallCount();
+  b->incrementCallCount();
+
+  auto* c = tree_.getOrCreateNode("a/b/c");
+  c->addTime(200'000'000); // 200ms
+  c->incrementCallCount();
+  c->incrementCallCount();
+  c->incrementCallCount();
+  c->incrementCallCount();
+
+  std::string expected = expectedHeader();
+  expected += expectedLine("", "a", "1.00s", "-", "0ns", "-", "1");
+  expected += expectedLine("├── ", "b", "500.00ms", "50.0%", "0ns", "-", "2");
+  expected +=
+      expectedLine("│   ├── ", "c", "200.00ms", "40.0%", "0ns", "-", "4");
+  expected +=
+      expectedLine("│   └── ", "(other)", "300.00ms", "60.0%", "0ns", "-", "-");
+  expected +=
+      expectedLine("└── ", "(other)", "500.00ms", "50.0%", "0ns", "-", "-");
+  expected += expectedFooter();
+
+  EXPECT_EQ(expected, tree_.toString());
+}
+
+TEST_F(HierarchicalTimerTest, toStringFormattedOutputMultipleRoots) {
+  auto* alpha = tree_.getOrCreateNode("alpha");
+  alpha->addTime(10'000'000); // 10ms
+  alpha->incrementCallCount();
+
+  auto* beta = tree_.getOrCreateNode("beta");
+  beta->addTime(20'000'000); // 20ms
+  beta->incrementCallCount();
+
+  std::string expected = expectedHeader();
+  expected += expectedLine("", "alpha", "10.00ms", "-", "0ns", "-", "1");
+  expected += expectedLine("", "beta", "20.00ms", "-", "0ns", "-", "1");
+  expected += expectedFooter();
+
+  EXPECT_EQ(expected, tree_.toString());
+}
+
+TEST_F(
+    HierarchicalTimerTest,
+    toStringFormattedOutputMultipleSameLevelChildren) {
+  auto* parent = tree_.getOrCreateNode("pipeline");
+  parent->addTime(200'000'000); // 200ms
+  parent->incrementCallCount();
+
+  auto* c1 = tree_.getOrCreateNode("pipeline/parse");
+  c1->addTime(50'000'000); // 50ms
+  c1->incrementCallCount();
+
+  auto* c2 = tree_.getOrCreateNode("pipeline/validate");
+  c2->addTime(30'000'000); // 30ms
+  c2->incrementCallCount();
+
+  auto* c3 = tree_.getOrCreateNode("pipeline/transform");
+  c3->addTime(80'000'000); // 80ms
+  c3->incrementCallCount();
+
+  auto* c4 = tree_.getOrCreateNode("pipeline/emit");
+  c4->addTime(20'000'000); // 20ms
+  c4->incrementCallCount();
+
+  std::string expected = expectedHeader();
+  expected += expectedLine("", "pipeline", "200.00ms", "-", "0ns", "-", "1");
+  expected +=
+      expectedLine("├── ", "parse", "50.00ms", "25.0%", "0ns", "-", "1");
+  expected +=
+      expectedLine("├── ", "validate", "30.00ms", "15.0%", "0ns", "-", "1");
+  expected +=
+      expectedLine("├── ", "transform", "80.00ms", "40.0%", "0ns", "-", "1");
+  expected += expectedLine("├── ", "emit", "20.00ms", "10.0%", "0ns", "-", "1");
+  expected +=
+      expectedLine("└── ", "(other)", "20.00ms", "10.0%", "0ns", "-", "-");
+  expected += expectedFooter();
+
+  EXPECT_EQ(expected, tree_.toString());
+}
+
+// =====================================================================
+// Tests - Standalone tests
+// =====================================================================
+
+TEST(HierarchicalTimerStandaloneTest, noEntriesNoOutput) {
+  LogCapture capture;
+  {
+    TimerTree tree;
+  }
+  EXPECT_TRUE(capture.captured().empty()) << capture.captured();
+}
+
+TEST(HierarchicalTimerStandaloneTest, destructorPrintsTitleAndResults) {
+  LogCapture capture;
+
+  {
+    TimerTree tree("MyBenchmarkTitle");
+    {
+      ScopedTimer t(tree, "sessionTimer");
+      doWork();
+    }
+  } // Destructor prints the table.
+
+  const auto& output = capture.captured();
+  EXPECT_NE(output.find("MyBenchmarkTitle"), std::string::npos) << output;
+  EXPECT_NE(output.find("sessionTimer"), std::string::npos) << output;
+  EXPECT_NE(output.find("HIERARCHICAL TIMING BREAKDOWN"), std::string::npos)
+      << output;
+}
+
+TEST(HierarchicalTimerStandaloneTest, printStatsClearsEntries) {
+  LogCapture capture1;
+  TimerTree tree("Session");
+
+  {
+    ScopedTimer t(tree, "firstTimer");
+    doWork();
+  }
+  tree.printStats();
+
+  const auto& output1 = capture1.captured();
+  EXPECT_NE(output1.find("Session"), std::string::npos) << output1;
+  EXPECT_NE(output1.find("firstTimer"), std::string::npos) << output1;
+
+  // After printStats(), entries should be cleared.
+  // Destructor should produce no further output.
+  LogCapture capture2;
+  tree.printStats();
+  EXPECT_TRUE(capture2.captured().empty()) << capture2.captured();
+}
+
+// =====================================================================
+// Tests - min/max tracking and CPU time
+// =====================================================================
+
+TEST_F(HierarchicalTimerTest, minMaxTracking) {
+  auto* node = tree_.getOrCreateNode("tracked");
+  node->addTime(100);
+  node->incrementCallCount();
+  node->addTime(500);
+  node->incrementCallCount();
+  node->addTime(200);
+  node->incrementCallCount();
+
+  EXPECT_EQ(800, node->totalTimeNs());
+  EXPECT_EQ(3, node->callCount());
+  EXPECT_EQ(100, node->minTimeNs());
+  EXPECT_EQ(500, node->maxTimeNs());
+  EXPECT_EQ(266, node->averageTimeNs()); // 800 / 3 = 266
+}
+
+TEST_F(HierarchicalTimerTest, toStringIncludesWallCpuColumns) {
+  auto* node = tree_.getOrCreateNode("op");
+  node->addTime(5'000'000); // 5ms
+  node->incrementCallCount();
+
+  const auto output = tree_.toString();
+  EXPECT_NE(output.find("Wall"), std::string::npos) << output;
+  EXPECT_NE(output.find("CPU"), std::string::npos) << output;
+  EXPECT_NE(output.find("Wall %"), std::string::npos) << output;
+  EXPECT_NE(output.find("CPU %"), std::string::npos) << output;
+
+  // Verbose columns should not appear in compact mode.
+  const auto verboseOutput = tree_.toString(true);
+  EXPECT_NE(verboseOutput.find("Min Wall"), std::string::npos) << verboseOutput;
+  EXPECT_NE(verboseOutput.find("Max Wall"), std::string::npos) << verboseOutput;
+  EXPECT_NE(verboseOutput.find("Avg CPU"), std::string::npos) << verboseOutput;
+  EXPECT_NE(verboseOutput.find("Min CPU"), std::string::npos) << verboseOutput;
+  EXPECT_NE(verboseOutput.find("Max CPU"), std::string::npos) << verboseOutput;
+}
+
+TEST_F(HierarchicalTimerTest, toStringWithTitle) {
+  TimerTree namedTree("MyBench");
+  auto* node = namedTree.getOrCreateNode("op");
+  node->addTime(1'000'000);
+  node->incrementCallCount();
+
+  const auto output = namedTree.toString();
+  EXPECT_NE(output.find("MyBench"), std::string::npos) << output;
+  EXPECT_NE(output.find("HIERARCHICAL TIMING BREAKDOWN"), std::string::npos)
+      << output;
+}
+
+TEST_F(HierarchicalTimerTest, resetAlsoResetsMinMaxAndCpu) {
+  auto* node = tree_.getOrCreateNode("tracked");
+  node->addTime(100);
+  node->addCpuTime(50);
+  node->incrementCallCount();
+
+  EXPECT_EQ(100, node->minTimeNs());
+  EXPECT_EQ(100, node->maxTimeNs());
+  EXPECT_EQ(50, node->totalCpuNs());
+  EXPECT_EQ(50, node->minCpuNs());
+  EXPECT_EQ(50, node->maxCpuNs());
+
+  tree_.reset();
+
+  EXPECT_EQ(std::numeric_limits<uint64_t>::max(), node->minTimeNs());
+  EXPECT_EQ(0, node->maxTimeNs());
+  EXPECT_EQ(0, node->totalCpuNs());
+  EXPECT_EQ(std::numeric_limits<uint64_t>::max(), node->minCpuNs());
+  EXPECT_EQ(0, node->maxCpuNs());
+}
+
+TEST_F(HierarchicalTimerTest, cpuPerCallStats) {
+  auto* node = tree_.getOrCreateNode("tracked");
+  node->addCpuTime(100);
+  node->addTime(200);
+  node->incrementCallCount();
+  node->addCpuTime(500);
+  node->addTime(600);
+  node->incrementCallCount();
+  node->addCpuTime(300);
+  node->addTime(400);
+  node->incrementCallCount();
+
+  EXPECT_EQ(900, node->totalCpuNs());
+  EXPECT_EQ(3, node->callCount());
+  EXPECT_EQ(300, node->averageCpuNs()); // 900 / 3
+  EXPECT_EQ(100, node->minCpuNs());
+  EXPECT_EQ(500, node->maxCpuNs());
+}
+
+TEST_F(HierarchicalTimerTest, toStringFormattedOutputWithCpuPerCall) {
+  auto* node = tree_.getOrCreateNode("op");
+  node->addTime(10'000'000); // 10ms wall
+  node->addCpuTime(5'000'000); // 5ms CPU
+  node->incrementCallCount();
+  node->addTime(20'000'000); // 20ms wall
+  node->addCpuTime(15'000'000); // 15ms CPU
+  node->incrementCallCount();
+
+  // Compact mode: no avg/min/max columns.
+  std::string expected = expectedHeader();
+  expected += expectedLine("", "op", "30.00ms", "-", "20.00ms", "-", "2");
+  expected += expectedFooter();
+
+  EXPECT_EQ(expected, tree_.toString());
+}
+
+TEST_F(HierarchicalTimerTest, toStringVerboseOutput) {
+  auto* node = tree_.getOrCreateNode("op");
+  node->addTime(10'000'000); // 10ms wall
+  node->addCpuTime(5'000'000); // 5ms CPU
+  node->incrementCallCount();
+  node->addTime(20'000'000); // 20ms wall
+  node->addCpuTime(15'000'000); // 15ms CPU
+  node->incrementCallCount();
+
+  std::string expected = expectedHeader("", true);
+  expected += expectedVerboseLine(
+      "",
+      "op",
+      "30.00ms", // total wall
+      "-", // wall %
+      "20.00ms", // total CPU
+      "-", // cpu %
+      "2",
+      "15.00ms", // avg wall: 30/2
+      "10.00ms", // min wall
+      "20.00ms", // max wall
+      "10.00ms", // avg CPU: 20/2
+      "5.00ms", // min CPU
+      "15.00ms"); // max CPU
+  expected += expectedFooter(true);
+
+  EXPECT_EQ(expected, tree_.toString(true));
+}
+
+TEST_F(HierarchicalTimerTest, cpuNowReturnsNonZero) {
+  EXPECT_GT(tree_.cpuNow(), 0);
+}
+
+TEST_F(HierarchicalTimerTest, cpuTimeTrackedByScopedTimer) {
+  {
+    ScopedTimer t(tree_, "cpuWork");
+    doWork();
+  }
+
+  const auto& roots = tree_.root().children();
+  ASSERT_EQ(1, roots.size());
+  EXPECT_GT(roots[0]->totalTimeNs(), 0);
+  EXPECT_GT(roots[0]->totalCpuNs(), 0);
+}
+
+// =====================================================================
+// Thread-local TimerTree tests
+// =====================================================================
+
+TEST(HierarchicalTimerThreadLocalTest, scopedTimerUsesThreadInstance) {
+  auto& tree = TimerTree::threadInstance();
+  tree.clear();
+
+  {
+    ScopedTimer t("threadLocalOp");
+    doWork();
+  }
+
+  const auto& roots = tree.root().children();
+  ASSERT_EQ(1, roots.size());
+  EXPECT_EQ("threadLocalOp", roots[0]->name());
+  EXPECT_EQ(1, roots[0]->callCount());
+  EXPECT_GT(roots[0]->totalTimeNs(), 0);
+  EXPECT_GT(roots[0]->totalCpuNs(), 0);
+  tree.clear();
+}
+
+TEST(HierarchicalTimerThreadLocalTest, threadInstanceIsSameAcrossCalls) {
+  auto& tree1 = TimerTree::threadInstance();
+  auto& tree2 = TimerTree::threadInstance();
+  EXPECT_EQ(&tree1, &tree2);
+}
+
+// Simulates two different classes recording into the same thread-local tree
+// using stack-based auto-nesting.
+namespace {
+void classAWork() {
+  ScopedTimer t1("classA");
+  {
+    ScopedTimer t2("process");
+    doWork();
+  }
+}
+
+void classBWork() {
+  ScopedTimer t1("classB");
+  {
+    ScopedTimer t2("compute");
+    doWork();
+  }
+}
+} // namespace
+
+TEST(HierarchicalTimerThreadLocalTest, sharedAcrossClasses) {
+  auto& tree = TimerTree::threadInstance();
+  tree.clear();
+
+  classAWork();
+  classBWork();
+  classAWork();
+
+  const auto& roots = tree.root().children();
+  ASSERT_EQ(2, roots.size());
+  EXPECT_EQ("classA", roots[0]->name());
+  EXPECT_EQ("classB", roots[1]->name());
+
+  EXPECT_EQ(2, roots[0]->callCount());
+  const auto& classAChildren = roots[0]->children();
+  ASSERT_EQ(1, classAChildren.size());
+  EXPECT_EQ("process", classAChildren[0]->name());
+  EXPECT_EQ(2, classAChildren[0]->callCount());
+
+  EXPECT_EQ(1, roots[1]->callCount());
+  const auto& classBChildren = roots[1]->children();
+  ASSERT_EQ(1, classBChildren.size());
+  EXPECT_EQ("compute", classBChildren[0]->name());
+  EXPECT_EQ(1, classBChildren[0]->callCount());
+  tree.clear();
+}
+
+TEST(HierarchicalTimerThreadLocalTest, nestedThreadLocalTimers) {
+  auto& tree = TimerTree::threadInstance();
+  tree.clear();
+
+  {
+    ScopedTimer outer("pipeline");
+    {
+      ScopedTimer inner("step1");
+      doWork();
+    }
+    {
+      ScopedTimer inner("step2");
+      doWork();
+    }
+  }
+
+  const auto& roots = tree.root().children();
+  ASSERT_EQ(1, roots.size());
+  EXPECT_EQ("pipeline", roots[0]->name());
+  EXPECT_EQ(1, roots[0]->callCount());
+  ASSERT_EQ(2, roots[0]->children().size());
+  EXPECT_EQ("step1", roots[0]->children()[0]->name());
+  EXPECT_EQ("step2", roots[0]->children()[1]->name());
+  tree.clear();
+}
+
+// =====================================================================
+// Tests - Stack-based auto-nesting
+// =====================================================================
+
+TEST(HierarchicalTimerAutoNestingTest, basicAutoNesting) {
+  auto& tree = TimerTree::threadInstance();
+  tree.clear();
+
+  {
+    ScopedTimer t1("benchmark");
+    {
+      ScopedTimer t2("read");
+      {
+        ScopedTimer t3("decode");
+        doWork();
+      }
+    }
+  }
+
+  const auto& roots = tree.root().children();
+  ASSERT_EQ(1, roots.size());
+  EXPECT_EQ("benchmark", roots[0]->name());
+  EXPECT_EQ(1, roots[0]->callCount());
+
+  const auto& readChildren = roots[0]->children();
+  ASSERT_EQ(1, readChildren.size());
+  EXPECT_EQ("read", readChildren[0]->name());
+  EXPECT_EQ(1, readChildren[0]->callCount());
+
+  const auto& decodeChildren = readChildren[0]->children();
+  ASSERT_EQ(1, decodeChildren.size());
+  EXPECT_EQ("decode", decodeChildren[0]->name());
+  EXPECT_EQ(1, decodeChildren[0]->callCount());
+  EXPECT_GT(decodeChildren[0]->totalTimeNs(), 0);
+
+  EXPECT_GE(readChildren[0]->totalTimeNs(), decodeChildren[0]->totalTimeNs());
+  EXPECT_GE(roots[0]->totalTimeNs(), readChildren[0]->totalTimeNs());
+  tree.clear();
+}
+
+TEST(HierarchicalTimerAutoNestingTest, autoNestingRestoresActiveNode) {
+  auto& tree = TimerTree::threadInstance();
+  tree.clear();
+
+  {
+    ScopedTimer t1("root");
+    {
+      ScopedTimer t2("child1");
+      doWork();
+    }
+    // After child1 is destroyed, active node should be restored to "root".
+    {
+      ScopedTimer t3("child2");
+      doWork();
+    }
+  }
+
+  const auto& roots = tree.root().children();
+  ASSERT_EQ(1, roots.size());
+  EXPECT_EQ("root", roots[0]->name());
+
+  // Both children should be siblings under "root", not nested.
+  const auto& children = roots[0]->children();
+  ASSERT_EQ(2, children.size());
+  EXPECT_EQ("child1", children[0]->name());
+  EXPECT_EQ("child2", children[1]->name());
+  tree.clear();
+}
+
+TEST(HierarchicalTimerAutoNestingTest, sequentialTopLevelTimers) {
+  auto& tree = TimerTree::threadInstance();
+  tree.clear();
+
+  {
+    ScopedTimer t1("alpha");
+    doWork();
+  }
+  {
+    ScopedTimer t2("beta");
+    doWork();
+  }
+
+  // Sequential (non-nested) timers should create separate top-level entries.
+  const auto& roots = tree.root().children();
+  ASSERT_EQ(2, roots.size());
+  EXPECT_EQ("alpha", roots[0]->name());
+  EXPECT_EQ("beta", roots[1]->name());
+  tree.clear();
+}
+
+TEST(HierarchicalTimerAutoNestingTest, autoNestingCpuTimeTracked) {
+  auto& tree = TimerTree::threadInstance();
+  tree.clear();
+
+  {
+    ScopedTimer t1("outer");
+    {
+      ScopedTimer t2("inner");
+      doWork();
+    }
+  }
+
+  const auto& roots = tree.root().children();
+  ASSERT_EQ(1, roots.size());
+  EXPECT_GT(roots[0]->totalCpuNs(), 0);
+  EXPECT_GT(roots[0]->children()[0]->totalCpuNs(), 0);
+  tree.clear();
+}
+
+} // namespace facebook::velox::test
diff --git a/velox/connectors/CMakeLists.txt b/velox/connectors/CMakeLists.txt
index 3fd17dde2d2..cb174e8bad4 100644
--- a/velox/connectors/CMakeLists.txt
+++ b/velox/connectors/CMakeLists.txt
@@ -11,9 +11,13 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-velox_add_library(velox_connector Connector.cpp)
+velox_add_library(velox_connector Connector.cpp HEADERS Connector.h ConnectorRegistryInternal.h)
 
-velox_link_libraries(velox_connector velox_common_config velox_vector)
+velox_link_libraries(velox_connector velox_common_config velox_exec_spill_stats velox_vector)
+
+velox_add_library(velox_connector_registry ConnectorRegistry.cpp HEADERS ConnectorRegistry.h)
+
+velox_link_libraries(velox_connector_registry velox_connector velox_scoped_registry velox_core)
 
 add_subdirectory(fuzzer)
 
diff --git a/velox/connectors/Connector.cpp b/velox/connectors/Connector.cpp
index e7c72af478b..25912dc717c 100644
--- a/velox/connectors/Connector.cpp
+++ b/velox/connectors/Connector.cpp
@@ -16,92 +16,52 @@
 
 #include "velox/connectors/Connector.h"
 
-namespace facebook::velox::connector {
-namespace {
-std::unordered_map<std::string, std::shared_ptr<ConnectorFactory>>&
-connectorFactories() {
-  static std::unordered_map<std::string, std::shared_ptr<ConnectorFactory>>
-      factories;
-  return factories;
-}
+#include "velox/common/EnumDefine.h"
 
-std::unordered_map<std::string, std::shared_ptr<Connector>>& connectors() {
-  static std::unordered_map<std::string, std::shared_ptr<Connector>> connectors;
-  return connectors;
-}
-} // namespace
+#include <memory>
+#include <string>
 
-bool DataSink::Stats::empty() const {
-  return numWrittenBytes == 0 && numWrittenFiles == 0 && spillStats.empty();
-}
+#include "velox/common/ScopedRegistry.h"
+#include "velox/common/base/Exceptions.h"
+#include "velox/connectors/ConnectorRegistryInternal.h"
 
-std::string DataSink::Stats::toString() const {
-  return fmt::format(
-      "numWrittenBytes {} numWrittenFiles {} {}",
-      succinctBytes(numWrittenBytes),
-      numWrittenFiles,
-      spillStats.toString());
-}
-
-bool registerConnectorFactory(std::shared_ptr<ConnectorFactory> factory) {
-  bool ok =
-      connectorFactories().insert({factory->connectorName(), factory}).second;
-  VELOX_CHECK(
-      ok,
-      "ConnectorFactory with name '{}' is already registered",
-      factory->connectorName());
-  return true;
-}
-
-bool hasConnectorFactory(const std::string& connectorName) {
-  return connectorFactories().count(connectorName) == 1;
-}
-
-bool unregisterConnectorFactory(const std::string& connectorName) {
-  auto count = connectorFactories().erase(connectorName);
-  return count == 1;
-}
+namespace facebook::velox::connector {
 
-std::shared_ptr<ConnectorFactory> getConnectorFactory(
-    const std::string& connectorName) {
-  auto it = connectorFactories().find(connectorName);
-  VELOX_CHECK(
-      it != connectorFactories().end(),
-      "ConnectorFactory with name '{}' not registered",
-      connectorName);
-  return it->second;
+ScopedRegistry<std::string, Connector>& connectors() {
+  static ScopedRegistry<std::string, Connector> instance;
+  return instance;
 }
 
-bool registerConnector(std::shared_ptr<Connector> connector) {
-  bool ok = connectors().insert({connector->connectorId(), connector}).second;
-  VELOX_CHECK(
-      ok,
-      "Connector with ID '{}' is already registered",
-      connector->connectorId());
+bool registerConnector(const std::shared_ptr<Connector>& connector) {
+  connectors().insert(connector->connectorId(), connector);
   return true;
 }
 
 bool unregisterConnector(const std::string& connectorId) {
-  auto count = connectors().erase(connectorId);
-  return count == 1;
+  return connectors().erase(connectorId);
 }
 
 std::shared_ptr<Connector> getConnector(const std::string& connectorId) {
-  auto it = connectors().find(connectorId);
-  VELOX_CHECK(
-      it != connectors().end(),
-      "Connector with ID '{}' not registered",
-      connectorId);
-  return it->second;
+  auto connector = connectors().find(connectorId);
+  VELOX_CHECK_NOT_NULL(
+      connector, "Connector with ID is not registered: {}", connectorId);
+  return connector;
 }
 
 bool hasConnector(const std::string& connectorId) {
-  return connectors().find(connectorId) != connectors().end();
+  return connectors().find(connectorId) != nullptr;
+}
+
+bool DataSink::Stats::empty() const {
+  return numWrittenBytes == 0 && numWrittenFiles == 0 && spillStats.empty();
 }
 
-const std::unordered_map<std::string, std::shared_ptr<Connector>>&
-getAllConnectors() {
-  return connectors();
+std::string DataSink::Stats::toString() const {
+  return fmt::format(
+      "numWrittenBytes {} numWrittenFiles {} {}",
+      succinctBytes(numWrittenBytes),
+      numWrittenFiles,
+      spillStats.toString());
 }
 
 folly::Synchronized<
diff --git a/velox/connectors/Connector.h b/velox/connectors/Connector.h
index 10cf82b342c..72ad3dc4b1e 100644
--- a/velox/connectors/Connector.h
+++ b/velox/connectors/Connector.h
@@ -16,17 +16,20 @@
 #pragma once
 
 #include "folly/CancellationToken.h"
-#include "velox/common/Enums.h"
+#include "velox/common/EnumDeclare.h"
 #include "velox/common/base/AsyncSource.h"
 #include "velox/common/base/PrefixSortConfig.h"
 #include "velox/common/base/RuntimeMetrics.h"
 #include "velox/common/base/SpillConfig.h"
-#include "velox/common/base/SpillStats.h"
 #include "velox/common/caching/AsyncDataCache.h"
 #include "velox/common/caching/ScanTracker.h"
+#include "velox/common/config/ConfigProvider.h"
 #include "velox/common/file/TokenProvider.h"
 #include "velox/common/future/VeloxPromise.h"
 #include "velox/core/ExpressionEvaluator.h"
+#include "velox/core/QueryConfig.h"
+#include "velox/core/ScanBatchEvent.h"
+#include "velox/exec/SpillStats.h"
 #include "velox/type/Filter.h"
 #include "velox/vector/ComplexVector.h"
 
@@ -44,7 +47,7 @@ class ConfigBase;
 
 namespace facebook::velox::core {
 class ITypedExpr;
-}
+} // namespace facebook::velox::core
 
 namespace facebook::velox::core {
 struct IndexLookupCondition;
@@ -80,7 +83,11 @@ struct ConnectorSplit : public ISerializable {
     return 0;
   }
 
-  virtual ~ConnectorSplit() {}
+  virtual ~ConnectorSplit() {
+    if (dataSource) {
+      dataSource->close();
+    }
+  }
 
   virtual std::string toString() const {
     return fmt::format(
@@ -134,6 +141,16 @@ class ConnectorTableHandle : public ISerializable {
     return false;
   }
 
+  /// Returns true if this table handle requires splits for index lookup.
+  /// Default implementation returns false. Subclasses can override this to
+  /// indicate that splits need to be provided to the index source before
+  /// performing lookups.
+  ///
+  /// NOTE: this only applies if supportsIndexLookup() returns true.
+  virtual bool needsIndexSplit() const {
+    return false;
+  }
+
   virtual std::string toString() const {
     return name();
   }
@@ -191,7 +208,7 @@ class DataSink {
     uint64_t recodeTimeNs{0};
     uint64_t compressionTimeNs{0};
 
-    common::SpillStats spillStats;
+    exec::SpillStats spillStats;
 
     bool empty() const;
 
@@ -266,7 +283,20 @@ class DataSource {
   /// Returns the number of input rows processed so far.
   virtual uint64_t getCompletedRows() = 0;
 
-  virtual std::unordered_map<std::string, RuntimeCounter> runtimeStats() = 0;
+  /// Stores a callback to fire after each scan batch.
+  void setScanBatchCallback(core::ScanBatchCallback callback) {
+    scanBatchCallback_ = std::move(callback);
+  }
+
+  /// Called by TableScan after each non-empty batch with generic scan stats.
+  /// Default is a no-op. Subclasses should override to create a
+  /// connector-specific event (e.g., FileScanBatchEvent), enrich it with
+  /// connector-specific fields, and call scanBatchCallback_.
+  virtual void fireScanBatchCallback(core::ScanBatchEvent /*event*/) {}
+
+  virtual std::unordered_map<std::string, RuntimeMetric> getRuntimeStats() {
+    return {};
+  }
 
   /// Returns true if 'this' has initiated all the prefetch this will initiate.
   /// This means that the caller should schedule next splits to prefetch in the
@@ -308,33 +338,46 @@ class DataSource {
   /// connector implementation decides how to support the cancellation if
   /// needed.
   virtual void cancel() {}
+
+ protected:
+  core::ScanBatchCallback scanBatchCallback_;
 };
 
 class IndexSource {
  public:
   virtual ~IndexSource() = default;
 
+  /// Adds splits to the index source for lookup. This is called when
+  /// the table handle's needsIndexSplit() returns true. This method must be
+  /// called before the first call to lookup(). This method is expected to be
+  /// called only once. Default implementation throws as most index sources
+  /// don't require splits.
+  virtual void addSplits(
+      std::vector<std::shared_ptr<ConnectorSplit>> /*splits*/) {
+    VELOX_UNSUPPORTED("This IndexSource does not support splits");
+  }
+
   /// Represents a lookup request for a given input.
-  struct LookupRequest {
+  struct Request {
     /// Contains the input column vectors used by lookup join and range
     /// conditions.
     RowVectorPtr input;
 
-    explicit LookupRequest(RowVectorPtr input) : input(std::move(input)) {}
+    explicit Request(RowVectorPtr input) : input(std::move(input)) {}
   };
 
   /// Represents the lookup result for a subset of input produced by the
-  /// 'LookupResultIterator'.
-  struct LookupResult {
+  /// 'ResultIterator'.
+  struct Result {
     /// Specifies the indices of input row in the lookup request that have
     /// matches in 'output'. It contains the input indices in the order
     /// of the input rows in the lookup request. Any gap in the indices means
     /// the input rows that has no matches in output.
     ///
     /// Example:
-    ///   LookupRequest: input = [0, 1, 2, 3, 4]
-    ///   LookupResult:  inputHits = [0, 0, 2, 2, 3, 4, 4, 4]
-    ///                  output    = [0, 1, 2, 3, 4, 5, 6, 7]
+    ///   Request: input = [0, 1, 2, 3, 4]
+    ///   Result:  inputHits = [0, 0, 2, 2, 3, 4, 4, 4]
+    ///            output    = [0, 1, 2, 3, 4, 5, 6, 7]
     ///
     ///   Here is match results for each input row:
     ///   input row #0: match with output rows #0 and #1.
@@ -343,7 +386,7 @@ class IndexSource {
     ///   input row #3: match with output row #4.
     ///   input row #4: match with output rows #5, #6 and #7.
     ///
-    /// 'LookupResultIterator' must also produce the output result in order of
+    /// 'ResultIterator' must also produce the output result in order of
     /// input rows.
     BufferPtr inputHits;
 
@@ -354,7 +397,7 @@ class IndexSource {
       return output->size();
     }
 
-    LookupResult(BufferPtr _inputHits, RowVectorPtr _output)
+    Result(BufferPtr _inputHits, RowVectorPtr _output)
         : inputHits(std::move(_inputHits)), output(std::move(_output)) {
       VELOX_CHECK_EQ(inputHits->size() / sizeof(vector_size_t), output->size());
     }
@@ -362,24 +405,28 @@ class IndexSource {
 
   /// The lookup result iterator used to fetch the lookup result in batch for a
   /// given lookup request.
-  class LookupResultIterator {
+  class ResultIterator {
    public:
-    virtual ~LookupResultIterator() = default;
+    virtual ~ResultIterator() = default;
+
+    /// Invoked to check if there are more lookup results available to fetch.
+    /// Returns true if there are more results, false otherwise. This allows
+    /// the caller to determine whether to continue calling 'next()'.
+    virtual bool hasNext() = 0;
 
     /// Invoked to fetch up to 'size' number of output rows. Returns nullptr if
     /// all the lookup results have been fetched. Returns std::nullopt and sets
     /// the 'future' if started asynchronous work and needs to wait for it to
     /// complete to continue processing. The caller will wait for the 'future'
     /// to complete before calling 'next' again.
-    virtual std::optional<std::unique_ptr<LookupResult>> next(
+    virtual std::optional<std::unique_ptr<Result>> next(
         vector_size_t size,
         velox::ContinueFuture& future) {
       VELOX_UNSUPPORTED();
     }
   };
 
-  virtual std::shared_ptr<LookupResultIterator> lookup(
-      const LookupRequest& request) = 0;
+  virtual std::shared_ptr<ResultIterator> lookup(const Request& request) = 0;
 
   virtual std::unordered_map<std::string, RuntimeMetric> runtimeStats() = 0;
 };
@@ -501,14 +548,24 @@ class ConnectorQueryCtx {
     return cancellationToken_;
   }
 
+  /// Deprecated: Use FileConfig::kSelectiveNimbleReaderEnabledSession instead.
   bool selectiveNimbleReaderEnabled() const {
     return selectiveNimbleReaderEnabled_;
   }
 
+  /// Deprecated: Use connector session properties instead.
   void setSelectiveNimbleReaderEnabled(bool value) {
     selectiveNimbleReaderEnabled_ = value;
   }
 
+  core::QueryConfig::RowSizeTrackingMode rowSizeTrackingMode() const {
+    return rowSizeTrackingEnabled_;
+  }
+
+  void setRowSizeTrackingMode(core::QueryConfig::RowSizeTrackingMode value) {
+    rowSizeTrackingEnabled_ = value;
+  }
+
   std::shared_ptr<filesystems::TokenProvider> fsTokenProvider() const {
     return fsTokenProvider_;
   }
@@ -531,6 +588,30 @@ class ConnectorQueryCtx {
   const folly::CancellationToken cancellationToken_;
   const std::shared_ptr<filesystems::TokenProvider> fsTokenProvider_;
   bool selectiveNimbleReaderEnabled_{false};
+  core::QueryConfig::RowSizeTrackingMode rowSizeTrackingEnabled_{
+      core::QueryConfig::RowSizeTrackingMode::ENABLED_FOR_ALL};
+};
+
+class Connector;
+
+class ConnectorFactory {
+ public:
+  explicit ConnectorFactory(const char* name) : name_(name) {}
+
+  virtual ~ConnectorFactory() = default;
+
+  const std::string& connectorName() const {
+    return name_;
+  }
+
+  virtual std::shared_ptr<Connector> newConnector(
+      const std::string& id,
+      std::shared_ptr<const config::ConfigBase> config,
+      folly::Executor* ioExecutor = nullptr,
+      folly::Executor* cpuExecutor = nullptr) = 0;
+
+ private:
+  const std::string name_;
 };
 
 class Connector {
@@ -550,6 +631,12 @@ class Connector {
     return config_;
   }
 
+  /// Returns the config provider for this connector's session properties,
+  /// or nullptr if the connector has no session-overridable properties.
+  virtual const config::ConfigProvider* configProvider() const {
+    return nullptr;
+  }
+
   /// Returns true if this connector would accept a filter dynamically
   /// generated during query execution.
   virtual bool canAddDynamicFilter() const {
@@ -566,15 +653,9 @@ class Connector {
   /// ConnectorSplit in addSplit(). If so, TableScan can preload splits
   /// so that file opening and metadata operations are off the Driver'
   /// thread.
-#ifdef VELOX_ENABLE_BACKWARD_COMPATIBILITY
-  virtual bool supportsSplitPreload() {
-    return false;
-  }
-#else
   virtual bool supportsSplitPreload() const {
     return false;
   }
-#endif
 
   /// Returns true if the connector supports index lookup, otherwise false.
   virtual bool supportsIndexLookup() const {
@@ -582,14 +663,14 @@ class Connector {
   }
 
   /// Creates index source for index join lookup.
-  /// @param inputType The list of probe-side columns that either used in
-  /// equi-clauses or join conditions.
-  /// @param numJoinKeys The number of key columns used in join equi-clauses.
-  /// The first 'numJoinKeys' columns in 'inputType' form a prefix of the
-  /// index, and the rest of the columns in inputType are expected to be used in
-  /// 'joinConditions'.
-  /// @param joinConditions The join conditions. It expects inputs columns from
-  /// the 'tail' of 'inputType' and from 'columnHandles'.
+  /// @param inputType The list of probe-side columns used in join conditions.
+  /// @param joinConditions The join conditions that specify how to perform the
+  /// index lookup. This includes:
+  /// - EqualIndexLookupCondition: For equi-join conditions.
+  /// - InIndexLookupCondition: For IN-list conditions.
+  /// - BetweenIndexLookupCondition: For range conditions.
+  /// The index source can determine which columns form the index prefix by
+  /// examining EqualIndexLookupCondition objects where !isFilter().
   /// @param outputType The lookup output type from index source.
   /// @param tableHandle The index table handle.
   /// @param columnHandles The column handles which maps from column name
@@ -607,9 +688,12 @@ class Connector {
   ///
   /// Here,
   /// - 'inputType' is ROW{t.sid, t.event_list}
-  /// - 'numJoinKeys' is 1 since only t.sid is used in join equi-clauses.
-  /// - 'joinConditions' specifies the join condition: contains(t.event_list,
-  ///   u.event_type)
+  /// - 'joinConditions' includes:
+  ///   - EqualIndexLookupCondition(u.sid, t.sid) for the equi-join
+  ///   - InIndexLookupCondition(u.event_type, t.event_list) for the IN
+  ///     condition
+  ///   - BetweenIndexLookupCondition(u.ds, '2024-01-01', '2024-01-07') for the
+  ///     BETWEEN condition
   /// - 'outputType' is ROW{u.event_value}
   /// - 'tableHandle' specifies the metadata of the index table.
   /// - 'columnHandles' is a map from 'u.event_type' (in 'joinConditions') and
@@ -619,7 +703,6 @@ class Connector {
   ///
   virtual std::shared_ptr<IndexSource> createIndexSource(
       const RowTypePtr& inputType,
-      size_t numJoinKeys,
       const std::vector<std::shared_ptr<core::IndexLookupCondition>>&
           joinConditions,
       const RowTypePtr& outputType,
@@ -658,9 +741,37 @@ class Connector {
 
   /// The name of the common runtime stats collected and reported by connector
   /// data/index sources.
-  static inline const std::string kTotalRemainingFilterTime{
+  static constexpr std::string_view kTotalRemainingFilterTime{
       "totalRemainingFilterWallNanos"};
 
+  /// Total CPU time spent on remaining filter evaluation.
+  static inline const std::string kTotalRemainingFilterCpuTime{
+      "totalRemainingFilterCpuNanos"};
+
+  /// Total time spent waiting for synchronously issued IO or for an in-progress
+  /// read-ahead to finish.
+  static constexpr std::string_view kIoWaitWallNanos{"ioWaitWallNanos"};
+
+  /// Time spent waiting for remote storage reads (S3, HDFS, etc.)
+  static constexpr std::string_view kStorageReadWallNanos{
+      "storageReadWallNanos"};
+
+  /// Time spent waiting for SSD cache reads.
+  static constexpr std::string_view kSsdCacheReadWallNanos{
+      "ssdCacheReadWallNanos"};
+
+  /// Time spent waiting for EXCLUSIVE cache entries (another thread is
+  /// loading).
+  static constexpr std::string_view kCacheWaitWallNanos{"cacheWaitWallNanos"};
+
+  /// Time spent waiting for coalesced loads from SSD cache.
+  static constexpr std::string_view kCoalescedSsdLoadWallNanos{
+      "coalescedSsdLoadWallNanos"};
+
+  /// Time spent waiting for coalesced loads from remote storage.
+  static constexpr std::string_view kCoalescedStorageLoadWallNanos{
+      "coalescedStorageLoadWallNanos"};
+
  private:
   static void unregisterTracker(cache::ScanTracker* tracker);
 
@@ -672,66 +783,18 @@ class Connector {
       trackers_;
 };
 
-class ConnectorFactory {
- public:
-  explicit ConnectorFactory(const char* name) : name_(name) {}
-
-  virtual ~ConnectorFactory() = default;
-
-  const std::string& connectorName() const {
-    return name_;
-  }
-
-  virtual std::shared_ptr<Connector> newConnector(
-      const std::string& id,
-      std::shared_ptr<const config::ConfigBase> config,
-      folly::Executor* ioExecutor = nullptr,
-      folly::Executor* cpuExecutor = nullptr) = 0;
+/// Deprecated free functions. Use ConnectorRegistry methods instead.
 
- private:
-  const std::string name_;
-};
+[[deprecated("Use ConnectorRegistry::global().insert() instead.")]]
+bool registerConnector(const std::shared_ptr<Connector>& connector);
 
-/// Adds a factory for creating connectors to the registry using connector
-/// name as the key. Throws if factor with the same name is already present.
-/// Always returns true. The return value makes it easy to use with
-/// FB_ANONYMOUS_VARIABLE.
-bool registerConnectorFactory(std::shared_ptr<ConnectorFactory> factory);
-
-/// Returns true if a connector with the specified name has been registered,
-/// false otherwise.
-bool hasConnectorFactory(const std::string& connectorName);
-
-/// Unregister a connector factory by name.
-/// Returns true if a connector with the specified name has been
-/// unregistered, false otherwise.
-bool unregisterConnectorFactory(const std::string& connectorName);
-
-/// Returns a factory for creating connectors with the specified name.
-/// Throws if factory doesn't exist.
-std::shared_ptr<ConnectorFactory> getConnectorFactory(
-    const std::string& connectorName);
-
-/// Adds connector instance to the registry using connector ID as the key.
-/// Throws if connector with the same ID is already present. Always returns
-/// true. The return value makes it easy to use with FB_ANONYMOUS_VARIABLE.
-bool registerConnector(std::shared_ptr<Connector> connector);
-
-/// Returns true if a connector with the specified ID has been registered, false
-/// otherwise.
+[[deprecated("Use ConnectorRegistry::tryGet() instead.")]]
 bool hasConnector(const std::string& connectorId);
 
-/// Removes the connector with specified ID from the registry. Returns true
-/// if connector was removed and false if connector didn't exist.
+[[deprecated("Use ConnectorRegistry::global().erase() instead.")]]
 bool unregisterConnector(const std::string& connectorId);
 
-/// Returns a connector with specified ID. Throws if connector doesn't
-/// exist.
+[[deprecated("Use ConnectorRegistry::tryGet() instead.")]]
 std::shared_ptr<Connector> getConnector(const std::string& connectorId);
 
-/// Returns a map of all (connectorId -> connector) pairs currently
-/// registered.
-const std::unordered_map<std::string, std::shared_ptr<Connector>>&
-getAllConnectors();
-
 } // namespace facebook::velox::connector
diff --git a/velox/connectors/ConnectorRegistry.cpp b/velox/connectors/ConnectorRegistry.cpp
new file mode 100644
index 00000000000..23155a435a1
--- /dev/null
+++ b/velox/connectors/ConnectorRegistry.cpp
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/ConnectorRegistry.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "velox/connectors/Connector.h"
+#include "velox/connectors/ConnectorRegistryInternal.h"
+#include "velox/core/QueryCtx.h"
+
+namespace facebook::velox::connector {
+
+namespace {
+
+ConnectorRegistry::Registry& registryFor(const core::QueryCtx& queryCtx) {
+  auto registry = queryCtx.registry<ConnectorRegistry::Registry>(
+      ConnectorRegistry::kRegistryKey);
+  return registry ? *registry : ConnectorRegistry::global();
+}
+
+} // namespace
+
+// static
+ConnectorRegistry::Registry& ConnectorRegistry::global() {
+  return connectors();
+}
+
+// static
+std::shared_ptr<ConnectorRegistry::Registry> ConnectorRegistry::create(
+    const Registry* parent) {
+  return std::make_shared<Registry>(parent);
+}
+
+// static
+std::shared_ptr<Connector> ConnectorRegistry::tryGet(
+    const core::QueryCtx& queryCtx,
+    const std::string& connectorId) {
+  return registryFor(queryCtx).find(connectorId);
+}
+
+// static
+std::shared_ptr<Connector> ConnectorRegistry::tryGet(
+    const std::string& connectorId) {
+  return global().find(connectorId);
+}
+
+// static
+void ConnectorRegistry::unregisterAll(const core::QueryCtx& queryCtx) {
+  auto registry = queryCtx.registry<ConnectorRegistry::Registry>(
+      ConnectorRegistry::kRegistryKey);
+  if (registry) {
+    registry->clear();
+  }
+}
+
+// static
+void ConnectorRegistry::unregisterAll() {
+  global().clear();
+}
+
+// static
+std::vector<std::pair<std::string, std::shared_ptr<Connector>>>
+ConnectorRegistry::snapshot(const core::QueryCtx& queryCtx) {
+  return registryFor(queryCtx).snapshot();
+}
+
+} // namespace facebook::velox::connector
diff --git a/velox/connectors/ConnectorRegistry.h b/velox/connectors/ConnectorRegistry.h
new file mode 100644
index 00000000000..c2a61ec81d4
--- /dev/null
+++ b/velox/connectors/ConnectorRegistry.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+#include "velox/common/ScopedRegistry.h"
+#include "velox/connectors/Connector.h"
+
+namespace facebook::velox::core {
+class QueryCtx;
+} // namespace facebook::velox::core
+
+namespace facebook::velox::connector {
+
+/// Manages connector registration and lookup. All methods are thread-safe.
+///
+/// Two groups of APIs:
+///
+/// - Query-scoped APIs take a QueryCtx& and check for per-query registry
+///   overrides before falling back to the global registry. Use these in
+///   operator and expression evaluation code where a QueryCtx is available.
+///
+/// - Global APIs operate directly on the global registry. Use these for
+///   process-level operations: startup registration, shutdown cleanup, and
+///   process-wide lookups (e.g., periodic stats reporting).
+/// All methods are thread-safe.
+class ConnectorRegistry {
+ public:
+  using Registry = ScopedRegistry<std::string, Connector>;
+
+  /// Registry key for per-query connector overrides on QueryCtx.
+  static constexpr std::string_view kRegistryKey = "connectors";
+
+  /// Return the global registry (root scope).
+  static Registry& global();
+
+  /// Create a per-query registry. If 'parent' is provided, lookups fall back
+  /// to it. Pass nullptr for isolation mode (no fallback).
+  static std::shared_ptr<Registry> create(const Registry* parent = nullptr);
+
+  /// Return the connector with the specified ID, or nullptr if not registered.
+  /// Checks per-query override on QueryCtx first, falls back to the global
+  /// registry if no override is set.
+  static std::shared_ptr<Connector> tryGet(
+      const core::QueryCtx& queryCtx,
+      const std::string& connectorId);
+
+  /// Return the connector with the specified ID from the global registry, or
+  /// nullptr if not registered.
+  static std::shared_ptr<Connector> tryGet(const std::string& connectorId);
+
+  /// Return all connectors whose implementation is of type T. Checks per-query
+  /// override on QueryCtx first, falls back to the global registry if no
+  /// override is set.
+  template <typename T>
+  static std::vector<std::shared_ptr<T>> findAll(
+      const core::QueryCtx& queryCtx) {
+    std::vector<std::shared_ptr<T>> result;
+    for (auto& [_, connector] : snapshot(queryCtx)) {
+      if (auto casted = std::dynamic_pointer_cast<T>(connector)) {
+        result.push_back(std::move(casted));
+      }
+    }
+    return result;
+  }
+
+  /// Return all connectors from the global registry whose implementation is
+  /// of type T.
+  template <typename T>
+  static std::vector<std::shared_ptr<T>> findAll() {
+    std::vector<std::shared_ptr<T>> result;
+    for (auto& [_, connector] : global().snapshot()) {
+      if (auto casted = std::dynamic_pointer_cast<T>(connector)) {
+        result.push_back(std::move(casted));
+      }
+    }
+    return result;
+  }
+
+  /// Unregister all connectors from the registry visible to the given query.
+  static void unregisterAll(const core::QueryCtx& queryCtx);
+
+  /// Unregister all connectors from the global registry.
+  static void unregisterAll();
+
+ private:
+  // Return a snapshot of all connectors visible to the given query. Uses
+  // per-query registry if set, otherwise the global registry.
+  static std::vector<std::pair<std::string, std::shared_ptr<Connector>>>
+  snapshot(const core::QueryCtx& queryCtx);
+};
+
+} // namespace facebook::velox::connector
diff --git a/velox/connectors/ConnectorRegistryInternal.h b/velox/connectors/ConnectorRegistryInternal.h
new file mode 100644
index 00000000000..feb55b5e1a4
--- /dev/null
+++ b/velox/connectors/ConnectorRegistryInternal.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+#include "velox/common/ScopedRegistry.h"
+#include "velox/connectors/Connector.h"
+
+namespace facebook::velox::connector {
+
+// Internal helper shared by Connector.cpp and ConnectorRegistry.cpp.
+// Not part of the public API. Do not include from outside velox/connectors/.
+ScopedRegistry<std::string, Connector>& connectors();
+
+} // namespace facebook::velox::connector
diff --git a/velox/connectors/fuzzer/CMakeLists.txt b/velox/connectors/fuzzer/CMakeLists.txt
index 8e21030f99d..09f9772cc01 100644
--- a/velox/connectors/fuzzer/CMakeLists.txt
+++ b/velox/connectors/fuzzer/CMakeLists.txt
@@ -13,6 +13,7 @@
 # limitations under the License.
 
 add_library(velox_fuzzer_connector OBJECT FuzzerConnector.cpp)
+velox_add_test_headers(velox_fuzzer_connector FuzzerConnector.h FuzzerConnectorSplit.h)
 
 target_link_libraries(velox_fuzzer_connector velox_connector velox_vector_fuzzer)
 
diff --git a/velox/connectors/fuzzer/FuzzerConnector.h b/velox/connectors/fuzzer/FuzzerConnector.h
index 53e94b5f638..5b3f9bf74e2 100644
--- a/velox/connectors/fuzzer/FuzzerConnector.h
+++ b/velox/connectors/fuzzer/FuzzerConnector.h
@@ -77,7 +77,7 @@ class FuzzerDataSource : public DataSource {
     return completedBytes_;
   }
 
-  std::unordered_map<std::string, RuntimeCounter> runtimeStats() override {
+  std::unordered_map<std::string, RuntimeMetric> getRuntimeStats() override {
     // TODO: Which stats do we want to expose here?
     return {};
   }
diff --git a/velox/connectors/fuzzer/tests/CMakeLists.txt b/velox/connectors/fuzzer/tests/CMakeLists.txt
index 6f0dbf3b647..14528bf0b01 100644
--- a/velox/connectors/fuzzer/tests/CMakeLists.txt
+++ b/velox/connectors/fuzzer/tests/CMakeLists.txt
@@ -24,3 +24,5 @@ target_link_libraries(
   GTest::gtest
   GTest::gtest_main
 )
+
+velox_add_library(velox_fuzzer_connector_lib INTERFACE HEADERS FuzzerConnectorTestBase.h)
diff --git a/velox/connectors/fuzzer/tests/FuzzerConnectorTestBase.h b/velox/connectors/fuzzer/tests/FuzzerConnectorTestBase.h
index b0c703f54bc..7b38fb23cdc 100644
--- a/velox/connectors/fuzzer/tests/FuzzerConnectorTestBase.h
+++ b/velox/connectors/fuzzer/tests/FuzzerConnectorTestBase.h
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/fuzzer/FuzzerConnector.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
@@ -28,11 +29,12 @@ class FuzzerConnectorTestBase : public exec::test::OperatorTestBase {
     OperatorTestBase::SetUp();
     connector::fuzzer::FuzzerConnectorFactory factory;
     auto fuzzerConnector = factory.newConnector(kFuzzerConnectorId, nullptr);
-    connector::registerConnector(fuzzerConnector);
+    connector::ConnectorRegistry::global().insert(
+        fuzzerConnector->connectorId(), fuzzerConnector);
   }
 
   void TearDown() override {
-    connector::unregisterConnector(kFuzzerConnectorId);
+    connector::ConnectorRegistry::global().erase(kFuzzerConnectorId);
     OperatorTestBase::TearDown();
   }
 
diff --git a/velox/connectors/hive/BufferedInputBuilder.cpp b/velox/connectors/hive/BufferedInputBuilder.cpp
new file mode 100644
index 00000000000..082c77c1922
--- /dev/null
+++ b/velox/connectors/hive/BufferedInputBuilder.cpp
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/BufferedInputBuilder.h"
+#include "velox/connectors/hive/HiveConnectorUtil.h"
+
+namespace facebook::velox::connector::hive {
+
+class DefaultBufferInputBuilder : public BufferedInputBuilder {
+ public:
+  std::unique_ptr<dwio::common::BufferedInput> create(
+      const FileHandle& fileHandle,
+      const dwio::common::ReaderOptions& readerOpts,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      std::shared_ptr<io::IoStatistics> ioStatistics,
+      std::shared_ptr<IoStats> ioStats,
+      folly::Executor* executor,
+      const folly::F14FastMap<std::string, std::string>& fileReadOps) override {
+    return createBufferedInput(
+        fileHandle,
+        readerOpts,
+        connectorQueryCtx,
+        ioStatistics,
+        ioStats,
+        executor,
+        fileReadOps);
+  }
+};
+
+// static
+std::shared_ptr<BufferedInputBuilder> BufferedInputBuilder::builder_ =
+    std::make_shared<DefaultBufferInputBuilder>();
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/BufferedInputBuilder.h b/velox/connectors/hive/BufferedInputBuilder.h
new file mode 100644
index 00000000000..583ec71c5c1
--- /dev/null
+++ b/velox/connectors/hive/BufferedInputBuilder.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#include <folly/Executor.h>
+
+#include "velox/connectors/Connector.h"
+#include "velox/connectors/hive/FileHandle.h"
+#include "velox/dwio/common/BufferedInput.h"
+#include "velox/dwio/common/Reader.h"
+
+namespace facebook::velox::connector::hive {
+
+/// Registering a different implementation of BufferedInput is allowed using
+/// 'registerBuilder' API.
+class BufferedInputBuilder {
+ public:
+  virtual ~BufferedInputBuilder() = default;
+
+  static const std::shared_ptr<BufferedInputBuilder>& getInstance() {
+    VELOX_CHECK_NOT_NULL(builder_, "Builder is not registered");
+    return builder_;
+  }
+
+  static void registerBuilder(std::shared_ptr<BufferedInputBuilder> builder) {
+    VELOX_CHECK_NOT_NULL(builder);
+    builder_ = std::move(builder);
+  }
+
+  virtual std::unique_ptr<dwio::common::BufferedInput> create(
+      const FileHandle& fileHandle,
+      const dwio::common::ReaderOptions& readerOpts,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      std::shared_ptr<io::IoStatistics> ioStatistics,
+      std::shared_ptr<IoStats> ioStats,
+      folly::Executor* executor,
+      const folly::F14FastMap<std::string, std::string>& fileReadOps = {}) = 0;
+
+ private:
+  static std::shared_ptr<BufferedInputBuilder> builder_;
+};
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/CMakeLists.txt b/velox/connectors/hive/CMakeLists.txt
index e7bbb90fe04..f2b941d6e71 100644
--- a/velox/connectors/hive/CMakeLists.txt
+++ b/velox/connectors/hive/CMakeLists.txt
@@ -12,31 +12,77 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_hive_config OBJECT HiveConfig.cpp)
+velox_add_library(velox_hive_config OBJECT FileConfig.cpp HiveConfig.cpp)
 velox_link_libraries(velox_hive_config velox_core velox_exception)
 
 add_subdirectory(iceberg)
+add_subdirectory(paimon)
 
 velox_add_library(
   velox_hive_connector
   OBJECT
-  FileHandle.cpp
+  BufferedInputBuilder.cpp
+  ExtractionUtils.cpp
+  ExtractionUtils.h
+  FileColumnHandle.cpp
+  FileConfig.cpp
+  FileConnectorUtil.cpp
+  FileDataSink.cpp
+  FileDataSource.cpp
+  FileIndexReader.cpp
+  FileSplitReader.cpp
   HiveConfig.cpp
+  HiveConfigProvider.cpp
   HiveConnector.cpp
-  HiveConnectorUtil.cpp
   HiveConnectorSplit.cpp
+  HiveConnectorUtil.cpp
   HiveDataSink.cpp
   HiveDataSource.cpp
-  HivePartitionUtil.cpp
+  HiveIndexSource.cpp
+  HivePartitionName.cpp
+  HiveSplitReader.cpp
   PartitionIdGenerator.cpp
-  SplitReader.cpp
   TableHandle.cpp
+  HEADERS
+  BufferedInputBuilder.h
+  FileColumnHandle.h
+  FileConfig.h
+  FileConnectorSplit.h
+  FileConnectorUtil.h
+  FileDataSink.h
+  FileDataSource.h
+  FileHandle.h
+  FileIndexReader.h
+  FileProperties.h
+  FileSplitReader.h
+  FileTableHandle.h
+  HiveConfig.h
+  HiveConfigMacrosDefine.h
+  HiveConfigMacrosUndef.h
+  HiveConfigProvider.h
+  HiveConnector.h
+  HiveConnectorSplit.h
+  HiveConnectorUtil.h
+  HiveDataSink.h
+  HiveDataSource.h
+  HiveIndexSource.h
+  HivePartitionFunction.h
+  HivePartitionName.h
+  HiveSplitReader.h
+  IndexReader.h
+  PartitionIdGenerator.h
+  TableHandle.h
 )
 
 velox_link_libraries(
   velox_hive_connector
-  PUBLIC velox_hive_iceberg_splitreader
-  PRIVATE velox_common_io velox_connector velox_dwio_catalog_fbhive velox_hive_partition_function
+  PRIVATE
+    velox_common_io
+    velox_connector
+    velox_dwio_catalog_fbhive
+    velox_exec
+    velox_hive_partition_function
+    velox_key_encoder
 )
 
 velox_add_library(velox_hive_partition_function HivePartitionFunction.cpp)
diff --git a/velox/connectors/hive/ExtractionUtils.cpp b/velox/connectors/hive/ExtractionUtils.cpp
new file mode 100644
index 00000000000..b660c1cecae
--- /dev/null
+++ b/velox/connectors/hive/ExtractionUtils.cpp
@@ -0,0 +1,531 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/ExtractionUtils.h"
+
+#include "velox/type/Filter.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::connector::hive {
+
+namespace {
+
+/// Extract sizes from a MapVector or ArrayVector as a FlatVector<int64_t>.
+VectorPtr extractSizes(const VectorPtr& input, memory::MemoryPool* pool) {
+  auto numRows = input->size();
+  auto sizesBuf = AlignedBuffer::allocate<int64_t>(numRows, pool);
+  auto* sizesData = sizesBuf->asMutable<int64_t>();
+
+  const vector_size_t* rawSizes;
+  if (input->typeKind() == TypeKind::MAP) {
+    rawSizes = input->as<MapVector>()->rawSizes();
+  } else {
+    rawSizes = input->as<ArrayVector>()->rawSizes();
+  }
+  for (vector_size_t i = 0; i < numRows; ++i) {
+    sizesData[i] = rawSizes[i];
+  }
+
+  return std::make_shared<FlatVector<int64_t>>(
+      pool,
+      BIGINT(),
+      input->nulls(),
+      numRows,
+      std::move(sizesBuf),
+      std::vector<BufferPtr>{});
+}
+
+/// Filter a MapVector to only keep entries with matching keys.
+VectorPtr filterMapByKeys(
+    const VectorPtr& input,
+    const ExtractionPathElement& step,
+    memory::MemoryPool* pool) {
+  auto* map = input->as<MapVector>();
+  auto numRows = map->size();
+  auto* rawOffsets = map->rawOffsets();
+  auto* rawSizes = map->rawSizes();
+  auto mapKeys = map->mapKeys();
+  auto mapValues = map->mapValues();
+
+  // Build output offsets and sizes, and a mapping of which key-value pairs
+  // to keep.
+  auto newOffsetsBuf = AlignedBuffer::allocate<vector_size_t>(numRows, pool);
+  auto newSizesBuf = AlignedBuffer::allocate<vector_size_t>(numRows, pool);
+  auto* newOffsets = newOffsetsBuf->asMutable<vector_size_t>();
+  auto* newSizes = newSizesBuf->asMutable<vector_size_t>();
+
+  // Build keep flags for all key-value pairs across all map entries.
+  std::vector<bool> keepFlags;
+  vector_size_t totalInputElements = 0;
+  for (vector_size_t i = 0; i < numRows; ++i) {
+    totalInputElements += rawSizes[i];
+  }
+  keepFlags.resize(totalInputElements, false);
+
+  if (totalInputElements == 0) {
+    // All maps are empty; return the input as-is with zeroed sizes.
+    return std::make_shared<MapVector>(
+        pool,
+        input->type(),
+        map->nulls(),
+        numRows,
+        std::move(newOffsetsBuf),
+        std::move(newSizesBuf),
+        mapKeys,
+        mapValues);
+  }
+
+  auto* stringFilter =
+      dynamic_cast<const StringMapKeyFilterExtractionPathElement*>(&step);
+  if (stringFilter) {
+    std::unordered_set<std::string> keySet(
+        stringFilter->filterKeys().begin(), stringFilter->filterKeys().end());
+    auto* keyVector = mapKeys->as<SimpleVector<StringView>>();
+    for (vector_size_t i = 0; i < totalInputElements; ++i) {
+      VELOX_DCHECK_LT(
+          static_cast<size_t>(i), keepFlags.size(), "Index out of bounds");
+      if (!keyVector->isNullAt(i) &&
+          keySet.count(std::string(keyVector->valueAt(i))) > 0) {
+        keepFlags[i] = true;
+      }
+    }
+  } else {
+    auto& intFilter =
+        static_cast<const IntMapKeyFilterExtractionPathElement&>(step);
+    std::unordered_set<int64_t> keySet(
+        intFilter.filterKeys().begin(), intFilter.filterKeys().end());
+    auto* keyVector = mapKeys->as<SimpleVector<int64_t>>();
+    for (vector_size_t i = 0; i < totalInputElements; ++i) {
+      VELOX_DCHECK_LT(
+          static_cast<size_t>(i), keepFlags.size(), "Index out of bounds");
+      if (!keyVector->isNullAt(i) && keySet.count(keyVector->valueAt(i)) > 0) {
+        keepFlags[i] = true;
+      }
+    }
+  }
+
+  // Count kept entries per map.
+  vector_size_t totalKept = 0;
+  for (vector_size_t i = 0; i < numRows; ++i) {
+    newOffsets[i] = totalKept;
+    vector_size_t kept = 0;
+    for (vector_size_t j = 0; j < rawSizes[i]; ++j) {
+      VELOX_DCHECK_LT(
+          static_cast<size_t>(rawOffsets[i] + j),
+          keepFlags.size(),
+          "Index out of bounds");
+      if (keepFlags[rawOffsets[i] + j]) {
+        ++kept;
+      }
+    }
+    newSizes[i] = kept;
+    totalKept += kept;
+  }
+
+  // Build index mapping for kept entries.
+  auto indexBuf = AlignedBuffer::allocate<vector_size_t>(totalKept, pool);
+  auto* indices = indexBuf->asMutable<vector_size_t>();
+  vector_size_t outIdx = 0;
+  for (vector_size_t i = 0; i < numRows; ++i) {
+    for (vector_size_t j = 0; j < rawSizes[i]; ++j) {
+      auto srcIdx = rawOffsets[i] + j;
+      VELOX_DCHECK_LT(
+          static_cast<size_t>(srcIdx), keepFlags.size(), "Index out of bounds");
+      if (keepFlags[srcIdx]) {
+        indices[outIdx++] = srcIdx;
+      }
+    }
+  }
+
+  // Create filtered keys and values using dictionary wrapping.
+  auto filteredKeys =
+      BaseVector::wrapInDictionary(nullptr, indexBuf, totalKept, mapKeys);
+  auto filteredValues =
+      BaseVector::wrapInDictionary(nullptr, indexBuf, totalKept, mapValues);
+
+  return std::make_shared<MapVector>(
+      pool,
+      input->type(),
+      map->nulls(),
+      numRows,
+      std::move(newOffsetsBuf),
+      std::move(newSizesBuf),
+      filteredKeys,
+      filteredValues);
+}
+
+/// Recursive implementation of extraction chain application.
+VectorPtr applyExtractionChainImpl(
+    const VectorPtr& input,
+    const std::vector<ExtractionPathElementPtr>& chain,
+    size_t index,
+    memory::MemoryPool* pool) {
+  if (index >= chain.size()) {
+    return input;
+  }
+
+  const auto& step = chain[index];
+  switch (step->step()) {
+    case ExtractionStep::kStructField: {
+      auto* row = input->as<RowVector>();
+      VELOX_CHECK_NOT_NULL(row);
+      auto& fieldName =
+          static_cast<const StructFieldExtractionPathElement&>(*step)
+              .fieldName();
+      auto childIdx = input->type()->asRow().getChildIdx(fieldName);
+      return applyExtractionChainImpl(
+          row->childAt(childIdx), chain, index + 1, pool);
+    }
+
+    case ExtractionStep::kMapKeys: {
+      auto* map = input->as<MapVector>();
+      VELOX_CHECK_NOT_NULL(map);
+      if (index + 1 >= chain.size()) {
+        return std::make_shared<ArrayVector>(
+            pool,
+            ARRAY(map->mapKeys()->type()),
+            map->nulls(),
+            map->size(),
+            map->offsets(),
+            map->sizes(),
+            map->mapKeys());
+      }
+      VELOX_CHECK_EQ(
+          static_cast<int>(chain[index + 1]->step()),
+          static_cast<int>(ExtractionStep::kArrayElements));
+      auto transformedKeys =
+          applyExtractionChainImpl(map->mapKeys(), chain, index + 2, pool);
+      return std::make_shared<ArrayVector>(
+          pool,
+          ARRAY(transformedKeys->type()),
+          map->nulls(),
+          map->size(),
+          map->offsets(),
+          map->sizes(),
+          transformedKeys);
+    }
+
+    case ExtractionStep::kMapValues: {
+      auto* map = input->as<MapVector>();
+      VELOX_CHECK_NOT_NULL(map);
+      if (index + 1 >= chain.size()) {
+        return std::make_shared<ArrayVector>(
+            pool,
+            ARRAY(map->mapValues()->type()),
+            map->nulls(),
+            map->size(),
+            map->offsets(),
+            map->sizes(),
+            map->mapValues());
+      }
+      VELOX_CHECK_EQ(
+          static_cast<int>(chain[index + 1]->step()),
+          static_cast<int>(ExtractionStep::kArrayElements));
+      auto transformedValues =
+          applyExtractionChainImpl(map->mapValues(), chain, index + 2, pool);
+      return std::make_shared<ArrayVector>(
+          pool,
+          ARRAY(transformedValues->type()),
+          map->nulls(),
+          map->size(),
+          map->offsets(),
+          map->sizes(),
+          transformedValues);
+    }
+
+    case ExtractionStep::kMapKeyFilter: {
+      auto filtered = filterMapByKeys(input, *step, pool);
+      return applyExtractionChainImpl(filtered, chain, index + 1, pool);
+    }
+
+    case ExtractionStep::kArrayElements: {
+      auto* array = input->as<ArrayVector>();
+      VELOX_CHECK_NOT_NULL(array);
+      if (index + 1 >= chain.size()) {
+        return input;
+      }
+      auto transformedElements =
+          applyExtractionChainImpl(array->elements(), chain, index + 1, pool);
+      return std::make_shared<ArrayVector>(
+          pool,
+          ARRAY(transformedElements->type()),
+          array->nulls(),
+          array->size(),
+          array->offsets(),
+          array->sizes(),
+          transformedElements);
+    }
+
+    case ExtractionStep::kSize: {
+      return extractSizes(input, pool);
+    }
+  }
+  VELOX_UNREACHABLE();
+}
+
+/// Analyze extraction chains on a ROW type to determine which fields are
+/// needed.
+std::unordered_set<std::string> analyzeStructNeeds(
+    const std::vector<NamedExtraction>& extractions) {
+  std::unordered_set<std::string> neededFields;
+  for (const auto& extraction : extractions) {
+    if (extraction.chain.empty()) {
+      // Pass-through: need all fields.
+      return {};
+    }
+    if (extraction.chain[0]->step() == ExtractionStep::kStructField) {
+      neededFields.insert(
+          static_cast<const StructFieldExtractionPathElement&>(
+              *extraction.chain[0])
+              .fieldName());
+    } else {
+      // Non-struct step on a struct: need everything.
+      return {};
+    }
+  }
+  return neededFields;
+}
+
+/// Build sub-chains by stripping the first step from each extraction chain.
+/// For MapKeys/MapValues, also strips the following ArrayElements step.
+/// Only includes extractions whose first step matches 'firstStep'.
+/// For ROW StructField, only includes extractions targeting 'fieldName'.
+std::vector<NamedExtraction> buildSubChains(
+    const std::vector<NamedExtraction>& extractions,
+    ExtractionStep firstStep,
+    const std::string& fieldName = "") {
+  std::vector<NamedExtraction> subChains;
+  for (const auto& extraction : extractions) {
+    if (extraction.chain.empty()) {
+      continue;
+    }
+    if (extraction.chain[0]->step() != firstStep) {
+      continue;
+    }
+    if (firstStep == ExtractionStep::kStructField) {
+      const auto& name = static_cast<const StructFieldExtractionPathElement&>(
+                             *extraction.chain[0])
+                             .fieldName();
+      if (name != fieldName) {
+        continue;
+      }
+    }
+
+    // Determine how many leading steps to skip.
+    size_t skip = 1;
+    if ((firstStep == ExtractionStep::kMapKeys ||
+         firstStep == ExtractionStep::kMapValues) &&
+        skip < extraction.chain.size() &&
+        extraction.chain[skip]->step() == ExtractionStep::kArrayElements) {
+      ++skip;
+    }
+
+    if (skip < extraction.chain.size()) {
+      NamedExtraction sub;
+      sub.outputName = extraction.outputName;
+      sub.chain = std::vector<ExtractionPathElementPtr>(
+          extraction.chain.begin() + static_cast<ptrdiff_t>(skip),
+          extraction.chain.end());
+      sub.dataType = extraction.dataType;
+      subChains.push_back(std::move(sub));
+    }
+  }
+  return subChains;
+}
+
+} // namespace
+
+VectorPtr applyExtractionChain(
+    const VectorPtr& input,
+    const std::vector<ExtractionPathElementPtr>& chain,
+    memory::MemoryPool* pool) {
+  return applyExtractionChainImpl(input, chain, 0, pool);
+}
+
+void configureExtractionScanSpec(
+    const TypePtr& hiveType,
+    const std::vector<NamedExtraction>& extractions,
+    common::ScanSpec& spec,
+    memory::MemoryPool* pool) {
+  if (extractions.empty()) {
+    return;
+  }
+
+  switch (hiveType->kind()) { // NOLINT(clang-diagnostic-switch-enum)
+    case TypeKind::MAP: {
+      // Determine the extraction type from the first step of all chains.
+      bool allKeys = true;
+      bool allValues = true;
+      bool allSize = true;
+      bool allMapKeyFilter = true;
+      for (const auto& extraction : extractions) {
+        if (extraction.chain.empty()) {
+          allKeys = false;
+          allValues = false;
+          allSize = false;
+          allMapKeyFilter = false;
+          break;
+        }
+        auto firstStep = extraction.chain[0]->step();
+        if (firstStep != ExtractionStep::kMapKeys) {
+          allKeys = false;
+        }
+        if (firstStep != ExtractionStep::kMapValues) {
+          allValues = false;
+        }
+        if (firstStep != ExtractionStep::kSize) {
+          allSize = false;
+        }
+        if (firstStep != ExtractionStep::kMapKeyFilter) {
+          allMapKeyFilter = false;
+        }
+      }
+
+      if (allSize) {
+        spec.setExtractionType(common::ScanSpec::ExtractionType::kSize);
+      } else if (allKeys) {
+        spec.setExtractionType(common::ScanSpec::ExtractionType::kKeys);
+        auto subChains = buildSubChains(extractions, ExtractionStep::kMapKeys);
+        if (!subChains.empty()) {
+          auto* keysSpec =
+              spec.childByName(common::ScanSpec::kMapKeysFieldName);
+          if (keysSpec) {
+            configureExtractionScanSpec(
+                hiveType->asMap().keyType(), subChains, *keysSpec, pool);
+          }
+        }
+      } else if (allValues) {
+        spec.setExtractionType(common::ScanSpec::ExtractionType::kValues);
+        auto subChains =
+            buildSubChains(extractions, ExtractionStep::kMapValues);
+        if (!subChains.empty()) {
+          auto* valuesSpec =
+              spec.childByName(common::ScanSpec::kMapValuesFieldName);
+          if (valuesSpec) {
+            configureExtractionScanSpec(
+                hiveType->asMap().valueType(), subChains, *valuesSpec, pool);
+          }
+        }
+      } else if (allMapKeyFilter) {
+        // kMapKeyFilter is type-preserving (MAP -> MAP), so no ExtractionType
+        // is set.  Instead, add an IN filter on the map keys ScanSpec so the
+        // reader can skip non-matching key-value pairs.
+        auto* keysSpec = spec.childByName(common::ScanSpec::kMapKeysFieldName);
+        if (keysSpec) {
+          // Merge filter keys from all extraction chains.
+          std::vector<std::string> mergedStringKeys;
+          std::vector<int64_t> mergedIntKeys;
+          bool useStringKeys = false;
+          for (const auto& extraction : extractions) {
+            if (auto* strFilter = dynamic_cast<
+                    const StringMapKeyFilterExtractionPathElement*>(
+                    extraction.chain[0].get())) {
+              useStringKeys = true;
+              mergedStringKeys.insert(
+                  mergedStringKeys.end(),
+                  strFilter->filterKeys().begin(),
+                  strFilter->filterKeys().end());
+            } else if (
+                auto* intFilter =
+                    dynamic_cast<const IntMapKeyFilterExtractionPathElement*>(
+                        extraction.chain[0].get())) {
+              mergedIntKeys.insert(
+                  mergedIntKeys.end(),
+                  intFilter->filterKeys().begin(),
+                  intFilter->filterKeys().end());
+            }
+          }
+
+          if (useStringKeys) {
+            keysSpec->setFilter(
+                std::make_unique<common::BytesValues>(
+                    mergedStringKeys, /*nullAllowed=*/false));
+          } else {
+            keysSpec->setFilter(
+                common::createBigintValues(
+                    mergedIntKeys, /*nullAllowed=*/false));
+          }
+        }
+
+        // Recurse with remaining chains (strip the kMapKeyFilter step).
+        auto subChains =
+            buildSubChains(extractions, ExtractionStep::kMapKeyFilter);
+        if (!subChains.empty()) {
+          configureExtractionScanSpec(hiveType, subChains, spec, pool);
+        }
+      }
+      break;
+    }
+    case TypeKind::ARRAY: {
+      bool allSize = true;
+      for (const auto& extraction : extractions) {
+        if (extraction.chain.empty() ||
+            extraction.chain[0]->step() != ExtractionStep::kSize) {
+          allSize = false;
+          break;
+        }
+      }
+      if (allSize) {
+        spec.setExtractionType(common::ScanSpec::ExtractionType::kSize);
+      }
+      break;
+    }
+    case TypeKind::ROW: {
+      auto neededFields = analyzeStructNeeds(extractions);
+      if (neededFields.empty()) {
+        // Need all fields: no pruning.
+        break;
+      }
+      const auto& rowType = hiveType->asRow();
+
+      // If exactly one field is needed, set kField extraction so the struct
+      // reader produces the field's vector directly instead of a RowVector.
+      if (neededFields.size() == 1) {
+        auto& onlyFieldName = *neededFields.begin();
+        auto fieldIdx = rowType.getChildIdx(onlyFieldName);
+        spec.setExtractionType(common::ScanSpec::ExtractionType::kField);
+        spec.setExtractionFieldIndex(fieldIdx);
+      }
+
+      for (uint32_t i = 0; i < rowType.size(); ++i) {
+        auto& fieldName = rowType.nameOf(i);
+        if (neededFields.count(fieldName) == 0) {
+          auto* child = spec.childByName(fieldName);
+          if (child) {
+            child->setConstantValue(
+                BaseVector::createNullConstant(rowType.childAt(i), 1, pool));
+          }
+        } else {
+          // Recurse into needed fields with their sub-chains.
+          auto subChains = buildSubChains(
+              extractions, ExtractionStep::kStructField, fieldName);
+          if (!subChains.empty()) {
+            auto* child = spec.childByName(fieldName);
+            if (child) {
+              configureExtractionScanSpec(
+                  rowType.childAt(i), subChains, *child, pool);
+            }
+          }
+        }
+      }
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/ExtractionUtils.h b/velox/connectors/hive/ExtractionUtils.h
new file mode 100644
index 00000000000..a803a66f35a
--- /dev/null
+++ b/velox/connectors/hive/ExtractionUtils.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/connectors/hive/TableHandle.h"
+#include "velox/dwio/common/ScanSpec.h"
+#include "velox/vector/ComplexVector.h"
+
+namespace facebook::velox::connector::hive {
+
+/// Apply an extraction chain to a vector, producing the output vector.
+/// The input vector must have a type compatible with the chain's expected
+/// input type.  The output vector has the type derived by the chain.
+///
+/// For multiple named extractions from the same column, call this once
+/// per extraction chain and assemble the results into a RowVector.
+VectorPtr applyExtractionChain(
+    const VectorPtr& input,
+    const std::vector<ExtractionPathElementPtr>& chain,
+    memory::MemoryPool* pool);
+
+/// Configure a ScanSpec for a column that has extraction chains.
+/// Analyzes the extraction chains and marks unneeded sub-streams as
+/// constant null so the reader can skip them (DWRF/Nimble pushdown).
+///
+/// This is an optimization — correctness is guaranteed by the
+/// post-read extraction in applyExtractionChain even without these hints.
+void configureExtractionScanSpec(
+    const TypePtr& hiveType,
+    const std::vector<NamedExtraction>& extractions,
+    common::ScanSpec& spec,
+    memory::MemoryPool* pool);
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/FileColumnHandle.cpp b/velox/connectors/hive/FileColumnHandle.cpp
new file mode 100644
index 00000000000..07e55acec33
--- /dev/null
+++ b/velox/connectors/hive/FileColumnHandle.cpp
@@ -0,0 +1,296 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/FileColumnHandle.h"
+
+namespace facebook::velox::connector::hive {
+namespace {
+
+const std::unordered_map<FileColumnHandle::ColumnType, std::string>&
+columnTypeNames() {
+  static const std::unordered_map<FileColumnHandle::ColumnType, std::string>
+      kColumnTypeNames = {
+          {FileColumnHandle::ColumnType::kPartitionKey, "PartitionKey"},
+          {FileColumnHandle::ColumnType::kRegular, "Regular"},
+          {FileColumnHandle::ColumnType::kSynthesized, "Synthesized"},
+          {FileColumnHandle::ColumnType::kRowIndex, "RowIndex"},
+          {FileColumnHandle::ColumnType::kRowId, "RowId"},
+      };
+  return kColumnTypeNames;
+}
+
+template <typename K, typename V>
+std::unordered_map<V, K> invertMap(const std::unordered_map<K, V>& mapping) {
+  std::unordered_map<V, K> inverted;
+  for (const auto& [key, value] : mapping) {
+    inverted.emplace(value, key);
+  }
+  return inverted;
+}
+
+std::unordered_map<ExtractionStep, std::string> extractionStepNames() {
+  return {
+      {ExtractionStep::kStructField, "STRUCT_FIELD"},
+      {ExtractionStep::kMapKeys, "MAP_KEYS"},
+      {ExtractionStep::kMapValues, "MAP_VALUES"},
+      {ExtractionStep::kMapKeyFilter, "MAP_KEY_FILTER"},
+      {ExtractionStep::kArrayElements, "ARRAY_ELEMENTS"},
+      {ExtractionStep::kSize, "SIZE"},
+  };
+}
+
+// Validate the extraction chain against the input type for step
+// compatibility.  Each step's output feeds as input to the next step.
+void validateExtractionChain(
+    const TypePtr& inputType,
+    const std::vector<ExtractionPathElementPtr>& chain) {
+  auto currentType = inputType;
+  for (size_t i = 0; i < chain.size(); ++i) {
+    const auto& element = chain[i];
+    switch (element->step()) {
+      case ExtractionStep::kStructField: {
+        VELOX_USER_CHECK(
+            currentType->isRow(),
+            "Extraction step StructField requires ROW input, got: {}",
+            currentType->toString());
+        const auto& rowType = currentType->asRow();
+        auto& fieldName =
+            static_cast<const StructFieldExtractionPathElement&>(*element)
+                .fieldName();
+        VELOX_USER_CHECK(
+            rowType.containsChild(fieldName),
+            "Extraction step StructField references non-existent field: {}",
+            fieldName);
+        currentType = rowType.findChild(fieldName);
+        break;
+      }
+      case ExtractionStep::kMapKeys: {
+        VELOX_USER_CHECK(
+            currentType->isMap(),
+            "Extraction step MapKeys requires MAP input, got: {}",
+            currentType->toString());
+        currentType = ARRAY(currentType->asMap().keyType());
+        break;
+      }
+      case ExtractionStep::kMapValues: {
+        VELOX_USER_CHECK(
+            currentType->isMap(),
+            "Extraction step MapValues requires MAP input, got: {}",
+            currentType->toString());
+        currentType = ARRAY(currentType->asMap().valueType());
+        break;
+      }
+      case ExtractionStep::kMapKeyFilter: {
+        VELOX_USER_CHECK(
+            currentType->isMap(),
+            "Extraction step MapKeyFilter requires MAP input, got: {}",
+            currentType->toString());
+        // Type-preserving: MAP(K, V) -> MAP(K, V).
+        break;
+      }
+      case ExtractionStep::kArrayElements: {
+        VELOX_USER_CHECK(
+            currentType->isArray(),
+            "Extraction step ArrayElements requires ARRAY input, got: {}",
+            currentType->toString());
+        currentType = currentType->asArray().elementType();
+        break;
+      }
+      case ExtractionStep::kSize: {
+        VELOX_USER_CHECK(
+            currentType->isMap() || currentType->isArray(),
+            "Extraction step Size requires MAP or ARRAY input, got: {}",
+            currentType->toString());
+        VELOX_USER_CHECK_EQ(
+            i,
+            chain.size() - 1,
+            "Extraction step Size must be the last step in the chain.");
+        currentType = BIGINT();
+        break;
+      }
+    }
+  }
+}
+
+// Recursively derive the output type from the input type and extraction
+// chain.  This follows the derivation rules in the design document.
+TypePtr deriveOutputTypeImpl(
+    const TypePtr& inputType,
+    const std::vector<ExtractionPathElementPtr>& chain,
+    size_t index) {
+  if (index >= chain.size()) {
+    return inputType;
+  }
+
+  const auto& element = chain[index];
+  switch (element->step()) {
+    case ExtractionStep::kStructField: {
+      VELOX_CHECK(inputType->isRow());
+      auto& fieldName =
+          static_cast<const StructFieldExtractionPathElement&>(*element)
+              .fieldName();
+      auto childType = inputType->asRow().findChild(fieldName);
+      return deriveOutputTypeImpl(childType, chain, index + 1);
+    }
+    case ExtractionStep::kMapKeys: {
+      VELOX_CHECK(inputType->isMap());
+      auto keyType = inputType->asMap().keyType();
+      if (index + 1 >= chain.size()) {
+        return ARRAY(keyType);
+      }
+      VELOX_CHECK_EQ(
+          static_cast<int>(chain[index + 1]->step()),
+          static_cast<int>(ExtractionStep::kArrayElements));
+      return ARRAY(deriveOutputTypeImpl(keyType, chain, index + 2));
+    }
+    case ExtractionStep::kMapValues: {
+      VELOX_CHECK(inputType->isMap());
+      auto valueType = inputType->asMap().valueType();
+      if (index + 1 >= chain.size()) {
+        return ARRAY(valueType);
+      }
+      VELOX_CHECK_EQ(
+          static_cast<int>(chain[index + 1]->step()),
+          static_cast<int>(ExtractionStep::kArrayElements));
+      return ARRAY(deriveOutputTypeImpl(valueType, chain, index + 2));
+    }
+    case ExtractionStep::kMapKeyFilter: {
+      VELOX_CHECK(inputType->isMap());
+      return deriveOutputTypeImpl(inputType, chain, index + 1);
+    }
+    case ExtractionStep::kArrayElements: {
+      VELOX_CHECK(inputType->isArray());
+      auto elementType = inputType->asArray().elementType();
+      return ARRAY(deriveOutputTypeImpl(elementType, chain, index + 1));
+    }
+    case ExtractionStep::kSize: {
+      VELOX_CHECK(inputType->isMap() || inputType->isArray());
+      return BIGINT();
+    }
+  }
+  VELOX_UNREACHABLE();
+}
+
+} // namespace
+
+bool extractionPathElementEquals(
+    const ExtractionPathElement& lhs,
+    const ExtractionPathElement& rhs) {
+  if (lhs.step() != rhs.step()) {
+    return false;
+  }
+  switch (lhs.step()) {
+    case ExtractionStep::kStructField:
+      return static_cast<const StructFieldExtractionPathElement&>(lhs)
+                 .fieldName() ==
+          static_cast<const StructFieldExtractionPathElement&>(rhs).fieldName();
+    case ExtractionStep::kMapKeyFilter: {
+      if (auto* lStr =
+              dynamic_cast<const StringMapKeyFilterExtractionPathElement*>(
+                  &lhs)) {
+        auto* rStr =
+            dynamic_cast<const StringMapKeyFilterExtractionPathElement*>(&rhs);
+        return rStr && lStr->filterKeys() == rStr->filterKeys();
+      }
+      if (auto* lInt =
+              dynamic_cast<const IntMapKeyFilterExtractionPathElement*>(&lhs)) {
+        auto* rInt =
+            dynamic_cast<const IntMapKeyFilterExtractionPathElement*>(&rhs);
+        return rInt && lInt->filterKeys() == rInt->filterKeys();
+      }
+      return false;
+    }
+    case ExtractionStep::kMapKeys:
+    case ExtractionStep::kMapValues:
+    case ExtractionStep::kArrayElements:
+    case ExtractionStep::kSize:
+      return true;
+  }
+  VELOX_UNREACHABLE();
+}
+
+/*static*/ std::shared_ptr<const ExtractionPathElement>
+ExtractionPathElement::simple(ExtractionStep step) {
+  return std::make_shared<SimpleExtractionPathElement>(step);
+}
+
+/*static*/ std::shared_ptr<const ExtractionPathElement>
+ExtractionPathElement::structField(const std::string& name) {
+  return std::make_shared<StructFieldExtractionPathElement>(name);
+}
+
+/*static*/ std::shared_ptr<const ExtractionPathElement>
+ExtractionPathElement::mapKeyFilter(std::vector<std::string> keys) {
+  return std::make_shared<StringMapKeyFilterExtractionPathElement>(
+      std::move(keys));
+}
+
+/*static*/ std::shared_ptr<const ExtractionPathElement>
+ExtractionPathElement::mapKeyFilter(std::vector<int64_t> keys) {
+  return std::make_shared<IntMapKeyFilterExtractionPathElement>(
+      std::move(keys));
+}
+
+bool NamedExtraction::operator==(const NamedExtraction& other) const {
+  if (outputName != other.outputName || chain.size() != other.chain.size() ||
+      !dataType->equivalent(*other.dataType)) {
+    return false;
+  }
+  for (size_t i = 0; i < chain.size(); ++i) {
+    if (!extractionPathElementEquals(*chain[i], *other.chain[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+std::string extractionStepName(ExtractionStep step) {
+  static const auto names = extractionStepNames();
+  return names.at(step);
+}
+
+ExtractionStep extractionStepFromName(const std::string& name) {
+  static const auto nameToStep = invertMap(extractionStepNames());
+  return nameToStep.at(name);
+}
+
+TypePtr deriveExtractionOutputType(
+    const TypePtr& inputType,
+    const std::vector<ExtractionPathElementPtr>& chain) {
+  validateExtractionChain(inputType, chain);
+  return deriveOutputTypeImpl(inputType, chain, 0);
+}
+
+std::string FileColumnHandle::columnTypeName(
+    FileColumnHandle::ColumnType columnType) {
+  const auto& names = columnTypeNames();
+  auto it = names.find(columnType);
+  VELOX_CHECK(it != names.end(), "Unknown column type");
+  return it->second;
+}
+
+FileColumnHandle::ColumnType FileColumnHandle::columnTypeFromName(
+    const std::string& name) {
+  const auto& names = columnTypeNames();
+  for (const auto& [type, typeName] : names) {
+    if (typeName == name) {
+      return type;
+    }
+  }
+  VELOX_FAIL("Unknown column type name: {}", name);
+}
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/FileColumnHandle.h b/velox/connectors/hive/FileColumnHandle.h
new file mode 100644
index 00000000000..4a6d564d35c
--- /dev/null
+++ b/velox/connectors/hive/FileColumnHandle.h
@@ -0,0 +1,244 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/connectors/Connector.h"
+#include "velox/type/Subfield.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox::connector::hive {
+
+/// Type of extraction to apply at one nesting level.
+enum class ExtractionStep : uint8_t {
+  /// Navigate into a struct field.  Input must be ROW.
+  kStructField,
+  /// Extract map keys as ARRAY.  Input must be MAP.
+  kMapKeys,
+  /// Extract map values as ARRAY.  Input must be MAP.
+  kMapValues,
+  /// Filter map to specific keys.  Input must be MAP.  Type-preserving.
+  kMapKeyFilter,
+  /// Navigate into array elements.  Input must be ARRAY.
+  kArrayElements,
+  /// Extract size as BIGINT.  Input must be MAP or ARRAY.  Terminal.
+  kSize,
+};
+
+/// Base class for one step in the extraction chain.
+class ExtractionPathElement {
+ public:
+  virtual ~ExtractionPathElement() = default;
+
+  /// Return the step type.
+  virtual ExtractionStep step() const = 0;
+
+  /// Create a simple step (MapKeys, MapValues, ArrayElements, Size).
+  static std::shared_ptr<const ExtractionPathElement> simple(
+      ExtractionStep step);
+
+  /// Create a StructField step.
+  static std::shared_ptr<const ExtractionPathElement> structField(
+      const std::string& name);
+
+  /// Create a MapKeyFilter step with string keys.
+  static std::shared_ptr<const ExtractionPathElement> mapKeyFilter(
+      std::vector<std::string> keys);
+
+  /// Create a MapKeyFilter step with integer keys.
+  static std::shared_ptr<const ExtractionPathElement> mapKeyFilter(
+      std::vector<int64_t> keys);
+};
+
+using ExtractionPathElementPtr = std::shared_ptr<const ExtractionPathElement>;
+
+/// Simple extraction step without extra data (MapKeys, MapValues,
+/// ArrayElements, Size).
+class SimpleExtractionPathElement : public ExtractionPathElement {
+ public:
+  explicit SimpleExtractionPathElement(ExtractionStep step) : step_(step) {}
+
+  ExtractionStep step() const override {
+    return step_;
+  }
+
+ private:
+  ExtractionStep step_;
+};
+
+/// Struct field extraction step.
+class StructFieldExtractionPathElement : public ExtractionPathElement {
+ public:
+  explicit StructFieldExtractionPathElement(std::string name)
+      : fieldName_(std::move(name)) {}
+
+  ExtractionStep step() const override {
+    return ExtractionStep::kStructField;
+  }
+
+  const std::string& fieldName() const {
+    return fieldName_;
+  }
+
+ private:
+  std::string fieldName_;
+};
+
+/// Map key filter extraction step with string keys.
+class StringMapKeyFilterExtractionPathElement : public ExtractionPathElement {
+ public:
+  explicit StringMapKeyFilterExtractionPathElement(
+      std::vector<std::string> keys)
+      : filterKeys_(std::move(keys)) {}
+
+  ExtractionStep step() const override {
+    return ExtractionStep::kMapKeyFilter;
+  }
+
+  const std::vector<std::string>& filterKeys() const {
+    return filterKeys_;
+  }
+
+ private:
+  std::vector<std::string> filterKeys_;
+};
+
+/// Map key filter extraction step with integer keys.
+class IntMapKeyFilterExtractionPathElement : public ExtractionPathElement {
+ public:
+  explicit IntMapKeyFilterExtractionPathElement(std::vector<int64_t> keys)
+      : filterKeys_(std::move(keys)) {}
+
+  ExtractionStep step() const override {
+    return ExtractionStep::kMapKeyFilter;
+  }
+
+  const std::vector<int64_t>& filterKeys() const {
+    return filterKeys_;
+  }
+
+ private:
+  std::vector<int64_t> filterKeys_;
+};
+
+/// Compare two ExtractionPathElements for equality.  Non-virtual to avoid
+/// slicing hazards with virtual operator==.
+bool extractionPathElementEquals(
+    const ExtractionPathElement& lhs,
+    const ExtractionPathElement& rhs);
+
+/// Named extraction chain producing one output column.
+struct NamedExtraction {
+  /// Output column name in the scan's outputType.
+  std::string outputName;
+
+  /// Extraction chain to apply.  Empty means pass-through (no extraction).
+  std::vector<ExtractionPathElementPtr> chain;
+
+  /// Output type after applying the chain.
+  TypePtr dataType;
+
+  bool operator==(const NamedExtraction& other) const;
+};
+
+/// Return the string name for an ExtractionStep enum value.
+std::string extractionStepName(ExtractionStep step);
+
+/// Parse an ExtractionStep from its string name.
+ExtractionStep extractionStepFromName(const std::string& name);
+
+/// Derive the output type by applying the extraction chain to the input type.
+/// Throws if the chain is invalid for the given input type.
+TypePtr deriveExtractionOutputType(
+    const TypePtr& inputType,
+    const std::vector<ExtractionPathElementPtr>& chain);
+
+/// Base class for column handles in file-based connectors.
+///
+/// Define the common interface for column metadata needed by
+/// FileDataSource and FileSplitReader. Connector-specific column handles
+/// (HiveColumnHandle, etc.) extend this class.
+class FileColumnHandle : public ColumnHandle {
+ public:
+  /// Classify columns by their role in the scan pipeline.
+  enum class ColumnType {
+    kPartitionKey,
+    kRegular,
+    kSynthesized,
+    /// A zero-based row number of type BIGINT auto-generated by the connector.
+    /// Row numbers are unique within a single file only.
+    kRowIndex,
+    kRowId,
+  };
+
+  virtual ColumnType columnType() const = 0;
+
+  /// The type of this column as defined in the table schema (metastore).
+  /// May differ from dataType() when extraction changes the output type.
+  /// Subclasses must provide this.
+  virtual const TypePtr& schemaType() const = 0;
+
+  /// The target data type for this column in the output.  Defaults to
+  /// schemaType() (no extraction or type coercion).  Override when the
+  /// output type differs from the table schema type.
+  virtual const TypePtr& dataType() const {
+    return schemaType();
+  }
+
+  /// Subfields required by the query for pruning complex types.
+  virtual const std::vector<common::Subfield>& requiredSubfields() const = 0;
+
+  virtual bool isPartitionKey() const {
+    return columnType() == ColumnType::kPartitionKey;
+  }
+
+  /// Return true if partition date values are encoded as days since epoch
+  /// (e.g., Iceberg) rather than ISO 8601 strings (e.g., Hive).
+  virtual bool isPartitionDateValueDaysSinceEpoch() const = 0;
+
+  /// Named extraction chains.  Empty means no extraction (default behavior).
+  virtual const std::vector<NamedExtraction>& extractions() const {
+    static const std::vector<NamedExtraction> kEmpty;
+    return kEmpty;
+  }
+
+  /// Optional row-wise post processor applied to this column after reading and
+  /// filtering. Must not change the vector size.
+  virtual const std::function<void(VectorPtr&)>& postProcessor() const = 0;
+
+  static std::string columnTypeName(ColumnType columnType);
+
+  static ColumnType columnTypeFromName(const std::string& name);
+};
+
+using FileColumnHandlePtr = std::shared_ptr<const FileColumnHandle>;
+using FileColumnHandleMap =
+    std::unordered_map<std::string, FileColumnHandlePtr>;
+
+} // namespace facebook::velox::connector::hive
+
+template <>
+struct fmt::formatter<
+    facebook::velox::connector::hive::FileColumnHandle::ColumnType>
+    : formatter<std::string> {
+  auto format(
+      facebook::velox::connector::hive::FileColumnHandle::ColumnType type,
+      format_context& ctx) const {
+    return formatter<std::string>::format(
+        facebook::velox::connector::hive::FileColumnHandle::columnTypeName(
+            type),
+        ctx);
+  }
+};
diff --git a/velox/connectors/hive/FileConfig.cpp b/velox/connectors/hive/FileConfig.cpp
new file mode 100644
index 00000000000..eec3b9cd724
--- /dev/null
+++ b/velox/connectors/hive/FileConfig.cpp
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/FileConfig.h"
+
+#include "velox/common/config/Config.h"
+
+namespace facebook::velox::connector::hive {
+
+const std::vector<config::ConfigProperty>& FileConfig::registeredProperties() {
+  static const std::vector<config::ConfigProperty> kProperties = [] {
+    std::vector<config::ConfigProperty> properties;
+#define VELOX_HIVE_CONFIG_REGISTER(constName) \
+  config::registerConfigProperty<FileConfig::constName##Property>(properties)
+
+    VELOX_HIVE_CONFIG_REGISTER(kOrcUseColumnNamesSession);
+    VELOX_HIVE_CONFIG_REGISTER(kParquetUseColumnNamesSession);
+    VELOX_HIVE_CONFIG_REGISTER(kAllowInt32NarrowingSession);
+    VELOX_HIVE_CONFIG_REGISTER(kReadTimestampPartitionValueAsLocalTimeSession);
+    VELOX_HIVE_CONFIG_REGISTER(kPreserveFlatMapsInMemorySession);
+    VELOX_HIVE_CONFIG_REGISTER(kReaderCollectColumnCpuMetricsSession);
+    VELOX_HIVE_CONFIG_REGISTER(kOrcFooterSpeculativeIoSizeSession);
+    VELOX_HIVE_CONFIG_REGISTER(kParquetFooterSpeculativeIoSizeSession);
+    VELOX_HIVE_CONFIG_REGISTER(kNimbleFooterSpeculativeIoSizeSession);
+    VELOX_HIVE_CONFIG_REGISTER(kNimbleStringDecoderZeroCopySession);
+    VELOX_HIVE_CONFIG_REGISTER(kNimblePreserveDictionaryEncodingSession);
+    VELOX_HIVE_CONFIG_REGISTER(kFileColumnNamesReadAsLowerCaseSession);
+    VELOX_HIVE_CONFIG_REGISTER(kIgnoreMissingFilesSession);
+    VELOX_HIVE_CONFIG_REGISTER(kMaxCoalescedBytesSession);
+    VELOX_HIVE_CONFIG_REGISTER(kLoadQuantumSession);
+    VELOX_HIVE_CONFIG_REGISTER(kReadStatsBasedFilterReorderDisabledSession);
+    VELOX_HIVE_CONFIG_REGISTER(kIndexEnabledSession);
+    VELOX_HIVE_CONFIG_REGISTER(kFileMetadataCacheEnabledSession);
+    VELOX_HIVE_CONFIG_REGISTER(kPinFileMetadataSession);
+    VELOX_HIVE_CONFIG_REGISTER(kSelectiveNimbleReaderEnabledSession);
+    VELOX_HIVE_CONFIG_REGISTER(kMaxCoalescedDistanceSession);
+    VELOX_HIVE_CONFIG_REGISTER(kParallelUnitLoadCountSession);
+    VELOX_HIVE_CONFIG_REGISTER(kReadTimestampUnitSession);
+
+#undef VELOX_HIVE_CONFIG_REGISTER
+
+    return properties;
+  }();
+  return kProperties;
+}
+
+int32_t FileConfig::maxCoalescedDistanceBytes(
+    const config::ConfigBase* session) const {
+  const auto distance = config::toCapacity(
+      session->get<std::string>(
+          kMaxCoalescedDistanceSession,
+          config_->get<std::string>(kMaxCoalescedDistance, "512kB")),
+      config::CapacityUnit::BYTE);
+  VELOX_USER_CHECK_LE(
+      distance,
+      std::numeric_limits<int32_t>::max(),
+      "The max merge distance to combine read requests must be less than 2GB."
+      " Got {} bytes.",
+      distance);
+  return int32_t(distance);
+}
+
+int32_t FileConfig::prefetchRowGroups() const {
+  return config_->get<int32_t>(kPrefetchRowGroups, 1);
+}
+
+size_t FileConfig::parallelUnitLoadCount(
+    const config::ConfigBase* session) const {
+  auto count = session->get<size_t>(
+      kParallelUnitLoadCountSession,
+      config_->get<size_t>(kParallelUnitLoadCount, 0));
+  VELOX_CHECK_LE(count, 100, "parallelUnitLoadCount too large: {}", count);
+  return count;
+}
+
+uint64_t FileConfig::filePreloadThreshold() const {
+  return config_->get<uint64_t>(kFilePreloadThreshold, 8UL << 20);
+}
+
+uint8_t FileConfig::readTimestampUnit(const config::ConfigBase* session) const {
+  const auto unit = sessionValue<uint8_t>(
+      session, kReadTimestampUnitSession, kReadTimestampUnit, 3 /*milli*/);
+  VELOX_CHECK(
+      unit == 3 || unit == 6 /*micro*/ || unit == 9 /*nano*/,
+      "Invalid timestamp unit.");
+  return unit;
+}
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/FileConfig.h b/velox/connectors/hive/FileConfig.h
new file mode 100644
index 00000000000..d932a2a066b
--- /dev/null
+++ b/velox/connectors/hive/FileConfig.h
@@ -0,0 +1,331 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <string>
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/config/Config.h"
+#include "velox/common/config/ConfigProperty.h"
+#include "velox/connectors/hive/HiveConfigMacrosDefine.h"
+
+namespace facebook::velox::connector::hive {
+
+/// Configuration for file-based data sources. Contains settings for file
+/// reading, I/O coalescing, format-specific options, and metadata caching.
+/// HiveConfig extends this with Hive-specific settings like partitioning,
+/// bucketing, and write-path options.
+class FileConfig {
+ public:
+  static const std::vector<config::ConfigProperty>& registeredProperties();
+
+  // --- VELOX_HIVE_CONFIG_LEGACY properties ---
+
+  VELOX_HIVE_CONFIG_LEGACY(
+      kOrcUseColumnNamesSession,
+      kOrcUseColumnNames,
+      isOrcUseColumnNames,
+      "orc_use_column_names",
+      "orc.use-column-names",
+      bool,
+      false,
+      "Map ORC table field names to file field names using names, not indices.")
+
+  VELOX_HIVE_CONFIG_LEGACY(
+      kParquetUseColumnNamesSession,
+      kParquetUseColumnNames,
+      isParquetUseColumnNames,
+      "parquet_use_column_names",
+      "parquet.use-column-names",
+      bool,
+      false,
+      "Map Parquet table field names to file field names using names, not indices.")
+
+  VELOX_HIVE_CONFIG_LEGACY(
+      kAllowInt32NarrowingSession,
+      kAllowInt32Narrowing,
+      allowInt32Narrowing,
+      "allow_int32_narrowing",
+      "parquet.allow-int32-narrowing",
+      bool,
+      false,
+      "Allow reading INT32 Parquet columns as a narrower integer type.")
+
+  VELOX_HIVE_CONFIG_LEGACY(
+      kReadTimestampPartitionValueAsLocalTimeSession,
+      kReadTimestampPartitionValueAsLocalTime,
+      readTimestampPartitionValueAsLocalTime,
+      "reader.timestamp_partition_value_as_local_time",
+      "reader.timestamp-partition-value-as-local-time",
+      bool,
+      true,
+      "Read timestamp partition values as local time.")
+
+  VELOX_HIVE_CONFIG_LEGACY(
+      kPreserveFlatMapsInMemorySession,
+      kPreserveFlatMapsInMemory,
+      preserveFlatMapsInMemory,
+      "preserve_flat_maps_in_memory",
+      "preserve-flat-maps-in-memory",
+      bool,
+      false,
+      "Preserve flat maps in memory as FlatMapVectors.")
+
+  VELOX_HIVE_CONFIG_LEGACY(
+      kReaderCollectColumnCpuMetricsSession,
+      kReaderCollectColumnCpuMetrics,
+      readerCollectColumnCpuMetrics,
+      "reader.collect_column_cpu_metrics",
+      "reader.collect-column-cpu-metrics",
+      bool,
+      false,
+      "Collect per-column CPU timing stats.")
+
+  VELOX_HIVE_CONFIG_LEGACY(
+      kOrcFooterSpeculativeIoSizeSession,
+      kOrcFooterSpeculativeIoSize,
+      orcFooterSpeculativeIoSize,
+      "orc_footer_speculative_io_size",
+      "orc.footer-speculative-io-size",
+      uint64_t,
+      256UL << 10,
+      "Speculative tail-read size in bytes for ORC files.")
+
+  VELOX_HIVE_CONFIG_LEGACY(
+      kParquetFooterSpeculativeIoSizeSession,
+      kParquetFooterSpeculativeIoSize,
+      parquetFooterSpeculativeIoSize,
+      "parquet_footer_speculative_io_size",
+      "parquet.footer-speculative-io-size",
+      uint64_t,
+      256UL << 10,
+      "Speculative tail-read size in bytes for Parquet files.")
+
+  VELOX_HIVE_CONFIG_LEGACY(
+      kNimbleFooterSpeculativeIoSizeSession,
+      kNimbleFooterSpeculativeIoSize,
+      nimbleFooterSpeculativeIoSize,
+      "nimble_footer_speculative_io_size",
+      "nimble.footer-speculative-io-size",
+      uint64_t,
+      8UL << 20,
+      "Speculative tail-read size in bytes for Nimble files.")
+
+  VELOX_HIVE_CONFIG_LEGACY(
+      kNimbleStringDecoderZeroCopySession,
+      kNimbleStringDecoderZeroCopy,
+      nimbleStringDecoderZeroCopy,
+      "nimble_string_decoder_zero_copy",
+      "nimble.string-decoder-zero-copy",
+      bool,
+      false,
+      "Enable zero-copy string decoding in Nimble selective reader.")
+
+  VELOX_HIVE_CONFIG_LEGACY(
+      kNimblePreserveDictionaryEncodingSession,
+      kNimblePreserveDictionaryEncoding,
+      nimblePreserveDictionaryEncoding,
+      "nimble_preserve_dictionary_encoding",
+      "nimble.preserve-dictionary-encoding",
+      bool,
+      false,
+      "Preserve dictionary encoding for Nimble string column reads.")
+
+  // --- VELOX_HIVE_CONFIG properties ---
+
+  VELOX_HIVE_CONFIG(
+      kFileColumnNamesReadAsLowerCaseSession,
+      isFileColumnNamesReadAsLowerCase,
+      "file_column_names_read_as_lower_case",
+      bool,
+      false,
+      "Read source file column names as lower case.")
+  static constexpr const char* kFileColumnNamesReadAsLowerCase =
+      "file-column-names-read-as-lower-case";
+
+  VELOX_HIVE_CONFIG_PROPERTY(
+      kIgnoreMissingFilesSession,
+      "ignore_missing_files",
+      bool,
+      false,
+      "Ignore missing files during table scan.")
+  bool ignoreMissingFiles(const config::ConfigBase* session) const {
+    return session->get<bool>(
+        kIgnoreMissingFilesSession,
+        kIgnoreMissingFilesSessionProperty::defaultValue);
+  }
+
+  VELOX_HIVE_CONFIG(
+      kMaxCoalescedBytesSession,
+      maxCoalescedBytes,
+      "max-coalesced-bytes",
+      int64_t,
+      128 << 20,
+      "Maximum coalesced bytes for a read request.")
+  static constexpr const char* kMaxCoalescedBytes = "max-coalesced-bytes";
+
+  VELOX_HIVE_CONFIG(
+      kLoadQuantumSession,
+      loadQuantum,
+      "load-quantum",
+      int32_t,
+      8 << 20,
+      "Total size in bytes for a direct coalesce request.")
+  static constexpr const char* kLoadQuantum = "load-quantum";
+
+  VELOX_HIVE_CONFIG(
+      kReadStatsBasedFilterReorderDisabledSession,
+      readStatsBasedFilterReorderDisabled,
+      "stats_based_filter_reorder_disabled",
+      bool,
+      false,
+      "Disable stats-based filter reordering.")
+  static constexpr const char* kReadStatsBasedFilterReorderDisabled =
+      "stats-based-filter-reorder-disabled";
+
+  VELOX_HIVE_CONFIG(
+      kIndexEnabledSession,
+      indexEnabled,
+      "index_enabled",
+      bool,
+      false,
+      "Use cluster index for filter-based row pruning.")
+  static constexpr const char* kIndexEnabled = "index-enabled";
+
+  VELOX_HIVE_CONFIG(
+      kFileMetadataCacheEnabledSession,
+      fileMetadataCacheEnabled,
+      "file_metadata_cache_enabled",
+      bool,
+      false,
+      "Cache file metadata in AsyncDataCache.")
+  static constexpr const char* kFileMetadataCacheEnabled =
+      "file-metadata-cache-enabled";
+
+  VELOX_HIVE_CONFIG(
+      kPinFileMetadataSession,
+      pinFileMetadata,
+      "pin_file_metadata",
+      bool,
+      false,
+      "Pin parsed metadata objects in reader cache.")
+  static constexpr const char* kPinFileMetadata = "pin-file-metadata";
+
+  VELOX_HIVE_CONFIG(
+      kSelectiveNimbleReaderEnabledSession,
+      selectiveNimbleReaderEnabled,
+      "selective_nimble_reader_enabled",
+      bool,
+      true,
+      "Enable selective Nimble reader.")
+
+  // --- VELOX_HIVE_CONFIG_PROPERTY properties ---
+
+  VELOX_HIVE_CONFIG_PROPERTY(
+      kMaxCoalescedDistanceSession,
+      "orc_max_merge_distance",
+      std::string,
+      "512kB",
+      "Maximum merge distance to combine read requests.")
+  static constexpr const char* kMaxCoalescedDistance = "max-coalesced-distance";
+
+  VELOX_HIVE_CONFIG_PROPERTY(
+      kParallelUnitLoadCountSession,
+      "parallel_unit_load_count",
+      size_t,
+      0,
+      "Number of units to load in parallel. 0 disables.")
+  static constexpr const char* kParallelUnitLoadCount =
+      "parallel-unit-load-count";
+
+  VELOX_HIVE_CONFIG_PROPERTY(
+      kReadTimestampUnitSession,
+      "reader.timestamp_unit",
+      uint8_t,
+      3,
+      "Unit for reading timestamps (0=second, 3=millisecond, 6=microsecond, 9=nanosecond).")
+  static constexpr const char* kReadTimestampUnit = "reader.timestamp-unit";
+
+  // --- Server-only properties (no macro) ---
+
+  /// The number of prefetch rowgroups.
+  static constexpr const char* kPrefetchRowGroups = "prefetch-rowgroups";
+
+  /// The threshold of file size in bytes when the whole file is fetched with
+  /// meta data together. Optimization to decrease the small IO requests.
+  static constexpr const char* kFilePreloadThreshold = "file-preload-threshold";
+
+  explicit FileConfig(std::shared_ptr<const config::ConfigBase> config) {
+    VELOX_CHECK_NOT_NULL(
+        config, "Config is null for FileConfig initialization");
+    config_ = std::move(config);
+  }
+
+  virtual ~FileConfig() = default;
+
+  int32_t maxCoalescedDistanceBytes(const config::ConfigBase* session) const;
+
+  int32_t prefetchRowGroups() const;
+
+  size_t parallelUnitLoadCount(const config::ConfigBase* session) const;
+
+  uint64_t filePreloadThreshold() const;
+
+  // Returns the timestamp unit used when reading timestamps from files.
+  uint8_t readTimestampUnit(const config::ConfigBase* session) const;
+
+  const std::shared_ptr<const config::ConfigBase>& config() const {
+    return config_;
+  }
+
+ protected:
+  static constexpr const char* kLegacyPrefix = "hive.";
+
+  // Looks up a config value by 'key', falling back to 'hive.' + key if not
+  // found. Used during migration away from redundant 'hive.' prefix in
+  // config keys.
+  template <typename T>
+  T configValue(const std::string& key, const T& defaultValue) const {
+    if (auto val = config_->get<T>(key)) {
+      return val.value();
+    }
+    return config_->get<T>(std::string(kLegacyPrefix) + key, defaultValue);
+  }
+
+  // Looks up a session property by 'sessionKey' (then 'hive.' + sessionKey),
+  // falling back to connector config by 'configKey' (then 'hive.' + configKey).
+  // Used during migration away from redundant 'hive.' prefix in property
+  // names.
+  template <typename T>
+  T sessionValue(
+      const config::ConfigBase* session,
+      const std::string& sessionKey,
+      const std::string& configKey,
+      const T& defaultValue) const {
+    if (auto val = session->get<T>(sessionKey)) {
+      return val.value();
+    }
+    if (auto val = session->get<T>(std::string(kLegacyPrefix) + sessionKey)) {
+      return val.value();
+    }
+    return configValue<T>(configKey, defaultValue);
+  }
+
+  std::shared_ptr<const config::ConfigBase> config_;
+};
+
+} // namespace facebook::velox::connector::hive
+
+#include "velox/connectors/hive/HiveConfigMacrosUndef.h"
diff --git a/velox/connectors/hive/FileConnectorSplit.h b/velox/connectors/hive/FileConnectorSplit.h
new file mode 100644
index 00000000000..efba64c5b8b
--- /dev/null
+++ b/velox/connectors/hive/FileConnectorSplit.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <optional>
+#include <unordered_map>
+
+#include "velox/connectors/Connector.h"
+#include "velox/connectors/hive/FileProperties.h"
+#include "velox/dwio/common/Options.h"
+
+namespace facebook::velox::connector::hive {
+
+/// Base split for file-based connectors. Represents a byte range within a
+/// single data file. Connector-specific splits (HiveConnectorSplit,
+/// HiveIcebergSplit) extend this to add synthesized columns, serde parameters,
+/// and other format-specific fields.
+struct FileConnectorSplit : public ConnectorSplit {
+  const std::string filePath;
+  dwio::common::FileFormat fileFormat;
+  const uint64_t start;
+  const uint64_t length;
+
+  /// File properties like file size used while opening the file handle.
+  std::optional<FileProperties> properties;
+
+  /// Mapping from partition keys to values. Values are specified as strings
+  /// formatted the same way as CAST(x as VARCHAR). Null values are specified as
+  /// std::nullopt. Date values must be formatted using ISO 8601 as YYYY-MM-DD.
+  const std::unordered_map<std::string, std::optional<std::string>>
+      partitionKeys;
+
+  FileConnectorSplit(
+      const std::string& connectorId,
+      const std::string& _filePath,
+      dwio::common::FileFormat _fileFormat,
+      uint64_t _start = 0,
+      uint64_t _length = std::numeric_limits<uint64_t>::max(),
+      int64_t splitWeight = 0,
+      bool cacheable = true,
+      std::optional<FileProperties> _properties = std::nullopt,
+      const std::unordered_map<std::string, std::optional<std::string>>&
+          _partitionKeys = {})
+      : ConnectorSplit(connectorId, splitWeight, cacheable),
+        filePath(_filePath),
+        fileFormat(_fileFormat),
+        start(_start),
+        length(_length),
+        properties(std::move(_properties)),
+        partitionKeys(_partitionKeys) {}
+
+  ~FileConnectorSplit() override = default;
+
+  uint64_t size() const override {
+    return length;
+  }
+
+  std::string getFileName() const {
+    const auto i = filePath.rfind('/');
+    return i == std::string::npos ? filePath : filePath.substr(i + 1);
+  }
+};
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/FileConnectorUtil.cpp b/velox/connectors/hive/FileConnectorUtil.cpp
new file mode 100644
index 00000000000..fbc314fa494
--- /dev/null
+++ b/velox/connectors/hive/FileConnectorUtil.cpp
@@ -0,0 +1,289 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/FileConnectorUtil.h"
+
+#include "velox/connectors/hive/FileColumnHandle.h"
+#include "velox/connectors/hive/FileConfig.h"
+#include "velox/connectors/hive/FileConnectorSplit.h"
+#include "velox/connectors/hive/FileTableHandle.h"
+
+namespace facebook::velox::connector::hive {
+
+void configureReaderOptions(
+    const std::shared_ptr<const FileConfig>& fileConfig,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    const FileTableHandlePtr& tableHandle,
+    const std::shared_ptr<const FileConnectorSplit>& fileSplit,
+    dwio::common::ReaderOptions& readerOptions) {
+  configureReaderOptions(
+      fileConfig,
+      connectorQueryCtx,
+      tableHandle->dataColumns(),
+      fileSplit,
+      tableHandle->tableParameters(),
+      readerOptions);
+}
+
+void configureReaderOptions(
+    const std::shared_ptr<const FileConfig>& fileConfig,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    const RowTypePtr& fileSchema,
+    const std::shared_ptr<const FileConnectorSplit>& fileSplit,
+    const std::unordered_map<std::string, std::string>& /*tableParameters*/,
+    dwio::common::ReaderOptions& readerOptions) {
+  auto sessionProperties = connectorQueryCtx->sessionProperties();
+  readerOptions.setLoadQuantum(fileConfig->loadQuantum(sessionProperties));
+  readerOptions.setMaxCoalesceBytes(
+      fileConfig->maxCoalescedBytes(sessionProperties));
+  readerOptions.setMaxCoalesceDistance(
+      fileConfig->maxCoalescedDistanceBytes(sessionProperties));
+  readerOptions.setFileColumnNamesReadAsLowerCase(
+      fileConfig->isFileColumnNamesReadAsLowerCase(sessionProperties));
+  readerOptions.setAllowEmptyFile(true);
+  bool useColumnNamesForColumnMapping = false;
+  switch (fileSplit->fileFormat) {
+    case dwio::common::FileFormat::DWRF:
+    case dwio::common::FileFormat::ORC: {
+      useColumnNamesForColumnMapping =
+          fileConfig->isOrcUseColumnNames(sessionProperties);
+      break;
+    }
+    case dwio::common::FileFormat::PARQUET: {
+      useColumnNamesForColumnMapping =
+          fileConfig->isParquetUseColumnNames(sessionProperties);
+      readerOptions.setAllowInt32Narrowing(
+          fileConfig->allowInt32Narrowing(sessionProperties));
+      break;
+    }
+    default:
+      useColumnNamesForColumnMapping = false;
+  }
+
+  readerOptions.setUseColumnNamesForColumnMapping(
+      useColumnNamesForColumnMapping);
+  readerOptions.setFileSchema(fileSchema);
+  readerOptions.setFilePreloadThreshold(fileConfig->filePreloadThreshold());
+  readerOptions.setPrefetchRowGroups(fileConfig->prefetchRowGroups());
+  readerOptions.setCacheable(fileSplit->cacheable);
+  const auto& sessionTzName = connectorQueryCtx->sessionTimezone();
+  if (!sessionTzName.empty()) {
+    const auto timezone = tz::locateZone(sessionTzName);
+    readerOptions.setSessionTimezone(timezone);
+  }
+  readerOptions.setAdjustTimestampToTimezone(
+      connectorQueryCtx->adjustTimestampToTimezone());
+  // Prefer connector session property (FileConfig). Fall back to
+  // ConnectorQueryCtx (threaded from QueryConfig) for backward compatibility
+  // with callers that set it as a query config.
+  if (sessionProperties->valueExists(
+          FileConfig::kSelectiveNimbleReaderEnabledSession)) {
+    readerOptions.setSelectiveNimbleReaderEnabled(
+        fileConfig->selectiveNimbleReaderEnabled(sessionProperties));
+  } else {
+    readerOptions.setSelectiveNimbleReaderEnabled(
+        connectorQueryCtx->selectiveNimbleReaderEnabled());
+  }
+  readerOptions.setFileMetadataCacheEnabled(
+      fileConfig->fileMetadataCacheEnabled(sessionProperties));
+  readerOptions.setPinFileMetadata(
+      fileConfig->pinFileMetadata(sessionProperties));
+
+  // Set footer speculative IO size based on file format.
+  switch (fileSplit->fileFormat) {
+    case dwio::common::FileFormat::DWRF:
+    case dwio::common::FileFormat::ORC:
+      readerOptions.setFooterSpeculativeIoSize(
+          fileConfig->orcFooterSpeculativeIoSize(sessionProperties));
+      break;
+    case dwio::common::FileFormat::PARQUET:
+      readerOptions.setFooterSpeculativeIoSize(
+          fileConfig->parquetFooterSpeculativeIoSize(sessionProperties));
+      break;
+    case dwio::common::FileFormat::NIMBLE:
+      readerOptions.setFooterSpeculativeIoSize(
+          fileConfig->nimbleFooterSpeculativeIoSize(sessionProperties));
+      break;
+    default:
+      // Use ORC default for unknown formats.
+      readerOptions.setFooterSpeculativeIoSize(
+          fileConfig->orcFooterSpeculativeIoSize(sessionProperties));
+      break;
+  }
+
+  if (readerOptions.fileFormat() != dwio::common::FileFormat::UNKNOWN) {
+    VELOX_CHECK(
+        readerOptions.fileFormat() == fileSplit->fileFormat,
+        "HiveDataSource received splits of different formats: {} and {}",
+        dwio::common::toString(readerOptions.fileFormat()),
+        dwio::common::toString(fileSplit->fileFormat));
+  } else {
+    readerOptions.setFileFormat(fileSplit->fileFormat);
+  }
+}
+
+void configureRowReaderOptions(
+    const std::unordered_map<std::string, std::string>& tableParameters,
+    const std::shared_ptr<common::ScanSpec>& scanSpec,
+    std::shared_ptr<common::MetadataFilter> metadataFilter,
+    const RowTypePtr& rowType,
+    const std::shared_ptr<const FileConnectorSplit>& fileSplit,
+    const std::shared_ptr<const FileConfig>& fileConfig,
+    const config::ConfigBase* sessionProperties,
+    folly::Executor* const ioExecutor,
+    dwio::common::RowReaderOptions& rowReaderOptions) {
+  auto skipRowsIt =
+      tableParameters.find(dwio::common::TableParameter::kSkipHeaderLineCount);
+  if (skipRowsIt != tableParameters.end()) {
+    rowReaderOptions.setSkipRows(folly::to<uint64_t>(skipRowsIt->second));
+  }
+  rowReaderOptions.setScanSpec(scanSpec);
+  rowReaderOptions.setIOExecutor(ioExecutor);
+  rowReaderOptions.setMetadataFilter(std::move(metadataFilter));
+  rowReaderOptions.setRequestedType(rowType);
+  rowReaderOptions.range(fileSplit->start, fileSplit->length);
+  if (fileConfig && sessionProperties) {
+    rowReaderOptions.setTimestampPrecision(
+        static_cast<TimestampPrecision>(
+            fileConfig->readTimestampUnit(sessionProperties)));
+    rowReaderOptions.setPreserveFlatMapsInMemory(
+        fileConfig->preserveFlatMapsInMemory(sessionProperties));
+    rowReaderOptions.setParallelUnitLoadCount(
+        fileConfig->parallelUnitLoadCount(sessionProperties));
+    rowReaderOptions.setIndexEnabled(
+        fileConfig->indexEnabled(sessionProperties));
+    rowReaderOptions.setCollectColumnCpuMetrics(
+        fileConfig->readerCollectColumnCpuMetrics(sessionProperties));
+  }
+}
+
+namespace {
+
+bool applyPartitionFilter(
+    const TypePtr& type,
+    const std::string& partitionValue,
+    bool isPartitionDateDaysSinceEpoch,
+    const common::Filter* filter,
+    bool asLocalTime) {
+  if (type->isDate()) {
+    int32_t result = 0;
+    // days_since_epoch partition values are integers in string format. Eg.
+    // Iceberg partition values.
+    if (isPartitionDateDaysSinceEpoch) {
+      result = folly::to<int32_t>(partitionValue);
+    } else {
+      result = DATE()->toDays(partitionValue);
+    }
+    return applyFilter(*filter, result);
+  }
+
+  switch (type->kind()) {
+    case TypeKind::BIGINT:
+    case TypeKind::INTEGER:
+    case TypeKind::SMALLINT:
+    case TypeKind::TINYINT: {
+      return applyFilter(*filter, folly::to<int64_t>(partitionValue));
+    }
+    case TypeKind::REAL:
+    case TypeKind::DOUBLE: {
+      return applyFilter(*filter, folly::to<double>(partitionValue));
+    }
+    case TypeKind::BOOLEAN: {
+      return applyFilter(*filter, folly::to<bool>(partitionValue));
+    }
+    case TypeKind::TIMESTAMP: {
+      auto result = util::fromTimestampString(
+          StringView(partitionValue), util::TimestampParseMode::kPrestoCast);
+      VELOX_CHECK(!result.hasError());
+      if (asLocalTime) {
+        result.value().toGMT(Timestamp::defaultTimezone());
+      }
+      return applyFilter(*filter, result.value());
+    }
+    case TypeKind::VARCHAR: {
+      return applyFilter(*filter, partitionValue);
+    }
+    default:
+      VELOX_FAIL(
+          "Bad type {} for partition value: {}", type->kind(), partitionValue);
+  }
+}
+
+} // namespace
+
+bool testFilters(
+    const common::ScanSpec* scanSpec,
+    const dwio::common::Reader* reader,
+    const std::string& filePath,
+    const std::unordered_map<std::string, std::optional<std::string>>&
+        partitionKeys,
+    const std::unordered_map<std::string, FileColumnHandlePtr>&
+        partitionKeysHandle,
+    bool asLocalTime) {
+  const auto totalRows = reader->numberOfRows();
+  const auto& fileTypeWithId = reader->typeWithId();
+  const auto& rowType = reader->rowType();
+  for (const auto& child : scanSpec->children()) {
+    if (child->filter()) {
+      const auto& name = child->fieldName();
+      auto iter = partitionKeys.find(name);
+      // By design, the partition key columns for Iceberg tables are included in
+      // the data files to facilitate partition transform and partition
+      // evolution, so we need to test both cases.
+      if (!rowType->containsChild(name) || iter != partitionKeys.end()) {
+        if (iter != partitionKeys.end() && iter->second.has_value()) {
+          const auto handlesIter = partitionKeysHandle.find(name);
+          VELOX_CHECK(handlesIter != partitionKeysHandle.end());
+
+          // This is a non-null partition key
+          return applyPartitionFilter(
+              handlesIter->second->dataType(),
+              iter->second.value(),
+              handlesIter->second->isPartitionDateValueDaysSinceEpoch(),
+              child->filter(),
+              asLocalTime);
+        }
+        // Column is missing, most likely due to schema evolution. Or it's a
+        // partition key but the partition value is NULL.
+        if (child->filter()->isDeterministic() &&
+            !child->filter()->testNull()) {
+          VLOG(1) << "Skipping " << filePath
+                  << " because the filter testNull() failed for column "
+                  << child->fieldName();
+          return false;
+        }
+      } else {
+        const auto& typeWithId = fileTypeWithId->childByName(name);
+        const auto columnStats = reader->columnStatistics(typeWithId->id());
+        if (columnStats != nullptr &&
+            !testFilter(
+                child->filter(),
+                columnStats.get(),
+                totalRows.value(),
+                typeWithId->type())) {
+          VLOG(1) << "Skipping " << filePath
+                  << " based on stats and filter for column "
+                  << child->fieldName();
+          return false;
+        }
+      }
+    }
+  }
+
+  return true;
+}
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/FileConnectorUtil.h b/velox/connectors/hive/FileConnectorUtil.h
new file mode 100644
index 00000000000..1312593976f
--- /dev/null
+++ b/velox/connectors/hive/FileConnectorUtil.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <folly/Executor.h>
+
+#include "velox/connectors/Connector.h"
+#include "velox/connectors/hive/FileHandle.h"
+#include "velox/dwio/common/Reader.h"
+
+namespace facebook::velox::connector::hive {
+
+class FileColumnHandle;
+using FileColumnHandlePtr = std::shared_ptr<const FileColumnHandle>;
+class FileTableHandle;
+using FileTableHandlePtr = std::shared_ptr<const FileTableHandle>;
+class FileConfig;
+struct FileConnectorSplit;
+
+/// Configures reader options for reading a data file. This is the generic
+/// version that does not apply serde (serialization/deserialization) options.
+/// For Hive tables that need serde options, use the overload in
+/// HiveConnectorUtil.h that accepts serdeParameters.
+void configureReaderOptions(
+    const std::shared_ptr<const FileConfig>& config,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    const FileTableHandlePtr& tableHandle,
+    const std::shared_ptr<const FileConnectorSplit>& fileSplit,
+    dwio::common::ReaderOptions& readerOptions);
+
+void configureReaderOptions(
+    const std::shared_ptr<const FileConfig>& fileConfig,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    const RowTypePtr& fileSchema,
+    const std::shared_ptr<const FileConnectorSplit>& fileSplit,
+    const std::unordered_map<std::string, std::string>& tableParameters,
+    dwio::common::ReaderOptions& readerOptions);
+
+/// Configures row reader options for reading rows from a data file. This is the
+/// generic version that does not set serde parameters. For Hive tables that
+/// need serde parameters, use the overload in HiveConnectorUtil.h.
+void configureRowReaderOptions(
+    const std::unordered_map<std::string, std::string>& tableParameters,
+    const std::shared_ptr<common::ScanSpec>& scanSpec,
+    std::shared_ptr<common::MetadataFilter> metadataFilter,
+    const RowTypePtr& rowType,
+    const std::shared_ptr<const FileConnectorSplit>& fileSplit,
+    const std::shared_ptr<const FileConfig>& fileConfig,
+    const config::ConfigBase* sessionProperties,
+    folly::Executor* ioExecutor,
+    dwio::common::RowReaderOptions& rowReaderOptions);
+
+/// Tests whether a file should be read based on partition key values and
+/// column statistics. Returns true if the file passes all filters, false
+/// if it can be skipped.
+bool testFilters(
+    const common::ScanSpec* scanSpec,
+    const dwio::common::Reader* reader,
+    const std::string& filePath,
+    const std::unordered_map<std::string, std::optional<std::string>>&
+        partitionKey,
+    const std::unordered_map<std::string, FileColumnHandlePtr>&
+        partitionKeysHandle,
+    bool asLocalTime);
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/FileDataSink.cpp b/velox/connectors/hive/FileDataSink.cpp
new file mode 100644
index 00000000000..1999e549daf
--- /dev/null
+++ b/velox/connectors/hive/FileDataSink.cpp
@@ -0,0 +1,523 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/FileDataSink.h"
+
+#include "velox/common/testutil/TestValue.h"
+#include "velox/exec/OperatorUtils.h"
+
+using facebook::velox::common::testutil::TestValue;
+
+namespace facebook::velox::connector::hive {
+namespace {
+#define WRITER_NON_RECLAIMABLE_SECTION_GUARD(index)       \
+  memory::NonReclaimableSectionGuard nonReclaimableGuard( \
+      writerInfo_[(index)]->nonReclaimableSectionHolder.get())
+
+std::shared_ptr<memory::MemoryPool> createSinkPool(
+    const std::shared_ptr<memory::MemoryPool>& writerPool) {
+  return writerPool->addLeafChild(fmt::format("{}.sink", writerPool->name()));
+}
+
+std::shared_ptr<memory::MemoryPool> createSortPool(
+    const std::shared_ptr<memory::MemoryPool>& writerPool) {
+  return writerPool->addLeafChild(fmt::format("{}.sort", writerPool->name()));
+}
+} // namespace
+
+const WriterId& WriterId::unpartitionedId() {
+  static const WriterId writerId{0};
+  return writerId;
+}
+
+std::string WriterId::toString() const {
+  if (partitionId.has_value() && bucketId.has_value()) {
+    return fmt::format("part[{}.{}]", partitionId.value(), bucketId.value());
+  }
+
+  if (partitionId.has_value() && !bucketId.has_value()) {
+    return fmt::format("part[{}]", partitionId.value());
+  }
+
+  // This WriterId is used to add an identifier in the MemoryPools. This could
+  // indicate unpart, but the bucket number needs to be disambiguated. So
+  // creating a new label using bucket.
+  if (!partitionId.has_value() && bucketId.has_value()) {
+    return fmt::format("bucket[{}]", bucketId.value());
+  }
+
+  return "unpart";
+}
+
+RowTypePtr FileDataSink::getNonPartitionTypes(
+    const std::vector<column_index_t>& dataCols,
+    const RowTypePtr& inputType) {
+  std::vector<std::string> childNames;
+  std::vector<TypePtr> childTypes;
+  const auto& dataSize = dataCols.size();
+  childNames.reserve(dataSize);
+  childTypes.reserve(dataSize);
+  for (auto dataCol : dataCols) {
+    childNames.push_back(inputType->nameOf(dataCol));
+    childTypes.push_back(inputType->childAt(dataCol));
+  }
+
+  return ROW(std::move(childNames), std::move(childTypes));
+}
+
+RowVectorPtr FileDataSink::makeDataInput(
+    const std::vector<column_index_t>& dataCols,
+    const RowVectorPtr& input) {
+  std::vector<VectorPtr> childVectors;
+  childVectors.reserve(dataCols.size());
+  for (auto dataCol : dataCols) {
+    childVectors.push_back(input->childAt(dataCol));
+  }
+
+  return std::make_shared<RowVector>(
+      input->pool(),
+      getNonPartitionTypes(dataCols, asRowType(input->type())),
+      input->nulls(),
+      input->size(),
+      std::move(childVectors),
+      input->getNullCount());
+}
+
+FileDataSink::FileDataSink(
+    RowTypePtr inputType,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    CommitStrategy commitStrategy,
+    dwio::common::FileFormat storageFormat,
+    uint32_t maxOpenWriters,
+    std::vector<column_index_t> partitionChannels,
+    std::vector<column_index_t> dataChannels,
+    int32_t bucketCount,
+    std::unique_ptr<core::PartitionFunction> bucketFunction,
+    std::unique_ptr<PartitionIdGenerator> partitionIdGenerator,
+    std::shared_ptr<dwio::common::WriterFactory> writerFactory,
+    uint64_t maxTargetFileBytes,
+    bool partitionKeyAsLowerCase,
+    const common::SpillConfig* spillConfig,
+    uint64_t sortWriterFinishTimeSliceLimitMs)
+    : inputType_(std::move(inputType)),
+      connectorQueryCtx_(connectorQueryCtx),
+      commitStrategy_(commitStrategy),
+      storageFormat_(storageFormat),
+      maxOpenWriters_(maxOpenWriters),
+      partitionChannels_(std::move(partitionChannels)),
+      partitionIdGenerator_(std::move(partitionIdGenerator)),
+      dataChannels_(std::move(dataChannels)),
+      bucketCount_(bucketCount),
+      bucketFunction_(std::move(bucketFunction)),
+      writerFactory_(std::move(writerFactory)),
+      spillConfig_(spillConfig),
+      sortWriterFinishTimeSliceLimitMs_(sortWriterFinishTimeSliceLimitMs),
+      maxTargetFileBytes_(maxTargetFileBytes),
+      partitionKeyAsLowerCase_(partitionKeyAsLowerCase) {
+  fileSystemStats_ = std::make_unique<IoStats>();
+}
+
+void FileDataSink::appendData(RowVectorPtr input) {
+  checkRunning();
+
+  // Lazy load all the input columns.
+  input->loadedVector();
+
+  // Write to unpartitioned (and unbucketed) table.
+  if (!isPartitioned() && !isBucketed()) {
+    const auto index = ensureWriter(WriterId::unpartitionedId());
+    write(index, input);
+    return;
+  }
+
+  // Compute partition and bucket numbers.
+  computePartitionAndBucketIds(input);
+
+  // All inputs belong to a single non-bucketed partition. The partition id
+  // must be zero.
+  if (!isBucketed() && partitionIdGenerator_->numPartitions() == 1) {
+    const auto index = ensureWriter(WriterId{0});
+    write(index, input);
+    return;
+  }
+
+  splitInputRowsAndEnsureWriters();
+
+  for (auto index = 0; index < writers_.size(); ++index) {
+    const vector_size_t partitionSize = partitionSizes_[index];
+    if (partitionSize == 0) {
+      continue;
+    }
+
+    RowVectorPtr writerInput = partitionSize == input->size()
+        ? input
+        : exec::wrap(partitionSize, partitionRows_[index], input);
+    write(index, writerInput);
+  }
+}
+
+void FileDataSink::write(size_t index, RowVectorPtr input) {
+  WRITER_NON_RECLAIMABLE_SECTION_GUARD(index);
+  auto dataInput = makeDataInput(dataChannels_, input);
+
+  if (writers_[index] == nullptr) {
+    writers_[index] = createWriterForIndex(index);
+  }
+
+  writers_[index]->write(dataInput);
+  writerInfo_[index]->inputSizeInBytes += dataInput->estimateFlatSize();
+  writerInfo_[index]->numWrittenRows += dataInput->size();
+  writerInfo_[index]->currentFileWrittenRows += dataInput->size();
+
+  // File rotation is not supported for bucketed tables (require one file per
+  // bucket with predictable name) or sorted writes (SortingWriter not
+  // recreated).
+  if (maxTargetFileBytes_ == 0 || isBucketed() || sortWrite()) {
+    return;
+  }
+
+  const auto currentFileBytes = getCurrentFileBytes(index);
+  if (currentFileBytes >= maxTargetFileBytes_) {
+    rotateWriter(index);
+  }
+}
+
+uint64_t FileDataSink::getCurrentFileBytes(size_t writerIndex) const {
+  VELOX_CHECK_LT(writerIndex, ioStats_.size());
+  VELOX_CHECK_LT(writerIndex, writerInfo_.size());
+  const auto totalBytes = ioStats_[writerIndex]->rawBytesWritten();
+  const auto baselineBytes = writerInfo_[writerIndex]->cumulativeWrittenBytes;
+  // Sanity check: total should always be >= baseline since ioStats is
+  // never reset and cumulative is a snapshot of rawBytesWritten at rotation.
+  VELOX_DCHECK_GE(totalBytes, baselineBytes);
+  return totalBytes - baselineBytes;
+}
+
+void FileDataSink::finalizeWriterFile(size_t index) {
+  VELOX_CHECK_LT(index, writerInfo_.size());
+  VELOX_CHECK_LT(index, ioStats_.size());
+
+  auto& info = writerInfo_[index];
+
+  // Capture current file stats AFTER close to include footer bytes.
+  const auto currentFileBytes = getCurrentFileBytes(index);
+
+  // Finalize the current file into writtenFiles using the stored names.
+  if (currentFileBytes > 0) {
+    FileInfo fileInfo;
+    fileInfo.writeFileName = info->currentWriteFileName;
+    fileInfo.targetFileName = info->currentTargetFileName;
+    fileInfo.fileSize = currentFileBytes;
+    fileInfo.numRows = info->currentFileWrittenRows;
+    // Reset for next file.
+    info->currentFileWrittenRows = 0;
+    info->writtenFiles.push_back(std::move(fileInfo));
+  }
+
+  // Update cumulative stats as a snapshot of total stats so far.
+  // This becomes the baseline for the next file.
+  info->cumulativeWrittenBytes = ioStats_[index]->rawBytesWritten();
+}
+
+void FileDataSink::rotateWriter(size_t index) {
+  VELOX_CHECK_LT(index, writers_.size());
+  VELOX_CHECK_LT(index, writerInfo_.size());
+
+  auto& info = writerInfo_[index];
+
+  // Close the writer first to flush all data including footer.
+  writers_[index]->close();
+
+  // Finalize the current file state.
+  finalizeWriterFile(index);
+
+  // Release old writer's memory pools. The new writer will be created lazily
+  // on the next write to avoid creating empty files.
+  writers_[index].reset();
+
+  ++info->fileSequenceNumber;
+}
+
+std::string FileDataSink::stateString(State state) {
+  switch (state) {
+    case State::kRunning:
+      return "RUNNING";
+    case State::kFinishing:
+      return "FLUSHING";
+    case State::kClosed:
+      return "CLOSED";
+    case State::kAborted:
+      return "ABORTED";
+    default:
+      VELOX_UNREACHABLE("BAD STATE: {}", static_cast<int>(state));
+  }
+}
+
+DataSink::Stats FileDataSink::stats() const {
+  Stats stats;
+  if (state_ == State::kAborted) {
+    return stats;
+  }
+
+  for (const auto& ioStats : ioStats_) {
+    stats.numWrittenBytes += ioStats->rawBytesWritten();
+    stats.writeIOTimeUs += ioStats->writeIOTimeUs();
+  }
+
+  if (state_ != State::kClosed) {
+    return stats;
+  }
+
+  // Count total files written, including rotated files.
+  stats.numWrittenFiles = 0;
+  for (size_t i = 0; i < writerInfo_.size(); ++i) {
+    const auto& info = writerInfo_.at(i);
+    VELOX_CHECK_NOT_NULL(info);
+    stats.numWrittenFiles += info->writtenFiles.size();
+    if (!info->spillStats->empty()) {
+      stats.spillStats += *info->spillStats;
+    }
+  }
+  return stats;
+}
+
+std::unordered_map<std::string, RuntimeCounter> FileDataSink::runtimeStats()
+    const {
+  std::unordered_map<std::string, RuntimeCounter> runtimeStats;
+
+  const auto fsStatsMap = fileSystemStats_->stats();
+  for (const auto& [statName, statValue] : fsStatsMap) {
+    runtimeStats.emplace(
+        statName, RuntimeCounter(statValue.sum, statValue.unit));
+  }
+
+  return runtimeStats;
+}
+
+std::shared_ptr<memory::MemoryPool> FileDataSink::createWriterPool(
+    const WriterId& writerId) {
+  auto* connectorPool = connectorQueryCtx_->connectorMemoryPool();
+  return connectorPool->addAggregateChild(
+      fmt::format("{}.{}", connectorPool->name(), writerId.toString()));
+}
+
+void FileDataSink::setMemoryReclaimers(
+    WriterInfo* /*writerInfo*/,
+    io::IoStatistics* /*ioStats*/) {
+  // Default no-op. Subclasses override to set up format-specific reclaimers.
+}
+
+void FileDataSink::setState(State newState) {
+  checkStateTransition(state_, newState);
+  state_ = newState;
+}
+
+void FileDataSink::checkStateTransition(State oldState, State newState) {
+  switch (oldState) {
+    case State::kRunning:
+      if (newState == State::kAborted || newState == State::kFinishing) {
+        return;
+      }
+      break;
+    case State::kFinishing:
+      if (newState == State::kAborted || newState == State::kClosed ||
+          // The finishing state is reentry state if we yield in the middle of
+          // finish processing if a single run takes too long.
+          newState == State::kFinishing) {
+        return;
+      }
+      [[fallthrough]];
+    case State::kAborted:
+    case State::kClosed:
+    default:
+      break;
+  }
+  VELOX_FAIL("Unexpected state transition from {} to {}", oldState, newState);
+}
+
+bool FileDataSink::finish() {
+  // Flush is reentry state.
+  setState(State::kFinishing);
+
+  // As for now, only sorted writer needs flush buffered data. For non-sorted
+  // writer, data is directly written to the underlying file writer.
+  if (!sortWrite()) {
+    return true;
+  }
+
+  const uint64_t startTimeMs = getCurrentTimeMs();
+  for (auto i = 0; i < writers_.size(); ++i) {
+    WRITER_NON_RECLAIMABLE_SECTION_GUARD(i);
+    if (!writers_[i]->finish()) {
+      return false;
+    }
+    if (getCurrentTimeMs() - startTimeMs > sortWriterFinishTimeSliceLimitMs_) {
+      return false;
+    }
+  }
+  return true;
+}
+
+std::vector<std::string> FileDataSink::close() {
+  setState(State::kClosed);
+  closeInternal();
+  return commitMessage();
+}
+
+void FileDataSink::abort() {
+  setState(State::kAborted);
+  closeInternal();
+}
+
+void FileDataSink::closeInternal() {
+  VELOX_CHECK_NE(state_, State::kRunning);
+  VELOX_CHECK_NE(state_, State::kFinishing);
+
+  TestValue::adjust(
+      "facebook::velox::connector::hive::FileDataSink::closeInternal", this);
+
+  // NOTE: writers_[i] can be nullptr during file rotation. In rotateWriter(),
+  // we call writers_[index].reset() to release the old writer before creating
+  // a new one. If an error occurs during new writer creation, or if abort is
+  // called during this window, the writer slot may be empty.
+  if (state_ == State::kClosed) {
+    for (int i = 0; i < writers_.size(); ++i) {
+      if (writers_[i] == nullptr) {
+        continue;
+      }
+      WRITER_NON_RECLAIMABLE_SECTION_GUARD(i);
+      writers_[i]->close();
+      finalizeWriterFile(i);
+    }
+  } else {
+    for (int i = 0; i < writers_.size(); ++i) {
+      if (writers_[i] == nullptr) {
+        continue;
+      }
+      WRITER_NON_RECLAIMABLE_SECTION_GUARD(i);
+      writers_[i]->abort();
+    }
+  }
+}
+
+uint32_t FileDataSink::ensureWriter(const WriterId& id) {
+  auto it = writerIndexMap_.find(id);
+  if (it != writerIndexMap_.end()) {
+    return it->second;
+  }
+  return appendWriter(id);
+}
+
+uint32_t FileDataSink::appendWriter(const WriterId& id) {
+  // Check max open writers.
+  VELOX_USER_CHECK_LE(
+      writers_.size(), maxOpenWriters_, "Exceeded open writer limit");
+  VELOX_CHECK_EQ(writers_.size(), writerInfo_.size());
+  VELOX_CHECK_EQ(writerIndexMap_.size(), writerInfo_.size());
+
+  std::optional<std::string> partitionName;
+  if (isPartitioned()) {
+    partitionName = getPartitionName(id.partitionId.value());
+  }
+
+  // Without explicitly setting flush policy, the default memory based flush
+  // policy is used.
+  auto writerParameters = getWriterParameters(partitionName, id.bucketId);
+  auto writerPool = createWriterPool(id);
+  auto sinkPool = createSinkPool(writerPool);
+  std::shared_ptr<memory::MemoryPool> sortPool{nullptr};
+  if (sortWrite()) {
+    sortPool = createSortPool(writerPool);
+  }
+  writerInfo_.emplace_back(
+      std::make_shared<WriterInfo>(
+          std::move(writerParameters),
+          std::move(writerPool),
+          std::move(sinkPool),
+          std::move(sortPool)));
+  ioStats_.emplace_back(std::make_unique<io::IoStatistics>());
+
+  setMemoryReclaimers(writerInfo_.back().get(), ioStats_.back().get());
+  writers_.emplace_back(createWriterForIndex(writerInfo_.size() - 1));
+  addThreadLocalRuntimeStat(
+      fmt::format("{}WriterCount", dwio::common::toString(storageFormat_)),
+      RuntimeCounter(1));
+  // Extends the buffer used for partition rows calculations.
+  partitionSizes_.emplace_back(0);
+  partitionRows_.emplace_back(nullptr);
+  rawPartitionRows_.emplace_back(nullptr);
+
+  writerIndexMap_.emplace(id, writers_.size() - 1);
+  return writerIndexMap_[id];
+}
+
+WriterId FileDataSink::getWriterId(vector_size_t row) const {
+  std::optional<uint32_t> partitionId;
+  if (isPartitioned()) {
+    VELOX_CHECK_LT(partitionIds_[row], std::numeric_limits<uint32_t>::max());
+    partitionId = static_cast<uint32_t>(partitionIds_[row]);
+  }
+
+  std::optional<uint32_t> bucketId;
+  if (isBucketed()) {
+    bucketId = bucketIds_[row];
+  }
+  return WriterId{partitionId, bucketId};
+}
+
+void FileDataSink::updatePartitionRows(
+    uint32_t index,
+    vector_size_t numRows,
+    vector_size_t row) {
+  VELOX_DCHECK_LT(index, partitionSizes_.size());
+  VELOX_DCHECK_EQ(partitionSizes_.size(), partitionRows_.size());
+  VELOX_DCHECK_EQ(partitionRows_.size(), rawPartitionRows_.size());
+  if (FOLLY_UNLIKELY(partitionRows_[index] == nullptr) ||
+      (partitionRows_[index]->capacity() < numRows * sizeof(vector_size_t))) {
+    partitionRows_[index] =
+        allocateIndices(numRows, connectorQueryCtx_->memoryPool());
+    rawPartitionRows_[index] =
+        partitionRows_[index]->asMutable<vector_size_t>();
+  }
+  rawPartitionRows_[index][partitionSizes_[index]] = row;
+  ++partitionSizes_[index];
+}
+
+void FileDataSink::splitInputRowsAndEnsureWriters() {
+  VELOX_CHECK(isPartitioned() || isBucketed());
+  if (isBucketed() && isPartitioned()) {
+    VELOX_CHECK_EQ(bucketIds_.size(), partitionIds_.size());
+  }
+
+  std::fill(partitionSizes_.begin(), partitionSizes_.end(), 0);
+
+  const auto numRows = static_cast<vector_size_t>(
+      isPartitioned() ? partitionIds_.size() : bucketIds_.size());
+  for (vector_size_t row = 0; row < numRows; ++row) {
+    const auto id = getWriterId(row);
+    const uint32_t index = ensureWriter(id);
+    updatePartitionRows(index, numRows, row);
+  }
+
+  for (uint32_t i = 0; i < partitionSizes_.size(); ++i) {
+    if (partitionSizes_[i] != 0) {
+      VELOX_CHECK_NOT_NULL(partitionRows_[i]);
+      partitionRows_[i]->setSize(partitionSizes_[i] * sizeof(vector_size_t));
+    }
+  }
+}
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/FileDataSink.h b/velox/connectors/hive/FileDataSink.h
new file mode 100644
index 00000000000..d427cc1db22
--- /dev/null
+++ b/velox/connectors/hive/FileDataSink.h
@@ -0,0 +1,447 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/connectors/Connector.h"
+#include "velox/connectors/hive/PartitionIdGenerator.h"
+#include "velox/dwio/common/Options.h"
+#include "velox/dwio/common/Writer.h"
+#include "velox/dwio/common/WriterFactory.h"
+#include "velox/exec/MemoryReclaimer.h"
+
+namespace facebook::velox::connector::hive {
+
+/// Parameters for file writers.
+class WriterParameters {
+ public:
+  enum class UpdateMode {
+    kNew, // Write files to a new directory.
+    kOverwrite, // Overwrite an existing directory.
+    // Append mode is currently only supported for unpartitioned tables.
+    kAppend, // Append to an unpartitioned table.
+  };
+
+  /// @param updateMode Write the files to a new directory, or append to an
+  /// existing directory or overwrite an existing directory.
+  /// @param partitionName Partition name in the typical Hive style, which is
+  /// also the partition subdirectory part of the partition path.
+  /// @param targetFileName The final name of a file after committing.
+  /// @param targetDirectory The final directory that a file should be in after
+  /// committing.
+  /// @param writeFileName The temporary name of the file that a running writer
+  /// writes to. If a running writer writes directory to the target file, set
+  /// writeFileName to targetFileName by default.
+  /// @param writeDirectory The temporary directory that a running writer writes
+  /// to. If a running writer writes directory to the target directory, set
+  /// writeDirectory to targetDirectory by default.
+  WriterParameters(
+      UpdateMode updateMode,
+      std::optional<std::string> partitionName,
+      std::string targetFileName,
+      std::string targetDirectory,
+      const std::optional<std::string>& writeFileName = std::nullopt,
+      const std::optional<std::string>& writeDirectory = std::nullopt)
+      : updateMode_(updateMode),
+        partitionName_(std::move(partitionName)),
+        targetFileName_(std::move(targetFileName)),
+        targetDirectory_(std::move(targetDirectory)),
+        writeFileName_(writeFileName.value_or(targetFileName_)),
+        writeDirectory_(writeDirectory.value_or(targetDirectory_)) {}
+
+  UpdateMode updateMode() const {
+    return updateMode_;
+  }
+
+  static std::string updateModeToString(UpdateMode updateMode) {
+    switch (updateMode) {
+      case UpdateMode::kNew:
+        return "NEW";
+      case UpdateMode::kOverwrite:
+        return "OVERWRITE";
+      case UpdateMode::kAppend:
+        return "APPEND";
+      default:
+        VELOX_UNSUPPORTED("Unsupported update mode.");
+    }
+  }
+
+  const std::optional<std::string>& partitionName() const {
+    return partitionName_;
+  }
+
+  const std::string& targetFileName() const {
+    return targetFileName_;
+  }
+
+  const std::string& writeFileName() const {
+    return writeFileName_;
+  }
+
+  const std::string& targetDirectory() const {
+    return targetDirectory_;
+  }
+
+  const std::string& writeDirectory() const {
+    return writeDirectory_;
+  }
+
+ private:
+  const UpdateMode updateMode_;
+  const std::optional<std::string> partitionName_;
+  const std::string targetFileName_;
+  const std::string targetDirectory_;
+  const std::string writeFileName_;
+  const std::string writeDirectory_;
+};
+
+/// Information about a single file written as part of a writer's output.
+/// When file rotation occurs, multiple FileInfo entries are created.
+struct FileInfo {
+  /// The temporary file name used during writing (in the staging directory).
+  std::string writeFileName;
+  /// The final file name after commit (in the target directory).
+  std::string targetFileName;
+  /// Size of the file in bytes.
+  uint64_t fileSize{0};
+  /// Number of rows in the file.
+  uint64_t numRows{0};
+};
+
+struct WriterInfo {
+  WriterInfo(
+      WriterParameters parameters,
+      std::shared_ptr<memory::MemoryPool> _writerPool,
+      std::shared_ptr<memory::MemoryPool> _sinkPool,
+      std::shared_ptr<memory::MemoryPool> _sortPool)
+      : writerParameters(std::move(parameters)),
+        nonReclaimableSectionHolder(new tsan_atomic<bool>(false)),
+        spillStats(std::make_unique<exec::SpillStats>()),
+        writerPool(std::move(_writerPool)),
+        sinkPool(std::move(_sinkPool)),
+        sortPool(std::move(_sortPool)) {}
+
+  // Writer configuration: update mode, partition, file paths.
+  const WriterParameters writerParameters;
+  // Guards non-reclaimable sections during write operations.
+  const std::unique_ptr<tsan_atomic<bool>> nonReclaimableSectionHolder;
+  // Collects the spill stats from sort writer if the spilling has been
+  // triggered.
+  const std::unique_ptr<exec::SpillStats> spillStats;
+  // Memory pool for the writer itself.
+  const std::shared_ptr<memory::MemoryPool> writerPool;
+  // Memory pool for the file sink (serialization layer).
+  const std::shared_ptr<memory::MemoryPool> sinkPool;
+  // Memory pool for sort buffers (nullptr if not a sorted write).
+  const std::shared_ptr<memory::MemoryPool> sortPool;
+  // Total rows written by this writer across all files.
+  uint64_t numWrittenRows{0};
+  // Rows written to the current file; reset to 0 when the file is finalized.
+  uint64_t currentFileWrittenRows{0};
+  uint64_t inputSizeInBytes{0};
+  /// File sequence number for tracking multiple files written due to size-based
+  /// splitting. Incremented each time the writer rotates to a new file.
+  /// Used to generate sequenced file names (e.g., file_1.orc, file_2.orc).
+  /// Invariant during write: fileSequenceNumber == writtenFiles.size()
+  /// After close: fileSequenceNumber + 1 == writtenFiles.size() (final file
+  /// added)
+  uint32_t fileSequenceNumber{0};
+  /// Tracks all files written by this writer.
+  /// During write: contains only rotated (completed) files.
+  /// After close: contains all files including the final one (via
+  /// finalizeWriterFile).
+  std::vector<FileInfo> writtenFiles;
+  /// Snapshot of total bytes written at the start of the current file.
+  /// Used as baseline to calculate current file size: rawBytesWritten() - this.
+  /// Updated to ioStats->rawBytesWritten() after each rotation.
+  uint64_t cumulativeWrittenBytes{0};
+  /// Current file's write filename (set when file is created/rotated).
+  /// This avoids recomputing makeSequencedFileName() in commitMessage().
+  std::string currentWriteFileName;
+  /// Current file's target filename (set when file is created/rotated).
+  std::string currentTargetFileName;
+};
+
+/// Identifies a writer by partition and bucket.
+struct WriterId {
+  std::optional<uint32_t> partitionId{std::nullopt};
+  std::optional<uint32_t> bucketId{std::nullopt};
+
+  WriterId() = default;
+
+  explicit WriterId(
+      std::optional<uint32_t> _partitionId,
+      std::optional<uint32_t> _bucketId = std::nullopt)
+      : partitionId(_partitionId), bucketId(_bucketId) {}
+
+  /// Returns the special writer id for the un-partitioned (and non-bucketed)
+  /// table.
+  static const WriterId& unpartitionedId();
+
+  std::string toString() const;
+
+  bool operator==(const WriterId& other) const {
+    return std::tie(partitionId, bucketId) ==
+        std::tie(other.partitionId, other.bucketId);
+  }
+};
+
+struct WriterIdHasher {
+  std::size_t operator()(const WriterId& id) const {
+    return bits::hashMix(
+        id.partitionId.value_or(std::numeric_limits<uint32_t>::max()),
+        id.bucketId.value_or(std::numeric_limits<uint32_t>::max()));
+  }
+};
+
+struct WriterIdEq {
+  bool operator()(const WriterId& lhs, const WriterId& rhs) const {
+    return lhs == rhs;
+  }
+};
+
+/// Base class for file-based data sinks that write data to columnar file
+/// formats (ORC, Parquet, etc.). Provides the generic write pipeline: state
+/// machine, row routing to writers, file rotation, and stats aggregation.
+///
+/// Connector-specific data sinks (Hive, Paimon, etc.) extend this class to
+/// add format-specific behavior like commit protocols, partition naming,
+/// writer creation, and memory reclamation.
+class FileDataSink : public DataSink {
+ public:
+  /// Defines the execution states of a file data sink.
+  enum class State {
+    /// The data sink accepts new append data in this state.
+    kRunning = 0,
+    /// The data sink flushes any buffered data to the underlying file writer
+    /// but no more data can be appended.
+    kFinishing = 1,
+    /// The data sink is aborted on error and no more data can be appended.
+    kAborted = 2,
+    /// The data sink is closed on error and no more data can be appended.
+    kClosed = 3
+  };
+  static std::string stateString(State state);
+
+  FileDataSink(
+      RowTypePtr inputType,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      CommitStrategy commitStrategy,
+      dwio::common::FileFormat storageFormat,
+      uint32_t maxOpenWriters,
+      std::vector<column_index_t> partitionChannels,
+      std::vector<column_index_t> dataChannels,
+      int32_t bucketCount,
+      std::unique_ptr<core::PartitionFunction> bucketFunction,
+      std::unique_ptr<PartitionIdGenerator> partitionIdGenerator,
+      std::shared_ptr<dwio::common::WriterFactory> writerFactory,
+      uint64_t maxTargetFileBytes,
+      bool partitionKeyAsLowerCase,
+      const common::SpillConfig* spillConfig,
+      uint64_t sortWriterFinishTimeSliceLimitMs);
+
+  void appendData(RowVectorPtr input) override;
+
+  bool finish() override;
+
+  Stats stats() const override;
+
+  std::unordered_map<std::string, RuntimeCounter> runtimeStats() const override;
+
+  std::vector<std::string> close() override;
+
+  void abort() override;
+
+ protected:
+  // Validates the state transition from 'oldState' to 'newState'.
+  void checkStateTransition(State oldState, State newState);
+  void setState(State newState);
+
+  // Generates commit messages for all writers containing metadata about written
+  // files. Creates a JSON object for each writer with partition name,
+  // file paths, file names, data sizes, and row counts. This metadata is used
+  // by the coordinator to commit the transaction and update the metastore.
+  //
+  // @return Vector of JSON strings, one per writer.
+  virtual std::vector<std::string> commitMessage() const = 0;
+
+  // Returns the type of non-partition data columns.
+  static RowTypePtr getNonPartitionTypes(
+      const std::vector<column_index_t>& dataCols,
+      const RowTypePtr& inputType);
+
+  // Filters out partition columns from the input, returning only data columns.
+  static RowVectorPtr makeDataInput(
+      const std::vector<column_index_t>& dataCols,
+      const RowVectorPtr& input);
+
+  FOLLY_ALWAYS_INLINE bool sortWrite() const {
+    return sortWrite_;
+  }
+
+  // Returns true if the table is partitioned.
+  FOLLY_ALWAYS_INLINE bool isPartitioned() const {
+    return partitionIdGenerator_ != nullptr;
+  }
+
+  // Returns true if the table is bucketed.
+  FOLLY_ALWAYS_INLINE bool isBucketed() const {
+    return bucketCount_ != 0;
+  }
+
+  FOLLY_ALWAYS_INLINE bool isCommitRequired() const {
+    return commitStrategy_ != CommitStrategy::kNoCommit;
+  }
+
+  std::shared_ptr<memory::MemoryPool> createWriterPool(
+      const WriterId& writerId);
+
+  // Sets up memory reclaimers for writer pools. Override to install
+  // format-specific reclaimers. Default is a no-op.
+  virtual void setMemoryReclaimers(
+      WriterInfo* writerInfo,
+      io::IoStatistics* ioStats);
+
+  // Returns the bytes written to the current file for the specified writer.
+  uint64_t getCurrentFileBytes(size_t writerIndex) const;
+
+  // Compute the partition id and bucket id for each row in 'input'.
+  virtual void computePartitionAndBucketIds(const RowVectorPtr& input) = 0;
+
+  // Get the HiveWriter corresponding to the row
+  // from partitionIds and bucketIds.
+  WriterId getWriterId(vector_size_t row) const;
+
+  // Computes the number of input rows as well as the actual input row indices
+  // to each corresponding (bucketed) partition based on the partition and
+  // bucket ids calculated by 'computePartitionAndBucketIds'.
+  void splitInputRowsAndEnsureWriters();
+
+  // Makes sure to create one writer for the given writer id. The function
+  // returns the corresponding index in 'writers_'.
+  virtual uint32_t ensureWriter(const WriterId& id);
+
+  // Appends a new writer for the given 'id'. The function returns the index of
+  // the newly created writer in 'writers_'.
+  uint32_t appendWriter(const WriterId& id);
+
+  // Creates a writer for the given index using the current file sequence.
+  virtual std::unique_ptr<facebook::velox::dwio::common::Writer>
+  createWriterForIndex(size_t writerIndex) = 0;
+
+  // Creates and configures WriterOptions based on file format.
+  virtual std::shared_ptr<dwio::common::WriterOptions> createWriterOptions()
+      const = 0;
+
+  virtual std::shared_ptr<dwio::common::WriterOptions> createWriterOptions(
+      size_t writerIndex) const = 0;
+
+  // Returns the partition directory name for the given partition ID.
+  virtual std::string getPartitionName(uint32_t partitionId) const = 0;
+
+  // Returns writer parameters for the given partition and bucket.
+  virtual WriterParameters getWriterParameters(
+      const std::optional<std::string>& partition,
+      std::optional<uint32_t> bucketId) const = 0;
+
+  // Records a row index for a specific partition.
+  void
+  updatePartitionRows(uint32_t index, vector_size_t numRows, vector_size_t row);
+
+  FOLLY_ALWAYS_INLINE void checkRunning() const {
+    VELOX_CHECK_EQ(state_, State::kRunning, "File data sink is not running");
+  }
+
+  // Invoked to write 'input' to the specified file writer.
+  void write(size_t index, RowVectorPtr input);
+
+  // Rotates the writer at the given index to a new file.
+  virtual void rotateWriter(size_t index);
+
+  // Finalizes the current file for the writer at the given index.
+  void finalizeWriterFile(size_t index);
+
+  virtual void closeInternal();
+
+  // IMPORTANT NOTE: these are passed to writers as raw pointers. FileDataSink
+  // owns the lifetime of these objects, and therefore must destroy them last.
+  std::vector<std::unique_ptr<io::IoStatistics>> ioStats_;
+  // Generic filesystem stats, exposed as RuntimeStats
+  std::unique_ptr<IoStats> fileSystemStats_;
+
+  const RowTypePtr inputType_;
+  const ConnectorQueryCtx* const connectorQueryCtx_;
+  const CommitStrategy commitStrategy_;
+  const dwio::common::FileFormat storageFormat_;
+  const uint32_t maxOpenWriters_;
+  const std::vector<column_index_t> partitionChannels_;
+  const std::unique_ptr<PartitionIdGenerator> partitionIdGenerator_;
+  // Indices of dataChannel are stored in ascending order
+  const std::vector<column_index_t> dataChannels_;
+  const int32_t bucketCount_{0};
+  const std::unique_ptr<core::PartitionFunction> bucketFunction_;
+  const std::shared_ptr<dwio::common::WriterFactory> writerFactory_;
+  const common::SpillConfig* const spillConfig_;
+  const uint64_t sortWriterFinishTimeSliceLimitMs_{0};
+  const uint64_t maxTargetFileBytes_{0};
+  const bool partitionKeyAsLowerCase_;
+
+  /// Whether this sink uses sorted writes. Set by subclass after computing
+  /// sort columns in its constructor.
+  bool sortWrite_{false};
+
+  State state_{State::kRunning};
+
+  tsan_atomic<bool> nonReclaimableSection_{false};
+
+  // The map from writer id to the writer index in 'writers_' and 'writerInfo_'.
+  folly::F14FastMap<WriterId, uint32_t, WriterIdHasher, WriterIdEq>
+      writerIndexMap_;
+
+  // Below are structures for partitions from all inputs. writerInfo_ and
+  // writers_ are both indexed by partitionId.
+  std::vector<std::shared_ptr<WriterInfo>> writerInfo_;
+  std::vector<std::unique_ptr<dwio::common::Writer>> writers_;
+
+  // Below are structures updated when processing current input. partitionIds_
+  // are indexed by the row of input_. partitionRows_, rawPartitionRows_ and
+  // partitionSizes_ are indexed by partitionId.
+  raw_vector<uint64_t> partitionIds_;
+  std::vector<BufferPtr> partitionRows_;
+  std::vector<vector_size_t*> rawPartitionRows_;
+  std::vector<vector_size_t> partitionSizes_;
+
+  // Reusable buffers for bucket id calculations.
+  std::vector<uint32_t> bucketIds_;
+};
+
+FOLLY_ALWAYS_INLINE std::ostream& operator<<(
+    std::ostream& os,
+    FileDataSink::State state) {
+  os << FileDataSink::stateString(state);
+  return os;
+}
+} // namespace facebook::velox::connector::hive
+
+template <>
+struct fmt::formatter<facebook::velox::connector::hive::FileDataSink::State>
+    : formatter<std::string> {
+  auto format(
+      facebook::velox::connector::hive::FileDataSink::State s,
+      format_context& ctx) const {
+    return formatter<std::string>::format(
+        facebook::velox::connector::hive::FileDataSink::stateString(s), ctx);
+  }
+};
diff --git a/velox/connectors/hive/FileDataSource.cpp b/velox/connectors/hive/FileDataSource.cpp
new file mode 100644
index 00000000000..260b6764a7c
--- /dev/null
+++ b/velox/connectors/hive/FileDataSource.cpp
@@ -0,0 +1,735 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/FileDataSource.h"
+
+#include <fmt/ranges.h>
+#include <string>
+#include <unordered_map>
+
+#include "velox/common/Casts.h"
+#include "velox/common/testutil/TestValue.h"
+#include "velox/common/time/CpuWallTimer.h"
+#include "velox/connectors/hive/ExtractionUtils.h"
+#include "velox/connectors/hive/FileConfig.h"
+#include "velox/expression/FieldReference.h"
+
+using facebook::velox::common::testutil::TestValue;
+
+namespace facebook::velox::connector::hive {
+
+namespace {
+
+inline void addIoCounterMetric(
+    io::IoCounter& counter,
+    const std::string& key,
+    std::unordered_map<std::string, RuntimeMetric>& res) {
+  if (counter.count() > 0) {
+    res.insert({key, RuntimeMetric(counter.count())});
+  }
+}
+
+inline void addIoCounterMetric(
+    uint64_t value,
+    const std::string& key,
+    RuntimeCounter::Unit unit,
+    std::unordered_map<std::string, RuntimeMetric>& res) {
+  if (value > 0) {
+    res.insert({key, RuntimeMetric(value, unit)});
+  }
+}
+
+inline void addIoStatsMetric(
+    io::IoCounter& counter,
+    const std::string& key,
+    RuntimeCounter::Unit unit,
+    std::unordered_map<std::string, RuntimeMetric>& res) {
+  if (counter.count() > 0) {
+    res.insert(
+        {key,
+         RuntimeMetric(
+             saturateCast(counter.sum()),
+             counter.count(),
+             saturateCast(counter.min()),
+             saturateCast(counter.max()),
+             unit)});
+  }
+}
+
+inline void addIoLatencyMetric(
+    io::IoCounter& counter,
+    const std::string& key,
+    std::unordered_map<std::string, RuntimeMetric>& res) {
+  if (counter.count() > 0) {
+    res.insert(
+        {key,
+         RuntimeMetric(
+             saturateCast(counter.sum() * 1'000),
+             counter.count(),
+             saturateCast(counter.min() * 1'000),
+             saturateCast(counter.max() * 1'000),
+             RuntimeCounter::Unit::kNanos)});
+  }
+}
+
+void addIoStatsToRuntimeStats(
+    io::IoStatistics& ioStats,
+    std::string_view prefix,
+    std::unordered_map<std::string, RuntimeMetric>& res) {
+  auto key = [&](std::string_view name) {
+    return prefix.empty() ? std::string(name)
+                          : fmt::format("{}.{}", prefix, name);
+  };
+
+  addIoLatencyMetric(
+      ioStats.queryThreadIoLatencyUs(), key(Connector::kIoWaitWallNanos), res);
+  addIoLatencyMetric(
+      ioStats.storageReadLatencyUs(),
+      key(Connector::kStorageReadWallNanos),
+      res);
+  addIoLatencyMetric(
+      ioStats.ssdCacheReadLatencyUs(),
+      key(Connector::kSsdCacheReadWallNanos),
+      res);
+  addIoLatencyMetric(
+      ioStats.cacheWaitLatencyUs(), key(Connector::kCacheWaitWallNanos), res);
+  addIoLatencyMetric(
+      ioStats.coalescedSsdLoadLatencyUs(),
+      key(Connector::kCoalescedSsdLoadWallNanos),
+      res);
+  addIoLatencyMetric(
+      ioStats.coalescedStorageLoadLatencyUs(),
+      key(Connector::kCoalescedStorageLoadWallNanos),
+      res);
+
+  addIoCounterMetric(
+      ioStats.prefetch(), key(FileDataSource::kNumPrefetch), res);
+  addIoStatsMetric(
+      ioStats.prefetch(),
+      key(FileDataSource::kPrefetchBytes),
+      RuntimeCounter::Unit::kBytes,
+      res);
+  addIoCounterMetric(
+      ioStats.totalScanTimeNs(),
+      key(FileDataSource::kTotalScanTime),
+      RuntimeCounter::Unit::kNanos,
+      res);
+  addIoCounterMetric(
+      ioStats.rawOverreadBytes(),
+      key(FileDataSource::kOverreadBytes),
+      RuntimeCounter::Unit::kBytes,
+      res);
+
+  addIoStatsMetric(
+      ioStats.read(),
+      key(FileDataSource::kStorageReadBytes),
+      RuntimeCounter::Unit::kBytes,
+      res);
+  addIoCounterMetric(
+      ioStats.ssdRead(), key(FileDataSource::kNumLocalRead), res);
+  addIoStatsMetric(
+      ioStats.ssdRead(),
+      key(FileDataSource::kLocalReadBytes),
+      RuntimeCounter::Unit::kBytes,
+      res);
+  addIoCounterMetric(ioStats.ramHit(), key(FileDataSource::kNumRamRead), res);
+  addIoStatsMetric(
+      ioStats.ramHit(),
+      key(FileDataSource::kRamReadBytes),
+      RuntimeCounter::Unit::kBytes,
+      res);
+}
+
+} // namespace
+
+void FileDataSource::processColumnHandle(const FileColumnHandlePtr& handle) {
+  switch (handle->columnType()) {
+    case FileColumnHandle::ColumnType::kRegular:
+      break;
+    case FileColumnHandle::ColumnType::kPartitionKey:
+      partitionKeys_.emplace(handle->name(), handle);
+      break;
+    case FileColumnHandle::ColumnType::kSynthesized:
+      infoColumns_.emplace(handle->name(), handle);
+      break;
+    case FileColumnHandle::ColumnType::kRowIndex:
+      specialColumns_.rowIndex = handle->name();
+      break;
+    case FileColumnHandle::ColumnType::kRowId:
+      specialColumns_.rowId = handle->name();
+      break;
+  }
+}
+
+FileDataSource::FileDataSource(
+    const RowTypePtr& outputType,
+    const connector::ConnectorTableHandlePtr& tableHandle,
+    const connector::ColumnHandleMap& assignments,
+    FileHandleFactory* fileHandleFactory,
+    folly::Executor* ioExecutor,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    const std::shared_ptr<FileConfig>& fileConfig)
+    : fileHandleFactory_(fileHandleFactory),
+      ioExecutor_(ioExecutor),
+      connectorQueryCtx_(connectorQueryCtx),
+      fileConfig_(fileConfig),
+      pool_(connectorQueryCtx->memoryPool()),
+      outputType_(outputType),
+      expressionEvaluator_(connectorQueryCtx->expressionEvaluator()) {
+  tableHandle_ = checkedPointerCast<const FileTableHandle>(tableHandle);
+
+  folly::F14FastMap<std::string_view, const FileColumnHandle*> columnHandles;
+  // Column handles keyed on the table column name.
+  for (const auto& [_, columnHandle] : assignments) {
+    auto handle = checkedPointerCast<const FileColumnHandle>(columnHandle);
+    const auto [it, unique] =
+        columnHandles.emplace(handle->name(), handle.get());
+    if (!unique) {
+      // This should not happen normally, but there are cases where we get
+      // duplicate assignments for partitioning columns.
+      checkColumnHandleConsistent(*handle, *it->second);
+      VELOX_CHECK_EQ(
+          handle->columnType(),
+          FileColumnHandle::ColumnType::kPartitionKey,
+          "Cannot map from same table column to different outputs in table scan; a project node should be used instead: {}",
+          handle->name());
+      continue;
+    }
+    processColumnHandle(handle);
+  }
+  for (auto& handle : tableHandle_->filterColumnHandles()) {
+    auto it = columnHandles.find(handle->name());
+    if (it != columnHandles.end()) {
+      checkColumnHandleConsistent(*handle, *it->second);
+      continue;
+    }
+    processColumnHandle(handle);
+  }
+
+  std::vector<std::string> readColumnNames;
+  auto readColumnTypes = outputType_->children();
+  for (const auto& outputName : outputType_->names()) {
+    auto it = assignments.find(outputName);
+    VELOX_CHECK(
+        it != assignments.end(),
+        "ColumnHandle is missing for output column: {}",
+        outputName);
+
+    auto* handle = static_cast<const FileColumnHandle*>(it->second.get());
+    readColumnNames.push_back(handle->name());
+    for (auto& subfield : handle->requiredSubfields()) {
+      VELOX_USER_CHECK_EQ(
+          getColumnName(subfield),
+          handle->name(),
+          "Required subfield does not match column name");
+      subfields_[handle->name()].push_back(&subfield);
+    }
+    columnPostProcessors_.push_back(handle->postProcessor());
+  }
+
+  if (fileConfig_->isFileColumnNamesReadAsLowerCase(
+          connectorQueryCtx->sessionProperties())) {
+    checkColumnNameLowerCase(outputType_);
+    checkColumnNameLowerCase(tableHandle_->subfieldFilters(), infoColumns_);
+    checkColumnNameLowerCase(tableHandle_->remainingFilter());
+  }
+
+  for (const auto& [k, v] : tableHandle_->subfieldFilters()) {
+    filters_.emplace(k.clone(), v);
+  }
+  double sampleRate = tableHandle_->sampleRate();
+  auto remainingFilter = extractFiltersFromRemainingFilter(
+      tableHandle_->remainingFilter(),
+      expressionEvaluator_,
+      filters_,
+      sampleRate);
+  if (sampleRate != 1) {
+    randomSkip_ = std::make_shared<random::RandomSkipTracker>(sampleRate);
+  }
+
+  if (remainingFilter) {
+    remainingFilterExprSet_ = expressionEvaluator_->compile(remainingFilter);
+    auto& remainingFilterExpr = remainingFilterExprSet_->expr(0);
+    folly::F14FastMap<std::string, column_index_t> columnNames;
+    for (int i = 0; i < readColumnNames.size(); ++i) {
+      columnNames[readColumnNames[i]] = i;
+    }
+    for (auto& input : remainingFilterExpr->distinctFields()) {
+      auto it = columnNames.find(input->field());
+      if (it != columnNames.end()) {
+        if (shouldEagerlyMaterialize(*remainingFilterExpr, *input)) {
+          multiReferencedFields_.push_back(it->second);
+        }
+        continue;
+      }
+      // Remaining filter may reference columns that are not used otherwise,
+      // e.g. are not being projected out and are not used in range filters.
+      // Make sure to add these columns to readerOutputType_.
+      readColumnNames.push_back(input->field());
+      readColumnTypes.push_back(input->type());
+    }
+    remainingFilterSubfields_ = remainingFilterExpr->extractSubfields();
+    if (VLOG_IS_ON(1)) {
+      VLOG(1) << fmt::format(
+          "Extracted subfields from remaining filter: [{}]",
+          fmt::join(remainingFilterSubfields_, ", "));
+    }
+    for (auto& subfield : remainingFilterSubfields_) {
+      const auto& name = getColumnName(subfield);
+      auto it = subfields_.find(name);
+      if (it != subfields_.end()) {
+        // Some subfields of the column are already projected out, we append the
+        // remainingFilter subfield
+        it->second.push_back(&subfield);
+      } else if (columnNames.count(name) == 0) {
+        // remainingFilter subfield's column is not projected out, we add the
+        // column and append the subfield
+        subfields_[name].push_back(&subfield);
+      }
+    }
+  }
+
+  readerOutputType_ =
+      ROW(std::move(readColumnNames), std::move(readColumnTypes));
+  scanSpec_ = makeScanSpec(
+      readerOutputType_,
+      subfields_,
+      filters_,
+      /*indexColumns=*/{},
+      tableHandle_->dataColumns(),
+      partitionKeys_,
+      infoColumns_,
+      specialColumns_,
+      fileConfig_->readStatsBasedFilterReorderDisabled(
+          connectorQueryCtx_->sessionProperties()),
+      pool_);
+  if (remainingFilter) {
+    metadataFilter_ = std::make_shared<common::MetadataFilter>(
+        *scanSpec_, *remainingFilter, expressionEvaluator_);
+  }
+
+  // Detect extraction columns and reconfigure scanSpec_ if needed.
+  bool hasExtractions = false;
+  readColumnTypes = readerOutputType_->children();
+  for (int outputIdx = 0; outputIdx < outputType->size(); ++outputIdx) {
+    const auto& outputName = outputType->nameOf(outputIdx);
+    auto it = assignments.find(outputName);
+    if (it == assignments.end()) {
+      continue;
+    }
+    auto* handle = static_cast<const FileColumnHandle*>(it->second.get());
+    if (!handle->extractions().empty()) {
+      // Column has extraction chains.  Read with schemaType from file, then
+      // apply extraction post-read.  Extractions and requiredSubfields are
+      // mutually exclusive (enforced by the column handle constructor).
+      auto readerIdx = readerOutputType_->getChildIdxIfExists(handle->name());
+      if (readerIdx.has_value()) {
+        readColumnTypes[*readerIdx] = handle->schemaType();
+        extractionColumns_[*readerIdx] = handle;
+        hasExtractions = true;
+      }
+    }
+  }
+
+  if (hasExtractions) {
+    // Rebuild readerOutputType_ with schemaType for extraction columns.
+    readerOutputType_ =
+        ROW(std::vector<std::string>(
+                readerOutputType_->names().begin(),
+                readerOutputType_->names().end()),
+            std::move(readColumnTypes));
+    // Rebuild scanSpec_ with the updated readerOutputType_.
+    scanSpec_ = makeScanSpec(
+        readerOutputType_,
+        subfields_,
+        filters_,
+        /*indexColumns=*/{},
+        tableHandle_->dataColumns(),
+        partitionKeys_,
+        infoColumns_,
+        specialColumns_,
+        fileConfig_->readStatsBasedFilterReorderDisabled(
+            connectorQueryCtx->sessionProperties()),
+        pool_);
+    configureExtractionColumns();
+  }
+
+  dataIoStats_ = std::make_shared<io::IoStatistics>();
+  metadataIoStats_ = std::make_shared<io::IoStatistics>();
+  ioStats_ = std::make_shared<IoStats>();
+}
+
+void FileDataSource::configureExtractionColumns() {
+  // Configure extraction columns on the ScanSpec.  For each column with
+  // extractions, this:
+  // 1. Sets pruning hints so DWRF/Nimble readers skip unneeded sub-streams.
+  // 2. Sets a transform function on the ScanSpec node so the reader applies
+  //    extraction chains and produces the output type directly.
+  for (auto& [colIdx, handle] : extractionColumns_) {
+    auto* fieldSpec = scanSpec_->childByName(readerOutputType_->nameOf(colIdx));
+    if (!fieldSpec) {
+      continue;
+    }
+    const auto& extractions = handle->extractions();
+    auto extractionOutputType = handle->dataType();
+
+    // For multiple extractions, do NOT call configureExtractionScanSpec --
+    // keep ExtractionType as kNone and use full chains in the transform.
+    // This ensures the text reader (which does not handle ExtractionType
+    // natively) produces correct results.
+    if (extractions.size() == 1) {
+      configureExtractionScanSpec(
+          handle->schemaType(), extractions, *fieldSpec, pool_);
+    }
+    if (extractions.size() == 1) {
+      // Store a full-chain transform so hasTransform() returns true.  This
+      // signals to the delta update path that extraction is configured.
+      // The full chain is captured for PrismSplitReader to replace it.
+      fieldSpec->setTransform(
+          [fullChain = extractions[0].chain](
+              const VectorPtr& input, memory::MemoryPool* pool) -> VectorPtr {
+            return applyExtractionChain(input, fullChain, pool);
+          },
+          extractionOutputType);
+    } else {
+      // Multiple extractions: do NOT set ExtractionType on the ScanSpec.
+      // Use full chains in the transform so the text reader (which does
+      // not handle ExtractionType natively) produces correct results.
+      // TODO: Optimization: for agreeing multiple extractions, set
+      // ExtractionType and use remaining chains.  Requires text reader
+      // to handle ExtractionType natively.
+      struct ExtractionInfo {
+        std::string outputName;
+        std::vector<ExtractionPathElementPtr> chain;
+      };
+
+      std::vector<ExtractionInfo> infos;
+      for (const auto& extraction : extractions) {
+        infos.push_back({extraction.outputName, extraction.chain});
+      }
+      // Always need a transform for multiple extractions to assemble ROW.
+      fieldSpec->setTransform(
+          [infos = std::move(infos)](
+              const VectorPtr& input, memory::MemoryPool* pool) -> VectorPtr {
+            std::vector<VectorPtr> children;
+            std::vector<std::string> names;
+            std::vector<TypePtr> types;
+            children.reserve(infos.size());
+            names.reserve(infos.size());
+            types.reserve(infos.size());
+            for (const auto& info : infos) {
+              VectorPtr extracted;
+              if (info.chain.empty()) {
+                extracted = input;
+              } else {
+                extracted = applyExtractionChain(input, info.chain, pool);
+              }
+              names.push_back(info.outputName);
+              types.push_back(extracted->type());
+              children.push_back(std::move(extracted));
+            }
+            return std::make_shared<RowVector>(
+                pool,
+                ROW(std::move(names), std::move(types)),
+                nullptr,
+                input->size(),
+                std::move(children));
+          },
+          extractionOutputType);
+    }
+  }
+
+  // Build readerProducedType_ -- the actual type the reader will produce.
+  // For extraction columns where the reader handles extraction natively
+  // (ExtractionType != kNone), the output type differs from schemaType.
+  {
+    auto names = readerOutputType_->names();
+    auto types = readerOutputType_->children();
+    bool needsSeparateType = false;
+    for (auto& [colIdx, handle] : extractionColumns_) {
+      auto* fieldSpec =
+          scanSpec_->childByName(readerOutputType_->nameOf(colIdx));
+      if (fieldSpec &&
+          fieldSpec->extractionType() !=
+              common::ScanSpec::ExtractionType::kNone) {
+        VELOX_CHECK_LT(static_cast<size_t>(colIdx), types.size());
+        types[colIdx] = handle->dataType();
+        needsSeparateType = true;
+      }
+    }
+    if (needsSeparateType) {
+      readerProducedType_ =
+          ROW(std::vector<std::string>(names.begin(), names.end()),
+              std::move(types));
+    }
+  }
+}
+
+std::unique_ptr<FileSplitReader> FileDataSource::createSplitReader() {
+  return FileSplitReader::create(
+      split_,
+      tableHandle_,
+      &partitionKeys_,
+      connectorQueryCtx_,
+      fileConfig_,
+      readerOutputType_,
+      dataIoStats_,
+      metadataIoStats_,
+      ioStats_,
+      fileHandleFactory_,
+      ioExecutor_,
+      scanSpec_,
+      /*subfieldFiltersForValidation=*/&filters_);
+}
+
+void FileDataSource::addSplit(std::shared_ptr<ConnectorSplit> split) {
+  VELOX_CHECK_NULL(
+      split_,
+      "Previous split has not been processed yet. Call next to process the split.");
+  split_ = checkedPointerCast<FileConnectorSplit>(split);
+
+  VLOG(1) << "Adding split " << split_->toString();
+
+  if (splitReader_) {
+    splitReader_.reset();
+  }
+
+  splitReader_ = createSplitReader();
+
+  // Split reader subclasses may need to use the reader options in prepareSplit
+  // so we initialize it beforehand.
+  splitReader_->configureReaderOptions(randomSkip_);
+  splitReader_->prepareSplit(metadataFilter_, runtimeStats_);
+  readerOutputType_ = splitReader_->readerOutputType();
+}
+
+std::optional<RowVectorPtr> FileDataSource::next(
+    uint64_t size,
+    velox::ContinueFuture& /*future*/) {
+  VELOX_CHECK(split_ != nullptr, "No split to process. Call addSplit first.");
+  VELOX_CHECK_NOT_NULL(splitReader_, "No split reader present");
+
+  TestValue::adjust(
+      "facebook::velox::connector::hive::FileDataSource::next", this);
+
+  if (splitReader_->emptySplit()) {
+    resetSplit();
+    return nullptr;
+  }
+
+  // Subclass reader may add extra columns to reader output (e.g. for bucket
+  // conversion or delta update).
+  auto& outputRowType =
+      readerProducedType_ ? readerProducedType_ : readerOutputType_;
+  auto needsExtraColumn = [&] {
+    return output_->asUnchecked<RowVector>()->childrenSize() <
+        outputRowType->size();
+  };
+  if (!output_ || needsExtraColumn()) {
+    output_ = BaseVector::create(outputRowType, 0, pool_);
+  }
+
+  const auto rowsScanned = splitReader_->next(size, output_);
+  completedRows_ += rowsScanned;
+  if (rowsScanned == 0) {
+    splitReader_->updateRuntimeStats(runtimeStats_);
+    resetSplit();
+    return nullptr;
+  }
+
+  VELOX_CHECK(
+      !output_->mayHaveNulls(), "Top-level row vector cannot have nulls");
+  auto rowsRemaining = output_->size();
+  if (rowsRemaining == 0) {
+    // no rows passed the pushed down filters.
+    return getEmptyOutput();
+  }
+
+  auto rowVector = std::dynamic_pointer_cast<RowVector>(output_);
+
+  // In case there is a remaining filter that excludes some but not all
+  // rows, collect the indices of the passing rows. If there is no filter,
+  // or it passes on all rows, leave this as null and let exec::wrap skip
+  // wrapping the results.
+  BufferPtr remainingIndices;
+  filterRows_.resize(rowVector->size());
+
+  if (remainingFilterExprSet_) {
+    rowsRemaining = evaluateRemainingFilter(rowVector);
+    VELOX_CHECK_LE(rowsRemaining, rowsScanned);
+    if (rowsRemaining == 0) {
+      // No rows passed the remaining filter.
+      return getEmptyOutput();
+    }
+
+    if (rowsRemaining < rowVector->size()) {
+      // Some, but not all rows passed the remaining filter.
+      remainingIndices = filterEvalCtx_.selectedIndices;
+    }
+  }
+
+  if (outputType_->size() == 0) {
+    return exec::wrap(rowsRemaining, remainingIndices, rowVector);
+  }
+
+  std::vector<VectorPtr> outputColumns;
+  outputColumns.reserve(outputType_->size());
+  for (int i = 0; i < outputType_->size(); ++i) {
+    auto& child = rowVector->childAt(i);
+    if (remainingIndices) {
+      // Disable dictionary values caching in expression eval so that we
+      // don't need to reallocate the result for every batch.
+      child->disableMemo();
+    }
+    auto column = exec::wrapChild(rowsRemaining, remainingIndices, child);
+    if (columnPostProcessors_[i]) {
+      columnPostProcessors_[i](column);
+    }
+    outputColumns.push_back(std::move(column));
+  }
+
+  return std::make_shared<RowVector>(
+      pool_, outputType_, BufferPtr(nullptr), rowsRemaining, outputColumns);
+}
+
+void FileDataSource::addDynamicFilter(
+    column_index_t outputChannel,
+    const std::shared_ptr<common::Filter>& filter) {
+  auto& fieldSpec = scanSpec_->getChildByChannel(outputChannel);
+  fieldSpec.setFilter(filter);
+  scanSpec_->resetCachedValues(true);
+  if (splitReader_) {
+    splitReader_->resetFilterCaches();
+  }
+}
+
+void FileDataSource::fireScanBatchCallback(core::ScanBatchEvent event) {
+  if (!scanBatchCallback_) {
+    return;
+  }
+  FileScanBatchEvent fileEvent;
+  fileEvent.numRows = event.numRows;
+  fileEvent.wallTimeMicros = event.wallTimeMicros;
+  if (tableHandle_) {
+    fileEvent.tableName = tableHandle_->name();
+  }
+  if (split_) {
+    fileEvent.filePath = split_->filePath;
+    if (!split_->partitionKeys.empty()) {
+      fileEvent.partitionKeys = &split_->partitionKeys;
+    }
+  }
+  scanBatchCallback_(fileEvent);
+}
+
+std::unordered_map<std::string, RuntimeMetric>
+FileDataSource::getRuntimeStats() {
+  auto res = runtimeStats_.toRuntimeMetricMap();
+  addIoStatsToRuntimeStats(*dataIoStats_, "", res);
+  addIoStatsToRuntimeStats(*metadataIoStats_, kMetadataPrefix, res);
+  res.insert(
+      {{std::string(Connector::kTotalRemainingFilterTime),
+        RuntimeMetric(
+            totalRemainingFilterTime_.load(std::memory_order_relaxed),
+            RuntimeCounter::Unit::kNanos)},
+       {Connector::kTotalRemainingFilterCpuTime,
+        RuntimeMetric(
+            totalRemainingFilterCpuTime_.load(std::memory_order_relaxed),
+            RuntimeCounter::Unit::kNanos)}});
+
+  const auto ioStatsMap = ioStats_->stats();
+  for (const auto& [key, value] : ioStatsMap) {
+    // IoStats may carry a ReadFile-layer storageReadBytes that reflects the
+    // actual bytes fetched from remote storage. Use it to override the
+    // DWIO-level estimate (IoStatistics).
+    if (key == kStorageReadBytes) {
+      res[std::string(key)] = value;
+    } else {
+      res.emplace(key, value);
+    }
+  }
+  return res;
+}
+
+void FileDataSource::setFromDataSource(
+    std::unique_ptr<DataSource> sourceUnique) {
+  auto source = dynamic_cast<FileDataSource*>(sourceUnique.get());
+  VELOX_CHECK_NOT_NULL(source, "Bad DataSource type");
+
+  split_ = std::move(source->split_);
+  runtimeStats_.skippedSplits += source->runtimeStats_.skippedSplits;
+  runtimeStats_.processedSplits += source->runtimeStats_.processedSplits;
+  runtimeStats_.skippedSplitBytes += source->runtimeStats_.skippedSplitBytes;
+  readerOutputType_ = std::move(source->readerOutputType_);
+  readerProducedType_ = std::move(source->readerProducedType_);
+  extractionColumns_ = std::move(source->extractionColumns_);
+  source->scanSpec_->moveAdaptationFrom(*scanSpec_);
+  scanSpec_ = std::move(source->scanSpec_);
+  metadataFilter_ = std::move(source->metadataFilter_);
+  splitReader_ = std::move(source->splitReader_);
+  splitReader_->setConnectorQueryCtx(connectorQueryCtx_);
+  // New io will be accounted on the stats of 'source'. Add the existing
+  // balance to that.
+  source->dataIoStats_->merge(*dataIoStats_);
+  dataIoStats_ = std::move(source->dataIoStats_);
+  source->metadataIoStats_->merge(*metadataIoStats_);
+  metadataIoStats_ = std::move(source->metadataIoStats_);
+  source->ioStats_->merge(*ioStats_);
+  ioStats_ = std::move(source->ioStats_);
+}
+
+int64_t FileDataSource::estimatedRowSize() {
+  if (splitReader_ == nullptr) {
+    return kUnknownRowSize;
+  }
+  auto rowSize = splitReader_->estimatedRowSize();
+  TestValue::adjust(
+      "facebook::velox::connector::hive::FileDataSource::estimatedRowSize",
+      &rowSize);
+  return rowSize;
+}
+
+vector_size_t FileDataSource::evaluateRemainingFilter(RowVectorPtr& rowVector) {
+  for (auto fieldIndex : multiReferencedFields_) {
+    LazyVector::ensureLoadedRows(
+        rowVector->childAt(fieldIndex),
+        filterRows_,
+        filterLazyDecoded_,
+        filterLazyBaseRows_);
+  }
+  CpuWallTiming filterTiming;
+  vector_size_t rowsRemaining{0};
+  {
+    CpuWallTimer timer(filterTiming);
+    expressionEvaluator_->evaluate(
+        remainingFilterExprSet_.get(), filterRows_, *rowVector, filterResult_);
+    rowsRemaining = exec::processFilterResults(
+        filterResult_, filterRows_, filterEvalCtx_, pool_);
+  }
+  totalRemainingFilterTime_.fetch_add(
+      filterTiming.wallNanos, std::memory_order_relaxed);
+  totalRemainingFilterCpuTime_.fetch_add(
+      filterTiming.cpuNanos, std::memory_order_relaxed);
+  return rowsRemaining;
+}
+
+void FileDataSource::resetSplit() {
+  split_.reset();
+  splitReader_->resetSplit();
+  // Keep readers around to hold adaptation.
+}
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/FileDataSource.h b/velox/connectors/hive/FileDataSource.h
new file mode 100644
index 00000000000..b03c19deff6
--- /dev/null
+++ b/velox/connectors/hive/FileDataSource.h
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/common/base/RandomUtil.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/common/io/IoStatistics.h"
+#include "velox/connectors/Connector.h"
+#include "velox/connectors/hive/FileConnectorSplit.h"
+#include "velox/connectors/hive/FileHandle.h"
+#include "velox/connectors/hive/FileSplitReader.h"
+#include "velox/connectors/hive/FileTableHandle.h"
+#include "velox/connectors/hive/HiveConnectorUtil.h"
+#include "velox/dwio/common/Statistics.h"
+#include "velox/exec/OperatorUtils.h"
+#include "velox/expression/Expr.h"
+
+namespace facebook::velox::connector::hive {
+
+/// File-specific scan batch event with split metadata.
+struct FileScanBatchEvent : public core::ScanBatchEvent {
+  /// Table name from the connector table handle.
+  std::string_view tableName;
+  /// File path of the current split.
+  std::string_view filePath;
+  /// Non-owning pointer to the current split's partition keys.
+  /// Null when partition keys are not available.
+  const std::unordered_map<std::string, std::optional<std::string>>*
+      partitionKeys{nullptr};
+};
+
+class FileConfig;
+
+/// Base class for file-based data sources that read from columnar file formats
+/// (ORC, Parquet, etc.) using FileSplitReader. Provides the common scan
+/// pipeline: column resolution, filter extraction, scan spec construction,
+/// split reading, remaining filter evaluation, and runtime stats collection.
+///
+/// Connector-specific data sources (Hive, Paimon, etc.) extend this class to
+/// add format-specific behavior like bucket conversion, multi-file splits, or
+/// merge-on-read.
+class FileDataSource : public DataSource {
+ public:
+  /// Runtime stat keys for file-based data sources. Data IO stats use the
+  /// keys directly (e.g., "storageReadBytes"). Metadata IO stats use the
+  /// kMetadataPrefix (e.g., "metadata.storageReadBytes").
+  static constexpr std::string_view kMetadataPrefix{"metadata"};
+  static constexpr std::string_view kNumPrefetch{"numPrefetch"};
+  static constexpr std::string_view kPrefetchBytes{"prefetchBytes"};
+  static constexpr std::string_view kTotalScanTime{"totalScanTime"};
+  static constexpr std::string_view kOverreadBytes{"overreadBytes"};
+  static constexpr std::string_view kStorageReadBytes{"storageReadBytes"};
+  static constexpr std::string_view kNumLocalRead{"numLocalRead"};
+  static constexpr std::string_view kLocalReadBytes{"localReadBytes"};
+  static constexpr std::string_view kNumRamRead{"numRamRead"};
+  static constexpr std::string_view kRamReadBytes{"ramReadBytes"};
+
+  FileDataSource(
+      const RowTypePtr& outputType,
+      const connector::ConnectorTableHandlePtr& tableHandle,
+      const connector::ColumnHandleMap& assignments,
+      FileHandleFactory* fileHandleFactory,
+      folly::Executor* ioExecutor,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      const std::shared_ptr<FileConfig>& fileConfig);
+
+  void addSplit(std::shared_ptr<ConnectorSplit> split) override;
+
+  std::optional<RowVectorPtr> next(uint64_t size, velox::ContinueFuture& future)
+      override;
+
+  void addDynamicFilter(
+      column_index_t outputChannel,
+      const std::shared_ptr<common::Filter>& filter) override;
+
+  uint64_t getCompletedBytes() override {
+    return dataIoStats_->rawBytesRead();
+  }
+
+  uint64_t getCompletedRows() override {
+    return completedRows_;
+  }
+
+  void fireScanBatchCallback(core::ScanBatchEvent event) override;
+
+  std::unordered_map<std::string, RuntimeMetric> getRuntimeStats() override;
+
+  bool allPrefetchIssued() const override {
+    return splitReader_ && splitReader_->allPrefetchIssued();
+  }
+
+  void setFromDataSource(std::unique_ptr<DataSource> sourceUnique) override;
+
+  int64_t estimatedRowSize() override;
+
+  const common::SubfieldFilters* getFilters() const override {
+    return &filters_;
+  }
+
+  const ConnectorQueryCtx* testingConnectorQueryCtx() const {
+    return connectorQueryCtx_;
+  }
+
+ protected:
+  virtual std::unique_ptr<FileSplitReader> createSplitReader();
+
+  FileHandleFactory* const fileHandleFactory_;
+  folly::Executor* const ioExecutor_;
+  const ConnectorQueryCtx* const connectorQueryCtx_;
+  const std::shared_ptr<FileConfig> fileConfig_;
+  memory::MemoryPool* const pool_;
+
+  std::shared_ptr<FileConnectorSplit> split_;
+  FileTableHandlePtr tableHandle_;
+  std::shared_ptr<common::ScanSpec> scanSpec_;
+  VectorPtr output_;
+  std::unique_ptr<FileSplitReader> splitReader_;
+
+  /// Output type from file reader. This is different from outputType_ in that
+  /// it contains column names before assignment, and columns that are only used
+  /// in the remaining filter.
+  RowTypePtr readerOutputType_;
+
+  /// Column handles for the partition key columns keyed on partition key column
+  /// name.
+  std::unordered_map<std::string, FileColumnHandlePtr> partitionKeys_;
+
+  std::shared_ptr<io::IoStatistics> dataIoStats_;
+  std::shared_ptr<io::IoStatistics> metadataIoStats_;
+  std::shared_ptr<IoStats> ioStats_;
+
+  /// Column handles for the split info columns keyed on their column names.
+  std::unordered_map<std::string, FileColumnHandlePtr> infoColumns_;
+  SpecialColumnNames specialColumns_{};
+
+  /// Subfield pruning info collected from column handles and remaining filter.
+  folly::F14FastMap<std::string, std::vector<const common::Subfield*>>
+      subfields_;
+  common::SubfieldFilters filters_;
+
+  const exec::ExprSet* remainingFilterExprSet() const {
+    return remainingFilterExprSet_.get();
+  }
+
+  const std::shared_ptr<common::MetadataFilter>& metadataFilter() const {
+    return metadataFilter_;
+  }
+
+  // Actual type produced by the reader after extraction pushdown.  Differs
+  // from readerOutputType_ when the reader handles extraction natively
+  // (e.g., MapKeys -> ARRAY).  Null if no extraction pushdown is active.
+  RowTypePtr readerProducedType_;
+
+  // Output columns that have extraction chains.  Maps output column index to
+  // the column handle.  These columns are read with schemaType and transformed
+  // post-read using the extraction chains.
+  folly::F14FastMap<column_index_t, const FileColumnHandle*> extractionColumns_;
+
+  dwio::common::RuntimeStatistics runtimeStats_;
+
+ private:
+  // Configure extraction columns on the ScanSpec and build
+  // readerProducedType_.  Called from the constructor after scanSpec_ is
+  // created.
+  void configureExtractionColumns();
+
+  /// Adds the information from column handle to the corresponding fields in
+  /// this object.
+  void processColumnHandle(const FileColumnHandlePtr& handle);
+
+  /// Evaluates remainingFilter_ on the specified vector. Returns number of rows
+  /// passed. Populates filterEvalCtx_.selectedIndices and selectedBits if only
+  /// some rows passed the filter. If none or all rows passed
+  /// filterEvalCtx_.selectedIndices and selectedBits are not updated.
+  vector_size_t evaluateRemainingFilter(RowVectorPtr& rowVector);
+
+  /// Clears split_ after split has been fully processed. Keeps readers around
+  /// to hold adaptation.
+  void resetSplit();
+
+  const RowVectorPtr& getEmptyOutput() {
+    if (!emptyOutput_) {
+      emptyOutput_ = RowVector::createEmpty(outputType_, pool_);
+    }
+    return emptyOutput_;
+  }
+
+  /// The row type for the data source output, not including filter-only
+  /// columns.
+  const RowTypePtr outputType_;
+  core::ExpressionEvaluator* const expressionEvaluator_;
+
+  std::vector<common::Subfield> remainingFilterSubfields_;
+  /// Optional post-processors for each output column, collected from
+  /// HiveColumnHandle::postProcessor(). Applied after reading and filtering to
+  /// transform column values. Indexed by output column position.
+  std::vector<std::function<void(VectorPtr&)>> columnPostProcessors_;
+  std::shared_ptr<common::MetadataFilter> metadataFilter_;
+  std::unique_ptr<exec::ExprSet> remainingFilterExprSet_;
+  RowVectorPtr emptyOutput_;
+  std::atomic_uint64_t totalRemainingFilterTime_{0};
+  std::atomic_uint64_t totalRemainingFilterCpuTime_{0};
+  uint64_t completedRows_{0};
+  /// Field indices referenced in both remaining filter and output type. These
+  /// columns need to be materialized eagerly to avoid missing values in output.
+  std::vector<column_index_t> multiReferencedFields_;
+
+  std::shared_ptr<random::RandomSkipTracker> randomSkip_;
+
+  /// Reusable memory for remaining filter evaluation.
+  VectorPtr filterResult_;
+  SelectivityVector filterRows_;
+  DecodedVector filterLazyDecoded_;
+  SelectivityVector filterLazyBaseRows_;
+  exec::FilterEvalCtx filterEvalCtx_;
+};
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/FileHandle.cpp b/velox/connectors/hive/FileHandle.cpp
index 267691cce2e..94b6bffb615 100644
--- a/velox/connectors/hive/FileHandle.cpp
+++ b/velox/connectors/hive/FileHandle.cpp
@@ -14,65 +14,6 @@
  * limitations under the License.
  */
 
+// Implementation moved to velox/common/caching/FileHandle.cpp.
+// This file is kept so the hive file_handle BUCK target still compiles.
 #include "velox/connectors/hive/FileHandle.h"
-#include "velox/common/base/Counters.h"
-#include "velox/common/base/StatsReporter.h"
-#include "velox/common/file/FileSystems.h"
-#include "velox/common/time/Timer.h"
-
-#include <atomic>
-
-namespace facebook::velox {
-
-uint64_t FileHandleSizer::operator()(const FileHandle& fileHandle) {
-  // TODO: add to support variable file cache size support when the file system
-  // underneath supports.
-  return 1;
-}
-
-namespace {
-// The group tracking is at the level of the directory, i.e. Hive partition.
-std::string groupName(const std::string& filename) {
-  const char* slash = strrchr(filename.c_str(), '/');
-  return slash ? std::string(filename.data(), slash - filename.data())
-               : filename;
-}
-} // namespace
-
-std::unique_ptr<FileHandle> FileHandleGenerator::operator()(
-    const FileHandleKey& key,
-    const FileProperties* properties,
-    filesystems::File::IoStats* stats) {
-  // We have seen cases where drivers are stuck when creating file handles.
-  // Adding a trace here to spot this more easily in future.
-  process::TraceContext trace("FileHandleGenerator::operator()");
-  uint64_t elapsedTimeUs{0};
-  std::unique_ptr<FileHandle> fileHandle;
-  {
-    MicrosecondTimer timer(&elapsedTimeUs);
-    fileHandle = std::make_unique<FileHandle>();
-    filesystems::FileOptions options;
-    options.stats = stats;
-    options.tokenProvider = key.tokenProvider;
-    if (properties) {
-      options.fileSize = properties->fileSize;
-      options.readRangeHint = properties->readRangeHint;
-      options.extraFileInfo = properties->extraFileInfo;
-    }
-    const auto& filename = key.filename;
-    fileHandle->file = filesystems::getFileSystem(filename, properties_)
-                           ->openFileForRead(filename, options);
-    fileHandle->uuid = StringIdLease(fileIds(), filename);
-    fileHandle->groupId = StringIdLease(fileIds(), groupName(filename));
-    VLOG(1) << "Generating file handle for: " << filename
-            << " uuid: " << fileHandle->uuid.id();
-  }
-  RECORD_HISTOGRAM_METRIC_VALUE(
-      kMetricHiveFileHandleGenerateLatencyMs, elapsedTimeUs / 1000);
-  // TODO: build the hash map/etc per file type -- presumably after reading
-  // the appropriate magic number from the file, or perhaps we include the file
-  // type in the file handle key.
-  return fileHandle;
-}
-
-} // namespace facebook::velox
diff --git a/velox/connectors/hive/FileHandle.h b/velox/connectors/hive/FileHandle.h
index 6f9b4050c31..7ac67f1a33c 100644
--- a/velox/connectors/hive/FileHandle.h
+++ b/velox/connectors/hive/FileHandle.h
@@ -14,117 +14,8 @@
  * limitations under the License.
  */
 
-// A FileHandle is a File pointer plus some (optional, file-type-dependent)
-// extra information for speeding up loading columnar data. For example, when
-// we open a file we might build a hash map saying what region(s) on disk
-// correspond to a given column in a given stripe.
-//
-// The FileHandle will normally be used in conjunction with a CachedFactory
-// to speed up queries that hit the same files repeatedly; see the
-// FileHandleCache and FileHandleFactory.
-
 #pragma once
 
-#include "velox/common/base/BitUtil.h"
-#include "velox/common/caching/CachedFactory.h"
-#include "velox/common/caching/FileIds.h"
-#include "velox/common/config/Config.h"
-#include "velox/common/file/File.h"
-#include "velox/common/file/TokenProvider.h"
-#include "velox/connectors/hive/FileProperties.h"
-
-namespace facebook::velox {
-
-// See the file comment.
-struct FileHandle {
-  std::shared_ptr<ReadFile> file;
-
-  // Each time we make a new FileHandle we assign it a uuid and use that id as
-  // the identifier in downstream data caching structures. This saves a lot of
-  // memory compared to using the filename as the identifier.
-  StringIdLease uuid;
-
-  // Id for the group of files this belongs to, e.g. its
-  // directory. Used for coarse granularity access tracking, for
-  // example to decide placing on SSD.
-  StringIdLease groupId;
-
-  // We'll want to have a hash map here to record the identifier->byte range
-  // mappings. Different formats may have different identifiers, so we may need
-  // a union of maps. For example in orc you need 3 integers (I think, to be
-  // confirmed with xldb): the row bundle, the node, and the sequence. For the
-  // first diff we'll not include the map.
-};
-
-/// Estimates the memory usage of a FileHandle object.
-struct FileHandleSizer {
-  uint64_t operator()(const FileHandle& a);
-};
-
-struct FileHandleKey {
-  std::string filename;
-  std::shared_ptr<filesystems::TokenProvider> tokenProvider{nullptr};
-
-  bool operator==(const FileHandleKey& other) const {
-    if (filename != other.filename) {
-      return false;
-    }
-
-    if (tokenProvider == other.tokenProvider) {
-      return true;
-    }
-
-    if (!tokenProvider || !other.tokenProvider) {
-      return false;
-    }
-
-    return tokenProvider->equals(*other.tokenProvider);
-  }
-};
-
-} // namespace facebook::velox
-
-namespace std {
-template <>
-struct hash<facebook::velox::FileHandleKey> {
-  size_t operator()(const facebook::velox::FileHandleKey& key) const noexcept {
-    size_t filenameHash = std::hash<std::string>()(key.filename);
-    return key.tokenProvider ? facebook::velox::bits::hashMix(
-                                   filenameHash, key.tokenProvider->hash())
-                             : filenameHash;
-  }
-};
-} // namespace std
-
-namespace facebook::velox {
-using FileHandleCache =
-    SimpleLRUCache<facebook::velox::FileHandleKey, FileHandle>;
-
-// Creates FileHandles via the Generator interface the CachedFactory requires.
-class FileHandleGenerator {
- public:
-  FileHandleGenerator() {}
-  FileHandleGenerator(std::shared_ptr<const config::ConfigBase> properties)
-      : properties_(std::move(properties)) {}
-  std::unique_ptr<FileHandle> operator()(
-      const FileHandleKey& filename,
-      const FileProperties* properties,
-      filesystems::File::IoStats* stats);
-
- private:
-  const std::shared_ptr<const config::ConfigBase> properties_;
-};
-
-using FileHandleFactory = CachedFactory<
-    FileHandleKey,
-    FileHandle,
-    FileHandleGenerator,
-    FileProperties,
-    filesystems::File::IoStats,
-    FileHandleSizer>;
-
-using FileHandleCachedPtr = CachedPtr<FileHandleKey, FileHandle>;
-
-using FileHandleCacheStats = SimpleLRUCacheStats;
-
-} // namespace facebook::velox
+// Moved to velox/common/caching/FileHandle.h.
+// This header is kept for backward compatibility.
+#include "velox/common/caching/FileHandle.h"
diff --git a/velox/connectors/hive/FileIndexReader.cpp b/velox/connectors/hive/FileIndexReader.cpp
new file mode 100644
index 00000000000..844f3bdc594
--- /dev/null
+++ b/velox/connectors/hive/FileIndexReader.cpp
@@ -0,0 +1,458 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/FileIndexReader.h"
+
+#include "velox/common/Casts.h"
+#include "velox/connectors/hive/BufferedInputBuilder.h"
+#include "velox/connectors/hive/FileConfig.h"
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/connectors/hive/HiveConnectorUtil.h"
+#include "velox/connectors/hive/TableHandle.h"
+#include "velox/dwio/common/ReaderFactory.h"
+#include "velox/serializers/KeyEncoder.h"
+
+namespace facebook::velox::connector::hive {
+namespace {
+
+// Gets the index of a column in the request type by name.
+// Throws if the column is not found.
+column_index_t getRequestColumnIndex(
+    const std::string& name,
+    const RowTypePtr& requestType) {
+  const auto idxOpt = requestType->getChildIdxIfExists(name);
+  VELOX_CHECK(
+      idxOpt.has_value(), "Request column {} not found in request type", name);
+  return idxOpt.value();
+}
+
+// Processes a between condition bound (lower or upper).
+// Returns true if the bound is a field access (non-constant).
+void processBetweenBound(
+    const core::TypedExprPtr& bound,
+    size_t boundIndex,
+    const char* boundName,
+    std::vector<std::optional<variant>>& constantBoundValues,
+    std::vector<column_index_t>& requestColumnIndices,
+    const RowTypePtr& requestType) {
+  if (auto constantExpr =
+          std::dynamic_pointer_cast<const core::ConstantTypedExpr>(bound)) {
+    VELOX_CHECK(
+        !constantExpr->hasValueVector(),
+        "Complex constant values not supported for between condition {} bound",
+        boundName);
+    VELOX_CHECK(
+        !constantExpr->value().isNull(),
+        "Null constant value not allowed for between condition {} bound",
+        boundName);
+    constantBoundValues[boundIndex] = constantExpr->value();
+    requestColumnIndices[boundIndex] = kConstantChannel;
+  } else {
+    auto fieldAccess =
+        checkedPointerCast<const core::FieldAccessTypedExpr>(bound);
+    requestColumnIndices[boundIndex] =
+        getRequestColumnIndex(fieldAccess->name(), requestType);
+  }
+}
+
+} // namespace
+
+FileIndexReader::FileIndexReader(
+    std::shared_ptr<const HiveConnectorSplit> hiveSplit,
+    const std::shared_ptr<const HiveTableHandle>& hiveTableHandle,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    const std::shared_ptr<const FileConfig>& fileConfig,
+    const std::shared_ptr<common::ScanSpec>& scanSpec,
+    const std::vector<core::IndexLookupConditionPtr>& indexLookupConditions,
+    const RowTypePtr& requestType,
+    const RowTypePtr& outputType,
+    const std::shared_ptr<io::IoStatistics>& ioStatistics,
+    const std::shared_ptr<IoStats>& ioStats,
+    FileHandleFactory* fileHandleFactory,
+    folly::Executor* ioExecutor,
+    uint32_t maxRowsPerRequest)
+    : tableHandle_{hiveTableHandle},
+      connectorQueryCtx_{connectorQueryCtx},
+      fileConfig_{fileConfig},
+      fileHandleFactory_{fileHandleFactory},
+      requestType_{requestType},
+      outputType_{outputType},
+      ioStatistics_{ioStatistics},
+      ioStats_{ioStats},
+      ioExecutor_{ioExecutor},
+      pool_{connectorQueryCtx->memoryPool()},
+      scanSpec_{scanSpec},
+      indexLookupConditions_{indexLookupConditions},
+      maxRowsPerRequest_{maxRowsPerRequest},
+      hiveSplit_{std::move(hiveSplit)},
+      fileReader_{createFileReader()},
+      indexReader_{createIndexReader()} {
+  parseIndexLookupConditions();
+}
+
+void FileIndexReader::parseIndexLookupConditions() {
+  VELOX_CHECK(
+      !indexLookupConditions_.empty(),
+      "Index lookup conditions cannot be empty");
+  const auto& indexColumns = tableHandle_->indexColumns();
+  VELOX_CHECK(
+      !indexColumns.empty(), "Index columns not set in hive table handle");
+  VELOX_CHECK_LE(indexLookupConditions_.size(), indexColumns.size());
+  VELOX_CHECK_LE(
+      indexLookupConditions_.size(),
+      indexColumns.size(),
+      "Too many index lookup conditions");
+  const auto numIndexLookupConditions = indexLookupConditions_.size();
+  requestColumnIndices_.resize(numIndexLookupConditions);
+  constantBoundValues_.resize(numIndexLookupConditions);
+
+  // For building indexBoundType_ during condition processing.
+  std::vector<std::string> indexColumnNames;
+  indexColumnNames.reserve(numIndexLookupConditions);
+  std::vector<TypePtr> indexColumnTypes;
+  indexColumnTypes.reserve(numIndexLookupConditions);
+
+  // Validate and process index lookup conditions:
+  // - Index lookup conditions combined with index filters must cover all table
+  // index
+  //   columns in order.
+  // - For each index column, it must have either an index lookup condition OR a
+  // filter
+  //   in the scan spec, but not both.
+  // - At least one index lookup condition must have a non-constant value (field
+  // access
+  //   from probe side).
+  // - For between conditions, at least one bound must be non-constant.
+  // - Processing stops when we encounter a range filter or between condition.
+  size_t numValidIndexLookupConditions{0};
+  bool hasNonConstantCondition{false};
+  for (size_t i = 0; i < indexLookupConditions_.size(); ++i) {
+    const auto& indexColumn = indexColumns[i];
+    // Process the index lookup condition for this index column.
+    const auto& condition = indexLookupConditions_[i];
+    // Validate that the condition's key column matches the expected index
+    // column.
+    const auto& conditionKeyName =
+        condition->key->asUnchecked<core::FieldAccessTypedExpr>()->name();
+    VELOX_CHECK_EQ(
+        conditionKeyName,
+        indexColumn,
+        "Index lookup condition key column does not match expected index column at position {}. Index lookup conditions must follow index column order.",
+        i);
+    const auto* spec = scanSpec_->childByName(indexColumn);
+    VELOX_CHECK(
+        spec == nullptr || !spec->hasFilter(),
+        "Index column '{}' cannot have both an index lookup condition and a filter at position {}",
+        indexColumn,
+        i);
+
+    // Determine the request column index for the condition value.
+    if (auto equalCondition =
+            std::dynamic_pointer_cast<core::EqualIndexLookupCondition>(
+                condition)) {
+      // Check if the value is a constant or a field access.
+      if (auto constantValue =
+              std::dynamic_pointer_cast<const core::ConstantTypedExpr>(
+                  equalCondition->value)) {
+        // Constant value - store in constantBoundValues_ and use
+        // kConstantChannel.
+        VELOX_CHECK(
+            !constantValue->hasValueVector(),
+            "Complex constant values not supported for equal condition value");
+        VELOX_CHECK(
+            !constantValue->value().isNull(),
+            "Null constant value not allowed for equal condition value");
+        constantBoundValues_[i].resize(1);
+        constantBoundValues_[i][0] = constantValue->value();
+        requestColumnIndices_[i] = {kConstantChannel};
+      } else {
+        // Field access - get request column index.
+        const auto requestFieldAccess =
+            checkedPointerCast<const core::FieldAccessTypedExpr>(
+                equalCondition->value);
+        requestColumnIndices_[i] = {
+            getRequestColumnIndex(requestFieldAccess->name(), requestType_)};
+        hasNonConstantCondition = true;
+      }
+      // Collect column name and type for indexBoundType_.
+      indexColumnNames.push_back(indexColumn);
+      indexColumnTypes.push_back(condition->key->type());
+      ++numValidIndexLookupConditions;
+      continue;
+    }
+
+    if (auto betweenCondition =
+            std::dynamic_pointer_cast<core::BetweenIndexLookupCondition>(
+                condition)) {
+      constantBoundValues_[i].resize(2);
+      requestColumnIndices_[i].resize(2);
+
+      processBetweenBound(
+          betweenCondition->lower,
+          0,
+          "lower",
+          constantBoundValues_[i],
+          requestColumnIndices_[i],
+          requestType_);
+      processBetweenBound(
+          betweenCondition->upper,
+          1,
+          "upper",
+          constantBoundValues_[i],
+          requestColumnIndices_[i],
+          requestType_);
+
+      // Track if this between condition has at least one non-constant bound.
+      if (requestColumnIndices_[i][0] != kConstantChannel ||
+          requestColumnIndices_[i][1] != kConstantChannel) {
+        hasNonConstantCondition = true;
+      }
+
+      // Collect column name and type for indexBoundType_.
+      indexColumnNames.push_back(indexColumn);
+      indexColumnTypes.push_back(condition->key->type());
+      ++numValidIndexLookupConditions;
+      // Between condition is a range condition, stop processing further.
+      break;
+    }
+
+    VELOX_FAIL(
+        "Unsupported index lookup condition type: {}", condition->toString());
+  }
+  VELOX_CHECK_EQ(numValidIndexLookupConditions, indexLookupConditions_.size());
+  VELOX_CHECK(
+      hasNonConstantCondition,
+      "At least one index lookup condition must have a non-constant value");
+
+  // Build and cache the index bound row type.
+  indexBoundType_ =
+      ROW(std::move(indexColumnNames), std::move(indexColumnTypes));
+}
+
+std::unique_ptr<dwio::common::Reader> FileIndexReader::createFileReader() {
+  VELOX_CHECK_NOT_NULL(hiveSplit_);
+
+  dwio::common::ReaderOptions readerOpts(connectorQueryCtx_->memoryPool());
+  // TODO: Use separate IoStatistics for data and metadata.
+  readerOpts.setDataIoStats(ioStatistics_);
+  readerOpts.setMetadataIoStats(ioStatistics_);
+  hive::configureReaderOptions(
+      fileConfig_,
+      connectorQueryCtx_,
+      tableHandle_,
+      hiveSplit_,
+      hiveSplit_->serdeParameters,
+      readerOpts);
+  readerOpts.setScanSpec(scanSpec_);
+  readerOpts.setFileFormat(hiveSplit_->fileFormat);
+  VELOX_CHECK_NULL(readerOpts.randomSkip());
+
+  FileHandleKey fileHandleKey{
+      .filename = hiveSplit_->filePath,
+      .tokenProvider = connectorQueryCtx_->fsTokenProvider()};
+
+  auto fileProperties = hiveSplit_->properties.value_or(FileProperties{});
+  auto fileHandleCachePtr = fileHandleFactory_->generate(
+      fileHandleKey, &fileProperties, ioStats_ ? ioStats_.get() : nullptr);
+  VELOX_CHECK_NOT_NULL(fileHandleCachePtr.get());
+
+  auto baseFileInput = BufferedInputBuilder::getInstance()->create(
+      *fileHandleCachePtr,
+      readerOpts,
+      connectorQueryCtx_,
+      ioStatistics_,
+      ioStats_,
+      ioExecutor_,
+      /*fileReadOps=*/{});
+
+  auto reader = dwio::common::getReaderFactory(readerOpts.fileFormat())
+                    ->createReader(std::move(baseFileInput), readerOpts);
+  VELOX_CHECK_NOT_NULL(reader);
+  return reader;
+}
+
+std::unique_ptr<dwio::common::IndexReader>
+FileIndexReader::createIndexReader() {
+  VELOX_CHECK_NOT_NULL(fileReader_);
+  VELOX_CHECK(
+      hiveSplit_->fileFormat == dwio::common::FileFormat::NIMBLE ||
+          hiveSplit_->fileFormat == dwio::common::FileFormat::FLUX ||
+          hiveSplit_->fileFormat == dwio::common::FileFormat::SST,
+      "FileIndexReader only supports Nimble, Flux and SST file formats");
+
+  dwio::common::RowReaderOptions rowReaderOpts;
+  configureRowReaderOptions(
+      tableHandle_->tableParameters(),
+      scanSpec_,
+      /*metadataFilter=*/nullptr,
+      outputType_,
+      hiveSplit_,
+      hiveSplit_->serdeParameters,
+      fileConfig_,
+      connectorQueryCtx_->sessionProperties(),
+      ioExecutor_,
+      rowReaderOpts);
+  if (hiveSplit_->fileFormat != dwio::common::FileFormat::SST) {
+    rowReaderOpts.setIndexEnabled(true);
+    // Disable eager first stripe load since FileIndexReader loads stripes
+    // on-demand based on index lookup results.
+    rowReaderOpts.setEagerFirstStripeLoad(false);
+  }
+  return fileReader_->createIndexReader(rowReaderOpts);
+}
+
+void FileIndexReader::startLookup(
+    const Request& request,
+    const Options& options) {
+  // Empty files have no cluster index, so indexReader_ is null.
+  if (indexReader_ == nullptr) {
+    return;
+  }
+  VELOX_CHECK(
+      !indexReader_->hasNext(),
+      "Previous request not finished. Call next() first.");
+  VELOX_CHECK_NOT_NULL(request.input);
+  VELOX_CHECK(requestType_->equivalent(*request.input->type()));
+
+  // Use caller-provided maxRowsPerRequest if set, otherwise fall back to
+  // the construction-time default.
+  const auto maxRows = options.maxRowsPerRequest != 0
+      ? options.maxRowsPerRequest
+      : static_cast<vector_size_t>(maxRowsPerRequest_);
+  auto indexBounds = buildRequestIndexBounds(request.input);
+  indexReader_->startLookup(indexBounds, {.maxRowsPerRequest = maxRows});
+}
+
+serializer::IndexBounds FileIndexReader::buildRequestIndexBounds(
+    const RowVectorPtr& request) {
+  VELOX_CHECK_NOT_NULL(request);
+  VELOX_CHECK_NOT_NULL(indexBoundType_);
+
+  const auto numRows = request->size();
+
+  // Resize and clear reusable column vectors.
+  lowerBoundColumns_.resize(indexLookupConditions_.size());
+  upperBoundColumns_.resize(indexLookupConditions_.size());
+
+  for (size_t i = 0; i < indexLookupConditions_.size(); ++i) {
+    const auto& condition = indexLookupConditions_[i];
+    const auto& type = condition->key->type();
+
+    if (auto equalCondition =
+            std::dynamic_pointer_cast<core::EqualIndexLookupCondition>(
+                condition)) {
+      // For equal condition, lower and upper bounds have the same value.
+      const auto colIdx = requestColumnIndices_[i][0];
+      if (colIdx == kConstantChannel) {
+        auto constVector = BaseVector::createConstant(
+            type, constantBoundValues_[i][0].value(), numRows, pool_);
+        lowerBoundColumns_[i] = constVector;
+        upperBoundColumns_[i] = constVector;
+      } else {
+        auto valueVector = request->childAt(colIdx);
+        lowerBoundColumns_[i] = valueVector;
+        upperBoundColumns_[i] = valueVector;
+      }
+    } else if (
+        auto betweenCondition =
+            std::dynamic_pointer_cast<core::BetweenIndexLookupCondition>(
+                condition)) {
+      // Handle lower bound.
+      if (constantBoundValues_[i][0].has_value()) {
+        auto constVector = BaseVector::createConstant(
+            type, constantBoundValues_[i][0].value(), numRows, pool_);
+        lowerBoundColumns_[i] = constVector;
+      } else {
+        const auto colIdx = requestColumnIndices_[i][0];
+        lowerBoundColumns_[i] = request->childAt(colIdx);
+      }
+
+      // Handle upper bound.
+      if (constantBoundValues_[i][1].has_value()) {
+        auto constVector = BaseVector::createConstant(
+            type, constantBoundValues_[i][1].value(), numRows, pool_);
+        upperBoundColumns_[i] = constVector;
+      } else {
+        const auto colIdx = requestColumnIndices_[i][1];
+        upperBoundColumns_[i] = request->childAt(colIdx);
+      }
+    } else {
+      VELOX_FAIL(
+          "Unsupported index lookup condition type: {}", condition->toString());
+    }
+  }
+
+  // Build RowVectors for lower and upper bounds.
+  auto lowerBoundVector = std::make_shared<RowVector>(
+      pool_, indexBoundType_, nullptr, numRows, lowerBoundColumns_);
+  auto upperBoundVector = std::make_shared<RowVector>(
+      pool_, indexBoundType_, nullptr, numRows, upperBoundColumns_);
+
+  // Collect column names for indexBounds.
+  std::vector<std::string> indexColumnNames;
+  indexColumnNames.reserve(indexLookupConditions_.size());
+  for (const auto& col : indexBoundType_->names()) {
+    indexColumnNames.push_back(col);
+  }
+
+  serializer::IndexBounds bounds;
+  bounds.indexColumns = std::move(indexColumnNames);
+  bounds.set(
+      serializer::IndexBound{std::move(lowerBoundVector), /*inclusive=*/true},
+      serializer::IndexBound{std::move(upperBoundVector), /*inclusive=*/true});
+  return bounds;
+}
+
+bool FileIndexReader::hasNext() {
+  return indexReader_ != nullptr && indexReader_->hasNext();
+}
+
+std::unique_ptr<FileIndexReader::Result> FileIndexReader::next(
+    vector_size_t maxOutputRows) {
+  VELOX_CHECK_NOT_NULL(indexReader_);
+  auto result = indexReader_->next(maxOutputRows);
+  if (result != nullptr) {
+    numIndexOutputRows_ += result->size();
+  }
+  return result;
+}
+
+std::unordered_map<std::string, RuntimeMetric> FileIndexReader::runtimeStats() {
+  std::unordered_map<std::string, RuntimeMetric> stats;
+  if (numIndexOutputRows_ != 0) {
+    stats[std::string(kNumIndexReaderOutputRows)] = RuntimeMetric(
+        static_cast<int64_t>(numIndexOutputRows_), RuntimeCounter::Unit::kNone);
+  }
+  if (indexReader_ != nullptr) {
+    for (auto& [key, metric] : indexReader_->stats()) {
+      auto [_, inserted] = stats.emplace(key, metric);
+      VELOX_CHECK(
+          inserted, "Duplicate runtime stat '{}' from index reader", key);
+    }
+  }
+  return stats;
+}
+
+std::string FileIndexReader::toString() const {
+  return fmt::format(
+      "FileIndexReader: split={} scanSpec={} requestType={} outputType={}",
+      hiveSplit_->toString(),
+      scanSpec_->toString(),
+      requestType_->toString(),
+      outputType_->toString());
+}
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/FileIndexReader.h b/velox/connectors/hive/FileIndexReader.h
new file mode 100644
index 00000000000..1d7d85f3bb9
--- /dev/null
+++ b/velox/connectors/hive/FileIndexReader.h
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/connectors/Connector.h"
+#include "velox/connectors/hive/FileHandle.h"
+#include "velox/connectors/hive/IndexReader.h"
+#include "velox/core/PlanNode.h"
+#include "velox/dwio/common/Reader.h"
+#include "velox/serializers/KeyEncoder.h"
+
+namespace facebook::velox::connector {
+class ConnectorQueryCtx;
+} // namespace facebook::velox::connector
+
+namespace facebook::velox::connector::hive {
+
+struct HiveConnectorSplit;
+class HiveTableHandle;
+class HiveColumnHandle;
+class FileConfig;
+
+/// Handles index lookups for a single Nimble file with cluster indexes.
+/// Focuses on:
+/// - Creating index bounds from index lookup conditions
+/// - Delegating actual index lookups to the format-specific IndexReader
+///
+/// Each FileIndexReader operates on exactly one file (split). HiveIndexSource
+/// handles multi-split orchestration (union, partition routing) on top.
+///
+/// The format-specific IndexReader (e.g., SelectiveNimbleIndexReader) handles:
+/// - Encoding keys into format-specific representations
+/// - Stripe iteration and row range computation
+/// - Data reading and output assembly
+class FileIndexReader : public SplitIndexReader {
+ public:
+  FileIndexReader(
+      std::shared_ptr<const HiveConnectorSplit> hiveSplit,
+      const std::shared_ptr<const HiveTableHandle>& hiveTableHandle,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      const std::shared_ptr<const FileConfig>& fileConfig,
+      const std::shared_ptr<common::ScanSpec>& scanSpec,
+      const std::vector<core::IndexLookupConditionPtr>& indexLookupConditions,
+      const RowTypePtr& requestType,
+      const RowTypePtr& outputType,
+      const std::shared_ptr<io::IoStatistics>& ioStats,
+      const std::shared_ptr<IoStats>& fsStats,
+      FileHandleFactory* fileHandleFactory,
+      folly::Executor* ioExecutor,
+      uint32_t maxRowsPerRequest = 0);
+
+  ~FileIndexReader() override = default;
+
+  /// Sets the input for index lookup. Each row in 'input' will be converted
+  /// to index bounds and passed to the format-specific IndexReader.
+  ///
+  /// @param request The lookup request containing input row vector with lookup
+  /// keys.
+  /// @param options Options controlling index reader behavior (e.g.,
+  /// maxRowsPerRequest). Defaults to no limit.
+  void startLookup(const Request& request, const Options& options = {})
+      override;
+
+  /// Returns true if there are more results to fetch from the current lookup.
+  bool hasNext() override;
+
+  /// Returns the next batch of matching rows for the current input rows.
+  /// The result from a single request row is never split across multiple
+  /// calls to next().
+  ///
+  /// @param maxOutputRows Maximum number of output rows to return.
+  /// @return Result containing matched rows and input hit indices, or nullptr
+  /// if no more results.
+  std::unique_ptr<Result> next(vector_size_t maxOutputRows) override;
+
+  std::unordered_map<std::string, RuntimeMetric> runtimeStats() override;
+
+  std::string toString() const;
+
+ private:
+  // Creates the file reader for reading file metadata and schema.
+  std::unique_ptr<dwio::common::Reader> createFileReader();
+
+  // Creates the format-specific index reader.
+  std::unique_ptr<dwio::common::IndexReader> createIndexReader();
+
+  // Parses index lookup conditions to extract column indices and constant
+  // values.
+  void parseIndexLookupConditions();
+
+  // Builds IndexBounds from the request row vector.
+  serializer::IndexBounds buildRequestIndexBounds(const RowVectorPtr& request);
+
+  const std::shared_ptr<const HiveTableHandle> tableHandle_;
+  const ConnectorQueryCtx* connectorQueryCtx_;
+  const std::shared_ptr<const FileConfig> fileConfig_;
+  FileHandleFactory* const fileHandleFactory_;
+  const RowTypePtr requestType_;
+  const RowTypePtr outputType_;
+  const std::shared_ptr<io::IoStatistics> ioStatistics_;
+  const std::shared_ptr<IoStats> ioStats_;
+  folly::Executor* const ioExecutor_;
+  memory::MemoryPool* const pool_;
+  const std::shared_ptr<common::ScanSpec> scanSpec_;
+  // Index lookup conditions (including equal conditions converted from lookup
+  // keys).
+  const std::vector<core::IndexLookupConditionPtr> indexLookupConditions_;
+  // Maximum output rows per index request batch. 0 means no limit.
+  const uint32_t maxRowsPerRequest_;
+
+  // Split must be initialized before fileReader_/indexReader_ since they
+  // depend on it during construction.
+  std::shared_ptr<const HiveConnectorSplit> hiveSplit_;
+  const std::unique_ptr<dwio::common::Reader> fileReader_;
+  const std::unique_ptr<dwio::common::IndexReader> indexReader_;
+
+  // Request column indices for each index lookup condition (for probe side
+  // columns). For EqualIndexLookupCondition, stores {valueIndex}. For
+  // BetweenIndexLookupCondition, stores {lowerIndex, upperIndex}.
+  std::vector<std::vector<column_index_t>> requestColumnIndices_;
+
+  // For BetweenIndexLookupCondition with constant bounds, stores the constant
+  // values directly. The outer vector is indexed by index lookup condition
+  // index. The inner vector has size 2 for between conditions (lower, upper).
+  // If a bound is a constant, the corresponding optional contains the value;
+  // otherwise it's std::nullopt and the value should be decoded from request.
+  std::vector<std::vector<std::optional<variant>>> constantBoundValues_;
+
+  // Cached row type for index bounds (column names and types from index lookup
+  // conditions).
+  RowTypePtr indexBoundType_;
+
+  // Reusable column vectors for building index bounds.
+  std::vector<VectorPtr> lowerBoundColumns_;
+  std::vector<VectorPtr> upperBoundColumns_;
+
+  uint64_t numIndexOutputRows_{0};
+};
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/FileProperties.h b/velox/connectors/hive/FileProperties.h
index d3ed9e3cbd6..67c409a04bb 100644
--- a/velox/connectors/hive/FileProperties.h
+++ b/velox/connectors/hive/FileProperties.h
@@ -14,26 +14,8 @@
  * limitations under the License.
  */
 
-// A FileHandle is a File pointer plus some (optional, file-type-dependent)
-// extra information for speeding up loading columnar data. For example, when
-// we open a file we might build a hash map saying what region(s) on disk
-// correspond to a given column in a given stripe.
-//
-// The FileHandle will normally be used in conjunction with a CachedFactory
-// to speed up queries that hit the same files repeatedly; see the
-// FileHandleCache and FileHandleFactory.
-
 #pragma once
 
-#include <cstdint>
-
-namespace facebook::velox {
-
-struct FileProperties {
-  std::optional<int64_t> fileSize;
-  std::optional<int64_t> modificationTime;
-  std::optional<int64_t> readRangeHint{std::nullopt};
-  std::shared_ptr<std::string> extraFileInfo{nullptr};
-};
-
-} // namespace facebook::velox
+// Moved to velox/common/caching/FileProperties.h.
+// This header is kept for backward compatibility.
+#include "velox/common/caching/FileProperties.h"
diff --git a/velox/connectors/hive/SplitReader.cpp b/velox/connectors/hive/FileSplitReader.cpp
similarity index 54%
rename from velox/connectors/hive/SplitReader.cpp
rename to velox/connectors/hive/FileSplitReader.cpp
index 166a1f449b6..01895ead23f 100644
--- a/velox/connectors/hive/SplitReader.cpp
+++ b/velox/connectors/hive/FileSplitReader.cpp
@@ -14,152 +14,178 @@
  * limitations under the License.
  */
 
-#include "velox/connectors/hive/SplitReader.h"
+#include "velox/connectors/hive/FileSplitReader.h"
 
 #include "velox/common/caching/CacheTTLController.h"
-#include "velox/connectors/hive/HiveConfig.h"
-#include "velox/connectors/hive/HiveConnectorSplit.h"
-#include "velox/connectors/hive/HiveConnectorUtil.h"
-#include "velox/connectors/hive/TableHandle.h"
-#include "velox/connectors/hive/iceberg/IcebergSplitReader.h"
+#include "velox/connectors/hive/BufferedInputBuilder.h"
+#include "velox/connectors/hive/FileConfig.h"
+#include "velox/connectors/hive/FileConnectorSplit.h"
+#include "velox/connectors/hive/FileConnectorUtil.h"
 #include "velox/dwio/common/ReaderFactory.h"
+#include "velox/type/DecimalUtil.h"
 
 namespace facebook::velox::connector::hive {
 namespace {
 
 template <TypeKind kind>
-VectorPtr newConstantFromString(
+VectorPtr newConstantFromStringImpl(
     const TypePtr& type,
     const std::optional<std::string>& value,
-    vector_size_t size,
     velox::memory::MemoryPool* pool,
-    const std::string& sessionTimezone,
-    bool asLocalTime,
-    bool isPartitionDateDaysSinceEpoch = false) {
+    bool isLocalTimestamp,
+    bool isDaysSinceEpoch) {
   using T = typename TypeTraits<kind>::NativeType;
   if (!value.has_value()) {
-    return std::make_shared<ConstantVector<T>>(pool, size, true, type, T());
+    return std::make_shared<ConstantVector<T>>(pool, 1, true, type, T());
   }
 
   if (type->isDate()) {
     int32_t days = 0;
     // For Iceberg, the date partition values are already in daysSinceEpoch
     // form.
-    if (isPartitionDateDaysSinceEpoch) {
+    if (isDaysSinceEpoch) {
       days = folly::to<int32_t>(value.value());
     } else {
-      days = DATE()->toDays(static_cast<folly::StringPiece>(value.value()));
+      days = DATE()->toDays(value.value());
     }
     return std::make_shared<ConstantVector<int32_t>>(
-        pool, size, false, type, std::move(days));
+        pool, 1, false, type, std::move(days));
   }
 
+  if constexpr (std::is_same_v<T, int64_t> || std::is_same_v<T, int128_t>) {
+    if (type->isDecimal()) {
+      T decimalValue = 0;
+      auto [precision, scale] = getDecimalPrecisionScale(*type);
+      auto status = DecimalUtil::castFromString(
+          StringView(value.value()), precision, scale, decimalValue);
+      if (!status.ok()) {
+        VELOX_USER_FAIL(status.message());
+      }
+      return std::make_shared<ConstantVector<T>>(
+          pool, 1, false, type, std::move(decimalValue));
+    }
+  }
   if constexpr (std::is_same_v<T, StringView>) {
     return std::make_shared<ConstantVector<StringView>>(
-        pool, size, false, type, StringView(value.value()));
+        pool, 1, false, type, StringView(value.value()));
   } else {
     auto copy = velox::util::Converter<kind>::tryCast(value.value())
                     .thenOrThrow(folly::identity, [&](const Status& status) {
                       VELOX_USER_FAIL("{}", status.message());
                     });
     if constexpr (kind == TypeKind::TIMESTAMP) {
-      if (asLocalTime) {
+      if (isLocalTimestamp) {
         copy.toGMT(Timestamp::defaultTimezone());
       }
     }
     return std::make_shared<ConstantVector<T>>(
-        pool, size, false, type, std::move(copy));
+        pool, 1, false, type, std::move(copy));
   }
 }
 } // namespace
 
-std::unique_ptr<SplitReader> SplitReader::create(
-    const std::shared_ptr<hive::HiveConnectorSplit>& hiveSplit,
-    const HiveTableHandlePtr& hiveTableHandle,
-    const std::unordered_map<std::string, HiveColumnHandlePtr>* partitionKeys,
+VectorPtr newConstantFromString(
+    const TypePtr& type,
+    const std::optional<std::string>& value,
+    velox::memory::MemoryPool* pool,
+    bool isLocalTimestamp,
+    bool isDaysSinceEpoch) {
+  return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
+      newConstantFromStringImpl,
+      type->kind(),
+      type,
+      value,
+      pool,
+      isLocalTimestamp,
+      isDaysSinceEpoch);
+}
+
+std::unique_ptr<FileSplitReader> FileSplitReader::create(
+    const std::shared_ptr<const hive::FileConnectorSplit>& fileSplit,
+    const FileTableHandlePtr& tableHandle,
+    const std::unordered_map<std::string, FileColumnHandlePtr>* partitionKeys,
     const ConnectorQueryCtx* connectorQueryCtx,
-    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const std::shared_ptr<const FileConfig>& fileConfig,
     const RowTypePtr& readerOutputType,
-    const std::shared_ptr<io::IoStatistics>& ioStats,
-    const std::shared_ptr<filesystems::File::IoStats>& fsStats,
+    const std::shared_ptr<io::IoStatistics>& dataIoStats,
+    const std::shared_ptr<io::IoStatistics>& metadataIoStats,
+    const std::shared_ptr<IoStats>& ioStats,
     FileHandleFactory* fileHandleFactory,
     folly::Executor* ioExecutor,
-    const std::shared_ptr<common::ScanSpec>& scanSpec) {
-  //  Create the SplitReader based on hiveSplit->customSplitInfo["table_format"]
-  if (hiveSplit->customSplitInfo.count("table_format") > 0 &&
-      hiveSplit->customSplitInfo["table_format"] == "hive-iceberg") {
-    return std::make_unique<iceberg::IcebergSplitReader>(
-        hiveSplit,
-        hiveTableHandle,
-        partitionKeys,
-        connectorQueryCtx,
-        hiveConfig,
-        readerOutputType,
-        ioStats,
-        fsStats,
-        fileHandleFactory,
-        ioExecutor,
-        scanSpec);
-  } else {
-    return std::unique_ptr<SplitReader>(new SplitReader(
-        hiveSplit,
-        hiveTableHandle,
-        partitionKeys,
-        connectorQueryCtx,
-        hiveConfig,
-        readerOutputType,
-        ioStats,
-        fsStats,
-        fileHandleFactory,
-        ioExecutor,
-        scanSpec));
-  }
+    const std::shared_ptr<common::ScanSpec>& scanSpec,
+    const common::SubfieldFilters* subfieldFiltersForValidation) {
+  return std::unique_ptr<FileSplitReader>(new FileSplitReader(
+      fileSplit,
+      tableHandle,
+      partitionKeys,
+      connectorQueryCtx,
+      fileConfig,
+      readerOutputType,
+      dataIoStats,
+      metadataIoStats,
+      ioStats,
+      fileHandleFactory,
+      ioExecutor,
+      scanSpec,
+      subfieldFiltersForValidation));
 }
 
-SplitReader::SplitReader(
-    const std::shared_ptr<const hive::HiveConnectorSplit>& hiveSplit,
-    const HiveTableHandlePtr& hiveTableHandle,
-    const std::unordered_map<std::string, HiveColumnHandlePtr>* partitionKeys,
+FileSplitReader::FileSplitReader(
+    const std::shared_ptr<const hive::FileConnectorSplit>& fileSplit,
+    const FileTableHandlePtr& tableHandle,
+    const std::unordered_map<std::string, FileColumnHandlePtr>* partitionKeys,
     const ConnectorQueryCtx* connectorQueryCtx,
-    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const std::shared_ptr<const FileConfig>& fileConfig,
     const RowTypePtr& readerOutputType,
-    const std::shared_ptr<io::IoStatistics>& ioStats,
-    const std::shared_ptr<filesystems::File::IoStats>& fsStats,
+    const std::shared_ptr<io::IoStatistics>& dataIoStats,
+    const std::shared_ptr<io::IoStatistics>& metadataIoStats,
+    const std::shared_ptr<IoStats>& ioStats,
     FileHandleFactory* fileHandleFactory,
     folly::Executor* ioExecutor,
-    const std::shared_ptr<common::ScanSpec>& scanSpec)
-    : hiveSplit_(hiveSplit),
-      hiveTableHandle_(hiveTableHandle),
+    const std::shared_ptr<common::ScanSpec>& scanSpec,
+    const common::SubfieldFilters* subfieldFiltersForValidation)
+    : tableHandle_(tableHandle),
       partitionKeys_(partitionKeys),
-      connectorQueryCtx_(connectorQueryCtx),
-      hiveConfig_(hiveConfig),
-      readerOutputType_(readerOutputType),
+      fileConfig_(fileConfig),
+      dataIoStats_(dataIoStats),
+      metadataIoStats_(metadataIoStats),
       ioStats_(ioStats),
-      fsStats_(fsStats),
       fileHandleFactory_(fileHandleFactory),
       ioExecutor_(ioExecutor),
       pool_(connectorQueryCtx->memoryPool()),
       scanSpec_(scanSpec),
+      subfieldFiltersForValidation_(subfieldFiltersForValidation),
+      fileSplit_(fileSplit),
+      connectorQueryCtx_(connectorQueryCtx),
+      readerOutputType_(readerOutputType),
       baseReaderOpts_(connectorQueryCtx->memoryPool()),
-      emptySplit_(false) {}
+      emptySplit_(false) {
+  baseReaderOpts_.setDataIoStats(dataIoStats_);
+  baseReaderOpts_.setMetadataIoStats(metadataIoStats_);
+}
 
-void SplitReader::configureReaderOptions(
+void FileSplitReader::configureReaderOptions(
     std::shared_ptr<velox::random::RandomSkipTracker> randomSkip) {
+  configureBaseReaderOptions();
+  baseReaderOpts_.setRandomSkip(std::move(randomSkip));
+  baseReaderOpts_.setScanSpec(scanSpec_);
+  baseReaderOpts_.setFileFormat(fileSplit_->fileFormat);
+}
+
+void FileSplitReader::configureBaseReaderOptions() {
   hive::configureReaderOptions(
-      hiveConfig_,
+      fileConfig_,
       connectorQueryCtx_,
-      hiveTableHandle_,
-      hiveSplit_,
+      tableHandle_,
+      fileSplit_,
       baseReaderOpts_);
-  baseReaderOpts_.setRandomSkip(std::move(randomSkip));
-  baseReaderOpts_.setScanSpec(scanSpec_);
-  baseReaderOpts_.setFileFormat(hiveSplit_->fileFormat);
 }
 
-void SplitReader::prepareSplit(
+void FileSplitReader::prepareSplit(
     std::shared_ptr<common::MetadataFilter> metadataFilter,
-    dwio::common::RuntimeStatistics& runtimeStats) {
-  createReader();
+    dwio::common::RuntimeStatistics& runtimeStats,
+    const folly::F14FastMap<std::string, std::string>& fileReadOps) {
+  createReader(fileReadOps);
   if (emptySplit_) {
     return;
   }
@@ -170,77 +196,33 @@ void SplitReader::prepareSplit(
     return;
   }
 
-  createRowReader(std::move(metadataFilter), std::move(rowType));
+  createRowReader(std::move(metadataFilter), std::move(rowType), std::nullopt);
 }
 
-void SplitReader::setBucketConversion(
-    std::vector<column_index_t> bucketChannels) {
-  bucketChannels_ = {bucketChannels.begin(), bucketChannels.end()};
-  partitionFunction_ = std::make_unique<HivePartitionFunction>(
-      hiveSplit_->bucketConversion->tableBucketCount,
-      std::move(bucketChannels));
-}
-
-std::vector<BaseVector::CopyRange> SplitReader::bucketConversionRows(
-    const RowVector& vector) {
-  partitions_.clear();
-  partitionFunction_->partition(vector, partitions_);
-  const auto bucketToKeep = *hiveSplit_->tableBucketNumber;
-  const auto partitionBucketCount =
-      hiveSplit_->bucketConversion->partitionBucketCount;
-  std::vector<BaseVector::CopyRange> ranges;
-  for (vector_size_t i = 0; i < vector.size(); ++i) {
-    VELOX_CHECK_EQ((partitions_[i] - bucketToKeep) % partitionBucketCount, 0);
-    if (partitions_[i] == bucketToKeep) {
-      auto& r = ranges.emplace_back();
-      r.sourceIndex = i;
-      r.targetIndex = ranges.size() - 1;
-      r.count = 1;
-    }
-  }
-  return ranges;
-}
-
-void SplitReader::applyBucketConversion(
-    VectorPtr& output,
-    const std::vector<BaseVector::CopyRange>& ranges) {
-  auto filtered =
-      BaseVector::create(output->type(), ranges.size(), output->pool());
-  filtered->copyRanges(output.get(), ranges);
-  output = std::move(filtered);
-}
-
-uint64_t SplitReader::next(uint64_t size, VectorPtr& output) {
-  uint64_t numScanned;
+uint64_t FileSplitReader::next(uint64_t size, VectorPtr& output) {
   if (!baseReaderOpts_.randomSkip()) {
-    numScanned = baseRowReader_->next(size, output);
-  } else {
-    dwio::common::Mutation mutation;
-    mutation.randomSkip = baseReaderOpts_.randomSkip().get();
-    numScanned = baseRowReader_->next(size, output, &mutation);
-  }
-  if (numScanned > 0 && output->size() > 0 && partitionFunction_) {
-    applyBucketConversion(
-        output, bucketConversionRows(*output->asChecked<RowVector>()));
+    return baseRowReader_->next(size, output);
   }
-  return numScanned;
+  dwio::common::Mutation mutation;
+  mutation.randomSkip = baseReaderOpts_.randomSkip().get();
+  return baseRowReader_->next(size, output, &mutation);
 }
 
-void SplitReader::resetFilterCaches() {
+void FileSplitReader::resetFilterCaches() {
   if (baseRowReader_) {
     baseRowReader_->resetFilterCaches();
   }
 }
 
-bool SplitReader::emptySplit() const {
+bool FileSplitReader::emptySplit() const {
   return emptySplit_;
 }
 
-void SplitReader::resetSplit() {
-  hiveSplit_.reset();
+void FileSplitReader::resetSplit() {
+  fileSplit_.reset();
 }
 
-int64_t SplitReader::estimatedRowSize() const {
+int64_t FileSplitReader::estimatedRowSize() const {
   if (!baseRowReader_) {
     return DataSource::kUnknownRowSize;
   }
@@ -249,31 +231,31 @@ int64_t SplitReader::estimatedRowSize() const {
   return size.value_or(DataSource::kUnknownRowSize);
 }
 
-void SplitReader::updateRuntimeStats(
+void FileSplitReader::updateRuntimeStats(
     dwio::common::RuntimeStatistics& stats) const {
   if (baseRowReader_) {
     baseRowReader_->updateRuntimeStats(stats);
   }
 }
 
-bool SplitReader::allPrefetchIssued() const {
+bool FileSplitReader::allPrefetchIssued() const {
   return baseRowReader_ && baseRowReader_->allPrefetchIssued();
 }
 
-void SplitReader::setConnectorQueryCtx(
+void FileSplitReader::setConnectorQueryCtx(
     const ConnectorQueryCtx* connectorQueryCtx) {
   connectorQueryCtx_ = connectorQueryCtx;
 }
 
-std::string SplitReader::toString() const {
+std::string FileSplitReader::toString() const {
   std::string partitionKeys;
   std::for_each(
       partitionKeys_->begin(), partitionKeys_->end(), [&](const auto& column) {
         partitionKeys += " " + column.second->toString();
       });
   return fmt::format(
-      "SplitReader: hiveSplit_{} scanSpec_{} readerOutputType_{} partitionKeys_{} reader{} rowReader{}",
-      hiveSplit_->toString(),
+      "FileSplitReader: fileSplit_{} scanSpec_{} readerOutputType_{} partitionKeys_{} reader{} rowReader{}",
+      fileSplit_->toString(),
       scanSpec_->toString(),
       readerOutputType_->toString(),
       partitionKeys,
@@ -281,23 +263,32 @@ std::string SplitReader::toString() const {
       static_cast<const void*>(baseRowReader_.get()));
 }
 
-void SplitReader::createReader() {
+void FileSplitReader::createReader(
+    const folly::F14FastMap<std::string, std::string>& fileReadOps) {
   VELOX_CHECK_NE(
       baseReaderOpts_.fileFormat(), dwio::common::FileFormat::UNKNOWN);
 
   FileHandleCachedPtr fileHandleCachePtr;
   FileHandleKey fileHandleKey{
-      .filename = hiveSplit_->filePath,
+      .filename = fileSplit_->filePath,
       .tokenProvider = connectorQueryCtx_->fsTokenProvider()};
+
+  auto fileProperties = fileSplit_->properties.value_or(FileProperties{});
+  fileProperties.fileReadOps = fileReadOps;
+  if (!tableHandle_->dbName().empty()) {
+    fileProperties.fileReadOps[kDbNameKey] = tableHandle_->dbName();
+  }
+  if (!tableHandle_->name().empty()) {
+    fileProperties.fileReadOps[kTableNameKey] = tableHandle_->name();
+  }
+
   try {
     fileHandleCachePtr = fileHandleFactory_->generate(
-        fileHandleKey,
-        hiveSplit_->properties.has_value() ? &*hiveSplit_->properties : nullptr,
-        fsStats_ ? fsStats_.get() : nullptr);
+        fileHandleKey, &fileProperties, ioStats_ ? ioStats_.get() : nullptr);
     VELOX_CHECK_NOT_NULL(fileHandleCachePtr.get());
   } catch (const VeloxRuntimeError& e) {
     if (e.errorCode() == error_code::kFileNotFound &&
-        hiveConfig_->ignoreMissingFiles(
+        fileConfig_->ignoreMissingFiles(
             connectorQueryCtx_->sessionProperties())) {
       emptySplit_ = true;
       return;
@@ -312,13 +303,14 @@ void SplitReader::createReader() {
   if (auto* cacheTTLController = cache::CacheTTLController::getInstance()) {
     cacheTTLController->addOpenFileInfo(fileHandleCachePtr->uuid.id());
   }
-  auto baseFileInput = createBufferedInput(
+  auto baseFileInput = BufferedInputBuilder::getInstance()->create(
       *fileHandleCachePtr,
       baseReaderOpts_,
       connectorQueryCtx_,
+      dataIoStats_,
       ioStats_,
-      fsStats_,
-      ioExecutor_);
+      ioExecutor_,
+      fileReadOps);
 
   baseReader_ = dwio::common::getReaderFactory(baseReaderOpts_.fileFormat())
                     ->createReader(std::move(baseFileInput), baseReaderOpts_);
@@ -327,32 +319,32 @@ void SplitReader::createReader() {
   }
 }
 
-RowTypePtr SplitReader::getAdaptedRowType() const {
+RowTypePtr FileSplitReader::getAdaptedRowType() const {
   auto& fileType = baseReader_->rowType();
   auto columnTypes = adaptColumns(fileType, baseReaderOpts_.fileSchema());
   auto columnNames = fileType->names();
   return ROW(std::move(columnNames), std::move(columnTypes));
 }
 
-bool SplitReader::filterOnStats(
+bool FileSplitReader::filterOnStats(
     dwio::common::RuntimeStatistics& runtimeStats) const {
   if (testFilters(
           scanSpec_.get(),
           baseReader_.get(),
-          hiveSplit_->filePath,
-          hiveSplit_->partitionKeys,
+          fileSplit_->filePath,
+          fileSplit_->partitionKeys,
           *partitionKeys_,
-          hiveConfig_->readTimestampPartitionValueAsLocalTime(
+          fileConfig_->readTimestampPartitionValueAsLocalTime(
               connectorQueryCtx_->sessionProperties()))) {
     ++runtimeStats.processedSplits;
     return true;
   }
   ++runtimeStats.skippedSplits;
-  runtimeStats.skippedSplitBytes += hiveSplit_->length;
+  runtimeStats.skippedSplitBytes += fileSplit_->length;
   return false;
 }
 
-bool SplitReader::checkIfSplitIsEmpty(
+bool FileSplitReader::checkIfSplitIsEmpty(
     dwio::common::RuntimeStatistics& runtimeStats) {
   // emptySplit_ may already be set if the data file is not found. In this case
   // we don't need to test further.
@@ -366,23 +358,42 @@ bool SplitReader::checkIfSplitIsEmpty(
   return emptySplit_;
 }
 
-void SplitReader::createRowReader(
+void FileSplitReader::createRowReader(
     std::shared_ptr<common::MetadataFilter> metadataFilter,
-    RowTypePtr rowType) {
+    RowTypePtr rowType,
+    std::optional<bool> rowSizeTrackingEnabled) {
   VELOX_CHECK_NULL(baseRowReader_);
-  configureRowReaderOptions(
-      hiveTableHandle_->tableParameters(),
+  configureBaseRowReaderOptions(std::move(metadataFilter), std::move(rowType));
+  baseRowReaderOpts_.setStringDecoderZeroCopy(
+      fileConfig_->nimbleStringDecoderZeroCopy(
+          connectorQueryCtx_->sessionProperties()));
+  baseRowReaderOpts_.setNimblePreserveDictionaryEncoding(
+      fileConfig_->nimblePreserveDictionaryEncoding(
+          connectorQueryCtx_->sessionProperties()));
+  baseRowReaderOpts_.setTrackRowSize(
+      rowSizeTrackingEnabled.has_value()
+          ? *rowSizeTrackingEnabled
+          : connectorQueryCtx_->rowSizeTrackingMode() !=
+              core::QueryConfig::RowSizeTrackingMode::DISABLED);
+  baseRowReader_ = baseReader_->createRowReader(baseRowReaderOpts_);
+}
+
+void FileSplitReader::configureBaseRowReaderOptions(
+    std::shared_ptr<common::MetadataFilter> metadataFilter,
+    RowTypePtr rowType) {
+  hive::configureRowReaderOptions(
+      tableHandle_->tableParameters(),
       scanSpec_,
       std::move(metadataFilter),
       std::move(rowType),
-      hiveSplit_,
-      hiveConfig_,
+      fileSplit_,
+      fileConfig_,
       connectorQueryCtx_->sessionProperties(),
+      ioExecutor_,
       baseRowReaderOpts_);
-  baseRowReader_ = baseReader_->createRowReader(baseRowReaderOpts_);
 }
 
-std::vector<TypePtr> SplitReader::adaptColumns(
+std::vector<TypePtr> FileSplitReader::adaptColumns(
     const RowTypePtr& fileType,
     const std::shared_ptr<const velox::RowType>& tableSchema) const {
   // Keep track of schema types for columns in file, used by ColumnSelector.
@@ -393,34 +404,20 @@ std::vector<TypePtr> SplitReader::adaptColumns(
     auto* childSpec = childrenSpecs[i].get();
     const std::string& fieldName = childSpec->fieldName();
 
-    if (auto it = hiveSplit_->partitionKeys.find(fieldName);
-        it != hiveSplit_->partitionKeys.end()) {
-      setPartitionValue(childSpec, fieldName, it->second);
-    } else if (auto iter = hiveSplit_->infoColumns.find(fieldName);
-               iter != hiveSplit_->infoColumns.end()) {
-      auto infoColumnType =
-          readerOutputType_->childAt(readerOutputType_->getChildIdx(fieldName));
-      auto constant = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
-          newConstantFromString,
-          infoColumnType->kind(),
-          infoColumnType,
-          iter->second,
-          1,
-          connectorQueryCtx_->memoryPool(),
-          connectorQueryCtx_->sessionTimezone(),
-          hiveConfig_->readTimestampPartitionValueAsLocalTime(
-              connectorQueryCtx_->sessionProperties()));
-      childSpec->setConstantValue(constant);
+    if (auto partitionIt = fileSplit_->partitionKeys.find(fieldName);
+        partitionIt != fileSplit_->partitionKeys.end()) {
+      setPartitionValue(childSpec, fieldName, partitionIt->second);
     } else if (
         childSpec->columnType() == common::ScanSpec::ColumnType::kRegular) {
       auto fileTypeIdx = fileType->getChildIdxIfExists(fieldName);
       if (!fileTypeIdx.has_value()) {
         // Column is missing. Most likely due to schema evolution.
         VELOX_CHECK(tableSchema, "Unable to resolve column '{}'", fieldName);
-        childSpec->setConstantValue(BaseVector::createNullConstant(
-            tableSchema->findChild(fieldName),
-            1,
-            connectorQueryCtx_->memoryPool()));
+        childSpec->setConstantValue(
+            BaseVector::createNullConstant(
+                tableSchema->findChild(fieldName),
+                1,
+                connectorQueryCtx_->memoryPool()));
       } else {
         // Column no longer missing, reset constant value set on the spec.
         childSpec->setConstantValue(nullptr);
@@ -446,25 +443,21 @@ std::vector<TypePtr> SplitReader::adaptColumns(
   return columnTypes;
 }
 
-void SplitReader::setPartitionValue(
+void FileSplitReader::setPartitionValue(
     common::ScanSpec* spec,
     const std::string& partitionKey,
     const std::optional<std::string>& value) const {
-  auto it = partitionKeys_->find(partitionKey);
+  const auto it = partitionKeys_->find(partitionKey);
   VELOX_CHECK(
       it != partitionKeys_->end(),
       "ColumnHandle is missing for partition key {}",
       partitionKey);
-  auto type = it->second->dataType();
-  auto constant = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
-      newConstantFromString,
-      type->kind(),
+  const auto type = it->second->dataType();
+  const auto constant = newConstantFromString(
       type,
       value,
-      1,
       connectorQueryCtx_->memoryPool(),
-      connectorQueryCtx_->sessionTimezone(),
-      hiveConfig_->readTimestampPartitionValueAsLocalTime(
+      fileConfig_->readTimestampPartitionValueAsLocalTime(
           connectorQueryCtx_->sessionProperties()),
       it->second->isPartitionDateValueDaysSinceEpoch());
   spec->setConstantValue(constant);
diff --git a/velox/connectors/hive/FileSplitReader.h b/velox/connectors/hive/FileSplitReader.h
new file mode 100644
index 00000000000..04e59016218
--- /dev/null
+++ b/velox/connectors/hive/FileSplitReader.h
@@ -0,0 +1,245 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/base/RandomUtil.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/connectors/hive/FileColumnHandle.h"
+#include "velox/connectors/hive/FileConnectorSplit.h"
+#include "velox/connectors/hive/FileHandle.h"
+#include "velox/connectors/hive/FileTableHandle.h"
+#include "velox/dwio/common/Options.h"
+#include "velox/dwio/common/Reader.h"
+
+namespace facebook::velox {
+class BaseVector;
+using VectorPtr = std::shared_ptr<BaseVector>;
+} // namespace facebook::velox
+
+namespace facebook::velox::common {
+class MetadataFilter;
+class ScanSpec;
+} // namespace facebook::velox::common
+
+namespace facebook::velox::connector {
+class ConnectorQueryCtx;
+} // namespace facebook::velox::connector
+
+namespace facebook::velox::dwio::common {
+struct RuntimeStatistics;
+} // namespace facebook::velox::dwio::common
+
+namespace facebook::velox::memory {
+class MemoryPool;
+}
+
+namespace facebook::velox::connector::hive {
+
+/// Creates a constant vector of size 1 from a string representation of a value.
+///
+/// Used to materialize partition column values and info columns (e.g., $path,
+/// $file_size) when reading Hive and Iceberg tables. Partition values are
+/// stored as strings in HiveConnectorSplit::partitionKeys and need to be
+/// converted to their appropriate types.
+///
+/// @param type The target Velox type for the constant vector. Supports all
+/// scalar types including primitives, dates, timestamps.
+/// @param value The string representation of the value to convert, formatted
+/// the same way as CAST(x as VARCHAR). Date values must be formatted using ISO
+/// 8601 as YYYY-MM-DD. If nullopt, creates a null constant vector.
+/// @param pool Memory pool for allocating the constant vector.
+/// @param isLocalTimestamp If true and type is TIMESTAMP, interprets the string
+/// value as local time and converts it to GMT. If false, treats the value
+/// as already in GMT.
+/// @param isDaysSinceEpoch If true and type is DATE, treats the string value as
+/// an integer representing days since epoch (used by Iceberg). If false, parses
+/// the string as a date string in ISO 8601 format (used by Hive).
+///
+/// @return A constant vector of size 1 containing the converted value, or a
+/// null constant if value is nullopt.
+/// @throws VeloxUserError if the string cannot be converted to the target type.
+VectorPtr newConstantFromString(
+    const TypePtr& type,
+    const std::optional<std::string>& value,
+    velox::memory::MemoryPool* pool,
+    bool isLocalTimestamp,
+    bool isDaysSinceEpoch);
+
+class FileConfig;
+
+class FileSplitReader {
+ public:
+  static std::unique_ptr<FileSplitReader> create(
+      const std::shared_ptr<const hive::FileConnectorSplit>& fileSplit,
+      const FileTableHandlePtr& tableHandle,
+      const std::unordered_map<std::string, FileColumnHandlePtr>* partitionKeys,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      const std::shared_ptr<const FileConfig>& fileConfig,
+      const RowTypePtr& readerOutputType,
+      const std::shared_ptr<io::IoStatistics>& dataIoStats,
+      const std::shared_ptr<io::IoStatistics>& metadataIoStats,
+      const std::shared_ptr<IoStats>& ioStats,
+      FileHandleFactory* fileHandleFactory,
+      folly::Executor* ioExecutor,
+      const std::shared_ptr<common::ScanSpec>& scanSpec,
+      const common::SubfieldFilters* subfieldFiltersForValidation = nullptr);
+
+  virtual ~FileSplitReader() = default;
+
+  void configureReaderOptions(
+      std::shared_ptr<random::RandomSkipTracker> randomSkip);
+
+  /// This function is used by different table formats like Iceberg and Hudi to
+  /// do additional preparations before reading the split, e.g. Open delete
+  /// files or log files, and add column adapatations for metadata columns. It
+  /// would be called only once per incoming split
+  virtual void prepareSplit(
+      std::shared_ptr<common::MetadataFilter> metadataFilter,
+      dwio::common::RuntimeStatistics& runtimeStats,
+      const folly::F14FastMap<std::string, std::string>& fileReadOps = {});
+
+  virtual uint64_t next(uint64_t size, VectorPtr& output);
+
+  void resetFilterCaches();
+
+  bool emptySplit() const;
+
+  void resetSplit();
+
+  int64_t estimatedRowSize() const;
+
+  void updateRuntimeStats(dwio::common::RuntimeStatistics& stats) const;
+
+  bool allPrefetchIssued() const;
+
+  void setConnectorQueryCtx(const ConnectorQueryCtx* connectorQueryCtx);
+
+  const RowTypePtr& readerOutputType() const {
+    return readerOutputType_;
+  }
+
+  std::string toString() const;
+
+ protected:
+  FileSplitReader(
+      const std::shared_ptr<const hive::FileConnectorSplit>& fileSplit,
+      const FileTableHandlePtr& tableHandle,
+      const std::unordered_map<std::string, FileColumnHandlePtr>* partitionKeys,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      const std::shared_ptr<const FileConfig>& fileConfig,
+      const RowTypePtr& readerOutputType,
+      const std::shared_ptr<io::IoStatistics>& dataIoStats,
+      const std::shared_ptr<io::IoStatistics>& metadataIoStats,
+      const std::shared_ptr<IoStats>& ioStats,
+      FileHandleFactory* fileHandleFactory,
+      folly::Executor* executor,
+      const std::shared_ptr<common::ScanSpec>& scanSpec,
+      const common::SubfieldFilters* subfieldFiltersForValidation = nullptr);
+
+  /// Create the dwio::common::Reader object baseReader_
+  /// read the data file's metadata and schema
+  void createReader(
+      const folly::F14FastMap<std::string, std::string>& fileReadOps = {});
+
+  // Adjust the scan spec according to the current split, then return the
+  // adapted row type.
+  RowTypePtr getAdaptedRowType() const;
+
+  // Check if the filters pass on the column statistics.  When delta update is
+  // present, the corresonding filter should be disabled before calling this
+  // function.
+  bool filterOnStats(dwio::common::RuntimeStatistics& runtimeStats) const;
+
+  /// Check if the fileSplit_ is empty. The split is considered empty when
+  ///   1) The data file is missing but the user chooses to ignore it
+  ///   2) The file does not contain any rows
+  ///   3) The data in the file does not pass the filters. The test is based on
+  ///      the file metadata and partition key values
+  /// This function needs to be called after baseReader_ is created.
+  bool checkIfSplitIsEmpty(dwio::common::RuntimeStatistics& runtimeStats);
+
+  /// Create the dwio::common::RowReader object baseRowReader_, which owns the
+  /// ColumnReaders that will be used to read the data
+  void createRowReader(
+      std::shared_ptr<common::MetadataFilter> metadataFilter,
+      RowTypePtr rowType,
+      std::optional<bool> rowSizeTrackingEnabled);
+
+  /// Sets a constant partition value on the scanSpec for a partition column.
+  /// Converts the partition key string value to the appropriate type and sets
+  /// it as a constant value in the scanSpec, so the column will be filled
+  /// with this constant value.
+  ///
+  /// @param spec The scan spec to set the constant value on.
+  /// @param partitionKey The name of the partition column.
+  void setPartitionValue(
+      common::ScanSpec* spec,
+      const std::string& partitionKey,
+      const std::optional<std::string>& value) const;
+
+  /// Virtual hook called by configureReaderOptions() to set format-specific
+  /// reader options on baseReaderOpts_. The base implementation calls the
+  /// generic configureReaderOptions() from FileConnectorUtil. Subclasses
+  /// (e.g., HiveSplitReader) override to call the Hive-specific version
+  /// that also applies serde options.
+  virtual void configureBaseReaderOptions();
+
+  /// Virtual hook called by createRowReader() to set format-specific row
+  /// reader options on baseRowReaderOpts_. The base implementation calls the
+  /// generic configureRowReaderOptions() from FileConnectorUtil. Subclasses
+  /// (e.g., HiveSplitReader) override to call the Hive-specific version
+  /// that also applies serde parameters.
+  virtual void configureBaseRowReaderOptions(
+      std::shared_ptr<common::MetadataFilter> metadataFilter,
+      RowTypePtr rowType);
+
+ private:
+  /// Different table formats may have different meatadata columns.
+  /// This function will be used to update the scanSpec for these columns.
+  virtual std::vector<TypePtr> adaptColumns(
+      const RowTypePtr& fileType,
+      const RowTypePtr& tableSchema) const;
+
+ protected:
+  const FileTableHandlePtr tableHandle_;
+  const std::unordered_map<std::string, FileColumnHandlePtr>* const
+      partitionKeys_;
+  const std::shared_ptr<const FileConfig> fileConfig_;
+  const std::shared_ptr<io::IoStatistics> dataIoStats_;
+  const std::shared_ptr<io::IoStatistics> metadataIoStats_;
+  const std::shared_ptr<IoStats> ioStats_;
+  FileHandleFactory* const fileHandleFactory_;
+  folly::Executor* const ioExecutor_;
+  memory::MemoryPool* const pool_;
+  const std::shared_ptr<common::ScanSpec> scanSpec_;
+  // Subfield filters from HiveDataSource, includes both original
+  // subfieldFilters and filters extracted from remainingFilter. Used by
+  // subclasses (e.g., HiveSplitReader) for synthesized column filter
+  // validation.
+  const common::SubfieldFilters* const subfieldFiltersForValidation_;
+
+  std::shared_ptr<const FileConnectorSplit> fileSplit_;
+  const ConnectorQueryCtx* connectorQueryCtx_;
+  RowTypePtr readerOutputType_;
+  std::unique_ptr<dwio::common::Reader> baseReader_;
+  std::unique_ptr<dwio::common::RowReader> baseRowReader_;
+  dwio::common::ReaderOptions baseReaderOpts_;
+  dwio::common::RowReaderOptions baseRowReaderOpts_;
+  bool emptySplit_;
+};
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/FileTableHandle.h b/velox/connectors/hive/FileTableHandle.h
new file mode 100644
index 00000000000..fb5e1ac656b
--- /dev/null
+++ b/velox/connectors/hive/FileTableHandle.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/connectors/Connector.h"
+#include "velox/connectors/hive/FileColumnHandle.h"
+#include "velox/core/ITypedExpr.h"
+#include "velox/type/Filter.h"
+#include "velox/type/Subfield.h"
+
+namespace facebook::velox::connector::hive {
+
+/// Base class for table handles in file-based connectors.
+///
+/// Define the common interface for table-level metadata needed by
+/// FileDataSource and FileSplitReader. Connector-specific table handles
+/// (HiveTableHandle, etc.) extend this class.
+class FileTableHandle : public ConnectorTableHandle {
+ public:
+  using ConnectorTableHandle::ConnectorTableHandle;
+
+  /// Single-field filters that can be applied efficiently during file reading.
+  virtual const common::SubfieldFilters& subfieldFilters() const = 0;
+
+  /// Remaining filter expression that cannot be converted into subfield
+  /// filters. Usually less efficient but supports arbitrary boolean
+  /// expressions.
+  virtual const core::TypedExprPtr& remainingFilter() const = 0;
+
+  /// Sampling rate between 0 and 1 (excluding 0). 0.1 means 10% sampling.
+  /// 1.0 means no sampling.
+  virtual double sampleRate() const = 0;
+
+  /// Subset of schema stored in data files (non-partitioning columns).
+  /// Needed for reading TEXTFILE, handling schema evolution, etc.
+  virtual const RowTypePtr& dataColumns() const = 0;
+
+  /// Extra parameters passed down to the file format reader layer.
+  virtual const std::unordered_map<std::string, std::string>& tableParameters()
+      const = 0;
+
+  /// Extra columns used in filters but not in the output. Returns column
+  /// handles as FileColumnHandlePtr for use in the generic scan pipeline.
+  virtual std::vector<FileColumnHandlePtr> filterColumnHandles() const = 0;
+
+  /// Database or namespace name for this table.
+  virtual const std::string& dbName() const = 0;
+};
+
+using FileTableHandlePtr = std::shared_ptr<const FileTableHandle>;
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HiveConfig.cpp b/velox/connectors/hive/HiveConfig.cpp
index 3463ec767c6..b05ffa1281d 100644
--- a/velox/connectors/hive/HiveConfig.cpp
+++ b/velox/connectors/hive/HiveConfig.cpp
@@ -15,10 +15,9 @@
  */
 
 #include "velox/connectors/hive/HiveConfig.h"
-#include "velox/common/config/Config.h"
-#include "velox/core/QueryConfig.h"
 
 #include <boost/algorithm/string.hpp>
+#include "velox/common/config/Config.h"
 
 namespace facebook::velox::connector::hive {
 
@@ -39,6 +38,34 @@ stringToInsertExistingPartitionsBehavior(const std::string& strValue) {
 
 } // namespace
 
+const std::vector<config::ConfigProperty>& HiveConfig::registeredProperties() {
+  static const std::vector<config::ConfigProperty> kProperties = [] {
+    // Start with FileConfig properties.
+    auto properties = FileConfig::registeredProperties();
+#define VELOX_HIVE_CONFIG_REGISTER(constName) \
+  config::registerConfigProperty<HiveConfig::constName##Property>(properties)
+
+    VELOX_HIVE_CONFIG_REGISTER(kInsertExistingPartitionsBehaviorSession);
+    VELOX_HIVE_CONFIG_REGISTER(kSortWriterMaxOutputBytesSession);
+    VELOX_HIVE_CONFIG_REGISTER(kMaxTargetFileSizeSession);
+    VELOX_HIVE_CONFIG_REGISTER(kMaxPartitionsPerWritersSession);
+    VELOX_HIVE_CONFIG_REGISTER(kAllowNullPartitionKeysSession);
+    VELOX_HIVE_CONFIG_REGISTER(kPartitionPathAsLowerCaseSession);
+    VELOX_HIVE_CONFIG_REGISTER(kSortWriterMaxOutputRowsSession);
+    VELOX_HIVE_CONFIG_REGISTER(kSortWriterFinishTimeSliceLimitMsSession);
+    VELOX_HIVE_CONFIG_REGISTER(kUser);
+    VELOX_HIVE_CONFIG_REGISTER(kSource);
+    VELOX_HIVE_CONFIG_REGISTER(kSchema);
+    VELOX_HIVE_CONFIG_REGISTER(kMaxBucketCountSession);
+    VELOX_HIVE_CONFIG_REGISTER(kMaxRowsPerIndexRequestSession);
+
+#undef VELOX_HIVE_CONFIG_REGISTER
+
+    return properties;
+  }();
+  return kProperties;
+}
+
 // static
 std::string HiveConfig::insertExistingPartitionsBehaviorString(
     InsertExistingPartitionsBehavior behavior) {
@@ -60,108 +87,39 @@ HiveConfig::insertExistingPartitionsBehavior(
       config_->get<std::string>(kInsertExistingPartitionsBehavior, "ERROR")));
 }
 
-uint32_t HiveConfig::maxPartitionsPerWriters(
-    const config::ConfigBase* session) const {
-  return session->get<uint32_t>(
-      kMaxPartitionsPerWritersSession,
-      config_->get<uint32_t>(kMaxPartitionsPerWriters, 128));
-}
-
-uint32_t HiveConfig::maxBucketCount(const config::ConfigBase* session) const {
-  return session->get<uint32_t>(
-      kMaxBucketCountSession, config_->get<uint32_t>(kMaxBucketCount, 100'000));
-}
-
 bool HiveConfig::immutablePartitions() const {
-  return config_->get<bool>(kImmutablePartitions, false);
+  return configValue<bool>(kImmutablePartitions, false);
 }
 
 std::string HiveConfig::gcsEndpoint() const {
-  return config_->get<std::string>(kGcsEndpoint, std::string(""));
+  return configValue<std::string>(kGcsEndpoint, std::string(""));
 }
 
 std::string HiveConfig::gcsCredentialsPath() const {
-  return config_->get<std::string>(kGcsCredentialsPath, std::string(""));
+  return configValue<std::string>(kGcsCredentialsPath, std::string(""));
 }
 
 std::optional<int> HiveConfig::gcsMaxRetryCount() const {
-  return static_cast<std::optional<int>>(config_->get<int>(kGcsMaxRetryCount));
+  if (auto val = config_->get<int>(kGcsMaxRetryCount)) {
+    return val;
+  }
+  return config_->get<int>(std::string(kLegacyPrefix) + kGcsMaxRetryCount);
 }
 
 std::optional<std::string> HiveConfig::gcsMaxRetryTime() const {
-  return static_cast<std::optional<std::string>>(
-      config_->get<std::string>(kGcsMaxRetryTime));
+  if (auto val = config_->get<std::string>(kGcsMaxRetryTime)) {
+    return val;
+  }
+  return config_->get<std::string>(
+      std::string(kLegacyPrefix) + kGcsMaxRetryTime);
 }
 
 std::optional<std::string> HiveConfig::gcsAuthAccessTokenProvider() const {
-  return static_cast<std::optional<std::string>>(
-      config_->get<std::string>(kGcsAuthAccessTokenProvider));
-}
-
-bool HiveConfig::isOrcUseColumnNames(const config::ConfigBase* session) const {
-  return session->get<bool>(
-      kOrcUseColumnNamesSession, config_->get<bool>(kOrcUseColumnNames, false));
-}
-
-bool HiveConfig::isParquetUseColumnNames(
-    const config::ConfigBase* session) const {
-  return session->get<bool>(
-      kParquetUseColumnNamesSession,
-      config_->get<bool>(kParquetUseColumnNames, false));
-}
-
-bool HiveConfig::isFileColumnNamesReadAsLowerCase(
-    const config::ConfigBase* session) const {
-  return session->get<bool>(
-      kFileColumnNamesReadAsLowerCaseSession,
-      config_->get<bool>(kFileColumnNamesReadAsLowerCase, false));
-}
-
-bool HiveConfig::isPartitionPathAsLowerCase(
-    const config::ConfigBase* session) const {
-  return session->get<bool>(kPartitionPathAsLowerCaseSession, true);
-}
-
-bool HiveConfig::allowNullPartitionKeys(
-    const config::ConfigBase* session) const {
-  return session->get<bool>(
-      kAllowNullPartitionKeysSession,
-      config_->get<bool>(kAllowNullPartitionKeys, true));
-}
-
-bool HiveConfig::ignoreMissingFiles(const config::ConfigBase* session) const {
-  return session->get<bool>(kIgnoreMissingFilesSession, false);
-}
-
-int64_t HiveConfig::maxCoalescedBytes(const config::ConfigBase* session) const {
-  return session->get<int64_t>(
-      kMaxCoalescedBytesSession,
-      config_->get<int64_t>(kMaxCoalescedBytes, 128 << 20)); // 128MB
-}
-
-int32_t HiveConfig::maxCoalescedDistanceBytes(
-    const config::ConfigBase* session) const {
-  const auto distance = config::toCapacity(
-      session->get<std::string>(
-          kMaxCoalescedDistanceSession,
-          config_->get<std::string>(kMaxCoalescedDistance, "512kB")),
-      config::CapacityUnit::BYTE);
-  VELOX_USER_CHECK_LE(
-      distance,
-      std::numeric_limits<int32_t>::max(),
-      "The max merge distance to combine read requests must be less than 2GB."
-      " Got {} bytes.",
-      distance);
-  return int32_t(distance);
-}
-
-int32_t HiveConfig::prefetchRowGroups() const {
-  return config_->get<int32_t>(kPrefetchRowGroups, 1);
-}
-
-int32_t HiveConfig::loadQuantum(const config::ConfigBase* session) const {
-  return session->get<int32_t>(
-      kLoadQuantumSession, config_->get<int32_t>(kLoadQuantum, 8 << 20));
+  if (auto val = config_->get<std::string>(kGcsAuthAccessTokenProvider)) {
+    return val;
+  }
+  return config_->get<std::string>(
+      std::string(kLegacyPrefix) + kGcsAuthAccessTokenProvider);
 }
 
 int32_t HiveConfig::numCacheFileHandles() const {
@@ -177,14 +135,11 @@ bool HiveConfig::isFileHandleCacheEnabled() const {
 }
 
 std::string HiveConfig::writeFileCreateConfig() const {
-  return config_->get<std::string>(kWriteFileCreateConfig, "");
-}
-
-uint32_t HiveConfig::sortWriterMaxOutputRows(
-    const config::ConfigBase* session) const {
-  return session->get<uint32_t>(
-      kSortWriterMaxOutputRowsSession,
-      config_->get<uint32_t>(kSortWriterMaxOutputRows, 1024));
+  // Legacy key used snake_case: "hive.write_file_create_config".
+  if (auto val = config_->get<std::string>(kWriteFileCreateConfig)) {
+    return val.value();
+  }
+  return config_->get<std::string>("hive.write_file_create_config", "");
 }
 
 uint64_t HiveConfig::sortWriterMaxOutputBytes(
@@ -196,58 +151,13 @@ uint64_t HiveConfig::sortWriterMaxOutputBytes(
       config::CapacityUnit::BYTE);
 }
 
-uint64_t HiveConfig::sortWriterFinishTimeSliceLimitMs(
-    const config::ConfigBase* session) const {
-  return session->get<uint64_t>(
-      kSortWriterFinishTimeSliceLimitMsSession,
-      config_->get<uint64_t>(kSortWriterFinishTimeSliceLimitMs, 5'000));
-}
-
-uint64_t HiveConfig::footerEstimatedSize() const {
-  return config_->get<uint64_t>(kFooterEstimatedSize, 256UL << 10);
-}
-
-uint64_t HiveConfig::filePreloadThreshold() const {
-  return config_->get<uint64_t>(kFilePreloadThreshold, 8UL << 20);
-}
-
-uint8_t HiveConfig::readTimestampUnit(const config::ConfigBase* session) const {
-  const auto unit = session->get<uint8_t>(
-      kReadTimestampUnitSession,
-      config_->get<uint8_t>(kReadTimestampUnit, 3 /*milli*/));
-  VELOX_CHECK(
-      unit == 3 || unit == 6 /*micro*/ || unit == 9 /*nano*/,
-      "Invalid timestamp unit.");
-  return unit;
-}
-
-bool HiveConfig::readTimestampPartitionValueAsLocalTime(
-    const config::ConfigBase* session) const {
-  return session->get<bool>(
-      kReadTimestampPartitionValueAsLocalTimeSession,
-      config_->get<bool>(kReadTimestampPartitionValueAsLocalTime, true));
-}
-
-bool HiveConfig::readStatsBasedFilterReorderDisabled(
-    const config::ConfigBase* session) const {
-  return session->get<bool>(
-      kReadStatsBasedFilterReorderDisabledSession,
-      config_->get<bool>(kReadStatsBasedFilterReorderDisabled, false));
-}
-
-std::string HiveConfig::hiveLocalDataPath() const {
-  return config_->get<std::string>(kLocalDataPath, "");
-}
-
-std::string HiveConfig::hiveLocalFileFormat() const {
-  return config_->get<std::string>(kLocalFileFormat, "");
-}
-
-bool HiveConfig::preserveFlatMapsInMemory(
+uint64_t HiveConfig::maxTargetFileSizeBytes(
     const config::ConfigBase* session) const {
-  return session->get<bool>(
-      kPreserveFlatMapsInMemorySession,
-      config_->get<bool>(kPreserveFlatMapsInMemory, false));
+  return config::toCapacity(
+      session->get<std::string>(
+          kMaxTargetFileSizeSession,
+          config_->get<std::string>(kMaxTargetFileSize, "0B")),
+      config::CapacityUnit::BYTE);
 }
 
 } // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HiveConfig.h b/velox/connectors/hive/HiveConfig.h
index 6cf3d911af1..6835bcd3d16 100644
--- a/velox/connectors/hive/HiveConfig.h
+++ b/velox/connectors/hive/HiveConfig.h
@@ -15,19 +15,20 @@
  */
 #pragma once
 
-#include <optional>
-#include <string>
-#include "velox/common/base/Exceptions.h"
-
-namespace facebook::velox::config {
-class ConfigBase;
-}
+#include "velox/connectors/hive/FileConfig.h"
+#include "velox/connectors/hive/HiveConfigMacrosDefine.h"
 
 namespace facebook::velox::connector::hive {
 
-/// Hive connector configs.
-class HiveConfig {
+/// Hive connector configs. Extends FileConfig with Hive-specific settings
+/// for partitioning, bucketing, write-path options, GCS storage, and other
+/// Hive table format concerns.
+class HiveConfig : public FileConfig {
  public:
+  /// Returns all registered session-overridable properties from both
+  /// FileConfig and HiveConfig.
+  static const std::vector<config::ConfigProperty>& registeredProperties();
+
   enum class InsertExistingPartitionsBehavior {
     kError,
     kOverwrite,
@@ -36,93 +37,147 @@ class HiveConfig {
   static std::string insertExistingPartitionsBehaviorString(
       InsertExistingPartitionsBehavior behavior);
 
-  /// Behavior on insert into existing partitions.
-  static constexpr const char* kInsertExistingPartitionsBehaviorSession =
-      "insert_existing_partitions_behavior";
+  // --- VELOX_HIVE_CONFIG_PROPERTY properties ---
+
+  VELOX_HIVE_CONFIG_PROPERTY(
+      kInsertExistingPartitionsBehaviorSession,
+      "insert_existing_partitions_behavior",
+      std::string,
+      "ERROR",
+      "Behavior when inserting into existing partitions: ERROR, OVERWRITE.")
   static constexpr const char* kInsertExistingPartitionsBehavior =
       "insert-existing-partitions-behavior";
 
-  /// Maximum number of (bucketed) partitions per a single table writer
-  /// instance.
+  VELOX_HIVE_CONFIG_PROPERTY(
+      kSortWriterMaxOutputBytesSession,
+      "sort_writer_max_output_bytes",
+      std::string,
+      "10MB",
+      "Maximum output bytes for sort writer.")
+  static constexpr const char* kSortWriterMaxOutputBytes =
+      "sort-writer-max-output-bytes";
+
+  VELOX_HIVE_CONFIG_PROPERTY(
+      kMaxTargetFileSizeSession,
+      "max_target_file_size",
+      std::string,
+      "0B",
+      "Maximum target file size. 0 means no limit.")
+  static constexpr const char* kMaxTargetFileSize = "max-target-file-size";
+
+  // --- VELOX_HIVE_CONFIG properties ---
+
+  VELOX_HIVE_CONFIG(
+      kMaxPartitionsPerWritersSession,
+      maxPartitionsPerWriters,
+      "max_partitions_per_writers",
+      uint32_t,
+      128,
+      "Maximum partitions per writer.")
   static constexpr const char* kMaxPartitionsPerWriters =
       "max-partitions-per-writers";
-  static constexpr const char* kMaxPartitionsPerWritersSession =
-      "max_partitions_per_writers";
 
-  /// Maximum number of buckets allowed to output by the table writers.
-  static constexpr const char* kMaxBucketCount = "hive.max-bucket-count";
-  static constexpr const char* kMaxBucketCountSession = "hive.max_bucket_count";
+  VELOX_HIVE_CONFIG(
+      kAllowNullPartitionKeysSession,
+      allowNullPartitionKeys,
+      "allow_null_partition_keys",
+      bool,
+      true,
+      "Allow null partition keys.")
+  static constexpr const char* kAllowNullPartitionKeys =
+      "allow-null-partition-keys";
+
+  VELOX_HIVE_CONFIG_PROPERTY(
+      kPartitionPathAsLowerCaseSession,
+      "partition_path_as_lower_case",
+      bool,
+      true,
+      "Write partition path segments as lower case.")
+  bool isPartitionPathAsLowerCase(const config::ConfigBase* session) const {
+    return session->get<bool>(
+        kPartitionPathAsLowerCaseSession,
+        kPartitionPathAsLowerCaseSessionProperty::defaultValue);
+  }
+
+  VELOX_HIVE_CONFIG(
+      kSortWriterMaxOutputRowsSession,
+      sortWriterMaxOutputRows,
+      "sort_writer_max_output_rows",
+      uint32_t,
+      1024,
+      "Maximum output rows for sort writer.")
+  static constexpr const char* kSortWriterMaxOutputRows =
+      "sort-writer-max-output-rows";
+
+  VELOX_HIVE_CONFIG(
+      kSortWriterFinishTimeSliceLimitMsSession,
+      sortWriterFinishTimeSliceLimitMs,
+      "sort_writer_finish_time_slice_limit_ms",
+      uint64_t,
+      5000,
+      "Time slice limit in ms for sort writer finish. 0 means no limit.")
+  static constexpr const char* kSortWriterFinishTimeSliceLimitMs =
+      "sort-writer-finish-time-slice-limit-ms";
+
+  VELOX_HIVE_CONFIG(kUser, user, "user", std::string, "", "User of the query.")
+
+  VELOX_HIVE_CONFIG(
+      kSource,
+      source,
+      "source",
+      std::string,
+      "",
+      "Source of the query.")
+
+  VELOX_HIVE_CONFIG(
+      kSchema,
+      schema,
+      "schema",
+      std::string,
+      "",
+      "Schema of the query.")
+
+  // --- VELOX_HIVE_CONFIG_LEGACY properties ---
+
+  VELOX_HIVE_CONFIG_LEGACY(
+      kMaxBucketCountSession,
+      kMaxBucketCount,
+      maxBucketCount,
+      "max_bucket_count",
+      "max-bucket-count",
+      uint32_t,
+      100'000,
+      "Maximum bucket count.")
+
+  VELOX_HIVE_CONFIG_LEGACY(
+      kMaxRowsPerIndexRequestSession,
+      kMaxRowsPerIndexRequest,
+      maxRowsPerIndexRequest,
+      "max_rows_per_index_request",
+      "max-rows-per-index-request",
+      uint32_t,
+      0,
+      "Maximum rows per index lookup request. 0 means no limit.")
+  // --- Server-only properties (no macro) ---
 
   /// Whether new data can be inserted into an unpartition table.
   /// Velox currently does not support appending data to existing partitions.
-  static constexpr const char* kImmutablePartitions =
-      "hive.immutable-partitions";
+  static constexpr const char* kImmutablePartitions = "immutable-partitions";
 
   /// The GCS storage endpoint server.
-  static constexpr const char* kGcsEndpoint = "hive.gcs.endpoint";
+  static constexpr const char* kGcsEndpoint = "gcs.endpoint";
 
   /// The GCS service account configuration JSON key file.
-  static constexpr const char* kGcsCredentialsPath =
-      "hive.gcs.json-key-file-path";
+  static constexpr const char* kGcsCredentialsPath = "gcs.json-key-file-path";
 
   /// The GCS maximum retry counter of transient errors.
-  static constexpr const char* kGcsMaxRetryCount = "hive.gcs.max-retry-count";
+  static constexpr const char* kGcsMaxRetryCount = "gcs.max-retry-count";
 
   /// The GCS maximum time allowed to retry transient errors.
-  static constexpr const char* kGcsMaxRetryTime = "hive.gcs.max-retry-time";
+  static constexpr const char* kGcsMaxRetryTime = "gcs.max-retry-time";
 
   static constexpr const char* kGcsAuthAccessTokenProvider =
-      "hive.gcs.auth.access-token-provider";
-
-  /// Maps table field names to file field names using names, not indices.
-  // TODO: remove hive_orc_use_column_names since it doesn't exist in presto,
-  // right now this is only used for testing.
-  static constexpr const char* kOrcUseColumnNames = "hive.orc.use-column-names";
-  static constexpr const char* kOrcUseColumnNamesSession =
-      "hive_orc_use_column_names";
-
-  /// Maps table field names to file field names using names, not indices.
-  static constexpr const char* kParquetUseColumnNames =
-      "hive.parquet.use-column-names";
-  static constexpr const char* kParquetUseColumnNamesSession =
-      "parquet_use_column_names";
-
-  /// Reads the source file column name as lower case.
-  static constexpr const char* kFileColumnNamesReadAsLowerCase =
-      "file-column-names-read-as-lower-case";
-  static constexpr const char* kFileColumnNamesReadAsLowerCaseSession =
-      "file_column_names_read_as_lower_case";
-
-  static constexpr const char* kPartitionPathAsLowerCaseSession =
-      "partition_path_as_lower_case";
-
-  static constexpr const char* kAllowNullPartitionKeys =
-      "allow-null-partition-keys";
-  static constexpr const char* kAllowNullPartitionKeysSession =
-      "allow_null_partition_keys";
-
-  static constexpr const char* kIgnoreMissingFilesSession =
-      "ignore_missing_files";
-
-  /// The max coalesce bytes for a request.
-  static constexpr const char* kMaxCoalescedBytes = "max-coalesced-bytes";
-  static constexpr const char* kMaxCoalescedBytesSession =
-      "max-coalesced-bytes";
-
-  /// The max merge distance to combine read requests.
-  /// Note: The session property name differs from the constant name for
-  /// backward compatibility with Presto.
-  static constexpr const char* kMaxCoalescedDistance = "max-coalesced-distance";
-  static constexpr const char* kMaxCoalescedDistanceSession =
-      "orc_max_merge_distance";
-
-  /// The number of prefetch rowgroups
-  static constexpr const char* kPrefetchRowGroups = "prefetch-rowgroups";
-
-  /// The total size in bytes for a direct coalesce request. Up to 8MB load
-  /// quantum size is supported when SSD cache is enabled.
-  static constexpr const char* kLoadQuantum = "load-quantum";
-  static constexpr const char* kLoadQuantumSession = "load-quantum";
+      "gcs.auth.access-token-provider";
 
   /// Maximum number of entries in the file handle cache.
   static constexpr const char* kNumCacheFileHandles = "num_cached_file_handles";
@@ -137,73 +192,15 @@ class HiveConfig {
   static constexpr const char* kEnableFileHandleCache =
       "file-handle-cache-enabled";
 
-  /// The size in bytes to be fetched with Meta data together, used when the
-  /// data after meta data will be used later. Optimization to decrease small IO
-  /// request
-  static constexpr const char* kFooterEstimatedSize = "footer-estimated-size";
-
-  /// The threshold of file size in bytes when the whole file is fetched with
-  /// meta data together. Optimization to decrease the small IO requests
-  static constexpr const char* kFilePreloadThreshold = "file-preload-threshold";
-
   /// Config used to create write files. This config is provided to underlying
   /// file system through hive connector and data sink. The config is free form.
   /// The form should be defined by the underlying file system.
   static constexpr const char* kWriteFileCreateConfig =
-      "hive.write_file_create_config";
-
-  /// Maximum number of rows for sort writer in one batch of output.
-  static constexpr const char* kSortWriterMaxOutputRows =
-      "sort-writer-max-output-rows";
-  static constexpr const char* kSortWriterMaxOutputRowsSession =
-      "sort_writer_max_output_rows";
-
-  /// Maximum bytes for sort writer in one batch of output.
-  static constexpr const char* kSortWriterMaxOutputBytes =
-      "sort-writer-max-output-bytes";
-  static constexpr const char* kSortWriterMaxOutputBytesSession =
-      "sort_writer_max_output_bytes";
-
-  /// Sort Writer will exit finish() method after this many milliseconds even if
-  /// it has not completed its work yet. Zero means no time limit.
-  static constexpr const char* kSortWriterFinishTimeSliceLimitMs =
-      "sort-writer_finish_time_slice_limit_ms";
-  static constexpr const char* kSortWriterFinishTimeSliceLimitMsSession =
-      "sort_writer_finish_time_slice_limit_ms";
-
-  // The unit for reading timestamps from files.
-  static constexpr const char* kReadTimestampUnit =
-      "hive.reader.timestamp-unit";
-  static constexpr const char* kReadTimestampUnitSession =
-      "hive.reader.timestamp_unit";
-
-  static constexpr const char* kReadTimestampPartitionValueAsLocalTime =
-      "hive.reader.timestamp-partition-value-as-local-time";
-  static constexpr const char* kReadTimestampPartitionValueAsLocalTimeSession =
-      "hive.reader.timestamp_partition_value_as_local_time";
-
-  static constexpr const char* kReadStatsBasedFilterReorderDisabled =
-      "stats-based-filter-reorder-disabled";
-  static constexpr const char* kReadStatsBasedFilterReorderDisabledSession =
-      "stats_based_filter_reorder_disabled";
-
-  static constexpr const char* kLocalDataPath = "hive_local_data_path";
-  static constexpr const char* kLocalFileFormat = "hive_local_file_format";
-
-  /// Whether to preserve flat maps in memory as FlatMapVectors instead of
-  /// converting them to MapVectors.
-  static constexpr const char* kPreserveFlatMapsInMemory =
-      "hive.preserve-flat-maps-in-memory";
-  static constexpr const char* kPreserveFlatMapsInMemorySession =
-      "hive.preserve_flat_maps_in_memory";
+      "write-file-create-config";
 
   InsertExistingPartitionsBehavior insertExistingPartitionsBehavior(
       const config::ConfigBase* session) const;
 
-  uint32_t maxPartitionsPerWriters(const config::ConfigBase* session) const;
-
-  uint32_t maxBucketCount(const config::ConfigBase* session) const;
-
   bool immutablePartitions() const;
 
   std::string gcsEndpoint() const;
@@ -216,27 +213,6 @@ class HiveConfig {
 
   std::optional<std::string> gcsAuthAccessTokenProvider() const;
 
-  bool isOrcUseColumnNames(const config::ConfigBase* session) const;
-
-  bool isParquetUseColumnNames(const config::ConfigBase* session) const;
-
-  bool isFileColumnNamesReadAsLowerCase(
-      const config::ConfigBase* session) const;
-
-  bool isPartitionPathAsLowerCase(const config::ConfigBase* session) const;
-
-  bool allowNullPartitionKeys(const config::ConfigBase* session) const;
-
-  bool ignoreMissingFiles(const config::ConfigBase* session) const;
-
-  int64_t maxCoalescedBytes(const config::ConfigBase* session) const;
-
-  int32_t maxCoalescedDistanceBytes(const config::ConfigBase* session) const;
-
-  int32_t prefetchRowGroups() const;
-
-  int32_t loadQuantum(const config::ConfigBase* session) const;
-
   int32_t numCacheFileHandles() const;
 
   uint64_t fileHandleExpirationDurationMs() const;
@@ -247,55 +223,14 @@ class HiveConfig {
 
   std::string writeFileCreateConfig() const;
 
-  uint32_t sortWriterMaxOutputRows(const config::ConfigBase* session) const;
-
   uint64_t sortWriterMaxOutputBytes(const config::ConfigBase* session) const;
 
-  uint64_t sortWriterFinishTimeSliceLimitMs(
-      const config::ConfigBase* session) const;
+  uint64_t maxTargetFileSizeBytes(const config::ConfigBase* session) const;
 
-  uint64_t footerEstimatedSize() const;
-
-  uint64_t filePreloadThreshold() const;
-
-  // Returns the timestamp unit used when reading timestamps from files.
-  uint8_t readTimestampUnit(const config::ConfigBase* session) const;
-
-  // Whether to read timestamp partition value as local time. If false, read as
-  // UTC.
-  bool readTimestampPartitionValueAsLocalTime(
-      const config::ConfigBase* session) const;
-
-  /// Returns true if the stats based filter reorder for read is disabled.
-  bool readStatsBasedFilterReorderDisabled(
-      const config::ConfigBase* session) const;
-
-  /// Returns the file system path containing local data. If non-empty,
-  /// initializes LocalHiveConnectorMetadata to provide metadata for the tables
-  /// in the directory.
-  std::string hiveLocalDataPath() const;
-
-  /// Returns the name of the file format to use in interpreting the contents of
-  /// hiveLocalDataPath().
-  std::string hiveLocalFileFormat() const;
-
-  /// Whether to preserve flat maps in memory as FlatMapVectors instead of
-  /// converting them to MapVectors.
-  bool preserveFlatMapsInMemory(const config::ConfigBase* session) const;
-
-  HiveConfig(std::shared_ptr<const config::ConfigBase> config) {
-    VELOX_CHECK_NOT_NULL(
-        config, "Config is null for HiveConfig initialization");
-    config_ = std::move(config);
-    // TODO: add sanity check
-  }
-
-  const std::shared_ptr<const config::ConfigBase>& config() const {
-    return config_;
-  }
-
- private:
-  std::shared_ptr<const config::ConfigBase> config_;
+  explicit HiveConfig(std::shared_ptr<const config::ConfigBase> config)
+      : FileConfig(std::move(config)) {}
 };
 
 } // namespace facebook::velox::connector::hive
+
+#include "velox/connectors/hive/HiveConfigMacrosUndef.h"
diff --git a/velox/connectors/hive/HiveConfigMacrosDefine.h b/velox/connectors/hive/HiveConfigMacrosDefine.h
new file mode 100644
index 00000000000..a86a5ddc397
--- /dev/null
+++ b/velox/connectors/hive/HiveConfigMacrosDefine.h
@@ -0,0 +1,102 @@
+// NOLINT(facebook-hte-MultipleIncludeGuardMissing)
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Macros for defining Hive connector config properties. Same traits-based
+// pattern as VELOX_QUERY_CONFIG in QueryConfig.h.
+//
+// No #pragma once — this file is intentionally included multiple times
+// (once per header that defines config properties). Each inclusion must
+// be paired with HiveConfigMacrosUndef.h to scope the macros.
+//
+// To add a new property, add two lines (order doesn't matter, but
+// grouping related properties together helps readability):
+//
+// 1. In FileConfig.h or HiveConfig.h (inside the class body):
+//   VELOX_HIVE_CONFIG(kMaxPartitionsPerWritersSession,
+//       maxPartitionsPerWriters, "max_partitions_per_writers",
+//       uint32_t, 128, "Maximum partitions per writer.")
+//
+// 2. In the matching .cpp file (inside registeredProperties()):
+//   VELOX_HIVE_CONFIG_REGISTER(kMaxPartitionsPerWritersSession);
+//
+// VELOX_HIVE_CONFIG generates:
+//   - struct kMaxPartitionsPerWritersSessionProperty {
+//         using type = uint32_t;
+//         static constexpr const char* key = "max_partitions_per_writers";
+//         static constexpr auto defaultValue = 128;
+//         static constexpr const char* description = "Maximum partitions...";
+//     };
+//   - static constexpr const char* kMaxPartitionsPerWritersSession =
+//         "max_partitions_per_writers"
+//   - uint32_t maxPartitionsPerWriters(const ConfigBase* session) const {
+//         return session->get<uint32_t>(kMaxPartitionsPerWritersSession,
+//             config_->get<uint32_t>(toConfigKey(...), 128));
+//     }
+//
+// VELOX_HIVE_CONFIG_PROPERTY generates the same but without the accessor.
+// Used for properties with custom accessor logic: capacity parsing,
+// validation, or session-only properties that should not fall back to
+// connector config (e.g., ignoreMissingFiles, isPartitionPathAsLowerCase).
+// New properties should use VELOX_HIVE_CONFIG and put validation in
+// HiveConfigProvider::normalize() and HiveConnector constructor.
+// TODO: Unify validation into a single path.
+//
+// VELOX_HIVE_CONFIG_LEGACY is the same as VELOX_HIVE_CONFIG but takes an
+// explicit config key and uses sessionValue() for legacy 'hive.' prefix
+// fallback.
+
+#ifdef VELOX_HIVE_CONFIG_MACROS_DEFINED
+#error "HiveConfigMacrosDefine.h included twice without HiveConfigMacrosUndef.h"
+#endif
+// NOLINTBEGIN(facebook-modularize-issue-check)
+#define VELOX_HIVE_CONFIG_MACROS_DEFINED
+
+#define VELOX_HIVE_CONFIG_PROPERTY(                  \
+    constName, keyStr, CppType, defaultVal, desc)    \
+  struct constName##Property {                       \
+    using type = CppType;                            \
+    static constexpr const char* key = keyStr;       \
+    static constexpr auto defaultValue = defaultVal; \
+    static constexpr const char* description = desc; \
+  };                                                 \
+  static constexpr const char* constName = keyStr;
+
+#define VELOX_HIVE_CONFIG(                                              \
+    constName, accessorName, key, CppType, defaultVal, desc)            \
+  VELOX_HIVE_CONFIG_PROPERTY(constName, key, CppType, defaultVal, desc) \
+  CppType accessorName(const config::ConfigBase* session) const {       \
+    return session->get<CppType>(                                       \
+        constName,                                                      \
+        config_->get<CppType>(                                          \
+            config::ConfigBase::toConfigKey(constName), defaultVal));   \
+  }
+
+#define VELOX_HIVE_CONFIG_LEGACY(                                       \
+    constName,                                                          \
+    configConstName,                                                    \
+    accessorName,                                                       \
+    key,                                                                \
+    configKey,                                                          \
+    CppType,                                                            \
+    defaultVal,                                                         \
+    desc)                                                               \
+  VELOX_HIVE_CONFIG_PROPERTY(constName, key, CppType, defaultVal, desc) \
+  static constexpr const char* configConstName = configKey;             \
+  CppType accessorName(const config::ConfigBase* session) const {       \
+    return sessionValue<CppType>(                                       \
+        session, constName, configConstName, defaultVal);               \
+  }
+// NOLINTEND(facebook-modularize-issue-check)
diff --git a/velox/connectors/hive/HiveConfigMacrosUndef.h b/velox/connectors/hive/HiveConfigMacrosUndef.h
new file mode 100644
index 00000000000..c2d0e5685a7
--- /dev/null
+++ b/velox/connectors/hive/HiveConfigMacrosUndef.h
@@ -0,0 +1,29 @@
+// NOLINT(facebook-hte-MultipleIncludeGuardMissing)
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Undefines macros from HiveConfigMacrosDefine.h.
+// Must be included after all macro usage.
+// No #pragma once — see HiveConfigMacrosDefine.h for explanation.
+
+#ifndef VELOX_HIVE_CONFIG_MACROS_DEFINED
+#error "HiveConfigMacrosUndef.h included without HiveConfigMacrosDefine.h"
+#endif
+#undef VELOX_HIVE_CONFIG_MACROS_DEFINED
+
+#undef VELOX_HIVE_CONFIG
+#undef VELOX_HIVE_CONFIG_LEGACY
+#undef VELOX_HIVE_CONFIG_PROPERTY
diff --git a/velox/connectors/hive/HiveConfigProvider.cpp b/velox/connectors/hive/HiveConfigProvider.cpp
new file mode 100644
index 00000000000..c6107a1872f
--- /dev/null
+++ b/velox/connectors/hive/HiveConfigProvider.cpp
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/connectors/hive/HiveConfigProvider.h"
+
+#include "velox/connectors/hive/HiveConfig.h"
+
+namespace facebook::velox::connector::hive {
+
+std::vector<config::ConfigProperty> HiveConfigProvider::properties() const {
+  return HiveConfig::registeredProperties();
+}
+
+std::string HiveConfigProvider::normalize(
+    std::string_view /*name*/,
+    std::string_view value) const {
+  return std::string(value);
+}
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HiveConfigProvider.h b/velox/connectors/hive/HiveConfigProvider.h
new file mode 100644
index 00000000000..752962d4585
--- /dev/null
+++ b/velox/connectors/hive/HiveConfigProvider.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/common/config/ConfigProvider.h"
+
+namespace facebook::velox::connector::hive {
+
+/// Exposes Hive connector session-overridable properties.
+class HiveConfigProvider : public config::ConfigProvider {
+ public:
+  /// Returns all session-overridable Hive connector properties.
+  std::vector<config::ConfigProperty> properties() const override;
+
+  /// Validates and normalizes a property value.
+  std::string normalize(std::string_view name, std::string_view value)
+      const override;
+};
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HiveConnector.cpp b/velox/connectors/hive/HiveConnector.cpp
index e04828e83aa..062a507fc64 100644
--- a/velox/connectors/hive/HiveConnector.cpp
+++ b/velox/connectors/hive/HiveConnector.cpp
@@ -17,8 +17,10 @@
 #include "velox/connectors/hive/HiveConnector.h"
 
 #include "velox/connectors/hive/HiveConfig.h"
+#include "velox/connectors/hive/HiveConfigProvider.h"
 #include "velox/connectors/hive/HiveDataSink.h"
 #include "velox/connectors/hive/HiveDataSource.h"
+#include "velox/connectors/hive/HiveIndexSource.h"
 #include "velox/connectors/hive/HivePartitionFunction.h"
 
 #include <boost/lexical_cast.hpp>
@@ -53,10 +55,15 @@ HiveConnector::HiveConnector(
   }
 }
 
+const config::ConfigProvider* HiveConnector::configProvider() const {
+  static const HiveConfigProvider kProvider;
+  return &kProvider;
+}
+
 std::unique_ptr<DataSource> HiveConnector::createDataSource(
     const RowTypePtr& outputType,
     const ConnectorTableHandlePtr& tableHandle,
-    const std::unordered_map<std::string, ColumnHandlePtr>& columnHandles,
+    const ColumnHandleMap& columnHandles,
     ConnectorQueryCtx* connectorQueryCtx) {
   return std::make_unique<HiveDataSource>(
       outputType,
@@ -86,6 +93,30 @@ std::unique_ptr<DataSink> HiveConnector::createDataSink(
       hiveConfig_);
 }
 
+std::shared_ptr<IndexSource> HiveConnector::createIndexSource(
+    const RowTypePtr& inputType,
+    const std::vector<std::shared_ptr<core::IndexLookupCondition>>&
+        joinConditions,
+    const RowTypePtr& outputType,
+    const ConnectorTableHandlePtr& tableHandle,
+    const ColumnHandleMap& columnHandles,
+    ConnectorQueryCtx* connectorQueryCtx) {
+  auto hiveTableHandle =
+      std::dynamic_pointer_cast<const HiveTableHandle>(tableHandle);
+  VELOX_CHECK_NOT_NULL(
+      hiveTableHandle, "Hive connector expecting hive table handle!");
+  return std::make_shared<HiveIndexSource>(
+      inputType,
+      joinConditions,
+      outputType,
+      hiveTableHandle,
+      columnHandles,
+      &fileHandleFactory_,
+      connectorQueryCtx,
+      hiveConfig_,
+      ioExecutor_);
+}
+
 // static
 void HiveConnector::registerSerDe() {
   HiveTableHandle::registerSerDe();
diff --git a/velox/connectors/hive/HiveConnector.h b/velox/connectors/hive/HiveConnector.h
index c6b91392976..95c175c4f69 100644
--- a/velox/connectors/hive/HiveConnector.h
+++ b/velox/connectors/hive/HiveConnector.h
@@ -34,6 +34,8 @@ class HiveConnector : public Connector {
       std::shared_ptr<const config::ConfigBase> config,
       folly::Executor* executor);
 
+  const config::ConfigProvider* configProvider() const override;
+
   bool canAddDynamicFilter() const override {
     return true;
   }
@@ -44,15 +46,13 @@ class HiveConnector : public Connector {
       const connector::ColumnHandleMap& columnHandles,
       ConnectorQueryCtx* connectorQueryCtx) override;
 
-#ifdef VELOX_ENABLE_BACKWARD_COMPATIBILITY
-  bool supportsSplitPreload() override {
+  bool supportsSplitPreload() const override {
     return true;
   }
-#else
-  bool supportsSplitPreload() const override {
+
+  bool supportsIndexLookup() const override {
     return true;
   }
-#endif
 
   std::unique_ptr<DataSink> createDataSink(
       RowTypePtr inputType,
@@ -60,6 +60,15 @@ class HiveConnector : public Connector {
       ConnectorQueryCtx* connectorQueryCtx,
       CommitStrategy commitStrategy) override;
 
+  std::shared_ptr<IndexSource> createIndexSource(
+      const RowTypePtr& inputType,
+      const std::vector<std::shared_ptr<core::IndexLookupCondition>>&
+          joinConditions,
+      const RowTypePtr& outputType,
+      const ConnectorTableHandlePtr& tableHandle,
+      const ColumnHandleMap& columnHandles,
+      ConnectorQueryCtx* connectorQueryCtx) override;
+
   folly::Executor* ioExecutor() const override {
     return ioExecutor_;
   }
@@ -95,7 +104,7 @@ class HiveConnectorFactory : public ConnectorFactory {
       const std::string& id,
       std::shared_ptr<const config::ConfigBase> config,
       folly::Executor* ioExecutor = nullptr,
-      folly::Executor* cpuExecutor = nullptr) override {
+      [[maybe_unused]] folly::Executor* cpuExecutor = nullptr) override {
     return std::make_shared<HiveConnector>(id, config, ioExecutor);
   }
 };
diff --git a/velox/connectors/hive/HiveConnectorSplit.cpp b/velox/connectors/hive/HiveConnectorSplit.cpp
index f38336d92ab..de5a55e8c14 100644
--- a/velox/connectors/hive/HiveConnectorSplit.cpp
+++ b/velox/connectors/hive/HiveConnectorSplit.cpp
@@ -30,15 +30,6 @@ std::string HiveConnectorSplit::toString() const {
   return fmt::format("Hive: {} {} - {}", filePath, start, length);
 }
 
-uint64_t HiveConnectorSplit::size() const {
-  return length;
-}
-
-std::string HiveConnectorSplit::getFileName() const {
-  const auto i = filePath.rfind('/');
-  return i == std::string::npos ? filePath : filePath.substr(i + 1);
-}
-
 folly::dynamic HiveConnectorSplit::serialize() const {
   folly::dynamic obj = folly::dynamic::object;
   obj["name"] = "HiveConnectorSplit";
@@ -148,8 +139,10 @@ std::shared_ptr<HiveConnectorSplit> HiveConnectorSplit::create(
     std::vector<std::shared_ptr<HiveColumnHandle>> bucketColumnHandles;
     for (const auto& bucketColumnHandleObj :
          bucketConversionObj["bucketColumnHandles"]) {
-      bucketColumnHandles.push_back(std::const_pointer_cast<HiveColumnHandle>(
-          ISerializable::deserialize<HiveColumnHandle>(bucketColumnHandleObj)));
+      bucketColumnHandles.push_back(
+          std::const_pointer_cast<HiveColumnHandle>(
+              ISerializable::deserialize<HiveColumnHandle>(
+                  bucketColumnHandleObj)));
     }
     bucketConversion = HiveBucketConversion{
         .tableBucketCount = static_cast<int32_t>(
diff --git a/velox/connectors/hive/HiveConnectorSplit.h b/velox/connectors/hive/HiveConnectorSplit.h
index 3485c2330fa..8f54e348167 100644
--- a/velox/connectors/hive/HiveConnectorSplit.h
+++ b/velox/connectors/hive/HiveConnectorSplit.h
@@ -17,10 +17,8 @@
 
 #include <optional>
 #include <unordered_map>
-#include "velox/connectors/Connector.h"
-#include "velox/connectors/hive/FileProperties.h"
+#include "velox/connectors/hive/FileConnectorSplit.h"
 #include "velox/connectors/hive/TableHandle.h"
-#include "velox/dwio/common/Options.h"
 
 namespace facebook::velox::connector::hive {
 
@@ -42,31 +40,17 @@ struct RowIdProperties {
   std::string tableGuid;
 };
 
-struct HiveConnectorSplit : public connector::ConnectorSplit {
-  const std::string filePath;
-  dwio::common::FileFormat fileFormat;
-  const uint64_t start;
-  const uint64_t length;
-
-  /// Mapping from partition keys to values. Values are specified as strings
-  /// formatted the same way as CAST(x as VARCHAR). Null values are specified as
-  /// std::nullopt. Date values must be formatted using ISO 8601 as YYYY-MM-DD.
-  /// All scalar types and date type are supported.
-  const std::unordered_map<std::string, std::optional<std::string>>
-      partitionKeys;
+struct HiveConnectorSplit : public FileConnectorSplit {
+  /// Synthesized columns like $path, $file_size associated with the split.
+  std::unordered_map<std::string, std::string> infoColumns;
+
+  /// Format-specific reader parameters (e.g., ORC serde options from Hive
+  /// metastore).
+  std::unordered_map<std::string, std::string> serdeParameters;
+
   std::optional<int32_t> tableBucketNumber;
   std::unordered_map<std::string, std::string> customSplitInfo;
   std::shared_ptr<std::string> extraFileInfo;
-  // Parameters that are provided as the serialization options.
-  std::unordered_map<std::string, std::string> serdeParameters;
-
-  /// These represent columns like $file_size, $file_modified_time that are
-  /// associated with the HiveSplit.
-  std::unordered_map<std::string, std::string> infoColumns;
-
-  /// These represent file properties like file size that are used while opening
-  /// the file handle.
-  std::optional<FileProperties> properties;
 
   std::optional<RowIdProperties> rowIdProperties;
 
@@ -91,29 +75,28 @@ struct HiveConnectorSplit : public connector::ConnectorSplit {
       std::optional<RowIdProperties> _rowIdProperties = std::nullopt,
       const std::optional<HiveBucketConversion>& _bucketConversion =
           std::nullopt)
-      : ConnectorSplit(connectorId, splitWeight, cacheable),
-        filePath(_filePath),
-        fileFormat(_fileFormat),
-        start(_start),
-        length(_length),
-        partitionKeys(_partitionKeys),
+      : FileConnectorSplit(
+            connectorId,
+            _filePath,
+            _fileFormat,
+            _start,
+            _length,
+            splitWeight,
+            cacheable,
+            std::move(_properties),
+            _partitionKeys),
+        infoColumns(_infoColumns),
+        serdeParameters(_serdeParameters),
         tableBucketNumber(_tableBucketNumber),
         customSplitInfo(_customSplitInfo),
         extraFileInfo(_extraFileInfo),
-        serdeParameters(_serdeParameters),
-        infoColumns(_infoColumns),
-        properties(_properties),
         rowIdProperties(_rowIdProperties),
         bucketConversion(_bucketConversion) {}
 
   ~HiveConnectorSplit() = default;
 
-  uint64_t size() const override;
-
   std::string toString() const override;
 
-  std::string getFileName() const;
-
   folly::dynamic serialize() const override;
 
   static std::shared_ptr<HiveConnectorSplit> create(const folly::dynamic& obj);
diff --git a/velox/connectors/hive/HiveConnectorUtil.cpp b/velox/connectors/hive/HiveConnectorUtil.cpp
index e06ee973ec7..0381ee2ecb5 100644
--- a/velox/connectors/hive/HiveConnectorUtil.cpp
+++ b/velox/connectors/hive/HiveConnectorUtil.cpp
@@ -16,12 +16,18 @@
 
 #include "velox/connectors/hive/HiveConnectorUtil.h"
 
-#include "velox/connectors/hive/HiveConfig.h"
-#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/connectors/hive/FileColumnHandle.h"
+
+#include "velox/connectors/hive/FileConfig.h"
+#include "velox/connectors/hive/FileConnectorSplit.h"
+#include "velox/connectors/hive/FileConnectorUtil.h"
+#include "velox/connectors/hive/FileTableHandle.h"
 #include "velox/dwio/common/CachedBufferedInput.h"
 #include "velox/dwio/common/DirectBufferedInput.h"
 #include "velox/expression/Expr.h"
+#include "velox/expression/ExprConstants.h"
 #include "velox/expression/ExprToSubfieldFilter.h"
+#include "velox/expression/FieldReference.h"
 
 namespace facebook::velox::connector::hive {
 namespace {
@@ -73,14 +79,15 @@ std::unique_ptr<common::Filter> makeFloatingPointMapKeyFilter(
     if (lowerUnbounded && upperUnbounded) {
       continue;
     }
-    filters.push_back(std::make_unique<common::FloatingPointRange<T>>(
-        lower,
-        lowerUnbounded,
-        lowerExclusive,
-        upper,
-        upperUnbounded,
-        upperExclusive,
-        false));
+    filters.push_back(
+        std::make_unique<common::FloatingPointRange<T>>(
+            lower,
+            lowerUnbounded,
+            lowerExclusive,
+            upper,
+            upperUnbounded,
+            upperExclusive,
+            false));
   }
   if (filters.size() == 1) {
     return std::move(filters[0]);
@@ -105,19 +112,16 @@ void addSubfields(
     }
   }
   subfields.resize(newSize);
+
   switch (type.kind()) {
     case TypeKind::ROW: {
       folly::F14FastMap<std::string, std::vector<SubfieldSpec>> required;
       for (auto& subfield : subfields) {
         auto* element = subfield.subfield->path()[level].get();
-        auto* nestedField = element->as<common::Subfield::NestedField>();
-        VELOX_CHECK(
-            nestedField,
-            "Unsupported for row subfields pruning: {}",
-            element->toString());
+        auto* nestedField = element->asChecked<common::Subfield::NestedField>();
         required[nestedField->name()].push_back(subfield);
       }
-      auto& rowType = type.asRow();
+      const auto& rowType = type.asRow();
       for (int i = 0; i < rowType.size(); ++i) {
         auto& childName = rowType.nameOf(i);
         auto& childType = rowType.childAt(i);
@@ -239,7 +243,7 @@ inline uint8_t parseDelimiter(const std::string& delim) {
 
 inline bool isSynthesizedColumn(
     const std::string& name,
-    const std::unordered_map<std::string, HiveColumnHandlePtr>& infoColumns) {
+    const std::unordered_map<std::string, FileColumnHandlePtr>& infoColumns) {
   return infoColumns.count(name) != 0;
 }
 
@@ -253,9 +257,8 @@ bool isSpecialColumn(
 
 const std::string& getColumnName(const common::Subfield& subfield) {
   VELOX_CHECK_GT(subfield.path().size(), 0);
-  auto* field = dynamic_cast<const common::Subfield::NestedField*>(
+  auto* field = checkedPointerCast<const common::Subfield::NestedField>(
       subfield.path()[0].get());
-  VELOX_CHECK_NOT_NULL(field);
   return field->name();
 }
 
@@ -285,7 +288,7 @@ void checkColumnNameLowerCase(const TypePtr& type) {
 
 void checkColumnNameLowerCase(
     const common::SubfieldFilters& filters,
-    const std::unordered_map<std::string, HiveColumnHandlePtr>& infoColumns) {
+    const std::unordered_map<std::string, FileColumnHandlePtr>& infoColumns) {
   for (const auto& filterIt : filters) {
     const auto name = filterIt.first.toString();
     if (isSynthesizedColumn(name, infoColumns)) {
@@ -333,9 +336,10 @@ void processFieldSpec(
     }
   });
   if (dataColumns) {
-    auto i = dataColumns->getChildIdxIfExists(fieldSpec.fieldName());
-    if (i.has_value()) {
-      if (dataColumns->childAt(*i)->isMap() && outputType->isRow()) {
+    const auto childIdxOpt =
+        dataColumns->getChildIdxIfExists(fieldSpec.fieldName());
+    if (childIdxOpt.has_value()) {
+      if (dataColumns->childAt(*childIdxOpt)->isMap() && outputType->isRow()) {
         fieldSpec.setFlatMapAsStruct(true);
       }
     }
@@ -344,14 +348,57 @@ void processFieldSpec(
 
 } // namespace
 
+void checkColumnHandleConsistent(
+    const FileColumnHandle& x,
+    const FileColumnHandle& y) {
+  VELOX_CHECK_EQ(
+      x.columnType(),
+      y.columnType(),
+      "Inconsistent column handle type: {}, expected {}, got {}",
+      x.name(),
+      FileColumnHandle::columnTypeName(x.columnType()),
+      FileColumnHandle::columnTypeName(y.columnType()));
+  VELOX_CHECK(
+      x.dataType()->equivalent(*y.dataType()),
+      "Inconsistent column handle data type: {}, expected {}, got {}",
+      x.name(),
+      x.dataType()->toString(),
+      y.dataType()->toString());
+}
+
 std::shared_ptr<common::ScanSpec> makeScanSpec(
     const RowTypePtr& rowType,
     const folly::F14FastMap<std::string, std::vector<const common::Subfield*>>&
         outputSubfields,
-    const common::SubfieldFilters& filters,
+    const common::SubfieldFilters& subfieldFilters,
     const RowTypePtr& dataColumns,
-    const std::unordered_map<std::string, HiveColumnHandlePtr>& partitionKeys,
-    const std::unordered_map<std::string, HiveColumnHandlePtr>& infoColumns,
+    const std::unordered_map<std::string, FileColumnHandlePtr>& partitionKeys,
+    const std::unordered_map<std::string, FileColumnHandlePtr>& infoColumns,
+    const SpecialColumnNames& specialColumns,
+    bool disableStatsBasedFilterReorder,
+    memory::MemoryPool* pool) {
+  return makeScanSpec(
+      rowType,
+      outputSubfields,
+      subfieldFilters,
+      /*indexColumns=*/{},
+      dataColumns,
+      partitionKeys,
+      infoColumns,
+      specialColumns,
+      disableStatsBasedFilterReorder,
+      pool);
+}
+
+std::shared_ptr<common::ScanSpec> makeScanSpec(
+    const RowTypePtr& rowType,
+    const folly::F14FastMap<std::string, std::vector<const common::Subfield*>>&
+        outputSubfields,
+    const common::SubfieldFilters& subfieldFilters,
+    const std::vector<std::string>& indexColumns,
+    const RowTypePtr& dataColumns,
+    const std::unordered_map<std::string, FileColumnHandlePtr>& partitionKeys,
+    const std::unordered_map<std::string, FileColumnHandlePtr>& infoColumns,
     const SpecialColumnNames& specialColumns,
     bool disableStatsBasedFilterReorder,
     memory::MemoryPool* pool) {
@@ -359,7 +406,7 @@ std::shared_ptr<common::ScanSpec> makeScanSpec(
   folly::F14FastMap<std::string, std::vector<const common::Subfield*>>
       filterSubfields;
   std::vector<SubfieldSpec> subfieldSpecs;
-  for (auto& [subfield, _] : filters) {
+  for (const auto& [subfield, _] : subfieldFilters) {
     if (auto name = subfield.toString();
         !isSynthesizedColumn(name, infoColumns) &&
         partitionKeys.count(name) == 0) {
@@ -426,16 +473,19 @@ std::shared_ptr<common::ScanSpec> makeScanSpec(
     }
   }
 
-  for (auto& pair : filters) {
+  // Process index columns from join conditions to ensure they are read.
+  // These columns are not projected out, only used for index lookup.
+  for (const auto& keyName : indexColumns) {
+    VELOX_CHECK_NOT_NULL(dataColumns);
+    if (spec->childByName(keyName) == nullptr) {
+      // This is required so that we can set filter on the index column in the
+      // selective reader later.
+      spec->getOrCreateChild(keyName);
+    }
+  }
+
+  for (auto& pair : subfieldFilters) {
     const auto name = pair.first.toString();
-    // SelectiveColumnReader doesn't support constant columns with filters,
-    // hence, we can't have a filter for a $path or $bucket column.
-    //
-    // Unfortunately, Presto happens to specify a filter for $path, $file_size,
-    // $file_modified_time or $bucket column. This filter is redundant and needs
-    // to be removed.
-    // TODO Remove this check when Presto is fixed to not specify a filter
-    // on $path and $bucket column.
     if (isSynthesizedColumn(name, infoColumns)) {
       continue;
     }
@@ -523,84 +573,52 @@ std::unique_ptr<dwio::common::SerDeOptions> parseSerdeParameters(
 }
 
 void configureReaderOptions(
-    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const std::shared_ptr<const FileConfig>& fileConfig,
     const ConnectorQueryCtx* connectorQueryCtx,
-    const std::shared_ptr<const HiveTableHandle>& hiveTableHandle,
-    const std::shared_ptr<const HiveConnectorSplit>& hiveSplit,
+    const FileTableHandlePtr& tableHandle,
+    const std::shared_ptr<const FileConnectorSplit>& fileSplit,
+    const std::unordered_map<std::string, std::string>& serdeParameters,
     dwio::common::ReaderOptions& readerOptions) {
   configureReaderOptions(
-      hiveConfig,
+      fileConfig,
       connectorQueryCtx,
-      hiveTableHandle->dataColumns(),
-      hiveSplit,
-      hiveTableHandle->tableParameters(),
+      tableHandle->dataColumns(),
+      fileSplit,
+      tableHandle->tableParameters(),
+      serdeParameters,
       readerOptions);
 }
 
 void configureReaderOptions(
-    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const std::shared_ptr<const FileConfig>& fileConfig,
     const ConnectorQueryCtx* connectorQueryCtx,
     const RowTypePtr& fileSchema,
-    const std::shared_ptr<const HiveConnectorSplit>& hiveSplit,
+    const std::shared_ptr<const FileConnectorSplit>& fileSplit,
     const std::unordered_map<std::string, std::string>& tableParameters,
+    const std::unordered_map<std::string, std::string>& serdeParameters,
     dwio::common::ReaderOptions& readerOptions) {
-  auto sessionProperties = connectorQueryCtx->sessionProperties();
-  readerOptions.setLoadQuantum(hiveConfig->loadQuantum(sessionProperties));
-  readerOptions.setMaxCoalesceBytes(
-      hiveConfig->maxCoalescedBytes(sessionProperties));
-  readerOptions.setMaxCoalesceDistance(
-      hiveConfig->maxCoalescedDistanceBytes(sessionProperties));
-  readerOptions.setFileColumnNamesReadAsLowerCase(
-      hiveConfig->isFileColumnNamesReadAsLowerCase(sessionProperties));
-  readerOptions.setAllowEmptyFile(true);
-  bool useColumnNamesForColumnMapping = false;
-  switch (hiveSplit->fileFormat) {
-    case dwio::common::FileFormat::DWRF:
-    case dwio::common::FileFormat::ORC: {
-      useColumnNamesForColumnMapping =
-          hiveConfig->isOrcUseColumnNames(sessionProperties);
-      break;
-    }
-    case dwio::common::FileFormat::PARQUET: {
-      useColumnNamesForColumnMapping =
-          hiveConfig->isParquetUseColumnNames(sessionProperties);
-      break;
-    }
-    default:
-      useColumnNamesForColumnMapping = false;
-  }
-
-  readerOptions.setUseColumnNamesForColumnMapping(
-      useColumnNamesForColumnMapping);
-  readerOptions.setFileSchema(fileSchema);
-  readerOptions.setFooterEstimatedSize(hiveConfig->footerEstimatedSize());
-  readerOptions.setFilePreloadThreshold(hiveConfig->filePreloadThreshold());
-  readerOptions.setPrefetchRowGroups(hiveConfig->prefetchRowGroups());
-  readerOptions.setNoCacheRetention(!hiveSplit->cacheable);
-  const auto& sessionTzName = connectorQueryCtx->sessionTimezone();
-  if (!sessionTzName.empty()) {
-    const auto timezone = tz::locateZone(sessionTzName);
-    readerOptions.setSessionTimezone(timezone);
-  }
-  readerOptions.setAdjustTimestampToTimezone(
-      connectorQueryCtx->adjustTimestampToTimezone());
-  readerOptions.setSelectiveNimbleReaderEnabled(
-      connectorQueryCtx->selectiveNimbleReaderEnabled());
-
-  if (readerOptions.fileFormat() != dwio::common::FileFormat::UNKNOWN) {
-    VELOX_CHECK(
-        readerOptions.fileFormat() == hiveSplit->fileFormat,
-        "HiveDataSource received splits of different formats: {} and {}",
-        dwio::common::toString(readerOptions.fileFormat()),
-        dwio::common::toString(hiveSplit->fileFormat));
-  } else {
-    auto serDeOptions =
-        parseSerdeParameters(hiveSplit->serdeParameters, tableParameters);
+  // Check if format was UNKNOWN before the generic call, since the generic
+  // version will set it. Serde options should only be applied on the first
+  // call (when format transitions from UNKNOWN).
+  const bool formatWasUnknown =
+      readerOptions.fileFormat() == dwio::common::FileFormat::UNKNOWN;
+
+  // Call the generic version which handles everything except serde.
+  // Use fully qualified call to the generic overload (6 params, no serde).
+  hive::configureReaderOptions(
+      fileConfig,
+      connectorQueryCtx,
+      fileSchema,
+      fileSplit,
+      tableParameters,
+      readerOptions);
+
+  // Apply serde options on top (Hive-specific).
+  if (formatWasUnknown) {
+    auto serDeOptions = parseSerdeParameters(serdeParameters, tableParameters);
     if (serDeOptions) {
       readerOptions.setSerDeOptions(*serDeOptions);
     }
-
-    readerOptions.setFileFormat(hiveSplit->fileFormat);
   }
 }
 
@@ -609,151 +627,37 @@ void configureRowReaderOptions(
     const std::shared_ptr<common::ScanSpec>& scanSpec,
     std::shared_ptr<common::MetadataFilter> metadataFilter,
     const RowTypePtr& rowType,
-    const std::shared_ptr<const HiveConnectorSplit>& hiveSplit,
-    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const std::shared_ptr<const FileConnectorSplit>& fileSplit,
+    const std::unordered_map<std::string, std::string>& serdeParameters,
+    const std::shared_ptr<const FileConfig>& fileConfig,
     const config::ConfigBase* sessionProperties,
+    folly::Executor* const ioExecutor,
     dwio::common::RowReaderOptions& rowReaderOptions) {
-  auto skipRowsIt =
-      tableParameters.find(dwio::common::TableParameter::kSkipHeaderLineCount);
-  if (skipRowsIt != tableParameters.end()) {
-    rowReaderOptions.setSkipRows(folly::to<uint64_t>(skipRowsIt->second));
-  }
-  rowReaderOptions.setScanSpec(scanSpec);
-  rowReaderOptions.setMetadataFilter(std::move(metadataFilter));
-  rowReaderOptions.setRequestedType(rowType);
-  rowReaderOptions.range(hiveSplit->start, hiveSplit->length);
-  if (hiveConfig && sessionProperties) {
-    rowReaderOptions.setTimestampPrecision(static_cast<TimestampPrecision>(
-        hiveConfig->readTimestampUnit(sessionProperties)));
-    rowReaderOptions.setPreserveFlatMapsInMemory(
-        hiveConfig->preserveFlatMapsInMemory(sessionProperties));
-  }
-  rowReaderOptions.setSerdeParameters(hiveSplit->serdeParameters);
-}
-
-namespace {
-
-bool applyPartitionFilter(
-    const TypePtr& type,
-    const std::string& partitionValue,
-    bool isPartitionDateDaysSinceEpoch,
-    const common::Filter* filter,
-    bool asLocalTime) {
-  if (type->isDate()) {
-    int32_t result = 0;
-    // days_since_epoch partition values are integers in string format. Eg.
-    // Iceberg partition values.
-    if (isPartitionDateDaysSinceEpoch) {
-      result = folly::to<int32_t>(partitionValue);
-    } else {
-      result = DATE()->toDays(static_cast<folly::StringPiece>(partitionValue));
-    }
-    return applyFilter(*filter, result);
-  }
-
-  switch (type->kind()) {
-    case TypeKind::BIGINT:
-    case TypeKind::INTEGER:
-    case TypeKind::SMALLINT:
-    case TypeKind::TINYINT: {
-      return applyFilter(*filter, folly::to<int64_t>(partitionValue));
-    }
-    case TypeKind::REAL:
-    case TypeKind::DOUBLE: {
-      return applyFilter(*filter, folly::to<double>(partitionValue));
-    }
-    case TypeKind::BOOLEAN: {
-      return applyFilter(*filter, folly::to<bool>(partitionValue));
-    }
-    case TypeKind::TIMESTAMP: {
-      auto result = util::fromTimestampString(
-          StringView(partitionValue), util::TimestampParseMode::kPrestoCast);
-      VELOX_CHECK(!result.hasError());
-      if (asLocalTime) {
-        result.value().toGMT(Timestamp::defaultTimezone());
-      }
-      return applyFilter(*filter, result.value());
-    }
-    case TypeKind::VARCHAR: {
-      return applyFilter(*filter, partitionValue);
-    }
-    default:
-      VELOX_FAIL(
-          "Bad type {} for partition value: {}", type->kind(), partitionValue);
-  }
-}
-
-} // namespace
-
-bool testFilters(
-    const common::ScanSpec* scanSpec,
-    const dwio::common::Reader* reader,
-    const std::string& filePath,
-    const std::unordered_map<std::string, std::optional<std::string>>&
-        partitionKeys,
-    const std::unordered_map<std::string, HiveColumnHandlePtr>&
-        partitionKeysHandle,
-    bool asLocalTime) {
-  const auto totalRows = reader->numberOfRows();
-  const auto& fileTypeWithId = reader->typeWithId();
-  const auto& rowType = reader->rowType();
-  for (const auto& child : scanSpec->children()) {
-    if (child->filter()) {
-      const auto& name = child->fieldName();
-      auto iter = partitionKeys.find(name);
-      // By design, the partition key columns for Iceberg tables are included in
-      // the data files to facilitate partition transform and partition
-      // evolution, so we need to test both cases.
-      if (!rowType->containsChild(name) || iter != partitionKeys.end()) {
-        if (iter != partitionKeys.end() && iter->second.has_value()) {
-          const auto handlesIter = partitionKeysHandle.find(name);
-          VELOX_CHECK(handlesIter != partitionKeysHandle.end());
-
-          // This is a non-null partition key
-          return applyPartitionFilter(
-              handlesIter->second->dataType(),
-              iter->second.value(),
-              handlesIter->second->isPartitionDateValueDaysSinceEpoch(),
-              child->filter(),
-              asLocalTime);
-        }
-        // Column is missing, most likely due to schema evolution. Or it's a
-        // partition key but the partition value is NULL.
-        if (child->filter()->isDeterministic() &&
-            !child->filter()->testNull()) {
-          VLOG(1) << "Skipping " << filePath
-                  << " because the filter testNull() failed for column "
-                  << child->fieldName();
-          return false;
-        }
-      } else {
-        const auto& typeWithId = fileTypeWithId->childByName(name);
-        const auto columnStats = reader->columnStatistics(typeWithId->id());
-        if (columnStats != nullptr &&
-            !testFilter(
-                child->filter(),
-                columnStats.get(),
-                totalRows.value(),
-                typeWithId->type())) {
-          VLOG(1) << "Skipping " << filePath
-                  << " based on stats and filter for column "
-                  << child->fieldName();
-          return false;
-        }
-      }
-    }
-  }
-
-  return true;
+  // Call the generic version which handles everything except serde.
+  // Use fully qualified call to the generic overload (9 params, no serde).
+  hive::configureRowReaderOptions(
+      tableParameters,
+      scanSpec,
+      std::move(metadataFilter),
+      rowType,
+      fileSplit,
+      fileConfig,
+      sessionProperties,
+      ioExecutor,
+      rowReaderOptions);
+
+  // Apply serde parameters on top (Hive-specific).
+  rowReaderOptions.setSerdeParameters(serdeParameters);
 }
 
 std::unique_ptr<dwio::common::BufferedInput> createBufferedInput(
     const FileHandle& fileHandle,
     const dwio::common::ReaderOptions& readerOpts,
     const ConnectorQueryCtx* connectorQueryCtx,
-    std::shared_ptr<io::IoStatistics> ioStats,
-    std::shared_ptr<filesystems::File::IoStats> fsStats,
-    folly::Executor* executor) {
+    std::shared_ptr<io::IoStatistics> ioStatistics,
+    std::shared_ptr<IoStats> ioStats,
+    folly::Executor* executor,
+    const folly::F14FastMap<std::string, std::string>& fileReadOps) {
   if (connectorQueryCtx->cache()) {
     return std::make_unique<dwio::common::CachedBufferedInput>(
         fileHandle.file,
@@ -763,10 +667,11 @@ std::unique_ptr<dwio::common::BufferedInput> createBufferedInput(
         Connector::getTracker(
             connectorQueryCtx->scanId(), readerOpts.loadQuantum()),
         fileHandle.groupId,
-        ioStats,
-        std::move(fsStats),
+        ioStatistics,
+        std::move(ioStats),
         executor,
-        readerOpts);
+        readerOpts,
+        fileReadOps);
   }
   if (readerOpts.fileFormat() == dwio::common::FileFormat::NIMBLE) {
     // Nimble streams (in case of single chunk) are compressed as whole and need
@@ -777,8 +682,11 @@ std::unique_ptr<dwio::common::BufferedInput> createBufferedInput(
         fileHandle.file,
         readerOpts.memoryPool(),
         dwio::common::MetricsLog::voidLog(),
+        ioStatistics.get(),
         ioStats.get(),
-        fsStats.get());
+        dwio::common::BufferedInput::kMaxMergeDistance,
+        std::nullopt,
+        fileReadOps);
   }
   return std::make_unique<dwio::common::DirectBufferedInput>(
       fileHandle.file,
@@ -787,10 +695,11 @@ std::unique_ptr<dwio::common::BufferedInput> createBufferedInput(
       Connector::getTracker(
           connectorQueryCtx->scanId(), readerOpts.loadQuantum()),
       fileHandle.groupId,
+      std::move(ioStatistics),
       std::move(ioStats),
-      std::move(fsStats),
       executor,
-      readerOpts);
+      readerOpts,
+      fileReadOps);
 }
 
 namespace {
@@ -803,16 +712,7 @@ core::CallTypedExprPtr replaceInputs(
 }
 
 bool endWith(const std::string& str, const char* suffix) {
-  int len = strlen(suffix);
-  if (str.size() < len) {
-    return false;
-  }
-  for (int i = 0, j = str.size() - len; i < len; ++i, ++j) {
-    if (str[j] != suffix[i]) {
-      return false;
-    }
-  }
-  return true;
+  return str.ends_with(suffix);
 }
 
 bool isNotExpr(
@@ -860,8 +760,6 @@ double getPrestoSampleRate(
   return std::max(0.0, std::min(1.0, rate->value().value<double>()));
 }
 
-} // namespace
-
 core::TypedExprPtr extractFiltersFromRemainingFilter(
     const core::TypedExprPtr& expr,
     core::ExpressionEvaluator* evaluator,
@@ -874,10 +772,10 @@ core::TypedExprPtr extractFiltersFromRemainingFilter(
   }
   common::Filter* oldFilter = nullptr;
   try {
-    common::Subfield subfield;
-    if (auto filter = exec::ExprToSubfieldFilterParser::getInstance()
-                          ->leafCallToSubfieldFilter(
-                              *call, subfield, evaluator, negated)) {
+    if (auto subfieldAndFilter =
+            exec::ExprToSubfieldFilterParser::getInstance()
+                ->leafCallToSubfieldFilter(*call, evaluator, negated)) {
+      auto& [subfield, filter] = subfieldAndFilter.value();
       if (auto it = filters.find(subfield); it != filters.end()) {
         oldFilter = it->second.get();
         filter = filter->mergeWith(oldFilter);
@@ -899,20 +797,73 @@ core::TypedExprPtr extractFiltersFromRemainingFilter(
     return inner ? replaceInputs(call, {inner}) : nullptr;
   }
 
-  if ((call->name() == "and" && !negated) ||
-      (call->name() == "or" && negated)) {
-    auto lhs = extractFiltersFromRemainingFilter(
-        call->inputs()[0], evaluator, negated, filters, sampleRate);
-    auto rhs = extractFiltersFromRemainingFilter(
-        call->inputs()[1], evaluator, negated, filters, sampleRate);
-    if (!lhs) {
-      return rhs;
+  if ((call->name() == expression::kAnd && !negated) ||
+      (call->name() == expression::kOr && negated)) {
+    std::vector<core::TypedExprPtr> args;
+    args.reserve(call->inputs().size());
+    for (const auto& input : call->inputs()) {
+      if (auto arg = extractFiltersFromRemainingFilter(
+              input, evaluator, negated, filters, sampleRate)) {
+        args.push_back(std::move(arg));
+      }
+      // If extractFiltersFromRemainingFilter returns nullptr, it means
+      // everything in input is converted to filters.
+    }
+    if (args.empty()) {
+      return nullptr;
+    }
+    if (args.size() == 1) {
+      return std::move(args[0]);
+    }
+    return replaceInputs(call, std::move(args));
+  }
+
+  if ((call->name() == expression::kAnd && negated) ||
+      (call->name() == expression::kOr && !negated)) {
+    std::vector<std::unique_ptr<common::Filter>> disjuncts;
+    common::Subfield subfield;
+
+    for (const auto& input : call->inputs()) {
+      common::SubfieldFilters tmpFilters;
+      double tmpSampleRate = 1;
+      auto tmpRemaining = extractFiltersFromRemainingFilter(
+          input, evaluator, negated, tmpFilters, tmpSampleRate);
+
+      if (tmpRemaining != nullptr || tmpSampleRate != 1 ||
+          tmpFilters.size() != 1) {
+        disjuncts.clear();
+        break;
+      }
+
+      if (disjuncts.empty()) {
+        subfield = tmpFilters.begin()->first.clone();
+      } else if (!(subfield == tmpFilters.begin()->first)) {
+        disjuncts.clear();
+        break;
+      }
+
+      disjuncts.push_back(tmpFilters.begin()->second->clone());
     }
-    if (!rhs) {
-      return lhs;
+
+    if (!disjuncts.empty()) {
+      auto filter =
+          exec::ExprToSubfieldFilterParser::makeOrFilter(std::move(disjuncts));
+
+      if (filter == nullptr) {
+        return expr;
+      }
+
+      auto it = filters.find(subfield);
+      if (it != filters.end()) {
+        filter = filter->mergeWith(it->second.get());
+      }
+
+      filters.insert_or_assign(std::move(subfield), std::move(filter));
+
+      return nullptr;
     }
-    return replaceInputs(call, {lhs, rhs});
   }
+
   if (!negated) {
     double rate = getPrestoSampleRate(expr, call, evaluator);
     if (rate != -1) {
@@ -920,6 +871,118 @@ core::TypedExprPtr extractFiltersFromRemainingFilter(
       return nullptr;
     }
   }
+
   return expr;
 }
+} // namespace
+
+core::TypedExprPtr extractFiltersFromRemainingFilter(
+    const core::TypedExprPtr& expr,
+    core::ExpressionEvaluator* evaluator,
+    common::SubfieldFilters& filters,
+    double& sampleRate) {
+  return extractFiltersFromRemainingFilter(
+      expr, evaluator, /*negated=*/false, filters, sampleRate);
+}
+
+bool shouldEagerlyMaterialize(
+    const exec::Expr& remainingFilter,
+    const exec::FieldReference& field) {
+  const auto isMember = [](const std::vector<exec::FieldReference*>& fields,
+                           const exec::FieldReference& field) {
+    return std::find(fields.begin(), fields.end(), &field) != fields.end();
+  };
+
+  if (!remainingFilter.evaluatesArgumentsOnNonIncreasingSelection()) {
+    return true;
+  }
+  for (auto& input : remainingFilter.inputs()) {
+    if (isMember(input->distinctFields(), field) && input->hasConditionals()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+namespace {
+template <TypeKind kind>
+std::unique_ptr<common::Filter> createRangeFilterInternal(
+    const variant& lower,
+    const variant& upper) {
+  using T = typename TypeTraits<kind>::NativeType;
+  const bool lowerUnbounded = lower.isNull();
+  const bool upperUnbounded = upper.isNull();
+
+  if constexpr (
+      kind == TypeKind::TINYINT || kind == TypeKind::SMALLINT ||
+      kind == TypeKind::INTEGER || kind == TypeKind::BIGINT) {
+    return std::make_unique<common::BigintRange>(
+        lowerUnbounded ? std::numeric_limits<int64_t>::min() : lower.value<T>(),
+        upperUnbounded ? std::numeric_limits<int64_t>::max() : upper.value<T>(),
+        /*nullAllowed=*/false);
+  } else if constexpr (kind == TypeKind::REAL) {
+    return std::make_unique<common::FloatRange>(
+        lowerUnbounded ? std::numeric_limits<float>::lowest()
+                       : lower.value<T>(),
+        lowerUnbounded,
+        /*lowerExclusive=*/false,
+        upperUnbounded ? std::numeric_limits<float>::max() : upper.value<T>(),
+        upperUnbounded,
+        /*upperExclusive=*/false,
+        /*nullAllowed=*/false);
+  } else if constexpr (kind == TypeKind::DOUBLE) {
+    return std::make_unique<common::DoubleRange>(
+        lowerUnbounded ? std::numeric_limits<double>::lowest()
+                       : lower.value<T>(),
+        lowerUnbounded,
+        /*lowerExclusive=*/false,
+        upperUnbounded ? std::numeric_limits<double>::max() : upper.value<T>(),
+        upperUnbounded,
+        /*upperExclusive=*/false,
+        /*nullAllowed=*/false);
+  } else if constexpr (
+      kind == TypeKind::VARCHAR || kind == TypeKind::VARBINARY) {
+    return std::make_unique<common::BytesRange>(
+        lowerUnbounded ? "" : std::string(lower.value<StringView>()),
+        lowerUnbounded,
+        /*lowerExclusive=*/false,
+        upperUnbounded ? "" : std::string(upper.value<StringView>()),
+        upperUnbounded,
+        /*upperExclusive=*/false,
+        /*nullAllowed=*/false);
+  } else if constexpr (kind == TypeKind::BOOLEAN) {
+    VELOX_CHECK(
+        !lowerUnbounded && !upperUnbounded,
+        "Boolean range filter requires both bounds");
+    return std::make_unique<common::BoolValue>(
+        lower.value<T>(), /*nullAllowed=*/false);
+  } else {
+    VELOX_UNSUPPORTED(
+        "Unsupported type kind for filter creation: {}",
+        TypeKindName::toName(kind));
+  }
+}
+} // namespace
+
+std::unique_ptr<common::Filter> createPointFilter(
+    const TypePtr& type,
+    const variant& value) {
+  VELOX_CHECK(!value.isNull(), "Value cannot be null");
+
+  return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+      createRangeFilterInternal, type->kind(), value, value);
+}
+
+std::unique_ptr<common::Filter> createRangeFilter(
+    const TypePtr& type,
+    const variant& lower,
+    const variant& upper) {
+  VELOX_CHECK(
+      !lower.isNull() || !upper.isNull(),
+      "At least one of lower or upper bound must be set");
+
+  return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+      createRangeFilterInternal, type->kind(), lower, upper);
+}
+
 } // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HiveConnectorUtil.h b/velox/connectors/hive/HiveConnectorUtil.h
index d649b12d093..191e03186ab 100644
--- a/velox/connectors/hive/HiveConnectorUtil.h
+++ b/velox/connectors/hive/HiveConnectorUtil.h
@@ -15,13 +15,15 @@
  */
 
 #pragma once
-#include <folly/Executor.h>
 #include <folly/container/F14Map.h>
 
-#include "velox/connectors/Connector.h"
-#include "velox/connectors/hive/FileHandle.h"
+#include "velox/connectors/hive/FileConnectorUtil.h"
 #include "velox/dwio/common/BufferedInput.h"
-#include "velox/dwio/common/Reader.h"
+
+namespace facebook::velox::exec {
+class Expr;
+class FieldReference;
+} // namespace facebook::velox::exec
 
 namespace facebook::velox::connector::hive {
 
@@ -32,13 +34,11 @@ struct HiveConnectorSplit;
 
 const std::string& getColumnName(const common::Subfield& subfield);
 
-void checkColumnNameLowerCase(const std::shared_ptr<const Type>& type);
+void checkColumnNameLowerCase(const TypePtr& type);
 
 void checkColumnNameLowerCase(
     const common::SubfieldFilters& filters,
-    const std::unordered_map<
-        std::string,
-        std::shared_ptr<const HiveColumnHandle>>& infoColumns);
+    const std::unordered_map<std::string, FileColumnHandlePtr>& infoColumns);
 
 void checkColumnNameLowerCase(const core::TypedExprPtr& typeExpr);
 
@@ -47,35 +47,84 @@ struct SpecialColumnNames {
   std::optional<std::string> rowId;
 };
 
+/// Check that two FileColumnHandle instances are consistent in terms of
+/// column type, data type, and file type. Throw if inconsistent.
+void checkColumnHandleConsistent(
+    const FileColumnHandle& x,
+    const FileColumnHandle& y);
+
+/// Creates a ScanSpec for reading data from a Hive table.
+///
+/// The ScanSpec describes which columns to read and what filters to apply.
+/// It handles several types of columns:
+/// - Regular data columns from the file
+/// - Partition key columns (values from file path)
+/// - Synthesized columns (e.g., $path, $bucket)
+/// - Special columns (e.g., row index, row ID)
+/// - Index columns for index lookup joins
+///
+/// @param rowType Schema of columns to be projected in the output.
+/// @param outputSubfields Map of column names to subfields that need to be
+///     read. Used for pruning nested structures.
+/// @param subfieldFilters Map of subfields to filters to apply during scan.
+/// @param indexColumns Column names used for index lookup joins. These columns
+///     are added to the scan spec even if they are not in the output
+///     projection, ensuring they are read from the file for join key matching.
+/// @param dataColumns Full schema of all columns in the data file. Used to
+///     look up column types when a column is referenced in filters or index
+///     columns but not in the output projection.
+/// @param partitionKeys Map of partition column names to their handles.
+///     Partition columns are not read from the file.
+/// @param infoColumns Map of synthesized column names (e.g., $path) to their
+///     handles.
+/// @param specialColumns Names of special columns like row index and row ID.
+/// @param disableStatsBasedFilterReorder If true, disables reordering of
+///     filters based on statistics.
+/// @param pool Memory pool for allocations during scan spec construction.
+/// @return A ScanSpec that can be used to configure a reader.
 std::shared_ptr<common::ScanSpec> makeScanSpec(
     const RowTypePtr& rowType,
     const folly::F14FastMap<std::string, std::vector<const common::Subfield*>>&
         outputSubfields,
-    const common::SubfieldFilters& filters,
+    const common::SubfieldFilters& subfieldFilters,
+    const RowTypePtr& dataColumns,
+    const std::unordered_map<std::string, FileColumnHandlePtr>& partitionKeys,
+    const std::unordered_map<std::string, FileColumnHandlePtr>& infoColumns,
+    const SpecialColumnNames& specialColumns,
+    bool disableStatsBasedFilterReorder,
+    memory::MemoryPool* pool);
+
+/// @deprecated Use the overload without indexColumns parameter instead.
+/// This overload is kept for backward compatibility and will be removed in a
+/// future release.
+std::shared_ptr<common::ScanSpec> makeScanSpec(
+    const RowTypePtr& rowType,
+    const folly::F14FastMap<std::string, std::vector<const common::Subfield*>>&
+        outputSubfields,
+    const common::SubfieldFilters& subfieldFilters,
+    const std::vector<std::string>& indexColumns,
     const RowTypePtr& dataColumns,
-    const std::unordered_map<
-        std::string,
-        std::shared_ptr<const HiveColumnHandle>>& partitionKeys,
-    const std::unordered_map<
-        std::string,
-        std::shared_ptr<const HiveColumnHandle>>& infoColumns,
+    const std::unordered_map<std::string, FileColumnHandlePtr>& partitionKeys,
+    const std::unordered_map<std::string, FileColumnHandlePtr>& infoColumns,
     const SpecialColumnNames& specialColumns,
     bool disableStatsBasedFilterReorder,
     memory::MemoryPool* pool);
 
 void configureReaderOptions(
-    const std::shared_ptr<const HiveConfig>& config,
+    const std::shared_ptr<const FileConfig>& config,
     const ConnectorQueryCtx* connectorQueryCtx,
-    const std::shared_ptr<const HiveTableHandle>& hiveTableHandle,
-    const std::shared_ptr<const HiveConnectorSplit>& hiveSplit,
+    const FileTableHandlePtr& tableHandle,
+    const std::shared_ptr<const FileConnectorSplit>& fileSplit,
+    const std::unordered_map<std::string, std::string>& serdeParameters,
     dwio::common::ReaderOptions& readerOptions);
 
 void configureReaderOptions(
-    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const std::shared_ptr<const FileConfig>& fileConfig,
     const ConnectorQueryCtx* connectorQueryCtx,
     const RowTypePtr& fileSchema,
-    const std::shared_ptr<const HiveConnectorSplit>& hiveSplit,
+    const std::shared_ptr<const FileConnectorSplit>& fileSplit,
     const std::unordered_map<std::string, std::string>& tableParameters,
+    const std::unordered_map<std::string, std::string>& serdeParameters,
     dwio::common::ReaderOptions& readerOptions);
 
 void configureRowReaderOptions(
@@ -83,35 +132,107 @@ void configureRowReaderOptions(
     const std::shared_ptr<common::ScanSpec>& scanSpec,
     std::shared_ptr<common::MetadataFilter> metadataFilter,
     const RowTypePtr& rowType,
-    const std::shared_ptr<const HiveConnectorSplit>& hiveSplit,
-    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const std::shared_ptr<const FileConnectorSplit>& fileSplit,
+    const std::unordered_map<std::string, std::string>& serdeParameters,
+    const std::shared_ptr<const FileConfig>& fileConfig,
     const config::ConfigBase* sessionProperties,
+    folly::Executor* ioExecutor,
     dwio::common::RowReaderOptions& rowReaderOptions);
 
-bool testFilters(
-    const common::ScanSpec* scanSpec,
-    const dwio::common::Reader* reader,
-    const std::string& filePath,
-    const std::unordered_map<std::string, std::optional<std::string>>&
-        partitionKey,
-    const std::unordered_map<
-        std::string,
-        std::shared_ptr<const HiveColumnHandle>>& partitionKeysHandle,
-    bool asLocalTime);
-
 std::unique_ptr<dwio::common::BufferedInput> createBufferedInput(
     const FileHandle& fileHandle,
     const dwio::common::ReaderOptions& readerOpts,
     const ConnectorQueryCtx* connectorQueryCtx,
-    std::shared_ptr<io::IoStatistics> ioStats,
-    std::shared_ptr<filesystems::File::IoStats> fsStats,
-    folly::Executor* executor);
-
+    std::shared_ptr<io::IoStatistics> ioStatistics,
+    std::shared_ptr<IoStats> ioStats,
+    folly::Executor* executor,
+    const folly::F14FastMap<std::string, std::string>& fileReadOps = {});
+
+/// Given a boolean expression, breaks it up into conjuncts and sorts these into
+/// single-column comparisons with constants (filters), rand() < sampleRate, and
+/// the rest (return value).
+///
+/// Multiple rand() < K conjuncts are combined into a single sampleRate by
+/// multiplying individual sample rates. rand() < 0.1 and rand() < 0.2 produces
+/// sampleRate = 0.02.
+///
+/// Multiple single-column comparisons with constants that reference the same
+/// column or subfield are combined into a single filter. Pre-existing entries
+/// in 'filters' are preserved and combined with the ones extracted from the
+/// 'expr'.
+///
+/// NOT(x OR y) is converted to (NOT x) AND (NOT y).
+///
+/// @param expr Boolean expression to break up.
+/// @param evaluator Expression evaluator to use.
+/// @param filters Mapping from a column or a subfield to comparison with
+/// constant.
+/// @param sampleRate Sample rate extracted from rand() < sampleRate conjuncts.
+/// @return Expression with filters and rand() < sampleRate conjuncts removed.
+///
+/// Examples:
+///   expr := a = 1 AND b > 0
+///   filters := {a: eq(1), b: gt(0)}
+//    sampleRate left unmodified
+//    return value is nullptr
+///
+///   expr: not (a > 0 or b > 10)
+///   filters := {a: le(0), b: le(10)}
+///   sampleRate left unmodified
+///   return value is nullptr
+///
+///   expr := a > 0 AND a < b AND rand() < 0.1
+///   filters := {a: gt(0)}
+///   sampleRate := 0.1
+///   return value is a < b
 core::TypedExprPtr extractFiltersFromRemainingFilter(
     const core::TypedExprPtr& expr,
     core::ExpressionEvaluator* evaluator,
-    bool negated,
     common::SubfieldFilters& filters,
     double& sampleRate);
 
+/// Determines whether a field referenced in the remaining filter should be
+/// eagerly materialized (loaded upfront) or can be lazily loaded.
+///
+/// Returns true (eager materialization needed) when:
+/// 1. The remaining filter is NOT an AND expression (e.g., OR), because row
+///    access patterns are unpredictable.
+/// 2. The field is used within a conditional sub-expression (IF, CASE, nested
+///    AND/OR) of an AND expression, because the conditional may access rows
+///    unpredictably.
+///
+/// Returns false (lazy loading OK) when the remaining filter is an AND
+/// expression and the field is only used in simple, non-conditional conjuncts.
+///
+/// @param remainingFilter The compiled remaining filter expression.
+/// @param field The field reference to check.
+/// @return true if the field should be eagerly materialized.
+bool shouldEagerlyMaterialize(
+    const exec::Expr& remainingFilter,
+    const exec::FieldReference& field);
+
+/// Creates a point lookup filter from a variant value.
+/// Null values are not allowed.
+/// Supports TINYINT, SMALLINT, INTEGER, BIGINT, REAL, DOUBLE, BOOLEAN,
+/// VARCHAR, and VARBINARY types.
+/// @param type The type of the value.
+/// @param value The filter value (must not be null).
+/// @return A filter for point lookup, or nullptr if type is not supported.
+std::unique_ptr<common::Filter> createPointFilter(
+    const TypePtr& type,
+    const variant& value);
+
+/// Creates a range filter from two variant values.
+/// Both lower and upper bounds are inclusive. Null values are not allowed.
+/// Supports TINYINT, SMALLINT, INTEGER, BIGINT, REAL, DOUBLE, VARCHAR,
+/// and VARBINARY types.
+/// @param type The type of the values.
+/// @param lower The lower bound value.
+/// @param upper The upper bound value.
+/// @return A filter for range lookup, or nullptr if type is not supported.
+std::unique_ptr<common::Filter> createRangeFilter(
+    const TypePtr& type,
+    const variant& lower,
+    const variant& upper);
+
 } // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HiveDataSink.cpp b/velox/connectors/hive/HiveDataSink.cpp
index 36c797e4eaf..f627df624ed 100644
--- a/velox/connectors/hive/HiveDataSink.cpp
+++ b/velox/connectors/hive/HiveDataSink.cpp
@@ -19,21 +19,17 @@
 #include "velox/common/base/Counters.h"
 #include "velox/common/base/Fs.h"
 #include "velox/common/base/StatsReporter.h"
-#include "velox/common/testutil/TestValue.h"
 #include "velox/connectors/hive/HiveConfig.h"
-#include "velox/connectors/hive/HiveConnectorUtil.h"
 #include "velox/connectors/hive/HivePartitionFunction.h"
 #include "velox/connectors/hive/TableHandle.h"
 #include "velox/dwio/common/Options.h"
 #include "velox/dwio/common/SortingWriter.h"
-#include "velox/exec/OperatorUtils.h"
 #include "velox/exec/SortBuffer.h"
 
 #include <boost/lexical_cast.hpp>
 #include <boost/uuid/uuid_generators.hpp>
 #include <boost/uuid/uuid_io.hpp>
-
-using facebook::velox::common::testutil::TestValue;
+#include <re2/re2.h>
 
 namespace facebook::velox::connector::hive {
 namespace {
@@ -41,72 +37,67 @@ namespace {
   memory::NonReclaimableSectionGuard nonReclaimableGuard( \
       writerInfo_[(index)]->nonReclaimableSectionHolder.get())
 
-// Returns the type of non-partition data columns.
-RowTypePtr getNonPartitionTypes(
-    const std::vector<column_index_t>& dataCols,
-    const RowTypePtr& inputType) {
-  std::vector<std::string> childNames;
-  std::vector<TypePtr> childTypes;
-  const auto& dataSize = dataCols.size();
-  childNames.reserve(dataSize);
-  childTypes.reserve(dataSize);
-  for (int dataCol : dataCols) {
-    childNames.push_back(inputType->nameOf(dataCol));
-    childTypes.push_back(inputType->childAt(dataCol));
-  }
-
-  return ROW(std::move(childNames), std::move(childTypes));
-}
-
-// Filters out partition columns if there is any.
-RowVectorPtr makeDataInput(
-    const std::vector<column_index_t>& dataCols,
-    const RowVectorPtr& input) {
-  std::vector<VectorPtr> childVectors;
-  childVectors.reserve(dataCols.size());
-  for (int dataCol : dataCols) {
-    childVectors.push_back(input->childAt(dataCol));
-  }
-
-  return std::make_shared<RowVector>(
-      input->pool(),
-      getNonPartitionTypes(dataCols, asRowType(input->type())),
-      input->nulls(),
-      input->size(),
-      std::move(childVectors),
-      input->getNullCount());
+// Appends a sequence number to a filename for file rotation.
+// Returns the original filename if sequenceNumber is 0 (no rotation yet).
+// Example: "file.orc" with seq 0 remains "file.orc"
+// Example: "file.orc" with seq 2 becomes "file_2.orc"
+std::string makeSequencedFileName(
+    const std::string& filename,
+    uint32_t sequenceNumber) {
+  if (sequenceNumber == 0) {
+    return filename;
+  }
+  const auto dotPos = filename.rfind('.');
+  if (dotPos == std::string::npos) {
+    // No extension, just append the sequence number
+    return fmt::format("{}_{}", filename, sequenceNumber);
+  }
+  // Insert sequence number before the extension
+  return fmt::format(
+      "{}_{}{}",
+      filename.substr(0, dotPos),
+      sequenceNumber,
+      filename.substr(dotPos));
 }
 
-// Returns a subset of column indices corresponding to partition keys.
-std::vector<column_index_t> getPartitionChannels(
-    const std::shared_ptr<const HiveInsertTableHandle>& insertTableHandle) {
-  std::vector<column_index_t> channels;
-
-  for (column_index_t i = 0; i < insertTableHandle->inputColumns().size();
-       i++) {
-    if (insertTableHandle->inputColumns()[i]->isPartitionKey()) {
-      channels.push_back(i);
-    }
-  }
-
-  return channels;
+std::unique_ptr<dwio::common::FileSink> createHiveFileSink(
+    const std::string& path,
+    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    memory::MemoryPool* sinkPool,
+    io::IoStatistics* ioStats,
+    IoStats* fileSystemStats,
+    const std::unordered_map<std::string, std::string>& storageParameters) {
+  return dwio::common::FileSink::create(
+      path,
+      {
+          .bufferWrite = false,
+          .connectorProperties = hiveConfig->config(),
+          .fileCreateConfig = hiveConfig->writeFileCreateConfig(),
+          .pool = sinkPool,
+          .metricLogger = dwio::common::MetricsLog::voidLog(),
+          .stats = ioStats,
+          .fileSystemStats = fileSystemStats,
+          .storageParameters = storageParameters,
+      });
 }
 
-// Returns the column indices of non-partition data columns.
-std::vector<column_index_t> getNonPartitionChannels(
-    const std::vector<column_index_t>& partitionChannels,
-    const column_index_t childrenSize) {
-  std::vector<column_index_t> dataChannels;
-  dataChannels.reserve(childrenSize - partitionChannels.size());
-
-  for (column_index_t i = 0; i < childrenSize; i++) {
-    if (std::find(partitionChannels.cbegin(), partitionChannels.cend(), i) ==
-        partitionChannels.cend()) {
-      dataChannels.push_back(i);
-    }
+// Creates a PartitionIdGenerator if the table is partitioned, otherwise returns
+// nullptr.
+std::unique_ptr<PartitionIdGenerator> createPartitionIdGenerator(
+    const RowTypePtr& inputType,
+    const std::shared_ptr<const HiveInsertTableHandle>& insertTableHandle,
+    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const ConnectorQueryCtx* connectorQueryCtx) {
+  auto partitionChannels = insertTableHandle->partitionChannels();
+  if (partitionChannels.empty()) {
+    return nullptr;
   }
-
-  return dataChannels;
+  return std::make_unique<PartitionIdGenerator>(
+      inputType,
+      partitionChannels,
+      hiveConfig->maxPartitionsPerWriters(
+          connectorQueryCtx->sessionProperties()),
+      connectorQueryCtx->memoryPool());
 }
 
 std::string makePartitionDirectory(
@@ -174,16 +165,6 @@ std::string computeBucketedFileName(
       "0{:0>{}}_0_{}", bucketValueStr, kMaxBucketCountPadding, queryId);
 }
 
-std::shared_ptr<memory::MemoryPool> createSinkPool(
-    const std::shared_ptr<memory::MemoryPool>& writerPool) {
-  return writerPool->addLeafChild(fmt::format("{}.sink", writerPool->name()));
-}
-
-std::shared_ptr<memory::MemoryPool> createSortPool(
-    const std::shared_ptr<memory::MemoryPool>& writerPool) {
-  return writerPool->addLeafChild(fmt::format("{}.sort", writerPool->name()));
-}
-
 uint64_t getFinishTimeSliceLimitMsFromHiveConfig(
     const std::shared_ptr<const HiveConfig>& config,
     const config::ConfigBase* sessions) {
@@ -200,32 +181,31 @@ FOLLY_ALWAYS_INLINE int32_t
 getBucketCount(const HiveBucketProperty* bucketProperty) {
   return bucketProperty == nullptr ? 0 : bucketProperty->bucketCount();
 }
-} // namespace
-
-const HiveWriterId& HiveWriterId::unpartitionedId() {
-  static const HiveWriterId writerId{0};
-  return writerId;
-}
 
-std::string HiveWriterId::toString() const {
-  if (partitionId.has_value() && bucketId.has_value()) {
-    return fmt::format("part[{}.{}]", partitionId.value(), bucketId.value());
-  }
-
-  if (partitionId.has_value() && !bucketId.has_value()) {
-    return fmt::format("part[{}]", partitionId.value());
+std::vector<column_index_t> computePartitionChannels(
+    const std::vector<std::shared_ptr<const HiveColumnHandle>>& inputColumns) {
+  std::vector<column_index_t> channels;
+  for (auto i = 0; i < inputColumns.size(); i++) {
+    if (inputColumns[i]->isPartitionKey()) {
+      channels.push_back(i);
+    }
   }
+  return channels;
+}
 
-  // This WriterId is used to add an identifier in the MemoryPools. This could
-  // indicate unpart, but the bucket number needs to be disambiguated. So
-  // creating a new label using bucket.
-  if (!partitionId.has_value() && bucketId.has_value()) {
-    return fmt::format("bucket[{}]", bucketId.value());
+std::vector<column_index_t> computeNonPartitionChannels(
+    const std::vector<std::shared_ptr<const HiveColumnHandle>>& inputColumns) {
+  std::vector<column_index_t> channels;
+  for (auto i = 0; i < inputColumns.size(); i++) {
+    if (!inputColumns[i]->isPartitionKey()) {
+      channels.push_back(i);
+    }
   }
-
-  return "unpart";
+  return channels;
 }
 
+} // namespace
+
 const std::string LocationHandle::tableTypeName(
     LocationHandle::TableType type) {
   static const auto tableTypes = tableTypeNames();
@@ -365,6 +345,54 @@ std::string HiveBucketProperty::toString() const {
   return out.str();
 }
 
+HiveInsertTableHandle::HiveInsertTableHandle(
+    std::vector<std::shared_ptr<const HiveColumnHandle>> inputColumns,
+    std::shared_ptr<const LocationHandle> locationHandle,
+    dwio::common::FileFormat storageFormat,
+    std::shared_ptr<const HiveBucketProperty> bucketProperty,
+    std::optional<common::CompressionKind> compressionKind,
+    const std::unordered_map<std::string, std::string>& serdeParameters,
+    const std::shared_ptr<dwio::common::WriterOptions>& writerOptions,
+    // When this option is set the HiveDataSink will always write a file even
+    // if there's no data. This is useful when the table is bucketed, but the
+    // engine handles ensuring a 1 to 1 mapping from task to bucket.
+    const bool ensureFiles,
+    std::shared_ptr<const FileNameGenerator> fileNameGenerator,
+    const std::unordered_map<std::string, std::string>& storageParameters)
+    : inputColumns_(std::move(inputColumns)),
+      locationHandle_(std::move(locationHandle)),
+      storageFormat_(storageFormat),
+      bucketProperty_(std::move(bucketProperty)),
+      compressionKind_(compressionKind),
+      serdeParameters_(serdeParameters),
+      writerOptions_(writerOptions),
+      ensureFiles_(ensureFiles),
+      fileNameGenerator_(std::move(fileNameGenerator)),
+      storageParameters_(storageParameters),
+      partitionChannels_(computePartitionChannels(inputColumns_)),
+      nonPartitionChannels_(computeNonPartitionChannels(inputColumns_)) {
+  if (compressionKind.has_value()) {
+    VELOX_CHECK(
+        compressionKind.value() != common::CompressionKind_MAX,
+        "Unsupported compression type: CompressionKind_MAX");
+  }
+
+  if (ensureFiles_) {
+    // If ensureFiles is set and either the bucketProperty is set or some
+    // partition keys are in the data, there is not a 1:1 mapping from Task to
+    // files so we can't proactively create writers.
+    VELOX_CHECK(
+        bucketProperty_ == nullptr || bucketProperty_->bucketCount() == 0,
+        "ensureFiles is not supported with bucketing");
+
+    for (const auto& inputColumn : inputColumns_) {
+      VELOX_CHECK(
+          !inputColumn->isPartitionKey(),
+          "ensureFiles is not supported with partition keys in the data");
+    }
+  }
+}
+
 HiveDataSink::HiveDataSink(
     RowTypePtr inputType,
     std::shared_ptr<const HiveInsertTableHandle> insertTableHandle,
@@ -382,7 +410,14 @@ HiveDataSink::HiveDataSink(
               ? createBucketFunction(
                     *insertTableHandle->bucketProperty(),
                     inputType)
-              : nullptr) {}
+              : nullptr,
+          insertTableHandle->partitionChannels(),
+          insertTableHandle->nonPartitionChannels(),
+          createPartitionIdGenerator(
+              inputType,
+              insertTableHandle,
+              hiveConfig,
+              connectorQueryCtx)) {}
 
 HiveDataSink::HiveDataSink(
     RowTypePtr inputType,
@@ -391,38 +426,35 @@ HiveDataSink::HiveDataSink(
     CommitStrategy commitStrategy,
     const std::shared_ptr<const HiveConfig>& hiveConfig,
     uint32_t bucketCount,
-    std::unique_ptr<core::PartitionFunction> bucketFunction)
-    : inputType_(std::move(inputType)),
+    std::unique_ptr<core::PartitionFunction> bucketFunction,
+    const std::vector<column_index_t>& partitionChannels,
+    const std::vector<column_index_t>& dataChannels,
+    std::unique_ptr<PartitionIdGenerator> partitionIdGenerator)
+    : FileDataSink(
+          std::move(inputType),
+          connectorQueryCtx,
+          commitStrategy,
+          insertTableHandle->storageFormat(),
+          hiveConfig->maxPartitionsPerWriters(
+              connectorQueryCtx->sessionProperties()),
+          partitionChannels,
+          dataChannels,
+          static_cast<int32_t>(bucketCount),
+          std::move(bucketFunction),
+          std::move(partitionIdGenerator),
+          dwio::common::getWriterFactory(insertTableHandle->storageFormat()),
+          hiveConfig->maxTargetFileSizeBytes(
+              connectorQueryCtx->sessionProperties()),
+          hiveConfig->isPartitionPathAsLowerCase(
+              connectorQueryCtx->sessionProperties()),
+          connectorQueryCtx->spillConfig(),
+          getFinishTimeSliceLimitMsFromHiveConfig(
+              hiveConfig,
+              connectorQueryCtx->sessionProperties())),
       insertTableHandle_(std::move(insertTableHandle)),
-      connectorQueryCtx_(connectorQueryCtx),
-      commitStrategy_(commitStrategy),
       hiveConfig_(hiveConfig),
       updateMode_(getUpdateMode()),
-      maxOpenWriters_(hiveConfig_->maxPartitionsPerWriters(
-          connectorQueryCtx->sessionProperties())),
-      partitionChannels_(getPartitionChannels(insertTableHandle_)),
-      partitionIdGenerator_(
-          !partitionChannels_.empty()
-              ? std::make_unique<PartitionIdGenerator>(
-                    inputType_,
-                    partitionChannels_,
-                    maxOpenWriters_,
-                    connectorQueryCtx_->memoryPool(),
-                    hiveConfig_->isPartitionPathAsLowerCase(
-                        connectorQueryCtx->sessionProperties()))
-              : nullptr),
-      dataChannels_(
-          getNonPartitionChannels(partitionChannels_, inputType_->size())),
-      bucketCount_(static_cast<int32_t>(bucketCount)),
-      bucketFunction_(std::move(bucketFunction)),
-      writerFactory_(
-          dwio::common::getWriterFactory(insertTableHandle_->storageFormat())),
-      spillConfig_(connectorQueryCtx->spillConfig()),
-      sortWriterFinishTimeSliceLimitMs_(getFinishTimeSliceLimitMsFromHiveConfig(
-          hiveConfig_,
-          connectorQueryCtx->sessionProperties())),
       fileNameGenerator_(insertTableHandle_->fileNameGenerator()) {
-  fileSystemStats_ = std::make_unique<filesystems::File::IoStats>();
   if (isBucketed()) {
     VELOX_USER_CHECK_LT(
         bucketCount_,
@@ -439,7 +471,7 @@ HiveDataSink::HiveDataSink(
     VELOX_CHECK(
         !isPartitioned() && !isBucketed(),
         "ensureFiles is not supported with bucketing or partition keys in the data");
-    ensureWriter(HiveWriterId::unpartitionedId());
+    ensureWriter(WriterId::unpartitionedId());
   }
 
   if (!isBucketed()) {
@@ -462,6 +494,7 @@ HiveDataSink::HiveDataSink(
              CompareFlags::NullHandlingMode::kNullAsValue});
       }
     }
+    sortWrite_ = !sortColumnIndices_.empty();
   }
 }
 
@@ -472,69 +505,6 @@ bool HiveDataSink::canReclaim() const {
        insertTableHandle_->storageFormat() == dwio::common::FileFormat::NIMBLE);
 }
 
-void HiveDataSink::appendData(RowVectorPtr input) {
-  checkRunning();
-
-  // Lazy load all the input columns.
-  input->loadedVector();
-
-  // Write to unpartitioned (and unbucketed) table.
-  if (!isPartitioned() && !isBucketed()) {
-    const auto index = ensureWriter(HiveWriterId::unpartitionedId());
-    write(index, input);
-    return;
-  }
-
-  // Compute partition and bucket numbers.
-  computePartitionAndBucketIds(input);
-
-  // All inputs belong to a single non-bucketed partition. The partition id
-  // must be zero.
-  if (!isBucketed() && partitionIdGenerator_->numPartitions() == 1) {
-    const auto index = ensureWriter(HiveWriterId{0});
-    write(index, input);
-    return;
-  }
-
-  splitInputRowsAndEnsureWriters();
-
-  for (auto index = 0; index < writers_.size(); ++index) {
-    const vector_size_t partitionSize = partitionSizes_[index];
-    if (partitionSize == 0) {
-      continue;
-    }
-
-    RowVectorPtr writerInput = partitionSize == input->size()
-        ? input
-        : exec::wrap(partitionSize, partitionRows_[index], input);
-    write(index, writerInput);
-  }
-}
-
-void HiveDataSink::write(size_t index, RowVectorPtr input) {
-  WRITER_NON_RECLAIMABLE_SECTION_GUARD(index);
-  auto dataInput = makeDataInput(dataChannels_, input);
-
-  writers_[index]->write(dataInput);
-  writerInfo_[index]->inputSizeInBytes += dataInput->estimateFlatSize();
-  writerInfo_[index]->numWrittenRows += dataInput->size();
-}
-
-std::string HiveDataSink::stateString(State state) {
-  switch (state) {
-    case State::kRunning:
-      return "RUNNING";
-    case State::kFinishing:
-      return "FLUSHING";
-    case State::kClosed:
-      return "CLOSED";
-    case State::kAborted:
-      return "ABORTED";
-    default:
-      VELOX_UNREACHABLE("BAD STATE: {}", static_cast<int>(state));
-  }
-}
-
 void HiveDataSink::computePartitionAndBucketIds(const RowVectorPtr& input) {
   VELOX_CHECK(isPartitioned() || isBucketed());
   if (isPartitioned()) {
@@ -561,59 +531,8 @@ void HiveDataSink::computePartitionAndBucketIds(const RowVectorPtr& input) {
   }
 }
 
-DataSink::Stats HiveDataSink::stats() const {
-  Stats stats;
-  if (state_ == State::kAborted) {
-    return stats;
-  }
-
-  int64_t numWrittenBytes{0};
-  int64_t writeIOTimeUs{0};
-  for (const auto& ioStats : ioStats_) {
-    numWrittenBytes += ioStats->rawBytesWritten();
-    writeIOTimeUs += ioStats->writeIOTimeUs();
-  }
-  stats.numWrittenBytes = numWrittenBytes;
-  stats.writeIOTimeUs = writeIOTimeUs;
-
-  if (state_ != State::kClosed) {
-    return stats;
-  }
-
-  stats.numWrittenFiles = writers_.size();
-  for (int i = 0; i < writerInfo_.size(); ++i) {
-    const auto& info = writerInfo_.at(i);
-    VELOX_CHECK_NOT_NULL(info);
-    const auto spillStats = info->spillStats->rlock();
-    if (!spillStats->empty()) {
-      stats.spillStats += *spillStats;
-    }
-  }
-  return stats;
-}
-
-std::unordered_map<std::string, RuntimeCounter> HiveDataSink::runtimeStats()
-    const {
-  std::unordered_map<std::string, RuntimeCounter> runtimeStats;
-
-  const auto fsStatsMap = fileSystemStats_->stats();
-  for (const auto& [statName, statValue] : fsStatsMap) {
-    runtimeStats.emplace(
-        statName, RuntimeCounter(statValue.sum, statValue.unit));
-  }
-
-  return runtimeStats;
-}
-
-std::shared_ptr<memory::MemoryPool> HiveDataSink::createWriterPool(
-    const HiveWriterId& writerId) {
-  auto* connectorPool = connectorQueryCtx_->connectorMemoryPool();
-  return connectorPool->addAggregateChild(
-      fmt::format("{}.{}", connectorPool->name(), writerId.toString()));
-}
-
 void HiveDataSink::setMemoryReclaimers(
-    HiveWriterInfo* writerInfo,
+    WriterInfo* writerInfo,
     io::IoStatistics* ioStats) {
   auto* connectorPool = connectorQueryCtx_->connectorMemoryPool();
   if (connectorPool->reclaimer() == nullptr) {
@@ -626,157 +545,51 @@ void HiveDataSink::setMemoryReclaimers(
   // writer.
 }
 
-void HiveDataSink::setState(State newState) {
-  checkStateTransition(state_, newState);
-  state_ = newState;
-}
-
-/// Validates the state transition from 'oldState' to 'newState'.
-void HiveDataSink::checkStateTransition(State oldState, State newState) {
-  switch (oldState) {
-    case State::kRunning:
-      if (newState == State::kAborted || newState == State::kFinishing) {
-        return;
-      }
-      break;
-    case State::kFinishing:
-      if (newState == State::kAborted || newState == State::kClosed ||
-          // The finishing state is reentry state if we yield in the middle of
-          // finish processing if a single run takes too long.
-          newState == State::kFinishing) {
-        return;
-      }
-      [[fallthrough]];
-    case State::kAborted:
-    case State::kClosed:
-    default:
-      break;
-  }
-  VELOX_FAIL("Unexpected state transition from {} to {}", oldState, newState);
-}
-
-bool HiveDataSink::finish() {
-  // Flush is reentry state.
-  setState(State::kFinishing);
-
-  // As for now, only sorted writer needs flush buffered data. For non-sorted
-  // writer, data is directly written to the underlying file writer.
-  if (!sortWrite()) {
-    return true;
-  }
-
-  // TODO: we might refactor to move the data sorting logic into hive data sink.
-  const uint64_t startTimeMs = getCurrentTimeMs();
-  for (auto i = 0; i < writers_.size(); ++i) {
-    WRITER_NON_RECLAIMABLE_SECTION_GUARD(i);
-    if (!writers_[i]->finish()) {
-      return false;
-    }
-    if (getCurrentTimeMs() - startTimeMs > sortWriterFinishTimeSliceLimitMs_) {
-      return false;
-    }
-  }
-  return true;
-}
-
-std::vector<std::string> HiveDataSink::close() {
-  setState(State::kClosed);
-  closeInternal();
-
+std::vector<std::string> HiveDataSink::commitMessage() const {
   std::vector<std::string> partitionUpdates;
   partitionUpdates.reserve(writerInfo_.size());
   for (int i = 0; i < writerInfo_.size(); ++i) {
     const auto& info = writerInfo_.at(i);
     VELOX_CHECK_NOT_NULL(info);
+
+    folly::dynamic fileWriteInfosArray = folly::dynamic::array;
+    for (const auto& fileInfo : info->writtenFiles) {
+      fileWriteInfosArray.push_back(
+          folly::dynamic::object(
+              HiveCommitMessage::kWriteFileName, fileInfo.writeFileName)(
+              HiveCommitMessage::kTargetFileName, fileInfo.targetFileName)(
+              HiveCommitMessage::kFileSize, fileInfo.fileSize));
+    }
+
     // clang-format off
       auto partitionUpdateJson = folly::toJson(
        folly::dynamic::object
-          ("name", info->writerParameters.partitionName().value_or(""))
-          ("updateMode",
-            HiveWriterParameters::updateModeToString(
+          (HiveCommitMessage::kName, info->writerParameters.partitionName().value_or(""))
+          (HiveCommitMessage::kUpdateMode,
+            WriterParameters::updateModeToString(
               info->writerParameters.updateMode()))
-          ("writePath", info->writerParameters.writeDirectory())
-          ("targetPath", info->writerParameters.targetDirectory())
-          ("fileWriteInfos", folly::dynamic::array(
-            folly::dynamic::object
-              ("writeFileName", info->writerParameters.writeFileName())
-              ("targetFileName", info->writerParameters.targetFileName())
-              ("fileSize", ioStats_.at(i)->rawBytesWritten())))
-          ("rowCount", info->numWrittenRows)
-          ("inMemoryDataSizeInBytes", info->inputSizeInBytes)
-          ("onDiskDataSizeInBytes", ioStats_.at(i)->rawBytesWritten())
-          ("containsNumberedFileNames", true));
+          (HiveCommitMessage::kWritePath, info->writerParameters.writeDirectory())
+          (HiveCommitMessage::kTargetPath, info->writerParameters.targetDirectory())
+          (HiveCommitMessage::kFileWriteInfos, std::move(fileWriteInfosArray))
+          (HiveCommitMessage::kRowCount, info->numWrittenRows)
+          (HiveCommitMessage::kInMemoryDataSizeInBytes, info->inputSizeInBytes)
+          (HiveCommitMessage::kOnDiskDataSizeInBytes, ioStats_.at(i)->rawBytesWritten())
+          (HiveCommitMessage::kContainsNumberedFileNames, true));
     // clang-format on
     partitionUpdates.push_back(partitionUpdateJson);
   }
   return partitionUpdates;
 }
 
-void HiveDataSink::abort() {
-  setState(State::kAborted);
-  closeInternal();
-}
-
-void HiveDataSink::closeInternal() {
-  VELOX_CHECK_NE(state_, State::kRunning);
-  VELOX_CHECK_NE(state_, State::kFinishing);
-
-  TestValue::adjust(
-      "facebook::velox::connector::hive::HiveDataSink::closeInternal", this);
-
-  if (state_ == State::kClosed) {
-    for (int i = 0; i < writers_.size(); ++i) {
-      WRITER_NON_RECLAIMABLE_SECTION_GUARD(i);
-      writers_[i]->close();
-    }
-  } else {
-    for (int i = 0; i < writers_.size(); ++i) {
-      WRITER_NON_RECLAIMABLE_SECTION_GUARD(i);
-      writers_[i]->abort();
-    }
-  }
-}
-
-uint32_t HiveDataSink::ensureWriter(const HiveWriterId& id) {
-  auto it = writerIndexMap_.find(id);
-  if (it != writerIndexMap_.end()) {
-    return it->second;
-  }
-  return appendWriter(id);
+std::shared_ptr<dwio::common::WriterOptions> HiveDataSink::createWriterOptions()
+    const {
+  // Default: use the last writer's info (for appendWriter which just added it)
+  return createWriterOptions(writerInfo_.size() - 1);
 }
 
-uint32_t HiveDataSink::appendWriter(const HiveWriterId& id) {
-  // Check max open writers.
-  VELOX_USER_CHECK_LE(
-      writers_.size(), maxOpenWriters_, "Exceeded open writer limit");
-  VELOX_CHECK_EQ(writers_.size(), writerInfo_.size());
-  VELOX_CHECK_EQ(writerIndexMap_.size(), writerInfo_.size());
-
-  std::optional<std::string> partitionName;
-  if (isPartitioned()) {
-    partitionName =
-        partitionIdGenerator_->partitionName(id.partitionId.value());
-  }
-
-  // Without explicitly setting flush policy, the default memory based flush
-  // policy is used.
-  auto writerParameters = getWriterParameters(partitionName, id.bucketId);
-  const auto writePath = fs::path(writerParameters.writeDirectory()) /
-      writerParameters.writeFileName();
-  auto writerPool = createWriterPool(id);
-  auto sinkPool = createSinkPool(writerPool);
-  std::shared_ptr<memory::MemoryPool> sortPool{nullptr};
-  if (sortWrite()) {
-    sortPool = createSortPool(writerPool);
-  }
-  writerInfo_.emplace_back(std::make_shared<HiveWriterInfo>(
-      std::move(writerParameters),
-      std::move(writerPool),
-      std::move(sinkPool),
-      std::move(sortPool)));
-  ioStats_.emplace_back(std::make_unique<io::IoStatistics>());
-
-  setMemoryReclaimers(writerInfo_.back().get(), ioStats_.back().get());
+std::shared_ptr<dwio::common::WriterOptions> HiveDataSink::createWriterOptions(
+    size_t writerIndex) const {
+  VELOX_CHECK_LT(writerIndex, writerInfo_.size());
 
   // Take the writer options provided by the user as a starting point, or
   // allocate a new one.
@@ -793,10 +606,6 @@ uint32_t HiveDataSink::appendWriter(const HiveWriterId& id) {
     options->schema = getNonPartitionTypes(dataChannels_, inputType_);
   }
 
-  if (options->memoryPool == nullptr) {
-    options->memoryPool = writerInfo_.back()->writerPool.get();
-  }
-
   if (!options->compressionKind) {
     options->compressionKind = insertTableHandle_->compressionKind();
   }
@@ -805,10 +614,12 @@ uint32_t HiveDataSink::appendWriter(const HiveWriterId& id) {
     options->spillConfig = spillConfig_;
   }
 
-  if (options->nonReclaimableSection == nullptr) {
-    options->nonReclaimableSection =
-        writerInfo_.back()->nonReclaimableSectionHolder.get();
-  }
+  // Always set per-writer options to the current writer's values.
+  // Since insertTableHandle_->writerOptions() returns a shared_ptr, each writer
+  // needs its own memory pool and nonReclaimableSection pointer.
+  options->memoryPool = writerInfo_[writerIndex]->writerPool.get();
+  options->nonReclaimableSection =
+      writerInfo_[writerIndex]->nonReclaimableSectionHolder.get();
 
   if (options->memoryReclaimerFactory == nullptr ||
       options->memoryReclaimerFactory() == nullptr) {
@@ -827,50 +638,70 @@ uint32_t HiveDataSink::appendWriter(const HiveWriterId& id) {
   options->adjustTimestampToTimezone =
       connectorQueryCtx_->adjustTimestampToTimezone();
   options->processConfigs(*hiveConfig_->config(), *connectorSessionProperties);
+  return options;
+}
+
+std::unique_ptr<dwio::common::Writer> HiveDataSink::createWriterForIndex(
+    size_t writerIndex) {
+  VELOX_CHECK_LT(writerIndex, writerInfo_.size());
+  VELOX_CHECK_LT(writerIndex, ioStats_.size());
+
+  auto& info = writerInfo_[writerIndex];
+  const auto& params = info->writerParameters;
+
+  // Compute and store the new file names.
+  info->currentWriteFileName =
+      makeSequencedFileName(params.writeFileName(), info->fileSequenceNumber);
+  info->currentTargetFileName =
+      makeSequencedFileName(params.targetFileName(), info->fileSequenceNumber);
+
+  const auto writePath =
+      (fs::path(params.writeDirectory()) / info->currentWriteFileName).string();
+
+  auto options = createWriterOptions(writerIndex);
 
   // Prevents the memory allocation during the writer creation.
-  WRITER_NON_RECLAIMABLE_SECTION_GUARD(writerInfo_.size() - 1);
+  WRITER_NON_RECLAIMABLE_SECTION_GUARD(writerIndex);
   auto writer = writerFactory_->createWriter(
-      dwio::common::FileSink::create(
+      createHiveFileSink(
           writePath,
-          {
-              .bufferWrite = false,
-              .connectorProperties = hiveConfig_->config(),
-              .fileCreateConfig = hiveConfig_->writeFileCreateConfig(),
-              .pool = writerInfo_.back()->sinkPool.get(),
-              .metricLogger = dwio::common::MetricsLog::voidLog(),
-              .stats = ioStats_.back().get(),
-              .fileSystemStats = fileSystemStats_.get(),
-          }),
+          hiveConfig_,
+          info->sinkPool.get(),
+          ioStats_[writerIndex].get(),
+          fileSystemStats_.get(),
+          insertTableHandle_->storageParameters()),
       options);
-  writer = maybeCreateBucketSortWriter(std::move(writer));
-  writers_.emplace_back(std::move(writer));
-  // Extends the buffer used for partition rows calculations.
-  partitionSizes_.emplace_back(0);
-  partitionRows_.emplace_back(nullptr);
-  rawPartitionRows_.emplace_back(nullptr);
-
-  writerIndexMap_.emplace(id, writers_.size() - 1);
-  return writerIndexMap_[id];
+  return maybeCreateBucketSortWriter(writerIndex, std::move(writer));
+}
+
+std::string HiveDataSink::getPartitionName(uint32_t partitionId) const {
+  VELOX_CHECK_NOT_NULL(partitionIdGenerator_);
+
+  return HivePartitionName::partitionName(
+      partitionId,
+      partitionIdGenerator_->partitionValues(),
+      partitionKeyAsLowerCase_);
 }
 
 std::unique_ptr<facebook::velox::dwio::common::Writer>
 HiveDataSink::maybeCreateBucketSortWriter(
+    size_t writerIndex,
     std::unique_ptr<facebook::velox::dwio::common::Writer> writer) {
   if (!sortWrite()) {
     return writer;
   }
-  auto* sortPool = writerInfo_.back()->sortPool.get();
+  auto* sortPool = writerInfo_[writerIndex]->sortPool.get();
   VELOX_CHECK_NOT_NULL(sortPool);
   auto sortBuffer = std::make_unique<exec::SortBuffer>(
       getNonPartitionTypes(dataChannels_, inputType_),
       sortColumnIndices_,
       sortCompareFlags_,
       sortPool,
-      writerInfo_.back()->nonReclaimableSectionHolder.get(),
+      writerInfo_[writerIndex]->nonReclaimableSectionHolder.get(),
       connectorQueryCtx_->prefixSortConfig(),
       spillConfig_,
-      writerInfo_.back()->spillStats.get());
+      writerInfo_[writerIndex]->spillStats.get());
+
   return std::make_unique<dwio::common::SortingWriter>(
       std::move(writer),
       std::move(sortBuffer),
@@ -881,62 +712,12 @@ HiveDataSink::maybeCreateBucketSortWriter(
       sortWriterFinishTimeSliceLimitMs_);
 }
 
-HiveWriterId HiveDataSink::getWriterId(size_t row) const {
-  std::optional<int32_t> partitionId;
-  if (isPartitioned()) {
-    VELOX_CHECK_LT(partitionIds_[row], std::numeric_limits<uint32_t>::max());
-    partitionId = static_cast<uint32_t>(partitionIds_[row]);
-  }
-
-  std::optional<int32_t> bucketId;
-  if (isBucketed()) {
-    bucketId = bucketIds_[row];
-  }
-  return HiveWriterId{partitionId, bucketId};
-}
-
-void HiveDataSink::splitInputRowsAndEnsureWriters() {
-  VELOX_CHECK(isPartitioned() || isBucketed());
-  if (isBucketed() && isPartitioned()) {
-    VELOX_CHECK_EQ(bucketIds_.size(), partitionIds_.size());
-  }
-
-  std::fill(partitionSizes_.begin(), partitionSizes_.end(), 0);
-
-  const auto numRows =
-      isPartitioned() ? partitionIds_.size() : bucketIds_.size();
-  for (auto row = 0; row < numRows; ++row) {
-    const auto id = getWriterId(row);
-    const uint32_t index = ensureWriter(id);
-
-    VELOX_DCHECK_LT(index, partitionSizes_.size());
-    VELOX_DCHECK_EQ(partitionSizes_.size(), partitionRows_.size());
-    VELOX_DCHECK_EQ(partitionRows_.size(), rawPartitionRows_.size());
-    if (FOLLY_UNLIKELY(partitionRows_[index] == nullptr) ||
-        (partitionRows_[index]->capacity() < numRows * sizeof(vector_size_t))) {
-      partitionRows_[index] =
-          allocateIndices(numRows, connectorQueryCtx_->memoryPool());
-      rawPartitionRows_[index] =
-          partitionRows_[index]->asMutable<vector_size_t>();
-    }
-    rawPartitionRows_[index][partitionSizes_[index]] = row;
-    ++partitionSizes_[index];
-  }
-
-  for (uint32_t i = 0; i < partitionSizes_.size(); ++i) {
-    if (partitionSizes_[i] != 0) {
-      VELOX_CHECK_NOT_NULL(partitionRows_[i]);
-      partitionRows_[i]->setSize(partitionSizes_[i] * sizeof(vector_size_t));
-    }
-  }
-}
-
-HiveWriterParameters HiveDataSink::getWriterParameters(
+WriterParameters HiveDataSink::getWriterParameters(
     const std::optional<std::string>& partition,
     std::optional<uint32_t> bucketId) const {
   auto [targetFileName, writeFileName] = getWriterFileNames(bucketId);
 
-  return HiveWriterParameters{
+  return WriterParameters{
       updateMode_,
       partition,
       targetFileName,
@@ -996,6 +777,8 @@ std::pair<std::string, std::string> HiveInsertFileNameGenerator::gen(
         connectorQueryCtx.queryId(),
         hiveConfig->maxBucketCount(connectorQueryCtx.sessionProperties()),
         bucketId.value());
+    // queryId may contain unsafe characters.
+    sanitizeFileName(targetFileName);
   } else if (generateFileName) {
     // targetFileName includes planNodeId and Uuid. As a result, different
     // table writers run by the same task driver or the same table writer
@@ -1006,7 +789,10 @@ std::pair<std::string, std::string> HiveInsertFileNameGenerator::gen(
         connectorQueryCtx.driverId(),
         connectorQueryCtx.planNodeId(),
         makeUuid());
+    // taskId, planNodeId may contain unsafe characters.
+    sanitizeFileName(targetFileName);
   }
+  // do not try to sanitize user provided targetFileName
   VELOX_CHECK(!targetFileName.empty());
   const std::string writeFileName = commitRequired
       ? fmt::format(".tmp.velox.{}_{}", targetFileName, makeUuid())
@@ -1020,6 +806,11 @@ std::pair<std::string, std::string> HiveInsertFileNameGenerator::gen(
   return {targetFileName, writeFileName};
 }
 
+void HiveInsertFileNameGenerator::sanitizeFileName(std::string& name) {
+  static const re2::RE2 re("[^a-zA-Z0-9._-]");
+  re2::RE2::GlobalReplace(&name, re, "_");
+}
+
 folly::dynamic HiveInsertFileNameGenerator::serialize() const {
   folly::dynamic obj = folly::dynamic::object;
   obj["name"] = "HiveInsertFileNameGenerator";
@@ -1043,16 +834,16 @@ std::string HiveInsertFileNameGenerator::toString() const {
   return "HiveInsertFileNameGenerator";
 }
 
-HiveWriterParameters::UpdateMode HiveDataSink::getUpdateMode() const {
+WriterParameters::UpdateMode HiveDataSink::getUpdateMode() const {
   if (insertTableHandle_->isExistingTable()) {
     if (insertTableHandle_->isPartitioned()) {
       const auto insertBehavior = hiveConfig_->insertExistingPartitionsBehavior(
           connectorQueryCtx_->sessionProperties());
       switch (insertBehavior) {
         case HiveConfig::InsertExistingPartitionsBehavior::kOverwrite:
-          return HiveWriterParameters::UpdateMode::kOverwrite;
+          return WriterParameters::UpdateMode::kOverwrite;
         case HiveConfig::InsertExistingPartitionsBehavior::kError:
-          return HiveWriterParameters::UpdateMode::kNew;
+          return WriterParameters::UpdateMode::kNew;
         default:
           VELOX_UNSUPPORTED(
               "Unsupported insert existing partitions behavior: {}",
@@ -1063,10 +854,10 @@ HiveWriterParameters::UpdateMode HiveDataSink::getUpdateMode() const {
       if (hiveConfig_->immutablePartitions()) {
         VELOX_USER_FAIL("Unpartitioned Hive tables are immutable.");
       }
-      return HiveWriterParameters::UpdateMode::kAppend;
+      return WriterParameters::UpdateMode::kAppend;
     }
   } else {
-    return HiveWriterParameters::UpdateMode::kNew;
+    return WriterParameters::UpdateMode::kNew;
   }
 }
 
@@ -1114,6 +905,13 @@ folly::dynamic HiveInsertTableHandle::serialize() const {
     params[key] = value;
   }
   obj["serdeParameters"] = params;
+
+  folly::dynamic storageParams = folly::dynamic::object;
+  for (const auto& [key, value] : storageParameters_) {
+    storageParams[key] = value;
+  }
+  obj["storageParameters"] = storageParams;
+
   obj["ensureFiles"] = ensureFiles_;
   obj["fileNameGenerator"] = fileNameGenerator_->serialize();
   return obj;
@@ -1145,6 +943,13 @@ HiveInsertTableHandlePtr HiveInsertTableHandle::create(
     serdeParameters.emplace(pair.first.asString(), pair.second.asString());
   }
 
+  std::unordered_map<std::string, std::string> storageParameters;
+  if (obj.count("storageParameters") > 0) {
+    for (const auto& pair : obj["storageParameters"].items()) {
+      storageParameters.emplace(pair.first.asString(), pair.second.asString());
+    }
+  }
+
   bool ensureFiles = obj["ensureFiles"].asBool();
 
   auto fileNameGenerator =
@@ -1158,7 +963,8 @@ HiveInsertTableHandlePtr HiveInsertTableHandle::create(
       serdeParameters,
       nullptr, // writerOptions is not serializable
       ensureFiles,
-      fileNameGenerator);
+      fileNameGenerator,
+      storageParameters);
 }
 
 void HiveInsertTableHandle::registerSerDe() {
@@ -1231,7 +1037,7 @@ LocationHandlePtr LocationHandle::create(const folly::dynamic& obj) {
 
 std::unique_ptr<memory::MemoryReclaimer> HiveDataSink::WriterReclaimer::create(
     HiveDataSink* dataSink,
-    HiveWriterInfo* writerInfo,
+    WriterInfo* writerInfo,
     io::IoStatistics* ioStats) {
   return std::unique_ptr<memory::MemoryReclaimer>(
       new HiveDataSink::WriterReclaimer(dataSink, writerInfo, ioStats));
@@ -1261,9 +1067,13 @@ uint64_t HiveDataSink::WriterReclaimer::reclaim(
   if (*writerInfo_->nonReclaimableSectionHolder.get()) {
     RECORD_METRIC_VALUE(kMetricMemoryNonReclaimableCount);
     LOG(WARNING) << "Can't reclaim from hive writer pool " << pool->name()
-                 << " which is under non-reclaimable section, "
-                 << " reserved memory: "
-                 << succinctBytes(pool->reservedBytes());
+                 << " which is under non-reclaimable section, root pool: "
+                 << pool->root()->name()
+                 << ", state: " << stateString(dataSink_->state_)
+                 << ", used: " << succinctBytes(pool->usedBytes())
+                 << ", reservation: " << succinctBytes(pool->reservedBytes())
+                 << ", root pool reservation: "
+                 << succinctBytes(pool->root()->reservedBytes());
     ++stats.numNonReclaimableAttempts;
     return 0;
   }
@@ -1277,7 +1087,8 @@ uint64_t HiveDataSink::WriterReclaimer::reclaim(
       ioStats_->rawBytesWritten() - writtenBytesBeforeReclaim;
   addThreadLocalRuntimeStat(
       kEarlyFlushedRawBytes,
-      RuntimeCounter(earlyFlushedRawBytes, RuntimeCounter::Unit::kBytes));
+      RuntimeCounter(
+          saturateCast(earlyFlushedRawBytes), RuntimeCounter::Unit::kBytes));
   if (earlyFlushedRawBytes > 0) {
     RECORD_METRIC_VALUE(
         kMetricFileWriterEarlyFlushedRawBytes, earlyFlushedRawBytes);
diff --git a/velox/connectors/hive/HiveDataSink.h b/velox/connectors/hive/HiveDataSink.h
index 8c305b7595d..8eb9ec04f0f 100644
--- a/velox/connectors/hive/HiveDataSink.h
+++ b/velox/connectors/hive/HiveDataSink.h
@@ -17,7 +17,9 @@
 
 #include "velox/common/compression/Compression.h"
 #include "velox/connectors/Connector.h"
+#include "velox/connectors/hive/FileDataSink.h"
 #include "velox/connectors/hive/HiveConfig.h"
+#include "velox/connectors/hive/HivePartitionName.h"
 #include "velox/connectors/hive/PartitionIdGenerator.h"
 #include "velox/connectors/hive/TableHandle.h"
 #include "velox/dwio/common/Options.h"
@@ -231,6 +233,9 @@ class HiveInsertFileNameGenerator : public FileNameGenerator {
       void* context);
 
   std::string toString() const override;
+
+  /// Replaces potentially unsafe characters in a file name with underscores
+  static void sanitizeFileName(std::string& name);
 };
 
 /// Represents a request for Hive write.
@@ -250,37 +255,9 @@ class HiveInsertTableHandle : public ConnectorInsertTableHandle {
       // engine handles ensuring a 1 to 1 mapping from task to bucket.
       const bool ensureFiles = false,
       std::shared_ptr<const FileNameGenerator> fileNameGenerator =
-          std::make_shared<const HiveInsertFileNameGenerator>())
-      : inputColumns_(std::move(inputColumns)),
-        locationHandle_(std::move(locationHandle)),
-        storageFormat_(storageFormat),
-        bucketProperty_(std::move(bucketProperty)),
-        compressionKind_(compressionKind),
-        serdeParameters_(serdeParameters),
-        writerOptions_(writerOptions),
-        ensureFiles_(ensureFiles),
-        fileNameGenerator_(std::move(fileNameGenerator)) {
-    if (compressionKind.has_value()) {
-      VELOX_CHECK(
-          compressionKind.value() != common::CompressionKind_MAX,
-          "Unsupported compression type: CompressionKind_MAX");
-    }
-
-    if (ensureFiles_) {
-      // If ensureFiles is set and either the bucketProperty is set or some
-      // partition keys are in the data, there is not a 1:1 mapping from Task to
-      // files so we can't proactively create writers.
-      VELOX_CHECK(
-          bucketProperty_ == nullptr || bucketProperty_->bucketCount() == 0,
-          "ensureFiles is not supported with bucketing");
-
-      for (const auto& inputColumn : inputColumns_) {
-        VELOX_CHECK(
-            !inputColumn->isPartitionKey(),
-            "ensureFiles is not supported with partition keys in the data");
-      }
-    }
-  }
+          std::make_shared<const HiveInsertFileNameGenerator>(),
+      const std::unordered_map<std::string, std::string>& storageParameters =
+          {});
 
   virtual ~HiveInsertTableHandle() = default;
 
@@ -301,10 +278,19 @@ class HiveInsertTableHandle : public ConnectorInsertTableHandle {
     return storageFormat_;
   }
 
+  /// Format specific options.
   const std::unordered_map<std::string, std::string>& serdeParameters() const {
     return serdeParameters_;
   }
 
+  /// Storage specific options.
+  const std::unordered_map<std::string, std::string>& storageParameters()
+      const {
+    return storageParameters_;
+  }
+
+  /// Avoid this in future usages. Format specific change should go through
+  /// serdeParameters.
   const std::shared_ptr<dwio::common::WriterOptions>& writerOptions() const {
     return writerOptions_;
   }
@@ -329,6 +315,16 @@ class HiveInsertTableHandle : public ConnectorInsertTableHandle {
 
   bool isExistingTable() const;
 
+  /// Returns a subset of column indices corresponding to partition keys.
+  const std::vector<column_index_t>& partitionChannels() const {
+    return partitionChannels_;
+  }
+
+  /// Returns the column indices of non-partition data columns.
+  const std::vector<column_index_t>& nonPartitionChannels() const {
+    return nonPartitionChannels_;
+  }
+
   folly::dynamic serialize() const override;
 
   static HiveInsertTableHandlePtr create(const folly::dynamic& obj);
@@ -337,9 +333,11 @@ class HiveInsertTableHandle : public ConnectorInsertTableHandle {
 
   std::string toString() const override;
 
- private:
+ protected:
   const std::vector<std::shared_ptr<const HiveColumnHandle>> inputColumns_;
   const std::shared_ptr<const LocationHandle> locationHandle_;
+
+ private:
   const dwio::common::FileFormat storageFormat_;
   const std::shared_ptr<const HiveBucketProperty> bucketProperty_;
   const std::optional<common::CompressionKind> compressionKind_;
@@ -347,173 +345,82 @@ class HiveInsertTableHandle : public ConnectorInsertTableHandle {
   const std::shared_ptr<dwio::common::WriterOptions> writerOptions_;
   const bool ensureFiles_;
   const std::shared_ptr<const FileNameGenerator> fileNameGenerator_;
+  const std::unordered_map<std::string, std::string> storageParameters_;
+  const std::vector<column_index_t> partitionChannels_;
+  const std::vector<column_index_t> nonPartitionChannels_;
 };
 
-/// Parameters for Hive writers.
-class HiveWriterParameters {
- public:
-  enum class UpdateMode {
-    kNew, // Write files to a new directory.
-    kOverwrite, // Overwrite an existing directory.
-    // Append mode is currently only supported for unpartitioned tables.
-    kAppend, // Append to an unpartitioned table.
-  };
-
-  /// @param updateMode Write the files to a new directory, or append to an
-  /// existing directory or overwrite an existing directory.
-  /// @param partitionName Partition name in the typical Hive style, which is
-  /// also the partition subdirectory part of the partition path.
-  /// @param targetFileName The final name of a file after committing.
-  /// @param targetDirectory The final directory that a file should be in after
-  /// committing.
-  /// @param writeFileName The temporary name of the file that a running writer
-  /// writes to. If a running writer writes directory to the target file, set
-  /// writeFileName to targetFileName by default.
-  /// @param writeDirectory The temporary directory that a running writer writes
-  /// to. If a running writer writes directory to the target directory, set
-  /// writeDirectory to targetDirectory by default.
-  HiveWriterParameters(
-      UpdateMode updateMode,
-      std::optional<std::string> partitionName,
-      std::string targetFileName,
-      std::string targetDirectory,
-      std::optional<std::string> writeFileName = std::nullopt,
-      std::optional<std::string> writeDirectory = std::nullopt)
-      : updateMode_(updateMode),
-        partitionName_(std::move(partitionName)),
-        targetFileName_(std::move(targetFileName)),
-        targetDirectory_(std::move(targetDirectory)),
-        writeFileName_(writeFileName.value_or(targetFileName_)),
-        writeDirectory_(writeDirectory.value_or(targetDirectory_)) {}
-
-  UpdateMode updateMode() const {
-    return updateMode_;
-  }
-
-  static std::string updateModeToString(UpdateMode updateMode) {
-    switch (updateMode) {
-      case UpdateMode::kNew:
-        return "NEW";
-      case UpdateMode::kOverwrite:
-        return "OVERWRITE";
-      case UpdateMode::kAppend:
-        return "APPEND";
-      default:
-        VELOX_UNSUPPORTED("Unsupported update mode.");
-    }
-  }
-
-  const std::optional<std::string>& partitionName() const {
-    return partitionName_;
-  }
-
-  const std::string& targetFileName() const {
-    return targetFileName_;
-  }
-
-  const std::string& writeFileName() const {
-    return writeFileName_;
-  }
-
-  const std::string& targetDirectory() const {
-    return targetDirectory_;
-  }
-
-  const std::string& writeDirectory() const {
-    return writeDirectory_;
-  }
-
- private:
-  const UpdateMode updateMode_;
-  const std::optional<std::string> partitionName_;
-  const std::string targetFileName_;
-  const std::string targetDirectory_;
-  const std::string writeFileName_;
-  const std::string writeDirectory_;
-};
-
-struct HiveWriterInfo {
-  HiveWriterInfo(
-      HiveWriterParameters parameters,
-      std::shared_ptr<memory::MemoryPool> _writerPool,
-      std::shared_ptr<memory::MemoryPool> _sinkPool,
-      std::shared_ptr<memory::MemoryPool> _sortPool)
-      : writerParameters(std::move(parameters)),
-        nonReclaimableSectionHolder(new tsan_atomic<bool>(false)),
-        spillStats(std::make_unique<folly::Synchronized<common::SpillStats>>()),
-        writerPool(std::move(_writerPool)),
-        sinkPool(std::move(_sinkPool)),
-        sortPool(std::move(_sortPool)) {}
-
-  const HiveWriterParameters writerParameters;
-  const std::unique_ptr<tsan_atomic<bool>> nonReclaimableSectionHolder;
-  /// Collects the spill stats from sort writer if the spilling has been
-  /// triggered.
-  const std::unique_ptr<folly::Synchronized<common::SpillStats>> spillStats;
-  const std::shared_ptr<memory::MemoryPool> writerPool;
-  const std::shared_ptr<memory::MemoryPool> sinkPool;
-  const std::shared_ptr<memory::MemoryPool> sortPool;
-  int64_t numWrittenRows = 0;
-  int64_t inputSizeInBytes = 0;
-};
-
-/// Identifies a hive writer.
-struct HiveWriterId {
-  std::optional<uint32_t> partitionId{std::nullopt};
-  std::optional<uint32_t> bucketId{std::nullopt};
-
-  HiveWriterId() = default;
-
-  HiveWriterId(
-      std::optional<uint32_t> _partitionId,
-      std::optional<uint32_t> _bucketId = std::nullopt)
-      : partitionId(_partitionId), bucketId(_bucketId) {}
-
-  /// Returns the special writer id for the un-partitioned (and non-bucketed)
-  /// table.
-  static const HiveWriterId& unpartitionedId();
-
-  std::string toString() const;
-
-  bool operator==(const HiveWriterId& other) const {
-    return std::tie(partitionId, bucketId) ==
-        std::tie(other.partitionId, other.bucketId);
-  }
-};
-
-struct HiveWriterIdHasher {
-  std::size_t operator()(const HiveWriterId& id) const {
-    return bits::hashMix(
-        id.partitionId.value_or(std::numeric_limits<uint32_t>::max()),
-        id.bucketId.value_or(std::numeric_limits<uint32_t>::max()));
-  }
+/// JSON field names for the partition update object produced by each writer
+/// and consumed by the Presto coordinator to finalize files and update the
+/// metastore.
+///
+/// JSON structure:
+/// {
+///   "name":                        "<partition key, e.g. ds=2024-01-01>",
+///   "updateMode":                  "NEW" | "APPEND" | "OVERWRITE",
+///   "writePath":                   "<staging directory>",
+///   "targetPath":                  "<final directory>",
+///   "fileWriteInfos": [
+///     {
+///       "writeFileName":           "<temp filename in writePath>",
+///       "targetFileName":          "<final filename in targetPath>",
+///       "fileSize":                <bytes>
+///     }
+///   ],
+///   "rowCount":                    <total rows>,
+///   "inMemoryDataSizeInBytes":     <uncompressed bytes>,
+///   "onDiskDataSizeInBytes":       <compressed bytes on disk>,
+///   "containsNumberedFileNames":   true | false
+/// }
+struct HiveCommitMessage {
+  /// Partition directory name in Hive format (e.g., "ds=2024-01-01/region=us").
+  /// Empty string for unpartitioned tables.
+  static constexpr const char* kName = "name";
+  /// Write mode: "NEW", "APPEND", or "OVERWRITE". Controls how the committer
+  /// handles metastore updates and existing file conflicts.
+  static constexpr const char* kUpdateMode = "updateMode";
+  /// Staging directory where files were written during execution.
+  static constexpr const char* kWritePath = "writePath";
+  /// Final destination directory. Files are renamed from writePath to
+  /// targetPath during commit.
+  static constexpr const char* kTargetPath = "targetPath";
+  /// Array of per-file metadata objects. One entry per file written, including
+  /// rotated files.
+  static constexpr const char* kFileWriteInfos = "fileWriteInfos";
+  /// Temporary filename used during writing (in the staging directory).
+  static constexpr const char* kWriteFileName = "writeFileName";
+  /// Final filename after commit (in the target directory).
+  static constexpr const char* kTargetFileName = "targetFileName";
+  /// Size of individual file in bytes.
+  static constexpr const char* kFileSize = "fileSize";
+  /// Total rows written to this partition across all files.
+  static constexpr const char* kRowCount = "rowCount";
+  /// Uncompressed input data size in bytes.
+  static constexpr const char* kInMemoryDataSizeInBytes =
+      "inMemoryDataSizeInBytes";
+  /// Compressed bytes written to disk.
+  static constexpr const char* kOnDiskDataSizeInBytes = "onDiskDataSizeInBytes";
+  /// Whether filenames follow a numbered sequence from file rotation.
+  static constexpr const char* kContainsNumberedFileNames =
+      "containsNumberedFileNames";
 };
 
-struct HiveWriterIdEq {
-  bool operator()(const HiveWriterId& lhs, const HiveWriterId& rhs) const {
-    return lhs == rhs;
-  }
-};
-
-class HiveDataSink : public DataSink {
+class HiveDataSink : public FileDataSink {
  public:
   /// The list of runtime stats reported by hive data sink
   static constexpr const char* kEarlyFlushedRawBytes = "earlyFlushedRawBytes";
 
-  /// Defines the execution states of a hive data sink running internally.
-  enum class State {
-    /// The data sink accepts new append data in this state.
-    kRunning = 0,
-    /// The data sink flushes any buffered data to the underlying file writer
-    /// but no more data can be appended.
-    kFinishing = 1,
-    /// The data sink is aborted on error and no more data can be appended.
-    kAborted = 2,
-    /// The data sink is closed on error and no more data can be appended.
-    kClosed = 3
-  };
-  static std::string stateString(State state);
-
+  /// Creates a HiveDataSink for writing data to Hive table files.
+  ///
+  /// @param inputType The schema of input data rows to be written.
+  /// @param insertTableHandle Metadata about the table write operation,
+  /// including storage format, compression, bucketing, and partitioning
+  /// configuration.
+  /// @param connectorQueryCtx Query context with session properties, memory
+  /// pools, and spill configuration.
+  /// @param commitStrategy Strategy for committing written data (kNoCommit or
+  /// kTaskCommit).
+  /// @param hiveConfig Hive connector configuration.
   HiveDataSink(
       RowTypePtr inputType,
       std::shared_ptr<const HiveInsertTableHandle> insertTableHandle,
@@ -521,6 +428,31 @@ class HiveDataSink : public DataSink {
       CommitStrategy commitStrategy,
       const std::shared_ptr<const HiveConfig>& hiveConfig);
 
+  /// Constructor with explicit bucketing and partitioning parameters.
+  ///
+  /// @param inputType The schema of input data rows to be written.
+  /// @param insertTableHandle Metadata about the table write operation,
+  /// including storage format, compression, location, and serialization
+  /// parameters.
+  /// @param connectorQueryCtx Query context with session properties, memory
+  /// pools, and spill configuration.
+  /// @param commitStrategy Strategy for committing written data (kNoCommit or
+  /// kTaskCommit). Determines whether temporary files need to be renamed on
+  /// commit.
+  /// @param hiveConfig Hive connector configuration with settings for max
+  /// partitions, bucketing limits etc.
+  /// @param bucketCount Number of buckets for bucketed tables (0 if not
+  /// bucketed). Must be less than the configured max bucket count.
+  /// @param bucketFunction Function to compute bucket IDs from row data
+  /// (nullptr if not bucketed). Used to distribute rows across buckets.
+  /// @param partitionChannels Column indices used for partitioning (empty if
+  /// not partitioned). These columns are extracted to determine partition
+  /// directories.
+  /// @param dataChannels Column indices for the actual data columns to be
+  /// written.
+  /// @param partitionIdGenerator Generates partition IDs from partition column
+  /// values (nullptr if not partitioned). Compute partition key combinations to
+  /// unique IDs.
   HiveDataSink(
       RowTypePtr inputType,
       std::shared_ptr<const HiveInsertTableHandle> insertTableHandle,
@@ -528,32 +460,21 @@ class HiveDataSink : public DataSink {
       CommitStrategy commitStrategy,
       const std::shared_ptr<const HiveConfig>& hiveConfig,
       uint32_t bucketCount,
-      std::unique_ptr<core::PartitionFunction> bucketFunction);
-
-  void appendData(RowVectorPtr input) override;
-
-  bool finish() override;
-
-  Stats stats() const override;
-
-  std::unordered_map<std::string, RuntimeCounter> runtimeStats() const override;
-
-  std::vector<std::string> close() override;
-
-  void abort() override;
+      std::unique_ptr<core::PartitionFunction> bucketFunction,
+      const std::vector<column_index_t>& partitionChannels,
+      const std::vector<column_index_t>& dataChannels,
+      std::unique_ptr<PartitionIdGenerator> partitionIdGenerator);
 
   bool canReclaim() const;
 
- private:
-  // Validates the state transition from 'oldState' to 'newState'.
-  void checkStateTransition(State oldState, State newState);
-  void setState(State newState);
+ protected:
+  std::vector<std::string> commitMessage() const override;
 
   class WriterReclaimer : public exec::MemoryReclaimer {
    public:
     static std::unique_ptr<memory::MemoryReclaimer> create(
         HiveDataSink* dataSink,
-        HiveWriterInfo* writerInfo,
+        WriterInfo* writerInfo,
         io::IoStatistics* ioStats);
 
     bool reclaimableBytes(
@@ -569,7 +490,7 @@ class HiveDataSink : public DataSink {
    private:
     WriterReclaimer(
         HiveDataSink* dataSink,
-        HiveWriterInfo* writerInfo,
+        WriterInfo* writerInfo,
         io::IoStatistics* ioStats)
         : exec::MemoryReclaimer(0),
           dataSink_(dataSink),
@@ -581,161 +502,57 @@ class HiveDataSink : public DataSink {
     }
 
     HiveDataSink* const dataSink_;
-    HiveWriterInfo* const writerInfo_;
+    WriterInfo* const writerInfo_;
     io::IoStatistics* const ioStats_;
   };
 
-  FOLLY_ALWAYS_INLINE bool sortWrite() const {
-    return !sortColumnIndices_.empty();
-  }
-
-  // Returns true if the table is partitioned.
-  FOLLY_ALWAYS_INLINE bool isPartitioned() const {
-    return partitionIdGenerator_ != nullptr;
-  }
-
-  // Returns true if the table is bucketed.
-  FOLLY_ALWAYS_INLINE bool isBucketed() const {
-    return bucketCount_ != 0;
-  }
-
-  FOLLY_ALWAYS_INLINE bool isCommitRequired() const {
-    return commitStrategy_ != CommitStrategy::kNoCommit;
-  }
-
-  std::shared_ptr<memory::MemoryPool> createWriterPool(
-      const HiveWriterId& writerId);
-
-  void setMemoryReclaimers(
-      HiveWriterInfo* writerInfo,
-      io::IoStatistics* ioStats);
+  void setMemoryReclaimers(WriterInfo* writerInfo, io::IoStatistics* ioStats)
+      override;
 
   // Compute the partition id and bucket id for each row in 'input'.
-  void computePartitionAndBucketIds(const RowVectorPtr& input);
+  void computePartitionAndBucketIds(const RowVectorPtr& input) override;
 
-  // Get the HiveWriter corresponding to the row
-  // from partitionIds and bucketIds.
-  FOLLY_ALWAYS_INLINE HiveWriterId getWriterId(size_t row) const;
+  std::unique_ptr<facebook::velox::dwio::common::Writer> createWriterForIndex(
+      size_t writerIndex) override;
 
-  // Computes the number of input rows as well as the actual input row indices
-  // to each corresponding (bucketed) partition based on the partition and
-  // bucket ids calculated by 'computePartitionAndBucketIds'. The function also
-  // ensures that there is a writer created for each (bucketed) partition.
-  void splitInputRowsAndEnsureWriters();
+  // Creates and configures WriterOptions based on file format.
+  std::shared_ptr<dwio::common::WriterOptions> createWriterOptions()
+      const override;
 
-  // Makes sure to create one writer for the given writer id. The function
-  // returns the corresponding index in 'writers_'.
-  uint32_t ensureWriter(const HiveWriterId& id);
+  virtual std::shared_ptr<dwio::common::WriterOptions> createWriterOptions(
+      size_t writerIndex) const override;
 
-  // Appends a new writer for the given 'id'. The function returns the index of
-  // the newly created writer in 'writers_'.
-  uint32_t appendWriter(const HiveWriterId& id);
+  // Returns the Hive partition directory name for the given partition ID.
+  virtual std::string getPartitionName(uint32_t partitionId) const override;
 
   std::unique_ptr<facebook::velox::dwio::common::Writer>
   maybeCreateBucketSortWriter(
+      size_t writerIndex,
       std::unique_ptr<facebook::velox::dwio::common::Writer> writer);
 
-  HiveWriterParameters getWriterParameters(
+  WriterParameters getWriterParameters(
       const std::optional<std::string>& partition,
-      std::optional<uint32_t> bucketId) const;
+      std::optional<uint32_t> bucketId) const override;
 
-  // Gets write and target file names for a writer based on the table commit
-  // strategy as well as table partitioned type. If commit is not required, the
-  // write file and target file has the same name. If not, add a temp file
-  // prefix to the target file for write file name. The coordinator (or driver
-  // for Presto on spark) will rename the write file to target file to commit
-  // the table write when update the metadata store. If it is a bucketed table,
-  // the file name encodes the corresponding bucket id.
+  // Gets write and target file names for a writer.
   std::pair<std::string, std::string> getWriterFileNames(
       std::optional<uint32_t> bucketId) const;
 
-  HiveWriterParameters::UpdateMode getUpdateMode() const;
-
-  FOLLY_ALWAYS_INLINE void checkRunning() const {
-    VELOX_CHECK_EQ(state_, State::kRunning, "Hive data sink is not running");
-  }
-
-  // Invoked to write 'input' to the specified file writer.
-  void write(size_t index, RowVectorPtr input);
-
-  void closeInternal();
+  WriterParameters::UpdateMode getUpdateMode() const;
 
-  // IMPORTANT NOTE: these are passed to writers as raw pointers. HiveDataSink
-  // owns the lifetime of these objects, and therefore must destroy them last.
-  // Additionally, we must assume that no objects which hold a reference to
-  // these stats will outlive the HiveDataSink instance. This is a reasonable
-  // assumption given the semantics of these stats objects.
-  std::vector<std::unique_ptr<io::IoStatistics>> ioStats_;
-  // Generic filesystem stats, exposed as RuntimeStats
-  std::unique_ptr<filesystems::File::IoStats> fileSystemStats_;
-
-  const RowTypePtr inputType_;
   const std::shared_ptr<const HiveInsertTableHandle> insertTableHandle_;
-  const ConnectorQueryCtx* const connectorQueryCtx_;
-  const CommitStrategy commitStrategy_;
   const std::shared_ptr<const HiveConfig> hiveConfig_;
-  const HiveWriterParameters::UpdateMode updateMode_;
-  const uint32_t maxOpenWriters_;
-  const std::vector<column_index_t> partitionChannels_;
-  const std::unique_ptr<PartitionIdGenerator> partitionIdGenerator_;
-  // Indices of dataChannel are stored in ascending order
-  const std::vector<column_index_t> dataChannels_;
-  const int32_t bucketCount_{0};
-  const std::unique_ptr<core::PartitionFunction> bucketFunction_;
-  const std::shared_ptr<dwio::common::WriterFactory> writerFactory_;
-  const common::SpillConfig* const spillConfig_;
-  const uint64_t sortWriterFinishTimeSliceLimitMs_{0};
+  const WriterParameters::UpdateMode updateMode_;
 
   std::vector<column_index_t> sortColumnIndices_;
   std::vector<CompareFlags> sortCompareFlags_;
 
-  State state_{State::kRunning};
-
-  tsan_atomic<bool> nonReclaimableSection_{false};
-
-  // The map from writer id to the writer index in 'writers_' and 'writerInfo_'.
-  folly::F14FastMap<HiveWriterId, uint32_t, HiveWriterIdHasher, HiveWriterIdEq>
-      writerIndexMap_;
-
-  // Below are structures for partitions from all inputs. writerInfo_ and
-  // writers_ are both indexed by partitionId.
-  std::vector<std::shared_ptr<HiveWriterInfo>> writerInfo_;
-  std::vector<std::unique_ptr<dwio::common::Writer>> writers_;
-
-  // Below are structures updated when processing current input. partitionIds_
-  // are indexed by the row of input_. partitionRows_, rawPartitionRows_ and
-  // partitionSizes_ are indexed by partitionId.
-  raw_vector<uint64_t> partitionIds_;
-  std::vector<BufferPtr> partitionRows_;
-  std::vector<vector_size_t*> rawPartitionRows_;
-  std::vector<vector_size_t> partitionSizes_;
-
-  // Reusable buffers for bucket id calculations.
-  std::vector<uint32_t> bucketIds_;
-
   // Strategy for naming writer files
   std::shared_ptr<const FileNameGenerator> fileNameGenerator_;
 };
 
-FOLLY_ALWAYS_INLINE std::ostream& operator<<(
-    std::ostream& os,
-    HiveDataSink::State state) {
-  os << HiveDataSink::stateString(state);
-  return os;
-}
 } // namespace facebook::velox::connector::hive
 
-template <>
-struct fmt::formatter<facebook::velox::connector::hive::HiveDataSink::State>
-    : formatter<std::string> {
-  auto format(
-      facebook::velox::connector::hive::HiveDataSink::State s,
-      format_context& ctx) const {
-    return formatter<std::string>::format(
-        facebook::velox::connector::hive::HiveDataSink::stateString(s), ctx);
-  }
-};
-
 template <>
 struct fmt::formatter<
     facebook::velox::connector::hive::LocationHandle::TableType>
diff --git a/velox/connectors/hive/HiveDataSource.cpp b/velox/connectors/hive/HiveDataSource.cpp
index d0c59b6392c..1db6ba3f543 100644
--- a/velox/connectors/hive/HiveDataSource.cpp
+++ b/velox/connectors/hive/HiveDataSource.cpp
@@ -16,220 +16,47 @@
 
 #include "velox/connectors/hive/HiveDataSource.h"
 
-#include <fmt/ranges.h>
-#include <string>
-#include <unordered_map>
+#include <utility>
 
-#include "velox/common/testutil/TestValue.h"
 #include "velox/connectors/hive/HiveConfig.h"
-#include "velox/expression/FieldReference.h"
-
-using facebook::velox::common::testutil::TestValue;
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/connectors/hive/HiveConnectorUtil.h"
+#include "velox/connectors/hive/HiveSplitReader.h"
 
 namespace facebook::velox::connector::hive {
 
-namespace {
-
-bool isMember(
-    const std::vector<exec::FieldReference*>& fields,
-    const exec::FieldReference& field) {
-  return std::find(fields.begin(), fields.end(), &field) != fields.end();
-}
-
-bool shouldEagerlyMaterialize(
-    const exec::Expr& remainingFilter,
-    const exec::FieldReference& field) {
-  if (!remainingFilter.evaluatesArgumentsOnNonIncreasingSelection()) {
-    return true;
-  }
-  for (auto& input : remainingFilter.inputs()) {
-    if (isMember(input->distinctFields(), field) && input->hasConditionals()) {
-      return true;
-    }
-  }
-  return false;
-}
-
-} // namespace
-
 HiveDataSource::HiveDataSource(
     const RowTypePtr& outputType,
     const connector::ConnectorTableHandlePtr& tableHandle,
-    const connector::ColumnHandleMap& columnHandles,
+    const connector::ColumnHandleMap& assignments,
     FileHandleFactory* fileHandleFactory,
     folly::Executor* ioExecutor,
     const ConnectorQueryCtx* connectorQueryCtx,
     const std::shared_ptr<HiveConfig>& hiveConfig)
-    : fileHandleFactory_(fileHandleFactory),
-      ioExecutor_(ioExecutor),
-      connectorQueryCtx_(connectorQueryCtx),
-      hiveConfig_(hiveConfig),
-      pool_(connectorQueryCtx->memoryPool()),
-      outputType_(outputType),
-      expressionEvaluator_(connectorQueryCtx->expressionEvaluator()) {
-  // Column handled keyed on the column alias, the name used in the query.
-  for (const auto& [canonicalizedName, columnHandle] : columnHandles) {
-    auto handle =
-        std::dynamic_pointer_cast<const HiveColumnHandle>(columnHandle);
-    VELOX_CHECK_NOT_NULL(
-        handle,
-        "ColumnHandle must be an instance of HiveColumnHandle for {}",
-        canonicalizedName);
-    switch (handle->columnType()) {
-      case HiveColumnHandle::ColumnType::kRegular:
-        break;
-      case HiveColumnHandle::ColumnType::kPartitionKey:
-        partitionKeys_.emplace(handle->name(), handle);
-        break;
-      case HiveColumnHandle::ColumnType::kSynthesized:
-        infoColumns_.emplace(handle->name(), handle);
-        break;
-      case HiveColumnHandle::ColumnType::kRowIndex:
-        specialColumns_.rowIndex = handle->name();
-        break;
-      case HiveColumnHandle::ColumnType::kRowId:
-        specialColumns_.rowId = handle->name();
-        break;
-    }
-  }
-
-  std::vector<std::string> readColumnNames;
-  auto readColumnTypes = outputType_->children();
-  for (const auto& outputName : outputType_->names()) {
-    auto it = columnHandles.find(outputName);
-    VELOX_CHECK(
-        it != columnHandles.end(),
-        "ColumnHandle is missing for output column: {}",
-        outputName);
-
-    auto* handle = static_cast<const HiveColumnHandle*>(it->second.get());
-    readColumnNames.push_back(handle->name());
-    for (auto& subfield : handle->requiredSubfields()) {
-      VELOX_USER_CHECK_EQ(
-          getColumnName(subfield),
-          handle->name(),
-          "Required subfield does not match column name");
-      subfields_[handle->name()].push_back(&subfield);
-    }
-  }
-
-  hiveTableHandle_ =
-      std::dynamic_pointer_cast<const HiveTableHandle>(tableHandle);
-  VELOX_CHECK_NOT_NULL(
-      hiveTableHandle_, "TableHandle must be an instance of HiveTableHandle");
-  if (hiveConfig_->isFileColumnNamesReadAsLowerCase(
-          connectorQueryCtx->sessionProperties())) {
-    checkColumnNameLowerCase(outputType_);
-    checkColumnNameLowerCase(hiveTableHandle_->subfieldFilters(), infoColumns_);
-    checkColumnNameLowerCase(hiveTableHandle_->remainingFilter());
-  }
-
-  for (const auto& [k, v] : hiveTableHandle_->subfieldFilters()) {
-    filters_.emplace(k.clone(), v);
-  }
-  double sampleRate = 1;
-  auto remainingFilter = extractFiltersFromRemainingFilter(
-      hiveTableHandle_->remainingFilter(),
-      expressionEvaluator_,
-      false,
-      filters_,
-      sampleRate);
-  if (sampleRate != 1) {
-    randomSkip_ = std::make_shared<random::RandomSkipTracker>(sampleRate);
-  }
-
-  if (remainingFilter) {
-    remainingFilterExprSet_ = expressionEvaluator_->compile(remainingFilter);
-    auto& remainingFilterExpr = remainingFilterExprSet_->expr(0);
-    folly::F14FastMap<std::string, column_index_t> columnNames;
-    for (int i = 0; i < readColumnNames.size(); ++i) {
-      columnNames[readColumnNames[i]] = i;
-    }
-    for (auto& input : remainingFilterExpr->distinctFields()) {
-      auto it = columnNames.find(input->field());
-      if (it != columnNames.end()) {
-        if (shouldEagerlyMaterialize(*remainingFilterExpr, *input)) {
-          multiReferencedFields_.push_back(it->second);
-        }
-        continue;
-      }
-      // Remaining filter may reference columns that are not used otherwise,
-      // e.g. are not being projected out and are not used in range filters.
-      // Make sure to add these columns to readerOutputType_.
-      readColumnNames.push_back(input->field());
-      readColumnTypes.push_back(input->type());
-    }
-    remainingFilterSubfields_ = remainingFilterExpr->extractSubfields();
-    if (VLOG_IS_ON(1)) {
-      VLOG(1) << fmt::format(
-          "Extracted subfields from remaining filter: [{}]",
-          fmt::join(remainingFilterSubfields_, ", "));
-    }
-    for (auto& subfield : remainingFilterSubfields_) {
-      const auto& name = getColumnName(subfield);
-      auto it = subfields_.find(name);
-      if (it != subfields_.end()) {
-        // Some subfields of the column are already projected out, we append the
-        // remainingFilter subfield
-        it->second.push_back(&subfield);
-      } else if (columnNames.count(name) == 0) {
-        // remainingFilter subfield's column is not projected out, we add the
-        // column and append the subfield
-        subfields_[name].push_back(&subfield);
-      }
-    }
-  }
-
-  readerOutputType_ =
-      ROW(std::move(readColumnNames), std::move(readColumnTypes));
-  scanSpec_ = makeScanSpec(
-      readerOutputType_,
-      subfields_,
-      filters_,
-      hiveTableHandle_->dataColumns(),
-      partitionKeys_,
-      infoColumns_,
-      specialColumns_,
-      hiveConfig_->readStatsBasedFilterReorderDisabled(
-          connectorQueryCtx_->sessionProperties()),
-      pool_);
-  if (remainingFilter) {
-    metadataFilter_ = std::make_shared<common::MetadataFilter>(
-        *scanSpec_, *remainingFilter, expressionEvaluator_);
-  }
-
-  ioStats_ = std::make_shared<io::IoStatistics>();
-  fsStats_ = std::make_shared<filesystems::File::IoStats>();
-}
-
-std::unique_ptr<SplitReader> HiveDataSource::createSplitReader() {
-  return SplitReader::create(
-      split_,
-      hiveTableHandle_,
-      &partitionKeys_,
-      connectorQueryCtx_,
-      hiveConfig_,
-      readerOutputType_,
-      ioStats_,
-      fsStats_,
-      fileHandleFactory_,
-      ioExecutor_,
-      scanSpec_);
-}
+    : FileDataSource(
+          outputType,
+          tableHandle,
+          assignments,
+          fileHandleFactory,
+          ioExecutor,
+          connectorQueryCtx,
+          hiveConfig),
+      hiveConfig_(hiveConfig) {}
 
 std::vector<column_index_t> HiveDataSource::setupBucketConversion() {
+  auto hiveSplit = checkedPointerCast<const HiveConnectorSplit>(split_);
   VELOX_CHECK_NE(
-      split_->bucketConversion->tableBucketCount,
-      split_->bucketConversion->partitionBucketCount);
-  VELOX_CHECK(split_->tableBucketNumber.has_value());
-  VELOX_CHECK_NOT_NULL(hiveTableHandle_->dataColumns());
+      hiveSplit->bucketConversion->tableBucketCount,
+      hiveSplit->bucketConversion->partitionBucketCount);
+  VELOX_CHECK(hiveSplit->tableBucketNumber.has_value());
+  VELOX_CHECK_NOT_NULL(tableHandle_->dataColumns());
   ++numBucketConversion_;
   bool rebuildScanSpec = false;
   std::vector<std::string> names;
   std::vector<TypePtr> types;
   std::vector<column_index_t> bucketChannels;
-  for (auto& handle : split_->bucketConversion->bucketColumnHandles) {
-    VELOX_CHECK(handle->columnType() == HiveColumnHandle::ColumnType::kRegular);
+  for (auto& handle : hiveSplit->bucketConversion->bucketColumnHandles) {
+    VELOX_CHECK(handle->columnType() == FileColumnHandle::ColumnType::kRegular);
     if (subfields_.erase(handle->name()) > 0) {
       rebuildScanSpec = true;
     }
@@ -241,8 +68,7 @@ std::vector<column_index_t> HiveDataSource::setupBucketConversion() {
       }
       index = names.size();
       names.push_back(handle->name());
-      types.push_back(
-          hiveTableHandle_->dataColumns()->findChild(handle->name()));
+      types.push_back(tableHandle_->dataColumns()->findChild(handle->name()));
       rebuildScanSpec = true;
     }
     bucketChannels.push_back(*index);
@@ -255,11 +81,12 @@ std::vector<column_index_t> HiveDataSource::setupBucketConversion() {
         readerOutputType_,
         subfields_,
         filters_,
-        hiveTableHandle_->dataColumns(),
+        /*indexColumns=*/{},
+        tableHandle_->dataColumns(),
         partitionKeys_,
         infoColumns_,
         specialColumns_,
-        hiveConfig_->readStatsBasedFilterReorderDisabled(
+        fileConfig_->readStatsBasedFilterReorderDisabled(
             connectorQueryCtx_->sessionProperties()),
         pool_);
     newScanSpec->moveAdaptationFrom(*scanSpec_);
@@ -269,8 +96,9 @@ std::vector<column_index_t> HiveDataSource::setupBucketConversion() {
 }
 
 void HiveDataSource::setupRowIdColumn() {
-  VELOX_CHECK(split_->rowIdProperties.has_value());
-  const auto& props = *split_->rowIdProperties;
+  auto hiveSplit = checkedPointerCast<const HiveConnectorSplit>(split_);
+  VELOX_CHECK(hiveSplit->rowIdProperties.has_value());
+  const auto& props = *hiveSplit->rowIdProperties;
   auto* rowId = scanSpec_->childByName(*specialColumns_.rowId);
   VELOX_CHECK_NOT_NULL(rowId);
   auto& rowIdType =
@@ -292,247 +120,65 @@ void HiveDataSource::setupRowIdColumn() {
           connectorQueryCtx_->memoryPool());
 }
 
-void HiveDataSource::addSplit(std::shared_ptr<ConnectorSplit> split) {
-  VELOX_CHECK_NULL(
-      split_,
-      "Previous split has not been processed yet. Call next to process the split.");
-  split_ = std::dynamic_pointer_cast<HiveConnectorSplit>(split);
-  VELOX_CHECK_NOT_NULL(split_, "Wrong type of split");
-
-  VLOG(1) << "Adding split " << split_->toString();
-
-  if (splitReader_) {
-    splitReader_.reset();
-  }
-
+std::vector<column_index_t> HiveDataSource::prepareSplit() {
+  auto hiveSplit = checkedPointerCast<const HiveConnectorSplit>(split_);
+  ++numSplitsByFileFormat_[split_->fileFormat];
   std::vector<column_index_t> bucketChannels;
-  if (split_->bucketConversion.has_value()) {
+  if (hiveSplit->bucketConversion.has_value()) {
     bucketChannels = setupBucketConversion();
   }
   if (specialColumns_.rowId.has_value()) {
     setupRowIdColumn();
   }
-
-  splitReader_ = createSplitReader();
-  if (!bucketChannels.empty()) {
-    splitReader_->setBucketConversion(std::move(bucketChannels));
-  }
-  // Split reader subclasses may need to use the reader options in prepareSplit
-  // so we initialize it beforehand.
-  splitReader_->configureReaderOptions(randomSkip_);
-  splitReader_->prepareSplit(metadataFilter_, runtimeStats_);
-  readerOutputType_ = splitReader_->readerOutputType();
+  return bucketChannels;
 }
 
-std::optional<RowVectorPtr> HiveDataSource::next(
-    uint64_t size,
-    velox::ContinueFuture& /*future*/) {
-  VELOX_CHECK(split_ != nullptr, "No split to process. Call addSplit first.");
-  VELOX_CHECK_NOT_NULL(splitReader_, "No split reader present");
-
-  TestValue::adjust(
-      "facebook::velox::connector::hive::HiveDataSource::next", this);
-
-  if (splitReader_->emptySplit()) {
-    resetSplit();
-    return nullptr;
-  }
-
-  // Bucket conversion or delta update could add extra column to reader output.
-  auto needsExtraColumn = [&] {
-    return output_->asUnchecked<RowVector>()->childrenSize() <
-        readerOutputType_->size();
-  };
-  if (!output_ || needsExtraColumn()) {
-    output_ = BaseVector::create(readerOutputType_, 0, pool_);
-  }
-
-  const auto rowsScanned = splitReader_->next(size, output_);
-  completedRows_ += rowsScanned;
-  if (rowsScanned == 0) {
-    splitReader_->updateRuntimeStats(runtimeStats_);
-    resetSplit();
-    return nullptr;
-  }
-
-  VELOX_CHECK(
-      !output_->mayHaveNulls(), "Top-level row vector cannot have nulls");
-  auto rowsRemaining = output_->size();
-  if (rowsRemaining == 0) {
-    // no rows passed the pushed down filters.
-    return getEmptyOutput();
-  }
-
-  auto rowVector = std::dynamic_pointer_cast<RowVector>(output_);
-
-  // In case there is a remaining filter that excludes some but not all
-  // rows, collect the indices of the passing rows. If there is no filter,
-  // or it passes on all rows, leave this as null and let exec::wrap skip
-  // wrapping the results.
-  BufferPtr remainingIndices;
-  filterRows_.resize(rowVector->size());
-
-  if (remainingFilterExprSet_) {
-    rowsRemaining = evaluateRemainingFilter(rowVector);
-    VELOX_CHECK_LE(rowsRemaining, rowsScanned);
-    if (rowsRemaining == 0) {
-      // No rows passed the remaining filter.
-      return getEmptyOutput();
-    }
-
-    if (rowsRemaining < rowVector->size()) {
-      // Some, but not all rows passed the remaining filter.
-      remainingIndices = filterEvalCtx_.selectedIndices;
-    }
-  }
-
-  if (outputType_->size() == 0) {
-    return exec::wrap(rowsRemaining, remainingIndices, rowVector);
-  }
-
-  std::vector<VectorPtr> outputColumns;
-  outputColumns.reserve(outputType_->size());
-  for (int i = 0; i < outputType_->size(); ++i) {
-    auto& child = rowVector->childAt(i);
-    if (remainingIndices) {
-      // Disable dictionary values caching in expression eval so that we
-      // don't need to reallocate the result for every batch.
-      child->disableMemo();
-    }
-    outputColumns.emplace_back(
-        exec::wrapChild(rowsRemaining, remainingIndices, child));
-  }
-
-  return std::make_shared<RowVector>(
-      pool_, outputType_, BufferPtr(nullptr), rowsRemaining, outputColumns);
-}
+std::unique_ptr<FileSplitReader> HiveDataSource::createSplitReader() {
+  auto bucketChannels = prepareSplit();
+  auto hiveSplit = checkedPointerCast<const HiveConnectorSplit>(split_);
 
-void HiveDataSource::addDynamicFilter(
-    column_index_t outputChannel,
-    const std::shared_ptr<common::Filter>& filter) {
-  auto& fieldSpec = scanSpec_->getChildByChannel(outputChannel);
-  fieldSpec.setFilter(filter);
-  scanSpec_->resetCachedValues(true);
-  if (splitReader_) {
-    splitReader_->resetFilterCaches();
-  }
+  return std::make_unique<HiveSplitReader>(
+      hiveSplit,
+      tableHandle_,
+      &partitionKeys_,
+      connectorQueryCtx_,
+      fileConfig_,
+      readerOutputType_,
+      dataIoStats_,
+      metadataIoStats_,
+      ioStats_,
+      fileHandleFactory_,
+      ioExecutor_,
+      scanSpec_,
+      &infoColumns_,
+      std::move(bucketChannels),
+      /*subfieldFiltersForValidation=*/&filters_);
 }
 
-std::unordered_map<std::string, RuntimeCounter> HiveDataSource::runtimeStats() {
-  auto res = runtimeStats_.toMap();
-  res.insert(
-      {{"numPrefetch", RuntimeCounter(ioStats_->prefetch().count())},
-       {"prefetchBytes",
-        RuntimeCounter(
-            ioStats_->prefetch().sum(), RuntimeCounter::Unit::kBytes)},
-       {"totalScanTime",
-        RuntimeCounter(
-            ioStats_->totalScanTime(), RuntimeCounter::Unit::kNanos)},
-       {Connector::kTotalRemainingFilterTime,
-        RuntimeCounter(
-            totalRemainingFilterTime_.load(std::memory_order_relaxed),
-            RuntimeCounter::Unit::kNanos)},
-       {"ioWaitWallNanos",
-        RuntimeCounter(
-            ioStats_->queryThreadIoLatency().sum() * 1000,
-            RuntimeCounter::Unit::kNanos)},
-       {"maxSingleIoWaitWallNanos",
-        RuntimeCounter(
-            ioStats_->queryThreadIoLatency().max() * 1000,
-            RuntimeCounter::Unit::kNanos)},
-       {"overreadBytes",
-        RuntimeCounter(
-            ioStats_->rawOverreadBytes(), RuntimeCounter::Unit::kBytes)}});
-  if (ioStats_->read().count() > 0) {
-    res.insert({"numStorageRead", RuntimeCounter(ioStats_->read().count())});
-    res.insert(
-        {"storageReadBytes",
-         RuntimeCounter(ioStats_->read().sum(), RuntimeCounter::Unit::kBytes)});
-  }
-  if (ioStats_->ssdRead().count() > 0) {
-    res.insert({"numLocalRead", RuntimeCounter(ioStats_->ssdRead().count())});
-    res.insert(
-        {"localReadBytes",
-         RuntimeCounter(
-             ioStats_->ssdRead().sum(), RuntimeCounter::Unit::kBytes)});
-  }
-  if (ioStats_->ramHit().count() > 0) {
-    res.insert({"numRamRead", RuntimeCounter(ioStats_->ramHit().count())});
-    res.insert(
-        {"ramReadBytes",
-         RuntimeCounter(
-             ioStats_->ramHit().sum(), RuntimeCounter::Unit::kBytes)});
-  }
+std::unordered_map<std::string, RuntimeMetric>
+HiveDataSource::getRuntimeStats() {
+  auto result = FileDataSource::getRuntimeStats();
   if (numBucketConversion_ > 0) {
-    res.insert({"numBucketConversion", RuntimeCounter(numBucketConversion_)});
+    result.insert(
+        {std::string(kNumBucketConversion),
+         RuntimeMetric(numBucketConversion_)});
   }
-
-  const auto fsStats = fsStats_->stats();
-  for (const auto& storageStats : fsStats) {
-    res.emplace(
-        storageStats.first,
-        RuntimeCounter(storageStats.second.sum, storageStats.second.unit));
+  for (const auto& [format, count] : numSplitsByFileFormat_) {
+    result.insert(
+        {fmt::format("{}{}", kFileFormat, dwio::common::toString(format)),
+         RuntimeMetric(count)});
   }
-  return res;
+  return result;
 }
 
 void HiveDataSource::setFromDataSource(
     std::unique_ptr<DataSource> sourceUnique) {
-  auto source = dynamic_cast<HiveDataSource*>(sourceUnique.get());
-  VELOX_CHECK_NOT_NULL(source, "Bad DataSource type");
-
-  split_ = std::move(source->split_);
-  runtimeStats_.skippedSplits += source->runtimeStats_.skippedSplits;
-  runtimeStats_.processedSplits += source->runtimeStats_.processedSplits;
-  runtimeStats_.skippedSplitBytes += source->runtimeStats_.skippedSplitBytes;
-  readerOutputType_ = std::move(source->readerOutputType_);
-  source->scanSpec_->moveAdaptationFrom(*scanSpec_);
-  scanSpec_ = std::move(source->scanSpec_);
-  splitReader_ = std::move(source->splitReader_);
-  splitReader_->setConnectorQueryCtx(connectorQueryCtx_);
-  // New io will be accounted on the stats of 'source'. Add the existing
-  // balance to that.
-  source->ioStats_->merge(*ioStats_);
-  ioStats_ = std::move(source->ioStats_);
-  source->fsStats_->merge(*fsStats_);
-  fsStats_ = std::move(source->fsStats_);
-
+  auto* source = checkedPointerCast<HiveDataSource>(sourceUnique.get());
   numBucketConversion_ += source->numBucketConversion_;
-}
-
-int64_t HiveDataSource::estimatedRowSize() {
-  if (!splitReader_) {
-    return kUnknownRowSize;
+  for (const auto& [format, count] : source->numSplitsByFileFormat_) {
+    numSplitsByFileFormat_[format] += count;
   }
-  return splitReader_->estimatedRowSize();
-}
-
-vector_size_t HiveDataSource::evaluateRemainingFilter(RowVectorPtr& rowVector) {
-  for (auto fieldIndex : multiReferencedFields_) {
-    LazyVector::ensureLoadedRows(
-        rowVector->childAt(fieldIndex),
-        filterRows_,
-        filterLazyDecoded_,
-        filterLazyBaseRows_);
-  }
-  uint64_t filterTimeUs{0};
-  vector_size_t rowsRemaining{0};
-  {
-    MicrosecondTimer timer(&filterTimeUs);
-    expressionEvaluator_->evaluate(
-        remainingFilterExprSet_.get(), filterRows_, *rowVector, filterResult_);
-    rowsRemaining = exec::processFilterResults(
-        filterResult_, filterRows_, filterEvalCtx_, pool_);
-  }
-  totalRemainingFilterTime_.fetch_add(
-      filterTimeUs * 1000, std::memory_order_relaxed);
-  return rowsRemaining;
-}
-
-void HiveDataSource::resetSplit() {
-  split_.reset();
-  splitReader_->resetSplit();
-  // Keep readers around to hold adaptation.
+  FileDataSource::setFromDataSource(std::move(sourceUnique));
 }
 
 HiveDataSource::WaveDelegateHookFunction HiveDataSource::waveDelegateHook_;
@@ -540,8 +186,10 @@ HiveDataSource::WaveDelegateHookFunction HiveDataSource::waveDelegateHook_;
 std::shared_ptr<wave::WaveDataSource> HiveDataSource::toWaveDataSource() {
   VELOX_CHECK_NOT_NULL(waveDelegateHook_);
   if (!waveDataSource_) {
+    auto hiveTableHandle =
+        checkedPointerCast<const HiveTableHandle>(tableHandle_);
     waveDataSource_ = waveDelegateHook_(
-        hiveTableHandle_,
+        hiveTableHandle,
         scanSpec_,
         readerOutputType_,
         &partitionKeys_,
@@ -549,9 +197,9 @@ std::shared_ptr<wave::WaveDataSource> HiveDataSource::toWaveDataSource() {
         ioExecutor_,
         connectorQueryCtx_,
         hiveConfig_,
-        ioStats_,
-        remainingFilterExprSet_.get(),
-        metadataFilter_);
+        dataIoStats_,
+        remainingFilterExprSet(),
+        metadataFilter());
   }
   return waveDataSource_;
 }
@@ -560,6 +208,5 @@ std::shared_ptr<wave::WaveDataSource> HiveDataSource::toWaveDataSource() {
 void HiveDataSource::registerWaveDelegateHook(WaveDelegateHookFunction hook) {
   waveDelegateHook_ = hook;
 }
-std::shared_ptr<wave::WaveDataSource> toWaveDataSource();
 
 } // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HiveDataSource.h b/velox/connectors/hive/HiveDataSource.h
index 64aa3d6420b..df6dbd4c539 100644
--- a/velox/connectors/hive/HiveDataSource.h
+++ b/velox/connectors/hive/HiveDataSource.h
@@ -15,65 +15,31 @@
  */
 #pragma once
 
-#include "velox/common/base/RandomUtil.h"
-#include "velox/common/file/FileSystems.h"
-#include "velox/common/io/IoStatistics.h"
-#include "velox/connectors/Connector.h"
-#include "velox/connectors/hive/FileHandle.h"
-#include "velox/connectors/hive/HiveConnectorSplit.h"
-#include "velox/connectors/hive/HiveConnectorUtil.h"
-#include "velox/connectors/hive/SplitReader.h"
+#include "velox/connectors/hive/FileDataSource.h"
 #include "velox/connectors/hive/TableHandle.h"
-#include "velox/dwio/common/Statistics.h"
-#include "velox/exec/OperatorUtils.h"
-#include "velox/expression/Expr.h"
 
 namespace facebook::velox::connector::hive {
 
 class HiveConfig;
 
-class HiveDataSource : public DataSource {
+class HiveDataSource : public FileDataSource {
  public:
+  static constexpr std::string_view kNumBucketConversion{"numBucketConversion"};
+  static constexpr std::string_view kFileFormat{"fileFormat."};
+
   HiveDataSource(
       const RowTypePtr& outputType,
       const connector::ConnectorTableHandlePtr& tableHandle,
-      const connector::ColumnHandleMap& columnHandles,
+      const connector::ColumnHandleMap& assignments,
       FileHandleFactory* fileHandleFactory,
-      folly::Executor* executor,
+      folly::Executor* ioExecutor,
       const ConnectorQueryCtx* connectorQueryCtx,
       const std::shared_ptr<HiveConfig>& hiveConfig);
 
-  void addSplit(std::shared_ptr<ConnectorSplit> split) override;
-
-  std::optional<RowVectorPtr> next(uint64_t size, velox::ContinueFuture& future)
-      override;
-
-  void addDynamicFilter(
-      column_index_t outputChannel,
-      const std::shared_ptr<common::Filter>& filter) override;
-
-  uint64_t getCompletedBytes() override {
-    return ioStats_->rawBytesRead();
-  }
-
-  uint64_t getCompletedRows() override {
-    return completedRows_;
-  }
-
-  std::unordered_map<std::string, RuntimeCounter> runtimeStats() override;
-
-  bool allPrefetchIssued() const override {
-    return splitReader_ && splitReader_->allPrefetchIssued();
-  }
+  std::unordered_map<std::string, RuntimeMetric> getRuntimeStats() override;
 
   void setFromDataSource(std::unique_ptr<DataSource> sourceUnique) override;
 
-  int64_t estimatedRowSize() override;
-
-  const common::SubfieldFilters* getFilters() const override {
-    return &filters_;
-  }
-
   std::shared_ptr<wave::WaveDataSource> toWaveDataSource() override;
 
   using WaveDelegateHookFunction =
@@ -81,12 +47,12 @@ class HiveDataSource : public DataSource {
           const HiveTableHandlePtr& hiveTableHandle,
           const std::shared_ptr<common::ScanSpec>& scanSpec,
           const RowTypePtr& readerOutputType,
-          std::unordered_map<std::string, HiveColumnHandlePtr>* partitionKeys,
+          std::unordered_map<std::string, FileColumnHandlePtr>* partitionKeys,
           FileHandleFactory* fileHandleFactory,
           folly::Executor* executor,
           const ConnectorQueryCtx* connectorQueryCtx,
           const std::shared_ptr<HiveConfig>& hiveConfig,
-          const std::shared_ptr<io::IoStatistics>& ioStats,
+          const std::shared_ptr<io::IoStatistics>& ioStatistics,
           const exec::ExprSet* remainingFilter,
           std::shared_ptr<common::MetadataFilter> metadataFilter)>;
 
@@ -94,94 +60,25 @@ class HiveDataSource : public DataSource {
 
   static void registerWaveDelegateHook(WaveDelegateHookFunction hook);
 
-  const ConnectorQueryCtx* testingConnectorQueryCtx() const {
-    return connectorQueryCtx_;
-  }
-
  protected:
-  virtual std::unique_ptr<SplitReader> createSplitReader();
-
-  FileHandleFactory* const fileHandleFactory_;
-  folly::Executor* const ioExecutor_;
-  const ConnectorQueryCtx* const connectorQueryCtx_;
-  const std::shared_ptr<HiveConfig> hiveConfig_;
-  memory::MemoryPool* const pool_;
+  std::unique_ptr<FileSplitReader> createSplitReader() override;
 
-  std::shared_ptr<HiveConnectorSplit> split_;
-  HiveTableHandlePtr hiveTableHandle_;
-  std::shared_ptr<common::ScanSpec> scanSpec_;
-  VectorPtr output_;
-  std::unique_ptr<SplitReader> splitReader_;
-
-  // Output type from file reader.  This is different from outputType_ that it
-  // contains column names before assignment, and columns that only used in
-  // remaining filter.
-  RowTypePtr readerOutputType_;
-
-  // Column handles for the partition key columns keyed on partition key column
-  // name.
-  std::unordered_map<std::string, HiveColumnHandlePtr> partitionKeys_;
-
-  std::shared_ptr<io::IoStatistics> ioStats_;
-  std::shared_ptr<filesystems::File::IoStats> fsStats_;
+  /// Pre-creation setup: stats tracking, bucket conversion, rowId.
+  /// Returns bucket channels (empty if none).
+  std::vector<column_index_t> prepareSplit();
 
  private:
   std::vector<column_index_t> setupBucketConversion();
 
   void setupRowIdColumn();
 
-  // Evaluates remainingFilter_ on the specified vector. Returns number of rows
-  // passed. Populates filterEvalCtx_.selectedIndices and selectedBits if only
-  // some rows passed the filter. If none or all rows passed
-  // filterEvalCtx_.selectedIndices and selectedBits are not updated.
-  vector_size_t evaluateRemainingFilter(RowVectorPtr& rowVector);
-
-  // Clear split_ after split has been fully processed.  Keep readers around to
-  // hold adaptation.
-  void resetSplit();
-
-  const RowVectorPtr& getEmptyOutput() {
-    if (!emptyOutput_) {
-      emptyOutput_ = RowVector::createEmpty(outputType_, pool_);
-    }
-    return emptyOutput_;
-  }
-
-  // The row type for the data source output, not including filter-only columns
-  const RowTypePtr outputType_;
-  core::ExpressionEvaluator* const expressionEvaluator_;
-
-  // Column handles for the Split info columns keyed on their column names.
-  std::unordered_map<std::string, HiveColumnHandlePtr> infoColumns_;
-  SpecialColumnNames specialColumns_{};
-  std::vector<common::Subfield> remainingFilterSubfields_;
-  folly::F14FastMap<std::string, std::vector<const common::Subfield*>>
-      subfields_;
-  common::SubfieldFilters filters_;
-  std::shared_ptr<common::MetadataFilter> metadataFilter_;
-  std::unique_ptr<exec::ExprSet> remainingFilterExprSet_;
-  RowVectorPtr emptyOutput_;
-  dwio::common::RuntimeStatistics runtimeStats_;
-  std::atomic<uint64_t> totalRemainingFilterTime_{0};
-  uint64_t completedRows_ = 0;
-
-  // Field indices referenced in both remaining filter and output type. These
-  // columns need to be materialized eagerly to avoid missing values in output.
-  std::vector<column_index_t> multiReferencedFields_;
-
-  std::shared_ptr<random::RandomSkipTracker> randomSkip_;
+  const std::shared_ptr<HiveConfig> hiveConfig_;
 
   int64_t numBucketConversion_ = 0;
 
-  // Reusable memory for remaining filter evaluation.
-  VectorPtr filterResult_;
-  SelectivityVector filterRows_;
-  DecodedVector filterLazyDecoded_;
-  SelectivityVector filterLazyBaseRows_;
-  exec::FilterEvalCtx filterEvalCtx_;
+  // Tracks the number of splits read per file format.
+  std::unordered_map<dwio::common::FileFormat, int64_t> numSplitsByFileFormat_;
 
-  // Remembers the WaveDataSource. Successive calls to toWaveDataSource() will
-  // return the same.
   std::shared_ptr<wave::WaveDataSource> waveDataSource_;
 };
 } // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HiveIndexSource.cpp b/velox/connectors/hive/HiveIndexSource.cpp
new file mode 100644
index 00000000000..225fd6ea3cd
--- /dev/null
+++ b/velox/connectors/hive/HiveIndexSource.cpp
@@ -0,0 +1,1370 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/connectors/hive/HiveIndexSource.h"
+
+#include <folly/ScopeGuard.h>
+#include <folly/container/F14Set.h>
+#include "velox/common/base/RuntimeMetrics.h"
+#include "velox/common/time/CpuWallTimer.h"
+#include "velox/common/time/Timer.h"
+#include "velox/connectors/hive/FileDataSource.h"
+#include "velox/connectors/hive/FileIndexReader.h"
+#include "velox/connectors/hive/FileSplitReader.h"
+#include "velox/connectors/hive/HiveConfig.h"
+#include "velox/connectors/hive/HiveConnectorUtil.h"
+#include "velox/exec/OperatorUtils.h"
+#include "velox/expression/FieldReference.h"
+#include "velox/vector/LazyVector.h"
+
+namespace facebook::velox::connector::hive {
+namespace {
+
+// Extracts a constant value from a point lookup filter (single value equality).
+// Returns nullopt if the filter is not a point lookup or cannot be converted.
+std::optional<variant> extractPointLookupValue(const common::Filter* filter) {
+  VELOX_CHECK_NOT_NULL(filter);
+
+  switch (filter->kind()) {
+    case common::FilterKind::kBigintRange: {
+      const auto* range = filter->as<common::BigintRange>();
+      if (range->isSingleValue()) {
+        return variant(range->lower());
+      }
+      return std::nullopt;
+    }
+    case common::FilterKind::kDoubleRange: {
+      const auto* range = filter->as<common::DoubleRange>();
+      if (!range->lowerUnbounded() && !range->upperUnbounded() &&
+          range->lower() == range->upper() && !range->lowerExclusive() &&
+          !range->upperExclusive()) {
+        return variant(range->lower());
+      }
+      return std::nullopt;
+    }
+    case common::FilterKind::kFloatRange: {
+      const auto* range = filter->as<common::FloatRange>();
+      if (!range->lowerUnbounded() && !range->upperUnbounded() &&
+          range->lower() == range->upper() && !range->lowerExclusive() &&
+          !range->upperExclusive()) {
+        return variant(range->lower());
+      }
+      return std::nullopt;
+    }
+    case common::FilterKind::kBytesRange: {
+      const auto* range = filter->as<common::BytesRange>();
+      if (range->isSingleValue()) {
+        return variant(range->lower());
+      }
+      return std::nullopt;
+    }
+    case common::FilterKind::kBytesValues: {
+      const auto* values = filter->as<common::BytesValues>();
+      if (values->values().size() == 1) {
+        return variant(*values->values().begin());
+      }
+      return std::nullopt;
+    }
+    case common::FilterKind::kBoolValue: {
+      const auto* boolFilter = filter->as<common::BoolValue>();
+      // BoolValue doesn't expose value() getter - use testBool to determine the
+      // value
+      return variant(boolFilter->testBool(true));
+    }
+    default:
+      return std::nullopt;
+  }
+}
+
+// Extracts range bounds from a range filter.
+// Returns a pair of (lower, upper) variants. If a bound is unbounded, the
+// corresponding variant will be null.
+// Returns nullopt if the filter is not a range filter or cannot be converted.
+std::optional<std::pair<variant, variant>> extractRangeBounds(
+    const common::Filter* filter) {
+  VELOX_CHECK_NOT_NULL(filter);
+
+  switch (filter->kind()) {
+    case common::FilterKind::kBigintRange: {
+      const auto* range = filter->as<common::BigintRange>();
+      return std::make_pair(variant(range->lower()), variant(range->upper()));
+    }
+    case common::FilterKind::kDoubleRange: {
+      const auto* range = filter->as<common::DoubleRange>();
+      if (range->lowerUnbounded() || range->upperUnbounded()) {
+        // Cannot convert unbounded ranges to BetweenCondition.
+        return std::nullopt;
+      }
+      return std::make_pair(variant(range->lower()), variant(range->upper()));
+    }
+    case common::FilterKind::kFloatRange: {
+      const auto* range = filter->as<common::FloatRange>();
+      if (range->lowerUnbounded() || range->upperUnbounded()) {
+        return std::nullopt;
+      }
+      return std::make_pair(variant(range->lower()), variant(range->upper()));
+    }
+    case common::FilterKind::kBytesRange: {
+      const auto* range = filter->as<common::BytesRange>();
+      if (!range->isSingleValue()) {
+        // Only convert bounded range filters.
+        return std::make_pair(variant(range->lower()), variant(range->upper()));
+      }
+      return std::nullopt;
+    }
+    default:
+      return std::nullopt;
+  }
+}
+
+// Creates an EqualIndexLookupCondition with a constant value.
+core::IndexLookupConditionPtr createEqualConditionWithConstant(
+    const std::string& columnName,
+    const TypePtr& type,
+    const variant& value) {
+  auto keyExpr = std::make_shared<core::FieldAccessTypedExpr>(type, columnName);
+  auto constantExpr = std::make_shared<core::ConstantTypedExpr>(type, value);
+  return std::make_shared<core::EqualIndexLookupCondition>(
+      std::move(keyExpr), std::move(constantExpr));
+}
+
+// Creates a BetweenIndexLookupCondition with constant bounds.
+core::IndexLookupConditionPtr createBetweenConditionWithConstants(
+    const std::string& columnName,
+    const TypePtr& type,
+    const variant& lowerValue,
+    const variant& upperValue) {
+  auto keyExpr = std::make_shared<core::FieldAccessTypedExpr>(type, columnName);
+  auto lowerExpr = std::make_shared<core::ConstantTypedExpr>(type, lowerValue);
+  auto upperExpr = std::make_shared<core::ConstantTypedExpr>(type, upperValue);
+  return std::make_shared<core::BetweenIndexLookupCondition>(
+      std::move(keyExpr), std::move(lowerExpr), std::move(upperExpr));
+}
+
+// Checks that a HiveColumnHandle is a regular column type.
+void checkColumnHandleIsRegular(const FileColumnHandle& handle) {
+  VELOX_CHECK_EQ(
+      handle.columnType(),
+      FileColumnHandle::ColumnType::kRegular,
+      "Expected regular column, got {} for column {}",
+      FileColumnHandle::columnTypeName(handle.columnType()),
+      handle.name());
+}
+
+// Gets the table column name from assignments for a given input column name.
+// Throws if not found in assignments.
+std::string getTableColumnName(
+    const std::string& inputColumnName,
+    const connector::ColumnHandleMap& assignments) {
+  auto it = assignments.find(inputColumnName);
+  VELOX_USER_CHECK(
+      it != assignments.end(),
+      "Column not found in assignments: {}",
+      inputColumnName);
+  const auto* handle =
+      checkedPointerCast<const HiveColumnHandle>(it->second.get());
+  return handle->name();
+}
+
+// Creates a new FieldAccessTypedExpr with the given column name but same type.
+core::FieldAccessTypedExprPtr renameFieldAccess(
+    const core::FieldAccessTypedExprPtr& field,
+    const std::string& newName) {
+  return std::make_shared<core::FieldAccessTypedExpr>(field->type(), newName);
+}
+
+// Converts an index lookup condition's key name from input column name to table
+// column name. Returns a new condition with the converted key name.
+core::IndexLookupConditionPtr convertConditionKeyName(
+    const core::IndexLookupConditionPtr& condition,
+    const connector::ColumnHandleMap& assignments) {
+  const auto tableColumnName =
+      getTableColumnName(condition->key->name(), assignments);
+  auto newKey = renameFieldAccess(condition->key, tableColumnName);
+
+  if (auto equalCondition =
+          std::dynamic_pointer_cast<core::EqualIndexLookupCondition>(
+              condition)) {
+    return std::make_shared<core::EqualIndexLookupCondition>(
+        std::move(newKey), equalCondition->value);
+  }
+  if (auto betweenCondition =
+          std::dynamic_pointer_cast<core::BetweenIndexLookupCondition>(
+              condition)) {
+    return std::make_shared<core::BetweenIndexLookupCondition>(
+        std::move(newKey), betweenCondition->lower, betweenCondition->upper);
+  }
+
+  VELOX_UNREACHABLE(
+      "Unsupported IndexLookupCondition type: {}", condition->toString());
+}
+
+// Filters input indices based on selected indices from filter evaluation.
+BufferPtr filterIndices(
+    vector_size_t numRows,
+    const BufferPtr& selectedIndices,
+    const BufferPtr& inputIndices,
+    memory::MemoryPool* pool) {
+  auto resultIndices = allocateIndices(numRows, pool);
+  auto* rawResultIndices = resultIndices->asMutable<vector_size_t>();
+  const auto* rawSelected = selectedIndices->as<vector_size_t>();
+  const auto* rawInputIndices = inputIndices->as<vector_size_t>();
+  for (vector_size_t i = 0; i < numRows; ++i) {
+    rawResultIndices[i] = rawInputIndices[rawSelected[i]];
+  }
+  return resultIndices;
+}
+} // namespace
+
+namespace {
+
+// Merges results from multiple split-level ResultIterators in inputHit order.
+// Each split independently produces results with sorted inputHits. This
+// iterator interleaves rows across splits to maintain the global non-decreasing
+// inputHit ordering required by IndexLookupJoin (for left join missed-row
+// detection and the check in prepareLookupResult).
+//
+// Uses a k-way merge: buffers one Result per split, then repeatedly picks
+// the split with the smallest current request index and copies all its rows
+// for that index before moving on.
+class UnionResultIterator : public IndexSource::ResultIterator {
+ public:
+  UnionResultIterator(
+      std::vector<std::shared_ptr<IndexSource::ResultIterator>> splitIters,
+      const RowTypePtr& outputType,
+      memory::MemoryPool* pool)
+      : outputType_(outputType), pool_(pool) {
+    VELOX_CHECK_GT(
+        splitIters.size(),
+        1,
+        "UnionResultIterator requires at least two iterators");
+    splits_.reserve(splitIters.size());
+    for (auto& iter : splitIters) {
+      splits_.emplace_back(std::move(iter));
+    }
+  }
+
+  bool hasNext() override {
+    for (const auto& split : splits_) {
+      if (!split.hasExhausted()) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  std::optional<std::unique_ptr<IndexSource::Result>> next(
+      vector_size_t size,
+      ContinueFuture& future) override {
+    // Fetch results for all non-exhausted splits that need data.
+    for (auto& split : splits_) {
+      if (split.needFetchResult()) {
+        if (!split.fetchResult(size, future)) {
+          VELOX_CHECK(future.valid(), "Async return requires a valid future");
+          return std::nullopt;
+        }
+      }
+    }
+
+    // Merge rows from all active splits in inputHit order by repeatedly
+    // picking the split with the smallest current request index and copying
+    // all its rows for that index.
+    auto mergedInputHits = allocateIndices(size, pool_);
+    auto* rawMergedHits = mergedInputHits->asMutable<vector_size_t>();
+    auto mergedOutput = BaseVector::create<RowVector>(outputType_, size, pool_);
+
+    vector_size_t numOutput = 0;
+    while (numOutput < size) {
+      int minSplitIndex = -1;
+      auto minRequestIndex = std::numeric_limits<vector_size_t>::max();
+      for (size_t i = 0; i < splits_.size(); ++i) {
+        if (splits_[i].hasResult() &&
+            splits_[i].currentRequestIndex() < minRequestIndex) {
+          minSplitIndex = static_cast<int>(i);
+          minRequestIndex = splits_[i].currentRequestIndex();
+        }
+      }
+      if (minSplitIndex < 0) {
+        // All splits are exhausted with no buffered data.
+        break;
+      }
+
+      auto& split = splits_[minSplitIndex];
+      VELOX_CHECK_LE(numOutput, size);
+      numOutput += split.fillResult(
+          minRequestIndex,
+          mergedOutput,
+          numOutput,
+          rawMergedHits,
+          size - numOutput);
+
+      // Stop if this split's buffer is consumed but not exhausted. We must
+      // refill it before continuing to avoid emitting larger inputHits from
+      // other splits that would violate non-decreasing order across next()
+      // calls.
+      if (split.needFetchResult()) {
+        break;
+      }
+    }
+
+    if (numOutput == 0) {
+      return nullptr;
+    }
+
+    mergedInputHits->setSize(numOutput * sizeof(vector_size_t));
+    mergedOutput->resize(numOutput);
+    return std::make_unique<IndexSource::Result>(
+        std::move(mergedInputHits), std::move(mergedOutput));
+  }
+
+ private:
+  // Tracks iteration state for a single split's ResultIterator. Buffers
+  // one Result at a time and tracks the current read position within it.
+  struct SplitState {
+    explicit SplitState(std::shared_ptr<IndexSource::ResultIterator> splitIter)
+        : iter(std::move(splitIter)) {}
+
+    const std::shared_ptr<IndexSource::ResultIterator> iter;
+    // Current buffered result from this split, or nullptr if not yet fetched.
+    std::unique_ptr<IndexSource::Result> result;
+    // Next row to read within 'result'.
+    vector_size_t resultOffset{0};
+    // True when the underlying iterator has no more results.
+    bool exhausted{false};
+
+    // Returns true if there are unconsumed rows in the current buffered result.
+    bool hasResult() const {
+      return result != nullptr && resultOffset < result->size();
+    }
+
+    // Returns true if the underlying iterator has no more results.
+    bool hasExhausted() const {
+      return exhausted;
+    }
+
+    // Returns true if the split needs to fetch the next result batch.
+    bool needFetchResult() const {
+      return !hasResult() && !hasExhausted();
+    }
+
+    // Returns the request index (inputHit) of the current row in the buffer.
+    vector_size_t currentRequestIndex() const {
+      VELOX_CHECK(hasResult());
+      return result->inputHits->as<const vector_size_t>()[resultOffset];
+    }
+
+    // Copies buffered rows matching the given request index to the output,
+    // up to maxRows. Returns the number of rows copied.
+    vector_size_t fillResult(
+        vector_size_t requestIndex,
+        const RowVectorPtr& output,
+        vector_size_t outputOffset,
+        vector_size_t* rawHits,
+        vector_size_t maxRows) {
+      VELOX_CHECK(hasResult());
+      // Count contiguous rows with the same request index.
+      const auto* hits = result->inputHits->as<const vector_size_t>();
+      vector_size_t count = 0;
+      while (count < maxRows && resultOffset + count < result->size() &&
+             hits[resultOffset + count] == requestIndex) {
+        ++count;
+      }
+      if (count > 0) {
+        output->copy(result->output.get(), outputOffset, resultOffset, count);
+        std::fill(
+            rawHits + outputOffset,
+            rawHits + outputOffset + count,
+            requestIndex);
+        resultOffset += count;
+      }
+      return count;
+    }
+
+    // Fetches the next non-empty result from the underlying iterator.
+    // Returns true when data is ready (or split is exhausted), false if async.
+    bool fetchResult(vector_size_t size, ContinueFuture& future) {
+      VELOX_CHECK(
+          !hasResult(), "Must consume current result before fetching next");
+      while (!exhausted) {
+        if (!iter->hasNext()) {
+          exhausted = true;
+          return true;
+        }
+        auto resultOpt = iter->next(size, future);
+        if (!resultOpt.has_value()) {
+          return false;
+        }
+        auto fetchedResult = std::move(resultOpt).value();
+        if (fetchedResult == nullptr) {
+          exhausted = true;
+          return true;
+        }
+        // Skip empty results (e.g., when all rows are filtered out by
+        // remaining filter) and continue fetching.
+        if (fetchedResult->size() == 0) {
+          continue;
+        }
+        result = std::move(fetchedResult);
+        resultOffset = 0;
+        return true;
+      }
+      VELOX_UNREACHABLE();
+    }
+  };
+
+  // Output schema used to allocate merged result vectors.
+  const RowTypePtr outputType_;
+  memory::MemoryPool* const pool_;
+  // Per-split state for buffering and tracking iteration progress. Not const
+  // because elements are mutated during iteration (result, resultOffset,
+  // exhausted), and const vector makes elements const via const T& access.
+  std::vector<SplitState> splits_;
+};
+
+} // namespace
+
+// Scope-attached timer that accumulates wall and CPU time into the
+// corresponding iterationStats fields when the attached block exits.
+// Expects a local variable named 'iterationStats' of type
+// HiveIndexSource::IterationStats.
+//
+// Usage:
+//   RECORD_CPU_WALL(setup) {
+//     // timed work
+//   }
+#define RECORD_CPU_WALL(name)                                        \
+  if (DeltaCpuWallTimer _timer_##name([&](const CpuWallTiming& _t) { \
+        iterationStats.name##WallNs += _t.wallNanos;                 \
+        iterationStats.name##CpuNs += _t.cpuNanos;                   \
+      });                                                            \
+      true)
+
+/// Iterates over results from a SplitIndexReader and applies HiveIndexSource's
+/// format-agnostic orchestration: remaining filter evaluation and output
+/// projection.
+class HiveLookupIterator : public IndexSource::ResultIterator {
+ public:
+  HiveLookupIterator(
+      std::shared_ptr<HiveIndexSource> indexSource,
+      SplitIndexReader* indexReader,
+      IndexSource::Request request,
+      SplitIndexReader::Options options)
+      : indexSource_(std::move(indexSource)),
+        indexReader_(indexReader),
+        request_(std::move(request)),
+        options_(options) {}
+
+  bool hasNext() override {
+    return state_ != State::kEnd;
+  }
+
+  std::optional<std::unique_ptr<IndexSource::Result>> next(
+      vector_size_t size,
+      ContinueFuture& /*unused*/) override {
+    if (state_ == State::kEnd) {
+      return nullptr;
+    }
+
+    HiveIndexSource::IterationStats iterationStats;
+    SCOPE_EXIT {
+      indexSource_->recordIterationStats(iterationStats);
+    };
+
+    // Initialize lookup on first call.
+    if (state_ == State::kInit) {
+      RECORD_CPU_WALL(setup) {
+        indexReader_->startLookup(request_, options_);
+      }
+      setState(State::kRead);
+    }
+
+    if (!indexReader_->hasNext()) {
+      setState(State::kEnd);
+      return nullptr;
+    }
+    return getOutput(size, iterationStats);
+  }
+
+ private:
+  // State of the iterator.
+  enum class State {
+    // Initial state after creation.
+    kInit,
+    // After lookup request has been set in index reader.
+    kRead,
+    // After all data has been read.
+    kEnd,
+  };
+
+  // Sets the state with validation of allowed transitions.
+  // Allowed transitions:
+  //   kInit -> kRead (when request is set)
+  //   kInit -> kEnd (when no matches on first call)
+  //   kRead -> kEnd (when all data has been read)
+  void setState(State newState) {
+    switch (state_) {
+      case State::kInit:
+        VELOX_CHECK(
+            newState == State::kRead || newState == State::kEnd,
+            "Invalid state transition from {} to {}",
+            stateName(state_),
+            stateName(newState));
+        break;
+      case State::kRead:
+        VELOX_CHECK(
+            newState == State::kEnd,
+            "Invalid state transition from {} to {}",
+            stateName(state_),
+            stateName(newState));
+        break;
+      case State::kEnd:
+        VELOX_FAIL(
+            "Invalid state transition from {} to {}",
+            stateName(state_),
+            stateName(newState));
+    }
+    state_ = newState;
+  }
+
+  static std::string stateName(State state) {
+    switch (state) {
+      case State::kInit:
+        return "kInit";
+      case State::kRead:
+        return "kRead";
+      case State::kEnd:
+        return "kEnd";
+      default:
+        VELOX_UNREACHABLE("Unknown state {}", static_cast<int>(state));
+    }
+  }
+
+  std::unique_ptr<IndexSource::Result> getOutput(
+      vector_size_t size,
+      HiveIndexSource::IterationStats& iterationStats) {
+    std::unique_ptr<IndexSource::Result> result;
+    RECORD_CPU_WALL(read) {
+      result = indexReader_->next(size);
+    }
+    if (result == nullptr) {
+      VELOX_CHECK(!indexReader_->hasNext());
+      setState(State::kEnd);
+      return nullptr;
+    }
+
+    if (!indexSource_->nonIndexConditions_.empty()) {
+      result = applyNonIndexCondition(std::move(result));
+    }
+
+    if (indexSource_->remainingFilterExprSet_ == nullptr) {
+      RECORD_CPU_WALL(output) {
+        result->output = indexSource_->projectOutput(
+            result->output->size(), nullptr, result->output);
+      }
+    } else {
+      result = evaluateRemainingFilter(std::move(result), iterationStats);
+    }
+    return result;
+  }
+
+  std::unique_ptr<IndexSource::Result> applyNonIndexCondition(
+      std::unique_ptr<IndexSource::Result> result) {
+    BufferPtr passingIndices{nullptr};
+    const auto numPassing = indexSource_->applyNonIndexConditions(
+        request_.input, result->output, result->inputHits, passingIndices);
+    if (numPassing == 0) {
+      return getEmptyResult();
+    }
+    if (passingIndices == nullptr) {
+      return result;
+    }
+    result->inputHits = filterIndices(
+        numPassing, passingIndices, result->inputHits, indexSource_->pool_);
+    result->output =
+        exec::wrap(numPassing, std::move(passingIndices), result->output);
+    return result;
+  }
+
+  std::unique_ptr<IndexSource::Result> evaluateRemainingFilter(
+      std::unique_ptr<IndexSource::Result> result,
+      HiveIndexSource::IterationStats& iterationStats) {
+    auto& output = result->output;
+    vector_size_t numRemainingRows;
+    RECORD_CPU_WALL(filter) {
+      numRemainingRows = indexSource_->evaluateRemainingFilter(output);
+    }
+
+    if (numRemainingRows == 0) {
+      return getEmptyResult();
+    }
+
+    BufferPtr remainingIndices{nullptr};
+    if (numRemainingRows != output->size()) {
+      remainingIndices = indexSource_->remainingFilterEvalCtx_.selectedIndices;
+      result->inputHits = filterIndices(
+          numRemainingRows,
+          remainingIndices,
+          result->inputHits,
+          indexSource_->pool_);
+    }
+    RECORD_CPU_WALL(output) {
+      output = indexSource_->projectOutput(
+          numRemainingRows, remainingIndices, output);
+    }
+    return result;
+  }
+
+  std::unique_ptr<IndexSource::Result> getEmptyResult() {
+    if (emptyResult_ == nullptr) {
+      emptyResult_ = std::make_unique<IndexSource::Result>(
+          allocateIndices(0, indexSource_->pool_),
+          indexSource_->getEmptyOutput());
+    }
+    return std::make_unique<IndexSource::Result>(
+        emptyResult_->inputHits, emptyResult_->output);
+  }
+
+  const std::shared_ptr<HiveIndexSource> indexSource_;
+  // Raw pointer to index reader for lookup operations.
+  SplitIndexReader* const indexReader_;
+  const IndexSource::Request request_;
+  const SplitIndexReader::Options options_;
+
+  State state_{State::kInit};
+  // Cached empty result for reuse when no rows pass the remaining filter.
+  std::unique_ptr<IndexSource::Result> emptyResult_;
+};
+
+HiveIndexSource::HiveIndexSource(
+    const RowTypePtr& requestType,
+    const std::vector<core::IndexLookupConditionPtr>& indexLookupConditions,
+    const RowTypePtr& outputType,
+    HiveTableHandlePtr tableHandle,
+    const ColumnHandleMap& columnHandles,
+    FileHandleFactory* fileHandleFactory,
+    ConnectorQueryCtx* connectorQueryCtx,
+    const std::shared_ptr<HiveConfig>& hiveConfig,
+    folly::Executor* executor)
+    : fileHandleFactory_(fileHandleFactory),
+      connectorQueryCtx_(connectorQueryCtx),
+      hiveConfig_(hiveConfig),
+      pool_(connectorQueryCtx->memoryPool()),
+      expressionEvaluator_(connectorQueryCtx->expressionEvaluator()),
+      maxRowsPerIndexRequest_(hiveConfig_->maxRowsPerIndexRequest(
+          connectorQueryCtx_->sessionProperties())),
+      tableHandle_(std::move(tableHandle)),
+      requestType_(requestType),
+      outputType_(outputType),
+      executor_(executor),
+      ioStatistics_(std::make_shared<io::IoStatistics>()),
+      ioStats_(std::make_shared<IoStats>()) {
+  init(columnHandles, indexLookupConditions);
+}
+
+void HiveIndexSource::initConditions(
+    const std::vector<core::IndexLookupConditionPtr>& indexLookupConditions,
+    const ColumnHandleMap& assignments,
+    const folly::F14FastMap<std::string_view, const HiveColumnHandle*>&
+        columnHandles,
+    std::vector<std::string>& readColumnNames,
+    std::vector<TypePtr>& readColumnTypes) {
+  const auto& indexColumns = tableHandle_->indexColumns();
+  const auto& dataColumns = tableHandle_->dataColumns();
+
+  // Build a map from condition key name to condition for quick lookup. The key
+  // name in IndexLookupCondition references input column name, we need to
+  // convert it to the table column name using assignments.
+  folly::F14FastMap<std::string, core::IndexLookupConditionPtr> conditionMap;
+  for (const auto& condition : indexLookupConditions) {
+    auto convertedCondition = convertConditionKeyName(condition, assignments);
+    const auto& columnName = convertedCondition->key->name();
+    VELOX_USER_CHECK(
+        conditionMap.emplace(columnName, std::move(convertedCondition)).second,
+        "Duplicate lookup key found in indexLookupConditions: {}",
+        columnName);
+  }
+
+  indexLookupConditions_.reserve(indexColumns.size());
+  size_t numValidIndexLookupConditions{0};
+  folly::F14FastSet<std::string> indexConditions;
+  // Process index columns in order, converting filters to index lookup
+  // conditions where possible. A range filter/condition stops further
+  // processing.
+  for (const auto& indexColumn : indexColumns) {
+    const common::Subfield subfield(indexColumn);
+    const auto filterIt = filters_.find(subfield);
+    const bool hasFilter = filterIt != filters_.end();
+    const auto conditionIt = conditionMap.find(indexColumn);
+    const bool hasIndexLookupCondition = conditionIt != conditionMap.end();
+
+    // Cannot have both a filter and an index lookup condition on the same
+    // column.
+    VELOX_CHECK(
+        !(hasFilter && hasIndexLookupCondition),
+        "Cannot have both filter and index lookup condition on index column {}",
+        indexColumn);
+
+    if (!hasFilter && !hasIndexLookupCondition) {
+      // No filter or index lookup condition on this column - stop processing.
+      break;
+    }
+
+    // Get column type from data columns.
+    const auto typeIdx = dataColumns->getChildIdxIfExists(indexColumn);
+    VELOX_CHECK(
+        typeIdx.has_value(),
+        "Index column {} not found in data columns",
+        indexColumn);
+
+    if (hasIndexLookupCondition) {
+      // Use the existing index lookup condition as-is.
+      const auto& condition = conditionIt->second;
+      indexLookupConditions_.push_back(condition);
+      VELOX_CHECK(!condition->isFilter());
+      ++numValidIndexLookupConditions;
+      indexConditions.insert(indexColumn);
+
+      // Check if this is a range condition (Between) - stops further
+      // processing.
+      if (std::dynamic_pointer_cast<core::BetweenIndexLookupCondition>(
+              condition)) {
+        break;
+      }
+      continue;
+    }
+
+    // Has filter - try to convert to index lookup condition.
+    VELOX_CHECK(hasFilter);
+    const auto& columnType = dataColumns->childAt(*typeIdx);
+    const auto* filter = filterIt->second.get();
+    // Try point lookup conversion first.
+    auto pointValue = extractPointLookupValue(filter);
+    if (pointValue.has_value()) {
+      auto condition = createEqualConditionWithConstant(
+          indexColumn, columnType, pointValue.value());
+      indexLookupConditions_.push_back(condition);
+      // Remove converted filter from filters_ map.
+      filters_.erase(filterIt);
+      continue;
+    }
+
+    // Try range conversion.
+    auto rangeBounds = extractRangeBounds(filter);
+    if (rangeBounds.has_value()) {
+      auto condition = createBetweenConditionWithConstants(
+          indexColumn, columnType, rangeBounds->first, rangeBounds->second);
+      indexLookupConditions_.push_back(condition);
+      // Remove converted filter from filters_ map.
+      filters_.erase(filterIt);
+      // Range condition stops further processing.
+      break;
+    }
+
+    // Filter cannot be converted - leave it in filters_ map and stop
+    // processing.
+    break;
+  }
+
+  // Process remaining conditions not consumed as index conditions.
+  folly::F14FastSet<std::string> readColumnNameSet(
+      readColumnNames.begin(), readColumnNames.end());
+  for (const auto& [columnName, condition] : conditionMap) {
+    if (indexConditions.count(columnName) > 0) {
+      continue;
+    }
+
+    // Reject conditions on index columns that weren't consumed — this
+    // indicates a prefix-gap violation (e.g., u0 and u2 but not u1).
+    VELOX_CHECK(
+        std::find(indexColumns.begin(), indexColumns.end(), columnName) ==
+            indexColumns.end(),
+        "Unprocessed join condition on index column "
+        "(conditions must follow index column order as a prefix): {}",
+        columnName);
+
+    // Non-index conditions become post-read equality filters.
+    const auto equalCondition =
+        std::dynamic_pointer_cast<core::EqualIndexLookupCondition>(condition);
+    VELOX_CHECK_NOT_NULL(
+        equalCondition,
+        "Non-index join condition must be an equal condition: {}",
+        columnName);
+    VELOX_CHECK(
+        !equalCondition->isFilter(),
+        "Non-index join condition cannot be a constant filter: {}",
+        columnName);
+
+    // Ensure the column is in the read set.
+    if (readColumnNameSet.count(columnName) == 0) {
+      auto handleIt = columnHandles.find(columnName);
+      VELOX_CHECK(
+          handleIt != columnHandles.end(),
+          "Non-index condition column missing from assignments: {}",
+          columnName);
+      readColumnNames.emplace_back(columnName);
+      readColumnTypes.push_back(handleIt->second->dataType());
+      readColumnNameSet.insert(columnName);
+    }
+
+    // Resolve column indices for runtime evaluation.
+    const auto probeFieldAccess =
+        checkedPointerCast<const core::FieldAccessTypedExpr>(
+            equalCondition->value);
+    auto outputColumnIt =
+        std::find(readColumnNames.begin(), readColumnNames.end(), columnName);
+    const auto outputColumnIndex =
+        std::distance(readColumnNames.begin(), outputColumnIt);
+    const auto requestColumnIndex =
+        requestType_->getChildIdx(probeFieldAccess->name());
+    nonIndexConditions_.push_back(
+        {static_cast<column_index_t>(outputColumnIndex),
+         static_cast<column_index_t>(requestColumnIndex)});
+  }
+
+  VELOX_CHECK_EQ(
+      numValidIndexLookupConditions + nonIndexConditions_.size(),
+      indexLookupConditions.size(),
+      "Not all join conditions were processed");
+
+  VELOX_CHECK(
+      !indexLookupConditions_.empty(),
+      "No index column join conditions found. At least one must be an "
+      "index column");
+}
+
+void HiveIndexSource::initRemainingFilter(
+    std::vector<std::string>& readColumnNames,
+    std::vector<TypePtr>& readColumnTypes) {
+  VELOX_CHECK_NULL(remainingFilterExprSet_);
+  double sampleRate = tableHandle_->sampleRate();
+  auto remainingFilter = extractFiltersFromRemainingFilter(
+      tableHandle_->remainingFilter(),
+      expressionEvaluator_,
+      filters_,
+      sampleRate);
+  // TODO: support sample rate later.
+  VELOX_CHECK_EQ(
+      sampleRate, 1, "Sample rate is not supported for index source");
+
+  if (remainingFilter == nullptr) {
+    return;
+  }
+
+  remainingFilterExprSet_ = expressionEvaluator_->compile(remainingFilter);
+
+  const auto& remainingFilterExpr = remainingFilterExprSet_->expr(0);
+  folly::F14FastMap<std::string, column_index_t> columnNames;
+  for (int i = 0; i < readColumnNames.size(); ++i) {
+    columnNames[readColumnNames[i]] = i;
+  }
+  for (const auto* input : remainingFilterExpr->distinctFields()) {
+    auto it = columnNames.find(input->field());
+    if (it != columnNames.end()) {
+      if (shouldEagerlyMaterialize(*remainingFilterExpr, *input)) {
+        remainingEagerlyLoadFields_.push_back(it->second);
+      }
+      continue;
+    }
+    // Remaining filter may reference columns that are not used otherwise,
+    // e.g. are not being projected out and are not used in range filters.
+    // Make sure to add these columns to readerOutputType_.
+    readColumnNames.push_back(input->field());
+    readColumnTypes.push_back(input->type());
+  }
+
+  remainingFilterSubfields_ = remainingFilterExpr->extractSubfields();
+  for (auto& subfield : remainingFilterSubfields_) {
+    const auto& name = getColumnName(subfield);
+    auto it = projectedSubfields_.find(name);
+    if (it != projectedSubfields_.end()) {
+      // Some subfields of the column are already projected out, we append
+      // the remainingFilter subfield
+      it->second.push_back(&subfield);
+    } else if (columnNames.count(name) == 0) {
+      // remainingFilter subfield's column is not projected out, we add the
+      // column and append the subfield
+      projectedSubfields_[name].push_back(&subfield);
+    }
+  }
+}
+
+void HiveIndexSource::init(
+    const ColumnHandleMap& assignments,
+    const std::vector<core::IndexLookupConditionPtr>& indexLookupConditions) {
+  VELOX_CHECK_NOT_NULL(tableHandle_);
+
+  folly::F14FastMap<std::string_view, const HiveColumnHandle*> columnHandles;
+  // Column handles keyed on the table column name.
+  for (const auto& [_, columnHandle] : assignments) {
+    auto handle = checkedPointerCast<const HiveColumnHandle>(columnHandle);
+    const auto [it, unique] =
+        columnHandles.emplace(handle->name(), handle.get());
+    VELOX_CHECK(unique, "Duplicate column handle for {}", handle->name());
+    // Allow regular and partition key columns. Partition keys are not read
+    // from files — their values are synthesized from split metadata.
+    VELOX_CHECK(
+        handle->columnType() == HiveColumnHandle::ColumnType::kRegular ||
+            handle->columnType() == HiveColumnHandle::ColumnType::kPartitionKey,
+        "Unsupported column type {} for column {}",
+        HiveColumnHandle::columnTypeName(handle->columnType()),
+        handle->name());
+    if (handle->columnType() == HiveColumnHandle::ColumnType::kPartitionKey) {
+      partitionKeyHandles_.emplace(handle->name(), handle);
+    }
+  }
+
+  for (const auto& handle : tableHandle_->filterColumnHandles()) {
+    auto it = columnHandles.find(handle->name());
+    if (it != columnHandles.end()) {
+      checkColumnHandleConsistent(*handle, *it->second);
+      continue;
+    }
+    checkColumnHandleIsRegular(*handle);
+  }
+
+  std::vector<std::string> readColumnNames;
+  auto readColumnTypes = outputType_->children();
+  for (const auto& outputName : outputType_->names()) {
+    auto it = assignments.find(outputName);
+    VELOX_CHECK(
+        it != assignments.end(),
+        "ColumnHandle is missing for output column: {}",
+        outputName);
+
+    auto handle = checkedPointerCast<const HiveColumnHandle>(it->second);
+    readColumnNames.push_back(handle->name());
+    if (handle->columnType() == HiveColumnHandle::ColumnType::kPartitionKey) {
+      // Subfield projection / postProcessor checks below don't apply to
+      // partition columns; their values come from split metadata.
+      continue;
+    }
+
+    for (auto& subfield : handle->requiredSubfields()) {
+      VELOX_USER_CHECK_EQ(
+          getColumnName(subfield),
+          handle->name(),
+          "Required subfield does not match column name");
+      projectedSubfields_[handle->name()].push_back(&subfield);
+    }
+    VELOX_CHECK_NULL(handle->postProcessor(), "Post processor not supported");
+  }
+
+  if (hiveConfig_->isFileColumnNamesReadAsLowerCase(
+          connectorQueryCtx_->sessionProperties())) {
+    checkColumnNameLowerCase(outputType_);
+    checkColumnNameLowerCase(tableHandle_->subfieldFilters(), {});
+    checkColumnNameLowerCase(tableHandle_->remainingFilter());
+  }
+
+  for (const auto& [subfield, filter] : tableHandle_->subfieldFilters()) {
+    filters_.emplace(subfield.clone(), filter);
+  }
+
+  initRemainingFilter(readColumnNames, readColumnTypes);
+
+  initConditions(
+      indexLookupConditions,
+      assignments,
+      columnHandles,
+      readColumnNames,
+      readColumnTypes);
+
+  readerOutputType_ =
+      ROW(std::move(readColumnNames), std::move(readColumnTypes));
+  scanSpec_ = makeScanSpec(
+      readerOutputType_,
+      projectedSubfields_,
+      filters_,
+      /*indexColumns=*/{},
+      tableHandle_->dataColumns(),
+      partitionKeyHandles_,
+      /*infoColumns=*/{},
+      /*specialColumns=*/{},
+      hiveConfig_->readStatsBasedFilterReorderDisabled(
+          connectorQueryCtx_->sessionProperties()),
+      pool_);
+}
+
+void HiveIndexSource::setPartitionValues(
+    const std::vector<std::shared_ptr<ConnectorSplit>>& splits) {
+  if (partitionKeyHandles_.empty() || splits.empty()) {
+    return;
+  }
+  const auto firstSplit =
+      checkedPointerCast<const HiveConnectorSplit>(splits[0]);
+  const auto& partitionValues = firstSplit->partitionKeys;
+
+  // Sanity check all splits share the same partition values.
+  for (size_t i = 1; i < splits.size(); ++i) {
+    const auto& split = checkedPointerCast<const HiveConnectorSplit>(splits[i]);
+    VELOX_CHECK(
+        split->partitionKeys == partitionValues,
+        "Split {} partition values differ from split 0: split[0].path={}, split[{}].path={}",
+        i,
+        firstSplit->filePath,
+        i,
+        split->filePath);
+  }
+
+  // Iterate scan spec children and set constant values for partition columns
+  // found in the split metadata.
+  auto& childrenSpecs = scanSpec_->children();
+  for (size_t i = 0; i < childrenSpecs.size(); ++i) {
+    auto* childSpec = childrenSpecs[i].get();
+    const auto& fieldName = childSpec->fieldName();
+
+    if (auto partitionIt = partitionValues.find(fieldName);
+        partitionIt != partitionValues.end()) {
+      setPartitionValue(childSpec, fieldName, partitionIt->second);
+    }
+  }
+}
+
+void HiveIndexSource::setPartitionValue(
+    common::ScanSpec* spec,
+    const std::string& partitionKey,
+    const std::optional<std::string>& value) const {
+  const auto it = partitionKeyHandles_.find(partitionKey);
+  VELOX_CHECK(
+      it != partitionKeyHandles_.end(),
+      "ColumnHandle is missing for partition key {}",
+      partitionKey);
+  const auto type = it->second->dataType();
+  const auto constant = newConstantFromString(
+      type,
+      value,
+      pool_,
+      hiveConfig_->readTimestampPartitionValueAsLocalTime(
+          connectorQueryCtx_->sessionProperties()),
+      it->second->isPartitionDateValueDaysSinceEpoch());
+  spec->setConstantValue(constant);
+}
+
+void HiveIndexSource::addSplits(
+    std::vector<std::shared_ptr<ConnectorSplit>> splits) {
+  VELOX_CHECK(
+      readers_.empty(),
+      "addSplits can only be called once for HiveIndexSource");
+
+  setPartitionValues(splits);
+
+  auto* registry = IndexReaderFactoryRegistry::getInstance();
+  for (auto& split : splits) {
+    auto hiveSplit = checkedPointerCast<const HiveConnectorSplit>(split);
+    const auto* factory = registry->getFactory(hiveSplit->fileFormat);
+    if (factory != nullptr) {
+      createCustomIndexReader(*factory, std::move(hiveSplit));
+    } else {
+      VELOX_CHECK(
+          hiveSplit->fileFormat == dwio::common::FileFormat::NIMBLE ||
+              hiveSplit->fileFormat == dwio::common::FileFormat::FLUX ||
+              hiveSplit->fileFormat == dwio::common::FileFormat::SST,
+          "No IndexReaderFactory registered for format: {}",
+          dwio::common::toString(hiveSplit->fileFormat));
+      createFileIndexReader(std::move(hiveSplit));
+    }
+  }
+
+  VELOX_CHECK(!readers_.empty(), "No index readers created from splits");
+}
+
+std::shared_ptr<IndexSource::ResultIterator> HiveIndexSource::lookup(
+    const Request& request) {
+  VELOX_CHECK(!readers_.empty(), "No index readers available for lookup");
+
+  auto options = SplitIndexReader::Options{
+      .maxRowsPerRequest = static_cast<vector_size_t>(maxRowsPerIndexRequest_)};
+
+  if (readers_.size() == 1) {
+    return std::make_shared<HiveLookupIterator>(
+        shared_from_this(), readers_[0].get(), request, options);
+  }
+
+  return createUnionLookupIterator(request, options);
+}
+
+std::shared_ptr<IndexSource::ResultIterator>
+HiveIndexSource::createUnionLookupIterator(
+    const Request& request,
+    const SplitIndexReader::Options& options) {
+  // Wraps each reader in a HiveLookupIterator and unions their results
+  // via UnionResultIterator. Each reader searches its own split
+  // independently with the same request.
+  VELOX_CHECK_GT(readers_.size(), 1, "Union requires at least two readers");
+  std::vector<std::shared_ptr<IndexSource::ResultIterator>> splitIters;
+  splitIters.reserve(readers_.size());
+  for (auto& reader : readers_) {
+    splitIters.push_back(
+        std::make_shared<HiveLookupIterator>(
+            shared_from_this(), reader.get(), request, options));
+  }
+  return std::make_shared<UnionResultIterator>(
+      std::move(splitIters), outputType_, pool_);
+}
+
+std::unordered_map<std::string, RuntimeMetric> HiveIndexSource::runtimeStats() {
+  // Start with accumulated per-call timing stats.
+  auto stats = runtimeStats_;
+
+  if (remainingFilterTimeNs_ != 0) {
+    stats[std::string(Connector::kTotalRemainingFilterTime)] =
+        RuntimeMetric(remainingFilterTimeNs_, RuntimeCounter::Unit::kNanos);
+  }
+
+  // Merge stats from all readers.
+  for (auto& reader : readers_) {
+    for (auto& [key, metric] : reader->runtimeStats()) {
+      auto it = stats.find(key);
+      if (it != stats.end()) {
+        it->second.merge(metric);
+      } else {
+        stats.emplace(key, metric);
+      }
+    }
+  }
+  // Add I/O stats from ioStatistics_ (storage read, ram cache, ssd cache).
+  if (ioStatistics_) {
+    const auto& read = ioStatistics_->read();
+    if (read.count() > 0) {
+      stats[std::string(FileDataSource::kStorageReadBytes)] = RuntimeMetric(
+          static_cast<int64_t>(read.sum()),
+          read.count(),
+          static_cast<int64_t>(read.min()),
+          static_cast<int64_t>(read.max()),
+          RuntimeCounter::Unit::kBytes);
+    }
+    const auto& ramHit = ioStatistics_->ramHit();
+    if (ramHit.count() > 0) {
+      stats[std::string(FileDataSource::kNumRamRead)] =
+          RuntimeMetric(static_cast<int64_t>(ramHit.count()));
+      stats[std::string(FileDataSource::kRamReadBytes)] = RuntimeMetric(
+          static_cast<int64_t>(ramHit.sum()),
+          ramHit.count(),
+          static_cast<int64_t>(ramHit.min()),
+          static_cast<int64_t>(ramHit.max()),
+          RuntimeCounter::Unit::kBytes);
+    }
+    const auto& ssdRead = ioStatistics_->ssdRead();
+    if (ssdRead.count() > 0) {
+      stats[std::string(FileDataSource::kNumLocalRead)] =
+          RuntimeMetric(static_cast<int64_t>(ssdRead.count()));
+      stats[std::string(FileDataSource::kLocalReadBytes)] = RuntimeMetric(
+          static_cast<int64_t>(ssdRead.sum()),
+          ssdRead.count(),
+          static_cast<int64_t>(ssdRead.min()),
+          static_cast<int64_t>(ssdRead.max()),
+          RuntimeCounter::Unit::kBytes);
+    }
+  }
+
+  return stats;
+}
+
+vector_size_t HiveIndexSource::applyNonIndexConditions(
+    const RowVectorPtr& request,
+    const RowVectorPtr& output,
+    const BufferPtr& inputHits,
+    BufferPtr& passingIndices) {
+  const auto numRows = output->size();
+  const auto* hits = inputHits->as<vector_size_t>();
+
+  SelectivityVector passingRows(numRows, true);
+
+  for (const auto& condition : nonIndexConditions_) {
+    const auto& outputVector = output->childAt(condition.outputColumnIndex);
+    const auto& requestVector = request->childAt(condition.requestColumnIndex);
+    for (vector_size_t row = 0; row < numRows; ++row) {
+      const auto requestRow = hits[row];
+      // Either null means not equal (standard SQL join semantics).
+      if (outputVector->isNullAt(row) || requestVector->isNullAt(requestRow) ||
+          !outputVector->equalValueAt(requestVector.get(), row, requestRow)) {
+        passingRows.setValid(row, false);
+      }
+    }
+  }
+  passingRows.updateBounds();
+
+  const auto numPassing = passingRows.countSelected();
+  if (numPassing == numRows) {
+    return numRows;
+  }
+
+  passingIndices = allocateIndices(numPassing, pool_);
+  auto* rawIndices = passingIndices->asMutable<vector_size_t>();
+  vector_size_t numSelected = 0;
+  passingRows.applyToSelected(
+      [&](vector_size_t row) { rawIndices[numSelected++] = row; });
+  VELOX_CHECK_EQ(numSelected, numPassing);
+  return numPassing;
+}
+
+vector_size_t HiveIndexSource::evaluateRemainingFilter(
+    RowVectorPtr& rowVector) {
+  remainingFilterRows_.resize(rowVector->size());
+  for (auto fieldIndex : remainingEagerlyLoadFields_) {
+    LazyVector::ensureLoadedRows(
+        rowVector->childAt(fieldIndex),
+        remainingFilterRows_,
+        remainingFilterLazyDecoded_,
+        remainingFilterLazyBaseRows_);
+  }
+
+  uint64_t filterTimeNs{0};
+  vector_size_t numRemainingRows{0};
+  {
+    NanosecondTimer timer(&filterTimeNs);
+    expressionEvaluator_->evaluate(
+        remainingFilterExprSet_.get(),
+        remainingFilterRows_,
+        *rowVector,
+        remainingFilterResult_);
+    numRemainingRows = exec::processFilterResults(
+        remainingFilterResult_,
+        remainingFilterRows_,
+        remainingFilterEvalCtx_,
+        pool_);
+  }
+  remainingFilterTimeNs_ += filterTimeNs;
+  return numRemainingRows;
+}
+
+void HiveIndexSource::recordIterationStats(
+    const IterationStats& iterationStats) {
+  const auto totalWallNs = iterationStats.setupWallNs +
+      iterationStats.readWallNs + iterationStats.outputWallNs +
+      iterationStats.filterWallNs;
+  if (totalWallNs != 0) {
+    exec::addOperatorRuntimeStats(
+        IterationStats::kConnectorLookupWallNanos,
+        RuntimeCounter(
+            static_cast<int64_t>(totalWallNs), RuntimeCounter::Unit::kNanos),
+        runtimeStats_);
+  }
+  if (iterationStats.setupWallNs != 0) {
+    exec::addOperatorRuntimeStats(
+        IterationStats::kIndexSetupWallNanos,
+        RuntimeCounter(
+            static_cast<int64_t>(iterationStats.setupWallNs),
+            RuntimeCounter::Unit::kNanos),
+        runtimeStats_);
+  }
+  if (iterationStats.setupCpuNs != 0) {
+    exec::addOperatorRuntimeStats(
+        IterationStats::kIndexSetupCpuNanos,
+        RuntimeCounter(
+            static_cast<int64_t>(iterationStats.setupCpuNs),
+            RuntimeCounter::Unit::kNanos),
+        runtimeStats_);
+  }
+  if (iterationStats.readWallNs != 0) {
+    exec::addOperatorRuntimeStats(
+        IterationStats::kIndexReadWallNanos,
+        RuntimeCounter(
+            static_cast<int64_t>(iterationStats.readWallNs),
+            RuntimeCounter::Unit::kNanos),
+        runtimeStats_);
+  }
+  if (iterationStats.readCpuNs != 0) {
+    exec::addOperatorRuntimeStats(
+        IterationStats::kIndexReadCpuNanos,
+        RuntimeCounter(
+            static_cast<int64_t>(iterationStats.readCpuNs),
+            RuntimeCounter::Unit::kNanos),
+        runtimeStats_);
+  }
+  if (iterationStats.outputCpuNs != 0) {
+    exec::addOperatorRuntimeStats(
+        IterationStats::kConnectorResultPrepareCpuNanos,
+        RuntimeCounter(
+            static_cast<int64_t>(iterationStats.outputCpuNs),
+            RuntimeCounter::Unit::kNanos),
+        runtimeStats_);
+  }
+  if (iterationStats.filterWallNs != 0) {
+    exec::addOperatorRuntimeStats(
+        IterationStats::kPostFilterWallNanos,
+        RuntimeCounter(
+            static_cast<int64_t>(iterationStats.filterWallNs),
+            RuntimeCounter::Unit::kNanos),
+        runtimeStats_);
+  }
+  if (iterationStats.filterCpuNs != 0) {
+    exec::addOperatorRuntimeStats(
+        IterationStats::kPostFilterCpuNanos,
+        RuntimeCounter(
+            static_cast<int64_t>(iterationStats.filterCpuNs),
+            RuntimeCounter::Unit::kNanos),
+        runtimeStats_);
+  }
+}
+
+RowVectorPtr HiveIndexSource::projectOutput(
+    vector_size_t numRows,
+    const BufferPtr& remainingIndices,
+    const RowVectorPtr& rowVector) {
+  if (outputType_->size() == 0) {
+    return exec::wrap(numRows, remainingIndices, rowVector);
+  }
+
+  std::vector<VectorPtr> outputColumns;
+  outputColumns.reserve(outputType_->size());
+  for (int i = 0; i < outputType_->size(); ++i) {
+    auto& child = rowVector->childAt(i);
+    if (remainingIndices) {
+      // Disable dictionary values caching in expression eval so that we
+      // don't need to reallocate the result for every batch.
+      child->disableMemo();
+    }
+    auto column = exec::wrapChild(numRows, remainingIndices, child);
+    outputColumns.push_back(std::move(column));
+  }
+
+  return std::make_shared<RowVector>(
+      pool_, outputType_, BufferPtr(nullptr), numRows, outputColumns);
+}
+
+void HiveIndexSource::createCustomIndexReader(
+    const IndexReaderFactory& factory,
+    std::shared_ptr<const HiveConnectorSplit> split) {
+  VELOX_CHECK_NOT_NULL(split);
+  auto reader = factory(split, tableHandle_, connectorQueryCtx_);
+  VELOX_CHECK_NOT_NULL(
+      reader,
+      "IndexReaderFactory returned null for format: {}",
+      dwio::common::toString(split->fileFormat));
+  readers_.push_back(std::move(reader));
+}
+
+void HiveIndexSource::createFileIndexReader(
+    std::shared_ptr<const HiveConnectorSplit> split) {
+  VELOX_CHECK_NOT_NULL(split);
+  readers_.push_back(
+      std::make_unique<FileIndexReader>(
+          std::move(split),
+          tableHandle_,
+          connectorQueryCtx_,
+          hiveConfig_,
+          scanSpec_,
+          indexLookupConditions_,
+          requestType_,
+          readerOutputType_,
+          ioStatistics_,
+          ioStats_,
+          fileHandleFactory_,
+          executor_,
+          maxRowsPerIndexRequest_));
+}
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HiveIndexSource.h b/velox/connectors/hive/HiveIndexSource.h
new file mode 100644
index 00000000000..40e2eed4047
--- /dev/null
+++ b/velox/connectors/hive/HiveIndexSource.h
@@ -0,0 +1,274 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <folly/Executor.h>
+#include <folly/container/F14Map.h>
+#include "velox/common/io/IoStatistics.h"
+#include "velox/connectors/Connector.h"
+#include "velox/connectors/hive/FileHandle.h"
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/connectors/hive/IndexReader.h"
+#include "velox/connectors/hive/TableHandle.h"
+#include "velox/core/PlanNode.h"
+#include "velox/dwio/common/ScanSpec.h"
+#include "velox/exec/OperatorUtils.h"
+#include "velox/expression/Expr.h"
+#include "velox/vector/DecodedVector.h"
+
+namespace facebook::velox::connector::hive {
+
+class HiveConfig;
+
+/// Provides index lookup for Hive-metastore-backed tables.
+///
+/// Owns format-agnostic orchestration: remaining filter evaluation and output
+/// projection. Delegates format-specific reads to either the built-in
+/// FileIndexReader (for Nimble) or external SplitIndexReader implementations
+/// registered via IndexReaderFactoryRegistry. Supports partitioned tables by
+/// synthesizing partition column values from split metadata via scan-spec
+/// constants.
+class HiveIndexSource : public IndexSource,
+                        public std::enable_shared_from_this<HiveIndexSource> {
+ public:
+  HiveIndexSource(
+      const RowTypePtr& requestType,
+      const std::vector<core::IndexLookupConditionPtr>& indexLookupConditions,
+      const RowTypePtr& outputType,
+      HiveTableHandlePtr tableHandle,
+      const ColumnHandleMap& columnHandles,
+      FileHandleFactory* fileHandleFactory,
+      ConnectorQueryCtx* connectorQueryCtx,
+      const std::shared_ptr<HiveConfig>& hiveConfig,
+      folly::Executor* executor);
+
+  ~HiveIndexSource() override = default;
+
+  void addSplits(std::vector<std::shared_ptr<ConnectorSplit>> splits) override;
+
+  std::shared_ptr<ResultIterator> lookup(const Request& request) override;
+
+  std::unordered_map<std::string, RuntimeMetric> runtimeStats() override;
+
+ private:
+  friend class HiveLookupIterator;
+
+  memory::MemoryPool* pool() const {
+    return pool_;
+  }
+
+  const RowTypePtr& outputType() const {
+    return outputType_;
+  }
+
+  const RowVectorPtr& getEmptyOutput() {
+    if (!emptyOutput_) {
+      emptyOutput_ = RowVector::createEmpty(outputType_, pool_);
+    }
+    return emptyOutput_;
+  }
+
+  // Evaluates remainingFilter on the specified vector. Returns number of rows
+  // passed. Populates filterEvalCtx_.selectedIndices and selectedBits if only
+  // some rows passed the filter. If none or all rows passed
+  // filterEvalCtx_.selectedIndices and selectedBits are not updated.
+  vector_size_t evaluateRemainingFilter(RowVectorPtr& rowVector);
+
+  // Applies non-index equi-join conditions as post-read equality filters.
+  // Compares request (probe) values against reader output column values
+  // for each non-index join condition. Returns the number of rows that pass
+  // all conditions. Populates 'passingIndices' with the indices of rows that
+  // pass when not all rows pass.
+  vector_size_t applyNonIndexConditions(
+      const RowVectorPtr& request,
+      const RowVectorPtr& output,
+      const BufferPtr& inputHits,
+      BufferPtr& passingIndices);
+
+  // Projects output from reader output to the final output type. Wraps child
+  // vectors with remaining filter indices if provided. Partition
+  // columns are emitted by the reader directly via setConstantValue() on
+  // the scan spec, so they are projected like any other column here.
+  RowVectorPtr projectOutput(
+      vector_size_t numRows,
+      const BufferPtr& remainingIndices,
+      const RowVectorPtr& rowVector);
+
+  // Sets partition column constants on scanSpec_ from the first split's
+  // partition values. No-op if there are no partition columns or no splits.
+  void setPartitionValues(
+      const std::vector<std::shared_ptr<ConnectorSplit>>& splits);
+
+  // Sets a constant partition value on the scanSpec for a partition column.
+  void setPartitionValue(
+      common::ScanSpec* spec,
+      const std::string& partitionKey,
+      const std::optional<std::string>& value) const;
+
+  void init(
+      const ColumnHandleMap& assignments,
+      const std::vector<core::IndexLookupConditionPtr>& indexLookupConditions);
+
+  // Initializes all join conditions:
+  // - Index conditions are pushed to indexLookupConditions_ (filters on
+  //   index columns are converted to index lookup conditions).
+  // - Non-index conditions are resolved to nonIndexConditions_ for
+  //   post-read equality filtering, and their columns are added to
+  //   readColumnNames/readColumnTypes if not already present.
+  void initConditions(
+      const std::vector<core::IndexLookupConditionPtr>& indexLookupConditions,
+      const ColumnHandleMap& assignments,
+      const folly::F14FastMap<std::string_view, const HiveColumnHandle*>&
+          columnHandles,
+      std::vector<std::string>& readColumnNames,
+      std::vector<TypePtr>& readColumnTypes);
+
+  // Initializes the remaining filter:
+  // - Compiles the remaining filter expression.
+  // - Identifies columns to eagerly materialize.
+  // - Adds columns referenced by remaining filter but not projected.
+  // - Extracts and processes subfields from the remaining filter.
+  void initRemainingFilter(
+      std::vector<std::string>& readColumnNames,
+      std::vector<TypePtr>& readColumnTypes);
+
+  // Creates a UnionResultIterator that unions results from all readers.
+  std::shared_ptr<ResultIterator> createUnionLookupIterator(
+      const Request& request,
+      const SplitIndexReader::Options& options);
+
+  // Creates a SplitIndexReader using a registered IndexReaderFactory.
+  void createCustomIndexReader(
+      const IndexReaderFactory& factory,
+      std::shared_ptr<const HiveConnectorSplit> split);
+
+  // Creates a FileIndexReader for a single split.
+  void createFileIndexReader(std::shared_ptr<const HiveConnectorSplit> split);
+
+  // Per-iteration timing breakdown for index lookups.
+  struct IterationStats {
+    uint64_t setupWallNs{0};
+    uint64_t setupCpuNs{0};
+    uint64_t readWallNs{0};
+    uint64_t readCpuNs{0};
+    uint64_t outputWallNs{0};
+    uint64_t outputCpuNs{0};
+    uint64_t filterWallNs{0};
+    uint64_t filterCpuNs{0};
+
+    static constexpr std::string_view kConnectorLookupWallNanos{
+        "connectorLookupWallNanos"};
+    static constexpr std::string_view kConnectorResultPrepareCpuNanos{
+        "connectorResultPrepareCpuNanos"};
+    static constexpr std::string_view kIndexSetupWallNanos{
+        "connectorIndexSetupWallNanos"};
+    static constexpr std::string_view kIndexSetupCpuNanos{
+        "connectorIndexSetupCpuNanos"};
+    static constexpr std::string_view kIndexReadWallNanos{
+        "connectorIndexReadWallNanos"};
+    static constexpr std::string_view kIndexReadCpuNanos{
+        "connectorIndexReadCpuNanos"};
+    static constexpr std::string_view kPostFilterWallNanos{
+        "connectorPostFilterWallNanos"};
+    static constexpr std::string_view kPostFilterCpuNanos{
+        "connectorPostFilterCpuNanos"};
+  };
+
+  // Records per-iteration timing breakdown using addOperatorRuntimeStats to
+  // preserve per-call count/min/max granularity.
+  void recordIterationStats(const IterationStats& iterationStats);
+
+  FileHandleFactory* const fileHandleFactory_;
+  ConnectorQueryCtx* const connectorQueryCtx_;
+  const std::shared_ptr<HiveConfig> hiveConfig_;
+  memory::MemoryPool* const pool_;
+  core::ExpressionEvaluator* const expressionEvaluator_;
+  const uint32_t maxRowsPerIndexRequest_;
+
+  const HiveTableHandlePtr tableHandle_;
+  const RowTypePtr requestType_;
+  const RowTypePtr outputType_;
+  folly::Executor* const executor_;
+
+  // All index lookup conditions including equal lookup keys converted to
+  // EqualIndexLookupConditions and original non-filter index lookup conditions.
+  // This is passed to FileIndexReader.
+  std::vector<core::IndexLookupConditionPtr> indexLookupConditions_;
+
+  // Non-index equi-join conditions: join keys that are not index columns
+  // (e.g., bucket columns used for colocated joins). Applied as post-read
+  // equality filters during lookup.
+  struct NonIndexCondition {
+    column_index_t outputColumnIndex;
+    column_index_t requestColumnIndex;
+  };
+  std::vector<NonIndexCondition> nonIndexConditions_;
+
+  // Partition column handles, keyed by table column name (handle->name()).
+  // Populated from kPartitionKey assignments in init(). Used to feed
+  // partition handles into makeScanSpec() and to look up dataType() when
+  // parsing partition value strings into typed constants.
+  std::unordered_map<std::string, FileColumnHandlePtr> partitionKeyHandles_;
+
+  // Filters for pushdown. Includes subfield filters from table handle and
+  // filters converted from constant index lookup conditions.
+  common::SubfieldFilters filters_;
+
+  // Remaining filter expression set after filter pushdown.
+  std::unique_ptr<exec::ExprSet> remainingFilterExprSet_;
+  // Subfields referenced by the remaining filter.
+  std::vector<common::Subfield> remainingFilterSubfields_;
+  // Total time spent on evaluating remaining filter in nanoseconds.
+  uint64_t remainingFilterTimeNs_{0};
+  // Field indices referenced in both remaining filter and output type. These
+  // columns need to be materialized eagerly to avoid missing values in output.
+  std::vector<column_index_t> remainingEagerlyLoadFields_;
+
+  // Filter evaluation state for remaining filter.
+  SelectivityVector remainingFilterRows_;
+  VectorPtr remainingFilterResult_;
+  DecodedVector remainingFilterLazyDecoded_;
+  SelectivityVector remainingFilterLazyBaseRows_;
+  exec::FilterEvalCtx remainingFilterEvalCtx_;
+
+  // Points to subfields from both output columns' required subfields and
+  // remainingFilterSubfields_. Used to tell the reader which nested fields to
+  // project out.
+  folly::F14FastMap<std::string, std::vector<const common::Subfield*>>
+      projectedSubfields_;
+
+  // Scan spec for the index reader.
+  std::shared_ptr<common::ScanSpec> scanSpec_;
+  // Output type for the index reader. Includes partition columns when they
+  // appear in outputType_; the per-split reader emits their values as
+  // constants via the scan spec's setConstantValue().
+  RowTypePtr readerOutputType_;
+  // All index readers (both built-in and external). FileIndexReader
+  // (Nimble) and external readers both implement SplitIndexReader.
+  // Created by addSplits().
+  std::vector<std::unique_ptr<SplitIndexReader>> readers_;
+
+  // Cached empty output vector.
+  RowVectorPtr emptyOutput_;
+
+  std::shared_ptr<io::IoStatistics> ioStatistics_;
+  std::shared_ptr<IoStats> ioStats_;
+
+  // Per-call timing stats accumulated via addOperatorRuntimeStats().
+  std::unordered_map<std::string, RuntimeMetric> runtimeStats_;
+};
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HivePartitionFunction.cpp b/velox/connectors/hive/HivePartitionFunction.cpp
index d273cc8163e..548aff99e15 100644
--- a/velox/connectors/hive/HivePartitionFunction.cpp
+++ b/velox/connectors/hive/HivePartitionFunction.cpp
@@ -15,6 +15,8 @@
  */
 #include "velox/connectors/hive/HivePartitionFunction.h"
 
+#include <utility>
+
 namespace facebook::velox::connector::hive {
 
 namespace {
@@ -31,8 +33,7 @@ int32_t hashInt64(int64_t value) {
 __attribute__((no_sanitize("integer")))
 #endif
 #endif
-uint32_t
-hashBytes(StringView bytes, int32_t initialValue) {
+uint32_t hashBytes(StringView bytes, int32_t initialValue) {
   uint32_t hash = initialValue;
   auto* data = bytes.data();
   for (auto i = 0; i < bytes.size(); ++i) {
@@ -461,7 +462,7 @@ HivePartitionFunction::HivePartitionFunction(
     std::vector<column_index_t> keyChannels,
     const std::vector<VectorPtr>& constValues)
     : numBuckets_{numBuckets},
-      bucketToPartition_{bucketToPartition},
+      bucketToPartition_{std::move(bucketToPartition)},
       keyChannels_{std::move(keyChannels)} {
   precomputedHashes_.resize(keyChannels_.size());
   size_t constChannel{0};
@@ -495,7 +496,7 @@ std::optional<uint32_t> HivePartitionFunction::partition(
     }
   }
 
-  static const int32_t kInt32Max = std::numeric_limits<int32_t>::max();
+  static constexpr int32_t kInt32Max = std::numeric_limits<int32_t>::max();
 
   if (bucketToPartition_.empty()) {
     // NOTE: if bucket to partition mapping is empty, then we do
diff --git a/velox/connectors/hive/HivePartitionName.cpp b/velox/connectors/hive/HivePartitionName.cpp
new file mode 100644
index 00000000000..2d7e7b9b665
--- /dev/null
+++ b/velox/connectors/hive/HivePartitionName.cpp
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/HivePartitionName.h"
+#include "velox/common/encode/Base64.h"
+#include "velox/dwio/catalog/fbhive/FileUtils.h"
+#include "velox/type/DecimalUtil.h"
+
+namespace facebook::velox::connector::hive {
+
+using namespace facebook::velox::dwio::catalog::fbhive;
+
+namespace {
+
+template <typename T>
+std::string formatDecimal(T value, const TypePtr& type) {
+  const auto& [p, s] = getDecimalPrecisionScale(*type);
+  const auto& maxSize = DecimalUtil::maxStringViewSize(p, s);
+  std::string buffer(maxSize, '\0');
+  const auto& actualSize =
+      DecimalUtil::castToString(value, s, maxSize, buffer.data());
+  buffer.resize(actualSize);
+  return buffer;
+}
+
+} // namespace
+
+std::string HivePartitionName::toName(int32_t value, const TypePtr& type) {
+  if (type->isDate()) {
+    return DateType::toIso8601(value);
+  }
+  return fmt::to_string(value);
+}
+
+std::string HivePartitionName::toName(int64_t value, const TypePtr& type) {
+  if (type->isShortDecimal()) {
+    return formatDecimal(value, type);
+  }
+  return fmt::to_string(value);
+}
+
+std::string HivePartitionName::toName(int128_t value, const TypePtr& type) {
+  if (type->isLongDecimal()) {
+    return formatDecimal(value, type);
+  }
+  return fmt::to_string(value);
+}
+
+std::string HivePartitionName::toName(Timestamp value, const TypePtr& type) {
+  value.toTimezone(Timestamp::defaultTimezone());
+  TimestampToStringOptions options;
+  options.dateTimeSeparator = ' ';
+  // Set the precision to milliseconds, and enable the skipTrailingZeros match
+  // the timestamp precision and truncation behavior of Presto.
+  options.precision = TimestampPrecision::kMilliseconds;
+  options.skipTrailingZeros = true;
+
+  auto result = value.toString(options);
+
+  // Presto's java.sql.Timestamp.toString() always keeps at least one decimal
+  // place even when all fractional seconds are zero.
+  // If skipTrailingZeros removed all fractional digits, add back ".0" to match
+  // Presto's behavior.
+  if (auto dotPos = result.find_last_of('.'); dotPos == std::string::npos) {
+    // No decimal point found, add ".0"
+    result += ".0";
+  }
+
+  return result;
+}
+
+std::string HivePartitionName::partitionName(
+    uint32_t partitionId,
+    const RowVectorPtr& partitionValues,
+    bool partitionKeyAsLowerCase) {
+  auto toPartitionName =
+      [](auto value, const TypePtr& type, int /*columnIndex*/) {
+        return HivePartitionName::toName(value, type);
+      };
+  return FileUtils::makePartName(
+      partitionKeyValues(
+          partitionId,
+          partitionValues,
+          /*nullValueString=*/"",
+          toPartitionName),
+      partitionKeyAsLowerCase);
+}
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HivePartitionName.h b/velox/connectors/hive/HivePartitionName.h
new file mode 100644
index 00000000000..3e519528866
--- /dev/null
+++ b/velox/connectors/hive/HivePartitionName.h
@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <memory>
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/SimpleVector.h"
+
+namespace facebook::velox::connector::hive {
+
+/// Converting partition values to their string representations.
+/// Provides template methods for formatting different data types according to
+/// Hive partitioning conventions.
+class HivePartitionName {
+ public:
+  /// Generic template for formatting partition values to strings using
+  /// fmt::to_string. Specialized for types that need special handling
+  /// (int32_t, int64_t, int128_t, Timestamp).
+  template <typename T>
+  FOLLY_ALWAYS_INLINE static std::string toName(T value, const TypePtr& type) {
+    return fmt::to_string(value);
+  }
+
+  /// Format int32_t partition values. Specialized to handle DATE type which
+  /// requires ISO-8601 formatting (YYYY-MM-DD) instead of raw integer value.
+  static std::string toName(int32_t value, const TypePtr& type);
+
+  /// Format int64_t partition values. Specialized to handle short DECIMAL type
+  /// which requires decimal string formatting with proper precision and scale
+  /// instead of raw integer value.
+  static std::string toName(int64_t value, const TypePtr& type);
+
+  /// Format int128_t partition values. Specialized to handle long DECIMAL type
+  /// which requires decimal string formatting with proper precision and scale
+  /// instead of raw integer value.
+  static std::string toName(int128_t value, const TypePtr& type);
+
+  /// Format Timestamp partition values. Specialized to:
+  /// 1. Convert to default timezone
+  /// 2. Use space as date-time separator (not 'T')
+  /// 3. Use millisecond precision with trailing zeros skipped
+  /// 4. Always keep at least ".0" for fractional seconds (Presto compatibility)
+  static std::string toName(Timestamp value, const TypePtr& type);
+
+  /// Build partition key-value pairs from partition values.
+  /// Returns a vector of (key, value) pairs for all partition columns.
+  /// @tparam F A callable that converts a value to a partition string.
+  ///         Takes (value, type, columnIndex) and returns string.
+  /// @param partitionId The partition ID (row index) to extract values from.
+  /// @param partitionValues RowVector containing partition values.
+  /// @param nullValueString The string to use for null values.
+  /// @param toPartitionName Callable to convert a value to a string.
+  template <typename F>
+  static std::vector<std::pair<std::string, std::string>> partitionKeyValues(
+      uint32_t partitionId,
+      const RowVectorPtr& partitionValues,
+      const std::string& nullValueString,
+      const F& toPartitionName);
+
+  /// Generate a Hive partition directory name from partition values for
+  /// partitionId.
+  ///
+  /// @param partitionId The row index in partitionValues to extract values
+  ///        from.
+  /// @param partitionValues RowVector containing partition values. Each
+  ///        child vector represents a partition column, and the row at
+  ///        partitionId contains the values for this partition.
+  /// @param partitionKeyAsLowerCase Controls whether partition column names
+  ///        should be converted to lowercase in the output. When true, column
+  ///        names are lowercased (e.g., "year=2025"); when false, original
+  ///        casing is preserved (e.g., "Year=2025").
+  /// @return A formatted partition directory name string. Null values are
+  /// represented as __HIVE_DEFAULT_PARTITION__.
+  static std::string partitionName(
+      uint32_t partitionId,
+      const RowVectorPtr& partitionValues,
+      bool partitionKeyAsLowerCase);
+};
+
+namespace detail {
+
+// Unified template function to extract partition key-value string from a
+// vector. Used by both Hive and Iceberg partition name generators.
+//
+// @tparam Kind The TypeKind of the partition column.
+// @tparam F A callable that converts a value to a partition string.
+// @param partitionVector The vector containing partition values.
+// @param row The row index to extract the value from.
+// @param type The type of the partition column.
+// @param columnIndex The column index in the partition values.
+// @param toPartitionName Callable to convert a value to a partition string.
+// @return A pair of (column_name, formatted_value).
+template <TypeKind Kind, typename F>
+std::string makePartitionKeyValueString(
+    const BaseVector& partitionVector,
+    vector_size_t row,
+    const TypePtr& type,
+    int columnIndex,
+    const F& toPartitionName) {
+  using T = typename TypeTraits<Kind>::NativeType;
+
+  return toPartitionName(
+      partitionVector.as<SimpleVector<T>>()->valueAt(row), type, columnIndex);
+}
+
+#define PARTITION_TYPE_DISPATCH(TEMPLATE_FUNC, typeKind, ...)                  \
+  [&]() {                                                                      \
+    switch (typeKind) {                                                        \
+      case TypeKind::BOOLEAN:                                                  \
+      case TypeKind::TINYINT:                                                  \
+      case TypeKind::SMALLINT:                                                 \
+      case TypeKind::INTEGER:                                                  \
+      case TypeKind::BIGINT:                                                   \
+      case TypeKind::VARCHAR:                                                  \
+      case TypeKind::VARBINARY:                                                \
+      case TypeKind::TIMESTAMP:                                                \
+        return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(                             \
+            TEMPLATE_FUNC, typeKind, __VA_ARGS__);                             \
+      default:                                                                 \
+        VELOX_UNSUPPORTED(                                                     \
+            "Unsupported partition type: {}", TypeKindName::toName(typeKind)); \
+    }                                                                          \
+  }()
+
+} // namespace detail
+
+template <typename F>
+std::vector<std::pair<std::string, std::string>>
+HivePartitionName::partitionKeyValues(
+    uint32_t partitionId,
+    const RowVectorPtr& partitionValues,
+    const std::string& nullValueString,
+    const F& toPartitionName) {
+  std::vector<std::pair<std::string, std::string>> partitionKeyValuePairs;
+  for (auto i = 0; i < partitionValues->childrenSize(); i++) {
+    const auto& child = partitionValues->childAt(i);
+    const auto& name = partitionValues->rowType()->nameOf(i);
+    if (child->isNullAt(partitionId)) {
+      partitionKeyValuePairs.emplace_back(
+          std::make_pair(name, nullValueString));
+      continue;
+    }
+
+    partitionKeyValuePairs.emplace_back(
+        std::make_pair(
+            name,
+            PARTITION_TYPE_DISPATCH(
+                detail::makePartitionKeyValueString,
+                child->typeKind(),
+                *child->loadedVector(),
+                partitionId,
+                child->type(),
+                i,
+                toPartitionName)));
+  }
+  return partitionKeyValuePairs;
+}
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HivePartitionUtil.cpp b/velox/connectors/hive/HivePartitionUtil.cpp
deleted file mode 100644
index cb95b916df3..00000000000
--- a/velox/connectors/hive/HivePartitionUtil.cpp
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/connectors/hive/HivePartitionUtil.h"
-#include "velox/vector/SimpleVector.h"
-
-namespace facebook::velox::connector::hive {
-
-#define PARTITION_TYPE_DISPATCH(TEMPLATE_FUNC, typeKind, ...)               \
-  [&]() {                                                                   \
-    switch (typeKind) {                                                     \
-      case TypeKind::BOOLEAN:                                               \
-      case TypeKind::TINYINT:                                               \
-      case TypeKind::SMALLINT:                                              \
-      case TypeKind::INTEGER:                                               \
-      case TypeKind::BIGINT:                                                \
-      case TypeKind::VARCHAR:                                               \
-      case TypeKind::VARBINARY:                                             \
-      case TypeKind::TIMESTAMP:                                             \
-        return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(                          \
-            TEMPLATE_FUNC, typeKind, __VA_ARGS__);                          \
-      default:                                                              \
-        VELOX_UNSUPPORTED(                                                  \
-            "Unsupported partition type: {}", mapTypeKindToName(typeKind)); \
-    }                                                                       \
-  }()
-
-namespace {
-template <typename T>
-inline std::string makePartitionValueString(T value) {
-  return folly::to<std::string>(value);
-}
-
-template <>
-inline std::string makePartitionValueString(bool value) {
-  return value ? "true" : "false";
-}
-
-template <>
-inline std::string makePartitionValueString(Timestamp value) {
-  value.toTimezone(Timestamp::defaultTimezone());
-  TimestampToStringOptions options;
-  options.dateTimeSeparator = ' ';
-  // Set the precision to milliseconds, and enable the skipTrailingZeros match
-  // the timestamp precision and truncation behavior of Presto.
-  options.precision = TimestampPrecision::kMilliseconds;
-  options.skipTrailingZeros = true;
-
-  auto result = value.toString(options);
-
-  // Presto's java.sql.Timestamp.toString() always keeps at least one decimal
-  // place even when all fractional seconds are zero.
-  // If skipTrailingZeros removed all fractional digits, add back ".0" to match
-  // Presto's behavior.
-  if (auto dotPos = result.find_last_of('.'); dotPos == std::string::npos) {
-    // No decimal point found, add ".0"
-    result += ".0";
-  }
-
-  return result;
-}
-
-template <TypeKind Kind>
-std::pair<std::string, std::string> makePartitionKeyValueString(
-    const BaseVector* partitionVector,
-    vector_size_t row,
-    const std::string& name,
-    bool isDate) {
-  using T = typename TypeTraits<Kind>::NativeType;
-  if (partitionVector->as<SimpleVector<T>>()->isNullAt(row)) {
-    return std::make_pair(name, "");
-  }
-  if (isDate) {
-    return std::make_pair(
-        name,
-        DATE()->toString(
-            partitionVector->as<SimpleVector<int32_t>>()->valueAt(row)));
-  }
-  return std::make_pair(
-      name,
-      makePartitionValueString(
-          partitionVector->as<SimpleVector<T>>()->valueAt(row)));
-}
-
-} // namespace
-
-std::vector<std::pair<std::string, std::string>> extractPartitionKeyValues(
-    const RowVectorPtr& partitionsVector,
-    vector_size_t row) {
-  std::vector<std::pair<std::string, std::string>> partitionKeyValues;
-  for (auto i = 0; i < partitionsVector->childrenSize(); i++) {
-    partitionKeyValues.push_back(PARTITION_TYPE_DISPATCH(
-        makePartitionKeyValueString,
-        partitionsVector->childAt(i)->typeKind(),
-        partitionsVector->childAt(i)->loadedVector(),
-        row,
-        asRowType(partitionsVector->type())->nameOf(i),
-        partitionsVector->childAt(i)->type()->isDate()));
-  }
-  return partitionKeyValues;
-}
-
-} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HiveSplitReader.cpp b/velox/connectors/hive/HiveSplitReader.cpp
new file mode 100644
index 00000000000..b6b1aa5a84a
--- /dev/null
+++ b/velox/connectors/hive/HiveSplitReader.cpp
@@ -0,0 +1,237 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/HiveSplitReader.h"
+
+#include "velox/connectors/hive/FileConfig.h"
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/connectors/hive/HiveConnectorUtil.h"
+
+namespace facebook::velox::connector::hive {
+
+HiveSplitReader::HiveSplitReader(
+    const std::shared_ptr<const HiveConnectorSplit>& hiveSplit,
+    const FileTableHandlePtr& tableHandle,
+    const std::unordered_map<std::string, FileColumnHandlePtr>* partitionKeys,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    const std::shared_ptr<const FileConfig>& fileConfig,
+    const RowTypePtr& readerOutputType,
+    const std::shared_ptr<io::IoStatistics>& dataIoStats,
+    const std::shared_ptr<io::IoStatistics>& metadataIoStats,
+    const std::shared_ptr<IoStats>& ioStats,
+    FileHandleFactory* fileHandleFactory,
+    folly::Executor* ioExecutor,
+    const std::shared_ptr<common::ScanSpec>& scanSpec,
+    const std::unordered_map<std::string, FileColumnHandlePtr>* infoColumns,
+    std::vector<column_index_t> bucketChannels,
+    const common::SubfieldFilters* subfieldFiltersForValidation)
+    : FileSplitReader(
+          hiveSplit,
+          tableHandle,
+          partitionKeys,
+          connectorQueryCtx,
+          fileConfig,
+          readerOutputType,
+          dataIoStats,
+          metadataIoStats,
+          ioStats,
+          fileHandleFactory,
+          ioExecutor,
+          scanSpec,
+          subfieldFiltersForValidation),
+      hiveSplit_(hiveSplit),
+      infoColumns_(infoColumns) {
+  if (!bucketChannels.empty()) {
+    bucketChannels_ = {bucketChannels.begin(), bucketChannels.end()};
+    partitionFunction_ = std::make_unique<HivePartitionFunction>(
+        hiveSplit_->bucketConversion->tableBucketCount,
+        std::move(bucketChannels));
+  }
+}
+
+void HiveSplitReader::prepareSplit(
+    std::shared_ptr<common::MetadataFilter> metadataFilter,
+    dwio::common::RuntimeStatistics& runtimeStats,
+    const folly::F14FastMap<std::string, std::string>& fileReadOps) {
+  validateSynthesizedColumnFilters();
+  FileSplitReader::prepareSplit(
+      std::move(metadataFilter), runtimeStats, fileReadOps);
+}
+
+void HiveSplitReader::validateSynthesizedColumnFilters() const {
+  if (!subfieldFiltersForValidation_ || !infoColumns_) {
+    return;
+  }
+  const auto& splitInfoColumns = hiveSplit_->infoColumns;
+  for (const auto& [subfield, filter] : *subfieldFiltersForValidation_) {
+    const auto& fieldName = subfield.toString();
+    auto infoColIter = splitInfoColumns.find(fieldName);
+    if (infoColIter == splitInfoColumns.end()) {
+      continue;
+    }
+    bool passed = false;
+    const auto& value = infoColIter->second;
+    auto handleIter = infoColumns_->find(fieldName);
+    VELOX_CHECK(
+        handleIter != infoColumns_->end(),
+        "Column handle for synthesized column '{}' not found in infoColumns",
+        fieldName);
+    TypeKind typeKind = handleIter->second->dataType()->kind();
+    switch (typeKind) {
+      case TypeKind::BIGINT:
+      case TypeKind::INTEGER:
+        passed = common::applyFilter(*filter, folly::to<int64_t>(value));
+        break;
+      case TypeKind::VARCHAR:
+        passed = common::applyFilter(*filter, value);
+        break;
+      default:
+        VELOX_FAIL("Unexpected type for synthesized column '{}'.", fieldName);
+    }
+    VELOX_CHECK(
+        passed,
+        "Synthesized column '{}' failed filter validation. "
+        "Filter: {}, Value: '{}'. Split: {}",
+        fieldName,
+        filter->toString(),
+        value,
+        fileSplit_->toString());
+  }
+}
+
+std::vector<TypePtr> HiveSplitReader::adaptColumns(
+    const RowTypePtr& fileType,
+    const RowTypePtr& tableSchema) const {
+  std::vector<TypePtr> columnTypes = fileType->children();
+
+  auto& childrenSpecs = scanSpec_->children();
+  for (size_t i = 0; i < childrenSpecs.size(); ++i) {
+    auto* childSpec = childrenSpecs[i].get();
+    const std::string& fieldName = childSpec->fieldName();
+
+    auto partitionIt = fileSplit_->partitionKeys.find(fieldName);
+    if (partitionIt != fileSplit_->partitionKeys.end()) {
+      setPartitionValue(childSpec, fieldName, partitionIt->second);
+    } else if (
+        hiveSplit_->infoColumns.find(fieldName) !=
+        hiveSplit_->infoColumns.end()) {
+      auto iter = hiveSplit_->infoColumns.find(fieldName);
+      auto infoColumnType =
+          readerOutputType_->childAt(readerOutputType_->getChildIdx(fieldName));
+      auto constant = newConstantFromString(
+          infoColumnType,
+          iter->second,
+          connectorQueryCtx_->memoryPool(),
+          fileConfig_->readTimestampPartitionValueAsLocalTime(
+              connectorQueryCtx_->sessionProperties()),
+          false);
+      childSpec->setConstantValue(constant);
+    } else if (
+        childSpec->columnType() == common::ScanSpec::ColumnType::kRegular) {
+      auto fileTypeIdx = fileType->getChildIdxIfExists(fieldName);
+      if (!fileTypeIdx.has_value()) {
+        VELOX_CHECK(tableSchema, "Unable to resolve column '{}'", fieldName);
+        childSpec->setConstantValue(
+            BaseVector::createNullConstant(
+                tableSchema->findChild(fieldName),
+                1,
+                connectorQueryCtx_->memoryPool()));
+      } else {
+        childSpec->setConstantValue(nullptr);
+        auto outputTypeIdx = readerOutputType_->getChildIdxIfExists(fieldName);
+        if (outputTypeIdx.has_value()) {
+          auto& outputType = readerOutputType_->childAt(*outputTypeIdx);
+          auto& columnType = columnTypes[*fileTypeIdx];
+          if (childSpec->isFlatMapAsStruct()) {
+            VELOX_CHECK(outputType->isRow() && columnType->isMap());
+          } else {
+            columnType = outputType;
+          }
+        }
+      }
+    }
+  }
+
+  scanSpec_->resetCachedValues(false);
+
+  return columnTypes;
+}
+
+void HiveSplitReader::configureBaseReaderOptions() {
+  hive::configureReaderOptions(
+      fileConfig_,
+      connectorQueryCtx_,
+      tableHandle_,
+      fileSplit_,
+      hiveSplit_->serdeParameters,
+      baseReaderOpts_);
+}
+
+void HiveSplitReader::configureBaseRowReaderOptions(
+    std::shared_ptr<common::MetadataFilter> metadataFilter,
+    RowTypePtr rowType) {
+  hive::configureRowReaderOptions(
+      tableHandle_->tableParameters(),
+      scanSpec_,
+      std::move(metadataFilter),
+      rowType,
+      fileSplit_,
+      hiveSplit_->serdeParameters,
+      fileConfig_,
+      connectorQueryCtx_->sessionProperties(),
+      ioExecutor_,
+      baseRowReaderOpts_);
+}
+
+std::vector<BaseVector::CopyRange> HiveSplitReader::bucketConversionRows(
+    const RowVector& vector) {
+  partitions_.clear();
+  partitionFunction_->partition(vector, partitions_);
+  const auto bucketToKeep = *hiveSplit_->tableBucketNumber;
+  const auto partitionBucketCount =
+      hiveSplit_->bucketConversion->partitionBucketCount;
+  std::vector<BaseVector::CopyRange> ranges;
+  for (vector_size_t i = 0; i < vector.size(); ++i) {
+    VELOX_CHECK_EQ((partitions_[i] - bucketToKeep) % partitionBucketCount, 0);
+    if (partitions_[i] == bucketToKeep) {
+      auto& r = ranges.emplace_back();
+      r.sourceIndex = i;
+      r.targetIndex = ranges.size() - 1;
+      r.count = 1;
+    }
+  }
+  return ranges;
+}
+
+void HiveSplitReader::applyBucketConversion(
+    VectorPtr& output,
+    const std::vector<BaseVector::CopyRange>& ranges) {
+  auto filtered =
+      BaseVector::create(output->type(), ranges.size(), output->pool());
+  filtered->copyRanges(output.get(), ranges);
+  output = std::move(filtered);
+}
+
+uint64_t HiveSplitReader::next(uint64_t size, VectorPtr& output) {
+  auto numScanned = FileSplitReader::next(size, output);
+  if (numScanned > 0 && output->size() > 0 && partitionFunction_) {
+    applyBucketConversion(
+        output, bucketConversionRows(*output->asChecked<RowVector>()));
+  }
+  return numScanned;
+}
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HiveSplitReader.h b/velox/connectors/hive/HiveSplitReader.h
new file mode 100644
index 00000000000..e50e87ed285
--- /dev/null
+++ b/velox/connectors/hive/HiveSplitReader.h
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/connectors/hive/FileSplitReader.h"
+#include "velox/connectors/hive/HivePartitionFunction.h"
+
+namespace facebook::velox::connector::hive {
+
+struct HiveConnectorSplit;
+
+/// Hive-specific FileSplitReader that adds bucket conversion support.
+///
+/// Bucket conversion is needed when a table's bucket count is increased but
+/// old partitions still use the original bucket count. In that case, a single
+/// file may contain rows for multiple new buckets, and the reader must filter
+/// to keep only rows belonging to the target bucket.
+class HiveSplitReader : public FileSplitReader {
+ public:
+  HiveSplitReader(
+      const std::shared_ptr<const HiveConnectorSplit>& hiveSplit,
+      const FileTableHandlePtr& tableHandle,
+      const std::unordered_map<std::string, FileColumnHandlePtr>* partitionKeys,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      const std::shared_ptr<const FileConfig>& fileConfig,
+      const RowTypePtr& readerOutputType,
+      const std::shared_ptr<io::IoStatistics>& dataIoStats,
+      const std::shared_ptr<io::IoStatistics>& metadataIoStats,
+      const std::shared_ptr<IoStats>& ioStats,
+      FileHandleFactory* fileHandleFactory,
+      folly::Executor* ioExecutor,
+      const std::shared_ptr<common::ScanSpec>& scanSpec,
+      const std::unordered_map<std::string, FileColumnHandlePtr>* infoColumns,
+      std::vector<column_index_t> bucketChannels = {},
+      const common::SubfieldFilters* subfieldFiltersForValidation = nullptr);
+
+  ~HiveSplitReader() override = default;
+
+  void prepareSplit(
+      std::shared_ptr<common::MetadataFilter> metadataFilter,
+      dwio::common::RuntimeStatistics& runtimeStats,
+      const folly::F14FastMap<std::string, std::string>& fileReadOps = {})
+      override;
+
+  uint64_t next(uint64_t size, VectorPtr& output) override;
+
+  const folly::F14FastSet<column_index_t>& bucketChannels() const {
+    return bucketChannels_;
+  }
+
+ protected:
+  void configureBaseReaderOptions() override;
+
+  void configureBaseRowReaderOptions(
+      std::shared_ptr<common::MetadataFilter> metadataFilter,
+      RowTypePtr rowType) override;
+
+  std::vector<BaseVector::CopyRange> bucketConversionRows(
+      const RowVector& vector);
+
+  void applyBucketConversion(
+      VectorPtr& output,
+      const std::vector<BaseVector::CopyRange>& ranges);
+
+  void validateSynthesizedColumnFilters() const;
+
+  const std::shared_ptr<const HiveConnectorSplit> hiveSplit_;
+
+ private:
+  std::vector<TypePtr> adaptColumns(
+      const RowTypePtr& fileType,
+      const RowTypePtr& tableSchema) const override;
+
+  const std::unordered_map<std::string, FileColumnHandlePtr>* infoColumns_{
+      nullptr};
+  folly::F14FastSet<column_index_t> bucketChannels_;
+  std::unique_ptr<HivePartitionFunction> partitionFunction_;
+  std::vector<uint32_t> partitions_;
+};
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/IndexReader.h b/velox/connectors/hive/IndexReader.h
new file mode 100644
index 00000000000..3ad7756c985
--- /dev/null
+++ b/velox/connectors/hive/IndexReader.h
@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <mutex>
+#include <unordered_map>
+
+#include <folly/CPortability.h>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/connectors/Connector.h"
+#include "velox/dwio/common/Reader.h"
+
+namespace facebook::velox::connector::hive {
+
+struct HiveConnectorSplit;
+
+/// Abstract interface for format-specific index readers.
+///
+/// Provides the customization point for storage formats to plug into
+/// HiveIndexSource. Each format implements this interface
+/// with its own I/O and decoding logic. HiveIndexSource owns all
+/// format-agnostic orchestration (partition routing, remaining filter
+/// evaluation, non-index condition filtering, output projection) and delegates
+/// storage-specific reads to SplitIndexReader implementations.
+///
+/// File-based readers (e.g., Nimble) can internally use ScanSpec and filter
+/// pushdown without leaking those concepts through this interface.
+class SplitIndexReader {
+ public:
+  using Request = IndexSource::Request;
+  using Result = IndexSource::Result;
+  using Options = dwio::common::IndexReader::Options;
+
+  /// The total number of output rows returned across all next() calls.
+  static constexpr std::string_view kNumIndexReaderOutputRows{
+      "numIndexReaderOutputRows"};
+
+  virtual ~SplitIndexReader() = default;
+
+  /// Initializes a lookup for the given probe request.
+  ///
+  /// The reader handles format-specific I/O (e.g., file reads for Nimble,
+  /// network RPCs for remote stores). HiveIndexSource handles everything above
+  /// this level (filters, projection, partition routing).
+  ///
+  /// After calling startLookup(), the caller iterates results via hasNext()
+  /// and next().
+  ///
+  /// @param request The probe-side input rows containing lookup keys.
+  /// @param options Lookup options (e.g., max rows per request batch).
+  virtual void startLookup(
+      const Request& request,
+      const Options& options = {}) = 0;
+
+  /// Returns true if there are more result batches to read.
+  virtual bool hasNext() = 0;
+
+  /// Returns the next batch of results, or nullptr if no more results.
+  ///
+  /// @param maxOutputRows Maximum number of rows to return in this batch.
+  virtual std::unique_ptr<Result> next(vector_size_t maxOutputRows) = 0;
+
+  /// Returns runtime statistics collected by this reader.
+  virtual std::unordered_map<std::string, RuntimeMetric> runtimeStats() = 0;
+};
+
+/// Factory function type for creating IndexReader instances.
+///
+/// Creates one IndexReader per split during HiveIndexSource::addSplits().
+/// Receives all the context needed to set up a reader for the given storage
+/// format.
+///
+/// @param split The split to create the reader for.
+/// @param tableHandle The table handle containing table metadata.
+/// @param connectorQueryCtx Query context (memory pool, session config, etc.).
+/// @return A unique_ptr to the created IndexReader.
+using IndexReaderFactory = std::function<std::unique_ptr<SplitIndexReader>(
+    const std::shared_ptr<const HiveConnectorSplit>& split,
+    const ConnectorTableHandlePtr& tableHandle,
+    ConnectorQueryCtx* connectorQueryCtx)>;
+
+/// Thread-safe registry for IndexReaderFactory instances keyed by file format.
+///
+/// External storage formats register their reader
+/// factories at application startup. HiveIndexSource consults this registry
+/// during addSplits() to find the appropriate reader for each split's file
+/// format.
+///
+/// Example registration:
+///   IndexReaderFactoryRegistry::getInstance()->registerFactory(
+///       FileFormat::DWRF, myDwrfReaderFactory);
+class IndexReaderFactoryRegistry {
+ public:
+  FOLLY_EXPORT static IndexReaderFactoryRegistry* getInstance() {
+    static IndexReaderFactoryRegistry instance;
+    return &instance;
+  }
+
+  /// Registers a factory for the given file format. Throws if a factory is
+  /// already registered for the format.
+  void registerFactory(
+      dwio::common::FileFormat format,
+      IndexReaderFactory factory) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    auto [it, inserted] = factories_.emplace(format, std::move(factory));
+    VELOX_CHECK(
+        inserted,
+        "IndexReaderFactory already registered for format: {}",
+        dwio::common::toString(format));
+  }
+
+  /// Unregisters the factory for the given file format. Returns true if a
+  /// factory was removed, false if none was registered.
+  bool unregisterFactory(dwio::common::FileFormat format) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return factories_.erase(format) > 0;
+  }
+
+  /// Returns the registered factory for the given format, or nullptr if none
+  /// is registered.
+  const IndexReaderFactory* getFactory(dwio::common::FileFormat format) const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    auto it = factories_.find(format);
+    return it != factories_.end() ? &it->second : nullptr;
+  }
+
+ private:
+  IndexReaderFactoryRegistry() = default;
+
+  mutable std::mutex mutex_;
+  std::unordered_map<dwio::common::FileFormat, IndexReaderFactory> factories_;
+};
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/PartitionIdGenerator.cpp b/velox/connectors/hive/PartitionIdGenerator.cpp
index bb20301b678..a4773da58a1 100644
--- a/velox/connectors/hive/PartitionIdGenerator.cpp
+++ b/velox/connectors/hive/PartitionIdGenerator.cpp
@@ -16,38 +16,30 @@
 
 #include "velox/connectors/hive/PartitionIdGenerator.h"
 
-#include "velox/connectors/hive/HivePartitionUtil.h"
-#include "velox/dwio/catalog/fbhive/FileUtils.h"
-
-using namespace facebook::velox::dwio::catalog::fbhive;
-
 namespace facebook::velox::connector::hive {
 
 PartitionIdGenerator::PartitionIdGenerator(
     const RowTypePtr& inputType,
     std::vector<column_index_t> partitionChannels,
     uint32_t maxPartitions,
-    memory::MemoryPool* pool,
-    bool partitionPathAsLowerCase)
+    memory::MemoryPool* pool)
     : pool_(pool),
       partitionChannels_(std::move(partitionChannels)),
-      maxPartitions_(maxPartitions),
-      partitionPathAsLowerCase_(partitionPathAsLowerCase) {
+      maxPartitions_(maxPartitions) {
   VELOX_USER_CHECK(
       !partitionChannels_.empty(), "There must be at least one partition key.");
   for (auto channel : partitionChannels_) {
     hashers_.emplace_back(
         exec::VectorHasher::create(inputType->childAt(channel), channel));
+    VELOX_USER_CHECK(
+        hashers_.back()->typeSupportsValueIds(),
+        "Unsupported partition type: {}.",
+        inputType->childAt(channel)->toString());
   }
 
   std::vector<TypePtr> partitionKeyTypes;
   std::vector<std::string> partitionKeyNames;
   for (auto channel : partitionChannels_) {
-    VELOX_USER_CHECK(
-        exec::VectorHasher::typeKindSupportsValueIds(
-            inputType->childAt(channel)->kind()),
-        "Unsupported partition type: {}.",
-        inputType->childAt(channel)->toString());
     partitionKeyTypes.push_back(inputType->childAt(channel));
     partitionKeyNames.push_back(inputType->nameOf(channel));
   }
@@ -97,12 +89,6 @@ void PartitionIdGenerator::run(
   }
 }
 
-std::string PartitionIdGenerator::partitionName(uint64_t partitionId) const {
-  return FileUtils::makePartName(
-      extractPartitionKeyValues(partitionValues_, partitionId),
-      partitionPathAsLowerCase_);
-}
-
 void PartitionIdGenerator::computeValueIds(
     const RowVectorPtr& input,
     raw_vector<uint64_t>& valueIds) {
diff --git a/velox/connectors/hive/PartitionIdGenerator.h b/velox/connectors/hive/PartitionIdGenerator.h
index c4e0320b46c..0a53252829c 100644
--- a/velox/connectors/hive/PartitionIdGenerator.h
+++ b/velox/connectors/hive/PartitionIdGenerator.h
@@ -29,14 +29,11 @@ class PartitionIdGenerator {
   /// @param maxPartitions The max number of distinct partitions.
   /// @param pool Memory pool. Used to allocate memory for storing unique
   /// partition key values.
-  /// @param partitionPathAsLowerCase Used to control whether the partition path
-  /// need to convert to lower case.
   PartitionIdGenerator(
       const RowTypePtr& inputType,
       std::vector<column_index_t> partitionChannels,
       uint32_t maxPartitions,
-      memory::MemoryPool* pool,
-      bool partitionPathAsLowerCase);
+      memory::MemoryPool* pool);
 
   /// Generate sequential partition IDs for input vector.
   /// @param input Input RowVector.
@@ -48,11 +45,16 @@ class PartitionIdGenerator {
     return partitionIds_.size();
   }
 
-  /// Return partition name for the given partition id in the typical Hive
-  /// style. It is derived from the partitionValues_ at index partitionId.
-  /// Partition keys appear in the order of partition columns in the table
-  /// schema.
-  std::string partitionName(uint64_t partitionId) const;
+  /// Returns the RowVector containing transformed partition keys.
+  /// Each row in this vector corresponds to a partition ID (row index =
+  /// partition ID).
+  /// Should be called after calling run() method.
+  ///
+  /// @return RowVector with one column per partition column, columns in same
+  /// order as partitionChannels_.
+  const RowVectorPtr& partitionValues() const {
+    return partitionValues_;
+  }
 
  private:
   static constexpr const int32_t kHasherReservePct = 20;
@@ -81,8 +83,6 @@ class PartitionIdGenerator {
 
   const uint32_t maxPartitions_;
 
-  const bool partitionPathAsLowerCase_;
-
   std::vector<std::unique_ptr<exec::VectorHasher>> hashers_;
   bool hasMultiplierSet_ = false;
 
diff --git a/velox/connectors/hive/SplitReader.h b/velox/connectors/hive/SplitReader.h
deleted file mode 100644
index 72a42b56b0b..00000000000
--- a/velox/connectors/hive/SplitReader.h
+++ /dev/null
@@ -1,204 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include "velox/common/base/RandomUtil.h"
-#include "velox/common/file/FileSystems.h"
-#include "velox/connectors/hive/FileHandle.h"
-#include "velox/connectors/hive/HivePartitionFunction.h"
-#include "velox/dwio/common/Options.h"
-#include "velox/dwio/common/Reader.h"
-
-namespace facebook::velox {
-class BaseVector;
-using VectorPtr = std::shared_ptr<BaseVector>;
-} // namespace facebook::velox
-
-namespace facebook::velox::common {
-class MetadataFilter;
-class ScanSpec;
-} // namespace facebook::velox::common
-
-namespace facebook::velox::connector {
-class ConnectorQueryCtx;
-} // namespace facebook::velox::connector
-
-namespace facebook::velox::dwio::common {
-struct RuntimeStatistics;
-} // namespace facebook::velox::dwio::common
-
-namespace facebook::velox::memory {
-class MemoryPool;
-}
-
-namespace facebook::velox::connector::hive {
-
-struct HiveConnectorSplit;
-class HiveTableHandle;
-class HiveColumnHandle;
-class HiveConfig;
-
-class SplitReader {
- public:
-  static std::unique_ptr<SplitReader> create(
-      const std::shared_ptr<hive::HiveConnectorSplit>& hiveSplit,
-      const std::shared_ptr<const HiveTableHandle>& hiveTableHandle,
-      const std::unordered_map<
-          std::string,
-          std::shared_ptr<const HiveColumnHandle>>* partitionKeys,
-      const ConnectorQueryCtx* connectorQueryCtx,
-      const std::shared_ptr<const HiveConfig>& hiveConfig,
-      const RowTypePtr& readerOutputType,
-      const std::shared_ptr<io::IoStatistics>& ioStats,
-      const std::shared_ptr<filesystems::File::IoStats>& fsStats,
-      FileHandleFactory* fileHandleFactory,
-      folly::Executor* ioExecutor,
-      const std::shared_ptr<common::ScanSpec>& scanSpec);
-
-  virtual ~SplitReader() = default;
-
-  void configureReaderOptions(
-      std::shared_ptr<random::RandomSkipTracker> randomSkip);
-
-  /// This function is used by different table formats like Iceberg and Hudi to
-  /// do additional preparations before reading the split, e.g. Open delete
-  /// files or log files, and add column adapatations for metadata columns. It
-  /// would be called only once per incoming split
-  virtual void prepareSplit(
-      std::shared_ptr<common::MetadataFilter> metadataFilter,
-      dwio::common::RuntimeStatistics& runtimeStats);
-
-  virtual uint64_t next(uint64_t size, VectorPtr& output);
-
-  void resetFilterCaches();
-
-  bool emptySplit() const;
-
-  void resetSplit();
-
-  int64_t estimatedRowSize() const;
-
-  void updateRuntimeStats(dwio::common::RuntimeStatistics& stats) const;
-
-  bool allPrefetchIssued() const;
-
-  void setConnectorQueryCtx(const ConnectorQueryCtx* connectorQueryCtx);
-
-  void setBucketConversion(std::vector<column_index_t> bucketChannels);
-
-  const RowTypePtr& readerOutputType() const {
-    return readerOutputType_;
-  }
-
-  std::string toString() const;
-
- protected:
-  SplitReader(
-      const std::shared_ptr<const hive::HiveConnectorSplit>& hiveSplit,
-      const std::shared_ptr<const HiveTableHandle>& hiveTableHandle,
-      const std::unordered_map<
-          std::string,
-          std::shared_ptr<const HiveColumnHandle>>* partitionKeys,
-      const ConnectorQueryCtx* connectorQueryCtx,
-      const std::shared_ptr<const HiveConfig>& hiveConfig,
-      const RowTypePtr& readerOutputType,
-      const std::shared_ptr<io::IoStatistics>& ioStats,
-      const std::shared_ptr<filesystems::File::IoStats>& fsStats,
-      FileHandleFactory* fileHandleFactory,
-      folly::Executor* executor,
-      const std::shared_ptr<common::ScanSpec>& scanSpec);
-
-  /// Create the dwio::common::Reader object baseReader_, which will be used to
-  /// read the data file's metadata and schema
-  void createReader();
-
-  // Adjust the scan spec according to the current split, then return the
-  // adapted row type.
-  RowTypePtr getAdaptedRowType() const;
-
-  // Check if the filters pass on the column statistics.  When delta update is
-  // present, the corresonding filter should be disabled before calling this
-  // function.
-  bool filterOnStats(dwio::common::RuntimeStatistics& runtimeStats) const;
-
-  /// Check if the hiveSplit_ is empty. The split is considered empty when
-  ///   1) The data file is missing but the user chooses to ignore it
-  ///   2) The file does not contain any rows
-  ///   3) The data in the file does not pass the filters. The test is based on
-  ///      the file metadata and partition key values
-  /// This function needs to be called after baseReader_ is created.
-  bool checkIfSplitIsEmpty(dwio::common::RuntimeStatistics& runtimeStats);
-
-  /// Create the dwio::common::RowReader object baseRowReader_, which owns the
-  /// ColumnReaders that will be used to read the data
-  void createRowReader(
-      std::shared_ptr<common::MetadataFilter> metadataFilter,
-      RowTypePtr rowType);
-
-  const folly::F14FastSet<column_index_t>& bucketChannels() const {
-    return bucketChannels_;
-  }
-
-  std::vector<BaseVector::CopyRange> bucketConversionRows(
-      const RowVector& vector);
-
-  void applyBucketConversion(
-      VectorPtr& output,
-      const std::vector<BaseVector::CopyRange>& ranges);
-
- private:
-  /// Different table formats may have different meatadata columns.
-  /// This function will be used to update the scanSpec for these columns.
-  std::vector<TypePtr> adaptColumns(
-      const RowTypePtr& fileType,
-      const std::shared_ptr<const velox::RowType>& tableSchema) const;
-
-  void setPartitionValue(
-      common::ScanSpec* spec,
-      const std::string& partitionKey,
-      const std::optional<std::string>& value) const;
-
- protected:
-  std::shared_ptr<const HiveConnectorSplit> hiveSplit_;
-  const std::shared_ptr<const HiveTableHandle> hiveTableHandle_;
-  const std::unordered_map<
-      std::string,
-      std::shared_ptr<const HiveColumnHandle>>* const partitionKeys_;
-  const ConnectorQueryCtx* connectorQueryCtx_;
-  const std::shared_ptr<const HiveConfig> hiveConfig_;
-
-  RowTypePtr readerOutputType_;
-  const std::shared_ptr<io::IoStatistics> ioStats_;
-  const std::shared_ptr<filesystems::File::IoStats> fsStats_;
-  FileHandleFactory* const fileHandleFactory_;
-  folly::Executor* const ioExecutor_;
-  memory::MemoryPool* const pool_;
-
-  std::shared_ptr<common::ScanSpec> scanSpec_;
-  std::unique_ptr<dwio::common::Reader> baseReader_;
-  std::unique_ptr<dwio::common::RowReader> baseRowReader_;
-  dwio::common::ReaderOptions baseReaderOpts_;
-  dwio::common::RowReaderOptions baseRowReaderOpts_;
-  bool emptySplit_;
-
- private:
-  folly::F14FastSet<column_index_t> bucketChannels_;
-  std::unique_ptr<HivePartitionFunction> partitionFunction_;
-  std::vector<uint32_t> partitions_;
-};
-
-} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/TableHandle.cpp b/velox/connectors/hive/TableHandle.cpp
index 3f7c8b6f93d..fc8b26508c6 100644
--- a/velox/connectors/hive/TableHandle.cpp
+++ b/velox/connectors/hive/TableHandle.cpp
@@ -19,37 +19,141 @@
 namespace facebook::velox::connector::hive {
 
 namespace {
-std::unordered_map<HiveColumnHandle::ColumnType, std::string>
-columnTypeNames() {
-  return {
-      {HiveColumnHandle::ColumnType::kPartitionKey, "PartitionKey"},
-      {HiveColumnHandle::ColumnType::kRegular, "Regular"},
-      {HiveColumnHandle::ColumnType::kSynthesized, "Synthesized"},
-      {HiveColumnHandle::ColumnType::kRowIndex, "RowIndex"},
-  };
+
+folly::dynamic serializeExtractionPathElement(
+    const ExtractionPathElement& element) {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["step"] = extractionStepName(element.step());
+  if (element.step() == ExtractionStep::kStructField) {
+    obj["fieldName"] =
+        static_cast<const StructFieldExtractionPathElement&>(element)
+            .fieldName();
+  }
+  if (element.step() == ExtractionStep::kMapKeyFilter) {
+    if (auto* stringFilter =
+            dynamic_cast<const StringMapKeyFilterExtractionPathElement*>(
+                &element)) {
+      folly::dynamic keys = folly::dynamic::array;
+      for (const auto& key : stringFilter->filterKeys()) {
+        keys.push_back(key);
+      }
+      obj["stringFilterKeys"] = keys;
+    } else if (
+        auto* intFilter =
+            dynamic_cast<const IntMapKeyFilterExtractionPathElement*>(
+                &element)) {
+      folly::dynamic keys = folly::dynamic::array;
+      for (const auto& key : intFilter->filterKeys()) {
+        keys.push_back(key);
+      }
+      obj["intFilterKeys"] = keys;
+    }
+  }
+  return obj;
 }
 
-template <typename K, typename V>
-std::unordered_map<V, K> invertMap(const std::unordered_map<K, V>& mapping) {
-  std::unordered_map<V, K> inverted;
-  for (const auto& [key, value] : mapping) {
-    inverted.emplace(value, key);
+ExtractionPathElementPtr deserializeExtractionPathElement(
+    const folly::dynamic& obj) {
+  auto step = extractionStepFromName(obj["step"].asString());
+  switch (step) {
+    case ExtractionStep::kStructField:
+      return ExtractionPathElement::structField(obj["fieldName"].asString());
+    case ExtractionStep::kMapKeyFilter: {
+      std::vector<std::string> stringKeys;
+      std::vector<int64_t> intKeys;
+      if (auto it = obj.find("stringFilterKeys"); it != obj.items().end()) {
+        for (const auto& key : it->second) {
+          stringKeys.push_back(key.asString());
+        }
+      }
+      if (auto it = obj.find("intFilterKeys"); it != obj.items().end()) {
+        for (const auto& key : it->second) {
+          intKeys.push_back(key.asInt());
+        }
+      }
+      if (!stringKeys.empty()) {
+        return ExtractionPathElement::mapKeyFilter(std::move(stringKeys));
+      }
+      return ExtractionPathElement::mapKeyFilter(std::move(intKeys));
+    }
+    case ExtractionStep::kMapKeys:
+    case ExtractionStep::kMapValues:
+    case ExtractionStep::kArrayElements:
+    case ExtractionStep::kSize:
+      return ExtractionPathElement::simple(step);
   }
-  return inverted;
+  VELOX_UNREACHABLE();
 }
 
-} // namespace
+folly::dynamic serializeNamedExtraction(const NamedExtraction& extraction) {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["outputName"] = extraction.outputName;
+  obj["dataType"] = extraction.dataType->serialize();
+  folly::dynamic chain = folly::dynamic::array;
+  for (const auto& element : extraction.chain) {
+    chain.push_back(serializeExtractionPathElement(*element));
+  }
+  obj["chain"] = chain;
+  return obj;
+}
 
-std::string HiveColumnHandle::columnTypeName(
-    HiveColumnHandle::ColumnType type) {
-  static const auto ctNames = columnTypeNames();
-  return ctNames.at(type);
+NamedExtraction deserializeNamedExtraction(const folly::dynamic& obj) {
+  NamedExtraction extraction;
+  extraction.outputName = obj["outputName"].asString();
+  extraction.dataType = ISerializable::deserialize<Type>(obj["dataType"]);
+  const auto& chainArr = obj["chain"];
+  extraction.chain.reserve(chainArr.size());
+  for (const auto& element : chainArr) {
+    extraction.chain.push_back(deserializeExtractionPathElement(element));
+  }
+  return extraction;
 }
 
-HiveColumnHandle::ColumnType HiveColumnHandle::columnTypeFromName(
-    const std::string& name) {
-  static const auto nameColumnTypes = invertMap(columnTypeNames());
-  return nameColumnTypes.at(name);
+} // namespace
+
+HiveColumnHandle::HiveColumnHandle(
+    const std::string& name,
+    ColumnType columnType,
+    TypePtr dataType,
+    TypePtr hiveType,
+    std::vector<common::Subfield> requiredSubfields,
+    std::vector<NamedExtraction> extractions,
+    ColumnParseParameters columnParseParameters,
+    std::function<void(VectorPtr&)> postProcessor)
+    : name_(name),
+      columnType_(columnType),
+      dataType_(std::move(dataType)),
+      hiveType_(std::move(hiveType)),
+      requiredSubfields_(std::move(requiredSubfields)),
+      extractions_(std::move(extractions)),
+      columnParseParameters_(columnParseParameters),
+      postProcessor_(std::move(postProcessor)) {
+  VELOX_USER_CHECK(
+      extractions_.empty() || requiredSubfields_.empty(),
+      "Extractions and requiredSubfields are mutually exclusive on column: {}",
+      name_);
+
+  if (extractions_.empty()) {
+    // No extractions: dataType and hiveType must match (existing behavior).
+    VELOX_USER_CHECK(
+        dataType_->equivalent(*hiveType_),
+        "data type {} and hive type {} do not match",
+        dataType_->toString(),
+        hiveType_->toString());
+  } else {
+    // Validate each extraction chain against hiveType and verify output types.
+    for (const auto& extraction : extractions_) {
+      auto derivedType =
+          deriveExtractionOutputType(hiveType_, extraction.chain);
+      VELOX_USER_CHECK(
+          derivedType->equivalent(*extraction.dataType),
+          "Extraction '{}' declared output type {} does not match "
+          "derived type: {}",
+          extraction.outputName,
+          extraction.dataType->toString(),
+          derivedType->toString());
+    }
+  }
 }
 
 folly::dynamic HiveColumnHandle::serialize() const {
@@ -63,6 +167,13 @@ folly::dynamic HiveColumnHandle::serialize() const {
     requiredSubfields.push_back(subfield.toString());
   }
   obj["requiredSubfields"] = requiredSubfields;
+  if (!extractions_.empty()) {
+    folly::dynamic extractions = folly::dynamic::array;
+    for (const auto& extraction : extractions_) {
+      extractions.push_back(serializeNamedExtraction(extraction));
+    }
+    obj["extractions"] = extractions;
+  }
   return obj;
 }
 
@@ -77,7 +188,57 @@ std::string HiveColumnHandle::toString() const {
   for (const auto& subfield : requiredSubfields_) {
     out << " " << subfield.toString();
   }
-  out << " ]]";
+  out << " ]";
+  if (!extractions_.empty()) {
+    out << ", extractions: [";
+    for (size_t i = 0; i < extractions_.size(); ++i) {
+      if (i > 0) {
+        out << ", ";
+      }
+      const auto& extraction = extractions_[i];
+      out << "{outputName: " << extraction.outputName << ", chain: [";
+      for (size_t j = 0; j < extraction.chain.size(); ++j) {
+        if (j > 0) {
+          out << ", ";
+        }
+        const auto& elem = *extraction.chain[j];
+        out << extractionStepName(elem.step());
+        if (elem.step() == ExtractionStep::kStructField) {
+          out << "("
+              << static_cast<const StructFieldExtractionPathElement&>(elem)
+                     .fieldName()
+              << ")";
+        }
+        if (elem.step() == ExtractionStep::kMapKeyFilter) {
+          out << "(";
+          if (auto* strFilter =
+                  dynamic_cast<const StringMapKeyFilterExtractionPathElement*>(
+                      &elem)) {
+            for (size_t k = 0; k < strFilter->filterKeys().size(); ++k) {
+              if (k > 0) {
+                out << ", ";
+              }
+              out << "\"" << strFilter->filterKeys()[k] << "\"";
+            }
+          } else if (
+              auto* intFilter =
+                  dynamic_cast<const IntMapKeyFilterExtractionPathElement*>(
+                      &elem)) {
+            for (size_t k = 0; k < intFilter->filterKeys().size(); ++k) {
+              if (k > 0) {
+                out << ", ";
+              }
+              out << intFilter->filterKeys()[k];
+            }
+          }
+          out << ")";
+        }
+      }
+      out << "], dataType: " << extraction.dataType->toString() << "}";
+    }
+    out << "]";
+  }
+  out << "]";
   return out.str();
 }
 
@@ -94,8 +255,20 @@ ColumnHandlePtr HiveColumnHandle::create(const folly::dynamic& obj) {
     requiredSubfields.emplace_back(s.asString());
   }
 
+  std::vector<NamedExtraction> extractions;
+  if (auto it = obj.find("extractions"); it != obj.items().end()) {
+    for (const auto& extraction : it->second) {
+      extractions.push_back(deserializeNamedExtraction(extraction));
+    }
+  }
+
   return std::make_shared<HiveColumnHandle>(
-      name, columnType, dataType, hiveType, std::move(requiredSubfields));
+      name,
+      columnType,
+      dataType,
+      hiveType,
+      std::move(requiredSubfields),
+      std::move(extractions));
 }
 
 void HiveColumnHandle::registerSerDe() {
@@ -106,18 +279,47 @@ void HiveColumnHandle::registerSerDe() {
 HiveTableHandle::HiveTableHandle(
     std::string connectorId,
     const std::string& tableName,
-    bool filterPushdownEnabled,
     common::SubfieldFilters subfieldFilters,
     const core::TypedExprPtr& remainingFilter,
     const RowTypePtr& dataColumns,
-    const std::unordered_map<std::string, std::string>& tableParameters)
-    : ConnectorTableHandle(std::move(connectorId)),
+    std::vector<std::string> indexColumns,
+    const std::unordered_map<std::string, std::string>& tableParameters,
+    std::vector<HiveColumnHandlePtr> filterColumnHandles,
+    double sampleRate,
+    std::string dbName)
+    : FileTableHandle(std::move(connectorId)),
       tableName_(tableName),
-      filterPushdownEnabled_(filterPushdownEnabled),
       subfieldFilters_(std::move(subfieldFilters)),
       remainingFilter_(remainingFilter),
+      sampleRate_(sampleRate),
       dataColumns_(dataColumns),
-      tableParameters_(tableParameters) {}
+      indexColumns_(std::move(indexColumns)),
+      tableParameters_(tableParameters),
+      filterColumnHandles_(std::move(filterColumnHandles)),
+      dbName_(std::move(dbName)) {
+  VELOX_CHECK_GT(sampleRate_, 0.0, "Sample rate must be positive");
+  VELOX_CHECK_LE(sampleRate_, 1.0, "Sample rate must not exceed 1.0");
+}
+
+HiveTableHandle::HiveTableHandle(
+    std::string connectorId,
+    const std::string& tableName,
+    common::SubfieldFilters subfieldFilters,
+    const core::TypedExprPtr& remainingFilter,
+    const RowTypePtr& dataColumns,
+    const std::unordered_map<std::string, std::string>& tableParameters,
+    std::vector<HiveColumnHandlePtr> filterColumnHandles,
+    double sampleRate)
+    : HiveTableHandle(
+          std::move(connectorId),
+          tableName,
+          std::move(subfieldFilters),
+          remainingFilter,
+          dataColumns,
+          /*indexColumns=*/{},
+          tableParameters,
+          std::move(filterColumnHandles),
+          sampleRate) {}
 
 std::string HiveTableHandle::toString() const {
   std::stringstream out;
@@ -139,6 +341,9 @@ std::string HiveTableHandle::toString() const {
     }
     out << "]";
   }
+  if (sampleRate_ < 1.0) {
+    out << ", sample rate: " << sampleRate_;
+  }
   if (remainingFilter_) {
     out << ", remaining filter: (" << remainingFilter_->toString() << ")";
   }
@@ -159,13 +364,25 @@ std::string HiveTableHandle::toString() const {
     }
     out << "]";
   }
+  if (!filterColumnHandles_.empty()) {
+    out << ", filter column handles: [";
+    bool first = true;
+    for (auto& handle : filterColumnHandles_) {
+      if (first) {
+        first = false;
+      } else {
+        out << ", ";
+      }
+      out << handle->toString();
+    }
+    out << "]";
+  }
   return out.str();
 }
 
 folly::dynamic HiveTableHandle::serialize() const {
   folly::dynamic obj = ConnectorTableHandle::serializeBase("HiveTableHandle");
   obj["tableName"] = tableName_;
-  obj["filterPushdownEnabled"] = filterPushdownEnabled_;
 
   folly::dynamic subfieldFilters = folly::dynamic::array;
   for (const auto& [subfield, filter] : subfieldFilters_) {
@@ -179,6 +396,11 @@ folly::dynamic HiveTableHandle::serialize() const {
   if (remainingFilter_) {
     obj["remainingFilter"] = remainingFilter_->serialize();
   }
+
+  if (sampleRate_ < 1.0) {
+    obj["sampleRate"] = sampleRate_;
+  }
+
   if (dataColumns_) {
     obj["dataColumns"] = dataColumns_->serialize();
   }
@@ -187,6 +409,24 @@ folly::dynamic HiveTableHandle::serialize() const {
     tableParameters[param.first] = param.second;
   }
   obj["tableParameters"] = tableParameters;
+  if (!filterColumnHandles_.empty()) {
+    folly::dynamic filterColumnHandles = folly::dynamic::array;
+    for (const auto& handle : filterColumnHandles_) {
+      filterColumnHandles.push_back(handle->serialize());
+    }
+    obj["filterColumnHandles"] = filterColumnHandles;
+  }
+  if (!indexColumns_.empty()) {
+    folly::dynamic indexColumns = folly::dynamic::array;
+    for (const auto& column : indexColumns_) {
+      indexColumns.push_back(column);
+    }
+    obj["indexColumns"] = indexColumns;
+  }
+
+  if (!dbName_.empty()) {
+    obj["dbName"] = dbName_;
+  }
 
   return obj;
 }
@@ -196,7 +436,6 @@ ConnectorTableHandlePtr HiveTableHandle::create(
     void* context) {
   auto connectorId = obj["connectorId"].asString();
   auto tableName = obj["tableName"].asString();
-  auto filterPushdownEnabled = obj["filterPushdownEnabled"].asBool();
 
   core::TypedExprPtr remainingFilter;
   if (auto it = obj.find("remainingFilter"); it != obj.items().end()) {
@@ -214,6 +453,11 @@ ConnectorTableHandlePtr HiveTableHandle::create(
         filter->clone();
   }
 
+  double sampleRate = 1.0;
+  if (obj.count("sampleRate")) {
+    sampleRate = obj["sampleRate"].asDouble();
+  }
+
   RowTypePtr dataColumns;
   if (auto it = obj.find("dataColumns"); it != obj.items().end()) {
     dataColumns = ISerializable::deserialize<RowType>(it->second, context);
@@ -226,14 +470,37 @@ ConnectorTableHandlePtr HiveTableHandle::create(
     tableParameters.emplace(key.asString(), value.asString());
   }
 
+  std::vector<HiveColumnHandlePtr> filterColumnHandles;
+  if (auto it = obj.find("filterColumnHandles"); it != obj.items().end()) {
+    for (const auto& handle : it->second) {
+      filterColumnHandles.push_back(
+          ISerializable::deserialize<HiveColumnHandle>(handle, context));
+    }
+  }
+
+  std::vector<std::string> indexColumns;
+  if (auto it = obj.find("indexColumns"); it != obj.items().end()) {
+    for (const auto& column : it->second) {
+      indexColumns.push_back(column.asString());
+    }
+  }
+
+  std::string dbName;
+  if (auto it = obj.find("dbName"); it != obj.items().end()) {
+    dbName = it->second.asString();
+  }
+
   return std::make_shared<const HiveTableHandle>(
       connectorId,
       tableName,
-      filterPushdownEnabled,
       std::move(subfieldFilters),
       remainingFilter,
       dataColumns,
-      tableParameters);
+      std::move(indexColumns),
+      tableParameters,
+      std::move(filterColumnHandles),
+      sampleRate,
+      std::move(dbName));
 }
 
 void HiveTableHandle::registerSerDe() {
diff --git a/velox/connectors/hive/TableHandle.h b/velox/connectors/hive/TableHandle.h
index c017eb41879..c0d5463c535 100644
--- a/velox/connectors/hive/TableHandle.h
+++ b/velox/connectors/hive/TableHandle.h
@@ -16,6 +16,8 @@
 #pragma once
 
 #include "velox/connectors/Connector.h"
+#include "velox/connectors/hive/FileColumnHandle.h"
+#include "velox/connectors/hive/FileTableHandle.h"
 #include "velox/core/ITypedExpr.h"
 #include "velox/type/Filter.h"
 #include "velox/type/Subfield.h"
@@ -23,18 +25,8 @@
 
 namespace facebook::velox::connector::hive {
 
-class HiveColumnHandle : public ColumnHandle {
+class HiveColumnHandle : public FileColumnHandle {
  public:
-  enum class ColumnType {
-    kPartitionKey,
-    kRegular,
-    kSynthesized,
-    /// A zero-based row number of type BIGINT auto-generated by the connector.
-    /// Rows numbers are unique within a single file only.
-    kRowIndex,
-    kRowId,
-  };
-
   struct ColumnParseParameters {
     enum PartitionDateValueFormat {
       kISO8601,
@@ -42,47 +34,68 @@ class HiveColumnHandle : public ColumnHandle {
     } partitionDateValueFormat;
   };
 
-  /// NOTE: 'dataType' is the column type in target write table. 'hiveType' is
+  /// NOTE: 'dataType' is the column type in target write table.  'hiveType' is
   /// converted type of the corresponding column in source table which might not
   /// be the same type, and the table scan needs to do data coercion if needs.
   /// The table writer also needs to respect the type difference when processing
   /// input data such as bucket id calculation.
+  ///
+  /// 'extractions' specifies named extraction chains.  When non-empty,
+  /// 'requiredSubfields' must be empty (mutually exclusive).  When a single
+  /// extraction is present, 'dataType' is that extraction's dataType.  When
+  /// multiple extractions are present, 'dataType' is a ROW type whose fields
+  /// are the outputNames with their corresponding dataTypes.
   HiveColumnHandle(
       const std::string& name,
       ColumnType columnType,
       TypePtr dataType,
       TypePtr hiveType,
       std::vector<common::Subfield> requiredSubfields = {},
-      ColumnParseParameters columnParseParameters = {})
-      : name_(name),
-        columnType_(columnType),
-        dataType_(std::move(dataType)),
-        hiveType_(std::move(hiveType)),
-        requiredSubfields_(std::move(requiredSubfields)),
-        columnParseParameters_(columnParseParameters) {
-    VELOX_USER_CHECK(
-        dataType_->equivalent(*hiveType_),
-        "data type {} and hive type {} do not match",
-        dataType_->toString(),
-        hiveType_->toString());
-  }
+      std::vector<NamedExtraction> extractions = {},
+      ColumnParseParameters columnParseParameters = {},
+      std::function<void(VectorPtr&)> postProcessor = {});
+
+  /// Legacy constructor without extractions for backward compatibility.
+  HiveColumnHandle(
+      const std::string& name,
+      ColumnType columnType,
+      TypePtr dataType,
+      TypePtr hiveType,
+      std::vector<common::Subfield> requiredSubfields,
+      ColumnParseParameters columnParseParameters,
+      std::function<void(VectorPtr&)> postProcessor = {})
+      : HiveColumnHandle(
+            name,
+            columnType,
+            std::move(dataType),
+            std::move(hiveType),
+            std::move(requiredSubfields),
+            /*extractions=*/{},
+            columnParseParameters,
+            std::move(postProcessor)) {}
 
   const std::string& name() const override {
     return name_;
   }
 
-  ColumnType columnType() const {
+  ColumnType columnType() const override {
     return columnType_;
   }
 
-  const TypePtr& dataType() const {
+  const TypePtr& dataType() const override {
     return dataType_;
   }
 
+  /// The type of this column as stored in the Hive source table. May differ
+  /// from dataType() when type coercion is needed for schema evolution.
   const TypePtr& hiveType() const {
     return hiveType_;
   }
 
+  const TypePtr& schemaType() const override {
+    return hiveType();
+  }
+
   /// Applies to columns of complex types: arrays, maps and structs.  When a
   /// query uses only some of the subfields, the engine provides the complete
   /// list of required subfields and the connector is free to prune the rest.
@@ -97,30 +110,53 @@ class HiveColumnHandle : public ColumnHandle {
   ///
   /// Pruning arrays means dropping values with indices larger than maximum
   /// required index.
-  const std::vector<common::Subfield>& requiredSubfields() const {
+  const std::vector<common::Subfield>& requiredSubfields() const override {
     return requiredSubfields_;
   }
 
-  bool isPartitionKey() const {
+  /// Named extraction chains.  Empty means no extraction (current behavior).
+  /// When a single entry is present, the column handle's dataType is that
+  /// entry's dataType.  When multiple entries are present, the column
+  /// handle's dataType is a ROW type whose fields are the outputNames with
+  /// their corresponding dataTypes.
+  /// Mutually exclusive with requiredSubfields — if extractions is non-empty,
+  /// requiredSubfields must be empty.
+  const std::vector<NamedExtraction>& extractions() const override {
+    return extractions_;
+  }
+
+  bool isPartitionKey() const override {
     return columnType_ == ColumnType::kPartitionKey;
   }
 
-  bool isPartitionDateValueDaysSinceEpoch() const {
+  bool isPartitionDateValueDaysSinceEpoch() const override {
     return columnParseParameters_.partitionDateValueFormat ==
         ColumnParseParameters::kDaysSinceEpoch;
   }
 
+  /// Apply some row-wise post processing to this column when it is present in
+  /// output.
+  ///
+  /// It's not allowed to change the size of the vector in the processor.  The
+  /// top level vector is guaranteed to be safe to change.  Any inner vectors
+  /// and buffers need to check the reference count before doing any change in
+  /// place, otherwise you need to allocate new vectors and buffers.
+  ///
+  /// For lazy vector, this will be applied after the lazy vector is loaded.
+  /// This is only applied after all the filtering is done; the filters (both
+  /// subfield filters and remaining filter) still apply to values before post
+  /// processing.  ValueHook usage will be disabled if a post processor is
+  /// present.
+  const std::function<void(VectorPtr&)>& postProcessor() const override {
+    return postProcessor_;
+  }
+
   std::string toString() const override;
 
   folly::dynamic serialize() const override;
 
   static ColumnHandlePtr create(const folly::dynamic& obj);
 
-  static std::string columnTypeName(HiveColumnHandle::ColumnType columnType);
-
-  static HiveColumnHandle::ColumnType columnTypeFromName(
-      const std::string& name);
-
   static void registerSerDe();
 
  private:
@@ -129,23 +165,42 @@ class HiveColumnHandle : public ColumnHandle {
   const TypePtr dataType_;
   const TypePtr hiveType_;
   const std::vector<common::Subfield> requiredSubfields_;
+  const std::vector<NamedExtraction> extractions_;
   const ColumnParseParameters columnParseParameters_;
+  const std::function<void(VectorPtr&)> postProcessor_;
 };
 
 using HiveColumnHandlePtr = std::shared_ptr<const HiveColumnHandle>;
 using HiveColumnHandleMap =
     std::unordered_map<std::string, HiveColumnHandlePtr>;
 
-class HiveTableHandle : public ConnectorTableHandle {
+class HiveTableHandle : public FileTableHandle {
  public:
+  /// @param sampleRate Sampling rate in (0, 1] range. 0.1 means 10% sampling.
+  /// 1.0 means no sampling. Default is no sampling.
   HiveTableHandle(
       std::string connectorId,
       const std::string& tableName,
-      bool filterPushdownEnabled,
       common::SubfieldFilters subfieldFilters,
       const core::TypedExprPtr& remainingFilter,
       const RowTypePtr& dataColumns = nullptr,
-      const std::unordered_map<std::string, std::string>& tableParameters = {});
+      std::vector<std::string> indexColumns = {},
+      const std::unordered_map<std::string, std::string>& tableParameters = {},
+      std::vector<HiveColumnHandlePtr> filterColumnHandles = {},
+      double sampleRate = 1.0,
+      std::string dbName = "");
+
+  /// Legacy constructor without indexColumns parameter for backward
+  /// compatibility.
+  HiveTableHandle(
+      std::string connectorId,
+      const std::string& tableName,
+      common::SubfieldFilters subfieldFilters,
+      const core::TypedExprPtr& remainingFilter,
+      const RowTypePtr& dataColumns,
+      const std::unordered_map<std::string, std::string>& tableParameters,
+      std::vector<HiveColumnHandlePtr> filterColumnHandles,
+      double sampleRate = 1.0);
 
   const std::string& tableName() const {
     return tableName_;
@@ -155,27 +210,55 @@ class HiveTableHandle : public ConnectorTableHandle {
     return tableName();
   }
 
-  bool isFilterPushdownEnabled() const {
-    return filterPushdownEnabled_;
+  bool supportsIndexLookup() const override {
+    return !indexColumns_.empty();
+  }
+
+  bool needsIndexSplit() const override {
+    return true;
   }
 
-  const common::SubfieldFilters& subfieldFilters() const {
+  const common::SubfieldFilters& subfieldFilters() const override {
     return subfieldFilters_;
   }
 
-  const core::TypedExprPtr& remainingFilter() const {
+  const core::TypedExprPtr& remainingFilter() const override {
     return remainingFilter_;
   }
 
-  // Schema of the table.  Need this for reading TEXTFILE.
-  const RowTypePtr& dataColumns() const {
+  double sampleRate() const override {
+    return sampleRate_;
+  }
+
+  const RowTypePtr& dataColumns() const override {
     return dataColumns_;
   }
 
-  const std::unordered_map<std::string, std::string>& tableParameters() const {
+  /// Returns the names of the index columns for the table.
+  const std::vector<std::string>& indexColumns() const {
+    return indexColumns_;
+  }
+
+  const std::unordered_map<std::string, std::string>& tableParameters()
+      const override {
     return tableParameters_;
   }
 
+  /// Return filter column handles as FileColumnHandlePtr for the generic scan
+  /// pipeline.
+  std::vector<FileColumnHandlePtr> filterColumnHandles() const override {
+    return {filterColumnHandles_.begin(), filterColumnHandles_.end()};
+  }
+
+  /// Return filter column handles with their concrete Hive type.
+  const std::vector<HiveColumnHandlePtr>& hiveFilterColumnHandles() const {
+    return filterColumnHandles_;
+  }
+
+  const std::string& dbName() const override {
+    return dbName_;
+  }
+
   std::string toString() const override;
 
   folly::dynamic serialize() const override;
@@ -188,13 +271,19 @@ class HiveTableHandle : public ConnectorTableHandle {
 
  private:
   const std::string tableName_;
-  const bool filterPushdownEnabled_;
   const common::SubfieldFilters subfieldFilters_;
   const core::TypedExprPtr remainingFilter_;
+  const double sampleRate_;
   const RowTypePtr dataColumns_;
+  const std::vector<std::string> indexColumns_;
   const std::unordered_map<std::string, std::string> tableParameters_;
+  const std::vector<HiveColumnHandlePtr> filterColumnHandles_;
+  const std::string dbName_;
 };
 
 using HiveTableHandlePtr = std::shared_ptr<const HiveTableHandle>;
 
 } // namespace facebook::velox::connector::hive
+
+// The fmt::formatter for FileColumnHandle::ColumnType is defined in
+// FileColumnHandle.h.
diff --git a/velox/connectors/hive/benchmarks/HivePartitionFunctionBenchmark.cpp b/velox/connectors/hive/benchmarks/HivePartitionFunctionBenchmark.cpp
index f503cb6e2e8..b55c02d7c07 100644
--- a/velox/connectors/hive/benchmarks/HivePartitionFunctionBenchmark.cpp
+++ b/velox/connectors/hive/benchmarks/HivePartitionFunctionBenchmark.cpp
@@ -97,7 +97,7 @@ class HivePartitionFunctionBenchmark
   void run(HivePartitionFunction* function) {
     if (rowVectors_.find(KIND) == rowVectors_.end()) {
       throw std::runtime_error(
-          fmt::format("Unsupported type {}.", mapTypeKindToName(KIND)));
+          fmt::format("Unsupported type {}.", TypeKindName::toName(KIND)));
     }
     function->partition(*rowVectors_[KIND], partitions_);
   }
diff --git a/velox/connectors/hive/iceberg/CMakeLists.txt b/velox/connectors/hive/iceberg/CMakeLists.txt
index 329998b5d40..f6369cb6d9e 100644
--- a/velox/connectors/hive/iceberg/CMakeLists.txt
+++ b/velox/connectors/hive/iceberg/CMakeLists.txt
@@ -11,15 +11,69 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+set(
+  ICEBERG_SOURCES
+  DeletionVectorReader.cpp
+  DeletionVectorWriter.cpp
+  EqualityDeleteFileReader.cpp
+  IcebergColumnHandle.cpp
+  IcebergConfig.cpp
+  IcebergConnector.cpp
+  IcebergDataFileStatistics.cpp
+  IcebergDataSink.cpp
+  IcebergDataSource.cpp
+  IcebergPartitionName.cpp
+  IcebergSplit.cpp
+  IcebergSplitReader.cpp
+  PartitionSpec.cpp
+  PositionalDeleteFileReader.cpp
+  TransformEvaluator.cpp
+  TransformExprBuilder.cpp
+  WriterOptionsAdapter.cpp
+)
+
+if(VELOX_ENABLE_PARQUET)
+  list(APPEND ICEBERG_SOURCES IcebergParquetStatsCollector.cpp)
+endif()
 
 velox_add_library(
   velox_hive_iceberg_splitreader
-  IcebergSplitReader.cpp
-  IcebergSplit.cpp
-  PositionalDeleteFileReader.cpp
+  ${ICEBERG_SOURCES}
+  HEADERS
+  DeletionVectorReader.h
+  DeletionVectorWriter.h
+  EqualityDeleteFileReader.h
+  IcebergColumnHandle.h
+  IcebergConfig.h
+  IcebergConnector.h
+  IcebergDataFileStatistics.h
+  IcebergDataSink.h
+  IcebergDataSource.h
+  IcebergDeleteFile.h
+  IcebergMetadataColumns.h
+  IcebergParquetStatsCollector.h
+  IcebergPartitionName.h
+  IcebergSplit.h
+  IcebergSplitReader.h
+  PartitionSpec.h
+  PositionalDeleteFileReader.h
+  TransformEvaluator.h
+  TransformExprBuilder.h
+  WriterOptionsAdapter.h
+)
+
+velox_link_libraries(
+  velox_hive_iceberg_splitreader
+  velox_connector
+  velox_dwio_parquet_field_id
+  velox_functions_iceberg
+  velox_dwio_dwrf_writer
+  Folly::folly
 )
 
-velox_link_libraries(velox_hive_iceberg_splitreader velox_connector Folly::folly)
+if(VELOX_ENABLE_PARQUET)
+  velox_link_libraries(velox_hive_iceberg_splitreader velox_dwio_arrow_parquet_writer)
+endif()
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/connectors/hive/iceberg/DeletionVectorReader.cpp b/velox/connectors/hive/iceberg/DeletionVectorReader.cpp
new file mode 100644
index 00000000000..6d612a3905c
--- /dev/null
+++ b/velox/connectors/hive/iceberg/DeletionVectorReader.cpp
@@ -0,0 +1,443 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/DeletionVectorReader.h"
+
+#include <folly/lang/Bits.h>
+
+#include "velox/common/base/BitUtil.h"
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/file/FileSystems.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+namespace {
+static constexpr uint32_t kSerialCookieNoRun = 12'346;
+static constexpr uint32_t kSerialCookie = 12'347;
+static constexpr uint32_t kRunContainersNoOffsetThreshold = 4;
+} // namespace
+
+DeletionVectorReader::DeletionVectorReader(
+    const IcebergDeleteFile& dvFile,
+    uint64_t splitOffset,
+    memory::MemoryPool* /*pool*/)
+    : dvFile_(dvFile), splitOffset_(splitOffset) {
+  VELOX_CHECK(
+      dvFile_.content == FileContent::kDeletionVector,
+      "Expected deletion vector file but got content type: {}",
+      static_cast<int>(dvFile_.content));
+  VELOX_CHECK_GT(dvFile_.recordCount, 0, "Empty deletion vector.");
+
+  static constexpr int64_t kMaxDeletionVectorRecordCount = 10'000'000'000LL;
+  VELOX_CHECK_LE(
+      dvFile_.recordCount,
+      kMaxDeletionVectorRecordCount,
+      "Deletion vector record count exceeds sanity limit: {}",
+      dvFile_.recordCount);
+}
+
+void DeletionVectorReader::loadBitmap() {
+  if (loaded_) {
+    return;
+  }
+  loaded_ = true;
+
+  // Prefer the typed contentOffset / contentLength fields. The legacy
+  // bounds-map encoding (kDvOffsetFieldId / kDvLengthFieldId) is kept as a
+  // fallback for callers that have not migrated yet.
+  uint64_t blobOffset = static_cast<uint64_t>(dvFile_.contentOffset);
+  uint64_t blobLength = dvFile_.contentLength > 0
+      ? static_cast<uint64_t>(dvFile_.contentLength)
+      : dvFile_.fileSizeInBytes;
+
+  if (dvFile_.contentLength == 0) {
+    if (auto it = dvFile_.lowerBounds.find(kDvOffsetFieldId);
+        it != dvFile_.lowerBounds.end()) {
+      try {
+        blobOffset = std::stoull(it->second);
+      } catch (const std::exception& e) {
+        VELOX_FAIL(
+            "Failed to parse DV blob offset from bounds map: {}", e.what());
+      }
+    }
+    if (auto it = dvFile_.upperBounds.find(kDvLengthFieldId);
+        it != dvFile_.upperBounds.end()) {
+      try {
+        blobLength = std::stoull(it->second);
+      } catch (const std::exception& e) {
+        VELOX_FAIL(
+            "Failed to parse DV blob length from bounds map: {}", e.what());
+      }
+    }
+  }
+
+  auto fs = filesystems::getFileSystem(dvFile_.filePath, nullptr);
+  auto readFile = fs->openFileForRead(dvFile_.filePath);
+
+  auto fileSize = readFile->size();
+  VELOX_CHECK_LE(
+      blobOffset,
+      fileSize,
+      "DV blob offset {} exceeds file size {}.",
+      blobOffset,
+      fileSize);
+  VELOX_CHECK_LE(
+      blobLength,
+      fileSize - blobOffset,
+      "DV blob range [{}, {}) exceeds file size {}.",
+      blobOffset,
+      blobOffset + blobLength,
+      fileSize);
+
+  std::string blobData(blobLength, '\0');
+  readFile->pread(blobOffset, blobLength, blobData.data());
+
+  // Detect format: 64-bit Roaring64Bitmap vs 32-bit RoaringBitmap.
+  // 64-bit format starts with [numGroups: uint64]. If the first 4 bytes
+  // match a 32-bit cookie (12346 or 12347), it's a legacy 32-bit bitmap.
+  // Otherwise, interpret as 64-bit format.
+  deserializeRoaring64Bitmap(blobData);
+
+  std::sort(deletedPositions_.begin(), deletedPositions_.end());
+}
+
+void DeletionVectorReader::deserializeRoaring64Bitmap(const std::string& data) {
+  if (data.size() < 8) {
+    VELOX_FAIL(
+        "Deletion vector blob too small: {} bytes, expected at least 8.",
+        data.size());
+  }
+
+  const auto* ptr = reinterpret_cast<const uint8_t*>(data.data());
+  const auto* end = ptr + data.size();
+
+  // Peek at first 4 bytes to detect 32-bit vs 64-bit format.
+  uint32_t firstWord;
+  std::memcpy(&firstWord, ptr, sizeof(uint32_t));
+  firstWord = folly::Endian::little(firstWord);
+
+  bool is32BitFormat = (firstWord == kSerialCookieNoRun) ||
+      ((firstWord & 0xFFFF) == kSerialCookie);
+
+  if (is32BitFormat) {
+    // Legacy 32-bit RoaringBitmap — all positions in [0, 2^32).
+    deserialize32BitRoaringBitmap(ptr, end, 0);
+    return;
+  }
+
+  // 64-bit Roaring64Bitmap format:
+  //   [numGroups: uint64]
+  //   For each group (sorted by highBits):
+  //     [highBits: uint32]
+  //     [32-bit RoaringBitmap in portable format]
+  uint64_t numGroups;
+  std::memcpy(&numGroups, ptr, sizeof(uint64_t));
+  numGroups = folly::Endian::little(numGroups);
+  ptr += sizeof(uint64_t);
+
+  static constexpr uint64_t kMaxGroups = 1'000'000;
+  VELOX_CHECK_LE(
+      numGroups,
+      kMaxGroups,
+      "Roaring64Bitmap group count exceeds sanity limit: {}",
+      numGroups);
+
+  for (uint64_t g = 0; g < numGroups; ++g) {
+    VELOX_CHECK_GE(
+        static_cast<size_t>(end - ptr),
+        sizeof(uint32_t),
+        "Truncated Roaring64Bitmap group header.");
+
+    uint32_t highBits;
+    std::memcpy(&highBits, ptr, sizeof(uint32_t));
+    highBits = folly::Endian::little(highBits);
+    ptr += sizeof(uint32_t);
+
+    int64_t highBitsOffset = static_cast<int64_t>(highBits) << 32;
+
+    // Deserialize the 32-bit bitmap for this group.
+    // We need to find its size first by parsing the header.
+    deserialize32BitRoaringBitmap(ptr, end, highBitsOffset);
+
+    // Advance ptr past the 32-bit bitmap we just parsed.
+    // Re-parse the header to compute the size.
+    const auto* bitmapStart = ptr;
+
+    uint32_t cookie;
+    std::memcpy(&cookie, bitmapStart, sizeof(uint32_t));
+    cookie = folly::Endian::little(cookie);
+
+    bool hasRunContainers = false;
+    uint32_t numContainers = 0;
+
+    if ((cookie & 0xFFFF) == kSerialCookie) {
+      hasRunContainers = true;
+      numContainers = (cookie >> 16) + 1;
+      ptr += sizeof(uint32_t);
+    } else if (cookie == kSerialCookieNoRun) {
+      ptr += sizeof(uint32_t);
+      uint32_t containerCount;
+      std::memcpy(&containerCount, ptr, sizeof(uint32_t));
+      numContainers = folly::Endian::little(containerCount);
+      ptr += sizeof(uint32_t);
+    } else {
+      VELOX_FAIL("Unknown roaring bitmap cookie in 64-bit group: {}", cookie);
+    }
+
+    if (numContainers == 0) {
+      continue;
+    }
+
+    // Skip run bitmap if present.
+    if (hasRunContainers) {
+      uint32_t runBitmapBytes = (numContainers + 7) / 8;
+      ptr += runBitmapBytes;
+    }
+
+    // Read key-cardinality pairs to compute container data sizes.
+    struct ContainerMeta {
+      uint16_t key;
+      uint32_t cardinality;
+      bool isRun;
+    };
+    std::vector<ContainerMeta> containers(numContainers);
+
+    // Re-read run bitmap for container type detection.
+    const auto* runBitmapPtr =
+        hasRunContainers ? bitmapStart + sizeof(uint32_t) : nullptr;
+
+    for (uint32_t i = 0; i < numContainers; ++i) {
+      uint16_t key, cardMinus1;
+      std::memcpy(&key, ptr, sizeof(uint16_t));
+      key = folly::Endian::little(key);
+      ptr += sizeof(uint16_t);
+      std::memcpy(&cardMinus1, ptr, sizeof(uint16_t));
+      cardMinus1 = folly::Endian::little(cardMinus1);
+      ptr += sizeof(uint16_t);
+      bool isRun = hasRunContainers && runBitmapPtr
+          ? ((runBitmapPtr[i / 8] >> (i % 8)) & 1)
+          : false;
+      containers[i] = {key, static_cast<uint32_t>(cardMinus1) + 1, isRun};
+    }
+
+    // Skip offset section
+    const bool hasOffsetSection =
+        !hasRunContainers || numContainers >= kRunContainersNoOffsetThreshold;
+    if (hasOffsetSection) {
+      ptr += numContainers * sizeof(uint32_t);
+    }
+
+    // Skip container data.
+    for (uint32_t i = 0; i < numContainers; ++i) {
+      if (containers[i].isRun) {
+        uint16_t numRuns;
+        std::memcpy(&numRuns, ptr, sizeof(uint16_t));
+        numRuns = folly::Endian::little(numRuns);
+        ptr += sizeof(uint16_t) + static_cast<size_t>(numRuns) * 4;
+      } else if (containers[i].cardinality <= 4'096) {
+        ptr += static_cast<size_t>(containers[i].cardinality) * 2;
+      } else {
+        ptr += 8'192;
+      }
+    }
+  }
+}
+
+void DeletionVectorReader::deserialize32BitRoaringBitmap(
+    const uint8_t* ptr,
+    const uint8_t* end,
+    int64_t highBitsOffset) {
+  VELOX_CHECK_GE(static_cast<size_t>(end - ptr), 8, "32-bit bitmap too small.");
+
+  uint32_t cookie;
+  std::memcpy(&cookie, ptr, sizeof(uint32_t));
+  cookie = folly::Endian::little(cookie);
+  ptr += sizeof(uint32_t);
+
+  bool hasRunContainers = false;
+  uint32_t numContainers = 0;
+
+  if ((cookie & 0xFFFF) == kSerialCookie) {
+    hasRunContainers = true;
+    numContainers = (cookie >> 16) + 1;
+  } else if (cookie == kSerialCookieNoRun) {
+    std::memcpy(&numContainers, ptr, sizeof(uint32_t));
+    numContainers = folly::Endian::little(numContainers);
+    ptr += sizeof(uint32_t);
+  } else {
+    VELOX_FAIL(
+        "Unknown roaring bitmap cookie: {}. Expected {} or {}.",
+        cookie,
+        kSerialCookieNoRun,
+        kSerialCookie);
+  }
+
+  if (numContainers == 0) {
+    return;
+  }
+
+  // Read run bitmap if present.
+  std::vector<bool> isRunContainer(numContainers, false);
+  if (hasRunContainers) {
+    uint32_t runBitmapBytes = (numContainers + 7) / 8;
+    VELOX_CHECK_GE(
+        static_cast<size_t>(end - ptr),
+        runBitmapBytes,
+        "Truncated run bitmap.");
+    for (uint32_t i = 0; i < numContainers; ++i) {
+      isRunContainer[i] = (ptr[i / 8] >> (i % 8)) & 1;
+    }
+    ptr += runBitmapBytes;
+  }
+
+  // Read key-cardinality pairs.
+  struct ContainerMeta {
+    uint16_t key;
+    uint32_t cardinality;
+  };
+  std::vector<ContainerMeta> containers(numContainers);
+
+  VELOX_CHECK_GE(
+      static_cast<size_t>(end - ptr),
+      numContainers * 4,
+      "Truncated container metadata.");
+  for (uint32_t i = 0; i < numContainers; ++i) {
+    uint16_t key, cardMinus1;
+    std::memcpy(&key, ptr, sizeof(uint16_t));
+    key = folly::Endian::little(key);
+    ptr += sizeof(uint16_t);
+    std::memcpy(&cardMinus1, ptr, sizeof(uint16_t));
+    cardMinus1 = folly::Endian::little(cardMinus1);
+    ptr += sizeof(uint16_t);
+    containers[i] = {key, static_cast<uint32_t>(cardMinus1) + 1};
+  }
+
+  // Skip offset section
+  const bool hasOffsetSection =
+      !hasRunContainers || numContainers >= kRunContainersNoOffsetThreshold;
+  if (hasOffsetSection) {
+    VELOX_CHECK_GE(
+        static_cast<size_t>(end - ptr),
+        numContainers * 4,
+        "Truncated offset section.");
+    ptr += numContainers * sizeof(uint32_t);
+  }
+
+  // dvFile_.recordCount was already validated against
+  // kMaxDeletionVectorRecordCount in the constructor.
+  deletedPositions_.reserve(deletedPositions_.size() + dvFile_.recordCount);
+
+  // Read container data.
+  for (uint32_t i = 0; i < numContainers; ++i) {
+    int64_t containerBase =
+        highBitsOffset | (static_cast<int64_t>(containers[i].key) << 16);
+    uint32_t cardinality = containers[i].cardinality;
+
+    if (isRunContainer[i]) {
+      uint16_t numRuns;
+      VELOX_CHECK_GE(
+          static_cast<size_t>(end - ptr), 2u, "Truncated run container.");
+      std::memcpy(&numRuns, ptr, sizeof(uint16_t));
+      numRuns = folly::Endian::little(numRuns);
+      ptr += sizeof(uint16_t);
+
+      VELOX_CHECK_GE(
+          static_cast<size_t>(end - ptr),
+          static_cast<size_t>(numRuns) * 4,
+          "Truncated run container data.");
+      for (uint16_t r = 0; r < numRuns; ++r) {
+        uint16_t start, lengthMinus1;
+        std::memcpy(&start, ptr, sizeof(uint16_t));
+        start = folly::Endian::little(start);
+        ptr += sizeof(uint16_t);
+        std::memcpy(&lengthMinus1, ptr, sizeof(uint16_t));
+        lengthMinus1 = folly::Endian::little(lengthMinus1);
+        ptr += sizeof(uint16_t);
+        for (uint32_t v = start;
+             v <= static_cast<uint32_t>(start) + lengthMinus1;
+             ++v) {
+          deletedPositions_.push_back(containerBase | v);
+        }
+      }
+    } else if (cardinality <= 4'096) {
+      VELOX_CHECK_GE(
+          static_cast<size_t>(end - ptr),
+          cardinality * 2,
+          "Truncated array container.");
+      for (uint32_t j = 0; j < cardinality; ++j) {
+        uint16_t val;
+        std::memcpy(&val, ptr, sizeof(uint16_t));
+        val = folly::Endian::little(val);
+        ptr += sizeof(uint16_t);
+        deletedPositions_.push_back(containerBase | val);
+      }
+    } else {
+      static constexpr size_t kBitsetBytes = 8'192;
+      VELOX_CHECK_GE(
+          static_cast<size_t>(end - ptr),
+          kBitsetBytes,
+          "Truncated bitset container.");
+      for (uint32_t word = 0; word < 1'024; ++word) {
+        uint64_t bits;
+        std::memcpy(&bits, ptr + word * 8, sizeof(uint64_t));
+        bits = folly::Endian::little(bits);
+        while (bits != 0) {
+          uint32_t bit = __builtin_ctzll(bits);
+          deletedPositions_.push_back(
+              containerBase | static_cast<int64_t>(word * 64 + bit));
+          bits &= bits - 1;
+        }
+      }
+      ptr += kBitsetBytes;
+    }
+  }
+}
+
+void DeletionVectorReader::readDeletePositions(
+    uint64_t baseReadOffset,
+    uint64_t size,
+    BufferPtr deleteBitmap) {
+  loadBitmap();
+
+  if (deletedPositions_.empty()) {
+    return;
+  }
+
+  auto* bitmap = deleteBitmap->asMutable<uint8_t>();
+  int64_t rowNumberLowerBound =
+      static_cast<int64_t>(splitOffset_ + baseReadOffset);
+  int64_t rowNumberUpperBound =
+      rowNumberLowerBound + static_cast<int64_t>(size);
+
+  while (positionIndex_ < deletedPositions_.size() &&
+         deletedPositions_[positionIndex_] < rowNumberLowerBound) {
+    ++positionIndex_;
+  }
+
+  while (positionIndex_ < deletedPositions_.size() &&
+         deletedPositions_[positionIndex_] < rowNumberUpperBound) {
+    auto bitIndex = static_cast<uint64_t>(
+        deletedPositions_[positionIndex_] - rowNumberLowerBound);
+    bits::setBit(bitmap, bitIndex);
+    ++positionIndex_;
+  }
+}
+
+bool DeletionVectorReader::noMoreData() const {
+  return loaded_ && positionIndex_ >= deletedPositions_.size();
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/DeletionVectorReader.h b/velox/connectors/hive/iceberg/DeletionVectorReader.h
new file mode 100644
index 00000000000..5c3cb4323c9
--- /dev/null
+++ b/velox/connectors/hive/iceberg/DeletionVectorReader.h
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "velox/common/base/BitUtil.h"
+#include "velox/common/memory/Memory.h"
+#include "velox/connectors/hive/iceberg/IcebergDeleteFile.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+/// Reads an Iceberg V3 deletion vector and applies it to the delete bitmap.
+///
+/// Supports both 64-bit Roaring64Bitmap format (used by Java's Roaring64Bitmap
+/// at Meta's 500 PB scale) and legacy 32-bit RoaringBitmap format.
+///
+/// 64-bit format: [numGroups: uint64] then for each group:
+///   [highBits: uint32] [32-bit RoaringBitmap in portable format]
+///
+/// 32-bit format: [cookie: uint32] [containerCount: uint32] ...
+///   Detected by checking if the first 8 bytes match a 32-bit cookie (12346
+///   or 12347).
+class DeletionVectorReader {
+ public:
+  /// @param dvFile Iceberg delete file metadata containing the Puffin file
+  /// path,
+  ///        blob offset, and blob length.
+  /// @param splitOffset File position of the first row in the split.
+  /// @param pool Memory pool for internal allocations.
+  DeletionVectorReader(
+      const IcebergDeleteFile& dvFile,
+      uint64_t splitOffset,
+      memory::MemoryPool* pool);
+
+  /// Reads deleted positions from the DV and sets corresponding bits in the
+  /// deleteBitmap for the current batch range.
+  void readDeletePositions(
+      uint64_t baseReadOffset,
+      uint64_t size,
+      BufferPtr deleteBitmap);
+
+  /// Returns true when there is no more data.
+  bool noMoreData() const;
+
+  static constexpr int32_t kDvOffsetFieldId = 100;
+  static constexpr int32_t kDvLengthFieldId = 101;
+
+ private:
+  void loadBitmap();
+
+  // Deserializes a 64-bit roaring bitmap (Roaring64Bitmap format).
+  void deserializeRoaring64Bitmap(const std::string& data);
+
+  // Deserializes a 32-bit roaring bitmap from portable binary format.
+  // Positions are offset by highBitsOffset (upper 32 bits for 64-bit mode,
+  // 0 for legacy 32-bit mode).
+  void deserialize32BitRoaringBitmap(
+      const uint8_t* ptr,
+      const uint8_t* end,
+      int64_t highBitsOffset);
+
+  // The deletion vector file metadata from the Iceberg manifest.
+  const IcebergDeleteFile dvFile_;
+
+  // Base offset of the split within the data file (for position mapping).
+  const uint64_t splitOffset_;
+
+  // Sorted list of deleted row positions (absolute, file-level positions).
+  std::vector<int64_t> deletedPositions_;
+
+  // Current scan position within deletedPositions_.
+  size_t positionIndex_{0};
+
+  // Whether the bitmap has been loaded from the DV file.
+  bool loaded_{false};
+};
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/DeletionVectorWriter.cpp b/velox/connectors/hive/iceberg/DeletionVectorWriter.cpp
new file mode 100644
index 00000000000..b2721e4f444
--- /dev/null
+++ b/velox/connectors/hive/iceberg/DeletionVectorWriter.cpp
@@ -0,0 +1,256 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/DeletionVectorWriter.h"
+
+#include <algorithm>
+#include <fstream>
+
+#include <folly/json.h>
+#include <folly/lang/Bits.h>
+
+#include "velox/common/base/Exceptions.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+namespace {
+
+// Roaring Bitmap portable format constants.
+constexpr uint32_t kSerialCookieNoRun = 12'346;
+constexpr uint32_t kMaxArrayContainerCardinality = 4'096;
+// Full bitmap container: 2^16 bits = 1024 uint64 words = 8192 bytes.
+constexpr size_t kBitmapContainerBytes = 8'192;
+constexpr size_t kBitmapContainerWords = 1'024;
+
+// Puffin file format constants (per Iceberg spec).
+constexpr char kPuffinMagic[] = {'\x50', '\x55', '\x46', '\x31'};
+constexpr size_t kPuffinMagicSize = 4;
+constexpr uint32_t kPuffinFooterFlags = 0;
+
+// Puffin blob metadata constants (per Iceberg V3 deletion vector spec).
+constexpr char kDeletionVectorBlobType[] = "deletion-vector-v1";
+constexpr char kCompressionCodecNone[] = "none";
+// Iceberg spec: source-field-id for whole-row deletes is INT_MAX - 1.
+constexpr int32_t kWholeRowDeleteFieldId = 2'147'483'646;
+
+void writeLittleEndian(std::string& out, uint16_t val) {
+  val = folly::Endian::little(val);
+  out.append(reinterpret_cast<const char*>(&val), sizeof(val));
+}
+
+void writeLittleEndian(std::string& out, uint32_t val) {
+  val = folly::Endian::little(val);
+  out.append(reinterpret_cast<const char*>(&val), sizeof(val));
+}
+
+void writeLittleEndian(std::string& out, uint64_t val) {
+  val = folly::Endian::little(val);
+  out.append(reinterpret_cast<const char*>(&val), sizeof(val));
+}
+
+// Serializes the key-cardinality header for a 32-bit Roaring Bitmap.
+void serializeKeyCardinality(
+    std::string& data,
+    const std::vector<std::pair<uint16_t, std::vector<uint16_t>>>& containers) {
+  for (const auto& [key, values] : containers) {
+    writeLittleEndian(data, key);
+    auto cardMinus1 = static_cast<uint16_t>(values.size() - 1);
+    writeLittleEndian(data, cardMinus1);
+  }
+}
+
+// Serializes the offset section for a 32-bit Roaring Bitmap.
+// Offsets point to where each container's data begins, measured from the start
+// of the serialized bitmap. The header consists of: cookie (4) + count (4) +
+// key-cardinality pairs (numContainers * 4) + offset section (numContainers *
+// 4). Offsets are relative to byte 0 of the serialized output, so the first
+// container's data starts immediately after the full header including offsets.
+void serializeOffsets(
+    std::string& data,
+    const std::vector<std::pair<uint16_t, std::vector<uint16_t>>>& containers) {
+  auto numContainers = static_cast<uint32_t>(containers.size());
+  uint32_t headerSize = 4 + 4 + numContainers * 4 + numContainers * 4;
+  uint32_t runningOffset = headerSize;
+  for (const auto& [key, values] : containers) {
+    writeLittleEndian(data, runningOffset);
+    if (values.size() <= kMaxArrayContainerCardinality) {
+      runningOffset += static_cast<uint32_t>(values.size()) * 2;
+    } else {
+      runningOffset += kBitmapContainerBytes;
+    }
+  }
+}
+
+// Serializes container data (array or bitmap) for a 32-bit Roaring Bitmap.
+// Array containers store sorted uint16 values directly. Bitmap containers
+// store a 65536-bit bitset as 1024 little-endian uint64 words, covering the
+// full uint16 range [0, 65535].
+void serializeContainerData(
+    std::string& data,
+    const std::vector<std::pair<uint16_t, std::vector<uint16_t>>>& containers) {
+  for (const auto& [key, values] : containers) {
+    if (values.size() <= kMaxArrayContainerCardinality) {
+      for (auto value : values) {
+        writeLittleEndian(data, value);
+      }
+    } else {
+      std::vector<uint64_t> bitmap(kBitmapContainerWords, 0);
+      for (auto value : values) {
+        bitmap[value / 64] |= (1ULL << (value % 64));
+      }
+      for (auto word : bitmap) {
+        writeLittleEndian(data, word);
+      }
+    }
+  }
+}
+
+} // namespace
+
+void DeletionVectorWriter::addDeletedPosition(int64_t position) {
+  VELOX_CHECK_GE(position, 0, "Deleted position must be non-negative.");
+  positions_.push_back(position);
+}
+
+void DeletionVectorWriter::addDeletedPositions(
+    const std::vector<int64_t>& positions) {
+  for (auto pos : positions) {
+    addDeletedPosition(pos);
+  }
+}
+
+std::string DeletionVectorWriter::serialize32(
+    const std::vector<uint32_t>& sorted) const {
+  if (sorted.empty()) {
+    std::string data;
+    writeLittleEndian(data, kSerialCookieNoRun);
+    uint32_t zero = 0;
+    writeLittleEndian(data, zero);
+    return data;
+  }
+
+  // Group values by high 16 bits (container key).
+  std::map<uint16_t, std::vector<uint16_t>> containerMap;
+  for (auto val : sorted) {
+    auto key = static_cast<uint16_t>(val >> 16);
+    auto low = static_cast<uint16_t>(val & 0xFFFF);
+    containerMap[key].push_back(low);
+  }
+
+  std::vector<std::pair<uint16_t, std::vector<uint16_t>>> containers(
+      containerMap.begin(), containerMap.end());
+  auto numContainers = static_cast<uint32_t>(containers.size());
+
+  std::string data;
+  writeLittleEndian(data, kSerialCookieNoRun);
+  writeLittleEndian(data, numContainers);
+  serializeKeyCardinality(data, containers);
+  serializeOffsets(data, containers);
+  serializeContainerData(data, containers);
+  return data;
+}
+
+std::string DeletionVectorWriter::serialize() const {
+  if (positions_.empty()) {
+    std::string data;
+    writeLittleEndian(data, static_cast<uint64_t>(0));
+    return data;
+  }
+
+  // Sort and deduplicate positions.
+  std::vector<int64_t> sorted = positions_;
+  std::sort(sorted.begin(), sorted.end());
+  sorted.erase(std::unique(sorted.begin(), sorted.end()), sorted.end());
+
+  // Partition into 32-bit high groups.
+  // Roaring64Bitmap format: [numGroups: uint64] then for each group:
+  //   [highBits: uint32] [serialized 32-bit RoaringBitmap]
+  std::map<uint32_t, std::vector<uint32_t>> groups;
+  for (auto pos : sorted) {
+    // Safe cast: addDeletedPosition() rejects negative values.
+    auto upos = static_cast<uint64_t>(pos);
+    groups[static_cast<uint32_t>(upos >> 32)].push_back(
+        static_cast<uint32_t>(upos & 0xFFFFFFFF));
+  }
+
+  std::string data;
+  writeLittleEndian(data, static_cast<uint64_t>(groups.size()));
+
+  for (auto& [highBits, lowValues] : groups) {
+    writeLittleEndian(data, highBits);
+    data.append(serialize32(lowValues));
+  }
+
+  return data;
+}
+
+void DeletionVectorWriter::clear() {
+  positions_.clear();
+}
+
+std::pair<uint64_t, uint64_t> writePuffinFile(
+    const std::string& filePath,
+    const std::string& blobData,
+    const std::string& referencedDataFile) {
+  uint64_t blobOffset = kPuffinMagicSize;
+  uint64_t blobLength = blobData.size();
+
+  folly::dynamic blobMeta = folly::dynamic::object(
+      "type", kDeletionVectorBlobType)(
+      "fields",
+      folly::dynamic::array(
+          folly::dynamic::object("source-field-id", kWholeRowDeleteFieldId)));
+  blobMeta["offset"] = blobOffset;
+  blobMeta["length"] = blobLength;
+  blobMeta["compression-codec"] = kCompressionCodecNone;
+
+  folly::dynamic properties = folly::dynamic::object;
+  properties["referenced-data-file"] = referencedDataFile;
+  blobMeta["properties"] = properties;
+
+  folly::dynamic footer = folly::dynamic::object;
+  footer["blobs"] = folly::dynamic::array(blobMeta);
+  footer["properties"] = folly::dynamic::object;
+
+  std::string footerJson = folly::toJson(footer);
+  uint32_t footerPayloadSize = static_cast<uint32_t>(footerJson.size());
+
+  std::string fileContent;
+  fileContent.append(kPuffinMagic, kPuffinMagicSize);
+  fileContent.append(blobData);
+  fileContent.append(footerJson);
+  uint32_t littleEndianSize = folly::Endian::little(footerPayloadSize);
+  fileContent.append(
+      reinterpret_cast<const char*>(&littleEndianSize),
+      sizeof(littleEndianSize));
+  uint32_t littleEndianFlags = folly::Endian::little(kPuffinFooterFlags);
+  fileContent.append(
+      reinterpret_cast<const char*>(&littleEndianFlags),
+      sizeof(littleEndianFlags));
+  fileContent.append(kPuffinMagic, kPuffinMagicSize);
+
+  std::ofstream out(filePath, std::ios::binary | std::ios::trunc);
+  VELOX_CHECK(
+      out.good(), "Failed to open Puffin file for writing: {}", filePath);
+  out.write(
+      fileContent.data(), static_cast<std::streamsize>(fileContent.size()));
+  out.close();
+  VELOX_CHECK(!out.fail(), "Failed to write Puffin file: {}", filePath);
+
+  return {blobOffset, blobLength};
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/DeletionVectorWriter.h b/velox/connectors/hive/iceberg/DeletionVectorWriter.h
new file mode 100644
index 00000000000..a6d7f4f0b2d
--- /dev/null
+++ b/velox/connectors/hive/iceberg/DeletionVectorWriter.h
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <map>
+#include <string>
+#include <vector>
+
+namespace facebook::velox::connector::hive::iceberg {
+
+/// Writes Iceberg V3 deletion vectors as serialized 64-bit roaring bitmaps.
+///
+/// Deletion vectors are an Iceberg V3 feature (format version 3). The roaring
+/// bitmap encoding itself is version-independent, but the Puffin blob type
+/// "deletion-vector-v1" is defined by the Iceberg V3 spec.
+///
+/// DVs are compact roaring bitmaps stored as blobs inside Puffin files to mark
+/// deleted rows in data files. This writer collects deleted row positions and
+/// serializes them in the Roaring64Bitmap portable format, compatible with
+/// Java's Roaring64Bitmap used by the Presto coordinator.
+///
+/// The 64-bit format partitions positions by their upper 32 bits into groups,
+/// each group containing a standard 32-bit RoaringBitmap for the lower 32
+/// bits. This supports files with more than 4 billion rows.
+///
+/// Usage:
+///   DeletionVectorWriter writer;
+///   writer.addDeletedPosition(5);
+///   writer.addDeletedPosition(5'000'000'000LL);
+///   std::string blob = writer.serialize();
+class DeletionVectorWriter {
+ public:
+  DeletionVectorWriter() = default;
+
+  /// Adds a deleted row position (0-based file row offset).
+  void addDeletedPosition(int64_t position);
+
+  /// Adds multiple deleted row positions.
+  void addDeletedPositions(const std::vector<int64_t>& positions);
+
+  /// Returns the number of deleted positions collected so far.
+  size_t numPositions() const {
+    return positions_.size();
+  }
+
+  /// Serializes collected positions into a 64-bit roaring bitmap.
+  ///
+  /// Format: Roaring64Bitmap portable serialization —
+  ///   [numGroups: uint64]
+  ///   For each group (sorted by highBits):
+  ///     [highBits: uint32]
+  ///     [32-bit RoaringBitmap in portable format]
+  ///
+  /// Each 32-bit RoaringBitmap uses SERIAL_COOKIE_NO_RUNCONTAINER (12346)
+  /// with array containers (cardinality <= 4096) or bitmap containers.
+  ///
+  /// @return Binary string containing the serialized 64-bit roaring bitmap.
+  std::string serialize() const;
+
+  /// Clears all collected positions.
+  void clear();
+
+ private:
+  /// Serializes a single 32-bit roaring bitmap from sorted, deduplicated
+  /// values in the range [0, 2^32).
+  std::string serialize32(const std::vector<uint32_t>& sorted) const;
+
+  std::vector<int64_t> positions_;
+};
+
+/// Writes a Puffin file containing a single deletion vector blob.
+///
+/// The Puffin file format consists of:
+///   - 4-byte magic: "PUF1"
+///   - Blob data (the serialized roaring bitmap)
+///   - Footer: blob metadata + footer payload size + magic
+///
+/// @param filePath Path to write the Puffin file.
+/// @param blobData Serialized roaring bitmap bytes.
+/// @param referencedDataFile Path of the data file this DV applies to.
+/// @return Pair of (blobOffset, blobLength) within the written file.
+std::pair<uint64_t, uint64_t> writePuffinFile(
+    const std::string& filePath,
+    const std::string& blobData,
+    const std::string& referencedDataFile);
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/EqualityDeleteFileReader.cpp b/velox/connectors/hive/iceberg/EqualityDeleteFileReader.cpp
new file mode 100644
index 00000000000..6d24875f375
--- /dev/null
+++ b/velox/connectors/hive/iceberg/EqualityDeleteFileReader.cpp
@@ -0,0 +1,360 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/EqualityDeleteFileReader.h"
+
+#include "velox/common/base/BitUtil.h"
+#include "velox/connectors/hive/BufferedInputBuilder.h"
+#include "velox/connectors/hive/HiveConnectorUtil.h"
+#include "velox/connectors/hive/iceberg/IcebergMetadataColumns.h"
+#include "velox/dwio/common/ReaderFactory.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+namespace {
+
+// Hashes a single value from a vector at the given index.
+// Handles lazy vectors via loadedVector(). Returns 0 for null values.
+uint64_t hashValue(const VectorPtr& vectorPtr, vector_size_t index) {
+  const auto* vector = vectorPtr->loadedVector();
+  if (vector->isNullAt(index)) {
+    return 0;
+  }
+
+  auto type = vector->type();
+  switch (type->kind()) { // NOLINT(clang-diagnostic-switch-enum)
+    case TypeKind::BOOLEAN:
+      return std::hash<bool>{}(
+          vector->as<SimpleVector<bool>>()->valueAt(index));
+    case TypeKind::TINYINT:
+      return std::hash<int8_t>{}(
+          vector->as<SimpleVector<int8_t>>()->valueAt(index));
+    case TypeKind::SMALLINT:
+      return std::hash<int16_t>{}(
+          vector->as<SimpleVector<int16_t>>()->valueAt(index));
+    case TypeKind::INTEGER:
+      return std::hash<int32_t>{}(
+          vector->as<SimpleVector<int32_t>>()->valueAt(index));
+    case TypeKind::BIGINT:
+      return std::hash<int64_t>{}(
+          vector->as<SimpleVector<int64_t>>()->valueAt(index));
+    case TypeKind::REAL:
+      return std::hash<float>{}(
+          vector->as<SimpleVector<float>>()->valueAt(index));
+    case TypeKind::DOUBLE:
+      return std::hash<double>{}(
+          vector->as<SimpleVector<double>>()->valueAt(index));
+    case TypeKind::VARCHAR:
+    case TypeKind::VARBINARY: {
+      auto stringView = vector->as<SimpleVector<StringView>>()->valueAt(index);
+      return folly::hasher<std::string_view>{}(
+          std::string_view(stringView.data(), stringView.size()));
+    }
+    case TypeKind::TIMESTAMP: {
+      auto ts = vector->as<SimpleVector<Timestamp>>()->valueAt(index);
+      return std::hash<int64_t>{}(ts.toNanos());
+    }
+    default:
+      VELOX_NYI(
+          "Equality delete hash not implemented for type: {}",
+          type->toString());
+  }
+}
+
+// Compares two values from vectors at given indices.
+// Handles lazy vectors via loadedVector().
+bool compareValues(
+    const VectorPtr& leftPtr,
+    vector_size_t leftIndex,
+    const VectorPtr& rightPtr,
+    vector_size_t rightIndex) {
+  const auto* left = leftPtr->loadedVector();
+  const auto* right = rightPtr->loadedVector();
+  bool leftNull = left->isNullAt(leftIndex);
+  bool rightNull = right->isNullAt(rightIndex);
+  if (leftNull && rightNull) {
+    return true;
+  }
+  if (leftNull || rightNull) {
+    return false;
+  }
+
+  auto type = left->type();
+  switch (type->kind()) { // NOLINT(clang-diagnostic-switch-enum)
+    case TypeKind::BOOLEAN:
+      return left->as<SimpleVector<bool>>()->valueAt(leftIndex) ==
+          right->as<SimpleVector<bool>>()->valueAt(rightIndex);
+    case TypeKind::TINYINT:
+      return left->as<SimpleVector<int8_t>>()->valueAt(leftIndex) ==
+          right->as<SimpleVector<int8_t>>()->valueAt(rightIndex);
+    case TypeKind::SMALLINT:
+      return left->as<SimpleVector<int16_t>>()->valueAt(leftIndex) ==
+          right->as<SimpleVector<int16_t>>()->valueAt(rightIndex);
+    case TypeKind::INTEGER:
+      return left->as<SimpleVector<int32_t>>()->valueAt(leftIndex) ==
+          right->as<SimpleVector<int32_t>>()->valueAt(rightIndex);
+    case TypeKind::BIGINT:
+      return left->as<SimpleVector<int64_t>>()->valueAt(leftIndex) ==
+          right->as<SimpleVector<int64_t>>()->valueAt(rightIndex);
+    case TypeKind::REAL:
+      return left->as<SimpleVector<float>>()->valueAt(leftIndex) ==
+          right->as<SimpleVector<float>>()->valueAt(rightIndex);
+    case TypeKind::DOUBLE:
+      return left->as<SimpleVector<double>>()->valueAt(leftIndex) ==
+          right->as<SimpleVector<double>>()->valueAt(rightIndex);
+    case TypeKind::VARCHAR:
+    case TypeKind::VARBINARY: {
+      auto leftValue = left->as<SimpleVector<StringView>>()->valueAt(leftIndex);
+      auto rightValue =
+          right->as<SimpleVector<StringView>>()->valueAt(rightIndex);
+      return std::string_view(leftValue.data(), leftValue.size()) ==
+          std::string_view(rightValue.data(), rightValue.size());
+    }
+    case TypeKind::TIMESTAMP:
+      return left->as<SimpleVector<Timestamp>>()->valueAt(leftIndex) ==
+          right->as<SimpleVector<Timestamp>>()->valueAt(rightIndex);
+    default:
+      VELOX_NYI(
+          "Equality delete comparison not implemented for type: {}",
+          type->toString());
+  }
+}
+
+} // namespace
+
+EqualityDeleteFileReader::EqualityDeleteFileReader(
+    const IcebergDeleteFile& deleteFile,
+    const std::vector<std::string>& equalityColumnNames,
+    const std::vector<TypePtr>& equalityColumnTypes,
+    const std::string& /*baseFilePath*/,
+    FileHandleFactory* fileHandleFactory,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    folly::Executor* executor,
+    const std::shared_ptr<const FileConfig>& fileConfig,
+    const std::shared_ptr<io::IoStatistics>& ioStatistics,
+    const std::shared_ptr<IoStats>& ioStats,
+    dwio::common::RuntimeStatistics& runtimeStats,
+    const std::string& connectorId)
+    : equalityColumnNames_(equalityColumnNames),
+      equalityColumnTypes_(equalityColumnTypes),
+      pool_(connectorQueryCtx->memoryPool()) {
+  VELOX_CHECK(
+      deleteFile.content == FileContent::kEqualityDeletes,
+      "Expected equality delete file but got content type: {}",
+      static_cast<int>(deleteFile.content));
+  VELOX_CHECK_GT(deleteFile.recordCount, 0, "Empty equality delete file.");
+  VELOX_CHECK(
+      !equalityColumnNames_.empty(),
+      "Equality delete file must specify at least one column.");
+  VELOX_CHECK_EQ(
+      equalityColumnNames_.size(),
+      equalityColumnTypes_.size(),
+      "Equality column names and types must have the same size.");
+
+  // Build the file schema for the equality delete columns only.
+  auto deleteFileSchema =
+      ROW(std::vector<std::string>(equalityColumnNames_),
+          std::vector<TypePtr>(equalityColumnTypes_));
+
+  // Create a ScanSpec that reads only the equality delete columns.
+  auto scanSpec = std::make_shared<common::ScanSpec>("<root>");
+  for (size_t i = 0; i < equalityColumnNames_.size(); ++i) {
+    scanSpec->addField(equalityColumnNames_[i], static_cast<int>(i));
+  }
+
+  auto deleteSplit = std::make_shared<HiveConnectorSplit>(
+      connectorId,
+      deleteFile.filePath,
+      deleteFile.fileFormat,
+      0,
+      deleteFile.fileSizeInBytes);
+
+  dwio::common::ReaderOptions deleteReaderOpts(pool_);
+  // TODO: Use separate IoStatistics for data and metadata.
+  deleteReaderOpts.setDataIoStats(ioStatistics);
+  deleteReaderOpts.setMetadataIoStats(ioStatistics);
+  configureReaderOptions(
+      fileConfig,
+      connectorQueryCtx,
+      deleteFileSchema,
+      deleteSplit,
+      /*tableParameters=*/{},
+      deleteReaderOpts);
+
+  const FileHandleKey fileHandleKey{
+      .filename = deleteFile.filePath,
+      .tokenProvider = connectorQueryCtx->fsTokenProvider()};
+  auto deleteFileHandleCachePtr = fileHandleFactory->generate(fileHandleKey);
+  auto deleteFileInput = BufferedInputBuilder::getInstance()->create(
+      *deleteFileHandleCachePtr,
+      deleteReaderOpts,
+      connectorQueryCtx,
+      ioStatistics,
+      ioStats,
+      executor);
+
+  auto deleteReader =
+      dwio::common::getReaderFactory(deleteReaderOpts.fileFormat())
+          ->createReader(std::move(deleteFileInput), deleteReaderOpts);
+
+  if (!testFilters(
+          scanSpec.get(),
+          deleteReader.get(),
+          deleteSplit->filePath,
+          deleteSplit->partitionKeys,
+          {},
+          fileConfig->readTimestampPartitionValueAsLocalTime(
+              connectorQueryCtx->sessionProperties()))) {
+    runtimeStats.skippedSplitBytes += static_cast<int64_t>(deleteSplit->length);
+    return;
+  }
+
+  dwio::common::RowReaderOptions deleteRowReaderOpts;
+  configureRowReaderOptions(
+      {},
+      scanSpec,
+      nullptr,
+      deleteFileSchema,
+      deleteSplit,
+      nullptr,
+      nullptr,
+      nullptr,
+      deleteRowReaderOpts);
+
+  auto deleteRowReader = deleteReader->createRowReader(deleteRowReaderOpts);
+
+  // Read the entire equality delete file and build the hash set.
+  VectorPtr output;
+  output = BaseVector::create(deleteFileSchema, 0, pool_);
+
+  while (true) {
+    auto rowsRead = deleteRowReader->next(
+        std::max(static_cast<uint64_t>(1'000), deleteFile.recordCount), output);
+    if (rowsRead == 0) {
+      break;
+    }
+
+    auto numRows = output->size();
+    if (numRows == 0) {
+      continue;
+    }
+
+    output->loadedVector();
+    auto rowOutput = std::dynamic_pointer_cast<RowVector>(output);
+    VELOX_CHECK_NOT_NULL(rowOutput);
+
+    size_t batchIndex = deleteRows_.size();
+    deleteRows_.push_back(rowOutput);
+
+    // Resolve column indices on the first batch.
+    if (deleteColumnIndices_.empty()) {
+      for (const auto& colName : equalityColumnNames_) {
+        auto idx = rowOutput->type()->as<TypeKind::ROW>().getChildIdx(colName);
+        deleteColumnIndices_.push_back(static_cast<column_index_t>(idx));
+      }
+    }
+
+    // Hash each row and insert into the multimap.
+    for (vector_size_t i = 0; i < numRows; ++i) {
+      uint64_t hash = hashRow(rowOutput, i, deleteColumnIndices_);
+      deleteKeyHashes_.emplace(hash, DeleteKeyEntry{batchIndex, i});
+    }
+
+    // Reset output for next batch.
+    output = BaseVector::create(deleteFileSchema, 0, pool_);
+  }
+}
+
+void EqualityDeleteFileReader::applyDeletes(
+    const RowVectorPtr& output,
+    BufferPtr deleteBitmap) {
+  if (deleteKeyHashes_.empty() || output->size() == 0) {
+    return;
+  }
+
+  auto* bitmap = deleteBitmap->asMutable<uint8_t>();
+
+  // For each row in the output, compute its hash and probe the delete set.
+  for (vector_size_t i = 0; i < output->size(); ++i) {
+    // Skip rows already deleted by positional/DV deletes.
+    if (bits::isBitSet(bitmap, i)) {
+      continue;
+    }
+
+    uint64_t hash = hashRow(output, i, resolveOutputColumnIndices(output));
+    auto range = deleteKeyHashes_.equal_range(hash);
+
+    for (auto it = range.first; it != range.second; ++it) {
+      auto& entry = it->second;
+      if (equalRows(output, i, deleteRows_[entry.batchIndex], entry.rowIndex)) {
+        bits::setBit(bitmap, i);
+        break;
+      }
+    }
+  }
+}
+
+const std::vector<column_index_t>&
+EqualityDeleteFileReader::resolveOutputColumnIndices(
+    const RowVectorPtr& row) const {
+  if (outputColumnIndices_.empty()) {
+    const auto& rowType = row->type()->asRow();
+    outputColumnIndices_.reserve(equalityColumnNames_.size());
+    for (const auto& colName : equalityColumnNames_) {
+      auto colIdx = rowType.getChildIdxIfExists(colName);
+      VELOX_CHECK(
+          colIdx.has_value(),
+          "Equality delete column not found in the output columns: {}",
+          colName);
+      outputColumnIndices_.push_back(static_cast<column_index_t>(*colIdx));
+    }
+  }
+  return outputColumnIndices_;
+}
+
+uint64_t EqualityDeleteFileReader::hashRow(
+    const RowVectorPtr& row,
+    vector_size_t index,
+    const std::vector<column_index_t>& colIndices) const {
+  uint64_t hash = 0;
+
+  for (auto colIdx : colIndices) {
+    auto colHash = hashValue(row->childAt(colIdx), index);
+    hash ^= colHash + 0x9e3779b97f4a7c15ULL + (hash << 6) + (hash >> 2);
+  }
+  return hash;
+}
+
+bool EqualityDeleteFileReader::equalRows(
+    const RowVectorPtr& left,
+    vector_size_t leftIndex,
+    const RowVectorPtr& right,
+    vector_size_t rightIndex) const {
+  const auto& leftColIndices = resolveOutputColumnIndices(left);
+
+  for (size_t i = 0; i < leftColIndices.size(); ++i) {
+    if (!compareValues(
+            left->childAt(leftColIndices[i]),
+            leftIndex,
+            right->childAt(deleteColumnIndices_[i]),
+            rightIndex)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/EqualityDeleteFileReader.h b/velox/connectors/hive/iceberg/EqualityDeleteFileReader.h
new file mode 100644
index 00000000000..ad3a2be359a
--- /dev/null
+++ b/velox/connectors/hive/iceberg/EqualityDeleteFileReader.h
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <folly/Executor.h>
+#include <memory>
+#include <unordered_set>
+
+#include "velox/connectors/Connector.h"
+#include "velox/connectors/hive/FileConfig.h"
+#include "velox/connectors/hive/FileHandle.h"
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/connectors/hive/iceberg/IcebergDeleteFile.h"
+#include "velox/dwio/common/Reader.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+/// Reads an Iceberg equality delete file and filters base data rows whose
+/// equality delete column values match any row in the delete file.
+///
+/// Iceberg equality delete files contain rows with values for one or more
+/// columns (identified by equalityFieldIds). A base data row is deleted if
+/// its values match ALL specified columns of ANY row in the delete file.
+///
+/// Unlike positional deletes (which set bits before reading), equality deletes
+/// require reading the base data first, then probing each row against the
+/// delete set. The reader eagerly loads all delete key tuples from the file
+/// into an in-memory hash set during construction.
+///
+/// The equality delete column names are resolved from equalityFieldIds via
+/// the table schema provided by the caller.
+class EqualityDeleteFileReader {
+ public:
+  /// Constructs a reader for a single equality delete file.
+  ///
+  /// Eagerly reads the entire delete file and builds an in-memory hash set
+  /// of delete key tuples. The delete file is fully consumed during
+  /// construction.
+  ///
+  /// @param deleteFile Metadata about the equality delete file. Must have
+  ///   content == FileContent::kEqualityDeletes and non-empty
+  ///   equalityFieldIds.
+  /// @param equalityColumnNames Ordered column names corresponding to
+  ///   equalityFieldIds, resolved by the caller from the table schema.
+  /// @param equalityColumnTypes Ordered column types corresponding to
+  ///   equalityFieldIds.
+  /// @param baseFilePath Path of the base data file being read.
+  /// @param fileHandleFactory Factory for creating file handles.
+  /// @param connectorQueryCtx Query context for memory and config.
+  /// @param executor IO executor for async reads.
+  /// @param hiveConfig Hive configuration.
+  /// @param ioStatistics IO statistics collector.
+  /// @param ioStats IO stats tracker.
+  /// @param runtimeStats Runtime statistics for recording skipped bytes.
+  /// @param connectorId Connector identifier.
+  EqualityDeleteFileReader(
+      const IcebergDeleteFile& deleteFile,
+      const std::vector<std::string>& equalityColumnNames,
+      const std::vector<TypePtr>& equalityColumnTypes,
+      const std::string& baseFilePath,
+      FileHandleFactory* fileHandleFactory,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      folly::Executor* executor,
+      const std::shared_ptr<const FileConfig>& fileConfig,
+      const std::shared_ptr<io::IoStatistics>& ioStatistics,
+      const std::shared_ptr<IoStats>& ioStats,
+      dwio::common::RuntimeStatistics& runtimeStats,
+      const std::string& connectorId);
+
+  /// Applies equality deletes to the output vector by setting bits in the
+  /// delete bitmap for rows whose equality column values match any delete
+  /// key tuple.
+  ///
+  /// @param output The base data output vector to filter.
+  /// @param deleteBitmap Output bitmap. Bit i is set if row i matches an
+  ///   equality delete. The bitmap must be pre-allocated to cover at least
+  ///   output->size() rows.
+  void applyDeletes(const RowVectorPtr& output, BufferPtr deleteBitmap);
+
+  /// Returns the number of delete key tuples loaded from the file.
+  size_t numDeleteKeys() const {
+    return deleteKeyHashes_.size();
+  }
+
+  /// Returns true if this reader has no delete keys (file was skipped or
+  /// empty). When true, applyDeletes() is a no-op.
+  bool empty() const {
+    return deleteKeyHashes_.empty();
+  }
+
+ private:
+  // Resolves column indices for the given row type, caching the result in
+  // outputColumnIndices_ for reuse across rows.
+  const std::vector<column_index_t>& resolveOutputColumnIndices(
+      const RowVectorPtr& row) const;
+
+  // Hashes a single row's equality delete columns into a uint64_t key.
+  uint64_t hashRow(
+      const RowVectorPtr& row,
+      vector_size_t index,
+      const std::vector<column_index_t>& colIndices) const;
+
+  // Checks whether two rows are equal on all equality delete columns.
+  bool equalRows(
+      const RowVectorPtr& left,
+      vector_size_t leftIndex,
+      const RowVectorPtr& right,
+      vector_size_t rightIndex) const;
+
+  // Column names and types for equality delete comparison.
+  std::vector<std::string> equalityColumnNames_;
+  std::vector<TypePtr> equalityColumnTypes_;
+
+  // Column indices in the delete file output vector.
+  std::vector<column_index_t> deleteColumnIndices_;
+
+  // Cached column indices for the output (probe) row type. Resolved lazily
+  // on first applyDeletes() call to avoid repeated name lookups per row.
+  mutable std::vector<column_index_t> outputColumnIndices_;
+
+  // All rows read from the equality delete file, stored for equality
+  // comparison during probing.
+  std::vector<RowVectorPtr> deleteRows_;
+
+  // Hash multimap storing (hash → (batch index, row index)) for all delete
+  // key tuples. Used for O(1) average-case probing.
+  struct DeleteKeyEntry {
+    size_t batchIndex;
+    vector_size_t rowIndex;
+  };
+  std::unordered_multimap<uint64_t, DeleteKeyEntry> deleteKeyHashes_;
+
+  memory::MemoryPool* const pool_;
+};
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergColumnHandle.cpp b/velox/connectors/hive/iceberg/IcebergColumnHandle.cpp
new file mode 100644
index 00000000000..28666689e6f
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergColumnHandle.cpp
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "velox/connectors/hive/TableHandle.h"
+#include "velox/connectors/hive/iceberg/IcebergColumnHandle.h"
+#include "velox/dwio/parquet/ParquetFieldId.h"
+#include "velox/type/Subfield.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+IcebergColumnHandle::IcebergColumnHandle(
+    const std::string& name,
+    ColumnType columnType,
+    TypePtr dataType,
+    parquet::ParquetFieldId icebergField,
+    std::vector<common::Subfield> requiredSubfields,
+    std::optional<std::string> initialDefaultValue)
+    : HiveColumnHandle(
+          name,
+          columnType,
+          dataType,
+          dataType,
+          std::move(requiredSubfields),
+          ColumnParseParameters{ColumnParseParameters::
+                                    PartitionDateValueFormat::kDaysSinceEpoch}),
+      field_(std::move(icebergField)),
+      initialDefaultValue_(std::move(initialDefaultValue)) {}
+
+const parquet::ParquetFieldId& IcebergColumnHandle::field() const {
+  return field_;
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergColumnHandle.h b/velox/connectors/hive/iceberg/IcebergColumnHandle.h
new file mode 100644
index 00000000000..54b722dae9e
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergColumnHandle.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "velox/connectors/hive/TableHandle.h"
+#include "velox/dwio/parquet/ParquetFieldId.h"
+#include "velox/type/Subfield.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+class IcebergColumnHandle : public HiveColumnHandle {
+ public:
+  IcebergColumnHandle(
+      const std::string& name,
+      ColumnType columnType,
+      TypePtr dataType,
+      parquet::ParquetFieldId icebergField,
+      std::vector<common::Subfield> requiredSubfields = {},
+      std::optional<std::string> initialDefaultValue = std::nullopt);
+
+  const parquet::ParquetFieldId& field() const;
+
+  const std::optional<std::string>& initialDefaultValue() const {
+    return initialDefaultValue_;
+  }
+
+ private:
+  const parquet::ParquetFieldId field_;
+  const std::optional<std::string> initialDefaultValue_;
+};
+
+using IcebergColumnHandlePtr = std::shared_ptr<const IcebergColumnHandle>;
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergConfig.cpp b/velox/connectors/hive/iceberg/IcebergConfig.cpp
new file mode 100644
index 00000000000..1b34b7c4eb7
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergConfig.cpp
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/IcebergConfig.h"
+
+#include "velox/common/config/Config.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+IcebergConfig::IcebergConfig(
+    const std::shared_ptr<const config::ConfigBase>& config)
+    : config_(config) {
+  VELOX_CHECK_NOT_NULL(
+      config_, "Config is null for IcebergConfig initialization");
+}
+
+std::string IcebergConfig::functionPrefix() const {
+  return config_->get<std::string>(
+      kFunctionPrefixConfig, kDefaultFunctionPrefix);
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergConfig.h b/velox/connectors/hive/iceberg/IcebergConfig.h
new file mode 100644
index 00000000000..9eba3bd20b9
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergConfig.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "velox/common/config/Config.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+/// Iceberg-specific connector configuration wrapper.
+/// Provides accessors for Iceberg-only settings while sharing the same
+/// underlying ConfigBase with HiveConfig.
+class IcebergConfig {
+ public:
+  /// Iceberg function prefix.
+  static constexpr const char* kFunctionPrefixConfig =
+      "presto.iceberg-namespace";
+
+  /// Default prefix used to register Iceberg transform functions when no
+  /// connector config override is provided.
+  static constexpr const char* kDefaultFunctionPrefix = "$internal$.iceberg.";
+
+  explicit IcebergConfig(
+      const std::shared_ptr<const config::ConfigBase>& config);
+
+  const std::shared_ptr<const config::ConfigBase>& config() const {
+    return config_;
+  }
+
+  std::string functionPrefix() const;
+
+ private:
+  const std::shared_ptr<const config::ConfigBase> config_;
+};
+
+using IcebergConfigPtr = std::shared_ptr<const IcebergConfig>;
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergConnector.cpp b/velox/connectors/hive/iceberg/IcebergConnector.cpp
new file mode 100644
index 00000000000..685be818d2c
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergConnector.cpp
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/IcebergConnector.h"
+
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/connectors/hive/iceberg/IcebergConfig.h"
+#include "velox/connectors/hive/iceberg/IcebergDataSink.h"
+#include "velox/connectors/hive/iceberg/IcebergDataSource.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+namespace {
+
+// Registers Iceberg partition transform functions with prefix.
+// NOTE: These functions are registered for internal transform usage only.
+// Upstream engines such as Prestissimo and Gluten should register the same
+// functions with different prefixes to avoid conflicts.
+void registerIcebergInternalFunctions(const std::string& prefix) {
+  static std::once_flag registerFlag;
+
+  std::call_once(registerFlag, [prefix]() {
+    functions::iceberg::registerFunctions(prefix);
+  });
+}
+
+} // namespace
+
+IcebergConnector::IcebergConnector(
+    const std::string& id,
+    std::shared_ptr<const config::ConfigBase> config,
+    folly::Executor* ioExecutor)
+    : HiveConnector(id, config, ioExecutor),
+      icebergConfig_(std::make_shared<IcebergConfig>(connectorConfig())) {
+  registerIcebergInternalFunctions(icebergConfig_->functionPrefix());
+}
+
+std::unique_ptr<DataSource> IcebergConnector::createDataSource(
+    const RowTypePtr& outputType,
+    const ConnectorTableHandlePtr& tableHandle,
+    const ColumnHandleMap& columnHandles,
+    ConnectorQueryCtx* connectorQueryCtx) {
+  return std::make_unique<IcebergDataSource>(
+      outputType,
+      tableHandle,
+      columnHandles,
+      &fileHandleFactory_,
+      ioExecutor_,
+      connectorQueryCtx,
+      hiveConfig_);
+}
+
+std::unique_ptr<DataSink> IcebergConnector::createDataSink(
+    RowTypePtr inputType,
+    ConnectorInsertTableHandlePtr connectorInsertTableHandle,
+    ConnectorQueryCtx* connectorQueryCtx,
+    CommitStrategy commitStrategy) {
+  auto icebergInsertHandle = checkedPointerCast<const IcebergInsertTableHandle>(
+      connectorInsertTableHandle);
+
+  return std::make_unique<IcebergDataSink>(
+      inputType,
+      icebergInsertHandle,
+      connectorQueryCtx,
+      commitStrategy,
+      hiveConfig_,
+      icebergConfig_);
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergConnector.h b/velox/connectors/hive/iceberg/IcebergConnector.h
new file mode 100644
index 00000000000..32c8206d293
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergConnector.h
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/connectors/hive/iceberg/IcebergConfig.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+/// Provides Iceberg table format support.
+/// - Creates IcebergDataSource instances for reading Iceberg tables with
+///   support for delete files and schema evolution.
+/// - Creates IcebergDataSink instances for writing data with Iceberg-specific
+///   partition transforms and commit metadata.
+class IcebergConnector final : public HiveConnector {
+ public:
+  IcebergConnector(
+      const std::string& id,
+      std::shared_ptr<const config::ConfigBase> config,
+      folly::Executor* ioExecutor);
+
+  /// Creates IcebergDataSource for reading from Iceberg tables.
+  ///
+  /// @param outputType The schema of the output data to read.
+  /// @param tableHandle The table handle containing table metadata.
+  /// @param columnHandles Map of column names to column handles.
+  /// @param connectorQueryCtx Query context for the read operation.
+  /// @return IcebergDataSource instance configured for the read operation.
+  std::unique_ptr<DataSource> createDataSource(
+      const RowTypePtr& outputType,
+      const ConnectorTableHandlePtr& tableHandle,
+      const ColumnHandleMap& columnHandles,
+      ConnectorQueryCtx* connectorQueryCtx) override;
+
+  /// Creates IcebergDataSink for writing to Iceberg tables.
+  ///
+  /// @param inputType The schema of the input data to write.
+  /// @param connectorInsertTableHandle Must be an IcebergInsertTableHandle
+  ///        containing Iceberg-specific write configuration.
+  /// @param connectorQueryCtx Query context for the write operation.
+  /// @param commitStrategy Strategy for committing the write operation. Only
+  ///        CommitStrategy::kNoCommit is supported for Iceberg tables. Files
+  ///        are written directly with their final names and commit metadata is
+  ///        returned for the coordinator to update the Iceberg metadata tables.
+  /// @return IcebergDataSink instance configured for the write operation.
+  std::unique_ptr<DataSink> createDataSink(
+      RowTypePtr inputType,
+      ConnectorInsertTableHandlePtr connectorInsertTableHandle,
+      ConnectorQueryCtx* connectorQueryCtx,
+      CommitStrategy commitStrategy) override;
+
+ private:
+  const std::shared_ptr<IcebergConfig> icebergConfig_;
+};
+
+class IcebergConnectorFactory final : public ConnectorFactory {
+ public:
+  static constexpr const char* kIcebergConnectorName = "iceberg";
+
+  IcebergConnectorFactory() : ConnectorFactory(kIcebergConnectorName) {}
+
+  /// Creates a new IcebergConnector instance.
+  ///
+  /// @param id Unique identifier for this connector instance (typically the
+  /// catalog name).
+  /// @param config Connector configuration properties
+  /// @param ioExecutor Optional executor for asynchronous I/O operations such
+  /// as split preloading and file prefetching. When provided, enables
+  /// background file operations off the main driver thread. If nullptr, I/O
+  /// operations run synchronously.
+  /// @param cpuExecutor ConnectorFactory interface to support other connector
+  /// types that may need CPU-bound async work. Currently unused by
+  /// IcebergConnector.
+  /// @return Shared pointer to the newly created IcebergConnector instance
+  std::shared_ptr<Connector> newConnector(
+      const std::string& id,
+      std::shared_ptr<const config::ConfigBase> config,
+      folly::Executor* ioExecutor = nullptr,
+      [[maybe_unused]] folly::Executor* cpuExecutor = nullptr) override {
+    return std::make_shared<IcebergConnector>(id, config, ioExecutor);
+  }
+};
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergDataFileStatistics.cpp b/velox/connectors/hive/iceberg/IcebergDataFileStatistics.cpp
new file mode 100644
index 00000000000..018f3f8f68c
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergDataFileStatistics.cpp
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/IcebergDataFileStatistics.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+folly::dynamic IcebergDataFileStatistics::toJson() const {
+  folly::dynamic json = folly::dynamic::object;
+  json["recordCount"] = numRecords;
+
+  folly::dynamic columnSizes = folly::dynamic::object;
+  folly::dynamic valueCounts = folly::dynamic::object;
+  folly::dynamic nullValueCounts = folly::dynamic::object;
+  folly::dynamic nanValueCounts = folly::dynamic::object;
+  folly::dynamic lowerBounds = folly::dynamic::object;
+  folly::dynamic upperBounds = folly::dynamic::object;
+
+  for (const auto& [fieldId, stats] : columnStats) {
+    auto fieldIdStr = folly::to<std::string>(fieldId);
+    columnSizes[fieldIdStr] = stats.columnSize;
+    valueCounts[fieldIdStr] = stats.valueCount;
+    nullValueCounts[fieldIdStr] = stats.nullValueCount;
+    if (stats.nanValueCount.has_value()) {
+      nanValueCounts[fieldIdStr] = stats.nanValueCount.value();
+    }
+    if (stats.lowerBound.has_value()) {
+      lowerBounds[fieldIdStr] = stats.lowerBound.value();
+    }
+    if (stats.upperBound.has_value()) {
+      upperBounds[fieldIdStr] = stats.upperBound.value();
+    }
+  }
+
+  json["columnSizes"] = std::move(columnSizes);
+  json["valueCounts"] = std::move(valueCounts);
+  json["nullValueCounts"] = std::move(nullValueCounts);
+  json["nanValueCounts"] = std::move(nanValueCounts);
+  json["lowerBounds"] = std::move(lowerBounds);
+  json["upperBounds"] = std::move(upperBounds);
+
+  return json;
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergDataFileStatistics.h b/velox/connectors/hive/iceberg/IcebergDataFileStatistics.h
new file mode 100644
index 00000000000..5bcfb84b83f
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergDataFileStatistics.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <optional>
+#include <string>
+
+#include <folly/container/F14Map.h>
+#include <folly/json/dynamic.h>
+
+namespace facebook::velox::connector::hive::iceberg {
+
+/// Statistics for an Iceberg data file, corresponding to the `data_file`
+/// structure defined in the Iceberg specification:
+/// https://iceberg.apache.org/spec/#data-file-fields.
+///
+/// All column-level statistics maps are keyed by Iceberg field IDs (`int32_t`),
+/// which uniquely identify columns in the Iceberg schema independent of column
+/// names or physical column positions.
+struct IcebergDataFileStatistics {
+  struct ColumnStats {
+    int64_t columnSize{0};
+
+    /// Total number of values for this field ID in the file, including null and
+    /// NaN values.
+    ///
+    /// For primitive (flat) columns, this is equal to the number of rows in the
+    /// file: numRows = valueCount = (nonNullValues + numNulls + numNaNs).
+    ///
+    /// For nested columns (e.g. elements inside an array), this represents the
+    /// total occurrences of the field across all rows, which is not necessarily
+    /// related to the top-level record count.
+    int64_t valueCount{0};
+    int64_t nullValueCount{0};
+    std::optional<int64_t> nanValueCount;
+    /// Base64 encoded lower bound.
+    std::optional<std::string> lowerBound;
+    /// Base64 encoded upper bound.
+    std::optional<std::string> upperBound;
+  };
+
+  int64_t numRecords{0};
+  folly::F14FastMap<int32_t, ColumnStats> columnStats;
+
+  /// Returns a IcebergDataFileStatistics with all values set to zero/empty.
+  /// Useful for empty data files that have no actual data.
+  static IcebergDataFileStatistics empty() {
+    return IcebergDataFileStatistics{.numRecords = 0, .columnStats = {}};
+  }
+
+  folly::dynamic toJson() const;
+};
+
+using IcebergDataFileStatisticsPtr = std::shared_ptr<IcebergDataFileStatistics>;
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergDataSink.cpp b/velox/connectors/hive/iceberg/IcebergDataSink.cpp
new file mode 100644
index 00000000000..f7eb3e39f5c
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergDataSink.cpp
@@ -0,0 +1,545 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/IcebergDataSink.h"
+
+#include <boost/lexical_cast.hpp>
+#include <boost/uuid/uuid_generators.hpp>
+#include <boost/uuid/uuid_io.hpp>
+#include <folly/json.h>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "velox/common/base/Fs.h"
+#include "velox/common/encode/Base64.h"
+#include "velox/common/memory/MemoryArbitrator.h"
+#include "velox/common/testutil/TestValue.h"
+#include "velox/connectors/hive/PartitionIdGenerator.h"
+#include "velox/connectors/hive/iceberg/IcebergColumnHandle.h"
+
+#ifdef VELOX_ENABLE_PARQUET
+#include "velox/connectors/hive/iceberg/IcebergParquetStatsCollector.h"
+#include "velox/dwio/parquet/writer/Writer.h"
+#endif
+
+#include "velox/connectors/hive/iceberg/TransformExprBuilder.h"
+#include "velox/connectors/hive/iceberg/WriterOptionsAdapter.h"
+#include "velox/dwio/dwrf/writer/Writer.h"
+#include "velox/exec/OperatorUtils.h"
+#include "velox/type/Type.h"
+
+using facebook::velox::common::testutil::TestValue;
+
+namespace facebook::velox::connector::hive::iceberg {
+
+namespace {
+
+template <TypeKind Kind>
+folly::dynamic extractPartitionValue(
+    const VectorPtr& child,
+    vector_size_t row) {
+  using T = typename TypeTraits<Kind>::NativeType;
+  return child->asChecked<SimpleVector<T>>()->valueAt(row);
+}
+
+template <>
+folly::dynamic extractPartitionValue<TypeKind::VARCHAR>(
+    const VectorPtr& child,
+    vector_size_t row) {
+  return child->asChecked<SimpleVector<StringView>>()->valueAt(row).str();
+}
+
+template <>
+folly::dynamic extractPartitionValue<TypeKind::VARBINARY>(
+    const VectorPtr& child,
+    vector_size_t row) {
+  return encoding::Base64::encode(
+      child->asChecked<SimpleVector<StringView>>()->valueAt(row));
+}
+
+template <>
+folly::dynamic extractPartitionValue<TypeKind::TIMESTAMP>(
+    const VectorPtr& child,
+    vector_size_t row) {
+  return child->asChecked<SimpleVector<Timestamp>>()->valueAt(row).toMicros();
+}
+
+class IcebergFileNameGenerator : public FileNameGenerator {
+ public:
+  std::pair<std::string, std::string> gen(
+      std::optional<uint32_t> bucketId,
+      const std::shared_ptr<const HiveInsertTableHandle> insertTableHandle,
+      const ConnectorQueryCtx& connectorQueryCtx,
+      bool commitRequired) const override;
+
+  folly::dynamic serialize() const override;
+
+  std::string toString() const override;
+};
+
+std::string makeUuid() {
+  return boost::lexical_cast<std::string>(boost::uuids::random_generator()());
+}
+
+std::pair<std::string, std::string> IcebergFileNameGenerator::gen(
+    std::optional<uint32_t> bucketId,
+    const std::shared_ptr<const HiveInsertTableHandle> insertTableHandle,
+    const ConnectorQueryCtx& connectorQueryCtx,
+    bool commitRequired) const {
+  auto targetFileName = insertTableHandle->locationHandle()->targetFileName();
+  if (targetFileName.empty()) {
+    targetFileName = fmt::format("{}", makeUuid());
+  }
+  auto fileFormat = dwio::common::toString(insertTableHandle->storageFormat());
+  auto fileName = fmt::format("{}.{}", targetFileName, fileFormat);
+  return {fileName, fileName};
+}
+
+folly::dynamic IcebergFileNameGenerator::serialize() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["name"] = "IcebergFileNameGenerator";
+  return obj;
+}
+
+std::string IcebergFileNameGenerator::toString() const {
+  return "IcebergFileNameGenerator";
+}
+
+} // namespace
+
+IcebergInsertTableHandle::IcebergInsertTableHandle(
+    std::vector<IcebergColumnHandlePtr> inputColumns,
+    LocationHandlePtr locationHandle,
+    dwio::common::FileFormat tableStorageFormat,
+    IcebergPartitionSpecPtr partitionSpec,
+    std::optional<common::CompressionKind> compressionKind,
+    const std::unordered_map<std::string, std::string>& serdeParameters)
+    : HiveInsertTableHandle(
+          std::vector<HiveColumnHandlePtr>(
+              inputColumns.begin(),
+              inputColumns.end()),
+          std::move(locationHandle),
+          tableStorageFormat,
+          nullptr,
+          compressionKind,
+          serdeParameters,
+          nullptr,
+          false,
+          std::make_shared<const HiveInsertFileNameGenerator>()),
+      partitionSpec_(partitionSpec) {
+  VELOX_USER_CHECK(
+      !inputColumns_.empty(),
+      "Input columns cannot be empty for Iceberg tables.");
+  VELOX_USER_CHECK_NOT_NULL(
+      locationHandle_, "Location handle is required for Iceberg tables.");
+  VELOX_USER_CHECK(
+      isSupportedFileFormat(tableStorageFormat),
+      "Unsupported file format for writing Iceberg tables: {}",
+      dwio::common::toString(tableStorageFormat));
+}
+
+namespace {
+
+// Creates partition channels by mapping partition spec fields to input column
+// indices. For each field in the partition spec, finds the corresponding
+// partition key column in the input columns and records its index.
+//
+// @param inputColumns The input columns from the insert table handle.
+// @param partitionSpec The Iceberg partition specification, or nullptr if
+// unpartitioned.
+// @return A vector of column indices representing the partition channels. Each
+// index corresponds to a partition field in the spec and points to the
+// matching partition key column in the input. Returns an empty vector if
+// partitionSpec is nullptr.
+std::vector<column_index_t> createPartitionChannels(
+    const std::vector<HiveColumnHandlePtr>& inputColumns,
+    const IcebergPartitionSpecPtr& partitionSpec) {
+  std::vector<column_index_t> channels;
+  if (!partitionSpec) {
+    return channels;
+  }
+
+  // Build a map from partition key column names to their indices in the input.
+  std::unordered_map<std::string, column_index_t> partitionKeyMap;
+  for (auto i = 0; i < inputColumns.size(); ++i) {
+    if (inputColumns[i]->isPartitionKey()) {
+      partitionKeyMap[inputColumns[i]->name()] = i;
+    }
+  }
+
+  // For each field in the partition spec, find its corresponding input column
+  // index.
+  channels.reserve(partitionSpec->fields.size());
+  for (const auto& field : partitionSpec->fields) {
+    if (auto it = partitionKeyMap.find(field.name);
+        it != partitionKeyMap.end()) {
+      channels.push_back(it->second);
+    }
+  }
+
+  return channels;
+}
+
+std::vector<column_index_t> createDataChannels(
+    const IcebergInsertTableHandlePtr& insertTableHandle) {
+  std::vector<column_index_t> dataChannels(
+      insertTableHandle->inputColumns().size());
+  std::iota(dataChannels.begin(), dataChannels.end(), 0);
+  return dataChannels;
+}
+
+// Creates a RowType schema for transformed partition values based on the
+// partition specification. This RowType is used to wrap the transformed
+// partition columns before passing them to the partition ID generator.
+//
+// For each partition field in the spec:
+// - The column type is the result type of the partition transform (e.g.,
+//   INTEGER for year transform, DATE for day transform).
+// - The column name is the source column name for identity transforms, or
+//   "columnName_transformName" for non-identity transforms (e.g., "birth_year"
+//   for a year transform on a birth column).
+//
+// @param partitionSpec The Iceberg partition specification, or nullptr if
+// unpartitioned.
+// @return A RowType containing one column per partition field with appropriate
+// names and types. Returns nullptr if partitionSpec is nullptr.
+RowTypePtr createPartitionRowType(
+    const IcebergPartitionSpecPtr& partitionSpec) {
+  if (!partitionSpec) {
+    return nullptr;
+  }
+
+  std::vector<TypePtr> partitionKeyTypes;
+  std::vector<std::string> partitionKeyNames;
+
+  // Build column names and types for each partition field.
+  // Identity transforms use the source column name directly.
+  // Non-identity transforms use "columnName_transformName" format.
+  for (const auto& field : partitionSpec->fields) {
+    partitionKeyTypes.emplace_back(field.resultType());
+    std::string key = field.transformType == TransformType::kIdentity
+        ? field.name
+        : fmt::format(
+              "{}_{}",
+              field.name,
+              TransformTypeName::toName(field.transformType));
+    partitionKeyNames.emplace_back(std::move(key));
+  }
+
+  return ROW(std::move(partitionKeyNames), std::move(partitionKeyTypes));
+}
+
+} // namespace
+
+IcebergDataSink::IcebergDataSink(
+    RowTypePtr inputType,
+    IcebergInsertTableHandlePtr insertTableHandle,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    CommitStrategy commitStrategy,
+    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const IcebergConfigPtr& icebergConfig)
+    : IcebergDataSink(
+          std::move(inputType),
+          insertTableHandle,
+          connectorQueryCtx,
+          commitStrategy,
+          hiveConfig,
+          createPartitionChannels(
+              insertTableHandle->inputColumns(),
+              insertTableHandle->partitionSpec()),
+          createDataChannels(insertTableHandle),
+          createPartitionRowType(insertTableHandle->partitionSpec()),
+          icebergConfig) {}
+
+IcebergDataSink::IcebergDataSink(
+    RowTypePtr inputType,
+    IcebergInsertTableHandlePtr insertTableHandle,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    CommitStrategy commitStrategy,
+    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const std::vector<column_index_t>& partitionChannels,
+    const std::vector<column_index_t>& dataChannels,
+    RowTypePtr partitionRowType,
+    const IcebergConfigPtr& icebergConfig)
+    : HiveDataSink(
+          inputType,
+          insertTableHandle,
+          connectorQueryCtx,
+          commitStrategy,
+          hiveConfig,
+          0,
+          nullptr,
+          partitionChannels,
+          dataChannels,
+          !partitionChannels.empty()
+              ? std::make_unique<PartitionIdGenerator>(
+                    partitionRowType,
+                    [&partitionChannels]() {
+                      std::vector<column_index_t> transformedChannels(
+                          partitionChannels.size());
+                      std::iota(
+                          transformedChannels.begin(),
+                          transformedChannels.end(),
+                          0);
+                      return transformedChannels;
+                    }(),
+                    hiveConfig->maxPartitionsPerWriters(
+                        connectorQueryCtx->sessionProperties()),
+                    connectorQueryCtx->memoryPool())
+              : nullptr),
+      partitionSpec_(insertTableHandle->partitionSpec()),
+      transformEvaluator_(
+          !partitionChannels.empty() ? std::make_unique<TransformEvaluator>(
+                                           TransformExprBuilder::toExpressions(
+                                               partitionSpec_,
+                                               partitionChannels_,
+                                               inputType_,
+                                               icebergConfig->functionPrefix()),
+                                           connectorQueryCtx_)
+                                     : nullptr),
+      icebergPartitionName_(
+          partitionSpec_ != nullptr
+              ? std::make_unique<IcebergPartitionName>(partitionSpec_)
+              : nullptr),
+      partitionRowType_(std::move(partitionRowType)),
+      icebergInsertTableHandle_(insertTableHandle) {
+  commitPartitionValue_.resize(maxOpenWriters_);
+
+#ifdef VELOX_ENABLE_PARQUET
+  // Only initialize Parquet stats collector for Parquet format tables
+  if (insertTableHandle->storageFormat() == dwio::common::FileFormat::PARQUET) {
+    std::vector<IcebergColumnHandlePtr> columnHandles;
+    columnHandles.reserve(insertTableHandle->inputColumns().size());
+    for (auto& column : insertTableHandle->inputColumns()) {
+      columnHandles.emplace_back(
+          checkedPointerCast<const IcebergColumnHandle>(column));
+    }
+    parquetStatsCollector_ = std::make_shared<IcebergParquetStatsCollector>(
+        std::move(columnHandles));
+  }
+#endif
+}
+
+std::vector<std::string> IcebergDataSink::commitMessage() const {
+  std::vector<std::string> commitTasks;
+  commitTasks.reserve(writerInfo_.size());
+
+  for (auto i = 0; i < writerInfo_.size(); ++i) {
+    const auto& writerInfo = writerInfo_.at(i);
+    VELOX_CHECK_NOT_NULL(writerInfo);
+
+    // Following metadata (json format) is consumed by Presto CommitTaskData.
+    // It contains the minimal subset of metadata.
+    VELOX_CHECK_EQ(writerInfo->writtenFiles.size(), dataFileStats_[i].size());
+    for (auto fileIdx = 0; fileIdx < writerInfo->writtenFiles.size();
+         ++fileIdx) {
+      const auto& fileInfo = writerInfo->writtenFiles[fileIdx];
+      // clang-format off
+      folly::dynamic commitData = folly::dynamic::object(
+        "path", (fs::path(writerInfo->writerParameters.targetDirectory()) /
+                      fileInfo.targetFileName).string())
+        ("fileSizeInBytes", fileInfo.fileSize)
+        ("metrics", dataFileStats_[i][fileIdx]->toJson())
+        ("partitionSpecJson",
+          icebergInsertTableHandle_->partitionSpec() ?
+            icebergInsertTableHandle_->partitionSpec()->specId : 0)
+        // Sort order evolution is not supported. Set default id to 0 ( unsorted order).
+        ("sortOrderId", 0)
+        ("fileFormat", toManifestFormatString(icebergInsertTableHandle_->storageFormat()))
+        ("content", "DATA");
+      // clang-format on
+      if (!commitPartitionValue_.empty() &&
+          !commitPartitionValue_[i].isNull()) {
+        commitData["partitionDataJson"] = folly::toJson(
+            folly::dynamic::object(
+                "partitionValues", commitPartitionValue_[i]));
+      }
+      auto commitDataJson = folly::toJson(commitData);
+      commitTasks.push_back(commitDataJson);
+    }
+  }
+  return commitTasks;
+}
+
+void IcebergDataSink::computePartitionAndBucketIds(const RowVectorPtr& input) {
+  VELOX_CHECK(isPartitioned());
+  VELOX_CHECK_NOT_NULL(transformEvaluator_);
+  VELOX_CHECK_NOT_NULL(partitionIdGenerator_);
+  // Step 1: Apply transforms to input partition columns.
+  auto transformedColumns = transformEvaluator_->evaluate(input);
+
+  // Step 2: Create RowVector based on transformed columns.
+  const auto& transformedRowVector = std::make_shared<RowVector>(
+      connectorQueryCtx_->memoryPool(),
+      partitionRowType_,
+      nullptr,
+      input->size(),
+      std::move(transformedColumns));
+  partitionIdGenerator_->run(transformedRowVector, partitionIds_);
+}
+
+std::string IcebergDataSink::getPartitionName(uint32_t partitionId) const {
+  VELOX_CHECK_NOT_NULL(icebergPartitionName_);
+
+  return icebergPartitionName_->partitionName(
+      partitionId,
+      partitionIdGenerator_->partitionValues(),
+      partitionKeyAsLowerCase_);
+}
+
+uint32_t IcebergDataSink::ensureWriter(const WriterId& id) {
+  auto writerId = HiveDataSink::ensureWriter(id);
+  if (isPartitioned() && commitPartitionValue_[writerId].isNull()) {
+    commitPartitionValue_[writerId] = makeCommitPartitionValue(writerId);
+  }
+  return writerId;
+}
+
+std::shared_ptr<dwio::common::WriterOptions>
+IcebergDataSink::createWriterOptions(size_t writerIndex) const {
+  auto options = HiveDataSink::createWriterOptions(writerIndex);
+
+  // Dispatch format-specific Iceberg overrides through the adapter so each
+  // supported format (Parquet, DWRF, Nimble) gets its pre/post-processConfigs
+  // hooks applied uniformly.
+  const auto adapter =
+      createWriterOptionsAdapter(icebergInsertTableHandle_->storageFormat());
+  if (adapter != nullptr) {
+    adapter->applyPreConfigs(*options);
+  }
+
+#ifdef VELOX_ENABLE_PARQUET
+  // Iceberg-runtime stats collector is not a static config; wire it inline.
+  if (auto parquetOptions =
+          std::dynamic_pointer_cast<parquet::WriterOptions>(options)) {
+    if (parquetStatsCollector_) {
+      parquetOptions->parquetFieldIds =
+          parquetStatsCollector_->parquetFieldIds().children;
+    }
+  }
+#endif
+
+  options->processConfigs(
+      *hiveConfig_->config(), *connectorQueryCtx_->sessionProperties());
+
+  if (adapter != nullptr) {
+    adapter->applyPostConfigs(*options);
+  }
+
+  return options;
+}
+
+folly::dynamic IcebergDataSink::makeCommitPartitionValue(
+    uint32_t writerIndex) const {
+  folly::dynamic partitionValues = folly::dynamic::array();
+  const auto& transformedValues = partitionIdGenerator_->partitionValues();
+  for (auto i = 0; i < partitionChannels_.size(); ++i) {
+    const auto& child = transformedValues->childAt(i);
+    if (child->isNullAt(writerIndex)) {
+      partitionValues.push_back(nullptr);
+    } else {
+      partitionValues.push_back(VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+          extractPartitionValue, child->typeKind(), child, writerIndex));
+    }
+  }
+  return partitionValues;
+}
+
+void IcebergDataSink::closeWriterAndCollectStats(size_t index) {
+  auto metadata = writers_[index]->close();
+  const bool fileAdded = getCurrentFileBytes(index) > 0;
+
+  // Finalize file info (capture file size, add to writtenFiles).
+  finalizeWriterFile(index);
+
+  if (!fileAdded) {
+    return;
+  }
+#ifdef VELOX_ENABLE_PARQUET
+  if (parquetStatsCollector_) {
+    dataFileStats_[index].emplace_back(
+        parquetStatsCollector_->aggregate(std::move(metadata)));
+    return;
+  }
+#endif
+  dataFileStats_[index].emplace_back(
+      std::make_shared<IcebergDataFileStatistics>(
+          IcebergDataFileStatistics::empty()));
+}
+
+void IcebergDataSink::rotateWriter(size_t index) {
+  VELOX_CHECK_LT(index, writers_.size());
+  VELOX_CHECK_NOT_NULL(writers_[index]);
+
+  // Ensure dataFileStats_ has an entry for this writer index.
+  if (dataFileStats_.size() <= index) {
+    dataFileStats_.resize(index + 1);
+  }
+
+  // Close the writer to flush the footer and obtain file metadata, then
+  // aggregate Iceberg stats from the metadata. The base rotateWriter() would
+  // also call writers_[index]->close() but discards the returned metadata.
+  // We close the writer ourselves to capture the metadata, then reset the
+  // writer to prevent double close.
+  {
+    const memory::NonReclaimableSectionGuard nonReclaimableGuard(
+        writerInfo_[index]->nonReclaimableSectionHolder.get());
+    closeWriterAndCollectStats(index);
+  }
+
+  // Release old writer. The new writer will be created lazily on the next
+  // write call.
+  writers_[index].reset();
+
+  ++writerInfo_[index]->fileSequenceNumber;
+}
+
+void IcebergDataSink::closeInternal() {
+  VELOX_CHECK_NE(state_, State::kRunning);
+  VELOX_CHECK_NE(state_, State::kFinishing);
+
+  TestValue::adjust(
+      "facebook::velox::connector::hive::FileDataSink::closeInternal", this);
+
+  if (state_ == State::kClosed) {
+    // Ensure dataFileStats_ has entries for all writers.
+    dataFileStats_.resize(writers_.size());
+
+    for (auto i = 0; i < writers_.size(); ++i) {
+      if (writers_[i] == nullptr) {
+        // Writer was rotated and is null. Stats for rotated files were already
+        // collected in rotateWriter(). No final file to close.
+        continue;
+      }
+      const memory::NonReclaimableSectionGuard nonReclaimableGuard(
+          writerInfo_[i]->nonReclaimableSectionHolder.get());
+      closeWriterAndCollectStats(i);
+    }
+  } else {
+    for (auto i = 0; i < writers_.size(); ++i) {
+      if (writers_[i] == nullptr) {
+        continue;
+      }
+      memory::NonReclaimableSectionGuard nonReclaimableGuard(
+          writerInfo_[i]->nonReclaimableSectionHolder.get());
+      writers_[i]->abort();
+    }
+  }
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergDataSink.h b/velox/connectors/hive/iceberg/IcebergDataSink.h
new file mode 100644
index 00000000000..8d4ee101a27
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergDataSink.h
@@ -0,0 +1,261 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "velox/connectors/hive/HiveDataSink.h"
+#include "velox/connectors/hive/TableHandle.h"
+#include "velox/connectors/hive/iceberg/IcebergColumnHandle.h"
+#include "velox/connectors/hive/iceberg/IcebergDataFileStatistics.h"
+
+#ifdef VELOX_ENABLE_PARQUET
+#include "velox/connectors/hive/iceberg/IcebergParquetStatsCollector.h"
+#endif
+
+#include "velox/connectors/hive/iceberg/IcebergConfig.h"
+#include "velox/connectors/hive/iceberg/IcebergPartitionName.h"
+#include "velox/connectors/hive/iceberg/PartitionSpec.h"
+#include "velox/connectors/hive/iceberg/TransformEvaluator.h"
+#include "velox/functions/iceberg/Register.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+/// Represents a request for Iceberg write.
+class IcebergInsertTableHandle final : public HiveInsertTableHandle {
+ public:
+  /// @param inputColumns Columns from the table schema to write.
+  /// The input RowVector must have the same number of columns and matching
+  /// types in the same order.
+  /// Column names in the RowVector may differ from those in inputColumns,
+  /// only position and type must align. All columns present in the input
+  /// data must be included, mismatches can lead to write failure.
+  /// @param locationHandle Contains the target location information including:
+  /// - Base directory path where data files will be written.
+  /// - File naming scheme and temporary directory paths.
+  /// @param tableStorageFormat File format to use for writing data files.
+  /// @param partitionSpec Optional partition specification defining how to
+  /// partition the data. If nullptr, the table is unpartitioned and all data
+  /// is written to a single directory.
+  /// @param compressionKind Optional compression to apply to data files.
+  /// @param serdeParameters Additional serialization/deserialization parameters
+  /// for the file format.
+  IcebergInsertTableHandle(
+      std::vector<IcebergColumnHandlePtr> inputColumns,
+      LocationHandlePtr locationHandle,
+      dwio::common::FileFormat tableStorageFormat,
+      IcebergPartitionSpecPtr partitionSpec,
+      std::optional<common::CompressionKind> compressionKind = {},
+      const std::unordered_map<std::string, std::string>& serdeParameters = {});
+
+  /// Returns the Iceberg partition specification that defines how the table
+  /// is partitioned.
+  const IcebergPartitionSpecPtr& partitionSpec() const {
+    return partitionSpec_;
+  }
+
+ private:
+  const IcebergPartitionSpecPtr partitionSpec_;
+};
+
+using IcebergInsertTableHandlePtr =
+    std::shared_ptr<const IcebergInsertTableHandle>;
+
+class IcebergDataSink : public HiveDataSink {
+ public:
+  IcebergDataSink(
+      RowTypePtr inputType,
+      IcebergInsertTableHandlePtr insertTableHandle,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      CommitStrategy commitStrategy,
+      const std::shared_ptr<const HiveConfig>& hiveConfig,
+      const IcebergConfigPtr& icebergConfig);
+
+  /// Generates Iceberg-specific commit messages for all writers containing
+  /// metadata about written files. Creates a JSON object for each writer
+  /// in the format expected by Presto and Spark for Iceberg tables.
+  ///
+  /// Each commit message contains:
+  /// - path: full file path where data was written.
+  /// - fileSizeInBytes: raw bytes written to disk.
+  /// - metrics: object with recordCount (number of rows written).
+  /// - partitionSpecJson: partition specification.
+  /// - fileFormat: storage format. Either "PARQUET" or "ORC". DWRF files
+  ///   are reported as "ORC" because Iceberg's file-format vocabulary has
+  ///   no DWRF enum.
+  /// - content: file content type ("DATA" for data files).
+  ///
+  /// See
+  /// https://github.com/prestodb/presto/blob/master/presto-iceberg/src/main/java/com/facebook/presto/iceberg/CommitTaskData.java
+  ///
+  /// Note: Complete Iceberg metrics are not yet implemented, which results in
+  /// incomplete manifest files that may lead to suboptimal query planning.
+  ///
+  /// @return Vector of JSON strings, one per writer, formatted according to
+  /// Presto and Spark Iceberg commit protocol.
+  std::vector<std::string> commitMessage() const override;
+
+ private:
+  IcebergDataSink(
+      RowTypePtr inputType,
+      IcebergInsertTableHandlePtr insertTableHandle,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      CommitStrategy commitStrategy,
+      const std::shared_ptr<const HiveConfig>& hiveConfig,
+      const std::vector<column_index_t>& partitionChannels,
+      const std::vector<column_index_t>& dataChannels,
+      RowTypePtr partitionRowType,
+      const IcebergConfigPtr& icebergConfig);
+
+  // Computes partition IDs for each row in the input batch by applying Iceberg
+  // partition transforms and generating unique partition identifiers.
+  //
+  // Performs a two-step process:
+  // 1. Applies Iceberg partition transforms (e.g., year, month, day, hour,
+  //    bucket, truncate) to the input partition columns using
+  //    transformEvaluator_ to produce transformed partition values.
+  // 2. Wraps the transformed columns in a RowVector with partitionRowType_
+  //    schema and passes it to partitionIdGenerator_ to compute partition IDs.
+  //
+  // The resulting partition IDs are stored in partitionIds_ buffer, where each
+  // element corresponds to a row in the input. These IDs are used to:
+  // - Route rows to the appropriate writer (one writer per unique partition).
+  // - Generate partition directory names via getPartitionName().
+  //
+  // Note: Iceberg does not support bucketing, so this method only computes
+  // partition IDs, not bucket IDs.
+  //
+  // @param input The input RowVector containing rows to be partitioned.
+  void computePartitionAndBucketIds(const RowVectorPtr& input) override;
+
+  // Returns the Iceberg partition directory name for the given partition ID.
+  // Converts the transformed partition values associated with the partition ID
+  // into an Iceberg compliant directory path
+  // (e.g., "date_year=2023/id_bucket=5").
+  std::string getPartitionName(uint32_t partitionId) const override;
+
+  // Ensures a writer exists for the given writer ID and returns its index.
+  // If the writer doesn't exist, creates it by calling appendWriter().
+  // Additionally, extracts and stores the transformed partition values for
+  // the writer in commitPartitionValue_ if not already set, which will be
+  // included in the commit message as "partitionDataJson".
+  uint32_t ensureWriter(const WriterId& id) override;
+
+  // Creates writer options configured for Iceberg table writes. Extends the
+  // base HiveDataSink writer options with Iceberg-specific settings:
+  // - Sets timestamp timezone to nullopt (UTC) for Iceberg compliance.
+  // - Sets timestamp precision to microseconds.
+  std::shared_ptr<dwio::common::WriterOptions> createWriterOptions(
+      size_t writerIndex) const override;
+
+  // Extracts partition values for a specific writer to be included in the
+  // commit message. Converts the transformed partition values from columnar
+  // storage (partitionIdGenerator_->partitionValues() where each partition
+  // field is a separate column) to row storage (a folly::dynamic array of
+  // values for the given writer index) for JSON serialization.
+  // Returns nullptr for null partition values.
+  folly::dynamic makeCommitPartitionValue(uint32_t writerIndex) const;
+
+  // Closes the active writer at 'index' to flush its file footer, captures
+  // the file metadata for Iceberg stats aggregation (via
+  // closeWriterAndCollectStats), then resets the writer so a new one is
+  // created lazily on the next write. Differs from the base
+  // FileDataSink::rotateWriter by also collecting per-file Iceberg stats
+  // before discarding the writer.
+  void rotateWriter(size_t index) override;
+
+  // Closes all remaining writers and aggregates their file metadata into
+  // per-writer Iceberg stats (when state == kClosed). On any other state,
+  // aborts the writers without collecting stats. Stats for already-rotated
+  // files were collected during rotateWriter().
+  void closeInternal() override;
+
+  // Closes the writer at 'index', captures the resulting file metadata, and
+  // appends a per-file IcebergDataFileStatistics entry to dataFileStats_
+  // (Parquet stats when the format provides them; an empty entry otherwise).
+  // Caller is responsible for the surrounding NonReclaimableSectionGuard.
+  void closeWriterAndCollectStats(size_t index);
+
+  // Iceberg partition specification defining how the table is partitioned.
+  // Contains partition fields with source column names, transform types
+  // (e.g., identity, year, month, day, hour, bucket, truncate), transform
+  // parameters, and result types. Null if the table is unpartitioned.
+  const IcebergPartitionSpecPtr partitionSpec_;
+
+  // Evaluates Iceberg partition transforms on input rows to produce transformed
+  // partition keys. Applies transforms defined in partitionSpec_ (e.g.,
+  // year(date_col), bucket(id, 16)) to the corresponding input columns and
+  // returns a vector of transformed columns. The transformed keys are then
+  // wrapped in a RowVector and passed to IcebergPartitionIdGenerator.
+  // Null if the table is unpartitioned.
+  const std::unique_ptr<TransformEvaluator> transformEvaluator_;
+
+  // Generates Iceberg compliant partition directory names from partition IDs.
+  // Converts transformed partition values to human-readable strings based on
+  // their transform types (e.g., year -> "2025", month -> "2025-11", hour ->
+  // "2025-11-12-13") and constructs URL-encoded partition paths.
+  // Null if the table is unpartitioned.
+  const std::unique_ptr<IcebergPartitionName> icebergPartitionName_;
+
+  // RowType schema for the transformed partition values RowVector.
+  // Contains one column per partition field in partitionSpec, where each
+  // column has:
+  // - Type: The result type of the partition transform (e.g., INTEGER for year
+  //   transform, DATE for day transform).
+  // - Name: Source column name for identity transforms, or
+  //   "columnName_transformName" for non-identity transforms (e.g.,
+  //   "date_year").
+  // Used to construct the RowVector that wraps the transformed partition
+  // columns before passing them to IcebergPartitionIdGenerator for partition ID
+  // generation and to IcebergPartitionNameGenerator for partition path name
+  // generation.
+  RowTypePtr partitionRowType_;
+
+  // Stores the transformed partition values for each writer to be included in
+  // the commit message sent to Presto. Indexed by writer index. Each entry
+  // contains the transformed partition values (as a folly::dynamic array) for
+  // that writer's partition, which are serialized to JSON as
+  // "partitionDataJson" in the commit protocol. These values represent the same
+  // transformed partition data as partitionIdGenerator_->partitionValues(), but
+  // converted from columnar storage (where each partition field is a separate
+  // column in the RowVector) to row storage (where each writer has a
+  // folly::dynamic array of values across all partition fields), ready for JSON
+  // serialization.
+  std::vector<folly::dynamic> commitPartitionValue_;
+
+  // Statistics for all data files written by this sink, organized by writer
+  // index and file index within each writer. These statistics are populated
+  // during rotateWriter() (for rotated files) and during closeInternal()
+  // (for the final file of each writer). These metrics are subsequently used
+  // to construct Iceberg commit messages.
+  // Outer vector: indexed by writer index (same as writerInfo_).
+  // Inner vector: one entry per file written by that writer (including
+  // rotated files and the final file). Each entry corresponds to one
+  // individual data file.
+  std::vector<std::vector<IcebergDataFileStatisticsPtr>> dataFileStats_;
+
+  const IcebergInsertTableHandlePtr icebergInsertTableHandle_;
+
+#ifdef VELOX_ENABLE_PARQUET
+  std::shared_ptr<IcebergParquetStatsCollector> parquetStatsCollector_;
+#endif
+};
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergDataSource.cpp b/velox/connectors/hive/iceberg/IcebergDataSource.cpp
new file mode 100644
index 00000000000..30fa219e9ab
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergDataSource.cpp
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/IcebergDataSource.h"
+
+#include "velox/connectors/hive/iceberg/IcebergSplit.h"
+#include "velox/connectors/hive/iceberg/IcebergSplitReader.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+IcebergDataSource::IcebergDataSource(
+    const RowTypePtr& outputType,
+    const ConnectorTableHandlePtr& tableHandle,
+    const ColumnHandleMap& assignments,
+    FileHandleFactory* fileHandleFactory,
+    folly::Executor* ioExecutor,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    const std::shared_ptr<HiveConfig>& hiveConfig)
+    : HiveDataSource(
+          outputType,
+          tableHandle,
+          assignments,
+          fileHandleFactory,
+          ioExecutor,
+          connectorQueryCtx,
+          hiveConfig),
+      columnHandles_(std::make_shared<ColumnHandleMap>(assignments)) {}
+
+std::unique_ptr<FileSplitReader> IcebergDataSource::createSplitReader() {
+  prepareSplit();
+  auto icebergSplit = checkedPointerCast<const HiveIcebergSplit>(split_);
+
+  auto reader = std::make_unique<IcebergSplitReader>(
+      icebergSplit,
+      tableHandle_,
+      &partitionKeys_,
+      connectorQueryCtx_,
+      fileConfig_,
+      readerOutputType_,
+      dataIoStats_,
+      metadataIoStats_,
+      ioStats_,
+      fileHandleFactory_,
+      ioExecutor_,
+      scanSpec_,
+      columnHandles_);
+
+  return reader;
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergDataSource.h b/velox/connectors/hive/iceberg/IcebergDataSource.h
new file mode 100644
index 00000000000..243ba61b043
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergDataSource.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/connectors/hive/HiveDataSource.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+/// Iceberg-specific data source that extends HiveDataSource.
+///
+/// Provides Iceberg table format support by creating
+/// IcebergSplitReader instances that handle:
+/// - Positional delete files for row-level deletes.
+/// - Schema evolution with column adaptation.
+/// - Iceberg-specific metadata columns.
+class IcebergDataSource : public HiveDataSource {
+ public:
+  IcebergDataSource(
+      const RowTypePtr& outputType,
+      const ConnectorTableHandlePtr& tableHandle,
+      const ColumnHandleMap& assignments,
+      FileHandleFactory* fileHandleFactory,
+      folly::Executor* ioExecutor,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      const std::shared_ptr<HiveConfig>& hiveConfig);
+
+ protected:
+  /// Creates an IcebergSplitReader for reading Iceberg data files.
+  ///
+  /// Unlike the base HiveDataSource which creates a generic FileSplitReader,
+  /// this method creates an IcebergSplitReader that handles Iceberg-specific
+  /// features like positional delete files and schema evolution.
+  std::unique_ptr<FileSplitReader> createSplitReader() override;
+
+ private:
+  /// Column handles map for accessing column metadata.
+  std::shared_ptr<ColumnHandleMap> columnHandles_;
+};
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergDeleteFile.h b/velox/connectors/hive/iceberg/IcebergDeleteFile.h
index 2f9206dfc26..a346fcccfef 100644
--- a/velox/connectors/hive/iceberg/IcebergDeleteFile.h
+++ b/velox/connectors/hive/iceberg/IcebergDeleteFile.h
@@ -27,6 +27,12 @@ enum class FileContent {
   kData,
   kPositionalDeletes,
   kEqualityDeletes,
+  /// Iceberg V3 deletion vector. A serialized roaring bitmap of deleted row
+  /// positions stored as a blob inside a Puffin file. More compact than V2
+  /// positional delete files and avoids sorted merge of multiple delete files.
+  /// The coordinator extracts the blob offset and length from the Puffin
+  /// footer and provides them via IcebergDeleteFile fields.
+  kDeletionVector,
 };
 
 struct IcebergDeleteFile {
@@ -47,6 +53,28 @@ struct IcebergDeleteFile {
   // 1 is in range [10, 50], then upperBounds will contain entry <1, "50">
   std::unordered_map<int32_t, std::string> upperBounds;
 
+  /// Data sequence number of this delete file, assigned by the Iceberg snapshot
+  /// that produced it. Per the Iceberg spec (V2+), an equality delete file must
+  /// only be applied to data files whose data sequence number is strictly less
+  /// than the delete file's data sequence number. A value of 0 means
+  /// "unassigned" (legacy V1 tables) and disables sequence number filtering.
+  int64_t dataSequenceNumber{0};
+
+  /// Byte offset of the deletion-vector blob inside the Puffin file pointed to
+  /// by 'filePath'. Only meaningful for kDeletionVector content. A value of 0
+  /// is allowed (and is the default for non-DV files).
+  int64_t contentOffset{0};
+
+  /// Length in bytes of the deletion-vector blob inside the Puffin file pointed
+  /// to by 'filePath'. Only meaningful for kDeletionVector content. A value of
+  /// 0 means the consumer should fall back to reading until end-of-file.
+  int64_t contentLength{0};
+
+  /// For kDeletionVector content: path of the data file this DV applies to.
+  /// When set (non-empty), the reader can skip this DV for any other data file
+  /// as a belt-and-suspenders pruning step. Empty string disables the filter.
+  std::string referencedDataFile{};
+
   IcebergDeleteFile(
       FileContent _content,
       const std::string& _filePath,
@@ -55,7 +83,11 @@ struct IcebergDeleteFile {
       uint64_t _fileSizeInBytes,
       std::vector<int32_t> _equalityFieldIds = {},
       std::unordered_map<int32_t, std::string> _lowerBounds = {},
-      std::unordered_map<int32_t, std::string> _upperBounds = {})
+      std::unordered_map<int32_t, std::string> _upperBounds = {},
+      int64_t _dataSequenceNumber = 0,
+      int64_t _contentOffset = 0,
+      int64_t _contentLength = 0,
+      std::string _referencedDataFile = {})
       : content(_content),
         filePath(_filePath),
         fileFormat(_fileFormat),
@@ -63,7 +95,11 @@ struct IcebergDeleteFile {
         fileSizeInBytes(_fileSizeInBytes),
         equalityFieldIds(_equalityFieldIds),
         lowerBounds(_lowerBounds),
-        upperBounds(_upperBounds) {}
+        upperBounds(_upperBounds),
+        dataSequenceNumber(_dataSequenceNumber),
+        contentOffset(_contentOffset),
+        contentLength(_contentLength),
+        referencedDataFile(std::move(_referencedDataFile)) {}
 };
 
 } // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergMetadataColumns.h b/velox/connectors/hive/iceberg/IcebergMetadataColumns.h
index 4cbf2a7862b..cacdb6009ec 100644
--- a/velox/connectors/hive/iceberg/IcebergMetadataColumns.h
+++ b/velox/connectors/hive/iceberg/IcebergMetadataColumns.h
@@ -28,6 +28,21 @@ struct IcebergMetadataColumn {
   std::shared_ptr<const Type> type;
   std::string doc;
 
+  // Reserved Field IDs for Iceberg tables; see
+  // https://iceberg.apache.org/spec/#reserved-field-ids
+  static constexpr int32_t kPosId = 2'147'483'545;
+  static constexpr int32_t kFilePathId = 2'147'483'546;
+  static constexpr int32_t kRowId = 2'147'483'540;
+  static constexpr int32_t kLastUpdatedSequenceNumber = 2'147'483'539;
+
+  static constexpr const char* kRowIdColumnName = "_row_id";
+  static constexpr const char* kLastUpdatedSequenceNumberColumnName =
+      "_last_updated_sequence_number";
+  // Info column keys provided in the split's infoColumns map.
+  static constexpr const char* kFirstRowIdInfoColumn = "$first_row_id";
+  static constexpr const char* kDataSequenceNumberInfoColumn =
+      "$data_sequence_number";
+
   IcebergMetadataColumn(
       int _id,
       const std::string& _name,
@@ -37,7 +52,7 @@ struct IcebergMetadataColumn {
 
   static std::shared_ptr<IcebergMetadataColumn> icebergDeleteFilePathColumn() {
     return std::make_shared<IcebergMetadataColumn>(
-        2147483546,
+        kFilePathId,
         "file_path",
         VARCHAR(),
         "Path of a file in which a deleted row is stored");
@@ -45,7 +60,7 @@ struct IcebergMetadataColumn {
 
   static std::shared_ptr<IcebergMetadataColumn> icebergDeletePosColumn() {
     return std::make_shared<IcebergMetadataColumn>(
-        2147483545,
+        kPosId,
         "pos",
         BIGINT(),
         "Ordinal position of a deleted row in the data file");
diff --git a/velox/connectors/hive/iceberg/IcebergParquetStatsCollector.cpp b/velox/connectors/hive/iceberg/IcebergParquetStatsCollector.cpp
new file mode 100644
index 00000000000..10b04574c0a
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergParquetStatsCollector.cpp
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/IcebergParquetStatsCollector.h"
+
+#include "velox/common/Casts.h"
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/encode/Base64.h"
+#include "velox/connectors/hive/iceberg/IcebergColumnHandle.h"
+#include "velox/connectors/hive/iceberg/IcebergDataFileStatistics.h"
+#include "velox/dwio/common/FileMetadata.h"
+#include "velox/dwio/parquet/writer/Writer.h"
+#include "velox/dwio/parquet/writer/arrow/Metadata.h"
+#include "velox/dwio/parquet/writer/arrow/Statistics.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+namespace {
+
+void addAllRecursive(
+    const parquet::ParquetFieldId& field,
+    const TypePtr& type,
+    std::unordered_set<int32_t>& fieldIds) {
+  fieldIds.insert(field.fieldId);
+
+  VELOX_CHECK_EQ(field.children.size(), type->size());
+  for (auto i = 0; i < type->size(); ++i) {
+    addAllRecursive(field.children[i], type->childAt(i), fieldIds);
+  }
+}
+
+// Recursively collects field IDs that should skip bounds collection.
+// Repeated fields (e.g. MAP and ARRAY) are not currently supported by Iceberg.
+// These fields, along with all their descendants, should skip bounds
+// collection.
+// @param field The Parquet field ID structure to process.
+// @param type The Velox type corresponding to this field.
+// @param fieldIds Output set to populate with field IDs to skip.
+void collectSkipBoundsFieldIds(
+    const parquet::ParquetFieldId& field,
+    const TypePtr& type,
+    std::unordered_set<int32_t>& fieldIds) {
+  VELOX_CHECK_NOT_NULL(type, "Input column type cannot be null.");
+
+  if (type->isMap() || type->isArray()) {
+    addAllRecursive(field, type, fieldIds);
+    return;
+  }
+
+  VELOX_CHECK_EQ(field.children.size(), type->size());
+  for (auto i = 0; i < type->size(); ++i) {
+    collectSkipBoundsFieldIds(field.children[i], type->childAt(i), fieldIds);
+  }
+}
+
+} // namespace
+
+IcebergParquetStatsCollector::IcebergParquetStatsCollector(
+    const std::vector<IcebergColumnHandlePtr>& inputColumns) {
+  parquetFieldIds_.children.reserve(inputColumns.size());
+  for (const auto& columnHandle : inputColumns) {
+    parquetFieldIds_.children.emplace_back(columnHandle->field());
+    collectSkipBoundsFieldIds(
+        columnHandle->field(), columnHandle->dataType(), skipBoundsFieldIds_);
+  }
+}
+
+IcebergDataFileStatisticsPtr IcebergParquetStatsCollector::aggregate(
+    std::unique_ptr<dwio::common::FileMetadata> fileMetadata) {
+  // Empty data file.
+  if (!fileMetadata) {
+    return std::make_shared<IcebergDataFileStatistics>(
+        IcebergDataFileStatistics::empty());
+  }
+
+  auto parquetMetadata =
+      checkedPointerCast<parquet::ParquetFileMetadata>(std::move(fileMetadata));
+  auto metadata = parquetMetadata->arrowMetadata();
+  auto dataFileStats = std::make_shared<IcebergDataFileStatistics>();
+  dataFileStats->numRecords = metadata->numRows();
+  const auto numRowGroups = metadata->numRowGroups();
+
+  // Track global min/max statistics for each column across all row groups.
+  // Key: Iceberg field ID.
+  // Value: A pair of Statistics objects where:
+  // - first: The statistics from the row group containing the global minimum
+  // value.
+  // - second: The statistics from the row group containing the global maximum
+  // value. Two separate objects are stored because the global minimum and
+  // global maximum for a single column may originate from different row groups.
+  folly::F14FastMap<
+      int32_t,
+      std::pair<
+          std::shared_ptr<parquet::arrow::Statistics>,
+          std::shared_ptr<parquet::arrow::Statistics>>>
+      globalMinMaxStats;
+
+  std::unordered_set<int32_t> fieldIds;
+  for (auto i = 0; i < numRowGroups; ++i) {
+    const auto& rowGroup = metadata->rowGroup(i);
+
+    for (auto j = 0; j < rowGroup->numColumns(); ++j) {
+      const auto& columnChunk = rowGroup->columnChunk(j);
+      const auto fieldId = columnChunk->fieldId();
+      fieldIds.insert(fieldId);
+
+      auto& stats = dataFileStats->columnStats[fieldId];
+      stats.valueCount += columnChunk->numValues();
+      stats.columnSize += columnChunk->totalCompressedSize();
+
+      const auto& columnChunkStats = columnChunk->statistics();
+      if (columnChunkStats) {
+        stats.nullValueCount += columnChunkStats->nullCount();
+
+        if (columnChunkStats->hasMinMax() && shouldStoreBounds(fieldId)) {
+          auto [it, inserted] = globalMinMaxStats.emplace(
+              fieldId, std::pair{columnChunkStats, columnChunkStats});
+
+          if (!inserted) {
+            auto& [minStats, maxStats] = it->second;
+
+            if (columnChunkStats->maxGreaterThan(*maxStats)) {
+              maxStats = columnChunkStats;
+            }
+            if (columnChunkStats->minLessThan(*minStats)) {
+              minStats = columnChunkStats;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  for (const auto fieldId : fieldIds) {
+    const auto& [nanCount, hasNanCount] = metadata->getNaNCount(fieldId);
+    if (hasNanCount) {
+      dataFileStats->columnStats[fieldId].nanValueCount = nanCount;
+    }
+  }
+
+  for (const auto& [fieldId, stats] : globalMinMaxStats) {
+    const auto& [minStats, maxStats] = stats;
+
+    auto& columnStats = dataFileStats->columnStats[fieldId];
+    const auto& lowerBound =
+        minStats->icebergLowerBoundInclusive(kDefaultTruncateLength);
+    columnStats.lowerBound =
+        encoding::Base64::encode(lowerBound.data(), lowerBound.size());
+
+    const auto upperBound =
+        maxStats->icebergUpperBoundExclusive(kDefaultTruncateLength);
+    if (upperBound.has_value()) {
+      columnStats.upperBound =
+          encoding::Base64::encode(upperBound->data(), upperBound->size());
+    }
+  }
+  return dataFileStats;
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergParquetStatsCollector.h b/velox/connectors/hive/iceberg/IcebergParquetStatsCollector.h
new file mode 100644
index 00000000000..8600f816d4d
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergParquetStatsCollector.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <unordered_set>
+
+#include "velox/connectors/hive/iceberg/IcebergColumnHandle.h"
+#include "velox/connectors/hive/iceberg/IcebergDataFileStatistics.h"
+#include "velox/dwio/common/FileMetadata.h"
+#include "velox/dwio/parquet/ParquetFieldId.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+/// Aggregates per-file Iceberg column statistics (column sizes, value counts,
+/// null/NaN counts, lower/upper bounds) from Parquet row group metadata
+/// produced by the Parquet writer. One instance is created per IcebergDataSink
+/// and reused across all writers; aggregate() is invoked after each Parquet
+/// file is closed. Also exposes the Parquet field IDs for the input columns
+/// so they can be threaded into the writer's column metadata.
+class IcebergParquetStatsCollector {
+ public:
+  explicit IcebergParquetStatsCollector(
+      const std::vector<IcebergColumnHandlePtr>& inputColumns);
+
+  /// Returns the Parquet field IDs for all input columns.
+  /// The field IDs are written to the Parquet data file's column metadata.
+  /// The return object describes a multi-column input.
+  const parquet::ParquetFieldId& parquetFieldIds() const {
+    return parquetFieldIds_;
+  }
+
+  /// Aggregates Parquet file metadata into Iceberg data file statistics.
+  /// Iterates through all row groups and columns to collect:
+  /// - Record count, split offsets, value counts, column sizes, null counts.
+  /// - Min/max bounds (base64-encoded). Currently not collected for MAP and
+  ///   ARRAY types and all their descendants.
+  /// @param fileMetadata The Parquet file metadata to aggregate.
+  IcebergDataFileStatisticsPtr aggregate(
+      std::unique_ptr<dwio::common::FileMetadata> fileMetadata);
+
+  /// TODO: Need to support this config property.
+  /// 16 is default value. See DEFAULT_WRITE_METRICS_MODE_DEFAULT in
+  /// org.apache.iceberg.TableProperties.
+  constexpr static int32_t kDefaultTruncateLength{16};
+
+ private:
+  bool shouldStoreBounds(int32_t fieldId) const {
+    return !skipBoundsFieldIds_.contains(fieldId);
+  }
+
+  // Hierarchical Parquet field IDs for all input columns. A single
+  // ParquetFieldId can describe all the columns including their nested
+  // children.
+  parquet::ParquetFieldId parquetFieldIds_;
+
+  // Set of field IDs for which bounds collection should be skipped.
+  // This includes MAP and ARRAY types and all their descendants.
+  std::unordered_set<int32_t> skipBoundsFieldIds_;
+};
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergPartitionName.cpp b/velox/connectors/hive/iceberg/IcebergPartitionName.cpp
new file mode 100644
index 00000000000..97a0f565b8b
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergPartitionName.cpp
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/connectors/hive/iceberg/IcebergPartitionName.h"
+#include "velox/common/encode/Base64.h"
+#include "velox/dwio/catalog/fbhive/FileUtils.h"
+#include "velox/functions/prestosql/URLFunctions.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+namespace {
+
+std::string escapePathName(const std::string& name) {
+  std::string encoded;
+  // Pre-allocate for worst case: every byte is invalid UTF-8.
+  // urlEscape() writes directly into the pre-allocated buffer and
+  // calls resize() at the end to shrink to the actual size used.
+  encoded.resize(name.size() * 9);
+  functions::detail::urlEscape(encoded, name);
+  return encoded;
+}
+
+} // namespace
+
+IcebergPartitionName::IcebergPartitionName(
+    const IcebergPartitionSpecPtr& partitionSpec) {
+  VELOX_CHECK_NOT_NULL(partitionSpec);
+  transformTypes_.reserve(partitionSpec->fields.size());
+  for (const auto& field : partitionSpec->fields) {
+    transformTypes_.emplace_back(field.transformType);
+  }
+}
+
+std::string IcebergPartitionName::partitionName(
+    uint32_t partitionId,
+    const RowVectorPtr& partitionValues,
+    bool partitionKeyAsLowerCase) const {
+  auto toPartitionName = [this](
+                             auto value, const TypePtr& type, int columnIndex) {
+    return IcebergPartitionName::toName(
+        value, type, transformTypes_[columnIndex]);
+  };
+
+  return dwio::catalog::fbhive::FileUtils::makePartName(
+      HivePartitionName::partitionKeyValues(
+          partitionId,
+          partitionValues,
+          /*nullValueString=*/"null",
+          toPartitionName),
+      partitionKeyAsLowerCase,
+      /*useDefaultPartitionValue=*/false,
+      escapePathName);
+}
+
+std::string IcebergPartitionName::toName(
+    int32_t value,
+    const TypePtr& type,
+    TransformType transformType) {
+  constexpr int32_t kEpochYear = 1970;
+  switch (transformType) {
+    case TransformType::kIdentity: {
+      if (type->isDate()) {
+        return DateType::toIso8601(value);
+      }
+      return fmt::to_string(value);
+    }
+    case TransformType::kDay:
+      return DATE()->toString(value);
+    case TransformType::kYear:
+      return fmt::format("{:04d}", kEpochYear + value);
+    case TransformType::kMonth: {
+      int32_t year = kEpochYear + value / 12;
+      int32_t month = 1 + value % 12;
+      if (month <= 0) {
+        month += 12;
+        year -= 1;
+      }
+      return fmt::format("{:04d}-{:02d}", year, month);
+    }
+    case TransformType::kHour: {
+      int64_t seconds = static_cast<int64_t>(value) * 3600;
+      std::tm tmValue;
+      VELOX_USER_CHECK(
+          Timestamp::epochToCalendarUtc(seconds, tmValue),
+          "Failed to convert seconds to time: {}",
+          seconds);
+      return fmt::format(
+          "{:04d}-{:02d}-{:02d}-{:02d}",
+          tmValue.tm_year + 1900,
+          tmValue.tm_mon + 1,
+          tmValue.tm_mday,
+          tmValue.tm_hour);
+    }
+    default:
+      return fmt::to_string(value);
+  }
+}
+
+std::string IcebergPartitionName::toName(
+    Timestamp value,
+    const TypePtr& type,
+    TransformType transformType) {
+  VELOX_CHECK(transformType == TransformType::kIdentity);
+  TimestampToStringOptions options;
+  options.precision = TimestampPrecision::kMilliseconds;
+  options.zeroPaddingYear = true;
+  options.skipTrailingZeros = true;
+  options.leadingPositiveSign = true;
+  return value.toString(options);
+}
+
+std::string IcebergPartitionName::toName(
+    StringView value,
+    const TypePtr& type,
+    TransformType transformType) {
+  VELOX_CHECK(
+      transformType == TransformType::kIdentity ||
+      transformType == TransformType::kTruncate);
+  if (type->isVarbinary()) {
+    return encoding::Base64::encode(value.data(), value.size());
+  }
+  return std::string(value);
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergPartitionName.h b/velox/connectors/hive/iceberg/IcebergPartitionName.h
new file mode 100644
index 00000000000..751f3620c80
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergPartitionName.h
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/connectors/hive/HivePartitionName.h"
+#include "velox/connectors/hive/iceberg/PartitionSpec.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+/// Generates Iceberg-compliant partition path names.
+/// Converts partition keys to human-readable strings based on their transform
+/// types (e.g., year, month, day, hour, identity, truncate) and constructs
+/// URL-encoded partition paths in the format "key1=value1/key2=value2/...".
+class IcebergPartitionName {
+ public:
+  /// @param partitionSpec Iceberg partition specification containing transform
+  /// definitions for each partition field. Used to get transform type and call
+  /// different format functions to convert transformed partition values to
+  /// human-readable strings.
+  IcebergPartitionName(const IcebergPartitionSpecPtr& partitionSpec);
+
+  /// Generates an Iceberg compliant partition path string for the given
+  /// partition ID.
+  ///
+  /// Constructs a partition path in the format "key1=value1/key2=value2/..."
+  /// where:
+  /// - Keys are partition column names for identity transforms, or
+  ///   "columnName_transformName" for non-identity transforms (e.g.,
+  ///   "date_year")
+  /// - Values are human-readable string representations of the transformed
+  ///   partition keys, formatted according to their transform types
+  /// - Both keys and values are URL-encoded per java.net.URLEncoder.encode()
+  ///
+  /// Example: "store_id=123/date_year=2025/address_bucket=1"
+  ///
+  /// Typically called once per partition ID when creating a new writer for that
+  /// partition.
+  ///
+  /// @param partitionId Sequential partition ID (0-based) used as the row index
+  /// into partitionValues. Must be less than partitionValues->size().
+  /// @param partitionValues RowVector containing transformed partition keys
+  /// for all partitions. Each row represents one unique partition, with
+  /// columns corresponding to partition fields in partitionSpec. Row at
+  /// partitionId contains the keys for this specific partition.
+  /// @param partitionKeyAsLowerCase Whether to convert partition keys to
+  /// lowercase in the generated partition path. When true, partition keys like
+  /// "Year" become "year" in the path "year=2025/...".
+  /// @return URL-encoded partition path string suitable for use in file paths.
+  std::string partitionName(
+      uint32_t partitionId,
+      const RowVectorPtr& partitionValues,
+      bool partitionKeyAsLowerCase) const;
+
+  /// Generic template for formatting simple types that just need string
+  /// conversion. Specialized for types that need special handling.
+  template <typename T>
+  FOLLY_ALWAYS_INLINE static std::string
+  toName(T value, const TypePtr& type, TransformType transformType) {
+    return HivePartitionName::toName(value, type);
+  }
+
+  /// Converts an int32_t partition key to its string representation based on
+  /// the transform type:
+  /// - kIdentity: For DATE type return "YYYY-MM-DD" format (e.g.,
+  ///              "2025-11-07").
+  ///              For other types return the value as-is (e.g., "-123").
+  /// - kDay: Returns date in "YYYY-MM-DD" format (e.g., "2025-11-07").
+  /// - kYear: Returns 4-digit year "YYYY" (e.g., "2025").
+  /// - kMonth: Returns "YYYY-MM" format (e.g., "2025-01").
+  /// - kHour: Returns "YYYY-MM-DD-HH" format (e.g., "2025-11-07-21").
+  static std::string
+  toName(int32_t value, const TypePtr& type, TransformType transformType);
+
+  /// Returns timestamp formatted with milliseconds precision, zero-padded
+  /// year, trailing zeros skipped, and leading positive sign for years >=
+  /// 10000. Examples:
+  /// - Timestamp(0, 0) -> "1970-01-01T00:00:00".
+  /// - Timestamp(1609459200, 999000000) -> "2021-01-01T00:00:00.999".
+  /// - Timestamp(1640995200, 500000000) -> "2022-01-01T00:00:00.5".
+  /// - Timestamp(-1, 999000000) -> "1969-12-31T23:59:59.999".
+  /// - Timestamp(253402300800, 100000000) -> "+10000-01-01T00:00:00.1".
+  static std::string
+  toName(Timestamp value, const TypePtr& type, TransformType transformType);
+
+  /// Converts a StringView partition key to its string representation.
+  /// - For VARBINARY type returns Base64-encoded string.
+  /// - For VARCHAR type returns the string value as-is.
+  static std::string
+  toName(StringView value, const TypePtr& type, TransformType transformType);
+
+ private:
+  // Cached transform types, one per partition column. Created once in
+  // constructor and reused for all formatting operations. Index corresponds to
+  // column index in partitionSpec_->fields.
+  std::vector<TransformType> transformTypes_;
+};
+
+using IcebergPartitionNamePtr = std::shared_ptr<const IcebergPartitionName>;
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergSplit.cpp b/velox/connectors/hive/iceberg/IcebergSplit.cpp
index e5cdf63c33b..a6bbea066d6 100644
--- a/velox/connectors/hive/iceberg/IcebergSplit.cpp
+++ b/velox/connectors/hive/iceberg/IcebergSplit.cpp
@@ -33,7 +33,8 @@ HiveIcebergSplit::HiveIcebergSplit(
     const std::shared_ptr<std::string>& extraFileInfo,
     bool cacheable,
     const std::unordered_map<std::string, std::string>& infoColumns,
-    std::optional<FileProperties> properties)
+    std::optional<FileProperties> properties,
+    int64_t dataSequenceNumber)
     : HiveConnectorSplit(
           connectorId,
           filePath,
@@ -50,7 +51,8 @@ HiveIcebergSplit::HiveIcebergSplit(
           infoColumns,
           properties,
           std::nullopt,
-          std::nullopt) {
+          std::nullopt),
+      dataSequenceNumber(dataSequenceNumber) {
   // TODO: Deserialize _extraFileInfo to get deleteFiles;
 }
 
@@ -69,7 +71,8 @@ HiveIcebergSplit::HiveIcebergSplit(
     bool cacheable,
     std::vector<IcebergDeleteFile> deletes,
     const std::unordered_map<std::string, std::string>& infoColumns,
-    std::optional<FileProperties> properties)
+    std::optional<FileProperties> properties,
+    int64_t dataSequenceNumber)
     : HiveConnectorSplit(
           connectorId,
           filePath,
@@ -87,5 +90,6 @@ HiveIcebergSplit::HiveIcebergSplit(
           properties,
           std::nullopt,
           std::nullopt),
-      deleteFiles(std::move(deletes)) {}
+      deleteFiles(std::move(deletes)),
+      dataSequenceNumber(dataSequenceNumber) {}
 } // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergSplit.h b/velox/connectors/hive/iceberg/IcebergSplit.h
index eb2448dabd1..982fbeb4e19 100644
--- a/velox/connectors/hive/iceberg/IcebergSplit.h
+++ b/velox/connectors/hive/iceberg/IcebergSplit.h
@@ -25,6 +25,13 @@ namespace facebook::velox::connector::hive::iceberg {
 struct HiveIcebergSplit : public connector::hive::HiveConnectorSplit {
   std::vector<IcebergDeleteFile> deleteFiles;
 
+  /// Data sequence number of the base data file in this split. Per the Iceberg
+  /// spec (V2+), an equality delete file should only apply to data files whose
+  /// data sequence number is strictly less than the delete file's sequence
+  /// number. A value of 0 means "unassigned" (legacy V1 tables) and disables
+  /// sequence number filtering.
+  int64_t dataSequenceNumber{0};
+
   HiveIcebergSplit(
       const std::string& connectorId,
       const std::string& filePath,
@@ -38,7 +45,8 @@ struct HiveIcebergSplit : public connector::hive::HiveConnectorSplit {
       const std::shared_ptr<std::string>& extraFileInfo = {},
       bool cacheable = true,
       const std::unordered_map<std::string, std::string>& infoColumns = {},
-      std::optional<FileProperties> fileProperties = std::nullopt);
+      std::optional<FileProperties> fileProperties = std::nullopt,
+      int64_t dataSequenceNumber = 0);
 
   // For tests only
   HiveIcebergSplit(
@@ -55,7 +63,8 @@ struct HiveIcebergSplit : public connector::hive::HiveConnectorSplit {
       bool cacheable = true,
       std::vector<IcebergDeleteFile> deletes = {},
       const std::unordered_map<std::string, std::string>& infoColumns = {},
-      std::optional<FileProperties> fileProperties = std::nullopt);
+      std::optional<FileProperties> fileProperties = std::nullopt,
+      int64_t dataSequenceNumber = 0);
 };
 
 } // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergSplitReader.cpp b/velox/connectors/hive/iceberg/IcebergSplitReader.cpp
index 8b8e9fe6ffa..63167152f3f 100644
--- a/velox/connectors/hive/iceberg/IcebergSplitReader.cpp
+++ b/velox/connectors/hive/iceberg/IcebergSplitReader.cpp
@@ -16,86 +16,493 @@
 
 #include "velox/connectors/hive/iceberg/IcebergSplitReader.h"
 
+#include <algorithm>
+
+#include <folly/ScopeGuard.h>
+#include <folly/lang/Bits.h>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/encode/Base64.h"
+#include "velox/connectors/hive/iceberg/IcebergColumnHandle.h"
 #include "velox/connectors/hive/iceberg/IcebergDeleteFile.h"
+#include "velox/connectors/hive/iceberg/IcebergMetadataColumns.h"
 #include "velox/connectors/hive/iceberg/IcebergSplit.h"
 #include "velox/dwio/common/BufferUtil.h"
+#include "velox/vector/DecodedVector.h"
 
 using namespace facebook::velox::dwio::common;
 
+namespace {
+
+// Fills null slots in a BIGINT child vector with values produced by valueAt(i),
+// where i is the output row index. If the whole vector is a null constant,
+// replaces it with a flat vector. If only some slots are null, copies non-null
+// values and fills null slots with valueAt(i). No-op when no nulls are present.
+template <typename F>
+void fillNullsWithInt64(
+    facebook::velox::VectorPtr& child,
+    facebook::velox::memory::MemoryPool* pool,
+    F valueAt) {
+  using namespace facebook::velox;
+  child = BaseVector::loadedVectorShared(child);
+  const auto vectorSize = child->size();
+  if (vectorSize == 0) {
+    return;
+  }
+  if (child->isConstantEncoding() && child->isNullAt(0)) {
+    auto flat =
+        BaseVector::create<FlatVector<int64_t>>(BIGINT(), vectorSize, pool);
+    for (vector_size_t i = 0; i < vectorSize; ++i) {
+      flat->set(i, valueAt(i));
+    }
+    child = std::move(flat);
+  } else if (child->mayHaveNulls()) {
+    const DecodedVector decoded(*child);
+    if (decoded.mayHaveNulls()) {
+      auto flat =
+          BaseVector::create<FlatVector<int64_t>>(BIGINT(), vectorSize, pool);
+      for (vector_size_t i = 0; i < vectorSize; ++i) {
+        if (decoded.isNullAt(i)) {
+          flat->set(i, valueAt(i));
+        } else {
+          flat->set(i, decoded.valueAt<int64_t>(i));
+        }
+      }
+      child = std::move(flat);
+    }
+  }
+}
+
+} // namespace
+
 namespace facebook::velox::connector::hive::iceberg {
+namespace {
+
+/// Returns true if a delete/update file should be skipped based on sequence
+/// number conflict resolution. Per the Iceberg spec (V2+):
+///   - Equality deletes apply when deleteSeqNum > dataSeqNum (i.e., skip when
+///     deleteSeqNum <= dataSeqNum).
+///   - Positional deletes, deletion vectors, and positional updates apply when
+///     deleteSeqNum >= dataSeqNum (i.e., skip when deleteSeqNum < dataSeqNum),
+///     because same-snapshot positional deletes SHOULD apply.
+///   - A sequence number of 0 means "unassigned" (legacy V1 tables) and
+///     disables filtering (never skip).
+bool shouldSkipBySequenceNumber(
+    int64_t deleteFileSeqNum,
+    int64_t dataSeqNum,
+    bool isEqualityDelete) {
+  if (deleteFileSeqNum <= 0 || dataSeqNum <= 0) {
+    return false;
+  }
+  return isEqualityDelete ? (deleteFileSeqNum <= dataSeqNum)
+                          : (deleteFileSeqNum < dataSeqNum);
+}
+
+} // namespace
 
 IcebergSplitReader::IcebergSplitReader(
-    const std::shared_ptr<const hive::HiveConnectorSplit>& hiveSplit,
-    const HiveTableHandlePtr& hiveTableHandle,
-    const std::unordered_map<std::string, HiveColumnHandlePtr>* partitionKeys,
+    const std::shared_ptr<const HiveIcebergSplit>& icebergSplit,
+    const FileTableHandlePtr& tableHandle,
+    const std::unordered_map<std::string, FileColumnHandlePtr>* partitionKeys,
     const ConnectorQueryCtx* connectorQueryCtx,
-    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const std::shared_ptr<const FileConfig>& fileConfig,
     const RowTypePtr& readerOutputType,
-    const std::shared_ptr<io::IoStatistics>& ioStats,
-    const std::shared_ptr<filesystems::File::IoStats>& fsStats,
+    const std::shared_ptr<io::IoStatistics>& dataIoStats,
+    const std::shared_ptr<io::IoStatistics>& metadataIoStats,
+    const std::shared_ptr<IoStats>& ioStats,
     FileHandleFactory* const fileHandleFactory,
     folly::Executor* executor,
-    const std::shared_ptr<common::ScanSpec>& scanSpec)
-    : SplitReader(
-          hiveSplit,
-          hiveTableHandle,
+    const std::shared_ptr<common::ScanSpec>& scanSpec,
+    std::shared_ptr<ColumnHandleMap> columnHandles)
+    : FileSplitReader(
+          icebergSplit,
+          tableHandle,
           partitionKeys,
           connectorQueryCtx,
-          hiveConfig,
+          fileConfig,
           readerOutputType,
+          dataIoStats,
+          metadataIoStats,
           ioStats,
-          fsStats,
           fileHandleFactory,
           executor,
           scanSpec),
+      icebergSplit_(icebergSplit),
       baseReadOffset_(0),
       splitOffset_(0),
-      deleteBitmap_(nullptr) {}
+      deleteBitmap_(nullptr),
+      columnHandles_(std::move(columnHandles)) {}
 
 void IcebergSplitReader::prepareSplit(
     std::shared_ptr<common::MetadataFilter> metadataFilter,
-    dwio::common::RuntimeStatistics& runtimeStats) {
-  createReader();
+    dwio::common::RuntimeStatistics& runtimeStats,
+    const folly::F14FastMap<std::string, std::string>& fileReadOps) {
+  // Temporarily extend the file schema with projected row-lineage columns
+  // (_row_id, _last_updated_sequence_number) so the reader allocates output
+  // slots for them. Scoped to createReader() so getAdaptedRowType() sees the
+  // original schema.
+  {
+    auto originalFileSchema = baseReaderOpts_.fileSchema();
+    auto restorer = folly::makeGuard([&] {
+      if (originalFileSchema) {
+        baseReaderOpts_.setFileSchema(originalFileSchema);
+      }
+    });
+    if (originalFileSchema) {
+      auto names = originalFileSchema->names();
+      auto types = originalFileSchema->children();
+      bool modified = false;
+      for (const auto* colName :
+           {IcebergMetadataColumn::kRowIdColumnName,
+            IcebergMetadataColumn::kLastUpdatedSequenceNumberColumnName}) {
+        if (readerOutputType_->containsChild(colName) &&
+            !originalFileSchema->containsChild(colName)) {
+          names.emplace_back(std::string(colName));
+          types.emplace_back(BIGINT());
+          modified = true;
+        }
+      }
+      if (modified) {
+        baseReaderOpts_.setFileSchema(ROW(std::move(names), std::move(types)));
+      }
+    }
+    createReader(fileReadOps);
+  }
+
   if (emptySplit_) {
     return;
   }
+
+  configureEqualityDeleteColumns();
+
+  firstRowId_ = std::nullopt;
+  if (auto it = icebergSplit_->infoColumns.find(
+          IcebergMetadataColumn::kFirstRowIdInfoColumn);
+      it != icebergSplit_->infoColumns.end()) {
+    try {
+      firstRowId_ = folly::to<int64_t>(it->second);
+    } catch (const folly::ConversionError&) {
+      VELOX_FAIL(
+          "Invalid $first_row_id value in split info columns: {}", it->second);
+    }
+    VELOX_CHECK_GE(*firstRowId_, 0, "First row ID must be non-negative");
+  }
+
+  dataSequenceNumber_ = std::nullopt;
+  if (auto it = icebergSplit_->infoColumns.find(
+          IcebergMetadataColumn::kDataSequenceNumberInfoColumn);
+      it != icebergSplit_->infoColumns.end()) {
+    try {
+      dataSequenceNumber_ = folly::to<int64_t>(it->second);
+    } catch (const folly::ConversionError&) {
+      VELOX_FAIL(
+          "Invalid $data_sequence_number value in split info columns: {}",
+          it->second);
+    }
+    VELOX_CHECK_GE(
+        *dataSequenceNumber_, 0, "Data sequence number must be non-negative");
+  }
+
+  // getAdaptedRowType() calls adaptColumns(), which may set
+  // _last_updated_sequence_number to a constant. Must run after
+  // dataSequenceNumber_ and firstRowId_ are initialized.
   auto rowType = getAdaptedRowType();
 
+  lastUpdatedSeqNumOutputIndex_ = std::nullopt;
+  if (dataSequenceNumber_.has_value()) {
+    auto* seqNumSpec = scanSpec_->childByName(
+        IcebergMetadataColumn::kLastUpdatedSequenceNumberColumnName);
+    if (seqNumSpec && !seqNumSpec->isConstant()) {
+      lastUpdatedSeqNumOutputIndex_ = readerOutputType_->getChildIdxIfExists(
+          IcebergMetadataColumn::kLastUpdatedSequenceNumberColumnName);
+    }
+  }
+
+  rowIdOutputIndex_ = std::nullopt;
+  if (firstRowId_.has_value()) {
+    rowIdOutputIndex_ = readerOutputType_->getChildIdxIfExists(
+        IcebergMetadataColumn::kRowIdColumnName);
+  }
+
   if (checkIfSplitIsEmpty(runtimeStats)) {
     VELOX_CHECK(emptySplit_);
     return;
   }
 
-  createRowReader(std::move(metadataFilter), std::move(rowType));
+  // Inject a row-number column when filters, random-skip, or positional
+  // deletes make the output-to-file-position mapping non-contiguous.
+  // Check split metadata rather than positionalDeleteFileReaders_ because
+  // the row reader must be configured before delete files are opened.
+  const bool hasPositionalDeletes = std::any_of(
+      icebergSplit_->deleteFiles.begin(),
+      icebergSplit_->deleteFiles.end(),
+      [](const IcebergDeleteFile& deleteFile) {
+        return deleteFile.content == FileContent::kPositionalDeletes &&
+            deleteFile.recordCount > 0;
+      });
+  useRowNumberColumn_ = rowIdOutputIndex_.has_value() &&
+      (scanSpec_->hasFilter() || baseReaderOpts_.randomSkip() != nullptr ||
+       hasPositionalDeletes);
+  if (useRowNumberColumn_) {
+    dwio::common::RowNumberColumnInfo rowNumInfo;
+    rowNumInfo.insertPosition = readerOutputType_->size();
+    rowNumInfo.name = "";
+    baseRowReaderOpts_.setRowNumberColumnInfo(rowNumInfo);
+  } else {
+    baseRowReaderOpts_.setRowNumberColumnInfo(std::nullopt);
+  }
+
+  createRowReader(std::move(metadataFilter), std::move(rowType), std::nullopt);
 
-  std::shared_ptr<const HiveIcebergSplit> icebergSplit =
-      std::dynamic_pointer_cast<const HiveIcebergSplit>(hiveSplit_);
   baseReadOffset_ = 0;
   splitOffset_ = baseRowReader_->nextRowNumber();
   positionalDeleteFileReaders_.clear();
+  deletionVectorReaders_.clear();
+  equalityDeleteFileReaders_.clear();
 
-  const auto& deleteFiles = icebergSplit->deleteFiles;
+  const auto& deleteFiles = icebergSplit_->deleteFiles;
   for (const auto& deleteFile : deleteFiles) {
     if (deleteFile.content == FileContent::kPositionalDeletes) {
       if (deleteFile.recordCount > 0) {
+        if (shouldSkipBySequenceNumber(
+                deleteFile.dataSequenceNumber,
+                icebergSplit_->dataSequenceNumber,
+                /*isEqualityDelete=*/false)) {
+          continue;
+        }
+
+        // Skip the delete file if all delete positions are before this split.
+        // TODO: Skip delete files where all positions are after the split, if
+        // split row count becomes available.
+        if (auto iter =
+                deleteFile.upperBounds.find(IcebergMetadataColumn::kPosId);
+            iter != deleteFile.upperBounds.end()) {
+          auto decodedBound = encoding::Base64::decode(iter->second);
+          VELOX_CHECK_EQ(
+              decodedBound.size(),
+              sizeof(uint64_t),
+              "Unexpected decoded size for positional delete upper bound.");
+          uint64_t posDeleteUpperBound;
+          std::memcpy(
+              &posDeleteUpperBound, decodedBound.data(), sizeof(uint64_t));
+          posDeleteUpperBound = folly::Endian::little(posDeleteUpperBound);
+          if (posDeleteUpperBound < splitOffset_) {
+            continue;
+          }
+        }
         positionalDeleteFileReaders_.push_back(
             std::make_unique<PositionalDeleteFileReader>(
                 deleteFile,
-                hiveSplit_->filePath,
+                fileSplit_->filePath,
                 fileHandleFactory_,
                 connectorQueryCtx_,
                 ioExecutor_,
-                hiveConfig_,
+                fileConfig_,
+                dataIoStats_,
                 ioStats_,
-                fsStats_,
                 runtimeStats,
                 splitOffset_,
-                hiveSplit_->connectorId));
+                fileSplit_->connectorId));
+      }
+    } else if (deleteFile.content == FileContent::kEqualityDeletes) {
+      if (deleteFile.recordCount > 0 && !deleteFile.equalityFieldIds.empty()) {
+        if (shouldSkipBySequenceNumber(
+                deleteFile.dataSequenceNumber,
+                icebergSplit_->dataSequenceNumber,
+                /*isEqualityDelete=*/true)) {
+          continue;
+        }
+
+        auto [equalityColumnNames, equalityColumnTypes] =
+            resolveEqualityColumns(deleteFile);
+
+        if (!equalityColumnNames.empty()) {
+          equalityDeleteFileReaders_.push_back(
+              std::make_unique<EqualityDeleteFileReader>(
+                  deleteFile,
+                  equalityColumnNames,
+                  equalityColumnTypes,
+                  fileSplit_->filePath,
+                  fileHandleFactory_,
+                  connectorQueryCtx_,
+                  ioExecutor_,
+                  fileConfig_,
+                  dataIoStats_,
+                  ioStats_,
+                  runtimeStats,
+                  fileSplit_->connectorId));
+        }
+      }
+    } else if (deleteFile.content == FileContent::kDeletionVector) {
+      if (deleteFile.recordCount > 0) {
+        if (shouldSkipBySequenceNumber(
+                deleteFile.dataSequenceNumber,
+                icebergSplit_->dataSequenceNumber,
+                /*isEqualityDelete=*/false)) {
+          continue;
+        }
+
+        // If 'referencedDataFile' is set and does not match the split's
+        // data file, log a warning. Do NOT skip the DV: silently dropping
+        // a coordinator-shipped DV could mask deletes if the planner and
+        // worker disagree on path normalization (trailing slash, scheme
+        // prefix like s3:// vs s3a://, percent-encoding). The coordinator
+        // already filters per-split, so the worker-side check is purely
+        // diagnostic.
+        if (!deleteFile.referencedDataFile.empty() &&
+            deleteFile.referencedDataFile != fileSplit_->filePath) {
+          LOG(WARNING)
+              << "Iceberg DV referencedDataFile does not match split path. "
+              << "Applying DV anyway. referencedDataFile='"
+              << deleteFile.referencedDataFile << "' splitPath='"
+              << fileSplit_->filePath << "'";
+        }
+
+        deletionVectorReaders_.push_back(
+            std::make_unique<DeletionVectorReader>(
+                deleteFile, splitOffset_, connectorQueryCtx_->memoryPool()));
       }
     } else {
-      VELOX_NYI();
+      VELOX_NYI(
+          "Unsupported delete file content type: {}",
+          static_cast<int>(deleteFile.content));
+    }
+  }
+}
+
+void IcebergSplitReader::configureEqualityDeleteColumns() {
+  // Reset partition-column tracking from any prior split before re-augmenting.
+  equalityAugmentedPartitionColumns_.clear();
+
+  std::vector<std::string> extraEqualityColumns;
+  std::vector<std::string> extraNames;
+  std::vector<TypePtr> extraTypes;
+  const auto& deleteFiles = icebergSplit_->deleteFiles;
+  const auto& splitPartitionKeys = icebergSplit_->partitionKeys;
+
+  for (const auto& deleteFile : deleteFiles) {
+    if (deleteFile.content != FileContent::kEqualityDeletes ||
+        deleteFile.recordCount == 0 || deleteFile.equalityFieldIds.empty()) {
+      continue;
+    }
+    if (shouldSkipBySequenceNumber(
+            deleteFile.dataSequenceNumber,
+            icebergSplit_->dataSequenceNumber,
+            /*isEqualityDelete=*/true)) {
+      continue;
+    }
+
+    auto [equalityColumnNames, equalityColumnTypes] =
+        resolveEqualityColumns(deleteFile);
+    for (size_t i = 0; i < equalityColumnNames.size(); ++i) {
+      const auto& name = equalityColumnNames[i];
+      // Skip if this column was already added by a previous delete file.
+      if (std::find(
+              extraEqualityColumns.begin(), extraEqualityColumns.end(), name) !=
+          extraEqualityColumns.end()) {
+        continue;
+      }
+      auto* fieldSpec = scanSpec_->childByName(name);
+      const bool alreadyInOutput =
+          readerOutputType_->getChildIdxIfExists(name).has_value();
+      if (fieldSpec != nullptr && fieldSpec->projectOut() && alreadyInOutput) {
+        // Already projected by the user (or a previous augmentation) AND
+        // present in the output type by name. The equality-delete reader can
+        // probe it directly.
+        continue;
+      }
+      // Either no spec exists, or one exists but is filter-only, or the
+      // scan-spec child is projected but the column is missing from
+      // 'readerOutputType_'. In all cases ensure the column ends up in
+      // 'readerOutputType_' AND has a projected scan-spec child with a
+      // non-conflicting channel.
+      if (fieldSpec == nullptr) {
+        fieldSpec = scanSpec_->getOrCreateChild(name);
+      }
+      fieldSpec->setProjectOut(true);
+      fieldSpec->setChannel(
+          static_cast<column_index_t>(
+              readerOutputType_->size() + extraEqualityColumns.size()));
+
+      // For partition columns set the partition value directly as a constant
+      // on the scan-spec child. This is independent of whether the data file
+      // contains the partition column physically. With the constant set
+      // up-front, 'adaptColumns' does not need any special-case logic for
+      // augmented partition columns and the read does not depend on the
+      // writer's choice of including the partition column in the file.
+      auto partitionIt = splitPartitionKeys.find(name);
+      if (partitionIt != splitPartitionKeys.end()) {
+        // Iceberg encodes DATE partition values as the integer number of
+        // days since the Unix epoch (e.g. "19345"). The standard
+        // 'setPartitionValue' helper learns this from the planner-supplied
+        // ColumnHandle via 'isPartitionDateValueDaysSinceEpoch()', but no
+        // ColumnHandle is available here when the partition column is not
+        // in the user's projection. Derive the flag from the column type
+        // instead — Iceberg always uses days-since-epoch for DATE.
+        const bool isDaysSinceEpoch = equalityColumnTypes[i]->isDate();
+        auto constant = newConstantFromString(
+            equalityColumnTypes[i],
+            partitionIt->second,
+            connectorQueryCtx_->memoryPool(),
+            fileConfig_->readTimestampPartitionValueAsLocalTime(
+                connectorQueryCtx_->sessionProperties()),
+            isDaysSinceEpoch);
+        fieldSpec->setConstantValue(constant);
+        // Mirror Java's PARTITION_KEY column-type marking: this column's
+        // value MUST come from the partition metadata, never from the file
+        // body. Track it so 'adaptColumns' Branch 1 does not later wipe the
+        // constant when the file happens to also carry the column.
+        equalityAugmentedPartitionColumns_.insert(name);
+      }
+
+      extraEqualityColumns.push_back(name);
+      extraNames.push_back(name);
+      extraTypes.push_back(equalityColumnTypes[i]);
     }
   }
+
+  if (extraEqualityColumns.empty()) {
+    return;
+  }
+
+  // Extend 'readerOutputType_' so the upstream FileDataSource allocates the
+  // output RowVector wide enough for the augmented scan-spec channels. The
+  // original projection columns remain at indices [0, originalSize), so
+  // FileDataSource's positional projection still returns exactly the
+  // user-requested columns.
+  auto names = readerOutputType_->names();
+  auto types = readerOutputType_->children();
+  names.insert(names.end(), extraNames.begin(), extraNames.end());
+  types.insert(types.end(), extraTypes.begin(), extraTypes.end());
+  readerOutputType_ = ROW(std::move(names), std::move(types));
+}
+
+std::pair<std::vector<std::string>, std::vector<TypePtr>>
+IcebergSplitReader::resolveEqualityColumns(
+    const IcebergDeleteFile& deleteFile) const {
+  std::vector<std::string> equalityColumnNames;
+  std::vector<TypePtr> equalityColumnTypes;
+
+  const auto& dataColumns = tableHandle_->dataColumns();
+  VELOX_CHECK(
+      dataColumns != nullptr,
+      "Iceberg equality delete file '{}' cannot be processed because "
+      "table data columns are not available in HiveTableHandle.",
+      deleteFile.filePath);
+  for (const auto& eqFieldId : deleteFile.equalityFieldIds) {
+    // Field IDs are 1-based sequential for non-evolved schemas.
+    auto colIdx = static_cast<uint32_t>(eqFieldId - 1);
+    VELOX_CHECK_LT(
+        colIdx,
+        dataColumns->size(),
+        "Equality delete field ID {} out of range. This may indicate "
+        "schema evolution with non-sequential field IDs, which is "
+        "not yet supported.",
+        eqFieldId);
+    equalityColumnNames.push_back(dataColumns->nameOf(colIdx));
+    equalityColumnTypes.push_back(dataColumns->childAt(colIdx));
+  }
+  return {std::move(equalityColumnNames), std::move(equalityColumnTypes)};
 }
 
 uint64_t IcebergSplitReader::next(uint64_t size, VectorPtr& output) {
@@ -114,7 +521,8 @@ uint64_t IcebergSplitReader::next(uint64_t size, VectorPtr& output) {
     return 0;
   }
 
-  if (!positionalDeleteFileReaders_.empty()) {
+  if (!positionalDeleteFileReaders_.empty() ||
+      !deletionVectorReaders_.empty()) {
     auto numBytes = bits::nbytes(actualSize);
     dwio::common::ensureCapacity<int8_t>(
         deleteBitmap_, numBytes, connectorQueryCtx_->memoryPool(), false, true);
@@ -129,6 +537,17 @@ uint64_t IcebergSplitReader::next(uint64_t size, VectorPtr& output) {
         ++iter;
       }
     }
+
+    for (auto iter = deletionVectorReaders_.begin();
+         iter != deletionVectorReaders_.end();) {
+      (*iter)->readDeletePositions(baseReadOffset_, actualSize, deleteBitmap_);
+
+      if ((*iter)->noMoreData()) {
+        iter = deletionVectorReaders_.erase(iter);
+      } else {
+        ++iter;
+      }
+    }
   }
 
   mutation.deletedRows = deleteBitmap_ && deleteBitmap_->size() > 0
@@ -137,7 +556,261 @@ uint64_t IcebergSplitReader::next(uint64_t size, VectorPtr& output) {
 
   auto rowsScanned = baseRowReader_->next(actualSize, output, &mutation);
 
+  auto* pool = connectorQueryCtx_->memoryPool();
+
+  if (rowsScanned > 0 &&
+      (lastUpdatedSeqNumOutputIndex_.has_value() ||
+       rowIdOutputIndex_.has_value())) {
+    auto* rowOutput = output->as<RowVector>();
+    VELOX_DCHECK_NOT_NULL(
+        rowOutput, "Expected RowVector output from table scan");
+
+    // If lastUpdatedSeqNumOutputIndex_ is present but dataSequenceNumber_ is
+    // not, the output is a constant NULL value vector already populated by the
+    // reader via adaptColumns.
+    if (lastUpdatedSeqNumOutputIndex_.has_value() &&
+        dataSequenceNumber_.has_value()) {
+      auto& seqNumChild = rowOutput->childAt(*lastUpdatedSeqNumOutputIndex_);
+      const int64_t seqNum = static_cast<int64_t>(*dataSequenceNumber_);
+      fillNullsWithInt64(
+          seqNumChild, pool, [seqNum](vector_size_t) { return seqNum; });
+    }
+
+    if (rowIdOutputIndex_.has_value() && firstRowId_.has_value()) {
+      auto& rowIdChild = rowOutput->childAt(*rowIdOutputIndex_);
+      if (useRowNumberColumn_) {
+        // Use the injected row-number column for file-absolute positions.
+        // The row-number column is always appended last (at index
+        // readerOutputType_->size()).
+        const DecodedVector decodedRowNums(
+            *rowOutput->childAt(readerOutputType_->size()));
+        const int64_t firstRowId = static_cast<int64_t>(*firstRowId_);
+        fillNullsWithInt64(rowIdChild, pool, [&](vector_size_t i) {
+          return firstRowId + decodedRowNums.valueAt<int64_t>(i);
+        });
+
+        // Strip the injected row-number column (always last) from the output.
+        auto children = rowOutput->children();
+        children.pop_back();
+        output = std::make_shared<RowVector>(
+            rowOutput->pool(),
+            readerOutputType_,
+            rowOutput->nulls(),
+            rowOutput->size(),
+            std::move(children));
+      } else {
+        // Contiguous output: _row_id = firstRowId_ + file_pos.
+        const int64_t base = static_cast<int64_t>(*firstRowId_) +
+            static_cast<int64_t>(splitOffset_ + baseReadOffset_);
+        fillNullsWithInt64(rowIdChild, pool, [base](vector_size_t i) {
+          return base + static_cast<int64_t>(i);
+        });
+      }
+    }
+  }
+
+  // Apply equality deletes after reading base data. Unlike positional deletes
+  // (which set bits before reading), equality deletes require the data values
+  // to be available for comparison.
+  if (rowsScanned > 0 && !equalityDeleteFileReaders_.empty()) {
+    auto outputRowVector = std::dynamic_pointer_cast<RowVector>(output);
+    VELOX_CHECK_NOT_NULL(
+        outputRowVector, "Output must be a RowVector for equality deletes.");
+
+    auto numRows = outputRowVector->size();
+
+    // Use a separate bitmap for equality deletes to track which rows to
+    // remove from the output.
+    BufferPtr eqDeleteBitmap = AlignedBuffer::allocate<bool>(numRows, pool);
+    std::memset(
+        eqDeleteBitmap->asMutable<uint8_t>(), 0, eqDeleteBitmap->size());
+
+    for (auto& reader : equalityDeleteFileReaders_) {
+      reader->applyDeletes(outputRowVector, eqDeleteBitmap);
+    }
+
+    // Count surviving rows and compact the output if any rows were deleted.
+    auto* eqBitmap = eqDeleteBitmap->as<uint8_t>();
+    vector_size_t numDeleted = 0;
+    for (vector_size_t i = 0; i < numRows; ++i) {
+      if (bits::isBitSet(eqBitmap, i)) {
+        ++numDeleted;
+      }
+    }
+
+    if (numDeleted > 0) {
+      vector_size_t numSurviving = numRows - numDeleted;
+      if (numSurviving == 0) {
+        // All rows in this batch were deleted by equality deletes. Do not
+        // return 0 here — that would be interpreted as end-of-split and
+        // prematurely stop scanning remaining rows in the data file.
+        // Instead, set output to an empty vector and return the original
+        // scanned count so the caller continues reading.
+        output = BaseVector::create(outputRowVector->type(), 0, pool);
+      } else {
+        // Build a list of surviving row ranges and use it to compact.
+        std::vector<BaseVector::CopyRange> ranges;
+        ranges.reserve(numSurviving);
+        vector_size_t targetIdx = 0;
+        for (vector_size_t i = 0; i < numRows; ++i) {
+          if (!bits::isBitSet(eqBitmap, i)) {
+            ranges.push_back({i, targetIdx++, 1});
+          }
+        }
+
+        auto newOutput =
+            BaseVector::create(outputRowVector->type(), numSurviving, pool);
+        newOutput->copyRanges(outputRowVector.get(), ranges);
+        newOutput->resize(numSurviving);
+        output = newOutput;
+        rowsScanned = numSurviving;
+      }
+    }
+
+    return rowsScanned;
+  }
+
   return rowsScanned;
 }
 
+std::vector<TypePtr> IcebergSplitReader::adaptColumns(
+    const RowTypePtr& fileType,
+    const RowTypePtr& tableSchema) const {
+  std::vector<TypePtr> columnTypes = fileType->children();
+  auto& childrenSpecs = scanSpec_->children();
+  const auto& splitInfoColumns = icebergSplit_->infoColumns;
+  const bool readTimestampAsLocalTime =
+      fileConfig_->readTimestampPartitionValueAsLocalTime(
+          connectorQueryCtx_->sessionProperties());
+  // Iceberg table stores all column's data in data file.
+  for (const auto& childSpec : childrenSpecs) {
+    const std::string& fieldName = childSpec->fieldName();
+    if (auto iter = splitInfoColumns.find(fieldName);
+        iter != splitInfoColumns.end()) {
+      auto infoColumnType = readerOutputType_->findChild(fieldName);
+      auto constant = newConstantFromString(
+          infoColumnType,
+          iter->second,
+          connectorQueryCtx_->memoryPool(),
+          readTimestampAsLocalTime,
+          false);
+      childSpec->setConstantValue(constant);
+    } else {
+      auto fileTypeIdx = fileType->getChildIdxIfExists(fieldName);
+      auto outputTypeIdx = readerOutputType_->getChildIdxIfExists(fieldName);
+      if (outputTypeIdx.has_value() && fileTypeIdx.has_value()) {
+        if (equalityAugmentedPartitionColumns_.count(fieldName) > 0) {
+          // This column was pre-installed as a partition-value constant by
+          // 'configureEqualityDeleteColumns'. Mirror Java's PARTITION_KEY
+          // semantics — the value comes from partition metadata, never from
+          // the file body, even though the file body happens to carry the
+          // column. Leave the constant in place; the column type entry for
+          // the file column index stays as the file type so Velox does not
+          // try to bind this output channel to a file read.
+          continue;
+        }
+        childSpec->setConstantValue(nullptr);
+        auto& outputType = readerOutputType_->childAt(*outputTypeIdx);
+        columnTypes[*fileTypeIdx] = outputType;
+      } else if (!fileTypeIdx.has_value()) {
+        // Handle columns missing from the data file in several scenarios:
+        // 1. Partition columns from a Hive-migrated table where partition
+        //    column values are stored in partition metadata rather than in
+        //    the data file itself.
+        // 2. Schema evolution with default values (Iceberg V3): Column was
+        //    added with an initial-default value. Use the default instead of
+        //    NULL.
+        // 3. Schema evolution: Column was added after the data file was
+        //    written and doesn't exist in older data files.
+        // 4. _last_updated_sequence_number: For Iceberg V3 row lineage, if
+        //    the column is not in the file, inherit the data sequence number
+        //    from the file's manifest entry.
+        // 5. _row_id: For Iceberg V3 row lineage, if the column is not in
+        //    the file, set as NULL constant here. When first_row_id is
+        //    available, next() will replace NULL with first_row_id + file
+        //    position.
+        // 6. Equality-delete partition columns not in the user's projection:
+        //    'configureEqualityDeleteColumns' has already pre-installed the
+        //    partition value as a constant, so this branch leaves it alone.
+        if (fieldName ==
+            IcebergMetadataColumn::kLastUpdatedSequenceNumberColumnName) {
+          // Column is absent from the data file. If a data sequence number is
+          // available (V3 snapshot), set a constant so every row inherits it.
+          // Otherwise (pre-V3 snapshot where the sequence number chain is
+          // unassigned), return null — analogous to the _row_id null path.
+          if (dataSequenceNumber_.has_value()) {
+            childSpec->setConstantValue(
+                std::make_shared<ConstantVector<int64_t>>(
+                    connectorQueryCtx_->memoryPool(),
+                    1,
+                    false,
+                    BIGINT(),
+                    static_cast<int64_t>(*dataSequenceNumber_)));
+          } else {
+            childSpec->setConstantValue(
+                BaseVector::createNullConstant(
+                    BIGINT(), 1, connectorQueryCtx_->memoryPool()));
+          }
+        } else if (fieldName == IcebergMetadataColumn::kRowIdColumnName) {
+          childSpec->setConstantValue(
+              BaseVector::createNullConstant(
+                  BIGINT(), 1, connectorQueryCtx_->memoryPool()));
+        } else if (childSpec->isConstant()) {
+          // Constant already set (case 6, or set on a previous prepareSplit
+          // call for the same scanSpec). Nothing to do.
+          continue;
+        } else if (auto partitionIt = fileSplit_->partitionKeys.find(fieldName);
+                   partitionIt != fileSplit_->partitionKeys.end()) {
+          setPartitionValue(childSpec.get(), fieldName, partitionIt->second);
+        } else {
+          // Check if column has an initial-default value (Iceberg V3)
+          bool hasDefaultValue = false;
+          // The columnHandles_ map is keyed by output name (which may be an
+          // alias). We need to find the column handle where the handle's name()
+          // matches fieldName. fieldName is the table column name from
+          // readerOutputType_.
+          for (const auto& [outputName, handle] : *columnHandles_) {
+            if (handle->name() == fieldName) {
+              auto icebergColumnHandle =
+                  std::dynamic_pointer_cast<const IcebergColumnHandle>(handle);
+              if (icebergColumnHandle &&
+                  icebergColumnHandle->initialDefaultValue().has_value()) {
+                // Use initial-default value for schema evolution.
+                auto columnType = tableSchema->findChild(fieldName);
+                VELOX_CHECK_NOT_NULL(
+                    columnType,
+                    "Column '{}' not found in table schema",
+                    fieldName);
+                auto constant = newConstantFromString(
+                    columnType,
+                    icebergColumnHandle->initialDefaultValue().value(),
+                    connectorQueryCtx_->memoryPool(),
+                    readTimestampAsLocalTime,
+                    false);
+                childSpec->setConstantValue(constant);
+                hasDefaultValue = true;
+                break;
+              }
+            }
+          }
+
+          // Fall back to NULL if no default value
+          if (!hasDefaultValue) {
+            auto columnType = tableSchema->findChild(fieldName);
+            VELOX_CHECK_NOT_NULL(
+                columnType, "Column '{}' not found in table schema", fieldName);
+            childSpec->setConstantValue(
+                BaseVector::createNullConstant(
+                    columnType, 1, connectorQueryCtx_->memoryPool()));
+          }
+        }
+      }
+    }
+  }
+
+  scanSpec_->resetCachedValues(false);
+
+  return columnTypes;
+}
+
 } // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergSplitReader.h b/velox/connectors/hive/iceberg/IcebergSplitReader.h
index 4b3c6b90104..7bba8464b57 100644
--- a/velox/connectors/hive/iceberg/IcebergSplitReader.h
+++ b/velox/connectors/hive/iceberg/IcebergSplitReader.h
@@ -16,45 +16,169 @@
 
 #pragma once
 
+#include <folly/container/F14Set.h>
+
 #include "velox/connectors/Connector.h"
-#include "velox/connectors/hive/SplitReader.h"
+#include "velox/connectors/hive/FileSplitReader.h"
+#include "velox/connectors/hive/iceberg/DeletionVectorReader.h"
+#include "velox/connectors/hive/iceberg/EqualityDeleteFileReader.h"
 #include "velox/connectors/hive/iceberg/PositionalDeleteFileReader.h"
 
 namespace facebook::velox::connector::hive::iceberg {
 
+struct HiveIcebergSplit;
 struct IcebergDeleteFile;
 
-class IcebergSplitReader : public SplitReader {
+class IcebergSplitReader : public FileSplitReader {
  public:
   IcebergSplitReader(
-      const std::shared_ptr<const hive::HiveConnectorSplit>& hiveSplit,
-      const HiveTableHandlePtr& hiveTableHandle,
-      const std::unordered_map<std::string, HiveColumnHandlePtr>* partitionKeys,
+      const std::shared_ptr<const HiveIcebergSplit>& icebergSplit,
+      const FileTableHandlePtr& tableHandle,
+      const std::unordered_map<std::string, FileColumnHandlePtr>* partitionKeys,
       const ConnectorQueryCtx* connectorQueryCtx,
-      const std::shared_ptr<const HiveConfig>& hiveConfig,
+      const std::shared_ptr<const FileConfig>& fileConfig,
       const RowTypePtr& readerOutputType,
-      const std::shared_ptr<io::IoStatistics>& ioStats,
-      const std::shared_ptr<filesystems::File::IoStats>& fsStats,
+      const std::shared_ptr<io::IoStatistics>& dataIoStats,
+      const std::shared_ptr<io::IoStatistics>& metadataIoStats,
+      const std::shared_ptr<IoStats>& ioStats,
       FileHandleFactory* fileHandleFactory,
       folly::Executor* executor,
-      const std::shared_ptr<common::ScanSpec>& scanSpec);
+      const std::shared_ptr<common::ScanSpec>& scanSpec,
+      std::shared_ptr<ColumnHandleMap> columnHandles);
 
   ~IcebergSplitReader() override = default;
 
   void prepareSplit(
       std::shared_ptr<common::MetadataFilter> metadataFilter,
-      dwio::common::RuntimeStatistics& runtimeStats) override;
+      dwio::common::RuntimeStatistics& runtimeStats,
+      const folly::F14FastMap<std::string, std::string>& fileReadOps = {})
+      override;
 
   uint64_t next(uint64_t size, VectorPtr& output) override;
 
  private:
-  // The read offset to the beginning of the split in number of rows for the
-  // current batch for the base data file
+  /// Adapts the data file schema to match the table schema expected by the
+  /// query.
+  ///
+  /// This method reconciles differences between the physical data file schema
+  /// and the logical table schema, handling various scenarios where columns may
+  /// be missing, added, or need special treatment.
+  ///
+  /// @param fileType The schema read from the data file's metadata. This
+  /// represents the actual columns physically present in the Parquet/ORC file.
+  /// @param tableSchema The logical schema defined in the catalog (e.g., from
+  /// DDL). This represents the current table schema that queries expect.
+  ///
+  /// @return A vector of column types adapted to match the query's
+  /// expectations, with appropriate type conversions and constant values set
+  /// for missing or special columns.
+  ///
+  /// The method handles the following scenarios for each column in the scan
+  /// spec:
+  ///
+  /// 1. Info columns (e.g., $path, $data_sequence_number, $deleted)
+  ///    These are virtual columns that provide metadata about the file itself.
+  ///    Values are read from the split's infoColumns map and set as constant
+  ///    values in the scanSpec so they're materialized for all rows.
+  ///
+  /// 2. Regular columns present in File:
+  ///    Column exists in both fileType and readerOutputType. Type is adapted
+  ///    from fileType to match the expected output type, handling schema
+  ///    evolution where column types may have changed.
+  ///
+  /// 3. Columns missing from File:
+  ///    a) Partition columns (hive-migrated tables):
+  ///       Column is marked as partition key in splitPartitionKeys_.
+  ///       In Hive-written Iceberg tables, partition column values are stored
+  ///       in partition metadata, not in the data file itself. Value is read
+  ///       from partition metadata and set as a constant.
+  ///    b) Schema evolution (newly added columns):
+  ///       Column was added to the table schema after this data file was
+  ///       written. Set as NULL constant since the old file doesn't contain
+  ///       this column.
+  ///    c) Row lineage (_last_updated_sequence_number):
+  ///       For Iceberg V3 row lineage, if the column is not in the file,
+  ///       inherit the data sequence number from the file's manifest entry
+  ///       (provided via $data_sequence_number info column). Per the spec,
+  ///       null values indicate the value should be inherited.
+  ///    d) Row lineage (_row_id):
+  ///       Per the spec, null _row_id values are assigned as
+  ///       first_row_id + file position. When first_row_id is available from
+  ///       the split info column $first_row_id, the value is computed
+  ///       in next(). When first_row_id is not available (e.g.,
+  ///       pre-V3 tables), NULL is returned.
+  std::vector<TypePtr> adaptColumns(
+      const RowTypePtr& fileType,
+      const RowTypePtr& tableSchema) const override;
+
+  // Resolves the equality field IDs of an equality-delete file to the
+  // corresponding column names and types in the table schema. In Iceberg,
+  // field IDs for top-level columns are assigned sequentially starting from
+  // 1, matching the column order in the table schema.
+  std::pair<std::vector<std::string>, std::vector<TypePtr>>
+  resolveEqualityColumns(const IcebergDeleteFile& deleteFile) const;
+
+  // Discovers equality-delete columns that are not in the user's projection
+  // and augments 'scanSpec_' and 'readerOutputType_' so they are physically
+  // read and made available in the output RowVector. For partition columns
+  // the partition value is set as a constant on the scan-spec child so the
+  // augmentation works regardless of whether the data file physically
+  // contains the partition column. Augmented columns are appended at the end
+  // of 'readerOutputType_' so the upstream FileDataSource's positional
+  // projection naturally drops them from the operator output.
+  void configureEqualityDeleteColumns();
+
+  // Names of scan-spec children that 'configureEqualityDeleteColumns'
+  // pre-installed a partition-value constant on for the current split.
+  // Mirrors the Java 'PARTITION_KEY' column-type distinction in
+  // 'IcebergUtil.getColumns(fields, schema, partitionSpec, typeManager)':
+  // for an equality-delete column that is also an identity-partition
+  // column, the value MUST come from the split's partition metadata, never
+  // from the data file body — even if the file body physically contains
+  // the column. 'adaptColumns' uses this set to skip clearing the partition
+  // constant on Branch 1, which would otherwise leave the column stuck as
+  // a constant null and break equality-delete matching after schema
+  // evolution adds new columns at indices that shift the augmented column
+  // out of its file-natural position.
+  folly::F14FastSet<std::string> equalityAugmentedPartitionColumns_;
+
+  const std::shared_ptr<const HiveIcebergSplit> icebergSplit_;
+
+  /// Read offset to the beginning of the split in number of rows for the
+  /// current batch for the base data file.
   uint64_t baseReadOffset_;
-  // The file position for the first row in the split
+  /// File position for the first row in the split.
   uint64_t splitOffset_;
+  // Active readers for positional delete files associated with this split.
   std::list<std::unique_ptr<PositionalDeleteFileReader>>
       positionalDeleteFileReaders_;
+  // Bitmap of deleted rows in the current batch; set bits mark deleted rows.
   BufferPtr deleteBitmap_;
+  // Output column index of _last_updated_sequence_number, if projected.
+  std::optional<column_index_t> lastUpdatedSeqNumOutputIndex_;
+  // Data sequence number from the split's manifest entry, used to populate
+  // _last_updated_sequence_number for rows whose stored value is null.
+  std::optional<int64_t> dataSequenceNumber_;
+  // First row ID from the split's $first_row_id info column, used to compute
+  // _row_id as first_row_id + file position for rows whose stored value is
+  // null.
+  std::optional<int64_t> firstRowId_;
+  // Output column index of _row_id, if projected.
+  std::optional<column_index_t> rowIdOutputIndex_;
+  // Whether an implicit row-number column is needed for _row_id computation
+  // (set when filters, random-skip, or positional deletes make output
+  // positions non-contiguous).
+  bool useRowNumberColumn_{false};
+
+  /// Readers for Iceberg V3 deletion vectors (Puffin-encoded roaring bitmaps).
+  std::list<std::unique_ptr<DeletionVectorReader>> deletionVectorReaders_;
+
+  /// Readers for equality delete files.
+  std::list<std::unique_ptr<EqualityDeleteFileReader>>
+      equalityDeleteFileReaders_;
+
+  /// Column handles map shared with IcebergDataSource.
+  /// Used for accessing column metadata including initial-default values.
+  std::shared_ptr<ColumnHandleMap> columnHandles_;
 };
 } // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/PartitionSpec.cpp b/velox/connectors/hive/iceberg/PartitionSpec.cpp
new file mode 100644
index 00000000000..38b4f0b67c3
--- /dev/null
+++ b/velox/connectors/hive/iceberg/PartitionSpec.cpp
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/PartitionSpec.h"
+
+#include "velox/common/EnumDefine.h"
+
+#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+namespace {
+
+TransformCategory getTransformCategory(TransformType transformType) {
+  switch (transformType) {
+    case TransformType::kIdentity:
+      return TransformCategory::kIdentity;
+    case TransformType::kYear:
+    case TransformType::kMonth:
+    case TransformType::kDay:
+    case TransformType::kHour:
+      return TransformCategory::kTemporal;
+    case TransformType::kBucket:
+      return TransformCategory::kBucket;
+    case TransformType::kTruncate:
+      return TransformCategory::kTruncate;
+    default:
+      VELOX_UNREACHABLE("Unknown transform type");
+  }
+}
+
+bool isValidPartitionType(const TypePtr& type) {
+  return !(
+      type->isRow() || type->isArray() || type->isMap() || type->isDouble() ||
+      type->isReal() || isTimestampWithTimeZoneType(type));
+}
+
+bool canTransform(TransformType transformType, const TypePtr& type) {
+  switch (transformType) {
+    case TransformType::kIdentity:
+      return type->isTinyint() || type->isSmallint() || type->isInteger() ||
+          type->isBigint() || type->isBoolean() || type->isDecimal() ||
+          type->isDate() || type->isTimestamp() || type->isVarchar() ||
+          type->isVarbinary();
+    case TransformType::kYear:
+    case TransformType::kMonth:
+    case TransformType::kDay:
+      return type->isDate() || type->isTimestamp();
+    case TransformType::kHour:
+      return type->isTimestamp();
+    case TransformType::kBucket:
+      return type->isInteger() || type->isBigint() || type->isDecimal() ||
+          type->isVarchar() || type->isVarbinary() || type->isDate() ||
+          type->isTimestamp();
+    case TransformType::kTruncate:
+      return type->isInteger() || type->isBigint() || type->isDecimal() ||
+          type->isVarchar() || type->isVarbinary();
+    default:
+      VELOX_UNREACHABLE("Unsupported partition transform type.");
+  }
+}
+
+const auto& transformTypeNames() {
+  static const folly::F14FastMap<TransformType, std::string_view>
+      kTransformNames = {
+          {TransformType::kIdentity, "identity"},
+          {TransformType::kHour, "hour"},
+          {TransformType::kDay, "day"},
+          {TransformType::kMonth, "month"},
+          {TransformType::kYear, "year"},
+          {TransformType::kBucket, "bucket"},
+          {TransformType::kTruncate, "trunc"},
+      };
+  return kTransformNames;
+}
+
+const auto& transformCategoryNames() {
+  static const folly::F14FastMap<TransformCategory, std::string_view>
+      kTransformCategoryNames = {
+          {TransformCategory::kIdentity, "Identity"},
+          {TransformCategory::kBucket, "Bucket"},
+          {TransformCategory::kTruncate, "Truncate"},
+          {TransformCategory::kTemporal, "Temporal"},
+      };
+  return kTransformCategoryNames;
+}
+
+} // namespace
+
+VELOX_DEFINE_ENUM_NAME(TransformType, transformTypeNames);
+
+VELOX_DEFINE_ENUM_NAME(TransformCategory, transformCategoryNames);
+
+void IcebergPartitionSpec::checkCompatibility() const {
+  folly::F14FastMap<std::string_view, std::vector<TransformType>>
+      columnTransforms;
+
+  for (const auto& field : fields) {
+    const auto& type = field.type;
+    const auto& name = field.name;
+    VELOX_USER_CHECK(
+        isValidPartitionType(type),
+        "Type is not supported as a partition column: {}",
+        type->name());
+
+    VELOX_USER_CHECK(
+        canTransform(field.transformType, type),
+        "Transform is not supported for partition column. Column: '{}', Type: '{}', Transform: '{}'.",
+        name,
+        type->name(),
+        TransformTypeName::toName(field.transformType));
+
+    columnTransforms[name].emplace_back(field.transformType);
+  }
+
+  // Check for duplicate transform categories per column.
+  std::vector<std::string> errors;
+  for (const auto& [columnName, transforms] : columnTransforms) {
+    folly::F14FastSet<TransformCategory> seenCategories;
+    for (const auto& transform : transforms) {
+      auto category = getTransformCategory(transform);
+      if (!seenCategories.insert(category).second) {
+        std::vector<std::string> transformNames;
+        for (const auto& t : transforms) {
+          transformNames.emplace_back(
+              std::string(TransformTypeName::toName(t)));
+        }
+        errors.emplace_back(
+            fmt::format(
+                "Column: '{}', Category: {}, Transforms: [{}]",
+                columnName,
+                TransformCategoryName::toName(category),
+                folly::join(", ", transformNames)));
+        break;
+      }
+    }
+  }
+
+  VELOX_USER_CHECK(
+      errors.empty(),
+      "Multiple transforms of the same category on a column are not allowed. "
+      "Each transform category can appear at most once per column. {}",
+      folly::join("; ", errors));
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/PartitionSpec.h b/velox/connectors/hive/iceberg/PartitionSpec.h
new file mode 100644
index 00000000000..99297da0edc
--- /dev/null
+++ b/velox/connectors/hive/iceberg/PartitionSpec.h
@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/type/Type.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+/// Partition transform types.
+/// Defines how source column values are converted into partition keys.
+/// See https://iceberg.apache.org/spec/#partition-transforms.
+enum class TransformType {
+  /// Use the source value as-is (no transformation).
+  kIdentity,
+  /// Extract a timestamp hour, as hours from 1970-01-01 00:00:00.
+  kHour,
+  /// Extract a date or timestamp day, as days from 1970-01-01.
+  kDay,
+  /// Extract a date or timestamp month, as months from 1970-01.
+  kMonth,
+  /// Extract a date or timestamp year, as years from 1970.
+  kYear,
+  /// Hash the value into N buckets for even distribution. Requires an integer
+  /// parameter specifying the bucket count.
+  kBucket,
+  /// Truncate strings or numbers to a specified width. Requires an integer
+  /// parameter specifying the truncate width.
+  kTruncate
+};
+
+VELOX_DECLARE_ENUM_NAME(TransformType);
+
+/// A single column can be used to produce multiple partition keys, but with
+/// following restrictions:
+/// - Transforms are organized into 4 categories: Identity, Temporal,
+///   Bucket, and Truncate.
+/// - Each category can appear at most once per column.
+/// - Sample valid specs on same column: ['truncate(a,2)', 'bucket(a,16)', 'a']
+///   or ['year(b)', 'bucket(b, 16)', 'b']
+enum class TransformCategory {
+  kIdentity,
+  /// Year/Month/Day/Hour
+  kTemporal,
+  kBucket,
+  kTruncate,
+};
+
+VELOX_DECLARE_ENUM_NAME(TransformCategory);
+
+/// Represents how to produce partition data for an Iceberg table.
+///
+/// This structure corresponds to the Iceberg Java PartitionSpec class but
+/// contains only the necessary fields for Velox. Partition keys are computed
+/// by transforming columns in a table.
+///
+/// The upstream engine processes this specification through the Iceberg Java
+/// library to validate column types, detect duplicates, and generate the
+/// partition spec that is passed to Velox.
+///
+/// IMPORTANT: Iceberg spec uses field IDs to identify source columns, but
+/// Velox RowType only supports matching fields by name. Therefore, Velox uses
+/// the partition field name to match against the table schema column names.
+/// Callers must ensure that partition field names exactly match the column
+/// names in the table schema.
+///
+/// The partition spec contains:
+/// - Unique ID for versioning and evolution.
+/// - Which source columns in current table schema to use for partitioning
+/// (identified by field name, not field ID as in the Iceberg spec).
+/// - What transforms to apply (identity, bucket, truncate etc.).
+/// - Transform parameters (e.g., bucket count, truncate width).
+struct IcebergPartitionSpec {
+  struct Field {
+    /// Column name as defined in table schema. This column's value is used to
+    /// compute partition key by applying 'transformType' transformation.
+    const std::string name;
+
+    /// Column type.
+    const TypePtr type;
+
+    /// Transform to apply. Callers must ensure the transform is compatible with
+    /// the column type.
+    const TransformType transformType;
+
+    /// Optional parameter for transforms that require configuration.
+    const std::optional<int32_t> parameter;
+
+    /// Returns the result type after applying this transform.
+    TypePtr resultType() const {
+      switch (transformType) {
+        case TransformType::kBucket:
+        case TransformType::kYear:
+        case TransformType::kMonth:
+        case TransformType::kHour:
+          return INTEGER();
+        case TransformType::kDay:
+          return DATE();
+        case TransformType::kIdentity:
+        case TransformType::kTruncate:
+          return type;
+      }
+      VELOX_UNREACHABLE("Unknown transform type");
+    }
+  };
+
+  const int32_t specId;
+  const std::vector<Field> fields;
+
+  /// Constructor with validation that:
+  /// - Each field's type is supported for partitioning.
+  /// - Each field's transform type is compatible with its data type.
+  /// - No transform category appears more than once per column (Identity,
+  ///   Temporal, Bucket, and Truncate are separate categories).
+  ///
+  /// @param _specId Partition specification ID.
+  /// @param _fields Vector of partition fields. When empty indicates no
+  /// partition.
+  /// @throws VeloxUserError if validation fails.
+  IcebergPartitionSpec(int32_t _specId, std::vector<Field> _fields)
+      : specId(_specId), fields(std::move(_fields)) {
+    checkCompatibility();
+  }
+
+ private:
+  // Validates partition fields for correctness.
+  // Checks type/transform compatibility and transform combination rules.
+  void checkCompatibility() const;
+};
+
+using IcebergPartitionSpecPtr = std::shared_ptr<const IcebergPartitionSpec>;
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/PositionalDeleteFileReader.cpp b/velox/connectors/hive/iceberg/PositionalDeleteFileReader.cpp
index d36550ac66a..4dd3100eb4a 100644
--- a/velox/connectors/hive/iceberg/PositionalDeleteFileReader.cpp
+++ b/velox/connectors/hive/iceberg/PositionalDeleteFileReader.cpp
@@ -16,8 +16,8 @@
 
 #include "velox/connectors/hive/iceberg/PositionalDeleteFileReader.h"
 
-#include "velox/connectors/hive/HiveConnectorUtil.h"
-#include "velox/connectors/hive/TableHandle.h"
+#include "velox/connectors/hive/BufferedInputBuilder.h"
+#include "velox/connectors/hive/FileConnectorUtil.h"
 #include "velox/connectors/hive/iceberg/IcebergDeleteFile.h"
 #include "velox/connectors/hive/iceberg/IcebergMetadataColumns.h"
 #include "velox/dwio/common/ReaderFactory.h"
@@ -30,9 +30,9 @@ PositionalDeleteFileReader::PositionalDeleteFileReader(
     FileHandleFactory* fileHandleFactory,
     const ConnectorQueryCtx* connectorQueryCtx,
     folly::Executor* executor,
-    const std::shared_ptr<const HiveConfig>& hiveConfig,
-    const std::shared_ptr<io::IoStatistics>& ioStats,
-    const std::shared_ptr<filesystems::File::IoStats>& fsStats,
+    const std::shared_ptr<const FileConfig>& fileConfig,
+    const std::shared_ptr<io::IoStatistics>& ioStatistics,
+    const std::shared_ptr<IoStats>& ioStats,
     dwio::common::RuntimeStatistics& runtimeStats,
     uint64_t splitOffset,
     const std::string& connectorId)
@@ -41,9 +41,9 @@ PositionalDeleteFileReader::PositionalDeleteFileReader(
       fileHandleFactory_(fileHandleFactory),
       executor_(executor),
       connectorQueryCtx_(connectorQueryCtx),
-      hiveConfig_(hiveConfig),
+      fileConfig_(fileConfig),
+      ioStatistics_(ioStatistics),
       ioStats_(ioStats),
-      fsStats_(fsStats),
       pool_(connectorQueryCtx->memoryPool()),
       filePathColumn_(IcebergMetadataColumn::icebergDeleteFilePathColumn()),
       posColumn_(IcebergMetadataColumn::icebergDeletePosColumn()),
@@ -56,15 +56,13 @@ PositionalDeleteFileReader::PositionalDeleteFileReader(
   VELOX_CHECK(deleteFile_.content == FileContent::kPositionalDeletes);
   VELOX_CHECK(deleteFile_.recordCount);
 
-  // TODO: check if the lowerbounds and upperbounds in deleteFile overlap with
-  //  this batch. If not, no need to proceed.
-
   // Create the ScanSpec for this delete file
   auto scanSpec = std::make_shared<common::ScanSpec>("<root>");
   scanSpec->addField(posColumn_->name, 0);
   auto* pathSpec = scanSpec->getOrCreateChild(filePathColumn_->name);
-  pathSpec->setFilter(std::make_unique<common::BytesValues>(
-      std::vector<std::string>({baseFilePath_}), false));
+  pathSpec->setFilter(
+      std::make_unique<common::BytesValues>(
+          std::vector<std::string>({baseFilePath_}), false));
 
   // Create the file schema (in RowType) and split that will be used by readers
   std::vector<std::string> deleteColumnNames(
@@ -84,8 +82,11 @@ PositionalDeleteFileReader::PositionalDeleteFileReader(
   // Create the Reader and RowReader
 
   dwio::common::ReaderOptions deleteReaderOpts(pool_);
+  // TODO: Use separate IoStatistics for data and metadata.
+  deleteReaderOpts.setDataIoStats(ioStatistics_);
+  deleteReaderOpts.setMetadataIoStats(ioStatistics_);
   configureReaderOptions(
-      hiveConfig_,
+      fileConfig_,
       connectorQueryCtx,
       deleteFileSchema,
       deleteSplit_,
@@ -96,12 +97,12 @@ PositionalDeleteFileReader::PositionalDeleteFileReader(
       .filename = deleteFile_.filePath,
       .tokenProvider = connectorQueryCtx_->fsTokenProvider()};
   auto deleteFileHandleCachePtr = fileHandleFactory_->generate(fileHandleKey);
-  auto deleteFileInput = createBufferedInput(
+  auto deleteFileInput = BufferedInputBuilder::getInstance()->create(
       *deleteFileHandleCachePtr,
       deleteReaderOpts,
       connectorQueryCtx,
+      ioStatistics_,
       ioStats_,
-      fsStats_,
       executor_);
 
   auto deleteReader =
@@ -118,7 +119,7 @@ PositionalDeleteFileReader::PositionalDeleteFileReader(
           deleteSplit_->filePath,
           deleteSplit_->partitionKeys,
           {},
-          hiveConfig_->readTimestampPartitionValueAsLocalTime(
+          fileConfig_->readTimestampPartitionValueAsLocalTime(
               connectorQueryCtx_->sessionProperties()))) {
     // We only count the number of base splits skipped as skippedSplits runtime
     // statistics in Velox.  Skipped delta split is only counted as skipped
@@ -137,6 +138,7 @@ PositionalDeleteFileReader::PositionalDeleteFileReader(
       deleteSplit_,
       nullptr,
       nullptr,
+      nullptr,
       deleteRowReaderOpts);
 
   deleteRowReader_.reset();
@@ -251,15 +253,17 @@ void PositionalDeleteFileReader::updateDeleteBitmap(
     deletePositionsOffset_++;
   }
 
-  deleteBitmapBuffer->setSize(std::max(
-      static_cast<uint64_t>(deleteBitmapBuffer->size()),
-      deletePositionsOffset_ == 0 ||
-              (deletePositionsOffset_ < deletePositionsVector->size() &&
-               deletePositions[deletePositionsOffset_] >= rowNumberUpperBound)
-          ? 0
-          : bits::nbytes(
-                deletePositions[deletePositionsOffset_ - 1] + 1 -
-                rowNumberLowerBound)));
+  deleteBitmapBuffer->setSize(
+      std::max(
+          static_cast<uint64_t>(deleteBitmapBuffer->size()),
+          deletePositionsOffset_ == 0 ||
+                  (deletePositionsOffset_ < deletePositionsVector->size() &&
+                   deletePositions[deletePositionsOffset_] >=
+                       rowNumberUpperBound)
+              ? 0
+              : bits::nbytes(
+                    deletePositions[deletePositionsOffset_ - 1] + 1 -
+                    rowNumberLowerBound)));
 }
 
 bool PositionalDeleteFileReader::readFinishedForBatch(
diff --git a/velox/connectors/hive/iceberg/PositionalDeleteFileReader.h b/velox/connectors/hive/iceberg/PositionalDeleteFileReader.h
index 211359d7fb9..7367de7818d 100644
--- a/velox/connectors/hive/iceberg/PositionalDeleteFileReader.h
+++ b/velox/connectors/hive/iceberg/PositionalDeleteFileReader.h
@@ -20,74 +20,139 @@
 #include <memory>
 
 #include "velox/connectors/Connector.h"
+#include "velox/connectors/hive/FileConfig.h"
 #include "velox/connectors/hive/FileHandle.h"
-#include "velox/connectors/hive/HiveConfig.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/connectors/hive/iceberg/IcebergDeleteFile.h"
+#include "velox/connectors/hive/iceberg/IcebergMetadataColumns.h"
 #include "velox/dwio/common/Reader.h"
 
 namespace facebook::velox::connector::hive::iceberg {
 
-struct IcebergDeleteFile;
-struct IcebergMetadataColumn;
-
+/// Reads a positional delete file and produces a deletion bitmap for the base
+/// data during merge-on-read. The delete file schema per the Iceberg V2 spec
+/// is:
+///   (file_path: VARCHAR, pos: BIGINT)
+///
+/// For each row in the delete file matching the base data file path, this
+/// reader records the deleted row position. During read, these positions are
+/// converted into a bitmap where set bits indicate rows that should be excluded
+/// from the output.
+///
+/// The reader processes delete positions incrementally, batch by batch.
+/// Positions from the delete file that fall within the current batch range are
+/// converted to bitmap bits. Leftover positions beyond the current batch are
+/// preserved and carried over to the next readDeletePositions() call.
 class PositionalDeleteFileReader {
  public:
+  /// Constructs a reader for a single positional delete file.
+  ///
+  /// Opens the delete file, sets up a filter on file_path = baseFilePath to
+  /// read only delete positions relevant to the current base data file, and
+  /// applies testFilters() to skip the entire delete file when possible (e.g.,
+  /// when the delete file contains no entries for this base file).
+  ///
+  /// @param deleteFile Metadata about the delete file (path, format, bounds,
+  ///   record count).
+  /// @param baseFilePath Path of the base data file being read. Used to filter
+  ///   delete records that apply to this specific data file.
+  /// @param fileHandleFactory Factory for creating file handles.
+  /// @param connectorQueryCtx Query context providing memory pool, session
+  ///   properties, and filesystem token.
+  /// @param executor Executor for async I/O operations.
+  /// @param fileConfig Hive connector configuration.
+  /// @param ioStatistics Shared I/O statistics counters.
+  /// @param ioStats Shared I/O stats tracker.
+  /// @param runtimeStats Runtime statistics to record skipped bytes when the
+  ///   delete file is filtered out entirely.
+  /// @param splitOffset Row number offset of the current split within the base
+  ///   data file. Delete positions are absolute within the file, so this offset
+  ///   is used to translate them to split-relative positions.
+  /// @param connectorId Connector ID for constructing the internal split.
   PositionalDeleteFileReader(
       const IcebergDeleteFile& deleteFile,
       const std::string& baseFilePath,
       FileHandleFactory* fileHandleFactory,
       const ConnectorQueryCtx* connectorQueryCtx,
       folly::Executor* executor,
-      const std::shared_ptr<const HiveConfig>& hiveConfig,
-      const std::shared_ptr<io::IoStatistics>& ioStats,
-      const std::shared_ptr<filesystems::File::IoStats>& fsStats,
+      const std::shared_ptr<const FileConfig>& fileConfig,
+      const std::shared_ptr<io::IoStatistics>& ioStatistics,
+      const std::shared_ptr<IoStats>& ioStats,
       dwio::common::RuntimeStatistics& runtimeStats,
       uint64_t splitOffset,
       const std::string& connectorId);
 
+  /// Reads delete positions for the current batch and sets corresponding bits
+  /// in the deletion bitmap.
+  ///
+  /// Processes delete positions in the range
+  /// [splitOffset + baseReadOffset, splitOffset + baseReadOffset + size).
+  /// Positions from the delete file that fall within this range have their
+  /// corresponding bits set in deleteBitmap. Positions beyond the range are
+  /// buffered for subsequent calls.
+  ///
+  /// @param baseReadOffset The read offset from the beginning of the split in
+  ///   number of rows for the current batch.
+  /// @param size The number of rows in the current batch, before deletion.
+  /// @param deleteBitmap Output bitmap buffer where set bits mark rows to
+  ///   delete. Bit positions are relative to baseReadOffset within the split.
   void readDeletePositions(
       uint64_t baseReadOffset,
       uint64_t size,
       BufferPtr deleteBitmap);
 
+  /// Returns true when all delete positions have been read and consumed from
+  /// this file.
   bool noMoreData();
 
  private:
+  // Converts delete positions from deletePositionsVector into set bits in the
+  // deleteBitmapBuffer for positions within
+  // [splitOffset + baseReadOffset, rowNumberUpperBound).
   void updateDeleteBitmap(
       VectorPtr deletePositionsVector,
       uint64_t baseReadOffset,
       int64_t rowNumberUpperBound,
       BufferPtr deleteBitmapBuffer);
 
+  // Returns true if enough delete positions have been read for the current
+  // batch, either because EOF or the next unprocessed position >=
+  // rowNumberUpperBound.
   bool readFinishedForBatch(int64_t rowNumberUpperBound);
 
-  const IcebergDeleteFile& deleteFile_;
-  const std::string& baseFilePath_;
+  const IcebergDeleteFile deleteFile_;
+  const std::string baseFilePath_;
   FileHandleFactory* const fileHandleFactory_;
   folly::Executor* const executor_;
-  const ConnectorQueryCtx* connectorQueryCtx_;
-  const std::shared_ptr<const HiveConfig> hiveConfig_;
-  const std::shared_ptr<io::IoStatistics> ioStats_;
-  const std::shared_ptr<filesystems::File::IoStats> fsStats_;
-  const std::shared_ptr<filesystems::File::IoStats> fsStats;
+  const ConnectorQueryCtx* const connectorQueryCtx_;
+  const std::shared_ptr<const FileConfig> fileConfig_;
+  const std::shared_ptr<io::IoStatistics> ioStatistics_;
+  const std::shared_ptr<IoStats> ioStats_;
   memory::MemoryPool* const pool_;
 
-  std::shared_ptr<IcebergMetadataColumn> filePathColumn_;
-  std::shared_ptr<IcebergMetadataColumn> posColumn_;
-  uint64_t splitOffset_;
+  // Iceberg metadata column descriptors for the delete file schema.
+  const std::shared_ptr<IcebergMetadataColumn> filePathColumn_;
+  const std::shared_ptr<IcebergMetadataColumn> posColumn_;
+
+  // Row number offset of the current split within the base data file.
+  const uint64_t splitOffset_;
 
+  // Internal split and row reader for the delete file. Reset to nullptr when
+  // the delete file is fully consumed or skipped by testFilters().
   std::shared_ptr<HiveConnectorSplit> deleteSplit_;
   std::unique_ptr<dwio::common::RowReader> deleteRowReader_;
-  // The vector to hold the delete positions read from the positional delete
-  // file. These positions are relative to the start of the whole base data
-  // file.
+
+  // Holds the raw output from reading the delete file. Contains a RowVector
+  // with a single pos column. Positions are absolute row numbers within the
+  // base data file.
   VectorPtr deletePositionsOutput_;
-  // The index of deletePositionsOutput_ that indicates up to where the delete
-  // positions have been converted into the bitmap
+
+  // Index into deletePositionsOutput_ indicating how far delete positions
+  // have been consumed and converted into bitmap bits.
   uint64_t deletePositionsOffset_;
-  // Total number of rows read from this positional delete file reader,
-  // including the rows filtered out from filters on both filePathColumn_ and
-  // posColumn_.
+
+  // Total number of rows read from this delete file, including rows filtered
+  // out by the file_path filter. Used to detect end-of-file.
   uint64_t totalNumRowsScanned_;
 };
 
diff --git a/velox/connectors/hive/iceberg/TransformEvaluator.cpp b/velox/connectors/hive/iceberg/TransformEvaluator.cpp
new file mode 100644
index 00000000000..2744bddafa7
--- /dev/null
+++ b/velox/connectors/hive/iceberg/TransformEvaluator.cpp
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/TransformEvaluator.h"
+
+#include "velox/expression/Expr.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+TransformEvaluator::TransformEvaluator(
+    const std::vector<core::TypedExprPtr>& expressions,
+    const ConnectorQueryCtx* connectorQueryCtx)
+    : connectorQueryCtx_(connectorQueryCtx) {
+  VELOX_CHECK_NOT_NULL(connectorQueryCtx_);
+  exprSet_ = connectorQueryCtx_->expressionEvaluator()->compile(expressions);
+  VELOX_CHECK_NOT_NULL(exprSet_);
+}
+
+std::vector<VectorPtr> TransformEvaluator::evaluate(
+    const RowVectorPtr& input) const {
+  const auto numRows = input->size();
+  const auto numExpressions = exprSet_->exprs().size();
+
+  std::vector<VectorPtr> results(numExpressions);
+  SelectivityVector rows(numRows);
+
+  // Evaluate all expressions in one pass.
+  connectorQueryCtx_->expressionEvaluator()->evaluate(
+      exprSet_.get(), rows, *input, results);
+
+  return results;
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/TransformEvaluator.h b/velox/connectors/hive/iceberg/TransformEvaluator.h
new file mode 100644
index 00000000000..ee7b26f7db8
--- /dev/null
+++ b/velox/connectors/hive/iceberg/TransformEvaluator.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/connectors/Connector.h"
+#include "velox/core/QueryCtx.h"
+#include "velox/expression/Expr.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+/// Evaluates multiple expressions efficiently using batch evaluation.
+/// Expressions are compiled once in the constructor and reused across multiple
+/// input batches.
+class TransformEvaluator {
+ public:
+  /// Creates an evaluator with the given expressions and connector query
+  /// context. Compiles the expressions once for reuse across multiple
+  /// evaluations.
+  ///
+  /// @param expressions Vector of typed expressions to evaluate. These are
+  /// typically built using TransformExprBuilder::toExpressions() for Iceberg
+  /// partition transforms, but can be any valid Velox expressions. The
+  /// expressions are compiled once during construction.
+  /// @param connectorQueryCtx Connector query context providing access to the
+  /// expression evaluator (for compilation and evaluation) and memory pool.
+  /// Must remain valid for the lifetime of this TransformEvaluator.
+  TransformEvaluator(
+      const std::vector<core::TypedExprPtr>& expressions,
+      const ConnectorQueryCtx* connectorQueryCtx);
+
+  /// Evaluates all expressions on the input data in a single pass.
+  /// Uses the pre-compiled ExprSet from the constructor for efficiency.
+  ///
+  /// The input RowType must match the RowType used when building the
+  /// expressions (passed to TransformExprBuilder::toExpressions). The column
+  /// positions, names and types must align. Create new TransformEvaluator for
+  /// input that has different RowType with the one when building the
+  /// expressions.
+  ///
+  /// @param input Input row vector containing the source data. Must have the
+  /// same RowType (column positions, names and types) as used when building the
+  /// expressions in the constructor.
+  /// @return Vector of result columns, one for each expression, in the same
+  /// order as the expressions provided to the constructor.
+  std::vector<VectorPtr> evaluate(const RowVectorPtr& input) const;
+
+ private:
+  const ConnectorQueryCtx* connectorQueryCtx_;
+  std::unique_ptr<exec::ExprSet> exprSet_;
+};
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/TransformExprBuilder.cpp b/velox/connectors/hive/iceberg/TransformExprBuilder.cpp
new file mode 100644
index 00000000000..4befbfb50b0
--- /dev/null
+++ b/velox/connectors/hive/iceberg/TransformExprBuilder.cpp
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/connectors/hive/iceberg/TransformExprBuilder.h"
+#include "velox/core/Expressions.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+namespace {
+
+/// Converts a single partition field to a typed expression.
+///
+/// Builds an expression tree for one partition transform. Identity transforms
+/// become FieldAccessTypedExpr, while other transforms (bucket, truncate,
+/// year, month, day, hour) become CallTypedExpr with appropriate function
+/// names and parameters.
+///
+/// @param field Partition field containing transform type, source column
+/// type, and optional parameter (e.g., bucket count, truncate width).
+/// @param inputFieldName Name of the source column in the input RowVector.
+/// @param icebergFuncPrefix Prefix of iceberg transform function names.
+/// @return Typed expression representing the transform.
+core::TypedExprPtr toExpression(
+    const IcebergPartitionSpec::Field& field,
+    const std::string& inputFieldName,
+    const std::string& icebergFuncPrefix) {
+  // For identity transform, just return a field access expression.
+  if (field.transformType == TransformType::kIdentity) {
+    return std::make_shared<core::FieldAccessTypedExpr>(
+        field.type, inputFieldName);
+  }
+
+  // For other transforms, build a CallTypedExpr with the appropriate function.
+  std::string functionName;
+  switch (field.transformType) {
+    case TransformType::kBucket:
+      functionName = icebergFuncPrefix + "bucket";
+      break;
+    case TransformType::kTruncate:
+      functionName = icebergFuncPrefix + "truncate";
+      break;
+    case TransformType::kYear:
+      functionName = icebergFuncPrefix + "years";
+      break;
+    case TransformType::kMonth:
+      functionName = icebergFuncPrefix + "months";
+      break;
+    case TransformType::kDay:
+      functionName = icebergFuncPrefix + "days";
+      break;
+    case TransformType::kHour:
+      functionName = icebergFuncPrefix + "hours";
+      break;
+    case TransformType::kIdentity:
+      break;
+  }
+
+  // Build the expression arguments.
+  std::vector<core::TypedExprPtr> exprArgs;
+  if (field.parameter.has_value()) {
+    exprArgs.emplace_back(
+        std::make_shared<core::ConstantTypedExpr>(
+            INTEGER(), Variant(field.parameter.value())));
+  }
+  exprArgs.emplace_back(
+      std::make_shared<core::FieldAccessTypedExpr>(field.type, inputFieldName));
+
+  return std::make_shared<core::CallTypedExpr>(
+      field.resultType(), std::move(exprArgs), functionName);
+}
+
+} // namespace
+
+std::vector<core::TypedExprPtr> TransformExprBuilder::toExpressions(
+    const IcebergPartitionSpecPtr& partitionSpec,
+    const std::vector<column_index_t>& partitionChannels,
+    const RowTypePtr& inputType,
+    const std::string& icebergFuncPrefix) {
+  VELOX_CHECK_EQ(
+      partitionSpec->fields.size(),
+      partitionChannels.size(),
+      "Number of partition fields must match number of partition channels");
+
+  const auto numTransforms = partitionChannels.size();
+  std::vector<core::TypedExprPtr> transformExprs;
+  transformExprs.reserve(numTransforms);
+
+  for (auto i = 0; i < numTransforms; i++) {
+    const auto channel = partitionChannels[i];
+    transformExprs.emplace_back(toExpression(
+        partitionSpec->fields.at(i),
+        inputType->nameOf(channel),
+        icebergFuncPrefix));
+  }
+
+  return transformExprs;
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/TransformExprBuilder.h b/velox/connectors/hive/iceberg/TransformExprBuilder.h
new file mode 100644
index 00000000000..b583adcf97d
--- /dev/null
+++ b/velox/connectors/hive/iceberg/TransformExprBuilder.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/connectors/hive/iceberg/PartitionSpec.h"
+#include "velox/expression/Expr.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+/// Converts Iceberg partition specification to Velox expressions.
+class TransformExprBuilder {
+ public:
+  /// Converts partition specification to a list of typed expressions.
+  ///
+  /// @param partitionSpec Iceberg partition specification containing transform
+  /// definitions for each partition field.
+  /// @param partitionChannels Column indices (0-based) in the input RowVector
+  /// that correspond to each partition field. Must have the same size as
+  /// partitionSpec->fields. Provides the positional mapping from partition spec
+  /// fields to input RowVector columns.
+  /// @param inputType The row type of the input data. This is necessary for
+  /// building expressions because the column names in partitionSpec reference
+  /// table schema names, which might not match the column names in inputType
+  /// (e.g., inputType may use generated names like c0, c1, c2). The
+  /// FieldAccessTypedExpr must be built using the actual column names from
+  /// inputType that will be present at runtime. The partitionChannels provide
+  /// the positional mapping to locate the correct columns.
+  /// @param icebergFuncPrefix Prefix for Iceberg transform function names.
+  /// @return Vector of typed expressions, one for each partition field.
+  static std::vector<core::TypedExprPtr> toExpressions(
+      const IcebergPartitionSpecPtr& partitionSpec,
+      const std::vector<column_index_t>& partitionChannels,
+      const RowTypePtr& inputType,
+      const std::string& icebergFuncPrefix);
+};
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/WriterOptionsAdapter.cpp b/velox/connectors/hive/iceberg/WriterOptionsAdapter.cpp
new file mode 100644
index 00000000000..8bd0fc08e75
--- /dev/null
+++ b/velox/connectors/hive/iceberg/WriterOptionsAdapter.cpp
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/WriterOptionsAdapter.h"
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/dwio/dwrf/writer/Writer.h"
+#include "velox/dwio/parquet/writer/WriterConfig.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+namespace {
+
+// Manifest format string emitted in Iceberg commit messages for files that
+// share the ORC on-disk family. Iceberg's manifest vocabulary has no DWRF or
+// NIMBLE enum, so DWRF and NIMBLE files are reported as "ORC" per the
+// cross-engine convention shared with the Java planner (see
+// FileFormat.{DWRF,NIMBLE}.toIceberg() in presto-facebook-iceberg).
+constexpr std::string_view kOrcManifestFormat{"ORC"};
+
+class ParquetWriterOptionsAdapter : public WriterOptionsAdapter {
+ public:
+  std::string manifestFormatString() const override {
+    return "PARQUET";
+  }
+
+  void applyPreConfigs(dwio::common::WriterOptions& options) const override {
+    // Per Iceberg spec (https://iceberg.apache.org/spec/#parquet):
+    // - Timestamps must be stored with microsecond precision.
+    // - Timestamps must NOT be adjusted to UTC; written as-is without
+    //   timezone conversion (empty string disables conversion).
+    //
+    // Settings are routed through serdeParameters to avoid pulling in
+    // parquet-specific headers. Keys must match
+    // kParquetSerdeTimestampUnit and kParquetSerdeTimestampTimezone in
+    // velox/dwio/parquet/writer/Writer.h. The value "6" represents
+    // microseconds (TimestampPrecision::kMicroseconds).
+    options.serdeParameters[parquet::WriterConfig::kParquetSerdeTimestampUnit] =
+        "6";
+    options.serdeParameters
+        [parquet::WriterConfig::kParquetSerdeTimestampTimezone] = "";
+  }
+};
+
+class DwrfWriterOptionsAdapter : public WriterOptionsAdapter {
+ public:
+  std::string manifestFormatString() const override {
+    return std::string{kOrcManifestFormat};
+  }
+
+  void applyPostConfigs(dwio::common::WriterOptions& options) const override {
+    // DWRF stores microsecond-precision timestamps natively, so no
+    // precision conversion is required; only timezone adjustment must be
+    // disabled per the Iceberg spec. Unlike Parquet, DWRF exposes
+    // timestamp configuration as direct fields on dwrf::WriterOptions
+    // rather than serdeParameters.
+    auto* dwrfOptions = dynamic_cast<dwrf::WriterOptions*>(&options);
+    if (dwrfOptions == nullptr) {
+      return;
+    }
+    dwrfOptions->adjustTimestampToTimezone = false;
+    dwrfOptions->sessionTimezone = nullptr;
+  }
+};
+
+class NimbleWriterOptionsAdapter : public WriterOptionsAdapter {
+ public:
+  // Reports NIMBLE files as ORC in the manifest so cross-engine readers
+  // (Presto coordinator, catalog) can interpret the commit message. The
+  // actual on-disk format is identified at read time via the file
+  // extension and on-disk magic bytes, not via this string.
+  std::string manifestFormatString() const override {
+    return std::string{kOrcManifestFormat};
+  }
+};
+
+} // namespace
+
+std::unique_ptr<WriterOptionsAdapter> createWriterOptionsAdapter(
+    dwio::common::FileFormat format) {
+  // ORC is intentionally excluded until a dedicated ORC end-to-end test
+  // exists.
+  // NOLINTNEXTLINE(clang-diagnostic-switch-enum)
+  switch (format) {
+    case dwio::common::FileFormat::PARQUET:
+      return std::make_unique<ParquetWriterOptionsAdapter>();
+    case dwio::common::FileFormat::DWRF:
+      return std::make_unique<DwrfWriterOptionsAdapter>();
+    case dwio::common::FileFormat::NIMBLE:
+      return std::make_unique<NimbleWriterOptionsAdapter>();
+    default:
+      return nullptr;
+  }
+}
+
+bool isSupportedFileFormat(dwio::common::FileFormat format) {
+  return createWriterOptionsAdapter(format) != nullptr;
+}
+
+std::string toManifestFormatString(dwio::common::FileFormat format) {
+  auto adapter = createWriterOptionsAdapter(format);
+  VELOX_CHECK_NOT_NULL(
+      adapter,
+      "Unsupported file format for Iceberg manifest: {}",
+      dwio::common::toString(format));
+  return adapter->manifestFormatString();
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/WriterOptionsAdapter.h b/velox/connectors/hive/iceberg/WriterOptionsAdapter.h
new file mode 100644
index 00000000000..29dae1dd7ee
--- /dev/null
+++ b/velox/connectors/hive/iceberg/WriterOptionsAdapter.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "velox/dwio/common/Options.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+/// Format-specific adapter for an Iceberg-bound WriterOptions instance.
+/// Encapsulates the per-file-format behavior (manifest format string,
+/// pre/post-processConfigs hooks on the writer options) behind a virtual
+/// interface. Dispatched at runtime via createWriterOptionsAdapter() based
+/// on the table's storage format.
+class WriterOptionsAdapter {
+ public:
+  virtual ~WriterOptionsAdapter() = default;
+
+  /// Identifier reported in Iceberg manifest commit messages. Iceberg's
+  /// file-format vocabulary has no DWRF enum; per the Iceberg SDK
+  /// convention, DWRF files are reported as "ORC" so downstream consumers
+  /// (Presto coordinator, catalog) can interpret the commit message.
+  virtual std::string manifestFormatString() const = 0;
+
+  /// Hook applied to WriterOptions BEFORE processConfigs() runs. Used for
+  /// settings that flow through serdeParameters.
+  virtual void applyPreConfigs(dwio::common::WriterOptions& /*options*/) const {
+  }
+
+  /// Hook applied to WriterOptions AFTER processConfigs() runs. Used for
+  /// direct field assignments that must not be overwritten by
+  /// config-driven processing.
+  virtual void applyPostConfigs(
+      dwio::common::WriterOptions& /*options*/) const {}
+};
+
+/// Returns the adapter for the given file format, or nullptr for
+/// unsupported formats. Single source of truth for which file formats the
+/// Iceberg DataSink supports on the write path.
+std::unique_ptr<WriterOptionsAdapter> createWriterOptionsAdapter(
+    dwio::common::FileFormat format);
+
+/// True if the Iceberg DataSink can write the given file format.
+bool isSupportedFileFormat(dwio::common::FileFormat format);
+
+/// Maps a Velox file format to the string used in Iceberg manifest commit
+/// messages. Throws if the format is not supported.
+std::string toManifestFormatString(dwio::common::FileFormat format);
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/tests/CMakeLists.txt b/velox/connectors/hive/iceberg/tests/CMakeLists.txt
index 3e54d543175..8931bb6d0e9 100644
--- a/velox/connectors/hive/iceberg/tests/CMakeLists.txt
+++ b/velox/connectors/hive/iceberg/tests/CMakeLists.txt
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 add_library(velox_dwio_iceberg_reader_benchmark_lib IcebergSplitReaderBenchmark.cpp)
+velox_add_test_headers(velox_dwio_iceberg_reader_benchmark_lib IcebergSplitReaderBenchmark.h)
 target_link_libraries(
   velox_dwio_iceberg_reader_benchmark_lib
   velox_exec_test_lib
@@ -30,6 +31,7 @@ if(VELOX_ENABLE_BENCHMARKS)
     velox_exec_test_lib
     velox_exec
     velox_hive_connector
+    velox_hive_iceberg_splitreader
     Folly::folly
     Folly::follybenchmark
     ${TEST_LINK_LIBS}
@@ -56,9 +58,118 @@ if(NOT VELOX_DISABLE_GOOGLETEST)
     GTest::gtest
     GTest::gtest_main
   )
+
+  add_executable(
+    velox_hive_iceberg_insert_test
+    IcebergConnectorTest.cpp
+    IcebergInsertTest.cpp
+    IcebergParquetStatsTest.cpp
+    IcebergTestBase.cpp
+    Main.cpp
+    PartitionNameTest.cpp
+    PartitionSpecTest.cpp
+    PartitionValueFormatterTest.cpp
+    TransformE2ETest.cpp
+    TransformTest.cpp
+  )
+  velox_add_test_headers(velox_hive_iceberg_insert_test IcebergTestBase.h)
+
+  add_test(velox_hive_iceberg_insert_test velox_hive_iceberg_insert_test)
+
+  target_link_libraries(
+    velox_hive_iceberg_insert_test
+    velox_exec_test_lib
+    velox_hive_connector
+    velox_hive_iceberg_splitreader
+    velox_vector_fuzzer
+    GTest::gtest
+    GTest::gtest_main
+  )
+
+  add_executable(velox_hive_iceberg_deletion_vector_test DeletionVectorReaderTest.cpp)
+  add_test(velox_hive_iceberg_deletion_vector_test velox_hive_iceberg_deletion_vector_test)
+
+  target_link_libraries(
+    velox_hive_iceberg_deletion_vector_test
+    velox_hive_connector
+    velox_hive_iceberg_splitreader
+    velox_exec_test_lib
+    velox_dwio_common_test_utils
+    GTest::gtest
+    GTest::gtest_main
+  )
+
   if(VELOX_ENABLE_PARQUET)
     target_link_libraries(velox_hive_iceberg_test velox_dwio_parquet_reader)
 
     file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/examples DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+
+    target_link_libraries(
+      velox_hive_iceberg_insert_test
+      velox_dwio_parquet_reader
+      velox_dwio_parquet_writer
+    )
   endif()
+
+  add_executable(velox_hive_iceberg_equality_delete_test EqualityDeleteFileReaderTest.cpp Main.cpp)
+  add_test(velox_hive_iceberg_equality_delete_test velox_hive_iceberg_equality_delete_test)
+
+  target_link_libraries(
+    velox_hive_iceberg_equality_delete_test
+    velox_hive_connector
+    velox_hive_iceberg_splitreader
+    velox_exec_test_lib
+    velox_dwio_common_test_utils
+    GTest::gtest
+  )
+
+  add_executable(velox_hive_iceberg_deletion_vector_writer_test DeletionVectorWriterTest.cpp)
+  add_test(
+    velox_hive_iceberg_deletion_vector_writer_test
+    velox_hive_iceberg_deletion_vector_writer_test
+  )
+
+  target_link_libraries(
+    velox_hive_iceberg_deletion_vector_writer_test
+    velox_hive_connector
+    velox_hive_iceberg_splitreader
+    velox_exec_test_lib
+    velox_dwio_common_test_utils
+    GTest::gtest
+    GTest::gtest_main
+  )
+
+  add_executable(
+    velox_hive_iceberg_dwrf_insert_test
+    IcebergDwrfInsertTest.cpp
+    IcebergTestBase.cpp
+    Main.cpp
+  )
+  add_test(velox_hive_iceberg_dwrf_insert_test velox_hive_iceberg_dwrf_insert_test)
+
+  target_link_libraries(
+    velox_hive_iceberg_dwrf_insert_test
+    velox_hive_connector
+    velox_hive_iceberg_splitreader
+    velox_exec_test_lib
+    velox_dwio_common_test_utils
+    velox_dwio_dwrf_reader
+    velox_dwio_dwrf_writer
+    velox_dwio_parquet_reader
+    velox_dwio_parquet_writer
+    GTest::gtest
+    GTest::gtest_main
+  )
+
+  add_executable(velox_hive_writer_options_adapter_test WriterOptionsAdapterTest.cpp)
+  add_test(velox_hive_writer_options_adapter_test velox_hive_writer_options_adapter_test)
+
+  target_link_libraries(
+    velox_hive_writer_options_adapter_test
+    velox_hive_connector
+    velox_hive_iceberg_splitreader
+    velox_dwio_common_exception
+    GTest::gtest
+    GTest::gtest_main
+  )
 endif()
diff --git a/velox/connectors/hive/iceberg/tests/DeletionVectorReaderTest.cpp b/velox/connectors/hive/iceberg/tests/DeletionVectorReaderTest.cpp
new file mode 100644
index 00000000000..001443fffbf
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/DeletionVectorReaderTest.cpp
@@ -0,0 +1,613 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/DeletionVectorReader.h"
+
+#include <fstream>
+
+#include <gtest/gtest.h>
+
+#include "velox/common/base/BitUtil.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/common/memory/Memory.h"
+#include "velox/common/testutil/TempFilePath.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::connector::hive::iceberg;
+using namespace facebook::velox::common::testutil;
+
+namespace {
+
+// Serializes a roaring bitmap in the portable format (no-run variant,
+// cookie = 12346). Supports only array containers (cardinality <= 4096).
+// This is the simplest format the DeletionVectorReader needs to parse.
+std::string serializeRoaringBitmapNoRun(const std::vector<int64_t>& positions) {
+  if (positions.empty()) {
+    // Empty bitmap: cookie + 0 containers.
+    std::string data(8, '\0');
+    uint32_t cookie = 12346;
+    uint32_t numContainers = 0;
+    std::memcpy(data.data(), &cookie, 4);
+    std::memcpy(data.data() + 4, &numContainers, 4);
+    return data;
+  }
+
+  // Group positions by high 16 bits.
+  std::map<uint16_t, std::vector<uint16_t>> containers;
+  for (auto pos : positions) {
+    auto key = static_cast<uint16_t>(pos >> 16);
+    auto low = static_cast<uint16_t>(pos & 0xFFFF);
+    containers[key].push_back(low);
+  }
+
+  for (auto& [key, vals] : containers) {
+    std::sort(vals.begin(), vals.end());
+  }
+
+  uint32_t numContainers = static_cast<uint32_t>(containers.size());
+
+  std::string data;
+  // Cookie.
+  constexpr uint32_t cookie = 12346;
+  data.append(reinterpret_cast<const char*>(&cookie), 4);
+  // Container count.
+  data.append(reinterpret_cast<const char*>(&numContainers), 4);
+
+  // Key-cardinality pairs.
+  for (auto& [key, vals] : containers) {
+    uint16_t cardMinus1 = static_cast<uint16_t>(vals.size() - 1);
+    data.append(reinterpret_cast<const char*>(&key), 2);
+    data.append(reinterpret_cast<const char*>(&cardMinus1), 2);
+  }
+
+  // Offset section (required for > 0 containers)
+  if (numContainers > 0) {
+    uint32_t offset = 4 + 4 + numContainers * 4 + numContainers * 4;
+    for (auto& [key, vals] : containers) {
+      data.append(reinterpret_cast<const char*>(&offset), 4);
+      offset += static_cast<uint32_t>(vals.size()) * 2;
+    }
+  }
+
+  // Container data (array containers: sorted uint16 values).
+  for (auto& [key, vals] : containers) {
+    for (auto v : vals) {
+      data.append(reinterpret_cast<const char*>(&v), 2);
+    }
+  }
+
+  return data;
+}
+
+// Serializes a roaring bitmap in the portable format with run containers
+// (cookie = 12347). All containers are run-encoded.
+std::string serializeRoaringBitmapWithRuns(
+    const std::vector<
+        std::pair<uint16_t, std::vector<std::pair<uint16_t, uint16_t>>>>&
+        containerRuns) {
+  // containerRuns: vector of (highBitsKey, vector of (start, lengthMinus1)).
+  uint32_t numContainers = static_cast<uint32_t>(containerRuns.size());
+
+  // Cookie: low 16 bits = 12347, high 16 bits = numContainers - 1.
+  uint32_t cookie = static_cast<uint32_t>(12347) | ((numContainers - 1) << 16);
+
+  std::string data;
+  data.append(reinterpret_cast<const char*>(&cookie), 4);
+
+  // Run bitmap: all containers are run containers. ceil(numContainers / 8)
+  // bytes.
+  uint32_t runBitmapBytes = (numContainers + 7) / 8;
+  std::vector<uint8_t> runBitmap(runBitmapBytes, 0xFF);
+  data.append(reinterpret_cast<const char*>(runBitmap.data()), runBitmapBytes);
+
+  // Compute cardinality for each container.
+  std::vector<uint32_t> cardinalities;
+  for (auto& [key, runs] : containerRuns) {
+    uint32_t card = 0;
+    for (auto& [start, lenMinus1] : runs) {
+      card += static_cast<uint32_t>(lenMinus1) + 1;
+    }
+    cardinalities.push_back(card);
+  }
+
+  // Key-cardinality pairs.
+  for (size_t i = 0; i < containerRuns.size(); ++i) {
+    uint16_t key = containerRuns[i].first;
+    uint16_t cardMinus1 = static_cast<uint16_t>(cardinalities[i] - 1);
+    data.append(reinterpret_cast<const char*>(&key), 2);
+    data.append(reinterpret_cast<const char*>(&cardMinus1), 2);
+  }
+
+  // Offset section (required for >= 4)
+  constexpr uint32_t kRunContainersNoOffsetThreshold = 4;
+  if (numContainers >= kRunContainersNoOffsetThreshold) {
+    // First container offset = cookie (4) + runBitmap (runBitmapBytes)
+    // + descriptive header (4 * numContainers) + offset header
+    // (4 * numContainers).
+    uint32_t offset =
+        4 + runBitmapBytes + 4 * numContainers + 4 * numContainers;
+    for (auto& [key, runs] : containerRuns) {
+      data.append(reinterpret_cast<const char*>(&offset), 4);
+      // Each run container occupies 2 + 4 * numRuns bytes.
+      offset += 2 + 4 * static_cast<uint32_t>(runs.size());
+    }
+  }
+
+  // Container data: each run container has numRuns (uint16) followed by
+  // (start, lengthMinus1) pairs.
+  for (auto& [key, runs] : containerRuns) {
+    uint16_t numRuns = static_cast<uint16_t>(runs.size());
+    data.append(reinterpret_cast<const char*>(&numRuns), 2);
+    for (auto& [start, lenMinus1] : runs) {
+      data.append(reinterpret_cast<const char*>(&start), 2);
+      data.append(reinterpret_cast<const char*>(&lenMinus1), 2);
+    }
+  }
+
+  return data;
+}
+
+// Expands a list of run-encoded containers into the full set of positions
+// they represent. Each container is keyed by its high 16 bits and contains
+// runs of (start, lengthMinus1)
+std::vector<uint64_t> expandRuns(
+    const std::vector<
+        std::pair<uint16_t, std::vector<std::pair<uint16_t, uint16_t>>>>&
+        containerRuns) {
+  std::vector<uint64_t> result;
+  for (const auto& [key, runs] : containerRuns) {
+    const uint64_t base = static_cast<uint64_t>(key) * 65536;
+    for (const auto& [start, lengthMinus1] : runs) {
+      for (uint64_t i = 0; i <= lengthMinus1; ++i) {
+        result.push_back(base + start + i);
+      }
+    }
+  }
+  return result;
+}
+
+// Writes binary data to a temp file and returns the path.
+std::shared_ptr<TempFilePath> writeDvFile(const std::string& bitmapData) {
+  auto tempFile = TempFilePath::create();
+  // Write directly via C++ streams since TempFilePath already creates the
+  // file and the local filesystem openFileForWrite may not overwrite.
+  std::ofstream out(tempFile->getPath(), std::ios::binary | std::ios::trunc);
+  VELOX_CHECK(out.good(), "Failed to open temp file for writing");
+  out.write(bitmapData.data(), static_cast<std::streamsize>(bitmapData.size()));
+  out.close();
+  return tempFile;
+}
+
+// Creates an IcebergDeleteFile for a deletion vector. Uses the typed
+/// 'contentOffset' / 'contentLength' fields rather than the legacy bounds-map
+/// encoding.
+IcebergDeleteFile makeDvDeleteFile(
+    const std::string& filePath,
+    uint64_t recordCount,
+    uint64_t fileSize,
+    uint64_t blobOffset = 0,
+    std::optional<uint64_t> blobLength = std::nullopt) {
+  const int64_t contentLength = blobLength.has_value()
+      ? static_cast<int64_t>(blobLength.value())
+      : static_cast<int64_t>(fileSize);
+
+  return IcebergDeleteFile(
+      FileContent::kDeletionVector,
+      filePath,
+      dwio::common::FileFormat::DWRF,
+      recordCount,
+      fileSize,
+      /*equalityFieldIds=*/{},
+      /*lowerBounds=*/{},
+      /*upperBounds=*/{},
+      /*dataSequenceNumber=*/0,
+      /*contentOffset=*/static_cast<int64_t>(blobOffset),
+      /*contentLength=*/contentLength);
+}
+
+// Extracts which bits are set in a bitmap buffer.
+std::vector<uint64_t> getSetBits(const BufferPtr& bitmap, uint64_t size) {
+  auto* raw = bitmap->as<uint8_t>();
+  std::vector<uint64_t> result;
+  for (uint64_t i = 0; i < size; ++i) {
+    if (bits::isBitSet(raw, i)) {
+      result.push_back(i);
+    }
+  }
+  return result;
+}
+
+} // namespace
+
+class DeletionVectorReaderTest : public ::testing::Test {
+ protected:
+  static void SetUpTestSuite() {
+    memory::MemoryManager::initialize(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    filesystems::registerLocalFileSystem();
+    pool_ = memory::memoryManager()->addLeafPool("DeletionVectorReaderTest");
+  }
+
+  BufferPtr allocateBitmap(uint64_t numBits) {
+    auto numBytes = bits::nbytes(numBits);
+    auto buffer = AlignedBuffer::allocate<uint8_t>(numBytes, pool_.get(), 0);
+    return buffer;
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_;
+};
+
+TEST_F(DeletionVectorReaderTest, basicArrayContainer) {
+  // Positions: 0, 5, 10, 99.
+  std::vector<int64_t> positions = {0, 5, 10, 99};
+  auto bitmapData = serializeRoaringBitmapNoRun(positions);
+  auto tempFile = writeDvFile(bitmapData);
+  auto fileSize = static_cast<uint64_t>(bitmapData.size());
+
+  auto dvFile =
+      makeDvDeleteFile(tempFile->getPath(), positions.size(), fileSize);
+
+  DeletionVectorReader reader(dvFile, 0, pool_.get());
+  EXPECT_FALSE(reader.noMoreData());
+
+  auto bitmap = allocateBitmap(100);
+  reader.readDeletePositions(0, 100, bitmap);
+
+  auto setBits = getSetBits(bitmap, 100);
+  EXPECT_EQ(setBits, (std::vector<uint64_t>{0, 5, 10, 99}));
+  EXPECT_TRUE(reader.noMoreData());
+}
+
+TEST_F(DeletionVectorReaderTest, batchRangeFiltering) {
+  // Positions: 10, 20, 30, 40, 50.
+  std::vector<int64_t> positions = {10, 20, 30, 40, 50};
+  auto bitmapData = serializeRoaringBitmapNoRun(positions);
+  auto tempFile = writeDvFile(bitmapData);
+  auto fileSize = static_cast<uint64_t>(bitmapData.size());
+
+  auto dvFile =
+      makeDvDeleteFile(tempFile->getPath(), positions.size(), fileSize);
+
+  DeletionVectorReader reader(dvFile, 0, pool_.get());
+
+  // First batch: rows 0-24 (should contain positions 10, 20).
+  auto bitmap1 = allocateBitmap(25);
+  reader.readDeletePositions(0, 25, bitmap1);
+  auto bits1 = getSetBits(bitmap1, 25);
+  EXPECT_EQ(bits1, (std::vector<uint64_t>{10, 20}));
+  EXPECT_FALSE(reader.noMoreData());
+
+  // Second batch: rows 25-49 (should contain positions 30, 40).
+  auto bitmap2 = allocateBitmap(25);
+  reader.readDeletePositions(25, 25, bitmap2);
+  auto bits2 = getSetBits(bitmap2, 25);
+  EXPECT_EQ(bits2, (std::vector<uint64_t>{5, 15}));
+  EXPECT_FALSE(reader.noMoreData());
+
+  // Third batch: rows 50-74 (should contain position 50).
+  auto bitmap3 = allocateBitmap(25);
+  reader.readDeletePositions(50, 25, bitmap3);
+  auto bits3 = getSetBits(bitmap3, 25);
+  EXPECT_EQ(bits3, (std::vector<uint64_t>{0}));
+  EXPECT_TRUE(reader.noMoreData());
+}
+
+TEST_F(DeletionVectorReaderTest, splitOffset) {
+  // Positions: 100, 105, 110.
+  std::vector<int64_t> positions = {100, 105, 110};
+  auto bitmapData = serializeRoaringBitmapNoRun(positions);
+  auto tempFile = writeDvFile(bitmapData);
+  auto fileSize = static_cast<uint64_t>(bitmapData.size());
+
+  auto dvFile =
+      makeDvDeleteFile(tempFile->getPath(), positions.size(), fileSize);
+
+  // Split starts at row 100.
+  DeletionVectorReader reader(dvFile, 100, pool_.get());
+
+  auto bitmap = allocateBitmap(20);
+  reader.readDeletePositions(0, 20, bitmap);
+
+  // Positions 100, 105, 110 relative to splitOffset=100, baseReadOffset=0
+  // become bit indices 0, 5, 10.
+  auto setBits = getSetBits(bitmap, 20);
+  EXPECT_EQ(setBits, (std::vector<uint64_t>{0, 5, 10}));
+  EXPECT_TRUE(reader.noMoreData());
+}
+
+TEST_F(DeletionVectorReaderTest, splitOffsetWithBaseReadOffset) {
+  // Positions: 200, 210, 220.
+  std::vector<int64_t> positions = {200, 210, 220};
+  auto bitmapData = serializeRoaringBitmapNoRun(positions);
+  auto tempFile = writeDvFile(bitmapData);
+  auto fileSize = static_cast<uint64_t>(bitmapData.size());
+
+  auto dvFile =
+      makeDvDeleteFile(tempFile->getPath(), positions.size(), fileSize);
+
+  // Split starts at row 100.
+  DeletionVectorReader reader(dvFile, 100, pool_.get());
+
+  // First batch: baseReadOffset=100, so file positions [200, 300).
+  // Positions 200, 210, 220 are all in range.
+  auto bitmap = allocateBitmap(100);
+  reader.readDeletePositions(100, 100, bitmap);
+
+  auto setBits = getSetBits(bitmap, 100);
+  EXPECT_EQ(setBits, (std::vector<uint64_t>{0, 10, 20}));
+  EXPECT_TRUE(reader.noMoreData());
+}
+
+TEST_F(DeletionVectorReaderTest, noDeletesInRange) {
+  // Positions: 1000, 2000.
+  std::vector<int64_t> positions = {1000, 2000};
+  auto bitmapData = serializeRoaringBitmapNoRun(positions);
+  auto tempFile = writeDvFile(bitmapData);
+  auto fileSize = static_cast<uint64_t>(bitmapData.size());
+
+  auto dvFile =
+      makeDvDeleteFile(tempFile->getPath(), positions.size(), fileSize);
+
+  DeletionVectorReader reader(dvFile, 0, pool_.get());
+
+  // Batch covers rows 0-99, no deletions in this range.
+  auto bitmap = allocateBitmap(100);
+  reader.readDeletePositions(0, 100, bitmap);
+
+  auto setBits = getSetBits(bitmap, 100);
+  EXPECT_TRUE(setBits.empty());
+  EXPECT_FALSE(reader.noMoreData());
+}
+
+TEST_F(DeletionVectorReaderTest, runContainers) {
+  // Use run-encoded containers: positions 10-19 and 50-59.
+  std::vector<std::pair<uint16_t, std::vector<std::pair<uint16_t, uint16_t>>>>
+      containerRuns = {
+          {0, {{10, 9}, {50, 9}}},
+      };
+  auto bitmapData = serializeRoaringBitmapWithRuns(containerRuns);
+  auto tempFile = writeDvFile(bitmapData);
+  auto fileSize = static_cast<uint64_t>(bitmapData.size());
+
+  auto expected = expandRuns(containerRuns);
+  auto dvFile =
+      makeDvDeleteFile(tempFile->getPath(), expected.size(), fileSize);
+
+  DeletionVectorReader reader(dvFile, 0, pool_.get());
+
+  auto bitmap = allocateBitmap(100);
+  reader.readDeletePositions(0, 100, bitmap);
+
+  auto setBits = getSetBits(bitmap, 100);
+  EXPECT_EQ(setBits, expected);
+  EXPECT_TRUE(reader.noMoreData());
+}
+
+TEST_F(DeletionVectorReaderTest, runContainersWithOffsetHeader) {
+  std::vector<std::pair<uint16_t, std::vector<std::pair<uint16_t, uint16_t>>>>
+      containerRuns = {
+          {0, {{10, 4}}}, // positions 10-14
+          {1, {{0, 2}, {100, 1}}}, // positions 65536-65538, 65636-65637
+          {2, {{500, 0}}}, // position 131072+500 = 131572
+          {3, {{1000, 9}}}, // positions 196608+1000..196608+1009
+      };
+  auto bitmapData = serializeRoaringBitmapWithRuns(containerRuns);
+  auto tempFile = writeDvFile(bitmapData);
+  auto fileSize = static_cast<uint64_t>(bitmapData.size());
+
+  auto expected = expandRuns(containerRuns);
+  auto dvFile =
+      makeDvDeleteFile(tempFile->getPath(), expected.size(), fileSize);
+
+  DeletionVectorReader reader(dvFile, 0, pool_.get());
+
+  const uint64_t numRows = 200'000;
+  auto bitmap = allocateBitmap(numRows);
+  reader.readDeletePositions(0, numRows, bitmap);
+
+  auto setBits = getSetBits(bitmap, numRows);
+  EXPECT_EQ(setBits, expected);
+  EXPECT_TRUE(reader.noMoreData());
+}
+
+TEST_F(DeletionVectorReaderTest, largePositionsMultipleContainers) {
+  // Positions spanning two containers: one in container 0 (key=0), one in
+  // container 1 (key=1, i.e. pos >= 65536).
+  std::vector<int64_t> positions = {5, 100, 65536, 65600};
+  auto bitmapData = serializeRoaringBitmapNoRun(positions);
+  auto tempFile = writeDvFile(bitmapData);
+  auto fileSize = static_cast<uint64_t>(bitmapData.size());
+
+  auto dvFile =
+      makeDvDeleteFile(tempFile->getPath(), positions.size(), fileSize);
+
+  DeletionVectorReader reader(dvFile, 0, pool_.get());
+
+  // Read a batch covering all positions.
+  auto bitmap = allocateBitmap(66000);
+  reader.readDeletePositions(0, 66000, bitmap);
+
+  auto setBits = getSetBits(bitmap, 66000);
+  EXPECT_EQ(setBits, (std::vector<uint64_t>{5, 100, 65536, 65600}));
+  EXPECT_TRUE(reader.noMoreData());
+}
+
+TEST_F(DeletionVectorReaderTest, blobOffset) {
+  // Write a file with some padding before the actual bitmap data.
+  std::vector<int64_t> positions = {3, 7, 11};
+  auto bitmapData = serializeRoaringBitmapNoRun(positions);
+
+  // Prepend 64 bytes of padding.
+  std::string padding(64, 'X');
+  std::string fileContent = padding + bitmapData;
+
+  auto tempFile = writeDvFile(fileContent);
+  auto fileSize = static_cast<uint64_t>(fileContent.size());
+
+  auto dvFile = makeDvDeleteFile(
+      tempFile->getPath(), positions.size(), fileSize, 64, bitmapData.size());
+
+  DeletionVectorReader reader(dvFile, 0, pool_.get());
+
+  auto bitmap = allocateBitmap(20);
+  reader.readDeletePositions(0, 20, bitmap);
+
+  auto setBits = getSetBits(bitmap, 20);
+  EXPECT_EQ(setBits, (std::vector<uint64_t>{3, 7, 11}));
+  EXPECT_TRUE(reader.noMoreData());
+}
+
+TEST_F(DeletionVectorReaderTest, constructorRejectsWrongContentType) {
+  auto tempFile = TempFilePath::create();
+  {
+    std::ofstream out(tempFile->getPath(), std::ios::binary | std::ios::trunc);
+    out.write("dummy", 5);
+  }
+
+  IcebergDeleteFile badFile(
+      FileContent::kPositionalDeletes,
+      tempFile->getPath(),
+      dwio::common::FileFormat::DWRF,
+      1,
+      5);
+
+  VELOX_ASSERT_THROW(
+      DeletionVectorReader(badFile, 0, pool_.get()),
+      "Expected deletion vector file");
+}
+
+TEST_F(DeletionVectorReaderTest, constructorRejectsEmptyDv) {
+  auto tempFile = TempFilePath::create();
+  {
+    std::ofstream out(tempFile->getPath(), std::ios::binary | std::ios::trunc);
+    out.write("dummy", 5);
+  }
+
+  IcebergDeleteFile emptyDv(
+      FileContent::kDeletionVector,
+      tempFile->getPath(),
+      dwio::common::FileFormat::DWRF,
+      0,
+      5);
+
+  VELOX_ASSERT_THROW(
+      DeletionVectorReader(emptyDv, 0, pool_.get()), "Empty deletion vector");
+}
+
+TEST_F(DeletionVectorReaderTest, noMoreDataAfterAllConsumed) {
+  std::vector<int64_t> positions = {0, 1, 2};
+  auto bitmapData = serializeRoaringBitmapNoRun(positions);
+  auto tempFile = writeDvFile(bitmapData);
+  auto fileSize = static_cast<uint64_t>(bitmapData.size());
+
+  auto dvFile =
+      makeDvDeleteFile(tempFile->getPath(), positions.size(), fileSize);
+
+  DeletionVectorReader reader(dvFile, 0, pool_.get());
+  EXPECT_FALSE(reader.noMoreData());
+
+  auto bitmap = allocateBitmap(10);
+  reader.readDeletePositions(0, 10, bitmap);
+  EXPECT_TRUE(reader.noMoreData());
+
+  // Additional reads should be no-ops.
+  auto bitmap2 = allocateBitmap(10);
+  reader.readDeletePositions(10, 10, bitmap2);
+  auto setBits2 = getSetBits(bitmap2, 10);
+  EXPECT_TRUE(setBits2.empty());
+  EXPECT_TRUE(reader.noMoreData());
+}
+
+TEST_F(DeletionVectorReaderTest, singlePosition) {
+  std::vector<int64_t> positions = {42};
+  auto bitmapData = serializeRoaringBitmapNoRun(positions);
+  auto tempFile = writeDvFile(bitmapData);
+  auto fileSize = static_cast<uint64_t>(bitmapData.size());
+
+  auto dvFile =
+      makeDvDeleteFile(tempFile->getPath(), positions.size(), fileSize);
+
+  DeletionVectorReader reader(dvFile, 0, pool_.get());
+
+  auto bitmap = allocateBitmap(100);
+  reader.readDeletePositions(0, 100, bitmap);
+
+  auto setBits = getSetBits(bitmap, 100);
+  EXPECT_EQ(setBits, (std::vector<uint64_t>{42}));
+}
+
+TEST_F(DeletionVectorReaderTest, consecutivePositions) {
+  // Positions: 0 through 99 (100 consecutive positions).
+  std::vector<int64_t> positions;
+  positions.reserve(100);
+  for (int64_t i = 0; i < 100; ++i) {
+    positions.push_back(i);
+  }
+  auto bitmapData = serializeRoaringBitmapNoRun(positions);
+  auto tempFile = writeDvFile(bitmapData);
+  auto fileSize = static_cast<uint64_t>(bitmapData.size());
+
+  auto dvFile =
+      makeDvDeleteFile(tempFile->getPath(), positions.size(), fileSize);
+
+  DeletionVectorReader reader(dvFile, 0, pool_.get());
+
+  auto bitmap = allocateBitmap(100);
+  reader.readDeletePositions(0, 100, bitmap);
+
+  auto setBits = getSetBits(bitmap, 100);
+  std::vector<uint64_t> expected;
+  expected.reserve(100);
+  for (uint64_t i = 0; i < 100; ++i) {
+    expected.push_back(i);
+  }
+  EXPECT_EQ(setBits, expected);
+}
+
+TEST_F(DeletionVectorReaderTest, invalidBitmapTooSmall) {
+  // Write a file that is too small to contain a valid roaring bitmap header.
+  std::string tinyData(4, '\0');
+  auto tempFile = writeDvFile(tinyData);
+
+  auto dvFile = makeDvDeleteFile(tempFile->getPath(), 1, tinyData.size());
+
+  DeletionVectorReader reader(dvFile, 0, pool_.get());
+
+  auto bitmap = allocateBitmap(10);
+  VELOX_ASSERT_THROW(reader.readDeletePositions(0, 10, bitmap), "too small");
+}
+
+TEST_F(DeletionVectorReaderTest, invalidBitmapBadCookie) {
+  // Write a file with an invalid cookie. Data must be large enough to pass
+  // the minimum size check (8 bytes for 64-bit header) so that the cookie
+  // validation is reached.
+  std::string badData(64, '\0');
+  uint32_t badCookie = 99999;
+  std::memcpy(badData.data(), &badCookie, 4);
+  auto tempFile = writeDvFile(badData);
+
+  auto dvFile = makeDvDeleteFile(tempFile->getPath(), 1, badData.size());
+
+  DeletionVectorReader reader(dvFile, 0, pool_.get());
+
+  auto bitmap = allocateBitmap(10);
+  VELOX_ASSERT_THROW(
+      reader.readDeletePositions(0, 10, bitmap),
+      "Unknown roaring bitmap cookie");
+}
diff --git a/velox/connectors/hive/iceberg/tests/DeletionVectorWriterTest.cpp b/velox/connectors/hive/iceberg/tests/DeletionVectorWriterTest.cpp
new file mode 100644
index 00000000000..fc869ee7954
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/DeletionVectorWriterTest.cpp
@@ -0,0 +1,319 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/DeletionVectorWriter.h"
+
+#include <fstream>
+
+#include <gtest/gtest.h>
+
+#include "velox/common/base/BitUtil.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/common/memory/Memory.h"
+#include "velox/common/testutil/TempFilePath.h"
+#include "velox/connectors/hive/iceberg/DeletionVectorReader.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::connector::hive::iceberg;
+using namespace facebook::velox::common::testutil;
+
+namespace {
+
+/// Extracts which bits are set in a bitmap buffer.
+std::vector<uint64_t> getSetBits(const BufferPtr& bitmap, uint64_t size) {
+  auto* raw = bitmap->as<uint8_t>();
+  std::vector<uint64_t> result;
+  for (uint64_t i = 0; i < size; ++i) {
+    if (bits::isBitSet(raw, i)) {
+      result.push_back(i);
+    }
+  }
+  return result;
+}
+
+} // namespace
+
+class DeletionVectorWriterTest : public ::testing::Test {
+ protected:
+  static void SetUpTestSuite() {
+    memory::MemoryManager::initialize(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    filesystems::registerLocalFileSystem();
+    pool_ = memory::memoryManager()->addLeafPool("DeletionVectorWriterTest");
+  }
+
+  BufferPtr allocateBitmap(uint64_t numBits) {
+    auto numBytes = bits::nbytes(numBits);
+    return AlignedBuffer::allocate<uint8_t>(numBytes, pool_.get(), 0);
+  }
+
+  /// Writes serialized bitmap to a temp file, reads it back with
+  /// DeletionVectorReader, and verifies the positions match.
+  void verifyRoundTrip(
+      const std::vector<int64_t>& positions,
+      uint64_t batchSize) {
+    DeletionVectorWriter writer;
+    writer.addDeletedPositions(positions);
+    EXPECT_EQ(writer.numPositions(), positions.size());
+
+    auto blobData = writer.serialize();
+
+    auto tempFile = TempFilePath::create();
+    {
+      std::ofstream out(
+          tempFile->getPath(), std::ios::binary | std::ios::trunc);
+      out.write(blobData.data(), static_cast<std::streamsize>(blobData.size()));
+    }
+
+    auto fileSize = static_cast<uint64_t>(blobData.size());
+
+    // Create IcebergDeleteFile with DV metadata.
+    std::unordered_map<int32_t, std::string> lowerBounds;
+    std::unordered_map<int32_t, std::string> upperBounds;
+    lowerBounds[DeletionVectorReader::kDvOffsetFieldId] = "0";
+    upperBounds[DeletionVectorReader::kDvLengthFieldId] =
+        std::to_string(fileSize);
+
+    IcebergDeleteFile dvFile(
+        FileContent::kDeletionVector,
+        tempFile->getPath(),
+        dwio::common::FileFormat::DWRF,
+        positions.size(),
+        fileSize,
+        {},
+        lowerBounds,
+        upperBounds);
+
+    DeletionVectorReader reader(dvFile, 0, pool_.get());
+
+    // Collect all set bits across batches.
+    std::vector<uint64_t> allSetBits;
+    int64_t maxPos = positions.empty()
+        ? 0
+        : *std::max_element(positions.begin(), positions.end());
+    uint64_t totalRows = static_cast<uint64_t>(maxPos) + batchSize;
+
+    for (uint64_t offset = 0; offset < totalRows; offset += batchSize) {
+      auto bitmap = allocateBitmap(batchSize);
+      reader.readDeletePositions(offset, batchSize, bitmap);
+      auto bits = getSetBits(bitmap, batchSize);
+      for (auto b : bits) {
+        allSetBits.push_back(offset + b);
+      }
+    }
+
+    // Sort and deduplicate the expected positions.
+    std::vector<int64_t> expected = positions;
+    std::sort(expected.begin(), expected.end());
+    expected.erase(
+        std::unique(expected.begin(), expected.end()), expected.end());
+
+    EXPECT_EQ(allSetBits.size(), expected.size());
+    for (size_t i = 0; i < expected.size(); ++i) {
+      EXPECT_EQ(allSetBits[i], static_cast<uint64_t>(expected[i]));
+    }
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_;
+};
+
+TEST_F(DeletionVectorWriterTest, emptyBitmap) {
+  DeletionVectorWriter writer;
+  EXPECT_EQ(writer.numPositions(), 0);
+
+  auto data = writer.serialize();
+  // Empty 64-bit bitmap: numGroups=0 as uint64 (8 bytes).
+  EXPECT_EQ(data.size(), 8);
+}
+
+TEST_F(DeletionVectorWriterTest, singlePosition) {
+  verifyRoundTrip({42}, 100);
+}
+
+TEST_F(DeletionVectorWriterTest, multiplePositions) {
+  verifyRoundTrip({0, 5, 10, 99}, 100);
+}
+
+TEST_F(DeletionVectorWriterTest, consecutivePositions) {
+  std::vector<int64_t> positions;
+  positions.reserve(100);
+  for (int64_t i = 0; i < 100; ++i) {
+    positions.push_back(i);
+  }
+  verifyRoundTrip(positions, 200);
+}
+
+TEST_F(DeletionVectorWriterTest, multipleContainers) {
+  // Positions spanning two containers (key=0 and key=1).
+  verifyRoundTrip({5, 100, 65536, 65600}, 70000);
+}
+
+TEST_F(DeletionVectorWriterTest, largeCardinalityBitmapContainer) {
+  // More than 4096 positions in a single container triggers bitmap container.
+  std::vector<int64_t> positions;
+  positions.reserve(5000);
+  for (int64_t i = 0; i < 5000; ++i) {
+    positions.push_back(i * 2); // Even numbers 0..9998.
+  }
+  verifyRoundTrip(positions, 10100);
+}
+
+TEST_F(DeletionVectorWriterTest, duplicatePositions) {
+  // addDeletedPosition() does not deduplicate — numPositions() counts all
+  // insertions including duplicates. serialize() deduplicates via std::set.
+  DeletionVectorWriter writer;
+  writer.addDeletedPosition(5);
+  writer.addDeletedPosition(5);
+  writer.addDeletedPosition(10);
+  writer.addDeletedPosition(10);
+  writer.addDeletedPosition(10);
+  EXPECT_EQ(writer.numPositions(), 5);
+
+  auto data = writer.serialize();
+
+  auto tempFile = TempFilePath::create();
+  {
+    std::ofstream out(tempFile->getPath(), std::ios::binary | std::ios::trunc);
+    out.write(data.data(), static_cast<std::streamsize>(data.size()));
+  }
+
+  std::unordered_map<int32_t, std::string> lowerBounds;
+  std::unordered_map<int32_t, std::string> upperBounds;
+  lowerBounds[DeletionVectorReader::kDvOffsetFieldId] = "0";
+  upperBounds[DeletionVectorReader::kDvLengthFieldId] =
+      std::to_string(data.size());
+
+  IcebergDeleteFile dvFile(
+      FileContent::kDeletionVector,
+      tempFile->getPath(),
+      dwio::common::FileFormat::DWRF,
+      2, // Only 2 unique positions.
+      data.size(),
+      {},
+      lowerBounds,
+      upperBounds);
+
+  DeletionVectorReader reader(dvFile, 0, pool_.get());
+
+  auto bitmap = allocateBitmap(20);
+  reader.readDeletePositions(0, 20, bitmap);
+
+  auto setBits = getSetBits(bitmap, 20);
+  EXPECT_EQ(setBits, (std::vector<uint64_t>{5, 10}));
+}
+
+TEST_F(DeletionVectorWriterTest, clearPositions) {
+  DeletionVectorWriter writer;
+  writer.addDeletedPosition(1);
+  writer.addDeletedPosition(2);
+  EXPECT_EQ(writer.numPositions(), 2);
+
+  writer.clear();
+  EXPECT_EQ(writer.numPositions(), 0);
+
+  auto data = writer.serialize();
+  EXPECT_EQ(data.size(), 8); // Empty bitmap.
+}
+
+TEST_F(DeletionVectorWriterTest, negativePositionRejected) {
+  DeletionVectorWriter writer;
+  VELOX_ASSERT_THROW(
+      writer.addDeletedPosition(-1), "Deleted position must be non-negative");
+}
+
+TEST_F(DeletionVectorWriterTest, fourOrMoreContainersWithOffsets) {
+  // With >= 4 containers, the roaring format includes an offset section.
+  std::vector<int64_t> positions;
+  positions.reserve(5);
+  for (int i = 0; i < 5; ++i) {
+    positions.push_back(static_cast<int64_t>(i) * 65536 + 42);
+  }
+  verifyRoundTrip(positions, 5 * 65536 + 100);
+}
+
+TEST_F(DeletionVectorWriterTest, puffinFileRoundTrip) {
+  DeletionVectorWriter writer;
+  writer.addDeletedPositions({3, 7, 42, 100});
+  auto blobData = writer.serialize();
+
+  auto tempFile = TempFilePath::create();
+  auto [blobOffset, blobLength] = writePuffinFile(
+      tempFile->getPath(), blobData, "/data/test-data-file.parquet");
+
+  EXPECT_EQ(blobOffset, 4); // After "PUF1" magic.
+  EXPECT_EQ(blobLength, blobData.size());
+
+  // Read the blob back from the Puffin file using DeletionVectorReader.
+  std::unordered_map<int32_t, std::string> lowerBounds;
+  std::unordered_map<int32_t, std::string> upperBounds;
+  lowerBounds[DeletionVectorReader::kDvOffsetFieldId] =
+      std::to_string(blobOffset);
+  upperBounds[DeletionVectorReader::kDvLengthFieldId] =
+      std::to_string(blobLength);
+
+  // Get full file size.
+  std::ifstream in(tempFile->getPath(), std::ios::binary | std::ios::ate);
+  auto fileSize = static_cast<uint64_t>(in.tellg());
+
+  IcebergDeleteFile dvFile(
+      FileContent::kDeletionVector,
+      tempFile->getPath(),
+      dwio::common::FileFormat::DWRF,
+      4,
+      fileSize,
+      {},
+      lowerBounds,
+      upperBounds);
+
+  DeletionVectorReader reader(dvFile, 0, pool_.get());
+
+  auto bitmap = allocateBitmap(200);
+  reader.readDeletePositions(0, 200, bitmap);
+
+  auto setBits = getSetBits(bitmap, 200);
+  EXPECT_EQ(setBits, (std::vector<uint64_t>{3, 7, 42, 100}));
+}
+
+/// Verifies 64-bit positions (>4 billion) serialize and deserialize correctly.
+/// This exercises the Roaring64Bitmap group partitioning for large data files.
+TEST_F(DeletionVectorWriterTest, largePositions64Bit) {
+  // Positions beyond the 32-bit range.
+  std::vector<int64_t> positions = {
+      100,
+      65'536,
+      5'000'000'000LL,
+      5'000'000'001LL,
+      10'000'000'000LL,
+  };
+  verifyRoundTrip(positions, 1'024);
+}
+
+/// Verifies mixed 32-bit and 64-bit positions in the same bitmap.
+TEST_F(DeletionVectorWriterTest, mixed32And64BitPositions) {
+  std::vector<int64_t> positions = {
+      0,
+      1,
+      65'535,
+      65'536,
+      4'294'967'295LL,
+      4'294'967'296LL,
+      8'589'934'592LL,
+  };
+  verifyRoundTrip(positions, 2'048);
+}
diff --git a/velox/connectors/hive/iceberg/tests/EqualityDeleteFileReaderTest.cpp b/velox/connectors/hive/iceberg/tests/EqualityDeleteFileReaderTest.cpp
new file mode 100644
index 00000000000..e0124e716aa
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/EqualityDeleteFileReaderTest.cpp
@@ -0,0 +1,1188 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
+#include "velox/connectors/ConnectorRegistry.h"
+#include "velox/connectors/hive/iceberg/IcebergConnector.h"
+#include "velox/connectors/hive/iceberg/IcebergDeleteFile.h"
+#include "velox/connectors/hive/iceberg/IcebergSplit.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+using namespace facebook::velox::exec::test;
+
+namespace {
+
+const std::string kIcebergConnectorId = "test-iceberg-eq-delete";
+
+} // namespace
+
+/// End-to-end tests for equality deletes via the IcebergSplitReader.
+/// These tests write DWRF data files and delete files, then execute
+/// table scans verifying that matching rows are filtered out.
+class EqualityDeleteFileReaderTest : public HiveConnectorTestBase {
+ protected:
+  void SetUp() override {
+    HiveConnectorTestBase::SetUp();
+    IcebergConnectorFactory icebergFactory;
+    auto icebergConnector = icebergFactory.newConnector(
+        kIcebergConnectorId,
+        std::make_shared<config::ConfigBase>(
+            std::unordered_map<std::string, std::string>()),
+        ioExecutor_.get());
+    connector::ConnectorRegistry::global().insert(
+        icebergConnector->connectorId(), icebergConnector);
+  }
+
+  void TearDown() override {
+    connector::ConnectorRegistry::global().erase(kIcebergConnectorId);
+    HiveConnectorTestBase::TearDown();
+  }
+
+  uint64_t getFileSize(const std::string& path) {
+    return filesystems::getFileSystem(path, nullptr)
+        ->openFileForRead(path)
+        ->size();
+  }
+
+  /// Writes a DWRF data file containing the given vectors.
+  std::shared_ptr<common::testutil::TempFilePath> writeDataFile(
+      const std::vector<RowVectorPtr>& data) {
+    auto file = common::testutil::TempFilePath::create();
+    writeToFile(file->getPath(), data);
+    return file;
+  }
+
+  /// Writes a DWRF delete file containing the equality delete rows.
+  std::shared_ptr<common::testutil::TempFilePath> writeEqDeleteFile(
+      const std::vector<RowVectorPtr>& deleteData) {
+    auto file = common::testutil::TempFilePath::create();
+    writeToFile(file->getPath(), deleteData);
+    return file;
+  }
+
+  /// Creates splits with equality delete files attached.
+  std::vector<std::shared_ptr<ConnectorSplit>> makeSplits(
+      const std::string& dataFilePath,
+      const std::vector<IcebergDeleteFile>& deleteFiles = {},
+      int64_t dataSequenceNumber = 0) {
+    return makeSplits(
+        dataFilePath,
+        /*partitionKeys=*/{},
+        deleteFiles,
+        dataSequenceNumber);
+  }
+
+  /// Creates splits with equality delete files and partition keys attached.
+  /// Use this overload to exercise the equality-delete augmentation for
+  /// partition columns missing from the user's projection.
+  std::vector<std::shared_ptr<ConnectorSplit>> makeSplits(
+      const std::string& dataFilePath,
+      const std::unordered_map<std::string, std::optional<std::string>>&
+          partitionKeys,
+      const std::vector<IcebergDeleteFile>& deleteFiles,
+      int64_t dataSequenceNumber = 0) {
+    auto fileSize = getFileSize(dataFilePath);
+    return {std::make_shared<HiveIcebergSplit>(
+        kIcebergConnectorId,
+        dataFilePath,
+        dwio::common::FileFormat::DWRF,
+        0,
+        fileSize,
+        partitionKeys,
+        std::nullopt,
+        std::unordered_map<std::string, std::string>{},
+        nullptr,
+        /*cacheable=*/true,
+        deleteFiles,
+        std::unordered_map<std::string, std::string>{},
+        std::nullopt,
+        dataSequenceNumber)};
+  }
+
+  /// Builds a table scan plan node with the given schema.
+  core::PlanNodePtr makeTableScanPlan(const RowTypePtr& rowType) {
+    return makeTableScanPlan(rowType, rowType);
+  }
+
+  /// Builds a table scan plan node with separate output and table column
+  /// schemas. Use this when the user's projection ('outputType') does not
+  /// contain every column referenced by an equality delete file
+  /// ('dataColumns' must contain the full table schema so the equality
+  /// column resolution can map field IDs to names).
+  core::PlanNodePtr makeTableScanPlan(
+      const RowTypePtr& outputType,
+      const RowTypePtr& dataColumns) {
+    return PlanBuilder()
+        .startTableScan()
+        .connectorId(kIcebergConnectorId)
+        .outputType(outputType)
+        .dataColumns(dataColumns)
+        .endTableScan()
+        .planNode();
+  }
+};
+
+/// Verifies that base rows matching the equality delete file are removed.
+TEST_F(EqualityDeleteFileReaderTest, basicSingleColumnDelete) {
+  auto rowType = ROW({"id", "value"}, {BIGINT(), VARCHAR()});
+
+  auto baseData = makeRowVector(
+      {"id", "value"},
+      {
+          makeFlatVector<int64_t>({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}),
+          makeFlatVector<std::string>(
+              {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"}),
+      });
+  auto dataFile = writeDataFile({baseData});
+
+  // Delete rows where id == 3 or id == 7.
+  auto deleteData = makeRowVector(
+      {"id"},
+      {
+          makeFlatVector<int64_t>({3, 7}),
+      });
+  auto eqDeleteFile = writeEqDeleteFile({deleteData});
+
+  IcebergDeleteFile icebergDeleteFile(
+      FileContent::kEqualityDeletes,
+      eqDeleteFile->getPath(),
+      dwio::common::FileFormat::DWRF,
+      2,
+      getFileSize(eqDeleteFile->getPath()),
+      /*equalityFieldIds=*/{1}); // field ID 1 = column 0 = "id"
+
+  auto splits = makeSplits(dataFile->getPath(), {icebergDeleteFile});
+  auto plan = makeTableScanPlan(rowType);
+  auto result = AssertQueryBuilder(plan).splits(splits).copyResults(pool());
+
+  auto expected = makeRowVector(
+      {"id", "value"},
+      {
+          makeFlatVector<int64_t>({0, 1, 2, 4, 5, 6, 8, 9}),
+          makeFlatVector<std::string>({"a", "b", "c", "e", "f", "g", "i", "j"}),
+      });
+
+  assertEqualResults({expected}, {result});
+}
+
+/// Regression test for the bug where IcebergSplitReader fails with
+/// "Column not found in row: <name>" when an equality-delete column is not
+/// part of the user's projection. The reader must augment its scan spec to
+/// physically read the equality-delete column, apply the delete, and then
+/// project the column away from the output before returning to the operator.
+TEST_F(EqualityDeleteFileReaderTest, equalityColumnNotInProjection) {
+  auto tableType = ROW({"id", "value"}, {BIGINT(), VARCHAR()});
+  // The user only selects 'value'. The equality delete is on 'id', which is
+  // NOT in the projection — this is the case that previously failed.
+  auto outputType = ROW({"value"}, {VARCHAR()});
+
+  auto baseData = makeRowVector(
+      {"id", "value"},
+      {
+          makeFlatVector<int64_t>({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}),
+          makeFlatVector<std::string>(
+              {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"}),
+      });
+  auto dataFile = writeDataFile({baseData});
+
+  // Delete rows where id == 3 or id == 7.
+  auto deleteData = makeRowVector(
+      {"id"},
+      {
+          makeFlatVector<int64_t>({3, 7}),
+      });
+  auto eqDeleteFile = writeEqDeleteFile({deleteData});
+
+  IcebergDeleteFile icebergDeleteFile(
+      FileContent::kEqualityDeletes,
+      eqDeleteFile->getPath(),
+      dwio::common::FileFormat::DWRF,
+      2,
+      getFileSize(eqDeleteFile->getPath()),
+      /*equalityFieldIds=*/{1}); // field ID 1 = column 0 = "id"
+
+  auto splits = makeSplits(dataFile->getPath(), {icebergDeleteFile});
+  auto plan = makeTableScanPlan(outputType, tableType);
+  auto result = AssertQueryBuilder(plan).splits(splits).copyResults(pool());
+
+  // The 'id' column must not appear in the output; only 'value' is projected.
+  // Rows with id=3 ("d") and id=7 ("h") are removed by the equality delete.
+  auto expected = makeRowVector(
+      {"value"},
+      {
+          makeFlatVector<std::string>({"a", "b", "c", "e", "f", "g", "i", "j"}),
+      });
+
+  assertEqualResults({expected}, {result});
+}
+
+/// Verifies that two equality-delete files referencing the SAME column not in
+/// the user's projection only augment 'scanSpec_' once. Exercises the
+/// de-duplication branch in 'IcebergSplitReader::prepareSplit'.
+TEST_F(EqualityDeleteFileReaderTest, multipleDeleteFilesSameMissingColumn) {
+  auto tableType = ROW({"id", "value"}, {BIGINT(), VARCHAR()});
+  auto outputType = ROW({"value"}, {VARCHAR()});
+
+  auto baseData = makeRowVector(
+      {"id", "value"},
+      {
+          makeFlatVector<int64_t>({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}),
+          makeFlatVector<std::string>(
+              {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"}),
+      });
+  auto dataFile = writeDataFile({baseData});
+
+  // Two delete files, both targeting 'id' (which is NOT in the projection).
+  auto deleteData1 = makeRowVector(
+      {"id"},
+      {
+          makeFlatVector<int64_t>({2, 5}),
+      });
+  auto eqDeleteFile1 = writeEqDeleteFile({deleteData1});
+  IcebergDeleteFile icebergDeleteFile1(
+      FileContent::kEqualityDeletes,
+      eqDeleteFile1->getPath(),
+      dwio::common::FileFormat::DWRF,
+      2,
+      getFileSize(eqDeleteFile1->getPath()),
+      /*equalityFieldIds=*/{1});
+
+  auto deleteData2 = makeRowVector(
+      {"id"},
+      {
+          makeFlatVector<int64_t>({0, 9}),
+      });
+  auto eqDeleteFile2 = writeEqDeleteFile({deleteData2});
+  IcebergDeleteFile icebergDeleteFile2(
+      FileContent::kEqualityDeletes,
+      eqDeleteFile2->getPath(),
+      dwio::common::FileFormat::DWRF,
+      2,
+      getFileSize(eqDeleteFile2->getPath()),
+      /*equalityFieldIds=*/{1});
+
+  auto splits =
+      makeSplits(dataFile->getPath(), {icebergDeleteFile1, icebergDeleteFile2});
+  auto plan = makeTableScanPlan(outputType, tableType);
+  auto result = AssertQueryBuilder(plan).splits(splits).copyResults(pool());
+
+  // Rows with id=0, 2, 5, 9 are removed (across both delete files).
+  auto expected = makeRowVector(
+      {"value"},
+      {
+          makeFlatVector<std::string>({"b", "d", "e", "g", "h", "i"}),
+      });
+
+  assertEqualResults({expected}, {result});
+}
+
+/// Verifies a multi-column equality-delete file where some columns ARE in the
+/// user's projection and some are NOT. Both must end up in the read output for
+/// the equality probe to succeed, while only the projected columns appear in
+/// the operator-visible result.
+TEST_F(EqualityDeleteFileReaderTest, equalityMixedInAndOutOfProjection) {
+  auto tableType = ROW({"a", "b", "c"}, {INTEGER(), VARCHAR(), BIGINT()});
+  // User selects only 'b' and 'c'. 'a' is referenced by the equality delete
+  // but not part of the projection.
+  auto outputType = ROW({"b", "c"}, {VARCHAR(), BIGINT()});
+
+  auto baseData = makeRowVector(
+      {"a", "b", "c"},
+      {
+          makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+          makeFlatVector<std::string>({"x", "y", "z", "x", "y"}),
+          makeFlatVector<int64_t>({10, 20, 30, 40, 50}),
+      });
+  auto dataFile = writeDataFile({baseData});
+
+  // Delete rows where (a=2, b="y") -- removes row 1.
+  // Also (a=1, b="y") -- no match (row with a=1 has b="x").
+  auto deleteData = makeRowVector(
+      {"a", "b"},
+      {
+          makeFlatVector<int32_t>({2, 1}),
+          makeFlatVector<std::string>({"y", "y"}),
+      });
+  auto eqDeleteFile = writeEqDeleteFile({deleteData});
+
+  IcebergDeleteFile icebergDeleteFile(
+      FileContent::kEqualityDeletes,
+      eqDeleteFile->getPath(),
+      dwio::common::FileFormat::DWRF,
+      3,
+      getFileSize(eqDeleteFile->getPath()),
+      /*equalityFieldIds=*/{1, 2}); // field IDs 1,2 = columns "a","b"
+
+  auto splits = makeSplits(dataFile->getPath(), {icebergDeleteFile});
+  auto plan = makeTableScanPlan(outputType, tableType);
+  auto result = AssertQueryBuilder(plan).splits(splits).copyResults(pool());
+
+  // Row 1 (a=2, b="y", c=20) is deleted. The remaining rows project to
+  // (b, c).
+  auto expected = makeRowVector(
+      {"b", "c"},
+      {
+          makeFlatVector<std::string>({"x", "z", "x", "y"}),
+          makeFlatVector<int64_t>({10, 30, 40, 50}),
+      });
+
+  assertEqualResults({expected}, {result});
+}
+
+/// Verifies that an equality delete on a partition column that IS in the data
+/// file (Iceberg-style) but NOT in the user's projection works correctly. The
+/// augmentation should set the partition value as a constant; the file-read
+/// path should then leave the constant in place because the column is present
+/// in 'fileType'.
+TEST_F(
+    EqualityDeleteFileReaderTest,
+    equalityPartitionColumnInFileNotInProjection) {
+  auto tableType = ROW({"part", "value"}, {INTEGER(), VARCHAR()});
+  auto outputType = ROW({"value"}, {VARCHAR()});
+
+  // Data file contains both 'part' and 'value', all rows in partition 2.
+  auto baseData = makeRowVector(
+      {"part", "value"},
+      {
+          makeFlatVector<int32_t>({2, 2, 2, 2}),
+          makeFlatVector<std::string>({"a", "b", "c", "d"}),
+      });
+  auto dataFile = writeDataFile({baseData});
+
+  auto deleteData = makeRowVector(
+      {"part", "value"},
+      {
+          makeFlatVector<int32_t>({2, 2}),
+          makeFlatVector<std::string>({"b", "d"}),
+      });
+  auto eqDeleteFile = writeEqDeleteFile({deleteData});
+
+  IcebergDeleteFile icebergDeleteFile(
+      FileContent::kEqualityDeletes,
+      eqDeleteFile->getPath(),
+      dwio::common::FileFormat::DWRF,
+      2,
+      getFileSize(eqDeleteFile->getPath()),
+      /*equalityFieldIds=*/{1, 2});
+
+  auto splits = makeSplits(
+      dataFile->getPath(),
+      /*partitionKeys=*/{{"part", std::optional<std::string>{"2"}}},
+      {icebergDeleteFile});
+  auto plan = makeTableScanPlan(outputType, tableType);
+  auto result = AssertQueryBuilder(plan).splits(splits).copyResults(pool());
+
+  auto expected = makeRowVector(
+      {"value"},
+      {
+          makeFlatVector<std::string>({"a", "c"}),
+      });
+
+  assertEqualResults({expected}, {result});
+}
+
+/// Same as above but the partition value does NOT match the equality-delete
+/// value, so no rows should be removed.
+TEST_F(
+    EqualityDeleteFileReaderTest,
+    equalityPartitionColumnNonMatchingPartition) {
+  auto tableType = ROW({"part", "value"}, {INTEGER(), VARCHAR()});
+  auto outputType = ROW({"value"}, {VARCHAR()});
+
+  // Data file holds rows in partition 2.
+  auto baseData = makeRowVector(
+      {"part", "value"},
+      {
+          makeFlatVector<int32_t>({2, 2, 2}),
+          makeFlatVector<std::string>({"a", "b", "c"}),
+      });
+  auto dataFile = writeDataFile({baseData});
+
+  // Delete (part=99, value="b"). No file row matches part=99.
+  auto deleteData = makeRowVector(
+      {"part", "value"},
+      {
+          makeFlatVector<int32_t>({99}),
+          makeFlatVector<std::string>({"b"}),
+      });
+  auto eqDeleteFile = writeEqDeleteFile({deleteData});
+
+  IcebergDeleteFile icebergDeleteFile(
+      FileContent::kEqualityDeletes,
+      eqDeleteFile->getPath(),
+      dwio::common::FileFormat::DWRF,
+      1,
+      getFileSize(eqDeleteFile->getPath()),
+      /*equalityFieldIds=*/{1, 2});
+
+  auto splits = makeSplits(
+      dataFile->getPath(),
+      /*partitionKeys=*/{{"part", std::optional<std::string>{"2"}}},
+      {icebergDeleteFile});
+  auto plan = makeTableScanPlan(outputType, tableType);
+  auto result = AssertQueryBuilder(plan).splits(splits).copyResults(pool());
+
+  auto expected = makeRowVector(
+      {"value"},
+      {
+          makeFlatVector<std::string>({"a", "b", "c"}),
+      });
+
+  assertEqualResults({expected}, {result});
+}
+
+/// Multi-column equality delete where ONE column is a partition column not in
+/// the projection and ANOTHER is a regular data column not in the projection.
+/// Both must be augmented; the partition column gets a constant value, the
+/// regular column is read from the file.
+TEST_F(
+    EqualityDeleteFileReaderTest,
+    equalityMixedPartitionAndRegularNotInProjection) {
+  auto tableType =
+      ROW({"part", "id", "value"}, {INTEGER(), BIGINT(), VARCHAR()});
+  auto outputType = ROW({"value"}, {VARCHAR()});
+
+  // Data file contains all three columns, all rows in partition 7.
+  auto baseData = makeRowVector(
+      {"part", "id", "value"},
+      {
+          makeFlatVector<int32_t>({7, 7, 7, 7}),
+          makeFlatVector<int64_t>({10, 20, 30, 40}),
+          makeFlatVector<std::string>({"a", "b", "c", "d"}),
+      });
+  auto dataFile = writeDataFile({baseData});
+
+  // Delete (part=7, id=20) and (part=7, id=40). Should remove "b" and "d".
+  auto deleteData = makeRowVector(
+      {"part", "id"},
+      {
+          makeFlatVector<int32_t>({7, 7}),
+          makeFlatVector<int64_t>({20, 40}),
+      });
+  auto eqDeleteFile = writeEqDeleteFile({deleteData});
+
+  IcebergDeleteFile icebergDeleteFile(
+      FileContent::kEqualityDeletes,
+      eqDeleteFile->getPath(),
+      dwio::common::FileFormat::DWRF,
+      2,
+      getFileSize(eqDeleteFile->getPath()),
+      /*equalityFieldIds=*/{1, 2}); // field IDs 1,2 = part, id
+
+  auto splits = makeSplits(
+      dataFile->getPath(),
+      /*partitionKeys=*/{{"part", std::optional<std::string>{"7"}}},
+      {icebergDeleteFile});
+  auto plan = makeTableScanPlan(outputType, tableType);
+  auto result = AssertQueryBuilder(plan).splits(splits).copyResults(pool());
+
+  auto expected = makeRowVector(
+      {"value"},
+      {
+          makeFlatVector<std::string>({"a", "c"}),
+      });
+
+  assertEqualResults({expected}, {result});
+}
+
+/// Verifies equality delete on a DATE partition column not in projection.
+/// Iceberg encodes DATE partition values as days-since-epoch (e.g. "19345").
+/// This exercises the type-derived 'isDaysSinceEpoch' flag in
+/// 'configureEqualityDeleteColumns' — for DATE columns the partition string
+/// must be parsed as an integer day count, NOT as an ISO-8601 date string.
+TEST_F(
+    EqualityDeleteFileReaderTest,
+    equalityDatePartitionColumnNotInProjection) {
+  auto tableType = ROW({"part_date", "value"}, {DATE(), VARCHAR()});
+  auto outputType = ROW({"value"}, {VARCHAR()});
+
+  // 19345 days since 1970-01-01 == 2022-12-22. All file rows belong to that
+  // partition.
+  constexpr int32_t kPartitionDays = 19345;
+  auto baseData = makeRowVector(
+      {"part_date", "value"},
+      {
+          makeFlatVector<int32_t>(
+              {kPartitionDays, kPartitionDays, kPartitionDays}, DATE()),
+          makeFlatVector<std::string>({"a", "b", "c"}),
+      });
+  auto dataFile = writeDataFile({baseData});
+
+  // Delete (part_date=19345, value="b").
+  auto deleteData = makeRowVector(
+      {"part_date", "value"},
+      {
+          makeFlatVector<int32_t>({kPartitionDays}, DATE()),
+          makeFlatVector<std::string>({"b"}),
+      });
+  auto eqDeleteFile = writeEqDeleteFile({deleteData});
+
+  IcebergDeleteFile icebergDeleteFile(
+      FileContent::kEqualityDeletes,
+      eqDeleteFile->getPath(),
+      dwio::common::FileFormat::DWRF,
+      1,
+      getFileSize(eqDeleteFile->getPath()),
+      /*equalityFieldIds=*/{1, 2});
+
+  auto splits = makeSplits(
+      dataFile->getPath(),
+      /*partitionKeys=*/
+      {{"part_date",
+        std::optional<std::string>{std::to_string(kPartitionDays)}}},
+      {icebergDeleteFile});
+  auto plan = makeTableScanPlan(outputType, tableType);
+  auto result = AssertQueryBuilder(plan).splits(splits).copyResults(pool());
+
+  auto expected = makeRowVector(
+      {"value"},
+      {
+          makeFlatVector<std::string>({"a", "c"}),
+      });
+
+  assertEqualResults({expected}, {result});
+}
+
+/// Exercises the filter-only column upgrade path in
+/// 'configureEqualityDeleteColumns'. The equality-delete column 'id' is
+/// referenced by a WHERE predicate (so the planner installs a scan-spec
+/// child with 'projectOut=false') but is NOT in the user's SELECT
+/// projection. The augmentation must upgrade the existing scan-spec child
+/// from filter-only to 'projectOut=true' and assign a non-conflicting
+/// channel so the equality-delete reader can probe by name.
+TEST_F(EqualityDeleteFileReaderTest, equalityFilterOnlyColumnNotInProjection) {
+  auto tableType = ROW({"id", "value"}, {BIGINT(), VARCHAR()});
+  auto outputType = ROW({"value"}, {VARCHAR()});
+
+  auto baseData = makeRowVector(
+      {"id", "value"},
+      {
+          makeFlatVector<int64_t>({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}),
+          makeFlatVector<std::string>(
+              {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"}),
+      });
+  auto dataFile = writeDataFile({baseData});
+
+  // Equality delete removes id == 4 and id == 8.
+  auto deleteData = makeRowVector(
+      {"id"},
+      {
+          makeFlatVector<int64_t>({4, 8}),
+      });
+  auto eqDeleteFile = writeEqDeleteFile({deleteData});
+
+  IcebergDeleteFile icebergDeleteFile(
+      FileContent::kEqualityDeletes,
+      eqDeleteFile->getPath(),
+      dwio::common::FileFormat::DWRF,
+      2,
+      getFileSize(eqDeleteFile->getPath()),
+      /*equalityFieldIds=*/{1}); // field ID 1 = "id"
+
+  auto splits = makeSplits(dataFile->getPath(), {icebergDeleteFile});
+  // WHERE id >= 3 keeps rows {3,4,5,6,7,8,9} from the file; the equality
+  // delete then removes id=4 and id=8, leaving values {d->skipped} no, we
+  // expect surviving values for ids {3,5,6,7,9}, projected as 'value' only.
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .connectorId(kIcebergConnectorId)
+                  .outputType(outputType)
+                  .dataColumns(tableType)
+                  .subfieldFilter("id >= 3")
+                  .endTableScan()
+                  .planNode();
+  auto result = AssertQueryBuilder(plan).splits(splits).copyResults(pool());
+
+  auto expected = makeRowVector(
+      {"value"},
+      {
+          makeFlatVector<std::string>({"d", "f", "g", "h", "j"}),
+      });
+
+  assertEqualResults({expected}, {result});
+}
+
+/// Regression test for the schema-evolution +
+/// partition-column-not-in-projection scenario surfaced by the Presto Iceberg
+/// integration test 'testEqualityDeleteWithPartitionColumnMissingInSelect'.
+///
+/// Setup (mirrors the Presto test for the older data file):
+///   - Full table schema: (a, b, c, d) with a, c, d as partition columns.
+///   - The data file under test was written BEFORE 'd' was added, so it
+///     physically contains only (a, b, c).
+///   - User projection: (a, b, d). 'd' must be NULL-filled (not in file);
+///     'c' is NOT in the projection but IS referenced by the equality
+///     delete and IS the file's identity-partition column.
+///
+/// The equality delete (a=6, c=2, b=1006) targets the file row
+/// (6, '1006', 2). The augmentation must:
+///   1. Add 'c' to 'scanSpec_' / 'readerOutputType_' so the eq-delete
+///      probe can find it by name.
+///   2. Leave 'd' alone — 'd' is in the user projection and gets the
+///      standard schema-evolution NULL-fill from 'adaptColumns'.
+///   3. Honour the existing partition-key constant on 'c' regardless of
+///      whether the file physically contains 'c'.
+TEST_F(
+    EqualityDeleteFileReaderTest,
+    equalityPartitionColumnNotInProjectionWithEvolvedSchema) {
+  // Full evolved table schema (after 'ALTER TABLE ADD COLUMN d').
+  auto tableType =
+      ROW({"a", "b", "c", "d"}, {INTEGER(), VARCHAR(), INTEGER(), VARCHAR()});
+  // User selects 'a', 'b', 'd'. Note 'c' is NOT projected.
+  auto outputType = ROW({"a", "b", "d"}, {INTEGER(), VARCHAR(), VARCHAR()});
+
+  // Data file contains only (a, b, c) — written before 'd' was added.
+  // Both rows are in the (a=6, c=2) partition.
+  auto baseData = makeRowVector(
+      {"a", "b", "c"},
+      {
+          makeFlatVector<int32_t>({6, 6}),
+          makeFlatVector<std::string>({"1006", "1009"}),
+          makeFlatVector<int32_t>({2, 2}),
+      });
+  auto dataFile = writeDataFile({baseData});
+
+  // Equality delete on (a, b, c) with values (6, '1006', 2). Field IDs
+  // are in field-id order = [1, 2, 3].
+  auto deleteData = makeRowVector(
+      {"a", "b", "c"},
+      {
+          makeFlatVector<int32_t>({6}),
+          makeFlatVector<std::string>({"1006"}),
+          makeFlatVector<int32_t>({2}),
+      });
+  auto eqDeleteFile = writeEqDeleteFile({deleteData});
+
+  IcebergDeleteFile icebergDeleteFile(
+      FileContent::kEqualityDeletes,
+      eqDeleteFile->getPath(),
+      dwio::common::FileFormat::DWRF,
+      1,
+      getFileSize(eqDeleteFile->getPath()),
+      /*equalityFieldIds=*/{1, 2, 3});
+
+  auto splits = makeSplits(
+      dataFile->getPath(),
+      /*partitionKeys=*/
+      {{"a", std::optional<std::string>{"6"}},
+       {"c", std::optional<std::string>{"2"}}},
+      {icebergDeleteFile});
+  auto plan = makeTableScanPlan(outputType, tableType);
+  auto result = AssertQueryBuilder(plan).splits(splits).copyResults(pool());
+
+  // Row (6, '1006', 2) is deleted by the equality delete; (6, '1009', 2)
+  // survives. 'd' is NULL because the data file was written before 'd'
+  // was added.
+  auto expected = makeRowVector(
+      {"a", "b", "d"},
+      {
+          makeFlatVector<int32_t>({6}),
+          makeFlatVector<std::string>({"1009"}),
+          makeNullableFlatVector<std::string>({std::nullopt}),
+      });
+
+  assertEqualResults({expected}, {result});
+}
+
+/// Verifies multi-column equality deletes (both columns must match).
+TEST_F(EqualityDeleteFileReaderTest, multiColumnDelete) {
+  auto rowType = ROW({"a", "b", "c"}, {INTEGER(), VARCHAR(), BIGINT()});
+
+  auto baseData = makeRowVector(
+      {"a", "b", "c"},
+      {
+          makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+          makeFlatVector<std::string>({"x", "y", "z", "x", "y"}),
+          makeFlatVector<int64_t>({10, 20, 30, 40, 50}),
+      });
+  auto dataFile = writeDataFile({baseData});
+
+  // Delete rows where (a=2, b="y") — matches row index 1.
+  // Also (a=5, b="y") — matches row index 4.
+  // But (a=1, b="y") — no match (a=1 has b="x").
+  auto deleteData = makeRowVector(
+      {"a", "b"},
+      {
+          makeFlatVector<int32_t>({2, 5, 1}),
+          makeFlatVector<std::string>({"y", "y", "y"}),
+      });
+  auto eqDeleteFile = writeEqDeleteFile({deleteData});
+
+  IcebergDeleteFile icebergDeleteFile(
+      FileContent::kEqualityDeletes,
+      eqDeleteFile->getPath(),
+      dwio::common::FileFormat::DWRF,
+      3,
+      getFileSize(eqDeleteFile->getPath()),
+      /*equalityFieldIds=*/{1, 2}); // field IDs 1,2 = columns "a","b"
+
+  auto splits = makeSplits(dataFile->getPath(), {icebergDeleteFile});
+  auto plan = makeTableScanPlan(rowType);
+  auto result = AssertQueryBuilder(plan).splits(splits).copyResults(pool());
+
+  // Rows 0, 2, 3 survive (rows 1 and 4 deleted).
+  auto expected = makeRowVector(
+      {"a", "b", "c"},
+      {
+          makeFlatVector<int32_t>({1, 3, 4}),
+          makeFlatVector<std::string>({"x", "z", "x"}),
+          makeFlatVector<int64_t>({10, 30, 40}),
+      });
+
+  assertEqualResults({expected}, {result});
+}
+
+/// Verifies that when no rows match, all rows survive.
+TEST_F(EqualityDeleteFileReaderTest, noMatchingDeletes) {
+  auto rowType = ROW({"id"}, {BIGINT()});
+
+  auto baseData = makeRowVector(
+      {"id"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3}),
+      });
+  auto dataFile = writeDataFile({baseData});
+
+  // Delete file has values not present in base data.
+  auto deleteData = makeRowVector(
+      {"id"},
+      {
+          makeFlatVector<int64_t>({100, 200}),
+      });
+  auto eqDeleteFile = writeEqDeleteFile({deleteData});
+
+  IcebergDeleteFile icebergDeleteFile(
+      FileContent::kEqualityDeletes,
+      eqDeleteFile->getPath(),
+      dwio::common::FileFormat::DWRF,
+      2,
+      getFileSize(eqDeleteFile->getPath()),
+      /*equalityFieldIds=*/{1});
+
+  auto splits = makeSplits(dataFile->getPath(), {icebergDeleteFile});
+  auto plan = makeTableScanPlan(rowType);
+  auto result = AssertQueryBuilder(plan).splits(splits).copyResults(pool());
+
+  auto expected = makeRowVector(
+      {"id"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3}),
+      });
+
+  assertEqualResults({expected}, {result});
+}
+
+/// Verifies that all rows are deleted when every base row matches.
+TEST_F(EqualityDeleteFileReaderTest, allRowsDeleted) {
+  auto rowType = ROW({"id"}, {BIGINT()});
+
+  auto baseData = makeRowVector(
+      {"id"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3}),
+      });
+  auto dataFile = writeDataFile({baseData});
+
+  auto deleteData = makeRowVector(
+      {"id"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3}),
+      });
+  auto eqDeleteFile = writeEqDeleteFile({deleteData});
+
+  IcebergDeleteFile icebergDeleteFile(
+      FileContent::kEqualityDeletes,
+      eqDeleteFile->getPath(),
+      dwio::common::FileFormat::DWRF,
+      3,
+      getFileSize(eqDeleteFile->getPath()),
+      /*equalityFieldIds=*/{1});
+
+  auto splits = makeSplits(dataFile->getPath(), {icebergDeleteFile});
+  auto plan = makeTableScanPlan(rowType);
+  auto result = AssertQueryBuilder(plan).splits(splits).copyResults(pool());
+
+  EXPECT_EQ(result->size(), 0);
+}
+
+/// Verifies equality deletes with VARCHAR columns.
+TEST_F(EqualityDeleteFileReaderTest, stringColumnDelete) {
+  auto rowType = ROW({"name", "age"}, {VARCHAR(), INTEGER()});
+
+  auto baseData = makeRowVector(
+      {"name", "age"},
+      {
+          makeFlatVector<std::string>({"alice", "bob", "charlie", "dave"}),
+          makeFlatVector<int32_t>({25, 30, 35, 40}),
+      });
+  auto dataFile = writeDataFile({baseData});
+
+  // Delete rows where name is "bob" or "dave".
+  auto deleteData = makeRowVector(
+      {"name"},
+      {
+          makeFlatVector<std::string>({"bob", "dave"}),
+      });
+  auto eqDeleteFile = writeEqDeleteFile({deleteData});
+
+  IcebergDeleteFile icebergDeleteFile(
+      FileContent::kEqualityDeletes,
+      eqDeleteFile->getPath(),
+      dwio::common::FileFormat::DWRF,
+      2,
+      getFileSize(eqDeleteFile->getPath()),
+      /*equalityFieldIds=*/{1}); // field ID 1 = "name"
+
+  auto splits = makeSplits(dataFile->getPath(), {icebergDeleteFile});
+  auto plan = makeTableScanPlan(rowType);
+  auto result = AssertQueryBuilder(plan).splits(splits).copyResults(pool());
+
+  auto expected = makeRowVector(
+      {"name", "age"},
+      {
+          makeFlatVector<std::string>({"alice", "charlie"}),
+          makeFlatVector<int32_t>({25, 35}),
+      });
+
+  assertEqualResults({expected}, {result});
+}
+
+/// Verifies equality deletes on a non-first column (field ID 2).
+TEST_F(EqualityDeleteFileReaderTest, deleteOnSecondColumn) {
+  auto rowType = ROW({"id", "category"}, {BIGINT(), VARCHAR()});
+
+  auto baseData = makeRowVector(
+      {"id", "category"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+          makeFlatVector<std::string>({"A", "B", "A", "C", "B"}),
+      });
+  auto dataFile = writeDataFile({baseData});
+
+  // Delete rows where category == "B".
+  auto deleteData = makeRowVector(
+      {"category"},
+      {
+          makeFlatVector<std::string>({"B"}),
+      });
+  auto eqDeleteFile = writeEqDeleteFile({deleteData});
+
+  IcebergDeleteFile icebergDeleteFile(
+      FileContent::kEqualityDeletes,
+      eqDeleteFile->getPath(),
+      dwio::common::FileFormat::DWRF,
+      1,
+      getFileSize(eqDeleteFile->getPath()),
+      /*equalityFieldIds=*/{2}); // field ID 2 = column 1 = "category"
+
+  auto splits = makeSplits(dataFile->getPath(), {icebergDeleteFile});
+  auto plan = makeTableScanPlan(rowType);
+  auto result = AssertQueryBuilder(plan).splits(splits).copyResults(pool());
+
+  // Rows with category="B" (indices 1,4) deleted.
+  auto expected = makeRowVector(
+      {"id", "category"},
+      {
+          makeFlatVector<int64_t>({1, 3, 4}),
+          makeFlatVector<std::string>({"A", "A", "C"}),
+      });
+
+  assertEqualResults({expected}, {result});
+}
+
+/// Verifies that equality deletes apply when the delete file has a higher
+/// sequence number than the data file (per the Iceberg V2+ spec).
+TEST_F(EqualityDeleteFileReaderTest, sequenceNumberDeleteApplies) {
+  auto rowType = ROW({"id", "value"}, {BIGINT(), VARCHAR()});
+
+  auto baseData = makeRowVector(
+      {"id", "value"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+          makeFlatVector<std::string>({"a", "b", "c", "d", "e"}),
+      });
+  auto dataFile = writeDataFile({baseData});
+
+  auto deleteData = makeRowVector(
+      {"id"},
+      {
+          makeFlatVector<int64_t>({2, 4}),
+      });
+  auto eqDeleteFile = writeEqDeleteFile({deleteData});
+
+  // Delete file has sequence number 5, data file has sequence number 3.
+  // Since deleteSeq (5) > dataSeq (3), the delete should apply.
+  IcebergDeleteFile icebergDeleteFile(
+      FileContent::kEqualityDeletes,
+      eqDeleteFile->getPath(),
+      dwio::common::FileFormat::DWRF,
+      2,
+      getFileSize(eqDeleteFile->getPath()),
+      /*equalityFieldIds=*/{1},
+      /*lowerBounds=*/{},
+      /*upperBounds=*/{},
+      /*dataSequenceNumber=*/5);
+
+  auto splits = makeSplits(
+      dataFile->getPath(),
+      {icebergDeleteFile},
+      /*dataSequenceNumber=*/3);
+  auto plan = makeTableScanPlan(rowType);
+  auto result = AssertQueryBuilder(plan).splits(splits).copyResults(pool());
+
+  // Rows with id=2 and id=4 are deleted.
+  auto expected = makeRowVector(
+      {"id", "value"},
+      {
+          makeFlatVector<int64_t>({1, 3, 5}),
+          makeFlatVector<std::string>({"a", "c", "e"}),
+      });
+
+  assertEqualResults({expected}, {result});
+}
+
+/// Verifies that equality deletes are skipped when the delete file has a
+/// lower or equal sequence number compared to the data file.
+TEST_F(EqualityDeleteFileReaderTest, sequenceNumberDeleteSkipped) {
+  auto rowType = ROW({"id", "value"}, {BIGINT(), VARCHAR()});
+
+  auto baseData = makeRowVector(
+      {"id", "value"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3}),
+          makeFlatVector<std::string>({"a", "b", "c"}),
+      });
+  auto dataFile = writeDataFile({baseData});
+
+  auto deleteData = makeRowVector(
+      {"id"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3}),
+      });
+  auto eqDeleteFile = writeEqDeleteFile({deleteData});
+
+  // Delete file has sequence number 2, data file has sequence number 5.
+  // Since deleteSeq (2) <= dataSeq (5), the delete should be skipped.
+  IcebergDeleteFile icebergDeleteFile(
+      FileContent::kEqualityDeletes,
+      eqDeleteFile->getPath(),
+      dwio::common::FileFormat::DWRF,
+      3,
+      getFileSize(eqDeleteFile->getPath()),
+      /*equalityFieldIds=*/{1},
+      /*lowerBounds=*/{},
+      /*upperBounds=*/{},
+      /*dataSequenceNumber=*/2);
+
+  auto splits = makeSplits(
+      dataFile->getPath(),
+      {icebergDeleteFile},
+      /*dataSequenceNumber=*/5);
+  auto plan = makeTableScanPlan(rowType);
+  auto result = AssertQueryBuilder(plan).splits(splits).copyResults(pool());
+
+  // All rows survive because the delete file is skipped.
+  auto expected = makeRowVector(
+      {"id", "value"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3}),
+          makeFlatVector<std::string>({"a", "b", "c"}),
+      });
+
+  assertEqualResults({expected}, {result});
+}
+
+/// Verifies that equality deletes are skipped when the delete file has the
+/// same sequence number as the data file (edge case of the <= check).
+TEST_F(EqualityDeleteFileReaderTest, sequenceNumberEqualSkipped) {
+  auto rowType = ROW({"id", "value"}, {BIGINT(), VARCHAR()});
+
+  auto baseData = makeRowVector(
+      {"id", "value"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3}),
+          makeFlatVector<std::string>({"a", "b", "c"}),
+      });
+  auto dataFile = writeDataFile({baseData});
+
+  auto deleteData = makeRowVector(
+      {"id"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3}),
+      });
+  auto eqDeleteFile = writeEqDeleteFile({deleteData});
+
+  // Delete file and data file have the same sequence number (5).
+  // Since deleteSeq (5) <= dataSeq (5), the delete should be skipped.
+  IcebergDeleteFile icebergDeleteFile(
+      FileContent::kEqualityDeletes,
+      eqDeleteFile->getPath(),
+      dwio::common::FileFormat::DWRF,
+      3,
+      getFileSize(eqDeleteFile->getPath()),
+      /*equalityFieldIds=*/{1},
+      /*lowerBounds=*/{},
+      /*upperBounds=*/{},
+      /*dataSequenceNumber=*/5);
+
+  auto splits = makeSplits(
+      dataFile->getPath(),
+      {icebergDeleteFile},
+      /*dataSequenceNumber=*/5);
+  auto plan = makeTableScanPlan(rowType);
+  auto result = AssertQueryBuilder(plan).splits(splits).copyResults(pool());
+
+  // All rows survive because the delete file is skipped (equal seq#).
+  auto expected = makeRowVector(
+      {"id", "value"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3}),
+          makeFlatVector<std::string>({"a", "b", "c"}),
+      });
+
+  assertEqualResults({expected}, {result});
+}
+
+/// Verifies that when either sequence number is 0 (unassigned/legacy V1),
+/// the delete file is always applied (filtering is disabled).
+TEST_F(EqualityDeleteFileReaderTest, sequenceNumberZeroAlwaysApplies) {
+  auto rowType = ROW({"id"}, {BIGINT()});
+
+  auto baseData = makeRowVector(
+      {"id"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3}),
+      });
+  auto dataFile = writeDataFile({baseData});
+
+  auto deleteData = makeRowVector(
+      {"id"},
+      {
+          makeFlatVector<int64_t>({2}),
+      });
+  auto eqDeleteFile = writeEqDeleteFile({deleteData});
+
+  // Delete file has sequence number 0 (legacy), data file has sequence 10.
+  // Since deleteSeq is 0, filtering is disabled and the delete applies.
+  IcebergDeleteFile icebergDeleteFile(
+      FileContent::kEqualityDeletes,
+      eqDeleteFile->getPath(),
+      dwio::common::FileFormat::DWRF,
+      1,
+      getFileSize(eqDeleteFile->getPath()),
+      /*equalityFieldIds=*/{1},
+      /*lowerBounds=*/{},
+      /*upperBounds=*/{},
+      /*dataSequenceNumber=*/0);
+
+  auto splits = makeSplits(
+      dataFile->getPath(),
+      {icebergDeleteFile},
+      /*dataSequenceNumber=*/10);
+  auto plan = makeTableScanPlan(rowType);
+  auto result = AssertQueryBuilder(plan).splits(splits).copyResults(pool());
+
+  // Row id=2 is deleted because sequence number filtering is disabled.
+  auto expected = makeRowVector(
+      {"id"},
+      {
+          makeFlatVector<int64_t>({1, 3}),
+      });
+
+  assertEqualResults({expected}, {result});
+}
+
+/// Verifies that when multiple delete files have different sequence numbers,
+/// only those with higher sequence numbers than the data file are applied.
+TEST_F(EqualityDeleteFileReaderTest, mixedSequenceNumbers) {
+  auto rowType = ROW({"id", "value"}, {BIGINT(), VARCHAR()});
+
+  auto baseData = makeRowVector(
+      {"id", "value"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+          makeFlatVector<std::string>({"a", "b", "c", "d", "e"}),
+      });
+  auto dataFile = writeDataFile({baseData});
+
+  // First delete file: seqNum=10 (higher than data seqNum=5) → applied.
+  auto deleteData1 = makeRowVector(
+      {"id"},
+      {
+          makeFlatVector<int64_t>({2}),
+      });
+  auto eqDeleteFile1 = writeEqDeleteFile({deleteData1});
+  IcebergDeleteFile icebergDeleteFile1(
+      FileContent::kEqualityDeletes,
+      eqDeleteFile1->getPath(),
+      dwio::common::FileFormat::DWRF,
+      1,
+      getFileSize(eqDeleteFile1->getPath()),
+      /*equalityFieldIds=*/{1},
+      /*lowerBounds=*/{},
+      /*upperBounds=*/{},
+      /*dataSequenceNumber=*/10);
+
+  // Second delete file: seqNum=3 (lower than data seqNum=5) → skipped.
+  auto deleteData2 = makeRowVector(
+      {"id"},
+      {
+          makeFlatVector<int64_t>({4}),
+      });
+  auto eqDeleteFile2 = writeEqDeleteFile({deleteData2});
+  IcebergDeleteFile icebergDeleteFile2(
+      FileContent::kEqualityDeletes,
+      eqDeleteFile2->getPath(),
+      dwio::common::FileFormat::DWRF,
+      1,
+      getFileSize(eqDeleteFile2->getPath()),
+      /*equalityFieldIds=*/{1},
+      /*lowerBounds=*/{},
+      /*upperBounds=*/{},
+      /*dataSequenceNumber=*/3);
+
+  auto splits = makeSplits(
+      dataFile->getPath(),
+      {icebergDeleteFile1, icebergDeleteFile2},
+      /*dataSequenceNumber=*/5);
+  auto plan = makeTableScanPlan(rowType);
+  auto result = AssertQueryBuilder(plan).splits(splits).copyResults(pool());
+
+  // Only id=2 is deleted (from delete file 1 with seqNum=10).
+  // id=4 survives because delete file 2 (seqNum=3) is skipped.
+  auto expected = makeRowVector(
+      {"id", "value"},
+      {
+          makeFlatVector<int64_t>({1, 3, 4, 5}),
+          makeFlatVector<std::string>({"a", "c", "d", "e"}),
+      });
+
+  assertEqualResults({expected}, {result});
+}
+
+// TODO: Add a Parquet-format equality delete test. Currently all equality
+// delete tests use DWRF because writeToFile() (from HiveConnectorTestBase)
+// only supports DWRF. Adding a Parquet test requires adding Parquet writer
+// dependencies to this test target's BUCK file and a Parquet write helper.
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/tests/IcebergConnectorTest.cpp b/velox/connectors/hive/iceberg/tests/IcebergConnectorTest.cpp
new file mode 100644
index 00000000000..248bccaaf3d
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/IcebergConnectorTest.cpp
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/IcebergConnector.h"
+#include <gtest/gtest.h>
+#include "velox/connectors/ConnectorRegistry.h"
+#include "velox/connectors/hive/HiveConfig.h"
+#include "velox/connectors/hive/iceberg/tests/IcebergTestBase.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+namespace {
+
+class IcebergConnectorTest : public test::IcebergTestBase {
+ protected:
+  static void resetIcebergConnector(
+      const std::shared_ptr<const config::ConfigBase>& config) {
+    ConnectorRegistry::global().erase(test::kIcebergConnectorId);
+
+    IcebergConnectorFactory factory;
+    auto icebergConnector =
+        factory.newConnector(test::kIcebergConnectorId, config);
+    ConnectorRegistry::global().insert(
+        icebergConnector->connectorId(), icebergConnector);
+  }
+};
+
+TEST_F(IcebergConnectorTest, connectorConfiguration) {
+  auto customConfig = std::make_shared<config::ConfigBase>(
+      std::unordered_map<std::string, std::string>{
+          {hive::HiveConfig::kEnableFileHandleCache, "true"},
+          {hive::HiveConfig::kNumCacheFileHandles, "1000"}});
+
+  resetIcebergConnector(customConfig);
+
+  // Verify connector was registered successfully with custom config.
+  auto icebergConnector = ConnectorRegistry::tryGet(test::kIcebergConnectorId);
+  ASSERT_NE(icebergConnector, nullptr);
+
+  auto config = icebergConnector->connectorConfig();
+  ASSERT_NE(config, nullptr);
+
+  hive::HiveConfig hiveConfig(config);
+  ASSERT_TRUE(hiveConfig.isFileHandleCacheEnabled());
+  ASSERT_EQ(hiveConfig.numCacheFileHandles(), 1000);
+}
+
+TEST_F(IcebergConnectorTest, connectorProperties) {
+  auto icebergConnector = ConnectorRegistry::tryGet(test::kIcebergConnectorId);
+  ASSERT_NE(icebergConnector, nullptr);
+
+  ASSERT_TRUE(icebergConnector->canAddDynamicFilter());
+  ASSERT_TRUE(icebergConnector->supportsSplitPreload());
+  ASSERT_NE(icebergConnector->ioExecutor(), nullptr);
+}
+
+} // namespace
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/tests/IcebergDwrfInsertTest.cpp b/velox/connectors/hive/iceberg/tests/IcebergDwrfInsertTest.cpp
new file mode 100644
index 00000000000..088f7b57832
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/IcebergDwrfInsertTest.cpp
@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/HiveConfig.h"
+#include "velox/connectors/hive/iceberg/tests/IcebergTestBase.h"
+#include "velox/dwio/dwrf/RegisterDwrfReader.h"
+#include "velox/dwio/dwrf/RegisterDwrfWriter.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+using namespace facebook::velox::common::testutil;
+
+namespace facebook::velox::connector::hive::iceberg {
+namespace {
+
+/// End-to-end tests for writing and reading Iceberg tables using the DWRF file
+/// format. Exercises the full write path (IcebergDataSink -> DWRF writer) and
+/// the full read path (IcebergSplitReader -> DWRF reader), verifying data
+/// round-trip correctness.
+class IcebergDwrfInsertTest : public test::IcebergTestBase {
+ protected:
+  void SetUp() override {
+    IcebergTestBase::SetUp();
+    dwrf::registerDwrfReaderFactory();
+    dwrf::registerDwrfWriterFactory();
+    fileFormat_ = dwio::common::FileFormat::DWRF;
+  }
+
+  /// Write test data using DWRF format, then read it back and verify results.
+  void test(const RowTypePtr& rowType, double nullRatio = 0.0) {
+    const auto outputDirectory = TempDirectoryPath::create();
+    const auto dataPath = outputDirectory->getPath();
+    constexpr int32_t numBatches = 10;
+    constexpr int32_t vectorSize = 5'000;
+    const auto vectors =
+        createTestData(rowType, numBatches, vectorSize, nullRatio);
+    const auto dataSink = createDataSinkAndAppendData(vectors, dataPath);
+    const auto commitTasks = dataSink->close();
+
+    auto splits = createSplitsForDirectory(dataPath);
+    ASSERT_EQ(splits.size(), commitTasks.size());
+    auto plan = exec::test::PlanBuilder()
+                    .startTableScan()
+                    .connectorId(test::kIcebergConnectorId)
+                    .outputType(rowType)
+                    .endTableScan()
+                    .planNode();
+    exec::test::AssertQueryBuilder(plan).splits(splits).assertResults(vectors);
+  }
+};
+
+TEST_F(IcebergDwrfInsertTest, basic) {
+  auto rowType =
+      ROW({"c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8"},
+          {BIGINT(),
+           INTEGER(),
+           SMALLINT(),
+           BOOLEAN(),
+           REAL(),
+           VARCHAR(),
+           VARBINARY(),
+           DOUBLE()});
+  test(rowType, 0.2);
+}
+
+TEST_F(IcebergDwrfInsertTest, mapAndArray) {
+  auto rowType =
+      ROW({"c1", "c2"}, {MAP(INTEGER(), VARCHAR()), ARRAY(VARCHAR())});
+  test(rowType);
+}
+
+/// Verify the commit message maps DWRF format to "ORC" per Iceberg SDK
+/// convention (Iceberg has no DWRF enum; DWRF files use the ORC identifier).
+TEST_F(IcebergDwrfInsertTest, commitMessageFormat) {
+  const auto outputDirectory = TempDirectoryPath::create();
+  const auto dataPath = outputDirectory->getPath();
+  auto rowType = ROW({"c1", "c2"}, {BIGINT(), VARCHAR()});
+  const auto vectors = createTestData(rowType, 2, 100);
+  const auto dataSink = createDataSinkAndAppendData(vectors, dataPath);
+  const auto commitTasks = dataSink->close();
+
+  ASSERT_GT(commitTasks.size(), 0);
+  for (const auto& task : commitTasks) {
+    auto taskJson = folly::parseJson(task);
+    ASSERT_TRUE(taskJson.count("fileFormat") > 0);
+    ASSERT_EQ(taskJson["fileFormat"].asString(), "ORC");
+  }
+}
+
+/// Round-trips TIMESTAMP values through the DWRF write path with the session
+/// configured for non-UTC timezone and adjustTimestampToTimezone=true. The
+/// Iceberg spec requires timestamps NOT be adjusted to UTC; the DataSink
+/// enforces this by overriding the DWRF WriterOptions fields via
+/// DwrfWriterOptionsAdapter::applyPostConfigs.
+///
+/// TODO: This test is a symmetric Velox-only round-trip and cannot, by
+/// itself, detect a regression where the DataSink stops overriding the DWRF
+/// timezone fields — any write-side shift is exactly cancelled by the
+/// matching read-side shift. The adapter's override contract is locked down
+/// at the unit level by
+/// WriterOptionsAdapterTest::dwrfPostConfigsOverridesTimestampFields. A
+/// true cross-engine validation (e.g., reading Velox-written Iceberg files
+/// with a Java Spark reader) is needed to verify the on-disk timestamp
+/// matches the spec.
+TEST_F(IcebergDwrfInsertTest, timestampRoundTrip) {
+  recreateConnectorQueryCtx(
+      /*sessionTimezone=*/"America/Los_Angeles",
+      /*adjustTimestampToTimezone=*/true);
+  auto rowType = ROW({"c1", "c2"}, {BIGINT(), TIMESTAMP()});
+  test(rowType);
+}
+
+/// End-to-end test for partitioned DWRF writes. Mirrors the identity-
+/// transform partition coverage that exists for Parquet and exercises the
+/// commitPartitionValue_ accounting on the DWRF code path.
+TEST_F(IcebergDwrfInsertTest, partitioned) {
+  auto rowType = ROW({"c1", "c2"}, {BIGINT(), VARCHAR()});
+  const auto outputDirectory = TempDirectoryPath::create();
+  const auto dataPath = outputDirectory->getPath();
+  const auto vectors = createTestData(rowType, 2, 50, 0.2);
+
+  std::vector<test::PartitionField> partitionTransforms = {
+      {0, TransformType::kIdentity, std::nullopt}};
+  const auto dataSink =
+      createDataSinkAndAppendData(vectors, dataPath, partitionTransforms);
+  const auto commitTasks = dataSink->close();
+  ASSERT_GT(commitTasks.size(), 0);
+
+  for (const auto& task : commitTasks) {
+    auto taskJson = folly::parseJson(task);
+    ASSERT_EQ(taskJson["fileFormat"].asString(), "ORC");
+    EXPECT_GT(taskJson.count("partitionDataJson"), 0);
+  }
+
+  auto splits = createSplitsForDirectory(dataPath);
+  ASSERT_EQ(splits.size(), commitTasks.size());
+  auto plan = exec::test::PlanBuilder()
+                  .startTableScan()
+                  .connectorId(test::kIcebergConnectorId)
+                  .outputType(rowType)
+                  .endTableScan()
+                  .planNode();
+  exec::test::AssertQueryBuilder(plan).splits(splits).assertResults(vectors);
+}
+
+/// Regression test for the isPartitioned() guard added to ensureWriter().
+/// Without the guard, calling ensureWriter() on a non-partitioned table
+/// invoked makeCommitPartitionValue(), which dereferences
+/// partitionIdGenerator_ — null for unpartitioned tables — causing a crash.
+/// Exercises the unpartitioned write path explicitly so any future
+/// regression is caught with a named test.
+TEST_F(IcebergDwrfInsertTest, ensureWriterNonPartitioned) {
+  auto rowType = ROW({"c1", "c2"}, {BIGINT(), VARCHAR()});
+  const auto outputDirectory = TempDirectoryPath::create();
+  const auto dataPath = outputDirectory->getPath();
+  const auto vectors = createTestData(rowType, 1, 50);
+
+  // No partitionFields => unpartitioned table, partitionIdGenerator_ stays
+  // null inside the sink. appendData triggers ensureWriter().
+  const auto dataSink = createDataSinkAndAppendData(vectors, dataPath);
+  const auto commitTasks = dataSink->close();
+
+  ASSERT_EQ(commitTasks.size(), 1);
+  auto taskJson = folly::parseJson(commitTasks[0]);
+  // Unpartitioned tables must not emit partitionDataJson.
+  EXPECT_EQ(taskJson.count("partitionDataJson"), 0);
+}
+
+} // namespace
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/tests/IcebergInsertTest.cpp b/velox/connectors/hive/iceberg/tests/IcebergInsertTest.cpp
new file mode 100644
index 00000000000..f7fbee5efe1
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/IcebergInsertTest.cpp
@@ -0,0 +1,272 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/HiveConfig.h"
+#include "velox/connectors/hive/iceberg/IcebergConnector.h"
+#include "velox/connectors/hive/iceberg/tests/IcebergTestBase.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+using namespace facebook::velox::common::testutil;
+
+namespace facebook::velox::connector::hive::iceberg {
+namespace {
+
+#ifdef VELOX_ENABLE_PARQUET
+
+class IcebergInsertTest : public test::IcebergTestBase {
+ protected:
+  void test(const RowTypePtr& rowType, double nullRatio = 0.0) {
+    const auto outputDirectory = TempDirectoryPath::create();
+    const auto dataPath = outputDirectory->getPath();
+    constexpr int32_t numBatches = 10;
+    constexpr int32_t vectorSize = 5'000;
+    const auto vectors =
+        createTestData(rowType, numBatches, vectorSize, nullRatio);
+    const auto dataSink = createDataSinkAndAppendData(vectors, dataPath);
+    const auto commitTasks = dataSink->close();
+
+    auto splits = createSplitsForDirectory(dataPath);
+    ASSERT_EQ(splits.size(), commitTasks.size());
+    auto plan = exec::test::PlanBuilder()
+                    .startTableScan()
+                    .connectorId(test::kIcebergConnectorId)
+                    .outputType(rowType)
+                    .endTableScan()
+                    .planNode();
+    exec::test::AssertQueryBuilder(plan).splits(splits).assertResults(vectors);
+  }
+};
+
+TEST_F(IcebergInsertTest, basic) {
+  auto rowType =
+      ROW({"c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "c10", "c11"},
+          {BIGINT(),
+           INTEGER(),
+           SMALLINT(),
+           BOOLEAN(),
+           REAL(),
+           DECIMAL(18, 5),
+           VARCHAR(),
+           VARBINARY(),
+           DATE(),
+           TIMESTAMP(),
+           ROW({"id", "name"}, {INTEGER(), VARCHAR()})});
+  test(rowType, 0.2);
+}
+
+TEST_F(IcebergInsertTest, mapAndArray) {
+  auto rowType =
+      ROW({"c1", "c2"}, {MAP(INTEGER(), VARCHAR()), ARRAY(VARCHAR())});
+  test(rowType);
+}
+
+TEST_F(IcebergInsertTest, bigDecimal) {
+  auto rowType = ROW({"c1"}, {DECIMAL(38, 5)});
+  fileFormat_ = dwio::common::FileFormat::PARQUET;
+  test(rowType);
+}
+
+TEST_F(IcebergInsertTest, singleColumnPartition) {
+  struct TestCase {
+    std::string name;
+    TypePtr type;
+  };
+
+  std::vector<TestCase> testCases = {
+      {"c1", BIGINT()},
+      {"c2", INTEGER()},
+      {"c3", SMALLINT()},
+      {"c4", DECIMAL(18, 5)},
+      {"c5", BOOLEAN()},
+      {"c6", VARCHAR()},
+      {"c7", DATE()},
+      {"c8", TIMESTAMP()}};
+
+  for (const auto& testCase : testCases) {
+    const auto outputDirectory = TempDirectoryPath::create();
+    constexpr int32_t numBatches = 2;
+    constexpr int32_t vectorSize = 50;
+    auto rowType = ROW({testCase.name}, {testCase.type});
+
+    const auto vectors = createTestData(rowType, numBatches, vectorSize, 0.5);
+    std::vector<test::PartitionField> partitionTransforms = {
+        {0, TransformType::kIdentity, std::nullopt}};
+    const auto dataSink = createDataSinkAndAppendData(
+        vectors, outputDirectory->getPath(), partitionTransforms);
+    const auto commitTasks = dataSink->close();
+    auto splits = createSplitsForDirectory(outputDirectory->getPath());
+
+    ASSERT_GT(commitTasks.size(), 0);
+    ASSERT_EQ(splits.size(), commitTasks.size());
+
+    for (const auto& task : commitTasks) {
+      auto taskJson = folly::parseJson(task);
+      ASSERT_TRUE(taskJson.count("partitionDataJson") > 0);
+    }
+
+    auto plan = exec::test::PlanBuilder()
+                    .startTableScan()
+                    .connectorId(test::kIcebergConnectorId)
+                    .outputType(rowType)
+                    .endTableScan()
+                    .planNode();
+    exec::test::AssertQueryBuilder(plan).splits(splits).assertResults(vectors);
+  }
+}
+
+TEST_F(IcebergInsertTest, partitionNullColumn) {
+  struct TestCase {
+    std::string name;
+    TypePtr type;
+  };
+
+  std::vector<TestCase> testCases = {
+      {"c1", BIGINT()},
+      {"c2", INTEGER()},
+      {"c3", SMALLINT()},
+      {"c4", DECIMAL(18, 5)},
+      {"c5", BOOLEAN()},
+      {"c6", VARCHAR()},
+      {"c7", DATE()},
+      {"c8", TIMESTAMP()}};
+
+  for (const auto& testCase : testCases) {
+    const auto outputDirectory = TempDirectoryPath::create();
+    constexpr int32_t numBatches = 2;
+    constexpr int32_t vectorSize = 100;
+    auto rowType = ROW({testCase.name}, {testCase.type});
+    // nullRatio = 1.0
+    const auto vectors = createTestData(rowType, numBatches, vectorSize, 1.0);
+
+    std::vector<test::PartitionField> partitionTransforms = {
+        {0, TransformType::kIdentity, std::nullopt}};
+    const auto dataSink = createDataSinkAndAppendData(
+        vectors, outputDirectory->getPath(), partitionTransforms);
+
+    const auto commitTasks = dataSink->close();
+    ASSERT_EQ(1, commitTasks.size());
+    auto taskJson = folly::parseJson(commitTasks.at(0));
+    ASSERT_EQ(1, taskJson.count("partitionDataJson"));
+    auto partitionData =
+        folly::parseJson(taskJson["partitionDataJson"].asString());
+    ASSERT_EQ(1, partitionData.count("partitionValues"));
+    auto partitionValues = partitionData["partitionValues"];
+    ASSERT_TRUE(partitionValues.isArray());
+    ASSERT_TRUE(partitionValues[0].isNull());
+
+    auto files = listFiles(outputDirectory->getPath());
+    ASSERT_EQ(files.size(), 1);
+
+    for (const auto& file : files) {
+      auto partitionKeys = extractPartitionKeys(file);
+      ASSERT_EQ(partitionKeys.size(), 1);
+      ASSERT_TRUE(partitionKeys.contains(testCase.name));
+      ASSERT_FALSE(partitionKeys.at(testCase.name).has_value());
+    }
+  }
+}
+
+TEST_F(IcebergInsertTest, partitionMultiColumns) {
+  auto rowType =
+      ROW({"c1", "c2", "c3", "c4"},
+          {
+              BIGINT(),
+              INTEGER(),
+              SMALLINT(),
+              DECIMAL(18, 5),
+          });
+  std::vector<std::vector<int32_t>> columnCombinations = {
+      {0, 1}, // BIGINT, INTEGER.
+      {2, 1}, // SMALLINT, INTEGER.
+      {2, 3}, // SMALLINT, DECIMAL.
+      {0, 2, 1} // BIGINT, SMALLINT, INTEGER.
+  };
+
+  for (const auto& combination : columnCombinations) {
+    const auto outputDirectory = TempDirectoryPath::create();
+    constexpr int32_t numBatches = 2;
+    constexpr int32_t vectorSize = 50;
+
+    std::vector<RowVectorPtr> vectors;
+    vectors.reserve(numBatches);
+    for (int32_t batch = 0; batch < numBatches; ++batch) {
+      vectors.push_back(makeRowVector(
+          rowType->names(),
+          {
+              makeFlatVector<int64_t>(
+                  vectorSize, [](auto row) { return row * 100; }),
+              makeFlatVector<int32_t>(
+                  vectorSize, [](auto row) { return row * 10; }),
+              makeFlatVector<int16_t>(vectorSize, [](auto row) { return row; }),
+              makeFlatVector<int64_t>(
+                  vectorSize,
+                  [](auto row) { return (row * 1000); },
+                  nullptr,
+                  DECIMAL(18, 5)),
+          }));
+    }
+
+    std::vector<test::PartitionField> partitionTransforms;
+    for (auto colIndex : combination) {
+      partitionTransforms.push_back(
+          {colIndex, TransformType::kIdentity, std::nullopt});
+    }
+
+    const auto dataSink = createDataSinkAndAppendData(
+        vectors, outputDirectory->getPath(), partitionTransforms);
+
+    const auto commitTasks = dataSink->close();
+    auto splits = createSplitsForDirectory(outputDirectory->getPath());
+
+    ASSERT_EQ(commitTasks.size(), vectorSize);
+    ASSERT_EQ(splits.size(), commitTasks.size());
+
+    auto plan = exec::test::PlanBuilder()
+                    .startTableScan()
+                    .connectorId(test::kIcebergConnectorId)
+                    .outputType(rowType)
+                    .endTableScan()
+                    .planNode();
+    exec::test::AssertQueryBuilder(plan).splits(splits).assertResults(vectors);
+  }
+}
+
+TEST_F(IcebergInsertTest, maxTargetFileSizeRotation) {
+  setConnectorSessionProperty(HiveConfig::kMaxTargetFileSizeSession, "4KB");
+
+  const auto outputPath = TempDirectoryPath::create()->getPath();
+  const auto rowType = ROW({"c0", "c1"}, {BIGINT(), VARCHAR()});
+  const auto vectors = createTestData(rowType, 10, 1'000);
+  const auto dataSink = createDataSinkAndAppendData(vectors, outputPath);
+  const auto commitTasks = dataSink->close();
+
+  ASSERT_EQ(listFiles(outputPath).size(), 5);
+
+  auto splits = createSplitsForDirectory(outputPath);
+  auto plan = exec::test::PlanBuilder()
+                  .startTableScan()
+                  .connectorId(test::kIcebergConnectorId)
+                  .outputType(rowType)
+                  .endTableScan()
+                  .planNode();
+  exec::test::AssertQueryBuilder(plan).splits(splits).assertResults(vectors);
+}
+
+#endif
+
+} // namespace
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/tests/IcebergParquetStatsTest.cpp b/velox/connectors/hive/iceberg/tests/IcebergParquetStatsTest.cpp
new file mode 100644
index 00000000000..ebab93a2510
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/IcebergParquetStatsTest.cpp
@@ -0,0 +1,881 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Conv.h>
+#include <folly/json.h>
+#include <gtest/gtest.h>
+
+#include "velox/common/encode/Base64.h"
+#include "velox/connectors/hive/iceberg/IcebergDataFileStatistics.h"
+#include "velox/connectors/hive/iceberg/tests/IcebergTestBase.h"
+
+using namespace facebook::velox::common::testutil;
+
+namespace facebook::velox::connector::hive::iceberg {
+
+namespace {
+
+#ifdef VELOX_ENABLE_PARQUET
+
+class IcebergParquetStatsTest : public test::IcebergTestBase {
+ protected:
+  static IcebergDataFileStatisticsPtr statsFromMetrics(
+      const folly::dynamic& metrics) {
+    VELOX_CHECK(metrics.isObject());
+    VELOX_CHECK(metrics.count("recordCount") > 0);
+    auto stats = std::make_shared<IcebergDataFileStatistics>();
+    stats->numRecords = metrics["recordCount"].asInt();
+
+    auto setIntField = [&](const folly::dynamic& map, auto setter) {
+      if (!map.isObject()) {
+        return;
+      }
+      for (const auto& item : map.items()) {
+        const auto fieldId = folly::to<int32_t>(item.first.asString());
+        auto& column = stats->columnStats[fieldId];
+        setter(column, item.second);
+      }
+    };
+
+    setIntField(metrics["columnSizes"], [](auto& column, const auto& value) {
+      column.columnSize = value.asInt();
+    });
+    setIntField(metrics["valueCounts"], [](auto& column, const auto& value) {
+      column.valueCount = value.asInt();
+    });
+    setIntField(
+        metrics["nullValueCounts"], [](auto& column, const auto& value) {
+          column.nullValueCount = value.asInt();
+        });
+    setIntField(metrics["nanValueCounts"], [](auto& column, const auto& value) {
+      column.nanValueCount = value.asInt();
+    });
+
+    const auto& lowerBounds = metrics["lowerBounds"];
+    if (lowerBounds.isObject()) {
+      for (const auto& item : lowerBounds.items()) {
+        const auto fieldId = folly::to<int32_t>(item.first.asString());
+        stats->columnStats[fieldId].lowerBound = item.second.asString();
+      }
+    }
+    const auto& upperBounds = metrics["upperBounds"];
+    if (upperBounds.isObject()) {
+      for (const auto& item : upperBounds.items()) {
+        const auto fieldId = folly::to<int32_t>(item.first.asString());
+        stats->columnStats[fieldId].upperBound = item.second.asString();
+      }
+    }
+
+    return stats;
+  }
+
+  static std::vector<IcebergDataFileStatisticsPtr> statsFromCommitTasks(
+      const std::vector<std::string>& commitTasks) {
+    std::vector<IcebergDataFileStatisticsPtr> stats;
+    stats.reserve(commitTasks.size());
+    for (const auto& task : commitTasks) {
+      auto taskJson = folly::parseJson(task);
+      VELOX_CHECK(taskJson.isObject());
+      VELOX_CHECK(taskJson.count("metrics") > 0);
+      stats.emplace_back(statsFromMetrics(taskJson["metrics"]));
+    }
+    return stats;
+  }
+
+  // Write data and get all stats (for partitioned tables).
+  std::vector<std::shared_ptr<IcebergDataFileStatistics>>
+  writeDataAndGetAllStats(
+      const RowVectorPtr& data,
+      const std::vector<test::PartitionField>& partitionFields = {}) {
+    const auto outputDir = TempDirectoryPath::create();
+    auto dataSink = createDataSinkAndAppendData(
+        {data}, outputDir->getPath(), partitionFields);
+    auto commitTasks = dataSink->close();
+    EXPECT_FALSE(commitTasks.empty());
+    return statsFromCommitTasks(commitTasks);
+  }
+
+  // Decode and extract typed value from base64 encoded bounds.
+  template <typename T>
+  static std::pair<T, T> decodeBounds(
+      const std::shared_ptr<IcebergDataFileStatistics>& stats,
+      int32_t fieldId) {
+    auto decode = [](const std::string& base64Encoded) {
+      const std::string decoded = encoding::Base64::decode(base64Encoded);
+      T value;
+      std::memcpy(&value, decoded.data(), sizeof(T));
+      return value;
+    };
+
+    const auto& columnStats = stats->columnStats.at(fieldId);
+    VELOX_CHECK(columnStats.lowerBound.has_value());
+    VELOX_CHECK(columnStats.upperBound.has_value());
+    return {
+        decode(columnStats.lowerBound.value()),
+        decode(columnStats.upperBound.value()),
+    };
+  }
+
+  // Verify basic statistics (record count, value counts, null counts).
+  static void verifyBasicStats(
+      const std::shared_ptr<IcebergDataFileStatistics>& stats,
+      int64_t expectedRecords,
+      const std::unordered_map<int32_t, int64_t>& expectedValueCounts,
+      const std::unordered_map<int32_t, int64_t>& expectedNullCounts) {
+    EXPECT_EQ(stats->numRecords, expectedRecords);
+
+    for (const auto& [fieldId, count] : expectedValueCounts) {
+      ASSERT_TRUE(stats->columnStats.contains(fieldId));
+      EXPECT_EQ(stats->columnStats.at(fieldId).valueCount, count);
+    }
+
+    if (!expectedNullCounts.empty()) {
+      for (const auto& [fieldId, count] : expectedNullCounts) {
+        ASSERT_TRUE(stats->columnStats.contains(fieldId));
+        EXPECT_EQ(stats->columnStats.at(fieldId).nullValueCount, count);
+      }
+    }
+  }
+
+  // Verify bounds exist for given field IDs.
+  static void verifyBoundsExist(
+      const std::shared_ptr<IcebergDataFileStatistics>& stats,
+      const std::vector<int32_t>& fieldIds) {
+    for (const int32_t fieldId : fieldIds) {
+      ASSERT_TRUE(stats->columnStats.contains(fieldId));
+      const auto& columnStats = stats->columnStats.at(fieldId);
+      ASSERT_TRUE(columnStats.lowerBound.has_value());
+      ASSERT_TRUE(columnStats.upperBound.has_value());
+      EXPECT_FALSE(columnStats.lowerBound.value().empty());
+      EXPECT_FALSE(columnStats.upperBound.value().empty());
+    }
+  }
+
+  // Verify bounds do not exist for given field IDs.
+  static void verifyBoundsNotExist(
+      const std::shared_ptr<IcebergDataFileStatistics>& stats,
+      const std::vector<int32_t>& fieldIds) {
+    for (const int32_t fieldId : fieldIds) {
+      if (stats->columnStats.contains(fieldId)) {
+        const auto& columnStats = stats->columnStats.at(fieldId);
+        ASSERT_FALSE(columnStats.lowerBound.has_value());
+        ASSERT_FALSE(columnStats.upperBound.has_value());
+      }
+    }
+  }
+};
+
+TEST_F(IcebergParquetStatsTest, mixedNull) {
+  constexpr vector_size_t size = 100;
+  constexpr int32_t expectedIntNulls = 34;
+  constexpr int32_t intColId = 1;
+
+  const auto& stats =
+      writeDataAndGetAllStats(makeRowVector({makeFlatVector<int32_t>(
+          size, [](vector_size_t row) { return row * 10; }, nullEvery(3))}));
+  verifyBasicStats(
+      stats[0], size, {{intColId, size}}, {{intColId, expectedIntNulls}});
+  verifyBoundsExist(stats[0], {intColId});
+
+  const auto& [minVal, maxVal] = decodeBounds<int32_t>(stats[0], intColId);
+  EXPECT_EQ(minVal, 10);
+  EXPECT_EQ(maxVal, 980);
+}
+
+TEST_F(IcebergParquetStatsTest, bigint) {
+  constexpr vector_size_t size = 100;
+  constexpr int32_t expectedNulls = 25;
+  constexpr int32_t bigintColId = 1;
+
+  const auto& stats =
+      writeDataAndGetAllStats(makeRowVector({makeFlatVector<int64_t>(
+          size,
+          [](vector_size_t row) { return row * 1'000'000'000LL; },
+          nullEvery(4))}));
+  verifyBasicStats(
+      stats[0], size, {{bigintColId, size}}, {{bigintColId, expectedNulls}});
+  verifyBoundsExist(stats[0], {bigintColId});
+
+  const auto& [minVal, maxVal] = decodeBounds<int64_t>(stats[0], bigintColId);
+  EXPECT_EQ(minVal, 1'000'000'000LL);
+  EXPECT_EQ(maxVal, 99'000'000'000LL);
+}
+
+TEST_F(IcebergParquetStatsTest, decimal) {
+  constexpr vector_size_t size = 100;
+  constexpr int32_t expectedNulls = 20;
+  constexpr int32_t decimalColId = 1;
+
+  const auto& stats =
+      writeDataAndGetAllStats(makeRowVector({makeFlatVector<int128_t>(
+          size,
+          [](vector_size_t row) { return HugeInt::build(row, row * 123); },
+          nullEvery(5),
+          DECIMAL(38, 3))}));
+  verifyBasicStats(
+      stats[0], size, {{decimalColId, size}}, {{decimalColId, expectedNulls}});
+  verifyBoundsExist(stats[0], {decimalColId});
+}
+
+TEST_F(IcebergParquetStatsTest, varchar) {
+  constexpr vector_size_t size = 100;
+  constexpr int32_t varcharColId = 1;
+
+  const auto& stats =
+      writeDataAndGetAllStats(makeRowVector({makeFlatVector<std::string>(
+          size,
+          [](vector_size_t row) {
+            return "Customer#00000" + std::to_string(row) + "_" +
+                std::string(row % 10, 'a');
+          },
+          nullEvery(6))}));
+
+  constexpr int32_t expectedNulls = 17;
+  verifyBasicStats(
+      stats[0], size, {{varcharColId, size}}, {{varcharColId, expectedNulls}});
+  verifyBoundsExist(stats[0], {varcharColId});
+
+  EXPECT_EQ(
+      encoding::Base64::decode(
+          stats[0]->columnStats.at(varcharColId).lowerBound.value()),
+      "Customer#0000010");
+  EXPECT_EQ(
+      encoding::Base64::decode(
+          stats[0]->columnStats.at(varcharColId).upperBound.value()),
+      "Customer#000009`");
+}
+
+TEST_F(IcebergParquetStatsTest, varbinary) {
+  constexpr vector_size_t size = 100;
+  constexpr int32_t varbinaryColId = 1;
+
+  auto rowVector = makeRowVector({makeFlatVector<std::string>(
+      size,
+      [](vector_size_t row) {
+        std::string value(17, 11);
+        value[0] = static_cast<char>(row % 256);
+        value[1] = static_cast<char>((row * 3) % 256);
+        value[2] = static_cast<char>((row * 7) % 256);
+        value[3] = static_cast<char>((row * 11) % 256);
+        return value;
+      },
+      nullEvery(5),
+      VARBINARY())});
+
+  const auto& stats = writeDataAndGetAllStats(rowVector);
+  constexpr int32_t expectedNulls = 20;
+  verifyBasicStats(
+      stats[0],
+      size,
+      {{varbinaryColId, size}},
+      {{varbinaryColId, expectedNulls}});
+  verifyBoundsExist(stats[0], {varbinaryColId});
+}
+
+TEST_F(IcebergParquetStatsTest, varbinaryWithTransform) {
+  const auto& fileStats = writeDataAndGetAllStats(
+      makeRowVector({makeFlatVector<std::string>(
+          {"01020304",
+           "05060708",
+           "090A0B0C",
+           "0D0E0F10",
+           "11121314",
+           "15161718",
+           "191A1B1C",
+           "1D1E1F20",
+           "21222324",
+           "25262728"},
+          VARBINARY())}),
+      {{0, TransformType::kBucket, 4}});
+  ASSERT_EQ(fileStats.size(), 3);
+  const auto& stats = fileStats[0];
+  EXPECT_EQ(stats->numRecords, 5);
+  constexpr int32_t varbinaryColId = 1;
+  EXPECT_EQ(stats->columnStats.at(varbinaryColId).valueCount, 5);
+}
+
+TEST_F(IcebergParquetStatsTest, multipleDataTypes) {
+  constexpr vector_size_t size = 100;
+  constexpr int32_t intColId = 1;
+  constexpr int32_t bigintColId = 2;
+  constexpr int32_t decimalColId = 3;
+  constexpr int32_t varcharColId = 4;
+  constexpr int32_t varbinaryColId = 5;
+
+  constexpr int32_t expectedIntNulls = 34;
+  constexpr int32_t expectedBigintNulls = 25;
+  constexpr int32_t expectedDecimalNulls = 20;
+  constexpr int32_t expectedVarcharNulls = 17;
+  constexpr int32_t expectedVarbinaryNulls = 15;
+
+  auto rowVector = makeRowVector(
+      {makeFlatVector<int32_t>(
+           size, [](vector_size_t row) { return row * 10; }, nullEvery(3)),
+       makeFlatVector<int64_t>(
+           size,
+           [](vector_size_t row) { return row * 1'000'000'000LL; },
+           nullEvery(4)),
+       makeFlatVector<int128_t>(
+           size,
+           [](vector_size_t row) { return HugeInt::build(row, row * 12'345); },
+           nullEvery(5),
+           DECIMAL(38, 3)),
+       makeFlatVector<std::string>(
+           size,
+           [](vector_size_t row) { return "str_" + std::to_string(row); },
+           nullEvery(6)),
+       makeFlatVector<std::string>(
+           size,
+           [](vector_size_t row) {
+             std::string value(4, 0);
+             value[0] = static_cast<char>(row % 256);
+             value[1] = static_cast<char>((row * 3) % 256);
+             value[2] = static_cast<char>((row * 7) % 256);
+             value[3] = static_cast<char>((row * 11) % 256);
+             return value;
+           },
+           nullEvery(7),
+           VARBINARY())});
+  const auto& stats = writeDataAndGetAllStats(rowVector);
+
+  verifyBasicStats(
+      stats[0],
+      size,
+      {
+          {intColId, size},
+          {bigintColId, size},
+          {decimalColId, size},
+          {varcharColId, size},
+          {varbinaryColId, size},
+      },
+      {
+          {intColId, expectedIntNulls},
+          {bigintColId, expectedBigintNulls},
+          {decimalColId, expectedDecimalNulls},
+          {varcharColId, expectedVarcharNulls},
+          {varbinaryColId, expectedVarbinaryNulls},
+      });
+
+  verifyBoundsExist(
+      stats[0],
+      {intColId, bigintColId, decimalColId, varcharColId, varbinaryColId});
+}
+
+TEST_F(IcebergParquetStatsTest, date) {
+  constexpr vector_size_t size = 100;
+  constexpr int32_t expectedNulls = 20;
+  constexpr int32_t dateColId = 1;
+
+  const auto& stats =
+      writeDataAndGetAllStats(makeRowVector({makeFlatVector<int32_t>(
+          size,
+          [](vector_size_t row) { return 18262 + row; },
+          nullEvery(5),
+          DATE())}));
+  verifyBasicStats(
+      stats[0], size, {{dateColId, size}}, {{dateColId, expectedNulls}});
+  verifyBoundsExist(stats[0], {dateColId});
+
+  const auto& [minVal, maxVal] = decodeBounds<int32_t>(stats[0], dateColId);
+  EXPECT_EQ(minVal, 18263);
+  EXPECT_EQ(maxVal, 18262 + 99);
+}
+
+TEST_F(IcebergParquetStatsTest, boolean) {
+  constexpr vector_size_t size = 100;
+  constexpr int32_t expectedNulls = 10;
+  constexpr int32_t boolColId = 1;
+
+  const auto& stats =
+      writeDataAndGetAllStats(makeRowVector({makeFlatVector<bool>(
+          size,
+          [](vector_size_t row) { return row % 2 == 1; },
+          nullEvery(10),
+          BOOLEAN())}));
+  verifyBasicStats(
+      stats[0], size, {{boolColId, size}}, {{boolColId, expectedNulls}});
+  verifyBoundsExist(stats[0], {boolColId});
+
+  // For boolean, the lower bound should be false (0) and upper bound should be
+  // true (1) if both values are present.
+  const auto& [minVal, maxVal] = decodeBounds<bool>(stats[0], boolColId);
+  EXPECT_FALSE(minVal);
+  EXPECT_TRUE(maxVal);
+}
+
+TEST_F(IcebergParquetStatsTest, empty) {
+  const auto outputDir = TempDirectoryPath::create();
+  auto dataSink = createDataSinkAndAppendData(
+      {makeRowVector(
+          {makeFlatVector<int32_t>(0), makeFlatVector<StringView>(0)})},
+      outputDir->getPath());
+  auto commitTasks = dataSink->close();
+  EXPECT_TRUE(commitTasks.empty());
+}
+
+TEST_F(IcebergParquetStatsTest, nullValues) {
+  constexpr vector_size_t size = 100;
+
+  const auto& stats = writeDataAndGetAllStats(makeRowVector(
+      {makeNullConstant(TypeKind::INTEGER, size),
+       makeNullConstant(TypeKind::VARCHAR, size)}));
+  EXPECT_EQ(stats[0]->numRecords, size);
+  ASSERT_EQ(stats[0]->columnStats.at(1).nullValueCount, size);
+  // Do not collect lower and upper bounds for NULLs.
+  for (const auto& [fieldId, columnStats] : stats[0]->columnStats) {
+    ASSERT_FALSE(columnStats.lowerBound.has_value());
+    ASSERT_FALSE(columnStats.upperBound.has_value());
+  }
+}
+
+TEST_F(IcebergParquetStatsTest, real) {
+  constexpr vector_size_t size = 100;
+  constexpr int32_t expectedNulls = 20;
+  constexpr int32_t realColId = 1;
+  int32_t expectedNaNs = 0;
+
+  const auto& stats =
+      writeDataAndGetAllStats(makeRowVector({makeFlatVector<float>(
+          size,
+          [&expectedNaNs](vector_size_t row) {
+            if (row % 6 == 0) {
+              expectedNaNs++;
+              return std::numeric_limits<float>::quiet_NaN();
+            }
+            return row * 1.5f;
+          },
+          nullEvery(5),
+          REAL())}));
+  verifyBasicStats(
+      stats[0], size, {{realColId, size}}, {{realColId, expectedNulls}});
+
+  EXPECT_EQ(
+      stats[0]->columnStats.at(realColId).nanValueCount.value_or(0),
+      expectedNaNs);
+  verifyBoundsExist(stats[0], {realColId});
+  const auto& [minVal, maxVal] = decodeBounds<float>(stats[0], realColId);
+  EXPECT_FLOAT_EQ(minVal, 1.5f);
+  EXPECT_FLOAT_EQ(maxVal, 148.5f);
+}
+
+TEST_F(IcebergParquetStatsTest, double) {
+  constexpr vector_size_t size = 100;
+  constexpr int32_t expectedNulls = 15;
+  constexpr int32_t doubleColId = 1;
+  int32_t expectedNaNs = 0;
+
+  auto rowVector = makeRowVector({makeFlatVector<double>(
+      size,
+      [&expectedNaNs](vector_size_t row) {
+        if (row % 3 == 0) {
+          expectedNaNs++;
+          return std::numeric_limits<double>::quiet_NaN();
+        }
+        if (row % 4 == 0) {
+          return std::numeric_limits<double>::infinity();
+        }
+        if (row % 5 == 0) {
+          return -std::numeric_limits<double>::infinity();
+        }
+        return row * 2.5;
+      },
+      nullEvery(7),
+      DOUBLE())});
+
+  const auto& stats = writeDataAndGetAllStats(rowVector);
+  verifyBasicStats(
+      stats[0], size, {{doubleColId, size}}, {{doubleColId, expectedNulls}});
+
+  EXPECT_EQ(
+      stats[0]->columnStats.at(doubleColId).nanValueCount.value_or(0),
+      expectedNaNs);
+
+  verifyBoundsExist(stats[0], {doubleColId});
+
+  // Verify bounds are set correctly and NaN/infinity values don't affect
+  // min/max incorrectly.
+  const auto& [minVal, maxVal] = decodeBounds<double>(stats[0], doubleColId);
+  EXPECT_DOUBLE_EQ(minVal, -std::numeric_limits<double>::infinity())
+      << "Lower bound should be -infinity";
+  EXPECT_DOUBLE_EQ(maxVal, std::numeric_limits<double>::infinity())
+      << "Upper bound should be infinity";
+}
+
+TEST_F(IcebergParquetStatsTest, mixedDoubleFloat) {
+  constexpr vector_size_t size = 6;
+
+  auto rowVector = makeRowVector(
+      {makeFlatVector<int32_t>(size, [](vector_size_t row) { return 1; }),
+       makeFlatVector<float>(
+           size,
+           [](vector_size_t row) {
+             return -std::numeric_limits<float>::infinity();
+           }),
+       makeFlatVector<double>(
+           size,
+           [](vector_size_t row) {
+             return std::numeric_limits<double>::infinity();
+           }),
+       makeFlatVector<double>(size, [](vector_size_t row) {
+         switch (row) {
+           case 0:
+             return 1.23;
+           case 1:
+             return -1.23;
+           case 2:
+             return std::numeric_limits<double>::infinity();
+           case 3:
+             return 2.23;
+           case 4:
+             return -std::numeric_limits<double>::infinity();
+           default:
+             return -2.23;
+         }
+       })});
+
+  const auto& stats = writeDataAndGetAllStats(rowVector);
+  constexpr int32_t doubleColId = 4;
+  verifyBasicStats(stats[0], size, {{doubleColId, size}}, {{doubleColId, 0}});
+  const auto& [minVal, maxVal] = decodeBounds<double>(stats[0], doubleColId);
+  EXPECT_DOUBLE_EQ(minVal, -std::numeric_limits<double>::infinity());
+  EXPECT_DOUBLE_EQ(maxVal, std::numeric_limits<double>::infinity());
+
+  constexpr int32_t floatColId = 2;
+  const auto& [minFloatVal, maxFloatVal] =
+      decodeBounds<float>(stats[0], floatColId);
+  EXPECT_FLOAT_EQ(minFloatVal, -std::numeric_limits<float>::infinity());
+  EXPECT_FLOAT_EQ(maxFloatVal, -std::numeric_limits<float>::infinity());
+}
+
+TEST_F(IcebergParquetStatsTest, NaN) {
+  constexpr vector_size_t size = 1'000;
+  constexpr int32_t expectedNulls = 500;
+  constexpr int32_t doubleColId = 1;
+  int32_t expectedNaNs = 0;
+
+  const auto& stats =
+      writeDataAndGetAllStats(makeRowVector({makeFlatVector<double>(
+          size,
+          [&expectedNaNs](vector_size_t /*row*/) {
+            expectedNaNs++;
+            return std::numeric_limits<double>::quiet_NaN();
+          },
+          nullEvery(2),
+          DOUBLE())}));
+  verifyBasicStats(
+      stats[0], size, {{doubleColId, size}}, {{doubleColId, expectedNulls}});
+
+  EXPECT_EQ(
+      stats[0]->columnStats.at(doubleColId).nanValueCount.value_or(0),
+      expectedNaNs);
+  // Do not collect bounds for NULLs and NaNs.
+  for (const auto& [fieldId, columnStats] : stats[0]->columnStats) {
+    ASSERT_FALSE(columnStats.lowerBound.has_value());
+    ASSERT_FALSE(columnStats.upperBound.has_value());
+  }
+}
+
+TEST_F(IcebergParquetStatsTest, partitionedTable) {
+  std::vector<test::PartitionField> partitionTransforms = {
+      {0, TransformType::kBucket, 4},
+      {1, TransformType::kDay, std::nullopt},
+      {2, TransformType::kTruncate, 2},
+  };
+
+  constexpr vector_size_t size = 100;
+
+  auto rowVector = makeRowVector(
+      {makeFlatVector<int32_t>(size, [](vector_size_t row) { return row; }),
+       makeFlatVector<int32_t>(
+           size,
+           [](vector_size_t row) { return 18262 + (row % 5); },
+           nullptr,
+           DATE()),
+       makeFlatVector<std::string>(size, [](vector_size_t row) {
+         return fmt::format("str{}", row % 10);
+       })});
+
+  const auto& fileStats =
+      writeDataAndGetAllStats(rowVector, partitionTransforms);
+
+  EXPECT_GT(fileStats.size(), 1)
+      << "Expected multiple files due to partitioning";
+
+  for (const auto& stats : fileStats) {
+    EXPECT_GT(stats->numRecords, 0);
+    ASSERT_FALSE(stats->columnStats.empty());
+
+    constexpr int32_t intColId = 1;
+    constexpr int32_t dateColId = 2;
+    constexpr int32_t varcharColId = 3;
+    EXPECT_EQ(stats->columnStats.at(intColId).valueCount, stats->numRecords);
+    EXPECT_EQ(stats->columnStats.at(dateColId).valueCount, stats->numRecords);
+    EXPECT_EQ(
+        stats->columnStats.at(varcharColId).valueCount, stats->numRecords);
+
+    for (const auto fieldId : {intColId, dateColId, varcharColId}) {
+      const auto& columnStats = stats->columnStats.at(fieldId);
+      ASSERT_TRUE(columnStats.lowerBound.has_value());
+      ASSERT_TRUE(columnStats.upperBound.has_value());
+      EXPECT_FALSE(columnStats.lowerBound.value().empty());
+      EXPECT_FALSE(columnStats.upperBound.value().empty());
+    }
+  }
+
+  // Verify total record count across all partitions.
+  int64_t totalRecords = 0;
+  for (const auto& stats : fileStats) {
+    totalRecords += stats->numRecords;
+  }
+  EXPECT_EQ(totalRecords, size);
+}
+
+TEST_F(IcebergParquetStatsTest, multiplePartitionTransforms) {
+  std::vector<test::PartitionField> partitionTransforms = {
+      {0, TransformType::kBucket, 2},
+      {1, TransformType::kYear, std::nullopt},
+      {2, TransformType::kTruncate, 3},
+      {3, TransformType::kIdentity, std::nullopt}};
+
+  constexpr vector_size_t size = 100;
+
+  auto rowVector = makeRowVector(
+      {makeFlatVector<int32_t>(
+           size, [](vector_size_t row) { return row * 10; }),
+       makeFlatVector<int32_t>(
+           size,
+           [](vector_size_t row) { return 18262 + (row * 100); },
+           nullptr,
+           DATE()),
+       makeFlatVector<std::string>(
+           size,
+           [](vector_size_t row) {
+             return fmt::format("prefix{}_value", row % 5);
+           }),
+       makeFlatVector<int64_t>(
+           size, [](vector_size_t row) { return (row % 3) * 1'000; })});
+
+  const auto& fileStats =
+      writeDataAndGetAllStats(rowVector, partitionTransforms);
+  EXPECT_GT(fileStats.size(), 1)
+      << "Expected multiple files due to partitioning";
+  // Check each file's stats.
+  for (const auto& stats : fileStats) {
+    EXPECT_GT(stats->numRecords, 0);
+    constexpr int32_t intColId = 1;
+    constexpr int32_t dateColId = 2;
+    constexpr int32_t bigintColId = 4;
+
+    if (stats->columnStats.contains(intColId)) {
+      const auto& [minVal, maxVal] = decodeBounds<int32_t>(stats, intColId);
+      EXPECT_LE(minVal, maxVal)
+          << "Lower bound should be <= upper bound for int column";
+    }
+
+    if (stats->columnStats.contains(dateColId)) {
+      const auto& [minVal, maxVal] = decodeBounds<int32_t>(stats, dateColId);
+      EXPECT_LE(minVal, maxVal)
+          << "Lower bound should be <= upper bound for date column";
+    }
+
+    if (stats->columnStats.contains(bigintColId)) {
+      const auto& [minVal, maxVal] = decodeBounds<int64_t>(stats, bigintColId);
+      EXPECT_LE(minVal, maxVal)
+          << "Lower bound should be <= upper bound for bigint column";
+    }
+  }
+  int64_t totalRecords = 0;
+  for (const auto& stats : fileStats) {
+    totalRecords += stats->numRecords;
+  }
+  EXPECT_EQ(totalRecords, size);
+}
+
+TEST_F(IcebergParquetStatsTest, partitionedTableWithNulls) {
+  constexpr vector_size_t size = 100;
+  constexpr int32_t expectedIntNulls = 20;
+  constexpr int32_t expectedDateNulls = 15;
+  constexpr int32_t expectedVarcharNulls = 10;
+
+  std::vector<test::PartitionField> partitionTransforms = {
+      {0, TransformType::kIdentity, std::nullopt},
+      {1, TransformType::kMonth, std::nullopt},
+      {2, TransformType::kTruncate, 2}};
+  auto rowVector = makeRowVector(
+      {makeFlatVector<int32_t>(
+           size,
+           [](vector_size_t row) { return row % 10; },
+           nullEvery(5),
+           INTEGER()),
+       makeFlatVector<int32_t>(
+           size,
+           [](vector_size_t row) { return 18262 + (row % 3) * 30; },
+           nullEvery(7),
+           DATE()),
+       makeFlatVector<std::string>(
+           size,
+           [](vector_size_t row) { return fmt::format("val{}", row % 5); },
+           nullEvery(11))});
+  const auto& fileStats =
+      writeDataAndGetAllStats(rowVector, partitionTransforms);
+  int32_t totalIntNulls = 0;
+  int32_t totalDateNulls = 0;
+  int32_t totalVarcharNulls = 0;
+  int32_t totalRecords = 0;
+
+  constexpr int32_t intColId = 1;
+  constexpr int32_t dateColId = 2;
+  constexpr int32_t varcharColId = 3;
+
+  for (const auto& stats : fileStats) {
+    totalRecords += stats->numRecords;
+    // Add null counts if present.
+    if (stats->columnStats.contains(intColId)) {
+      totalIntNulls += stats->columnStats.at(intColId).nullValueCount;
+    }
+
+    if (stats->columnStats.contains(dateColId)) {
+      totalDateNulls += stats->columnStats.at(dateColId).nullValueCount;
+    }
+
+    if (stats->columnStats.contains(varcharColId)) {
+      totalVarcharNulls += stats->columnStats.at(varcharColId).nullValueCount;
+    }
+  }
+
+  // Verify total counts match expected.
+  EXPECT_EQ(totalRecords, size);
+  EXPECT_EQ(totalIntNulls, expectedIntNulls);
+  EXPECT_EQ(totalDateNulls, expectedDateNulls);
+  EXPECT_EQ(totalVarcharNulls, expectedVarcharNulls);
+}
+
+TEST_F(IcebergParquetStatsTest, mapType) {
+  constexpr vector_size_t size = 100;
+  constexpr int32_t intColId = 1;
+  constexpr int32_t mapValueColId = 3; // Map value field ID.
+
+  std::vector<std::optional<
+      std::vector<std::pair<int32_t, std::optional<std::string>>>>>
+      mapData;
+  for (auto i = 0; i < size; ++i) {
+    std::vector<std::pair<int32_t, std::optional<std::string>>> mapRow;
+    for (auto j = 0; j < 5; ++j) {
+      mapRow.emplace_back(j, fmt::format("value_{}", i * 5 + j));
+    }
+    mapData.push_back(std::move(mapRow));
+  }
+
+  const auto& stats = writeDataAndGetAllStats(makeRowVector({
+      makeFlatVector<int32_t>(size, [](auto row) { return row * 10; }),
+      makeNullableMapVector<int32_t, std::string>(mapData),
+  }));
+  verifyBasicStats(stats[0], size, {{intColId, size}}, {{intColId, 0}});
+
+  EXPECT_EQ(stats[0]->columnStats.at(mapValueColId).valueCount, size * 5);
+  // Map values have stats but no bounds (skipBounds=true for maps).
+  verifyBoundsNotExist(stats[0], {mapValueColId});
+}
+
+TEST_F(IcebergParquetStatsTest, arrayType) {
+  constexpr vector_size_t size = 100;
+  constexpr int32_t intColId = 1;
+  constexpr int32_t arrayElementColId = 3; // Array element field ID.
+
+  std::vector<std::vector<std::optional<std::string>>> arrayData;
+  for (auto i = 0; i < size; ++i) {
+    std::vector<std::optional<std::string>> arrayRow;
+    for (auto j = 0; j < 3; ++j) {
+      arrayRow.emplace_back(fmt::format("item_{}", i * 3 + j));
+    }
+    arrayData.push_back(std::move(arrayRow));
+  }
+
+  const auto& stats = writeDataAndGetAllStats(makeRowVector(
+      {makeFlatVector<int32_t>(size, [](auto row) { return row * 10; }),
+       makeNullableArrayVector<std::string>(arrayData)}));
+  verifyBasicStats(stats[0], size, {{intColId, size}}, {{intColId, 0}});
+
+  EXPECT_EQ(stats[0]->columnStats.at(arrayElementColId).valueCount, size * 3);
+  // Array elements have stats but no bounds (skipBounds=true for arrays).
+  verifyBoundsNotExist(stats[0], {arrayElementColId});
+}
+
+// Test statistics collection for nested struct fields.
+// Field ID assignment:
+//   int_col: 1
+//   struct_col: 2 (parent, no stats)
+//     first_level_id: 3
+//     first_level_name: 4
+//     nested_struct: 5 (parent, no stats)
+//       second_level_id: 6
+//       second_level_name: 7
+// Statistics collected for leaf fields: [1, 3, 4, 6, 7]
+TEST_F(IcebergParquetStatsTest, structType) {
+  constexpr vector_size_t size = 100;
+  constexpr int32_t intColId = 1;
+  constexpr int32_t firstLevelIdColId = 3;
+  constexpr int32_t secondLevelIdColId = 6;
+  constexpr int32_t secondLevelNameColId = 7;
+
+  auto firstLevelId = makeFlatVector<int32_t>(
+      size, [](vector_size_t row) { return row % size; }, nullEvery(5));
+
+  auto firstLevelName = makeFlatVector<std::string>(
+      size,
+      [](vector_size_t row) { return fmt::format("name_{}", row * 10); },
+      nullEvery(7));
+
+  auto secondLevelId = makeFlatVector<int32_t>(
+      size, [](vector_size_t row) { return row * size; }, nullEvery(6));
+
+  auto secondLevelName = makeFlatVector<std::string>(
+      size,
+      [](vector_size_t row) { return fmt::format("nested_{}", row * 100); },
+      nullEvery(8));
+
+  auto nestedStruct = makeRowVector({secondLevelId, secondLevelName});
+  auto structVector =
+      makeRowVector({firstLevelId, firstLevelName, nestedStruct});
+  auto rowVector = makeRowVector(
+      {makeFlatVector<int32_t>(size, [](auto row) { return row * 10; }),
+       structVector});
+
+  const auto& stats = writeDataAndGetAllStats(rowVector);
+  EXPECT_EQ(stats[0]->numRecords, size);
+  EXPECT_EQ(stats[0]->columnStats.size(), 5);
+
+  verifyBasicStats(
+      stats[0],
+      size,
+      {{intColId, size}, {firstLevelIdColId, size}, {secondLevelIdColId, size}},
+      {{intColId, 0}, {firstLevelIdColId, 20}});
+
+  EXPECT_EQ(
+      encoding::Base64::decode(
+          stats[0]->columnStats.at(secondLevelNameColId).lowerBound.value()),
+      "nested_100");
+  EXPECT_EQ(
+      encoding::Base64::decode(
+          stats[0]->columnStats.at(secondLevelNameColId).upperBound.value()),
+      "nested_9900");
+}
+
+#endif
+
+} // namespace
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/tests/IcebergReadTest.cpp b/velox/connectors/hive/iceberg/tests/IcebergReadTest.cpp
index c8269083d52..71c1ae4b621 100644
--- a/velox/connectors/hive/iceberg/tests/IcebergReadTest.cpp
+++ b/velox/connectors/hive/iceberg/tests/IcebergReadTest.cpp
@@ -14,29 +14,47 @@
  * limitations under the License.
  */
 
+#include <folly/Singleton.h>
+#include <folly/lang/Bits.h>
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/encode/Base64.h"
 #include "velox/common/file/FileSystems.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/connectors/hive/iceberg/IcebergColumnHandle.h"
+#include "velox/connectors/hive/iceberg/IcebergConnector.h"
 #include "velox/connectors/hive/iceberg/IcebergDeleteFile.h"
 #include "velox/connectors/hive/iceberg/IcebergMetadataColumns.h"
 #include "velox/connectors/hive/iceberg/IcebergSplit.h"
 #include "velox/dwio/common/tests/utils/DataFiles.h"
 #include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
+
 #ifdef VELOX_ENABLE_PARQUET
 #include "velox/dwio/parquet/RegisterParquetReader.h"
 #endif
 
-#include <folly/Singleton.h>
-
 using namespace facebook::velox::exec::test;
 using namespace facebook::velox::exec;
 using namespace facebook::velox::dwio::common;
 using namespace facebook::velox::test;
+using namespace facebook::velox::common::testutil;
 
 namespace facebook::velox::connector::hive::iceberg {
 
+namespace {
+// Return the file size for the given path using Velox's filesystem API.
+uint64_t getTestFileSize(const std::string& path) {
+  return filesystems::getFileSystem(path, nullptr)
+      ->openFileForRead(path)
+      ->size();
+}
+} // namespace
+
+static const char* kIcebergConnectorId = "test-iceberg";
+
 class HiveIcebergTest : public HiveConnectorTestBase {
  public:
   void SetUp() override {
@@ -44,6 +62,20 @@ class HiveIcebergTest : public HiveConnectorTestBase {
 #ifdef VELOX_ENABLE_PARQUET
     parquet::registerParquetReaderFactory();
 #endif
+    // Register IcebergConnector.
+    IcebergConnectorFactory icebergFactory;
+    auto icebergConnector = icebergFactory.newConnector(
+        kIcebergConnectorId,
+        std::make_shared<config::ConfigBase>(
+            std::unordered_map<std::string, std::string>()),
+        ioExecutor_.get());
+    connector::ConnectorRegistry::global().insert(
+        icebergConnector->connectorId(), icebergConnector);
+  }
+
+  void TearDown() override {
+    connector::ConnectorRegistry::global().erase(kIcebergConnectorId);
+    HiveConnectorTestBase::TearDown();
   }
 
   HiveIcebergTest()
@@ -155,7 +187,7 @@ class HiveIcebergTest : public HiveConnectorTestBase {
     return values;
   }
 
-  std::vector<int64_t> makeContinuousIncreasingValues(
+  static std::vector<int64_t> makeContinuousIncreasingValues(
       int64_t begin,
       int64_t end) {
     std::vector<int64_t> values;
@@ -219,10 +251,9 @@ class HiveIcebergTest : public HiveConnectorTestBase {
           IcebergDeleteFile icebergDeleteFile(
               FileContent::kPositionalDeletes,
               deleteFilePath,
-              fileFomat_,
+              fileFormat_,
               deleteFilePaths[deleteFileName].first,
-              testing::internal::GetFileSize(
-                  std::fopen(deleteFilePath.c_str(), "r")));
+              getTestFileSize(deleteFilePath));
           deleteFiles.push_back(icebergDeleteFile);
         }
       }
@@ -234,13 +265,17 @@ class HiveIcebergTest : public HiveConnectorTestBase {
 
     std::string duckdbSql =
         getDuckDBQuery(rowGroupSizesForFiles, deleteFilesForBaseDatafiles);
-    auto plan = tableScanNode();
-    auto task = HiveConnectorTestBase::assertQuery(
-        plan, splits, duckdbSql, numPrefetchSplits);
+    auto plan = PlanBuilder()
+                    .startTableScan()
+                    .connectorId(kIcebergConnectorId)
+                    .outputType(ROW({"c0"}, {BIGINT()}))
+                    .endTableScan()
+                    .planNode();
+    auto task = assertQuery(plan, splits, duckdbSql, numPrefetchSplits);
 
     auto planStats = toPlanStats(task->taskStats());
-    auto scanNodeId = plan->id();
-    auto it = planStats.find(scanNodeId);
+
+    auto it = planStats.find(plan->id());
     ASSERT_TRUE(it != planStats.end());
     ASSERT_TRUE(it->second.peakMemoryBytes > 0);
   }
@@ -250,6 +285,64 @@ class HiveIcebergTest : public HiveConnectorTestBase {
  protected:
   std::shared_ptr<dwrf::Config> config_;
   std::function<std::unique_ptr<dwrf::DWRFFlushPolicy>()> flushPolicyFactory_;
+  FileFormat fileFormat_{FileFormat::DWRF};
+
+  /// Helper to create a standard c0 HiveColumnHandle (BIGINT).
+  std::shared_ptr<HiveColumnHandle> makeC0Handle() {
+    return std::make_shared<HiveColumnHandle>(
+        "c0",
+        HiveColumnHandle::ColumnType::kRegular,
+        BIGINT(),
+        BIGINT(),
+        std::vector<common::Subfield>{});
+  }
+
+  /// Helper to create an IcebergColumnHandle with default value.
+  std::shared_ptr<IcebergColumnHandle> makeIcebergHandle(
+      const std::string& name,
+      const TypePtr& type,
+      int fieldId,
+      const std::string& defaultValue) {
+    return std::make_shared<IcebergColumnHandle>(
+        name,
+        HiveColumnHandle::ColumnType::kRegular,
+        type,
+        parquet::ParquetFieldId(fieldId),
+        std::vector<common::Subfield>{},
+        std::optional<std::string>{defaultValue});
+  }
+
+  /// Helper function to test schema evolution with initial default values.
+  void assertDefaultValues(
+      const RowTypePtr& outputType,
+      const RowTypePtr& scanSpecType,
+      const ColumnHandleMap& assignments,
+      const std::vector<RowVectorPtr>& data,
+      const std::vector<RowVectorPtr>& expected,
+      const std::unordered_map<std::string, std::string>& sessionProperties =
+          {}) {
+    // Write data file with old schema
+    auto dataFilePath = TempFilePath::create();
+    writeToFile(dataFilePath->getPath(), data);
+    auto icebergSplits = makeIcebergSplits(dataFilePath->getPath());
+
+    // Build plan
+    auto plan = PlanBuilder()
+                    .startTableScan()
+                    .connectorId(kIcebergConnectorId)
+                    .outputType(outputType)
+                    .dataColumns(scanSpecType)
+                    .assignments(assignments)
+                    .endTableScan()
+                    .planNode();
+
+    // Build query and add session properties if provided
+    auto queryBuilder = AssertQueryBuilder(plan);
+    for (const auto& [key, value] : sessionProperties) {
+      queryBuilder.connectorSessionProperty(kIcebergConnectorId, key, value);
+    }
+    queryBuilder.splits(icebergSplits).assertResults(expected);
+  }
 
   std::vector<std::shared_ptr<ConnectorSplit>> makeIcebergSplits(
       const std::string& dataFilePath,
@@ -257,33 +350,57 @@ class HiveIcebergTest : public HiveConnectorTestBase {
       const std::unordered_map<std::string, std::optional<std::string>>&
           partitionKeys = {},
       const uint32_t splitCount = 1) {
-    std::unordered_map<std::string, std::string> customSplitInfo;
-    customSplitInfo["table_format"] = "hive-iceberg";
-
     auto file = filesystems::getFileSystem(dataFilePath, nullptr)
                     ->openFileForRead(dataFilePath);
     const int64_t fileSize = file->size();
-    std::vector<std::shared_ptr<ConnectorSplit>> splits;
     const uint64_t splitSize = std::floor((fileSize) / splitCount);
 
+    std::vector<std::shared_ptr<ConnectorSplit>> splits;
+    splits.reserve(splitCount);
+
     for (int i = 0; i < splitCount; ++i) {
-      splits.emplace_back(std::make_shared<HiveIcebergSplit>(
-          kHiveConnectorId,
-          dataFilePath,
-          fileFomat_,
-          i * splitSize,
-          splitSize,
-          partitionKeys,
-          std::nullopt,
-          customSplitInfo,
-          nullptr,
-          /*cacheable=*/true,
-          deleteFiles));
+      splits.emplace_back(
+          std::make_shared<HiveIcebergSplit>(
+              kIcebergConnectorId,
+              dataFilePath,
+              fileFormat_,
+              i * splitSize,
+              splitSize,
+              partitionKeys,
+              std::nullopt,
+              std::unordered_map<std::string, std::string>{},
+              nullptr,
+              /*cacheable=*/true,
+              deleteFiles));
     }
 
     return splits;
   }
 
+  ColumnHandleMap makeColumnHandles(
+      const RowTypePtr& rowType,
+      const std::unordered_set<int>& partitionIndices = {}) {
+    ColumnHandleMap assignments;
+    for (auto i = 0; i < rowType->size(); ++i) {
+      const auto& columnName = rowType->nameOf(i);
+      const auto& columnType = rowType->childAt(i);
+      auto columnHandleType = partitionIndices.contains(i)
+          ? FileColumnHandle::ColumnType::kPartitionKey
+          : FileColumnHandle::ColumnType::kRegular;
+
+      assignments.insert(
+          {columnName,
+           std::make_shared<HiveColumnHandle>(
+               columnName,
+               columnHandleType,
+               columnType,
+               columnType,
+               std::vector<common::Subfield>{})});
+    }
+
+    return assignments;
+  }
+
 #ifdef VELOX_ENABLE_PARQUET
   std::vector<std::shared_ptr<ConnectorSplit>> createParquetDeleteFileAndSplits(
       const std::string& path,
@@ -299,39 +416,185 @@ class HiveIcebergTest : public HiveConnectorTestBase {
                     static_cast<vector_size_t>(deletedPositionSize),
                     [&](vector_size_t) { return path; }),
                 makeFlatVector<int64_t>(deletePositionsVec),
-            })},
-        config_,
-        flushPolicyFactory_);
+            })});
 
     IcebergDeleteFile icebergDeleteFile(
         FileContent::kPositionalDeletes,
         deleteFilePath->getPath(),
-        fileFomat_,
+        fileFormat_,
         deletedPositionSize,
-        testing::internal::GetFileSize(
-            std::fopen(deleteFilePath->getPath().c_str(), "r")));
+        getTestFileSize(deleteFilePath->getPath()));
     auto fileSize = filesystems::getFileSystem(path, nullptr)
                         ->openFileForRead(path)
                         ->size();
 
-    std::unordered_map<std::string, std::string> customSplitInfo{
-        {"table_format", "hive-iceberg"}};
     std::unordered_map<std::string, std::optional<std::string>> partitionKeys;
     return {std::make_shared<HiveIcebergSplit>(
-        kHiveConnectorId,
+        kIcebergConnectorId,
         path,
-        dwio::common::FileFormat::PARQUET,
+        FileFormat::PARQUET,
         0,
         fileSize,
         partitionKeys,
         std::nullopt,
-        customSplitInfo,
+        std::unordered_map<std::string, std::string>{},
         nullptr,
         /*cacheable=*/true,
         std::vector<IcebergDeleteFile>{icebergDeleteFile})};
   }
 #endif
 
+  /// Creates a single HiveIcebergSplit from the full data file with info
+  /// columns (e.g. $first_row_id, $data_sequence_number) and optional
+  /// delete files.
+  std::shared_ptr<ConnectorSplit> makeIcebergSplitWithInfoColumns(
+      const std::string& dataFilePath,
+      const std::unordered_map<std::string, std::string>& infoColumns,
+      const std::vector<IcebergDeleteFile>& deleteFiles = {}) {
+    auto file = filesystems::getFileSystem(dataFilePath, nullptr)
+                    ->openFileForRead(dataFilePath);
+    return std::make_shared<HiveIcebergSplit>(
+        kIcebergConnectorId,
+        dataFilePath,
+        fileFormat_,
+        0,
+        file->size(),
+        std::unordered_map<std::string, std::optional<std::string>>{},
+        std::nullopt,
+        std::unordered_map<std::string, std::string>{},
+        nullptr,
+        /*cacheable=*/true,
+        deleteFiles,
+        infoColumns);
+  }
+
+  struct RowLineageTestCase {
+    std::vector<int64_t> values;
+    // Physically stored _row_id values; nullopt entries write a file null.
+    // Absent means no _row_id column in the file; reader derives from
+    // firstRowId. Always paired with storedSequenceNumbers.
+    std::optional<std::vector<std::optional<int64_t>>> storedRowIds;
+    // Physically stored _last_updated_sequence_number values; nullopt entries
+    // write a file null. Absent means no column in the file; reader derives
+    // from dataSequenceNumber. Always paired with storedRowIds.
+    std::optional<std::vector<std::optional<int64_t>>> storedSequenceNumbers;
+    // Passed as first_row_id in the split's info columns.
+    std::optional<int64_t> firstRowId;
+    // Passed as data_sequence_number in the split's info columns.
+    std::optional<int64_t> dataSequenceNumber;
+    // File positions to delete; empty means no delete file is created.
+    std::vector<int64_t> deletePositions;
+    // Subfield filter expression (e.g., "c0 > 20"); empty means no filter.
+    std::string subfieldFilter;
+    // Expected output rows: (c0, _row_id, _last_updated_sequence_number).
+    std::vector<RowVectorPtr> expectedVectors;
+  };
+
+  // Writes tc to a temp data file, executes a table scan over
+  // (c0, _row_id, _last_updated_sequence_number), and asserts the result.
+  void assertRowLineage(const RowLineageTestCase& tc) {
+    VELOX_CHECK_EQ(
+        tc.storedRowIds.has_value(),
+        tc.storedSequenceNumbers.has_value(),
+        "rowIds and sequenceNumbers must both be set or both absent.");
+
+    auto pathColumn = IcebergMetadataColumn::icebergDeleteFilePathColumn();
+    auto posColumn = IcebergMetadataColumn::icebergDeletePosColumn();
+
+    // Build the data file vectors from the explicit column fields.
+    std::vector<RowVectorPtr> inputVectors;
+    if (!tc.storedRowIds.has_value()) {
+      // No physical lineage columns: file contains only c0.
+      inputVectors = {makeRowVector({makeFlatVector<int64_t>(tc.values)})};
+    } else {
+      // Physical lineage columns are present in the file.
+      static const std::vector<std::string> kFileColumns = {
+          "c0", "_row_id", "_last_updated_sequence_number"};
+      inputVectors = {makeRowVector(
+          kFileColumns,
+          {
+              makeFlatVector<int64_t>(tc.values),
+              makeNullableFlatVector<int64_t>(*tc.storedRowIds),
+              makeNullableFlatVector<int64_t>(*tc.storedSequenceNumbers),
+          })};
+    }
+
+    auto dataFilePath = TempFilePath::create();
+    writeToFile(dataFilePath->getPath(), inputVectors);
+
+    std::vector<IcebergDeleteFile> deleteFiles;
+    std::shared_ptr<TempFilePath> deleteFilePath;
+    if (!tc.deletePositions.empty()) {
+      deleteFilePath = TempFilePath::create();
+      writeToFile(
+          deleteFilePath->getPath(),
+          {makeRowVector(
+              {pathColumn->name, posColumn->name},
+              {makeFlatVector<std::string>(
+                   static_cast<vector_size_t>(tc.deletePositions.size()),
+                   [&](auto) { return dataFilePath->getPath(); }),
+               makeFlatVector<int64_t>(tc.deletePositions)})});
+
+      const uint64_t upperBound = static_cast<uint64_t>(*std::max_element(
+          tc.deletePositions.begin(), tc.deletePositions.end()));
+      const auto upperBoundLE = folly::Endian::little(upperBound);
+      const auto encodedUpperBound = encoding::Base64::encode(
+          std::string_view(
+              reinterpret_cast<const char*>(&upperBoundLE),
+              sizeof(upperBoundLE)));
+
+      deleteFiles.push_back(IcebergDeleteFile(
+          FileContent::kPositionalDeletes,
+          deleteFilePath->getPath(),
+          fileFormat_,
+          static_cast<int64_t>(tc.deletePositions.size()),
+          getTestFileSize(deleteFilePath->getPath()),
+          {},
+          {},
+          {{posColumn->id, encodedUpperBound}}));
+    }
+
+    std::unordered_map<std::string, std::string> infoColumns;
+    if (tc.firstRowId.has_value()) {
+      infoColumns[IcebergMetadataColumn::kFirstRowIdInfoColumn] =
+          std::to_string(*tc.firstRowId);
+    }
+    if (tc.dataSequenceNumber.has_value()) {
+      infoColumns[IcebergMetadataColumn::kDataSequenceNumberInfoColumn] =
+          std::to_string(*tc.dataSequenceNumber);
+    }
+
+    auto split = makeIcebergSplitWithInfoColumns(
+        dataFilePath->getPath(), infoColumns, deleteFiles);
+
+    const auto outputType =
+        ROW({"c0", "_row_id", "_last_updated_sequence_number"},
+            {BIGINT(), BIGINT(), BIGINT()});
+    const auto tableDataColumns = ROW({"c0"}, {BIGINT()});
+
+    core::PlanNodePtr plan;
+    if (!tc.subfieldFilter.empty()) {
+      plan = PlanBuilder()
+                 .startTableScan()
+                 .connectorId(kIcebergConnectorId)
+                 .outputType(outputType)
+                 .dataColumns(tableDataColumns)
+                 .subfieldFilter(tc.subfieldFilter)
+                 .endTableScan()
+                 .planNode();
+    } else {
+      plan = PlanBuilder()
+                 .startTableScan()
+                 .connectorId(kIcebergConnectorId)
+                 .outputType(outputType)
+                 .dataColumns(tableDataColumns)
+                 .endTableScan()
+                 .planNode();
+    }
+
+    AssertQueryBuilder(plan).splits({split}).assertResults(tc.expectedVectors);
+  }
+
  private:
   std::map<std::string, std::shared_ptr<TempFilePath>> writeDataFiles(
       std::map<std::string, std::vector<int64_t>> rowGroupSizesForFiles) {
@@ -348,11 +611,7 @@ class HiveIcebergTest : public HiveConnectorTestBase {
       // files. This is to make constructing DuckDB queries easier
       std::vector<RowVectorPtr> dataVectors =
           makeVectors(dataFile.second, startingValue);
-      writeToFile(
-          dataFilePaths[dataFile.first]->getPath(),
-          dataVectors,
-          config_,
-          flushPolicyFactory_);
+      writeToFile(dataFilePaths[dataFile.first]->getPath(), dataVectors);
 
       for (int i = 0; i < dataVectors.size(); i++) {
         dataVectorsJoined.push_back(dataVectors[i]);
@@ -409,11 +668,7 @@ class HiveIcebergTest : public HiveConnectorTestBase {
         totalPositionsInDeleteFile += positionsInRowGroup.size();
       }
 
-      writeToFile(
-          deleteFilePath->getPath(),
-          deleteFileVectors,
-          config_,
-          flushPolicyFactory_);
+      writeToFile(deleteFilePath->getPath(), deleteFileVectors);
 
       deleteFilePaths[deleteFileName] =
           std::make_pair(totalPositionsInDeleteFile, deleteFilePath);
@@ -432,8 +687,7 @@ class HiveIcebergTest : public HiveConnectorTestBase {
     for (int j = 0; j < vectorSizes.size(); j++) {
       auto data = makeContinuousIncreasingValues(
           startingValue, startingValue + vectorSizes[j]);
-      VectorPtr c0 = makeFlatVector<int64_t>(data);
-      vectors.push_back(makeRowVector({"c0"}, {c0}));
+      vectors.push_back(makeRowVector({makeFlatVector<int64_t>(data)}));
       startingValue += vectorSizes[j];
     }
 
@@ -460,9 +714,9 @@ class HiveIcebergTest : public HiveConnectorTestBase {
     // Group the delete vectors by baseFileName
     std::map<std::string, std::vector<std::vector<int64_t>>>
         deletePosVectorsForAllBaseFiles;
-    for (auto deleteFile : deleteFilesForBaseDatafiles) {
+    for (auto& deleteFile : deleteFilesForBaseDatafiles) {
       auto deleteFileContent = deleteFile.second;
-      for (auto rowGroup : deleteFileContent) {
+      for (auto& rowGroup : deleteFileContent) {
         auto baseFileName = rowGroup.first;
         deletePosVectorsForAllBaseFiles[baseFileName].push_back(
             rowGroup.second);
@@ -475,7 +729,7 @@ class HiveIcebergTest : public HiveConnectorTestBase {
     std::map<std::string, std::vector<int64_t>>
         flattenedDeletePosVectorsForAllBaseFiles;
     int64_t totalNumDeletePositions = 0;
-    for (auto deleteVectorsForBaseFile : deletePosVectorsForAllBaseFiles) {
+    for (auto& deleteVectorsForBaseFile : deletePosVectorsForAllBaseFiles) {
       auto baseFileName = deleteVectorsForBaseFile.first;
       auto deletePositionVectors = deleteVectorsForBaseFile.second;
       std::vector<int64_t> deletePositionVector =
@@ -488,14 +742,18 @@ class HiveIcebergTest : public HiveConnectorTestBase {
     // Now build the DuckDB queries
     if (totalNumDeletePositions == 0) {
       return "SELECT * FROM tmp";
-    } else if (totalNumDeletePositions >= totalNumRowsInAllBaseFiles) {
+    }
+
+    if (totalNumDeletePositions >= totalNumRowsInAllBaseFiles) {
       return "SELECT * FROM tmp WHERE 1 = 0";
-    } else {
+    }
+
+    {
       // Convert the delete positions in all base files into column values
       std::vector<int64_t> allDeleteValues;
 
       int64_t numRowsInPreviousBaseFiles = 0;
-      for (auto baseFileSize : baseFileSizes) {
+      for (auto& baseFileSize : baseFileSizes) {
         auto deletePositions =
             flattenedDeletePosVectorsForAllBaseFiles[baseFileSize.first];
 
@@ -515,7 +773,7 @@ class HiveIcebergTest : public HiveConnectorTestBase {
 
       return fmt::format(
           "SELECT * FROM tmp WHERE c0 NOT IN ({})",
-          makeNotInList(allDeleteValues));
+          folly::join(", ", allDeleteValues));
     }
   }
 
@@ -523,7 +781,7 @@ class HiveIcebergTest : public HiveConnectorTestBase {
       const std::vector<std::vector<int64_t>>& deletePositionVectors,
       int64_t baseFileSize) {
     std::vector<int64_t> deletePositionVector;
-    for (auto vec : deletePositionVectors) {
+    for (auto& vec : deletePositionVectors) {
       for (auto pos : vec) {
         if (pos >= 0 && pos < baseFileSize) {
           deletePositionVector.push_back(pos);
@@ -539,29 +797,9 @@ class HiveIcebergTest : public HiveConnectorTestBase {
     return deletePositionVector;
   }
 
-  std::string makeNotInList(const std::vector<int64_t>& deletePositionVector) {
-    if (deletePositionVector.empty()) {
-      return "";
-    }
-
-    return std::accumulate(
-        deletePositionVector.begin() + 1,
-        deletePositionVector.end(),
-        std::to_string(deletePositionVector[0]),
-        [](const std::string& a, int64_t b) {
-          return a + ", " + std::to_string(b);
-        });
-  }
-
-  core::PlanNodePtr tableScanNode() {
-    return PlanBuilder(pool_.get()).tableScan(rowType_).planNode();
-  }
-
-  dwio::common::FileFormat fileFomat_{dwio::common::FileFormat::DWRF};
-
-  RowTypePtr rowType_{ROW({"c0"}, {BIGINT()})};
   std::shared_ptr<IcebergMetadataColumn> pathColumn_ =
       IcebergMetadataColumn::icebergDeleteFilePathColumn();
+
   std::shared_ptr<IcebergMetadataColumn> posColumn_ =
       IcebergMetadataColumn::icebergDeletePosColumn();
 };
@@ -591,7 +829,7 @@ TEST_F(HiveIcebergTest, singleBaseFileSinglePositionalDeleteFile) {
 /// delete positions. The parameter passed to
 /// assertSingleBaseFileSingleDeleteFile is the delete positions.for the middle
 /// base file.
-TEST_F(HiveIcebergTest, MultipleBaseFilesSinglePositionalDeleteFile) {
+TEST_F(HiveIcebergTest, multipleBaseFilesSinglePositionalDeleteFile) {
   folly::SingletonVault::singleton()->registrationComplete();
 
   assertMultipleBaseFileSingleDeleteFile({0, 1, 2, 3});
@@ -754,88 +992,686 @@ TEST_F(HiveIcebergTest, positionalDeletesMultipleSplits) {
   assertMultipleSplits({1000, 9000, 20000}, 1, 0, 20000, 3);
 }
 
-TEST_F(HiveIcebergTest, testPartitionedRead) {
-  RowTypePtr rowType{ROW({"c0", "ds"}, {BIGINT(), DateType::get()})};
-  std::unordered_map<std::string, std::optional<std::string>> partitionKeys;
-  // Iceberg API sets partition values for dates to daysSinceEpoch, so
-  // in velox, we do not need to convert it to days.
-  // Test query on two partitions ds=17627(2018-04-06), ds=17628(2018-04-07)
-  std::vector<std::shared_ptr<ConnectorSplit>> splits;
-  std::vector<std::shared_ptr<TempFilePath>> dataFilePaths;
-  for (int i = 0; i <= 1; ++i) {
-    std::vector<RowVectorPtr> dataVectors;
-    int32_t daysSinceEpoch = 17627 + i;
-    VectorPtr c0 = makeFlatVector<int64_t>((std::vector<int64_t>){i});
-    VectorPtr ds =
-        makeFlatVector<int32_t>((std::vector<int32_t>){daysSinceEpoch});
-    dataVectors.push_back(makeRowVector({"c0", "ds"}, {c0, ds}));
+TEST_F(HiveIcebergTest, schemaEvolutionRemoveColumn) {
+  auto oldRowType = ROW({"c0", "c1", "c2"}, {BIGINT(), INTEGER(), VARCHAR()});
+  auto newRowType = ROW({"c0", "c2"}, {BIGINT(), VARCHAR()});
 
-    auto dataFilePath = TempFilePath::create();
-    dataFilePaths.push_back(dataFilePath);
-    writeToFile(
-        dataFilePath->getPath(), dataVectors, config_, flushPolicyFactory_);
-    partitionKeys["ds"] = std::to_string(daysSinceEpoch);
+  // Write data file with old schema (c0, c1, c2).
+  std::vector<RowVectorPtr> dataVectors;
+  dataVectors.push_back(makeRowVector(
+      oldRowType->names(),
+      {
+          makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+          makeFlatVector<int32_t>({10, 20, 30, 40, 50}),
+          makeFlatVector<std::string>({"a", "b", "c", "d", "e"}),
+      }));
+
+  auto dataFilePath = TempFilePath::create();
+  writeToFile(dataFilePath->getPath(), dataVectors);
+
+  auto icebergSplits = makeIcebergSplits(dataFilePath->getPath());
+
+  // Expected result: c0 and c2 have values, c1 is not present.
+  std::vector<RowVectorPtr> expectedVectors;
+  expectedVectors.push_back(makeRowVector(
+      newRowType->names(),
+      {
+          dataVectors[0]->childAt(0),
+          dataVectors[0]->childAt(2),
+      }));
+
+  // Read with new schema (c0 and c2 only, c1 removed).
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .connectorId(kIcebergConnectorId)
+                  .outputType(newRowType)
+                  .endTableScan()
+                  .planNode();
+  AssertQueryBuilder(plan).splits(icebergSplits).assertResults(expectedVectors);
+}
+
+TEST_F(HiveIcebergTest, schemaEvolutionAddColumns) {
+  auto oldRowType = ROW({"c0"}, {BIGINT()});
+  auto newRowType = ROW({"c0", "c1", "c2"}, {BIGINT(), INTEGER(), VARCHAR()});
+
+  // Write data file with old schema (only c0).
+  std::vector<RowVectorPtr> dataVectors;
+  dataVectors.push_back(makeRowVector({
+      makeFlatVector<int64_t>({100, 200, 300}),
+  }));
+  auto dataFilePath = TempFilePath::create();
+  writeToFile(dataFilePath->getPath(), dataVectors);
+  auto icebergSplits = makeIcebergSplits(dataFilePath->getPath());
+
+  // Expected result: c0 has values, c1 and c2 are NULL.
+  std::vector<RowVectorPtr> expectedVectors;
+  expectedVectors.push_back(makeRowVector({
+      dataVectors[0]->childAt(0),
+      makeNullConstant(TypeKind::INTEGER, 3),
+      makeNullConstant(TypeKind::VARCHAR, 3),
+  }));
+
+  // Read with new schema (c0, c1, and c2).
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .connectorId(kIcebergConnectorId)
+                  .outputType(newRowType)
+                  .dataColumns(newRowType)
+                  .endTableScan()
+                  .planNode();
+  AssertQueryBuilder(plan).splits(icebergSplits).assertResults(expectedVectors);
+}
+
+// Test Iceberg V3 initial-default: a column added after data files were written
+// should return its initial-default value (not NULL) for those historical rows.
+TEST_F(HiveIcebergTest, addColumnWithDefault) {
+  auto newRowType = ROW({"c0", "country"}, {BIGINT(), VARCHAR()});
+
+  std::vector<RowVectorPtr> dataVectors;
+  dataVectors.push_back(makeRowVector({makeFlatVector<int64_t>({1, 2, 3})}));
+
+  ColumnHandleMap assignments;
+  assignments["c0"] = makeC0Handle();
+  assignments["country"] = makeIcebergHandle("country", VARCHAR(), 2, "IN");
+
+  std::vector<RowVectorPtr> expectedVectors;
+  expectedVectors.push_back(makeRowVector(
+      newRowType->names(),
+      {dataVectors[0]->childAt(0),
+       makeFlatVector<std::string>({"IN", "IN", "IN"})}));
+
+  assertDefaultValues(
+      newRowType, newRowType, assignments, dataVectors, expectedVectors);
+}
+
+TEST_F(HiveIcebergTest, addColumnWithDefaultAndAlias) {
+  auto outputType = ROW({"c0", "region"}, {BIGINT(), VARCHAR()});
+  auto dataColumns = ROW({"c0", "country"}, {BIGINT(), VARCHAR()});
+
+  std::vector<RowVectorPtr> dataVectors;
+  dataVectors.push_back(makeRowVector({makeFlatVector<int64_t>({1, 2, 3})}));
+
+  ColumnHandleMap assignments;
+  assignments["c0"] = makeC0Handle();
+  // Key is "region" (alias), but handle refers to "country" (table column)
+  assignments["region"] = makeIcebergHandle("country", VARCHAR(), 2, "IN");
+
+  std::vector<RowVectorPtr> expectedVectors;
+  expectedVectors.push_back(makeRowVector(
+      outputType->names(),
+      {dataVectors[0]->childAt(0),
+       makeFlatVector<std::string>({"IN", "IN", "IN"})}));
+
+  assertDefaultValues(
+      outputType, dataColumns, assignments, dataVectors, expectedVectors);
+}
+
+TEST_F(HiveIcebergTest, fileValueOverridesDefault) {
+  auto rowType = ROW({"c0", "country"}, {BIGINT(), VARCHAR()});
+
+  std::vector<RowVectorPtr> dataVectors;
+  dataVectors.push_back(makeRowVector(
+      {makeFlatVector<int64_t>({1, 2, 3}),
+       makeFlatVector<std::string>({"US", "UK", "CA"})}));
+
+  ColumnHandleMap assignments;
+  assignments["c0"] = makeC0Handle();
+  assignments["country"] = makeIcebergHandle("country", VARCHAR(), 2, "IN");
+
+  // Expected: file values ("US", "UK", "CA"), NOT the default "IN"
+  std::vector<RowVectorPtr> expectedVectors;
+  expectedVectors.push_back(makeRowVector(
+      rowType->names(),
+      {dataVectors[0]->childAt(0), dataVectors[0]->childAt(1)}));
+
+  assertDefaultValues(
+      rowType, rowType, assignments, dataVectors, expectedVectors);
+}
+
+TEST_F(HiveIcebergTest, addColumnWithDefaultAllTypes) {
+  auto newRowType =
+      ROW({"c0",
+           "tiny_val",
+           "small_val",
+           "int_val",
+           "big_val",
+           "real_val",
+           "double_val",
+           "bool_val",
+           "str_val",
+           "short_decimal",
+           "long_decimal",
+           "date_val",
+           "timestamp_val"},
+          {BIGINT(),
+           TINYINT(),
+           SMALLINT(),
+           INTEGER(),
+           BIGINT(),
+           REAL(),
+           DOUBLE(),
+           BOOLEAN(),
+           VARCHAR(),
+           DECIMAL(10, 2),
+           DECIMAL(38, 10),
+           DATE(),
+           TIMESTAMP()});
+
+  std::vector<RowVectorPtr> dataVectors;
+  dataVectors.push_back(makeRowVector({makeFlatVector<int64_t>({1, 2, 3})}));
+
+  ColumnHandleMap assignments;
+  assignments["c0"] = makeC0Handle();
+  assignments["tiny_val"] = makeIcebergHandle("tiny_val", TINYINT(), 2, "10");
+  assignments["small_val"] =
+      makeIcebergHandle("small_val", SMALLINT(), 3, "100");
+  assignments["int_val"] = makeIcebergHandle("int_val", INTEGER(), 4, "1000");
+  assignments["big_val"] = makeIcebergHandle("big_val", BIGINT(), 5, "10000");
+  assignments["real_val"] = makeIcebergHandle("real_val", REAL(), 6, "3.14");
+  assignments["double_val"] =
+      makeIcebergHandle("double_val", DOUBLE(), 7, "2.718");
+  assignments["bool_val"] = makeIcebergHandle("bool_val", BOOLEAN(), 8, "true");
+  assignments["str_val"] =
+      makeIcebergHandle("str_val", VARCHAR(), 9, "default_string");
+  assignments["short_decimal"] =
+      makeIcebergHandle("short_decimal", DECIMAL(10, 2), 10, "99.99");
+  assignments["long_decimal"] = makeIcebergHandle(
+      "long_decimal",
+      DECIMAL(38, 10),
+      11,
+      "123456789012345678901234567.8901234567");
+  assignments["date_val"] =
+      makeIcebergHandle("date_val", DATE(), 12, "2024-01-15");
+  assignments["timestamp_val"] = makeIcebergHandle(
+      "timestamp_val", TIMESTAMP(), 13, "2024-01-15 10:30:00");
+
+  std::vector<RowVectorPtr> expectedVectors;
+  expectedVectors.push_back(makeRowVector(
+      newRowType->names(),
+      {dataVectors[0]->childAt(0),
+       makeFlatVector<int8_t>({10, 10, 10}),
+       makeFlatVector<int16_t>({100, 100, 100}),
+       makeFlatVector<int32_t>({1000, 1000, 1000}),
+       makeFlatVector<int64_t>({10000, 10000, 10000}),
+       makeFlatVector<float>({3.14f, 3.14f, 3.14f}),
+       makeFlatVector<double>({2.718, 2.718, 2.718}),
+       makeFlatVector<bool>({true, true, true}),
+       makeFlatVector<std::string>(
+           {"default_string", "default_string", "default_string"}),
+       makeFlatVector<int64_t>({9999, 9999, 9999}, DECIMAL(10, 2)),
+       makeFlatVector<int128_t>(
+           {HugeInt::parse("1234567890123456789012345678901234567"),
+            HugeInt::parse("1234567890123456789012345678901234567"),
+            HugeInt::parse("1234567890123456789012345678901234567")},
+           DECIMAL(38, 10)),
+       makeFlatVector<int32_t>({19737, 19737, 19737}, DATE()),
+       makeFlatVector<Timestamp>(
+           {Timestamp(1705314600, 0),
+            Timestamp(1705314600, 0),
+            Timestamp(1705314600, 0)})}));
+
+  assertDefaultValues(
+      newRowType,
+      newRowType,
+      assignments,
+      dataVectors,
+      expectedVectors,
+      {{HiveConfig::kReadTimestampPartitionValueAsLocalTimeSession, "false"}});
+}
+
+TEST_F(HiveIcebergTest, addColumnWithInvalidDefault) {
+  auto newRowType = ROW({"c0", "age"}, {BIGINT(), INTEGER()});
+
+  std::vector<RowVectorPtr> dataVectors;
+  dataVectors.push_back(makeRowVector({makeFlatVector<int64_t>({1, 2, 3})}));
+  auto dataFilePath = TempFilePath::create();
+  writeToFile(dataFilePath->getPath(), dataVectors);
+  auto icebergSplits = makeIcebergSplits(dataFilePath->getPath());
+
+  ColumnHandleMap assignments;
+  assignments["c0"] = makeC0Handle();
+  assignments["age"] = makeIcebergHandle("age", INTEGER(), 2, "IN");
+
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .connectorId(kIcebergConnectorId)
+                  .outputType(newRowType)
+                  .dataColumns(newRowType)
+                  .assignments(assignments)
+                  .endTableScan()
+                  .planNode();
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan).splits(icebergSplits).copyResults(pool()),
+      "Invalid");
+}
+
+TEST_F(HiveIcebergTest, addColumnWithEmptyStringDefault) {
+  auto newRowType = ROW({"c0", "name"}, {BIGINT(), VARCHAR()});
+
+  std::vector<RowVectorPtr> dataVectors;
+  dataVectors.push_back(makeRowVector({makeFlatVector<int64_t>({1, 2, 3})}));
+
+  ColumnHandleMap assignments;
+  assignments["c0"] = makeC0Handle();
+  assignments["name"] = makeIcebergHandle("name", VARCHAR(), 2, "");
+
+  std::vector<RowVectorPtr> expectedVectors;
+  expectedVectors.push_back(makeRowVector(
+      newRowType->names(),
+      {dataVectors[0]->childAt(0), makeFlatVector<std::string>({"", "", ""})}));
+
+  assertDefaultValues(
+      newRowType, newRowType, assignments, dataVectors, expectedVectors, {});
+}
+
+TEST_F(HiveIcebergTest, defaultValueWithDeletesAndFilters) {
+  auto newRowType = ROW({"c0", "country"}, {BIGINT(), VARCHAR()});
+
+  // Write data file with old schema (only c0) containing rows 1-10.
+  std::vector<RowVectorPtr> dataVectors;
+  dataVectors.push_back(makeRowVector(
+      {makeFlatVector<int64_t>({1, 2, 3, 4, 5, 6, 7, 8, 9, 10})}));
+  auto dataFilePath = TempFilePath::create();
+  writeToFile(dataFilePath->getPath(), dataVectors);
+
+  // Create delete file that deletes positions 1, 3, 5 (rows 2, 4, 6).
+  auto deleteFilePath = TempFilePath::create();
+  std::vector<int64_t> deletePositions = {1, 3, 5};
+  auto pathColumn = IcebergMetadataColumn::icebergDeleteFilePathColumn();
+  auto posColumn = IcebergMetadataColumn::icebergDeletePosColumn();
+  writeToFile(
+      deleteFilePath->getPath(),
+      {makeRowVector(
+          {pathColumn->name, posColumn->name},
+          {makeFlatVector<std::string>(
+               3, [&](vector_size_t) { return dataFilePath->getPath(); }),
+           makeFlatVector<int64_t>(deletePositions)})});
+
+  IcebergDeleteFile icebergDeleteFile(
+      FileContent::kPositionalDeletes,
+      deleteFilePath->getPath(),
+      dwio::common::FileFormat::DWRF,
+      3,
+      getTestFileSize(deleteFilePath->getPath()));
+
+  ColumnHandleMap assignments;
+  assignments["c0"] = makeC0Handle();
+  assignments["country"] = makeIcebergHandle("country", VARCHAR(), 2, "IN");
+
+  // Test 1: No filter - rows 1,3,5,7,8,9,10 (after deletes: 2,4,6 removed)
+  {
+    auto icebergSplits =
+        makeIcebergSplits(dataFilePath->getPath(), {icebergDeleteFile}, {}, 1);
+    std::vector<RowVectorPtr> expectedVectors;
+    expectedVectors.push_back(makeRowVector(
+        newRowType->names(),
+        {makeFlatVector<int64_t>({1, 3, 5, 7, 8, 9, 10}),
+         makeFlatVector<std::string>(
+             {"IN", "IN", "IN", "IN", "IN", "IN", "IN"})}));
+
+    auto plan = PlanBuilder()
+                    .startTableScan()
+                    .connectorId(kIcebergConnectorId)
+                    .outputType(newRowType)
+                    .dataColumns(newRowType)
+                    .assignments(assignments)
+                    .endTableScan()
+                    .planNode();
+    AssertQueryBuilder(plan)
+        .splits(icebergSplits)
+        .assertResults(expectedVectors);
+  }
+
+  // Test 2: Filter on file column (c0 > 5) with deletes
+  // After deletes: 1,3,5,7,8,9,10 remain. Filter c0 > 5: 7,8,9,10
+  {
+    auto icebergSplits =
+        makeIcebergSplits(dataFilePath->getPath(), {icebergDeleteFile}, {}, 1);
+    std::vector<RowVectorPtr> expectedVectors;
+    expectedVectors.push_back(makeRowVector(
+        newRowType->names(),
+        {makeFlatVector<int64_t>({7, 8, 9, 10}),
+         makeFlatVector<std::string>({"IN", "IN", "IN", "IN"})}));
+
+    auto plan = PlanBuilder()
+                    .startTableScan()
+                    .connectorId(kIcebergConnectorId)
+                    .outputType(newRowType)
+                    .dataColumns(newRowType)
+                    .assignments(assignments)
+                    .endTableScan()
+                    .filter("c0 > 5")
+                    .planNode();
+    AssertQueryBuilder(plan)
+        .splits(icebergSplits)
+        .assertResults(expectedVectors);
+  }
+
+  // Test 3: Filter on default value column (country = 'IN') with deletes
+  // All remaining rows should match since default is 'IN'
+  {
+    auto icebergSplits =
+        makeIcebergSplits(dataFilePath->getPath(), {icebergDeleteFile}, {}, 1);
+    std::vector<RowVectorPtr> expectedVectors;
+    expectedVectors.push_back(makeRowVector(
+        newRowType->names(),
+        {makeFlatVector<int64_t>({1, 3, 5, 7, 8, 9, 10}),
+         makeFlatVector<std::string>(
+             {"IN", "IN", "IN", "IN", "IN", "IN", "IN"})}));
+
+    auto plan = PlanBuilder()
+                    .startTableScan()
+                    .connectorId(kIcebergConnectorId)
+                    .outputType(newRowType)
+                    .dataColumns(newRowType)
+                    .assignments(assignments)
+                    .endTableScan()
+                    .filter("country = 'IN'")
+                    .planNode();
+    AssertQueryBuilder(plan)
+        .splits(icebergSplits)
+        .assertResults(expectedVectors);
+  }
+
+  // Test 4: Combined filter (c0 > 3 AND country = 'IN') with deletes
+  // After deletes: 1,3,5,7,8,9,10. Filter c0 > 3: 5,7,8,9,10
+  {
     auto icebergSplits =
-        makeIcebergSplits(dataFilePath->getPath(), {}, partitionKeys);
-    splits.insert(splits.end(), icebergSplits.begin(), icebergSplits.end());
+        makeIcebergSplits(dataFilePath->getPath(), {icebergDeleteFile}, {}, 1);
+    std::vector<RowVectorPtr> expectedVectors;
+    expectedVectors.push_back(makeRowVector(
+        newRowType->names(),
+        {makeFlatVector<int64_t>({5, 7, 8, 9, 10}),
+         makeFlatVector<std::string>({"IN", "IN", "IN", "IN", "IN"})}));
+
+    auto plan = PlanBuilder()
+                    .startTableScan()
+                    .connectorId(kIcebergConnectorId)
+                    .outputType(newRowType)
+                    .dataColumns(newRowType)
+                    .assignments(assignments)
+                    .endTableScan()
+                    .filter("c0 > 3 AND country = 'IN'")
+                    .planNode();
+    AssertQueryBuilder(plan)
+        .splits(icebergSplits)
+        .assertResults(expectedVectors);
   }
+}
 
-  connector::ColumnHandleMap assignments;
-  assignments.insert(
-      {"c0",
-       std::make_shared<HiveColumnHandle>(
-           "c0",
-           HiveColumnHandle::ColumnType::kRegular,
-           rowType->childAt(0),
-           rowType->childAt(0))});
-
-  std::vector<common::Subfield> requiredSubFields;
-  HiveColumnHandle::ColumnParseParameters columnParseParameters;
-  columnParseParameters.partitionDateValueFormat =
-      HiveColumnHandle::ColumnParseParameters::kDaysSinceEpoch;
-  assignments.insert(
-      {"ds",
-       std::make_shared<HiveColumnHandle>(
-           "ds",
-           HiveColumnHandle::ColumnType::kPartitionKey,
-           rowType->childAt(1),
-           rowType->childAt(1),
-           std::move(requiredSubFields),
-           columnParseParameters)});
-
-  auto plan = PlanBuilder(pool_.get())
-                  .tableScan(rowType, {}, "", nullptr, assignments)
+// Test reading partition columns from Hive-migrated tables.
+// This tests the adaptColumns method handling partition columns that are not
+// stored in the data file but provided via partitionKeys map.
+// This scenario occurs when reading Hive-written data files where partition
+// column values are stored in partition metadata rather than in the data file.
+TEST_F(HiveIcebergTest, partitionColumnsFromHive) {
+  auto fileRowType = ROW({"c0", "c1"}, {BIGINT(), INTEGER()});
+  auto tableRowType =
+      ROW({"c0", "c1", "region", "year"},
+          {BIGINT(), INTEGER(), VARCHAR(), INTEGER()});
+
+  // Write data file with only non-partition columns (c0, c1).
+  std::vector<RowVectorPtr> dataVectors;
+  dataVectors.push_back(makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      makeFlatVector<int32_t>({10, 20, 30}),
+  }));
+  auto dataFilePath = TempFilePath::create();
+  writeToFile(dataFilePath->getPath(), dataVectors);
+
+  // Set partition keys for region and year.
+  std::unordered_map<std::string, std::optional<std::string>> partitionKeys;
+  partitionKeys["region"] = "US";
+  partitionKeys["year"] = "2025";
+
+  auto icebergSplits =
+      makeIcebergSplits(dataFilePath->getPath(), {}, partitionKeys);
+  auto assignments = makeColumnHandles(tableRowType, {2, 3});
+
+  // Expected result: c0 and c1 from file, region and year from partition keys.
+  std::vector<RowVectorPtr> expectedVectors;
+  expectedVectors.push_back(makeRowVector(
+      tableRowType->names(),
+      {
+          dataVectors[0]->childAt(0),
+          dataVectors[0]->childAt(1),
+          makeFlatVector<std::string>({"US", "US", "US"}),
+          makeFlatVector<int32_t>({2025, 2025, 2025}),
+      }));
+
+  // Read with table schema including partition columns.
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .connectorId(kIcebergConnectorId)
+                  .outputType(tableRowType)
+                  .dataColumns(tableRowType)
+                  .assignments(assignments)
+                  .endTableScan()
                   .planNode();
+  AssertQueryBuilder(plan).splits(icebergSplits).assertResults(expectedVectors);
+}
 
-  HiveConnectorTestBase::assertQuery(
-      plan,
-      splits,
-      "SELECT * FROM (VALUES (0, '2018-04-06'), (1, '2018-04-07'))",
-      0);
+// Test that positional delete files are skipped when their position upper bound
+// is before the split offset. When a delete file's upperBound is less than the
+// split's starting row, all deletes in that file are not relevant to this
+// split.
+TEST_F(HiveIcebergTest, skipDeleteFileByPositionUpperBound) {
+  folly::SingletonVault::singleton()->registrationComplete();
 
-  // Test filter on non-partitioned non-date column
-  std::vector<std::string> nonPartitionFilters = {"c0 = 1"};
-  plan = PlanBuilder(pool_.get())
-             .tableScan(rowType, nonPartitionFilters, "", nullptr, assignments)
-             .planNode();
+  auto pathColumn = IcebergMetadataColumn::icebergDeleteFilePathColumn();
+  auto posColumn = IcebergMetadataColumn::icebergDeletePosColumn();
 
-  HiveConnectorTestBase::assertQuery(plan, splits, "SELECT 1, '2018-04-07'");
+  // Create a data file with 100 rows.
+  auto dataFilePath = TempFilePath::create();
+  std::vector<RowVectorPtr> dataVectors = {makeRowVector(
+      {makeFlatVector<int64_t>(makeContinuousIncreasingValues(0, 100))})};
+  writeToFile(dataFilePath->getPath(), dataVectors);
 
-  // Test filter on non-partitioned date column
-  std::vector<std::string> filters = {"ds = date'2018-04-06'"};
-  plan = PlanBuilder(pool_.get()).tableScan(rowType, filters).planNode();
+  // Create a delete file targeting positions 0, 1, 2.
+  auto deleteFilePath = TempFilePath::create();
+  std::vector<RowVectorPtr> deleteVectors = {makeRowVector(
+      {pathColumn->name, posColumn->name},
+      {makeFlatVector<std::string>(
+           3, [&](auto) { return dataFilePath->getPath(); }),
+       makeFlatVector<int64_t>({0, 1, 2})})};
+  writeToFile(deleteFilePath->getPath(), deleteVectors);
+
+  // upperBound "2" is the max position in the delete file. Iceberg stores
+  // long bounds as 8-byte little-endian binary, then Base64 encodes them.
+  uint64_t upperBound = 2;
+  auto upperBoundLE = folly::Endian::little(upperBound);
+  auto encodedUpperBound = encoding::Base64::encode(
+      std::string_view(
+          reinterpret_cast<const char*>(&upperBoundLE), sizeof(upperBoundLE)));
+  IcebergDeleteFile deleteFile(
+      FileContent::kPositionalDeletes,
+      deleteFilePath->getPath(),
+      FileFormat::DWRF,
+      3,
+      getTestFileSize(deleteFilePath->getPath()),
+      {},
+      {},
+      {{posColumn->id, encodedUpperBound}});
+
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .connectorId(kIcebergConnectorId)
+                  .outputType(ROW({"c0"}, {BIGINT()}))
+                  .endTableScan()
+                  .planNode();
 
-  splits.clear();
-  for (auto& dataFilePath : dataFilePaths) {
-    auto icebergSplits = makeIcebergSplits(dataFilePath->getPath());
-    splits.insert(splits.end(), icebergSplits.begin(), icebergSplits.end());
-  }
+  // Create a split that starts at the middle of the file. The split offset
+  // will be greater than the delete file's upper bound (2), so the delete
+  // file should be skipped completely.
+  auto file = filesystems::getFileSystem(dataFilePath->getPath(), nullptr)
+                  ->openFileForRead(dataFilePath->getPath());
+  const int64_t fileSize = file->size();
+  std::vector<IcebergDeleteFile> deleteFiles = {deleteFile};
+  auto split = std::make_shared<HiveIcebergSplit>(
+      kIcebergConnectorId,
+      dataFilePath->getPath(),
+      FileFormat::DWRF,
+      static_cast<uint64_t>(fileSize / 2),
+      static_cast<uint64_t>(fileSize / 2),
+      std::unordered_map<std::string, std::optional<std::string>>{},
+      std::nullopt,
+      std::unordered_map<std::string, std::string>{},
+      std::shared_ptr<std::string>{},
+      true,
+      deleteFiles);
+
+  // The second half of the file should be returned with no rows deleted.
+  createDuckDbTable({makeRowVector(
+      {makeFlatVector<int64_t>(makeContinuousIncreasingValues(50, 50))})});
+  assertQuery(plan, {split}, "SELECT * FROM tmp", 0);
+}
+
+// Row lineage scenarios for _row_id and _last_updated_sequence_number:
+//   1. Pre-V3: no info columns, no physical columns → both null.
+//   2. V3 new insert: no physical columns; derived from info columns.
+//   3. V3 rewrite: physical values take precedence over info columns.
+//   4. Physical columns all null: falls back to info column derivation.
+//   5. Mixed null/non-null: null slots derived, non-null slots preserved.
+//   6. first_row_id = 0 is a valid value.
+//   7. Positional deletes: _row_id uses file-absolute positions.
+//   8. Subfield filter: _row_id uses file-absolute positions, not output
+//   indices.
+TEST_F(HiveIcebergTest, rowLineage) {
+  folly::SingletonVault::singleton()->registrationComplete();
 
-  HiveConnectorTestBase::assertQuery(plan, splits, "SELECT 0, '2018-04-06'");
+  static const std::vector<std::string> kOutputNames = {
+      "c0", "_row_id", "_last_updated_sequence_number"};
+
+  // 1. Pre-V3.
+  assertRowLineage({
+      .values = {1, 2, 3},
+      .expectedVectors = {makeRowVector(
+          kOutputNames,
+          {
+              makeFlatVector<int64_t>({1, 2, 3}),
+              makeNullableFlatVector<int64_t>(
+                  {std::nullopt, std::nullopt, std::nullopt}),
+              makeNullableFlatVector<int64_t>(
+                  {std::nullopt, std::nullopt, std::nullopt}),
+          })},
+  });
+
+  // 2. V3 new insert.
+  assertRowLineage({
+      .values = {10, 20, 30},
+      .firstRowId = 100,
+      .dataSequenceNumber = 7,
+      .expectedVectors = {makeRowVector(
+          kOutputNames,
+          {
+              makeFlatVector<int64_t>({10, 20, 30}),
+              makeFlatVector<int64_t>({100, 101, 102}),
+              makeFlatVector<int64_t>({7, 7, 7}),
+          })},
+  });
+
+  // 3. V3 rewrite: physical values must not be overridden by info columns.
+  assertRowLineage({
+      .values = {1, 2, 3},
+      .storedRowIds = {{500, 501, 502}},
+      .storedSequenceNumbers = {{3, 5, 3}},
+      .firstRowId = 999,
+      .dataSequenceNumber = 99,
+      .expectedVectors = {makeRowVector(
+          kOutputNames,
+          {
+              makeFlatVector<int64_t>({1, 2, 3}),
+              makeFlatVector<int64_t>({500, 501, 502}),
+              makeFlatVector<int64_t>({3, 5, 3}),
+          })},
+  });
+
+  // 4. Physical columns all null: falls back to info column derivation.
+  assertRowLineage({
+      .values = {1, 2, 3},
+      .storedRowIds = {{std::nullopt, std::nullopt, std::nullopt}},
+      .storedSequenceNumbers = {{std::nullopt, std::nullopt, std::nullopt}},
+      .firstRowId = 50,
+      .dataSequenceNumber = 42,
+      .expectedVectors = {makeRowVector(
+          kOutputNames,
+          {
+              makeFlatVector<int64_t>({1, 2, 3}),
+              makeFlatVector<int64_t>({50, 51, 52}),
+              makeFlatVector<int64_t>({42, 42, 42}),
+          })},
+  });
+
+  // 5. Mixed null/non-null: null slots derived from info columns, non-null
+  // preserved.
+  //   pos 0: _row_id=null→10+0=10, seq_num=null→42
+  //   pos 1: _row_id=99,           seq_num=5
+  //   pos 2: _row_id=null→10+2=12, seq_num=null→42
+  //   pos 3: _row_id=77,           seq_num=10
+  assertRowLineage({
+      .values = {10, 20, 30, 40},
+      .storedRowIds = {{std::nullopt, 99, std::nullopt, 77}},
+      .storedSequenceNumbers = {{std::nullopt, 5, std::nullopt, 10}},
+      .firstRowId = 10,
+      .dataSequenceNumber = 42,
+      .expectedVectors = {makeRowVector(
+          kOutputNames,
+          {
+              makeFlatVector<int64_t>({10, 20, 30, 40}),
+              makeFlatVector<int64_t>({10, 99, 12, 77}),
+              makeFlatVector<int64_t>({42, 5, 42, 10}),
+          })},
+  });
+
+  // 6. first_row_id = 0 is a valid value; _row_id starts at zero.
+  assertRowLineage({
+      .values = {5, 6, 7},
+      .firstRowId = 0,
+      .dataSequenceNumber = 5,
+      .expectedVectors = {makeRowVector(
+          kOutputNames,
+          {
+              makeFlatVector<int64_t>({5, 6, 7}),
+              makeFlatVector<int64_t>({0, 1, 2}),
+              makeFlatVector<int64_t>({5, 5, 5}),
+          })},
+  });
+
+  // 7. Positional deletes: _row_id uses file-absolute positions.
+  assertRowLineage({
+      .values = {10, 20, 30, 40, 50},
+      .firstRowId = 200,
+      .dataSequenceNumber = 42,
+      .deletePositions = {1, 3},
+      .expectedVectors = {makeRowVector(
+          kOutputNames,
+          {
+              makeFlatVector<int64_t>({10, 30, 50}),
+              makeFlatVector<int64_t>({200, 202, 204}),
+              makeFlatVector<int64_t>({42, 42, 42}),
+          })},
+  });
+
+  // 8. Subfield filter: _row_id uses file-absolute positions, not output
+  // indices.
+  assertRowLineage({
+      .values = {10, 20, 30, 40, 50},
+      .firstRowId = 100,
+      .dataSequenceNumber = 15,
+      .subfieldFilter = "c0 > 20",
+      .expectedVectors = {makeRowVector(
+          kOutputNames,
+          {
+              makeFlatVector<int64_t>({30, 40, 50}),
+              makeFlatVector<int64_t>({102, 103, 104}),
+              makeFlatVector<int64_t>({15, 15, 15}),
+          })},
+  });
 }
 
 #ifdef VELOX_ENABLE_PARQUET
-TEST_F(HiveIcebergTest, testPositionalDeleteFileWithRowGroupFilter) {
+TEST_F(HiveIcebergTest, positionalDeleteFileWithRowGroupFilter) {
   // This file contains three row groups, each with about 100 rows.
   // Each row group has min/max values: [200, 299], [0, 99], [100, 199].
   // The filter here is id >= 100, which will cause the parquet reader to filter
@@ -850,14 +1686,294 @@ TEST_F(HiveIcebergTest, testPositionalDeleteFileWithRowGroupFilter) {
       deletedPositionSize); // allocate 100 elements, [100, 199].
   std::iota(deletePositionsVec.begin(), deletePositionsVec.end(), 100);
   auto deleteFilePath = TempFilePath::create();
-  HiveConnectorTestBase::assertQuery(
-      PlanBuilder(pool_.get())
-          .tableScan(ROW({"id"}, {BIGINT()}), {"id >= 100"})
+  assertQuery(
+      PlanBuilder()
+          .startTableScan()
+          .connectorId(kIcebergConnectorId)
+          .outputType(ROW({"id"}, {BIGINT()}))
+          .remainingFilter("id >= 100")
+          .endTableScan()
           .planNode(),
+
       createParquetDeleteFileAndSplits(
           path, deletePositionsVec, deletedPositionSize, deleteFilePath),
       "SELECT i AS id FROM range(100, 300) AS t(i)",
       0);
 }
 #endif
+
+// Sequence number filtering tests for positional deletes (Diff 2).
+// Per the Iceberg V2+ spec, a positional delete file should only apply to
+// data files whose dataSequenceNumber is strictly less than the delete file's.
+
+TEST_F(HiveIcebergTest, positionalDeleteSequenceNumberApplied) {
+  folly::SingletonVault::singleton()->registrationComplete();
+
+  auto pathColumn = IcebergMetadataColumn::icebergDeleteFilePathColumn();
+  auto posColumn = IcebergMetadataColumn::icebergDeletePosColumn();
+  auto rowType = ROW({"c0"}, {BIGINT()});
+
+  // Write base data file: c0 = [0, 1, 2, 3, 4].
+  auto dataFilePath = TempFilePath::create();
+  writeToFile(
+      dataFilePath->getPath(),
+      {makeRowVector({makeFlatVector<int64_t>({0, 1, 2, 3, 4})})});
+
+  // Write positional delete file targeting positions 1 and 3.
+  auto deleteFilePath = TempFilePath::create();
+  auto baseFilePath = dataFilePath->getPath();
+  writeToFile(
+      deleteFilePath->getPath(),
+      {makeRowVector(
+          {pathColumn->name, posColumn->name},
+          {
+              makeFlatVector<std::string>(
+                  2, [&](vector_size_t) { return baseFilePath; }),
+              makeFlatVector<int64_t>({1, 3}),
+          })});
+
+  // Delete file seqNum=10 > data seqNum=5 → delete should be applied.
+  IcebergDeleteFile deleteFile(
+      FileContent::kPositionalDeletes,
+      deleteFilePath->getPath(),
+      dwio::common::FileFormat::DWRF,
+      2,
+      getTestFileSize(deleteFilePath->getPath()),
+      {},
+      {},
+      {},
+      /*dataSequenceNumber=*/10);
+
+  auto file = filesystems::getFileSystem(baseFilePath, nullptr)
+                  ->openFileForRead(baseFilePath);
+  auto split = std::make_shared<HiveIcebergSplit>(
+      kIcebergConnectorId,
+      baseFilePath,
+      dwio::common::FileFormat::DWRF,
+      0,
+      file->size(),
+      std::unordered_map<std::string, std::optional<std::string>>{},
+      std::nullopt,
+      std::unordered_map<std::string, std::string>{},
+      nullptr,
+      true,
+      std::vector<IcebergDeleteFile>{deleteFile},
+      std::unordered_map<std::string, std::string>{},
+      std::nullopt,
+      /*dataSequenceNumber=*/5);
+
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .connectorId(kIcebergConnectorId)
+                  .outputType(rowType)
+                  .endTableScan()
+                  .planNode();
+
+  // Positions 1 and 3 deleted → remaining: [0, 2, 4].
+  auto expected = makeRowVector({makeFlatVector<int64_t>({0, 2, 4})});
+  AssertQueryBuilder(plan).split(split).assertResults({expected});
+}
+
+TEST_F(HiveIcebergTest, positionalDeleteSequenceNumberSkipped) {
+  folly::SingletonVault::singleton()->registrationComplete();
+
+  auto pathColumn = IcebergMetadataColumn::icebergDeleteFilePathColumn();
+  auto posColumn = IcebergMetadataColumn::icebergDeletePosColumn();
+  auto rowType = ROW({"c0"}, {BIGINT()});
+
+  auto dataFilePath = TempFilePath::create();
+  writeToFile(
+      dataFilePath->getPath(),
+      {makeRowVector({makeFlatVector<int64_t>({0, 1, 2, 3, 4})})});
+
+  auto deleteFilePath = TempFilePath::create();
+  auto baseFilePath = dataFilePath->getPath();
+  writeToFile(
+      deleteFilePath->getPath(),
+      {makeRowVector(
+          {pathColumn->name, posColumn->name},
+          {
+              makeFlatVector<std::string>(
+                  2, [&](vector_size_t) { return baseFilePath; }),
+              makeFlatVector<int64_t>({1, 3}),
+          })});
+
+  // Delete file seqNum=5 < data seqNum=10 → delete should be skipped.
+  IcebergDeleteFile deleteFile(
+      FileContent::kPositionalDeletes,
+      deleteFilePath->getPath(),
+      dwio::common::FileFormat::DWRF,
+      2,
+      getTestFileSize(deleteFilePath->getPath()),
+      {},
+      {},
+      {},
+      /*dataSequenceNumber=*/5);
+
+  auto file = filesystems::getFileSystem(baseFilePath, nullptr)
+                  ->openFileForRead(baseFilePath);
+  auto split = std::make_shared<HiveIcebergSplit>(
+      kIcebergConnectorId,
+      baseFilePath,
+      dwio::common::FileFormat::DWRF,
+      0,
+      file->size(),
+      std::unordered_map<std::string, std::optional<std::string>>{},
+      std::nullopt,
+      std::unordered_map<std::string, std::string>{},
+      nullptr,
+      true,
+      std::vector<IcebergDeleteFile>{deleteFile},
+      std::unordered_map<std::string, std::string>{},
+      std::nullopt,
+      /*dataSequenceNumber=*/10);
+
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .connectorId(kIcebergConnectorId)
+                  .outputType(rowType)
+                  .endTableScan()
+                  .planNode();
+
+  // Delete skipped → all rows survive: [0, 1, 2, 3, 4].
+  auto expected = makeRowVector({makeFlatVector<int64_t>({0, 1, 2, 3, 4})});
+  AssertQueryBuilder(plan).split(split).assertResults({expected});
+}
+
+// Verifies that same-snapshot positional deletes apply (deleteSeqNum ==
+// dataSeqNum). Per the Iceberg spec, positional deletes in the same snapshot
+// SHOULD apply, so the skip condition uses strict < (not <=).
+TEST_F(HiveIcebergTest, positionalDeleteSequenceNumberEqualApplied) {
+  folly::SingletonVault::singleton()->registrationComplete();
+
+  auto pathColumn = IcebergMetadataColumn::icebergDeleteFilePathColumn();
+  auto posColumn = IcebergMetadataColumn::icebergDeletePosColumn();
+  auto rowType = ROW({"c0"}, {BIGINT()});
+
+  auto dataFilePath = TempFilePath::create();
+  writeToFile(
+      dataFilePath->getPath(),
+      {makeRowVector({makeFlatVector<int64_t>({0, 1, 2, 3, 4})})});
+
+  auto deleteFilePath = TempFilePath::create();
+  auto baseFilePath = dataFilePath->getPath();
+  writeToFile(
+      deleteFilePath->getPath(),
+      {makeRowVector(
+          {pathColumn->name, posColumn->name},
+          {
+              makeFlatVector<std::string>(
+                  2, [&](vector_size_t) { return baseFilePath; }),
+              makeFlatVector<int64_t>({1, 3}),
+          })});
+
+  // Delete file seqNum=5 == data seqNum=5 → delete should be applied
+  // (same-snapshot positional deletes apply per Iceberg spec).
+  IcebergDeleteFile deleteFile(
+      FileContent::kPositionalDeletes,
+      deleteFilePath->getPath(),
+      dwio::common::FileFormat::DWRF,
+      2,
+      getTestFileSize(deleteFilePath->getPath()),
+      {},
+      {},
+      {},
+      /*dataSequenceNumber=*/5);
+
+  auto file = filesystems::getFileSystem(baseFilePath, nullptr)
+                  ->openFileForRead(baseFilePath);
+  auto split = std::make_shared<HiveIcebergSplit>(
+      kIcebergConnectorId,
+      baseFilePath,
+      dwio::common::FileFormat::DWRF,
+      0,
+      file->size(),
+      std::unordered_map<std::string, std::optional<std::string>>{},
+      std::nullopt,
+      std::unordered_map<std::string, std::string>{},
+      nullptr,
+      true,
+      std::vector<IcebergDeleteFile>{deleteFile},
+      std::unordered_map<std::string, std::string>{},
+      std::nullopt,
+      /*dataSequenceNumber=*/5);
+
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .connectorId(kIcebergConnectorId)
+                  .outputType(rowType)
+                  .endTableScan()
+                  .planNode();
+
+  // Same-snapshot delete applied: positions 1 and 3 deleted → [0, 2, 4].
+  auto expected = makeRowVector({makeFlatVector<int64_t>({0, 2, 4})});
+  AssertQueryBuilder(plan).split(split).assertResults({expected});
+}
+
+TEST_F(HiveIcebergTest, positionalDeleteSequenceNumberZeroDisablesFilter) {
+  folly::SingletonVault::singleton()->registrationComplete();
+
+  auto pathColumn = IcebergMetadataColumn::icebergDeleteFilePathColumn();
+  auto posColumn = IcebergMetadataColumn::icebergDeletePosColumn();
+  auto rowType = ROW({"c0"}, {BIGINT()});
+
+  auto dataFilePath = TempFilePath::create();
+  writeToFile(
+      dataFilePath->getPath(),
+      {makeRowVector({makeFlatVector<int64_t>({0, 1, 2, 3, 4})})});
+
+  auto deleteFilePath = TempFilePath::create();
+  auto baseFilePath = dataFilePath->getPath();
+  writeToFile(
+      deleteFilePath->getPath(),
+      {makeRowVector(
+          {pathColumn->name, posColumn->name},
+          {
+              makeFlatVector<std::string>(
+                  2, [&](vector_size_t) { return baseFilePath; }),
+              makeFlatVector<int64_t>({1, 3}),
+          })});
+
+  // Delete file seqNum=0 (unassigned/V1 legacy) → always applied regardless.
+  IcebergDeleteFile deleteFile(
+      FileContent::kPositionalDeletes,
+      deleteFilePath->getPath(),
+      dwio::common::FileFormat::DWRF,
+      2,
+      getTestFileSize(deleteFilePath->getPath()),
+      {},
+      {},
+      {},
+      /*dataSequenceNumber=*/0);
+
+  auto file = filesystems::getFileSystem(baseFilePath, nullptr)
+                  ->openFileForRead(baseFilePath);
+  auto split = std::make_shared<HiveIcebergSplit>(
+      kIcebergConnectorId,
+      baseFilePath,
+      dwio::common::FileFormat::DWRF,
+      0,
+      file->size(),
+      std::unordered_map<std::string, std::optional<std::string>>{},
+      std::nullopt,
+      std::unordered_map<std::string, std::string>{},
+      nullptr,
+      true,
+      std::vector<IcebergDeleteFile>{deleteFile},
+      std::unordered_map<std::string, std::string>{},
+      std::nullopt,
+      /*dataSequenceNumber=*/100);
+
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .connectorId(kIcebergConnectorId)
+                  .outputType(rowType)
+                  .endTableScan()
+                  .planNode();
+
+  // SeqNum=0 disables filtering → delete applied: [0, 2, 4].
+  auto expected = makeRowVector({makeFlatVector<int64_t>({0, 2, 4})});
+  AssertQueryBuilder(plan).split(split).assertResults({expected});
+}
+
 } // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.cpp b/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.cpp
index 2c2c26297fd..e1ba2c4269f 100644
--- a/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.cpp
+++ b/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.cpp
@@ -17,6 +17,8 @@
 #include "velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.h"
 #include <filesystem>
 
+#include "velox/connectors/hive/HiveConfig.h"
+
 using namespace facebook::velox;
 using namespace facebook::velox::dwio;
 using namespace facebook::velox::dwio::common;
@@ -99,8 +101,6 @@ IcebergSplitReaderBenchmark::makeIcebergSplit(
     const std::string& dataFilePath,
     const std::vector<IcebergDeleteFile>& deleteFiles) {
   std::unordered_map<std::string, std::optional<std::string>> partitionKeys;
-  std::unordered_map<std::string, std::string> customSplitInfo;
-  customSplitInfo["table_format"] = "hive-iceberg";
 
   auto readFile = std::make_shared<LocalReadFile>(dataFilePath);
   const int64_t fileSize = readFile->size();
@@ -108,12 +108,12 @@ IcebergSplitReaderBenchmark::makeIcebergSplit(
   return std::make_shared<HiveIcebergSplit>(
       kHiveConnectorId,
       dataFilePath,
-      fileFomat_,
+      fileFormat_,
       0,
       fileSize,
       partitionKeys,
       std::nullopt,
-      customSplitInfo,
+      std::unordered_map<std::string, std::string>{},
       nullptr,
       /*cacheable=*/true,
       deleteFiles);
@@ -175,7 +175,7 @@ IcebergSplitReaderBenchmark::createIcebergSplitsWithPositionalDelete(
       IcebergDeleteFile deleteFile(
           FileContent::kPositionalDeletes,
           deleteFilePath,
-          fileFomat_,
+          fileFormat_,
           deleteRowsCount,
           testing::internal::GetFileSize(
               std::fopen(deleteFilePath.c_str(), "r")));
@@ -284,7 +284,6 @@ void IcebergSplitReaderBenchmark::readSingleColumn(
       std::make_shared<HiveTableHandle>(
           "kHiveConnectorId",
           "tableName",
-          false,
           std::move(filters),
           remainingFilterExpr,
           rowType);
@@ -293,10 +292,11 @@ void IcebergSplitReaderBenchmark::readSingleColumn(
       std::make_shared<HiveConfig>(std::make_shared<config::ConfigBase>(
           std::unordered_map<std::string, std::string>(), true));
   const RowTypePtr readerOutputType;
-  const std::shared_ptr<io::IoStatistics> ioStats =
+  const std::shared_ptr<io::IoStatistics> ioStatistics =
+      std::make_shared<io::IoStatistics>();
+  const std::shared_ptr<io::IoStatistics> metadataIoStatistics =
       std::make_shared<io::IoStatistics>();
-  const std::shared_ptr<filesystems::File::IoStats> fsStats =
-      std::make_shared<filesystems::File::IoStats>();
+  const std::shared_ptr<IoStats> ioStats = std::make_shared<IoStats>();
 
   std::shared_ptr<memory::MemoryPool> root =
       memory::memoryManager()->addRootPool(
@@ -331,21 +331,24 @@ void IcebergSplitReaderBenchmark::readSingleColumn(
   suspender.dismiss();
 
   uint64_t resultSize = 0;
-  for (std::shared_ptr<HiveConnectorSplit> split : splits) {
+  for (const auto& split : splits) {
     scanSpec->resetCachedValues(true);
+    auto icebergSplit = checkedPointerCast<const HiveIcebergSplit>(split);
     std::unique_ptr<IcebergSplitReader> icebergSplitReader =
         std::make_unique<IcebergSplitReader>(
-            split,
+            icebergSplit,
             hiveTableHandle,
             nullptr,
             connectorQueryCtx_.get(),
             hiveConfig,
             rowType,
+            ioStatistics,
+            metadataIoStatistics,
             ioStats,
-            fsStats,
             &fileHandleFactory,
             nullptr,
-            scanSpec);
+            scanSpec,
+            nullptr);
 
     std::shared_ptr<random::RandomSkipTracker> randomSkip;
     icebergSplitReader->configureReaderOptions(randomSkip);
diff --git a/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.h b/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.h
index 3408fa4ce83..5d96cc21005 100644
--- a/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.h
+++ b/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.h
@@ -16,6 +16,7 @@
 #pragma once
 
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/connectors/hive/TableHandle.h"
 #include "velox/connectors/hive/iceberg/IcebergDeleteFile.h"
 #include "velox/connectors/hive/iceberg/IcebergMetadataColumns.h"
@@ -24,7 +25,6 @@
 #include "velox/dwio/common/tests/utils/DataSetBuilder.h"
 #include "velox/dwio/dwrf/RegisterDwrfReader.h"
 #include "velox/dwio/dwrf/writer/Writer.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
 #include <folly/Benchmark.h>
@@ -32,6 +32,8 @@
 
 namespace facebook::velox::iceberg::reader::test {
 
+using TempDirectoryPath = common::testutil::TempDirectoryPath;
+
 constexpr uint32_t kNumRowsPerBatch = 20000;
 constexpr uint32_t kNumBatches = 50;
 constexpr uint32_t kNumRowsPerRowGroup = 10000;
@@ -108,10 +110,10 @@ class IcebergSplitReaderBenchmark {
 
  private:
   const std::string fileName_ = "test.data";
-  const std::shared_ptr<exec::test::TempDirectoryPath> fileFolder_ =
-      exec::test::TempDirectoryPath::create();
-  const std::shared_ptr<exec::test::TempDirectoryPath> deleteFileFolder_ =
-      exec::test::TempDirectoryPath::create();
+  const std::shared_ptr<TempDirectoryPath> fileFolder_ =
+      TempDirectoryPath::create();
+  const std::shared_ptr<TempDirectoryPath> deleteFileFolder_ =
+      TempDirectoryPath::create();
 
   std::unique_ptr<facebook::velox::test::DataSetBuilder> dataSetBuilder_;
   std::shared_ptr<memory::MemoryPool> rootPool_;
@@ -119,7 +121,7 @@ class IcebergSplitReaderBenchmark {
   std::unique_ptr<dwrf::Writer> writer_;
   dwio::common::RuntimeStatistics runtimeStats_;
 
-  dwio::common::FileFormat fileFomat_{dwio::common::FileFormat::DWRF};
+  dwio::common::FileFormat fileFormat_{dwio::common::FileFormat::DWRF};
   const std::string kHiveConnectorId = "hive-iceberg";
 };
 
diff --git a/velox/connectors/hive/iceberg/tests/IcebergTestBase.cpp b/velox/connectors/hive/iceberg/tests/IcebergTestBase.cpp
new file mode 100644
index 00000000000..eb1312eb1a2
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/IcebergTestBase.cpp
@@ -0,0 +1,330 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/tests/IcebergTestBase.h"
+
+#include <filesystem>
+
+#include "velox/connectors/ConnectorRegistry.h"
+#include "velox/connectors/hive/iceberg/IcebergColumnHandle.h"
+#include "velox/connectors/hive/iceberg/IcebergConfig.h"
+#include "velox/connectors/hive/iceberg/IcebergConnector.h"
+#include "velox/connectors/hive/iceberg/IcebergDataSink.h"
+#include "velox/connectors/hive/iceberg/IcebergSplit.h"
+#include "velox/connectors/hive/iceberg/PartitionSpec.h"
+#include "velox/expression/Expr.h"
+
+namespace facebook::velox::connector::hive::iceberg::test {
+
+const std::string kIcebergConnectorId{"test-iceberg"};
+
+void IcebergTestBase::SetUp() {
+  HiveConnectorTestBase::SetUp();
+#ifdef VELOX_ENABLE_PARQUET
+  parquet::registerParquetReaderFactory();
+  parquet::registerParquetWriterFactory();
+#endif
+  Type::registerSerDe();
+
+  // Register IcebergConnector.
+  IcebergConnectorFactory icebergFactory;
+  auto icebergConnector = icebergFactory.newConnector(
+      kIcebergConnectorId,
+      std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>()),
+      ioExecutor_.get());
+  ConnectorRegistry::global().insert(
+      icebergConnector->connectorId(), icebergConnector);
+
+  connectorSessionProperties_ = std::make_shared<config::ConfigBase>(
+      std::unordered_map<std::string, std::string>(), true);
+
+  hiveConfig_ =
+      std::make_shared<HiveConfig>(std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>()));
+
+  icebergConfig_ =
+      std::make_shared<IcebergConfig>(std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>{
+              {IcebergConfig::kFunctionPrefixConfig,
+               IcebergConfig::kDefaultFunctionPrefix}}));
+
+  setupMemoryPools();
+
+  fuzzerOptions_.vectorSize = 100;
+  fuzzerOptions_.nullRatio = 0.1;
+  fuzzer_ = std::make_unique<VectorFuzzer>(fuzzerOptions_, opPool_.get(), 1);
+}
+
+void IcebergTestBase::TearDown() {
+  fuzzer_.reset();
+  connectorQueryCtx_.reset();
+  connectorPool_.reset();
+  opPool_.reset();
+  root_.reset();
+  queryCtx_.reset();
+  ConnectorRegistry::global().erase(kIcebergConnectorId);
+  HiveConnectorTestBase::TearDown();
+}
+
+void IcebergTestBase::setupMemoryPools() {
+  root_.reset();
+  opPool_.reset();
+  connectorPool_.reset();
+  connectorQueryCtx_.reset();
+  queryCtx_.reset();
+
+  root_ = memory::memoryManager()->addRootPool(
+      "IcebergTest", 1L << 30, exec::MemoryReclaimer::create());
+  opPool_ = root_->addLeafChild("operator");
+  connectorPool_ =
+      root_->addAggregateChild("connector", exec::MemoryReclaimer::create());
+
+  recreateConnectorQueryCtx(/*sessionTimezone=*/"", false);
+}
+
+void IcebergTestBase::recreateConnectorQueryCtx(
+    const std::string& sessionTimezone,
+    bool adjustTimestampToTimezone) {
+  connectorQueryCtx_.reset();
+  queryCtx_.reset();
+
+  queryCtx_ = core::QueryCtx::create(nullptr, core::QueryConfig({}));
+  auto expressionEvaluator = std::make_unique<exec::SimpleExpressionEvaluator>(
+      queryCtx_.get(), opPool_.get());
+
+  connectorQueryCtx_ = std::make_unique<ConnectorQueryCtx>(
+      opPool_.get(),
+      connectorPool_.get(),
+      connectorSessionProperties_.get(),
+      nullptr,
+      common::PrefixSortConfig(),
+      std::move(expressionEvaluator),
+      nullptr,
+      "query.IcebergTest",
+      "task.IcebergTest",
+      "planNodeId.IcebergTest",
+      0,
+      sessionTimezone,
+      adjustTimestampToTimezone);
+}
+
+std::vector<RowVectorPtr> IcebergTestBase::createTestData(
+    RowTypePtr rowType,
+    int32_t numBatches,
+    vector_size_t rowsPerBatch,
+    double nullRatio) {
+  std::vector<RowVectorPtr> vectors;
+  vectors.reserve(numBatches);
+
+  fuzzerOptions_.nullRatio = nullRatio;
+  fuzzerOptions_.allowDictionaryVector = false;
+  fuzzerOptions_.timestampPrecision =
+      fuzzer::FuzzerTimestampPrecision::kMilliSeconds;
+  fuzzer_->setOptions(fuzzerOptions_);
+
+  for (auto i = 0; i < numBatches; ++i) {
+    vectors.push_back(fuzzer_->fuzzRow(rowType, rowsPerBatch, false));
+  }
+
+  return vectors;
+}
+
+void IcebergTestBase::setConnectorSessionProperty(
+    const std::string& key,
+    const std::string& value) {
+  VELOX_CHECK_NOT_NULL(connectorSessionProperties_);
+  connectorSessionProperties_->set(key, value);
+}
+
+std::shared_ptr<IcebergPartitionSpec> IcebergTestBase::createPartitionSpec(
+    const RowTypePtr& rowType,
+    const std::vector<PartitionField>& partitionFields) {
+  std::vector<IcebergPartitionSpec::Field> fields;
+  for (const auto& partitionField : partitionFields) {
+    fields.push_back(
+        IcebergPartitionSpec::Field{
+            rowType->nameOf(partitionField.id),
+            rowType->childAt(partitionField.id),
+            partitionField.type,
+            partitionField.parameter});
+  }
+
+  return fields.empty() ? nullptr
+                        : std::make_shared<IcebergPartitionSpec>(1, fields);
+}
+
+namespace {
+
+parquet::ParquetFieldId makeField(const TypePtr& type, int32_t& fieldId) {
+  const int32_t currentId = fieldId++;
+  std::vector<parquet::ParquetFieldId> children;
+  children.reserve(type->size());
+  for (auto i = 0; i < type->size(); ++i) {
+    children.push_back(makeField(type->childAt(i), fieldId));
+  }
+  return parquet::ParquetFieldId{currentId, children};
+}
+
+void addColumnHandles(
+    const RowTypePtr& rowType,
+    const std::vector<PartitionField>& partitionFields,
+    std::vector<IcebergColumnHandlePtr>& columnHandles) {
+  std::unordered_set<int32_t> partitionColumnIds;
+  for (const auto& field : partitionFields) {
+    partitionColumnIds.insert(field.id);
+  }
+
+  int32_t fieldId = 1;
+  columnHandles.reserve(rowType->size());
+  for (auto i = 0; i < rowType->size(); ++i) {
+    const auto& columnName = rowType->nameOf(i);
+    const auto& type = rowType->childAt(i);
+    auto field = makeField(type, fieldId);
+    columnHandles.push_back(
+        std::make_shared<const IcebergColumnHandle>(
+            columnName,
+            partitionColumnIds.contains(i)
+                ? FileColumnHandle::ColumnType::kPartitionKey
+                : FileColumnHandle::ColumnType::kRegular,
+            type,
+            field));
+  }
+}
+
+} // namespace
+
+IcebergInsertTableHandlePtr IcebergTestBase::createInsertTableHandle(
+    const RowTypePtr& rowType,
+    const std::string& outputDirectoryPath,
+    const std::vector<PartitionField>& partitionFields) {
+  std::vector<IcebergColumnHandlePtr> columnHandles;
+  addColumnHandles(rowType, partitionFields, columnHandles);
+
+  auto locationHandle = std::make_shared<LocationHandle>(
+      outputDirectoryPath,
+      outputDirectoryPath,
+      LocationHandle::TableType::kNew);
+
+  auto partitionSpec = createPartitionSpec(rowType, partitionFields);
+
+  return std::make_shared<const IcebergInsertTableHandle>(
+      /*inputColumns=*/columnHandles,
+      locationHandle,
+      /*tableStorageFormat=*/fileFormat_,
+      partitionSpec,
+      /*compressionKind=*/common::CompressionKind::CompressionKind_ZSTD);
+}
+
+std::shared_ptr<IcebergDataSink> IcebergTestBase::createDataSink(
+    const RowTypePtr& rowType,
+    const std::string& outputDirectoryPath,
+    const std::vector<PartitionField>& partitionFields) {
+  auto tableHandle =
+      createInsertTableHandle(rowType, outputDirectoryPath, partitionFields);
+  return std::make_shared<IcebergDataSink>(
+      rowType,
+      tableHandle,
+      connectorQueryCtx_.get(),
+      CommitStrategy::kNoCommit,
+      hiveConfig_,
+      icebergConfig_);
+}
+
+std::shared_ptr<IcebergDataSink> IcebergTestBase::createDataSinkAndAppendData(
+    const std::vector<RowVectorPtr>& vectors,
+    const std::string& dataPath,
+    const std::vector<PartitionField>& partitionFields) {
+  VELOX_CHECK(!vectors.empty(), "vectors cannot be empty");
+
+  auto rowType = vectors.front()->rowType();
+  auto dataSink = createDataSink(rowType, dataPath, partitionFields);
+
+  for (const auto& vector : vectors) {
+    dataSink->appendData(vector);
+  }
+  EXPECT_TRUE(dataSink->finish());
+  return dataSink;
+}
+
+std::vector<std::string> IcebergTestBase::listFiles(
+    const std::string& dirPath) {
+  std::vector<std::string> files;
+  if (!std::filesystem::exists(dirPath)) {
+    return files;
+  }
+
+  for (auto& dirEntry :
+       std::filesystem::recursive_directory_iterator(dirPath)) {
+    if (dirEntry.is_regular_file()) {
+      files.push_back(dirEntry.path().string());
+    }
+  }
+  return files;
+}
+
+std::unordered_map<std::string, std::optional<std::string>>
+IcebergTestBase::extractPartitionKeys(const std::string& filePath) {
+  std::unordered_map<std::string, std::optional<std::string>> partitionKeys;
+
+  std::vector<std::string> pathComponents;
+  folly::split("/", filePath, pathComponents);
+  for (const auto& component : pathComponents) {
+    if (component.find('=') != std::string::npos) {
+      std::vector<std::string> keys;
+      folly::split('=', component, keys);
+      if (keys.size() == 2) {
+        if (keys[1] == "null") {
+          partitionKeys[keys[0]] = std::nullopt;
+        } else {
+          partitionKeys[keys[0]] = keys[1];
+        }
+      }
+    }
+  }
+
+  return partitionKeys;
+}
+
+std::vector<std::shared_ptr<ConnectorSplit>>
+IcebergTestBase::createSplitsForDirectory(const std::string& directory) {
+  std::vector<std::shared_ptr<ConnectorSplit>> splits;
+
+  auto files = listFiles(directory);
+  for (const auto& filePath : files) {
+    auto partitionKeys = extractPartitionKeys(filePath);
+
+    const auto file = filesystems::getFileSystem(filePath, nullptr)
+                          ->openFileForRead(filePath);
+    splits.push_back(
+        std::make_shared<HiveIcebergSplit>(
+            kIcebergConnectorId,
+            filePath,
+            fileFormat_,
+            0,
+            file->size(),
+            partitionKeys,
+            std::nullopt,
+            std::unordered_map<std::string, std::string>{},
+            nullptr,
+            /*cacheable=*/true,
+            std::vector<IcebergDeleteFile>()));
+  }
+
+  return splits;
+}
+
+} // namespace facebook::velox::connector::hive::iceberg::test
diff --git a/velox/connectors/hive/iceberg/tests/IcebergTestBase.h b/velox/connectors/hive/iceberg/tests/IcebergTestBase.h
new file mode 100644
index 00000000000..b3eefbd4726
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/IcebergTestBase.h
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <gtest/gtest.h>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "velox/common/testutil/TempDirectoryPath.h"
+#include "velox/connectors/hive/iceberg/IcebergConfig.h"
+#include "velox/connectors/hive/iceberg/IcebergDataSink.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+#ifdef VELOX_ENABLE_PARQUET
+#include "velox/dwio/parquet/RegisterParquetWriter.h"
+#include "velox/dwio/parquet/reader/ParquetReader.h"
+#endif
+
+namespace facebook::velox::connector::hive::iceberg::test {
+
+using TempDirectoryPath = common::testutil::TempDirectoryPath;
+
+extern const std::string kIcebergConnectorId;
+
+struct PartitionField {
+  // 0-based column index.
+  int32_t id;
+  TransformType type;
+  std::optional<int32_t> parameter;
+};
+
+class IcebergTestBase : public exec::test::HiveConnectorTestBase {
+ protected:
+  void SetUp() override;
+
+  void TearDown() override;
+
+  std::vector<RowVectorPtr> createTestData(
+      RowTypePtr rowType,
+      int32_t numBatches,
+      vector_size_t rowsPerBatch,
+      double nullRatio = 0.0);
+
+  std::shared_ptr<IcebergDataSink> createDataSink(
+      const RowTypePtr& rowType,
+      const std::string& outputDirectoryPath,
+      const std::vector<PartitionField>& partitionFields = {});
+
+  std::shared_ptr<IcebergDataSink> createDataSinkAndAppendData(
+      const std::vector<RowVectorPtr>& vectors,
+      const std::string& dataPath,
+      const std::vector<PartitionField>& partitionFields = {});
+
+  std::vector<std::shared_ptr<ConnectorSplit>> createSplitsForDirectory(
+      const std::string& directory);
+
+  std::vector<std::string> listFiles(const std::string& dirPath);
+
+  std::shared_ptr<IcebergPartitionSpec> createPartitionSpec(
+      const RowTypePtr& rowType,
+      const std::vector<PartitionField>& partitionFields);
+
+  void setConnectorSessionProperty(
+      const std::string& key,
+      const std::string& value);
+
+  /// Recreates the connector query context with the given session timezone
+  /// and timestamp-adjustment flag. Tests use this to exercise non-UTC
+  /// session configurations and verify timezone-sensitive behavior.
+  void recreateConnectorQueryCtx(
+      const std::string& sessionTimezone,
+      bool adjustTimestampToTimezone);
+
+  /// Extracts partition key-value pairs from a file path.
+  /// Returns a map where keys are partition column names and values are
+  /// partition values (std::nullopt for null values).
+  /// Example: "/path/to/c1=10/c2=null/file.parquet" returns
+  /// {{"c1", "10"}, {"c2", std::nullopt}}.
+  static std::unordered_map<std::string, std::optional<std::string>>
+  extractPartitionKeys(const std::string& filePath);
+
+  dwio::common::FileFormat fileFormat_{dwio::common::FileFormat::PARQUET};
+  std::shared_ptr<memory::MemoryPool> opPool_;
+  std::unique_ptr<ConnectorQueryCtx> connectorQueryCtx_;
+
+ private:
+  IcebergInsertTableHandlePtr createInsertTableHandle(
+      const RowTypePtr& rowType,
+      const std::string& outputDirectoryPath,
+      const std::vector<PartitionField>& partitionFields = {});
+
+  std::vector<std::string> listPartitionDirectories(
+      const std::string& dataPath);
+
+  void setupMemoryPools();
+
+  std::shared_ptr<memory::MemoryPool> root_;
+  std::shared_ptr<memory::MemoryPool> connectorPool_;
+  std::shared_ptr<config::ConfigBase> connectorSessionProperties_;
+  std::shared_ptr<HiveConfig> hiveConfig_;
+  std::shared_ptr<IcebergConfig> icebergConfig_;
+  VectorFuzzer::Options fuzzerOptions_;
+  std::unique_ptr<VectorFuzzer> fuzzer_;
+  std::shared_ptr<core::QueryCtx> queryCtx_;
+};
+
+} // namespace facebook::velox::connector::hive::iceberg::test
diff --git a/velox/connectors/hive/iceberg/tests/Main.cpp b/velox/connectors/hive/iceberg/tests/Main.cpp
new file mode 100644
index 00000000000..3c9dd661505
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/Main.cpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/process/ThreadDebugInfo.h"
+
+#include <folly/init/Init.h>
+#include <gtest/gtest.h>
+
+// This main is needed for some tests on linux.
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  // Signal handler required for ThreadDebugInfoTest
+  facebook::velox::process::addDefaultFatalSignalHandler();
+  folly::Init init(&argc, &argv, false);
+  return RUN_ALL_TESTS();
+}
diff --git a/velox/connectors/hive/iceberg/tests/PartitionNameTest.cpp b/velox/connectors/hive/iceberg/tests/PartitionNameTest.cpp
new file mode 100644
index 00000000000..8e9bafbe453
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/PartitionNameTest.cpp
@@ -0,0 +1,481 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <numeric>
+
+#include "velox/common/encode/Base64.h"
+#include "velox/connectors/hive/iceberg/IcebergConfig.h"
+#include "velox/connectors/hive/iceberg/IcebergPartitionName.h"
+#include "velox/connectors/hive/iceberg/TransformEvaluator.h"
+#include "velox/connectors/hive/iceberg/TransformExprBuilder.h"
+#include "velox/connectors/hive/iceberg/tests/IcebergTestBase.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+using namespace facebook::velox;
+
+namespace {
+
+class PartitionNameTest : public test::IcebergTestBase {
+ protected:
+  // Generates partition IDs for the input rows and verifies that the resulting
+  // partition paths match the expected paths. Each row is processed
+  // independently, and its generated partition path is compared against the
+  // corresponding entry in expectedPaths.
+  //
+  // @param input Input data to generate partition IDs from. Must have the
+  // same size as expectedPaths.
+  // @param partitionSpec The IcebergPartitionSpec defining the partition
+  // transforms. The partition channels are determined by matching field names
+  // from the spec to column names in the input's type.
+  // @param expectedPaths Expected partition path strings, one per row. Each
+  // path should be the complete partition directory name (e.g., "col1=val1").
+  void verifyPartitionPaths(
+      const RowVectorPtr& input,
+      const std::shared_ptr<IcebergPartitionSpec>& partitionSpec,
+      const std::vector<std::string>& expectedPaths) const {
+    ASSERT_EQ(expectedPaths.size(), input->size());
+    std::vector<column_index_t> partitionChannels(partitionSpec->fields.size());
+    auto rowType = input->rowType();
+    for (auto i = 0; i < partitionSpec->fields.size(); ++i) {
+      partitionChannels[i] =
+          rowType->getChildIdx(partitionSpec->fields[i].name);
+    }
+
+    // Step 1: Build transform expressions and create evaluator.
+    auto transformExpressions = TransformExprBuilder::toExpressions(
+        partitionSpec,
+        partitionChannels,
+        rowType,
+        std::string(IcebergConfig::kDefaultFunctionPrefix));
+    auto transformEvaluator = std::make_unique<TransformEvaluator>(
+        transformExpressions, connectorQueryCtx_.get());
+
+    // Step 2: Apply transforms to input partition columns.
+    auto transformedColumns = transformEvaluator->evaluate(input);
+
+    std::vector<TypePtr> partitionKeyTypes;
+    std::vector<std::string> partitionKeyNames;
+    for (const auto& field : partitionSpec->fields) {
+      partitionKeyTypes.emplace_back(field.resultType());
+      std::string key = field.transformType == TransformType::kIdentity
+          ? field.name
+          : fmt::format(
+                "{}_{}",
+                field.name,
+                TransformTypeName::toName(field.transformType));
+      partitionKeyNames.emplace_back(std::move(key));
+    }
+
+    auto partitionRowType =
+        ROW(std::move(partitionKeyNames), std::move(partitionKeyTypes));
+    // Step 3: Create RowVector based on transformed columns.
+    auto transformedRowVector = std::make_shared<RowVector>(
+        connectorQueryCtx_->memoryPool(),
+        partitionRowType,
+        nullptr,
+        input->size(),
+        std::move(transformedColumns));
+
+    // Step 4: Generate partition IDs from transformed data.
+    // The transformed row vector has columns in the same order as partition
+    // spec fields, so channels are sequential: 0, 1, 2, ...
+    std::vector<column_index_t> transformedChannels(
+        partitionSpec->fields.size());
+    std::iota(transformedChannels.begin(), transformedChannels.end(), 0);
+
+    auto idGenerator = std::make_unique<PartitionIdGenerator>(
+        partitionRowType,
+        transformedChannels,
+        /*maxPartitions=*/128,
+        connectorQueryCtx_->memoryPool());
+
+    auto nameGenerator = std::make_unique<IcebergPartitionName>(partitionSpec);
+
+    raw_vector<uint64_t> partitionIds(input->size());
+    idGenerator->run(transformedRowVector, partitionIds);
+
+    for (auto i = 0; i < input->size(); ++i) {
+      std::string partitionName = nameGenerator->partitionName(
+          partitionIds[i], idGenerator->partitionValues(), false);
+      ASSERT_EQ(partitionName, expectedPaths[i]);
+    }
+  }
+};
+
+TEST_F(PartitionNameTest, identity) {
+  std::vector<std::tuple<TypePtr, VectorPtr, std::string>> input = {
+      {INTEGER(), makeConstant<int32_t>(42, 1), "42"},
+      {BIGINT(), makeConstant<int64_t>(9'876'543'210, 1), "9876543210"},
+      {VARCHAR(),
+       makeConstant<std::string>("test string partition column name", 1),
+       "test+string+partition+column+name"},
+      {VARBINARY(),
+       makeConstant<std::string>("\x48\x65\x6c\x6c\x6f", 1, VARBINARY()),
+       "SGVsbG8%3D"},
+      {DECIMAL(18, 4),
+       makeConstant<int64_t>(12'345'678'901'234, 1, DECIMAL(18, 4)),
+       "1234567890.1234"},
+      {BOOLEAN(), makeConstant<bool>(true, 1), "true"},
+      {DATE(), makeConstant<int32_t>(18'262, 1, DATE()), "2020-01-01"},
+  };
+
+  for (const auto& [type, value, expectedValue] : input) {
+    const auto& partitionSpec = createPartitionSpec(
+        ROW({"c0"}, {type}), {{0, TransformType::kIdentity, std::nullopt}});
+
+    verifyPartitionPaths(
+        makeRowVector({value}),
+        partitionSpec,
+        {fmt::format("c0={}", expectedValue)});
+  }
+}
+
+TEST_F(PartitionNameTest, timestamp) {
+  std::vector<Timestamp> timestamps = {
+      Timestamp(253402300800, 100000000), // +10000-01-01T00:00:00.1.
+      Timestamp(-62170000000, 0), // -0001-11-29T19:33:20.
+      Timestamp(-62135577748, 999000000), // 0001-01-01T05:17:32.999.
+      Timestamp(0, 0), // 1970-01-01T00:00.
+      Timestamp(1609459200, 999000000), // 2021-01-01T00:00.
+      Timestamp(1640995200, 500000000), // 2022-01-01T00:00:00.5.
+      Timestamp(1672531200, 123000000), // 2023-01-01T00:00:00.123.
+      Timestamp(-1, 999000000), // 1969-12-31T23:59:59.999.
+      Timestamp(1, 1000000), // 1970-01-01T00:00:01.001.
+      Timestamp(-62167219199, 0), // 0000-01-01T00:00:01.
+      Timestamp(-377716279140, 321000000), // -10000-01-01T01:01:00.321.
+      Timestamp(253402304660, 321000000), // +10000-01-01T01:01:00.321.
+      Timestamp(951782400, 0), // 2000-02-29T00:00:00 (leap year).
+      Timestamp(4107456000, 0), // 2100-02-28T00:00:00.
+      Timestamp(-86400, 0), // 1969-12-31T00:00:00.
+  };
+
+  std::vector<std::string> expectedPartitionNames = {
+      "c0=%2B10000-01-01T00%3A00%3A00.1",
+      "c0=-0001-11-29T19%3A33%3A20",
+      "c0=0001-01-01T05%3A17%3A32.999",
+      "c0=1970-01-01T00%3A00%3A00",
+      "c0=2021-01-01T00%3A00%3A00.999",
+      "c0=2022-01-01T00%3A00%3A00.5",
+      "c0=2023-01-01T00%3A00%3A00.123",
+      "c0=1969-12-31T23%3A59%3A59.999",
+      "c0=1970-01-01T00%3A00%3A01.001",
+      "c0=0000-01-01T00%3A00%3A01",
+      "c0=-10000-08-24T19%3A21%3A00.321",
+      "c0=%2B10000-01-01T01%3A04%3A20.321",
+      "c0=2000-02-29T00%3A00%3A00",
+      "c0=2100-02-28T00%3A00%3A00",
+      "c0=1969-12-31T00%3A00%3A00",
+  };
+
+  const auto& partitionSpec = createPartitionSpec(
+      ROW({"c0"}, {TIMESTAMP()}),
+      {{0, TransformType::kIdentity, std::nullopt}});
+
+  verifyPartitionPaths(
+      makeRowVector({makeFlatVector<Timestamp>(timestamps)}),
+      partitionSpec,
+      expectedPartitionNames);
+}
+
+TEST_F(PartitionNameTest, null) {
+  std::vector<
+      std::tuple<TypePtr, TransformType, std::optional<int32_t>, VectorPtr>>
+      input = {
+          {INTEGER(),
+           TransformType::kBucket,
+           32,
+           makeConstant<int32_t>(std::nullopt, 1)},
+          {VARCHAR(),
+           TransformType::kTruncate,
+           100,
+           makeConstant<std::string>(std::nullopt, 1)},
+          {DECIMAL(18, 3),
+           TransformType::kIdentity,
+           std::nullopt,
+           makeConstant<int64_t>(std::nullopt, 1, DECIMAL(18, 3))},
+          {TIMESTAMP(),
+           TransformType::kYear,
+           std::nullopt,
+           makeConstant<Timestamp>(std::nullopt, 1)},
+          {TIMESTAMP(),
+           TransformType::kMonth,
+           std::nullopt,
+           makeConstant<Timestamp>(std::nullopt, 1)},
+          {DATE(),
+           TransformType::kDay,
+           std::nullopt,
+           makeConstant<int32_t>(std::nullopt, 1, DATE())},
+          {TIMESTAMP(),
+           TransformType::kHour,
+           std::nullopt,
+           makeConstant<Timestamp>(std::nullopt, 1)},
+      };
+
+  for (const auto& [type, transformType, parameter, value] : input) {
+    auto rowType = ROW({"c0"}, {type});
+    const auto& partitionSpec =
+        createPartitionSpec(rowType, {{0, transformType, parameter}});
+    if (transformType == TransformType::kIdentity) {
+      verifyPartitionPaths(makeRowVector({value}), partitionSpec, {"c0=null"});
+    } else {
+      verifyPartitionPaths(
+          makeRowVector({value}),
+          partitionSpec,
+          {fmt::format(
+              "c0_{}=null", TransformTypeName::toName(transformType))});
+    }
+  }
+}
+
+// test both partition column name and partition key encoding.
+TEST_F(PartitionNameTest, specialChars) {
+  std::vector<std::pair<std::string, std::string>> inputs = {
+      {"abc123", "abc123"},
+      {"ABC123", "ABC123"},
+      {"a.b-c_d*e", "a.b-c_d*e"},
+      {"space test", "space+test"},
+      {"slash/test", "slash%2Ftest"},
+      {"question?test", "question%3Ftest"},
+      {"percent%test", "percent%25test"},
+      {"hash#test", "hash%23test"},
+      {"ampersand&test", "ampersand%26test"},
+      {"equals=test", "equals%3Dtest"},
+      {"plus+test", "plus%2Btest"},
+      {"comma,test", "comma%2Ctest"},
+      {"semicolon;test", "semicolon%3Btest"},
+      {"at@test", "at%40test"},
+      {"exclamation!test", "exclamation%21test"},
+      {"dollar$test", "dollar%24test"},
+      {"backslash\\test", "backslash%5Ctest"},
+      {"quote\"test", "quote%22test"},
+      {"apostrophe'test", "apostrophe%27test"},
+      {"paren(test", "paren%28test"},
+      {"paren)test", "paren%29test"},
+      {"less<than", "less%3Cthan"},
+      {"greater>than", "greater%3Ethan"},
+      {"colon:test", "colon%3Atest"},
+      {"pipe|test", "pipe%7Ctest"},
+      {"bracket[test", "bracket%5Btest"},
+      {"bracket]test", "bracket%5Dtest"},
+      {"brace{test", "brace%7Btest"},
+      {"brace}test", "brace%7Dtest"},
+      {"caret^test", "caret%5Etest"},
+      {"tilde~test", "tilde%7Etest"},
+      {"backtick`test", "backtick%60test"},
+      {"newline\ntest", "newline%0Atest"},
+      {"carriage\rreturn", "carriage%0Dreturn"},
+      {"tab\ttest", "tab%09test"},
+      {"unicode\u00A9test", "unicode%C2%A9test"},
+      {"email@example.com", "email%40example.com"},
+      {"user:password@host:port/path", "user%3Apassword%40host%3Aport%2Fpath"},
+      {"https://github.com/facebookincubator/velox",
+       "https%3A%2F%2Fgithub.com%2Ffacebookincubator%2Fvelox"},
+      {"a+b=c&d=e+f", "a%2Bb%3Dc%26d%3De%2Bf"},
+      {"a#b=c/d e", "a%23b%3Dc%2Fd+e"},
+      {"special!@#$%^&*()_+", "special%21%40%23%24%25%5E%26*%28%29_%2B"},
+  };
+
+  for (const auto& [input, encodedValue] : inputs) {
+    const auto& partitionSpec = createPartitionSpec(
+        ROW({input}, {VARCHAR()}),
+        {{0, TransformType::kIdentity, std::nullopt}});
+
+    verifyPartitionPaths(
+        makeRowVector(
+            {input}, {makeConstant<StringView>(StringView(input), 1)}),
+        partitionSpec,
+        {fmt::format("{}={}", encodedValue, encodedValue)});
+  }
+}
+
+TEST_F(PartitionNameTest, multipleRows) {
+  const auto& partitionSpec = createPartitionSpec(
+      ROW({"c0", "c1"}, {INTEGER(), VARCHAR()}),
+      {
+          {0, TransformType::kBucket, 8},
+          {1, TransformType::kIdentity, std::nullopt},
+      });
+
+  verifyPartitionPaths(
+      makeRowVector({
+          makeFlatVector<int32_t>({10, 20, 30, -100}),
+          makeFlatVector<std::string>({"value1", "VALue2", "VALUE3", ""}),
+      }),
+      partitionSpec,
+      {
+          "c0_bucket=4/c1=value1",
+          "c0_bucket=3/c1=VALue2",
+          "c0_bucket=3/c1=VALUE3",
+          "c0_bucket=6/c1=",
+      });
+}
+
+TEST_F(PartitionNameTest, year) {
+  const auto& partitionSpec = createPartitionSpec(
+      ROW({"c0"}, {TIMESTAMP()}), {{0, TransformType::kYear, std::nullopt}});
+
+  std::vector<Timestamp> timestamps = {
+      Timestamp(0, 0),
+      Timestamp(1609459200, 0),
+      Timestamp(1640995200, 0),
+      Timestamp(-31536000, 0),
+      Timestamp(253402300800, 0),
+  };
+
+  verifyPartitionPaths(
+      makeRowVector({makeFlatVector<Timestamp>(timestamps)}),
+      partitionSpec,
+      {
+          "c0_year=1970",
+          "c0_year=2021",
+          "c0_year=2022",
+          "c0_year=1969",
+          "c0_year=10000",
+      });
+}
+
+TEST_F(PartitionNameTest, yearWithDate) {
+  const auto& partitionSpec = createPartitionSpec(
+      ROW({"c0"}, {DATE()}), {{0, TransformType::kYear, std::nullopt}});
+
+  verifyPartitionPaths(
+      makeRowVector({makeFlatVector<int32_t>({0, 365, 18262, -365}, DATE())}),
+      partitionSpec,
+      {
+          "c0_year=1970",
+          "c0_year=1971",
+          "c0_year=2020",
+          "c0_year=1969",
+      });
+}
+
+TEST_F(PartitionNameTest, month) {
+  const auto& partitionSpec = createPartitionSpec(
+      ROW({"c0"}, {TIMESTAMP()}), {{0, TransformType::kMonth, std::nullopt}});
+
+  verifyPartitionPaths(
+      makeRowVector({makeFlatVector<Timestamp>({
+          Timestamp(0, 0),
+          Timestamp(2678400, 0),
+          Timestamp(1609459200, 0),
+          Timestamp(1640995200, 0),
+          Timestamp(-2678400, 0),
+      })}),
+      partitionSpec,
+      {
+          "c0_month=1970-01",
+          "c0_month=1970-02",
+          "c0_month=2021-01",
+          "c0_month=2022-01",
+          "c0_month=1969-12",
+      });
+}
+
+TEST_F(PartitionNameTest, monthWithDate) {
+  const auto& partitionSpec = createPartitionSpec(
+      ROW({"c0"}, {DATE()}), {{0, TransformType::kMonth, std::nullopt}});
+
+  verifyPartitionPaths(
+      makeRowVector({makeFlatVector<int32_t>({0, 31, 365, -31}, DATE())}),
+      partitionSpec,
+      {
+          "c0_month=1970-01",
+          "c0_month=1970-02",
+          "c0_month=1971-01",
+          "c0_month=1969-12",
+      });
+}
+
+TEST_F(PartitionNameTest, day) {
+  const auto& partitionSpec = createPartitionSpec(
+      ROW({"c0"}, {TIMESTAMP()}), {{0, TransformType::kDay, std::nullopt}});
+
+  std::vector<Timestamp> timestamps = {
+      Timestamp(0, 0),
+      Timestamp(86400, 0),
+      Timestamp(1577836800, 0),
+      Timestamp(-86400, 0),
+  };
+
+  verifyPartitionPaths(
+      makeRowVector({makeFlatVector<Timestamp>(timestamps)}),
+      partitionSpec,
+      {
+          "c0_day=1970-01-01",
+          "c0_day=1970-01-02",
+          "c0_day=2020-01-01",
+          "c0_day=1969-12-31",
+      });
+}
+
+TEST_F(PartitionNameTest, dayWithDate) {
+  const auto& partitionSpec = createPartitionSpec(
+      ROW({"c0"}, {DATE()}), {{0, TransformType::kDay, std::nullopt}});
+
+  verifyPartitionPaths(
+      makeRowVector({makeFlatVector<int32_t>({0, 1, 18262, -1}, DATE())}),
+      partitionSpec,
+      {
+          "c0_day=1970-01-01",
+          "c0_day=1970-01-02",
+          "c0_day=2020-01-01",
+          "c0_day=1969-12-31",
+      });
+}
+
+TEST_F(PartitionNameTest, hour) {
+  const auto& partitionSpec = createPartitionSpec(
+      ROW({"c0"}, {TIMESTAMP()}), {{0, TransformType::kHour, std::nullopt}});
+
+  std::vector<Timestamp> timestamps = {
+      Timestamp(0, 0),
+      Timestamp(3600, 0),
+      Timestamp(86400, 0),
+      Timestamp(1577836800, 0),
+      Timestamp(-3600, 0),
+  };
+
+  verifyPartitionPaths(
+      makeRowVector({makeFlatVector<Timestamp>(timestamps)}),
+      partitionSpec,
+      {
+          "c0_hour=1970-01-01-00",
+          "c0_hour=1970-01-01-01",
+          "c0_hour=1970-01-02-00",
+          "c0_hour=2020-01-01-00",
+          "c0_hour=1969-12-31-23",
+      });
+}
+
+TEST_F(PartitionNameTest, multipleTransformsSameColumn) {
+  const auto& partitionSpec = createPartitionSpec(
+      ROW({"c0"}, {TIMESTAMP()}),
+      {
+          {0, TransformType::kIdentity, std::nullopt},
+          {0, TransformType::kYear, std::nullopt},
+          {0, TransformType::kBucket, 10},
+      });
+
+  verifyPartitionPaths(
+      makeRowVector({makeFlatVector<Timestamp>({Timestamp(1609459200, 0)})}),
+      partitionSpec,
+      {"c0=2021-01-01T00%3A00%3A00/c0_year=2021/c0_bucket=0"});
+}
+
+} // namespace
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/tests/PartitionSpecTest.cpp b/velox/connectors/hive/iceberg/tests/PartitionSpecTest.cpp
new file mode 100644
index 00000000000..23a06340aad
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/PartitionSpecTest.cpp
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/PartitionSpec.h"
+
+#include <gtest/gtest.h>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+namespace {
+
+TEST(PartitionSpecTest, invalidColumnType) {
+  auto makeSpec = [](const TypePtr& type) {
+    std::vector<IcebergPartitionSpec::Field> fields = {
+        {"c0", type, TransformType::kIdentity, std::nullopt},
+    };
+    return std::make_shared<const IcebergPartitionSpec>(1, fields);
+  };
+
+  VELOX_ASSERT_USER_THROW(
+      makeSpec(ROW({{"a", INTEGER()}})),
+      "Type is not supported as a partition column: ROW");
+  VELOX_ASSERT_USER_THROW(
+      makeSpec(ARRAY(INTEGER())),
+      "Type is not supported as a partition column: ARRAY");
+  VELOX_ASSERT_USER_THROW(
+      makeSpec(MAP(VARCHAR(), INTEGER())),
+      "Type is not supported as a partition column: MAP");
+  VELOX_ASSERT_USER_THROW(
+      makeSpec(TIMESTAMP_WITH_TIME_ZONE()),
+      "Type is not supported as a partition column: TIMESTAMP WITH TIME ZONE");
+}
+
+TEST(PartitionSpecTest, invalidMultipleTransforms) {
+  {
+    std::vector<IcebergPartitionSpec::Field> fields = {
+        {"c0", VARCHAR(), TransformType::kIdentity, std::nullopt},
+        {"c0", VARCHAR(), TransformType::kIdentity, std::nullopt},
+    };
+    VELOX_ASSERT_USER_THROW(
+        std::make_shared<const IcebergPartitionSpec>(1, fields),
+        "Column: 'c0', Category: Identity, Transforms: [identity, identity]");
+  }
+
+  {
+    std::vector<IcebergPartitionSpec::Field> fields = {
+        {"c0", VARCHAR(), TransformType::kBucket, 16},
+        {"c0", VARCHAR(), TransformType::kBucket, 32},
+    };
+    VELOX_ASSERT_USER_THROW(
+        std::make_shared<const IcebergPartitionSpec>(1, fields),
+        "Column: 'c0', Category: Bucket, Transforms: [bucket, bucket]");
+  }
+
+  {
+    std::vector<IcebergPartitionSpec::Field> fields = {
+        {"c0", VARCHAR(), TransformType::kTruncate, 2},
+        {"c0", VARCHAR(), TransformType::kTruncate, 5},
+    };
+    VELOX_ASSERT_USER_THROW(
+        std::make_shared<const IcebergPartitionSpec>(1, fields),
+        "Column: 'c0', Category: Truncate, Transforms: [trunc, trunc]");
+  }
+
+  {
+    std::vector<IcebergPartitionSpec::Field> fields4 = {
+        {"c0", TIMESTAMP(), TransformType::kYear, std::nullopt},
+        {"c0", TIMESTAMP(), TransformType::kMonth, std::nullopt},
+        {"c0", TIMESTAMP(), TransformType::kDay, std::nullopt},
+        {"c0", TIMESTAMP(), TransformType::kHour, std::nullopt},
+    };
+    VELOX_ASSERT_USER_THROW(
+        std::make_shared<const IcebergPartitionSpec>(1, fields4),
+        "Column: 'c0', Category: Temporal, Transforms: [year, month, day, hour]");
+  }
+}
+
+TEST(PartitionSpecTest, invalidMultipleTransformsMultipleColumns) {
+  std::vector<IcebergPartitionSpec::Field> fields = {
+      {"c0", DATE(), TransformType::kYear, std::nullopt},
+      {"c0", DATE(), TransformType::kMonth, std::nullopt},
+      {"c1", VARCHAR(), TransformType::kBucket, 16},
+      {"c1", VARCHAR(), TransformType::kBucket, 32},
+  };
+  // order may vary due to map iteration.
+  VELOX_ASSERT_USER_THROW(
+      std::make_shared<const IcebergPartitionSpec>(1, fields),
+      "Column: 'c0', Category: Temporal, Transforms: [year, month]");
+  VELOX_ASSERT_USER_THROW(
+      std::make_shared<const IcebergPartitionSpec>(1, fields),
+      "Column: 'c1', Category: Bucket, Transforms: [bucket, bucket]");
+}
+
+TEST(PartitionSpecTest, validMultipleTransforms) {
+  {
+    std::vector<IcebergPartitionSpec::Field> fields = {
+        {"c0", VARCHAR(), TransformType::kIdentity, std::nullopt},
+        {"c0", VARCHAR(), TransformType::kBucket, 16},
+        {"c0", VARCHAR(), TransformType::kTruncate, 10},
+    };
+    auto spec = std::make_shared<const IcebergPartitionSpec>(1, fields);
+    EXPECT_EQ(spec->fields.size(), 3);
+  }
+
+  {
+    std::vector<IcebergPartitionSpec::Field> fields = {
+        {"c0", DATE(), TransformType::kYear, std::nullopt},
+        {"c0", DATE(), TransformType::kBucket, 16},
+        {"c0", DATE(), TransformType::kIdentity, std::nullopt},
+    };
+    auto spec = std::make_shared<const IcebergPartitionSpec>(1, fields);
+    EXPECT_EQ(spec->fields.size(), 3);
+  }
+}
+
+} // namespace
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/tests/PartitionValueFormatterTest.cpp b/velox/connectors/hive/iceberg/tests/PartitionValueFormatterTest.cpp
new file mode 100644
index 00000000000..13cda035cbf
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/PartitionValueFormatterTest.cpp
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "velox/connectors/hive/iceberg/IcebergPartitionName.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+namespace {
+
+template <typename T>
+std::string toPath(TransformType transform, T value, const TypePtr& type) {
+  return IcebergPartitionName::toName(value, type, transform);
+}
+
+std::string timestampToPath(const Timestamp& timestamp) {
+  return toPath(TransformType::kIdentity, timestamp, TIMESTAMP());
+}
+
+std::string testString(
+    const std::string& value,
+    const TypePtr& typePtr = VARCHAR()) {
+  auto identityResult =
+      toPath(TransformType::kIdentity, StringView(value), typePtr);
+  auto truncateResult =
+      toPath(TransformType::kTruncate, StringView(value), typePtr);
+  EXPECT_EQ(identityResult, truncateResult);
+  return identityResult;
+}
+
+std::string testVarbinary(const std::string& value) {
+  return testString(value, VARBINARY());
+}
+
+std::string testInteger(int32_t value) {
+  auto identityResult = toPath(TransformType::kIdentity, value, INTEGER());
+  auto bucketResult = toPath(TransformType::kBucket, value, INTEGER());
+  auto truncResult = toPath(TransformType::kTruncate, value, INTEGER());
+  EXPECT_EQ(identityResult, truncResult);
+  EXPECT_EQ(bucketResult, truncResult);
+  return truncResult;
+}
+
+TEST(IcebergPartitionPathTest, integer) {
+  EXPECT_EQ(testInteger(0), "0");
+  EXPECT_EQ(testInteger(1), "1");
+  EXPECT_EQ(testInteger(100), "100");
+  EXPECT_EQ(testInteger(-100), "-100");
+  EXPECT_EQ(testInteger(128), "128");
+  EXPECT_EQ(testInteger(1024), "1024");
+}
+
+TEST(IcebergPartitionPathTest, date) {
+  EXPECT_EQ(toPath(TransformType::kIdentity, 18'262, DATE()), "2020-01-01");
+  EXPECT_EQ(toPath(TransformType::kIdentity, 0, DATE()), "1970-01-01");
+  EXPECT_EQ(toPath(TransformType::kIdentity, -1, DATE()), "1969-12-31");
+  EXPECT_EQ(toPath(TransformType::kIdentity, 2'932'897, DATE()), "10000-01-01");
+}
+
+TEST(IcebergPartitionPathTest, boolean) {
+  EXPECT_EQ(toPath(TransformType::kIdentity, true, BOOLEAN()), "true");
+  EXPECT_EQ(toPath(TransformType::kIdentity, false, BOOLEAN()), "false");
+}
+
+TEST(IcebergPartitionPathTest, string) {
+  EXPECT_EQ(testString("a/b/c=d"), "a/b/c=d");
+  EXPECT_EQ(testString(""), "");
+  EXPECT_EQ(testString("abc"), "abc");
+}
+
+TEST(IcebergPartitionPathTest, varbinary) {
+  EXPECT_EQ(testVarbinary("\x48\x65\x6c\x6c\x6f"), "SGVsbG8=");
+  EXPECT_EQ(testVarbinary("\x1\x2\x3"), "AQID");
+  EXPECT_EQ(testVarbinary(""), "");
+}
+
+TEST(IcebergPartitionPathTest, timestamp) {
+  EXPECT_EQ(timestampToPath(Timestamp(0, 0)), "1970-01-01T00:00:00");
+  EXPECT_EQ(
+      timestampToPath(Timestamp(1'609'459'200, 999'000'000)),
+      "2021-01-01T00:00:00.999");
+  EXPECT_EQ(
+      timestampToPath(Timestamp(1'640'995'200, 500'000'000)),
+      "2022-01-01T00:00:00.5");
+  EXPECT_EQ(
+      timestampToPath(Timestamp(-1, 999'000'000)), "1969-12-31T23:59:59.999");
+  EXPECT_EQ(
+      timestampToPath(Timestamp(253'402'300'800, 100'000'000)),
+      "+10000-01-01T00:00:00.1");
+  EXPECT_EQ(
+      timestampToPath(Timestamp(-62'170'000'000, 0)), "-0001-11-29T19:33:20");
+  EXPECT_EQ(
+      timestampToPath(Timestamp(-62'167'219'199, 0)), "0000-01-01T00:00:01");
+}
+
+TEST(IcebergPartitionPathTest, year) {
+  EXPECT_EQ(toPath(TransformType::kYear, 0, INTEGER()), "1970");
+  EXPECT_EQ(toPath(TransformType::kYear, 1, INTEGER()), "1971");
+  EXPECT_EQ(toPath(TransformType::kYear, 8'030, INTEGER()), "10000");
+  EXPECT_EQ(toPath(TransformType::kYear, -1, INTEGER()), "1969");
+  EXPECT_EQ(toPath(TransformType::kYear, -50, INTEGER()), "1920");
+}
+
+TEST(IcebergPartitionPathTest, month) {
+  EXPECT_EQ(toPath(TransformType::kMonth, 0, INTEGER()), "1970-01");
+  EXPECT_EQ(toPath(TransformType::kMonth, 1, INTEGER()), "1970-02");
+  EXPECT_EQ(toPath(TransformType::kMonth, 11, INTEGER()), "1970-12");
+  EXPECT_EQ(toPath(TransformType::kMonth, 612, INTEGER()), "2021-01");
+  EXPECT_EQ(toPath(TransformType::kMonth, -1, INTEGER()), "1969-12");
+  EXPECT_EQ(toPath(TransformType::kMonth, -13, INTEGER()), "1968-12");
+}
+
+TEST(IcebergPartitionPathTest, day) {
+  EXPECT_EQ(toPath(TransformType::kDay, 0, DATE()), "1970-01-01");
+  EXPECT_EQ(toPath(TransformType::kDay, 1, DATE()), "1970-01-02");
+  EXPECT_EQ(toPath(TransformType::kDay, 18'262, DATE()), "2020-01-01");
+  EXPECT_EQ(toPath(TransformType::kDay, -1, DATE()), "1969-12-31");
+}
+
+TEST(IcebergPartitionPathTest, hour) {
+  EXPECT_EQ(toPath(TransformType::kHour, 0, INTEGER()), "1970-01-01-00");
+  EXPECT_EQ(toPath(TransformType::kHour, 1, INTEGER()), "1970-01-01-01");
+  EXPECT_EQ(toPath(TransformType::kHour, 24, INTEGER()), "1970-01-02-00");
+  EXPECT_EQ(toPath(TransformType::kHour, 438'288, INTEGER()), "2020-01-01-00");
+  EXPECT_EQ(toPath(TransformType::kHour, -1, INTEGER()), "1969-12-31-23");
+}
+
+} // namespace
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/tests/TransformE2ETest.cpp b/velox/connectors/hive/iceberg/tests/TransformE2ETest.cpp
new file mode 100644
index 00000000000..cd613219836
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/TransformE2ETest.cpp
@@ -0,0 +1,799 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <filesystem>
+
+#include <folly/json.h>
+
+#include "velox/common/encode/Base64.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
+#include "velox/connectors/hive/iceberg/IcebergSplit.h"
+#include "velox/connectors/hive/iceberg/tests/IcebergTestBase.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/iceberg/Murmur3Hash32.h"
+
+using namespace facebook::velox::common::testutil;
+
+namespace facebook::velox::connector::hive::iceberg {
+
+using namespace facebook::velox::exec::test;
+
+namespace {
+
+#ifdef VELOX_ENABLE_PARQUET
+
+class TransformE2ETest : public test::IcebergTestBase {
+ protected:
+  static constexpr int32_t kDefaultNumBatches = 2;
+  static constexpr int32_t kDefaultRowsPerBatch = 100;
+
+  std::vector<RowVectorPtr> createTimestampTestData() {
+    std::vector<RowVectorPtr> batches;
+    // 1. Aligned to hour boundaries (no minutes/seconds) since hour is the
+    //    finest granularity transform tested.
+    // 2. Include negative epoch values (pre-1970) to test edge cases.
+    // 3. Span multiple years and months.
+    static const std::vector<Timestamp> timestamps = {
+        // 1969-01-01 00:00:00 (negative epoch)
+        Timestamp(-31536000, 0),
+        // 1969-12-31 00:00:00 (day before epoch)
+        Timestamp(-86400, 0),
+        // 1970-01-01 00:00:00
+        Timestamp(0, 0),
+        // 1970-01-01 01:00:00
+        Timestamp(3600, 0),
+        // 1970-01-02 00:00:00
+        Timestamp(86400, 0),
+        // 1970-01-31 00:00:00
+        Timestamp(2592000, 0),
+        // 1971-01-01 00:00:00
+        Timestamp(31536000, 0),
+        // 2021-01-01 00:00:00
+        Timestamp(1609459200, 0),
+        // 2021-01-02 00:00:00
+        Timestamp(1609545600, 0),
+        // 2021-02-01 00:00:00
+        Timestamp(1612224000, 0),
+        // 2022-01-01 00:00:00
+        Timestamp(1640995200, 0),
+        // 2023-01-01 00:00:00
+        Timestamp(1672531200, 0),
+        // 2100-01-01 00:00:00
+        Timestamp(4102444800, 0),
+    };
+
+    for (auto i = 0; i < kDefaultNumBatches; i++) {
+      auto timestampVector = makeFlatVector<Timestamp>(
+          kDefaultRowsPerBatch,
+          [](auto row) { return timestamps[row % timestamps.size()]; });
+      batches.push_back(makeRowVector({timestampVector}));
+    }
+    return batches;
+  }
+
+  std::shared_ptr<TempDirectoryPath> writeBatchesWithTransforms(
+      const std::vector<RowVectorPtr>& batches,
+      const std::vector<test::PartitionField>& partitionFields) {
+    VELOX_CHECK(!batches.empty(), "input cannot be empty");
+
+    int64_t expectedRowCount = 0;
+    for (const auto& batch : batches) {
+      expectedRowCount += batch->size();
+    }
+
+    auto rowType = batches.front()->rowType();
+    auto outputDirectory = TempDirectoryPath::create();
+    const auto dataSink = createDataSinkAndAppendData(
+        batches, outputDirectory->getPath(), partitionFields);
+    dataSink->close();
+    verifyTotalRowCount(rowType, outputDirectory->getPath(), expectedRowCount);
+    return outputDirectory;
+  }
+
+  // Generate a key from a timestamp and transform type.
+  // The key format depends on the transform type:
+  // - kMonth: "YYYY-MM"
+  // - kDay: "YYYY-MM-DD"
+  // - kHour: "YYYY-MM-DD-HH"
+  static std::string timestampToKey(
+      const Timestamp& ts,
+      TransformType transformType) {
+    std::tm tm;
+    if (!Timestamp::epochToCalendarUtc(ts.getSeconds(), tm)) {
+      return "";
+    }
+
+    int32_t year = tm.tm_year + 1900;
+    int32_t month = tm.tm_mon + 1;
+    int32_t day = tm.tm_mday;
+    int32_t hour = tm.tm_hour;
+
+    switch (transformType) {
+      case TransformType::kMonth:
+        return fmt::format("{:04d}-{:02d}", year, month);
+      case TransformType::kDay:
+        return fmt::format("{:04d}-{:02d}-{:02d}", year, month, day);
+      case TransformType::kHour:
+        return fmt::format(
+            "{:04d}-{:02d}-{:02d}-{:02d}", year, month, day, hour);
+      default:
+        VELOX_UNREACHABLE();
+    }
+  }
+
+  // Helper function to build expected counts map from timestamp batches.
+  // The key format depends on the transform type:
+  // - kMonth: "YYYY-MM"
+  // - kDay: "YYYY-MM-DD"
+  // - kHour: "YYYY-MM-DD-HH"
+  static std::unordered_map<std::string, int32_t>
+  buildExpectedCountsFromTimestamps(
+      const std::vector<RowVectorPtr>& batches,
+      TransformType transformType) {
+    std::unordered_map<std::string, int32_t> expectedCounts;
+
+    for (const auto& batch : batches) {
+      auto timestampVector = batch->childAt(0)->as<SimpleVector<Timestamp>>();
+      for (auto i = 0; i < batch->size(); i++) {
+        Timestamp ts = timestampVector->valueAt(i);
+        std::string key = timestampToKey(ts, transformType);
+        expectedCounts[key]++;
+      }
+    }
+    return expectedCounts;
+  }
+
+  static std::string dirName(const std::string& path) {
+    return std::filesystem::path(path).filename().string();
+  }
+
+  static std::vector<std::string> firstLevelDirectories(
+      const std::string& basePath) {
+    std::vector<std::string> directories;
+    for (const auto& entry : std::filesystem::directory_iterator(basePath)) {
+      if (entry.is_directory()) {
+        directories.push_back(entry.path().string());
+      }
+    }
+    return directories;
+  }
+
+  static std::vector<std::string> listDirectoriesRecursively(
+      const std::string& path) {
+    std::vector<std::string> directories;
+    auto firstLevelDirs = firstLevelDirectories(path);
+
+    for (const auto& dir : firstLevelDirs) {
+      directories.push_back(dirName(dir));
+      auto subDirs = listDirectoriesRecursively(dir);
+      directories.insert(directories.end(), subDirs.begin(), subDirs.end());
+    }
+
+    return directories;
+  }
+
+  static std::vector<std::string> verifyPartitionCount(
+      const std::string& outputPath,
+      int32_t expectedCount) {
+    const auto partitionDirs = firstLevelDirectories(outputPath);
+    EXPECT_EQ(partitionDirs.size(), expectedCount);
+    for (const auto& dir : partitionDirs) {
+      const auto name = dirName(dir);
+      EXPECT_TRUE(name.find('=') != std::string::npos)
+          << "Partition directory " << name
+          << " does not follow Iceberg naming convention";
+    }
+    return partitionDirs;
+  }
+
+  // Verify the total row count across all partitions.
+  void verifyTotalRowCount(
+      const RowTypePtr& rowType,
+      const std::string& outputPath,
+      int32_t expectedRowCount) {
+    auto splits = createSplitsForDirectory(outputPath);
+
+    const auto plan = PlanBuilder()
+                          .startTableScan()
+                          .connectorId(test::kIcebergConnectorId)
+                          .outputType(rowType)
+                          .endTableScan()
+                          .planNode();
+
+    const auto actualRowCount =
+        AssertQueryBuilder(plan).splits(splits).countResults();
+
+    ASSERT_EQ(actualRowCount, expectedRowCount);
+  }
+
+  // Verify data in a specific partition.
+  void verifyPartitionData(
+      const RowTypePtr& rowType,
+      const std::string& partitionPath,
+      const std::string& partitionFilter,
+      const int32_t expectedRowCount) {
+    auto scanPlan = PlanBuilder()
+                        .startTableScan()
+                        .connectorId(test::kIcebergConnectorId)
+                        .outputType(rowType)
+                        .endTableScan()
+                        .planNode();
+
+    const auto actualRowCount =
+        AssertQueryBuilder(scanPlan)
+            .splits(createSplitsForDirectory(partitionPath))
+            .countResults();
+
+    ASSERT_EQ(actualRowCount, expectedRowCount);
+
+    const auto filterPlan = PlanBuilder()
+                                .startTableScan()
+                                .connectorId(test::kIcebergConnectorId)
+                                .outputType(rowType)
+                                .endTableScan()
+                                .filter(partitionFilter)
+                                .planNode();
+    const auto filteredRowCount =
+        AssertQueryBuilder(filterPlan)
+            .splits(createSplitsForDirectory(partitionPath))
+            .countResults();
+    ASSERT_EQ(expectedRowCount, filteredRowCount);
+  }
+
+  static std::pair<std::string, std::string> parsePartitionDirName(
+      const std::string& name) {
+    auto eq = name.find('=');
+    VELOX_CHECK(eq != std::string::npos);
+    auto us = name.rfind('_', eq - 1);
+    auto columnName = name.substr(0, us);
+    auto value = name.substr(eq + 1);
+    return {columnName, value};
+  }
+
+  static int32_t computeBucketHash(
+      const StringView& value,
+      int32_t numBuckets) {
+    int32_t hash = functions::iceberg::Murmur3Hash32::hashBytes(
+        value.data(), value.size());
+    return ((hash & 0x7FFFFFFF) % numBuckets);
+  }
+
+  folly::dynamic getPartitionValuesFromCommitMessage(
+      const RowVectorPtr& rowVector) {
+    auto outputDirectory = TempDirectoryPath::create();
+    std::vector<test::PartitionField> partitionTransforms = {
+        {0, TransformType::kIdentity, std::nullopt},
+    };
+    const auto dataSink = createDataSinkAndAppendData(
+        {rowVector}, outputDirectory->getPath(), partitionTransforms);
+
+    dataSink->close();
+    auto commitMessages = dataSink->commitMessage();
+    VELOX_CHECK_EQ(commitMessages.size(), 1);
+    auto commitData = folly::parseJson(commitMessages[0]);
+    auto partitionDataJson =
+        folly::parseJson(commitData["partitionDataJson"].asString());
+    auto partitionValues = partitionDataJson["partitionValues"];
+    VELOX_CHECK_EQ(partitionValues.size(), 1);
+    return partitionValues[0];
+  }
+};
+
+TEST_F(TransformE2ETest, identity) {
+  constexpr auto rowsPerBatch = 10;
+  constexpr auto duplicates = 5;
+  auto rowType = ROW({"c0"}, {INTEGER()});
+  auto baseVectors = createTestData(rowType, kDefaultNumBatches, rowsPerBatch);
+
+  // Duplicate each row to create multiple rows with the same partition key.
+  std::vector<RowVectorPtr> vectors;
+  for (const auto& baseVector : baseVectors) {
+    auto duplicatedColumn = wrapInDictionary(
+        makeIndices(
+            baseVector->size() * duplicates,
+            [duplicates](auto row) { return row / duplicates; }),
+        baseVector->size() * duplicates,
+        baseVector->childAt(0));
+    vectors.push_back(makeRowVector({duplicatedColumn}));
+  }
+
+  auto outputDirectory = writeBatchesWithTransforms(
+      vectors, {{0, TransformType::kIdentity, std::nullopt}});
+
+  auto partitionDirs = verifyPartitionCount(
+      outputDirectory->getPath(), kDefaultNumBatches * rowsPerBatch);
+
+  for (const auto& dir : partitionDirs) {
+    const auto name = dirName(dir);
+    // Each partition should have duplicates rows.
+    verifyPartitionData(rowType, dir, name, duplicates);
+  }
+}
+
+TEST_F(TransformE2ETest, partitionNamingConventions) {
+  auto rowVector = makeRowVector(
+      {
+          "c_int",
+          "c_bigint",
+          "c_varchar",
+          "c_varchar2",
+          "c_decimal",
+          "c_varbinary",
+      },
+      {
+          makeConstant(42, 1, INTEGER()),
+          makeConstant(static_cast<int64_t>(9'876'543'210), 1, BIGINT()),
+          makeConstant("test string", 1, VARCHAR()),
+          makeNullConstant(TypeKind::VARCHAR, 1),
+          makeConstant(static_cast<int64_t>(1'234'567'890), 1, DECIMAL(18, 3)),
+          makeConstant("binarydata\1\2\3", 1, VARBINARY()),
+      });
+
+  std::vector<test::PartitionField> partitionTransforms = {
+      {0, TransformType::kIdentity, std::nullopt}, // c_int.
+      {1, TransformType::kIdentity, std::nullopt}, // c_bigint.
+      {2, TransformType::kIdentity, std::nullopt}, // c_varchar.
+      {4, TransformType::kIdentity, std::nullopt}, // c_decimal.
+      {5, TransformType::kIdentity, std::nullopt}, // c_varbinary.
+      {3, TransformType::kIdentity, std::nullopt}, // c_varchar2.
+  };
+
+  auto outputDirectory =
+      writeBatchesWithTransforms({rowVector}, partitionTransforms);
+
+  const auto actualPartitionNames =
+      listDirectoriesRecursively(outputDirectory->getPath());
+
+  // Build expected partition folder names.
+  std::vector<std::string> expectedPartitionNames = {
+      "c_int=42",
+      "c_bigint=9876543210",
+      "c_varchar=test+string",
+      "c_decimal=1234567.890",
+      "c_varbinary=YmluYXJ5ZGF0YQECAw%3D%3D",
+      "c_varchar2=null",
+  };
+
+  ASSERT_EQ(actualPartitionNames, expectedPartitionNames)
+      << "Partition folder names do not match expected values";
+}
+
+TEST_F(TransformE2ETest, varbinaryPartitionCommitMessage) {
+  std::vector<std::string> testData = {
+      "binarydata\x01\x02\x03",
+      "",
+      ".-_*/?%#&=+,;@!$\\\"'()<>:|[]{}^~`\n\r\t\u00A9",
+  };
+
+  for (const auto& binaryData : testData) {
+    SCOPED_TRACE(testing::Message() << "binaryData: " << binaryData);
+    auto rowVector = makeRowVector({
+        makeConstant(binaryData, 1, VARBINARY()),
+    });
+
+    auto partitionValue = getPartitionValuesFromCommitMessage(rowVector);
+    ASSERT_EQ(
+        partitionValue.asString(),
+        encoding::Base64::encode(binaryData.data(), binaryData.size()));
+  }
+}
+
+TEST_F(TransformE2ETest, nullPartitionValue) {
+  const std::vector<TypeKind> typeKinds = {
+      TypeKind::BOOLEAN,
+      TypeKind::INTEGER,
+      TypeKind::BIGINT,
+      TypeKind::VARCHAR,
+      TypeKind::VARBINARY,
+      TypeKind::TIMESTAMP,
+  };
+
+  for (const auto& typeKind : typeKinds) {
+    auto rowVector = makeRowVector({
+        makeNullConstant(typeKind, 1),
+    });
+
+    auto partitionValue = getPartitionValuesFromCommitMessage(rowVector);
+    ASSERT_TRUE(partitionValue.isNull());
+  }
+}
+
+TEST_F(TransformE2ETest, bucket) {
+  constexpr int32_t numBuckets = 4;
+  auto rowType = ROW({"c_varchar"}, {VARCHAR()});
+  auto vectors =
+      createTestData(rowType, kDefaultNumBatches, kDefaultRowsPerBatch);
+
+  auto outputDirectory = writeBatchesWithTransforms(
+      vectors, {{0, TransformType::kBucket, numBuckets}});
+
+  const auto partitionDirs =
+      verifyPartitionCount(outputDirectory->getPath(), numBuckets);
+
+  int32_t totalRows = 0;
+  for (const auto& dir : partitionDirs) {
+    auto splits = createSplitsForDirectory(dir);
+    auto countPlan = PlanBuilder()
+                         .startTableScan()
+                         .connectorId(test::kIcebergConnectorId)
+                         .outputType(rowType)
+                         .endTableScan()
+                         .planNode();
+    auto partitionRowCount =
+        AssertQueryBuilder(countPlan).splits(splits).countResults();
+
+    totalRows += partitionRowCount;
+    ASSERT_GT(partitionRowCount, 0);
+  }
+
+  ASSERT_EQ(totalRows, kDefaultNumBatches * kDefaultRowsPerBatch);
+
+  std::unordered_map<std::string, int32_t> valueToExpectedBucket;
+
+  for (const auto& dir : partitionDirs) {
+    const auto name = dirName(dir);
+    const auto [k, v] = parsePartitionDirName(name);
+    const int32_t expectedBucket = std::stoi(v);
+
+    auto dataPlan = PlanBuilder()
+                        .startTableScan()
+                        .connectorId(test::kIcebergConnectorId)
+                        .outputType(rowType)
+                        .endTableScan()
+                        .project({"c_varchar"})
+                        .planNode();
+    const auto& dataResult = AssertQueryBuilder(dataPlan)
+                                 .splits(createSplitsForDirectory(dir))
+                                 .copyResults(opPool_.get());
+
+    auto varcharColumn = dataResult->childAt(0)->asFlatVector<StringView>();
+    for (auto i = 0; i < dataResult->size(); i++) {
+      auto value = varcharColumn->valueAt(i);
+
+      auto computedBucket = computeBucketHash(value, numBuckets);
+      ASSERT_EQ(computedBucket, expectedBucket);
+    }
+  }
+}
+
+TEST_F(TransformE2ETest, truncate) {
+  auto rowType = ROW({"c_int"}, {INTEGER()});
+
+  std::vector<RowVectorPtr> batches;
+  for (auto i = 0; i < kDefaultNumBatches; i++) {
+    std::vector<VectorPtr> columns;
+    columns.push_back(
+        makeFlatVector<int32_t>(50, [](auto row) { return row % 100; }));
+    auto vectors = makeRowVector(rowType->names(), columns);
+    batches.push_back(vectors);
+  }
+
+  auto outputDirectory =
+      writeBatchesWithTransforms(batches, {{0, TransformType::kTruncate, 10}});
+
+  auto partitionDirs = verifyPartitionCount(outputDirectory->getPath(), 5);
+
+  for (const auto& dir : partitionDirs) {
+    const std::string name = dirName(dir);
+    auto [c, v] = parsePartitionDirName(name);
+    const std::string filter = fmt::format(
+        "{}>={} AND {}<{}", c, v, c, std::to_string(std::stoi(v) + 10));
+
+    verifyPartitionData(
+        rowType, dir, filter, 20); // 10 values per batch * 2 batches.
+  }
+}
+
+TEST_F(TransformE2ETest, year) {
+  auto rowType = ROW({"c_date"}, {DATE()});
+  static const std::vector<int32_t> dates = {
+      18'262, 18'628, 18'993, 19'358, 19'723, 20'181};
+  std::vector<RowVectorPtr> batches;
+  for (auto i = 0; i < kDefaultNumBatches; i++) {
+    auto dateVector = makeFlatVector<int32_t>(
+        kDefaultRowsPerBatch,
+        [](auto row) { return dates[row % dates.size()]; },
+        nullptr,
+        DATE());
+    batches.emplace_back(makeRowVector(rowType->names(), {dateVector}));
+  }
+
+  auto outputDirectory = writeBatchesWithTransforms(
+      batches, {{0, TransformType::kYear, std::nullopt}});
+
+  auto partitionDirs = verifyPartitionCount(outputDirectory->getPath(), 6);
+
+  for (int32_t year = 2020; year <= 2025; year++) {
+    const auto expectedDirName = fmt::format("c_date_year={}", year);
+    bool foundPartition = false;
+    auto yearFilter = [](int32_t year) -> std::string {
+      return fmt::format("YEAR(DATE '{}-01-01')={}", year, year);
+    };
+
+    for (const auto& dir : partitionDirs) {
+      SCOPED_TRACE(year);
+      const auto name = dirName(dir);
+      if (name == expectedDirName) {
+        foundPartition = true;
+        auto datePlan = PlanBuilder()
+                            .startTableScan()
+                            .connectorId(test::kIcebergConnectorId)
+                            .outputType(rowType)
+                            .endTableScan()
+                            .filter(yearFilter(year))
+                            .planNode();
+
+        auto partitionRowCount = AssertQueryBuilder(datePlan)
+                                     .splits(createSplitsForDirectory(dir))
+                                     .countResults();
+
+        auto countPlan = PlanBuilder()
+                             .startTableScan()
+                             .connectorId(test::kIcebergConnectorId)
+                             .outputType(rowType)
+                             .endTableScan()
+                             .planNode();
+        auto totalPartitionCount = AssertQueryBuilder(countPlan)
+                                       .splits(createSplitsForDirectory(dir))
+                                       .countResults();
+        ASSERT_EQ(partitionRowCount, totalPartitionCount);
+        break;
+      }
+    }
+    ASSERT_TRUE(foundPartition);
+  }
+}
+
+TEST_F(TransformE2ETest, month) {
+  auto batches = createTimestampTestData();
+
+  auto outputDirectory = writeBatchesWithTransforms(
+      batches, {{0, TransformType::kMonth, std::nullopt}});
+
+  auto expectedCounts =
+      buildExpectedCountsFromTimestamps(batches, TransformType::kMonth);
+  const auto partitionDirs = firstLevelDirectories(outputDirectory->getPath());
+
+  for (const auto& dir : partitionDirs) {
+    const auto name = dirName(dir);
+    auto [c, v] = parsePartitionDirName(name);
+    size_t dashPos = v.find('-');
+    ASSERT_NE(dashPos, std::string::npos) << "Invalid month format: " << v;
+
+    int32_t year = std::stoi(v.substr(0, dashPos));
+    int32_t month = std::stoi(v.substr(dashPos + 1));
+    std::string filter =
+        fmt::format("YEAR(c0) = {} AND MONTH(c0) = {}", year, month);
+    std::string monthKey = fmt::format("{:04d}-{:02d}", year, month);
+    verifyPartitionData(
+        ROW({"c0"}, {TIMESTAMP()}), dir, filter, expectedCounts[monthKey]);
+  }
+}
+
+TEST_F(TransformE2ETest, day) {
+  auto batches = createTimestampTestData();
+
+  auto outputDirectory = writeBatchesWithTransforms(
+      batches, {{0, TransformType::kDay, std::nullopt}});
+
+  auto expectedCounts =
+      buildExpectedCountsFromTimestamps(batches, TransformType::kDay);
+  const auto partitionDirs = firstLevelDirectories(outputDirectory->getPath());
+
+  for (const auto& dir : partitionDirs) {
+    const auto name = dirName(dir);
+    auto [c, v] = parsePartitionDirName(name);
+    std::vector<std::string> dateParts;
+    folly::split('-', v, dateParts);
+    ASSERT_EQ(dateParts.size(), 3) << "Invalid day format: " << v;
+
+    int32_t year = std::stoi(dateParts[0]);
+    int32_t month = std::stoi(dateParts[1]);
+    int32_t day = std::stoi(dateParts[2]);
+
+    std::string filter = fmt::format(
+        "YEAR(c0) = {} AND MONTH(c0) = {} AND DAY(c0) = {}", year, month, day);
+    std::string dayKey = fmt::format("{:04d}-{:02d}-{:02d}", year, month, day);
+    verifyPartitionData(
+        ROW({"c0"}, {TIMESTAMP()}), dir, filter, expectedCounts[dayKey]);
+  }
+}
+
+TEST_F(TransformE2ETest, hour) {
+  auto batches = createTimestampTestData();
+
+  auto outputDirectory = writeBatchesWithTransforms(
+      batches, {{0, TransformType::kHour, std::nullopt}});
+
+  auto expectedCounts =
+      buildExpectedCountsFromTimestamps(batches, TransformType::kHour);
+  const auto partitionDirs = firstLevelDirectories(outputDirectory->getPath());
+
+  for (const auto& dir : partitionDirs) {
+    const auto name = dirName(dir);
+    auto [c, v] = parsePartitionDirName(name);
+    std::vector<std::string> dateParts;
+    folly::split('-', v, dateParts);
+    ASSERT_EQ(dateParts.size(), 4) << "Invalid hour format: " << v;
+
+    int32_t year = std::stoi(dateParts[0]);
+    int32_t month = std::stoi(dateParts[1]);
+    int32_t day = std::stoi(dateParts[2]);
+    int32_t hour = std::stoi(dateParts[3]);
+
+    std::string filter = fmt::format(
+        "YEAR(c0) = {} AND MONTH(c0) = {} AND "
+        "DAY(c0) = {} AND HOUR(c0) = {}",
+        year,
+        month,
+        day,
+        hour);
+    std::string hourKey =
+        fmt::format("{:04d}-{:02d}-{:02d}-{:02d}", year, month, day, hour);
+    verifyPartitionData(
+        ROW({"c0"}, {TIMESTAMP()}), dir, filter, expectedCounts[hourKey]);
+  }
+}
+
+TEST_F(TransformE2ETest, multipleTransformsOnSameColumn) {
+  auto rowType = ROW(
+      {
+          "c_int",
+          "c_bigint",
+      },
+      {
+          INTEGER(),
+          BIGINT(),
+      });
+
+  auto vectors = createTestData(rowType, 2, 20);
+  auto outputDirectory = writeBatchesWithTransforms(
+      vectors,
+      {
+          {0, TransformType::kIdentity, std::nullopt}, // c_int.
+          {0, TransformType::kTruncate, 10}, // truncate(c_int, 10).
+          {0, TransformType::kBucket, 4}, // bucket(c_int, 4).
+      });
+
+  auto firstLevelDirs = firstLevelDirectories(outputDirectory->getPath());
+  ASSERT_GT(firstLevelDirs.size(), 0);
+  for (const auto& dir : firstLevelDirs) {
+    const auto name = dirName(dir);
+    ASSERT_TRUE(name.find("c_int=") != std::string::npos)
+        << "First level directory " << name << " should use identity transform";
+
+    auto secondLevelDirs = firstLevelDirectories(dir);
+    ASSERT_GT(secondLevelDirs.size(), 0)
+        << "No second level directories found in " << dir;
+
+    for (const auto& secondDir : secondLevelDirs) {
+      const auto secondName = dirName(secondDir);
+      ASSERT_TRUE(secondName.find("c_int_trunc=") != std::string::npos)
+          << "Second level directory " << secondName
+          << " should use truncate transform";
+
+      auto thirdLevelDirs = firstLevelDirectories(secondDir);
+      ASSERT_GT(thirdLevelDirs.size(), 0)
+          << "No third level directories found in " << secondDir;
+
+      for (const auto& thirdDir : thirdLevelDirs) {
+        const auto thirdName = dirName(thirdDir);
+        ASSERT_TRUE(thirdName.find("c_int_bucket=") != std::string::npos)
+            << "Third level directory " << thirdName
+            << " should use bucket transform";
+
+        // Verify the partition has data.
+        auto splits = createSplitsForDirectory(thirdDir);
+        auto countPlan = PlanBuilder()
+                             .startTableScan()
+                             .connectorId(test::kIcebergConnectorId)
+                             .outputType(rowType)
+                             .endTableScan()
+                             .planNode();
+        auto rowCount =
+            AssertQueryBuilder(countPlan).splits(splits).countResults();
+        ASSERT_GT(rowCount, 0)
+            << "Leaf partition directory " << thirdDir << " has no data";
+      }
+    }
+  }
+}
+
+TEST_F(TransformE2ETest, dateIdentityPartitionWithFilter) {
+  auto rowType = ROW({"c_date", "c_value"}, {DATE(), INTEGER()});
+
+  static const std::vector<int32_t> dates = {20147, 19816};
+  std::vector<RowVectorPtr> batches;
+  for (auto i = 0; i < kDefaultNumBatches; i++) {
+    batches.emplace_back(makeRowVector(
+        rowType->names(),
+        {makeFlatVector<int32_t>(
+             kDefaultRowsPerBatch,
+             [](auto row) { return dates[row % dates.size()]; },
+             nullptr,
+             DATE()),
+         makeFlatVector<int32_t>(
+             kDefaultRowsPerBatch, [](auto row) { return row; })}));
+  }
+
+  auto outputDirectory = writeBatchesWithTransforms(
+      batches, {{0, TransformType::kIdentity, std::nullopt}});
+
+  auto partitionDirs = verifyPartitionCount(outputDirectory->getPath(), 2);
+
+  std::vector<std::shared_ptr<ConnectorSplit>> splits;
+
+  for (const auto& dir : partitionDirs) {
+    const auto daysSinceEpoch =
+        dirName(dir) == "c_date=2025-02-28" ? "20147" : "19816";
+
+    for (const auto& filePath : listFiles(dir)) {
+      const auto file = filesystems::getFileSystem(filePath, nullptr)
+                            ->openFileForRead(filePath);
+      splits.push_back(
+          std::make_shared<HiveIcebergSplit>(
+              test::kIcebergConnectorId,
+              filePath,
+              fileFormat_,
+              0,
+              file->size(),
+              std::unordered_map<std::string, std::optional<std::string>>{
+                  {"c_date", daysSinceEpoch}},
+              std::nullopt,
+              std::unordered_map<std::string, std::string>{},
+              nullptr,
+              /*cacheable=*/true,
+              std::vector<IcebergDeleteFile>()));
+    }
+  }
+
+  ColumnHandleMap assignments{
+      {"c_date",
+       std::make_shared<IcebergColumnHandle>(
+           "c_date",
+           FileColumnHandle::ColumnType::kPartitionKey,
+           DATE(),
+           parquet::ParquetFieldId{0, {}},
+           std::vector<common::Subfield>{})},
+      {"c_value",
+       std::make_shared<IcebergColumnHandle>(
+           "c_value",
+           FileColumnHandle::ColumnType::kRegular,
+           INTEGER(),
+           parquet::ParquetFieldId{1, {}})},
+  };
+
+  auto filterPlan = PlanBuilder()
+                        .startTableScan()
+                        .connectorId(test::kIcebergConnectorId)
+                        .outputType(rowType)
+                        .assignments(assignments)
+                        .remainingFilter("c_date = DATE '2025-02-28'")
+                        .endTableScan()
+                        .planNode();
+
+  const auto filteredRowCount =
+      AssertQueryBuilder(filterPlan).splits(splits).countResults();
+
+  ASSERT_EQ(filteredRowCount, kDefaultRowsPerBatch);
+}
+#endif
+
+} // namespace
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/tests/TransformTest.cpp b/velox/connectors/hive/iceberg/tests/TransformTest.cpp
new file mode 100644
index 00000000000..05660e6cf8c
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/TransformTest.cpp
@@ -0,0 +1,332 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/encode/Base64.h"
+#include "velox/connectors/hive/iceberg/IcebergConfig.h"
+#include "velox/connectors/hive/iceberg/PartitionSpec.h"
+#include "velox/connectors/hive/iceberg/TransformEvaluator.h"
+#include "velox/connectors/hive/iceberg/TransformExprBuilder.h"
+#include "velox/connectors/hive/iceberg/tests/IcebergTestBase.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+namespace {
+
+class TransformTest : public test::IcebergTestBase {
+ protected:
+  void testTransform(
+      const IcebergPartitionSpecPtr& spec,
+      const RowVectorPtr& input,
+      const RowVectorPtr& expected) const {
+    std::vector<column_index_t> partitionChannels;
+    for (const auto& field : spec->fields) {
+      partitionChannels.push_back(input->rowType()->getChildIdx(field.name));
+    }
+    // Build and evaluate transform expressions.
+    auto transformExprs = TransformExprBuilder::toExpressions(
+        spec,
+        partitionChannels,
+        input->rowType(),
+        std::string(IcebergConfig::kDefaultFunctionPrefix));
+    auto transformEvaluator = std::make_unique<TransformEvaluator>(
+        transformExprs, connectorQueryCtx_.get());
+    auto result = transformEvaluator->evaluate(input);
+
+    ASSERT_EQ(result.size(), expected->childrenSize());
+    for (auto i = 0; i < result.size(); ++i) {
+      velox::test::assertEqualVectors(expected->childAt(i), result[i]);
+    }
+  }
+};
+
+TEST_F(TransformTest, identity) {
+  const auto& rowType =
+      ROW({"c0", "c1", "c2", "c3", "c4"},
+          {INTEGER(), BIGINT(), VARCHAR(), VARBINARY(), TIMESTAMP()});
+  const auto& partitionSpec = createPartitionSpec(
+      rowType,
+      {
+          {0, TransformType::kIdentity, std::nullopt},
+          {1, TransformType::kIdentity, std::nullopt},
+          {2, TransformType::kIdentity, std::nullopt},
+          {3, TransformType::kIdentity, std::nullopt},
+          {4, TransformType::kIdentity, std::nullopt},
+      });
+
+  const std::vector<VectorPtr> input = {
+      makeFlatVector<int32_t>({1, -1}),
+      makeFlatVector<int64_t>({1L, -1L}),
+      makeFlatVector<std::string>({("test data"), ("")}),
+      makeFlatVector<std::string>({("\x01\x02\x03"), ("")}, VARBINARY()),
+      makeFlatVector<Timestamp>({Timestamp(0, 0), Timestamp(1609459200, 0)}),
+  };
+
+  testTransform(partitionSpec, makeRowVector(input), makeRowVector(input));
+}
+
+TEST_F(TransformTest, nulls) {
+  const auto& rowType =
+      ROW({"c0", "c1", "c2", "c3", "c4", "c5", "c6"},
+          {INTEGER(),
+           VARCHAR(),
+           VARBINARY(),
+           DATE(),
+           TIMESTAMP(),
+           TIMESTAMP(),
+           TIMESTAMP()});
+  const auto& partitionSpec = createPartitionSpec(
+      rowType,
+      {
+          {0, TransformType::kIdentity, std::nullopt},
+          {1, TransformType::kBucket, 8},
+          {2, TransformType::kTruncate, 16},
+          {3, TransformType::kYear, std::nullopt},
+          {4, TransformType::kMonth, std::nullopt},
+          {5, TransformType::kDay, std::nullopt},
+          {6, TransformType::kHour, std::nullopt},
+      });
+  testTransform(
+      partitionSpec,
+      makeRowVector({
+          makeNullableFlatVector<int32_t>({std::nullopt}),
+          makeNullableFlatVector<std::string>({std::nullopt}),
+          makeNullableFlatVector<std::string>({std::nullopt}, VARBINARY()),
+          makeNullableFlatVector<int32_t>({std::nullopt}, DATE()),
+          makeNullableFlatVector<Timestamp>({std::nullopt}),
+          makeNullableFlatVector<Timestamp>({std::nullopt}),
+          makeNullableFlatVector<Timestamp>({std::nullopt}),
+      }),
+      makeRowVector({
+          makeNullableFlatVector<int32_t>({std::nullopt}),
+          makeNullableFlatVector<int32_t>({std::nullopt}),
+          makeNullableFlatVector<std::string>({std::nullopt}, VARBINARY()),
+          makeNullableFlatVector<int32_t>({std::nullopt}),
+          makeNullableFlatVector<int32_t>({std::nullopt}),
+          makeNullableFlatVector<int32_t>({std::nullopt}, DATE()),
+          makeNullableFlatVector<int32_t>({std::nullopt}),
+      }));
+}
+
+TEST_F(TransformTest, bucket) {
+  const auto& rowType =
+      ROW({"c0", "c1", "c2", "c3", "c4", "c5"},
+          {INTEGER(), BIGINT(), VARCHAR(), VARBINARY(), DATE(), TIMESTAMP()});
+  const auto& partitionSpec = createPartitionSpec(
+      rowType,
+      {
+          {0, TransformType::kBucket, 4},
+          {1, TransformType::kBucket, 8},
+          {2, TransformType::kBucket, 16},
+          {3, TransformType::kBucket, 32},
+          {4, TransformType::kBucket, 10},
+          {5, TransformType::kBucket, 8},
+      });
+
+  testTransform(
+      partitionSpec,
+      makeRowVector({
+          makeFlatVector<int32_t>({8, 34, 0}),
+          makeFlatVector<int64_t>({34L, 0L, -34L}),
+          makeFlatVector<std::string>({"abcdefg", "测试", ""}),
+          makeFlatVector<std::string>(
+              {"\x61\x62\x64\x00\x00", "\x01\x02\x03\x04", "\x00"},
+              VARBINARY()),
+          makeFlatVector<int32_t>({0, 365, 18'262}),
+          makeFlatVector<Timestamp>(
+              {Timestamp(0, 0),
+               Timestamp(-31536000, 0),
+               Timestamp(1612224000, 0)}),
+      }),
+      makeRowVector({
+          makeFlatVector<int32_t>({3, 3, 0}),
+          makeFlatVector<int32_t>({3, 4, 5}),
+          makeFlatVector<int32_t>({6, 8, 0}),
+          makeFlatVector<int32_t>({26, 5, 0}),
+          makeFlatVector<int32_t>({6, 1, 3}),
+          makeFlatVector<int32_t>({4, 3, 5}),
+      }));
+}
+
+TEST_F(TransformTest, year) {
+  const auto& rowType = ROW({"c0", "c1"}, {DATE(), TIMESTAMP()});
+  const auto& partitionSpec = createPartitionSpec(
+      rowType,
+      {
+          {0, TransformType::kYear, std::nullopt},
+          {1, TransformType::kYear, std::nullopt},
+      });
+
+  testTransform(
+      partitionSpec,
+      makeRowVector({
+          makeFlatVector<int32_t>({0, 18'262, -365}),
+          makeFlatVector<Timestamp>(
+              {Timestamp(0, 0),
+               Timestamp(31536000, 0),
+               Timestamp(-31536000, 0)}),
+      }),
+      makeRowVector({
+          makeFlatVector<int32_t>({0, 50, -1}),
+          makeFlatVector<int32_t>({0, 1, -1}),
+      }));
+}
+
+TEST_F(TransformTest, month) {
+  const auto& rowType = ROW({"c0", "c1"}, {DATE(), TIMESTAMP()});
+  const auto& partitionSpec = createPartitionSpec(
+      rowType,
+      {
+          {0, TransformType::kMonth, std::nullopt},
+          {1, TransformType::kMonth, std::nullopt},
+      });
+
+  testTransform(
+      partitionSpec,
+      makeRowVector({
+          makeFlatVector<int32_t>({0, 18'262, -365}),
+          makeFlatVector<Timestamp>(
+              {Timestamp(0, 0),
+               Timestamp(31536000, 0),
+               Timestamp(-2678400, 0)}),
+      }),
+      makeRowVector({
+          makeFlatVector<int32_t>({0, 600, -12}),
+          makeFlatVector<int32_t>({0, 12, -1}),
+      }));
+}
+
+TEST_F(TransformTest, day) {
+  const auto& rowType = ROW({"c0", "c1"}, {DATE(), TIMESTAMP()});
+  const auto& partitionSpec = createPartitionSpec(
+      rowType,
+      {
+          {0, TransformType::kDay, std::nullopt},
+          {1, TransformType::kDay, std::nullopt},
+      });
+
+  testTransform(
+      partitionSpec,
+      makeRowVector({
+          makeFlatVector<int32_t>({0, 17532, -1}, DATE()),
+          makeFlatVector<Timestamp>(
+              {Timestamp(0, 0),
+               Timestamp(1514764800, 0),
+               Timestamp(-86400, 0)}),
+      }),
+      makeRowVector({
+          makeFlatVector<int32_t>({0, 17532, -1}, DATE()),
+          makeFlatVector<int32_t>({0, 17532, -1}, DATE()),
+      }));
+}
+
+TEST_F(TransformTest, hour) {
+  const auto& partitionSpec = createPartitionSpec(
+      ROW({"c0"}, {TIMESTAMP()}), {{0, TransformType::kHour, std::nullopt}});
+
+  testTransform(
+      partitionSpec,
+      makeRowVector({makeFlatVector<Timestamp>({
+          Timestamp(0, 0),
+          Timestamp(3600, 0),
+          Timestamp(-3600, 0),
+      })}),
+      makeRowVector({makeFlatVector<int32_t>({0, 1, -1})}));
+}
+
+TEST_F(TransformTest, truncate) {
+  const auto& rowType = ROW(
+      {"c0", "c1", "c2", "c3"}, {INTEGER(), BIGINT(), VARCHAR(), VARBINARY()});
+  const auto& partitionSpec = createPartitionSpec(
+      rowType,
+      {
+          {0, TransformType::kTruncate, 10},
+          {1, TransformType::kTruncate, 100},
+          {2, TransformType::kTruncate, 5},
+          {3, TransformType::kTruncate, 3},
+      });
+
+  testTransform(
+      partitionSpec,
+      makeRowVector({
+          makeFlatVector<int32_t>({11, -11, 5}),
+          makeFlatVector<int64_t>({123L, -123L, 50L}),
+          makeFlatVector<std::string>({"abcdefg", "测试data", "x"}),
+          makeFlatVector<std::string>(
+              {"abcdefg", "\x01\x02\x03\x04", "\x05"}, VARBINARY()),
+      }),
+      makeRowVector({
+          makeFlatVector<int32_t>({10, -20, 0}),
+          makeFlatVector<int64_t>({100L, -200L, 0L}),
+          makeFlatVector<std::string>({"abcde", "测试dat", "x"}),
+          makeFlatVector<std::string>(
+              {"abc", "\x01\x02\x03", "\x05"}, VARBINARY()),
+      }));
+}
+
+TEST_F(TransformTest, multipleTransforms) {
+  const auto& rowType = ROW({"c0", "c1", "c2"}, {INTEGER(), DATE(), VARCHAR()});
+  const auto& partitionSpec = createPartitionSpec(
+      rowType,
+      {
+          {0, TransformType::kBucket, 4},
+          {1, TransformType::kYear, std::nullopt},
+          {2, TransformType::kTruncate, 3},
+      });
+
+  testTransform(
+      partitionSpec,
+      makeRowVector({
+          makeFlatVector<int32_t>({8, 34}),
+          makeFlatVector<int32_t>({0, 17532}),
+          makeFlatVector<std::string>({"abcdefg", "ab c"}),
+      }),
+      makeRowVector({
+          makeFlatVector<int32_t>({3, 3}),
+          makeFlatVector<int32_t>({0, 48}),
+          makeFlatVector<std::string>({"abc", "ab "}),
+      }));
+}
+
+TEST_F(TransformTest, multipleTransformsOnSameColumn) {
+  const auto& rowType = ROW({"c0", "c1"}, {DATE(), VARCHAR()});
+  const auto& partitionSpec = createPartitionSpec(
+      rowType,
+      {
+          {0, TransformType::kYear, std::nullopt},
+          {0, TransformType::kBucket, 10},
+          {1, TransformType::kTruncate, 5},
+          {1, TransformType::kBucket, 8},
+      });
+
+  testTransform(
+      partitionSpec,
+      makeRowVector(
+          rowType->names(),
+          {
+              makeFlatVector<int32_t>({0, 17532}),
+              makeFlatVector<std::string>({"abcdefg", "test"}),
+          }),
+      makeRowVector({
+          makeFlatVector<int32_t>({0, 48}),
+          makeFlatVector<int32_t>({6, 7}),
+          makeFlatVector<std::string>({"abcde", "test"}),
+          makeFlatVector<int32_t>({6, 3}),
+      }));
+}
+
+} // namespace
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/tests/WriterOptionsAdapterTest.cpp b/velox/connectors/hive/iceberg/tests/WriterOptionsAdapterTest.cpp
new file mode 100644
index 00000000000..854abc4a0c2
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/WriterOptionsAdapterTest.cpp
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/WriterOptionsAdapter.h"
+
+#include <gtest/gtest.h>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/dwio/dwrf/writer/Writer.h"
+#include "velox/dwio/parquet/writer/WriterConfig.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+namespace {
+
+// Verifies the dispatch table in createWriterOptionsAdapter():
+// PARQUET, DWRF, NIMBLE return non-null adapters; everything else returns
+// null. This is the single source of truth for which file formats the
+// Iceberg DataSink supports on the write path.
+TEST(WriterOptionsAdapterTest, createWriterOptionsAdapterDispatch) {
+  EXPECT_NE(
+      createWriterOptionsAdapter(dwio::common::FileFormat::PARQUET), nullptr);
+  EXPECT_NE(
+      createWriterOptionsAdapter(dwio::common::FileFormat::DWRF), nullptr);
+  EXPECT_NE(
+      createWriterOptionsAdapter(dwio::common::FileFormat::NIMBLE), nullptr);
+
+  // ORC, TEXT, JSON, ALPHA, etc. are intentionally unsupported on the
+  // write path until each gets its own end-to-end coverage.
+  EXPECT_EQ(createWriterOptionsAdapter(dwio::common::FileFormat::ORC), nullptr);
+  EXPECT_EQ(
+      createWriterOptionsAdapter(dwio::common::FileFormat::TEXT), nullptr);
+  EXPECT_EQ(
+      createWriterOptionsAdapter(dwio::common::FileFormat::JSON), nullptr);
+}
+
+// Verifies isSupportedFileFormat() agrees with createWriterOptionsAdapter().
+TEST(WriterOptionsAdapterTest, isSupportedFileFormatMatchesDispatch) {
+  EXPECT_TRUE(isSupportedFileFormat(dwio::common::FileFormat::PARQUET));
+  EXPECT_TRUE(isSupportedFileFormat(dwio::common::FileFormat::DWRF));
+  EXPECT_TRUE(isSupportedFileFormat(dwio::common::FileFormat::NIMBLE));
+
+  EXPECT_FALSE(isSupportedFileFormat(dwio::common::FileFormat::ORC));
+  EXPECT_FALSE(isSupportedFileFormat(dwio::common::FileFormat::TEXT));
+  EXPECT_FALSE(isSupportedFileFormat(dwio::common::FileFormat::JSON));
+}
+
+// Verifies the manifest format string written into Iceberg commit messages
+// matches the cross-engine convention. Iceberg's manifest vocabulary has no
+// DWRF/NIMBLE enum, so both report "ORC" (matching the Java planner's
+// FileFormat.{DWRF,NIMBLE}.toIceberg()) so downstream Iceberg consumers can
+// interpret the message. Parquet reports "PARQUET" because Iceberg has a
+// native enum for it. The on-disk format is identified at read time via
+// the file extension and on-disk magic bytes, so writing "ORC" for NIMBLE
+// is safe.
+TEST(WriterOptionsAdapterTest, toManifestFormatString) {
+  EXPECT_EQ(
+      toManifestFormatString(dwio::common::FileFormat::PARQUET), "PARQUET");
+  EXPECT_EQ(toManifestFormatString(dwio::common::FileFormat::DWRF), "ORC");
+  EXPECT_EQ(toManifestFormatString(dwio::common::FileFormat::NIMBLE), "ORC");
+}
+
+// Verifies the Parquet adapter's pre-config hook installs the Iceberg-spec
+// timestamp serdeParameters. These values must be set before
+// processConfigs() runs because the Parquet writer reads them from
+// serdeParameters during config processing.
+TEST(WriterOptionsAdapterTest, parquetPreConfigsSetsTimestampSerdeParameters) {
+  auto adapter = createWriterOptionsAdapter(dwio::common::FileFormat::PARQUET);
+  ASSERT_NE(adapter, nullptr);
+
+  dwio::common::WriterOptions options;
+  adapter->applyPreConfigs(options);
+
+  EXPECT_EQ(
+      options
+          .serdeParameters[parquet::WriterConfig::kParquetSerdeTimestampUnit],
+      "6");
+  EXPECT_EQ(
+      options.serdeParameters
+          [parquet::WriterConfig::kParquetSerdeTimestampTimezone],
+      "");
+}
+
+// Verifies the DWRF adapter's post-config hook overrides timestamp settings
+// regardless of what processConfigs() left in place. The Iceberg spec
+// requires timestamps NOT be adjusted to UTC; if the DataSink stops calling
+// applyPostConfigs after processConfigs, this test still locks the adapter's
+// override contract — IcebergDataSink::createWriterOptions must use it.
+TEST(WriterOptionsAdapterTest, dwrfPostConfigsOverridesTimestampFields) {
+  auto adapter = createWriterOptionsAdapter(dwio::common::FileFormat::DWRF);
+  ASSERT_NE(adapter, nullptr);
+
+  dwrf::WriterOptions options;
+  options.adjustTimestampToTimezone = true;
+  options.sessionTimezone = tz::locateZone("America/Los_Angeles");
+
+  adapter->applyPostConfigs(options);
+
+  EXPECT_FALSE(options.adjustTimestampToTimezone);
+  EXPECT_EQ(options.sessionTimezone, nullptr);
+}
+
+// Verifies toManifestFormatString() throws for unsupported formats rather
+// than silently returning an incorrect string.
+TEST(WriterOptionsAdapterTest, toManifestFormatStringThrowsForUnsupported) {
+  VELOX_ASSERT_THROW(
+      toManifestFormatString(dwio::common::FileFormat::ORC),
+      "Unsupported file format for Iceberg manifest");
+  VELOX_ASSERT_THROW(
+      toManifestFormatString(dwio::common::FileFormat::TEXT),
+      "Unsupported file format for Iceberg manifest");
+}
+
+} // namespace
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/paimon/CMakeLists.txt b/velox/connectors/hive/paimon/CMakeLists.txt
new file mode 100644
index 00000000000..615b1e260c1
--- /dev/null
+++ b/velox/connectors/hive/paimon/CMakeLists.txt
@@ -0,0 +1,46 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+velox_add_library(
+  velox_hive_paimon_split
+  PaimonConnectorSplit.cpp
+  PaimonDataFileMeta.cpp
+  PaimonDeletionFile.cpp
+  PaimonRowKind.cpp
+  HEADERS
+  PaimonConnectorSplit.h
+  PaimonDataFileMeta.h
+  PaimonDeletionFile.h
+  PaimonRowKind.h
+)
+
+velox_link_libraries(velox_hive_paimon_split velox_connector velox_hive_connector fmt::fmt)
+
+velox_add_library(
+  velox_hive_paimon_connector
+  PaimonConnector.cpp
+  PaimonDataSource.cpp
+  PaimonSplitReader.cpp
+  HEADERS
+  PaimonConfig.h
+  PaimonConnector.h
+  PaimonDataSource.h
+  PaimonSplitReader.h
+)
+
+velox_link_libraries(velox_hive_paimon_connector velox_hive_paimon_split velox_hive_connector)
+
+if(${VELOX_BUILD_TESTING})
+  add_subdirectory(tests)
+endif()
diff --git a/velox/experimental/wave/dwio/nimble/Encoding.h b/velox/connectors/hive/paimon/PaimonConfig.h
similarity index 60%
rename from velox/experimental/wave/dwio/nimble/Encoding.h
rename to velox/connectors/hive/paimon/PaimonConfig.h
index 5ed9e0cac1e..c53f76eebc4 100644
--- a/velox/experimental/wave/dwio/nimble/Encoding.h
+++ b/velox/connectors/hive/paimon/PaimonConfig.h
@@ -13,19 +13,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 #pragma once
 
-namespace facebook::wave::nimble {
-class Encoding {
+#include "velox/connectors/hive/FileConfig.h"
+
+namespace facebook::velox::connector::hive::paimon {
+
+/// Paimon-specific connector configuration.
+/// Extends FileConfig with Paimon-specific settings.
+class PaimonConfig : public FileConfig {
  public:
-  // The binary layout for each Encoding begins with the same prefix:
-  // 1 byte: EncodingType
-  // 1 byte: DataType
-  // 4 bytes: uint32_t num rows
-  static constexpr int kEncodingTypeOffset = 0;
-  static constexpr int kDataTypeOffset = 1;
-  static constexpr int kRowCountOffset = 2;
-  static constexpr int kPrefixSize = 6;
+  explicit PaimonConfig(std::shared_ptr<const config::ConfigBase> config)
+      : FileConfig(std::move(config)) {}
 };
-} // namespace facebook::wave::nimble
+
+} // namespace facebook::velox::connector::hive::paimon
diff --git a/velox/connectors/hive/paimon/PaimonConnector.cpp b/velox/connectors/hive/paimon/PaimonConnector.cpp
new file mode 100644
index 00000000000..2b04959f5cc
--- /dev/null
+++ b/velox/connectors/hive/paimon/PaimonConnector.cpp
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/connectors/hive/paimon/PaimonConnector.h"
+
+#include "velox/connectors/hive/paimon/PaimonDataSource.h"
+
+namespace facebook::velox::connector::hive::paimon {
+
+PaimonConnector::PaimonConnector(
+    const std::string& id,
+    std::shared_ptr<const config::ConfigBase> config,
+    folly::Executor* ioExecutor)
+    : HiveConnector(id, config, ioExecutor),
+      paimonConfig_(std::make_shared<PaimonConfig>(connectorConfig())) {}
+
+std::unique_ptr<DataSource> PaimonConnector::createDataSource(
+    const RowTypePtr& outputType,
+    const ConnectorTableHandlePtr& tableHandle,
+    const ColumnHandleMap& columnHandles,
+    ConnectorQueryCtx* connectorQueryCtx) {
+  return std::make_unique<PaimonDataSource>(
+      outputType,
+      tableHandle,
+      columnHandles,
+      &fileHandleFactory_,
+      ioExecutor_,
+      connectorQueryCtx,
+      paimonConfig_);
+}
+
+} // namespace facebook::velox::connector::hive::paimon
diff --git a/velox/connectors/hive/paimon/PaimonConnector.h b/velox/connectors/hive/paimon/PaimonConnector.h
new file mode 100644
index 00000000000..97bf4a50aa8
--- /dev/null
+++ b/velox/connectors/hive/paimon/PaimonConnector.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/connectors/hive/paimon/PaimonConfig.h"
+
+namespace facebook::velox::connector::hive::paimon {
+
+/// Provides Paimon table format support by extending HiveConnector.
+///
+/// Creates PaimonDataSource instances that handle Paimon's multi-file splits
+/// (one split = one bucket with multiple data files across LSM-tree levels).
+/// Reuses HiveConnector's ORC/Parquet readers directly — no Arrow bridge.
+class PaimonConnector final : public HiveConnector {
+ public:
+  PaimonConnector(
+      const std::string& id,
+      std::shared_ptr<const config::ConfigBase> config,
+      folly::Executor* ioExecutor);
+
+  /// Creates PaimonDataSource for reading from Paimon tables.
+  std::unique_ptr<DataSource> createDataSource(
+      const RowTypePtr& outputType,
+      const ConnectorTableHandlePtr& tableHandle,
+      const ColumnHandleMap& columnHandles,
+      ConnectorQueryCtx* connectorQueryCtx) override;
+
+ private:
+  const std::shared_ptr<PaimonConfig> paimonConfig_;
+};
+
+class PaimonConnectorFactory final : public ConnectorFactory {
+ public:
+  static constexpr const char* kPaimonConnectorName = "paimon";
+
+  PaimonConnectorFactory() : ConnectorFactory(kPaimonConnectorName) {}
+
+  std::shared_ptr<Connector> newConnector(
+      const std::string& id,
+      std::shared_ptr<const config::ConfigBase> config,
+      folly::Executor* ioExecutor = nullptr,
+      [[maybe_unused]] folly::Executor* cpuExecutor = nullptr) override {
+    return std::make_shared<PaimonConnector>(id, config, ioExecutor);
+  }
+};
+
+} // namespace facebook::velox::connector::hive::paimon
diff --git a/velox/connectors/hive/paimon/PaimonConnectorSplit.cpp b/velox/connectors/hive/paimon/PaimonConnectorSplit.cpp
new file mode 100644
index 00000000000..176159c33bb
--- /dev/null
+++ b/velox/connectors/hive/paimon/PaimonConnectorSplit.cpp
@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/connectors/hive/paimon/PaimonConnectorSplit.h"
+
+#include <fmt/format.h>
+
+#include "velox/common/base/Exceptions.h"
+
+namespace facebook::velox::connector::hive::paimon {
+
+std::string paimonTableTypeString(PaimonTableType type) {
+  switch (type) {
+    case PaimonTableType::kAppendOnly:
+      return "APPEND_ONLY";
+    case PaimonTableType::kPrimaryKey:
+      return "PRIMARY_KEY";
+    default:
+      VELOX_FAIL("Unknown PaimonTableType: {}", static_cast<int>(type));
+  }
+}
+
+PaimonTableType paimonTableTypeFromString(const std::string& str) {
+  if (str == "APPEND_ONLY") {
+    return PaimonTableType::kAppendOnly;
+  }
+  if (str == "PRIMARY_KEY") {
+    return PaimonTableType::kPrimaryKey;
+  }
+  VELOX_FAIL("Unknown PaimonTableType: {}", str);
+}
+
+PaimonConnectorSplit::PaimonConnectorSplit(
+    const std::string& connectorId,
+    int64_t snapshotId,
+    PaimonTableType tableType,
+    dwio::common::FileFormat fileFormat,
+    const std::vector<PaimonDataFile>& dataFiles,
+    std::unordered_map<std::string, std::optional<std::string>> partitionKeys,
+    std::optional<int32_t> tableBucketNumber,
+    bool rawConvertible)
+    : ConnectorSplit(connectorId),
+      snapshotId_(snapshotId),
+      tableType_(tableType),
+      fileFormat_(fileFormat),
+      dataFiles_(dataFiles),
+      partitionKeys_(std::move(partitionKeys)),
+      tableBucketNumber_(tableBucketNumber),
+      rawConvertible_(rawConvertible) {
+  VELOX_CHECK(
+      !dataFiles_.empty(), "PaimonConnectorSplit requires non-empty dataFiles");
+
+  if (rawConvertible_) {
+    for (const auto& file : dataFiles_) {
+      VELOX_CHECK_EQ(
+          file.deleteRowCount,
+          0,
+          "rawConvertible split cannot have files with deleteRowCount > 0: {}",
+          file.toString());
+    }
+  }
+}
+
+std::string PaimonConnectorSplit::toString() const {
+  std::string dataFilesStr;
+  for (const auto& file : dataFiles_) {
+    if (!dataFilesStr.empty()) {
+      dataFilesStr += ", ";
+    }
+    dataFilesStr += file.toString();
+  }
+
+  return fmt::format(
+      "PaimonConnectorSplit[snapshot {}, type {}, rawConvertible {}, "
+      "connector '{}', dataFiles=[{}]]",
+      snapshotId_,
+      paimonTableTypeString(tableType_),
+      rawConvertible_,
+      connectorId,
+      dataFilesStr);
+}
+
+folly::dynamic PaimonConnectorSplit::serialize() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["name"] = "PaimonConnectorSplit";
+  obj["connectorId"] = connectorId;
+  obj["snapshotId"] = snapshotId_;
+  obj["tableType"] = paimonTableTypeString(tableType_);
+  obj["rawConvertible"] = rawConvertible_;
+
+  folly::dynamic filesArray = folly::dynamic::array;
+  for (const auto& file : dataFiles_) {
+    filesArray.push_back(file.serialize());
+  }
+  obj["dataFiles"] = filesArray;
+
+  folly::dynamic partitionKeysObj = folly::dynamic::object;
+  for (const auto& [key, value] : partitionKeys_) {
+    partitionKeysObj[key] =
+        value.has_value() ? folly::dynamic(value.value()) : nullptr;
+  }
+  obj["partitionKeys"] = partitionKeysObj;
+
+  obj["tableBucketNumber"] = tableBucketNumber_.has_value()
+      ? folly::dynamic(tableBucketNumber_.value())
+      : nullptr;
+
+  obj["fileFormat"] = dwio::common::toString(fileFormat_);
+
+  return obj;
+}
+
+// static
+std::shared_ptr<PaimonConnectorSplit> PaimonConnectorSplit::create(
+    const folly::dynamic& obj) {
+  const auto connectorId = obj["connectorId"].asString();
+  const auto snapshotId = obj["snapshotId"].asInt();
+  const auto tableType = paimonTableTypeFromString(obj["tableType"].asString());
+  const auto rawConvertible = obj["rawConvertible"].asBool();
+
+  std::vector<PaimonDataFile> dataFiles;
+  for (const auto& fileObj : obj["dataFiles"]) {
+    dataFiles.emplace_back(PaimonDataFile::create(fileObj));
+  }
+
+  std::unordered_map<std::string, std::optional<std::string>> partitionKeys;
+  for (const auto& [key, value] : obj["partitionKeys"].items()) {
+    partitionKeys[key.asString()] = value.isNull()
+        ? std::nullopt
+        : std::optional<std::string>(value.asString());
+  }
+
+  const auto tableBucketNumber = obj["tableBucketNumber"].isNull()
+      ? std::nullopt
+      : std::optional<int32_t>(obj["tableBucketNumber"].asInt());
+
+  const auto fileFormat =
+      dwio::common::toFileFormat(obj["fileFormat"].asString());
+
+  return std::make_shared<PaimonConnectorSplit>(
+      connectorId,
+      snapshotId,
+      tableType,
+      fileFormat,
+      dataFiles,
+      std::move(partitionKeys),
+      tableBucketNumber,
+      rawConvertible);
+}
+
+// static
+void PaimonConnectorSplit::registerSerDe() {
+  auto& registry = DeserializationRegistryForSharedPtr();
+  registry.Register("PaimonConnectorSplit", PaimonConnectorSplit::create);
+}
+
+// --- Builder ---
+
+PaimonConnectorSplitBuilder& PaimonConnectorSplitBuilder::addFile(
+    std::string filePath,
+    uint64_t fileSize,
+    int32_t level) {
+  PaimonDataFile meta;
+  meta.path = std::move(filePath);
+  meta.size = fileSize;
+  meta.level = level;
+  dataFiles_.emplace_back(std::move(meta));
+  return *this;
+}
+
+PaimonConnectorSplitBuilder& PaimonConnectorSplitBuilder::partitionKey(
+    std::string name,
+    std::optional<std::string> value) {
+  partitionKeys_.emplace(std::move(name), std::move(value));
+  return *this;
+}
+
+PaimonConnectorSplitBuilder& PaimonConnectorSplitBuilder::tableBucketNumber(
+    int32_t bucketId) {
+  tableBucketNumber_ = bucketId;
+  return *this;
+}
+
+PaimonConnectorSplitBuilder& PaimonConnectorSplitBuilder::rawConvertible(
+    bool value) {
+  rawConvertible_ = value;
+  return *this;
+}
+
+std::shared_ptr<PaimonConnectorSplit> PaimonConnectorSplitBuilder::build() {
+  return std::make_shared<PaimonConnectorSplit>(
+      connectorId_,
+      snapshotId_,
+      tableType_,
+      fileFormat_,
+      dataFiles_,
+      partitionKeys_,
+      tableBucketNumber_,
+      rawConvertible_);
+}
+
+} // namespace facebook::velox::connector::hive::paimon
diff --git a/velox/connectors/hive/paimon/PaimonConnectorSplit.h b/velox/connectors/hive/paimon/PaimonConnectorSplit.h
new file mode 100644
index 00000000000..9182b51b22a
--- /dev/null
+++ b/velox/connectors/hive/paimon/PaimonConnectorSplit.h
@@ -0,0 +1,587 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <fmt/format.h>
+#include <optional>
+#include <ostream>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include <folly/CPortability.h>
+
+#include "velox/connectors/Connector.h"
+#include "velox/connectors/hive/paimon/PaimonDataFileMeta.h"
+#include "velox/dwio/common/Options.h"
+
+namespace facebook::velox::connector::hive::paimon {
+
+/// Paimon table type determines read and write semantics.
+///
+/// # Table Types
+///
+/// Append-only: No primary key. Each write appends new independent files. All
+/// files are at LSM level 0 and rawConvertible is always true. Files can be
+/// read in any order for batch queries. No merge-on-read needed. Compaction
+/// only reduces the number of small files (concatenation, no deduplication).
+///
+/// Primary-key: Uses an LSM tree to organize data files per bucket. New writes
+/// go to level 0; background compaction merges files into higher levels,
+/// deduplicating by primary key. The merge engine determines how duplicate
+/// keys are resolved:
+///
+///   Deduplicate (upsert): Latest write wins — entire row replaced.
+///     Write {id=1, name="Alice"} then {id=1, name="Bob"}
+///     → result: {id=1, name="Bob"}
+///
+///   Partial-update: Only non-null columns in new record overwrite old values.
+///     Write {id=1, name="Alice", age=25} then {id=1, name=NULL, age=26}
+///     → result: {id=1, name="Alice", age=26}
+///
+/// # Partitioning and Bucketing
+///
+/// Paimon uses a fixed physical layout: partition-dirs / bucket-dir / files.
+/// The hierarchy is strictly partition → bucket → files with no nesting or
+/// reordering (no bucket-before-partition or bucket-after-bucket).
+///
+/// Partitioning: Hive-style directory partitioning by column values. Zero or
+/// more partition columns, ordered. Each unique combination of partition values
+/// creates a physical directory. Partition columns are NOT stored in the data
+/// files (values are in the directory path). Enables partition pruning.
+///
+/// Bucketing: Hash-distributes rows within a partition into N buckets. Each
+/// bucket is a physical directory (bucket-0/, bucket-1/, ...) and acts as an
+/// independent LSM tree instance. For primary-key tables, the bucket key
+/// defaults to the primary key, ensuring each key maps to exactly one bucket
+/// (merge-on-read only needs to look within a single bucket). For append-only
+/// tables, bucket key can be any column(s) for write parallelism.
+///
+/// Unbucketed tables use a single implicit bucket-0/ directory. All four
+/// combinations of partitioned/unpartitioned × bucketed/unbucketed are valid:
+///
+///   Partitioned + bucketed:   dt=2024-01-01/bucket-0/data.orc
+///   Partitioned + unbucketed: dt=2024-01-01/bucket-0/data.orc  (bucket-0 only)
+///   Unpartitioned + bucketed: bucket-0/data.orc, bucket-1/data.orc, ...
+///   Unpartitioned + unbucketed: bucket-0/data.orc  (bucket-0 only)
+///
+/// Each PaimonConnectorSplit represents one partition + one bucket. The
+/// partitionKeys field carries partition column values, and tableBucketNumber
+/// identifies the bucket (nullopt for unbucketed tables).
+///
+/// # LSM Tree Structure (Primary-Key Tables)
+///
+/// Level 0: Newest data. Each flush creates a new file. Files within level 0
+///   CAN have overlapping keys (multiple files may contain the same key).
+///   minSequenceNumber == maxSequenceNumber (single commit per file).
+///
+/// Level 1+: Compacted data. Compaction merges lower-level files, deduplicating
+///   keys and producing non-overlapping key ranges. No two files at the same
+///   level share a key. minSequenceNumber < maxSequenceNumber (merged from
+///   multiple commits).
+///
+/// # Compaction Strategy (Universal Compaction)
+///
+/// Primary-key tables use Universal Compaction (similar to RocksDB):
+///
+/// Sorted runs: Each L0 file is its own sorted run. All files at the same
+///   higher level (L1, L2, ...) together form one sorted run with
+///   non-overlapping keys. Compaction merges sorted runs.
+///
+/// Trigger: When the number of sorted runs exceeds
+///   num-sorted-run.compaction-trigger (default: 5), compaction is triggered.
+///
+/// Picking strategy: Compaction picks the OLDEST sorted runs first and merges
+///   them until the count drops below the trigger threshold. The output level
+///   depends on which sorted runs are merged. Multiple non-L0 levels can
+///   exist (L1, L2, ...). Within each level, files have non-overlapping key
+///   ranges. L0 files can overlap with any level.
+///
+/// Who runs compaction:
+///   - Default: the writer process (Flink task) runs compaction asynchronously
+///     after each commit.
+///   - Dedicated mode: a separate compaction job can be configured to offload
+///     compaction from writers.
+///   - Either way, compaction creates a new snapshot with updated manifest
+///     entries (REMOVE old files, ADD compacted file).
+///
+/// Compaction output:
+///   - Data file: deduplicated keys, latest value wins (by sequence number).
+///   - With changelog-producer=lookup: also generates a changelog file.
+///   - With deletion-vectors.enabled: may generate deletion bitmaps instead of
+///     rewriting data files.
+///
+/// Append-only compaction: Only concatenates small files into larger ones (no
+///   key deduplication). All files stay at level 0. Triggered when the number
+///   of small files exceeds a threshold.
+///
+/// rawConvertible: Per-split flag set by the Paimon planner.
+///   false = keys overlap across levels, merge-on-read required.
+///   true  = fully compacted (single level, no overlapping keys), read
+///   directly. Always true for append-only tables.
+///
+/// # Snapshots and Manifests
+///
+/// Every Paimon read (batch or streaming) goes through snapshots — immutable
+/// point-in-time views of the table. A snapshot points to a manifest-list,
+/// which references manifest files that record which data files are active.
+///
+/// Physical layout on storage:
+///
+///   table-path/
+///     snapshot/
+///       snapshot-1      ← JSON: points to manifest-list-1
+///       snapshot-2      ← JSON: points to manifest-list-2
+///     manifest/
+///       manifest-list-1 ← lists which manifest files to read
+///       manifest-1      ← data file entries (ADD/REMOVE)
+///       manifest-2
+///     dt=2024-01-01/
+///       bucket-0/
+///         data-001.orc  ← actual data files
+///         data-002.orc
+///     schema/
+///       schema-0        ← table schema
+///
+/// Each manifest entry contains both structured metadata and the file path:
+///
+///   {action: ADD,
+///    partition: {dt: "2024-01-01"},       ← structured, for fast pruning
+///    bucket: 0,                           ← structured, for fast pruning
+///    filePath: "dt=2024-01-01/bucket-0/data-001.orc",  ← for I/O
+///    level: 0, minSeq: 10, maxSeq: 10, ...}
+///
+/// The partition/bucket values are redundant with the file path (which
+/// encodes them in the directory structure) — the structured fields enable
+/// fast partition/bucket pruning without path parsing.
+///
+/// The Paimon planner reads the manifest, applies partition pruning, and
+/// generates one PaimonConnectorSplit per partition × bucket combination:
+///
+///   Manifest entries after pruning for dt='2024-01-01':
+///     partition={dt: "2024-01-01"}, bucket=0: [data-001.orc, data-002.orc]
+///     partition={dt: "2024-01-01"}, bucket=1: [data-001.orc]
+///   → Split 1: partitionKeys={dt: "2024-01-01"}, bucket=0, 2 files
+///   → Split 2: partitionKeys={dt: "2024-01-01"}, bucket=1, 1 file
+///
+/// Snapshot isolation: Readers see only files referenced by their snapshot.
+/// Concurrent writers creating new snapshots don't affect in-flight reads.
+/// Old data files are only deleted after snapshot expiration (no snapshot
+/// references them). The manifest is authoritative — partition directories
+/// may contain old compacted-away files that no snapshot references.
+///
+/// # Read Modes
+///
+/// All reads are snapshot-based. The mode determines how many snapshots are
+/// read and what output is produced:
+///
+/// Batch (snapshot read): Reads the full file set at ONE snapshot. For
+///   primary-key tables, merge-on-read ALWAYS required to deduplicate by key
+///   and return the current state — regardless of changelog mode. This is the
+///   Velox/Presto read path.
+///
+/// Time travel: Batch read at a user-specified older snapshot (instead of
+///   the latest). Same mechanism, different snapshot ID. Only works if the
+///   snapshot hasn't been expired.
+///
+/// Streaming: Reads DELTAS between consecutive snapshots (N→N+1→N+2→...).
+///   Only processes newly added files (the manifest diff), emitting changelog
+///   records. Runs continuously, polling for new snapshots. Specifies only a
+///   start snapshot — the end is unbounded. Merge-on-read is NOT needed for
+///   streaming — the reader only sees delta files, not the full file set, so
+///   there is nothing to merge against. For input changelog mode, RowKind is
+///   stored in the files and emitted directly. For upsert mode, the reader
+///   infers changelog from the delta. Compaction deltas are a special case:
+///   the changelog is collapsed, so changelog-producer=lookup is needed to
+///   regenerate meaningful changelog records during compaction.
+///
+/// Incremental: Bounded streaming — reads deltas from snapshot N to M, then
+///   stops. Same delta mechanism as streaming but with an end bound.
+///
+/// Merge-on-read summary for primary-key tables:
+///   Batch/time-travel: Always required (full file set, must deduplicate).
+///   Streaming/incremental: Never required (delta files only, no merge).
+///
+/// # Coordinator/Reader Responsibility Split
+///
+/// Split generation follows a coordinator/reader architecture (mirrors
+/// Flink's enumerator/reader pattern):
+///
+/// Coordinator (Java planner):
+///   - Batch: reads manifest at one snapshot, groups files by partition ×
+///     bucket, generates one PaimonConnectorSplit per group.
+///   - Streaming: starts at a given snapshot, continuously polls for new
+///     snapshots. For each new snapshot (N→N+1), computes the manifest diff
+///     (newly added files), groups delta files by partition × bucket, and
+///     generates one split per group. Repeats indefinitely.
+///   - Incremental: same as streaming but stops at the end snapshot M.
+///   - With changelog-producer=lookup: sends changelog files (kCompact) for
+///     streaming, data files (kAppend) for batch.
+///   - Without changelog-producer: sends data files (kAppend) for all modes.
+///
+/// Reader (Velox worker):
+///   - Stateless — receives splits and reads files. Does not track snapshots,
+///     does not compute deltas, does not decide which file type to read.
+///   - For batch: performs merge-on-read if rawConvertible is false.
+///   - For streaming: emits rows directly (as +I without changelog-producer,
+///     or with stored RowKind for changelog files / input changelog mode).
+///
+/// # Changelog Semantics
+///
+/// Primary-key tables can produce a changelog stream with four row kinds:
+///   +I (INSERT):        New key added.
+///   -U (UPDATE_BEFORE): Old value being replaced (for retraction).
+///   +U (UPDATE_AFTER):  New value replacing it.
+///   -D (DELETE):        Key removed.
+///
+/// -U and +U are always emitted as a consecutive pair for the same key.
+/// Intermediate updates are collapsed — the consumer sees only the net
+/// change (oldest value → newest value), not every step.
+///
+/// # RowKind and the _rowkind Column
+///
+/// Every primary-key table supports a hidden system column `_rowkind` that
+/// encodes the change type per row. At the file format level (Parquet, ORC,
+/// Nimble), `_rowkind` is a regular TINYINT column — the file format has no
+/// special knowledge of it. It is "hidden" only at the SQL layer (not shown
+/// in SELECT *). Values: 0=+I, 1=-U, 2=+U, 3=-D.
+///
+/// Whether `_rowkind` is actually written to data files depends on the mode:
+///
+/// Upsert mode (normal writes): `_rowkind` is omitted from data files since
+///   all records are implicitly +I/+U (insert or update, latest wins). The
+///   streaming reader INFERS -U/+U pairs during merge-on-read by comparing
+///   old vs new values for the same key across LSM levels. When a SQL DELETE
+///   is issued, Paimon writes a record with `_rowkind=-D` to level 0, along
+///   with the full before-image (all column values populated). Compaction
+///   removes the key entirely.
+///
+///   Limitation: Streaming reads in upsert mode only process delta files
+///   (newly added files between snapshots) — the reader does NOT look back
+///   at previous snapshots. A key appearing once in the delta is emitted as
+///   +I, even if that key already existed in a prior snapshot (should be +U).
+///   For correct +I vs +U distinction, use changelog-producer=lookup which
+///   looks up old values from existing files to determine the actual change
+///   type. This limitation does NOT apply to input changelog mode — the
+///   source provides the correct RowKind (+I/+U/-U/-D) explicitly.
+///
+/// Input changelog mode (CDC source writes): `_rowkind` IS written for every
+///   row. The external source (Flink CDC, Kafka) provides the change type.
+///   The streaming reader emits rows with their stored RowKind directly — no
+///   merge inference needed for uncompacted data. Files must be read in
+///   sequence-number order since -U/+U pairs may span files. Compaction
+///   collapses the stored changelog; use changelog-producer=lookup to
+///   regenerate it during compaction.
+///
+/// rowkind.field mode: Instead of the hidden `_rowkind` column, the table
+///   designates a user-visible column (e.g., "op") to carry the change type.
+///   Useful when the CDC source provides change type as a regular field. At
+///   the file level, it's just a regular column — the Paimon engine
+///   interprets its values as RowKind.
+///
+/// # Deletes
+///
+/// A delete record is NOT a row with null values. It's a complete row (full
+/// before-image) tagged with RowKind=-D. The mechanism depends on the source:
+///
+///   SQL DELETE:       Paimon engine writes {_rowkind=-D, id=1, name="Alice"}
+///   CDC source:       External source provides -D record with full values
+///   rowkind.field:    User column carries the delete marker
+///
+/// The full old column values (before-image) are carried for streaming/
+/// changelog consumers that need retraction semantics. Without old values,
+/// the consumer would need its own state lookup to know what was deleted:
+///
+///   Example — aggregation counting users by country:
+///     State: {id=1, name="Alice", country="US"}  → US count = 1
+///
+///     -D {id=1} (key only):
+///       Consumer doesn't know which country to decrement — must look up.
+///     -D {id=1, name="Alice", country="US"} (full before-image):
+///       Consumer decrements US count directly. No lookup needed.
+///
+/// Same reason -U (UPDATE_BEFORE) carries the full old row — the consumer
+/// retracts old values before applying +U (UPDATE_AFTER) with new values.
+/// For batch reads, the old values don't matter (compaction removes the key).
+///
+/// Separately, deletion files (PaimonDeletionFile) are a bitmap-based
+/// mechanism that marks row positions as deleted within an existing data
+/// file without rewriting it. This is orthogonal to RowKind-based deletes.
+///
+/// For batch/snapshot reads (Presto), changelog semantics don't apply — the
+/// reader returns the current state of each row, not the change history.
+///
+/// Append-only tables only produce +I (INSERT) records — no updates or
+/// deletes since there's no primary key to identify rows. Streaming reads
+/// from append-only tables emit all new rows as +I; file read order doesn't
+/// matter since there are no retraction pairs.
+///
+/// # Sequence Numbers
+///
+/// Auto-generated per-commit, monotonically increasing. Used within a
+/// snapshot for merge-on-read ordering (higher sequence number wins for
+/// duplicate keys). NOT used for snapshot isolation (that's handled by the
+/// manifest chain). Sequence numbers are per-file metadata, not per-row —
+/// after compaction, per-row attribution is lost but the LSM level order
+/// makes it unnecessary.
+///
+/// # changelog-producer=lookup
+///
+/// When configured on a primary-key table, the compactor generates TWO
+/// outputs per compaction: (1) a data file (no `_rowkind` in upsert mode)
+/// and (2) a separate changelog file containing the pre-computed changelog
+/// with correct RowKind (+I/+U/-U/-D, includes `_rowkind`). Both files are
+/// marked as PaimonFileSource::kCompact (produced by compaction). Without
+/// this flag, compaction produces only a data file.
+///
+/// The coordinator (Java planner) sends the right files based on read mode:
+///
+///   Batch read:      sends data files only → merge-on-read as usual
+///   Streaming read:  sends changelog files only → RowKind already correct,
+///                    no inference or merge needed
+///
+/// Without changelog-producer=lookup, streaming reads work as follows:
+///
+///   Streaming read (no changelog-producer):
+///     Coordinator sends the delta data files (newly added between snapshots).
+///     The reader does NOT do merge-on-read — it only processes delta files,
+///     not the full file set. Each row in the delta is emitted as +I. The
+///     limitation is that the reader cannot distinguish +I (new key) from +U
+///     (existing key updated) because it doesn't look back at previous
+///     snapshots. For many use cases (e.g., downstream upsert sinks) this is
+///     acceptable since the consumer treats +I and +U identically.
+///
+///   Compaction snapshots are problematic without changelog-producer: the
+///   compacted file contains ALL keys (not just changed ones), so the reader
+///   would emit +I for every key — including unchanged ones. With
+///   changelog-producer=lookup, the compactor compares old vs new values and
+///   generates a changelog file with only actual changes.
+///
+///   If the same key is updated across multiple consecutive snapshots (N→N+1,
+///   N+1→N+2, ...), each delta is processed independently. The reader emits
+///   one +I per delta that touches the key. The downstream consumer must be
+///   idempotent (e.g., upsert by key) to handle this correctly. Without
+///   merge-on-read, the reader has no version information — it does not know
+///   whether a key is new or updated, nor can it deduplicate across deltas.
+///   This is by design: streaming reads trade correctness of change types for
+///   simplicity and performance.
+///
+///   Example — key updated across two snapshots without changelog-producer:
+///
+///     Delta N→N+1:   {id=1, name="Alice"}  → emitted as +I
+///     Delta N+1→N+2: {id=1, name="Bob"}    → emitted as +I (not +U)
+///
+///   This works for upsert sinks (consumer does INSERT-or-UPDATE by key —
+///   final state is correct regardless of +I vs +U). It breaks for retraction
+///   sinks (e.g., aggregation counting by name):
+///
+///     Correct:    +I "Alice" (count=1), -U "Alice" + +U "Bob" (count=1)
+///     Without changelog-producer: +I "Alice" (count=1), +I "Bob" (count=2) ✗
+///
+///   For exact changelog semantics, use changelog-producer=lookup.
+///
+/// The file origin (write vs compaction) is indicated by PaimonFileSource in
+/// PaimonDataFile::fileSource. Both data files and changelog files use
+/// the same physical file format. Note that PaimonFileSource indicates HOW
+/// the file was produced, not WHETHER it is a data or changelog file — both
+/// are marked kCompact when produced by compaction. The coordinator tracks
+/// which is which via separate manifest entries.
+///
+/// Schema difference: In upsert mode (no input changelog), data files do NOT
+/// contain the `_rowkind` column (all records are implicitly +I/+U). Changelog
+/// files generated by changelog-producer=lookup DO contain `_rowkind` since
+/// they carry explicit change types. The coordinator knows which file type it
+/// is sending, so the reader schema is adjusted accordingly. In input changelog
+/// mode, both data and changelog files contain `_rowkind`.
+///
+/// # Velox Connector Scope
+///
+/// Currently only batch reads (Presto) are supported. Only data files are
+/// needed — changelog files and streaming semantics are not required.
+///
+/// Future streaming support: We will require changelog-producer=lookup (or
+/// full-compaction) to be enabled on the table. This means the compactor
+/// generates pre-computed changelog files, and the streaming reader consumes
+/// them directly. We do NOT plan to support beforeFiles-based diffing (where
+/// the reader merges old and new file sets to infer changelog at read time).
+/// This avoids expensive read-time merge and simplifies the reader — the
+/// coordinator sends changelog files for compaction snapshots and delta data
+/// files for non-compaction snapshots.
+enum class PaimonTableType {
+  /// No primary key. Data files are independent — no merge-on-read needed.
+  /// All files at level 0, rawConvertible always true.
+  kAppendOnly,
+  /// Has a primary key. Uses LSM tree with merge-on-read to deduplicate
+  /// records by key when data spans multiple compaction levels.
+  kPrimaryKey,
+};
+
+/// Returns the string name of the table type (e.g., "APPEND_ONLY").
+std::string paimonTableTypeString(PaimonTableType type);
+
+/// Parses a table type from its string name.
+PaimonTableType paimonTableTypeFromString(const std::string& str);
+
+FOLLY_ALWAYS_INLINE std::ostream& operator<<(
+    std::ostream& os,
+    PaimonTableType type) {
+  os << paimonTableTypeString(type);
+  return os;
+}
+
+} // namespace facebook::velox::connector::hive::paimon
+
+template <>
+struct fmt::formatter<facebook::velox::connector::hive::paimon::PaimonTableType>
+    : formatter<std::string> {
+  auto format(
+      facebook::velox::connector::hive::paimon::PaimonTableType type,
+      format_context& ctx) const {
+    return formatter<std::string>::format(
+        facebook::velox::connector::hive::paimon::paimonTableTypeString(type),
+        ctx);
+  }
+};
+
+namespace facebook::velox::connector::hive::paimon {
+
+/// Represents a Paimon DataSplit — a collection of data files in one
+/// partition/bucket.
+///
+/// Unlike HiveConnectorSplit (one file per split), a Paimon split maps to a
+/// logical bucket which may contain multiple physical files across LSM-tree
+/// levels.
+///
+/// NOTE: Table-wide metadata (primary key columns, merge engine, table schema)
+/// is NOT carried in the split. A future PaimonTableHandle (extending
+/// HiveTableHandle) will carry this information, needed for merge-on-read
+/// (key deduplication) and schema evolution. For batch reads of
+/// rawConvertible=true splits, the existing HiveTableHandle suffices.
+class PaimonConnectorSplit : public connector::ConnectorSplit {
+ public:
+  /// @param connectorId Connector identifier.
+  /// @param snapshotId Paimon table snapshot version this split was generated
+  ///        from.
+  /// @param tableType Whether this is an append-only or primary-key table.
+  /// @param fileFormat File format of the data files (e.g., ORC, Parquet).
+  /// @param dataFiles Data files in this split, each representing a physical
+  ///        file in the LSM-tree.
+  /// @param partitionKeys Partition key-value pairs. Keys map to partition
+  ///        column names; values are nullopt for null partitions.
+  /// @param tableBucketNumber Bucket number within the Paimon table's bucket
+  ///        distribution. Nullopt for unbucketed tables.
+  /// @param rawConvertible Per-split flag indicating whether all files in this
+  ///        split (partition × bucket) can be read without merge-on-read (no
+  ///        key deduplication needed across LSM levels). Set by the Paimon
+  ///        planner based on the compaction state of the entire bucket. Only
+  ///        meaningful for primary-key tables.
+  PaimonConnectorSplit(
+      const std::string& connectorId,
+      int64_t snapshotId,
+      PaimonTableType tableType,
+      dwio::common::FileFormat fileFormat,
+      const std::vector<PaimonDataFile>& dataFiles,
+      std::unordered_map<std::string, std::optional<std::string>> partitionKeys,
+      std::optional<int32_t> tableBucketNumber,
+      bool rawConvertible = true);
+
+  int64_t snapshotId() const {
+    return snapshotId_;
+  }
+
+  PaimonTableType tableType() const {
+    return tableType_;
+  }
+
+  const std::vector<PaimonDataFile>& dataFiles() const {
+    return dataFiles_;
+  }
+
+  const std::unordered_map<std::string, std::optional<std::string>>&
+  partitionKeys() const {
+    return partitionKeys_;
+  }
+
+  std::optional<int32_t> tableBucketNumber() const {
+    return tableBucketNumber_;
+  }
+
+  bool rawConvertible() const {
+    return rawConvertible_;
+  }
+
+  dwio::common::FileFormat fileFormat() const {
+    return fileFormat_;
+  }
+
+  std::string toString() const override;
+
+  folly::dynamic serialize() const override;
+
+  static std::shared_ptr<PaimonConnectorSplit> create(
+      const folly::dynamic& obj);
+
+  static void registerSerDe();
+
+ private:
+  const int64_t snapshotId_;
+  const PaimonTableType tableType_;
+  const dwio::common::FileFormat fileFormat_;
+  const std::vector<PaimonDataFile> dataFiles_;
+  const std::unordered_map<std::string, std::optional<std::string>>
+      partitionKeys_;
+  const std::optional<int32_t> tableBucketNumber_;
+  const bool rawConvertible_;
+};
+
+/// Builder for PaimonConnectorSplit construction.
+class PaimonConnectorSplitBuilder {
+ public:
+  PaimonConnectorSplitBuilder(
+      std::string connectorId,
+      int64_t snapshotId,
+      PaimonTableType tableType,
+      dwio::common::FileFormat fileFormat)
+      : connectorId_(std::move(connectorId)),
+        snapshotId_(snapshotId),
+        tableType_(tableType),
+        fileFormat_(fileFormat) {}
+
+  PaimonConnectorSplitBuilder&
+  addFile(std::string filePath, uint64_t fileSize, int32_t level = 0);
+
+  PaimonConnectorSplitBuilder& partitionKey(
+      std::string name,
+      std::optional<std::string> value);
+
+  PaimonConnectorSplitBuilder& tableBucketNumber(int32_t bucketId);
+
+  PaimonConnectorSplitBuilder& rawConvertible(bool value);
+
+  std::shared_ptr<PaimonConnectorSplit> build();
+
+ private:
+  const std::string connectorId_;
+  const int64_t snapshotId_;
+  const PaimonTableType tableType_;
+  const dwio::common::FileFormat fileFormat_;
+  std::vector<PaimonDataFile> dataFiles_;
+  std::unordered_map<std::string, std::optional<std::string>> partitionKeys_;
+  std::optional<int32_t> tableBucketNumber_;
+  bool rawConvertible_{true};
+};
+
+} // namespace facebook::velox::connector::hive::paimon
diff --git a/velox/connectors/hive/paimon/PaimonDataFileMeta.cpp b/velox/connectors/hive/paimon/PaimonDataFileMeta.cpp
new file mode 100644
index 00000000000..82b3437028f
--- /dev/null
+++ b/velox/connectors/hive/paimon/PaimonDataFileMeta.cpp
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/connectors/hive/paimon/PaimonDataFileMeta.h"
+
+#include "velox/common/base/Exceptions.h"
+
+namespace facebook::velox::connector::hive::paimon {
+
+// static
+std::string PaimonDataFile::typeString(Type type) {
+  switch (type) {
+    case Type::kData:
+      return "DATA";
+    case Type::kChangelog:
+      return "CHANGELOG";
+    default:
+      VELOX_FAIL("Unknown PaimonDataFile::Type: {}", static_cast<int>(type));
+  }
+}
+
+// static
+PaimonDataFile::Type PaimonDataFile::typeFromString(const std::string& str) {
+  if (str == "DATA") {
+    return Type::kData;
+  }
+  if (str == "CHANGELOG") {
+    return Type::kChangelog;
+  }
+  VELOX_FAIL("Unknown PaimonDataFile::Type: {}", str);
+}
+
+// static
+std::string PaimonDataFile::sourceString(Source source) {
+  switch (source) {
+    case Source::kAppend:
+      return "APPEND";
+    case Source::kCompact:
+      return "COMPACT";
+    default:
+      VELOX_FAIL(
+          "Unknown PaimonDataFile::Source: {}", static_cast<int>(source));
+  }
+}
+
+// static
+PaimonDataFile::Source PaimonDataFile::sourceFromString(
+    const std::string& str) {
+  if (str == "APPEND") {
+    return Source::kAppend;
+  }
+  if (str == "COMPACT") {
+    return Source::kCompact;
+  }
+  VELOX_FAIL("Unknown PaimonDataFile::Source: {}", str);
+}
+
+std::string PaimonDataFile::toString() const {
+  return fmt::format(
+      "{{path={}, size={}, rows={}, level={}, type={}, source={}, "
+      "deletionFile={}}}",
+      path,
+      size,
+      rowCount,
+      level,
+      typeString(type),
+      sourceString(source),
+      deletionFile.has_value() ? deletionFile->toString() : "none");
+}
+
+folly::dynamic PaimonDataFile::serialize() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["filePath"] = path;
+  obj["fileSize"] = size;
+  obj["rowCount"] = rowCount;
+  obj["level"] = level;
+  obj["minSequenceNumber"] = minSequenceNumber;
+  obj["maxSequenceNumber"] = maxSequenceNumber;
+  obj["deleteRowCount"] = deleteRowCount;
+  obj["creationTimeMs"] = creationTimeMs;
+  obj["fileType"] = typeString(type);
+  obj["sourceType"] = sourceString(source);
+  if (deletionFile.has_value()) {
+    obj["deletionFile"] = deletionFile->serialize();
+  }
+  return obj;
+}
+
+// static
+PaimonDataFile PaimonDataFile::create(const folly::dynamic& obj) {
+  PaimonDataFile file;
+  file.path = obj["filePath"].asString();
+  file.size = static_cast<uint64_t>(obj["fileSize"].asInt());
+  file.rowCount = static_cast<uint64_t>(obj["rowCount"].asInt());
+  file.level = static_cast<int32_t>(obj["level"].asInt());
+  file.minSequenceNumber = obj["minSequenceNumber"].asInt();
+  file.maxSequenceNumber = obj["maxSequenceNumber"].asInt();
+  file.deleteRowCount = obj["deleteRowCount"].asInt();
+  file.creationTimeMs = obj["creationTimeMs"].asInt();
+  file.type = typeFromString(obj["fileType"].asString());
+  file.source = sourceFromString(obj["sourceType"].asString());
+  if (obj.count("deletionFile") > 0) {
+    file.deletionFile = PaimonDeletionFile::create(obj["deletionFile"]);
+  }
+  return file;
+}
+
+} // namespace facebook::velox::connector::hive::paimon
diff --git a/velox/connectors/hive/paimon/PaimonDataFileMeta.h b/velox/connectors/hive/paimon/PaimonDataFileMeta.h
new file mode 100644
index 00000000000..5011ba5e523
--- /dev/null
+++ b/velox/connectors/hive/paimon/PaimonDataFileMeta.h
@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <fmt/format.h>
+#include <folly/dynamic.h>
+#include <cstdint>
+#include <optional>
+#include <ostream>
+#include <string>
+
+#include <folly/CPortability.h>
+
+#include "velox/connectors/hive/paimon/PaimonDeletionFile.h"
+
+namespace facebook::velox::connector::hive::paimon {
+
+/// Represents a single Paimon file (data or changelog) within a split.
+/// Mirrors Apache Paimon's DataFileMeta structure.
+///
+/// Both data files and changelog files use the same physical file format
+/// (Parquet, ORC, Nimble) and carry the same metadata. The distinction is
+/// captured by `type`:
+///   - kData: regular data file (current state of records).
+///   - kChangelog: changelog file with RowKind (+I/-U/+U/-D) for streaming.
+struct PaimonDataFile {
+  /// Whether this file is a data file or a changelog file. Both use the
+  /// same physical format — this enum distinguishes their semantic role.
+  ///
+  /// Data files contain the current state of records. Changelog files
+  /// contain the change history with RowKind tags. The coordinator sends
+  /// data files for batch reads and changelog files for streaming reads
+  /// (when changelog-producer=lookup is configured).
+  enum class Type {
+    /// Regular data file containing current record state.
+    kData,
+
+    /// Changelog file containing records tagged with RowKind (+I/-U/+U/-D).
+    /// Only produced when changelog-producer=lookup is configured on the table.
+    /// The coordinator sends these for streaming reads instead of data files.
+    kChangelog,
+  };
+
+  /// Origin of a Paimon file — how it was produced, not what it contains.
+  /// Mirrors Paimon's DataFileMeta.FileSource enum.
+  ///
+  /// This does NOT indicate whether the file contains `_rowkind`. The presence
+  /// of `_rowkind` depends on the changelog mode (upsert vs input changelog),
+  /// not the source type.
+  enum class Source {
+    /// File produced by a normal write (flush/append).
+    kAppend,
+
+    /// File produced by compaction. This could be:
+    ///   - Without changelog-producer=lookup: a regular data file (same as
+    ///     kAppend but produced by compaction instead of a write).
+    ///   - With changelog-producer=lookup: compaction produces TWO files —
+    ///     (1) a data file (no `_rowkind` in upsert mode) and (2) a separate
+    ///     changelog file (with `_rowkind` containing correct +I/-U/+U/-D).
+    ///     Both are marked kCompact. The coordinator sends the right one based
+    ///     on the read mode (data file for batch, changelog file for
+    ///     streaming).
+    kCompact,
+  };
+
+  /// Returns the string name of the file type (e.g., "DATA").
+  static std::string typeString(Type type);
+
+  /// Parses a file type from its string name.
+  static Type typeFromString(const std::string& str);
+
+  /// Returns the string name of the source type (e.g., "APPEND").
+  static std::string sourceString(Source source);
+
+  /// Parses a source type from its string name.
+  static Source sourceFromString(const std::string& str);
+
+  /// Path to the file (ORC, Parquet, etc.).
+  std::string path;
+
+  /// Size of the file in bytes.
+  uint64_t size{0};
+
+  /// Number of rows in this file.
+  uint64_t rowCount{0};
+
+  /// LSM-tree level of this file. Level 0 contains the newest (unflushed)
+  /// data; higher levels contain progressively more compacted data. Within
+  /// level 0, files CAN have overlapping keys. Within level 1+, compaction
+  /// guarantees non-overlapping key ranges across files.
+  /// Always 0 for append-only tables (no compaction).
+  int32_t level{0};
+
+  /// Sequence number range of records in this file. Auto-generated per-commit,
+  /// monotonically increasing. For level 0 files, min == max (single commit).
+  /// For compacted files (level 1+), min < max (merged from multiple commits).
+  /// Used during merge-on-read to resolve duplicate keys — higher sequence
+  /// number wins. Per-file metadata only (not per-row); after compaction,
+  /// per-row sequence attribution is lost but LSM level order makes it
+  /// unnecessary.
+  int64_t minSequenceNumber{0};
+  int64_t maxSequenceNumber{0};
+
+  /// Number of rows in this file with RowKind = DELETE or UPDATE_BEFORE.
+  /// row_count = addRowCount + deleteRowCount, where addRowCount is the
+  /// number of INSERT or UPDATE_AFTER rows.
+  ///
+  /// Only applicable to primary-key tables. Append-only tables have no
+  /// _rowkind column and every row is implicitly +I, so deleteRowCount is
+  /// always 0.
+  ///
+  /// This is independent of deletionFile — deleteRowCount counts changelog
+  /// records stored inside the file, while deletionFile is an external bitmap
+  /// of positionally deleted rows.
+  ///
+  /// Used to determine rawConvertible: if deleteRowCount > 0, the file
+  /// contains changelog records and cannot be read raw (needs RowKind
+  /// filtering during merge-on-read).
+  int64_t deleteRowCount{0};
+
+  /// Timestamp (epoch millis) when this file was created.
+  int64_t creationTimeMs{0};
+
+  /// Whether this is a data file or changelog file.
+  Type type{Type::kData};
+
+  /// How this file was produced (write vs compaction).
+  Source source{Source::kAppend};
+
+  /// Deletion file for this data file. Contains a roaring bitmap of deleted
+  /// row positions. Nullopt if no rows have been deleted from this file.
+  /// Applies to both primary-key and append-only tables (when
+  /// deletion-vectors.enabled is set). Orthogonal to deleteRowCount —
+  /// deletionFile marks positional deletes, while deleteRowCount counts
+  /// RowKind-based changelog records.
+  /// See PaimonDeletionFile for details.
+  std::optional<PaimonDeletionFile> deletionFile;
+
+  std::string toString() const;
+  folly::dynamic serialize() const;
+  static PaimonDataFile create(const folly::dynamic& obj);
+};
+
+FOLLY_ALWAYS_INLINE std::ostream& operator<<(
+    std::ostream& os,
+    PaimonDataFile::Type type) {
+  os << PaimonDataFile::typeString(type);
+  return os;
+}
+
+FOLLY_ALWAYS_INLINE std::ostream& operator<<(
+    std::ostream& os,
+    PaimonDataFile::Source source) {
+  os << PaimonDataFile::sourceString(source);
+  return os;
+}
+
+} // namespace facebook::velox::connector::hive::paimon
+
+template <>
+struct fmt::formatter<
+    facebook::velox::connector::hive::paimon::PaimonDataFile::Type>
+    : formatter<std::string> {
+  auto format(
+      facebook::velox::connector::hive::paimon::PaimonDataFile::Type type,
+      format_context& ctx) const {
+    return formatter<std::string>::format(
+        facebook::velox::connector::hive::paimon::PaimonDataFile::typeString(
+            type),
+        ctx);
+  }
+};
+
+template <>
+struct fmt::formatter<
+    facebook::velox::connector::hive::paimon::PaimonDataFile::Source>
+    : formatter<std::string> {
+  auto format(
+      facebook::velox::connector::hive::paimon::PaimonDataFile::Source source,
+      format_context& ctx) const {
+    return formatter<std::string>::format(
+        facebook::velox::connector::hive::paimon::PaimonDataFile::sourceString(
+            source),
+        ctx);
+  }
+};
diff --git a/velox/connectors/hive/paimon/PaimonDataSource.cpp b/velox/connectors/hive/paimon/PaimonDataSource.cpp
new file mode 100644
index 00000000000..8ef7a14a9fc
--- /dev/null
+++ b/velox/connectors/hive/paimon/PaimonDataSource.cpp
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/connectors/hive/paimon/PaimonDataSource.h"
+
+#include "velox/common/Casts.h"
+#include "velox/connectors/hive/paimon/PaimonConnectorSplit.h"
+#include "velox/connectors/hive/paimon/PaimonSplitReader.h"
+
+namespace facebook::velox::connector::hive::paimon {
+
+PaimonDataSource::PaimonDataSource(
+    const RowTypePtr& outputType,
+    const ConnectorTableHandlePtr& tableHandle,
+    const ColumnHandleMap& assignments,
+    FileHandleFactory* fileHandleFactory,
+    folly::Executor* ioExecutor,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    const std::shared_ptr<PaimonConfig>& paimonConfig)
+    : FileDataSource(
+          outputType,
+          tableHandle,
+          assignments,
+          fileHandleFactory,
+          ioExecutor,
+          connectorQueryCtx,
+          paimonConfig) {}
+
+void PaimonDataSource::addSplit(std::shared_ptr<ConnectorSplit> split) {
+  paimonSplit_ = checkedPointerCast<PaimonConnectorSplit>(split);
+
+  if (!paimonSplit_->rawConvertible()) {
+    VELOX_NYI(
+        "Paimon merge-on-read is not yet implemented. "
+        "Primary-key tables with rawConvertible=false require merge-on-read "
+        "to deduplicate records across LSM levels.");
+  }
+
+  // Create a FileConnectorSplit for the first data file and delegate to
+  // FileDataSource::addSplit(), which calls createSplitReader() to create
+  // a PaimonSplitReader that handles all files internally.
+  const auto& firstFile = paimonSplit_->dataFiles().front();
+  auto firstFileSplit = std::make_shared<FileConnectorSplit>(
+      paimonSplit_->connectorId,
+      firstFile.path,
+      paimonSplit_->fileFormat(),
+      /*_start=*/0,
+      /*_length=*/std::numeric_limits<uint64_t>::max(),
+      /*splitWeight=*/0,
+      /*cacheable=*/true,
+      /*_properties=*/std::nullopt,
+      paimonSplit_->partitionKeys());
+
+  FileDataSource::addSplit(std::move(firstFileSplit));
+}
+
+std::unique_ptr<FileSplitReader> PaimonDataSource::createSplitReader() {
+  return std::make_unique<PaimonSplitReader>(
+      split_,
+      paimonSplit_,
+      tableHandle_,
+      &partitionKeys_,
+      connectorQueryCtx_,
+      fileConfig_,
+      readerOutputType_,
+      dataIoStats_,
+      metadataIoStats_,
+      ioStats_,
+      fileHandleFactory_,
+      ioExecutor_,
+      scanSpec_);
+}
+
+} // namespace facebook::velox::connector::hive::paimon
diff --git a/velox/connectors/hive/paimon/PaimonDataSource.h b/velox/connectors/hive/paimon/PaimonDataSource.h
new file mode 100644
index 00000000000..bad88951042
--- /dev/null
+++ b/velox/connectors/hive/paimon/PaimonDataSource.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/connectors/hive/FileDataSource.h"
+#include "velox/connectors/hive/paimon/PaimonConfig.h"
+
+namespace facebook::velox::connector::hive::paimon {
+
+class PaimonConnectorSplit;
+
+/// Paimon-specific data source that extends FileDataSource.
+///
+/// Acts as an orchestrator that selects the right reading strategy based on
+/// split properties:
+///
+///   rawConvertible=true (append-only or fully-compacted primary-key):
+///     Creates a PaimonSplitReader that handles multi-file iteration,
+///     deletion vectors, and _rowkind internally. FileDataSource::next()
+///     drives the read loop — no override needed.
+///
+///   rawConvertible=false (primary-key with overlapping keys):
+///     Merge path. A PaimonMergeReader opens all files simultaneously and
+///     performs a sorted merge by primary key, deduplicating by sequence
+///     number. Not yet implemented.
+class PaimonDataSource : public FileDataSource {
+ public:
+  PaimonDataSource(
+      const RowTypePtr& outputType,
+      const ConnectorTableHandlePtr& tableHandle,
+      const ColumnHandleMap& assignments,
+      FileHandleFactory* fileHandleFactory,
+      folly::Executor* ioExecutor,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      const std::shared_ptr<PaimonConfig>& paimonConfig);
+
+  void addSplit(std::shared_ptr<ConnectorSplit> split) override;
+
+ protected:
+  /// Creates a PaimonSplitReader with all data files from the Paimon split.
+  /// Called by FileDataSource::addSplit() during split initialization.
+  std::unique_ptr<FileSplitReader> createSplitReader() override;
+
+ private:
+  // The original Paimon split. Stored so createSplitReader() can access
+  // the full list of data files.
+  std::shared_ptr<PaimonConnectorSplit> paimonSplit_;
+};
+
+} // namespace facebook::velox::connector::hive::paimon
diff --git a/velox/connectors/hive/paimon/PaimonDeletionFile.cpp b/velox/connectors/hive/paimon/PaimonDeletionFile.cpp
new file mode 100644
index 00000000000..67ded98d65d
--- /dev/null
+++ b/velox/connectors/hive/paimon/PaimonDeletionFile.cpp
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/connectors/hive/paimon/PaimonDeletionFile.h"
+
+#include "velox/common/base/Exceptions.h"
+
+namespace facebook::velox::connector::hive::paimon {
+
+PaimonDeletionFile::PaimonDeletionFile(
+    std::string _path,
+    uint64_t _offset,
+    uint64_t _length,
+    uint64_t _cardinality)
+    : path(std::move(_path)),
+      offset(_offset),
+      length(_length),
+      cardinality(_cardinality) {
+  VELOX_CHECK_GT(length, 0, "PaimonDeletionFile length must be > 0");
+  VELOX_CHECK_GT(cardinality, 0, "PaimonDeletionFile cardinality must be > 0");
+}
+
+std::string PaimonDeletionFile::toString() const {
+  return fmt::format(
+      "{{path={}, offset={}, length={}, cardinality={}}}",
+      path,
+      offset,
+      length,
+      cardinality);
+}
+
+folly::dynamic PaimonDeletionFile::serialize() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["path"] = path;
+  obj["offset"] = offset;
+  obj["length"] = length;
+  obj["cardinality"] = cardinality;
+  return obj;
+}
+
+// static
+PaimonDeletionFile PaimonDeletionFile::create(const folly::dynamic& obj) {
+  return PaimonDeletionFile(
+      obj["path"].asString(),
+      static_cast<uint64_t>(obj["offset"].asInt()),
+      static_cast<uint64_t>(obj["length"].asInt()),
+      static_cast<uint64_t>(obj["cardinality"].asInt()));
+}
+
+} // namespace facebook::velox::connector::hive::paimon
diff --git a/velox/connectors/hive/paimon/PaimonDeletionFile.h b/velox/connectors/hive/paimon/PaimonDeletionFile.h
new file mode 100644
index 00000000000..671d4e1bd4f
--- /dev/null
+++ b/velox/connectors/hive/paimon/PaimonDeletionFile.h
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <fmt/format.h>
+#include <folly/dynamic.h>
+#include <cstdint>
+#include <string>
+
+namespace facebook::velox::connector::hive::paimon {
+
+/// Paimon deletion file — a serialized Roaring Bitmap tracking deleted row
+/// positions within an existing data file. Only used for primary-key tables
+/// with deletion-vectors.enabled=true. Append-only tables have no concept of
+/// row-level deletes (no primary key to identify specific rows).
+///
+/// # How Deletion Vectors Work
+///
+/// When a primary-key table has deletion vectors enabled, an UPDATE or DELETE
+/// does not rewrite the original data file. Instead:
+///   1. The new/updated record is written to a new L0 data file (as usual).
+///   2. A deletion bitmap is written marking the old row's position in the
+///      original data file (0-based row index).
+///   3. The reader loads the bitmap and skips those positions during scanning.
+///
+/// This improves read performance: without deletion vectors, the reader must
+/// do merge-on-read to discover that a key in an older file has been superseded
+/// by a newer file. With deletion vectors, the reader skips deleted rows
+/// immediately — no merge needed. A split with deletion vectors can be
+/// rawConvertible=true because the bitmaps already tell the reader which rows
+/// to skip (old and new values don't overlap from the reader's perspective).
+///
+/// Similar to Iceberg's positional delete files.
+///
+/// # Manifest Integration
+///
+/// When deletion vectors are written, Paimon creates a new snapshot with
+/// updated manifest entries for the affected data file:
+///   REMOVE: old manifest entry (without or with old deletion file)
+///   ADD:    same data file, now with deletion file reference attached
+/// The data file itself is NOT rewritten — only the manifest entry changes.
+///
+/// Each data file has at most ONE deletion file at any point in time. If more
+/// rows are deleted later, the bitmap is replaced with a new one containing
+/// all deleted positions (old + new, merged). The old bitmap becomes obsolete.
+///
+/// Deletion files can be attached to data files at ANY LSM level (L0, L1,
+/// L2, etc.), not just L0.
+///
+/// # File Format
+///
+/// Deletion files are NOT stored in a columnar format (not Parquet/ORC/Nimble)
+/// and not in a row-based format (not compact row). They use a custom binary
+/// format:
+///   - Core payload: standard RoaringBitmap portable binary serialization
+///     (cross-language spec from RoaringFormatSpec). C++ can read this with
+///     the CRoaring library; Java uses org.roaringbitmap.RoaringBitmap.
+///   - Container packing: when multiple bitmaps are packed into a single file,
+///     Paimon uses a simple custom binary layout with length-prefixed entries
+///     mapping data file names to their bitmap bytes.
+///
+/// Each bitmap contains 0-based row positions of deleted rows within its
+/// associated data file.
+///
+/// Multiple deletion bitmaps can be packed into a single container file.
+/// 'offset' and 'length' specify the byte range within the container where
+/// this bitmap's data lives. For standalone deletion files, offset is 0 and
+/// length equals the file size.
+///
+/// # Relationship to RowKind-Based Deletes
+///
+/// Deletion files are orthogonal to RowKind-based deletes:
+///
+///   RowKind=-D: A full record written to a NEW data file at level 0,
+///     containing the key + all column values tagged with -D. Used for logical
+///     deletes (CDC source, SQL DELETE). Compaction resolves it by removing the
+///     key entirely.
+///
+///   Deletion file (this struct): A bitmap referencing row positions in an
+///     EXISTING data file. No new data record written. Used as a physical
+///     optimization to avoid rewriting files during compaction or partial
+///     deletes.
+///
+/// For batch reads, the reader loads deletion bitmaps and filters out deleted
+/// row positions during scanning.
+struct PaimonDeletionFile {
+  /// @param path Path to the deletion file.
+  /// @param offset Byte offset within the container file.
+  /// @param length Number of bytes of bitmap data (must be > 0).
+  /// @param cardinality Number of deleted rows (must be > 0).
+  PaimonDeletionFile(
+      std::string path,
+      uint64_t offset,
+      uint64_t length,
+      uint64_t cardinality);
+
+  std::string path;
+
+  // Byte offset within the container file where this bitmap starts.
+  uint64_t offset;
+
+  // Number of bytes of bitmap data. Must be > 0.
+  uint64_t length;
+
+  // Number of deleted rows (pre-computed for stats without reading bitmap).
+  // Must be > 0.
+  uint64_t cardinality;
+
+  std::string toString() const;
+  folly::dynamic serialize() const;
+  static PaimonDeletionFile create(const folly::dynamic& obj);
+};
+
+} // namespace facebook::velox::connector::hive::paimon
diff --git a/velox/connectors/hive/paimon/PaimonRowKind.cpp b/velox/connectors/hive/paimon/PaimonRowKind.cpp
new file mode 100644
index 00000000000..cfa2d156067
--- /dev/null
+++ b/velox/connectors/hive/paimon/PaimonRowKind.cpp
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/connectors/hive/paimon/PaimonRowKind.h"
+
+#include "velox/common/base/Exceptions.h"
+
+namespace facebook::velox::connector::hive::paimon {
+
+std::string paimonRowKindString(PaimonRowKind kind) {
+  switch (kind) {
+    case PaimonRowKind::kInsert:
+      return "+I";
+    case PaimonRowKind::kUpdateBefore:
+      return "-U";
+    case PaimonRowKind::kUpdateAfter:
+      return "+U";
+    case PaimonRowKind::kDelete:
+      return "-D";
+    default:
+      VELOX_FAIL("Unknown PaimonRowKind: {}", static_cast<int>(kind));
+  }
+}
+
+PaimonRowKind paimonRowKindFromValue(int8_t value) {
+  switch (value) {
+    case 0:
+      return PaimonRowKind::kInsert;
+    case 1:
+      return PaimonRowKind::kUpdateBefore;
+    case 2:
+      return PaimonRowKind::kUpdateAfter;
+    case 3:
+      return PaimonRowKind::kDelete;
+    default:
+      VELOX_FAIL("Unknown PaimonRowKind value: {}", value);
+  }
+}
+
+std::string paimonChangelogModeString(PaimonChangelogMode mode) {
+  switch (mode) {
+    case PaimonChangelogMode::kNone:
+      return "NONE";
+    case PaimonChangelogMode::kInput:
+      return "INPUT";
+    case PaimonChangelogMode::kLookup:
+      return "LOOKUP";
+    case PaimonChangelogMode::kFullCompaction:
+      return "FULL_COMPACTION";
+    default:
+      VELOX_FAIL("Unknown PaimonChangelogMode: {}", static_cast<int>(mode));
+  }
+}
+
+PaimonChangelogMode paimonChangelogModeFromString(const std::string& str) {
+  if (str == "NONE") {
+    return PaimonChangelogMode::kNone;
+  }
+  if (str == "INPUT") {
+    return PaimonChangelogMode::kInput;
+  }
+  if (str == "LOOKUP") {
+    return PaimonChangelogMode::kLookup;
+  }
+  if (str == "FULL_COMPACTION") {
+    return PaimonChangelogMode::kFullCompaction;
+  }
+  VELOX_FAIL("Unknown PaimonChangelogMode: {}", str);
+}
+
+} // namespace facebook::velox::connector::hive::paimon
diff --git a/velox/connectors/hive/paimon/PaimonRowKind.h b/velox/connectors/hive/paimon/PaimonRowKind.h
new file mode 100644
index 00000000000..4c1546696b0
--- /dev/null
+++ b/velox/connectors/hive/paimon/PaimonRowKind.h
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <fmt/format.h>
+#include <cstdint>
+#include <ostream>
+#include <string>
+
+#include <folly/CPortability.h>
+
+namespace facebook::velox::connector::hive::paimon {
+
+/// Name of the hidden system column that stores the change type per row.
+/// Only present in primary-key table files — append-only tables do not
+/// have this column (every row is implicitly +I).
+/// At the file format level (Parquet, ORC, Nimble), this is a regular
+/// TINYINT column — the file format has no special knowledge of it.
+/// It is "hidden" only at the SQL layer (not shown in SELECT *).
+static constexpr std::string_view kRowKindColumn = "_rowkind";
+
+/// Row-level change type stored in the `_rowkind` column.
+/// Values match the Paimon Java RowKind enum (0-3).
+///
+/// Only meaningful for primary-key tables. Append-only tables have no
+/// concept of updates or deletes — every row is implicitly +I.
+enum class PaimonRowKind : int8_t {
+  /// +I: New row inserted.
+  kInsert = 0,
+  /// -U: Old value being replaced (retraction). Always followed by +U.
+  kUpdateBefore = 1,
+  /// +U: New value replacing the old one. Always preceded by -U.
+  kUpdateAfter = 2,
+  /// -D: Row deleted. Carries the full before-image (all column values).
+  kDelete = 3,
+};
+
+std::string paimonRowKindString(PaimonRowKind kind);
+PaimonRowKind paimonRowKindFromValue(int8_t value);
+
+FOLLY_ALWAYS_INLINE std::ostream& operator<<(
+    std::ostream& os,
+    PaimonRowKind kind) {
+  os << paimonRowKindString(kind);
+  return os;
+}
+
+/// Changelog mode determines how a table produces changelog records and
+/// whether `_rowkind` is physically stored in data files. This is a
+/// table-level property set via the `changelog-producer` option.
+/// Only meaningful for primary-key tables — append-only tables have no
+/// updates or deletes, so every row is implicitly +I regardless of this
+/// setting.
+///
+/// # _rowkind Presence in Files
+///
+///   Mode             | Data files  | Changelog files (from compaction)
+///   -----------------+-------------+----------------------------------
+///   kNone            | No          | N/A (no changelog files produced)
+///   kInput           | Yes         | Yes
+///   kLookup          | No          | Yes
+///   kFullCompaction   | No          | Yes
+///
+/// For batch reads, `_rowkind` is not needed — the reader returns
+/// current state, not changelog. This enum becomes relevant for streaming.
+enum class PaimonChangelogMode {
+  /// Default for primary-key tables. No changelog producer configured.
+  /// Data files do NOT contain `_rowkind`. Compaction does NOT generate
+  /// changelog files. Streaming reads emit all delta rows as +I (cannot
+  /// distinguish INSERT from UPDATE).
+  kNone,
+  /// Source provides RowKind explicitly (CDC/input changelog).
+  /// Data files DO contain `_rowkind` for every row.
+  kInput,
+  /// Compactor generates changelog files by looking up old values during
+  /// every compaction (both partial and full). Data files do NOT contain
+  /// `_rowkind`, but changelog files do. Provides low-latency changelog
+  /// for streaming consumers at the cost of higher write amplification.
+  kLookup,
+  /// Same mechanism as kLookup (looking up old values to produce changelog),
+  /// but changelog files are only generated during full compaction — partial
+  /// compactions do NOT produce changelog. Between full compactions,
+  /// streaming consumers get degraded output (all rows emitted as +I).
+  /// Lower write cost than kLookup, but higher changelog latency.
+  kFullCompaction,
+};
+
+std::string paimonChangelogModeString(PaimonChangelogMode mode);
+PaimonChangelogMode paimonChangelogModeFromString(const std::string& str);
+
+FOLLY_ALWAYS_INLINE std::ostream& operator<<(
+    std::ostream& os,
+    PaimonChangelogMode mode) {
+  os << paimonChangelogModeString(mode);
+  return os;
+}
+
+} // namespace facebook::velox::connector::hive::paimon
+
+template <>
+struct fmt::formatter<facebook::velox::connector::hive::paimon::PaimonRowKind>
+    : formatter<std::string> {
+  auto format(
+      facebook::velox::connector::hive::paimon::PaimonRowKind kind,
+      format_context& ctx) const {
+    return formatter<std::string>::format(
+        facebook::velox::connector::hive::paimon::paimonRowKindString(kind),
+        ctx);
+  }
+};
+
+template <>
+struct fmt::formatter<
+    facebook::velox::connector::hive::paimon::PaimonChangelogMode>
+    : formatter<std::string> {
+  auto format(
+      facebook::velox::connector::hive::paimon::PaimonChangelogMode mode,
+      format_context& ctx) const {
+    return formatter<std::string>::format(
+        facebook::velox::connector::hive::paimon::paimonChangelogModeString(
+            mode),
+        ctx);
+  }
+};
diff --git a/velox/connectors/hive/paimon/PaimonSplitReader.cpp b/velox/connectors/hive/paimon/PaimonSplitReader.cpp
new file mode 100644
index 00000000000..446e47897dc
--- /dev/null
+++ b/velox/connectors/hive/paimon/PaimonSplitReader.cpp
@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/connectors/hive/paimon/PaimonSplitReader.h"
+
+#include <limits>
+
+namespace facebook::velox::connector::hive::paimon {
+
+PaimonSplitReader::PaimonSplitReader(
+    const std::shared_ptr<const FileConnectorSplit>& fileSplit,
+    std::shared_ptr<const PaimonConnectorSplit> paimonSplit,
+    const FileTableHandlePtr& tableHandle,
+    const std::unordered_map<std::string, FileColumnHandlePtr>* partitionKeys,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    const std::shared_ptr<const FileConfig>& fileConfig,
+    const RowTypePtr& readerOutputType,
+    const std::shared_ptr<io::IoStatistics>& dataIoStats,
+    const std::shared_ptr<io::IoStatistics>& metadataIoStats,
+    const std::shared_ptr<IoStats>& ioStats,
+    FileHandleFactory* fileHandleFactory,
+    folly::Executor* executor,
+    const std::shared_ptr<common::ScanSpec>& scanSpec)
+    : FileSplitReader(
+          fileSplit,
+          tableHandle,
+          partitionKeys,
+          connectorQueryCtx,
+          fileConfig,
+          readerOutputType,
+          dataIoStats,
+          metadataIoStats,
+          ioStats,
+          fileHandleFactory,
+          executor,
+          scanSpec),
+      paimonSplit_(std::move(paimonSplit)) {
+  // Validate all data files upfront.
+  for (const auto& dataFile : paimonSplit_->dataFiles()) {
+    VELOX_CHECK(
+        !dataFile.deletionFile.has_value(),
+        "Paimon deletion vector reading is not yet implemented. "
+        "File '{}' has a deletion vector with {} deleted rows.",
+        dataFile.path,
+        dataFile.deletionFile.has_value() ? dataFile.deletionFile->cardinality
+                                          : 0);
+    VELOX_CHECK_EQ(
+        dataFile.type,
+        PaimonDataFile::Type::kData,
+        "Paimon changelog file reading is not yet supported. "
+        "File '{}' has type {}.",
+        dataFile.path,
+        dataFile.type);
+  }
+
+  // Build FileConnectorSplits for all data files so we can switch between
+  // them during multi-file iteration.
+  const auto& dataFiles = paimonSplit_->dataFiles();
+  fileSplits_.reserve(dataFiles.size());
+  for (const auto& dataFile : dataFiles) {
+    fileSplits_.emplace_back(makeFileConnectorSplit(dataFile));
+  }
+}
+
+void PaimonSplitReader::prepareSplit(
+    std::shared_ptr<common::MetadataFilter> metadataFilter,
+    dwio::common::RuntimeStatistics& runtimeStats,
+    const folly::F14FastMap<std::string, std::string>& /*fileReadOps*/) {
+  // Save for re-use when advancing to subsequent files.
+  metadataFilter_ = std::move(metadataFilter);
+  runtimeStats_ = &runtimeStats;
+}
+
+uint64_t PaimonSplitReader::next(uint64_t size, VectorPtr& output) {
+  while (ensureFileSplitReader()) {
+    // When deletion vectors are implemented, apply the deletion bitmap
+    // here via Mutation.deletedRows, following the same pattern as
+    // IcebergSplitReader::next().
+    const auto rowsRead = FileSplitReader::next(size, output);
+    if (rowsRead > 0) {
+      return rowsRead;
+    }
+    // Current file exhausted, try the next one.
+    finishFileSplitReader();
+  }
+  return 0;
+}
+
+bool PaimonSplitReader::ensureFileSplitReader() {
+  if (baseReader_ != nullptr) {
+    VELOX_CHECK_NOT_NULL(baseRowReader_);
+    return true;
+  }
+  VELOX_CHECK_NULL(baseRowReader_);
+
+  while (currentFileIndex_ < fileSplits_.size()) {
+    // Point to the current file.
+    fileSplit_ = fileSplits_[currentFileIndex_];
+
+    // Initialize the base reader for this file.
+    FileSplitReader::prepareSplit(metadataFilter_, *runtimeStats_);
+    if (!emptySplit_) {
+      return true;
+    }
+    ++currentFileIndex_;
+  }
+  return false; // All files exhausted.
+}
+
+void PaimonSplitReader::finishFileSplitReader() {
+  VELOX_CHECK_LT(currentFileIndex_, fileSplits_.size());
+  VELOX_CHECK_NOT_NULL(baseReader_);
+  VELOX_CHECK_NOT_NULL(baseRowReader_);
+  ++currentFileIndex_;
+  baseReader_ = nullptr;
+  baseRowReader_ = nullptr;
+  emptySplit_ = false;
+}
+
+std::shared_ptr<FileConnectorSplit> PaimonSplitReader::makeFileConnectorSplit(
+    const PaimonDataFile& dataFile) const {
+  return std::make_shared<FileConnectorSplit>(
+      paimonSplit_->connectorId,
+      dataFile.path,
+      paimonSplit_->fileFormat(),
+      /*_start=*/0,
+      /*_length=*/std::numeric_limits<uint64_t>::max(),
+      /*splitWeight=*/0,
+      /*cacheable=*/true,
+      /*_properties=*/std::nullopt,
+      paimonSplit_->partitionKeys());
+}
+
+} // namespace facebook::velox::connector::hive::paimon
diff --git a/velox/connectors/hive/paimon/PaimonSplitReader.h b/velox/connectors/hive/paimon/PaimonSplitReader.h
new file mode 100644
index 00000000000..c21e660ee2b
--- /dev/null
+++ b/velox/connectors/hive/paimon/PaimonSplitReader.h
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/connectors/hive/FileSplitReader.h"
+#include "velox/connectors/hive/paimon/PaimonConnectorSplit.h"
+
+namespace facebook::velox::connector::hive::paimon {
+
+/// Reader for rawConvertible Paimon splits. Extends FileSplitReader to handle
+/// Paimon-specific concerns:
+///
+///   - Multi-file iteration: A single Paimon split may contain multiple data
+///     files (one per LSM level in a bucket). This reader iterates through
+///     all files sequentially, transparently advancing to the next file when
+///     the current one is exhausted.
+///
+///   - Deletion vectors: Roaring bitmaps marking deleted row positions within
+///     a data file. Loaded in prepareSplit(), applied in next() via
+///     Mutation.deletedRows (same pattern as IcebergSplitReader). (NYI)
+///
+///   - _rowkind system column: Change type (+I/-U/+U/-D) for changelog files
+///     and input changelog mode. Handled in adaptColumns(). (NYI)
+///
+/// Also serves as the building block for PaimonMergeReader, which composes
+/// multiple PaimonSplitReaders to perform merge-on-read for primary-key
+/// tables with rawConvertible=false.
+class PaimonSplitReader : public FileSplitReader {
+ public:
+  /// @param fileSplit FileConnectorSplit for the first data file (set by
+  ///        FileDataSource::addSplit before calling createSplitReader).
+  /// @param paimonSplit The full Paimon split. PaimonSplitReader builds
+  ///        FileConnectorSplits for all data files internally.
+  PaimonSplitReader(
+      const std::shared_ptr<const FileConnectorSplit>& fileSplit,
+      std::shared_ptr<const PaimonConnectorSplit> paimonSplit,
+      const FileTableHandlePtr& tableHandle,
+      const std::unordered_map<std::string, FileColumnHandlePtr>* partitionKeys,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      const std::shared_ptr<const FileConfig>& fileConfig,
+      const RowTypePtr& readerOutputType,
+      const std::shared_ptr<io::IoStatistics>& dataIoStats,
+      const std::shared_ptr<io::IoStatistics>& metadataIoStats,
+      const std::shared_ptr<IoStats>& ioStats,
+      FileHandleFactory* fileHandleFactory,
+      folly::Executor* executor,
+      const std::shared_ptr<common::ScanSpec>& scanSpec);
+
+  ~PaimonSplitReader() override = default;
+
+  /// Saves metadata filter and runtime stats for use by
+  /// ensureFileSplitReader(). File validation is done in the constructor.
+  void prepareSplit(
+      std::shared_ptr<common::MetadataFilter> metadataFilter,
+      dwio::common::RuntimeStatistics& runtimeStats,
+      const folly::F14FastMap<std::string, std::string>& fileReadOps = {})
+      override;
+
+  /// Reads from the current file. When a file is exhausted, transparently
+  /// advances to the next file in the split. Returns 0 only when all files
+  /// are exhausted.
+  uint64_t next(uint64_t size, VectorPtr& output) override;
+
+ private:
+  // Builds a FileConnectorSplit from a PaimonDataFile.
+  std::shared_ptr<FileConnectorSplit> makeFileConnectorSplit(
+      const PaimonDataFile& dataFile) const;
+
+  // Ensures a file split reader is ready to produce rows. If the current
+  // reader is exhausted, advances to the next non-empty file. Returns true
+  // if a reader is ready, false when all files are exhausted.
+  bool ensureFileSplitReader();
+
+  // Cleans up the current file reader after it is exhausted and advances
+  // currentFileIndex_ so ensureFileSplitReader() opens the next file.
+  void finishFileSplitReader();
+
+  const std::shared_ptr<const PaimonConnectorSplit> paimonSplit_;
+
+  // FileConnectorSplits built from paimonSplit_->dataFiles(), one per file.
+  // Used to switch the base reader between files during iteration.
+  std::vector<std::shared_ptr<FileConnectorSplit>> fileSplits_;
+
+  // Index of the next data file to open.
+  size_t currentFileIndex_{0};
+
+  // Saved from prepareSplit() for re-use when advancing to subsequent files.
+  std::shared_ptr<common::MetadataFilter> metadataFilter_;
+  dwio::common::RuntimeStatistics* runtimeStats_{nullptr};
+};
+
+} // namespace facebook::velox::connector::hive::paimon
diff --git a/velox/connectors/hive/paimon/tests/CMakeLists.txt b/velox/connectors/hive/paimon/tests/CMakeLists.txt
new file mode 100644
index 00000000000..f8265678b67
--- /dev/null
+++ b/velox/connectors/hive/paimon/tests/CMakeLists.txt
@@ -0,0 +1,60 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+if(NOT VELOX_DISABLE_GOOGLETEST)
+  add_executable(velox_hive_paimon_split_test PaimonConnectorSplitTest.cpp)
+  add_test(velox_hive_paimon_split_test velox_hive_paimon_split_test)
+
+  target_link_libraries(
+    velox_hive_paimon_split_test
+    velox_hive_paimon_split
+    velox_dwio_common
+    GTest::gtest
+    GTest::gtest_main
+    GTest::gmock
+  )
+
+  add_executable(velox_hive_paimon_data_file_meta_test PaimonDataFileMetaTest.cpp)
+  add_test(velox_hive_paimon_data_file_meta_test velox_hive_paimon_data_file_meta_test)
+
+  target_link_libraries(
+    velox_hive_paimon_data_file_meta_test
+    velox_hive_paimon_split
+    GTest::gtest
+    GTest::gtest_main
+    GTest::gmock
+  )
+
+  add_executable(velox_hive_paimon_deletion_file_test PaimonDeletionFileTest.cpp)
+  add_test(velox_hive_paimon_deletion_file_test velox_hive_paimon_deletion_file_test)
+
+  target_link_libraries(
+    velox_hive_paimon_deletion_file_test
+    velox_hive_paimon_split
+    GTest::gtest
+    GTest::gtest_main
+    GTest::gmock
+  )
+
+  add_executable(velox_hive_paimon_row_kind_test PaimonRowKindTest.cpp)
+  add_test(velox_hive_paimon_row_kind_test velox_hive_paimon_row_kind_test)
+
+  target_link_libraries(
+    velox_hive_paimon_row_kind_test
+    velox_hive_paimon_split
+    GTest::gtest
+    GTest::gtest_main
+    fmt::fmt
+  )
+endif()
diff --git a/velox/connectors/hive/paimon/tests/PaimonConnectorSplitTest.cpp b/velox/connectors/hive/paimon/tests/PaimonConnectorSplitTest.cpp
new file mode 100644
index 00000000000..0ebb2680fd7
--- /dev/null
+++ b/velox/connectors/hive/paimon/tests/PaimonConnectorSplitTest.cpp
@@ -0,0 +1,373 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/connectors/hive/paimon/PaimonConnectorSplit.h"
+
+#include <fmt/format.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <sstream>
+
+#include "velox/common/base/tests/GTestUtils.h"
+
+using namespace facebook::velox::connector::hive::paimon;
+using namespace facebook::velox;
+using namespace facebook::velox::dwio::common;
+
+namespace {
+using PartitionKeys =
+    std::unordered_map<std::string, std::optional<std::string>>;
+} // namespace
+
+class PaimonConnectorSplitTest : public testing::Test {
+ protected:
+  const std::string kConnectorId{"test-connector"};
+};
+
+TEST_F(PaimonConnectorSplitTest, basic) {
+  PaimonDataFile file0;
+  file0.path = "s3://bucket/table/dt=2024-01-01/bucket-0/data-001.orc";
+  file0.size = 1024;
+  file0.rowCount = 100;
+  file0.level = 0;
+
+  PaimonDataFile file1;
+  file1.path = "s3://bucket/table/dt=2024-01-01/bucket-0/data-002.orc";
+  file1.size = 2048;
+  file1.rowCount = 200;
+  file1.level = 1;
+
+  std::vector<PaimonDataFile> files{file0, file1};
+  PartitionKeys partitionKeys{{"dt", "2024-01-01"}};
+
+  auto split = std::make_shared<PaimonConnectorSplit>(
+      kConnectorId,
+      /*snapshotId=*/1,
+      PaimonTableType::kPrimaryKey,
+      FileFormat::DWRF,
+      files,
+      partitionKeys,
+      0);
+
+  EXPECT_EQ(split->snapshotId(), 1);
+  EXPECT_EQ(split->tableType(), PaimonTableType::kPrimaryKey);
+  EXPECT_EQ(split->fileFormat(), FileFormat::DWRF);
+  EXPECT_TRUE(split->rawConvertible());
+  EXPECT_EQ(split->tableBucketNumber(), 0);
+  ASSERT_EQ(split->dataFiles().size(), 2);
+  EXPECT_EQ(split->dataFiles()[0].path, files[0].path);
+  EXPECT_EQ(split->dataFiles()[0].size, 1024);
+  EXPECT_EQ(split->dataFiles()[1].path, files[1].path);
+  EXPECT_EQ(split->dataFiles()[1].size, 2048);
+  ASSERT_EQ(split->partitionKeys().count("dt"), 1);
+  EXPECT_EQ(split->partitionKeys().at("dt"), "2024-01-01");
+}
+
+TEST_F(PaimonConnectorSplitTest, nimbleFormat) {
+  PaimonDataFile file0;
+  file0.path = "s3://bucket/table/data-001.nimble";
+  file0.size = 4096;
+  file0.rowCount = 100;
+  std::vector<PaimonDataFile> files{file0};
+
+  auto split = std::make_shared<PaimonConnectorSplit>(
+      kConnectorId,
+      /*snapshotId=*/1,
+      PaimonTableType::kAppendOnly,
+      FileFormat::NIMBLE,
+      files,
+      PartitionKeys{},
+      std::nullopt);
+
+  ASSERT_EQ(split->dataFiles().size(), 1);
+  EXPECT_EQ(split->tableType(), PaimonTableType::kAppendOnly);
+  EXPECT_EQ(split->fileFormat(), FileFormat::NIMBLE);
+}
+
+TEST_F(PaimonConnectorSplitTest, parquetFormat) {
+  PaimonDataFile file0;
+  file0.path = "s3://bucket/table/data-001.parquet";
+  file0.size = 4096;
+  file0.rowCount = 100;
+  std::vector<PaimonDataFile> files{file0};
+
+  auto split = std::make_shared<PaimonConnectorSplit>(
+      kConnectorId,
+      /*snapshotId=*/1,
+      PaimonTableType::kAppendOnly,
+      FileFormat::PARQUET,
+      files,
+      PartitionKeys{},
+      std::nullopt);
+
+  ASSERT_EQ(split->dataFiles().size(), 1);
+  EXPECT_EQ(split->fileFormat(), FileFormat::PARQUET);
+}
+
+TEST_F(PaimonConnectorSplitTest, emptyFilesThrows) {
+  std::vector<PaimonDataFile> noFiles;
+  VELOX_ASSERT_THROW(
+      std::make_shared<PaimonConnectorSplit>(
+          kConnectorId,
+          /*snapshotId=*/1,
+          PaimonTableType::kAppendOnly,
+          FileFormat::NIMBLE,
+          noFiles,
+          PartitionKeys{},
+          std::nullopt),
+      "PaimonConnectorSplit requires non-empty dataFiles");
+}
+
+TEST_F(PaimonConnectorSplitTest, rawConvertibleWithDeleteRowCountThrows) {
+  PaimonDataFile file;
+  file.path = "data-001.orc";
+  file.size = 1024;
+  file.rowCount = 100;
+  file.level = 1;
+  file.deleteRowCount = 5;
+
+  std::vector<PaimonDataFile> files{file};
+  VELOX_ASSERT_THROW(
+      std::make_shared<PaimonConnectorSplit>(
+          kConnectorId,
+          /*snapshotId=*/1,
+          PaimonTableType::kPrimaryKey,
+          FileFormat::DWRF,
+          files,
+          PartitionKeys{},
+          std::nullopt,
+          /*rawConvertible=*/true),
+      "rawConvertible split cannot have files with deleteRowCount > 0");
+}
+
+TEST_F(PaimonConnectorSplitTest, notRawConvertibleWithDeleteRowCount) {
+  PaimonDataFile file;
+  file.path = "data-001.orc";
+  file.size = 1024;
+  file.rowCount = 100;
+  file.level = 1;
+  file.deleteRowCount = 5;
+
+  std::vector<PaimonDataFile> files{file};
+  auto split = std::make_shared<PaimonConnectorSplit>(
+      kConnectorId,
+      /*snapshotId=*/1,
+      PaimonTableType::kPrimaryKey,
+      FileFormat::DWRF,
+      files,
+      PartitionKeys{},
+      std::nullopt,
+      /*rawConvertible=*/false);
+
+  EXPECT_FALSE(split->rawConvertible());
+  EXPECT_EQ(split->dataFiles()[0].deleteRowCount, 5);
+}
+
+TEST_F(PaimonConnectorSplitTest, toStringOutput) {
+  PaimonDataFile f0;
+  f0.path = "data-001.orc";
+  f0.size = 1024;
+  f0.rowCount = 100;
+
+  PaimonDataFile f1;
+  f1.path = "data-002.orc";
+  f1.size = 2048;
+  f1.rowCount = 200;
+  f1.level = 1;
+
+  PaimonDataFile f2;
+  f2.path = "data-003.orc";
+  f2.size = 512;
+  f2.rowCount = 50;
+  f2.level = 2;
+
+  std::vector<PaimonDataFile> files{f0, f1, f2};
+
+  auto split = std::make_shared<PaimonConnectorSplit>(
+      kConnectorId,
+      /*snapshotId=*/42,
+      PaimonTableType::kPrimaryKey,
+      FileFormat::DWRF,
+      files,
+      PartitionKeys{},
+      std::nullopt);
+
+  EXPECT_THAT(split->toString(), testing::HasSubstr("snapshot 42"));
+  EXPECT_THAT(split->toString(), testing::HasSubstr("PRIMARY_KEY"));
+  EXPECT_THAT(split->toString(), testing::HasSubstr(kConnectorId));
+  EXPECT_THAT(split->toString(), testing::HasSubstr("data-001.orc"));
+  EXPECT_THAT(split->toString(), testing::HasSubstr("data-003.orc"));
+  EXPECT_THAT(split->toString(), testing::HasSubstr("size=1024"));
+  EXPECT_THAT(split->toString(), testing::HasSubstr("rows=100"));
+  EXPECT_THAT(split->toString(), testing::HasSubstr("level=1"));
+  EXPECT_THAT(split->toString(), testing::HasSubstr("deletionFile=none"));
+}
+
+TEST_F(PaimonConnectorSplitTest, nullPartitionValue) {
+  PaimonDataFile file0;
+  file0.path = "data-001.orc";
+  file0.size = 1024;
+  file0.rowCount = 100;
+  std::vector<PaimonDataFile> files{file0};
+  PartitionKeys partitionKeys{{"country", std::nullopt}};
+
+  auto split = std::make_shared<PaimonConnectorSplit>(
+      kConnectorId,
+      /*snapshotId=*/1,
+      PaimonTableType::kAppendOnly,
+      FileFormat::DWRF,
+      files,
+      partitionKeys,
+      std::nullopt);
+
+  ASSERT_EQ(split->partitionKeys().count("country"), 1);
+  EXPECT_EQ(split->partitionKeys().at("country"), std::nullopt);
+}
+
+TEST_F(PaimonConnectorSplitTest, builder) {
+  auto split = PaimonConnectorSplitBuilder(
+                   kConnectorId,
+                   /*snapshotId=*/5,
+                   PaimonTableType::kPrimaryKey,
+                   FileFormat::PARQUET)
+                   .addFile("s3://bucket/data-001.parquet", 1024, 0)
+                   .addFile("s3://bucket/data-002.parquet", 2048, 1)
+                   .partitionKey("dt", "2024-01-01")
+                   .partitionKey("country", std::nullopt)
+                   .tableBucketNumber(3)
+                   .build();
+
+  EXPECT_EQ(split->snapshotId(), 5);
+  EXPECT_EQ(split->fileFormat(), FileFormat::PARQUET);
+  EXPECT_TRUE(split->rawConvertible());
+
+  ASSERT_EQ(split->dataFiles().size(), 2);
+  EXPECT_EQ(split->dataFiles()[0].path, "s3://bucket/data-001.parquet");
+  EXPECT_EQ(split->dataFiles()[0].size, 1024);
+  EXPECT_EQ(split->dataFiles()[1].path, "s3://bucket/data-002.parquet");
+  EXPECT_EQ(split->dataFiles()[1].size, 2048);
+  EXPECT_EQ(split->tableBucketNumber(), 3);
+  EXPECT_EQ(split->partitionKeys().at("dt"), "2024-01-01");
+  EXPECT_EQ(split->partitionKeys().at("country"), std::nullopt);
+}
+
+TEST_F(PaimonConnectorSplitTest, builderDefaults) {
+  auto split = PaimonConnectorSplitBuilder(
+                   kConnectorId,
+                   /*snapshotId=*/1,
+                   PaimonTableType::kAppendOnly,
+                   FileFormat::NIMBLE)
+                   .addFile("data.nimble", 512)
+                   .build();
+
+  ASSERT_EQ(split->dataFiles().size(), 1);
+  EXPECT_EQ(split->fileFormat(), FileFormat::NIMBLE);
+  EXPECT_EQ(split->tableBucketNumber(), std::nullopt);
+  EXPECT_TRUE(split->partitionKeys().empty());
+}
+
+TEST_F(PaimonConnectorSplitTest, serializeRoundTrip) {
+  PaimonDataFile meta;
+  meta.path = "s3://bucket/data-001.parquet";
+  meta.size = 4096;
+  meta.rowCount = 1000;
+  meta.level = 2;
+  meta.minSequenceNumber = 10;
+  meta.maxSequenceNumber = 20;
+  meta.deleteRowCount = 5;
+  meta.creationTimeMs = 1700000000;
+  meta.source = PaimonDataFile::Source::kCompact;
+  meta.deletionFile =
+      PaimonDeletionFile{"s3://bucket/deletion-001.bin", 0, 128, 5};
+
+  std::vector<PaimonDataFile> files{meta};
+  PartitionKeys partitionKeys{{"dt", "2024-01-01"}, {"country", std::nullopt}};
+
+  auto original = std::make_shared<PaimonConnectorSplit>(
+      kConnectorId,
+      /*snapshotId=*/42,
+      PaimonTableType::kPrimaryKey,
+      FileFormat::PARQUET,
+      files,
+      partitionKeys,
+      /*tableBucketNumber=*/7,
+      /*rawConvertible=*/false);
+
+  auto serialized = original->serialize();
+  auto deserialized = PaimonConnectorSplit::create(serialized);
+
+  EXPECT_EQ(deserialized->connectorId, kConnectorId);
+  EXPECT_EQ(deserialized->snapshotId(), 42);
+  EXPECT_EQ(deserialized->tableType(), PaimonTableType::kPrimaryKey);
+  EXPECT_EQ(deserialized->fileFormat(), FileFormat::PARQUET);
+  EXPECT_FALSE(deserialized->rawConvertible());
+  EXPECT_EQ(deserialized->tableBucketNumber(), 7);
+
+  ASSERT_EQ(deserialized->dataFiles().size(), 1);
+  const auto& file = deserialized->dataFiles()[0];
+  EXPECT_EQ(file.path, "s3://bucket/data-001.parquet");
+  EXPECT_EQ(file.size, 4096);
+  EXPECT_EQ(file.rowCount, 1000);
+  EXPECT_EQ(file.level, 2);
+  EXPECT_EQ(file.minSequenceNumber, 10);
+  EXPECT_EQ(file.maxSequenceNumber, 20);
+  EXPECT_EQ(file.deleteRowCount, 5);
+  EXPECT_EQ(file.creationTimeMs, 1700000000);
+  EXPECT_EQ(file.source, PaimonDataFile::Source::kCompact);
+
+  ASSERT_TRUE(file.deletionFile.has_value());
+  EXPECT_EQ(file.deletionFile->path, "s3://bucket/deletion-001.bin");
+  EXPECT_EQ(file.deletionFile->offset, 0);
+  EXPECT_EQ(file.deletionFile->length, 128);
+  EXPECT_EQ(file.deletionFile->cardinality, 5);
+
+  ASSERT_EQ(deserialized->partitionKeys().count("dt"), 1);
+  EXPECT_EQ(deserialized->partitionKeys().at("dt"), "2024-01-01");
+  ASSERT_EQ(deserialized->partitionKeys().count("country"), 1);
+  EXPECT_EQ(deserialized->partitionKeys().at("country"), std::nullopt);
+
+  ASSERT_EQ(deserialized->dataFiles().size(), 1);
+  EXPECT_EQ(deserialized->dataFiles()[0].path, "s3://bucket/data-001.parquet");
+  EXPECT_EQ(deserialized->dataFiles()[0].size, 4096);
+}
+
+TEST_F(PaimonConnectorSplitTest, paimonTableTypeStringAndParse) {
+  EXPECT_EQ(paimonTableTypeString(PaimonTableType::kAppendOnly), "APPEND_ONLY");
+  EXPECT_EQ(paimonTableTypeString(PaimonTableType::kPrimaryKey), "PRIMARY_KEY");
+
+  EXPECT_EQ(
+      paimonTableTypeFromString("APPEND_ONLY"), PaimonTableType::kAppendOnly);
+  EXPECT_EQ(
+      paimonTableTypeFromString("PRIMARY_KEY"), PaimonTableType::kPrimaryKey);
+
+  VELOX_ASSERT_THROW(
+      paimonTableTypeFromString("UNKNOWN"), "Unknown PaimonTableType: UNKNOWN");
+}
+
+TEST_F(PaimonConnectorSplitTest, tableTypeStreamAndFormat) {
+  {
+    std::ostringstream os;
+    os << PaimonTableType::kAppendOnly;
+    EXPECT_EQ(os.str(), "APPEND_ONLY");
+  }
+  {
+    std::ostringstream os;
+    os << PaimonTableType::kPrimaryKey;
+    EXPECT_EQ(os.str(), "PRIMARY_KEY");
+  }
+
+  EXPECT_EQ(fmt::format("{}", PaimonTableType::kAppendOnly), "APPEND_ONLY");
+  EXPECT_EQ(fmt::format("{}", PaimonTableType::kPrimaryKey), "PRIMARY_KEY");
+}
diff --git a/velox/connectors/hive/paimon/tests/PaimonConnectorTest.cpp b/velox/connectors/hive/paimon/tests/PaimonConnectorTest.cpp
new file mode 100644
index 00000000000..4bfb10dc774
--- /dev/null
+++ b/velox/connectors/hive/paimon/tests/PaimonConnectorTest.cpp
@@ -0,0 +1,329 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/connectors/hive/paimon/PaimonConnector.h"
+
+#include <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/connectors/ConnectorRegistry.h"
+#include "velox/connectors/hive/HiveConfig.h"
+#include "velox/connectors/hive/paimon/PaimonConnectorSplit.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+namespace facebook::velox::connector::hive::paimon {
+namespace {
+
+static const std::string kPaimonConnectorId = "test-paimon";
+
+class PaimonConnectorTest : public exec::test::HiveConnectorTestBase {
+ protected:
+  void SetUp() override {
+    HiveConnectorTestBase::SetUp();
+    auto config = std::make_shared<config::ConfigBase>(
+        std::unordered_map<std::string, std::string>{});
+    auto connector =
+        PaimonConnectorFactory().newConnector(kPaimonConnectorId, config);
+    ConnectorRegistry::global().insert(connector->connectorId(), connector);
+  }
+
+  void TearDown() override {
+    ConnectorRegistry::global().erase(kPaimonConnectorId);
+    HiveConnectorTestBase::TearDown();
+  }
+
+  /// Creates a table handle for the Paimon connector.
+  static std::shared_ptr<HiveTableHandle> makePaimonTableHandle(
+      const RowTypePtr& dataColumns = nullptr,
+      common::SubfieldFilters subfieldFilters = {},
+      const core::TypedExprPtr& remainingFilter = nullptr) {
+    return std::make_shared<HiveTableHandle>(
+        kPaimonConnectorId,
+        "paimon_table",
+        std::move(subfieldFilters),
+        remainingFilter,
+        dataColumns);
+  }
+
+  /// Creates column assignments for all columns as regular columns.
+  static connector::ColumnHandleMap makePaimonColumnHandles(
+      const RowTypePtr& rowType) {
+    connector::ColumnHandleMap assignments;
+    assignments.reserve(rowType->size());
+    for (uint32_t i = 0; i < rowType->size(); ++i) {
+      const auto& name = rowType->nameOf(i);
+      assignments[name] = std::make_shared<HiveColumnHandle>(
+          name,
+          HiveColumnHandle::ColumnType::kRegular,
+          rowType->childAt(i),
+          rowType->childAt(i));
+    }
+    return assignments;
+  }
+
+  /// Builds a table scan plan using the Paimon connector.
+  core::PlanNodePtr makePaimonScanPlan(
+      const RowTypePtr& outputType,
+      const RowTypePtr& dataColumns = nullptr,
+      common::SubfieldFilters subfieldFilters = {},
+      const core::TypedExprPtr& remainingFilter = nullptr) {
+    auto tableHandle = makePaimonTableHandle(
+        dataColumns ? dataColumns : outputType,
+        std::move(subfieldFilters),
+        remainingFilter);
+    auto assignments =
+        makePaimonColumnHandles(dataColumns ? dataColumns : outputType);
+    return exec::test::PlanBuilder()
+        .startTableScan()
+        .connectorId(kPaimonConnectorId)
+        .outputType(outputType)
+        .tableHandle(tableHandle)
+        .assignments(assignments)
+        .endTableScan()
+        .planNode();
+  }
+
+  /// Creates a PaimonConnectorSplit from file paths.
+  std::shared_ptr<PaimonConnectorSplit> makePaimonSplit(
+      const std::vector<std::string>& filePaths,
+      PaimonTableType tableType = PaimonTableType::kAppendOnly,
+      dwio::common::FileFormat format = dwio::common::FileFormat::DWRF,
+      const std::unordered_map<std::string, std::optional<std::string>>&
+          partitionKeys = {},
+      bool rawConvertible = true) {
+    PaimonConnectorSplitBuilder builder(
+        kPaimonConnectorId, /*snapshotId=*/1, tableType, format);
+    for (const auto& filePath : filePaths) {
+      builder.addFile(filePath, /*fileSize=*/0);
+    }
+    for (const auto& [key, value] : partitionKeys) {
+      builder.partitionKey(key, value);
+    }
+    builder.rawConvertible(rawConvertible);
+    return builder.build();
+  }
+};
+
+TEST_F(PaimonConnectorTest, connectorRegistration) {
+  auto connector = ConnectorRegistry::tryGet(kPaimonConnectorId);
+  ASSERT_NE(connector, nullptr);
+  ASSERT_NE(connector->connectorConfig(), nullptr);
+}
+
+TEST_F(PaimonConnectorTest, connectorFactory) {
+  PaimonConnectorFactory factory;
+  EXPECT_EQ(
+      std::string(PaimonConnectorFactory::kPaimonConnectorName), "paimon");
+
+  auto config = std::make_shared<config::ConfigBase>(
+      std::unordered_map<std::string, std::string>{
+          {HiveConfig::kEnableFileHandleCache, "true"},
+          {HiveConfig::kNumCacheFileHandles, "500"}});
+
+  auto connector = factory.newConnector("test-paimon-2", config);
+  ASSERT_NE(connector, nullptr);
+
+  HiveConfig hiveConfig(connector->connectorConfig());
+  EXPECT_TRUE(hiveConfig.isFileHandleCacheEnabled());
+  EXPECT_EQ(hiveConfig.numCacheFileHandles(), 500);
+}
+
+// E2E test: read a single file from an append-only Paimon split.
+TEST_F(PaimonConnectorTest, appendOnlySingleFile) {
+  auto rowType = ROW({"c0", "c1"}, {BIGINT(), VARCHAR()});
+  auto vectors = makeVectors(rowType, 1, 100);
+
+  auto filePaths = makeFilePaths(1);
+  writeToFile(filePaths[0]->getPath(), vectors);
+
+  auto split = makePaimonSplit({filePaths[0]->getPath()});
+  auto plan = makePaimonScanPlan(rowType);
+
+  exec::test::AssertQueryBuilder(plan).split(split).assertResults(vectors);
+}
+
+// E2E test: read multiple files from a single append-only Paimon split.
+TEST_F(PaimonConnectorTest, appendOnlyMultipleFiles) {
+  auto rowType = ROW({"c0", "c1"}, {BIGINT(), VARCHAR()});
+  auto vectors1 = makeVectors(rowType, 1, 100);
+  auto vectors2 = makeVectors(rowType, 1, 50);
+
+  auto filePaths = makeFilePaths(2);
+  writeToFile(filePaths[0]->getPath(), vectors1);
+  writeToFile(filePaths[1]->getPath(), vectors2);
+
+  auto split =
+      makePaimonSplit({filePaths[0]->getPath(), filePaths[1]->getPath()});
+  auto plan = makePaimonScanPlan(rowType);
+
+  // Expected result is all rows from both files.
+  std::vector<RowVectorPtr> expected;
+  expected.insert(expected.end(), vectors1.begin(), vectors1.end());
+  expected.insert(expected.end(), vectors2.begin(), vectors2.end());
+
+  exec::test::AssertQueryBuilder(plan).split(split).assertResults(expected);
+}
+
+// Verify that empty splits (no data files) are rejected by
+// PaimonConnectorSplit.
+TEST_F(PaimonConnectorTest, rejectsEmptySplit) {
+  VELOX_ASSERT_THROW(
+      makePaimonSplit({}), "PaimonConnectorSplit requires non-empty dataFiles");
+}
+
+// E2E test: read with partition keys from an append-only Paimon split.
+TEST_F(PaimonConnectorTest, appendOnlyWithPartitionKeys) {
+  // Data file columns (not including partition column).
+  auto dataRowType = ROW({"c0"}, {BIGINT()});
+  auto vectors = makeVectors(dataRowType, 1, 100);
+
+  auto filePaths = makeFilePaths(1);
+  writeToFile(filePaths[0]->getPath(), vectors);
+
+  // The output includes both the data column and the partition column.
+  auto outputType = ROW({"c0", "p0"}, {BIGINT(), VARCHAR()});
+  auto tableHandle = makePaimonTableHandle(outputType);
+
+  connector::ColumnHandleMap assignments;
+  assignments["c0"] = std::make_shared<HiveColumnHandle>(
+      "c0", HiveColumnHandle::ColumnType::kRegular, BIGINT(), BIGINT());
+  assignments["p0"] = std::make_shared<HiveColumnHandle>(
+      "p0", HiveColumnHandle::ColumnType::kPartitionKey, VARCHAR(), VARCHAR());
+
+  auto plan = exec::test::PlanBuilder()
+                  .startTableScan()
+                  .connectorId(kPaimonConnectorId)
+                  .outputType(outputType)
+                  .tableHandle(tableHandle)
+                  .assignments(assignments)
+                  .endTableScan()
+                  .planNode();
+
+  auto split = makePaimonSplit(
+      {filePaths[0]->getPath()},
+      PaimonTableType::kAppendOnly,
+      dwio::common::FileFormat::DWRF,
+      {{"p0", std::optional<std::string>("2024-01-01")}});
+
+  // Build expected output with the partition value filled in.
+  auto expectedC0 = vectors[0]->childAt(0);
+  auto numRows = vectors[0]->size();
+  auto expectedP0 =
+      BaseVector::createConstant(VARCHAR(), "2024-01-01", numRows, pool());
+
+  auto expected = makeRowVector({"c0", "p0"}, {expectedC0, expectedP0});
+
+  exec::test::AssertQueryBuilder(plan).split(split).assertResults({expected});
+}
+
+// Verify that non-rawConvertible splits trigger NYI (merge-on-read).
+TEST_F(PaimonConnectorTest, rejectsNonRawConvertible) {
+  auto rowType = ROW({"c0"}, {BIGINT()});
+  auto vectors = makeVectors(rowType, 1, 10);
+
+  auto filePaths = makeFilePaths(1);
+  writeToFile(filePaths[0]->getPath(), vectors);
+
+  auto split = makePaimonSplit(
+      {filePaths[0]->getPath()},
+      PaimonTableType::kAppendOnly,
+      dwio::common::FileFormat::DWRF,
+      /*partitionKeys=*/{},
+      /*rawConvertible=*/false);
+
+  auto plan = makePaimonScanPlan(rowType);
+
+  VELOX_ASSERT_THROW(
+      exec::test::AssertQueryBuilder(plan).split(split).copyResults(pool()),
+      "Paimon merge-on-read is not yet implemented");
+}
+
+// E2E test: primary-key table with rawConvertible=true reads successfully.
+// When fully compacted (rawConvertible), primary-key tables can be read
+// the same way as append-only — each file is independent, no merge needed.
+TEST_F(PaimonConnectorTest, primaryKeyRawConvertible) {
+  auto rowType = ROW({"c0"}, {BIGINT()});
+  auto vectors = makeVectors(rowType, 1, 10);
+
+  auto filePaths = makeFilePaths(1);
+  writeToFile(filePaths[0]->getPath(), vectors);
+
+  auto split = makePaimonSplit(
+      {filePaths[0]->getPath()},
+      PaimonTableType::kPrimaryKey,
+      dwio::common::FileFormat::DWRF);
+
+  auto plan = makePaimonScanPlan(rowType);
+
+  exec::test::AssertQueryBuilder(plan).split(split).assertResults(vectors);
+}
+
+// Verify that primary-key table with rawConvertible=false triggers NYI.
+TEST_F(PaimonConnectorTest, rejectsPrimaryKeyNonRawConvertible) {
+  auto rowType = ROW({"c0"}, {BIGINT()});
+  auto vectors = makeVectors(rowType, 1, 10);
+
+  auto filePaths = makeFilePaths(1);
+  writeToFile(filePaths[0]->getPath(), vectors);
+
+  auto split = makePaimonSplit(
+      {filePaths[0]->getPath()},
+      PaimonTableType::kPrimaryKey,
+      dwio::common::FileFormat::DWRF,
+      /*partitionKeys=*/{},
+      /*rawConvertible=*/false);
+
+  auto plan = makePaimonScanPlan(rowType);
+
+  VELOX_ASSERT_THROW(
+      exec::test::AssertQueryBuilder(plan).split(split).copyResults(pool()),
+      "Paimon merge-on-read is not yet implemented");
+}
+
+// E2E test: multiple splits each with multiple files.
+TEST_F(PaimonConnectorTest, appendOnlyMultipleSplits) {
+  auto rowType = ROW({"c0", "c1"}, {BIGINT(), VARCHAR()});
+
+  // Split 1 with 2 files.
+  auto vectors1a = makeVectors(rowType, 1, 50);
+  auto vectors1b = makeVectors(rowType, 1, 30);
+  // Split 2 with 1 file.
+  auto vectors2a = makeVectors(rowType, 1, 40);
+
+  auto filePaths = makeFilePaths(3);
+  writeToFile(filePaths[0]->getPath(), vectors1a);
+  writeToFile(filePaths[1]->getPath(), vectors1b);
+  writeToFile(filePaths[2]->getPath(), vectors2a);
+
+  auto split1 =
+      makePaimonSplit({filePaths[0]->getPath(), filePaths[1]->getPath()});
+  auto split2 = makePaimonSplit({filePaths[2]->getPath()});
+
+  auto plan = makePaimonScanPlan(rowType);
+
+  std::vector<RowVectorPtr> expected;
+  expected.insert(expected.end(), vectors1a.begin(), vectors1a.end());
+  expected.insert(expected.end(), vectors1b.begin(), vectors1b.end());
+  expected.insert(expected.end(), vectors2a.begin(), vectors2a.end());
+
+  exec::test::AssertQueryBuilder(plan)
+      .splits({split1, split2})
+      .assertResults(expected);
+}
+
+} // namespace
+} // namespace facebook::velox::connector::hive::paimon
diff --git a/velox/connectors/hive/paimon/tests/PaimonDataFileMetaTest.cpp b/velox/connectors/hive/paimon/tests/PaimonDataFileMetaTest.cpp
new file mode 100644
index 00000000000..e728191992b
--- /dev/null
+++ b/velox/connectors/hive/paimon/tests/PaimonDataFileMetaTest.cpp
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/connectors/hive/paimon/PaimonDataFileMeta.h"
+
+#include <fmt/format.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <sstream>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/base/tests/GTestUtils.h"
+
+using namespace facebook::velox::connector::hive::paimon;
+using namespace facebook::velox;
+
+TEST(PaimonDataFileTest, serializeRoundTrip) {
+  PaimonDataFile file;
+  file.path = "data.parquet";
+  file.size = 4096;
+  file.rowCount = 500;
+  file.level = 1;
+  file.minSequenceNumber = 5;
+  file.maxSequenceNumber = 15;
+  file.deleteRowCount = 3;
+  file.creationTimeMs = 1700000000;
+  file.type = PaimonDataFile::Type::kChangelog;
+  file.source = PaimonDataFile::Source::kCompact;
+  file.deletionFile = PaimonDeletionFile{"del.bin", 0, 64, 2};
+
+  auto serialized = file.serialize();
+  auto deserialized = PaimonDataFile::create(serialized);
+
+  EXPECT_EQ(deserialized.path, "data.parquet");
+  EXPECT_EQ(deserialized.size, 4096);
+  EXPECT_EQ(deserialized.rowCount, 500);
+  EXPECT_EQ(deserialized.level, 1);
+  EXPECT_EQ(deserialized.minSequenceNumber, 5);
+  EXPECT_EQ(deserialized.maxSequenceNumber, 15);
+  EXPECT_EQ(deserialized.deleteRowCount, 3);
+  EXPECT_EQ(deserialized.creationTimeMs, 1700000000);
+  EXPECT_EQ(deserialized.type, PaimonDataFile::Type::kChangelog);
+  EXPECT_EQ(deserialized.source, PaimonDataFile::Source::kCompact);
+  ASSERT_TRUE(deserialized.deletionFile.has_value());
+  EXPECT_EQ(deserialized.deletionFile->path, "del.bin");
+  EXPECT_EQ(deserialized.deletionFile->offset, 0);
+  EXPECT_EQ(deserialized.deletionFile->length, 64);
+  EXPECT_EQ(deserialized.deletionFile->cardinality, 2);
+}
+
+TEST(PaimonDataFileTest, serializeNoDeletionFile) {
+  PaimonDataFile file;
+  file.path = "data.orc";
+  file.size = 1024;
+
+  auto serialized = file.serialize();
+  auto deserialized = PaimonDataFile::create(serialized);
+
+  EXPECT_EQ(deserialized.path, "data.orc");
+  EXPECT_EQ(deserialized.size, 1024);
+  EXPECT_FALSE(deserialized.deletionFile.has_value());
+}
+
+TEST(PaimonDataFileTest, serializeDefaultValues) {
+  PaimonDataFile file;
+  file.path = "data.orc";
+
+  auto serialized = file.serialize();
+  auto deserialized = PaimonDataFile::create(serialized);
+
+  EXPECT_EQ(deserialized.path, "data.orc");
+  EXPECT_EQ(deserialized.size, 0);
+  EXPECT_EQ(deserialized.rowCount, 0);
+  EXPECT_EQ(deserialized.level, 0);
+  EXPECT_EQ(deserialized.minSequenceNumber, 0);
+  EXPECT_EQ(deserialized.maxSequenceNumber, 0);
+  EXPECT_EQ(deserialized.deleteRowCount, 0);
+  EXPECT_EQ(deserialized.creationTimeMs, 0);
+  EXPECT_EQ(deserialized.type, PaimonDataFile::Type::kData);
+  EXPECT_EQ(deserialized.source, PaimonDataFile::Source::kAppend);
+  EXPECT_FALSE(deserialized.deletionFile.has_value());
+}
+
+TEST(PaimonDataFileTest, toString) {
+  PaimonDataFile file;
+  file.path = "data.orc";
+  file.size = 1024;
+  file.rowCount = 100;
+  file.level = 0;
+
+  auto str = file.toString();
+  EXPECT_THAT(str, testing::HasSubstr("data.orc"));
+  EXPECT_THAT(str, testing::HasSubstr("size=1024"));
+  EXPECT_THAT(str, testing::HasSubstr("rows=100"));
+  EXPECT_THAT(str, testing::HasSubstr("level=0"));
+  EXPECT_THAT(str, testing::HasSubstr("type=DATA"));
+  EXPECT_THAT(str, testing::HasSubstr("source=APPEND"));
+  EXPECT_THAT(str, testing::HasSubstr("deletionFile=none"));
+}
+
+TEST(PaimonDataFileTest, toStringChangelog) {
+  PaimonDataFile file;
+  file.path = "changelog.orc";
+  file.size = 2048;
+  file.rowCount = 200;
+  file.level = 1;
+  file.type = PaimonDataFile::Type::kChangelog;
+  file.source = PaimonDataFile::Source::kCompact;
+  file.deletionFile = PaimonDeletionFile{"del.bin", 0, 64, 2};
+
+  auto str = file.toString();
+  EXPECT_THAT(str, testing::HasSubstr("type=CHANGELOG"));
+  EXPECT_THAT(str, testing::HasSubstr("source=COMPACT"));
+  EXPECT_THAT(str, testing::HasSubstr("del.bin"));
+  EXPECT_THAT(str, testing::HasSubstr("cardinality=2"));
+}
+
+TEST(PaimonDataFileTest, defaultValues) {
+  PaimonDataFile file;
+  EXPECT_TRUE(file.path.empty());
+  EXPECT_EQ(file.size, 0);
+  EXPECT_EQ(file.rowCount, 0);
+  EXPECT_EQ(file.level, 0);
+  EXPECT_EQ(file.minSequenceNumber, 0);
+  EXPECT_EQ(file.maxSequenceNumber, 0);
+  EXPECT_EQ(file.deleteRowCount, 0);
+  EXPECT_EQ(file.creationTimeMs, 0);
+  EXPECT_EQ(file.type, PaimonDataFile::Type::kData);
+  EXPECT_EQ(file.source, PaimonDataFile::Source::kAppend);
+  EXPECT_FALSE(file.deletionFile.has_value());
+}
+
+TEST(PaimonDataFileTest, typeStringAndParse) {
+  EXPECT_EQ(PaimonDataFile::typeString(PaimonDataFile::Type::kData), "DATA");
+  EXPECT_EQ(
+      PaimonDataFile::typeString(PaimonDataFile::Type::kChangelog),
+      "CHANGELOG");
+
+  EXPECT_EQ(
+      PaimonDataFile::typeFromString("DATA"), PaimonDataFile::Type::kData);
+  EXPECT_EQ(
+      PaimonDataFile::typeFromString("CHANGELOG"),
+      PaimonDataFile::Type::kChangelog);
+
+  VELOX_ASSERT_THROW(
+      PaimonDataFile::typeFromString("UNKNOWN"),
+      "Unknown PaimonDataFile::Type: UNKNOWN");
+}
+
+TEST(PaimonDataFileTest, sourceStringAndParse) {
+  EXPECT_EQ(
+      PaimonDataFile::sourceString(PaimonDataFile::Source::kAppend), "APPEND");
+  EXPECT_EQ(
+      PaimonDataFile::sourceString(PaimonDataFile::Source::kCompact),
+      "COMPACT");
+
+  EXPECT_EQ(
+      PaimonDataFile::sourceFromString("APPEND"),
+      PaimonDataFile::Source::kAppend);
+  EXPECT_EQ(
+      PaimonDataFile::sourceFromString("COMPACT"),
+      PaimonDataFile::Source::kCompact);
+
+  VELOX_ASSERT_THROW(
+      PaimonDataFile::sourceFromString("UNKNOWN"),
+      "Unknown PaimonDataFile::Source: UNKNOWN");
+}
+
+TEST(PaimonDataFileTest, typeStreamAndFormat) {
+  {
+    std::ostringstream os;
+    os << PaimonDataFile::Type::kData;
+    EXPECT_EQ(os.str(), "DATA");
+  }
+  {
+    std::ostringstream os;
+    os << PaimonDataFile::Type::kChangelog;
+    EXPECT_EQ(os.str(), "CHANGELOG");
+  }
+
+  EXPECT_EQ(fmt::format("{}", PaimonDataFile::Type::kData), "DATA");
+  EXPECT_EQ(fmt::format("{}", PaimonDataFile::Type::kChangelog), "CHANGELOG");
+}
+
+TEST(PaimonDataFileTest, sourceStreamAndFormat) {
+  {
+    std::ostringstream os;
+    os << PaimonDataFile::Source::kAppend;
+    EXPECT_EQ(os.str(), "APPEND");
+  }
+  {
+    std::ostringstream os;
+    os << PaimonDataFile::Source::kCompact;
+    EXPECT_EQ(os.str(), "COMPACT");
+  }
+
+  EXPECT_EQ(fmt::format("{}", PaimonDataFile::Source::kAppend), "APPEND");
+  EXPECT_EQ(fmt::format("{}", PaimonDataFile::Source::kCompact), "COMPACT");
+}
diff --git a/velox/connectors/hive/paimon/tests/PaimonDeletionFileTest.cpp b/velox/connectors/hive/paimon/tests/PaimonDeletionFileTest.cpp
new file mode 100644
index 00000000000..9290f6c57b5
--- /dev/null
+++ b/velox/connectors/hive/paimon/tests/PaimonDeletionFileTest.cpp
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/connectors/hive/paimon/PaimonDeletionFile.h"
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/base/tests/GTestUtils.h"
+
+using namespace facebook::velox::connector::hive::paimon;
+using namespace facebook::velox;
+
+TEST(PaimonDeletionFileTest, serializeRoundTrip) {
+  PaimonDeletionFile df("s3://bucket/deletion.bin", 64, 256, 10);
+
+  auto serialized = df.serialize();
+  auto deserialized = PaimonDeletionFile::create(serialized);
+
+  EXPECT_EQ(deserialized.path, "s3://bucket/deletion.bin");
+  EXPECT_EQ(deserialized.offset, 64);
+  EXPECT_EQ(deserialized.length, 256);
+  EXPECT_EQ(deserialized.cardinality, 10);
+}
+
+TEST(PaimonDeletionFileTest, serializeRoundTripZeroOffset) {
+  PaimonDeletionFile df("deletion-standalone.bin", 0, 512, 42);
+
+  auto serialized = df.serialize();
+  auto deserialized = PaimonDeletionFile::create(serialized);
+
+  EXPECT_EQ(deserialized.path, "deletion-standalone.bin");
+  EXPECT_EQ(deserialized.offset, 0);
+  EXPECT_EQ(deserialized.length, 512);
+  EXPECT_EQ(deserialized.cardinality, 42);
+}
+
+TEST(PaimonDeletionFileTest, serializeRoundTripLargeValues) {
+  PaimonDeletionFile df(
+      "s3://bucket/container.bin", 1ULL << 32, 1ULL << 20, 1000000);
+
+  auto serialized = df.serialize();
+  auto deserialized = PaimonDeletionFile::create(serialized);
+
+  EXPECT_EQ(deserialized.path, "s3://bucket/container.bin");
+  EXPECT_EQ(deserialized.offset, 1ULL << 32);
+  EXPECT_EQ(deserialized.length, 1ULL << 20);
+  EXPECT_EQ(deserialized.cardinality, 1000000);
+}
+
+TEST(PaimonDeletionFileTest, toString) {
+  PaimonDeletionFile df("del.bin", 0, 128, 5);
+
+  auto str = df.toString();
+  EXPECT_THAT(str, testing::HasSubstr("del.bin"));
+  EXPECT_THAT(str, testing::HasSubstr("offset=0"));
+  EXPECT_THAT(str, testing::HasSubstr("length=128"));
+  EXPECT_THAT(str, testing::HasSubstr("cardinality=5"));
+}
+
+TEST(PaimonDeletionFileTest, toStringContainerFile) {
+  PaimonDeletionFile df("s3://bucket/container.bin", 1024, 256, 15);
+
+  auto str = df.toString();
+  EXPECT_THAT(str, testing::HasSubstr("s3://bucket/container.bin"));
+  EXPECT_THAT(str, testing::HasSubstr("offset=1024"));
+  EXPECT_THAT(str, testing::HasSubstr("length=256"));
+  EXPECT_THAT(str, testing::HasSubstr("cardinality=15"));
+}
+
+TEST(PaimonDeletionFileTest, zeroLengthThrows) {
+  VELOX_ASSERT_THROW(
+      PaimonDeletionFile("del.bin", 0, 0, 5),
+      "PaimonDeletionFile length must be > 0");
+}
+
+TEST(PaimonDeletionFileTest, zeroCardinalityThrows) {
+  VELOX_ASSERT_THROW(
+      PaimonDeletionFile("del.bin", 0, 128, 0),
+      "PaimonDeletionFile cardinality must be > 0");
+}
+
+TEST(PaimonDeletionFileTest, zeroLengthAndCardinalityThrows) {
+  VELOX_ASSERT_THROW(
+      PaimonDeletionFile("del.bin", 0, 0, 0),
+      "PaimonDeletionFile length must be > 0");
+}
diff --git a/velox/connectors/hive/paimon/tests/PaimonRowKindTest.cpp b/velox/connectors/hive/paimon/tests/PaimonRowKindTest.cpp
new file mode 100644
index 00000000000..0e58526d4a5
--- /dev/null
+++ b/velox/connectors/hive/paimon/tests/PaimonRowKindTest.cpp
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/connectors/hive/paimon/PaimonRowKind.h"
+
+#include <fmt/format.h>
+#include <gtest/gtest.h>
+#include <sstream>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/base/tests/GTestUtils.h"
+
+using namespace facebook::velox::connector::hive::paimon;
+using namespace facebook::velox;
+
+TEST(PaimonRowKindTest, rowKindString) {
+  EXPECT_EQ(paimonRowKindString(PaimonRowKind::kInsert), "+I");
+  EXPECT_EQ(paimonRowKindString(PaimonRowKind::kUpdateBefore), "-U");
+  EXPECT_EQ(paimonRowKindString(PaimonRowKind::kUpdateAfter), "+U");
+  EXPECT_EQ(paimonRowKindString(PaimonRowKind::kDelete), "-D");
+}
+
+TEST(PaimonRowKindTest, rowKindFromValue) {
+  EXPECT_EQ(paimonRowKindFromValue(0), PaimonRowKind::kInsert);
+  EXPECT_EQ(paimonRowKindFromValue(1), PaimonRowKind::kUpdateBefore);
+  EXPECT_EQ(paimonRowKindFromValue(2), PaimonRowKind::kUpdateAfter);
+  EXPECT_EQ(paimonRowKindFromValue(3), PaimonRowKind::kDelete);
+
+  VELOX_ASSERT_THROW(
+      paimonRowKindFromValue(4), "Unknown PaimonRowKind value: 4");
+  VELOX_ASSERT_THROW(
+      paimonRowKindFromValue(-1), "Unknown PaimonRowKind value: -1");
+}
+
+TEST(PaimonRowKindTest, rowKindStreamAndFormat) {
+  {
+    std::ostringstream os;
+    os << PaimonRowKind::kInsert;
+    EXPECT_EQ(os.str(), "+I");
+  }
+  {
+    std::ostringstream os;
+    os << PaimonRowKind::kDelete;
+    EXPECT_EQ(os.str(), "-D");
+  }
+
+  EXPECT_EQ(fmt::format("{}", PaimonRowKind::kInsert), "+I");
+  EXPECT_EQ(fmt::format("{}", PaimonRowKind::kUpdateBefore), "-U");
+  EXPECT_EQ(fmt::format("{}", PaimonRowKind::kUpdateAfter), "+U");
+  EXPECT_EQ(fmt::format("{}", PaimonRowKind::kDelete), "-D");
+}
+
+TEST(PaimonRowKindTest, rowKindValues) {
+  EXPECT_EQ(static_cast<int8_t>(PaimonRowKind::kInsert), 0);
+  EXPECT_EQ(static_cast<int8_t>(PaimonRowKind::kUpdateBefore), 1);
+  EXPECT_EQ(static_cast<int8_t>(PaimonRowKind::kUpdateAfter), 2);
+  EXPECT_EQ(static_cast<int8_t>(PaimonRowKind::kDelete), 3);
+}
+
+TEST(PaimonRowKindTest, changelogModeStringAndParse) {
+  EXPECT_EQ(paimonChangelogModeString(PaimonChangelogMode::kNone), "NONE");
+  EXPECT_EQ(paimonChangelogModeString(PaimonChangelogMode::kInput), "INPUT");
+  EXPECT_EQ(paimonChangelogModeString(PaimonChangelogMode::kLookup), "LOOKUP");
+  EXPECT_EQ(
+      paimonChangelogModeString(PaimonChangelogMode::kFullCompaction),
+      "FULL_COMPACTION");
+
+  EXPECT_EQ(paimonChangelogModeFromString("NONE"), PaimonChangelogMode::kNone);
+  EXPECT_EQ(
+      paimonChangelogModeFromString("INPUT"), PaimonChangelogMode::kInput);
+  EXPECT_EQ(
+      paimonChangelogModeFromString("LOOKUP"), PaimonChangelogMode::kLookup);
+  EXPECT_EQ(
+      paimonChangelogModeFromString("FULL_COMPACTION"),
+      PaimonChangelogMode::kFullCompaction);
+
+  VELOX_ASSERT_THROW(
+      paimonChangelogModeFromString("UNKNOWN"),
+      "Unknown PaimonChangelogMode: UNKNOWN");
+}
+
+TEST(PaimonRowKindTest, changelogModeStreamAndFormat) {
+  {
+    std::ostringstream os;
+    os << PaimonChangelogMode::kNone;
+    EXPECT_EQ(os.str(), "NONE");
+  }
+  {
+    std::ostringstream os;
+    os << PaimonChangelogMode::kLookup;
+    EXPECT_EQ(os.str(), "LOOKUP");
+  }
+
+  EXPECT_EQ(fmt::format("{}", PaimonChangelogMode::kNone), "NONE");
+  EXPECT_EQ(fmt::format("{}", PaimonChangelogMode::kInput), "INPUT");
+  EXPECT_EQ(fmt::format("{}", PaimonChangelogMode::kLookup), "LOOKUP");
+  EXPECT_EQ(
+      fmt::format("{}", PaimonChangelogMode::kFullCompaction),
+      "FULL_COMPACTION");
+}
+
+TEST(PaimonRowKindTest, rowKindColumnName) {
+  EXPECT_EQ(kRowKindColumn, "_rowkind");
+}
diff --git a/velox/connectors/hive/storage_adapters/CMakeLists.txt b/velox/connectors/hive/storage_adapters/CMakeLists.txt
index bd7c37f8164..9cbad36cf77 100644
--- a/velox/connectors/hive/storage_adapters/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/CMakeLists.txt
@@ -16,3 +16,10 @@ add_subdirectory(s3fs)
 add_subdirectory(hdfs)
 add_subdirectory(gcs)
 add_subdirectory(abfs)
+
+velox_add_library(
+  velox_hive_storage_adapters_test_common
+  INTERFACE
+  HEADERS
+  test_common/InsertTest.h
+)
diff --git a/velox/connectors/hive/storage_adapters/abfs/AbfsPath.h b/velox/connectors/hive/storage_adapters/abfs/AbfsPath.h
index 0dbaa0a4eae..3a4e0d99f09 100644
--- a/velox/connectors/hive/storage_adapters/abfs/AbfsPath.h
+++ b/velox/connectors/hive/storage_adapters/abfs/AbfsPath.h
@@ -54,6 +54,11 @@ static constexpr const char* kAzureOAuthAuthType = "OAuth";
 
 static constexpr const char* kAzureSASAuthType = "SAS";
 
+// For performance, re - use SAS tokens until the expiry is within this number
+// of seconds.
+static constexpr const char* kAzureSasTokenRenewPeriod =
+    "fs.azure.sas.token.renew.period.for.streams";
+
 // Helper class to parse and extract information from a given ABFS path.
 class AbfsPath {
  public:
diff --git a/velox/connectors/hive/storage_adapters/abfs/AbfsReadFile.cpp b/velox/connectors/hive/storage_adapters/abfs/AbfsReadFile.cpp
index 9747e5e04c4..2d819a051d7 100644
--- a/velox/connectors/hive/storage_adapters/abfs/AbfsReadFile.cpp
+++ b/velox/connectors/hive/storage_adapters/abfs/AbfsReadFile.cpp
@@ -19,11 +19,14 @@
 #include "velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h"
 #include "velox/connectors/hive/storage_adapters/abfs/AzureClientProviderFactories.h"
 
+#include <algorithm>
+
 namespace facebook::velox::filesystems {
 
 class AbfsReadFile::Impl {
-  constexpr static uint64_t kNaturalReadSize = 4 << 20; // 4M
+  constexpr static uint64_t kNaturalReadSize = 4'194'304; // 4M
   constexpr static uint64_t kReadConcurrency = 8;
+  constexpr static size_t kDiscardBufferSize = 262'144; // 256K
 
  public:
   explicit Impl(std::string_view path, const config::ConfigBase& config) {
@@ -57,13 +60,13 @@ class AbfsReadFile::Impl {
       uint64_t offset,
       uint64_t length,
       void* buffer,
-      File::IoStats* stats) const {
+      const FileIoContext& context) const {
     preadInternal(offset, length, static_cast<char*>(buffer));
     return {static_cast<char*>(buffer), length};
   }
 
-  std::string pread(uint64_t offset, uint64_t length, File::IoStats* stats)
-      const {
+  std::string
+  pread(uint64_t offset, uint64_t length, const FileIoContext& context) const {
     std::string result(length, 0);
     preadInternal(offset, length, result.data());
     return result;
@@ -72,21 +75,12 @@ class AbfsReadFile::Impl {
   uint64_t preadv(
       uint64_t offset,
       const std::vector<folly::Range<char*>>& buffers,
-      File::IoStats* stats) const {
-    size_t length = 0;
-    auto size = buffers.size();
-    for (auto& range : buffers) {
+      const FileIoContext& context) const {
+    size_t length{0};
+    for (const auto& range : buffers) {
       length += range.size();
     }
-    std::string result(length, 0);
-    preadInternal(offset, length, static_cast<char*>(result.data()));
-    size_t resultOffset = 0;
-    for (auto range : buffers) {
-      if (range.data()) {
-        memcpy(range.data(), &(result.data()[resultOffset]), range.size());
-      }
-      resultOffset += range.size();
-    }
+    preadvInternal(offset, length, buffers);
 
     return length;
   }
@@ -94,14 +88,14 @@ class AbfsReadFile::Impl {
   uint64_t preadv(
       folly::Range<const common::Region*> regions,
       folly::Range<folly::IOBuf*> iobufs,
-      File::IoStats* stats) const {
+      const FileIoContext& context) const {
     size_t length = 0;
     VELOX_CHECK_EQ(regions.size(), iobufs.size());
     for (size_t i = 0; i < regions.size(); ++i) {
       const auto& region = regions[i];
       auto& output = iobufs[i];
       output = folly::IOBuf(folly::IOBuf::CREATE, region.length);
-      pread(region.offset, region.length, output.writableData(), stats);
+      pread(region.offset, region.length, output.writableData(), context);
       output.append(region.length);
       length += region.length;
     }
@@ -133,8 +127,8 @@ class AbfsReadFile::Impl {
   void preadInternal(uint64_t offset, uint64_t length, char* position) const {
     // Read the desired range of bytes.
     Azure::Core::Http::HttpRange range;
-    range.Offset = offset;
-    range.Length = length;
+    range.Offset = static_cast<int64_t>(offset);
+    range.Length = static_cast<int64_t>(length);
 
     Azure::Storage::Blobs::DownloadBlobOptions blob;
     blob.Range = range;
@@ -143,6 +137,40 @@ class AbfsReadFile::Impl {
         reinterpret_cast<uint8_t*>(position), length);
   }
 
+  void preadvInternal(
+      uint64_t offset,
+      uint64_t length,
+      const std::vector<folly::Range<char*>>& buffers) const {
+    Azure::Core::Http::HttpRange range;
+    range.Offset = static_cast<int64_t>(offset);
+    range.Length = static_cast<int64_t>(length);
+
+    Azure::Storage::Blobs::DownloadBlobOptions blob;
+    blob.Range = range;
+    auto response = fileClient_->download(blob);
+
+    std::vector<uint8_t> discardBuffer;
+    for (const auto& buffer : buffers) {
+      auto remaining = buffer.size();
+      if (buffer.data() != nullptr) {
+        response.Value.BodyStream->ReadToCount(
+            reinterpret_cast<uint8_t*>(buffer.data()), remaining);
+        continue;
+      }
+
+      const auto discardBufferSize = std::min(remaining, kDiscardBufferSize);
+      if (discardBuffer.size() < discardBufferSize) {
+        discardBuffer.resize(discardBufferSize);
+      }
+
+      while (remaining > 0) {
+        const auto readSize = std::min(remaining, discardBuffer.size());
+        response.Value.BodyStream->ReadToCount(discardBuffer.data(), readSize);
+        remaining -= readSize;
+      }
+    }
+  }
+
   std::string filePath_;
   std::unique_ptr<AzureBlobClient> fileClient_;
   int64_t length_ = -1;
@@ -155,36 +183,36 @@ AbfsReadFile::AbfsReadFile(
 }
 
 void AbfsReadFile::initialize(const FileOptions& options) {
-  return impl_->initialize(options);
+  impl_->initialize(options);
 }
 
 std::string_view AbfsReadFile::pread(
     uint64_t offset,
     uint64_t length,
     void* buffer,
-    File::IoStats* stats) const {
-  return impl_->pread(offset, length, buffer, stats);
+    const FileIoContext& context) const {
+  return impl_->pread(offset, length, buffer, context);
 }
 
 std::string AbfsReadFile::pread(
     uint64_t offset,
     uint64_t length,
-    File::IoStats* stats) const {
-  return impl_->pread(offset, length, stats);
+    const FileIoContext& context) const {
+  return impl_->pread(offset, length, context);
 }
 
 uint64_t AbfsReadFile::preadv(
     uint64_t offset,
     const std::vector<folly::Range<char*>>& buffers,
-    File::IoStats* stats) const {
-  return impl_->preadv(offset, buffers, stats);
+    const FileIoContext& context) const {
+  return impl_->preadv(offset, buffers, context);
 }
 
 uint64_t AbfsReadFile::preadv(
     folly::Range<const common::Region*> regions,
     folly::Range<folly::IOBuf*> iobufs,
-    File::IoStats* stats) const {
-  return impl_->preadv(regions, iobufs, stats);
+    const FileIoContext& context) const {
+  return impl_->preadv(regions, iobufs, context);
 }
 
 uint64_t AbfsReadFile::size() const {
diff --git a/velox/connectors/hive/storage_adapters/abfs/AbfsReadFile.h b/velox/connectors/hive/storage_adapters/abfs/AbfsReadFile.h
index 942439c06c1..56c99f2aa7d 100644
--- a/velox/connectors/hive/storage_adapters/abfs/AbfsReadFile.h
+++ b/velox/connectors/hive/storage_adapters/abfs/AbfsReadFile.h
@@ -35,22 +35,22 @@ class AbfsReadFile final : public ReadFile {
       uint64_t offset,
       uint64_t length,
       void* buf,
-      File::IoStats* stats = nullptr) const final;
+      const FileIoContext& context = {}) const final;
 
   std::string pread(
       uint64_t offset,
       uint64_t length,
-      File::IoStats* stats = nullptr) const final;
+      const FileIoContext& context = {}) const final;
 
   uint64_t preadv(
       uint64_t offset,
       const std::vector<folly::Range<char*>>& buffers,
-      File::IoStats* stats = nullptr) const final;
+      const FileIoContext& context = {}) const final;
 
   uint64_t preadv(
       folly::Range<const common::Region*> regions,
       folly::Range<folly::IOBuf*> iobufs,
-      File::IoStats* stats = nullptr) const final;
+      const FileIoContext& context = {}) const final;
 
   uint64_t size() const final;
 
diff --git a/velox/connectors/hive/storage_adapters/abfs/AbfsUtil.cpp b/velox/connectors/hive/storage_adapters/abfs/AbfsUtil.cpp
new file mode 100644
index 00000000000..5aefc098386
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/AbfsUtil.cpp
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h"
+#include "velox/common/config/Config.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsPath.h"
+
+namespace facebook::velox::filesystems {
+
+std::vector<CacheKey> extractCacheKeyFromConfig(
+    const config::ConfigBase& config) {
+  std::vector<CacheKey> cacheKeys;
+  constexpr std::string_view authTypePrefix{kAzureAccountAuthType};
+  for (const auto& [key, value] : config.rawConfigs()) {
+    if (key.find(authTypePrefix) == 0) {
+      // Extract the accountName after "fs.azure.account.auth.type.".
+      auto remaining = std::string_view(key).substr(authTypePrefix.size() + 1);
+      auto dot = remaining.find(".");
+      VELOX_USER_CHECK_NE(
+          dot,
+          std::string_view::npos,
+          "Invalid Azure account auth type key: {}",
+          key);
+      cacheKeys.emplace_back(CacheKey{remaining.substr(0, dot), value});
+    }
+  }
+  return cacheKeys;
+}
+
+} // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h b/velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h
index 925c6f91ece..1a6cf6e0a0e 100644
--- a/velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h
+++ b/velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h
@@ -26,6 +26,16 @@ constexpr std::string_view kAbfsScheme{"abfs://"};
 constexpr std::string_view kAbfssScheme{"abfss://"};
 } // namespace
 
+class ConfigBase;
+
+struct CacheKey {
+  const std::string accountName;
+  const std::string authType;
+
+  CacheKey(std::string_view accountName, std::string_view authType)
+      : accountName(accountName), authType(authType) {}
+};
+
 inline bool isAbfsFile(const std::string_view filename) {
   return filename.find(kAbfsScheme) == 0 || filename.find(kAbfssScheme) == 0;
 }
@@ -45,4 +55,7 @@ inline std::string throwStorageExceptionWithOperationDetails(
   VELOX_FAIL(errMsg);
 }
 
+std::vector<CacheKey> extractCacheKeyFromConfig(
+    const config::ConfigBase& config);
+
 } // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/abfs/AzureClientProvider.h b/velox/connectors/hive/storage_adapters/abfs/AzureClientProvider.h
index 291cc8e73a6..1a1a68f6d87 100644
--- a/velox/connectors/hive/storage_adapters/abfs/AzureClientProvider.h
+++ b/velox/connectors/hive/storage_adapters/abfs/AzureClientProvider.h
@@ -16,6 +16,8 @@
 
 #pragma once
 
+#include "velox/common/config/Config.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsPath.h"
 #include "velox/connectors/hive/storage_adapters/abfs/AzureBlobClient.h"
 #include "velox/connectors/hive/storage_adapters/abfs/AzureDataLakeFileClient.h"
 
diff --git a/velox/connectors/hive/storage_adapters/abfs/CMakeLists.txt b/velox/connectors/hive/storage_adapters/abfs/CMakeLists.txt
index e01169bbd96..ed93e4df610 100644
--- a/velox/connectors/hive/storage_adapters/abfs/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/abfs/CMakeLists.txt
@@ -14,7 +14,23 @@
 
 # for generated headers
 
-velox_add_library(velox_abfs RegisterAbfsFileSystem.cpp)
+velox_add_library(
+  velox_abfs
+  RegisterAbfsFileSystem.cpp
+  HEADERS
+  AbfsFileSystem.h
+  AbfsPath.h
+  AbfsReadFile.h
+  AbfsUtil.h
+  AbfsWriteFile.h
+  AzureBlobClient.h
+  AzureClientProvider.h
+  AzureClientProviderFactories.h
+  AzureClientProviderImpl.h
+  AzureDataLakeFileClient.h
+  DynamicSasTokenClientProvider.h
+  RegisterAbfsFileSystem.h
+)
 
 if(VELOX_ENABLE_ABFS)
   velox_sources(
@@ -23,9 +39,11 @@ if(VELOX_ENABLE_ABFS)
       AbfsFileSystem.cpp
       AbfsPath.cpp
       AbfsReadFile.cpp
+      AbfsUtil.cpp
       AbfsWriteFile.cpp
       AzureClientProviderFactories.cpp
       AzureClientProviderImpl.cpp
+      DynamicSasTokenClientProvider.cpp
   )
 
   velox_link_libraries(
diff --git a/velox/connectors/hive/storage_adapters/abfs/DynamicSasTokenClientProvider.cpp b/velox/connectors/hive/storage_adapters/abfs/DynamicSasTokenClientProvider.cpp
new file mode 100644
index 00000000000..b98ae99d48e
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/DynamicSasTokenClientProvider.cpp
@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/storage_adapters/abfs/DynamicSasTokenClientProvider.h"
+
+#include <azure/core/datetime.hpp>
+
+namespace facebook::velox::filesystems {
+
+namespace {
+
+constexpr int64_t kDefaultSasTokenRenewPeriod = 120; // in seconds
+
+Azure::DateTime getExpiry(const std::string_view& token) {
+  if (token.empty()) {
+    return Azure::DateTime::clock::time_point::min();
+  }
+
+  static constexpr std::string_view kSignedExpiry{"se="};
+  static constexpr int32_t kSignedExpiryLen = 3;
+
+  auto start = token.find(kSignedExpiry);
+  if (start == std::string::npos) {
+    return Azure::DateTime::clock::time_point::min();
+  }
+  start += kSignedExpiryLen;
+
+  auto end = token.find("&", start);
+  auto seValue = (end == std::string::npos)
+      ? std::string(token.substr(start))
+      : std::string(token.substr(start, end - start));
+
+  seValue = Azure::Core::Url::Decode(seValue);
+  auto seDate =
+      Azure::DateTime::Parse(seValue, Azure::DateTime::DateFormat::Rfc3339);
+
+  static constexpr std::string_view kSignedKeyExpiry = "ske=";
+  static constexpr int32_t kSignedKeyExpiryLen = 4;
+
+  start = token.find(kSignedKeyExpiry);
+  if (start == std::string::npos) {
+    return seDate;
+  }
+  start += kSignedKeyExpiryLen;
+
+  end = token.find("&", start);
+  auto skeValue = (end == std::string::npos)
+      ? std::string(token.substr(start))
+      : std::string(token.substr(start, end - start));
+
+  skeValue = Azure::Core::Url::Decode(skeValue);
+  auto skeDate =
+      Azure::DateTime::Parse(skeValue, Azure::DateTime::DateFormat::Rfc3339);
+
+  return std::min(skeDate, seDate);
+}
+
+bool isNearExpiry(Azure::DateTime expiration, int64_t minExpirationInSeconds) {
+  if (expiration == Azure::DateTime::clock::time_point::min()) {
+    return true;
+  }
+  auto remaining = std::chrono::duration_cast<std::chrono::seconds>(
+                       expiration - Azure::DateTime::clock::now())
+                       .count();
+  return remaining <= minExpirationInSeconds;
+}
+
+class DynamicSasTokenDataLakeFileClient final : public AzureDataLakeFileClient {
+ public:
+  DynamicSasTokenDataLakeFileClient(
+      const std::shared_ptr<AbfsPath>& abfsPath,
+      const std::shared_ptr<SasTokenProvider>& sasKeyGenerator,
+      int64_t sasTokenRenewPeriod)
+      : abfsPath_(abfsPath),
+        sasKeyGenerator_(sasKeyGenerator),
+        sasTokenRenewPeriod_(sasTokenRenewPeriod) {}
+
+  void create() override {
+    getWriteClient()->Create();
+  }
+
+  Azure::Storage::Files::DataLake::Models::PathProperties getProperties()
+      override {
+    return getReadClient()->GetProperties().Value;
+  }
+
+  void append(const uint8_t* buffer, size_t size, uint64_t offset) override {
+    auto bodyStream = Azure::Core::IO::MemoryBodyStream(buffer, size);
+    getWriteClient()->Append(bodyStream, offset);
+  }
+
+  void flush(uint64_t position) override {
+    getWriteClient()->Flush(position);
+  }
+
+  void close() override {}
+
+  std::string getUrl() override {
+    return getWriteClient()->GetUrl();
+  }
+
+ private:
+  std::shared_ptr<AbfsPath> abfsPath_;
+  std::shared_ptr<SasTokenProvider> sasKeyGenerator_;
+  int64_t sasTokenRenewPeriod_;
+
+  std::unique_ptr<DataLakeFileClient> writeClient_{nullptr};
+  Azure::DateTime writeSasExpiration_{
+      Azure::DateTime::clock::time_point::min()};
+
+  std::unique_ptr<DataLakeFileClient> readClient_{nullptr};
+  Azure::DateTime readSasExpiration_{Azure::DateTime::clock::time_point::min()};
+
+  DataLakeFileClient* getWriteClient() {
+    if (writeClient_ == nullptr ||
+        isNearExpiry(writeSasExpiration_, sasTokenRenewPeriod_)) {
+      const auto& sas = sasKeyGenerator_->getSasToken(
+          abfsPath_->fileSystem(), abfsPath_->filePath(), kAbfsWriteOperation);
+      writeSasExpiration_ = getExpiry(sas);
+      writeClient_ = std::make_unique<DataLakeFileClient>(
+          fmt::format("{}?{}", abfsPath_->getUrl(false), sas));
+    }
+    return writeClient_.get();
+  }
+
+  DataLakeFileClient* getReadClient() {
+    if (readClient_ == nullptr ||
+        isNearExpiry(readSasExpiration_, sasTokenRenewPeriod_)) {
+      const auto& sas = sasKeyGenerator_->getSasToken(
+          abfsPath_->fileSystem(), abfsPath_->filePath(), kAbfsReadOperation);
+      readSasExpiration_ = getExpiry(sas);
+      readClient_ = std::make_unique<DataLakeFileClient>(
+          fmt::format("{}?{}", abfsPath_->getUrl(false), sas));
+    }
+    return readClient_.get();
+  }
+};
+
+class DynamicSasTokenBlobClient : public AzureBlobClient {
+ public:
+  DynamicSasTokenBlobClient(
+      const std::shared_ptr<AbfsPath>& abfsPath,
+      const std::shared_ptr<SasTokenProvider>& sasTokenProvider,
+      int64_t sasTokenRenewPeriod)
+      : abfsPath_(abfsPath),
+        sasTokenProvider_(sasTokenProvider),
+        sasTokenRenewPeriod_(sasTokenRenewPeriod) {}
+
+  Azure::Response<Azure::Storage::Blobs::Models::BlobProperties> getProperties()
+      override {
+    return getBlobClient()->GetProperties();
+  }
+
+  Azure::Response<Azure::Storage::Blobs::Models::DownloadBlobResult> download(
+      const Azure::Storage::Blobs::DownloadBlobOptions& options) override {
+    return getBlobClient()->Download(options);
+  }
+
+  std::string getUrl() override {
+    return getBlobClient()->GetUrl();
+  }
+
+ private:
+  std::shared_ptr<AbfsPath> abfsPath_;
+  std::shared_ptr<SasTokenProvider> sasTokenProvider_;
+  int64_t sasTokenRenewPeriod_;
+
+  std::unique_ptr<Azure::Storage::Blobs::BlobClient> blobClient_{nullptr};
+  Azure::DateTime sasExpiration_{Azure::DateTime::clock::time_point::min()};
+
+  BlobClient* getBlobClient() {
+    if (blobClient_ == nullptr ||
+        isNearExpiry(sasExpiration_, sasTokenRenewPeriod_)) {
+      const auto& sas = sasTokenProvider_->getSasToken(
+          abfsPath_->fileSystem(), abfsPath_->filePath(), kAbfsReadOperation);
+      sasExpiration_ = getExpiry(sas);
+      blobClient_ = std::make_unique<Azure::Storage::Blobs::BlobClient>(
+          fmt::format("{}?{}", abfsPath_->getUrl(true), sas));
+    }
+    return blobClient_.get();
+  }
+};
+
+} // namespace
+
+DynamicSasTokenClientProvider::DynamicSasTokenClientProvider(
+    const std::shared_ptr<SasTokenProvider>& sasTokenProvider)
+    : AzureClientProvider(), sasTokenProvider_(sasTokenProvider) {}
+
+void DynamicSasTokenClientProvider::init(const config::ConfigBase& config) {
+  sasTokenRenewPeriod_ = config.get<int64_t>(
+      kAzureSasTokenRenewPeriod, kDefaultSasTokenRenewPeriod);
+}
+
+std::unique_ptr<AzureBlobClient>
+DynamicSasTokenClientProvider::getReadFileClient(
+    const std::shared_ptr<AbfsPath>& abfsPath,
+    const config::ConfigBase& config) {
+  init(config);
+  return std::make_unique<DynamicSasTokenBlobClient>(
+      abfsPath, sasTokenProvider_, sasTokenRenewPeriod_);
+}
+
+std::unique_ptr<AzureDataLakeFileClient>
+DynamicSasTokenClientProvider::getWriteFileClient(
+    const std::shared_ptr<AbfsPath>& abfsPath,
+    const config::ConfigBase& config) {
+  init(config);
+  return std::make_unique<DynamicSasTokenDataLakeFileClient>(
+      abfsPath, sasTokenProvider_, sasTokenRenewPeriod_);
+}
+} // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/abfs/DynamicSasTokenClientProvider.h b/velox/connectors/hive/storage_adapters/abfs/DynamicSasTokenClientProvider.h
new file mode 100644
index 00000000000..ab1d53f0045
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/DynamicSasTokenClientProvider.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/connectors/hive/storage_adapters/abfs/AzureBlobClient.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AzureClientProvider.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AzureClientProviderFactories.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AzureDataLakeFileClient.h"
+
+namespace facebook::velox::filesystems {
+
+/// SAS permissions reference:
+/// https://learn.microsoft.com/en-us/rest/api/storageservices/create-service-sas#permissions-for-a-directory-container-or-blob
+///
+/// ReadClient uses "read" permission for Download and GetProperties.
+/// WriteClient uses "read" permission for GetProperties, and "write" permission
+/// for other operations.
+static const std::string kAbfsReadOperation{"read"};
+static const std::string kAbfsWriteOperation{"write"};
+
+/// Interface for providing SAS tokens for ABFS file system operations.
+/// Adapted from the Hadoop Azure implementation:
+/// org.apache.hadoop.fs.azurebfs.extensions.SASTokenProvider
+class SasTokenProvider {
+ public:
+  virtual ~SasTokenProvider() = default;
+
+  virtual std::string getSasToken(
+      const std::string& fileSystem,
+      const std::string& path,
+      const std::string& operation) = 0;
+};
+
+/// Client provider that dynamically refreshes SAS tokens based on the
+/// expiration time of the token. A SasTokenProvider for retrieving SAS tokens
+/// must be provided to this class. Example for generating the SAS token can be
+/// found in:
+/// https://github.com/Azure/azure-sdk-for-cpp/blob/3d917e7c178f0a49b189395a907180084857cc70/sdk/storage/azure-storage-blobs/samples/blob_sas.cpp
+class DynamicSasTokenClientProvider : public AzureClientProvider {
+ public:
+  explicit DynamicSasTokenClientProvider(
+      const std::shared_ptr<SasTokenProvider>& sasTokenProvider);
+
+  std::unique_ptr<AzureBlobClient> getReadFileClient(
+      const std::shared_ptr<AbfsPath>& abfsPath,
+      const config::ConfigBase& config) override;
+
+  std::unique_ptr<AzureDataLakeFileClient> getWriteFileClient(
+      const std::shared_ptr<AbfsPath>& abfsPath,
+      const config::ConfigBase& config) override;
+
+ private:
+  void init(const config::ConfigBase& config);
+
+  std::shared_ptr<SasTokenProvider> sasTokenProvider_;
+  int64_t sasTokenRenewPeriod_;
+};
+
+} // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.cpp b/velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.cpp
index dcb46aa0529..df7a4cea829 100644
--- a/velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.cpp
+++ b/velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.cpp
@@ -52,7 +52,8 @@ std::unique_ptr<velox::dwio::common::FileSink> abfsWriteFileSinkGenerator(
         fileSystem->openFileForWrite(fileURI),
         fileURI,
         options.metricLogger,
-        options.stats);
+        options.stats,
+        options.fileSystemStats);
   }
   return nullptr;
 }
@@ -68,40 +69,28 @@ void registerAbfsFileSystem() {
 
 void registerAzureClientProvider(const config::ConfigBase& config) {
 #ifdef VELOX_ENABLE_ABFS
-  for (const auto& [key, value] : config.rawConfigs()) {
-    constexpr std::string_view authTypePrefix{kAzureAccountAuthType};
-    if (key.find(authTypePrefix) == 0) {
-      std::string_view skey = key;
-      // Extract the accountName after "fs.azure.account.auth.type.".
-      auto remaining = skey.substr(authTypePrefix.size() + 1);
-      auto dot = remaining.find(".");
-      VELOX_USER_CHECK_NE(
-          dot,
-          std::string_view::npos,
-          "Invalid Azure account auth type key: {}",
-          key);
-      auto accountName = std::string(remaining.substr(0, dot));
 
-      if (value == kAzureSharedKeyAuthType) {
-        AzureClientProviderFactories::registerFactory(
-            accountName, [](const std::string&) {
-              return std::make_unique<SharedKeyAzureClientProvider>();
-            });
-      } else if (value == kAzureOAuthAuthType) {
-        AzureClientProviderFactories::registerFactory(
-            accountName, [](const std::string&) {
-              return std::make_unique<OAuthAzureClientProvider>();
-            });
-      } else if (value == kAzureSASAuthType) {
-        AzureClientProviderFactories::registerFactory(
-            accountName, [](const std::string&) {
-              return std::make_unique<FixedSasAzureClientProvider>();
-            });
-      } else {
-        VELOX_USER_FAIL(
-            "Unsupported auth type {}, supported auth types are SharedKey, OAuth and SAS.",
-            value);
-      }
+  for (const auto& [accountName, authType] :
+       extractCacheKeyFromConfig(config)) {
+    if (authType == kAzureSharedKeyAuthType) {
+      AzureClientProviderFactories::registerFactory(
+          accountName, [](const std::string&) {
+            return std::make_unique<SharedKeyAzureClientProvider>();
+          });
+    } else if (authType == kAzureOAuthAuthType) {
+      AzureClientProviderFactories::registerFactory(
+          accountName, [](const std::string&) {
+            return std::make_unique<OAuthAzureClientProvider>();
+          });
+    } else if (authType == kAzureSASAuthType) {
+      AzureClientProviderFactories::registerFactory(
+          accountName, [](const std::string&) {
+            return std::make_unique<FixedSasAzureClientProvider>();
+          });
+    } else {
+      VELOX_USER_FAIL(
+          "Unsupported auth type {}, supported auth types are SharedKey, OAuth and SAS.",
+          authType);
     }
   }
 #endif
diff --git a/velox/connectors/hive/storage_adapters/abfs/tests/AbfsFileSystemTest.cpp b/velox/connectors/hive/storage_adapters/abfs/tests/AbfsFileSystemTest.cpp
index 245c6931cb3..6b8db42f4e1 100644
--- a/velox/connectors/hive/storage_adapters/abfs/tests/AbfsFileSystemTest.cpp
+++ b/velox/connectors/hive/storage_adapters/abfs/tests/AbfsFileSystemTest.cpp
@@ -14,10 +14,11 @@
  * limitations under the License.
  */
 
+#include <azure/core/io/body_stream.hpp>
 #include <gtest/gtest.h>
 #include <atomic>
-#include <filesystem>
 #include <random>
+#include <string_view>
 
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/config/Config.h"
@@ -30,6 +31,7 @@
 #include "connectors/hive/storage_adapters/abfs/AzureClientProviderFactories.h"
 #include "connectors/hive/storage_adapters/abfs/AzureClientProviderImpl.h"
 #include "connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.h"
+#include "velox/common/testutil/TempFilePath.h"
 #include "velox/connectors/hive/storage_adapters/abfs/AbfsReadFile.h"
 #include "velox/connectors/hive/storage_adapters/abfs/AbfsWriteFile.h"
 #include "velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.h"
@@ -37,15 +39,87 @@
 #include "velox/connectors/hive/storage_adapters/abfs/tests/MockDataLakeFileClient.h"
 #include "velox/dwio/common/FileSink.h"
 #include "velox/exec/tests/utils/PortUtil.h"
-#include "velox/exec/tests/utils/TempFilePath.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::filesystems;
+using namespace facebook::velox::common::testutil;
 using ::facebook::velox::common::Region;
 
 namespace {
 
-constexpr int kOneMB = 1 << 20;
+constexpr int kOneMB = 1'048'576;
+
+struct RecordedDownload {
+  int64_t offset{0};
+  int64_t length{0};
+};
+
+struct InMemoryReadState {
+  std::string data;
+  std::vector<RecordedDownload> downloads;
+};
+
+class InMemoryAzureBlobClient final : public AzureBlobClient {
+ public:
+  explicit InMemoryAzureBlobClient(std::shared_ptr<InMemoryReadState> state)
+      : state_(std::move(state)) {}
+
+  Azure::Response<Azure::Storage::Blobs::Models::BlobProperties> getProperties()
+      override {
+    VELOX_FAIL("Unexpected getProperties call.");
+  }
+
+  Azure::Response<Azure::Storage::Blobs::Models::DownloadBlobResult> download(
+      const Azure::Storage::Blobs::DownloadBlobOptions& options) override {
+    const auto& range = options.Range.Value();
+    const auto offset = range.Offset;
+    const auto length = range.Length.Value();
+
+    VELOX_CHECK_GE(offset, 0);
+    VELOX_CHECK_GE(length, 0);
+    VELOX_CHECK_LE(offset + length, static_cast<int64_t>(state_->data.size()));
+
+    state_->downloads.push_back({offset, length});
+
+    Azure::Storage::Blobs::Models::DownloadBlobResult result;
+    result.BodyStream = std::make_unique<Azure::Core::IO::MemoryBodyStream>(
+        reinterpret_cast<const uint8_t*>(state_->data.data() + offset),
+        static_cast<size_t>(length));
+    return Azure::Response<Azure::Storage::Blobs::Models::DownloadBlobResult>(
+        std::move(result), nullptr);
+  }
+
+  std::string getUrl() override {
+    return std::string{kUrl};
+  }
+
+ private:
+  static constexpr std::string_view kUrl =
+      "https://unit.blob.core.windows.net/container/test-file";
+
+  std::shared_ptr<InMemoryReadState> state_;
+};
+
+class InMemoryAzureClientProvider final : public AzureClientProvider {
+ public:
+  explicit InMemoryAzureClientProvider(std::shared_ptr<InMemoryReadState> state)
+      : state_(std::move(state)) {}
+
+  std::unique_ptr<AzureBlobClient> getReadFileClient(
+      const std::shared_ptr<AbfsPath>& path,
+      const config::ConfigBase& config) override {
+    return std::make_unique<InMemoryAzureBlobClient>(state_);
+  }
+
+  std::unique_ptr<AzureDataLakeFileClient> getWriteFileClient(
+      const std::shared_ptr<AbfsPath>& path,
+      const config::ConfigBase& config) override {
+    VELOX_FAIL("Unexpected getWriteFileClient call.");
+  }
+
+ private:
+  std::shared_ptr<InMemoryReadState> state_;
+};
 
 class TestAzureClientProvider final : public AzureClientProvider {
  public:
@@ -97,22 +171,24 @@ class AbfsFileSystemTest : public testing::Test {
   }
 
   static std::string generateRandomData(int size) {
-    static const char charset[] =
+    static constexpr std::string_view kCharacters =
         "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    std::mt19937 generator(std::random_device{}());
+    std::uniform_int_distribution<size_t> distribution(
+        0, kCharacters.size() - 1);
 
     std::string data(size, ' ');
 
     for (int i = 0; i < size; ++i) {
-      int index = rand() % (sizeof(charset) - 1);
-      data[i] = charset[index];
+      data[i] = kCharacters[distribution(generator)];
     }
 
     return data;
   }
 
  private:
-  static std::shared_ptr<::exec::test::TempFilePath> createFile() {
-    auto tempFile = exec::test::TempFilePath::create();
+  static std::shared_ptr<TempFilePath> createFile() {
+    auto tempFile = TempFilePath::create();
     tempFile->append("aaaaa");
     tempFile->append("bbbbb");
     tempFile->append(std::string(kOneMB, 'c'));
@@ -121,6 +197,8 @@ class AbfsFileSystemTest : public testing::Test {
   }
 };
 
+namespace {
+
 void readData(ReadFile* readFile) {
   ASSERT_EQ(readFile->size(), 15 + kOneMB);
   char buffer1[5];
@@ -169,6 +247,8 @@ void readData(ReadFile* readFile) {
       "ccccc");
 }
 
+} // namespace
+
 TEST_F(AbfsFileSystemTest, readFile) {
   auto readFile = abfs_->openFileForRead(azuriteServer_->fileURI());
   readData(readFile.get());
@@ -181,6 +261,74 @@ TEST_F(AbfsFileSystemTest, openFileForReadWithOptions) {
   readData(readFile.get());
 }
 
+TEST(AbfsReadFileTest, preadvUsesSingleDownloadForBuffersWithGaps) {
+  auto state = std::make_shared<InMemoryReadState>();
+  state->data = "0123456789abcdefghijklmn";
+
+  registerAzureClientProviderFactory("unit", [state](const std::string&) {
+    return std::make_unique<InMemoryAzureClientProvider>(state);
+  });
+
+  AbfsReadFile readFile{
+      "abfs://container@unit.dfs.core.windows.net/test-file",
+      config::ConfigBase({})};
+  FileOptions options;
+  options.fileSize = state->data.size();
+  readFile.initialize(options);
+
+  char firstBuffer[5];
+  char secondBuffer[5];
+  const std::vector<folly::Range<char*>> buffers = {
+      folly::Range<char*>(firstBuffer, sizeof(firstBuffer)),
+      folly::Range<char*>(nullptr, 7),
+      folly::Range<char*>(secondBuffer, sizeof(secondBuffer)),
+  };
+
+  ASSERT_EQ(17, readFile.preadv(2, buffers));
+  ASSERT_EQ(state->downloads.size(), 1);
+  EXPECT_EQ(state->downloads[0].offset, 2);
+  EXPECT_EQ(state->downloads[0].length, 17);
+  EXPECT_EQ(std::string_view(firstBuffer, sizeof(firstBuffer)), "23456");
+  EXPECT_EQ(std::string_view(secondBuffer, sizeof(secondBuffer)), "efghi");
+}
+
+TEST(AbfsReadFileTest, preadvUsesSingleDownloadForDefaultCoalescedGap) {
+  constexpr size_t kLeadingReadSize = 4;
+  constexpr size_t kGapSize = static_cast<size_t>(512) * 1'024;
+  constexpr size_t kTrailingReadSize = 4;
+
+  auto state = std::make_shared<InMemoryReadState>();
+  state->data = std::string(kLeadingReadSize, 'a') +
+      std::string(kGapSize, 'x') + std::string(kTrailingReadSize, 'b');
+
+  registerAzureClientProviderFactory(
+      "unit-large-gap", [state](const std::string&) {
+        return std::make_unique<InMemoryAzureClientProvider>(state);
+      });
+
+  AbfsReadFile readFile{
+      "abfs://container@unit-large-gap.dfs.core.windows.net/test-file",
+      config::ConfigBase({})};
+  FileOptions options;
+  options.fileSize = state->data.size();
+  readFile.initialize(options);
+
+  char firstBuffer[kLeadingReadSize];
+  char secondBuffer[kTrailingReadSize];
+  const std::vector<folly::Range<char*>> buffers = {
+      folly::Range<char*>(firstBuffer, sizeof(firstBuffer)),
+      folly::Range<char*>(nullptr, kGapSize),
+      folly::Range<char*>(secondBuffer, sizeof(secondBuffer)),
+  };
+
+  ASSERT_EQ(state->data.size(), readFile.preadv(0, buffers));
+  ASSERT_EQ(state->downloads.size(), 1);
+  EXPECT_EQ(state->downloads[0].offset, 0);
+  EXPECT_EQ(state->downloads[0].length, state->data.size());
+  EXPECT_EQ(std::string_view(firstBuffer, sizeof(firstBuffer)), "aaaa");
+  EXPECT_EQ(std::string_view(secondBuffer, sizeof(secondBuffer)), "bbbb");
+}
+
 TEST_F(AbfsFileSystemTest, openFileForReadWithInvalidOptions) {
   FileOptions options;
   options.fileSize = -kOneMB;
@@ -211,7 +359,7 @@ TEST_F(AbfsFileSystemTest, multipleThreadsWithReadFile) {
       0, sleepTimesInMicroseconds.size() - 1);
   for (int i = 0; i < 10; i++) {
     auto thread = std::thread([&] {
-      int index = distribution(generator);
+      const auto index = distribution(generator);
       while (!startThreads) {
         std::this_thread::yield();
       }
@@ -243,10 +391,9 @@ TEST(AbfsWriteFileTest, openFileForWriteTest) {
       reinterpret_cast<MockDataLakeFileClient*>(mockClient.get())->path();
   AbfsWriteFile abfsWriteFile(kAbfsFile, mockClient);
   EXPECT_EQ(abfsWriteFile.size(), 0);
-  std::string dataContent = "";
+  std::string dataContent;
   uint64_t totalSize = 0;
-  std::string randomData =
-      AbfsFileSystemTest::generateRandomData(1 * 1024 * 1024);
+  std::string randomData = AbfsFileSystemTest::generateRandomData(kOneMB);
   for (int i = 0; i < 8; ++i) {
     abfsWriteFile.append(randomData);
     dataContent += randomData;
@@ -255,11 +402,11 @@ TEST(AbfsWriteFileTest, openFileForWriteTest) {
   abfsWriteFile.flush();
   EXPECT_EQ(abfsWriteFile.size(), totalSize);
 
-  randomData = AbfsFileSystemTest::generateRandomData(9 * 1024 * 1024);
+  randomData = AbfsFileSystemTest::generateRandomData(9 * kOneMB);
   dataContent += randomData;
   abfsWriteFile.append(randomData);
   totalSize += randomData.size();
-  randomData = AbfsFileSystemTest::generateRandomData(2 * 1024 * 1024);
+  randomData = AbfsFileSystemTest::generateRandomData(2 * kOneMB);
   dataContent += randomData;
   totalSize += randomData.size();
   abfsWriteFile.append(randomData);
@@ -301,7 +448,7 @@ TEST_F(AbfsFileSystemTest, clientProviderFactoryNotRegistered) {
 }
 
 TEST_F(AbfsFileSystemTest, registerAbfsFileSink) {
-  static const std::vector<std::string> paths = {
+  const std::vector<std::string> paths = {
       "abfs://test@test.dfs.core.windows.net/test",
       "abfss://test@test.dfs.core.windows.net/test"};
   std::unordered_map<std::string, std::string> config(
diff --git a/velox/connectors/hive/storage_adapters/abfs/tests/AzuriteServer.h b/velox/connectors/hive/storage_adapters/abfs/tests/AzuriteServer.h
index 037c4d9f38d..9921db93845 100644
--- a/velox/connectors/hive/storage_adapters/abfs/tests/AzuriteServer.h
+++ b/velox/connectors/hive/storage_adapters/abfs/tests/AzuriteServer.h
@@ -15,7 +15,7 @@
  */
 
 #include "velox/common/config/Config.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 
 #include <azure/storage/blobs/blob_container_client.hpp>
 #include <azure/storage/blobs/block_blob_client.hpp>
@@ -28,6 +28,7 @@
 namespace facebook::velox::filesystems {
 
 using namespace Azure::Storage::Blobs;
+using TempDirectoryPath = common::testutil::TempDirectoryPath;
 static std::string_view kAzuriteServerExecutableName{"azurite-blob"};
 static std::string_view kAzuriteSearchPath{":/usr/bin/azurite"};
 
diff --git a/velox/connectors/hive/storage_adapters/abfs/tests/CMakeLists.txt b/velox/connectors/hive/storage_adapters/abfs/tests/CMakeLists.txt
index 8deb76801b0..a8a34147d78 100644
--- a/velox/connectors/hive/storage_adapters/abfs/tests/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/abfs/tests/CMakeLists.txt
@@ -18,9 +18,11 @@ add_executable(
   AbfsUtilTest.cpp
   AzureClientProvidersTest.cpp
   AzureClientProviderFactoriesTest.cpp
+  DynamicSasTokenClientProviderTest.cpp
   AzuriteServer.cpp
   MockDataLakeFileClient.cpp
 )
+velox_add_test_headers(velox_abfs_test AzuriteServer.h MockDataLakeFileClient.h)
 
 add_test(velox_abfs_test velox_abfs_test)
 target_link_libraries(
diff --git a/velox/connectors/hive/storage_adapters/abfs/tests/DynamicSasTokenClientProviderTest.cpp b/velox/connectors/hive/storage_adapters/abfs/tests/DynamicSasTokenClientProviderTest.cpp
new file mode 100644
index 00000000000..8793aea080b
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/tests/DynamicSasTokenClientProviderTest.cpp
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/storage_adapters/abfs/DynamicSasTokenClientProvider.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AzureClientProviderFactories.h"
+#include "velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.h"
+
+#include "gtest/gtest.h"
+
+#include <azure/storage/blobs/blob_sas_builder.hpp>
+#include <chrono>
+#include <cstdint>
+
+using namespace facebook::velox::filesystems;
+using namespace facebook::velox;
+
+namespace {
+
+class MyDynamicAbfsSasTokenProvider : public SasTokenProvider {
+ public:
+  MyDynamicAbfsSasTokenProvider(int64_t expiration)
+      : expirationSeconds_(expiration) {}
+
+  std::string getSasToken(
+      const std::string& fileSystem,
+      const std::string& path,
+      const std::string& operation) override {
+    const auto lastSlash = path.find_last_of("/");
+    const auto containerName = path.substr(0, lastSlash);
+    const auto blobName = path.substr(lastSlash + 1);
+
+    Azure::Storage::Sas::BlobSasBuilder sasBuilder;
+    sasBuilder.ExpiresOn = Azure::DateTime::clock::now() +
+        std::chrono::seconds(expirationSeconds_);
+    sasBuilder.BlobContainerName = containerName;
+    sasBuilder.BlobName = blobName;
+    sasBuilder.Resource = Azure::Storage::Sas::BlobSasResource::Blob;
+    sasBuilder.SetPermissions(
+        Azure::Storage::Sas::BlobSasPermissions::Read &
+        Azure::Storage::Sas::BlobSasPermissions::Write);
+
+    std::string sasToken = sasBuilder.GenerateSasToken(
+        Azure::Storage::StorageSharedKeyCredential(
+            "test",
+            "Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw=="));
+
+    // Remove the leading '?' from the SAS token.
+    if (sasToken[0] == '?') {
+      sasToken = sasToken.substr(1);
+    }
+
+    return sasToken;
+  }
+
+ private:
+  int64_t expirationSeconds_;
+};
+
+} // namespace
+
+TEST(DynamicSasTokenClientProviderTest, dynamicSasToken) {
+  {
+    const std::string account = "account1";
+    const config::ConfigBase config(
+        {{"fs.azure.account.auth.type.account1.dfs.core.windows.net", "SAS"},
+         {"fs.azure.sas.token.renew.period.for.streams", "1"}},
+        false);
+    registerAzureClientProviderFactory(account, [](const std::string&) {
+      auto sasTokenProvider =
+          std::make_shared<MyDynamicAbfsSasTokenProvider>(3);
+      return std::make_unique<DynamicSasTokenClientProvider>(sasTokenProvider);
+    });
+
+    auto abfsPath = std::make_shared<AbfsPath>(
+        fmt::format("abfs://abc@{}.dfs.core.windows.net/file", account));
+    auto readClient =
+        AzureClientProviderFactories::getReadFileClient(abfsPath, config);
+    auto writeClient =
+        AzureClientProviderFactories::getWriteFileClient(abfsPath, config);
+
+    auto readUrl = readClient->getUrl();
+    auto writeUrl = writeClient->getUrl();
+
+    // Let the current time pass 3 seconds to ensure the SAS token is expired.
+    std::this_thread::sleep_for(std::chrono::seconds(3)); // NOLINT
+
+    auto newReadUrl = readClient->getUrl();
+    ASSERT_NE(readUrl, newReadUrl);
+    // The SAS token should be reused.
+    ASSERT_EQ(newReadUrl, readClient->getUrl());
+
+    auto newWriteUrl = writeClient->getUrl();
+    ASSERT_NE(writeUrl, newWriteUrl);
+    // The SAS token should be reused.
+    ASSERT_EQ(newWriteUrl, writeClient->getUrl());
+  }
+
+  {
+    // SAS token expired by setting the renewal period to 120 seconds.
+    const std::string account = "account2";
+    const config::ConfigBase config(
+        {{"fs.azure.account.auth.type.account2.dfs.core.windows.net", "SAS"},
+         {"fs.azure.sas.token.renew.period.for.streams", "120"}},
+        false);
+    registerAzureClientProviderFactory(account, [](const std::string&) {
+      auto sasTokenProvider =
+          std::make_shared<MyDynamicAbfsSasTokenProvider>(60);
+      return std::make_unique<DynamicSasTokenClientProvider>(sasTokenProvider);
+    });
+
+    auto abfsPath = std::make_shared<AbfsPath>(
+        fmt::format("abfs://abc@{}.dfs.core.windows.net/file", account));
+    auto readClient =
+        AzureClientProviderFactories::getReadFileClient(abfsPath, config);
+    auto writeClient =
+        AzureClientProviderFactories::getWriteFileClient(abfsPath, config);
+
+    auto readUrl = readClient->getUrl();
+    auto writeUrl = writeClient->getUrl();
+
+    // Let the current time pass 3 seconds to ensure the timestamp in the SAS
+    // token is updated.
+    std::this_thread::sleep_for(std::chrono::seconds(3)); // NOLINT
+
+    // Sas token should be renewed because the time left is less than the
+    // renewal period.
+    ASSERT_NE(readUrl, readClient->getUrl());
+    ASSERT_NE(writeUrl, writeClient->getUrl());
+  }
+}
diff --git a/velox/connectors/hive/storage_adapters/abfs/tests/MockDataLakeFileClient.h b/velox/connectors/hive/storage_adapters/abfs/tests/MockDataLakeFileClient.h
index 560294414c8..d021a7d4259 100644
--- a/velox/connectors/hive/storage_adapters/abfs/tests/MockDataLakeFileClient.h
+++ b/velox/connectors/hive/storage_adapters/abfs/tests/MockDataLakeFileClient.h
@@ -14,11 +14,12 @@
  * limitations under the License.
  */
 
-#include "velox/exec/tests/utils/TempFilePath.h"
+#include "velox/common/testutil/TempFilePath.h"
 
 #include "velox/connectors/hive/storage_adapters/abfs/AzureDataLakeFileClient.h"
 
 using namespace Azure::Storage::Files::DataLake::Models;
+using namespace facebook::velox::common::testutil;
 
 namespace facebook::velox::filesystems {
 
@@ -26,7 +27,7 @@ namespace facebook::velox::filesystems {
 class MockDataLakeFileClient : public AzureDataLakeFileClient {
  public:
   MockDataLakeFileClient() {
-    auto tempFile = velox::exec::test::TempFilePath::create();
+    auto tempFile = TempFilePath::create();
     filePath_ = tempFile->getPath();
   }
 
diff --git a/velox/connectors/hive/storage_adapters/gcs/CMakeLists.txt b/velox/connectors/hive/storage_adapters/gcs/CMakeLists.txt
index 7e110edac19..2991a5e3123 100644
--- a/velox/connectors/hive/storage_adapters/gcs/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/gcs/CMakeLists.txt
@@ -14,7 +14,17 @@
 
 # for generated headers
 
-velox_add_library(velox_gcs RegisterGcsFileSystem.cpp)
+velox_add_library(
+  velox_gcs
+  RegisterGcsFileSystem.cpp
+  HEADERS
+  GcsFileSystem.h
+  GcsOAuthCredentialsProvider.h
+  GcsReadFile.h
+  GcsUtil.h
+  GcsWriteFile.h
+  RegisterGcsFileSystem.h
+)
 
 if(VELOX_ENABLE_GCS)
   velox_sources(velox_gcs PRIVATE GcsFileSystem.cpp GcsUtil.cpp GcsWriteFile.cpp GcsReadFile.cpp)
diff --git a/velox/connectors/hive/storage_adapters/gcs/GcsFileSystem.cpp b/velox/connectors/hive/storage_adapters/gcs/GcsFileSystem.cpp
index 897f7056171..8ec4873e28d 100644
--- a/velox/connectors/hive/storage_adapters/gcs/GcsFileSystem.cpp
+++ b/velox/connectors/hive/storage_adapters/gcs/GcsFileSystem.cpp
@@ -72,8 +72,9 @@ class GcsFileSystem::Impl {
  public:
   Impl(const std::string& bucket, const config::ConfigBase* config)
       : bucket_(bucket),
-        hiveConfig_(std::make_shared<HiveConfig>(
-            std::make_shared<config::ConfigBase>(config->rawConfigsCopy()))) {}
+        hiveConfig_(
+            std::make_shared<HiveConfig>(std::make_shared<config::ConfigBase>(
+                config->rawConfigsCopy()))) {}
 
   ~Impl() = default;
 
diff --git a/velox/connectors/hive/storage_adapters/gcs/GcsReadFile.cpp b/velox/connectors/hive/storage_adapters/gcs/GcsReadFile.cpp
index 072a4f7a37f..3379e15bd6c 100644
--- a/velox/connectors/hive/storage_adapters/gcs/GcsReadFile.cpp
+++ b/velox/connectors/hive/storage_adapters/gcs/GcsReadFile.cpp
@@ -59,7 +59,7 @@ class GcsReadFile::Impl {
       uint64_t length,
       void* buffer,
       std::atomic<uint64_t>& bytesRead,
-      filesystems::File::IoStats* stats = nullptr) const {
+      const FileIoContext& context) const {
     preadInternal(offset, length, static_cast<char*>(buffer), bytesRead);
     return {static_cast<char*>(buffer), length};
   }
@@ -68,7 +68,7 @@ class GcsReadFile::Impl {
       uint64_t offset,
       uint64_t length,
       std::atomic<uint64_t>& bytesRead,
-      filesystems::File::IoStats* stats = nullptr) const {
+      const FileIoContext& context) const {
     std::string result(length, 0);
     char* position = result.data();
     preadInternal(offset, length, position, bytesRead);
@@ -79,7 +79,7 @@ class GcsReadFile::Impl {
       uint64_t offset,
       const std::vector<folly::Range<char*>>& buffers,
       std::atomic<uint64_t>& bytesRead,
-      filesystems::File::IoStats* stats = nullptr) const {
+      const FileIoContext& context) const {
     // 'buffers' contains Ranges(data, size)  with some gaps (data = nullptr) in
     // between. This call must populate the ranges (except gap ranges)
     // sequentially starting from 'offset'. If a range pointer is nullptr, the
@@ -158,21 +158,21 @@ std::string_view GcsReadFile::pread(
     uint64_t offset,
     uint64_t length,
     void* buffer,
-    filesystems::File::IoStats* stats) const {
-  return impl_->pread(offset, length, buffer, bytesRead_, stats);
+    const FileIoContext& context) const {
+  return impl_->pread(offset, length, buffer, bytesRead_, context);
 }
 
 std::string GcsReadFile::pread(
     uint64_t offset,
     uint64_t length,
-    filesystems::File::IoStats* stats) const {
-  return impl_->pread(offset, length, bytesRead_, stats);
+    const FileIoContext& context) const {
+  return impl_->pread(offset, length, bytesRead_, context);
 }
 uint64_t GcsReadFile::preadv(
     uint64_t offset,
     const std::vector<folly::Range<char*>>& buffers,
-    filesystems::File::IoStats* stats) const {
-  return impl_->preadv(offset, buffers, bytesRead_, stats);
+    const FileIoContext& context) const {
+  return impl_->preadv(offset, buffers, bytesRead_, context);
 }
 
 uint64_t GcsReadFile::size() const {
diff --git a/velox/connectors/hive/storage_adapters/gcs/GcsReadFile.h b/velox/connectors/hive/storage_adapters/gcs/GcsReadFile.h
index a3d328996ec..035bc597ab5 100644
--- a/velox/connectors/hive/storage_adapters/gcs/GcsReadFile.h
+++ b/velox/connectors/hive/storage_adapters/gcs/GcsReadFile.h
@@ -38,17 +38,17 @@ class GcsReadFile : public ReadFile {
       uint64_t offset,
       uint64_t length,
       void* buffer,
-      filesystems::File::IoStats* stats = nullptr) const override;
+      const FileIoContext& context = {}) const override;
 
   std::string pread(
       uint64_t offset,
       uint64_t length,
-      filesystems::File::IoStats* stats = nullptr) const override;
+      const FileIoContext& context = {}) const override;
 
   uint64_t preadv(
       uint64_t offset,
       const std::vector<folly::Range<char*>>& buffers,
-      filesystems::File::IoStats* stats = nullptr) const override;
+      const FileIoContext& context = {}) const override;
 
   uint64_t size() const override;
 
diff --git a/velox/connectors/hive/storage_adapters/gcs/RegisterGcsFileSystem.cpp b/velox/connectors/hive/storage_adapters/gcs/RegisterGcsFileSystem.cpp
index d1ae189c7f8..13e9c94e1db 100644
--- a/velox/connectors/hive/storage_adapters/gcs/RegisterGcsFileSystem.cpp
+++ b/velox/connectors/hive/storage_adapters/gcs/RegisterGcsFileSystem.cpp
@@ -103,7 +103,8 @@ std::unique_ptr<velox::dwio::common::FileSink> gcsWriteFileSinkGenerator(
         fileSystem->openFileForWrite(fileURI, {{}, options.pool, std::nullopt}),
         fileURI,
         options.metricLogger,
-        options.stats);
+        options.stats,
+        options.fileSystemStats);
   }
   return nullptr;
 }
diff --git a/velox/connectors/hive/storage_adapters/gcs/tests/CMakeLists.txt b/velox/connectors/hive/storage_adapters/gcs/tests/CMakeLists.txt
index f462c45f9d3..b75f7492c5a 100644
--- a/velox/connectors/hive/storage_adapters/gcs/tests/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/gcs/tests/CMakeLists.txt
@@ -13,6 +13,7 @@
 # limitations under the License.
 
 add_executable(velox_gcs_file_test GcsUtilTest.cpp GcsFileSystemTest.cpp)
+velox_add_test_headers(velox_gcs_file_test GcsEmulator.h)
 add_test(velox_gcs_file_test velox_gcs_file_test)
 target_link_libraries(
   velox_gcs_file_test
@@ -23,7 +24,7 @@ target_link_libraries(
   velox_file
   velox_gcs
   velox_hive_connector
-  velox_temp_path
+  velox_test_util
   GTest::gmock
   GTest::gtest
   GTest::gtest_main
@@ -37,6 +38,8 @@ target_link_libraries(
   velox_gcs
   velox_hive_config
   velox_core
+  velox_dwio_parquet_reader
+  velox_dwio_parquet_writer
   velox_exec_test_lib
   velox_dwio_common_exception
   velox_exec
diff --git a/velox/connectors/hive/storage_adapters/gcs/tests/GcsFileSystemTest.cpp b/velox/connectors/hive/storage_adapters/gcs/tests/GcsFileSystemTest.cpp
index 34c62d4a472..4aa0df8d123 100644
--- a/velox/connectors/hive/storage_adapters/gcs/tests/GcsFileSystemTest.cpp
+++ b/velox/connectors/hive/storage_adapters/gcs/tests/GcsFileSystemTest.cpp
@@ -17,13 +17,15 @@
 #include "velox/connectors/hive/storage_adapters/gcs/GcsFileSystem.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/File.h"
+#include "velox/common/testutil/TempFilePath.h"
 #include "velox/connectors/hive/storage_adapters/gcs/GcsUtil.h"
 #include "velox/connectors/hive/storage_adapters/gcs/RegisterGcsFileSystem.h"
 #include "velox/connectors/hive/storage_adapters/gcs/tests/GcsEmulator.h"
-#include "velox/exec/tests/utils/TempFilePath.h"
 
 #include "gtest/gtest.h"
 
+using namespace facebook::velox::common::testutil;
+
 namespace facebook::velox::filesystems {
 namespace {
 
@@ -60,8 +62,8 @@ TEST_F(GcsFileSystemTest, readFile) {
   EXPECT_EQ(size, ref_size);
   EXPECT_EQ(readFile->pread(0, size), kLoremIpsum);
 
-  char buffer1[size];
-  ASSERT_EQ(readFile->pread(0, size, &buffer1), kLoremIpsum);
+  std::vector<char> buffer1(size);
+  ASSERT_EQ(readFile->pread(0, size, buffer1.data()), kLoremIpsum);
   ASSERT_EQ(readFile->size(), ref_size);
 
   char buffer2[50];
@@ -252,7 +254,7 @@ TEST_F(GcsFileSystemTest, credentialsConfig) {
       "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
       "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/foo-email%40foo-project.iam.gserviceaccount.com"
   })""";
-  auto jsonFile = exec::test::TempFilePath::create();
+  auto jsonFile = TempFilePath::create();
   std::ofstream credsOut(jsonFile->getPath());
   credsOut << kCreds;
   credsOut.close();
diff --git a/velox/connectors/hive/storage_adapters/gcs/tests/GcsMultipleEndpointsTest.cpp b/velox/connectors/hive/storage_adapters/gcs/tests/GcsMultipleEndpointsTest.cpp
index 00bb3310a06..e8ae75c715e 100644
--- a/velox/connectors/hive/storage_adapters/gcs/tests/GcsMultipleEndpointsTest.cpp
+++ b/velox/connectors/hive/storage_adapters/gcs/tests/GcsMultipleEndpointsTest.cpp
@@ -18,6 +18,7 @@
 #include <folly/init/Init.h>
 
 #include "gtest/gtest.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
 #include "velox/connectors/hive/storage_adapters/gcs/RegisterGcsFileSystem.h"
@@ -70,8 +71,10 @@ class GcsMultipleEndpointsTest : public testing::Test,
         std::string(connectorId2),
         gcsEmulatorTwo_->hiveConfig(config2Override),
         ioExecutor_.get());
-    connector::registerConnector(hiveConnector1);
-    connector::registerConnector(hiveConnector2);
+    connector::ConnectorRegistry::global().insert(
+        hiveConnector1->connectorId(), hiveConnector1);
+    connector::ConnectorRegistry::global().insert(
+        hiveConnector2->connectorId(), hiveConnector2);
   }
 
   void TearDown() override {
@@ -100,7 +103,8 @@ class GcsMultipleEndpointsTest : public testing::Test,
     // Second column contains details about written files.
     auto details = results->childAt(exec::TableWriteTraits::kFragmentChannel)
                        ->as<FlatVector<StringView>>();
-    folly::dynamic obj = folly::parseJson(details->valueAt(1));
+    folly::dynamic obj =
+        folly::parseJson(std::string_view(details->valueAt(1)));
     return obj["fileWriteInfos"];
   }
 
@@ -191,8 +195,8 @@ TEST_F(GcsMultipleEndpointsTest, baseEndpoints) {
 
   testJoin(kExpectedRows, gcsBucket, kConnectorId1, kConnectorId2);
 
-  connector::unregisterConnector(std::string(kConnectorId1));
-  connector::unregisterConnector(std::string(kConnectorId2));
+  connector::ConnectorRegistry::global().erase(std::string(kConnectorId1));
+  connector::ConnectorRegistry::global().erase(std::string(kConnectorId2));
 }
 
 } // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/hdfs/CMakeLists.txt b/velox/connectors/hive/storage_adapters/hdfs/CMakeLists.txt
index 8c49f3e11ed..087397c1c38 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/hdfs/CMakeLists.txt
@@ -14,7 +14,16 @@
 
 # for generated headers
 
-velox_add_library(velox_hdfs RegisterHdfsFileSystem.cpp)
+velox_add_library(
+  velox_hdfs
+  RegisterHdfsFileSystem.cpp
+  HEADERS
+  HdfsFileSystem.h
+  HdfsReadFile.h
+  HdfsUtil.h
+  HdfsWriteFile.h
+  RegisterHdfsFileSystem.h
+)
 
 if(VELOX_ENABLE_HDFS)
   velox_sources(velox_hdfs PRIVATE HdfsFileSystem.cpp HdfsReadFile.cpp HdfsWriteFile.cpp)
diff --git a/velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.cpp b/velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.cpp
index aedd1fe44d3..46522ab2a6f 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.cpp
+++ b/velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.cpp
@@ -56,11 +56,29 @@ class HdfsFileSystem::Impl {
   }
 
   ~Impl() {
-    LOG(INFO) << "Disconnecting HDFS file system";
-    int disconnectResult = driver_->Disconnect(hdfsClient_);
-    if (disconnectResult != 0) {
-      LOG(WARNING) << "hdfs disconnect failure in HdfsReadFile close: "
-                   << errno;
+    if (!closed_) {
+      LOG(WARNING)
+          << "The HdfsFileSystem instance is not closed upon destruction. You must explicitly call the close() API before JVM termination to ensure proper disconnection.";
+    }
+  }
+
+  // The HdfsFileSystem::Disconnect operation requires the JVM method
+  // definitions to be loaded within an active JVM process.
+  // Therefore, it must be invoked before the JVM shuts down.
+
+  // To address this, we’ve introduced a new close() API that performs the
+  // disconnect operation. Third-party applications can call this close() method
+  // prior to JVM termination to ensure proper cleanup.
+  void close() {
+    if (!closed_) {
+      LOG(WARNING) << "Disconnecting HDFS file system";
+      int disconnectResult = driver_->Disconnect(hdfsClient_);
+      if (disconnectResult != 0) {
+        LOG(WARNING) << "hdfs disconnect failure in HdfsReadFile close: "
+                     << errno;
+      }
+
+      closed_ = true;
     }
   }
 
@@ -75,6 +93,7 @@ class HdfsFileSystem::Impl {
  private:
   hdfsFS hdfsClient_;
   filesystems::arrow::io::internal::LibHdfsShim* driver_;
+  bool closed_ = false;
 };
 
 HdfsFileSystem::HdfsFileSystem(
@@ -109,6 +128,10 @@ std::unique_ptr<WriteFile> HdfsFileSystem::openFileForWrite(
       impl_->hdfsShim(), impl_->hdfsClient(), path);
 }
 
+void HdfsFileSystem::close() {
+  impl_->close();
+}
+
 bool HdfsFileSystem::isHdfsFile(const std::string_view filePath) {
   return (filePath.find(kScheme) == 0) || (filePath.find(kViewfsScheme) == 0);
 }
diff --git a/velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.h b/velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.h
index cebe40aa890..9720bb13034 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.h
+++ b/velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.h
@@ -61,6 +61,8 @@ class HdfsFileSystem : public FileSystem {
       std::string_view path,
       const FileOptions& options = {}) override;
 
+  void close();
+
   // Deletes the hdfs files.
   void remove(std::string_view path) override;
 
diff --git a/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.cpp b/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.cpp
index affc1dfd2ed..94adb31a742 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.cpp
+++ b/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.cpp
@@ -103,12 +103,17 @@ class HdfsReadFile::Impl {
     }
   }
 
-  std::string_view pread(uint64_t offset, uint64_t length, void* buf) const {
+  std::string_view pread(
+      uint64_t offset,
+      uint64_t length,
+      void* buf,
+      const FileIoContext& context) const {
     preadInternal(offset, length, static_cast<char*>(buf));
     return {static_cast<char*>(buf), length};
   }
 
-  std::string pread(uint64_t offset, uint64_t length) const {
+  std::string
+  pread(uint64_t offset, uint64_t length, const FileIoContext& context) const {
     std::string result(length, 0);
     char* pos = result.data();
     preadInternal(offset, length, pos);
@@ -163,15 +168,15 @@ std::string_view HdfsReadFile::pread(
     uint64_t offset,
     uint64_t length,
     void* buf,
-    filesystems::File::IoStats* stats) const {
-  return pImpl->pread(offset, length, buf);
+    const FileIoContext& context) const {
+  return pImpl->pread(offset, length, buf, context);
 }
 
 std::string HdfsReadFile::pread(
     uint64_t offset,
     uint64_t length,
-    filesystems::File::IoStats* stats) const {
-  return pImpl->pread(offset, length);
+    const FileIoContext& context) const {
+  return pImpl->pread(offset, length, context);
 }
 
 uint64_t HdfsReadFile::size() const {
diff --git a/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.h b/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.h
index ddd35e511a7..6208702eab5 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.h
+++ b/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.h
@@ -38,12 +38,12 @@ class HdfsReadFile final : public ReadFile {
       uint64_t offset,
       uint64_t length,
       void* buf,
-      filesystems::File::IoStats* stats = nullptr) const final;
+      const FileIoContext& context = {}) const final;
 
   std::string pread(
       uint64_t offset,
       uint64_t length,
-      filesystems::File::IoStats* stats = nullptr) const final;
+      const FileIoContext& context = {}) const final;
 
   uint64_t size() const final;
 
diff --git a/velox/connectors/hive/storage_adapters/hdfs/HdfsWriteFile.cpp b/velox/connectors/hive/storage_adapters/hdfs/HdfsWriteFile.cpp
index be668a3133e..26d43ccb910 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/HdfsWriteFile.cpp
+++ b/velox/connectors/hive/storage_adapters/hdfs/HdfsWriteFile.cpp
@@ -54,12 +54,14 @@ HdfsWriteFile::~HdfsWriteFile() {
 
 void HdfsWriteFile::close() {
   int success = driver_->CloseFile(hdfsClient_, hdfsFile_);
+  common::testutil::TestValue::adjust(
+      "facebook::velox::connectors::hive::HdfsWriteFile::close", &success);
+  hdfsFile_ = nullptr;
   VELOX_CHECK_EQ(
       success,
       0,
       "Failed to close hdfs file: {}",
       driver_->GetLastExceptionRootCause());
-  hdfsFile_ = nullptr;
 }
 
 void HdfsWriteFile::flush() {
diff --git a/velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.cpp b/velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.cpp
index 1f23179f0a7..d8b31e806d1 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.cpp
+++ b/velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.cpp
@@ -28,44 +28,48 @@ namespace facebook::velox::filesystems {
 #ifdef VELOX_ENABLE_HDFS
 std::mutex mtx;
 
+folly::ConcurrentHashMap<std::string, std::shared_ptr<HdfsFileSystem>>
+    registeredFilesystems;
+
 std::function<std::shared_ptr<
     FileSystem>(std::shared_ptr<const config::ConfigBase>, std::string_view)>
 hdfsFileSystemGenerator() {
-  static auto filesystemGenerator = [](std::shared_ptr<const config::ConfigBase>
-                                           properties,
-                                       std::string_view filePath) {
-    static folly::ConcurrentHashMap<std::string, std::shared_ptr<FileSystem>>
-        filesystems;
-    static folly::
-        ConcurrentHashMap<std::string, std::shared_ptr<folly::once_flag>>
-            hdfsInitiationFlags;
-    HdfsServiceEndpoint endpoint =
-        HdfsFileSystem::getServiceEndpoint(filePath, properties.get());
-    std::string hdfsIdentity = endpoint.identity();
-    if (filesystems.find(hdfsIdentity) != filesystems.end()) {
-      return filesystems[hdfsIdentity];
-    }
-    std::unique_lock<std::mutex> lk(mtx, std::defer_lock);
-    /// If the init flag for a given hdfs identity is not found,
-    /// create one for init use. It's a singleton.
-    if (hdfsInitiationFlags.find(hdfsIdentity) == hdfsInitiationFlags.end()) {
-      lk.lock();
-      if (hdfsInitiationFlags.find(hdfsIdentity) == hdfsInitiationFlags.end()) {
-        std::shared_ptr<folly::once_flag> initiationFlagPtr =
-            std::make_shared<folly::once_flag>();
-        hdfsInitiationFlags.insert(hdfsIdentity, initiationFlagPtr);
-      }
-      lk.unlock();
-    }
-    folly::call_once(
-        *hdfsInitiationFlags[hdfsIdentity].get(),
-        [&properties, endpoint, hdfsIdentity]() {
-          auto filesystem =
-              std::make_shared<HdfsFileSystem>(properties, endpoint);
-          filesystems.insert(hdfsIdentity, filesystem);
-        });
-    return filesystems[hdfsIdentity];
-  };
+  static auto filesystemGenerator =
+      [](std::shared_ptr<const config::ConfigBase> properties,
+         std::string_view filePath) {
+        static folly::
+            ConcurrentHashMap<std::string, std::shared_ptr<folly::once_flag>>
+                hdfsInitiationFlags;
+        HdfsServiceEndpoint endpoint =
+            HdfsFileSystem::getServiceEndpoint(filePath, properties.get());
+        std::string hdfsIdentity = endpoint.identity();
+        if (registeredFilesystems.find(hdfsIdentity) !=
+            registeredFilesystems.end()) {
+          return registeredFilesystems[hdfsIdentity];
+        }
+        std::unique_lock<std::mutex> lk(mtx, std::defer_lock);
+        /// If the init flag for a given hdfs identity is not found,
+        /// create one for init use. It's a singleton.
+        if (hdfsInitiationFlags.find(hdfsIdentity) ==
+            hdfsInitiationFlags.end()) {
+          lk.lock();
+          if (hdfsInitiationFlags.find(hdfsIdentity) ==
+              hdfsInitiationFlags.end()) {
+            std::shared_ptr<folly::once_flag> initiationFlagPtr =
+                std::make_shared<folly::once_flag>();
+            hdfsInitiationFlags.insert(hdfsIdentity, initiationFlagPtr);
+          }
+          lk.unlock();
+        }
+        folly::call_once(
+            *hdfsInitiationFlags[hdfsIdentity].get(),
+            [&properties, endpoint, hdfsIdentity]() {
+              auto filesystem =
+                  std::make_shared<HdfsFileSystem>(properties, endpoint);
+              registeredFilesystems.insert(hdfsIdentity, filesystem);
+            });
+        return registeredFilesystems[hdfsIdentity];
+      };
   return filesystemGenerator;
 }
 
@@ -85,7 +89,8 @@ hdfsWriteFileSinkGenerator() {
               fileSystem->openFileForWrite(pathSuffix),
               fileURI,
               options.metricLogger,
-              options.stats);
+              options.stats,
+              options.fileSystemStats);
         }
         return static_cast<std::unique_ptr<dwio::common::WriteFileSink>>(
             nullptr);
diff --git a/velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.h b/velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.h
index 6f6f0c032bd..18eef4aca17 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.h
+++ b/velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.h
@@ -16,8 +16,15 @@
 
 #pragma once
 
+#include "folly/concurrency/ConcurrentHashMap.h"
+
 namespace facebook::velox::filesystems {
 
+class HdfsFileSystem;
+
+extern folly::ConcurrentHashMap<std::string, std::shared_ptr<HdfsFileSystem>>
+    registeredFilesystems;
+
 // Register the HDFS.
 void registerHdfsFileSystem();
 
diff --git a/velox/connectors/hive/storage_adapters/hdfs/tests/CMakeLists.txt b/velox/connectors/hive/storage_adapters/hdfs/tests/CMakeLists.txt
index a0ad9d67e99..7a6b0832765 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/tests/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/hdfs/tests/CMakeLists.txt
@@ -13,6 +13,7 @@
 # limitations under the License.
 
 add_executable(velox_hdfs_file_test HdfsFileSystemTest.cpp HdfsMiniCluster.cpp HdfsUtilTest.cpp)
+velox_add_test_headers(velox_hdfs_file_test HdfsMiniCluster.h)
 
 add_test(velox_hdfs_file_test velox_hdfs_file_test)
 target_link_libraries(
@@ -32,11 +33,15 @@ target_link_libraries(
 target_compile_options(velox_hdfs_file_test PRIVATE -Wno-deprecated-declarations)
 
 add_executable(velox_hdfs_insert_test HdfsInsertTest.cpp HdfsMiniCluster.cpp HdfsUtilTest.cpp)
+velox_add_test_headers(velox_hdfs_insert_test HdfsMiniCluster.h)
 
 add_test(velox_hdfs_insert_test velox_hdfs_insert_test)
 
 target_link_libraries(
   velox_hdfs_insert_test
+  velox_dwio_parquet_reader
+  velox_dwio_parquet_writer
+  velox_hdfs
   velox_exec_test_lib
   velox_exec
   GTest::gtest
@@ -49,7 +54,7 @@ target_compile_options(velox_hdfs_insert_test PRIVATE -Wno-deprecated-declaratio
 # velox_hdfs_insert_test and velox_hdfs_file_test two tests can't run in
 # parallel due to the port conflict in Hadoop NameNode and DataNode. The
 # namenode port conflict can be resolved using the -nnport configuration in
-# hadoop-mapreduce-client-jobclient-3.3.0-tests.jar. However the data node port
+# hadoop-mapreduce-client-jobclient-3.3.6-tests.jar. However the data node port
 # cannot be configured. Therefore, we need to make sure that
 # velox_hdfs_file_test runs only after velox_hdfs_insert_test has finished.
 set_tests_properties(velox_hdfs_insert_test PROPERTIES DEPENDS velox_hdfs_file_test)
diff --git a/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsFileSystemTest.cpp b/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsFileSystemTest.cpp
index e5c0883284b..e20e8761a07 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsFileSystemTest.cpp
+++ b/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsFileSystemTest.cpp
@@ -21,16 +21,18 @@
 #include "gtest/gtest.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TempFilePath.h"
+#include "velox/common/testutil/TestValue.h"
 #include "velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.h"
 #include "velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.h"
 #include "velox/connectors/hive/storage_adapters/hdfs/tests/HdfsMiniCluster.h"
 #include "velox/core/QueryConfig.h"
-#include "velox/exec/tests/utils/TempFilePath.h"
 #include "velox/external/hdfs/ArrowHdfsInternal.h"
 
 #include <unistd.h>
 
 using namespace facebook::velox;
+using namespace facebook::velox::common::testutil;
 
 using filesystems::arrow::io::internal::LibHdfsShim;
 
@@ -72,6 +74,11 @@ class HdfsFileSystemTest : public testing::Test {
   }
 
   static void TearDownTestSuite() {
+    for (const auto& [_, filesystem] :
+         facebook::velox::filesystems::registeredFilesystems) {
+      filesystem->close();
+    }
+
     miniCluster->stop();
   }
 
@@ -88,8 +95,8 @@ class HdfsFileSystemTest : public testing::Test {
   static std::string fullDestinationPath_;
 
  private:
-  static std::shared_ptr<::exec::test::TempFilePath> createFile() {
-    auto tempFile = exec::test::TempFilePath::create();
+  static std::shared_ptr<TempFilePath> createFile() {
+    auto tempFile = TempFilePath::create();
     tempFile->append("aaaaa");
     tempFile->append("bbbbb");
     tempFile->append(std::string(kOneMB, 'c'));
@@ -520,3 +527,34 @@ TEST_F(HdfsFileSystemTest, readFailures) {
       std::string(miniCluster->nameNodePort()));
   verifyFailures(driver, hdfs);
 }
+
+DEBUG_ONLY_TEST_F(HdfsFileSystemTest, writeFilePreventsDoubleClose) {
+  common::testutil::TestValue::enable();
+
+  int closeCallCount = 0;
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::connectors::hive::HdfsWriteFile::close",
+      std::function<void(int*)>([&closeCallCount](int* success) {
+        ++closeCallCount;
+        if (closeCallCount == 1) {
+          *success = -1;
+        }
+      }));
+
+  auto writeFile = openFileForWrite("/test_double_close.txt");
+
+  writeFile->append("test data");
+  writeFile->flush();
+
+  VELOX_ASSERT_THROW(writeFile->close(), "Failed to close hdfs file:");
+
+  EXPECT_EQ(closeCallCount, 1);
+
+  // Destructor should not call close() again because hdfsFile_ is nullptr
+  // The closeCallCount should remain 1.
+  writeFile.reset();
+  EXPECT_EQ(closeCallCount, 1);
+
+  common::testutil::TestValue::disable();
+}
diff --git a/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsInsertTest.cpp b/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsInsertTest.cpp
index 9ec9a125415..ed2287a7c42 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsInsertTest.cpp
+++ b/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsInsertTest.cpp
@@ -17,6 +17,7 @@
 #include "gtest/gtest.h"
 
 #include "velox/common/memory/Memory.h"
+#include "velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.h"
 #include "velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.h"
 #include "velox/connectors/hive/storage_adapters/hdfs/tests/HdfsMiniCluster.h"
 #include "velox/connectors/hive/storage_adapters/test_common/InsertTest.h"
@@ -47,6 +48,10 @@ class HdfsInsertTest : public testing::Test, public InsertTest {
   }
 
   void TearDown() override {
+    for (const auto& [_, filesystem] :
+         facebook::velox::filesystems::registeredFilesystems) {
+      filesystem->close();
+    }
     InsertTest::TearDown();
     miniCluster->stop();
   }
diff --git a/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsMiniCluster.h b/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsMiniCluster.h
index c54ae9589b3..62b45609d80 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsMiniCluster.h
+++ b/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsMiniCluster.h
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 
 #include <pwd.h>
 #include <unistd.h>
@@ -22,11 +22,14 @@
 #include "boost/process.hpp"
 
 namespace facebook::velox::filesystems::test {
+
+using TempDirectoryPath = common::testutil::TempDirectoryPath;
+
 static const std::string kMiniClusterExecutableName{"hadoop"};
 static const std::string kHadoopSearchPath{":/usr/local/hadoop/bin"};
 static const std::string kJarCommand{"jar"};
 static const std::string kMiniclusterJar{
-    "/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-3.3.0-tests.jar"};
+    "/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-3.3.6-tests.jar"};
 static const std::string kMiniclusterCommand{"minicluster"};
 static const std::string kNoMapReduceOption{"-nomr"};
 static const std::string kFormatNameNodeOption{"-format"};
diff --git a/velox/connectors/hive/storage_adapters/s3fs/CMakeLists.txt b/velox/connectors/hive/storage_adapters/s3fs/CMakeLists.txt
index 741f01a61b3..91be9ee864c 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/s3fs/CMakeLists.txt
@@ -14,7 +14,18 @@
 
 # for generated headers
 
-velox_add_library(velox_s3fs RegisterS3FileSystem.cpp)
+velox_add_library(
+  velox_s3fs
+  RegisterS3FileSystem.cpp
+  HEADERS
+  RegisterS3FileSystem.h
+  S3Config.h
+  S3Counters.h
+  S3FileSystem.h
+  S3ReadFile.h
+  S3Util.h
+  S3WriteFile.h
+)
 if(VELOX_ENABLE_S3)
   velox_sources(
     velox_s3fs
diff --git a/velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.cpp b/velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.cpp
index 62d014090a4..630bb411327 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.cpp
@@ -102,7 +102,8 @@ std::unique_ptr<velox::dwio::common::FileSink> s3WriteFileSinkGenerator(
         fileSystem->openFileForWrite(fileURI, {{}, options.pool, std::nullopt}),
         fileURI,
         options.metricLogger,
-        options.stats);
+        options.stats,
+        options.fileSystemStats);
   }
   return nullptr;
 }
diff --git a/velox/connectors/hive/storage_adapters/s3fs/S3Config.cpp b/velox/connectors/hive/storage_adapters/s3fs/S3Config.cpp
index a82a3be4562..b006a4e42e9 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/S3Config.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/S3Config.cpp
@@ -21,6 +21,9 @@
 
 namespace facebook::velox::filesystems {
 
+static constexpr size_t kMinimumMultipartMinPartSize = 5U << 20; // 5MB
+static constexpr size_t kMaximumMultipartMinPartSize = 5U << 30; // 5GB
+
 std::string S3Config::cacheKey(
     std::string_view bucket,
     std::shared_ptr<const config::ConfigBase> config) {
@@ -72,6 +75,15 @@ S3Config::S3Config(
   }
   payloadSigningPolicy_ =
       properties->get<std::string>(kS3PayloadSigningPolicy, "Never");
+
+  VELOX_CHECK_GE(
+      minPartSize(),
+      kMinimumMultipartMinPartSize,
+      "The min-part-size S3 configuration must exceed 5MB.");
+  VELOX_CHECK_LE(
+      minPartSize(),
+      kMaximumMultipartMinPartSize,
+      "The min-part-size S3 configuration must not exceed 5GB.");
 }
 
 std::optional<std::string> S3Config::endpointRegion() const {
@@ -87,4 +99,10 @@ std::optional<std::string> S3Config::endpointRegion() const {
   return region;
 }
 
+size_t S3Config::minPartSize() const {
+  return config::toCapacity(
+      config_.find(Keys::kMultipartMinPartSize)->second.value(),
+      config::CapacityUnit::BYTE);
+}
+
 } // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/s3fs/S3Config.h b/velox/connectors/hive/storage_adapters/s3fs/S3Config.h
index 4fad4379925..cd094a59832 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/S3Config.h
+++ b/velox/connectors/hive/storage_adapters/s3fs/S3Config.h
@@ -76,6 +76,8 @@ class S3Config {
     kRetryMode,
     kUseProxyFromEnv,
     kCredentialsProvider,
+    kIMDSEnabled,
+    kMultipartMinPartSize,
     kEnd
   };
 
@@ -114,6 +116,9 @@ class S3Config {
              std::make_pair("use-proxy-from-env", "false")},
             {Keys::kCredentialsProvider,
              std::make_pair("aws-credentials-provider", std::nullopt)},
+            {Keys::kIMDSEnabled, std::make_pair("aws-imds-enabled", "true")},
+            {Keys::kMultipartMinPartSize,
+             std::make_pair("min-part-size", "10MB")},
         };
     return config;
   }
@@ -243,6 +248,14 @@ class S3Config {
     return config_.find(Keys::kCredentialsProvider)->second;
   }
 
+  /// Returns true if IMDS is enabled in the configuration settings
+  bool useIMDS() const {
+    auto value = config_.find(Keys::kIMDSEnabled)->second.value();
+    return folly::to<bool>(value);
+  }
+
+  size_t minPartSize() const;
+
  private:
   std::unordered_map<Keys, std::optional<std::string>> config_;
   std::string payloadSigningPolicy_;
diff --git a/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.cpp b/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.cpp
index cdc456ee94b..d96fd7707dc 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.cpp
@@ -229,23 +229,30 @@ void registerCredentialsProvider(
 
 class S3FileSystem::Impl {
  public:
-  Impl(const S3Config& s3Config) {
+  explicit Impl(std::shared_ptr<S3Config> s3Config)
+      : s3Config_(std::move(s3Config)) {
     VELOX_CHECK(getAwsInstance()->isInitialized(), "S3 is not initialized");
-    Aws::S3::S3ClientConfiguration clientConfig;
-    if (s3Config.endpoint().has_value()) {
-      clientConfig.endpointOverride = s3Config.endpoint().value();
+    Aws::Client::ClientConfigurationInitValues initValues;
+    initValues.shouldDisableIMDS = !s3Config_->useIMDS();
+    Aws::S3::S3ClientConfiguration clientConfig(initValues);
+    clientConfig.checksumConfig.requestChecksumCalculation =
+        Aws::Client::RequestChecksumCalculation::WHEN_REQUIRED;
+    clientConfig.checksumConfig.responseChecksumValidation =
+        Aws::Client::ResponseChecksumValidation::WHEN_REQUIRED;
+    if (s3Config_->endpoint().has_value()) {
+      clientConfig.endpointOverride = s3Config_->endpoint().value();
     }
 
-    if (s3Config.endpointRegion().has_value()) {
-      clientConfig.region = s3Config.endpointRegion().value();
+    if (s3Config_->endpointRegion().has_value()) {
+      clientConfig.region = s3Config_->endpointRegion().value();
     }
 
-    if (s3Config.useProxyFromEnv()) {
+    if (s3Config_->useProxyFromEnv()) {
       auto proxyConfig =
           S3ProxyConfigurationBuilder(
-              s3Config.endpoint().has_value() ? s3Config.endpoint().value()
-                                              : "")
-              .useSsl(s3Config.useSSL())
+              s3Config_->endpoint().has_value() ? s3Config_->endpoint().value()
+                                                : "")
+              .useSsl(s3Config_->useSSL())
               .build();
       if (proxyConfig.has_value()) {
         clientConfig.proxyScheme = Aws::Http::SchemeMapper::FromString(
@@ -257,42 +264,42 @@ class S3FileSystem::Impl {
       }
     }
 
-    if (s3Config.useSSL()) {
+    if (s3Config_->useSSL()) {
       clientConfig.scheme = Aws::Http::Scheme::HTTPS;
     } else {
       clientConfig.scheme = Aws::Http::Scheme::HTTP;
     }
 
-    if (s3Config.connectTimeout().has_value()) {
+    if (s3Config_->connectTimeout().has_value()) {
       clientConfig.connectTimeoutMs =
           std::chrono::duration_cast<std::chrono::milliseconds>(
               facebook::velox::config::toDuration(
-                  s3Config.connectTimeout().value()))
+                  s3Config_->connectTimeout().value()))
               .count();
     }
 
-    if (s3Config.socketTimeout().has_value()) {
+    if (s3Config_->socketTimeout().has_value()) {
       clientConfig.requestTimeoutMs =
           std::chrono::duration_cast<std::chrono::milliseconds>(
               facebook::velox::config::toDuration(
-                  s3Config.socketTimeout().value()))
+                  s3Config_->socketTimeout().value()))
               .count();
     }
 
-    if (s3Config.maxConnections().has_value()) {
-      clientConfig.maxConnections = s3Config.maxConnections().value();
+    if (s3Config_->maxConnections().has_value()) {
+      clientConfig.maxConnections = s3Config_->maxConnections().value();
     }
 
-    auto retryStrategy = getRetryStrategy(s3Config);
+    auto retryStrategy = getRetryStrategy(s3Config_);
     if (retryStrategy.has_value()) {
       clientConfig.retryStrategy = retryStrategy.value();
     }
 
-    clientConfig.useVirtualAddressing = s3Config.useVirtualAddressing();
+    clientConfig.useVirtualAddressing = s3Config_->useVirtualAddressing();
     clientConfig.payloadSigningPolicy =
-        inferPayloadSign(s3Config.payloadSigningPolicy());
+        inferPayloadSign(s3Config_->payloadSigningPolicy());
 
-    auto credentialsProvider = getCredentialsProvider(s3Config);
+    auto credentialsProvider = getCredentialsProvider(*s3Config_);
 
     client_ = std::make_shared<Aws::S3::S3Client>(
         credentialsProvider, nullptr /* endpointProvider */, clientConfig);
@@ -376,9 +383,9 @@ class S3FileSystem::Impl {
 
   // Return a client RetryStrategy based on the config.
   std::optional<std::shared_ptr<Aws::Client::RetryStrategy>> getRetryStrategy(
-      const S3Config& s3Config) const {
-    auto retryMode = s3Config.retryMode();
-    auto maxAttempts = s3Config.maxAttempts();
+      const std::shared_ptr<S3Config>& s3Config) const {
+    auto retryMode = s3Config->retryMode();
+    auto maxAttempts = s3Config->maxAttempts();
     if (retryMode.has_value()) {
       if (retryMode.value() == "standard") {
         if (maxAttempts.has_value()) {
@@ -441,16 +448,21 @@ class S3FileSystem::Impl {
     return getAwsInstance()->getLogPrefix();
   }
 
+  std::shared_ptr<S3Config> getS3Config() {
+    return s3Config_;
+  }
+
  private:
   std::shared_ptr<Aws::S3::S3Client> client_;
+  std::shared_ptr<S3Config> s3Config_;
 };
 
 S3FileSystem::S3FileSystem(
     std::string_view bucketName,
     const std::shared_ptr<const config::ConfigBase> config)
     : FileSystem(config) {
-  S3Config s3Config(bucketName, config);
-  impl_ = std::make_shared<Impl>(s3Config);
+  auto s3Config = std::make_shared<S3Config>(bucketName, config);
+  impl_ = std::make_shared<Impl>(std::move(s3Config));
 }
 
 std::string S3FileSystem::getLogLevelName() const {
@@ -474,8 +486,8 @@ std::unique_ptr<WriteFile> S3FileSystem::openFileForWrite(
     std::string_view s3Path,
     const FileOptions& options) {
   const auto path = getPath(s3Path);
-  auto s3file =
-      std::make_unique<S3WriteFile>(path, impl_->s3Client(), options.pool);
+  auto s3file = std::make_unique<S3WriteFile>(
+      path, impl_->s3Client(), options.pool, impl_->getS3Config());
   return s3file;
 }
 
diff --git a/velox/connectors/hive/storage_adapters/s3fs/S3ReadFile.cpp b/velox/connectors/hive/storage_adapters/s3fs/S3ReadFile.cpp
index 06d180b19f7..f19587114eb 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/S3ReadFile.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/S3ReadFile.cpp
@@ -79,13 +79,13 @@ class S3ReadFile ::Impl {
       uint64_t offset,
       uint64_t length,
       void* buffer,
-      File::IoStats* stats) const {
+      const FileIoContext& context) const {
     preadInternal(offset, length, static_cast<char*>(buffer));
     return {static_cast<char*>(buffer), length};
   }
 
-  std::string pread(uint64_t offset, uint64_t length, File::IoStats* stats)
-      const {
+  std::string
+  pread(uint64_t offset, uint64_t length, const FileIoContext& context) const {
     std::string result(length, 0);
     char* position = result.data();
     preadInternal(offset, length, position);
@@ -95,7 +95,7 @@ class S3ReadFile ::Impl {
   uint64_t preadv(
       uint64_t offset,
       const std::vector<folly::Range<char*>>& buffers,
-      File::IoStats* stats) const {
+      const FileIoContext& context) const {
     // 'buffers' contains Ranges(data, size)  with some gaps (data = nullptr) in
     // between. This call must populate the ranges (except gap ranges)
     // sequentially starting from 'offset'. AWS S3 GetObject does not support
@@ -183,22 +183,22 @@ std::string_view S3ReadFile::pread(
     uint64_t offset,
     uint64_t length,
     void* buf,
-    filesystems::File::IoStats* stats) const {
-  return impl_->pread(offset, length, buf, stats);
+    const FileIoContext& context) const {
+  return impl_->pread(offset, length, buf, context);
 }
 
 std::string S3ReadFile::pread(
     uint64_t offset,
     uint64_t length,
-    filesystems::File::IoStats* stats) const {
-  return impl_->pread(offset, length, stats);
+    const FileIoContext& context) const {
+  return impl_->pread(offset, length, context);
 }
 
 uint64_t S3ReadFile::preadv(
     uint64_t offset,
     const std::vector<folly::Range<char*>>& buffers,
-    filesystems::File::IoStats* stats) const {
-  return impl_->preadv(offset, buffers, stats);
+    const FileIoContext& context) const {
+  return impl_->preadv(offset, buffers, context);
 }
 
 uint64_t S3ReadFile::size() const {
diff --git a/velox/connectors/hive/storage_adapters/s3fs/S3ReadFile.h b/velox/connectors/hive/storage_adapters/s3fs/S3ReadFile.h
index 0b08ed0ec18..deca155abb0 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/S3ReadFile.h
+++ b/velox/connectors/hive/storage_adapters/s3fs/S3ReadFile.h
@@ -35,17 +35,17 @@ class S3ReadFile : public ReadFile {
       uint64_t offset,
       uint64_t length,
       void* buf,
-      filesystems::File::IoStats* stats = nullptr) const final;
+      const FileIoContext& context = {}) const final;
 
   std::string pread(
       uint64_t offset,
       uint64_t length,
-      filesystems::File::IoStats* stats = nullptr) const final;
+      const FileIoContext& context = {}) const final;
 
   uint64_t preadv(
       uint64_t offset,
       const std::vector<folly::Range<char*>>& buffers,
-      filesystems::File::IoStats* stats = nullptr) const final;
+      const FileIoContext& context = {}) const final;
 
   uint64_t size() const final;
 
diff --git a/velox/connectors/hive/storage_adapters/s3fs/S3Util.cpp b/velox/connectors/hive/storage_adapters/s3fs/S3Util.cpp
index 9470f858884..8f982131d4c 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/S3Util.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/S3Util.cpp
@@ -157,7 +157,7 @@ std::optional<std::string> parseAWSStandardRegionName(
   const std::string_view kAmazonHostSuffix = ".amazonaws.com";
   auto index = endpoint.size() - kAmazonHostSuffix.size();
   // Handle the case where the endpoint ends in a trailing slash.
-  if (endpoint.back() == '/') {
+  if (!endpoint.empty() && endpoint.back() == '/') {
     index--;
   }
   if (endpoint.rfind(kAmazonHostSuffix) != index) {
diff --git a/velox/connectors/hive/storage_adapters/s3fs/S3Util.h b/velox/connectors/hive/storage_adapters/s3fs/S3Util.h
index ab2e25790d0..125d9cc805b 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/S3Util.h
+++ b/velox/connectors/hive/storage_adapters/s3fs/S3Util.h
@@ -204,7 +204,7 @@ std::optional<std::string> parseAWSStandardRegionName(
 class S3ProxyConfigurationBuilder {
  public:
   S3ProxyConfigurationBuilder(const std::string& s3Endpoint)
-      : s3Endpoint_(s3Endpoint){};
+      : s3Endpoint_(s3Endpoint) {}
 
   S3ProxyConfigurationBuilder& useSsl(const bool& useSsl) {
     useSsl_ = useSsl;
@@ -237,7 +237,7 @@ class StringViewStream : Aws::Utils::Stream::PreallocatedStreamBuf,
 
 template <>
 struct fmt::formatter<Aws::Http::HttpResponseCode> : formatter<int> {
-  auto format(Aws::Http::HttpResponseCode s, format_context& ctx) {
+  auto format(Aws::Http::HttpResponseCode s, format_context& ctx) const {
     return formatter<int>::format(static_cast<int>(s), ctx);
   }
 };
diff --git a/velox/connectors/hive/storage_adapters/s3fs/S3WriteFile.cpp b/velox/connectors/hive/storage_adapters/s3fs/S3WriteFile.cpp
index fcccfe240ab..1acf2ee08fa 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/S3WriteFile.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/S3WriteFile.cpp
@@ -16,6 +16,7 @@
 
 #include "velox/connectors/hive/storage_adapters/s3fs/S3WriteFile.h"
 #include "velox/common/base/StatsReporter.h"
+#include "velox/connectors/hive/storage_adapters/s3fs/S3Config.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/S3Counters.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/S3Util.h"
 #include "velox/dwio/common/DataBuffer.h"
@@ -29,6 +30,7 @@
 #include <aws/s3/model/CreateMultipartUploadRequest.h>
 #include <aws/s3/model/HeadBucketRequest.h>
 #include <aws/s3/model/HeadObjectRequest.h>
+#include <aws/s3/model/PutObjectRequest.h>
 #include <aws/s3/model/UploadPartRequest.h>
 
 namespace facebook::velox::filesystems {
@@ -38,13 +40,14 @@ class S3WriteFile::Impl {
   explicit Impl(
       std::string_view path,
       Aws::S3::S3Client* client,
-      memory::MemoryPool* pool)
-      : client_(client), pool_(pool) {
+      memory::MemoryPool* pool,
+      const std::shared_ptr<S3Config>& s3Config)
+      : client_(client), pool_(pool), minPartSize_(s3Config->minPartSize()) {
     VELOX_CHECK_NOT_NULL(client);
     VELOX_CHECK_NOT_NULL(pool);
     getBucketAndKeyFromPath(path, bucket_, key_);
     currentPart_ = std::make_unique<dwio::common::DataBuffer<char>>(*pool_);
-    currentPart_->reserve(kPartUploadSize);
+    currentPart_->reserve(minPartSize_);
     // Check that the object doesn't exist, if it does throw an error.
     {
       Aws::S3::Model::HeadObjectRequest request;
@@ -77,36 +80,60 @@ class S3WriteFile::Impl {
             outcome, "Failed to create S3 bucket", bucket_, "");
       }
     }
+    fileSize_ = 0;
+  }
 
-    // Initiate the multi-part upload.
-    {
-      Aws::S3::Model::CreateMultipartUploadRequest request;
-      request.SetBucket(awsString(bucket_));
-      request.SetKey(awsString(key_));
+  void createMultipartUploadRequest() {
+    Aws::S3::Model::CreateMultipartUploadRequest request;
+    request.SetBucket(awsString(bucket_));
+    request.SetKey(awsString(key_));
 
-      /// If we do not set anything then the SDK will default to application/xml
-      /// which confuses some tools
-      /// (https://github.com/apache/arrow/issues/11934). So we instead default
-      /// to application/octet-stream which is less misleading.
-      request.SetContentType(kApplicationOctetStream);
-      // The default algorithm used is MD5. However, MD5 is not supported with
-      // fips and can cause a SIGSEGV. Set CRC32 instead which is a standard for
-      // checksum computation and is not restricted by fips.
-      request.SetChecksumAlgorithm(Aws::S3::Model::ChecksumAlgorithm::CRC32);
+    /// If we do not set anything then the SDK will default to application/xml
+    /// which confuses some tools
+    /// (https://github.com/apache/arrow/issues/11934). So we instead default
+    /// to application/octet-stream which is less misleading.
+    request.SetContentType(kApplicationOctetStream);
+    auto outcome = client_->CreateMultipartUpload(request);
+    VELOX_CHECK_AWS_OUTCOME(
+        outcome, "Failed initiating multiple part upload", bucket_, key_);
+    uploadState_.id = outcome.GetResult().GetUploadId();
+  }
 
-      auto outcome = client_->CreateMultipartUpload(request);
-      VELOX_CHECK_AWS_OUTCOME(
-          outcome, "Failed initiating multiple part upload", bucket_, key_);
-      uploadState_.id = outcome.GetResult().GetUploadId();
-    }
+  // This uploads the buffer as a single object. This is used if we deal with
+  // buffers smaller than min-part-size.
 
-    fileSize_ = 0;
+  void putObjectRequest() {
+    Aws::S3::Model::PutObjectRequest request;
+    request.SetBucket(awsString(bucket_));
+    request.SetKey(awsString(key_));
+
+    /// If we do not set anything then the SDK will default to application/xml
+    /// which confuses some tools
+    /// (https://github.com/apache/arrow/issues/11934). So we instead default
+    /// to application/octet-stream which is less misleading.
+    request.SetContentType(kApplicationOctetStream);
+    request.SetContentLength(currentPart_->size());
+    request.SetBody(
+        std::make_shared<StringViewStream>(
+            currentPart_->data(), currentPart_->size()));
+    RECORD_METRIC_VALUE(kMetricS3StartedUploads);
+    auto outcome = client_->PutObject(request);
+    VELOX_CHECK_AWS_OUTCOME(
+        outcome, "Failed single object upload", bucket_, key_);
+    if (outcome.IsSuccess()) {
+      RECORD_METRIC_VALUE(kMetricS3SuccessfulUploads);
+    } else {
+      RECORD_METRIC_VALUE(kMetricS3FailedUploads);
+    }
   }
 
   // Appends data to the end of the file.
   void append(std::string_view data) {
     VELOX_CHECK(!closed(), "File is closed");
-    if (data.size() + currentPart_->size() >= kPartUploadSize) {
+    if (data.size() + currentPart_->size() > minPartSize_) {
+      if (uploadState_.partNumber == 0) {
+        createMultipartUploadRequest();
+      }
       upload(data);
     } else {
       // Append to current part.
@@ -118,16 +145,26 @@ class S3WriteFile::Impl {
   // No-op.
   void flush() {
     VELOX_CHECK(!closed(), "File is closed");
-    /// currentPartSize must be less than kPartUploadSize since
-    /// append() would have already flushed after reaching kUploadPartSize.
-    VELOX_CHECK_LT(currentPart_->size(), kPartUploadSize);
+    /// currentPartSize must be less than minPartSize since
+    /// append() would have already flushed after reaching minPartSize.
+    VELOX_CHECK_LT(currentPart_->size(), minPartSize_);
   }
 
-  // Complete the multipart upload and close the file.
+  // Send the buffer in a single request or complete the multipart upload.
+  // Then close the file.
   void close() {
     if (closed()) {
       return;
     }
+    // If we haven't sent anything yet, that is the file is less then
+    // minFileSize_. lets put the object that is in the buffer.
+    if (uploadState_.partNumber == 0) {
+      // Send single request.
+      putObjectRequest();
+      currentPart_->clear();
+      return;
+    }
+
     RECORD_METRIC_VALUE(kMetricS3StartedUploads);
     uploadPart({currentPart_->data(), currentPart_->size()}, true);
     VELOX_CHECK_EQ(uploadState_.partNumber, uploadState_.completedParts.size());
@@ -163,7 +200,6 @@ class S3WriteFile::Impl {
   }
 
  private:
-  static constexpr int64_t kPartUploadSize = 10 * 1024 * 1024;
   static constexpr const char* kApplicationOctetStream =
       "application/octet-stream";
 
@@ -179,8 +215,8 @@ class S3WriteFile::Impl {
   };
   UploadState uploadState_;
 
-  // Data can be smaller or larger than the kPartUploadSize.
-  // Complete the currentPart_ and upload kPartUploadSize chunks of data.
+  // Data can be smaller or larger than the minPartSize_.
+  // Complete the currentPart_ and upload minPartSize_ chunks of data.
   // Save the remaining into currentPart_.
   void upload(const std::string_view data) {
     auto dataPtr = data.data();
@@ -191,18 +227,18 @@ class S3WriteFile::Impl {
     uploadPart({currentPart_->data(), currentPart_->size()});
     dataPtr += remainingBufferSize;
     dataSize -= remainingBufferSize;
-    while (dataSize > kPartUploadSize) {
-      uploadPart({dataPtr, kPartUploadSize});
-      dataPtr += kPartUploadSize;
-      dataSize -= kPartUploadSize;
+    while (dataSize > minPartSize_) {
+      uploadPart({dataPtr, minPartSize_});
+      dataPtr += minPartSize_;
+      dataSize -= minPartSize_;
     }
     // Stash the remaining at the beginning of currentPart.
     currentPart_->unsafeAppend(0, dataPtr, dataSize);
   }
 
   void uploadPart(const std::string_view part, bool isLast = false) {
-    // Only the last part can be less than kPartUploadSize.
-    VELOX_CHECK(isLast || (!isLast && (part.size() == kPartUploadSize)));
+    // Only the last part can be less than minPartSize.
+    VELOX_CHECK(isLast || (!isLast && (part.size() == minPartSize_)));
     // Upload the part.
     {
       Aws::S3::Model::UploadPartRequest request;
@@ -213,10 +249,6 @@ class S3WriteFile::Impl {
       request.SetContentLength(part.size());
       request.SetBody(
           std::make_shared<StringViewStream>(part.data(), part.size()));
-      // The default algorithm used is MD5. However, MD5 is not supported with
-      // fips and can cause a SIGSEGV. Set CRC32 instead which is a standard for
-      // checksum computation and is not restricted by fips.
-      request.SetChecksumAlgorithm(Aws::S3::Model::ChecksumAlgorithm::CRC32);
       auto outcome = client_->UploadPart(request);
       VELOX_CHECK_AWS_OUTCOME(outcome, "Failed to upload", bucket_, key_);
       // Append ETag and part number for this uploaded part.
@@ -241,13 +273,15 @@ class S3WriteFile::Impl {
   std::string bucket_;
   std::string key_;
   size_t fileSize_ = -1;
+  const size_t minPartSize_;
 };
 
 S3WriteFile::S3WriteFile(
     std::string_view path,
     Aws::S3::S3Client* client,
-    memory::MemoryPool* pool) {
-  impl_ = std::make_shared<Impl>(path, client, pool);
+    memory::MemoryPool* pool,
+    const std::shared_ptr<S3Config>& s3Config) {
+  impl_ = std::make_shared<Impl>(path, client, pool, s3Config);
 }
 
 void S3WriteFile::append(std::string_view data) {
diff --git a/velox/connectors/hive/storage_adapters/s3fs/S3WriteFile.h b/velox/connectors/hive/storage_adapters/s3fs/S3WriteFile.h
index 929eed20c37..ef4ad2968d2 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/S3WriteFile.h
+++ b/velox/connectors/hive/storage_adapters/s3fs/S3WriteFile.h
@@ -25,20 +25,25 @@ class S3Client;
 
 namespace facebook::velox::filesystems {
 
+class S3Config;
+
 /// S3WriteFile uses the Apache Arrow implementation as a reference.
 /// AWS C++ SDK allows streaming writes via the MultiPart upload API.
 /// Multipart upload allows you to upload a single object as a set of parts.
 /// Each part is a contiguous portion of the object's data.
 /// While AWS and Minio support different sizes for each
-/// part (only requiring a minimum of 5MB), Cloudflare R2 requires that every
-/// part be exactly equal (except for the last part). We set this to 10 MiB, so
-/// that in combination with the maximum number of parts of 10,000, this gives a
-/// file limit of 100k MiB (or about 98 GiB).
-/// (see https://docs.aws.amazon.com/AmazonS3/latest/userguide/qfacts.html)
-/// (for rational, see: https://github.com/apache/arrow/issues/34363)
-/// You can upload these object parts independently and in any order.
-/// After all parts of your object are uploaded, Amazon S3 assembles these parts
-/// and creates the object.
+/// part (only requiring a minimum of 5MB - but not enforced), Apache Ozone
+/// enforces the minimum 5MB (smaller parts are ignored), and Cloudflare R2
+/// requires that every part be exactly equal (except for the last part). We set
+/// this to minPartSize (default 10MB), so that in combination with the maximum
+/// number of parts of 10,000, this gives a file limit of 100k MiB (or about 98
+/// GiB).
+/// (for rationale, see: https://github.com/apache/arrow/issues/34363)
+/// For AWS limits see
+/// https://docs.aws.amazon.com/AmazonS3/latest/userguide/qfacts.html). You can
+/// upload these object parts independently and in any order. After all parts of
+/// your object are uploaded, Amazon S3 assembles these parts and creates the
+/// object.
 /// https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html
 /// https://github.com/apache/arrow/blob/main/cpp/src/arrow/filesystem/s3fs.cc
 /// S3WriteFile is not thread-safe.
@@ -50,7 +55,8 @@ class S3WriteFile : public WriteFile {
   S3WriteFile(
       std::string_view path,
       Aws::S3::S3Client* client,
-      memory::MemoryPool* pool);
+      memory::MemoryPool* pool,
+      const std::shared_ptr<S3Config>& s3Config);
 
   /// Appends data to the end of the file.
   /// Uploads a part on reaching part size limit.
@@ -69,6 +75,8 @@ class S3WriteFile : public WriteFile {
   int numPartsUploaded() const;
 
  protected:
+  void createMultipartUploadRequest();
+
   class Impl;
   std::shared_ptr<Impl> impl_;
 };
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/CMakeLists.txt b/velox/connectors/hive/storage_adapters/s3fs/tests/CMakeLists.txt
index 9d92727e767..4de74413313 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/tests/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/CMakeLists.txt
@@ -23,6 +23,7 @@ target_link_libraries(
 )
 
 add_executable(velox_s3file_test S3FileSystemTest.cpp S3UtilTest.cpp)
+velox_add_test_headers(velox_s3file_test MinioServer.h S3Test.h)
 add_test(velox_s3file_test velox_s3file_test)
 target_link_libraries(
   velox_s3file_test
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/MinioServer.h b/velox/connectors/hive/storage_adapters/s3fs/tests/MinioServer.h
index 591ed403f35..164bb590518 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/tests/MinioServer.h
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/MinioServer.h
@@ -17,13 +17,15 @@
 #pragma once
 
 #include "velox/common/config/Config.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/exec/tests/utils/PortUtil.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 #include "boost/process.hpp"
 
 using namespace facebook::velox;
 
+using TempDirectoryPath = common::testutil::TempDirectoryPath;
+
 namespace {
 constexpr char const* kMinioExecutableName{"minio-2022-05-26"};
 constexpr char const* kMinioAccessKey{"minio"};
@@ -34,7 +36,7 @@ constexpr char const* kMinioSecretKey{"miniopass"};
 // Adapted from the Apache Arrow library.
 class MinioServer {
  public:
-  MinioServer() : tempPath_(::exec::test::TempDirectoryPath::create()) {
+  MinioServer() : tempPath_(TempDirectoryPath::create()) {
     constexpr auto kHostAddressTemplate = "127.0.0.1:{}";
     auto ports = facebook::velox::exec::test::getFreePorts(2);
     connectionString_ = fmt::format(kHostAddressTemplate, ports[0]);
@@ -74,7 +76,7 @@ class MinioServer {
   }
 
  private:
-  const std::shared_ptr<exec::test::TempDirectoryPath> tempPath_;
+  const std::shared_ptr<TempDirectoryPath> tempPath_;
   std::string connectionString_;
   std::string consoleAddress_;
   const std::string accessKey_ = kMinioAccessKey;
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/S3ConfigTest.cpp b/velox/connectors/hive/storage_adapters/s3fs/tests/S3ConfigTest.cpp
index e8d48fe6edd..20b10268677 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/tests/S3ConfigTest.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/S3ConfigTest.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/connectors/hive/storage_adapters/s3fs/S3Config.h"
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/config/Config.h"
 
 #include <gtest/gtest.h>
@@ -37,6 +38,8 @@ TEST(S3ConfigTest, defaultConfig) {
   ASSERT_EQ(s3Config.payloadSigningPolicy(), "Never");
   ASSERT_EQ(s3Config.cacheKey("foo", config), "foo");
   ASSERT_EQ(s3Config.bucket(), "");
+  ASSERT_EQ(s3Config.useIMDS(), true);
+  ASSERT_EQ(s3Config.minPartSize(), 10485760);
 }
 
 TEST(S3ConfigTest, overrideConfig) {
@@ -53,7 +56,9 @@ TEST(S3ConfigTest, overrideConfig) {
       {S3Config::baseConfigKey(S3Config::Keys::kIamRole), "iam"},
       {S3Config::baseConfigKey(S3Config::Keys::kIamRoleSessionName), "velox"},
       {S3Config::baseConfigKey(S3Config::Keys::kCredentialsProvider),
-       "my-credentials-provider"}};
+       "my-credentials-provider"},
+      {S3Config::baseConfigKey(S3Config::Keys::kIMDSEnabled), "false"},
+      {S3Config::baseConfigKey(S3Config::Keys::kMultipartMinPartSize), "20MB"}};
   auto configBase =
       std::make_shared<config::ConfigBase>(std::move(configFromFile));
   auto s3Config = S3Config("bucket", configBase);
@@ -71,6 +76,8 @@ TEST(S3ConfigTest, overrideConfig) {
   ASSERT_EQ(s3Config.cacheKey("bar", configBase), "endpoint-bar");
   ASSERT_EQ(s3Config.bucket(), "bucket");
   ASSERT_EQ(s3Config.credentialsProvider(), "my-credentials-provider");
+  ASSERT_EQ(s3Config.useIMDS(), false);
+  ASSERT_EQ(s3Config.minPartSize(), 20971520);
 }
 
 TEST(S3ConfigTest, overrideBucketConfig) {
@@ -95,7 +102,9 @@ TEST(S3ConfigTest, overrideBucketConfig) {
       {S3Config::baseConfigKey(S3Config::Keys::kCredentialsProvider),
        "my-credentials-provider"},
       {S3Config::bucketConfigKey(S3Config::Keys::kCredentialsProvider, bucket),
-       "override-credentials-provider"}};
+       "override-credentials-provider"},
+      {S3Config::baseConfigKey(S3Config::Keys::kIMDSEnabled), "false"},
+      {S3Config::baseConfigKey(S3Config::Keys::kMultipartMinPartSize), "20MB"}};
   auto configBase =
       std::make_shared<config::ConfigBase>(std::move(bucketConfigFromFile));
   auto s3Config = S3Config(bucket, configBase);
@@ -115,6 +124,50 @@ TEST(S3ConfigTest, overrideBucketConfig) {
       "bucket.s3-region.amazonaws.com-bucket");
   ASSERT_EQ(s3Config.cacheKey("foo", configBase), "endpoint-foo");
   ASSERT_EQ(s3Config.credentialsProvider(), "override-credentials-provider");
+  ASSERT_EQ(s3Config.useIMDS(), false);
+  ASSERT_EQ(s3Config.minPartSize(), 20971520);
+}
+
+TEST(S3ConfigTest, minPartSizeValidation) {
+  // Test that setting min-part-size below 5MB throws an error.
+  std::unordered_map<std::string, std::string> configFromFile = {
+      {S3Config::baseConfigKey(S3Config::Keys::kMultipartMinPartSize), "4MB"}};
+  auto configBase =
+      std::make_shared<config::ConfigBase>(std::move(configFromFile));
+
+  VELOX_ASSERT_THROW(
+      S3Config("bucket", configBase),
+      "The min-part-size S3 configuration must exceed 5MB");
+
+  configFromFile = {
+      {S3Config::baseConfigKey(S3Config::Keys::kMultipartMinPartSize), "10GB"}};
+  configBase = std::make_shared<config::ConfigBase>(std::move(configFromFile));
+  VELOX_ASSERT_THROW(
+      S3Config("bucket", configBase),
+      "The min-part-size S3 configuration must not exceed 5GB");
+}
+
+TEST(S3ConfigTest, minPartSizeValidationBucketConfig) {
+  // Test that setting bucket-specific min-part-size below 5MB throws an error.
+  std::string_view bucket = "testbucket";
+  std::unordered_map<std::string, std::string> configFromFile = {
+      {S3Config::bucketConfigKey(S3Config::Keys::kMultipartMinPartSize, bucket),
+       "3MB"}};
+  auto configBase =
+      std::make_shared<config::ConfigBase>(std::move(configFromFile));
+
+  VELOX_ASSERT_THROW(
+      S3Config(bucket, configBase),
+      "The min-part-size S3 configuration must exceed 5MB");
+
+  configFromFile = {
+      {S3Config::bucketConfigKey(S3Config::Keys::kMultipartMinPartSize, bucket),
+       "10GB"}};
+  configBase = std::make_shared<config::ConfigBase>(std::move(configFromFile));
+
+  VELOX_ASSERT_THROW(
+      S3Config(bucket, configBase),
+      "The min-part-size S3 configuration must not exceed 5GB");
 }
 
 } // namespace
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemMetricsTest.cpp b/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemMetricsTest.cpp
index aba2ac90236..907acf92783 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemMetricsTest.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemMetricsTest.cpp
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #include <folly/init/Init.h>
 #include <functional>
 
@@ -24,8 +25,9 @@
 
 #include <gtest/gtest.h>
 
-namespace facebook::velox::filesystems {
+namespace facebook::velox::filesystems::test {
 namespace {
+
 class S3TestReporter : public BaseStatsReporter {
  public:
   mutable std::mutex m;
@@ -40,6 +42,7 @@ class S3TestReporter : public BaseStatsReporter {
     statTypeMap.clear();
     histogramPercentilesMap.clear();
   }
+
   void registerMetricExportType(const char* key, StatType statType)
       const override {
     statTypeMap[key] = statType;
@@ -68,18 +71,6 @@ class S3TestReporter : public BaseStatsReporter {
     histogramPercentilesMap[key.str()] = pcts;
   }
 
-  void registerQuantileMetricExportType(
-      const char* /* key */,
-      const std::vector<StatType>& /* statTypes */,
-      const std::vector<double>& /* pcts */,
-      const std::vector<size_t>& /* slidingWindowsSeconds */) const override {}
-
-  void registerQuantileMetricExportType(
-      folly::StringPiece /* key */,
-      const std::vector<StatType>& /* statTypes */,
-      const std::vector<double>& /* pcts */,
-      const std::vector<size_t>& /* slidingWindowsSeconds */) const override {}
-
   void addMetricValue(const std::string& key, const size_t value)
       const override {
     std::lock_guard<std::mutex> l(m);
@@ -110,42 +101,6 @@ class S3TestReporter : public BaseStatsReporter {
     counterMap[key.str()] = std::max(counterMap[key.str()], value);
   }
 
-  void addQuantileMetricValue(const std::string& /* key */, size_t /* value */)
-      const override {}
-
-  void addQuantileMetricValue(const char* /* key */, size_t /* value */)
-      const override {}
-
-  void addQuantileMetricValue(folly::StringPiece /* key */, size_t /* value */)
-      const override {}
-
-  void registerDynamicQuantileMetricExportType(
-      const char* /* keyPattern */,
-      const std::vector<StatType>& /* statTypes */,
-      const std::vector<double>& /* pcts */,
-      const std::vector<size_t>& /* slidingWindowsSeconds */) const override {}
-
-  void registerDynamicQuantileMetricExportType(
-      folly::StringPiece /* keyPattern */,
-      const std::vector<StatType>& /* statTypes */,
-      const std::vector<double>& /* pcts */,
-      const std::vector<size_t>& /* slidingWindowsSeconds */) const override {}
-
-  void addDynamicQuantileMetricValue(
-      const std::string& /* key */,
-      folly::Range<const folly::StringPiece*> /* subkeys */,
-      size_t /* value */) const override {}
-
-  void addDynamicQuantileMetricValue(
-      const char* /* key */,
-      folly::Range<const folly::StringPiece*> /* subkeys */,
-      size_t /* value */) const override {}
-
-  void addDynamicQuantileMetricValue(
-      folly::StringPiece /* key */,
-      folly::Range<const folly::StringPiece*> /* subkeys */,
-      size_t /* value */) const override {}
-
   std::string fetchMetrics() override {
     std::stringstream ss;
     ss << "[";
@@ -217,7 +172,7 @@ TEST_F(S3FileSystemMetricsTest, metrics) {
   EXPECT_EQ(1, s3Reporter->counterMap[std::string{kMetricS3GetObjectCalls}]);
 }
 
-} // namespace facebook::velox::filesystems
+} // namespace facebook::velox::filesystems::test
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemTest.cpp b/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemTest.cpp
index 3fea62365bb..a94e9b4c352 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemTest.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemTest.cpp
@@ -175,7 +175,7 @@ TEST_F(S3FileSystemTest, noBackendServer) {
   minioServer_->stop();
   VELOX_ASSERT_THROW(
       s3fs.openFileForRead(kDummyPath),
-      "Failed to get metadata for S3 object due to: 'Network connection'. Path:'s3://dummy/foo.txt', SDK Error Type:99, HTTP Status Code:-1, S3 Service:'Unknown', Message:'curlCode: 7, Couldn't connect to server'");
+      "Failed to get metadata for S3 object due to: 'Network connection'. Path:'s3://dummy/foo.txt', SDK Error Type:99, HTTP Status Code:-1, S3 Service:'Unknown', Message:'curlCode: 7, Couldn't connect to server");
   // Start Minio again.
   minioServer_->start();
 }
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/S3InsertTest.cpp b/velox/connectors/hive/storage_adapters/s3fs/tests/S3InsertTest.cpp
index 2f1e753e7ba..0861df83d48 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/tests/S3InsertTest.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/S3InsertTest.cpp
@@ -28,18 +28,21 @@ class S3InsertTest : public S3Test, public test::InsertTest {
  protected:
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+    filesystems::registerS3FileSystem();
+  }
+
+  static void TearDownTestCase() {
+    filesystems::finalizeS3FileSystem();
   }
 
   void SetUp() override {
     S3Test::SetUp();
-    filesystems::registerS3FileSystem();
     InsertTest::SetUp(minioServer_->hiveConfig(), ioExecutor_.get());
   }
 
   void TearDown() override {
     S3Test::TearDown();
     InsertTest::TearDown();
-    filesystems::finalizeS3FileSystem();
   }
 };
 } // namespace
@@ -51,6 +54,22 @@ TEST_F(S3InsertTest, s3InsertTest) {
 
   runInsertTest(kOutputDirectory, kExpectedRows, pool());
 }
+
+// Test with data exceeding the default 5MB minPartSize to trigger multipart
+// upload. This test generates enough data to exceed 5MB, which should trigger
+// at least one multipart upload part and a remainder.
+TEST_F(S3InsertTest, s3MultipartUploadTest) {
+  // Generate enough rows to exceed 5MB.
+  // Each row has 4 columns: BIGINT (8 bytes), INTEGER (4 bytes),
+  // SMALLINT (2 bytes), DOUBLE (8 bytes) = 22 bytes per row minimum.
+  // To exceed 5MB (5 * 1024 * 1024 = 5,242,880 bytes), we need at least
+  // 5,242,880 / 22 ≈ 238,313 rows. Let's use 300,000 rows to be safe.
+  const int64_t kExpectedRows = 300'000;
+  const std::string_view kOutputDirectory{"s3://multipartdata/"};
+  minioServer_->addBucket("multipartdata");
+
+  runInsertTest(kOutputDirectory, kExpectedRows, pool());
+}
 } // namespace facebook::velox::filesystems
 
 int main(int argc, char** argv) {
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/S3MultipleEndpointsTest.cpp b/velox/connectors/hive/storage_adapters/s3fs/tests/S3MultipleEndpointsTest.cpp
index cf446b12d2e..3c90521bb56 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/tests/S3MultipleEndpointsTest.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/S3MultipleEndpointsTest.cpp
@@ -17,6 +17,7 @@
 #include <folly/init/Init.h>
 
 #include "gtest/gtest.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/S3Util.h"
@@ -71,8 +72,10 @@ class S3MultipleEndpoints : public S3Test, public ::test::VectorTestBase {
         std::string(connectorId2),
         minioSecondServer_->hiveConfig(config2Override),
         ioExecutor_.get());
-    connector::registerConnector(hiveConnector1);
-    connector::registerConnector(hiveConnector2);
+    connector::ConnectorRegistry::global().insert(
+        hiveConnector1->connectorId(), hiveConnector1);
+    connector::ConnectorRegistry::global().insert(
+        hiveConnector2->connectorId(), hiveConnector2);
   }
 
   void TearDown() override {
@@ -102,7 +105,8 @@ class S3MultipleEndpoints : public S3Test, public ::test::VectorTestBase {
     // Second column contains details about written files.
     auto details = results->childAt(exec::TableWriteTraits::kFragmentChannel)
                        ->as<FlatVector<StringView>>();
-    folly::dynamic obj = folly::parseJson(details->valueAt(1));
+    folly::dynamic obj =
+        folly::parseJson(std::string_view(details->valueAt(1)));
     return obj["fileWriteInfos"];
   }
 
@@ -190,8 +194,8 @@ TEST_F(S3MultipleEndpoints, baseEndpoints) {
 
   testJoin(kExpectedRows, outputDirectory, kConnectorId1, kConnectorId2);
 
-  connector::unregisterConnector(std::string(kConnectorId1));
-  connector::unregisterConnector(std::string(kConnectorId2));
+  connector::ConnectorRegistry::global().erase(std::string(kConnectorId1));
+  connector::ConnectorRegistry::global().erase(std::string(kConnectorId2));
 }
 
 TEST_F(S3MultipleEndpoints, bucketEndpoints) {
@@ -217,8 +221,8 @@ TEST_F(S3MultipleEndpoints, bucketEndpoints) {
 
   testJoin(kExpectedRows, outputDirectory, kConnectorId1, kConnectorId2);
 
-  connector::unregisterConnector(std::string(kConnectorId1));
-  connector::unregisterConnector(std::string(kConnectorId2));
+  connector::ConnectorRegistry::global().erase(std::string(kConnectorId1));
+  connector::ConnectorRegistry::global().erase(std::string(kConnectorId2));
 }
 
 } // namespace facebook::velox
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/S3ReadTest.cpp b/velox/connectors/hive/storage_adapters/s3fs/tests/S3ReadTest.cpp
index bbd08483751..9062eed288a 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/tests/S3ReadTest.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/S3ReadTest.cpp
@@ -18,6 +18,7 @@
 #include <gtest/gtest.h>
 
 #include "velox/common/memory/Memory.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/tests/S3Test.h"
@@ -43,14 +44,15 @@ class S3ReadTest : public S3Test, public ::test::VectorTestBase {
     connector::hive::HiveConnectorFactory factory;
     auto hiveConnector =
         factory.newConnector(kHiveConnectorId, minioServer_->hiveConfig());
-    connector::registerConnector(hiveConnector);
+    connector::ConnectorRegistry::global().insert(
+        hiveConnector->connectorId(), hiveConnector);
     parquet::registerParquetReaderFactory();
   }
 
   void TearDown() override {
     parquet::unregisterParquetReaderFactory();
     filesystems::finalizeS3FileSystem();
-    connector::unregisterConnector(kHiveConnectorId);
+    connector::ConnectorRegistry::global().erase(kHiveConnectorId);
     S3Test::TearDown();
   }
 };
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/S3Test.h b/velox/connectors/hive/storage_adapters/s3fs/tests/S3Test.h
index 6a190684e2b..16e2a425649 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/tests/S3Test.h
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/S3Test.h
@@ -16,16 +16,17 @@
 
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/File.h"
+#include "velox/common/testutil/TempFilePath.h"
 #include "velox/connectors/hive/FileHandle.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/S3Util.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/tests/MinioServer.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
-#include "velox/exec/tests/utils/TempFilePath.h"
 
 #include "gtest/gtest.h"
 
 using namespace facebook::velox;
+using TempFilePath = common::testutil::TempFilePath;
 
 constexpr int kOneMB = 1 << 20;
 
diff --git a/velox/connectors/hive/storage_adapters/test_common/InsertTest.h b/velox/connectors/hive/storage_adapters/test_common/InsertTest.h
index 0700ca7a334..c595beca383 100644
--- a/velox/connectors/hive/storage_adapters/test_common/InsertTest.h
+++ b/velox/connectors/hive/storage_adapters/test_common/InsertTest.h
@@ -18,7 +18,9 @@
 #include <gtest/gtest.h>
 
 #include "velox/common/memory/Memory.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/hive/HiveConnector.h"
+#include "velox/connectors/hive/HiveDataSink.h"
 #include "velox/dwio/parquet/RegisterParquetReader.h"
 #include "velox/dwio/parquet/RegisterParquetWriter.h"
 #include "velox/exec/TableWriter.h"
@@ -37,7 +39,8 @@ class InsertTest : public velox::test::VectorTestBase {
     connector::hive::HiveConnectorFactory factory;
     auto hiveConnector = factory.newConnector(
         exec::test::kHiveConnectorId, hiveConfig, ioExecutor);
-    connector::registerConnector(hiveConnector);
+    connector::ConnectorRegistry::global().insert(
+        hiveConnector->connectorId(), hiveConnector);
 
     parquet::registerParquetReaderFactory();
     parquet::registerParquetWriterFactory();
@@ -47,7 +50,7 @@ class InsertTest : public velox::test::VectorTestBase {
     parquet::unregisterParquetReaderFactory();
     parquet::unregisterParquetWriterFactory();
 
-    connector::unregisterConnector(exec::test::kHiveConnectorId);
+    connector::ConnectorRegistry::global().erase(exec::test::kHiveConnectorId);
   }
 
   void runInsertTest(
@@ -87,19 +90,26 @@ class InsertTest : public velox::test::VectorTestBase {
                        ->as<FlatVector<StringView>>();
     ASSERT_TRUE(details->isNullAt(0));
     ASSERT_FALSE(details->isNullAt(1));
-    folly::dynamic obj = folly::parseJson(details->valueAt(1));
+    folly::dynamic obj =
+        folly::parseJson(std::string_view(details->valueAt(1)));
 
-    ASSERT_EQ(numRows, obj["rowCount"].asInt());
-    auto fileWriteInfos = obj["fileWriteInfos"];
+    ASSERT_EQ(
+        numRows, obj[connector::hive::HiveCommitMessage::kRowCount].asInt());
+    auto fileWriteInfos =
+        obj[connector::hive::HiveCommitMessage::kFileWriteInfos];
     ASSERT_EQ(1, fileWriteInfos.size());
 
-    auto writeFileName = fileWriteInfos[0]["writeFileName"].asString();
+    auto writeFileName =
+        fileWriteInfos[0][connector::hive::HiveCommitMessage::kWriteFileName]
+            .asString();
 
     // Read from 'writeFileName' and verify the data matches the original.
     plan = exec::test::PlanBuilder().tableScan(rowType).planNode();
 
     auto filePath = fmt::format("{}{}", outputDirectory, writeFileName);
-    const int64_t fileSize = fileWriteInfos[0]["fileSize"].asInt();
+    const int64_t fileSize =
+        fileWriteInfos[0][connector::hive::HiveCommitMessage::kFileSize]
+            .asInt();
     auto split = exec::test::HiveConnectorSplitBuilder(filePath)
                      .fileFormat(dwio::common::FileFormat::PARQUET)
                      .length(fileSize)
diff --git a/velox/connectors/hive/tests/CMakeLists.txt b/velox/connectors/hive/tests/CMakeLists.txt
index 0a24b6b10c4..9cceaa511e3 100644
--- a/velox/connectors/hive/tests/CMakeLists.txt
+++ b/velox/connectors/hive/tests/CMakeLists.txt
@@ -13,6 +13,10 @@
 # limitations under the License.
 add_executable(
   velox_hive_connector_test
+  FileColumnHandleTest.cpp
+  FileConfigTest.cpp
+  FileConnectorSplitTest.cpp
+  FileConnectorUtilTest.cpp
   FileHandleTest.cpp
   HiveConfigTest.cpp
   HiveDataSinkTest.cpp
@@ -20,7 +24,7 @@ add_executable(
   HiveConnectorUtilTest.cpp
   HiveConnectorSerDeTest.cpp
   HivePartitionFunctionTest.cpp
-  HivePartitionUtilTest.cpp
+  HivePartitionNameTest.cpp
   HiveSplitTest.cpp
   PartitionIdGeneratorTest.cpp
   TableHandleTest.cpp
@@ -36,6 +40,7 @@ target_link_libraries(
   velox_vector_test_lib
   velox_exec
   velox_exec_test_lib
+  GTest::gmock
   GTest::gtest
   GTest::gtest_main
 )
diff --git a/velox/connectors/hive/tests/FileColumnHandleTest.cpp b/velox/connectors/hive/tests/FileColumnHandleTest.cpp
new file mode 100644
index 00000000000..ba955b57444
--- /dev/null
+++ b/velox/connectors/hive/tests/FileColumnHandleTest.cpp
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/FileColumnHandle.h"
+#include <fmt/format.h>
+#include <gtest/gtest.h>
+#include "velox/common/base/tests/GTestUtils.h"
+
+using namespace facebook::velox::connector::hive;
+
+TEST(FileColumnHandleTest, columnTypeName) {
+  EXPECT_EQ(
+      FileColumnHandle::columnTypeName(
+          FileColumnHandle::ColumnType::kPartitionKey),
+      "PartitionKey");
+  EXPECT_EQ(
+      FileColumnHandle::columnTypeName(FileColumnHandle::ColumnType::kRegular),
+      "Regular");
+  EXPECT_EQ(
+      FileColumnHandle::columnTypeName(
+          FileColumnHandle::ColumnType::kSynthesized),
+      "Synthesized");
+  EXPECT_EQ(
+      FileColumnHandle::columnTypeName(FileColumnHandle::ColumnType::kRowIndex),
+      "RowIndex");
+  EXPECT_EQ(
+      FileColumnHandle::columnTypeName(FileColumnHandle::ColumnType::kRowId),
+      "RowId");
+}
+
+TEST(FileColumnHandleTest, columnTypeFromName) {
+  EXPECT_EQ(
+      FileColumnHandle::columnTypeFromName("PartitionKey"),
+      FileColumnHandle::ColumnType::kPartitionKey);
+  EXPECT_EQ(
+      FileColumnHandle::columnTypeFromName("Regular"),
+      FileColumnHandle::ColumnType::kRegular);
+  EXPECT_EQ(
+      FileColumnHandle::columnTypeFromName("Synthesized"),
+      FileColumnHandle::ColumnType::kSynthesized);
+  EXPECT_EQ(
+      FileColumnHandle::columnTypeFromName("RowIndex"),
+      FileColumnHandle::ColumnType::kRowIndex);
+  EXPECT_EQ(
+      FileColumnHandle::columnTypeFromName("RowId"),
+      FileColumnHandle::ColumnType::kRowId);
+}
+
+TEST(FileColumnHandleTest, columnTypeFromNameInvalid) {
+  VELOX_ASSERT_THROW(
+      FileColumnHandle::columnTypeFromName("Unknown"),
+      "Unknown column type name: Unknown");
+}
+
+TEST(FileColumnHandleTest, columnTypeRoundTrip) {
+  const std::vector<FileColumnHandle::ColumnType> allTypes = {
+      FileColumnHandle::ColumnType::kPartitionKey,
+      FileColumnHandle::ColumnType::kRegular,
+      FileColumnHandle::ColumnType::kSynthesized,
+      FileColumnHandle::ColumnType::kRowIndex,
+      FileColumnHandle::ColumnType::kRowId,
+  };
+  for (auto type : allTypes) {
+    EXPECT_EQ(
+        FileColumnHandle::columnTypeFromName(
+            FileColumnHandle::columnTypeName(type)),
+        type);
+  }
+}
+
+TEST(FileColumnHandleTest, fmtFormatter) {
+  EXPECT_EQ(
+      fmt::format("{}", FileColumnHandle::ColumnType::kRegular), "Regular");
+  EXPECT_EQ(
+      fmt::format("{}", FileColumnHandle::ColumnType::kPartitionKey),
+      "PartitionKey");
+}
diff --git a/velox/connectors/hive/tests/FileConfigTest.cpp b/velox/connectors/hive/tests/FileConfigTest.cpp
new file mode 100644
index 00000000000..65377e41ca3
--- /dev/null
+++ b/velox/connectors/hive/tests/FileConfigTest.cpp
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/FileConfig.h"
+#include <gtest/gtest.h>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/config/Config.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::connector::hive;
+
+TEST(FileConfigTest, defaultConfig) {
+  FileConfig config(
+      std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>()));
+  const auto emptySession = std::make_unique<config::ConfigBase>(
+      std::unordered_map<std::string, std::string>());
+
+  EXPECT_FALSE(config.isOrcUseColumnNames(emptySession.get()));
+  EXPECT_FALSE(config.isParquetUseColumnNames(emptySession.get()));
+  EXPECT_FALSE(config.isFileColumnNamesReadAsLowerCase(emptySession.get()));
+  EXPECT_FALSE(config.ignoreMissingFiles(emptySession.get()));
+  EXPECT_EQ(config.maxCoalescedBytes(emptySession.get()), 128 << 20);
+  EXPECT_EQ(config.maxCoalescedDistanceBytes(emptySession.get()), 512 << 10);
+  EXPECT_EQ(config.prefetchRowGroups(), 1);
+  EXPECT_EQ(config.parallelUnitLoadCount(emptySession.get()), 0);
+  EXPECT_EQ(config.loadQuantum(emptySession.get()), 8 << 20);
+  EXPECT_EQ(config.filePreloadThreshold(), 8UL << 20);
+  EXPECT_EQ(config.readTimestampUnit(emptySession.get()), 3);
+  EXPECT_TRUE(
+      config.readTimestampPartitionValueAsLocalTime(emptySession.get()));
+  EXPECT_FALSE(config.readStatsBasedFilterReorderDisabled(emptySession.get()));
+  EXPECT_FALSE(config.preserveFlatMapsInMemory(emptySession.get()));
+  EXPECT_FALSE(config.indexEnabled(emptySession.get()));
+  EXPECT_FALSE(config.readerCollectColumnCpuMetrics(emptySession.get()));
+  EXPECT_FALSE(config.fileMetadataCacheEnabled(emptySession.get()));
+  EXPECT_FALSE(config.pinFileMetadata(emptySession.get()));
+  EXPECT_EQ(config.orcFooterSpeculativeIoSize(emptySession.get()), 256UL << 10);
+  EXPECT_EQ(
+      config.parquetFooterSpeculativeIoSize(emptySession.get()), 256UL << 10);
+  EXPECT_EQ(
+      config.nimbleFooterSpeculativeIoSize(emptySession.get()), 8UL << 20);
+  EXPECT_FALSE(config.nimbleStringDecoderZeroCopy(emptySession.get()));
+  EXPECT_FALSE(config.nimblePreserveDictionaryEncoding(emptySession.get()));
+}
+
+TEST(FileConfigTest, overrideConfig) {
+  std::unordered_map<std::string, std::string> configFromFile = {
+      {FileConfig::kOrcUseColumnNames, "true"},
+      {FileConfig::kParquetUseColumnNames, "true"},
+      {FileConfig::kFileColumnNamesReadAsLowerCase, "true"},
+      {FileConfig::kMaxCoalescedBytes, "100"},
+      {FileConfig::kMaxCoalescedDistance, "100kB"},
+      {FileConfig::kPrefetchRowGroups, "4"},
+      {FileConfig::kLoadQuantum, std::to_string(4 << 20)},
+      {FileConfig::kFilePreloadThreshold, std::to_string(16UL << 20)},
+      {FileConfig::kReadStatsBasedFilterReorderDisabled, "true"},
+      {FileConfig::kPreserveFlatMapsInMemory, "true"},
+      {FileConfig::kIndexEnabled, "true"},
+      {FileConfig::kReaderCollectColumnCpuMetrics, "true"},
+      {FileConfig::kFileMetadataCacheEnabled, "true"},
+      {FileConfig::kPinFileMetadata, "true"},
+      {FileConfig::kOrcFooterSpeculativeIoSize, std::to_string(512UL << 10)},
+      {FileConfig::kParquetFooterSpeculativeIoSize, std::to_string(1UL << 20)},
+      {FileConfig::kNimbleFooterSpeculativeIoSize, std::to_string(4UL << 20)},
+      {FileConfig::kNimbleStringDecoderZeroCopy, "true"},
+      {FileConfig::kNimblePreserveDictionaryEncoding, "true"},
+  };
+  FileConfig config(
+      std::make_shared<config::ConfigBase>(std::move(configFromFile)));
+  const auto emptySession = std::make_unique<config::ConfigBase>(
+      std::unordered_map<std::string, std::string>());
+
+  EXPECT_TRUE(config.isOrcUseColumnNames(emptySession.get()));
+  EXPECT_TRUE(config.isParquetUseColumnNames(emptySession.get()));
+  EXPECT_TRUE(config.isFileColumnNamesReadAsLowerCase(emptySession.get()));
+  EXPECT_EQ(config.maxCoalescedBytes(emptySession.get()), 100);
+  EXPECT_EQ(config.maxCoalescedDistanceBytes(emptySession.get()), 100 << 10);
+  EXPECT_EQ(config.prefetchRowGroups(), 4);
+  EXPECT_EQ(config.loadQuantum(emptySession.get()), 4 << 20);
+  EXPECT_EQ(config.filePreloadThreshold(), 16UL << 20);
+  EXPECT_TRUE(config.readStatsBasedFilterReorderDisabled(emptySession.get()));
+  EXPECT_TRUE(config.preserveFlatMapsInMemory(emptySession.get()));
+  EXPECT_TRUE(config.indexEnabled(emptySession.get()));
+  EXPECT_TRUE(config.readerCollectColumnCpuMetrics(emptySession.get()));
+  EXPECT_TRUE(config.fileMetadataCacheEnabled(emptySession.get()));
+  EXPECT_TRUE(config.pinFileMetadata(emptySession.get()));
+  EXPECT_EQ(config.orcFooterSpeculativeIoSize(emptySession.get()), 512UL << 10);
+  EXPECT_EQ(
+      config.parquetFooterSpeculativeIoSize(emptySession.get()), 1UL << 20);
+  EXPECT_EQ(
+      config.nimbleFooterSpeculativeIoSize(emptySession.get()), 4UL << 20);
+  EXPECT_TRUE(config.nimbleStringDecoderZeroCopy(emptySession.get()));
+  EXPECT_TRUE(config.nimblePreserveDictionaryEncoding(emptySession.get()));
+}
+
+TEST(FileConfigTest, overrideSession) {
+  FileConfig config(
+      std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>()));
+  std::unordered_map<std::string, std::string> sessionOverride = {
+      {FileConfig::kOrcUseColumnNamesSession, "true"},
+      {FileConfig::kParquetUseColumnNamesSession, "true"},
+      {FileConfig::kFileColumnNamesReadAsLowerCaseSession, "true"},
+      {FileConfig::kIgnoreMissingFilesSession, "true"},
+      {FileConfig::kMaxCoalescedDistanceSession, "3MB"},
+      {FileConfig::kLoadQuantumSession, std::to_string(4 << 20)},
+      {FileConfig::kReadStatsBasedFilterReorderDisabledSession, "true"},
+      {FileConfig::kPreserveFlatMapsInMemorySession, "true"},
+      {FileConfig::kIndexEnabledSession, "true"},
+      {FileConfig::kReaderCollectColumnCpuMetricsSession, "true"},
+      {FileConfig::kFileMetadataCacheEnabledSession, "true"},
+      {FileConfig::kPinFileMetadataSession, "true"},
+      {FileConfig::kOrcFooterSpeculativeIoSizeSession,
+       std::to_string(128UL << 10)},
+      {FileConfig::kParquetFooterSpeculativeIoSizeSession,
+       std::to_string(512UL << 10)},
+      {FileConfig::kNimbleFooterSpeculativeIoSizeSession,
+       std::to_string(2UL << 20)},
+      {FileConfig::kNimbleStringDecoderZeroCopySession, "true"},
+      {FileConfig::kNimblePreserveDictionaryEncodingSession, "true"},
+  };
+  const auto session =
+      std::make_unique<config::ConfigBase>(std::move(sessionOverride));
+
+  EXPECT_TRUE(config.isOrcUseColumnNames(session.get()));
+  EXPECT_TRUE(config.isParquetUseColumnNames(session.get()));
+  EXPECT_TRUE(config.isFileColumnNamesReadAsLowerCase(session.get()));
+  EXPECT_TRUE(config.ignoreMissingFiles(session.get()));
+  EXPECT_EQ(config.maxCoalescedDistanceBytes(session.get()), 3 << 20);
+  EXPECT_EQ(config.loadQuantum(session.get()), 4 << 20);
+  EXPECT_TRUE(config.readStatsBasedFilterReorderDisabled(session.get()));
+  EXPECT_TRUE(config.preserveFlatMapsInMemory(session.get()));
+  EXPECT_TRUE(config.indexEnabled(session.get()));
+  EXPECT_TRUE(config.readerCollectColumnCpuMetrics(session.get()));
+  EXPECT_TRUE(config.fileMetadataCacheEnabled(session.get()));
+  EXPECT_TRUE(config.pinFileMetadata(session.get()));
+  EXPECT_EQ(config.orcFooterSpeculativeIoSize(session.get()), 128UL << 10);
+  EXPECT_EQ(config.parquetFooterSpeculativeIoSize(session.get()), 512UL << 10);
+  EXPECT_EQ(config.nimbleFooterSpeculativeIoSize(session.get()), 2UL << 20);
+  EXPECT_TRUE(config.nimbleStringDecoderZeroCopy(session.get()));
+  EXPECT_TRUE(config.nimblePreserveDictionaryEncoding(session.get()));
+}
+
+TEST(FileConfigTest, nullConfig) {
+  VELOX_ASSERT_THROW(
+      FileConfig(nullptr), "Config is null for FileConfig initialization");
+}
+
+TEST(FileConfigTest, invalidTimestampUnit) {
+  FileConfig config(
+      std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>()));
+  std::unordered_map<std::string, std::string> sessionOverride = {
+      {FileConfig::kReadTimestampUnitSession, "5"},
+  };
+  const auto session =
+      std::make_unique<config::ConfigBase>(std::move(sessionOverride));
+  VELOX_ASSERT_THROW(
+      config.readTimestampUnit(session.get()), "Invalid timestamp unit.");
+}
diff --git a/velox/connectors/hive/tests/FileConnectorSplitTest.cpp b/velox/connectors/hive/tests/FileConnectorSplitTest.cpp
new file mode 100644
index 00000000000..08fc673b7a0
--- /dev/null
+++ b/velox/connectors/hive/tests/FileConnectorSplitTest.cpp
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/FileConnectorSplit.h"
+#include <gtest/gtest.h>
+
+using namespace facebook::velox;
+using namespace facebook::velox::connector::hive;
+
+TEST(FileConnectorSplitTest, construction) {
+  FileConnectorSplit split(
+      "connectorId",
+      "/path/to/file.parquet",
+      dwio::common::FileFormat::PARQUET,
+      100,
+      5000,
+      /*splitWeight=*/2,
+      /*cacheable=*/false);
+
+  EXPECT_EQ(split.connectorId, "connectorId");
+  EXPECT_EQ(split.filePath, "/path/to/file.parquet");
+  EXPECT_EQ(split.fileFormat, dwio::common::FileFormat::PARQUET);
+  EXPECT_EQ(split.start, 100);
+  EXPECT_EQ(split.length, 5000);
+  EXPECT_EQ(split.splitWeight, 2);
+  EXPECT_FALSE(split.cacheable);
+  EXPECT_FALSE(split.properties.has_value());
+}
+
+TEST(FileConnectorSplitTest, defaults) {
+  FileConnectorSplit split(
+      "connectorId", "/file.orc", dwio::common::FileFormat::ORC);
+
+  EXPECT_EQ(split.start, 0);
+  EXPECT_EQ(split.length, std::numeric_limits<uint64_t>::max());
+  EXPECT_EQ(split.splitWeight, 0);
+  EXPECT_TRUE(split.cacheable);
+  EXPECT_FALSE(split.properties.has_value());
+}
+
+TEST(FileConnectorSplitTest, size) {
+  FileConnectorSplit split(
+      "connectorId", "/file.dwrf", dwio::common::FileFormat::DWRF, 0, 12345);
+
+  EXPECT_EQ(split.size(), 12345);
+}
+
+TEST(FileConnectorSplitTest, getFileName) {
+  FileConnectorSplit split(
+      "connectorId",
+      "/path/to/data/part-00000.parquet",
+      dwio::common::FileFormat::PARQUET);
+
+  EXPECT_EQ(split.getFileName(), "part-00000.parquet");
+}
+
+TEST(FileConnectorSplitTest, getFileNameNoSlash) {
+  FileConnectorSplit split(
+      "connectorId", "file.orc", dwio::common::FileFormat::ORC);
+
+  EXPECT_EQ(split.getFileName(), "file.orc");
+}
+
+TEST(FileConnectorSplitTest, fileProperties) {
+  FileProperties props = {.fileSize = 1024, .modificationTime = 999};
+  FileConnectorSplit split(
+      "connectorId",
+      "/file.parquet",
+      dwio::common::FileFormat::PARQUET,
+      0,
+      std::numeric_limits<uint64_t>::max(),
+      0,
+      true,
+      props);
+
+  ASSERT_TRUE(split.properties.has_value());
+  EXPECT_EQ(split.properties->fileSize.value(), 1024);
+  EXPECT_EQ(split.properties->modificationTime.value(), 999);
+}
diff --git a/velox/connectors/hive/tests/FileConnectorUtilTest.cpp b/velox/connectors/hive/tests/FileConnectorUtilTest.cpp
new file mode 100644
index 00000000000..ef70a1e2e34
--- /dev/null
+++ b/velox/connectors/hive/tests/FileConnectorUtilTest.cpp
@@ -0,0 +1,481 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/FileConnectorUtil.h"
+
+#include <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/io/IoStatistics.h"
+#include "velox/connectors/hive/FileConfig.h"
+#include "velox/connectors/hive/FileConnectorSplit.h"
+#include "velox/connectors/hive/TableHandle.h"
+#include "velox/dwio/dwrf/reader/DwrfReader.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/type/Filter.h"
+
+namespace facebook::velox::connector {
+
+class FileConnectorUtilTest : public exec::test::HiveConnectorTestBase {
+ protected:
+  struct QueryCtxHolder {
+    std::shared_ptr<config::ConfigBase> sessionProperties;
+    std::unique_ptr<ConnectorQueryCtx> ctx;
+  };
+
+  QueryCtxHolder makeConnectorQueryCtx(
+      std::unordered_map<std::string, std::string> sessionProps = {}) {
+    QueryCtxHolder holder;
+    holder.sessionProperties =
+        std::make_shared<config::ConfigBase>(std::move(sessionProps), true);
+    holder.ctx = std::make_unique<ConnectorQueryCtx>(
+        pool_.get(),
+        pool_.get(),
+        holder.sessionProperties.get(),
+        nullptr,
+        common::PrefixSortConfig(),
+        nullptr,
+        nullptr,
+        "query.FileConnectorUtilTest",
+        "task.FileConnectorUtilTest",
+        "planNodeId.FileConnectorUtilTest",
+        0,
+        "");
+    return holder;
+  }
+
+  std::shared_ptr<const hive::FileConfig> makeFileConfig(
+      std::unordered_map<std::string, std::string> props = {}) {
+    return std::make_shared<hive::FileConfig>(
+        std::make_shared<config::ConfigBase>(std::move(props)));
+  }
+
+  std::shared_ptr<const hive::FileConnectorSplit> makeSplit(
+      dwio::common::FileFormat format = dwio::common::FileFormat::DWRF,
+      const std::string& path = "/tmp/testfile") {
+    return std::make_shared<hive::FileConnectorSplit>(
+        "testConnectorId", path, format);
+  }
+
+  std::string writeDataFile(const RowVectorPtr& data) {
+    auto path = exec::test::TempFilePath::create();
+    auto filePath = path->getPath();
+    tempPaths_.push_back(std::move(path));
+    writeToFile(filePath, {data});
+    return filePath;
+  }
+
+  std::unique_ptr<dwio::common::Reader> makeReader(const std::string& path) {
+    dwio::common::ReaderOptions readerOpts(pool_.get());
+    readerOpts.setDataIoStats(dataIoStats_);
+    readerOpts.setMetadataIoStats(metadataIoStats_);
+    readerOpts.setFileFormat(dwio::common::FileFormat::DWRF);
+    auto readFile = std::make_shared<LocalReadFile>(path);
+    auto input = std::make_unique<dwio::common::BufferedInput>(
+        std::move(readFile), readerOpts.memoryPool());
+    return dwrf::DwrfReader::create(std::move(input), readerOpts);
+  }
+
+  std::shared_ptr<velox::io::IoStatistics> dataIoStats_ =
+      std::make_shared<velox::io::IoStatistics>();
+  std::shared_ptr<velox::io::IoStatistics> metadataIoStats_ =
+      std::make_shared<velox::io::IoStatistics>();
+
+ private:
+  std::vector<std::shared_ptr<exec::test::TempFilePath>> tempPaths_;
+};
+
+TEST_F(FileConnectorUtilTest, configureReaderOptions) {
+  auto fileConfig = makeFileConfig();
+
+  // Test with DWRF format.
+  {
+    auto holder = makeConnectorQueryCtx();
+    auto split = makeSplit(dwio::common::FileFormat::DWRF);
+    dwio::common::ReaderOptions readerOptions(pool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
+    hive::configureReaderOptions(
+        fileConfig,
+        holder.ctx.get(),
+        /*fileSchema=*/nullptr,
+        split,
+        /*tableParameters=*/{},
+        readerOptions);
+
+    EXPECT_EQ(readerOptions.fileFormat(), dwio::common::FileFormat::DWRF);
+    EXPECT_FALSE(readerOptions.fileColumnNamesReadAsLowerCase());
+    EXPECT_FALSE(readerOptions.useColumnNamesForColumnMapping());
+  }
+
+  // Test with ORC format and useColumnNames enabled via session.
+  {
+    auto holder = makeConnectorQueryCtx(
+        {{hive::FileConfig::kOrcUseColumnNamesSession, "true"}});
+    auto split = makeSplit(dwio::common::FileFormat::ORC);
+    dwio::common::ReaderOptions readerOptions(pool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
+    hive::configureReaderOptions(
+        fileConfig,
+        holder.ctx.get(),
+        /*fileSchema=*/nullptr,
+        split,
+        /*tableParameters=*/{},
+        readerOptions);
+
+    EXPECT_EQ(readerOptions.fileFormat(), dwio::common::FileFormat::ORC);
+    EXPECT_TRUE(readerOptions.useColumnNamesForColumnMapping());
+  }
+
+  // Test with Parquet format and useColumnNames enabled via session.
+  {
+    auto holder = makeConnectorQueryCtx(
+        {{hive::FileConfig::kParquetUseColumnNamesSession, "true"}});
+    auto split = makeSplit(dwio::common::FileFormat::PARQUET);
+    dwio::common::ReaderOptions readerOptions(pool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
+    hive::configureReaderOptions(
+        fileConfig,
+        holder.ctx.get(),
+        /*fileSchema=*/nullptr,
+        split,
+        /*tableParameters=*/{},
+        readerOptions);
+
+    EXPECT_EQ(readerOptions.fileFormat(), dwio::common::FileFormat::PARQUET);
+    EXPECT_TRUE(readerOptions.useColumnNamesForColumnMapping());
+  }
+
+  // Test format mismatch throws.
+  {
+    auto holder = makeConnectorQueryCtx();
+    auto split = makeSplit(dwio::common::FileFormat::DWRF);
+    dwio::common::ReaderOptions readerOptions(pool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
+    readerOptions.setFileFormat(dwio::common::FileFormat::PARQUET);
+    VELOX_ASSERT_THROW(
+        hive::configureReaderOptions(
+            fileConfig,
+            holder.ctx.get(),
+            /*fileSchema=*/nullptr,
+            split,
+            /*tableParameters=*/{},
+            readerOptions),
+        "received splits of different formats");
+  }
+}
+
+TEST_F(FileConnectorUtilTest, configureRowReaderOptions) {
+  auto holder = makeConnectorQueryCtx();
+  auto fileConfig = makeFileConfig();
+  auto split = makeSplit(dwio::common::FileFormat::DWRF);
+  auto scanSpec = std::make_shared<common::ScanSpec>("<root>");
+  auto rowType = ROW({"c0"}, {BIGINT()});
+
+  dwio::common::RowReaderOptions rowReaderOptions;
+  hive::configureRowReaderOptions(
+      /*tableParameters=*/{},
+      scanSpec,
+      /*metadataFilter=*/nullptr,
+      rowType,
+      split,
+      fileConfig,
+      holder.ctx->sessionProperties(),
+      /*ioExecutor=*/nullptr,
+      rowReaderOptions);
+
+  EXPECT_EQ(rowReaderOptions.scanSpec(), scanSpec);
+  EXPECT_EQ(rowReaderOptions.offset(), 0);
+  EXPECT_EQ(rowReaderOptions.length(), std::numeric_limits<uint64_t>::max());
+}
+
+TEST_F(FileConnectorUtilTest, configureRowReaderOptionsSkipRows) {
+  auto holder = makeConnectorQueryCtx();
+  auto fileConfig = makeFileConfig();
+  auto split = makeSplit(dwio::common::FileFormat::DWRF);
+  auto scanSpec = std::make_shared<common::ScanSpec>("<root>");
+  auto rowType = ROW({"c0"}, {BIGINT()});
+
+  std::unordered_map<std::string, std::string> tableParameters = {
+      {dwio::common::TableParameter::kSkipHeaderLineCount, "5"},
+  };
+
+  dwio::common::RowReaderOptions rowReaderOptions;
+  hive::configureRowReaderOptions(
+      tableParameters,
+      scanSpec,
+      /*metadataFilter=*/nullptr,
+      rowType,
+      split,
+      fileConfig,
+      holder.ctx->sessionProperties(),
+      /*ioExecutor=*/nullptr,
+      rowReaderOptions);
+
+  EXPECT_EQ(rowReaderOptions.skipRows(), 5);
+}
+
+TEST_F(FileConnectorUtilTest, configureRowReaderOptionsSplitRange) {
+  auto holder = makeConnectorQueryCtx();
+  auto fileConfig = makeFileConfig();
+  auto split = std::make_shared<hive::FileConnectorSplit>(
+      "testConnectorId",
+      "/tmp/testfile",
+      dwio::common::FileFormat::DWRF,
+      /*start=*/100,
+      /*length=*/5000);
+  auto scanSpec = std::make_shared<common::ScanSpec>("<root>");
+  auto rowType = ROW({"c0"}, {BIGINT()});
+
+  dwio::common::RowReaderOptions rowReaderOptions;
+  hive::configureRowReaderOptions(
+      /*tableParameters=*/{},
+      scanSpec,
+      /*metadataFilter=*/nullptr,
+      rowType,
+      split,
+      fileConfig,
+      holder.ctx->sessionProperties(),
+      /*ioExecutor=*/nullptr,
+      rowReaderOptions);
+
+  EXPECT_EQ(rowReaderOptions.offset(), 100);
+  EXPECT_EQ(rowReaderOptions.length(), 5000);
+}
+
+TEST_F(FileConnectorUtilTest, testFiltersNoFilters) {
+  auto rowType = ROW({"c0"}, {BIGINT()});
+  auto batch =
+      makeRowVector({"c0"}, {makeFlatVector<int64_t>(100, folly::identity)});
+  auto filePath = writeDataFile(batch);
+  auto reader = makeReader(filePath);
+
+  auto scanSpec = std::make_shared<common::ScanSpec>("<root>");
+  scanSpec->addField("c0", 0);
+
+  EXPECT_TRUE(
+      hive::testFilters(
+          scanSpec.get(),
+          reader.get(),
+          filePath,
+          /*partitionKey=*/{},
+          /*partitionKeysHandle=*/{},
+          /*asLocalTime=*/false));
+}
+
+TEST_F(FileConnectorUtilTest, testFiltersPartitionKeyPasses) {
+  auto rowType = ROW({"c0"}, {BIGINT()});
+  auto batch =
+      makeRowVector({"c0"}, {makeFlatVector<int64_t>(100, folly::identity)});
+  auto filePath = writeDataFile(batch);
+  auto reader = makeReader(filePath);
+
+  auto scanSpec = std::make_shared<common::ScanSpec>("<root>");
+  scanSpec->addField("c0", 0);
+  auto* dsSpec = scanSpec->addField("ds", 1);
+  dsSpec->setFilter(
+      std::make_unique<common::BytesValues>(
+          std::vector<std::string>{"2024-01-01"}, false));
+
+  std::unordered_map<std::string, std::optional<std::string>> partitionKeys = {
+      {"ds", "2024-01-01"},
+  };
+
+  auto dsHandle = std::make_shared<hive::HiveColumnHandle>(
+      "ds",
+      hive::HiveColumnHandle::ColumnType::kPartitionKey,
+      VARCHAR(),
+      VARCHAR());
+  std::unordered_map<std::string, hive::FileColumnHandlePtr>
+      partitionKeysHandle = {
+          {"ds", dsHandle},
+      };
+
+  EXPECT_TRUE(
+      hive::testFilters(
+          scanSpec.get(),
+          reader.get(),
+          filePath,
+          partitionKeys,
+          partitionKeysHandle,
+          /*asLocalTime=*/false));
+}
+
+TEST_F(FileConnectorUtilTest, testFiltersPartitionKeyFails) {
+  auto rowType = ROW({"c0"}, {BIGINT()});
+  auto batch =
+      makeRowVector({"c0"}, {makeFlatVector<int64_t>(100, folly::identity)});
+  auto filePath = writeDataFile(batch);
+  auto reader = makeReader(filePath);
+
+  auto scanSpec = std::make_shared<common::ScanSpec>("<root>");
+  scanSpec->addField("c0", 0);
+  auto* dsSpec = scanSpec->addField("ds", 1);
+  dsSpec->setFilter(
+      std::make_unique<common::BytesValues>(
+          std::vector<std::string>{"2024-01-01"}, false));
+
+  std::unordered_map<std::string, std::optional<std::string>> partitionKeys = {
+      {"ds", "2024-02-15"},
+  };
+
+  auto dsHandle = std::make_shared<hive::HiveColumnHandle>(
+      "ds",
+      hive::HiveColumnHandle::ColumnType::kPartitionKey,
+      VARCHAR(),
+      VARCHAR());
+  std::unordered_map<std::string, hive::FileColumnHandlePtr>
+      partitionKeysHandle = {
+          {"ds", dsHandle},
+      };
+
+  EXPECT_FALSE(
+      hive::testFilters(
+          scanSpec.get(),
+          reader.get(),
+          filePath,
+          partitionKeys,
+          partitionKeysHandle,
+          /*asLocalTime=*/false));
+}
+
+TEST_F(FileConnectorUtilTest, testFiltersNullPartitionKeyRejectsNotNull) {
+  auto rowType = ROW({"c0"}, {BIGINT()});
+  auto batch =
+      makeRowVector({"c0"}, {makeFlatVector<int64_t>(100, folly::identity)});
+  auto filePath = writeDataFile(batch);
+  auto reader = makeReader(filePath);
+
+  auto scanSpec = std::make_shared<common::ScanSpec>("<root>");
+  scanSpec->addField("c0", 0);
+  auto* dsSpec = scanSpec->addField("ds", 1);
+  dsSpec->setFilter(
+      std::make_unique<common::BytesValues>(
+          std::vector<std::string>{"2024-01-01"}, false));
+
+  std::unordered_map<std::string, std::optional<std::string>> partitionKeys = {
+      {"ds", std::nullopt},
+  };
+
+  auto dsHandle = std::make_shared<hive::HiveColumnHandle>(
+      "ds",
+      hive::HiveColumnHandle::ColumnType::kPartitionKey,
+      VARCHAR(),
+      VARCHAR());
+  std::unordered_map<std::string, hive::FileColumnHandlePtr>
+      partitionKeysHandle = {
+          {"ds", dsHandle},
+      };
+
+  EXPECT_FALSE(
+      hive::testFilters(
+          scanSpec.get(),
+          reader.get(),
+          filePath,
+          partitionKeys,
+          partitionKeysHandle,
+          /*asLocalTime=*/false));
+}
+
+TEST_F(FileConnectorUtilTest, testFiltersIntegerPartitionKey) {
+  auto rowType = ROW({"c0"}, {BIGINT()});
+  auto batch =
+      makeRowVector({"c0"}, {makeFlatVector<int64_t>(100, folly::identity)});
+  auto filePath = writeDataFile(batch);
+  auto reader = makeReader(filePath);
+
+  auto scanSpec = std::make_shared<common::ScanSpec>("<root>");
+  scanSpec->addField("c0", 0);
+  auto* yearSpec = scanSpec->addField("year", 1);
+  yearSpec->setFilter(std::make_unique<common::BigintRange>(2024, 2024, false));
+
+  // Matching partition value.
+  {
+    std::unordered_map<std::string, std::optional<std::string>> partitionKeys =
+        {{"year", "2024"}};
+    auto yearHandle = std::make_shared<hive::HiveColumnHandle>(
+        "year",
+        hive::HiveColumnHandle::ColumnType::kPartitionKey,
+        BIGINT(),
+        BIGINT());
+    std::unordered_map<std::string, hive::FileColumnHandlePtr>
+        partitionKeysHandle = {{"year", yearHandle}};
+
+    EXPECT_TRUE(
+        hive::testFilters(
+            scanSpec.get(),
+            reader.get(),
+            filePath,
+            partitionKeys,
+            partitionKeysHandle,
+            /*asLocalTime=*/false));
+  }
+
+  // Non-matching partition value.
+  {
+    std::unordered_map<std::string, std::optional<std::string>> partitionKeys =
+        {{"year", "2023"}};
+    auto yearHandle = std::make_shared<hive::HiveColumnHandle>(
+        "year",
+        hive::HiveColumnHandle::ColumnType::kPartitionKey,
+        BIGINT(),
+        BIGINT());
+    std::unordered_map<std::string, hive::FileColumnHandlePtr>
+        partitionKeysHandle = {{"year", yearHandle}};
+
+    EXPECT_FALSE(
+        hive::testFilters(
+            scanSpec.get(),
+            reader.get(),
+            filePath,
+            partitionKeys,
+            partitionKeysHandle,
+            /*asLocalTime=*/false));
+  }
+}
+
+TEST_F(FileConnectorUtilTest, testFiltersMissingColumn) {
+  auto rowType = ROW({"c0"}, {BIGINT()});
+  auto batch =
+      makeRowVector({"c0"}, {makeFlatVector<int64_t>(100, folly::identity)});
+  auto filePath = writeDataFile(batch);
+  auto reader = makeReader(filePath);
+
+  auto scanSpec = std::make_shared<common::ScanSpec>("<root>");
+  scanSpec->addField("c0", 0);
+  // Filter on a column that doesn't exist in the file and is not a partition
+  // key. This simulates schema evolution where the column was added later.
+  auto* newColSpec = scanSpec->addField("newCol", 1);
+  // Filter that rejects null -- should cause the split to be skipped since
+  // the column is missing (will be all nulls).
+  newColSpec->setFilter(
+      std::make_unique<common::BytesValues>(
+          std::vector<std::string>{"someValue"}, false));
+
+  EXPECT_FALSE(
+      hive::testFilters(
+          scanSpec.get(),
+          reader.get(),
+          filePath,
+          /*partitionKey=*/{},
+          /*partitionKeysHandle=*/{},
+          /*asLocalTime=*/false));
+}
+
+} // namespace facebook::velox::connector
diff --git a/velox/connectors/hive/tests/FileHandleTest.cpp b/velox/connectors/hive/tests/FileHandleTest.cpp
index 6c3e71c42fe..f0320d715f1 100644
--- a/velox/connectors/hive/tests/FileHandleTest.cpp
+++ b/velox/connectors/hive/tests/FileHandleTest.cpp
@@ -20,14 +20,15 @@
 #include "velox/common/caching/SimpleLRUCache.h"
 #include "velox/common/file/File.h"
 #include "velox/common/file/FileSystems.h"
-#include "velox/exec/tests/utils/TempFilePath.h"
+#include "velox/common/testutil/TempFilePath.h"
 
 using namespace facebook::velox;
+using namespace facebook::velox::common::testutil;
 
 TEST(FileHandleTest, localFile) {
   filesystems::registerLocalFileSystem();
 
-  auto tempFile = exec::test::TempFilePath::create();
+  auto tempFile = TempFilePath::create();
   const auto& filename = tempFile->getPath();
   remove(filename.c_str());
 
@@ -52,7 +53,7 @@ TEST(FileHandleTest, localFile) {
 TEST(FileHandleTest, localFileWithProperties) {
   filesystems::registerLocalFileSystem();
 
-  auto tempFile = exec::test::TempFilePath::create();
+  auto tempFile = TempFilePath::create();
   const auto& filename = tempFile->getPath();
   remove(filename.c_str());
 
diff --git a/velox/connectors/hive/tests/HiveConfigTest.cpp b/velox/connectors/hive/tests/HiveConfigTest.cpp
index ef6262cd4b2..6a58752c134 100644
--- a/velox/connectors/hive/tests/HiveConfigTest.cpp
+++ b/velox/connectors/hive/tests/HiveConfigTest.cpp
@@ -23,8 +23,9 @@ using namespace facebook::velox::connector::hive;
 using facebook::velox::connector::hive::HiveConfig;
 
 TEST(HiveConfigTest, defaultConfig) {
-  HiveConfig hiveConfig(std::make_shared<config::ConfigBase>(
-      std::unordered_map<std::string, std::string>()));
+  HiveConfig hiveConfig(
+      std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>()));
   const auto emptySession = std::make_unique<config::ConfigBase>(
       std::unordered_map<std::string, std::string>());
   ASSERT_EQ(
@@ -54,6 +55,17 @@ TEST(HiveConfigTest, defaultConfig) {
   ASSERT_TRUE(hiveConfig.allowNullPartitionKeys(emptySession.get()));
   ASSERT_EQ(hiveConfig.loadQuantum(emptySession.get()), 8 << 20);
   ASSERT_FALSE(hiveConfig.preserveFlatMapsInMemory(emptySession.get()));
+  ASSERT_FALSE(hiveConfig.indexEnabled(emptySession.get()));
+  ASSERT_FALSE(hiveConfig.fileMetadataCacheEnabled(emptySession.get()));
+  ASSERT_EQ(
+      hiveConfig.orcFooterSpeculativeIoSize(emptySession.get()), 256UL << 10);
+  ASSERT_EQ(
+      hiveConfig.parquetFooterSpeculativeIoSize(emptySession.get()),
+      256UL << 10);
+  ASSERT_EQ(
+      hiveConfig.nimbleFooterSpeculativeIoSize(emptySession.get()), 8UL << 20);
+  ASSERT_FALSE(hiveConfig.nimbleStringDecoderZeroCopy(emptySession.get()));
+  ASSERT_FALSE(hiveConfig.nimblePreserveDictionaryEncoding(emptySession.get()));
 }
 
 TEST(HiveConfigTest, overrideConfig) {
@@ -77,7 +89,15 @@ TEST(HiveConfigTest, overrideConfig) {
       {HiveConfig::kReadStatsBasedFilterReorderDisabled, "true"},
       {HiveConfig::kLoadQuantum, std::to_string(4 << 20)},
       {HiveConfig::kMaxBucketCount, std::to_string(100'000)},
-      {HiveConfig::kPreserveFlatMapsInMemory, "true"}};
+      {HiveConfig::kPreserveFlatMapsInMemory, "true"},
+      {HiveConfig::kIndexEnabled, "true"},
+      {HiveConfig::kFileMetadataCacheEnabled, "true"},
+      {HiveConfig::kOrcFooterSpeculativeIoSize, std::to_string(512UL << 10)},
+      {HiveConfig::kParquetFooterSpeculativeIoSize, std::to_string(1UL << 20)},
+      {HiveConfig::kNimbleFooterSpeculativeIoSize, std::to_string(4UL << 20)},
+      {HiveConfig::kNimbleStringDecoderZeroCopy, "true"},
+      {HiveConfig::kNimblePreserveDictionaryEncoding, "true"},
+  };
   HiveConfig hiveConfig(
       std::make_shared<config::ConfigBase>(std::move(configFromFile)));
   auto emptySession = std::make_shared<config::ConfigBase>(
@@ -109,11 +129,22 @@ TEST(HiveConfigTest, overrideConfig) {
   ASSERT_EQ(hiveConfig.loadQuantum(emptySession.get()), 4 << 20);
   ASSERT_EQ(hiveConfig.maxBucketCount(emptySession.get()), 100'000);
   ASSERT_TRUE(hiveConfig.preserveFlatMapsInMemory(emptySession.get()));
+  ASSERT_TRUE(hiveConfig.indexEnabled(emptySession.get()));
+  ASSERT_TRUE(hiveConfig.fileMetadataCacheEnabled(emptySession.get()));
+  ASSERT_EQ(
+      hiveConfig.orcFooterSpeculativeIoSize(emptySession.get()), 512UL << 10);
+  ASSERT_EQ(
+      hiveConfig.parquetFooterSpeculativeIoSize(emptySession.get()), 1UL << 20);
+  ASSERT_EQ(
+      hiveConfig.nimbleFooterSpeculativeIoSize(emptySession.get()), 4UL << 20);
+  ASSERT_TRUE(hiveConfig.nimbleStringDecoderZeroCopy(emptySession.get()));
+  ASSERT_TRUE(hiveConfig.nimblePreserveDictionaryEncoding(emptySession.get()));
 }
 
 TEST(HiveConfigTest, overrideSession) {
-  HiveConfig hiveConfig(std::make_shared<config::ConfigBase>(
-      std::unordered_map<std::string, std::string>()));
+  HiveConfig hiveConfig(
+      std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>()));
   std::unordered_map<std::string, std::string> sessionOverride = {
       {HiveConfig::kInsertExistingPartitionsBehaviorSession, "OVERWRITE"},
       {HiveConfig::kOrcUseColumnNamesSession, "true"},
@@ -128,6 +159,16 @@ TEST(HiveConfigTest, overrideSession) {
       {HiveConfig::kReadStatsBasedFilterReorderDisabledSession, "true"},
       {HiveConfig::kLoadQuantumSession, std::to_string(4 << 20)},
       {HiveConfig::kPreserveFlatMapsInMemorySession, "true"},
+      {HiveConfig::kIndexEnabledSession, "true"},
+      {HiveConfig::kFileMetadataCacheEnabledSession, "true"},
+      {HiveConfig::kOrcFooterSpeculativeIoSizeSession,
+       std::to_string(128UL << 10)},
+      {HiveConfig::kParquetFooterSpeculativeIoSizeSession,
+       std::to_string(512UL << 10)},
+      {HiveConfig::kNimbleFooterSpeculativeIoSizeSession,
+       std::to_string(2UL << 20)},
+      {HiveConfig::kNimbleStringDecoderZeroCopySession, "true"},
+      {HiveConfig::kNimblePreserveDictionaryEncodingSession, "true"},
   };
   const auto session =
       std::make_unique<config::ConfigBase>(std::move(sessionOverride));
@@ -155,4 +196,12 @@ TEST(HiveConfigTest, overrideSession) {
   ASSERT_TRUE(hiveConfig.readStatsBasedFilterReorderDisabled(session.get()));
   ASSERT_EQ(hiveConfig.loadQuantum(session.get()), 4 << 20);
   ASSERT_TRUE(hiveConfig.preserveFlatMapsInMemory(session.get()));
+  ASSERT_TRUE(hiveConfig.indexEnabled(session.get()));
+  ASSERT_TRUE(hiveConfig.fileMetadataCacheEnabled(session.get()));
+  ASSERT_EQ(hiveConfig.orcFooterSpeculativeIoSize(session.get()), 128UL << 10);
+  ASSERT_EQ(
+      hiveConfig.parquetFooterSpeculativeIoSize(session.get()), 512UL << 10);
+  ASSERT_EQ(hiveConfig.nimbleFooterSpeculativeIoSize(session.get()), 2UL << 20);
+  ASSERT_TRUE(hiveConfig.nimbleStringDecoderZeroCopy(session.get()));
+  ASSERT_TRUE(hiveConfig.nimblePreserveDictionaryEncoding(session.get()));
 }
diff --git a/velox/connectors/hive/tests/HiveConnectorSerDeTest.cpp b/velox/connectors/hive/tests/HiveConnectorSerDeTest.cpp
index 345050cc55e..9bec9c0c5a7 100644
--- a/velox/connectors/hive/tests/HiveConnectorSerDeTest.cpp
+++ b/velox/connectors/hive/tests/HiveConnectorSerDeTest.cpp
@@ -115,26 +115,44 @@ TEST_F(HiveConnectorSerDeTest, hiveTableHandle) {
   auto rowType =
       ROW({"c0c0", "c1", "c2", "c3", "c4", "c5"},
           {INTEGER(), BIGINT(), DOUBLE(), BOOLEAN(), BIGINT(), VARCHAR()});
-  auto tableHandle = makeTableHandle(
-      common::test::SubfieldFiltersBuilder()
-          .add("c0.c0", isNotNull())
-          .add(
-              "c1",
-              lessThanOrEqualHugeint(std::numeric_limits<int128_t>::max()))
-          .add("c2", greaterThanOrEqualDouble(3.1415))
-          .add("c3", boolEqual(true))
-          .add("c4", in({0xdeadbeaf, 0xcafecafe}))
-          .add("c2", notIn({0xdeadbeaf, 0xcafecafe}))
-          .add(
-              "c5",
-              orFilter(between("abc", "efg"), greaterThanOrEqual("dragon")))
-          .build(),
-      parseExpr("c1 > c4 and c3 = true", rowType),
-      "hive_table",
-      ROW({"c0", "c1"}, {BIGINT(), VARCHAR()}),
-      true,
-      {{dwio::common::TableParameter::kSkipHeaderLineCount, "1"}});
-  testSerde(*tableHandle);
+
+  for (bool withIndexColumns : {false, true}) {
+    SCOPED_TRACE(fmt::format("withIndexColumns: {}", withIndexColumns));
+
+    std::vector<std::string> indexColumns = withIndexColumns
+        ? std::vector<std::string>{"c0c0", "c1"}
+        : std::vector<std::string>{};
+
+    auto tableHandle = makeTableHandle(
+        common::test::SubfieldFiltersBuilder()
+            .add("c0.c0", isNotNull())
+            .add(
+                "c1",
+                lessThanOrEqualHugeint(std::numeric_limits<int128_t>::max()))
+            .add("c2", greaterThanOrEqualDouble(3.1415))
+            .add("c3", boolEqual(true))
+            .add("c4", in({0xdeadbeaf, 0xcafecafe}))
+            .add("c2", notIn({0xdeadbeaf, 0xcafecafe}))
+            .add(
+                "c5",
+                orFilter(between("abc", "efg"), greaterThanOrEqual("dragon")))
+            .build(),
+        parseExpr("c1 > c4 and c3 = true", rowType),
+        "hive_table",
+        ROW({"c0", "c1"}, {BIGINT(), VARCHAR()}),
+        indexColumns,
+        {{dwio::common::TableParameter::kSkipHeaderLineCount, "1"}});
+
+    EXPECT_EQ(tableHandle->supportsIndexLookup(), withIndexColumns);
+    EXPECT_TRUE(tableHandle->needsIndexSplit());
+    EXPECT_EQ(tableHandle->indexColumns().empty(), !withIndexColumns);
+    if (withIndexColumns) {
+      EXPECT_EQ(tableHandle->indexColumns().size(), 2);
+      EXPECT_EQ(tableHandle->indexColumns()[0], "c0c0");
+      EXPECT_EQ(tableHandle->indexColumns()[1], "c1");
+    }
+    testSerde(*tableHandle);
+  }
 }
 
 TEST_F(HiveConnectorSerDeTest, hiveColumnHandle) {
@@ -150,10 +168,11 @@ TEST_F(HiveConnectorSerDeTest, hiveColumnHandle) {
   });
 
   auto columnHandleTypes = {
-      HiveColumnHandle::ColumnType::kPartitionKey,
-      HiveColumnHandle::ColumnType::kRegular,
-      HiveColumnHandle::ColumnType::kSynthesized,
-      HiveColumnHandle::ColumnType::kRowIndex,
+      FileColumnHandle::ColumnType::kPartitionKey,
+      FileColumnHandle::ColumnType::kRegular,
+      FileColumnHandle::ColumnType::kSynthesized,
+      FileColumnHandle::ColumnType::kRowIndex,
+      FileColumnHandle::ColumnType::kRowId,
   };
 
   for (auto columnHandleType : columnHandleTypes) {
@@ -211,6 +230,11 @@ TEST_F(HiveConnectorSerDeTest, hiveInsertTableHandle) {
       {"key2", "value2"},
   };
 
+  std::unordered_map<std::string, std::string> storageParameters = {
+      {"key3", "value3"},
+      {"key4", "value4"},
+  };
+
   auto hiveInsertTableHandle =
       exec::test::HiveConnectorTestBase::makeHiveInsertTableHandle(
           tableColumnNames,
@@ -220,7 +244,10 @@ TEST_F(HiveConnectorSerDeTest, hiveInsertTableHandle) {
           locationHandle,
           dwio::common::FileFormat::NIMBLE,
           common::CompressionKind::CompressionKind_SNAPPY,
-          serdeParameters);
+          serdeParameters,
+          nullptr, // writerOptions
+          false, // ensureFiles
+          storageParameters);
   testSerde(*hiveInsertTableHandle);
 }
 
diff --git a/velox/connectors/hive/tests/HiveConnectorTest.cpp b/velox/connectors/hive/tests/HiveConnectorTest.cpp
index 6fdc8d130c9..180e347b4b6 100644
--- a/velox/connectors/hive/tests/HiveConnectorTest.cpp
+++ b/velox/connectors/hive/tests/HiveConnectorTest.cpp
@@ -18,9 +18,15 @@
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/connectors/hive/ExtractionUtils.h"
+#include "velox/connectors/hive/FileHandle.h"
 #include "velox/connectors/hive/HiveConfig.h"
 #include "velox/connectors/hive/HiveConnectorUtil.h"
 #include "velox/connectors/hive/HiveDataSource.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/expression/ExprConstants.h"
 #include "velox/expression/ExprToSubfieldFilter.h"
 
 namespace facebook::velox::connector::hive {
@@ -92,17 +98,20 @@ TEST_F(HiveConnectorTest, makeScanSpecRequiredSubfieldsMultilevel) {
   auto rowType = ROW({{"c0", columnType}});
   auto subfields = makeSubfields({"c0.c0c1[3][\"foo\"].c0c1c0"});
   for (bool statsBasedFilterReorderDisabled : {false, true}) {
-    SCOPED_TRACE(fmt::format(
-        "statsBasedFilterReorderDisabled {}", statsBasedFilterReorderDisabled));
+    SCOPED_TRACE(
+        fmt::format(
+            "statsBasedFilterReorderDisabled {}",
+            statsBasedFilterReorderDisabled));
 
     auto scanSpec = makeScanSpec(
         rowType,
         groupSubfields(subfields),
-        {},
-        nullptr,
-        {},
-        {},
-        {},
+        /*subfieldFilters=*/{},
+        /*indexColumns=*/{},
+        /*dataColumns=*/nullptr,
+        /*partitionKeys=*/{},
+        /*infoColumns=*/{},
+        /*specialColumns=*/{},
         statsBasedFilterReorderDisabled,
         pool_.get());
     ASSERT_EQ(
@@ -141,12 +150,13 @@ TEST_F(HiveConnectorTest, makeScanSpecRequiredSubfieldsMergeFields) {
       rowType,
       groupSubfields(makeSubfields(
           {"c0.c0c0.c0c0c0", "c0.c0c0.c0c0c2", "c0.c0c1", "c0.c0c1.c0c1c0"})),
-      {},
-      nullptr,
-      {},
-      {},
-      {},
-      false,
+      /*subfieldFilters=*/{},
+      /*indexColumns=*/{},
+      /*dataColumns=*/nullptr,
+      /*partitionKeys=*/{},
+      /*infoColumns=*/{},
+      /*specialColumns=*/{},
+      /*disableStatsBasedFilterReorder=*/false,
       pool_.get());
   auto* c0c0 = scanSpec->childByName("c0")->childByName("c0c0");
   ASSERT_FALSE(c0c0->childByName("c0c0c0")->isConstant());
@@ -166,12 +176,13 @@ TEST_F(HiveConnectorTest, makeScanSpecRequiredSubfieldsMergeArray) {
   auto scanSpec = makeScanSpec(
       rowType,
       groupSubfields(makeSubfields({"c0[1].c0c0", "c0[2].c0c2"})),
-      {},
-      nullptr,
-      {},
-      {},
-      {},
-      false,
+      /*subfieldFilters=*/{},
+      /*indexColumns=*/{},
+      /*dataColumns=*/nullptr,
+      /*partitionKeys=*/{},
+      /*infoColumns=*/{},
+      /*specialColumns=*/{},
+      /*disableStatsBasedFilterReorder=*/false,
       pool_.get());
   auto* c0 = scanSpec->childByName("c0");
   ASSERT_EQ(c0->maxArrayElementsCount(), 2);
@@ -192,12 +203,13 @@ TEST_F(HiveConnectorTest, makeScanSpecRequiredSubfieldsMergeArrayNegative) {
       makeScanSpec(
           rowType,
           groupedSubfields,
-          {},
-          nullptr,
-          {},
-          {},
-          {},
-          false,
+          /*subfieldFilters=*/{},
+          /*indexColumns=*/{},
+          /*dataColumns=*/nullptr,
+          /*partitionKeys=*/{},
+          /*infoColumns=*/{},
+          /*specialColumns=*/{},
+          /*disableStatsBasedFilterReorder=*/false,
           pool_.get()),
       "Non-positive array subscript cannot be push down");
 }
@@ -210,12 +222,13 @@ TEST_F(HiveConnectorTest, makeScanSpecRequiredSubfieldsMergeMap) {
   auto scanSpec = makeScanSpec(
       rowType,
       groupSubfields(makeSubfields({"c0[10].c0c0", "c0[20].c0c2"})),
-      {},
-      nullptr,
-      {},
-      {},
-      {},
-      false,
+      /*subfieldFilters=*/{},
+      /*indexColumns=*/{},
+      /*dataColumns=*/nullptr,
+      /*partitionKeys=*/{},
+      /*infoColumns=*/{},
+      /*specialColumns=*/{},
+      /*disableStatsBasedFilterReorder=*/false,
       pool_.get());
   auto* c0 = scanSpec->childByName("c0");
   ASSERT_EQ(
@@ -241,12 +254,13 @@ TEST_F(
   auto scanSpec = makeScanSpec(
       rowType,
       groupSubfields(makeSubfields({"c0[\"foo\"]"})),
-      {},
-      nullptr,
-      {},
-      {},
-      {},
-      false,
+      /*subfieldFilters=*/{},
+      /*indexColumns=*/{},
+      /*dataColumns=*/nullptr,
+      /*partitionKeys=*/{},
+      /*infoColumns=*/{},
+      /*specialColumns=*/{},
+      /*disableStatsBasedFilterReorder=*/false,
       pool_.get());
   auto* c0 = scanSpec->childByName("c0");
   ASSERT_EQ(c0->flatMapFeatureSelection(), std::vector<std::string>({"foo"}));
@@ -263,12 +277,13 @@ TEST_F(HiveConnectorTest, makeScanSpecRequiredSubfieldsAllSubscripts) {
     auto scanSpec = makeScanSpec(
         rowType,
         groupSubfields(makeSubfields({path})),
-        {},
-        nullptr,
-        {},
-        {},
-        {},
-        false,
+        /*subfieldFilters=*/{},
+        /*indexColumns=*/{},
+        /*dataColumns=*/nullptr,
+        /*partitionKeys=*/{},
+        /*infoColumns=*/{},
+        /*specialColumns=*/{},
+        /*disableStatsBasedFilterReorder=*/false,
         pool_.get());
     auto* c0 = scanSpec->childByName("c0");
     ASSERT_TRUE(c0->flatMapFeatureSelection().empty());
@@ -285,12 +300,13 @@ TEST_F(HiveConnectorTest, makeScanSpecRequiredSubfieldsAllSubscripts) {
   auto scanSpec = makeScanSpec(
       rowType,
       groupSubfields(makeSubfields({"c0[*][*].c0c0"})),
-      {},
-      nullptr,
-      {},
-      {},
-      {},
-      false,
+      /*subfieldFilters=*/{},
+      /*indexColumns=*/{},
+      /*dataColumns=*/nullptr,
+      /*partitionKeys=*/{},
+      /*infoColumns=*/{},
+      /*specialColumns=*/{},
+      /*disableStatsBasedFilterReorder=*/false,
       pool_.get());
   auto* c0 = scanSpec->childByName("c0");
   ASSERT_TRUE(mapKeyIsNotNull(*c0));
@@ -310,12 +326,13 @@ TEST_F(HiveConnectorTest, makeScanSpecRequiredSubfieldsDoubleMapKey) {
   auto scanSpec = makeScanSpec(
       rowType,
       groupSubfields(makeSubfields({"c0[0]", "c1[-1]"})),
-      {},
-      nullptr,
-      {},
-      {},
-      {},
-      false,
+      /*subfieldFilters=*/{},
+      /*indexColumns=*/{},
+      /*dataColumns=*/nullptr,
+      /*partitionKeys=*/{},
+      /*infoColumns=*/{},
+      /*specialColumns=*/{},
+      /*disableStatsBasedFilterReorder=*/false,
       pool_.get());
   auto* keysFilter = scanSpec->childByName("c0")
                          ->childByName(ScanSpec::kMapKeysFieldName)
@@ -340,12 +357,13 @@ TEST_F(HiveConnectorTest, makeScanSpecRequiredSubfieldsDoubleMapKey) {
       rowType,
       groupSubfields(makeSubfields(
           {"c0[-9223372036854775808]", "c1[9223372036854775807]"})),
-      {},
-      nullptr,
-      {},
-      {},
-      {},
-      false,
+      /*subfieldFilters=*/{},
+      /*indexColumns=*/{},
+      /*dataColumns=*/nullptr,
+      /*partitionKeys=*/{},
+      /*infoColumns=*/{},
+      /*specialColumns=*/{},
+      /*disableStatsBasedFilterReorder=*/false,
       pool_.get());
   keysFilter = scanSpec->childByName("c0")
                    ->childByName(ScanSpec::kMapKeysFieldName)
@@ -361,12 +379,13 @@ TEST_F(HiveConnectorTest, makeScanSpecRequiredSubfieldsDoubleMapKey) {
       rowType,
       groupSubfields(makeSubfields(
           {"c0[9223372036854775807]", "c0[-9223372036854775808]"})),
-      {},
-      nullptr,
-      {},
-      {},
-      {},
-      false,
+      /*subfieldFilters=*/{},
+      /*indexColumns=*/{},
+      /*dataColumns=*/nullptr,
+      /*partitionKeys=*/{},
+      /*infoColumns=*/{},
+      /*specialColumns=*/{},
+      /*disableStatsBasedFilterReorder=*/false,
       pool_.get());
   keysFilter = scanSpec->childByName("c0")
                    ->childByName(ScanSpec::kMapKeysFieldName)
@@ -379,12 +398,13 @@ TEST_F(HiveConnectorTest, makeScanSpecRequiredSubfieldsDoubleMapKey) {
   scanSpec = makeScanSpec(
       rowType,
       groupSubfields(makeSubfields({"c0[-100000000]", "c0[100000000]"})),
-      {},
-      nullptr,
-      {},
-      {},
-      {},
-      false,
+      /*subfieldFilters=*/{},
+      /*indexColumns=*/{},
+      /*dataColumns=*/nullptr,
+      /*partitionKeys=*/{},
+      /*infoColumns=*/{},
+      /*specialColumns=*/{},
+      /*disableStatsBasedFilterReorder=*/false,
       pool_.get());
   keysFilter = scanSpec->childByName("c0")
                    ->childByName(ScanSpec::kMapKeysFieldName)
@@ -422,11 +442,12 @@ TEST_F(HiveConnectorTest, makeScanSpecRequiredSubfieldsOnlyInFilters) {
       readerOutputType,
       groupSubfields(makeSubfields({"c0.c0c1", "c0.c0c3"})),
       filters,
-      ROW({{"c0", c0Type}, {"c1", c1Type}}),
-      {},
-      {},
-      {},
-      false,
+      /*indexColumns=*/{},
+      /*dataColumns=*/ROW({{"c0", c0Type}, {"c1", c1Type}}),
+      /*partitionKeys=*/{},
+      /*infoColumns=*/{},
+      /*specialColumns=*/{},
+      /*disableStatsBasedFilterReorder=*/false,
       pool_.get());
 
   auto c0 = scanSpec->childByName("c0");
@@ -503,12 +524,13 @@ TEST_F(HiveConnectorTest, makeScanSpecDuplicateSubfields) {
       rowType,
       groupSubfields(makeSubfields(
           {"c0[10][1]", "c0[10][2]", "c1[\"foo\"][1]", "c1[\"foo\"][2]"})),
-      {},
-      nullptr,
-      {},
-      {},
-      {},
-      false,
+      /*subfieldFilters=*/{},
+      /*indexColumns=*/{},
+      /*dataColumns=*/nullptr,
+      /*partitionKeys=*/{},
+      /*infoColumns=*/{},
+      /*specialColumns=*/{},
+      /*disableStatsBasedFilterReorder=*/false,
       pool_.get());
   auto* c0 = scanSpec->childByName("c0");
   ASSERT_EQ(c0->children().size(), 2);
@@ -523,13 +545,14 @@ TEST_F(HiveConnectorTest, makeScanSpecFilterPartitionKey) {
   filters.emplace(Subfield("ds"), exec::equal("2023-10-13"));
   auto scanSpec = makeScanSpec(
       rowType,
-      {},
+      /*outputSubfields=*/{},
       filters,
-      rowType,
-      {{"ds", nullptr}},
-      {},
-      {},
-      false,
+      /*indexColumns=*/{},
+      /*dataColumns=*/rowType,
+      /*partitionKeys=*/{{"ds", nullptr}},
+      /*infoColumns=*/{},
+      /*specialColumns=*/{},
+      /*disableStatsBasedFilterReorder=*/false,
       pool_.get());
   ASSERT_TRUE(scanSpec->childByName("c0")->projectOut());
   ASSERT_FALSE(scanSpec->childByName("ds")->projectOut());
@@ -544,12 +567,13 @@ TEST_F(HiveConnectorTest, makeScanSpecPrunedMapNonNullMapKey) {
   auto scanSpec = makeScanSpec(
       rowType,
       groupSubfields(makeSubfields({"c0.c0c1"})),
-      {},
-      nullptr,
-      {},
-      {},
-      {},
-      false,
+      /*subfieldFilters=*/{},
+      /*indexColumns=*/{},
+      /*dataColumns=*/nullptr,
+      /*partitionKeys=*/{},
+      /*infoColumns=*/{},
+      /*specialColumns=*/{},
+      /*disableStatsBasedFilterReorder=*/false,
       pool_.get());
   auto* c0 = scanSpec->childByName("c0");
   ASSERT_EQ(c0->children().size(), 2);
@@ -560,12 +584,13 @@ TEST_F(HiveConnectorTest, makeScanSpecPrunedMapNonNullMapKey) {
   scanSpec = makeScanSpec(
       rowType,
       groupSubfields(makeSubfields({"c0.c0c0"})),
-      {},
-      nullptr,
-      {},
-      {},
-      {},
-      false,
+      /*subfieldFilters=*/{},
+      /*indexColumns=*/{},
+      /*dataColumns=*/nullptr,
+      /*partitionKeys=*/{},
+      /*infoColumns=*/{},
+      /*specialColumns=*/{},
+      /*disableStatsBasedFilterReorder=*/false,
       pool_.get());
   c0 = scanSpec->childByName("c0");
   ASSERT_EQ(c0->children().size(), 2);
@@ -581,8 +606,8 @@ TEST_F(HiveConnectorTest, extractFiltersFromRemainingFilter) {
   auto expr = parseExpr("not (c0 > 0 or c1 > 0)", rowType);
   SubfieldFilters filters;
   double sampleRate = 1;
-  auto remaining = extractFiltersFromRemainingFilter(
-      expr, &evaluator, false, filters, sampleRate);
+  auto remaining =
+      extractFiltersFromRemainingFilter(expr, &evaluator, filters, sampleRate);
   ASSERT_FALSE(remaining);
   ASSERT_EQ(sampleRate, 1);
   ASSERT_EQ(filters.size(), 2);
@@ -591,8 +616,8 @@ TEST_F(HiveConnectorTest, extractFiltersFromRemainingFilter) {
 
   expr = parseExpr("not (c0 > 0 or c1 > c0)", rowType);
   filters.clear();
-  remaining = extractFiltersFromRemainingFilter(
-      expr, &evaluator, false, filters, sampleRate);
+  remaining =
+      extractFiltersFromRemainingFilter(expr, &evaluator, filters, sampleRate);
   ASSERT_EQ(sampleRate, 1);
   ASSERT_EQ(filters.size(), 1);
   ASSERT_GT(filters.count(Subfield("c0")), 0);
@@ -602,14 +627,70 @@ TEST_F(HiveConnectorTest, extractFiltersFromRemainingFilter) {
   expr = parseExpr(
       "not (c2 > 1::decimal(20, 0) or c2 < 0::decimal(20, 0))", rowType);
   filters.clear();
-  remaining = extractFiltersFromRemainingFilter(
-      expr, &evaluator, false, filters, sampleRate);
+  remaining =
+      extractFiltersFromRemainingFilter(expr, &evaluator, filters, sampleRate);
   ASSERT_EQ(sampleRate, 1);
   ASSERT_GT(filters.count(Subfield("c2")), 0);
   // Change these once HUGEINT filter merge is fixed.
   ASSERT_TRUE(remaining);
   ASSERT_EQ(
       remaining->toString(), "not(lt(ROW[\"c2\"],cast(0 as DECIMAL(20, 0))))");
+
+  // parseExpr gives AND/OR with 2 arguments.  We need to construct the node
+  // manually to have more than 2.
+  expr = std::make_shared<core::CallTypedExpr>(
+      BOOLEAN(),
+      expression::kAnd,
+      parseExpr("c0 > 0", rowType),
+      parseExpr("c1 > 0", rowType),
+      parseExpr("c2 > 0::decimal(20, 0)", rowType));
+  filters.clear();
+  remaining =
+      extractFiltersFromRemainingFilter(expr, &evaluator, filters, sampleRate);
+  ASSERT_EQ(sampleRate, 1);
+  ASSERT_EQ(filters.size(), 3);
+  ASSERT_TRUE(filters.contains(Subfield("c0")));
+  ASSERT_TRUE(filters.contains(Subfield("c1")));
+  ASSERT_TRUE(filters.contains(Subfield("c2")));
+  ASSERT_FALSE(remaining);
+
+  expr = std::make_shared<core::CallTypedExpr>(
+      BOOLEAN(),
+      expression::kAnd,
+      parseExpr("c0 % 2 = 0", rowType),
+      parseExpr("c1 % 3 = 0", rowType),
+      parseExpr("c2 > 0::decimal(20, 0)", rowType));
+  filters.clear();
+  remaining =
+      extractFiltersFromRemainingFilter(expr, &evaluator, filters, sampleRate);
+  ASSERT_EQ(sampleRate, 1);
+  ASSERT_EQ(filters.size(), 1);
+  ASSERT_TRUE(filters.contains(Subfield("c2")));
+  ASSERT_TRUE(remaining);
+  ASSERT_EQ(
+      remaining->toString(),
+      "and(eq(mod(ROW[\"c0\"],2),0),eq(mod(ROW[\"c1\"],3),0))");
+
+  // Test VARCHAR OR filter pushdown:
+  // n_name = 'FRANCE' OR n_name = 'GERMANY' should push down as
+  // BytesValues('FRANCE', 'GERMANY').
+  {
+    auto varcharRowType = ROW({"n_name"}, {VARCHAR()});
+    expr = parseExpr("n_name = 'FRANCE' or n_name = 'GERMANY'", varcharRowType);
+    filters.clear();
+    remaining = extractFiltersFromRemainingFilter(
+        expr, &evaluator, filters, sampleRate);
+    ASSERT_FALSE(remaining);
+    ASSERT_EQ(sampleRate, 1);
+    ASSERT_EQ(filters.size(), 1);
+    ASSERT_TRUE(filters.contains(Subfield("n_name")));
+    auto* filter = filters.at(Subfield("n_name")).get();
+    ASSERT_TRUE(filter->is(FilterKind::kBytesValues));
+    auto* bytesValues = filter->as<BytesValues>();
+    ASSERT_EQ(bytesValues->values().size(), 2);
+    ASSERT_TRUE(bytesValues->values().count("FRANCE"));
+    ASSERT_TRUE(bytesValues->values().count("GERMANY"));
+  }
 }
 
 TEST_F(HiveConnectorTest, prestoTableSampling) {
@@ -620,8 +701,8 @@ TEST_F(HiveConnectorTest, prestoTableSampling) {
   auto expr = parseExpr("rand() < 0.5", rowType);
   SubfieldFilters filters;
   double sampleRate = 1;
-  auto remaining = extractFiltersFromRemainingFilter(
-      expr, &evaluator, false, filters, sampleRate);
+  auto remaining =
+      extractFiltersFromRemainingFilter(expr, &evaluator, filters, sampleRate);
   ASSERT_FALSE(remaining);
   ASSERT_EQ(sampleRate, 0.5);
   ASSERT_TRUE(filters.empty());
@@ -629,8 +710,8 @@ TEST_F(HiveConnectorTest, prestoTableSampling) {
   expr = parseExpr("c0 > 0 and rand() < 0.5", rowType);
   filters.clear();
   sampleRate = 1;
-  remaining = extractFiltersFromRemainingFilter(
-      expr, &evaluator, false, filters, sampleRate);
+  remaining =
+      extractFiltersFromRemainingFilter(expr, &evaluator, filters, sampleRate);
   ASSERT_FALSE(remaining);
   ASSERT_EQ(sampleRate, 0.5);
   ASSERT_EQ(filters.size(), 1);
@@ -639,8 +720,8 @@ TEST_F(HiveConnectorTest, prestoTableSampling) {
   expr = parseExpr("rand() < 0.5 and rand() < 0.5", rowType);
   filters.clear();
   sampleRate = 1;
-  remaining = extractFiltersFromRemainingFilter(
-      expr, &evaluator, false, filters, sampleRate);
+  remaining =
+      extractFiltersFromRemainingFilter(expr, &evaluator, filters, sampleRate);
   ASSERT_FALSE(remaining);
   ASSERT_EQ(sampleRate, 0.25);
   ASSERT_TRUE(filters.empty());
@@ -648,13 +729,532 @@ TEST_F(HiveConnectorTest, prestoTableSampling) {
   expr = parseExpr("c0 > 0 or rand() < 0.5", rowType);
   filters.clear();
   sampleRate = 1;
-  remaining = extractFiltersFromRemainingFilter(
-      expr, &evaluator, false, filters, sampleRate);
+  remaining =
+      extractFiltersFromRemainingFilter(expr, &evaluator, filters, sampleRate);
   ASSERT_TRUE(remaining);
   ASSERT_EQ(*remaining, *expr);
   ASSERT_EQ(sampleRate, 1);
   ASSERT_TRUE(filters.empty());
 }
 
+#define VELOX_ASSERT_FILTER(expected, actual)   \
+  ASSERT_TRUE(expected->testingEquals(*actual)) \
+      << expected->toString() << " vs " << actual->toString();
+
+TEST_F(HiveConnectorTest, disjuncts) {
+  auto queryCtx = core::QueryCtx::create();
+  exec::SimpleExpressionEvaluator evaluator(queryCtx.get(), pool_.get());
+  auto rowType = ROW({"c0", "c1", "c2"}, {BIGINT(), BIGINT(), DECIMAL(20, 0)});
+
+  {
+    auto expr =
+        parseExpr("(c0 > 0 and c0 < 10) or (c0 > 5 and c0 < 15)", rowType);
+
+    SubfieldFilters filters;
+    double sampleRate = 1;
+    auto remaining = extractFiltersFromRemainingFilter(
+        expr, &evaluator, filters, sampleRate);
+    ASSERT_TRUE(remaining == nullptr);
+    ASSERT_EQ(sampleRate, 1);
+    ASSERT_EQ(filters.size(), 1);
+    VELOX_ASSERT_FILTER(exec::between(1, 14), filters.begin()->second);
+  }
+
+  {
+    auto expr = parseExpr("(c0 between -10 and 12)", rowType);
+
+    SubfieldFilters filters;
+    double sampleRate = 1;
+    auto remaining = extractFiltersFromRemainingFilter(
+        expr, &evaluator, filters, sampleRate);
+    ASSERT_TRUE(remaining == nullptr);
+    ASSERT_EQ(sampleRate, 1);
+    ASSERT_EQ(filters.size(), 1);
+    ASSERT_EQ(filters.begin()->first, Subfield("c0"));
+    VELOX_ASSERT_FILTER(exec::between(-10, 12), filters.begin()->second);
+
+    expr = parseExpr("(c0 > 0 and c0 < 10) or (c0 > 5 and c0 < 15)", rowType);
+    remaining = extractFiltersFromRemainingFilter(
+        expr, &evaluator, filters, sampleRate);
+    ASSERT_TRUE(remaining == nullptr);
+    ASSERT_EQ(sampleRate, 1);
+    ASSERT_EQ(filters.size(), 1);
+    ASSERT_EQ(filters.begin()->first, Subfield("c0"));
+    VELOX_ASSERT_FILTER(exec::between(1, 12), filters.begin()->second);
+  }
+
+  {
+    auto expr = parseExpr("c0 not in (1, 3) or c0 in (1, 2)", rowType);
+    SubfieldFilters filters;
+    double sampleRate = 1;
+    auto remaining = extractFiltersFromRemainingFilter(
+        expr, &evaluator, filters, sampleRate);
+    ASSERT_EQ(remaining, expr);
+    ASSERT_EQ(sampleRate, 1);
+    ASSERT_TRUE(filters.empty());
+  }
+}
+
+#undef VELOX_ASSERT_FILTER
+
+/// A mock filesystem that delegates to the local filesystem but captures
+/// the FileOptions::fileReadOps passed to openFileForRead. Used to verify
+/// that FileSplitReader::createReader() propagates table identity (dbName,
+/// tableName) into fileReadOps.
+class CapturingFileSystem : public filesystems::FileSystem {
+ public:
+  static constexpr std::string_view kScheme = "capture:";
+
+  static folly::F14FastMap<std::string, std::string>& capturedFileReadOps() {
+    static folly::F14FastMap<std::string, std::string> instance;
+    return instance;
+  }
+
+  explicit CapturingFileSystem(std::shared_ptr<const config::ConfigBase> config)
+      : FileSystem(std::move(config)) {}
+
+  std::string name() const override {
+    return "capture";
+  }
+
+  std::string_view extractPath(std::string_view path) const override {
+    if (path.substr(0, kScheme.size()) == kScheme) {
+      return path.substr(kScheme.size());
+    }
+    return path;
+  }
+
+  std::unique_ptr<ReadFile> openFileForRead(
+      std::string_view path,
+      const filesystems::FileOptions& options) override {
+    capturedFileReadOps() = options.fileReadOps;
+    auto localPath = extractPath(path);
+    return filesystems::getFileSystem(localPath, config_)
+        ->openFileForRead(localPath, options);
+  }
+
+  std::unique_ptr<WriteFile> openFileForWrite(
+      std::string_view,
+      const filesystems::FileOptions&) override {
+    VELOX_UNSUPPORTED();
+  }
+
+  void remove(std::string_view) override {
+    VELOX_UNSUPPORTED();
+  }
+
+  void rename(std::string_view, std::string_view, bool) override {
+    VELOX_UNSUPPORTED();
+  }
+
+  bool exists(std::string_view path) override {
+    auto localPath = extractPath(path);
+    return filesystems::getFileSystem(localPath, config_)->exists(localPath);
+  }
+
+  std::vector<std::string> list(std::string_view) override {
+    VELOX_UNSUPPORTED();
+  }
+
+  void mkdir(std::string_view, const filesystems::DirectoryOptions&) override {
+    VELOX_UNSUPPORTED();
+  }
+
+  void rmdir(std::string_view) override {
+    VELOX_UNSUPPORTED();
+  }
+};
+
+TEST_F(HiveConnectorTest, fileReadOpsTableIdentityPropagation) {
+  // Register the capturing filesystem once.
+  static bool registered = false;
+  if (!registered) {
+    filesystems::registerFileSystem(
+        [](std::string_view path) {
+          return path.find(CapturingFileSystem::kScheme) == 0;
+        },
+        [](std::shared_ptr<const config::ConfigBase> config, std::string_view) {
+          return std::make_shared<CapturingFileSystem>(std::move(config));
+        });
+    registered = true;
+  }
+
+  // Write test data to a local temp file.
+  auto rowType = ROW({"c0"}, {BIGINT()});
+  auto vector = makeRowVector({"c0"}, {makeFlatVector<int64_t>({1, 2, 3})});
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vector);
+
+  // Create a table handle with dbName and tableName set.
+  auto tableHandle = std::make_shared<HiveTableHandle>(
+      kHiveConnectorId,
+      "test_table",
+      SubfieldFilters{},
+      /*remainingFilter=*/nullptr,
+      /*dataColumns=*/nullptr,
+      /*indexColumns=*/std::vector<std::string>{},
+      /*tableParameters=*/std::unordered_map<std::string, std::string>{},
+      /*filterColumnHandles=*/std::vector<HiveColumnHandlePtr>{},
+      /*sampleRate=*/1.0,
+      /*dbName=*/"test_db");
+
+  // Build the split using the capturing filesystem scheme so that
+  // openFileForRead captures the fileReadOps populated by FileSplitReader.
+  auto split = exec::test::HiveConnectorSplitBuilder(
+                   fmt::format("capture:{}", filePath->getPath()))
+                   .fileFormat(dwio::common::FileFormat::DWRF)
+                   .build();
+
+  // Build and run a table scan. This exercises the full pipeline:
+  // FileSplitReader::createReader() -> FileHandleGenerator ->
+  // CapturingFileSystem.
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(rowType)
+                  .tableHandle(tableHandle)
+                  .assignments(allRegularColumns(rowType))
+                  .endTableScan()
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan).split(split).copyResults(pool_.get());
+  ASSERT_EQ(result->size(), 3);
+
+  // Verify that FileSplitReader propagated dbName and tableName into
+  // fileReadOps.
+  auto& captured = CapturingFileSystem::capturedFileReadOps();
+  ASSERT_EQ(captured.at(std::string(kDbNameKey)), "test_db");
+  ASSERT_EQ(captured.at(std::string(kTableNameKey)), "test_table");
+}
+
+/// Verifies that getRuntimeStats() merge logic allows IoStats (ReadFile-layer)
+/// to override the storageReadBytes value from IoStatistics (DWIO-level).
+TEST_F(HiveConnectorTest, ioStatsOverridesStorageReadBytes) {
+  // Step 1: Simulate DWIO-level IoStatistics with an inaccurate estimate.
+  auto ioStatistics = std::make_shared<io::IoStatistics>();
+  ioStatistics->read().increment(200); // DWIO estimate (undercounts gaps)
+
+  // Step 2: Simulate ReadFile-layer IoStats with ground-truth values.
+  IoStats ioStats;
+  ioStats.addCounter(
+      std::string(FileDataSource::kStorageReadBytes),
+      RuntimeCounter(50, RuntimeCounter::Unit::kBytes));
+  ioStats.addCounter(
+      "extentCacheHitBytes", RuntimeCounter(250, RuntimeCounter::Unit::kBytes));
+
+  // Replicate the merge logic from FileDataSource::getRuntimeStats().
+  std::unordered_map<std::string, RuntimeMetric> res;
+
+  // IoStatistics inserts first (Step 2 in getRuntimeStats).
+  res.insert(
+      {std::string(FileDataSource::kStorageReadBytes),
+       RuntimeMetric(
+           ioStatistics->read().sum(),
+           ioStatistics->read().count(),
+           ioStatistics->read().min(),
+           ioStatistics->read().max(),
+           RuntimeCounter::Unit::kBytes)});
+
+  // IoStats merge (Step 3 in getRuntimeStats) -- override storageReadBytes.
+  const auto ioStatsMap = ioStats.stats();
+  for (const auto& [key, value] : ioStatsMap) {
+    if (key == FileDataSource::kStorageReadBytes) {
+      res[std::string(key)] = value;
+    } else {
+      res.emplace(key, value);
+    }
+  }
+
+  // Ground-truth storageReadBytes from IoStats should override DWIO estimate.
+  ASSERT_EQ(res.at("storageReadBytes").sum, 50);
+  ASSERT_EQ(res.at("storageReadBytes").unit, RuntimeCounter::Unit::kBytes);
+  // extentCacheHitBytes should be added as a new diagnostic counter.
+  ASSERT_EQ(res.at("extentCacheHitBytes").sum, 250);
+}
+
+/// Verifies that without IoStats override, storageReadBytes retains the
+/// IoStatistics value.
+TEST_F(HiveConnectorTest, storageReadBytesWithoutOverride) {
+  auto ioStatistics = std::make_shared<io::IoStatistics>();
+  ioStatistics->read().increment(200);
+
+  // IoStats has unrelated counters only -- no storageReadBytes.
+  IoStats ioStats;
+  ioStats.addCounter(
+      "wsInRegionReadBytes", RuntimeCounter(300, RuntimeCounter::Unit::kBytes));
+
+  std::unordered_map<std::string, RuntimeMetric> res;
+  res.insert(
+      {std::string(FileDataSource::kStorageReadBytes),
+       RuntimeMetric(
+           ioStatistics->read().sum(),
+           ioStatistics->read().count(),
+           ioStatistics->read().min(),
+           ioStatistics->read().max(),
+           RuntimeCounter::Unit::kBytes)});
+
+  const auto ioStatsMap = ioStats.stats();
+  for (const auto& [key, value] : ioStatsMap) {
+    if (key == FileDataSource::kStorageReadBytes) {
+      res[std::string(key)] = value;
+    } else {
+      res.emplace(key, value);
+    }
+  }
+
+  // storageReadBytes should retain the IoStatistics value.
+  ASSERT_EQ(res.at("storageReadBytes").sum, 200);
+  // Unrelated IoStats counters should still be added.
+  ASSERT_EQ(res.at("wsInRegionReadBytes").sum, 300);
+}
+
+// --- ScanSpec extraction pushdown tests (file reader layer) ---
+
+TEST_F(HiveConnectorTest, extractionScanSpecMapKeepsBothChildren) {
+  // Map readers read keys and values together, so extraction from maps
+  // does not prune map children.  The extraction is applied post-read.
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  auto rowType = ROW({{"col", hiveType}});
+  auto scanSpec = makeScanSpec(
+      rowType,
+      /*outputSubfields=*/{},
+      /*subfieldFilters=*/{},
+      /*indexColumns=*/{},
+      /*dataColumns=*/nullptr,
+      /*partitionKeys=*/{},
+      /*infoColumns=*/{},
+      /*specialColumns=*/{},
+      /*disableStatsBasedFilterReorder=*/false,
+      pool_.get());
+
+  // MapKeys extraction -- map children should still be readable.
+  std::vector<NamedExtraction> extractions = {
+      {"keys",
+       {ExtractionPathElement::simple(ExtractionStep::kMapKeys)},
+       ARRAY(VARCHAR())}};
+
+  auto* colSpec = scanSpec->childByName("col");
+  ASSERT_NE(colSpec, nullptr);
+  configureExtractionScanSpec(hiveType, extractions, *colSpec, pool_.get());
+
+  auto* keysSpec = colSpec->childByName(ScanSpec::kMapKeysFieldName);
+  ASSERT_NE(keysSpec, nullptr);
+  ASSERT_FALSE(keysSpec->isConstant());
+  auto* valuesSpec = colSpec->childByName(ScanSpec::kMapValuesFieldName);
+  ASSERT_NE(valuesSpec, nullptr);
+  ASSERT_FALSE(valuesSpec->isConstant());
+}
+
+TEST_F(HiveConnectorTest, extractionScanSpecSizeKeepsBothChildren) {
+  // Size extraction on a map -- map children should still be readable
+  // (extraction is post-read).
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  auto rowType = ROW({{"col", hiveType}});
+  auto scanSpec = makeScanSpec(
+      rowType,
+      /*outputSubfields=*/{},
+      /*subfieldFilters=*/{},
+      /*indexColumns=*/{},
+      /*dataColumns=*/nullptr,
+      /*partitionKeys=*/{},
+      /*infoColumns=*/{},
+      /*specialColumns=*/{},
+      /*disableStatsBasedFilterReorder=*/false,
+      pool_.get());
+
+  std::vector<NamedExtraction> extractions = {
+      {"sz", {ExtractionPathElement::simple(ExtractionStep::kSize)}, BIGINT()}};
+
+  auto* colSpec = scanSpec->childByName("col");
+  configureExtractionScanSpec(hiveType, extractions, *colSpec, pool_.get());
+
+  auto* keysSpec = colSpec->childByName(ScanSpec::kMapKeysFieldName);
+  ASSERT_FALSE(keysSpec->isConstant());
+  auto* valuesSpec = colSpec->childByName(ScanSpec::kMapValuesFieldName);
+  ASSERT_FALSE(valuesSpec->isConstant());
+}
+
+TEST_F(HiveConnectorTest, extractionScanSpecStructFieldPruning) {
+  // Extraction with StructField should prune unneeded fields.
+  auto hiveType = ROW({{"x", INTEGER()}, {"y", DOUBLE()}, {"z", VARCHAR()}});
+  auto rowType = ROW({{"col", hiveType}});
+  auto scanSpec = makeScanSpec(
+      rowType,
+      /*outputSubfields=*/{},
+      /*subfieldFilters=*/{},
+      /*indexColumns=*/{},
+      /*dataColumns=*/nullptr,
+      /*partitionKeys=*/{},
+      /*infoColumns=*/{},
+      /*specialColumns=*/{},
+      /*disableStatsBasedFilterReorder=*/false,
+      pool_.get());
+
+  std::vector<NamedExtraction> extractions = {
+      {"col_x", {ExtractionPathElement::structField("x")}, INTEGER()}};
+
+  auto* colSpec = scanSpec->childByName("col");
+  configureExtractionScanSpec(hiveType, extractions, *colSpec, pool_.get());
+
+  // x should be readable, y and z should be constant null.
+  ASSERT_FALSE(colSpec->childByName("x")->isConstant());
+  ASSERT_TRUE(colSpec->childByName("y")->isConstant());
+  ASSERT_TRUE(colSpec->childByName("z")->isConstant());
+}
+
+TEST_F(HiveConnectorTest, scanSpecTransformApplied) {
+  // Verify that a transform set on ScanSpec is callable and produces
+  // the correct output type.
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  auto scanSpec = std::make_shared<ScanSpec>("col");
+  scanSpec->addFieldRecursively("col", *hiveType, 0);
+
+  auto* colSpec = scanSpec->childByName("col");
+  ASSERT_NE(colSpec, nullptr);
+  ASSERT_FALSE(colSpec->hasTransform());
+
+  // Set a MapKeys extraction transform.
+  auto chain = std::vector<ExtractionPathElementPtr>{
+      ExtractionPathElement::simple(ExtractionStep::kMapKeys)};
+  colSpec->setTransform(
+      [chain](const VectorPtr& input, memory::MemoryPool* pool) -> VectorPtr {
+        return applyExtractionChain(input, chain, pool);
+      },
+      ARRAY(VARCHAR()));
+
+  ASSERT_TRUE(colSpec->hasTransform());
+
+  // Create a test MapVector and apply the transform.
+  auto keys = makeFlatVector<StringView>({"a", "b", "c"});
+  auto values = makeFlatVector<int64_t>({1, 2, 3});
+  auto mapVector = makeMapVector({0, 2}, keys, values);
+
+  auto result = colSpec->transform()(mapVector, pool_.get());
+  ASSERT_TRUE(result->type()->isArray());
+  ASSERT_EQ(result->size(), 2);
+  auto* array = result->as<ArrayVector>();
+  ASSERT_EQ(array->sizeAt(0), 2);
+  ASSERT_EQ(array->sizeAt(1), 1);
+}
+
+TEST_F(HiveConnectorTest, extractionScanSpecMapKeyFilterString) {
+  // kMapKeyFilter with string keys should set an IN filter on the keys
+  // ScanSpec.  ExtractionType should remain kNone since kMapKeyFilter is
+  // type-preserving.
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  auto rowType = ROW({{"col", hiveType}});
+  auto scanSpec = makeScanSpec(
+      rowType,
+      /*outputSubfields=*/{},
+      /*subfieldFilters=*/{},
+      /*indexColumns=*/{},
+      /*dataColumns=*/nullptr,
+      /*partitionKeys=*/{},
+      /*infoColumns=*/{},
+      /*specialColumns=*/{},
+      /*disableStatsBasedFilterReorder=*/false,
+      pool_.get());
+
+  std::vector<NamedExtraction> extractions = {
+      {"filtered",
+       {ExtractionPathElement::mapKeyFilter(
+           std::vector<std::string>{"a", "b"})},
+       hiveType}};
+
+  auto* colSpec = scanSpec->childByName("col");
+  ASSERT_NE(colSpec, nullptr);
+  configureExtractionScanSpec(hiveType, extractions, *colSpec, pool_.get());
+
+  // ExtractionType should remain kNone.
+  ASSERT_EQ(colSpec->extractionType(), ScanSpec::ExtractionType::kNone);
+
+  // Keys ScanSpec should have an IN filter set.
+  auto* keysSpec = colSpec->childByName(ScanSpec::kMapKeysFieldName);
+  ASSERT_NE(keysSpec, nullptr);
+  ASSERT_NE(keysSpec->filter(), nullptr);
+  // Filter should pass "a" and "b" but not "c".
+  ASSERT_TRUE(keysSpec->filter()->testStringView(StringView("a")));
+  ASSERT_TRUE(keysSpec->filter()->testStringView(StringView("b")));
+  ASSERT_FALSE(keysSpec->filter()->testStringView(StringView("c")));
+}
+
+TEST_F(HiveConnectorTest, extractionScanSpecMapKeyFilterInt) {
+  // kMapKeyFilter with integer keys should set an IN filter on the keys
+  // ScanSpec.
+  auto hiveType = MAP(BIGINT(), VARCHAR());
+  auto rowType = ROW({{"col", hiveType}});
+  auto scanSpec = makeScanSpec(
+      rowType,
+      /*outputSubfields=*/{},
+      /*subfieldFilters=*/{},
+      /*indexColumns=*/{},
+      /*dataColumns=*/nullptr,
+      /*partitionKeys=*/{},
+      /*infoColumns=*/{},
+      /*specialColumns=*/{},
+      /*disableStatsBasedFilterReorder=*/false,
+      pool_.get());
+
+  std::vector<NamedExtraction> extractions = {
+      {"filtered",
+       {ExtractionPathElement::mapKeyFilter(std::vector<int64_t>{10, 20, 30})},
+       hiveType}};
+
+  auto* colSpec = scanSpec->childByName("col");
+  ASSERT_NE(colSpec, nullptr);
+  configureExtractionScanSpec(hiveType, extractions, *colSpec, pool_.get());
+
+  // ExtractionType should remain kNone.
+  ASSERT_EQ(colSpec->extractionType(), ScanSpec::ExtractionType::kNone);
+
+  // Keys ScanSpec should have an IN filter set.
+  auto* keysSpec = colSpec->childByName(ScanSpec::kMapKeysFieldName);
+  ASSERT_NE(keysSpec, nullptr);
+  ASSERT_NE(keysSpec->filter(), nullptr);
+  // Filter should pass 10, 20, 30 but not 5.
+  ASSERT_TRUE(keysSpec->filter()->testInt64(10));
+  ASSERT_TRUE(keysSpec->filter()->testInt64(20));
+  ASSERT_TRUE(keysSpec->filter()->testInt64(30));
+  ASSERT_FALSE(keysSpec->filter()->testInt64(5));
+}
+
+TEST_F(HiveConnectorTest, extractionScanSpecMapKeyFilterThenMapKeys) {
+  // kMapKeyFilter followed by kMapKeys should set a filter on keys and then
+  // configure kKeys extraction on the remaining chain.
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  auto rowType = ROW({{"col", hiveType}});
+  auto scanSpec = makeScanSpec(
+      rowType,
+      /*outputSubfields=*/{},
+      /*subfieldFilters=*/{},
+      /*indexColumns=*/{},
+      /*dataColumns=*/nullptr,
+      /*partitionKeys=*/{},
+      /*infoColumns=*/{},
+      /*specialColumns=*/{},
+      /*disableStatsBasedFilterReorder=*/false,
+      pool_.get());
+
+  std::vector<NamedExtraction> extractions = {
+      {"keys",
+       {ExtractionPathElement::mapKeyFilter(std::vector<std::string>{"x", "y"}),
+        ExtractionPathElement::simple(ExtractionStep::kMapKeys)},
+       ARRAY(VARCHAR())}};
+
+  auto* colSpec = scanSpec->childByName("col");
+  ASSERT_NE(colSpec, nullptr);
+  configureExtractionScanSpec(hiveType, extractions, *colSpec, pool_.get());
+
+  // Filter should be set on keys.
+  auto* keysSpec = colSpec->childByName(ScanSpec::kMapKeysFieldName);
+  ASSERT_NE(keysSpec, nullptr);
+  ASSERT_NE(keysSpec->filter(), nullptr);
+  ASSERT_TRUE(keysSpec->filter()->testStringView(StringView("x")));
+  ASSERT_FALSE(keysSpec->filter()->testStringView(StringView("z")));
+
+  // After stripping kMapKeyFilter, remaining chain is [kMapKeys], so
+  // kKeys extraction should be set.
+  ASSERT_EQ(colSpec->extractionType(), ScanSpec::ExtractionType::kKeys);
+}
+
 } // namespace
 } // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/tests/HiveConnectorUtilTest.cpp b/velox/connectors/hive/tests/HiveConnectorUtilTest.cpp
index 7a0653ad22a..c7e22a8629f 100644
--- a/velox/connectors/hive/tests/HiveConnectorUtilTest.cpp
+++ b/velox/connectors/hive/tests/HiveConnectorUtilTest.cpp
@@ -16,10 +16,18 @@
 
 #include "velox/connectors/hive/HiveConnectorUtil.h"
 #include <gtest/gtest.h>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/io/IoStatistics.h"
 #include "velox/connectors/hive/HiveConfig.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
 #include "velox/connectors/hive/TableHandle.h"
+#include "velox/core/Expressions.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/expression/Expr.h"
+#include "velox/expression/ExprToSubfieldFilter.h"
+#include "velox/expression/FieldReference.h"
+#include "velox/parse/ExpressionsParser.h"
+#include "velox/parse/TypeResolver.h"
 
 #include "velox/dwio/dwrf/writer/Writer.h"
 
@@ -31,6 +39,24 @@ namespace facebook::velox::connector {
 
 using namespace dwio::common;
 
+namespace {
+// Unsupported types for createPointFilter and createRangeFilter with test
+// values.
+struct UnsupportedFilterType {
+  TypePtr type;
+  variant value;
+};
+
+const std::vector<UnsupportedFilterType> kUnsupportedFilterTypes = {
+    {TIMESTAMP(), variant(Timestamp(0, 0))},
+    {ARRAY(BIGINT()), variant::array({variant::create<TypeKind::BIGINT>(1)})},
+    {MAP(VARCHAR(), BIGINT()),
+     variant::map({{variant("key"), variant::create<TypeKind::BIGINT>(1)}})},
+    {ROW({{"a", BIGINT()}}),
+     variant::row({variant::create<TypeKind::BIGINT>(1)})},
+};
+} // namespace
+
 class HiveConnectorUtilTest : public exec::test::HiveConnectorTestBase {
  protected:
   static bool compareSerDeOptions(
@@ -43,6 +69,10 @@ class HiveConnectorUtilTest : public exec::test::HiveConnectorTestBase {
 
   std::shared_ptr<memory::MemoryPool> pool_ =
       memory::memoryManager()->addLeafPool();
+  std::shared_ptr<velox::io::IoStatistics> dataIoStats_ =
+      std::make_shared<velox::io::IoStatistics>();
+  std::shared_ptr<velox::io::IoStatistics> metadataIoStats_ =
+      std::make_shared<velox::io::IoStatistics>();
 };
 
 TEST_F(HiveConnectorUtilTest, configureReaderOptions) {
@@ -69,6 +99,8 @@ TEST_F(HiveConnectorUtilTest, configureReaderOptions) {
 
   // Dynamic parameters.
   dwio::common::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   FileFormat fileFormat{FileFormat::DWRF};
   std::unordered_map<std::string, std::string> tableParameters;
   std::unordered_map<std::string, std::string> serdeParameters;
@@ -78,10 +110,10 @@ TEST_F(HiveConnectorUtilTest, configureReaderOptions) {
     return std::make_shared<hive::HiveTableHandle>(
         "testConnectorId",
         "testTable",
-        false,
         common::SubfieldFilters{},
         nullptr,
         nullptr,
+        /*indexColumns=*/std::vector<std::string>{},
         tableParameters);
   };
 
@@ -103,11 +135,18 @@ TEST_F(HiveConnectorUtilTest, configureReaderOptions) {
     auto tableHandle = createTableHandle();
     auto split = createSplit();
     configureReaderOptions(
-        hiveConfig, connectorQueryCtx.get(), tableHandle, split, readerOptions);
+        hiveConfig,
+        connectorQueryCtx.get(),
+        tableHandle,
+        split,
+        split->serdeParameters,
+        readerOptions);
   };
 
   auto clearDynamicParameters = [&](FileFormat newFileFormat) {
     readerOptions = dwio::common::ReaderOptions(pool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
     fileFormat = newFileFormat;
     tableParameters.clear();
     serdeParameters.clear();
@@ -142,11 +181,12 @@ TEST_F(HiveConnectorUtilTest, configureReaderOptions) {
       readerOptions.fileColumnNamesReadAsLowerCase(),
       hiveConfig->isFileColumnNamesReadAsLowerCase(&sessionProperties));
   checkUseColumnNamesForColumnMapping();
-  EXPECT_EQ(
-      readerOptions.footerEstimatedSize(), hiveConfig->footerEstimatedSize());
   EXPECT_EQ(
       readerOptions.filePreloadThreshold(), hiveConfig->filePreloadThreshold());
   EXPECT_EQ(readerOptions.prefetchRowGroups(), hiveConfig->prefetchRowGroups());
+  EXPECT_EQ(
+      readerOptions.fileMetadataCacheEnabled(),
+      hiveConfig->fileMetadataCacheEnabled(&sessionProperties));
 
   // Modify field delimiter and change the file format.
   clearDynamicParameters(FileFormat::TEXT);
@@ -234,9 +274,10 @@ TEST_F(HiveConnectorUtilTest, configureReaderOptions) {
   customHiveConfigProps[hive::HiveConfig::kFileColumnNamesReadAsLowerCase] =
       "true";
   customHiveConfigProps[hive::HiveConfig::kOrcUseColumnNames] = "true";
-  customHiveConfigProps[hive::HiveConfig::kFooterEstimatedSize] = "1111";
   customHiveConfigProps[hive::HiveConfig::kFilePreloadThreshold] = "9999";
   customHiveConfigProps[hive::HiveConfig::kPrefetchRowGroups] = "10";
+  customHiveConfigProps[hive::HiveConfig::kFileMetadataCacheEnabled] = "true";
+  customHiveConfigProps[hive::HiveConfig::kOrcFooterSpeculativeIoSize] = "1111";
   hiveConfig = std::make_shared<hive::HiveConfig>(
       std::make_shared<config::ConfigBase>(std::move(customHiveConfigProps)));
   performConfigure();
@@ -252,10 +293,12 @@ TEST_F(HiveConnectorUtilTest, configureReaderOptions) {
       readerOptions.fileColumnNamesReadAsLowerCase(),
       hiveConfig->isFileColumnNamesReadAsLowerCase(&sessionProperties));
   EXPECT_EQ(
-      readerOptions.footerEstimatedSize(), hiveConfig->footerEstimatedSize());
+      readerOptions.footerSpeculativeIoSize(),
+      hiveConfig->orcFooterSpeculativeIoSize(&sessionProperties));
   EXPECT_EQ(
       readerOptions.filePreloadThreshold(), hiveConfig->filePreloadThreshold());
   EXPECT_EQ(readerOptions.prefetchRowGroups(), hiveConfig->prefetchRowGroups());
+  EXPECT_TRUE(readerOptions.fileMetadataCacheEnabled());
   clearDynamicParameters(FileFormat::ORC);
   performConfigure();
   checkUseColumnNamesForColumnMapping();
@@ -264,18 +307,210 @@ TEST_F(HiveConnectorUtilTest, configureReaderOptions) {
   checkUseColumnNamesForColumnMapping();
 }
 
+TEST_F(HiveConnectorUtilTest, footerSpeculativeIoSizeByFormat) {
+  config::ConfigBase sessionProperties{
+      std::unordered_map<std::string, std::string>{}};
+  auto connectorQueryCtx = std::make_unique<connector::ConnectorQueryCtx>(
+      pool_.get(),
+      pool_.get(),
+      &sessionProperties,
+      nullptr,
+      common::PrefixSortConfig(),
+      nullptr,
+      nullptr,
+      "query.HiveConnectorUtilTest",
+      "task.HiveConnectorUtilTest",
+      "planNodeId.HiveConnectorUtilTest",
+      0,
+      "");
+
+  std::unordered_map<std::string, std::string> customHiveConfigProps;
+  customHiveConfigProps[hive::HiveConfig::kOrcFooterSpeculativeIoSize] = "1111";
+  customHiveConfigProps[hive::HiveConfig::kParquetFooterSpeculativeIoSize] =
+      "2222";
+  customHiveConfigProps[hive::HiveConfig::kNimbleFooterSpeculativeIoSize] =
+      "3333";
+  auto hiveConfig = std::make_shared<hive::HiveConfig>(
+      std::make_shared<config::ConfigBase>(std::move(customHiveConfigProps)));
+
+  const std::unordered_map<std::string, std::optional<std::string>>
+      partitionKeys;
+  const std::unordered_map<std::string, std::string> customSplitInfo;
+  std::unordered_map<std::string, std::string> serdeParameters;
+
+  auto createTableHandle = []() {
+    return std::make_shared<hive::HiveTableHandle>(
+        "testConnectorId",
+        "testTable",
+        common::SubfieldFilters{},
+        nullptr,
+        nullptr,
+        std::vector<std::string>{},
+        std::unordered_map<std::string, std::string>{});
+  };
+
+  auto createSplit = [&](FileFormat format) {
+    return std::make_shared<hive::HiveConnectorSplit>(
+        "testConnectorId",
+        "/tmp/",
+        format,
+        0UL,
+        std::numeric_limits<uint64_t>::max(),
+        partitionKeys,
+        std::nullopt,
+        customSplitInfo,
+        nullptr,
+        serdeParameters);
+  };
+
+  // Test ORC format.
+  {
+    dwio::common::ReaderOptions readerOptions(pool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
+    auto tableHandle = createTableHandle();
+    auto split = createSplit(FileFormat::ORC);
+    configureReaderOptions(
+        hiveConfig,
+        connectorQueryCtx.get(),
+        tableHandle,
+        split,
+        split->serdeParameters,
+        readerOptions);
+    EXPECT_EQ(
+        readerOptions.footerSpeculativeIoSize(),
+        hiveConfig->orcFooterSpeculativeIoSize(&sessionProperties));
+    EXPECT_EQ(readerOptions.footerSpeculativeIoSize(), 1111);
+  }
+
+  // Test DWRF format (uses ORC config).
+  {
+    dwio::common::ReaderOptions readerOptions(pool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
+    auto tableHandle = createTableHandle();
+    auto split = createSplit(FileFormat::DWRF);
+    configureReaderOptions(
+        hiveConfig,
+        connectorQueryCtx.get(),
+        tableHandle,
+        split,
+        split->serdeParameters,
+        readerOptions);
+    EXPECT_EQ(
+        readerOptions.footerSpeculativeIoSize(),
+        hiveConfig->orcFooterSpeculativeIoSize(&sessionProperties));
+    EXPECT_EQ(readerOptions.footerSpeculativeIoSize(), 1111);
+  }
+
+  // Test Parquet format.
+  {
+    dwio::common::ReaderOptions readerOptions(pool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
+    auto tableHandle = createTableHandle();
+    auto split = createSplit(FileFormat::PARQUET);
+    configureReaderOptions(
+        hiveConfig,
+        connectorQueryCtx.get(),
+        tableHandle,
+        split,
+        split->serdeParameters,
+        readerOptions);
+    EXPECT_EQ(
+        readerOptions.footerSpeculativeIoSize(),
+        hiveConfig->parquetFooterSpeculativeIoSize(&sessionProperties));
+    EXPECT_EQ(readerOptions.footerSpeculativeIoSize(), 2222);
+  }
+
+  // Test Nimble format.
+  {
+    dwio::common::ReaderOptions readerOptions(pool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
+    auto tableHandle = createTableHandle();
+    auto split = createSplit(FileFormat::NIMBLE);
+    configureReaderOptions(
+        hiveConfig,
+        connectorQueryCtx.get(),
+        tableHandle,
+        split,
+        split->serdeParameters,
+        readerOptions);
+    EXPECT_EQ(
+        readerOptions.footerSpeculativeIoSize(),
+        hiveConfig->nimbleFooterSpeculativeIoSize(&sessionProperties));
+    EXPECT_EQ(readerOptions.footerSpeculativeIoSize(), 3333);
+  }
+}
+
+TEST_F(HiveConnectorUtilTest, fileMetadataCacheEnabledSessionOverride) {
+  // Verify default is off.
+  dwio::common::ReaderOptions defaultOptions(pool_.get());
+  defaultOptions.setDataIoStats(dataIoStats_);
+  defaultOptions.setMetadataIoStats(metadataIoStats_);
+  ASSERT_FALSE(defaultOptions.fileMetadataCacheEnabled());
+
+  for (bool enabled : {true, false}) {
+    SCOPED_TRACE(fmt::format("fileMetadataCacheEnabled={}", enabled));
+
+    config::ConfigBase sessionProperties(
+        std::unordered_map<std::string, std::string>{
+            {hive::HiveConfig::kFileMetadataCacheEnabledSession,
+             enabled ? "true" : "false"}});
+    auto connectorQueryCtx = std::make_unique<connector::ConnectorQueryCtx>(
+        pool_.get(),
+        pool_.get(),
+        &sessionProperties,
+        nullptr,
+        common::PrefixSortConfig(),
+        nullptr,
+        nullptr,
+        "query.HiveConnectorUtilTest",
+        "task.HiveConnectorUtilTest",
+        "planNodeId.HiveConnectorUtilTest",
+        0,
+        "");
+    auto hiveConfig =
+        std::make_shared<hive::HiveConfig>(std::make_shared<config::ConfigBase>(
+            std::unordered_map<std::string, std::string>()));
+    dwio::common::ReaderOptions readerOptions(pool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
+
+    auto tableHandle = std::make_shared<hive::HiveTableHandle>(
+        "testConnectorId",
+        "testTable",
+        common::SubfieldFilters{},
+        nullptr,
+        nullptr,
+        std::vector<std::string>{},
+        std::unordered_map<std::string, std::string>{});
+    auto split = std::make_shared<hive::HiveConnectorSplit>(
+        "testConnectorId", "/tmp/", FileFormat::DWRF);
+    configureReaderOptions(
+        hiveConfig,
+        connectorQueryCtx.get(),
+        tableHandle,
+        split,
+        split->serdeParameters,
+        readerOptions);
+    ASSERT_EQ(readerOptions.fileMetadataCacheEnabled(), enabled);
+  }
+}
+
 TEST_F(HiveConnectorUtilTest, cacheRetention) {
   struct {
     bool splitCacheable;
-    bool expectedNoCacheRetention;
+    bool expectedCacheable;
 
     std::string debugString() const {
       return fmt::format(
-          "splitCacheable {}, expectedNoCacheRetention {}",
+          "splitCacheable {}, expectedCacheable {}",
           splitCacheable,
-          expectedNoCacheRetention);
+          expectedCacheable);
     }
-  } testSettings[] = {{false, true}, {true, false}};
+  } testSettings[] = {{false, false}, {true, true}};
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
@@ -300,14 +535,16 @@ TEST_F(HiveConnectorUtilTest, cacheRetention) {
         "");
 
     dwio::common::ReaderOptions readerOptions(pool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
 
     auto tableHandle = std::make_shared<hive::HiveTableHandle>(
         "testConnectorId",
         "testTable",
-        false,
         common::SubfieldFilters{},
         nullptr,
         nullptr,
+        /*indexColumns=*/std::vector<std::string>{},
         std::unordered_map<std::string, std::string>{});
 
     auto hiveSplit = std::make_shared<hive::HiveConnectorSplit>(
@@ -329,10 +566,10 @@ TEST_F(HiveConnectorUtilTest, cacheRetention) {
         connectorQueryCtx.get(),
         tableHandle,
         hiveSplit,
+        hiveSplit->serdeParameters,
         readerOptions);
 
-    ASSERT_EQ(
-        readerOptions.noCacheRetention(), testData.expectedNoCacheRetention);
+    ASSERT_EQ(readerOptions.cacheable(), testData.expectedCacheable);
   }
 }
 
@@ -349,9 +586,11 @@ TEST_F(HiveConnectorUtilTest, configureSstRowReaderOptions) {
       /*scanSpec=*/nullptr,
       /*metadataFilter=*/nullptr,
       /*rowType=*/nullptr,
-      /*hiveSplit=*/hiveSplit,
-      /*hiveConfig=*/nullptr,
+      /*fileSplit=*/hiveSplit,
+      /*serdeParameters=*/hiveSplit->serdeParameters,
+      /*fileConfig=*/nullptr,
       /*sessionProperties=*/nullptr,
+      /*ioExecutor=*/nullptr,
       /*rowReaderOptions=*/rowReaderOpts);
 
   EXPECT_EQ(rowReaderOpts.serdeParameters(), hiveSplit->serdeParameters);
@@ -374,9 +613,11 @@ TEST_F(HiveConnectorUtilTest, configureRowReaderOptionsFromConfig) {
         /*scanSpec=*/nullptr,
         /*metadataFilter=*/nullptr,
         /*rowType=*/nullptr,
-        /*hiveSplit=*/hiveSplit,
-        /*hiveConfig=*/hiveConfig,
+        /*fileSplit=*/hiveSplit,
+        /*serdeParameters=*/{},
+        /*fileConfig=*/hiveConfig,
         /*sessionProperties=*/&sessionProperties,
+        /*ioExecutor=*/nullptr,
         /*rowReaderOptions=*/rowReaderOpts);
 
     EXPECT_FALSE(rowReaderOpts.preserveFlatMapsInMemory());
@@ -399,9 +640,11 @@ TEST_F(HiveConnectorUtilTest, configureRowReaderOptionsFromConfig) {
         /*scanSpec=*/nullptr,
         /*metadataFilter=*/nullptr,
         /*rowType=*/nullptr,
-        /*hiveSplit=*/hiveSplit,
-        /*hiveConfig=*/hiveConfig,
+        /*fileSplit=*/hiveSplit,
+        /*serdeParameters=*/{},
+        /*fileConfig=*/hiveConfig,
         /*sessionProperties=*/&sessionProperties,
+        /*ioExecutor=*/nullptr,
         /*rowReaderOptions=*/rowReaderOpts);
 
     EXPECT_TRUE(rowReaderOpts.preserveFlatMapsInMemory());
@@ -425,9 +668,11 @@ TEST_F(HiveConnectorUtilTest, configureRowReaderOptionsFromConfig) {
         /*scanSpec=*/nullptr,
         /*metadataFilter=*/nullptr,
         /*rowType=*/nullptr,
-        /*hiveSplit=*/hiveSplit,
-        /*hiveConfig=*/hiveConfig,
+        /*fileSplit=*/hiveSplit,
+        /*serdeParameters=*/{},
+        /*fileConfig=*/hiveConfig,
         /*sessionProperties=*/&sessionProperties,
+        /*ioExecutor=*/nullptr,
         /*rowReaderOptions=*/rowReaderOpts);
 
     EXPECT_TRUE(rowReaderOpts.preserveFlatMapsInMemory());
@@ -452,13 +697,466 @@ TEST_F(HiveConnectorUtilTest, configureRowReaderOptionsFromConfig) {
         /*scanSpec=*/nullptr,
         /*metadataFilter=*/nullptr,
         /*rowType=*/nullptr,
-        /*hiveSplit=*/hiveSplit,
-        /*hiveConfig=*/hiveConfig,
+        /*fileSplit=*/hiveSplit,
+        /*serdeParameters=*/{},
+        /*fileConfig=*/hiveConfig,
         /*sessionProperties=*/&sessionProperties,
+        /*ioExecutor=*/nullptr,
         /*rowReaderOptions=*/rowReaderOpts);
 
     EXPECT_TRUE(rowReaderOpts.preserveFlatMapsInMemory());
   }
 }
 
+TEST_F(HiveConnectorUtilTest, checkColumnHandleConsistent) {
+  // Create two consistent column handles
+  auto handle1 = std::make_shared<hive::HiveColumnHandle>(
+      "col1", hive::FileColumnHandle::ColumnType::kRegular, BIGINT(), BIGINT());
+  auto handle2 = std::make_shared<hive::HiveColumnHandle>(
+      "col1", hive::FileColumnHandle::ColumnType::kRegular, BIGINT(), BIGINT());
+
+  // Should not throw for consistent handles
+  EXPECT_NO_THROW(hive::checkColumnHandleConsistent(*handle1, *handle2));
+
+  // Test inconsistent column type
+  auto handlePartition = std::make_shared<hive::HiveColumnHandle>(
+      "col1",
+      hive::FileColumnHandle::ColumnType::kPartitionKey,
+      BIGINT(),
+      BIGINT());
+  VELOX_ASSERT_THROW(
+      hive::checkColumnHandleConsistent(*handle1, *handlePartition),
+      "Inconsistent column handle type: col1, expected Regular, got PartitionKey");
+
+  // Test inconsistent data type
+  auto handleVarchar = std::make_shared<hive::HiveColumnHandle>(
+      "col1",
+      hive::FileColumnHandle::ColumnType::kRegular,
+      VARCHAR(),
+      VARCHAR());
+  VELOX_ASSERT_THROW(
+      hive::checkColumnHandleConsistent(*handle1, *handleVarchar),
+      "Inconsistent column handle data type: col1, expected BIGINT, got VARCHAR");
+}
+
+TEST_F(HiveConnectorUtilTest, makeScanSpecWithIndexColumns) {
+  // Data columns schema - all columns available in the file.
+  const auto dataColumns = ROW(
+      {{"a", BIGINT()},
+       {"b", VARCHAR()},
+       {"c", INTEGER()},
+       {"d", DOUBLE()},
+       {"e", ROW({{"x", INTEGER()}, {"y", VARCHAR()}})}});
+
+  struct TestCase {
+    std::string name;
+    RowTypePtr rowType;
+    folly::F14FastMap<std::string, std::vector<const common::Subfield*>>
+        outputSubfields;
+    std::function<common::SubfieldFilters()> makeSubfieldFilters;
+    std::vector<std::string> indexColumns;
+    std::vector<std::string> expectedColumns;
+    std::vector<std::string> unexpectedColumns;
+
+    std::string debugString() const {
+      return fmt::format(
+          "name: {}, indexColumns: [{}], expectedColumns: [{}], unexpectedColumns: [{}]",
+          name,
+          folly::join(", ", indexColumns),
+          folly::join(", ", expectedColumns),
+          folly::join(", ", unexpectedColumns));
+    }
+  };
+
+  // Subfields for nested column 'e'.
+  const common::Subfield subfieldEx("e.x");
+  const common::Subfield subfieldEy("e.y");
+
+  const std::vector<TestCase> testCases = {
+      {
+          "Index columns not in output projection",
+          ROW({"a", "b"}, {BIGINT(), VARCHAR()}),
+          /*outputSubfields=*/{},
+          /*makeSubfieldFilters=*/nullptr,
+          /*indexColumns=*/{"c", "d"},
+          /*expectedColumns=*/{"a", "b", "c", "d"},
+          /*unexpectedColumns=*/{"e"},
+      },
+      {
+          "Index column already in output projection",
+          ROW({"a", "b"}, {BIGINT(), VARCHAR()}),
+          /*outputSubfields=*/{},
+          /*makeSubfieldFilters=*/nullptr,
+          /*indexColumns=*/{"a", "c"},
+          /*expectedColumns=*/{"a", "b", "c"},
+          /*unexpectedColumns=*/{"d", "e"},
+      },
+      {
+          "Empty index columns",
+          ROW({"a", "b"}, {BIGINT(), VARCHAR()}),
+          /*outputSubfields=*/{},
+          /*makeSubfieldFilters=*/nullptr,
+          /*indexColumns=*/{},
+          /*expectedColumns=*/{"a", "b"},
+          /*unexpectedColumns=*/{"c", "d", "e"},
+      },
+      {
+          "Output subfield without index columns",
+          ROW({"e"}, {ROW({{"x", INTEGER()}, {"y", VARCHAR()}})}),
+          /*outputSubfields=*/{{"e", {&subfieldEx}}},
+          /*makeSubfieldFilters=*/nullptr,
+          /*indexColumns=*/{},
+          /*expectedColumns=*/{"e"},
+          /*unexpectedColumns=*/{"a", "b", "c", "d"},
+      },
+      {
+          "Output subfield with different index column",
+          ROW({"e"}, {ROW({{"x", INTEGER()}, {"y", VARCHAR()}})}),
+          /*outputSubfields=*/{{"e", {&subfieldEx}}},
+          /*makeSubfieldFilters=*/nullptr,
+          /*indexColumns=*/{"c"},
+          /*expectedColumns=*/{"e", "c"},
+          /*unexpectedColumns=*/{"a", "b", "d"},
+      },
+      {
+          "Output subfield with same parent as index column",
+          ROW({"a", "e"},
+              {BIGINT(), ROW({{"x", INTEGER()}, {"y", VARCHAR()}})}),
+          /*outputSubfields=*/{{"e", {&subfieldEx}}},
+          /*makeSubfieldFilters=*/nullptr,
+          /*indexColumns=*/{"a", "e"},
+          /*expectedColumns=*/{"a", "e"},
+          /*unexpectedColumns=*/{"b", "c", "d"},
+      },
+      {
+          "Subfield filter without index column",
+          ROW({"a", "b"}, {BIGINT(), VARCHAR()}),
+          /*outputSubfields=*/{},
+          /*makeSubfieldFilters=*/
+          []() {
+            common::SubfieldFilters filters;
+            filters.emplace(
+                common::Subfield("c"), exec::greaterThanOrEqual(10));
+            return filters;
+          },
+          /*indexColumns=*/{"d"},
+          /*expectedColumns=*/{"a", "b", "c", "d"},
+          /*unexpectedColumns=*/{"e"},
+      },
+      {
+          "Subfield filter without index column",
+          ROW({"a", "b"}, {BIGINT(), VARCHAR()}),
+          /*outputSubfields=*/{},
+          /*makeSubfieldFilters=*/
+          []() {
+            common::SubfieldFilters filters;
+            filters.emplace(
+                common::Subfield("c"), exec::greaterThanOrEqual(10));
+            return filters;
+          },
+          /*indexColumns=*/{"c"},
+          /*expectedColumns=*/{"a", "b", "c"},
+          /*unexpectedColumns=*/{"e"},
+      },
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+
+    common::SubfieldFilters subfieldFilters;
+    if (testCase.makeSubfieldFilters) {
+      subfieldFilters = testCase.makeSubfieldFilters();
+    }
+
+    auto scanSpec = hive::makeScanSpec(
+        testCase.rowType,
+        testCase.outputSubfields,
+        subfieldFilters,
+        testCase.indexColumns,
+        dataColumns,
+        /*partitionKeys=*/{},
+        /*infoColumns=*/{},
+        /*specialColumns=*/{},
+        /*disableStatsBasedFilterReorder=*/false,
+        pool_.get());
+
+    for (const auto& col : testCase.expectedColumns) {
+      EXPECT_NE(scanSpec->childByName(col), nullptr)
+          << "Expected column " << col << " to be in scan spec";
+    }
+    for (const auto& col : testCase.unexpectedColumns) {
+      EXPECT_EQ(scanSpec->childByName(col), nullptr)
+          << "Unexpected column " << col << " should not be in scan spec";
+    }
+  }
+}
+
+TEST_F(HiveConnectorUtilTest, makeScanSpecWithIndexColumnsError) {
+  // Test that makeScanSpec throws when index columns are set but dataColumns
+  // is null.
+  const auto rowType = ROW({"a", "b"}, {BIGINT(), VARCHAR()});
+
+  VELOX_ASSERT_THROW(
+      hive::makeScanSpec(
+          rowType,
+          /*outputSubfields=*/{},
+          /*subfieldFilters=*/{},
+          /*indexColumns=*/{"c"},
+          /*dataColumns=*/nullptr,
+          /*partitionKeys=*/{},
+          /*infoColumns=*/{},
+          /*specialColumns=*/{},
+          /*disableStatsBasedFilterReorder=*/false,
+          pool_.get()),
+      "");
+}
+
+TEST_F(HiveConnectorUtilTest, shouldEagerlyMaterialize) {
+  auto queryCtx = core::QueryCtx::create();
+  auto execCtx = std::make_unique<core::ExecCtx>(pool_.get(), queryCtx.get());
+
+  auto compileExpression = [&](const std::string& expr,
+                               const RowTypePtr& rowType) {
+    auto untyped = parse::DuckSqlExpressionsParser().parseExpr(expr);
+    auto typedExpr =
+        core::Expressions::inferTypes(untyped, rowType, pool_.get());
+    std::vector<core::TypedExprPtr> expressions = {typedExpr};
+    return std::make_unique<exec::ExprSet>(
+        std::move(expressions), execCtx.get());
+  };
+
+  const auto rowType = ROW({"a", "b", "c"}, {BIGINT(), BIGINT(), BIGINT()});
+
+  // Test 1: OR expression doesn't evaluate arguments on non-increasing
+  // selection, so should return true (eager materialization needed).
+  {
+    auto exprSet = compileExpression("a > 10 OR b > 20", rowType);
+    auto& expr = *exprSet->exprs().front();
+    for (const auto& field : expr.distinctFields()) {
+      EXPECT_TRUE(hive::shouldEagerlyMaterialize(expr, *field));
+    }
+  }
+
+  // Test 2: AND expression evaluates arguments on non-increasing selection.
+  // Field used in simple conjunct (no conditionals) should not be eagerly
+  // materialized.
+  {
+    auto exprSet = compileExpression("a > 10 AND b > 20", rowType);
+    auto& expr = *exprSet->exprs().front();
+    for (const auto& field : expr.distinctFields()) {
+      EXPECT_FALSE(hive::shouldEagerlyMaterialize(expr, *field));
+    }
+  }
+
+  // Test 3: AND expression with field used in IF conditional.
+  // Field used in input with conditionals should be eagerly materialized.
+  {
+    auto exprSet =
+        compileExpression("a > 10 AND if(b > 20, c < 30, c > 5)", rowType);
+    auto& expr = *exprSet->exprs().front();
+    for (const auto& field : expr.distinctFields()) {
+      if (field->field() == "c" || field->field() == "b") {
+        EXPECT_TRUE(hive::shouldEagerlyMaterialize(expr, *field));
+      } else {
+        EXPECT_FALSE(hive::shouldEagerlyMaterialize(expr, *field));
+      }
+    }
+  }
+
+  // Test 4: AND expression where field is used in simple conjunct,
+  // not in conditional.
+  {
+    auto exprSet =
+        compileExpression("a > 10 OR if(b > 20, c < 30, c < 5)", rowType);
+    auto& expr = *exprSet->exprs().front();
+    // Find field 'a' which is used in simple comparison, not in conditional.
+    for (const auto& field : expr.distinctFields()) {
+      EXPECT_TRUE(hive::shouldEagerlyMaterialize(expr, *field));
+    }
+  }
+}
+
+TEST_F(HiveConnectorUtilTest, createPointFilter) {
+  // Test BIGINT point filter.
+  {
+    auto filter = hive::createPointFilter(
+        BIGINT(), variant::create<TypeKind::BIGINT>(42));
+    ASSERT_NE(filter, nullptr);
+    EXPECT_TRUE(filter->testInt64(42));
+    EXPECT_FALSE(filter->testInt64(41));
+    EXPECT_FALSE(filter->testInt64(43));
+    EXPECT_FALSE(filter->testNull());
+  }
+
+  // Test INTEGER point filter.
+  {
+    auto filter = hive::createPointFilter(INTEGER(), variant(100));
+    ASSERT_NE(filter, nullptr);
+    EXPECT_TRUE(filter->testInt64(100));
+    EXPECT_FALSE(filter->testInt64(99));
+    EXPECT_FALSE(filter->testNull());
+  }
+
+  // Test DOUBLE point filter.
+  {
+    auto filter = hive::createPointFilter(DOUBLE(), variant(3.14));
+    ASSERT_NE(filter, nullptr);
+    EXPECT_TRUE(filter->testDouble(3.14));
+    EXPECT_FALSE(filter->testDouble(3.15));
+    EXPECT_FALSE(filter->testNull());
+  }
+
+  // Test VARCHAR point filter.
+  {
+    auto filter = hive::createPointFilter(VARCHAR(), variant("hello"));
+    ASSERT_NE(filter, nullptr);
+    EXPECT_TRUE(filter->testBytes("hello", 5));
+    EXPECT_FALSE(filter->testBytes("world", 5));
+    EXPECT_FALSE(filter->testNull());
+  }
+
+  // Test BOOLEAN point filter.
+  {
+    auto filter = hive::createPointFilter(BOOLEAN(), variant(true));
+    ASSERT_NE(filter, nullptr);
+    EXPECT_TRUE(filter->testBool(true));
+    EXPECT_FALSE(filter->testBool(false));
+    EXPECT_FALSE(filter->testNull());
+  }
+
+  // Test null value throws.
+  {
+    VELOX_ASSERT_THROW(
+        hive::createPointFilter(BIGINT(), variant::null(TypeKind::BIGINT)),
+        "Value cannot be null");
+  }
+
+  // Test unsupported types throw.
+  for (const auto& unsupported : kUnsupportedFilterTypes) {
+    SCOPED_TRACE(
+        fmt::format("Unsupported type: {}", unsupported.type->toString()));
+    VELOX_ASSERT_THROW(
+        hive::createPointFilter(unsupported.type, unsupported.value), "");
+  }
+}
+
+TEST_F(HiveConnectorUtilTest, createRangeFilter) {
+  // Test BIGINT range filter.
+  {
+    auto filter = hive::createRangeFilter(
+        BIGINT(),
+        variant::create<TypeKind::BIGINT>(10),
+        variant::create<TypeKind::BIGINT>(20));
+    ASSERT_NE(filter, nullptr);
+    EXPECT_TRUE(filter->testInt64(10));
+    EXPECT_TRUE(filter->testInt64(15));
+    EXPECT_TRUE(filter->testInt64(20));
+    EXPECT_FALSE(filter->testInt64(9));
+    EXPECT_FALSE(filter->testInt64(21));
+    EXPECT_FALSE(filter->testNull());
+  }
+
+  // Test INTEGER range filter.
+  {
+    auto filter = hive::createRangeFilter(INTEGER(), variant(0), variant(100));
+    ASSERT_NE(filter, nullptr);
+    EXPECT_TRUE(filter->testInt64(0));
+    EXPECT_TRUE(filter->testInt64(50));
+    EXPECT_TRUE(filter->testInt64(100));
+    EXPECT_FALSE(filter->testInt64(-1));
+    EXPECT_FALSE(filter->testInt64(101));
+  }
+
+  // Test DOUBLE range filter.
+  {
+    auto filter = hive::createRangeFilter(DOUBLE(), variant(1.0), variant(2.0));
+    ASSERT_NE(filter, nullptr);
+    EXPECT_TRUE(filter->testDouble(1.0));
+    EXPECT_TRUE(filter->testDouble(1.5));
+    EXPECT_TRUE(filter->testDouble(2.0));
+    EXPECT_FALSE(filter->testDouble(0.9));
+    EXPECT_FALSE(filter->testDouble(2.1));
+  }
+
+  // Test VARCHAR range filter.
+  {
+    auto filter =
+        hive::createRangeFilter(VARCHAR(), variant("apple"), variant("banana"));
+    ASSERT_NE(filter, nullptr);
+    EXPECT_TRUE(filter->testBytes("apple", 5));
+    EXPECT_TRUE(filter->testBytes("ball", 4));
+    EXPECT_TRUE(filter->testBytes("banana", 6));
+    EXPECT_FALSE(filter->testBytes("aaa", 3));
+    EXPECT_FALSE(filter->testBytes("cherry", 6));
+  }
+
+  // Test lower bound only (upper unbounded) - BIGINT.
+  {
+    auto filter = hive::createRangeFilter(
+        BIGINT(),
+        variant::create<TypeKind::BIGINT>(10),
+        variant::null(TypeKind::BIGINT));
+    ASSERT_NE(filter, nullptr);
+    EXPECT_TRUE(filter->testInt64(10));
+    EXPECT_TRUE(filter->testInt64(100));
+    EXPECT_TRUE(filter->testInt64(std::numeric_limits<int64_t>::max()));
+    EXPECT_FALSE(filter->testInt64(9));
+    EXPECT_FALSE(filter->testNull());
+  }
+
+  // Test upper bound only (lower unbounded) - BIGINT.
+  {
+    auto filter = hive::createRangeFilter(
+        BIGINT(),
+        variant::null(TypeKind::BIGINT),
+        variant::create<TypeKind::BIGINT>(20));
+    ASSERT_NE(filter, nullptr);
+    EXPECT_TRUE(filter->testInt64(20));
+    EXPECT_TRUE(filter->testInt64(0));
+    EXPECT_TRUE(filter->testInt64(std::numeric_limits<int64_t>::min()));
+    EXPECT_FALSE(filter->testInt64(21));
+    EXPECT_FALSE(filter->testNull());
+  }
+
+  // Test lower bound only - DOUBLE.
+  {
+    auto filter = hive::createRangeFilter(
+        DOUBLE(), variant(1.5), variant::null(TypeKind::DOUBLE));
+    ASSERT_NE(filter, nullptr);
+    EXPECT_TRUE(filter->testDouble(1.5));
+    EXPECT_TRUE(filter->testDouble(100.0));
+    EXPECT_FALSE(filter->testDouble(1.0));
+  }
+
+  // Test upper bound only - VARCHAR.
+  {
+    auto filter = hive::createRangeFilter(
+        VARCHAR(), variant::null(TypeKind::VARCHAR), variant("banana"));
+    ASSERT_NE(filter, nullptr);
+    EXPECT_TRUE(filter->testBytes("banana", 6));
+    EXPECT_TRUE(filter->testBytes("aaa", 3));
+    EXPECT_FALSE(filter->testBytes("cherry", 6));
+  }
+
+  // Test both bounds null throws.
+  {
+    VELOX_ASSERT_THROW(
+        hive::createRangeFilter(
+            BIGINT(),
+            variant::null(TypeKind::BIGINT),
+            variant::null(TypeKind::BIGINT)),
+        "At least one of lower or upper bound must be set");
+  }
+
+  // Test unsupported types throw.
+  for (const auto& unsupported : kUnsupportedFilterTypes) {
+    SCOPED_TRACE(
+        fmt::format("Unsupported type: {}", unsupported.type->toString()));
+    VELOX_ASSERT_THROW(
+        hive::createRangeFilter(
+            unsupported.type, unsupported.value, unsupported.value),
+        "");
+  }
+}
+
 } // namespace facebook::velox::connector
diff --git a/velox/connectors/hive/tests/HiveDataSinkTest.cpp b/velox/connectors/hive/tests/HiveDataSinkTest.cpp
index 4e3f0a19f4e..0fd25a9805b 100644
--- a/velox/connectors/hive/tests/HiveDataSinkTest.cpp
+++ b/velox/connectors/hive/tests/HiveDataSinkTest.cpp
@@ -16,14 +16,18 @@
 
 #include <gtest/gtest.h>
 #include "velox/common/caching/AsyncDataCache.h"
+#include "velox/common/io/IoStatistics.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 
 #include <folly/init/Init.h>
+#include <folly/system/HardwareConcurrency.h>
 #include <re2/re2.h>
 #include "velox/common/base/Fs.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/testutil/TestValue.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/hive/HiveConnector.h"
+#include "velox/connectors/hive/HiveDataSink.h"
 #include "velox/dwio/common/BufferedInput.h"
 #include "velox/dwio/common/Options.h"
 #include "velox/dwio/dwrf/reader/DwrfReader.h"
@@ -37,8 +41,8 @@
 #include "velox/dwio/parquet/writer/Writer.h"
 #endif
 
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
 namespace facebook::velox::connector::hive {
@@ -73,7 +77,7 @@ class HiveDataSinkTest : public exec::test::HiveConnectorTestBase {
     setupMemoryPools();
 
     spillExecutor_ = std::make_unique<folly::IOThreadPoolExecutor>(
-        std::thread::hardware_concurrency());
+        folly::available_concurrency());
   }
 
   void TearDown() override {
@@ -113,7 +117,8 @@ class HiveDataSinkTest : public exec::test::HiveConnectorTestBase {
         0,
         0,
         writerFlushThreshold,
-        "none");
+        "none",
+        0);
   }
 
   void setupMemoryPools() {
@@ -165,7 +170,7 @@ class HiveDataSinkTest : public exec::test::HiveConnectorTestBase {
             connector::hive::LocationHandle::TableType::kNew),
         fileFormat,
         CompressionKind::CompressionKind_ZSTD,
-        {},
+        {}, // serdeParameters
         writerOptions,
         ensureFiles);
   }
@@ -205,7 +210,7 @@ class HiveDataSinkTest : public exec::test::HiveConnectorTestBase {
     return files;
   }
 
-  void verifyWrittenData(const std::string& dirPath, int32_t numFiles = 1) {
+  void verifyWrittenData(const std::string& dirPath, uint32_t numFiles = 1) {
     const std::vector<std::string> filePaths = listFiles(dirPath);
     ASSERT_EQ(filePaths.size(), numFiles);
     std::vector<std::shared_ptr<connector::ConnectorSplit>> splits;
@@ -239,6 +244,10 @@ class HiveDataSinkTest : public exec::test::HiveConnectorTestBase {
       std::make_shared<HiveConfig>(std::make_shared<config::ConfigBase>(
           std::unordered_map<std::string, std::string>()));
   std::unique_ptr<folly::IOThreadPoolExecutor> spillExecutor_;
+  std::shared_ptr<velox::io::IoStatistics> dataIoStats_ =
+      std::make_shared<velox::io::IoStatistics>();
+  std::shared_ptr<velox::io::IoStatistics> metadataIoStats_ =
+      std::make_shared<velox::io::IoStatistics>();
 };
 
 TEST_F(HiveDataSinkTest, hiveSortingColumn) {
@@ -616,7 +625,7 @@ TEST_F(HiveDataSinkTest, close) {
     const auto partitions = dataSink->close();
     // Can't append after close.
     VELOX_ASSERT_THROW(
-        dataSink->appendData(vectors.back()), "Hive data sink is not running");
+        dataSink->appendData(vectors.back()), "File data sink is not running");
     VELOX_ASSERT_THROW(
         dataSink->close(), "Unexpected state transition from CLOSED to CLOSED");
     VELOX_ASSERT_THROW(
@@ -664,7 +673,7 @@ TEST_F(HiveDataSinkTest, abort) {
         "Unexpected state transition from ABORTED to ABORTED");
     // Can't append after abort.
     VELOX_ASSERT_THROW(
-        dataSink->appendData(vectors.back()), "Hive data sink is not running");
+        dataSink->appendData(vectors.back()), "File data sink is not running");
   }
 }
 
@@ -739,7 +748,7 @@ DEBUG_ONLY_TEST_F(HiveDataSinkTest, memoryReclaim) {
     std::shared_ptr<TempDirectoryPath> spillDirectory;
     std::unique_ptr<SpillConfig> spillConfig;
     if (testData.writerSpillEnabled) {
-      spillDirectory = exec::test::TempDirectoryPath::create();
+      spillDirectory = TempDirectoryPath::create();
       spillConfig = getSpillConfig(
           spillDirectory->getPath(), testData.writerFlushThreshold);
       auto connectorQueryCtx = std::make_unique<connector::ConnectorQueryCtx>(
@@ -881,7 +890,7 @@ TEST_F(HiveDataSinkTest, memoryReclaimAfterClose) {
     std::shared_ptr<TempDirectoryPath> spillDirectory;
     std::unique_ptr<SpillConfig> spillConfig;
     if (testData.writerSpillEnabled) {
-      spillDirectory = exec::test::TempDirectoryPath::create();
+      spillDirectory = TempDirectoryPath::create();
       spillConfig = getSpillConfig(spillDirectory->getPath(), 0);
       auto connectorQueryCtx = std::make_unique<connector::ConnectorQueryCtx>(
           opPool_.get(),
@@ -1017,7 +1026,7 @@ TEST_F(HiveDataSinkTest, sortWriterMemoryReclaimDuringFinish) {
           std::make_shared<HiveSortingColumn>(
               "c1", core::SortOrder{false, false})});
   std::shared_ptr<TempDirectoryPath> spillDirectory =
-      exec::test::TempDirectoryPath::create();
+      TempDirectoryPath::create();
   std::unique_ptr<SpillConfig> spillConfig =
       getSpillConfig(spillDirectory->getPath(), 1);
   connectorSessionProperties_->set(
@@ -1084,7 +1093,7 @@ DEBUG_ONLY_TEST_F(HiveDataSinkTest, sortWriterFailureTest) {
           std::make_shared<HiveSortingColumn>(
               "c1", core::SortOrder{false, false})});
   const std::shared_ptr<TempDirectoryPath> spillDirectory =
-      exec::test::TempDirectoryPath::create();
+      TempDirectoryPath::create();
   std::unique_ptr<SpillConfig> spillConfig =
       getSpillConfig(spillDirectory->getPath(), 0);
   // Triggers the memory reservation in sort buffer.
@@ -1167,7 +1176,9 @@ TEST_F(HiveDataSinkTest, flushPolicyWithParquet) {
   ASSERT_TRUE(dataSink->finish());
   dataSink->close();
 
-  dwio::common::ReaderOptions readerOpts{pool_.get()};
+  dwio::common::ReaderOptions readerOpts(pool_.get());
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   const std::vector<std::string> filePaths =
       listFiles(outputDirectory->getPath());
   auto bufferedInput = std::make_unique<dwio::common::BufferedInput>(
@@ -1205,7 +1216,9 @@ TEST_F(HiveDataSinkTest, flushPolicyWithDWRF) {
   ASSERT_TRUE(dataSink->finish());
   dataSink->close();
 
-  dwio::common::ReaderOptions readerOpts{pool_.get()};
+  dwio::common::ReaderOptions readerOpts(pool_.get());
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   const std::vector<std::string> filePaths =
       listFiles(outputDirectory->getPath());
   auto bufferedInput = std::make_unique<dwio::common::BufferedInput>(
@@ -1288,7 +1301,7 @@ TEST_F(HiveDataSinkTest, ensureFilesUnsupported) {
           dwio::common::FileFormat::DWRF,
           CompressionKind::CompressionKind_ZSTD,
           {}, // serdeParameters
-          nullptr, // writeOptions
+          nullptr, // writerOptions
           true // ensureFiles
           ),
       "ensureFiles is not supported with partition keys in the data");
@@ -1311,12 +1324,532 @@ TEST_F(HiveDataSinkTest, ensureFilesUnsupported) {
           dwio::common::FileFormat::DWRF,
           CompressionKind::CompressionKind_ZSTD,
           {}, // serdeParameters
-          nullptr, // writeOptions
+          nullptr, // writerOptions
           true // ensureFiles
           ),
       "ensureFiles is not supported with bucketing");
 }
 
+TEST_F(HiveDataSinkTest, fileRotationBasic) {
+  const auto outputDirectory = TempDirectoryPath::create();
+
+  std::unordered_map<std::string, std::string> connectorConfig;
+  connectorConfig.emplace("max-target-file-size", "1MB");
+  connectorConfig.emplace("hive.orc.writer.stripe-max-size", "256KB");
+  connectorConfig_ = std::make_shared<HiveConfig>(
+      std::make_shared<config::ConfigBase>(std::move(connectorConfig)));
+
+  auto dataSink = createDataSink(rowType_, outputDirectory->getPath());
+
+  const int numBatches = 100;
+  const auto vectors = createVectors(1000, numBatches);
+  for (const auto& vector : vectors) {
+    dataSink->appendData(vector);
+  }
+
+  ASSERT_TRUE(dataSink->finish());
+  const auto partitions = dataSink->close();
+  const auto stats = dataSink->stats();
+
+  ASSERT_GT(stats.numWrittenFiles, 1);
+  ASSERT_EQ(partitions.size(), 1);
+
+  const auto partitionJson = folly::parseJson(partitions[0]);
+  ASSERT_TRUE(partitionJson.count(HiveCommitMessage::kFileWriteInfos) > 0);
+  const auto& fileWriteInfos =
+      partitionJson[HiveCommitMessage::kFileWriteInfos];
+  ASSERT_GT(fileWriteInfos.size(), 1);
+
+  for (size_t i = 0; i < fileWriteInfos.size(); ++i) {
+    ASSERT_TRUE(fileWriteInfos[i].count(HiveCommitMessage::kWriteFileName) > 0);
+    ASSERT_TRUE(
+        fileWriteInfos[i].count(HiveCommitMessage::kTargetFileName) > 0);
+    ASSERT_TRUE(fileWriteInfos[i].count(HiveCommitMessage::kFileSize) > 0);
+    ASSERT_GT(fileWriteInfos[i][HiveCommitMessage::kFileSize].asInt(), 0);
+  }
+  createDuckDbTable(vectors);
+  verifyWrittenData(outputDirectory->getPath(), stats.numWrittenFiles);
+}
+
+TEST_F(HiveDataSinkTest, fileRotationNoEmptyTrailingFile) {
+  const auto outputDirectory = TempDirectoryPath::create();
+
+  std::unordered_map<std::string, std::string> connectorConfig;
+  connectorConfig.emplace("max-target-file-size", "1KB");
+  connectorConfig.emplace("hive.orc.writer.stripe-max-size", "1KB");
+  connectorConfig_ = std::make_shared<HiveConfig>(
+      std::make_shared<config::ConfigBase>(std::move(connectorConfig)));
+
+  auto dataSink = createDataSink(rowType_, outputDirectory->getPath());
+
+  const auto vectors = createVectors(2000, 10);
+  for (const auto& vector : vectors) {
+    dataSink->appendData(vector);
+  }
+
+  ASSERT_TRUE(dataSink->finish());
+  const auto partitions = dataSink->close();
+  const auto stats = dataSink->stats();
+
+  ASSERT_EQ(partitions.size(), 1);
+  const auto partitionJson = folly::parseJson(partitions[0]);
+  ASSERT_TRUE(partitionJson.count(HiveCommitMessage::kFileWriteInfos) > 0);
+  const auto& fileWriteInfos =
+      partitionJson[HiveCommitMessage::kFileWriteInfos];
+  ASSERT_EQ(fileWriteInfos.size(), 5);
+
+  const auto filePaths = listFiles(outputDirectory->getPath());
+  ASSERT_EQ(filePaths.size(), fileWriteInfos.size());
+  ASSERT_EQ(filePaths.size(), stats.numWrittenFiles);
+  createDuckDbTable(vectors);
+  verifyWrittenData(outputDirectory->getPath(), stats.numWrittenFiles);
+}
+
+TEST_F(HiveDataSinkTest, fileRotationDisabledForBucketedTables) {
+  const auto outputDirectory = TempDirectoryPath::create();
+
+  std::unordered_map<std::string, std::string> connectorConfig;
+  connectorConfig.emplace("max-target-file-size", "100KB");
+  connectorConfig_ = std::make_shared<HiveConfig>(
+      std::make_shared<config::ConfigBase>(std::move(connectorConfig)));
+
+  const int32_t numBuckets = 2;
+  auto bucketProperty = std::make_shared<HiveBucketProperty>(
+      HiveBucketProperty::Kind::kHiveCompatible,
+      numBuckets,
+      std::vector<std::string>{"c0"},
+      std::vector<TypePtr>{BIGINT()},
+      std::vector<std::shared_ptr<const HiveSortingColumn>>{});
+
+  auto dataSink = createDataSink(
+      rowType_,
+      outputDirectory->getPath(),
+      dwio::common::FileFormat::DWRF,
+      {},
+      bucketProperty);
+
+  const int numBatches = 20;
+  const auto vectors = createVectors(500, numBatches);
+  for (const auto& vector : vectors) {
+    dataSink->appendData(vector);
+  }
+
+  ASSERT_TRUE(dataSink->finish());
+  const auto partitions = dataSink->close();
+  const auto stats = dataSink->stats();
+
+  ASSERT_EQ(stats.numWrittenFiles, numBuckets);
+  ASSERT_EQ(partitions.size(), numBuckets);
+
+  for (const auto& partition : partitions) {
+    const auto partitionJson = folly::parseJson(partition);
+    ASSERT_TRUE(partitionJson.count(HiveCommitMessage::kFileWriteInfos) > 0);
+    const auto& fileWriteInfos =
+        partitionJson[HiveCommitMessage::kFileWriteInfos];
+    ASSERT_EQ(fileWriteInfos.size(), 1);
+  }
+
+  createDuckDbTable(vectors);
+  verifyWrittenData(outputDirectory->getPath(), numBuckets);
+}
+
+TEST_F(HiveDataSinkTest, fileRotationDisabledByDefault) {
+  const auto outputDirectory = TempDirectoryPath::create();
+
+  // Don't set max-target-file-size (use default which is disabled)
+  auto dataSink = createDataSink(rowType_, outputDirectory->getPath());
+
+  // Write a lot of data
+  const int numBatches = 20;
+  const auto vectors = createVectors(500, numBatches);
+  for (const auto& vector : vectors) {
+    dataSink->appendData(vector);
+  }
+
+  ASSERT_TRUE(dataSink->finish());
+  const auto partitions = dataSink->close();
+  const auto stats = dataSink->stats();
+
+  // Should have exactly 1 file (no rotation when disabled)
+  ASSERT_EQ(stats.numWrittenFiles, 1)
+      << "Without maxTargetFileSize, should create exactly 1 file";
+  ASSERT_GT(stats.numWrittenBytes, 0);
+  ASSERT_EQ(partitions.size(), 1);
+
+  // Verify partition update has correct file info
+  const auto partitionJson = folly::parseJson(partitions[0]);
+  ASSERT_TRUE(partitionJson.count(HiveCommitMessage::kFileWriteInfos) > 0);
+  const auto& fileWriteInfos =
+      partitionJson[HiveCommitMessage::kFileWriteInfos];
+  ASSERT_EQ(fileWriteInfos.size(), 1)
+      << "Should have exactly 1 file entry when rotation disabled";
+
+  // Verify file info fields
+  const auto& fileInfo = fileWriteInfos[0];
+  ASSERT_TRUE(fileInfo.count(HiveCommitMessage::kWriteFileName) > 0);
+  ASSERT_TRUE(fileInfo.count(HiveCommitMessage::kTargetFileName) > 0);
+  ASSERT_TRUE(fileInfo.count(HiveCommitMessage::kFileSize) > 0);
+  ASSERT_FALSE(fileInfo[HiveCommitMessage::kWriteFileName].asString().empty());
+  ASSERT_FALSE(fileInfo[HiveCommitMessage::kTargetFileName].asString().empty());
+
+  const auto reportedFileSize =
+      static_cast<uint64_t>(fileInfo[HiveCommitMessage::kFileSize].asInt());
+  ASSERT_GT(reportedFileSize, 0);
+
+  // File size in fileWriteInfos should match stats.numWrittenBytes
+  ASSERT_EQ(reportedFileSize, stats.numWrittenBytes);
+
+  // onDiskDataSizeInBytes should also match
+  const auto onDiskBytes = static_cast<uint64_t>(
+      partitionJson[HiveCommitMessage::kOnDiskDataSizeInBytes].asInt());
+  ASSERT_EQ(onDiskBytes, stats.numWrittenBytes);
+
+  // Verify actual file on disk matches reported size
+  const auto filePaths = listFiles(outputDirectory->getPath());
+  ASSERT_EQ(filePaths.size(), 1);
+  ASSERT_EQ(fs::file_size(filePaths[0]), reportedFileSize);
+
+  createDuckDbTable(vectors);
+  verifyWrittenData(outputDirectory->getPath());
+}
+
+TEST_F(HiveDataSinkTest, fileRotationIoStatsAccumulation) {
+  const auto outputDirectory = TempDirectoryPath::create();
+
+  std::unordered_map<std::string, std::string> connectorConfig;
+  connectorConfig.emplace("max-target-file-size", "1MB");
+  connectorConfig.emplace("hive.orc.writer.stripe-max-size", "256KB");
+  connectorConfig_ = std::make_shared<HiveConfig>(
+      std::make_shared<config::ConfigBase>(std::move(connectorConfig)));
+
+  auto dataSink = createDataSink(rowType_, outputDirectory->getPath());
+
+  const int numBatches = 100;
+  const auto vectors = createVectors(1000, numBatches);
+  for (const auto& vector : vectors) {
+    dataSink->appendData(vector);
+  }
+
+  const auto statsBeforeClose = dataSink->stats();
+  ASSERT_GT(statsBeforeClose.numWrittenBytes, 0);
+
+  ASSERT_TRUE(dataSink->finish());
+  const auto partitions = dataSink->close();
+  const auto statsAfterClose = dataSink->stats();
+
+  ASSERT_GT(statsAfterClose.numWrittenFiles, 1);
+  ASSERT_GT(statsAfterClose.numWrittenBytes, 0);
+
+  const auto filePaths = listFiles(outputDirectory->getPath());
+  ASSERT_EQ(filePaths.size(), statsAfterClose.numWrittenFiles);
+
+  uint64_t totalFileSizeOnDisk = 0;
+  for (const auto& filePath : filePaths) {
+    totalFileSizeOnDisk += fs::file_size(filePath);
+  }
+
+  ASSERT_GT(
+      statsAfterClose.numWrittenBytes,
+      static_cast<uint64_t>(totalFileSizeOnDisk * 0.9));
+  ASSERT_LT(
+      statsAfterClose.numWrittenBytes,
+      static_cast<uint64_t>(totalFileSizeOnDisk * 1.1));
+
+  ASSERT_EQ(partitions.size(), 1);
+  const auto partitionJson = folly::parseJson(partitions[0]);
+  const auto onDiskBytes = static_cast<uint64_t>(
+      partitionJson[HiveCommitMessage::kOnDiskDataSizeInBytes].asInt());
+  ASSERT_EQ(onDiskBytes, statsAfterClose.numWrittenBytes);
+
+  createDuckDbTable(vectors);
+  verifyWrittenData(
+      outputDirectory->getPath(), statsAfterClose.numWrittenFiles);
+}
+
+TEST_F(HiveDataSinkTest, fileRotationFileInfoConsistency) {
+  // Tests that file info (names, sizes) in partition updates is consistent
+  // with actual files on disk after rotation.
+  const auto outputDirectory = TempDirectoryPath::create();
+
+  std::unordered_map<std::string, std::string> connectorConfig;
+  connectorConfig.emplace("max-target-file-size", "500KB");
+  connectorConfig.emplace("hive.orc.writer.stripe-max-size", "128KB");
+  connectorConfig_ = std::make_shared<HiveConfig>(
+      std::make_shared<config::ConfigBase>(std::move(connectorConfig)));
+
+  auto dataSink = createDataSink(rowType_, outputDirectory->getPath());
+
+  const int numBatches = 50;
+  const auto vectors = createVectors(500, numBatches);
+  for (const auto& vector : vectors) {
+    dataSink->appendData(vector);
+  }
+
+  ASSERT_TRUE(dataSink->finish());
+  const auto partitions = dataSink->close();
+  const auto stats = dataSink->stats();
+
+  ASSERT_GT(stats.numWrittenFiles, 1);
+  ASSERT_EQ(partitions.size(), 1);
+
+  const auto partitionJson = folly::parseJson(partitions[0]);
+  const auto& fileWriteInfos =
+      partitionJson[HiveCommitMessage::kFileWriteInfos];
+
+  // Verify file count matches
+  ASSERT_EQ(fileWriteInfos.size(), stats.numWrittenFiles);
+
+  // Get actual files on disk
+  const auto filePaths = listFiles(outputDirectory->getPath());
+  ASSERT_EQ(filePaths.size(), stats.numWrittenFiles);
+
+  // Build a map of file names to sizes from partition info
+  std::map<std::string, uint64_t> reportedFiles;
+  uint64_t totalReportedSize = 0;
+  for (size_t i = 0; i < fileWriteInfos.size(); ++i) {
+    const auto& info = fileWriteInfos[i];
+    const auto fileName = info[HiveCommitMessage::kWriteFileName].asString();
+    const auto fileSize =
+        static_cast<uint64_t>(info[HiveCommitMessage::kFileSize].asInt());
+    reportedFiles[fileName] = fileSize;
+    totalReportedSize += fileSize;
+
+    // Verify each file has non-empty name and positive size
+    ASSERT_FALSE(fileName.empty()) << "File name at index " << i << " is empty";
+    ASSERT_GT(fileSize, 0) << "File size at index " << i << " is zero";
+  }
+
+  // Verify onDiskDataSizeInBytes matches sum of file sizes
+  const auto onDiskBytes = static_cast<uint64_t>(
+      partitionJson[HiveCommitMessage::kOnDiskDataSizeInBytes].asInt());
+  ASSERT_EQ(onDiskBytes, totalReportedSize);
+  ASSERT_EQ(onDiskBytes, stats.numWrittenBytes);
+
+  // Verify actual file sizes on disk match reported sizes exactly.
+  // Stats are captured after close, so footer bytes are included.
+  for (const auto& filePath : filePaths) {
+    const auto fileName = fs::path(filePath).filename().string();
+    ASSERT_TRUE(reportedFiles.count(fileName) > 0)
+        << "File on disk not found in partition info: " << fileName;
+
+    const auto actualSize = fs::file_size(filePath);
+    const auto reportedSize = reportedFiles[fileName];
+    // Sizes should match exactly since stats are captured after close.
+    ASSERT_EQ(actualSize, reportedSize)
+        << "File size mismatch for " << fileName;
+  }
+
+  createDuckDbTable(vectors);
+  verifyWrittenData(outputDirectory->getPath(), stats.numWrittenFiles);
+}
+
+TEST_F(HiveDataSinkTest, fileRotationStatsProgressDuringWrite) {
+  // Tests that stats are correctly reported during writing (not just at close).
+  // Verifies stats grow monotonically even when rotation happens mid-write.
+  const auto outputDirectory = TempDirectoryPath::create();
+
+  std::unordered_map<std::string, std::string> connectorConfig;
+  connectorConfig.emplace("max-target-file-size", "256KB");
+  connectorConfig.emplace("hive.orc.writer.stripe-max-size", "64KB");
+  connectorConfig_ = std::make_shared<HiveConfig>(
+      std::make_shared<config::ConfigBase>(std::move(connectorConfig)));
+
+  auto dataSink = createDataSink(rowType_, outputDirectory->getPath());
+
+  const auto vectors = createVectors(500, 50);
+  uint64_t previousBytes = 0;
+
+  for (size_t i = 0; i < vectors.size(); ++i) {
+    dataSink->appendData(vectors[i]);
+    const auto currentStats = dataSink->stats();
+
+    // Stats should be monotonically increasing
+    ASSERT_GE(currentStats.numWrittenBytes, previousBytes)
+        << "Stats decreased at batch " << i;
+    previousBytes = currentStats.numWrittenBytes;
+  }
+
+  const auto statsBeforeFinish = dataSink->stats();
+  ASSERT_GT(statsBeforeFinish.numWrittenBytes, 0);
+
+  ASSERT_TRUE(dataSink->finish());
+  const auto partitions = dataSink->close();
+  const auto finalStats = dataSink->stats();
+
+  // Final stats should be >= stats before finish
+  ASSERT_GE(finalStats.numWrittenBytes, statsBeforeFinish.numWrittenBytes);
+  ASSERT_GT(finalStats.numWrittenFiles, 1);
+
+  createDuckDbTable(vectors);
+  verifyWrittenData(outputDirectory->getPath(), finalStats.numWrittenFiles);
+}
+
+TEST_F(HiveDataSinkTest, fileRotationWithPartitionedTable) {
+  // Tests file rotation with partitioned tables.
+  const auto outputDirectory = TempDirectoryPath::create();
+
+  std::unordered_map<std::string, std::string> connectorConfig;
+  connectorConfig.emplace("max-target-file-size", "256KB");
+  connectorConfig.emplace("hive.orc.writer.stripe-max-size", "64KB");
+  connectorConfig_ = std::make_shared<HiveConfig>(
+      std::make_shared<config::ConfigBase>(std::move(connectorConfig)));
+
+  // Create a partitioned table with partition column
+  auto partitionedRowType = ROW(
+      {"c0", "c1", "c2", "p0"}, {BIGINT(), INTEGER(), SMALLINT(), VARCHAR()});
+
+  auto dataSink = createDataSink(
+      partitionedRowType,
+      outputDirectory->getPath(),
+      dwio::common::FileFormat::DWRF,
+      {"p0"});
+
+  // Create vectors with a few distinct partition values
+  const int numBatches = 30;
+  std::vector<RowVectorPtr> vectors;
+  vectors.reserve(numBatches);
+  for (int i = 0; i < numBatches; ++i) {
+    auto c0 = makeFlatVector<int64_t>(500, [](auto row) { return row; });
+    auto c1 = makeFlatVector<int32_t>(500, [](auto row) { return row * 2; });
+    auto c2 = makeFlatVector<int16_t>(500, [](auto row) { return row % 100; });
+    // Two partitions: "part_a" and "part_b"
+    auto p0 = makeFlatVector<StringView>(500, [i](auto row) {
+      return (i + row) % 2 == 0 ? "part_a" : "part_b";
+    });
+    vectors.push_back(makeRowVector({c0, c1, c2, p0}));
+  }
+
+  for (const auto& vector : vectors) {
+    dataSink->appendData(vector);
+  }
+
+  ASSERT_TRUE(dataSink->finish());
+  const auto partitions = dataSink->close();
+  const auto stats = dataSink->stats();
+
+  // Should have 2 partitions
+  ASSERT_EQ(partitions.size(), 2);
+
+  // Each partition may have multiple files due to rotation
+  uint32_t totalFilesFromPartitions = 0;
+  for (const auto& partition : partitions) {
+    const auto partitionJson = folly::parseJson(partition);
+    ASSERT_TRUE(partitionJson.count(HiveCommitMessage::kFileWriteInfos) > 0);
+    const auto& fileWriteInfos =
+        partitionJson[HiveCommitMessage::kFileWriteInfos];
+    ASSERT_GT(fileWriteInfos.size(), 0);
+    totalFilesFromPartitions += fileWriteInfos.size();
+
+    // Verify each file has valid info
+    for (const auto& fileInfo : fileWriteInfos) {
+      ASSERT_TRUE(fileInfo.count(HiveCommitMessage::kWriteFileName) > 0);
+      ASSERT_TRUE(fileInfo.count(HiveCommitMessage::kTargetFileName) > 0);
+      ASSERT_TRUE(fileInfo.count(HiveCommitMessage::kFileSize) > 0);
+      ASSERT_GT(fileInfo[HiveCommitMessage::kFileSize].asInt(), 0);
+    }
+  }
+
+  ASSERT_EQ(totalFilesFromPartitions, stats.numWrittenFiles);
+}
+
+TEST_F(HiveDataSinkTest, fileRotationWriteIOTimeAccumulation) {
+  // Tests that writeIOTimeUs is correctly accumulated across rotated files.
+  const auto outputDirectory = TempDirectoryPath::create();
+
+  std::unordered_map<std::string, std::string> connectorConfig;
+  connectorConfig.emplace("max-target-file-size", "512KB");
+  connectorConfig.emplace("hive.orc.writer.stripe-max-size", "128KB");
+  connectorConfig_ = std::make_shared<HiveConfig>(
+      std::make_shared<config::ConfigBase>(std::move(connectorConfig)));
+
+  auto dataSink = createDataSink(rowType_, outputDirectory->getPath());
+
+  const int numBatches = 60;
+  const auto vectors = createVectors(500, numBatches);
+  for (const auto& vector : vectors) {
+    dataSink->appendData(vector);
+  }
+
+  ASSERT_TRUE(dataSink->finish());
+  dataSink->close();
+  const auto stats = dataSink->stats();
+
+  // Should have multiple files from rotation
+  ASSERT_GT(stats.numWrittenFiles, 1);
+
+  // writeIOTimeUs should be non-zero (actual I/O happened)
+  // Note: This may be 0 on very fast systems, so we just check it's >= 0
+  ASSERT_GE(stats.writeIOTimeUs, 0);
+
+  createDuckDbTable(vectors);
+  verifyWrittenData(outputDirectory->getPath(), stats.numWrittenFiles);
+}
+
+TEST_F(HiveDataSinkTest, fileRotationWithMemoryReclaim) {
+  // Tests that file rotation works correctly when memory reclamation is
+  // enabled. This verifies the single ioStats approach - we reuse the same
+  // ioStats object during rotation instead of replacing it, which prevents
+  // race conditions with WriterReclaimer.
+  const auto outputDirectory = TempDirectoryPath::create();
+
+  std::unordered_map<std::string, std::string> connectorConfig;
+  // Use small file size to trigger multiple rotations
+  connectorConfig.emplace("max-target-file-size", "256KB");
+  connectorConfig.emplace("hive.orc.writer.stripe-max-size", "64KB");
+  connectorConfig_ = std::make_shared<HiveConfig>(
+      std::make_shared<config::ConfigBase>(std::move(connectorConfig)));
+
+  // Setup memory pools with spill config to enable reclaim
+  auto spillDirectory = TempDirectoryPath::create();
+  auto spillConfig = getSpillConfig(spillDirectory->getPath(), 1 << 30);
+  auto connectorQueryCtx = std::make_unique<connector::ConnectorQueryCtx>(
+      opPool_.get(),
+      connectorPool_.get(),
+      connectorSessionProperties_.get(),
+      spillConfig.get(),
+      common::PrefixSortConfig(),
+      nullptr,
+      nullptr,
+      "query.HiveDataSinkTest",
+      "task.HiveDataSinkTest",
+      "planNodeId.HiveDataSinkTest",
+      0,
+      "");
+  setConnectorQueryContext(std::move(connectorQueryCtx));
+
+  auto dataSink = createDataSink(rowType_, outputDirectory->getPath());
+  auto* hiveDataSink = static_cast<HiveDataSink*>(dataSink.get());
+
+  // Verify reclaim is enabled
+  ASSERT_TRUE(hiveDataSink->canReclaim());
+
+  const int numBatches = 50;
+  const auto vectors = createVectors(500, numBatches);
+
+  for (const auto& vector : vectors) {
+    dataSink->appendData(vector);
+  }
+
+  // Trigger memory reclaim if there's reclaimable memory
+  auto reclaimableBytes = root_->reclaimableBytes();
+  if (reclaimableBytes.has_value() && reclaimableBytes.value() > 0) {
+    memory::MemoryReclaimer::Stats reclaimStats;
+    root_->reclaim(1L << 20, 0, reclaimStats);
+  }
+
+  ASSERT_TRUE(dataSink->finish());
+  const auto partitions = dataSink->close();
+  const auto stats = dataSink->stats();
+
+  // Should have multiple files from rotation
+  ASSERT_GT(stats.numWrittenFiles, 1);
+  ASSERT_EQ(partitions.size(), 1);
+
+  // Verify data integrity
+  createDuckDbTable(vectors);
+  verifyWrittenData(outputDirectory->getPath(), stats.numWrittenFiles);
+}
+
 TEST_F(HiveDataSinkTest, raceWithCacheEviction) {
   /// This test ensures that LRU cache staleness and StringIdMap cache
   /// eviction do not cause issues with file reads.
@@ -1324,7 +1857,7 @@ TEST_F(HiveDataSinkTest, raceWithCacheEviction) {
   auto cacheCleaner = std::async(std::launch::async, [&] {
     auto cache = cache::AsyncDataCache::getInstance();
     auto hiveConnector = std::dynamic_pointer_cast<HiveConnector>(
-        getConnector(exec::test::kHiveConnectorId));
+        ConnectorRegistry::tryGet(exec::test::kHiveConnectorId));
     while (!stop) {
       std::this_thread::sleep_for(std::chrono::milliseconds(10));
       cache->clear();
@@ -1375,6 +1908,99 @@ TEST_F(HiveDataSinkTest, lazyVectorForParquet) {
 }
 #endif
 
+// Test to verify that each writer has its own nonReclaimableSection
+// pointer when writerOptions is shared.
+TEST_F(HiveDataSinkTest, sharedWriterOptionsWithMultipleWriters) {
+  const auto outputDirectory = TempDirectoryPath::create();
+
+  const int32_t numBuckets = 3;
+  auto bucketProperty = std::make_shared<HiveBucketProperty>(
+      HiveBucketProperty::Kind::kHiveCompatible,
+      numBuckets,
+      std::vector<std::string>{"c0"},
+      std::vector<TypePtr>{BIGINT()},
+      std::vector<std::shared_ptr<const HiveSortingColumn>>{});
+
+  // Create shared writer options (this simulates the scenario where
+  // insertTableHandle_->writerOptions() returns a shared object)
+  auto sharedWriterOptions = std::make_shared<dwrf::WriterOptions>();
+
+  // Create a data sink with multiple writers (one for each bucket)
+  auto dataSink = createDataSink(
+      rowType_,
+      outputDirectory->getPath(),
+      dwio::common::FileFormat::DWRF,
+      {},
+      bucketProperty,
+      sharedWriterOptions);
+
+  const auto vectors = createVectors(200, 3);
+
+  // Write data - this should work without throwing exceptions
+  for (const auto& vector : vectors) {
+    dataSink->appendData(vector);
+  }
+
+  while (!dataSink->finish()) {
+  }
+  const auto partitions = dataSink->close();
+
+  ASSERT_GT(partitions.size(), 1);
+  createDuckDbTable(vectors);
+  verifyWrittenData(
+      outputDirectory->getPath(), static_cast<uint32_t>(partitions.size()));
+}
+
+DEBUG_ONLY_TEST_F(HiveDataSinkTest, perWriterMemoryPool) {
+  const auto outputDirectory = TempDirectoryPath::create();
+  auto writerOptions = std::make_shared<dwrf::WriterOptions>();
+
+  const auto rowType = ROW({"c0", "p0"}, {BIGINT(), VARCHAR()});
+  auto dataSink = createDataSink(
+      rowType,
+      outputDirectory->getPath(),
+      dwio::common::FileFormat::DWRF,
+      {"p0"},
+      nullptr,
+      writerOptions);
+
+  std::set<std::string> writerPoolNames;
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::dwrf::Writer::write",
+      std::function<void(dwrf::Writer*)>([&](dwrf::Writer* writer) {
+        // Memory pool hierarchy:
+        // Hive writer pool -> DWRF writer pool -> DWRF category leaf pools.
+        auto* innerPool = writer->getContext()
+                              .getMemoryPool(dwrf::MemoryUsageCategory::GENERAL)
+                              .parent();
+        ASSERT_NE(innerPool, nullptr);
+        auto* writerPool = innerPool->parent();
+        ASSERT_NE(writerPool, nullptr);
+        writerPoolNames.insert(writerPool->name());
+      }));
+
+  dataSink->appendData(makeRowVector({
+      makeFlatVector<int64_t>(200, folly::identity),
+      makeFlatVector<StringView>(
+          200, [](auto row) { return row % 2 == 0 ? "part_0" : "part_1"; }),
+  }));
+
+  ASSERT_EQ(writerPoolNames.size(), 2);
+  ASSERT_TRUE(dataSink->finish());
+  ASSERT_EQ(dataSink->close().size(), 2);
+}
+
+TEST_F(HiveDataSinkTest, sanitizeFileName) {
+  auto sanitizeFileName = [](std::string fileName) {
+    HiveInsertFileNameGenerator::sanitizeFileName(fileName);
+    return fileName;
+  };
+  ASSERT_EQ(sanitizeFileName("abc"), "abc");
+  ASSERT_EQ(sanitizeFileName("abc_.-ABC012"), "abc_.-ABC012");
+  ASSERT_EQ(sanitizeFileName("abc_.-ABC012\\/"), "abc_.-ABC012__");
+  ASSERT_EQ(sanitizeFileName("local://abc/bcd/"), "local___abc_bcd_");
+}
+
 } // namespace
 } // namespace facebook::velox::connector::hive
 
diff --git a/velox/connectors/hive/tests/HivePartitionFunctionTest.cpp b/velox/connectors/hive/tests/HivePartitionFunctionTest.cpp
index 4fdf68684b0..1adfb387445 100644
--- a/velox/connectors/hive/tests/HivePartitionFunctionTest.cpp
+++ b/velox/connectors/hive/tests/HivePartitionFunctionTest.cpp
@@ -832,10 +832,11 @@ TEST_F(HivePartitionFunctionTest, skew) {
   }
   std::vector<VectorPtr> partitionedInputs;
   for (int partition = 0; partition < numRemotePartitions; ++partition) {
-    partitionedInputs.push_back(exec::wrap(
-        partitionSizeVectors[partition],
-        partitionIndicesVector[partition],
-        input));
+    partitionedInputs.push_back(
+        exec::wrap(
+            partitionSizeVectors[partition],
+            partitionIndicesVector[partition],
+            input));
   }
 
   // Checks that the bad hive partition function (using round-robin map from
diff --git a/velox/connectors/hive/tests/HivePartitionUtilTest.cpp b/velox/connectors/hive/tests/HivePartitionNameTest.cpp
similarity index 85%
rename from velox/connectors/hive/tests/HivePartitionUtilTest.cpp
rename to velox/connectors/hive/tests/HivePartitionNameTest.cpp
index 8598f46742f..b236951946f 100644
--- a/velox/connectors/hive/tests/HivePartitionUtilTest.cpp
+++ b/velox/connectors/hive/tests/HivePartitionNameTest.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "velox/connectors/hive/HivePartitionUtil.h"
+#include "velox/connectors/hive/HivePartitionName.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/dwio/catalog/fbhive/FileUtils.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
@@ -26,7 +26,7 @@ using namespace facebook::velox;
 using namespace facebook::velox::connector::hive;
 using namespace facebook::velox::dwio::catalog::fbhive;
 
-class HivePartitionUtilTest : public ::testing::Test,
+class HivePartitionNameTest : public ::testing::Test,
                               public velox::test::VectorTestBase {
  protected:
   static void SetUpTestCase() {
@@ -62,9 +62,26 @@ class HivePartitionUtilTest : public ::testing::Test,
         input->size(),
         partitions);
   }
+
+  static auto toPartitionName() {
+    return [](auto value, const TypePtr& type, int /*columnIndex*/) {
+      return HivePartitionName::toName(value, type);
+    };
+  }
+
+  std::vector<std::pair<std::string, std::string>> extractPartitionKeyValues(
+      RowVectorPtr input,
+      const std::vector<column_index_t>& partitionChannels,
+      vector_size_t rowIndex = 0) {
+    return HivePartitionName::partitionKeyValues(
+        rowIndex,
+        makePartitionsVector(input, partitionChannels),
+        /*nullValueString=*/"",
+        toPartitionName());
+  }
 };
 
-TEST_F(HivePartitionUtilTest, partitionName) {
+TEST_F(HivePartitionNameTest, partitionName) {
   {
     RowVectorPtr input = makeRowVector(
         {"flat_bool_col",
@@ -102,9 +119,7 @@ TEST_F(HivePartitionUtilTest, partitionName) {
 
       EXPECT_EQ(
           FileUtils::makePartName(
-              extractPartitionKeyValues(
-                  makePartitionsVector(input, partitionChannels), 0),
-              true),
+              extractPartitionKeyValues(input, partitionChannels), true),
           folly::join(
               "/",
               std::vector<std::string>(
@@ -124,14 +139,12 @@ TEST_F(HivePartitionUtilTest, partitionName) {
 
     VELOX_ASSERT_THROW(
         FileUtils::makePartName(
-            extractPartitionKeyValues(
-                makePartitionsVector(input, partitionChannels), 0),
-            true),
+            extractPartitionKeyValues(input, partitionChannels), true),
         "Unsupported partition type: MAP");
   }
 }
 
-TEST_F(HivePartitionUtilTest, partitionNameForNull) {
+TEST_F(HivePartitionNameTest, partitionNameForNull) {
   std::vector<std::string> partitionColumnNames{
       "flat_bool_col",
       "flat_tinyint_col",
@@ -155,15 +168,14 @@ TEST_F(HivePartitionUtilTest, partitionNameForNull) {
 
   for (auto i = 0; i < partitionColumnNames.size(); i++) {
     std::vector<column_index_t> partitionChannels = {(column_index_t)i};
-    auto partitionEntries = extractPartitionKeyValues(
-        makePartitionsVector(input, partitionChannels), 0);
+    auto partitionEntries = extractPartitionKeyValues(input, partitionChannels);
     EXPECT_EQ(1, partitionEntries.size());
     EXPECT_EQ(partitionColumnNames[i], partitionEntries[0].first);
     EXPECT_EQ("", partitionEntries[0].second);
   }
 }
 
-TEST_F(HivePartitionUtilTest, timestampPartitionValueFormatting) {
+TEST_F(HivePartitionNameTest, timestampPartitionValueFormatting) {
   // Test timestamp partition value formatting to match Presto's
   // java.sql.Timestamp.toString() behavior: removes trailing zeros but keeps at
   // least one decimal place
@@ -192,11 +204,10 @@ TEST_F(HivePartitionUtilTest, timestampPartitionValueFormatting) {
       makeRowVector({"timestamp_col"}, {makeFlatVector<Timestamp>(timestamps)});
 
   std::vector<column_index_t> partitionChannels{0};
-  auto partitionsVector = makePartitionsVector(input, partitionChannels);
 
   for (size_t i = 0; i < timestamps.size(); i++) {
-    auto partitionEntries = extractPartitionKeyValues(
-        partitionsVector, static_cast<vector_size_t>(i));
+    auto partitionEntries =
+        extractPartitionKeyValues(input, partitionChannels, i);
 
     EXPECT_EQ(1, partitionEntries.size());
     EXPECT_EQ("timestamp_col", partitionEntries[0].first);
diff --git a/velox/connectors/hive/tests/PartitionIdGeneratorTest.cpp b/velox/connectors/hive/tests/PartitionIdGeneratorTest.cpp
index 271e4599d3f..7dcb0d5e195 100644
--- a/velox/connectors/hive/tests/PartitionIdGeneratorTest.cpp
+++ b/velox/connectors/hive/tests/PartitionIdGeneratorTest.cpp
@@ -16,6 +16,7 @@
 
 #include "velox/connectors/hive/PartitionIdGenerator.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/connectors/hive/HivePartitionName.h"
 #include "velox/type/TimestampConversion.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
@@ -34,7 +35,7 @@ class PartitionIdGeneratorTest : public ::testing::Test,
 TEST_F(PartitionIdGeneratorTest, consecutiveIdsSingleKey) {
   auto numPartitions = 100;
 
-  PartitionIdGenerator idGenerator(ROW({VARCHAR()}), {0}, 100, pool(), true);
+  PartitionIdGenerator idGenerator(ROW({VARCHAR()}), {0}, 100, pool());
 
   auto input = makeRowVector(
       {makeFlatVector<StringView>(numPartitions * 3, [&](auto row) {
@@ -56,7 +57,7 @@ TEST_F(PartitionIdGeneratorTest, consecutiveIdsSingleKey) {
 
 TEST_F(PartitionIdGeneratorTest, consecutiveIdsMultipleKeys) {
   PartitionIdGenerator idGenerator(
-      ROW({VARCHAR(), INTEGER()}), {0, 1}, 100, pool(), true);
+      ROW({VARCHAR(), INTEGER()}), {0, 1}, 100, pool());
 
   auto input = makeRowVector({
       makeFlatVector<StringView>(
@@ -83,7 +84,7 @@ TEST_F(PartitionIdGeneratorTest, consecutiveIdsMultipleKeys) {
 
 TEST_F(PartitionIdGeneratorTest, multipleBoolKeys) {
   PartitionIdGenerator idGenerator(
-      ROW({BOOLEAN(), BOOLEAN()}), {0, 1}, 100, pool(), true);
+      ROW({BOOLEAN(), BOOLEAN()}), {0, 1}, 100, pool());
 
   auto input = makeRowVector({
       makeFlatVector<bool>(
@@ -109,7 +110,7 @@ TEST_F(PartitionIdGeneratorTest, multipleBoolKeys) {
 }
 
 TEST_F(PartitionIdGeneratorTest, stableIdsSingleKey) {
-  PartitionIdGenerator idGenerator(ROW({BIGINT()}), {0}, 100, pool(), true);
+  PartitionIdGenerator idGenerator(ROW({BIGINT()}), {0}, 100, pool());
 
   auto numPartitions = 40;
   auto input = makeRowVector({
@@ -136,7 +137,7 @@ TEST_F(PartitionIdGeneratorTest, stableIdsSingleKey) {
 
 TEST_F(PartitionIdGeneratorTest, stableIdsMultipleKeys) {
   PartitionIdGenerator idGenerator(
-      ROW({BIGINT(), VARCHAR(), INTEGER()}), {1, 2}, 100, pool(), true);
+      ROW({BIGINT(), VARCHAR(), INTEGER()}), {1, 2}, 100, pool());
 
   const vector_size_t size = 1'000;
   auto input = makeRowVector({
@@ -175,7 +176,7 @@ TEST_F(PartitionIdGeneratorTest, stableIdsMultipleKeys) {
 
 TEST_F(PartitionIdGeneratorTest, partitionKeysCaseSensitive) {
   PartitionIdGenerator idGenerator(
-      ROW({"cc0", "Cc1"}, {BIGINT(), VARCHAR()}), {1}, 100, pool(), false);
+      ROW({"cc0", "Cc+1"}, {BIGINT(), VARCHAR()}), {1}, 100, pool());
 
   auto input = makeRowVector({
       makeFlatVector<int64_t>({1, 2, 3}),
@@ -184,12 +185,19 @@ TEST_F(PartitionIdGeneratorTest, partitionKeysCaseSensitive) {
 
   raw_vector<uint64_t> firstTimeIds;
   idGenerator.run(input, firstTimeIds);
-  EXPECT_EQ("Cc1=apple", idGenerator.partitionName(0));
-  EXPECT_EQ("Cc1=orange", idGenerator.partitionName(1));
+
+  EXPECT_EQ(
+      "Cc+1=apple",
+      HivePartitionName::partitionName(
+          0, idGenerator.partitionValues(), /*partitionKeyAsLowerCase=*/false));
+  EXPECT_EQ(
+      "Cc+1=orange",
+      HivePartitionName::partitionName(
+          1, idGenerator.partitionValues(), /*partitionKeyAsLowerCase=*/false));
 }
 
 TEST_F(PartitionIdGeneratorTest, numPartitions) {
-  PartitionIdGenerator idGenerator(ROW({BIGINT()}), {0}, 100, pool(), true);
+  PartitionIdGenerator idGenerator(ROW({BIGINT()}), {0}, 100, pool());
 
   // First run to process partition 0,..,9. Total num of partitions processed by
   // far is 10.
@@ -224,7 +232,7 @@ TEST_F(PartitionIdGeneratorTest, limitOfPartitionNumber) {
   auto maxPartitions = 100;
 
   PartitionIdGenerator idGenerator(
-      ROW({INTEGER()}), {0}, maxPartitions, pool(), true);
+      ROW({INTEGER()}), {0}, maxPartitions, pool());
 
   auto input = makeRowVector({
       makeFlatVector<int32_t>(maxPartitions + 1, [](auto row) { return row; }),
@@ -239,7 +247,7 @@ TEST_F(PartitionIdGeneratorTest, limitOfPartitionNumber) {
 
 TEST_F(PartitionIdGeneratorTest, timestampPartitionKeyComparasion) {
   PartitionIdGenerator idGenerator(
-      ROW({"timestamp_col"}, {TIMESTAMP()}), {0}, 100, pool(), true);
+      ROW({"timestamp_col"}, {TIMESTAMP()}), {0}, 100, pool());
   auto timestampResult = util::fromTimestampString(
       "2025-01-02 00:00:00.0", util::TimestampParseMode::kPrestoCast);
   auto input = makeRowVector({
@@ -247,13 +255,17 @@ TEST_F(PartitionIdGeneratorTest, timestampPartitionKeyComparasion) {
   });
   raw_vector<uint64_t> testTimeIds;
   idGenerator.run(input, testTimeIds);
+
   EXPECT_EQ(
-      idGenerator.partitionName(testTimeIds[0]),
+      HivePartitionName::partitionName(
+          testTimeIds[0],
+          idGenerator.partitionValues(),
+          /*partitionKeyAsLowerCase=*/true),
       "timestamp_col=2025-01-01 16%3A00%3A00.0");
 }
 
 TEST_F(PartitionIdGeneratorTest, timestampPartitionKey) {
-  PartitionIdGenerator idGenerator(ROW({TIMESTAMP()}), {0}, 100, pool(), true);
+  PartitionIdGenerator idGenerator(ROW({TIMESTAMP()}), {0}, 100, pool());
 
   auto numPartitions = 50;
   auto input = makeRowVector({
@@ -325,8 +337,7 @@ TEST_F(PartitionIdGeneratorTest, supportedPartitionKeyTypes) {
         }),
         {0, 1, 2, 3, 4, 5, 6, 7},
         100,
-        pool(),
-        true);
+        pool());
 
     auto input = makeRowVector(
         {makeNullableFlatVector<StringView>(
@@ -362,8 +373,7 @@ TEST_F(PartitionIdGeneratorTest, supportedPartitionKeyTypes) {
 
     for (column_index_t i = 1; i < input->childrenSize(); i++) {
       VELOX_ASSERT_THROW(
-          PartitionIdGenerator(
-              asRowType(input->type()), {i}, 100, pool(), true),
+          PartitionIdGenerator(asRowType(input->type()), {i}, 100, pool()),
           fmt::format(
               "Unsupported partition type: {}.",
               input->childAt(i)->type()->toString()));
diff --git a/velox/connectors/hive/tests/TableHandleTest.cpp b/velox/connectors/hive/tests/TableHandleTest.cpp
index 53cb95a2722..c342add7f4e 100644
--- a/velox/connectors/hive/tests/TableHandleTest.cpp
+++ b/velox/connectors/hive/tests/TableHandleTest.cpp
@@ -16,11 +16,14 @@
 
 #include "velox/connectors/hive/TableHandle.h"
 
+#include <gmock/gmock.h>
 #include "gtest/gtest.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/connectors/hive/ExtractionUtils.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 
 using namespace facebook::velox;
+using namespace facebook::velox::connector::hive;
 
 TEST(FileHandleTest, hiveColumnHandle) {
   Type::registerSerDe();
@@ -35,7 +38,7 @@ TEST(FileHandleTest, hiveColumnHandle) {
   ASSERT_EQ(columnHandle->name(), "columnHandle");
   ASSERT_EQ(
       columnHandle->columnType(),
-      connector::hive::HiveColumnHandle::ColumnType::kRegular);
+      connector::hive::FileColumnHandle::ColumnType::kRegular);
   ASSERT_EQ(columnHandle->dataType(), columnType);
   ASSERT_EQ(columnHandle->hiveType(), columnType);
   ASSERT_FALSE(columnHandle->isPartitionKey());
@@ -55,3 +58,727 @@ TEST(FileHandleTest, hiveColumnHandle) {
           {"c0.c0c1[3][\"foo\"].c0c1c0"}),
       "data type ROW<c0c0:BIGINT,c0c1:ARRAY<MAP<VARCHAR,ROW<c0c1c0:BIGINT,c0c1c1:BIGINT>>>> and hive type ROW<c0c0:BIGINT,c0c1:BIGINT> do not match");
 }
+
+TEST(TableHandleTest, hiveTableHandleDbName) {
+  connector::hive::HiveTableHandle::registerSerDe();
+
+  // Default dbName is empty.
+  auto handleNoDb = std::make_shared<connector::hive::HiveTableHandle>(
+      "test-connector",
+      "test_table",
+      common::SubfieldFilters{},
+      /*remainingFilter=*/nullptr);
+  ASSERT_TRUE(handleNoDb->dbName().empty());
+  ASSERT_EQ(handleNoDb->tableName(), "test_table");
+
+  // Explicit dbName is preserved.
+  auto handleWithDb = std::make_shared<connector::hive::HiveTableHandle>(
+      "test-connector",
+      "test_table",
+      common::SubfieldFilters{},
+      /*remainingFilter=*/nullptr,
+      /*dataColumns=*/nullptr,
+      /*indexColumns=*/std::vector<std::string>{},
+      /*tableParameters=*/std::unordered_map<std::string, std::string>{},
+      /*filterColumnHandles=*/
+      std::vector<connector::hive::HiveColumnHandlePtr>{},
+      /*sampleRate=*/1.0,
+      /*dbName=*/"test_db");
+  ASSERT_EQ(handleWithDb->dbName(), "test_db");
+  ASSERT_EQ(handleWithDb->tableName(), "test_table");
+
+  // Serialization round-trip preserves dbName.
+  auto obj = handleWithDb->serialize();
+  auto clone = ISerializable::deserialize<connector::hive::HiveTableHandle>(
+      obj, /*context=*/nullptr);
+  ASSERT_EQ(clone->dbName(), "test_db");
+  ASSERT_EQ(clone->tableName(), "test_table");
+
+  // Round-trip with empty dbName omits the field.
+  auto objNoDb = handleNoDb->serialize();
+  auto cloneNoDb = ISerializable::deserialize<connector::hive::HiveTableHandle>(
+      objNoDb, /*context=*/nullptr);
+  ASSERT_TRUE(cloneNoDb->dbName().empty());
+}
+
+TEST(TableHandleTest, hiveTableHandleIndexSupport) {
+  // Test HiveTableHandle without index columns.
+  auto tableHandleWithoutIndex =
+      std::make_shared<connector::hive::HiveTableHandle>(
+          "test-connector",
+          "test_table",
+          common::SubfieldFilters{},
+          /*remainingFilter=*/nullptr,
+          /*dataColumns=*/nullptr,
+          /*indexColumns=*/std::vector<std::string>{});
+
+  ASSERT_FALSE(tableHandleWithoutIndex->supportsIndexLookup());
+  ASSERT_TRUE(tableHandleWithoutIndex->needsIndexSplit());
+  ASSERT_TRUE(tableHandleWithoutIndex->indexColumns().empty());
+
+  // Test HiveTableHandle with index columns.
+  auto tableHandleWithIndex =
+      std::make_shared<connector::hive::HiveTableHandle>(
+          "test-connector",
+          "test_table",
+          common::SubfieldFilters{},
+          /*remainingFilter=*/nullptr,
+          /*dataColumns=*/nullptr,
+          /*indexColumns=*/std::vector<std::string>{"col1", "col2"});
+
+  ASSERT_TRUE(tableHandleWithIndex->supportsIndexLookup());
+  ASSERT_TRUE(tableHandleWithIndex->needsIndexSplit());
+  ASSERT_EQ(tableHandleWithIndex->indexColumns().size(), 2);
+  ASSERT_EQ(tableHandleWithIndex->indexColumns()[0], "col1");
+  ASSERT_EQ(tableHandleWithIndex->indexColumns()[1], "col2");
+}
+
+// --- Column extraction pushdown tests ---
+
+using EPE = ExtractionPathElementPtr;
+
+TEST(ExtractionStepTest, nameRoundTrip) {
+  // Verify all extraction steps can be converted to names and back.
+  std::vector<ExtractionStep> steps = {
+      ExtractionStep::kStructField,
+      ExtractionStep::kMapKeys,
+      ExtractionStep::kMapValues,
+      ExtractionStep::kMapKeyFilter,
+      ExtractionStep::kArrayElements,
+      ExtractionStep::kSize,
+  };
+  for (auto step : steps) {
+    auto name = extractionStepName(step);
+    ASSERT_EQ(extractionStepFromName(name), step);
+  }
+}
+
+TEST(ExtractionStepTest, nameValues) {
+  ASSERT_EQ(extractionStepName(ExtractionStep::kStructField), "STRUCT_FIELD");
+  ASSERT_EQ(extractionStepName(ExtractionStep::kMapKeys), "MAP_KEYS");
+  ASSERT_EQ(extractionStepName(ExtractionStep::kMapValues), "MAP_VALUES");
+  ASSERT_EQ(
+      extractionStepName(ExtractionStep::kMapKeyFilter), "MAP_KEY_FILTER");
+  ASSERT_EQ(
+      extractionStepName(ExtractionStep::kArrayElements), "ARRAY_ELEMENTS");
+  ASSERT_EQ(extractionStepName(ExtractionStep::kSize), "SIZE");
+}
+
+TEST(DeriveExtractionOutputTypeTest, mapKeys) {
+  // map_keys(col) where col: MAP(VARCHAR, BIGINT) -> ARRAY(VARCHAR).
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  std::vector<EPE> chain = {
+      ExtractionPathElement::simple(ExtractionStep::kMapKeys)};
+  auto outputType = deriveExtractionOutputType(hiveType, chain);
+  ASSERT_TRUE(outputType->equivalent(*ARRAY(VARCHAR())));
+}
+
+TEST(DeriveExtractionOutputTypeTest, mapValues) {
+  // map_values(col) where col: MAP(VARCHAR, BIGINT) -> ARRAY(BIGINT).
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  std::vector<EPE> chain = {
+      ExtractionPathElement::simple(ExtractionStep::kMapValues)};
+  auto outputType = deriveExtractionOutputType(hiveType, chain);
+  ASSERT_TRUE(outputType->equivalent(*ARRAY(BIGINT())));
+}
+
+TEST(DeriveExtractionOutputTypeTest, size) {
+  // cardinality(col) where col: MAP(VARCHAR, BIGINT) -> BIGINT.
+  auto mapType = MAP(VARCHAR(), BIGINT());
+  std::vector<EPE> chain = {
+      ExtractionPathElement::simple(ExtractionStep::kSize)};
+  auto outputType = deriveExtractionOutputType(mapType, chain);
+  ASSERT_TRUE(outputType->equivalent(*BIGINT()));
+
+  // cardinality(col) where col: ARRAY(BIGINT) -> BIGINT.
+  auto arrayType = ARRAY(BIGINT());
+  outputType = deriveExtractionOutputType(arrayType, chain);
+  ASSERT_TRUE(outputType->equivalent(*BIGINT()));
+}
+
+TEST(DeriveExtractionOutputTypeTest, structFieldMapKeys) {
+  // map_keys(col.a.b) where col: ROW(a: ROW(b: MAP(K, V))) -> ARRAY(K).
+  auto hiveType = ROW({{"a", ROW({{"b", MAP(VARCHAR(), BIGINT())}})}});
+  std::vector<EPE> chain = {
+      ExtractionPathElement::structField("a"),
+      ExtractionPathElement::structField("b"),
+      ExtractionPathElement::simple(ExtractionStep::kMapKeys)};
+  auto outputType = deriveExtractionOutputType(hiveType, chain);
+  ASSERT_TRUE(outputType->equivalent(*ARRAY(VARCHAR())));
+}
+
+TEST(DeriveExtractionOutputTypeTest, structFieldSize) {
+  // cardinality(col.features) where col: ROW(features: ARRAY(FLOAT),
+  // label: INT) -> BIGINT.
+  auto hiveType = ROW({{"features", ARRAY(REAL())}, {"label", INTEGER()}});
+  std::vector<EPE> chain = {
+      ExtractionPathElement::structField("features"),
+      ExtractionPathElement::simple(ExtractionStep::kSize)};
+  auto outputType = deriveExtractionOutputType(hiveType, chain);
+  ASSERT_TRUE(outputType->equivalent(*BIGINT()));
+}
+
+TEST(DeriveExtractionOutputTypeTest, mapValuesArrayElementsMapKeys) {
+  // map_keys(map_values(col)) where col: MAP(K1, MAP(K2, V))
+  // -> ARRAY(ARRAY(K2)).
+  auto hiveType = MAP(VARCHAR(), MAP(INTEGER(), DOUBLE()));
+  std::vector<EPE> chain = {
+      ExtractionPathElement::simple(ExtractionStep::kMapValues),
+      ExtractionPathElement::simple(ExtractionStep::kArrayElements),
+      ExtractionPathElement::simple(ExtractionStep::kMapKeys)};
+  auto outputType = deriveExtractionOutputType(hiveType, chain);
+  ASSERT_TRUE(outputType->equivalent(*ARRAY(ARRAY(INTEGER()))));
+}
+
+TEST(DeriveExtractionOutputTypeTest, nestedArrayElements) {
+  // map_keys(array_elements(map_values(col)))
+  // where col: MAP(K1, ARRAY(MAP(K2, V))) -> ARRAY(ARRAY(ARRAY(K2))).
+  auto hiveType = MAP(VARCHAR(), ARRAY(MAP(INTEGER(), DOUBLE())));
+  std::vector<EPE> chain = {
+      ExtractionPathElement::simple(ExtractionStep::kMapValues),
+      ExtractionPathElement::simple(ExtractionStep::kArrayElements),
+      ExtractionPathElement::simple(ExtractionStep::kArrayElements),
+      ExtractionPathElement::simple(ExtractionStep::kMapKeys)};
+  auto outputType = deriveExtractionOutputType(hiveType, chain);
+  ASSERT_TRUE(outputType->equivalent(*ARRAY(ARRAY(ARRAY(INTEGER())))));
+}
+
+TEST(DeriveExtractionOutputTypeTest, mapValuesStructField) {
+  // map_values(col).x where col: MAP(K, ROW(x: INT, y: INT))
+  // -> ARRAY(INT).
+  auto hiveType = MAP(VARCHAR(), ROW({{"x", INTEGER()}, {"y", INTEGER()}}));
+  std::vector<EPE> chain = {
+      ExtractionPathElement::simple(ExtractionStep::kMapValues),
+      ExtractionPathElement::simple(ExtractionStep::kArrayElements),
+      ExtractionPathElement::structField("x")};
+  auto outputType = deriveExtractionOutputType(hiveType, chain);
+  ASSERT_TRUE(outputType->equivalent(*ARRAY(INTEGER())));
+}
+
+TEST(DeriveExtractionOutputTypeTest, mapKeyFilter) {
+  // map_subset(col, ARRAY['a', 'b']) where col: MAP(VARCHAR, BIGINT)
+  // -> MAP(VARCHAR, BIGINT).
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  std::vector<EPE> chain = {
+      ExtractionPathElement::mapKeyFilter(std::vector<std::string>{"a", "b"})};
+  auto outputType = deriveExtractionOutputType(hiveType, chain);
+  ASSERT_TRUE(outputType->equivalent(*MAP(VARCHAR(), BIGINT())));
+}
+
+TEST(DeriveExtractionOutputTypeTest, mapKeyFilterMapValuesStructField) {
+  // element_at(col, 'foo').x via extraction chain:
+  // [MapKeyFilter(["foo"]), MapValues, ArrayElements, StructField("x")]
+  // where col: MAP(VARCHAR, ROW(x: INT, y: INT)) -> ARRAY(INT).
+  auto hiveType = MAP(VARCHAR(), ROW({{"x", INTEGER()}, {"y", INTEGER()}}));
+  std::vector<EPE> chain = {
+      ExtractionPathElement::mapKeyFilter(std::vector<std::string>{"foo"}),
+      ExtractionPathElement::simple(ExtractionStep::kMapValues),
+      ExtractionPathElement::simple(ExtractionStep::kArrayElements),
+      ExtractionPathElement::structField("x")};
+  auto outputType = deriveExtractionOutputType(hiveType, chain);
+  ASSERT_TRUE(outputType->equivalent(*ARRAY(INTEGER())));
+}
+
+TEST(DeriveExtractionOutputTypeTest, nestedKeyFilter) {
+  // Nested key filter: MAP(K1, MAP(VARCHAR, ROW(x: INT, y: INT)))
+  // Chain: [MapValues, AE, MapKeyFilter(["foo"]), MapValues, AE,
+  // StructField("x")]
+  // -> ARRAY(ARRAY(INT)).
+  auto hiveType =
+      MAP(VARCHAR(), MAP(VARCHAR(), ROW({{"x", INTEGER()}, {"y", DOUBLE()}})));
+  std::vector<EPE> chain = {
+      ExtractionPathElement::simple(ExtractionStep::kMapValues),
+      ExtractionPathElement::simple(ExtractionStep::kArrayElements),
+      ExtractionPathElement::mapKeyFilter(std::vector<std::string>{"foo"}),
+      ExtractionPathElement::simple(ExtractionStep::kMapValues),
+      ExtractionPathElement::simple(ExtractionStep::kArrayElements),
+      ExtractionPathElement::structField("x")};
+  auto outputType = deriveExtractionOutputType(hiveType, chain);
+  ASSERT_TRUE(outputType->equivalent(*ARRAY(ARRAY(INTEGER()))));
+}
+
+TEST(DeriveExtractionOutputTypeTest, emptyChain) {
+  // Empty chain means pass-through.
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  std::vector<EPE> chain = {};
+  auto outputType = deriveExtractionOutputType(hiveType, chain);
+  ASSERT_TRUE(outputType->equivalent(*hiveType));
+}
+
+TEST(DeriveExtractionOutputTypeTest, errorMissingArrayElementsAfterMapValues) {
+  // [MapValues, MapKeys] on MAP(K1, ARRAY(MAP(K2, V))) — missing
+  // ArrayElements.
+  auto hiveType = MAP(VARCHAR(), ARRAY(MAP(INTEGER(), DOUBLE())));
+  std::vector<EPE> chain = {
+      ExtractionPathElement::simple(ExtractionStep::kMapValues),
+      ExtractionPathElement::simple(ExtractionStep::kMapKeys)};
+  VELOX_ASSERT_THROW(
+      deriveExtractionOutputType(hiveType, chain),
+      "MapKeys requires MAP input, got: ARRAY");
+}
+
+TEST(DeriveExtractionOutputTypeTest, errorMissingArrayElementsAfterMapKeys) {
+  // [MapKeys, StructField("x")] on MAP(ROW(x: INT, y: INT), V) — missing
+  // ArrayElements.
+  auto hiveType = MAP(ROW({{"x", INTEGER()}, {"y", INTEGER()}}), BIGINT());
+  std::vector<EPE> chain = {
+      ExtractionPathElement::simple(ExtractionStep::kMapKeys),
+      ExtractionPathElement::structField("x")};
+  VELOX_ASSERT_THROW(
+      deriveExtractionOutputType(hiveType, chain),
+      "StructField requires ROW input, got: ARRAY");
+}
+
+TEST(DeriveExtractionOutputTypeTest, errorSizeNotTerminal) {
+  // Size must be the last step.
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  std::vector<EPE> chain = {
+      ExtractionPathElement::simple(ExtractionStep::kSize),
+      ExtractionPathElement::simple(ExtractionStep::kMapKeys)};
+  VELOX_ASSERT_THROW(
+      deriveExtractionOutputType(hiveType, chain),
+      "Size must be the last step");
+}
+
+TEST(DeriveExtractionOutputTypeTest, errorStructFieldOnMap) {
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  std::vector<EPE> chain = {ExtractionPathElement::structField("x")};
+  VELOX_ASSERT_THROW(
+      deriveExtractionOutputType(hiveType, chain),
+      "StructField requires ROW input");
+}
+
+TEST(DeriveExtractionOutputTypeTest, errorMapKeysOnArray) {
+  auto hiveType = ARRAY(BIGINT());
+  std::vector<EPE> chain = {
+      ExtractionPathElement::simple(ExtractionStep::kMapKeys)};
+  VELOX_ASSERT_THROW(
+      deriveExtractionOutputType(hiveType, chain),
+      "MapKeys requires MAP input");
+}
+
+TEST(DeriveExtractionOutputTypeTest, errorSizeOnScalar) {
+  auto hiveType = BIGINT();
+  std::vector<EPE> chain = {
+      ExtractionPathElement::simple(ExtractionStep::kSize)};
+  VELOX_ASSERT_THROW(
+      deriveExtractionOutputType(hiveType, chain),
+      "Size requires MAP or ARRAY input");
+}
+
+TEST(DeriveExtractionOutputTypeTest, errorNonExistentField) {
+  auto hiveType = ROW({{"a", INTEGER()}});
+  std::vector<EPE> chain = {ExtractionPathElement::structField("nonexistent")};
+  VELOX_ASSERT_THROW(
+      deriveExtractionOutputType(hiveType, chain),
+      "non-existent field: nonexistent");
+}
+
+TEST(ColumnExtractionTest, singleExtraction) {
+  // Single extraction: map_keys(col) where col: MAP(VARCHAR, BIGINT).
+  Type::registerSerDe();
+  HiveColumnHandle::registerSerDe();
+
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  auto outputType = ARRAY(VARCHAR());
+  std::vector<NamedExtraction> extractions = {
+      {"keys",
+       {ExtractionPathElement::simple(ExtractionStep::kMapKeys)},
+       outputType}};
+
+  auto handle = std::make_shared<HiveColumnHandle>(
+      "col",
+      HiveColumnHandle::ColumnType::kRegular,
+      outputType,
+      hiveType,
+      std::vector<common::Subfield>{},
+      std::move(extractions));
+
+  ASSERT_EQ(handle->name(), "col");
+  ASSERT_TRUE(handle->dataType()->equivalent(*ARRAY(VARCHAR())));
+  ASSERT_TRUE(handle->hiveType()->equivalent(*MAP(VARCHAR(), BIGINT())));
+  ASSERT_TRUE(handle->requiredSubfields().empty());
+  ASSERT_EQ(handle->extractions().size(), 1);
+  ASSERT_EQ(handle->extractions()[0].outputName, "keys");
+  ASSERT_EQ(handle->extractions()[0].chain.size(), 1);
+  ASSERT_EQ(
+      handle->extractions()[0].chain[0]->step(), ExtractionStep::kMapKeys);
+  ASSERT_TRUE(handle->extractions()[0].dataType->equivalent(*ARRAY(VARCHAR())));
+
+  // Serialization round-trip.
+  auto obj = handle->serialize();
+  auto clone = ISerializable::deserialize<HiveColumnHandle>(obj);
+  ASSERT_EQ(clone->toString(), handle->toString());
+  ASSERT_EQ(clone->extractions().size(), 1);
+  ASSERT_EQ(clone->extractions()[0].outputName, "keys");
+  ASSERT_TRUE(clone->extractions()[0].dataType->equivalent(*ARRAY(VARCHAR())));
+}
+
+TEST(ColumnExtractionTest, multipleExtractions) {
+  // Multiple extractions from the same column:
+  // map_keys(col), cardinality(col) where col: MAP(VARCHAR, BIGINT).
+  Type::registerSerDe();
+  HiveColumnHandle::registerSerDe();
+
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  auto keysType = ARRAY(VARCHAR());
+  auto sizeType = BIGINT();
+  auto rowOutputType = ROW({{"keys", keysType}, {"size", sizeType}});
+  std::vector<NamedExtraction> extractions = {
+      {"keys",
+       {ExtractionPathElement::simple(ExtractionStep::kMapKeys)},
+       keysType},
+      {"size",
+       {ExtractionPathElement::simple(ExtractionStep::kSize)},
+       sizeType}};
+
+  auto handle = std::make_shared<HiveColumnHandle>(
+      "col",
+      HiveColumnHandle::ColumnType::kRegular,
+      rowOutputType,
+      hiveType,
+      std::vector<common::Subfield>{},
+      std::move(extractions));
+
+  ASSERT_EQ(handle->extractions().size(), 2);
+  ASSERT_EQ(handle->extractions()[0].outputName, "keys");
+  ASSERT_EQ(handle->extractions()[1].outputName, "size");
+
+  // Serialization round-trip.
+  auto obj = handle->serialize();
+  auto clone = ISerializable::deserialize<HiveColumnHandle>(obj);
+  ASSERT_EQ(clone->extractions().size(), 2);
+  ASSERT_EQ(clone->extractions()[0].outputName, "keys");
+  ASSERT_EQ(clone->extractions()[1].outputName, "size");
+  ASSERT_TRUE(clone->extractions()[0].dataType->equivalent(*ARRAY(VARCHAR())));
+  ASSERT_TRUE(clone->extractions()[1].dataType->equivalent(*BIGINT()));
+}
+
+TEST(ColumnExtractionTest, complexChainWithKeyFilter) {
+  // Chain: [MapKeyFilter(["foo", "bar"]), MapValues, AE, StructField("x")]
+  // on MAP(VARCHAR, ROW(x: INT, y: INT)) -> ARRAY(INT).
+  Type::registerSerDe();
+  HiveColumnHandle::registerSerDe();
+
+  auto hiveType = MAP(VARCHAR(), ROW({{"x", INTEGER()}, {"y", INTEGER()}}));
+  auto outputType = ARRAY(INTEGER());
+  std::vector<NamedExtraction> extractions = {
+      {"col_x",
+       {ExtractionPathElement::mapKeyFilter(
+            std::vector<std::string>{"foo", "bar"}),
+        ExtractionPathElement::simple(ExtractionStep::kMapValues),
+        ExtractionPathElement::simple(ExtractionStep::kArrayElements),
+        ExtractionPathElement::structField("x")},
+       outputType}};
+
+  auto handle = std::make_shared<HiveColumnHandle>(
+      "col",
+      HiveColumnHandle::ColumnType::kRegular,
+      outputType,
+      hiveType,
+      std::vector<common::Subfield>{},
+      std::move(extractions));
+
+  ASSERT_EQ(handle->extractions().size(), 1);
+  ASSERT_EQ(handle->extractions()[0].chain.size(), 4);
+
+  // Verify key filter keys are preserved.
+  ASSERT_THAT(
+      static_cast<const StringMapKeyFilterExtractionPathElement&>(
+          *handle->extractions()[0].chain[0])
+          .filterKeys(),
+      testing::ElementsAre("foo", "bar"));
+
+  // Serialization round-trip.
+  auto obj = handle->serialize();
+  auto clone = ISerializable::deserialize<HiveColumnHandle>(obj);
+  ASSERT_EQ(clone->extractions().size(), 1);
+  ASSERT_EQ(clone->extractions()[0].chain.size(), 4);
+  ASSERT_THAT(
+      static_cast<const StringMapKeyFilterExtractionPathElement&>(
+          *clone->extractions()[0].chain[0])
+          .filterKeys(),
+      testing::ElementsAre("foo", "bar"));
+}
+
+TEST(ColumnExtractionTest, intFilterKeys) {
+  // MapKeyFilter with integer keys.
+  Type::registerSerDe();
+  HiveColumnHandle::registerSerDe();
+
+  auto hiveType = MAP(BIGINT(), VARCHAR());
+  auto outputType = MAP(BIGINT(), VARCHAR());
+  std::vector<NamedExtraction> extractions = {
+      {"filtered",
+       {ExtractionPathElement::mapKeyFilter(std::vector<int64_t>{1, 2, 3})},
+       outputType}};
+
+  auto handle = std::make_shared<HiveColumnHandle>(
+      "col",
+      HiveColumnHandle::ColumnType::kRegular,
+      outputType,
+      hiveType,
+      std::vector<common::Subfield>{},
+      std::move(extractions));
+
+  ASSERT_THAT(
+      static_cast<const IntMapKeyFilterExtractionPathElement&>(
+          *handle->extractions()[0].chain[0])
+          .filterKeys(),
+      testing::ElementsAre(1, 2, 3));
+
+  // Serialization round-trip.
+  auto obj = handle->serialize();
+  auto clone = ISerializable::deserialize<HiveColumnHandle>(obj);
+  ASSERT_THAT(
+      static_cast<const IntMapKeyFilterExtractionPathElement&>(
+          *clone->extractions()[0].chain[0])
+          .filterKeys(),
+      testing::ElementsAre(1, 2, 3));
+}
+
+TEST(ColumnExtractionTest, mutualExclusivity) {
+  // Cannot set both extractions and requiredSubfields.
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  std::vector<common::Subfield> requiredSubfields;
+  requiredSubfields.emplace_back("col[\"foo\"]");
+  std::vector<NamedExtraction> extractions = {
+      {"keys",
+       {ExtractionPathElement::simple(ExtractionStep::kMapKeys)},
+       ARRAY(VARCHAR())}};
+
+  VELOX_ASSERT_THROW(
+      std::make_shared<HiveColumnHandle>(
+          "col",
+          HiveColumnHandle::ColumnType::kRegular,
+          ARRAY(VARCHAR()),
+          hiveType,
+          std::move(requiredSubfields),
+          std::move(extractions)),
+      "mutually exclusive");
+}
+
+TEST(ColumnExtractionTest, extractionOutputTypeMismatch) {
+  // Declared output type doesn't match derived type.
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  std::vector<NamedExtraction> extractions = {
+      {"keys",
+       {ExtractionPathElement::simple(ExtractionStep::kMapKeys)},
+       // Wrong: should be ARRAY(VARCHAR), not ARRAY(BIGINT).
+       ARRAY(BIGINT())}};
+
+  VELOX_ASSERT_THROW(
+      std::make_shared<HiveColumnHandle>(
+          "col",
+          HiveColumnHandle::ColumnType::kRegular,
+          ARRAY(BIGINT()),
+          hiveType,
+          std::vector<common::Subfield>{},
+          std::move(extractions)),
+      "does not match derived type");
+}
+
+TEST(ColumnExtractionTest, noExtractionsBackwardCompatible) {
+  // Empty extractions: existing behavior, dataType must match hiveType.
+  auto type = MAP(VARCHAR(), BIGINT());
+  auto handle = std::make_shared<HiveColumnHandle>(
+      "col", HiveColumnHandle::ColumnType::kRegular, type, type);
+
+  ASSERT_TRUE(handle->extractions().empty());
+  ASSERT_TRUE(handle->requiredSubfields().empty());
+  ASSERT_TRUE(handle->dataType()->equivalent(*type));
+}
+
+TEST(ColumnExtractionTest, threeExtractionsFromSameColumn) {
+  // Three extractions: size, keys, and value subfield.
+  // col: MAP(BIGINT, ROW(a: VARCHAR, b: DOUBLE, c: INT))
+  Type::registerSerDe();
+  HiveColumnHandle::registerSerDe();
+
+  auto hiveType =
+      MAP(BIGINT(), ROW({{"a", VARCHAR()}, {"b", DOUBLE()}, {"c", INTEGER()}}));
+  auto szType = BIGINT();
+  auto keysType = ARRAY(BIGINT());
+  auto valsAType = ARRAY(VARCHAR());
+  auto rowOutputType =
+      ROW({{"sz", szType}, {"keys", keysType}, {"vals_a", valsAType}});
+
+  std::vector<NamedExtraction> extractions = {
+      {"sz", {ExtractionPathElement::simple(ExtractionStep::kSize)}, szType},
+      {"keys",
+       {ExtractionPathElement::simple(ExtractionStep::kMapKeys)},
+       keysType},
+      {"vals_a",
+       {ExtractionPathElement::simple(ExtractionStep::kMapValues),
+        ExtractionPathElement::simple(ExtractionStep::kArrayElements),
+        ExtractionPathElement::structField("a")},
+       valsAType}};
+
+  auto handle = std::make_shared<HiveColumnHandle>(
+      "col",
+      HiveColumnHandle::ColumnType::kRegular,
+      rowOutputType,
+      hiveType,
+      std::vector<common::Subfield>{},
+      std::move(extractions));
+
+  ASSERT_EQ(handle->extractions().size(), 3);
+
+  // Serialization round-trip.
+  auto obj = handle->serialize();
+  auto clone = ISerializable::deserialize<HiveColumnHandle>(obj);
+  ASSERT_EQ(clone->extractions().size(), 3);
+  ASSERT_EQ(clone->extractions()[0].outputName, "sz");
+  ASSERT_EQ(clone->extractions()[1].outputName, "keys");
+  ASSERT_EQ(clone->extractions()[2].outputName, "vals_a");
+  ASSERT_TRUE(clone->extractions()[0].dataType->equivalent(*BIGINT()));
+  ASSERT_TRUE(clone->extractions()[1].dataType->equivalent(*ARRAY(BIGINT())));
+  ASSERT_TRUE(clone->extractions()[2].dataType->equivalent(*ARRAY(VARCHAR())));
+}
+// --- Runtime extraction application tests ---
+
+class ExtractionUtilsTest : public testing::Test, public test::VectorTestBase {
+ protected:
+  static void SetUpTestSuite() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
+
+TEST_F(ExtractionUtilsTest, mapKeys) {
+  // Apply MapKeys to a MapVector.
+  auto mapVector = makeMapVector<std::string, int64_t>(
+      {{{{"a", 1}, {"b", 2}}}, {{{"c", 3}}}});
+
+  std::vector<EPE> chain = {
+      ExtractionPathElement::simple(ExtractionStep::kMapKeys)};
+  auto result = applyExtractionChain(mapVector, chain, pool());
+
+  ASSERT_TRUE(result->type()->isArray());
+  auto* array = result->as<ArrayVector>();
+  ASSERT_EQ(array->size(), 2);
+  // First map has 2 keys, second has 1.
+  ASSERT_EQ(array->sizeAt(0), 2);
+  ASSERT_EQ(array->sizeAt(1), 1);
+}
+
+TEST_F(ExtractionUtilsTest, mapValues) {
+  // Apply MapValues to a MapVector.
+  auto mapVector = makeMapVector<std::string, int64_t>(
+      {{{{"a", 10}, {"b", 20}}}, {{{"c", 30}}}});
+
+  std::vector<EPE> chain = {
+      ExtractionPathElement::simple(ExtractionStep::kMapValues)};
+  auto result = applyExtractionChain(mapVector, chain, pool());
+
+  ASSERT_TRUE(result->type()->isArray());
+  auto* array = result->as<ArrayVector>();
+  ASSERT_EQ(array->size(), 2);
+  ASSERT_EQ(array->sizeAt(0), 2);
+  ASSERT_EQ(array->sizeAt(1), 1);
+  // Check values.
+  auto* elements = array->elements()->as<FlatVector<int64_t>>();
+  ASSERT_EQ(elements->valueAt(0), 10);
+  ASSERT_EQ(elements->valueAt(1), 20);
+  ASSERT_EQ(elements->valueAt(2), 30);
+}
+
+TEST_F(ExtractionUtilsTest, sizeOnMap) {
+  // Apply Size to a MapVector.
+  auto mapVector = makeMapVector<std::string, int64_t>(
+      {{{{"a", 1}, {"b", 2}, {"c", 3}}}, {{{"d", 4}}}});
+
+  std::vector<EPE> chain = {
+      ExtractionPathElement::simple(ExtractionStep::kSize)};
+  auto result = applyExtractionChain(mapVector, chain, pool());
+
+  ASSERT_TRUE(result->type()->isBigint());
+  auto* sizes = result->as<FlatVector<int64_t>>();
+  ASSERT_EQ(sizes->size(), 2);
+  ASSERT_EQ(sizes->valueAt(0), 3);
+  ASSERT_EQ(sizes->valueAt(1), 1);
+}
+
+TEST_F(ExtractionUtilsTest, sizeOnArray) {
+  // Apply Size to an ArrayVector.
+  auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3}, {4, 5}});
+
+  std::vector<EPE> chain = {
+      ExtractionPathElement::simple(ExtractionStep::kSize)};
+  auto result = applyExtractionChain(arrayVector, chain, pool());
+
+  ASSERT_TRUE(result->type()->isBigint());
+  auto* sizes = result->as<FlatVector<int64_t>>();
+  ASSERT_EQ(sizes->size(), 2);
+  ASSERT_EQ(sizes->valueAt(0), 3);
+  ASSERT_EQ(sizes->valueAt(1), 2);
+}
+
+TEST_F(ExtractionUtilsTest, structField) {
+  // Apply StructField to a RowVector.
+  auto rowVector = makeRowVector(
+      {"x", "y"},
+      {makeFlatVector<int32_t>({10, 20}), makeFlatVector<int32_t>({30, 40})});
+
+  std::vector<EPE> chain = {ExtractionPathElement::structField("x")};
+  auto result = applyExtractionChain(rowVector, chain, pool());
+
+  ASSERT_TRUE(result->type()->isInteger());
+  auto* flat = result->as<FlatVector<int32_t>>();
+  ASSERT_EQ(flat->valueAt(0), 10);
+  ASSERT_EQ(flat->valueAt(1), 20);
+}
+
+TEST_F(ExtractionUtilsTest, mapKeyFilter) {
+  // Apply MapKeyFilter to filter specific keys.
+  auto mapVector = makeMapVector<std::string, int64_t>(
+      {{{{"a", 1}, {"b", 2}, {"c", 3}}}, {{{"a", 10}, {"d", 40}}}});
+
+  std::vector<EPE> chain = {
+      ExtractionPathElement::mapKeyFilter(std::vector<std::string>{"a", "c"})};
+  auto result = applyExtractionChain(mapVector, chain, pool());
+
+  ASSERT_TRUE(result->type()->isMap());
+  auto* filteredMap = result->as<MapVector>();
+  ASSERT_EQ(filteredMap->size(), 2);
+  // First map: "a" and "c" kept (2 out of 3).
+  ASSERT_EQ(filteredMap->sizeAt(0), 2);
+  // Second map: only "a" kept (1 out of 2).
+  ASSERT_EQ(filteredMap->sizeAt(1), 1);
+}
+
+TEST_F(ExtractionUtilsTest, chainMapValuesStructField) {
+  // Chain: [MapValues, ArrayElements, StructField("x")]
+  // on MAP(VARCHAR, ROW(x: INT, y: INT)) -> ARRAY(INT).
+  auto keys = makeFlatVector<StringView>({"k1", "k2", "k3"});
+  auto structValues = makeRowVector(
+      {"x", "y"},
+      {makeFlatVector<int32_t>({10, 20, 30}),
+       makeFlatVector<int32_t>({100, 200, 300})});
+  auto mapVector = makeMapVector({0, 2}, keys, structValues);
+
+  std::vector<EPE> chain = {
+      ExtractionPathElement::simple(ExtractionStep::kMapValues),
+      ExtractionPathElement::simple(ExtractionStep::kArrayElements),
+      ExtractionPathElement::structField("x")};
+  auto result = applyExtractionChain(mapVector, chain, pool());
+
+  // Output should be ARRAY(INT).
+  ASSERT_TRUE(result->type()->isArray());
+  auto* array = result->as<ArrayVector>();
+  ASSERT_EQ(array->size(), 2);
+  // First map had 2 entries, second had 1.
+  ASSERT_EQ(array->sizeAt(0), 2);
+  ASSERT_EQ(array->sizeAt(1), 1);
+  auto* elements = array->elements()->as<FlatVector<int32_t>>();
+  ASSERT_EQ(elements->valueAt(0), 10);
+  ASSERT_EQ(elements->valueAt(1), 20);
+  ASSERT_EQ(elements->valueAt(2), 30);
+}
+
+TEST_F(ExtractionUtilsTest, emptyChain) {
+  // Empty chain should return the input unchanged.
+  auto mapVector = makeMapVector<std::string, int64_t>({{{{"a", 1}}}});
+  std::vector<EPE> chain = {};
+  auto result = applyExtractionChain(mapVector, chain, pool());
+  ASSERT_EQ(result.get(), mapVector.get());
+}
diff --git a/velox/connectors/tests/CMakeLists.txt b/velox/connectors/tests/CMakeLists.txt
index b70f227b41e..ff2f31ea83a 100644
--- a/velox/connectors/tests/CMakeLists.txt
+++ b/velox/connectors/tests/CMakeLists.txt
@@ -17,6 +17,10 @@ add_test(velox_connector_test velox_connector_test)
 target_link_libraries(
   velox_connector_test
   velox_connector
+  velox_connector_registry
+  velox_core
+  velox_memory
+  GTest::gmock
   GTest::gtest
   GTest::gtest_main
   glog::glog
diff --git a/velox/connectors/tests/ConnectorTest.cpp b/velox/connectors/tests/ConnectorTest.cpp
index a58cf822777..2adc5ee91d0 100644
--- a/velox/connectors/tests/ConnectorTest.cpp
+++ b/velox/connectors/tests/ConnectorTest.cpp
@@ -15,15 +15,18 @@
  */
 
 #include "velox/connectors/Connector.h"
-#include "velox/common/base/tests/GTestUtils.h"
-#include "velox/common/config/Config.h"
 
-#include <gtest/gtest.h>
+#include <memory>
+#include <utility>
 
-namespace facebook::velox::connector {
+#include <fmt/format.h>
+#include <gtest/gtest.h>
 
-class ConnectorTest : public testing::Test {};
+#include "velox/common/memory/Memory.h"
+#include "velox/connectors/ConnectorRegistry.h"
+#include "velox/core/QueryCtx.h"
 
+namespace facebook::velox::connector {
 namespace {
 
 class TestConnector : public connector::Connector {
@@ -47,54 +50,135 @@ class TestConnector : public connector::Connector {
   }
 };
 
-class TestConnectorFactory : public connector::ConnectorFactory {
- public:
-  static constexpr const char* kConnectorFactoryName = "test-factory";
-
-  TestConnectorFactory() : ConnectorFactory(kConnectorFactoryName) {}
-
-  std::shared_ptr<Connector> newConnector(
-      const std::string& id,
-      std::shared_ptr<const config::ConfigBase> /*config*/,
-      folly::Executor* /*ioExecutor*/ = nullptr,
-      folly::Executor* /*cpuExecutor*/ = nullptr) override {
-    return std::make_shared<TestConnector>(id);
-  }
-};
-
-} // namespace
-
-TEST_F(ConnectorTest, getAllConnectors) {
-  registerConnectorFactory(std::make_shared<TestConnectorFactory>());
-  VELOX_ASSERT_THROW(
-      registerConnectorFactory(std::make_shared<TestConnectorFactory>()),
-      "ConnectorFactory with name 'test-factory' is already registered");
-  EXPECT_TRUE(hasConnectorFactory(TestConnectorFactory::kConnectorFactoryName));
+TEST(ConnectorTest, registryOperations) {
   const int32_t numConnectors = 10;
   for (int32_t i = 0; i < numConnectors; i++) {
-    registerConnector(
-        getConnectorFactory(TestConnectorFactory::kConnectorFactoryName)
-            ->newConnector(
-                fmt::format("connector-{}", i),
-                std::make_shared<config::ConfigBase>(
-                    std::unordered_map<std::string, std::string>())));
+    auto connector =
+        std::make_shared<TestConnector>(fmt::format("connector-{}", i));
+    auto connectorId = connector->connectorId();
+    ConnectorRegistry::global().insert(
+        std::move(connectorId), std::move(connector));
   }
-  const auto& connectors = getAllConnectors();
-  EXPECT_EQ(connectors.size(), numConnectors);
+
   for (int32_t i = 0; i < numConnectors; i++) {
-    EXPECT_EQ(connectors.count(fmt::format("connector-{}", i)), 1);
+    EXPECT_NE(
+        ConnectorRegistry::tryGet(fmt::format("connector-{}", i)), nullptr);
   }
-  for (int32_t i = 0; i < numConnectors; i++) {
-    unregisterConnector(fmt::format("connector-{}", i));
+  EXPECT_EQ(ConnectorRegistry::tryGet("nonexistent"), nullptr);
+
+  auto allTestConnectors = ConnectorRegistry::findAll<TestConnector>();
+  EXPECT_EQ(allTestConnectors.size(), numConnectors);
+
+  ConnectorRegistry::unregisterAll();
+  EXPECT_EQ(ConnectorRegistry::findAll<TestConnector>().size(), 0);
+}
+
+class ConnectorRegistryTest : public testing::Test {
+ protected:
+  static void SetUpTestSuite() {
+    memory::MemoryManager::testingSetInstance({});
   }
-  EXPECT_EQ(getAllConnectors().size(), 0);
-  EXPECT_TRUE(
-      unregisterConnectorFactory(TestConnectorFactory::kConnectorFactoryName));
-  EXPECT_FALSE(
-      unregisterConnectorFactory(TestConnectorFactory::kConnectorFactoryName));
+};
+
+TEST_F(ConnectorRegistryTest, queryScopedOverride) {
+  auto globalConnector = std::make_shared<TestConnector>("global");
+  ConnectorRegistry::global().insert("catalog", globalConnector);
+
+  auto queryCtx = core::QueryCtx::create();
+  auto queryRegistry = ConnectorRegistry::create(&ConnectorRegistry::global());
+  auto queryConnector = std::make_shared<TestConnector>("query-override");
+  queryRegistry->insert("catalog", queryConnector);
+  queryCtx->setRegistry(ConnectorRegistry::kRegistryKey, queryRegistry);
+
+  // Query-scoped lookup returns the override.
+  EXPECT_EQ(ConnectorRegistry::tryGet(*queryCtx, "catalog"), queryConnector);
+  // Global lookup returns the global connector.
+  EXPECT_EQ(ConnectorRegistry::tryGet("catalog"), globalConnector);
+
+  ConnectorRegistry::unregisterAll();
+}
+
+TEST_F(ConnectorRegistryTest, queryScopedFallbackToGlobal) {
+  auto globalConnector = std::make_shared<TestConnector>("global");
+  ConnectorRegistry::global().insert("catalog", globalConnector);
+
+  auto queryCtx = core::QueryCtx::create();
+  auto queryRegistry = ConnectorRegistry::create(&ConnectorRegistry::global());
+  queryCtx->setRegistry(ConnectorRegistry::kRegistryKey, queryRegistry);
+
+  // Empty per-query registry falls back to global.
+  EXPECT_EQ(ConnectorRegistry::tryGet(*queryCtx, "catalog"), globalConnector);
+
+  ConnectorRegistry::unregisterAll();
+}
+
+TEST_F(ConnectorRegistryTest, noQueryRegistryFallsBackToGlobal) {
+  auto globalConnector = std::make_shared<TestConnector>("global");
+  ConnectorRegistry::global().insert("catalog", globalConnector);
+
+  // QueryCtx with no per-query registry set.
+  auto queryCtx = core::QueryCtx::create();
+  EXPECT_EQ(ConnectorRegistry::tryGet(*queryCtx, "catalog"), globalConnector);
+
+  ConnectorRegistry::unregisterAll();
+}
+
+TEST_F(ConnectorRegistryTest, queryScopedUnregisterAll) {
+  auto globalConnector = std::make_shared<TestConnector>("global");
+  ConnectorRegistry::global().insert("catalog", globalConnector);
+
+  auto queryCtx = core::QueryCtx::create();
+  auto queryRegistry = ConnectorRegistry::create(&ConnectorRegistry::global());
+  queryRegistry->insert("catalog", std::make_shared<TestConnector>("query"));
+  queryCtx->setRegistry(ConnectorRegistry::kRegistryKey, queryRegistry);
+
+  ConnectorRegistry::unregisterAll(*queryCtx);
+
+  // Query-scoped registry cleared; falls back to global.
+  EXPECT_EQ(ConnectorRegistry::tryGet(*queryCtx, "catalog"), globalConnector);
+  // Global is untouched.
+  EXPECT_EQ(ConnectorRegistry::tryGet("catalog"), globalConnector);
+
+  ConnectorRegistry::unregisterAll();
 }
 
-TEST_F(ConnectorTest, connectorSplit) {
+// Verify that unregisterAll on a queryCtx without a per-query registry does
+// not clear the global registry.
+TEST_F(ConnectorRegistryTest, unregisterAllNoQueryRegistry) {
+  auto globalConnector = std::make_shared<TestConnector>("global");
+  ConnectorRegistry::global().insert("catalog", globalConnector);
+
+  auto queryCtx = core::QueryCtx::create();
+  ConnectorRegistry::unregisterAll(*queryCtx);
+
+  // Global registry is untouched.
+  EXPECT_EQ(ConnectorRegistry::tryGet("catalog"), globalConnector);
+
+  ConnectorRegistry::unregisterAll();
+}
+
+TEST_F(ConnectorRegistryTest, queryScopedFindAll) {
+  ConnectorRegistry::global().insert(
+      "global-cat", std::make_shared<TestConnector>("global-cat"));
+
+  auto queryCtx = core::QueryCtx::create();
+  auto queryRegistry = ConnectorRegistry::create(&ConnectorRegistry::global());
+  queryRegistry->insert(
+      "query-cat", std::make_shared<TestConnector>("query-cat"));
+  queryCtx->setRegistry(ConnectorRegistry::kRegistryKey, queryRegistry);
+
+  // findAll with queryCtx sees both query-scoped and global connectors.
+  auto all = ConnectorRegistry::findAll<TestConnector>(*queryCtx);
+  EXPECT_EQ(all.size(), 2);
+
+  // findAll without queryCtx sees only global.
+  auto globalOnly = ConnectorRegistry::findAll<TestConnector>();
+  EXPECT_EQ(globalOnly.size(), 1);
+
+  ConnectorRegistry::unregisterAll();
+}
+
+TEST(ConnectorTest, connectorSplit) {
   {
     const ConnectorSplit split("test", 100, true);
     ASSERT_EQ(split.connectorId, "test");
@@ -114,4 +198,5 @@ TEST_F(ConnectorTest, connectorSplit) {
         "[split: connector id test, weight 50, cacheable false]");
   }
 }
+} // namespace
 } // namespace facebook::velox::connector
diff --git a/velox/connectors/tpcds/CMakeLists.txt b/velox/connectors/tpcds/CMakeLists.txt
index 4c92a290f13..d05ff0b3ce0 100644
--- a/velox/connectors/tpcds/CMakeLists.txt
+++ b/velox/connectors/tpcds/CMakeLists.txt
@@ -12,7 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_tpcds_connector TpcdsConnector.cpp)
+velox_add_library(
+  velox_tpcds_connector
+  TpcdsConnector.cpp
+  HEADERS
+  TpcdsConnector.h
+  TpcdsConnectorSplit.h
+)
 velox_link_libraries(velox_tpcds_connector PUBLIC velox_connector velox_tpcds_gen PRIVATE fmt::fmt)
 
 if(${VELOX_BUILD_TESTING})
diff --git a/velox/connectors/tpcds/TpcdsConnector.cpp b/velox/connectors/tpcds/TpcdsConnector.cpp
index 5902f49da4c..b981bda903a 100644
--- a/velox/connectors/tpcds/TpcdsConnector.cpp
+++ b/velox/connectors/tpcds/TpcdsConnector.cpp
@@ -65,7 +65,7 @@ TpcdsDataSource::TpcdsDataSource(
         handle,
         "ColumnHandle must be an instance of TpcdsColumnHandle "
         "for '{}' on table '{}'",
-        handle->name(),
+        it->second->name(),
         toTableName(table_));
 
     auto idx = tpcdsTableSchema->getChildIdxIfExists(handle->name());
diff --git a/velox/connectors/tpcds/TpcdsConnector.h b/velox/connectors/tpcds/TpcdsConnector.h
index 88ad845ff39..329114d9005 100644
--- a/velox/connectors/tpcds/TpcdsConnector.h
+++ b/velox/connectors/tpcds/TpcdsConnector.h
@@ -102,7 +102,7 @@ class TpcdsDataSource : public velox::connector::DataSource {
     return completedBytes_;
   }
 
-  std::unordered_map<std::string, RuntimeCounter> runtimeStats() override {
+  std::unordered_map<std::string, RuntimeMetric> getRuntimeStats() override {
     return {};
   }
 
diff --git a/velox/connectors/tpcds/TpcdsConnectorSplit.h b/velox/connectors/tpcds/TpcdsConnectorSplit.h
index 1f51eb22af6..80fb8863e76 100644
--- a/velox/connectors/tpcds/TpcdsConnectorSplit.h
+++ b/velox/connectors/tpcds/TpcdsConnectorSplit.h
@@ -53,8 +53,8 @@ template <>
 struct fmt::formatter<facebook::velox::connector::tpcds::TpcdsConnectorSplit>
     : formatter<std::string> {
   auto format(
-      facebook::velox::connector::tpcds::TpcdsConnectorSplit s,
-      format_context& ctx) {
+      facebook::velox::connector::tpcds::TpcdsConnectorSplit const& s,
+      format_context& ctx) const {
     return formatter<std::string>::format(s.toString(), ctx);
   }
 };
@@ -64,8 +64,9 @@ struct fmt::formatter<
     std::shared_ptr<facebook::velox::connector::tpcds::TpcdsConnectorSplit>>
     : formatter<std::string> {
   auto format(
-      std::shared_ptr<facebook::velox::connector::tpcds::TpcdsConnectorSplit> s,
-      format_context& ctx) {
+      std::shared_ptr<
+          facebook::velox::connector::tpcds::TpcdsConnectorSplit> const& s,
+      format_context& ctx) const {
     return formatter<std::string>::format(s->toString(), ctx);
   }
 };
diff --git a/velox/connectors/tpcds/tests/TpcdsConnectorTest.cpp b/velox/connectors/tpcds/tests/TpcdsConnectorTest.cpp
index 987a0a9e058..c03cddbd8bf 100644
--- a/velox/connectors/tpcds/tests/TpcdsConnectorTest.cpp
+++ b/velox/connectors/tpcds/tests/TpcdsConnectorTest.cpp
@@ -17,6 +17,7 @@
 #include "velox/connectors/tpcds/TpcdsConnector.h"
 #include <folly/init/Init.h>
 #include "gtest/gtest.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
@@ -35,18 +36,20 @@ class TpcdsConnectorTest : public exec::test::OperatorTestBase {
         kTpcdsConnectorId,
         std::make_shared<config::ConfigBase>(
             std::unordered_map<std::string, std::string>()));
-    connector::registerConnector(connector);
+    connector::ConnectorRegistry::global().insert(
+        connector->connectorId(), connector);
   }
 
   void TearDown() override {
-    connector::unregisterConnector(kTpcdsConnectorId);
+    connector::ConnectorRegistry::global().erase(kTpcdsConnectorId);
     OperatorTestBase::TearDown();
   }
 
   exec::Split makeTpcdsSplit(size_t totalParts = 1, size_t partNumber = 0)
       const {
-    return exec::Split(std::make_shared<TpcdsConnectorSplit>(
-        kTpcdsConnectorId, /*cacheable=*/true, totalParts, partNumber));
+    return exec::Split(
+        std::make_shared<TpcdsConnectorSplit>(
+            kTpcdsConnectorId, /*cacheable=*/true, totalParts, partNumber));
   }
 
   RowVectorPtr getResults(
@@ -118,8 +121,9 @@ TEST_F(TpcdsConnectorTest, singleColumnWithAlias) {
   auto plan = exec::test::PlanBuilder()
                   .startTableScan()
                   .outputType(outputType)
-                  .tableHandle(std::make_shared<TpcdsTableHandle>(
-                      kTpcdsConnectorId, velox::tpcds::Table::TBL_ITEM))
+                  .tableHandle(
+                      std::make_shared<TpcdsTableHandle>(
+                          kTpcdsConnectorId, velox::tpcds::Table::TBL_ITEM))
                   .assignments({
                       {aliasedName,
                        std::make_shared<TpcdsColumnHandle>("i_product_name")},
diff --git a/velox/connectors/tpch/CMakeLists.txt b/velox/connectors/tpch/CMakeLists.txt
index 43ebe514b28..20c3fc632bb 100644
--- a/velox/connectors/tpch/CMakeLists.txt
+++ b/velox/connectors/tpch/CMakeLists.txt
@@ -12,7 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_tpch_connector OBJECT TpchConnector.cpp)
+velox_add_library(
+  velox_tpch_connector
+  OBJECT
+  TpchConnector.cpp
+  HEADERS
+  TpchConnector.h
+  TpchConnectorSplit.h
+)
 
 velox_link_libraries(
   velox_tpch_connector
diff --git a/velox/connectors/tpch/TpchConnector.h b/velox/connectors/tpch/TpchConnector.h
index 5d006490bad..3325b9dee5c 100644
--- a/velox/connectors/tpch/TpchConnector.h
+++ b/velox/connectors/tpch/TpchConnector.h
@@ -34,10 +34,28 @@ class TpchColumnHandle : public ColumnHandle {
  public:
   explicit TpchColumnHandle(const std::string& name) : name_(name) {}
 
-  const std::string& name() const {
+  const std::string& name() const override {
     return name_;
   }
 
+  folly::dynamic serialize() const override {
+    folly::dynamic obj = folly::dynamic::object;
+    obj["name"] = TpchColumnHandle::getClassName();
+    obj["columnName"] = name_;
+    return obj;
+  }
+
+  static std::shared_ptr<TpchColumnHandle> create(const folly::dynamic& obj) {
+    auto name = obj["columnName"].asString();
+    return std::make_shared<TpchColumnHandle>(name);
+  }
+
+  static void registerSerDe() {
+    registerDeserializer<TpchColumnHandle>();
+  }
+
+  VELOX_DEFINE_CLASS_NAME(TpchColumnHandle)
+
  private:
   const std::string name_;
 };
@@ -83,6 +101,40 @@ class TpchTableHandle : public ConnectorTableHandle {
     return scaleFactor_;
   }
 
+  folly::dynamic serialize() const override {
+    folly::dynamic obj = folly::dynamic::object;
+    obj["name"] = TpchTableHandle::getClassName();
+    obj["connectorId"] = connectorId();
+    obj["table"] = static_cast<int>(table_);
+    obj["scaleFactor"] = scaleFactor_;
+    if (filterExpression_) {
+      obj["filterExpression"] = filterExpression_->serialize();
+    }
+    return obj;
+  }
+
+  static ConnectorTableHandlePtr create(
+      const folly::dynamic& obj,
+      void* context) {
+    auto connectorId = obj["connectorId"].asString();
+    auto table = static_cast<velox::tpch::Table>(obj["table"].asInt());
+    auto scaleFactor = obj["scaleFactor"].asDouble();
+    velox::core::TypedExprPtr filterExpression = nullptr;
+    if (obj.count("filterExpression") && !obj["filterExpression"].isNull()) {
+      filterExpression =
+          velox::ISerializable::deserialize<velox::core::ITypedExpr>(
+              obj["filterExpression"], context);
+    }
+    return std::make_shared<TpchTableHandle>(
+        connectorId, table, scaleFactor, std::move(filterExpression));
+  }
+
+  static void registerSerDe() {
+    registerDeserializerWithContext<TpchTableHandle>();
+  }
+
+  VELOX_DEFINE_CLASS_NAME(TpchTableHandle)
+
  private:
   const velox::tpch::Table table_;
   double scaleFactor_;
@@ -117,7 +169,7 @@ class TpchDataSource : public DataSource {
     return completedBytes_;
   }
 
-  std::unordered_map<std::string, RuntimeCounter> runtimeStats() override {
+  std::unordered_map<std::string, RuntimeMetric> getRuntimeStats() override {
     // TODO: Which stats do we want to expose here?
     return {};
   }
@@ -179,6 +231,12 @@ class TpchConnector final : public Connector {
       CommitStrategy /*commitStrategy*/) override final {
     VELOX_NYI("TpchConnector does not support data sink.");
   }
+
+  static void registerSerDe() {
+    TpchTableHandle::registerSerDe();
+    TpchColumnHandle::registerSerDe();
+    TpchConnectorSplit::registerSerDe();
+  }
 };
 
 class TpchConnectorFactory : public ConnectorFactory {
diff --git a/velox/connectors/tpch/TpchConnectorSplit.h b/velox/connectors/tpch/TpchConnectorSplit.h
index b4b5420d1f9..7aa962d6a4e 100644
--- a/velox/connectors/tpch/TpchConnectorSplit.h
+++ b/velox/connectors/tpch/TpchConnectorSplit.h
@@ -32,19 +32,45 @@ struct TpchConnectorSplit : public connector::ConnectorSplit {
       bool cacheable,
       size_t totalParts,
       size_t partNumber)
-      : ConnectorSplit(connectorId, /*_splitWeight=*/0, cacheable),
+      : ConnectorSplit(connectorId, /*_splitWeight=*/1, cacheable),
         totalParts(totalParts),
         partNumber(partNumber) {
     VELOX_CHECK_GE(totalParts, 1, "totalParts must be >= 1");
     VELOX_CHECK_GT(totalParts, partNumber, "totalParts must be > partNumber");
   }
 
+  folly::dynamic serialize() const override {
+    folly::dynamic obj = folly::dynamic::object;
+    obj["name"] = TpchConnectorSplit::getClassName();
+    obj["connectorId"] = connectorId;
+    obj["splitWeight"] = splitWeight;
+    obj["cacheable"] = cacheable;
+    obj["totalParts"] = totalParts;
+    obj["partNumber"] = partNumber;
+    return obj;
+  }
+
+  static std::shared_ptr<TpchConnectorSplit> create(const folly::dynamic& obj) {
+    auto connectorId = obj["connectorId"].asString();
+    auto cacheable = obj["cacheable"].asBool();
+    auto totalParts = static_cast<size_t>(obj["totalParts"].asInt());
+    auto partNumber = static_cast<size_t>(obj["partNumber"].asInt());
+    return std::make_shared<TpchConnectorSplit>(
+        connectorId, cacheable, totalParts, partNumber);
+  }
+
+  static void registerSerDe() {
+    registerDeserializer<TpchConnectorSplit>();
+  }
+
   // In how many parts the generated TPC-H table will be segmented, roughly
   // `rowCount / totalParts`
   size_t totalParts{1};
 
   // Which of these parts will be read by this split.
   size_t partNumber{0};
+
+  VELOX_DEFINE_CLASS_NAME(TpchConnectorSplit)
 };
 
 } // namespace facebook::velox::connector::tpch
diff --git a/velox/connectors/tpch/tests/CMakeLists.txt b/velox/connectors/tpch/tests/CMakeLists.txt
index eb4f2718516..63477670d4f 100644
--- a/velox/connectors/tpch/tests/CMakeLists.txt
+++ b/velox/connectors/tpch/tests/CMakeLists.txt
@@ -11,7 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-add_executable(velox_tpch_connector_test TpchConnectorTest.cpp)
+add_executable(velox_tpch_connector_test TpchConnectorTest.cpp TpchConnectorSerDeTest.cpp)
 
 add_test(velox_tpch_connector_test velox_tpch_connector_test)
 
diff --git a/velox/connectors/tpch/tests/SpeedTest.cpp b/velox/connectors/tpch/tests/SpeedTest.cpp
index 180713b0a4e..1874b3cb460 100644
--- a/velox/connectors/tpch/tests/SpeedTest.cpp
+++ b/velox/connectors/tpch/tests/SpeedTest.cpp
@@ -19,6 +19,7 @@
 #include <chrono>
 
 #include "velox/common/memory/Memory.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/tpch/TpchConnector.h"
 #include "velox/connectors/tpch/TpchConnectorSplit.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
@@ -61,11 +62,12 @@ class TpchSpeedTest {
         kTpchConnectorId_,
         std::make_shared<config::ConfigBase>(
             std::unordered_map<std::string, std::string>()));
-    connector::registerConnector(tpchConnector);
+    connector::ConnectorRegistry::global().insert(
+        tpchConnector->connectorId(), tpchConnector);
   }
 
   ~TpchSpeedTest() {
-    connector::unregisterConnector(kTpchConnectorId_);
+    connector::ConnectorRegistry::global().erase(kTpchConnectorId_);
   }
 
   void run(tpch::Table table, size_t scaleFactor, size_t numSplits) {
@@ -117,8 +119,9 @@ class TpchSpeedTest {
     for (size_t i = 0; i < numSplits; ++i) {
       task.addSplit(
           scanId,
-          exec::Split(std::make_shared<connector::tpch::TpchConnectorSplit>(
-              kTpchConnectorId_, /*cacheable=*/true, numSplits, i)));
+          exec::Split(
+              std::make_shared<connector::tpch::TpchConnectorSplit>(
+                  kTpchConnectorId_, /*cacheable=*/true, numSplits, i)));
     }
 
     task.noMoreSplits(scanId);
diff --git a/velox/connectors/tpch/tests/TpchConnectorSerDeTest.cpp b/velox/connectors/tpch/tests/TpchConnectorSerDeTest.cpp
new file mode 100644
index 00000000000..5f700faf19c
--- /dev/null
+++ b/velox/connectors/tpch/tests/TpchConnectorSerDeTest.cpp
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include "velox/connectors/tpch/TpchConnector.h"
+#include "velox/connectors/tpch/TpchConnectorSplit.h"
+#include "velox/core/ITypedExpr.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox::connector::tpch::test {
+namespace {
+
+class TpchConnectorSerDeTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  TpchConnectorSerDeTest() {
+    Type::registerSerDe();
+    core::ITypedExpr::registerSerDe();
+    TpchConnector::registerSerDe();
+  }
+
+  template <typename T>
+  static void testSerde(const T& handle) {
+    auto str = handle.toString();
+    auto obj = handle.serialize();
+    auto clone = ISerializable::deserialize<T>(obj);
+    ASSERT_EQ(clone->toString(), str);
+  }
+
+  static void testSerde(const TpchColumnHandle& handle) {
+    auto obj = handle.serialize();
+    auto clone = ISerializable::deserialize<TpchColumnHandle>(obj);
+    ASSERT_EQ(handle.name(), clone->name());
+  }
+
+  static void testSerde(const TpchTableHandle& handle) {
+    auto str = handle.toString();
+    auto obj = handle.serialize();
+    auto pool = memory::memoryManager()->addLeafPool();
+    auto clone = ISerializable::deserialize<TpchTableHandle>(obj, pool.get());
+    ASSERT_EQ(clone->toString(), str);
+    ASSERT_EQ(handle.connectorId(), clone->connectorId());
+    ASSERT_EQ(handle.getTable(), clone->getTable());
+    ASSERT_EQ(handle.getScaleFactor(), clone->getScaleFactor());
+    if (handle.filterExpression()) {
+      ASSERT_NE(clone->filterExpression(), nullptr);
+      ASSERT_EQ(
+          handle.filterExpression()->toString(),
+          clone->filterExpression()->toString());
+    } else {
+      ASSERT_EQ(clone->filterExpression(), nullptr);
+    }
+  }
+
+  static void testSerde(const TpchConnectorSplit& split) {
+    auto str = split.toString();
+    auto obj = split.serialize();
+    auto clone = ISerializable::deserialize<TpchConnectorSplit>(obj);
+    ASSERT_EQ(clone->toString(), str);
+    ASSERT_EQ(split.connectorId, clone->connectorId);
+    ASSERT_EQ(split.splitWeight, clone->splitWeight);
+    ASSERT_EQ(split.cacheable, clone->cacheable);
+    ASSERT_EQ(split.totalParts, clone->totalParts);
+    ASSERT_EQ(split.partNumber, clone->partNumber);
+  }
+};
+
+TEST_F(TpchConnectorSerDeTest, tpchColumnHandle) {
+  auto handle1 = TpchColumnHandle("n_nationkey");
+  testSerde(handle1);
+
+  auto handle2 = TpchColumnHandle("l_orderkey");
+  testSerde(handle2);
+
+  auto handle3 = TpchColumnHandle("c_name");
+  testSerde(handle3);
+}
+
+TEST_F(TpchConnectorSerDeTest, tpchTableHandle) {
+  const std::string connectorId = "test-tpch";
+
+  auto handle1 = TpchTableHandle(connectorId, velox::tpch::Table::TBL_NATION);
+  testSerde(handle1);
+
+  auto handle2 =
+      TpchTableHandle(connectorId, velox::tpch::Table::TBL_LINEITEM, 10.0);
+  testSerde(handle2);
+
+  auto handle3 =
+      TpchTableHandle(connectorId, velox::tpch::Table::TBL_ORDERS, 0.01);
+  testSerde(handle3);
+
+  // Test with filterExpression
+  auto filterExpr =
+      std::make_shared<core::FieldAccessTypedExpr>(BIGINT(), "n_nationkey");
+  auto handle4 = TpchTableHandle(
+      connectorId, velox::tpch::Table::TBL_NATION, 1.0, filterExpr);
+  testSerde(handle4);
+
+  std::vector<velox::tpch::Table> tables = {
+      velox::tpch::Table::TBL_NATION,
+      velox::tpch::Table::TBL_REGION,
+      velox::tpch::Table::TBL_PART,
+      velox::tpch::Table::TBL_SUPPLIER,
+      velox::tpch::Table::TBL_PARTSUPP,
+      velox::tpch::Table::TBL_CUSTOMER,
+      velox::tpch::Table::TBL_ORDERS,
+      velox::tpch::Table::TBL_LINEITEM,
+  };
+
+  for (auto table : tables) {
+    testSerde(TpchTableHandle(connectorId, table, 1.0));
+  }
+
+  std::vector<double> scaleFactors = {0.01, 0.1, 1.0, 5.0, 10.0, 100.0, 1000.0};
+  for (auto sf : scaleFactors) {
+    testSerde(
+        TpchTableHandle(connectorId, velox::tpch::Table::TBL_CUSTOMER, sf));
+  }
+}
+
+TEST_F(TpchConnectorSerDeTest, tpchConnectorSplit) {
+  const std::string connectorId = "test-tpch";
+
+  auto split1 = TpchConnectorSplit(connectorId, false, 10, 5);
+  testSerde(split1);
+
+  auto split2 = TpchConnectorSplit(connectorId, true, 100, 99);
+  testSerde(split2);
+
+  auto split3 = TpchConnectorSplit(connectorId, 1, 0);
+  testSerde(split3);
+}
+
+} // namespace
+} // namespace facebook::velox::connector::tpch::test
diff --git a/velox/connectors/tpch/tests/TpchConnectorTest.cpp b/velox/connectors/tpch/tests/TpchConnectorTest.cpp
index 1d62b7f9577..2e991549f01 100644
--- a/velox/connectors/tpch/tests/TpchConnectorTest.cpp
+++ b/velox/connectors/tpch/tests/TpchConnectorTest.cpp
@@ -18,6 +18,7 @@
 #include <folly/init/Init.h>
 #include "gtest/gtest.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
@@ -44,18 +45,20 @@ class TpchConnectorTest : public exec::test::OperatorTestBase {
         kTpchConnectorId,
         std::make_shared<config::ConfigBase>(
             std::unordered_map<std::string, std::string>()));
-    connector::registerConnector(tpchConnector);
+    connector::ConnectorRegistry::global().insert(
+        tpchConnector->connectorId(), tpchConnector);
   }
 
   void TearDown() override {
-    connector::unregisterConnector(kTpchConnectorId);
+    connector::ConnectorRegistry::global().erase(kTpchConnectorId);
     OperatorTestBase::TearDown();
   }
 
   exec::Split makeTpchSplit(size_t totalParts = 1, size_t partNumber = 0)
       const {
-    return exec::Split(std::make_shared<TpchConnectorSplit>(
-        kTpchConnectorId, /*cacheable=*/true, totalParts, partNumber));
+    return exec::Split(
+        std::make_shared<TpchConnectorSplit>(
+            kTpchConnectorId, /*cacheable=*/true, totalParts, partNumber));
   }
 
   RowVectorPtr getResults(
@@ -132,8 +135,9 @@ TEST_F(TpchConnectorTest, singleColumnWithAlias) {
       PlanBuilder()
           .startTableScan()
           .outputType(outputType)
-          .tableHandle(std::make_shared<TpchTableHandle>(
-              kTpchConnectorId, Table::TBL_NATION))
+          .tableHandle(
+              std::make_shared<TpchTableHandle>(
+                  kTpchConnectorId, Table::TBL_NATION))
           .assignments({
               {aliasedName, std::make_shared<TpchColumnHandle>("n_name")},
               {"other_name", std::make_shared<TpchColumnHandle>("n_name")},
@@ -158,8 +162,9 @@ void TpchConnectorTest::runScaleFactorTest(double scaleFactor) {
   auto plan = PlanBuilder()
                   .startTableScan()
                   .outputType(ROW({}, {}))
-                  .tableHandle(std::make_shared<TpchTableHandle>(
-                      kTpchConnectorId, Table::TBL_SUPPLIER, scaleFactor))
+                  .tableHandle(
+                      std::make_shared<TpchTableHandle>(
+                          kTpchConnectorId, Table::TBL_SUPPLIER, scaleFactor))
                   .endTableScan()
                   .singleAggregation({}, {"count(1)"})
                   .planNode();
@@ -187,8 +192,9 @@ TEST_F(TpchConnectorTest, lineitemTinyRowCount) {
   auto plan = PlanBuilder()
                   .startTableScan()
                   .outputType(ROW({}, {}))
-                  .tableHandle(std::make_shared<TpchTableHandle>(
-                      kTpchConnectorId, Table::TBL_LINEITEM, 0.01))
+                  .tableHandle(
+                      std::make_shared<TpchTableHandle>(
+                          kTpchConnectorId, Table::TBL_LINEITEM, 0.01))
                   .endTableScan()
                   .singleAggregation({}, {"count(1)"})
                   .planNode();
diff --git a/velox/core/CMakeLists.txt b/velox/core/CMakeLists.txt
index 26fdad62a49..f68a88900da 100644
--- a/velox/core/CMakeLists.txt
+++ b/velox/core/CMakeLists.txt
@@ -25,6 +25,19 @@ velox_add_library(
   QueryConfig.cpp
   QueryCtx.cpp
   SimpleFunctionMetadata.cpp
+  TableWriteTraits.cpp
+  HEADERS
+  CoreTypeSystem.h
+  Expressions.h
+  ITypedExpr.h
+  PlanConsistencyChecker.h
+  PlanFragment.h
+  PlanNode.h
+  QueryConfig.h
+  QueryCtx.h
+  ScanBatchEvent.h
+  SimpleFunctionMetadata.h
+  TableWriteTraits.h
 )
 
 velox_link_libraries(
@@ -33,6 +46,7 @@ velox_link_libraries(
     velox_arrow_bridge
     velox_caching
     velox_common_config
+    velox_config_property
     velox_connector
     velox_exception
     velox_expression_functions
@@ -44,3 +58,10 @@ velox_link_libraries(
     fmt::fmt
   PRIVATE velox_encode
 )
+
+velox_add_library(velox_query_config_provider QueryConfigProvider.cpp HEADERS QueryConfigProvider.h)
+velox_link_libraries(velox_query_config_provider PUBLIC velox_core velox_config_property)
+
+velox_add_library(velox_metaprogramming INTERFACE HEADERS Metaprogramming.h)
+
+velox_add_library(velox_expression_evaluator INTERFACE HEADERS ExpressionEvaluator.h)
diff --git a/velox/core/Expressions.cpp b/velox/core/Expressions.cpp
index 7ab4c78d048..b1b512b4331 100644
--- a/velox/core/Expressions.cpp
+++ b/velox/core/Expressions.cpp
@@ -14,9 +14,13 @@
  * limitations under the License.
  */
 #include "velox/core/Expressions.h"
+
+#include <folly/hash/Hash.h>
+
 #include "velox/common/Casts.h"
 #include "velox/common/encode/Base64.h"
 #include "velox/vector/ComplexVector.h"
+#include "velox/vector/ConstantVector.h"
 #include "velox/vector/SimpleVector.h"
 #include "velox/vector/VectorSaver.h"
 
@@ -68,6 +72,7 @@ void ITypedExpr::registerSerDe() {
   registry.Register("FieldAccessTypedExpr", core::FieldAccessTypedExpr::create);
   registry.Register("InputTypedExpr", core::InputTypedExpr::create);
   registry.Register("LambdaTypedExpr", core::LambdaTypedExpr::create);
+  registry.Register("NullIfTypedExpr", core::NullIfTypedExpr::create);
 }
 
 void InputTypedExpr::accept(
@@ -87,6 +92,19 @@ TypedExprPtr InputTypedExpr::create(const folly::dynamic& obj, void* context) {
   return std::make_shared<InputTypedExpr>(std::move(type));
 }
 
+std::optional<bool> ConstantTypedExpr::toBool() const {
+  VELOX_CHECK(
+      this->type()->isBoolean(),
+      "Expected boolean expression, but got {}",
+      this->type()->toString());
+
+  if (!isNull()) {
+    return valueVector_ ? valueVector_->as<ConstantVector<bool>>()->valueAt(0)
+                        : value_.value<TypeKind::BOOLEAN>();
+  }
+  return std::nullopt;
+}
+
 void ConstantTypedExpr::accept(
     const ITypedExprVisitor& visitor,
     ITypedExprVisitorContext& context) const {
@@ -128,6 +146,12 @@ TypedExprPtr ConstantTypedExpr::create(
   return std::make_shared<ConstantTypedExpr>(restoreVector(dataStream, pool));
 }
 
+// static
+TypedExprPtr ConstantTypedExpr::makeNull(const TypePtr& type) {
+  return std::make_shared<core::ConstantTypedExpr>(
+      type, Variant::null(type->kind()));
+}
+
 std::string ConstantTypedExpr::toString() const {
   if (hasValueVector()) {
     return valueVector_->toString(0);
@@ -404,7 +428,8 @@ uint64_t hashImpl(const TypePtr& type, const Variant& value) {
 } // namespace
 
 size_t ConstantTypedExpr::localHash() const {
-  static const size_t kBaseHash = std::hash<const char*>()("ConstantTypedExpr");
+  static const size_t kBaseHash =
+      folly::hasher<std::string_view>()("ConstantTypedExpr");
 
   uint64_t h;
 
@@ -466,7 +491,7 @@ TypedExprPtr FieldAccessTypedExpr::rewriteInputNames(
   VELOX_CHECK_EQ(1, newInputs.size());
   // Only rewrite name if input in InputTypedExpr. Rewrite in other
   // cases(like dereference) is unsound.
-  if (!is_instance_of<InputTypedExpr>(newInputs[0])) {
+  if (!newInputs[0]->isInputKind()) {
     return std::make_shared<FieldAccessTypedExpr>(type(), newInputs[0], name_);
   }
   auto it = mapping.find(name_);
@@ -663,4 +688,63 @@ TypedExprPtr CastTypedExpr::create(const folly::dynamic& obj, void* context) {
       std::move(type), std::move(inputs), obj["isTryCast"].asBool());
 }
 
+NullIfTypedExpr::NullIfTypedExpr(
+    TypedExprPtr value,
+    TypedExprPtr comparand,
+    TypePtr commonType)
+    : ITypedExpr{ExprKind::kNullIf, value->type(), {std::move(value), std::move(comparand)}},
+      commonType_(std::move(commonType)) {}
+
+TypedExprPtr NullIfTypedExpr::rewriteInputNames(
+    const std::unordered_map<std::string, TypedExprPtr>& mapping) const {
+  auto newInputs = rewriteInputsRecursive(mapping);
+  return std::make_shared<NullIfTypedExpr>(
+      std::move(newInputs[0]), std::move(newInputs[1]), commonType_);
+}
+
+size_t NullIfTypedExpr::localHash() const {
+  static const size_t kBaseHash =
+      folly::hasher<std::string_view>()("NullIfTypedExpr");
+  return bits::hashMix(kBaseHash, commonType_->hashKind());
+}
+
+bool NullIfTypedExpr::operator==(const ITypedExpr& other) const {
+  const auto* otherNullIf = dynamic_cast<const NullIfTypedExpr*>(&other);
+  if (!otherNullIf) {
+    return false;
+  }
+  return *type() == *otherNullIf->type() &&
+      *commonType_ == *otherNullIf->commonType_ &&
+      *inputs()[0] == *otherNullIf->inputs()[0] &&
+      *inputs()[1] == *otherNullIf->inputs()[1];
+}
+
+std::string NullIfTypedExpr::toString() const {
+  return fmt::format(
+      "nullif({}, {})", inputs()[0]->toString(), inputs()[1]->toString());
+}
+
+void NullIfTypedExpr::accept(
+    const ITypedExprVisitor& visitor,
+    ITypedExprVisitorContext& context) const {
+  visitor.visit(*this, context);
+}
+
+folly::dynamic NullIfTypedExpr::serialize() const {
+  auto obj = ITypedExpr::serializeBase("NullIfTypedExpr");
+  obj["commonType"] = commonType_->serialize();
+  return obj;
+}
+
+// static
+TypedExprPtr NullIfTypedExpr::create(const folly::dynamic& obj, void* context) {
+  auto type = core::deserializeType(obj, context);
+  auto inputs = deserializeInputs(obj, context);
+  auto commonType = ISerializable::deserialize<Type>(obj["commonType"]);
+
+  VELOX_CHECK_EQ(inputs.size(), 2);
+  return std::make_shared<NullIfTypedExpr>(
+      std::move(inputs[0]), std::move(inputs[1]), std::move(commonType));
+}
+
 } // namespace facebook::velox::core
diff --git a/velox/core/Expressions.h b/velox/core/Expressions.h
index 699351d98bd..0eb5db006bd 100644
--- a/velox/core/Expressions.h
+++ b/velox/core/Expressions.h
@@ -15,6 +15,8 @@
  */
 #pragma once
 
+#include <folly/hash/Hash.h>
+
 #include "velox/common/Casts.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/core/ITypedExpr.h"
@@ -28,7 +30,7 @@ class InputTypedExpr : public ITypedExpr {
       : ITypedExpr{ExprKind::kInput, std::move(type)} {}
 
   bool operator==(const ITypedExpr& other) const final {
-    return is_instance_of<InputTypedExpr>(&other);
+    return other.isInputKind();
   }
 
   std::string toString() const override {
@@ -36,7 +38,8 @@ class InputTypedExpr : public ITypedExpr {
   }
 
   size_t localHash() const override {
-    static const size_t kBaseHash = std::hash<const char*>()("InputTypedExpr");
+    static const size_t kBaseHash =
+        folly::hasher<std::string_view>()("InputTypedExpr");
     return kBaseHash;
   }
 
@@ -61,7 +64,13 @@ class ConstantTypedExpr : public ITypedExpr {
   // Variant::null() value is supported.
   ConstantTypedExpr(TypePtr type, Variant value)
       : ITypedExpr{ExprKind::kConstant, std::move(type)},
-        value_{std::move(value)} {}
+        value_{std::move(value)} {
+    VELOX_CHECK(
+        value_.isTypeCompatible(ITypedExpr::type()),
+        "Expression type {} does not match variant type {}",
+        ITypedExpr::type()->toString(),
+        value_.inferType()->toString());
+  }
 
   // Creates constant expression of scalar or complex type. The value comes from
   // index zero.
@@ -108,6 +117,10 @@ class ConstantTypedExpr : public ITypedExpr {
     return BaseVector::createConstant(type(), value_, 1, pool);
   }
 
+  /// Returns value of boolean expression, std::nullopt for null booleans.
+  /// Throws an error if expression is not of boolean type.
+  std::optional<bool> toBool() const;
+
   const std::vector<TypedExprPtr>& inputs() const {
     static const std::vector<TypedExprPtr> kEmpty{};
     return kEmpty;
@@ -141,6 +154,9 @@ class ConstantTypedExpr : public ITypedExpr {
 
   static TypedExprPtr create(const folly::dynamic& obj, void* context);
 
+  /// Returns a NULL constant expression of given type.
+  static TypedExprPtr makeNull(const TypePtr& type);
+
  private:
   const Variant value_;
   const VectorPtr valueVector_;
@@ -213,8 +229,9 @@ class CallTypedExpr : public ITypedExpr {
   std::string toString() const override;
 
   size_t localHash() const override {
-    static const size_t kBaseHash = std::hash<const char*>()("CallTypedExpr");
-    return bits::hashMix(kBaseHash, std::hash<std::string>()(name_));
+    static const size_t kBaseHash =
+        folly::hasher<std::string_view>()("CallTypedExpr");
+    return bits::hashMix(kBaseHash, folly::hasher<std::string_view>()(name_));
   }
 
   void accept(
@@ -237,10 +254,10 @@ class CallTypedExpr : public ITypedExpr {
       return false;
     }
     return std::equal(
-        this->inputs().begin(),
-        this->inputs().end(),
-        other.inputs().begin(),
-        other.inputs().end(),
+        this->inputs().cbegin(),
+        this->inputs().cend(),
+        other.inputs().cbegin(),
+        other.inputs().cend(),
         [](const auto& p1, const auto& p2) { return *p1 == *p2; });
   }
 
@@ -268,7 +285,7 @@ class FieldAccessTypedExpr : public ITypedExpr {
   FieldAccessTypedExpr(TypePtr type, TypedExprPtr input, std::string name)
       : ITypedExpr{ExprKind::kFieldAccess, std::move(type), {std::move(input)}},
         name_(std::move(name)),
-        isInputColumn_(is_instance_of<InputTypedExpr>(inputs()[0].get())) {}
+        isInputColumn_(inputs()[0]->isInputKind()) {}
 
   const std::string& name() const {
     return name_;
@@ -282,8 +299,8 @@ class FieldAccessTypedExpr : public ITypedExpr {
 
   size_t localHash() const override {
     static const size_t kBaseHash =
-        std::hash<const char*>()("FieldAccessTypedExpr");
-    return bits::hashMix(kBaseHash, std::hash<std::string>()(name_));
+        folly::hasher<std::string_view>()("FieldAccessTypedExpr");
+    return bits::hashMix(kBaseHash, folly::hasher<std::string_view>()(name_));
   }
 
   void accept(
@@ -306,10 +323,10 @@ class FieldAccessTypedExpr : public ITypedExpr {
       return false;
     }
     return std::equal(
-        this->inputs().begin(),
-        this->inputs().end(),
-        other.inputs().begin(),
-        other.inputs().end(),
+        this->inputs().cbegin(),
+        this->inputs().cend(),
+        other.inputs().cbegin(),
+        other.inputs().cend(),
         [](const auto& p1, const auto& p2) { return *p1 == *p2; });
   }
 
@@ -338,7 +355,7 @@ class DereferenceTypedExpr : public ITypedExpr {
         index_(index) {
     // Make sure this isn't being used to access a top level column.
     VELOX_USER_CHECK(
-        !is_instance_of<InputTypedExpr>(inputs()[0]),
+        !inputs()[0]->isInputKind(),
         "DereferenceTypedExpr select a subfeild cannot be used to access a top level column");
   }
 
@@ -360,12 +377,16 @@ class DereferenceTypedExpr : public ITypedExpr {
   }
 
   std::string toString() const override {
-    return fmt::format("{}[{}]", inputs()[0]->toString(), name());
+    const auto& fieldName = name();
+    if (fieldName.empty()) {
+      return fmt::format("{}[{}]", inputs()[0]->toString(), index_);
+    }
+    return fmt::format("{}[{}]", inputs()[0]->toString(), fieldName);
   }
 
   size_t localHash() const override {
     static const size_t kBaseHash =
-        std::hash<const char*>()("DereferenceTypedExpr");
+        folly::hasher<std::string_view>()("DereferenceTypedExpr");
     return bits::hashMix(kBaseHash, index_);
   }
 
@@ -386,10 +407,10 @@ class DereferenceTypedExpr : public ITypedExpr {
       return false;
     }
     return std::equal(
-        this->inputs().begin(),
-        this->inputs().end(),
-        other.inputs().begin(),
-        other.inputs().end(),
+        this->inputs().cbegin(),
+        this->inputs().cend(),
+        other.inputs().cbegin(),
+        other.inputs().cend(),
         [](const auto& p1, const auto& p2) { return *p1 == *p2; });
   }
 
@@ -420,7 +441,8 @@ class ConcatTypedExpr : public ITypedExpr {
   std::string toString() const override;
 
   size_t localHash() const override {
-    static const size_t kBaseHash = std::hash<const char*>()("ConcatTypedExpr");
+    static const size_t kBaseHash =
+        folly::hasher<std::string_view>()("ConcatTypedExpr");
     return kBaseHash;
   }
 
@@ -441,10 +463,10 @@ class ConcatTypedExpr : public ITypedExpr {
       return false;
     }
     return std::equal(
-        this->inputs().begin(),
-        this->inputs().end(),
-        other.inputs().begin(),
-        other.inputs().end(),
+        this->inputs().cbegin(),
+        this->inputs().cend(),
+        other.inputs().cbegin(),
+        other.inputs().cend(),
         [](const auto& p1, const auto& p2) { return *p1 == *p2; });
   }
 
@@ -484,7 +506,8 @@ class LambdaTypedExpr : public ITypedExpr {
   }
 
   size_t localHash() const override {
-    static const size_t kBaseHash = std::hash<const char*>()("LambdaTypedExpr");
+    static const size_t kBaseHash =
+        folly::hasher<std::string_view>()("LambdaTypedExpr");
     return bits::hashMix(kBaseHash, body_->hash());
   }
 
@@ -522,7 +545,7 @@ using LambdaTypedExprPtr = std::shared_ptr<const LambdaTypedExpr>;
 class CastTypedExpr : public ITypedExpr {
  public:
   /// @param type Type to convert to. This is the return type of the CAST
-  /// expresion.
+  /// expression.
   /// @param input Single input. The type of input is referred to as from-type
   /// and expected to be different from to-type.
   /// @param isTryCast Whether this expression is used for `try_cast`.
@@ -548,7 +571,8 @@ class CastTypedExpr : public ITypedExpr {
   std::string toString() const override;
 
   size_t localHash() const override {
-    static const size_t kBaseHash = std::hash<const char*>()("CastTypedExpr");
+    static const size_t kBaseHash =
+        folly::hasher<std::string_view>()("CastTypedExpr");
     return bits::hashMix(kBaseHash, std::hash<bool>()(isTryCast_));
   }
 
@@ -586,12 +610,58 @@ class CastTypedExpr : public ITypedExpr {
 
 using CastTypedExprPtr = std::shared_ptr<const CastTypedExpr>;
 
+/// NULLIF(a, b) expression. Returns NULL if a equals b, otherwise returns a.
+///
+/// The comparison uses the common supertype of a and b, but the return type is
+/// a's original type. The common type is stored as metadata and used internally
+/// to cast both inputs for comparison only.
+class NullIfTypedExpr : public ITypedExpr {
+ public:
+  /// @param value The first argument. Its type determines the return type.
+  /// @param comparand The second argument to compare against.
+  /// @param commonType The common supertype used to cast both inputs for
+  /// comparison.
+  NullIfTypedExpr(
+      TypedExprPtr value,
+      TypedExprPtr comparand,
+      TypePtr commonType);
+
+  /// Returns the common supertype used for comparison.
+  const TypePtr& commonType() const {
+    return commonType_;
+  }
+
+  TypedExprPtr rewriteInputNames(
+      const std::unordered_map<std::string, TypedExprPtr>& mapping)
+      const override;
+
+  std::string toString() const override;
+
+  size_t localHash() const override;
+
+  void accept(
+      const ITypedExprVisitor& visitor,
+      ITypedExprVisitorContext& context) const override;
+
+  bool operator==(const ITypedExpr& other) const override;
+
+  folly::dynamic serialize() const override;
+
+  static TypedExprPtr create(const folly::dynamic& obj, void* context);
+
+ private:
+  // The common supertype used to cast both inputs for comparison.
+  const TypePtr commonType_;
+};
+
+using NullIfTypedExprPtr = std::shared_ptr<const NullIfTypedExpr>;
+
 /// A collection of convenience methods for working with expressions.
 class TypedExprs {
  public:
   /// Returns true if 'expr' is a field access expression.
   static bool isFieldAccess(const TypedExprPtr& expr) {
-    return is_instance_of<FieldAccessTypedExpr>(expr);
+    return expr->isFieldAccessKind();
   }
 
   /// Returns 'expr' as FieldAccessTypedExprPtr or null if not field access
@@ -602,7 +672,7 @@ class TypedExprs {
 
   /// Returns true if 'expr' is a constant expression.
   static bool isConstant(const TypedExprPtr& expr) {
-    return is_instance_of<ConstantTypedExpr>(expr);
+    return expr->isConstantKind();
   }
 
   /// Returns 'expr' as ConstantTypedExprPtr or null if not a constant
@@ -613,7 +683,7 @@ class TypedExprs {
 
   /// Returns true if 'expr' is a lambda expression.
   static bool isLambda(const TypedExprPtr& expr) {
-    return is_instance_of<LambdaTypedExpr>(expr);
+    return expr->isLambdaKind();
   }
 
   /// Returns 'expr' as LambdaTypedExprPtr or null if not a lambda expression.
@@ -658,6 +728,9 @@ class ITypedExprVisitor {
   virtual void visit(const LambdaTypedExpr& expr, ITypedExprVisitorContext& ctx)
       const = 0;
 
+  virtual void visit(const NullIfTypedExpr& expr, ITypedExprVisitorContext& ctx)
+      const = 0;
+
  protected:
   void visitInputs(const ITypedExpr& expr, ITypedExprVisitorContext& ctx)
       const {
@@ -710,6 +783,11 @@ class DefaultTypedExprVisitor : public ITypedExprVisitor {
       const override {
     visitInputs(expr, ctx);
   }
+
+  void visit(const NullIfTypedExpr& expr, ITypedExprVisitorContext& ctx)
+      const override {
+    visitInputs(expr, ctx);
+  }
 };
 
 } // namespace facebook::velox::core
diff --git a/velox/core/ITypedExpr.cpp b/velox/core/ITypedExpr.cpp
index ba531da895c..d11156e3fb5 100644
--- a/velox/core/ITypedExpr.cpp
+++ b/velox/core/ITypedExpr.cpp
@@ -16,6 +16,8 @@
 
 #include "velox/core/ITypedExpr.h"
 
+#include "velox/common/EnumDefine.h"
+
 namespace facebook::velox::core {
 
 namespace {
@@ -35,4 +37,14 @@ const auto& exprKindNames() {
 } // namespace
 
 VELOX_DEFINE_ENUM_NAME(ExprKind, exprKindNames);
+
+size_t ITypedExprHasher::operator()(const ITypedExpr* expr) const {
+  return expr->hash();
+}
+
+bool ITypedExprComparer::operator()(
+    const ITypedExpr* lhs,
+    const ITypedExpr* rhs) const {
+  return *lhs == *rhs;
+}
 } // namespace facebook::velox::core
diff --git a/velox/core/ITypedExpr.h b/velox/core/ITypedExpr.h
index bcdf55f233f..6cbb443c755 100644
--- a/velox/core/ITypedExpr.h
+++ b/velox/core/ITypedExpr.h
@@ -28,6 +28,7 @@ enum class ExprKind : int32_t {
   kConstant = 6,
   kConcat = 7,
   kLambda = 8,
+  kNullIf = 9,
 };
 
 VELOX_DECLARE_ENUM_NAME(ExprKind);
@@ -38,6 +39,14 @@ class ITypedExprVisitorContext;
 
 using TypedExprPtr = std::shared_ptr<const ITypedExpr>;
 
+struct ITypedExprHasher {
+  size_t operator()(const ITypedExpr* expr) const;
+};
+
+struct ITypedExprComparer {
+  bool operator()(const ITypedExpr* lhs, const ITypedExpr* rhs) const;
+};
+
 /// Strongly-typed expression, e.g. literal, function call, etc.
 class ITypedExpr : public ISerializable {
  public:
@@ -93,6 +102,10 @@ class ITypedExpr : public ISerializable {
     return kind_ == ExprKind::kLambda;
   }
 
+  bool isNullIfKind() const {
+    return kind_ == ExprKind::kNullIf;
+  }
+
   template <typename T>
   const T* asUnchecked() const {
     return dynamic_cast<const T*>(this);
@@ -115,8 +128,17 @@ class ITypedExpr : public ISerializable {
 
   virtual std::string toString() const = 0;
 
+  /// Returns a hash value for this expression node only, not including inputs.
+  /// Implementations must use a stable hash like folly::hasher to ensure
+  /// stable hashing across processes and builds.
   virtual size_t localHash() const = 0;
 
+  /// Returns a hash value for the entire expression tree rooted at this node.
+  /// The hash is computed by combining localHash() with the type's hash and
+  /// the hashes of all input expressions.
+  ///
+  /// STABILITY GUARANTEE: This hash is stable across different processes,
+  /// builds, and machines.
   size_t hash() const {
     size_t hash = bits::hashMix(type_->hashKind(), localHash());
     for (size_t i = 0; i < inputs_.size(); ++i) {
diff --git a/velox/core/Metaprogramming.h b/velox/core/Metaprogramming.h
index 955ea4122b4..95906ef2140 100644
--- a/velox/core/Metaprogramming.h
+++ b/velox/core/Metaprogramming.h
@@ -124,11 +124,10 @@ template <typename C, class TResolver, typename TRet, typename... TArgs>
 struct has_method {
  private:
   template <typename T>
-  static constexpr auto check(T*) ->
-      typename std::is_same<
-          decltype(std::declval<TResolver>().template resolve<T>(
-              std::declval<TArgs>()...)),
-          TRet>::type {
+  static constexpr auto check(T*) -> typename std::is_same<
+      decltype(std::declval<TResolver>().template resolve<T>(
+          std::declval<TArgs>()...)),
+      TRet>::type {
     return {};
   }
 
diff --git a/velox/core/PlanConsistencyChecker.cpp b/velox/core/PlanConsistencyChecker.cpp
index 89c95c0d654..35db704a3f0 100644
--- a/velox/core/PlanConsistencyChecker.cpp
+++ b/velox/core/PlanConsistencyChecker.cpp
@@ -15,15 +15,47 @@
  */
 
 #include "velox/core/PlanConsistencyChecker.h"
+#include "velox/common/base/Exceptions.h"
 
 namespace facebook::velox::core {
 
 namespace {
 
+// Returns a message describing the plan node for exception context.
+std::string planNodeMessage(VeloxException::Type /*exceptionType*/, void* arg) {
+  auto* node = static_cast<const PlanNode*>(arg);
+  return fmt::format("Plan node: {}", node->toString(/*detailed=*/true));
+}
+
 class Checker : public PlanNodeVisitor {
  public:
+  explicit Checker(PlanNodeId rootId) : rootId_{std::move(rootId)} {}
+
   void visit(const AggregationNode& node, PlanNodeVisitorContext& ctx)
       const override {
+    const auto& rowType = node.sources().at(0)->outputType();
+    for (const auto& expr : node.groupingKeys()) {
+      checkInputs(expr, rowType);
+    }
+
+    for (const auto& expr : node.preGroupedKeys()) {
+      checkInputs(expr, rowType);
+    }
+
+    for (const auto& aggregate : node.aggregates()) {
+      checkInputs(aggregate.call, rowType);
+
+      for (const auto& expr : aggregate.sortingKeys) {
+        checkInputs(expr, rowType);
+      }
+
+      if (aggregate.mask) {
+        checkInputs(aggregate.mask, rowType);
+      }
+    }
+
+    verifyOutputNames(node);
+
     visitSources(&node, ctx);
   }
 
@@ -66,6 +98,26 @@ class Checker : public PlanNodeVisitor {
 
   void visit(const HashJoinNode& node, PlanNodeVisitorContext& ctx)
       const override {
+    std::unordered_set<std::pair<std::string, std::string>> keyNames;
+    for (auto i = 0; i < node.leftKeys().size(); ++i) {
+      const auto& leftKey = node.leftKeys().at(i);
+      const auto& rightKey = node.rightKeys().at(i);
+
+      auto [_, inserted] = keyNames.insert({leftKey->name(), rightKey->name()});
+      VELOX_USER_CHECK(
+          inserted,
+          "Duplicate join condition: \"{}\" = \"{}\"",
+          leftKey->name(),
+          rightKey->name());
+    }
+
+    if (node.filter()) {
+      const auto& leftRowType = node.sources().at(0)->outputType();
+      const auto& rightRowType = node.sources().at(1)->outputType();
+      auto rowType = leftRowType->unionWith(rightRowType);
+      checkInputs(node.filter(), rowType);
+    }
+
     visitSources(&node, ctx);
   }
 
@@ -89,11 +141,26 @@ class Checker : public PlanNodeVisitor {
     visitSources(&node, ctx);
   }
 
+  void visit(const MixedUnionNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
   void visit(const MarkDistinctNode& node, PlanNodeVisitorContext& ctx)
       const override {
     visitSources(&node, ctx);
   }
 
+  void visit(const EnforceDistinctNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const MarkSortedNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
   void visit(const MergeExchangeNode& node, PlanNodeVisitorContext& ctx)
       const override {
     visitSources(&node, ctx);
@@ -106,6 +173,15 @@ class Checker : public PlanNodeVisitor {
 
   void visit(const NestedLoopJoinNode& node, PlanNodeVisitorContext& ctx)
       const override {
+    if (node.joinCondition() != nullptr) {
+      const auto& leftRowType = node.sources().at(0)->outputType();
+      const auto& rightRowType = node.sources().at(1)->outputType();
+      auto rowType = leftRowType->unionWith(rightRowType);
+      checkInputs(node.joinCondition(), rowType);
+    }
+
+    verifyOutputNames(node);
+
     visitSources(&node, ctx);
   }
 
@@ -131,12 +207,10 @@ class Checker : public PlanNodeVisitor {
       checkInputs(expr, rowType);
     }
 
-    // Verify that output column names are not empty and unique.
-    std::unordered_set<std::string> names;
-    for (const auto& name : node.outputType()->names()) {
-      VELOX_USER_CHECK(!name.empty(), "Output column name cannot be empty");
-      VELOX_USER_CHECK(
-          names.insert(name).second, "Duplicate output column: {}", name);
+    // The root ProjectNode may have empty or duplicate output names when used
+    // to apply user-specified column aliases (e.g. SELECT 1 as x, 2 as x).
+    if (node.id() != rootId_) {
+      verifyOutputNames(node);
     }
 
     visitSources(&node, ctx);
@@ -160,6 +234,22 @@ class Checker : public PlanNodeVisitor {
 
   void visit(const TableScanNode& node, PlanNodeVisitorContext& ctx)
       const override {
+    verifyOutputNames(node);
+
+    // Verify assignments match outputType 1:1.
+    const auto& names = node.outputType()->names();
+    VELOX_USER_CHECK_EQ(
+        names.size(),
+        node.assignments().size(),
+        "Column assignments must match output type");
+
+    for (const auto& name : names) {
+      VELOX_USER_CHECK(
+          node.assignments().contains(name),
+          "Column assignment is missing for {}",
+          name);
+    }
+
     visitSources(&node, ctx);
   }
 
@@ -209,10 +299,22 @@ class Checker : public PlanNodeVisitor {
  private:
   void visitSources(const PlanNode* node, PlanNodeVisitorContext& ctx) const {
     for (auto& source : node->sources()) {
+      ExceptionContextSetter exceptionContext(
+          {planNodeMessage, (void*)source.get()});
       source->accept(*this, ctx);
     }
   }
 
+  // Verify that output column names are not empty and unique.
+  static void verifyOutputNames(const PlanNode& node) {
+    folly::F14FastSet<std::string_view> names;
+    for (const auto& name : node.outputType()->names()) {
+      VELOX_USER_CHECK(!name.empty(), "Output column name cannot be empty");
+      VELOX_USER_CHECK(
+          names.emplace(name).second, "Duplicate output column: {}", name);
+    }
+  }
+
   static void checkInputs(
       const core::TypedExprPtr& expr,
       const RowTypePtr& rowType) {
@@ -233,16 +335,27 @@ class Checker : public PlanNodeVisitor {
       }
     }
 
+    if (expr->isLambdaKind()) {
+      const auto& lambda = expr->asUnchecked<core::LambdaTypedExpr>();
+      checkInputs(lambda->body(), lambda->signature()->unionWith(rowType));
+    }
+
     for (const auto& input : expr->inputs()) {
       checkInputs(input, rowType);
     }
   }
+
+  // ID of the root node. Used to skip output name validation on the root
+  // ProjectNode, which may have user-specified aliases that are empty or
+  // duplicated.
+  const PlanNodeId rootId_;
 };
 } // namespace
 
 void PlanConsistencyChecker::check(const core::PlanNodePtr& plan) {
+  ExceptionContextSetter exceptionContext({planNodeMessage, (void*)plan.get()});
   PlanNodeVisitorContext ctx;
-  Checker checker;
+  Checker checker{plan->id()};
   plan->accept(checker, ctx);
 }
 }; // namespace facebook::velox::core
diff --git a/velox/core/PlanNode.cpp b/velox/core/PlanNode.cpp
index 2cf53c91020..f47b957aced 100644
--- a/velox/core/PlanNode.cpp
+++ b/velox/core/PlanNode.cpp
@@ -15,12 +15,15 @@
  */
 #include <folly/container/F14Set.h>
 
+#include "velox/common/Casts.h"
 #include "velox/common/encode/Base64.h"
 #include "velox/core/PlanNode.h"
+
+#include "velox/common/EnumDefine.h"
+#include "velox/core/TableWriteTraits.h"
 #include "velox/vector/VectorSaver.h"
 
 namespace facebook::velox::core {
-
 namespace {
 
 void appendComma(int32_t i, std::stringstream& sql) {
@@ -59,7 +62,11 @@ IndexLookupConditionPtr createIndexJoinCondition(
 }
 } // namespace
 
-std::vector<IndexLookupConditionPtr> deserializeJoinConditions(
+/// Deserializes lookup conditions from dynamic object for index lookup joins.
+/// These conditions are more complex than simple equality join conditions and
+/// can include IN, BETWEEN, and EQUAL conditions that involve both left and
+/// right side columns.
+std::vector<IndexLookupConditionPtr> deserializejoinConditions(
     const folly::dynamic& obj,
     void* context) {
   if (obj.count("joinConditions") == 0) {
@@ -162,6 +169,7 @@ AggregationNode::AggregationNode(
     const std::vector<vector_size_t>& globalGroupingSets,
     const std::optional<FieldAccessTypedExprPtr>& groupId,
     bool ignoreNullKeys,
+    bool noGroupsSpanBatches,
     PlanNodePtr source)
     : PlanNode(id),
       step_(step),
@@ -172,6 +180,7 @@ AggregationNode::AggregationNode(
       ignoreNullKeys_(ignoreNullKeys),
       groupId_(groupId),
       globalGroupingSets_(globalGroupingSets),
+      noGroupsSpanBatches_(noGroupsSpanBatches),
       sources_{source},
       outputType_(getAggregationOutputType(
           groupingKeys_,
@@ -216,6 +225,10 @@ AggregationNode::AggregationNode(
     VELOX_USER_CHECK(
         groupId_.has_value(), "Global grouping sets require GroupId key");
   }
+
+  VELOX_USER_CHECK(
+      !noGroupsSpanBatches_ || isPreGrouped(),
+      "noGroupsSpanBatches can only be set for streaming aggregation (pre-grouped)");
 }
 
 AggregationNode::AggregationNode(
@@ -226,6 +239,7 @@ AggregationNode::AggregationNode(
     const std::vector<std::string>& aggregateNames,
     const std::vector<Aggregate>& aggregates,
     bool ignoreNullKeys,
+    bool noGroupsSpanBatches,
     PlanNodePtr source)
     : AggregationNode(
           id,
@@ -237,6 +251,7 @@ AggregationNode::AggregationNode(
           kDefaultGlobalGroupingSets,
           kDefaultGroupId,
           ignoreNullKeys,
+          noGroupsSpanBatches,
           source) {}
 
 namespace {
@@ -273,19 +288,12 @@ void addSortingKeys(
   }
 }
 
-void addVectorSerdeKind(VectorSerde::Kind kind, std::stringstream& stream) {
-  stream << VectorSerde::kindName(kind);
+void addVectorSerdeKind(const std::string& kind, std::stringstream& stream) {
+  stream << kind;
 }
 } // namespace
 
 bool AggregationNode::canSpill(const QueryConfig& queryConfig) const {
-  // TODO: Add spilling for aggregations over distinct inputs.
-  // https://github.com/facebookincubator/velox/issues/7454
-  for (const auto& aggregate : aggregates_) {
-    if (aggregate.distinct) {
-      return false;
-    }
-  }
   // TODO: add spilling for pre-grouped aggregation later:
   // https://github.com/facebookincubator/velox/issues/3264
   return (isFinal() || isSingle()) && !groupingKeys().empty() &&
@@ -331,6 +339,10 @@ void AggregationNode::addDetails(std::stringstream& stream) const {
   if (groupId_.has_value()) {
     stream << " Group Id key: " << groupId_.value()->name();
   }
+
+  if (noGroupsSpanBatches_) {
+    stream << " noGroupsSpanBatches";
+  }
 }
 
 namespace {
@@ -369,6 +381,7 @@ folly::dynamic AggregationNode::serialize() const {
     obj["groupId"] = ISerializable::serialize(groupId_.value());
   }
   obj["ignoreNullKeys"] = ignoreNullKeys_;
+  obj["noGroupsSpanBatches"] = noGroupsSpanBatches_;
   return obj;
 }
 
@@ -386,6 +399,10 @@ std::vector<FieldAccessTypedExprPtr> deserializeFields(
       array, context);
 }
 
+FieldAccessTypedExprPtr deserializeField(const folly::dynamic& obj) {
+  return ISerializable::deserialize<FieldAccessTypedExpr>(obj);
+}
+
 std::vector<std::string> deserializeStrings(const folly::dynamic& array) {
   return ISerializable::deserialize<std::vector<std::string>>(array);
 }
@@ -485,6 +502,8 @@ PlanNodePtr AggregationNode::create(const folly::dynamic& obj, void* context) {
       globalGroupingSets,
       groupId,
       obj["ignoreNullKeys"].asBool(),
+      obj.count("noGroupsSpanBatches") ? obj["noGroupsSpanBatches"].asBool()
+                                       : false,
       deserializeSingleSource(obj, context));
 }
 
@@ -892,6 +911,13 @@ class SummarizeExprVisitor : public ITypedExprVisitor {
     myCtx.expressionCounts()["lambda"]++;
     expr.body()->accept(*this, ctx);
   }
+
+  void visit(const NullIfTypedExpr& expr, ITypedExprVisitorContext& ctx)
+      const override {
+    auto& myCtx = static_cast<Context&>(ctx);
+    myCtx.expressionCounts()["nullif"]++;
+    visitInputs(expr, ctx);
+  }
 };
 
 void appendCounts(
@@ -1129,7 +1155,7 @@ std::vector<std::string> allNames(
     const std::vector<std::string>& names,
     const std::vector<std::string>& moreNames) {
   auto result = names;
-  result.insert(result.end(), moreNames.begin(), moreNames.end());
+  result.insert(result.cend(), moreNames.cbegin(), moreNames.cend());
   return result;
 }
 
@@ -1141,13 +1167,14 @@ std::vector<TypedExprPtr> flattenExprs(
     const PlanNodePtr& input) {
   std::vector<TypedExprPtr> result;
   for (auto& group : exprs) {
-    result.insert(result.end(), group.begin(), group.end());
+    result.insert(result.cend(), group.cbegin(), group.cend());
   }
 
   const auto& sourceType = input->outputType();
   for (auto& name : moreNames) {
-    result.push_back(std::make_shared<FieldAccessTypedExpr>(
-        sourceType->findChild(name), name));
+    result.push_back(
+        std::make_shared<FieldAccessTypedExpr>(
+            sourceType->findChild(name), name));
   }
   return result;
 }
@@ -1319,7 +1346,7 @@ void ExchangeNode::addDetails(std::stringstream& stream) const {
 folly::dynamic ExchangeNode::serialize() const {
   auto obj = PlanNode::serialize();
   obj["outputType"] = ExchangeNode::outputType()->serialize();
-  obj["serdeKind"] = VectorSerde::kindName(serdeKind_);
+  obj["serdeKind"] = serdeKind_;
   return obj;
 }
 
@@ -1334,7 +1361,7 @@ PlanNodePtr ExchangeNode::create(const folly::dynamic& obj, void* context) {
   return std::make_shared<ExchangeNode>(
       deserializePlanNodeId(obj),
       deserializeRowType(obj["outputType"]),
-      VectorSerde::kindByName(obj["serdeKind"].asString()));
+      obj["serdeKind"].asString());
 }
 
 UnnestNode::UnnestNode(
@@ -1343,14 +1370,34 @@ UnnestNode::UnnestNode(
     std::vector<FieldAccessTypedExprPtr> unnestVariables,
     std::vector<std::string> unnestNames,
     std::optional<std::string> ordinalityName,
-    std::optional<std::string> emptyUnnestValueName,
+    std::optional<std::string> markerName,
+    const PlanNodePtr& source)
+    : UnnestNode(
+          id,
+          std::move(replicateVariables),
+          std::move(unnestVariables),
+          std::move(unnestNames),
+          std::move(ordinalityName),
+          std::move(markerName),
+          std::nullopt,
+          source) {}
+
+UnnestNode::UnnestNode(
+    const PlanNodeId& id,
+    std::vector<FieldAccessTypedExprPtr> replicateVariables,
+    std::vector<FieldAccessTypedExprPtr> unnestVariables,
+    std::vector<std::string> unnestNames,
+    std::optional<std::string> ordinalityName,
+    std::optional<std::string> markerName,
+    std::optional<bool> splitOutput,
     const PlanNodePtr& source)
     : PlanNode(id),
       replicateVariables_{std::move(replicateVariables)},
       unnestVariables_{std::move(unnestVariables)},
       unnestNames_{std::move(unnestNames)},
       ordinalityName_{std::move(ordinalityName)},
-      emptyUnnestValueName_(std::move(emptyUnnestValueName)),
+      markerName_(std::move(markerName)),
+      splitOutput_(splitOutput),
       sources_{source} {
   // Calculate output type. First come "replicate" columns, followed by
   // "unnest" columns, followed by an optional ordinality column.
@@ -1387,8 +1434,8 @@ UnnestNode::UnnestNode(
     types.emplace_back(BIGINT());
   }
 
-  if (emptyUnnestValueName_.has_value()) {
-    names.emplace_back(emptyUnnestValueName_.value());
+  if (markerName_.has_value()) {
+    names.emplace_back(markerName_.value());
     types.emplace_back(BOOLEAN());
   }
 
@@ -1408,8 +1455,11 @@ folly::dynamic UnnestNode::serialize() const {
   if (ordinalityName_.has_value()) {
     obj["ordinalityName"] = ordinalityName_.value();
   }
-  if (emptyUnnestValueName_.has_value()) {
-    obj["emptyUnnestValueName"] = emptyUnnestValueName_.value();
+  if (markerName_.has_value()) {
+    obj["markerName"] = markerName_.value();
+  }
+  if (splitOutput_.has_value()) {
+    obj["splitOutput"] = splitOutput_.value();
   }
   return obj;
 }
@@ -1431,9 +1481,13 @@ PlanNodePtr UnnestNode::create(const folly::dynamic& obj, void* context) {
   if (obj.count("ordinalityName")) {
     ordinalityName = obj["ordinalityName"].asString();
   }
-  std::optional<std::string> emptyUnnestValueName = std::nullopt;
-  if (obj.count("emptyUnnestValueName")) {
-    emptyUnnestValueName = obj["emptyUnnestValueName"].asString();
+  std::optional<std::string> markerName = std::nullopt;
+  if (obj.count("markerName")) {
+    markerName = obj["markerName"].asString();
+  }
+  std::optional<bool> splitOutput = std::nullopt;
+  if (obj.count("splitOutput")) {
+    splitOutput = obj["splitOutput"].asBool();
   }
   return std::make_shared<UnnestNode>(
       deserializePlanNodeId(obj),
@@ -1441,7 +1495,8 @@ PlanNodePtr UnnestNode::create(const folly::dynamic& obj, void* context) {
       std::move(unnestVariables),
       std::move(unnestNames),
       std::move(ordinalityName),
-      std::move(emptyUnnestValueName),
+      std::move(markerName),
+      splitOutput,
       std::move(source));
 }
 
@@ -1509,7 +1564,8 @@ void AbstractJoinNode::validate() const {
   // Output of left semi and anti joins cannot include columns from the right
   // side.
   bool outputMayIncludeRightColumns =
-      !(isLeftSemiFilterJoin() || isLeftSemiProjectJoin() || isAntiJoin());
+      !(isLeftSemiFilterJoin() || isLeftSemiProjectJoin() || isAntiJoin() ||
+        isCountingJoin());
 
   for (auto i = 0; i < numOutputColumns; ++i) {
     auto name = outputType_->nameOf(i);
@@ -1570,28 +1626,51 @@ const auto& joinTypeNames() {
       {JoinType::kLeftSemiProject, "LEFT SEMI (PROJECT)"},
       {JoinType::kRightSemiProject, "RIGHT SEMI (PROJECT)"},
       {JoinType::kAnti, "ANTI"},
+      {JoinType::kCountingAnti, "COUNTING ANTI"},
+      {JoinType::kCountingLeftSemiFilter, "COUNTING LEFT SEMI (FILTER)"},
   };
   return kNames;
 }
 
 // Check that each output of the join is in exactly one of the inputs.
-void checkJoinColumnNames(
+void checkJoinOutput(
     const RowTypePtr& leftType,
     const RowTypePtr& rightType,
     const RowTypePtr& outputType,
     uint32_t numColumnsToCheck) {
   for (auto i = 0; i < numColumnsToCheck; ++i) {
-    const auto name = outputType->nameOf(i);
-    const bool leftContains = leftType->containsChild(name);
-    const bool rightContains = rightType->containsChild(name);
+    const auto& name = outputType->nameOf(i);
+    const auto& type = outputType->childAt(i);
+
+    const auto leftIndex = leftType->getChildIdxIfExists(name);
+    const auto rightIndex = rightType->getChildIdxIfExists(name);
+
     VELOX_USER_CHECK(
-        !(leftContains && rightContains),
+        !(leftIndex.has_value() && rightIndex.has_value()),
         "Duplicate column name found on join's left and right sides: {}",
         name);
     VELOX_USER_CHECK(
-        leftContains || rightContains,
+        leftIndex.has_value() || rightIndex.has_value(),
         "Join's output column not found in either left or right sides: {}",
         name);
+
+    if (leftIndex.has_value()) {
+      const auto& expectedType = leftType->childAt(leftIndex.value());
+      VELOX_USER_CHECK(
+          expectedType->equivalent(*type),
+          "Join output column type must match the input type: {} vs. {}",
+          type->toString(),
+          expectedType->toString());
+    }
+
+    if (rightIndex.has_value()) {
+      const auto& expectedType = rightType->childAt(rightIndex.value());
+      VELOX_USER_CHECK(
+          expectedType->equivalent(*type),
+          "Join output column type must match the input type: {} vs. {}",
+          type->toString(),
+          expectedType->toString());
+    }
   }
 }
 
@@ -1604,11 +1683,16 @@ void HashJoinNode::addDetails(std::stringstream& stream) const {
   if (nullAware_) {
     stream << ", null aware";
   }
+  if (nullAsValue_) {
+    stream << ", null as value";
+  }
 }
 
 folly::dynamic HashJoinNode::serialize() const {
   auto obj = serializeBase();
   obj["nullAware"] = nullAware_;
+  obj["nullAsValue"] = nullAsValue_;
+  obj["useHashTableCache"] = useHashTableCache_;
   return obj;
 }
 
@@ -1624,6 +1708,8 @@ PlanNodePtr HashJoinNode::create(const folly::dynamic& obj, void* context) {
   VELOX_CHECK_EQ(2, sources.size());
 
   auto nullAware = obj["nullAware"].asBool();
+  auto nullAsValue = obj.getDefault("nullAsValue", false).asBool();
+  auto useHashTableCache = obj.getDefault("useHashTableCache", false).asBool();
   auto leftKeys = deserializeFields(obj["leftKeys"], context);
   auto rightKeys = deserializeFields(obj["rightKeys"], context);
 
@@ -1643,7 +1729,9 @@ PlanNodePtr HashJoinNode::create(const folly::dynamic& obj, void* context) {
       filter,
       sources[0],
       sources[1],
-      outputType);
+      outputType,
+      useHashTableCache,
+      nullAsValue);
 }
 
 MergeJoinNode::MergeJoinNode(
@@ -1730,7 +1818,8 @@ IndexLookupJoinNode::IndexLookupJoinNode(
     const std::vector<FieldAccessTypedExprPtr>& leftKeys,
     const std::vector<FieldAccessTypedExprPtr>& rightKeys,
     const std::vector<IndexLookupConditionPtr>& joinConditions,
-    bool includeMatchColumn,
+    TypedExprPtr filter,
+    bool hasMarker,
     PlanNodePtr left,
     TableScanNodePtr right,
     RowTypePtr outputType)
@@ -1739,13 +1828,13 @@ IndexLookupJoinNode::IndexLookupJoinNode(
           joinType,
           leftKeys,
           rightKeys,
-          /*filter=*/nullptr,
+          std::move(filter),
           std::move(left),
           right,
           outputType),
       lookupSourceNode_(std::move(right)),
       joinConditions_(joinConditions),
-      includeMatchColumn_(includeMatchColumn) {
+      hasMarker_(hasMarker) {
   VELOX_USER_CHECK(
       !leftKeys.empty(),
       "The index lookup join node requires at least one join key");
@@ -1789,7 +1878,7 @@ IndexLookupJoinNode::IndexLookupJoinNode(
   }
 
   auto numOutputColumns = outputType_->size();
-  if (includeMatchColumn_) {
+  if (hasMarker_) {
     VELOX_USER_CHECK(
         isLeftJoin(),
         "Index join match column can only present for {} but not {}",
@@ -1809,7 +1898,7 @@ IndexLookupJoinNode::IndexLookupJoinNode(
     VELOX_USER_CHECK(!rightType->containsChild(name));
   }
 
-  checkJoinColumnNames(leftType, rightType, outputType_, numOutputColumns);
+  checkJoinOutput(leftType, rightType, outputType_, numOutputColumns);
 }
 
 PlanNodePtr IndexLookupJoinNode::create(
@@ -1818,17 +1907,19 @@ PlanNodePtr IndexLookupJoinNode::create(
   auto sources = deserializeSources(obj, context);
   VELOX_CHECK_EQ(2, sources.size());
   TableScanNodePtr lookupSource =
-      std::dynamic_pointer_cast<const TableScanNode>(sources[1]);
-  VELOX_CHECK_NOT_NULL(lookupSource);
+      checkedPointerCast<const TableScanNode>(sources[1]);
 
   auto leftKeys = deserializeFields(obj["leftKeys"], context);
   auto rightKeys = deserializeFields(obj["rightKeys"], context);
 
-  VELOX_CHECK_EQ(obj.count("filter"), 0);
+  TypedExprPtr filter;
+  if (obj.count("filter")) {
+    filter = ISerializable::deserialize<ITypedExpr>(obj["filter"], context);
+  }
 
-  auto joinConditions = deserializeJoinConditions(obj, context);
+  auto joinConditions = deserializejoinConditions(obj, context);
 
-  const bool includeMatchColumn = obj["includeMatchColumn"].asBool();
+  const bool hasMarker = obj["hasMarker"].asBool();
 
   auto outputType = deserializeRowType(obj["outputType"]);
 
@@ -1838,7 +1929,8 @@ PlanNodePtr IndexLookupJoinNode::create(
       std::move(leftKeys),
       std::move(rightKeys),
       std::move(joinConditions),
-      includeMatchColumn,
+      filter,
+      hasMarker,
       sources[0],
       std::move(lookupSource),
       std::move(outputType));
@@ -1853,24 +1945,32 @@ folly::dynamic IndexLookupJoinNode::serialize() const {
     }
     obj["joinConditions"] = std::move(serializedJoins);
   }
-  obj["includeMatchColumn"] = includeMatchColumn_;
+  if (filter_) {
+    obj["filter"] = filter_->serialize();
+  }
+  obj["hasMarker"] = hasMarker_;
   return obj;
 }
 
+bool IndexLookupJoinNode::needsIndexSplit() const {
+  return lookupSourceNode_->tableHandle()->needsIndexSplit();
+}
+
 void IndexLookupJoinNode::addDetails(std::stringstream& stream) const {
   AbstractJoinNode::addDetails(stream);
   if (joinConditions_.empty()) {
     return;
   }
 
-  std::vector<std::string> joinConditionStrs;
-  joinConditionStrs.reserve(joinConditions_.size());
+  std::vector<std::string> joinConditionstrs;
+  joinConditionstrs.reserve(joinConditions_.size());
   for (const auto& joinCondition : joinConditions_) {
-    joinConditionStrs.push_back(joinCondition->toString());
+    joinConditionstrs.push_back(joinCondition->toString());
   }
-  stream << ", joinConditions: [" << folly::join(", ", joinConditionStrs)
-         << " ], includeMatchColumn: ["
-         << (includeMatchColumn_ ? "true" : "false") << "]";
+  stream << ", joinConditions: [" << folly::join(", ", joinConditionstrs)
+         << " ], filter: ["
+         << (filter_ == nullptr ? "null" : filter_->toString())
+         << "], hasMarker: [" << (hasMarker_ ? "true" : "false") << "]";
 }
 
 void IndexLookupJoinNode::accept(
@@ -1892,9 +1992,7 @@ bool IndexLookupJoinNode::isSupported(JoinType joinType) {
 }
 
 bool isIndexLookupJoin(const PlanNode* planNode) {
-  const auto* indexLookupJoin =
-      dynamic_cast<const IndexLookupJoinNode*>(planNode);
-  return indexLookupJoin != nullptr;
+  return isInstanceOf<IndexLookupJoinNode>(planNode);
 }
 
 // static
@@ -1936,7 +2034,7 @@ NestedLoopJoinNode::NestedLoopJoinNode(
         name);
   }
 
-  checkJoinColumnNames(leftType, rightType, outputType_, numOutputColumns);
+  checkJoinOutput(leftType, rightType, outputType_, numOutputColumns);
 }
 
 NestedLoopJoinNode::NestedLoopJoinNode(
@@ -2374,6 +2472,158 @@ PlanNodePtr MarkDistinctNode::create(const folly::dynamic& obj, void* context) {
       deserializePlanNodeId(obj), markerName, distinctKeys, source);
 }
 
+EnforceDistinctNode::EnforceDistinctNode(
+    PlanNodeId id,
+    std::vector<FieldAccessTypedExprPtr> distinctKeys,
+    std::vector<FieldAccessTypedExprPtr> preGroupedKeys,
+    std::string errorMessage,
+    PlanNodePtr source)
+    : PlanNode(std::move(id)),
+      distinctKeys_(std::move(distinctKeys)),
+      preGroupedKeys_(std::move(preGroupedKeys)),
+      errorMessage_(std::move(errorMessage)),
+      sources_{std::move(source)} {
+  VELOX_USER_CHECK(!distinctKeys_.empty(), "distinctKeys must not be empty.");
+  VELOX_USER_CHECK(!errorMessage_.empty(), "errorMessage must not be empty");
+
+  using TypedExprSet = folly::
+      F14FastSet<const ITypedExpr*, ITypedExprHasher, ITypedExprComparer>;
+
+  TypedExprSet distinctKeySet;
+  const auto& inputType = sources_.front()->outputType();
+  for (const auto& key : distinctKeys_) {
+    VELOX_USER_CHECK(
+        key->isInputColumn(),
+        "Distinct key must be a column reference: {}.",
+        key->toString());
+
+    VELOX_USER_CHECK(
+        distinctKeySet.insert(key.get()).second,
+        "Duplicate distinct key: {}.",
+        key->toString());
+
+    VELOX_USER_CHECK(
+        inputType->containsChild(key->name()),
+        "Distinct key must be present in the input: {}.",
+        key->toString());
+  }
+
+  TypedExprSet preGroupedKeySet;
+  for (const auto& key : preGroupedKeys_) {
+    VELOX_USER_CHECK(
+        preGroupedKeySet.insert(key.get()).second,
+        "Duplicate pre-grouped key: {}.",
+        key->name());
+    VELOX_USER_CHECK(
+        distinctKeySet.contains(key.get()),
+        "Pre-grouped key must be one of the distinct keys: {}.",
+        key->name());
+  }
+}
+
+folly::dynamic EnforceDistinctNode::serialize() const {
+  auto obj = PlanNode::serialize();
+  obj["distinctKeys"] = ISerializable::serialize(this->distinctKeys_);
+  obj["preGroupedKeys"] = ISerializable::serialize(this->preGroupedKeys_);
+  obj["errorMessage"] = this->errorMessage_;
+  return obj;
+}
+
+void EnforceDistinctNode::accept(
+    const PlanNodeVisitor& visitor,
+    PlanNodeVisitorContext& context) const {
+  visitor.visit(*this, context);
+}
+
+// static
+PlanNodePtr EnforceDistinctNode::create(
+    const folly::dynamic& obj,
+    void* context) {
+  auto source = deserializeSingleSource(obj, context);
+  auto distinctKeys = deserializeFields(obj["distinctKeys"], context);
+  auto preGroupedKeys = deserializeFields(obj["preGroupedKeys"], context);
+  auto errorMessage = obj["errorMessage"].asString();
+
+  return std::make_shared<EnforceDistinctNode>(
+      deserializePlanNodeId(obj),
+      distinctKeys,
+      preGroupedKeys,
+      errorMessage,
+      source);
+}
+
+RowTypePtr getMarkSortedOutputType(
+    const RowTypePtr& inputType,
+    const std::string& markerName) {
+  std::vector<std::string> names = inputType->names();
+  std::vector<TypePtr> types = inputType->children();
+
+  names.emplace_back(markerName);
+  types.emplace_back(BOOLEAN());
+  return ROW(std::move(names), std::move(types));
+}
+
+MarkSortedNode::MarkSortedNode(
+    PlanNodeId id,
+    std::string markerName,
+    std::vector<FieldAccessTypedExprPtr> sortingKeys,
+    std::vector<SortOrder> sortingOrders,
+    PlanNodePtr source)
+    : PlanNode(std::move(id)),
+      markerName_(std::move(markerName)),
+      sortingKeys_(std::move(sortingKeys)),
+      sortingOrders_(std::move(sortingOrders)),
+      sources_{std::move(source)},
+      outputType_(
+          getMarkSortedOutputType(sources_[0]->outputType(), markerName_)) {
+  VELOX_USER_CHECK_GT(markerName_.size(), 0);
+  VELOX_USER_CHECK_GT(sortingKeys_.size(), 0);
+  VELOX_USER_CHECK_EQ(
+      sortingKeys_.size(),
+      sortingOrders_.size(),
+      "Number of sorting keys and sorting orders must be the same");
+}
+
+void MarkSortedNode::addDetails(std::stringstream& stream) const {
+  stream << "marker: " << markerName_ << ", keys: [";
+  for (auto i = 0; i < sortingKeys_.size(); ++i) {
+    if (i > 0) {
+      stream << ", ";
+    }
+    stream << sortingKeys_[i]->name() << " " << sortingOrders_[i].toString();
+  }
+  stream << "]";
+}
+
+folly::dynamic MarkSortedNode::serialize() const {
+  auto obj = PlanNode::serialize();
+  obj["markerName"] = this->markerName_;
+  obj["sortingKeys"] = ISerializable::serialize(this->sortingKeys_);
+  obj["sortingOrders"] = ISerializable::serialize(this->sortingOrders_);
+  return obj;
+}
+
+void MarkSortedNode::accept(
+    const PlanNodeVisitor& visitor,
+    PlanNodeVisitorContext& context) const {
+  visitor.visit(*this, context);
+}
+
+// static
+PlanNodePtr MarkSortedNode::create(const folly::dynamic& obj, void* context) {
+  auto source = deserializeSingleSource(obj, context);
+  auto markerName = obj["markerName"].asString();
+  auto sortingKeys = deserializeFields(obj["sortingKeys"], context);
+  auto sortingOrders = deserializeSortingOrders(obj["sortingOrders"]);
+
+  return std::make_shared<MarkSortedNode>(
+      deserializePlanNodeId(obj),
+      markerName,
+      sortingKeys,
+      sortingOrders,
+      source);
+}
+
 namespace {
 RowTypePtr getRowNumberOutputType(
     const RowTypePtr& inputType,
@@ -2486,7 +2736,7 @@ const char* TopNRowNumberNode::rankFunctionName(
   static const auto kFunctionNames = rankFunctionNames();
   auto it = kFunctionNames.find(function);
   VELOX_CHECK(
-      it != kFunctionNames.end(),
+      it != kFunctionNames.cend(),
       "Invalid rank function {}",
       static_cast<int>(function));
   return it->second.c_str();
@@ -2497,7 +2747,7 @@ TopNRowNumberNode::RankFunction TopNRowNumberNode::rankFunctionFromName(
     std::string_view name) {
   static const auto kFunctionNames = invertMap(rankFunctionNames());
   auto it = kFunctionNames.find(name.data());
-  VELOX_CHECK(it != kFunctionNames.end(), "Invalid rank function {}", name);
+  VELOX_CHECK(it != kFunctionNames.cend(), "Invalid rank function {}", name);
   return it->second;
 }
 
@@ -2640,8 +2890,135 @@ PlanNodePtr LocalMergeNode::create(const folly::dynamic& obj, void* context) {
       std::move(sources));
 }
 
+namespace {
+// Validates that grouping keys in 'spec' are present in 'type' and have no
+// duplicates. 'context' is used in error messages (e.g. "written columns",
+// "source output").
+void validateGroupingKeys(
+    const ColumnStatsSpec& spec,
+    const RowType& type,
+    std::string_view context) {
+  folly::F14FastSet<std::string> seenKeys;
+  for (const auto& key : spec.groupingKeys) {
+    VELOX_USER_CHECK(
+        type.containsChild(key->name()),
+        "Grouping key not found in {}: {}",
+        context,
+        key->name());
+    VELOX_USER_CHECK(
+        seenKeys.insert(key->name()).second,
+        "Duplicate grouping key: {}",
+        key->name());
+  }
+}
+} // namespace
+
+TableWriteNode::TableWriteNode(
+    const PlanNodeId& id,
+    const RowTypePtr& columns,
+    const std::vector<std::string>& columnNames,
+    std::optional<ColumnStatsSpec> columnStatsSpec,
+    std::shared_ptr<const InsertTableHandle> insertTableHandle,
+    bool hasPartitioningScheme,
+    RowTypePtr outputType,
+    connector::CommitStrategy commitStrategy,
+    const PlanNodePtr& source)
+    : PlanNode(id),
+      sources_{source},
+      columns_{columns},
+      columnNames_{columnNames},
+      columnStatsSpec_(std::move(columnStatsSpec)),
+      insertTableHandle_(std::move(insertTableHandle)),
+      hasPartitioningScheme_(hasPartitioningScheme),
+      outputType_(std::move(outputType)),
+      commitStrategy_(commitStrategy) {
+  VELOX_USER_CHECK_NOT_NULL(sources_[0]);
+  VELOX_USER_CHECK_NOT_NULL(insertTableHandle_);
+  VELOX_USER_CHECK_EQ(columns_->size(), columnNames_.size());
+  for (const auto& column : columns_->names()) {
+    VELOX_USER_CHECK(
+        sources_[0]->outputType()->containsChild(column),
+        "Column not found in TableWrite input: {}",
+        column);
+  }
+  if (columnStatsSpec_.has_value()) {
+    VELOX_USER_CHECK(
+        columnStatsSpec_->aggregationStep == AggregationNode::Step::kSingle ||
+            columnStatsSpec_->aggregationStep ==
+                AggregationNode::Step::kPartial,
+        "TableWriteNode requires aggregation step to be single or partial");
+    validateGroupingKeys(
+        columnStatsSpec_.value(), *columns_, "written columns");
+  }
+  // Single-column BIGINT output with no stats spec. Used by Spark/Gluten
+  // and other non-Prestissimo integrations.
+  if (outputType_->size() == 1 && !columnStatsSpec_.has_value()) {
+    VELOX_USER_CHECK_EQ(
+        outputType_->childAt(0)->kind(),
+        TypeKind::BIGINT,
+        "Single-column outputType must be BIGINT");
+    return;
+  }
+  const auto expectedType = TableWriteTraits::outputType(columnStatsSpec_);
+  VELOX_USER_CHECK(
+      outputType_->equivalent(*expectedType),
+      "TableWriteNode outputType mismatch: {} vs computed {}",
+      outputType_->toString(),
+      expectedType->toString());
+}
+
+namespace {
+void addStatsSpecDetails(
+    std::stringstream& stream,
+    const std::optional<ColumnStatsSpec>& spec) {
+  if (!spec.has_value()) {
+    return;
+  }
+  stream << "stats[" << AggregationNode::toName(spec->aggregationStep);
+  if (!spec->groupingKeys.empty()) {
+    stream << " [";
+    addFields(stream, spec->groupingKeys);
+    stream << "]";
+  }
+  stream << ": ";
+  for (auto i = 0; i < spec->aggregates.size(); ++i) {
+    appendComma(i, stream);
+    stream << spec->aggregates[i].call->toString();
+  }
+  stream << "]";
+}
+} // namespace
+
 void TableWriteNode::addDetails(std::stringstream& stream) const {
-  stream << insertTableHandle_->connectorInsertTableHandle()->toString();
+  stream << insertTableHandle_->connectorId() << ", "
+         << folly::join(", ", columnNames_);
+  if (columnStatsSpec_.has_value()) {
+    stream << ", ";
+    addStatsSpecDetails(stream, columnStatsSpec_);
+  }
+}
+
+RowTypePtr ColumnStatsSpec::outputType() const {
+  // Create output type based on the column stats collection specs.
+  std::vector<std::string> names;
+  std::vector<TypePtr> types;
+
+  const auto numAggregates = aggregates.size();
+  const auto outputTypeSize = groupingKeys.size() + numAggregates;
+
+  names.reserve(outputTypeSize);
+  types.reserve(outputTypeSize);
+
+  for (const auto& key : groupingKeys) {
+    names.push_back(key->name());
+    types.push_back(key->type());
+  }
+
+  for (auto i = 0; i < numAggregates; ++i) {
+    names.push_back(aggregateNames[i]);
+    types.push_back(aggregates[i].call->type());
+  }
+  return ROW(std::move(names), std::move(types));
 }
 
 folly::dynamic ColumnStatsSpec::serialize() const {
@@ -2709,11 +3086,6 @@ PlanNodePtr TableWriteNode::create(const folly::dynamic& obj, void* context) {
   auto columns = deserializeRowType(obj["columns"]);
   auto columnNames =
       ISerializable::deserialize<std::vector<std::string>>(obj["columnNames"]);
-  AggregationNodePtr aggregationNode;
-  if (obj.count("aggregationNode") != 0) {
-    aggregationNode = ISerializable::deserialize<AggregationNode>(
-        obj["aggregationNode"], context);
-  }
   auto connectorId = obj["connectorId"].asString();
   auto connectorInsertTableHandle =
       ISerializable::deserialize<connector::ConnectorInsertTableHandle>(
@@ -2739,7 +3111,36 @@ PlanNodePtr TableWriteNode::create(const folly::dynamic& obj, void* context) {
       deserializeSingleSource(obj, context));
 }
 
-void TableWriteMergeNode::addDetails(std::stringstream& /* stream */) const {}
+TableWriteMergeNode::TableWriteMergeNode(
+    const PlanNodeId& id,
+    RowTypePtr outputType,
+    std::optional<ColumnStatsSpec> columnStatsSpec,
+    PlanNodePtr source)
+    : PlanNode(id),
+      columnStatsSpec_(std::move(columnStatsSpec)),
+      sources_{std::move(source)},
+      outputType_(std::move(outputType)) {
+  VELOX_USER_CHECK_NOT_NULL(sources_[0]);
+  const auto expectedType = TableWriteTraits::outputType(columnStatsSpec_);
+  VELOX_USER_CHECK(
+      outputType_->equivalent(*expectedType),
+      "TableWriteMergeNode outputType mismatch: {} vs computed {}",
+      outputType_->toString(),
+      expectedType->toString());
+  if (hasColumnStatsSpec()) {
+    VELOX_USER_CHECK(
+        columnStatsSpec_->aggregationStep == AggregationNode::Step::kFinal ||
+            columnStatsSpec_->aggregationStep ==
+                AggregationNode::Step::kIntermediate,
+        "TableWriteMergeNode requires aggregation step to be intermediate or final");
+    validateGroupingKeys(
+        columnStatsSpec_.value(), *sources_[0]->outputType(), "source output");
+  }
+}
+
+void TableWriteMergeNode::addDetails(std::stringstream& stream) const {
+  addStatsSpecDetails(stream, columnStatsSpec_);
+}
 
 folly::dynamic TableWriteMergeNode::serialize() const {
   auto obj = PlanNode::serialize();
@@ -2780,8 +3181,8 @@ MergeExchangeNode::MergeExchangeNode(
     const RowTypePtr& type,
     const std::vector<FieldAccessTypedExprPtr>& sortingKeys,
     const std::vector<SortOrder>& sortingOrders,
-    VectorSerde::Kind serdeKind)
-    : ExchangeNode(id, type, serdeKind),
+    std::string serdeKind)
+    : ExchangeNode(id, type, std::move(serdeKind)),
       sortingKeys_(sortingKeys),
       sortingOrders_(sortingOrders) {}
 
@@ -2796,7 +3197,7 @@ folly::dynamic MergeExchangeNode::serialize() const {
   obj["outputType"] = ExchangeNode::outputType()->serialize();
   obj["sortingKeys"] = ISerializable::serialize(sortingKeys_);
   obj["sortingOrders"] = serializeSortingOrders(sortingOrders_);
-  obj["serdeKind"] = VectorSerde::kindName(serdeKind());
+  obj["serdeKind"] = serdeKind();
   return obj;
 }
 
@@ -2813,7 +3214,7 @@ PlanNodePtr MergeExchangeNode::create(
   const auto outputType = deserializeRowType(obj["outputType"]);
   const auto sortingKeys = deserializeFields(obj["sortingKeys"], context);
   const auto sortingOrders = deserializeSortingOrders(obj["sortingOrders"]);
-  const auto serdeKind = VectorSerde::kindByName(obj["serdeKind"].asString());
+  const auto serdeKind = obj["serdeKind"].asString();
   return std::make_shared<MergeExchangeNode>(
       deserializePlanNodeId(obj),
       outputType,
@@ -2883,7 +3284,7 @@ PartitionedOutputNode::PartitionedOutputNode(
     bool replicateNullsAndAny,
     PartitionFunctionSpecPtr partitionFunctionSpec,
     RowTypePtr outputType,
-    VectorSerde::Kind serdeKind,
+    std::string serdeKind,
     PlanNodePtr source)
     : PlanNode(id),
       kind_(kind),
@@ -2892,7 +3293,7 @@ PartitionedOutputNode::PartitionedOutputNode(
       numPartitions_(numPartitions),
       replicateNullsAndAny_(replicateNullsAndAny),
       partitionFunctionSpec_(std::move(partitionFunctionSpec)),
-      serdeKind_(serdeKind),
+      serdeKind_(std::move(serdeKind)),
       outputType_(std::move(outputType)) {
   VELOX_USER_CHECK_GT(numPartitions_, 0);
   if (numPartitions_ == 1) {
@@ -2917,7 +3318,7 @@ std::shared_ptr<PartitionedOutputNode> PartitionedOutputNode::broadcast(
     const PlanNodeId& id,
     int numPartitions,
     RowTypePtr outputType,
-    VectorSerde::Kind serdeKind,
+    std::string serdeKind,
     PlanNodePtr source) {
   std::vector<TypedExprPtr> noKeys;
   return std::make_shared<PartitionedOutputNode>(
@@ -2936,7 +3337,7 @@ std::shared_ptr<PartitionedOutputNode> PartitionedOutputNode::broadcast(
 std::shared_ptr<PartitionedOutputNode> PartitionedOutputNode::arbitrary(
     const PlanNodeId& id,
     RowTypePtr outputType,
-    VectorSerde::Kind serdeKind,
+    std::string serdeKind,
     PlanNodePtr source) {
   std::vector<TypedExprPtr> noKeys;
   return std::make_shared<PartitionedOutputNode>(
@@ -2955,7 +3356,7 @@ std::shared_ptr<PartitionedOutputNode> PartitionedOutputNode::arbitrary(
 std::shared_ptr<PartitionedOutputNode> PartitionedOutputNode::single(
     const PlanNodeId& id,
     RowTypePtr outputType,
-    VectorSerde::Kind serdeKind,
+    std::string serdeKind,
     PlanNodePtr source) {
   std::vector<TypedExprPtr> noKeys;
   return std::make_shared<PartitionedOutputNode>(
@@ -3037,7 +3438,7 @@ folly::dynamic PartitionedOutputNode::serialize() const {
   obj["keys"] = ISerializable::serialize(keys_);
   obj["replicateNullsAndAny"] = replicateNullsAndAny_;
   obj["partitionFunctionSpec"] = partitionFunctionSpec_->serialize();
-  obj["serdeKind"] = VectorSerde::kindName(serdeKind_);
+  obj["serdeKind"] = serdeKind_;
   obj["outputType"] = outputType_->serialize();
   return obj;
 }
@@ -3061,7 +3462,7 @@ PlanNodePtr PartitionedOutputNode::create(
       ISerializable::deserialize<PartitionFunctionSpec>(
           obj["partitionFunctionSpec"], context),
       deserializeRowType(obj["outputType"]),
-      VectorSerde::kindByName(obj["serdeKind"].asString()),
+      obj["serdeKind"].asString(),
       deserializeSingleSource(obj, context));
 }
 
@@ -3069,21 +3470,30 @@ SpatialJoinNode::SpatialJoinNode(
     const PlanNodeId& id,
     JoinType joinType,
     TypedExprPtr joinCondition,
+    FieldAccessTypedExprPtr probeGeometry,
+    FieldAccessTypedExprPtr buildGeometry,
+    std::optional<FieldAccessTypedExprPtr> radius,
     PlanNodePtr left,
     PlanNodePtr right,
     RowTypePtr outputType)
     : PlanNode(id),
       joinType_(joinType),
       joinCondition_(std::move(joinCondition)),
+      probeGeometry_(std::move(probeGeometry)),
+      buildGeometry_(std::move(buildGeometry)),
+      radius_(std::move(radius)),
       sources_({std::move(left), std::move(right)}),
       outputType_(std::move(outputType)) {
   VELOX_USER_CHECK(
       isSupported(joinType_),
       "The join type is not supported by spatial join: {}",
       JoinTypeName::toName(joinType_));
-  VELOX_USER_CHECK(
-      joinCondition_ != nullptr,
-      "The join condition must not be null for spatial join");
+  VELOX_USER_CHECK_NOT_NULL(
+      joinCondition_, "The join condition must not be null for spatial join");
+  VELOX_USER_CHECK_NOT_NULL(
+      probeGeometry_, "Probe geometery must not be null for spatial joins");
+  VELOX_USER_CHECK_NOT_NULL(
+      buildGeometry_, "Build geometery must not be null for spatial joins");
   VELOX_USER_CHECK_EQ(
       sources_.size(), 2, "Must have 2 sources for spatial joins");
   VELOX_USER_CHECK(
@@ -3092,7 +3502,7 @@ SpatialJoinNode::SpatialJoinNode(
       sources_[1] != nullptr,
       "Right source must not be null for spatial joins");
 
-  checkJoinColumnNames(
+  checkJoinOutput(
       sources_[0]->outputType(),
       sources_[1]->outputType(),
       outputType_,
@@ -3115,6 +3525,11 @@ void SpatialJoinNode::addDetails(std::stringstream& stream) const {
   if (joinCondition_) {
     stream << ", joinCondition: " << joinCondition_->toString();
   }
+  stream << ", probeGeometry: " << probeGeometry_->name();
+  stream << ", buildGeometry: " << buildGeometry_->name();
+  if (radius_) {
+    stream << ", radius: " << radius_.value()->name();
+  }
 }
 
 folly::dynamic SpatialJoinNode::serialize() const {
@@ -3124,6 +3539,11 @@ folly::dynamic SpatialJoinNode::serialize() const {
     obj["joinCondition"] = joinCondition_->serialize();
   }
   obj["outputType"] = outputType_->serialize();
+  obj["probeGeometry"] = probeGeometry_->serialize();
+  obj["buildGeometry"] = buildGeometry_->serialize();
+  if (radius_) {
+    obj["radius"] = radius_.value()->serialize();
+  }
   return obj;
 }
 
@@ -3144,11 +3564,20 @@ PlanNodePtr SpatialJoinNode::create(const folly::dynamic& obj, void* context) {
   }
 
   auto outputType = deserializeRowType(obj["outputType"]);
+  auto probeGeometry = deserializeField(obj["probeGeometry"]);
+  auto buildGeometry = deserializeField(obj["buildGeometry"]);
+  std::optional<FieldAccessTypedExprPtr> radius;
+  if (obj.count("radius")) {
+    radius = deserializeField(obj["radius"]);
+  }
 
   return std::make_shared<SpatialJoinNode>(
       deserializePlanNodeId(obj),
       JoinTypeName::toJoinType(obj["joinType"].asString()),
       joinCondition,
+      probeGeometry,
+      buildGeometry,
+      radius,
       sources[0],
       sources[1],
       outputType);
@@ -3298,6 +3727,14 @@ void MarkDistinctNode::addDetails(std::stringstream& stream) const {
   addFields(stream, distinctKeys_);
 }
 
+void EnforceDistinctNode::addDetails(std::stringstream& stream) const {
+  if (isPreGrouped()) {
+    stream << "STREAMING ";
+  }
+  addFields(stream, distinctKeys_);
+  stream << " " << errorMessage_;
+}
+
 void PlanNode::toString(
     std::stringstream& stream,
     bool detailed,
@@ -3425,6 +3862,25 @@ void PlanNode::toSkeletonString(
   }
 }
 
+// static
+const PlanNode* PlanNode::findFirstNode(
+    const PlanNode* root,
+    const std::function<bool(const PlanNode* node)>& predicate) {
+  VELOX_CHECK_NOT_NULL(root);
+  if (predicate(root)) {
+    return root;
+  }
+
+  // Recursively go further through the sources.
+  for (const auto& source : root->sources()) {
+    const auto* ret = PlanNode::findFirstNode(source.get(), predicate);
+    if (ret != nullptr) {
+      return ret;
+    }
+  }
+  return nullptr;
+}
+
 namespace {
 void collectLeafPlanNodeIds(
     const PlanNode& planNode,
@@ -3455,6 +3911,7 @@ void PlanNode::registerSerDe() {
   registry.Register("AggregationNode", AggregationNode::create);
   registry.Register("AssignUniqueIdNode", AssignUniqueIdNode::create);
   registry.Register("EnforceSingleRowNode", EnforceSingleRowNode::create);
+  registry.Register("EnforceDistinctNode", EnforceDistinctNode::create);
   registry.Register("ExchangeNode", ExchangeNode::create);
   registry.Register("ExpandNode", ExpandNode::create);
   registry.Register("FilterNode", FilterNode::create);
@@ -3467,6 +3924,8 @@ void PlanNode::registerSerDe() {
   registry.Register("LimitNode", LimitNode::create);
   registry.Register("LocalMergeNode", LocalMergeNode::create);
   registry.Register("LocalPartitionNode", LocalPartitionNode::create);
+  registry.Register("MarkDistinctNode", MarkDistinctNode::create);
+  registry.Register("MarkSortedNode", MarkSortedNode::create);
   registry.Register("OrderByNode", OrderByNode::create);
   registry.Register("PartitionedOutputNode", PartitionedOutputNode::create);
   registry.Register("ProjectNode", ProjectNode::create);
@@ -3482,6 +3941,8 @@ void PlanNode::registerSerDe() {
   registry.Register("ValuesNode", ValuesNode::create);
   registry.Register("WindowNode", WindowNode::create);
   registry.Register("MarkDistinctNode", MarkDistinctNode::create);
+  registry.Register("MixedUnionNode", MixedUnionNode::create);
+  registry.Register("RPCNode", RPCNode::create);
   registry.Register(
       "GatherPartitionFunctionSpec", GatherPartitionFunctionSpec::deserialize);
 }
@@ -3587,7 +4048,7 @@ folly::dynamic IndexLookupCondition::serialize() const {
 }
 
 bool InIndexLookupCondition::isFilter() const {
-  return std::dynamic_pointer_cast<const ConstantTypedExpr>(list) != nullptr;
+  return list->isConstantKind();
 }
 
 folly::dynamic InIndexLookupCondition::serialize() const {
@@ -3605,16 +4066,13 @@ void InIndexLookupCondition::validate() const {
   VELOX_CHECK_NOT_NULL(key);
   VELOX_CHECK_NOT_NULL(list);
   VELOX_CHECK(
-      std::dynamic_pointer_cast<const FieldAccessTypedExpr>(list) ||
-          std::dynamic_pointer_cast<const ConstantTypedExpr>(list),
+      list->isFieldAccessKind() || list->isConstantKind(),
       "Invalid condition list {}",
       list->toString());
-  const auto listType =
-      std::dynamic_pointer_cast<const ArrayType>(list->type());
-  VELOX_CHECK_NOT_NULL(listType);
+  const auto& listType = list->type()->asArray();
   VELOX_CHECK_EQ(
       key->type()->kind(),
-      listType->elementType()->kind(),
+      listType.elementType()->kind(),
       "In condition key and list condition element must have the same type");
 }
 
@@ -3632,9 +4090,7 @@ IndexLookupConditionPtr InIndexLookupCondition::create(
 }
 
 bool BetweenIndexLookupCondition::isFilter() const {
-  return (std::dynamic_pointer_cast<const ConstantTypedExpr>(lower) !=
-          nullptr) &&
-      (std::dynamic_pointer_cast<const ConstantTypedExpr>(upper) != nullptr);
+  return lower->isConstantKind() && upper->isConstantKind();
 }
 
 folly::dynamic BetweenIndexLookupCondition::serialize() const {
@@ -3669,14 +4125,12 @@ void BetweenIndexLookupCondition::validate() const {
   VELOX_CHECK_NOT_NULL(lower);
   VELOX_CHECK_NOT_NULL(upper);
   VELOX_CHECK(
-      std::dynamic_pointer_cast<const FieldAccessTypedExpr>(lower) ||
-          std::dynamic_pointer_cast<const ConstantTypedExpr>(lower),
+      lower->isFieldAccessKind() || lower->isConstantKind(),
       "Invalid lower between condition {}",
       lower->toString());
 
   VELOX_CHECK(
-      std::dynamic_pointer_cast<const FieldAccessTypedExpr>(upper) ||
-          std::dynamic_pointer_cast<const ConstantTypedExpr>(upper),
+      upper->isFieldAccessKind() || upper->isConstantKind(),
       "Invalid upper between condition {}",
       upper->toString());
 
@@ -3692,7 +4146,7 @@ void BetweenIndexLookupCondition::validate() const {
 }
 
 bool EqualIndexLookupCondition::isFilter() const {
-  return std::dynamic_pointer_cast<const ConstantTypedExpr>(value) != nullptr;
+  return value->isConstantKind();
 }
 
 folly::dynamic EqualIndexLookupCondition::serialize() const {
@@ -3718,9 +4172,15 @@ IndexLookupConditionPtr EqualIndexLookupCondition::create(
 void EqualIndexLookupCondition::validate() const {
   VELOX_CHECK_NOT_NULL(key);
   VELOX_CHECK_NOT_NULL(value);
-  VELOX_CHECK_NOT_NULL(
-      std::dynamic_pointer_cast<const ConstantTypedExpr>(value),
-      "Equal condition value must be a constant expression: {}",
+  // Value can be either a constant expression or a field access expression
+  // (probe side column).
+  const bool isConstant =
+      std::dynamic_pointer_cast<const ConstantTypedExpr>(value) != nullptr;
+  const bool isFieldAccess =
+      std::dynamic_pointer_cast<const FieldAccessTypedExpr>(value) != nullptr;
+  VELOX_CHECK(
+      isConstant || isFieldAccess,
+      "Equal condition value must be a constant or field access expression: {}",
       value->toString());
 
   VELOX_CHECK_EQ(
@@ -3730,4 +4190,184 @@ void EqualIndexLookupCondition::validate() const {
       key->type()->toString(),
       value->type()->toString());
 }
+
+void MixedUnionNode::accept(
+    const PlanNodeVisitor& visitor,
+    PlanNodeVisitorContext& context) const {
+  visitor.visit(*this, context);
+}
+
+folly::dynamic MixedUnionNode::serialize() const {
+  auto obj = PlanNode::serialize();
+  return obj;
+}
+
+// static
+PlanNodePtr MixedUnionNode::create(const folly::dynamic& obj, void* context) {
+  auto sources = deserializeSources(obj, context);
+
+  return std::make_shared<MixedUnionNode>(
+      deserializePlanNodeId(obj), std::move(sources));
+}
+
+RPCNode::RPCNode(
+    const PlanNodeId& id,
+    PlanNodePtr source,
+    std::string functionName,
+    TypePtr functionResultType,
+    std::string outputColumn,
+    RowTypePtr outputType,
+    std::vector<std::string> argumentColumns,
+    std::vector<TypePtr> argumentTypes,
+    std::vector<VectorPtr> constantInputs,
+    rpc::RPCStreamingMode streamingMode,
+    int32_t dispatchBatchSize)
+    : PlanNode(id),
+      sources_{std::move(source)},
+      functionName_(std::move(functionName)),
+      resultType_(std::move(functionResultType)),
+      outputColumn_(std::move(outputColumn)),
+      outputType_(std::move(outputType)),
+      argumentColumns_(std::move(argumentColumns)),
+      argumentTypes_(std::move(argumentTypes)),
+      constantInputs_(std::move(constantInputs)),
+      streamingMode_(streamingMode),
+      dispatchBatchSize_(dispatchBatchSize) {
+  VELOX_CHECK_EQ(
+      argumentColumns_.size(),
+      argumentTypes_.size(),
+      "argumentColumns and argumentTypes must have the same size");
+  VELOX_CHECK_EQ(
+      argumentColumns_.size(),
+      constantInputs_.size(),
+      "argumentColumns and constantInputs must have the same size");
+  VELOX_CHECK(
+      outputType_->containsChild(outputColumn_),
+      "RPCNode outputType must contain the RPC result column: {}",
+      outputColumn_);
+}
+
+void RPCNode::addDetails(std::stringstream& stream) const {
+  stream << "function: " << functionName_ << ", outputColumn: " << outputColumn_
+         << ", streamingMode: "
+         << (streamingMode_ == rpc::RPCStreamingMode::kBatch ? "BATCH"
+                                                             : "PER_ROW");
+  if (dispatchBatchSize_ > 0) {
+    stream << ", dispatchBatchSize: " << dispatchBatchSize_;
+  }
+}
+
+folly::dynamic RPCNode::serialize() const {
+  auto obj = PlanNode::serialize();
+  obj["functionName"] = functionName_;
+  obj["resultType"] = resultType_->serialize();
+
+  // Serialize argument columns (string names).
+  auto colsArray = folly::dynamic::array();
+  for (const auto& col : argumentColumns_) {
+    colsArray.push_back(col);
+  }
+  obj["argumentColumns"] = std::move(colsArray);
+
+  // Serialize argument types.
+  obj["argumentTypes"] = ISerializable::serialize(argumentTypes_);
+
+  // Serialize constant inputs as ConstantTypedExpr for round-trip fidelity.
+  auto constArray = folly::dynamic::array();
+  for (size_t i = 0; i < constantInputs_.size(); ++i) {
+    if (constantInputs_[i]) {
+      auto constExpr =
+          std::make_shared<core::ConstantTypedExpr>(constantInputs_[i]);
+      constArray.push_back(constExpr->serialize());
+    } else {
+      constArray.push_back(nullptr);
+    }
+  }
+  obj["constantInputs"] = std::move(constArray);
+
+  obj["outputColumn"] = outputColumn_;
+  obj["outputType"] = outputType_->serialize();
+  obj["streamingMode"] =
+      streamingMode_ == rpc::RPCStreamingMode::kBatch ? "BATCH" : "PER_ROW";
+  obj["dispatchBatchSize"] = dispatchBatchSize_;
+  return obj;
+}
+
+// static
+PlanNodePtr RPCNode::create(const folly::dynamic& obj, void* context) {
+  auto source = deserializeSingleSource(obj, context);
+  auto functionName = obj["functionName"].asString();
+  auto resultType = ISerializable::deserialize<Type>(obj["resultType"]);
+
+  // Deserialize argument columns.
+  std::vector<std::string> argumentColumns;
+  if (obj.count("argumentColumns")) {
+    for (const auto& col : obj["argumentColumns"]) {
+      argumentColumns.push_back(col.asString());
+    }
+  }
+
+  // Deserialize argument types.
+  auto argumentTypes =
+      ISerializable::deserialize<std::vector<Type>>(obj["argumentTypes"]);
+
+  // Deserialize constant inputs from ConstantTypedExpr.
+  std::vector<VectorPtr> constantInputs;
+  if (obj.count("constantInputs")) {
+    for (const auto& item : obj["constantInputs"]) {
+      if (item.isNull()) {
+        constantInputs.push_back(nullptr);
+      } else {
+        auto constExpr = std::dynamic_pointer_cast<const ConstantTypedExpr>(
+            ISerializable::deserialize<ITypedExpr>(item, context));
+        VELOX_CHECK_NOT_NULL(
+            constExpr, "Expected ConstantTypedExpr for constant input");
+        auto* pool = static_cast<memory::MemoryPool*>(context);
+        constantInputs.push_back(constExpr->toConstantVector(pool));
+      }
+    }
+  }
+
+  auto outputColumn = obj["outputColumn"].asString();
+
+  // Deserialize explicit output type.
+  RowTypePtr outputType;
+  if (obj.count("outputType")) {
+    outputType = std::dynamic_pointer_cast<const RowType>(
+        ISerializable::deserialize<Type>(obj["outputType"]));
+  } else {
+    // Backward compat: derive from source + result column.
+    std::vector<std::string> names;
+    std::vector<TypePtr> types;
+    if (source) {
+      auto sourceType = source->outputType();
+      for (int32_t i = 0; i < sourceType->size(); ++i) {
+        names.emplace_back(sourceType->nameOf(i));
+        types.push_back(sourceType->childAt(i));
+      }
+    }
+    names.push_back(outputColumn);
+    types.push_back(resultType);
+    outputType = ROW(std::move(names), std::move(types));
+  }
+
+  auto streamingMode = obj["streamingMode"].asString() == "BATCH"
+      ? rpc::RPCStreamingMode::kBatch
+      : rpc::RPCStreamingMode::kPerRow;
+  auto dispatchBatchSize =
+      static_cast<int32_t>(obj["dispatchBatchSize"].asInt());
+  return std::make_shared<RPCNode>(
+      deserializePlanNodeId(obj),
+      std::move(source),
+      std::move(functionName),
+      std::move(resultType),
+      std::move(outputColumn),
+      std::move(outputType),
+      std::move(argumentColumns),
+      std::move(argumentTypes),
+      std::move(constantInputs),
+      streamingMode,
+      dispatchBatchSize);
+}
+
 } // namespace facebook::velox::core
diff --git a/velox/core/PlanNode.h b/velox/core/PlanNode.h
index b5c82d29a2c..4d7d1017f4b 100644
--- a/velox/core/PlanNode.h
+++ b/velox/core/PlanNode.h
@@ -19,7 +19,8 @@
 
 #include <utility>
 
-#include "velox/common/Enums.h"
+#include "velox/common/EnumDeclare.h"
+#include "velox/common/rpc/RPCTypes.h"
 #include "velox/connectors/Connector.h"
 #include "velox/core/Expressions.h"
 #include "velox/core/QueryConfig.h"
@@ -206,6 +207,14 @@ class PlanNode : public ISerializable {
     return false;
   }
 
+  /// Returns true if this plan node requires single-threaded execution
+  /// (maxDrivers = 1). For example, ValuesNode, final OrderByNode, final
+  /// LimitNode, MergeExchangeNode, LocalMergeNode, and
+  /// LocalPartitionNode(Gather) all require single-threaded execution.
+  virtual bool requiresSingleThread() const {
+    return false;
+  }
+
   /// Returns true if this plan node operator supports task barrier processing.
   /// To support barrier processing, the operator must be able to drain its
   /// buffered output when it receives the drain signal at split boundary. Not
@@ -259,23 +268,28 @@ class PlanNode : public ISerializable {
   /// The name of the plan node, used in toString.
   virtual std::string_view name() const = 0;
 
+  template <typename T>
+  bool is() const {
+    return dynamic_cast<const T*>(this) != nullptr;
+  }
+
+  template <typename T>
+  const T* as() const {
+    return dynamic_cast<const T*>(this);
+  }
+
   /// Recursively checks the node tree for a first node that satisfy a given
   /// condition. Returns pointer to the node if found, nullptr if not.
   static const PlanNode* findFirstNode(
-      const PlanNode* node,
-      const std::function<bool(const PlanNode* node)>& predicate) {
-    if (predicate(node)) {
-      return node;
-    }
+      const PlanNode* root,
+      const std::function<bool(const PlanNode* node)>& predicate);
 
-    // Recursively go further through the sources.
-    for (const auto& source : node->sources()) {
-      const auto* ret = PlanNode::findFirstNode(source.get(), predicate);
-      if (ret != nullptr) {
-        return ret;
-      }
-    }
-    return nullptr;
+  /// @return PlanNode with matching ID or nullptr if not found.
+  static const PlanNode* findNodeById(
+      const PlanNode* root,
+      const PlanNodeId& id) {
+    return findFirstNode(
+        root, [&](const auto* node) { return node->id() == id; });
   }
 
  private:
@@ -386,6 +400,10 @@ class ValuesNode : public PlanNode {
   void accept(const PlanNodeVisitor& visitor, PlanNodeVisitorContext& context)
       const override;
 
+  bool requiresSingleThread() const override {
+    return !parallelizable_;
+  }
+
   const std::vector<RowVectorPtr>& values() const {
     return values_;
   }
@@ -488,6 +506,10 @@ class ArrowStreamNode : public PlanNode {
   void accept(const PlanNodeVisitor& visitor, PlanNodeVisitorContext& context)
       const override;
 
+  bool requiresSingleThread() const override {
+    return true;
+  }
+
   const std::shared_ptr<ArrowArrayStream>& arrowStream() const {
     return arrowStream_;
   }
@@ -1103,14 +1125,14 @@ class AggregationNode : public PlanNode {
 
     /// Optional name of input column to use as a mask. Column type must be
     /// BOOLEAN.
-    FieldAccessTypedExprPtr mask;
+    FieldAccessTypedExprPtr mask{};
 
     /// Optional list of input columns to sort by before applying aggregate
     /// function.
-    std::vector<FieldAccessTypedExprPtr> sortingKeys;
+    std::vector<FieldAccessTypedExprPtr> sortingKeys{};
 
     /// A list of sorting orders that goes together with 'sortingKeys'.
-    std::vector<SortOrder> sortingOrders;
+    std::vector<SortOrder> sortingOrders{};
 
     /// Boolean indicating whether inputs must be de-duplicated before
     /// aggregating.
@@ -1129,6 +1151,7 @@ class AggregationNode : public PlanNode {
       const std::vector<std::string>& aggregateNames,
       const std::vector<Aggregate>& aggregates,
       bool ignoreNullKeys,
+      bool noGroupsSpanBatches,
       PlanNodePtr source);
 
   /// @param globalGroupingSets Group IDs of the global grouping sets produced
@@ -1150,6 +1173,7 @@ class AggregationNode : public PlanNode {
       const std::vector<vector_size_t>& globalGroupingSets,
       const std::optional<FieldAccessTypedExprPtr>& groupId,
       bool ignoreNullKeys,
+      bool noGroupsSpanBatches,
       PlanNodePtr source);
 
   class Builder {
@@ -1166,6 +1190,7 @@ class AggregationNode : public PlanNode {
       globalGroupingSets_ = other.globalGroupingSets();
       groupId_ = other.groupId();
       ignoreNullKeys_ = other.ignoreNullKeys();
+      noGroupsSpanBatches_ = other.noGroupsSpanBatches();
       VELOX_CHECK_EQ(other.sources().size(), 1);
       source_ = other.sources()[0];
     }
@@ -1216,6 +1241,11 @@ class AggregationNode : public PlanNode {
       return *this;
     }
 
+    Builder& noGroupsSpanBatches(bool noGroupsSpanBatches) {
+      noGroupsSpanBatches_ = noGroupsSpanBatches;
+      return *this;
+    }
+
     Builder& source(PlanNodePtr source) {
       source_ = std::move(source);
       return *this;
@@ -1250,6 +1280,7 @@ class AggregationNode : public PlanNode {
           globalGroupingSets_,
           groupId_,
           ignoreNullKeys_.value(),
+          noGroupsSpanBatches_,
           source_.value());
     }
 
@@ -1263,6 +1294,7 @@ class AggregationNode : public PlanNode {
     std::vector<vector_size_t> globalGroupingSets_ = kDefaultGlobalGroupingSets;
     std::optional<FieldAccessTypedExprPtr> groupId_ = kDefaultGroupId;
     std::optional<bool> ignoreNullKeys_;
+    bool noGroupsSpanBatches_{false};
     std::optional<PlanNodePtr> source_;
   };
 
@@ -1296,10 +1328,10 @@ class AggregationNode : public PlanNode {
   bool isPreGrouped() const {
     return !preGroupedKeys_.empty() &&
         std::equal(
-            preGroupedKeys_.begin(),
-            preGroupedKeys_.end(),
-            groupingKeys_.begin(),
-            groupingKeys_.end(),
+            preGroupedKeys_.cbegin(),
+            preGroupedKeys_.cend(),
+            groupingKeys_.cbegin(),
+            groupingKeys_.cend(),
             [](const FieldAccessTypedExprPtr& x,
                const FieldAccessTypedExprPtr& y) -> bool {
               return (*x == *y);
@@ -1322,10 +1354,19 @@ class AggregationNode : public PlanNode {
     return globalGroupingSets_;
   }
 
-  std::optional<FieldAccessTypedExprPtr> groupId() const {
+  const std::optional<FieldAccessTypedExprPtr>& groupId() const {
     return groupId_;
   }
 
+  /// When true, indicates that for streaming aggregation, no sort group spans
+  /// across input batches. Each input batch contains complete data for its
+  /// groups - no group will appear in any subsequent input batch. This allows
+  /// the streaming aggregation operator to immediately produce the aggregation
+  /// result for all the groups in each input batch.
+  bool noGroupsSpanBatches() const {
+    return noGroupsSpanBatches_;
+  }
+
   std::string_view name() const override {
     return "Aggregation";
   }
@@ -1362,8 +1403,15 @@ class AggregationNode : public PlanNode {
   const std::vector<Aggregate> aggregates_;
   const bool ignoreNullKeys_;
 
-  std::optional<FieldAccessTypedExprPtr> groupId_;
-  std::vector<vector_size_t> globalGroupingSets_;
+  const std::optional<FieldAccessTypedExprPtr> groupId_;
+  const std::vector<vector_size_t> globalGroupingSets_;
+
+  // When true, indicates that for streaming aggregation, no sort group spans
+  // across input batches. Each input batch contains complete data for its
+  // groups - no group will appear in any subsequent input batch. This allows
+  // the streaming aggregation operator to immediately produce the aggregation
+  // result for all the groups in each input batch.
+  const bool noGroupsSpanBatches_;
 
   const std::vector<PlanNodePtr> sources_;
   const RowTypePtr outputType_;
@@ -1433,13 +1481,91 @@ struct ColumnStatsSpec : public ISerializable {
     VELOX_CHECK_EQ(aggregates.size(), aggregateNames.size());
   }
 
+  /// Returns the output row type that will be produced by this column stats
+  /// spec. The output type is determined by the grouping keys and aggregate
+  /// functions specified in the object.
+  RowTypePtr outputType() const;
+
   folly::dynamic serialize() const override;
 
   static ColumnStatsSpec create(const folly::dynamic& obj, void* context);
 };
 
+/// Writes input rows to a table via a connector-specific DataSink and
+/// optionally collects per-column statistics (count, min, max,
+/// approx_distinct) using an embedded ColumnStatsCollector.
+///
+/// Two output modes depending on outputType:
+///
+/// 1. Single-column BIGINT (Spark/Gluten): output is a single row count.
+///    No stats, no fragments, no commit context. Used when columnStatsSpec
+///    is not set.
+///
+/// 2. Multiplexed format (Prestissimo, see TableWriteTraits):
+///   Channel 0 (rows):      row count or NULL
+///   Channel 1 (fragments): file fragment data or NULL
+///   Channel 2 (context):   commit context JSON (always present)
+///   Channel 3+ (stats):    aggregated statistics columns (if configured)
+///
+///   Each operator instance (one per driver) produces three kinds of rows:
+///     - Statistics rows: rows=NULL, fragments=NULL, stats populated.
+///       One row per partition (or one row for unpartitioned tables).
+///     - Fragment rows:   rows=NULL, fragments=non-NULL, stats=NULL.
+///       One row per output file.
+///     - Summary row:     rows=totalCount, fragments=NULL, stats=NULL.
+///       One per driver, emitted last.
+///
+///   The context column (channel 2) is a JSON object. See
+///   TableWriteTraits for field names (taskId, lifespan,
+///   pageSinkCommitStrategy, lastPage). All rows carry context; the
+///   summary row has lastPage=true.
+///
+///   When columnStatsSpec is set, the aggregation step controls output types:
+///     - kSingle:  produces final statistics values (single-driver, no merge).
+///     - kPartial: produces intermediate aggregation state (requires a
+///                 downstream TableWriteMergeNode to finalize).
+///
+/// Typical plan topologies (data flows left to right):
+///
+///   Single-node, single-driver:
+///     Input → TableWrite(kSingle)
+///
+///   Single-node, multi-driver:
+///     Input → TableWrite(kPartial) → LocalGather → TableWriteMerge(kFinal)
+///
+///   Multi-node, multi-driver:
+///     Worker:      Input → TableWrite(kPartial) → LocalGather
+///                    → TableWriteMerge(kIntermediate) → PartitionedOutput
+///     Coordinator: Exchange → TableWriteMerge(kFinal)
+///     In Prestissimo, the coordinator uses Presto's Java
+///     TableFinishOperator instead of TableWriteMerge.
 class TableWriteNode : public PlanNode {
  public:
+  /// @param id Plan node ID.
+  /// @param columns Subset of source output columns to write, potentially
+  /// reordered. The names in this type must match columns in the source
+  /// output (used to build the input-to-output column mapping).
+  /// @param columnNames Target table column names for the written data.
+  /// Aligned 1:1 with 'columns'. May differ from 'columns' names when the
+  /// query renames columns (e.g. source has "expr_0" but table column is
+  /// "key"). The DataSink receives data using these names.
+  /// @param columnStatsSpec Optional specification for column statistics
+  /// collection. When set, the operator collects per-column aggregates
+  /// (count, min, max, approx_distinct) alongside the write. Restrictions:
+  ///   - aggregation step must be kSingle or kPartial.
+  ///   - grouping keys must be a subset of 'columns' (partition columns).
+  ///   - grouping keys must not contain duplicates.
+  /// @param insertTableHandle Connector-specific handle identifying the
+  /// target table and write operation.
+  /// @param hasPartitioningScheme Whether a partitioning scheme is configured
+  /// for shuffles. Controls which query config determines the number of
+  /// writer operator instances: 'task_partitioned_writer_count' if true,
+  /// 'task_writer_count' if false.
+  /// @param outputType Output row type. For Prestissimo, must match
+  /// TableWriteTraits::outputType(columnStatsSpec). For Spark/Gluten, a
+  /// single-column BIGINT type with no columnStatsSpec.
+  /// @param commitStrategy Commit strategy for the write operation.
+  /// @param source Input plan node providing rows to write.
   TableWriteNode(
       const PlanNodeId& id,
       const RowTypePtr& columns,
@@ -1449,25 +1575,7 @@ class TableWriteNode : public PlanNode {
       bool hasPartitioningScheme,
       RowTypePtr outputType,
       connector::CommitStrategy commitStrategy,
-      const PlanNodePtr& source)
-      : PlanNode(id),
-        sources_{source},
-        columns_{columns},
-        columnNames_{columnNames},
-        columnStatsSpec_(std::move(columnStatsSpec)),
-        insertTableHandle_(std::move(insertTableHandle)),
-        hasPartitioningScheme_(hasPartitioningScheme),
-        outputType_(std::move(outputType)),
-        commitStrategy_(commitStrategy) {
-    VELOX_USER_CHECK_EQ(columns_->size(), columnNames_.size());
-    for (const auto& column : columns_->names()) {
-      VELOX_USER_CHECK(
-          source->outputType()->containsChild(column),
-          "Column {} not found in TableWriter input: {}",
-          column,
-          source->outputType()->toString());
-    }
-  }
+      const PlanNodePtr& source);
 
   class Builder {
    public:
@@ -1605,8 +1713,7 @@ class TableWriteNode : public PlanNode {
   /// Indicates if this table write plan node has specified partitioning
   /// scheme for remote and local shuffles. If true, the task creates a
   /// number of table write operators based on the query config
-  /// 'task_partitioned_writer_count', otherwise based on
-  /// x'task_writer_count'.
+  /// 'task_partitioned_writer_count', otherwise based on 'task_writer_count'.
   bool hasPartitioningScheme() const {
     return hasPartitioningScheme_;
   }
@@ -1615,17 +1722,19 @@ class TableWriteNode : public PlanNode {
     return commitStrategy_;
   }
 
-  /// Returns true of this table write plan node has configured column
-  /// statistics collection.
   bool hasColumnStatsSpec() const {
     return columnStatsSpec_.has_value();
   }
 
-  /// Optional spec for column statistics collection.
   const std::optional<ColumnStatsSpec>& columnStatsSpec() const {
     return columnStatsSpec_;
   }
 
+  bool requiresSingleThread() const override {
+    return !insertTableHandle_->connectorInsertTableHandle()
+                ->supportsMultiThreading();
+  }
+
   bool canSpill(const QueryConfig& queryConfig) const override {
     return queryConfig.writerSpillEnabled();
   }
@@ -1653,29 +1762,50 @@ class TableWriteNode : public PlanNode {
 
 using TableWriteNodePtr = std::shared_ptr<const TableWriteNode>;
 
+/// Merges output from multiple TableWrite operators. Collects fragments,
+/// accumulates row counts, and aggregates column statistics using an
+/// embedded ColumnStatsCollector.
+///
+/// Input rows are classified per-row using TableWriteTraits::isStatisticsRow
+/// (see TableWriteTraits). Input batches may contain a mix of statistics and
+/// data rows (e.g. when receiving batched output from an exchange):
+///   - Statistics rows (rows=NULL, fragments=NULL): routed to the stats
+///     collector for aggregation.
+///   - Data rows (rows or fragments non-NULL): row counts are accumulated,
+///     fragments are buffered, and commit context is validated for
+///     consistency (all inputs must share the same commit strategy;
+///     taskId may differ in cross-worker merge).
+///
+/// Output follows the same three-phase protocol as TableWriteNode:
+///   1. Fragment rows (emitted first, to free memory).
+///   2. Aggregated statistics rows from the stats collector.
+///   3. Summary row with total row count and lastPage=true.
+///
+/// The aggregation step in ColumnStatsSpec must be kIntermediate or kFinal:
+///   - kIntermediate: reads partial state, produces partial state (for
+///     further merging downstream).
+///   - kFinal: reads partial state, produces final scalar values.
+///
+/// Supports both single-task multi-driver merge (via LocalGather) and
+/// cross-task merge (via Exchange from multiple workers).
 class TableWriteMergeNode : public PlanNode {
  public:
-  /// 'outputType' specifies the type to store the metadata of table write
-  /// output which contains the following columns: 'numWrittenRows',
-  /// 'fragment' and 'tableCommitContext'.
+  /// @param id Plan node ID.
+  /// @param columnStatsSpec Optional specification for column statistics
+  /// aggregation. Restrictions:
+  ///   - aggregation step must be kIntermediate or kFinal.
+  ///   - grouping keys must be present in source output type.
+  ///   - grouping keys must not contain duplicates.
+  /// @param outputType Output row type. Column names may differ from
+  /// TableWriteTraits defaults (e.g. Prestissimo appends node ID suffixes).
+  /// Types must match TableWriteTraits::outputType(columnStatsSpec).
+  /// @param source Input plan node, typically a LocalGather over
+  /// TableWriteNode(s).
   TableWriteMergeNode(
       const PlanNodeId& id,
       RowTypePtr outputType,
       std::optional<ColumnStatsSpec> columnStatsSpec,
-      PlanNodePtr source)
-      : PlanNode(id),
-        columnStatsSpec_(std::move(columnStatsSpec)),
-        sources_{std::move(source)},
-        outputType_(std::move(outputType)) {
-    if (hasColumnStatsSpec()) {
-      VELOX_USER_CHECK(
-          columnStatsSpec_->aggregationStep ==
-                  core::AggregationNode::Step::kFinal ||
-              columnStatsSpec_->aggregationStep ==
-                  core::AggregationNode::Step::kIntermediate,
-          "TableWriteMergeNode requires aggregation step to be intermediate or final");
-    }
-  }
+      PlanNodePtr source);
 
   class Builder {
    public:
@@ -1738,6 +1868,10 @@ class TableWriteMergeNode : public PlanNode {
     return columnStatsSpec_;
   }
 
+  bool requiresSingleThread() const override {
+    return true;
+  }
+
   const std::vector<PlanNodePtr>& sources() const override {
     return sources_;
   }
@@ -2044,11 +2178,8 @@ using GroupIdNodePtr = std::shared_ptr<const GroupIdNode>;
 
 class ExchangeNode : public PlanNode {
  public:
-  ExchangeNode(
-      const PlanNodeId& id,
-      RowTypePtr type,
-      VectorSerde::Kind serdeKind)
-      : PlanNode(id), outputType_(type), serdeKind_(serdeKind) {}
+  ExchangeNode(const PlanNodeId& id, RowTypePtr type, std::string serdeKind)
+      : PlanNode(id), outputType_(type), serdeKind_(std::move(serdeKind)) {}
 
   class Builder {
    public:
@@ -2070,8 +2201,8 @@ class ExchangeNode : public PlanNode {
       return *this;
     }
 
-    Builder& serdeKind(VectorSerde::Kind serdeKind) {
-      serdeKind_ = serdeKind;
+    Builder& serdeKind(std::string serdeKind) {
+      serdeKind_ = std::move(serdeKind);
       return *this;
     }
 
@@ -2089,7 +2220,7 @@ class ExchangeNode : public PlanNode {
    private:
     std::optional<PlanNodeId> id_;
     std::optional<RowTypePtr> outputType_;
-    std::optional<VectorSerde::Kind> serdeKind_;
+    std::optional<std::string> serdeKind_;
   };
 
   const RowTypePtr& outputType() const override {
@@ -2113,7 +2244,7 @@ class ExchangeNode : public PlanNode {
     return "Exchange";
   }
 
-  VectorSerde::Kind serdeKind() const {
+  const std::string& serdeKind() const {
     return serdeKind_;
   }
 
@@ -2125,7 +2256,7 @@ class ExchangeNode : public PlanNode {
   void addDetails(std::stringstream& stream) const override;
 
   const RowTypePtr outputType_;
-  const VectorSerde::Kind serdeKind_;
+  const std::string serdeKind_;
 };
 
 using ExchangeNodePtr = std::shared_ptr<const ExchangeNode>;
@@ -2137,7 +2268,7 @@ class MergeExchangeNode : public ExchangeNode {
       const RowTypePtr& type,
       const std::vector<FieldAccessTypedExprPtr>& sortingKeys,
       const std::vector<SortOrder>& sortingOrders,
-      VectorSerde::Kind serdeKind);
+      std::string serdeKind);
 
   class Builder {
    public:
@@ -2171,8 +2302,8 @@ class MergeExchangeNode : public ExchangeNode {
       return *this;
     }
 
-    Builder& serdeKind(VectorSerde::Kind serdeKind) {
-      serdeKind_ = serdeKind;
+    Builder& serdeKind(std::string serdeKind) {
+      serdeKind_ = std::move(serdeKind);
       return *this;
     }
 
@@ -2201,7 +2332,7 @@ class MergeExchangeNode : public ExchangeNode {
     std::optional<RowTypePtr> outputType_;
     std::optional<std::vector<FieldAccessTypedExprPtr>> sortingKeys_;
     std::optional<std::vector<SortOrder>> sortingOrders_;
-    std::optional<VectorSerde::Kind> serdeKind_;
+    std::optional<std::string> serdeKind_;
   };
 
   const std::vector<FieldAccessTypedExprPtr>& sortingKeys() const {
@@ -2212,6 +2343,10 @@ class MergeExchangeNode : public ExchangeNode {
     return sortingOrders_;
   }
 
+  bool requiresSingleThread() const override {
+    return true;
+  }
+
   void accept(const PlanNodeVisitor& visitor, PlanNodeVisitorContext& context)
       const override;
 
@@ -2310,6 +2445,10 @@ class LocalMergeNode : public PlanNode {
   void accept(const PlanNodeVisitor& visitor, PlanNodeVisitorContext& context)
       const override;
 
+  bool requiresSingleThread() const override {
+    return true;
+  }
+
   const std::vector<FieldAccessTypedExprPtr>& sortingKeys() const {
     return sortingKeys_;
   }
@@ -2521,6 +2660,10 @@ class LocalPartitionNode : public PlanNode {
     return scaleWriter_;
   }
 
+  bool requiresSingleThread() const override {
+    return type_ == Type::kGather;
+  }
+
   bool supportsBarrier() const override {
     return !scaleWriter_;
   }
@@ -2581,26 +2724,26 @@ class PartitionedOutputNode : public PlanNode {
       bool replicateNullsAndAny,
       PartitionFunctionSpecPtr partitionFunctionSpec,
       RowTypePtr outputType,
-      VectorSerde::Kind serdeKind,
+      std::string serdeKind,
       PlanNodePtr source);
 
   static std::shared_ptr<PartitionedOutputNode> broadcast(
       const PlanNodeId& id,
       int numPartitions,
       RowTypePtr outputType,
-      VectorSerde::Kind serdeKind,
+      std::string serdeKind,
       PlanNodePtr source);
 
   static std::shared_ptr<PartitionedOutputNode> arbitrary(
       const PlanNodeId& id,
       RowTypePtr outputType,
-      VectorSerde::Kind serdeKind,
+      std::string serdeKind,
       PlanNodePtr source);
 
   static std::shared_ptr<PartitionedOutputNode> single(
       const PlanNodeId& id,
       RowTypePtr outputType,
-      VectorSerde::Kind VectorSerde,
+      std::string serdeKind,
       PlanNodePtr source);
 
   class Builder {
@@ -2655,8 +2798,8 @@ class PartitionedOutputNode : public PlanNode {
       return *this;
     }
 
-    Builder& serdeKind(VectorSerde::Kind serdeKind) {
-      serdeKind_ = serdeKind;
+    Builder& serdeKind(std::string serdeKind) {
+      serdeKind_ = std::move(serdeKind);
       return *this;
     }
 
@@ -2708,7 +2851,7 @@ class PartitionedOutputNode : public PlanNode {
     std::optional<bool> replicateNullsAndAny_;
     std::optional<PartitionFunctionSpecPtr> partitionFunctionSpec_;
     std::optional<RowTypePtr> outputType_;
-    std::optional<VectorSerde::Kind> serdeKind_;
+    std::optional<std::string> serdeKind_;
     std::optional<PlanNodePtr> source_;
   };
 
@@ -2751,7 +2894,7 @@ class PartitionedOutputNode : public PlanNode {
     return kind_;
   }
 
-  VectorSerde::Kind serdeKind() const {
+  const std::string& serdeKind() const {
     return serdeKind_;
   }
 
@@ -2789,7 +2932,7 @@ class PartitionedOutputNode : public PlanNode {
   const int numPartitions_;
   const bool replicateNullsAndAny_;
   const PartitionFunctionSpecPtr partitionFunctionSpec_;
-  const VectorSerde::Kind serdeKind_;
+  const std::string serdeKind_;
   const RowTypePtr outputType_;
 };
 
@@ -2830,6 +2973,12 @@ enum class JoinType {
   // equal to the cardinality of the left side.
   kLeftSemiFilter = 4,
 
+  // Multiset version of kLeftSemiFilter. The build side deduplicates keys and
+  // stores a per-key count. On probe, each match decrements the count; the
+  // probe row is emitted only while the count is greater than zero. Implements
+  // INTERSECT ALL semantics.
+  kCountingLeftSemiFilter = 5,
+
   // Return each row from the left side with a boolean flag indicating whether
   // there exists a match on the right side. For this join type, cardinality
   // of the output equals the cardinality of the left side.
@@ -2838,12 +2987,12 @@ enum class JoinType {
   // 'nullAware' boolean specified separately.
   //
   // Null-aware join follows IN semantic. Regular join follows EXISTS semantic.
-  kLeftSemiProject = 5,
+  kLeftSemiProject = 6,
 
   // Opposite of kLeftSemiFilter. Return a subset of rows from the right side
   // which have a match on the left side. For this join type, cardinality of
   // the output is less than or equal to the cardinality of the right side.
-  kRightSemiFilter = 6,
+  kRightSemiFilter = 7,
 
   // Opposite of kLeftSemiProject. Return each row from the right side with a
   // boolean flag indicating whether there exists a match on the left side.
@@ -2854,7 +3003,7 @@ enum class JoinType {
   // 'nullAware' boolean specified separately.
   //
   // Null-aware join follows IN semantic. Regular join follows EXISTS semantic.
-  kRightSemiProject = 7,
+  kRightSemiProject = 8,
 
   // Return each row from the left side which has no match on the right side.
   // The handling of the rows with nulls in the join key depends on the
@@ -2869,9 +3018,15 @@ enum class JoinType {
   // Regular anti join follows NOT EXISTS semantic:
   // (1) ignore right-side rows with nulls in the join keys;
   // (2) unconditionally return left side rows with nulls in the join keys.
-  kAnti = 8,
+  kAnti = 9,
 
-  kNumJoinTypes = 9,
+  // Multiset version of kAnti. The build side deduplicates keys and stores a
+  // per-key count. On probe, each match decrements the count; the probe row is
+  // emitted only when the count reaches zero or no match is found. Implements
+  // EXCEPT ALL semantics.
+  kCountingAnti = 10,
+
+  kNumJoinTypes = 11,
 };
 
 VELOX_DECLARE_ENUM_NAME(JoinType);
@@ -2912,6 +3067,26 @@ inline bool isAntiJoin(JoinType joinType) {
   return joinType == JoinType::kAnti;
 }
 
+inline bool isCountingAntiJoin(JoinType joinType) {
+  return joinType == JoinType::kCountingAnti;
+}
+
+inline bool isCountingLeftSemiFilterJoin(JoinType joinType) {
+  return joinType == JoinType::kCountingLeftSemiFilter;
+}
+
+inline bool isCountingJoin(JoinType joinType) {
+  return isCountingAntiJoin(joinType) || isCountingLeftSemiFilterJoin(joinType);
+}
+
+/// Returns true if the join type is "probe-only", meaning the output includes
+/// only columns from the probe side (plus possibly a mark column).
+inline bool isProbeOnlyJoin(JoinType joinType) {
+  return joinType == JoinType::kLeftSemiFilter ||
+      joinType == JoinType::kLeftSemiProject || joinType == JoinType::kAnti ||
+      isCountingJoin(joinType);
+}
+
 inline bool isNullAwareSupported(JoinType joinType) {
   return joinType == JoinType::kAnti ||
       joinType == JoinType::kLeftSemiProject ||
@@ -3050,10 +3225,34 @@ class AbstractJoinNode : public PlanNode {
     return joinType_ == JoinType::kAnti;
   }
 
+  bool isCountingAntiJoin() const {
+    return joinType_ == JoinType::kCountingAnti;
+  }
+
+  bool isCountingLeftSemiFilterJoin() const {
+    return joinType_ == JoinType::kCountingLeftSemiFilter;
+  }
+
+  bool isCountingJoin() const {
+    return core::isCountingJoin(joinType_);
+  }
+
   bool isPreservingProbeOrder() const {
     return isInnerJoin() || isLeftJoin() || isAntiJoin();
   }
 
+  /// Indicates if this joinNode can drop duplicate rows with same join key.
+  /// For left semi and anti join, it is not necessary to store duplicate rows.
+  /// For counting joins, duplicates are folded into a per-key count.
+  bool canDropDuplicates() const {
+    // Left semi and anti join with no extra filter only needs to know whether
+    // there is a match. Hence, no need to store entries with duplicate keys.
+    // Counting joins always deduplicate and track counts.
+    return isCountingJoin() ||
+        (!filter() &&
+         (isLeftSemiFilterJoin() || isLeftSemiProjectJoin() || isAntiJoin()));
+  }
+
   const std::vector<FieldAccessTypedExprPtr>& leftKeys() const {
     return leftKeys_;
   }
@@ -3093,6 +3292,12 @@ class AbstractJoinNode : public PlanNode {
 /// EXISTS.
 class HashJoinNode : public AbstractJoinNode {
  public:
+  /// @param nullAware Applies to semi and anti joins only. When true, the
+  /// join semantic is IN / NOT IN (three-valued NULL logic). When false, the
+  /// join semantic is EXISTS / NOT EXISTS.
+  /// @param nullAsValue When true, join keys use IS NOT DISTINCT FROM
+  /// semantics where NULL equals NULL. Used to implement SQL set operations
+  /// (EXCEPT, INTERSECT). Mutually exclusive with nullAware.
   HashJoinNode(
       const PlanNodeId& id,
       JoinType joinType,
@@ -3102,7 +3307,9 @@ class HashJoinNode : public AbstractJoinNode {
       TypedExprPtr filter,
       PlanNodePtr left,
       PlanNodePtr right,
-      RowTypePtr outputType)
+      RowTypePtr outputType,
+      bool useHashTableCache = false,
+      bool nullAsValue = false)
       : AbstractJoinNode(
             id,
             joinType,
@@ -3112,9 +3319,21 @@ class HashJoinNode : public AbstractJoinNode {
             std::move(left),
             std::move(right),
             std::move(outputType)),
-        nullAware_{nullAware} {
+        nullAware_{nullAware},
+        nullAsValue_{nullAsValue},
+        useHashTableCache_{useHashTableCache} {
     validate();
 
+    VELOX_USER_CHECK(
+        !nullAware || !nullAsValue,
+        "nullAware and nullAsValue are mutually exclusive");
+
+    if (isCountingJoin()) {
+      VELOX_USER_CHECK(
+          !nullAware, "Counting joins do not support null-aware flag");
+      VELOX_USER_CHECK(!filter_, "Counting joins do not support extra filter");
+    }
+
     if (nullAware) {
       VELOX_USER_CHECK(
           isNullAwareSupported(joinType),
@@ -3137,6 +3356,8 @@ class HashJoinNode : public AbstractJoinNode {
     explicit Builder(const HashJoinNode& other)
         : AbstractJoinNode::Builder<HashJoinNode, Builder>(other) {
       nullAware_ = other.isNullAware();
+      nullAsValue_ = other.isNullAsValue();
+      useHashTableCache_ = other.useHashTableCache();
     }
 
     Builder& nullAware(bool value) {
@@ -3144,6 +3365,16 @@ class HashJoinNode : public AbstractJoinNode {
       return *this;
     }
 
+    Builder& nullAsValue(bool value) {
+      nullAsValue_ = value;
+      return *this;
+    }
+
+    Builder& useHashTableCache(bool value) {
+      useHashTableCache_ = value;
+      return *this;
+    }
+
     std::shared_ptr<HashJoinNode> build() const {
       VELOX_USER_CHECK(id_.has_value(), "HashJoinNode id is not set");
       VELOX_USER_CHECK(
@@ -3170,11 +3401,15 @@ class HashJoinNode : public AbstractJoinNode {
           filter_.value_or(nullptr),
           left_.value(),
           right_.value(),
-          outputType_.value());
+          outputType_.value(),
+          useHashTableCache_.value_or(false),
+          nullAsValue_.value_or(false));
     }
 
    private:
     std::optional<bool> nullAware_;
+    std::optional<bool> nullAsValue_;
+    std::optional<bool> useHashTableCache_;
   };
 
   std::string_view name() const override {
@@ -3193,10 +3428,27 @@ class HashJoinNode : public AbstractJoinNode {
         queryConfig.joinSpillEnabled();
   }
 
+  bool requiresSingleThread() const override {
+    return isRightSemiProjectJoin() && nullAware_;
+  }
+
   bool isNullAware() const {
     return nullAware_;
   }
 
+  /// Returns true when join keys use IS NOT DISTINCT FROM semantics where
+  /// NULL equals NULL. Used to implement SQL set operations (EXCEPT,
+  /// INTERSECT).
+  bool isNullAsValue() const {
+    return nullAsValue_;
+  }
+
+  /// Returns whether hash table caching is enabled for broadcast joins.
+  /// Only used by Presto-on-Spark.
+  bool useHashTableCache() const {
+    return useHashTableCache_;
+  }
+
   folly::dynamic serialize() const override;
 
   static PlanNodePtr create(const folly::dynamic& obj, void* context);
@@ -3205,6 +3457,8 @@ class HashJoinNode : public AbstractJoinNode {
   void addDetails(std::stringstream& stream) const override;
 
   const bool nullAware_;
+  const bool nullAsValue_;
+  const bool useHashTableCache_;
 };
 
 using HashJoinNodePtr = std::shared_ptr<const HashJoinNode>;
@@ -3260,6 +3514,10 @@ class MergeJoinNode : public AbstractJoinNode {
     }
   };
 
+  bool requiresSingleThread() const override {
+    return true;
+  }
+
   std::string_view name() const override {
     return "MergeJoin";
   }
@@ -3368,8 +3626,9 @@ struct BetweenIndexLookupCondition : public IndexLookupCondition {
 using BetweenIndexLookupConditionPtr =
     std::shared_ptr<BetweenIndexLookupCondition>;
 
-/// Represents EQUAL index lookup condition: 'key' = 'value'. 'value' must be a
-/// constant value with the same type as 'key'.
+/// Represents EQUAL index lookup condition: 'key' = 'value'. 'value' can be
+/// either a constant value or a field access expression (probe side column)
+/// with the same type as 'key'.
 struct EqualIndexLookupCondition : public IndexLookupCondition {
   /// The value to compare against.
   TypedExprPtr value;
@@ -3431,7 +3690,15 @@ class IndexLookupJoinNode : public AbstractJoinNode {
  public:
   /// @param joinType Specifies the lookup join type. Only INNER and LEFT joins
   /// are supported.
-  /// @param includeMatchColumn if true, the output type includes a boolean
+  /// @param leftKeys Left side join keys used for index lookup.
+  /// @param rightKeys Right side join keys that form the index prefix.
+  /// @param joinConditions Additional conditions for index lookup that can't
+  /// be converted into simple equality join conditions. These conditions use
+  /// columns from both left and right  and exactly one index column from
+  /// the right side.sides
+  /// @param filter Additional filter to apply on join results. This supports
+  /// filters that can't be converted into join conditions.
+  /// @param hasMarker if true, the output type includes a boolean
   /// column at the end to indicate if a join output row has a match or not.
   /// This only applies for left join.
   IndexLookupJoinNode(
@@ -3440,7 +3707,8 @@ class IndexLookupJoinNode : public AbstractJoinNode {
       const std::vector<FieldAccessTypedExprPtr>& leftKeys,
       const std::vector<FieldAccessTypedExprPtr>& rightKeys,
       const std::vector<IndexLookupConditionPtr>& joinConditions,
-      bool includeMatchColumn,
+      TypedExprPtr filter,
+      bool hasMarker,
       PlanNodePtr left,
       TableScanNodePtr right,
       RowTypePtr outputType);
@@ -3453,16 +3721,27 @@ class IndexLookupJoinNode : public AbstractJoinNode {
     explicit Builder(const IndexLookupJoinNode& other)
         : AbstractJoinNode::Builder<IndexLookupJoinNode, Builder>(other) {
       joinConditions_ = other.joinConditions();
+      filter_ = other.filter();
+      hasMarker_ = other.hasMarker();
     }
 
+    /// Set lookup conditions for index lookup that can't be converted into
+    /// simple equality join conditions.
     Builder& joinConditions(
         std::vector<IndexLookupConditionPtr> joinConditions) {
       joinConditions_ = std::move(joinConditions);
       return *this;
     }
 
-    Builder& includeMatchColumn(bool includeMatchColumn) {
-      includeMatchColumn_ = includeMatchColumn;
+    /// Set additional filter to apply on join results.
+    Builder& filter(TypedExprPtr filter) {
+      filter_ = std::move(filter);
+      return *this;
+    }
+
+    /// Set whether to include a marker column for left joins.
+    Builder& hasMarker(bool hasMarker) {
+      hasMarker_ = hasMarker;
       return *this;
     }
 
@@ -3480,25 +3759,23 @@ class IndexLookupJoinNode : public AbstractJoinNode {
           right_.has_value(), "IndexLookupJoinNode right source is not set");
       VELOX_USER_CHECK(
           outputType_.has_value(), "IndexLookupJoinNode outputType is not set");
-      VELOX_USER_CHECK(
-          joinConditions_.has_value(),
-          "IndexLookupJoinNode join conditions are not set");
 
       return std::make_shared<IndexLookupJoinNode>(
           id_.value(),
           joinType_.value(),
           leftKeys_.value(),
           rightKeys_.value(),
-          joinConditions_.value(),
-          includeMatchColumn_,
+          joinConditions_,
+          filter_.value_or(nullptr),
+          hasMarker_,
           left_.value(),
           std::dynamic_pointer_cast<const TableScanNode>(right_.value()),
           outputType_.value());
     }
 
    private:
-    std::optional<std::vector<IndexLookupConditionPtr>> joinConditions_;
-    bool includeMatchColumn_;
+    std::vector<IndexLookupConditionPtr> joinConditions_;
+    bool hasMarker_{false};
   };
 
   bool supportsBarrier() const override {
@@ -3509,6 +3786,12 @@ class IndexLookupJoinNode : public AbstractJoinNode {
     return lookupSourceNode_;
   }
 
+  /// Returns true if the lookup source requires splits for index lookup.
+  /// This delegates to the table handle's needsIndexSplit() method.
+  bool needsIndexSplit() const;
+
+  /// Returns the join conditions for index lookup that can't be converted into
+  /// simple equality join conditions.
   const std::vector<IndexLookupConditionPtr>& joinConditions() const {
     return joinConditions_;
   }
@@ -3517,8 +3800,9 @@ class IndexLookupJoinNode : public AbstractJoinNode {
     return "IndexLookupJoin";
   }
 
-  bool includeMatchColumn() const {
-    return includeMatchColumn_;
+  /// Returns whether this node includes a marker column for left joins.
+  bool hasMarker() const {
+    return hasMarker_;
   }
 
   void accept(const PlanNodeVisitor& visitor, PlanNodeVisitorContext& context)
@@ -3534,11 +3818,16 @@ class IndexLookupJoinNode : public AbstractJoinNode {
  private:
   void addDetails(std::stringstream& stream) const override;
 
+  /// The table scan node that provides the lookup source for index operations.
   const TableScanNodePtr lookupSourceNode_;
 
+  /// Join conditions that can't be converted into simple equality join
+  /// conditions. These conditions involve columns from both left and right
+  /// sides and exactly one index column from the right side.
   const std::vector<IndexLookupConditionPtr> joinConditions_;
 
-  const bool includeMatchColumn_;
+  /// Whether to include a marker column for left joins to indicate matches.
+  const bool hasMarker_;
 };
 
 using IndexLookupJoinNodePtr = std::shared_ptr<const IndexLookupJoinNode>;
@@ -3806,6 +4095,10 @@ class OrderByNode : public PlanNode {
   void accept(const PlanNodeVisitor& visitor, PlanNodeVisitorContext& context)
       const override;
 
+  bool requiresSingleThread() const override {
+    return !isPartial_;
+  }
+
   // True if this node only sorts a portion of the final result. If it is
   // true, a local merge or merge exchange is required to merge the sorted
   // runs.
@@ -3852,10 +4145,29 @@ class SpatialJoinNode : public PlanNode {
       const PlanNodeId& id,
       JoinType joinType,
       TypedExprPtr joinCondition,
+      FieldAccessTypedExprPtr probeGeometry,
+      FieldAccessTypedExprPtr buildGeometry,
+      std::optional<FieldAccessTypedExprPtr> radius,
       PlanNodePtr left,
       PlanNodePtr right,
       RowTypePtr outputType);
 
+  SpatialJoinNode(
+      const PlanNodeId& id,
+      JoinType joinType,
+      TypedExprPtr joinCondition,
+      PlanNodePtr left,
+      PlanNodePtr right,
+      RowTypePtr outputType);
+
+  PlanNodePtr leftNode() const {
+    return sources()[0];
+  }
+
+  PlanNodePtr rightNode() const {
+    return sources()[1];
+  }
+
   class Builder {
    public:
     Builder() = default;
@@ -3864,6 +4176,9 @@ class SpatialJoinNode : public PlanNode {
       id_ = other.id();
       joinType_ = other.joinType();
       joinCondition_ = other.joinCondition();
+      probeGeometry_ = other.probeGeometry();
+      buildGeometry_ = other.buildGeometry();
+      radius_ = other.radius();
       VELOX_CHECK_EQ(other.sources().size(), 2);
       left_ = other.sources()[0];
       right_ = other.sources()[1];
@@ -3885,6 +4200,21 @@ class SpatialJoinNode : public PlanNode {
       return *this;
     }
 
+    Builder& probeGeometry(FieldAccessTypedExprPtr probeGeometry) {
+      probeGeometry_ = std::move(probeGeometry);
+      return *this;
+    }
+
+    Builder& buildGeometry(FieldAccessTypedExprPtr buildGeometry) {
+      buildGeometry_ = std::move(buildGeometry);
+      return *this;
+    }
+
+    Builder& radius(FieldAccessTypedExprPtr radius) {
+      radius_ = std::move(radius);
+      return *this;
+    }
+
     Builder& left(PlanNodePtr left) {
       left_ = std::move(left);
       return *this;
@@ -3908,11 +4238,38 @@ class SpatialJoinNode : public PlanNode {
           right_.has_value(), "SpatialJoinNode right source is not set");
       VELOX_USER_CHECK(
           outputType_.has_value(), "SpatialJoinNode outputType is not set");
+      VELOX_USER_CHECK(
+          probeGeometry_.has_value(),
+          "SpatialJoinNode probe geometry is not set");
+      VELOX_USER_CHECK(
+          buildGeometry_.has_value(),
+          "SpatialJoinNode build geometry is not set");
+
+      VELOX_USER_CHECK(
+          (probeGeometry_.has_value() && buildGeometry_.has_value()) ||
+              (!probeGeometry_.has_value() && !buildGeometry_.has_value()),
+          "Either probe and build geometry must both be set, or neither");
+
+      if (probeGeometry_.has_value() && buildGeometry_.has_value()) {
+        return std::make_shared<SpatialJoinNode>(
+            id_.value(),
+            joinType_,
+            joinCondition_,
+            probeGeometry_.value(),
+            buildGeometry_.value(),
+            radius_,
+            left_.value(),
+            right_.value(),
+            outputType_.value());
+      }
 
       return std::make_shared<SpatialJoinNode>(
           id_.value(),
           joinType_,
           joinCondition_,
+          probeGeometry_.value(),
+          buildGeometry_.value(),
+          radius_,
           left_.value(),
           right_.value(),
           outputType_.value());
@@ -3922,6 +4279,9 @@ class SpatialJoinNode : public PlanNode {
     std::optional<PlanNodeId> id_;
     JoinType joinType_ = kDefaultJoinType;
     TypedExprPtr joinCondition_;
+    std::optional<FieldAccessTypedExprPtr> probeGeometry_;
+    std::optional<FieldAccessTypedExprPtr> buildGeometry_;
+    std::optional<FieldAccessTypedExprPtr> radius_;
     std::optional<PlanNodePtr> left_;
     std::optional<PlanNodePtr> right_;
     std::optional<RowTypePtr> outputType_;
@@ -3946,6 +4306,18 @@ class SpatialJoinNode : public PlanNode {
     return joinCondition_;
   }
 
+  const FieldAccessTypedExprPtr& probeGeometry() const {
+    return probeGeometry_;
+  }
+
+  const FieldAccessTypedExprPtr& buildGeometry() const {
+    return buildGeometry_;
+  }
+
+  const std::optional<FieldAccessTypedExprPtr>& radius() const {
+    return radius_;
+  }
+
   JoinType joinType() const {
     return joinType_;
   }
@@ -3964,6 +4336,9 @@ class SpatialJoinNode : public PlanNode {
 
   const JoinType joinType_;
   const TypedExprPtr joinCondition_;
+  const FieldAccessTypedExprPtr probeGeometry_;
+  const FieldAccessTypedExprPtr buildGeometry_;
+  const std::optional<FieldAccessTypedExprPtr> radius_;
   const std::vector<PlanNodePtr> sources_;
   const RowTypePtr outputType_;
 };
@@ -4071,6 +4446,10 @@ class TopNNode : public PlanNode {
   void accept(const PlanNodeVisitor& visitor, PlanNodeVisitorContext& context)
       const override;
 
+  bool requiresSingleThread() const override {
+    return !isPartial_;
+  }
+
   int32_t count() const {
     return count_;
   }
@@ -4206,6 +4585,10 @@ class LimitNode : public PlanNode {
     return count_;
   }
 
+  bool requiresSingleThread() const override {
+    return !isPartial_;
+  }
+
   bool isPartial() const {
     return isPartial_;
   }
@@ -4245,17 +4628,33 @@ class UnnestNode : public PlanNode {
   /// names must appear in the same order as unnestVariables.
   /// @param ordinalityName Optional name for the ordinality columns. If not
   /// present, ordinality column is not produced.
-  /// @param emptyUnnestValueName Optional name for column which indicates an
-  /// output row has empty unnest value or not. If not present, emptyUnnestValue
-  /// column is not provided and the unnest operator also skips producing output
-  /// rows with empty unnest value.
+  /// @param markerName Optional name for column which indicates whether an
+  /// output row has non-empty unnested value. If not present, marker column is
+  /// not provided and the unnest operator also skips producing output rows
+  /// with empty unnest value.
+  /// @param splitOutput Optional flag to control whether it should output 1
+  /// batch for each input batch, or split output batches if they are too large.
+  /// If true, output is split into batches according to Operator's
+  /// outputBatchRows logic. If false, output is not split and output batches
+  /// match input batches 1:1. If not set, defaults to the value of the
+  /// unnest_split_output config in the QueryConfig.
+  UnnestNode(
+      const PlanNodeId& id,
+      std::vector<FieldAccessTypedExprPtr> replicateVariables,
+      std::vector<FieldAccessTypedExprPtr> unnestVariables,
+      std::vector<std::string> unnestNames,
+      std::optional<std::string> ordinalityName,
+      std::optional<std::string> markerName,
+      const PlanNodePtr& source);
+
   UnnestNode(
       const PlanNodeId& id,
       std::vector<FieldAccessTypedExprPtr> replicateVariables,
       std::vector<FieldAccessTypedExprPtr> unnestVariables,
       std::vector<std::string> unnestNames,
       std::optional<std::string> ordinalityName,
-      std::optional<std::string> emptyUnnestValueName,
+      std::optional<std::string> markerName,
+      std::optional<bool> splitOutput,
       const PlanNodePtr& source);
 
   class Builder {
@@ -4268,6 +4667,7 @@ class UnnestNode : public PlanNode {
       unnestVariables_ = other.unnestVariables();
       unnestNames_ = other.unnestNames_;
       ordinalityName_ = other.ordinalityName_;
+      splitOutput_ = other.splitOutput_;
       VELOX_CHECK_EQ(other.sources().size(), 1);
       source_ = other.sources()[0];
     }
@@ -4304,9 +4704,13 @@ class UnnestNode : public PlanNode {
       return *this;
     }
 
-    Builder& emptyUnnestValueName(
-        std::optional<std::string> emptyUnnestValueName) {
-      emptyUnnestValueName_ = std::move(emptyUnnestValueName);
+    Builder& markerName(std::optional<std::string> markerName) {
+      markerName_ = std::move(markerName);
+      return *this;
+    }
+
+    Builder& splitOutput(std::optional<bool> splitOutput) {
+      splitOutput_ = splitOutput;
       return *this;
     }
 
@@ -4328,7 +4732,8 @@ class UnnestNode : public PlanNode {
           unnestVariables_.value(),
           unnestNames_.value(),
           ordinalityName_,
-          emptyUnnestValueName_,
+          markerName_,
+          splitOutput_,
           source_.value());
     }
 
@@ -4338,8 +4743,9 @@ class UnnestNode : public PlanNode {
     std::optional<std::vector<FieldAccessTypedExprPtr>> unnestVariables_;
     std::optional<std::vector<std::string>> unnestNames_;
     std::optional<std::string> ordinalityName_;
-    std::optional<std::string> emptyUnnestValueName_;
+    std::optional<std::string> markerName_;
     std::optional<PlanNodePtr> source_;
+    std::optional<bool> splitOutput_;
   };
 
   bool supportsBarrier() const override {
@@ -4380,12 +4786,16 @@ class UnnestNode : public PlanNode {
     return ordinalityName_.has_value();
   }
 
-  const std::optional<std::string>& emptyUnnestValueName() const {
-    return emptyUnnestValueName_;
+  const std::optional<std::string>& markerName() const {
+    return markerName_;
   }
 
-  bool hasEmptyUnnestValue() const {
-    return emptyUnnestValueName_.has_value();
+  bool hasMarker() const {
+    return markerName_.has_value();
+  }
+
+  const std::optional<bool>& splitOutput() const {
+    return splitOutput_;
   }
 
   std::string_view name() const override {
@@ -4403,7 +4813,8 @@ class UnnestNode : public PlanNode {
   const std::vector<FieldAccessTypedExprPtr> unnestVariables_;
   const std::vector<std::string> unnestNames_;
   const std::optional<std::string> ordinalityName_;
-  const std::optional<std::string> emptyUnnestValueName_;
+  const std::optional<std::string> markerName_;
+  const std::optional<bool> splitOutput_;
   const std::vector<PlanNodePtr> sources_;
   RowTypePtr outputType_;
 };
@@ -4462,6 +4873,14 @@ class EnforceSingleRowNode : public PlanNode {
     return sources_;
   }
 
+  /// Validates that input produces exactly one row, so the pipeline must
+  /// observe all rows sequentially on a single driver. Multiple drivers
+  /// would each independently produce a row (or NULL on empty input),
+  /// breaking the single-row contract.
+  bool requiresSingleThread() const override {
+    return true;
+  }
+
   void accept(const PlanNodeVisitor& visitor, PlanNodeVisitorContext& context)
       const override;
 
@@ -5060,6 +5479,10 @@ class MarkDistinctNode : public PlanNode {
     return "MarkDistinct";
   }
 
+  bool canSpill(const QueryConfig& queryConfig) const override {
+    return queryConfig.markDistinctSpillEnabled();
+  }
+
   const std::string& markerName() const {
     return markerName_;
   }
@@ -5086,6 +5509,208 @@ class MarkDistinctNode : public PlanNode {
 
 using MarkDistinctNodePtr = std::shared_ptr<const MarkDistinctNode>;
 
+/// Checks that input rows have unique values in the specified key columns.
+/// Passes through all input rows unchanged. Raises an exception if duplicate
+/// key values are detected.
+///
+/// Used to validate uniqueness constraints, such as ensuring a scalar subquery
+/// returns at most one row per group.
+///
+class EnforceDistinctNode : public PlanNode {
+ public:
+  /// @param distinctKeys Columns that must have unique values.
+  /// @param preGroupedKeys Subset of distinctKeys that input is already
+  /// clustered on. When preGroupedKeys equals distinctKeys, a streaming
+  /// implementation is used that compares consecutive rows instead of using a
+  /// hash table.
+  /// @param errorMessage Custom error message to show when duplicates are
+  /// found.
+  EnforceDistinctNode(
+      PlanNodeId id,
+      std::vector<FieldAccessTypedExprPtr> distinctKeys,
+      std::vector<FieldAccessTypedExprPtr> preGroupedKeys,
+      std::string errorMessage,
+      PlanNodePtr source);
+
+  const std::vector<PlanNodePtr>& sources() const override {
+    return sources_;
+  }
+
+  void accept(const PlanNodeVisitor& visitor, PlanNodeVisitorContext& context)
+      const override;
+
+  const RowTypePtr& outputType() const override {
+    return sources_[0]->outputType();
+  }
+
+  std::string_view name() const override {
+    return "EnforceDistinct";
+  }
+
+  const std::vector<FieldAccessTypedExprPtr>& distinctKeys() const {
+    return distinctKeys_;
+  }
+
+  const std::vector<FieldAccessTypedExprPtr>& preGroupedKeys() const {
+    return preGroupedKeys_;
+  }
+
+  /// Returns true if all distinct keys are pre-grouped, meaning input is
+  /// clustered on distinct keys and streaming enforcement can be used.
+  bool isPreGrouped() const {
+    return preGroupedKeys_.size() == distinctKeys_.size();
+  }
+
+  const std::string& errorMessage() const {
+    return errorMessage_;
+  }
+
+  folly::dynamic serialize() const override;
+
+  static PlanNodePtr create(const folly::dynamic& obj, void* context);
+
+ private:
+  void addDetails(std::stringstream& stream) const override;
+
+  const std::vector<FieldAccessTypedExprPtr> distinctKeys_;
+  const std::vector<FieldAccessTypedExprPtr> preGroupedKeys_;
+  const std::string errorMessage_;
+  const std::vector<PlanNodePtr> sources_;
+};
+
+using EnforceDistinctNodePtr = std::shared_ptr<const EnforceDistinctNode>;
+
+/// The MarkSorted operator marks rows where the sort key changes.
+/// The result is put in a new markerName column alongside the original input.
+/// The first row is always marked true. Subsequent rows are marked true if
+/// they compare as sorted relative to the previous row based on sortingKeys
+/// and sortingOrders.
+/// @param markerName Name of the output marker channel.
+/// @param sortingKeys Keys to check for sorted order.
+/// @param sortingOrders Sort orders (ascending/descending, nulls first/last).
+class MarkSortedNode : public PlanNode {
+ public:
+  MarkSortedNode(
+      PlanNodeId id,
+      std::string markerName,
+      std::vector<FieldAccessTypedExprPtr> sortingKeys,
+      std::vector<SortOrder> sortingOrders,
+      PlanNodePtr source);
+
+  class Builder {
+   public:
+    Builder() = default;
+
+    explicit Builder(const MarkSortedNode& other) {
+      id_ = other.id();
+      markerName_ = other.markerName();
+      sortingKeys_ = other.sortingKeys();
+      sortingOrders_ = other.sortingOrders();
+      VELOX_CHECK_EQ(other.sources().size(), 1);
+      source_ = other.sources()[0];
+    }
+
+    Builder& id(PlanNodeId id) {
+      id_ = std::move(id);
+      return *this;
+    }
+
+    Builder& markerName(std::string markerName) {
+      markerName_ = std::move(markerName);
+      return *this;
+    }
+
+    Builder& sortingKeys(std::vector<FieldAccessTypedExprPtr> sortingKeys) {
+      sortingKeys_ = std::move(sortingKeys);
+      return *this;
+    }
+
+    Builder& sortingOrders(std::vector<SortOrder> sortingOrders) {
+      sortingOrders_ = std::move(sortingOrders);
+      return *this;
+    }
+
+    Builder& source(PlanNodePtr source) {
+      source_ = std::move(source);
+      return *this;
+    }
+
+    std::shared_ptr<MarkSortedNode> build() const {
+      VELOX_USER_CHECK(id_.has_value(), "MarkSortedNode id is not set");
+      VELOX_USER_CHECK(
+          markerName_.has_value(), "MarkSortedNode markerName is not set");
+      VELOX_USER_CHECK(
+          sortingKeys_.has_value(), "MarkSortedNode sortingKeys is not set");
+      VELOX_USER_CHECK(
+          sortingOrders_.has_value(),
+          "MarkSortedNode sortingOrders is not set");
+      VELOX_USER_CHECK(source_.has_value(), "MarkSortedNode source is not set");
+
+      return std::make_shared<MarkSortedNode>(
+          id_.value(),
+          markerName_.value(),
+          sortingKeys_.value(),
+          sortingOrders_.value(),
+          source_.value());
+    }
+
+   private:
+    std::optional<PlanNodeId> id_;
+    std::optional<std::string> markerName_;
+    std::optional<std::vector<FieldAccessTypedExprPtr>> sortingKeys_;
+    std::optional<std::vector<SortOrder>> sortingOrders_;
+    std::optional<PlanNodePtr> source_;
+  };
+
+  const std::vector<PlanNodePtr>& sources() const override {
+    return sources_;
+  }
+
+  void accept(const PlanNodeVisitor& visitor, PlanNodeVisitorContext& context)
+      const override;
+
+  /// The outputType is the concatenation of the input columns and marker
+  /// column.
+  const RowTypePtr& outputType() const override {
+    return outputType_;
+  }
+
+  std::string_view name() const override {
+    return "MarkSorted";
+  }
+
+  const std::string& markerName() const {
+    return markerName_;
+  }
+
+  const std::vector<FieldAccessTypedExprPtr>& sortingKeys() const {
+    return sortingKeys_;
+  }
+
+  const std::vector<SortOrder>& sortingOrders() const {
+    return sortingOrders_;
+  }
+
+  folly::dynamic serialize() const override;
+
+  static PlanNodePtr create(const folly::dynamic& obj, void* context);
+
+ private:
+  void addDetails(std::stringstream& stream) const override;
+
+  const std::string markerName_;
+
+  const std::vector<FieldAccessTypedExprPtr> sortingKeys_;
+
+  const std::vector<SortOrder> sortingOrders_;
+
+  const std::vector<PlanNodePtr> sources_;
+
+  const RowTypePtr outputType_;
+};
+
+using MarkSortedNodePtr = std::shared_ptr<const MarkSortedNode>;
+
 /// Optimized version of a WindowNode for a single row_number, rank or
 /// dense_rank function with a limit over sorted partitions. The output of this
 /// node contains all input columns followed by an optional
@@ -5294,6 +5919,149 @@ class TopNRowNumberNode : public PlanNode {
 
 using TopNRowNumberNodePtr = std::shared_ptr<const TopNRowNumberNode>;
 
+/// Union operator that combines data from multiple inputs.
+/// Supports both serial mode (process inputs one at a time) and
+/// mixed mode (process inputs simultaneously and combine results).
+class MixedUnionNode : public PlanNode {
+ public:
+  MixedUnionNode(const PlanNodeId& id, std::vector<PlanNodePtr> sources)
+      : MixedUnionNode(id, std::move(sources), {}) {}
+
+  MixedUnionNode(
+      const PlanNodeId& id,
+      std::vector<PlanNodePtr> sources,
+      std::vector<int64_t> batchSizesPerSource)
+      : PlanNode(id),
+        sources_(std::move(sources)),
+        batchSizesPerSource_(std::move(batchSizesPerSource)) {
+    VELOX_USER_CHECK(
+        !sources_.empty(), "Union node must have at least one source");
+
+    // All sources must have the same output type
+    outputType_ = sources_[0]->outputType();
+    for (size_t i = 1; i < sources_.size(); ++i) {
+      VELOX_USER_CHECK(
+          outputType_->equivalent(*sources_[i]->outputType()),
+          "All Union sources must have the same output type. "
+          "Source 0 type: {}, Source {} type: {}",
+          outputType_->toString(),
+          i,
+          sources_[i]->outputType()->toString());
+    }
+  }
+
+  class Builder {
+   public:
+    Builder() = default;
+
+    explicit Builder(const MixedUnionNode& other) {
+      id_ = other.id();
+      sources_ = other.sources();
+      batchSizesPerSource_ = other.batchSizesPerSource();
+    }
+
+    Builder& id(PlanNodeId id) {
+      id_ = std::move(id);
+      return *this;
+    }
+
+    Builder& sources(std::vector<PlanNodePtr> sources) {
+      sources_ = std::move(sources);
+      return *this;
+    }
+
+    Builder& source(PlanNodePtr source) {
+      if (!sources_.has_value()) {
+        sources_ = std::vector<PlanNodePtr>{};
+      }
+      sources_->push_back(std::move(source));
+      return *this;
+    }
+
+    Builder& batchSizesPerSource(std::vector<int64_t> batchSizes) {
+      batchSizesPerSource_ = std::move(batchSizes);
+      return *this;
+    }
+
+    Builder& batchSizeForSource(int32_t sourceIndex, int64_t batchSize) {
+      if (!batchSizesPerSource_.has_value()) {
+        batchSizesPerSource_ = std::vector<int64_t>{};
+      }
+      if (sourceIndex >= batchSizesPerSource_->size()) {
+        batchSizesPerSource_->resize(sourceIndex + 1, 0);
+      }
+      (*batchSizesPerSource_)[sourceIndex] = batchSize;
+      return *this;
+    }
+
+    std::shared_ptr<MixedUnionNode> build() const {
+      VELOX_USER_CHECK(id_.has_value(), "MixedUnionNode id is not set");
+      VELOX_USER_CHECK(
+          sources_.has_value() && !sources_->empty(),
+          "MixedUnionNode sources is not set or empty");
+
+      return std::make_shared<MixedUnionNode>(
+          id_.value(),
+          sources_.value(),
+          batchSizesPerSource_.value_or(std::vector<int64_t>{}));
+    }
+
+   private:
+    std::optional<PlanNodeId> id_;
+    std::optional<std::vector<PlanNodePtr>> sources_;
+    std::optional<std::vector<int64_t>> batchSizesPerSource_;
+  };
+
+  const std::vector<PlanNodePtr>& sources() const override {
+    return sources_;
+  }
+
+  const RowTypePtr& outputType() const override {
+    return outputType_;
+  }
+
+  /// Returns the batch sizes per source index.
+  /// This controls how many rows are taken from each source when mixing.
+  const std::vector<int64_t>& batchSizesPerSource() const {
+    return batchSizesPerSource_;
+  }
+
+  /// Get batch size for a specific source index (returns 0 if not set).
+  int64_t getBatchSizeForSource(int32_t sourceIndex) const {
+    if (sourceIndex < 0 || sourceIndex >= batchSizesPerSource_.size()) {
+      return 0;
+    }
+    return batchSizesPerSource_[sourceIndex];
+  }
+
+  bool requiresSingleThread() const override {
+    return true;
+  }
+
+  void accept(const PlanNodeVisitor& visitor, PlanNodeVisitorContext& context)
+      const override;
+
+  std::string_view name() const override {
+    return "MixedUnion";
+  }
+
+  folly::dynamic serialize() const override;
+
+  static PlanNodePtr create(const folly::dynamic& obj, void* context);
+
+  bool supportsBarrier() const override {
+    return true;
+  }
+
+ private:
+  void addDetails(std::stringstream& /* stream */) const override {}
+  const std::vector<PlanNodePtr> sources_;
+  RowTypePtr outputType_;
+  std::vector<int64_t> batchSizesPerSource_;
+};
+
+using MixedUnionNodePtr = std::shared_ptr<const MixedUnionNode>;
+
 class PlanNodeVisitorContext {
  public:
   virtual ~PlanNodeVisitorContext() = default;
@@ -5349,6 +6117,13 @@ class PlanNodeVisitor {
   virtual void visit(const MarkDistinctNode& node, PlanNodeVisitorContext& ctx)
       const = 0;
 
+  virtual void visit(
+      const EnforceDistinctNode& node,
+      PlanNodeVisitorContext& ctx) const = 0;
+
+  virtual void visit(const MarkSortedNode& node, PlanNodeVisitorContext& ctx)
+      const = 0;
+
   virtual void visit(const MergeExchangeNode& node, PlanNodeVisitorContext& ctx)
       const = 0;
 
@@ -5407,6 +6182,9 @@ class PlanNodeVisitor {
   virtual void visit(const WindowNode& node, PlanNodeVisitorContext& ctx)
       const = 0;
 
+  virtual void visit(const MixedUnionNode& node, PlanNodeVisitorContext& ctx)
+      const = 0;
+
   /// Used to visit custom PlanNodes that extend the set provided by Velox.
   virtual void visit(const PlanNode& node, PlanNodeVisitorContext& ctx)
       const = 0;
@@ -5419,6 +6197,126 @@ class PlanNodeVisitor {
   }
 };
 
+/// Plan node for async RPC execution (e.g., LLM inference, embeddings).
+///
+/// Stores the function name, result type, argument columns, and streaming
+/// mode. The RPCNode does NOT evaluate argument expressions — a ProjectNode
+/// inserted before this node by the plan rewriter computes argument columns.
+///
+/// Architecture:
+///   SQL: SELECT rpc_function(col1, 'model_name') FROM table
+///            |
+///            v (Plan Rewriter)
+///     ProjectNode (__rpc_arg_0 = col1, __rpc_arg_1 = 'model_name')
+///           |
+///        RPCNode (argumentColumns = [__rpc_arg_0, __rpc_arg_1])
+///           |
+///       source[0]
+///           |
+///       TableScan
+class RPCNode : public PlanNode {
+ public:
+  /// @param id Unique identifier for this plan node.
+  /// @param source Data source (the only source).
+  /// @param functionName Name of the registered AsyncRPCFunction.
+  /// @param functionResultType Velox type of the RPC result column.
+  /// @param outputColumn Name of the output column for RPC responses.
+  /// @param outputType Explicit output type. Must contain outputColumn
+  ///        and any passthrough source columns needed by downstream.
+  ///        Specified explicitly (like AbstractJoinNode) to support column
+  ///        pruning.
+  /// @param argumentColumns Names of input columns containing pre-evaluated
+  ///        argument values. RPCOperator reads these columns in addInput().
+  /// @param argumentTypes Types of each argument (aligned with
+  ///        argumentColumns). Passed to AsyncRPCFunction::initialize().
+  /// @param constantInputs Constant argument values (aligned with
+  ///        argumentColumns). nullptr for non-constant args, single-element
+  ///        ConstantVectors for constant args. Passed to initialize().
+  /// @param streamingMode The streaming mode for RPC execution.
+  /// @param dispatchBatchSize For BATCH mode pipelining: fire callBatch()
+  ///        every N rows during addInput() instead of collecting all rows.
+  RPCNode(
+      const PlanNodeId& id,
+      PlanNodePtr source,
+      std::string functionName,
+      TypePtr functionResultType,
+      std::string outputColumn,
+      RowTypePtr outputType,
+      std::vector<std::string> argumentColumns,
+      std::vector<TypePtr> argumentTypes,
+      std::vector<VectorPtr> constantInputs,
+      rpc::RPCStreamingMode streamingMode = rpc::RPCStreamingMode::kPerRow,
+      int32_t dispatchBatchSize = 0);
+
+  const PlanNodePtr& source() const {
+    return sources_[0];
+  }
+
+  const std::string& functionName() const {
+    return functionName_;
+  }
+
+  const TypePtr& rpcResultType() const {
+    return resultType_;
+  }
+
+  const std::string& outputColumn() const {
+    return outputColumn_;
+  }
+
+  const std::vector<std::string>& argumentColumns() const {
+    return argumentColumns_;
+  }
+
+  const std::vector<TypePtr>& argumentTypes() const {
+    return argumentTypes_;
+  }
+
+  const std::vector<VectorPtr>& constantInputs() const {
+    return constantInputs_;
+  }
+
+  rpc::RPCStreamingMode streamingMode() const {
+    return streamingMode_;
+  }
+
+  int32_t dispatchBatchSize() const {
+    return dispatchBatchSize_;
+  }
+
+  std::string_view name() const override {
+    return "RPC";
+  }
+
+  const RowTypePtr& outputType() const override {
+    return outputType_;
+  }
+
+  const std::vector<PlanNodePtr>& sources() const override {
+    return sources_;
+  }
+
+  folly::dynamic serialize() const override;
+
+  static PlanNodePtr create(const folly::dynamic& obj, void* context);
+
+ private:
+  void addDetails(std::stringstream& stream) const override;
+
+  std::vector<PlanNodePtr> sources_;
+  std::string functionName_;
+  TypePtr resultType_;
+  std::string outputColumn_;
+  RowTypePtr outputType_;
+  std::vector<std::string> argumentColumns_;
+  std::vector<TypePtr> argumentTypes_;
+  std::vector<VectorPtr> constantInputs_;
+  rpc::RPCStreamingMode streamingMode_;
+  int32_t dispatchBatchSize_{0};
+};
+
+using RPCNodePtr = std::shared_ptr<RPCNode>;
+
 } // namespace facebook::velox::core
 
 template <>
diff --git a/velox/core/QueryConfig.cpp b/velox/core/QueryConfig.cpp
index 3d5b25ff948..9a247e35a2c 100644
--- a/velox/core/QueryConfig.cpp
+++ b/velox/core/QueryConfig.cpp
@@ -22,29 +22,281 @@
 
 namespace facebook::velox::core {
 
-QueryConfig::QueryConfig(
-    const std::unordered_map<std::string, std::string>& values)
-    : config_{std::make_unique<config::ConfigBase>(
-          std::unordered_map<std::string, std::string>(values))} {
-  validateConfig();
+const std::vector<config::ConfigProperty>& QueryConfig::registeredProperties() {
+  static const std::vector<config::ConfigProperty> kProperties = [] {
+    std::vector<config::ConfigProperty> properties;
+#define VELOX_REGISTER_QUERY_CONFIG(constName) \
+  config::registerConfigProperty<QueryConfig::constName##Property>(properties)
+
+    // Memory.
+    VELOX_REGISTER_QUERY_CONFIG(kQueryMaxMemoryPerNode);
+
+    // Session.
+    VELOX_REGISTER_QUERY_CONFIG(kSessionTimezone);
+    VELOX_REGISTER_QUERY_CONFIG(kSessionStartTime);
+    VELOX_REGISTER_QUERY_CONFIG(kAdjustTimestampToTimezone);
+
+    // Expression evaluation.
+    VELOX_REGISTER_QUERY_CONFIG(kExprEvalSimplified);
+    VELOX_REGISTER_QUERY_CONFIG(kExprEvalFlatNoNulls);
+    VELOX_REGISTER_QUERY_CONFIG(kExprTrackCpuUsage);
+    VELOX_REGISTER_QUERY_CONFIG(kExprTrackCpuUsageForFunctions);
+    VELOX_REGISTER_QUERY_CONFIG(kExprAdaptiveCpuSampling);
+    VELOX_REGISTER_QUERY_CONFIG(kExprAdaptiveCpuSamplingMaxOverheadPct);
+    VELOX_REGISTER_QUERY_CONFIG(kExprDedupNonDeterministic);
+    VELOX_REGISTER_QUERY_CONFIG(kExprMaxArraySizeInReduce);
+    VELOX_REGISTER_QUERY_CONFIG(kExprMaxCompiledRegexes);
+
+    // Operator.
+    VELOX_REGISTER_QUERY_CONFIG(kOperatorTrackCpuUsage);
+
+    // Cast.
+    VELOX_REGISTER_QUERY_CONFIG(kLegacyCast);
+    VELOX_REGISTER_QUERY_CONFIG(kCastMatchStructByName);
+
+    // Local exchange.
+    VELOX_REGISTER_QUERY_CONFIG(kMaxLocalExchangeBufferSize);
+    VELOX_REGISTER_QUERY_CONFIG(kMaxLocalExchangePartitionCount);
+    VELOX_REGISTER_QUERY_CONFIG(
+        kMinLocalExchangePartitionCountToUsePartitionBuffer);
+    VELOX_REGISTER_QUERY_CONFIG(kMaxLocalExchangePartitionBufferSize);
+    VELOX_REGISTER_QUERY_CONFIG(kLocalExchangePartitionBufferPreserveEncoding);
+    VELOX_REGISTER_QUERY_CONFIG(kLocalMergeSourceQueueSize);
+
+    // Exchange.
+    VELOX_REGISTER_QUERY_CONFIG(kMaxExchangeBufferSize);
+    VELOX_REGISTER_QUERY_CONFIG(kMaxMergeExchangeBufferSize);
+    VELOX_REGISTER_QUERY_CONFIG(kMinExchangeOutputBatchBytes);
+
+    // Aggregation.
+    VELOX_REGISTER_QUERY_CONFIG(kMaxPartialAggregationMemory);
+    VELOX_REGISTER_QUERY_CONFIG(kMaxExtendedPartialAggregationMemory);
+    VELOX_REGISTER_QUERY_CONFIG(kAbandonPartialAggregationMinRows);
+    VELOX_REGISTER_QUERY_CONFIG(kAbandonPartialAggregationMinPct);
+    VELOX_REGISTER_QUERY_CONFIG(kAggregationCompactionBytesThreshold);
+    VELOX_REGISTER_QUERY_CONFIG(kAggregationCompactionUnusedMemoryRatio);
+    VELOX_REGISTER_QUERY_CONFIG(kAggregationMemoryCompactionReclaimEnabled);
+
+    // TopN row number.
+    VELOX_REGISTER_QUERY_CONFIG(kAbandonPartialTopNRowNumberMinRows);
+    VELOX_REGISTER_QUERY_CONFIG(kAbandonPartialTopNRowNumberMinPct);
+
+    // Hash build dedup.
+    VELOX_REGISTER_QUERY_CONFIG(kAbandonDedupHashMapMinRows);
+    VELOX_REGISTER_QUERY_CONFIG(kAbandonDedupHashMapMinPct);
+
+    // Miscellaneous.
+    VELOX_REGISTER_QUERY_CONFIG(kMaxElementsSizeInRepeatAndSequence);
+
+    // Partitioned output.
+    VELOX_REGISTER_QUERY_CONFIG(kPartitionedOutputEagerFlush);
+    VELOX_REGISTER_QUERY_CONFIG(kMaxPartitionedOutputBufferSize);
+    VELOX_REGISTER_QUERY_CONFIG(kMaxOutputBufferSize);
+
+    // Output batch.
+    VELOX_REGISTER_QUERY_CONFIG(kPreferredOutputBatchBytes);
+    VELOX_REGISTER_QUERY_CONFIG(kPreferredOutputBatchRows);
+    VELOX_REGISTER_QUERY_CONFIG(kMaxOutputBatchRows);
+    VELOX_REGISTER_QUERY_CONFIG(kMergeJoinOutputBatchStartSize);
+
+    // Table scan.
+    VELOX_REGISTER_QUERY_CONFIG(kTableScanGetOutputTimeLimitMs);
+    VELOX_REGISTER_QUERY_CONFIG(kTableScanOutputBatchRowsOverride);
+
+    // Hash table.
+    VELOX_REGISTER_QUERY_CONFIG(kHashAdaptivityEnabled);
+    VELOX_REGISTER_QUERY_CONFIG(kAdaptiveFilterReorderingEnabled);
+    VELOX_REGISTER_QUERY_CONFIG(kParallelOutputJoinBuildRowsEnabled);
+
+    // Spill.
+    VELOX_REGISTER_QUERY_CONFIG(kSpillEnabled);
+    VELOX_REGISTER_QUERY_CONFIG(kAggregationSpillEnabled);
+    VELOX_REGISTER_QUERY_CONFIG(kJoinSpillEnabled);
+    VELOX_REGISTER_QUERY_CONFIG(kMixedGroupedModeHashJoinSpillEnabled);
+    VELOX_REGISTER_QUERY_CONFIG(kOrderBySpillEnabled);
+    VELOX_REGISTER_QUERY_CONFIG(kWindowSpillEnabled);
+    VELOX_REGISTER_QUERY_CONFIG(kWindowSpillMinReadBatchRows);
+    VELOX_REGISTER_QUERY_CONFIG(kWriterSpillEnabled);
+    VELOX_REGISTER_QUERY_CONFIG(kRowNumberSpillEnabled);
+    VELOX_REGISTER_QUERY_CONFIG(kMarkDistinctSpillEnabled);
+    VELOX_REGISTER_QUERY_CONFIG(kTopNRowNumberSpillEnabled);
+    VELOX_REGISTER_QUERY_CONFIG(kLocalMergeSpillEnabled);
+    VELOX_REGISTER_QUERY_CONFIG(kMaxSpillRunRows);
+    VELOX_REGISTER_QUERY_CONFIG(kMaxSpillBytes);
+    VELOX_REGISTER_QUERY_CONFIG(kMaxSpillLevel);
+    VELOX_REGISTER_QUERY_CONFIG(kMaxSpillFileSize);
+    VELOX_REGISTER_QUERY_CONFIG(kSpillCompressionKind);
+    VELOX_REGISTER_QUERY_CONFIG(kSpillNumMaxMergeFiles);
+    VELOX_REGISTER_QUERY_CONFIG(kSpillPrefixSortEnabled);
+    VELOX_REGISTER_QUERY_CONFIG(kSpillWriteBufferSize);
+    VELOX_REGISTER_QUERY_CONFIG(kSpillReadBufferSize);
+    VELOX_REGISTER_QUERY_CONFIG(kSpillFileCreateConfig);
+    VELOX_REGISTER_QUERY_CONFIG(kAggregationSpillFileCreateConfig);
+    VELOX_REGISTER_QUERY_CONFIG(kHashJoinSpillFileCreateConfig);
+    VELOX_REGISTER_QUERY_CONFIG(kRowNumberSpillFileCreateConfig);
+    VELOX_REGISTER_QUERY_CONFIG(kSpillStartPartitionBit);
+    VELOX_REGISTER_QUERY_CONFIG(kSpillNumPartitionBits);
+    VELOX_REGISTER_QUERY_CONFIG(kMinSpillableReservationPct);
+    VELOX_REGISTER_QUERY_CONFIG(kSpillableReservationGrowthPct);
+
+    // Writer.
+    VELOX_REGISTER_QUERY_CONFIG(kWriterFlushThresholdBytes);
+
+    // Presto-specific.
+    VELOX_REGISTER_QUERY_CONFIG(kPrestoArrayAggIgnoreNulls);
+
+    // Spark-specific.
+    VELOX_REGISTER_QUERY_CONFIG(kSparkAnsiEnabled);
+    VELOX_REGISTER_QUERY_CONFIG(kSparkBloomFilterExpectedNumItems);
+    VELOX_REGISTER_QUERY_CONFIG(kSparkBloomFilterNumBits);
+    VELOX_REGISTER_QUERY_CONFIG(kSparkBloomFilterMaxNumBits);
+    VELOX_REGISTER_QUERY_CONFIG(kSparkBloomFilterMaxNumItems);
+    VELOX_REGISTER_QUERY_CONFIG(kSparkLegacyDateFormatter);
+    VELOX_REGISTER_QUERY_CONFIG(kSparkLegacyStatisticalAggregate);
+    VELOX_REGISTER_QUERY_CONFIG(kSparkJsonIgnoreNullFields);
+    VELOX_REGISTER_QUERY_CONFIG(kSparkCollectListIgnoreNulls);
+
+    // Task writer.
+    VELOX_REGISTER_QUERY_CONFIG(kTaskWriterCount);
+
+    // Hash probe.
+    VELOX_REGISTER_QUERY_CONFIG(kHashProbeFinishEarlyOnEmptyBuild);
+    VELOX_REGISTER_QUERY_CONFIG(kHashProbeDynamicFilterPushdownEnabled);
+    VELOX_REGISTER_QUERY_CONFIG(kHashProbeStringDynamicFilterPushdownEnabled);
+    VELOX_REGISTER_QUERY_CONFIG(kHashProbeBloomFilterPushdownMaxSize);
+    VELOX_REGISTER_QUERY_CONFIG(kMinTableRowsForParallelJoinBuild);
+
+    // Debug and validation.
+    VELOX_REGISTER_QUERY_CONFIG(kValidateOutputFromOperators);
+    VELOX_REGISTER_QUERY_CONFIG(kEnableExpressionEvaluationCache);
+    VELOX_REGISTER_QUERY_CONFIG(kMaxSharedSubexprResultsCached);
+
+    // Split preload.
+    VELOX_REGISTER_QUERY_CONFIG(kMaxSplitPreloadPerDriver);
+
+    // Driver.
+    VELOX_REGISTER_QUERY_CONFIG(kDriverCpuTimeSliceLimitMs);
+
+    // Window.
+    VELOX_REGISTER_QUERY_CONFIG(kWindowNumSubPartitions);
+
+    // Prefix sort.
+    VELOX_REGISTER_QUERY_CONFIG(kPrefixSortNormalizedKeyMaxBytes);
+    VELOX_REGISTER_QUERY_CONFIG(kPrefixSortMinRows);
+    VELOX_REGISTER_QUERY_CONFIG(kPrefixSortMaxStringPrefixLength);
+
+    // Query trace.
+    VELOX_REGISTER_QUERY_CONFIG(kQueryTraceEnabled);
+    VELOX_REGISTER_QUERY_CONFIG(kQueryTraceDir);
+    VELOX_REGISTER_QUERY_CONFIG(kQueryTraceNodeId);
+    VELOX_REGISTER_QUERY_CONFIG(kQueryTraceMaxBytes);
+    VELOX_REGISTER_QUERY_CONFIG(kQueryTraceTaskRegExp);
+    VELOX_REGISTER_QUERY_CONFIG(kQueryTraceDryRun);
+    VELOX_REGISTER_QUERY_CONFIG(kOpTraceDirectoryCreateConfig);
+
+    // Debug expression.
+    VELOX_REGISTER_QUERY_CONFIG(kDebugDisableExpressionWithPeeling);
+    VELOX_REGISTER_QUERY_CONFIG(kDebugDisableCommonSubExpressions);
+    VELOX_REGISTER_QUERY_CONFIG(kDebugDisableExpressionWithMemoization);
+    VELOX_REGISTER_QUERY_CONFIG(kDebugDisableExpressionWithLazyInputs);
+    VELOX_REGISTER_QUERY_CONFIG(kDebugMemoryPoolNameRegex);
+    VELOX_REGISTER_QUERY_CONFIG(kDebugMemoryPoolWarnThresholdBytes);
+    VELOX_REGISTER_QUERY_CONFIG(kDebugLambdaFunctionEvaluationBatchSize);
+    VELOX_REGISTER_QUERY_CONFIG(kDebugBingTileChildrenMaxZoomShift);
+
+    // Nimble (deprecated, kept for backward compatibility).
+    VELOX_REGISTER_QUERY_CONFIG(kSelectiveNimbleReaderEnabled);
+
+    // Scale writer.
+    VELOX_REGISTER_QUERY_CONFIG(kScaleWriterRebalanceMaxMemoryUsageRatio);
+    VELOX_REGISTER_QUERY_CONFIG(kScaleWriterMaxPartitionsPerWriter);
+    VELOX_REGISTER_QUERY_CONFIG(
+        kScaleWriterMinPartitionProcessedBytesRebalanceThreshold);
+    VELOX_REGISTER_QUERY_CONFIG(
+        kScaleWriterMinProcessedBytesRebalanceThreshold);
+
+    // Table scan scaling.
+    VELOX_REGISTER_QUERY_CONFIG(kTableScanScaledProcessingEnabled);
+    VELOX_REGISTER_QUERY_CONFIG(kTableScanScaleUpMemoryUsageRatio);
+
+    // Shuffle.
+    VELOX_REGISTER_QUERY_CONFIG(kShuffleCompressionKind);
+    VELOX_REGISTER_QUERY_CONFIG(kMinShuffleCompressionPageSizeBytes);
+
+    // Map.
+    VELOX_REGISTER_QUERY_CONFIG(kThrowExceptionOnDuplicateMapKeys);
+
+    // Index lookup join.
+    VELOX_REGISTER_QUERY_CONFIG(kIndexLookupJoinMaxPrefetchBatches);
+    VELOX_REGISTER_QUERY_CONFIG(kIndexLookupJoinSplitOutput);
+
+    // Exchange request.
+    VELOX_REGISTER_QUERY_CONFIG(kRequestDataSizesMaxWaitSec);
+
+    // Streaming aggregation.
+    VELOX_REGISTER_QUERY_CONFIG(kStreamingAggregationMinOutputBatchRows);
+    VELOX_REGISTER_QUERY_CONFIG(kStreamingAggregationEagerFlush);
+
+    // Exchange optimization.
+    VELOX_REGISTER_QUERY_CONFIG(kSkipRequestDataSizeWithSingleSourceEnabled);
+    VELOX_REGISTER_QUERY_CONFIG(kExchangeLazyFetchingEnabled);
+
+    // JSON cast.
+    VELOX_REGISTER_QUERY_CONFIG(kFieldNamesInJsonCastEnabled);
+
+    // Operator stats.
+    VELOX_REGISTER_QUERY_CONFIG(kOperatorTrackExpressionStats);
+    VELOX_REGISTER_QUERY_CONFIG(kEnableOperatorBatchSizeStats);
+
+    // Unnest.
+    VELOX_REGISTER_QUERY_CONFIG(kUnnestSplitOutput);
+
+    // Memory reclaimer.
+    VELOX_REGISTER_QUERY_CONFIG(kQueryMemoryReclaimerPriority);
+
+    // Splits.
+    VELOX_REGISTER_QUERY_CONFIG(kMaxNumSplitsListenedTo);
+
+    // Source and tags.
+    VELOX_REGISTER_QUERY_CONFIG(kSource);
+    VELOX_REGISTER_QUERY_CONFIG(kClientTags);
+
+    // Row size tracking.
+    VELOX_REGISTER_QUERY_CONFIG(kRowSizeTrackingMode);
+
+    // Join build.
+    VELOX_REGISTER_QUERY_CONFIG(kJoinBuildVectorHasherMaxNumDistinct);
+
+    // Mark sorted.
+    VELOX_REGISTER_QUERY_CONFIG(kMarkSortedZeroCopyThreshold);
+
+#undef VELOX_REGISTER_QUERY_CONFIG
+
+    return properties;
+  }();
+  return kProperties;
 }
 
-QueryConfig::QueryConfig(std::unordered_map<std::string, std::string>&& values)
-    : config_{std::make_unique<config::ConfigBase>(std::move(values))} {
+QueryConfig::QueryConfig(std::unordered_map<std::string, std::string> values)
+    : QueryConfig{
+          ConfigTag{},
+          std::make_shared<config::ConfigBase>(std::move(values))} {}
+
+QueryConfig::QueryConfig(
+    ConfigTag /*tag*/,
+    std::shared_ptr<const config::IConfig> config)
+    : config_{std::move(config)} {
   validateConfig();
 }
 
 void QueryConfig::validateConfig() {
   // Validate if timezone name can be recognized.
-  if (config_->valueExists(QueryConfig::kSessionTimezone)) {
+  if (auto tz = config_->get<std::string>(QueryConfig::kSessionTimezone)) {
     VELOX_USER_CHECK(
-        tz::getTimeZoneID(
-            config_->get<std::string>(QueryConfig::kSessionTimezone).value(),
-            false) != -1,
-        fmt::format(
-            "session '{}' set with invalid value '{}'",
-            QueryConfig::kSessionTimezone,
-            config_->get<std::string>(QueryConfig::kSessionTimezone).value()));
+        tz::getTimeZoneID(*tz, false) != -1,
+        "session '{}' set with invalid value '{}'",
+        QueryConfig::kSessionTimezone,
+        *tz);
   }
 }
 
diff --git a/velox/core/QueryConfig.h b/velox/core/QueryConfig.h
index 02cde3df9b4..2031009585c 100644
--- a/velox/core/QueryConfig.h
+++ b/velox/core/QueryConfig.h
@@ -15,726 +15,1484 @@
  */
 #pragma once
 
-#include "velox/common/compression/Compression.h"
 #include "velox/common/config/Config.h"
+#include "velox/common/config/ConfigProperty.h"
 #include "velox/vector/TypeAliases.h"
 
 namespace facebook::velox::core {
 
-/// A simple wrapper around velox::ConfigBase. Defines constants for query
+/// Macros for defining query config properties.
+///
+/// To add a new property, add two lines (order doesn't matter, but
+/// grouping related properties together helps readability):
+///
+/// 1. In QueryConfig.h (inside the class body):
+///   VELOX_QUERY_CONFIG(kSpillEnabled, spillEnabled, "spill_enabled",
+///       bool, false, "Global enable spilling flag.");
+///
+/// 2. In QueryConfig.cpp (inside registeredProperties()):
+///   VELOX_REGISTER_QUERY_CONFIG(kSpillEnabled);
+///
+/// VELOX_QUERY_CONFIG generates:
+///   - struct kSpillEnabledProperty {
+///         using type = bool;
+///         static constexpr const char* key = "spill_enabled";
+///         static constexpr auto defaultValue = false;
+///         static constexpr const char* description = "Global enable...";
+///     };
+///   - static constexpr const char* kSpillEnabled = "spill_enabled"
+///   - bool spillEnabled() const {
+///         return get<bool>(kSpillEnabled, false);
+///     }
+///
+/// VELOX_QUERY_CONFIG_PROPERTY generates the same but without the accessor.
+/// Used for legacy properties with custom accessor logic (capacity parsing,
+/// validation, clamping). New properties should use VELOX_QUERY_CONFIG and
+/// put validation in QueryConfig::validateConfig() and
+/// QueryConfigProvider::normalize().
+/// TODO: Unify validateConfig() and normalize() into a single validation path.
+#define VELOX_QUERY_CONFIG_PROPERTY(                 \
+    constName, keyStr, CppType, defaultVal, desc)    \
+  struct constName##Property {                       \
+    using type = CppType;                            \
+    static constexpr const char* key = keyStr;       \
+    static constexpr auto defaultValue = defaultVal; \
+    static constexpr const char* description = desc; \
+  };                                                 \
+  static constexpr const char* constName = keyStr;
+
+#define VELOX_QUERY_CONFIG(                                                 \
+    constName, accessorName, keyStr, CppType, defaultVal, desc)             \
+  VELOX_QUERY_CONFIG_PROPERTY(constName, keyStr, CppType, defaultVal, desc) \
+  CppType accessorName() const {                                            \
+    return get<CppType>(constName, defaultVal);                             \
+  }
+
+/// A simple wrapper around velox::IConfig. Defines constants for query
 /// config properties and accessor methods.
 /// Create per query context. Does not have a singleton instance.
 /// Does not allow altering properties on the fly. Only at creation time.
 class QueryConfig {
  public:
+  explicit QueryConfig(std::unordered_map<std::string, std::string> values);
+
+  // This is needed only to resolve correct ctor for cases like
+  // QueryConfig{{}} or QueryConfig({}).
+  struct ConfigTag {};
+
   explicit QueryConfig(
-      const std::unordered_map<std::string, std::string>& values);
+      ConfigTag /*tag*/,
+      std::shared_ptr<const config::IConfig> config);
 
-  explicit QueryConfig(std::unordered_map<std::string, std::string>&& values);
+  /// Returns all registered query config properties.
+  static const std::vector<config::ConfigProperty>& registeredProperties();
 
   /// Maximum memory that a query can use on a single host.
-  static constexpr const char* kQueryMaxMemoryPerNode =
-      "query_max_memory_per_node";
+  VELOX_QUERY_CONFIG_PROPERTY(
+      kQueryMaxMemoryPerNode,
+      "query_max_memory_per_node",
+      std::string,
+      "0B",
+      "Maximum memory that a query can use on a single host.")
 
   /// User provided session timezone. Stores a string with the actual timezone
   /// name, e.g: "America/Los_Angeles".
-  static constexpr const char* kSessionTimezone = "session_timezone";
+  VELOX_QUERY_CONFIG(
+      kSessionTimezone,
+      sessionTimezone,
+      "session_timezone",
+      std::string,
+      "",
+      "Session timezone name, e.g. 'America/Los_Angeles'.")
+
+  /// Session start time in milliseconds since Unix epoch. This represents when
+  /// the query session began execution. Used for functions that need to know
+  /// the session start time (e.g., current_date, localtime).
+  VELOX_QUERY_CONFIG(
+      kSessionStartTime,
+      sessionStartTimeMs,
+      "start_time",
+      int64_t,
+      0,
+      "Session start time in milliseconds since Unix epoch.")
 
   /// If true, timezone-less timestamp conversions (e.g. string to timestamp,
   /// when the string does not specify a timezone) will be adjusted to the user
   /// provided session timezone (if any).
-  ///
-  /// For instance:
-  ///
-  ///  if this option is true and user supplied "America/Los_Angeles",
-  ///  "1970-01-01" will be converted to -28800 instead of 0.
-  ///
-  /// False by default.
-  static constexpr const char* kAdjustTimestampToTimezone =
-      "adjust_timestamp_to_session_timezone";
+  VELOX_QUERY_CONFIG(
+      kAdjustTimestampToTimezone,
+      adjustTimestampToTimezone,
+      "adjust_timestamp_to_session_timezone",
+      bool,
+      false,
+      "Adjust timezone-less timestamp conversions to session timezone.")
 
   /// Whether to use the simplified expression evaluation path. False by
   /// default.
-  static constexpr const char* kExprEvalSimplified =
-      "expression.eval_simplified";
+  VELOX_QUERY_CONFIG(
+      kExprEvalSimplified,
+      exprEvalSimplified,
+      "expression.eval_simplified",
+      bool,
+      false,
+      "Use simplified expression evaluation path.")
+
+  /// Whether to enable the FlatNoNulls fast path for expression evaluation.
+  /// When enabled, expressions skip null checking and vector decoding when all
+  /// inputs are flat-encoded with no nulls. True by default.
+  VELOX_QUERY_CONFIG(
+      kExprEvalFlatNoNulls,
+      exprEvalFlatNoNulls,
+      "expression.eval_flat_no_nulls",
+      bool,
+      true,
+      "Enable FlatNoNulls fast path for expression evaluation.")
 
   /// Whether to track CPU usage for individual expressions (supported by call
   /// and cast expressions). False by default. Can be expensive when processing
   /// small batches, e.g. < 10K rows.
-  static constexpr const char* kExprTrackCpuUsage =
-      "expression.track_cpu_usage";
+  VELOX_QUERY_CONFIG(
+      kExprTrackCpuUsage,
+      exprTrackCpuUsage,
+      "expression.track_cpu_usage",
+      bool,
+      false,
+      "Track CPU usage for individual expressions.")
+
+  /// Takes a comma separated list of function names to track CPU usage for.
+  /// Only applicable when kExprTrackCpuUsage is set to false. Is empty by
+  /// default.
+  VELOX_QUERY_CONFIG(
+      kExprTrackCpuUsageForFunctions,
+      exprTrackCpuUsageForFunctions,
+      "expression.track_cpu_usage_for_functions",
+      std::string,
+      "",
+      "Comma-separated function names to track CPU usage for.")
+
+  /// Enables adaptive per-function CPU usage sampling. When enabled, each
+  /// function is calibrated over the first 6 batches (1 warmup + 5
+  /// calibration) to measure the overhead of CPU tracking (clock_gettime).
+  VELOX_QUERY_CONFIG(
+      kExprAdaptiveCpuSampling,
+      exprAdaptiveCpuSampling,
+      "expression.adaptive_cpu_sampling",
+      bool,
+      false,
+      "Enable adaptive per-function CPU usage sampling.")
+
+  /// Maximum acceptable overhead percentage for CPU tracking per function.
+  /// Used with kExprAdaptiveCpuSampling.
+  VELOX_QUERY_CONFIG(
+      kExprAdaptiveCpuSamplingMaxOverheadPct,
+      exprAdaptiveCpuSamplingMaxOverheadPct,
+      "expression.adaptive_cpu_sampling_max_overhead_pct",
+      double,
+      1.0,
+      "Maximum acceptable overhead percentage for CPU tracking per function.")
+
+  /// Controls whether non-deterministic expressions are deduplicated during
+  /// compilation. If set to false, non-deterministic functions (such as
+  /// rand()) will not be deduplicated.
+  VELOX_QUERY_CONFIG(
+      kExprDedupNonDeterministic,
+      exprDedupNonDeterministic,
+      "expression.dedup_non_deterministic",
+      bool,
+      true,
+      "Deduplicate non-deterministic expressions during compilation.")
 
   /// Whether to track CPU usage for stages of individual operators. True by
   /// default. Can be expensive when processing small batches, e.g. < 10K rows.
-  static constexpr const char* kOperatorTrackCpuUsage =
-      "track_operator_cpu_usage";
+  VELOX_QUERY_CONFIG(
+      kOperatorTrackCpuUsage,
+      operatorTrackCpuUsage,
+      "track_operator_cpu_usage",
+      bool,
+      true,
+      "Track CPU usage for stages of individual operators.")
 
   /// Flags used to configure the CAST operator:
-
-  static constexpr const char* kLegacyCast = "legacy_cast";
+  VELOX_QUERY_CONFIG(
+      kLegacyCast,
+      isLegacyCast,
+      "legacy_cast",
+      bool,
+      false,
+      "Use legacy CAST behavior.")
 
   /// This flag makes the Row conversion to by applied in a way that the casting
   /// row field are matched by name instead of position.
-  static constexpr const char* kCastMatchStructByName =
-      "cast_match_struct_by_name";
+  VELOX_QUERY_CONFIG(
+      kCastMatchStructByName,
+      isMatchStructByName,
+      "cast_match_struct_by_name",
+      bool,
+      false,
+      "Match Row fields by name instead of position in CAST.")
 
   /// Reduce() function will throw an error if encountered an array of size
   /// greater than this.
-  static constexpr const char* kExprMaxArraySizeInReduce =
-      "expression.max_array_size_in_reduce";
+  VELOX_QUERY_CONFIG(
+      kExprMaxArraySizeInReduce,
+      exprMaxArraySizeInReduce,
+      "expression.max_array_size_in_reduce",
+      uint64_t,
+      100'000,
+      "Maximum array size allowed in reduce() function.")
 
   /// Controls maximum number of compiled regular expression patterns per
   /// function instance per thread of execution.
-  static constexpr const char* kExprMaxCompiledRegexes =
-      "expression.max_compiled_regexes";
+  VELOX_QUERY_CONFIG(
+      kExprMaxCompiledRegexes,
+      exprMaxCompiledRegexes,
+      "expression.max_compiled_regexes",
+      uint64_t,
+      100,
+      "Maximum compiled regex patterns per function instance per thread.")
 
   /// Used for backpressure to block local exchange producers when the local
   /// exchange buffer reaches or exceeds this size.
-  static constexpr const char* kMaxLocalExchangeBufferSize =
-      "max_local_exchange_buffer_size";
+  VELOX_QUERY_CONFIG(
+      kMaxLocalExchangeBufferSize,
+      maxLocalExchangeBufferSize,
+      "max_local_exchange_buffer_size",
+      uint64_t,
+      32UL << 20,
+      "Max local exchange buffer size in bytes for backpressure.")
 
   /// Limits the number of partitions created by a local exchange.
-  /// Partitioning data too granularly can lead to poor performance.
-  /// This setting allows increasing the task concurrency for all
-  /// pipelines except the ones that require a local partitioning.
-  /// Affects the number of drivers for pipelines containing
-  /// LocalPartitionNode and cannot exceed the maximum number of
-  /// pipeline drivers configured for the task.
-  static constexpr const char* kMaxLocalExchangePartitionCount =
-      "max_local_exchange_partition_count";
+  VELOX_QUERY_CONFIG(
+      kMaxLocalExchangePartitionCount,
+      maxLocalExchangePartitionCount,
+      "max_local_exchange_partition_count",
+      uint32_t,
+      std::numeric_limits<uint32_t>::max(),
+      "Maximum number of partitions in local exchange.")
 
   /// Minimum number of local exchange output partitions to use buffered
   /// partitioning.
-  ///
-  /// When the number of output partitions is low, it is preferred to process
-  /// one input vector at a time. For example, with 10 output partitions
-  /// splitting a single 100KB input vector into 10 10KB vectors is acceptable.
-  /// However, when the number of output partitions is high it may result in a
-  /// large number of tiny vectors generated. For example, with 100 output
-  /// partitions splitting a single 100KB input vector results in 100 1KB
-  /// vectors. Exchanging and processing tiny vectors may negatively impact
-  /// performance. To avoid this, buffered partitioning is used to accumulate
-  /// larger vectors.
-  static constexpr const char*
-      kMinLocalExchangePartitionCountToUsePartitionBuffer =
-          "min_local_exchange_partition_count_to_use_partition_buffer";
+  VELOX_QUERY_CONFIG(
+      kMinLocalExchangePartitionCountToUsePartitionBuffer,
+      minLocalExchangePartitionCountToUsePartitionBuffer,
+      "min_local_exchange_partition_count_to_use_partition_buffer",
+      uint32_t,
+      33,
+      "Minimum output partitions to use buffered partitioning.")
 
   /// Maximum size in bytes to accumulate for a single partition of a local
   /// exchange before flushing.
-  ///
-  /// The total amount of memory used by a single
-  /// local exchange operator is the sum of the sizes of all partitions. For
-  /// example, if the number of downstream pipeline drivers is 10 and the max
-  /// local exchange partition buffer size is 100KB, then the total memory used
-  /// by a single local exchange operator is 1MB. The total memory needed to
-  /// perform a local exchange is equal to the single local exchange
-  /// operator memory multiplied by the number of upstream pipeline drivers. For
-  /// example, if the number of upstream pipeline drivers is 10 the total memory
-  /// used by the local exchange operator is 10MB.
-  static constexpr const char* kMaxLocalExchangePartitionBufferSize =
-      "max_local_exchange_partition_buffer_size";
+  VELOX_QUERY_CONFIG(
+      kMaxLocalExchangePartitionBufferSize,
+      maxLocalExchangePartitionBufferSize,
+      "max_local_exchange_partition_buffer_size",
+      uint64_t,
+      64UL * 1024,
+      "Max bytes to accumulate per local exchange partition.")
 
   /// Try to preserve the encoding of the input vector when copying it to the
   /// buffer.
-  static constexpr const char* kLocalExchangePartitionBufferPreserveEncoding =
-      "local_exchange_partition_buffer_preserve_encoding";
+  VELOX_QUERY_CONFIG(
+      kLocalExchangePartitionBufferPreserveEncoding,
+      localExchangePartitionBufferPreserveEncoding,
+      "local_exchange_partition_buffer_preserve_encoding",
+      bool,
+      false,
+      "Preserve encoding of input vector in partition buffer.")
 
   /// Maximum number of vectors buffered in each local merge source before
   /// blocking to wait for consumers.
-  static constexpr const char* kLocalMergeSourceQueueSize =
-      "local_merge_source_queue_size";
+  VELOX_QUERY_CONFIG(
+      kLocalMergeSourceQueueSize,
+      localMergeSourceQueueSize,
+      "local_merge_source_queue_size",
+      uint32_t,
+      2,
+      "Maximum vectors buffered in each local merge source.")
 
   /// Maximum size in bytes to accumulate in ExchangeQueue. Enforced
   /// approximately, not strictly.
-  static constexpr const char* kMaxExchangeBufferSize =
-      "exchange.max_buffer_size";
+  VELOX_QUERY_CONFIG(
+      kMaxExchangeBufferSize,
+      maxExchangeBufferSize,
+      "exchange.max_buffer_size",
+      uint64_t,
+      32UL << 20,
+      "Maximum bytes to accumulate in ExchangeQueue.")
 
   /// Maximum size in bytes to accumulate among all sources of the merge
   /// exchange. Enforced approximately, not strictly.
-  static constexpr const char* kMaxMergeExchangeBufferSize =
-      "merge_exchange.max_buffer_size";
+  VELOX_QUERY_CONFIG(
+      kMaxMergeExchangeBufferSize,
+      maxMergeExchangeBufferSize,
+      "merge_exchange.max_buffer_size",
+      uint64_t,
+      128UL << 20,
+      "Maximum bytes to accumulate among all merge exchange sources.")
 
   /// The minimum number of bytes to accumulate in the ExchangeQueue
-  /// before unblocking a consumer. This is used to avoid creating tiny
-  /// batches which may have a negative impact on performance when the
-  /// cost of creating vectors is high (for example, when there are many
-  /// columns). To avoid latency degradation, the exchange client unblocks a
-  /// consumer when 1% of the data size observed so far is accumulated.
-  static constexpr const char* kMinExchangeOutputBatchBytes =
-      "min_exchange_output_batch_bytes";
-
-  static constexpr const char* kMaxPartialAggregationMemory =
-      "max_partial_aggregation_memory";
-
-  static constexpr const char* kMaxExtendedPartialAggregationMemory =
-      "max_extended_partial_aggregation_memory";
-
-  static constexpr const char* kAbandonPartialAggregationMinRows =
-      "abandon_partial_aggregation_min_rows";
-
-  static constexpr const char* kAbandonPartialAggregationMinPct =
-      "abandon_partial_aggregation_min_pct";
-
-  static constexpr const char* kAbandonPartialTopNRowNumberMinRows =
-      "abandon_partial_topn_row_number_min_rows";
-
-  static constexpr const char* kAbandonPartialTopNRowNumberMinPct =
-      "abandon_partial_topn_row_number_min_pct";
-
-  static constexpr const char* kMaxElementsSizeInRepeatAndSequence =
-      "max_elements_size_in_repeat_and_sequence";
+  /// before unblocking a consumer.
+  VELOX_QUERY_CONFIG(
+      kMinExchangeOutputBatchBytes,
+      minExchangeOutputBatchBytes,
+      "min_exchange_output_batch_bytes",
+      uint64_t,
+      2UL << 20,
+      "Minimum bytes to accumulate before unblocking an exchange consumer.")
+
+  VELOX_QUERY_CONFIG(
+      kMaxPartialAggregationMemory,
+      maxPartialAggregationMemoryUsage,
+      "max_partial_aggregation_memory",
+      uint64_t,
+      1L << 24,
+      "Maximum memory for partial aggregation.")
+
+  VELOX_QUERY_CONFIG(
+      kMaxExtendedPartialAggregationMemory,
+      maxExtendedPartialAggregationMemoryUsage,
+      "max_extended_partial_aggregation_memory",
+      uint64_t,
+      1L << 26,
+      "Maximum memory for extended partial aggregation.")
+
+  VELOX_QUERY_CONFIG(
+      kAbandonPartialAggregationMinRows,
+      abandonPartialAggregationMinRows,
+      "abandon_partial_aggregation_min_rows",
+      int32_t,
+      100'000,
+      "Minimum input rows before checking whether to abandon partial aggregation.")
+
+  VELOX_QUERY_CONFIG(
+      kAbandonPartialAggregationMinPct,
+      abandonPartialAggregationMinPct,
+      "abandon_partial_aggregation_min_pct",
+      int32_t,
+      80,
+      "Abandon partial aggregation if reduction percentage exceeds this.")
+
+  /// Memory threshold in bytes for triggering string compaction during
+  /// global aggregation. Disabled by default (0).
+  VELOX_QUERY_CONFIG(
+      kAggregationCompactionBytesThreshold,
+      aggregationCompactionBytesThreshold,
+      "aggregation_compaction_bytes_threshold",
+      uint64_t,
+      0,
+      "Memory threshold in bytes for triggering string compaction during aggregation.")
+
+  /// Ratio of unused (evicted) bytes to total bytes that triggers compaction.
+  VELOX_QUERY_CONFIG(
+      kAggregationCompactionUnusedMemoryRatio,
+      aggregationCompactionUnusedMemoryRatio,
+      "aggregation_compaction_unused_memory_ratio",
+      double,
+      0.25,
+      "Ratio of unused bytes to total bytes that triggers compaction.")
+
+  /// If true, enables lightweight memory compaction before spilling during
+  /// memory reclaim in aggregation.
+  VELOX_QUERY_CONFIG(
+      kAggregationMemoryCompactionReclaimEnabled,
+      aggregationMemoryCompactionReclaimEnabled,
+      "aggregation_memory_compaction_reclaim_enabled",
+      bool,
+      false,
+      "Enable memory compaction before spilling during aggregation reclaim.")
+
+  VELOX_QUERY_CONFIG(
+      kAbandonPartialTopNRowNumberMinRows,
+      abandonPartialTopNRowNumberMinRows,
+      "abandon_partial_topn_row_number_min_rows",
+      int32_t,
+      100'000,
+      "Minimum rows before checking whether to abandon partial TopN row number.")
+
+  VELOX_QUERY_CONFIG(
+      kAbandonPartialTopNRowNumberMinPct,
+      abandonPartialTopNRowNumberMinPct,
+      "abandon_partial_topn_row_number_min_pct",
+      int32_t,
+      80,
+      "Abandon partial TopN row number if reduction percentage exceeds this.")
+
+  /// Number of input rows to receive before starting to check whether to
+  /// abandon building a HashTable without duplicates in HashBuild.
+  VELOX_QUERY_CONFIG(
+      kAbandonDedupHashMapMinRows,
+      abandonHashBuildDedupMinRows,
+      "abandon_dedup_hashmap_min_rows",
+      int32_t,
+      100'000,
+      "Minimum rows before checking whether to abandon dedup hash map.")
+
+  /// Abandons building a HashTable without duplicates in HashBuild for left
+  /// semi/anti join if the percentage of distinct keys exceeds this threshold.
+  VELOX_QUERY_CONFIG(
+      kAbandonDedupHashMapMinPct,
+      abandonHashBuildDedupMinPct,
+      "abandon_dedup_hashmap_min_pct",
+      int32_t,
+      0,
+      "Abandon dedup hash map if distinct key percentage exceeds this. 0 disables.")
+
+  VELOX_QUERY_CONFIG(
+      kMaxElementsSizeInRepeatAndSequence,
+      maxElementsSizeInRepeatAndSequence,
+      "max_elements_size_in_repeat_and_sequence",
+      int32_t,
+      10'000,
+      "Maximum elements size in repeat and sequence functions.")
+
+  /// If true, the PartitionedOutput operator will flush rows eagerly.
+  VELOX_QUERY_CONFIG(
+      kPartitionedOutputEagerFlush,
+      partitionedOutputEagerFlush,
+      "partitioned_output_eager_flush",
+      bool,
+      false,
+      "Flush PartitionedOutput rows eagerly without buffering.")
 
   /// The maximum number of bytes to buffer in PartitionedOutput operator to
   /// avoid creating tiny SerializedPages.
-  ///
-  /// For PartitionedOutputNode::Kind::kPartitioned, PartitionedOutput operator
-  /// would buffer up to that number of bytes / number of destinations for each
-  /// destination before producing a SerializedPage.
-  static constexpr const char* kMaxPartitionedOutputBufferSize =
-      "max_page_partitioning_buffer_size";
+  VELOX_QUERY_CONFIG(
+      kMaxPartitionedOutputBufferSize,
+      maxPartitionedOutputBufferSize,
+      "max_page_partitioning_buffer_size",
+      uint64_t,
+      32UL << 20,
+      "Maximum bytes to buffer in PartitionedOutput operator.")
 
   /// The maximum size in bytes for the task's buffered output.
-  ///
-  /// The producer Drivers are blocked when the buffered size exceeds
-  /// this. The Drivers are resumed when the buffered size goes below
-  /// OutputBufferManager::kContinuePct % of this.
-  static constexpr const char* kMaxOutputBufferSize = "max_output_buffer_size";
+  VELOX_QUERY_CONFIG(
+      kMaxOutputBufferSize,
+      maxOutputBufferSize,
+      "max_output_buffer_size",
+      uint64_t,
+      32UL << 20,
+      "Maximum size in bytes for the task's buffered output.")
 
   /// Preferred size of batches in bytes to be returned by operators from
-  /// Operator::getOutput. It is used when an estimate of average row size is
-  /// known. Otherwise kPreferredOutputBatchRows is used.
-  static constexpr const char* kPreferredOutputBatchBytes =
-      "preferred_output_batch_bytes";
+  /// Operator::getOutput.
+  VELOX_QUERY_CONFIG(
+      kPreferredOutputBatchBytes,
+      preferredOutputBatchBytes,
+      "preferred_output_batch_bytes",
+      uint64_t,
+      10UL << 20,
+      "Preferred size of output batches in bytes.")
 
   /// Preferred number of rows to be returned by operators from
-  /// Operator::getOutput. It is used when an estimate of average row size is
-  /// not known. When the estimate of average row size is known,
-  /// kPreferredOutputBatchBytes is used.
-  static constexpr const char* kPreferredOutputBatchRows =
-      "preferred_output_batch_rows";
+  /// Operator::getOutput. Used when average row size is not known.
+  VELOX_QUERY_CONFIG_PROPERTY(
+      kPreferredOutputBatchRows,
+      "preferred_output_batch_rows",
+      uint32_t,
+      1024,
+      "Preferred number of rows in output batches.")
 
   /// Max number of rows that could be return by operators from
-  /// Operator::getOutput. It is used when an estimate of average row size is
-  /// known and kPreferredOutputBatchBytes is used to compute the number of
-  /// output rows.
-  static constexpr const char* kMaxOutputBatchRows = "max_output_batch_rows";
+  /// Operator::getOutput.
+  VELOX_QUERY_CONFIG_PROPERTY(
+      kMaxOutputBatchRows,
+      "max_output_batch_rows",
+      uint32_t,
+      10000,
+      "Maximum number of rows in output batches.")
+
+  /// Initial output batch size in rows for MergeJoin operator.
+  VELOX_QUERY_CONFIG_PROPERTY(
+      kMergeJoinOutputBatchStartSize,
+      "merge_join_output_batch_start_size",
+      uint32_t,
+      0,
+      "Initial output batch size in rows for MergeJoin. 0 disables dynamic adjustment.")
 
   /// TableScan operator will exit getOutput() method after this many
   /// milliseconds even if it has no data to return yet. Zero means 'no time
   /// limit'.
-  static constexpr const char* kTableScanGetOutputTimeLimitMs =
-      "table_scan_getoutput_time_limit_ms";
+  VELOX_QUERY_CONFIG(
+      kTableScanGetOutputTimeLimitMs,
+      tableScanGetOutputTimeLimitMs,
+      "table_scan_getoutput_time_limit_ms",
+      uint32_t,
+      5'000,
+      "Time limit in ms for TableScan getOutput(). 0 means no limit.")
+
+  /// If non-zero, overrides the number of rows in each output batch produced
+  /// by the TableScan operator. Zero means 'no override'.
+  VELOX_QUERY_CONFIG(
+      kTableScanOutputBatchRowsOverride,
+      tableScanOutputBatchRowsOverride,
+      "table_scan_output_batch_rows_override",
+      uint32_t,
+      0,
+      "Override number of rows in TableScan output batches. 0 means no override.")
 
   /// If false, the 'group by' code is forced to use generic hash mode
   /// hashtable.
-  static constexpr const char* kHashAdaptivityEnabled =
-      "hash_adaptivity_enabled";
+  VELOX_QUERY_CONFIG(
+      kHashAdaptivityEnabled,
+      hashAdaptivityEnabled,
+      "hash_adaptivity_enabled",
+      bool,
+      true,
+      "Enable hash adaptivity for group-by hash mode selection.")
 
   /// If true, the conjunction expression can reorder inputs based on the time
   /// taken to calculate them.
-  static constexpr const char* kAdaptiveFilterReorderingEnabled =
-      "adaptive_filter_reordering_enabled";
+  VELOX_QUERY_CONFIG(
+      kAdaptiveFilterReorderingEnabled,
+      adaptiveFilterReorderingEnabled,
+      "adaptive_filter_reordering_enabled",
+      bool,
+      true,
+      "Allow conjunction to reorder inputs based on evaluation time.")
+
+  /// If true, allow hash probe drivers to generate build-side rows in parallel.
+  VELOX_QUERY_CONFIG(
+      kParallelOutputJoinBuildRowsEnabled,
+      parallelOutputJoinBuildRowsEnabled,
+      "parallel_output_join_build_rows_enabled",
+      bool,
+      false,
+      "Allow hash probe drivers to generate build-side rows in parallel.")
 
   /// Global enable spilling flag.
-  static constexpr const char* kSpillEnabled = "spill_enabled";
+  VELOX_QUERY_CONFIG(
+      kSpillEnabled,
+      spillEnabled,
+      "spill_enabled",
+      bool,
+      false,
+      "Global enable spilling flag.")
 
   /// Aggregation spilling flag, only applies if "spill_enabled" flag is set.
-  static constexpr const char* kAggregationSpillEnabled =
-      "aggregation_spill_enabled";
+  VELOX_QUERY_CONFIG(
+      kAggregationSpillEnabled,
+      aggregationSpillEnabled,
+      "aggregation_spill_enabled",
+      bool,
+      true,
+      "Enable aggregation spilling. Requires spill_enabled.")
 
   /// Join spilling flag, only applies if "spill_enabled" flag is set.
-  static constexpr const char* kJoinSpillEnabled = "join_spill_enabled";
+  VELOX_QUERY_CONFIG(
+      kJoinSpillEnabled,
+      joinSpillEnabled,
+      "join_spill_enabled",
+      bool,
+      true,
+      "Enable join spilling. Requires spill_enabled.")
 
   /// Config to enable hash join spill for mixed grouped execution mode.
-  static constexpr const char* kMixedGroupedModeHashJoinSpillEnabled =
-      "mixed_grouped_mode_hash_join_spill_enabled";
+  VELOX_QUERY_CONFIG(
+      kMixedGroupedModeHashJoinSpillEnabled,
+      mixedGroupedModeHashJoinSpillEnabled,
+      "mixed_grouped_mode_hash_join_spill_enabled",
+      bool,
+      false,
+      "Enable hash join spill for mixed grouped execution mode.")
 
   /// OrderBy spilling flag, only applies if "spill_enabled" flag is set.
-  static constexpr const char* kOrderBySpillEnabled = "order_by_spill_enabled";
+  VELOX_QUERY_CONFIG(
+      kOrderBySpillEnabled,
+      orderBySpillEnabled,
+      "order_by_spill_enabled",
+      bool,
+      true,
+      "Enable order-by spilling. Requires spill_enabled.")
 
   /// Window spilling flag, only applies if "spill_enabled" flag is set.
-  static constexpr const char* kWindowSpillEnabled = "window_spill_enabled";
+  VELOX_QUERY_CONFIG(
+      kWindowSpillEnabled,
+      windowSpillEnabled,
+      "window_spill_enabled",
+      bool,
+      true,
+      "Enable window spilling. Requires spill_enabled.")
+
+  /// When processing spilled window data, read batches of whole partitions
+  /// having at least that many rows.
+  VELOX_QUERY_CONFIG(
+      kWindowSpillMinReadBatchRows,
+      windowSpillMinReadBatchRows,
+      "window_spill_min_read_batch_rows",
+      uint32_t,
+      1'000,
+      "Minimum rows to read per batch when processing spilled window data.")
 
   /// If true, the memory arbitrator will reclaim memory from table writer by
-  /// flushing its buffered data to disk. only applies if "spill_enabled" flag
-  /// is set.
-  static constexpr const char* kWriterSpillEnabled = "writer_spill_enabled";
+  /// flushing its buffered data to disk. Requires spill_enabled.
+  VELOX_QUERY_CONFIG(
+      kWriterSpillEnabled,
+      writerSpillEnabled,
+      "writer_spill_enabled",
+      bool,
+      true,
+      "Enable writer spilling by flushing buffered data to disk.")
 
   /// RowNumber spilling flag, only applies if "spill_enabled" flag is set.
-  static constexpr const char* kRowNumberSpillEnabled =
-      "row_number_spill_enabled";
+  VELOX_QUERY_CONFIG(
+      kRowNumberSpillEnabled,
+      rowNumberSpillEnabled,
+      "row_number_spill_enabled",
+      bool,
+      true,
+      "Enable RowNumber spilling. Requires spill_enabled.")
+
+  /// MarkDistinct spilling flag, only applies if "spill_enabled" flag is set.
+  VELOX_QUERY_CONFIG(
+      kMarkDistinctSpillEnabled,
+      markDistinctSpillEnabled,
+      "mark_distinct_spill_enabled",
+      bool,
+      false,
+      "Enable MarkDistinct spilling. Requires spill_enabled.")
 
   /// TopNRowNumber spilling flag, only applies if "spill_enabled" flag is set.
-  static constexpr const char* kTopNRowNumberSpillEnabled =
-      "topn_row_number_spill_enabled";
+  VELOX_QUERY_CONFIG(
+      kTopNRowNumberSpillEnabled,
+      topNRowNumberSpillEnabled,
+      "topn_row_number_spill_enabled",
+      bool,
+      true,
+      "Enable TopNRowNumber spilling. Requires spill_enabled.")
 
   /// LocalMerge spilling flag, only applies if "spill_enabled" flag is set.
-  static constexpr const char* kLocalMergeSpillEnabled =
-      "local_merge_spill_enabled";
+  VELOX_QUERY_CONFIG(
+      kLocalMergeSpillEnabled,
+      localMergeSpillEnabled,
+      "local_merge_spill_enabled",
+      bool,
+      false,
+      "Enable LocalMerge spilling. Requires spill_enabled.")
 
   /// Specify the max number of local sources to merge at a time.
+  /// Uses std::numeric_limits<uint32_t>::max() as default.
   static constexpr const char* kLocalMergeMaxNumMergeSources =
       "local_merge_max_num_merge_sources";
 
-  /// The max row numbers to fill and spill for each spill run. This is used to
-  /// cap the memory used for spilling. If it is zero, then there is no limit
-  /// and spilling might run out of memory.
-  /// Based on offline test results, the default value is set to 12 million rows
-  /// which uses ~128MB memory when to fill a spill run.
-  static constexpr const char* kMaxSpillRunRows = "max_spill_run_rows";
-
-  /// The max spill bytes limit set for each query. This is used to cap the
-  /// storage used for spilling. If it is zero, then there is no limit and
-  /// spilling might exhaust the storage or takes too long to run. The default
-  /// value is set to 100 GB.
-  static constexpr const char* kMaxSpillBytes = "max_spill_bytes";
+  /// The max row numbers to fill and spill for each spill run. Default is
+  /// 12 million rows which uses ~128MB memory.
+  VELOX_QUERY_CONFIG(
+      kMaxSpillRunRows,
+      maxSpillRunRows,
+      "max_spill_run_rows",
+      uint64_t,
+      12UL << 20,
+      "Maximum rows to fill and spill per spill run. 0 means no limit.")
+
+  /// The max spill bytes limit set for each query. Default is 100 GB.
+  VELOX_QUERY_CONFIG(
+      kMaxSpillBytes,
+      maxSpillBytes,
+      "max_spill_bytes",
+      uint64_t,
+      100UL << 30,
+      "Maximum total spill bytes per query. 0 means no limit.")
 
   /// The max allowed spilling level with zero being the initial spilling level.
-  /// This only applies for hash build spilling which might trigger recursive
-  /// spilling when the build table is too big. If it is set to -1, then there
-  /// is no limit and then some extreme large query might run out of spilling
-  /// partition bits (see kSpillPartitionBits) at the end. The max spill level
-  /// is used in production to prevent some bad user queries from using too much
-  /// io and cpu resources.
-  static constexpr const char* kMaxSpillLevel = "max_spill_level";
+  VELOX_QUERY_CONFIG(
+      kMaxSpillLevel,
+      maxSpillLevel,
+      "max_spill_level",
+      int32_t,
+      1,
+      "Maximum allowed spilling level. -1 means no limit.")
 
   /// The max allowed spill file size. If it is zero, then there is no limit.
-  static constexpr const char* kMaxSpillFileSize = "max_spill_file_size";
-
-  static constexpr const char* kSpillCompressionKind =
-      "spill_compression_codec";
-
-  /// Enable the prefix sort or fallback to timsort in spill. The prefix sort is
-  /// faster than std::sort but requires the memory to build normalized prefix
-  /// keys, which might have potential risk of running out of server memory.
-  static constexpr const char* kSpillPrefixSortEnabled =
-      "spill_prefixsort_enabled";
-
-  /// Specifies spill write buffer size in bytes. The spiller tries to buffer
-  /// serialized spill data up to the specified size before write to storage
-  /// underneath for io efficiency. If it is set to zero, then spill write
-  /// buffering is disabled.
-  static constexpr const char* kSpillWriteBufferSize =
-      "spill_write_buffer_size";
-
-  /// Specifies the buffer size in bytes to read from one spilled file. If the
-  /// underlying filesystem supports async read, we do read-ahead with double
-  /// buffering, which doubles the buffer used to read from each spill file.
-  static constexpr const char* kSpillReadBufferSize = "spill_read_buffer_size";
-
-  /// Config used to create spill files. This config is provided to underlying
-  /// file system and the config is free form. The form should be defined by the
-  /// underlying file system.
-  static constexpr const char* kSpillFileCreateConfig =
-      "spill_file_create_config";
-
-  /// Default offset spill start partition bit. It is used with
-  /// 'kSpillNumPartitionBits' together to
-  /// calculate the spilling partition number for join spill or aggregation
-  /// spill.
-  static constexpr const char* kSpillStartPartitionBit =
-      "spiller_start_partition_bit";
-
-  /// Default number of spill partition bits. It is the number of bits used to
-  /// calculate the spill partition number for hash join and RowNumber. The
-  /// number of spill partitions will be power of two.
-  ///
-  /// NOTE: as for now, we only support up to 8-way spill partitioning.
-  static constexpr const char* kSpillNumPartitionBits =
-      "spiller_num_partition_bits";
+  VELOX_QUERY_CONFIG(
+      kMaxSpillFileSize,
+      maxSpillFileSize,
+      "max_spill_file_size",
+      uint64_t,
+      0,
+      "Maximum spill file size. 0 means no limit.")
+
+  VELOX_QUERY_CONFIG(
+      kSpillCompressionKind,
+      spillCompressionKind,
+      "spill_compression_codec",
+      std::string,
+      "none",
+      "Compression codec for spill data.")
+
+  /// The max number of files to merge at a time when merging sorted spilled
+  /// files. 0 means unlimited.
+  VELOX_QUERY_CONFIG(
+      kSpillNumMaxMergeFiles,
+      spillNumMaxMergeFiles,
+      "spill_num_max_merge_files",
+      uint32_t,
+      0,
+      "Maximum files to merge at a time when merging sorted spill files. 0 means unlimited.")
+
+  /// Enable the prefix sort or fallback to timsort in spill.
+  VELOX_QUERY_CONFIG(
+      kSpillPrefixSortEnabled,
+      spillPrefixSortEnabled,
+      "spill_prefixsort_enabled",
+      bool,
+      false,
+      "Enable prefix sort in spill instead of timsort.")
+
+  /// Specifies spill write buffer size in bytes. 0 disables buffering.
+  VELOX_QUERY_CONFIG(
+      kSpillWriteBufferSize,
+      spillWriteBufferSize,
+      "spill_write_buffer_size",
+      uint64_t,
+      1L << 20,
+      "Spill write buffer size in bytes. 0 disables buffering.")
+
+  /// Specifies the buffer size in bytes to read from one spilled file.
+  VELOX_QUERY_CONFIG(
+      kSpillReadBufferSize,
+      spillReadBufferSize,
+      "spill_read_buffer_size",
+      uint64_t,
+      1L << 20,
+      "Buffer size in bytes to read from one spilled file.")
+
+  /// Config used to create spill files.
+  VELOX_QUERY_CONFIG(
+      kSpillFileCreateConfig,
+      spillFileCreateConfig,
+      "spill_file_create_config",
+      std::string,
+      "",
+      "Config for creating spill files, passed to underlying file system.")
+
+  /// Config used to create aggregation spill files.
+  VELOX_QUERY_CONFIG(
+      kAggregationSpillFileCreateConfig,
+      aggregationSpillFileCreateConfig,
+      "aggregation_spill_file_create_config",
+      std::string,
+      "",
+      "Config for creating aggregation spill files.")
+
+  /// Config used to create hash join spill files.
+  VELOX_QUERY_CONFIG(
+      kHashJoinSpillFileCreateConfig,
+      hashJoinSpillFileCreateConfig,
+      "hash_join_spill_file_create_config",
+      std::string,
+      "",
+      "Config for creating hash join spill files.")
+
+  /// Config used to create row number spill files.
+  VELOX_QUERY_CONFIG(
+      kRowNumberSpillFileCreateConfig,
+      rowNumberSpillFileCreateConfig,
+      "row_number_spill_file_create_config",
+      std::string,
+      "",
+      "Config for creating row number spill files.")
+
+  /// Default offset spill start partition bit.
+  VELOX_QUERY_CONFIG(
+      kSpillStartPartitionBit,
+      spillStartPartitionBit,
+      "spiller_start_partition_bit",
+      uint8_t,
+      48,
+      "Start partition bit offset for spilling.")
+
+  /// Default number of spill partition bits. Max 3 (8-way partitioning).
+  VELOX_QUERY_CONFIG_PROPERTY(
+      kSpillNumPartitionBits,
+      "spiller_num_partition_bits",
+      uint8_t,
+      3,
+      "Number of bits for spill partition calculation.")
 
   /// The minimal available spillable memory reservation in percentage of the
-  /// current memory usage. Suppose the current memory usage size of M,
-  /// available memory reservation size of N and min reservation percentage of
-  /// P, if M * P / 100 > N, then spiller operator needs to grow the memory
-  /// reservation with percentage of spillableReservationGrowthPct(). This
-  /// ensures we have sufficient amount of memory reservation to process the
-  /// large input outlier.
-  static constexpr const char* kMinSpillableReservationPct =
-      "min_spillable_reservation_pct";
-
-  /// The spillable memory reservation growth percentage of the previous memory
-  /// reservation size. 10 means exponential growth along a series of integer
-  /// powers of 11/10. The reservation grows by this much until it no longer
-  /// can, after which it starts spilling.
-  static constexpr const char* kSpillableReservationGrowthPct =
-      "spillable_reservation_growth_pct";
+  /// current memory usage.
+  VELOX_QUERY_CONFIG(
+      kMinSpillableReservationPct,
+      minSpillableReservationPct,
+      "min_spillable_reservation_pct",
+      int32_t,
+      5,
+      "Minimum available spillable memory reservation as percentage of usage.")
+
+  /// The spillable memory reservation growth percentage.
+  VELOX_QUERY_CONFIG(
+      kSpillableReservationGrowthPct,
+      spillableReservationGrowthPct,
+      "spillable_reservation_growth_pct",
+      int32_t,
+      10,
+      "Spillable memory reservation growth percentage.")
 
   /// Minimum memory footprint size required to reclaim memory from a file
   /// writer by flushing its buffered data to disk.
-  static constexpr const char* kWriterFlushThresholdBytes =
-      "writer_flush_threshold_bytes";
+  VELOX_QUERY_CONFIG(
+      kWriterFlushThresholdBytes,
+      writerFlushThresholdBytes,
+      "writer_flush_threshold_bytes",
+      uint64_t,
+      96L << 20,
+      "Minimum memory footprint to reclaim from a file writer by flushing.")
 
   /// If true, array_agg() aggregation function will ignore nulls in the input.
-  static constexpr const char* kPrestoArrayAggIgnoreNulls =
-      "presto.array_agg.ignore_nulls";
-
-  /// If true, Spark function's behavior is ANSI-compliant, e.g. throws runtime
-  /// exception instead of returning null on invalid inputs. It affects only
-  /// functions explicitly marked as "ANSI compliant".
-  /// Note: This feature is still under development to achieve full ANSI
-  /// compliance. Users can refer to the Spark function documentation to verify
-  /// the current support status of a specific function.
-  static constexpr const char* kSparkAnsiEnabled = "spark.ansi_enabled";
+  VELOX_QUERY_CONFIG(
+      kPrestoArrayAggIgnoreNulls,
+      prestoArrayAggIgnoreNulls,
+      "presto.array_agg.ignore_nulls",
+      bool,
+      false,
+      "If true, array_agg() ignores nulls in the input.")
+
+  /// If true, Spark function's behavior is ANSI-compliant.
+  VELOX_QUERY_CONFIG(
+      kSparkAnsiEnabled,
+      sparkAnsiEnabled,
+      "spark.ansi_enabled",
+      bool,
+      false,
+      "Enable ANSI-compliant behavior for Spark functions.")
 
   /// The default number of expected items for the bloomfilter.
-  static constexpr const char* kSparkBloomFilterExpectedNumItems =
-      "spark.bloom_filter.expected_num_items";
+  VELOX_QUERY_CONFIG(
+      kSparkBloomFilterExpectedNumItems,
+      sparkBloomFilterExpectedNumItems,
+      "spark.bloom_filter.expected_num_items",
+      int64_t,
+      1'000'000L,
+      "Default number of expected items for the Spark bloom filter.")
 
   /// The default number of bits to use for the bloom filter.
-  static constexpr const char* kSparkBloomFilterNumBits =
-      "spark.bloom_filter.num_bits";
+  VELOX_QUERY_CONFIG(
+      kSparkBloomFilterNumBits,
+      sparkBloomFilterNumBits,
+      "spark.bloom_filter.num_bits",
+      int64_t,
+      8'388'608L,
+      "Default number of bits for the Spark bloom filter.")
 
   /// The max number of bits to use for the bloom filter.
-  static constexpr const char* kSparkBloomFilterMaxNumBits =
-      "spark.bloom_filter.max_num_bits";
-
-  /// The current spark partition id.
+  VELOX_QUERY_CONFIG(
+      kSparkBloomFilterMaxNumBits,
+      sparkBloomFilterMaxNumBits,
+      "spark.bloom_filter.max_num_bits",
+      int64_t,
+      67'108'864,
+      "Maximum number of bits for the Spark bloom filter.")
+
+  /// The max number of items to use for the bloom filter.
+  VELOX_QUERY_CONFIG(
+      kSparkBloomFilterMaxNumItems,
+      sparkBloomFilterMaxNumItems,
+      "spark.bloom_filter.max_num_items",
+      int64_t,
+      4'000'000L,
+      "Maximum number of items for the Spark bloom filter.")
+
+  /// The current spark partition id. No default (throws if not set).
   static constexpr const char* kSparkPartitionId = "spark.partition_id";
 
   /// If true, simple date formatter is used for time formatting and parsing.
-  /// Joda date formatter is used by default.
-  static constexpr const char* kSparkLegacyDateFormatter =
-      "spark.legacy_date_formatter";
-
-  /// If true, Spark statistical aggregation functions including skewness,
-  /// kurtosis, stddev, stddev_samp, variance, var_samp, covar_samp and corr
-  /// will return NaN instead of NULL when dividing by zero during expression
-  /// evaluation.
-  static constexpr const char* kSparkLegacyStatisticalAggregate =
-      "spark.legacy_statistical_aggregate";
+  VELOX_QUERY_CONFIG(
+      kSparkLegacyDateFormatter,
+      sparkLegacyDateFormatter,
+      "spark.legacy_date_formatter",
+      bool,
+      false,
+      "Use simple date formatter instead of Joda for Spark.")
+
+  /// If true, Spark statistical aggregation functions return NaN instead of
+  /// NULL when dividing by zero.
+  VELOX_QUERY_CONFIG(
+      kSparkLegacyStatisticalAggregate,
+      sparkLegacyStatisticalAggregate,
+      "spark.legacy_statistical_aggregate",
+      bool,
+      false,
+      "Return NaN instead of NULL for Spark statistical aggregation on divide-by-zero.")
 
   /// If true, ignore null fields when generating JSON string.
-  /// If false, null fields are included with a null value.
-  static constexpr const char* kSparkJsonIgnoreNullFields =
-      "spark.json_ignore_null_fields";
+  VELOX_QUERY_CONFIG(
+      kSparkJsonIgnoreNullFields,
+      sparkJsonIgnoreNullFields,
+      "spark.json_ignore_null_fields",
+      bool,
+      true,
+      "Ignore null fields when generating JSON string in Spark.")
+
+  /// If true, collect_list aggregate function will ignore nulls in the input.
+  VELOX_QUERY_CONFIG(
+      kSparkCollectListIgnoreNulls,
+      sparkCollectListIgnoreNulls,
+      "spark.collect_list.ignore_nulls",
+      bool,
+      true,
+      "If true, Spark collect_list() ignores nulls in the input.")
 
   /// The number of local parallel table writer operators per task.
-  static constexpr const char* kTaskWriterCount = "task_writer_count";
+  VELOX_QUERY_CONFIG(
+      kTaskWriterCount,
+      taskWriterCount,
+      "task_writer_count",
+      uint32_t,
+      4,
+      "Number of local parallel table writer operators per task.")
 
   /// The number of local parallel table writer operators per task for
-  /// partitioned writes. If not set, use "task_writer_count".
+  /// partitioned writes. If not set, use "task_writer_count". No default.
   static constexpr const char* kTaskPartitionedWriterCount =
       "task_partitioned_writer_count";
 
   /// If true, finish the hash probe on an empty build table for a specific set
   /// of hash joins.
-  static constexpr const char* kHashProbeFinishEarlyOnEmptyBuild =
-      "hash_probe_finish_early_on_empty_build";
+  VELOX_QUERY_CONFIG(
+      kHashProbeFinishEarlyOnEmptyBuild,
+      hashProbeFinishEarlyOnEmptyBuild,
+      "hash_probe_finish_early_on_empty_build",
+      bool,
+      false,
+      "Finish hash probe early on empty build table.")
+
+  /// Whether hash probe can generate any dynamic filter and push down to
+  /// upstream operators.
+  VELOX_QUERY_CONFIG(
+      kHashProbeDynamicFilterPushdownEnabled,
+      hashProbeDynamicFilterPushdownEnabled,
+      "hash_probe_dynamic_filter_pushdown_enabled",
+      bool,
+      true,
+      "Enable dynamic filter generation and pushdown from hash probe.")
+
+  /// Whether hash probe can generate dynamic filter for string types.
+  VELOX_QUERY_CONFIG(
+      kHashProbeStringDynamicFilterPushdownEnabled,
+      hashProbeStringDynamicFilterPushdownEnabled,
+      "hash_probe_string_dynamic_filter_pushdown_enabled",
+      bool,
+      false,
+      "Enable dynamic filter pushdown for string types from hash probe.")
+
+  /// The maximum byte size of Bloom filter from hash probe. 0 = disabled.
+  VELOX_QUERY_CONFIG(
+      kHashProbeBloomFilterPushdownMaxSize,
+      hashProbeBloomFilterPushdownMaxSize,
+      "hash_probe_bloom_filter_pushdown_max_size",
+      uint64_t,
+      0,
+      "Maximum byte size of Bloom filter from hash probe. 0 disables.")
 
   /// The minimum number of table rows that can trigger the parallel hash join
   /// table build.
-  static constexpr const char* kMinTableRowsForParallelJoinBuild =
-      "min_table_rows_for_parallel_join_build";
-
-  /// If set to true, then during execution of tasks, the output vectors of
-  /// every operator are validated for consistency. This is an expensive check
-  /// so should only be used for debugging. It can help debug issues where
-  /// malformed vector cause failures or crashes by helping identify which
-  /// operator is generating them.
-  static constexpr const char* kValidateOutputFromOperators =
-      "debug.validate_output_from_operators";
-
-  /// If true, enable caches in expression evaluation for performance, including
-  /// ExecCtx::vectorPool_, ExecCtx::decodedVectorPool_,
-  /// ExecCtx::selectivityVectorPool_, Expr::baseDictionary_,
-  /// Expr::dictionaryCache_, and Expr::cachedDictionaryIndices_. Otherwise,
-  /// disable the caches.
-  static constexpr const char* kEnableExpressionEvaluationCache =
-      "enable_expression_evaluation_cache";
+  VELOX_QUERY_CONFIG(
+      kMinTableRowsForParallelJoinBuild,
+      minTableRowsForParallelJoinBuild,
+      "min_table_rows_for_parallel_join_build",
+      uint32_t,
+      1'000,
+      "Minimum table rows to trigger parallel hash join table build.")
+
+  /// If set to true, validate output vectors of every operator for consistency.
+  VELOX_QUERY_CONFIG(
+      kValidateOutputFromOperators,
+      validateOutputFromOperators,
+      "debug.validate_output_from_operators",
+      bool,
+      false,
+      "Validate output vectors from every operator for consistency.")
+
+  /// If true, enable caches in expression evaluation for performance.
+  VELOX_QUERY_CONFIG(
+      kEnableExpressionEvaluationCache,
+      isExpressionEvaluationCacheEnabled,
+      "enable_expression_evaluation_cache",
+      bool,
+      true,
+      "Enable caches in expression evaluation for performance.")
 
   /// For a given shared subexpression, the maximum distinct sets of inputs we
-  /// cache results for. Lambdas can call the same expression with different
-  /// inputs many times, causing the results we cache to explode in size.
-  /// Putting a limit contains the memory usage.
-  static constexpr const char* kMaxSharedSubexprResultsCached =
-      "max_shared_subexpr_results_cached";
+  /// cache results for.
+  VELOX_QUERY_CONFIG(
+      kMaxSharedSubexprResultsCached,
+      maxSharedSubexprResultsCached,
+      "max_shared_subexpr_results_cached",
+      uint32_t,
+      10,
+      "Maximum distinct input sets to cache for shared subexpressions.")
 
   /// Maximum number of splits to preload. Set to 0 to disable preloading.
-  static constexpr const char* kMaxSplitPreloadPerDriver =
-      "max_split_preload_per_driver";
+  VELOX_QUERY_CONFIG(
+      kMaxSplitPreloadPerDriver,
+      maxSplitPreloadPerDriver,
+      "max_split_preload_per_driver",
+      int32_t,
+      2,
+      "Maximum number of splits to preload. 0 disables preloading.")
 
   /// If not zero, specifies the cpu time slice limit in ms that a driver thread
-  /// can continuously run without yielding. If it is zero, then there is no
-  /// limit.
-  static constexpr const char* kDriverCpuTimeSliceLimitMs =
-      "driver_cpu_time_slice_limit_ms";
-
-  /// Maximum number of bytes to use for the normalized key in prefix-sort. Use
-  /// 0 to disable prefix-sort.
-  static constexpr const char* kPrefixSortNormalizedKeyMaxBytes =
-      "prefixsort_normalized_key_max_bytes";
-
-  /// Minimum number of rows to use prefix-sort. The default value has been
-  /// derived using micro-benchmarking.
-  static constexpr const char* kPrefixSortMinRows = "prefixsort_min_rows";
+  /// can continuously run without yielding.
+  VELOX_QUERY_CONFIG(
+      kDriverCpuTimeSliceLimitMs,
+      driverCpuTimeSliceLimitMs,
+      "driver_cpu_time_slice_limit_ms",
+      uint32_t,
+      0,
+      "CPU time slice limit in ms before yielding. 0 means no limit.")
+
+  /// Window operator sub-partition count per thread.
+  VELOX_QUERY_CONFIG(
+      kWindowNumSubPartitions,
+      windowNumSubPartitions,
+      "window_num_sub_partitions",
+      uint32_t,
+      1,
+      "Number of sub-partitions per thread in Window operator.")
+
+  /// Maximum number of bytes to use for the normalized key in prefix-sort.
+  VELOX_QUERY_CONFIG(
+      kPrefixSortNormalizedKeyMaxBytes,
+      prefixSortNormalizedKeyMaxBytes,
+      "prefixsort_normalized_key_max_bytes",
+      uint32_t,
+      128,
+      "Maximum bytes for normalized key in prefix-sort. 0 disables.")
+
+  /// Minimum number of rows to use prefix-sort.
+  VELOX_QUERY_CONFIG(
+      kPrefixSortMinRows,
+      prefixSortMinRows,
+      "prefixsort_min_rows",
+      uint32_t,
+      128,
+      "Minimum rows to use prefix-sort.")
 
   /// Maximum number of bytes to be stored in prefix-sort buffer for a string
   /// key.
-  static constexpr const char* kPrefixSortMaxStringPrefixLength =
-      "prefixsort_max_string_prefix_length";
+  VELOX_QUERY_CONFIG(
+      kPrefixSortMaxStringPrefixLength,
+      prefixSortMaxStringPrefixLength,
+      "prefixsort_max_string_prefix_length",
+      uint32_t,
+      16,
+      "Maximum bytes stored in prefix-sort buffer for a string key.")
 
   /// Enable query tracing flag.
-  static constexpr const char* kQueryTraceEnabled = "query_trace_enabled";
+  VELOX_QUERY_CONFIG(
+      kQueryTraceEnabled,
+      queryTraceEnabled,
+      "query_trace_enabled",
+      bool,
+      false,
+      "Enable query tracing.")
 
   /// Base dir of a query to store tracing data.
-  static constexpr const char* kQueryTraceDir = "query_trace_dir";
+  VELOX_QUERY_CONFIG(
+      kQueryTraceDir,
+      queryTraceDir,
+      "query_trace_dir",
+      std::string,
+      "",
+      "Base directory for storing query trace data.")
 
   /// The plan node id whose input data will be traced.
-  /// Empty string if only want to trace the query metadata.
-  static constexpr const char* kQueryTraceNodeId = "query_trace_node_id";
+  VELOX_QUERY_CONFIG(
+      kQueryTraceNodeId,
+      queryTraceNodeId,
+      "query_trace_node_id",
+      std::string,
+      "",
+      "Plan node id whose input data will be traced.")
 
   /// The max trace bytes limit. Tracing is disabled if zero.
-  static constexpr const char* kQueryTraceMaxBytes = "query_trace_max_bytes";
-
-  /// The regexp of traced task id. We only enable trace on a task if its id
-  /// matches.
-  static constexpr const char* kQueryTraceTaskRegExp =
-      "query_trace_task_reg_exp";
-
-  /// If true, we only collect the input trace for a given operator but without
-  /// the actual execution.
-  static constexpr const char* kQueryTraceDryRun = "query_trace_dry_run";
-
-  /// Config used to create operator trace directory. This config is provided to
-  /// underlying file system and the config is free form. The form should be
-  /// defined by the underlying file system.
-  static constexpr const char* kOpTraceDirectoryCreateConfig =
-      "op_trace_directory_create_config";
+  VELOX_QUERY_CONFIG(
+      kQueryTraceMaxBytes,
+      queryTraceMaxBytes,
+      "query_trace_max_bytes",
+      uint64_t,
+      0,
+      "Maximum trace bytes. Tracing disabled if zero.")
+
+  /// The regexp of traced task id.
+  VELOX_QUERY_CONFIG(
+      kQueryTraceTaskRegExp,
+      queryTraceTaskRegExp,
+      "query_trace_task_reg_exp",
+      std::string,
+      "",
+      "Regexp for task ids to enable tracing on.")
+
+  /// If true, only collect input trace without actual execution.
+  VELOX_QUERY_CONFIG(
+      kQueryTraceDryRun,
+      queryTraceDryRun,
+      "query_trace_dry_run",
+      bool,
+      false,
+      "Collect input trace without actual execution.")
+
+  /// Config used to create operator trace directory.
+  VELOX_QUERY_CONFIG(
+      kOpTraceDirectoryCreateConfig,
+      opTraceDirectoryCreateConfig,
+      "op_trace_directory_create_config",
+      std::string,
+      "",
+      "Config for creating operator trace directory.")
 
   /// Disable optimization in expression evaluation to peel common dictionary
   /// layer from inputs.
-  static constexpr const char* kDebugDisableExpressionWithPeeling =
-      "debug_disable_expression_with_peeling";
+  VELOX_QUERY_CONFIG(
+      kDebugDisableExpressionWithPeeling,
+      debugDisableExpressionsWithPeeling,
+      "debug_disable_expression_with_peeling",
+      bool,
+      false,
+      "Disable dictionary peeling optimization in expression evaluation.")
+
+  /// Minimum number of rows in the selectivity vector for peeling to be
+  /// applied during expression evaluation. For small batches, the overhead of
+  /// peeling can outweigh the benefits.
+  VELOX_QUERY_CONFIG(
+      kMinRowsForPeeling,
+      minRowsForPeeling,
+      "expression.min_rows_for_peeling",
+      int32_t,
+      0,
+      "Minimum number of rows to process for peeling optimization in expression evaluation to be active.");
 
   /// Disable optimization in expression evaluation to re-use cached results for
   /// common sub-expressions.
-  static constexpr const char* kDebugDisableCommonSubExpressions =
-      "debug_disable_common_sub_expressions";
+  VELOX_QUERY_CONFIG(
+      kDebugDisableCommonSubExpressions,
+      debugDisableCommonSubExpressions,
+      "debug_disable_common_sub_expressions",
+      bool,
+      false,
+      "Disable common sub-expression caching in expression evaluation.")
 
   /// Disable optimization in expression evaluation to re-use cached results
-  /// between subsequent input batches that are dictionary encoded and have the
-  /// same alphabet(underlying flat vector).
-  static constexpr const char* kDebugDisableExpressionWithMemoization =
-      "debug_disable_expression_with_memoization";
+  /// between subsequent dictionary-encoded input batches.
+  VELOX_QUERY_CONFIG(
+      kDebugDisableExpressionWithMemoization,
+      debugDisableExpressionsWithMemoization,
+      "debug_disable_expression_with_memoization",
+      bool,
+      false,
+      "Disable dictionary memoization in expression evaluation.")
 
   /// Disable optimization in expression evaluation to delay loading of lazy
   /// inputs unless required.
-  static constexpr const char* kDebugDisableExpressionWithLazyInputs =
-      "debug_disable_expression_with_lazy_inputs";
-
-  /// Fix the random seed used to create data structure used in
-  /// approx_percentile.  This makes the query result deterministic on single
-  /// node; multi-node partial aggregation is still subject to non-determinism
-  /// due to non-deterministic merge order.
+  VELOX_QUERY_CONFIG(
+      kDebugDisableExpressionWithLazyInputs,
+      debugDisableExpressionsWithLazyInputs,
+      "debug_disable_expression_with_lazy_inputs",
+      bool,
+      false,
+      "Disable lazy input loading optimization in expression evaluation.")
+
+  /// Fix the random seed used in approx_percentile. No default (optional).
   static constexpr const char*
       kDebugAggregationApproxPercentileFixedRandomSeed =
           "debug_aggregation_approx_percentile_fixed_random_seed";
 
-  /// When debug is enabled for memory manager, this is used to match the memory
-  /// pools that need allocation callsites tracking. Default to track nothing.
-  static constexpr const char* kDebugMemoryPoolNameRegex =
-      "debug_memory_pool_name_regex";
-
-  /// Warning threshold in bytes for debug memory pools. When set to a
-  /// non-zero value, a warning will be logged once per memory pool when
-  /// allocations cause the pool to exceed this threshold. This is useful for
-  /// identifying memory usage patterns during debugging. Requires allocation
-  /// tracking to be enabled via `debug_memory_pool_name_regex` for the pool. A
-  /// value of 0 means no warning threshold is enforced.
-  static constexpr const char* kDebugMemoryPoolWarnThresholdBytes =
-      "debug_memory_pool_warn_threshold_bytes";
-
-  /// Some lambda functions over arrays and maps are evaluated in batches of the
-  /// underlying elements that comprise the arrays/maps. This is done to make
-  /// the batch size manageable as array vectors can have thousands of elements
-  /// each and hit scaling limits as implementations typically expect
-  /// BaseVectors to a couple of thousand entries. This lets up tune those batch
-  /// sizes.
-  static constexpr const char* kDebugLambdaFunctionEvaluationBatchSize =
-      "debug_lambda_function_evaluation_batch_size";
-
-  /// The UDF `bing_tile_children` generates the children of a Bing tile based
-  /// on a specified target zoom level. The number of children produced is
-  /// determined by the difference between the target zoom level and the zoom
-  /// level of the input tile. This configuration limits the number of children
-  /// by capping the maximum zoom level difference, with a default value set
-  /// to 5. This cap is necessary to prevent excessively large array outputs,
-  /// which can exceed the size limits of the elements vector in the Velox array
-  /// vector.
-  static constexpr const char* kDebugBingTileChildrenMaxZoomShift =
-      "debug_bing_tile_children_max_zoom_shift";
-
-  /// Temporary flag to control whether selective Nimble reader should be used
-  /// in this query or not.  Will be removed after the selective Nimble reader
-  /// is fully rolled out.
-  static constexpr const char* kSelectiveNimbleReaderEnabled =
-      "selective_nimble_reader_enabled";
-
-  /// The max ratio of a query used memory to its max capacity, and the scale
-  /// writer exchange stops scaling writer processing if the query's current
-  /// memory usage exceeds this ratio. The value is in the range of (0, 1].
-  static constexpr const char* kScaleWriterRebalanceMaxMemoryUsageRatio =
-      "scaled_writer_rebalance_max_memory_usage_ratio";
-
-  /// The max number of logical table partitions that can be assigned to a
-  /// single table writer thread. The logical table partition is used by local
-  /// exchange writer for writer scaling, and multiple physical table
-  /// partitions can be mapped to the same logical table partition based on the
-  /// hash value of calculated partitioned ids.
-  static constexpr const char* kScaleWriterMaxPartitionsPerWriter =
-      "scaled_writer_max_partitions_per_writer";
-
-  /// Minimum amount of data processed by a logical table partition to trigger
-  /// writer scaling if it is detected as overloaded by scale wrirer exchange.
-  static constexpr const char*
-      kScaleWriterMinPartitionProcessedBytesRebalanceThreshold =
-          "scaled_writer_min_partition_processed_bytes_rebalance_threshold";
-
-  /// Minimum amount of data processed by all the logical table partitions to
-  /// trigger skewed partition rebalancing by scale writer exchange.
-  static constexpr const char* kScaleWriterMinProcessedBytesRebalanceThreshold =
-      "scaled_writer_min_processed_bytes_rebalance_threshold";
-
-  /// If true, enables the scaled table scan processing. For each table scan
-  /// plan node, a scan controller is used to control the number of running scan
-  /// threads based on the query memory usage. It keeps increasing the number of
-  /// running threads until the query memory usage exceeds the threshold defined
-  /// by 'table_scan_scale_up_memory_usage_ratio'.
-  static constexpr const char* kTableScanScaledProcessingEnabled =
-      "table_scan_scaled_processing_enabled";
-
-  /// The query memory usage ratio used by scan controller to decide if it can
-  /// increase the number of running scan threads. When the query memory usage
-  /// is below this ratio, the scan controller keeps increasing the running scan
-  /// thread for scale up, and stop once exceeds this ratio. The value is in the
-  /// range of [0, 1].
-  ///
-  /// NOTE: this only applies if 'table_scan_scaled_processing_enabled' is true.
-  static constexpr const char* kTableScanScaleUpMemoryUsageRatio =
-      "table_scan_scale_up_memory_usage_ratio";
-
-  /// Specifies the shuffle compression kind which is defined by
-  /// CompressionKind. If it is CompressionKind_NONE, then no compression.
-  static constexpr const char* kShuffleCompressionKind =
-      "shuffle_compression_codec";
-
-  /// If a key is found in multiple given maps, by default that key's value in
-  /// the resulting map comes from the last one of those maps. When true, throw
-  /// exception on duplicate map key.
-  static constexpr const char* kThrowExceptionOnDuplicateMapKeys =
-      "throw_exception_on_duplicate_map_keys";
-
-  /// Specifies the max number of input batches to prefetch to do index lookup
-  /// ahead. If it is zero, then process one input batch at a time.
-  static constexpr const char* kIndexLookupJoinMaxPrefetchBatches =
-      "index_lookup_join_max_prefetch_batches";
-
-  /// If this is true, then the index join operator might split output for each
-  /// input batch based on the output batch size control. Otherwise, it tries to
-  /// produce a single output for each input batch.
-  static constexpr const char* kIndexLookupJoinSplitOutput =
-      "index_lookup_join_split_output";
+  /// Regex to match memory pools for allocation callsite tracking.
+  VELOX_QUERY_CONFIG(
+      kDebugMemoryPoolNameRegex,
+      debugMemoryPoolNameRegex,
+      "debug_memory_pool_name_regex",
+      std::string,
+      "",
+      "Regex to match memory pools for allocation callsite tracking.")
+
+  /// Warning threshold in bytes for debug memory pools. Uses toCapacity
+  /// for parsing.
+  VELOX_QUERY_CONFIG_PROPERTY(
+      kDebugMemoryPoolWarnThresholdBytes,
+      "debug_memory_pool_warn_threshold_bytes",
+      std::string,
+      "0B",
+      "Warning threshold in bytes for debug memory pools.")
+
+  /// Batch size for lambda function evaluation over arrays and maps.
+  VELOX_QUERY_CONFIG(
+      kDebugLambdaFunctionEvaluationBatchSize,
+      debugLambdaFunctionEvaluationBatchSize,
+      "debug_lambda_function_evaluation_batch_size",
+      int32_t,
+      10'000,
+      "Batch size for lambda function evaluation over arrays and maps.")
+
+  /// Max zoom level difference for bing_tile_children UDF.
+  VELOX_QUERY_CONFIG(
+      kDebugBingTileChildrenMaxZoomShift,
+      debugBingTileChildrenMaxZoomShift,
+      "debug_bing_tile_children_max_zoom_shift",
+      uint8_t,
+      7,
+      "Maximum zoom level difference for bing_tile_children.")
+
+  /// Deprecated: Use FileConfig::kSelectiveNimbleReaderEnabledSession instead.
+  /// Kept for backward compatibility with Presto session properties.
+  VELOX_QUERY_CONFIG(
+      kSelectiveNimbleReaderEnabled,
+      selectiveNimbleReaderEnabled,
+      "selective_nimble_reader_enabled",
+      bool,
+      true,
+      "Enable selective Nimble reader.")
+
+  /// The max ratio of query memory usage to max capacity for scale writer
+  /// exchange to stop scaling.
+  VELOX_QUERY_CONFIG(
+      kScaleWriterRebalanceMaxMemoryUsageRatio,
+      scaleWriterRebalanceMaxMemoryUsageRatio,
+      "scaled_writer_rebalance_max_memory_usage_ratio",
+      double,
+      0.7,
+      "Max memory usage ratio before scale writer exchange stops scaling.")
+
+  /// The max number of logical table partitions per writer thread.
+  VELOX_QUERY_CONFIG(
+      kScaleWriterMaxPartitionsPerWriter,
+      scaleWriterMaxPartitionsPerWriter,
+      "scaled_writer_max_partitions_per_writer",
+      uint32_t,
+      128,
+      "Max logical table partitions per table writer thread.")
+
+  /// Minimum data processed per partition to trigger writer scaling.
+  VELOX_QUERY_CONFIG(
+      kScaleWriterMinPartitionProcessedBytesRebalanceThreshold,
+      scaleWriterMinPartitionProcessedBytesRebalanceThreshold,
+      "scaled_writer_min_partition_processed_bytes_rebalance_threshold",
+      uint64_t,
+      128 << 20,
+      "Minimum bytes processed per partition to trigger writer scaling.")
+
+  /// Minimum total data processed to trigger skewed partition rebalancing.
+  VELOX_QUERY_CONFIG(
+      kScaleWriterMinProcessedBytesRebalanceThreshold,
+      scaleWriterMinProcessedBytesRebalanceThreshold,
+      "scaled_writer_min_processed_bytes_rebalance_threshold",
+      uint64_t,
+      256 << 20,
+      "Minimum total bytes processed to trigger skewed partition rebalancing.")
+
+  /// If true, enables the scaled table scan processing.
+  VELOX_QUERY_CONFIG(
+      kTableScanScaledProcessingEnabled,
+      tableScanScaledProcessingEnabled,
+      "table_scan_scaled_processing_enabled",
+      bool,
+      false,
+      "Enable scaled table scan processing based on memory usage.")
+
+  /// The query memory usage ratio for scan controller to decide if it can
+  /// increase running scan threads.
+  VELOX_QUERY_CONFIG(
+      kTableScanScaleUpMemoryUsageRatio,
+      tableScanScaleUpMemoryUsageRatio,
+      "table_scan_scale_up_memory_usage_ratio",
+      double,
+      0.7,
+      "Memory usage ratio threshold for scaling up scan threads.")
+
+  /// Specifies the shuffle compression kind.
+  VELOX_QUERY_CONFIG(
+      kShuffleCompressionKind,
+      shuffleCompressionKind,
+      "shuffle_compression_codec",
+      std::string,
+      "none",
+      "Compression codec for shuffle data.")
+
+  /// Minimum serialized page size in bytes to attempt shuffle compression.
+  VELOX_QUERY_CONFIG(
+      kMinShuffleCompressionPageSizeBytes,
+      minShuffleCompressionPageSizeBytes,
+      "min_shuffle_compression_page_size_bytes",
+      int32_t,
+      0,
+      "Minimum serialized page size in bytes to attempt shuffle compression.")
+
+  /// When true, throw exception on duplicate map key.
+  VELOX_QUERY_CONFIG(
+      kThrowExceptionOnDuplicateMapKeys,
+      throwExceptionOnDuplicateMapKeys,
+      "throw_exception_on_duplicate_map_keys",
+      bool,
+      false,
+      "Throw exception on duplicate map keys.")
+
+  /// Max number of input batches to prefetch for index lookup. 0 = disabled.
+  VELOX_QUERY_CONFIG(
+      kIndexLookupJoinMaxPrefetchBatches,
+      indexLookupJoinMaxPrefetchBatches,
+      "index_lookup_join_max_prefetch_batches",
+      uint32_t,
+      0,
+      "Maximum input batches to prefetch for index lookup. 0 disables.")
+
+  /// If true, index join operator may split output per input batch.
+  VELOX_QUERY_CONFIG(
+      kIndexLookupJoinSplitOutput,
+      indexLookupJoinSplitOutput,
+      "index_lookup_join_split_output",
+      bool,
+      true,
+      "Allow index join operator to split output based on batch size.")
 
   // Max wait time for exchange request in seconds.
-  static constexpr const char* kRequestDataSizesMaxWaitSec =
-      "request_data_sizes_max_wait_sec";
-
-  /// In streaming aggregation, wait until we have enough number of output rows
-  /// to produce a batch of size specified by this. If set to 0, then
-  /// Operator::outputBatchRows will be used as the min output batch rows.
-  static constexpr const char* kStreamingAggregationMinOutputBatchRows =
-      "streaming_aggregation_min_output_batch_rows";
+  VELOX_QUERY_CONFIG(
+      kRequestDataSizesMaxWaitSec,
+      requestDataSizesMaxWaitSec,
+      "request_data_sizes_max_wait_sec",
+      int32_t,
+      10,
+      "Maximum wait time for exchange request in seconds.")
+
+  /// In streaming aggregation, min output rows before producing a batch.
+  VELOX_QUERY_CONFIG(
+      kStreamingAggregationMinOutputBatchRows,
+      streamingAggregationMinOutputBatchRows,
+      "streaming_aggregation_min_output_batch_rows",
+      int32_t,
+      0,
+      "Minimum rows to accumulate before producing streaming aggregation output. 0 uses default.")
 
   /// TODO: Remove after dependencies are cleaned up.
-  static constexpr const char* kStreamingAggregationEagerFlush =
-      "streaming_aggregation_eager_flush";
-
-  /// If this is true, then it allows you to get the struct field names
-  /// as json element names when casting a row to json.
-  static constexpr const char* kFieldNamesInJsonCastEnabled =
-      "field_names_in_json_cast_enabled";
-
-  /// If this is true, then operators that evaluate expressions will track
-  /// stats for expressions that are not special forms and return them as
-  /// part of their operator stats. Tracking these stats can be expensive
-  /// (especially if operator stats are retrieved frequently) and this allows
-  /// the user to explicitly enable it.
-  static constexpr const char* kOperatorTrackExpressionStats =
-      "operator_track_expression_stats";
-
-  /// If this is true, enable the operator input/output batch size stats
-  /// collection in driver execution. This can be expensive for data types with
-  /// a large number of columns (e.g., ROW types) as it calls estimateFlatSize()
-  /// which recursively calculates sizes for all child vectors.
-  static constexpr const char* kEnableOperatorBatchSizeStats =
-      "enable_operator_batch_size_stats";
-
-  /// If this is true, then the unnest operator might split output for each
-  /// input batch based on the output batch size control. Otherwise, it produces
-  /// a single output for each input batch.
-  static constexpr const char* kUnnestSplitOutput = "unnest_split_output";
-
-  /// Priority of the query in the memory pool reclaimer. Lower value means
-  /// higher priority. This is used in global arbitration victim selection.
-  static constexpr const char* kQueryMemoryReclaimerPriority =
-      "query_memory_reclaimer_priority";
-
-  /// The max number of input splits to listen to by SplitListener per table
-  /// scan node per worker. It's up to the SplitListener implementation to
-  /// respect this config.
-  static constexpr const char* kMaxNumSplitsListenedTo =
-      "max_num_splits_listened_to";
-
-  /// Source of the query. Used by Presto to identify the file system username.
-  static constexpr const char* kSource = "source";
-
-  /// Client tags of the query. Used by Presto to identify the file system
-  /// username.
-  static constexpr const char* kClientTags = "client_tags";
-
-  bool selectiveNimbleReaderEnabled() const {
-    return get<bool>(kSelectiveNimbleReaderEnabled, false);
-  }
-
-  bool debugDisableExpressionsWithPeeling() const {
-    return get<bool>(kDebugDisableExpressionWithPeeling, false);
-  }
-
-  bool debugDisableCommonSubExpressions() const {
-    return get<bool>(kDebugDisableCommonSubExpressions, false);
-  }
-
-  bool debugDisableExpressionsWithMemoization() const {
-    return get<bool>(kDebugDisableExpressionWithMemoization, false);
-  }
-
-  bool debugDisableExpressionsWithLazyInputs() const {
-    return get<bool>(kDebugDisableExpressionWithLazyInputs, false);
-  }
-
-  std::string debugMemoryPoolNameRegex() const {
-    return get<std::string>(kDebugMemoryPoolNameRegex, "");
-  }
-
-  uint64_t debugMemoryPoolWarnThresholdBytes() const {
-    return config::toCapacity(
-        get<std::string>(kDebugMemoryPoolWarnThresholdBytes, "0B"),
-        config::CapacityUnit::BYTE);
-  }
-
-  std::optional<uint32_t> debugAggregationApproxPercentileFixedRandomSeed()
-      const {
-    return get<uint32_t>(kDebugAggregationApproxPercentileFixedRandomSeed);
-  }
-
-  int32_t debugLambdaFunctionEvaluationBatchSize() const {
-    return get<int32_t>(kDebugLambdaFunctionEvaluationBatchSize, 10'000);
-  }
-
-  uint8_t debugBingTileChildrenMaxZoomShift() const {
-    return get<uint8_t>(kDebugBingTileChildrenMaxZoomShift, 5);
-  }
+  VELOX_QUERY_CONFIG(
+      kStreamingAggregationEagerFlush,
+      streamingAggregationEagerFlush,
+      "streaming_aggregation_eager_flush",
+      bool,
+      false,
+      "Enable eager flush for streaming aggregation.")
+
+  // If true, skip request data size if there is only single source.
+  VELOX_QUERY_CONFIG(
+      kSkipRequestDataSizeWithSingleSourceEnabled,
+      singleSourceExchangeOptimizationEnabled,
+      "skip_request_data_size_with_single_source_enabled",
+      bool,
+      false,
+      "Skip request data size check with single exchange source.")
+
+  /// If true, exchange clients defer data fetching until next() is called.
+  VELOX_QUERY_CONFIG(
+      kExchangeLazyFetchingEnabled,
+      exchangeLazyFetchingEnabled,
+      "exchange_lazy_fetching_enabled",
+      bool,
+      false,
+      "Defer exchange data fetching until next() is called.")
+
+  /// If true, use struct field names as JSON element names when casting row to
+  /// json.
+  VELOX_QUERY_CONFIG(
+      kFieldNamesInJsonCastEnabled,
+      isFieldNamesInJsonCastEnabled,
+      "field_names_in_json_cast_enabled",
+      bool,
+      false,
+      "Use struct field names as JSON element names in CAST to JSON.")
+
+  /// If true, operators track stats for non-special-form expressions.
+  VELOX_QUERY_CONFIG(
+      kOperatorTrackExpressionStats,
+      operatorTrackExpressionStats,
+      "operator_track_expression_stats",
+      bool,
+      false,
+      "Track expression stats in operators that evaluate expressions.")
+
+  /// If true, enable operator input/output batch size stats collection.
+  VELOX_QUERY_CONFIG(
+      kEnableOperatorBatchSizeStats,
+      enableOperatorBatchSizeStats,
+      "enable_operator_batch_size_stats",
+      bool,
+      true,
+      "Enable input/output batch size stats collection in driver execution.")
+
+  /// If true, the unnest operator may split output per input batch.
+  VELOX_QUERY_CONFIG(
+      kUnnestSplitOutput,
+      unnestSplitOutput,
+      "unnest_split_output",
+      bool,
+      true,
+      "Allow unnest operator to split output based on batch size.")
+
+  /// Priority of the query in the memory pool reclaimer. Lower means higher
+  /// priority.
+  VELOX_QUERY_CONFIG(
+      kQueryMemoryReclaimerPriority,
+      queryMemoryReclaimerPriority,
+      "query_memory_reclaimer_priority",
+      int32_t,
+      std::numeric_limits<int32_t>::max(),
+      "Query priority in memory pool reclaimer. Lower means higher priority.")
+
+  /// The max number of input splits to listen to by SplitListener.
+  VELOX_QUERY_CONFIG(
+      kMaxNumSplitsListenedTo,
+      maxNumSplitsListenedTo,
+      "max_num_splits_listened_to",
+      int32_t,
+      0,
+      "Max input splits to listen to by SplitListener per scan node per worker.")
+
+  /// Source of the query.
+  VELOX_QUERY_CONFIG(
+      kSource,
+      source,
+      "source",
+      std::string,
+      "",
+      "Source of the query.")
+
+  /// Client tags of the query.
+  VELOX_QUERY_CONFIG(
+      kClientTags,
+      clientTags,
+      "client_tags",
+      std::string,
+      "",
+      "Client tags of the query.")
+
+  /// Enable (reader) row size tracker. Uses enum stored as int32_t.
+  VELOX_QUERY_CONFIG_PROPERTY(
+      kRowSizeTrackingMode,
+      "row_size_tracking_mode",
+      int32_t,
+      2,
+      "Row size tracking mode: 0=disabled, 1=exclude delta splits, 2=enabled for all.")
+
+  /// Maximum number of distinct values to keep when merging vector hashers in
+  /// join HashBuild.
+  VELOX_QUERY_CONFIG(
+      kJoinBuildVectorHasherMaxNumDistinct,
+      joinBuildVectorHasherMaxNumDistinct,
+      "join_build_vector_hasher_max_num_distinct",
+      uint32_t,
+      1'000'000,
+      "Max distinct values to keep when merging vector hashers in join HashBuild.")
+
+  /// Batch size threshold for zero-copy optimization in MarkSorted operator.
+  VELOX_QUERY_CONFIG(
+      kMarkSortedZeroCopyThreshold,
+      markSortedZeroCopyThreshold,
+      "mark_sorted_zero_copy_threshold",
+      int32_t,
+      1000,
+      "Batch size threshold for zero-copy in MarkSorted operator.")
+
+  // --- Hand-written accessors for properties that need custom logic ---
+
+  // Generated by VELOX_QUERY_CONFIG for simple properties above.
 
   uint64_t queryMaxMemoryPerNode() const {
     return config::toCapacity(
@@ -742,112 +1500,6 @@ class QueryConfig {
         config::CapacityUnit::BYTE);
   }
 
-  uint64_t maxPartialAggregationMemoryUsage() const {
-    static constexpr uint64_t kDefault = 1L << 24;
-    return get<uint64_t>(kMaxPartialAggregationMemory, kDefault);
-  }
-
-  uint64_t maxExtendedPartialAggregationMemoryUsage() const {
-    static constexpr uint64_t kDefault = 1L << 26;
-    return get<uint64_t>(kMaxExtendedPartialAggregationMemory, kDefault);
-  }
-
-  int32_t abandonPartialAggregationMinRows() const {
-    return get<int32_t>(kAbandonPartialAggregationMinRows, 100'000);
-  }
-
-  int32_t abandonPartialAggregationMinPct() const {
-    return get<int32_t>(kAbandonPartialAggregationMinPct, 80);
-  }
-
-  int32_t abandonPartialTopNRowNumberMinRows() const {
-    return get<int32_t>(kAbandonPartialTopNRowNumberMinRows, 100'000);
-  }
-
-  int32_t abandonPartialTopNRowNumberMinPct() const {
-    return get<int32_t>(kAbandonPartialTopNRowNumberMinPct, 80);
-  }
-
-  int32_t maxElementsSizeInRepeatAndSequence() const {
-    return get<int32_t>(kMaxElementsSizeInRepeatAndSequence, 10'000);
-  }
-
-  uint64_t maxSpillRunRows() const {
-    static constexpr uint64_t kDefault = 12UL << 20;
-    return get<uint64_t>(kMaxSpillRunRows, kDefault);
-  }
-
-  uint64_t maxSpillBytes() const {
-    static constexpr uint64_t kDefault = 100UL << 30;
-    return get<uint64_t>(kMaxSpillBytes, kDefault);
-  }
-
-  uint64_t maxPartitionedOutputBufferSize() const {
-    static constexpr uint64_t kDefault = 32UL << 20;
-    return get<uint64_t>(kMaxPartitionedOutputBufferSize, kDefault);
-  }
-
-  uint64_t maxOutputBufferSize() const {
-    static constexpr uint64_t kDefault = 32UL << 20;
-    return get<uint64_t>(kMaxOutputBufferSize, kDefault);
-  }
-
-  uint64_t maxLocalExchangeBufferSize() const {
-    static constexpr uint64_t kDefault = 32UL << 20;
-    return get<uint64_t>(kMaxLocalExchangeBufferSize, kDefault);
-  }
-
-  uint32_t maxLocalExchangePartitionCount() const {
-    // defaults to unlimited
-    static constexpr uint32_t kDefault = std::numeric_limits<uint32_t>::max();
-    return get<uint32_t>(kMaxLocalExchangePartitionCount, kDefault);
-  }
-
-  uint32_t minLocalExchangePartitionCountToUsePartitionBuffer() const {
-    // Use non buffering mode if the partition count 32 or less
-    // The default value is 32 is chosen rather conservatively. A
-    // significant performance degradation of a non-buffered approach is
-    // observed after 16 partitions.
-    static constexpr uint64_t kDefault = 33;
-    return get<uint32_t>(
-        kMinLocalExchangePartitionCountToUsePartitionBuffer, kDefault);
-  }
-
-  uint64_t maxLocalExchangePartitionBufferSize() const {
-    /// The default partition buffer size is 64KB.
-    static constexpr uint64_t kDefault = 64UL * 1024;
-    return get<uint64_t>(kMaxLocalExchangePartitionBufferSize, kDefault);
-  }
-
-  bool localExchangePartitionBufferPreserveEncoding() const {
-    /// Trying to preserve encoding can be expensive. Disabled by default.
-    return get<bool>(kLocalExchangePartitionBufferPreserveEncoding, false);
-  }
-
-  uint32_t localMergeSourceQueueSize() const {
-    return get<uint32_t>(kLocalMergeSourceQueueSize, 2);
-  }
-
-  uint64_t maxExchangeBufferSize() const {
-    static constexpr uint64_t kDefault = 32UL << 20;
-    return get<uint64_t>(kMaxExchangeBufferSize, kDefault);
-  }
-
-  uint64_t maxMergeExchangeBufferSize() const {
-    static constexpr uint64_t kDefault = 128UL << 20;
-    return get<uint64_t>(kMaxMergeExchangeBufferSize, kDefault);
-  }
-
-  uint64_t minExchangeOutputBatchBytes() const {
-    static constexpr uint64_t kDefault = 2UL << 20;
-    return get<uint64_t>(kMinExchangeOutputBatchBytes, kDefault);
-  }
-
-  uint64_t preferredOutputBatchBytes() const {
-    static constexpr uint64_t kDefault = 10UL << 20;
-    return get<uint64_t>(kPreferredOutputBatchBytes, kDefault);
-  }
-
   vector_size_t preferredOutputBatchRows() const {
     const uint32_t batchRows = get<uint32_t>(kPreferredOutputBatchRows, 1024);
     VELOX_USER_CHECK_LE(batchRows, std::numeric_limits<vector_size_t>::max());
@@ -861,94 +1513,10 @@ class QueryConfig {
     return maxBatchRows;
   }
 
-  uint32_t tableScanGetOutputTimeLimitMs() const {
-    return get<uint64_t>(kTableScanGetOutputTimeLimitMs, 5'000);
-  }
-
-  bool hashAdaptivityEnabled() const {
-    return get<bool>(kHashAdaptivityEnabled, true);
-  }
-
-  uint32_t writeStrideSize() const {
-    static constexpr uint32_t kDefault = 100'000;
-    return kDefault;
-  }
-
-  bool flushPerBatch() const {
-    static constexpr bool kDefault = true;
-    return kDefault;
-  }
-
-  bool adaptiveFilterReorderingEnabled() const {
-    return get<bool>(kAdaptiveFilterReorderingEnabled, true);
-  }
-
-  bool isLegacyCast() const {
-    return get<bool>(kLegacyCast, false);
-  }
-
-  bool isMatchStructByName() const {
-    return get<bool>(kCastMatchStructByName, false);
-  }
-
-  uint64_t exprMaxArraySizeInReduce() const {
-    return get<uint64_t>(kExprMaxArraySizeInReduce, 100'000);
-  }
-
-  uint64_t exprMaxCompiledRegexes() const {
-    return get<uint64_t>(kExprMaxCompiledRegexes, 100);
-  }
-
-  bool adjustTimestampToTimezone() const {
-    return get<bool>(kAdjustTimestampToTimezone, false);
-  }
-
-  std::string sessionTimezone() const {
-    return get<std::string>(kSessionTimezone, "");
-  }
-
-  bool exprEvalSimplified() const {
-    return get<bool>(kExprEvalSimplified, false);
-  }
-
-  bool spillEnabled() const {
-    return get<bool>(kSpillEnabled, false);
-  }
-
-  bool aggregationSpillEnabled() const {
-    return get<bool>(kAggregationSpillEnabled, true);
-  }
-
-  bool joinSpillEnabled() const {
-    return get<bool>(kJoinSpillEnabled, true);
-  }
-
-  bool mixedGroupedModeHashJoinSpillEnabled() const {
-    return get<bool>(kMixedGroupedModeHashJoinSpillEnabled, false);
-  }
-
-  bool orderBySpillEnabled() const {
-    return get<bool>(kOrderBySpillEnabled, true);
-  }
-
-  bool windowSpillEnabled() const {
-    return get<bool>(kWindowSpillEnabled, true);
-  }
-
-  bool writerSpillEnabled() const {
-    return get<bool>(kWriterSpillEnabled, true);
-  }
-
-  bool rowNumberSpillEnabled() const {
-    return get<bool>(kRowNumberSpillEnabled, true);
-  }
-
-  bool topNRowNumberSpillEnabled() const {
-    return get<bool>(kTopNRowNumberSpillEnabled, true);
-  }
-
-  bool localMergeSpillEnabled() const {
-    return get<bool>(kLocalMergeSpillEnabled, false);
+  vector_size_t mergeJoinOutputBatchStartSize() const {
+    const uint32_t batchRows = get<uint32_t>(kMergeJoinOutputBatchStartSize, 0);
+    VELOX_USER_CHECK_LE(batchRows, std::numeric_limits<vector_size_t>::max());
+    return batchRows;
   }
 
   uint32_t localMergeMaxNumMergeSources() const {
@@ -958,15 +1526,6 @@ class QueryConfig {
     return maxNumMergeSources;
   }
 
-  int32_t maxSpillLevel() const {
-    return get<int32_t>(kMaxSpillLevel, 1);
-  }
-
-  uint8_t spillStartPartitionBit() const {
-    constexpr uint8_t kDefaultStartBit = 48;
-    return get<uint8_t>(kSpillStartPartitionBit, kDefaultStartBit);
-  }
-
   uint8_t spillNumPartitionBits() const {
     constexpr uint8_t kDefaultBits = 3;
     constexpr uint8_t kMaxBits = 3;
@@ -974,109 +1533,6 @@ class QueryConfig {
         kMaxBits, get<uint8_t>(kSpillNumPartitionBits, kDefaultBits));
   }
 
-  uint64_t writerFlushThresholdBytes() const {
-    return get<uint64_t>(kWriterFlushThresholdBytes, 96L << 20);
-  }
-
-  uint64_t maxSpillFileSize() const {
-    constexpr uint64_t kDefaultMaxFileSize = 0;
-    return get<uint64_t>(kMaxSpillFileSize, kDefaultMaxFileSize);
-  }
-
-  std::string spillCompressionKind() const {
-    return get<std::string>(kSpillCompressionKind, "none");
-  }
-
-  bool spillPrefixSortEnabled() const {
-    return get<bool>(kSpillPrefixSortEnabled, false);
-  }
-
-  uint64_t spillWriteBufferSize() const {
-    // The default write buffer size set to 1MB.
-    return get<uint64_t>(kSpillWriteBufferSize, 1L << 20);
-  }
-
-  uint64_t spillReadBufferSize() const {
-    // The default read buffer size set to 1MB.
-    return get<uint64_t>(kSpillReadBufferSize, 1L << 20);
-  }
-
-  std::string spillFileCreateConfig() const {
-    return get<std::string>(kSpillFileCreateConfig, "");
-  }
-
-  int32_t minSpillableReservationPct() const {
-    constexpr int32_t kDefaultPct = 5;
-    return get<int32_t>(kMinSpillableReservationPct, kDefaultPct);
-  }
-
-  int32_t spillableReservationGrowthPct() const {
-    constexpr int32_t kDefaultPct = 10;
-    return get<int32_t>(kSpillableReservationGrowthPct, kDefaultPct);
-  }
-
-  bool queryTraceEnabled() const {
-    return get<bool>(kQueryTraceEnabled, false);
-  }
-
-  std::string queryTraceDir() const {
-    // The default query trace dir, empty by default.
-    return get<std::string>(kQueryTraceDir, "");
-  }
-
-  std::string queryTraceNodeId() const {
-    // The default query trace node ID, empty by default.
-    return get<std::string>(kQueryTraceNodeId, "");
-  }
-
-  uint64_t queryTraceMaxBytes() const {
-    return get<uint64_t>(kQueryTraceMaxBytes, 0);
-  }
-
-  std::string queryTraceTaskRegExp() const {
-    // The default query trace task regexp, empty by default.
-    return get<std::string>(kQueryTraceTaskRegExp, "");
-  }
-
-  bool queryTraceDryRun() const {
-    return get<bool>(kQueryTraceDryRun, false);
-  }
-
-  std::string opTraceDirectoryCreateConfig() const {
-    return get<std::string>(kOpTraceDirectoryCreateConfig, "");
-  }
-
-  bool prestoArrayAggIgnoreNulls() const {
-    return get<bool>(kPrestoArrayAggIgnoreNulls, false);
-  }
-
-  bool sparkAnsiEnabled() const {
-    return get<bool>(kSparkAnsiEnabled, false);
-  }
-
-  int64_t sparkBloomFilterExpectedNumItems() const {
-    constexpr int64_t kDefault = 1'000'000L;
-    return get<int64_t>(kSparkBloomFilterExpectedNumItems, kDefault);
-  }
-
-  int64_t sparkBloomFilterNumBits() const {
-    constexpr int64_t kDefault = 8'388'608L;
-    return get<int64_t>(kSparkBloomFilterNumBits, kDefault);
-  }
-
-  // Spark kMaxNumBits is 67'108'864, but velox has memory limit sizeClassSizes
-  // 256, so decrease it to not over memory limit.
-  int64_t sparkBloomFilterMaxNumBits() const {
-    constexpr int64_t kDefault = 4'096 * 1024;
-    auto value = get<int64_t>(kSparkBloomFilterMaxNumBits, kDefault);
-    VELOX_USER_CHECK_LE(
-        value,
-        kDefault,
-        "{} cannot exceed the default value",
-        kSparkBloomFilterMaxNumBits);
-    return value;
-  }
-
   int32_t sparkPartitionId() const {
     auto id = get<int32_t>(kSparkPartitionId);
     VELOX_CHECK(id.has_value(), "Spark partition id is not set.");
@@ -1085,182 +1541,45 @@ class QueryConfig {
     return value;
   }
 
-  bool sparkLegacyDateFormatter() const {
-    return get<bool>(kSparkLegacyDateFormatter, false);
-  }
-
-  bool sparkLegacyStatisticalAggregate() const {
-    return get<bool>(kSparkLegacyStatisticalAggregate, false);
-  }
-
-  bool sparkJsonIgnoreNullFields() const {
-    return get<bool>(kSparkJsonIgnoreNullFields, true);
-  }
-
-  bool exprTrackCpuUsage() const {
-    return get<bool>(kExprTrackCpuUsage, false);
-  }
-
-  bool operatorTrackCpuUsage() const {
-    return get<bool>(kOperatorTrackCpuUsage, true);
-  }
-
-  uint32_t taskWriterCount() const {
-    return get<uint32_t>(kTaskWriterCount, 4);
-  }
-
   uint32_t taskPartitionedWriterCount() const {
     return get<uint32_t>(kTaskPartitionedWriterCount)
         .value_or(taskWriterCount());
   }
 
-  bool hashProbeFinishEarlyOnEmptyBuild() const {
-    return get<bool>(kHashProbeFinishEarlyOnEmptyBuild, false);
-  }
-
-  uint32_t minTableRowsForParallelJoinBuild() const {
-    return get<uint32_t>(kMinTableRowsForParallelJoinBuild, 1'000);
-  }
-
-  bool validateOutputFromOperators() const {
-    return get<bool>(kValidateOutputFromOperators, false);
-  }
-
-  bool isExpressionEvaluationCacheEnabled() const {
-    return get<bool>(kEnableExpressionEvaluationCache, true);
-  }
-
-  uint32_t maxSharedSubexprResultsCached() const {
-    // 10 was chosen as a default as there are cases where a shared
-    // subexpression can be called in 2 different places and a particular
-    // argument may be peeled in one and not peeled in another. 10 is large
-    // enough to handle this happening for a few arguments in different
-    // combinations.
-    //
-    // For example, when the UDF at the root of a shared subexpression does not
-    // have default null behavior and takes an input that is dictionary encoded
-    // with nulls set in the DictionaryVector. That dictionary
-    // encoding may be peeled depending on whether or not there is a UDF above
-    // it in the expression tree that has default null behavior and takes the
-    // same input as an argument.
-    return get<uint32_t>(kMaxSharedSubexprResultsCached, 10);
-  }
-
-  int32_t maxSplitPreloadPerDriver() const {
-    return get<int32_t>(kMaxSplitPreloadPerDriver, 2);
-  }
-
-  uint32_t driverCpuTimeSliceLimitMs() const {
-    return get<uint32_t>(kDriverCpuTimeSliceLimitMs, 0);
-  }
-
-  uint32_t prefixSortNormalizedKeyMaxBytes() const {
-    return get<uint32_t>(kPrefixSortNormalizedKeyMaxBytes, 128);
-  }
-
-  uint32_t prefixSortMinRows() const {
-    return get<uint32_t>(kPrefixSortMinRows, 128);
-  }
-
-  uint32_t prefixSortMaxStringPrefixLength() const {
-    return get<uint32_t>(kPrefixSortMaxStringPrefixLength, 16);
-  }
-
-  double scaleWriterRebalanceMaxMemoryUsageRatio() const {
-    return get<double>(kScaleWriterRebalanceMaxMemoryUsageRatio, 0.7);
-  }
-
-  uint32_t scaleWriterMaxPartitionsPerWriter() const {
-    return get<uint32_t>(kScaleWriterMaxPartitionsPerWriter, 128);
-  }
-
-  uint64_t scaleWriterMinPartitionProcessedBytesRebalanceThreshold() const {
-    return get<uint64_t>(
-        kScaleWriterMinPartitionProcessedBytesRebalanceThreshold, 128 << 20);
-  }
-
-  uint64_t scaleWriterMinProcessedBytesRebalanceThreshold() const {
-    return get<uint64_t>(
-        kScaleWriterMinProcessedBytesRebalanceThreshold, 256 << 20);
-  }
-
-  bool tableScanScaledProcessingEnabled() const {
-    return get<bool>(kTableScanScaledProcessingEnabled, false);
-  }
-
-  double tableScanScaleUpMemoryUsageRatio() const {
-    return get<double>(kTableScanScaleUpMemoryUsageRatio, 0.7);
-  }
-
-  uint32_t indexLookupJoinMaxPrefetchBatches() const {
-    return get<uint32_t>(kIndexLookupJoinMaxPrefetchBatches, 0);
-  }
-
-  bool indexLookupJoinSplitOutput() const {
-    return get<bool>(kIndexLookupJoinSplitOutput, true);
-  }
-
-  std::string shuffleCompressionKind() const {
-    return get<std::string>(kShuffleCompressionKind, "none");
-  }
-
-  int32_t requestDataSizesMaxWaitSec() const {
-    return get<int32_t>(kRequestDataSizesMaxWaitSec, 10);
-  }
-
-  bool throwExceptionOnDuplicateMapKeys() const {
-    return get<bool>(kThrowExceptionOnDuplicateMapKeys, false);
-  }
-
-  /// TODO: Remove after dependencies are cleaned up.
-  bool streamingAggregationEagerFlush() const {
-    return get<bool>(kStreamingAggregationEagerFlush, false);
-  }
-
-  int32_t streamingAggregationMinOutputBatchRows() const {
-    return get<int32_t>(kStreamingAggregationMinOutputBatchRows, 0);
-  }
-
-  bool isFieldNamesInJsonCastEnabled() const {
-    return get<bool>(kFieldNamesInJsonCastEnabled, false);
-  }
-
-  bool operatorTrackExpressionStats() const {
-    return get<bool>(kOperatorTrackExpressionStats, false);
-  }
-
-  bool enableOperatorBatchSizeStats() const {
-    return get<bool>(kEnableOperatorBatchSizeStats, true);
-  }
-
-  bool unnestSplitOutput() const {
-    return get<bool>(kUnnestSplitOutput, true);
-  }
-
-  int32_t queryMemoryReclaimerPriority() const {
-    return get<int32_t>(
-        kQueryMemoryReclaimerPriority, std::numeric_limits<int32_t>::max());
+  std::optional<uint32_t> debugAggregationApproxPercentileFixedRandomSeed()
+      const {
+    return get<uint32_t>(kDebugAggregationApproxPercentileFixedRandomSeed);
   }
 
-  int32_t maxNumSplitsListenedTo() const {
-    return get<int32_t>(kMaxNumSplitsListenedTo, 0);
+  uint64_t debugMemoryPoolWarnThresholdBytes() const {
+    return config::toCapacity(
+        get<std::string>(kDebugMemoryPoolWarnThresholdBytes, "0B"),
+        config::CapacityUnit::BYTE);
   }
 
-  std::string source() const {
-    return get<std::string>(kSource, "");
-  }
+  enum class RowSizeTrackingMode {
+    DISABLED = 0,
+    EXCLUDE_DELTA_SPLITS = 1,
+    ENABLED_FOR_ALL = 2,
+  };
 
-  std::string clientTags() const {
-    return get<std::string>(kClientTags, "");
+  RowSizeTrackingMode rowSizeTrackingMode() const {
+    return get<RowSizeTrackingMode>(
+        kRowSizeTrackingMode, RowSizeTrackingMode::ENABLED_FOR_ALL);
   }
 
   template <typename T>
   T get(const std::string& key, const T& defaultValue) const {
     return config_->get<T>(key, defaultValue);
   }
+
   template <typename T>
   std::optional<T> get(const std::string& key) const {
-    return std::optional<T>(config_->get<T>(key));
+    return config_->get<T>(key);
+  }
+
+  const std::shared_ptr<const config::IConfig>& config() const {
+    return config_;
   }
 
   /// Test-only method to override the current query config properties.
@@ -1273,6 +1592,10 @@ class QueryConfig {
  private:
   void validateConfig();
 
-  std::unique_ptr<velox::config::ConfigBase> config_;
+  std::shared_ptr<const config::IConfig> config_;
 };
+
+#undef VELOX_QUERY_CONFIG
+#undef VELOX_QUERY_CONFIG_PROPERTY
+
 } // namespace facebook::velox::core
diff --git a/velox/core/QueryConfigProvider.cpp b/velox/core/QueryConfigProvider.cpp
new file mode 100644
index 00000000000..4ecd836ee09
--- /dev/null
+++ b/velox/core/QueryConfigProvider.cpp
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/core/QueryConfigProvider.h"
+
+#include "velox/core/QueryConfig.h"
+
+namespace facebook::velox::core {
+
+std::vector<config::ConfigProperty> QueryConfigProvider::properties() const {
+  return QueryConfig::registeredProperties();
+}
+
+std::string QueryConfigProvider::normalize(
+    std::string_view /*name*/,
+    std::string_view value) const {
+  return std::string(value);
+}
+
+} // namespace facebook::velox::core
diff --git a/velox/core/QueryConfigProvider.h b/velox/core/QueryConfigProvider.h
new file mode 100644
index 00000000000..21ad4cde39d
--- /dev/null
+++ b/velox/core/QueryConfigProvider.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/common/config/ConfigProvider.h"
+
+namespace facebook::velox::core {
+
+/// Exposes all QueryConfig properties as ConfigProperty entries.
+class QueryConfigProvider : public config::ConfigProvider {
+ public:
+  std::vector<config::ConfigProperty> properties() const override;
+
+  std::string normalize(std::string_view name, std::string_view value)
+      const override;
+};
+
+} // namespace facebook::velox::core
diff --git a/velox/core/QueryCtx.cpp b/velox/core/QueryCtx.cpp
index 6297a271882..6cfcb3950ba 100644
--- a/velox/core/QueryCtx.cpp
+++ b/velox/core/QueryCtx.cpp
@@ -15,8 +15,8 @@
  */
 
 #include "velox/core/QueryCtx.h"
+#include "velox/common/base/Exceptions.h"
 #include "velox/common/base/SpillConfig.h"
-#include "velox/common/base/TraceConfig.h"
 #include "velox/common/config/Config.h"
 
 namespace facebook::velox::core {
@@ -30,18 +30,35 @@ std::shared_ptr<QueryCtx> QueryCtx::create(
     cache::AsyncDataCache* cache,
     std::shared_ptr<memory::MemoryPool> pool,
     folly::Executor* spillExecutor,
-    const std::string& queryId,
+    std::string queryId,
     std::shared_ptr<filesystems::TokenProvider> tokenProvider) {
+  return QueryCtx::Builder()
+      .executor(executor)
+      .queryConfig(std::move(queryConfig))
+      .connectorConfigs(std::move(connectorConfigs))
+      .asyncDataCache(cache)
+      .pool(std::move(pool))
+      .spillExecutor(spillExecutor)
+      .queryId(std::move(queryId))
+      .tokenProvider(std::move(tokenProvider))
+      .build();
+}
+
+std::shared_ptr<QueryCtx> QueryCtx::Builder::build() {
   std::shared_ptr<QueryCtx> queryCtx(new QueryCtx(
-      executor,
-      std::move(queryConfig),
-      std::move(connectorConfigs),
-      cache,
-      std::move(pool),
-      spillExecutor,
-      queryId,
-      std::move(tokenProvider)));
+      executor_,
+      std::move(queryConfig_),
+      std::move(connectorConfigs_),
+      cache_,
+      std::move(pool_),
+      spillExecutor_,
+      std::move(queryId_),
+      std::move(tokenProvider_),
+      std::move(traceCtxProvider_)));
   queryCtx->maybeSetReclaimer();
+  for (auto& cb : releaseCallbacks_) {
+    queryCtx->addReleaseCallback(std::move(cb));
+  }
   return queryCtx;
 }
 
@@ -54,7 +71,8 @@ QueryCtx::QueryCtx(
     std::shared_ptr<memory::MemoryPool> pool,
     folly::Executor* spillExecutor,
     const std::string& queryId,
-    std::shared_ptr<filesystems::TokenProvider> tokenProvider)
+    std::shared_ptr<filesystems::TokenProvider> tokenProvider,
+    TraceCtxProvider traceCtxProvider)
     : queryId_(queryId),
       executor_(executor),
       spillExecutor_(spillExecutor),
@@ -62,15 +80,29 @@ QueryCtx::QueryCtx(
       connectorSessionProperties_(connectorSessionProperties),
       pool_(std::move(pool)),
       queryConfig_{std::move(queryConfig)},
-      fsTokenProvider_(std::move(tokenProvider)) {
+      fsTokenProvider_(std::move(tokenProvider)),
+      traceCtxProvider_(std::move(traceCtxProvider)) {
   initPool(queryId);
 }
 
+QueryCtx::~QueryCtx() {
+  for (auto& cb : releaseCallbacks_) {
+    try {
+      cb();
+    } catch (const std::exception& e) {
+      LOG(ERROR) << "Release callback threw exception: " << e.what();
+    } catch (...) {
+      LOG(ERROR) << "Release callback threw unknown exception";
+    }
+  }
+  VELOX_CHECK(!underArbitration_);
+}
+
 /*static*/ std::string QueryCtx::generatePoolName(const std::string& queryId) {
   // We attach a monotonically increasing sequence number to ensure the pool
   // name is unique.
   static std::atomic<int64_t> seqNum{0};
-  return fmt::format("query.{}.{}", queryId.c_str(), seqNum++);
+  return fmt::format("query.{}.{}", queryId, seqNum++);
 }
 
 void QueryCtx::maybeSetReclaimer() {
@@ -86,18 +118,19 @@ void QueryCtx::updateSpilledBytesAndCheckLimit(uint64_t bytes) {
   const auto numSpilledBytes = numSpilledBytes_.fetch_add(bytes) + bytes;
   if (queryConfig_.maxSpillBytes() > 0 &&
       numSpilledBytes > queryConfig_.maxSpillBytes()) {
-    VELOX_SPILL_LIMIT_EXCEEDED(fmt::format(
-        "Query exceeded per-query local spill limit of {}",
-        succinctBytes(queryConfig_.maxSpillBytes())));
+    VELOX_SPILL_LIMIT_EXCEEDED(
+        fmt::format(
+            "Query exceeded per-query local spill limit of {}",
+            succinctBytes(queryConfig_.maxSpillBytes())));
   }
 }
 
 void QueryCtx::updateTracedBytesAndCheckLimit(uint64_t bytes) {
   if (numTracedBytes_.fetch_add(bytes) + bytes >=
       queryConfig_.queryTraceMaxBytes()) {
-    VELOX_TRACE_LIMIT_EXCEEDED(fmt::format(
+    VELOX_TRACE_LIMIT_EXCEEDED(
         "Query exceeded per-query local trace limit of {}",
-        succinctBytes(queryConfig_.queryTraceMaxBytes())));
+        succinctBytes(queryConfig_.queryTraceMaxBytes()));
   }
 }
 
diff --git a/velox/core/QueryCtx.h b/velox/core/QueryCtx.h
index 423e93ea312..749c6d0be3f 100644
--- a/velox/core/QueryCtx.h
+++ b/velox/core/QueryCtx.h
@@ -17,32 +17,99 @@
 #pragma once
 
 #include <folly/Executor.h>
-#include <folly/executors/CPUThreadPoolExecutor.h>
+#include <folly/Synchronized.h>
+#include <folly/container/F14Map.h>
+#include <deque>
+#include <functional>
+#include <string_view>
+#include <typeindex>
+#include "velox/common/base/Exceptions.h"
 #include "velox/common/caching/AsyncDataCache.h"
 #include "velox/common/memory/Memory.h"
 #include "velox/core/QueryConfig.h"
+#include "velox/core/ScanBatchEvent.h"
 #include "velox/vector/DecodedVector.h"
 #include "velox/vector/VectorPool.h"
 
-namespace facebook::velox {
-class Config;
-}
+namespace facebook::velox::exec::trace {
+class TraceCtx;
+} // namespace facebook::velox::exec::trace
 
 namespace facebook::velox::core {
 
+struct PlanFragment;
+
+/// Query execution context that manages resources and configuration for a
+/// query.
+///
+/// QueryCtx encapsulates query-level state and resources including:
+///
+/// - Memory pool management and memory arbitration.
+/// - Query and connector-specific configuration.
+/// - Executor for parallel task execution.
+/// - Async data cache for IO operations.
+/// - Spill executor for disk-based operations.
+/// - Query tracing and metrics tracking.
+///
+/// Usage Contexts:
+///
+/// - Multi-threaded execution: Used with Task::start() where an executor must
+///   be provided and its lifetime must outlive all tasks using this context.
+/// - Single-threaded execution: Used with ExecCtx or Task::next() for
+///   expression evaluation where no executor is required.
+///
+/// Construction:
+///
+/// To construct a QueryCtx, prefer to use the builder pattern:
+///
+/// @code
+///   auto queryCtx = QueryCtx::Builder()
+///       .executor(myExecutor)
+///       .queryConfig(configMap)
+///       .queryId("query-123")
+///       .pool(myMemoryPool)
+///       .build();
+/// @endcode
+///
+/// Memory Management:
+///
+/// - Automatically creates a root memory pool if not provided
+/// - Supports memory arbitration and reclamation under memory pressure
+/// - Tracks spilled bytes with configurable limits
+/// - Thread-safe memory pool operations
+///
+/// Thread-safety: QueryCtx is thread-safe for concurrent access across
+/// multiple tasks and operators within a query execution.
 class QueryCtx : public std::enable_shared_from_this<QueryCtx> {
  public:
-  ~QueryCtx() {
-    VELOX_CHECK(!underArbitration_);
-  }
+  using ReleaseCallback = std::function<void()>;
+  using TraceCtxProvider = std::function<std::unique_ptr<exec::trace::TraceCtx>(
+      core::QueryCtx&,
+      const core::PlanFragment&)>;
 
-  /// QueryCtx is used in different places. When used with `Task::start()`, it's
-  /// required that the caller supplies the executor and ensure its lifetime
-  /// outlives the tasks that use it. In contrast, when used in expression
-  /// evaluation through `ExecCtx` or 'Task::next()' for single thread execution
-  /// mode, executor is not needed. Hence, we don't require executor to always
-  /// be passed in here, but instead, ensure that executor exists when actually
-  /// being used.
+  ~QueryCtx();
+
+  /// Creates a new QueryCtx instance with the specified configuration.
+  ///
+  /// This factory method constructs a QueryCtx with all necessary resources
+  /// and automatically sets up memory reclamation if not already configured.
+  ///
+  /// @param executor Optional executor for parallel task execution. Required
+  ///                 when used with Task::start(), but not needed for
+  ///                 expression evaluation or single-threaded execution.
+  /// @param queryConfig Query-level configuration settings.
+  /// @param connectorConfigs Connector-specific configuration mappings.
+  /// @param cache Async data cache for IO operations (defaults to global
+  ///              instance).
+  /// @param pool Memory pool for query execution (auto-created if nullptr).
+  /// @param spillExecutor Optional executor for spilling operations.
+  /// @param queryId Unique identifier for this query.
+  /// @param tokenProvider Optional filesystem token provider for
+  ///                      authentication.
+  /// @return Shared pointer to the newly created QueryCtx.
+  ///
+  /// Note: The caller must ensure the executor's lifetime outlives all tasks
+  /// using this QueryCtx when executor is provided.
   static std::shared_ptr<QueryCtx> create(
       folly::Executor* executor = nullptr,
       QueryConfig&& queryConfig = QueryConfig{{}},
@@ -51,9 +118,109 @@ class QueryCtx : public std::enable_shared_from_this<QueryCtx> {
       cache::AsyncDataCache* cache = cache::AsyncDataCache::getInstance(),
       std::shared_ptr<memory::MemoryPool> pool = nullptr,
       folly::Executor* spillExecutor = nullptr,
-      const std::string& queryId = "",
+      std::string queryId = "",
       std::shared_ptr<filesystems::TokenProvider> tokenProvider = {});
 
+  /// Builder pattern for constructing QueryCtx instances.
+  ///
+  /// Provides a fluent interface for creating QueryCtx with optional
+  /// parameters. This is the recommended approach for improved readability,
+  /// especially when only setting a subset of configuration options.
+  ///
+  /// Example:
+  /// @code
+  ///   auto ctx = QueryCtx::Builder()
+  ///                  .queryId("my-query")
+  ///                  .executor(myExecutor)
+  ///                  .queryConfig(QueryConfig{mySettings})
+  ///                  .build();
+  /// @endcode
+  class Builder {
+   public:
+    Builder& executor(folly::Executor* executor) {
+      executor_ = executor;
+      return *this;
+    }
+
+    Builder& queryConfig(QueryConfig queryConfig) {
+      queryConfig_ = std::move(queryConfig);
+      return *this;
+    }
+
+    Builder& connectorConfigs(
+        std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>
+            connectorConfigs) {
+      connectorConfigs_ = std::move(connectorConfigs);
+      return *this;
+    }
+
+    Builder& asyncDataCache(cache::AsyncDataCache* cache) {
+      cache_ = cache;
+      return *this;
+    }
+
+    Builder& pool(std::shared_ptr<memory::MemoryPool> pool) {
+      pool_ = std::move(pool);
+      return *this;
+    }
+
+    Builder& spillExecutor(folly::Executor* spillExecutor) {
+      spillExecutor_ = spillExecutor;
+      return *this;
+    }
+
+    Builder& queryId(std::string queryId) {
+      queryId_ = std::move(queryId);
+      return *this;
+    }
+
+    Builder& tokenProvider(
+        std::shared_ptr<filesystems::TokenProvider> tokenProvider) {
+      tokenProvider_ = std::move(tokenProvider);
+      return *this;
+    }
+
+    /// Adds a callback to be invoked when the QueryCtx is destroyed.
+    /// Multiple callbacks can be added by calling this method multiple times.
+    Builder& releaseCallback(ReleaseCallback callback) {
+      releaseCallbacks_.push_back(std::move(callback));
+      return *this;
+    }
+
+    Builder& traceCtxProvider(TraceCtxProvider provider) {
+      traceCtxProvider_ = std::move(provider);
+      return *this;
+    }
+
+    /// Constructs and returns a QueryCtx with the configured parameters.
+    ///
+    /// @return Shared pointer to the newly created QueryCtx instance
+    std::shared_ptr<QueryCtx> build();
+
+   private:
+    folly::Executor* executor_{nullptr};
+    QueryConfig queryConfig_{QueryConfig{{}}};
+    std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>
+        connectorConfigs_;
+    cache::AsyncDataCache* cache_{cache::AsyncDataCache::getInstance()};
+    std::shared_ptr<memory::MemoryPool> pool_;
+    folly::Executor* spillExecutor_{nullptr};
+    std::string queryId_;
+    std::shared_ptr<filesystems::TokenProvider> tokenProvider_;
+    std::deque<ReleaseCallback> releaseCallbacks_;
+    TraceCtxProvider traceCtxProvider_;
+  };
+
+  /// Generates a unique memory pool name for a query.
+  ///
+  /// Creates a pool name by combining the provided query ID with a
+  /// monotonically increasing sequence number to ensure uniqueness across
+  /// multiple pool creations, even for the same query ID.
+  ///
+  /// @param queryId The query identifier to incorporate into the pool name
+  /// @return A unique pool name in the format "query.{queryId}.{seqNum}"
+  ///
+  /// Thread-safe: Uses atomic operations for sequence number generation.
   static std::string generatePoolName(const std::string& queryId);
 
   memory::MemoryPool* pool() const {
@@ -94,6 +261,22 @@ class QueryCtx : public std::enable_shared_from_this<QueryCtx> {
     return fsTokenProvider_;
   }
 
+  /// Registers a callback to be invoked when this QueryCtx is destroyed.
+  /// This allows external resources tied to the query's lifetime to be cleaned
+  /// up before the QueryCtx and its members are destructed. For example,
+  /// resources that have allocations in the query's memory pool.
+  ///
+  /// Example: HashTableCache uses this to remove cached hash tables when a
+  /// query completes. The cache entry holds a child memory pool of the query
+  /// pool, so it must be released before the query pool is destroyed.
+  ///
+  /// Note: Callbacks are invoked in registration order. Exceptions thrown by
+  /// callbacks are caught and logged; they do not prevent subsequent callbacks
+  /// from running.
+  void addReleaseCallback(ReleaseCallback callback) {
+    releaseCallbacks_.push_back(std::move(callback));
+  }
+
   /// Overrides the previous configuration. Note that this function is NOT
   /// thread-safe and should probably only be used in tests.
   void testingOverrideConfigUnsafe(
@@ -131,6 +314,67 @@ class QueryCtx : public std::enable_shared_from_this<QueryCtx> {
   /// the max query trace bytes limit.
   void updateTracedBytesAndCheckLimit(uint64_t bytes);
 
+  TraceCtxProvider traceCtxProvider() {
+    return traceCtxProvider_;
+  }
+
+  void setTraceCtxProvider(TraceCtxProvider provider) {
+    traceCtxProvider_ = std::move(provider);
+  }
+
+  /// Sets an optional callback fired by TableScan after each non-empty batch.
+  void setScanBatchCallback(ScanBatchCallback callback) {
+    scanBatchCallback_ = std::move(callback);
+  }
+
+  const ScanBatchCallback& scanBatchCallback() const {
+    return scanBatchCallback_;
+  }
+
+  /// Store a per-query registry override. Each subsystem defines its own key
+  /// (e.g., "connectors", "vectorFunctions"). The registry is stored as a
+  /// type-erased shared_ptr; callers must use the same type T for setRegistry
+  /// and registry calls with the same key. Returns true if the key was newly
+  /// inserted. Throws if the key already exists unless 'overwrite' is true,
+  /// in which case the existing entry is replaced and false is returned.
+  template <typename T>
+  bool setRegistry(
+      std::string_view key,
+      std::shared_ptr<T> registry,
+      bool overwrite = false) {
+    return registries_.withWLock([&](auto& map) {
+      auto it = map.find(std::string(key));
+      if (it != map.end()) {
+        VELOX_CHECK(overwrite, "Registry already set: {}", key);
+        it->second = {std::move(registry), std::type_index(typeid(T))};
+        return false;
+      }
+      map.emplace(
+          std::string(key),
+          RegistryEntry{std::move(registry), std::type_index(typeid(T))});
+      return true;
+    });
+  }
+
+  /// Retrieve a per-query registry override. Returns nullptr if no override
+  /// was set for this key. Asserts that the stored type matches T.
+  template <typename T>
+  std::shared_ptr<T> registry(std::string_view key) const {
+    return registries_.withRLock([&](const auto& map) -> std::shared_ptr<T> {
+      auto it = map.find(std::string(key));
+      if (it == map.end()) {
+        return nullptr;
+      }
+      VELOX_CHECK(
+          it->second.type == std::type_index(typeid(T)),
+          "Registry type mismatch for key '{}': expected {}, got {}",
+          key,
+          typeid(T).name(),
+          it->second.type.name());
+      return std::static_pointer_cast<T>(it->second.ptr);
+    });
+  }
+
   void testingOverrideMemoryPool(std::shared_ptr<memory::MemoryPool> pool) {
     pool_ = std::move(pool);
   }
@@ -159,7 +403,8 @@ class QueryCtx : public std::enable_shared_from_this<QueryCtx> {
       std::shared_ptr<memory::MemoryPool> pool = nullptr,
       folly::Executor* spillExecutor = nullptr,
       const std::string& queryId = "",
-      std::shared_ptr<filesystems::TokenProvider> tokenProvider = {});
+      std::shared_ptr<filesystems::TokenProvider> tokenProvider = {},
+      TraceCtxProvider traceCtxProvider = nullptr);
 
   class MemoryReclaimer : public memory::MemoryReclaimer {
    public:
@@ -214,6 +459,7 @@ class QueryCtx : public std::enable_shared_from_this<QueryCtx> {
 
   // Invoked to start memory arbitration on this query.
   void startArbitration();
+
   // Invoked to stop memory arbitration on this query.
   void finishArbitration();
 
@@ -230,10 +476,29 @@ class QueryCtx : public std::enable_shared_from_this<QueryCtx> {
   std::atomic<uint64_t> numTracedBytes_{0};
 
   mutable std::mutex mutex_;
+
   // Indicates if this query is under memory arbitration or not.
   std::atomic_bool underArbitration_{false};
   std::vector<ContinuePromise> arbitrationPromises_;
   std::shared_ptr<filesystems::TokenProvider> fsTokenProvider_;
+  // Callbacks invoked before destruction to clean up external resources.
+  std::deque<ReleaseCallback> releaseCallbacks_;
+
+  // A function that constructs a custom trace ctx object.
+  TraceCtxProvider traceCtxProvider_;
+
+  // Optional per-batch scan stats callback.
+  ScanBatchCallback scanBatchCallback_;
+
+  // Type-erased registry entry for per-query overrides.
+  struct RegistryEntry {
+    std::shared_ptr<void> ptr;
+    std::type_index type;
+  };
+
+  // Per-query registry overrides keyed by subsystem name.
+  folly::Synchronized<folly::F14FastMap<std::string, RegistryEntry>>
+      registries_;
 };
 
 // Represents the state of one thread of query execution.
@@ -260,6 +525,7 @@ class ExecCtx {
           !queryConfig.debugDisableExpressionsWithMemoization() &&
           exprEvalCacheEnabled;
       peelingEnabled = !queryConfig.debugDisableExpressionsWithPeeling();
+      minRowsForPeeling = queryConfig.minRowsForPeeling();
       sharedSubExpressionReuseEnabled =
           !queryConfig.debugDisableCommonSubExpressions();
       deferredLazyLoadingEnabled =
@@ -279,6 +545,9 @@ class ExecCtx {
     bool dictionaryMemoizationEnabled;
     /// True if peeling is enabled during experssion evaluation.
     bool peelingEnabled;
+    /// Minimum number of rows required for peeling to be applied during
+    /// expression evaluation.
+    int32_t minRowsForPeeling;
     /// True if shared subexpression reuse is enabled during experssion
     /// evaluation.
     bool sharedSubExpressionReuseEnabled;
diff --git a/velox/core/ScanBatchEvent.h b/velox/core/ScanBatchEvent.h
new file mode 100644
index 00000000000..27a01c59ec5
--- /dev/null
+++ b/velox/core/ScanBatchEvent.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cstdint>
+#include <functional>
+
+namespace facebook::velox::core {
+
+/// Per-batch scan statistics event fired by TableScan after each batch.
+struct ScanBatchEvent {
+  virtual ~ScanBatchEvent() = default;
+
+  /// Post-pushdown, pre-remaining-filter row count.
+  uint64_t numRows{0};
+  /// Wall time spent producing this batch in microseconds.
+  uint64_t wallTimeMicros{0};
+};
+
+using ScanBatchCallback = std::function<void(const ScanBatchEvent&)>;
+
+} // namespace facebook::velox::core
diff --git a/velox/core/SimpleFunctionMetadata.h b/velox/core/SimpleFunctionMetadata.h
index 05fb26a4491..d160778cfff 100644
--- a/velox/core/SimpleFunctionMetadata.h
+++ b/velox/core/SimpleFunctionMetadata.h
@@ -80,6 +80,21 @@ struct udf_canonical_name<
   static constexpr exec::FunctionCanonicalName value = T::canonical_name;
 };
 
+// If a UDF doesn't declare a default owner
+template <class T, class = void>
+struct udf_owner {
+  static constexpr std::string_view value() {
+    return "";
+  }
+};
+
+template <class T>
+struct udf_owner<T, util::detail::void_t<decltype(T::owner)>> {
+  static constexpr std::string_view value() {
+    return T::owner;
+  }
+};
+
 // Has the value true, unless a Variadic Type appears anywhere but at the end
 // of the parameters.
 template <typename... TArgs>
@@ -243,13 +258,14 @@ struct TypeAnalysis<Generic<T, comparable, orderable>> {
     } else {
       auto typeVariableName = fmt::format("__user_T{}", T::getId());
       results.out << typeVariableName;
-      results.addVariable(exec::SignatureVariable(
-          typeVariableName,
-          std::nullopt,
-          exec::ParameterType::kTypeParameter,
-          false,
-          orderable,
-          comparable));
+      results.addVariable(
+          exec::SignatureVariable(
+              typeVariableName,
+              std::nullopt,
+              exec::ParameterType::kTypeParameter,
+              false,
+              orderable,
+              comparable));
     }
     results.stats.hasGeneric = true;
     results.physicalType = UNKNOWN();
@@ -264,10 +280,12 @@ struct TypeAnalysis<ShortDecimal<P, S>> {
     const auto p = P::name();
     const auto s = S::name();
     results.out << fmt::format("decimal({},{})", p, s);
-    results.addVariable(exec::SignatureVariable(
-        p, std::nullopt, exec::ParameterType::kIntegerParameter));
-    results.addVariable(exec::SignatureVariable(
-        s, std::nullopt, exec::ParameterType::kIntegerParameter));
+    results.addVariable(
+        exec::SignatureVariable(
+            p, std::nullopt, exec::ParameterType::kIntegerParameter));
+    results.addVariable(
+        exec::SignatureVariable(
+            s, std::nullopt, exec::ParameterType::kIntegerParameter));
     results.physicalType = BIGINT();
   }
 };
@@ -280,10 +298,12 @@ struct TypeAnalysis<LongDecimal<P, S>> {
     const auto p = P::name();
     const auto s = S::name();
     results.out << fmt::format("decimal({},{})", p, s);
-    results.addVariable(exec::SignatureVariable(
-        p, std::nullopt, exec::ParameterType::kIntegerParameter));
-    results.addVariable(exec::SignatureVariable(
-        s, std::nullopt, exec::ParameterType::kIntegerParameter));
+    results.addVariable(
+        exec::SignatureVariable(
+            p, std::nullopt, exec::ParameterType::kIntegerParameter));
+    results.addVariable(
+        exec::SignatureVariable(
+            s, std::nullopt, exec::ParameterType::kIntegerParameter));
     results.physicalType = HUGEINT();
   }
 };
@@ -295,8 +315,9 @@ struct TypeAnalysis<facebook::velox::BigintEnumT<E>> {
 
     const auto e = E::name();
     results.out << fmt::format("bigint_enum({})", e);
-    results.addVariable(exec::SignatureVariable(
-        e, std::nullopt, exec::ParameterType::kEnumParameter));
+    results.addVariable(
+        exec::SignatureVariable(
+            e, std::nullopt, exec::ParameterType::kEnumParameter));
     results.physicalType = BIGINT();
   }
 };
@@ -308,8 +329,9 @@ struct TypeAnalysis<facebook::velox::VarcharEnumT<E>> {
 
     const auto e = E::name();
     results.out << fmt::format("varchar_enum({})", e);
-    results.addVariable(exec::SignatureVariable(
-        e, std::nullopt, exec::ParameterType::kEnumParameter));
+    results.addVariable(
+        exec::SignatureVariable(
+            e, std::nullopt, exec::ParameterType::kEnumParameter));
     results.physicalType = VARCHAR();
   }
 };
@@ -431,6 +453,9 @@ class ISimpleFunctionMetadata {
   virtual std::string getName() const = 0;
   virtual bool isDeterministic() const = 0;
   virtual bool defaultNullBehavior() const = 0;
+  // Return the owner of the function. This is used for logging and
+  // attribution.
+  virtual std::string_view owner() const = 0;
   virtual uint32_t priority() const = 0;
   virtual const std::shared_ptr<exec::FunctionSignature> signature() const = 0;
   virtual const TypePtr& resultPhysicalType() const = 0;
@@ -545,6 +570,10 @@ class SimpleFunctionMetadata : public ISimpleFunctionMetadata {
     return udf_is_deterministic<Fun>();
   }
 
+  std::string_view owner() const final {
+    return udf_owner<Fun>::value();
+  }
+
   bool defaultNullBehavior() const final {
     return defaultNullBehavior_;
   }
@@ -874,8 +903,28 @@ class UDFHolder {
         (udf_has_callAscii_return_void && udf_has_call_return_bool)),
       "The return type for callAscii() must match the return type for call().");
 
-  // initialize():
-  static constexpr bool udf_has_initialize = util::has_method<
+  // Detects if initialize() is a template method using SFINAE.
+  // Template methods can match any signature via template parameter deduction,
+  // causing false positives in trait detection. We probe with a dummy type
+  // that's not in our expected signature to identify templates.
+  struct DummyProbeType {};
+
+  template <typename U, typename = void>
+  struct has_template_initialize : std::false_type {};
+
+  template <typename U>
+  struct has_template_initialize<
+      U,
+      util::detail::void_t<decltype(std::declval<U>().initialize(
+          std::declval<const std::vector<TypePtr>&>(),
+          std::declval<const core::QueryConfig&>(),
+          std::declval<const DummyProbeType*>()))>> : std::true_type {};
+
+  static constexpr bool is_initialize_template =
+      has_template_initialize<Fun>::value;
+
+  // Check for initialize() without MemoryPool parameter.
+  static constexpr bool udf_has_initialize_without_pool = util::has_method<
       Fun,
       initialize_method_resolver,
       void,
@@ -883,6 +932,25 @@ class UDFHolder {
       const core::QueryConfig&,
       const exec_arg_type<TArgs>*...>::value;
 
+  // Check for initialize() with MemoryPool parameter.
+  // Excludes template methods to prevent them from incorrectly matching
+  // via template parameter substitution (e.g., T=MemoryPool).
+  static constexpr bool udf_has_initialize_with_pool =
+      !is_initialize_template &&
+      util::has_method<
+          Fun,
+          initialize_method_resolver,
+          void,
+          const std::vector<TypePtr>&,
+          const core::QueryConfig&,
+          memory::MemoryPool*,
+          const exec_arg_type<TArgs>*...>::value;
+
+  // Combined trait for backward compatibility: true if ANY initialize exists
+  // This preserves the original meaning of udf_has_initialize
+  static constexpr bool udf_has_initialize =
+      udf_has_initialize_with_pool || udf_has_initialize_without_pool;
+
   // TODO Remove
   static constexpr bool udf_has_legacy_initialize = util::has_method<
       Fun,
@@ -958,6 +1026,10 @@ class UDFHolder {
     return udf_is_deterministic<Fun>();
   }
 
+  std::string_view owner() const {
+    return udf_owner<Fun>::value();
+  }
+
   static constexpr bool isVariadic() {
     if constexpr (num_args == 0) {
       return false;
@@ -969,9 +1041,16 @@ class UDFHolder {
   FOLLY_ALWAYS_INLINE void initialize(
       const std::vector<TypePtr>& inputTypes,
       const core::QueryConfig& config,
+      memory::MemoryPool* memoryPool,
       const typename exec_resolver<TArgs>::in_type*... constantArgs) {
-    if constexpr (udf_has_initialize) {
+    // Prefer non-MemoryPool signature first to handle template methods
+    // correctly. Template initialize() methods can match any signature via
+    // template parameter deduction, so we avoid passing MemoryPool to them.
+    if constexpr (udf_has_initialize_without_pool) {
       return instance_.initialize(inputTypes, config, constantArgs...);
+    } else if constexpr (udf_has_initialize_with_pool) {
+      return instance_.initialize(
+          inputTypes, config, memoryPool, constantArgs...);
     }
   }
 
diff --git a/velox/core/TableWriteTraits.cpp b/velox/core/TableWriteTraits.cpp
new file mode 100644
index 00000000000..bc6e1a31832
--- /dev/null
+++ b/velox/core/TableWriteTraits.cpp
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/core/TableWriteTraits.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/ConstantVector.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::core {
+
+// static
+RowVectorPtr TableWriteTraits::createAggregationStatsOutput(
+    RowTypePtr outputType,
+    RowVectorPtr aggregationOutput,
+    StringView tableCommitContext,
+    velox::memory::MemoryPool* pool) {
+  // TODO: record aggregation stats output time.
+  if (aggregationOutput == nullptr) {
+    return nullptr;
+  }
+  VELOX_CHECK_GT(aggregationOutput->childrenSize(), 0);
+  const vector_size_t numOutputRows = aggregationOutput->childAt(0)->size();
+  std::vector<VectorPtr> columns;
+  for (int channel = 0; channel < outputType->size(); channel++) {
+    if (channel < TableWriteTraits::kContextChannel) {
+      // 1. Set null rows column.
+      // 2. Set null fragments column.
+      columns.push_back(
+          BaseVector::createNullConstant(
+              outputType->childAt(channel), numOutputRows, pool));
+      continue;
+    }
+    if (channel == TableWriteTraits::kContextChannel) {
+      // 3. Set commitcontext column.
+      columns.push_back(
+          std::make_shared<ConstantVector<StringView>>(
+              pool,
+              numOutputRows,
+              false /*isNull*/,
+              VARBINARY(),
+              // Note that we move tableCommitContext here, so ensure this
+              // branch is only executed once in the loop.
+              std::move(tableCommitContext)));
+      continue;
+    }
+    // 4. Set statistics columns.
+    columns.push_back(
+        aggregationOutput->childAt(channel - TableWriteTraits::kStatsChannel));
+  }
+  return std::make_shared<RowVector>(
+      pool, outputType, nullptr, numOutputRows, columns);
+}
+
+std::string TableWriteTraits::rowCountColumnName() {
+  static const std::string kRowCountName = "rows";
+  return kRowCountName;
+}
+
+std::string TableWriteTraits::fragmentColumnName() {
+  static const std::string kFragmentName = "fragments";
+  return kFragmentName;
+}
+
+std::string TableWriteTraits::contextColumnName() {
+  static const std::string kContextName = "commitcontext";
+  return kContextName;
+}
+
+const TypePtr& TableWriteTraits::rowCountColumnType() {
+  static const TypePtr kRowCountType = BIGINT();
+  return kRowCountType;
+}
+
+const TypePtr& TableWriteTraits::fragmentColumnType() {
+  static const TypePtr kFragmentType = VARBINARY();
+  return kFragmentType;
+}
+
+const TypePtr& TableWriteTraits::contextColumnType() {
+  static const TypePtr kContextType = VARBINARY();
+  return kContextType;
+}
+
+// static.
+RowTypePtr TableWriteTraits::outputType(
+    const std::optional<core::ColumnStatsSpec>& columnStatsSpec) {
+  static const auto kOutputTypeWithoutStats =
+      ROW({rowCountColumnName(), fragmentColumnName(), contextColumnName()},
+          {rowCountColumnType(), fragmentColumnType(), contextColumnType()});
+  if (!columnStatsSpec.has_value()) {
+    return kOutputTypeWithoutStats;
+  }
+  return kOutputTypeWithoutStats->unionWith(columnStatsSpec->outputType());
+}
+
+bool TableWriteTraits::isStatisticsRow(
+    const RowVectorPtr& output,
+    vector_size_t index) {
+  VELOX_DCHECK_LT(index, output->size());
+  return output->childAt(kRowCountChannel)->isNullAt(index) &&
+      output->childAt(kFragmentChannel)->isNullAt(index);
+}
+
+folly::dynamic TableWriteTraits::getTableCommitContext(
+    const RowVectorPtr& input) {
+  VELOX_CHECK_GT(input->size(), 0);
+  auto* contextVector =
+      input->childAt(kContextChannel)->as<SimpleVector<StringView>>();
+  return folly::parseJson(
+      std::string_view(contextVector->valueAt(input->size() - 1)));
+}
+
+int64_t TableWriteTraits::getRowCount(const RowVectorPtr& output) {
+  VELOX_CHECK_GT(output->size(), 0);
+  auto* rowCountVector =
+      output->childAt(kRowCountChannel)->as<SimpleVector<int64_t>>();
+  VELOX_CHECK_NOT_NULL(rowCountVector);
+  int64_t rowCount{0};
+  for (int i = 0; i < output->size(); ++i) {
+    if (!rowCountVector->isNullAt(i)) {
+      rowCount += rowCountVector->valueAt(i);
+    }
+  }
+  return rowCount;
+}
+
+} // namespace facebook::velox::core
diff --git a/velox/core/TableWriteTraits.h b/velox/core/TableWriteTraits.h
new file mode 100644
index 00000000000..1c671c4fe08
--- /dev/null
+++ b/velox/core/TableWriteTraits.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+#include "velox/core/PlanNode.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox::core {
+
+/// Defines table writer output related config properties that are shared
+/// between TableWriter and TableWriteMerger.
+///
+/// TODO: the table write output processing is Prestissimo specific. Consider
+/// move these part logic to Prestissimo and pass to Velox through a customized
+/// output processing callback.
+class TableWriteTraits {
+ public:
+  /// Defines the column names/types in table write output.
+  static std::string rowCountColumnName();
+  static std::string fragmentColumnName();
+  static std::string contextColumnName();
+
+  static const TypePtr& rowCountColumnType();
+  static const TypePtr& fragmentColumnType();
+  static const TypePtr& contextColumnType();
+
+  /// Defines the column channels in table write output.
+  /// Both the statistics and the row_count + fragments are transferred over the
+  /// same communication link between the TableWriter and TableFinish. Thus the
+  /// multiplexing is needed.
+  ///
+  ///  The transferred page layout looks like:
+  /// [row_count_channel], [fragment_channel], [context_channel],
+  /// [statistic_channel_1] ... [statistic_channel_N]]
+  ///
+  /// [row_count_channel] - contains number of rows processed by a TableWriter
+  /// [fragment_channel] - contains data provided by the DataSink#finish
+  /// [context_channel] - JSON-serialized commit context (VARBINARY).
+  ///   Present on every row. See k*ContextKey constants below.
+  /// [statistic_channel_1] ...[statistic_channel_N] -
+  /// contain aggregated statistics computed by the statistics aggregation
+  /// within the TableWriter
+  ///
+  /// For convenience, we never set both: [row_count_channel] +
+  /// [fragment_channel] and the [statistic_channel_1] ...
+  /// [statistic_channel_N].
+  ///
+  /// If this is a row that holds statistics - the [row_count_channel] +
+  /// [fragment_channel] will be NULL.
+  ///
+  /// If this is a row that holds the row count
+  /// or the fragment - all the statistics channels will be set to NULL.
+  static constexpr int32_t kRowCountChannel = 0;
+  static constexpr int32_t kFragmentChannel = 1;
+  static constexpr int32_t kContextChannel = 2;
+  static constexpr int32_t kStatsChannel = 3;
+
+  /// Field names in the commit context JSON object (context_channel).
+  /// The context is a JSON object serialized as VARBINARY, e.g.:
+  ///   {"taskId":"...", "lifespan":"TaskWide",
+  ///    "pageSinkCommitStrategy":"NO_COMMIT", "lastPage":true}
+  static constexpr std::string_view kLifeSpanContextKey = "lifespan";
+  static constexpr std::string_view kTaskIdContextKey = "taskId";
+  static constexpr std::string_view kCommitStrategyContextKey =
+      "pageSinkCommitStrategy";
+  static constexpr std::string_view klastPageContextKey = "lastPage";
+
+  static RowTypePtr outputType(
+      const std::optional<core::ColumnStatsSpec>& columnStatsSpec);
+
+  /// Returns true if row 'index' in 'output' is a statistics row (both row
+  /// count and fragment channels are NULL). Statistics rows carry aggregated
+  /// per-column stats; data rows carry row counts and/or file fragments.
+  static bool isStatisticsRow(
+      const RowVectorPtr& output,
+      vector_size_t index = 0);
+
+  /// Returns the parsed commit context from table writer 'output'.
+  static folly::dynamic getTableCommitContext(const RowVectorPtr& output);
+
+  /// Returns the sum of row counts from table writer 'output'.
+  static int64_t getRowCount(const RowVectorPtr& output);
+
+  /// Creates the statistics output.
+  /// Statistics page layout (aggregate by partition):
+  /// row     fragments     context     [partition]   stats1     stats2 ...
+  /// null       null          X          [X]            X          X
+  /// null       null          X          [X]            X          X
+  static RowVectorPtr createAggregationStatsOutput(
+      RowTypePtr outputType,
+      RowVectorPtr aggregationOutput,
+      StringView tableCommitContext,
+      velox::memory::MemoryPool* pool);
+};
+
+} // namespace facebook::velox::core
diff --git a/velox/core/tests/CMakeLists.txt b/velox/core/tests/CMakeLists.txt
index 19cdc3611c6..d2c87a04bca 100644
--- a/velox/core/tests/CMakeLists.txt
+++ b/velox/core/tests/CMakeLists.txt
@@ -16,6 +16,7 @@ add_executable(
   velox_core_test
   ConstantTypedExprTest.cpp
   PlanFragmentTest.cpp
+  PlanNodeBuilderTest.cpp
   PlanNodeTest.cpp
   QueryConfigTest.cpp
   QueryCtxTest.cpp
@@ -39,11 +40,18 @@ target_link_libraries(
     GTest::gtest_main
 )
 
+add_executable(velox_query_config_provider_test QueryConfigProviderTest.cpp)
+add_test(velox_query_config_provider_test velox_query_config_provider_test)
+target_link_libraries(
+  velox_query_config_provider_test
+  PRIVATE velox_query_config_provider velox_core GTest::gtest GTest::gtest_main
+)
+
 add_executable(velox_core_plan_consistency_checker_test PlanConsistencyCheckerTest.cpp)
 
 add_test(velox_core_plan_consistency_checker_test velox_core_plan_consistency_checker_test)
 
 target_link_libraries(
   velox_core_plan_consistency_checker_test
-  PRIVATE velox_core GTest::gtest GTest::gtest_main
+  PRIVATE velox_core velox_exec GTest::gtest GTest::gtest_main
 )
diff --git a/velox/core/tests/ConstantTypedExprTest.cpp b/velox/core/tests/ConstantTypedExprTest.cpp
index 3d067f9ede8..2107d373e8a 100644
--- a/velox/core/tests/ConstantTypedExprTest.cpp
+++ b/velox/core/tests/ConstantTypedExprTest.cpp
@@ -15,15 +15,179 @@
  */
 #include <gtest/gtest.h>
 
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/memory/Memory.h"
 #include "velox/core/Expressions.h"
 #include "velox/functions/prestosql/types/HyperLogLogType.h"
 #include "velox/functions/prestosql/types/JsonType.h"
 #include "velox/functions/prestosql/types/TDigestType.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/type/Variant.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
 
 namespace facebook::velox::core::test {
 
-TEST(ConstantTypedExprTest, null) {
+namespace {
+struct TestOpaqueStruct {
+  int value;
+  std::string name;
+
+  TestOpaqueStruct(int v, std::string n) : value(v), name(std::move(n)) {}
+
+  bool operator==(const TestOpaqueStruct& other) const {
+    return value == other.value && name == other.name;
+  }
+};
+
+} // namespace
+
+class ConstantTypedExprTest : public ::testing::Test,
+                              public velox::test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    pool_ = memory::memoryManager()->addLeafPool();
+
+    // Register serialization/deserialization functions needed for the tests
+    Type::registerSerDe();
+    ITypedExpr::registerSerDe();
+
+    // Register OPAQUE type serialization for TestOpaqueStruct
+    static folly::once_flag once;
+    folly::call_once(once, []() {
+      OpaqueType::registerSerialization<TestOpaqueStruct>(
+          "TestOpaqueStruct",
+          [](const std::shared_ptr<TestOpaqueStruct>& obj) -> std::string {
+            return folly::json::serialize(
+                folly::dynamic::object("value", obj->value)("name", obj->name),
+                folly::json::serialization_opts{});
+          },
+          [](const std::string& json) -> std::shared_ptr<TestOpaqueStruct> {
+            folly::dynamic obj = folly::parseJson(json);
+            return std::make_shared<TestOpaqueStruct>(
+                obj["value"].asInt(), obj["name"].asString());
+          });
+    });
+  }
+
+  // Helper functions
+  std::shared_ptr<ConstantTypedExpr> createVariantExpr(
+      const TypePtr& type,
+      const Variant& value) {
+    return std::make_shared<ConstantTypedExpr>(type, value);
+  }
+
+  std::shared_ptr<ConstantTypedExpr> createNullVariantExpr(
+      const TypePtr& type) {
+    return std::make_shared<ConstantTypedExpr>(
+        type, variant::null(type->kind()));
+  }
+
+  std::shared_ptr<ConstantTypedExpr> createVectorExpr(const VectorPtr& vector) {
+    return std::make_shared<ConstantTypedExpr>(vector);
+  }
+
+  template <typename T>
+  VectorPtr createConstantVector(const TypePtr& type, const T& value) {
+    return BaseVector::createConstant(type, variant(value), 1, pool_.get());
+  }
+
+  VectorPtr createNullConstantVector(const TypePtr& type) {
+    return BaseVector::createNullConstant(type, 1, pool_.get());
+  }
+
+  // Test Data
+  struct TestValues {
+    variant nullValue;
+    std::vector<variant> nonNullValues;
+
+    TestValues(TypeKind kind) : nullValue(variant::null(kind)) {}
+  };
+
+  TestValues getTestValues(TypeKind kind) {
+    TestValues values(kind);
+
+    switch (kind) {
+      case TypeKind::BOOLEAN:
+        values.nonNullValues = {variant(true), variant(false)};
+        break;
+      case TypeKind::TINYINT:
+        values.nonNullValues = {
+            variant(int8_t(0)), variant(int8_t(127)), variant(int8_t(-128))};
+        break;
+      case TypeKind::SMALLINT:
+        values.nonNullValues = {
+            variant(int16_t(0)),
+            variant(int16_t(32767)),
+            variant(int16_t(-32768))};
+        break;
+      case TypeKind::INTEGER:
+        values.nonNullValues = {
+            variant(int32_t(0)),
+            variant(int32_t(2147483647)),
+            variant(int32_t(-2147483648))};
+        break;
+      case TypeKind::BIGINT:
+        values.nonNullValues = {
+            variant(int64_t(0)),
+            variant(int64_t(9223372036854775807LL)),
+            variant(int64_t(-9223372036854775808ULL))};
+        break;
+      case TypeKind::REAL:
+        values.nonNullValues = {variant(0.0f), variant(3.14f), variant(-1.5f)};
+        break;
+      case TypeKind::DOUBLE:
+        values.nonNullValues = {
+            variant(0.0), variant(3.14159), variant(-2.71828)};
+        break;
+      case TypeKind::VARCHAR:
+        values.nonNullValues = {
+            variant(""), variant("hello"), variant("test string")};
+        break;
+      case TypeKind::VARBINARY:
+        values.nonNullValues = {
+            variant::binary(""),
+            variant::binary("binary data"),
+            variant::binary("\x00\x01\x02")};
+        break;
+      case TypeKind::TIMESTAMP:
+        values.nonNullValues = {
+            variant(Timestamp(0, 0)),
+            variant(Timestamp(1234567890, 123456789))};
+        break;
+      case TypeKind::HUGEINT:
+        values.nonNullValues = {
+            variant(int128_t(0)),
+            variant(int128_t(123)),
+            variant(int128_t(-456))};
+        break;
+      default:
+        // For complex types, we'll handle them within individual tests.
+        break;
+    }
+    return values;
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_;
+  const std::vector<TypeKind> scalarTypes_ = {
+      TypeKind::BOOLEAN,
+      TypeKind::TINYINT,
+      TypeKind::SMALLINT,
+      TypeKind::INTEGER,
+      TypeKind::BIGINT,
+      TypeKind::REAL,
+      TypeKind::DOUBLE,
+      TypeKind::VARCHAR,
+      TypeKind::VARBINARY,
+      TypeKind::TIMESTAMP,
+      TypeKind::HUGEINT};
+};
+
+TEST_F(ConstantTypedExprTest, null) {
   auto makeNull = [](const TypePtr& type) {
     return std::make_shared<ConstantTypedExpr>(
         type, variant::null(type->kind()));
@@ -67,4 +231,386 @@ TEST(ConstantTypedExprTest, null) {
       *makeNull(ROW({"x", "y"}, {INTEGER(), REAL()})));
 }
 
+TEST_F(ConstantTypedExprTest, hashScalarTypes) {
+  // Tests the consistency of the hash value returned by the ConstantTypedExpr
+  // between its construction using variant and Velox vectors.
+  for (auto kind : scalarTypes_) {
+    auto type = createScalarType(kind);
+    auto testValues = getTestValues(kind);
+
+    // null values
+    auto nullVariantExpr = createNullVariantExpr(type);
+    auto nullVectorExpr = createVectorExpr(createNullConstantVector(type));
+    EXPECT_EQ(nullVariantExpr->hash(), nullVectorExpr->hash())
+        << "Hash mismatch for null " << TypeKindName::toName(kind);
+
+    // non-null values
+    for (const auto& value : testValues.nonNullValues) {
+      auto variantExpr = std::make_shared<ConstantTypedExpr>(type, value);
+      auto vectorExpr = createVectorExpr(
+          BaseVector::createConstant(type, value, 1, pool_.get()));
+      EXPECT_EQ(variantExpr->hash(), vectorExpr->hash())
+          << "Hash mismatch for non-null " << TypeKindName::toName(kind)
+          << " with value " << value.toJson(type);
+    }
+  }
+}
+
+TEST_F(ConstantTypedExprTest, hashComplexTypes) {
+  // ARRAY
+  auto arrayType = ARRAY(INTEGER());
+
+  // null values
+  auto nullArrayVariantExpr = createNullVariantExpr(arrayType);
+  auto nullArrayVectorExpr =
+      createVectorExpr(createNullConstantVector(arrayType));
+  EXPECT_EQ(nullArrayVariantExpr->hash(), nullArrayVectorExpr->hash())
+      << "Hash mismatch for null ARRAY variant vs vector";
+
+  // non-null values
+  auto arrayVariant = Variant::array({1, 2, 3});
+  auto arrayVariantExpr =
+      std::make_shared<ConstantTypedExpr>(arrayType, arrayVariant);
+  auto arrayVector = makeArrayVector<int32_t>({{1, 2, 3}});
+  auto arrayVectorExpr = createVectorExpr(arrayVector);
+  EXPECT_EQ(arrayVariantExpr->hash(), arrayVectorExpr->hash())
+      << "Hash mismatch for non-null ARRAY variant vs vector";
+
+  // MAP
+  auto mapType = MAP(VARCHAR(), INTEGER());
+
+  // null values
+  auto nullMapVariantExpr = createNullVariantExpr(mapType);
+  auto nullMapVectorExpr = createVectorExpr(createNullConstantVector(mapType));
+  EXPECT_EQ(nullMapVariantExpr->hash(), nullMapVectorExpr->hash())
+      << "Hash mismatch for null MAP variant vs vector";
+
+  // non-null values
+  std::map<Variant, Variant> mapData = {{"key1", 1}, {"key2", 2}};
+  auto mapVariant = Variant::map(mapData);
+  auto mapVariantExpr =
+      std::make_shared<ConstantTypedExpr>(mapType, mapVariant);
+  auto mapVector =
+      makeMapVector<std::string, int32_t>({{{"key1", 1}, {"key2", 2}}});
+  auto mapVectorExpr = createVectorExpr(mapVector);
+  EXPECT_EQ(mapVariantExpr->hash(), mapVectorExpr->hash())
+      << "Hash mismatch for non-null MAP variant vs vector";
+
+  // ROW
+  auto rowType = ROW({{"a", INTEGER()}, {"b", VARCHAR()}});
+
+  // null values
+  auto nullRowVariantExpr = createNullVariantExpr(rowType);
+  auto nullRowVectorExpr = createVectorExpr(createNullConstantVector(rowType));
+  EXPECT_EQ(nullRowVariantExpr->hash(), nullRowVectorExpr->hash())
+      << "Hash mismatch for null ROW variant vs vector";
+
+  // non-null values
+  auto rowVariant = Variant::row({42, "hello"});
+  auto rowVariantExpr =
+      std::make_shared<ConstantTypedExpr>(rowType, rowVariant);
+  auto rowVector = makeRowVector(
+      {makeFlatVector<int32_t>({42}), makeFlatVector<std::string>({"hello"})});
+  auto rowVectorExpr = createVectorExpr(rowVector);
+  EXPECT_EQ(rowVariantExpr->hash(), rowVectorExpr->hash())
+      << "Hash mismatch for non-null ROW variant vs vector";
+
+  // OPAQUE
+  auto testObj = std::make_shared<TestOpaqueStruct>(42, "test_data");
+  auto opaqueType = OPAQUE<TestOpaqueStruct>();
+
+  // null values
+  auto nullOpaqueVariantExpr = createNullVariantExpr(opaqueType);
+  auto nullOpaqueVectorExpr =
+      createVectorExpr(createNullConstantVector(opaqueType));
+  EXPECT_EQ(nullOpaqueVariantExpr->hash(), nullOpaqueVectorExpr->hash())
+      << "Hash mismatch for null OPAQUE";
+
+  // non-null values
+  auto opaqueVariant = Variant::opaque(testObj);
+  auto opaqueVariantExpr =
+      std::make_shared<ConstantTypedExpr>(opaqueType, opaqueVariant);
+  auto opaqueVectorExpr = createVectorExpr(
+      BaseVector::createConstant(opaqueType, opaqueVariant, 1, pool_.get()));
+  EXPECT_EQ(opaqueVariantExpr->hash(), opaqueVectorExpr->hash())
+      << "Hash mismatch for non-null OPAQUE";
+}
+
+TEST_F(ConstantTypedExprTest, serdeScalarTypes) {
+  // Test serialize/deserialize APIs for scalar types to ensure backward
+  // compatibility.
+  for (auto kind : scalarTypes_) {
+    auto type = createScalarType(kind);
+    auto testValues = getTestValues(kind);
+
+    // null values
+    auto nullVariantExpr = createNullVariantExpr(type);
+    auto serialized = nullVariantExpr->serialize();
+    auto deserialized = ConstantTypedExpr::create(serialized, pool_.get());
+    EXPECT_TRUE(*nullVariantExpr == *deserialized)
+        << "Serialize/deserialize mismatch for null variant "
+        << TypeKindName::toName(kind);
+    auto nullVectorExpr = createVectorExpr(createNullConstantVector(type));
+    serialized = nullVectorExpr->serialize();
+    deserialized = ConstantTypedExpr::create(serialized, pool_.get());
+    EXPECT_TRUE(*nullVectorExpr == *deserialized)
+        << "Serialize/deserialize mismatch for null vector "
+        << TypeKindName::toName(kind);
+
+    // non-null values
+    for (const auto& value : testValues.nonNullValues) {
+      auto variantExpr = std::make_shared<ConstantTypedExpr>(type, value);
+      serialized = variantExpr->serialize();
+      deserialized = ConstantTypedExpr::create(serialized, pool_.get());
+      EXPECT_TRUE(*variantExpr == *deserialized)
+          << "Serialize/deserialize mismatch for variant "
+          << TypeKindName::toName(kind);
+
+      auto vectorExpr = createVectorExpr(
+          BaseVector::createConstant(type, value, 1, pool_.get()));
+      serialized = vectorExpr->serialize();
+      deserialized = ConstantTypedExpr::create(serialized, pool_.get());
+      EXPECT_TRUE(*vectorExpr == *deserialized)
+          << "Serialize/deserialize mismatch for vector "
+          << TypeKindName::toName(kind) << " with value " << value.toJson(type);
+    }
+  }
+}
+
+TEST_F(ConstantTypedExprTest, serdeComplexTypes) {
+  // ARRAY
+  auto arrayType = ARRAY(INTEGER());
+
+  // null values
+  auto nullArrayVariantExpr = createNullVariantExpr(arrayType);
+  auto serialized = nullArrayVariantExpr->serialize();
+  auto deserialized = ConstantTypedExpr::create(serialized, nullptr);
+  EXPECT_TRUE(*nullArrayVariantExpr == *deserialized)
+      << "Serialize/deserialize mismatch for null ARRAY variant";
+  auto nullArrayVectorExpr =
+      createVectorExpr(createNullConstantVector(arrayType));
+  serialized = nullArrayVectorExpr->serialize();
+  deserialized = ConstantTypedExpr::create(serialized, pool_.get());
+  EXPECT_TRUE(*nullArrayVectorExpr == *deserialized)
+      << "Serialize/deserialize mismatch for null ARRAY vector";
+
+  // non-null values
+  auto arrayVariant = Variant::array({1, 2, 3});
+  auto arrayVariantExpr =
+      std::make_shared<ConstantTypedExpr>(arrayType, arrayVariant);
+  serialized = arrayVariantExpr->serialize();
+  deserialized = ConstantTypedExpr::create(serialized, nullptr);
+  EXPECT_TRUE(*arrayVariantExpr == *deserialized)
+      << "Serialize/deserialize mismatch for ARRAY variant with data";
+  auto arrayVector = makeArrayVector<int32_t>({{1, 2, 3}});
+  auto arrayVectorExpr = createVectorExpr(arrayVector);
+  serialized = arrayVectorExpr->serialize();
+  deserialized = ConstantTypedExpr::create(serialized, pool_.get());
+  EXPECT_TRUE(*arrayVectorExpr == *deserialized)
+      << "Serialize/deserialize mismatch for ARRAY vector with data";
+
+  // MAP
+  auto mapType = MAP(VARCHAR(), INTEGER());
+  // null values
+  auto nullMapVariantExpr = createNullVariantExpr(mapType);
+  serialized = nullMapVariantExpr->serialize();
+  deserialized = ConstantTypedExpr::create(serialized, nullptr);
+  EXPECT_TRUE(*nullMapVariantExpr == *deserialized)
+      << "Serialize/deserialize mismatch for null MAP variant";
+
+  // non-null values
+  std::map<Variant, Variant> mapData = {{"key1", 1}, {"key2", 2}};
+  auto mapVariant = Variant::map(mapData);
+  auto mapVariantExpr =
+      std::make_shared<ConstantTypedExpr>(mapType, mapVariant);
+  serialized = mapVariantExpr->serialize();
+  deserialized = ConstantTypedExpr::create(serialized, nullptr);
+  EXPECT_TRUE(*mapVariantExpr == *deserialized)
+      << "Serialize/deserialize mismatch for MAP variant with data";
+
+  // ROW
+  auto rowType = ROW({{"a", INTEGER()}, {"b", VARCHAR()}});
+  // null values
+  auto nullRowVariantExpr = createNullVariantExpr(rowType);
+  serialized = nullRowVariantExpr->serialize();
+  deserialized = ConstantTypedExpr::create(serialized, nullptr);
+  EXPECT_TRUE(*nullRowVariantExpr == *deserialized)
+      << "Serialize/deserialize mismatch for null ROW variant";
+
+  // non-null values
+  auto rowVariant = Variant::row({42, "hello"});
+  auto rowVariantExpr =
+      std::make_shared<ConstantTypedExpr>(rowType, rowVariant);
+  serialized = rowVariantExpr->serialize();
+  deserialized = ConstantTypedExpr::create(serialized, nullptr);
+  EXPECT_TRUE(*rowVariantExpr == *deserialized)
+      << "Serialize/deserialize mismatch for ROW variant with data";
+
+  // OPAQUE
+  auto opaqueType = OPAQUE<TestOpaqueStruct>();
+
+  // null values
+  auto nullOpaqueVariantExpr = createNullVariantExpr(opaqueType);
+  serialized = nullOpaqueVariantExpr->serialize();
+  deserialized = ConstantTypedExpr::create(serialized, nullptr);
+  EXPECT_TRUE(*nullOpaqueVariantExpr == *deserialized)
+      << "Serialize/deserialize mismatch for null OPAQUE variant";
+  auto nullOpaqueVectorExpr =
+      createVectorExpr(createNullConstantVector(opaqueType));
+  serialized = nullOpaqueVectorExpr->serialize();
+  deserialized = ConstantTypedExpr::create(serialized, pool_.get());
+  EXPECT_TRUE(*nullOpaqueVectorExpr == *deserialized)
+      << "Serialize/deserialize mismatch for null OPAQUE vector";
+
+  // non-null values
+  auto testObj = std::make_shared<TestOpaqueStruct>(42, "test_data");
+  auto opaqueVariant = Variant::opaque(testObj);
+  auto opaqueVariantExpr =
+      std::make_shared<ConstantTypedExpr>(opaqueType, opaqueVariant);
+  serialized = opaqueVariantExpr->serialize();
+  deserialized = ConstantTypedExpr::create(serialized, nullptr);
+  auto actualObj = static_pointer_cast<const ConstantTypedExpr>(deserialized)
+                       ->value()
+                       .value<TypeKind::OPAQUE>()
+                       .obj;
+  EXPECT_EQ(*testObj, *static_pointer_cast<TestOpaqueStruct>(actualObj));
+}
+
+TEST_F(ConstantTypedExprTest, toStringScalarTypes) {
+  for (auto kind : scalarTypes_) {
+    auto type = createScalarType(kind);
+    auto testValues = getTestValues(kind);
+
+    // null values
+    auto nullVariantExpr = createNullVariantExpr(type);
+    auto nullVectorExpr = createVectorExpr(createNullConstantVector(type));
+    EXPECT_EQ(nullVariantExpr->toString(), nullVectorExpr->toString())
+        << "toString mismatch for null " << TypeKindName::toName(kind);
+
+    // non-null values
+    for (const auto& value : testValues.nonNullValues) {
+      auto variantExpr = std::make_shared<ConstantTypedExpr>(type, value);
+      auto vectorExpr = createVectorExpr(
+          BaseVector::createConstant(type, value, 1, pool_.get()));
+      EXPECT_EQ(variantExpr->toString(), vectorExpr->toString())
+          << "toString mismatch for " << TypeKindName::toName(kind)
+          << " with value " << value.toJson(type);
+    }
+  }
+}
+
+TEST_F(ConstantTypedExprTest, toStringComplexTypes) {
+  // ARRAY
+  auto arrayType = ARRAY(INTEGER());
+
+  // null values
+  auto nullArrayVariantExpr = createNullVariantExpr(arrayType);
+  auto nullArrayVectorExpr =
+      createVectorExpr(createNullConstantVector(arrayType));
+  EXPECT_EQ(nullArrayVariantExpr->toString(), nullArrayVectorExpr->toString())
+      << "toString mismatch for null ARRAY";
+
+  // non-null values
+  auto arrayVariant = Variant::array({1, 2, 3});
+  auto arrayVariantExpr =
+      std::make_shared<ConstantTypedExpr>(arrayType, arrayVariant);
+  auto arrayVector = makeArrayVector<int32_t>({{1, 2, 3}});
+  auto arrayVectorExpr = createVectorExpr(arrayVector);
+  EXPECT_EQ(arrayVariantExpr->toString(), arrayVectorExpr->toString())
+      << "toString mismatch for ARRAY variant vs vector";
+
+  // MAP
+  auto mapType = MAP(VARCHAR(), INTEGER());
+
+  // null values
+  auto nullMapVariantExpr = createNullVariantExpr(mapType);
+  auto nullMapVectorExpr = createVectorExpr(createNullConstantVector(mapType));
+  EXPECT_EQ(nullMapVariantExpr->toString(), nullMapVectorExpr->toString())
+      << "toString mismatch for null MAP";
+
+  // non-null values
+  std::map<Variant, Variant> mapData = {{"key1", 1}, {"key2", 2}};
+  auto mapVariant = Variant::map(mapData);
+  auto mapVariantExpr =
+      std::make_shared<ConstantTypedExpr>(mapType, mapVariant);
+  auto mapVector =
+      makeMapVector<std::string, int32_t>({{{"key1", 1}, {"key2", 2}}});
+  auto mapVectorExpr = createVectorExpr(mapVector);
+  EXPECT_EQ(mapVariantExpr->toString(), mapVectorExpr->toString())
+      << "toString mismatch for MAP variant vs vector";
+
+  // ROW
+  auto rowType = ROW({{"a", INTEGER()}, {"b", VARCHAR()}});
+
+  // null values
+  auto nullRowVariantExpr = createNullVariantExpr(rowType);
+  auto nullRowVectorExpr = createVectorExpr(createNullConstantVector(rowType));
+  EXPECT_EQ(nullRowVariantExpr->toString(), nullRowVectorExpr->toString())
+      << "toString mismatch for null ROW";
+
+  // non-null values
+  auto rowVariant = Variant::row({42, "hello"});
+  auto rowVariantExpr =
+      std::make_shared<ConstantTypedExpr>(rowType, rowVariant);
+  auto rowVector = makeRowVector(
+      {makeFlatVector<int32_t>({42}), makeFlatVector<std::string>({"hello"})});
+  auto rowVectorExpr = createVectorExpr(rowVector);
+  EXPECT_EQ(rowVariantExpr->toString(), rowVectorExpr->toString())
+      << "toString mismatch for ROW variant vs vector";
+
+  // OPAQUE
+  auto opaqueType = OPAQUE<TestOpaqueStruct>();
+
+  // null values
+  auto nullOpaqueVariantExpr = createNullVariantExpr(opaqueType);
+  auto nullOpaqueVectorExpr =
+      createVectorExpr(createNullConstantVector(opaqueType));
+  EXPECT_EQ(nullOpaqueVariantExpr->toString(), nullOpaqueVectorExpr->toString())
+      << "toString mismatch for null OPAQUE";
+
+  // non-null values
+  auto testObj = std::make_shared<TestOpaqueStruct>(42, "test_data");
+  auto opaqueVariant = Variant::opaque(testObj);
+  auto opaqueVariantExpr =
+      std::make_shared<ConstantTypedExpr>(opaqueType, opaqueVariant);
+  auto opaqueVectorExpr = createVectorExpr(
+      BaseVector::createConstant(opaqueType, opaqueVariant, 1, pool_.get()));
+  EXPECT_EQ(opaqueVariantExpr->toString(), opaqueVectorExpr->toString())
+      << "toString mismatch for OPAQUE variant vs vector";
+}
+
+TEST_F(ConstantTypedExprTest, variantTypeCheck) {
+  auto testVariantExpr = [&](const Variant& value,
+                             const TypePtr& type,
+                             const TypePtr& expectedType) {
+    VELOX_ASSERT_THROW(
+        createVariantExpr(type, value),
+        fmt::format(
+            "Expression type {} does not match variant type {}",
+            type->toString(),
+            expectedType->toString()));
+    if (type->isPrimitiveType()) {
+      VELOX_ASSERT_THROW(
+          createVariantExpr(type, Variant::null(expectedType->kind())),
+          fmt::format(
+              "Expression type {} does not match variant type {}",
+              type->toString(),
+              expectedType->toString()));
+    } else {
+      ASSERT_NO_THROW(
+          createVariantExpr(type, Variant::null(expectedType->kind())));
+    }
+  };
+
+  testVariantExpr("abc", INTEGER(), VARCHAR());
+  testVariantExpr(variant(123LL), INTEGER(), BIGINT());
+  testVariantExpr(2.0, BIGINT(), DOUBLE());
+  testVariantExpr(
+      variant::array({1, 2, 3}), ARRAY(VARCHAR()), ARRAY(INTEGER()));
+  testVariantExpr(
+      variant::map({{2.0, "xyz"}}),
+      MAP(INTEGER(), VARCHAR()),
+      MAP(DOUBLE(), VARCHAR()));
+}
+
 } // namespace facebook::velox::core::test
diff --git a/velox/core/tests/PlanConsistencyCheckerTest.cpp b/velox/core/tests/PlanConsistencyCheckerTest.cpp
index 41c7992b7dd..33b99e191da 100644
--- a/velox/core/tests/PlanConsistencyCheckerTest.cpp
+++ b/velox/core/tests/PlanConsistencyCheckerTest.cpp
@@ -17,6 +17,7 @@
 
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/core/PlanConsistencyChecker.h"
+#include "velox/parse/PlanNodeIdGenerator.h"
 
 namespace facebook::velox::core {
 
@@ -26,6 +27,16 @@ class PlanConsistencyCheckerTest : public testing::Test {
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   }
+
+  void SetUp() override {
+    idGenerator_.reset();
+  }
+
+  std::string nextId() {
+    return idGenerator_.next();
+  }
+
+  PlanNodeIdGenerator idGenerator_;
 };
 
 TypedExprPtr Lit(Variant value) {
@@ -33,28 +44,28 @@ TypedExprPtr Lit(Variant value) {
   return std::make_shared<ConstantTypedExpr>(std::move(type), std::move(value));
 }
 
-TypedExprPtr Col(TypePtr type, std::string name) {
+FieldAccessTypedExprPtr Col(TypePtr type, std::string name) {
   return std::make_shared<FieldAccessTypedExpr>(
       std::move(type), std::move(name));
 }
 
 TEST_F(PlanConsistencyCheckerTest, filter) {
   auto valuesNode =
-      std::make_shared<ValuesNode>("0", std::vector<RowVectorPtr>{});
+      std::make_shared<ValuesNode>(nextId(), std::vector<RowVectorPtr>{});
 
   auto projectNode = std::make_shared<ProjectNode>(
-      "2",
+      nextId(),
       std::vector<std::string>{"a", "b", "c"},
       std::vector<TypedExprPtr>{Lit(true), Lit(1), Lit(0.1)},
       valuesNode);
 
   auto filterNode =
-      std::make_shared<FilterNode>("1", Col(BOOLEAN(), "a"), projectNode);
+      std::make_shared<FilterNode>(nextId(), Col(BOOLEAN(), "a"), projectNode);
   ASSERT_NO_THROW(PlanConsistencyChecker::check(filterNode));
 
   // Wrong type.
   filterNode =
-      std::make_shared<FilterNode>("1", Col(BOOLEAN(), "b"), projectNode);
+      std::make_shared<FilterNode>(nextId(), Col(BOOLEAN(), "b"), projectNode);
 
   VELOX_ASSERT_THROW(
       PlanConsistencyChecker::check(filterNode),
@@ -62,42 +73,402 @@ TEST_F(PlanConsistencyCheckerTest, filter) {
 
   // Wrong name.
   filterNode =
-      std::make_shared<FilterNode>("1", Col(BOOLEAN(), "x"), projectNode);
+      std::make_shared<FilterNode>(nextId(), Col(BOOLEAN(), "x"), projectNode);
 
   VELOX_ASSERT_THROW(
       PlanConsistencyChecker::check(filterNode), "Field not found: x");
+
+  // Non-existent column referenced in a lambda expression.
+  filterNode = std::make_shared<FilterNode>(
+      nextId(),
+      std::make_shared<CallTypedExpr>(
+          BOOLEAN(),
+          "any_match",
+          Lit(Variant::array({1, 2, 3})),
+          std::make_shared<LambdaTypedExpr>(
+              ROW("x", INTEGER()),
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(),
+                  "lt",
+                  Col(INTEGER(), "x"),
+                  Col(INTEGER(), "blah")))),
+      projectNode);
+
+  VELOX_ASSERT_THROW(
+      PlanConsistencyChecker::check(filterNode), "Field not found: blah");
 }
 
 TEST_F(PlanConsistencyCheckerTest, project) {
   auto valuesNode =
-      std::make_shared<ValuesNode>("0", std::vector<RowVectorPtr>{});
+      std::make_shared<ValuesNode>(nextId(), std::vector<RowVectorPtr>{});
+
+  {
+    auto projectNode = std::make_shared<ProjectNode>(
+        nextId(),
+        std::vector<std::string>{"a", "b", "c"},
+        std::vector<TypedExprPtr>{Lit(true), Lit(1), Lit(0.1)},
+        valuesNode);
+    ASSERT_NO_THROW(PlanConsistencyChecker::check(projectNode));
+  }
+
+  {
+    // Duplicate output name in the root ProjectNode is allowed. This is used to
+    // apply user-specified column aliases (e.g. SELECT 1 AS x, 2 AS x).
+    auto projectNode = std::make_shared<ProjectNode>(
+        nextId(),
+        std::vector<std::string>{"a", "a", "c"},
+        std::vector<TypedExprPtr>{Lit(true), Lit(1), Lit(0.1)},
+        valuesNode);
+    ASSERT_NO_THROW(PlanConsistencyChecker::check(projectNode));
+
+    // Duplicate output name in a non-root ProjectNode is not allowed.
+    auto outputProject = std::make_shared<ProjectNode>(
+        nextId(),
+        std::vector<std::string>{"x", "y", "z"},
+        std::vector<TypedExprPtr>{
+            Col(BOOLEAN(), "a"), Col(BOOLEAN(), "a"), Col(DOUBLE(), "c")},
+        projectNode);
+
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(outputProject),
+        "Duplicate output column: a");
+  }
+
+  // Wrong column name.
+  {
+    auto projectNode = std::make_shared<ProjectNode>(
+        nextId(),
+        std::vector<std::string>{"a", "a", "c"},
+        std::vector<TypedExprPtr>{Lit(true), Col(REAL(), "x"), Lit(0.1)},
+        valuesNode);
+
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(projectNode), "Field not found: x");
+  }
+}
+
+TEST_F(PlanConsistencyCheckerTest, aggregation) {
+  auto valuesNode =
+      std::make_shared<ValuesNode>(nextId(), std::vector<RowVectorPtr>{});
 
   auto projectNode = std::make_shared<ProjectNode>(
-      "2",
+      nextId(),
       std::vector<std::string>{"a", "b", "c"},
       std::vector<TypedExprPtr>{Lit(true), Lit(1), Lit(0.1)},
       valuesNode);
   ASSERT_NO_THROW(PlanConsistencyChecker::check(projectNode));
 
+  {
+    auto aggregationNode = std::make_shared<AggregationNode>(
+        nextId(),
+        AggregationNode::Step::kPartial,
+        std::vector<FieldAccessTypedExprPtr>{},
+        std::vector<FieldAccessTypedExprPtr>{},
+        std::vector<std::string>{"sum", "cnt"},
+        std::vector<AggregationNode::Aggregate>{
+            {
+                .call = std::make_shared<CallTypedExpr>(
+                    BIGINT(), "sum", Col(INTEGER(), "x")),
+                .rawInputTypes = {BIGINT()},
+            },
+            {
+                .call = std::make_shared<CallTypedExpr>(BIGINT(), "count"),
+                .rawInputTypes = {},
+            },
+        },
+        /*ignoreNullKeys=*/false,
+        /*noGroupsSpanBatches=*/false,
+        projectNode);
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(aggregationNode), "Field not found: x");
+  }
+
+  {
+    auto aggregationNode = std::make_shared<AggregationNode>(
+        nextId(),
+        AggregationNode::Step::kPartial,
+        std::vector<FieldAccessTypedExprPtr>{Col(INTEGER(), "y")},
+        std::vector<FieldAccessTypedExprPtr>{},
+        std::vector<std::string>{"sum", "cnt"},
+        std::vector<AggregationNode::Aggregate>{
+            {
+                .call = std::make_shared<CallTypedExpr>(
+                    BIGINT(), "sum", Col(INTEGER(), "b")),
+                .rawInputTypes = {BIGINT()},
+            },
+            {
+                .call = std::make_shared<CallTypedExpr>(BIGINT(), "count"),
+                .rawInputTypes = {},
+            },
+        },
+        /*ignoreNullKeys=*/false,
+        /*noGroupsSpanBatches=*/false,
+        projectNode);
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(aggregationNode), "Field not found: y");
+  }
+
+  {
+    auto aggregationNode = std::make_shared<AggregationNode>(
+        nextId(),
+        AggregationNode::Step::kPartial,
+        std::vector<FieldAccessTypedExprPtr>{},
+        std::vector<FieldAccessTypedExprPtr>{},
+        std::vector<std::string>{"sum", "cnt"},
+        std::vector<AggregationNode::Aggregate>{
+            {
+                .call = std::make_shared<CallTypedExpr>(
+                    BIGINT(), "sum", Col(INTEGER(), "b")),
+                .rawInputTypes = {BIGINT()},
+                .mask = Col(BOOLEAN(), "z"),
+            },
+            {
+                .call = std::make_shared<CallTypedExpr>(BIGINT(), "count"),
+                .rawInputTypes = {},
+            },
+        },
+        /*ignoreNullKeys=*/false,
+        /*noGroupsSpanBatches=*/false,
+        projectNode);
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(aggregationNode), "Field not found: z");
+  }
+
+  {
+    auto aggregationNode = std::make_shared<AggregationNode>(
+        nextId(),
+        AggregationNode::Step::kPartial,
+        std::vector<FieldAccessTypedExprPtr>{},
+        std::vector<FieldAccessTypedExprPtr>{},
+        std::vector<std::string>{"sum", "sum"},
+        std::vector<AggregationNode::Aggregate>{
+            {
+                .call = std::make_shared<CallTypedExpr>(
+                    BIGINT(), "sum", Col(INTEGER(), "b")),
+                .rawInputTypes = {BIGINT()},
+            },
+            {
+                .call = std::make_shared<CallTypedExpr>(BIGINT(), "count"),
+                .rawInputTypes = {},
+            },
+        },
+        /*ignoreNullKeys=*/false,
+        /*noGroupsSpanBatches=*/false,
+        projectNode);
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(aggregationNode),
+        "Duplicate output column: sum");
+  }
+}
+
+TEST_F(PlanConsistencyCheckerTest, hashJoin) {
+  auto leftValuesNode =
+      std::make_shared<ValuesNode>(nextId(), std::vector<RowVectorPtr>{});
+
+  auto leftProjectNode = std::make_shared<ProjectNode>(
+      nextId(),
+      std::vector<std::string>{"a", "b"},
+      std::vector<TypedExprPtr>{Lit(1), Lit(2)},
+      leftValuesNode);
+  ASSERT_NO_THROW(PlanConsistencyChecker::check(leftValuesNode));
+
+  auto rightValuesNode =
+      std::make_shared<ValuesNode>(nextId(), std::vector<RowVectorPtr>{});
+
+  auto rightProjectNode = std::make_shared<ProjectNode>(
+      nextId(),
+      std::vector<std::string>{"c", "d"},
+      std::vector<TypedExprPtr>{Lit(1), Lit(2)},
+      leftValuesNode);
+  ASSERT_NO_THROW(PlanConsistencyChecker::check(rightProjectNode));
+
+  // Invalid reference in the filter.
+  {
+    auto joinNode = std::make_shared<HashJoinNode>(
+        nextId(),
+        JoinType::kLeft,
+        /*nullAware=*/false,
+        std::vector<FieldAccessTypedExprPtr>{Col(INTEGER(), "a")},
+        std::vector<FieldAccessTypedExprPtr>{Col(INTEGER(), "c")},
+        std::make_shared<CallTypedExpr>(
+            BOOLEAN(), "lt", Col(INTEGER(), "b"), Col(INTEGER(), "blah")),
+        leftProjectNode,
+        rightProjectNode,
+        ROW({}));
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(joinNode),
+        "Field not found: blah. Available fields are: a, b, c, d.");
+  }
+
+  // Duplicate join condition.
+  {
+    auto joinNode = std::make_shared<HashJoinNode>(
+        nextId(),
+        JoinType::kLeft,
+        /*nullAware=*/false,
+        std::vector<FieldAccessTypedExprPtr>{
+            Col(INTEGER(), "a"), Col(INTEGER(), "a")},
+        std::vector<FieldAccessTypedExprPtr>{
+            Col(INTEGER(), "c"), Col(INTEGER(), "c")},
+        /*filter=*/nullptr,
+        leftProjectNode,
+        rightProjectNode,
+        ROW({}));
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(joinNode),
+        "Duplicate join condition: \"a\" = \"c\"");
+  }
+}
+
+TEST_F(PlanConsistencyCheckerTest, nestedLoopJoin) {
+  auto leftValuesNode =
+      std::make_shared<ValuesNode>(nextId(), std::vector<RowVectorPtr>{});
+
+  auto leftProjectNode = std::make_shared<ProjectNode>(
+      nextId(),
+      std::vector<std::string>{"a", "b"},
+      std::vector<TypedExprPtr>{Lit(1), Lit(2)},
+      leftValuesNode);
+  ASSERT_NO_THROW(PlanConsistencyChecker::check(leftValuesNode));
+
+  auto rightValuesNode =
+      std::make_shared<ValuesNode>(nextId(), std::vector<RowVectorPtr>{});
+
+  auto rightProjectNode = std::make_shared<ProjectNode>(
+      nextId(),
+      std::vector<std::string>{"c", "d"},
+      std::vector<TypedExprPtr>{Lit(1), Lit(2)},
+      leftValuesNode);
+  ASSERT_NO_THROW(PlanConsistencyChecker::check(rightProjectNode));
+
+  // Invalid reference in the filter.
+  {
+    auto joinNode = std::make_shared<NestedLoopJoinNode>(
+        nextId(),
+        JoinType::kLeft,
+        std::make_shared<CallTypedExpr>(
+            BOOLEAN(), "lt", Col(INTEGER(), "b"), Col(INTEGER(), "blah")),
+        leftProjectNode,
+        rightProjectNode,
+        ROW({}));
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(joinNode),
+        "Field not found: blah. Available fields are: a, b, c, d.");
+  }
+
   // Duplicate output name.
-  projectNode = std::make_shared<ProjectNode>(
-      "2",
-      std::vector<std::string>{"a", "a", "c"},
-      std::vector<TypedExprPtr>{Lit(true), Lit(1), Lit(0.1)},
-      valuesNode);
+  {
+    auto joinNode = std::make_shared<NestedLoopJoinNode>(
+        nextId(),
+        leftProjectNode,
+        rightProjectNode,
+        ROW({"a", "c", "a"}, INTEGER()));
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(joinNode), "Duplicate output column: a");
+  }
+}
 
-  VELOX_ASSERT_THROW(
-      PlanConsistencyChecker::check(projectNode), "Duplicate output column: a");
+namespace {
+class TestTableHandle : public connector::ConnectorTableHandle {
+ public:
+  explicit TestTableHandle(std::string connectorId, std::string name)
+      : connector::ConnectorTableHandle(std::move(connectorId)),
+        name_{std::move(name)} {}
 
-  // Wrong column name.
-  projectNode = std::make_shared<ProjectNode>(
-      "2",
-      std::vector<std::string>{"a", "a", "c"},
-      std::vector<TypedExprPtr>{Lit(true), Col(REAL(), "x"), Lit(0.1)},
-      valuesNode);
+  const std::string& name() const override {
+    return name_;
+  }
 
-  VELOX_ASSERT_THROW(
-      PlanConsistencyChecker::check(projectNode), "Field not found: x");
+ private:
+  const std::string name_;
+};
+
+class TestColumnHandle : public connector::ColumnHandle {
+ public:
+  explicit TestColumnHandle(std::string name) : name_{std::move(name)} {}
+
+  const std::string& name() const override {
+    return name_;
+  }
+
+ private:
+  const std::string name_;
+};
+} // namespace
+
+TEST_F(PlanConsistencyCheckerTest, tableScan) {
+  // Empty output column name.
+  {
+    auto scanNode = std::make_shared<TableScanNode>(
+        nextId(),
+        ROW({"", "b"}, INTEGER()),
+        std::make_shared<TestTableHandle>("test", "t"),
+        connector::ColumnHandleMap{});
+
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(scanNode),
+        "Output column name cannot be empty");
+  }
+
+  // Duplicate output column name.
+  {
+    auto scanNode = std::make_shared<TableScanNode>(
+        nextId(),
+        ROW({"a", "b", "a"}, INTEGER()),
+        std::make_shared<TestTableHandle>("test", "t"),
+        connector::ColumnHandleMap{});
+
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(scanNode), "Duplicate output column: a");
+  }
+
+  // Missing assignments.
+  {
+    auto scanNode = std::make_shared<TableScanNode>(
+        nextId(),
+        ROW({"a", "b", "c"}, INTEGER()),
+        std::make_shared<TestTableHandle>("test", "t"),
+        connector::ColumnHandleMap{});
+
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(scanNode),
+        "Column assignments must match output type");
+  }
+
+  {
+    connector::ColumnHandleMap assignments{
+        {"a", std::make_shared<TestColumnHandle>("x")},
+        {"b", std::make_shared<TestColumnHandle>("y")},
+        {"blah", std::make_shared<TestColumnHandle>("z")},
+    };
+
+    auto scanNode = std::make_shared<TableScanNode>(
+        nextId(),
+        ROW({"a", "b", "c"}, INTEGER()),
+        std::make_shared<TestTableHandle>("test", "t"),
+        assignments);
+
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(scanNode),
+        "Column assignment is missing for c");
+  }
+
+  // No issues.
+  {
+    connector::ColumnHandleMap assignments{
+        {"a", std::make_shared<TestColumnHandle>("x")},
+        {"b", std::make_shared<TestColumnHandle>("y")},
+        {"c", std::make_shared<TestColumnHandle>("z")},
+    };
+
+    auto scanNode = std::make_shared<TableScanNode>(
+        nextId(),
+        ROW({"a", "b", "c"}, INTEGER()),
+        std::make_shared<TestTableHandle>("test", "t"),
+        assignments);
+
+    ASSERT_NO_THROW(PlanConsistencyChecker::check(scanNode));
+  }
 }
 
 } // namespace
diff --git a/velox/core/tests/PlanFragmentTest.cpp b/velox/core/tests/PlanFragmentTest.cpp
index 4e05757dfc1..64bc4e587df 100644
--- a/velox/core/tests/PlanFragmentTest.cpp
+++ b/velox/core/tests/PlanFragmentTest.cpp
@@ -188,7 +188,8 @@ TEST_F(PlanFragmentTest, aggregationCanSpill) {
         testData.hasPreAggregation ? preGroupingKeys : emptyPreGroupingKeys,
         testData.isDistinct ? emptyAggregateNames : aggregateNames,
         testData.isDistinct ? emptyAggregates : aggregates,
-        false,
+        /*ignoreNullKeys=*/false,
+        /*noGroupsSpanBatches=*/false,
         valueNode_);
     auto queryCtx = getSpillQueryCtx(
         testData.isSpillEnabled,
diff --git a/velox/core/tests/PlanNodeBuilderTest.cpp b/velox/core/tests/PlanNodeBuilderTest.cpp
index 840baacb712..f199083b51a 100644
--- a/velox/core/tests/PlanNodeBuilderTest.cpp
+++ b/velox/core/tests/PlanNodeBuilderTest.cpp
@@ -17,6 +17,7 @@
 
 #include "velox/common/memory/Memory.h"
 #include "velox/core/PlanNode.h"
+#include "velox/core/TableWriteTraits.h"
 #include "velox/duckdb/conversion/DuckParser.h"
 #include "velox/exec/tests/utils/AggregationResolver.h"
 #include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
@@ -62,7 +63,7 @@ class PlanNodeBuilderTest : public testing::Test, public test::VectorTestBase {
 
       core::AggregationNode::Aggregate agg;
       agg.call = std::dynamic_pointer_cast<const core::CallTypedExpr>(
-          core::Expressions::inferTypes(untypedExpr.expr, type, pool()));
+          core::Expressions::inferTypes(untypedExpr, type, pool()));
 
       if (step == core::AggregationNode::Step::kPartial ||
           step == core::AggregationNode::Step::kSingle) {
@@ -74,14 +75,14 @@ class PlanNodeBuilderTest : public testing::Test, public test::VectorTestBase {
         agg.rawInputTypes = rawInputArgs[i];
       }
 
-      VELOX_CHECK_NULL(untypedExpr.maskExpr);
-      VELOX_CHECK(!untypedExpr.distinct);
-      VELOX_CHECK(untypedExpr.orderBy.empty());
+      VELOX_CHECK_NULL(untypedExpr->filter());
+      VELOX_CHECK(!untypedExpr->isDistinct());
+      VELOX_CHECK(untypedExpr->orderBy().empty());
 
       aggs.emplace_back(agg);
 
-      if (untypedExpr.expr->alias().has_value()) {
-        names.push_back(untypedExpr.expr->alias().value());
+      if (untypedExpr->alias().has_value()) {
+        names.push_back(untypedExpr->alias().value());
       } else {
         names.push_back(fmt::format("a{}", i));
       }
@@ -358,7 +359,6 @@ TEST_F(PlanNodeBuilderTest, tableWriteNode) {
   const PlanNodeId id = "table_write_node_id";
   const RowTypePtr columns = ROW({"c0"}, {INTEGER()});
   const std::vector<std::string> columnNames{"c0"};
-  const RowTypePtr outputType = ROW({"c1"}, {BIGINT()});
   const bool hasPartitioningScheme = true;
   const auto commitStrategy = connector::CommitStrategy::kNoCommit;
 
@@ -367,6 +367,7 @@ TEST_F(PlanNodeBuilderTest, tableWriteNode) {
       std::vector<std::string>{},
       AggregationNode::Step::kPartial,
       std::vector<std::string>{"sum(c0)"});
+  const auto outputType = TableWriteTraits::outputType(statsSpec);
 
   const auto insertTableHandle =
       std::make_shared<InsertTableHandle>("connector_id", nullptr);
@@ -378,7 +379,7 @@ TEST_F(PlanNodeBuilderTest, tableWriteNode) {
     EXPECT_EQ(node->insertTableHandle(), insertTableHandle);
     EXPECT_TRUE(node->hasColumnStatsSpec());
     EXPECT_EQ(node->hasPartitioningScheme(), hasPartitioningScheme);
-    EXPECT_EQ(node->outputType(), outputType);
+    EXPECT_TRUE(node->outputType()->equivalent(*outputType));
     EXPECT_EQ(node->commitStrategy(), commitStrategy);
     EXPECT_EQ(node->sources(), std::vector<PlanNodePtr>{source_});
   };
@@ -402,19 +403,19 @@ TEST_F(PlanNodeBuilderTest, tableWriteNode) {
 
 TEST_F(PlanNodeBuilderTest, tableWriteMergeNode) {
   const PlanNodeId id = "table_write_merge_node_id";
-  const RowTypePtr outputType = ROW({"c0"}, {BIGINT()});
 
   const auto statsSpec = createStatsSpec(
-      outputType,
+      source_->outputType(),
       std::vector<std::string>{},
       AggregationNode::Step::kIntermediate,
       std::vector<std::string>{"sum(c0)"},
       {{BIGINT()}});
+  const auto outputType = TableWriteTraits::outputType(statsSpec);
 
   const auto verify =
       [&](const std::shared_ptr<const TableWriteMergeNode>& node) {
         EXPECT_EQ(node->id(), id);
-        EXPECT_EQ(node->outputType(), outputType);
+        EXPECT_TRUE(node->outputType()->equivalent(*outputType));
         EXPECT_TRUE(node->hasColumnStatsSpec());
         EXPECT_EQ(node->sources()[0], source_);
       };
@@ -496,7 +497,7 @@ TEST_F(PlanNodeBuilderTest, groupIdNode) {
 TEST_F(PlanNodeBuilderTest, exchangeNode) {
   const PlanNodeId id = "exchange_node_id";
   const RowTypePtr type = ROW({"c0"}, {BIGINT()});
-  const auto serdeKind = VectorSerde::Kind::kPresto;
+  const auto serdeKind = "Presto";
 
   const auto verify = [&](const std::shared_ptr<const ExchangeNode>& node) {
     EXPECT_EQ(node->id(), id);
@@ -518,7 +519,7 @@ TEST_F(PlanNodeBuilderTest, exchangeNode) {
 TEST_F(PlanNodeBuilderTest, mergeExchangeNode) {
   const PlanNodeId id = "merge_exchange_node_id";
   const RowTypePtr type = ROW({"c0"}, {BIGINT()});
-  const auto serdeKind = VectorSerde::Kind::kPresto;
+  const auto serdeKind = "Presto";
   const std::vector<FieldAccessTypedExprPtr> sortingKeys = {
       std::make_shared<FieldAccessTypedExpr>(BIGINT(), "c1")};
   const std::vector<SortOrder> sortingOrders = {SortOrder(true, false)};
@@ -611,7 +612,7 @@ TEST_F(PlanNodeBuilderTest, partitionedOutputNode) {
   const auto partitionFunctionSpec =
       std::make_shared<GatherPartitionFunctionSpec>();
   const RowTypePtr outputType = ROW({"c0"}, {BIGINT()});
-  const auto serdeKind = VectorSerde::Kind::kPresto;
+  const auto serdeKind = "Presto";
 
   const auto verify =
       [&](const std::shared_ptr<const PartitionedOutputNode>& node) {
@@ -670,6 +671,7 @@ TEST_F(PlanNodeBuilderTest, hashJoinNode) {
   const auto verify = [&](const std::shared_ptr<const HashJoinNode>& node) {
     EXPECT_EQ(node->id(), id);
     EXPECT_EQ(node->isNullAware(), nullAware);
+    EXPECT_FALSE(node->isNullAsValue());
     EXPECT_EQ(node->joinType(), joinType);
     EXPECT_EQ(node->leftKeys(), leftKeys);
     EXPECT_EQ(node->rightKeys(), rightKeys);
@@ -756,8 +758,8 @@ TEST_F(PlanNodeBuilderTest, indexLookupJoinNode) {
   const std::vector<IndexLookupConditionPtr> joinConditions{
       std::make_shared<BetweenIndexLookupCondition>(
           std::make_shared<FieldAccessTypedExpr>(BIGINT(), "c0"),
-          std::make_shared<ConstantTypedExpr>(BIGINT(), variant(1)),
-          std::make_shared<ConstantTypedExpr>(BIGINT(), variant(2)))};
+          std::make_shared<ConstantTypedExpr>(BIGINT(), Variant(1LL)),
+          std::make_shared<ConstantTypedExpr>(BIGINT(), Variant(2LL)))};
   const auto left =
       ValuesNode::Builder()
           .id("values_node_id_1")
@@ -768,8 +770,9 @@ TEST_F(PlanNodeBuilderTest, indexLookupJoinNode) {
       TableScanNode::Builder()
           .id("values_node_id_2")
           .outputType(ROW({"c1"}, {VARCHAR()}))
-          .tableHandle(std::make_shared<TestConnectorTableHandleForLookupJoin>(
-              "connector_id"))
+          .tableHandle(
+              std::make_shared<TestConnectorTableHandleForLookupJoin>(
+                  "connector_id"))
           .assignments({{"c1", std::make_shared<DummyColumnHandle>()}})
           .build();
   const auto outputType = ROW({"c0"}, {BIGINT()});
@@ -809,7 +812,7 @@ TEST_F(PlanNodeBuilderTest, nestedLoopJoinNode) {
   const PlanNodeId id = "nested_loop_join_node_id";
   const auto joinType = JoinType::kLeft;
   const auto joinCondition =
-      std::make_shared<ConstantTypedExpr>(BOOLEAN(), variant(true));
+      std::make_shared<ConstantTypedExpr>(BOOLEAN(), Variant(true));
   const auto left =
       ValuesNode::Builder()
           .id("values_node_id_1")
@@ -881,25 +884,35 @@ TEST_F(PlanNodeBuilderTest, spatialJoinNode) {
   const PlanNodeId id = "spatial_join_node_id";
   const auto joinType = JoinType::kInner;
   const auto joinCondition =
-      std::make_shared<ConstantTypedExpr>(BOOLEAN(), variant(true));
-  const auto left =
-      ValuesNode::Builder()
-          .id("values_node_id_1")
-          .values({makeRowVector(
-              {"c0"}, {makeFlatVector<int64_t>(std::vector<int64_t>{1})})})
-          .build();
-  const auto right =
-      ValuesNode::Builder()
-          .id("values_node_id_2")
-          .values({makeRowVector(
-              {"c1"}, {makeFlatVector<int64_t>(std::vector<int64_t>{2})})})
-          .build();
+      std::make_shared<ConstantTypedExpr>(BOOLEAN(), Variant(true));
+  const auto left = ValuesNode::Builder()
+                        .id("values_node_id_1")
+                        .values({makeRowVector(
+                            {"c0", "g0"},
+                            {makeFlatVector<int64_t>(std::vector<int64_t>{1}),
+                             makeFlatVector<std::string>(
+                                 std::vector<std::string>{"POINT(0 0)"})})})
+                        .build();
+  const auto right = ValuesNode::Builder()
+                         .id("values_node_id_2")
+                         .values({makeRowVector(
+                             {"c1", "g1"},
+                             {makeFlatVector<int64_t>(std::vector<int64_t>{2}),
+                              makeFlatVector<std::string>(
+                                  std::vector<std::string>{"POINT(0 0)"})})})
+                         .build();
   const auto outputType = ROW({"c0"}, {BIGINT()});
+  const auto probeGeom =
+      std::make_shared<FieldAccessTypedExpr>(VARCHAR(), "g0");
+  const auto buildGeom =
+      std::make_shared<FieldAccessTypedExpr>(VARCHAR(), "g1");
 
   const auto verify = [&](const std::shared_ptr<const SpatialJoinNode>& node) {
     EXPECT_EQ(node->id(), id);
     EXPECT_EQ(node->joinType(), joinType);
     EXPECT_EQ(node->joinCondition(), joinCondition);
+    EXPECT_EQ(node->probeGeometry(), probeGeom);
+    EXPECT_EQ(node->buildGeometry(), buildGeom);
     EXPECT_EQ(node->sources()[0], left);
     EXPECT_EQ(node->sources()[1], right);
     EXPECT_EQ(node->outputType(), outputType);
@@ -911,6 +924,8 @@ TEST_F(PlanNodeBuilderTest, spatialJoinNode) {
                         .joinCondition(joinCondition)
                         .left(left)
                         .right(right)
+                        .probeGeometry(probeGeom)
+                        .buildGeometry(buildGeom)
                         .outputType(outputType)
                         .build();
   verify(node);
@@ -988,6 +1003,7 @@ TEST_F(PlanNodeBuilderTest, unnestNode) {
   std::vector<std::string> unnestNames{"b"};
   std::optional<std::string> ordinalityName =
       std::make_optional<std::string>("ord");
+  std::optional<bool> splitOutput = false;
 
   const auto verify = [&](const std::shared_ptr<const UnnestNode>& node) {
     EXPECT_EQ(node->id(), id);
@@ -995,6 +1011,7 @@ TEST_F(PlanNodeBuilderTest, unnestNode) {
     EXPECT_EQ(node->unnestVariables(), unnestVariables);
     EXPECT_TRUE(node->hasOrdinality());
     EXPECT_EQ(node->sources()[0], source_);
+    EXPECT_EQ(node->splitOutput(), splitOutput);
 
     for (int i = 0; i < node->outputType()->size(); ++i) {
       if (i < replicateVariables.size()) {
@@ -1017,6 +1034,7 @@ TEST_F(PlanNodeBuilderTest, unnestNode) {
                         .unnestNames(unnestNames)
                         .ordinalityName(ordinalityName)
                         .source(source_)
+                        .splitOutput(splitOutput)
                         .build();
   verify(node);
 
diff --git a/velox/core/tests/PlanNodeTest.cpp b/velox/core/tests/PlanNodeTest.cpp
index c09d3b44cd7..30ccd68f825 100644
--- a/velox/core/tests/PlanNodeTest.cpp
+++ b/velox/core/tests/PlanNodeTest.cpp
@@ -13,10 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/core/PlanNode.h"
 #include <gtest/gtest.h>
-
 #include "velox/common/base/tests/GTestUtils.h"
-#include "velox/core/PlanNode.h"
+#include "velox/core/Expressions.h"
+#include "velox/parse/PlanNodeIdGenerator.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
@@ -85,6 +86,55 @@ TEST_F(PlanNodeTest, findFirstNode) {
       }));
 }
 
+TEST_F(PlanNodeTest, findNodeById) {
+  auto values = std::make_shared<ValuesNode>("1", std::vector<RowVectorPtr>{});
+  auto project = std::make_shared<ProjectNode>(
+      "2",
+      std::vector<std::string>{"a", "b"},
+      std::vector<TypedExprPtr>{
+          std::make_shared<CallTypedExpr>(DOUBLE(), "rand"),
+          std::make_shared<CallTypedExpr>(DOUBLE(), "rand"),
+      },
+      values);
+
+  auto filter = std::make_shared<FilterNode>(
+      "3",
+      std::make_shared<CallTypedExpr>(
+          BOOLEAN(),
+          "gt",
+          std::make_shared<FieldAccessTypedExpr>(DOUBLE(), "a"),
+          std::make_shared<ConstantTypedExpr>(DOUBLE(), 0.5)),
+      project);
+
+  auto limit = std::make_shared<LimitNode>("4", 0, 10, false, filter);
+
+  ASSERT_EQ(PlanNode::findNodeById(limit.get(), "1"), values.get());
+  ASSERT_EQ(PlanNode::findNodeById(limit.get(), "2"), project.get());
+  ASSERT_EQ(PlanNode::findNodeById(limit.get(), "3"), filter.get());
+  ASSERT_EQ(PlanNode::findNodeById(limit.get(), "4"), limit.get());
+
+  ASSERT_EQ(PlanNode::findNodeById(limit.get(), "5"), nullptr);
+  ASSERT_EQ(PlanNode::findNodeById(project.get(), "4"), nullptr);
+}
+
+TEST_F(PlanNodeTest, is) {
+  auto values = std::make_shared<ValuesNode>("1", std::vector<RowVectorPtr>{});
+  auto project = std::make_shared<ProjectNode>(
+      "2",
+      std::vector<std::string>{"a", "b"},
+      std::vector<TypedExprPtr>{
+          std::make_shared<CallTypedExpr>(DOUBLE(), "rand"),
+          std::make_shared<CallTypedExpr>(DOUBLE(), "rand"),
+      },
+      values);
+
+  ASSERT_TRUE(values->is<ValuesNode>());
+  ASSERT_FALSE(values->is<ProjectNode>());
+
+  ASSERT_FALSE(project->is<ValuesNode>());
+  ASSERT_TRUE(project->is<ProjectNode>());
+}
+
 TEST_F(PlanNodeTest, sortOrder) {
   struct {
     SortOrder order1;
@@ -132,6 +182,7 @@ TEST_F(PlanNodeTest, duplicateSortKeys) {
           "orderBy", sortingKeys, sortingOrders, false, nullptr),
       "Duplicate sorting keys are not allowed: c0");
 }
+
 class TestIndexTableHandle : public connector::ConnectorTableHandle {
  public:
   TestIndexTableHandle()
@@ -163,7 +214,32 @@ class TestIndexTableHandle : public connector::ConnectorTableHandle {
   }
 };
 
-TEST_F(PlanNodeTest, isIndexLookupJoin) {
+TEST_F(PlanNodeTest, nestedLoopJoin) {
+  auto leftData = makeRowVector(
+      {"a"},
+      {
+          makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+      });
+
+  auto rightData = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+  });
+
+  core::PlanNodeIdGenerator planNodeIdGenerator;
+  auto nextId = [&planNodeIdGenerator]() { return planNodeIdGenerator.next(); };
+
+  auto leftValues = std::make_shared<ValuesNode>(
+      nextId(), std::vector<RowVectorPtr>{leftData});
+  auto rightValues = std::make_shared<ValuesNode>(
+      nextId(), std::vector<RowVectorPtr>{rightData});
+
+  VELOX_ASSERT_THROW(
+      std::make_shared<NestedLoopJoinNode>(
+          nextId(), leftValues, rightValues, ROW({"a"}, VARCHAR())),
+      "Join output column type must match the input type: VARCHAR vs. INTEGER");
+}
+
+TEST_F(PlanNodeTest, indexLookupJoin) {
   const auto rowType = ROW({"name"}, {BIGINT()});
   const auto valueNode = std::make_shared<ValuesNode>("orderBy", rowData_);
   ASSERT_FALSE(isIndexLookupJoin(valueNode.get()));
@@ -193,12 +269,17 @@ TEST_F(PlanNodeTest, isIndexLookupJoin) {
             leftKeys,
             rightKeys,
             std::vector<IndexLookupConditionPtr>{},
-            /*includeMatchColumn=*/false,
+            /*filter=*/nullptr,
+            /*hasMarker=*/false,
             probeNode,
             buildNode,
             outputType);
     ASSERT_TRUE(isIndexLookupJoin(indexJoinNodeWithInnerJoin.get()));
-    ASSERT_FALSE(indexJoinNodeWithInnerJoin->includeMatchColumn());
+    ASSERT_FALSE(indexJoinNodeWithInnerJoin->hasMarker());
+    ASSERT_EQ(indexJoinNodeWithInnerJoin->filter(), nullptr);
+    ASSERT_EQ(
+        indexJoinNodeWithInnerJoin->toString(/*detailed=*/true),
+        "-- IndexLookupJoin[indexJoinNode][INNER c0=c1] -> c0:BIGINT, c1:BIGINT\n");
   }
   {
     const RowTypePtr outputTypeWithMatchColumn =
@@ -210,12 +291,39 @@ TEST_F(PlanNodeTest, isIndexLookupJoin) {
             leftKeys,
             rightKeys,
             std::vector<IndexLookupConditionPtr>{},
-            /*includeMatchColumn=*/true,
+            /*filter=*/nullptr,
+            /*hasMarker=*/true,
             probeNode,
             buildNode,
             outputTypeWithMatchColumn);
     ASSERT_TRUE(isIndexLookupJoin(indexJoinNodeWithLeftJoin.get()));
-    ASSERT_TRUE(indexJoinNodeWithLeftJoin->includeMatchColumn());
+    ASSERT_TRUE(indexJoinNodeWithLeftJoin->hasMarker());
+    ASSERT_EQ(indexJoinNodeWithLeftJoin->filter(), nullptr);
+    ASSERT_EQ(
+        indexJoinNodeWithLeftJoin->toString(/*detailed=*/true),
+        "-- IndexLookupJoin[indexJoinNode][LEFT c0=c1] -> c0:BIGINT, c1:BIGINT, c2:BOOLEAN\n");
+  }
+  {
+    // Test IndexLookupJoinNode with filter
+    const auto filterExpr = std::make_shared<core::FieldAccessTypedExpr>(
+        BOOLEAN(), "filter_column");
+    const auto indexJoinNodeWithFilter = std::make_shared<IndexLookupJoinNode>(
+        "indexJoinNodeWithFilter",
+        core::JoinType::kInner,
+        leftKeys,
+        rightKeys,
+        std::vector<IndexLookupConditionPtr>{},
+        /*filter=*/filterExpr,
+        /*hasMarker=*/false,
+        probeNode,
+        buildNode,
+        outputType);
+    ASSERT_TRUE(isIndexLookupJoin(indexJoinNodeWithFilter.get()));
+    ASSERT_FALSE(indexJoinNodeWithFilter->hasMarker());
+    ASSERT_EQ(indexJoinNodeWithFilter->filter(), filterExpr);
+    ASSERT_EQ(
+        indexJoinNodeWithFilter->toString(/*detailed=*/true),
+        "-- IndexLookupJoin[indexJoinNodeWithFilter][INNER c0=c1, filter: \"filter_column\"] -> c0:BIGINT, c1:BIGINT\n");
   }
   // Error case.
   {
@@ -226,7 +334,8 @@ TEST_F(PlanNodeTest, isIndexLookupJoin) {
             leftKeys,
             rightKeys,
             std::vector<IndexLookupConditionPtr>{},
-            /*includeMatchColumn=*/true,
+            /*filter=*/nullptr,
+            /*hasMarker=*/true,
             probeNode,
             buildNode,
             outputType),
@@ -240,7 +349,8 @@ TEST_F(PlanNodeTest, isIndexLookupJoin) {
             leftKeys,
             rightKeys,
             std::vector<IndexLookupConditionPtr>{},
-            /*includeMatchColumn=*/true,
+            /*filter=*/nullptr,
+            /*hasMarker=*/true,
             probeNode,
             buildNode,
             outputType),
@@ -256,12 +366,28 @@ TEST_F(PlanNodeTest, isIndexLookupJoin) {
             leftKeys,
             rightKeys,
             std::vector<IndexLookupConditionPtr>{},
-            /*includeMatchColumn=*/true,
+            /*filter=*/nullptr,
+            /*hasMarker=*/true,
             probeNode,
             buildNode,
             outputTypeWithDuplicateMatchColumn),
         "");
   }
+  {
+    VELOX_ASSERT_THROW(
+        std::make_shared<IndexLookupJoinNode>(
+            "indexJoinNode",
+            core::JoinType::kLeft,
+            leftKeys,
+            rightKeys,
+            std::vector<IndexLookupConditionPtr>{},
+            /*filter=*/nullptr,
+            /*hasMarker=*/false,
+            probeNode,
+            buildNode,
+            ROW({"c0", "c1"}, {VARCHAR(), BIGINT()})),
+        "Join output column type must match the input type: VARCHAR vs. BIGINT");
+  }
 }
 
 TEST_F(PlanNodeTest, partitionedOutputNode) {
@@ -272,7 +398,7 @@ TEST_F(PlanNodeTest, partitionedOutputNode) {
       std::make_shared<FieldAccessTypedExpr>(BIGINT(), "c0")};
   const PartitionFunctionSpecPtr partitionFunctionSpec =
       std::make_shared<GatherPartitionFunctionSpec>();
-  const VectorSerde::Kind serdeKind = VectorSerde::Kind::kPresto;
+  const std::string serdeKind = "Presto";
   PlanNodePtr source = std::make_shared<ValuesNode>("source", rowData_);
 
   {
@@ -373,4 +499,239 @@ TEST_F(PlanNodeTest, partitionedOutputNode) {
           source),
       "partitioning doesn't allow for partitioning keys");
 }
+
+TEST_F(PlanNodeTest, aggregationNodeNoGroupsSpanBatches) {
+  auto values = std::make_shared<ValuesNode>("values", rowData_);
+
+  const std::vector<FieldAccessTypedExprPtr> groupingKeys{
+      std::make_shared<FieldAccessTypedExpr>(BIGINT(), "c0")};
+  const std::vector<FieldAccessTypedExprPtr> preGroupedKeys{
+      std::make_shared<FieldAccessTypedExpr>(BIGINT(), "c0")};
+  const std::vector<std::string> aggregateNames{"sum"};
+  const std::vector<AggregationNode::Aggregate> aggregates{
+      {.call = std::make_shared<CallTypedExpr>(BIGINT(), "sum"),
+       .rawInputTypes = {BIGINT()}}};
+
+  // noGroupsSpanBatches=true with preGroupedKeys (streaming aggregation) should
+  // succeed and the accessor should return true.
+  {
+    auto aggNode = std::make_shared<AggregationNode>(
+        "agg",
+        AggregationNode::Step::kSingle,
+        groupingKeys,
+        preGroupedKeys,
+        aggregateNames,
+        aggregates,
+        /*ignoreNullKeys=*/false,
+        /*noGroupsSpanBatches=*/true,
+        values);
+    ASSERT_TRUE(aggNode->noGroupsSpanBatches());
+    ASSERT_TRUE(aggNode->isPreGrouped());
+    ASSERT_EQ(
+        aggNode->toString(true),
+        "-- Aggregation[agg][SINGLE STREAMING [c0] sum := sum() noGroupsSpanBatches] -> c0:BIGINT, sum:BIGINT\n");
+  }
+
+  // noGroupsSpanBatches=false with preGroupedKeys should succeed and the
+  // accessor should return false.
+  {
+    auto aggNode = std::make_shared<AggregationNode>(
+        "agg",
+        AggregationNode::Step::kSingle,
+        groupingKeys,
+        preGroupedKeys,
+        aggregateNames,
+        aggregates,
+        /*ignoreNullKeys=*/false,
+        /*noGroupsSpanBatches=*/false,
+        values);
+    ASSERT_FALSE(aggNode->noGroupsSpanBatches());
+    ASSERT_TRUE(aggNode->isPreGrouped());
+    ASSERT_EQ(
+        aggNode->toString(true),
+        "-- Aggregation[agg][SINGLE STREAMING [c0] sum := sum()] -> c0:BIGINT, sum:BIGINT\n");
+  }
+
+  // noGroupsSpanBatches=true without preGroupedKeys (non-streaming aggregation)
+  // should fail.
+  VELOX_ASSERT_THROW(
+      std::make_shared<AggregationNode>(
+          "agg",
+          AggregationNode::Step::kSingle,
+          groupingKeys,
+          /*preGroupedKeys=*/std::vector<FieldAccessTypedExprPtr>{},
+          aggregateNames,
+          aggregates,
+          /*ignoreNullKeys=*/false,
+          /*noGroupsSpanBatches=*/true,
+          values),
+      "noGroupsSpanBatches can only be set for streaming aggregation (pre-grouped)");
+
+  // noGroupsSpanBatches=false without preGroupedKeys should succeed.
+  {
+    auto aggNode = std::make_shared<AggregationNode>(
+        "agg",
+        AggregationNode::Step::kSingle,
+        groupingKeys,
+        /*preGroupedKeys=*/std::vector<FieldAccessTypedExprPtr>{},
+        aggregateNames,
+        aggregates,
+        /*ignoreNullKeys=*/false,
+        /*noGroupsSpanBatches=*/false,
+        values);
+    ASSERT_FALSE(aggNode->noGroupsSpanBatches());
+    ASSERT_FALSE(aggNode->isPreGrouped());
+    ASSERT_EQ(
+        aggNode->toString(true),
+        "-- Aggregation[agg][SINGLE [c0] sum := sum()] -> c0:BIGINT, sum:BIGINT\n");
+  }
+}
+TEST_F(PlanNodeTest, rpcNodeSerdePerRowMode) {
+  Type::registerSerDe();
+  core::PlanNode::registerSerDe();
+  core::ITypedExpr::registerSerDe();
+
+  // Create a ValuesNode as the source with a "prompt" column.
+  auto sourceData =
+      makeRowVector({"prompt"}, {makeFlatVector<StringView>({"hello"})});
+  auto valuesNode = std::make_shared<core::ValuesNode>(
+      "values-1", std::vector<RowVectorPtr>{sourceData});
+
+  auto rpcNode = std::make_shared<core::RPCNode>(
+      "rpc-1",
+      valuesNode,
+      "test_function",
+      VARCHAR(),
+      "response",
+      ROW({"prompt", "response"}, {VARCHAR(), VARCHAR()}),
+      std::vector<std::string>{"prompt"},
+      std::vector<TypePtr>{VARCHAR()},
+      std::vector<VectorPtr>{nullptr},
+      rpc::RPCStreamingMode::kPerRow,
+      0);
+
+  // Serialize and deserialize.
+  const auto serialized = rpcNode->serialize();
+  auto copy =
+      ISerializable::deserialize<core::PlanNode>(serialized, pool_.get());
+
+  // Compare detailed string representation.
+  ASSERT_EQ(rpcNode->toString(true, true), copy->toString(true, true));
+
+  // Verify deserialized fields.
+  auto* copyRpc = dynamic_cast<const core::RPCNode*>(copy.get());
+  ASSERT_NE(copyRpc, nullptr);
+  EXPECT_EQ(copyRpc->functionName(), "test_function");
+  EXPECT_EQ(copyRpc->outputColumn(), "response");
+  EXPECT_EQ(copyRpc->streamingMode(), rpc::RPCStreamingMode::kPerRow);
+  EXPECT_EQ(copyRpc->dispatchBatchSize(), 0);
+  EXPECT_EQ(*copyRpc->rpcResultType(), *VARCHAR());
+  EXPECT_EQ(copyRpc->argumentColumns().size(), 1);
+  EXPECT_EQ(copyRpc->argumentColumns()[0], "prompt");
+  EXPECT_EQ(copyRpc->argumentTypes().size(), 1);
+  EXPECT_EQ(*copyRpc->argumentTypes()[0], *VARCHAR());
+}
+
+TEST_F(PlanNodeTest, rpcNodeSerdeBatchMode) {
+  Type::registerSerDe();
+  core::PlanNode::registerSerDe();
+  core::ITypedExpr::registerSerDe();
+
+  auto sourceData = makeRowVector(
+      {"prompt", "model"},
+      {makeFlatVector<StringView>({"hello"}),
+       makeFlatVector<StringView>({"llama"})});
+  auto valuesNode = std::make_shared<core::ValuesNode>(
+      "values-1", std::vector<RowVectorPtr>{sourceData});
+
+  auto rpcNode = std::make_shared<core::RPCNode>(
+      "rpc-2",
+      valuesNode,
+      "batch_function",
+      VARCHAR(),
+      "result",
+      ROW({"prompt", "model", "result"}, {VARCHAR(), VARCHAR(), VARCHAR()}),
+      std::vector<std::string>{"prompt", "model"},
+      std::vector<TypePtr>{VARCHAR(), VARCHAR()},
+      std::vector<VectorPtr>{nullptr, nullptr},
+      rpc::RPCStreamingMode::kBatch,
+      50);
+
+  const auto serialized = rpcNode->serialize();
+  auto copy =
+      ISerializable::deserialize<core::PlanNode>(serialized, pool_.get());
+
+  ASSERT_EQ(rpcNode->toString(true, true), copy->toString(true, true));
+
+  auto* copyRpc = dynamic_cast<const core::RPCNode*>(copy.get());
+  ASSERT_NE(copyRpc, nullptr);
+  EXPECT_EQ(copyRpc->functionName(), "batch_function");
+  EXPECT_EQ(copyRpc->outputColumn(), "result");
+  EXPECT_EQ(copyRpc->streamingMode(), rpc::RPCStreamingMode::kBatch);
+  EXPECT_EQ(copyRpc->dispatchBatchSize(), 50);
+  EXPECT_EQ(copyRpc->argumentColumns().size(), 2);
+  EXPECT_EQ(copyRpc->argumentColumns()[0], "prompt");
+  EXPECT_EQ(copyRpc->argumentColumns()[1], "model");
+}
+
+TEST_F(PlanNodeTest, rpcNodeSerdeWithConstants) {
+  Type::registerSerDe();
+  core::PlanNode::registerSerDe();
+  core::ITypedExpr::registerSerDe();
+
+  auto sourceData =
+      makeRowVector({"prompt"}, {makeFlatVector<StringView>({"hello"})});
+  auto valuesNode = std::make_shared<core::ValuesNode>(
+      "values-1", std::vector<RowVectorPtr>{sourceData});
+
+  // Create constant vectors for model and system_prompt arguments.
+  auto modelConstant = makeConstant("llama3", 1);
+  auto systemPromptConstant = makeConstant("You are helpful.", 1);
+
+  auto rpcNode = std::make_shared<core::RPCNode>(
+      "rpc-3",
+      valuesNode,
+      "test_function",
+      VARCHAR(),
+      "response",
+      ROW({"prompt", "response"}, {VARCHAR(), VARCHAR()}),
+      std::vector<std::string>{"prompt", "model", "system_prompt"},
+      std::vector<TypePtr>{VARCHAR(), VARCHAR(), VARCHAR()},
+      std::vector<VectorPtr>{nullptr, modelConstant, systemPromptConstant});
+
+  // Verify constants before serde.
+  ASSERT_EQ(rpcNode->constantInputs().size(), 3);
+  EXPECT_EQ(rpcNode->constantInputs()[0], nullptr);
+  EXPECT_NE(rpcNode->constantInputs()[1], nullptr);
+  EXPECT_NE(rpcNode->constantInputs()[2], nullptr);
+
+  // Serialize and deserialize.
+  const auto serialized = rpcNode->serialize();
+  auto copy =
+      ISerializable::deserialize<core::PlanNode>(serialized, pool_.get());
+
+  auto* copyRpc = dynamic_cast<const core::RPCNode*>(copy.get());
+  ASSERT_NE(copyRpc, nullptr);
+  EXPECT_EQ(copyRpc->functionName(), "test_function");
+  EXPECT_EQ(copyRpc->argumentColumns().size(), 3);
+
+  // Verify constants survive the round-trip.
+  ASSERT_EQ(copyRpc->constantInputs().size(), 3);
+  EXPECT_EQ(copyRpc->constantInputs()[0], nullptr);
+  ASSERT_NE(copyRpc->constantInputs()[1], nullptr);
+  ASSERT_NE(copyRpc->constantInputs()[2], nullptr);
+
+  // Verify constant values.
+  auto modelVec = copyRpc->constantInputs()[1];
+  EXPECT_TRUE(modelVec->isConstantEncoding());
+  EXPECT_EQ(
+      modelVec->as<ConstantVector<StringView>>()->valueAt(0).str(), "llama3");
+
+  auto promptVec = copyRpc->constantInputs()[2];
+  EXPECT_TRUE(promptVec->isConstantEncoding());
+  EXPECT_EQ(
+      promptVec->as<ConstantVector<StringView>>()->valueAt(0).str(),
+      "You are helpful.");
+}
+
 } // namespace
diff --git a/velox/core/tests/QueryConfigProviderTest.cpp b/velox/core/tests/QueryConfigProviderTest.cpp
new file mode 100644
index 00000000000..4eceef24859
--- /dev/null
+++ b/velox/core/tests/QueryConfigProviderTest.cpp
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/core/QueryConfigProvider.h"
+#include <gtest/gtest.h>
+#include "velox/core/QueryConfig.h"
+
+using namespace facebook::velox::config;
+using namespace facebook::velox::core;
+
+class QueryConfigProviderTest : public ::testing::Test {
+ protected:
+  QueryConfigProvider provider_;
+};
+
+TEST_F(QueryConfigProviderTest, propertiesNotEmpty) {
+  auto props = provider_.properties();
+  EXPECT_GT(props.size(), 140);
+}
+
+TEST_F(QueryConfigProviderTest, allNamesNonEmpty) {
+  for (const auto& prop : provider_.properties()) {
+    EXPECT_FALSE(prop.name.empty()) << "Found property with empty name";
+    EXPECT_FALSE(prop.description.empty())
+        << "Property " << prop.name << " has empty description";
+  }
+}
+
+TEST_F(QueryConfigProviderTest, noDuplicateNames) {
+  auto props = provider_.properties();
+  std::set<std::string> names;
+  for (const auto& prop : props) {
+    EXPECT_TRUE(names.insert(prop.name).second)
+        << "Duplicate property name: " << prop.name;
+  }
+}
+
+TEST_F(QueryConfigProviderTest, knownProperties) {
+  auto props = provider_.properties();
+
+  auto findProp =
+      [&](const std::string& name) -> std::optional<ConfigProperty> {
+    for (const auto& prop : props) {
+      if (prop.name == name) {
+        return prop;
+      }
+    }
+    return std::nullopt;
+  };
+
+  // Check a boolean property.
+  auto spillEnabled = findProp(QueryConfig::kSpillEnabled);
+  ASSERT_TRUE(spillEnabled.has_value());
+  EXPECT_EQ(spillEnabled->type, ConfigPropertyType::kBoolean);
+  EXPECT_EQ(spillEnabled->defaultValue, "false");
+
+  // Check a string property.
+  auto sessionTz = findProp(QueryConfig::kSessionTimezone);
+  ASSERT_TRUE(sessionTz.has_value());
+  EXPECT_EQ(sessionTz->type, ConfigPropertyType::kString);
+  EXPECT_EQ(sessionTz->defaultValue, "");
+
+  // Check an integer property (macro-registered).
+  auto startTime = findProp(QueryConfig::kSessionStartTime);
+  ASSERT_TRUE(startTime.has_value());
+  EXPECT_EQ(startTime->type, ConfigPropertyType::kInteger);
+  EXPECT_EQ(startTime->defaultValue, "0");
+
+  // Check a double property (macro-registered).
+  auto cpuOverhead =
+      findProp(QueryConfig::kExprAdaptiveCpuSamplingMaxOverheadPct);
+  ASSERT_TRUE(cpuOverhead.has_value());
+  EXPECT_EQ(cpuOverhead->type, ConfigPropertyType::kDouble);
+  EXPECT_EQ(cpuOverhead->defaultValue, "1");
+}
+
+TEST_F(QueryConfigProviderTest, normalizePassthrough) {
+  EXPECT_EQ(provider_.normalize("spill_enabled", "true"), "true");
+  EXPECT_EQ(provider_.normalize("session_timezone", "UTC"), "UTC");
+}
+
+TEST_F(QueryConfigProviderTest, configPropertyTypeNames) {
+  EXPECT_EQ(
+      ConfigPropertyTypeName::toName(ConfigPropertyType::kBoolean), "BOOLEAN");
+  EXPECT_EQ(
+      ConfigPropertyTypeName::toName(ConfigPropertyType::kInteger), "INTEGER");
+  EXPECT_EQ(
+      ConfigPropertyTypeName::toName(ConfigPropertyType::kDouble), "DOUBLE");
+  EXPECT_EQ(
+      ConfigPropertyTypeName::toName(ConfigPropertyType::kString), "STRING");
+
+  EXPECT_EQ(
+      ConfigPropertyTypeName::toConfigPropertyType("BOOLEAN"),
+      ConfigPropertyType::kBoolean);
+  EXPECT_EQ(
+      ConfigPropertyTypeName::toConfigPropertyType("INTEGER"),
+      ConfigPropertyType::kInteger);
+}
diff --git a/velox/core/tests/QueryConfigTest.cpp b/velox/core/tests/QueryConfigTest.cpp
index daab3fad2a0..ce7d7124d7c 100644
--- a/velox/core/tests/QueryConfigTest.cpp
+++ b/velox/core/tests/QueryConfigTest.cpp
@@ -168,8 +168,9 @@ TEST_F(QueryConfigTest, expressionEvaluationRelatedConfigs) {
             std::make_shared<core::ExecCtx>(pool.get(), queryCtx.get());
         auto evalCtx = std::make_shared<exec::EvalCtx>(execCtx.get());
 
+        SelectivityVector rows(100, true);
         ASSERT_EQ(
-            evalCtx->peelingEnabled(),
+            evalCtx->peelingEnabled(rows),
             !queryConfig.debugDisableExpressionsWithPeeling());
         ASSERT_EQ(
             evalCtx->sharedSubExpressionReuseEnabled(),
@@ -203,6 +204,151 @@ TEST_F(QueryConfigTest, expressionEvaluationRelatedConfigs) {
   testConfig(createConfig(false, true, false, false));
   testConfig(createConfig(false, false, true, false));
   testConfig(createConfig(false, false, false, true));
+
+  // Verify minRowsForPeeling: peeling is suppressed when the number of
+  // selected rows is below the threshold.
+  {
+    std::unordered_map<std::string, std::string> configData(
+        {{core::QueryConfig::kMinRowsForPeeling, "50"}});
+    auto queryCtx =
+        core::QueryCtx::create(nullptr, QueryConfig{std::move(configData)});
+    auto execCtx = std::make_shared<core::ExecCtx>(pool.get(), queryCtx.get());
+    auto evalCtx = std::make_shared<exec::EvalCtx>(execCtx.get());
+
+    SelectivityVector belowThreshold(30, true);
+    ASSERT_FALSE(evalCtx->peelingEnabled(belowThreshold));
+
+    SelectivityVector atThreshold(50, true);
+    ASSERT_TRUE(evalCtx->peelingEnabled(atThreshold));
+
+    SelectivityVector aboveThreshold(100, true);
+    ASSERT_TRUE(evalCtx->peelingEnabled(aboveThreshold));
+  }
+}
+
+TEST_F(QueryConfigTest, sessionStartTime) {
+  // Test with no session start time set
+  {
+    auto queryCtx = QueryCtx::create(nullptr, QueryConfig{{}});
+    const QueryConfig& config = queryCtx->queryConfig();
+
+    EXPECT_EQ(config.sessionStartTimeMs(), 0);
+  }
+
+  // Test with session start time set
+  {
+    int64_t startTimeMs = 1674123456789; // Some timestamp in milliseconds
+    std::unordered_map<std::string, std::string> configData(
+        {{QueryConfig::kSessionStartTime, std::to_string(startTimeMs)}});
+    auto queryCtx =
+        QueryCtx::create(nullptr, QueryConfig{std::move(configData)});
+    const QueryConfig& config = queryCtx->queryConfig();
+
+    EXPECT_EQ(config.sessionStartTimeMs(), startTimeMs);
+  }
+
+  // Test with negative session start time (should be valid)
+  {
+    int64_t negativeStartTime = -1000;
+    std::unordered_map<std::string, std::string> configData(
+        {{QueryConfig::kSessionStartTime, std::to_string(negativeStartTime)}});
+    auto queryCtx =
+        QueryCtx::create(nullptr, QueryConfig{std::move(configData)});
+    const QueryConfig& config = queryCtx->queryConfig();
+
+    EXPECT_EQ(config.sessionStartTimeMs(), negativeStartTime);
+  }
+
+  // Test with maximum int64_t value
+  {
+    int64_t maxTime = std::numeric_limits<int64_t>::max();
+    std::unordered_map<std::string, std::string> configData(
+        {{QueryConfig::kSessionStartTime, std::to_string(maxTime)}});
+    auto queryCtx =
+        QueryCtx::create(nullptr, QueryConfig{std::move(configData)});
+    const QueryConfig& config = queryCtx->queryConfig();
+
+    EXPECT_EQ(config.sessionStartTimeMs(), maxTime);
+  }
+}
+
+TEST_F(QueryConfigTest, singleSourceExchangeOptimizationConfig) {
+  // Test default value (should be false)
+  {
+    auto queryCtx = QueryCtx::create(nullptr, QueryConfig{{}});
+    const QueryConfig& config = queryCtx->queryConfig();
+    EXPECT_FALSE(config.singleSourceExchangeOptimizationEnabled());
+  }
+
+  // Test with optimization enabled
+  {
+    std::unordered_map<std::string, std::string> configData(
+        {{QueryConfig::kSkipRequestDataSizeWithSingleSourceEnabled, "true"}});
+    auto queryCtx =
+        QueryCtx::create(nullptr, QueryConfig{std::move(configData)});
+    const QueryConfig& config = queryCtx->queryConfig();
+    EXPECT_TRUE(config.singleSourceExchangeOptimizationEnabled());
+  }
+
+  // Test with optimization explicitly disabled
+  {
+    std::unordered_map<std::string, std::string> configData(
+        {{QueryConfig::kSkipRequestDataSizeWithSingleSourceEnabled, "false"}});
+    auto queryCtx =
+        QueryCtx::create(nullptr, QueryConfig{std::move(configData)});
+    const QueryConfig& config = queryCtx->queryConfig();
+    EXPECT_FALSE(config.singleSourceExchangeOptimizationEnabled());
+  }
+}
+
+TEST_F(QueryConfigTest, operatorSpillFileCreateConfig) {
+  // Test default values (empty strings)
+  {
+    auto queryCtx = QueryCtx::create(nullptr, QueryConfig{{}});
+    const QueryConfig& config = queryCtx->queryConfig();
+    EXPECT_EQ(config.aggregationSpillFileCreateConfig(), "");
+    EXPECT_EQ(config.hashJoinSpillFileCreateConfig(), "");
+  }
+
+  // Test with aggregation spill file create config set
+  {
+    std::unordered_map<std::string, std::string> configData(
+        {{QueryConfig::kAggregationSpillFileCreateConfig,
+          "aggregation_config_value"}});
+    auto queryCtx =
+        QueryCtx::create(nullptr, QueryConfig{std::move(configData)});
+    const QueryConfig& config = queryCtx->queryConfig();
+    EXPECT_EQ(
+        config.aggregationSpillFileCreateConfig(), "aggregation_config_value");
+    EXPECT_EQ(config.hashJoinSpillFileCreateConfig(), "");
+  }
+
+  // Test with hash join spill file create config set
+  {
+    std::unordered_map<std::string, std::string> configData(
+        {{QueryConfig::kHashJoinSpillFileCreateConfig,
+          "hashjoin_config_value"}});
+    auto queryCtx =
+        QueryCtx::create(nullptr, QueryConfig{std::move(configData)});
+    const QueryConfig& config = queryCtx->queryConfig();
+    EXPECT_EQ(config.aggregationSpillFileCreateConfig(), "");
+    EXPECT_EQ(config.hashJoinSpillFileCreateConfig(), "hashjoin_config_value");
+  }
+
+  // Test with both configs set
+  {
+    std::unordered_map<std::string, std::string> configData(
+        {{QueryConfig::kAggregationSpillFileCreateConfig,
+          "aggregation_config_value"},
+         {QueryConfig::kHashJoinSpillFileCreateConfig,
+          "hashjoin_config_value"}});
+    auto queryCtx =
+        QueryCtx::create(nullptr, QueryConfig{std::move(configData)});
+    const QueryConfig& config = queryCtx->queryConfig();
+    EXPECT_EQ(
+        config.aggregationSpillFileCreateConfig(), "aggregation_config_value");
+    EXPECT_EQ(config.hashJoinSpillFileCreateConfig(), "hashjoin_config_value");
+  }
 }
 
 } // namespace facebook::velox::core::test
diff --git a/velox/core/tests/QueryCtxTest.cpp b/velox/core/tests/QueryCtxTest.cpp
index 52ce900640b..44dbc5927c4 100644
--- a/velox/core/tests/QueryCtxTest.cpp
+++ b/velox/core/tests/QueryCtxTest.cpp
@@ -51,4 +51,90 @@ TEST_F(QueryCtxTest, withSysRootPool) {
   ASSERT_FALSE(
       queryPool->reclaimer()->reclaimableBytes(*queryPool, reclaimableBytes));
 }
+
+TEST_F(QueryCtxTest, releaseCallbacks) {
+  int callbackCount = 0;
+  std::string capturedQueryId;
+
+  {
+    auto queryCtx = QueryCtx::create(
+        nullptr,
+        QueryConfig{{}},
+        std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
+        nullptr,
+        nullptr,
+        nullptr,
+        "test_query_id");
+
+    // Add multiple callbacks.
+    queryCtx->addReleaseCallback([&callbackCount]() { ++callbackCount; });
+
+    queryCtx->addReleaseCallback(
+        [&callbackCount, &capturedQueryId, id = queryCtx->queryId()]() {
+          ++callbackCount;
+          capturedQueryId = id;
+        });
+
+    // Callbacks should not be invoked yet.
+    ASSERT_EQ(callbackCount, 0);
+  }
+
+  // After QueryCtx destruction, all callbacks should have been invoked.
+  ASSERT_EQ(callbackCount, 2);
+  ASSERT_EQ(capturedQueryId, "test_query_id");
+}
+
+TEST_F(QueryCtxTest, releaseCallbackException) {
+  int callbackCount = 0;
+
+  {
+    auto queryCtx = QueryCtx::create(
+        nullptr,
+        QueryConfig{{}},
+        std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
+        nullptr,
+        nullptr,
+        nullptr,
+        "test_query_id");
+
+    // First callback succeeds.
+    queryCtx->addReleaseCallback([&callbackCount]() { ++callbackCount; });
+
+    // Second callback throws an exception.
+    queryCtx->addReleaseCallback(
+        []() { throw std::runtime_error("Test exception"); });
+
+    // Third callback should still execute despite the previous exception.
+    queryCtx->addReleaseCallback([&callbackCount]() { ++callbackCount; });
+  }
+
+  // All callbacks should have been attempted, with exception caught and logged.
+  // First and third callbacks should have incremented the counter.
+  ASSERT_EQ(callbackCount, 2);
+}
+
+TEST_F(QueryCtxTest, builderReleaseCallbacks) {
+  int callbackCount = 0;
+  std::string capturedQueryId;
+
+  {
+    // Use builder to add release callbacks during construction.
+    auto queryCtx =
+        QueryCtx::Builder()
+            .queryId("builder_test_query_id")
+            .releaseCallback([&callbackCount]() { ++callbackCount; })
+            .releaseCallback([&callbackCount, &capturedQueryId]() {
+              ++callbackCount;
+              capturedQueryId = "builder_test_query_id";
+            })
+            .build();
+
+    // Callbacks should not be invoked yet.
+    ASSERT_EQ(callbackCount, 0);
+  }
+
+  // After QueryCtx destruction, all callbacks should have been invoked.
+  ASSERT_EQ(callbackCount, 2);
+  ASSERT_EQ(capturedQueryId, "builder_test_query_id");
+}
 } // namespace facebook::velox::core::test
diff --git a/velox/core/tests/TypedExprHashConsistencyTest.cpp b/velox/core/tests/TypedExprHashConsistencyTest.cpp
new file mode 100644
index 00000000000..5926510f233
--- /dev/null
+++ b/velox/core/tests/TypedExprHashConsistencyTest.cpp
@@ -0,0 +1,286 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "velox/common/memory/Memory.h"
+#include "velox/core/Expressions.h"
+#include "velox/type/Variant.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+namespace facebook::velox::core::test {
+
+/// Tests for expression hash consistency.
+///
+/// These tests verify that hash functions are deterministic and stable:
+/// 1. Same expression hashed multiple times produces same result
+/// 2. Semantically equivalent expressions have same hash
+/// 3. Hash survives serialization roundtrip
+/// 4. Different expressions produce different hashes
+///
+/// Note: We do NOT use hardcoded expected hash values as that makes tests
+/// brittle. Instead we test hash properties.
+class TypedExprHashConsistencyTest : public ::testing::Test,
+                                     public velox::test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    pool_ = memory::memoryManager()->addLeafPool();
+    Type::registerSerDe();
+    ITypedExpr::registerSerDe();
+  }
+
+  std::shared_ptr<ConstantTypedExpr> makeConstantExpr(
+      const TypePtr& type,
+      const Variant& value) {
+    return std::make_shared<ConstantTypedExpr>(type, value);
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_;
+};
+
+// Test that hashing the same expression multiple times gives same result
+TEST_F(TypedExprHashConsistencyTest, idempotency) {
+  // InputTypedExpr
+  auto inputExpr = std::make_shared<InputTypedExpr>(INTEGER());
+  EXPECT_EQ(inputExpr->hash(), inputExpr->hash());
+
+  // ConstantTypedExpr with various types
+  auto boolExpr = makeConstantExpr(BOOLEAN(), variant(true));
+  EXPECT_EQ(boolExpr->hash(), boolExpr->hash());
+
+  auto intExpr = makeConstantExpr(INTEGER(), variant(int32_t(42)));
+  EXPECT_EQ(intExpr->hash(), intExpr->hash());
+
+  auto strExpr = makeConstantExpr(VARCHAR(), variant("hello"));
+  EXPECT_EQ(strExpr->hash(), strExpr->hash());
+
+  // CallTypedExpr
+  auto callExpr = std::make_shared<CallTypedExpr>(
+      BIGINT(),
+      std::vector<TypedExprPtr>{
+          std::make_shared<FieldAccessTypedExpr>(BIGINT(), "a")},
+      "plus");
+  EXPECT_EQ(callExpr->hash(), callExpr->hash());
+
+  // FieldAccessTypedExpr
+  auto fieldExpr = std::make_shared<FieldAccessTypedExpr>(BIGINT(), "column");
+  EXPECT_EQ(fieldExpr->hash(), fieldExpr->hash());
+
+  // CastTypedExpr
+  auto castExpr = std::make_shared<CastTypedExpr>(
+      VARCHAR(),
+      std::vector<TypedExprPtr>{
+          std::make_shared<FieldAccessTypedExpr>(INTEGER(), "x")},
+      false);
+  EXPECT_EQ(castExpr->hash(), castExpr->hash());
+}
+
+// Test that equivalent expressions created separately have same hash
+TEST_F(TypedExprHashConsistencyTest, equivalentExpressions) {
+  // Create two equivalent InputTypedExpr
+  auto input1 = std::make_shared<InputTypedExpr>(INTEGER());
+  auto input2 = std::make_shared<InputTypedExpr>(INTEGER());
+  EXPECT_EQ(input1->hash(), input2->hash());
+
+  // Create two equivalent ConstantTypedExpr
+  auto const1 = makeConstantExpr(INTEGER(), variant(int32_t(42)));
+  auto const2 = makeConstantExpr(INTEGER(), variant(int32_t(42)));
+  EXPECT_EQ(const1->hash(), const2->hash());
+
+  // Create two equivalent CallTypedExpr
+  auto call1 = std::make_shared<CallTypedExpr>(
+      BIGINT(),
+      std::vector<TypedExprPtr>{
+          std::make_shared<FieldAccessTypedExpr>(BIGINT(), "x")},
+      "negate");
+  auto call2 = std::make_shared<CallTypedExpr>(
+      BIGINT(),
+      std::vector<TypedExprPtr>{
+          std::make_shared<FieldAccessTypedExpr>(BIGINT(), "x")},
+      "negate");
+  EXPECT_EQ(call1->hash(), call2->hash());
+
+  // Create two equivalent FieldAccessTypedExpr
+  auto field1 = std::make_shared<FieldAccessTypedExpr>(VARCHAR(), "name");
+  auto field2 = std::make_shared<FieldAccessTypedExpr>(VARCHAR(), "name");
+  EXPECT_EQ(field1->hash(), field2->hash());
+
+  // Create two equivalent CastTypedExpr (cast)
+  auto cast1 = std::make_shared<CastTypedExpr>(
+      VARCHAR(),
+      std::vector<TypedExprPtr>{
+          std::make_shared<FieldAccessTypedExpr>(INTEGER(), "y")},
+      false);
+  auto cast2 = std::make_shared<CastTypedExpr>(
+      VARCHAR(),
+      std::vector<TypedExprPtr>{
+          std::make_shared<FieldAccessTypedExpr>(INTEGER(), "y")},
+      false);
+  EXPECT_EQ(cast1->hash(), cast2->hash());
+
+  // Create two equivalent CastTypedExpr (try_cast)
+  auto tryCast1 = std::make_shared<CastTypedExpr>(
+      VARCHAR(),
+      std::vector<TypedExprPtr>{
+          std::make_shared<FieldAccessTypedExpr>(INTEGER(), "z")},
+      true);
+  auto tryCast2 = std::make_shared<CastTypedExpr>(
+      VARCHAR(),
+      std::vector<TypedExprPtr>{
+          std::make_shared<FieldAccessTypedExpr>(INTEGER(), "z")},
+      true);
+  EXPECT_EQ(tryCast1->hash(), tryCast2->hash());
+}
+
+// Test that hash survives serialization roundtrip
+TEST_F(TypedExprHashConsistencyTest, serializationRoundtrip) {
+  auto testRoundtrip = [this](const TypedExprPtr& expr) {
+    auto originalHash = expr->hash();
+
+    // Serialize
+    auto serialized = expr->serialize();
+
+    // Deserialize
+    auto deserialized =
+        ISerializable::deserialize<ITypedExpr>(serialized, pool_.get());
+
+    // Hash should be the same
+    EXPECT_EQ(originalHash, deserialized->hash())
+        << "Hash changed after serialization roundtrip for: "
+        << expr->toString();
+  };
+
+  // Test various expression types
+  testRoundtrip(std::make_shared<InputTypedExpr>(INTEGER()));
+  testRoundtrip(makeConstantExpr(INTEGER(), variant(int32_t(42))));
+  testRoundtrip(makeConstantExpr(VARCHAR(), variant("test")));
+  testRoundtrip(std::make_shared<FieldAccessTypedExpr>(BIGINT(), "col"));
+  testRoundtrip(
+      std::make_shared<CallTypedExpr>(
+          BIGINT(),
+          std::vector<TypedExprPtr>{
+              std::make_shared<FieldAccessTypedExpr>(BIGINT(), "a")},
+          "abs"));
+  testRoundtrip(
+      std::make_shared<CastTypedExpr>(
+          VARCHAR(),
+          std::vector<TypedExprPtr>{
+              std::make_shared<FieldAccessTypedExpr>(INTEGER(), "x")},
+          false));
+}
+
+// Test that different expressions produce different hashes
+TEST_F(TypedExprHashConsistencyTest, distinctness) {
+  // Different constant values should have different hashes
+  auto int1 = makeConstantExpr(INTEGER(), variant(int32_t(1)));
+  auto int2 = makeConstantExpr(INTEGER(), variant(int32_t(2)));
+  EXPECT_NE(int1->hash(), int2->hash());
+
+  // Different types should have different hashes
+  auto intExpr = makeConstantExpr(INTEGER(), variant(int32_t(42)));
+  auto bigintExpr = makeConstantExpr(BIGINT(), variant(int64_t(42)));
+  EXPECT_NE(intExpr->hash(), bigintExpr->hash());
+
+  // Different field names should have different hashes
+  auto field1 = std::make_shared<FieldAccessTypedExpr>(INTEGER(), "a");
+  auto field2 = std::make_shared<FieldAccessTypedExpr>(INTEGER(), "b");
+  EXPECT_NE(field1->hash(), field2->hash());
+
+  // Different function names should have different hashes
+  auto call1 = std::make_shared<CallTypedExpr>(
+      BIGINT(),
+      std::vector<TypedExprPtr>{
+          std::make_shared<FieldAccessTypedExpr>(BIGINT(), "x")},
+      "abs");
+  auto call2 = std::make_shared<CallTypedExpr>(
+      BIGINT(),
+      std::vector<TypedExprPtr>{
+          std::make_shared<FieldAccessTypedExpr>(BIGINT(), "x")},
+      "negate");
+  EXPECT_NE(call1->hash(), call2->hash());
+
+  // cast vs try_cast should have different hashes
+  auto cast = std::make_shared<CastTypedExpr>(
+      VARCHAR(),
+      std::vector<TypedExprPtr>{
+          std::make_shared<FieldAccessTypedExpr>(INTEGER(), "x")},
+      false);
+  auto tryCast = std::make_shared<CastTypedExpr>(
+      VARCHAR(),
+      std::vector<TypedExprPtr>{
+          std::make_shared<FieldAccessTypedExpr>(INTEGER(), "x")},
+      true);
+  EXPECT_NE(cast->hash(), tryCast->hash());
+}
+
+// Test complex nested expressions
+TEST_F(TypedExprHashConsistencyTest, nestedExpressions) {
+  // Create a complex nested expression: cast(plus(a, b) as varchar)
+  auto fieldA = std::make_shared<FieldAccessTypedExpr>(BIGINT(), "a");
+  auto fieldB = std::make_shared<FieldAccessTypedExpr>(BIGINT(), "b");
+  auto plusExpr = std::make_shared<CallTypedExpr>(
+      BIGINT(), std::vector<TypedExprPtr>{fieldA, fieldB}, "plus");
+  auto castExpr = std::make_shared<CastTypedExpr>(
+      VARCHAR(), std::vector<TypedExprPtr>{plusExpr}, false);
+
+  // Create an equivalent expression
+  auto fieldA2 = std::make_shared<FieldAccessTypedExpr>(BIGINT(), "a");
+  auto fieldB2 = std::make_shared<FieldAccessTypedExpr>(BIGINT(), "b");
+  auto plusExpr2 = std::make_shared<CallTypedExpr>(
+      BIGINT(), std::vector<TypedExprPtr>{fieldA2, fieldB2}, "plus");
+  auto castExpr2 = std::make_shared<CastTypedExpr>(
+      VARCHAR(), std::vector<TypedExprPtr>{plusExpr2}, false);
+
+  // Equivalent nested expressions should have same hash
+  EXPECT_EQ(castExpr->hash(), castExpr2->hash());
+
+  // Idempotency
+  EXPECT_EQ(castExpr->hash(), castExpr->hash());
+}
+
+// Test lambda expressions
+TEST_F(TypedExprHashConsistencyTest, lambdaExpressions) {
+  auto signature = ROW({"x"}, {INTEGER()});
+  auto body = std::make_shared<FieldAccessTypedExpr>(INTEGER(), "x");
+  auto lambda1 = std::make_shared<LambdaTypedExpr>(signature, body);
+  auto lambda2 = std::make_shared<LambdaTypedExpr>(signature, body);
+
+  EXPECT_EQ(lambda1->hash(), lambda2->hash());
+  EXPECT_EQ(lambda1->hash(), lambda1->hash());
+}
+
+// Test concat expressions
+TEST_F(TypedExprHashConsistencyTest, concatExpressions) {
+  auto expr1 = std::make_shared<ConcatTypedExpr>(
+      std::vector<std::string>{"a", "b"},
+      std::vector<TypedExprPtr>{
+          std::make_shared<FieldAccessTypedExpr>(INTEGER(), "x"),
+          std::make_shared<FieldAccessTypedExpr>(VARCHAR(), "y")});
+  auto expr2 = std::make_shared<ConcatTypedExpr>(
+      std::vector<std::string>{"a", "b"},
+      std::vector<TypedExprPtr>{
+          std::make_shared<FieldAccessTypedExpr>(INTEGER(), "x"),
+          std::make_shared<FieldAccessTypedExpr>(VARCHAR(), "y")});
+
+  EXPECT_EQ(expr1->hash(), expr2->hash());
+  EXPECT_EQ(expr1->hash(), expr1->hash());
+}
+
+} // namespace facebook::velox::core::test
diff --git a/velox/core/tests/TypedExprSerdeTest.cpp b/velox/core/tests/TypedExprSerdeTest.cpp
index 62c6ae93006..16e32f48529 100644
--- a/velox/core/tests/TypedExprSerdeTest.cpp
+++ b/velox/core/tests/TypedExprSerdeTest.cpp
@@ -67,6 +67,18 @@ TEST_F(TypedExprSerDeTest, fieldAccess) {
       0);
   testSerde(expression);
   ASSERT_EQ(expression->toString(), "\"ab\"[a]");
+
+  expression = std::make_shared<DereferenceTypedExpr>(
+      INTEGER(),
+      std::make_shared<FieldAccessTypedExpr>(ROW({INTEGER(), VARCHAR()}), "x"),
+      0);
+  ASSERT_EQ(expression->toString(), "\"x\"[0]");
+
+  expression = std::make_shared<DereferenceTypedExpr>(
+      VARCHAR(),
+      std::make_shared<FieldAccessTypedExpr>(ROW({INTEGER(), VARCHAR()}), "x"),
+      1);
+  ASSERT_EQ(expression->toString(), "\"x\"[1]");
 }
 
 TEST_F(TypedExprSerDeTest, constant) {
@@ -144,4 +156,30 @@ TEST_F(TypedExprSerDeTest, lambda) {
   testSerde(expression);
 }
 
+TEST_F(TypedExprSerDeTest, nullIf) {
+  TypedExprPtr expression = std::make_shared<NullIfTypedExpr>(
+      std::make_shared<FieldAccessTypedExpr>(INTERVAL_DAY_TIME(), "a"),
+      std::make_shared<FieldAccessTypedExpr>(INTERVAL_DAY_TIME(), "b"),
+      INTERVAL_DAY_TIME());
+  testSerde(expression);
+
+  expression = std::make_shared<NullIfTypedExpr>(
+      std::make_shared<FieldAccessTypedExpr>(DATE(), "a"),
+      std::make_shared<FieldAccessTypedExpr>(DATE(), "b"),
+      DATE());
+  testSerde(expression);
+
+  expression = std::make_shared<NullIfTypedExpr>(
+      std::make_shared<FieldAccessTypedExpr>(TIME(), "a"),
+      std::make_shared<FieldAccessTypedExpr>(TIME(), "b"),
+      TIME());
+  testSerde(expression);
+
+  expression = std::make_shared<NullIfTypedExpr>(
+      std::make_shared<FieldAccessTypedExpr>(TIME_MICRO_UTC(), "a"),
+      std::make_shared<FieldAccessTypedExpr>(TIME_MICRO_UTC(), "b"),
+      TIME_MICRO_UTC());
+  testSerde(expression);
+}
+
 } // namespace facebook::velox::core::test
diff --git a/velox/docs/conf.py b/velox/docs/conf.py
index e6401fa5fd2..a87507e85da 100644
--- a/velox/docs/conf.py
+++ b/velox/docs/conf.py
@@ -51,6 +51,7 @@
     "pr",
     "spark",
     "iceberg",
+    "delta",
     "sphinx.ext.autodoc",
     "sphinx.ext.doctest",
     "sphinx.ext.mathjax",
diff --git a/velox/docs/configs.rst b/velox/docs/configs.rst
index 21eebecf8df..a30f901d552 100644
--- a/velox/docs/configs.rst
+++ b/velox/docs/configs.rst
@@ -27,6 +27,12 @@ Generic Configuration
      - 10000
      - Max number of rows that could be return by operators from Operator::getOutput. It is used when an estimate of
        average row size is known and preferred_output_batch_bytes is used to compute the number of output rows.
+   * - merge_join_output_batch_start_size
+     - integer
+     - 0
+     - Initial output batch size in rows for MergeJoin operator. When non-zero, the batch size starts at this value
+       and is dynamically adjusted based on the average row size of previous output batches. When zero (default),
+       dynamic adjustment is disabled and the batch size is fixed at preferred_output_batch_rows.
    * - max_elements_size_in_repeat_and_sequence
      - integer
      - 10000
@@ -43,6 +49,17 @@ Generic Configuration
      - integer
      - 80
      - Abandons partial TopNRowNumber if number of output rows equals or exceeds this percentage of the number of input rows.
+   * - abandon_dedup_hashmap_min_rows
+     - integer
+     - 100,000
+     - Number of input rows to receive before starting to check whether to abandon building a HashTable without
+       duplicates in HashBuild for left semi/anti join.
+   * - abandon_dedup_hashmap_min_pct
+     - integer
+     - 0
+     - Abandons building a HashTable without duplicates in HashBuild for left semi/anti join if the percentage of
+       distinct keys in the HashTable exceeds this threshold. Zero means 'disable this optimization'.
+       Does not apply to counting joins (kCountingAnti, kCountingLeftSemiFilter) which always require deduplication.
    * - session_timezone
      - string
      -
@@ -64,7 +81,7 @@ Generic Configuration
      - bool
      - true
      - If true, the driver will collect the operator's input/output batch size through vector flat size estimation, otherwise not.
-     - We might turn this off in use cases which have very wide column width and batch size estimation has non-trivial cpu cost.
+       We might turn this off in use cases which have very wide column width and batch size estimation has non-trivial cpu cost.
    * - hash_adaptivity_enabled
      - bool
      - true
@@ -73,6 +90,11 @@ Generic Configuration
      - bool
      - true
      - If true, the conjunction expression can reorder inputs based on the time taken to calculate them.
+   * - parallel_join_build_rows_enabled
+     - bool
+     - false
+     - If true, the hash probe drivers can output build\-side rows in parallel for full and right joins (only when spilling is not
+       enabled by hash probe). If false, only the last prober is allowed to output build\-side rows.
    * - max_local_exchange_buffer_size
      - integer
      - 32MB
@@ -106,6 +128,12 @@ Generic Configuration
        client. Enforced approximately, not strictly. A larger size can increase network throughput
        for larger clusters and thus decrease query processing time at the expense of reducing the
        amount of memory available for other usage.
+   * - skip_request_data_size_with_single_source_enabled
+     - bool
+     - false
+     -  If true, skip request data size if there is only single source.
+        This is used to optimize the Presto-on-Spark use case where each exchange client
+        has only one shuffle partition source.
    * - local_merge_source_queue_size
      - integer
      - 2
@@ -116,6 +144,10 @@ Generic Configuration
      - The maximum size in bytes for the task's buffered output when output is partitioned using hash of partitioning keys. See PartitionedOutputNode::Kind::kPartitioned.
        The producer Drivers are blocked when the buffered size exceeds this.
        The Drivers are resumed when the buffered size goes below OutputBufferManager::kContinuePct (90)% of this.
+   * - partitioned_output_eager_flush
+     - bool
+     - false
+     - If true, the PartitionedOutput operator will flush rows eagerly, without waiting until buffers reach certain size. Default is false.
    * - max_output_buffer_size
      - integer
      - 32MB
@@ -126,6 +158,21 @@ Generic Configuration
      - integer
      - 1000
      - The minimum number of table rows that can trigger the parallel hash join table build.
+   * - hash_probe_dynamic_filter_pushdown_enabled
+     - bool
+     - true
+     - Whether hash probe can generate any dynamic filter (including Bloom filter) and push down to upstream operators.
+   * - hash_probe_string_dynamic_filter_pushdown_enabled
+     - bool
+     - false
+     - Whether hash probe can generate dynamic filter for string types and push down to upstream operators.
+   * - hash_probe_bloom_filter_pushdown_max_size
+     - integer
+     - 0
+     - The maximum byte size of Bloom filter that can be generated from hash
+       probe.  When set to 0, no Bloom filter will be generated.  To achieve
+       optimal performance, this should not be too larger than the CPU cache
+       size on the host.
    * - debug.validate_output_from_operators
      - bool
      - false
@@ -148,6 +195,12 @@ Generic Configuration
      - 0
      - If it is not zero, specifies the time limit that a driver can continuously
        run on a thread before yield. If it is zero, then it no limit.
+   * - window_num_sub_partitions
+     - integer
+     - 1
+     - Window operator can be configured to sub-divide window partitions on each thread of execution into groups of
+       sub partitions for sequential processing. This setting specifies how many sub-partitions to create for each
+       thread. Use 1 to disable sub partitioning.
    * - prefixsort_normalized_key_max_bytes
      - integer
      - 128
@@ -200,7 +253,6 @@ Generic Configuration
        be expensive (especially if operator stats are retrieved frequently) and this allows the user to
        explicitly enable it.
 
-.. _expression-evaluation-conf:
 
 Expression Evaluation Configuration
 -----------------------------------
@@ -216,11 +268,40 @@ Expression Evaluation Configuration
      - boolean
      - false
      - Whether to use the simplified expression evaluation path.
+   * - expression.eval_flat_no_nulls
+     - boolean
+     - true
+     - Whether to enable the FlatNoNulls fast path for expression evaluation. When enabled, expressions skip null
+       checking and vector decoding when all inputs are flat-encoded with no nulls. Set to false to disable this
+       optimization.
    * - expression.track_cpu_usage
      - boolean
      - false
      - Whether to track CPU usage for individual expressions (supported by call and cast expressions). Can be expensive
        when processing small batches, e.g. < 10K rows.
+   * - expression.track_cpu_usage_for_functions
+     - string
+     - ""
+     - Comma-separated list of function names to selectively track CPU usage for. Only applicable when
+       ``expression.track_cpu_usage`` is set to false. Function names are case-insensitive and will be normalized
+       to lowercase. This allows fine-grained control over CPU tracking overhead when only specific functions need to
+       be monitored.
+   * - expression.adaptive_cpu_sampling
+     - boolean
+     - false
+     - Enables adaptive per-function CPU usage sampling. Each function is calibrated over 6 batches (1 warmup + 5
+       calibration) to measure the overhead of CPU tracking (clock_gettime) relative to the function's execution time.
+       The timer overhead is measured once per ExprSet and shared across all functions. Functions where tracking overhead
+       is acceptable are always tracked; functions where overhead exceeds ``expression.adaptive_cpu_sampling_max_overhead_pct``
+       are sampled at a rate proportional to their overhead. Sampled timing stats are extrapolated to approximate
+       full-population values.
+   * - expression.adaptive_cpu_sampling_max_overhead_pct
+     - float
+     - 1.0
+     - Maximum acceptable CPU tracking overhead percentage per function, used with ``expression.adaptive_cpu_sampling``.
+       Functions whose tracking overhead exceeds this threshold are sampled at a rate of
+       ceil(overhead_pct / max_overhead_pct). For example, with max_overhead=1.0, a function with 70% tracking overhead
+       is sampled every 70th batch, bounding its effective overhead to ~1%. Must be greater than 0.
    * - legacy_cast
      - bool
      - false
@@ -335,6 +416,12 @@ Spilling
      - boolean
      - true
      - When `spill_enabled` is true, determines whether Window operator can spill to disk under memory pressure.
+   * - window_spill_min_read_batch_rows
+     - integer
+     - 1000
+     - When processing spilled window data, read batches of whole partitions having at least that many rows. Set to 1 to
+       read one whole partition at a time. Each driver processing the Window operator will process that much data at
+       once.
    * - row_number_spill_enabled
      - boolean
      - true
@@ -343,6 +430,10 @@ Spilling
      - boolean
      - true
      - When `spill_enabled` is true, determines whether TopNRowNumber operator can spill to disk under memory pressure.
+   * - mark_distinct_spill_enabled
+     - boolean
+     - false
+     - When `spill_enabled` is true, determines whether MarkDistinct operator can spill to disk under memory pressure.
    * - writer_spill_enabled
      - boolean
      - true
@@ -428,6 +519,12 @@ Spilling
      - Specifies the compression algorithm type to compress the spilled data before write to disk to trade CPU for IO
        efficiency. The supported compression codecs are: zlib, snappy, lzo, zstd, lz4 and gzip.
        none means no compression.
+   * - spill_num_max_merge_files
+     - integer
+     - 0
+     - The max number of files to merge at a time when merging sorted files into a single ordered stream. 0 means unlimited.
+       This is used to reduce memory pressure by capping the number of open files when merging spilled sorted files to
+       avoid using too much memory and causing OOM. Note that this is only applicable for ordered spill.
    * - spill_prefixsort_enabled
      - bool
      - false
@@ -465,6 +562,28 @@ Aggregation
      - integer
      - 80
      - Abandons partial aggregation if number of groups equals or exceeds this percentage of the number of input rows.
+   * - aggregation_compaction_bytes_threshold
+     - integer
+     - 0
+     - Memory threshold in bytes for triggering string compaction during global
+       aggregation. When total string storage exceeds this limit with high unused
+       memory ratio, compaction is triggered to reclaim dead strings. Disabled by
+       default (0). Currently only applies to approx_most_frequent aggregate with
+       StringView type during global aggregation.
+   * - aggregation_compaction_unused_memory_ratio
+     - double
+     - 0.25
+     - Ratio of unused (evicted) bytes to total bytes that triggers compaction.
+       The value is in the range of [0, 1). Currently only applies to approx_most_frequent
+       aggregate with StringView type during global aggregation. May be extended
+       to other aggregation types on-demand.
+   * - aggregation_memory_compaction_reclaim_enabled
+     - bool
+     - false
+     - If true, enables lightweight memory compaction before spilling during
+       memory reclaim in aggregation. When enabled, the aggregation operator
+       will try to compact aggregate function state (e.g., free dead strings)
+       before resorting to spilling.
    * - streaming_aggregation_min_output_batch_rows
      - integer
      - 0
@@ -503,6 +622,13 @@ Table Scan
        increasing the number of running scan threads, and stop once exceeds this
        ratio. The value is in the range of [0, 1]. This only applies if
        'table_scan_scaled_processing_enabled' is true.
+   * - table_scan_output_batch_rows_override
+     - integer
+     - 0
+     - If non-zero, overrides the number of rows in each output batch produced
+       by the TableScan operator, bypassing the dynamic batch size calculation.
+       This is useful for correctness testing where a fixed batch size is needed
+       to produce deterministic results. Zero means 'no override'.
 
 Table Writer
 ------------
@@ -548,11 +674,50 @@ Table Writer
      - Minimum amount of data processed by all the logical table partitions to
        trigger skewed partition rebalancing by scale writer exchange.
 
+Connector Config
+----------------
+Connector config is initialized on velox runtime startup and is shared among queries as the default config across all connectors.
+Each query can override the config by setting corresponding query session properties such as in Prestissimo.
+
+.. list-table::
+   :widths: 20 20 10 10 70
+   :header-rows: 1
+
+   * - Configuration Property Name
+     - Session Property Name
+     - Type
+     - Default Value
+     - Description
+   * - user
+     -
+     - string
+     - ""
+     - The user of the query. Used for storage logging.
+   * - source
+     -
+     - string
+     - ""
+     - The source of the query. Used for storage access and logging.
+   * - schema
+     -
+     - string
+     - ""
+     - The schema of the query. Used for storage logging.
+
 Hive Connector
 --------------
 Hive Connector config is initialized on velox runtime startup and is shared among queries as the default config.
 Each query can override the config by setting corresponding query session properties such as in Prestissimo.
 
+Configuration property names use kebab-case (e.g., ``max-bucket-count``).
+Session property names use snake_case (e.g., ``max_bucket_count``).
+Properties without a session property name in the table below are fixed for the lifetime of the process
+and cannot be modified per query.
+
+Properties of type ``capacity`` accept human-readable size strings such as ``512kB``, ``128MB``, ``1GB``, etc.
+Properties of type ``integer`` with byte-valued defaults (shown as ``256KB``, ``8MB``, etc. for readability)
+must be specified as raw byte counts.
+
 .. list-table::
    :widths: 20 20 10 10 70
    :header-rows: 1
@@ -562,13 +727,13 @@ Each query can override the config by setting corresponding query session proper
      - Type
      - Default Value
      - Description
-   * - hive.max-partitions-per-writers
-     -
+   * - max-partitions-per-writers
+     - max_partitions_per_writers
      - integer
-     - 100
+     - 128
      - Maximum number of (bucketed) partitions per a single table writer instance.
-   * - hive.max-bucket-count
-     - hive.max_bucket_count
+   * - max-bucket-count
+     - max_bucket_count
      - integer
      - 100000
      - Maximum number of buckets that a table writer is allowed to write to.
@@ -580,7 +745,7 @@ Each query can override the config by setting corresponding query session proper
        the update mode field of the table writer operator output. ``OVERWRITE``
        sets the update mode to indicate overwriting a partition if exists. ``ERROR`` sets the update mode to indicate
        error throwing if writing to an existing partition.
-   * - hive.immutable-partitions
+   * - immutable-partitions
      -
      - bool
      - false
@@ -617,7 +782,7 @@ Each query can override the config by setting corresponding query session proper
      - Maximum size in bytes to coalesce requests to be fetched in a single request.
    * - max-coalesced-distance
      -
-     - integer
+     - capacity
      - 512KB
      - Maximum distance in capacity units between chunks to be fetched that may be coalesced into a single request.
    * - load-quantum
@@ -644,21 +809,23 @@ Each query can override the config by setting corresponding query session proper
      - Maximum number of rows for sort writer in one batch of output. This is to limit the memory usage of sort writer.
    * - sort-writer-max-output-bytes
      - sort_writer_max_output_bytes
-     - string
+     - capacity
      - 10MB
      - Maximum bytes for sort writer in one batch of output. This is to limit the memory usage of sort writer.
+   * - max-target-file-size
+     - max_target_file_size
+     - capacity
+     - 0B
+     - Maximum target file size for writers. When a file exceeds this size during writing, the writer
+       closes the current file and starts writing to a new file. Accepts human-readable values like
+       "1GB". Zero means no limit (default). File rotation is not supported for bucketed tables or
+       sorted writes.
    * - file-preload-threshold
      -
      - integer
      - 8MB
      - Usually Velox fetches the meta data firstly then fetch the rest of file. But if the file is very small, Velox can fetch the whole file directly to avoid multiple IO requests.
        The parameter controls the threshold when whole file is fetched.
-   * - footer-estimated-size
-     -
-     - integer
-     - 1MB
-     - Define the estimation of footer size in ORC and Parquet format. The footer data includes version, schema, and meta data for every columns which may or may not need to be fetched later.
-       The parameter controls the size when footer is fetched each time. Bigger value can decrease the IO requests but may fetch more useless meta data.
    * - cache.no_retention
      - cache.no_retention
      - bool
@@ -667,25 +834,74 @@ Each query can override the config by setting corresponding query session proper
        and also skip staging to the ssd cache. This helps to prevent the cache space pollution
        from the one-time table scan by large batch query when mixed running with interactive
        query which has high data locality.
-   * - hive.reader.stats_based_filter_reorder_disabaled
-     - hive.reader.stats_based_filter_reorder_disabaled
+   * - stats-based-filter-reorder-disabled
+     - stats_based_filter_reorder_disabled
      - bool
      - false
      - If true, disable the stats based filter reordering during the read processing, and the
        filter execution order is totally determined by the filter type. Otherwise, the file
        reader will dynamically adjust the filter execution order based on the past filter
        execution stats.
-   * - hive.reader.timestamp-partition-value-as-local-time
-     - hive.reader.timestamp_partition_value_as_local_time
+   * - reader.timestamp-partition-value-as-local-time
+     - reader.timestamp_partition_value_as_local_time
      - bool
      - true
      - Reads timestamp partition value as local time if true. Otherwise, reads as UTC.
-   * - hive.preserve-flat-maps-in-memory
-     - hive.preserve_flat_maps_in_memory
+   * - preserve-flat-maps-in-memory
+     - preserve_flat_maps_in_memory
      - bool
      - false
      - Whether to preserve flat maps in memory as FlatMapVectors instead of converting them to MapVectors. This is only applied during data reading inside the DWRF and Nimble readers, not during downstream processing like expression evaluation etc.
-
+   * - max-rows-per-index-request
+     - max_rows_per_index_request
+     - integer
+     - 0
+     - Maximum number of output rows to return per index lookup request. The limit is applied to the actual output rows
+       after filtering. 0 means no limit (default).
+   * - file-metadata-cache-enabled
+     - file_metadata_cache_enabled
+     - bool
+     - false
+     - Whether to cache file metadata (footer, stripes, index) in the process-wide AsyncDataCache. When enabled,
+       the first reader performs a speculative tail read and populates the cache; subsequent readers on the same file
+       serve metadata from cache with zero file IO. Currently only supported by Nimble format.
+   * - pin-file-metadata
+     - pin_file_metadata
+     - bool
+     - false
+     - Whether to pin parsed metadata objects (e.g., StripeGroup, IndexGroup) in the reader's metadata cache with
+       strong references so they are never evicted. This avoids re-reading and re-parsing metadata on every stripe
+       access when weak-pointer cache entries would otherwise expire. Can be used independently of
+       file-metadata-cache-enabled. Currently only supported by Nimble format.
+   * - reader.collect-column-cpu-metrics
+     - reader.collect_column_cpu_metrics
+     - bool
+     - false
+     - If true, enables collection of per-column timing statistics during file reading. This includes
+       decompression and decode CPU time metrics for each column, reported as runtime metrics in the format
+       ``column_<nodeId>.<type>.decompressCPUTimeNanos`` and ``column_<nodeId>.<type>.decodeCPUTimeNanos``.
+       Useful for performance analysis and identifying slow columns.
+   * - orc.footer-speculative-io-size
+     - orc_footer_speculative_io_size
+     - integer
+     - 256KB
+     - Speculative tail-read size in bytes when opening ORC files. Controls how many bytes are read from the end
+       of the file to load the footer and nearby metadata in a single IO operation.
+       Set to 0 for adaptive mode.
+   * - parquet.footer-speculative-io-size
+     - parquet_footer_speculative_io_size
+     - integer
+     - 256KB
+     - Speculative tail-read size in bytes when opening Parquet files. Controls how many bytes are read from the end
+       of the file to load the footer and nearby metadata in a single IO operation.
+       Set to 0 for adaptive mode.
+   * - nimble.footer-speculative-io-size
+     - nimble_footer_speculative_io_size
+     - integer
+     - 8MB
+     - Speculative tail-read size in bytes when opening Nimble files. Controls how many bytes are read from the end
+       of the file to load the footer and nearby metadata in a single IO operation.
+       Set to 0 for adaptive mode.
 
 ``ORC File Format Configuration``
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -778,7 +994,7 @@ Each query can override the config by setting corresponding query session proper
      - 1024
      - Batch size used when writing into Parquet through Arrow bridge.
    * - hive.parquet.writer.created-by
-     -
+     - hive.parquet.writer.created_by
      - string
      - parquet-cpp-velox version 0.0.0
      - Created-by value used when writing to Parquet.
@@ -879,6 +1095,19 @@ Each query can override the config by setting corresponding query session proper
      -
      - A custom credential provider, if specified, will be used to create the client in favor of other authentication mechanisms.
        The provider must be registered using "registerAWSCredentialsProvider" before it can be used.
+   * - hive.s3.aws-imds-enabled
+     - bool
+     - true
+     - AWS Instance Metadata Service (IMDS) is an AWS EC2 instance component used by applications to securely access metadata.
+       We must disable it on other instances to avoid high first-time read latency from S3 compatible object storages.
+   * - hive.s3.min-part-size
+     - string
+     - 10MB
+     - Minimum multi-part upload part size. The smallest allowed value is 5MB. The largest allowed value is 5GB.
+       If a file is less than this size, the file is sent as a single put request.
+       Otherwise, the file is split into multiple equal sized chunks of this part size excluding the last chunk.
+       The `AWS specification <https://docs.aws.amazon.com/AmazonS3/latest/userguide/qfacts.html> `_ limits the part size between 5MB and 5GB.
+       Some S3 backend providers enforce these limits strictly.
 
 Bucket Level Configuration
 """"""""""""""""""""""""""
@@ -898,23 +1127,23 @@ These semantics are similar to the `Apache Hadoop-Aws module <https://hadoop.apa
      - Type
      - Default Value
      - Description
-   * - hive.gcs.endpoint
+   * - gcs.endpoint
      - string
      -
      - The GCS storage URI.
-   * - hive.gcs.json-key-file-path
+   * - gcs.json-key-file-path
      - string
      -
      - The GCS service account configuration JSON key file.
-   * - hive.gcs.max-retry-count
+   * - gcs.max-retry-count
      - integer
      -
      - The GCS maximum retry counter of transient errors.
-   * - hive.gcs.max-retry-time
+   * - gcs.max-retry-time
      - string
      -
      - The GCS maximum time allowed to retry transient errors.
-   * - hive.gcs.auth.access-token-provider
+   * - gcs.auth.access-token-provider
      - string
      -
      - A custom OAuth credential provider, if specified, will be used to create the client in favor of other
@@ -970,6 +1199,12 @@ These semantics are similar to the `Apache Hadoop-Aws module <https://hadoop.apa
      - Specifies the OAuth 2.0 token endpoint URL for the Azure AD application.
        This endpoint is used to acquire access tokens for authenticating with Azure storage.
        The URL follows the format: `https://login.microsoftonline.com/<tenant-id>/oauth2/token`.
+   * - fs.azure.sas.token.renew.period.for.streams
+     - string
+     - 120
+     - Specifies the period in seconds to re-use SAS tokens until the expiry is within this number of seconds.
+       This configuration is used together with `registerSasTokenProvider` for dynamic SAS token renewal.
+       When a SAS token is close to expiry, it will be renewed by getting a new token from the provider.
 
 Presto-specific Configuration
 -----------------------------
@@ -1012,15 +1247,18 @@ Spark-specific Configuration
      - integer
      - 1000000
      - The default number of expected items for the bloom filter in :spark:func:`bloom_filter_agg` function.
+   * - spark.bloom_filter.max_num_items
+     - integer
+     - 4000000
+     - The maximum number of items for the bloom filter in :spark:func:`bloom_filter_agg` function.
    * - spark.bloom_filter.num_bits
      - integer
      - 8388608
      - The default number of bits to use for the bloom filter in :spark:func:`bloom_filter_agg` function.
    * - spark.bloom_filter.max_num_bits
      - integer
-     - 4194304
-     - The maximum number of bits to use for the bloom filter in :spark:func:`bloom_filter_agg` function,
-       the value of this config can not exceed the default value.
+     - 67108864
+     - The maximum number of bits to use for the bloom filter in :spark:func:`bloom_filter_agg` function.
    * - spark.partition_id
      - integer
      -
@@ -1078,3 +1316,145 @@ Tracing
      - false
      - If true, we only collect the input trace for a given operator but without the actual
        execution. This is used for crash debugging.
+
+Cudf-specific Configuration (Experimental)
+------------------------------------------
+These configurations are available when `compiled with cuDF <https://github.com/facebookincubator/velox/blob/main/velox/experimental/cudf/README.md#getting-started-with-velox-cudf>`_.
+Note: These configurations are experimental and subject to change.
+
+.. list-table::
+   :widths: 30 10 10 70
+   :header-rows: 1
+
+   * - Property Name
+     - Type
+     - Default Value
+     - Description
+   * - cudf.enabled
+     - bool
+     - true
+     - If true, enable cuDF. By default, it is enabled if compiled with cuDF.
+   * - cudf.memory_resource
+     - string
+     - async
+     - The memory resource to use for cuDF. Possible values are (cuda, pool, async, arena, managed, managed_pool, prefetch_managed, prefetch_managed_pool).
+       The prefetch options enable automatic prefetching for better GPU memory performance: prefetch_managed uses CUDA unified memory with prefetching,
+       prefetch_managed_pool uses a pooled version of CUDA unified memory with prefetching.
+   * - cudf.memory_percent
+     - integer
+     - 50
+     - The initial percent of GPU memory to allocate for pool or arena memory resources.
+   * - cudf.function_name_prefix
+     - string
+     - ""
+     - The prefix to use for the function names in cuDF.
+   * - cudf.ast_expression_enabled
+     - bool
+     - true
+     - If true, enable using cuDF AST-based expression evaluation when supported.
+   * - cudf.ast_expression_priority
+     - integer
+     - 100
+     - Priority of cuDF AST expressions. Higher value wins when multiple cuDF execution options are available for the same Velox expression. Standalone cuDF functions have priority 50. If enabled, with a default priority of 100, AST will be chosen as replacement for cudf execution.
+   * - cudf.allow_cpu_fallback
+     - bool
+     - true
+     - If true, allow falling back to Velox CPU execution when an operation is not supported in cuDF execution. If false, an error will be thrown if an operation is not supported in cuDF execution.
+   * - cudf.debug_enabled
+     - bool
+     - false
+     - If true, enable debug printing.
+   * - cudf.log_fallback
+     - bool
+     - true
+     - If true, log a reason for falling back to Velox CPU execution, when an operation is not supported in cuDF execution.
+   * - cudf.function_engine
+     - string
+     - presto
+   * - cudf.timestamp_unit
+     - string
+     - ns
+     - Timestamp precision unit for cuDF timestamp types. Valid values are: "s" (seconds), "ms" (milliseconds), "us" (microseconds), "ns" (nanoseconds). This controls the precision of timestamp data when converting between Velox and cuDF formats.
+     - Register the function for a specific engine. The optional values are presto or spark.
+
+Cudf Hive Connector Configuration (Experimental)
+------------------------------------------------
+These configurations apply to the cuDF Hive connector (Parquet reader/writer via cuDF).
+Connector config is initialized on velox runtime startup and is shared among queries as the default config.
+Each query can override the config by setting the corresponding session property.
+Reader options map to `libcudf parquet_reader_options <https://docs.rapids.ai/api/libcudf/stable/classcudf_1_1io_1_1parquet__reader__options>`_ (used with the chunked reader when applicable).
+
+.. list-table::
+   :widths: 20 20 10 10 70
+   :header-rows: 1
+
+   * - Configuration Property Name
+     - Session Property Name
+     - Type
+     - Default Value
+     - Description
+   * - cudf.hive.use-buffered-input
+     - cudf.hive.use_buffered_input
+     - bool
+     - true
+     - Whether to use BufferedInput for CudfHiveDataSource (can use AsyncDataCache when HiveConfig file handle cache is enabled).
+   * - cudf.hive.use-experimental-reader
+     - cudf.hive.use_experimental_reader
+     - bool
+     - false
+     - Whether to use the experimental cuDF Parquet reader (Hybrid Scan) for highly selective filters. When enabled, uses `libcudf hybrid_scan_reader <https://docs.rapids.ai/api/libcudf/stable/classcudf_1_1io_1_1parquet_1_1experimental_1_1hybrid__scan__reader>`_.
+   * - parquet.reader.use-pandas-metadata
+     - parquet.reader.use_pandas_metadata
+     - bool
+     - true
+     - Enable or disable use of pandas metadata while reading. Maps to ``enable_use_pandas_metadata`` in `libcudf parquet_reader_options <https://docs.rapids.ai/api/libcudf/stable/classcudf_1_1io_1_1parquet__reader__options>`_.
+   * - parquet.reader.use-arrow-schema
+     - parquet.reader.use_arrow_schema
+     - bool
+     - true
+     - Enable or disable use of Arrow schema while reading. Maps to ``enable_use_arrow_schema`` in `libcudf parquet_reader_options <https://docs.rapids.ai/api/libcudf/stable/classcudf_1_1io_1_1parquet__reader__options>`_.
+   * - parquet.reader.allow-mismatched-parquet-schemas
+     - parquet.reader.allow_mismatched_parquet_schemas
+     - bool
+     - false
+     - Enable or disable reading matching projected and filter columns from mismatched Parquet sources. Maps to ``enable_allow_mismatched_pq_schemas`` in `libcudf parquet_reader_options <https://docs.rapids.ai/api/libcudf/stable/classcudf_1_1io_1_1parquet__reader__options>`_.
+   * - parquet.reader.timestamp-type
+     - parquet.reader.timestamp_type
+     - string
+     - TIMESTAMP_MILLISECONDS
+     - Timestamp type used to cast all timestamp columns (e.g. TIMESTAMP_DAYS, TIMESTAMP_SECONDS, TIMESTAMP_MILLISECONDS, TIMESTAMP_MICROSECONDS, TIMESTAMP_NANOSECONDS). Maps to ``set_timestamp_type`` in `libcudf parquet_reader_options <https://docs.rapids.ai/api/libcudf/stable/classcudf_1_1io_1_1parquet__reader__options>`_.
+   * - parquet.reader.chunk-read-limit
+     - parquet.reader.chunk_read_limit
+     - integer
+     - 0
+     - Limit on total number of bytes to be returned per read (per table chunk); 0 means no limit. Maps to ``chunk_read_limit`` in `libcudf hybrid_scan_reader <https://docs.rapids.ai/api/libcudf/stable/classcudf_1_1io_1_1parquet_1_1experimental_1_1hybrid__scan__reader>`_ (e.g. ``setup_chunking_for_filter_columns``, ``setup_chunking_for_payload_columns``).
+   * - parquet.reader.pass-read-limit
+     - parquet.reader.pass_read_limit
+     - integer
+     - 0
+     - Limit on the amount of memory (bytes) used for reading and decompressing data; 0 means no limit. This is a hint, not an absolute limit—if a single row group cannot fit within the limit, it will still be loaded. Affects how many row groups can be read at a time by limiting decompression space. Maps to ``pass_read_limit`` in `libcudf hybrid_scan_reader <https://docs.rapids.ai/api/libcudf/stable/classcudf_1_1io_1_1parquet_1_1experimental_1_1hybrid__scan__reader>`_ (e.g. ``setup_chunking_for_filter_columns``, ``setup_chunking_for_payload_columns``).
+   * - parquet.reader.convert-strings-to-categories
+     - parquet.reader.convert_strings_to_categories
+     - bool
+     - false
+     - Whether to store string data as categorical type.
+   * - parquet.writer.write-timestamps-as-utc
+     - parquet.writer.write_timestamps_as_utc
+     - bool
+     - true
+     - Whether to write timestamps as UTC.
+   * - sort-writer_finish_time_slice_limit_ms
+     - sort_writer_finish_time_slice_limit_ms
+     - integer
+     - 5000
+     - Sort writer exits finish() after this many milliseconds even if work is not complete; 0 means no time limit.
+   * - parquet.writer.write-arrow-schema
+     - parquet.writer.write_arrow_schema
+     - bool
+     - false
+     - Whether to write ARROW schema.
+   * - parquet.writer.write-v2-page-headers
+     - parquet.writer.write_v2_page_headers
+     - bool
+     - false
+     - Whether to write V2 page headers.
diff --git a/velox/docs/designs/column-extraction-pushdown.md b/velox/docs/designs/column-extraction-pushdown.md
new file mode 100644
index 00000000000..ba5dd4e1c24
--- /dev/null
+++ b/velox/docs/designs/column-extraction-pushdown.md
@@ -0,0 +1,767 @@
+# Column Extraction Pushdown Proposal
+
+*2026-03-04*
+
+## Motivation
+
+Queries like `SELECT map_keys(col) FROM t`, `SELECT cardinality(col) FROM t`,
+or `SELECT map_values(col).x FROM t` currently read the entire complex-typed
+column from storage, even though only a subset of its physical streams is
+needed.  For a `MAP(K, V)` column, `map_keys` only needs keys (not values), and
+`cardinality` only needs the lengths stream (neither keys nor values).
+
+This waste is significant for wide map/struct values — the reader
+materializes data that the engine immediately discards.
+
+**Column extraction pushdown** is a new pushdown mechanism, separate from
+subfield pruning, that tells the reader to extract a specific component from a
+complex type and produce it as a **different output type**.  For example,
+extracting map keys produces an `ARRAY(K)` instead of a `MAP(K, V)`.
+
+### Distinction from subfield pruning
+
+|                | Subfield pruning                     | Column extraction                                  |
+|----------------|--------------------------------------|----------------------------------------------------|
+| Output type    | Same as input (MAP stays MAP)        | Different (MAP -> ARRAY, MAP/ARRAY -> BIGINT)      |
+| Semantics      | Drop unused parts, null-fill         | Transform the type structure                       |
+| Mechanism      | `requiredSubfields` on column handle | `extractions` (NamedExtraction list) on column handle |
+| Composability  | N/A                                  | N/A — mutually exclusive with subfield pruning     |
+
+### Why not extend subfield pruning?
+
+Consider this query:
+
+```sql
+SELECT cardinality(col) AS a, col['foo'] AS b FROM t
+```
+
+where `col` is `MAP(VARCHAR, BIGINT)`.
+
+Both `a` and `b` reference the same column `col`, but they need fundamentally
+different things:
+
+- `a` needs only the size — no keys, no values.
+- `b` needs the key `"foo"` and its corresponding value.
+
+With subfield pruning, a single column handle represents `col`.  The required
+subfields from both references are merged:
+
+```
+requiredSubfields: ["col[$]", "col[\"foo\"]"]
+```
+
+These are contradictory: `[$]` says "skip keys and values" while `["foo"]` says
+"read key `foo` and its value." The reader cannot satisfy both with one pass —
+it must read the whole column in order to return maps with correct size, and
+if it only reads key `foo` the result would be incorrect.
+
+Column extraction solves this with a single column handle that carries
+**multiple named extraction chains**.  The column is read once, and each
+extraction is applied independently:
+
+```
+assignments: {
+    "col": {
+        name: "col",
+        hiveType: MAP(VARCHAR, BIGINT),
+        dataType: ROW({ "a": BIGINT, "b": ARRAY(BIGINT) }),
+        extractions: [
+            { outputName: "a", chain: [Size],  dataType: BIGINT },
+            { outputName: "b", chain: [MapKeyFilter(["foo"]), MapValues],  dataType: ARRAY(BIGINT) }
+        ],
+    }
+}
+```
+
+The reader reads `col` once — it reads sizes without restriction (`a`), and read
+keys and values with a filter on the key (since `b` needs only key `"foo"`), and
+further apply remaining of the chain in `b` in the column reader of map values.
+
+This is the core reason column extraction is a new mechanism rather than an
+extension of subfield pruning.  Subfield pruning merges all references to a
+column into one output, which forces the reader to satisfy the union of all
+requirements.  Column extraction keeps a single column handle but produces
+multiple named outputs, each with its own extraction chain.
+
+## Protocol: Extraction Chain
+
+The extraction is expressed as an ordered chain of steps.  Each step operates on
+one nesting level of the source type.  The chain is a new field on the column
+handle, mutually exclusive with `requiredSubfields`.
+
+### Extraction steps
+
+```
+ExtractionStep =
+  | StructField(name: string)    // Navigate into a struct field.
+  | MapKeys                      // Extract map keys.  MAP(K, V) → ARRAY(K).
+  | MapValues                    // Extract map values.  MAP(K, V) → ARRAY(V).
+  | MapKeyFilter(keys: list)     // Filter map to specific keys.
+  |                              //   MAP(K, V) → MAP(K, V).  Type-preserving.
+  |                              //   Keys are strings or integers depending on
+  |                              //   the map's key type.
+  | ArrayElements                // Navigate into array elements.
+  | Size                         // Extract size.  MAP/ARRAY → BIGINT.  Terminal.
+```
+
+### Step input/output types (validation)
+
+Each step's output feeds as input to the next step.  This forms a linear
+pipeline for **type validation**:
+
+| Step               | Required input              | Output       |
+|--------------------|-----------------------------|--------------|
+| `StructField(f)`   | `ROW(..., f: T, ...)`       | `T`          |
+| `MapKeys`          | `MAP(K, V)`                 | `ARRAY(K)`   |
+| `MapValues`        | `MAP(K, V)`                 | `ARRAY(V)`   |
+| `MapKeyFilter(ks)` | `MAP(K, V)`                 | `MAP(K, V)`  |
+| `ArrayElements`    | `ARRAY(T)`                  | `T`          |
+| `Size`             | `MAP(K, V)` or `ARRAY(T)`   | `BIGINT`     |
+
+**Rule:** `MapKeys` and `MapValues` produce `ARRAY(...)`.  Any subsequent step
+sees `ARRAY` as input.  Therefore, `MapKeys`/`MapValues` **must** be followed
+by `ArrayElements` unless it is the last step in the chain.  `MapKeyFilter` is
+type-preserving (`MAP` → `MAP`) and does NOT require `ArrayElements` after it.
+
+### Output type derivation
+
+The validation pipeline loses nesting information (each `ArrayElements`
+unwraps one `ARRAY` layer).  The actual output type is derived recursively:
+
+```
+derive(T, []) = T
+
+derive(ROW(.., f:T, ..), [StructField(f),               ...rest]) = derive(T, rest)
+
+derive(MAP(K, V),         [MapKeys,       ArrayElements, ...rest]) = ARRAY(derive(K, rest))
+derive(MAP(K, V),         [MapKeys])                               = ARRAY(K)
+
+derive(MAP(K, V),         [MapValues,     ArrayElements, ...rest]) = ARRAY(derive(V, rest))
+derive(MAP(K, V),         [MapValues])                             = ARRAY(V)
+
+derive(MAP(K, V),         [MapKeyFilter,                ...rest]) = derive(MAP(K, V), rest)
+
+derive(ARRAY(T),          [ArrayElements,                ...rest]) = ARRAY(derive(T, rest))
+
+derive(MAP|ARRAY,         [Size])                                  = BIGINT
+```
+
+`MapKeys`/`MapValues` + `ArrayElements` are consumed as a pair — the
+extraction wraps in `ARRAY`, and `ArrayElements` enters it.  `MapKeyFilter` is
+type-preserving and does not consume an `ArrayElements`.  A standalone
+`ArrayElements` (without a preceding extraction step) handles a source `ARRAY`
+level.
+
+### `ArrayElements` roles
+
+| Context                      | Role                                                                                          |
+|------------------------------|-----------------------------------------------------------------------------------------------|
+| After `MapKeys`/`MapValues`  | Consumes the `ARRAY` produced by extraction.  **Mandatory** to continue the chain.            |
+| On a source `ARRAY` type     | Navigates into the array's elements.  **Mandatory** when the source type has an `ARRAY` level.|
+
+Every `ARRAY` boundary in the chain — whether from extraction or from the
+source type — is explicitly represented by an `ArrayElements` step.
+
+### Mutual exclusivity with subfield pruning
+
+Column extraction (`extractions`) and subfield pruning (`requiredSubfields`)
+**cannot coexist** on the same column handle.  A column handle uses either
+`requiredSubfields` (type-preserving pruning) or `extractions` (extraction
+chains), but not both.
+
+This simplifies the reader contract — the reader either prunes subfields
+within the existing type structure, or applies extraction chains to produce
+new types.  There is no ambiguity about which operation runs first or how
+their type changes interact.
+
+**When to use which:**
+
+- Use `requiredSubfields` when the column's output type stays the same as the
+  file type (struct field pruning, map key filtering, array index truncation).
+- Use `extractions` when the column's output type changes (MapKeys, MapValues,
+  Size, StructField extraction, or any chain that transforms the type).
+
+**Expressing subfield-like operations in extraction chains:**
+
+Operations that would have used `requiredSubfields` can be expressed as
+extraction steps instead:
+
+- Struct field access → `StructField(name)` in the chain
+- Map key filtering → `MapKeyFilter(keys)` in the chain
+- Multiple struct fields → multiple `NamedExtraction` entries, each with a
+  `StructField` chain
+
+For example, instead of `requiredSubfields: ["col.x", "col.y"]`, use:
+```
+extractions: [
+    { outputName: "x", chain: [StructField("x")], dataType: INT },
+    { outputName: "y", chain: [StructField("y")], dataType: INT }
+]
+```
+
+### Overlap between `MapKeyFilter` and map key pruning
+
+`MapKeyFilter` and subfield pruning's map key subscripts (`["key1"]`, `["key2"]`)
+both filter a map to specific keys.  They overlap in functionality but differ in
+where they sit:
+
+- **Subfield pruning** (`requiredSubfields: ["col[\"foo\"]"]`): filters keys on
+  the source column, output stays `MAP(K, V)`.  No extraction chain involved.
+- **`MapKeyFilter`**: filters keys as a step in the extraction chain, output
+  stays `MAP(K, V)`.  Can compose with other extraction steps.
+
+Since extraction and subfield pruning are mutually exclusive on the same column
+handle, use one or the other:
+
+- Use `requiredSubfields` when key filtering is the only operation needed and
+  no type transformation is involved.
+- Use `MapKeyFilter` in an extraction chain when key filtering combines with
+  other extraction steps (e.g., `[MapKeyFilter(["foo"]), MapValues]`).
+
+### Overlap between `StructField` and struct subfield pruning
+
+`StructField` and subfield pruning's nested field paths (`.field1`, `.field2`)
+both navigate into struct fields.  They overlap when accessing struct children:
+
+- **Subfield pruning** (`requiredSubfields: ["col.x"]`): prunes the struct to
+  only field `x`, output stays `ROW(...)` with other fields null-filled.
+- **`StructField("x")`**: extracts field `x` as a step in the extraction chain,
+  output becomes the field's type directly (e.g., `INT`).
+
+Since extraction and subfield pruning are mutually exclusive:
+
+- Use `requiredSubfields` for struct pruning when no type transformation is
+  needed (output stays ROW).
+- Use `StructField` in an extraction chain when struct navigation combines
+  with other extraction steps (e.g., `[StructField("a"), MapKeys]`).
+
+## Examples
+
+### `map_keys(col)` — `col: MAP(K, V)`
+
+```
+Chain: [MapKeys]
+Validation:  MAP(K,V) → MapKeys → ARRAY(K) ✓
+Output:      ARRAY(K)
+```
+
+### `map_keys(col.a.b)` — `col: ROW(a: ROW(b: MAP(K, V)))`
+
+```
+Chain: [StructField("a"), StructField("b"), MapKeys]
+Validation:  ROW → StructField("a") → ROW → StructField("b") → MAP(K,V) → MapKeys → ARRAY(K) ✓
+Output:      ARRAY(K)
+```
+
+### `cardinality(col)` — `col: MAP(K, V)` or `ARRAY(T)`
+
+```
+Chain: [Size]
+Validation:  MAP(K,V) → Size → BIGINT ✓
+Output:      BIGINT
+```
+
+### `col.x` — `col: ROW(x: INT, y: INT)`
+
+Struct field access with no other extraction steps.  Prefer subfield pruning
+(`requiredSubfields: ["col.x"]`) which keeps the `ROW` type and uses existing
+infrastructure.  `StructField` is only needed when it is part of a larger
+extraction chain (see `map_keys(col.a.b)` and `cardinality(col.features)`).
+
+```
+-- Preferred: subfield pruning
+extraction:          []
+requiredSubfields:   ["col.x"]
+
+-- Also valid but unnecessary: extraction
+Chain: [StructField("x")]
+Output:      INT
+```
+
+### `cardinality(col.features)` — `col: ROW(features: ARRAY(FLOAT), label: INT)`
+
+Size extraction on a nested field.  Navigate into the struct, then extract
+size.
+
+```
+Chain: [StructField("features"), Size]
+Validation:  ROW → StructField("features") → ARRAY(FLOAT) → Size → BIGINT ✓
+Output:      BIGINT
+```
+
+### `map_keys(map_values(col))` — `col: MAP(K1, MAP(K2, V))`
+
+This represents `transform(map_values(col), x -> map_keys(x))` — for each
+value (which is `MAP(K2, V)`), extract its keys.
+
+```
+Chain: [MapValues, ArrayElements, MapKeys]
+Validation:  MAP(K1, MAP(K2,V)) → MapValues → ARRAY(MAP(K2,V))
+                                 → ArrayElements → MAP(K2,V)
+                                 → MapKeys → ARRAY(K2)  ✓
+Output:      derive(MAP(K1, MAP(K2,V)), [MV, AE, MK])
+             = ARRAY(derive(MAP(K2,V), [MK]))
+             = ARRAY(ARRAY(K2))
+```
+
+### `map_keys(array_elements(map_values(col)))` — `col: MAP(K1, ARRAY(MAP(K2, V)))`
+
+```
+Chain: [MapValues, ArrayElements, ArrayElements, MapKeys]
+Validation:  MAP(K1, ARRAY(MAP(K2,V))) → MapValues   → ARRAY(ARRAY(MAP(K2,V)))
+                                        → ArrayElements → ARRAY(MAP(K2,V))
+                                        → ArrayElements → MAP(K2,V)
+                                        → MapKeys       → ARRAY(K2)  ✓
+Output:      derive(MAP(K1, ARRAY(MAP(K2,V))), [MV, AE, AE, MK])
+             = ARRAY(derive(ARRAY(MAP(K2,V)), [AE, MK]))
+             = ARRAY(ARRAY(derive(MAP(K2,V), [MK])))
+             = ARRAY(ARRAY(ARRAY(K2)))
+```
+
+Two `ArrayElements` — the first consumes the `ARRAY` from `MapValues`, the
+second navigates the source `ARRAY` level.
+
+### `map_values(col).x` — `col: MAP(K, ROW(x: INT, y: INT))`
+
+Extraction is used, so `requiredSubfields` cannot be set.  Use `StructField`
+in the chain to extract the specific field.
+
+```
+Chain: [MapValues, ArrayElements, StructField("x")]
+Validation:  MAP(K, ROW(x,y)) → MapValues     → ARRAY(ROW(x,y))
+                               → ArrayElements → ROW(x,y)
+                               → StructField   → INT ✓
+Output:      ARRAY(INT)
+```
+
+### `map_subset(col, ARRAY['a', 'b'])` — `col: MAP(VARCHAR, BIGINT)`
+
+Map key filtering with no other extraction steps.  Prefer subfield pruning
+(`requiredSubfields: ["col[\"a\"]", "col[\"b\"]"]`) which uses existing
+infrastructure.  `MapKeyFilter` is only needed when it is part of a larger
+extraction chain (see the nested key filter example below).
+
+```
+-- Preferred: subfield pruning
+extraction:          []
+requiredSubfields:   ["col[\"a\"]", "col[\"b\"]"]
+
+-- Also valid but unnecessary: extraction
+Chain: [MapKeyFilter(["a", "b"])]
+Output:      MAP(VARCHAR, BIGINT)
+```
+
+### `element_at(col, 'foo').x` — `col: MAP(VARCHAR, ROW(x: INT, y: INT))`
+
+Single-key filter with single struct field access.  Since `MapKeyFilter` is
+the only extraction step, prefer subfield pruning:
+
+```
+-- Preferred: subfield pruning (no extraction chain)
+extraction:          []
+requiredSubfields:   ["col[\"foo\"].x"]
+
+-- Also valid: extraction chain avoids materializing the full ROW, which can
+-- be beneficial when the struct has many fields.
+Chain: [MapKeyFilter(["foo"]), MapValues, ArrayElements, StructField("x")]
+Output:      ARRAY(INT)
+```
+
+### Non-pushable: `map_keys(map_filter(col, (k, v) -> v > 10))` — `col: MAP(VARCHAR, BIGINT)`
+
+The `map_filter` predicate depends on values (`v > 10`).  If we pushed
+`MapKeys` extraction to the reader, the reader would skip values, making it
+impossible to evaluate the filter.  **Extraction cannot be pushed** through
+intermediate expressions that depend on skipped data.  The entire map must be
+read, `map_filter` applied in the engine, and then `map_keys` applied to the
+filtered result.
+
+### Nested key filter — `col: MAP(K1, MAP(VARCHAR, ROW(x: INT, y: INT)))`
+
+SQL: `transform(map_values(col), m -> element_at(m, 'foo').x)`
+
+Extract values from outer map, filter inner map to key `"foo"`, extract
+subfield `x`.  Extraction is used, so `requiredSubfields` cannot be set.
+Use `StructField` in the chain.
+
+```
+Chain: [MapValues, ArrayElements, MapKeyFilter(["foo"]), MapValues, ArrayElements, StructField("x")]
+Validation:  MAP(K1, MAP(VARCHAR, ROW(x,y))) → MapValues     → ARRAY(MAP(VARCHAR, ROW(x,y)))
+                                              → ArrayElements → MAP(VARCHAR, ROW(x,y))
+                                              → MapKeyFilter  → MAP(VARCHAR, ROW(x,y))
+                                              → MapValues     → ARRAY(ROW(x,y))
+                                              → ArrayElements → ROW(x,y)
+                                              → StructField   → INT ✓
+Output:      ARRAY(ARRAY(INT))
+```
+
+### Error: missing `ArrayElements` after `MapValues`
+
+```
+Chain: [MapValues, MapKeys]   on MAP(K1, ARRAY(MAP(K2, V)))
+Validation:  MAP(K1, ARRAY(MAP(K2,V))) → MapValues → ARRAY(ARRAY(MAP(K2,V)))
+                                        → MapKeys → ERROR: expects MAP, got ARRAY
+```
+
+### Error: missing `ArrayElements` after `MapKeys`
+
+```
+Chain: [MapKeys, StructField("x")]   on MAP(ROW(x: INT, y: INT), V)
+Validation:  MAP(ROW(x,y), V) → MapKeys → ARRAY(ROW(x,y))
+                               → StructField("x") → ERROR: expects ROW, got ARRAY
+```
+
+## Column Handle Protocol
+
+### `HiveColumnHandle` (C++)
+
+```cpp
+/// Type of extraction to apply at one nesting level.
+enum class ExtractionStep : uint8_t {
+  /// Navigate into a struct field.  Input must be ROW.
+  kStructField,
+  /// Extract map keys as ARRAY.  Input must be MAP.
+  kMapKeys,
+  /// Extract map values as ARRAY.  Input must be MAP.
+  kMapValues,
+  /// Filter map to specific keys.  Input must be MAP.  Type-preserving.
+  kMapKeyFilter,
+  /// Navigate into array elements.  Input must be ARRAY.
+  kArrayElements,
+  /// Extract size as BIGINT.  Input must be MAP or ARRAY.  Terminal.
+  kSize,
+};
+
+/// Base class for one step in the extraction chain.  Subclasses carry
+/// step-specific data (field name, filter keys).
+class ExtractionPathElement {
+ public:
+  virtual ~ExtractionPathElement() = default;
+  virtual ExtractionStep step() const = 0;
+
+  /// Factory methods.
+  static std::shared_ptr<const ExtractionPathElement> simple(ExtractionStep);
+  static std::shared_ptr<const ExtractionPathElement> structField(
+      const std::string& name);
+  static std::shared_ptr<const ExtractionPathElement> mapKeyFilter(
+      std::vector<std::string> keys);
+  static std::shared_ptr<const ExtractionPathElement> mapKeyFilter(
+      std::vector<int64_t> keys);
+};
+
+using ExtractionPathElementPtr = std::shared_ptr<const ExtractionPathElement>;
+
+/// Concrete subclasses:
+///   SimpleExtractionPathElement       — MapKeys, MapValues, ArrayElements, Size
+///   StructFieldExtractionPathElement  — kStructField; carries fieldName()
+///   MapKeyFilterExtractionPathElement — kMapKeyFilter; carries
+///                                      stringFilterKeys() / intFilterKeys()
+
+/// Named extraction chain producing one output column.
+struct NamedExtraction {
+  /// Output column name in the scan's outputType.
+  std::string outputName;
+
+  /// Extraction chain to apply.  Empty means pass-through (no extraction).
+  std::vector<ExtractionPathElementPtr> chain;
+
+  /// Output type after applying the chain.
+  TypePtr dataType;
+};
+
+class HiveColumnHandle : public connector::ColumnHandle {
+ public:
+  HiveColumnHandle(
+      const std::string& name,
+      ColumnType columnType,
+      TypePtr dataType,
+      TypePtr hiveType,
+      std::vector<common::Subfield> requiredSubfields = {},
+      std::vector<NamedExtraction> extractions = {},
+      ...);
+
+  /// Named extraction chains.  Empty means no extraction (current behavior).
+  /// When a single entry is present, the column handle's dataType is that
+  /// entry's dataType.  When multiple entries are present, the column
+  /// handle's dataType is a ROW type whose fields are the outputNames with
+  /// their corresponding dataTypes.
+  /// Mutually exclusive with requiredSubfields — if extractions is non-empty,
+  /// requiredSubfields must be empty.
+  const std::vector<NamedExtraction>& extractions() const {
+    return extractions_;
+  }
+
+ private:
+  ...
+  std::vector<NamedExtraction> extractions_;
+};
+```
+
+### `HiveColumnHandle` (Java / Presto coordinator)
+
+```java
+public class HiveColumnHandle extends BaseHiveColumnHandle {
+    ...
+    // Existing
+    private final List<Subfield> requiredSubfields;
+
+    // New: named extraction chains
+    private final List<NamedExtraction> extractions;
+
+    public record NamedExtraction(
+        String outputName,
+        List<ExtractionPathElement> chain,
+        TypeSignature dataType
+    ) {}
+
+    public sealed interface ExtractionPathElement {
+        ExtractionStep step();
+
+        // MapKeys, MapValues, ArrayElements, Size
+        record Simple(ExtractionStep step)
+            implements ExtractionPathElement {}
+
+        record StructField(String fieldName)
+            implements ExtractionPathElement {
+            public ExtractionStep step() { return ExtractionStep.STRUCT_FIELD; }
+        }
+
+        record MapKeyFilter(
+            List<String> stringFilterKeys,
+            List<Long> intFilterKeys)
+            implements ExtractionPathElement {
+            public ExtractionStep step() { return ExtractionStep.MAP_KEY_FILTER; }
+        }
+    }
+
+    public enum ExtractionStep {
+        STRUCT_FIELD,
+        MAP_KEYS,
+        MAP_VALUES,
+        MAP_KEY_FILTER,
+        ARRAY_ELEMENTS,
+        SIZE
+    }
+}
+```
+
+### Serialization
+
+The named extraction chains are serialized as a JSON array in the plan
+fragment.  Note that `requiredSubfields` and `extractions` are mutually
+exclusive — when `extractions` is non-empty, `requiredSubfields` must be
+empty:
+
+```json
+{
+  "name": "col",
+  "hiveType": "map(varchar, array(map(integer, double)))",
+  "requiredSubfields": [],
+  "extractions": [
+    {
+      "outputName": "col_keys",
+      "dataType": "array(array(array(integer)))",
+      "chain": [
+        {"step": "MAP_VALUES"},
+        {"step": "ARRAY_ELEMENTS"},
+        {"step": "ARRAY_ELEMENTS"},
+        {"step": "MAP_KEYS"}
+      ]
+    }
+  ]
+}
+```
+
+With key filter and struct field extraction:
+
+```json
+{
+  "name": "col",
+  "hiveType": "map(varchar, row(x integer, y integer))",
+  "requiredSubfields": [],
+  "extractions": [
+    {
+      "outputName": "col_x",
+      "dataType": "array(integer)",
+      "chain": [
+        {"step": "MAP_KEY_FILTER", "stringFilterKeys": ["foo", "bar"]},
+        {"step": "MAP_VALUES"},
+        {"step": "ARRAY_ELEMENTS"},
+        {"step": "STRUCT_FIELD", "fieldName": "x"}
+      ]
+    }
+  ]
+}
+```
+
+Multiple extractions from the same column:
+
+```json
+{
+  "name": "col",
+  "hiveType": "map(varchar, row(x integer, y double))",
+  "requiredSubfields": [],
+  "extractions": [
+    {
+      "outputName": "col_size",
+      "dataType": "bigint",
+      "chain": [{"step": "SIZE"}]
+    },
+    {
+      "outputName": "col_keys",
+      "dataType": "array(varchar)",
+      "chain": [{"step": "MAP_KEYS"}]
+    },
+    {
+      "outputName": "col_x",
+      "dataType": "array(integer)",
+      "chain": [
+        {"step": "MAP_VALUES"},
+        {"step": "ARRAY_ELEMENTS"},
+        {"step": "STRUCT_FIELD", "fieldName": "x"}
+      ]
+    }
+  ]
+}
+```
+
+### Contract
+
+- `extractions` is empty → current behavior, `requiredSubfields` may be used
+  for type-preserving pruning.
+- `extractions` is non-empty → worker applies each chain, producing the
+  corresponding `dataType`.  `requiredSubfields` must be empty.
+- `extractions` and `requiredSubfields` are **mutually exclusive** on the same
+  column handle.
+- `requiredSubfields` operates on the file type (existing behavior).
+- When multiple extractions are needed from the same column, use the
+  `NamedExtraction` list on a single column handle (see "Multiple extractions
+  per column" below).  Do NOT create multiple column handles for the same
+  source column.
+- The worker validates `hiveType` + each extraction chain → its `dataType`
+  and rejects mismatches.
+
+### Multiple extractions per column
+
+When a query references the same column with different extractions (e.g.,
+`SELECT map_keys(col) AS keys, cardinality(col) AS size FROM t`), a single
+column handle carries all extraction chains via `NamedExtraction`.  The column
+handle's `dataType` is a **ROW** whose fields are the output names with their
+corresponding types:
+
+```
+assignments: {
+    "col": HiveColumnHandle {
+        name: "col",
+        hiveType: MAP(K, V),
+        dataType: ROW({ "keys": ARRAY(K), "size": BIGINT }),
+        extractions: [
+            { outputName: "keys", chain: [MapKeys],  dataType: ARRAY(K) },
+            { outputName: "size", chain: [Size],     dataType: BIGINT   }
+        ]
+    }
+}
+```
+
+The column is read once from the file.  Each extraction chain is applied
+independently to produce a field in the output ROW.
+
+**Examples with multiple extractions:**
+
+```
+-- col: MAP(VARCHAR, ROW(x: INT, y: INT, z: INT))
+-- Query: SELECT map_keys(col) AS keys, map_values(col).x AS vals_x FROM t
+--
+-- Two extractions: keys and a specific value subfield.
+-- Use StructField in the values chain to extract only field x.
+
+HiveColumnHandle {
+    name: "col",
+    hiveType: MAP(VARCHAR, ROW(x: INT, y: INT, z: INT)),
+    dataType: ROW({ "keys": ARRAY(VARCHAR), "vals_x": ARRAY(INT) }),
+    extractions: [
+        { outputName: "keys",   chain: [MapKeys],                              dataType: ARRAY(VARCHAR) },
+        { outputName: "vals_x", chain: [MapValues, ArrayElements, StructField("x")],  dataType: ARRAY(INT) }
+    ]
+}
+```
+
+```
+-- col: MAP(BIGINT, ROW(a: VARCHAR, b: DOUBLE, c: INT))
+-- Query: SELECT cardinality(col) AS sz, map_values(col).a AS vals_a,
+--        map_values(col).b AS vals_b FROM t
+--
+-- Three outputs: size and two value subfields.
+-- Each subfield gets its own NamedExtraction with a StructField chain.
+
+HiveColumnHandle {
+    name: "col",
+    hiveType: MAP(BIGINT, ROW(a: VARCHAR, b: DOUBLE, c: INT)),
+    dataType: ROW({ "sz": BIGINT, "vals_a": ARRAY(VARCHAR), "vals_b": ARRAY(DOUBLE) }),
+    extractions: [
+        { outputName: "sz",     chain: [Size],                                     dataType: BIGINT },
+        { outputName: "vals_a", chain: [MapValues, ArrayElements, StructField("a")],  dataType: ARRAY(VARCHAR) },
+        { outputName: "vals_b", chain: [MapValues, ArrayElements, StructField("b")],  dataType: ARRAY(DOUBLE) }
+    ]
+}
+```
+
+## Future Extensions
+
+### `ArraySlice` — sequence truncating for ML
+
+ML models often consume variable-length sequences (user activity histories,
+embedding arrays, feature maps) but have a maximum sequence length.  Reading
+10K-element arrays when the model only uses the last 128 is wasteful.
+
+`ArraySlice(offset, length)` would be a **type-preserving** step that truncates
+arrays at the reader level.  A negative `length` selects from the end of the
+array: `ArraySlice(0, -128)` means "take the last 128 elements."
+
+| Step                   | Required input | Output      |
+|------------------------|----------------|-------------|
+| `ArraySlice(off, len)` | `ARRAY(T)`     | `ARRAY(T)`  |
+
+Since the output type is the same as the input, `ArraySlice` does NOT require
+`ArrayElements` after it (unlike `MapKeys`/`MapValues` which change the type).
+
+Derivation rule:
+
+```
+derive(ARRAY(T), [ArraySlice, ...rest]) = derive(ARRAY(T), rest)
+```
+
+Composed examples:
+
+```
+-- Feature map with array values, filter to specific keys, truncate each to 128
+col: MAP(VARCHAR, ARRAY(FLOAT))
+Chain: [MapKeyFilter(["feat1", "feat2"]), MapValues, ArrayElements, ArraySlice(0, 128)]
+Output: ARRAY(ARRAY(FLOAT))
+```
+
+```
+-- User history, take first 128 events, extract only item_id
+col: ARRAY(ROW(item_id BIGINT, timestamp BIGINT))
+Chain: [ArraySlice(0, 128), ArrayElements, StructField("item_id")]
+Output: ARRAY(BIGINT)
+```
+
+```
+-- User history, take LAST 128 events (most recent)
+col: ARRAY(ROW(item_id BIGINT, timestamp BIGINT))
+Chain: [ArraySlice(0, -128)]
+Output: ARRAY(ROW(item_id BIGINT, timestamp BIGINT))
+```
+
+```
+-- Feature map with array values, filter to specific keys, take last 64 from each
+col: MAP(VARCHAR, ARRAY(FLOAT))
+Chain: [MapKeyFilter(["feat1", "feat2"]), MapValues, ArrayElements, ArraySlice(0, -64)]
+Output: ARRAY(ARRAY(FLOAT))
+```
+
+This is a natural extension — it fits into the chain as a type-preserving step,
+composable with extraction steps before and after it.  Velox already has
+`ScanSpec::maxArrayElementsCount_` for the prefix case; `ArraySlice` generalizes
+it to work within extraction chains.
diff --git a/velox/docs/develop.rst b/velox/docs/develop.rst
index 48c4641e71c..c4df460f191 100644
--- a/velox/docs/develop.rst
+++ b/velox/docs/develop.rst
@@ -21,8 +21,10 @@ This guide is intended for Velox contributors and developers of Velox-based appl
     develop/connectors
     develop/joins
     develop/anti-join
+    develop/hash-table-caching
     develop/operators
     develop/task
+    develop/task-barrier
     develop/simd
     develop/memory
     develop/spilling
diff --git a/velox/docs/develop/TpchBenchmark.rst b/velox/docs/develop/TpchBenchmark.rst
index 23ba28b5d02..fd0a517f682 100644
--- a/velox/docs/develop/TpchBenchmark.rst
+++ b/velox/docs/develop/TpchBenchmark.rst
@@ -11,7 +11,7 @@ query engine.
 
 Benchmarking in Velox is made easy with the optionally built TpchBenchmark
 (velox_tpch_benchmark) executable. To build the benchmark executable
-(*_build/release/velox/benchamrks/tpch/velox_tpch_benchmark*), use the
+(*_build/release/velox/benchmarks/tpch/velox_tpch_benchmark*), use the
 following command line to do the build with S3 support:
 
 .. code:: shell
@@ -45,9 +45,9 @@ responsible for both **driver** threads and I/O threads.
 Multiple Process Executor Use Case
 ----------------------------------
 
-This use case is used by Spark + `Gluten <https://github.com/oap-project/gluten>`_
+This use case is used by Spark + `Gluten <https://github.com/apache/gluten>`_
 and it differs from the Presto use case where parallelism is concerned. Spark
-uses multiple processes where each process is a Gluten+Velox query processor.
+uses multiple processes where each process is a Gluten + Velox query processor.
 Spark scales by using many Linux processes for query processing. In this case
 this means that the **drivers** are outside of Velox and Gluten and is defined
 by the Spark configuration and number of workers. Gluten takes on the role of
@@ -89,7 +89,7 @@ use a single dash not a double dash; i.e. -option and not --option):
 
 **NOTE:** *There is a limitation on the implementation of the AWS SDK that
 will cause failures (curl error 28) if the **driver** *threads times I/O threads
-grow much beyond 350 threads. This only really effects the multi-threaded
+grow much beyond 350 threads. This only really affects the multi-threaded
 **drivers** *use case like the benchmark tool. It is only known to be an issue
 when running against AWS S3. However, the error is coming from the libcurl
 library so it is possible other Cloud storage APIs could also be affected.*
@@ -99,7 +99,7 @@ Velox exposes other options used for tuning that are of interest:
 * *max_coalesce_bytes* - Size of coalesced data, has small improvements as size
   grows.
 
-* *max_coalesce_distance_bytes* - Maximum gap bytes between data that can
+* *max_coalesce_distance_bytes* - Maximum gap bytes between data that can be
   coalesced. Larger may mean more fetched data but at greater bytes/sec.
 
 Top Optimization Recommendations
@@ -149,14 +149,14 @@ chunks as opposed to many smaller requests.
 
 This configuration option is useful for workloads that read the same data
 several times per query but only applies to the single process use case.
-*NOTE: There is a SSD Caching option in Velox but it to is ONLY useful in
+*NOTE: There is a SSD Caching option in Velox but it too is ONLY useful in
 the single process use case.*
 
 **num_splits_per_file**
 -----------------------
 
 This configuration option is best when the data set count of row groups
-matches this value. The affect in overall performance appears based on
+matches this value. The effect on overall performance appears based on
 testing to be small, however.
 
 Optimizations for All Workloads (Both Use Cases)
@@ -183,8 +183,8 @@ fine-tuned for the workload being run.
 Summary
 =======
 
-If a use of Velox matches the use case of the TcphBenchmark then it is a good
-tool to test, I/O and driver performance for specific TCP-H queries. This would
+If a use of Velox matches the use case of the TpchBenchmark then it is a good
+tool to test, I/O and driver performance for specific TPC-H queries. This would
 benefit execution of specific production workloads that are like the chosen
 queries. If in multi-process use case, like Spark/Gluten/Velox configuration,
 the recommendation is to oversubscribe I/O threads between 2X and 3X vCPUs and
diff --git a/velox/docs/develop/aggregate-functions.rst b/velox/docs/develop/aggregate-functions.rst
index e989f624976..b0146f2f4b3 100644
--- a/velox/docs/develop/aggregate-functions.rst
+++ b/velox/docs/develop/aggregate-functions.rst
@@ -137,8 +137,9 @@ Simple Function Interface
 
 This section describes the main concepts and the simple interface of
 aggregation functions. Examples of aggregation functions implemented through
-the simple-function interface can be found at velox/exec/tests/SimpleAverageAggregate.cpp
-and velox/exec/tests/SimpleArrayAggAggregate.cpp.
+the simple-function interface can be found at SimpleAverageAggregate.cpp,
+SimpleArrayAggAggregate.cpp, SimpleVariadicSumAggregate.cpp, and
+SimpleVariadicArrayAggAggregate.cpp under velox/exec/tests.
 
 A simple aggregation function is implemented as a class as the following.
 
@@ -451,16 +452,12 @@ null should be written to the final result vector.
 Limitations
 ^^^^^^^^^^^
 
-The simple aggregation function interface currently has three limitations.
+The simple aggregation function interface currently has two limitations.
 
-1. All values read or written by the aggrgeaiton function must be part of the
-   accumulators. This means that there cannot be function-level states kept
-   outside of accumulators.
-
-2. Optimizations on constant inputs is not supported. I.e., constant input
+1. Optimizations on constant inputs is not supported. I.e., constant input
    arguments are processed once per row in the same way as non-constant inputs.
 
-3. Aggregation pushdown to table scan is not supported yet. We're planning to
+2. Aggregation pushdown to table scan is not supported yet. We're planning to
    add this support.
 
 Vector Function Interface
diff --git a/velox/docs/develop/aggregations.rst b/velox/docs/develop/aggregations.rst
index 934252f7c14..46c04818914 100644
--- a/velox/docs/develop/aggregations.rst
+++ b/velox/docs/develop/aggregations.rst
@@ -112,6 +112,27 @@ encounters a row with a different values in pre-grouped keys. This helps reduce
 the total amount of memory used and allows to unblock downstream operators
 faster.
 
+noGroupsSpanBatches Optimization
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+AggregationNode supports an optional ``noGroupsSpanBatches`` flag that can be set
+to true for streaming aggregations. When enabled, this flag indicates that no
+sort group spans across input batches - each input batch contains complete data
+for its groups, and no group will appear in any subsequent input batch.
+
+This optimization allows the StreamingAggregation operator to immediately produce
+aggregation results for all groups in each input batch without waiting to see if
+more data for those groups will arrive in subsequent batches. This can
+significantly improve output latency and reduce memory usage since the operator
+doesn't need to hold onto partial aggregation state across batches.
+
+The ``noGroupsSpanBatches`` flag can only be set when the aggregation is
+pre-grouped (streaming). Setting it on a non-streaming aggregation will result
+in an error.
+
+This optimization is typically set automatically by query optimizers when they can
+guarantee that the input data meets the required properties.
+
 Push-Down into Table Scan
 -------------------------
 
@@ -343,5 +364,6 @@ accumulators.
 Many aggregate functions implement toIntermediate() fast path. Some examples include:
 :func:`min`, :func:`max`, :func:`array_agg`, :func:`set_agg`, :func:`map_agg`, :func:`map_union`.
 
-One can use runtime statistic `abandonedPartialAggregation` to tell whether
-partial aggregation was abandoned.
+Runtime statistic `abandonedPartialAggregationRows` counts rows that bypassed
+partial aggregation after it was abandoned. A value greater than 0 indicates
+that partial aggregation was abandoned.
diff --git a/velox/docs/develop/connectors.rst b/velox/docs/develop/connectors.rst
index 9e550e007e7..b4c4275cdb8 100644
--- a/velox/docs/develop/connectors.rst
+++ b/velox/docs/develop/connectors.rst
@@ -89,7 +89,7 @@ S3 is supported using the `AWS SDK for C++ <https://github.com/aws/aws-sdk-cpp>`
 S3 supported schemes are `s3://` (Amazon S3, Minio), `s3a://` (Hadoop 3.x), `s3n://` (Deprecated in Hadoop 3.x),
 `oss://` (Alibaba cloud storage), and `cos://`, `cosn://` (Tencent cloud storage).
 
-HDFS is supported using the
+HDFS is supported using the `Apache Hadoop libhdfs.so <https://github.com/apache/hadoop>`_ and
 `Apache Hawk libhdfs3 <https://github.com/apache/hawq/tree/master/depends/libhdfs3>`_ library. HDFS supported schemes
 are `hdfs://`.
 
@@ -121,3 +121,8 @@ This is the behavior when the proxy settings are enabled:
 4. The no_proxy/NO_PROXY list is comma separated.
 5. Use . or \*. to indicate domain suffix matching, e.g. `.foobar.com` will
    match `test.foobar.com` or `foo.foobar.com`.
+
+HDFS Storage adapter
+********************
+
+Velox currently supports HDFS by dynamically loading libhdfs.so from the environment's ${HADOOP_HOME}/native/lib directory. If you prefer to use libhdfs3 instead, you can create a symbolic link from libhdfs.so to libhdfs3.so within the same directory.
diff --git a/velox/docs/develop/debugging/print-plan-with-stats.rst b/velox/docs/develop/debugging/print-plan-with-stats.rst
index 3bb482763c6..f215705d2e4 100644
--- a/velox/docs/develop/debugging/print-plan-with-stats.rst
+++ b/velox/docs/develop/debugging/print-plan-with-stats.rst
@@ -283,3 +283,22 @@ TableScan operator shows how many rows were processed by pushing down aggregatio
 .. code-block::
 
     loadedToValueHook          sum: 50000, count: 5, min: 10000, max: 10000
+
+GPU Operator Stats
+~~~~~~~~~~~~~~~~~~
+
+When cuDF GPU operators are enabled, the stats output includes GPU-specific
+operators. Adapter operators (``CudfToVelox``, ``CudfFromVelox``) appear as
+operator-type breakdown lines under their parent plan node:
+
+.. code-block::
+
+    -- Aggregation[4][FINAL] -> a0:DOUBLE
+       Output: 2 rows, Cpu time: 546us, Wall time: 601us
+       CudfToVelox: Input: 1 rows, Cpu time: 193us, Wall time: 224us
+       CudfReduceFINAL: Input: 1 rows, Cpu time: 352us, Wall time: 377us
+
+Here, ``Aggregation[4]`` has two operators: ``CudfReduceFINAL`` (the GPU
+aggregation) and ``CudfToVelox`` (GPU-to-CPU format conversion). The summary
+line shows their combined stats. This is the same multi-operator mechanism
+used by ``HashBuild``/``HashProbe`` under join nodes.
diff --git a/velox/docs/develop/expression-evaluation.rst b/velox/docs/develop/expression-evaluation.rst
index ec9ef94a76b..7b2293aea62 100644
--- a/velox/docs/develop/expression-evaluation.rst
+++ b/velox/docs/develop/expression-evaluation.rst
@@ -371,13 +371,13 @@ depth-first order. For each node a sequence of operations is performed.
 Flat No-Nulls Fast Path
 ```````````````````````
 
-When evaluating simple expressions on short vectors (< 1000 rows), the overhead
-of handling nulls and encodings is visible. To optimize these use cases,
-expression evaluation takes flat-no-nulls fast path
-(Expr::evalFlatNoNulls). This path applies automatically when inputs are flat
-vectors or constants with no nulls and all sub-expressions are guaranteed to
-produce flat-or-constant-no-nulls results given flat-or-constant-no-nulls
-inputs.
+When evaluating simple expressions, the overhead of handling nulls and encodings
+is visible. To optimize these use cases, expression evaluation takes
+flat-no-nulls fast path (Expr::evalFlatNoNulls). This path applies automatically
+when inputs are flat vectors or constants with no nulls and all sub-expressions
+are guaranteed to produce flat-or-constant-no-nulls results given
+flat-or-constant-no-nulls inputs. The optimization can be disabled by setting the
+``expression.eval_flat_no_nulls`` configuration property to false.
 
 An example of a workload that benefits from this optimization is basic arithmetic
 over non-null floats found in many machine learning pre-processing workloads.
@@ -457,3 +457,23 @@ SWITCH expression evaluation goes through the following steps:
 SWITCH expression sets EvalCtx::isFinalSelection flag to false. The expressions
 are expected to use this flag to decide whether the partially populated result
 vector must be preserved or can be overwritten.
+
+Expression Hashing
+``````````````````
+
+Each expression node provides a ``hash()`` method that computes a stable hash
+value for the expression tree. This hash can be used for deduplication
+and expression comparison.
+
+**Stability Guarantee**: Expression hashes are stable across different
+processes, builds, and machines. This is achieved by using a stable hasher
+like ``folly::hasher``.
+
+The hash is computed recursively:
+
+* ``localHash()`` computes a hash for the expression node itself (type name,
+  function name, field name, etc.)
+* ``hash()`` combines ``localHash()`` with the type's hash and the hashes of
+  all input expressions
+
+This enables use cases like expression-based sampling and deduplication.
diff --git a/velox/docs/develop/hash-table-caching.rst b/velox/docs/develop/hash-table-caching.rst
new file mode 100644
index 00000000000..056189854d7
--- /dev/null
+++ b/velox/docs/develop/hash-table-caching.rst
@@ -0,0 +1,510 @@
+========================
+Broadcast Build Caching
+========================
+
+Background
+----------
+
+In materialized execution engines like Spark and Presto on Spark, for broadcast joins,
+the build side splits are replicated to all join tasks due to upfront split planning.
+This kind of upfront split planning allows these engines to provide task level fault tolerance
+as the input splits of the tasks are tracked and output data can be discarded,
+thus enabling task level retries.
+
+But due to this, each task independently builds an identical hash table from the
+same data. For large build sides this is wasteful: every task spends CPU and memory
+constructing the same hash table that another task in the same query has already built.
+
+The Build IO Tax
+^^^^^^^^^^^^^^^^
+
+Also, the broadcast data follows a write-once-read-many I/O pattern. Each task re-reads
+the build side data independently. When the number of tasks is large ---
+O(100k) tasks across 10k+ workers --- these concurrent reads overwhelm the I/O
+service layer, leading to throttling.
+
+Throttling causes tasks to stall for seconds to minutes waiting for I/O. When
+queries are charged for reserved workers, these stalls mean reserved resources
+sit idle, increasing query cost. Beyond I/O fetch delays, when the hash table is
+large (in the gigabyte range), the CPU cost of rebuilding it per task is also
+significant and wasteful.
+
+Hash table caching eliminates this redundant work by allowing the first task to
+build the hash table and making it available to all subsequent tasks in the same
+Velox instance. This is a build-once, reuse-many paradigm. In Sapphire-Velox,
+this implements a once-per-worker model that yields more than an order of
+magnitude savings, since the number of tasks far exceeds the number of workers.
+
+Enabling Hash Table Caching
+----------------------------
+
+Hash table caching is enabled by setting the ``useHashTableCache`` flag to
+``true`` on the ``HashJoinNode``:
+
+.. code-block:: c++
+
+    auto joinNode =
+        core::HashJoinNode::Builder()
+            .id(planNodeIdGenerator->next())
+            .joinType(core::JoinType::kInner)
+            .nullAware(false)
+            .leftKeys({leftKeyField})
+            .rightKeys({rightKeyField})
+            .left(probeNode)
+            .right(buildNode)
+            .outputType(outputType)
+            .useHashTableCache(true)
+            .build();
+
+When ``useHashTableCache`` is false (the default), the hash join behaves
+exactly as before. The flag is only intended for broadcast joins and is
+currently used by Presto-on-Spark.
+
+Overall Design
+--------------
+
+Hash table caching introduces a global singleton ``HashTableCache`` that stores
+built hash tables keyed by ``queryId:planNodeId``. The cache coordinates
+between tasks so that exactly one task builds the hash table while other tasks
+wait and then reuse the result.
+
+The ``HashTableCache`` is a process-wide singleton in the Velox instance,
+alongside the ``AsyncDataCache`` and ``MemoryManager``. The cache and its
+methods provide building blocks for drivers within a task and tasks within a
+worker to coordinate hash table construction and reuse.
+
+The design has three main components:
+
+1. **HashTableCache** - A process-wide singleton that stores and manages cached
+   hash table entries.
+2. **HashTableCacheEntry** - A cache entry that holds the hash table, build
+   coordination state, and a dedicated memory pool.
+3. **HashBuild operator integration** - Logic in the HashBuild operator to
+   check the cache, build or wait, and store the result.
+
+Cache Structure
+---------------
+
+``HashTableCache`` is a thread-safe singleton that maps cache keys to cache
+entries:
+
+.. code-block:: c++
+
+    class HashTableCache {
+        std::mutex lock_;
+        std::unordered_map<std::string,
+                           std::shared_ptr<HashTableCacheEntry>> tables_;
+    };
+
+Each ``HashTableCacheEntry`` contains:
+
+.. list-table::
+   :widths: 25 75
+   :header-rows: 1
+
+   * - Field
+     - Description
+   * - ``cacheKey``
+     - The key used to look up this entry (``queryId:planNodeId``).
+   * - ``builderTaskId``
+     - The task ID of the task that is responsible for building the table.
+   * - ``tablePool``
+     - A leaf memory pool under the query pool used for table allocations.
+   * - ``table``
+     - The built ``BaseHashTable``, set once build is complete.
+   * - ``hasNullKeys``
+     - Whether the build side contained null join keys.
+   * - ``buildComplete``
+     - Atomic flag indicating whether the table has been fully built.
+   * - ``buildPromises``
+     - Promises used to notify waiting tasks when build completes.
+
+Cache API
+---------
+
+The ``HashTableCache`` exposes three methods. All decisions are made under a
+single ``std::mutex``. The lock is held only for map lookups, inserts, and
+promise creation --- never during table building or memory allocation.
+
+get()
+^^^^^
+
+The ``get()`` method is the central coordination point. It is called by every
+``HashBuild`` operator during ``initialize()`` and determines the caller's
+role under the mutex:
+
+.. code-block:: text
+
+    get(key, taskId, queryCtx, *future):
+        lock(lock_)
+        Case 1 – No entry:    create entry, set builderTaskId → return entry (Builder)
+        Case 2 – Same task:   return entry (Builder, coordinate via JoinBridge)
+        Case 3 – Diff task, not complete: push promise → return entry + future (Waiter)
+        Case 4 – Complete:    return entry (Late Arrival)
+
+When creating a new entry, ``get()`` allocates a ``tablePool`` as a leaf child
+of the query pool and registers a ``QueryCtx`` release callback that calls
+``drop()`` on query destruction.
+
+Key design decisions in ``get()``:
+
+- **Memory pool ownership**: The ``tablePool`` is a leaf child of the first
+  caller's ``QueryCtx`` root pool. All drivers in the builder task share this
+  pool for partial table allocations (via ``HashBuild::tableMemoryPool()``),
+  tying the cached table's memory accounting to the originating query.
+- **Cleanup callback**: ``QueryCtx::addReleaseCallback`` ensures the cache entry
+  is dropped when the query finishes. ``drop()`` resets the
+  ``shared_ptr<BaseHashTable>`` outside the lock to free memory before the entry
+  is destroyed.
+- **Lock scope**: All decisions are made under a single ``std::mutex``. The lock
+  is held only for map lookups/inserts and promise creation --- never during
+  table building or memory allocation.
+
+put()
+^^^^^
+
+Called by the last driver of the builder task after merging all partial tables.
+Publishes the table and wakes all waiters:
+
+.. code-block:: text
+
+    put(key, table, hasNullKeys):
+        lock(lock_)
+        entry.table = table
+        entry.buildComplete = true
+        promises = move(entry.buildPromises)
+        unlock(lock_)
+        for each promise: promise.setValue()   // wake waiters outside lock
+
+drop()
+^^^^^^
+
+Removes a cache entry and frees the table memory. Called by the ``QueryCtx``
+cleanup callback when the query is destroyed:
+
+.. code-block:: text
+
+    drop(key):
+        lock(lock_)
+        entry = move(tables_[key])
+        tables_.erase(key)
+        unlock(lock_)
+        entry.table.reset()   // free memory outside lock
+
+Build Coordination
+------------------
+
+When hash table caching is enabled, the HashBuild operator calls
+``HashTableCache::get()`` during initialization. The cache uses the first
+caller's task as the builder and makes subsequent callers wait.
+
+Builder Task
+^^^^^^^^^^^^
+
+The first task to call ``get()`` for a given key creates the cache entry and
+becomes the builder. This task proceeds through the normal HashBuild flow:
+all its drivers build partial hash tables, the last driver merges them, and
+the merged table is stored in the cache via ``HashTableCache::put()``.
+
+Drivers within the builder task coordinate with each other through the
+existing ``HashJoinBridge`` mechanism. The cache does not interfere with
+intra-task driver synchronization.
+
+Waiter Tasks
+^^^^^^^^^^^^
+
+When a task calls ``get()`` and finds that another task is already building the
+table (``builderTaskId`` differs from its own task ID and ``buildComplete`` is
+false), it receives a ``ContinueFuture`` and transitions to the
+``kWaitForBuild`` state. The task is suspended until the builder task calls
+``put()``, which fulfills all waiting promises.
+
+Once notified, the waiter task calls ``noMoreInput()`` which finds the table
+in the cache and passes it directly to the ``HashJoinBridge`` without building
+anything. The probe side then runs normally against the cached table.
+
+.. code-block:: text
+
+    Task 1 (Builder)              Task 2 (Waiter)              Task 3 (Waiter)
+    ────────────────              ───────────────              ───────────────
+    get() → creates entry         get() → sees builder         get() → sees builder
+    builds hash table             receives future              receives future
+    put() → sets table            (suspended)                  (suspended)
+    notifies waiters ──────────→  wakes up                     wakes up
+                                  uses cached table            uses cached table
+
+Cache Hit
+^^^^^^^^^
+
+If a task calls ``get()`` and finds ``buildComplete`` is already true, the
+cached table is returned immediately. The HashBuild operator skips all build
+logic and passes the table to the ``HashJoinBridge``.
+
+The HashBuild operator reports cache hits and misses via runtime statistics:
+
+- ``hashtable.cacheHit`` - Table was found in the cache and reused.
+- ``hashtable.cacheMiss`` - Table was not in the cache; this task built it.
+
+Usage by HashBuild
+------------------
+
+The HashBuild operator uses the cache in a three-phase protocol: build, synchronize,
+and probe.
+
+Step 1: Build Phase (Producer)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+When a ``HashBuild`` operator is initialized, it checks the cache via
+``setupCachedHashTable()``.
+
+- **Cache Miss (Builder)**: The first task to find a miss becomes the Builder.
+  It creates a cache entry, pulls data from storage, builds the
+  ``BaseHashTable``, and calls ``put()`` to publish it. Within the Builder task,
+  subsequent drivers also call ``get()`` and receive the same entry (since
+  ``builderTaskId == taskId``). Each driver calls ``setupTable()`` to allocate
+  its own partial ``BaseHashTable`` using ``cacheEntry->tablePool``, receives its
+  subset of input via ``addInput()``, and builds a partial table. Intra-task
+  coordination between these drivers uses the standard ``allPeersFinished()`` /
+  ``JoinBridge`` mechanism, not the cache.
+
+- **The Wait (Waiters)**: If other tasks arrive while the Builder is building,
+  they encounter the pending state and transition to ``kWaitForBuild``, waiting
+  on a ``ContinueFuture`` provided by the cache.
+
+- **Short-circuiting Upstream**: Once the Builder publishes the table, waiters
+  are unblocked. Upon receiving the cached table, waiter tasks set their
+  no-more-input flags. This short-circuits their source operators (e.g.,
+  ``TableScan``), immediately stopping further data retrieval.
+
+Step 2: Synchronization (JoinBridge)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The ``HashJoinBridge`` acts as the hand-off point between the build and probe
+sides. Even if the table was retrieved from the cache rather than built locally,
+the bridge ensures the probe side is notified that the data is ready for
+processing. Both builder and waiter tasks call
+``joinBridge.setHashTable()`` to publish the table (or cached table) to the
+probe operators.
+
+Step 3: Probe Phase (Consumer)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The ``HashProbe`` operator takes the cached table from the bridge and executes
+as usual. Because the table is held as a ``shared_ptr``, the probe operator's
+reference prevents the cache from freeing the table while a join is actively
+scanning it. Once the probe finishes, the reference count is decremented. The
+table is ultimately freed when the ``QueryCtx`` release callback calls
+``drop()``.
+
+HashBuild Lifecycle
+-------------------
+
+The following pseudocode shows the complete lifecycle of a ``HashBuild``
+operator when hash table caching is enabled. Only the key function calls are
+shown.
+
+Initialization
+^^^^^^^^^^^^^^
+
+.. code-block:: text
+
+    initialize():
+        cacheKey = "queryId:planNodeId"
+        cacheEntry = HashTableCache::instance()->get(cacheKey, taskId, queryCtx, &future_)
+
+        if cacheEntry.buildComplete:        // Late Arrival
+            noMoreInput()                   // → finishHashBuild() → getHashTableFromCache()
+            return
+
+        if future_.valid():                 // Waiter
+            state = kWaitForBuild
+            return
+
+        // Builder: proceed with normal table setup
+        setupTable()                        // allocate BaseHashTable using cacheEntry.tablePool
+        setupSpiller()                      // no-op: canSpill() returns false with cache
+
+Build and Publish
+^^^^^^^^^^^^^^^^^
+
+.. code-block:: text
+
+    noMoreInput() → finishHashBuild():
+        if not allPeersFinished():          // wait for peer drivers in same task
+            state = kWaitForBuild
+            return
+
+        if getHashTableFromCache():         // Waiter or Late Arrival: cache has table
+            joinBridge.setHashTable(cacheEntry.table, hasNullKeys)
+            return
+
+        // Builder (last driver): merge and publish
+        table_.prepareJoinTable(otherTables)
+        HashTableCache::instance()->put(cacheKey, table_, hasNullKeys)
+        joinBridge.setHashTable(table_, hasNullKeys)
+
+Waiter Wake-up
+^^^^^^^^^^^^^^
+
+.. code-block:: text
+
+    isBlocked():
+        case kWaitForBuild:
+            if receivedCachedHashTable():   // future_ fulfilled, buildComplete == true
+                setRunning()
+                noMoreInput()               // → finishHashBuild() → getHashTableFromCache()
+
+Skipping Source Reads
+---------------------
+
+Waiter tasks never read any data from storage. No splits are fetched, no
+exchanges are initiated.
+
+In Velox, a build-side pipeline is a chain of operators ending with
+``HashBuild`` as the sink:
+
+.. code-block:: text
+
+    [TableScan / Exchange] → ... → [HashBuild]
+         operators_[0]               operators_[last]
+
+The ``Driver::runInternal()`` loop iterates through operator pairs ``(op,
+nextOp)`` and, for each pair, follows this sequence:
+
+1. Check ``op->isBlocked()`` --- if blocked, suspend the Driver.
+2. Check ``nextOp->isBlocked()`` --- if blocked, suspend the Driver.
+3. Check ``nextOp->needsInput()`` --- if false, skip pulling from ``op``.
+4. Call ``op->getOutput()`` and feed the result to ``nextOp->addInput()``.
+
+The critical point is that ``nextOp->isBlocked()`` is checked **before**
+``op->getOutput()`` is ever called. When the ``HashBuild`` operator is in the
+``kWaitForBuild`` state, it returns a blocked status, which prevents the
+driver from pulling data from any upstream operator (e.g., ``TableScan`` or
+``Exchange``). Once the cached table arrives and the waiter calls
+``noMoreInput()``, source operators are short-circuited immediately ---
+they never execute at all.
+
+This is a key benefit of the caching design: waiter tasks incur zero I/O cost.
+
+Memory Management
+-----------------
+
+Cached hash tables must outlive the task that built them because waiter tasks
+from the same query need to access the table after the builder task has
+finished. To support this, cached hash tables use a dedicated leaf memory pool
+created under the **query** memory pool rather than the operator's task-level
+pool.
+
+Pool Hierarchy
+^^^^^^^^^^^^^^
+
+.. code-block:: text
+
+    Query Pool
+    ├── Task 1 Pool (builder - may finish first)
+    │   └── Operator Pool
+    └── cached_table_<key> Pool  ← hash table lives here
+        (created by HashTableCache)
+
+The ``tablePool`` is created by the first call to ``get()`` as a leaf child of
+the caller's ``QueryCtx`` root pool. All drivers in the builder task share this
+pool for their partial table allocations via ``HashBuild::tableMemoryPool()``.
+This ties the cached table's memory accounting to the originating query rather
+than to any individual task, allowing the table to survive task completion.
+
+Cleanup Callback
+^^^^^^^^^^^^^^^^
+
+When a cache entry is created, ``HashTableCache::get()`` registers a release
+callback on the ``QueryCtx``. When the query context is destroyed, this
+callback calls ``HashTableCache::drop()`` to remove the entry and free the
+table's memory before the query pool is torn down. ``drop()`` resets the
+``shared_ptr<BaseHashTable>`` outside the lock to free memory before the entry
+itself is destroyed. This ensures there are no dangling references to
+destroyed memory pools.
+
+``HashBuild::tableMemoryPool()`` returns the cache entry's ``tablePool`` when
+caching is enabled, or the operator's own ``pool()`` for regular joins.
+
+Ownership and Shared Pointers
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Without caching, the hash table is transferred to the ``HashJoinBridge`` as a
+``unique_ptr``. With caching enabled, the table is stored as a ``shared_ptr``
+in the cache entry and a copy of the ``shared_ptr`` is passed to the bridge.
+This allows the cache to retain ownership while the bridge and probe operator
+also hold references. The ``HashJoinBridge::setHashTable()`` signature was
+changed to accept ``shared_ptr`` to support this.
+
+Reference counting ensures that the table is not freed while any probe operator
+is actively scanning it. Once the probe finishes, the reference count is
+decremented. The table is ultimately freed when the ``QueryCtx`` release
+callback calls ``drop()``.
+
+Spilling
+--------
+
+Spilling is not supported when hash table caching is enabled. Both
+``HashBuild::canSpill()`` and ``HashBuild::canReclaim()`` return false when
+``useHashTableCache`` is true:
+
+.. code-block:: c++
+
+    bool HashBuild::canSpill() const {
+        // ...
+        if (useHashTableCache()) {
+            return false;
+        }
+        // ...
+    }
+
+This is because spilling clears the hash table from memory and rebuilds it
+later, which would corrupt the cached table that other tasks may be using.
+Specifically:
+
+- **Builder task**: Cannot spill because the table is shared via the cache.
+  Spilling would invalidate the ``shared_ptr`` held by waiter tasks.
+- **Waiter tasks**: Cannot spill because they use the cached table directly
+  and never build their own.
+- **Coordination complexity**: Rebuild-after-spill would require re-coordinating
+  across all tasks sharing the cached table.
+
+Broadcast joins (the primary use case for this cache) are generally expected to
+fit in memory. If a build-side relation is large enough to require spilling, it
+should bypass the cache and use a standard partitioned hash join with spilling
+enabled.
+
+Eviction
+--------
+
+Cache eviction is not currently supported. Entries remain in the cache until
+the query context is destroyed, at which point the release callback removes
+them.
+
+Future memory pressure-based eviction would need to address:
+
+1. **Tracking total memory**: Summing the memory held by all cached tables.
+2. **Eviction policy**: Deciding which entries to evict (e.g., LRU, by size).
+3. **Reference invalidation**: Safely handling eviction while probe operators
+   hold references via ``shared_ptr``.
+4. **Rebuild fallback**: Allowing tasks to re-build the table if it was evicted.
+
+The ``drop()`` method already provides the mechanism for removing individual
+entries and could be extended to support eviction driven by the memory manager
+or arbitration framework.
+
+Limitations and Future Work
+---------------------------
+
+- **No spilling**: Cached tables must reside entirely in memory. See
+  :ref:`Spilling <spilling>` above.
+- **No eviction**: Cached entries live for the full query lifetime. Memory
+  pressure-based eviction is planned.
+- **Single-query scope**: The cache key includes the ``queryId``, so tables are
+  not shared across different queries even if the build side data is identical.
+  Cross-query sharing is a potential future optimization.
+- **No sanity checks on table sharing during probe**: For right joins, we rely on
+  the planner to not do a broadcast join and skip using cached tables. But velox
+  as a library does not do checks during probe that it is in fact running a join
+  that does not mutate the hash table. Mutating the cached hash table can cause
+  incorrect execution results. We should add this check
diff --git a/velox/docs/develop/hash-table.rst b/velox/docs/develop/hash-table.rst
index 1d82a1427ca..421668256c5 100644
--- a/velox/docs/develop/hash-table.rst
+++ b/velox/docs/develop/hash-table.rst
@@ -4,7 +4,7 @@
 .. role:: m(math)
 
 ==========
-Hash table
+Hash Table
 ==========
 
 The hash table used in Velox is similar to the
@@ -30,7 +30,7 @@ These are referred to as padding.
     :align: center
 
 A hash table is never full. There are always some empty slots. Velox allows the hash table to fill up to
-:raw-html:`<text style="font-size:1.2em;background-color:none">⅞</text>` of capacity before resizing.
+:raw-html:`<text style="font-size:1.2em;background-color:none">0.7</text>` of capacity before resizing.
 On resize the hash table’s capacity doubles.
 
 Individual buckets may be completely empty, partially filled or full. Buckets are filled left to right.
@@ -117,7 +117,7 @@ the hash table is never full and there are enough gaps in the form of empty slot
 Resizing
 --------
 
-If the hash table fills up beyond :raw-html:`<text style="font-size:1.2em;background-color:none">⅞</text>`
+If the hash table fills up beyond :raw-html:`<text style="font-size:1.2em;background-color:none">0.7</text>`
 of capacity, it needs to be resized. Each resize doubles the capacity.
 A new hash table is allocated and all existing entries inserted using the “Inserting an entry” process.
 Since we know that all entries are unique, the “Inserting an entry” process can be simplified to
@@ -126,11 +126,181 @@ insert an entry, we compute a hash, extract tag and bucket number, go to the buc
 entry if there is space. If the bucket is full, we proceed to the next bucket and continue until we
 find a bucket with an empty slot. We insert the new entry there.
 
+Hash Modes
+----------
+
+The description above covers the default bucket-based hash table (kHash mode).
+Velox also supports two optimized modes that avoid per-entry hashing and
+bucket probing when the key values allow it. The hash table analyzes the key
+data during build and selects the best mode automatically.
+
+The three modes are:
+
+* **kArray** — Direct array lookup. Does not use the bucket-based hash table at
+  all. Each key combination maps to an index in a flat array. Lookup is O(1)
+  with no hashing or probing. Used when the combined key space is small enough
+  to fit in an array.
+
+* **kNormalizedKey** — Bucket-based (same layout as kHash), but keys are
+  encoded into a single 64-bit normalized key stored alongside each row. Key
+  comparison uses this normalized key instead of comparing individual columns,
+  which is faster for multi-column keys.
+
+* **kHash** — Bucket-based with full key comparison. Used when keys cannot be
+  mapped to value IDs or normalized into 64 bits (e.g., complex types like
+  ARRAY, MAP, ROW).
+
+kArray Mode
+~~~~~~~~~~~
+
+In kArray mode, the bucket-based hash table is not used at all. Instead,
+``table_`` is a flat array of pointers indexed directly by a value ID computed
+from the key columns. Lookup is a single array access — no hashing, no tag
+comparison, no probing.
+
+VectorHasher tracks the range (min, max) and distinct values for each key
+column. Each column is assigned a *multiplier* so that multi-column keys
+produce a unique combined index:
+
+.. code-block:: text
+
+    index = valueId(col0) + valueId(col1) * multiplier1 + valueId(col2) * multiplier2 + ...
+
+The value ID for a column is computed using one of two approaches:
+
+1. **Range-based**: for numeric types, the value ID is ``value - min``. The
+   array dimension for the column is the range (max - min + 1). The combined
+   product of all column ranges must be < 2M. This is preferred when the range
+   is within 20x of the distinct count (to avoid wasting array space on sparse
+   ranges).
+
+2. **Distinct-value-based**: VectorHasher maintains a mapping from each unique
+   value to a consecutive integer ID (0, 1, 2, ...). This works for all
+   supported types including VARCHAR, where each unique string gets its own
+   ID. The combined product of per-column distinct counts must be < 2M.
+   This is used when ranges are too large or not applicable (e.g., for
+   VARCHAR, where values don't have a numeric range).
+
+The array size is the product of all per-column dimensions (ranges or distinct
+counts), capped at ``kArrayHashMaxSize`` (2M entries = 16MB of pointer
+storage).
+
+**Supported types**: BOOLEAN, TINYINT, SMALLINT, INTEGER, BIGINT, VARCHAR,
+VARBINARY, TIMESTAMP. Types like REAL, DOUBLE, ARRAY, MAP, ROW do not support
+value ID tracking and cannot use kArray mode.
+
+**Examples**:
+
+* Two BIGINT columns, 500 rows with values 0..499. Range per column is 500,
+  combined range is 500 * 500 = 250'000 < 2M. Uses range-based kArray.
+  (See ``HashTableTest.int2DenseArray``.)
+
+* One VARCHAR column, 500 rows. Each unique string is assigned a consecutive
+  ID (e.g., "apple" → 0, "banana" → 1, ...). With 500 distinct values, the
+  array has 500 entries. (See ``HashTableTest.string1DenseArray``.)
+
+* Two BIGINT columns, 500 rows with spacing 1'000 (values 0, 1000, 2000, ...).
+  Range per column is 500'000, combined range is 250B — too large. But distinct
+  count per column is 500, combined 250'000 < 2M. Uses distinct-value-based
+  kArray. (See ``HashTableTest.int2SparseArray``.)
+
+kNormalizedKey Mode
+~~~~~~~~~~~~~~~~~~~
+
+When the combined key space exceeds 2M entries but can be encoded into a single
+64-bit integer, the table uses kNormalizedKey mode. This uses the same
+bucket-based layout as kHash, but stores a 64-bit *normalized key* immediately
+before each row in the RowContainer.
+
+The normalized key is computed using the same multiplier-based encoding as
+kArray mode:
+
+.. code-block:: text
+
+    normalizedKey = valueId(col0) + valueId(col1) * multiplier1 + ...
+
+During lookups, the normalized key is compared first — a single 64-bit integer
+comparison. If it doesn't match, the full per-column key comparison is skipped.
+This is particularly effective for multi-column keys where comparing individual
+columns would require multiple memory accesses and type-specific comparisons.
+
+**Examples**:
+
+* Two VARCHAR columns, 5'000 rows. Distinct count per column exceeds what fits
+  in a flat array, but the combined distinct values fit in 64 bits.
+  (See ``HashTableTest.string2Normalized``.)
+
+* Two BIGINT columns, 10'000 rows with spacing 1'000 (values 0, 1000, 2000,
+  ...). Range per column is 10M, combined range overflows the 2M array limit,
+  but fits in a 64-bit normalized key.
+  (See ``HashTableTest.int2SparseNormalized``.)
+
+Adaptive Prefetching in hashRows
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+When computing hashes in kNormalizedKey mode, ``hashRows`` reads the normalized
+key stored immediately before each row pointer. Because rows are allocated from
+a RowContainer arena and accessed in hash-partitioned order, successive row
+pointers typically reference different cache lines. When
+the working set exceeds the CPU's last-level cache, each normalized key read
+incurs a DRAM access.
+
+To hide this latency, ``hashRows`` uses the ``AdaptivePrefetch`` class. During
+the first 16 iterations, the class measures per-iteration time using a
+conservative look-ahead of 4. After measurement, it computes an optimal look-ahead
+distance based on the ratio of assumed DRAM latency to measured iteration time,
+multiplied by a coefficient of 4. The result is clamped to [4, 32] — values
+above 32 risk polluting L1 cache with too many outstanding prefetches.
+
+kHash Mode
+~~~~~~~~~~
+
+This is the fallback mode used when:
+
+* Key types don't support value IDs (e.g., ARRAY, MAP, ROW, DOUBLE, REAL).
+* A single key column has more than 10'000 distinct values and the range
+  overflows (cannot use normalized keys).
+* Both the combined range and combined distinct count overflow 64 bits.
+
+In this mode, lookups compute a hash, probe buckets, compare tags, and then
+compare actual key values by following pointers to the RowContainer.
+
+**Examples**:
+
+* One ROW(BIGINT, VARCHAR, BIGINT) column. ROW type does not support value IDs.
+  (See ``HashTableTest.structKey``.)
+
+* Six columns (5 BIGINT + 1 VARCHAR), 100'000 rows with spacing 1'000. The
+  combined cardinality overflows 64 bits.
+  (See ``HashTableTest.mixed6Sparse``.)
+
+Mode Selection
+~~~~~~~~~~~~~~
+
+The mode is selected by ``decideHashMode()`` using this priority:
+
+1. If combined ranges < 2M → **kArray** (range-based).
+2. If best combination of per-column ranges/distincts < 2M → **kArray**
+   (mixed).
+3. If combined ranges fit in 64 bits → **kNormalizedKey**.
+4. If single key column with > 10'000 distincts → **kHash** (normalized key
+   not worthwhile for a single wide column).
+5. If combined distincts < 2M → **kArray** (distinct-value-based).
+6. If both ranges and distincts overflow → **kHash**.
+7. Otherwise → **kNormalizedKey** (combined distincts fit in 64 bits).
+
+The selected mode is reported in the ``hashtable.hashMode`` runtime stat:
+0 for kHash, 1 for kArray, 2 for kNormalizedKey.
+
+See ``HashTableTest`` in ``velox/exec/tests/HashTableTest.cpp`` for tests
+covering all three modes.
+
 Use Cases
 ---------
 
-The main use cases for the hash table are `Join <joins.html>`_ and
-`Aggregation <aggregations.html>`_ operators.
+The main use cases for the hash table are :doc:`Join <joins>` and
+:doc:`Aggregation <aggregations>` operators. It is also used by RowNumber,
+TopNRowNumber, and MarkDistinct operators.
 
 The HashBuild operator builds the hash table to store unique values of the join keys found on the build
 side of the join. The HashProbe operator looks up entries in the hash table using join keys from the
diff --git a/velox/docs/develop/images/task-barrier-multi-driver.png b/velox/docs/develop/images/task-barrier-multi-driver.png
new file mode 100644
index 00000000000..33a173cb512
Binary files /dev/null and b/velox/docs/develop/images/task-barrier-multi-driver.png differ
diff --git a/velox/docs/develop/images/task-barrier-single-driver.png b/velox/docs/develop/images/task-barrier-single-driver.png
new file mode 100644
index 00000000000..cd861aafb5a
Binary files /dev/null and b/velox/docs/develop/images/task-barrier-single-driver.png differ
diff --git a/velox/docs/develop/joins.rst b/velox/docs/develop/joins.rst
index 0a1bf3d6a5c..5f91fea6f43 100644
--- a/velox/docs/develop/joins.rst
+++ b/velox/docs/develop/joins.rst
@@ -3,10 +3,13 @@ Joins
 =====
 
 Velox supports inner, left, right, full outer, left semi filter, left semi
-project, right semi filter, right semi project, and anti hash joins using
-either partitioned or broadcast distribution strategies. Semi project and
+project, right semi filter, right semi project, anti, and counting hash joins
+using either partitioned or broadcast distribution strategies. Semi project and
 anti joins support additional null-aware flag to distinguish between IN
-(null aware) and EXISTS (regular) semantics. Velox also supports cross joins.
+(null aware) and EXISTS (regular) semantics. Anti, left semi filter, and
+counting joins support a null-as-value flag that enables IS NOT DISTINCT FROM
+semantics for join keys (NULL equals NULL), used to implement SQL set operations
+(EXCEPT, INTERSECT, EXCEPT ALL, INTERSECT ALL). Velox also supports cross joins.
 
 Velox also supports inner and left merge join for the case where join inputs are
 sorted on the join keys. Right, full, left semi, right semi, and anti merge joins
@@ -24,11 +27,18 @@ values need to match, and an optional filter to apply to join results.
     :align: center
 
 The join type can be one of kInner, kLeft, kRight, kFull, kLeftSemiFilter,
-kLeftSemiProject, kRightSemiFilter, kRightSemiProject, or kAnti.
+kCountingLeftSemiFilter, kLeftSemiProject, kRightSemiFilter, kRightSemiProject,
+kAnti, or kCountingAnti.
 
 kLeftSemiProject, kRightSemiProject and kAnti joins support an additional
 nullAware flag to distinguish between IN (null aware) and EXISTS (regular)
-semantics.
+semantics. See :doc:`Anti joins <anti-join>` for detailed semantics.
+
+kAnti, kLeftSemiFilter, kCountingAnti, and kCountingLeftSemiFilter joins support
+an additional nullAsValue flag that makes join keys use IS NOT DISTINCT FROM
+semantics where NULL equals NULL. This is used to implement SQL set operations
+(EXCEPT, INTERSECT, EXCEPT ALL, INTERSECT ALL) which require NULLs to match.
+The nullAsValue and nullAware flags are mutually exclusive.
 
 Filter is optional. If specified it can be any expression over the results of
 the join. This expression will be evaluated using the same expression
@@ -119,7 +129,7 @@ HashProbe operator gets access to via a special mechanism: JoinBridge.
     :align: center
 
 Both HashBuild and HashAggregation operators use the same data structure for the
-hash table: `velox::exec::HashTable <hash-table.html>`_. The payload, the non-join key columns
+hash table: :doc:`HashTable <hash-table>`. The payload, the non-join key columns
 referred to as dependent columns, are stored row-wise in the RowContainer.
 
 Using the hash table in join and aggregation allows for a future optimization
@@ -198,6 +208,12 @@ the join is executed using broadcast or partitioned strategy has no effect on
 the join execution itself. The only difference is that broadcast execution
 allows for dynamic filter pushdown while partitioned execution does not.
 
+HashJoinNode supports a ``useHashTableCache`` flag (used only by Presto-on-Spark)
+that enables caching of the hash table built for broadcast joins. When enabled,
+the first task to build the hash table stores it in a global cache, and subsequent
+tasks from same query reuse the cached table instead of rebuilding it. See
+:doc:`Broadcast Build Caching <hash-table-caching>` for details.
+
 PartitionedOutput operator and OutputBufferManager support
 broadcasting the results of the plan evaluation. This functionality is enabled
 by setting boolean flag "broadcast" in the PartitionedOutputNode to true.
@@ -218,7 +234,7 @@ regular anti join is used for queries with NOT EXISTS <subquery> clause.
 
 Broadly-speaking anti join returns probe-side rows which have no match on
 the build side. However, the exact semantics are a bit tricky. These are
-described in detail in :doc:`Anti joins <../develop/anti-join>`.
+described in detail in :doc:`Anti joins <anti-join>`.
 
 At a high level, null-aware anti join without extra filter behaves as follows:
 
@@ -249,7 +265,7 @@ only if the whole build side is empty, allowing to implement semantic
 safe because that row cannot possibly match anything on these destinations.
 
 Semi Joins
-----------
+~~~~~~~~~~
 
 Semi filter joins are used for queries with IN <subquery> and EXISTS <subquery>
 clauses. Left semi filter join should be used when cardinality of the outer
@@ -306,13 +322,63 @@ configuring exec::HashTable to set the "allowDuplicates" flag to false. This
 optimization reduces memory usage of the hash table in case the build side
 contains duplicate join keys.
 
+Counting Joins
+~~~~~~~~~~~~~~
+
+Counting joins (kCountingAnti and kCountingLeftSemiFilter) are multiset variants
+of kAnti and kLeftSemiFilter used to implement EXCEPT ALL and INTERSECT ALL
+respectively.
+
+EXCEPT and INTERSECT treat both inputs as sets: they remove duplicates and
+return distinct rows. EXCEPT ALL and INTERSECT ALL preserve duplicates and
+operate on multisets: each row is considered independently.
+
+.. code-block:: sql
+
+    -- EXCEPT removes duplicates:
+    -- {A, A, A, B, B} EXCEPT {A, C} = {A, B}    (just "is A present?")
+
+    -- EXCEPT ALL counts duplicates:
+    -- {A, A, A, B, B} EXCEPT ALL {A, C} = {A, A, B, B}    (remove one A)
+
+    -- INTERSECT removes duplicates:
+    -- {A, A, A, B, B} INTERSECT {A, A, C} = {A}    (just "is A present?")
+
+    -- INTERSECT ALL counts duplicates:
+    -- {A, A, A, B, B} INTERSECT ALL {A, A, C} = {A, A}    (keep min count)
+
+EXCEPT ALL and INTERSECT ALL cannot be implemented using regular semi and anti
+joins because those only check for the existence of a match, not the number of
+matches. Counting joins solve this by tracking per-key counts.
+
+The build side deduplicates keys and stores a per-key count. Unlike semi and
+anti joins which skip duplicate keys entirely (see `Skipping Duplicate Keys`_
+above), counting joins keep exactly one entry per key with a count of how many
+times that key appeared.
+
+On probe, each match decrements the count. kCountingAnti emits a probe row when
+the count reaches zero or no match is found (EXCEPT ALL semantics).
+kCountingLeftSemiFilter emits a probe row while the count is greater than zero
+(INTERSECT ALL semantics). Counting joins do not support extra filter or
+null-aware mode. Spilling is not yet supported.
+
+Because the probe side modifies per-key counts in the hash table (decrementing
+on each match), it must run either single-threaded or with the probe input
+partitioned on join keys across threads. Without partitioning, multiple probe
+threads could decrement the same key's count concurrently, producing incorrect
+results. The build side can run multi-threaded: each build driver constructs its
+own hash table, and these are merged by summing per-key counts for duplicate
+keys.
+
 Execution Statistics
 ~~~~~~~~~~~~~~~~~~~~
 
-HashBuild operator reports the range and number of distinct values for each join
-key if these are not too large and allow for array-based join or use of
-normalized keys.
+HashBuild operator reports the hash table mode, the range and number of distinct
+values for each join key if these are not too large and allow for array-based
+join or use of normalized keys.
 
+* hashtable.hashMode - the hash mode of the table: 0 for kHash, 1 for kArray,
+  2 for kNormalizedKey
 * rangeKey<N> - the range of values for the join key #N
 * distinctKey<N> - the number of distinct values for the join key #N
 
@@ -339,18 +405,19 @@ to HiveConnector.
 Memory Layout
 -------------
 
-Inside hash table we keep the row values in `RowContainer`.  This is a row-wise
-storage and each row consists the following components:
+The :doc:`hash table <hash-table>` stores row values in RowContainer. This is
+a row-wise storage and each row consists of the following components:
 
 1. Null flags (1 bit per item) for
     1. Keys (only if nullable)
     2. Dependants
-2. Has-probed flag (1 bit)
+2. Has-probed flag (1 bit, right and full outer joins only)
 3. Free flag (1 bit)
 4. Keys
 5. Dependants
 6. Variable size (32 bit)
-7. Next offset (64 bit pointer)
+7. Next offset (64 bit pointer, joins that allow duplicate keys)
+8. Count (32 bit, counting joins only, mutually exclusive with Next offset)
 
 
 Merge Join Implementation
@@ -377,5 +444,6 @@ pipeline. CallbackSink is installed at the end of the right-side pipeline.
 Usage Examples
 --------------
 
-Check out velox/exec/tests/HashJoinTest.cpp and MergeJoinTest.cpp for examples
-of how to build and execute a plan with a hash or merge join.
+Check out velox/exec/tests/HashJoinTest.cpp, CountingJoinTest.cpp, and
+MergeJoinTest.cpp for examples of how to build and execute a plan with a hash,
+counting, or merge join.
diff --git a/velox/docs/develop/memory.rst b/velox/docs/develop/memory.rst
index 5d879a0137d..3675f821816 100644
--- a/velox/docs/develop/memory.rst
+++ b/velox/docs/develop/memory.rst
@@ -122,7 +122,7 @@ Memory Manager
     :alt: Memory Manager
 
 The memory manager is created on server startup with the provided
-*MemoryManagerOption*. It creates a memory allocator instance to manage the
+*MemoryManager::Options*. It creates a memory allocator instance to manage the
 physical memory allocations for both query memory allocated through memory pool
 and cache memory allocated through the file cache. It ensures the total
 allocated memory is within the system memory limit (specified by
@@ -539,7 +539,7 @@ between queries by adjusting their memory pool’s capacities accordingly (see
 
 The *MemoryArbitrator* is defined to support different implementations for
 different query systems. As for now, we implement *SharedArbitrator* for both
-Prestissimo and Prestissimo-on-Spark. `Gluten <https://github.com/apache/incubator-gluten>`_ implements its own memory
+Prestissimo and Prestissimo-on-Spark. `Gluten <https://github.com/apache/gluten>`_ implements its own memory
 arbitrator to integrate with the `Spark memory system <https://www.linkedin.com/pulse/apache-spark-memory-management-deep-dive-deepak-rajak/>`_. *SharedArbitrator*
 ensures the total allocated memory capacity is within the query memory limit
 (*MemoryManager::Options::arbitratorCapacity*), and also ensures each individual
@@ -667,7 +667,7 @@ Here is the memory reclaim process within a query:
    reclamation through disk spilling and table writer flush. *Operator::reclaim*
    is added to support memory reclamation with the default implementation does
    nothing. Only spillable operators override that method: *OrderBy*, *HashBuild*,
-   *HashAggregation*, *RowNumber*, *TopNRowNumber*, *Window* and *TableWriter*.
+   *HashAggregation*, *RowNumber*, *TopNRowNumber*, *MarkDistinct*, *Window* and *TableWriter*.
    As for now, we simply spill everything from the spillable operator’s row
    container to free up memory. After we add memory compaction support for row
    containers, we could leverage fine-grained disk spilling features in Velox
diff --git a/velox/docs/develop/operators.rst b/velox/docs/develop/operators.rst
index 37457bf5cec..c9dbb53cb86 100644
--- a/velox/docs/develop/operators.rst
+++ b/velox/docs/develop/operators.rst
@@ -56,10 +56,12 @@ ValuesNode                  Values                                           Y
 LocalMergeNode              LocalMerge
 LocalPartitionNode          LocalPartition and LocalExchange
 EnforceSingleRowNode        EnforceSingleRow
+EnforceDistinctNode         EnforceDistinct or StreamingEnforceDistinct
 AssignUniqueIdNode          AssignUniqueId
 WindowNode                  Window
 RowNumberNode               RowNumber
 TopNRowNumberNode           TopNRowNumber
+MixedUnionNode              MixedUnion
 ==========================  ==============================================   ===========================
 
 Plan Nodes
@@ -547,6 +549,10 @@ and emitting results.
      - Join type: inner, left, right, full, left semi filter, left semi project, right semi filter, right semi project, anti. You can read about different join types in this `blog post <https://dataschool.com/how-to-teach-people-sql/sql-join-types-explained-visually/>`_.
    * - nullAware
      - Applies to anti and semi project joins only. Indicates whether the join semantic is IN (nullAware = true) or EXISTS (nullAware = false).
+   * - nullAsValue
+     - Optional. When true, join keys use IS NOT DISTINCT FROM semantics where NULL equals NULL. Used to implement SQL set operations (EXCEPT, INTERSECT, EXCEPT ALL, INTERSECT ALL). Mutually exclusive with nullAware.
+   * - useHashTableCache
+     - Optional. Used only by Presto-on-Spark. When true, enables caching of the hash table built for broadcast joins so that subsequent tasks can reuse it.
    * - leftKeys
      - Columns from the left hand side input that are part of the equality condition. At least one must be specified.
    * - rightKeys
@@ -850,6 +856,35 @@ values set to null. If input contains more than one row raises an exception.
 
 Used for queries with non-correlated sub-queries.
 
+EnforceDistinctNode
+~~~~~~~~~~~~~~~~~~~
+
+The EnforceDistinct operator ensures that input rows have unique values for
+specified key columns. It passes through all input rows unchanged, but throws
+an exception with a custom error message if any duplicate key values are
+detected. This is useful for validating uniqueness constraints at runtime,
+such as ensuring a correlated scalar subquery returns at most one row per group.
+
+When preGroupedKeys equals distinctKeys (i.e., input is clustered on the
+distinct keys), the streaming implementation is used which requires only O(1)
+memory. Otherwise, the hash-based implementation is used which requires O(n)
+memory to track all unique key combinations seen so far.
+
+.. list-table::
+   :widths: 10 30
+   :align: left
+   :header-rows: 1
+
+   * - Property
+     - Description
+   * - distinctKeys
+     - List of columns that must have unique values.
+   * - preGroupedKeys
+     - Optional subset of distinctKeys that input is already clustered on. When
+       equal to distinctKeys, uses streaming enforcement with O(1) memory.
+   * - errorMessage
+     - Error message to include in the exception when duplicates are found.
+
 AssignUniqueIdNode
 ~~~~~~~~~~~~~~~~~~
 
@@ -947,7 +982,7 @@ results available before seeing all input.
 TopNRowNumberNode
 ~~~~~~~~~~~~~~~~~
 
-An optimized version of a WindowNode with a single row_number function and a
+An optimized version of a WindowNode with a single row_number, rank or dense_rank function and a
 limit over sorted partitions.
 
 Partitions the input using specified partitioning keys and maintains up to
@@ -955,11 +990,11 @@ a 'limit' number of top rows for each partition. After receiving all input,
 assigns row numbers within each partition starting from 1.
 
 This operator accumulates state: a hash table mapping partition keys to a list
-of top 'limit' rows within that partition.  Returning the row numbers as
+of top 'limit' rows within that partition.  Returning the row number or rank as
 a column in the output is optional. This operator supports spilling as well.
 
 This operator is logically equivalent to a WindowNode followed by
-FilterNode(row_number <= limit), but it uses less memory and CPU.
+FilterNode(rank/row_number <= limit), but it uses less memory and CPU.
 
 .. list-table::
   :widths: 10 30
@@ -985,6 +1020,11 @@ MarkDistinctNode
 The MarkDistinct operator is used to produce aggregate mask columns for aggregations over distinct values, e.g. agg(DISTINCT a).
 Mask is a boolean column set to true for a subset of input rows that collectively represent a set of unique values of 'distinctKeys'.
 
+This operator supports spilling. The spill mechanism follows the same pattern as RowNumber: when memory pressure
+triggers spilling, the hash table contents and future input are partitioned and written to disk. During restore,
+each partition's hash table is rebuilt from the spilled data, preserving knowledge of which keys were already seen.
+Disabled by default; enable with `mark_distinct_spill_enabled` configuration property.
+
 .. list-table::
   :widths: 10 30
   :align: left
@@ -997,6 +1037,35 @@ Mask is a boolean column set to true for a subset of input rows that collectivel
   * - distinctKeys
     - Names of grouping keys.
 
+MixedUnionNode
+~~~~~~~~~~~~~~
+
+The mixed union operation combines data from multiple input sources concurrently,
+producing a single output stream that interleaves rows from all sources. It does
+not enforce a sort order but does attempt to mix input sources according to
+specified ratios; after exhaustion it continues with remaining sources.
+
+All sources must produce the same output schema.
+
+MixedUnion runs single-threaded. Each source runs on its own pipeline and feeds
+data into the MixedUnion operator via a merge source queue.
+
+This operator performs a UNION ALL. It does not deduplicate rows.
+
+.. list-table::
+  :widths: 10 30
+  :align: left
+  :header-rows: 1
+
+  * - Property
+    - Description
+  * - sources
+    - Two or more input plan nodes. All sources must have the same output type.
+  * - batchSizesPerSource
+    - Optional list of per-source batch sizes that controls how many rows are
+      taken from each source when mixing. If not specified or set to zero for a
+      source, a default batch size is used.
+
 Examples
 --------
 
@@ -1059,3 +1128,41 @@ ALL.
 .. image:: images/local-exchange.png
     :width: 400
     :align: center
+
+GPU Operators (cuDF)
+--------------------
+
+When cuDF is enabled, CPU operators are replaced with GPU equivalents at
+pipeline construction time via the ``OperatorAdapterRegistry``. For example,
+``FilterProject`` becomes ``CudfFilterProject``, ``Aggregation`` becomes
+``CudfGroupby`` or ``CudfReduce``, and ``HashJoin`` becomes
+``CudfHashJoinBuild``/``CudfHashJoinProbe``.
+
+Adapter operators are automatically inserted at GPU/CPU boundaries:
+
+* ``CudfFromVelox`` — inserted before a GPU operator when the preceding
+  operator produces CPU data (host-to-device conversion).
+* ``CudfToVelox`` — inserted after a GPU operator when the next operator
+  or the pipeline output requires CPU data (device-to-host conversion).
+
+Adapter operators use synthetic planNodeIds (e.g. ``4-to-velox``) at runtime,
+but redirect their stats to the parent plan node via ``setStatSplitter``.
+This means they appear in ``printPlanWithStats`` output as operator-type
+breakdown lines under their parent node (the same mechanism used by
+``HashBuild``/``HashProbe`` under ``HashJoinNode``).
+
+All cuDF operators extend ``CudfOperatorBase``, which provides:
+
+* Template method pattern (``doAddInput``/``doGetOutput``/``doClose``)
+* NVTX profiling ranges
+
+GPU operators are identified by their ``Cudf`` prefix in operator type names
+(e.g. ``CudfFilterProject``, ``CudfLocalPartition``, ``CudfReduceFINAL``).
+Operators without this prefix (e.g. ``LocalExchange``) run on CPU.
+``TableScan`` uses the cuDF GPU parquet reader via the connector layer but
+is not itself a ``CudfOperatorBase`` subclass.
+
+In stats output, "Cpu time" and "Wall time" for GPU operators reflect the
+host-side duration of ``addInput``/``getOutput`` calls, which includes
+enqueuing GPU work and synchronizing. These are not GPU hardware execution
+times.
diff --git a/velox/docs/develop/scalar-functions.rst b/velox/docs/develop/scalar-functions.rst
index 663aa6bd0a7..5b24a766c18 100644
--- a/velox/docs/develop/scalar-functions.rst
+++ b/velox/docs/develop/scalar-functions.rst
@@ -216,6 +216,38 @@ An example of such function is rand():
     }
   };
 
+Function Owner
+^^^^^^^^^^^^^^
+
+Functions can specify an owner (team or individual) responsible for the function.
+This information is included in exception context messages to help with error
+attribution and debugging. By default, no owner is set.
+
+To specify a custom owner, define a static ``owner`` variable in your function class:
+
+.. code-block:: c++
+
+  template <typename TExec>
+  struct MyFunction {
+    VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+    // Specify the team or individual responsible for this function.
+    static constexpr std::string_view owner = "my-team";
+
+    FOLLY_ALWAYS_INLINE bool call(int64_t& result, const int64_t& input) {
+      result = input * 2;
+      return true;
+    }
+  };
+
+When an exception occurs during function evaluation, the error context will
+include the owner information (if specified), making it easier to identify which team should
+investigate the issue. For example, an error message might look like:
+
+.. code-block:: text
+
+  Owner: my-team. Expression: my_function(c0)
+
 All-ASCII Fast Path
 ^^^^^^^^^^^^^^^^^^^
 
@@ -870,13 +902,32 @@ Use exec::registerVectorFunction to register a stateless vector function.
 exec::registerVectorFunction takes a name, a list of supported signatures
 and unique_ptr to an instance of the function. It takes an optional 'metadata'
 parameter that specifies whether a function is deterministic, has default null
-behavior, and other properties. A helper VectorFunctionMetadataBuilder class
+behavior, owner, and other properties. A helper VectorFunctionMetadataBuilder class
 allows to easily construct 'metadata'. For example,
 
 .. code-block:: c++
 
     VectorFunctionMetadataBuilder().defaultNullBehavior(false).build();
 
+To specify a custom owner for a vector function, use the owner() method of
+VectorFunctionMetadataBuilder:
+
+.. code-block:: c++
+
+    VectorFunctionMetadataBuilder()
+        .defaultNullBehavior(false)
+        .owner("my-team")
+        .build();
+
+The owner information is included in exception context messages to help with
+error attribution and debugging. By default, no owner is set.
+When an exception occurs during function evaluation, the error message will
+include the owner (if specified), for example:
+
+.. code-block:: text
+
+    Owner: my-team. Expression: my_vector_function(c0)
+
 
 An optional “overwrite” flag specifies whether to overwrite a function if a function
 with the specified name already exists.
@@ -1152,6 +1203,72 @@ Benchmarks are a great way to check if an optimization is working, evaluate
 how much benefit it brings and decide whether it is worth the additional
 complexity.
 
+Listening to Function Calls
+--------------------------
+
+Velox supports observing VectorFunction::apply calls via a global listener
+registry. This is useful for monitoring, access control, auditing, or any
+cross-cutting concern that needs to observe function execution without modifying
+function implementations.
+
+Listener factories are registered globally via
+``registerVectorFunctionListenerFactory()``. During expression compilation,
+ExprCompiler calls each factory's ``create()`` method once per resolved scalar
+function. The factory receives the function name, ``VectorFunctionMetadata``,
+and ``QueryConfig``, and returns a ``VectorFunctionListeners`` struct containing
+optional pre and/or post listeners, or ``std::nullopt`` to skip that function.
+
+.. code-block:: c++
+
+  #include "velox/expression/VectorFunctionListener.h"
+
+  class MyListenerFactory : public VectorFunctionListenerFactory {
+   public:
+    std::optional<VectorFunctionListeners> create(
+        std::string_view functionName,
+        const VectorFunctionMetadata& metadata,
+        const core::QueryConfig& queryConfig) override {
+      if (functionName != "target_fn") {
+        return std::nullopt;
+      }
+      return VectorFunctionListeners{
+          std::make_shared<PreApplyListener>(
+              [](std::string_view functionName,
+                 const SelectivityVector& rows,
+                 const std::vector<VectorPtr>& args,
+                 const TypePtr& outputType,
+                 const EvalCtx& context) {
+                // Called before VectorFunction::apply.
+              }),
+          std::make_shared<PostApplyListener>(
+              [](std::string_view functionName,
+                 const SelectivityVector& rows,
+                 const std::vector<VectorPtr>& args,
+                 const TypePtr& outputType,
+                 const EvalCtx& context,
+                 const VectorPtr& result,
+                 std::exception_ptr error) {
+                // Called after VectorFunction::apply, even if apply threw.
+                // 'error' is non-null when apply threw; the framework
+                // rethrows it after all post-listeners have executed.
+              }),
+      };
+    }
+  };
+
+  // Register globally (typically at startup).
+  auto factory = std::make_shared<MyListenerFactory>();
+  registerVectorFunctionListenerFactory(factory);
+
+Key properties:
+
+- **Multiple factories** can be registered independently, each observing
+  different concerns without coordination.
+- **Pre-listener** exceptions propagate immediately and abort the function call.
+- **Post-listener** exceptions are caught and logged (rate-limited); they do not
+  mask the original apply error or prevent other post-listeners from running.
+- **Special forms** (AND, OR, CAST, etc.) are not subject to listening.
+
 Documenting
 -----------
 
diff --git a/velox/docs/develop/task-barrier.rst b/velox/docs/develop/task-barrier.rst
new file mode 100644
index 00000000000..4bc31856559
--- /dev/null
+++ b/velox/docs/develop/task-barrier.rst
@@ -0,0 +1,425 @@
+============
+Task Barrier
+============
+
+Motivation & Context
+--------------------
+
+The introduction of Task Barrier support in Velox was driven by two distinct but
+related high-performance workloads: AI training data loading and Real-time
+Streaming Processing. Both require strict control over task lifecycle and state
+management.
+
+These workloads share three critical requirements:
+
+1. **High Efficiency (Task Reuse)**: AI training feeds data split-by-split.
+   Creating a new VeloxTask for every single split incurs some overhead (memory
+   allocation, plan optimization, operator initialization).
+
+2. **Checkpointing & Consistency (Streaming)**: Streaming systems need a way to
+   safely "pause" the stream to take a consistent snapshot. To do this, the
+   system must ensure all data belonging to a specific time window or epoch is
+   fully processed and flushed before moving to the next.
+
+3. **Deterministic Execution**: To ensure experiments are reproducible, data
+   order and processing must be identical across runs.
+
+The Solution: Task Barrier
+--------------------------
+
+To solve this, Velox uses Sequential Task Execution combined with a Task
+Barrier. This allows a single Velox Task to be reused indefinitely.
+
+The "Barrier" is a synchronization mechanism that forces the task to "pause"
+and drain all in-flight data—including buffered data in stateful operators.
+
+* **For AI Loading**: This ensures the task is clean and ready for the next
+  batch of splits without overhead.
+
+* **For Streaming**: This acts as a "consistent cut," ensuring that all state
+  modifications for the current epoch are finalized and emitted before the next
+  epoch begins.
+
+API & Usage
+-----------
+
+The core API introduced is ``Task::requestBarrier()``. This signals the task to
+finish processing all currently queued splits and fully drain all stateful
+operators.
+
+Workflow
+^^^^^^^^
+
+1. **Feed Splits**: The application adds a set of splits to the task, providing
+   exactly one split per each data source (e.g., one file split for every
+   TableScan node).
+
+2. **Request Barrier**: Immediately after feeding the splits, the application
+   calls ``requestBarrier()``. This signals that no more splits will be added
+   after this Split Set until it has been fully processed, all resulting data
+   has been produced, and the task has completely drained and signaled its
+   completion (reached the barrier).
+
+3. **Process & Barrier Detection**: The application continuously calls
+   ``task->next()`` to fetch results. From a user perspective, the Barrier
+   Reached state is detected precisely when:
+
+   * ``task->next()`` returns no data (nullptr), AND
+   * The returned ContinueFuture is not set (invalid)
+
+   This specific combination confirms that the task is not merely blocked
+   waiting for I/O, but has fully drained all vectors from the current Split
+   Set and is now idle.
+
+   (Note: The internal mechanism of how drivers coordinate this draining
+   sequence and signal completion to the Task is explained in detail in the
+   Implementation Mechanism section).
+
+4. **Decision (Cycle or Finish)**: Once the barrier is reached, the application
+   must take one of two actions:
+
+   * **Finish Task**: If there are no more splits to process (e.g., end of
+     dataset), call ``noMoreSplits()`` on the task to signal the final end of
+     the job and terminate.
+   * **Repeat Cycle**: If more splits exist, proceed to Step 5 to add the next
+     set.
+
+5. **Resume**: The application adds the new Split Set and repeats the process
+   from Step 1.
+
+Code Example (C++)
+^^^^^^^^^^^^^^^^^^
+
+The following pseudo-code illustrates how an AI data loader interacts with the
+Velox Task Barrier:
+
+.. code-block:: c++
+
+    // AI data loading loop
+    // 1. Get splits from the runtime
+    // 2. Feed them to Velox
+    // 3. Wait for barrier to ensure all data for those splits is produced
+
+    bool addSplits();
+
+    for (;;) {
+      // Data consumption loop
+      while (true) {
+        ContinueFuture dataFuture = ContinueFuture::makeEmpty();
+        // Fetch next batch of results (velox vector)
+        auto data = veloxTask->next(&dataFuture);
+
+        if (data != nullptr) {
+          // Consume the data (e.g., feed to training loop)
+          consume(data);
+          continue;
+        }
+
+        // If no data is returned, check if we are blocked
+        // BARRIER REACHED CONDITION: Data is null AND future is invalid.
+        if (!dataFuture.valid()) {
+          // The Task is now idle at the Barrier.
+
+          // Attempt to fetch new splits for the next Split Set
+          if (getSplits()) {
+            continue; // New splits added -> Resume processing (Repeat Cycle)
+          }
+
+          // No more splits available -> Execution finished.
+          return;
+        }
+
+        // Wait for the task to produce more data
+        wait(dataFuture);
+      }
+    }
+
+    // Helper to add splits and request barrier
+    bool getSplits() {
+      auto splitSet = nextSplitSet();
+
+      // TERMINATION CONDITION:
+      // If no more splits are available from the source (e.g., end of dataset),
+      // we must explicitly signal the Task that input is finished.
+      if (!splitSet.has_value()) {
+         for (auto& [op, planNode] : veloxPlan.leafNodes) {
+           veloxTask->noMoreSplits(planNode->id());
+         }
+         return false;
+      }
+
+      // Add splits for all leaf nodes
+      for (auto& [op, planNode] : veloxPlan.leafNodes) {
+        veloxTask->addSplit(planNode->id(), splitSet.at(planNode->id()));
+      }
+
+      // Request a barrier immediately after adding the split set
+      // This acts as a seal for the current split set, ensuring the task
+      // drains fully.
+      veloxTask->requestBarrier();
+      return true;
+    }
+
+Implementation Mechanism
+------------------------
+
+The implementation relies on a special Barrier Split and a cooperative draining
+mechanism within the Driver pipeline.
+
+The Barrier Split
+^^^^^^^^^^^^^^^^^
+
+When ``requestBarrier()`` is called:
+
+* Velox injects a special "Barrier Split" into the split queue of every source
+  operator in the leaf drivers (the drivers that read raw input splits).
+* This split acts as a Sentinel that flows through the pipeline.
+* It is excluded from standard task split processing statistics.
+
+Draining Stateful Operators
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Standard stateless operators (e.g., Filter, Project) process data
+vector-by-vector, typically producing one output vector for each input vector
+without buffering. They handle the barrier sentinel simply by passing it
+downstream once the current input vector is finished.
+
+However, stateful operators (like Aggregations or Joins) actively buffer data
+across multiple input vectors. The barrier mechanism forces them to flush this
+buffer via a BarrierState maintained by each Driver.
+
+The Draining Process:
+
+* **Trigger**: When a source operator receives the Barrier Split, it enters
+  "draining mode" by calling the driver's ``drainOutput()`` method.
+* **Action**: The driver then propagates this state by calling ``startDrain()``
+  on the next operator in the pipeline.
+* **Flush**: If that operator is stateful, it flushes all buffered data to the
+  output.
+* **Forward**: The operator then calls ``startDrain()`` on its downstream
+  operator, ensuring the signal flows operator-by-operator within the driver.
+
+Diagram: Draining Flow (Single Driver)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The diagram below shows how the signal flows. Notice how the Stateful Operator
+must flush its buffer before passing the signal to the Sink.
+
+.. image:: images/task-barrier-single-driver.png
+   :alt: Draining Flow (Single Driver)
+   :width: 100%
+
+Cross-Pipeline Propagation (The DAG)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+A complex query plan in Velox is executed as a Directed Acyclic Graph (DAG) of
+pipelines. The barrier must propagate through this entire graph in topological
+order.
+
+**Mechanism: LocalExchange via Exchange Queue**
+
+The pipelines in Velox are connected by LocalExchange through an Exchange Queue
+mechanism. This structure allows the barrier signal to "jump" across pipeline
+boundaries.
+
+* **Leaf Pipeline Completion**: The barrier processing starts at the leaf
+  drivers. The signal propagates down the operators until it reaches the Sink
+  Operator (e.g., LocalPartition, LocalExchangeSink).
+
+* **The Bridge (Queue)**: When the Sink Operator receives the ``startDrain()``
+  signal, it first flushes any buffered data it holds. It then places a special
+  Barrier Token into the connecting Exchange Queue. This marker sits
+  immediately after the last data vector generated by the current Split Set.
+
+* **Downstream Pipeline Activation**: The downstream driver (e.g., the Join
+  pipeline) reads from this queue. When its Source Operator encounters the
+  Barrier Token, it interprets this as the signal to initiate the barrier
+  sequence for its own pipeline.
+
+* **Synchronization**: This ensures strict ordering. Pipeline B cannot finish
+  its barrier processing until Pipeline A has fully flushed its data and passed
+  the barrier token. The Task monitors the completion of all drivers via the
+  internal ``finishDriverBarrier()`` mechanism; only when the final sink in the
+  final pipeline has finished draining is the Barrier Future fulfilled.
+
+Illustration: MergeJoin Example
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Consider a MergeJoin with two upstream pipelines (Left and Right) feeding into a
+Join pipeline.
+
+* **Step 1**: The Task injects Barrier Splits into the TableScan operators of
+  both the Left and Right pipelines.
+* **Step 2**: Both pipelines process their splits, flush their local operators
+  (e.g., filters), and push data to their respective Exchange Queues.
+* **Step 3**: Both pipelines finish by pushing a Barrier Token into their
+  queues.
+* **Step 4**: The Join Pipeline reads from these queues. It processes data until
+  it hits the Barrier Token on both inputs.
+* **Step 5**: The MergeJoin operator receives ``startDrain()``. It performs the
+  "Drop-Input" optimization (checking if it can stop early) and flushes any
+  remaining matches.
+* **Step 6**: The Join pipeline completes, fulfilling the user's promise.
+
+.. image:: images/task-barrier-multi-driver.png
+   :alt: MergeJoin Barrier Propagation
+   :width: 100%
+
+TableScan & Source Operator Mechanics
+-------------------------------------
+
+The TableScan (or any Source Operator) is the entry point for the barrier
+signal. Its behavior is critical for determining when to "Pause" (Drain) and
+when to "Resume."
+
+Delivery (Entering the Barrier)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+* **Injection**: The ``requestBarrier`` API directly injects a BarrierSplit into
+  the Task's split queue. This split is distinct from regular data splits (e.g.,
+  FileConnectorSplit).
+* **Detection**: The Driver loop responsible for the TableScan fetches the next
+  split from the queue. When it pops the BarrierSplit, it does not attempt to
+  read data.
+* **Signal Initiation**: Instead of calling getOutput, the driver invokes
+  ``startDrain()`` on the TableScan operator. This initiates the cascading drain
+  sequence described in The Draining Process Section.
+* **Exclusion**: The TableScan ensures this split does not increment task
+  progress counters (e.g., "completed splits"), ensuring the barrier is
+  transparent to execution metrics.
+
+Resuming (Exit & Next Split)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+* **Idle State**: Once the TableScan has propagated the drain signal and the
+  downstream pipeline has fully drained, the Driver completes that specific
+  execution cycle. The Task marks the barrier future as complete.
+* **Wait**: The TableScan driver does not terminate; it simply returns to
+  checking the split queue. If the queue is empty, the driver yields (waits).
+* **Re-activation**: When the application calls ``addSplit()`` with new data
+  splits for the next logical Split Set:
+
+  1. The splits are pushed to the queue.
+  2. The TableScan driver wakes up, pops a valid data split, and resumes
+     standard data processing (getOutput).
+
+This seamless transition allows the same Task and Driver instances—and their
+associated memory pools and caches—to be reused indefinitely.
+
+Operator-Specific Implementation Details
+----------------------------------------
+
+The core of the barrier implementation lies in the ``startDrain()`` virtual
+method. While stateless operators simply pass the signal through, stateful
+operators must actively manage their buffers to ensure data determinism.
+
+Index Lookup Join
+^^^^^^^^^^^^^^^^^
+
+* **Function**: Connects a stream of input rows (probe side) with a remote or
+  local index (build side), often fetching matches asynchronously.
+
+**Draining Complexity**: The operator typically buffers input rows to perform
+batched lookups or asynchronous prefetches. Simply stopping input isn't enough;
+pending lookups inside the execution engine must complete and be emitted.
+
+**Barrier Logic**:
+
+* **Flush Prefetch Buffers**: When the barrier signal is received, the operator
+  forces the flushing of any "in-flight" batches that have been sent for lookup
+  but haven't yet produced output.
+* **Drain Output**: It ensures that ``getOutput()`` continues to return results
+  until all buffered lookup requests have been resolved and emitted.
+
+Unnest
+^^^^^^
+
+* **Function**: Expands complex types (arrays, maps) into multiple rows.
+
+**Draining Complexity**: An Unnest operator might require multiple calls to
+``getOutput()`` to fully process a single large input vector due to output batch
+size limits. If a barrier arrives, the operator cannot simply stop; it must
+finish expanding the current vector.
+
+**Barrier Logic**:
+
+* **Process Remaining Rows**: The ``startDrain()`` logic ensures that the
+  operator does not accept new input vectors but continues to generate output
+  until the current input vector is fully unnested.
+* **Clean State**: Once the current input vector is exhausted, the operator
+  transitions to a finished state for that specific barrier cycle, ensuring no
+  partial arrays are left "half-expanded" across the split boundary.
+
+Sort Merge Join
+^^^^^^^^^^^^^^^
+
+* **Function**: Assumes both inputs are sorted and finds matches by traversing
+  them simultaneously. It is highly stateful and relies on the relative order of
+  keys.
+
+**Draining Complexity**: "Over-Reading" in Draining Mode
+
+In a standard Sort Merge Join, the operator buffers rows from one side while
+iterating through the other. When a Barrier acts as a temporary "End of Stream,"
+the operator might continue reading from one input even after the other input
+has finished, to find potential matches. However, because the inputs are sorted,
+the operator often knows that no further matches are possible, making this extra
+I/O wasteful.
+
+**Barrier Logic & The "Drop-Input" Optimization**
+
+This operator implements an optimization to prevent wasteful processing:
+
+1. **Draining Matches**: When ``startDrain()`` is invoked, the operator forces
+   the processing of any matches currently possible with the buffered data.
+
+2. **Early Cutoff (Drop-Input)**:
+
+   * **Logic**: If one side of the join is fully processed/drained (hit the
+     barrier), the operator compares the max key from that finished side against
+     the current key of the active side.
+   * **Decision**: If the active side's key has already passed the finished
+     side's max key (based on sort order), no future matches are possible.
+   * **Action**: The operator sets the ``dropInputOpId`` in the BarrierState.
+     This signals the driver to stop pulling data for the remaining side
+     immediately.
+
+This optimization saves significant CPU and I/O resources while still
+guaranteeing the same correct result as a full drain.
+
+Streaming Aggregation
+^^^^^^^^^^^^^^^^^^^^^
+
+* **Function**: Computes aggregates (SUM, COUNT, etc.) on data already sorted by
+  grouping keys.
+
+**Draining Complexity**: The operator buffers the current group's accumulation
+in memory. If the split ends exactly at a barrier, that partial accumulation
+exists in the operator's state but hasn't been emitted because the operator
+hasn't seen a "new" key to trigger the flush.
+
+**Barrier Logic**:
+
+* **Force Group Flush**: Upon receiving the barrier signal via ``startDrain()``,
+  the operator treats the event as a virtual "end of stream" for the current
+  batch. It forces the emission of the accumulated result for the current group
+  key, even if the key hasn't changed yet.
+* **Reset Accumulators**: After flushing, the accumulators are reset. This
+  ensures that when the task resumes after the barrier with new splits, it
+  starts fresh.
+
+Limitations
+-----------
+
+* **Sequential Execution Mode Only**: The barrier logic currently requires the
+  task to be running in sequential execution mode (single-threaded logic per
+  driver).
+
+* **Restricted Data Sources**: The barrier execution strictly supports only
+  TableScan source nodes. Other source nodes, such as Values (value source node)
+  or RemoteExchange (remote exchange node), are not supported.
+
+* **HashJoin**: Not supported. HashJoin involves complex build-side state
+  management that is less common in the streaming/AI workloads targeted by this
+  feature. These workloads typically rely on MergeJoin or IndexJoin to maintain
+  order and lower memory footprint.
diff --git a/velox/docs/develop/testing.rst b/velox/docs/develop/testing.rst
index 93f92b50a04..e9dabed5229 100644
--- a/velox/docs/develop/testing.rst
+++ b/velox/docs/develop/testing.rst
@@ -11,5 +11,6 @@ Testing Tools
     testing/join-fuzzer
     testing/memory-arbitration-fuzzer
     testing/row-number-fuzzer
+    testing/spatial-join-fuzzer
     testing/writer-fuzzer
     testing/spark-query-runner.rst
diff --git a/velox/docs/develop/testing/memory-arbitration-fuzzer.rst b/velox/docs/develop/testing/memory-arbitration-fuzzer.rst
index b4a15c89245..005b80d4ddb 100644
--- a/velox/docs/develop/testing/memory-arbitration-fuzzer.rst
+++ b/velox/docs/develop/testing/memory-arbitration-fuzzer.rst
@@ -9,8 +9,8 @@ It works as follows:
 
 1. Data Generation: It starts by generating a random set of input data, also known as a vector. This data can
    have a variety of encodings and data layouts to ensure thorough testing.
-2. Plan Generation: Generate multiple plans with different query shapes. Currently, it supports HashJoin and
-   HashAggregation plans.
+2. Plan Generation: Generate multiple plans with different query shapes. Currently, it supports HashJoin,
+   HashAggregation, RowNumber, TopNRowNumber, and OrderBy plans.
 3. Query Execution: Create multiple threads, each thread randomly picks a plan with spill enabled or not, and repeatedly
    running this process until ${iteration_duration_sec} seconds. The query thread expects query to succeed or fail with
    query OOM or abort errors, otherwise it throws.
diff --git a/velox/docs/develop/testing/row-number-fuzzer.rst b/velox/docs/develop/testing/row-number-fuzzer.rst
index f90b33f7621..769acfe2269 100644
--- a/velox/docs/develop/testing/row-number-fuzzer.rst
+++ b/velox/docs/develop/testing/row-number-fuzzer.rst
@@ -1,30 +1,51 @@
-================
-RowNumber Fuzzer
-================
+==================================
+RowNumber and TopNRowNumber Fuzzer
+==================================
 
-The RowNumberFuzzer is a testing tool that automatically generate equivalent query plans and then executes these plans
-to validate the consistency of the results. It works as follows:
+The RowNumberFuzzer and TopNRowNumberFuzzer are testing tools that automatically generate equivalent query plans that
+use the RowNumber and TopNRowNumber Velox plan nodes, and then execute these plans to validate the consistency of
+the results. They works as follows:
 
-1. Data Generation: It starts by generating a random set of input data, also known as a vector. This data can
+1. Data Generation: Generate a random set of input data, also known as a vector. This data can
    have a variety of encodings and data layouts to ensure thorough testing.
-2. Plan Generation: Generate two equivalent query plans, one is row-number over ValuesNode as the base plan.
-   and the other is over TableScanNode as the alter plan.
+2. Plan Generation: Generate equivalent query plans and validate results across all of them.
+
+   For RowNumberFuzzer:
+
+   * Base plan: RowNumber over ValuesNode.
+   * Alternative plan: RowNumber over TableScanNode.
+
+   For TopNRowNumberFuzzer:
+
+   * Base plan: TopNRowNumber over ValuesNode using a randomly chosen rank function
+     (``row_number``, ``rank``, or ``dense_rank``) with a random row limit.
+   * Alternative plan: WindowNode over ValuesNode using the same rank function and partition/sort
+     keys, followed by a filter on the rank value to apply the same limit. This validates that the
+     optimised TopNRowNumber operator produces results consistent with the general Window operator.
+   * Alternative plan: TopNRowNumber over TableScanNode using the same rank function and limit.
+
 3. Query Execution: Executes those equivalent query plans using the generated data and asserts that the results are
    consistent across different plans.
+
   i. Execute the base plan, compare the result with the reference (DuckDB or Presto) and use it as the expected result.
-  #. Execute the alter plan multiple times with and without spill, and compare each result with the
+  #. Execute the alternative plans multiple times with and without spill, and compare each result with the
      expected result.
+
 4. Iteration: This process is repeated multiple times to ensure reliability and robustness.
 
 How to run
 ----------
 
-Use velox_row_number_fuzzer binary to run rowNumber fuzzer:
-
+Use velox_row_number_fuzzer to run RowNumberFuzzer
 ::
 
     velox/exec/fuzzer/velox_row_number_fuzzer --seed 123 --duration_sec 60
 
+Similarly, use velox_topn_row_number_fuzzer to run TopNRowNumberFuzzer
+::
+
+    velox/exec/fuzzer/velox_topn_row_number_fuzzer --seed 123 --duration_sec 60
+
 By default, the fuzzer will go through 10 iterations. Use --steps
 or --duration-sec flag to run fuzzer for longer. Use --seed to
 reproduce fuzzer failures.
diff --git a/velox/docs/develop/testing/spatial-join-fuzzer.rst b/velox/docs/develop/testing/spatial-join-fuzzer.rst
new file mode 100644
index 00000000000..519ab359093
--- /dev/null
+++ b/velox/docs/develop/testing/spatial-join-fuzzer.rst
@@ -0,0 +1,118 @@
+====================
+Spatial Join Fuzzer
+====================
+
+Overview
+========
+
+The Spatial Join Fuzzer tests the correctness of the SpatialJoin operator by generating random geometry data and spatial join plans. It verifies that SpatialJoin produces the same results as NestedLoopJoin for equivalent queries.
+
+
+Supported Features
+==================
+
+Join Types
+----------
+
+The fuzzer tests the two join types supported by SpatialJoin (as defined in ``SpatialJoinNode::isSupported()``):
+
+* **INNER** - Only matching rows from both sides
+* **LEFT** - All rows from left side, matched rows from right side
+
+Spatial Predicates
+------------------
+
+The fuzzer tests these spatial predicates:
+
+* ``ST_Intersects(geometry1, geometry2)`` - Tests if geometries intersect
+* ``ST_Contains(geometry1, geometry2)`` - Tests if one geometry contains another
+* ``ST_Within(geometry1, geometry2)`` - Tests if one geometry is within another
+* ``ST_Distance(geometry1, geometry2) < threshold`` - Tests distance with threshold
+
+Geometry Types
+--------------
+
+The fuzzer generates Well-Known Text (WKT) strings for three geometry types:
+
+* **POINT** - Single coordinate point (e.g., ``POINT (10.5 20.3)``)
+* **POLYGON** - Closed shape with vertices
+* **LINESTRING** - Line segment between two points
+
+Distribution Patterns
+---------------------
+
+Geometries are generated using three distribution patterns:
+
+* **Uniform** - Geometries uniformly distributed in space (0-1000 range)
+* **Clustered** - Geometries grouped in 5 specific regions to test overlap scenarios
+* **Sparse** - Geometries widely spread (0-2000 range) with low overlap probability
+
+Implementation Details
+======================
+
+
+Geometry Generation
+-------------------
+
+Geometries are generated using ``AbstractInputGenerator`` subclasses:
+
+* ``PointInputGenerator`` - Generates POINT WKT strings
+* ``PolygonInputGenerator`` - Generates POLYGON WKT strings
+* ``LineStringInputGenerator`` - Generates LINESTRING WKT strings
+
+Each generator implements the ``generate(vector_size_t index)`` method to produce geometry strings based on the distribution pattern.
+
+**Uniform Distribution**::
+
+    x = random(0, 1000)
+    y = random(0, 1000)
+    POINT (x y)
+
+**Clustered Distribution**::
+
+    cluster = row % 5  // 5 clusters
+    centerX = cluster * 200 + 100
+    centerY = cluster * 200 + 100
+    x = centerX + random(-50, 50)
+    y = centerY + random(-50, 50)
+    POINT (x y)
+
+**Sparse Distribution**::
+
+    x = random(0, 2000)  // Larger Range
+    y = random(0, 2000)
+    POINT (x y)
+
+Data Matching Strategy
+----------------------
+
+To ensure some matches occur during joins:
+
+* Build side copies ~30% of geometries from probe side
+* 10% chance of empty build side to test edge cases
+
+Verification
+------------
+
+The fuzzer compares results from two equivalent plans:
+
+1. **SpatialJoin plan** - Using the specialized SpatialJoin operator
+2. **NestedLoopJoin plan** - Using NestedLoopJoin with the same spatial predicate as a filter
+
+Results must match exactly, validating that SpatialJoin implements spatial predicates correctly.
+
+Key Differences from JoinFuzzer
+================================
+
+Join Conditions
+---------------
+
+Unlike regular joins with simple equality predicates::
+
+    // Regular join
+    probe.id = build.id
+
+    // Spatial join
+    ST_Intersects(probe_geom, build_geom)
+
+Spatial joins use **function call expressions** as join conditions rather than simple column references.
diff --git a/velox/docs/develop/timestamp.rst b/velox/docs/develop/timestamp.rst
index 7d745cc21a9..139fd53fa93 100644
--- a/velox/docs/develop/timestamp.rst
+++ b/velox/docs/develop/timestamp.rst
@@ -139,6 +139,16 @@ generally more efficient, but std::chrono does not handle time zone offsets
 such as ``+09:00``.  Timezone offsets are only supported in the API version
 that takes a timezone ID.
 
+Timezone Database Lookup
+------------------------
+
+Velox uses the IANA Time Zone Database to handle timezone conversions. It looks for the database in the following order:
+
+1. The directory specified by the ``TZDIR`` environment variable.
+2. ``/usr/share/zoneinfo/uclibc`` (on Linux).
+3. ``/usr/share/zoneinfo`` (on Linux).
+4. The path pointed to by ``/etc/localtime`` (on macOS).
+
 Casts
 -----
 
diff --git a/velox/docs/develop/types.rst b/velox/docs/develop/types.rst
index 98106d931bb..c948dbf136b 100644
--- a/velox/docs/develop/types.rst
+++ b/velox/docs/develop/types.rst
@@ -115,6 +115,9 @@ DATE                    INTEGER
 DECIMAL                 BIGINT if precision <= 18, HUGEINT if precision >= 19
 INTERVAL DAY TO SECOND  BIGINT
 INTERVAL YEAR TO MONTH  INTEGER
+TIME                    BIGINT
+TIME_MICRO_UTC          BIGINT
+TIMESTAMP_UTC           TIMESTAMP
 ======================  ======================================================
 
 DECIMAL type carries additional `precision`,
@@ -130,6 +133,12 @@ upto 38 precision, with a range of :math:`[-10^{38} + 1, +10^{38} - 1]`.
 All the three values, precision, scale, unscaled value are required to represent a
 decimal value.
 
+TIME represents time in milliseconds since midnight, subject to session timezone interpretation. Thus min/max value can range from 0 to 23:59:59.999.
+TIME_MICRO_UTC represents time in microseconds since midnight in UTC, not subject to session timezone adjustment. Thus min/max value can range from 00:00:00.000000 to 23:59:59.999999.
+The TIME and TIME_MICRO_UTC types are backed by BIGINT physical type.
+
+TIMESTAMP represents a timestamp subject to session timezone interpretation. TIMESTAMP_UTC represents a timestamp in UTC, not subject to session timezone adjustment. Both types are backed by TIMESTAMP physical type.
+
 Custom Types
 ~~~~~~~~~~~~
 Most custom types can be represented as logical types and can be built by extending
@@ -168,18 +177,35 @@ The table below shows the supported Presto types.
 Presto Type               Physical Type
 ========================  =====================
 HYPERLOGLOG               VARBINARY
+KHYPERLOGLOG              VARBINARY
+P4HYPERLOGLOG             VARBINARY
 JSON                      VARCHAR
 TIMESTAMP WITH TIME ZONE  BIGINT
 UUID                      HUGEINT
 IPADDRESS                 HUGEINT
 IPPREFIX                  ROW(HUGEINT,TINYINT)
+BINGTILE                  BIGINT
 GEOMETRY                  VARBINARY
+SPHERICALGEOGRAPHY        VARBINARY
+SETDIGEST                 VARBINARY
 TDIGEST                   VARBINARY
 QDIGEST                   VARBINARY
 BIGINT_ENUM               BIGINT
 VARCHAR_ENUM              VARCHAR
+TIME WITH TIME ZONE       BIGINT
 ========================  =====================
 
+KHYPERLOGLOG is a data sketch for estimating reidentifiability and joinability within a dataset.
+Based on the `KHyperLogLog paper <https://research.google/pubs/khyperloglog-estimating-reidentifiability-and-joinability-of-large-data-at-scale/>`_,
+it maintains a map of K number of HyperLogLog structures, where each entry corresponds to a unique key from one column,
+and the HLL estimates the cardinality of the associated unique identifiers from another column.
+For storage and retrieval it may be cast to/from VARBINARY.
+
+P4HYPERLOGLOG is a data sketch for cardinality estimation that uses only the dense HyperLogLog
+representation. Unlike standard HYPERLOGLOG which supports both sparse and dense formats,
+P4HYPERLOGLOG always uses dense format. It may be cast to/from HYPERLOGLOG and to/from VARBINARY
+for storage and retrieval.
+
 TIMESTAMP WITH TIME ZONE represents a time point in milliseconds precision
 from UNIX epoch with timezone information. Its physical type is BIGINT.
 The high 52 bits of bigint store signed integer for milliseconds in UTC.
@@ -199,7 +225,10 @@ IPPREFIX networks.
 IPPREFIX represents an IPv6 or IPv4 formatted IPv6 address along with a one byte
 prefix length. Its physical type is ROW(HUGEINT, TINYINT). The IPADDRESS is stored in
 the HUGEINT and is in the form defined in `RFC 4291#section-2.5.5.2 <https://datatracker.ietf.org/doc/html/rfc4291.html#section-2.5.5.2>`_.
-The prefix length is stored in the TINYINT.
+The prefix length is stored in the TINYINT. Note that IPv6 prefix lengths go up
+to 128, which overflows TINYINT (int8_t, max 127). Prefix length 128 is stored
+as -128. Code that reads the prefix length must cast to uint8_t to recover the
+correct unsigned value.
 The IP address stored is the canonical(smallest) IP address in the
 subnet range. This type can be used in IP subnet functions.
 
@@ -213,6 +242,10 @@ As a result the IPPREFIX object stores *FFFF:FFFF::* and the length 32 for both
    IPPREFIX 'FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF/32' -- IPPREFIX 'FFFF:FFFF:0000:0000:0000:0000:0000:0000/32'
    IPPREFIX 'FFFF:FFFF:4455:6677:8899:AABB:CCDD:EEFF/32' -- IPPREFIX 'FFFF:FFFF:0000:0000:0000:0000:0000:0000/32'
 
+SETDIGEST is a data sketch for estimating set cardinality and performing set operations
+like intersection cardinality and Jaccard index. It combines HyperLogLog with MinHash.
+SetDigests may be merged, and for storage and retrieval they may be cast to/from VARBINARY.
+
 TDIGEST(DOUBLE) is a data sketch for estimating rank-based metrics.
 T-digests may be merged without losing precision, and for storage and retrieval
 they may be cast to/from VARBINARY. The T-digest accepts a parameter of type
@@ -243,6 +276,23 @@ VarcharEnumParameter as the key.
 Casting is only permitted to and from VARCHAR type, and is case-sensitive. Casting between different enum types is not permitted.
 Comparison operations are only allowed between values of the same enum type.
 
+TIME WITH TIME ZONE represents time from midnight in milliseconds precision at a particular timezone.
+Its physical type is BIGINT. The high 52 bits of bigint store signed integer for milliseconds in UTC.
+The lower 12 bits store the time zone offsets minutes. This allows the time to be converted at any point of
+time without ambiguity of daylight savings time. Time zone offsets range from -14:00 hours to +14:00 hours.
+
+BINGTILE represents a `Bing tile <https://learn.microsoft.com/en-us/bingmaps/articles/bing-maps-tile-system>`_.
+It is a quadtree in the Web Mercator projection, where each tile is 256x256 pixels. Its physical type is BIGINT.
+
+GEOMETRY represents a geometry as defined in `Simple Feature Access <https://en.wikipedia.org/wiki/Simple_Features>`_.
+Subtypes include Point, MultiPoint, LineString, MultiLineString, Polygon, MultiPolygon, and GeometryCollection. They
+are often stored as `Well-Known Text <https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry>`_ or
+`Well-Known Binary <https://en.wikipedia.org/wiki/Well-known_binary>`_.
+
+SPHERICALGEOGRAPHY represents a geometry on a spherical model of the Earth. It is internally represented the same
+way as GEOMETRY, but only certain functions are supported.  Moreover, these functions will return values in meters
+as opposed to the units of the coordinate space.
+
 Spark Types
 ~~~~~~~~~~~~
 The `data types <https://spark.apache.org/docs/latest/sql-ref-datatypes.html>`_ in Spark have some semantic differences compared to those in
@@ -262,6 +312,14 @@ key differences are listed below.
       ) AS t(ts);
       -- 2014-03-08 09:00:00.012345
 
+* Spark operates on the TIME_MICRO_UTC type for "microsecond" precision and timezone unawareness,
+  while Presto uses the standard TIME type.
+  Example::
+
+      SELECT cast('12:30:45.123456' as time)  -- 12:30:45.123456
+
+* Spark uses TIMESTAMP_UTC to support TimestampNTZType. TIMESTAMP_UTC is not subject to session timezone adjustment.
+
 * In function comparisons, nested null values are handled as values.
   Example::
 
@@ -279,3 +337,233 @@ key differences are listed below.
   also not orderable, but it is comparable if both key and value types are
   comparable. The implication is that MAP type cannot be used as a join, group
   by or order by key in Spark.
+
+Type Coercion
+~~~~~~~~~~~~~
+Type coercion is the implicit conversion of a value from one type to
+another during query planning. It resolves function overloads and
+special-form result types when arguments don't match a signature exactly.
+
+Coercion is a planning-time concern: by the time a Velox ``Task`` is
+constructed, every implicit conversion is already a materialized ``Cast``
+node in the typed expression tree, and runtime evaluators do not consult
+the coercer.
+
+Coercion rules live in ``TypeCoercer`` (``velox/type/TypeCoercer.h``).
+``TypeCoercer`` is value-typed and immutable after construction. Velox ships
+a default instance (``TypeCoercer::defaults()``) holding a conservative
+built-in rule set used when no dialect coercer is provided. SQL dialects
+ship their own complete instances -- for example,
+``velox::functions::prestosql::typeCoercer()`` for the Presto dialect -- that
+match the dialect's overload-resolution semantics.
+
+``TypeCoercer`` itself is frontend-agnostic: it's a plain value type that
+the resolver APIs (``SignatureBinder``,
+``resolveFunction*WithCoercions``, the special-form ``resolveTypeInt``
+helpers) accept as a defaulted tail parameter so existing callers
+compile unchanged and use ``TypeCoercer::defaults()``. How a coercer
+reaches the resolver APIs is the frontend's choice. Axiom, for example,
+threads the dialect coercer through ``logical_plan::PlanBuilder``'s
+``Context.coercer`` field, which the SQL parser sets when constructing
+the plan builder; other frontends may pass a coercer directly into the
+resolver APIs or wire it through their own planning context.
+
+Customization scope
+^^^^^^^^^^^^^^^^^^^
+
+What a dialect's ``TypeCoercer`` rule set controls:
+
+* **Primitives** (TINYINT, SMALLINT, INTEGER, BIGINT, REAL, DOUBLE, BOOLEAN,
+  VARCHAR, VARBINARY, DATE, TIMESTAMP, UNKNOWN): full control over which
+  source/target pairs are allowed and at what cost. Lower cost is preferred
+  during overload resolution.
+* **DECIMAL**: customizable for source and target separately; DECIMAL ->
+  DECIMAL is not customizable. See the DECIMAL section below.
+* **Container types** (ARRAY, MAP, ROW) and FUNCTION/OPAQUE: not
+  customizable directly. Coercibility is structural -- names and arities
+  must match, and children are recursed element-wise. A dialect controls
+  container behavior only indirectly via element-type rules.
+* **Custom types** (e.g. JSON, TIMESTAMP WITH TIME ZONE, BINGTILE): not
+  customizable through a dialect's ``TypeCoercer`` rule set. Custom-type
+  coercions are registered via ``registerCastRules`` alongside
+  ``registerCustomType`` and live in the global ``CastRulesRegistry``,
+  which is shared across dialects. To keep callers from having to query
+  both registries, ``TypeCoercer::coerceTypeBase`` consults
+  ``CastRulesRegistry`` as a fallback after its own rule lookup -- so
+  custom-type coercions remain reachable through any ``TypeCoercer``
+  instance even though the dialect can't override them.
+
+Cost magnitudes
+^^^^^^^^^^^^^^^
+
+Overload resolution sums per-argument coercion costs
+(``Coercion::overallCost``) to compare candidate signatures. For sums to
+be meaningful, every ``CoercionEntry.cost`` in a single ``TypeCoercer``
+instance must be in the same small magnitude -- today's defaults use
+costs 1-9, one per source-type series. There is no hardcoded surcharge
+added at lookup time: the dialect's rule cost is returned verbatim.
+
+DECIMAL
+^^^^^^^
+
+DECIMAL handling depends on which side is DECIMAL. Rule keys collapse on
+the name ``DECIMAL`` regardless of (p, s) -- one rule per
+``(sourceName, targetName)`` pair on each side.
+
+**Source DECIMAL** (e.g. ``DECIMAL(p, s) -> DOUBLE``). A dialect
+registers one rule per ``(DECIMAL, target)`` where ``target`` is a
+non-DECIMAL type (DECIMAL -> DECIMAL is not customizable; see below).
+The source must be the canonical placeholder ``DECIMAL(1, 0)``; the rule
+fires for any actual ``DECIMAL(p, s)`` source because the source's
+precision/scale is not part of the lookup key. The rule resolves
+directly to the target type at the rule's cost.
+
+**Target DECIMAL** (e.g. ``INTEGER -> DECIMAL(p, s)``). A dialect
+registers one rule per ``(source, DECIMAL)``. The rule's stored target
+is the minimum-width decimal that holds every value of the source
+(e.g. ``INTEGER -> DECIMAL(10, 0)``). At lookup, the type system extends
+the rule's fixed target to the caller's requested ``DECIMAL(p, s)`` via
+``ShortDecimalType::isCoercibleTo`` / ``LongDecimalType::isCoercibleTo``
+(see widening rule below). Returns ``nullopt`` if the caller's target is
+too narrow.
+
+Widening itself contributes 0 to the cost; the rule's stored cost is
+returned verbatim. ``INT -> DECIMAL(10, 0)`` and ``INT -> DECIMAL(38,
+18)`` both cost whatever the rule says (e.g. cost 2 in INTEGER's series).
+This is a simple choice that works for current overload-resolution
+cases; it may need to be revisited if a function is registered with
+multiple concrete DECIMAL-target signatures, since they would all coerce
+at the same cost and produce ambiguous resolution.
+
+**DECIMAL -> DECIMAL** (e.g. ``DECIMAL(10, 2) -> DECIMAL(20, 4)``) is
+**not customizable** by dialects. ``TypeCoercer`` rejects rule entries
+with both source and target DECIMAL at construction time, so attempting
+to register one fails fast. Dialects that need non-standard
+DECIMAL -> DECIMAL semantics must extend the type system, not
+``TypeCoercer``.
+
+At lookup time, ``coerceTypeBase`` short-circuits for any two DECIMALs
+regardless of (p, s) and returns ``Coercion{type: from, cost: 0}``.
+Precision/scale reconciliation is therefore not done by
+``coerceTypeBase`` itself; instead it happens via DECIMAL-specific paths
+in two places:
+
+* ``LongDecimalType::commonSuperType`` inside ``leastCommonSuperType``
+  computes the common ``(p, s)`` for plan-level operations (UNION, CASE
+  result type, etc.).
+* ``SignatureBinder``'s integer-parameter binding handles function
+  signatures of the form ``DECIMAL(P, S)`` by binding ``P`` and ``S`` as
+  integer variables from the actual argument types.
+
+*DECIMAL widening rule.* ``DECIMAL(p1, s1)`` is coercible to
+``DECIMAL(p2, s2)`` iff:
+
+* ``p1 - s1 <= p2 - s2`` -- the target has at least as many integer
+  digits as the source, and
+* ``s1 <= s2`` -- the target has at least as much scale.
+
+Both conditions must hold; otherwise the widening fails. This rule is
+used by Target DECIMAL above (extending a fixed-width target to a wider
+caller-requested DECIMAL) and by ``LongDecimalType::commonSuperType``
+for DECIMAL -> DECIMAL reconciliation.
+
+``coerceTypeBase`` vs ``coercible``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``coerceTypeBase(from, to)`` is a single-rule lookup. It does NOT recurse
+into container children -- ``coerceTypeBase(ARRAY<INT>, ARRAY<BIGINT>)``
+returns ``nullopt`` because no flat rule keys on
+``("ARRAY", "ARRAY")``. ``coercible(from, to)`` is the structural
+predicate: for primitives it delegates to ``coerceTypeBase``; for
+containers it requires matching names and arities, then sums child
+coercion costs.
+
+Default coercion rules
+^^^^^^^^^^^^^^^^^^^^^^
+
+``TypeCoercer::defaults()`` ships the rules below. In this and the
+Presto-specific table that follows, allowed targets are listed in cost
+order (cheapest first), and for DECIMAL targets the listed type is the
+minimum-width decimal that holds every value of the source (lookup
+widens to a wider DECIMAL when compatible -- see the DECIMAL section
+above).
+
+==============   ==========================================================
+Source           Allowed targets (in cost order, cheapest first)
+==============   ==========================================================
+TINYINT          SMALLINT, INTEGER, BIGINT, DECIMAL(3, 0), REAL, DOUBLE
+SMALLINT         INTEGER, BIGINT, DECIMAL(5, 0), REAL, DOUBLE
+INTEGER          BIGINT, DECIMAL(10, 0), REAL, DOUBLE
+BIGINT           DECIMAL(19, 0), DOUBLE
+REAL             DOUBLE
+DECIMAL          REAL, DOUBLE
+DATE             TIMESTAMP
+UNKNOWN          TINYINT, BOOLEAN, SMALLINT, INTEGER, BIGINT, REAL, DOUBLE,
+                 VARCHAR, VARBINARY
+==============   ==========================================================
+
+Notable absences:
+
+* ``BIGINT -> REAL`` is not in the defaults (BIGINT has 64-bit integer
+  precision; REAL holds only ~7 decimal digits). Presto allows it; the
+  Presto dialect coercer adds it (see below).
+* No reverse conversions (e.g. ``DOUBLE -> REAL``, ``BIGINT -> INTEGER``).
+* No string conversions (e.g. ``INTEGER -> VARCHAR``).
+* No conversions between unrelated families (e.g. ``BOOLEAN -> INTEGER``,
+  ``DATE -> BIGINT``).
+
+Presto-specific coercion rules
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``velox::functions::prestosql::typeCoercer()`` (in
+``velox/functions/prestosql/coercion/PrestoCoercions.{h,cpp}``) ships a
+complete rule set independent from ``TypeCoercer::defaults()`` so that
+dialect-specific changes don't silently shift when Velox defaults change.
+Same table conventions as above.
+
+==============   ==========================================================
+Source           Allowed targets (in cost order, cheapest first)
+==============   ==========================================================
+TINYINT          SMALLINT, INTEGER, BIGINT, DECIMAL(3, 0), REAL, DOUBLE
+SMALLINT         INTEGER, BIGINT, DECIMAL(5, 0), REAL, DOUBLE
+INTEGER          BIGINT, DECIMAL(10, 0), REAL, DOUBLE
+BIGINT           DECIMAL(19, 0), REAL, DOUBLE
+REAL             DOUBLE
+DECIMAL          REAL, DOUBLE
+DATE             TIMESTAMP
+UNKNOWN          TINYINT, BOOLEAN, SMALLINT, INTEGER, BIGINT, REAL, DOUBLE,
+                 VARCHAR, VARBINARY
+==============   ==========================================================
+
+Differences from Velox's defaults:
+
+* ``BIGINT -> REAL`` is added. The BIGINT row becomes
+  ``DECIMAL(19, 0), REAL, DOUBLE``, mirroring the INTEGER row's
+  ordering. This makes ``divide(real, bigint)`` resolve to
+  ``divide(real, real)`` via ``BIGINT -> REAL`` (cost 2) instead of
+  ``divide(double, double)`` via ``REAL -> DOUBLE + BIGINT -> DOUBLE``
+  (cost 1 + 3 = 4), matching Presto's overload resolution.
+
+Presto also allows the following implicit coercions:
+
+==============================   ==========================================
+Source                           Target
+==============================   ==========================================
+TIMESTAMP                        TIMESTAMP WITH TIME ZONE
+DATE                             TIMESTAMP WITH TIME ZONE
+TIME                             TIME WITH TIME ZONE
+==============================   ==========================================
+
+These are not part of ``presto::typeCoercer()``'s rule set. From
+Velox's perspective the targets above are *custom* types
+(``TIMESTAMP WITH TIME ZONE``, ``TIME WITH TIME ZONE``) registered via
+``registerCustomType``, so their coercion rules live in the global
+``CastRulesRegistry`` (registered with ``implicitAllowed = true``
+alongside the type) rather than in the dialect's ``TypeCoercer``.
+Lookup still finds them because ``coerceTypeBase`` consults
+``CastRulesRegistry`` as a fallback.
+
+Casts to other Presto types backed by Velox custom types (JSON,
+BINGTILE, IPADDRESS, IPPREFIX, UUID, BIGINT_ENUM, VARCHAR_ENUM,
+P4HYPERLOGLOG) are explicit-only -- see
+:doc:`/functions/presto/conversion`.
diff --git a/velox/docs/ext/delta.py b/velox/docs/ext/delta.py
new file mode 100644
index 00000000000..40a76426a2e
--- /dev/null
+++ b/velox/docs/ext/delta.py
@@ -0,0 +1,773 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Generating delta function link :delta:func:`<name>`"""
+
+from __future__ import annotations
+
+from function import (
+    function_sig_re,
+    pairindextypes,
+    parse_arglist,
+    pseudo_parse_arglist,
+    parse_annotation,
+    ObjectEntry,
+    ModuleEntry,
+)
+from typing import Any, Iterable, Iterator, Tuple, cast
+
+from docutils import nodes
+from docutils.nodes import Element, Node
+from docutils.parsers.rst import directives
+from sphinx import addnodes
+from sphinx.addnodes import desc_signature, pending_xref
+from sphinx.application import Sphinx
+from sphinx.builders import Builder
+from sphinx.directives import ObjectDescription
+from sphinx.domains import Domain, Index, IndexEntry, ObjType
+from sphinx.environment import BuildEnvironment
+from sphinx.locale import _, __
+from sphinx.roles import XRefRole
+from sphinx.util import logging
+from sphinx.util.docfields import Field
+from sphinx.util.nodes import (
+    find_pending_xref_condition,
+    make_id,
+    make_refnode,
+)
+from sphinx.util.typing import OptionSpec
+
+logger = logging.getLogger(__name__)
+
+function_module = "delta"
+
+
+class DeltaObject(ObjectDescription[Tuple[str, str]]):
+    """
+    Description of a general Delta object.
+
+    :cvar allow_nesting: Class is an object that allows for nested namespaces
+    :vartype allow_nesting: bool
+    """
+
+    option_spec: OptionSpec = {
+        "noindex": directives.flag,
+        "noindexentry": directives.flag,
+        "nocontentsentry": directives.flag,
+        "module": directives.unchanged,
+        "canonical": directives.unchanged,
+        "annotation": directives.unchanged,
+    }
+
+    doc_field_types = [
+        Field(
+            "returnvalue",
+            label=_("Returns"),
+            has_arg=False,
+            names=("returns", "return"),
+        ),
+    ]
+
+    allow_nesting = False
+
+    def get_signature_prefix(self, sig: str) -> list[nodes.Node]:
+        """May return a prefix to put before the object name in the
+        signature.
+        """
+        return []
+
+    def needs_arglist(self) -> bool:
+        """May return true if an empty argument list is to be generated even if
+        the document contains none.
+        """
+        return False
+
+    def handle_signature(self, sig: str, signode: desc_signature) -> tuple[str, str]:
+        """Transform a Delta signature into RST nodes.
+        Return (fully qualified name of the thing, classname if any).
+        If inside a class, the current class name is handled intelligently:
+        * it is stripped from the displayed name if present
+        * it is added to the full name (return value) if not present
+        """
+        m = function_sig_re.match(sig)
+        if m is None:
+            raise ValueError
+        prefix, name, arglist, retann = m.groups()
+
+        # determine module and class name (if applicable), as well as full name
+        modname = self.options.get("module", self.env.ref_context.get("delta:module"))
+        classname = self.env.ref_context.get("delta:class")
+        if classname:
+            add_module = False
+            if prefix and (prefix == classname or prefix.startswith(classname + ".")):
+                fullname = prefix + name
+                # class name is given again in the signature
+                prefix = prefix[len(classname) :].lstrip(".")
+            elif prefix:
+                # class name is given in the signature, but different
+                # (shouldn't happen)
+                fullname = classname + "." + prefix + name
+            else:
+                # class name is not given in the signature
+                fullname = classname + "." + name
+        else:
+            add_module = True
+            if prefix:
+                classname = prefix.rstrip(".")
+                fullname = prefix + name
+            else:
+                classname = ""
+                fullname = name
+
+        signode["module"] = modname
+        signode["class"] = classname
+        signode["fullname"] = fullname
+
+        sig_prefix = self.get_signature_prefix(sig)
+        if sig_prefix:
+            if type(sig_prefix) is str:
+                raise TypeError(
+                    "Python directive method get_signature_prefix()"
+                    " must return a list of nodes."
+                    f" Return value was '{sig_prefix}'."
+                )
+            else:
+                signode += addnodes.desc_annotation(str(sig_prefix), "", *sig_prefix)
+
+        if prefix:
+            signode += addnodes.desc_addname(prefix, prefix)
+        elif modname and add_module and self.env.config.add_module_names:
+            nodetext = modname + "."
+            signode += addnodes.desc_addname(nodetext, nodetext)
+
+        signode += addnodes.desc_name(name, name)
+        if arglist:
+            try:
+                signode += parse_arglist(function_module, arglist, self.env)
+            except SyntaxError:
+                # fallback to parse arglist original parser.
+                # it supports to represent optional arguments (ex. "func(foo [, bar])")
+                pseudo_parse_arglist(signode, arglist)
+            except NotImplementedError as exc:
+                logger.warning(
+                    "could not parse arglist (%r): %s", arglist, exc, location=signode
+                )
+                pseudo_parse_arglist(signode, arglist)
+        else:
+            if self.needs_arglist():
+                # for callables, add an empty parameter list
+                signode += addnodes.desc_parameterlist()
+
+        if retann:
+            children = parse_annotation(function_module, retann, self.env)
+            signode += addnodes.desc_returns(retann, "", *children)
+
+        anno = self.options.get("annotation")
+        if anno:
+            signode += addnodes.desc_annotation(
+                " " + anno, "", addnodes.desc_sig_space(), nodes.Text(anno)
+            )
+
+        return fullname, prefix
+
+    def _object_hierarchy_parts(self, sig_node: desc_signature) -> tuple[str, ...]:
+        if "fullname" not in sig_node:
+            return ()
+        modname = sig_node.get("module")
+        fullname = sig_node["fullname"]
+
+        if modname:
+            return (modname, *fullname.split("."))
+        else:
+            return tuple(fullname.split("."))
+
+    def get_index_text(self, modname: str, name: tuple[str, str]) -> str:
+        """Return the text for the index entry of the object."""
+        raise NotImplementedError("must be implemented in subclasses")
+
+    def add_target_and_index(
+        self, name_cls: tuple[str, str], sig: str, signode: desc_signature
+    ) -> None:
+        modname = self.options.get("module", self.env.ref_context.get("delta:module"))
+        fullname = (modname + "." if modname else "") + name_cls[0]
+        node_id = make_id(self.env, self.state.document, "", fullname)
+        signode["ids"].append(node_id)
+        self.state.document.note_explicit_target(signode)
+
+        domain = cast(DeltaDomain, self.env.get_domain("delta"))
+        domain.note_object(fullname, self.objtype, node_id, location=signode)
+
+        canonical_name = self.options.get("canonical")
+        if canonical_name:
+            domain.note_object(
+                canonical_name, self.objtype, node_id, aliased=True, location=signode
+            )
+
+        if "noindexentry" not in self.options:
+            indextext = self.get_index_text(modname, name_cls)
+            if indextext:
+                self.indexnode["entries"].append(
+                    ("single", indextext, node_id, "", None)
+                )
+
+    def before_content(self) -> None:
+        """Handle object nesting before content
+
+        For constructs that aren't nestable, the stack is bypassed, and instead
+        only the most recent object is tracked. This object prefix name will be
+        removed with :delta:meth:`after_content`.
+        """
+        prefix = None
+        if self.names:
+            # fullname and name_prefix come from the `handle_signature` method.
+            # fullname represents the full object name that is constructed using
+            # object nesting and explicit prefixes. `name_prefix` is the
+            # explicit prefix given in a signature
+            (fullname, name_prefix) = self.names[-1]
+            if self.allow_nesting:
+                prefix = fullname
+            elif name_prefix:
+                prefix = name_prefix.strip(".")
+        if prefix:
+            self.env.ref_context["delta:class"] = prefix
+            if self.allow_nesting:
+                classes = self.env.ref_context.setdefault("delta:classes", [])
+                classes.append(prefix)
+        if "module" in self.options:
+            modules = self.env.ref_context.setdefault("delta:modules", [])
+            modules.append(self.env.ref_context.get("delta:module"))
+            self.env.ref_context["delta:module"] = self.options["module"]
+
+    def after_content(self) -> None:
+        """Handle object de-nesting after content
+
+        If this class is a nestable object, removing the last nested class prefix
+        ends further nesting in the object.
+
+        If this class is not a nestable object, the list of classes should not
+        be altered as we didn't affect the nesting levels in
+        :delta:meth:`before_content`.
+        """
+        classes = self.env.ref_context.setdefault("delta:classes", [])
+        if self.allow_nesting:
+            try:
+                classes.pop()
+            except IndexError:
+                pass
+        self.env.ref_context["delta:class"] = classes[-1] if len(classes) > 0 else None
+        if "module" in self.options:
+            modules = self.env.ref_context.setdefault("delta:modules", [])
+            if modules:
+                self.env.ref_context["delta:module"] = modules.pop()
+            else:
+                self.env.ref_context.pop("delta:module")
+
+    def _toc_entry_name(self, sig_node: desc_signature) -> str:
+        if not sig_node.get("_toc_parts"):
+            return ""
+
+        config = self.env.app.config
+        objtype = sig_node.parent.get("objtype")
+        if config.add_function_parentheses and objtype in {"function", "method"}:
+            parens = "()"
+        else:
+            parens = ""
+        *parents, name = sig_node["_toc_parts"]
+        if config.toc_object_entries_show_parents == "domain":
+            return sig_node.get("fullname", name) + parens
+        if config.toc_object_entries_show_parents == "hide":
+            return name + parens
+        if config.toc_object_entries_show_parents == "all":
+            return ".".join(parents + [name + parens])
+        return ""
+
+
+class DeltaFunction(DeltaObject):
+    """Description of a function."""
+
+    option_spec: OptionSpec = DeltaObject.option_spec.copy()
+    option_spec.update(
+        {
+            "async": directives.flag,
+        }
+    )
+
+    def get_signature_prefix(self, sig: str) -> list[nodes.Node]:
+        if "async" in self.options:
+            return [addnodes.desc_sig_keyword("", "async"), addnodes.desc_sig_space()]
+        else:
+            return []
+
+    def needs_arglist(self) -> bool:
+        return True
+
+    def add_target_and_index(
+        self, name_cls: tuple[str, str], sig: str, signode: desc_signature
+    ) -> None:
+        super().add_target_and_index(name_cls, sig, signode)
+        if "noindexentry" not in self.options:
+            modname = self.options.get(
+                "module", self.env.ref_context.get("delta:module")
+            )
+            node_id = signode["ids"][0]
+
+            name, cls = name_cls
+            if modname:
+                text = _("%s() (in module %s)") % (name, modname)
+                self.indexnode["entries"].append(("single", text, node_id, "", None))
+            else:
+                text = f"{pairindextypes['builtin']}; {name}()"
+                self.indexnode["entries"].append(("pair", text, node_id, "", None))
+
+    def get_index_text(self, modname: str, name_cls: tuple[str, str]) -> str | None:
+        # add index in own add_target_and_index() instead.
+        return None
+
+
+class DeltaXRefRole(XRefRole):
+    def process_link(
+        self,
+        env: BuildEnvironment,
+        refnode: Element,
+        has_explicit_title: bool,
+        title: str,
+        target: str,
+    ) -> tuple[str, str]:
+        refnode["delta:module"] = env.ref_context.get("delta:module")
+        refnode["delta:class"] = env.ref_context.get("delta:class")
+        if not has_explicit_title:
+            title = title.lstrip(".")  # only has a meaning for the target
+            target = target.lstrip("~")  # only has a meaning for the title
+            # if the first character is a tilde, don't display the module/class
+            # parts of the contents
+            if title[0:1] == "~":
+                title = title[1:]
+                dot = title.rfind(".")
+                if dot != -1:
+                    title = title[dot + 1 :]
+        # if the first character is a dot, search more specific namespaces first
+        # else search builtins first
+        if target[0:1] == ".":
+            target = target[1:]
+            refnode["refspecific"] = True
+        return title, target
+
+
+class DeltaModuleIndex(Index):
+    """
+    Index subclass to provide the Delta module index.
+    """
+
+    name = "modindex"
+    localname = _("Delta Module Index")
+    shortname = _("modules")
+
+    def generate(
+        self, docnames: Iterable[str] | None = None
+    ) -> tuple[list[tuple[str, list[IndexEntry]]], bool]:
+        content: dict[str, list[IndexEntry]] = {}
+        # list of prefixes to ignore
+        ignores: list[str] = self.domain.env.config["modindex_common_prefix"]
+        ignores = sorted(ignores, key=len, reverse=True)
+        # list of all modules, sorted by module name
+        modules = sorted(
+            self.domain.data["modules"].items(), key=lambda x: x[0].lower()
+        )
+        # sort out collapsible modules
+        prev_modname = ""
+        num_toplevels = 0
+        for modname, (docname, node_id, synopsis, platforms, deprecated) in modules:
+            if docnames and docname not in docnames:
+                continue
+
+            for ignore in ignores:
+                if modname.startswith(ignore):
+                    modname = modname[len(ignore) :]
+                    stripped = ignore
+                    break
+            else:
+                stripped = ""
+
+            # we stripped the whole module name?
+            if not modname:
+                modname, stripped = stripped, ""
+
+            entries = content.setdefault(modname[0].lower(), [])
+
+            package = modname.split(".")[0]
+            if package != modname:
+                # it's a submodule
+                if prev_modname == package:
+                    # first submodule - make parent a group head
+                    if entries:
+                        last = entries[-1]
+                        entries[-1] = IndexEntry(
+                            last[0], 1, last[2], last[3], last[4], last[5], last[6]
+                        )
+                elif not prev_modname.startswith(package):
+                    # submodule without parent in list, add dummy entry
+                    entries.append(
+                        IndexEntry(stripped + package, 1, "", "", "", "", "")
+                    )
+                subtype = 2
+            else:
+                num_toplevels += 1
+                subtype = 0
+
+            qualifier = _("Deprecated") if deprecated else ""
+            entries.append(
+                IndexEntry(
+                    stripped + modname,
+                    subtype,
+                    docname,
+                    node_id,
+                    platforms,
+                    qualifier,
+                    synopsis,
+                )
+            )
+            prev_modname = modname
+
+        # apply heuristics when to collapse modindex at page load:
+        # only collapse if number of toplevel modules is larger than
+        # number of submodules
+        collapse = len(modules) - num_toplevels < num_toplevels
+
+        # sort by first letter
+        sorted_content = sorted(content.items())
+
+        return sorted_content, collapse
+
+
+class DeltaDomain(Domain):
+    """Delta domain."""
+
+    name = "delta"
+    label = "Delta"
+    object_types: dict[str, ObjType] = {
+        "function": ObjType(_("function"), "func", "obj"),
+    }
+
+    directives = {
+        "function": DeltaFunction,
+    }
+    roles = {
+        "func": DeltaXRefRole(fix_parens=True),
+    }
+    initial_data: dict[str, dict[str, tuple[Any]]] = {
+        "objects": {},  # fullname -> docname, objtype
+        "modules": {},  # modname -> docname, synopsis, platform, deprecated
+    }
+    indices = [
+        DeltaModuleIndex,
+    ]
+
+    @property
+    def objects(self) -> dict[str, ObjectEntry]:
+        return self.data.setdefault("objects", {})  # fullname -> ObjectEntry
+
+    def note_object(
+        self,
+        name: str,
+        objtype: str,
+        node_id: str,
+        aliased: bool = False,
+        location: Any = None,
+    ) -> None:
+        """Note a delta object for cross reference.
+
+        .. versionadded:: 2.1
+        """
+        if name in self.objects:
+            other = self.objects[name]
+            if other.aliased and aliased is False:
+                # The original definition found. Override it!
+                pass
+            elif other.aliased is False and aliased:
+                # The original definition is already registered.
+                return
+            else:
+                # duplicated
+                logger.warning(
+                    __(
+                        "duplicate object description of %s, "
+                        "other instance in %s, use :noindex: for one of them"
+                    ),
+                    name,
+                    other.docname,
+                    location=location,
+                )
+        self.objects[name] = ObjectEntry(self.env.docname, node_id, objtype, aliased)
+
+    @property
+    def modules(self) -> dict[str, ModuleEntry]:
+        return self.data.setdefault("modules", {})  # modname -> ModuleEntry
+
+    def note_module(
+        self, name: str, node_id: str, synopsis: str, platform: str, deprecated: bool
+    ) -> None:
+        """Note a delta module for cross reference.
+
+        .. versionadded:: 2.1
+        """
+        self.modules[name] = ModuleEntry(
+            self.env.docname, node_id, synopsis, platform, deprecated
+        )
+
+    def clear_doc(self, docname: str) -> None:
+        for fullname, obj in list(self.objects.items()):
+            if obj.docname == docname:
+                del self.objects[fullname]
+        for modname, mod in list(self.modules.items()):
+            if mod.docname == docname:
+                del self.modules[modname]
+
+    def merge_domaindata(self, docnames: list[str], otherdata: dict[str, Any]) -> None:
+        # XXX check duplicates?
+        for fullname, obj in otherdata["objects"].items():
+            if obj.docname in docnames:
+                self.objects[fullname] = obj
+        for modname, mod in otherdata["modules"].items():
+            if mod.docname in docnames:
+                self.modules[modname] = mod
+
+    def find_obj(
+        self,
+        env: BuildEnvironment,
+        modname: str,
+        classname: str,
+        name: str,
+        type: str | None,
+        searchmode: int = 0,
+    ) -> list[tuple[str, ObjectEntry]]:
+        """Find a Delta object for "name", perhaps using the given module
+        and/or classname.  Returns a list of (name, object entry) tuples.
+        """
+        # skip parens
+        if name[-2:] == "()":
+            name = name[:-2]
+
+        if not name:
+            return []
+
+        matches: list[tuple[str, ObjectEntry]] = []
+
+        newname = None
+        if searchmode == 1:
+            if type is None:
+                objtypes = list(self.object_types)
+            else:
+                objtypes = self.objtypes_for_role(type)
+            if objtypes is not None:
+                if modname and classname:
+                    fullname = modname + "." + classname + "." + name
+                    if (
+                        fullname in self.objects
+                        and self.objects[fullname].objtype in objtypes
+                    ):
+                        newname = fullname
+                if not newname:
+                    if (
+                        modname
+                        and modname + "." + name in self.objects
+                        and self.objects[modname + "." + name].objtype in objtypes
+                    ):
+                        newname = modname + "." + name
+                    elif (
+                        name in self.objects and self.objects[name].objtype in objtypes
+                    ):
+                        newname = name
+                    else:
+                        # "fuzzy" searching mode
+                        searchname = "." + name
+                        matches = [
+                            (oname, self.objects[oname])
+                            for oname in self.objects
+                            if oname.endswith(searchname)
+                            and self.objects[oname].objtype in objtypes
+                        ]
+        else:
+            # NOTE: searching for exact match, object type is not considered
+            if name in self.objects:
+                newname = name
+            elif type == "mod":
+                # only exact matches allowed for modules
+                return []
+            elif classname and classname + "." + name in self.objects:
+                newname = classname + "." + name
+            elif modname and modname + "." + name in self.objects:
+                newname = modname + "." + name
+            elif (
+                modname
+                and classname
+                and modname + "." + classname + "." + name in self.objects
+            ):
+                newname = modname + "." + classname + "." + name
+        if newname is not None:
+            matches.append((newname, self.objects[newname]))
+        return matches
+
+    def resolve_xref(
+        self,
+        env: BuildEnvironment,
+        fromdocname: str,
+        builder: Builder,
+        type: str,
+        target: str,
+        node: pending_xref,
+        contnode: Element,
+    ) -> Element | None:
+        modname = node.get("delta:module")
+        clsname = node.get("delta:class")
+        searchmode = 1 if node.hasattr("refspecific") else 0
+        matches = self.find_obj(env, modname, clsname, target, type, searchmode)
+
+        if not matches and type == "attr":
+            # fallback to meth (for property; Sphinx-2.4.x)
+            # this ensures that `:attr:` role continues to refer to the old property entry
+            # that defined by ``method`` directive in old reST files.
+            matches = self.find_obj(env, modname, clsname, target, "meth", searchmode)
+        if not matches and type == "meth":
+            # fallback to attr (for property)
+            # this ensures that `:meth:` in the old reST files can refer to the property
+            # entry that defined by ``property`` directive.
+            #
+            # Note: _prop is a secret role only for internal look-up.
+            matches = self.find_obj(env, modname, clsname, target, "_prop", searchmode)
+
+        if not matches:
+            return None
+        elif len(matches) > 1:
+            canonicals = [m for m in matches if not m[1].aliased]
+            if len(canonicals) == 1:
+                matches = canonicals
+            else:
+                logger.warning(
+                    __("more than one target found for cross-reference %r: %s"),
+                    target,
+                    ", ".join(match[0] for match in matches),
+                    type="ref",
+                    subtype="python",
+                    location=node,
+                )
+        name, obj = matches[0]
+
+        if obj[2] == "module":
+            return self._make_module_refnode(builder, fromdocname, name, contnode)
+        else:
+            # determine the content of the reference by conditions
+            content = find_pending_xref_condition(node, "resolved")
+            if content:
+                children = content.children
+            else:
+                # if not found, use contnode
+                children = [contnode]
+
+            return make_refnode(builder, fromdocname, obj[0], obj[1], children, name)
+
+    def resolve_any_xref(
+        self,
+        env: BuildEnvironment,
+        fromdocname: str,
+        builder: Builder,
+        target: str,
+        node: pending_xref,
+        contnode: Element,
+    ) -> list[tuple[str, Element]]:
+        modname = node.get("delta:module")
+        clsname = node.get("delta:class")
+        results: list[tuple[str, Element]] = []
+
+        # always search in "refspecific" mode with the :any: role
+        matches = self.find_obj(env, modname, clsname, target, None, 1)
+        multiple_matches = len(matches) > 1
+
+        for name, obj in matches:
+            if multiple_matches and obj.aliased:
+                # Skip duplicated matches
+                continue
+
+            if obj[2] == "module":
+                results.append(
+                    (
+                        "delta:mod",
+                        self._make_module_refnode(builder, fromdocname, name, contnode),
+                    )
+                )
+            else:
+                # determine the content of the reference by conditions
+                content = find_pending_xref_condition(node, "resolved")
+                if content:
+                    children = content.children
+                else:
+                    # if not found, use contnode
+                    children = [contnode]
+
+                results.append(
+                    (
+                        "delta:" + self.role_for_objtype(obj[2]),
+                        make_refnode(
+                            builder, fromdocname, obj[0], obj[1], children, name
+                        ),
+                    )
+                )
+        return results
+
+    def _make_module_refnode(
+        self, builder: Builder, fromdocname: str, name: str, contnode: Node
+    ) -> Element:
+        # get additional info for modules
+        module = self.modules[name]
+        title = name
+        if module.synopsis:
+            title += ": " + module.synopsis
+        if module.deprecated:
+            title += _(" (deprecated)")
+        if module.platform:
+            title += " (" + module.platform + ")"
+        return make_refnode(
+            builder, fromdocname, module.docname, module.node_id, contnode, title
+        )
+
+    def get_objects(self) -> Iterator[tuple[str, str, str, str, str, int]]:
+        for modname, mod in self.modules.items():
+            yield (modname, modname, "module", mod.docname, mod.node_id, 0)
+        for refname, obj in self.objects.items():
+            if obj.objtype != "module":  # modules are already handled
+                if obj.aliased:
+                    # aliased names are not full-text searchable.
+                    yield (refname, refname, obj.objtype, obj.docname, obj.node_id, -1)
+                else:
+                    yield (refname, refname, obj.objtype, obj.docname, obj.node_id, 1)
+
+    def get_full_qualified_name(self, node: Element) -> str | None:
+        modname = node.get("delta:module")
+        clsname = node.get("delta:class")
+        target = node.get("reftarget")
+        if target is None:
+            return None
+        else:
+            return ".".join(filter(None, [modname, clsname, target]))
+
+
+def setup(app: Sphinx) -> dict[str, Any]:
+    app.setup_extension("sphinx.directives")
+    app.add_domain(DeltaDomain)
+
+    return {
+        "version": "builtin",
+        "env_version": 3,
+        "parallel_read_safe": True,
+        "parallel_write_safe": True,
+    }
diff --git a/velox/docs/functions.rst b/velox/docs/functions.rst
index 6164b8ad3de..ae2d4d2ef99 100644
--- a/velox/docs/functions.rst
+++ b/velox/docs/functions.rst
@@ -21,6 +21,8 @@ Presto Functions
     functions/presto/aggregate
     functions/presto/window
     functions/presto/hyperloglog
+    functions/presto/khyperloglog
+    functions/presto/setdigest
     functions/presto/tdigest
     functions/presto/qdigest
     functions/presto/geospatial
@@ -70,132 +72,140 @@ for :doc:`all <functions/presto/coverage>` and :doc:`most used
     =================================================  =================================================  =================================================  ==  =================================================  ==  =================================================
     Scalar Functions                                                                                                                                             Aggregate Functions                                    Window Functions
     =======================================================================================================================================================  ==  =================================================  ==  =================================================
-    :func:`$internal$json_string_to_array_cast`        :func:`gt`                                         :func:`sequence`                                       :func:`any_value`                                      :func:`cume_dist`
-    :func:`$internal$json_string_to_map_cast`          :func:`gte`                                        :func:`sha1`                                           :func:`approx_distinct`                                :func:`dense_rank`
-    :func:`$internal$json_string_to_row_cast`          :func:`hamming_distance`                           :func:`sha256`                                         :func:`approx_most_frequent`                           :func:`first_value`
-    :func:`$internal$split_to_map`                     :func:`hmac_md5`                                   :func:`sha512`                                         :func:`approx_percentile`                              :func:`lag`
-    :func:`abs`                                        :func:`hmac_sha1`                                  :func:`shuffle`                                        :func:`approx_set`                                     :func:`last_value`
-    :func:`acos`                                       :func:`hmac_sha256`                                :func:`sign`                                           :func:`arbitrary`                                      :func:`lead`
-    :func:`all_keys_match`                             :func:`hmac_sha512`                                :func:`simplify_geometry`                              :func:`array_agg`                                      :func:`nth_value`
-    :func:`all_match`                                  :func:`hour`                                       :func:`sin`                                            :func:`avg`                                            :func:`ntile`
-    :func:`any_keys_match`                             in                                                 :func:`slice`                                          :func:`bitwise_and_agg`                                :func:`percent_rank`
-    :func:`any_match`                                  :func:`infinity`                                   :func:`split`                                          :func:`bitwise_or_agg`                                 :func:`rank`
-    :func:`any_values_match`                           :func:`inverse_beta_cdf`                           :func:`split_part`                                     :func:`bitwise_xor_agg`                                :func:`row_number`
-    :func:`array_average`                              :func:`inverse_binomial_cdf`                       :func:`split_to_map`                                   :func:`bool_and`
-    :func:`array_constructor`                          :func:`inverse_cauchy_cdf`                         :func:`split_to_multimap`                              :func:`bool_or`
-    :func:`array_cum_sum`                              :func:`inverse_chi_squared_cdf`                    :func:`spooky_hash_v2_32`                              :func:`checksum`
-    :func:`array_distinct`                             :func:`inverse_f_cdf`                              :func:`spooky_hash_v2_64`                              :func:`classification_fall_out`
-    :func:`array_duplicates`                           :func:`inverse_gamma_cdf`                          :func:`sqrt`                                           :func:`classification_miss_rate`
-    :func:`array_except`                               :func:`inverse_laplace_cdf`                        :func:`st_area`                                        :func:`classification_precision`
-    :func:`array_frequency`                            :func:`inverse_normal_cdf`                         :func:`st_asbinary`                                    :func:`classification_recall`
-    :func:`array_has_duplicates`                       :func:`inverse_poisson_cdf`                        :func:`st_astext`                                      :func:`classification_thresholds`
-    :func:`array_intersect`                            :func:`inverse_weibull_cdf`                        :func:`st_boundary`                                    :func:`corr`
-    :func:`array_join`                                 :func:`ip_prefix`                                  :func:`st_buffer`                                      :func:`count`
-    :func:`array_max`                                  :func:`ip_prefix_collapse`                         :func:`st_centroid`                                    :func:`count_if`
-    :func:`array_max_by`                               :func:`ip_prefix_subnets`                          :func:`st_contains`                                    :func:`covar_pop`
-    :func:`array_min`                                  :func:`ip_subnet_max`                              :func:`st_convexhull`                                  :func:`covar_samp`
-    :func:`array_min_by`                               :func:`ip_subnet_min`                              :func:`st_coorddim`                                    :func:`entropy`
-    :func:`array_normalize`                            :func:`ip_subnet_range`                            :func:`st_crosses`                                     :func:`every`
-    :func:`array_position`                             :func:`is_finite`                                  :func:`st_difference`                                  :func:`geometric_mean`
-    :func:`array_remove`                               :func:`is_infinite`                                :func:`st_dimension`                                   :func:`histogram`
-    :func:`array_sort`                                 :func:`is_json_scalar`                             :func:`st_disjoint`                                    :func:`kurtosis`
-    :func:`array_sort_desc`                            :func:`is_nan`                                     :func:`st_distance`                                    :func:`map_agg`
-    :func:`array_sum`                                  :func:`is_null`                                    :func:`st_endpoint`                                    :func:`map_union`
-    :func:`array_sum_propagate_element_null`           :func:`is_private_ip`                              :func:`st_envelope`                                    :func:`map_union_sum`
-    :func:`array_top_n`                                :func:`is_subnet_of`                               :func:`st_envelopeaspts`                               :func:`max`
-    :func:`array_union`                                :func:`json_array_contains`                        :func:`st_equals`                                      :func:`max_by`
-    :func:`arrays_overlap`                             :func:`json_array_get`                             :func:`st_exteriorring`                                :func:`max_data_size_for_stats`
-    :func:`asin`                                       :func:`json_array_length`                          :func:`st_geometries`                                  :func:`merge`
-    :func:`at_timezone`                                :func:`json_extract`                               :func:`st_geometryfromtext`                            :func:`min`
-    :func:`atan`                                       :func:`json_extract_scalar`                        :func:`st_geometryn`                                   :func:`min_by`
-    :func:`atan2`                                      :func:`json_format`                                :func:`st_geometrytype`                                :func:`multimap_agg`
-    :func:`beta_cdf`                                   :func:`json_parse`                                 :func:`st_geomfrombinary`                              :func:`noisy_approx_distinct_sfm`
-    :func:`between`                                    :func:`json_size`                                  :func:`st_interiorringn`                               :func:`noisy_approx_set_sfm`
-    :func:`bing_tile`                                  :func:`laplace_cdf`                                :func:`st_interiorrings`                               :func:`noisy_approx_set_sfm_from_index_and_zeros`
-    :func:`bing_tile_at`                               :func:`last_day_of_month`                          :func:`st_intersection`                                :func:`noisy_avg_gaussian`
-    :func:`bing_tile_children`                         :func:`least`                                      :func:`st_intersects`                                  :func:`noisy_count_gaussian`
-    :func:`bing_tile_coordinates`                      :func:`length`                                     :func:`st_isclosed`                                    :func:`noisy_count_if_gaussian`
-    :func:`bing_tile_parent`                           :func:`levenshtein_distance`                       :func:`st_isempty`                                     :func:`noisy_sum_gaussian`
-    :func:`bing_tile_quadkey`                          :func:`like`                                       :func:`st_isring`                                      :func:`numeric_histogram`
-    :func:`bing_tile_zoom_level`                       :func:`line_interpolate_point`                     :func:`st_issimple`                                    :func:`qdigest_agg`
-    :func:`bing_tiles_around`                          :func:`line_locate_point`                          :func:`st_isvalid`                                     :func:`reduce_agg`
-    :func:`binomial_cdf`                               :func:`ln`                                         :func:`st_length`                                      :func:`regr_avgx`
-    :func:`bit_count`                                  :func:`log10`                                      :func:`st_numgeometries`                               :func:`regr_avgy`
-    :func:`bitwise_and`                                :func:`log2`                                       :func:`st_numinteriorring`                             :func:`regr_count`
-    :func:`bitwise_arithmetic_shift_right`             :func:`lower`                                      :func:`st_numpoints`                                   :func:`regr_intercept`
-    :func:`bitwise_left_shift`                         :func:`lpad`                                       :func:`st_overlaps`                                    :func:`regr_r2`
-    :func:`bitwise_logical_shift_right`                :func:`lt`                                         :func:`st_point`                                       :func:`regr_slope`
-    :func:`bitwise_not`                                :func:`lte`                                        :func:`st_pointn`                                      :func:`regr_sxx`
-    :func:`bitwise_or`                                 :func:`ltrim`                                      :func:`st_points`                                      :func:`regr_sxy`
-    :func:`bitwise_right_shift`                        :func:`map`                                        :func:`st_polygon`                                     :func:`regr_syy`
-    :func:`bitwise_right_shift_arithmetic`             :func:`map_concat`                                 :func:`st_relate`                                      :func:`set_agg`
-    :func:`bitwise_shift_left`                         :func:`map_entries`                                :func:`st_startpoint`                                  :func:`set_union`
-    :func:`bitwise_xor`                                :func:`map_filter`                                 :func:`st_symdifference`                               :func:`skewness`
-    :func:`cardinality`                                :func:`map_from_entries`                           :func:`st_touches`                                     :func:`stddev`
-    :func:`cauchy_cdf`                                 :func:`map_key_exists`                             :func:`st_union`                                       :func:`stddev_pop`
-    :func:`cbrt`                                       :func:`map_keys`                                   :func:`st_within`                                      :func:`stddev_samp`
-    :func:`ceil`                                       :func:`map_keys_by_top_n_values`                   :func:`st_x`                                           :func:`sum`
-    :func:`ceiling`                                    :func:`map_normalize`                              :func:`st_xmax`                                        :func:`sum_data_size_for_stats`
-    :func:`chi_squared_cdf`                            :func:`map_remove_null_values`                     :func:`st_xmin`                                        :func:`tdigest_agg`
-    :func:`chr`                                        :func:`map_subset`                                 :func:`st_y`                                           :func:`var_pop`
-    :func:`clamp`                                      :func:`map_top_n`                                  :func:`st_ymax`                                        :func:`var_samp`
-    :func:`codepoint`                                  :func:`map_top_n_keys`                             :func:`st_ymin`                                        :func:`variance`
-    :func:`combinations`                               :func:`map_top_n_values`                           :func:`starts_with`
-    :func:`combine_hash_internal`                      :func:`map_values`                                 :func:`strpos`
-    :func:`concat`                                     :func:`map_zip_with`                               :func:`strrpos`
-    :func:`construct_tdigest`                          :func:`md5`                                        :func:`subscript`
-    :func:`contains`                                   :func:`merge_sfm`                                  :func:`substr`
-    :func:`cos`                                        :func:`merge_tdigest`                              :func:`substring`
-    :func:`cosh`                                       :func:`millisecond`                                :func:`tan`
-    :func:`cosine_similarity`                          :func:`minus`                                      :func:`tanh`
-    :func:`crc32`                                      :func:`minute`                                     :func:`timezone_hour`
-    :func:`current_date`                               :func:`mod`                                        :func:`timezone_minute`
-    :func:`date`                                       :func:`month`                                      :func:`to_base`
-    :func:`date_add`                                   :func:`multimap_from_entries`                      :func:`to_base64`
-    :func:`date_diff`                                  :func:`multiply`                                   :func:`to_base64url`
-    :func:`date_format`                                :func:`murmur3_x64_128`                            :func:`to_big_endian_32`
-    :func:`date_parse`                                 :func:`nan`                                        :func:`to_big_endian_64`
-    :func:`date_trunc`                                 :func:`negate`                                     :func:`to_hex`
-    :func:`day`                                        :func:`neq`                                        :func:`to_ieee754_32`
-    :func:`day_of_month`                               :func:`ngrams`                                     :func:`to_ieee754_64`
-    :func:`day_of_week`                                :func:`no_keys_match`                              :func:`to_iso8601`
-    :func:`day_of_year`                                :func:`no_values_match`                            :func:`to_milliseconds`
-    :func:`degrees`                                    :func:`noisy_empty_approx_set_sfm`                 :func:`to_unixtime`
-    :func:`destructure_tdigest`                        :func:`none_match`                                 :func:`to_utf8`
-    :func:`distinct_from`                              :func:`normal_cdf`                                 :func:`trail`
-    :func:`divide`                                     :func:`normalize`                                  :func:`transform`
-    :func:`dot_product`                                not                                                :func:`transform_keys`
-    :func:`dow`                                        :func:`parse_datetime`                             :func:`transform_values`
-    :func:`doy`                                        :func:`parse_duration`                             :func:`trim`
-    :func:`e`                                          :func:`parse_presto_data_size`                     :func:`trim_array`
-    :func:`element_at`                                 :func:`pi`                                         :func:`trimmed_mean`
-    :func:`empty_approx_set`                           :func:`plus`                                       :func:`truncate`
-    :func:`ends_with`                                  :func:`poisson_cdf`                                :func:`typeof`
-    :func:`eq`                                         :func:`pow`                                        :func:`upper`
-    :func:`exp`                                        :func:`power`                                      :func:`url_decode`
-    :func:`f_cdf`                                      :func:`quantile_at_value`                          :func:`url_encode`
-    :func:`fail`                                       :func:`quantiles_at_values`                        :func:`url_extract_fragment`
-    :func:`filter`                                     :func:`quarter`                                    :func:`url_extract_host`
-    :func:`find_first`                                 :func:`radians`                                    :func:`url_extract_parameter`
-    :func:`find_first_index`                           :func:`rand`                                       :func:`url_extract_path`
-    :func:`flatten`                                    :func:`random`                                     :func:`url_extract_port`
-    :func:`flatten_geometry_collections`               :func:`reduce`                                     :func:`url_extract_protocol`
-    :func:`floor`                                      :func:`regexp_extract`                             :func:`url_extract_query`
-    :func:`format_datetime`                            :func:`regexp_extract_all`                         :func:`uuid`
-    :func:`from_base`                                  :func:`regexp_like`                                :func:`value_at_quantile`
-    :func:`from_base64`                                :func:`regexp_replace`                             :func:`values_at_quantiles`
-    :func:`from_base64url`                             :func:`regexp_split`                               :func:`week`
-    :func:`from_big_endian_32`                         :func:`remove_nulls`                               :func:`week_of_year`
-    :func:`from_big_endian_64`                         :func:`repeat`                                     :func:`weibull_cdf`
-    :func:`from_hex`                                   :func:`replace`                                    :func:`width_bucket`
-    :func:`from_ieee754_32`                            :func:`replace_first`                              :func:`wilson_interval_lower`
-    :func:`from_ieee754_64`                            :func:`reverse`                                    :func:`wilson_interval_upper`
-    :func:`from_iso8601_date`                          :func:`round`                                      :func:`word_stem`
-    :func:`from_iso8601_timestamp`                     :func:`rpad`                                       :func:`xxhash64`
-    :func:`from_unixtime`                              :func:`rtrim`                                      :func:`xxhash64_internal`
-    :func:`from_utf8`                                  :func:`scale_qdigest`                              :func:`year`
-    :func:`gamma_cdf`                                  :func:`scale_tdigest`                              :func:`year_of_week`
-    :func:`geometry_invalid_reason`                    :func:`second`                                     :func:`yow`
-    :func:`geometry_nearest_points`                    :func:`secure_rand`                                :func:`zip`
-    :func:`greatest`                                   :func:`secure_random`                              :func:`zip_with`
+    :func:`$internal$json_string_to_array_cast`        :func:`geometry_to_dissolved_bing_tiles`           :func:`secure_rand`                                    :func:`any_value`                                      :func:`cume_dist`
+    :func:`$internal$json_string_to_map_cast`          :func:`geometry_union`                             :func:`secure_random`                                  :func:`approx_distinct`                                :func:`dense_rank`
+    :func:`$internal$json_string_to_row_cast`          :func:`great_circle_distance`                      :func:`sequence`                                       :func:`approx_most_frequent`                           :func:`first_value`
+    :func:`$internal$split_to_map`                     :func:`greatest`                                   :func:`sha1`                                           :func:`approx_percentile`                              :func:`lag`
+    :func:`abs`                                        :func:`gt`                                         :func:`sha256`                                         :func:`approx_set`                                     :func:`last_value`
+    :func:`acos`                                       :func:`gte`                                        :func:`sha512`                                         :func:`arbitrary`                                      :func:`lead`
+    :func:`all_keys_match`                             :func:`hamming_distance`                           :func:`shuffle`                                        :func:`array_agg`                                      :func:`nth_value`
+    :func:`all_match`                                  :func:`hmac_md5`                                   :func:`sign`                                           :func:`avg`                                            :func:`ntile`
+    :func:`any_keys_match`                             :func:`hmac_sha1`                                  :func:`simplify_geometry`                              :func:`bitwise_and_agg`                                :func:`percent_rank`
+    :func:`any_match`                                  :func:`hmac_sha256`                                :func:`sin`                                            :func:`bitwise_or_agg`                                 :func:`rank`
+    :func:`any_values_match`                           :func:`hmac_sha512`                                :func:`slice`                                          :func:`bitwise_xor_agg`                                :func:`row_number`
+    :func:`array_average`                              :func:`hour`                                       :func:`split`                                          :func:`bool_and`
+    :func:`array_constructor`                          in                                                 :func:`split_part`                                     :func:`bool_or`
+    :func:`array_cum_sum`                              :func:`infinity`                                   :func:`split_to_map`                                   :func:`checksum`
+    :func:`array_distinct`                             :func:`inverse_beta_cdf`                           :func:`split_to_multimap`                              :func:`classification_fall_out`
+    :func:`array_duplicates`                           :func:`inverse_binomial_cdf`                       :func:`spooky_hash_v2_32`                              :func:`classification_miss_rate`
+    :func:`array_except`                               :func:`inverse_cauchy_cdf`                         :func:`spooky_hash_v2_64`                              :func:`classification_precision`
+    :func:`array_frequency`                            :func:`inverse_chi_squared_cdf`                    :func:`sqrt`                                           :func:`classification_recall`
+    :func:`array_has_duplicates`                       :func:`inverse_f_cdf`                              :func:`st_area`                                        :func:`classification_thresholds`
+    :func:`array_intersect`                            :func:`inverse_gamma_cdf`                          :func:`st_asbinary`                                    :func:`corr`
+    :func:`array_join`                                 :func:`inverse_laplace_cdf`                        :func:`st_astext`                                      :func:`count`
+    :func:`array_max`                                  :func:`inverse_normal_cdf`                         :func:`st_boundary`                                    :func:`count_if`
+    :func:`array_max_by`                               :func:`inverse_poisson_cdf`                        :func:`st_buffer`                                      :func:`covar_pop`
+    :func:`array_min`                                  :func:`inverse_t_cdf`                              :func:`st_centroid`                                    :func:`covar_samp`
+    :func:`array_min_by`                               :func:`inverse_weibull_cdf`                        :func:`st_contains`                                    :func:`entropy`
+    :func:`array_normalize`                            :func:`ip_prefix`                                  :func:`st_convexhull`                                  :func:`every`
+    :func:`array_position`                             :func:`ip_prefix_collapse`                         :func:`st_coorddim`                                    :func:`geometric_mean`
+    :func:`array_remove`                               :func:`ip_prefix_subnets`                          :func:`st_crosses`                                     :func:`histogram`
+    :func:`array_sort`                                 :func:`ip_subnet_max`                              :func:`st_difference`                                  :func:`kurtosis`
+    :func:`array_sort_desc`                            :func:`ip_subnet_min`                              :func:`st_dimension`                                   :func:`map_agg`
+    :func:`array_subset`                               :func:`ip_subnet_range`                            :func:`st_disjoint`                                    :func:`map_union`
+    :func:`array_sum`                                  :func:`is_finite`                                  :func:`st_distance`                                    :func:`map_union_sum`
+    :func:`array_sum_propagate_element_null`           :func:`is_infinite`                                :func:`st_endpoint`                                    :func:`max`
+    :func:`array_top_n`                                :func:`is_json_scalar`                             :func:`st_envelope`                                    :func:`max_by`
+    :func:`array_union`                                :func:`is_nan`                                     :func:`st_envelopeaspts`                               :func:`max_data_size_for_stats`
+    :func:`arrays_overlap`                             :func:`is_null`                                    :func:`st_equals`                                      :func:`merge`
+    :func:`asin`                                       :func:`is_private_ip`                              :func:`st_exteriorring`                                :func:`min`
+    :func:`at_timezone`                                :func:`is_subnet_of`                               :func:`st_geometries`                                  :func:`min_by`
+    :func:`atan`                                       :func:`json_array_contains`                        :func:`st_geometryfromtext`                            :func:`multimap_agg`
+    :func:`atan2`                                      :func:`json_array_get`                             :func:`st_geometryn`                                   :func:`noisy_approx_distinct_sfm`
+    :func:`beta_cdf`                                   :func:`json_array_length`                          :func:`st_geometrytype`                                :func:`noisy_approx_set_sfm`
+    :func:`between`                                    :func:`json_extract`                               :func:`st_geomfrombinary`                              :func:`noisy_approx_set_sfm_from_index_and_zeros`
+    :func:`bing_tile`                                  :func:`json_extract_scalar`                        :func:`st_interiorringn`                               :func:`noisy_avg_gaussian`
+    :func:`bing_tile_at`                               :func:`json_format`                                :func:`st_interiorrings`                               :func:`noisy_count_gaussian`
+    :func:`bing_tile_children`                         :func:`json_parse`                                 :func:`st_intersection`                                :func:`noisy_count_if_gaussian`
+    :func:`bing_tile_coordinates`                      :func:`json_size`                                  :func:`st_intersects`                                  :func:`noisy_sum_gaussian`
+    :func:`bing_tile_parent`                           :func:`laplace_cdf`                                :func:`st_isclosed`                                    :func:`numeric_histogram`
+    :func:`bing_tile_polygon`                          :func:`last_day_of_month`                          :func:`st_isempty`                                     :func:`qdigest_agg`
+    :func:`bing_tile_quadkey`                          :func:`least`                                      :func:`st_isring`                                      :func:`reduce_agg`
+    :func:`bing_tile_zoom_level`                       :func:`length`                                     :func:`st_issimple`                                    :func:`regr_avgx`
+    :func:`bing_tiles_around`                          :func:`levenshtein_distance`                       :func:`st_isvalid`                                     :func:`regr_avgy`
+    :func:`binomial_cdf`                               :func:`like`                                       :func:`st_length`                                      :func:`regr_count`
+    :func:`bit_count`                                  :func:`line_interpolate_point`                     :func:`st_linefromtext`                                :func:`regr_intercept`
+    :func:`bit_length`                                 :func:`line_locate_point`                          :func:`st_linestring`                                  :func:`regr_r2`
+    :func:`bitwise_and`                                :func:`ln`                                         :func:`st_multipoint`                                  :func:`regr_slope`
+    :func:`bitwise_arithmetic_shift_right`             :func:`localtime`                                  :func:`st_numgeometries`                               :func:`regr_sxx`
+    :func:`bitwise_left_shift`                         :func:`log10`                                      :func:`st_numinteriorring`                             :func:`regr_sxy`
+    :func:`bitwise_logical_shift_right`                :func:`log2`                                       :func:`st_numpoints`                                   :func:`regr_syy`
+    :func:`bitwise_not`                                :func:`longest_common_prefix`                      :func:`st_overlaps`                                    :func:`set_agg`
+    :func:`bitwise_or`                                 :func:`lower`                                      :func:`st_point`                                       :func:`set_union`
+    :func:`bitwise_right_shift`                        :func:`lpad`                                       :func:`st_pointn`                                      :func:`skewness`
+    :func:`bitwise_right_shift_arithmetic`             :func:`lt`                                         :func:`st_points`                                      :func:`stddev`
+    :func:`bitwise_shift_left`                         :func:`lte`                                        :func:`st_polygon`                                     :func:`stddev_pop`
+    :func:`bitwise_xor`                                :func:`ltrim`                                      :func:`st_relate`                                      :func:`stddev_samp`
+    :func:`cardinality`                                :func:`map`                                        :func:`st_startpoint`                                  :func:`sum`
+    :func:`cauchy_cdf`                                 :func:`map_concat`                                 :func:`st_symdifference`                               :func:`sum_data_size_for_stats`
+    :func:`cbrt`                                       :func:`map_entries`                                :func:`st_touches`                                     :func:`tdigest_agg`
+    :func:`ceil`                                       :func:`map_filter`                                 :func:`st_union`                                       :func:`var_pop`
+    :func:`ceiling`                                    :func:`map_from_entries`                           :func:`st_within`                                      :func:`var_samp`
+    :func:`chi_squared_cdf`                            :func:`map_intersect`                              :func:`st_x`                                           :func:`variance`
+    :func:`chr`                                        :func:`map_key_exists`                             :func:`st_xmax`
+    :func:`clamp`                                      :func:`map_keys`                                   :func:`st_xmin`
+    :func:`codepoint`                                  :func:`map_keys_by_top_n_values`                   :func:`st_y`
+    :func:`combinations`                               :func:`map_normalize`                              :func:`st_ymax`
+    :func:`combine_hash_internal`                      :func:`map_remove_null_values`                     :func:`st_ymin`
+    :func:`concat`                                     :func:`map_subset`                                 :func:`starts_with`
+    :func:`construct_tdigest`                          :func:`map_top_n`                                  :func:`strpos`
+    :func:`contains`                                   :func:`map_top_n_keys`                             :func:`strrpos`
+    :func:`cos`                                        :func:`map_top_n_values`                           :func:`subscript`
+    :func:`cosh`                                       :func:`map_values`                                 :func:`substr`
+    :func:`cosine_similarity`                          :func:`map_zip_with`                               :func:`substring`
+    :func:`crc32`                                      :func:`md5`                                        :func:`t_cdf`
+    :func:`current_date`                               :func:`merge_hll`                                  :func:`tan`
+    :func:`date`                                       :func:`merge_sfm`                                  :func:`tanh`
+    :func:`date_add`                                   :func:`merge_tdigest`                              :func:`timezone_hour`
+    :func:`date_diff`                                  :func:`millisecond`                                :func:`timezone_minute`
+    :func:`date_format`                                :func:`minus`                                      :func:`to_base`
+    :func:`date_parse`                                 :func:`minute`                                     :func:`to_base64`
+    :func:`date_trunc`                                 :func:`mod`                                        :func:`to_base64url`
+    :func:`day`                                        :func:`month`                                      :func:`to_big_endian_32`
+    :func:`day_of_month`                               :func:`multimap_from_entries`                      :func:`to_big_endian_64`
+    :func:`day_of_week`                                :func:`multiply`                                   :func:`to_hex`
+    :func:`day_of_year`                                :func:`murmur3_x64_128`                            :func:`to_ieee754_32`
+    :func:`degrees`                                    :func:`nan`                                        :func:`to_ieee754_64`
+    :func:`destructure_tdigest`                        :func:`negate`                                     :func:`to_iso8601`
+    :func:`distinct_from`                              :func:`neq`                                        :func:`to_milliseconds`
+    :func:`divide`                                     :func:`ngrams`                                     :func:`to_unixtime`
+    :func:`dot_product`                                :func:`no_keys_match`                              :func:`to_utf8`
+    :func:`dow`                                        :func:`no_values_match`                            :func:`trail`
+    :func:`doy`                                        :func:`noisy_empty_approx_set_sfm`                 :func:`transform`
+    :func:`e`                                          :func:`none_match`                                 :func:`transform_keys`
+    :func:`element_at`                                 :func:`normal_cdf`                                 :func:`transform_values`
+    :func:`empty_approx_set`                           :func:`normalize`                                  :func:`trim`
+    :func:`ends_with`                                  not                                                :func:`trim_array`
+    :func:`enum_key`                                   :func:`parse_datetime`                             :func:`trimmed_mean`
+    :func:`eq`                                         :func:`parse_duration`                             :func:`truncate`
+    :func:`exp`                                        :func:`parse_presto_data_size`                     :func:`typeof`
+    :func:`expand_envelope`                            :func:`pi`                                         :func:`upper`
+    :func:`f_cdf`                                      :func:`plus`                                       :func:`url_decode`
+    :func:`fail`                                       :func:`poisson_cdf`                                :func:`url_encode`
+    :func:`filter`                                     :func:`pow`                                        :func:`url_extract_fragment`
+    :func:`find_first`                                 :func:`power`                                      :func:`url_extract_host`
+    :func:`find_first_index`                           :func:`quantile_at_value`                          :func:`url_extract_parameter`
+    :func:`flatten`                                    :func:`quantiles_at_values`                        :func:`url_extract_path`
+    :func:`flatten_geometry_collections`               :func:`quarter`                                    :func:`url_extract_port`
+    :func:`floor`                                      :func:`radians`                                    :func:`url_extract_protocol`
+    :func:`format_datetime`                            :func:`rand`                                       :func:`url_extract_query`
+    :func:`from_base`                                  :func:`random`                                     :func:`uuid`
+    :func:`from_base32`                                :func:`reduce`                                     :func:`value_at_quantile`
+    :func:`from_base64`                                :func:`regexp_extract`                             :func:`values_at_quantiles`
+    :func:`from_base64url`                             :func:`regexp_extract_all`                         :func:`week`
+    :func:`from_big_endian_32`                         :func:`regexp_like`                                :func:`week_of_year`
+    :func:`from_big_endian_64`                         :func:`regexp_replace`                             :func:`weibull_cdf`
+    :func:`from_hex`                                   :func:`regexp_split`                               :func:`width_bucket`
+    :func:`from_ieee754_32`                            :func:`remap_keys`                                 :func:`wilson_interval_lower`
+    :func:`from_ieee754_64`                            :func:`remove_nulls`                               :func:`wilson_interval_upper`
+    :func:`from_iso8601_date`                          :func:`repeat`                                     :func:`word_stem`
+    :func:`from_iso8601_timestamp`                     :func:`replace`                                    :func:`xxhash64`
+    :func:`from_unixtime`                              :func:`replace_first`                              :func:`xxhash64_internal`
+    :func:`from_utf8`                                  :func:`reverse`                                    :func:`year`
+    :func:`gamma_cdf`                                  :func:`round`                                      :func:`year_of_week`
+    :func:`geometry_as_geojson`                        :func:`rpad`                                       :func:`yow`
+    :func:`geometry_from_geojson`                      :func:`rtrim`                                      :func:`zip`
+    :func:`geometry_invalid_reason`                    :func:`scale_qdigest`                              :func:`zip_with`
+    :func:`geometry_nearest_points`                    :func:`scale_tdigest`
+    :func:`geometry_to_bing_tiles`                     :func:`second`
     =================================================  =================================================  =================================================  ==  =================================================  ==  =================================================
diff --git a/velox/docs/functions/delta/functions.rst b/velox/docs/functions/delta/functions.rst
new file mode 100644
index 00000000000..e1b3de5673f
--- /dev/null
+++ b/velox/docs/functions/delta/functions.rst
@@ -0,0 +1,13 @@
+********************
+Delta Lake Functions
+********************
+
+Here is a list of all scalar Delta Lake functions available in Velox.
+Function names link to function description.
+
+These functions are used in deletion vector read.
+Refer to `Delta Lake documentation <https://docs.delta.io/delta-deletion-vectors/#_top>`_ and `Delta Lake deletion vector blog <https://delta.io/blog/2023-07-05-deletion-vectors/>`_ for details.
+
+.. delta:function:: bitmap_array_contains(bitmap_array: varbinary, input: bigint) -> bool
+
+    Not implemented.
diff --git a/velox/docs/functions/iceberg/functions.rst b/velox/docs/functions/iceberg/functions.rst
index 768f79b43a5..a878f8c40ea 100644
--- a/velox/docs/functions/iceberg/functions.rst
+++ b/velox/docs/functions/iceberg/functions.rst
@@ -22,3 +22,58 @@ Refer to `Iceberg documenation <https://iceberg.apache.org/spec/#partition-trans
    Supported types for ``input`` are INTEGER, BIGINT, DECIMAL, DATE, TIMESTAMP, VARCHAR, VARBINARY. ::
        SELECT bucket(128, 'abcd'); -- 4
        SELECT bucket(100, 34L); -- 79
+
+.. iceberg:function:: days(input) -> date
+
+   Returns the date. ::
+
+       SELECT days(DATE '2017-12-01'); -- 2017-12-01
+       SELECT days(TIMESTAMP '2017-12-01 10:12:55.038194'); -- 2017-12-01
+       SELECT days(DATE '1969-12-31'); -- 1969-12-31
+
+.. iceberg:function:: hours(input) -> integer
+
+   Returns the number of hours since epoch (1970-01-01 00:00:00). Returns 0 for '1970-01-01 00:00:00' timestamps.
+   Returns negative value for timestamps before '1970-01-01 00:00:00'. ::
+
+       SELECT hours(TIMESTAMP '2017-12-01 10:12:55.038194'); -- 420034
+       SELECT hours(TIMESTAMP '1969-12-31 23:59:58.999999'); -- -1
+
+.. iceberg:function:: months(input) -> integer
+
+   Returns the number of months since epoch (1970-01-01). Returns 0 for '1970-01-01' date and timestamps.
+   Returns negative value for dates and timestamps before '1970-01-01'.  ::
+
+       SELECT months(DATE '2017-12-01'); -- 575
+       SELECT months(TIMESTAMP '2017-12-01 10:12:55.038194'); -- 575
+       SELECT months(DATE '1960-01-01'); -- -120
+
+.. iceberg:function:: truncate(width, input) -> same type as input
+
+   Returns the truncated value of the input based on the specified width.
+   For numeric values, truncate to the nearest lower multiple of ``width``, the truncate function is: input - (((input % width) + width) % width).
+   The ``width`` is used to truncate decimal values is applied using unscaled value to avoid additional (and potentially conflicting) parameters.
+   For string values, it truncates a valid UTF-8 string with no more than ``width`` code points.
+   In contrast to strings, binary values do not have an assumed encoding and are truncated to ``width`` bytes.
+
+   Argument ``width`` must be a positive integer.
+   Supported types for ``input`` are: SHORTINT, TYNYINT, SMALLINT, INTEGER, BIGINT, DECIMAL, VARCHAR, VARBINARY. ::
+
+       SELECT truncate(10, 11); -- 10
+       SELECT truncate(10, -11); -- -20
+       SELECT truncate(7, 22); -- 21
+       SELECT truncate(0, 11); -- error: Reason: (0 vs. 0) Invalid truncate width\nExpression: width <= 0
+       SELECT truncate(-3, 11); -- error: Reason: (-3 vs. 0) Invalid truncate width\nExpression: width <= 0
+       SELECT truncate(4, 'iceberg'); -- 'iceb'
+       SELECT truncate(1, '测试'); -- 测
+       SELECT truncate(6, '测试'); -- 测试
+       SELECT truncate(6, cast('测试' as binary)); -- 测试_
+
+.. iceberg:function:: years(input) -> integer
+
+   Returns the number of years since epoch (1970-01-01). Returns 0 for '1970-01-01' date and timestamps.
+   Returns negative value for dates and timestamps before '1970-01-01'.  ::
+
+       SELECT years(DATE '2017-12-01'); -- 47
+       SELECT years(TIMESTAMP '2017-12-01 10:12:55.038194'); -- 47
+       SELECT years(DATE '1960-01-01'); -- -10
diff --git a/velox/docs/functions/presto/aggregate.rst b/velox/docs/functions/presto/aggregate.rst
index 8212675c328..97b6d91b646 100644
--- a/velox/docs/functions/presto/aggregate.rst
+++ b/velox/docs/functions/presto/aggregate.rst
@@ -17,14 +17,14 @@ depending on the order of input values.
 General Aggregate Functions
 ---------------------------
 
-.. function:: arbitrary(x) -> [same as x]
-
-    Returns an arbitrary non-null value of ``x``, if one exists.
-
 .. function:: any_value(x) -> [same as x]
 
     This is an alias for :func:`arbitrary`.
 
+.. function:: arbitrary(x) -> [same as x]
+
+    Returns an arbitrary non-null value of ``x``, if one exists.
+
 .. function:: array_agg(x) -> array<[same as x]>
 
     Returns an array created from the input ``x`` elements. Ignores null
@@ -89,37 +89,17 @@ General Aggregate Functions
 
     This is an alias for :func:`bool_and`.
 
-.. function:: histogram(x)
-
-    Returns a map containing the count of the number of times
-    each input value occurs. Supports integral, floating-point,
-    boolean, timestamp, and date input types.
-
 .. function:: geometric_mean(bigint) -> double
               geometric_mean(double) -> double
               geometric_mean(real) -> real
 
     Returns the `geometric mean <https://en.wikipedia.org/wiki/Geometric_mean>`_ of all input values.
 
-.. function:: max_by(x, y) -> [same as x]
-
-    Returns the value of ``x`` associated with the maximum value of ``y`` over all input values.
-    ``y`` must be an orderable type.
-
-.. function:: max_by(x, y, n) -> array([same as x])
-    :noindex:
-
-    Returns n values of ``x`` associated with the n largest values of ``y`` in descending order of ``y``.
-
-.. function:: min_by(x, y) -> [same as x]
-
-    Returns the value of ``x`` associated with the minimum value of ``y`` over all input values.
-    ``y`` must be an orderable type.
-
-.. function:: min_by(x, y, n) -> array([same as x])
-    :noindex:
+.. function:: histogram(x)
 
-    Returns n values of ``x`` associated with the n smallest values of ``y`` in ascending order of ``y``.
+    Returns a map containing the count of the number of times
+    each input value occurs. Supports integral, floating-point,
+    boolean, timestamp, and date input types.
 
 .. function:: max(x) -> [same as x]
 
@@ -138,6 +118,16 @@ General Aggregate Functions
     Nulls are not included in the output array.
     For REAL and DOUBLE types, NaN is considered greater than Infinity.
 
+.. function:: max_by(x, y) -> [same as x]
+
+    Returns the value of ``x`` associated with the maximum value of ``y`` over all input values.
+    ``y`` must be an orderable type.
+
+.. function:: max_by(x, y, n) -> array([same as x])
+    :noindex:
+
+    Returns n values of ``x`` associated with the n largest values of ``y`` in descending order of ``y``.
+
 .. function:: min(x) -> [same as x]
 
     Returns the minimum value of all input values.
@@ -155,6 +145,16 @@ General Aggregate Functions
     Nulls are not included in output array.
     For REAL and DOUBLE types, NaN is considered greater than Infinity.
 
+.. function:: min_by(x, y) -> [same as x]
+
+    Returns the value of ``x`` associated with the minimum value of ``y`` over all input values.
+    ``y`` must be an orderable type.
+
+.. function:: min_by(x, y, n) -> array([same as x])
+    :noindex:
+
+    Returns n values of ``x`` associated with the n smallest values of ``y`` in ascending order of ``y``.
+
 .. function:: multimap_agg(K key, V value) -> map(K,array(V))
 
     Returns a multimap created from the input ``key`` / ``value`` pairs.
@@ -307,6 +307,33 @@ Map Aggregate Functions
     Returns the union of all the input maps summing the values of matching keys in all
     the maps. All null values in the original maps are coalesced to 0.
 
+Array Aggregate Functions
+-------------------------
+
+.. function:: vector_sum(array(T)) -> array(T)
+
+    Returns the element-wise sum of all input arrays. Equivalent to
+    ``ARRAY[SUM(a[1]), SUM(a[2]), ...]``, with the same null-handling
+    semantics as :func:`sum`: null elements are skipped, and positions
+    where all input values are null produce null in the output.
+    All input arrays must have the same length; an error is raised if
+    arrays of different lengths are encountered.
+    Supported types for T are: TINYINT, SMALLINT, INTEGER, BIGINT, REAL
+    and DOUBLE.
+    For integer types, arithmetic overflow results in an error,
+    consistent with the behavior of :func:`sum`. For floating-point
+    types (REAL, DOUBLE), NaN values propagate through the sum and
+    overflow produces Infinity, following standard IEEE 754 semantics.
+
+    This is useful when rows contain fixed-dimension vectors (e.g.
+    embedding vectors or feature arrays) and you need to compute a
+    component-wise sum across all rows::
+
+        SELECT vector_sum(embedding) FROM item_embeddings;
+
+        -- With 3 rows: [1, 2, 3], [10, 20, 30], [100, 200, 300]
+        -- Returns:     [111, 222, 333]
+
 Approximate Aggregate Functions
 -------------------------------
 
@@ -420,6 +447,40 @@ __ https://www.cse.ust.hk/~raywong/comp5331/References/EfficientComputationOfFre
     As ``approx_percentile(x, w, percentages)``, but with a maximum rank error
     of ``accuracy``.
 
+.. function:: numeric_histogram(buckets, value, weight) -> map<double, double>
+
+    Computes an approximate histogram with up to ``buckets`` number of buckets
+    for all ``value``\ s with a per-item weight of ``weight``.  The keys of the
+    returned map are roughly the center of the bin, and the entry is the total
+    weight of the bin.  The algorithm is based loosely on [BenHaimTomTov2010]_.
+
+    ``buckets`` must be a ``bigint``. ``value`` and ``weight`` must be numeric.
+    ::
+
+        SELECT numeric_histogram(3, v, 1.0)
+        FROM (
+         VALUES (10),
+                (15),
+                (20),
+                (25),
+                (30)
+        ) AS t(v);
+        --{30.0->1.0, 22.5->2.0, 12.5->2.0}
+
+.. function:: numeric_histogram(buckets, value) -> map<double, double>
+
+    Computes an approximate histogram with up to ``buckets`` number of buckets
+    for all ``value``\ s. This function is equivalent to the variant of
+    :func:`!numeric_histogram` that takes a ``weight``, with a per-item weight of ``1``.
+    In this case, the total weight in the returned map is the count of items in the bin.
+    ::
+
+        SELECT numeric_histogram(3, v)
+        FROM (
+        VALUES (10.0), (15.0), (20.0), (25.0), (30.0)
+        ) AS t(v);
+        --{30.0->1.0, 22.5->2.0, 12.5->2.0}
+
 Classification Metrics Aggregate Functions
 ------------------------------------------
 
@@ -703,10 +764,6 @@ Statistical Aggregate Functions
 
     Returns the sample standard deviation of all input values.
 
-.. function:: variance(x) -> double
-
-    This is an alias for :func:`var_samp`.
-
 .. function:: var_pop(x) -> double
 
     Returns the population variance of all input values.
@@ -715,6 +772,10 @@ Statistical Aggregate Functions
 
     Returns the sample variance of all input values.
 
+.. function:: variance(x) -> double
+
+    This is an alias for :func:`var_samp`.
+
 Noisy Aggregate Functions
 -------------------------
 
diff --git a/velox/docs/functions/presto/array.rst b/velox/docs/functions/presto/array.rst
index ffa394f6e4c..db3230cdd7a 100644
--- a/velox/docs/functions/presto/array.rst
+++ b/velox/docs/functions/presto/array.rst
@@ -7,7 +7,7 @@ Array Functions
     Returns whether all elements of an array match the given predicate.
 
         Returns true if all the elements match the predicate (a special case is when the array is empty);
-        Returns false if one or more elements don’t match;
+        Returns false if one or more elements don't match;
         Returns NULL if the predicate function returns NULL for one or more elements and true for all other elements.
         Throws an exception if the predicate fails for one or more elements and returns true or NULL for the rest.
 
@@ -20,20 +20,12 @@ Array Functions
         Returns NULL if the predicate function returns NULL for one or more elements and false for all other elements.
         Throws an exception if the predicate fails for one or more elements and returns false or NULL for the rest.
 
-.. function:: none_match(array(T), function(T, boolean)) → boolean
-
-    Returns whether no elements of an array match the given predicate.
-
-        Returns true if none of the elements matches the predicate (a special case is when the array is empty);
-        Returns false if one or more elements match;
-        Returns NULL if the predicate function returns NULL for one or more elements and false for all other elements.
-        Throws an exception if the predicate fails for one or more elements and returns false or NULL for the rest.
-
 .. function:: array_average(array(double)) -> double
 
     Returns the average of all non-null elements of the array. If there are no non-null elements, returns null.
 
 .. function:: array_cum_sum(array(T)) -> array(T)
+
     Returns the array whose elements are the cumulative sum of the input array, i.e. result[i] = input[1] + input[2] +
     … + input[i]. If there there is null elements in the array, the cumulative sum at and after the element is null.
     The following types are supported: int8_t, int16_t, int32_t, int64_t, int128_t, float, double, ShortDecimal,
@@ -117,6 +109,13 @@ Array Functions
         SELECT array_max(ARRAY[{-1, -2, -3, nan()]); -- NaN
         SELECT array_max(ARRAY[{infinity(), nan()]); -- NaN
 
+.. function:: array_max_by(array(T), function(T, U)) -> T()
+
+    Applies the provided function to each element, and returns the element that gives the maximum value.
+    ``U`` can be any orderable type. ::
+
+        SELECT array_max_by(ARRAY ['a', 'bbb', 'cc'], x -> LENGTH(x)) -- 'bbb'
+
 .. function:: array_min(array(E)) -> E
 
     Returns the minimum value of input array.
@@ -131,20 +130,16 @@ Array Functions
         SELECT array_min(ARRAY[{-1, -2, -3, nan()]); -- -1
         SELECT array_min(ARRAY[{infinity(), nan()]); -- Infinity
 
-.. function:: array_normalize(array(E), E) -> array(E)
+.. function:: array_min_by(array(T), function(T, U)) -> T
 
-    Normalizes array ``x`` by dividing each element by the p-norm of the array. It is equivalent to ``TRANSFORM(array, v -> v / REDUCE(array, 0, (a, v) -> a + POW(ABS(v), p), a -> POW(a, 1 / p))``, but the reduce part is only executed once. Returns null if the array is null or there are null array elements. If ``p`` is 0, then the input array is returned. Only REAL and DOUBLE types are supported.
+    Applies the provided function to each element, and returns the element that gives the minimum value.
+    ``U`` can be any orderable type. ::
 
-.. function:: arrays_overlap(x, y) -> boolean
+        SELECT array_min_by(ARRAY ['a', 'bbb', 'cc'], x -> LENGTH(x)) -- 'a'
 
-    Tests if arrays ``x`` and ``y`` have any non-null elements in common.
-    Returns null if there are no non-null elements in common but either array contains null.
-    For REAL and DOUBLE, NANs (Not-a-Number) are considered equal.
-
-.. function:: arrays_union(x, y) -> array
+.. function:: array_normalize(array(E), E) -> array(E)
 
-    Returns an array of the elements in the union of x and y, without duplicates.
-    For REAL and DOUBLE, NANs (Not-a-Number) are considered equal.
+    Normalizes array ``x`` by dividing each element by the p-norm of the array. It is equivalent to ``TRANSFORM(array, v -> v / REDUCE(array, 0, (a, v) -> a + POW(ABS(v), p), a -> POW(a, 1 / p))``, but the reduce part is only executed once. Returns null if the array is null or there are null array elements. If ``p`` is 0, then the input array is returned. Only REAL and DOUBLE types are supported.
 
 .. function:: array_position(x, element) -> bigint
 
@@ -209,7 +204,7 @@ Array Functions
         SELECT array_sort(ARRAY [ARRAY [1, 2], ARRAY [1, null]]); -- failed: Ordering nulls is not supported
 
 .. function:: array_sort_desc(array(T), function(T,U)) -> array(T)
-    :noindex:
+      :noindex:
 
     Returns the array sorted by values computed using specified lambda in descending
     order. U must be an orderable type. Null elements will be placed at the end of
@@ -217,13 +212,57 @@ Array Functions
     nested nulls. Throws if deciding the order of elements would require comparing nested
     null values. ::
 
-        SELECT array_sort_desc(ARRAY ['cat', 'leopard', 'mouse'], x -> length(x)); -- ['leopard', 'mouse', 'cat']
+          SELECT array_sort_desc(ARRAY ['cat', 'leopard', 'mouse'], x -> length(x)); -- ['leopard', 'mouse', 'cat']
+
+.. function:: array_split_into_chunks(array(T), sz) -> array(array(T))
+
+    Returns an array of arrays splitting the input array into chunks of given
+    length. The last chunk will be shorter than the chunk length if the array's
+    length is not an integer multiple of the chunk length. Ignores null inputs,
+    but not elements. ::
+
+        SELECT array_split_into_chunks(ARRAY [1, 2, 3, 4, 5], 2); -- [[1, 2], [3, 4], [5]]
+        SELECT array_split_into_chunks(ARRAY [1, 2, 3], 5); -- [[1, 2, 3]]
+        SELECT array_split_into_chunks(ARRAY ['a', 'b', 'c'], 2); -- [['a', 'b'], ['c']]
+
+.. function:: array_subset(array(T), array(int)) -> array(T)
+
+    Returns an array containing elements from the input array at the specified 1-based indices.
+    Indices must be positive integers. Invalid indices (out of bounds, zero, or negative) are ignored.
+    Null elements at valid indices are preserved in the output. Duplicate indices result in duplicate elements in the output.
+    The output maintains the order of the indices array. ::
+
+          SELECT array_subset(ARRAY[1, 2, 3, 4, 5], ARRAY[1, 3, 5]); -- [1, 3, 5]
+          SELECT array_subset(ARRAY['a', 'b', 'c'], ARRAY[3, 1, 2]); -- ['c', 'a', 'b']
+          SELECT array_subset(ARRAY[1, NULL, 3], ARRAY[2]); -- [NULL]
+          SELECT array_subset(ARRAY[1, 2, 3], ARRAY[1, 1, 2]); -- [1, 1, 2]
+          SELECT array_subset(ARRAY[1, 2, 3], ARRAY[5, 0, -1]); -- []
 
 .. function:: array_sum(array(T)) -> bigint/double
 
     Returns the sum of all non-null elements of the array. If there is no non-null elements, returns 0. The behaviour is similar to aggregation function sum().
     T must be coercible to double. Returns bigint if T is coercible to bigint. Otherwise, returns double.
 
+.. function:: array_top_n(array(T), int) -> array(T)
+
+    Returns an array of the top ``n`` elements from a given ``array``, sorted according to its natural descending order.
+    If ``n`` is larger than the size of the given ``array``, the returned list will be the same size as the input instead of ``n``. ::
+
+        SELECT array_top_n(ARRAY [1, 100, 2, 5, 3], 3); -- [100, 5, 3]
+        SELECT array_top_n(ARRAY [1, 100], 5); -- [100, 1]
+        SELECT array_top_n(ARRAY ['a', 'zzz', 'zz', 'b', 'g', 'f'], 3); -- ['zzz', 'zz', 'g']
+
+.. function:: arrays_overlap(x, y) -> boolean
+
+    Tests if arrays ``x`` and ``y`` have any non-null elements in common.
+    Returns null if there are no non-null elements in common but either array contains null.
+    For REAL and DOUBLE, NANs (Not-a-Number) are considered equal.
+
+.. function:: arrays_union(x, y) -> array
+
+    Returns an array of the elements in the union of x and y, without duplicates.
+    For REAL and DOUBLE, NANs (Not-a-Number) are considered equal.
+
 .. function:: cardinality(x) -> bigint
 
     Returns the cardinality (size) of the array ``x``.
@@ -252,6 +291,32 @@ Array Functions
         SELECT contains(ARRAY[ARRAY[2, 3]], ARRAY[2, null]); -- failed: contains does not support arrays with elements that are null or contain null
         SELECT contains(ARRAY[ARRAY[2, null]], ARRAY[2, 1]); -- failed: contains does not support arrays with elements that are null or contain null
 
+.. function:: dot_product(array(T), array(T)) -> bigint/double
+
+    Computes the dot product of two arrays. The dot product is the sum of element-wise
+    products of corresponding elements. Both arrays must have the same length.
+    If either array is null, returns null. If arrays have different lengths, throws an error.
+    Null elements in arrays are treated as zero.
+    Returns bigint for integer arrays, double for floating-point arrays.
+    For empty integer arrays, returns 0. For empty floating-point arrays, returns NaN. ::
+
+          SELECT dot_product(ARRAY[1, 2, 3], ARRAY[4, 5, 6]); -- 32 (1*4 + 2*5 + 3*6)
+          SELECT dot_product(ARRAY[1.0, 2.0], ARRAY[3.0, 4.0]); -- 11.0 (1.0*3.0 + 2.0*4.0)
+          SELECT dot_product(ARRAY[1, NULL, 3], ARRAY[4, 5, 6]); -- 22 (1*4 + 0*5 + 3*6)
+          SELECT dot_product(ARRAY[], ARRAY[]); -- 0 for integer arrays, NaN for floating-point arrays
+          SELECT dot_product(NULL, ARRAY[1, 2, 3]); -- NULL
+
+.. function:: dot_product(map(K, V), map(K, V)) -> bigint/double
+
+    Computes the dot product of two maps. For maps, the dot product is computed by
+    multiplying values with matching keys and summing the results. Keys present in only
+    one map contribute zero to the result. If either map is null, returns null.
+    Null values in maps are treated as zero.
+    Returns bigint for integer value maps, double for floating-point value maps. ::
+
+          SELECT dot_product(MAP(ARRAY[1, 2], ARRAY[10, 20]), MAP(ARRAY[1, 2], ARRAY[3, 4])); -- 110 (10*3 + 20*4)
+          SELECT dot_product(MAP(ARRAY['a', 'b'], ARRAY[1.0, 2.0]), MAP(ARRAY['a', 'c'], ARRAY[3.0, 4.0])); -- 3.0 (only 'a' matches)
+
 .. function:: element_at(array(E), index) -> E
 
     Returns element of ``array`` at given ``index``.
@@ -313,6 +378,31 @@ Array Functions
 
     Flattens an ``array(array(T))`` to an ``array(T)`` by concatenating the contained arrays.
 
+.. function:: l2_norm(array(T)) -> double
+
+    Returns the Euclidean norm (L2 norm) of an array of numeric values.
+    The L2 norm is calculated as the square root of the sum of squares of all elements: sqrt(sum(x^2)).
+    Returns 0.0 for empty arrays. Null elements are skipped in the calculation.
+    Supports integer and floating point types. ::
+
+          SELECT l2_norm(ARRAY[3, 4]); -- 5.0
+          SELECT l2_norm(ARRAY[1, 2, 2]); -- 3.0
+          SELECT l2_norm(ARRAY[3.0, 4.0]); -- 5.0
+          SELECT l2_norm(ARRAY[]); -- 0.0
+          SELECT l2_norm(ARRAY[3, NULL, 4]); -- 5.0
+
+.. function:: l2_norm(map(K, V)) -> double
+
+    Returns the Euclidean norm (L2 norm) of the values in a map.
+    The L2 norm is calculated as the square root of the sum of squares of all values: sqrt(sum(v^2)).
+    Keys are ignored; only values are used in the calculation.
+    Returns 0.0 for empty maps. Null values are skipped in the calculation.
+    Supports maps with numeric value types (integer or floating point). ::
+
+          SELECT l2_norm(MAP(ARRAY['a', 'b'], ARRAY[3, 4])); -- 5.0
+          SELECT l2_norm(MAP(ARRAY[1, 2], ARRAY[3.0, 4.0])); -- 5.0
+          SELECT l2_norm(MAP(ARRAY[], ARRAY[])); -- 0.0
+
 .. function:: ngrams(array(T), n) -> array(array(T))
 
     Returns `n-grams <https://en.wikipedia.org/wiki/N-gram>`_  for the array.
@@ -326,6 +416,15 @@ Array Functions
         SELECT ngrams(ARRAY[1, 2, 3, 4], 2); -- [[1, 2], [2, 3], [3, 4]]
         SELECT ngrams(ARRAY["foo", NULL, "bar"], 2); -- [["foo", NULL], [NULL, "bar"]]
 
+.. function:: none_match(array(T), function(T, boolean)) → boolean
+
+    Returns whether no elements of an array match the given predicate.
+
+        Returns true if none of the elements matches the predicate (a special case is when the array is empty);
+        Returns false if one or more elements match;
+        Returns NULL if the predicate function returns NULL for one or more elements and false for all other elements.
+        Throws an exception if the predicate fails for one or more elements and returns false or NULL for the rest.
+
 .. function:: reduce(array(T), initialState S, inputFunction(S,T,S), outputFunction(S,R)) -> R
 
     Returns a single value reduced from ``array``. ``inputFunction`` will
@@ -348,6 +447,14 @@ Array Functions
                       (s, x) -> CAST(ROW(x + s.sum, s.count + 1) AS ROW(sum DOUBLE, count INTEGER)),
                       s -> IF(s.count = 0, NULL, s.sum / s.count));
 
+.. function:: remove_nulls(x) -> array
+
+    Remove null values from an array ``array`` ::
+
+        SELECT remove_nulls(ARRAY[1, NULL, 3, NULL]); -- [1, 3]
+        SELECT remove_nulls(ARRAY[true, false, NULL]); -- [true, false]
+        SELECT remove_nulls(ARRAY[ARRAY[1, 2], NULL, ARRAY[1, NULL, 3]]); -- [[1, 2], [1, null, 3]]
+
 .. function:: repeat(element, count) -> array(E)
 
     Repeat ``element`` for ``count`` times. ``count`` cannot be negative and must be less than or equal to 10000.
@@ -356,6 +463,16 @@ Array Functions
 
     Returns an array which has the reversed order of the input array.
 
+.. function:: sequence(start, stop) -> array
+
+    Generate a sequence of integers from start to stop, incrementing by 1 if start is less than or equal to stop,
+    otherwise -1.
+
+.. function:: sequence(start, stop, step) -> array
+   :noindex:
+
+    Generate a sequence of integers from start to stop, incrementing by step.
+
 .. function:: shuffle(array(E)) -> array(E)
 
     Generate a random permutation of the given ``array`` ::
@@ -369,16 +486,6 @@ Array Functions
     Returns a subarray starting from index ``start``(or starting from the end
     if ``start`` is negative) with a length of ``length``.
 
-.. function:: sequence(start, stop) -> array
-
-    Generate a sequence of integers from start to stop, incrementing by 1 if start is less than or equal to stop,
-    otherwise -1.
-
-.. function:: sequence(start, stop, step) -> array
-   :noindex:
-
-    Generate a sequence of integers from start to stop, incrementing by step.
-
 .. function:: subscript(array(E), index) -> E
 
     Returns element of ``array`` at given ``index``. The index starts from one.
@@ -396,6 +503,18 @@ Array Functions
         SELECT transform(ARRAY ['x', 'abc', 'z'], x -> x || '0'); -- ['x0', 'abc0', 'z0']
         SELECT transform(ARRAY [ARRAY [1, NULL, 2], ARRAY[3, NULL]], a -> filter(a, x -> x IS NOT NULL)); -- [[1, 2], [3]]
 
+.. function:: transform_with_index(array(T), function(T,bigint,U)) -> array(U)
+
+    Returns an array that is the result of applying ``function`` to each element of ``array``.
+    The lambda function receives both the element and its 1-based index as arguments.
+    This is useful for transformations that need to know the position of each element::
+
+        SELECT transform_with_index(ARRAY [], (x, i) -> x + i); -- []
+        SELECT transform_with_index(ARRAY [5, 6, 7], (x, i) -> x * i); -- [5, 12, 21]
+        SELECT transform_with_index(ARRAY ['a', 'b', 'c'], (x, i) -> concat(x, cast(i as varchar))); -- ['a1', 'b2', 'c3']
+        SELECT transform_with_index(ARRAY [10, 20, 30], (x, i) -> i); -- [1, 2, 3]
+        SELECT transform_with_index(ARRAY [1, 2, 3], (x, i) -> if(i % 2 = 1, x, x * 2)); -- [1, 4, 3]
+
 .. function:: trim_array(x, n) -> array
 
     Remove n elements from the end of ``array``::
@@ -404,14 +523,6 @@ Array Functions
         SELECT trim_array(ARRAY[1, 2, 3, 4], 2); -- [1, 2]
         SELECT trim_array(ARRAY[1, 2, 3, 4], 4); -- []
 
-.. function:: remove_nulls(x) -> array
-
-    Remove null values from an array ``array`` ::
-
-        SELECT remove_nulls(ARRAY[1, NULL, 3, NULL]); -- [1, 3]
-        SELECT remove_nulls(ARRAY[true, false, NULL]); -- [true, false]
-        SELECT remove_nulls(ARRAY[ARRAY[1, 2], NULL, ARRAY[1, NULL, 3]]); -- [[1, 2], [1, null, 3]]
-
 .. function:: zip(array(T), array(U),..) -> array(row(T,U, ...))
 
     Returns the merge of the given arrays, element-wise into a single array of rows.
diff --git a/velox/docs/functions/presto/binary.rst b/velox/docs/functions/presto/binary.rst
index 315ba71be2c..95860626277 100644
--- a/velox/docs/functions/presto/binary.rst
+++ b/velox/docs/functions/presto/binary.rst
@@ -6,6 +6,22 @@ Binary Functions
 
     Computes the crc32 checksum of ``binary``.
 
+.. function:: fnv1_32(binary) -> integer
+
+    Computes the FNV-1 32-bit hash of ``binary``.
+
+.. function:: fnv1_64(binary) -> bigint
+
+    Computes the FNV-1 64-bit hash of ``binary``.
+
+.. function:: fnv1a_32(binary) -> integer
+
+    Computes the FNV-1a 32-bit hash of ``binary``.
+
+.. function:: fnv1a_64(binary) -> bigint
+
+    Computes the FNV-1a 64-bit hash of ``binary``.
+
 .. function:: from_base64(string) -> varbinary
 
     Decodes a Base64-encoded ``string`` back into its original binary form.
@@ -89,6 +105,11 @@ Binary Functions
 
     Computes the md5 hash of ``binary``.
 
+.. function:: murmur3_x64_128(binary) -> varbinary
+
+    Computes a 128-bit hash of ``binary`` that is equivalent to the 128-bit
+    MurmurHash3 algorithm, often called MurmurHash3_x64_128 or Murmur3F.
+
 .. function:: rpad(binary, size, padbinary) -> varbinary
     :noindex:
 
diff --git a/velox/docs/functions/presto/conversion.rst b/velox/docs/functions/presto/conversion.rst
index d33e6c492d4..5d8f0ac3c6c 100644
--- a/velox/docs/functions/presto/conversion.rst
+++ b/velox/docs/functions/presto/conversion.rst
@@ -30,7 +30,7 @@ are supported if the conversion of their element types are supported. In additio
 supported conversions to/from JSON are listed in :doc:`json`.
 
 .. list-table::
-   :widths: 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25
+   :widths: 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25
    :header-rows: 1
 
    * -
@@ -52,6 +52,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - ipprefix
      - tdigest
      - qdigest
+     - setdigest
+     - khyperloglog
    * - tinyint
      - Y
      - Y
@@ -71,6 +73,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      -
      -
+     -
+     -
    * - smallint
      - Y
      - Y
@@ -90,6 +94,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      -
      -
+     -
+     -
    * - integer
      - Y
      - Y
@@ -109,6 +115,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      -
      -
+     -
+     -
    * - bigint
      - Y
      - Y
@@ -128,6 +136,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      -
      -
+     -
+     -
    * - boolean
      - Y
      - Y
@@ -147,6 +157,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      -
      -
+     -
+     -
    * - real
      - Y
      - Y
@@ -166,6 +178,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      -
      -
+     -
+     -
    * - double
      - Y
      - Y
@@ -185,6 +199,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      -
      -
+     -
+     -
    * - varchar
      - Y
      - Y
@@ -204,6 +220,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - Y
      -
      -
+     -
+     -
    * - varbinary
      -
      -
@@ -223,6 +241,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - Y
      - Y
      - Y
+     - Y
+     - Y
    * - timestamp
      -
      -
@@ -242,6 +262,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      -
      -
+     -
+     -
    * - timestamp with time zone
      -
      -
@@ -261,6 +283,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      -
      -
+     -
+     -
    * - date
      -
      -
@@ -280,6 +304,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      -
      -
+     -
+     -
    * - interval day to second
      -
      -
@@ -299,6 +325,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      -
      -
+     -
+     -
    * - decimal
      - Y
      - Y
@@ -318,6 +346,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      -
      -
+     -
+     -
    * - ipaddress
      -
      -
@@ -337,6 +367,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - Y
      -
      -
+     -
+     -
    * - ipprefix
      -
      -
@@ -356,6 +388,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - Y
      -
      -
+     -
+     -
    * - tdigest
      -
      -
@@ -375,6 +409,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      -
      -
+     -
+     -
    * - qdigest
      -
      -
@@ -394,6 +430,50 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      -
      -
+     -
+     -
+   * - setdigest
+     -
+     -
+     -
+     -
+     -
+     -
+     -
+     -
+     - Y
+     -
+     -
+     -
+     -
+     -
+     -
+     -
+     -
+     -
+     -
+     -
+   * - khyperloglog
+     -
+     -
+     -
+     -
+     -
+     -
+     -
+     -
+     - Y
+     -
+     -
+     -
+     -
+     -
+     -
+     -
+     -
+     -
+     -
+     -
 
 Cast to Integral Types
 ----------------------
@@ -870,6 +950,26 @@ This allows quantile digests to be stored and retrieved for later use.
 
   SELECT cast(qdigest_agg(cast(1.0 as double)) as varbinary); -- AHsUrkfheoQ/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAPA/AAAAAAAA8D8BAAAAAAAAAAAAAPA/AAAAAAAA8L8=
 
+From SETDIGEST
+^^^^^^^^^^^^^^
+
+Returns the SetDigest as a varbinary string containing the serialized representation of the SetDigest data structure.
+This allows SetDigests to be stored and retrieved for later use.
+
+::
+
+  SELECT cast(make_set_digest(1) as varbinary);
+
+From KHYPERLOGLOG
+^^^^^^^^^^^^^^^^^
+
+Returns the KHyperLogLog as a varbinary string containing the serialized representation of the KHyperLogLog data structure.
+This allows KHyperLogLogs to be stored and retrieved for later use.
+
+::
+
+  SELECT cast(khyperloglog_agg(1, 123) as varbinary);
+
 Cast to TIMESTAMP
 -----------------
 
@@ -1324,6 +1424,32 @@ This allows previously stored quantile digests to be restored for use.
   SELECT cast(stored_qdigest_binary as qdigest(real));
   SELECT cast(stored_qdigest_binary as qdigest(double));
 
+Cast to SETDIGEST
+-----------------
+
+From VARBINARY
+^^^^^^^^^^^^^^
+
+Returns a SetDigest reconstructed from the varbinary string containing the serialized representation.
+This allows previously stored SetDigests to be restored for use.
+
+::
+
+  SELECT cast(stored_setdigest_binary as setdigest);
+
+Cast to KHYPERLOGLOG
+--------------------
+
+From VARBINARY
+^^^^^^^^^^^^^^
+
+Returns a KHyperLogLog reconstructed from the varbinary string containing the serialized representation.
+This allows previously stored KHyperLogLogs to be restored for use.
+
+::
+
+  SELECT cast(stored_khyperloglog_binary as khyperloglog);
+
 Cast to IPPREFIX
 ----------------
 
diff --git a/velox/docs/functions/presto/coverage.rst b/velox/docs/functions/presto/coverage.rst
index aacb76f9463..6b2d88fcf22 100644
--- a/velox/docs/functions/presto/coverage.rst
+++ b/velox/docs/functions/presto/coverage.rst
@@ -62,12 +62,14 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     table.coverage tr:nth-child(7) td:nth-child(9) {background-color: #6BA81E;}
     table.coverage tr:nth-child(8) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(8) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(8) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(8) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(8) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(8) td:nth-child(9) {background-color: #6BA81E;}
     table.coverage tr:nth-child(9) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(9) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(9) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(9) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(9) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(9) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(9) td:nth-child(9) {background-color: #6BA81E;}
@@ -108,6 +110,7 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     table.coverage tr:nth-child(15) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(15) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(15) td:nth-child(7) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(16) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(16) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(16) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(16) td:nth-child(7) {background-color: #6BA81E;}
@@ -117,9 +120,10 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     table.coverage tr:nth-child(17) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(17) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(18) td:nth-child(1) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(18) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(18) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(18) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(18) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(18) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(19) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(19) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(19) td:nth-child(3) {background-color: #6BA81E;}
@@ -158,14 +162,16 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     table.coverage tr:nth-child(25) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(25) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(25) td:nth-child(4) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(25) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(25) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(26) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(26) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(26) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(26) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(27) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(27) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(27) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(27) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(27) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(27) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(28) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(28) td:nth-child(3) {background-color: #6BA81E;}
@@ -175,7 +181,7 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     table.coverage tr:nth-child(29) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(29) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(29) td:nth-child(4) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(29) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(29) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(30) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(30) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(30) td:nth-child(4) {background-color: #6BA81E;}
@@ -184,6 +190,8 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     table.coverage tr:nth-child(31) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(31) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(31) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(31) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(31) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(32) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(32) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(32) td:nth-child(3) {background-color: #6BA81E;}
@@ -193,6 +201,7 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     table.coverage tr:nth-child(33) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(33) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(33) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(34) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(34) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(34) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(34) td:nth-child(5) {background-color: #6BA81E;}
@@ -204,11 +213,13 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     table.coverage tr:nth-child(36) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(36) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(36) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(36) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(37) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(37) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(37) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(37) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(37) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(37) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(38) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(38) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(38) td:nth-child(3) {background-color: #6BA81E;}
@@ -227,6 +238,7 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     table.coverage tr:nth-child(40) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(40) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(40) td:nth-child(7) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(41) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(41) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(41) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(41) td:nth-child(4) {background-color: #6BA81E;}
@@ -236,6 +248,7 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     table.coverage tr:nth-child(42) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(42) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(42) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(42) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(42) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(43) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(43) td:nth-child(2) {background-color: #6BA81E;}
@@ -248,8 +261,10 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     table.coverage tr:nth-child(44) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(44) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(44) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(44) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(45) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(45) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(45) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(45) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(45) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(45) td:nth-child(7) {background-color: #6BA81E;}
@@ -260,11 +275,12 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     table.coverage tr:nth-child(46) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(46) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(47) td:nth-child(1) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(47) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(47) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(47) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(47) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(47) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(48) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(48) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(48) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(48) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(48) td:nth-child(5) {background-color: #6BA81E;}
@@ -277,21 +293,27 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     table.coverage tr:nth-child(49) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(50) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(50) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(50) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(50) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(50) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(50) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(51) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(51) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(51) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(51) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(51) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(51) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(52) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(52) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(52) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(52) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(52) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(52) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(53) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(53) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(53) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(53) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(53) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(53) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(54) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(54) td:nth-child(3) {background-color: #6BA81E;}
@@ -299,7 +321,6 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     table.coverage tr:nth-child(54) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(54) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(55) td:nth-child(1) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(55) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(55) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(55) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(55) td:nth-child(5) {background-color: #6BA81E;}
@@ -311,29 +332,30 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     table.coverage tr:nth-child(56) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(56) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(57) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(57) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(57) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(57) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(57) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(57) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(58) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(58) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(58) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(58) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(58) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(58) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(59) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(59) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(59) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(59) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(59) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(59) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(60) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(60) td:nth-child(2) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(60) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(60) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(60) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(60) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(61) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(61) td:nth-child(2) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(61) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(61) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(61) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(61) td:nth-child(7) {background-color: #6BA81E;}
@@ -349,22 +371,25 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     table.coverage tr:nth-child(63) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(63) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(63) td:nth-child(7) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(64) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(64) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(64) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(64) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(64) td:nth-child(5) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(65) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(64) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(65) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(65) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(65) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(65) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(65) td:nth-child(7) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(66) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(66) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(66) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(66) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(66) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(66) td:nth-child(7) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(67) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(67) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(67) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(67) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(67) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(68) td:nth-child(1) {background-color: #6BA81E;}
@@ -391,6 +416,7 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     table.coverage tr:nth-child(71) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(72) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(72) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(72) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(72) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(72) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(72) td:nth-child(7) {background-color: #6BA81E;}
@@ -402,33 +428,44 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     table.coverage tr:nth-child(73) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(74) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(74) td:nth-child(2) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(74) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(74) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(74) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(74) td:nth-child(7) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(75) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(75) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(75) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(75) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(75) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(75) td:nth-child(7) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(76) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(76) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(76) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(76) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(76) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(76) td:nth-child(7) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(77) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(77) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(77) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(77) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(77) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(77) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(78) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(78) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(78) td:nth-child(3) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(78) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(78) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(78) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(79) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(79) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(79) td:nth-child(3) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(79) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(79) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(80) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(80) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(80) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(80) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(81) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(81) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(81) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(81) td:nth-child(4) {background-color: #6BA81E;}
     </style>
 
 .. table::
@@ -438,83 +475,85 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     ========================================  ========================================  ========================================  ========================================  ========================================  ==  ========================================  ==  ========================================
     Scalar Functions                                                                                                                                                                                                      Aggregate Functions                           Window Functions
     ================================================================================================================================================================================================================  ==  ========================================  ==  ========================================
-    :func:`abs`                               :func:`date_diff`                         :func:`ip_subnet_range`                   :func:`random`                            :func:`st_numgeometries`                      :func:`approx_distinct`                       :func:`cume_dist`
-    :func:`acos`                              :func:`date_format`                       :func:`is_finite`                         :func:`reduce`                            :func:`st_numinteriorring`                    :func:`approx_most_frequent`                  :func:`dense_rank`
-    :func:`all_match`                         :func:`date_parse`                        :func:`is_infinite`                       :func:`regexp_extract`                    :func:`st_numpoints`                          :func:`approx_percentile`                     :func:`first_value`
-    :func:`any_keys_match`                    :func:`date_trunc`                        :func:`is_json_scalar`                    :func:`regexp_extract_all`                :func:`st_overlaps`                           :func:`approx_set`                            :func:`lag`
-    :func:`any_match`                         :func:`day`                               :func:`is_nan`                            :func:`regexp_like`                       :func:`st_point`                              :func:`arbitrary`                             :func:`last_value`
-    :func:`any_values_match`                  :func:`day_of_month`                      :func:`is_private_ip`                     :func:`regexp_replace`                    :func:`st_pointn`                             :func:`array_agg`                             :func:`lead`
-    :func:`array_average`                     :func:`day_of_week`                       :func:`is_subnet_of`                      :func:`regexp_split`                      :func:`st_points`                             :func:`avg`                                   :func:`nth_value`
-    :func:`array_cum_sum`                     :func:`day_of_year`                       jaccard_index                             regress                                   :func:`st_polygon`                            :func:`bitwise_and_agg`                       :func:`ntile`
-    :func:`array_distinct`                    :func:`degrees`                           :func:`json_array_contains`               reidentification_potential                :func:`st_relate`                             :func:`bitwise_or_agg`                        :func:`percent_rank`
-    :func:`array_duplicates`                  :func:`dow`                               :func:`json_array_get`                    :func:`remove_nulls`                      :func:`st_startpoint`                         :func:`bool_and`                              :func:`rank`
-    :func:`array_except`                      :func:`doy`                               :func:`json_array_length`                 render                                    :func:`st_symdifference`                      :func:`bool_or`                               :func:`row_number`
-    :func:`array_frequency`                   :func:`e`                                 :func:`json_extract`                      :func:`repeat`                            :func:`st_touches`                            :func:`checksum`
-    :func:`array_has_duplicates`              :func:`element_at`                        :func:`json_extract_scalar`               :func:`replace`                           :func:`st_union`                              :func:`classification_fall_out`
-    :func:`array_intersect`                   :func:`empty_approx_set`                  :func:`json_format`                       :func:`replace_first`                     :func:`st_within`                             :func:`classification_miss_rate`
-    :func:`array_join`                        :func:`ends_with`                         :func:`json_parse`                        :func:`reverse`                           :func:`st_x`                                  :func:`classification_precision`
-    array_least_frequent                      enum_key                                  :func:`json_size`                         rgb                                       :func:`st_xmax`                               :func:`classification_recall`
-    :func:`array_max`                         :func:`exp`                               key_sampling_percent                      :func:`round`                             :func:`st_xmin`                               :func:`classification_thresholds`
-    :func:`array_max_by`                      expand_envelope                           :func:`laplace_cdf`                       :func:`rpad`                              :func:`st_y`                                  convex_hull_agg
-    :func:`array_min`                         :func:`f_cdf`                             :func:`last_day_of_month`                 :func:`rtrim`                             :func:`st_ymax`                               :func:`corr`
-    :func:`array_min_by`                      features                                  :func:`least`                             :func:`scale_qdigest`                     :func:`st_ymin`                               :func:`count`
-    :func:`array_normalize`                   :func:`filter`                            :func:`length`                            :func:`second`                            :func:`starts_with`                           :func:`count_if`
-    :func:`array_position`                    :func:`filter`                            :func:`levenshtein_distance`              :func:`secure_rand`                       :func:`strpos`                                :func:`covar_pop`
-    :func:`array_remove`                      :func:`find_first`                        :func:`line_interpolate_point`            :func:`secure_random`                     :func:`strrpos`                               :func:`covar_samp`
-    :func:`array_sort`                        :func:`find_first_index`                  :func:`line_locate_point`                 :func:`sequence`                          :func:`substr`                                differential_entropy
-    :func:`array_sort_desc`                   :func:`flatten`                           :func:`ln`                                :func:`sha1`                              :func:`tan`                                   :func:`entropy`
-    array_split_into_chunks                   :func:`flatten_geometry_collections`      localtime                                 :func:`sha256`                            :func:`tanh`                                  evaluate_classifier_predictions
-    :func:`array_sum`                         :func:`floor`                             localtimestamp                            :func:`sha512`                            tdigest_agg                                   :func:`every`
-    :func:`array_top_n`                       fnv1_32                                   :func:`log10`                             :func:`shuffle`                           :func:`timezone_hour`                         :func:`geometric_mean`
-    :func:`array_union`                       fnv1_64                                   :func:`log2`                              :func:`sign`                              :func:`timezone_minute`                       geometry_union_agg
-    :func:`arrays_overlap`                    fnv1a_32                                  :func:`lower`                             :func:`simplify_geometry`                 :func:`to_base`                               :func:`histogram`
-    :func:`asin`                              fnv1a_64                                  :func:`lpad`                              :func:`sin`                               to_base32                                     khyperloglog_agg
-    :func:`atan`                              :func:`format_datetime`                   :func:`ltrim`                             sketch_kll_quantile                       :func:`to_base64`                             :func:`kurtosis`
-    :func:`atan2`                             :func:`from_base`                         :func:`map`                               sketch_kll_rank                           :func:`to_base64url`                          learn_classifier
-    bar                                       from_base32                               :func:`map_concat`                        :func:`slice`                             :func:`to_big_endian_32`                      learn_libsvm_classifier
-    :func:`beta_cdf`                          :func:`from_base64`                       :func:`map_entries`                       spatial_partitions                        :func:`to_big_endian_64`                      learn_libsvm_regressor
-    :func:`bing_tile`                         :func:`from_base64url`                    :func:`map_filter`                        :func:`split`                             to_geometry                                   learn_regressor
-    :func:`bing_tile_at`                      :func:`from_big_endian_32`                :func:`map_from_entries`                  :func:`split_part`                        :func:`to_hex`                                make_set_digest
-    :func:`bing_tile_children`                :func:`from_big_endian_64`                :func:`map_keys`                          :func:`split_to_map`                      :func:`to_ieee754_32`                         :func:`map_agg`
-    :func:`bing_tile_coordinates`             :func:`from_hex`                          :func:`map_keys_by_top_n_values`          :func:`split_to_multimap`                 :func:`to_ieee754_64`                         :func:`map_union`
-    :func:`bing_tile_parent`                  :func:`from_ieee754_32`                   :func:`map_normalize`                     :func:`spooky_hash_v2_32`                 :func:`to_iso8601`                            :func:`map_union_sum`
-    bing_tile_polygon                         :func:`from_ieee754_64`                   :func:`map_remove_null_values`            :func:`spooky_hash_v2_64`                 :func:`to_milliseconds`                       :func:`max`
-    :func:`bing_tile_quadkey`                 :func:`from_iso8601_date`                 :func:`map_subset`                        :func:`sqrt`                              to_spherical_geography                        :func:`max_by`
-    :func:`bing_tile_zoom_level`              :func:`from_iso8601_timestamp`            :func:`map_top_n`                         :func:`st_area`                           :func:`to_unixtime`                           :func:`merge`
-    :func:`bing_tiles_around`                 :func:`from_unixtime`                     :func:`map_top_n_keys`                    :func:`st_asbinary`                       :func:`to_utf8`                               merge_set_digest
-    :func:`binomial_cdf`                      :func:`from_utf8`                         map_top_n_keys_by_value                   :func:`st_astext`                         :func:`trail`                                 :func:`min`
-    :func:`bit_count`                         :func:`gamma_cdf`                         :func:`map_top_n_values`                  :func:`st_boundary`                       :func:`transform`                             :func:`min_by`
-    :func:`bitwise_and`                       geometry_as_geojson                       :func:`map_values`                        :func:`st_buffer`                         :func:`transform_keys`                        :func:`multimap_agg`
-    :func:`bitwise_arithmetic_shift_right`    geometry_from_geojson                     :func:`map_zip_with`                      :func:`st_centroid`                       :func:`transform_values`                      :func:`noisy_avg_gaussian`
-    :func:`bitwise_left_shift`                :func:`geometry_invalid_reason`           :func:`md5`                               :func:`st_contains`                       :func:`trim`                                  :func:`noisy_count_gaussian`
-    :func:`bitwise_logical_shift_right`       :func:`geometry_nearest_points`           merge_hll                                 :func:`st_convexhull`                     :func:`trim_array`                            :func:`noisy_count_if_gaussian`
-    :func:`bitwise_not`                       geometry_to_bing_tiles                    merge_khll                                :func:`st_coorddim`                       :func:`truncate`                              :func:`noisy_sum_gaussian`
-    :func:`bitwise_or`                        geometry_to_dissolved_bing_tiles          :func:`millisecond`                       :func:`st_crosses`                        :func:`typeof`                                :func:`numeric_histogram`
-    :func:`bitwise_right_shift`               geometry_union                            :func:`minute`                            :func:`st_difference`                     uniqueness_distribution                       :func:`qdigest_agg`
-    :func:`bitwise_right_shift_arithmetic`    great_circle_distance                     :func:`mod`                               :func:`st_dimension`                      :func:`upper`                                 :func:`reduce_agg`
-    :func:`bitwise_shift_left`                :func:`greatest`                          :func:`month`                             :func:`st_disjoint`                       :func:`url_decode`                            :func:`regr_avgx`
-    :func:`bitwise_xor`                       :func:`hamming_distance`                  :func:`multimap_from_entries`             :func:`st_distance`                       :func:`url_encode`                            :func:`regr_avgy`
-    :func:`cardinality`                       hash_counts                               :func:`murmur3_x64_128`                   :func:`st_endpoint`                       :func:`url_extract_fragment`                  :func:`regr_count`
-    :func:`cauchy_cdf`                        :func:`hmac_md5`                          myanmar_font_encoding                     :func:`st_envelope`                       :func:`url_extract_host`                      :func:`regr_intercept`
-    :func:`cbrt`                              :func:`hmac_sha1`                         myanmar_normalize_unicode                 :func:`st_envelopeaspts`                  :func:`url_extract_parameter`                 :func:`regr_r2`
-    :func:`ceil`                              :func:`hmac_sha256`                       :func:`nan`                               :func:`st_equals`                         :func:`url_extract_path`                      :func:`regr_slope`
-    :func:`ceiling`                           :func:`hmac_sha512`                       :func:`ngrams`                            :func:`st_exteriorring`                   :func:`url_extract_port`                      :func:`regr_sxx`
-    :func:`chi_squared_cdf`                   :func:`hour`                              :func:`no_keys_match`                     :func:`st_geometries`                     :func:`url_extract_protocol`                  :func:`regr_sxy`
-    :func:`chr`                               :func:`infinity`                          :func:`no_values_match`                   :func:`st_geometryfromtext`               :func:`url_extract_query`                     :func:`regr_syy`
-    classify                                  intersection_cardinality                  :func:`none_match`                        :func:`st_geometryn`                      :func:`uuid`                                  reservoir_sample
-    :func:`codepoint`                         :func:`inverse_beta_cdf`                  :func:`normal_cdf`                        :func:`st_geometrytype`                   :func:`value_at_quantile`                     :func:`set_agg`
-    color                                     :func:`inverse_binomial_cdf`              :func:`normalize`                         :func:`st_geomfrombinary`                 :func:`values_at_quantiles`                   :func:`set_union`
-    :func:`combinations`                      :func:`inverse_cauchy_cdf`                now                                       :func:`st_interiorringn`                  :func:`week`                                  sketch_kll
-    :func:`concat`                            :func:`inverse_chi_squared_cdf`           :func:`parse_datetime`                    :func:`st_interiorrings`                  :func:`week_of_year`                          sketch_kll_with_k
-    :func:`contains`                          :func:`inverse_f_cdf`                     :func:`parse_duration`                    :func:`st_intersection`                   :func:`weibull_cdf`                           :func:`skewness`
-    :func:`cos`                               :func:`inverse_gamma_cdf`                 :func:`parse_presto_data_size`            :func:`st_intersects`                     :func:`width_bucket`                          spatial_partitioning
-    :func:`cosh`                              :func:`inverse_laplace_cdf`               :func:`pi`                                :func:`st_isclosed`                       :func:`wilson_interval_lower`                 :func:`stddev`
-    :func:`cosine_similarity`                 :func:`inverse_normal_cdf`                pinot_binary_decimal_to_double            :func:`st_isempty`                        :func:`wilson_interval_upper`                 :func:`stddev_pop`
-    :func:`crc32`                             :func:`inverse_poisson_cdf`               :func:`poisson_cdf`                       :func:`st_isring`                         :func:`word_stem`                             :func:`stddev_samp`
-    :func:`current_date`                      :func:`inverse_weibull_cdf`               :func:`pow`                               :func:`st_issimple`                       :func:`xxhash64`                              :func:`sum`
-    current_time                              :func:`ip_prefix`                         :func:`power`                             :func:`st_isvalid`                        :func:`year`                                  :func:`tdigest_agg`
-    current_timestamp                         :func:`ip_prefix_collapse`                :func:`quantile_at_value`                 :func:`st_length`                         :func:`year_of_week`                          :func:`var_pop`
-    current_timezone                          :func:`ip_prefix_subnets`                 :func:`quarter`                           st_linefromtext                           :func:`yow`                                   :func:`var_samp`
-    :func:`date`                              :func:`ip_subnet_max`                     :func:`radians`                           st_linestring                             :func:`zip`                                   :func:`variance`
-    :func:`date_add`                          :func:`ip_subnet_min`                     :func:`rand`                              st_multipoint                             :func:`zip_with`
+    :func:`abs`                               :func:`date_format`                       :func:`ip_subnet_range`                   :func:`random`                            :func:`st_numpoints`                          :func:`approx_distinct`                       :func:`cume_dist`
+    :func:`acos`                              :func:`date_parse`                        :func:`is_finite`                         :func:`reduce`                            :func:`st_overlaps`                           :func:`approx_most_frequent`                  :func:`dense_rank`
+    :func:`all_match`                         :func:`date_trunc`                        :func:`is_infinite`                       :func:`regexp_extract`                    :func:`st_point`                              :func:`approx_percentile`                     :func:`first_value`
+    :func:`any_keys_match`                    :func:`day`                               :func:`is_json_scalar`                    :func:`regexp_extract_all`                :func:`st_pointn`                             :func:`approx_set`                            :func:`lag`
+    :func:`any_match`                         :func:`day_of_month`                      :func:`is_nan`                            :func:`regexp_like`                       :func:`st_points`                             :func:`arbitrary`                             :func:`last_value`
+    :func:`any_values_match`                  :func:`day_of_week`                       :func:`is_private_ip`                     :func:`regexp_replace`                    :func:`st_polygon`                            :func:`array_agg`                             :func:`lead`
+    :func:`array_average`                     :func:`day_of_year`                       :func:`is_subnet_of`                      :func:`regexp_split`                      :func:`st_relate`                             :func:`avg`                                   :func:`nth_value`
+    :func:`array_cum_sum`                     :func:`degrees`                           :func:`jaccard_index`                     regress                                   :func:`st_startpoint`                         :func:`bitwise_and_agg`                       :func:`ntile`
+    :func:`array_distinct`                    :func:`dot_product`                       :func:`json_array_contains`               :func:`reidentification_potential`        :func:`st_symdifference`                      :func:`bitwise_or_agg`                        :func:`percent_rank`
+    :func:`array_duplicates`                  :func:`dow`                               :func:`json_array_get`                    :func:`remove_nulls`                      :func:`st_touches`                            :func:`bool_and`                              :func:`rank`
+    :func:`array_except`                      :func:`doy`                               :func:`json_array_length`                 render                                    :func:`st_union`                              :func:`bool_or`                               :func:`row_number`
+    :func:`array_frequency`                   :func:`e`                                 :func:`json_extract`                      :func:`repeat`                            :func:`st_within`                             :func:`checksum`
+    :func:`array_has_duplicates`              :func:`element_at`                        :func:`json_extract_scalar`               :func:`replace`                           :func:`st_x`                                  :func:`classification_fall_out`
+    :func:`array_intersect`                   :func:`empty_approx_set`                  :func:`json_format`                       :func:`replace_first`                     :func:`st_xmax`                               :func:`classification_miss_rate`
+    :func:`array_join`                        :func:`ends_with`                         :func:`json_parse`                        :func:`reverse`                           :func:`st_xmin`                               :func:`classification_precision`
+    array_least_frequent                      :func:`enum_key`                          :func:`json_size`                         rgb                                       :func:`st_y`                                  :func:`classification_recall`
+    :func:`array_max`                         :func:`exp`                               key_sampling_percent                      :func:`round`                             :func:`st_ymax`                               :func:`classification_thresholds`
+    :func:`array_max_by`                      :func:`expand_envelope`                   l2_squared                                :func:`rpad`                              :func:`st_ymin`                               :func:`convex_hull_agg`
+    :func:`array_min`                         :func:`f_cdf`                             :func:`laplace_cdf`                       :func:`rtrim`                             :func:`starts_with`                           :func:`corr`
+    :func:`array_min_by`                      features                                  :func:`last_day_of_month`                 :func:`scale_qdigest`                     :func:`strpos`                                :func:`count`
+    :func:`array_normalize`                   :func:`filter`                            :func:`least`                             :func:`second`                            :func:`strrpos`                               :func:`count_if`
+    :func:`array_position`                    :func:`filter`                            :func:`length`                            :func:`secure_rand`                       :func:`substr`                                :func:`covar_pop`
+    :func:`array_remove`                      :func:`find_first`                        :func:`levenshtein_distance`              :func:`secure_random`                     :func:`tan`                                   :func:`covar_samp`
+    :func:`array_sort`                        :func:`find_first_index`                  :func:`line_interpolate_point`            :func:`sequence`                          :func:`tanh`                                  differential_entropy
+    :func:`array_sort_desc`                   :func:`flatten`                           :func:`line_locate_point`                 :func:`sha1`                              tdigest_agg                                   :func:`entropy`
+    array_split_into_chunks                   :func:`flatten_geometry_collections`      :func:`ln`                                :func:`sha256`                            :func:`timezone_hour`                         evaluate_classifier_predictions
+    :func:`array_sum`                         :func:`floor`                             :func:`localtime`                         :func:`sha512`                            :func:`timezone_minute`                       :func:`every`
+    :func:`array_top_n`                       :func:`fnv1_32`                           :func:`localtimestamp`                    :func:`shuffle`                           :func:`to_base`                               :func:`geometric_mean`
+    :func:`array_union`                       :func:`fnv1_64`                           :func:`log10`                             :func:`sign`                              to_base32                                     geometry_union_agg
+    :func:`arrays_overlap`                    :func:`fnv1a_32`                          :func:`log2`                              :func:`simplify_geometry`                 :func:`to_base64`                             :func:`histogram`
+    :func:`asin`                              :func:`fnv1a_64`                          :func:`longest_common_prefix`             :func:`sin`                               :func:`to_base64url`                          khyperloglog_agg
+    :func:`atan`                              :func:`format_datetime`                   :func:`lower`                             sketch_kll_quantile                       :func:`to_big_endian_32`                      :func:`kurtosis`
+    :func:`atan2`                             :func:`from_base`                         :func:`lpad`                              sketch_kll_rank                           :func:`to_big_endian_64`                      learn_classifier
+    bar                                       :func:`from_base32`                       :func:`ltrim`                             :func:`slice`                             :func:`to_geometry`                           learn_libsvm_classifier
+    :func:`beta_cdf`                          :func:`from_base64`                       :func:`map`                               spatial_partitions                        :func:`to_hex`                                learn_libsvm_regressor
+    :func:`bing_tile`                         :func:`from_base64url`                    :func:`map_concat`                        :func:`split`                             :func:`to_ieee754_32`                         learn_regressor
+    :func:`bing_tile_at`                      :func:`from_big_endian_32`                :func:`map_entries`                       :func:`split_part`                        :func:`to_ieee754_64`                         :func:`make_set_digest`
+    :func:`bing_tile_children`                :func:`from_big_endian_64`                :func:`map_filter`                        :func:`split_to_map`                      :func:`to_iso8601`                            :func:`map_agg`
+    :func:`bing_tile_coordinates`             :func:`from_hex`                          :func:`map_from_entries`                  :func:`split_to_multimap`                 :func:`to_milliseconds`                       :func:`map_union`
+    :func:`bing_tile_parent`                  :func:`from_ieee754_32`                   :func:`map_keys`                          :func:`spooky_hash_v2_32`                 :func:`to_spherical_geography`                :func:`map_union_sum`
+    :func:`bing_tile_polygon`                 :func:`from_ieee754_64`                   :func:`map_keys_by_top_n_values`          :func:`spooky_hash_v2_64`                 :func:`to_unixtime`                           :func:`max`
+    :func:`bing_tile_quadkey`                 :func:`from_iso8601_date`                 :func:`map_normalize`                     :func:`sqrt`                              :func:`to_utf8`                               :func:`max_by`
+    :func:`bing_tile_zoom_level`              :func:`from_iso8601_timestamp`            :func:`map_remove_null_values`            :func:`st_area`                           :func:`trail`                                 :func:`merge`
+    :func:`bing_tiles_around`                 :func:`from_unixtime`                     :func:`map_subset`                        :func:`st_asbinary`                       :func:`transform`                             :func:`merge_set_digest`
+    :func:`binomial_cdf`                      :func:`from_utf8`                         :func:`map_top_n`                         :func:`st_astext`                         :func:`transform_keys`                        :func:`min`
+    :func:`bit_count`                         :func:`gamma_cdf`                         :func:`map_top_n_keys`                    :func:`st_boundary`                       :func:`transform_values`                      :func:`min_by`
+    :func:`bit_length`                        :func:`geometry_as_geojson`               map_top_n_keys_by_value                   :func:`st_buffer`                         :func:`trim`                                  :func:`multimap_agg`
+    :func:`bitwise_and`                       :func:`geometry_from_geojson`             :func:`map_top_n_values`                  :func:`st_centroid`                       :func:`trim_array`                            :func:`noisy_avg_gaussian`
+    :func:`bitwise_arithmetic_shift_right`    :func:`geometry_invalid_reason`           :func:`map_values`                        :func:`st_contains`                       :func:`truncate`                              :func:`noisy_count_gaussian`
+    :func:`bitwise_left_shift`                :func:`geometry_nearest_points`           :func:`map_zip_with`                      :func:`st_convexhull`                     :func:`typeof`                                :func:`noisy_count_if_gaussian`
+    :func:`bitwise_logical_shift_right`       :func:`geometry_to_bing_tiles`            :func:`md5`                               :func:`st_coorddim`                       :func:`uniqueness_distribution`               :func:`noisy_sum_gaussian`
+    :func:`bitwise_not`                       :func:`geometry_to_dissolved_bing_tiles`  :func:`merge_hll`                         :func:`st_crosses`                        :func:`upper`                                 :func:`numeric_histogram`
+    :func:`bitwise_or`                        :func:`geometry_union`                    :func:`merge_khll`                        :func:`st_difference`                     :func:`url_decode`                            :func:`qdigest_agg`
+    :func:`bitwise_right_shift`               google_polyline_decode                    :func:`millisecond`                       :func:`st_dimension`                      :func:`url_encode`                            :func:`reduce_agg`
+    :func:`bitwise_right_shift_arithmetic`    google_polyline_encode                    :func:`minute`                            :func:`st_disjoint`                       :func:`url_extract_fragment`                  :func:`regr_avgx`
+    :func:`bitwise_shift_left`                :func:`great_circle_distance`             :func:`mod`                               :func:`st_distance`                       :func:`url_extract_host`                      :func:`regr_avgy`
+    :func:`bitwise_xor`                       :func:`greatest`                          :func:`month`                             :func:`st_endpoint`                       :func:`url_extract_parameter`                 :func:`regr_count`
+    :func:`cardinality`                       :func:`hamming_distance`                  :func:`multimap_from_entries`             :func:`st_envelope`                       :func:`url_extract_path`                      :func:`regr_intercept`
+    :func:`cauchy_cdf`                        :func:`hash_counts`                       :func:`murmur3_x64_128`                   :func:`st_envelopeaspts`                  :func:`url_extract_port`                      :func:`regr_r2`
+    :func:`cbrt`                              :func:`hmac_md5`                          myanmar_font_encoding                     :func:`st_equals`                         :func:`url_extract_protocol`                  :func:`regr_slope`
+    :func:`ceil`                              :func:`hmac_sha1`                         myanmar_normalize_unicode                 :func:`st_exteriorring`                   :func:`url_extract_query`                     :func:`regr_sxx`
+    :func:`ceiling`                           :func:`hmac_sha256`                       :func:`nan`                               :func:`st_geometries`                     :func:`uuid`                                  :func:`regr_sxy`
+    :func:`chi_squared_cdf`                   :func:`hmac_sha512`                       :func:`ngrams`                            :func:`st_geometryfromtext`               :func:`value_at_quantile`                     :func:`regr_syy`
+    :func:`chr`                               :func:`hour`                              :func:`no_keys_match`                     :func:`st_geometryn`                      :func:`values_at_quantiles`                   :func:`reservoir_sample`
+    classify                                  :func:`infinity`                          :func:`no_values_match`                   :func:`st_geometrytype`                   :func:`week`                                  :func:`set_agg`
+    :func:`codepoint`                         :func:`intersection_cardinality`          :func:`none_match`                        :func:`st_geomfrombinary`                 :func:`week_of_year`                          :func:`set_union`
+    color                                     :func:`inverse_beta_cdf`                  :func:`normal_cdf`                        :func:`st_interiorringn`                  :func:`weibull_cdf`                           sketch_kll
+    :func:`combinations`                      :func:`inverse_binomial_cdf`              :func:`normalize`                         :func:`st_interiorrings`                  :func:`width_bucket`                          sketch_kll_with_k
+    :func:`concat`                            :func:`inverse_cauchy_cdf`                :func:`now`                               :func:`st_intersection`                   :func:`wilson_interval_lower`                 :func:`skewness`
+    :func:`contains`                          :func:`inverse_chi_squared_cdf`           :func:`parse_datetime`                    :func:`st_intersects`                     :func:`wilson_interval_upper`                 spatial_partitioning
+    :func:`cos`                               :func:`inverse_f_cdf`                     :func:`parse_duration`                    :func:`st_isclosed`                       :func:`word_stem`                             :func:`stddev`
+    :func:`cosh`                              :func:`inverse_gamma_cdf`                 :func:`parse_presto_data_size`            :func:`st_isempty`                        :func:`xxhash64`                              :func:`stddev_pop`
+    :func:`cosine_similarity`                 :func:`inverse_laplace_cdf`               :func:`pi`                                :func:`st_isring`                         :func:`year`                                  :func:`stddev_samp`
+    :func:`crc32`                             :func:`inverse_normal_cdf`                pinot_binary_decimal_to_double            :func:`st_issimple`                       :func:`year_of_week`                          :func:`sum`
+    :func:`current_date`                      :func:`inverse_poisson_cdf`               :func:`poisson_cdf`                       :func:`st_isvalid`                        :func:`yow`                                   :func:`tdigest_agg`
+    :func:`current_time`                      :func:`inverse_weibull_cdf`               :func:`pow`                               :func:`st_length`                         :func:`zip`                                   :func:`var_pop`
+    :func:`current_timestamp`                 :func:`ip_prefix`                         :func:`power`                             :func:`st_linefromtext`                   :func:`zip_with`                              :func:`var_samp`
+    :func:`current_timezone`                  :func:`ip_prefix_collapse`                :func:`quantile_at_value`                 :func:`st_linestring`                                                                   :func:`variance`
+    :func:`date`                              :func:`ip_prefix_subnets`                 :func:`quarter`                           :func:`st_multipoint`
+    :func:`date_add`                          :func:`ip_subnet_max`                     :func:`radians`                           :func:`st_numgeometries`
+    :func:`date_diff`                         :func:`ip_subnet_min`                     :func:`rand`                              :func:`st_numinteriorring`
     ========================================  ========================================  ========================================  ========================================  ========================================  ==  ========================================  ==  ========================================
diff --git a/velox/docs/functions/presto/datetime.rst b/velox/docs/functions/presto/datetime.rst
index 98e42dac552..5703b8baf10 100644
--- a/velox/docs/functions/presto/datetime.rst
+++ b/velox/docs/functions/presto/datetime.rst
@@ -144,7 +144,10 @@ Date and Time Functions
 
 .. function:: from_unixtime(unixtime) -> timestamp
 
-    Returns the UNIX timestamp ``unixtime`` as a timestamp.
+    Returns the UNIX timestamp ``unixtime`` as a timestamp.  If the
+    :doc:`adjust_timestamp_to_session_timezone <../../configs>` property is set
+    to true, then the timestamp is adjusted to the time zone specified in
+    :doc:`session_timezone <../../configs>`.
 
 .. function:: from_unixtime(unixtime, string) -> timestamp with time zone
     :noindex:
@@ -158,6 +161,10 @@ Date and Time Functions
     using ``hours`` and ``minutes`` for the time zone offset.
     The offset must be in [-14:00, 14:00] range.
 
+.. function:: localtimestamp -> timestamp
+
+    Returns the timestamp as of the start of the query.
+
 .. function:: to_iso8601(x) -> varchar
 
     Formats ``x`` as an ISO 8601 string. Supported types for ``x`` are:
@@ -177,6 +184,31 @@ Date and Time Functions
 
     Returns ``timestamp`` as a UNIX timestamp.
 
+.. function:: current_time() -> time with time zone
+
+    Returns the current time since midnight with the session timezoneReturns the current time since midnight with the session timezone, based on the query session start time.
+
+.. function:: current_timezone() -> varchar
+
+    Returns the current session time zone as a varchar.
+
+    Example::
+
+        SELECT current_timezone;   -- Asia/Kolkata
+
+.. function:: current_timestamp() -> timestamp with time zone
+.. function:: now() -> timestamp with time zone
+
+    Returns the current timestamp with session time zone applied.
+    The timestamp is captured once at the start of query execution and remains
+    constant throughout the query. This matches the standard SQL behavior for
+    ``CURRENT_TIMESTAMP`` and ``NOW()``.
+
+    Example::
+
+        SELECT current_timestamp;  -- 2025-07-17 14:53:12.123 Asia/Kolkata
+        SELECT now();              -- 2025-07-17 14:53:12.123 Asia/Kolkata
+
 Truncation Function
 -------------------
 
@@ -314,6 +346,10 @@ Specifier Description
 
     Formats ``x`` as a string using ``format``. ``x`` is a timestamp or a timestamp with time zone.
 
+.. function:: date_parse(string, format) -> timestamp
+
+    Parses ``string`` into a timestamp using ``format``.
+
 Java Date Functions
 -------------------
 
diff --git a/velox/docs/functions/presto/decimal.rst b/velox/docs/functions/presto/decimal.rst
index 539398e7124..875fc813e9b 100644
--- a/velox/docs/functions/presto/decimal.rst
+++ b/velox/docs/functions/presto/decimal.rst
@@ -235,6 +235,14 @@ Decimal Functions
 
     Returns absolute value of x (r = `|x|`).
 
+.. function:: ceil(x: decimal(p, s)) -> r: decimal(pr, 0)
+
+    Returns 'x' rounded up to the nearest integer. The scale of the result is 0.
+    The precision is calculated as:
+    ::
+
+        pr = min(38, p - s + min(s, 1))
+
 .. function:: divide(x: decimal(p1, s1), y: decimal(p2, s2)) -> r: decimal(p, s)
 
     Returns the result of dividing x by y (r = x / y).
diff --git a/velox/docs/functions/presto/geospatial.rst b/velox/docs/functions/presto/geospatial.rst
index 256a6cb825f..052dfe05da9 100644
--- a/velox/docs/functions/presto/geospatial.rst
+++ b/velox/docs/functions/presto/geospatial.rst
@@ -73,6 +73,40 @@ Geometry Constructors
 
     Returns a geometry type polygon object from WKT representation.
 
+.. function:: ST_LineFromText(wkt: varchar) -> linestring: Geometry
+
+    Returns a geometry type linestring object from WKT representation.
+    An error is returned if the input WKT represents a valid non-LineString
+    geometry. Null input returns null output.
+
+.. function:: ST_LineString(points: array(Geometry)) -> linestring: Geometry
+
+    Returns a LineString formed from an array of points. If there are fewer
+    than two non-empty points in the input array, an empty LineString will
+    be returned. Throws an exception if any element in the array is null or
+    empty or same as the previous one. The returned geometry may not be simple,
+    e.g. may self-intersect or may contain duplicate vertexes depending on the
+    input.
+
+.. function:: ST_MultiPoint(points: array(Geometry)) -> multipoint: Geometry
+
+    Returns a MultiPoint geometry object formed from the specified points.
+    Return null if input array is empty. Throws an exception if any element
+    in the array is null or empty. The returned geometry may not be simple
+    and may contain duplicate points if input array has duplicates.
+
+.. function:: to_spherical_geography(input: Geometry) -> output: SphericalGeography
+
+    Converts a ``Geometry`` object to a SphericalGeography object on the sphere
+    of the Earth’s radius. For each point of the input geometry, it verifies that
+    point.x is within [-180.0, 180.0] and point.y is within [-90.0, 90.0],
+    and uses them as (longitude, latitude) degrees to construct the shape
+    of the ``SphericalGeography`` result.
+
+.. function:: to_geometry(input: SphericalGeography) -> output: Geometry
+
+    Converts a SphericalGeography object to a Geometry object.
+
 Spatial Predicates
 ------------------
 
@@ -101,7 +135,9 @@ function you are using.
 
 .. function:: ST_Equals(geometry1: Geometry, geometry2: Geometry) -> boolean
 
-    Returns ``true`` if the given geometries represent the same geometry.
+    Returns ``true`` if the given geometries represent the same geometry
+    according to ISO SQL/MM semantics. Also returns ``true`` if both geometries are empty,
+    regardless of their geometry types.
 
 .. function:: ST_Intersects(geometry1: Geometry, geometry2: Geometry) -> boolean
 
@@ -114,7 +150,7 @@ function you are using.
     Returns ``true`` if the given geometries share space, are of the same
     dimension, but are not completely contained by each other.
 
-.. function:: ST_Relat(geometry1: Geometry, geometry2: Geometry, relation: varchar) -> boolean
+.. function:: ST_Relate(geometry1: Geometry, geometry2: Geometry, relation: varchar) -> boolean
 
     Returns true if first geometry is spatially related to second geometry as
     described by the relation.  The relation is a string like ``'"1*T***T**'``:
@@ -178,6 +214,24 @@ Spatial Operations
     Empty geometries will return an empty polygon. Negative or NaN distances will
     return an error. Positive infinity distances may lead to undefined results.
 
+.. function:: geometry_union(geometries: array(Geometry)) -> union: Geometry
+
+    Returns a geometry that represents the point set union of the input geometries.
+    Performance of this function, in conjunction with array_agg() to first
+    aggregate the input geometries, may be better than geometry_union_agg(),
+    at the expense of higher memory utilization. Null elements in the input
+    array are ignored. Empty array input returns null.
+
+.. function:: geometry_union_agg(geometry: Geometry) -> union: Geometry
+
+    Returns a geometry that represents the point set union of the aggregated
+    input geometries. Null geometries are ignored. Empty input returns null.
+
+.. function:: convex_hull_agg(geometry: Geometry) -> union: Geometry
+
+    Returns a geometry that represents the convex hull of the points in the
+    aggregated input geometries.  Null geometries are ignored. Empty input
+    returns null.
 
 Accessors
 ---------
@@ -213,6 +267,12 @@ Accessors
    on a two dimensional plane (based on spatial ref) in projected units. Will
    return an error if the input geometry is not a LineString or MultiLineString.
 
+.. function:: ST_Length(sphericalgeography: SphericalGeography) -> length: double
+
+    Returns the length of a ``LineString`` or ``MultiLineString`` on a spherical model of the
+    Earth. This is equivalent to the sum of great-circle distances between adjacent points
+    on the ``LineString``.
+
 .. function:: ST_PointN(linestring: Geometry, index: integer) -> point: geometry
 
    Returns the vertex of a LineString at a given index (indices start at 1).
@@ -224,7 +284,7 @@ Accessors
    Returns an array of points in a geometry. Empty or null inputs
    return null.
 
-.. function:: ST_NumPoints(geometry: Geometry) -> points: integer
+.. function:: ST_NumPoints(geometry: Geometry) -> points: bigint
 
    Returns the number of points in a geometry. This is an extension
    to the SQL/MM ``ST_NumPoints`` function which only applies to
@@ -251,6 +311,10 @@ Accessors
     reason. If the geometry is valid and simple (or ``NULL``), return ``NULL``.
     This function is relatively expensive.
 
+.. function:: great_circle_distance(latitude1, longitude1, latitude2, longitude2) -> double
+
+    Returns the great-circle distance between two points on Earth's surface in kilometers.
+
 .. function:: ST_Area(geometry: Geometry) -> area: double
 
     Returns the 2D Euclidean area of ``geometry``.
@@ -258,16 +322,36 @@ Accessors
     returns the sum of the areas of the individual geometries. Empty geometries
     return 0.
 
+.. function:: ST_Area(sphericalgeography: SphericalGeography) -> area: double
+
+    Returns the area of a polygon or multi-polygon in square meters using a spherical model for Earth.
+
 .. function:: ST_Centroid(geometry: Geometry) -> geometry: Geometry
 
     Returns the point value that is the mathematical centroid of ``geometry``.
-    Empty geometry inputs result in empty output.
+    Empty geometry inputs result in null output.
+
+.. function:: ST_Centroid(SphericalGeography) -> Point
+
+    Returns the point value that is the mathematical centroid of a spherical geometry.
+    Empty geometry inputs result in null output.
+
+    It supports Points and MultiPoints as input and returns the three-dimensional
+    centroid projected onto the surface of the (spherical) Earth.
+    For example, MULTIPOINT (0 -45, 0 45, 30 0, -30 0) returns Point(0, 0).
+    Note: In the case that the three-dimensional centroid is at (0, 0, 0)
+    (e.g. MULTIPOINT (0 0, -180 0)), the spherical centroid is undefined and an
+    arbitrary point will be returned.
 
 .. function:: ST_Distance(geometry1: Geometry, geometry2: Geometry) -> distance: double
 
     Returns the 2-dimensional cartesian minimum distance (based on spatial ref)
     between two geometries in projected units. Empty geometries result in null output.
 
+.. function:: ST_Distance(sphericalgeography1: SphericalGeography, sphericalgeography2: SphericalGeography) -> distance: double
+
+    Returns the great-circle distance in meters between two SphericalGeography points.
+
 .. function:: ST_GeometryType(geometry: Geometry) -> type: varchar
 
     Returns the type of the geometry.
@@ -376,7 +460,7 @@ Accessors
     GEOMETRYCOLLECTION (POINT (0 0), GEOMETRYCOLLECTION (POINT (1 1))) ->
     [POINT (0 0), POINT (1 1)], GEOMETRYCOLLECTION EMPTY -> [].
 
-.. function:: ST_NumInteriorRing(geometry: Geometry) -> output: integer
+.. function:: ST_NumInteriorRing(geometry: Geometry) -> output: bigint
 
     Returns the cardinality of the collection of interior rings of a polygon.
 
@@ -384,7 +468,7 @@ Accessors
 
     Returns the minimum convex geometry that encloses all input geometries.
 
-.. function:: ST_CoordDim(geometry: Geometry) -> output: integer
+.. function:: ST_CoordDim(geometry: Geometry) -> output: tinyint
 
     Return the coordinate dimension of the geometry.
 
@@ -472,6 +556,16 @@ for more details.
 
     Creates a Bing tile object from a quadkey. An invalid quadkey will return a User Error.
 
+.. function:: bing_tiles_around(latitude, longitude, zoom_level) -> array(BingTile)
+
+    Returns a collection of Bing tiles that surround the point specified
+    by the latitude and longitude arguments at a given zoom level.
+
+.. function:: bing_tiles_around(latitude, longitude, zoom_level, radius_in_km) -> array(BingTile)
+
+    Returns a minimum set of Bing tiles at specified zoom level that cover a circle of specified
+    radius in km around a specified (latitude, longitude) point.
+
 .. function:: bing_tile_coordinates(tile: BingTile) -> coords: row(integer,integer)
 
     Returns the ``x``, ``y`` coordinates of a given Bing tile as ``row(x, y)``.
@@ -503,6 +597,16 @@ for more details.
     childZoom is less than the tile's zoom.  The order is deterministic but not
     specified.
 
+.. function:: bing_tile_polygon(tile) -> Geometry
+
+    Returns the polygon representation of a given Bing tile.
+
+.. function:: bing_tile_at(latitude, longitude, zoom_level) -> BingTile
+
+    Returns a Bing tile at a given zoom level containing a point at a given latitude
+    and longitude. Latitude must be within ``[-85.05112878, 85.05112878]`` range.
+    Longitude must be within ``[-180, 180]`` range. Zoom levels from 1 to 23 are supported.
+
 .. function:: bing_tile_quadkey() -> quadKey: varchar
 
     Returns the quadkey representing the provided bing tile.
@@ -513,5 +617,98 @@ for more details.
     given zoom level. Empty inputs return an empty array, and null inputs return
     null.
 
+.. function:: geometry_to_dissolved_bing_tiles(geometry: Geometry, max_zoom_level: tinyint) -> tile: array(BingTile)
+
+    Returns the minimum set of Bing tiles that fully covers a given geometry at a
+    given zoom level, recursively dissolving full sets of children into parents.
+    This results in a smaller array of tiles of different zoom levels.
+    For example, if the non-dissolved covering is [“00”, “01”, “02”, “03”, “10”],
+    the dissolved covering would be [“0”, “10”]. Zoom levels from 0 to 23 are supported.
+
+S2 Cell Functions
+-----------------
+
+`S2 Geometry <http://s2geometry.io/>`_ is a library for spherical geometry that
+decomposes the Earth's surface into a hierarchy of cells. Unlike planar tiling
+systems (e.g., Bing Tiles), S2 cells have near-uniform area across all latitudes.
+
+Each cell is identified by a 64-bit **cell ID** (stored as ``BIGINT``), which
+encodes both the cell's position and level in the hierarchy. Cells are organized
+in 31 levels (0–30), where level 0 cells are the largest (covering roughly 1/6
+of Earth's surface) and level 30 cells are the smallest (sub-centimeter).
+
+Cells can also be represented as compact hexadecimal **tokens** (e.g.,
+``'8085808b'``), which are shorter and human-readable. Use
+``s2_cell_from_token`` and ``s2_cell_to_token`` to convert between the two
+representations.
+
+All functions operate on cell IDs (``BIGINT``) rather than tokens because cell
+IDs support direct integer comparison, efficient equi-joins and GROUP BY, and
+compose without casting (e.g., ``s2_cell_contains(s2_cell_parent(id, 10), id)``).
+Tokens are useful for human-readable output and interop with external systems
+that use the token format.
+
+
+.. function:: s2_cell_area_sq_km(cell_id: bigint) -> area: double
+
+    Returns the area of the S2 cell in square kilometers.
+    Returns an error if the cell ID is invalid.
+
+.. function:: s2_cell_contains(parent_cell_id: bigint, child_cell_id: bigint) -> boolean
+
+    Returns ``true`` if the first S2 cell contains the second. Containment is
+    hierarchical: a cell contains all of its descendants at finer levels.
+    Returns an error if either cell ID is invalid.
+
+.. function:: s2_cell_from_token(cell_token: varchar) -> cell_id: bigint
+
+    Returns the 64-bit S2 cell ID for the given cell token. The
+    ``cell_token`` is a compact hexadecimal representation of the S2 cell.
+    Returns an error if the cell token is invalid.
+
+.. function:: s2_cell_level(cell_id: bigint) -> level: integer
+
+    Returns the level of the S2 cell, from 0 (coarsest) to 30 (finest).
+    Returns an error if the cell ID is invalid.
+
+.. function:: s2_cell_parent(cell_id: bigint, level: integer) -> parent_id: bigint
+
+    Returns the parent S2 cell ID at the given ``level``. If the cell is
+    already at or above the given level, returns the same cell ID. The
+    ``level`` must be in the ``[0, 30]`` range. Returns an error if the cell
+    ID is invalid or the level is out of range.
+
+.. function:: s2_cell_to_token(cell_id: bigint) -> cell_token: varchar
+
+    Returns the compact hexadecimal token representation of the S2 cell.
+    Returns an error if the cell ID is invalid.
+
+.. function:: s2_cells(geometry: Geometry, level: integer) -> cell_ids: array(bigint)
+
+    Returns the set of S2 cell IDs that cover the given geometry at a fixed
+    ``level``. All returned cells are at the same level. Supports Point,
+    LineString, Polygon, and their Multi variants. Empty geometries return an
+    empty array, null geometries return null. The ``level`` must be in the
+    ``[0, 30]`` range.
+
+.. function:: s2_cells(geometry: Geometry, min_level: integer, max_level: integer, max_cells: integer) -> cell_ids: array(bigint)
+
+    Returns a compact set of S2 cell IDs at mixed levels that cover the given
+    geometry, similar to ``geometry_to_dissolved_bing_tiles``. The coverer uses
+    large cells (at ``min_level``) for interiors and small cells (up to
+    ``max_level``) for boundaries, targeting at most ``max_cells`` cells. This
+    is useful for compact spatial indexing of regions like cities or countries.
+    Both levels must be in the ``[0, 30]`` range with ``min_level <= max_level``,
+    and ``max_cells`` must be >= 1. Empty geometries return an empty array,
+    null geometries return null.
+
+    Note: ``max_cells`` is a soft limit. Up to 6 cells may be returned
+    regardless of ``max_cells`` if the region intersects multiple cube faces
+    of the S2 projection. ``min_level`` takes priority over ``max_cells`` —
+    cells below ``min_level`` are never used even if this causes more cells
+    to be returned. If ``max_cells`` is less than 4, the covering area may be
+    significantly larger than the original region. A value of 8 or higher is
+    recommended for a reasonable approximation.
+
 .. _OpenGIS Specifications: https://www.ogc.org/standards/ogcapi-features/
 .. _SQL/MM Part 3: Spatial: https://www.iso.org/standard/31369.html
diff --git a/velox/docs/functions/presto/hyperloglog.rst b/velox/docs/functions/presto/hyperloglog.rst
index ecd8e6d384a..fd10739f5a5 100644
--- a/velox/docs/functions/presto/hyperloglog.rst
+++ b/velox/docs/functions/presto/hyperloglog.rst
@@ -70,3 +70,10 @@ Functions
 
     Returns the ``HyperLogLog`` of the aggregate union of the individual ``hll``
     HyperLogLog structures.
+
+.. function:: merge_hll(array(HyperLogLog)) -> HyperLogLog
+
+    Returns the ``HyperLogLog`` of the union of an array of ``HyperLogLog`` structures.
+
+    * Returns ``NULL`` if the input array is ``NULL``, empty, or contains only ``NULL`` elements
+    * Ignores ``NULL`` elements and merges only valid ``HyperLogLog`` structures when the array contains a mix of ``NULL`` and non-null elements
diff --git a/velox/docs/functions/presto/ipaddress.rst b/velox/docs/functions/presto/ipaddress.rst
index f1c061566a2..3b558ee88cd 100644
--- a/velox/docs/functions/presto/ipaddress.rst
+++ b/velox/docs/functions/presto/ipaddress.rst
@@ -69,6 +69,35 @@ IP Functions
         SELECT IP_PREFIX_SUBNETS(IPPREFIX '192.168.1.0/24', 25); -- [{192.168.1.0/25}, {192.168.1.128/25}]
         SELECT IP_PREFIX_SUBNETS(IPPREFIX '2a03:2880:c000::/34', 36); -- [{2a03:2880:c000::/36}, {2a03:2880:d000::/36}, {2a03:2880:e000::/36}, {2a03:2880:f000::/36}]
 
+.. function:: ip_version(ip_address) -> bigint
+
+    Returns ``4`` if ``ip_address`` is an IPv4 address, ``6`` if it is an IPv6 address.
+    IPv4-mapped IPv6 addresses (e.g. ``::ffff:1.2.3.4``) are treated as IPv4.
+    ``ip_address`` is of type ``IPADDRESS``. ::
+
+        SELECT ip_version(IPADDRESS '1.2.3.4'); -- 4
+        SELECT ip_version(IPADDRESS '::ffff:1.2.3.4'); -- 4
+        SELECT ip_version(IPADDRESS '64:ff9b::17'); -- 6
+        SELECT ip_version(IPADDRESS '2001:db8::1'); -- 6
+
+.. function:: ip_version(ip_prefix) -> bigint
+
+    Returns ``4`` if ``ip_prefix`` contains an IPv4 address, ``6`` if it contains an IPv6 address.
+    IPv4-mapped IPv6 prefixes are treated as IPv4.
+    ``ip_prefix`` is of type ``IPPREFIX``. ::
+
+        SELECT ip_version(IPPREFIX '1.2.3.4/24'); -- 4
+        SELECT ip_version(IPPREFIX '64:ff9b::17/64'); -- 6
+
+.. function:: ip_prefix_masklen(ip_prefix) -> bigint
+
+    Returns the prefix length (mask length) of ``ip_prefix``.
+    The value is in the range [0, 32] for IPv4 and [0, 128] for IPv6. ::
+
+        SELECT ip_prefix_masklen(IPPREFIX '1.2.3.4/24'); -- 24
+        SELECT ip_prefix_masklen(IPPREFIX '64:ff9b::17/128'); -- 128
+        SELECT ip_prefix_masklen(IPPREFIX '::/0'); -- 0
+
 .. function:: is_private_ip(ip_address) -> boolean
 
     Returns whether ``ip_address`` of type ``IPADDRESS`` is a private or reserved IP address
diff --git a/velox/docs/functions/presto/khyperloglog.rst b/velox/docs/functions/presto/khyperloglog.rst
new file mode 100644
index 00000000000..ba23b051a3a
--- /dev/null
+++ b/velox/docs/functions/presto/khyperloglog.rst
@@ -0,0 +1,84 @@
+=========================
+KHyperLogLog Functions
+=========================
+
+KHyperLogLog is a data sketch for estimating reidentifiability and joinability within a dataset.
+Based on the `KHyperLogLog paper <https://research.google/pubs/khyperloglog-estimating-reidentifiability-and-joinability-of-large-data-at-scale/>`_,
+it maintains a map of K number of HyperLogLog structures, where each entry corresponds to a unique key from one column,
+and the HLL estimates the cardinality of the associated unique identifiers from another column.
+
+Data Structures
+---------------
+
+A KHyperLogLog is a data sketch which stores approximate cardinality information for key-value
+associations. The Velox type for this data structure is called ``KHyperLogLog``.
+For storage and retrieval, KHyperLogLog values may be cast to/from ``VARBINARY``.
+
+Serialization format is compatible with Presto's.
+
+Aggregate Functions
+-------------------
+
+.. function:: khyperloglog_agg(x, uii) -> KHyperLogLog
+
+    Returns the ``KHyperLogLog`` sketch which summarizes the association between
+    the key column ``x`` and the unique identifier column ``uii``.
+    The ``x`` parameter represents the key values and ``uii`` represents
+    the unique identifiers associated with each key.
+
+.. function:: merge(KHyperLogLog) -> KHyperLogLog
+
+    Returns the ``KHyperLogLog`` of the aggregate union of the individual ``KHyperLogLog``
+    structures.
+
+Scalar Functions
+----------------
+
+.. function:: cardinality(khll) -> bigint
+
+    Returns the estimated total cardinality (number of unique keys) from the
+    ``KHyperLogLog`` sketch ``khll``.
+
+.. function:: intersection_cardinality(khll1, khll2) -> bigint
+
+    Returns the estimated intersection cardinality between two ``KHyperLogLog`` sketches.
+    If both sketches are exact (small cardinality), returns the exact intersection count.
+    Otherwise, returns an approximation using the Jaccard index.
+
+.. function:: jaccard_index(khll1, khll2) -> double
+
+    Returns the Jaccard index (similarity coefficient) between two ``KHyperLogLog`` sketches.
+    The Jaccard index is a value in [0, 1] where:
+
+    * 1.0 means the sets are identical
+    * 0.0 means the sets are disjoint (no overlap)
+
+.. function:: merge_khll(array(KHyperLogLog)) -> KHyperLogLog
+
+    Returns the ``KHyperLogLog`` of the union of an array of ``KHyperLogLog`` structures.
+
+    * Returns ``NULL`` if the input array is ``NULL``, empty, or contains only ``NULL`` elements
+    * Ignores ``NULL`` elements and merges only valid ``KHyperLogLog`` structures when the array contains a mix of ``NULL`` and non-null elements
+
+.. function:: reidentification_potential(khll, threshold) -> double
+
+    Returns the reidentification potential of the ``KHyperLogLog`` sketch ``khll``
+    at the given ``threshold``. This measures the fraction of keys that have
+    cardinality at or below the threshold, which indicates how easily those
+    keys could be reidentified.
+
+.. function:: uniqueness_distribution(khll) -> map(bigint, double)
+
+    Returns a histogram map representing the distribution of uniqueness values
+    in the ``KHyperLogLog`` sketch ``khll``. Each key in the map represents a
+    cardinality bucket, and the value represents the fraction of keys falling
+    into that bucket. The histogram size defaults to the minhash size of the
+    KHyperLogLog instance.
+
+.. function:: uniqueness_distribution(khll, histogramSize) -> map(bigint, double)
+   :noindex:
+
+    Returns a histogram map representing the distribution of uniqueness values
+    in the ``KHyperLogLog`` sketch ``khll`` with the specified ``histogramSize``.
+    Each key in the map represents a cardinality bucket, and the value represents
+    the fraction of keys falling into that bucket.
diff --git a/velox/docs/functions/presto/map.rst b/velox/docs/functions/presto/map.rst
index c81d7eba948..e7cd9b160da 100644
--- a/velox/docs/functions/presto/map.rst
+++ b/velox/docs/functions/presto/map.rst
@@ -46,6 +46,29 @@ Map Functions
 
     See also :func:`map_agg` for creating a map as an aggregation.
 
+.. function:: map_append(map(K,V), array(K), array(V)) -> map(K,V)
+
+    Returns a map with new key-value pairs appended to the input map. The new keys are provided in the first array parameter and corresponding values in the second array parameter.
+    Keys and values arrays must have the same length. New keys must not already exist in the input map. Duplicate keys in the new keys array are not allowed.
+    Null keys are ignored. Null values are preserved in the output map. For REAL and DOUBLE, NaNs (Not-a-Number) are considered equal. ::
+
+        SELECT map_append(MAP(ARRAY[1, 2], ARRAY[10, 20]), ARRAY[3, 4], ARRAY[30, 40]); -- {1 -> 10, 2 -> 20, 3 -> 30, 4 -> 40}
+        SELECT map_append(MAP(ARRAY['a', 'b'], ARRAY[1, 2]), ARRAY['c'], ARRAY[3]); -- {'a' -> 1, 'b' -> 2, 'c' -> 3}
+        SELECT map_append(MAP(ARRAY[1], ARRAY[10]), ARRAY[2, null, 3], ARRAY[20, 30, 40]); -- {1 -> 10, 2 -> 20, 3 -> 40}
+        SELECT map_append(MAP(ARRAY[1], ARRAY[10]), ARRAY[2, 3], ARRAY[null, 30]); -- {1 -> 10, 2 -> null, 3 -> 30}
+        SELECT map_append(MAP(ARRAY[1], ARRAY[10]), ARRAY[], ARRAY[]); -- {1 -> 10}
+
+.. function:: map_update(map(K,V), array(K), array(V)) -> map(K,V)
+
+    Returns a map with values updated for the specified keys. If a key exists in the input map, its value is updated in place (preserving original order). If a key doesn't exist, it is added to the end of the map.
+    Keys and values arrays must have the same length. Duplicate keys in the keys array are not allowed.
+    Null keys are ignored. Null values are preserved in the output map. For REAL and DOUBLE, NaNs (Not-a-Number) are considered equal. ::
+
+        SELECT map_update(MAP(ARRAY[1, 2, 3], ARRAY[10, 20, 30]), ARRAY[2, 4], ARRAY[200, 400]); -- {1 -> 10, 2 -> 200, 3 -> 30, 4 -> 400}
+        SELECT map_update(MAP(ARRAY['a', 'b'], ARRAY[1, 2]), ARRAY['a', 'c'], ARRAY[100, 300]); -- {'a' -> 100, 'b' -> 2, 'c' -> 300}
+        SELECT map_update(MAP(ARRAY[1], ARRAY[10]), ARRAY[1, 2], ARRAY[null, 20]); -- {1 -> null, 2 -> 20}
+        SELECT map_update(MAP(ARRAY[1, 2], ARRAY[10, 20]), ARRAY[], ARRAY[]); -- {1 -> 10, 2 -> 20}
+
 .. function:: map_concat(map1(K,V), map2(K,V), ..., mapN(K,V)) -> map(K,V)
 
    Returns the union of all the given maps. If a key is found in multiple given maps,
@@ -84,6 +107,40 @@ Map Functions
         SELECT map_normalize(map(array['a', 'b', 'c', 'd'], array[1, null, 4, 5])); -- {a=0.1, b=null, c=0.4, d=0.5}
         SELECT map_normalize(map(array['a', 'b', 'c'], array[1, 0, -1])); -- {a=Infinity, b=NaN, c=-Infinity}
 
+.. function:: map_values_in_range(map(K,V), lower_bound, upper_bound) -> map(K,V)
+
+    Returns a map containing only the entries from the input map whose values
+    fall within the specified range [lower_bound, upper_bound] (inclusive).
+    Entries with values less than lower_bound or greater than upper_bound are removed.
+    Entries with null values are preserved in the output.
+    V must be a numeric type (integer, bigint, real, or double). ::
+
+        SELECT map_values_in_range(MAP(ARRAY[1, 2, 3, 4], ARRAY[10, 20, 30, 40]), 15, 35); -- {2 -> 20, 3 -> 30}
+        SELECT map_values_in_range(MAP(ARRAY['a', 'b', 'c'], ARRAY[1.5, 2.5, 3.5]), 2.0, 3.0); -- {b -> 2.5}
+        SELECT map_values_in_range(MAP(ARRAY[1, 2], ARRAY[null, 50]), 0, 100); -- {1 -> null, 2 -> 50}
+        SELECT map_values_in_range(MAP(ARRAY[1, 2, 3], ARRAY[5, 50, 500]), 10, 100); -- {2 -> 50}
+
+.. function:: map_values_all_match(x(K,V), function(V, boolean)) -> boolean
+
+    Returns true if all values in the given map match the predicate and false otherwise. NULL if the predicate function returns NULL for one or more values and true for all other values. Equivalent to ``all_match(map_values(x), predicate)`` but avoids materializing the intermediate array. ::
+
+        SELECT map_values_all_match(map(array['a', 'b', 'c'], array[1, 2, 3]), x -> x > 0); -- true
+        SELECT map_values_all_match(map(array['a', 'b', 'c'], array[1, 2, 3]), x -> x > 1); -- false
+
+.. function:: map_values_any_match(x(K,V), function(V, boolean)) -> boolean
+
+    Returns true if one or more values in the given map match the predicate and false otherwise. NULL if the predicate function returns NULL for one or more values and false for all other values. Equivalent to ``any_match(map_values(x), predicate)`` but avoids materializing the intermediate array. ::
+
+        SELECT map_values_any_match(map(array['a', 'b', 'c'], array[1, 2, 3]), x -> x = 1); -- true
+        SELECT map_values_any_match(map(array['a', 'b', 'c'], array[1, 2, 3]), x -> x = 5); -- false
+
+.. function:: map_values_none_match(x(K,V), function(V, boolean)) -> boolean
+
+    Returns true if no values in the given map match the predicate and false otherwise. NULL if the predicate function returns NULL for one or more values and false for all other values. Equivalent to ``none_match(map_values(x), predicate)`` but avoids materializing the intermediate array. ::
+
+        SELECT map_values_none_match(map(array['a', 'b', 'c'], array[1, 2, 3]), x -> x = 5); -- true
+        SELECT map_values_none_match(map(array['a', 'b', 'c'], array[1, 2, 3]), x -> x = 1); -- false
+
 .. function:: map_remove_null_values(map(K,V)) -> map(K,V)
 
     Returns a map by removing all the keys in input map with null values. If input
@@ -94,6 +151,16 @@ Map Functions
         SELECT map_remove_null_values(MAP(ARRAY[1, 2, 3], ARRAY[3, 4, NULL])); -- {1=3, 2=4}
         SELECT map_remove_null_values(NULL); -- NULL
 
+.. function:: remap_keys(map(K,V), array(K), array(K)) -> map(K,V)
+
+      Returns a map with keys remapped according to the oldKeys and newKeys arrays.
+      Unmapped keys remain unchanged. Values are preserved. Null keys are ignored. ::
+
+          SELECT remap_keys(MAP(ARRAY[1, 2, 3], ARRAY[10, 20, 30]), ARRAY[1, 3], ARRAY[100, 300]); -- {100 -> 10, 2 -> 20, 300 -> 30}
+          SELECT remap_keys(MAP(ARRAY['a', 'b', 'c'], ARRAY[1, 2, 3]), ARRAY['a', 'c'], ARRAY['alpha', 'charlie']); -- {alpha -> 1, b -> 2, charlie -> 3}
+          SELECT remap_keys(MAP(ARRAY[1, 2, 3], ARRAY[10, null, 30]), ARRAY[1, 2], ARRAY[100, 200]); -- {100 -> 10, 200 -> null, 3 -> 30}
+          SELECT remap_keys(MAP(ARRAY[1, 2], ARRAY[10, 20]), ARRAY[], ARRAY[]); -- {1 -> 10, 2 -> 20}
+
 .. function:: map_subset(map(K,V), array(k)) -> map(K,V)
 
     Constructs a map from those entries of ``map`` for which the key is in the array given
@@ -102,8 +169,53 @@ Map Functions
         SELECT map_subset(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[10]); -- {}
         SELECT map_subset(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[1]); -- {1->'a'}
         SELECT map_subset(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[1,3]); -- {1->'a'}
-        SELECT map_subset(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[]); -- {}
         SELECT map_subset(MAP(ARRAY[], ARRAY[]), ARRAY[1,2]); -- {}
+        SELECT map_subset(MAP(ARRAY[], ARRAY[]), ARRAY[]); -- {}
+
+.. function:: map_subset_key_in_range(map(K,V), low_key, high_key) -> map(K,V)
+
+    Returns a sub-map containing only the entries from the input map whose keys fall
+    within the inclusive range ``[low_key, high_key]``. Both bounds are inclusive.
+    If ``low_key > high_key``, returns an empty map. Entries with null values are
+    preserved. If the input map, ``low_key``, or ``high_key`` is ``NULL``, the
+    result is ``NULL``. ``K`` must be an orderable type. ::
+
+        SELECT map_subset_key_in_range(MAP(ARRAY[1,2,3,4,5], ARRAY[10,20,30,40,50]), 2, 4); -- {2->20, 3->30, 4->40}
+        SELECT map_subset_key_in_range(MAP(ARRAY[7,10,14,20], ARRAY[70,100,140,200]), 7, 14); -- {7->70, 10->100, 14->140}
+        SELECT map_subset_key_in_range(MAP(ARRAY[1,2,3], ARRAY[10,20,30]), 5, 1); -- {}
+        SELECT map_subset_key_in_range(MAP(ARRAY[], ARRAY[]), 1, 10); -- {}
+
+.. function:: map_intersect(map(K,V), array(K)) -> map(K,V)
+
+    Returns a map containing only the entries from the input map whose keys are present in the given array.
+    This function is equivalent to map_subset. Null keys in the array are ignored.
+    For keys containing REAL and DOUBLE, NANs (Not-a-Number) are considered equal. ::
+
+        SELECT map_intersect(MAP(ARRAY[1,2,3], ARRAY['a','b','c']), ARRAY[1,3]); -- {1->'a', 3->'c'}
+        SELECT map_intersect(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[10]); -- {}
+        SELECT map_intersect(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[]); -- {}
+        SELECT map_intersect(MAP(ARRAY[], ARRAY[]), ARRAY[1,2]); -- {}
+
+.. function:: map_except(map(K,V), array(k)) -> map(K,V)
+
+    Constructs a map from those entries of ``map`` for which the key is not in the array given.
+    For keys containing REAL and DOUBLE, NANs (Not-a-Number) are considered equal. ::
+
+        SELECT map_except(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[10]); -- {1->'a', 2->'b'}
+        SELECT map_except(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[1]); -- {2->'b'}
+        SELECT map_except(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[1,3]); -- {2->'b'}
+        SELECT map_except(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[]); -- {1->'a', 2->'b'}
+        SELECT map_except(MAP(ARRAY[], ARRAY[]), ARRAY[1,2]); -- {}
+
+.. function:: map_keys_overlap(map(K,V), array(K)) -> boolean
+
+    Returns true if any key in the map matches any element in the given array, false otherwise.
+    Returns false if either the map or array is empty. Null keys in the array are ignored. ::
+
+        SELECT map_keys_overlap(MAP(ARRAY[1, 2, 3], ARRAY[10, 20, 30]), ARRAY[1, 5]); -- true
+        SELECT map_keys_overlap(MAP(ARRAY[1, 2, 3], ARRAY[10, 20, 30]), ARRAY[4, 5]); -- false
+        SELECT map_keys_overlap(MAP(ARRAY['a', 'b'], ARRAY[1, 2]), ARRAY['a']); -- true
+        SELECT map_keys_overlap(MAP(ARRAY[], ARRAY[]), ARRAY[1]); -- false
 
 .. function:: map_top_n(map(K,V), n) -> map(K, V)
 
@@ -114,6 +226,24 @@ Map Functions
         SELECT map_top_n(map(ARRAY['a', 'b', 'c'], ARRAY[2, 3, 1]), 2) --- {'b' -> 3, 'a' -> 2}
         SELECT map_top_n(map(ARRAY['a', 'b', 'c'], ARRAY[NULL, 3, NULL]), 2) --- {'b' -> 3, 'c' -> NULL}
 
+.. function:: map_trim_values(map(K, array(V)), n) -> map(K, array(V))
+
+    Trims the value arrays in a map to a specified maximum size.
+    This function is useful for optimizing memory usage and performance for large feature maps
+    where the value arrays may grow unbounded.
+
+    Returns a map where each value array is trimmed to at most n elements.
+    If n is negative, returns the original map unchanged.
+    If n is 0, returns a map where all values are empty arrays.
+    If a value array has fewer than n elements, it is left unchanged.
+    Null elements in the arrays are preserved in the output. ::
+
+        SELECT map_trim_values(MAP(ARRAY['a', 'b'], ARRAY[ARRAY[1, 2, 3], ARRAY[4, 5, 6, 7]]), 2); -- {a -> [1, 2], b -> [4, 5]}
+        SELECT map_trim_values(MAP(ARRAY['a'], ARRAY[ARRAY[1, 2]]), 5); -- {a -> [1, 2]}
+        SELECT map_trim_values(MAP(ARRAY['a'], ARRAY[ARRAY[1, NULL, 3]]), 2); -- {a -> [1, NULL]}
+        SELECT map_trim_values(MAP(ARRAY['a'], ARRAY[ARRAY[1, 2, 3]]), 0); -- {a -> []}
+        SELECT map_trim_values(MAP(ARRAY['a'], ARRAY[ARRAY[1, 2, 3]]), -1); -- {a -> [1, 2, 3]}
+
 .. function:: map_keys_by_top_n_values(map(K,V), n) -> array(K)
 
     Returns an array of the top N keys from a map. Keeps only the top N elements by value. Keys are used to break ties with the max key being chosen. Both keys and values should be orderable.
diff --git a/velox/docs/functions/presto/math.rst b/velox/docs/functions/presto/math.rst
index b61a623aca6..91e3cc7e6a2 100644
--- a/velox/docs/functions/presto/math.rst
+++ b/velox/docs/functions/presto/math.rst
@@ -383,6 +383,10 @@ Probability Functions: cdf
     Compute the Poisson cdf with given lambda (mean) parameter:  P(N <= value; lambda).
     The lambda parameter must be a positive real number (of type DOUBLE) and value must be a non-negative integer.
 
+.. function:: t_cdf(df, value) -> double
+
+    Compute the Student's t cdf with given degrees of freedom:  P(N < value; df).
+    The degrees of freedom must be a positive real number and value must be a real value.
 
 .. function:: weibull_cdf(a, b, value) -> double
 
@@ -455,6 +459,12 @@ Probability Functions: inverse_cdf
     probability (p): P(N < n). The df parameter must be positive real values.
     The probability p must lie on the interval [0, 1].
 
+.. function:: inverse_t_cdf(df, p) -> double
+
+    Compute the inverse of the Student's t cdf with given degrees of freedom for the cumulative
+    probability (p): P(N < n). The degrees of freedom must be a positive real value.
+    The probability p must lie on the interval [0, 1].
+
 ====================================
 Statistical Functions
 ====================================
diff --git a/velox/docs/functions/presto/qdigest.rst b/velox/docs/functions/presto/qdigest.rst
index 9b7b00dabb0..ba11449e4dd 100644
--- a/velox/docs/functions/presto/qdigest.rst
+++ b/velox/docs/functions/presto/qdigest.rst
@@ -54,6 +54,11 @@ Functions
     must be a value greater than zero and less than one, and it must be constant
     for all input rows.
 
+.. function:: scale_qdigest(qdigest(T), scale_factor) -> qdigest(T)
+
+    Returns a ``qdigest`` whose distribution has been scaled by a factor
+    specified by ``scale_factor``.
+
 .. function:: value_at_quantile(digest: qdigest<T>, quantile: double) -> T
 
     Returns the approximate percentile values from the quantile digest ``digest`` given the ``quantile``.
diff --git a/velox/docs/functions/presto/setdigest.rst b/velox/docs/functions/presto/setdigest.rst
new file mode 100644
index 00000000000..cea62df12ee
--- /dev/null
+++ b/velox/docs/functions/presto/setdigest.rst
@@ -0,0 +1,68 @@
+======================
+SetDigest Functions
+======================
+
+SetDigest is a data sketch for estimating set cardinality and performing set
+operations like intersection cardinality and Jaccard index. It combines HyperLogLog
+for cardinality estimation with MinHash for exact counting and intersection operations.
+
+SetDigests may be merged, and for storage and retrieval they may be cast to/from ``VARBINARY``.
+
+Data Structures
+---------------
+
+A SetDigest is a data sketch which stores approximate set membership and cardinality
+information. The Velox type for this data structure is called ``SetDigest``.
+SetDigests support two element types internally:
+
+* ``bigint`` - for integer values (all numeric types are converted to bigint)
+* ``varchar`` - for string values
+
+When a SetDigest is exact (cardinality is less than the maximum hash limit),
+operations like intersection cardinality return exact results. When the digest
+becomes approximate (high cardinality), it uses HyperLogLog and MinHash estimation.
+
+Serialization format is compatible with Presto's.
+
+Aggregate Functions
+-------------------
+
+.. function:: make_set_digest(x) -> SetDigest
+
+    Returns the ``SetDigest`` sketch which summarizes the input data set of ``x``.
+    Supported input types include: ``boolean``, ``tinyint``, ``smallint``, ``integer``,
+    ``bigint``, ``real``, ``double``, ``date``, ``varchar``, and ``varbinary``.
+
+.. function:: merge_set_digest(SetDigest) -> SetDigest
+
+    Returns the ``SetDigest`` of the aggregate union of the individual ``SetDigest``
+    structures.
+
+Scalar Functions
+----------------
+
+.. function:: cardinality(setdigest) -> bigint
+
+    Returns the estimated cardinality of the set represented by the ``SetDigest`` sketch.
+    If the digest is exact (low cardinality), returns the exact count.
+    Otherwise, returns an approximation using HyperLogLog.
+
+.. function:: intersection_cardinality(setdigest1, setdigest2) -> bigint
+
+    Returns the estimated intersection cardinality between two ``SetDigest`` sketches.
+
+    * If both digests are exact: returns the exact intersection count
+    * If either digest is approximate: returns an estimation using the Jaccard index
+
+    The result is capped at the minimum cardinality of the two input digests to
+    ensure logical consistency.
+
+.. function:: jaccard_index(setdigest1, setdigest2) -> double
+
+    Returns the Jaccard index (similarity coefficient) between two ``SetDigest`` sketches.
+    The Jaccard index is a value in [0, 1] where:
+
+    * 1.0 means the sets are identical
+    * 0.0 means the sets are disjoint (no overlap)
+
+    Uses MinHash estimation for efficient computation.
diff --git a/velox/docs/functions/presto/string.rst b/velox/docs/functions/presto/string.rst
index 7806bd646ee..4034ff6d652 100644
--- a/velox/docs/functions/presto/string.rst
+++ b/velox/docs/functions/presto/string.rst
@@ -19,6 +19,12 @@ String Functions
     some languages. Specifically, this will return incorrect results for
     Lithuanian, Turkish and Azeri.
 
+.. function:: bit_length(string) -> integer
+
+    Returns the bit length for the specified string column.
+
+        SELECT bit_length('123'); -- 24
+
 .. function:: chr(n) -> varchar
 
     Returns the Unicode code point ``n`` as a single character string.
@@ -60,6 +66,10 @@ String Functions
     i.e. the number of positions at which the corresponding characters are different.
     Note that the two strings must have the same length.
 
+.. function:: jarowinkler_similarity(string1, string2) -> double
+
+    Returns the Jaro-Winkler similarity of ``string1`` and ``string2``.
+
 .. function:: length(string) -> bigint
 
     Returns the length of ``string`` in characters.
@@ -69,6 +79,10 @@ String Functions
     Returns the Levenshtein edit distance of 2 strings. I.e. the minimum number of single-character edits
     (insertions, deletions or substitutions) needed to convert ``string_1`` to ``string_2``.
 
+.. function:: longest_common_prefix(string1, string2) -> varchar
+
+    Returns the longest common prefix between ``string1`` and ``string2``
+
 .. function:: lower(string) -> varchar
 
     Converts ``string`` to lowercase.
@@ -93,7 +107,7 @@ String Functions
         SELECT ltrim('test', 't'); -- est
         SELECT ltrim('tetris', 'te'); -- ris
 
-.. function:: replaceFirst(string, search, replace) -> varchar
+.. function:: replace_first(string, search, replace) -> varchar
 
     Removes the first instances of ``search`` with ``replace`` in ``string``.
 
@@ -358,3 +372,8 @@ Unicode Functions
 .. function:: to_utf8(string) -> varbinary
 
     Encodes ``string`` into a UTF-8 varbinary representation.
+
+.. function:: key_sampling_percent(varchar) -> double
+
+    Generates a double value between 0.0 and 1.0 based on the hash of the given ``varchar``.
+    This function is useful for deterministic sampling of data.
diff --git a/velox/docs/functions/presto/tdigest.rst b/velox/docs/functions/presto/tdigest.rst
index b43be2f3de6..a115ce84be7 100644
--- a/velox/docs/functions/presto/tdigest.rst
+++ b/velox/docs/functions/presto/tdigest.rst
@@ -105,6 +105,55 @@ Functions
     Returns the mean of values between ``low_quantile`` and ``high_quantile`` (inclusive) from the T-digest ``digest``.
     Both quantile values must be between zero and one (inclusive), and ``low_quantile`` must be less than or equal to ``high_quantile``.
 
+.. function:: winsorized_mean(digest: tdigest<double>, low_quantile: double, high_quantile: double) -> double
+
+    Returns the Winsorized mean from the T-digest ``digest``. Values below
+    ``low_quantile`` are replaced with the boundary value at that quantile.
+    Values above ``high_quantile`` are replaced with the boundary value at
+    that quantile. The mean is then computed on all values including the
+    replaced tails. Both quantile values must be between zero and one
+    (inclusive), and ``low_quantile`` must be less than or equal to
+    ``high_quantile``.
+
+    Unlike :func:`trimmed_mean` which excludes tail values entirely,
+    ``winsorized_mean`` replaces them with the boundary values, keeping the
+    total count unchanged.
+
+.. function:: approx_winsorized_mean(x: double, low_quantile: double, high_quantile: double) -> double
+
+    Returns the approximate Winsorized mean of all input values of ``x``
+    using a T-digest sketch. This is a single-pass aggregate that replaces
+    values below ``low_quantile`` with the boundary value at that quantile,
+    and values above ``high_quantile`` with the boundary value at that
+    quantile, then computes the mean.
+
+    ``low_quantile`` and ``high_quantile`` must be constants between zero and
+    one (inclusive), and ``low_quantile`` must be less than or equal to
+    ``high_quantile``. The default compression factor is ``100``.
+
+    This function replaces the common two-pass pattern of computing percentile
+    thresholds with ``approx_percentile`` and then capping values with
+    ``LEAST``/``GREATEST`` before computing ``AVG``.
+
+    Example::
+
+        -- Old two-pass pattern:
+        WITH t AS (
+            SELECT APPROX_PERCENTILE(x, 0.99) AS thresh FROM data
+        )
+        SELECT AVG(LEAST(data.x, t.thresh)) FROM data, t;
+
+        -- New single-pass equivalent:
+        SELECT approx_winsorized_mean(x, 0.0, 0.99) FROM data;
+
+.. function:: approx_winsorized_mean(x: double, low_quantile: double, high_quantile: double, compression: double) -> double
+   :noindex:
+
+    Like the above, but with a specified compression factor. ``compression``
+    must be a positive constant. The default is ``100``, maximum is ``1000``,
+    and values lower than ``10`` are rounded to ``10``. Higher compression
+    means more accuracy at the cost of more memory.
+
 .. function:: value_at_quantile(digest: tdigest<double>, quantile: double) -> double
 
     Returns the approximate percentile value from the T-digest ``digest`` at the given ``quantile``.
diff --git a/velox/docs/functions/spark/aggregate.rst b/velox/docs/functions/spark/aggregate.rst
index a9ac2bd001c..b94fe339f73 100644
--- a/velox/docs/functions/spark/aggregate.rst
+++ b/velox/docs/functions/spark/aggregate.rst
@@ -10,17 +10,25 @@ General Aggregate Functions
 .. spark:function:: avg(x) -> double|decimal
 
     Returns the average (arithmetic mean) of all non-null input values.
-    When x is of type DECIMAL, the result type is DECIMAL,
-    and the intermediate results are varbinarys or (sum, count) pairs represented as row(decimal, bigint).
+    When ``x`` is of type DECIMAL(p, s), the result type is DECIMAL(p + 4, s + 4),
+    and the intermediate results are (sum, count) pairs represented as ROW(DECIMAL(p + 10, s), BIGINT).
+    The current implementation for DECIMAL matches Spark avg's default behavior with spark.sql.decimalOperations.allowPrecisionLoss=true.
     For all other input types, the result type is DOUBLE,
-    and the intermediate results are (sum, count) pairs represented as row(double, bigint).
-    When all inputs are nulls, the intermediate result is row(0, 0),
+    and the intermediate results are (sum, count) pairs represented as ROW(DOUBLE, BIGINT).
+    When all inputs are nulls, the intermediate result is ROW(0, 0),
     and the final result is null.
 
 .. spark:function:: bit_xor(x) -> bigint
 
     Returns the bitwise XOR of all non-null input values, or null if none.
 
+.. spark:function:: bitmap_construct_agg(position) -> varbinary
+
+    Builds a fixed-size 4096-byte (32768-bit) bitmap by setting bits at the
+    specified positions. Input positions must be BIGINT values in [0, 32767].
+    Null inputs are ignored. Returns an all-zeros bitmap for empty or all-null
+    input (this is a non-nullable aggregate).
+
 .. spark:function:: bloom_filter_agg(hash, estimatedNumItems, numBits) -> varbinary
 
     Creates bloom filter from input hashes and returns it serialized into VARBINARY.
@@ -55,13 +63,23 @@ General Aggregate Functions
 
 .. spark:function:: collect_list(x) -> array<[same as x]>
 
-    Returns an array created from the input ``x`` elements. Ignores null
-    inputs, and returns an empty array when all inputs are null.
+    Returns an array created from the input ``x`` elements. By default,
+    ignores null inputs and returns an empty array when all inputs are null.
+
+    When the configuration property ``spark.collect_list.ignore_nulls`` is set
+    to ``false``, null values are included in the output array (RESPECT NULLS
+    behavior). In this mode, an all-null input produces an array of nulls
+    instead of an empty array.
+
+.. spark:function:: collect_set(x [, ignoreNulls]) -> array<[same as x]>
 
-.. spark:function:: collect_set(x) -> array<[same as x]>
+    Returns an array consisting of all unique values from the input ``x`` elements.
+    When ``ignoreNulls`` is ``true``, null inputs are excluded and an all-null
+    input returns an empty array. NaN values are considered distinct.
 
-    Returns an array consisting of all unique values from the input ``x`` elements excluding NULLs.
-    NaN values are considered distinct. Returns empty array if input is empty or all NULL.
+    When ``ignoreNulls`` is set to ``false`` (RESPECT NULLS), null values are
+    included in the result set. In this mode, an all-null input produces an
+    array containing a single null instead of an empty array.
 
     Example::
 
diff --git a/velox/docs/functions/spark/array.rst b/velox/docs/functions/spark/array.rst
index 42dbfe54e21..0cf2b019a91 100644
--- a/velox/docs/functions/spark/array.rst
+++ b/velox/docs/functions/spark/array.rst
@@ -171,13 +171,35 @@ Array Functions
 .. spark:function:: array_sort(array(E)) -> array(E)
 
     Returns an array which has the sorted order of the input array(E). The elements of array(E) must
-    be orderable. Null elements will be placed at the end of the returned array. ::
+    be orderable. NULL and NaN elements will be placed at the end of the returned array, with NaN elements appearing before NULL elements for floating-point types. ::
 
         SELECT array_sort(array(1, 2, 3)); -- [1, 2, 3]
         SELECT array_sort(array(3, 2, 1)); -- [1, 2, 3]
-        SELECT array_sort(array(2, 1, NULL); -- [1, 2, NULL]
+        SELECT array_sort(array(2, 1, NULL)); -- [1, 2, NULL]
         SELECT array_sort(array(NULL, 1, NULL)); -- [1, NULL, NULL]
         SELECT array_sort(array(NULL, 2, 1)); -- [1, 2, NULL]
+        SELECT array_sort(array(4.0, NULL, float('nan'), 3.0)); -- [3.0, 4.0, NaN, NULL]
+        SELECT array_sort(array(array(), array(1, 3, NULL), array(NULL, 6), NULL, array(2, 1))); -- [[], [NULL, 6], [1, 3, NULL], [2, 1], NULL]
+
+.. spark:function:: array_sort(array(E), function(E,U)) -> array(E)
+    :noindex:
+
+    Returns the array sorted by values computed using specified lambda in ascending order. ``U`` must be an orderable type.
+    NULL and NaN elements returned by the lambda function will be placed at the end of the returned array, with NaN elements appearing before NULL elements.
+    This function is not supported in Spark and is only used inside Velox for rewriting :spark:func:`array_sort(array(E), function(E,E,U)) -> array(E)` as :spark:func:`array_sort(array(E), function(E,U)) -> array(E)`. ::
+
+.. spark:function:: array_sort(array(E), function(E,E,U)) -> array(E)
+    :noindex:
+
+    Returns the array sorted by values computed using specified lambda in ascending
+    order. ``U`` must be an orderable type.
+    The function attempts to analyze the lambda function and rewrite it into a simpler call that
+    specifies the sort-by expression (like :spark:func:`array_sort(array(E), function(E,U)) -> array(E)`). For example, ``(left, right) -> if(length(left) > length(right), 1, if(length(left) < length(right), -1, 0))`` will be rewritten to ``x -> length(x)``. If rewrite is not possible, a user error will be thrown.
+    If the rewritten function returns NULL, the corresponding element will be placed at the end the returned array. Please note that due to this rewrite optimization, the NULL handling logics between Spark and Velox differ. In Spark, the position of NULL element is determined by the comparison of NULL with other elements. ::
+
+        SELECT array_sort(array('cat', 'leopard', 'mouse'), (left, right) -> if(length(left) > length(right), 1, if(length(left) < length(right), -1, 0))); -- ['cat', 'mouse', 'leopard']
+        select array_sort(array("abcd123", "abcd", NULL, "abc"), (left, right) -> if(length(left) > length(right), 1, if(length(left) < length(right), -1, 0))); -- ["abc", "abcd", "abcd123", NULL]
+        select array_sort(array("abcd123", "abcd", NULL, "abc"), (left, right) -> if(length(left) > length(right), 1, if(length(left) = length(right), 0, -1))); -- ["abc", "abcd", "abcd123", NULL] different with Spark: ["abc", NULL, "abcd", "abcd123"]
 
 .. spark:function:: array_union(array(E) x, array(E) y) -> array(E)
 
@@ -260,6 +282,21 @@ Array Functions
     Returns true if value matches at least one of the elements of the array.
     Supports BOOLEAN, REAL, DOUBLE, BIGINT, VARCHAR, TIMESTAMP, DATE, DECIMAL input types.
 
+.. spark:function:: sequence(start, stop) -> array(T)
+                    sequence(start, stop, step) -> array(T)
+
+    Generates an array of elements from ``start`` to ``stop``, incrementing by
+    ``step`` (default 1 if ``start <= stop``, otherwise -1).
+
+    Supports tinyint, smallint, integer, and bigint types for start, stop, and
+    step, preserving the input type in the result array. Also supports date
+    inputs with day-to-second or year-to-month interval step, and timestamp
+    inputs with interval step. ::
+
+        SELECT sequence(1, 5); -- [1, 2, 3, 4, 5]
+        SELECT sequence(5, 1); -- [5, 4, 3, 2, 1]
+        SELECT sequence(1, 10, 3); -- [1, 4, 7, 10]
+
 .. spark:function:: shuffle(array(E), seed) -> array(E)
 
     Generates a random permutation of the given ``array`` using a seed derived
diff --git a/velox/docs/functions/spark/conversion.rst b/velox/docs/functions/spark/conversion.rst
index 22a7da562c4..ae37c420097 100644
--- a/velox/docs/functions/spark/conversion.rst
+++ b/velox/docs/functions/spark/conversion.rst
@@ -80,9 +80,15 @@ Valid examples
 From strings
 ^^^^^^^^^^^^
 
+*(ANSI compliant)*
+
 Casting a string to an integral type is allowed if the string represents a number within the range of result type.
-Casting from strings that represent floating-point numbers truncates the decimal part of the input value.
-Casting from invalid input values throws.
+Casting from strings that represent floating-point numbers truncates the
+decimal part of the input value when ANSI mode is disabled; throws an
+error otherwise.
+
+Casting from other invalid strings returns NULL when ANSI mode is disabled;
+throws an error otherwise.
 
 Valid examples
 
@@ -91,28 +97,28 @@ Valid examples
   SELECT cast('12345' as bigint); -- 12345
   SELECT cast('+1' as tinyint); -- 1
   SELECT cast('-1' as tinyint); -- -1
-  SELECT cast('12345.67' as bigint); -- 12345
-  SELECT cast('1.2' as tinyint); -- 1
-  SELECT cast('-1.8' as tinyint); -- -1
+  SELECT cast('12345.67' as bigint); -- 12345 (ANSI OFF) / ERROR (ANSI ON)
+  SELECT cast('1.2' as tinyint); -- 1 (ANSI OFF) / ERROR (ANSI ON)
+  SELECT cast('-1.8' as tinyint); -- -1 (ANSI OFF) / ERROR (ANSI ON)
   SELECT cast('+1' as tinyint); -- 1
-  SELECT cast('1.' as tinyint); -- 1
+  SELECT cast('1.' as tinyint); -- 1 (ANSI OFF) / ERROR (ANSI ON)
   SELECT cast('-1' as tinyint); -- -1
-  SELECT cast('-1.' as tinyint); -- -1
-  SELECT cast('0.' as tinyint); -- 0
-  SELECT cast('.' as tinyint); -- 0
-  SELECT cast('-.' as tinyint); -- 0
+  SELECT cast('-1.' as tinyint); -- -1 (ANSI OFF) / ERROR (ANSI ON)
+  SELECT cast('0.' as tinyint); -- 0 (ANSI OFF) / ERROR (ANSI ON)
+  SELECT cast('.' as tinyint); -- 0 (ANSI OFF) / ERROR (ANSI ON)
+  SELECT cast('-.' as tinyint); -- 0 (ANSI OFF) / ERROR (ANSI ON)
 
 Invalid examples
 
 ::
 
-  SELECT cast('1234567' as tinyint); -- NULL // Reason: Out of range
-  SELECT cast('1a' as tinyint); -- NULL // Invalid argument
-  SELECT cast('' as tinyint); -- NULL // Invalid argument
-  SELECT cast('1,234,567' as bigint); -- NULL // Invalid argument
-  SELECT cast('1'234'567' as bigint); -- NULL // Invalid argument
-  SELECT cast('nan' as bigint); -- NULL // Invalid argument
-  SELECT cast('infinity' as bigint); -- NULL // Invalid argument
+  SELECT cast('1234567' as tinyint); -- NULL (ANSI OFF) / ERROR (ANSI ON)
+  SELECT cast('1a' as tinyint); -- NULL (ANSI OFF) / ERROR (ANSI ON)
+  SELECT cast('' as tinyint); -- NULL (ANSI OFF) / ERROR (ANSI ON)
+  SELECT cast('1,234,567' as bigint); -- NULL (ANSI OFF) / ERROR (ANSI ON)
+  SELECT cast('1'234'567' as bigint); -- NULL (ANSI OFF) / ERROR (ANSI ON)
+  SELECT cast('nan' as bigint); -- NULL (ANSI OFF) / ERROR (ANSI ON)
+  SELECT cast('infinity' as bigint); -- NULL (ANSI OFF) / ERROR (ANSI ON)
 
 From decimal
 ^^^^^^^^^^^^
@@ -132,7 +138,7 @@ Valid examples
   SELECT cast(cast(2147483648.90 as DECIMAL(12, 2)) as bigint); -- 2147483648
 
 From timestamp
-^^^^^^^^^^^^^
+^^^^^^^^^^^^^^
 
 Casting timestamp as integral types returns the number of seconds by converting timestamp as microseconds, dividing by the number of microseconds in a second, and then rounding down to the nearest second since the epoch (1970-01-01 00:00:00 UTC).
 
@@ -155,8 +161,12 @@ Cast to Boolean
 From VARCHAR
 ^^^^^^^^^^^^
 
-The strings `t, f, y, n, 1, 0, yes, no, true, false` and their upper case equivalents are allowed to be casted to boolean.
-Casting from other strings to boolean throws.
+*(ANSI compliant)*
+
+The strings `t, f, y, n, 1, 0, yes, no, true, false` and their upper case
+equivalents are allowed to be cast to boolean.
+Casting from invalid strings throws an error when ANSI mode is enabled,
+or returns NULL when ANSI mode is disabled.
 
 Valid examples
 
@@ -177,16 +187,42 @@ Invalid examples
 
 ::
 
-  SELECT cast('1.7E308' as boolean); -- NULL // Invalid argument
-  SELECT cast('nan' as boolean); -- NULL // Invalid argument
-  SELECT cast('infinity' as boolean); -- NULL // Invalid argument
-  SELECT cast('12' as boolean); -- NULL // Invalid argument
-  SELECT cast('-1' as boolean); -- NULL // Invalid argument
-  SELECT cast('tr' as boolean); -- NULL // Invalid argument
-  SELECT cast('tru' as boolean); -- NULL // Invalid argument
+  SELECT cast('1.7E308' as boolean); -- NULL (ANSI OFF) / ERROR (ANSI ON)
+  SELECT cast('nan' as boolean); -- NULL (ANSI OFF) / ERROR (ANSI ON)
+  SELECT cast('infinity' as boolean); -- NULL (ANSI OFF) / ERROR (ANSI ON)
+  SELECT cast('12' as boolean); -- NULL (ANSI OFF) / ERROR (ANSI ON)
+  SELECT cast('-1' as boolean); -- NULL (ANSI OFF) / ERROR (ANSI ON)
+  SELECT cast('tr' as boolean); -- NULL (ANSI OFF) / ERROR (ANSI ON)
+  SELECT cast('tru' as boolean); -- NULL (ANSI OFF) / ERROR (ANSI ON)
 
 Cast to String
 --------------
+From DECIMAL
+^^^^^^^^^^^^
+
+*(ANSI compliant)*
+
+Casting a DECIMAL to STRING returns a plain decimal value.
+The scale is preserved and trailing zeros are kept for normal (non-scientific) form.
+When the absolute value is less than:math:`10^{-6}`, the result is formatted in scientific notation (e.g. ``1.23E-8``).
+
+The conversion always succeeds with identical results for both ANSI ON and OFF modes.
+
+Valid examples
+
+::
+
+  SELECT cast(cast(1.00 as decimal(10, 2)) as string); -- '1.00'
+  SELECT cast(cast(12.30 as decimal(10, 2)) as string); -- '12.30'
+  SELECT cast(cast(0.00000012 as decimal(10, 8)) as string); -- '0.00000012'
+  SELECT cast(cast(-1.00 as decimal(10, 2)) as string); -- '-1.00'
+  SELECT cast(cast(123456789.123456789 as decimal(18, 9)) as string); -- '123456789.123456789'
+  SELECT cast(cast(0.00 as decimal(5, 2)) as string); -- '0.00'
+  SELECT cast(cast(999.99 as decimal(5, 2)) as string); -- '999.99'
+  SELECT cast(cast(-0.01 as decimal(3, 2)) as string); -- '-0.01'
+  SELECT cast(cast(1 as decimal(38, 20)) as string);   -- '1E-20'
+  SELECT cast(cast(0 as decimal(10, 7)) as string);   -- '0E-7'
+  SELECT cast(cast(123 as decimal(38, 10)) as string); -- '1.23E-8'
 
 From TIMESTAMP
 ^^^^^^^^^^^^^^
@@ -214,6 +250,8 @@ Cast to Date
 From strings
 ^^^^^^^^^^^^
 
+*(ANSI compliant)*
+
 All Spark supported patterns are allowed:
 
   * ``[+-](YYYY-MM-DD)``
@@ -230,7 +268,9 @@ For the last two patterns, the trailing ``*`` can represent none or any sequence
   * "1970-01-01 (BC)"
 
 All leading and trailing UTF8 white-spaces will be trimmed before cast.
-Casting from invalid input values throws.
+
+When ANSI mode is enabled, casting from invalid input values throws an error.
+When ANSI mode is disabled, casting from invalid input values returns NULL.
 
 Valid examples
 
diff --git a/velox/docs/functions/spark/datetime.rst b/velox/docs/functions/spark/datetime.rst
index d87f5819885..958179a2bf1 100644
--- a/velox/docs/functions/spark/datetime.rst
+++ b/velox/docs/functions/spark/datetime.rst
@@ -106,6 +106,15 @@ These functions support TIMESTAMP and DATE input types.
         SELECT datediff('2009-07-31', '2009-07-30'); -- 1
         SELECT datediff('2009-07-30', '2009-07-31'); -- -1
 
+.. spark:function:: dayname(date) -> varchar
+
+    Returns the three-letter abbreviated day name from the given date (Sun, Mon, Tue, Wed, Thu, Fri, Sat). ::
+
+        SELECT dayname('2009-07-30'); -- 'Thu'
+        SELECT dayname('2023-08-20'); -- 'Sun'
+        SELECT dayname('2023-08-21'); -- 'Mon'
+        SELECT dayname('1582-10-15'); -- 'Fri'
+
 .. spark:function:: dayofmonth(date) -> integer
 
     Returns the day of month of the date. ::
@@ -244,6 +253,30 @@ These functions support TIMESTAMP and DATE input types.
 
         SELECT month('2009-07-30'); -- 7
 
+.. spark:function:: monthname(date) -> varchar
+
+    Returns the three-letter abbreviated month name for the given ``date``.
+    Possible values: Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec. ::
+
+        SELECT monthname('2008-02-20'); -- 'Feb'
+        SELECT monthname('2011-05-06'); -- 'May'
+        SELECT monthname('2023-08-20'); -- 'Aug'
+        SELECT monthname('1582-10-15'); -- 'Oct'
+
+.. spark:function:: months_between(timestamp1, timestamp2, roundOff) -> double
+
+    Returns number of months between times ``timestamp1`` and ``timestamp2``.
+    If ``timestamp1`` is later than ``timestamp2``, the result is positive.
+    If ``timestamp1`` and ``timestamp2`` are on the same day of month, or both are the
+    last day of month, time of day will be ignored. Otherwise, the difference is calculated
+    based on 31 days per month, and rounded to 8 digits unless ``roundOff`` is false. ::
+
+        SELECT months_between('1997-02-28 10:30:00', '1996-10-30', true); -- 3.94959677
+        SELECT months_between('1997-02-28 10:30:00', '1996-10-30', false); -- 3.9495967741935485
+        SELECT months_between('1997-02-28 10:30:00', '1996-03-31 11:00:00', true); -- 11.0
+        SELECT months_between('1997-02-28 10:30:00', '1996-03-28 11:00:00', true); -- 11.0
+        SELECT months_between('1997-02-21 10:30:00', '1996-03-21 11:00:00', true); -- 11.0
+
 .. spark:function:: next_day(startDate, dayOfWeek) -> date
 
     Returns the first date which is later than ``startDate`` and named as ``dayOfWeek``.
@@ -273,7 +306,7 @@ These functions support TIMESTAMP and DATE input types.
 
 .. spark:function:: timestampadd(unit, value, timestamp) -> timestamp
 
-    Adds an interval ``value`` of type ``unit`` to ``timestamp``.
+    Adds an int or bigint interval ``value`` of type ``unit`` to ``timestamp``.
     Subtraction can be performed by using a negative ``value``.
     Throws exception if ``unit`` is invalid.
     ``unit`` is case insensitive and must be one of the following:
@@ -322,12 +355,14 @@ These functions support TIMESTAMP and DATE input types.
     converts the number of seconds to a timestamp. For floating-point types
     (FLOAT, DOUBLE), the function scales the input to microseconds, truncates
     towards zero, and saturates the result to the minimum and maximum values allowed
-    in Spark.::
+    in Spark. Returns NULL when ``x`` is NaN or Infinity. ::
 
         SELECT timestamp_seconds(1230219000); -- '2008-12-25 15:30:00'
         SELECT timestamp_seconds(1230219000.123); -- '2008-12-25 15:30:00.123'
         SELECT timestamp_seconds(double(1.1234567)); -- '1970-01-01 00:00:01.123456'
+        SELECT timestamp_seconds(double('inf')); -- NULL
         SELECT timestamp_seconds(float(3.4028235E+38)); -- '+294247-01-10 04:00:54.775807'
+        SELECT timestamp_seconds(float('nan')); -- NULL
 
 .. spark:function:: to_unix_timestamp(date) -> bigint
    :noindex:
diff --git a/velox/docs/functions/spark/decimal.rst b/velox/docs/functions/spark/decimal.rst
index d4b33dcbe08..1afd15d5e88 100644
--- a/velox/docs/functions/spark/decimal.rst
+++ b/velox/docs/functions/spark/decimal.rst
@@ -8,6 +8,14 @@ The result may exceed maximum allowed precision of 38.
 
 Second stage caps precision at 38 and either reduces the scale or not depending on allow-precision-loss flag.
 
+The allow-precision-loss flag applies to both regular and checked (ANSI mode) arithmetic functions.
+In Spark, there are no separate checked expression classes. The same expression (e.g., ``Add``)
+handles both ANSI and non-ANSI behavior, controlled by an ``EvalMode`` flag. In Velox, the checked
+variants are registered as separate functions (e.g., ``checked_add``, ``checked_subtract``)
+to support the TRY evaluation mode (e.g., ``try(checked_add(...))`` returns NULL on overflow).
+
+Regular functions return NULL on overflow, while checked functions throw an error.
+
 For example, addition of decimal(38, 7) and decimal(10, 0) requires precision of 39 and scale of 7.
 Since precision exceeds 38 it needs to be capped. When allow-precision-loss, precision is capped at 38 and scale is reduced by 1 to 6.
 When allow-precision-loss is false, precision is capped at 38 as well, but scale is kept at 7.
@@ -38,7 +46,7 @@ The HiveQL behavior:
 https://cwiki.apache.org/confluence/download/attachments/27362075/Hive_Decimal_Precision_Scale_Support.pdf
 
 Additionally, the computation of decimal division adapts to the allow-precision-loss flag,
-while the decimal addition, subtraction, and multiplication do not.
+while the decimal addition, subtraction, multiplication and integer division do not.
 
 Addition and Subtraction
 ~~~~~~~~~~~~~~~~~~~~~~~~
@@ -74,6 +82,15 @@ When allow-precision-loss is false:
     p = wholeDigits + fractionalDigits
     s = fractionalDigits
 
+Integer Division
+~~~~~~~~~~~~~~~~
+
+::
+
+    precision = p1 - s1 + s2
+    p = precision == 0 ? 1 : min(38,  precision)
+    s = 0
+
 Decimal Precision and Scale Adjustment
 --------------------------------------
 
@@ -112,6 +129,81 @@ Decimal division uses a different formula:
 
 Returns NULL when the actual result cannot be represented with the calculated decimal type.
 
+Arithmetic Functions
+--------------------
+
+.. spark:function:: add(x: decimal(p1, s1), y: decimal(p2, s2)) -> r: decimal(p3, s3)
+
+    Returns the result of adding ``x`` and ``y``. The result type is determined
+    by the precision and scale computation rules described above.
+    Returns NULL when the result overflows.
+    Corresponds to Spark's operator ``+`` with ``spark.sql.ansi.enabled`` set to false.  ::
+
+        SELECT CAST(1.1 as DECIMAL(3, 1)) + CAST(2.2 as DECIMAL(3, 1)); -- 3.3
+        SELECT CAST('99999999999999999999999999999999999999' as DECIMAL(38, 0)) + CAST(1 as DECIMAL(38, 0)); -- NULL
+
+.. spark:function:: checked_add(x: decimal(p1, s1), y: decimal(p2, s2)) -> r: decimal(p3, s3)
+
+    Returns the result of adding ``x`` and ``y``. The result type is determined
+    by the precision and scale computation rules described above.
+    Throws an error when the result overflows.
+    Corresponds to Spark's operator ``+`` with ``spark.sql.ansi.enabled`` set to true.
+
+.. spark:function:: checked_div(x: decimal(p1, s1), y: decimal(p2, s2)) -> bigint
+
+    Performs integer division and returns the bigint result of dividing ``x`` by ``y``, truncating toward zero.
+    Truncation occurs if the result is within the result precision but exceeds the BIGINT range.
+    Division by zero or overflow results in an error.
+    Does not have ``allow-precision-loss`` variants because ``IntegralDivide`` always returns
+    ``LongType`` (result scale is 0), so precision loss is not applicable.
+    Corresponds to Spark's operator ``div`` with ``spark.sql.ansi.enabled`` set to true.
+
+.. spark:function:: checked_multiply(x: decimal(p1, s1), y: decimal(p2, s2)) -> r: decimal(p3, s3)
+
+    Returns the result of multiplying ``x`` and ``y``. The result type is determined
+    by the precision and scale computation rules described above.
+    Throws an error when the result overflows.
+    Corresponds to Spark's operator ``*`` with ``spark.sql.ansi.enabled`` set to true.
+
+.. spark:function:: checked_subtract(x: decimal(p1, s1), y: decimal(p2, s2)) -> r: decimal(p3, s3)
+
+    Returns the result of subtracting ``y`` from ``x``. The result type is determined
+    by the precision and scale computation rules described above.
+    Throws an error when the result overflows.
+    Corresponds to Spark's operator ``-`` with ``spark.sql.ansi.enabled`` set to true.
+
+.. spark:function:: div(x: decimal(p1, s1), y: decimal(p2, s2)) -> bigint
+
+    Performs integer division and returns the bigint result of dividing ``x`` by ``y``, truncating toward zero.
+    Truncation occurs if the result is within the result precision but exceeds the BIGINT range.
+    Division by zero or overflow results in NULL. Does not respect the ``allow-precision-loss`` configuration.
+    Corresponds to Spark's operator ``div`` with ``spark.sql.ansi.enabled`` set to false.  ::
+
+        SELECT CAST(1 as DECIMAL(17, 3)) div CAST(2 as DECIMAL(17, 3)); -- 0
+        SELECT CAST(21 as DECIMAL(20, 3)) div CAST(20 as DECIMAL(20, 2)); -- 1
+        SELECT CAST(1 as DECIMAL(20, 3)) div CAST(0 as DECIMAL(20, 3)); -- NULL
+        SELECT CAST(99999999999999999999999999999999999 as DECIMAL(38, 1)) div CAST(0.001 as DECIMAL(7, 4)); -- 687399551400672280 // Result is truncated to int64_t.
+
+.. spark:function:: multiply(x: decimal(p1, s1), y: decimal(p2, s2)) -> r: decimal(p3, s3)
+
+    Returns the result of multiplying ``x`` and ``y``. The result type is determined
+    by the precision and scale computation rules described above.
+    Returns NULL when the result overflows.
+    Corresponds to Spark's operator ``*`` with ``spark.sql.ansi.enabled`` set to false.  ::
+
+        SELECT CAST(1.1 as DECIMAL(3, 1)) * CAST(2.0 as DECIMAL(3, 1)); -- 2.20
+        SELECT CAST('99999999999999999999999999999999999999' as DECIMAL(38, 0)) * CAST(10 as DECIMAL(38, 0)); -- NULL
+
+.. spark:function:: subtract(x: decimal(p1, s1), y: decimal(p2, s2)) -> r: decimal(p3, s3)
+
+    Returns the result of subtracting ``y`` from ``x``. The result type is determined
+    by the precision and scale computation rules described above.
+    Returns NULL when the result overflows.
+    Corresponds to Spark's operator ``-`` with ``spark.sql.ansi.enabled`` set to false.  ::
+
+        SELECT CAST(1.1 as DECIMAL(3, 1)) - CAST(2.2 as DECIMAL(3, 1)); -- -1.1
+        SELECT CAST('-99999999999999999999999999999999999999' as DECIMAL(38, 0)) - CAST(1 as DECIMAL(38, 0)); -- NULL
+
 Decimal Functions
 -----------------
 .. spark:function:: ceil(x: decimal(p, s)) -> r: decimal(pr, 0)
diff --git a/velox/docs/functions/spark/json.rst b/velox/docs/functions/spark/json.rst
index c5fef47a773..c7f37a7ffa5 100644
--- a/velox/docs/functions/spark/json.rst
+++ b/velox/docs/functions/spark/json.rst
@@ -59,10 +59,7 @@ JSON Functions
 .. spark:function:: get_json_object(jsonString, path) -> varchar
 
     Returns a json object, represented by VARCHAR, from ``jsonString`` by searching ``path``.
-    Valid ``path`` should start with '$' and then contain "[index]", "['field']" or ".field"
-    to define a JSON path. Here are some examples: "$.a" "$.a.b", "$[0]['a'].b". Returns
-    ``jsonString`` if ``path`` is "$". Returns NULL if ``jsonString`` or ``path`` is malformed.
-    Returns NULL if ``path`` does not exist. ::
+    Returns NULL if ``jsonString`` or ``path`` is malformed or ``path`` does not exist. ::
 
         SELECT get_json_object('{"a":"b"}', '$.a'); -- 'b'
         SELECT get_json_object('{"a":{"b":"c"}}', '$.a'); -- '{"b":"c"}'
@@ -70,6 +67,12 @@ JSON Functions
         SELECT get_json_object('{"a"-3}'', '$.a'); -- NULL (malformed JSON string)
         SELECT get_json_object('{"a":3}'', '.a'); -- NULL (malformed JSON path)
 
+    Valid ``path`` syntax:
+        * Must start with '$'.
+        * Using "[index]", "['field']" or ".field" to navigate to the desired JSON object.
+        * Whitespace is allowed **after the dot** and **before the field name**, e.g., "$.  field".
+        * Trailing whitespace after '$' is allowed, e.g., "$   ".
+
 .. spark:function:: json_array_length(jsonString) -> integer
 
     Returns the number of elements in the outermost JSON array from ``jsonString``.
diff --git a/velox/docs/functions/spark/map.rst b/velox/docs/functions/spark/map.rst
index 85532a6a12a..667cd833c56 100644
--- a/velox/docs/functions/spark/map.rst
+++ b/velox/docs/functions/spark/map.rst
@@ -51,6 +51,16 @@ Map Functions
 
         SELECT map_from_arrays(array(1.0, 3.0), array('2', '4')); -- {1.0 -> 2, 3.0 -> 4}
 
+.. spark:function:: map_from_entries(array(struct(K,V))) -> map(K,V)
+
+    Returns a map created from the given array of entries. Throws exception if duplicate key or NULL
+    key is found. Returns NULL if NULL entry exists. ::
+
+        SELECT map_from_entries(array(struct(1, 'a'), struct(2, 'null'))); -- {1 -> 'a', 2 -> 'null'}
+        SELECT map_from_entries(array(struct(1, 'a'), null)); -- {null}
+        SELECT map_from_entries(array(struct(null, 'a'))); -- "map key cannot be null"
+        SELECT map_from_entries(array(struct(1, 'a'), struct(1, 'b'))); -- "Duplicate map keys (1) are not allowed"
+
 .. spark:function:: map_keys(x(K,V)) -> array(K)
 
     Returns all the keys in the map ``x``.
diff --git a/velox/docs/functions/spark/math.rst b/velox/docs/functions/spark/math.rst
index 08a11a2b60e..a5f211b9bc6 100644
--- a/velox/docs/functions/spark/math.rst
+++ b/velox/docs/functions/spark/math.rst
@@ -2,12 +2,17 @@
 Mathematical Functions
 ======================
 
-.. spark:function:: abs(x) -> [same as x]
+.. spark:function:: abs(x) -> [same as x] (ANSI compliant)
 
     Returns the absolute value of ``x``. When ``x`` is negative minimum
-    value of integral type, returns the same value as ``x`` following
-    the behavior when Spark ANSI mode is disabled.
-
+    value of integral type returns the same value as ``x`` following
+    the behavior when Spark ANSI mode is disabled and throws exception
+    when Spark ANSI mode is enabled. ::
+
+        SELECT abs(-42); -- 42
+        SELECT abs(3.14); -- 3.14
+        SELECT abs(-128); -- 128 (with ANSI mode disabled)
+        SELECT abs(-128); -- Overflow exception (with ANSI mode enabled for TINYINT)
 .. spark:function:: acos(x) -> double
 
     Returns the inverse cosine (a.k.a. arc cosine) of ``x``.
@@ -78,7 +83,14 @@ Mathematical Functions
     Returns the result of adding x to y. The types of x and y must be the same.
     For integral types, overflow results in an error. Corresponds to Spark's operator ``+`` with ``failOnError`` as true.
 
-.. function:: checked_divide(x, y) -> [same as x]
+.. function:: checked_div(x, y) -> bigint
+
+    Returns the result of integer division of ``x`` by ``y``, truncating toward zero.
+    Supported types are integral types, ``x`` and ``y`` must have the same type.
+    Division by zero or overflow results in an error. This function operates in ANSI mode (error on invalid input).
+    Corresponds to Spark's operator ``div`` with ``spark.sql.ansi.enabled`` set to true.
+
+.. spark:function:: checked_divide(x, y) -> [same as x]
 
     Returns the results of dividing x by y. The types of x and y must be the same.
     Division by zero results in an error. Corresponds to Spark's operator ``/`` with ``failOnError`` as true.
@@ -113,6 +125,16 @@ Mathematical Functions
 
     Converts angle x in radians to degrees.
 
+.. spark:function:: div(x, y) -> bigint
+
+    Returns the results of dividing x by y. Performs the integer division truncates toward zero.
+    Supported types are integral types, x and y must have the same type.
+    Division by zero or overflow results in null. ::
+
+        SELECT 3 div 2; -- 1
+        SELECT 1L div 2L; -- 0
+        SELECT 3 div 0; -- NULL
+
 .. spark:function:: divide(x, y) -> double
 
     Returns the results of dividing x by y. Performs floating point division.
@@ -256,8 +278,8 @@ Mathematical Functions
     `spark.partition_id` to each thread (in a deterministic way) .
     ``seed`` must be constant. NULL ``seed`` is identical to zero ``seed``. ::
 
-        SELECT rand(0);    -- 0.5488135024422883
-        SELECT rand(NULL); -- 0.5488135024422883
+        SELECT rand(0);    -- 0.7604953758285915
+        SELECT rand(NULL); -- 0.7604953758285915
 
 .. spark:function:: random() -> double
 
diff --git a/velox/docs/functions/spark/misc.rst b/velox/docs/functions/spark/misc.rst
index 311586faa6f..445921ce442 100644
--- a/velox/docs/functions/spark/misc.rst
+++ b/velox/docs/functions/spark/misc.rst
@@ -2,6 +2,19 @@
 Miscellaneous Functions
 =======================
 
+.. spark:function:: assert_not_null(value) -> value
+
+    Returns the input ``value`` if it is not null. Throws an error if
+    ``value`` is null. Used to enforce NOT NULL column constraints during
+    table inserts.
+
+.. spark:function:: assert_not_null(value, errMsg) -> value
+   :noindex:
+
+    A version of ``assert_not_null`` that uses a custom error message.
+    ``errMsg`` is a constant VARCHAR specifying the error message to throw
+    when ``value`` is null.
+
 .. spark:function:: at_least_n_non_nulls(n, value1, value2, ..., valueN) -> bool
 
     Returns true if there are at least ``n`` non-null and non-NaN values,
diff --git a/velox/docs/functions/spark/string.rst b/velox/docs/functions/spark/string.rst
index 6e8c5f96de8..d39c86592c7 100644
--- a/velox/docs/functions/spark/string.rst
+++ b/velox/docs/functions/spark/string.rst
@@ -286,6 +286,27 @@ String Functions
         SELECT overlay('Spark SQL', 'tructured', 2, 4); -- "Structured SQL"
         SELECT overlay('Spark SQL', '_', -6, 3); -- "_Sql"
 
+.. spark:function:: randstr(length, seed) -> varchar
+
+    Returns a string of the specified ``length`` whose characters are chosen uniformly
+    at random from the following pool of characters: 0-9, a-z, A-Z.
+    Both ``length`` and ``seed`` must be non-null constants.
+    ``length`` must be a non-negative integer (SMALLINT or INT).
+    ``seed`` must be an integer (INT or BIGINT).
+    With the same ``seed`` and partition ID, the function produces a reproducible sequence
+    of outputs, though each row receives a different value from the sequence as the
+    internal generator advances.
+    The partition ID is retrieved from the ``spark_partition_id`` query configuration.
+    It's consistent with Spark's internal assignment for tasks.
+    Uses XORShift random number generator matching Spark's implementation.
+    Note: Spark's analyzer always provides a seed (either user-specified or
+    auto-generated), so only the seeded variant is implemented.
+    This function was added in Spark 4.0. ::
+
+        SELECT randstr(5, 0);  -- "ceV0P" (reproducible with seed)
+        SELECT randstr(10, 0); -- "ceV0PXaR2I"
+        SELECT randstr(0, 42); -- ""
+
 .. spark:function:: read_side_padding(string, limit) -> varchar
 
     Right-pads the given string with spaces to the specified length ``limit``.
@@ -458,6 +479,26 @@ String Functions
         SELECT substring_index('aaaaa', 'aa', 5); -- "aaaaa"
         SELECT substring_index('aaaaa', 'aa', -5); -- "aaaaa"
 
+.. spark:function:: to_pretty_string(x) -> varchar
+
+    Returns pretty string for ``x``. All scalar types are supported.
+    Adjusts the timestamp input to the given time zone if set through ``session_timezone`` config.
+    The result is different from that of casting ``x`` as string in the following aspects.
+
+    - It prints null input as "NULL" rather than producing null output.
+
+    - It prints binary values using the hex format.
+
+    ::
+
+        SELECT to_pretty_string(4); -- "4"
+        SELECT to_pretty_string(cast("1.0" as float)); -- "1.0"
+        SELECT to_pretty_string("spark"); -- "spark"
+        SELECT to_pretty_string(cast('abcdef' as binary)); -- "[61 62 63 64 65 66]"
+        SELECT to_pretty_string(null); -- "NULL"
+        SELECT to_pretty_string(cast(2347589 as timestamp)); -- "1970-01-28 12:06:29"
+        SELECT to_pretty_string(cast('2024-05-08' as date)); -- "2024-05-08"
+
 .. spark:function:: translate(string, match, replace) -> varchar
 
     Returns a new translated string. It translates the character in ``string`` by a
diff --git a/velox/docs/index.rst b/velox/docs/index.rst
index 8fb3f14161b..f1d65f2065e 100644
--- a/velox/docs/index.rst
+++ b/velox/docs/index.rst
@@ -10,6 +10,7 @@ Velox Documentation
     functions
     spark_functions
     functions/iceberg/functions
+    functions/delta/functions
     configs
     monitoring
     bindings/python/index
diff --git a/velox/docs/monitoring/metrics.rst b/velox/docs/monitoring/metrics.rst
index 2764a1c46dd..f16bfe0530e 100644
--- a/velox/docs/monitoring/metrics.rst
+++ b/velox/docs/monitoring/metrics.rst
@@ -93,13 +93,16 @@ Task Execution
        30 buckets. It is configured to report the latency at P50, P90, P99,
        and P100 percentiles.
    * - task_batch_process_time_ms
-     - Average
+     - Avg
      - Tracks the averaged task batch processing time. This only applies for
        sequential task execution mode.
    * - task_barrier_process_time_ms
      - Histogram
      - Tracks task barrier execution time in range of [0, 30s] with 30 buckets
        and each bucket with time window of 1s. We report P50, P90, P99, and P100.
+   * - task_splits_count
+     - Count
+     - The total number of splits received by all tasks.
 
 Memory Management
 -----------------
@@ -160,9 +163,6 @@ Memory Management
    * - task_memory_reclaim_wait_timeout_count
      - Count
      - The number of times that the task memory reclaim wait timeouts.
-   * - task_splits_count
-     - Count
-     - The total number of splits received by all tasks.
    * - memory_non_reclaimable_count
      - Count
      - The number of times that the memory reclaim fails because the operator is executing a
@@ -226,11 +226,11 @@ Memory Management
        arbitration operation in range of [0, 600s] with 20 buckets. It is configured
        to report the latency at P50, P90, P99 and P100 percentiles.
    * - arbitrator_free_capacity_bytes
-     - Average
+     - Avg
      - The average of total free memory capacity which is managed by the
        memory arbitrator.
    * - arbitrator_free_reserved_capacity_bytes
-     - Average
+     - Avg
      - The average of free memory capacity reserved to ensure each query has
        the minimal required capacity to run.
    * - memory_pool_initial_capacity_bytes
@@ -292,9 +292,12 @@ Cache
      - Avg
      - Max possible age of AsyncDataCache and SsdCache entries since the raw file
        was opened to load the cache.
-   * - memory_cache_num_entries
+   * - memory_cache_num_large_entries
+     - Avg
+     - Total number of large cache entries.
+   * - memory_cache_num_tiny_entries
      - Avg
-     - Total number of cache entries.
+     - Total number of tiny cache entries.
    * - memory_cache_num_empty_entries
      - Avg
      - Total number of cache entries that do not cache anything.
@@ -416,9 +419,15 @@ Cache
    * - ssd_cache_write_ssd_errors
      - Sum
      - Total number of error while writing to SSD cache files.
+   * - ssd_cache_write_no_space_errors
+     - Sum
+     - Total number of errors due to SSD no space for writes.
    * - ssd_cache_write_ssd_dropped
      - Sum
      - Total number of writes dropped due to no cache space.
+   * - ssd_cache_write_exceed_entry_limit
+     - Sum
+     - Total number of writes dropped due to entry limit exceeded.
    * - ssd_cache_write_checkpoint_errors
      - Sum
      - Total number of errors while writing SSD checkpoint file.
@@ -511,9 +520,9 @@ Spilling
      - The distribution of the amount of time spent on serializing rows for
        spilling in range of [0, 600s] with 20 buckets. It is configured to report
        the latency at P50, P90, P99, and P100 percentiles.
-   * - spill_disk_writes_count
+   * - spill_writes_count
      - Count
-     - The number of disk writes to spill rows.
+     - The number of Velox filesystem write calls to spill rows.
    * - spill_flush_time_ms
      - Histogram
      - The distribution of the amount of time spent on copy out serialized
@@ -619,6 +628,9 @@ Index Join
      - The distribution of index lookup result bytes in range of [0, 128MB] with
        128 buckets. It is configured to report the capacity at P50, P90, P99, and
        P100 percentiles.
+   * - index_lookup_error_result_count
+     - Count
+     - The number of results with error.
 
 Table Scan
 ----------
@@ -631,10 +643,10 @@ Table Scan
      - Type
      - Description
    * - table_scan_batch_process_time_ms
-     - Average
+     - Avg
      - Tracks the averaged table scan batch processing time in milliseconds.
    * - table_scan_batch_bytes
-     - Average
+     - Avg
      - Tracks the averaged table scan output batch size in bytes.
        with 512 buckets and reports P50, P90, P99, and P100
 
diff --git a/velox/docs/monitoring/stats.rst b/velox/docs/monitoring/stats.rst
index f6823991773..aa14d81d78e 100644
--- a/velox/docs/monitoring/stats.rst
+++ b/velox/docs/monitoring/stats.rst
@@ -104,6 +104,11 @@ These stats are reported only by TableScan operator
    * - numRunningScanThreads
      -
      - The number of running table scan drivers.
+   * - fileFormat.<format>
+     -
+     - The number of splits read for each file format (e.g. fileFormat.dwrf,
+       fileFormat.parquet, fileFormat.nimble). Reported per format encountered
+       during the query.
 
 TableWriter
 -----------
@@ -157,17 +162,34 @@ These stats are reported only by IndexLookupJoin operator
    * - Stats
      - Unit
      - Description
+   * - connectorIndexReadCpuNanos
+     - nanos
+     - CPU time spent reading index data from the index reader (e.g. stripe I/O, decoding).
+   * - connectorIndexReadWallNanos
+     - nanos
+     - Wall time spent reading index data from the index reader (e.g. stripe I/O, decoding).
+   * - connectorIndexSetupCpuNanos
+     - nanos
+     - CPU time spent initializing the index lookup (startLookup).
+   * - connectorIndexSetupWallNanos
+     - nanos
+     - Wall time spent initializing the index lookup (startLookup).
    * - connectorlookupWallNanos
      - nanos
-     - The end-to-end walltime in nanoseconds that the index connector do the lookup.
+     - End-to-end wall time for the index connector lookup (sum of setup, read, output, and filter).
    * - connectorlookupWaitWallNanos
      - nanos
      - The walltime in nanoseconds that the index connector wait for the lookup from
        remote storage.
+   * - connectorPostFilterCpuNanos
+     - nanos
+     - CPU time spent evaluating the remaining filter on index lookup results.
+   * - connectorPostFilterWallNanos
+     - nanos
+     - Wall time spent evaluating the remaining filter on index lookup results.
    * - connectorResultPrepareCpuNanos
      - nanos
-     - The cpu time in nanoseconds that the index connector process response from storages
-       client for followup processing by index join operator.
+     - CPU time spent projecting output columns from index reader results.
    * - clientlookupWaitWallNanos
      - nanos
      - The walltime in nanoseconds that the storage client wait for the lookup from remote storage.
@@ -192,6 +214,9 @@ These stats are reported only by IndexLookupJoin operator
    * - clientNumLazyDecodedResultBatches
      -
      - The number of lazy decoded result batches returned from the storage client.
+   * - numIndexSplits
+     -
+     - The number of index splits provided for index lookup.
 
 Merge
 -----
@@ -342,6 +367,177 @@ These stats are reported only by connector data or index sources.
    * - Stats
      - Unit
      - Description
+   * - ioWaitWallNanos
+     - nanos
+     - Total time spent by query processing threads waiting for I/O operations
+       to complete. This includes waiting for synchronously issued I/O or for
+       in-progress read-ahead operations to finish.
+   * - storageReadWallNanos
+     - nanos
+     - Time spent waiting for direct remote storage reads (e.g., S3, HDFS).
+       This is a component of ioWaitWallNanos.
+   * - ssdCacheReadWallNanos
+     - nanos
+     - Time spent waiting for SSD cache reads. This is a component of
+       ioWaitWallNanos.
+   * - cacheWaitWallNanos
+     - nanos
+     - Time spent waiting for cache entries that are being loaded by another
+       thread (EXCLUSIVE state). This is a component of ioWaitWallNanos.
+   * - coalescedSsdLoadWallNanos
+     - nanos
+     - Time spent waiting for coalesced loads from SSD cache. This occurs when
+       multiple requests are combined into a single SSD read operation.
+       This is a component of ioWaitWallNanos.
+   * - coalescedStorageLoadWallNanos
+     - nanos
+     - Time spent waiting for coalesced loads from remote storage. This occurs
+       when multiple requests are combined into a single remote storage read.
+       This is a component of ioWaitWallNanos.
    * - totalRemainingFilterWallNanos
      - nanos
      - The total walltime in nanoseconds that the data or index connector do the remaining filtering.
+   * - totalRemainingFilterCpuNanos
+     - nanos
+     - The total CPU time in nanoseconds that the data or index connector do the remaining filtering.
+   * - numIndexReaderOutputRows
+     -
+     - The total number of output rows returned across all next() calls from the
+       index reader. This is the final row count after cluster index bounds
+       and ScanSpec filter pushdown.
+   * - numIndexFilterConversions
+     -
+     - The number of index columns that were converted from ScanSpec filters to
+       index bounds for index-based filtering (e.g., cluster index pruning in
+       Nimble). A value greater than zero indicates filters were successfully
+       converted to leverage file index structures for row pruning.
+   * - numIndexLookupReadSegments
+     -
+     - The total number of read segments across all stripes during index lookup.
+       A read segment is a contiguous row range within a stripe that needs to be
+       read. When filters are present, overlapping request ranges are split at
+       boundaries to enable per-request output tracking. Without filters,
+       overlapping ranges are merged to minimize I/O.
+   * - numIndexLookupRequests
+     -
+     - The number of index lookup requests submitted in startLookup(). Each
+       request corresponds to one set of index bounds and may match rows across
+       multiple stripes.
+   * - numIndexLookupStripes
+     -
+     - The total number of stripes that need to be read for all index lookup
+       requests. Within a single startLookup() call, a stripe shared by
+       multiple requests is counted once; across different startLookup() calls,
+       the same stripe is counted separately for each call.
+   * - numIndexMatchedRows
+     -
+     - The total number of rows matched by the cluster index across all stripes.
+       These are the rows identified as matching the lookup bounds within each
+       stripe, before any ScanSpec filter pushdown. Comparing with actual output
+       rows shows filter selectivity.
+   * - numIndexScannedRows
+     -
+     - The total number of rows in all loaded stripes during index lookup.
+       Measures the full stripe row count regardless of how many rows are
+       actually needed. Comparing with numIndexMatchedRows shows cluster index
+       selectivity within stripes.
+   * - numStripeLoads
+     -
+     - The number of times a stripe has been loaded during index lookup. This
+       metric helps track the I/O efficiency of index-based reads, where lower
+       values indicate better stripe reuse across lookups.
+   * - numIndexDistinctStripesLoaded
+     -
+     - The number of distinct stripes loaded across the lifetime of the index
+       reader. Comparing with numStripeLoads (which counts every load call)
+       reveals redundant loads of the same stripe.
+   * - indexStripeLoadWallNanos
+     - nanos
+     - Wall time spent loading stripes (or equivalent format-specific load
+       unit) during index lookup, summed across all stripe loads.
+   * - indexStripeLoadCpuNanos
+     - nanos
+     - CPU time spent loading stripes during index lookup. May undercount on
+       async/prefetch paths.
+   * - indexDataDecodeWallNanos
+     - nanos
+     - Wall time spent decoding column data from loaded stripes during index
+       lookup, summed across all read segments.
+   * - indexDataDecodeCpuNanos
+     - nanos
+     - CPU time spent decoding column data from loaded stripes during index
+       lookup. Same prefetch undercounting caveat as indexStripeLoadCpuNanos.
+
+FileBasedDataSource
+-------------------
+These stats are reported by the file-based connector data source (Hive connector).
+Data stream IO stats use the stat names directly (e.g., ``storageReadBytes``).
+Metadata IO stats (footer, stripe groups, index) use a ``metadata.`` prefix
+(e.g., ``metadata.storageReadBytes``, ``metadata.ramReadBytes``).
+
+.. list-table::
+   :widths: 50 25 50
+   :header-rows: 1
+
+   * - Stats
+     - Unit
+     - Description
+   * - skippedSplits
+     -
+     - The number of splits skipped based on file statistics.
+   * - processedSplits
+     -
+     - The number of splits processed.
+   * - skippedSplitBytes
+     - bytes
+     - The total bytes in splits skipped based on file statistics.
+   * - skippedStrides
+     -
+     - The number of strides (row groups) skipped based on statistics.
+   * - processedStrides
+     -
+     - The number of strides (row groups) processed.
+   * - footerBufferOverread
+     - bytes
+     - The number of extra bytes read beyond the footer size due to buffer
+       over-reading.
+   * - numStripes
+     -
+     - The number of stripes read from the file.
+   * - flattenStringDictionaryValues
+     -
+     - The number of rows returned by the string dictionary reader that were
+       flattened instead of keeping dictionary encoding.
+   * - pageLoadTimeNs
+     - nanos
+     - The total time spent loading pages.
+   * - numPrefetch
+     -
+     - The number of prefetch operations issued.
+   * - prefetchBytes
+     - bytes
+     - The total bytes prefetched, including min and max per prefetch operation.
+   * - totalScanTime
+     - nanos
+     - The total wall time spent scanning the file.
+   * - overreadBytes
+     - bytes
+     - The total raw bytes over-read during I/O operations.
+   * - storageReadBytes
+     - bytes
+     - The total bytes read from remote storage, including min and max per read
+       operation.
+   * - numLocalRead
+     -
+     - The number of reads served from the local SSD cache.
+   * - localReadBytes
+     - bytes
+     - The total bytes read from the local SSD cache, including min and max per
+       read operation.
+   * - numRamRead
+     -
+     - The number of reads served from the in-memory (RAM) cache.
+   * - ramReadBytes
+     - bytes
+     - The total bytes read from the in-memory (RAM) cache, including min and
+       max per read operation.
diff --git a/velox/docs/monthly-updates/may-2025.rst b/velox/docs/monthly-updates/may-2025.rst
index fcacf090853..d049377a9a5 100644
--- a/velox/docs/monthly-updates/may-2025.rst
+++ b/velox/docs/monthly-updates/may-2025.rst
@@ -1,6 +1,6 @@
-**************
+***************
 May 2025 Update
-**************
+***************
 
 This update was generated with the assistance of AI. While we strive for accuracy, please note
 that AI-generated content may not always be error-free. We encourage you to verify any information
diff --git a/velox/duckdb/conversion/CMakeLists.txt b/velox/duckdb/conversion/CMakeLists.txt
index 010f13f8f35..d9a8de03642 100644
--- a/velox/duckdb/conversion/CMakeLists.txt
+++ b/velox/duckdb/conversion/CMakeLists.txt
@@ -11,11 +11,11 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-velox_add_library(velox_duckdb_conversion DuckConversion.cpp)
+velox_add_library(velox_duckdb_conversion DuckConversion.cpp HEADERS DuckConversion.h)
 
 velox_link_libraries(velox_duckdb_conversion velox_core velox_vector duckdb_static)
 
-velox_add_library(velox_duckdb_parser DuckParser.cpp)
+velox_add_library(velox_duckdb_parser DuckParser.cpp HEADERS DuckParser.h)
 
 velox_link_libraries(
   velox_duckdb_parser
diff --git a/velox/duckdb/conversion/DuckConversion.cpp b/velox/duckdb/conversion/DuckConversion.cpp
index 10fc820c6b1..19dce42cd86 100644
--- a/velox/duckdb/conversion/DuckConversion.cpp
+++ b/velox/duckdb/conversion/DuckConversion.cpp
@@ -79,6 +79,10 @@ LogicalType fromVeloxType(const TypePtr& type) {
       if (type->isIntervalDayTime()) {
         return LogicalType::INTERVAL;
       }
+      if (type->isTime()) {
+        VELOX_DCHECK(type->equivalent(*TIME()));
+        return LogicalType::TIME;
+      }
       return LogicalType::BIGINT;
     case TypeKind::REAL:
       return LogicalType::FLOAT;
@@ -138,6 +142,8 @@ TypePtr toVeloxType(LogicalType type, bool fileColumnNamesReadAsLowerCase) {
       return VARCHAR();
     case LogicalTypeId::DATE:
       return DATE();
+    case LogicalTypeId::TIME:
+      return TIME();
     case LogicalTypeId::TIMESTAMP:
       return TIMESTAMP();
     case LogicalTypeId::TIMESTAMP_TZ: {
@@ -192,6 +198,9 @@ TypePtr toVeloxType(LogicalType type, bool fileColumnNamesReadAsLowerCase) {
       if (auto customType = getCustomType(name, {})) {
         return customType;
       }
+      if (name == "OPAQUE<void>") {
+        return OPAQUE<void>();
+      }
       [[fallthrough]];
     }
     default:
diff --git a/velox/duckdb/conversion/DuckParser.cpp b/velox/duckdb/conversion/DuckParser.cpp
index d65406f693e..89532695bd0 100644
--- a/velox/duckdb/conversion/DuckParser.cpp
+++ b/velox/duckdb/conversion/DuckParser.cpp
@@ -133,6 +133,16 @@ std::shared_ptr<const core::CallExpr> callExpr(
     std::vector<core::ExprPtr> params,
     std::optional<std::string> alias,
     const ParseOptions& options) {
+  // DuckDB parser requires IF to have 3 arguments: condition, then-clause, and
+  // else-clause. For example, `IF(a > b, 10)` doesn't parse correctly and must
+  // be written as `IF(a > b, 10, null)`. Remove the redundant else-clause.
+  if (name == "if") {
+    if (params.back()->is(core::IExpr::Kind::kConstant) &&
+        params.back()->as<core::ConstantExpr>()->type()->isUnknown()) {
+      params.pop_back();
+    }
+  }
+
   return std::make_shared<const core::CallExpr>(
       toFullFunctionName(name, options.functionPrefix),
       std::move(params),
@@ -259,6 +269,55 @@ std::shared_ptr<const core::ConstantExpr> tryParseInterval(
       INTERVAL_DAY_TIME(), Variant(value.value() * multiplier), alias);
 }
 
+// DuckDB parses struct literals {'x': 1, 'y': 2} as struct_pack(1 AS x, 2 AS
+// y) and ROW(1, 2) as row(1, 2). Folds into a ROW constant when all arguments
+// are constants. Returns nullptr otherwise.
+core::ExprPtr tryFoldRowConstant(
+    const std::vector<core::ExprPtr>& inputs,
+    const std::optional<std::string>& alias) {
+  std::vector<std::string> names;
+  std::vector<TypePtr> types;
+  std::vector<Variant> values;
+  names.reserve(inputs.size());
+  types.reserve(inputs.size());
+  values.reserve(inputs.size());
+  for (const auto& input : inputs) {
+    auto* constant = input->as<core::ConstantExpr>();
+    if (!constant) {
+      return nullptr;
+    }
+    names.push_back(constant->alias().value_or(""));
+    types.push_back(constant->type());
+    values.push_back(constant->value());
+  }
+  return std::make_shared<const core::ConstantExpr>(
+      ROW(std::move(names), std::move(types)),
+      Variant::row(std::move(values)),
+      alias);
+}
+
+// DuckDB parses [1, 2, 3] as list_value(1, 2, 3). Folds into an ARRAY constant
+// when all arguments are constants. Returns nullptr otherwise.
+core::ExprPtr tryFoldArrayConstant(
+    const std::vector<core::ExprPtr>& inputs,
+    const std::optional<std::string>& alias) {
+  std::vector<Variant> elements;
+  elements.reserve(inputs.size());
+  TypePtr elementType = UNKNOWN();
+  for (const auto& input : inputs) {
+    auto* constant = input->as<core::ConstantExpr>();
+    if (!constant) {
+      return nullptr;
+    }
+    elements.push_back(constant->value());
+    if (!constant->value().isNull()) {
+      elementType = constant->type();
+    }
+  }
+  return std::make_shared<const core::ConstantExpr>(
+      ARRAY(elementType), Variant::array(std::move(elements)), alias);
+}
+
 // Parse a function call (avg(a), func(1, b), etc).
 // Arithmetic operators also follow this path (a + b, a * b, etc).
 core::ExprPtr parseFunctionExpr(
@@ -279,6 +338,20 @@ core::ExprPtr parseFunctionExpr(
     }
   }
 
+  if (func == "struct_pack" || func == "row") {
+    if (auto rowConstant = tryFoldRowConstant(params, getAlias(expr))) {
+      return rowConstant;
+    }
+  }
+
+  // DuckDB parses [1, 2, 3] as list_value(1, 2, 3). Fold into an ARRAY
+  // constant when all arguments are constants.
+  if (func == "list_value") {
+    if (auto arrayConstant = tryFoldArrayConstant(params, getAlias(expr))) {
+      return arrayConstant;
+    }
+  }
+
   // NOT LIKE function needs special handling as it maps to two functions
   // "not" and "like".
   if (func == "notlike") {
@@ -327,10 +400,11 @@ core::ExprPtr parseConjunctionExpr(
       StringUtil::Lower(ExpressionTypeToOperator(expr.GetExpressionType()));
 
   if (conjExpr.children.size() < 2) {
-    throw std::invalid_argument(folly::sformat(
-        "Malformed conjunction expression "
-        "(expected at least 2 input columns, got {}).",
-        conjExpr.children.size()));
+    throw std::invalid_argument(
+        folly::sformat(
+            "Malformed conjunction expression "
+            "(expected at least 2 input columns, got {}).",
+            conjExpr.children.size()));
   }
 
   // DuckDB's parser returns conjunction involving multiple input in a flat
@@ -380,6 +454,10 @@ core::ExprPtr parseOperatorExpr(
         if (auto constantExpr =
                 dynamic_cast<ConstantExpression*>(child.get())) {
           auto& value = constantExpr->value;
+          if (value.type().id() == LogicalTypeId::INTEGER &&
+              options.parseIntegerAsBigint) {
+            value = Value::BIGINT(value.GetValue<int32_t>());
+          }
           if (options.parseDecimalAsDouble &&
               value.type().id() == duckdb::LogicalTypeId::DECIMAL) {
             value = Value::DOUBLE(value.GetValue<double>());
@@ -463,8 +541,9 @@ core::ExprPtr parseOperatorExpr(
     }
 
     if (options.parseInListAsArray) {
-      params.emplace_back(std::make_shared<const core::ConstantExpr>(
-          ARRAY(valueType), Variant::array(values), std::nullopt));
+      params.emplace_back(
+          std::make_shared<const core::ConstantExpr>(
+              ARRAY(valueType), Variant::array(values), std::nullopt));
     }
     auto inExpr = callExpr("in", std::move(params), getAlias(expr), options);
     // Translate COMPARE_NOT_IN into NOT(IN()).
@@ -595,6 +674,23 @@ core::ExprPtr parseCastExpr(
             getAlias(expr));
       }
     }
+
+    // DuckDB parses DATE '...' and '...'::date as cast(varchar as DATE).
+    // Fold into a DATE constant.
+    if (targetType->isDate() && constant->type()->isVarchar()) {
+      const auto& value = constant->value().value<TypeKind::VARCHAR>();
+      return std::make_shared<const core::ConstantExpr>(
+          DATE(),
+          Variant::create<TypeKind::INTEGER>(DATE()->toDays(value)),
+          getAlias(expr));
+    }
+
+    // ROW(1, 2)::struct(x bigint, y bigint) — re-type the ROW constant with
+    // the target type (which carries field names). Child types must match.
+    if (targetType->isRow() && targetType->equivalent(*constant->type())) {
+      return std::make_shared<const core::ConstantExpr>(
+          targetType, constant->value(), getAlias(expr));
+    }
   }
 
   const bool isTryCast = castExpr.try_cast;
@@ -693,7 +789,8 @@ std::unique_ptr<::duckdb::ParsedExpression> parseSingleExpression(
   auto parsed = parseExpression(exprString);
   VELOX_CHECK_EQ(
       1, parsed.size(), "Expected exactly one expression: {}.", exprString);
-  return std::move(parsed.front());
+  auto result = std::move(parsed.front());
+  return result;
 }
 } // namespace
 
@@ -753,7 +850,7 @@ bool isNullsFirst(
 }
 } // namespace
 
-OrderByClause parseOrderByExpr(const std::string& exprString) {
+parse::OrderByClause parseOrderByExpr(const std::string& exprString) {
   ParserOptions options;
   ParseOptions parseOptions;
   options.preserve_identifier_case = false;
@@ -775,49 +872,54 @@ OrderByClause parseOrderByExpr(const std::string& exprString) {
       .nullsFirst = nullsFirst};
 }
 
-AggregateExpr parseAggregateExpr(
+core::AggregateCallExprPtr parseAggregateExpr(
     const std::string& exprString,
     const ParseOptions& options) {
   auto parsedExpr = parseSingleExpression(exprString);
 
   auto& functionExpr = dynamic_cast<FunctionExpression&>(*parsedExpr);
 
-  AggregateExpr aggregateExpr;
-  aggregateExpr.expr = parseExpr(*parsedExpr, options);
-  aggregateExpr.distinct = functionExpr.distinct;
+  auto callExpr = parseExpr(*parsedExpr, options);
 
+  std::vector<core::SortKey> orderBy;
   if (functionExpr.order_bys) {
     for (const auto& orderByNode : functionExpr.order_bys->orders) {
-      const bool ascending = isAscending(orderByNode.type, exprString);
-      const bool nullsFirst = isNullsFirst(orderByNode.null_order, exprString);
-      aggregateExpr.orderBy.emplace_back(OrderByClause{
-          parseExpr(*orderByNode.expression, options), ascending, nullsFirst});
+      orderBy.push_back(
+          {parseExpr(*orderByNode.expression, options),
+           isAscending(orderByNode.type, exprString),
+           isNullsFirst(orderByNode.null_order, exprString)});
     }
   }
 
+  core::ExprPtr filter;
   if (functionExpr.filter) {
-    aggregateExpr.maskExpr = parseExpr(*functionExpr.filter, options);
+    filter = parseExpr(*functionExpr.filter, options);
   }
 
-  return aggregateExpr;
+  auto* call = callExpr->as<core::CallExpr>();
+  return std::make_shared<core::AggregateCallExpr>(
+      call->name(),
+      call->inputs(),
+      functionExpr.distinct,
+      std::move(filter),
+      std::move(orderBy),
+      callExpr->alias());
 }
 
 namespace {
+
+using WindowType = core::WindowCallExpr::WindowType;
+using BoundType = core::WindowCallExpr::BoundType;
+
 WindowType parseWindowType(const WindowExpression& expr) {
-  auto windowType = [&](const WindowBoundary& boundary) -> WindowType {
-    if (boundary == WindowBoundary::CURRENT_ROW_ROWS ||
+  auto isRows = [](const WindowBoundary& boundary) {
+    return boundary == WindowBoundary::CURRENT_ROW_ROWS ||
         boundary == WindowBoundary::EXPR_FOLLOWING_ROWS ||
-        boundary == WindowBoundary::EXPR_PRECEDING_ROWS) {
-      return WindowType::kRows;
-    }
-    return WindowType::kRange;
+        boundary == WindowBoundary::EXPR_PRECEDING_ROWS;
   };
 
-  auto startType = windowType(expr.start);
-  if (startType == WindowType::kRows) {
-    return startType;
-  }
-  return windowType(expr.end);
+  return (isRows(expr.start) || isRows(expr.end)) ? WindowType::kRows
+                                                  : WindowType::kRange;
 }
 
 BoundType parseBoundType(WindowBoundary boundary) {
@@ -841,29 +943,23 @@ BoundType parseBoundType(WindowBoundary boundary) {
   VELOX_UNREACHABLE();
 }
 
-} // namespace
-
-IExprWindowFunction parseWindowExpr(
+core::WindowCallExprPtr buildWindowCallExpr(
+    ParsedExpression& parsedExpr,
     const std::string& windowString,
     const ParseOptions& options) {
-  auto parsedExpr = parseSingleExpression(windowString);
-  VELOX_CHECK(
-      parsedExpr->IsWindow(),
-      "Invalid window function expression: {}",
-      windowString);
+  auto& windowExpr = dynamic_cast<WindowExpression&>(parsedExpr);
 
-  IExprWindowFunction windowIExpr;
-  auto& windowExpr = dynamic_cast<WindowExpression&>(*parsedExpr);
-  for (int i = 0; i < windowExpr.partitions.size(); i++) {
-    windowIExpr.partitionBy.push_back(
-        parseExpr(*(windowExpr.partitions[i].get()), options));
+  std::vector<core::ExprPtr> partitionKeys;
+  for (const auto& partition : windowExpr.partitions) {
+    partitionKeys.push_back(parseExpr(*partition, options));
   }
 
+  std::vector<core::SortKey> orderByKeys;
   for (const auto& orderByNode : windowExpr.orders) {
-    const bool ascending = isAscending(orderByNode.type, windowString);
-    const bool nullsFirst = isNullsFirst(orderByNode.null_order, windowString);
-    windowIExpr.orderBy.emplace_back(OrderByClause{
-        parseExpr(*orderByNode.expression, options), ascending, nullsFirst});
+    orderByKeys.push_back(
+        {parseExpr(*orderByNode.expression, options),
+         isAscending(orderByNode.type, windowString),
+         isNullsFirst(orderByNode.null_order, windowString)});
   }
 
   std::vector<core::ExprPtr> params;
@@ -880,32 +976,58 @@ IExprWindowFunction parseWindowExpr(
     params.emplace_back(parseExpr(*windowExpr.default_expr, options));
   }
 
-  auto func = normalizeFuncName(windowExpr.function_name);
-  windowIExpr.functionCall =
-      callExpr(func, std::move(params), getAlias(windowExpr), options);
-
-  windowIExpr.ignoreNulls = windowExpr.ignore_nulls;
-
-  windowIExpr.frame.type = parseWindowType(windowExpr);
-  windowIExpr.frame.startType = parseBoundType(windowExpr.start);
+  core::ExprPtr startValue;
   if (windowExpr.start_expr) {
-    windowIExpr.frame.startValue =
-        parseExpr(*windowExpr.start_expr.get(), options);
+    startValue = parseExpr(*windowExpr.start_expr, options);
   }
-
-  windowIExpr.frame.endType = parseBoundType(windowExpr.end);
+  core::ExprPtr endValue;
   if (windowExpr.end_expr) {
-    windowIExpr.frame.endValue = parseExpr(*windowExpr.end_expr.get(), options);
+    endValue = parseExpr(*windowExpr.end_expr, options);
   }
-  return windowIExpr;
+
+  auto endType = parseBoundType(windowExpr.end);
+  if (options.correctWindowFrameDefault && orderByKeys.empty() &&
+      endType == core::WindowCallExpr::BoundType::kCurrentRow) {
+    endType = core::WindowCallExpr::BoundType::kUnboundedFollowing;
+  }
+
+  return std::make_shared<core::WindowCallExpr>(
+      normalizeFuncName(windowExpr.function_name),
+      std::move(params),
+      std::move(partitionKeys),
+      std::move(orderByKeys),
+      core::WindowCallExpr::Frame{
+          parseWindowType(windowExpr),
+          parseBoundType(windowExpr.start),
+          std::move(startValue),
+          endType,
+          std::move(endValue)},
+      windowExpr.ignore_nulls,
+      getAlias(windowExpr));
 }
 
-std::string OrderByClause::toString() const {
-  return fmt::format(
-      "{} {} NULLS {}",
-      expr->toString(),
-      (ascending ? "ASC" : "DESC"),
-      (nullsFirst ? "FIRST" : "LAST"));
+} // namespace
+
+core::WindowCallExprPtr parseWindowExpr(
+    const std::string& windowString,
+    const ParseOptions& options) {
+  auto parsedExpr = parseSingleExpression(windowString);
+  VELOX_CHECK(
+      parsedExpr->IsWindow(),
+      "Invalid window function expression: {}",
+      windowString);
+
+  return buildWindowCallExpr(*parsedExpr, windowString, options);
+}
+
+core::ExprPtr parseScalarOrWindowExpr(
+    const std::string& exprString,
+    const ParseOptions& options) {
+  auto parsedExpr = parseSingleExpression(exprString);
+  if (parsedExpr->IsWindow()) {
+    return buildWindowCallExpr(*parsedExpr, exprString, options);
+  }
+  return parseExpr(*parsedExpr, options);
 }
 
 } // namespace facebook::velox::duckdb
diff --git a/velox/duckdb/conversion/DuckParser.h b/velox/duckdb/conversion/DuckParser.h
index 413e9280561..f8e094109d0 100644
--- a/velox/duckdb/conversion/DuckParser.h
+++ b/velox/duckdb/conversion/DuckParser.h
@@ -16,18 +16,10 @@
 #pragma once
 
 #include <string>
-#include "velox/parse/IExpr.h"
+#include "velox/parse/SqlExpressionsParser.h"
 
 namespace facebook::velox::duckdb {
 
-struct OrderByClause {
-  core::ExprPtr expr;
-  bool ascending;
-  bool nullsFirst;
-
-  std::string toString() const;
-};
-
 /// Hold parsing options.
 struct ParseOptions {
   // Retain legacy behavior by default.
@@ -37,6 +29,12 @@ struct ParseOptions {
   // single array argument.
   bool parseInListAsArray = true;
 
+  // DuckDB defaults the window frame end bound to CURRENT ROW even when ORDER
+  // BY is absent. The SQL standard requires UNBOUNDED FOLLOWING in that case.
+  // When true, corrects this default. Cannot distinguish defaulted from
+  // explicit frames, so an explicit CURRENT ROW may be incorrectly overridden.
+  bool correctWindowFrameDefault = false;
+
   /// SQL functions could be registered with different prefixes by the user.
   /// This parameter is the registered prefix of presto or spark functions,
   /// which helps generate the correct Velox expression.
@@ -58,60 +56,30 @@ std::vector<core::ExprPtr> parseMultipleExpressions(
     const std::string& exprString,
     const ParseOptions& options);
 
-struct AggregateExpr {
-  core::ExprPtr expr;
-  std::vector<OrderByClause> orderBy;
-  bool distinct{false};
-  core::ExprPtr maskExpr{nullptr};
-};
-
 /// Parses aggregate function call expression with optional ORDER by clause.
+/// Always returns an AggregateCallExpr.
 /// Examples:
 ///     sum(a)
 ///     sum(a) as s
 ///     array_agg(x ORDER BY y DESC)
-AggregateExpr parseAggregateExpr(
+core::AggregateCallExprPtr parseAggregateExpr(
     const std::string& exprString,
     const ParseOptions& options);
 
 // Parses an ORDER BY clause using DuckDB's internal postgresql-based parser.
 // Uses ASC NULLS LAST as the default sort order.
-OrderByClause parseOrderByExpr(const std::string& exprString);
-
-// Parses a WINDOW function SQL string using DuckDB's internal postgresql-based
-// parser. Window Functions are executed by Velox Window PlanNodes and not the
-// expression evaluation. So we cannot use an IExpr based API. The structures
-// below capture all the metadata needed from the window function SQL string
-// for usage in the WindowNode plan node.
-enum class WindowType { kRows, kRange };
-
-enum class BoundType {
-  kCurrentRow,
-  kUnboundedPreceding,
-  kUnboundedFollowing,
-  kPreceding,
-  kFollowing
-};
+parse::OrderByClause parseOrderByExpr(const std::string& exprString);
 
-struct IExprWindowFrame {
-  WindowType type;
-  BoundType startType;
-  core::ExprPtr startValue;
-  BoundType endType;
-  core::ExprPtr endValue;
-};
-
-struct IExprWindowFunction {
-  core::ExprPtr functionCall;
-  IExprWindowFrame frame;
-  bool ignoreNulls;
-
-  std::vector<core::ExprPtr> partitionBy;
-  std::vector<OrderByClause> orderBy;
-};
-
-IExprWindowFunction parseWindowExpr(
+/// Parses a WINDOW function SQL string. Returns a WindowCallExpr.
+core::WindowCallExprPtr parseWindowExpr(
     const std::string& windowString,
     const ParseOptions& options);
 
+/// Parses a SQL expression that can be either a scalar expression or a window
+/// function. Returns a WindowCallExpr (kWindow kind) for window functions,
+/// or a regular ExprPtr for scalar expressions.
+core::ExprPtr parseScalarOrWindowExpr(
+    const std::string& exprString,
+    const ParseOptions& options);
+
 } // namespace facebook::velox::duckdb
diff --git a/velox/duckdb/conversion/tests/DuckConversionTest.cpp b/velox/duckdb/conversion/tests/DuckConversionTest.cpp
index d73f222b818..c5d9e09db15 100644
--- a/velox/duckdb/conversion/tests/DuckConversionTest.cpp
+++ b/velox/duckdb/conversion/tests/DuckConversionTest.cpp
@@ -91,7 +91,6 @@ TEST(DuckConversionTest, duckValueToVariantUnsupported) {
   /// defined as static constexpr const causing a double definition only in the
   /// debug build.
   std::vector<LogicalType> unsupported = {
-      ::duckdb::TransformStringToLogicalType("time"),
       ::duckdb::TransformStringToLogicalType("interval"),
       LogicalType::LIST({::duckdb::TransformStringToLogicalType("integer")}),
       LogicalType::STRUCT(
@@ -123,6 +122,7 @@ TEST(DuckConversionTest, types) {
 
   testRoundTrip(TIMESTAMP());
   testRoundTrip(DATE());
+  testRoundTrip(TIME());
   testRoundTrip(INTERVAL_DAY_TIME());
 
   testRoundTrip(DECIMAL(22, 5));
@@ -157,7 +157,8 @@ TEST(DuckConversionTest, createTable) {
            DOUBLE()}));
 
   testCreateTable(
-      ROW({"a", "b", "c"}, {TIMESTAMP(), DATE(), INTERVAL_DAY_TIME()}));
+      ROW({"a", "b", "c", "d"},
+          {TIMESTAMP(), DATE(), INTERVAL_DAY_TIME(), TIME()}));
 
   testCreateTable(ROW({"a", "b"}, {DECIMAL(7, 5), DECIMAL(30, 10)}));
 
diff --git a/velox/duckdb/conversion/tests/DuckParserTest.cpp b/velox/duckdb/conversion/tests/DuckParserTest.cpp
index 21168c4248d..dd73fe6c141 100644
--- a/velox/duckdb/conversion/tests/DuckParserTest.cpp
+++ b/velox/duckdb/conversion/tests/DuckParserTest.cpp
@@ -22,6 +22,7 @@
 
 using namespace facebook::velox;
 using namespace facebook::velox::duckdb;
+using namespace facebook::velox::parse;
 
 namespace {
 std::shared_ptr<const core::IExpr> parseExpr(const std::string& exprString) {
@@ -99,40 +100,9 @@ TEST(DuckParserTest, functions) {
 }
 
 namespace {
-std::string toString(const std::vector<OrderByClause>& orderBy) {
-  std::stringstream out;
-  if (!orderBy.empty()) {
-    out << "ORDER BY ";
-    for (auto i = 0; i < orderBy.size(); ++i) {
-      if (i > 0) {
-        out << ", ";
-      }
-      out << orderBy[i].toString();
-    }
-  }
-
-  return out.str();
-}
-
 std::string parseAgg(const std::string& expression) {
   ParseOptions options;
-  auto aggregateExpr = parseAggregateExpr(expression, options);
-  std::stringstream out;
-  out << aggregateExpr.expr->toString();
-
-  if (aggregateExpr.distinct) {
-    out << " DISTINCT";
-  }
-
-  if (!aggregateExpr.orderBy.empty()) {
-    out << " " << toString(aggregateExpr.orderBy);
-  }
-
-  if (aggregateExpr.maskExpr != nullptr) {
-    out << " FILTER " << aggregateExpr.maskExpr->toString();
-  }
-
-  return out.str();
+  return parseAggregateExpr(expression, options)->toString();
 }
 } // namespace
 
@@ -148,20 +118,20 @@ TEST(DuckParserTest, aggregates) {
       "array_agg(\"x\") ORDER BY \"y\" ASC NULLS FIRST",
       parseAgg("array_agg(x ORDER BY y NULLS FIRST)"));
   EXPECT_EQ(
-      "array_agg(\"x\") ORDER BY \"y\" ASC NULLS LAST, \"z\" ASC NULLS LAST",
+      "array_agg(\"x\") ORDER BY \"y\" ASC NULLS LAST,\"z\" ASC NULLS LAST",
       parseAgg("array_agg(x ORDER BY y, z)"));
 }
 
 TEST(DuckParserTest, aggregatesWithMasks) {
   EXPECT_EQ(
-      "array_agg(\"x\") FILTER \"m\"",
+      "array_agg(\"x\") FILTER(WHERE \"m\")",
       parseAgg("array_agg(x) filter (where m)"));
 }
 
 TEST(DuckParserTest, distinctAggregates) {
-  EXPECT_EQ("count(\"x\") DISTINCT", parseAgg("count(distinct x)"));
-  EXPECT_EQ("count(\"x\",\"y\") DISTINCT", parseAgg("count(distinct x, y)"));
-  EXPECT_EQ("sum(\"x\") DISTINCT", parseAgg("sum(distinct x)"));
+  EXPECT_EQ("count(DISTINCT \"x\")", parseAgg("count(distinct x)"));
+  EXPECT_EQ("count(DISTINCT \"x\",\"y\")", parseAgg("count(distinct x, y)"));
+  EXPECT_EQ("sum(DISTINCT \"x\")", parseAgg("sum(distinct x)"));
 }
 
 TEST(DuckParserTest, subscript) {
@@ -414,8 +384,9 @@ TEST(DuckParserTest, cast) {
       "cast(\"str_col\" as INTERVAL DAY TO SECOND)",
       parseExpr("cast(str_col as interval day to second)")->toString());
 
-  // Unsupported casts for now.
-  EXPECT_THROW(parseExpr("cast('2020-01-01' as TIME)"), std::runtime_error);
+  EXPECT_EQ(
+      "cast(2020-01-01 as TIME)",
+      parseExpr("cast('2020-01-01' as TIME)")->toString());
 
   // Complex types.
   EXPECT_EQ(
@@ -461,6 +432,8 @@ TEST(DuckParserTest, ifCase) {
       "if(\"a\",plus(\"b\",\"c\"),g(\"d\"))",
       parseExpr("if(a, b + c, g(d))")->toString());
 
+  EXPECT_EQ("if(gt(\"a\",0),10)", parseExpr("if(a > 0, 10, null)")->toString());
+
   // CASE statements.
   EXPECT_EQ(
       "if(1,null,0)",
@@ -569,92 +542,36 @@ TEST(DuckParserTest, orderBy) {
 }
 
 namespace {
-const std::string windowTypeString(WindowType w) {
-  switch (w) {
-    case WindowType::kRange:
-      return "RANGE";
-    case WindowType::kRows:
-      return "ROWS";
-  }
-  VELOX_UNREACHABLE();
-}
-
-const std::string boundTypeString(BoundType b) {
-  switch (b) {
-    case BoundType::kUnboundedPreceding:
-      return "UNBOUNDED PRECEDING";
-    case BoundType::kUnboundedFollowing:
-      return "UNBOUNDED FOLLOWING";
-    case BoundType::kPreceding:
-      return "PRECEDING";
-    case BoundType::kFollowing:
-      return "FOLLOWING";
-    case BoundType::kCurrentRow:
-      return "CURRENT ROW";
-  }
-  VELOX_UNREACHABLE();
-}
 
 const std::string parseWindow(const std::string& expr) {
   ParseOptions options;
-  auto windowExpr = parseWindowExpr(expr, options);
-  std::string concatPartitions;
-  int i = 0;
-  for (const auto& partition : windowExpr.partitionBy) {
-    concatPartitions += partition->toString();
-    if (i > 0) {
-      concatPartitions += " , ";
-    }
-    i++;
-  }
-  auto partitionString = windowExpr.partitionBy.empty()
-      ? ""
-      : fmt::format("PARTITION BY {}", concatPartitions);
-
-  auto orderByString = toString(windowExpr.orderBy);
-
-  auto frameString = fmt::format(
-      "{} BETWEEN {}{} AND{} {}",
-      windowTypeString(windowExpr.frame.type),
-      (windowExpr.frame.startValue
-           ? windowExpr.frame.startValue->toString() + " "
-           : ""),
-      boundTypeString(windowExpr.frame.startType),
-      (windowExpr.frame.endValue ? " " + windowExpr.frame.endValue->toString()
-                                 : ""),
-      boundTypeString(windowExpr.frame.endType));
-
-  return fmt::format(
-      "{} OVER ({} {} {})",
-      windowExpr.functionCall->toString(),
-      partitionString,
-      orderByString,
-      frameString);
+  return parseWindowExpr(expr, options)->toString();
 }
 } // namespace
 
 TEST(DuckParserTest, window) {
   EXPECT_EQ(
-      "row_number() AS c OVER (PARTITION BY \"a\" ORDER BY \"b\" ASC NULLS LAST"
-      " RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)",
+      "row_number() OVER (PARTITION BY \"a\" ORDER BY \"b\" ASC NULLS LAST "
+      "RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS c",
       parseWindow("row_number() over (partition by a order by b) as c"));
   EXPECT_EQ(
-      "row_number() AS a OVER (  RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)",
+      "row_number() OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS a",
       parseWindow("row_number() over () as a"));
   EXPECT_EQ(
-      "row_number() AS a OVER ( ORDER BY \"b\" ASC NULLS LAST "
-      "RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)",
+      "row_number() OVER (ORDER BY \"b\" ASC NULLS LAST "
+      "RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS a",
       parseWindow("row_number() over (order by b) as a"));
   EXPECT_EQ(
-      "row_number() OVER (PARTITION BY \"a\"  ROWS BETWEEN "
-      "UNBOUNDED PRECEDING AND CURRENT ROW)",
+      "row_number() OVER (PARTITION BY \"a\" "
+      "ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)",
       parseWindow(
           "row_number() over (partition by a rows between unbounded preceding and current row)"));
   EXPECT_EQ(
       "row_number() OVER (PARTITION BY \"a\" ORDER BY \"b\" ASC NULLS LAST "
       "ROWS BETWEEN plus(\"a\",10) PRECEDING AND 10 FOLLOWING)",
-      parseWindow("row_number() over (partition by a order by b "
-                  "rows between a + 10 preceding and 10 following)"));
+      parseWindow(
+          "row_number() over (partition by a order by b "
+          "rows between a + 10 preceding and 10 following)"));
   EXPECT_EQ(
       "row_number() OVER (PARTITION BY \"a\" ORDER BY \"b\" DESC NULLS FIRST "
       "ROWS BETWEEN plus(\"a\",10) PRECEDING AND 10 FOLLOWING)",
@@ -663,17 +580,17 @@ TEST(DuckParserTest, window) {
           "rows between a + 10 preceding and 10 following)"));
 
   EXPECT_EQ(
-      "lead(\"x\",\"y\",\"z\") OVER (  "
+      "lead(\"x\",\"y\",\"z\") OVER ("
       "RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)",
       parseWindow("lead(x, y, z) over ()"));
 
   EXPECT_EQ(
-      "lag(\"x\",3,\"z\") OVER (  "
+      "lag(\"x\",3,\"z\") OVER ("
       "RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)",
       parseWindow("lag(x, 3, z) over ()"));
 
   EXPECT_EQ(
-      "nth_value(\"x\",3) OVER (  "
+      "nth_value(\"x\",3) OVER ("
       "RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)",
       parseWindow("nth_value(x, 3) over ()"));
 }
@@ -682,17 +599,33 @@ TEST(DuckParserTest, windowWithIntegerConstant) {
   ParseOptions options;
   options.parseIntegerAsBigint = false;
   auto windowExpr = parseWindowExpr("nth_value(x, 3) over ()", options);
-  auto func =
-      std::dynamic_pointer_cast<const core::CallExpr>(windowExpr.functionCall);
-  ASSERT_TRUE(func != nullptr)
-      << windowExpr.functionCall->toString() << " is not a call expr";
-  EXPECT_EQ(func->inputs().size(), 2);
-  auto param = func->inputs()[1];
+  ASSERT_TRUE(windowExpr->is(core::IExpr::Kind::kWindow));
+  auto* windowCall = windowExpr->as<core::WindowCallExpr>();
+  EXPECT_EQ(windowCall->inputs().size(), 2);
+  auto param = windowCall->inputs()[1];
   auto constant = std::dynamic_pointer_cast<const core::ConstantExpr>(param);
   ASSERT_TRUE(constant != nullptr) << param->toString() << " is not a constant";
   EXPECT_EQ(*constant->type(), *INTEGER());
 }
 
+TEST(DuckParserTest, parseScalarOrWindowExpr) {
+  ParseOptions options;
+
+  // Scalar expression returns a plain ExprPtr.
+  auto scalar = parseScalarOrWindowExpr("a + b", options);
+  ASSERT_FALSE(scalar->is(core::IExpr::Kind::kWindow));
+  EXPECT_EQ(scalar->toString(), "plus(\"a\",\"b\")");
+
+  // Window expression returns a WindowCallExpr.
+  auto window =
+      parseScalarOrWindowExpr("row_number() over (order by a)", options);
+  ASSERT_TRUE(window->is(core::IExpr::Kind::kWindow));
+  auto* windowCall = window->as<core::WindowCallExpr>();
+  EXPECT_EQ(windowCall->name(), "row_number");
+  EXPECT_EQ(windowCall->orderByKeys().size(), 1);
+  EXPECT_TRUE(windowCall->orderByKeys()[0].ascending);
+}
+
 TEST(DuckParserTest, invalidExpression) {
   VELOX_ASSERT_THROW(
       parseExpr("func(a b)"),
@@ -831,3 +764,128 @@ TEST(DuckParserTest, lambda) {
       parseExpr("filter(a, if (b > 0, x -> (x = 10), x -> (x = 20)))")
           ->toString());
 }
+
+TEST(DuckParserTest, arrayLiteral) {
+  {
+    auto expr = parseExpr("ARRAY[1, 2, 3]");
+    EXPECT_TRUE(expr->is(core::IExpr::Kind::kConstant));
+    VELOX_EXPECT_EQ_TYPES(
+        expr->as<core::ConstantExpr>()->type(), ARRAY(BIGINT()));
+    EXPECT_EQ("{1, 2, 3}", expr->toString());
+  }
+
+  {
+    auto expr = parseExpr("[1, 2, 3]");
+    EXPECT_TRUE(expr->is(core::IExpr::Kind::kConstant));
+    VELOX_EXPECT_EQ_TYPES(
+        expr->as<core::ConstantExpr>()->type(), ARRAY(BIGINT()));
+    EXPECT_EQ("{1, 2, 3}", expr->toString());
+  }
+
+  // Array with null elements.
+  {
+    auto expr = parseExpr("[1, null, 3]");
+    EXPECT_TRUE(expr->is(core::IExpr::Kind::kConstant));
+    VELOX_EXPECT_EQ_TYPES(
+        expr->as<core::ConstantExpr>()->type(), ARRAY(BIGINT()));
+    EXPECT_EQ("{1, null, 3}", expr->toString());
+  }
+
+  // All-null array.
+  {
+    auto expr = parseExpr("[null, null]");
+    EXPECT_TRUE(expr->is(core::IExpr::Kind::kConstant));
+    VELOX_EXPECT_EQ_TYPES(
+        expr->as<core::ConstantExpr>()->type(), ARRAY(UNKNOWN()));
+    EXPECT_EQ("{null, null}", expr->toString());
+  }
+
+  // Empty array.
+  {
+    auto expr = parseExpr("[]");
+    EXPECT_TRUE(expr->is(core::IExpr::Kind::kConstant));
+    VELOX_EXPECT_EQ_TYPES(
+        expr->as<core::ConstantExpr>()->type(), ARRAY(UNKNOWN()));
+    EXPECT_EQ("<empty>", expr->toString());
+  }
+
+  // Nested array.
+  {
+    auto expr = parseExpr("[[1, 2], [3, 4]]");
+    EXPECT_TRUE(expr->is(core::IExpr::Kind::kConstant));
+    VELOX_EXPECT_EQ_TYPES(
+        expr->as<core::ConstantExpr>()->type(), ARRAY(ARRAY(BIGINT())));
+    EXPECT_EQ("{{1, 2}, {3, 4}}", expr->toString());
+  }
+
+  // Non-constant argument stays a function call.
+  {
+    auto expr = parseExpr("[a, 1, 2]");
+    EXPECT_TRUE(expr->is(core::IExpr::Kind::kCall));
+    EXPECT_EQ("list_value(\"a\",1,2)", expr->toString());
+  }
+}
+
+TEST(DuckParserTest, structLiteral) {
+  // {'x': 1, 'y': 2} becomes a ROW constant with named fields.
+  {
+    auto expr = parseExpr("{'x': 1, 'y': 2}");
+    EXPECT_TRUE(expr->is(core::IExpr::Kind::kConstant));
+    VELOX_EXPECT_EQ_TYPES(
+        expr->as<core::ConstantExpr>()->type(),
+        ROW({"x", "y"}, {BIGINT(), BIGINT()}));
+    EXPECT_EQ("{1, 2}", expr->toString());
+  }
+
+  // ROW(1, 2) becomes a ROW constant with unnamed fields.
+  {
+    auto expr = parseExpr("ROW(1, 2)");
+    EXPECT_TRUE(expr->is(core::IExpr::Kind::kConstant));
+    VELOX_EXPECT_EQ_TYPES(
+        expr->as<core::ConstantExpr>()->type(), ROW({"", ""}, BIGINT()));
+    EXPECT_EQ("{1, 2}", expr->toString());
+  }
+
+  // ROW(a, 2) with a non-constant argument stays a function call.
+  {
+    auto expr = parseExpr("ROW(a, 2)");
+    EXPECT_TRUE(expr->is(core::IExpr::Kind::kCall));
+    EXPECT_EQ("row(\"a\",2)", expr->toString());
+  }
+
+  // ROW(1, 2)::struct(x bigint, y bigint) becomes a named ROW constant.
+  {
+    auto expr = parseExpr("ROW(1, 2)::struct(x bigint, y bigint)");
+    EXPECT_TRUE(expr->is(core::IExpr::Kind::kConstant));
+    VELOX_EXPECT_EQ_TYPES(
+        expr->as<core::ConstantExpr>()->type(), ROW({"x", "y"}, BIGINT()));
+    EXPECT_EQ("{1, 2}", expr->toString());
+  }
+
+  // ROW(1, 2)::struct(x varchar, y bigint) with mismatched child types stays a
+  // cast.
+  {
+    auto expr = parseExpr("ROW(1, 2)::struct(x varchar, y bigint)");
+    EXPECT_TRUE(expr->is(core::IExpr::Kind::kCast));
+    EXPECT_EQ("cast({1, 2} as ROW<x:VARCHAR,y:BIGINT>)", expr->toString());
+  }
+}
+
+TEST(DuckParserTest, dateLiteral) {
+  for (const auto& sql : {"'1994-01-01'::date", "DATE '1994-01-01'"}) {
+    SCOPED_TRACE(sql);
+    auto expr = parseExpr(sql);
+    EXPECT_TRUE(expr->is(core::IExpr::Kind::kConstant));
+
+    auto* constant = expr->as<core::ConstantExpr>();
+    EXPECT_EQ(*constant->type(), *DATE());
+    EXPECT_EQ(constant->value().value<int32_t>(), DATE()->toDays("1994-01-01"));
+
+    EXPECT_EQ("1994-01-01", expr->toString());
+  }
+
+  // Invalid date string.
+  VELOX_ASSERT_THROW(
+      parseExpr("DATE 'not-a-date'"),
+      "Unable to parse date value: \"not-a-date\"");
+}
diff --git a/velox/dwio/catalog/fbhive/CMakeLists.txt b/velox/dwio/catalog/fbhive/CMakeLists.txt
index 17a778f41c3..305cf427c3d 100644
--- a/velox/dwio/catalog/fbhive/CMakeLists.txt
+++ b/velox/dwio/catalog/fbhive/CMakeLists.txt
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_dwio_catalog_fbhive FileUtils.cpp)
+velox_add_library(velox_dwio_catalog_fbhive FileUtils.cpp HEADERS FileUtils.h)
 velox_link_libraries(velox_dwio_catalog_fbhive velox_exception fmt::fmt Folly::folly)
 
 if(${VELOX_BUILD_TESTING})
diff --git a/velox/dwio/catalog/fbhive/FileUtils.cpp b/velox/dwio/catalog/fbhive/FileUtils.cpp
index 36d1b29d98e..621ee20bbbf 100644
--- a/velox/dwio/catalog/fbhive/FileUtils.cpp
+++ b/velox/dwio/catalog/fbhive/FileUtils.cpp
@@ -112,9 +112,10 @@ std::vector<std::pair<std::string, std::string>> extractPartitionKeyValues(
         std::vector<std::string> tokens;
         folly::split('=', partitionPart, tokens);
         if (tokens.size() == 2) {
-          parsedParts.emplace_back(std::make_pair(
-              FileUtils::unescapePathName(tokens[0]),
-              FileUtils::unescapePathName(tokens[1])));
+          parsedParts.emplace_back(
+              std::make_pair(
+                  FileUtils::unescapePathName(tokens[0]),
+                  FileUtils::unescapePathName(tokens[1])));
         }
       });
 }
@@ -157,46 +158,29 @@ std::string FileUtils::unescapePathName(const std::string& data) {
 
 std::string FileUtils::makePartName(
     const std::vector<std::pair<std::string, std::string>>& entries,
-    bool partitionPathAsLowerCase) {
-  size_t size = 0;
-  size_t escapeCount = 0;
-  std::for_each(entries.begin(), entries.end(), [&](auto& pair) {
-    auto keySize = pair.first.size();
-    VELOX_CHECK_GT(keySize, 0);
-    size += keySize;
-    escapeCount += countEscape(pair.first);
-
-    auto valSize = pair.second.size();
-    if (valSize == 0) {
-      size += kDefaultPartitionValue.size();
-    } else {
-      size += valSize;
-      escapeCount += countEscape(pair.second);
+    bool partitionPathAsLowerCase,
+    bool useDefaultPartitionValue,
+    const EncodeFunction& encodeFunc) {
+  VELOX_CHECK(!entries.empty());
+  std::ostringstream out;
+
+  for (const auto& [key, value] : entries) {
+    VELOX_CHECK(!key.empty());
+    if (out.tellp() > 0) {
+      out << '/';
     }
-  });
 
-  std::string ret;
-  ret.reserve(size + escapeCount * HEX_WIDTH + entries.size() - 1);
-
-  std::for_each(entries.begin(), entries.end(), [&](auto& pair) {
-    if (ret.size() > 0) {
-      ret += "/";
-    }
-    if (partitionPathAsLowerCase) {
-      ret += escapePathName(toLower(pair.first));
-    } else {
-      ret += escapePathName(pair.first);
-    }
+    std::string keyToEncode = partitionPathAsLowerCase ? toLower(key) : key;
+    out << encodeFunc(keyToEncode) << '=';
 
-    ret += "=";
-    if (pair.second.size() == 0) {
-      ret += kDefaultPartitionValue;
+    if (value.empty() && useDefaultPartitionValue) {
+      out << kDefaultPartitionValue;
     } else {
-      ret += escapePathName(pair.second);
+      out << encodeFunc(value);
     }
-  });
+  }
 
-  return ret;
+  return out.str();
 }
 
 std::vector<std::pair<std::string, std::string>> FileUtils::parsePartKeyValues(
diff --git a/velox/dwio/catalog/fbhive/FileUtils.h b/velox/dwio/catalog/fbhive/FileUtils.h
index a8ca8bf07ef..519c274fc6f 100644
--- a/velox/dwio/catalog/fbhive/FileUtils.h
+++ b/velox/dwio/catalog/fbhive/FileUtils.h
@@ -29,6 +29,10 @@ namespace fbhive {
 
 class FileUtils {
  public:
+  /// Function type for encoding partition key/value strings.
+  /// Takes a string to encode and returns the encoded string.
+  using EncodeFunction = std::function<std::string(const std::string&)>;
+
   /// Converts the path name to be hive metastore compliant, will do
   /// url-encoding when needed.
   static std::string escapePathName(const std::string& data);
@@ -39,9 +43,19 @@ class FileUtils {
 
   /// Creates the partition directory path from the list of partition key/value
   /// pairs, will do url-encoding when needed.
+  /// @param entries Vector of (key, value) pairs for partition columns. Cannot
+  ///        be empty.
+  /// @param partitionPathAsLowerCase Whether to convert keys to lowercase
+  /// @param useDefaultPartitionValue If true, empty values are replaced with
+  ///        kDefaultPartitionValue. If false, empty values are encoded as-is.
+  ///        Defaults to true for Hive compatibility.
+  /// @param encodeFunc Function to use for encoding keys and values.
+  ///                   Defaults to escapePathName.
   static std::string makePartName(
       const std::vector<std::pair<std::string, std::string>>& entries,
-      bool partitionPathAsLowerCase);
+      bool partitionPathAsLowerCase,
+      bool useDefaultPartitionValue = true,
+      const EncodeFunction& encodeFunc = escapePathName);
 
   /// Converts the hive-metastore-compliant path name back to the corresponding
   /// partition key/value pairs.
diff --git a/velox/dwio/catalog/fbhive/test/FileUtilsTests.cpp b/velox/dwio/catalog/fbhive/test/FileUtilsTests.cpp
index 042c5ba9308..579c7533ecd 100644
--- a/velox/dwio/catalog/fbhive/test/FileUtilsTests.cpp
+++ b/velox/dwio/catalog/fbhive/test/FileUtilsTests.cpp
@@ -19,10 +19,12 @@
 #include "velox/common/base/Exceptions.h"
 #include "velox/dwio/catalog/fbhive/FileUtils.h"
 
+namespace facebook::velox::dwio::catalog::fbhive {
+namespace {
+
 using namespace ::testing;
-using namespace facebook::velox::dwio::catalog::fbhive;
 
-TEST(FileUtilsTests, MakePartName) {
+TEST(FileUtilsTests, makePartName) {
   std::vector<std::pair<std::string, std::string>> pairs{
       {"ds", "2016-01-01"}, {"FOO", ""}, {"a\nb:c", "a#b=c"}};
   ASSERT_EQ(
@@ -31,9 +33,22 @@ TEST(FileUtilsTests, MakePartName) {
   ASSERT_EQ(
       FileUtils::makePartName(pairs, false),
       "ds=2016-01-01/FOO=__HIVE_DEFAULT_PARTITION__/a%0Ab%3Ac=a%23b%3Dc");
+  ASSERT_THROW(FileUtils::makePartName({}, false), VeloxException);
+}
+
+TEST(FileUtilsTests, makePartNameWithoutDefaultPartitionValue) {
+  std::vector<std::pair<std::string, std::string>> pairs{
+      {"ds", "2016-01-01"}, {"FOO", ""}, {"a\nb:c", "a#b=c"}};
+  // Test with useDefaultPartitionValue = false.
+  ASSERT_EQ(
+      FileUtils::makePartName(pairs, true, false),
+      "ds=2016-01-01/foo=/a%0Ab%3Ac=a%23b%3Dc");
+  ASSERT_EQ(
+      FileUtils::makePartName(pairs, false, false),
+      "ds=2016-01-01/FOO=/a%0Ab%3Ac=a%23b%3Dc");
 }
 
-TEST(FileUtilsTests, ParsePartKeyValues) {
+TEST(FileUtilsTests, parsePartKeyValues) {
   EXPECT_THROW(
       FileUtils::parsePartKeyValues("ds"), facebook::velox::VeloxRuntimeError);
   EXPECT_THROW(
@@ -60,7 +75,7 @@ TEST(FileUtilsTests, ParsePartKeyValues) {
           std::make_pair("a\nb:c", "a#b=c/")));
 }
 
-TEST(FileUtilsTests, ExtractPartitionName) {
+TEST(FileUtilsTests, extractPartitionName) {
   struct TestCase {
    public:
     TestCase(const std::string& filePath, const std::string& partitionName)
@@ -88,3 +103,6 @@ TEST(FileUtilsTests, ExtractPartitionName) {
         FileUtils::extractPartitionName(testCase.filePath));
   }
 }
+
+} // namespace
+} // namespace facebook::velox::dwio::catalog::fbhive
diff --git a/velox/dwio/common/Adaptor.h b/velox/dwio/common/Adaptor.h
index 2fef0a96655..ae89074808f 100644
--- a/velox/dwio/common/Adaptor.h
+++ b/velox/dwio/common/Adaptor.h
@@ -27,7 +27,7 @@
 #define DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
 #define DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
 #else
-#error("Unknown compiler")
+#error ("Unknown compiler")
 #endif
 
 #define PRAGMA(TXT) _Pragma(#TXT)
diff --git a/velox/dwio/common/Arena.h b/velox/dwio/common/Arena.h
new file mode 100644
index 00000000000..9690ce727d3
--- /dev/null
+++ b/velox/dwio/common/Arena.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <google/protobuf/arena.h>
+#include <google/protobuf/stubs/common.h>
+
+namespace facebook::velox::dwio::common {
+
+/// Wrapper over protobuf's arena allocation.  The API changes from
+/// CreateMessage() to Create() in newer protobuf versions.
+template <class T, class... Args>
+T* ArenaCreate(google::protobuf::Arena* arena, Args&&... args) {
+#if GOOGLE_PROTOBUF_VERSION >= 5030000
+  return google::protobuf::Arena::Create<T>(arena, std::forward<Args>(args)...);
+#else
+  return google::protobuf::Arena::CreateMessage<T>(
+      arena, std::forward<Args>(args)...);
+#endif
+}
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/BitPackDecoder.h b/velox/dwio/common/BitPackDecoder.h
index 2aa785e2d29..5f31267026d 100644
--- a/velox/dwio/common/BitPackDecoder.h
+++ b/velox/dwio/common/BitPackDecoder.h
@@ -109,7 +109,7 @@ static inline uint32_t unpackNaive(
     uint64_t inputBufferLen,
     uint64_t numValues,
     uint8_t bitWidth,
-    T* FOLLY_NONNULL& result);
+    T * FOLLY_NONNULL & result);
 
 /// Unpack numValues number of input values from inputBuffer. The results
 /// will be written to result. numValues must be a multiple of 8. The
@@ -122,7 +122,7 @@ inline void unpack(
     uint64_t inputBufferLen,
     uint64_t numValues,
     uint8_t bitWidth,
-    T* FOLLY_NONNULL& result) {
+    T * FOLLY_NONNULL & result) {
   unpackNaive<T>(inputBits, inputBufferLen, numValues, bitWidth, result);
 }
 
@@ -159,7 +159,7 @@ static inline uint32_t unpackNaive(
     uint64_t inputBufferLen,
     uint64_t numValues,
     uint8_t bitWidth,
-    T* FOLLY_NONNULL& result) {
+    T * FOLLY_NONNULL & result) {
   VELOX_CHECK(bitWidth >= 1 && bitWidth <= sizeof(T) * 8);
   VELOX_CHECK(inputBufferLen * 8 >= bitWidth * numValues);
 
diff --git a/velox/dwio/common/BufferedInput.cpp b/velox/dwio/common/BufferedInput.cpp
index 8791e418f49..ec745f0eb3e 100644
--- a/velox/dwio/common/BufferedInput.cpp
+++ b/velox/dwio/common/BufferedInput.cpp
@@ -27,6 +27,42 @@ using ::facebook::velox::common::Region;
 
 namespace facebook::velox::dwio::common {
 
+CachedRegion::CachedRegion(cache::CachePin pin) : pin_(std::move(pin)) {
+  VELOX_CHECK(!pin_.empty(), "CachedRegion requires a non-empty cache pin");
+  auto* entry = pin_.checkedEntry();
+  VELOX_CHECK(
+      !entry->isExclusive(),
+      "CachedRegion requires a shared (non-exclusive) cache pin");
+  size_ = entry->size();
+  if (entry->hasContiguousData()) {
+    ranges_.push_back(
+        folly::Range<const char*>(entry->contiguousData(), size_));
+  } else {
+    auto& allocation = entry->nonContiguousData();
+    ranges_.reserve(allocation.numRuns());
+    uint64_t offset{0};
+    for (int i = 0; i < allocation.numRuns() && offset < size_; ++i) {
+      auto run = allocation.runAt(i);
+      const uint64_t bytes =
+          run.numPages() * memory::AllocationTraits::kPageSize;
+      const uint64_t readSize = std::min(bytes, size_ - offset);
+      ranges_.emplace_back(run.data<const char>(), readSize);
+      offset += readSize;
+    }
+  }
+}
+
+folly::IOBuf CachedRegion::toIOBuf() const {
+  VELOX_CHECK(!ranges_.empty());
+  auto iobuf =
+      folly::IOBuf::wrapBufferAsValue(ranges_[0].data(), ranges_[0].size());
+  for (size_t i = 1; i < ranges_.size(); ++i) {
+    iobuf.appendToChain(
+        folly::IOBuf::wrapBuffer(ranges_[i].data(), ranges_[i].size()));
+  }
+  return iobuf;
+}
+
 static_assert(std::is_move_constructible<BufferedInput>());
 
 namespace {
@@ -44,6 +80,14 @@ uint64_t BufferedInput::nextFetchSize() const {
       });
 }
 
+void BufferedInput::reset() {
+  regions_.clear();
+  offsets_.clear();
+  buffers_.clear();
+  enqueuedToBufferOffset_.clear();
+  allocPool_->clear();
+}
+
 void BufferedInput::load(const LogType logType) {
   // no regions to load
   if (regions_.size() == 0) {
@@ -82,14 +126,15 @@ void BufferedInput::readToBuffer(
     uint64_t offset,
     folly::Range<char*> allocated,
     const LogType logType) {
-  uint64_t usec = 0;
+  uint64_t storageReadTimeUs = 0;
   {
-    MicrosecondTimer timer(&usec);
+    MicrosecondTimer timer(&storageReadTimeUs);
     input_->read(allocated.data(), allocated.size(), offset, logType);
   }
   if (auto* stats = input_->getStats()) {
     stats->read().increment(allocated.size());
-    stats->queryThreadIoLatency().increment(usec);
+    stats->queryThreadIoLatencyUs().increment(storageReadTimeUs);
+    stats->storageReadLatencyUs().increment(storageReadTimeUs);
   }
 }
 
@@ -114,8 +159,9 @@ std::unique_ptr<SeekableInputStream> BufferedInput::enqueue(
       // help faster lookup using enqueuedToBufferOffset_ later.
       [region, this, i = regions_.size() - 1]() {
         auto result = readInternal(region.offset, region.length, i);
-        VELOX_CHECK(
-            std::get<1>(result) != MAX_UINT64,
+        VELOX_CHECK_NE(
+            std::get<1>(result),
+            MAX_UINT64,
             "Fail to read region offset={} length={}",
             region.offset,
             region.length);
diff --git a/velox/dwio/common/BufferedInput.h b/velox/dwio/common/BufferedInput.h
index 1f877b3fa8d..a9077a90452 100644
--- a/velox/dwio/common/BufferedInput.h
+++ b/velox/dwio/common/BufferedInput.h
@@ -16,6 +16,8 @@
 
 #pragma once
 
+#include "folly/io/IOBuf.h"
+#include "velox/common/caching/AsyncDataCache.h"
 #include "velox/common/caching/ScanTracker.h"
 #include "velox/common/memory/AllocationPool.h"
 #include "velox/dwio/common/SeekableInputStream.h"
@@ -26,6 +28,37 @@ DECLARE_bool(wsVRLoad);
 
 namespace facebook::velox::dwio::common {
 
+/// Provides read-only access to cached data without copying. Holds a
+/// shared-mode pin on the cache entry, keeping it alive while the caller
+/// accesses the data buffers.
+class CachedRegion {
+ public:
+  /// The pin must be non-empty and in shared (non-exclusive) mode.
+  explicit CachedRegion(cache::CachePin pin);
+
+  uint64_t size() const {
+    return size_;
+  }
+
+  /// Returns buffer ranges covering the cached data. For small entries the
+  /// result is a single contiguous range; for larger entries there may be
+  /// multiple non-contiguous ranges from the backing allocation.
+  const std::vector<folly::Range<const char*>>& ranges() const {
+    return ranges_;
+  }
+
+  /// Returns an IOBuf chain wrapping the cached data ranges without copying.
+  /// The returned IOBuf references memory owned by this CachedRegion, so
+  /// the caller must not outlive this object.
+  folly::IOBuf toIOBuf() const;
+
+ private:
+  cache::CachePin pin_;
+  // Cached data size in bytes.
+  uint64_t size_{0};
+  std::vector<folly::Range<const char*>> ranges_;
+};
+
 class BufferedInput {
  public:
   constexpr static uint64_t kMaxMergeDistance = 1024 * 1024 * 1.25;
@@ -35,15 +68,19 @@ class BufferedInput {
       memory::MemoryPool& pool,
       const MetricsLogPtr& metricsLog = MetricsLog::voidLog(),
       IoStatistics* stats = nullptr,
-      filesystems::File::IoStats* fsStats = nullptr,
+      velox::IoStats* ioStats = nullptr,
       uint64_t maxMergeDistance = kMaxMergeDistance,
-      std::optional<bool> wsVRLoad = std::nullopt)
+      std::optional<bool> wsVRLoad = std::nullopt,
+      folly::F14FastMap<std::string, std::string> fileReadOps = {},
+      bool cacheable = false)
       : BufferedInput(
             std::make_shared<ReadFileInputStream>(
                 std::move(readFile),
                 metricsLog,
                 stats,
-                fsStats),
+                ioStats,
+                std::move(fileReadOps),
+                cacheable),
             pool,
             maxMergeDistance,
             wsVRLoad) {}
@@ -79,9 +116,19 @@ class BufferedInput {
       velox::common::Region region,
       const StreamIdentifier* sid = nullptr);
 
-  /// Returns true if load synchronously.
-  virtual bool supportSyncLoad() const {
-    return true;
+  /// Preloads the entire file into memory for fast sub-region access.
+  /// Each subclass stores the preloaded data in its own native format.
+  /// For small files (<= filePreloadThreshold), this eliminates separate
+  /// footer and stripe data reads.
+  virtual void preload() {
+    enqueue({0, input_->getLength()});
+    load(LogType::FILE);
+    preloaded_ = true;
+  }
+
+  /// Returns true if the file has been preloaded.
+  virtual bool preloaded() const {
+    return preloaded_;
   }
 
   /// load all regions to be read in an optimized way (IO efficiency)
@@ -149,8 +196,50 @@ class BufferedInput {
     return nullptr;
   }
 
+  /// Returns true if this BufferedInput has a backing cache (e.g.,
+  /// AsyncDataCache). When true, callers may skip their own caching of raw
+  /// bytes since the BufferedInput will handle caching.
+  virtual bool hasCache() const {
+    return false;
+  }
+
+  /// Offers pre-read data for a file region to the backing cache. Throws if
+  /// hasCache() is false. Override in subclasses with a backing cache.
+  virtual void cacheRegion(
+      uint64_t /*offset*/,
+      uint64_t /*length*/,
+      std::string_view /*data*/) {
+    VELOX_UNSUPPORTED("cacheRegion requires a backing cache");
+  }
+
+  /// Overload that copies from an IOBuf (possibly chained) into the cache
+  /// entry, avoiding the need to coalesce the IOBuf first. 'bufferOffset' is
+  /// the byte offset within the IOBuf chain where the region data starts.
+  /// Throws if hasCache() is false.
+  virtual void cacheRegion(
+      uint64_t /*offset*/,
+      uint64_t /*length*/,
+      const folly::IOBuf& /*buffer*/,
+      uint64_t /*bufferOffset*/) {
+    VELOX_UNSUPPORTED("cacheRegion requires a backing cache");
+  }
+
+  /// Finds a cached region at the given offset. Returns a CachedRegion holding
+  /// a shared-mode pin on the cache entry if found, or std::nullopt on cache
+  /// miss. Throws if hasCache() is false.
+  virtual std::optional<CachedRegion> findCachedRegion(
+      uint64_t /*offset*/) const {
+    VELOX_UNSUPPORTED("findCachedRegion requires a backing cache");
+  }
+
   virtual uint64_t nextFetchSize() const;
 
+  /// Resets the buffered input for reuse. This is used by index lookup which
+  /// reuses the same BufferedInput across different index lookups. For
+  /// instance, Nimble file format with cluster index supports index lookup and
+  /// needs to reset the buffered input state between lookups.
+  virtual void reset();
+
  protected:
   static int adjustedReadPct(const cache::TrackingData& trackingData) {
     // When this method is called, there is one more reference that is already
@@ -255,6 +344,7 @@ class BufferedInput {
       velox::common::Region& first,
       const velox::common::Region& second);
 
+  bool preloaded_{false};
   uint64_t maxMergeDistance_;
   std::optional<bool> wsVRLoad_;
   std::unique_ptr<memory::AllocationPool> allocPool_;
diff --git a/velox/dwio/common/CMakeLists.txt b/velox/dwio/common/CMakeLists.txt
index 3a4976bd625..532f2d3bcf6 100644
--- a/velox/dwio/common/CMakeLists.txt
+++ b/velox/dwio/common/CMakeLists.txt
@@ -14,6 +14,7 @@
 add_subdirectory(compression)
 add_subdirectory(encryption)
 add_subdirectory(exception)
+add_subdirectory(wrap)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
@@ -35,7 +36,7 @@ velox_add_library(
   DirectBufferedInput.cpp
   DirectDecoder.cpp
   DirectInputStream.cpp
-  DwioMetricsLog.cpp
+  MetricsLog.cpp
   ExecutorBarrier.cpp
   FileSink.cpp
   FlatMapHelper.cpp
@@ -45,6 +46,7 @@ velox_add_library(
   MetadataFilter.cpp
   Options.cpp
   OutputStream.cpp
+  ParallelUnitLoader.cpp
   ParallelFor.cpp
   Range.cpp
   Reader.cpp
@@ -58,11 +60,80 @@ velox_add_library(
   SelectiveStructColumnReader.cpp
   SortingWriter.cpp
   SortingWriter.h
+  StatisticsBuilder.cpp
   Throttler.cpp
   TypeUtils.cpp
   TypeWithId.cpp
   Writer.cpp
   WriterFactory.cpp
+  HEADERS
+  Adaptor.h
+  Arena.h
+  BitConcatenation.h
+  BitPackDecoder.h
+  BufferUtil.h
+  BufferedInput.h
+  CacheInputStream.h
+  CachedBufferedInput.h
+  ChainedBuffer.h
+  Closeable.h
+  ColumnLoader.h
+  ColumnSelector.h
+  ColumnVisitors.h
+  DataBuffer.h
+  DataBufferHolder.h
+  DecoderUtil.h
+  DirectBufferedInput.h
+  DirectDecoder.h
+  DirectInputStream.h
+  ErrorTolerance.h
+  ExecutorBarrier.h
+  FileMetadata.h
+  FileSink.h
+  FilterNode.h
+  FlatMapHelper.h
+  FlushPolicy.h
+  FormatData.h
+  InputStream.h
+  IntCodecCommon.h
+  IntDecoder.h
+  MeasureTime.h
+  MetadataFilter.h
+  MetricsLog.h
+  Mutation.h
+  OnDemandUnitLoader.h
+  Options.h
+  OutputStream.h
+  ParallelFor.h
+  ParallelUnitLoader.h
+  PositionProvider.h
+  RandGen.h
+  Range.h
+  Reader.h
+  ReaderFactory.h
+  Retry.h
+  ScanSpec.h
+  SeekableInputStream.h
+  SelectiveByteRleColumnReader.h
+  SelectiveColumnReader.h
+  SelectiveColumnReaderInternal.h
+  SelectiveFlatMapColumnReader.h
+  SelectiveFloatingPointColumnReader.h
+  SelectiveIntegerColumnReader.h
+  SelectiveRepeatedColumnReader.h
+  SelectiveStructColumnReader.h
+  Statistics.h
+  StatisticsBuilder.h
+  StreamIdentifier.h
+  StreamUtil.h
+  Throttler.h
+  TypeUtil.h
+  TypeUtils.h
+  TypeWithId.h
+  UnitLoader.h
+  UnitLoaderTools.h
+  Writer.h
+  WriterFactory.h
 )
 
 velox_include_directories(velox_dwio_common PRIVATE ${Protobuf_INCLUDE_DIRS})
@@ -74,13 +145,13 @@ velox_link_libraries(
   velox_common_io
   velox_common_compression
   velox_common_config
+  velox_common_hyperloglog
   velox_dwio_common_encryption
   velox_dwio_common_exception
   velox_exception
   velox_expression
   velox_memory
   velox_type_tz
-  Boost::regex
   Folly::folly
   glog::glog
   protobuf::libprotobuf
diff --git a/velox/dwio/common/CacheInputStream.cpp b/velox/dwio/common/CacheInputStream.cpp
index dedda0c72f6..8474c2aac33 100644
--- a/velox/dwio/common/CacheInputStream.cpp
+++ b/velox/dwio/common/CacheInputStream.cpp
@@ -35,14 +35,14 @@ CacheInputStream::CacheInputStream(
     const Region& region,
     std::shared_ptr<ReadFileInputStream> input,
     uint64_t fileNum,
-    bool noCacheRetention,
+    bool cacheable,
     std::shared_ptr<ScanTracker> tracker,
     TrackingId trackingId,
     uint64_t groupId,
     int32_t loadQuantum)
     : bufferedInput_(bufferedInput),
       cache_(bufferedInput_->cache()),
-      noCacheRetention_(noCacheRetention),
+      cacheable_(cacheable),
       region_(region),
       fileNum_(fileNum),
       tracker_(std::move(tracker)),
@@ -53,12 +53,18 @@ CacheInputStream::CacheInputStream(
       input_(std::move(input)) {}
 
 CacheInputStream::~CacheInputStream() {
+  if (preloaded_) {
+    // Preloaded streams hold a shared pin copy. Just release it; eviction of
+    // the preloaded entry is handled by CachedBufferedInput destructor based
+    // on cacheable_ flag.
+    return;
+  }
   clearCachePin();
   makeCacheEvictable();
 }
 
 void CacheInputStream::makeCacheEvictable() {
-  if (!noCacheRetention_) {
+  if (preloaded_ || cacheable_) {
     return;
   }
   // Walks through the potential prefetch or access cache space of this cache
@@ -97,7 +103,7 @@ bool CacheInputStream::Next(const void** buffer, int32_t* size) {
   }
   offsetInRun_ += *size;
 
-  if (prefetchPct_ < 100) {
+  if (!preloaded_ && prefetchPct_ < 100) {
     const auto offsetInQuantum = position_ % loadQuantum_;
     const auto nextQuantumOffset = position_ - offsetInQuantum + loadQuantum_;
     const auto prefetchThreshold = loadQuantum_ * prefetchPct_ / 100;
@@ -142,8 +148,8 @@ bool CacheInputStream::SkipInt64(int64_t count) {
   return false;
 }
 
-google::protobuf::int64 CacheInputStream::ByteCount() const {
-  return static_cast<google::protobuf::int64>(position_);
+int64_t CacheInputStream::ByteCount() const {
+  return static_cast<int64_t>(position_);
 }
 
 void CacheInputStream::seekToPosition(PositionProvider& seekPosition) {
@@ -170,29 +176,6 @@ void CacheInputStream::setRemainingBytes(uint64_t remainingBytes) {
   window_ = Region{static_cast<uint64_t>(position_), remainingBytes};
 }
 
-namespace {
-std::vector<folly::Range<char*>> makeRanges(
-    cache::AsyncDataCacheEntry* entry,
-    size_t length) {
-  std::vector<folly::Range<char*>> buffers;
-  if (entry->tinyData() == nullptr) {
-    auto& allocation = entry->data();
-    buffers.reserve(allocation.numRuns());
-    uint64_t offsetInRuns = 0;
-    for (int i = 0; i < allocation.numRuns(); ++i) {
-      auto run = allocation.runAt(i);
-      uint64_t bytes = run.numPages() * memory::AllocationTraits::kPageSize;
-      uint64_t readSize = std::min(bytes, length - offsetInRuns);
-      buffers.push_back(folly::Range<char*>(run.data<char>(), readSize));
-      offsetInRuns += readSize;
-    }
-  } else {
-    buffers.push_back(folly::Range<char*>(entry->tinyData(), entry->size()));
-  }
-  return buffers;
-}
-} // namespace
-
 void CacheInputStream::loadSync(const Region& region) {
   process::TraceContext trace("loadSync");
   int64_t hitSize = region.length;
@@ -211,11 +194,16 @@ void CacheInputStream::loadSync(const Region& region) {
   // the individual parts are hit.
   ioStats_->incRawBytesRead(hitSize);
   prefetchStarted_ = false;
+
+  // TODO: add a maximum retry limit or timeout to prevent infinite loops under
+  // memory pressure or contention if findOrCreate() consistently returns empty
+  // pins.
   do {
     folly::SemiFuture<bool> cacheLoadWait(false);
     cache::RawFileCacheKey key{fileNum_, region.offset};
     clearCachePin();
-    pin_ = cache_->findOrCreate(key, region.length, &cacheLoadWait);
+    pin_ = cache_->findOrCreate(
+        key, region.length, /*contiguous=*/false, &cacheLoadWait);
     if (pin_.empty()) {
       VELOX_CHECK(cacheLoadWait.valid());
       uint64_t waitUs{0};
@@ -225,7 +213,8 @@ void CacheInputStream::loadSync(const Region& region) {
             .via(&folly::QueuedImmediateExecutor::instance())
             .wait();
       }
-      ioStats_->queryThreadIoLatency().increment(waitUs);
+      ioStats_->queryThreadIoLatencyUs().increment(waitUs);
+      ioStats_->cacheWaitLatencyUs().increment(waitUs);
       continue;
     }
 
@@ -245,24 +234,25 @@ void CacheInputStream::loadSync(const Region& region) {
     if (loadFromSsd(region, *entry)) {
       return;
     }
-    const auto ranges = makeRanges(entry, region.length);
+    const auto ranges = entry->dataRanges(region.length);
     uint64_t storageReadUs{0};
     {
       MicrosecondTimer timer(&storageReadUs);
       input_->read(ranges, region.offset, LogType::FILE);
     }
     ioStats_->read().increment(region.length);
-    ioStats_->queryThreadIoLatency().increment(storageReadUs);
-    ioStats_->incTotalScanTime(storageReadUs * 1'000);
-    entry->setExclusiveToShared(!noCacheRetention_);
+    ioStats_->queryThreadIoLatencyUs().increment(storageReadUs);
+    ioStats_->storageReadLatencyUs().increment(storageReadUs);
+    ioStats_->incTotalScanTimeNs(storageReadUs * 1'000);
+    entry->setExclusiveToShared(cacheable_);
   } while (pin_.empty());
 }
 
 void CacheInputStream::clearCachePin() {
-  if (pin_.empty()) {
+  if (preloaded_ || pin_.empty()) {
     return;
   }
-  if (noCacheRetention_) {
+  if (!cacheable_) {
     pin_.checkedEntry()->makeEvictable();
   }
   pin_.clear();
@@ -318,7 +308,8 @@ bool CacheInputStream::loadFromSsd(
   VELOX_CHECK(pin_.empty());
   pin_ = std::move(pins[0]);
   ioStats_->ssdRead().increment(region.length);
-  ioStats_->queryThreadIoLatency().increment(ssdLoadUs);
+  ioStats_->queryThreadIoLatencyUs().increment(ssdLoadUs);
+  ioStats_->ssdCacheReadLatencyUs().increment(ssdLoadUs);
   // Skip no-cache retention setting as data is loaded from ssd.
   entry.setExclusiveToShared();
   return true;
@@ -334,7 +325,9 @@ std::string CacheInputStream::ssdFileName() const {
 
 void CacheInputStream::loadPosition() {
   const auto offset = region_.offset;
+
   if (pin_.empty()) {
+    VELOX_CHECK(!preloaded_, "Preloaded stream must always have a valid pin");
     auto load = bufferedInput_->coalescedLoad(this);
     if (load != nullptr) {
       folly::SemiFuture<bool> waitFuture(false);
@@ -342,16 +335,21 @@ void CacheInputStream::loadPosition() {
       {
         MicrosecondTimer timer(&loadUs);
         try {
-          if (!load->loadOrFuture(&waitFuture, !noCacheRetention_)) {
+          if (!load->loadOrFuture(&waitFuture, cacheable_)) {
             waitFuture.wait();
           }
         } catch (const std::exception& e) {
-          // Log the error and continue. The error, if it persists, will be hit
-          // again in looking up the specific entry and thrown from there.
+          // Log the error and continue. The error, if it persists, will be
+          // hit again in looking up the specific entry and thrown from there.
           LOG(ERROR) << "IOERR: error in coalesced load " << e.what();
         }
       }
-      ioStats_->queryThreadIoLatency().increment(loadUs);
+      ioStats_->queryThreadIoLatencyUs().increment(loadUs);
+      if (load->isSsdLoad()) {
+        ioStats_->coalescedSsdLoadLatencyUs().increment(loadUs);
+      } else {
+        ioStats_->coalescedStorageLoadLatencyUs().increment(loadUs);
+      }
     }
 
     const auto nextLoadRegion = nextQuantizedLoadRegion(position_);
@@ -366,15 +364,16 @@ void CacheInputStream::loadPosition() {
       entry->offset() + entry->size() > positionInFile) {
     // The position is inside the range of 'entry'.
     const auto offsetInEntry = positionInFile - entry->offset();
-    if (entry->data().numPages() == 0) {
-      run_ = reinterpret_cast<uint8_t*>(entry->tinyData());
+    if (entry->hasContiguousData()) {
+      run_ = reinterpret_cast<uint8_t*>(entry->contiguousData());
       runSize_ = entry->size();
       offsetInRun_ = offsetInEntry;
       offsetOfRun_ = 0;
     } else {
-      entry->data().findRun(offsetInEntry, &runIndex_, &offsetInRun_);
+      entry->nonContiguousData().findRun(
+          offsetInEntry, &runIndex_, &offsetInRun_);
       offsetOfRun_ = offsetInEntry - offsetInRun_;
-      const auto run = entry->data().runAt(runIndex_);
+      const auto run = entry->nonContiguousData().runAt(runIndex_);
       run_ = run.data();
       runSize_ = memory::AllocationTraits::pageBytes(run.numPages());
       if (offsetOfRun_ + runSize_ > entry->size()) {
@@ -382,6 +381,14 @@ void CacheInputStream::loadPosition() {
       }
     }
   } else {
+    // Position is out of range for the current entry. This cannot happen for
+    // preloaded entries since they cover the entire file.
+    VELOX_CHECK(
+        !preloaded_,
+        "Position {} out of range for preloaded entry [{}, {})",
+        positionInFile,
+        entry->offset(),
+        entry->offset() + entry->size());
     clearCachePin();
     loadPosition();
   }
@@ -394,7 +401,7 @@ velox::common::Region CacheInputStream::nextQuantizedLoadRegion(
   nextRegion.offset += (prevLoadedPosition / loadQuantum_) * loadQuantum_;
   // Set length to be the lesser of 'loadQuantum_' and distance to end of
   // 'region_'
-  nextRegion.length = std::min<int32_t>(
+  nextRegion.length = std::min<uint64_t>(
       loadQuantum_, region_.length - (nextRegion.offset - region_.offset));
   return nextRegion;
 }
diff --git a/velox/dwio/common/CacheInputStream.h b/velox/dwio/common/CacheInputStream.h
index 195bdbdd135..272901e1cc7 100644
--- a/velox/dwio/common/CacheInputStream.h
+++ b/velox/dwio/common/CacheInputStream.h
@@ -35,7 +35,7 @@ class CacheInputStream : public SeekableInputStream {
       const velox::common::Region& region,
       std::shared_ptr<ReadFileInputStream> input,
       uint64_t fileNum,
-      bool noCacheRetention,
+      bool cacheable,
       std::shared_ptr<cache::ScanTracker> tracker,
       cache::TrackingId trackingId,
       uint64_t groupId,
@@ -51,7 +51,7 @@ class CacheInputStream : public SeekableInputStream {
   bool Next(const void** data, int* size) override;
   void BackUp(int count) override;
   bool SkipInt64(int64_t count) override;
-  google::protobuf::int64 ByteCount() const override;
+  int64_t ByteCount() const override;
   void seekToPosition(PositionProvider& position) override;
   std::string getName() const override;
   size_t positionSize() const override;
@@ -72,15 +72,26 @@ class CacheInputStream : public SeekableInputStream {
         region_,
         input_,
         fileNum_,
-        noCacheRetention_,
+        cacheable_,
         tracker_,
         trackingId_,
         groupId_,
         loadQuantum_);
     copy->position_ = position_;
+    if (preloaded_) {
+      copy->setPreloadedPin(pin_);
+    }
     return copy;
   }
 
+  /// Sets the stream to serve data from a preloaded whole-file cache entry.
+  /// The pin is copied so the stream can outlive the CachedBufferedInput. When
+  /// set, the stream skips coalesced loading, prefetching, and eviction.
+  void setPreloadedPin(cache::CachePin pin) {
+    pin_ = std::move(pin);
+    preloaded_ = true;
+  }
+
   /// Sets the stream to range over a window that starts at the current position
   /// and is 'remainingBytes' bytes in size. 'remainingBytes' must be <=
   /// 'region_.length - position_'. The stream cannot be used for reading
@@ -98,8 +109,8 @@ class CacheInputStream : public SeekableInputStream {
     prefetchPct_ = pct;
   }
 
-  bool testingNoCacheRetention() const {
-    return noCacheRetention_;
+  bool testingCacheable() const {
+    return cacheable_;
   }
 
  private:
@@ -120,7 +131,7 @@ class CacheInputStream : public SeekableInputStream {
       cache::AsyncDataCacheEntry& entry);
 
   // Invoked to clear the cache pin of the accessed cache entry and mark it as
-  // immediate evictable if 'noCacheRetention_' flag is set.
+  // immediate evictable if 'cacheable_' is false.
   void clearCachePin();
 
   void makeCacheEvictable();
@@ -131,10 +142,10 @@ class CacheInputStream : public SeekableInputStream {
 
   CachedBufferedInput* const bufferedInput_;
   cache::AsyncDataCache* const cache_;
-  // True if a pin should be set to the lowest retention score after
+  // False if a pin should be set to the lowest retention score after
   // unpinning. This applies to sequential reads where second access
   // to the page is not expected.
-  const bool noCacheRetention_;
+  const bool cacheable_;
   // The region of 'input' 'this' ranges over.
   const velox::common::Region region_;
   const uint64_t fileNum_;
@@ -152,15 +163,15 @@ class CacheInputStream : public SeekableInputStream {
   // Handle of cache entry.
   cache::CachePin pin_;
 
-  // Offset of current run from start of 'entry_->data()'
+  // Offset of current run from start of 'entry_->nonContiguousData()'
   uint64_t offsetOfRun_;
 
-  // Pointer  to start of  current run in 'entry->data()' or
-  // 'entry->tinyData()'.
+  // Pointer to start of current run in 'entry->nonContiguousData()' or
+  // 'entry->contiguousData()'.
   uint8_t* run_{nullptr};
   // Position of stream relative to 'run_'.
   int offsetInRun_{0};
-  // Index of run in 'entry_->data()'
+  // Index of run in 'entry_->nonContiguousData()'
   int runIndex_ = -1;
   // Number of valid bytes above 'run_'.
   uint32_t runSize_ = 0;
@@ -175,6 +186,10 @@ class CacheInputStream : public SeekableInputStream {
   // Over 100 means no prefetch.
   int32_t prefetchPct_{200};
 
+  // True if this stream serves data from a preloaded whole-file cache entry.
+  // When set, loading, prefetching, and eviction are all skipped.
+  bool preloaded_{false};
+
   // True if prefetch the next 'loadQuantum_' has been started. Cleared when
   // moving to the next load quantum.
   bool prefetchStarted_{false};
diff --git a/velox/dwio/common/CachedBufferedInput.cpp b/velox/dwio/common/CachedBufferedInput.cpp
index 26b59d265f6..be6bffb03de 100644
--- a/velox/dwio/common/CachedBufferedInput.cpp
+++ b/velox/dwio/common/CachedBufferedInput.cpp
@@ -15,8 +15,11 @@
  */
 
 #include "velox/dwio/common/CachedBufferedInput.h"
+#include "folly/io/Cursor.h"
+#include "velox/common/Casts.h"
 #include "velox/common/memory/Allocation.h"
 #include "velox/common/process/TraceContext.h"
+#include "velox/common/time/Timer.h"
 #include "velox/dwio/common/CacheInputStream.h"
 
 DECLARE_int32(cache_prefetch_min_pct);
@@ -47,29 +50,38 @@ std::unique_ptr<SeekableInputStream> CachedBufferedInput::enqueue(
     id = TrackingId(sid->getId());
   }
   VELOX_CHECK_LE(region.offset + region.length, fileSize_);
-  requests_.emplace_back(
-      RawFileCacheKey{fileNum_.id(), region.offset}, region.length, id);
   if (tracker_ != nullptr) {
     tracker_->recordReference(id, region.length, fileNum_.id(), groupId_.id());
   }
   auto stream = std::make_unique<CacheInputStream>(
       this,
-      ioStats_.get(),
+      ioStatistics_.get(),
       region,
       input_,
       fileNum_.id(),
-      options_.noCacheRetention(),
+      options_.cacheable(),
       tracker_,
       id,
       groupId_.id(),
       options_.loadQuantum());
-  requests_.back().stream = stream.get();
+  if (preloaded()) {
+    // Data is already in cache. Give the stream its own pin copy so it can
+    // outlive this CachedBufferedInput and skip all loading/prefetch logic.
+    stream->setPreloadedPin(preloadPin_);
+  } else {
+    requests_.emplace_back(
+        RawFileCacheKey{fileNum_.id(), region.offset}, region.length, id);
+    requests_.back().stream = stream.get();
+  }
   return stream;
 }
 
 bool CachedBufferedInput::isBuffered(uint64_t /*offset*/, uint64_t /*length*/)
     const {
-  return false;
+  // When preloaded, the entire file content is already in cache, so any
+  // region within the file is considered buffered and can be served without
+  // additional I/O.
+  return preloaded();
 }
 
 bool CachedBufferedInput::shouldPreload(int32_t numPages) {
@@ -82,7 +94,7 @@ bool CachedBufferedInput::shouldPreload(int32_t numPages) {
     numPages += memory::AllocationTraits::numPages(
         std::min<int32_t>(request.size, options_.loadQuantum()));
   }
-  const auto cachePages = cache_->incrementCachedPages(0);
+  const auto cachePages = cache_->cachedPages();
   auto* allocator = cache_->allocator();
   const auto maxPages =
       memory::AllocationTraits::numPages(allocator->capacity());
@@ -127,10 +139,11 @@ std::vector<CacheRequest*> makeRequestParts(
   std::vector<CacheRequest*> parts;
   for (uint64_t offset = 0; offset < request.size; offset += loadQuantum) {
     const int32_t size = std::min<int32_t>(loadQuantum, request.size - offset);
-    extraRequests.push_back(std::make_unique<CacheRequest>(
-        RawFileCacheKey{request.key.fileNum, request.key.offset + offset},
-        size,
-        request.trackingId));
+    extraRequests.push_back(
+        std::make_unique<CacheRequest>(
+            RawFileCacheKey{request.key.fileNum, request.key.offset + offset},
+            size,
+            request.trackingId));
     parts.push_back(extraRequests.back().get());
     parts.back()->coalesces = prefetch;
     if (prefetchOne) {
@@ -160,6 +173,52 @@ bool lessThan(const CacheRequest* left, const CacheRequest* right) {
 
 } // namespace
 
+void CachedBufferedInput::preload() {
+  VELOX_CHECK(preloadPin_.empty(), "preload() called more than once");
+  VELOX_CHECK(requests_.empty(), "preload() must be called before enqueue()");
+  cache::RawFileCacheKey key{fileNum_.id(), 0};
+  folly::SemiFuture<bool> waitFuture(false);
+  do {
+    preloadPin_ =
+        cache_->findOrCreate(key, fileSize_, /*contiguous=*/false, &waitFuture);
+    if (preloadPin_.empty()) {
+      uint64_t waitUs{0};
+      {
+        MicrosecondTimer timer(&waitUs);
+        std::move(waitFuture).wait();
+      }
+      ioStatistics_->queryThreadIoLatencyUs().increment(waitUs);
+      ioStatistics_->cacheWaitLatencyUs().increment(waitUs);
+    }
+  } while (preloadPin_.empty());
+
+  auto* entry = preloadPin_.checkedEntry();
+  if (!entry->getAndClearFirstUseFlag()) {
+    // Already loaded by another concurrent query.
+    ioStatistics_->ramHit().increment(fileSize_);
+  }
+  if (!entry->isExclusive()) {
+    // Cache hit — already loaded.
+    return;
+  }
+
+  entry->setGroupId(groupId_.id());
+  entry->setTrackingId(
+      cache::TrackingId(StreamIdentifier::sequentialFile().id_));
+  auto ranges = entry->dataRanges(fileSize_);
+  uint64_t storageReadUs{0};
+  {
+    MicrosecondTimer timer(&storageReadUs);
+    input_->read(ranges, 0, LogType::FILE);
+  }
+  ioStatistics_->read().increment(fileSize_);
+  ioStatistics_->incRawBytesRead(fileSize_);
+  ioStatistics_->queryThreadIoLatencyUs().increment(storageReadUs);
+  ioStatistics_->storageReadLatencyUs().increment(storageReadUs);
+  ioStatistics_->incTotalScanTimeNs(storageReadUs * 1'000);
+  entry->setExclusiveToShared(options_.cacheable());
+}
+
 void CachedBufferedInput::load(const LogType /*unused*/) {
   // 'requests_ is cleared on exit.
   auto requests = std::move(requests_);
@@ -193,8 +252,8 @@ void CachedBufferedInput::load(const LogType /*unused*/) {
       if (ssdFile != nullptr) {
         part->ssdPin = ssdFile->find(part->key);
         if (!part->ssdPin.empty() && part->ssdPin.run().size() < part->size) {
-          LOG(INFO) << "IOERR: Ignoring SSD shorter than requested: "
-                    << part->ssdPin.run().size() << " vs " << part->size;
+          LOG(WARNING) << "Ignoring SSD shorter than requested: "
+                       << part->ssdPin.run().size() << " vs " << part->size;
           part->ssdPin.clear();
         }
         if (!part->ssdPin.empty()) {
@@ -236,7 +295,7 @@ std::vector<int32_t> CachedBufferedInput::groupRequests(
   if (requests.empty() || (requests.size() < 2 && !prefetch)) {
     return {};
   }
-  const int32_t maxDistance = kSsd ? 20000 : options_.maxCoalesceDistance();
+  const int32_t maxDistance = kSsd ? 20'000 : options_.maxCoalesceDistance();
 
   // Combine adjacent short reads.
   int64_t coalescedBytes = 0;
@@ -278,14 +337,14 @@ class DwioCoalescedLoadBase : public cache::CoalescedLoad {
  public:
   DwioCoalescedLoadBase(
       cache::AsyncDataCache& cache,
-      std::shared_ptr<IoStatistics> ioStats,
-      std::shared_ptr<filesystems::File::IoStats> fsStats,
+      std::shared_ptr<IoStatistics> ioStatistics,
+      std::shared_ptr<velox::IoStats> ioStats,
       uint64_t groupId,
       std::vector<CacheRequest*> requests)
       : CoalescedLoad(makeKeys(requests), makeSizes(requests)),
         cache_(cache),
+        ioStatistics_(std::move(ioStatistics)),
         ioStats_(std::move(ioStats)),
-        fsStats_(std::move(fsStats)),
         groupId_(groupId) {
     requests_.reserve(requests.size());
     for (const auto& request : requests) {
@@ -320,17 +379,17 @@ class DwioCoalescedLoadBase : public cache::CoalescedLoad {
 
  protected:
   void updateStats(const CoalesceIoStats& stats, bool prefetch, bool ssd) {
-    if (ioStats_ == nullptr) {
+    if (ioStatistics_ == nullptr) {
       return;
     }
-    ioStats_->incRawOverreadBytes(stats.extraBytes);
+    ioStatistics_->incRawOverreadBytes(stats.extraBytes);
     if (ssd) {
-      ioStats_->ssdRead().increment(stats.payloadBytes);
+      ioStatistics_->ssdRead().increment(stats.payloadBytes);
     } else {
-      ioStats_->read().increment(stats.payloadBytes);
+      ioStatistics_->read().increment(stats.payloadBytes);
     }
     if (prefetch) {
-      ioStats_->prefetch().increment(stats.payloadBytes);
+      ioStatistics_->prefetch().increment(stats.payloadBytes);
     }
   }
 
@@ -355,8 +414,8 @@ class DwioCoalescedLoadBase : public cache::CoalescedLoad {
 
   cache::AsyncDataCache& cache_;
   std::vector<CacheRequest> requests_;
-  std::shared_ptr<IoStatistics> ioStats_;
-  std::shared_ptr<filesystems::File::IoStats> fsStats_;
+  std::shared_ptr<IoStatistics> ioStatistics_;
+  std::shared_ptr<velox::IoStats> ioStats_;
   const uint64_t groupId_;
   int64_t size_{0};
 };
@@ -367,20 +426,24 @@ class DwioCoalescedLoad : public DwioCoalescedLoadBase {
   DwioCoalescedLoad(
       cache::AsyncDataCache& cache,
       std::shared_ptr<ReadFileInputStream> input,
-      std::shared_ptr<IoStatistics> ioStats,
-      std::shared_ptr<filesystems::File::IoStats> fsStats,
+      std::shared_ptr<IoStatistics> ioStatistics,
+      std::shared_ptr<velox::IoStats> ioStats,
       uint64_t groupId,
       std::vector<CacheRequest*> requests,
       int32_t maxCoalesceDistance)
       : DwioCoalescedLoadBase(
             cache,
+            std::move(ioStatistics),
             std::move(ioStats),
-            std::move(fsStats),
             groupId,
             std::move(requests)),
         input_(std::move(input)),
         maxCoalesceDistance_(maxCoalesceDistance) {}
 
+  bool isSsdLoad() const override {
+    return false;
+  }
+
   std::vector<CachePin> loadData(bool prefetch) override {
     std::vector<CachePin> pins;
     pins.reserve(keys_.size());
@@ -421,17 +484,21 @@ class SsdLoad : public DwioCoalescedLoadBase {
  public:
   SsdLoad(
       cache::AsyncDataCache& cache,
-      std::shared_ptr<IoStatistics> ioStats,
-      std::shared_ptr<filesystems::File::IoStats> fsStats,
+      std::shared_ptr<IoStatistics> ioStatistics,
+      std::shared_ptr<velox::IoStats> ioStats,
       uint64_t groupId,
       std::vector<CacheRequest*> requests)
       : DwioCoalescedLoadBase(
             cache,
+            std::move(ioStatistics),
             std::move(ioStats),
-            std::move(fsStats),
             groupId,
             std::move(requests)) {}
 
+  bool isSsdLoad() const override {
+    return true;
+  }
+
   std::vector<CachePin> loadData(bool prefetch) override {
     std::vector<SsdPin> ssdPins;
     std::vector<CachePin> pins;
@@ -467,19 +534,19 @@ void CachedBufferedInput::readRegion(
   std::shared_ptr<cache::CoalescedLoad> load;
   if (!requests[0]->ssdPin.empty()) {
     load = std::make_shared<SsdLoad>(
-        *cache_, ioStats_, fsStats_, groupId_.id(), requests);
+        *cache_, ioStatistics_, ioStats_, groupId_.id(), requests);
   } else {
     load = std::make_shared<DwioCoalescedLoad>(
         *cache_,
         input_,
+        ioStatistics_,
         ioStats_,
-        fsStats_,
         groupId_.id(),
         requests,
         options_.maxCoalesceDistance());
   }
-  allCoalescedLoads_.push_back(load);
-  coalescedLoads_.withWLock([&](auto& loads) {
+  coalescedLoads_.push_back(load);
+  streamToCoalescedLoad_.withWLock([&](auto& loads) {
     for (auto& request : requests) {
       loads[request->stream] = load;
     }
@@ -490,52 +557,65 @@ void CachedBufferedInput::readRegions(
     const std::vector<CacheRequest*>& requests,
     bool prefetch,
     const std::vector<int32_t>& groupEnds) {
-  int i = 0;
-  std::vector<CacheRequest*> group;
-  for (auto end : groupEnds) {
-    while (i < end) {
-      group.push_back(requests[i++]);
+  if (requests.empty()) {
+    VELOX_CHECK(groupEnds.empty());
+    return;
+  }
+  // Record the starting position so that we only submit the loads created by
+  // this call. Without this, non-prefetch loads or stale loads from previous
+  // cycles could be incorrectly submitted for async prefetching.
+  const int32_t startIndex = static_cast<int32_t>(coalescedLoads_.size());
+  int32_t requestIdx{0};
+  std::vector<CacheRequest*> requestGroup;
+  for (auto groupEndIdx : groupEnds) {
+    while (requestIdx < groupEndIdx) {
+      requestGroup.push_back(requests[requestIdx++]);
     }
-    readRegion(group, prefetch);
-    group.clear();
+    readRegion(requestGroup, prefetch);
+    requestGroup.clear();
   }
+
   if (prefetch && executor_) {
-    std::vector<int32_t> doneIndices;
-    for (auto i = 0; i < allCoalescedLoads_.size(); ++i) {
-      auto& load = allCoalescedLoads_[i];
+    // Only submit the loads created by this call to the executor.
+    for (auto i = startIndex; i < coalescedLoads_.size(); ++i) {
+      auto& load = coalescedLoads_[i];
       if (load->state() == CoalescedLoad::State::kPlanned) {
         executor_->add(
-            [pendingLoad = load, ssdSavable = !options_.noCacheRetention()]() {
+            [pendingLoad = load, ssdSavable = options_.cacheable()]() {
               process::TraceContext trace("Read Ahead");
               pendingLoad->loadOrFuture(nullptr, ssdSavable);
             });
-      } else {
-        doneIndices.push_back(i);
       }
     }
     // Remove the loads that were complete. There can be done loads if the same
     // CachedBufferedInput has multiple cycles of enqueues and loads.
-    for (int i = 0, j = 0, k = 0; i < allCoalescedLoads_.size(); ++i) {
+    std::vector<int32_t> doneIndices;
+    for (int32_t i = 0; i < startIndex; ++i) {
+      if (coalescedLoads_[i]->state() != CoalescedLoad::State::kPlanned) {
+        doneIndices.push_back(i);
+      }
+    }
+    for (int i = 0, j = 0, k = 0; i < coalescedLoads_.size(); ++i) {
       if (j < doneIndices.size() && doneIndices[j] == i) {
         ++j;
       } else {
-        allCoalescedLoads_[k++] = std::move(allCoalescedLoads_[i]);
+        coalescedLoads_[k++] = std::move(coalescedLoads_[i]);
       }
     }
-    allCoalescedLoads_.resize(allCoalescedLoads_.size() - doneIndices.size());
+    coalescedLoads_.resize(coalescedLoads_.size() - doneIndices.size());
   }
 }
 
 std::shared_ptr<cache::CoalescedLoad> CachedBufferedInput::coalescedLoad(
     const SeekableInputStream* stream) {
-  return coalescedLoads_.withWLock(
+  return streamToCoalescedLoad_.withWLock(
       [&](auto& loads) -> std::shared_ptr<cache::CoalescedLoad> {
         auto it = loads.find(stream);
         if (it == loads.end()) {
           return nullptr;
         }
         auto load = std::move(it->second);
-        auto* dwioLoad = static_cast<DwioCoalescedLoadBase*>(load.get());
+        auto* dwioLoad = checkedPointerCast<DwioCoalescedLoadBase>(load.get());
         for (auto& request : dwioLoad->requests()) {
           loads.erase(request.stream);
         }
@@ -543,22 +623,36 @@ std::shared_ptr<cache::CoalescedLoad> CachedBufferedInput::coalescedLoad(
       });
 }
 
+void CachedBufferedInput::reset() {
+  BufferedInput::reset();
+  for (auto& load : coalescedLoads_) {
+    load->cancel();
+  }
+  coalescedLoads_.clear();
+  streamToCoalescedLoad_.wlock()->clear();
+  requests_.clear();
+}
+
 std::unique_ptr<SeekableInputStream> CachedBufferedInput::read(
     uint64_t offset,
     uint64_t length,
     LogType /*logType*/) const {
   VELOX_CHECK_LE(offset + length, fileSize_);
-  return std::make_unique<CacheInputStream>(
+  auto stream = std::make_unique<CacheInputStream>(
       const_cast<CachedBufferedInput*>(this),
-      ioStats_.get(),
+      ioStatistics_.get(),
       Region{offset, length},
       input_,
       fileNum_.id(),
-      options_.noCacheRetention(),
+      options_.cacheable(),
       nullptr,
       TrackingId(),
       0,
       options_.loadQuantum());
+  if (preloaded()) {
+    stream->setPreloadedPin(preloadPin_);
+  }
+  return stream;
 }
 
 bool CachedBufferedInput::prefetch(Region region) {
@@ -574,4 +668,89 @@ bool CachedBufferedInput::prefetch(Region region) {
   return true;
 }
 
+void CachedBufferedInput::cacheRegion(
+    uint64_t offset,
+    uint64_t length,
+    std::string_view data) {
+  VELOX_CHECK_EQ(data.size(), length);
+  auto iobuf = folly::IOBuf::wrapBufferAsValue(data.data(), data.size());
+  cacheRegion(offset, length, iobuf, 0);
+}
+
+void CachedBufferedInput::cacheRegion(
+    uint64_t offset,
+    uint64_t length,
+    const folly::IOBuf& buffer,
+    uint64_t bufferOffset) {
+  auto pin =
+      cache_->findOrCreate(RawFileCacheKey{fileNum_.id(), offset}, length);
+  // Empty pin means the cache is at capacity and cannot accept new entries.
+  // Non-exclusive means another thread already cached this region; skip the
+  // duplicate write.
+  if (pin.empty() || !pin.checkedEntry()->isExclusive()) {
+    return;
+  }
+
+  folly::io::Cursor cursor(&buffer);
+  cursor.skip(bufferOffset);
+  VELOX_CHECK_GE(
+      cursor.totalLength(),
+      length,
+      "IOBuf has {} bytes after offset {}, need {}",
+      cursor.totalLength(),
+      bufferOffset,
+      length);
+
+  auto* entry = pin.checkedEntry();
+  if (entry->hasContiguousData()) {
+    cursor.pull(entry->contiguousData(), length);
+  } else {
+    auto& allocation = entry->nonContiguousData();
+    uint64_t copyBytes = 0;
+    for (int i = 0; i < allocation.numRuns() && copyBytes < length; ++i) {
+      const auto run = allocation.runAt(i);
+      const uint64_t copySize =
+          std::min<uint64_t>(run.numBytes(), length - copyBytes);
+      cursor.pull(run.data(), copySize);
+      copyBytes += copySize;
+    }
+    VELOX_CHECK_EQ(copyBytes, length);
+  }
+
+  // Clear the first-use flag since this entry is being populated externally
+  // (not loaded on-demand). The first findCachedRegion access should count
+  // as a cache hit.
+  entry->getAndClearFirstUseFlag();
+  entry->setExclusiveToShared();
+}
+
+std::optional<CachedRegion> CachedBufferedInput::findCachedRegion(
+    uint64_t offset) const {
+  const cache::RawFileCacheKey key{fileNum_.id(), offset};
+  for (;;) {
+    folly::SemiFuture<bool> waitFuture(false);
+    auto result = cache_->find(key, &waitFuture);
+    if (!result.has_value()) {
+      return std::nullopt;
+    }
+    if (!result->empty()) {
+      auto* entry = result->checkedEntry();
+      if (!entry->getAndClearFirstUseFlag()) {
+        ioStatistics_->ramHit().increment(entry->size());
+      }
+      return CachedRegion{std::move(*result)};
+    }
+    // Entry is exclusive — wait for it to become shared, then retry.
+    uint64_t waitUs{0};
+    {
+      MicrosecondTimer timer(&waitUs);
+      std::move(waitFuture)
+          .via(&folly::QueuedImmediateExecutor::instance())
+          .wait();
+    }
+    ioStatistics_->queryThreadIoLatencyUs().increment(waitUs);
+    ioStatistics_->cacheWaitLatencyUs().increment(waitUs);
+  }
+}
+
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/CachedBufferedInput.h b/velox/dwio/common/CachedBufferedInput.h
index ddb08061c9b..bb246598e03 100644
--- a/velox/dwio/common/CachedBufferedInput.h
+++ b/velox/dwio/common/CachedBufferedInput.h
@@ -27,8 +27,6 @@
 #include "velox/dwio/common/CacheInputStream.h"
 #include "velox/dwio/common/InputStream.h"
 
-DECLARE_int32(cache_load_quantum);
-
 namespace facebook::velox::dwio::common {
 
 struct CacheRequest {
@@ -61,25 +59,31 @@ class CachedBufferedInput : public BufferedInput {
       cache::AsyncDataCache* cache,
       std::shared_ptr<cache::ScanTracker> tracker,
       StringIdLease groupId,
-      std::shared_ptr<IoStatistics> ioStats,
-      std::shared_ptr<filesystems::File::IoStats> fsStats,
+      std::shared_ptr<IoStatistics> ioStatistics,
+      std::shared_ptr<velox::IoStats> ioStats,
       folly::Executor* executor,
-      const io::ReaderOptions& readerOptions)
+      const io::ReaderOptions& readerOptions,
+      folly::F14FastMap<std::string, std::string> fileReadOps = {})
       : BufferedInput(
             std::move(readFile),
             readerOptions.memoryPool(),
             metricsLog,
+            ioStatistics.get(),
             ioStats.get(),
-            fsStats.get()),
+            kMaxMergeDistance,
+            std::nullopt,
+            std::move(fileReadOps),
+            readerOptions.cacheable()),
         cache_(cache),
         fileNum_(std::move(fileNum)),
         tracker_(std::move(tracker)),
         groupId_(std::move(groupId)),
+        ioStatistics_(std::move(ioStatistics)),
         ioStats_(std::move(ioStats)),
-        fsStats_(std::move(fsStats)),
         executor_(executor),
         fileSize_(input_->getLength()),
         options_(readerOptions) {
+    VELOX_CHECK_NOT_NULL(cache_, "CachedBufferedInput requires a cache");
     checkLoadQuantum();
   }
 
@@ -89,8 +93,8 @@ class CachedBufferedInput : public BufferedInput {
       cache::AsyncDataCache* cache,
       std::shared_ptr<cache::ScanTracker> tracker,
       StringIdLease groupId,
-      std::shared_ptr<IoStatistics> ioStats,
-      std::shared_ptr<filesystems::File::IoStats> fsStats,
+      std::shared_ptr<IoStatistics> ioStatistics,
+      std::shared_ptr<velox::IoStats> ioStats,
       folly::Executor* executor,
       const io::ReaderOptions& readerOptions)
       : BufferedInput(std::move(input), readerOptions.memoryPool()),
@@ -98,26 +102,32 @@ class CachedBufferedInput : public BufferedInput {
         fileNum_(std::move(fileNum)),
         tracker_(std::move(tracker)),
         groupId_(std::move(groupId)),
+        ioStatistics_(std::move(ioStatistics)),
         ioStats_(std::move(ioStats)),
-        fsStats_(std::move(fsStats)),
         executor_(executor),
         fileSize_(input_->getLength()),
         options_(readerOptions) {
+    VELOX_CHECK_NOT_NULL(cache_, "CachedBufferedInput requires a cache");
     checkLoadQuantum();
   }
 
   ~CachedBufferedInput() override {
-    for (auto& load : allCoalescedLoads_) {
+    for (auto& load : coalescedLoads_) {
       load->cancel();
     }
+    if (!options_.cacheable() && !preloadPin_.empty()) {
+      preloadPin_.checkedEntry()->makeEvictable();
+    }
   }
 
   std::unique_ptr<SeekableInputStream> enqueue(
       velox::common::Region region,
       const StreamIdentifier* sid) override;
 
-  bool supportSyncLoad() const override {
-    return false;
+  void preload() override;
+
+  bool preloaded() const override {
+    return !preloadPin_.empty();
   }
 
   void load(const LogType /*unused*/) override;
@@ -151,16 +161,50 @@ class CachedBufferedInput : public BufferedInput {
         cache_,
         tracker_,
         groupId_,
+        ioStatistics_,
         ioStats_,
-        fsStats_,
         executor_,
         options_);
   }
 
+  /// Creates a clone that reads through the cache but marks entries as
+  /// immediately evictable on destruction (cacheable=false). Use when the
+  /// caller has its own caching layer (e.g., MetadataCache) and does not need
+  /// AsyncDataCache to retain the raw bytes.
+  std::unique_ptr<CachedBufferedInput> cloneNonCacheable() const {
+    auto nonCacheableOptions = options_;
+    nonCacheableOptions.setCacheable(false);
+    return std::make_unique<CachedBufferedInput>(
+        input_,
+        fileNum_,
+        cache_,
+        tracker_,
+        groupId_,
+        ioStatistics_,
+        ioStats_,
+        executor_,
+        nonCacheableOptions);
+  }
+
   cache::AsyncDataCache* cache() const {
     return cache_;
   }
 
+  bool hasCache() const override {
+    return true;
+  }
+
+  void cacheRegion(uint64_t offset, uint64_t length, std::string_view data)
+      override;
+
+  void cacheRegion(
+      uint64_t offset,
+      uint64_t length,
+      const folly::IOBuf& buffer,
+      uint64_t bufferOffset) override;
+
+  std::optional<CachedRegion> findCachedRegion(uint64_t offset) const override;
+
   /// Returns the CoalescedLoad that contains the correlated loads for 'stream'
   /// or nullptr if none. Returns nullptr on all but first call for 'stream'
   /// since the load is to be triggered by the first access.
@@ -175,6 +219,18 @@ class CachedBufferedInput : public BufferedInput {
     VELOX_NYI();
   }
 
+  /// Resets the buffered input for reuse across different operations.
+  void reset() override;
+
+  const std::vector<std::shared_ptr<cache::CoalescedLoad>>&
+  testingCoalescedLoads() const {
+    return coalescedLoads_;
+  }
+
+  size_t testingStreamToCoalescedLoadSize() const {
+    return streamToCoalescedLoad_.rlock()->size();
+  }
+
  private:
   template <bool kSsd>
   std::vector<int32_t> groupRequests(
@@ -213,8 +269,8 @@ class CachedBufferedInput : public BufferedInput {
   const StringIdLease fileNum_;
   const std::shared_ptr<cache::ScanTracker> tracker_;
   const StringIdLease groupId_;
-  const std::shared_ptr<IoStatistics> ioStats_;
-  const std::shared_ptr<filesystems::File::IoStats> fsStats_;
+  const std::shared_ptr<IoStatistics> ioStatistics_;
+  const std::shared_ptr<velox::IoStats> ioStats_;
   folly::Executor* const executor_;
   const uint64_t fileSize_;
   const io::ReaderOptions options_;
@@ -222,14 +278,18 @@ class CachedBufferedInput : public BufferedInput {
   // Regions that are candidates for loading.
   std::vector<CacheRequest> requests_;
 
-  // Coalesced loads spanning multiple cache entries in one IO.
+  // Map from stream to its coalesced load.
   folly::Synchronized<folly::F14FastMap<
       const SeekableInputStream*,
       std::shared_ptr<cache::CoalescedLoad>>>
-      coalescedLoads_;
+      streamToCoalescedLoad_;
+
+  // All distinct coalesced loads.
+  std::vector<std::shared_ptr<cache::CoalescedLoad>> coalescedLoads_;
 
-  // Distinct coalesced loads in 'coalescedLoads_'.
-  std::vector<std::shared_ptr<cache::CoalescedLoad>> allCoalescedLoads_;
+  // Holds the whole-file cache entry alive for the lifetime of this input.
+  // Set by preload(), used by CacheInputStream to serve sub-region reads.
+  cache::CachePin preloadPin_;
 };
 
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/ChainedBuffer.h b/velox/dwio/common/ChainedBuffer.h
index 7b514d6b460..38ba8d7c269 100644
--- a/velox/dwio/common/ChainedBuffer.h
+++ b/velox/dwio/common/ChainedBuffer.h
@@ -20,10 +20,7 @@
 #include "velox/common/base/GTestMacros.h"
 #include "velox/dwio/common/DataBuffer.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
 
 namespace {
 
@@ -228,7 +225,4 @@ class ChainedBuffer {
   VELOX_FRIEND_TEST(ChainedBufferTests, testClearAll);
 };
 
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/ColumnLoader.cpp b/velox/dwio/common/ColumnLoader.cpp
index 7d62008440b..c2d211d89e8 100644
--- a/velox/dwio/common/ColumnLoader.cpp
+++ b/velox/dwio/common/ColumnLoader.cpp
@@ -56,7 +56,7 @@ RowSet read(
 
   structReader->advanceFieldReader(fieldReader, offset);
   fieldReader->scanSpec()->setValueHook(hook);
-  fieldReader->read(offset, effectiveRows, incomingNulls);
+  fieldReader->readWithTiming(offset, effectiveRows, incomingNulls);
   if (fieldReader->fileType().type()->isRow() ||
       fieldReader->scanSpec()->isFlatMapAsStruct()) {
     // 'fieldReader_' may itself produce LazyVectors. For this it must have its
@@ -116,6 +116,19 @@ void ColumnLoader::loadInternal(
   }
 }
 
+void TransformColumnLoader::loadInternal(
+    RowSet rows,
+    ValueHook* hook,
+    vector_size_t resultSize,
+    VectorPtr* result) {
+  process::TraceContext trace("TransformColumnLoader::loadInternal");
+  VectorPtr fileResult;
+  ColumnLoader::loadInternal(rows, hook, resultSize, &fileResult);
+  if (fileResult) {
+    *result = transform_(fileResult, fieldReader_->memoryPool());
+  }
+}
+
 void DeltaUpdateColumnLoader::loadInternal(
     RowSet rows,
     ValueHook* hook,
diff --git a/velox/dwio/common/ColumnLoader.h b/velox/dwio/common/ColumnLoader.h
index 50950b74e6e..07c0bca6fb2 100644
--- a/velox/dwio/common/ColumnLoader.h
+++ b/velox/dwio/common/ColumnLoader.h
@@ -16,7 +16,9 @@
 
 #pragma once
 
+#include "velox/dwio/common/ScanSpec.h"
 #include "velox/dwio/common/SelectiveStructColumnReader.h"
+#include "velox/vector/LazyVector.h"
 
 namespace facebook::velox::dwio::common {
 
@@ -30,11 +32,13 @@ class ColumnLoader : public VectorLoader {
         fieldReader_(fieldReader),
         version_(version) {}
 
+  virtual ~ColumnLoader() = default;
+
   bool supportsHook() const override {
     return true;
   }
 
- private:
+ protected:
   void loadInternal(
       RowSet rows,
       ValueHook* hook,
@@ -49,6 +53,34 @@ class ColumnLoader : public VectorLoader {
   const uint64_t version_;
 };
 
+/// Wraps a ColumnLoader and applies a post-read transform when the lazy
+/// vector is loaded.  Used for mixed extraction transforms where the reader
+/// produces the file type and the transform converts to the extraction
+/// output type (e.g., MAP → ROW<keys, sz> for MapKeys + Size extractions).
+class TransformColumnLoader : public ColumnLoader {
+ public:
+  TransformColumnLoader(
+      SelectiveStructColumnReaderBase* structReader,
+      SelectiveColumnReader* fieldReader,
+      uint64_t version,
+      common::ScanSpec::VectorTransform transform)
+      : ColumnLoader(structReader, fieldReader, version),
+        transform_(std::move(transform)) {}
+
+  bool supportsHook() const override {
+    return false;
+  }
+
+ private:
+  void loadInternal(
+      RowSet rows,
+      ValueHook* hook,
+      vector_size_t resultSize,
+      VectorPtr* result) override;
+
+  common::ScanSpec::VectorTransform transform_;
+};
+
 class DeltaUpdateColumnLoader : public VectorLoader {
  public:
   DeltaUpdateColumnLoader(
diff --git a/velox/dwio/common/ColumnSelector.h b/velox/dwio/common/ColumnSelector.h
index 62408e55a21..9bef521d99a 100644
--- a/velox/dwio/common/ColumnSelector.h
+++ b/velox/dwio/common/ColumnSelector.h
@@ -388,8 +388,10 @@ class ColumnSelector {
     // expect a runtime_error rather than fault.
     // Do-Not change the message as expected by client in failure case
     if (!notFound.empty()) {
-      throw std::runtime_error(folly::to<std::string>(
-          "Columns not found in hive table: ", folly::join(", ", notFound)));
+      throw std::runtime_error(
+          folly::to<std::string>(
+              "Columns not found in hive table: ",
+              folly::join(", ", notFound)));
     }
   }
 
diff --git a/velox/dwio/common/ColumnVisitors.h b/velox/dwio/common/ColumnVisitors.h
index e4a507370bc..33d7a2d6e32 100644
--- a/velox/dwio/common/ColumnVisitors.h
+++ b/velox/dwio/common/ColumnVisitors.h
@@ -491,7 +491,7 @@ class ColumnVisitor {
 
  protected:
   const TFilter& filter_;
-  SelectiveColumnReader* reader_;
+  SelectiveColumnReader* const reader_;
   const bool allowNulls_;
   const vector_size_t* rows_;
   vector_size_t numRows_;
@@ -928,8 +928,9 @@ class DictionaryColumnVisitor
           (simd::reinterpretBatch<uint32_t>(cache) &
            xsimd::batch<uint32_t>(1)) != xsimd::batch<uint32_t>(0));
 #else
-      auto unknowns = simd::toBitMask(xsimd::batch_bool<int32_t>(
-          simd::reinterpretBatch<uint32_t>((cache & (kUnknown << 24)) << 1)));
+      auto unknowns = simd::toBitMask(
+          xsimd::batch_bool<int32_t>(simd::reinterpretBatch<uint32_t>(
+              (cache & (kUnknown << 24)) << 1)));
       auto passed = simd::toBitMask(
           xsimd::batch_bool<int32_t>(simd::reinterpretBatch<uint32_t>(cache)));
 #endif
@@ -1175,7 +1176,7 @@ ColumnVisitor<T, TFilter, ExtractValues, isDense, hasBulkPath>::
   }
   auto result = DictionaryColumnVisitor<T, TFilter, ExtractValues, isDense>(
       filter_, reader_, RowSet(rows_ + rowIndex_, numRows_), values_);
-  result.numValuesBias_ = numValuesBias_;
+  result.setNumValuesBias(numValuesBias_);
   return result;
 }
 
@@ -1227,7 +1228,14 @@ class StringDictionaryColumnVisitor
     vector_size_t previous =
         isDense && TFilter::deterministic ? 0 : super::currentRow();
     if constexpr (!DictSuper::hasFilter()) {
-      super::filterPassed(index);
+      // Hooks are LazyVector-level and have no access to the dictionary.
+      // They must receive decoded StringView values, not dictionary indices.
+      if constexpr (super::kHasHook) {
+        super::values_.addValue(
+            super::rowIndex_ + super::numValuesBias_, valueInDictionary(index));
+      } else {
+        super::filterPassed(index);
+      }
     } else {
       // check the dictionary cache
       if (TFilter::deterministic &&
@@ -1329,8 +1337,9 @@ class StringDictionaryColumnVisitor
           (simd::reinterpretBatch<uint32_t>(cache) &
            xsimd::batch<uint32_t>(1)) != xsimd::batch<uint32_t>(0));
 #else
-      auto unknowns = simd::toBitMask(xsimd::batch_bool<int32_t>(
-          simd::reinterpretBatch<uint32_t>((cache & (kUnknown << 24)) << 1)));
+      auto unknowns = simd::toBitMask(
+          xsimd::batch_bool<int32_t>(simd::reinterpretBatch<uint32_t>(
+              (cache & (kUnknown << 24)) << 1)));
       auto passed = simd::toBitMask(
           xsimd::batch_bool<int32_t>(simd::reinterpretBatch<uint32_t>(cache)));
 #endif
@@ -1419,7 +1428,7 @@ class StringDictionaryColumnVisitor
     }
   }
 
-  folly::StringPiece valueInDictionary(int64_t index) {
+  StringView valueInDictionary(int64_t index) {
     auto stripeDictSize = DictSuper::state_.dictionary.numValues;
     if (index < stripeDictSize) {
       return reinterpret_cast<const StringView*>(
@@ -1576,7 +1585,7 @@ class StringColumnReadWithVisitorHelper {
       ExtractValues extractValues,
       F readWithVisitor) {
     readWithVisitor(
-        ColumnVisitor<folly::StringPiece, TFilter, ExtractValues, kIsDense>(
+        ColumnVisitor<std::string_view, TFilter, ExtractValues, kIsDense>(
             *static_cast<const TFilter*>(filter),
             &reader_,
             rows_,
diff --git a/velox/dwio/common/DataBuffer.h b/velox/dwio/common/DataBuffer.h
index ba84cb45a21..1f2964c1a61 100644
--- a/velox/dwio/common/DataBuffer.h
+++ b/velox/dwio/common/DataBuffer.h
@@ -23,10 +23,7 @@
 #include "velox/common/memory/Memory.h"
 #include "velox/dwio/common/exception/Exception.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
 
 template <typename T, typename = std::enable_if_t<std::is_trivial_v<T>>>
 class DataBuffer {
@@ -34,8 +31,9 @@ class DataBuffer {
   explicit DataBuffer(velox::memory::MemoryPool& pool, uint64_t size = 0)
       : pool_(&pool),
         // Initial allocation uses calloc, to avoid memset.
-        buf_(reinterpret_cast<T*>(
-            pool_->allocateZeroFilled(1, sizeInBytes(size)))),
+        buf_(
+            reinterpret_cast<T*>(
+                pool_->allocateZeroFilled(1, sizeInBytes(size)))),
         size_(size),
         capacity_(size) {
     VELOX_CHECK(buf_ != nullptr || size_ == 0);
@@ -233,7 +231,5 @@ class DataBuffer {
   // Maximum capacity of items of type T.
   uint64_t capacity_;
 };
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/DataBufferHolder.cpp b/velox/dwio/common/DataBufferHolder.cpp
index f6ff2757a35..0f5b246f062 100644
--- a/velox/dwio/common/DataBufferHolder.cpp
+++ b/velox/dwio/common/DataBufferHolder.cpp
@@ -21,7 +21,7 @@ using facebook::velox::common::testutil::TestValue;
 
 namespace facebook::velox::dwio::common {
 
-void DataBufferHolder::take(const std::vector<folly::StringPiece>& buffers) {
+void DataBufferHolder::take(const std::vector<std::string_view>& buffers) {
   // compute size
   uint64_t totalSize = 0;
   for (auto& buf : buffers) {
@@ -38,7 +38,7 @@ void DataBufferHolder::take(const std::vector<folly::StringPiece>& buffers) {
   auto* data = buf.data();
   for (auto& buffer : buffers) {
     const auto size = buffer.size();
-    ::memcpy(data, buffer.begin(), size);
+    ::memcpy(data, buffer.cbegin(), size);
     data += size;
   }
   // If possibly, write content of the data to output immediately. Otherwise,
diff --git a/velox/dwio/common/DataBufferHolder.h b/velox/dwio/common/DataBufferHolder.h
index 1c291f13328..91f4fe56007 100644
--- a/velox/dwio/common/DataBufferHolder.h
+++ b/velox/dwio/common/DataBufferHolder.h
@@ -47,14 +47,14 @@ class DataBufferHolder {
 
   /// Takes content of the incoming data buffer. It is the caller's
   /// responsibility to resize the buffer (if required).
-  void take(const std::vector<folly::StringPiece>& buffers);
+  void take(const std::vector<std::string_view>& buffers);
 
-  void take(folly::StringPiece buffer) {
-    take(std::vector<folly::StringPiece>{buffer});
+  void take(std::string_view buffer) {
+    take(std::vector<std::string_view>{buffer});
   }
 
   void take(const dwio::common::DataBuffer<char>& buffer) {
-    take(folly::StringPiece{buffer.data(), buffer.size()});
+    take(std::string_view{buffer.data(), buffer.size()});
   }
 
   std::vector<dwio::common::DataBuffer<char>>& getBuffers() {
diff --git a/velox/dwio/common/DecoderUtil.h b/velox/dwio/common/DecoderUtil.h
index 9527915e099..b572058d9ee 100644
--- a/velox/dwio/common/DecoderUtil.h
+++ b/velox/dwio/common/DecoderUtil.h
@@ -202,11 +202,20 @@ void fixedWidthScan(
           int32_t numRowsInBuffer,
           int32_t rowOffset,
           const T* buffer) {
-        rowLoop(
+        if constexpr (!hasFilter && !hasHook && !scatter) {
+          if (isDense(&rows[rowIndex], numRowsInBuffer)) {
+            std::memcpy(
+                rawValues + numValues,
+                buffer + rows[rowIndex] - rowOffset,
+                sizeof(T) * numRowsInBuffer);
+            numValues += numRowsInBuffer;
+            return;
+          }
+        }
+        rowLoop<kStep>(
             rows,
             rowIndex,
             rowIndex + numRowsInBuffer,
-            kStep,
             [&](int32_t rowIndex) {
               auto firstRow = rows[rowIndex];
               if (!hasFilter) {
@@ -223,7 +232,7 @@ void fixedWidthScan(
                         kStep,
                         rawValues);
                   } else {
-                    simd::memcpy(
+                    FOLLY_BUILTIN_MEMCPY(
                         rawValues + numValues,
                         buffer + firstRow - rowOffset,
                         sizeof(T) * kStep);
diff --git a/velox/dwio/common/DirectBufferedInput.cpp b/velox/dwio/common/DirectBufferedInput.cpp
index 1b5e4faafa5..58076fcb512 100644
--- a/velox/dwio/common/DirectBufferedInput.cpp
+++ b/velox/dwio/common/DirectBufferedInput.cpp
@@ -49,13 +49,12 @@ std::unique_ptr<SeekableInputStream> DirectBufferedInput::enqueue(
     id = TrackingId(sid->getId());
   }
   VELOX_CHECK_LE(region.offset + region.length, fileSize_);
-  requests_.emplace_back(region, id);
   if (tracker_) {
     tracker_->recordReference(id, region.length, fileNum_.id(), groupId_.id());
   }
   auto stream = std::make_unique<DirectInputStream>(
       this,
-      ioStats_.get(),
+      ioStatistics_.get(),
       region,
       input_,
       fileNum_.id(),
@@ -63,13 +62,21 @@ std::unique_ptr<SeekableInputStream> DirectBufferedInput::enqueue(
       id,
       groupId_.id(),
       options_.loadQuantum());
-  requests_.back().stream = stream.get();
+  if (!preloaded()) {
+    // Only track requests when not preloaded. Preloaded streams serve data
+    // directly from preloadData_ without going through coalesced loads.
+    requests_.emplace_back(region, id);
+    requests_.back().stream = stream.get();
+  }
   return stream;
 }
 
 bool DirectBufferedInput::isBuffered(uint64_t /*offset*/, uint64_t /*length*/)
     const {
-  return false;
+  // When preloaded, the entire file content is already in memory, so any
+  // region within the file is considered buffered and can be served without
+  // additional I/O.
+  return preloaded();
 }
 
 bool DirectBufferedInput::shouldPreload(int32_t numPages) {
@@ -187,8 +194,8 @@ void DirectBufferedInput::readRegion(
   }
   auto load = std::make_shared<DirectCoalescedLoad>(
       input_,
+      ioStatistics_,
       ioStats_,
-      fsStats_,
       groupId_.id(),
       requests,
       pool_,
@@ -235,7 +242,7 @@ std::shared_ptr<DirectCoalescedLoad> DirectBufferedInput::coalescedLoad(
   return streamToCoalescedLoad_.withWLock(
       [&](auto& loads) -> std::shared_ptr<DirectCoalescedLoad> {
         auto it = loads.find(stream);
-        if (it == loads.end()) {
+        if (it == loads.cend()) {
           return nullptr;
         }
         auto load = std::move(it->second);
@@ -244,39 +251,105 @@ std::shared_ptr<DirectCoalescedLoad> DirectBufferedInput::coalescedLoad(
       });
 }
 
-std::unique_ptr<SeekableInputStream> DirectBufferedInput::read(
-    uint64_t offset,
-    uint64_t length,
-    LogType /*logType*/) const {
-  VELOX_CHECK_LE(offset + length, fileSize_);
-  return std::make_unique<DirectInputStream>(
-      const_cast<DirectBufferedInput*>(this),
-      ioStats_.get(),
-      Region{offset, length},
-      input_,
-      fileNum_.id(),
-      nullptr,
-      TrackingId(),
-      0,
-      options_.loadQuantum());
+void DirectBufferedInput::reset() {
+  BufferedInput::reset();
+  for (auto& load : coalescedLoads_) {
+    load->cancel();
+  }
+  coalescedLoads_.clear();
+  streamToCoalescedLoad_.wlock()->clear();
+  requests_.clear();
 }
 
 namespace {
 void appendRanges(
-    memory::Allocation& allocation,
+    const memory::Allocation& allocation,
     size_t length,
     std::vector<folly::Range<char*>>& buffers) {
+  VELOX_CHECK_LE(
+      length,
+      memory::AllocationTraits::pageBytes(allocation.numPages()),
+      "Length exceeds allocation size");
+  buffers.reserve(buffers.size() + allocation.numRuns());
   uint64_t offsetInRuns = 0;
   for (int i = 0; i < allocation.numRuns(); ++i) {
+    VELOX_CHECK_GE(length, offsetInRuns);
     auto run = allocation.runAt(i);
     const uint64_t bytes = memory::AllocationTraits::pageBytes(run.numPages());
     const uint64_t readSize = std::min(bytes, length - offsetInRuns);
-    buffers.push_back(folly::Range<char*>(run.data<char>(), readSize));
+    buffers.emplace_back(run.data<char>(), readSize);
     offsetInRuns += readSize;
+    if (offsetInRuns >= length) {
+      break;
+    }
   }
 }
 } // namespace
 
+void DirectBufferedInput::preload() {
+  VELOX_CHECK(!preloadData_.has_value(), "preload() called more than once");
+  VELOX_CHECK(requests_.empty(), "preload() must be called before enqueue()");
+  preloadData_.emplace();
+  preloadData_->size = fileSize_;
+  uint64_t storageReadUs{0};
+  {
+    MicrosecondTimer timer(&storageReadUs);
+    if (fileSize_ <= kTinySize) {
+      preloadData_->tinyData.resize(fileSize_);
+      input_->read(preloadData_->tinyData.data(), fileSize_, 0, LogType::FILE);
+    } else {
+      const auto numPages = memory::AllocationTraits::numPages(fileSize_);
+      pool_->allocateNonContiguous(numPages, preloadData_->data);
+      std::vector<folly::Range<char*>> buffers;
+      appendRanges(preloadData_->data, fileSize_, buffers);
+      input_->read(buffers, 0, LogType::FILE);
+    }
+  }
+  ioStatistics_->read().increment(fileSize_);
+  ioStatistics_->incRawBytesRead(fileSize_);
+  ioStatistics_->queryThreadIoLatencyUs().increment(storageReadUs);
+  ioStatistics_->storageReadLatencyUs().increment(storageReadUs);
+  ioStatistics_->incTotalScanTimeNs(storageReadUs * 1'000);
+}
+
+folly::Range<const char*> DirectBufferedInput::preloadedData(
+    uint64_t offset,
+    uint64_t length) const {
+  VELOX_CHECK(
+      preloadData_.has_value(), "preloadedData() called without preload");
+  VELOX_CHECK_LT(offset, preloadData_->size, "Offset exceeds preloaded size");
+  const auto available =
+      std::min<uint64_t>(length, preloadData_->size - offset);
+  if (preloadData_->data.numPages() == 0) {
+    return {preloadData_->tinyData.data() + offset, available};
+  }
+  int32_t runIndex;
+  int32_t offsetInRun;
+  preloadData_->data.findRun(offset, &runIndex, &offsetInRun);
+  const auto run = preloadData_->data.runAt(runIndex);
+  const auto runBytes = memory::AllocationTraits::pageBytes(run.numPages());
+  const auto contiguousBytes =
+      std::min<uint64_t>(available, runBytes - offsetInRun);
+  return {run.data<const char>() + offsetInRun, contiguousBytes};
+}
+
+std::unique_ptr<SeekableInputStream> DirectBufferedInput::read(
+    uint64_t offset,
+    uint64_t length,
+    LogType /*logType*/) const {
+  VELOX_CHECK_LE(offset + length, fileSize_);
+  return std::make_unique<DirectInputStream>(
+      const_cast<DirectBufferedInput*>(this),
+      ioStatistics_.get(),
+      Region{offset, length},
+      input_,
+      fileNum_.id(),
+      nullptr,
+      TrackingId(),
+      0,
+      options_.loadQuantum());
+}
+
 std::vector<cache::CachePin> DirectCoalescedLoad::loadData(bool prefetch) {
   std::vector<folly::Range<char*>> buffers;
   int64_t lastEnd = requests_[0].region.offset;
@@ -286,10 +359,11 @@ std::vector<cache::CachePin> DirectCoalescedLoad::loadData(bool prefetch) {
   for (auto& request : requests_) {
     const auto& region = request.region;
     if (region.offset > lastEnd) {
-      buffers.push_back(folly::Range<char*>(
-          nullptr,
-          reinterpret_cast<char*>(
-              static_cast<uint64_t>(region.offset - lastEnd))));
+      buffers.push_back(
+          folly::Range<char*>(
+              nullptr,
+              reinterpret_cast<char*>(
+                  static_cast<uint64_t>(region.offset - lastEnd))));
       overread += buffers.back().size();
     }
 
@@ -321,13 +395,14 @@ std::vector<cache::CachePin> DirectCoalescedLoad::loadData(bool prefetch) {
     input_->read(buffers, requests_[0].region.offset, LogType::FILE);
   }
 
-  ioStats_->read().increment(size + overread);
-  ioStats_->incRawBytesRead(size);
-  ioStats_->incTotalScanTime(usecs * 1'000);
-  ioStats_->queryThreadIoLatency().increment(usecs);
-  ioStats_->incRawOverreadBytes(overread);
+  ioStatistics_->read().increment(size + overread);
+  ioStatistics_->incRawBytesRead(size);
+  ioStatistics_->incTotalScanTimeNs(usecs * 1'000);
+  ioStatistics_->queryThreadIoLatencyUs().increment(usecs);
+  ioStatistics_->storageReadLatencyUs().increment(usecs);
+  ioStatistics_->incRawOverreadBytes(overread);
   if (prefetch) {
-    ioStats_->prefetch().increment(size + overread);
+    ioStatistics_->prefetch().increment(size + overread);
   }
   TestValue::adjust(
       "facebook::velox::cache::DirectCoalescedLoad::loadData", this);
@@ -342,7 +417,7 @@ int32_t DirectCoalescedLoad::getData(
       requests_.begin(), requests_.end(), offset, [](auto& x, auto offset) {
         return x.region.offset < offset;
       });
-  if (it == requests_.end() || it->region.offset != offset) {
+  if (it == requests_.cend() || it->region.offset != offset) {
     return 0;
   }
   data = std::move(it->data);
diff --git a/velox/dwio/common/DirectBufferedInput.h b/velox/dwio/common/DirectBufferedInput.h
index ea697c9e175..c23e104e92a 100644
--- a/velox/dwio/common/DirectBufferedInput.h
+++ b/velox/dwio/common/DirectBufferedInput.h
@@ -17,6 +17,7 @@
 #pragma once
 
 #include <folly/Executor.h>
+#include <folly/Range.h>
 
 #include "velox/common/caching/AsyncDataCache.h"
 #include "velox/common/caching/FileGroupStats.h"
@@ -57,23 +58,24 @@ class DirectCoalescedLoad : public cache::CoalescedLoad {
  public:
   DirectCoalescedLoad(
       std::shared_ptr<ReadFileInputStream> input,
-      std::shared_ptr<IoStatistics> ioStats,
-      std::shared_ptr<filesystems::File::IoStats> fsStats,
+      std::shared_ptr<IoStatistics> ioStatistics,
+      std::shared_ptr<velox::IoStats> ioStats,
       uint64_t /* groupId */,
       const std::vector<LoadRequest*>& requests,
       memory::MemoryPool* pool,
       int32_t loadQuantum)
       : CoalescedLoad({}, {}),
+        ioStatistics_(ioStatistics),
         ioStats_(ioStats),
-        fsStats_(fsStats),
         input_(std::move(input)),
         loadQuantum_(loadQuantum),
         pool_(pool) {
     VELOX_DCHECK_NOT_NULL(pool_);
     VELOX_DCHECK(
-        std::is_sorted(requests.begin(), requests.end(), [](auto* x, auto* y) {
-          return x->region.offset < y->region.offset;
-        }));
+        std::is_sorted(
+            requests.cbegin(), requests.cend(), [](auto* x, auto* y) {
+              return x->region.offset < y->region.offset;
+            }));
     requests_.reserve(requests.size());
     for (auto i = 0; i < requests.size(); ++i) {
       requests_.push_back(std::move(*requests[i]));
@@ -84,6 +86,12 @@ class DirectCoalescedLoad : public cache::CoalescedLoad {
   /// data is retrieved with getData().
   std::vector<cache::CachePin> loadData(bool prefetch) override;
 
+  /// Returns false since DirectCoalescedLoad reads from remote storage, not
+  /// SSD.
+  bool isSsdLoad() const override {
+    return false;
+  }
+
   /// Returns the buffer for 'region' in either 'data' or 'tinyData'. 'region'
   /// must match a region given to DirectBufferedInput::enqueue().
   int32_t
@@ -102,8 +110,8 @@ class DirectCoalescedLoad : public cache::CoalescedLoad {
   }
 
  private:
-  const std::shared_ptr<IoStatistics> ioStats_;
-  const std::shared_ptr<filesystems::File::IoStats> fsStats_;
+  const std::shared_ptr<IoStatistics> ioStatistics_;
+  const std::shared_ptr<velox::IoStats> ioStats_;
   const std::shared_ptr<ReadFileInputStream> input_;
   const int32_t loadQuantum_;
   memory::MemoryPool* const pool_;
@@ -120,21 +128,25 @@ class DirectBufferedInput : public BufferedInput {
       StringIdLease fileNum,
       std::shared_ptr<cache::ScanTracker> tracker,
       StringIdLease groupId,
-      std::shared_ptr<IoStatistics> ioStats,
-      std::shared_ptr<filesystems::File::IoStats> fsStats,
+      std::shared_ptr<IoStatistics> ioStatistics,
+      std::shared_ptr<velox::IoStats> ioStats,
       folly::Executor* executor,
-      const io::ReaderOptions& readerOptions)
+      const io::ReaderOptions& readerOptions,
+      folly::F14FastMap<std::string, std::string> fileReadOps = {})
       : BufferedInput(
             std::move(readFile),
             readerOptions.memoryPool(),
             metricsLog,
+            ioStatistics.get(),
             ioStats.get(),
-            fsStats.get()),
+            kMaxMergeDistance,
+            std::nullopt,
+            std::move(fileReadOps)),
         fileNum_(std::move(fileNum)),
         tracker_(std::move(tracker)),
         groupId_(std::move(groupId)),
+        ioStatistics_(std::move(ioStatistics)),
         ioStats_(std::move(ioStats)),
-        fsStats_(std::move(fsStats)),
         executor_(executor),
         fileSize_(input_->getLength()),
         options_(readerOptions) {}
@@ -149,8 +161,10 @@ class DirectBufferedInput : public BufferedInput {
       velox::common::Region region,
       const StreamIdentifier* sid) override;
 
-  bool supportSyncLoad() const override {
-    return false;
+  void preload() override;
+
+  bool preloaded() const override {
+    return preloadData_.has_value();
   }
 
   void load(const LogType /*unused*/) override;
@@ -176,8 +190,8 @@ class DirectBufferedInput : public BufferedInput {
         fileNum_,
         tracker_,
         groupId_,
+        ioStatistics_,
         ioStats_,
-        fsStats_,
         executor_,
         options_));
   }
@@ -186,6 +200,12 @@ class DirectBufferedInput : public BufferedInput {
     return pool_;
   }
 
+  /// Returns the contiguous byte range of preloaded data at 'offset' in the
+  /// file, up to 'length' bytes. Caller must call preload() first and ensure
+  /// 'offset' < file size.
+  folly::Range<const char*> preloadedData(uint64_t offset, uint64_t length)
+      const;
+
   /// Returns the CoalescedLoad that contains the correlated loads for
   /// 'stream' or nullptr if none. Returns nullptr on all but first
   /// call for 'stream' since the load is to be triggered by the first
@@ -200,31 +220,60 @@ class DirectBufferedInput : public BufferedInput {
     return executor_;
   }
 
+  const std::vector<std::shared_ptr<cache::CoalescedLoad>>&
+  testingCoalescedLoads() const {
+    return coalescedLoads_;
+  }
+
+  size_t testingStreamToCoalescedLoadSize() const {
+    return streamToCoalescedLoad_.rlock()->size();
+  }
+
   uint64_t nextFetchSize() const override {
     VELOX_NYI();
   }
 
- private:
-  /// Constructor used by clone().
+  /// Resets the buffered input for reuse across different operations.
+  void reset() override;
+
+ protected:
+  // The constructor and some member variables are protected to allow custom
+  // extended buffered inputs.
+  // Constructor used by clone().
   DirectBufferedInput(
       std::shared_ptr<ReadFileInputStream> input,
       StringIdLease fileNum,
       std::shared_ptr<cache::ScanTracker> tracker,
       StringIdLease groupId,
-      std::shared_ptr<IoStatistics> ioStats,
-      std::shared_ptr<filesystems::File::IoStats> fsStats,
+      std::shared_ptr<IoStatistics> ioStatistics,
+      std::shared_ptr<velox::IoStats> ioStats,
       folly::Executor* executor,
       const io::ReaderOptions& readerOptions)
       : BufferedInput(std::move(input), readerOptions.memoryPool()),
         fileNum_(std::move(fileNum)),
         tracker_(std::move(tracker)),
         groupId_(std::move(groupId)),
+        ioStatistics_(std::move(ioStatistics)),
         ioStats_(std::move(ioStats)),
-        fsStats_(std::move(fsStats)),
         executor_(executor),
         fileSize_(input_->getLength()),
         options_(readerOptions) {}
 
+  // Regions that are candidates for loading.
+  const StringIdLease fileNum_;
+  const std::shared_ptr<cache::ScanTracker> tracker_;
+  const StringIdLease groupId_;
+  const std::shared_ptr<IoStatistics> ioStatistics_;
+  const std::shared_ptr<velox::IoStats> ioStats_;
+  folly::Executor* const executor_;
+  const uint64_t fileSize_;
+  const io::ReaderOptions options_;
+  std::vector<LoadRequest> requests_;
+
+  // Distinct coalesced loads in 'coalescedLoads_'.
+  std::vector<std::shared_ptr<cache::CoalescedLoad>> coalescedLoads_;
+
+ private:
   std::vector<int32_t> groupRequests(
       const std::vector<LoadRequest*>& requests,
       bool prefetch) const;
@@ -261,27 +310,21 @@ class DirectBufferedInput : public BufferedInput {
     }
   };
 
-  const StringIdLease fileNum_;
-  const std::shared_ptr<cache::ScanTracker> tracker_;
-  const StringIdLease groupId_;
-  const std::shared_ptr<IoStatistics> ioStats_;
-  const std::shared_ptr<filesystems::File::IoStats> fsStats_;
-  folly::Executor* const executor_;
-  const uint64_t fileSize_;
-
-  // Regions that are candidates for loading.
-  std::vector<LoadRequest> requests_;
-
   // Coalesced loads spanning multiple streams in one IO.
   folly::Synchronized<folly::F14FastMap<
       const SeekableInputStream*,
       std::shared_ptr<DirectCoalescedLoad>>>
       streamToCoalescedLoad_;
 
-  // Distinct coalesced loads in 'coalescedLoads_'.
-  std::vector<std::shared_ptr<cache::CoalescedLoad>> coalescedLoads_;
-
-  io::ReaderOptions options_;
+  // Preloaded file data read in a single IO by preload(). Exactly one of
+  // 'tinyData' or 'data' is populated: 'tinyData' when the file size <=
+  // kTinySize, 'data' (non-contiguous allocation) otherwise.
+  struct PreloadData {
+    memory::Allocation data;
+    std::string tinyData;
+    uint64_t size;
+  };
+  std::optional<PreloadData> preloadData_;
 };
 
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/DirectInputStream.cpp b/velox/dwio/common/DirectInputStream.cpp
index 68173b40f25..19bfb5ef73f 100644
--- a/velox/dwio/common/DirectInputStream.cpp
+++ b/velox/dwio/common/DirectInputStream.cpp
@@ -91,8 +91,8 @@ bool DirectInputStream::SkipInt64(int64_t count) {
   return false;
 }
 
-google::protobuf::int64 DirectInputStream::ByteCount() const {
-  return static_cast<google::protobuf::int64>(offsetInRegion_);
+int64_t DirectInputStream::ByteCount() const {
+  return static_cast<int64_t>(offsetInRegion_);
 }
 
 void DirectInputStream::seekToPosition(PositionProvider& seekPosition) {
@@ -153,12 +153,25 @@ void DirectInputStream::loadSync() {
     input_->read(ranges, loadedRegion_.offset, LogType::FILE);
   }
   ioStats_->read().increment(loadedRegion_.length);
-  ioStats_->queryThreadIoLatency().increment(usecs);
-  ioStats_->incTotalScanTime(usecs * 1'000);
+  ioStats_->queryThreadIoLatencyUs().increment(usecs);
+  ioStats_->storageReadLatencyUs().increment(usecs);
+  ioStats_->incTotalScanTimeNs(usecs * 1'000);
 }
 
 void DirectInputStream::loadPosition() {
   VELOX_CHECK_LT(offsetInRegion_, region_.length);
+
+  // Fast path: serve from preloaded whole-file data.
+  if (bufferedInput_->preloaded()) {
+    const auto range = bufferedInput_->preloadedData(
+        region_.offset + offsetInRegion_, region_.length - offsetInRegion_);
+    run_ = reinterpret_cast<uint8_t*>(const_cast<char*>(range.data()));
+    runSize_ = range.size();
+    offsetInRun_ = 0;
+    offsetOfRun_ = 0;
+    return;
+  }
+
   if (!loaded_) {
     loaded_ = true;
     auto load = bufferedInput_->coalescedLoad(this);
@@ -173,7 +186,9 @@ void DirectInputStream::loadPosition() {
         loadedRegion_.offset = region_.offset;
         loadedRegion_.length = load->getData(region_.offset, data_, tinyData_);
       }
-      ioStats_->queryThreadIoLatency().increment(loadUs);
+      ioStats_->queryThreadIoLatencyUs().increment(loadUs);
+      // DirectCoalescedLoad always reads from remote storage, not SSD.
+      ioStats_->coalescedStorageLoadLatencyUs().increment(loadUs);
     } else {
       // Standalone stream, not part of coalesced load.
       loadedRegion_.offset = 0;
diff --git a/velox/dwio/common/DirectInputStream.h b/velox/dwio/common/DirectInputStream.h
index 3d75b445956..b5bc4440066 100644
--- a/velox/dwio/common/DirectInputStream.h
+++ b/velox/dwio/common/DirectInputStream.h
@@ -44,7 +44,7 @@ class DirectInputStream : public SeekableInputStream {
   bool Next(const void** data, int* size) override;
   void BackUp(int count) override;
   bool SkipInt64(int64_t count) override;
-  google::protobuf::int64 ByteCount() const override;
+  int64_t ByteCount() const override;
 
   void seekToPosition(PositionProvider& position) override;
   std::string getName() const override;
@@ -91,8 +91,8 @@ class DirectInputStream : public SeekableInputStream {
   // Contains the data if the range is too small for Allocation.
   std::string tinyData_;
 
-  // Pointer  to start of current run in 'entry->data()' or
-  // 'entry->tinyData()'.
+  // Pointer to start of current run in 'entry->nonContiguousData()' or
+  // 'entry->contiguousData()'.
   uint8_t* run_{nullptr};
 
   // Offset of current run from start of 'data_'
diff --git a/velox/dwio/common/ErrorTolerance.h b/velox/dwio/common/ErrorTolerance.h
index db186084cea..4f2aafd6111 100644
--- a/velox/dwio/common/ErrorTolerance.h
+++ b/velox/dwio/common/ErrorTolerance.h
@@ -18,10 +18,7 @@
 
 #include "velox/dwio/common/exception/Exception.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
 
 /**
  * Error tolerance level for readers
@@ -63,7 +60,4 @@ struct ErrorTolerance {
   }
 };
 
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/FileMetadata.h b/velox/dwio/common/FileMetadata.h
new file mode 100644
index 00000000000..1beb77ffdb2
--- /dev/null
+++ b/velox/dwio/common/FileMetadata.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+namespace facebook::velox::dwio::common {
+
+/// File format specific metadata returned when a writer is closed.
+/// Caller of Writer::close() can do further processing such as aggregate
+/// row group statistics to file level statistics based on the metadata.
+class FileMetadata {
+ public:
+  virtual ~FileMetadata() = default;
+};
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/FileSink.cpp b/velox/dwio/common/FileSink.cpp
index 6654dfb6407..fe69778d851 100644
--- a/velox/dwio/common/FileSink.cpp
+++ b/velox/dwio/common/FileSink.cpp
@@ -111,10 +111,13 @@ WriteFileSink::WriteFileSink(
     std::unique_ptr<WriteFile> writeFile,
     std::string name,
     MetricsLogPtr metricLogger,
-    IoStatistics* stats)
+    IoStatistics* stats,
+    velox::IoStats* fileSystemStats)
     : FileSink(
           std::move(name),
-          {.metricLogger = std::move(metricLogger), .stats = stats}),
+          {.metricLogger = std::move(metricLogger),
+           .stats = stats,
+           .fileSystemStats = fileSystemStats}),
       writeFile_{std::move(writeFile)} {
   VELOX_CHECK_NOT_NULL(writeFile_);
 }
diff --git a/velox/dwio/common/FileSink.h b/velox/dwio/common/FileSink.h
index 914d06055f1..74273f2b9da 100644
--- a/velox/dwio/common/FileSink.h
+++ b/velox/dwio/common/FileSink.h
@@ -46,7 +46,8 @@ class FileSink : public Closeable {
     memory::MemoryPool* pool{nullptr};
     MetricsLogPtr metricLogger{MetricsLog::voidLog()};
     IoStatistics* stats{nullptr};
-    filesystems::File::IoStats* fileSystemStats{nullptr};
+    velox::IoStats* fileSystemStats{nullptr};
+    std::unordered_map<std::string, std::string> storageParameters{};
   };
 
   FileSink(std::string name, const Options& options)
@@ -105,6 +106,10 @@ class FileSink : public Closeable {
     return stats_;
   }
 
+  velox::IoStats* getFileSystemStats() {
+    return fileSystemStats_;
+  }
+
  protected:
   // General write wrapper with logging. All concrete subclasses gets logging
   // for free if they call a public method that goes through this method.
@@ -119,7 +124,7 @@ class FileSink : public Closeable {
   memory::MemoryPool* const pool_;
   const MetricsLogPtr metricLogger_;
   IoStatistics* const stats_;
-  filesystems::File::IoStats* const fileSystemStats_;
+  velox::IoStats* const fileSystemStats_;
 
   uint64_t size_;
 };
@@ -131,7 +136,8 @@ class WriteFileSink final : public FileSink {
       std::unique_ptr<WriteFile> writeFile,
       std::string name,
       MetricsLogPtr metricLogger = MetricsLog::voidLog(),
-      IoStatistics* stats = nullptr);
+      IoStatistics* stats = nullptr,
+      velox::IoStats* fileSystemStats = nullptr);
 
   ~WriteFileSink() override {
     destroy();
diff --git a/velox/dwio/common/FlatMapHelper.cpp b/velox/dwio/common/FlatMapHelper.cpp
index 5d48887af47..e392bf60a65 100644
--- a/velox/dwio/common/FlatMapHelper.cpp
+++ b/velox/dwio/common/FlatMapHelper.cpp
@@ -21,11 +21,20 @@
 namespace facebook::velox::dwio::common::flatmap {
 namespace detail {
 
-void reset(VectorPtr& vector, vector_size_t size, bool hasNulls) {
+void reset(
+    VectorPtr& vector,
+    VectorEncoding::Simple desiredEncoding,
+    vector_size_t size,
+    bool hasNulls) {
   if (!vector) {
     return;
   }
 
+  if (vector->encoding() != desiredEncoding) {
+    vector.reset();
+    return;
+  }
+
   if (vector.use_count() > 1) {
     vector.reset();
     return;
@@ -39,6 +48,9 @@ void reset(VectorPtr& vector, vector_size_t size, bool hasNulls) {
     }
   }
   vector->resize(size);
+  // Reside BaseVector::length_ as it will be updated in the subsequent copy()
+  // calls.
+  vector->BaseVector::resize(0);
 }
 
 void initializeStringVector(
@@ -162,7 +174,7 @@ void initializeVectorImpl<TypeKind::ARRAY>(
     }
   }
 
-  detail::reset(vector, size, hasNulls);
+  detail::reset(vector, VectorEncoding::Simple::ARRAY, size, hasNulls);
   VectorPtr origElementsVector;
   if (vector) {
     auto& arrayVector = dynamic_cast<ArrayVector&>(*vector);
@@ -226,7 +238,7 @@ void initializeMapVector(
     size = sizeOverride.value();
   }
 
-  detail::reset(vector, size, hasNulls);
+  detail::reset(vector, VectorEncoding::Simple::MAP, size, hasNulls);
   VectorPtr origKeysVector;
   VectorPtr origValuesVector;
   if (vector) {
@@ -298,7 +310,7 @@ void initializeVectorImpl<TypeKind::ROW>(
     }
   }
 
-  detail::reset(vector, size, hasNulls);
+  detail::reset(vector, VectorEncoding::Simple::ROW, size, hasNulls);
   std::vector<VectorPtr> origChildren;
   if (vector) {
     auto& rowVector = dynamic_cast<RowVector&>(*vector);
@@ -359,8 +371,9 @@ vector_size_t copyNulls(
   vector_size_t nulls = 0;
   // it's assumed that initVector is called before calling this method to
   // properly allocate/clear nulls buffer. So we only need to check against
-  // target vector here.
-  target.resize(targetIndex + count, false);
+  // target vector here.  We only call BaseVector::resize here to make sure
+  // BaseVector::size() is only updated.
+  target.BaseVector::resize(targetIndex + count, false);
   if (target.mayHaveNulls()) {
     auto tgtNulls = const_cast<uint64_t*>(target.rawNulls());
     if (source.isConstantEncoding()) {
@@ -485,7 +498,10 @@ vector_size_t copyOffsets(
     vector_size_t sourceIndex,
     vector_size_t count,
     vector_size_t& childOffset) {
-  target.resize(targetIndex + count);
+  // Its expected that initVector is called before calling this method so the
+  // offsets and sizes buffers are properly allocated. We only call
+  // BaseVector::resize here to make sure BaseVector::size() is only updated.
+  target.BaseVector::resize(targetIndex + count);
   auto tgtOffsets = const_cast<vector_size_t*>(target.rawOffsets());
   auto tgtSizes = const_cast<vector_size_t*>(target.rawSizes());
   auto srcSizes = source.rawSizes();
@@ -701,8 +717,9 @@ bool copyNull(
     vector_size_t sourceIndex) {
   // it's assumed that initVector is called before calling this method to
   // properly allocate/clear nulls buffer. So we only need to check against
-  // target vector here.
-  target.resize(targetIndex + 1, false);
+  // target vector here. We only call BaseVector::resize here to make sure
+  // BaseVector::size() is only updated.
+  target.BaseVector::resize(targetIndex + 1, false);
   if (target.mayHaveNulls()) {
     bool srcIsNull =
         (source.isConstantEncoding() ||
@@ -792,7 +809,10 @@ vector_size_t copyOffset(
     const T& source,
     vector_size_t sourceIndex,
     vector_size_t& childOffset) {
-  target.resize(targetIndex + 1);
+  // Its expected that initVector is called before calling this method so the
+  // offsets and sizes buffers are properly allocated. We only call
+  // BaseVector::resize here to make sure BaseVector::size() is only updated.
+  target.BaseVector::resize(targetIndex + 1);
   auto tgtSizes = const_cast<vector_size_t*>(target.rawSizes());
   childOffset = nextChildOffset(target, targetIndex);
   const_cast<vector_size_t*>(target.rawOffsets())[targetIndex] = childOffset;
diff --git a/velox/dwio/common/FlatMapHelper.h b/velox/dwio/common/FlatMapHelper.h
index 05212cdd44e..404e7891a08 100644
--- a/velox/dwio/common/FlatMapHelper.h
+++ b/velox/dwio/common/FlatMapHelper.h
@@ -24,7 +24,11 @@ namespace facebook::velox::dwio::common::flatmap {
 namespace detail {
 
 // Reset vector with the desired size/hasNulls properties
-void reset(VectorPtr& vector, vector_size_t size, bool hasNulls);
+void reset(
+    VectorPtr& vector,
+    VectorEncoding::Simple desiredEncoding,
+    vector_size_t size,
+    bool hasNulls);
 
 // Reset vector smart pointer if any of the buffers is not single referenced.
 template <typename... T>
@@ -63,7 +67,7 @@ void initializeFlatVector(
     vector_size_t size,
     bool hasNulls,
     std::vector<BufferPtr>&& stringBuffers = {}) {
-  detail::reset(vector, size, hasNulls);
+  detail::reset(vector, VectorEncoding::Simple::FLAT, size, hasNulls);
   if (vector) {
     auto& flatVector = dynamic_cast<FlatVector<T>&>(*vector);
     detail::resetIfNotWritable(vector, flatVector.nulls(), flatVector.values());
@@ -232,14 +236,14 @@ KeyPredicate<T> prepareKeyPredicate(std::string_view expression) {
   // You cannot mix allow key and reject key.
   VELOX_CHECK(
       modes.empty() ||
-      std::all_of(modes.begin(), modes.end(), [&modes](const auto& v) {
+      std::all_of(modes.cbegin(), modes.cend(), [&modes](const auto& v) {
         return v == modes.front();
       }));
 
   auto mode = modes.empty() ? KeyProjectionMode::ALLOW : modes.front();
 
   return KeyPredicate<T>(
-      mode, typename KeyPredicate<T>::Lookup(keys.begin(), keys.end()));
+      mode, typename KeyPredicate<T>::Lookup(keys.cbegin(), keys.cend()));
 }
 
 } // namespace facebook::velox::dwio::common::flatmap
diff --git a/velox/dwio/common/FormatData.h b/velox/dwio/common/FormatData.h
index 4e8a5548fb0..2a1a228251d 100644
--- a/velox/dwio/common/FormatData.h
+++ b/velox/dwio/common/FormatData.h
@@ -126,13 +126,20 @@ class FormatData {
   virtual bool parentNullsInLeaves() const {
     return false;
   }
+
+  bool stringDecoderZeroCopy() const {
+    return stringDecoderZeroCopy_;
+  }
+
+ protected:
+  bool stringDecoderZeroCopy_{false};
 };
 
 /// Base class for format-specific reader initialization arguments.
 class FormatParams {
  public:
-  explicit FormatParams(memory::MemoryPool& pool, ColumnReaderStatistics& stats)
-      : pool_(pool), stats_(stats) {}
+  FormatParams(memory::MemoryPool& pool, ColumnReaderStatistics& stats)
+      : pool_(&pool), stats_(&stats) {}
 
   virtual ~FormatParams() = default;
 
@@ -143,16 +150,16 @@ class FormatParams {
       const velox::common::ScanSpec& scanSpec) = 0;
 
   memory::MemoryPool& pool() {
-    return pool_;
+    return *pool_;
   }
 
   ColumnReaderStatistics& runtimeStatistics() {
-    return stats_;
+    return *stats_;
   }
 
  private:
-  memory::MemoryPool& pool_;
-  ColumnReaderStatistics& stats_;
+  memory::MemoryPool* const pool_;
+  ColumnReaderStatistics* const stats_;
 };
 
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/InputStream.cpp b/velox/dwio/common/InputStream.cpp
index cc20a5fc55e..fec1982a844 100644
--- a/velox/dwio/common/InputStream.cpp
+++ b/velox/dwio/common/InputStream.cpp
@@ -64,26 +64,29 @@ ReadFileInputStream::ReadFileInputStream(
     std::shared_ptr<velox::ReadFile> readFile,
     const MetricsLogPtr& metricsLog,
     IoStatistics* stats,
-    filesystems::File::IoStats* fsStats)
-    : InputStream(readFile->getName(), metricsLog, stats, fsStats),
+    velox::IoStats* ioStats,
+    folly::F14FastMap<std::string, std::string> fileOpts,
+    bool cacheable)
+    : InputStream(readFile->getName(), metricsLog, stats, ioStats),
+      fileIoContext_(ioStats, std::move(fileOpts), nullptr, cacheable),
       readFile_(std::move(readFile)) {}
 
 void ReadFileInputStream::read(
     void* buf,
     uint64_t length,
     uint64_t offset,
-    MetricsLog::MetricsType purpose) {
+    MetricsLog::Type purpose) {
   VELOX_CHECK_NOT_NULL(buf);
   logRead(offset, length, purpose);
   uint64_t readTimeUs{0};
   std::string_view readData;
   {
     MicrosecondTimer timer(&readTimeUs);
-    readData = readFile_->pread(offset, length, buf, fsStats_);
+    readData = readFile_->pread(offset, length, buf, fileIoContext_);
   }
   if (stats_) {
     stats_->incRawBytesRead(length);
-    stats_->incTotalScanTime(readTimeUs * 1'000);
+    stats_->incTotalScanTimeNs(readTimeUs * 1'000);
   }
 
   VELOX_CHECK_EQ(
@@ -102,7 +105,7 @@ void ReadFileInputStream::read(
     LogType logType) {
   const int64_t bufferSize = totalBufferSize(buffers);
   logRead(offset, bufferSize, logType);
-  const auto size = readFile_->preadv(offset, buffers, fsStats_);
+  const auto size = readFile_->preadv(offset, buffers, fileIoContext_);
   VELOX_CHECK_EQ(
       size,
       bufferSize,
@@ -119,7 +122,7 @@ folly::SemiFuture<uint64_t> ReadFileInputStream::readAsync(
     LogType logType) {
   const int64_t bufferSize = totalBufferSize(buffers);
   logRead(offset, bufferSize, logType);
-  return readFile_->preadvAsync(offset, buffers, fsStats_);
+  return readFile_->preadvAsync(offset, buffers, fileIoContext_);
 }
 
 bool ReadFileInputStream::hasReadAsync() const {
@@ -137,11 +140,12 @@ void ReadFileInputStream::vread(
       size_t(0),
       [&](size_t acc, const auto& r) { return acc + r.length; });
   logRead(regions[0].offset, length, purpose);
-  auto readStartMicros = getCurrentTimeMicro();
-  readFile_->preadv(regions, iobufs, fsStats_);
+  const auto readStartTimeUs = getCurrentTimeMicro();
+  readFile_->preadv(regions, iobufs, fileIoContext_);
   if (stats_) {
     stats_->incRawBytesRead(length);
-    stats_->incTotalScanTime((getCurrentTimeMicro() - readStartMicros) * 1000);
+    stats_->incTotalScanTimeNs(
+        (getCurrentTimeMicro() - readStartTimeUs) * 1'000);
   }
 }
 
diff --git a/velox/dwio/common/InputStream.h b/velox/dwio/common/InputStream.h
index b0b6deb2c1f..a1c4f55edea 100644
--- a/velox/dwio/common/InputStream.h
+++ b/velox/dwio/common/InputStream.h
@@ -26,6 +26,7 @@
 #include <utility>
 #include <vector>
 
+#include <folly/container/F14Map.h>
 #include "velox/common/file/File.h"
 #include "velox/common/file/Region.h"
 #include "velox/common/io/IoStatistics.h"
@@ -43,11 +44,11 @@ class InputStream {
       const std::string& path,
       const MetricsLogPtr& metricsLog = MetricsLog::voidLog(),
       IoStatistics* stats = nullptr,
-      filesystems::File::IoStats* fsStats = nullptr)
+      velox::IoStats* ioStats = nullptr)
       : path_{path},
         metricsLog_{metricsLog},
         stats_(stats),
-        fsStats_(fsStats) {}
+        ioStats_(ioStats) {}
 
   virtual ~InputStream() = default;
 
@@ -132,7 +133,7 @@ class InputStream {
   std::string path_;
   MetricsLogPtr metricsLog_;
   IoStatistics* stats_;
-  filesystems::File::IoStats* fsStats_;
+  velox::IoStats* ioStats_;
 };
 
 /// An input stream that reads from an already opened ReadFile.
@@ -143,7 +144,9 @@ class ReadFileInputStream final : public InputStream {
       std::shared_ptr<velox::ReadFile>,
       const MetricsLogPtr& metricsLog = MetricsLog::voidLog(),
       IoStatistics* stats = nullptr,
-      filesystems::File::IoStats* fsStats = nullptr);
+      velox::IoStats* ioStats = nullptr,
+      folly::F14FastMap<std::string, std::string> fileReadOps = {},
+      bool cacheable = false);
 
   ~ReadFileInputStream() override = default;
 
@@ -179,6 +182,7 @@ class ReadFileInputStream final : public InputStream {
   }
 
  private:
+  FileIoContext fileIoContext_;
   std::shared_ptr<velox::ReadFile> readFile_;
 };
 
diff --git a/velox/dwio/common/IntDecoder.h b/velox/dwio/common/IntDecoder.h
index 79f7bb8d89e..b106548a68d 100644
--- a/velox/dwio/common/IntDecoder.h
+++ b/velox/dwio/common/IntDecoder.h
@@ -225,13 +225,18 @@ FOLLY_ALWAYS_INLINE uint64_t IntDecoder<isSigned>::readVuLong() {
   if (LIKELY(bufferEnd_ - bufferStart_ >= folly::kMaxVarintLength64)) {
     const char* p = bufferStart_;
     uint64_t val;
+
+    // Fast path for 1-byte varints (values 0-127), which are very common.
+    // This avoids the do-while loop overhead for the most frequent case.
+    int64_t b = *p++;
+    val = (b & 0x7f);
+    if (b >= 0) {
+      bufferStart_ = p;
+      return val;
+    }
+
+    // Multi-byte varint path
     do {
-      int64_t b;
-      b = *p++;
-      val = (b & 0x7f);
-      if (UNLIKELY(b >= 0)) {
-        break;
-      }
       b = *p++;
       val |= (b & 0x7f) << 7;
       if (UNLIKELY(b >= 0)) {
@@ -292,8 +297,8 @@ FOLLY_ALWAYS_INLINE uint64_t IntDecoder<isSigned>::readVuLong() {
     return val;
   }
 
-  int64_t result = 0;
-  int64_t offset = 0;
+  uint64_t result = 0;
+  uint64_t offset = 0;
   signed char ch;
   do {
     ch = readByte();
diff --git a/velox/dwio/common/MeasureTime.h b/velox/dwio/common/MeasureTime.h
index c4eaf1281f3..1b7de305a03 100644
--- a/velox/dwio/common/MeasureTime.h
+++ b/velox/dwio/common/MeasureTime.h
@@ -20,10 +20,7 @@
 #include <functional>
 #include <optional>
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
 
 class MeasureTime {
  public:
@@ -61,7 +58,4 @@ inline std::optional<MeasureTime> measureTimeIfCallback(
   return std::nullopt;
 }
 
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/MetadataFilter.cpp b/velox/dwio/common/MetadataFilter.cpp
index 374a2d86108..88e3a5481e2 100644
--- a/velox/dwio/common/MetadataFilter.cpp
+++ b/velox/dwio/common/MetadataFilter.cpp
@@ -18,6 +18,7 @@
 
 #include <folly/container/F14Map.h>
 #include "velox/dwio/common/ScanSpec.h"
+#include "velox/expression/ExprConstants.h"
 #include "velox/expression/ExprToSubfieldFilter.h"
 
 namespace facebook::velox::common {
@@ -67,86 +68,118 @@ class MetadataFilter::LeafNode : public Node {
   std::unique_ptr<Filter> filter_;
 };
 
-struct MetadataFilter::AndNode : Node {
+struct MetadataFilter::ConditionNode : Node {
   static std::unique_ptr<Node> create(
-      std::unique_ptr<Node> lhs,
-      std::unique_ptr<Node> rhs) {
-    if (!lhs) {
-      return rhs;
-    }
-    if (!rhs) {
-      return lhs;
+      bool conjuction,
+      std::vector<std::unique_ptr<Node>> args);
+
+  static std::unique_ptr<Node> fromExpression(
+      const std::vector<core::TypedExprPtr>& inputs,
+      core::ExpressionEvaluator* evaluator,
+      bool conjunction,
+      bool negated) {
+    conjunction = negated ? !conjunction : conjunction;
+    std::vector<std::unique_ptr<Node>> args;
+    args.reserve(inputs.size());
+    for (const auto& input : inputs) {
+      auto node = Node::fromExpression(*input, evaluator, negated);
+      if (node) {
+        args.push_back(std::move(node));
+      } else if (!conjunction) {
+        return nullptr;
+      }
     }
-    return std::make_unique<AndNode>(std::move(lhs), std::move(rhs));
+    return create(conjunction, std::move(args));
   }
 
-  AndNode(std::unique_ptr<Node> lhs, std::unique_ptr<Node> rhs)
-      : lhs_(std::move(lhs)), rhs_(std::move(rhs)) {}
+  explicit ConditionNode(std::vector<std::unique_ptr<Node>> args)
+      : args_{std::move(args)} {}
 
-  void addToScanSpec(ScanSpec& scanSpec) const override {
-    lhs_->addToScanSpec(scanSpec);
-    rhs_->addToScanSpec(scanSpec);
-  }
-
-  uint64_t* eval(LeafResults& leafResults, int size) const override {
-    auto* l = lhs_->eval(leafResults, size);
-    auto* r = rhs_->eval(leafResults, size);
-    if (!l) {
-      return r;
-    }
-    if (!r) {
-      return l;
+  void addToScanSpec(ScanSpec& scanSpec) const final {
+    for (const auto& arg : args_) {
+      arg->addToScanSpec(scanSpec);
     }
-    bits::orBits(l, r, 0, size);
-    return l;
   }
 
-  std::string toString() const override {
-    return "and(" + lhs_->toString() + "," + rhs_->toString() + ")";
+ protected:
+  std::string ToStringImpl(std::string_view prefix) const {
+    std::string result{prefix};
+    for (size_t i = 0; i < args_.size(); ++i) {
+      if (i != 0) {
+        result += ",";
+      }
+      result += args_[i]->toString();
+    }
+    result += ")";
+    return result;
   }
 
- private:
-  std::unique_ptr<Node> lhs_;
-  std::unique_ptr<Node> rhs_;
+  std::vector<std::unique_ptr<Node>> args_;
 };
 
-struct MetadataFilter::OrNode : Node {
-  static std::unique_ptr<Node> create(
-      std::unique_ptr<Node> lhs,
-      std::unique_ptr<Node> rhs) {
-    if (!lhs || !rhs) {
-      return nullptr;
+struct MetadataFilter::AndNode final : ConditionNode {
+  using ConditionNode::ConditionNode;
+
+  uint64_t* eval(LeafResults& leafResults, int size) const final {
+    uint64_t* result = nullptr;
+    for (const auto& arg : args_) {
+      auto* a = arg->eval(leafResults, size);
+      if (!a) {
+        continue;
+      }
+      if (!result) {
+        result = a;
+      } else {
+        bits::orBits(result, a, 0, size);
+      }
     }
-    return std::make_unique<OrNode>(std::move(lhs), std::move(rhs));
+    return result;
   }
 
-  OrNode(std::unique_ptr<Node> lhs, std::unique_ptr<Node> rhs)
-      : lhs_(std::move(lhs)), rhs_(std::move(rhs)) {}
-
-  void addToScanSpec(ScanSpec& scanSpec) const override {
-    lhs_->addToScanSpec(scanSpec);
-    rhs_->addToScanSpec(scanSpec);
+  std::string toString() const final {
+    return ToStringImpl("and(");
   }
+};
 
-  uint64_t* eval(LeafResults& leafResults, int size) const override {
-    auto* l = lhs_->eval(leafResults, size);
-    auto* r = rhs_->eval(leafResults, size);
-    if (!l || !r) {
-      return nullptr;
+struct MetadataFilter::OrNode final : ConditionNode {
+  using ConditionNode::ConditionNode;
+
+  uint64_t* eval(LeafResults& leafResults, int size) const final {
+    uint64_t* result = nullptr;
+    for (const auto& arg : args_) {
+      auto* a = arg->eval(leafResults, size);
+      if (!a) {
+        return nullptr;
+      }
+      if (!result) {
+        result = a;
+      } else {
+        bits::andBits(result, a, 0, size);
+      }
     }
-    bits::andBits(l, r, 0, size);
-    return l;
+    return result;
   }
 
-  std::string toString() const override {
-    return "or(" + lhs_->toString() + "," + rhs_->toString() + ")";
+  std::string toString() const final {
+    return ToStringImpl("or(");
   }
-
- private:
-  std::unique_ptr<Node> lhs_;
-  std::unique_ptr<Node> rhs_;
 };
 
+std::unique_ptr<MetadataFilter::Node> MetadataFilter::ConditionNode::create(
+    bool conjunction,
+    std::vector<std::unique_ptr<Node>> args) {
+  if (args.empty()) {
+    return nullptr;
+  }
+  if (args.size() == 1) {
+    return std::move(args[0]);
+  }
+  if (conjunction) {
+    return std::make_unique<AndNode>(std::move(args));
+  }
+  return std::make_unique<OrNode>(std::move(args));
+}
+
 namespace {
 
 const core::CallTypedExpr* asCall(const core::ITypedExpr* expr) {
@@ -163,29 +196,26 @@ std::unique_ptr<MetadataFilter::Node> MetadataFilter::Node::fromExpression(
   if (!call) {
     return nullptr;
   }
-  if (call->name() == "and") {
-    auto lhs = fromExpression(*call->inputs()[0], evaluator, negated);
-    auto rhs = fromExpression(*call->inputs()[1], evaluator, negated);
-    return negated ? OrNode::create(std::move(lhs), std::move(rhs))
-                   : AndNode::create(std::move(lhs), std::move(rhs));
+  if (call->name() == expression::kAnd) {
+    return ConditionNode::fromExpression(
+        call->inputs(), evaluator, true, negated);
   }
-  if (call->name() == "or") {
-    auto lhs = fromExpression(*call->inputs()[0], evaluator, negated);
-    auto rhs = fromExpression(*call->inputs()[1], evaluator, negated);
-    return negated ? AndNode::create(std::move(lhs), std::move(rhs))
-                   : OrNode::create(std::move(lhs), std::move(rhs));
+  if (call->name() == expression::kOr) {
+    return ConditionNode::fromExpression(
+        call->inputs(), evaluator, false, negated);
   }
   if (call->name() == "not") {
     return fromExpression(*call->inputs()[0], evaluator, !negated);
   }
   try {
-    Subfield subfield;
-    auto filter =
+    auto subfieldAndFilter =
         exec::ExprToSubfieldFilterParser::getInstance()
-            ->leafCallToSubfieldFilter(*call, subfield, evaluator, negated);
-    if (!filter) {
+            ->leafCallToSubfieldFilter(*call, evaluator, negated);
+    if (!subfieldAndFilter.has_value()) {
       return nullptr;
     }
+
+    auto& [subfield, filter] = subfieldAndFilter.value();
     VELOX_CHECK(
         subfield.valid(),
         "Invalid subfield from expression: {}",
diff --git a/velox/dwio/common/MetadataFilter.h b/velox/dwio/common/MetadataFilter.h
index 62b604b1440..d626bbdd967 100644
--- a/velox/dwio/common/MetadataFilter.h
+++ b/velox/dwio/common/MetadataFilter.h
@@ -50,6 +50,7 @@ class MetadataFilter {
 
  private:
   struct Node;
+  struct ConditionNode;
   struct AndNode;
   struct OrNode;
 
diff --git a/velox/dwio/common/DwioMetricsLog.cpp b/velox/dwio/common/MetricsLog.cpp
similarity index 59%
rename from velox/dwio/common/DwioMetricsLog.cpp
rename to velox/dwio/common/MetricsLog.cpp
index d8e0323f9bd..a18a3f71073 100644
--- a/velox/dwio/common/DwioMetricsLog.cpp
+++ b/velox/dwio/common/MetricsLog.cpp
@@ -35,6 +35,42 @@ std::shared_ptr<DwioMetricsLogFactory>& metricsLogFactory() {
 }
 } // namespace
 
+/* static */ std::shared_ptr<const MetricsLog> MetricsLog::voidLog() {
+  static const MetricsLog kInstance{{}};
+  return {std::shared_ptr<const MetricsLog>{}, &kInstance};
+}
+
+/* static */ std::string MetricsLog::getMetricTypeName(Type type) {
+  switch (type) {
+    case Type::HEADER:
+      return "HEADER";
+    case Type::FOOTER:
+      return "FOOTER";
+    case Type::FILE:
+      return "FILE";
+    case Type::STRIPE:
+      return "STRIPE";
+    case Type::STRIPE_INDEX:
+      return "STRIPE_INDEX";
+    case Type::STRIPE_FOOTER:
+      return "STRIPE_FOOTER";
+    case Type::STREAM:
+      return "STREAM";
+    case Type::STREAM_BUNDLE:
+      return "STREAM_BUNDLE";
+    case Type::GROUP:
+      return "GROUP";
+    case Type::GROUP_INDEX:
+      return "GROUP_INDEX";
+    case Type::BLOCK:
+      return "BLOCK";
+    case Type::TEST:
+      return "TEST";
+    default:
+      VELOX_UNREACHABLE("Unknown MetricsLog type: {}", static_cast<int>(type));
+  }
+}
+
 void registerMetricsLogFactory(std::shared_ptr<DwioMetricsLogFactory> factory) {
   metricsLogFactory() = std::move(factory);
 }
diff --git a/velox/dwio/common/MetricsLog.h b/velox/dwio/common/MetricsLog.h
index 024117bd568..691ad356fb4 100644
--- a/velox/dwio/common/MetricsLog.h
+++ b/velox/dwio/common/MetricsLog.h
@@ -19,17 +19,15 @@
 #include "velox/dwio/common/FilterNode.h"
 #include "velox/dwio/common/exception/Exception.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
 
 class MetricsLog {
  public:
   static constexpr std::string_view LIB_VERSION_STRING{"1.1"};
-  static constexpr folly::StringPiece WRITE_OPERATION{"WRITE"};
+  static constexpr std::string_view WRITE_OPERATION{"WRITE"};
 
-  enum class MetricsType {
+  /// Identifies the type of metadata being read or logged for metrics purposes.
+  enum class Type {
     HEADER,
     FOOTER,
     FILE,
@@ -39,8 +37,10 @@ class MetricsLog {
     STREAM,
     STREAM_BUNDLE,
     GROUP,
+    GROUP_INDEX,
     BLOCK,
-    TEST
+    TEST,
+    METADATA
   };
 
   virtual ~MetricsLog() = default;
@@ -54,7 +54,7 @@ class MetricsLog {
       uint64_t footerSize,
       uint64_t readOffset,
       uint64_t readSize,
-      MetricsType type,
+      Type type,
       uint32_t numFileRead,
       uint32_t numStripeCache) const {}
 
@@ -127,45 +127,17 @@ class MetricsLog {
 
   virtual void logFileClose(const FileCloseMetrics& /* metrics */) const {}
 
-  static std::shared_ptr<const MetricsLog> voidLog() {
-    static const MetricsLog kInstance{{}};
-    return {std::shared_ptr<const MetricsLog>{}, &kInstance};
-  }
+  static std::shared_ptr<const MetricsLog> voidLog();
 
  protected:
   MetricsLog(const std::string& file) : file_{file} {}
 
-  static std::string getMetricTypeName(MetricsType type) {
-    switch (type) {
-      case MetricsType::HEADER:
-        return "HEADER";
-      case MetricsType::FOOTER:
-        return "FOOTER";
-      case MetricsType::FILE:
-        return "FILE";
-      case MetricsType::STRIPE:
-        return "STRIPE";
-      case MetricsType::STRIPE_INDEX:
-        return "STRIPE_INDEX";
-      case MetricsType::STRIPE_FOOTER:
-        return "STRIPE_FOOTER";
-      case MetricsType::STREAM:
-        return "STREAM";
-      case MetricsType::STREAM_BUNDLE:
-        return "STREAM_BUNDLE";
-      case MetricsType::GROUP:
-        return "GROUP";
-      case MetricsType::BLOCK:
-        return "BLOCK";
-      case MetricsType::TEST:
-        return "TEST";
-    }
-  }
+  static std::string getMetricTypeName(Type type);
 
   std::string file_;
 };
 
-using LogType = MetricsLog::MetricsType;
+using LogType = MetricsLog::Type;
 using MetricsLogPtr = std::shared_ptr<const MetricsLog>;
 
 class DwioMetricsLogFactory {
@@ -178,7 +150,4 @@ void registerMetricsLogFactory(std::shared_ptr<DwioMetricsLogFactory> factory);
 
 DwioMetricsLogFactory& getMetricsLogFactory();
 
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/OnDemandUnitLoader.cpp b/velox/dwio/common/OnDemandUnitLoader.cpp
index d4ef4f0a5ef..1a21f5475c1 100644
--- a/velox/dwio/common/OnDemandUnitLoader.cpp
+++ b/velox/dwio/common/OnDemandUnitLoader.cpp
@@ -15,12 +15,12 @@
  */
 
 #include "velox/dwio/common/OnDemandUnitLoader.h"
+#include "velox/common/time/Timer.h"
 
 #include <numeric>
 
 #include "velox/common/base/Exceptions.h"
 #include "velox/dwio/common/MeasureTime.h"
-#include "velox/dwio/common/UnitLoaderTools.h"
 
 using facebook::velox::dwio::common::measureTimeIfCallback;
 
@@ -42,6 +42,7 @@ class OnDemandUnitLoader : public UnitLoader {
   LoadUnit& getLoadedUnit(uint32_t unit) override {
     VELOX_CHECK_LT(unit, loadUnits_.size(), "Unit out of range");
 
+    processedUnits_.insert(unit);
     if (loadedUnit_.has_value()) {
       if (loadedUnit_.value() == unit) {
         return *loadUnits_[unit];
@@ -51,11 +52,14 @@ class OnDemandUnitLoader : public UnitLoader {
       loadedUnit_.reset();
     }
 
+    uint64_t unitLoadNanos{0};
     {
+      NanosecondTimer timer{&unitLoadNanos};
       auto measure = measureTimeIfCallback(blockedOnIoCallback_);
       loadUnits_[unit]->load();
     }
     loadedUnit_ = unit;
+    unitLoadNanos_ += unitLoadNanos;
 
     return *loadUnits_[unit];
   }
@@ -73,11 +77,25 @@ class OnDemandUnitLoader : public UnitLoader {
         rowOffsetInUnit, loadUnits_[unit]->getNumRows(), "Row out of range");
   }
 
+  UnitLoaderStats stats() override {
+    UnitLoaderStats stats;
+    stats.addCounter("processedUnits", RuntimeCounter(processedUnits_.size()));
+    stats.addCounter(
+        "unitLoadNanos",
+        RuntimeCounter(
+            saturateCast(unitLoadNanos_), RuntimeCounter::Unit::kNanos));
+    return stats;
+  }
+
  private:
   const std::vector<std::unique_ptr<LoadUnit>> loadUnits_;
   const std::function<void(std::chrono::high_resolution_clock::duration)>
       blockedOnIoCallback_;
   std::optional<uint32_t> loadedUnit_;
+
+  // Stats
+  std::unordered_set<uint32_t> processedUnits_;
+  uint64_t unitLoadNanos_{0};
 };
 
 } // namespace
diff --git a/velox/dwio/common/Options.cpp b/velox/dwio/common/Options.cpp
index 33946f71159..26487686393 100644
--- a/velox/dwio/common/Options.cpp
+++ b/velox/dwio/common/Options.cpp
@@ -39,6 +39,10 @@ FileFormat toFileFormat(std::string_view s) {
     return FileFormat::ORC;
   } else if (s == "sst") {
     return FileFormat::SST;
+  } else if (s == "flux") {
+    return FileFormat::FLUX;
+  } else if (s == "avro") {
+    return FileFormat::AVRO;
   }
   return FileFormat::UNKNOWN;
 }
@@ -65,6 +69,10 @@ std::string_view toString(FileFormat fmt) {
       return "orc";
     case FileFormat::SST:
       return "sst";
+    case FileFormat::FLUX:
+      return "flux";
+    case FileFormat::AVRO:
+      return "avro";
     default:
       return "unknown";
   }
diff --git a/velox/dwio/common/Options.h b/velox/dwio/common/Options.h
index ef70cb72379..a16a1e30a62 100644
--- a/velox/dwio/common/Options.h
+++ b/velox/dwio/common/Options.h
@@ -17,7 +17,8 @@
 #pragma once
 
 #include <limits>
-#include <unordered_set>
+#include <string>
+#include <unordered_map>
 
 #include <folly/Executor.h>
 #include "velox/common/base/RandomUtil.h"
@@ -51,6 +52,8 @@ enum class FileFormat {
   NIMBLE = 8,
   ORC = 9,
   SST = 10, // rocksdb sst format
+  FLUX = 11,
+  AVRO = 12,
 };
 
 FileFormat toFileFormat(std::string_view s);
@@ -282,6 +285,22 @@ class RowReaderOptions {
     scanSpec_ = std::move(scanSpec);
   }
 
+  folly::Executor* ioExecutor() const {
+    return ioExecutor_;
+  }
+
+  void setIOExecutor(folly::Executor* const ioExecutor) {
+    ioExecutor_ = ioExecutor;
+  }
+
+  const size_t parallelUnitLoadCount() const {
+    return parallelUnitLoadCount_;
+  }
+
+  void setParallelUnitLoadCount(size_t parallelUnitLoadCount) {
+    parallelUnitLoadCount_ = parallelUnitLoadCount;
+  }
+
   const std::shared_ptr<velox::common::MetadataFilter>& metadataFilter() const {
     return metadataFilter_;
   }
@@ -296,8 +315,8 @@ class RowReaderOptions {
           flatmapNodeIdsAsStruct) {
     VELOX_CHECK(
         std::all_of(
-            flatmapNodeIdsAsStruct.begin(),
-            flatmapNodeIdsAsStruct.end(),
+            flatmapNodeIdsAsStruct.cbegin(),
+            flatmapNodeIdsAsStruct.cend(),
             [](const auto& kv) { return !kv.second.empty(); }),
         "To use struct encoding for flatmap, keys to project must be specified");
     flatmapNodeIdAsStruct_ = std::move(flatmapNodeIdsAsStruct);
@@ -428,12 +447,64 @@ class RowReaderOptions {
     serdeParameters_ = std::move(serdeParameters);
   }
 
+  bool trackRowSize() const {
+    return trackRowSize_;
+  }
+
+  void setTrackRowSize(bool trackRowSize) {
+    trackRowSize_ = trackRowSize;
+  }
+
+  bool indexEnabled() const {
+    return indexEnabled_;
+  }
+
+  /// Sets whether to use the cluster index for filter-based row pruning.
+  /// When enabled, filters from ScanSpec are converted to index bounds for
+  /// efficient row skipping based on the file's cluster index.
+  ///
+  /// NOTE: currently only supported by Nimble format.
+  void setIndexEnabled(bool enabled) {
+    indexEnabled_ = enabled;
+  }
+
+  bool stringDecoderZeroCopy() const {
+    return stringDecoderZeroCopy_;
+  }
+
+  void setStringDecoderZeroCopy(bool stringDecoderZeroCopy) {
+    stringDecoderZeroCopy_ = stringDecoderZeroCopy;
+  }
+
+  bool nimblePreserveDictionaryEncoding() const {
+    return nimblePreserveDictionaryEncoding_;
+  }
+
+  void setNimblePreserveDictionaryEncoding(bool value) {
+    nimblePreserveDictionaryEncoding_ = value;
+  }
+
+  bool collectColumnCpuMetrics() const {
+    return collectColumnCpuMetrics_;
+  }
+
+  RowReaderOptions& setCollectColumnCpuMetrics(bool collect) {
+    collectColumnCpuMetrics_ = collect;
+    return *this;
+  }
+
+  // Legacy alias — remove after Nimble OSS bumps Velox.
+  RowReaderOptions& setCollectColumnStats(bool collect) {
+    return setCollectColumnCpuMetrics(collect);
+  }
+
  private:
   uint64_t dataStart_;
   uint64_t dataLength_;
   bool preloadStripe_;
   bool projectSelectedType_;
   bool returnFlatVector_ = false;
+  size_t parallelUnitLoadCount_ = 0;
   ErrorTolerance errorTolerance_;
   std::shared_ptr<ColumnSelector> selector_;
   RowTypePtr requestedType_;
@@ -446,7 +517,8 @@ class RowReaderOptions {
   // Whether to generate FlatMapVectors when reading flat maps from the file. By
   // default, converts flat maps in the file to MapVectors.
   bool preserveFlatMapsInMemory_ = false;
-
+  // Optional io executor to enable parallel unit loader.
+  folly::Executor* ioExecutor_{nullptr};
   // Optional executors to enable internal reader parallelism.
   // 'decodingExecutor' allow parallelising the vector decoding process.
   // 'ioExecutor' enables parallelism when performing file system read
@@ -485,20 +557,27 @@ class RowReaderOptions {
   TimestampPrecision timestampPrecision_ = TimestampPrecision::kMilliseconds;
 
   std::shared_ptr<FormatSpecificOptions> formatSpecificOptions_;
+  bool trackRowSize_{false};
+  bool indexEnabled_{false};
+  // Enables zero-copy string decoding in the Nimble selective reader,
+  // using the non-legacy encoding path. Controlled via session property.
+  bool stringDecoderZeroCopy_{false};
+  // Controls whether dictionary-encoded Nimble string columns return
+  // DictionaryVector instead of FlatVector. Controlled via session property.
+  bool nimblePreserveDictionaryEncoding_{false};
+  bool collectColumnCpuMetrics_{false};
 };
 
 /// Options for creating a Reader.
 class ReaderOptions : public io::ReaderOptions {
  public:
-  static constexpr uint64_t kDefaultFooterEstimatedSize = 1024 * 1024; // 1MB
+  static constexpr uint64_t kDefaultFooterSpeculativeIoSize =
+      1024 * 1024; // 1MB
   static constexpr uint64_t kDefaultFilePreloadThreshold =
       1024 * 1024 * 8; // 8MB
 
   explicit ReaderOptions(velox::memory::MemoryPool* pool)
-      : io::ReaderOptions(pool),
-        tailLocation_(std::numeric_limits<uint64_t>::max()),
-        fileFormat_(FileFormat::UNKNOWN),
-        fileSchema_(nullptr) {}
+      : io::ReaderOptions(pool) {}
 
   /// Sets the format of the file, such as "rc" or "dwrf". The default is
   /// "dwrf".
@@ -507,6 +586,13 @@ class ReaderOptions : public io::ReaderOptions {
     return *this;
   }
 
+  /// Sets the property bag.
+  ReaderOptions& setProperties(
+      std::unordered_map<std::string, std::string> properties) {
+    properties_ = std::move(properties);
+    return *this;
+  }
+
   /// Sets the current table schema of the file (a Type tree).  This could be
   /// different from the actual schema in file if schema evolution happened.
   /// For "dwrf" format, a default schema is derived from the file. For "rc"
@@ -535,8 +621,8 @@ class ReaderOptions : public io::ReaderOptions {
     return *this;
   }
 
-  ReaderOptions& setFooterEstimatedSize(uint64_t size) {
-    footerEstimatedSize_ = size;
+  ReaderOptions& setFooterSpeculativeIoSize(uint64_t size) {
+    footerSpeculativeIoSize_ = size;
     return *this;
   }
 
@@ -555,11 +641,6 @@ class ReaderOptions : public io::ReaderOptions {
     return *this;
   }
 
-  ReaderOptions& setIOExecutor(std::shared_ptr<folly::Executor> executor) {
-    ioExecutor_ = std::move(executor);
-    return *this;
-  }
-
   ReaderOptions& setSessionTimezone(const tz::TimeZone* sessionTimezone) {
     sessionTimezone_ = sessionTimezone;
     return *this;
@@ -580,6 +661,11 @@ class ReaderOptions : public io::ReaderOptions {
     return fileFormat_;
   }
 
+  /// Gets the property bag.
+  const std::unordered_map<std::string, std::string>& properties() const {
+    return properties_;
+  }
+
   /// Gets the file schema.
   const std::shared_ptr<const velox::RowType>& fileSchema() const {
     return fileSchema_;
@@ -597,18 +683,14 @@ class ReaderOptions : public io::ReaderOptions {
     return decrypterFactory_;
   }
 
-  uint64_t footerEstimatedSize() const {
-    return footerEstimatedSize_;
+  uint64_t footerSpeculativeIoSize() const {
+    return footerSpeculativeIoSize_;
   }
 
   uint64_t filePreloadThreshold() const {
     return filePreloadThreshold_;
   }
 
-  const std::shared_ptr<folly::Executor>& ioExecutor() const {
-    return ioExecutor_;
-  }
-
   const tz::TimeZone* sessionTimezone() const {
     return sessionTimezone_;
   }
@@ -633,12 +715,12 @@ class ReaderOptions : public io::ReaderOptions {
     randomSkip_ = std::move(randomSkip);
   }
 
-  bool noCacheRetention() const {
-    return noCacheRetention_;
+  bool cacheable() const {
+    return cacheable_;
   }
 
-  void setNoCacheRetention(bool noCacheRetention) {
-    noCacheRetention_ = noCacheRetention;
+  void setCacheable(bool cacheable) {
+    cacheable_ = cacheable;
   }
 
   const std::shared_ptr<velox::common::ScanSpec>& scanSpec() const {
@@ -657,6 +739,52 @@ class ReaderOptions : public io::ReaderOptions {
     selectiveNimbleReaderEnabled_ = value;
   }
 
+  /// Whether to cache file metadata (footer, stripes, index) in the
+  /// process-wide AsyncDataCache. When enabled, the first reader performs a
+  /// speculative tail read and populates the cache; subsequent readers on the
+  /// same file initialize from the cache with zero additional IO.
+  bool fileMetadataCacheEnabled() const {
+    return fileMetadataCacheEnabled_;
+  }
+
+  void setFileMetadataCacheEnabled(bool value) {
+    fileMetadataCacheEnabled_ = value;
+  }
+
+  /// If true, pins parsed metadata objects (e.g., StripeGroup, IndexGroup) in
+  /// the reader's metadata cache with strong references so they are never
+  /// evicted. This avoids re-reading and re-parsing metadata on every stripe
+  /// access when weak-pointer cache entries would otherwise expire.
+  bool pinFileMetadata() const {
+    return pinFileMetadata_;
+  }
+
+  void setPinFileMetadata(bool value) {
+    pinFileMetadata_ = value;
+  }
+
+  /// Whether to load and initialize the cluster index during file open.
+  /// When true, the cluster index section is preloaded and the structured
+  /// ClusterIndex object is created. Default true.
+  bool loadClusterIndex() const {
+    return loadClusterIndex_;
+  }
+
+  void setLoadClusterIndex(bool value) {
+    loadClusterIndex_ = value;
+  }
+
+  /// Whether to load and initialize the chunk index during file open.
+  /// When true, the chunk index section is preloaded and the structured
+  /// ChunkIndex object is created. Default true.
+  bool loadChunkIndex() const {
+    return loadChunkIndex_;
+  }
+
+  void setLoadChunkIndex(bool value) {
+    loadChunkIndex_ = value;
+  }
+
   bool allowEmptyFile() const {
     return allowEmptyFile_;
   }
@@ -665,23 +793,42 @@ class ReaderOptions : public io::ReaderOptions {
     allowEmptyFile_ = value;
   }
 
+  /// Allows reading INT32 physical type columns as a narrower integer type
+  /// (e.g., INT32 -> TINYINT/SMALLINT). Some Parquet writers store INT_8 and
+  /// INT_16 values as plain INT32 without a converted type annotation. When
+  /// enabled, the value is silently truncated on overflow. When disabled
+  /// (default), only annotated type-matching reads are allowed (e.g.,
+  /// INT_8 -> TINYINT, INT_16 -> SMALLINT, INT_32 -> INTEGER).
+  bool allowInt32Narrowing() const {
+    return allowInt32Narrowing_;
+  }
+
+  void setAllowInt32Narrowing(bool value) {
+    allowInt32Narrowing_ = value;
+  }
+
  private:
-  uint64_t tailLocation_;
-  FileFormat fileFormat_;
+  uint64_t tailLocation_{std::numeric_limits<uint64_t>::max()};
+  FileFormat fileFormat_{FileFormat::UNKNOWN};
   RowTypePtr fileSchema_;
   SerDeOptions serDeOptions_;
+  std::unordered_map<std::string, std::string> properties_{};
   std::shared_ptr<encryption::DecrypterFactory> decrypterFactory_;
-  uint64_t footerEstimatedSize_{kDefaultFooterEstimatedSize};
+  uint64_t footerSpeculativeIoSize_{kDefaultFooterSpeculativeIoSize};
   uint64_t filePreloadThreshold_{kDefaultFilePreloadThreshold};
   bool fileColumnNamesReadAsLowerCase_{false};
   bool useColumnNamesForColumnMapping_{false};
-  std::shared_ptr<folly::Executor> ioExecutor_;
   std::shared_ptr<random::RandomSkipTracker> randomSkip_;
   std::shared_ptr<velox::common::ScanSpec> scanSpec_;
   const tz::TimeZone* sessionTimezone_{nullptr};
   bool adjustTimestampToTimezone_{false};
   bool selectiveNimbleReaderEnabled_{false};
+  bool fileMetadataCacheEnabled_{false};
+  bool pinFileMetadata_{false};
+  bool loadClusterIndex_{true};
+  bool loadChunkIndex_{true};
   bool allowEmptyFile_{false};
+  bool allowInt32Narrowing_{false};
 };
 
 struct WriterOptions {
diff --git a/velox/dwio/common/OutputStream.h b/velox/dwio/common/OutputStream.h
index 46e90410ab1..d106cd4c9f3 100644
--- a/velox/dwio/common/OutputStream.h
+++ b/velox/dwio/common/OutputStream.h
@@ -47,8 +47,8 @@ class BufferedOutputStream : public google::protobuf::io::ZeroCopyOutputStream {
 
   void BackUp(int32_t count) override;
 
-  google::protobuf::int64 ByteCount() const override {
-    return static_cast<google::protobuf::int64>(size());
+  int64_t ByteCount() const override {
+    return static_cast<int64_t>(size());
   }
 
   bool WriteAliasedRaw(const void* /* unused */, int32_t /* unused */)
@@ -116,7 +116,7 @@ class BufferedOutputStream : public google::protobuf::io::ZeroCopyOutputStream {
       void** buffer,
       int32_t* size,
       uint64_t headerSize,
-      const std::vector<folly::StringPiece>& bufferToFlush) {
+      const std::vector<std::string_view>& bufferToFlush) {
     bufferHolder_.take(bufferToFlush);
     *buffer = buffer_.data() + headerSize;
     *size = static_cast<int32_t>(buffer_.size() - headerSize);
diff --git a/velox/dwio/common/ParallelUnitLoader.cpp b/velox/dwio/common/ParallelUnitLoader.cpp
new file mode 100644
index 00000000000..778fc3c380c
--- /dev/null
+++ b/velox/dwio/common/ParallelUnitLoader.cpp
@@ -0,0 +1,197 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/common/ParallelUnitLoader.h"
+#include <numeric>
+#include "velox/common/base/AsyncSource.h"
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/testutil/TestValue.h"
+#include "velox/common/time/Timer.h"
+
+namespace facebook::velox::dwio::common {
+
+class ParallelUnitLoader : public UnitLoader {
+ public:
+  /// Enables concurrent loading of multiple units (stripes, row groups, etc.)
+  /// using asynchronous I/O to improve throughput and reduce read latency.
+  ///
+  /// **Loading Strategy:**
+  /// - Initialization: Preloads up to `maxConcurrentLoads` units concurrently
+  /// - Access pattern: On each getLoadedUnit() call, ensures the requested unit
+  ///   is loaded and triggers loading of subsequent units within the window
+  /// - Memory management: Unloads all previous units to control memory usage
+  ///
+  /// **Performance Characteristics:**
+  /// - Best suited for sequential access patterns
+  /// - Memory usage: O(maxConcurrentLoads * average_unit_size)
+  /// - I/O parallelism: Up to `maxConcurrentLoads` concurrent load operations
+  ///
+  /// **Parameters:**
+  /// @param units All units to be loaded
+  /// @param ioExecutor Thread pool for asynchronous unit loading operations
+  /// @param maxConcurrentLoads Maximum units to load concurrently (sliding
+  /// window size)
+  ///
+  /// **Example with maxConcurrentLoads=3:**
+  /// ```
+  /// Units: [0,1,2,3,4,5,6,7,8,9]
+  /// Init:  Load [0,1,2] concurrently
+  /// Get(0): Wait for unit 0, trigger load of units [0,1,2], unload none
+  /// Get(1): Wait for unit 1, trigger load of units [1,2,3], unload [0]
+  /// Get(2): Wait for unit 2, trigger load of units [2,3,4], unload [0,1]
+  /// ```
+  ParallelUnitLoader(
+      std::vector<std::unique_ptr<LoadUnit>> units,
+      folly::Executor* ioExecutor,
+      uint16_t maxConcurrentLoads)
+      : loadUnits_(
+            std::make_move_iterator(units.begin()),
+            std::make_move_iterator(units.end())),
+        ioExecutor_(ioExecutor),
+        maxConcurrentLoads_(maxConcurrentLoads) {
+    VELOX_CHECK_NOT_NULL(ioExecutor, "ParallelUnitLoader ioExecutor is null");
+    VELOX_CHECK_GT(
+        maxConcurrentLoads_,
+        0,
+        "ParallelUnitLoader maxConcurrentLoads should be larger than 0");
+    asyncSources_.resize(loadUnits_.size());
+    unitsLoaded_.resize(loadUnits_.size());
+  }
+
+  /// Destructor ensures all pending load operations are properly cancelled
+  /// and waited for to prevent resource leaks and dangling references.
+  ~ParallelUnitLoader() override {
+    for (auto& source : asyncSources_) {
+      if (source) {
+        source->cancel();
+      }
+    }
+  }
+
+  LoadUnit& getLoadedUnit(uint32_t unit) override {
+    VELOX_CHECK_LT(unit, loadUnits_.size(), "Unit out of range");
+
+    processedUnits_.insert(unit);
+    // Ensure sliding window of units [unit, unit + maxConcurrentLoads_) is
+    // loading
+    for (size_t i = unit;
+         i < loadUnits_.size() && i < unit + maxConcurrentLoads_;
+         ++i) {
+      if (!unitsLoaded_[i]) {
+        load(i);
+      }
+    }
+
+    uint64_t unitLoadNanos{0};
+    try {
+      NanosecondTimer timer{&unitLoadNanos};
+      asyncSources_[unit]->move();
+    } catch (const std::exception& e) {
+      VELOX_FAIL("Failed to load unit {}: {}", unit, e.what());
+    }
+    waitForUnitReadyNanos_ += unitLoadNanos;
+
+    // Unload the previous units
+    unloadUntil(unit);
+
+    return *loadUnits_[unit];
+  }
+
+  void onRead(uint32_t unit, uint64_t rowOffsetInUnit, uint64_t /* rowCount */)
+      override {
+    VELOX_CHECK_LT(unit, loadUnits_.size(), "Unit out of range");
+    VELOX_CHECK_LT(
+        rowOffsetInUnit, loadUnits_[unit]->getNumRows(), "Row out of range");
+  }
+
+  void onSeek(uint32_t unit, uint64_t rowOffsetInUnit) override {
+    VELOX_CHECK_LT(unit, loadUnits_.size(), "Unit out of range");
+    VELOX_CHECK_LE(
+        rowOffsetInUnit, loadUnits_[unit]->getNumRows(), "Row out of range");
+  }
+
+  UnitLoaderStats stats() override {
+    UnitLoaderStats stats;
+    stats.addCounter("processedUnits", RuntimeCounter(processedUnits_.size()));
+    stats.addCounter(
+        "waitForUnitReadyNanos",
+        RuntimeCounter(
+            saturateCast(waitForUnitReadyNanos_),
+            RuntimeCounter::Unit::kNanos));
+    return stats;
+  }
+
+ private:
+  /// Submits the unit's load() to the I/O thread pool
+  void load(uint32_t unitIndex) {
+    VELOX_CHECK_LT(unitIndex, loadUnits_.size(), "Unit index out of bounds");
+    VELOX_CHECK_NOT_NULL(ioExecutor_, "ParallelUnitLoader ioExecutor is null");
+    VELOX_DCHECK(!loadUnits_.empty(), "loadUnits_ should not be empty");
+
+    // Capture shared_ptr by value to prevent use-after-free if
+    // ParallelUnitLoader is destroyed while async operation is running
+    auto unit = loadUnits_[unitIndex];
+    auto asyncSource = std::make_shared<AsyncSource<folly::Unit>>([unit] {
+      unit->load();
+      return std::make_unique<folly::Unit>();
+    });
+    asyncSources_[unitIndex] = asyncSource;
+    ioExecutor_->add([asyncSource] {
+      velox::common::testutil::TestValue::adjust(
+          "facebook::velox::dwio::common::ParallelUnitLoader::load",
+          asyncSource.get());
+      asyncSource->prepare();
+    });
+    unitsLoaded_[unitIndex] = true;
+  }
+
+  /// Unloads all the units before 'unitIndex'
+  void unloadUntil(uint32_t unitIndex) {
+    for (size_t i = 0; i < unitIndex; ++i) {
+      if (unitsLoaded_[i]) {
+        loadUnits_[i]->unload();
+        unitsLoaded_[i] = false;
+      }
+    }
+  }
+
+  std::vector<bool> unitsLoaded_;
+  std::vector<std::shared_ptr<LoadUnit>> loadUnits_;
+  std::vector<std::shared_ptr<AsyncSource<folly::Unit>>> asyncSources_;
+  folly::Executor* ioExecutor_;
+  size_t maxConcurrentLoads_;
+
+  // Stats
+  std::unordered_set<uint32_t> processedUnits_;
+  uint64_t waitForUnitReadyNanos_{0};
+};
+
+std::unique_ptr<UnitLoader> ParallelUnitLoaderFactory::create(
+    std::vector<std::unique_ptr<LoadUnit>> loadUnits,
+    uint64_t rowsToSkip) {
+  const auto totalRows = std::accumulate(
+      loadUnits.cbegin(), loadUnits.cend(), 0UL, [](uint64_t sum, auto& unit) {
+        return sum + unit->getNumRows();
+      });
+  VELOX_CHECK_LE(
+      rowsToSkip,
+      totalRows,
+      "Can only skip up to the past-the-end row of the file.");
+  return std::make_unique<ParallelUnitLoader>(
+      std::move(loadUnits), ioExecutor_, maxConcurrentLoads_);
+}
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/ParallelUnitLoader.h b/velox/dwio/common/ParallelUnitLoader.h
new file mode 100644
index 00000000000..0ba89028326
--- /dev/null
+++ b/velox/dwio/common/ParallelUnitLoader.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <folly/Executor.h>
+#include <folly/futures/Future.h>
+
+#include <vector>
+#include "velox/dwio/common/UnitLoader.h"
+
+namespace facebook::velox::dwio::common {
+class ParallelUnitLoaderFactory : public UnitLoaderFactory {
+ public:
+  ParallelUnitLoaderFactory(
+      folly::Executor* ioExecutor,
+      size_t maxConcurrentLoads)
+      : ioExecutor_(ioExecutor), maxConcurrentLoads_(maxConcurrentLoads) {}
+
+  std::unique_ptr<UnitLoader> create(
+      std::vector<std::unique_ptr<LoadUnit>> loadUnits,
+      uint64_t rowsToSkip) override;
+
+ private:
+  folly::Executor* ioExecutor_;
+  size_t maxConcurrentLoads_;
+};
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/PositionProvider.h b/velox/dwio/common/PositionProvider.h
index 7be3bc7a160..c99655a87e7 100644
--- a/velox/dwio/common/PositionProvider.h
+++ b/velox/dwio/common/PositionProvider.h
@@ -23,7 +23,7 @@ namespace facebook::velox::dwio::common {
 class PositionProvider {
  public:
   explicit PositionProvider(const std::vector<uint64_t>& positions)
-      : position_{positions.begin()}, end_{positions.end()} {}
+      : position_{positions.cbegin()}, end_{positions.cend()} {}
 
   uint64_t next();
 
diff --git a/velox/dwio/common/RandGen.h b/velox/dwio/common/RandGen.h
index b83743bbcca..a1fc53e8dc7 100644
--- a/velox/dwio/common/RandGen.h
+++ b/velox/dwio/common/RandGen.h
@@ -19,10 +19,7 @@
 #include <folly/Conv.h>
 #include <random>
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
 
 class RandGen {
  public:
@@ -68,7 +65,4 @@ class RandGen {
   std::uniform_int_distribution<int32_t> dist_;
 };
 
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/Reader.cpp b/velox/dwio/common/Reader.cpp
index 559dab5ae80..3d4508655a8 100644
--- a/velox/dwio/common/Reader.cpp
+++ b/velox/dwio/common/Reader.cpp
@@ -20,7 +20,7 @@ namespace facebook::velox::dwio::common {
 
 using namespace velox::common;
 
-VectorPtr RowReader::projectColumns(
+RowReader::ProjectColumnsResult RowReader::projectColumnsWithSelection(
     const VectorPtr& input,
     const ScanSpec& spec,
     const Mutation* mutation) {
@@ -75,11 +75,23 @@ VectorPtr RowReader::projectColumns(
   auto rowType = ROW(std::move(names), std::move(types));
   auto size = bits::countBits(passed.data(), 0, input->size());
   if (size == 0) {
-    return RowVector::createEmpty(rowType, input->pool());
+    // Empty output. Return null selectedRows when the input was already
+    // empty (no rows were dropped — identity mapping holds trivially).
+    // Otherwise return a zero-length selection buffer so callers can
+    // distinguish "all rows filtered out" from "identity mapping" by
+    // checking selectedRows == nullptr.
+    return {
+        RowVector::createEmpty(rowType, input->pool()),
+        input->size() == 0 ? nullptr : allocateIndices(0, input->pool())};
   }
+
+  // Preserve input nulls buffer
+  BufferPtr outputNulls = input->nulls();
+
+  BufferPtr selectedRows;
   if (size < input->size()) {
-    auto indices = allocateIndices(size, input->pool());
-    auto* rawIndices = indices->asMutable<vector_size_t>();
+    selectedRows = allocateIndices(size, input->pool());
+    auto* rawIndices = selectedRows->asMutable<vector_size_t>();
     vector_size_t j = 0;
     bits::forEachSetBit(
         passed.data(), 0, input->size(), [&](auto i) { rawIndices[j++] = i; });
@@ -89,11 +101,69 @@ VectorPtr RowReader::projectColumns(
       }
       child->disableMemo();
       child = BaseVector::wrapInDictionary(
-          nullptr, indices, size, std::move(child));
+          nullptr, selectedRows, size, std::move(child));
+    }
+
+    // Filter the nulls buffer to match the filtered rows
+    if (input->nulls()) {
+      outputNulls = AlignedBuffer::allocate<bool>(size, input->pool());
+      auto* rawOutputNulls = outputNulls->asMutable<uint64_t>();
+      // Initialize all as not null (all bits set to 1)
+      memset(rawOutputNulls, 0xFF, bits::nbytes(size));
+
+      const auto* rawInputNulls = input->rawNulls();
+      for (vector_size_t i = 0; i < size; ++i) {
+        if (bits::isBitNull(rawInputNulls, rawIndices[i])) {
+          bits::setNull(rawOutputNulls, i);
+        }
+      }
+    }
+  }
+
+  // Apply post-read transforms for column extraction pushdown.
+  // This runs after filtering/dictionary wrapping so the vectors have the
+  // correct row count.  If a child has more elements than the output size
+  // (e.g., text reader pre-allocates), slice it first.
+  bool hasTransforms = false;
+  for (auto& childSpec : spec.children()) {
+    if (!childSpec->projectOut() || !childSpec->hasTransform()) {
+      continue;
+    }
+    auto i = childSpec->channel();
+    if (children[i]) {
+      auto child = children[i];
+      if (child->size() > size) {
+        child = child->slice(0, size);
+      }
+      children[i] = childSpec->transform()(child, input->pool());
+      hasTransforms = true;
     }
   }
-  return std::make_shared<RowVector>(
-      input->pool(), rowType, nullptr, size, std::move(children));
+
+  // Rebuild rowType if transforms changed any child types.
+  if (hasTransforms) {
+    auto rowNames = rowType->asRow().names();
+    std::vector<TypePtr> rowTypes;
+    rowTypes.reserve(numColumns);
+    for (column_index_t i = 0; i < numColumns; ++i) {
+      rowTypes.push_back(
+          children[i] ? children[i]->type() : rowType->childAt(i));
+    }
+    rowType =
+        ROW(std::vector<std::string>(rowNames.begin(), rowNames.end()),
+            std::move(rowTypes));
+  }
+
+  auto output = std::make_shared<RowVector>(
+      input->pool(), rowType, outputNulls, size, std::move(children));
+  return {std::move(output), std::move(selectedRows)};
+}
+
+VectorPtr RowReader::projectColumns(
+    const VectorPtr& input,
+    const ScanSpec& spec,
+    const Mutation* mutation) {
+  return projectColumnsWithSelection(input, spec, mutation).output;
 }
 
 namespace {
diff --git a/velox/dwio/common/Reader.h b/velox/dwio/common/Reader.h
index 9dddfaeaca0..4fe4e7a5138 100644
--- a/velox/dwio/common/Reader.h
+++ b/velox/dwio/common/Reader.h
@@ -21,12 +21,16 @@
 #include <optional>
 #include <string>
 
+#include <folly/container/F14Map.h>
+
+#include "velox/connectors/Connector.h"
 #include "velox/dwio/common/InputStream.h"
 #include "velox/dwio/common/Mutation.h"
 #include "velox/dwio/common/Options.h"
 #include "velox/dwio/common/SelectiveColumnReader.h"
 #include "velox/dwio/common/Statistics.h"
 #include "velox/dwio/common/TypeWithId.h"
+#include "velox/serializers/KeyEncoder.h"
 #include "velox/type/Type.h"
 #include "velox/vector/BaseVector.h"
 
@@ -44,6 +48,16 @@ class RowReader {
  public:
   static constexpr int64_t kAtEnd = -1;
 
+  /// Runtime stat names.
+  /// Tracks the number of index columns that were converted from ScanSpec
+  /// filters to index bounds for index-based filtering (e.g., cluster index
+  /// pruning in Nimble).
+  static constexpr std::string_view kNumIndexFilterConversions =
+      "numIndexFilterConversions";
+
+  /// Tracks the number of times a stripe has been loaded during index lookup.
+  static constexpr std::string_view kNumStripeLoads = "numStripeLoads";
+
   virtual ~RowReader() = default;
 
   /**
@@ -139,6 +153,34 @@ class RowReader {
     return std::nullopt;
   }
 
+  /**
+   * Result of projectColumnsWithSelection. 'output' is the projected
+   * RowVector. 'selectedRows' maps each output row back to its input row
+   * index: selectedRows[i] is the input row that produced output row i.
+   * 'selectedRows' is null when no rows were dropped — output rows are
+   * identity-aligned with the input. This includes the empty-input case
+   * (input->size() == 0), where the identity mapping holds trivially.
+   * When all rows are filtered out from a non-empty input, 'output' is
+   * empty and 'selectedRows' is a non-null zero-length buffer so callers
+   * can distinguish "filtered to empty" from "identity mapping".
+   */
+  struct ProjectColumnsResult {
+    VectorPtr output;
+    BufferPtr selectedRows;
+  };
+
+  /**
+   * Like projectColumns, but also returns the input-row selection used to
+   * build the output. Callers that need to keep an external per-input-row
+   * structure (for example, an index reader's inputHits buffer) aligned
+   * with the filtered output can use 'selectedRows' to compact that
+   * structure without re-running filters.
+   */
+  static ProjectColumnsResult projectColumnsWithSelection(
+      const VectorPtr& input,
+      const velox::common::ScanSpec& spec,
+      const Mutation* mutation);
+
   /**
    * Helper function used by non-selective reader to project top level columns
    * according to the scan spec and mutations.
@@ -157,6 +199,154 @@ class RowReader {
       VectorPtr& result);
 };
 
+/// Represents a row range within a stripe [startRow, endRow).
+struct RowRange {
+  vector_size_t startRow{0}; // Inclusive
+  vector_size_t endRow{0}; // Exclusive
+
+  RowRange() = default;
+  RowRange(vector_size_t _startRow, vector_size_t _endRow)
+      : startRow(_startRow), endRow(_endRow) {}
+
+  /// Returns true if this row range is empty (no rows to read).
+  bool empty() const {
+    return startRow >= endRow;
+  }
+};
+
+/**
+ * Abstract index reader interface for index-based lookups.
+ *
+ * IndexReader provides a batch lookup API that takes a vector of index bounds
+ * and returns results via an iterator pattern. This interface is used by
+ * HiveIndexReader to perform efficient key-based lookups on indexed files.
+ *
+ * Usage pattern:
+ *   1. Call startLookup() with a vector of index bounds to start a new batch
+ * lookup
+ *   2. Call next() repeatedly to get results until it returns nullptr
+ *   3. Each next() call returns results for one or more request indices
+ *
+ * The implementation is responsible for:
+ *   - Encoding index bounds into format-specific keys
+ *   - Looking up stripes and row ranges
+ *   - Managing stripe iteration and data reading
+ *   - Returning results in the correct order
+ */
+class IndexReader {
+ public:
+  /// Runtime stat names for index reader.
+
+  /// Tracks the number of index lookup requests submitted in startLookup().
+  /// Each request corresponds to one set of index bounds and may match rows
+  /// across multiple stripes.
+  static constexpr std::string_view kNumIndexLookupRequests =
+      "numIndexLookupRequests";
+
+  /// Tracks the total number of stripes that need to be read for all requests.
+  /// Within a single startLookup() call, a stripe shared by multiple requests
+  /// is counted once; across different startLookup() calls, the same stripe is
+  /// counted separately for each call.
+  static constexpr std::string_view kNumIndexLookupStripes =
+      "numIndexLookupStripes";
+
+  /// Tracks the total number of rows in all loaded stripes. Measures the full
+  /// stripe row count regardless of how many rows are actually needed by
+  /// index lookups. Comparing with kNumIndexMatchedRows shows cluster index
+  /// selectivity within stripes.
+  static constexpr std::string_view kNumIndexScannedRows =
+      "numIndexScannedRows";
+
+  /// Tracks the total number of rows matched by the cluster index across all
+  /// stripes. These are the rows identified as matching the lookup bounds
+  /// within each stripe, before any ScanSpec filter pushdown. Comparing with
+  /// actual output rows shows filter selectivity.
+  static constexpr std::string_view kNumIndexMatchedRows =
+      "numIndexMatchedRows";
+
+  /// Tracks the total number of read segments across all stripes. A read
+  /// segment is a contiguous row range within a stripe that needs to be read.
+  /// When filters are present, overlapping request ranges are split at
+  /// boundaries to enable per-request output tracking. Without filters,
+  /// overlapping ranges are merged to minimize I/O.
+  static constexpr std::string_view kNumIndexLookupReadSegments =
+      "numIndexLookupReadSegments";
+
+  /// Wall time spent loading stripes (or equivalent format-specific load unit)
+  /// during index lookup, summed across all stripe loads.
+  static constexpr std::string_view kIndexStripeLoadWallNanos =
+      "indexStripeLoadWallNanos";
+
+  /// CPU time spent loading stripes during index lookup. May undercount on
+  /// async/prefetch paths; see IndexSource::lookupTiming() for details.
+  static constexpr std::string_view kIndexStripeLoadCpuNanos =
+      "indexStripeLoadCpuNanos";
+
+  /// Wall time spent decoding column data from loaded stripes during index
+  /// lookup, summed across all read segments.
+  static constexpr std::string_view kIndexDataDecodeWallNanos =
+      "indexDataDecodeWallNanos";
+
+  /// CPU time spent decoding column data from loaded stripes during index
+  /// lookup. Same prefetch caveat as kIndexStripeLoadCpuNanos.
+  static constexpr std::string_view kIndexDataDecodeCpuNanos =
+      "indexDataDecodeCpuNanos";
+
+  /// Number of distinct stripes loaded across the lifetime of this index
+  /// reader. Useful for spotting redundant loads when comparing against
+  /// numStripeLoads (which counts every load call).
+  static constexpr std::string_view kNumIndexDistinctStripesLoaded =
+      "numIndexDistinctStripesLoaded";
+
+  virtual ~IndexReader() = default;
+
+  /// Returns runtime statistics accumulated by this index reader.
+  virtual folly::F14FastMap<std::string, RuntimeMetric> stats() const {
+    return {};
+  }
+
+  /// Options for controlling index reader behavior.
+  struct Options {
+    /// Maximum number of rows to read per index lookup request.
+    /// When set to non-zero, the index reader will stop fetching or truncate
+    /// stripes once the total row range (before filtering) reaches this limit.
+    /// 0 means no limit (default).
+    vector_size_t maxRowsPerRequest{0};
+  };
+
+  /// Starts a new batch lookup with the given index bounds.
+  /// Each index bound in the vector represents a separate lookup request.
+  /// After calling startLookup(), call next() repeatedly to get results.
+  ///
+  /// @param indexBounds Index bounds for the lookup request. Contains
+  ///        column names and lower/upper bound values.
+  /// @param options Options controlling index reader behavior (e.g.,
+  ///        maxRowsPerRequest). Defaults to no limit.
+  /// @throws if lookup is not supported by the implementation or if any
+  ///         index bound is invalid.
+  virtual void startLookup(
+      const velox::serializer::IndexBounds& indexBounds,
+      const Options& options) = 0;
+
+  /// Returns true if there are more results to fetch from the current lookup.
+  virtual bool hasNext() const = 0;
+
+  /// Returns the next batch of results from the current lookup.
+  /// Results are returned in request order - all results for request N are
+  /// returned before any results for request N+1.
+  ///
+  /// The Result contains:
+  /// - inputHits: Buffer of request indices for each output row
+  /// - output: RowVector of matching data rows
+  ///
+  /// @param maxOutputRows Maximum number of output rows to return in this
+  ///        batch. The actual number may be less if fewer rows are available.
+  /// @return Result containing inputHits and output rows, or nullptr if no
+  ///         more results are available.
+  virtual std::unique_ptr<connector::IndexSource::Result> next(
+      vector_size_t maxOutputRows) = 0;
+};
+
 /**
  * Abstract reader class.
  *
@@ -179,11 +369,18 @@ class Reader {
    */
   virtual std::optional<uint64_t> numberOfRows() const = 0;
 
-  /**
-   * Get statistics for a specified column.
-   * @param index column index
-   * @return column statisctics
-   */
+  /// Returns file-level statistics for the column identified by 'index'.
+  ///
+  /// 'index' is a node ID in the type tree (TypeWithId::id()), not a top-level
+  /// column ordinal. Node 0 is the root ROW type; top-level columns start at 1
+  /// for flat schemas. For nested types, IDs follow pre-order DFS numbering.
+  ///
+  /// Use typeWithId() to navigate the schema and obtain the correct ID:
+  ///   auto& col = reader->typeWithId()->childByName("column_name");
+  ///   auto stats = reader->columnStatistics(col->id());
+  ///
+  /// Returns nullptr if statistics are not available (e.g., non-leaf complex
+  /// types in Parquet, out-of-range index, or missing stats in the file).
   virtual std::unique_ptr<ColumnStatistics> columnStatistics(
       uint32_t index) const = 0;
 
@@ -207,6 +404,17 @@ class Reader {
   virtual std::unique_ptr<RowReader> createRowReader(
       const RowReaderOptions& options = {}) const = 0;
 
+  /**
+   * Create index reader object for index-based lookups.
+   * @param options Row reader options describing the data to fetch
+   * @return Index reader for efficient key-based lookups
+   * @throws if index reading is not supported by the implementation
+   */
+  virtual std::unique_ptr<IndexReader> createIndexReader(
+      const RowReaderOptions& options = {}) const {
+    VELOX_UNSUPPORTED("Reader::createIndexReader() is not supported");
+  }
+
   static TypePtr updateColumnNames(
       const TypePtr& fileType,
       const TypePtr& tableType);
diff --git a/velox/dwio/common/Retry.h b/velox/dwio/common/Retry.h
index d2860cfb6b7..9ea087d4361 100644
--- a/velox/dwio/common/Retry.h
+++ b/velox/dwio/common/Retry.h
@@ -28,10 +28,7 @@
 #include "velox/dwio/common/RandGen.h"
 #include "velox/dwio/common/exception/Exception.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
 
 class retriable_error : public std::runtime_error {
  public:
@@ -229,7 +226,4 @@ class RetryModule {
   }
 };
 
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/ScanSpec.cpp b/velox/dwio/common/ScanSpec.cpp
index 69669122215..b6cbd4ab516 100644
--- a/velox/dwio/common/ScanSpec.cpp
+++ b/velox/dwio/common/ScanSpec.cpp
@@ -104,8 +104,8 @@ uint64_t ScanSpec::newRead() {
   if (numReads_ == 0 ||
       (!disableStatsBasedFilterReorder_ &&
        !std::is_sorted(
-           children_.begin(),
-           children_.end(),
+           children_.cbegin(),
+           children_.cend(),
            [this](
                const std::shared_ptr<ScanSpec>& left,
                const std::shared_ptr<ScanSpec>& right) {
@@ -321,6 +321,9 @@ bool testStringFilter(
 bool testBoolFilter(
     const common::Filter* filter,
     dwio::common::BooleanColumnStatistics* boolStats) {
+  if (!boolStats) {
+    return true;
+  }
   const auto trueCount = boolStats->getTrueCount();
   const auto falseCount = boolStats->getFalseCount();
   if (trueCount.has_value() && falseCount.has_value()) {
diff --git a/velox/dwio/common/ScanSpec.h b/velox/dwio/common/ScanSpec.h
index fbcac3d3a59..8204011ccda 100644
--- a/velox/dwio/common/ScanSpec.h
+++ b/velox/dwio/common/ScanSpec.h
@@ -28,17 +28,16 @@
 
 #include <vector>
 
-namespace facebook {
-namespace velox {
+namespace facebook::velox {
 namespace dwio::common {
 class ColumnStatistics;
 }
 namespace common {
 
-// Describes the filtering and value extraction for a
-// SelectiveColumnReader. This is owned by the TableScan Operator and
-// is passed to SelectiveColumnReaders at construction.  This is
-// mutable by readers to reflect filter order and other adaptations.
+/// Describes the filtering and value extraction for a
+/// SelectiveColumnReader. This is owned by the TableScan Operator and
+/// is passed to SelectiveColumnReaders at construction.  This is
+/// mutable by readers to reflect filter order and other adaptations.
 class ScanSpec {
  public:
   enum class ColumnType : int8_t {
@@ -47,7 +46,7 @@ class ScanSpec {
     kComposite, // A struct with all children not read from file
   };
 
-  // Convert ColumnType to its string name representation.
+  /// Convert ColumnType to its string name representation.
   static std::string_view columnTypeString(ColumnType columnType);
 
   static constexpr column_index_t kNoChannel = ~0;
@@ -57,15 +56,15 @@ class ScanSpec {
 
   explicit ScanSpec(const std::string& name) : fieldName_(name) {}
 
-  // Filter to apply. If 'this' corresponds to a struct/list/map, this
-  // can only be isNull or isNotNull, other filtering is given by
-  // 'children'.
+  /// Filter to apply. If 'this' corresponds to a struct/list/map, this
+  /// can only be isNull or isNotNull, other filtering is given by
+  /// 'children'.
   const common::Filter* filter() const {
     return filterDisabled_ ? nullptr : filter_.get();
   }
 
-  // Sets 'filter_'. May be used at initialization or when adding a
-  // pushed down filter, e.g. top k cutoff.
+  /// Sets 'filter_'. May be used at initialization or when adding a
+  /// pushed down filter, e.g. top k cutoff.
   void setFilter(std::shared_ptr<Filter> filter) {
     filter_ = std::move(filter);
   }
@@ -96,8 +95,8 @@ class ScanSpec {
     return metadataFilters_[i].second;
   }
 
-  // Returns a constant vector if 'this' corresponds to a partitioning
-  // column or to a missing column. These change from split to split.
+  /// Returns a constant vector if 'this' corresponds to a partitioning
+  /// column or to a missing column. These change from split to split.
   VectorPtr constantValue() const {
     return constantValue_;
   }
@@ -128,32 +127,34 @@ class ScanSpec {
     return columnType_ == ColumnType::kRegular && !isConstant();
   }
 
-  // Name of the value in its container, i.e. field name in struct or
-  // string key in map. Not all fields of 'this' apply in list/map
-  // value cases but the overhead is manageable, the space taken is
-  // less than the Subfield path that will in any case exist for each
-  // separately named list/map element.
+  /// Name of the value in its container, i.e. field name in struct or
+  /// string key in map. Not all fields of 'this' apply in list/map
+  /// value cases but the overhead is manageable, the space taken is
+  /// less than the Subfield path that will in any case exist for each
+  /// separately named list/map element.
   const std::string& fieldName() const {
     return fieldName_;
   }
 
-  // Subscript if this refers to a member of a list or an
-  // integer-keyed map value. If this is a member in a row, this is
-  // the ordinal position in the row type.  Subscript is mutable, for
-  // example the position of the reader in a struct's readers may vary
-  // between splits. Set to correspond to the position of 'fieldName'
-  // when first reading a struct. Not mutable if this refers to a
-  // list/map subscript.
+  /// Subscript if this refers to a member of a list or an
+  /// integer-keyed map value. If this is a member in a row, this is
+  /// the ordinal position in the row type.  Subscript is mutable, for
+  /// example the position of the reader in a struct's readers may vary
+  /// between splits. Set to correspond to the position of 'fieldName'
+  /// when first reading a struct. Not mutable if this refers to a
+  /// list/map subscript.
   int64_t subscript() const {
     return subscript_;
   }
 
   void setSubscript(int64_t subscript) {
-    subscript_ = subscript;
+    if (subscript_ != subscript) {
+      subscript_ = subscript;
+    }
   }
 
-  // True if the value is returned from scan.  A runtime pushdown of a filter
-  // function may cause this to become false at run time.
+  /// True if the value is returned from scan.  A runtime pushdown of a filter
+  /// function may cause this to become false at run time.
   bool projectOut() const {
     return projectOut_;
   }
@@ -166,8 +167,8 @@ class ScanSpec {
     return projectOut_ || deltaUpdate_;
   }
 
-  // Position in the RowVector returned by the top level scan. Applies
-  // only to children of the root struct where projectOut_ is true.
+  /// Position in the RowVector returned by the top level scan. Applies
+  /// only to children of the root struct where projectOut_ is true.
   column_index_t channel() const {
     return channel_;
   }
@@ -180,31 +181,31 @@ class ScanSpec {
     return children_;
   }
 
-  // Returns 'children in a stable order. May be used for parallel
-  // construction and read-ahead of reader trees while the main user
-  // of 'this' is running. 'children_' may be reordered while running
-  // but the tree being constructed must see a single, unchanging
-  // order.
+  /// Returns 'children in a stable order. May be used for parallel
+  /// construction and read-ahead of reader trees while the main user
+  /// of 'this' is running. 'children_' may be reordered while running
+  /// but the tree being constructed must see a single, unchanging
+  /// order.
   const std::vector<ScanSpec*>& stableChildren();
 
-  // Returns a read sequence number. This can b used for tagging
-  // lazy vectors with a generation number so that we can check that
-  // the reader that made them has not advanced between the making and
-  // the loading of the lazy vector. This must be called if 'this'
-  // corresponds to a struct or flat map reader with pushdown. This
-  // may periodically do adaptation such as filter reordering. This
-  // will initialize the read order on first call and calling this at
-  // each level of struct is mandatory.
+  /// Returns a read sequence number. This can b used for tagging
+  /// lazy vectors with a generation number so that we can check that
+  /// the reader that made them has not advanced between the making and
+  /// the loading of the lazy vector. This must be called if 'this'
+  /// corresponds to a struct or flat map reader with pushdown. This
+  /// may periodically do adaptation such as filter reordering. This
+  /// will initialize the read order on first call and calling this at
+  /// each level of struct is mandatory.
   uint64_t newRead();
 
   /// Returns the ScanSpec corresponding to 'name'. Creates it if needed without
   /// any intermediate level.
   ScanSpec* getOrCreateChild(const std::string& name);
 
-  // Returns the ScanSpec corresponding to 'subfield'. Creates it if
-  // needed, including any intermediate levels. This is used at
-  // TableScan initialization to create the ScanSpec tree that
-  // corresponds to the ColumnReader tree.
+  /// Returns the ScanSpec corresponding to 'subfield'. Creates it if
+  /// needed, including any intermediate levels. This is used at
+  /// TableScan initialization to create the ScanSpec tree that
+  /// corresponds to the ColumnReader tree.
   ScanSpec* getOrCreateChild(const Subfield& subfield);
 
   ScanSpec* childByName(const std::string& name) const {
@@ -227,11 +228,11 @@ class ScanSpec {
     valueHook_ = valueHook;
   }
 
-  // Returns true if the corresponding reader only needs to reference the nulls
-  // stream.  True if filter is is-null with or without value extraction or if
-  // filter is is-not-null and no value is extracted.  Note that this does not
-  // apply to Nimble format leaf nodes, because nulls are mixed in the encoding
-  // with actual values.
+  /// Returns true if the corresponding reader only needs to reference the nulls
+  /// stream.  True if filter is is-null with or without value extraction or if
+  /// filter is is-not-null and no value is extracted.  Note that this does not
+  /// apply to Nimble format leaf nodes, because nulls are mixed in the encoding
+  /// with actual values.
   bool readsNullsOnly() const {
     if (auto* filter = this->filter()) {
       if (filter->kind() == FilterKind::kIsNull) {
@@ -252,11 +253,11 @@ class ScanSpec {
     makeFlat_ = makeFlat;
   }
 
-  // True if this or a descendant has a filter that will affect the number of
-  // output rows.  Note that filter on map keys and array indices is not
-  // counted, as they do not change the number of container output rows.
-  //
-  // This may change as a result of runtime adaptation.
+  /// True if this or a descendant has a filter that will affect the number of
+  /// output rows.  Note that filter on map keys and array indices is not
+  /// counted, as they do not change the number of container output rows.
+  ///
+  /// This may change as a result of runtime adaptation.
   bool hasFilter() const;
 
   /// Similar as hasFilter() but also return true even there is a filter on
@@ -271,8 +272,8 @@ class ScanSpec {
   /// filtered out.
   bool testNull() const;
 
-  // Resets cached values after this or children were updated, e.g. a new filter
-  // was added or existing filter was modified.
+  /// Resets cached values after this or children were updated, e.g. a new
+  /// filter was added or existing filter was modified.
   void resetCachedValues(bool doReorder) {
     hasFilter_.reset();
     for (auto& child : children_) {
@@ -283,49 +284,50 @@ class ScanSpec {
     }
   }
 
-  // Returns the child which produces values for 'channel'. Throws if not found.
+  /// Returns the child which produces values for 'channel'. Throws if not
+  /// found.
   ScanSpec& getChildByChannel(column_index_t channel);
 
-  // sets filter order and filters of 'this' from 'other'. Used when
-  // initializing a ScanSpec for a new split or stripe. This transfers
-  // dynamically acquired filters and adaptive filter order. 'other'
-  // should not be used after this. Different splits or stripes may
-  // have their own ScanSpec trees, so we only move the content, not
-  // the ScanSpec tree itself.
+  /// Sets filter order and filters of 'this' from 'other'. Used when
+  /// initializing a ScanSpec for a new split or stripe. This transfers
+  /// dynamically acquired filters and adaptive filter order. 'other'
+  /// should not be used after this. Different splits or stripes may
+  /// have their own ScanSpec trees, so we only move the content, not
+  /// the ScanSpec tree itself.
   void moveAdaptationFrom(ScanSpec& other);
 
   std::string toString() const;
 
-  // Add a field to this ScanSpec, with content projected out.
+  /// Add a field to this ScanSpec, with content projected out.
   ScanSpec* addField(const std::string& name, column_index_t channel);
 
-  // Add a field and its children recursively to this ScanSpec, all projected
-  // out.
+  /// Add a field and its children recursively to this ScanSpec, all projected
+  /// out.
   ScanSpec* addFieldRecursively(
       const std::string& name,
       const Type&,
       column_index_t channel);
 
-  // Add a field for map key.
+  /// Add a field for map key.
   ScanSpec* addMapKeyField();
 
-  // Add a field for map key, along with its child recursively.
+  /// Add a field for map key, along with its child recursively.
   ScanSpec* addMapKeyFieldRecursively(const Type&);
 
-  // Add a field for map value.
+  /// Add a field for map value.
   ScanSpec* addMapValueField();
 
-  // Add a field for map value, along with its child recursively.
+  /// Add a field for map value, along with its child recursively.
   ScanSpec* addMapValueFieldRecursively(const Type&);
 
-  // Add a field for array element.
+  /// Add a field for array element.
   ScanSpec* addArrayElementField();
 
-  // Add a field for array element, along with its child recursively.
+  /// Add a field for array element, along with its child recursively.
   ScanSpec* addArrayElementFieldRecursively(const Type&);
 
-  // Add all child fields on the type recursively to this ScanSpec, all
-  // projected out.
+  /// Add all child fields on the type recursively to this ScanSpec, all
+  /// projected out.
   void addAllChildFields(const Type&);
 
   const std::vector<std::string>& flatMapFeatureSelection() const {
@@ -378,6 +380,86 @@ class ScanSpec {
     isFlatMapAsStruct_ = value;
   }
 
+  /// Extraction type for column extraction pushdown.  When set on a map or
+  /// array ScanSpec, tells the column reader to skip reading unneeded
+  /// streams and produce a different output type.
+  enum class ExtractionType : uint8_t {
+    kNone, ///< No extraction — read normally.
+    kKeys, ///< Extract map keys as ARRAY(K).  Skip reading values.
+    kValues, ///< Extract map values as ARRAY(V).  Skip reading keys.
+    kSize, ///< Extract size as BIGINT.  Skip reading keys and values.
+    kField, ///< Extract a single struct field.  Output is the field's type.
+  };
+
+  void setExtractionType(ExtractionType type) {
+    extractionType_ = type;
+  }
+
+  ExtractionType extractionType() const {
+    return extractionType_;
+  }
+
+  void setExtractionFieldIndex(column_index_t index) {
+    extractionFieldIndex_ = index;
+  }
+
+  column_index_t extractionFieldIndex() const {
+    return extractionFieldIndex_;
+  }
+
+  /// Post-read transform applied to the column's vector after it is read
+  /// from the file.  Used by column extraction pushdown to transform the
+  /// file-type vector (e.g., MAP) into the extraction output type (e.g.,
+  /// ARRAY for MapKeys).  The transform receives the read vector and a
+  /// memory pool, and returns the transformed vector.
+  ///
+  /// The transform is applied in these cases:
+  ///
+  /// 1. Delta update fallback: when a column has both extraction pushdown
+  ///    and a delta update (e.g., MAP_CONCAT), the reader checks
+  ///    deltaUpdate() and bypasses ExtractionType, producing the file
+  ///    type.  After the delta update modifies the vector, the full-chain
+  ///    transform is applied by SelectiveStructColumnReaderBase::getValues().
+  ///    ExtractionType may be set but is ignored by the reader.
+  ///
+  /// 2. Multiple extractions: when multiple extraction chains target the
+  ///    same column, the transform assembles a ROW from the individual
+  ///    extraction results.  ExtractionType is always kNone (not set for
+  ///    multiple extractions to ensure text reader compatibility).
+  ///
+  /// 3. Text reader: RowReader::projectColumns() applies the transform
+  ///    because the text reader does not use the selective reader
+  ///    framework.  ExtractionType is kNone (same as case 2) or set but
+  ///    ignored (single extraction — text reader applies the full-chain
+  ///    transform regardless).
+  ///
+  /// For selective readers (DWRF, Nimble) with a single extraction and
+  /// no delta update, the full chain is handled by ScanSpec pushdown
+  /// (ExtractionType + sub-spec pruning) and the transform is not
+  /// applied at read time.
+  using VectorTransform =
+      std::function<VectorPtr(const VectorPtr&, memory::MemoryPool*)>;
+
+  /// Set the post-read transform and the output type it produces.
+  /// The reader uses outputType to allocate the result vector, reads into
+  /// a temporary vector of the file type, then applies the transform.
+  void setTransform(VectorTransform transform, TypePtr outputType) {
+    transform_ = std::move(transform);
+    transformOutputType_ = std::move(outputType);
+  }
+
+  const VectorTransform& transform() const {
+    return transform_;
+  }
+
+  const TypePtr& transformOutputType() const {
+    return transformOutputType_;
+  }
+
+  bool hasTransform() const {
+    return transform_ != nullptr;
+  }
+
   /// Disable stats based filter reordering.
   void disableStatsBasedFilterReorder() {
     disableStatsBasedFilterReorder_ = true;
@@ -407,29 +489,29 @@ class ScanSpec {
   // Number of times read is called on the corresponding reader. This
   // is used for setup on first use and to produce a read sequence
   // number for LazyVectors.
-  uint64_t numReads_ = 0;
+  uint64_t numReads_{0};
 
   // Ordinal position of 'this' in its containing spec. For a struct
   // member this is the position of the reader in the child
   // readers. If this describes an operation on an array element or a
   // map with numeric key, this is the subscript as defined for array
   // or map.
-  int64_t subscript_ = -1;
+  int64_t subscript_{-1};
   // Column name if this is a struct mamber. String key if this
   // describes an operation on a map value.
   std::string fieldName_;
   // Ordinal position of the extracted value in the containing
   // RowVector. Set only when this describes a struct member.
-  column_index_t channel_ = kNoChannel;
+  column_index_t channel_{kNoChannel};
 
   VectorPtr constantValue_;
-  bool projectOut_ = false;
+  bool projectOut_{false};
 
-  ColumnType columnType_ = ColumnType::kRegular;
+  ColumnType columnType_{ColumnType::kRegular};
 
   // True if a string dictionary or flat map in this field should be
   // returned as flat.
-  bool makeFlat_ = false;
+  bool makeFlat_{false};
   std::shared_ptr<const common::Filter> filter_;
   bool filterDisabled_ = false;
   dwio::common::DeltaColumnUpdater* deltaUpdate_ = nullptr;
@@ -470,6 +552,18 @@ class ScanSpec {
   // This node represents a flat map column that need to be read as struct,
   // i.e. in table schema it is a MAP, but in result vector it is ROW.
   bool isFlatMapAsStruct_ = false;
+
+  // Extraction type for map/array/struct column readers.
+  ExtractionType extractionType_{ExtractionType::kNone};
+
+  // Index of the field to extract when extractionType_ is kField.
+  column_index_t extractionFieldIndex_{0};
+
+  // Post-read transform for column extraction pushdown.
+  VectorTransform transform_;
+
+  // Output type after the transform is applied.
+  TypePtr transformOutputType_;
 };
 
 template <typename F>
@@ -501,8 +595,8 @@ void ScanSpec::visit(const Type& type, F&& f) {
   }
 }
 
-// Returns false if no value from a range defined by stats can pass the
-// filter. True, otherwise.
+/// Returns false if no value from a range defined by stats can pass the
+/// filter. True, otherwise.
 bool testFilter(
     const common::Filter* filter,
     dwio::common::ColumnStatistics* stats,
@@ -510,8 +604,7 @@ bool testFilter(
     const TypePtr& type);
 
 } // namespace common
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox
 
 template <>
 struct fmt::formatter<facebook::velox::common::ScanSpec::ColumnType>
diff --git a/velox/dwio/common/SeekableInputStream.cpp b/velox/dwio/common/SeekableInputStream.cpp
index 2f461551626..db3c7f4a502 100644
--- a/velox/dwio/common/SeekableInputStream.cpp
+++ b/velox/dwio/common/SeekableInputStream.cpp
@@ -163,8 +163,8 @@ bool SeekableArrayInputStream::SkipInt64(int64_t count) {
   return false;
 }
 
-google::protobuf::int64 SeekableArrayInputStream::ByteCount() const {
-  return static_cast<google::protobuf::int64>(position_);
+int64_t SeekableArrayInputStream::ByteCount() const {
+  return static_cast<int64_t>(position_);
 }
 
 void SeekableArrayInputStream::seekToPosition(PositionProvider& position) {
@@ -241,8 +241,8 @@ bool SeekableFileInputStream::SkipInt64(int64_t signedCount) {
   return position_ < length_;
 }
 
-google::protobuf::int64 SeekableFileInputStream::ByteCount() const {
-  return static_cast<google::protobuf::int64>(position_);
+int64_t SeekableFileInputStream::ByteCount() const {
+  return static_cast<int64_t>(position_);
 }
 
 void SeekableFileInputStream::seekToPosition(PositionProvider& location) {
diff --git a/velox/dwio/common/SeekableInputStream.h b/velox/dwio/common/SeekableInputStream.h
index c53347a6204..f4e33008523 100644
--- a/velox/dwio/common/SeekableInputStream.h
+++ b/velox/dwio/common/SeekableInputStream.h
@@ -79,7 +79,7 @@ class SeekableArrayInputStream : public SeekableInputStream {
   virtual bool Next(const void** data, int32_t* size) override;
   virtual void BackUp(int32_t count) override;
   virtual bool SkipInt64(int64_t count) override;
-  virtual google::protobuf::int64 ByteCount() const override;
+  virtual int64_t ByteCount() const override;
   virtual void seekToPosition(PositionProvider& position) override;
   virtual std::string getName() const override;
   virtual size_t positionSize() const override;
@@ -120,7 +120,7 @@ class SeekableFileInputStream : public SeekableInputStream {
   virtual bool Next(const void** data, int32_t* size) override;
   virtual void BackUp(int32_t count) override;
   virtual bool SkipInt64(int64_t count) override;
-  virtual google::protobuf::int64 ByteCount() const override;
+  virtual int64_t ByteCount() const override;
   virtual void seekToPosition(PositionProvider& position) override;
   virtual std::string getName() const override;
   virtual size_t positionSize() const override;
diff --git a/velox/dwio/common/SelectiveColumnReader.cpp b/velox/dwio/common/SelectiveColumnReader.cpp
index 17b2207d65a..f2fc5918c02 100644
--- a/velox/dwio/common/SelectiveColumnReader.cpp
+++ b/velox/dwio/common/SelectiveColumnReader.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "velox/common/time/CpuWallTimer.h"
 #include "velox/dwio/common/SelectiveColumnReaderInternal.h"
 
 namespace facebook::velox::dwio::common {
@@ -46,17 +47,36 @@ SelectiveColumnReader::SelectiveColumnReader(
     std::shared_ptr<const dwio::common::TypeWithId> fileType,
     dwio::common::FormatParams& params,
     velox::common::ScanSpec& scanSpec)
-    : memoryPool_(&params.pool()),
+    : pool_(&params.pool()),
       requestedType_(requestedType),
       fileType_(fileType),
       formatData_(params.toFormatData(fileType, scanSpec)),
       scanSpec_(&scanSpec),
-      outputRows_(memoryPool_),
-      valueRows_(memoryPool_),
-      outerNonNullRows_(memoryPool_),
-      innerNonNullRows_(memoryPool_) {
-  scanState_.rowsCopy = raw_vector<vector_size_t>(memoryPool_);
-  scanState_.filterCache = raw_vector<uint8_t>(memoryPool_);
+      outputRows_(pool_),
+      valueRows_(pool_),
+      outerNonNullRows_(pool_),
+      innerNonNullRows_(pool_) {
+  scanState_.rowsCopy = raw_vector<vector_size_t>(pool_);
+  scanState_.filterCache = raw_vector<uint8_t>(pool_);
+  // Initialize per-column metrics if collection is enabled.
+  if (params.runtimeStatistics().columnMetricsSet) {
+    columnMetrics_ = params.runtimeStatistics().columnMetricsSet->getOrCreate(
+        fileType_->id());
+  }
+}
+
+void SelectiveColumnReader::readWithTiming(
+    int64_t offset,
+    const RowSet& rows,
+    const uint64_t* incomingNulls) {
+  if (columnMetrics_ && fileType_->type()->isPrimitiveType()) {
+    DeltaCpuWallTimer timer([this](const CpuWallTiming& timing) {
+      columnMetrics_->decodeCPUTimeNanos.increment(timing.cpuNanos);
+    });
+    read(offset, rows, incomingNulls);
+  } else {
+    read(offset, rows, incomingNulls);
+  }
 }
 
 void SelectiveColumnReader::filterRowGroups(
@@ -130,8 +150,8 @@ void SelectiveColumnReader::prepareNulls(
       resultNulls_->capacity() >= bits::nbytes(numRows) + simd::kPadding) {
     resultNulls_->setSize(bits::nbytes(numRows));
   } else {
-    resultNulls_ = AlignedBuffer::allocate<bool>(
-        numRows + (simd::kPadding * 8), memoryPool_);
+    resultNulls_ =
+        AlignedBuffer::allocate<bool>(numRows + (simd::kPadding * 8), pool_);
     rawResultNulls_ = resultNulls_->asMutable<uint64_t>();
   }
   anyNulls_ = false;
@@ -151,7 +171,7 @@ const uint64_t* SelectiveColumnReader::shouldMoveNulls(const RowSet& rows) {
     if (!(resultNulls_ && resultNulls_->unique() &&
           resultNulls_->capacity() >= rows.size() + simd::kPadding)) {
       resultNulls_ = AlignedBuffer::allocate<bool>(
-          rows.size() + (simd::kPadding * 8), memoryPool_);
+          rows.size() + (simd::kPadding * 8), pool_);
       rawResultNulls_ = resultNulls_->asMutable<uint64_t>();
     }
     moveFrom = nullsInReadRange_->as<uint64_t>();
@@ -243,7 +263,19 @@ void SelectiveColumnReader::getIntValues(
       }
       break;
     case TypeKind::HUGEINT:
-      getFlatValues<int128_t, int128_t>(rows, result, requestedType);
+      switch (valueSize_) {
+        case 16:
+          getFlatValues<int128_t, int128_t>(rows, result, requestedType);
+          break;
+        case 8:
+          getFlatValues<int64_t, int128_t>(rows, result, requestedType);
+          break;
+        case 4:
+          getFlatValues<int32_t, int128_t>(rows, result, requestedType);
+          break;
+        default:
+          VELOX_FAIL("Unsupported value size: {}", valueSize_);
+      }
       break;
     case TypeKind::BIGINT:
       switch (valueSize_) {
@@ -260,6 +292,17 @@ void SelectiveColumnReader::getIntValues(
           VELOX_FAIL("Unsupported value size: {}", valueSize_);
       }
       break;
+    case TypeKind::DOUBLE:
+      // Only Parquet INT32 (valueSize_==4) widens to DOUBLE. INT64->DOUBLE
+      // is rejected in convertType due to precision loss.
+      switch (valueSize_) {
+        case 4:
+          getFlatValues<int32_t, double>(rows, result, requestedType);
+          break;
+        default:
+          VELOX_FAIL("Unsupported value size: {}", valueSize_);
+      }
+      break;
     default:
       VELOX_FAIL(
           "Not a valid type for integer reader: {}", requestedType->toString());
@@ -344,8 +387,7 @@ void SelectiveColumnReader::getFlatValues<int8_t, bool>(
   constexpr int32_t kWidth = xsimd::batch<int8_t>::size;
   VELOX_CHECK_EQ(valueSize_, sizeof(int8_t));
   compactScalarValues<int8_t, int8_t>(rows, isFinal);
-  auto boolValues =
-      AlignedBuffer::allocate<bool>(numValues_, memoryPool_, false);
+  auto boolValues = AlignedBuffer::allocate<bool>(numValues_, pool_, false);
   auto rawBytes = values_->as<int8_t>();
   auto zero = xsimd::broadcast<int8_t>(0);
   if constexpr (kWidth == 32) {
@@ -363,7 +405,7 @@ void SelectiveColumnReader::getFlatValues<int8_t, bool>(
     }
   }
   *result = std::make_shared<FlatVector<bool>>(
-      memoryPool_,
+      pool_,
       type,
       resultNulls(),
       numValues_,
@@ -410,11 +452,11 @@ void SelectiveColumnReader::compactScalarValues<bool, bool>(
   values_->setSize(bits::nbytes(numValues_));
 }
 
-char* SelectiveColumnReader::copyStringValue(folly::StringPiece value) {
+char* SelectiveColumnReader::copyStringValue(std::string_view value) {
   uint64_t size = value.size();
   if (stringBuffers_.empty() || rawStringUsed_ + size > rawStringSize_) {
     auto bytes = std::max(size, kStringBufferSize);
-    BufferPtr buffer = AlignedBuffer::allocate<char>(bytes, memoryPool_);
+    BufferPtr buffer = AlignedBuffer::allocate<char>(bytes, pool_);
     // Use the preferred size instead of the requested one to improve memory
     // efficiency.
     buffer->setSize(buffer->capacity());
@@ -431,7 +473,7 @@ char* SelectiveColumnReader::copyStringValue(folly::StringPiece value) {
   return rawStringBuffer_ + start;
 }
 
-void SelectiveColumnReader::addStringValue(folly::StringPiece value) {
+void SelectiveColumnReader::addStringValue(std::string_view value) {
   auto copy = copyStringValue(value);
   reinterpret_cast<StringView*>(rawValues_)[numValues_++] =
       StringView(copy, value.size());
@@ -449,8 +491,11 @@ void SelectiveColumnReader::setNulls(BufferPtr resultNulls) {
 
 void SelectiveColumnReader::resetFilterCaches() {
   if (scanState_.filterCache.empty() && scanSpec_->hasFilter()) {
-    scanState_.filterCache.resize(std::max<int32_t>(
-        1, scanState_.dictionary.numValues + scanState_.dictionary2.numValues));
+    scanState_.filterCache.resize(
+        std::max<int32_t>(
+            1,
+            scanState_.dictionary.numValues +
+                scanState_.dictionary2.numValues));
     scanState_.updateRawState();
   }
   if (!scanState_.filterCache.empty()) {
@@ -476,7 +521,7 @@ void SelectiveColumnReader::addSkippedParentNulls(
     int64_t from,
     int64_t to,
     int32_t numNulls) {
-  auto rowsPerRowGroup = formatData_->rowsPerRowGroup();
+  const auto rowsPerRowGroup = formatData_->rowsPerRowGroup();
   if (rowsPerRowGroup.has_value() &&
       from / rowsPerRowGroup.value() >
           parentNullsRecordedTo_ / rowsPerRowGroup.value()) {
@@ -484,7 +529,7 @@ void SelectiveColumnReader::addSkippedParentNulls(
     parentNullsRecordedTo_ = from;
     numParentNulls_ = 0;
   }
-  if (parentNullsRecordedTo_) {
+  if (parentNullsRecordedTo_ > 0) {
     VELOX_CHECK_EQ(parentNullsRecordedTo_, from);
   }
   numParentNulls_ += numNulls;
diff --git a/velox/dwio/common/SelectiveColumnReader.h b/velox/dwio/common/SelectiveColumnReader.h
index 591208b1788..fe727c1ba37 100644
--- a/velox/dwio/common/SelectiveColumnReader.h
+++ b/velox/dwio/common/SelectiveColumnReader.h
@@ -27,6 +27,10 @@
 
 namespace facebook::velox::dwio::common {
 
+struct ColumnMetrics;
+
+using ScanSpec = velox::common::ScanSpec;
+
 /// Generalized representation of a set of distinct values for dictionary
 /// encodings.
 struct DictionaryValues {
@@ -128,6 +132,10 @@ struct ScanState {
   RawScanState rawState;
 };
 
+inline bool isDense(const RowSet& rows) {
+  return rows.empty() || rows.size() == rows.back() + 1;
+}
+
 class SelectiveColumnReader {
  public:
   static constexpr uint64_t kStringBufferSize = 16 * 1024;
@@ -169,6 +177,14 @@ class SelectiveColumnReader {
   virtual void
   read(int64_t offset, const RowSet& rows, const uint64_t* incomingNulls) = 0;
 
+  /// Wraps read() to collect decode timing stats for leaf columns.
+  /// Only times primitive types to avoid double-counting in complex types
+  /// (struct/map/array) which recursively call children's readWithTiming.
+  void readWithTiming(
+      int64_t offset,
+      const RowSet& rows,
+      const uint64_t* incomingNulls);
+
   virtual uint64_t skip(uint64_t numValues) {
     return formatData_->skip(numValues);
   }
@@ -241,7 +257,7 @@ class SelectiveColumnReader {
   uint64_t* mutableNulls(int32_t size) {
     if (!resultNulls_->unique()) {
       resultNulls_ = AlignedBuffer::allocate<bool>(
-          numValues_ + size, memoryPool_, bits::kNotNull);
+          numValues_ + size, pool_, bits::kNotNull);
       rawResultNulls_ = resultNulls_->asMutable<uint64_t>();
     }
     if (resultNulls_->capacity() * 8 < numValues_ + size) {
@@ -482,20 +498,27 @@ class SelectiveColumnReader {
     return false;
   }
 
-  StringView copyStringValueIfNeed(folly::StringPiece value) {
-    if (value.size() <= StringView::kInlineSize) {
+  StringView copyStringValueIfNeed(std::string_view value) {
+    if (value.size() <= StringView::kInlineSize ||
+        formatData().stringDecoderZeroCopy()) {
       return StringView(value);
     }
+
     auto* data = copyStringValue(value);
     return StringView(data, value.size());
   }
 
+  void setStringBuffers(std::vector<BufferPtr> buffers) {
+    stringBuffers_ = std::move(buffers);
+    rawStringBuffer_ = nullptr;
+  }
+
   virtual void setCurrentRowNumber(int64_t /*value*/) {
     VELOX_UNREACHABLE("Only struct reader supports this method");
   }
 
   memory::MemoryPool* memoryPool() const {
-    return memoryPool_;
+    return pool_;
   }
 
  protected:
@@ -581,11 +604,11 @@ class SelectiveColumnReader {
   // Checks consistency of nulls-related state.
   const uint64_t* shouldMoveNulls(const RowSet& rows);
 
-  void addStringValue(folly::StringPiece value);
+  void addStringValue(std::string_view value);
 
   // Copies 'value' to buffers owned by 'this' and returns the start of the
   // copy.
-  char* copyStringValue(folly::StringPiece value);
+  char* copyStringValue(std::string_view value);
 
   virtual bool hasDeletion() const {
     return false;
@@ -620,7 +643,7 @@ class SelectiveColumnReader {
     return scanSpec_->hasFilter() || hasDeletion();
   }
 
-  memory::MemoryPool* const memoryPool_;
+  memory::MemoryPool* const pool_;
 
   // The requested data type
   const TypePtr requestedType_;
@@ -636,6 +659,10 @@ class SelectiveColumnReader {
   // run time based on adaptation. Owned by caller.
   velox::common::ScanSpec* const scanSpec_;
 
+  // Per-column metrics for timing stats. May be nullptr if collection is
+  // disabled.
+  ColumnMetrics* columnMetrics_{nullptr};
+
   // Row number after last read row, relative to the ORC stripe or Parquet
   // Rowgroup start.
   int64_t readOffset_ = 0;
@@ -732,13 +759,14 @@ class SelectiveColumnReader {
 };
 
 template <>
-inline void SelectiveColumnReader::addValue(const folly::StringPiece value) {
+inline void SelectiveColumnReader::addValue(const std::string_view value) {
   const uint64_t size = value.size();
-  if (size <= StringView::kInlineSize) {
+  if (formatData().stringDecoderZeroCopy() || size <= StringView::kInlineSize) {
     reinterpret_cast<StringView*>(rawValues_)[numValues_++] =
         StringView(value.data(), size);
     return;
   }
+
   if (rawStringBuffer_ && rawStringUsed_ + size <= rawStringSize_) {
     memcpy(rawStringBuffer_ + rawStringUsed_, value.data(), size);
     reinterpret_cast<StringView*>(rawValues_)[numValues_++] =
@@ -766,7 +794,7 @@ struct NoHook final : public ValueHook {
 
   void addValue(vector_size_t /*row*/, double /*value*/) final {}
 
-  void addValue(vector_size_t /*row*/, folly::StringPiece /*value*/) final {}
+  void addValue(vector_size_t /*row*/, std::string_view /*value*/) final {}
 };
 
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/SelectiveColumnReaderInternal.h b/velox/dwio/common/SelectiveColumnReaderInternal.h
index f491870bfff..a9033b8d10b 100644
--- a/velox/dwio/common/SelectiveColumnReaderInternal.h
+++ b/velox/dwio/common/SelectiveColumnReaderInternal.h
@@ -21,16 +21,22 @@
 #include "velox/dwio/common/DirectDecoder.h"
 #include "velox/dwio/common/SelectiveColumnReader.h"
 #include "velox/dwio/common/TypeUtils.h"
-#include "velox/exec/AggregationHook.h"
 #include "velox/type/Timestamp.h"
+#include "velox/vector/AggregationHook.h"
 #include "velox/vector/ConstantVector.h"
 #include "velox/vector/DictionaryVector.h"
 #include "velox/vector/FlatVector.h"
 
 #include <numeric>
+#include <type_traits>
 
 namespace facebook::velox::dwio::common {
 
+/// True for arithmetic types and extended integer types (int128_t, uint128_t).
+template <typename T>
+inline constexpr bool kIsNumericScalar = std::is_arithmetic_v<T> ||
+    std::is_same_v<T, int128_t> || std::is_same_v<T, uint128_t>;
+
 template <typename T>
 void SelectiveColumnReader::ensureValuesCapacity(
     vector_size_t numRows,
@@ -40,8 +46,8 @@ void SelectiveColumnReader::ensureValuesCapacity(
           BaseVector::byteSize<T>(numRows) + simd::kPadding) {
     return;
   }
-  auto newValues = AlignedBuffer::allocate<T>(
-      numRows + simd::kPadding / sizeof(T), memoryPool_);
+  auto newValues =
+      AlignedBuffer::allocate<T>(numRows + simd::kPadding / sizeof(T), pool_);
   if (preserveData) {
     std::memcpy(
         newValues->template asMutable<char>(), rawValues_, values_->capacity());
@@ -98,6 +104,26 @@ void SelectiveColumnReader::getFlatValues(
     VectorPtr* result,
     const TypePtr& type,
     bool isFinal) {
+  static_assert(
+      std::is_trivially_copyable_v<T> && std::is_trivially_copyable_v<TVector>,
+      "T and TVector must be trivially copyable types");
+
+  // When T and TVector differ, both must be numeric scalars. This prevents
+  // accidental cross-domain copies such as Timestamp<->int64_t or
+  // StringView<->int128_t. Same-size cross-domain conversions (e.g.,
+  // int32_t -> float) would be strict-aliasing violations in
+  // compactScalarValues; schema validation must reject them before reaching
+  // here.
+  if constexpr (!std::is_same_v<T, TVector>) {
+    static_assert(
+        kIsNumericScalar<T> && kIsNumericScalar<TVector>,
+        "Cross-type getFlatValues requires both T and TVector to be numeric");
+    static_assert(
+        sizeof(T) != sizeof(TVector) ||
+            std::is_floating_point_v<T> == std::is_floating_point_v<TVector>,
+        "Same-size cross-domain conversions (e.g., int32 -> float) are not "
+        "supported");
+  }
   VELOX_CHECK_NE(valueSize_, kNoValueSize);
   VELOX_CHECK(mayGetValues_);
   if (isFinal) {
@@ -111,12 +137,12 @@ void SelectiveColumnReader::getFlatValues(
       } else {
         flatMapValueConstantNullValues_ =
             std::make_shared<ConstantVector<TVector>>(
-                memoryPool_, rows.size(), true, type, T());
+                pool_, rows.size(), true, type, TVector());
       }
       *result = flatMapValueConstantNullValues_;
     } else {
       *result = std::make_shared<ConstantVector<TVector>>(
-          memoryPool_, rows.size(), true, type, T());
+          pool_, rows.size(), true, type, TVector());
     }
     return;
   }
@@ -138,7 +164,7 @@ void SelectiveColumnReader::getFlatValues(
       flat->setStringBuffers(std::move(stringBuffers_));
     } else {
       flatMapValueFlatValues_ = std::make_shared<FlatVector<TVector>>(
-          memoryPool_,
+          pool_,
           type,
           resultNulls(),
           numValues_,
@@ -148,7 +174,7 @@ void SelectiveColumnReader::getFlatValues(
     *result = flatMapValueFlatValues_;
   } else {
     *result = std::make_shared<FlatVector<TVector>>(
-        memoryPool_,
+        pool_,
         type,
         resultNulls(),
         numValues_,
diff --git a/velox/dwio/common/SelectiveFlatMapColumnReader.cpp b/velox/dwio/common/SelectiveFlatMapColumnReader.cpp
index 05bf1a7a991..15ce348fd7f 100644
--- a/velox/dwio/common/SelectiveFlatMapColumnReader.cpp
+++ b/velox/dwio/common/SelectiveFlatMapColumnReader.cpp
@@ -57,42 +57,16 @@ void SelectiveFlatMapColumnReader::getValues(
   auto* resultFlatMap = prepareResult(*result, keysVector_, rows.size());
   setComplexNulls(rows, *result);
 
-  for (const auto& childSpec : scanSpec_->children()) {
-    VELOX_TRACE_HISTORY_PUSH("getValues %s", childSpec->fieldName().c_str());
-    if (!childSpec->keepValues()) {
-      continue;
-    }
-
-    VELOX_CHECK(
-        childSpec->readFromFile(),
-        "Flatmap children must always be read from file.");
-
-    if (childSpec->subscript() == kConstantChildSpecSubscript) {
-      continue;
-    }
-
-    const auto channel = childSpec->channel();
-    const auto index = childSpec->subscript();
-    auto& childResult = resultFlatMap->mapValuesAt(channel);
-
-    VELOX_CHECK(
-        !childSpec->deltaUpdate(),
-        "Delta update not supported in flat map yet");
-    VELOX_CHECK(
-        !childSpec->isConstant(),
-        "Flat map values cannot be constant in scanSpec.");
-    VELOX_CHECK_EQ(
-        childSpec->columnType(),
-        velox::common::ScanSpec::ColumnType::kRegular,
-        "Flat map only supports regular column types in scan spec.");
-
-    children_[index]->getValues(rows, &childResult);
-
-    for (size_t i = 0; i < children_.size(); ++i) {
-      const auto& inMap = inMapBuffer(i);
-      if (inMap) {
-        resultFlatMap->inMapsAt(i, true) = inMap;
-      }
+  // Loop over column readers
+  for (int i = 0; i < children_.size(); ++i) {
+    auto& child = children_[i];
+    VectorPtr values;
+    child->getValues(rows, &values);
+    resultFlatMap->mapValuesAt(i) = values;
+
+    const auto& inMap = inMapBuffer(i);
+    if (inMap) {
+      resultFlatMap->inMapsAt(i, true) = inMap;
     }
   }
 }
diff --git a/velox/dwio/common/SelectiveFloatingPointColumnReader.h b/velox/dwio/common/SelectiveFloatingPointColumnReader.h
index a096b7e34e1..1f3445918b6 100644
--- a/velox/dwio/common/SelectiveFloatingPointColumnReader.h
+++ b/velox/dwio/common/SelectiveFloatingPointColumnReader.h
@@ -35,9 +35,11 @@ class SelectiveFloatingPointColumnReader : public SelectiveColumnReader {
             params,
             scanSpec) {}
 
-  // Offers fast path only if data and result widths match.
+  // Offers a fast path only if data and result widths match.
+  static constexpr bool kHasBulkPath = std::is_same_v<TData, TRequested>;
+
   bool hasBulkPath() const override {
-    return std::is_same_v<TData, TRequested>;
+    return kHasBulkPath;
   }
 
   template <typename Reader, bool kEncodingHasNulls>
@@ -90,7 +92,7 @@ void SelectiveFloatingPointColumnReader<TData, TRequested>::readHelper(
           TFilter,
           ExtractValues,
           isDense,
-          std::is_same_v<TData, TRequested>>(
+          Reader::kHasBulkPath>(
           *static_cast<const TFilter*>(filter), this, rows, extractValues));
 }
 
diff --git a/velox/dwio/common/SelectiveIntegerColumnReader.h b/velox/dwio/common/SelectiveIntegerColumnReader.h
index 679d13dcf5c..d9ba805167a 100644
--- a/velox/dwio/common/SelectiveIntegerColumnReader.h
+++ b/velox/dwio/common/SelectiveIntegerColumnReader.h
@@ -200,6 +200,13 @@ void SelectiveIntegerColumnReader::processFilter(
               velox::common::NegatedBigintValuesUsingBitmask,
               isDense>(filter, rows, extractValues);
       break;
+    case velox::common::FilterKind::kBigintValuesUsingBloomFilter:
+      static_cast<Reader*>(this)
+          ->template readHelper<
+              Reader,
+              velox::common::BigintValuesUsingBloomFilter,
+              isDense>(filter, rows, extractValues);
+      break;
     default:
       static_cast<Reader*>(this)
           ->template readHelper<Reader, velox::common::Filter, isDense>(
diff --git a/velox/dwio/common/SelectiveRepeatedColumnReader.cpp b/velox/dwio/common/SelectiveRepeatedColumnReader.cpp
index 5342e4591e1..b17098d612f 100644
--- a/velox/dwio/common/SelectiveRepeatedColumnReader.cpp
+++ b/velox/dwio/common/SelectiveRepeatedColumnReader.cpp
@@ -80,7 +80,7 @@ void prepareResult(
 void SelectiveRepeatedColumnReader::ensureAllLengthsBuffer(vector_size_t size) {
   if (!allLengthsHolder_ ||
       allLengthsHolder_->capacity() < size * sizeof(vector_size_t)) {
-    allLengthsHolder_ = allocateIndices(size, memoryPool_);
+    allLengthsHolder_ = allocateIndices(size, pool_);
     allLengths_ = allLengthsHolder_->asMutable<vector_size_t>();
   }
 }
@@ -209,34 +209,69 @@ RowSet SelectiveRepeatedColumnReader::applyFilter(const RowSet& rows) {
   return outputRows_;
 }
 
+void SelectiveRepeatedColumnReader::getExtractionSizeValues(
+    const RowSet& rows,
+    VectorPtr* result) {
+  VELOX_DCHECK_NOT_NULL(result);
+  FlatVector<int64_t>* flatResult = nullptr;
+  if (*result && result->get()->type()->isBigint()) {
+    flatResult = result->get()->asFlatVector<int64_t>();
+  }
+  if (!flatResult || !flatResult->values()) {
+    *result = std::make_shared<FlatVector<int64_t>>(
+        pool_,
+        BIGINT(),
+        nullptr,
+        rows.size(),
+        AlignedBuffer::allocate<int64_t>(rows.size(), pool_),
+        std::vector<BufferPtr>{});
+    flatResult = result->get()->asFlatVector<int64_t>();
+  } else {
+    flatResult->resize(static_cast<vector_size_t>(rows.size()));
+  }
+  auto* sizesData = flatResult->mutableRawValues();
+  auto* nulls = nullsInReadRange_ ? nullsInReadRange_->as<uint64_t>() : nullptr;
+  for (vector_size_t i = 0; i < static_cast<vector_size_t>(rows.size()); ++i) {
+    sizesData[i] =
+        (nulls && bits::isBitNull(nulls, rows[i])) ? 0 : allLengths_[rows[i]];
+  }
+  setComplexNulls(rows, *result);
+}
+
 SelectiveListColumnReader::SelectiveListColumnReader(
     const TypePtr& requestedType,
     const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     FormatParams& params,
     velox::common::ScanSpec& scanSpec)
     : SelectiveRepeatedColumnReader(requestedType, params, scanSpec, fileType) {
+  VELOX_CHECK(
+      scanSpec.extractionType() ==
+              velox::common::ScanSpec::ExtractionType::kNone ||
+          scanSpec.extractionType() ==
+              velox::common::ScanSpec::ExtractionType::kSize,
+      "Array column reader only supports kNone and kSize extraction, got: {}",
+      static_cast<int>(scanSpec.extractionType()));
 }
 
 uint64_t SelectiveListColumnReader::skip(uint64_t numValues) {
   numValues = formatData_->skipNulls(numValues);
-  if (child_) {
-    std::array<int32_t, kBufferSize> buffer;
-    uint64_t childElements = 0;
-    uint64_t lengthsRead = 0;
-    while (lengthsRead < numValues) {
-      uint64_t chunk =
-          std::min(numValues - lengthsRead, static_cast<uint64_t>(kBufferSize));
-      readLengths(buffer.data(), chunk, nullptr);
-      for (size_t i = 0; i < chunk; ++i) {
-        childElements += static_cast<size_t>(buffer[i]);
-      }
-      lengthsRead += chunk;
+  std::array<int32_t, kBufferSize> buffer{};
+  uint64_t childElements = 0;
+  uint64_t lengthsRead = 0;
+  while (lengthsRead < numValues) {
+    uint64_t chunk =
+        std::min(numValues - lengthsRead, static_cast<uint64_t>(kBufferSize));
+    readLengths(buffer.data(), static_cast<int32_t>(chunk), nullptr);
+    for (size_t i = 0; i < chunk; ++i) {
+      childElements += static_cast<size_t>(buffer[i]);
     }
-    child_->seekTo(child_->readOffset() + childElements, false);
-    childTargetReadOffset_ += childElements;
-  } else {
-    VELOX_FAIL("Repeated reader with no children");
+    lengthsRead += chunk;
+  }
+  if (child_) {
+    child_->seekTo(
+        child_->readOffset() + static_cast<int64_t>(childElements), false);
   }
+  childTargetReadOffset_ += static_cast<int64_t>(childElements);
   return numValues;
 }
 
@@ -245,15 +280,27 @@ void SelectiveListColumnReader::read(
     const RowSet& rows,
     const uint64_t* incomingNulls) {
   // Catch up if the child is behind the length stream.
-  child_->seekTo(childTargetReadOffset_, false);
+  if (child_) {
+    child_->seekTo(childTargetReadOffset_, false);
+  }
   prepareRead<char>(offset, rows, incomingNulls);
   auto activeRows = applyFilter(rows);
   nestedRowsAllSelected_ = activeRows.size() == rows.back() + 1 &&
       scanSpec_->maxArrayElementsCount() ==
           std::numeric_limits<vector_size_t>::max();
   makeNestedRowSet(activeRows, rows.back());
-  if (child_ && !nestedRows_.empty()) {
-    child_->read(child_->readOffset(), nestedRows_, nullptr);
+  // When deltaUpdate is set, treat extractionType as kNone so all child
+  // streams are read.  The extraction transform is applied after the
+  // delta update.
+  if (scanSpec_->extractionType() ==
+          velox::common::ScanSpec::ExtractionType::kSize &&
+      !scanSpec_->deltaUpdate()) {
+    // Size extraction: only need offsets/sizes, skip child stream.
+    if (child_ && !nestedRows_.empty()) {
+      child_->seekTo(child_->readOffset() + nestedRows_.back() + 1, false);
+    }
+  } else if (child_ && !nestedRows_.empty()) {
+    child_->readWithTiming(child_->readOffset(), nestedRows_, nullptr);
     nestedRowsAllSelected_ = nestedRowsAllSelected_ &&
         nestedRows_.size() == child_->outputRows().size();
     nestedRows_ = child_->outputRows();
@@ -266,7 +313,18 @@ void SelectiveListColumnReader::getValues(
     const RowSet& rows,
     VectorPtr* result) {
   VELOX_DCHECK_NOT_NULL(result);
-  prepareResult(*result, requestedType_, rows.size(), memoryPool_);
+
+  // When deltaUpdate is set, treat extractionType as kNone so the reader
+  // produces the full array.  The extraction transform is applied after
+  // the delta update.
+  if (scanSpec_->extractionType() ==
+          velox::common::ScanSpec::ExtractionType::kSize &&
+      !scanSpec_->deltaUpdate()) {
+    getExtractionSizeValues(rows, result);
+    return;
+  }
+
+  prepareResult(*result, requestedType_, rows.size(), pool_);
   auto* resultArray = result->get()->asUnchecked<ArrayVector>();
   makeOffsetsAndSizes(rows, *resultArray);
   setComplexNulls(rows, *result);
@@ -277,48 +335,40 @@ void SelectiveListColumnReader::getValues(
   }
 }
 
-SelectiveMapColumnReader::SelectiveMapColumnReader(
-    const TypePtr& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
-    FormatParams& params,
-    velox::common::ScanSpec& scanSpec)
-    : SelectiveRepeatedColumnReader(requestedType, params, scanSpec, fileType) {
-}
-
-uint64_t SelectiveMapColumnReader::skip(uint64_t numValues) {
+uint64_t SelectiveMapColumnReaderBase::skip(uint64_t numValues) {
   numValues = formatData_->skipNulls(numValues);
-  if (keyReader_ || elementReader_) {
-    std::array<int32_t, kBufferSize> buffer;
-    uint64_t childElements{0};
-    uint64_t lengthsRead{0};
-    while (lengthsRead < numValues) {
-      const uint64_t chunk =
-          std::min(numValues - lengthsRead, static_cast<uint64_t>(kBufferSize));
-      readLengths(buffer.data(), chunk, nullptr);
-      for (size_t i = 0; i < chunk; ++i) {
-        childElements += buffer[i];
-      }
-      lengthsRead += chunk;
-    }
-
-    if (keyReader_) {
-      keyReader_->seekTo(keyReader_->readOffset() + childElements, false);
-    }
-    if (elementReader_) {
-      elementReader_->seekTo(
-          elementReader_->readOffset() + childElements, false);
+  std::array<int32_t, kBufferSize> buffer;
+  uint64_t childElements{0};
+  uint64_t lengthsRead{0};
+  while (lengthsRead < numValues) {
+    const uint64_t chunk =
+        std::min(numValues - lengthsRead, static_cast<uint64_t>(kBufferSize));
+    readLengths(buffer.data(), chunk, nullptr);
+    for (size_t i = 0; i < chunk; ++i) {
+      childElements += buffer[i];
     }
-    childTargetReadOffset_ += childElements;
-  } else {
-    VELOX_FAIL("repeated reader with no children");
+    lengthsRead += chunk;
+  }
+  if (keyReader_) {
+    keyReader_->seekTo(keyReader_->readOffset() + childElements, false);
   }
+  if (elementReader_) {
+    elementReader_->seekTo(elementReader_->readOffset() + childElements, false);
+  }
+  childTargetReadOffset_ += childElements;
   return numValues;
 }
 
-void SelectiveMapColumnReader::read(
+void SelectiveMapColumnReaderBase::read(
     int64_t offset,
     const RowSet& rows,
     const uint64_t* incomingNulls) {
+  // When deltaUpdate is set, treat extractionType as kNone so all streams
+  // are read.  The extraction transform is applied after the delta update.
+  const auto extractionType = scanSpec_->deltaUpdate()
+      ? velox::common::ScanSpec::ExtractionType::kNone
+      : scanSpec_->extractionType();
+
   // Catch up if child readers are behind the length stream.
   if (keyReader_) {
     keyReader_->seekTo(childTargetReadOffset_, false);
@@ -334,31 +384,167 @@ void SelectiveMapColumnReader::read(
       scanSpec_->maxArrayElementsCount(),
       std::numeric_limits<vector_size_t>::max());
   makeNestedRowSet(activeRows, rows.back());
-  if (keyReader_ && elementReader_ && !nestedRows_.empty()) {
-    keyReader_->read(keyReader_->readOffset(), nestedRows_, nullptr);
-    nestedRowsAllSelected_ = nestedRowsAllSelected_ &&
-        nestedRows_.size() == keyReader_->outputRows().size();
-    nestedRows_ = keyReader_->outputRows();
-    if (!nestedRows_.empty()) {
-      elementReader_->read(elementReader_->readOffset(), nestedRows_, nullptr);
+
+  if (extractionType == velox::common::ScanSpec::ExtractionType::kSize) {
+    // Size extraction: only need offsets/sizes, skip both key and value
+    // streams.  Advance children past the nested rows without reading.
+    if (keyReader_ && !nestedRows_.empty()) {
+      keyReader_->seekTo(
+          keyReader_->readOffset() + nestedRows_.back() + 1, false);
+    }
+    if (elementReader_ && !nestedRows_.empty()) {
+      elementReader_->seekTo(
+          elementReader_->readOffset() + nestedRows_.back() + 1, false);
+    }
+  } else if (extractionType == velox::common::ScanSpec::ExtractionType::kKeys) {
+    // Keys extraction: read only keys, skip values.
+    if (keyReader_ && !nestedRows_.empty()) {
+      keyReader_->readWithTiming(
+          keyReader_->readOffset(), nestedRows_, nullptr);
+      nestedRowsAllSelected_ = nestedRowsAllSelected_ &&
+          nestedRows_.size() == keyReader_->outputRows().size();
+      nestedRows_ = keyReader_->outputRows();
+    }
+    if (elementReader_ && !nestedRows_.empty()) {
+      elementReader_->seekTo(
+          elementReader_->readOffset() + nestedRows_.back() + 1, false);
+    }
+  } else if (
+      extractionType == velox::common::ScanSpec::ExtractionType::kValues) {
+    // Values extraction: read only values, skip keys.
+    if (keyReader_ && !nestedRows_.empty()) {
+      keyReader_->seekTo(
+          keyReader_->readOffset() + nestedRows_.back() + 1, false);
+    }
+    if (elementReader_ && !nestedRows_.empty()) {
+      elementReader_->readWithTiming(
+          elementReader_->readOffset(), nestedRows_, nullptr);
       nestedRowsAllSelected_ = nestedRowsAllSelected_ &&
           nestedRows_.size() == elementReader_->outputRows().size();
       nestedRows_ = elementReader_->outputRows();
     }
+  } else {
+    // Normal read: read both keys and values.
+    VELOX_CHECK_EQ(
+        static_cast<int>(extractionType),
+        static_cast<int>(velox::common::ScanSpec::ExtractionType::kNone));
+    if (keyReader_ && elementReader_ && !nestedRows_.empty()) {
+      keyReader_->readWithTiming(
+          keyReader_->readOffset(), nestedRows_, nullptr);
+      nestedRowsAllSelected_ = nestedRowsAllSelected_ &&
+          nestedRows_.size() == keyReader_->outputRows().size();
+      nestedRows_ = keyReader_->outputRows();
+      if (!nestedRows_.empty()) {
+        elementReader_->readWithTiming(
+            elementReader_->readOffset(), nestedRows_, nullptr);
+        nestedRowsAllSelected_ = nestedRowsAllSelected_ &&
+            nestedRows_.size() == elementReader_->outputRows().size();
+        nestedRows_ = elementReader_->outputRows();
+      }
+    }
   }
   numValues_ = activeRows.size();
   readOffset_ = offset + rows.back() + 1;
 }
 
+SelectiveMapColumnReader::SelectiveMapColumnReader(
+    const TypePtr& requestedType,
+    const TypeWithIdPtr& fileType,
+    FormatParams& params,
+    ScanSpec& scanSpec)
+    : SelectiveMapColumnReaderBase(requestedType, params, scanSpec, fileType) {
+  VELOX_CHECK(!scanSpec_->isFlatMapAsStruct());
+  // We should not need this anymore.  Is there a safe way to find out if there
+  // is any prod usages that forget to set up the map children in scan spec?
+  // This should be only possible when user bypasses the connector interface and
+  // create file readers directly.
+  if (scanSpec_->children().empty()) {
+    scanSpec_->getOrCreateChild(ScanSpec::kMapKeysFieldName);
+    scanSpec_->getOrCreateChild(ScanSpec::kMapValuesFieldName);
+  }
+  scanSpec_->children()[0]->setProjectOut(true);
+  scanSpec_->children()[1]->setProjectOut(true);
+}
+
+void SelectiveMapColumnReaderBase::getExtractionValues(
+    const RowSet& rows,
+    VectorPtr* result) {
+  VELOX_DCHECK_NOT_NULL(result);
+  const auto extractionType = scanSpec_->extractionType();
+  VELOX_DCHECK_NE(
+      static_cast<int>(extractionType),
+      static_cast<int>(velox::common::ScanSpec::ExtractionType::kNone));
+
+  // When deltaUpdate is set, treat extractionType as kNone so the reader
+  // produces the full map.  The extraction transform is applied after
+  // the delta update.
+  if (extractionType == velox::common::ScanSpec::ExtractionType::kSize &&
+      !scanSpec_->deltaUpdate()) {
+    getExtractionSizeValues(rows, result);
+    return;
+  }
+
+  // kKeys or kValues: compute offsets/sizes via a reusable MapVector,
+  // then read elements and construct the output ArrayVector.
+  prepareResult(
+      extractionOffsetsTemp_,
+      requestedType_,
+      static_cast<vector_size_t>(rows.size()),
+      pool_);
+  auto* tempMap = extractionOffsetsTemp_->asUnchecked<MapVector>();
+  makeOffsetsAndSizes(rows, *tempMap);
+  setComplexNulls(rows, extractionOffsetsTemp_);
+
+  // Extract elements from the existing result to reuse across batches.
+  VectorPtr elements;
+  if (*result && result->get()->encoding() == VectorEncoding::Simple::ARRAY) {
+    elements = result->get()->asUnchecked<ArrayVector>()->elements();
+  }
+  if (extractionType == velox::common::ScanSpec::ExtractionType::kKeys) {
+    if (!nestedRows_.empty()) {
+      keyReader_->getValues(nestedRows_, &elements);
+    }
+  } else {
+    if (!nestedRows_.empty()) {
+      prepareStructResult(requestedType_->childAt(1), &elements);
+      elementReader_->getValues(nestedRows_, &elements);
+    }
+  }
+  auto elemType = elements
+      ? elements->type()
+      : requestedType_->childAt(
+            extractionType == velox::common::ScanSpec::ExtractionType::kKeys
+                ? 0
+                : 1);
+  *result = std::make_shared<ArrayVector>(
+      pool_,
+      ARRAY(elemType),
+      tempMap->nulls(),
+      rows.size(),
+      tempMap->offsets(),
+      tempMap->sizes(),
+      elements);
+}
+
 void SelectiveMapColumnReader::getValues(
     const RowSet& rows,
     VectorPtr* result) {
   VELOX_DCHECK_NOT_NULL(result);
-  VELOX_CHECK(
-      !result->get() || result->get()->type()->isMap(),
-      "Expect MAP result vector, got {}",
-      result->get()->type()->toString());
-  prepareResult(*result, requestedType_, rows.size(), memoryPool_);
+  const auto extractionType = scanSpec_->extractionType();
+
+  // When deltaUpdate is set, treat extractionType as kNone so the reader
+  // produces the full map.  The extraction transform is applied after
+  // the delta update.
+  if (extractionType != velox::common::ScanSpec::ExtractionType::kNone &&
+      !scanSpec_->deltaUpdate()) {
+    getExtractionValues(rows, result);
+    return;
+  }
+
+  // Normal path: produce MapVector.  If the result has a non-MAP type
+  // (e.g., from a previous extraction transform), prepareResult will
+  // replace it with a fresh MapVector.
+  prepareResult(*result, requestedType_, rows.size(), pool_);
   auto* resultMap = result->get()->asUnchecked<MapVector>();
   makeOffsetsAndSizes(rows, *resultMap);
   setComplexNulls(rows, *result);
@@ -374,4 +560,114 @@ void SelectiveMapColumnReader::getValues(
   }
 }
 
+SelectiveMapAsStructColumnReader::SelectiveMapAsStructColumnReader(
+    const TypePtr& requestedType,
+    const TypeWithIdPtr& fileType,
+    FormatParams& params,
+    ScanSpec& scanSpec)
+    : SelectiveMapColumnReaderBase(requestedType, params, scanSpec, fileType) {
+  VELOX_CHECK(scanSpec_->isFlatMapAsStruct() && requestedType_->isMap());
+  VELOX_CHECK_EQ(
+      static_cast<int>(scanSpec.extractionType()),
+      static_cast<int>(velox::common::ScanSpec::ExtractionType::kNone),
+      "Flat map as struct reader does not support extraction pushdown");
+  mapScanSpec_.addMapKeyFieldRecursively(*requestedType_->childAt(0));
+  mapScanSpec_.addMapValueFieldRecursively(*requestedType_->childAt(1));
+  column_index_t maxChannel = 0;
+  for (auto& childSpec : scanSpec_->children()) {
+    auto field = folly::tryTo<int64_t>(childSpec->fieldName());
+    VELOX_CHECK(
+        field.hasValue(),
+        "Fail to parse field name: {}",
+        childSpec->fieldName());
+    keyToIndex_[*field] = childSpec->channel();
+    maxChannel = std::max(maxChannel, childSpec->channel());
+  }
+  copyRanges_.resize(maxChannel + 1);
+}
+
+void SelectiveMapAsStructColumnReader::getValues(
+    const RowSet& rows,
+    VectorPtr* result) {
+  VELOX_CHECK_NOT_NULL(*result);
+  VELOX_CHECK(
+      result->get()->type()->isRow(),
+      "Expect ROW, got {}",
+      result->get()->type()->toString());
+  BaseVector::prepareForReuse(*result, rows.size());
+  auto* resultRow = result->get()->asChecked<RowVector>();
+  setComplexNulls(rows, *result);
+  for (auto& child : resultRow->children()) {
+    bits::fillBits(child->mutableRawNulls(), 0, rows.size(), bits::kNull);
+  }
+  numValues_ = rows.size();
+  if (nestedRows_.empty()) {
+    return;
+  }
+  keyReader_->getValues(nestedRows_, &mapKeys_);
+  prepareStructResult(requestedType_->childAt(1), &mapValues_);
+  elementReader_->getValues(nestedRows_, &mapValues_);
+  decodedKeys_.decode(*mapKeys_);
+  for (auto& ranges : copyRanges_) {
+    ranges.clear();
+  }
+  switch (mapKeys_->type()->kind()) {
+    case TypeKind::TINYINT:
+      makeCopyRanges<int8_t>(rows);
+      break;
+    case TypeKind::SMALLINT:
+      makeCopyRanges<int16_t>(rows);
+      break;
+    case TypeKind::INTEGER:
+      makeCopyRanges<int32_t>(rows);
+      break;
+    case TypeKind::BIGINT:
+      makeCopyRanges<int64_t>(rows);
+      break;
+    default:
+      VELOX_UNSUPPORTED(
+          "Unsupported key type: {}", mapKeys_->type()->toString());
+  }
+  for (column_index_t i = 0; i < resultRow->childrenSize(); ++i) {
+    resultRow->childAt(i)->copyRanges(mapValues_.get(), copyRanges_[i]);
+  }
+}
+
+template <typename T>
+void SelectiveMapAsStructColumnReader::makeCopyRanges(const RowSet& rows) {
+  auto* nulls = nullsInReadRange_ ? nullsInReadRange_->as<uint64_t>() : nullptr;
+  for (vector_size_t i = 0,
+                     currentOffset = 0,
+                     currentRow = 0,
+                     nestedRowIndex = 0;
+       i < rows.size();
+       ++i) {
+    const auto row = rows[i];
+    if (nulls && bits::isBitNull(nulls, row)) {
+      anyNulls_ = true;
+      continue;
+    }
+    currentOffset += sumLengths(allLengths_, nulls, currentRow, row);
+    currentRow = row + 1;
+    nestedRowIndex =
+        advanceNestedRows(nestedRows_, nestedRowIndex, currentOffset);
+    currentOffset += allLengths_[row];
+    const auto newNestedRowIndex =
+        advanceNestedRows(nestedRows_, nestedRowIndex, currentOffset);
+    for (auto j = nestedRowIndex; j < newNestedRowIndex; ++j) {
+      VELOX_CHECK(!decodedKeys_.isNullAt(j));
+      auto it = keyToIndex_.find(decodedKeys_.valueAt<T>(j));
+      if (it == keyToIndex_.end()) {
+        continue;
+      }
+      copyRanges_[it->second].push_back({
+          .sourceIndex = j,
+          .targetIndex = i,
+          .count = 1,
+      });
+    }
+    nestedRowIndex = newNestedRowIndex;
+  }
+}
+
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/SelectiveRepeatedColumnReader.h b/velox/dwio/common/SelectiveRepeatedColumnReader.h
index f1792ff9511..985a240bb06 100644
--- a/velox/dwio/common/SelectiveRepeatedColumnReader.h
+++ b/velox/dwio/common/SelectiveRepeatedColumnReader.h
@@ -42,7 +42,7 @@ class SelectiveRepeatedColumnReader : public SelectiveColumnReader {
       velox::common::ScanSpec& scanSpec,
       std::shared_ptr<const dwio::common::TypeWithId> type)
       : SelectiveColumnReader(requestedType, std::move(type), params, scanSpec),
-        nestedRowsHolder_(memoryPool_) {}
+        nestedRowsHolder_(pool_) {}
 
   /// Reads 'numLengths' next lengths into 'result'. If 'nulls' is
   /// non-null, each kNull bit signifies a null with a length of 0 to
@@ -62,7 +62,7 @@ class SelectiveRepeatedColumnReader : public SelectiveColumnReader {
   /// Creates a struct if '*result' is empty and 'type' is a row.
   void prepareStructResult(const TypePtr& type, VectorPtr* result) {
     if (!*result && type->kind() == TypeKind::ROW) {
-      *result = BaseVector::create(type, 0, memoryPool_);
+      *result = BaseVector::create(type, 0, pool_);
     }
   }
 
@@ -85,6 +85,10 @@ class SelectiveRepeatedColumnReader : public SelectiveColumnReader {
     return i;
   }
 
+  /// Produce a FlatVector<int64_t> of sizes directly from allLengths_ for
+  /// kSize extraction.  Reuses the result vector across batches.
+  void getExtractionSizeValues(const RowSet& rows, VectorPtr* result);
+
   void ensureAllLengthsBuffer(vector_size_t size);
 
   BufferPtr allLengthsHolder_;
@@ -112,7 +116,9 @@ class SelectiveListColumnReader : public SelectiveRepeatedColumnReader {
       velox::common::ScanSpec& scanSpec);
 
   void resetFilterCaches() override {
-    child_->resetFilterCaches();
+    if (child_) {
+      child_->resetFilterCaches();
+    }
   }
 
   uint64_t skip(uint64_t numValues) override;
@@ -128,17 +134,17 @@ class SelectiveListColumnReader : public SelectiveRepeatedColumnReader {
   std::unique_ptr<SelectiveColumnReader> child_;
 };
 
-class SelectiveMapColumnReader : public SelectiveRepeatedColumnReader {
+class SelectiveMapColumnReaderBase : public SelectiveRepeatedColumnReader {
  public:
-  SelectiveMapColumnReader(
-      const TypePtr& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
-      FormatParams& params,
-      velox::common::ScanSpec& scanSpec);
+  using SelectiveRepeatedColumnReader::SelectiveRepeatedColumnReader;
 
   void resetFilterCaches() override {
-    keyReader_->resetFilterCaches();
-    elementReader_->resetFilterCaches();
+    if (keyReader_) {
+      keyReader_->resetFilterCaches();
+    }
+    if (elementReader_) {
+      elementReader_->resetFilterCaches();
+    }
   }
 
   uint64_t skip(uint64_t numValues) override;
@@ -146,11 +152,64 @@ class SelectiveMapColumnReader : public SelectiveRepeatedColumnReader {
   void read(int64_t offset, const RowSet& rows, const uint64_t* incomingNulls)
       override;
 
-  void getValues(const RowSet& rows, VectorPtr* result) override;
+  void seekToRowGroup(int64_t index) override {
+    SelectiveRepeatedColumnReader::seekToRowGroup(index);
+    if (keyReader_) {
+      keyReader_->seekToRowGroup(index);
+      keyReader_->setReadOffsetRecursive(0);
+    }
+    if (elementReader_) {
+      elementReader_->seekToRowGroup(index);
+      elementReader_->setReadOffsetRecursive(0);
+    }
+    childTargetReadOffset_ = 0;
+  }
 
  protected:
+  /// Handle extraction types (kSize, kKeys, kValues) in getValues.
+  void getExtractionValues(const RowSet& rows, VectorPtr* result);
+
   std::unique_ptr<SelectiveColumnReader> keyReader_;
   std::unique_ptr<SelectiveColumnReader> elementReader_;
+
+  // Reusable MapVector for computing offsets/sizes in kKeys/kValues extraction.
+  // Not needed for kSize (sizes computed directly from allLengths_).
+  VectorPtr extractionOffsetsTemp_;
+};
+
+class SelectiveMapColumnReader : public SelectiveMapColumnReaderBase {
+ public:
+  SelectiveMapColumnReader(
+      const TypePtr& requestedType,
+      const TypeWithIdPtr& fileType,
+      FormatParams& params,
+      ScanSpec& scanSpec);
+
+  void getValues(const RowSet& rows, VectorPtr* result) override;
+};
+
+class SelectiveMapAsStructColumnReader : public SelectiveMapColumnReaderBase {
+ public:
+  SelectiveMapAsStructColumnReader(
+      const TypePtr& requestedType,
+      const TypeWithIdPtr& fileType,
+      FormatParams& params,
+      ScanSpec& scanSpec);
+
+  void getValues(const RowSet& rows, VectorPtr* result) override;
+
+ protected:
+  ScanSpec mapScanSpec_{"<mapScanSpec>"};
+
+ private:
+  template <typename T>
+  void makeCopyRanges(const RowSet& rows);
+
+  folly::F14FastMap<int64_t, column_index_t> keyToIndex_;
+  std::vector<std::vector<BaseVector::CopyRange>> copyRanges_;
+  VectorPtr mapKeys_;
+  VectorPtr mapValues_;
+  DecodedVector decodedKeys_;
 };
 
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/SelectiveStructColumnReader.cpp b/velox/dwio/common/SelectiveStructColumnReader.cpp
index 7c0e9b208f9..e453fa03f07 100644
--- a/velox/dwio/common/SelectiveStructColumnReader.cpp
+++ b/velox/dwio/common/SelectiveStructColumnReader.cpp
@@ -407,7 +407,6 @@ void SelectiveStructColumnReaderBase::read(
   }
 
   const uint64_t* structNulls = nulls();
-
   // A struct reader may have a null/non-null filter
   if (scanSpec_->filter()) {
     const auto kind = scanSpec_->filter()->kind();
@@ -429,7 +428,6 @@ void SelectiveStructColumnReaderBase::read(
   VELOX_CHECK(!childSpecs.empty());
   for (size_t i = 0; i < childSpecs.size(); ++i) {
     const auto& childSpec = childSpecs[i];
-    VELOX_TRACE_HISTORY_PUSH("read %s", childSpec->fieldName().c_str());
 
     if (childSpec->deltaUpdate()) {
       // Will make LazyVector.
@@ -453,7 +451,7 @@ void SelectiveStructColumnReaderBase::read(
     auto* reader = children_.at(fieldIndex);
     if (reader->isTopLevel() && childSpec->projectOut() &&
         !childSpec->hasFilter() && generateLazyChildren_) {
-      // Will make a LazyVector.
+      // Will make a LazyVector (with or without transform).
       continue;
     }
 
@@ -463,7 +461,7 @@ void SelectiveStructColumnReaderBase::read(
         SelectivityTimer timer(childSpec->selectivity(), activeRows.size());
 
         reader->resetInitTimeClocks();
-        reader->read(offset, activeRows, structNulls);
+        reader->readWithTiming(offset, activeRows, structNulls);
 
         // Exclude initialization time.
         timer.subtract(reader->initTimeClocks());
@@ -475,7 +473,7 @@ void SelectiveStructColumnReaderBase::read(
         break;
       }
     } else {
-      reader->read(offset, activeRows, structNulls);
+      reader->readWithTiming(offset, activeRows, structNulls);
     }
   }
 
@@ -531,12 +529,59 @@ bool SelectiveStructColumnReaderBase::isChildMissing(
        childSpec.channel() >= fileType_->size());
 }
 
+std::unique_ptr<velox::dwio::common::ColumnLoader>
+SelectiveStructColumnReaderBase::makeColumnLoader(vector_size_t index) {
+  // Check if the child at this index has a transform with kNone extraction.
+  // If so, return a TransformColumnLoader to apply the transform lazily.
+  for (const auto& childSpec : scanSpec_->children()) {
+    if (childSpec->subscript() == index && childSpec->hasTransform() &&
+        childSpec->extractionType() ==
+            velox::common::ScanSpec::ExtractionType::kNone) {
+      return std::make_unique<velox::dwio::common::TransformColumnLoader>(
+          this, children_[index], numReads_, childSpec->transform());
+    }
+  }
+  return std::make_unique<velox::dwio::common::ColumnLoader>(
+      this, children_[index], numReads_);
+}
+
 void SelectiveStructColumnReaderBase::getValues(
     const RowSet& rows,
     VectorPtr* result) {
   VELOX_CHECK(!scanSpec_->children().empty());
   VELOX_CHECK_NOT_NULL(
       *result, "SelectiveStructColumnReaderBase expects a non-null result");
+
+  // When deltaUpdate is set, skip kField extraction so the reader produces
+  // the full struct.  The extraction transform is applied after the delta
+  // update.
+  if (!isRoot_ &&
+      scanSpec_->extractionType() ==
+          velox::common::ScanSpec::ExtractionType::kField &&
+      !scanSpec_->deltaUpdate()) {
+    auto fieldIdx = scanSpec_->extractionFieldIndex();
+    for (const auto& childSpec : scanSpec_->children()) {
+      if (childSpec->channel() == fieldIdx && !childSpec->isConstant()) {
+        auto index = static_cast<vector_size_t>(childSpec->subscript());
+        if (childSpec->hasFilter() || !children_[index]->isTopLevel() ||
+            !generateLazyChildren_) {
+          children_[index]->getValues(rows, result);
+        } else {
+          // Lazy loading: create a LazyVector for the extracted field.
+          setOutputRowsForLazy(rows);
+          setLazyField(
+              makeColumnLoader(index),
+              children_[index]->requestedType(),
+              static_cast<vector_size_t>(rows.size()),
+              pool_,
+              *result);
+        }
+        return;
+      }
+    }
+    VELOX_UNREACHABLE();
+  }
+
   VELOX_CHECK(
       result->get()->type()->isRow(),
       "Struct reader expects a result of type ROW.");
@@ -550,7 +595,6 @@ void SelectiveStructColumnReaderBase::getValues(
 
   setComplexNulls(rows, *result);
   for (const auto& childSpec : scanSpec_->children()) {
-    VELOX_TRACE_HISTORY_PUSH("getValues %s", childSpec->fieldName().c_str());
     if (!childSpec->keepValues()) {
       continue;
     }
@@ -574,9 +618,18 @@ void SelectiveStructColumnReaderBase::getValues(
                 this, children_[index], numReads_),
             resultRow->type()->childAt(channel),
             rows.size(),
-            memoryPool_,
+            pool_,
             childResult);
       }
+      // If the column also has an extraction transform (e.g., MapKeys on a
+      // MAP_CONCAT delta-updated column), apply it after the delta update.
+      // The delta update modifies the column (e.g., MAP_CONCAT adds entries),
+      // and extraction should see the updated data.
+      if (childSpec->hasTransform() && childResult) {
+        // Force-load lazy vectors so the transform can process them.
+        childResult = BaseVector::loadedVectorShared(childResult);
+        childResult = childSpec->transform()(childResult, pool_);
+      }
       continue;
     }
 
@@ -615,13 +668,16 @@ void SelectiveStructColumnReaderBase::getValues(
 
     // LazyVector result.
     setOutputRowsForLazy(rows);
+    // When the child has a transform (e.g., extraction pushdown), the lazy
+    // vector type is the transform's output type, not the file column type.
+    auto lazyType =
+        (childSpec->hasTransform() && childSpec->transformOutputType())
+        ? childSpec->transformOutputType()
+        : resultRow->type()->childAt(channel);
     setLazyField(
-        std::make_unique<ColumnLoader>(this, children_[index], numReads_),
-        resultRow->type()->childAt(channel),
-        rows.size(),
-        memoryPool_,
-        childResult);
+        makeColumnLoader(index), lazyType, rows.size(), pool_, childResult);
   }
+
   resultRow->updateContainsLazyNotLoaded();
 }
 
diff --git a/velox/dwio/common/SelectiveStructColumnReader.h b/velox/dwio/common/SelectiveStructColumnReader.h
index e867caa80ee..9d106a40284 100644
--- a/velox/dwio/common/SelectiveStructColumnReader.h
+++ b/velox/dwio/common/SelectiveStructColumnReader.h
@@ -20,6 +20,8 @@
 
 namespace facebook::velox::dwio::common {
 
+class ColumnLoader;
+
 template <typename T, typename KeyNode, typename FormatData>
 class SelectiveFlatMapColumnReaderHelper;
 
@@ -108,7 +110,7 @@ class SelectiveStructColumnReaderBase : public SelectiveColumnReader {
 
   // The subscript of childSpecs will be set to this value if the column is
   // constant (either explicitly or because it's missing).
-  static constexpr int32_t kConstantChildSpecSubscript = -1;
+  static constexpr int32_t kConstantChildSpecSubscript{-1};
 
   SelectiveStructColumnReaderBase(
       const TypePtr& requestedType,
@@ -122,7 +124,7 @@ class SelectiveStructColumnReaderBase : public SelectiveColumnReader {
             getExceptionContext().message(VeloxException::Type::kSystem)),
         isRoot_(isRoot),
         generateLazyChildren_(generateLazyChildren),
-        rows_(memoryPool_) {}
+        rows_(pool_) {}
 
   bool hasDeletion() const final {
     return hasDeletion_;
@@ -161,6 +163,12 @@ class SelectiveStructColumnReaderBase : public SelectiveColumnReader {
       const int64_t offset,
       const int32_t rowsPerRowGroup);
 
+  virtual std::unique_ptr<velox::dwio::common::ColumnLoader> makeColumnLoader(
+      vector_size_t index);
+
+  // Sequence number of output batch. Checked against ColumnLoaders
+  // created by 'this' to verify they are still valid at load.
+  uint64_t numReads_ = 0;
   std::vector<SelectiveColumnReader*> children_;
 
  private:
@@ -189,13 +197,9 @@ class SelectiveStructColumnReaderBase : public SelectiveColumnReader {
   // Dense set of rows to read in next().
   raw_vector<vector_size_t> rows_;
 
-  // Sequence number of output batch. Checked against ColumnLoaders
-  // created by 'this' to verify they are still valid at load.
-  uint64_t numReads_ = 0;
-
   int64_t lazyVectorReadOffset_;
 
-  int64_t currentRowNumber_ = -1;
+  int64_t currentRowNumber_{-1};
 
   const Mutation* mutation_ = nullptr;
 
@@ -245,7 +249,7 @@ class SelectiveFlatMapColumnReaderHelper {
       reader_.children_[i]->setIsFlatMapValue(true);
     }
     if (auto type = reader_.requestedType_->childAt(1); type->isRow()) {
-      childValues_ = BaseVector::create(type, 0, reader_.memoryPool_);
+      childValues_ = BaseVector::create(type, 0, reader_.pool_);
     }
   }
 
@@ -261,8 +265,7 @@ class SelectiveFlatMapColumnReaderHelper {
       result->resize(size);
     } else {
       VLOG(1) << "Reallocating result MAP vector of size " << size;
-      result =
-          BaseVector::create(reader_.requestedType_, size, reader_.memoryPool_);
+      result = BaseVector::create(reader_.requestedType_, size, reader_.pool_);
     }
     return *result->asUnchecked<MapVector>();
   }
@@ -335,7 +338,7 @@ void SelectiveFlatMapColumnReaderHelper<T, KeyNode, FormatData>::read(
     reader_.advanceFieldReader(child, offset);
   }
   for (auto* child : reader_.children_) {
-    child->read(offset, activeRows, mapNulls);
+    child->readWithTiming(offset, activeRows, mapNulls);
     child->addParentNulls(offset, mapNulls, rows);
   }
   reader_.lazyVectorReadOffset_ = offset;
@@ -498,7 +501,7 @@ void SelectiveFlatMapColumnReaderHelper<T, KeyNode, FormatData>::copyValues(
       }
     }
     if (strKeySize > 0) {
-      auto buf = AlignedBuffer::allocate<char>(strKeySize, reader_.memoryPool_);
+      auto buf = AlignedBuffer::allocate<char>(strKeySize, reader_.pool_);
       rawStrKeyBuffer = buf->template asMutable<char>();
       flatKeys->addStringBuffer(buf);
       strKeySize = 0;
diff --git a/velox/dwio/common/SortingWriter.cpp b/velox/dwio/common/SortingWriter.cpp
index d67efd6ec22..9e973106739 100644
--- a/velox/dwio/common/SortingWriter.cpp
+++ b/velox/dwio/common/SortingWriter.cpp
@@ -86,11 +86,11 @@ bool SortingWriter::finish() {
   return true;
 }
 
-void SortingWriter::close() {
+std::unique_ptr<FileMetadata> SortingWriter::close() {
   VELOX_CHECK(isFinishing());
   setState(State::kClosed);
   VELOX_CHECK_NULL(sortBuffer_);
-  outputWriter_->close();
+  return outputWriter_->close();
 }
 
 void SortingWriter::abort() {
@@ -114,10 +114,14 @@ uint64_t SortingWriter::reclaim(
 
   if (!isRunning() && !isFinishing()) {
     LOG(WARNING) << "Can't reclaim from a not running hive sort writer pool: "
-                 << sortPool_->name() << ", state: " << state()
-                 << "used memory: " << succinctBytes(sortPool_->usedBytes())
-                 << ", reserved memory: "
-                 << succinctBytes(sortPool_->reservedBytes());
+                 << sortPool_->name()
+                 << ", root pool: " << sortPool_->root()->name()
+                 << ", state: " << state()
+                 << ", used: " << succinctBytes(sortPool_->usedBytes())
+                 << ", reservation: "
+                 << succinctBytes(sortPool_->reservedBytes())
+                 << ", root pool reservation: "
+                 << succinctBytes(sortPool_->root()->reservedBytes());
     ++stats.numNonReclaimableAttempts;
     return 0;
   }
diff --git a/velox/dwio/common/SortingWriter.h b/velox/dwio/common/SortingWriter.h
index a136cff1238..c7a191a30a5 100644
--- a/velox/dwio/common/SortingWriter.h
+++ b/velox/dwio/common/SortingWriter.h
@@ -42,7 +42,9 @@ class SortingWriter : public Writer {
   /// be flushed.
   void flush() override;
 
-  void close() override;
+  /// Closes the writer. Returns file metadata, or null if no metadata is
+  /// available (e.g. for an empty file).
+  std::unique_ptr<FileMetadata> close() override;
 
   void abort() override;
 
diff --git a/velox/dwio/common/Statistics.h b/velox/dwio/common/Statistics.h
index 1c6965d6d71..ff56ea640e1 100644
--- a/velox/dwio/common/Statistics.h
+++ b/velox/dwio/common/Statistics.h
@@ -16,12 +16,21 @@
 
 #pragma once
 
+#include <fmt/format.h>
 #include <folly/Hash.h>
+#include <folly/Synchronized.h>
 #include <folly/container/F14Map.h>
+#include <type_traits>
+#include <utility>
+#include "velox/common/time/CpuWallTimer.h"
+#include "velox/dwio/common/Options.h"
+#include "velox/dwio/common/TypeWithId.h"
+#include "velox/dwio/common/UnitLoader.h"
 
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/RuntimeMetrics.h"
-#include "velox/dwio/common/exception/Exception.h"
+#include "velox/common/io/IoStatistics.h"
+#include "velox/type/Type.h"
 
 namespace facebook::velox::dwio::common {
 
@@ -135,6 +144,12 @@ class ColumnStatistics {
     numDistinct_ = count;
   }
 
+  /// Returns true if there are no non-null values (value count is known to be
+  /// zero).
+  bool isAllNull() const {
+    return valueCount_.has_value() && valueCount_.value() == 0;
+  }
+
   /**
    * return string representation of this stats object
    */
@@ -493,10 +508,11 @@ class MapColumnStatistics : public virtual ColumnStatistics {
     values.reserve(entryStatistics_.size());
     for (const auto& entry : entryStatistics_) {
       auto& stats = *entry.second;
-      values.push_back(fmt::format(
-          "{{ Key: {}, Stats: {},}}",
-          entry.first.toString(),
-          stats.toString()));
+      values.push_back(
+          fmt::format(
+              "{{ Key: {}, Stats: {},}}",
+              entry.first.toString(),
+              stats.toString()));
     }
     std::string repr;
     folly::join(",", values, repr);
@@ -532,10 +548,192 @@ class Statistics {
   virtual uint32_t getNumberOfColumns() const = 0;
 };
 
+/// Runs 'func' and records decompression stats if 'counter' is non-null.
+template <typename F>
+auto withDecompressStats(io::IoCounter* counter, F&& func)
+    -> std::enable_if_t<!std::is_void_v<decltype(func())>, decltype(func())> {
+  if (counter) {
+    DeltaCpuWallTimer timer([counter](const CpuWallTiming& timing) {
+      counter->increment(timing.cpuNanos);
+    });
+    return func();
+  }
+  return func();
+}
+
+template <typename F>
+auto withDecompressStats(io::IoCounter* counter, F&& func)
+    -> std::enable_if_t<std::is_void_v<decltype(func())>> {
+  if (counter) {
+    DeltaCpuWallTimer timer([counter](const CpuWallTiming& timing) {
+      counter->increment(timing.cpuNanos);
+    });
+    func();
+    return;
+  }
+  func();
+}
+
+/// Per-column statistics counters. Wraps multiple IoCounter instances for
+/// different types of measurements (decompression, encoding, etc.).
+/// Can be used by any file format reader (DWRF, Nimble, Parquet, etc.).
+struct ColumnMetrics {
+  explicit ColumnMetrics(TypeKind type = TypeKind::INVALID) : typeKind(type) {}
+
+  TypeKind typeKind;
+  io::IoCounter decompressCPUTimeNanos;
+  io::IoCounter decodeCPUTimeNanos;
+
+  /// Merges stats from another ColumnMetrics instance.
+  void merge(const ColumnMetrics& other) {
+    decompressCPUTimeNanos.merge(other.decompressCPUTimeNanos);
+    decodeCPUTimeNanos.merge(other.decodeCPUTimeNanos);
+  }
+};
+
+/// Thread-safe collection of per-column metrics keyed by nodeId.
+/// Can be used by any file format reader (DWRF, Nimble, Parquet, etc.).
+struct ColumnMetricsSet {
+  /// Gets or creates a ColumnMetrics for a column. Sets typeKind when creating.
+  ColumnMetrics* getOrCreate(
+      uint32_t nodeId,
+      TypeKind typeKind = TypeKind::INVALID) {
+    auto locked = map_.wlock();
+    auto it = locked->find(nodeId);
+    if (it == locked->end()) {
+      it = locked->emplace(nodeId, std::make_unique<ColumnMetrics>(typeKind))
+               .first;
+    }
+    return it->second.get();
+  }
+
+  /// Merges all column metrics from another ColumnMetricsSet instance.
+  void mergeFrom(const ColumnMetricsSet& other) {
+    auto srcLocked = other.map_.rlock();
+    auto dstLocked = map_.wlock();
+    for (const auto& [nodeId, srcStats] : *srcLocked) {
+      auto it = dstLocked->find(nodeId);
+      if (it == dstLocked->end()) {
+        it =
+            dstLocked->emplace(nodeId, std::make_unique<ColumnMetrics>()).first;
+        it->second->typeKind = srcStats->typeKind;
+      }
+      it->second->merge(*srcStats);
+    }
+  }
+
+  /// Exports per-column metrics into the runtime metrics result map.
+  void toRuntimeMetrics(
+      std::unordered_map<std::string, RuntimeMetric>& result) const {
+    auto statsLocked = map_.rlock();
+    for (const auto& [nodeId, stats] : *statsLocked) {
+      // Export decompression timing.
+      const auto& decompressCounter = stats->decompressCPUTimeNanos;
+      if (decompressCounter.count() > 0) {
+        result.emplace(
+            fmt::format(
+                "column_{}.{}.decompressCPUTimeNanos",
+                nodeId,
+                TypeKindName::toName(stats->typeKind)),
+            RuntimeMetric{
+                saturateCast(decompressCounter.sum()),
+                decompressCounter.count(),
+                saturateCast(decompressCounter.min()),
+                saturateCast(decompressCounter.max()),
+                RuntimeCounter::Unit::kNanos});
+      }
+      // Export decode timing.
+      const auto& decodeCounter = stats->decodeCPUTimeNanos;
+      if (decodeCounter.count() > 0) {
+        result.emplace(
+            fmt::format(
+                "column_{}.{}.decodeCPUTimeNanos",
+                nodeId,
+                TypeKindName::toName(stats->typeKind)),
+            RuntimeMetric{
+                saturateCast(decodeCounter.sum()),
+                decodeCounter.count(),
+                saturateCast(decodeCounter.min()),
+                saturateCast(decodeCounter.max()),
+                RuntimeCounter::Unit::kNanos});
+      }
+    }
+  }
+
+ private:
+  folly::Synchronized<
+      folly::F14FastMap<uint32_t, std::unique_ptr<ColumnMetrics>>>
+      map_;
+};
+
 struct ColumnReaderStatistics {
   // Number of rows returned by string dictionary reader that is flattened
   // instead of keeping dictionary encoding.
   int64_t flattenStringDictionaryValues{0};
+
+  // Total time spent in loading pages, in nanoseconds.
+  io::IoCounter pageLoadTimeNs;
+
+  // Per-column decompression metrics. Only populated when column stats
+  // collection is enabled.
+  std::optional<ColumnMetricsSet> columnMetricsSet;
+
+  /// Initializes column stats collection for the given schema if enabled in
+  /// options. Recursively registers metrics for all columns in the type tree.
+  void initColumnStatsCollection(
+      const TypeWithId& schema,
+      const RowReaderOptions& options) {
+    if (!options.collectColumnCpuMetrics()) {
+      return;
+    }
+    columnMetricsSet.emplace();
+    registerColumnMetricsImpl(schema);
+  }
+
+  /// Merges all stats from another ColumnReaderStatistics instance.
+  void mergeFrom(const ColumnReaderStatistics& other) {
+    flattenStringDictionaryValues += other.flattenStringDictionaryValues;
+    pageLoadTimeNs.merge(other.pageLoadTimeNs);
+    if (other.columnMetricsSet) {
+      if (!columnMetricsSet) {
+        columnMetricsSet.emplace();
+      }
+      columnMetricsSet->mergeFrom(*other.columnMetricsSet);
+    }
+  }
+
+  /// Exports all metrics into the runtime metrics result map.
+  void toRuntimeMetrics(
+      std::unordered_map<std::string, RuntimeMetric>& result) const {
+    if (flattenStringDictionaryValues > 0) {
+      result.emplace(
+          "flattenStringDictionaryValues",
+          RuntimeMetric(flattenStringDictionaryValues));
+    }
+    if (pageLoadTimeNs.sum() > 0) {
+      result.emplace(
+          "pageLoadTimeNs",
+          RuntimeMetric(
+              pageLoadTimeNs.sum(),
+              pageLoadTimeNs.count(),
+              pageLoadTimeNs.min(),
+              pageLoadTimeNs.max(),
+              RuntimeCounter::Unit::kNanos));
+    }
+    if (columnMetricsSet) {
+      columnMetricsSet->toRuntimeMetrics(result);
+    }
+  }
+
+ private:
+  void registerColumnMetricsImpl(const TypeWithId& node) {
+    columnMetricsSet->getOrCreate(node.id(), node.type()->kind());
+    for (uint32_t i = 0; i < node.size(); ++i) {
+      if (const auto* child = node.childAt(i).get()) {
+        registerColumnMetricsImpl(*child);
+      }
+    }
+  }
 };
 
 struct RuntimeStatistics {
@@ -558,40 +756,40 @@ struct RuntimeStatistics {
 
   int64_t numStripes{0};
 
-  ColumnReaderStatistics columnReaderStatistics;
+  UnitLoaderStats unitLoaderStats;
+  ColumnReaderStatistics columnReaderStats;
 
-  std::unordered_map<std::string, RuntimeCounter> toMap() {
-    std::unordered_map<std::string, RuntimeCounter> result;
+  std::unordered_map<std::string, RuntimeMetric> toRuntimeMetricMap() {
+    std::unordered_map<std::string, RuntimeMetric> result;
+    for (const auto& [name, metric] : unitLoaderStats.stats()) {
+      result.emplace(name, RuntimeMetric(metric.sum, metric.unit));
+    }
     if (skippedSplits > 0) {
-      result.emplace("skippedSplits", RuntimeCounter(skippedSplits));
+      result.emplace("skippedSplits", RuntimeMetric(skippedSplits));
     }
     if (processedSplits > 0) {
-      result.emplace("processedSplits", RuntimeCounter(processedSplits));
+      result.emplace("processedSplits", RuntimeMetric(processedSplits));
     }
     if (skippedSplitBytes > 0) {
       result.emplace(
           "skippedSplitBytes",
-          RuntimeCounter(skippedSplitBytes, RuntimeCounter::Unit::kBytes));
+          RuntimeMetric(skippedSplitBytes, RuntimeCounter::Unit::kBytes));
     }
     if (skippedStrides > 0) {
-      result.emplace("skippedStrides", RuntimeCounter(skippedStrides));
+      result.emplace("skippedStrides", RuntimeMetric(skippedStrides));
     }
     if (processedStrides > 0) {
-      result.emplace("processedStrides", RuntimeCounter(processedStrides));
+      result.emplace("processedStrides", RuntimeMetric(processedStrides));
     }
     if (footerBufferOverread > 0) {
       result.emplace(
           "footerBufferOverread",
-          RuntimeCounter(footerBufferOverread, RuntimeCounter::Unit::kBytes));
+          RuntimeMetric(footerBufferOverread, RuntimeCounter::Unit::kBytes));
     }
     if (numStripes > 0) {
-      result.emplace("numStripes", RuntimeCounter(numStripes));
-    }
-    if (columnReaderStatistics.flattenStringDictionaryValues > 0) {
-      result.emplace(
-          "flattenStringDictionaryValues",
-          RuntimeCounter(columnReaderStatistics.flattenStringDictionaryValues));
+      result.emplace("numStripes", RuntimeMetric(numStripes));
     }
+    columnReaderStats.toRuntimeMetrics(result);
     return result;
   }
 };
diff --git a/velox/dwio/common/StatisticsBuilder.cpp b/velox/dwio/common/StatisticsBuilder.cpp
new file mode 100644
index 00000000000..9d0b41cc6d5
--- /dev/null
+++ b/velox/dwio/common/StatisticsBuilder.cpp
@@ -0,0 +1,450 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/common/StatisticsBuilder.h"
+
+namespace facebook::velox::dwio::stats {
+
+// Import column statistics types from dwio::common.
+using common::BinaryColumnStatistics;
+using common::BooleanColumnStatistics;
+using common::ColumnStatistics;
+using common::DoubleColumnStatistics;
+using common::IntegerColumnStatistics;
+using common::StringColumnStatistics;
+
+namespace {
+
+template <typename T>
+void addWithOverflowCheck(std::optional<T>& to, T value, uint64_t count) {
+  if (to.has_value()) {
+    T result;
+    auto overflow = __builtin_mul_overflow(value, count, &result);
+    if (!overflow) {
+      overflow = __builtin_add_overflow(to.value(), result, &to.value());
+    }
+    if (overflow) {
+      to.reset();
+    }
+  }
+}
+
+template <typename T>
+void mergeWithOverflowCheck(
+    std::optional<T>& to,
+    const std::optional<T>& from) {
+  if (to.has_value()) {
+    if (from.has_value()) {
+      auto overflow =
+          __builtin_add_overflow(to.value(), from.value(), &to.value());
+      if (overflow) {
+        to.reset();
+      }
+    } else {
+      to.reset();
+    }
+  }
+}
+
+template <typename T>
+void mergeCount(std::optional<T>& to, const std::optional<T>& from) {
+  if (to.has_value()) {
+    if (from.has_value()) {
+      to.value() += from.value();
+    } else {
+      to.reset();
+    }
+  }
+}
+
+template <typename T>
+void mergeMin(std::optional<T>& to, const std::optional<T>& from) {
+  if (to.has_value()) {
+    if (!from.has_value()) {
+      to.reset();
+    } else if (from.value() < to.value()) {
+      to = from;
+    }
+  }
+}
+
+template <typename T>
+void mergeMax(std::optional<T>& to, const std::optional<T>& from) {
+  if (to.has_value()) {
+    if (!from.has_value()) {
+      to.reset();
+    } else if (from.value() > to.value()) {
+      to = from;
+    }
+  }
+}
+
+bool isValidLength(const std::optional<uint64_t>& length) {
+  return length.has_value() &&
+      length.value() <= std::numeric_limits<int64_t>::max();
+}
+
+bool shouldKeepString(
+    const std::optional<std::string>& val,
+    uint32_t lengthLimit) {
+  return val.has_value() && val.value().size() <= lengthLimit;
+}
+
+} // namespace
+
+std::unique_ptr<ColumnStatistics> StatisticsBuilder::build() const {
+  auto result = std::make_unique<ColumnStatistics>(
+      valueCount_, hasNull_, rawSize_, size_, estimateNumDistinct());
+
+  // For the base builder, there are no typed stats to add.
+  return result;
+}
+
+void StatisticsBuilder::incrementSize(uint64_t size) {
+  if (LIKELY(size_.has_value())) {
+    addWithOverflowCheck(size_, size, /*count=*/1);
+  }
+}
+
+void StatisticsBuilder::merge(const ColumnStatistics& other, bool ignoreSize) {
+  mergeCount(valueCount_, other.getNumberOfValues());
+
+  if (!hasNull_.has_value() || !hasNull_.value()) {
+    auto otherHasNull = other.hasNull();
+    if (otherHasNull.has_value()) {
+      if (otherHasNull.value()) {
+        hasNull_ = true;
+      }
+    } else if (hasNull_.has_value()) {
+      hasNull_.reset();
+    }
+  }
+  mergeCount(rawSize_, other.getRawSize());
+  if (!ignoreSize) {
+    mergeCount(size_, other.getSize());
+  }
+  if (hll_) {
+    auto* otherBuilder = dynamic_cast<const StatisticsBuilder*>(&other);
+    VELOX_CHECK_NOT_NULL(otherBuilder);
+    VELOX_CHECK_NOT_NULL(otherBuilder->hll_);
+    hll_->mergeWith(*otherBuilder->hll_);
+  }
+}
+
+std::unique_ptr<StatisticsBuilder> StatisticsBuilder::create(
+    const Type& type,
+    const StatisticsBuilderOptions& options) {
+  switch (type.kind()) {
+    case TypeKind::BOOLEAN:
+      return std::make_unique<BooleanStatisticsBuilder>(options);
+    case TypeKind::TINYINT:
+    case TypeKind::SMALLINT:
+    case TypeKind::INTEGER:
+    case TypeKind::BIGINT:
+      return std::make_unique<IntegerStatisticsBuilder>(options);
+    case TypeKind::REAL:
+    case TypeKind::DOUBLE:
+      return std::make_unique<DoubleStatisticsBuilder>(options);
+    case TypeKind::VARCHAR:
+      return std::make_unique<StringStatisticsBuilder>(options);
+    case TypeKind::VARBINARY:
+      return std::make_unique<BinaryStatisticsBuilder>(options);
+    default:
+      return std::make_unique<StatisticsBuilder>(options);
+  }
+}
+
+void StatisticsBuilder::createTree(
+    std::vector<std::unique_ptr<StatisticsBuilder>>& statBuilders,
+    const Type& type,
+    const StatisticsBuilderOptions& options) {
+  auto kind = type.kind();
+  switch (kind) {
+    case TypeKind::BOOLEAN:
+    case TypeKind::TINYINT:
+    case TypeKind::SMALLINT:
+    case TypeKind::INTEGER:
+    case TypeKind::BIGINT:
+    case TypeKind::REAL:
+    case TypeKind::DOUBLE:
+    case TypeKind::VARCHAR:
+    case TypeKind::VARBINARY:
+    case TypeKind::TIMESTAMP:
+      statBuilders.push_back(StatisticsBuilder::create(type, options));
+      break;
+
+    case TypeKind::ARRAY: {
+      statBuilders.push_back(StatisticsBuilder::create(type, options));
+      const auto& arrayType = dynamic_cast<const ArrayType&>(type);
+      createTree(statBuilders, *arrayType.elementType(), options);
+      break;
+    }
+
+    case TypeKind::MAP: {
+      statBuilders.push_back(StatisticsBuilder::create(type, options));
+      const auto& mapType = dynamic_cast<const MapType&>(type);
+      createTree(statBuilders, *mapType.keyType(), options);
+      createTree(statBuilders, *mapType.valueType(), options);
+      break;
+    }
+
+    case TypeKind::ROW: {
+      statBuilders.push_back(StatisticsBuilder::create(type, options));
+      const auto& rowType = dynamic_cast<const RowType&>(type);
+      for (const auto& childType : rowType.children()) {
+        createTree(statBuilders, *childType, options);
+      }
+      break;
+    }
+    default:
+      VELOX_FAIL("Not supported type: {}", kind);
+      break;
+  }
+}
+
+void BooleanStatisticsBuilder::addValues(bool value, uint64_t count) {
+  increaseValueCount(count);
+  if (trueCount_.has_value() && value) {
+    trueCount_.value() += count;
+  }
+}
+
+void BooleanStatisticsBuilder::merge(
+    const ColumnStatistics& other,
+    bool ignoreSize) {
+  StatisticsBuilder::merge(other, ignoreSize);
+  auto stats = dynamic_cast<const BooleanColumnStatistics*>(&other);
+  if (!stats) {
+    if (!other.isAllNull() && trueCount_.has_value()) {
+      trueCount_.reset();
+    }
+    return;
+  }
+  mergeCount(trueCount_, stats->getTrueCount());
+}
+
+std::unique_ptr<ColumnStatistics> BooleanStatisticsBuilder::build() const {
+  auto trueCount = isAllNull() ? std::nullopt : trueCount_;
+  auto result = std::make_unique<BooleanColumnStatistics>(
+      static_cast<const ColumnStatistics&>(*this), trueCount);
+  if (auto numDistinct = estimateNumDistinct()) {
+    result->setNumDistinct(*numDistinct);
+  }
+  return result;
+}
+
+void IntegerStatisticsBuilder::addValues(int64_t value, uint64_t count) {
+  increaseValueCount(count);
+  if (min_.has_value() && value < min_.value()) {
+    min_ = value;
+  }
+  if (max_.has_value() && value > max_.value()) {
+    max_ = value;
+  }
+  addWithOverflowCheck(sum_, value, count);
+  addHash(value);
+}
+
+void IntegerStatisticsBuilder::merge(
+    const ColumnStatistics& other,
+    bool ignoreSize) {
+  StatisticsBuilder::merge(other, ignoreSize);
+  auto stats = dynamic_cast<const IntegerColumnStatistics*>(&other);
+  if (!stats) {
+    if (!other.isAllNull()) {
+      min_.reset();
+      max_.reset();
+      sum_.reset();
+    }
+    return;
+  }
+  mergeMin(min_, stats->getMinimum());
+  mergeMax(max_, stats->getMaximum());
+  mergeWithOverflowCheck(sum_, stats->getSum());
+}
+
+std::unique_ptr<ColumnStatistics> IntegerStatisticsBuilder::build() const {
+  auto min = isAllNull() ? std::nullopt : min_;
+  auto max = isAllNull() ? std::nullopt : max_;
+  auto sum = isAllNull() ? std::nullopt : sum_;
+  auto result = std::make_unique<IntegerColumnStatistics>(
+      static_cast<const ColumnStatistics&>(*this), min, max, sum);
+  if (auto numDistinct = estimateNumDistinct()) {
+    result->setNumDistinct(*numDistinct);
+  }
+  return result;
+}
+
+void DoubleStatisticsBuilder::addValues(double value, uint64_t count) {
+  increaseValueCount(count);
+  if (std::isnan(value)) {
+    clear();
+    return;
+  }
+
+  if (min_.has_value() && value < min_.value()) {
+    min_ = value;
+  }
+  if (max_.has_value() && value > max_.value()) {
+    max_ = value;
+  }
+  addHash(value);
+  if (sum_.has_value()) {
+    for (uint64_t i = 0; i < count; ++i) {
+      sum_.value() += value;
+    }
+    if (std::isnan(sum_.value())) {
+      sum_.reset();
+    }
+  }
+}
+
+void DoubleStatisticsBuilder::merge(
+    const ColumnStatistics& other,
+    bool ignoreSize) {
+  StatisticsBuilder::merge(other, ignoreSize);
+  auto stats = dynamic_cast<const DoubleColumnStatistics*>(&other);
+  if (!stats) {
+    if (!other.isAllNull()) {
+      clear();
+    }
+    return;
+  }
+  mergeMin(min_, stats->getMinimum());
+  mergeMax(max_, stats->getMaximum());
+  mergeCount(sum_, stats->getSum());
+  if (sum_.has_value() && std::isnan(sum_.value())) {
+    sum_.reset();
+  }
+}
+
+std::unique_ptr<ColumnStatistics> DoubleStatisticsBuilder::build() const {
+  auto min = isAllNull() ? std::nullopt : min_;
+  auto max = isAllNull() ? std::nullopt : max_;
+  auto sum = isAllNull() ? std::nullopt : sum_;
+  auto result = std::make_unique<DoubleColumnStatistics>(
+      static_cast<const ColumnStatistics&>(*this), min, max, sum);
+  if (auto numDistinct = estimateNumDistinct()) {
+    result->setNumDistinct(*numDistinct);
+  }
+  return result;
+}
+
+void StringStatisticsBuilder::addValues(
+    std::string_view value,
+    uint64_t count) {
+  auto isSelfEmpty = isAllNull();
+  increaseValueCount(count);
+  if (isSelfEmpty) {
+    min_ = value;
+    max_ = value;
+  } else {
+    if (min_.has_value() && value < std::string_view{min_.value()}) {
+      min_ = value;
+    }
+    if (max_.has_value() && value > std::string_view{max_.value()}) {
+      max_ = value;
+    }
+  }
+  addHash(value);
+
+  addWithOverflowCheck<uint64_t>(length_, value.size(), count);
+}
+
+void StringStatisticsBuilder::merge(
+    const ColumnStatistics& other,
+    bool ignoreSize) {
+  auto isSelfEmpty = isAllNull();
+  StatisticsBuilder::merge(other, ignoreSize);
+  auto stats = dynamic_cast<const StringColumnStatistics*>(&other);
+  if (!stats) {
+    if (!other.isAllNull()) {
+      min_.reset();
+      max_.reset();
+      length_.reset();
+    }
+    return;
+  }
+
+  if (other.isAllNull()) {
+    return;
+  }
+
+  if (isSelfEmpty) {
+    min_ = stats->getMinimum();
+    max_ = stats->getMaximum();
+  } else {
+    mergeMin(min_, stats->getMinimum());
+    mergeMax(max_, stats->getMaximum());
+  }
+
+  mergeWithOverflowCheck(length_, stats->getTotalLength());
+}
+
+std::unique_ptr<ColumnStatistics> StringStatisticsBuilder::build() const {
+  std::optional<std::string> min;
+  std::optional<std::string> max;
+  std::optional<int64_t> length;
+  if (!isAllNull()) {
+    if (shouldKeepString(min_, lengthLimit_)) {
+      min = min_;
+    }
+    if (shouldKeepString(max_, lengthLimit_)) {
+      max = max_;
+    }
+    if (isValidLength(length_)) {
+      length = length_.value();
+    }
+  }
+  auto result = std::make_unique<StringColumnStatistics>(
+      static_cast<const ColumnStatistics&>(*this), min, max, length);
+  if (auto numDistinct = estimateNumDistinct()) {
+    result->setNumDistinct(*numDistinct);
+  }
+  return result;
+}
+
+void BinaryStatisticsBuilder::addValues(uint64_t length, uint64_t count) {
+  increaseValueCount(count);
+  addWithOverflowCheck(length_, length, count);
+}
+
+void BinaryStatisticsBuilder::merge(
+    const ColumnStatistics& other,
+    bool ignoreSize) {
+  StatisticsBuilder::merge(other, ignoreSize);
+  auto stats = dynamic_cast<const BinaryColumnStatistics*>(&other);
+  if (!stats) {
+    if (!other.isAllNull() && length_.has_value()) {
+      length_.reset();
+    }
+    return;
+  }
+  mergeWithOverflowCheck(length_, stats->getTotalLength());
+}
+
+std::unique_ptr<ColumnStatistics> BinaryStatisticsBuilder::build() const {
+  auto length =
+      (!isAllNull() && isValidLength(length_)) ? length_ : std::nullopt;
+  auto result = std::make_unique<BinaryColumnStatistics>(
+      static_cast<const ColumnStatistics&>(*this), length);
+  if (auto numDistinct = estimateNumDistinct()) {
+    result->setNumDistinct(*numDistinct);
+  }
+  return result;
+}
+
+} // namespace facebook::velox::dwio::stats
diff --git a/velox/dwio/common/StatisticsBuilder.h b/velox/dwio/common/StatisticsBuilder.h
new file mode 100644
index 00000000000..61319f73364
--- /dev/null
+++ b/velox/dwio/common/StatisticsBuilder.h
@@ -0,0 +1,334 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/hyperloglog/SparseHll.h"
+#include "velox/dwio/common/Statistics.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox::dwio::stats {
+
+// Import column statistics types from dwio::common.
+using common::BinaryColumnStatistics;
+using common::BooleanColumnStatistics;
+using common::ColumnStatistics;
+using common::DoubleColumnStatistics;
+using common::IntegerColumnStatistics;
+using common::StringColumnStatistics;
+
+/// Options for creating StatisticsBuilder instances.
+struct StatisticsBuilderOptions {
+  explicit StatisticsBuilderOptions(
+      uint32_t stringLengthLimit,
+      std::optional<uint64_t> initialSize = std::nullopt,
+      bool countDistincts = false,
+      HashStringAllocator* allocator = nullptr)
+      : stringLengthLimit{stringLengthLimit},
+        initialSize{initialSize},
+        countDistincts(countDistincts),
+        allocator(allocator) {}
+
+  /// Maximum length of min/max string values to track. Strings longer than
+  /// this limit are dropped from statistics.
+  uint32_t stringLengthLimit;
+
+  /// Initial value for the size statistic (total stream bytes). Nullopt means
+  /// size tracking is disabled until ensureSize() is called.
+  std::optional<uint64_t> initialSize;
+
+  /// Whether to count approximate distinct values using HyperLogLog. Requires
+  /// 'allocator' to be set.
+  bool countDistincts{false};
+
+  /// Allocator for HyperLogLog distinct counting. Required if 'countDistincts'
+  /// is true.
+  HashStringAllocator* allocator;
+
+  /// Returns a copy with distinct counting disabled.
+  StatisticsBuilderOptions dropNumDistinct() const {
+    return StatisticsBuilderOptions(stringLengthLimit, initialSize);
+  }
+};
+
+/// Base class for stats builder. Stats builder is used in writer and file merge
+/// to collect and merge stats.
+/// It can also be used for gathering stats in ad hoc sampling. In this case it
+/// may also count distinct values if enabled in 'options'.
+class StatisticsBuilder : public virtual ColumnStatistics {
+ public:
+  explicit StatisticsBuilder(const StatisticsBuilderOptions& options)
+      : options_{options} {
+    VELOX_CHECK(
+        !options.countDistincts || options.allocator != nullptr,
+        "allocator is required when countDistincts is true");
+    init();
+  }
+
+  ~StatisticsBuilder() override = default;
+
+  void setHasNull() {
+    hasNull_ = true;
+  }
+
+  void increaseValueCount(uint64_t count = 1) {
+    if (valueCount_.has_value()) {
+      valueCount_.value() += count;
+    }
+  }
+
+  void increaseRawSize(uint64_t rawSize) {
+    if (rawSize_.has_value()) {
+      rawSize_.value() += rawSize;
+    }
+  }
+
+  void clearRawSize() {
+    rawSize_.reset();
+  }
+
+  void ensureSize() {
+    if (!size_.has_value()) {
+      size_ = 0;
+    }
+  }
+
+  void incrementSize(uint64_t size);
+
+  template <typename T>
+  void addHash(const T& data) {
+    if (hll_) {
+      hll_->insertHash(folly::hasher<T>()(data));
+    }
+  }
+
+  int64_t cardinality() const {
+    VELOX_CHECK_NOT_NULL(hll_);
+    return hll_->cardinality();
+  }
+
+  /// Returns estimated number of distinct values if distinct counting is
+  /// enabled, or std::nullopt otherwise.
+  std::optional<int64_t> estimateNumDistinct() const {
+    if (hll_) {
+      return hll_->cardinality();
+    }
+    return std::nullopt;
+  }
+
+  /// Merges stats of same type. Used in writer to aggregate file level stats.
+  virtual void merge(const ColumnStatistics& other, bool ignoreSize = false);
+
+  /// Resets to initial state. Used where row index entry level stats is
+  /// captured.
+  virtual void reset() {
+    init();
+  }
+
+  /// Builds a read-only ColumnStatistics snapshot. Typed stats (min/max/sum)
+  /// are omitted when isAllNull(). String min/max are omitted when they exceed
+  /// the string length limit.
+  virtual std::unique_ptr<ColumnStatistics> build() const;
+
+  /// Creates a StatisticsBuilder for the given type. For MAP type, creates a
+  /// base StatisticsBuilder (not a MapStatisticsBuilder, which stays in DWRF).
+  static std::unique_ptr<StatisticsBuilder> create(
+      const Type& type,
+      const StatisticsBuilderOptions& options);
+
+  /// For the given type tree, creates a list of stat builders.
+  static void createTree(
+      std::vector<std::unique_ptr<StatisticsBuilder>>& statBuilders,
+      const Type& type,
+      const StatisticsBuilderOptions& options);
+
+ private:
+  void init() {
+    valueCount_ = 0;
+    hasNull_ = false;
+    rawSize_ = 0;
+    size_ = options_.initialSize;
+    if (options_.countDistincts) {
+      hll_ =
+          std::make_shared<velox::common::hll::SparseHll<>>(options_.allocator);
+    }
+  }
+
+ protected:
+  StatisticsBuilderOptions options_;
+  std::shared_ptr<velox::common::hll::SparseHll<>> hll_;
+};
+
+class BooleanStatisticsBuilder : public virtual StatisticsBuilder,
+                                 public BooleanColumnStatistics {
+ public:
+  explicit BooleanStatisticsBuilder(const StatisticsBuilderOptions& options)
+      : StatisticsBuilder{options.dropNumDistinct()} {
+    init();
+  }
+
+  ~BooleanStatisticsBuilder() override = default;
+
+  void addValues(bool value, uint64_t count = 1);
+
+  std::unique_ptr<ColumnStatistics> build() const override;
+
+  void merge(const ColumnStatistics& other, bool ignoreSize = false) override;
+
+  void reset() override {
+    StatisticsBuilder::reset();
+    init();
+  }
+
+ private:
+  void init() {
+    trueCount_ = 0;
+  }
+};
+
+class IntegerStatisticsBuilder : public virtual StatisticsBuilder,
+                                 public IntegerColumnStatistics {
+ public:
+  explicit IntegerStatisticsBuilder(const StatisticsBuilderOptions& options)
+      : StatisticsBuilder{options} {
+    init();
+  }
+
+  ~IntegerStatisticsBuilder() override = default;
+
+  void addValues(int64_t value, uint64_t count = 1);
+
+  std::unique_ptr<ColumnStatistics> build() const override;
+
+  void merge(const ColumnStatistics& other, bool ignoreSize = false) override;
+
+  void reset() override {
+    StatisticsBuilder::reset();
+    init();
+  }
+
+ private:
+  void init() {
+    min_ = std::numeric_limits<int64_t>::max();
+    max_ = std::numeric_limits<int64_t>::min();
+    sum_ = 0;
+  }
+};
+
+static_assert(
+    std::numeric_limits<double>::has_infinity,
+    "infinity not defined");
+
+class DoubleStatisticsBuilder : public virtual StatisticsBuilder,
+                                public DoubleColumnStatistics {
+ public:
+  explicit DoubleStatisticsBuilder(const StatisticsBuilderOptions& options)
+      : StatisticsBuilder{options} {
+    init();
+  }
+
+  ~DoubleStatisticsBuilder() override = default;
+
+  void addValues(double value, uint64_t count = 1);
+
+  std::unique_ptr<ColumnStatistics> build() const override;
+
+  void merge(const ColumnStatistics& other, bool ignoreSize = false) override;
+
+  void reset() override {
+    StatisticsBuilder::reset();
+    init();
+  }
+
+ private:
+  void init() {
+    min_ = std::numeric_limits<double>::infinity();
+    max_ = -std::numeric_limits<double>::infinity();
+    sum_ = 0;
+  }
+
+  void clear() {
+    min_.reset();
+    max_.reset();
+    sum_.reset();
+  }
+};
+
+class StringStatisticsBuilder : public virtual StatisticsBuilder,
+                                public StringColumnStatistics {
+ public:
+  explicit StringStatisticsBuilder(const StatisticsBuilderOptions& options)
+      : StatisticsBuilder{options}, lengthLimit_{options.stringLengthLimit} {
+    init();
+  }
+
+  ~StringStatisticsBuilder() override = default;
+
+  void addValues(std::string_view value, uint64_t count = 1);
+
+  std::unique_ptr<ColumnStatistics> build() const override;
+
+  void merge(const ColumnStatistics& other, bool ignoreSize = false) override;
+
+  void reset() override {
+    StatisticsBuilder::reset();
+    init();
+  }
+
+ protected:
+  uint32_t lengthLimit_;
+
+  bool shouldKeep(const std::optional<std::string>& val) const {
+    return val.has_value() && val.value().size() <= lengthLimit_;
+  }
+
+ private:
+  void init() {
+    min_.reset();
+    max_.reset();
+    length_ = 0;
+  }
+};
+
+class BinaryStatisticsBuilder : public virtual StatisticsBuilder,
+                                public BinaryColumnStatistics {
+ public:
+  explicit BinaryStatisticsBuilder(const StatisticsBuilderOptions& options)
+      : StatisticsBuilder{options.dropNumDistinct()} {
+    init();
+  }
+
+  ~BinaryStatisticsBuilder() override = default;
+
+  void addValues(uint64_t length, uint64_t count = 1);
+
+  std::unique_ptr<ColumnStatistics> build() const override;
+
+  void merge(const ColumnStatistics& other, bool ignoreSize = false) override;
+
+  void reset() override {
+    StatisticsBuilder::reset();
+    init();
+  }
+
+ private:
+  void init() {
+    length_ = 0;
+  }
+};
+
+} // namespace facebook::velox::dwio::stats
diff --git a/velox/dwio/common/StreamUtil.h b/velox/dwio/common/StreamUtil.h
index 0a0a2b2b0e8..c2ac4e1bdc3 100644
--- a/velox/dwio/common/StreamUtil.h
+++ b/velox/dwio/common/StreamUtil.h
@@ -76,19 +76,19 @@ inline bool isDense(const T* values, int32_t size) {
   return (values[size - 1] - values[0] == size - 1);
 }
 
-template <typename Dense, typename Sparse, typename SparseN>
+template <int kStep, typename Dense, typename Sparse, typename SparseN>
 void rowLoop(
     const int32_t* rows,
     int32_t begin,
     int32_t end,
-    int32_t step,
     Dense dense,
     Sparse sparse,
     SparseN sparseN) {
+  static_assert(bits::isPowerOfTwo(kStep));
   int32_t i = begin;
-  auto firstPartial = (end - begin) & ~(step - 1);
-  for (; i < firstPartial; i += step) {
-    if (isDense(&rows[i], step)) {
+  const auto firstPartial = (end - begin) & ~(kStep - 1);
+  for (; i < begin + firstPartial; i += kStep) {
+    if (isDense(&rows[i], kStep)) {
       dense(i);
     } else {
       sparse(i);
@@ -144,7 +144,7 @@ inline void readContiguous(
 
 // Returns the number of elements in rows that are < limit.
 inline int32_t numBelow(folly::Range<const int32_t*> rows, int32_t limit) {
-  return std::lower_bound(rows.begin(), rows.end(), limit) - rows.begin();
+  return std::lower_bound(rows.cbegin(), rows.cend(), limit) - rows.cbegin();
 }
 
 template <typename T, typename SingleValue, typename SparseRange>
@@ -159,15 +159,15 @@ inline void loopOverBuffers(
   int32_t rowOffset = initialRow;
   int32_t rowIndex = 0;
   while (rowIndex < rows.size()) {
-    auto available = (bufferEnd - bufferStart) / sizeof(T);
-    auto numRowsInBuffer = rows.back() - rowOffset < available
+    const auto available = (bufferEnd - bufferStart) / sizeof(T);
+    const auto numRowsInBuffer = rows.back() - rowOffset < available
         ? rows.size() - rowIndex
         : numBelow(
               folly::Range<const int32_t*>(
                   &rows[rowIndex], rows.size() - rowIndex),
               rowOffset + available);
 
-    if (!numRowsInBuffer) {
+    if (numRowsInBuffer == 0) {
       skipBytes(
           (rows[rowIndex] - rowOffset) * sizeof(T),
           &input,
diff --git a/velox/dwio/common/Throttler.h b/velox/dwio/common/Throttler.h
index 05bce4ceb2d..7bd84406efb 100644
--- a/velox/dwio/common/Throttler.h
+++ b/velox/dwio/common/Throttler.h
@@ -18,6 +18,8 @@
 #include <mutex>
 #include <random>
 
+#include <folly/SharedMutex.h>
+
 #include "velox/common/caching/CachedFactory.h"
 #include "velox/common/caching/SimpleLRUCache.h"
 #include "velox/common/io/IoStatistics.h"
diff --git a/velox/dwio/common/TypeUtils.cpp b/velox/dwio/common/TypeUtils.cpp
index 29e22046196..b0220b9acdc 100644
--- a/velox/dwio/common/TypeUtils.cpp
+++ b/velox/dwio/common/TypeUtils.cpp
@@ -131,11 +131,13 @@ void checkTypeCompatibility(
     const FShouldRead& shouldRead,
     const std::function<std::string()>& exceptionMessageCreator) {
   if (shouldRead(to) && !isCompatible(from.kind(), kind(to))) {
-    VELOX_SCHEMA_MISMATCH_ERROR(fmt::format(
-        "{}, From Kind: {}, To Kind: {}",
-        exceptionMessageCreator ? exceptionMessageCreator() : "Schema mismatch",
-        mapTypeKindToName(from.kind()),
-        mapTypeKindToName(kind(to))));
+    VELOX_SCHEMA_MISMATCH_ERROR(
+        fmt::format(
+            "{}, From Kind: {}, To Kind: {}",
+            exceptionMessageCreator ? exceptionMessageCreator()
+                                    : "Schema mismatch",
+            TypeKindName::toName(from.kind()),
+            TypeKindName::toName(kind(to))));
   }
 
   if (recurse) {
diff --git a/velox/dwio/common/TypeWithId.h b/velox/dwio/common/TypeWithId.h
index a147cfe5066..80084dbfb53 100644
--- a/velox/dwio/common/TypeWithId.h
+++ b/velox/dwio/common/TypeWithId.h
@@ -97,4 +97,6 @@ class TypeWithId : public velox::Tree<std::shared_ptr<const TypeWithId>> {
   const std::vector<std::shared_ptr<const TypeWithId>> children_;
 };
 
+using TypeWithIdPtr = std::shared_ptr<const TypeWithId>;
+
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/UnitLoader.h b/velox/dwio/common/UnitLoader.h
index d3125dacc4b..d1fc54ab240 100644
--- a/velox/dwio/common/UnitLoader.h
+++ b/velox/dwio/common/UnitLoader.h
@@ -16,9 +16,13 @@
 
 #pragma once
 
+#include <folly/Synchronized.h>
+#include <folly/container/F14Map.h>
 #include <cstdint>
 #include <memory>
 #include <vector>
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/base/RuntimeMetrics.h"
 
 namespace facebook::velox::dwio::common {
 
@@ -39,6 +43,44 @@ class LoadUnit {
   virtual uint64_t getIoSize() = 0;
 };
 
+class UnitLoaderStats {
+ public:
+  UnitLoaderStats() = default;
+
+  void addCounter(const std::string& name, RuntimeCounter counter) {
+    auto locked = stats_.wlock();
+    auto it = locked->find(name);
+    if (it == locked->end()) {
+      auto [ptr, inserted] = locked->emplace(name, RuntimeMetric(counter.unit));
+      VELOX_CHECK(inserted);
+      ptr->second.addValue(counter.value);
+    } else {
+      VELOX_CHECK_EQ(it->second.unit, counter.unit);
+      it->second.addValue(counter.value);
+    }
+  }
+
+  void merge(const UnitLoaderStats& other) {
+    auto otherStats = other.stats();
+    auto locked = stats_.wlock();
+    for (const auto& [name, metric] : otherStats) {
+      auto it = locked->find(name);
+      if (it == locked->end()) {
+        locked->emplace(name, metric);
+      } else {
+        it->second.merge(metric);
+      }
+    }
+  }
+
+  folly::F14FastMap<std::string, RuntimeMetric> stats() const {
+    return stats_.copy();
+  }
+
+ private:
+  folly::Synchronized<folly::F14FastMap<std::string, RuntimeMetric>> stats_;
+};
+
 class UnitLoader {
  public:
   virtual ~UnitLoader() = default;
@@ -56,6 +98,10 @@ class UnitLoader {
   /// Reader reports seek calling this method. The call must be done **before**
   /// getLoadedUnit for the new unit.
   virtual void onSeek(uint32_t unit, uint64_t rowOffsetInUnit) = 0;
+
+  virtual UnitLoaderStats stats() {
+    return UnitLoaderStats();
+  };
 };
 
 class UnitLoaderFactory {
diff --git a/velox/dwio/common/Writer.cpp b/velox/dwio/common/Writer.cpp
index 87951cad7c5..5124cfd5ed6 100644
--- a/velox/dwio/common/Writer.cpp
+++ b/velox/dwio/common/Writer.cpp
@@ -16,6 +16,8 @@
 
 #include "velox/dwio/common/Writer.h"
 
+#include "velox/common/base/Exceptions.h"
+
 namespace facebook::velox::dwio::common {
 
 void Writer::checkStateTransition(State oldState, State newState) {
diff --git a/velox/dwio/common/Writer.h b/velox/dwio/common/Writer.h
index 774aafe4c9a..1950677a0bf 100644
--- a/velox/dwio/common/Writer.h
+++ b/velox/dwio/common/Writer.h
@@ -16,12 +16,12 @@
 
 #pragma once
 
-#include <cstddef>
-#include <cstdint>
-#include <optional>
+#include <ostream>
 #include <string>
 
-#include "velox/vector/ComplexVector.h"
+#include "velox/common/base/Portability.h"
+#include "velox/dwio/common/FileMetadata.h"
+#include "velox/vector/BaseVector.h"
 
 namespace facebook::velox::dwio::common {
 
@@ -70,10 +70,12 @@ class Writer {
   /// NOTE: this must be called before close().
   virtual bool finish() = 0;
 
-  /// Invokes closes the writer. Data can no longer be written.
+  /// Closes the writer. Data can no longer be written. Returns format-specific
+  /// file metadata collected during write operations. The returned pointer can
+  /// be null if no metadata is available, such as for an empty data file.
   ///
   /// NOTE: this must be called after the last finish() which returns true.
-  virtual void close() = 0;
+  virtual std::unique_ptr<FileMetadata> close() = 0;
 
   /// Aborts the writing by closing the writer and dropping everything.
   /// Data can no longer be written.
@@ -91,7 +93,7 @@ class Writer {
   /// Validates the state transition from 'oldState' to 'newState'.
   static void checkStateTransition(State oldState, State newState);
 
-  State state_{State::kInit};
+  tsan_atomic<State> state_{State::kInit};
 };
 
 FOLLY_ALWAYS_INLINE std::ostream& operator<<(
diff --git a/velox/dwio/common/compression/CMakeLists.txt b/velox/dwio/common/compression/CMakeLists.txt
index ed39366b3a5..913a8d061c9 100644
--- a/velox/dwio/common/compression/CMakeLists.txt
+++ b/velox/dwio/common/compression/CMakeLists.txt
@@ -17,6 +17,11 @@ velox_add_library(
   Compression.cpp
   PagedInputStream.cpp
   PagedOutputStream.cpp
+  HEADERS
+  Compression.h
+  CompressionBufferPool.h
+  PagedInputStream.h
+  PagedOutputStream.h
 )
 
 velox_link_libraries(
diff --git a/velox/dwio/common/compression/Compression.cpp b/velox/dwio/common/compression/Compression.cpp
index 222385b3ce4..59e4232176c 100644
--- a/velox/dwio/common/compression/Compression.cpp
+++ b/velox/dwio/common/compression/Compression.cpp
@@ -16,7 +16,9 @@
 
 #include "velox/dwio/common/compression/Compression.h"
 #include "velox/common/compression/LzoDecompressor.h"
+#include "velox/common/time/CpuWallTimer.h"
 #include "velox/dwio/common/IntCodecCommon.h"
+#include "velox/dwio/common/Statistics.h"
 #include "velox/dwio/common/compression/PagedInputStream.h"
 
 #include <folly/logging/xlog.h>
@@ -398,9 +400,6 @@ uint64_t Lz4Decompressor::decompressInternal(
   return static_cast<uint64_t>(result);
 }
 
-// NOTE: We do not keep `ZSTD_DCtx' around on purpose, because if we keep it
-// around, in flat map column reader we have hundreds of thousands of
-// decompressors at same time and causing OOM.
 class ZstdDecompressor : public Decompressor {
  public:
   explicit ZstdDecompressor(
@@ -424,7 +423,10 @@ uint64_t ZstdDecompressor::decompress(
     uint64_t srcLength,
     char* dest,
     uint64_t destLength) {
-  auto ret = ZSTD_decompress(dest, destLength, src, srcLength);
+  // Reuse 'ZSTD_DCtx' per-thread to avoid repeated allocations.
+  thread_local std::unique_ptr<ZSTD_DCtx, size_t (*)(ZSTD_DCtx*)> ctx{
+      ZSTD_createDCtx(), ZSTD_freeDCtx};
+  auto ret = ZSTD_decompressDCtx(ctx.get(), dest, destLength, src, srcLength);
   DWIO_ENSURE(
       !ZSTD_isError(ret),
       "ZSTD returned an error: ",
@@ -513,8 +515,9 @@ class ZlibDecompressionStream : public PagedInputStream,
       const std::string& streamDebugInfo,
       bool isGzip = false,
       bool useRawDecompression = false,
-      size_t compressedLength = 0)
-      : PagedInputStream{std::move(inStream), pool, streamDebugInfo, useRawDecompression, compressedLength},
+      size_t compressedLength = 0,
+      io::IoCounter* decompressCounter = nullptr)
+      : PagedInputStream{std::move(inStream), pool, streamDebugInfo, useRawDecompression, compressedLength, decompressCounter},
         ZlibDecompressor{blockSize, windowBits, streamDebugInfo, isGzip} {}
   ~ZlibDecompressionStream() override = default;
 
@@ -555,6 +558,8 @@ bool ZlibDecompressionStream::readOrSkip(const void** data, int32_t* size) {
     *size = static_cast<int32_t>(availSize);
     outputBufferPtr_ = inputBufferPtr_ + availSize;
     outputBufferLength_ = 0;
+    inputBufferPtr_ += availSize;
+    remainingLength_ -= availSize;
   } else {
     DWIO_ENSURE_EQ(
         state_,
@@ -566,43 +571,54 @@ bool ZlibDecompressionStream::readOrSkip(const void** data, int32_t* size) {
     prepareOutputBuffer(
         getDecompressedLength(inputBufferPtr_, availSize).first);
 
-    reset();
-    zstream_.next_in =
-        reinterpret_cast<Bytef*>(const_cast<char*>(inputBufferPtr_));
-    zstream_.avail_in = folly::to<uInt>(availSize);
-    outputBufferPtr_ = outputBuffer_->data();
-    zstream_.next_out =
-        reinterpret_cast<Bytef*>(const_cast<char*>(outputBufferPtr_));
-    zstream_.avail_out = folly::to<uInt>(blockSize_);
-    int32_t result;
-    do {
-      result = inflate(
-          &zstream_, availSize == remainingLength_ ? Z_FINISH : Z_SYNC_FLUSH);
-      switch (result) {
-        case Z_OK:
-          remainingLength_ -= availSize;
-          inputBufferPtr_ += availSize;
+    auto doDecompress = [&]() {
+      reset();
+      int32_t result;
+      *size = 0;
+      do {
+        if (inputBufferPtr_ == inputBufferPtrEnd_) {
           readBuffer(true);
-          availSize = std::min(
-              static_cast<size_t>(inputBufferPtrEnd_ - inputBufferPtr_),
-              remainingLength_);
-          zstream_.next_in =
-              reinterpret_cast<Bytef*>(const_cast<char*>(inputBufferPtr_));
-          zstream_.avail_in = static_cast<uInt>(availSize);
-          break;
-        case Z_STREAM_END:
-          break;
-        default:
-          DWIO_RAISE(
-              "Error in ZlibDecompressionStream::Next in ",
-              getName(),
-              ". error: ",
-              result,
-              " Info: ",
-              ZlibDecompressor::streamDebugInfo_);
-      }
-    } while (result != Z_STREAM_END);
-    *size = static_cast<int32_t>(blockSize_ - zstream_.avail_out);
+        }
+        zstream_.next_in =
+            reinterpret_cast<Bytef*>(const_cast<char*>(inputBufferPtr_));
+        zstream_.avail_in =
+            static_cast<size_t>(inputBufferPtrEnd_ - inputBufferPtr_);
+
+        do {
+          // size_ of outputBuffer_ is not updated in inflate, so *size is used
+          // here to ensure enough capacity for the output data.
+          outputBuffer_->extend(*size);
+          outputBufferPtr_ = outputBuffer_->data();
+          zstream_.next_out = reinterpret_cast<Bytef*>(
+              const_cast<char*>(outputBufferPtr_ + *size));
+          zstream_.avail_out = folly::to<uInt>(blockSize_);
+          result = inflate(&zstream_, Z_SYNC_FLUSH);
+          // Result handling adapted from https://zlib.net/zlib_how.html
+          switch (result) {
+            case Z_NEED_DICT:
+              result = Z_DATA_ERROR;
+              [[fallthrough]];
+            case Z_DATA_ERROR:
+              [[fallthrough]];
+            case Z_MEM_ERROR:
+              [[fallthrough]];
+            case Z_STREAM_ERROR:
+              DWIO_RAISE("Failed to inflate input data. error: ", result);
+            default:
+              *size += static_cast<int32_t>(
+                  blockSize_ - static_cast<int64_t>(zstream_.avail_out));
+              const size_t inputConsumed =
+                  reinterpret_cast<const char*>(zstream_.next_in) -
+                  inputBufferPtr_;
+              remainingLength_ -= inputConsumed;
+              inputBufferPtr_ += inputConsumed;
+          }
+        } while (zstream_.avail_out == 0);
+      } while (result != Z_STREAM_END);
+    };
+
+    withDecompressStats(decompressCounter_, [&] { doDecompress(); });
+
     if (data) {
       *data = outputBufferPtr_;
     }
@@ -610,8 +626,6 @@ bool ZlibDecompressionStream::readOrSkip(const void** data, int32_t* size) {
     outputBufferPtr_ += *size;
   }
 
-  inputBufferPtr_ += availSize;
-  remainingLength_ -= availSize;
   bytesReturned_ += *size;
   return true;
 }
@@ -668,7 +682,8 @@ std::unique_ptr<dwio::common::SeekableInputStream> createDecompressor(
     const std::string& streamDebugInfo,
     const Decrypter* decrypter,
     bool useRawDecompression,
-    size_t compressedLength) {
+    size_t compressedLength,
+    io::IoCounter* decompressCounter) {
   std::unique_ptr<Decompressor> decompressor;
   switch (static_cast<int64_t>(kind)) {
     case CompressionKind::CompressionKind_NONE:
@@ -689,7 +704,8 @@ std::unique_ptr<dwio::common::SeekableInputStream> createDecompressor(
             streamDebugInfo,
             false,
             useRawDecompression,
-            compressedLength);
+            compressedLength,
+            decompressCounter);
       }
       decompressor = std::make_unique<ZlibDecompressor>(
           blockSize, options.format.zlib.windowBits, streamDebugInfo, false);
@@ -706,7 +722,8 @@ std::unique_ptr<dwio::common::SeekableInputStream> createDecompressor(
             streamDebugInfo,
             true,
             useRawDecompression,
-            compressedLength);
+            compressedLength,
+            decompressCounter);
       }
       decompressor = std::make_unique<ZlibDecompressor>(
           blockSize, options.format.zlib.windowBits, streamDebugInfo, true);
@@ -741,7 +758,8 @@ std::unique_ptr<dwio::common::SeekableInputStream> createDecompressor(
       decrypter,
       streamDebugInfo,
       useRawDecompression,
-      compressedLength);
+      compressedLength,
+      decompressCounter);
 }
 
 } // namespace facebook::velox::dwio::common::compression
diff --git a/velox/dwio/common/compression/Compression.h b/velox/dwio/common/compression/Compression.h
index 3d26b3af98a..00204918a4c 100644
--- a/velox/dwio/common/compression/Compression.h
+++ b/velox/dwio/common/compression/Compression.h
@@ -17,6 +17,7 @@
 #pragma once
 
 #include "velox/common/compression/Compression.h"
+#include "velox/common/io/IoStatistics.h"
 #include "velox/dwio/common/SeekableInputStream.h"
 #include "velox/dwio/common/encryption/Encryption.h"
 
@@ -98,6 +99,7 @@ struct CompressionOptions {
  * @param options The compression options to use
  * @param useRawDecompression Specify whether to perform raw decompression
  * @param compressedLength The compressed block length for raw decompression
+ * @param decompressCounter Optional IoCounter for tracking decompression stats
  */
 std::unique_ptr<dwio::common::SeekableInputStream> createDecompressor(
     facebook::velox::common::CompressionKind kind,
@@ -108,7 +110,8 @@ std::unique_ptr<dwio::common::SeekableInputStream> createDecompressor(
     const std::string& streamDebugInfo,
     const dwio::common::encryption::Decrypter* decryptr = nullptr,
     bool useRawDecompression = false,
-    size_t compressedLength = 0);
+    size_t compressedLength = 0,
+    io::IoCounter* decompressCounter = nullptr);
 
 /**
  * Create a compressor for the given compression kind.
diff --git a/velox/dwio/common/compression/PagedInputStream.cpp b/velox/dwio/common/compression/PagedInputStream.cpp
index 08357298cf5..7891f3a3d58 100644
--- a/velox/dwio/common/compression/PagedInputStream.cpp
+++ b/velox/dwio/common/compression/PagedInputStream.cpp
@@ -16,6 +16,8 @@
 
 #include "velox/dwio/common/compression/PagedInputStream.h"
 
+#include "velox/dwio/common/Statistics.h"
+
 namespace facebook::velox::dwio::common::compression {
 
 void PagedInputStream::prepareOutputBuffer(uint64_t uncompressedLength) {
@@ -165,7 +167,7 @@ bool PagedInputStream::readOrSkip(const void** data, int32_t* size) {
   // perform decryption
   if (decrypter_) {
     decryptionBuffer_ =
-        decrypter_->decrypt(folly::StringPiece{input, remainingLength_});
+        decrypter_->decrypt(std::string_view{input, remainingLength_});
     input = reinterpret_cast<const char*>(decryptionBuffer_->data());
     remainingLength_ = decryptionBuffer_->length();
     if (data) {
@@ -186,11 +188,13 @@ bool PagedInputStream::readOrSkip(const void** data, int32_t* size) {
       outputBufferPtr_ = nullptr;
     } else {
       prepareOutputBuffer(decompressedLength);
-      outputBufferLength_ = decompressor_->decompress(
-          input,
-          remainingLength_,
-          outputBuffer_->data(),
-          outputBuffer_->capacity());
+      outputBufferLength_ = withDecompressStats(decompressCounter_, [&] {
+        return decompressor_->decompress(
+            input,
+            remainingLength_,
+            outputBuffer_->data(),
+            outputBuffer_->capacity());
+      });
       if (data) {
         *data = outputBuffer_->data();
       }
diff --git a/velox/dwio/common/compression/PagedInputStream.h b/velox/dwio/common/compression/PagedInputStream.h
index 15b1acd630a..7045e98483f 100644
--- a/velox/dwio/common/compression/PagedInputStream.h
+++ b/velox/dwio/common/compression/PagedInputStream.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include "velox/common/io/IoStatistics.h"
 #include "velox/dwio/common/SeekableInputStream.h"
 #include "velox/dwio/common/compression/Compression.h"
 
@@ -30,13 +31,15 @@ class PagedInputStream : public dwio::common::SeekableInputStream {
       const dwio::common::encryption::Decrypter* decrypter,
       const std::string& streamDebugInfo,
       bool useRawDecompression = false,
-      size_t compressedLength = 0)
+      size_t compressedLength = 0,
+      io::IoCounter* decompressCounter = nullptr)
       : input_(std::move(inStream)),
         pool_(memPool),
         inputBuffer_(pool_),
         decompressor_{std::move(decompressor)},
         decrypter_{decrypter},
-        streamDebugInfo_{streamDebugInfo} {
+        streamDebugInfo_{streamDebugInfo},
+        decompressCounter_{decompressCounter} {
     DWIO_ENSURE(
         decompressor_ || decrypter_,
         "one of decompressor or decryptor is required");
@@ -56,7 +59,7 @@ class PagedInputStream : public dwio::common::SeekableInputStream {
   // NOTE: This always returns true.
   bool SkipInt64(int64_t count) override;
 
-  google::protobuf::int64 ByteCount() const override {
+  int64_t ByteCount() const override {
     return bytesReturned_ + pendingSkip_;
   }
 
@@ -87,13 +90,15 @@ class PagedInputStream : public dwio::common::SeekableInputStream {
       memory::MemoryPool& memPool,
       const std::string& streamDebugInfo,
       bool useRawDecompression = false,
-      size_t compressedLength = 0)
+      size_t compressedLength = 0,
+      io::IoCounter* decompressCounter = nullptr)
       : input_(std::move(inStream)),
         pool_(memPool),
         inputBuffer_(pool_),
         decompressor_{nullptr},
         decrypter_{nullptr},
-        streamDebugInfo_{streamDebugInfo} {
+        streamDebugInfo_{streamDebugInfo},
+        decompressCounter_{decompressCounter} {
     DWIO_ENSURE(
         !useRawDecompression || compressedLength > 0,
         "For raw decompression, compressedLength should be greater than zero");
@@ -182,6 +187,11 @@ class PagedInputStream : public dwio::common::SeekableInputStream {
 
   // Stream Debug Info
   const std::string streamDebugInfo_;
+
+ protected:
+  // Owned by ColumnReaderStatistics. Valid for the lifetime of this stream
+  // because ColumnReaderStatistics outlives all streams within a DwrfRowReader.
+  io::IoCounter* const decompressCounter_{nullptr};
 };
 
 } // namespace facebook::velox::dwio::common::compression
diff --git a/velox/dwio/common/compression/PagedOutputStream.cpp b/velox/dwio/common/compression/PagedOutputStream.cpp
index 18d993bf74f..2519893be4b 100644
--- a/velox/dwio/common/compression/PagedOutputStream.cpp
+++ b/velox/dwio/common/compression/PagedOutputStream.cpp
@@ -18,7 +18,7 @@
 
 namespace facebook::velox::dwio::common::compression {
 
-std::vector<folly::StringPiece> PagedOutputStream::createPage() {
+std::vector<std::string_view> PagedOutputStream::createPage() {
   auto origSize = buffer_.size();
   VELOX_CHECK_GT(origSize, pageHeaderSize_);
   origSize -= pageHeaderSize_;
@@ -34,15 +34,15 @@ std::vector<folly::StringPiece> PagedOutputStream::createPage() {
         origSize);
   }
 
-  folly::StringPiece compressed;
+  std::string_view compressed;
   if (compressedSize >= origSize) {
     // write orig
     writeHeader(buffer_.data(), origSize, true);
-    compressed = folly::StringPiece(buffer_.data(), origSize + pageHeaderSize_);
+    compressed = std::string_view(buffer_.data(), origSize + pageHeaderSize_);
   } else {
     // write compressed
     writeHeader(compressionBuffer_->data(), compressedSize, false);
-    compressed = folly::StringPiece(
+    compressed = std::string_view(
         compressionBuffer_->data(), compressedSize + pageHeaderSize_);
   }
 
@@ -50,13 +50,13 @@ std::vector<folly::StringPiece> PagedOutputStream::createPage() {
     return {compressed};
   }
 
-  encryptionBuffer_ = encryptor_->encrypt(folly::StringPiece(
-      compressed.begin() + pageHeaderSize_, compressed.end()));
+  encryptionBuffer_ = encryptor_->encrypt(
+      std::string_view(compressed.begin() + pageHeaderSize_, compressed.end()));
   updateSize(
       const_cast<char*>(compressed.begin()), encryptionBuffer_->length());
   return {
-      folly::StringPiece(compressed.begin(), pageHeaderSize_),
-      folly::StringPiece(
+      std::string_view(compressed.begin(), pageHeaderSize_),
+      std::string_view(
           reinterpret_cast<const char*>(encryptionBuffer_->data()),
           encryptionBuffer_->length())};
 }
diff --git a/velox/dwio/common/compression/PagedOutputStream.h b/velox/dwio/common/compression/PagedOutputStream.h
index 498bba3c781..415d2961eca 100644
--- a/velox/dwio/common/compression/PagedOutputStream.h
+++ b/velox/dwio/common/compression/PagedOutputStream.h
@@ -64,8 +64,8 @@ class PagedOutputStream : public BufferedOutputStream {
       int32_t strideIndex = -1) const override;
 
  private:
-  // create page using compressor and encryptor
-  std::vector<folly::StringPiece> createPage();
+  // Create page using compressor and encryptor.
+  std::vector<std::string_view> createPage();
 
   void writeHeader(char* buffer, size_t compressedSize, bool original);
 
diff --git a/velox/dwio/common/encryption/CMakeLists.txt b/velox/dwio/common/encryption/CMakeLists.txt
index 610ebb4684a..6cd1d01807d 100644
--- a/velox/dwio/common/encryption/CMakeLists.txt
+++ b/velox/dwio/common/encryption/CMakeLists.txt
@@ -12,6 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_dwio_common_encryption Encryption.cpp)
+velox_add_library(velox_dwio_common_encryption Encryption.cpp HEADERS Encryption.h TestProvider.h)
 
 velox_link_libraries(velox_dwio_common_encryption Folly::folly)
diff --git a/velox/dwio/common/encryption/Encryption.cpp b/velox/dwio/common/encryption/Encryption.cpp
index 2e7df9a4793..1db5b8c24de 100644
--- a/velox/dwio/common/encryption/Encryption.cpp
+++ b/velox/dwio/common/encryption/Encryption.cpp
@@ -16,19 +16,11 @@
 
 #include "velox/dwio/common/encryption/Encryption.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
-namespace encryption {
+namespace facebook::velox::dwio::common::encryption {
 
 bool operator==(const EncryptionProperties& a, const EncryptionProperties& b) {
   return std::addressof(a) == std::addressof(b) ||
       (typeid(a) == typeid(b) && a.equals(b));
 }
 
-} // namespace encryption
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common::encryption
diff --git a/velox/dwio/common/encryption/Encryption.h b/velox/dwio/common/encryption/Encryption.h
index db3c2196d95..798f67d3c9f 100644
--- a/velox/dwio/common/encryption/Encryption.h
+++ b/velox/dwio/common/encryption/Encryption.h
@@ -20,11 +20,7 @@
 #include "folly/io/IOBuf.h"
 #include "velox/dwio/common/exception/Exception.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
-namespace encryption {
+namespace facebook::velox::dwio::common::encryption {
 
 enum class EncryptionProvider { Unknown = 0, CryptoService };
 
@@ -64,7 +60,7 @@ class Encrypter {
   virtual const std::string& getKey() const = 0;
 
   virtual std::unique_ptr<folly::IOBuf> encrypt(
-      folly::StringPiece input) const = 0;
+      std::string_view input) const = 0;
 
   virtual std::unique_ptr<Encrypter> clone() const = 0;
 };
@@ -87,7 +83,7 @@ class Decrypter {
   virtual bool isKeyLoaded() const = 0;
 
   virtual std::unique_ptr<folly::IOBuf> decrypt(
-      folly::StringPiece input) const = 0;
+      std::string_view input) const = 0;
 
   virtual std::unique_ptr<Decrypter> clone() const = 0;
 };
@@ -108,7 +104,7 @@ class DummyDecrypter : public Decrypter {
   }
 
   std::unique_ptr<folly::IOBuf> decrypt(
-      folly::StringPiece /* unused */) const override {
+      std::string_view /* unused */) const override {
     DWIO_RAISE("Failed to access encrypted data");
   }
 
@@ -127,8 +123,4 @@ class DummyDecrypterFactory : public DecrypterFactory {
   }
 };
 
-} // namespace encryption
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common::encryption
diff --git a/velox/dwio/common/encryption/TestProvider.h b/velox/dwio/common/encryption/TestProvider.h
index 7ef41de8e57..b50f727a1e9 100644
--- a/velox/dwio/common/encryption/TestProvider.h
+++ b/velox/dwio/common/encryption/TestProvider.h
@@ -20,12 +20,7 @@
 #include "velox/dwio/common/encryption/Encryption.h"
 #include "velox/dwio/common/exception/Exception.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
-namespace encryption {
-namespace test {
+namespace facebook::velox::dwio::common::encryption::test {
 
 class TestEncryption {
  public:
@@ -37,18 +32,19 @@ class TestEncryption {
     return key_;
   }
 
-  std::unique_ptr<folly::IOBuf> encrypt(folly::StringPiece input) const {
+  std::unique_ptr<folly::IOBuf> encrypt(std::string_view input) const {
     ++count_;
     auto encoded = velox::encoding::Base64::encodeUrl(input);
     return folly::IOBuf::copyBuffer(key_ + encoded);
   }
 
-  std::unique_ptr<folly::IOBuf> decrypt(folly::StringPiece input) const {
+  std::unique_ptr<folly::IOBuf> decrypt(std::string_view input) const {
     ++count_;
-    std::string key{input.begin(), key_.size()};
+    std::string key{input.cbegin(), key_.size()};
     DWIO_ENSURE_EQ(key_, key);
-    auto decoded = velox::encoding::Base64::decodeUrl(folly::StringPiece{
-        input.begin() + key_.size(), input.size() - key_.size()});
+    auto decoded = velox::encoding::Base64::decodeUrl(
+        std::string_view{
+            input.begin() + key_.size(), input.size() - key_.size()});
     return folly::IOBuf::copyBuffer(decoded);
   }
 
@@ -67,8 +63,7 @@ class TestEncrypter : public TestEncryption, public Encrypter {
     return TestEncryption::getKey();
   }
 
-  std::unique_ptr<folly::IOBuf> encrypt(
-      folly::StringPiece input) const override {
+  std::unique_ptr<folly::IOBuf> encrypt(std::string_view input) const override {
     return TestEncryption::encrypt(input);
   }
 
@@ -89,8 +84,7 @@ class TestDecrypter : public TestEncryption, public Decrypter {
     return !getKey().empty();
   }
 
-  std::unique_ptr<folly::IOBuf> decrypt(
-      folly::StringPiece input) const override {
+  std::unique_ptr<folly::IOBuf> decrypt(std::string_view input) const override {
     return TestEncryption::decrypt(input);
   }
 
@@ -144,9 +138,4 @@ class TestDecrypterFactory : public DecrypterFactory {
   }
 };
 
-} // namespace test
-} // namespace encryption
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common::encryption::test
diff --git a/velox/dwio/common/exception/CMakeLists.txt b/velox/dwio/common/exception/CMakeLists.txt
index c30b1577c29..d981830ca69 100644
--- a/velox/dwio/common/exception/CMakeLists.txt
+++ b/velox/dwio/common/exception/CMakeLists.txt
@@ -12,6 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_dwio_common_exception Exception.cpp Exceptions.cpp)
+velox_add_library(
+  velox_dwio_common_exception
+  Exception.cpp
+  Exceptions.cpp
+  HEADERS
+  Exception.h
+  Exceptions.h
+)
 
 velox_link_libraries(velox_dwio_common_exception velox_exception Folly::folly glog::glog)
diff --git a/velox/dwio/common/exception/Exception.cpp b/velox/dwio/common/exception/Exception.cpp
index 97b0b78fd3c..e15f503d3ee 100644
--- a/velox/dwio/common/exception/Exception.cpp
+++ b/velox/dwio/common/exception/Exception.cpp
@@ -17,11 +17,7 @@
 #include "velox/dwio/common/exception/Exception.h"
 #include "velox/common/base/Exceptions.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
-namespace exception {
+namespace facebook::velox::dwio::common::exception {
 
 std::unique_ptr<ExceptionLogger>& exceptionLogger() {
   static std::unique_ptr<ExceptionLogger> logger(nullptr);
@@ -40,8 +36,4 @@ ExceptionLogger* getExceptionLogger() {
   return exceptionLogger().get();
 }
 
-} // namespace exception
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common::exception
diff --git a/velox/dwio/common/exception/Exception.h b/velox/dwio/common/exception/Exception.h
index 5e5e5b85f73..140df90e195 100644
--- a/velox/dwio/common/exception/Exception.h
+++ b/velox/dwio/common/exception/Exception.h
@@ -18,11 +18,8 @@
 
 #include "velox/common/base/VeloxException.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
-namespace exception {
+namespace facebook::velox::dwio {
+namespace common::exception {
 
 class ExceptionLogger {
  public:
@@ -101,8 +98,7 @@ class LoggedException : public velox::VeloxException {
   }
 };
 
-} // namespace exception
-} // namespace common
+} // namespace common::exception
 
 #define DWIO_WARN_IF(e, ...)                                                \
   ({                                                                        \
@@ -256,6 +252,4 @@ containing information about the file, line, and function where it happened.
       "]: ",                           \
       ##__VA_ARGS__);
 
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio
diff --git a/velox/dwio/common/exception/Exceptions.cpp b/velox/dwio/common/exception/Exceptions.cpp
index 04835dc5ac1..6c1bc5818e3 100644
--- a/velox/dwio/common/exception/Exceptions.cpp
+++ b/velox/dwio/common/exception/Exceptions.cpp
@@ -22,10 +22,7 @@
 #include <cstdio>
 #include <string>
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
 
 void verify_range(uint64_t v, uint64_t rangeMask) {
   auto mv = (v & rangeMask);
@@ -67,7 +64,4 @@ std::string format_error_string(std::string fmt...) {
   return s;
 }
 
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/exception/Exceptions.h b/velox/dwio/common/exception/Exceptions.h
index d6963468ea4..c241e5788f4 100644
--- a/velox/dwio/common/exception/Exceptions.h
+++ b/velox/dwio/common/exception/Exceptions.h
@@ -22,10 +22,7 @@
 #include <string>
 #include "velox/dwio/common/exception/Exception.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
 
 class NotImplementedYet : public std::logic_error {
  public:
@@ -117,7 +114,4 @@ using logic_error = exception_error<std::logic_error>;
 using runtime_error = exception_error<std::runtime_error>;
 using EOF_error = exception_error<EOFError>;
 
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/tests/BufferedInputTest.cpp b/velox/dwio/common/tests/BufferedInputTest.cpp
new file mode 100644
index 00000000000..820394cb350
--- /dev/null
+++ b/velox/dwio/common/tests/BufferedInputTest.cpp
@@ -0,0 +1,798 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/common/BufferedInput.h"
+
+#include <fmt/core.h>
+#include <folly/executors/IOThreadPoolExecutor.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/caching/FileIds.h"
+#include "velox/common/file/tests/TestUtils.h"
+#include "velox/connectors/hive/BufferedInputBuilder.h"
+#include "velox/dwio/common/DirectBufferedInput.h"
+#include "velox/dwio/dwrf/test/TestReadFile.h"
+
+using namespace facebook::velox::dwio::common;
+namespace cache = facebook::velox::cache;
+using facebook::velox::StringIdLease;
+using facebook::velox::common::Region;
+using namespace facebook::velox::memory;
+using namespace ::testing;
+
+namespace {
+
+class ReadFileMock : public ::facebook::velox::ReadFile {
+ public:
+  virtual ~ReadFileMock() override = default;
+
+// On Centos9 the gtest mock header doesn't initialize the
+// buffer_ member in MatcherBase correctly - the default constructor only
+// initializes one: /usr/include/gtest/gtest-matchers.h:302:33 resulting in
+// error:
+// '<unnamed>.testing::Matcher<const
+// facebook::velox::FileIoContext&>::<unnamed>.testing::internal::MatcherBase<const
+// facebook::velox::FileIoContext&>::buffer_' is used uninitialized
+// [-Werror=uninitialized]
+//  302 |       : vtable_(other.vtable_), buffer_(other.buffer_) {
+// Fix: https://github.com/google/googletest/pull/3797
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wuninitialized"
+  MOCK_METHOD(
+      std::string_view,
+      pread,
+      (uint64_t offset,
+       uint64_t length,
+       void* buf,
+       (const facebook::velox::FileIoContext&)context),
+      (const, override));
+
+  MOCK_METHOD(bool, shouldCoalesce, (), (const, override));
+  MOCK_METHOD(uint64_t, size, (), (const, override));
+  MOCK_METHOD(uint64_t, memoryUsage, (), (const, override));
+  MOCK_METHOD(std::string, getName, (), (const, override));
+  MOCK_METHOD(uint64_t, getNaturalReadSize, (), (const, override));
+  MOCK_METHOD(
+      uint64_t,
+      preadv,
+      (folly::Range<const Region*> regions,
+       folly::Range<folly::IOBuf*> iobufs,
+       (const facebook::velox::FileIoContext&)context),
+      (const, override));
+};
+
+void expectPreads(
+    ReadFileMock& file,
+    std::string_view content,
+    std::vector<Region> reads) {
+  EXPECT_CALL(file, getName()).WillRepeatedly(Return("mock_name"));
+  EXPECT_CALL(file, size()).WillRepeatedly(Return(content.size()));
+  for (auto& read : reads) {
+    ASSERT_GE(content.size(), read.offset + read.length);
+    EXPECT_CALL(file, pread(read.offset, read.length, _, _))
+        .Times(1)
+        .WillOnce(
+            [content](
+                uint64_t offset,
+                uint64_t length,
+                void* buf,
+                const facebook::velox::FileIoContext& context)
+                -> std::string_view {
+              memcpy(buf, content.data() + offset, length);
+              return {content.data() + offset, length};
+            });
+  }
+}
+
+void expectPreadvs(
+    ReadFileMock& file,
+    std::string_view content,
+    std::vector<Region> reads) {
+  EXPECT_CALL(file, getName()).WillRepeatedly(Return("mock_name"));
+  EXPECT_CALL(file, size()).WillRepeatedly(Return(content.size()));
+  EXPECT_CALL(file, preadv(_, _, _))
+      .Times(1)
+      .WillOnce(
+          [content, reads](
+              folly::Range<const Region*> regions,
+              folly::Range<folly::IOBuf*> iobufs,
+              const facebook::velox::FileIoContext& context) -> uint64_t {
+            EXPECT_EQ(regions.size(), reads.size());
+            uint64_t length = 0;
+            for (size_t i = 0; i < reads.size(); ++i) {
+              const auto& region = regions[i];
+              const auto& read = reads[i];
+              auto& iobuf = iobufs[i];
+              length += region.length;
+              EXPECT_EQ(region.offset, read.offset);
+              EXPECT_EQ(region.length, read.length);
+              if (!read.label.empty()) {
+                EXPECT_EQ(read.label, region.label);
+              }
+              EXPECT_LE(region.offset + region.length, content.size());
+              iobuf = folly::IOBuf(
+                  folly::IOBuf::COPY_BUFFER,
+                  content.data() + region.offset,
+                  region.length);
+            }
+
+            return length;
+          });
+}
+#pragma GCC diagnostic pop
+
+std::optional<std::string> getNext(SeekableInputStream& input) {
+  const void* buf = nullptr;
+  int32_t size;
+  if (input.Next(&buf, &size)) {
+    return std::string(
+        static_cast<const char*>(buf), static_cast<size_t>(size));
+  } else {
+    return std::nullopt;
+  }
+}
+
+class BufferedInputTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    MemoryManager::testingSetInstance(MemoryManager::Options{});
+  }
+
+  const std::shared_ptr<MemoryPool> pool_ = memoryManager()->addLeafPool();
+};
+
+TEST_F(BufferedInputTest, hasCache) {
+  auto readFile =
+      std::make_shared<facebook::velox::InMemoryReadFile>(std::string("test"));
+  BufferedInput input(readFile, *pool_);
+  // Base BufferedInput does not have cache.
+  EXPECT_FALSE(input.hasCache());
+
+  // Cache APIs throw when there is no backing cache.
+  VELOX_ASSERT_THROW(
+      input.cacheRegion(0, 4, std::string_view("test")),
+      "cacheRegion requires a backing cache");
+  VELOX_ASSERT_THROW(
+      input.findCachedRegion(0), "findCachedRegion requires a backing cache");
+}
+
+TEST_F(BufferedInputTest, cachedRegion) {
+  auto dataCache = cache::AsyncDataCache::create(memoryManager()->allocator());
+
+  // Empty pin throws.
+  VELOX_ASSERT_THROW(
+      CachedRegion(cache::CachePin{}),
+      "CachedRegion requires a non-empty cache pin");
+
+  // Exclusive pin throws.
+  auto& ids = facebook::velox::fileIds();
+  {
+    StringIdLease fileId(ids, "exclusiveTestFile");
+    cache::RawFileCacheKey key{fileId.id(), 0};
+    auto pin = dataCache->findOrCreate(key, 100);
+    ASSERT_FALSE(pin.empty());
+    ASSERT_TRUE(pin.checkedEntry()->isExclusive());
+    VELOX_ASSERT_THROW(
+        CachedRegion(std::move(pin)),
+        "CachedRegion requires a shared (non-exclusive) cache pin");
+  }
+
+  struct TestParam {
+    uint64_t entrySize;
+    bool expectTinyData;
+
+    std::string debugString() const {
+      return fmt::format(
+          "entrySize {}, expectTinyData {}", entrySize, expectTinyData);
+    }
+  };
+  std::vector<TestParam> testSettings = {
+      // Small entry uses tinyData (single contiguous range).
+      {100, true},
+      // Entry just below tinyData boundary still uses tinyData.
+      {cache::AsyncDataCacheEntry::kTinyDataSize - 1, true},
+      // Entry at tinyData boundary uses allocation.
+      {cache::AsyncDataCacheEntry::kTinyDataSize, false},
+      // One page allocation (single run).
+      {AllocationTraits::kPageSize, false},
+      // Large allocation (possibly multiple runs).
+      {128 << 10, false},
+  };
+
+  for (size_t i = 0; i < testSettings.size(); ++i) {
+    const auto& testData = testSettings[i];
+    SCOPED_TRACE(testData.debugString());
+
+    const auto entrySize = testData.entrySize;
+    std::string expected(entrySize, '\0');
+    for (uint64_t j = 0; j < entrySize; ++j) {
+      expected[j] = static_cast<char>('a' + (j % 26));
+    }
+
+    StringIdLease fileId(ids, fmt::format("cachedRegionTestFile_{}", i));
+    cache::RawFileCacheKey key{fileId.id(), 0};
+    auto pin = dataCache->findOrCreate(key, entrySize);
+    ASSERT_FALSE(pin.empty());
+    auto* entry = pin.checkedEntry();
+    ASSERT_TRUE(entry->isExclusive());
+
+    // Populate the entry with test data.
+    if (testData.expectTinyData) {
+      ASSERT_TRUE(entry->hasContiguousData());
+      memcpy(entry->contiguousData(), expected.data(), entrySize);
+    } else {
+      auto& allocation = entry->nonContiguousData();
+      ASSERT_GT(allocation.numRuns(), 0);
+      uint64_t offset = 0;
+      for (int i = 0; i < allocation.numRuns() && offset < entrySize; ++i) {
+        auto run = allocation.runAt(i);
+        const uint64_t bytes = run.numPages() * AllocationTraits::kPageSize;
+        const uint64_t copySize = std::min(bytes, entrySize - offset);
+        memcpy(run.data<char>(), expected.data() + offset, copySize);
+        offset += copySize;
+      }
+    }
+    entry->setExclusiveToShared();
+
+    CachedRegion region(std::move(pin));
+    EXPECT_EQ(region.size(), entrySize);
+    ASSERT_FALSE(region.ranges().empty());
+
+    if (testData.expectTinyData) {
+      EXPECT_EQ(region.ranges().size(), 1);
+    }
+
+    // Verify content through ranges.
+    uint64_t verified = 0;
+    for (const auto& range : region.ranges()) {
+      EXPECT_EQ(
+          std::string_view(range.data(), range.size()),
+          std::string_view(expected.data() + verified, range.size()));
+      verified += range.size();
+    }
+    EXPECT_EQ(verified, entrySize);
+
+    // Verify toIOBuf produces identical content.
+    auto iobuf = region.toIOBuf();
+    EXPECT_EQ(iobuf.computeChainDataLength(), entrySize);
+    iobuf.coalesce();
+    EXPECT_EQ(
+        std::string_view(
+            reinterpret_cast<const char*>(iobuf.data()), iobuf.length()),
+        expected);
+  }
+}
+
+TEST_F(BufferedInputTest, zeroLengthStream) {
+  auto readFile =
+      std::make_shared<facebook::velox::InMemoryReadFile>(std::string());
+  BufferedInput input(readFile, *pool_);
+  auto ret = input.enqueue({0, 0});
+  EXPECT_EQ(input.nextFetchSize(), 0);
+  EXPECT_NE(ret, nullptr);
+  const void* buf = nullptr;
+  int32_t size = 1;
+  EXPECT_FALSE(ret->Next(&buf, &size));
+  EXPECT_EQ(size, 0);
+}
+
+TEST_F(BufferedInputTest, useRead) {
+  std::string content = "hello";
+  auto readFileMock = std::make_shared<ReadFileMock>();
+  expectPreads(*readFileMock, content, {{0, 5}});
+  // Use read
+  BufferedInput input(
+      readFileMock,
+      *pool_,
+      MetricsLog::voidLog(),
+      nullptr,
+      nullptr,
+      10,
+      /* wsVRLoad = */ false);
+  auto ret = input.enqueue({0, 5});
+  ASSERT_NE(ret, nullptr);
+
+  EXPECT_EQ(input.nextFetchSize(), 5);
+  input.load(LogType::TEST);
+
+  auto next = getNext(*ret);
+  ASSERT_TRUE(next.has_value());
+  EXPECT_EQ(next.value(), content);
+}
+
+TEST_F(BufferedInputTest, useVRead) {
+  std::string content = "hello";
+  auto readFileMock = std::make_shared<ReadFileMock>();
+  expectPreadvs(*readFileMock, content, {{0, 5}});
+  // Use vread
+  BufferedInput input(
+      readFileMock,
+      *pool_,
+      MetricsLog::voidLog(),
+      nullptr,
+      nullptr,
+      10,
+      /* wsVRLoad = */ true);
+  auto ret = input.enqueue({0, 5});
+  ASSERT_NE(ret, nullptr);
+
+  EXPECT_EQ(input.nextFetchSize(), 5);
+  input.load(LogType::TEST);
+
+  auto next = getNext(*ret);
+  ASSERT_TRUE(next.has_value());
+  EXPECT_EQ(next.value(), content);
+}
+
+TEST_F(BufferedInputTest, willMerge) {
+  std::string content = "hello world";
+  auto readFileMock = std::make_shared<ReadFileMock>();
+
+  // Will merge because the distance is 1 and max distance to merge is 10.
+  // Expect only one call.
+  expectPreads(*readFileMock, content, {{0, 11}});
+
+  BufferedInput input(
+      readFileMock,
+      *pool_,
+      MetricsLog::voidLog(),
+      nullptr,
+      nullptr,
+      10, // Will merge if distance <= 10
+      /* wsVRLoad = */ false);
+
+  auto ret1 = input.enqueue({0, 5});
+  auto ret2 = input.enqueue({6, 5});
+  ASSERT_NE(ret1, nullptr);
+  ASSERT_NE(ret2, nullptr);
+
+  EXPECT_EQ(input.nextFetchSize(), 10);
+  input.load(LogType::TEST);
+
+  auto next1 = getNext(*ret1);
+  ASSERT_TRUE(next1.has_value());
+  EXPECT_EQ(next1.value(), "hello");
+
+  auto next2 = getNext(*ret2);
+  ASSERT_TRUE(next2.has_value());
+  EXPECT_EQ(next2.value(), "world");
+}
+
+TEST_F(BufferedInputTest, wontMerge) {
+  std::string content = "hello  world"; // two spaces
+  auto readFileMock = std::make_shared<ReadFileMock>();
+
+  // Won't merge because the distance is 2 and max distance to merge is 1.
+  // Expect two calls
+  expectPreads(*readFileMock, content, {{0, 5}, {7, 5}});
+
+  BufferedInput input(
+      readFileMock,
+      *pool_,
+      MetricsLog::voidLog(),
+      nullptr,
+      nullptr,
+      1, // Will merge if distance <= 1
+      /* wsVRLoad = */ false);
+
+  auto ret1 = input.enqueue({0, 5});
+  auto ret2 = input.enqueue({7, 5});
+  ASSERT_NE(ret1, nullptr);
+  ASSERT_NE(ret2, nullptr);
+
+  EXPECT_EQ(input.nextFetchSize(), 10);
+  input.load(LogType::TEST);
+
+  auto next1 = getNext(*ret1);
+  ASSERT_TRUE(next1.has_value());
+  EXPECT_EQ(next1.value(), "hello");
+
+  auto next2 = getNext(*ret2);
+  ASSERT_TRUE(next2.has_value());
+  EXPECT_EQ(next2.value(), "world");
+}
+
+TEST_F(BufferedInputTest, readSorting) {
+  std::string content = "aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqq";
+  std::vector<Region> regions = {{6, 3}, {24, 3}, {3, 3}, {0, 3}, {29, 3}};
+
+  auto readFileMock = std::make_shared<ReadFileMock>();
+  expectPreads(*readFileMock, content, {{0, 9}, {24, 3}, {29, 3}});
+  BufferedInput input(
+      readFileMock,
+      *pool_,
+      MetricsLog::voidLog(),
+      nullptr,
+      nullptr,
+      1, // Will merge if distance <= 1
+      /* wsVRLoad = */ false);
+
+  std::vector<std::pair<std::unique_ptr<SeekableInputStream>, std::string>>
+      result;
+  result.reserve(regions.size());
+  int64_t bytesToRead = 0;
+  for (auto& region : regions) {
+    bytesToRead += region.length;
+    auto ret = input.enqueue(region);
+    ASSERT_NE(ret, nullptr);
+    result.push_back(
+        {std::move(ret), content.substr(region.offset, region.length)});
+  }
+
+  EXPECT_EQ(input.nextFetchSize(), bytesToRead);
+  input.load(LogType::TEST);
+
+  for (auto& r : result) {
+    auto next = getNext(*r.first);
+    ASSERT_TRUE(next.has_value());
+    EXPECT_EQ(next.value(), r.second);
+  }
+}
+
+TEST_F(BufferedInputTest, VreadSorting) {
+  std::string content = "aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqq";
+  std::vector<Region> regions = {{6, 3}, {24, 3}, {3, 3}, {0, 3}, {29, 3}};
+
+  auto readFileMock = std::make_shared<ReadFileMock>();
+  expectPreadvs(
+      *readFileMock, content, {{0, 3}, {3, 3}, {6, 3}, {24, 3}, {29, 3}});
+  BufferedInput input(
+      readFileMock,
+      *pool_,
+      MetricsLog::voidLog(),
+      nullptr,
+      nullptr,
+      1, // Will merge if distance <= 1
+      /* wsVRLoad = */ true);
+
+  std::vector<std::pair<std::unique_ptr<SeekableInputStream>, std::string>>
+      result;
+  result.reserve(regions.size());
+  int64_t bytesToRead = 0;
+  for (auto& region : regions) {
+    bytesToRead += region.length;
+    auto ret = input.enqueue(region);
+    ASSERT_NE(ret, nullptr);
+    result.push_back(
+        {std::move(ret), content.substr(region.offset, region.length)});
+  }
+
+  EXPECT_EQ(input.nextFetchSize(), bytesToRead);
+  input.load(LogType::TEST);
+
+  for (auto& r : result) {
+    auto next = getNext(*r.first);
+    ASSERT_TRUE(next.has_value());
+    EXPECT_EQ(next.value(), r.second);
+  }
+}
+
+TEST_F(BufferedInputTest, VreadSortingWithLabels) {
+  std::string content = "aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqq";
+  std::vector<std::string> l = {"a", "b", "c", "d", "e"};
+  std::vector<Region> regions = {
+      {6, 3, l[2]}, {24, 3, l[3]}, {3, 3, l[1]}, {0, 3, l[0]}, {29, 3, l[4]}};
+
+  auto readFileMock = std::make_shared<ReadFileMock>();
+  expectPreadvs(
+      *readFileMock,
+      content,
+      {{0, 3, l[0]}, {3, 3, l[1]}, {6, 3, l[2]}, {24, 3, l[3]}, {29, 3, l[4]}});
+  BufferedInput input(
+      readFileMock,
+      *pool_,
+      MetricsLog::voidLog(),
+      nullptr,
+      nullptr,
+      1, // Will merge if distance <= 1
+      /* wsVRLoad = */ true);
+
+  std::vector<std::pair<std::unique_ptr<SeekableInputStream>, std::string>>
+      result;
+  result.reserve(regions.size());
+  int64_t bytesToRead = 0;
+  for (auto& region : regions) {
+    bytesToRead += region.length;
+    auto ret = input.enqueue(region);
+    ASSERT_NE(ret, nullptr);
+    result.push_back(
+        {std::move(ret), content.substr(region.offset, region.length)});
+  }
+
+  EXPECT_EQ(input.nextFetchSize(), bytesToRead);
+  input.load(LogType::TEST);
+
+  for (auto& r : result) {
+    auto next = getNext(*r.first);
+    ASSERT_TRUE(next.has_value());
+    EXPECT_EQ(next.value(), r.second);
+  }
+}
+
+TEST_F(BufferedInputTest, resetAfterAllStreamsConsumed) {
+  const std::string content = "aaabbbcccdddeee";
+  auto readFileMock = std::make_shared<ReadFileMock>();
+
+  // First round: enqueue and consume all streams.
+  expectPreads(*readFileMock, content, {{0, 6}});
+
+  BufferedInput input(
+      readFileMock,
+      *pool_,
+      MetricsLog::voidLog(),
+      nullptr,
+      nullptr,
+      10,
+      /* wsVRLoad = */ false);
+
+  const auto ret1 = input.enqueue({0, 3});
+  const auto ret2 = input.enqueue({3, 3});
+  ASSERT_NE(ret1, nullptr);
+  ASSERT_NE(ret2, nullptr);
+
+  input.load(LogType::TEST);
+
+  // Consume all streams.
+  auto next1 = getNext(*ret1);
+  ASSERT_TRUE(next1.has_value());
+  EXPECT_EQ(next1.value(), "aaa");
+
+  const auto next2 = getNext(*ret2);
+  ASSERT_TRUE(next2.has_value());
+  EXPECT_EQ(next2.value(), "bbb");
+
+  // Reset and enqueue new streams.
+  input.reset();
+  EXPECT_EQ(input.nextFetchSize(), 0);
+
+  // Second round: enqueue different regions after reset.
+  expectPreads(*readFileMock, content, {{6, 9}});
+
+  const auto ret3 = input.enqueue({6, 3});
+  const auto ret4 = input.enqueue({9, 6});
+  ASSERT_NE(ret3, nullptr);
+  ASSERT_NE(ret4, nullptr);
+
+  EXPECT_EQ(input.nextFetchSize(), 9);
+  input.load(LogType::TEST);
+
+  const auto next3 = getNext(*ret3);
+  ASSERT_TRUE(next3.has_value());
+  EXPECT_EQ(next3.value(), "ccc");
+
+  const auto next4 = getNext(*ret4);
+  ASSERT_TRUE(next4.has_value());
+  EXPECT_EQ(next4.value(), "dddeee");
+}
+
+TEST_F(BufferedInputTest, resetAfterPartialStreamsConsumed) {
+  const std::string content = "aaabbbcccdddeee";
+  auto readFileMock = std::make_shared<ReadFileMock>();
+
+  // First round: enqueue streams but only consume some.
+  expectPreads(*readFileMock, content, {{0, 9}});
+
+  BufferedInput input(
+      readFileMock,
+      *pool_,
+      MetricsLog::voidLog(),
+      nullptr,
+      nullptr,
+      10,
+      /*wsVRLoad=*/false);
+
+  const auto ret1 = input.enqueue({0, 3});
+  const auto ret2 = input.enqueue({3, 3});
+  const auto ret3 = input.enqueue({6, 3});
+  ASSERT_NE(ret1, nullptr);
+  ASSERT_NE(ret2, nullptr);
+  ASSERT_NE(ret3, nullptr);
+
+  input.load(LogType::TEST);
+
+  // Only consume the first stream, leave ret2 and ret3 unconsumed.
+  auto next1 = getNext(*ret1);
+  ASSERT_TRUE(next1.has_value());
+  EXPECT_EQ(next1.value(), "aaa");
+
+  // Reset without consuming all streams.
+  input.reset();
+  EXPECT_EQ(input.nextFetchSize(), 0);
+
+  // Second round: enqueue different regions after reset.
+  expectPreads(*readFileMock, content, {{9, 6}});
+
+  const auto ret4 = input.enqueue({9, 6});
+  ASSERT_NE(ret4, nullptr);
+
+  EXPECT_EQ(input.nextFetchSize(), 6);
+  input.load(LogType::TEST);
+
+  const auto next4 = getNext(*ret4);
+  ASSERT_TRUE(next4.has_value());
+  EXPECT_EQ(next4.value(), "dddeee");
+}
+
+TEST_F(BufferedInputTest, preload) {
+  std::string content = "hello world, this is preload test data!";
+  auto readFile =
+      std::make_shared<facebook::velox::tests::utils::CountingReadFile>(
+          content);
+
+  BufferedInput input(
+      readFile,
+      *pool_,
+      MetricsLog::voidLog(),
+      nullptr,
+      nullptr,
+      10,
+      /* wsVRLoad = */ false);
+
+  ASSERT_EQ(readFile->numReads(), 0);
+  EXPECT_FALSE(input.preloaded());
+
+  input.preload();
+  EXPECT_TRUE(input.preloaded());
+
+  const auto readsAfterPreload = readFile->numReads();
+  ASSERT_GT(readsAfterPreload, 0);
+
+  // After preload, sub-region reads should be served from preloaded data.
+  auto stream1 = input.read(0, 5, LogType::FILE);
+  auto next1 = getNext(*stream1);
+  ASSERT_TRUE(next1.has_value());
+  EXPECT_EQ(next1.value(), "hello");
+
+  auto stream2 = input.read(6, 5, LogType::FILE);
+  auto next2 = getNext(*stream2);
+  ASSERT_TRUE(next2.has_value());
+  EXPECT_EQ(next2.value(), "world");
+
+  // No additional file reads after preload.
+  ASSERT_EQ(readFile->numReads(), readsAfterPreload);
+}
+
+class CustomDirectBufferedInput
+    : public facebook::velox::dwio::common::DirectBufferedInput {
+ public:
+  CustomDirectBufferedInput(
+      std::shared_ptr<facebook::velox::ReadFile> readFile,
+      const facebook::velox::dwio::common::MetricsLogPtr& metricsLog,
+      facebook::velox::StringIdLease fileNum,
+      std::shared_ptr<facebook::velox::cache::ScanTracker> tracker,
+      facebook::velox::StringIdLease groupId,
+      std::shared_ptr<facebook::velox::io::IoStatistics> ioStatistics,
+      std::shared_ptr<facebook::velox::IoStats> ioStats,
+      folly::Executor* executor,
+      const facebook::velox::io::ReaderOptions& readerOptions,
+      folly::F14FastMap<std::string, std::string> fileReadOps = {})
+      : DirectBufferedInput(
+            std::move(readFile),
+            metricsLog,
+            std::move(fileNum),
+            std::move(tracker),
+            std::move(groupId),
+            std::move(ioStatistics),
+            std::move(ioStats),
+            executor,
+            readerOptions,
+            std::move(fileReadOps)) {
+    VELOX_NYI("Not implemented in CustomBufferedInputBuilder");
+  }
+
+  std::unique_ptr<facebook::velox::dwio::common::BufferedInput> clone()
+      const override {
+    return std::unique_ptr<facebook::velox::dwio::common::BufferedInput>(
+        new CustomDirectBufferedInput(
+            input_,
+            fileNum_,
+            tracker_,
+            groupId_,
+            ioStatistics_,
+            ioStats_,
+            executor_,
+            options_));
+  }
+
+ protected:
+  // Expose protected members to verify their accessibility.
+  using facebook::velox::dwio::common::DirectBufferedInput::coalescedLoads_;
+  using facebook::velox::dwio::common::DirectBufferedInput::requests_;
+
+ private:
+  CustomDirectBufferedInput(
+      std::shared_ptr<facebook::velox::dwio::common::ReadFileInputStream> input,
+      facebook::velox::StringIdLease fileNum,
+      std::shared_ptr<facebook::velox::cache::ScanTracker> tracker,
+      facebook::velox::StringIdLease groupId,
+      std::shared_ptr<facebook::velox::io::IoStatistics> ioStatistics,
+      std::shared_ptr<facebook::velox::IoStats> ioStats,
+      folly::Executor* executor,
+      const facebook::velox::io::ReaderOptions& readerOptions)
+      : DirectBufferedInput(
+            std::move(input),
+            std::move(fileNum),
+            std::move(tracker),
+            std::move(groupId),
+            std::move(ioStatistics),
+            std::move(ioStats),
+            executor,
+            readerOptions) {}
+};
+
+class CustomBufferedInputBuilder
+    : public facebook::velox::connector::hive::BufferedInputBuilder {
+ public:
+  std::unique_ptr<facebook::velox::dwio::common::BufferedInput> create(
+      const facebook::velox::FileHandle& fileHandle,
+      const facebook::velox::dwio::common::ReaderOptions& readerOpts,
+      const facebook::velox::connector::ConnectorQueryCtx* connectorQueryCtx,
+      std::shared_ptr<facebook::velox::io::IoStatistics> ioStatistics,
+      std::shared_ptr<facebook::velox::IoStats> ioStats,
+      folly::Executor* executor,
+      const folly::F14FastMap<std::string, std::string>& fileReadOps = {})
+      override {
+    auto file = std::make_shared<TestReadFile>(11, 100 << 20, ioStats);
+    auto tracker = std::make_shared<facebook::velox::cache::ScanTracker>(
+        "", nullptr, /*loadQuantum=*/8 << 20);
+    return std::make_unique<CustomDirectBufferedInput>(
+        std::move(file),
+        facebook::velox::dwio::common::MetricsLog::voidLog(),
+        fileHandle.uuid,
+        std::move(tracker),
+        fileHandle.groupId,
+        std::move(ioStatistics),
+        std::move(ioStats),
+        executor,
+        readerOpts,
+        fileReadOps);
+  }
+};
+
+class CustomBufferedInputTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    MemoryManager::testingSetInstance(MemoryManager::Options{});
+    facebook::velox::connector::hive::BufferedInputBuilder::registerBuilder(
+        std::make_shared<CustomBufferedInputBuilder>());
+  }
+
+  const std::shared_ptr<MemoryPool> pool_ = memoryManager()->addLeafPool();
+  std::shared_ptr<facebook::velox::io::IoStatistics> dataIoStats_{
+      std::make_shared<facebook::velox::io::IoStatistics>()};
+  std::shared_ptr<facebook::velox::io::IoStatistics> metadataIoStats_{
+      std::make_shared<facebook::velox::io::IoStatistics>()};
+};
+
+} // namespace
+
+TEST_F(CustomBufferedInputTest, basic) {
+  facebook::velox::FileHandle fileHandle;
+  facebook::velox::dwio::common::ReaderOptions readerOpts(pool_.get());
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
+  auto ioStatistics = std::make_shared<facebook::velox::io::IoStatistics>();
+  auto ioStats = std::make_shared<facebook::velox::IoStats>();
+  auto executor = std::make_unique<folly::IOThreadPoolExecutor>(10, 10);
+
+  VELOX_ASSERT_THROW(
+      facebook::velox::connector::hive::BufferedInputBuilder::getInstance()
+          ->create(
+              fileHandle, readerOpts, nullptr, ioStatistics, ioStats, nullptr),
+      "Not implemented in CustomBufferedInputBuilder");
+}
diff --git a/velox/dwio/common/tests/CMakeLists.txt b/velox/dwio/common/tests/CMakeLists.txt
index b65afce1367..ccf991c6daf 100644
--- a/velox/dwio/common/tests/CMakeLists.txt
+++ b/velox/dwio/common/tests/CMakeLists.txt
@@ -14,6 +14,7 @@
 
 add_subdirectory(utils)
 add_library(velox_dwio_faulty_file_sink FaultyFileSink.cpp)
+velox_add_test_headers(velox_dwio_faulty_file_sink FaultyFileSink.h)
 target_link_libraries(velox_dwio_faulty_file_sink velox_file_test_utils velox_dwio_common)
 
 # There is an issue with the VTT symbol for the InlineExecutor from folly when
@@ -38,6 +39,7 @@ add_executable(
   DecoderUtilTest.cpp
   ExecutorBarrierTest.cpp
   OnDemandUnitLoaderTests.cpp
+  ParallelUnitLoaderTest.cpp
   LocalFileSinkTest.cpp
   MemorySinkTest.cpp
   LoggedExceptionTest.cpp
@@ -48,21 +50,26 @@ add_executable(
   ReaderTest.cpp
   RetryTests.cpp
   ScanSpecTest.cpp
+  SelectiveColumnReaderTest.cpp
   SortingWriterTest.cpp
-  TestBufferedInput.cpp
+  StreamUtilTest.cpp
+  BufferedInputTest.cpp
+  CachedBufferedInputTest.cpp
+  DirectBufferedInputTest.cpp
   ThrottlerTest.cpp
   TypeTests.cpp
   UnitLoaderToolsTests.cpp
   WriterTest.cpp
   OptionsTests.cpp
 )
+velox_add_test_headers(velox_dwio_common_test UnitLoaderBaseTest.h)
 add_test(velox_dwio_common_test velox_dwio_common_test)
 target_link_libraries(
   velox_dwio_common_test
   velox_dwio_common_test_utils
-  velox_temp_path
+  velox_hive_connector
+  velox_test_util
   velox_vector_test_lib
-  Boost::regex
   velox_link_libs
   Folly::folly
   ${TEST_LINK_LIBS}
@@ -97,7 +104,7 @@ if(VELOX_ENABLE_BENCHMARKS)
   )
 
   if(VELOX_ENABLE_ARROW)
-    add_subdirectory(Lemire/FastPFor)
+    add_subdirectory(Lemire)
     add_executable(velox_dwio_common_bitpack_decoder_benchmark BitPackDecoderBenchmark.cpp)
 
     target_compile_options(
diff --git a/velox/dwio/common/tests/CachedBufferedInputTest.cpp b/velox/dwio/common/tests/CachedBufferedInputTest.cpp
new file mode 100644
index 00000000000..a1caeca3728
--- /dev/null
+++ b/velox/dwio/common/tests/CachedBufferedInputTest.cpp
@@ -0,0 +1,1733 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/common/CachedBufferedInput.h"
+
+#include <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/caching/FileIds.h"
+#include "velox/common/file/tests/TestUtils.h"
+#include "velox/common/io/IoStatistics.h"
+#include "velox/common/io/Options.h"
+#include "velox/common/memory/MallocAllocator.h"
+#include "velox/common/testutil/TestValue.h"
+
+#include <folly/executors/CPUThreadPoolExecutor.h>
+#include <folly/io/IOBuf.h>
+#include <folly/synchronization/Baton.h>
+
+#include <thread>
+
+using namespace facebook::velox;
+using namespace facebook::velox::dwio::common;
+using namespace facebook::velox::cache;
+using namespace facebook::velox::memory;
+using facebook::velox::common::testutil::TestValue;
+
+namespace {
+
+std::optional<std::string> getNext(SeekableInputStream& input) {
+  const void* buf = nullptr;
+  int32_t size;
+  if (input.Next(&buf, &size)) {
+    return std::string(
+        static_cast<const char*>(buf), static_cast<size_t>(size));
+  } else {
+    return std::nullopt;
+  }
+}
+
+class CachedBufferedInputTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    TestValue::enable();
+    MemoryManager::testingSetInstance(MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    executor_ = std::make_unique<folly::CPUThreadPoolExecutor>(10);
+    allocator_ = std::make_shared<MallocAllocator>(MemoryAllocator::Options{
+        .capacity = 512 << 20, .reservationByteLimit = 0});
+    cache_ = AsyncDataCache::create(allocator_.get());
+    tracker_ = std::make_shared<ScanTracker>(
+        "testTracker", nullptr, 256 << 10 /* 256KB */);
+    pool_ = memoryManager()->addLeafPool();
+  }
+
+  void TearDown() override {
+    executor_.reset();
+    cache_->shutdown();
+    cache_.reset();
+    allocator_.reset();
+  }
+
+  const std::shared_ptr<IoStatistics> dataIoStats_{
+      std::make_shared<IoStatistics>()};
+  const std::shared_ptr<IoStatistics> metadataIoStats_{
+      std::make_shared<IoStatistics>()};
+
+  std::unique_ptr<folly::CPUThreadPoolExecutor> executor_;
+  std::shared_ptr<MemoryPool> pool_;
+  std::shared_ptr<MallocAllocator> allocator_;
+  std::shared_ptr<AsyncDataCache> cache_;
+  std::shared_ptr<ScanTracker> tracker_;
+};
+
+enum class CacheRegionApi {
+  kStringView,
+  kIOBuf,
+};
+
+std::string cacheRegionApiString(CacheRegionApi api) {
+  switch (api) {
+    case CacheRegionApi::kStringView:
+      return "StringView";
+    case CacheRegionApi::kIOBuf:
+      return "IOBuf";
+  }
+  VELOX_UNREACHABLE();
+}
+
+class CacheRegionTest : public CachedBufferedInputTest,
+                        public testing::WithParamInterface<CacheRegionApi> {
+ protected:
+  // Calls cacheRegion using the API selected by the test parameter.
+  // For IOBuf mode, splits the source data into multiple chained buffers
+  // to exercise the multi-buffer path.
+  void cacheRegionWithApi(
+      CachedBufferedInput& input,
+      uint64_t offset,
+      uint64_t length,
+      const char* data) {
+    switch (GetParam()) {
+      case CacheRegionApi::kStringView: {
+        input.cacheRegion(offset, length, std::string_view(data, length));
+        break;
+      }
+      case CacheRegionApi::kIOBuf: {
+        // Split data into 3 chained IOBufs to exercise multi-buffer cursor
+        // path. Also prepend a prefix to exercise non-zero bufferOffset.
+        constexpr uint64_t kPrefix = 37;
+        const std::string prefix(kPrefix, 'Z');
+        const uint64_t chunk1 = length / 3;
+        const uint64_t chunk2 = length / 3;
+        const uint64_t chunk3 = length - chunk1 - chunk2;
+
+        auto iobuf = folly::IOBuf::copyBuffer(prefix);
+        iobuf->appendToChain(folly::IOBuf::copyBuffer(data, chunk1));
+        iobuf->appendToChain(folly::IOBuf::copyBuffer(data + chunk1, chunk2));
+        iobuf->appendToChain(
+            folly::IOBuf::copyBuffer(data + chunk1 + chunk2, chunk3));
+        ASSERT_EQ(iobuf->computeChainDataLength(), kPrefix + length);
+        input.cacheRegion(offset, length, *iobuf, kPrefix);
+        break;
+      }
+    }
+  }
+};
+
+TEST_F(CachedBufferedInputTest, reset) {
+  constexpr int32_t kContentSize = 4 << 20; // 4MB
+  std::string content;
+  content.resize(kContentSize);
+  for (int32_t i = 0; i < kContentSize; ++i) {
+    content[i] = static_cast<char>('a' + (i % 26));
+  }
+  auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  readerOptions.setLoadQuantum(1 << 20);
+
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "testFile");
+  StringIdLease groupId(ids, "testGroup");
+
+  CachedBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      cache_.get(),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  // First round: enqueue and load streams.
+  constexpr int32_t kRegionSize = 8 << 10; // 8KB
+  auto stream1 = input.enqueue({0, kRegionSize}, nullptr);
+  auto stream2 = input.enqueue({kRegionSize, kRegionSize}, nullptr);
+  ASSERT_NE(stream1, nullptr);
+  ASSERT_NE(stream2, nullptr);
+
+  // Verify cache is empty before load.
+  auto stats = cache_->refreshStats();
+  EXPECT_EQ(stats.numEntries, 0);
+
+  input.load(LogType::TEST);
+
+  EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 2);
+  EXPECT_EQ(input.testingCoalescedLoads().size(), 1);
+
+  // Wait until cache has two entries after load.
+  while (cache_->refreshStats().numEntries != 2) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  }
+  stats = cache_->refreshStats();
+  EXPECT_EQ(stats.numEntries, 2);
+
+  EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 2);
+  EXPECT_EQ(input.testingCoalescedLoads().size(), 1);
+
+  // Consume streams.
+  auto next1 = getNext(*stream1);
+  ASSERT_TRUE(next1.has_value());
+  EXPECT_EQ(next1.value(), content.substr(0, kRegionSize));
+  EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 0);
+  EXPECT_EQ(input.testingCoalescedLoads().size(), 1);
+
+  stats = cache_->refreshStats();
+  EXPECT_EQ(stats.numEntries, 2);
+
+  auto next2 = getNext(*stream2);
+  ASSERT_TRUE(next2.has_value());
+  EXPECT_EQ(next2.value(), content.substr(kRegionSize, kRegionSize));
+  EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 0);
+  EXPECT_EQ(input.testingCoalescedLoads().size(), 1);
+
+  stream1.reset();
+  stream2.reset();
+
+  EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 0);
+  EXPECT_EQ(input.testingCoalescedLoads().size(), 1);
+
+  stats = cache_->refreshStats();
+  EXPECT_EQ(stats.sharedPinnedBytes, 0);
+  EXPECT_EQ(stats.exclusivePinnedBytes, 0);
+  EXPECT_EQ(stats.numEntries, 2);
+
+  // Reset the input.
+  input.reset();
+
+  EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 0);
+  EXPECT_EQ(input.testingCoalescedLoads().size(), 0);
+
+  stats = cache_->refreshStats();
+  EXPECT_EQ(stats.sharedPinnedBytes, 0);
+  EXPECT_EQ(stats.exclusivePinnedBytes, 0);
+  EXPECT_EQ(stats.numEntries, 2);
+
+  // Second round: enqueue different regions after reset.
+  auto stream3 = input.enqueue({2 * kRegionSize, kRegionSize}, nullptr);
+  auto stream4 = input.enqueue({3 * kRegionSize, kRegionSize}, nullptr);
+  ASSERT_NE(stream3, nullptr);
+  ASSERT_NE(stream4, nullptr);
+
+  stats = cache_->refreshStats();
+  EXPECT_EQ(stats.sharedPinnedBytes, 0);
+  EXPECT_EQ(stats.exclusivePinnedBytes, 0);
+  EXPECT_EQ(stats.numEntries, 2);
+
+  input.load(LogType::TEST);
+
+  // Wait until cache has two entries after load.
+  while (cache_->refreshStats().numEntries != 4) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  }
+  stats = cache_->refreshStats();
+  EXPECT_EQ(stats.numEntries, 4);
+
+  auto next3 = getNext(*stream3);
+  ASSERT_TRUE(next3.has_value());
+  EXPECT_EQ(next3.value(), content.substr(2 * kRegionSize, kRegionSize));
+
+  auto next4 = getNext(*stream4);
+  ASSERT_TRUE(next4.has_value());
+  EXPECT_EQ(next4.value(), content.substr(3 * kRegionSize, kRegionSize));
+
+  // Reset the input.
+  input.reset();
+
+  stats = cache_->refreshStats();
+  EXPECT_GT(stats.sharedPinnedBytes, 0);
+  EXPECT_EQ(stats.exclusivePinnedBytes, 0);
+  EXPECT_EQ(stats.numEntries, 4);
+
+  stream3.reset();
+  stream4.reset();
+
+  stats = cache_->refreshStats();
+  EXPECT_EQ(stats.sharedPinnedBytes, 0);
+  EXPECT_EQ(stats.exclusivePinnedBytes, 0);
+  EXPECT_EQ(stats.numEntries, 4);
+}
+
+TEST_F(CachedBufferedInputTest, readAfterReset) {
+  constexpr int32_t kContentSize = 4 << 20; // 4MB
+  std::string content;
+  content.resize(kContentSize);
+  for (int32_t i = 0; i < kContentSize; ++i) {
+    content[i] = static_cast<char>('a' + (i % 26));
+  }
+  auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  readerOptions.setLoadQuantum(1 << 20);
+
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "testFile");
+  StringIdLease groupId(ids, "testGroup");
+
+  CachedBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      cache_.get(),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  constexpr int32_t kRegionSize = 8 << 10; // 8KB
+
+  // Enqueue and load streams.
+  auto stream1 = input.enqueue({0, kRegionSize}, nullptr);
+  auto stream2 = input.enqueue({kRegionSize, kRegionSize}, nullptr);
+  ASSERT_NE(stream1, nullptr);
+  ASSERT_NE(stream2, nullptr);
+
+  input.load(LogType::TEST);
+
+  // Wait until cache has two entries after load.
+  while (cache_->refreshStats().numEntries != 2) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  }
+  auto stats = cache_->refreshStats();
+  EXPECT_EQ(stats.numEntries, 2);
+
+  // Reset the input before reading from streams.
+  input.reset();
+  EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 0);
+  EXPECT_EQ(input.testingCoalescedLoads().size(), 0);
+
+  stats = cache_->refreshStats();
+  EXPECT_EQ(stats.numEntries, 2);
+
+  // Read from streams after reset - data should still be available from cache.
+  auto next1 = getNext(*stream1);
+  ASSERT_TRUE(next1.has_value());
+  EXPECT_EQ(next1.value(), content.substr(0, kRegionSize));
+
+  auto next2 = getNext(*stream2);
+  ASSERT_TRUE(next2.has_value());
+  EXPECT_EQ(next2.value(), content.substr(kRegionSize, kRegionSize));
+
+  EXPECT_EQ(stats.sharedPinnedBytes, 0);
+  EXPECT_EQ(stats.exclusivePinnedBytes, 0);
+  EXPECT_EQ(stats.numEntries, 2);
+}
+
+DEBUG_ONLY_TEST_F(CachedBufferedInputTest, resetInputWithBeforeLoading) {
+  constexpr int32_t kContentSize = 4 << 20; // 4MB
+  std::string content;
+  content.resize(kContentSize);
+  for (int32_t i = 0; i < kContentSize; ++i) {
+    content[i] = static_cast<char>('a' + (i % 26));
+  }
+  auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  readerOptions.setLoadQuantum(1 << 20);
+
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "testFile");
+  StringIdLease groupId(ids, "testGroup");
+
+  CachedBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      cache_.get(),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  constexpr int32_t kRegionSize = 8 << 10; // 8KB
+
+  // Block the coalesced load to verify cache references are held.
+  folly::Baton<> loadStarted;
+  folly::Baton<> loadAllowed;
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::cache::CoalescedLoad::loadOrFuture",
+      std::function<void(const CoalescedLoad*)>(
+          [&](const CoalescedLoad* /*load*/) {
+            loadStarted.post();
+            loadAllowed.wait();
+          }));
+
+  // Enqueue and load streams.
+  auto stream1 = input.enqueue({0, kRegionSize}, nullptr);
+  auto stream2 = input.enqueue({kRegionSize, kRegionSize}, nullptr);
+  ASSERT_NE(stream1, nullptr);
+  ASSERT_NE(stream2, nullptr);
+
+  input.load(LogType::TEST);
+
+  // Wait for the load to start (but it's blocked).
+  loadStarted.wait();
+
+  // Verify cache is still empty (load is pending).
+  auto stats = cache_->refreshStats();
+  EXPECT_EQ(stats.numEntries, 0);
+  EXPECT_EQ(stats.numExclusive, 0);
+
+  // Verify coalesced load references are held.
+  EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 2);
+  EXPECT_EQ(input.testingCoalescedLoads().size(), 1);
+
+  // Reset the input while load is pending.
+  input.reset();
+
+  stats = cache_->refreshStats();
+  EXPECT_EQ(stats.numEntries, 0);
+  EXPECT_EQ(stats.numExclusive, 0);
+
+  // After reset, internal tracking should be cleared.
+  EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 0);
+  EXPECT_EQ(input.testingCoalescedLoads().size(), 0);
+
+  // Allow the load to proceed but cancelled.
+  loadAllowed.post();
+
+  std::this_thread::sleep_for(std::chrono::seconds(1));
+
+  stats = cache_->refreshStats();
+  EXPECT_EQ(stats.numEntries, 0);
+  EXPECT_EQ(stats.numExclusive, 0);
+
+  // Read from streams - data should be available from cache.
+  auto next1 = getNext(*stream1);
+  ASSERT_TRUE(next1.has_value());
+  EXPECT_EQ(next1.value(), content.substr(0, kRegionSize));
+
+  auto next2 = getNext(*stream2);
+  ASSERT_TRUE(next2.has_value());
+  EXPECT_EQ(next2.value(), content.substr(kRegionSize, kRegionSize));
+
+  stats = cache_->refreshStats();
+  EXPECT_EQ(stats.numEntries, 2);
+  EXPECT_EQ(stats.numExclusive, 0);
+}
+
+DEBUG_ONLY_TEST_F(CachedBufferedInputTest, resetInputWithAfterLoading) {
+  constexpr int32_t kContentSize = 4 << 20; // 4MB
+  std::string content;
+  content.resize(kContentSize);
+  for (int32_t i = 0; i < kContentSize; ++i) {
+    content[i] = static_cast<char>('a' + (i % 26));
+  }
+  auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  readerOptions.setLoadQuantum(1 << 20);
+
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "testFile");
+  StringIdLease groupId(ids, "testGroup");
+
+  CachedBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      cache_.get(),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  constexpr int32_t kRegionSize = 8 << 10; // 8KB
+
+  // Block the coalesced load to verify cache references are held.
+  folly::Baton<> loadStarted;
+  folly::Baton<> loadAllowed;
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::cache::CoalescedLoad::loadOrFuture::loading",
+      std::function<void(const CoalescedLoad*)>(
+          [&](const CoalescedLoad* /*load*/) {
+            loadStarted.post();
+            loadAllowed.wait();
+          }));
+
+  // Enqueue and load streams.
+  auto stream1 = input.enqueue({0, kRegionSize}, nullptr);
+  auto stream2 = input.enqueue({kRegionSize, kRegionSize}, nullptr);
+  ASSERT_NE(stream1, nullptr);
+  ASSERT_NE(stream2, nullptr);
+
+  input.load(LogType::TEST);
+
+  // Wait for the load to start (but it's blocked).
+  loadStarted.wait();
+
+  // Verify cache is still empty (load is pending).
+  auto stats = cache_->refreshStats();
+  EXPECT_EQ(stats.numEntries, 0);
+  EXPECT_EQ(stats.numExclusive, 0);
+
+  // Verify coalesced load references are held.
+  EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 2);
+  EXPECT_EQ(input.testingCoalescedLoads().size(), 1);
+
+  // Reset the input while load is pending.
+  input.reset();
+
+  stats = cache_->refreshStats();
+  EXPECT_EQ(stats.numEntries, 0);
+  EXPECT_EQ(stats.numExclusive, 0);
+
+  // After reset, internal tracking should be cleared.
+  EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 0);
+  EXPECT_EQ(input.testingCoalescedLoads().size(), 0);
+
+  // Allow the load to proceed without cancelling.
+  loadAllowed.post();
+
+  // Wait until cache has two entries after load.
+  while (cache_->refreshStats().numEntries != 2) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  }
+
+  stats = cache_->refreshStats();
+  EXPECT_EQ(stats.numEntries, 2);
+  EXPECT_EQ(stats.numExclusive, 0);
+
+  // Read from streams - data should be available from cache.
+  auto next1 = getNext(*stream1);
+  ASSERT_TRUE(next1.has_value());
+  EXPECT_EQ(next1.value(), content.substr(0, kRegionSize));
+
+  auto next2 = getNext(*stream2);
+  ASSERT_TRUE(next2.has_value());
+  EXPECT_EQ(next2.value(), content.substr(kRegionSize, kRegionSize));
+
+  stats = cache_->refreshStats();
+  EXPECT_EQ(stats.numEntries, 2);
+  EXPECT_EQ(stats.numExclusive, 0);
+}
+
+TEST_F(CachedBufferedInputTest, hasCache) {
+  constexpr int32_t kContentSize = 1 << 20;
+  std::string content;
+  content.resize(kContentSize);
+  auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "testFile");
+  StringIdLease groupId(ids, "testGroup");
+
+  CachedBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      cache_.get(),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  // CachedBufferedInput always has cache.
+  EXPECT_TRUE(input.hasCache());
+}
+
+TEST_P(CacheRegionTest, cacheAndFind) {
+  SCOPED_TRACE(cacheRegionApiString(GetParam()));
+  constexpr int32_t kContentSize = 1 << 20; // 1MB
+  std::string content;
+  content.resize(kContentSize);
+  for (int32_t i = 0; i < kContentSize; ++i) {
+    content[i] = static_cast<char>('a' + (i % 26));
+  }
+  auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "testFile_cacheAndFind");
+  StringIdLease groupId(ids, "testGroup_cacheAndFind");
+
+  CachedBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      cache_.get(),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  // Initially no regions are cached.
+  EXPECT_FALSE(input.findCachedRegion(0).has_value());
+  EXPECT_FALSE(input.findCachedRegion(1000).has_value());
+
+  // Cache a small region (fits in tinyData path).
+  constexpr uint64_t kSmallSize = 100;
+  cacheRegionWithApi(input, 0, kSmallSize, content.data());
+
+  EXPECT_TRUE(input.findCachedRegion(0).has_value());
+  EXPECT_FALSE(input.findCachedRegion(1000).has_value());
+
+  // Verify cached data is readable via read().
+  auto stream = input.read(0, kSmallSize, LogType::FILE);
+  auto next = getNext(*stream);
+  ASSERT_TRUE(next.has_value());
+  EXPECT_EQ(next.value(), content.substr(0, kSmallSize));
+
+  // Cache a larger region.
+  constexpr uint64_t kLargeOffset = 1000;
+  constexpr uint64_t kLargeSize = 64 * 1024; // 64KB
+  cacheRegionWithApi(
+      input, kLargeOffset, kLargeSize, content.data() + kLargeOffset);
+
+  EXPECT_TRUE(input.findCachedRegion(kLargeOffset).has_value());
+
+  // Verify large cached data is readable.
+  auto stream2 = input.read(kLargeOffset, kLargeSize, LogType::FILE);
+  std::string readBack;
+  readBack.resize(kLargeSize);
+  stream2->readFully(readBack.data(), kLargeSize);
+  EXPECT_EQ(readBack, content.substr(kLargeOffset, kLargeSize));
+
+  // Caching the same region again is a no-op (already cached).
+  cacheRegionWithApi(input, 0, kSmallSize, content.data());
+  EXPECT_TRUE(input.findCachedRegion(0).has_value());
+
+  auto stats = cache_->refreshStats();
+  EXPECT_EQ(stats.numEntries, 2);
+}
+
+TEST_P(CacheRegionTest, smallEntry) {
+  SCOPED_TRACE(cacheRegionApiString(GetParam()));
+  constexpr int32_t kContentSize = 1 << 20;
+  std::string content;
+  content.resize(kContentSize);
+  for (int32_t i = 0; i < kContentSize; ++i) {
+    content[i] = static_cast<char>('a' + (i % 26));
+  }
+  auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "testFile_smallEntry");
+  StringIdLease groupId(ids, "testGroup_smallEntry");
+
+  CachedBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      cache_.get(),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  constexpr uint64_t kOffset = 0;
+  constexpr uint64_t kSize = 100;
+  static_assert(kSize < AsyncDataCacheEntry::kTinyDataSize);
+
+  EXPECT_FALSE(input.findCachedRegion(kOffset).has_value());
+
+  cacheRegionWithApi(input, kOffset, kSize, content.data() + kOffset);
+
+  // First findCachedRegion after cacheRegion should count as a cache hit since
+  // cacheRegion clears the first-use flag (data was populated externally, not
+  // loaded on-demand).
+  EXPECT_EQ(dataIoStats_->ramHit().count(), 0);
+  auto result = input.findCachedRegion(kOffset);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_EQ(result->size(), kSize);
+  EXPECT_EQ(dataIoStats_->ramHit().count(), 1);
+  EXPECT_EQ(dataIoStats_->ramHit().sum(), kSize);
+
+  // Second findCachedRegion is also a cache hit.
+  auto result2 = input.findCachedRegion(kOffset);
+  ASSERT_TRUE(result2.has_value());
+  EXPECT_EQ(dataIoStats_->ramHit().count(), 2);
+  EXPECT_EQ(dataIoStats_->ramHit().sum(), 2 * kSize);
+
+  // Small entry should have exactly one contiguous range.
+  const auto& ranges = result->ranges();
+  ASSERT_EQ(ranges.size(), 1);
+  EXPECT_EQ(ranges[0].size(), kSize);
+  EXPECT_EQ(
+      std::string_view(ranges[0].data(), ranges[0].size()),
+      std::string_view(content.data() + kOffset, kSize));
+
+  // toIOBuf on a small (single-range) entry produces a single IOBuf.
+  auto iobuf = result->toIOBuf();
+  EXPECT_FALSE(iobuf.isChained());
+  EXPECT_EQ(iobuf.length(), kSize);
+  EXPECT_EQ(
+      std::string_view(
+          reinterpret_cast<const char*>(iobuf.data()), iobuf.length()),
+      std::string_view(content.data() + kOffset, kSize));
+}
+
+TEST_P(CacheRegionTest, largeEntry) {
+  SCOPED_TRACE(cacheRegionApiString(GetParam()));
+  constexpr int32_t kContentSize = 1 << 20;
+  std::string content;
+  content.resize(kContentSize);
+  for (int32_t i = 0; i < kContentSize; ++i) {
+    content[i] = static_cast<char>('a' + (i % 26));
+  }
+  auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "testFile_largeEntry");
+  StringIdLease groupId(ids, "testGroup_largeEntry");
+
+  CachedBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      cache_.get(),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  constexpr uint64_t kOffset = 0;
+  constexpr uint64_t kSize = 64 * 1024; // 64KB
+  static_assert(kSize >= AsyncDataCacheEntry::kTinyDataSize);
+
+  cacheRegionWithApi(input, kOffset, kSize, content.data() + kOffset);
+
+  auto result = input.findCachedRegion(kOffset);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_EQ(result->size(), kSize);
+
+  // Large entry may have multiple ranges. Verify total size and content.
+  const auto& ranges = result->ranges();
+  ASSERT_GT(ranges.size(), 0);
+
+  uint64_t totalSize = 0;
+  std::string reassembled;
+  reassembled.reserve(kSize);
+  for (const auto& range : ranges) {
+    EXPECT_GT(range.size(), 0);
+    reassembled.append(range.data(), range.size());
+    totalSize += range.size();
+  }
+  EXPECT_EQ(totalSize, kSize);
+  EXPECT_EQ(reassembled, content.substr(kOffset, kSize));
+
+  // toIOBuf total length matches and content matches.
+  auto iobuf = result->toIOBuf();
+  EXPECT_EQ(iobuf.computeChainDataLength(), kSize);
+
+  std::string fromIobuf;
+  fromIobuf.reserve(kSize);
+  const auto* current = &iobuf;
+  do {
+    fromIobuf.append(
+        reinterpret_cast<const char*>(current->data()), current->length());
+    current = current->next();
+  } while (current != &iobuf);
+  EXPECT_EQ(fromIobuf, content.substr(kOffset, kSize));
+}
+
+TEST_P(CacheRegionTest, miss) {
+  SCOPED_TRACE(cacheRegionApiString(GetParam()));
+  constexpr int32_t kContentSize = 1 << 20;
+  std::string content(kContentSize, 'x');
+  auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "testFile_miss");
+  StringIdLease groupId(ids, "testGroup_miss");
+
+  CachedBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      cache_.get(),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  EXPECT_FALSE(input.findCachedRegion(0).has_value());
+  EXPECT_FALSE(input.findCachedRegion(12345).has_value());
+}
+
+TEST_P(CacheRegionTest, pinKeepsDataAlive) {
+  SCOPED_TRACE(cacheRegionApiString(GetParam()));
+  constexpr int32_t kContentSize = 1 << 20;
+  std::string content;
+  content.resize(kContentSize);
+  for (int32_t i = 0; i < kContentSize; ++i) {
+    content[i] = static_cast<char>('a' + (i % 26));
+  }
+  auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "testFile_pinAlive");
+  StringIdLease groupId(ids, "testGroup_pinAlive");
+
+  CachedBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      cache_.get(),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  constexpr uint64_t kSize = 100;
+  cacheRegionWithApi(input, 0, kSize, content.data());
+
+  auto cached = input.findCachedRegion(0);
+  ASSERT_TRUE(cached.has_value());
+
+  auto stats = cache_->refreshStats();
+  EXPECT_GT(stats.sharedPinnedBytes, 0);
+
+  const auto& ranges = cached->ranges();
+  ASSERT_EQ(ranges.size(), 1);
+  EXPECT_EQ(
+      std::string_view(ranges[0].data(), ranges[0].size()),
+      std::string_view(content.data(), kSize));
+
+  // Move into a new optional — pin transfers, data stays valid.
+  auto moved = std::move(cached);
+  ASSERT_TRUE(moved.has_value());
+  EXPECT_EQ(moved->size(), kSize);
+  EXPECT_EQ(moved->ranges().size(), 1);
+  EXPECT_EQ(
+      std::string_view(moved->ranges()[0].data(), moved->ranges()[0].size()),
+      std::string_view(content.data(), kSize));
+
+  stats = cache_->refreshStats();
+  EXPECT_GT(stats.sharedPinnedBytes, 0);
+
+  // Dropping the moved CachedRegion releases the pin.
+  moved.reset();
+  stats = cache_->refreshStats();
+  EXPECT_EQ(stats.sharedPinnedBytes, 0);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    CacheRegionTest,
+    CacheRegionTest,
+    testing::Values(CacheRegionApi::kStringView, CacheRegionApi::kIOBuf),
+    [](const testing::TestParamInfo<CacheRegionApi>& info) {
+      return cacheRegionApiString(info.param);
+    });
+
+TEST_F(CachedBufferedInputTest, findCachedRegionExclusiveWithWait) {
+  constexpr int32_t kContentSize = 1 << 20;
+  std::string content;
+  content.resize(kContentSize);
+  for (int32_t i = 0; i < kContentSize; ++i) {
+    content[i] = static_cast<char>('a' + (i % 26));
+  }
+  auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  auto& ids = fileIds();
+  const std::string fileName = "testFile_findWait";
+  StringIdLease fileId(ids, fileName);
+  StringIdLease groupId(ids, "testGroup_findWait");
+
+  CachedBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      cache_.get(),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  constexpr uint64_t kOffset = 0;
+  constexpr uint64_t kSize = 100;
+
+  // Create an exclusive entry using the same file ID as the
+  // CachedBufferedInput.
+  StringIdLease sameFileId(ids, fileName);
+  RawFileCacheKey key{sameFileId.id(), kOffset};
+  auto exclusivePin = cache_->findOrCreate(key, kSize);
+  ASSERT_FALSE(exclusivePin.empty());
+  ASSERT_TRUE(exclusivePin.entry()->isExclusive());
+
+  // Verify latency counters are initially zero.
+  EXPECT_EQ(dataIoStats_->cacheWaitLatencyUs().count(), 0);
+  EXPECT_EQ(dataIoStats_->queryThreadIoLatencyUs().count(), 0);
+
+  // Spawn a thread that calls findCachedRegion — it will block waiting for
+  // the exclusive entry to become shared.
+  std::atomic_bool findFinished{false};
+  std::optional<CachedRegion> findResult;
+  std::thread findThread([&]() {
+    findResult = input.findCachedRegion(kOffset);
+    findFinished.store(true, std::memory_order_release);
+  });
+
+  // Give the thread time to enter the wait state.
+  std::this_thread::sleep_for(std::chrono::milliseconds(200));
+  ASSERT_FALSE(findFinished.load(std::memory_order_acquire));
+
+  // Populate the entry and transition to shared.
+  auto* entry = exclusivePin.entry();
+  ASSERT_LT(kSize, AsyncDataCacheEntry::kTinyDataSize);
+  ::memcpy(entry->contiguousData(), content.data() + kOffset, kSize);
+  entry->setExclusiveToShared();
+  exclusivePin.clear();
+
+  // The findCachedRegion thread should now complete.
+  findThread.join();
+  ASSERT_TRUE(findFinished.load(std::memory_order_acquire));
+
+  // Verify the latency counters were incremented.
+  EXPECT_EQ(dataIoStats_->cacheWaitLatencyUs().count(), 1);
+  EXPECT_GT(dataIoStats_->cacheWaitLatencyUs().sum(), 0);
+  EXPECT_EQ(dataIoStats_->queryThreadIoLatencyUs().count(), 1);
+  EXPECT_GT(dataIoStats_->queryThreadIoLatencyUs().sum(), 0);
+
+  // Verify the returned CachedRegion has correct data.
+  ASSERT_TRUE(findResult.has_value());
+  EXPECT_EQ(findResult->size(), kSize);
+  const auto& ranges = findResult->ranges();
+  ASSERT_EQ(ranges.size(), 1);
+  EXPECT_EQ(
+      std::string_view(ranges[0].data(), ranges[0].size()),
+      std::string_view(content.data() + kOffset, kSize));
+}
+
+TEST_F(CachedBufferedInputTest, cacheRegionSkipsOngoingInsert) {
+  constexpr int32_t kContentSize = 1 << 20;
+  std::string content;
+  content.resize(kContentSize);
+  for (int32_t i = 0; i < kContentSize; ++i) {
+    content[i] = static_cast<char>('a' + (i % 26));
+  }
+  auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  auto& ids = fileIds();
+  const std::string fileName = "testFile_skipInsert";
+  StringIdLease fileId(ids, fileName);
+  StringIdLease groupId(ids, "testGroup_skipInsert");
+
+  CachedBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      cache_.get(),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  constexpr uint64_t kOffset = 0;
+  constexpr uint64_t kSize = 100;
+
+  // Simulate an ongoing insert by creating an exclusive entry directly.
+  StringIdLease sameFileId(ids, fileName);
+  RawFileCacheKey key{sameFileId.id(), kOffset};
+  auto exclusivePin = cache_->findOrCreate(key, kSize);
+  ASSERT_FALSE(exclusivePin.empty());
+  ASSERT_TRUE(exclusivePin.entry()->isExclusive());
+
+  // cacheRegion with different data should return immediately without blocking
+  // or overwriting (the entry is already exclusively held by another
+  // operation).
+  const std::string differentData(kSize, 'X');
+  input.cacheRegion(kOffset, kSize, std::string_view(differentData));
+
+  // The entry should still be exclusive — cacheRegion gave up.
+  ASSERT_TRUE(exclusivePin.entry()->isExclusive());
+
+  // Complete the original insert with the real data.
+  auto* entry = exclusivePin.entry();
+  ASSERT_LT(kSize, AsyncDataCacheEntry::kTinyDataSize);
+  ::memcpy(entry->contiguousData(), content.data() + kOffset, kSize);
+  entry->setExclusiveToShared();
+  exclusivePin.clear();
+
+  // findCachedRegion should return the original data, not the 'X' data
+  // that cacheRegion tried to write.
+  auto cached = input.findCachedRegion(kOffset);
+  ASSERT_TRUE(cached.has_value());
+  EXPECT_EQ(cached->size(), kSize);
+  const auto& ranges = cached->ranges();
+  ASSERT_EQ(ranges.size(), 1);
+  EXPECT_EQ(
+      std::string_view(ranges[0].data(), ranges[0].size()),
+      std::string_view(content.data() + kOffset, kSize));
+  // Verify it's NOT the data passed to cacheRegion.
+  EXPECT_NE(
+      std::string_view(ranges[0].data(), ranges[0].size()),
+      std::string_view(differentData));
+}
+
+TEST_F(CachedBufferedInputTest, preloadCalledTwice) {
+  std::string content(1024, 'x');
+  auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "preloadTwice");
+  StringIdLease groupId(ids, "preloadTwiceGroup");
+
+  CachedBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      cache_.get(),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  input.preload();
+  ASSERT_TRUE(input.preloaded());
+  VELOX_ASSERT_THROW(input.preload(), "preload() called more than once");
+}
+
+TEST_F(CachedBufferedInputTest, isBufferedWithPreload) {
+  std::string content(1024, 'x');
+  auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "isBufferedPreload");
+  StringIdLease groupId(ids, "isBufferedPreloadGroup");
+
+  CachedBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      cache_.get(),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  // Before preload, isBuffered should return false.
+  EXPECT_FALSE(input.isBuffered(0, 100));
+
+  input.preload();
+  ASSERT_TRUE(input.preloaded());
+
+  // After preload, isBuffered should return true.
+  EXPECT_TRUE(input.isBuffered(0, 100));
+  EXPECT_TRUE(input.isBuffered(500, 200));
+}
+
+TEST_F(CachedBufferedInputTest, enqueueSkipsRequestsWhenPreloaded) {
+  std::string content(1024, 'x');
+  auto readFile = std::make_shared<tests::utils::CountingReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "enqueueSkipsRequests");
+  StringIdLease groupId(ids, "enqueueSkipsRequestsGroup");
+
+  CachedBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      cache_.get(),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  ASSERT_EQ(readFile->numReads(), 0);
+
+  input.preload();
+  ASSERT_TRUE(input.preloaded());
+  ASSERT_EQ(readFile->numReads(), 1);
+
+  // After preload, enqueue should not add to requests or coalesced loads.
+  auto stream = input.enqueue(common::Region{0, 100}, nullptr);
+  ASSERT_NE(stream, nullptr);
+
+  // Verify no coalesced loads were created (requests are skipped when
+  // preloaded).
+  EXPECT_EQ(input.testingCoalescedLoads().size(), 0);
+  EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 0);
+
+  // Stream should still be able to read data from preloaded content.
+  auto next = getNext(*stream);
+  ASSERT_TRUE(next.has_value());
+  EXPECT_EQ(next.value(), content.substr(0, 100));
+
+  // No additional file reads - all served from preloaded cache.
+  ASSERT_EQ(readFile->numReads(), 1);
+}
+
+TEST_F(CachedBufferedInputTest, readSetsPreloadedPinWhenPreloaded) {
+  constexpr int32_t kContentSize = 1 << 20;
+  std::string content;
+  content.resize(kContentSize);
+  for (int32_t i = 0; i < kContentSize; ++i) {
+    content[i] = static_cast<char>('a' + (i % 26));
+  }
+  auto readFile = std::make_shared<tests::utils::CountingReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  readerOptions.setLoadQuantum(1 << 20);
+
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "readSetsPreloadedPin");
+  StringIdLease groupId(ids, "readSetsPreloadedPinGroup");
+
+  CachedBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      cache_.get(),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  ASSERT_EQ(readFile->numReads(), 0);
+
+  input.preload();
+  ASSERT_TRUE(input.preloaded());
+  ASSERT_EQ(readFile->numReads(), 1);
+
+  // Use read() to create a stream (not enqueue).
+  auto stream = input.read(0, 100, LogType::TEST);
+  ASSERT_NE(stream, nullptr);
+
+  // Stream should be able to read data from preloaded content.
+  auto next = getNext(*stream);
+  ASSERT_TRUE(next.has_value());
+  EXPECT_EQ(next.value(), content.substr(0, 100));
+
+  // No additional file reads - all served from preloaded cache.
+  ASSERT_EQ(readFile->numReads(), 1);
+}
+
+TEST_F(CachedBufferedInputTest, preloadAfterEnqueue) {
+  std::string content(1024, 'x');
+  auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "preloadAfterEnqueue");
+  StringIdLease groupId(ids, "preloadAfterEnqueueGroup");
+
+  CachedBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      cache_.get(),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  input.enqueue({0, 100}, nullptr);
+  VELOX_ASSERT_THROW(
+      input.preload(), "preload() must be called before enqueue()");
+}
+
+TEST_F(CachedBufferedInputTest, preloadedStreamSkipsEviction) {
+  // When cacheable_=false, non-preloaded streams mark cache entries as
+  // immediately evictable on destruction (via clearCachePin and
+  // makeCacheEvictable). Preloaded streams must skip both because the
+  // preloaded cache entry is shared across all streams.
+  constexpr int32_t kContentSize = 1 << 20;
+  std::string content;
+  content.resize(kContentSize);
+  for (int32_t i = 0; i < kContentSize; ++i) {
+    content[i] = static_cast<char>('a' + (i % 26));
+  }
+  auto readFile = std::make_shared<tests::utils::CountingReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  readerOptions.setCacheable(false);
+  readerOptions.setLoadQuantum(1 << 20);
+
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "preloadEvictionTest");
+  StringIdLease groupId(ids, "preloadEvictionGroup");
+
+  CachedBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      cache_.get(),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  ASSERT_EQ(readFile->numReads(), 0);
+
+  input.preload();
+  ASSERT_TRUE(input.preloaded());
+  ASSERT_EQ(readFile->numReads(), 1);
+
+  auto statsBefore = cache_->refreshStats();
+  ASSERT_GT(statsBefore.sharedPinnedBytes, 0);
+
+  // Create a stream, read from it, and destroy it.
+  {
+    auto stream = input.enqueue(common::Region{0, 100}, nullptr);
+    auto next = getNext(*stream);
+    ASSERT_TRUE(next.has_value());
+    EXPECT_EQ(next.value(), content.substr(0, 100));
+  }
+
+  // The preloaded cache entry must still be pinned and accessible after stream
+  // destruction, even with cacheable_=false.
+  auto statsAfter = cache_->refreshStats();
+  EXPECT_GT(statsAfter.sharedPinnedBytes, 0);
+
+  // A new stream should still be able to read from the preloaded entry.
+  auto stream2 = input.enqueue(common::Region{0, 100}, nullptr);
+  auto next2 = getNext(*stream2);
+  ASSERT_TRUE(next2.has_value());
+  EXPECT_EQ(next2.value(), content.substr(0, 100));
+
+  // No additional file reads — all served from preloaded cache.
+  ASSERT_EQ(readFile->numReads(), 1);
+}
+
+TEST_F(CachedBufferedInputTest, preloadRespectsNotCacheable) {
+  // When cacheable_=false, the preloaded cache entry should be made evictable
+  // (lastUse=0, numUses=0) when CachedBufferedInput is destroyed.
+  constexpr int32_t kContentSize = 1 << 20;
+  std::string content;
+  content.resize(kContentSize);
+  for (int32_t i = 0; i < kContentSize; ++i) {
+    content[i] = static_cast<char>('a' + (i % 26));
+  }
+  auto readFile = std::make_shared<tests::utils::CountingReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  readerOptions.setCacheable(false);
+  readerOptions.setLoadQuantum(1 << 20);
+
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "preloadNotCacheableTest");
+  StringIdLease groupId(ids, "preloadNotCacheableGroup");
+  const auto fileNumId = fileId.id();
+
+  {
+    CachedBufferedInput input(
+        readFile,
+        MetricsLog::voidLog(),
+        std::move(fileId),
+        cache_.get(),
+        tracker_,
+        std::move(groupId),
+        dataIoStats_,
+        nullptr,
+        executor_.get(),
+        readerOptions);
+
+    input.preload();
+    ASSERT_TRUE(input.preloaded());
+
+    auto stats = cache_->refreshStats();
+    ASSERT_GT(stats.sharedPinnedBytes, 0);
+  }
+
+  // After CachedBufferedInput destruction with cacheable_=false, the preloaded
+  // entry should be marked as immediately evictable via makeEvictable().
+  cache::RawFileCacheKey key{fileNumId, 0};
+  EXPECT_TRUE(cache_->testingIsEvictable(key));
+}
+
+TEST_F(CachedBufferedInputTest, preloadRespectsCacheable) {
+  // When cacheable_=true (default), the preloaded cache entry should not be
+  // marked as immediately evictable after CachedBufferedInput is destroyed.
+  constexpr int32_t kContentSize = 1 << 20;
+  std::string content;
+  content.resize(kContentSize);
+  for (int32_t i = 0; i < kContentSize; ++i) {
+    content[i] = static_cast<char>('a' + (i % 26));
+  }
+  auto readFile = std::make_shared<tests::utils::CountingReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  readerOptions.setCacheable(true);
+  readerOptions.setLoadQuantum(1 << 20);
+
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "preloadCacheableTest");
+  StringIdLease groupId(ids, "preloadCacheableGroup");
+  const auto fileNumId = fileId.id();
+
+  {
+    CachedBufferedInput input(
+        readFile,
+        MetricsLog::voidLog(),
+        std::move(fileId),
+        cache_.get(),
+        tracker_,
+        std::move(groupId),
+        dataIoStats_,
+        nullptr,
+        executor_.get(),
+        readerOptions);
+
+    input.preload();
+    ASSERT_TRUE(input.preloaded());
+  }
+
+  // After CachedBufferedInput destruction with cacheable_=true, the cache
+  // entry should NOT be marked as immediately evictable.
+  cache::RawFileCacheKey key{fileNumId, 0};
+  EXPECT_FALSE(cache_->testingIsEvictable(key));
+}
+
+TEST_F(CachedBufferedInputTest, preload) {
+  struct TestParam {
+    uint64_t fileSize;
+    std::string debugString() const {
+      return fmt::format("fileSize {}", fileSize);
+    }
+  };
+  std::vector<TestParam> testSettings = {
+      // Small file (tinyData path in cache entry).
+      {100},
+      // File at tinyData boundary.
+      {AsyncDataCacheEntry::kTinyDataSize},
+      // Larger file (allocation path).
+      {1 << 20},
+  };
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    std::string content;
+    content.resize(testData.fileSize);
+    for (uint64_t i = 0; i < testData.fileSize; ++i) {
+      content[i] = static_cast<char>('a' + (i % 26));
+    }
+    auto readFile = std::make_shared<tests::utils::CountingReadFile>(content);
+
+    io::ReaderOptions readerOptions(pool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
+    readerOptions.setLoadQuantum(1 << 20);
+
+    auto& ids = fileIds();
+    StringIdLease fileId(ids, fmt::format("preloadTest_{}", testData.fileSize));
+    StringIdLease groupId(
+        ids, fmt::format("preloadGroup_{}", testData.fileSize));
+
+    CachedBufferedInput input(
+        readFile,
+        MetricsLog::voidLog(),
+        std::move(fileId),
+        cache_.get(),
+        tracker_,
+        std::move(groupId),
+        dataIoStats_,
+        nullptr,
+        executor_.get(),
+        readerOptions);
+
+    ASSERT_EQ(readFile->numReads(), 0);
+    EXPECT_FALSE(input.preloaded());
+
+    auto statsBefore = cache_->refreshStats();
+    const auto readCountBefore = dataIoStats_->read().count();
+    const auto readSumBefore = dataIoStats_->read().sum();
+    const auto rawBytesBefore = dataIoStats_->rawBytesRead();
+
+    input.preload();
+
+    EXPECT_TRUE(input.preloaded());
+
+    const auto readsAfterPreload = readFile->numReads();
+    ASSERT_GT(readsAfterPreload, 0);
+
+    // Cache should have one new entry for the whole file.
+    auto statsAfter = cache_->refreshStats();
+    EXPECT_EQ(statsAfter.numEntries, statsBefore.numEntries + 1);
+    // preloadPin_ holds a shared pin.
+    EXPECT_GT(statsAfter.sharedPinnedBytes, 0);
+    // IO stats: one storage read of fileSize bytes.
+    EXPECT_EQ(dataIoStats_->read().count(), readCountBefore + 1);
+    EXPECT_EQ(dataIoStats_->read().sum(), readSumBefore + testData.fileSize);
+    EXPECT_EQ(dataIoStats_->rawBytesRead(), rawBytesBefore + testData.fileSize);
+
+    // Enqueue sub-region streams and read from the preloaded cache entry.
+    const uint64_t regionSize =
+        std::min<uint64_t>(testData.fileSize / 2, testData.fileSize);
+    auto stream1 = input.enqueue(common::Region{0, regionSize}, nullptr);
+    ASSERT_NE(stream1, nullptr);
+
+    auto next1 = getNext(*stream1);
+    ASSERT_TRUE(next1.has_value());
+    EXPECT_EQ(next1.value(), content.substr(0, regionSize));
+
+    if (testData.fileSize > regionSize) {
+      auto stream2 = input.enqueue(
+          common::Region{regionSize, testData.fileSize - regionSize}, nullptr);
+      ASSERT_NE(stream2, nullptr);
+
+      auto next2 = getNext(*stream2);
+      ASSERT_TRUE(next2.has_value());
+      EXPECT_EQ(
+          next2.value(),
+          content.substr(regionSize, testData.fileSize - regionSize));
+    }
+
+    // No additional file reads after preload.
+    ASSERT_EQ(readFile->numReads(), readsAfterPreload);
+  }
+}
+
+TEST_F(CachedBufferedInputTest, preloadCacheSharing) {
+  constexpr int32_t kContentSize = 1 << 20; // 1MB
+  std::string content;
+  content.resize(kContentSize);
+  for (int32_t i = 0; i < kContentSize; ++i) {
+    content[i] = static_cast<char>('a' + (i % 26));
+  }
+  auto readFile = std::make_shared<tests::utils::CountingReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  readerOptions.setLoadQuantum(1 << 20);
+
+  auto& ids = fileIds();
+  const std::string fileName = "preloadSharingTest";
+  StringIdLease fileId1(ids, fileName);
+  StringIdLease groupId1(ids, "preloadSharingGroup1");
+
+  CachedBufferedInput input1(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId1),
+      cache_.get(),
+      tracker_,
+      std::move(groupId1),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  ASSERT_EQ(readFile->numReads(), 0);
+
+  // First preload reads from storage.
+  input1.preload();
+  EXPECT_TRUE(input1.preloaded());
+  ASSERT_EQ(readFile->numReads(), 1);
+
+  auto stats1 = cache_->refreshStats();
+  auto readCount1 = dataIoStats_->read().count();
+
+  // Second CachedBufferedInput with the same file should hit the cache.
+  StringIdLease fileId2(ids, fileName);
+  StringIdLease groupId2(ids, "preloadSharingGroup2");
+
+  CachedBufferedInput input2(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId2),
+      cache_.get(),
+      tracker_,
+      std::move(groupId2),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  input2.preload();
+  EXPECT_TRUE(input2.preloaded());
+
+  // No additional file read — second preload hits the cache.
+  ASSERT_EQ(readFile->numReads(), 1);
+
+  // No additional cache entry should be created.
+  auto stats2 = cache_->refreshStats();
+  EXPECT_EQ(stats2.numEntries, stats1.numEntries);
+
+  // No additional storage read should happen (cache hit).
+  EXPECT_EQ(dataIoStats_->read().count(), readCount1);
+
+  // Both inputs should still be able to read data.
+  auto stream1 = input1.enqueue(common::Region{0, 100}, nullptr);
+  auto next1 = getNext(*stream1);
+  ASSERT_TRUE(next1.has_value());
+  EXPECT_EQ(next1.value(), content.substr(0, 100));
+
+  auto stream2 = input2.enqueue(common::Region{0, 100}, nullptr);
+  auto next2 = getNext(*stream2);
+  ASSERT_TRUE(next2.has_value());
+  EXPECT_EQ(next2.value(), content.substr(0, 100));
+
+  // No additional file reads — all served from cache.
+  ASSERT_EQ(readFile->numReads(), 1);
+}
+
+TEST_F(CachedBufferedInputTest, prefetchScope) {
+  constexpr int32_t kContentSize = 32 << 20;
+  std::string content;
+  content.resize(kContentSize);
+  for (int32_t i = 0; i < kContentSize; ++i) {
+    content[i] = static_cast<char>('a' + (i % 26));
+  }
+  auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "testFile");
+  StringIdLease groupId(ids, "testGroup");
+
+  CachedBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      cache_.get(),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  // Enqueue non-prefetch requests (with stream IDs).
+  constexpr int32_t kNumRequests = 3;
+  constexpr uint64_t kRequestSize = 500;
+  std::vector<std::unique_ptr<StreamIdentifier>> streamIds;
+  for (int32_t i = 0; i < kNumRequests; ++i) {
+    streamIds.push_back(std::make_unique<StreamIdentifier>(i));
+  }
+  for (int32_t i = 0; i < kNumRequests; ++i) {
+    input.enqueue(
+        {static_cast<uint64_t>(i * 1000), kRequestSize}, streamIds[i].get());
+  }
+  input.load(LogType::TEST);
+
+  // There should be exactly 1 non-prefetch CoalescedLoad in kPlanned state.
+  const auto& loadsBeforePrefetch = input.testingCoalescedLoads();
+  ASSERT_EQ(loadsBeforePrefetch.size(), 1);
+  ASSERT_EQ(loadsBeforePrefetch[0]->state(), CoalescedLoad::State::kPlanned);
+
+  // Enqueue prefetch requests (without stream IDs).
+  constexpr int32_t kMB = 1 << 20;
+  for (int32_t i = 0; i < kNumRequests; ++i) {
+    input.enqueue(
+        {static_cast<uint64_t>(10 * kMB + i * 1000), kRequestSize}, nullptr);
+  }
+  input.load(LogType::TEST);
+
+  // Wait for executor to complete all submitted tasks.
+  executor_->join();
+
+  const auto& loadsAfterPrefetch = input.testingCoalescedLoads();
+  ASSERT_EQ(loadsAfterPrefetch.size(), 2);
+  EXPECT_EQ(loadsAfterPrefetch[0]->state(), CoalescedLoad::State::kPlanned)
+      << "Non-prefetch load should NOT be submitted to executor";
+  EXPECT_EQ(loadsAfterPrefetch[1]->state(), CoalescedLoad::State::kLoaded)
+      << "Prefetch load should be submitted and completed by executor";
+
+  EXPECT_EQ(dataIoStats_->prefetch().sum(), kNumRequests * kRequestSize);
+}
+
+TEST_F(CachedBufferedInputTest, cloneNonCacheable) {
+  constexpr int32_t kContentSize = 1 << 20; // 1MB
+  std::string content(kContentSize, 'x');
+  auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  readerOptions.setLoadQuantum(1 << 20);
+
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "testFile");
+  StringIdLease groupId(ids, "testGroup");
+
+  const auto fileNum = fileId.id();
+  CachedBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      cache_.get(),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      /*ioStats=*/nullptr,
+      executor_.get(),
+      readerOptions);
+
+  ASSERT_TRUE(input.hasCache());
+
+  auto nonCacheable = input.cloneNonCacheable();
+  ASSERT_TRUE(nonCacheable->hasCache());
+
+  // Read through the non-cacheable clone.
+  constexpr uint64_t kOffset = 0;
+  constexpr uint64_t kLength = 1'024;
+  StreamIdentifier sid(0);
+  auto stream = nonCacheable->enqueue({kOffset, kLength}, &sid);
+  nonCacheable->load(LogType::FILE);
+
+  auto result = getNext(*stream);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_EQ(result->size(), kLength);
+
+  // The cache should have an entry from the non-cacheable read.
+  auto statsAfterLoad = cache_->refreshStats();
+  EXPECT_GT(statsAfterLoad.numEntries, 0);
+
+  // The entry should not be evictable while the non-cacheable clone is alive.
+  const cache::RawFileCacheKey cacheKey{fileNum, kOffset};
+  EXPECT_FALSE(cache_->testingIsEvictable(cacheKey));
+
+  // Release the stream and destroy the non-cacheable input. Because
+  // cacheable=false, the destructor marks preloaded entries as immediately
+  // evictable (lastUse=0, numUses=0).
+  stream.reset();
+  nonCacheable.reset();
+
+  // The entry is still in cache but now marked as immediately evictable.
+  auto statsAfterDestroy = cache_->refreshStats();
+  EXPECT_EQ(statsAfterDestroy.numEntries, statsAfterLoad.numEntries);
+  EXPECT_TRUE(cache_->testingIsEvictable(cacheKey));
+
+  // Read the same region through a cacheable input — should still work.
+  StringIdLease fileId2(ids, "testFile2");
+  StringIdLease groupId2(ids, "testGroup2");
+  const auto fileNum2 = fileId2.id();
+  CachedBufferedInput cacheableInput(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId2),
+      cache_.get(),
+      tracker_,
+      std::move(groupId2),
+      dataIoStats_,
+      /*ioStats=*/nullptr,
+      executor_.get(),
+      readerOptions);
+
+  auto stream2 = cacheableInput.enqueue({kOffset, kLength}, &sid);
+  cacheableInput.load(LogType::FILE);
+  auto result2 = getNext(*stream2);
+  ASSERT_TRUE(result2.has_value());
+  EXPECT_EQ(result2->size(), kLength);
+
+  // The cacheable input's entry should persist and not be marked evictable.
+  stream2.reset();
+  const cache::RawFileCacheKey cacheKey2{fileNum2, kOffset};
+  auto statsAfterCacheable = cache_->refreshStats();
+  EXPECT_GT(statsAfterCacheable.numEntries, 0);
+  EXPECT_FALSE(cache_->testingIsEvictable(cacheKey2));
+}
+
+} // namespace
diff --git a/velox/dwio/common/tests/ChainedBufferTests.cpp b/velox/dwio/common/tests/ChainedBufferTests.cpp
index 0612f4341ff..43820bc0c77 100644
--- a/velox/dwio/common/tests/ChainedBufferTests.cpp
+++ b/velox/dwio/common/tests/ChainedBufferTests.cpp
@@ -23,10 +23,7 @@
 
 using namespace ::testing;
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
 
 class ChainedBufferTests : public Test {
  protected:
@@ -64,8 +61,9 @@ TEST_F(ChainedBufferTests, testCreate) {
 
 TEST_F(ChainedBufferTests, testReserve) {
   for (const uint32_t initialCapacityBytes : {0, 16}) {
-    SCOPED_TRACE(fmt::format(
-        "initialCapacityBytes ", succinctBytes(initialCapacityBytes)));
+    SCOPED_TRACE(
+        fmt::format(
+            "initialCapacityBytes ", succinctBytes(initialCapacityBytes)));
     ChainedBuffer<int32_t> buf{*pool_, initialCapacityBytes, 1024};
     ASSERT_EQ(buf.capacity(), initialCapacityBytes);
     ASSERT_EQ(buf.size(), 0);
@@ -252,8 +250,9 @@ TEST_F(ChainedBufferTests, testTrailingZeros) {
 
 TEST_F(ChainedBufferTests, testClearAll) {
   for (const uint32_t initialCapacityBytes : {0, 128}) {
-    SCOPED_TRACE(fmt::format(
-        "initialCapacityBytes ", succinctBytes(initialCapacityBytes)));
+    SCOPED_TRACE(
+        fmt::format(
+            "initialCapacityBytes ", succinctBytes(initialCapacityBytes)));
     ChainedBuffer<int32_t> buf{*pool_, initialCapacityBytes, 1024};
     ASSERT_EQ(buf.capacity(), initialCapacityBytes);
     ASSERT_EQ(buf.size(), 0);
@@ -321,7 +320,5 @@ TEST_F(ChainedBufferTests, testClearAll) {
     ASSERT_EQ(buf.pages_.size(), 9);
   }
 }
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/tests/ColumnReaderStatisticsTests.cpp b/velox/dwio/common/tests/ColumnReaderStatisticsTests.cpp
new file mode 100644
index 00000000000..3e71fbcdf07
--- /dev/null
+++ b/velox/dwio/common/tests/ColumnReaderStatisticsTests.cpp
@@ -0,0 +1,403 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include <thread>
+#include <vector>
+#include "velox/dwio/common/Statistics.h"
+#include "velox/type/Type.h"
+
+using namespace facebook::velox::dwio::common;
+using facebook::velox::RuntimeMetric;
+using facebook::velox::TypeKind;
+
+TEST(IoCounterTest, BasicOperations) {
+  facebook::velox::io::IoCounter counter;
+
+  EXPECT_EQ(counter.sum(), 0);
+  EXPECT_EQ(counter.count(), 0);
+
+  counter.increment(5'000);
+  counter.increment(3'000);
+
+  EXPECT_EQ(counter.sum(), 8'000);
+  EXPECT_EQ(counter.count(), 2);
+  EXPECT_EQ(counter.min(), 3'000);
+  EXPECT_EQ(counter.max(), 5'000);
+}
+
+TEST(IoCounterTest, ConcurrentAccess) {
+  facebook::velox::io::IoCounter counter;
+  constexpr int kNumThreads = 4;
+  constexpr int kIterationsPerThread = 1'000;
+
+  std::vector<std::thread> threads;
+  threads.reserve(kNumThreads);
+  for (int i = 0; i < kNumThreads; ++i) {
+    threads.emplace_back([&counter]() {
+      for (int j = 0; j < kIterationsPerThread; ++j) {
+        counter.increment(5);
+      }
+    });
+  }
+  for (auto& t : threads) {
+    t.join();
+  }
+
+  EXPECT_EQ(counter.sum(), kNumThreads * kIterationsPerThread * 5);
+  EXPECT_EQ(counter.count(), kNumThreads * kIterationsPerThread);
+}
+
+TEST(ColumnMetricsSetTest, GetOrCreate) {
+  ColumnMetricsSet metricsSet;
+
+  auto* result = metricsSet.getOrCreate(1);
+  ASSERT_NE(result, nullptr);
+
+  // Returns same instance for same nodeId.
+  EXPECT_EQ(metricsSet.getOrCreate(1), result);
+
+  // Returns different instance for different nodeId.
+  auto* result2 = metricsSet.getOrCreate(2);
+  EXPECT_NE(result2, result);
+}
+
+TEST(ColumnMetricsSetTest, GetOrCreateWithTypeKind) {
+  ColumnMetricsSet metricsSet;
+
+  // Pass type when calling getOrCreate.
+  auto* result = metricsSet.getOrCreate(1, TypeKind::BIGINT);
+  ASSERT_NE(result, nullptr);
+  result->decompressCPUTimeNanos.increment(1'000);
+
+  // Returns same instance for same nodeId.
+  auto* result2 = metricsSet.getOrCreate(1);
+  EXPECT_EQ(result2, result);
+
+  // Different nodeId with different type.
+  auto* result3 = metricsSet.getOrCreate(2, TypeKind::VARCHAR);
+  EXPECT_NE(result3, result);
+  result3->decompressCPUTimeNanos.increment(2'000);
+
+  // Verify types are used in toRuntimeMetrics.
+  std::unordered_map<std::string, RuntimeMetric> metrics;
+  metricsSet.toRuntimeMetrics(metrics);
+  EXPECT_EQ(metrics["column_1.BIGINT.decompressCPUTimeNanos"].sum, 1'000);
+  EXPECT_EQ(metrics["column_2.VARCHAR.decompressCPUTimeNanos"].sum, 2'000);
+}
+
+TEST(ColumnMetricsSetTest, ToRuntimeMetrics) {
+  ColumnMetricsSet metricsSet;
+
+  // Empty stats produces empty result.
+  std::unordered_map<std::string, RuntimeMetric> result;
+  metricsSet.toRuntimeMetrics(result);
+  EXPECT_TRUE(result.empty());
+
+  // Add timing data with type information.
+  auto* col1 = metricsSet.getOrCreate(1, TypeKind::BIGINT);
+  col1->decompressCPUTimeNanos.increment(5'000);
+  col1->decompressCPUTimeNanos.increment(3'000);
+
+  auto* col2 = metricsSet.getOrCreate(42, TypeKind::VARCHAR);
+  col2->decompressCPUTimeNanos.increment(2'000);
+
+  // Create a column with type but no data.
+  metricsSet.getOrCreate(99, TypeKind::DOUBLE);
+
+  result.clear();
+  metricsSet.toRuntimeMetrics(result);
+
+  // RuntimeMetric has sum/count/min/max, metric name includes type.
+  EXPECT_EQ(result["column_1.BIGINT.decompressCPUTimeNanos"].sum, 8'000);
+  EXPECT_EQ(result["column_1.BIGINT.decompressCPUTimeNanos"].count, 2);
+  EXPECT_EQ(result["column_1.BIGINT.decompressCPUTimeNanos"].min, 3'000);
+  EXPECT_EQ(result["column_1.BIGINT.decompressCPUTimeNanos"].max, 5'000);
+  EXPECT_EQ(result["column_42.VARCHAR.decompressCPUTimeNanos"].sum, 2'000);
+  EXPECT_EQ(result["column_42.VARCHAR.decompressCPUTimeNanos"].count, 1);
+
+  // Zero values are not included.
+  metricsSet.getOrCreate(99);
+  result.clear();
+  metricsSet.toRuntimeMetrics(result);
+  EXPECT_EQ(result.count("column_99.DOUBLE.decompressCPUTimeNanos"), 0);
+}
+
+TEST(ColumnMetricsSetTest, ToRuntimeMetricsWithInvalidType) {
+  ColumnMetricsSet metricsSet;
+
+  // Add timing data without type information (INVALID type).
+  auto* col1 = metricsSet.getOrCreate(1);
+  col1->decompressCPUTimeNanos.increment(5'000);
+
+  std::unordered_map<std::string, RuntimeMetric> result;
+  metricsSet.toRuntimeMetrics(result);
+
+  // Should use INVALID as type name.
+  EXPECT_EQ(result["column_1.INVALID.decompressCPUTimeNanos"].sum, 5'000);
+}
+
+TEST(ColumnMetricsSetTest, ToRuntimeMetricsWithDecodeTime) {
+  ColumnMetricsSet metricsSet;
+
+  // Add both decompress and decode timing data.
+  auto* col1 = metricsSet.getOrCreate(1, TypeKind::BIGINT);
+  col1->decompressCPUTimeNanos.increment(5'000);
+  col1->decodeCPUTimeNanos.increment(10'000);
+  col1->decodeCPUTimeNanos.increment(8'000);
+
+  auto* col2 = metricsSet.getOrCreate(2, TypeKind::VARCHAR);
+  col2->decodeCPUTimeNanos.increment(3'000);
+
+  std::unordered_map<std::string, RuntimeMetric> result;
+  metricsSet.toRuntimeMetrics(result);
+
+  // Column 1 has both decompress and decode metrics.
+  EXPECT_EQ(result["column_1.BIGINT.decompressCPUTimeNanos"].sum, 5'000);
+  EXPECT_EQ(result["column_1.BIGINT.decodeCPUTimeNanos"].sum, 18'000);
+  EXPECT_EQ(result["column_1.BIGINT.decodeCPUTimeNanos"].count, 2);
+  EXPECT_EQ(result["column_1.BIGINT.decodeCPUTimeNanos"].min, 8'000);
+  EXPECT_EQ(result["column_1.BIGINT.decodeCPUTimeNanos"].max, 10'000);
+
+  // Column 2 has only decode metrics.
+  EXPECT_EQ(result.count("column_2.VARCHAR.decompressCPUTimeNanos"), 0);
+  EXPECT_EQ(result["column_2.VARCHAR.decodeCPUTimeNanos"].sum, 3'000);
+  EXPECT_EQ(result["column_2.VARCHAR.decodeCPUTimeNanos"].count, 1);
+}
+
+TEST(RuntimeStatisticsTest, ToRuntimeMetricMap) {
+  RuntimeStatistics stats;
+
+  // Empty stats produces empty result.
+  EXPECT_TRUE(stats.toRuntimeMetricMap().empty());
+
+  // Set various stats.
+  stats.skippedSplits = 5;
+  stats.processedSplits = 15;
+  stats.skippedStrides = 10;
+  stats.processedStrides = 30;
+  stats.numStripes = 4;
+  stats.columnReaderStats.flattenStringDictionaryValues = 1'000;
+
+  // Add per-column stats with type.
+  stats.columnReaderStats.columnMetricsSet.emplace();
+  auto* colMetrics = stats.columnReaderStats.columnMetricsSet->getOrCreate(
+      1, TypeKind::BIGINT);
+  colMetrics->decompressCPUTimeNanos.increment(5'000);
+  colMetrics->decodeCPUTimeNanos.increment(12'000);
+
+  auto result = stats.toRuntimeMetricMap();
+
+  EXPECT_EQ(result["skippedSplits"].sum, 5);
+  EXPECT_EQ(result["processedSplits"].sum, 15);
+  EXPECT_EQ(result["skippedStrides"].sum, 10);
+  EXPECT_EQ(result["processedStrides"].sum, 30);
+  EXPECT_EQ(result["numStripes"].sum, 4);
+  EXPECT_EQ(result["flattenStringDictionaryValues"].sum, 1'000);
+  EXPECT_EQ(result["column_1.BIGINT.decompressCPUTimeNanos"].sum, 5'000);
+  EXPECT_EQ(result["column_1.BIGINT.decompressCPUTimeNanos"].count, 1);
+  EXPECT_EQ(result["column_1.BIGINT.decodeCPUTimeNanos"].sum, 12'000);
+  EXPECT_EQ(result["column_1.BIGINT.decodeCPUTimeNanos"].count, 1);
+}
+
+TEST(ColumnMetricsSetConcurrencyTest, ConcurrentGetOrCreate) {
+  ColumnMetricsSet metricsSet;
+  constexpr int kNumThreads = 4;
+  constexpr int kNumColumns = 10;
+
+  // Pre-populate columns with types before concurrent access.
+  for (uint32_t colId = 0; colId < kNumColumns; ++colId) {
+    metricsSet.getOrCreate(colId, TypeKind::BIGINT);
+  }
+
+  std::vector<std::thread> threads;
+  threads.reserve(kNumThreads);
+  for (int i = 0; i < kNumThreads; ++i) {
+    threads.emplace_back([&metricsSet]() {
+      for (uint32_t colId = 0; colId < kNumColumns; ++colId) {
+        auto* colMetrics = metricsSet.getOrCreate(colId);
+        colMetrics->decompressCPUTimeNanos.increment(100);
+      }
+    });
+  }
+  for (auto& t : threads) {
+    t.join();
+  }
+
+  std::unordered_map<std::string, RuntimeMetric> result;
+  metricsSet.toRuntimeMetrics(result);
+
+  for (uint32_t colId = 0; colId < kNumColumns; ++colId) {
+    auto key = fmt::format("column_{}.BIGINT.decompressCPUTimeNanos", colId);
+    EXPECT_EQ(result[key].sum, kNumThreads * 100);
+    EXPECT_EQ(result[key].count, kNumThreads);
+  }
+}
+
+TEST(IoCounterTest, MergeStats) {
+  facebook::velox::io::IoCounter counter1;
+  counter1.increment(5'000);
+  counter1.increment(3'000);
+
+  facebook::velox::io::IoCounter counter2;
+  counter2.increment(2'000);
+
+  counter1.merge(counter2);
+
+  EXPECT_EQ(counter1.sum(), 10'000);
+  EXPECT_EQ(counter1.count(), 3);
+}
+
+TEST(ColumnMetricsSetTest, MergeFromWithOverlappingNodeIds) {
+  ColumnMetricsSet src;
+  auto* srcCol1 = src.getOrCreate(1, TypeKind::BIGINT);
+  srcCol1->decompressCPUTimeNanos.increment(5'000);
+  srcCol1->decompressCPUTimeNanos.increment(3'000);
+  srcCol1->decodeCPUTimeNanos.increment(10'000);
+
+  auto* srcCol2 = src.getOrCreate(2, TypeKind::VARCHAR);
+  srcCol2->decompressCPUTimeNanos.increment(2'000);
+  srcCol2->decodeCPUTimeNanos.increment(4'000);
+
+  ColumnMetricsSet dst;
+  auto* dstCol1 = dst.getOrCreate(1, TypeKind::BIGINT);
+  dstCol1->decompressCPUTimeNanos.increment(1'000);
+  dstCol1->decodeCPUTimeNanos.increment(6'000);
+
+  dst.mergeFrom(src);
+
+  std::unordered_map<std::string, RuntimeMetric> result;
+  dst.toRuntimeMetrics(result);
+
+  EXPECT_EQ(result["column_1.BIGINT.decompressCPUTimeNanos"].sum, 9'000);
+  EXPECT_EQ(result["column_1.BIGINT.decompressCPUTimeNanos"].count, 3);
+  EXPECT_EQ(result["column_1.BIGINT.decodeCPUTimeNanos"].sum, 16'000);
+  EXPECT_EQ(result["column_1.BIGINT.decodeCPUTimeNanos"].count, 2);
+  EXPECT_EQ(result["column_2.VARCHAR.decompressCPUTimeNanos"].sum, 2'000);
+  EXPECT_EQ(result["column_2.VARCHAR.decompressCPUTimeNanos"].count, 1);
+  EXPECT_EQ(result["column_2.VARCHAR.decodeCPUTimeNanos"].sum, 4'000);
+  EXPECT_EQ(result["column_2.VARCHAR.decodeCPUTimeNanos"].count, 1);
+}
+
+TEST(ColumnMetricsSetTest, MergeFromWithDisjointNodeIds) {
+  ColumnMetricsSet src;
+  auto* srcCol3 = src.getOrCreate(3, TypeKind::DOUBLE);
+  srcCol3->decompressCPUTimeNanos.increment(3'000);
+
+  auto* srcCol4 = src.getOrCreate(4, TypeKind::BOOLEAN);
+  srcCol4->decompressCPUTimeNanos.increment(4'000);
+
+  ColumnMetricsSet dst;
+  auto* dstCol1 = dst.getOrCreate(1, TypeKind::BIGINT);
+  dstCol1->decompressCPUTimeNanos.increment(1'000);
+
+  auto* dstCol2 = dst.getOrCreate(2, TypeKind::VARCHAR);
+  dstCol2->decompressCPUTimeNanos.increment(2'000);
+
+  dst.mergeFrom(src);
+
+  std::unordered_map<std::string, RuntimeMetric> result;
+  dst.toRuntimeMetrics(result);
+
+  EXPECT_EQ(result["column_1.BIGINT.decompressCPUTimeNanos"].sum, 1'000);
+  EXPECT_EQ(result["column_2.VARCHAR.decompressCPUTimeNanos"].sum, 2'000);
+  EXPECT_EQ(result["column_3.DOUBLE.decompressCPUTimeNanos"].sum, 3'000);
+  EXPECT_EQ(result["column_4.BOOLEAN.decompressCPUTimeNanos"].sum, 4'000);
+}
+
+TEST(ColumnMetricsSetTest, MergeFromEmpty) {
+  ColumnMetricsSet nonEmpty;
+  auto* col = nonEmpty.getOrCreate(1, TypeKind::BIGINT);
+  col->decompressCPUTimeNanos.increment(5'000);
+
+  ColumnMetricsSet empty;
+
+  nonEmpty.mergeFrom(empty);
+
+  std::unordered_map<std::string, RuntimeMetric> result;
+  nonEmpty.toRuntimeMetrics(result);
+  EXPECT_EQ(result["column_1.BIGINT.decompressCPUTimeNanos"].sum, 5'000);
+
+  ColumnMetricsSet empty2;
+  empty2.mergeFrom(nonEmpty);
+
+  result.clear();
+  empty2.toRuntimeMetrics(result);
+  EXPECT_EQ(result["column_1.BIGINT.decompressCPUTimeNanos"].sum, 5'000);
+}
+
+TEST(ColumnReaderStatisticsTest, MergeFromWithColumnMetrics) {
+  ColumnReaderStatistics src;
+  src.flattenStringDictionaryValues = 100;
+  src.columnMetricsSet.emplace();
+  src.columnMetricsSet->getOrCreate(1, TypeKind::BIGINT)
+      ->decompressCPUTimeNanos.increment(1'000);
+
+  // Merge into stats without columnMetricsSet - creates and populates it.
+  ColumnReaderStatistics dst;
+  dst.flattenStringDictionaryValues = 50;
+  dst.mergeFrom(src);
+
+  EXPECT_EQ(dst.flattenStringDictionaryValues, 150);
+  ASSERT_TRUE(dst.columnMetricsSet.has_value());
+
+  std::unordered_map<std::string, RuntimeMetric> result;
+  dst.columnMetricsSet->toRuntimeMetrics(result);
+  EXPECT_EQ(result["column_1.BIGINT.decompressCPUTimeNanos"].sum, 1'000);
+}
+
+TEST(ColumnReaderStatisticsTest, MergeFromBothWithColumnMetrics) {
+  ColumnReaderStatistics src;
+  src.flattenStringDictionaryValues = 100;
+  src.columnMetricsSet.emplace();
+  src.columnMetricsSet->getOrCreate(1, TypeKind::BIGINT)
+      ->decompressCPUTimeNanos.increment(1'000);
+
+  ColumnReaderStatistics dst;
+  dst.flattenStringDictionaryValues = 50;
+  dst.columnMetricsSet.emplace();
+  dst.columnMetricsSet->getOrCreate(1, TypeKind::BIGINT)
+      ->decompressCPUTimeNanos.increment(2'000);
+
+  dst.mergeFrom(src);
+
+  EXPECT_EQ(dst.flattenStringDictionaryValues, 150);
+  ASSERT_TRUE(dst.columnMetricsSet.has_value());
+
+  std::unordered_map<std::string, RuntimeMetric> result;
+  dst.columnMetricsSet->toRuntimeMetrics(result);
+  EXPECT_EQ(result["column_1.BIGINT.decompressCPUTimeNanos"].sum, 3'000);
+}
+
+TEST(ColumnReaderStatisticsTest, MergeFromWithoutColumnMetrics) {
+  ColumnReaderStatistics src;
+  src.flattenStringDictionaryValues = 100;
+
+  ColumnReaderStatistics dst;
+  dst.flattenStringDictionaryValues = 50;
+  dst.columnMetricsSet.emplace();
+  dst.columnMetricsSet->getOrCreate(1, TypeKind::BIGINT)
+      ->decompressCPUTimeNanos.increment(1'000);
+
+  dst.mergeFrom(src);
+
+  EXPECT_EQ(dst.flattenStringDictionaryValues, 150);
+  ASSERT_TRUE(dst.columnMetricsSet.has_value());
+
+  std::unordered_map<std::string, RuntimeMetric> result;
+  dst.columnMetricsSet->toRuntimeMetrics(result);
+  EXPECT_EQ(result["column_1.BIGINT.decompressCPUTimeNanos"].sum, 1'000);
+}
diff --git a/velox/dwio/common/tests/ColumnSelectorTests.cpp b/velox/dwio/common/tests/ColumnSelectorTests.cpp
index f0176b3824d..b65411d0e6f 100644
--- a/velox/dwio/common/tests/ColumnSelectorTests.cpp
+++ b/velox/dwio/common/tests/ColumnSelectorTests.cpp
@@ -394,17 +394,19 @@ TEST(ColumnSelectorTests, testFlatMapKeyFilterAllowed) {
 }
 
 TEST(ColumnSelectorTests, testPartitionKeysMark) {
-  const auto schema = std::dynamic_pointer_cast<const RowType>(
-      HiveTypeParser().parse("struct<"
-                             "id:bigint"
-                             "memo:string"
-                             "ds:string"
-                             "key:string>"));
-
-  const auto physicalSchema = std::dynamic_pointer_cast<const RowType>(
-      HiveTypeParser().parse("struct<"
-                             "id:bigint"
-                             "memo:string>"));
+  const auto schema =
+      std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
+          "struct<"
+          "id:bigint"
+          "memo:string"
+          "ds:string"
+          "key:string>"));
+
+  const auto physicalSchema =
+      std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
+          "struct<"
+          "id:bigint"
+          "memo:string>"));
 
   // use schema and physical schema to initialize a column selector
   // without filtering
@@ -456,14 +458,16 @@ TEST(ColumnSelectorTests, testPartitionKeysMark) {
     EXPECT_EQ(root->childAt(3)->getNode().expression, "gold");
 
     // test apply to real data file disk schema
-    const auto schemaMore = std::dynamic_pointer_cast<const RowType>(
-        HiveTypeParser().parse("struct<"
-                               "id:bigint"
-                               "memo:string"
-                               "extra:array<float>>"));
-    const auto schemaLess = std::dynamic_pointer_cast<const RowType>(
-        HiveTypeParser().parse("struct<"
-                               "id:bigint>"));
+    const auto schemaMore =
+        std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
+            "struct<"
+            "id:bigint"
+            "memo:string"
+            "extra:array<float>>"));
+    const auto schemaLess =
+        std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
+            "struct<"
+            "id:bigint>"));
 
     auto csMore = ColumnSelector::apply(cs, schemaMore);
     LOG(INFO) << "CS filter size: " << cs->getProjection().size();
@@ -510,14 +514,15 @@ TEST(ColumnSelectorTests, testPartitionKeysMark) {
 }
 
 TEST(ColumnSelectorTests, testProjectionUnchangedWhenReadSetChanged) {
-  const auto schema = std::dynamic_pointer_cast<const RowType>(
-      HiveTypeParser().parse("struct<"
-                             "id:bigint"
-                             "values:array<float>"
-                             "tags:map<int, string>"
-                             "notes:struct<f1:int, f2:double, f3:string>"
-                             "memo:string"
-                             "extra:string>"));
+  const auto schema =
+      std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
+          "struct<"
+          "id:bigint"
+          "values:array<float>"
+          "tags:map<int, string>"
+          "notes:struct<f1:int, f2:double, f3:string>"
+          "memo:string"
+          "extra:string>"));
   ColumnSelector cs(schema, std::vector<std::string>{"id", "values"});
   cs.setRead(cs.findColumn("notes"));
 
@@ -559,13 +564,14 @@ TEST(ColumnSelectorTests, testProjectionUnchangedWhenReadSetChanged) {
 }
 
 TEST(ColumnSelectorTests, testProjectOrder) {
-  const auto schema = std::dynamic_pointer_cast<const RowType>(
-      HiveTypeParser().parse("struct<"
-                             "id:bigint"
-                             "values:array<float>"
-                             "tags:map<int, string>"
-                             "notes:struct<f1:int, f2:double, f3:string>"
-                             "memo:string>"));
+  const auto schema =
+      std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
+          "struct<"
+          "id:bigint"
+          "values:array<float>"
+          "tags:map<int, string>"
+          "notes:struct<f1:int, f2:double, f3:string>"
+          "memo:string>"));
 
   // test filter with names with order of tags, memo and id
   {
@@ -642,14 +648,15 @@ TEST(ColumnSelectorTests, testProjectOrder) {
 }
 
 TEST(ColumnSelectorTests, testNonexistingColFilters) {
-  const auto schema = std::dynamic_pointer_cast<const RowType>(
-      HiveTypeParser().parse("struct<"
-                             "id:bigint"
-                             "values:array<float>"
-                             "tags:map<int, string>"
-                             "notes:struct<f1:int, f2:double, f3:string>"
-                             "memo:string"
-                             "extra:string>"));
+  const auto schema =
+      std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
+          "struct<"
+          "id:bigint"
+          "values:array<float>"
+          "tags:map<int, string>"
+          "notes:struct<f1:int, f2:double, f3:string>"
+          "memo:string"
+          "extra:string>"));
 
   EXPECT_THROW(
       ColumnSelector cs(
@@ -659,15 +666,16 @@ TEST(ColumnSelectorTests, testNonexistingColFilters) {
 }
 
 TEST(TestColumnSelector, fileColumnNamesReadAsLowerCaseDuplicateColFilters) {
-  const auto schema = std::dynamic_pointer_cast<const RowType>(
-      HiveTypeParser().parse("struct<"
-                             "id:bigint"
-                             "id:bigint"
-                             "values:array<float>"
-                             "tags:map<int, string>"
-                             "notes:struct<f1:int, f2:double, f3:string>"
-                             "memo:string"
-                             "extra:string>"));
+  const auto schema =
+      std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
+          "struct<"
+          "id:bigint"
+          "id:bigint"
+          "values:array<float>"
+          "tags:map<int, string>"
+          "notes:struct<f1:int, f2:double, f3:string>"
+          "memo:string"
+          "extra:string>"));
 
   EXPECT_THROW(
       ColumnSelector cs(schema, std::vector<std::string>{"id"}, nullptr, true),
diff --git a/velox/dwio/common/tests/DataBufferTests.cpp b/velox/dwio/common/tests/DataBufferTests.cpp
index a6ddee1afab..c5e7b816cbc 100644
--- a/velox/dwio/common/tests/DataBufferTests.cpp
+++ b/velox/dwio/common/tests/DataBufferTests.cpp
@@ -21,10 +21,8 @@
 #include "velox/common/memory/Memory.h"
 #include "velox/dwio/common/DataBuffer.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
+
 using namespace facebook::velox::memory;
 using namespace testing;
 using MemoryPool = facebook::velox::memory::MemoryPool;
@@ -175,7 +173,5 @@ TEST_F(DataBufferTest, Move) {
   }
   ASSERT_EQ(0, pool_->usedBytes());
 }
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/tests/DecoderUtilTest.cpp b/velox/dwio/common/tests/DecoderUtilTest.cpp
index f142d2baf46..9e42cb22882 100644
--- a/velox/dwio/common/tests/DecoderUtilTest.cpp
+++ b/velox/dwio/common/tests/DecoderUtilTest.cpp
@@ -17,6 +17,7 @@
 #include "velox/dwio/common/DecoderUtil.h"
 #include <folly/Random.h>
 #include "velox/common/base/Nulls.h"
+#include "velox/dwio/common/SelectiveColumnReader.h"
 #include "velox/type/Filter.h"
 
 #include <gtest/gtest.h>
@@ -161,17 +162,6 @@ TEST_F(DecoderUtilTest, nonNullsFromSparse) {
   }
 }
 
-namespace facebook::velox::dwio::common {
-// Excerpt from LazyVector.h.
-struct NoHook {
-  void addValues(
-      const int32_t* /*rows*/,
-      const int32_t* /*values*/,
-      int32_t /*size*/) {}
-};
-
-} // namespace facebook::velox::dwio::common
-
 TEST_F(DecoderUtilTest, processFixedWithRun) {
   // Tests processing consecutive batches of integers with processFixedWidthRun.
   constexpr int kSize = 100;
@@ -233,3 +223,35 @@ TEST_F(DecoderUtilTest, processFixedWithRun) {
     }
   }
 }
+
+TEST_F(DecoderUtilTest, fixedWidthScanMemcpyFastPath) {
+  constexpr int kSize = 10;
+  int32_t rows[kSize];
+  std::iota(std::begin(rows), std::end(rows), 0);
+  float expectedValues[kSize], actualValues[kSize];
+  for (int i = 0; i < kSize; ++i) {
+    expectedValues[i] = std::sin(i);
+    actualValues[i] = NAN;
+  }
+  int32_t numValues = 0;
+  SeekableArrayInputStream input(
+      reinterpret_cast<const uint8_t*>(expectedValues), sizeof(expectedValues));
+  const char* bufferStart = nullptr;
+  const char* bufferEnd = nullptr;
+  NoHook noHook;
+  fixedWidthScan<float, false, false>(
+      {rows, kSize},
+      nullptr,
+      actualValues,
+      nullptr,
+      numValues,
+      input,
+      bufferStart,
+      bufferEnd,
+      common::AlwaysTrue(),
+      noHook);
+  for (int i = 0; i < kSize; ++i) {
+    ASSERT_EQ(actualValues[i], expectedValues[i]);
+  }
+  ASSERT_EQ(numValues, kSize);
+}
diff --git a/velox/dwio/common/tests/DirectBufferedInputTest.cpp b/velox/dwio/common/tests/DirectBufferedInputTest.cpp
new file mode 100644
index 00000000000..a7a0f48591e
--- /dev/null
+++ b/velox/dwio/common/tests/DirectBufferedInputTest.cpp
@@ -0,0 +1,918 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/common/DirectBufferedInput.h"
+
+#include <fmt/core.h>
+#include <folly/executors/CPUThreadPoolExecutor.h>
+#include <folly/synchronization/Baton.h>
+#include <gtest/gtest.h>
+#include <thread>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/caching/FileIds.h"
+#include "velox/common/file/tests/TestUtils.h"
+#include "velox/common/io/IoStatistics.h"
+#include "velox/common/io/Options.h"
+#include "velox/common/testutil/TestValue.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::dwio::common;
+using namespace facebook::velox::cache;
+using namespace facebook::velox::memory;
+using facebook::velox::common::testutil::TestValue;
+
+namespace {
+
+std::optional<std::string> getNext(SeekableInputStream& input) {
+  const void* buf = nullptr;
+  int32_t size;
+  if (input.Next(&buf, &size)) {
+    return std::string(
+        static_cast<const char*>(buf), static_cast<size_t>(size));
+  } else {
+    return std::nullopt;
+  }
+}
+
+class DirectBufferedInputTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    TestValue::enable();
+    MemoryManager::testingSetInstance(MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    executor_ = std::make_unique<folly::CPUThreadPoolExecutor>(10);
+    tracker_ = std::make_shared<ScanTracker>(
+        "testTracker", nullptr, 256 << 10 /* 256KB */);
+    rootPool_ = memoryManager()->addRootPool();
+    pool_ = rootPool_->addLeafChild("DirectBufferedInputTest");
+  }
+
+  void TearDown() override {
+    executor_.reset();
+  }
+
+  const std::shared_ptr<IoStatistics> dataIoStats_{
+      std::make_shared<IoStatistics>()};
+  const std::shared_ptr<IoStatistics> metadataIoStats_{
+      std::make_shared<IoStatistics>()};
+
+  std::unique_ptr<folly::CPUThreadPoolExecutor> executor_;
+  std::shared_ptr<MemoryPool> rootPool_;
+  std::shared_ptr<MemoryPool> pool_;
+  std::shared_ptr<ScanTracker> tracker_;
+};
+
+TEST_F(DirectBufferedInputTest, reset) {
+  constexpr int32_t kContentSize = 4 << 20; // 4MB
+  std::string content;
+  content.resize(kContentSize);
+  for (int32_t i = 0; i < kContentSize; ++i) {
+    content[i] = static_cast<char>('a' + (i % 26));
+  }
+
+  // Test both tiny and non-tiny region sizes.
+  for (const bool tinyRegion : {false, true}) {
+    SCOPED_TRACE(fmt::format("tinyRegion: {}", tinyRegion));
+
+    const uint64_t regionSize = tinyRegion
+        ? DirectBufferedInput::kTinySize - 100
+        : DirectBufferedInput::kTinySize + 1000;
+
+    auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+    io::ReaderOptions readerOptions(pool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
+    readerOptions.setLoadQuantum(1 << 20);
+
+    auto& ids = fileIds();
+    StringIdLease fileId(ids, "testFile");
+    StringIdLease groupId(ids, "testGroup");
+
+    DirectBufferedInput input(
+        readFile,
+        MetricsLog::voidLog(),
+        std::move(fileId),
+        tracker_,
+        std::move(groupId),
+        dataIoStats_,
+        nullptr,
+        executor_.get(),
+        readerOptions);
+
+    // First round: enqueue and load streams.
+    auto stream1 = input.enqueue(common::Region{0, regionSize}, nullptr);
+    auto stream2 =
+        input.enqueue(common::Region{regionSize, regionSize}, nullptr);
+    ASSERT_NE(stream1, nullptr);
+    ASSERT_NE(stream2, nullptr);
+
+    input.load(LogType::TEST);
+
+    EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 2);
+    EXPECT_EQ(input.testingCoalescedLoads().size(), 1);
+
+    // Consume streams.
+    auto next1 = getNext(*stream1);
+    ASSERT_TRUE(next1.has_value());
+    EXPECT_EQ(next1.value(), content.substr(0, regionSize));
+    EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 1);
+    EXPECT_EQ(input.testingCoalescedLoads().size(), 1);
+
+    auto next2 = getNext(*stream2);
+    ASSERT_TRUE(next2.has_value());
+    EXPECT_EQ(next2.value(), content.substr(regionSize, regionSize));
+    EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 0);
+    EXPECT_EQ(input.testingCoalescedLoads().size(), 1);
+
+    if (tinyRegion) {
+      ASSERT_EQ(pool_->usedBytes(), 0);
+    } else {
+      ASSERT_GT(pool_->usedBytes(), 0);
+    }
+
+    stream1.reset();
+    stream2.reset();
+
+    EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 0);
+    EXPECT_EQ(input.testingCoalescedLoads().size(), 1);
+    ASSERT_EQ(pool_->usedBytes(), 0);
+
+    // Reset the input.
+    input.reset();
+    EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 0);
+    EXPECT_EQ(input.testingCoalescedLoads().size(), 0);
+    ASSERT_EQ(pool_->usedBytes(), 0);
+
+    // Second round: enqueue different regions after reset.
+    auto stream3 =
+        input.enqueue(common::Region{2 * regionSize, regionSize}, nullptr);
+    auto stream4 =
+        input.enqueue(common::Region{3 * regionSize, regionSize}, nullptr);
+    ASSERT_NE(stream3, nullptr);
+    ASSERT_NE(stream4, nullptr);
+
+    input.load(LogType::TEST);
+
+    EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 2);
+    EXPECT_EQ(input.testingCoalescedLoads().size(), 1);
+
+    auto next3 = getNext(*stream3);
+    ASSERT_TRUE(next3.has_value());
+    EXPECT_EQ(next3.value(), content.substr(2 * regionSize, regionSize));
+
+    auto next4 = getNext(*stream4);
+    ASSERT_TRUE(next4.has_value());
+    EXPECT_EQ(next4.value(), content.substr(3 * regionSize, regionSize));
+
+    if (tinyRegion) {
+      ASSERT_EQ(pool_->usedBytes(), 0);
+    } else {
+      ASSERT_GT(pool_->usedBytes(), 0);
+    }
+
+    // Reset the input.
+    input.reset();
+
+    if (tinyRegion) {
+      ASSERT_EQ(pool_->usedBytes(), 0);
+    } else {
+      ASSERT_GT(pool_->usedBytes(), 0);
+    }
+
+    EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 0);
+    EXPECT_EQ(input.testingCoalescedLoads().size(), 0);
+
+    stream3.reset();
+    stream4.reset();
+    ASSERT_EQ(pool_->usedBytes(), 0);
+  }
+}
+
+TEST_F(DirectBufferedInputTest, readAfterReset) {
+  constexpr int32_t kContentSize = 4 << 20; // 4MB
+  std::string content;
+  content.resize(kContentSize);
+  for (int32_t i = 0; i < kContentSize; ++i) {
+    content[i] = static_cast<char>('a' + (i % 26));
+  }
+
+  // Test both tiny and non-tiny region sizes.
+  for (const bool tinyRegion : {false, true}) {
+    SCOPED_TRACE(fmt::format("tinyRegion: {}", tinyRegion));
+
+    const uint64_t regionSize = tinyRegion
+        ? DirectBufferedInput::kTinySize - 100
+        : DirectBufferedInput::kTinySize + 1000;
+
+    auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+    io::ReaderOptions readerOptions(pool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
+    readerOptions.setLoadQuantum(1 << 20);
+
+    auto& ids = fileIds();
+    StringIdLease fileId(ids, "testFile");
+    StringIdLease groupId(ids, "testGroup");
+
+    DirectBufferedInput input(
+        readFile,
+        MetricsLog::voidLog(),
+        std::move(fileId),
+        tracker_,
+        std::move(groupId),
+        dataIoStats_,
+        nullptr,
+        executor_.get(),
+        readerOptions);
+
+    // Enqueue and load streams.
+    auto stream1 = input.enqueue(common::Region{0, regionSize}, nullptr);
+    auto stream2 =
+        input.enqueue(common::Region{regionSize, regionSize}, nullptr);
+    ASSERT_NE(stream1, nullptr);
+    ASSERT_NE(stream2, nullptr);
+
+    input.load(LogType::TEST);
+
+    // Reset the input before reading from streams.
+    input.reset();
+
+    EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 0);
+    EXPECT_EQ(input.testingCoalescedLoads().size(), 0);
+
+    // Read from streams after reset - data should still be available.
+    auto next1 = getNext(*stream1);
+    ASSERT_TRUE(next1.has_value());
+    EXPECT_EQ(next1.value(), content.substr(0, regionSize));
+    if (tinyRegion) {
+      ASSERT_EQ(pool_->usedBytes(), 0);
+    } else {
+      ASSERT_GT(pool_->usedBytes(), 0);
+    }
+
+    auto next2 = getNext(*stream2);
+    ASSERT_TRUE(next2.has_value());
+    EXPECT_EQ(next2.value(), content.substr(regionSize, regionSize));
+    if (tinyRegion) {
+      ASSERT_EQ(pool_->usedBytes(), 0);
+    } else {
+      ASSERT_GT(pool_->usedBytes(), 0);
+    }
+
+    stream1.reset();
+    stream2.reset();
+    while (pool_->usedBytes() > 0) {
+      std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
+  }
+}
+
+DEBUG_ONLY_TEST_F(DirectBufferedInputTest, resetInputWithBeforeLoading) {
+  constexpr int32_t kContentSize = 4 << 20; // 4MB
+  std::string content;
+  content.resize(kContentSize);
+  for (int32_t i = 0; i < kContentSize; ++i) {
+    content[i] = static_cast<char>('a' + (i % 26));
+  }
+
+  // Test both tiny and non-tiny region sizes.
+  for (const bool tinyRegion : {false, true}) {
+    SCOPED_TRACE(fmt::format("tinyRegion: {}", tinyRegion));
+
+    const uint64_t regionSize = tinyRegion
+        ? DirectBufferedInput::kTinySize - 100
+        : DirectBufferedInput::kTinySize + 1000;
+
+    auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+    io::ReaderOptions readerOptions(pool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
+    readerOptions.setLoadQuantum(1 << 20);
+
+    auto& ids = fileIds();
+    StringIdLease fileId(ids, "testFile");
+    StringIdLease groupId(ids, "testGroup");
+
+    DirectBufferedInput input(
+        readFile,
+        MetricsLog::voidLog(),
+        std::move(fileId),
+        tracker_,
+        std::move(groupId),
+        dataIoStats_,
+        nullptr,
+        executor_.get(),
+        readerOptions);
+
+    // Block the coalesced load to verify references are held.
+    folly::Baton<> loadStarted;
+    folly::Baton<> loadAllowed;
+
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::cache::CoalescedLoad::loadOrFuture",
+        std::function<void(const CoalescedLoad*)>(
+            [&](const CoalescedLoad* /*load*/) {
+              loadStarted.post();
+              loadAllowed.wait();
+            }));
+
+    // Enqueue and load streams.
+    auto stream1 = input.enqueue(common::Region{0, regionSize}, nullptr);
+    auto stream2 =
+        input.enqueue(common::Region{regionSize, regionSize}, nullptr);
+    ASSERT_NE(stream1, nullptr);
+    ASSERT_NE(stream2, nullptr);
+
+    ASSERT_EQ(pool_->usedBytes(), 0);
+    input.load(LogType::TEST);
+    ASSERT_EQ(pool_->usedBytes(), 0);
+
+    // Wait for the load to start (but it's blocked).
+    loadStarted.wait();
+    ASSERT_EQ(pool_->usedBytes(), 0);
+
+    // Verify coalesced load references are held.
+    EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 2);
+    EXPECT_EQ(input.testingCoalescedLoads().size(), 1);
+
+    // Reset the input while load is pending.
+    input.reset();
+    ASSERT_EQ(pool_->usedBytes(), 0);
+
+    // After reset, internal tracking should be cleared.
+    EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 0);
+    EXPECT_EQ(input.testingCoalescedLoads().size(), 0);
+
+    // Allow the load to proceed but cancelled.
+    loadAllowed.post();
+
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    ASSERT_EQ(pool_->usedBytes(), 0);
+
+    // Read from streams - data should be available after load completes.
+    auto next1 = getNext(*stream1);
+    ASSERT_TRUE(next1.has_value());
+    EXPECT_EQ(next1.value(), content.substr(0, regionSize));
+    if (tinyRegion) {
+      ASSERT_EQ(pool_->usedBytes(), 0);
+    } else {
+      ASSERT_GT(pool_->usedBytes(), 0);
+    }
+
+    auto next2 = getNext(*stream2);
+    ASSERT_TRUE(next2.has_value());
+    EXPECT_EQ(next2.value(), content.substr(regionSize, regionSize));
+    if (tinyRegion) {
+      ASSERT_EQ(pool_->usedBytes(), 0);
+    } else {
+      ASSERT_GT(pool_->usedBytes(), 0);
+    }
+    stream1.reset();
+    stream2.reset();
+    ASSERT_EQ(pool_->usedBytes(), 0);
+  }
+}
+
+DEBUG_ONLY_TEST_F(DirectBufferedInputTest, resetInputWithAfterLoading) {
+  constexpr int32_t kContentSize = 4 << 20; // 4MB
+  std::string content;
+  content.resize(kContentSize);
+  for (int32_t i = 0; i < kContentSize; ++i) {
+    content[i] = static_cast<char>('a' + (i % 26));
+  }
+
+  // Test both tiny and non-tiny region sizes.
+  for (const bool tinyRegion : {false, true}) {
+    SCOPED_TRACE(fmt::format("tinyRegion: {}", tinyRegion));
+
+    const uint64_t regionSize = tinyRegion
+        ? DirectBufferedInput::kTinySize - 100
+        : DirectBufferedInput::kTinySize + 1000;
+
+    auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+    io::ReaderOptions readerOptions(pool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
+    readerOptions.setLoadQuantum(1 << 20);
+
+    auto& ids = fileIds();
+    StringIdLease fileId(ids, "testFile");
+    StringIdLease groupId(ids, "testGroup");
+
+    DirectBufferedInput input(
+        readFile,
+        MetricsLog::voidLog(),
+        std::move(fileId),
+        tracker_,
+        std::move(groupId),
+        dataIoStats_,
+        nullptr,
+        executor_.get(),
+        readerOptions);
+
+    // Block the coalesced load to verify references are held.
+    folly::Baton<> loadStarted;
+    folly::Baton<> loadAllowed;
+
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::cache::CoalescedLoad::loadOrFuture::loading",
+        std::function<void(const CoalescedLoad*)>(
+            [&](const CoalescedLoad* /*load*/) {
+              loadStarted.post();
+              loadAllowed.wait();
+            }));
+
+    // Enqueue and load streams.
+    auto stream1 = input.enqueue(common::Region{0, regionSize}, nullptr);
+    auto stream2 =
+        input.enqueue(common::Region{regionSize, regionSize}, nullptr);
+    ASSERT_NE(stream1, nullptr);
+    ASSERT_NE(stream2, nullptr);
+
+    ASSERT_EQ(pool_->usedBytes(), 0);
+    input.load(LogType::TEST);
+    ASSERT_EQ(pool_->usedBytes(), 0);
+
+    // Wait for the load to start (but it's blocked).
+    loadStarted.wait();
+    ASSERT_EQ(pool_->usedBytes(), 0);
+
+    // Verify coalesced load references are held.
+    EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 2);
+    EXPECT_EQ(input.testingCoalescedLoads().size(), 1);
+
+    // Reset the input while load is pending.
+    input.reset();
+    ASSERT_EQ(pool_->usedBytes(), 0);
+
+    // After reset, internal tracking should be cleared.
+    EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 0);
+    EXPECT_EQ(input.testingCoalescedLoads().size(), 0);
+
+    // Allow the load to proceed without cancelling.
+    loadAllowed.post();
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+
+    // Read from streams - data should be available after load completes.
+    auto next1 = getNext(*stream1);
+    ASSERT_TRUE(next1.has_value());
+    EXPECT_EQ(next1.value(), content.substr(0, regionSize));
+    if (tinyRegion) {
+      ASSERT_EQ(pool_->usedBytes(), 0);
+    } else {
+      ASSERT_GT(pool_->usedBytes(), 0);
+    }
+
+    auto next2 = getNext(*stream2);
+    ASSERT_TRUE(next2.has_value());
+    EXPECT_EQ(next2.value(), content.substr(regionSize, regionSize));
+    if (tinyRegion) {
+      ASSERT_EQ(pool_->usedBytes(), 0);
+    } else {
+      ASSERT_GT(pool_->usedBytes(), 0);
+    }
+    stream1.reset();
+    stream2.reset();
+    while (pool_->usedBytes() > 0) {
+      std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
+  }
+}
+
+TEST_F(DirectBufferedInputTest, preloadCalledTwice) {
+  std::string content(1024, 'x');
+  auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "preloadTwice");
+  StringIdLease groupId(ids, "preloadTwiceGroup");
+
+  DirectBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  input.preload();
+  ASSERT_TRUE(input.preloaded());
+  VELOX_ASSERT_THROW(input.preload(), "preload() called more than once");
+}
+
+TEST_F(DirectBufferedInputTest, isBufferedWithPreload) {
+  std::string content(1024, 'x');
+  auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "isBufferedPreload");
+  StringIdLease groupId(ids, "isBufferedPreloadGroup");
+
+  DirectBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  // Before preload, isBuffered should return false.
+  EXPECT_FALSE(input.isBuffered(0, 100));
+
+  input.preload();
+  ASSERT_TRUE(input.preloaded());
+
+  // After preload, isBuffered should return true.
+  EXPECT_TRUE(input.isBuffered(0, 100));
+  EXPECT_TRUE(input.isBuffered(500, 200));
+}
+
+TEST_F(DirectBufferedInputTest, enqueueSkipsRequestsWhenPreloaded) {
+  std::string content(1024, 'x');
+  auto readFile = std::make_shared<tests::utils::CountingReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "enqueueSkipsRequests");
+  StringIdLease groupId(ids, "enqueueSkipsRequestsGroup");
+
+  DirectBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  ASSERT_EQ(readFile->numReads(), 0);
+
+  input.preload();
+  ASSERT_TRUE(input.preloaded());
+  ASSERT_EQ(readFile->numReads(), 1);
+
+  // After preload, enqueue should not add to requests or coalesced loads.
+  auto stream = input.enqueue(common::Region{0, 100}, nullptr);
+  ASSERT_NE(stream, nullptr);
+
+  // Verify no coalesced loads were created (requests are skipped when
+  // preloaded).
+  EXPECT_EQ(input.testingCoalescedLoads().size(), 0);
+  EXPECT_EQ(input.testingStreamToCoalescedLoadSize(), 0);
+
+  // Stream should still be able to read data from preloaded content.
+  auto next = getNext(*stream);
+  ASSERT_TRUE(next.has_value());
+  EXPECT_EQ(next.value(), content.substr(0, 100));
+
+  // No additional file reads - all served from preloaded data.
+  ASSERT_EQ(readFile->numReads(), 1);
+}
+
+TEST_F(DirectBufferedInputTest, preloadAfterEnqueue) {
+  std::string content(1024, 'x');
+  auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "preloadAfterEnqueue");
+  StringIdLease groupId(ids, "preloadAfterEnqueueGroup");
+
+  DirectBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  input.enqueue({0, 100}, nullptr);
+  VELOX_ASSERT_THROW(
+      input.preload(), "preload() must be called before enqueue()");
+}
+
+TEST_F(DirectBufferedInputTest, preloadedDataWithoutPreload) {
+  std::string content(1024, 'x');
+  auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "preloadedDataNoPreload");
+  StringIdLease groupId(ids, "preloadedDataNoPreloadGroup");
+
+  DirectBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  VELOX_ASSERT_THROW(
+      input.preloadedData(0, 100), "preloadedData() called without preload");
+}
+
+TEST_F(DirectBufferedInputTest, preloadedDataOffsetOutOfRange) {
+  std::string content(1024, 'x');
+  auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "preloadedDataOOR");
+  StringIdLease groupId(ids, "preloadedDataOORGroup");
+
+  DirectBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  input.preload();
+  VELOX_ASSERT_THROW(
+      input.preloadedData(1024, 100), "Offset exceeds preloaded size");
+}
+
+TEST_F(DirectBufferedInputTest, preload) {
+  struct TestParam {
+    uint64_t fileSize;
+    std::string debugString() const {
+      return fmt::format("fileSize {}", fileSize);
+    }
+  };
+  std::vector<TestParam> testSettings = {
+      // Tiny file (below kTinySize).
+      {DirectBufferedInput::kTinySize - 100},
+      // Non-tiny file (above kTinySize).
+      {DirectBufferedInput::kTinySize + 1000},
+      // Larger file.
+      {1 << 20},
+  };
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    std::string content;
+    content.resize(testData.fileSize);
+    for (uint64_t i = 0; i < testData.fileSize; ++i) {
+      content[i] = static_cast<char>('a' + (i % 26));
+    }
+    auto readFile = std::make_shared<tests::utils::CountingReadFile>(content);
+
+    io::ReaderOptions readerOptions(pool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
+    readerOptions.setLoadQuantum(1 << 20);
+
+    auto& ids = fileIds();
+    StringIdLease fileId(ids, fmt::format("preloadTest_{}", testData.fileSize));
+    StringIdLease groupId(
+        ids, fmt::format("preloadGroup_{}", testData.fileSize));
+
+    DirectBufferedInput input(
+        readFile,
+        MetricsLog::voidLog(),
+        std::move(fileId),
+        tracker_,
+        std::move(groupId),
+        dataIoStats_,
+        nullptr,
+        executor_.get(),
+        readerOptions);
+
+    ASSERT_EQ(readFile->numReads(), 0);
+    EXPECT_FALSE(input.preloaded());
+
+    input.preload();
+
+    EXPECT_TRUE(input.preloaded());
+
+    ASSERT_EQ(readFile->numReads(), 1);
+
+    // Enqueue sub-region streams and read from preloaded data.
+    const uint64_t regionSize =
+        std::min<uint64_t>(testData.fileSize / 2, testData.fileSize);
+    auto stream1 = input.enqueue(common::Region{0, regionSize}, nullptr);
+    ASSERT_NE(stream1, nullptr);
+
+    auto next1 = getNext(*stream1);
+    ASSERT_TRUE(next1.has_value());
+    EXPECT_EQ(next1.value(), content.substr(0, regionSize));
+
+    if (testData.fileSize > regionSize) {
+      auto stream2 = input.enqueue(
+          common::Region{regionSize, testData.fileSize - regionSize}, nullptr);
+      ASSERT_NE(stream2, nullptr);
+
+      auto next2 = getNext(*stream2);
+      ASSERT_TRUE(next2.has_value());
+      EXPECT_EQ(
+          next2.value(),
+          content.substr(regionSize, testData.fileSize - regionSize));
+    }
+
+    // No additional file reads after preload.
+    ASSERT_EQ(readFile->numReads(), 1);
+  }
+}
+
+TEST_F(DirectBufferedInputTest, preloadedData) {
+  struct TestParam {
+    uint64_t fileSize;
+    uint64_t offset;
+    uint64_t length;
+    // Expected size of the returned range. For tiny files, this equals
+    // min(length, fileSize - offset). For large files, it may be smaller
+    // due to non-contiguous allocation run boundaries.
+    bool expectTinyPath;
+    std::string debugString() const {
+      return fmt::format(
+          "fileSize {}, offset {}, length {}, expectTinyPath {}",
+          fileSize,
+          offset,
+          length,
+          expectTinyPath);
+    }
+  };
+
+  std::vector<TestParam> testSettings = {
+      // Tiny file: read from beginning.
+      {1000, 0, 500, true},
+      // Tiny file: read from middle.
+      {1000, 400, 200, true},
+      // Tiny file: length exceeds remaining bytes.
+      {1000, 800, 500, true},
+      // Tiny file: length zero.
+      {1000, 0, 0, true},
+      // Tiny file: read last byte.
+      {1000, 999, 100, true},
+      // Tiny file: read entire file.
+      {1000, 0, 1000, true},
+      // Large file: read from beginning.
+      {1 << 20, 0, 4096, false},
+      // Large file: read from middle.
+      {1 << 20, 100'000, 4096, false},
+      // Large file: length exceeds remaining bytes.
+      {1 << 20, (1 << 20) - 100, 4096, false},
+      // Large file: length zero.
+      {1 << 20, 0, 0, false},
+      // Large file: read last byte.
+      {1 << 20, (1 << 20) - 1, 100, false},
+  };
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    std::string content;
+    content.resize(testData.fileSize);
+    for (uint64_t i = 0; i < testData.fileSize; ++i) {
+      content[i] = static_cast<char>('a' + (i % 26));
+    }
+    auto readFile = std::make_shared<tests::utils::CountingReadFile>(content);
+
+    io::ReaderOptions readerOptions(pool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
+    auto& ids = fileIds();
+    StringIdLease fileId(
+        ids,
+        fmt::format(
+            "preloadedData_{}_{}_{}",
+            testData.fileSize,
+            testData.offset,
+            testData.length));
+    StringIdLease groupId(
+        ids,
+        fmt::format(
+            "preloadedDataGroup_{}_{}_{}",
+            testData.fileSize,
+            testData.offset,
+            testData.length));
+
+    DirectBufferedInput input(
+        readFile,
+        MetricsLog::voidLog(),
+        std::move(fileId),
+        tracker_,
+        std::move(groupId),
+        dataIoStats_,
+        nullptr,
+        executor_.get(),
+        readerOptions);
+
+    ASSERT_EQ(readFile->numReads(), 0);
+    input.preload();
+    ASSERT_EQ(readFile->numReads(), 1);
+
+    const auto range = input.preloadedData(testData.offset, testData.length);
+
+    // No additional file reads — preloadedData serves from memory.
+    ASSERT_EQ(readFile->numReads(), 1);
+
+    const auto expectedAvailable = std::min<uint64_t>(
+        testData.length, testData.fileSize - testData.offset);
+
+    if (testData.length == 0) {
+      EXPECT_EQ(range.size(), 0);
+      continue;
+    }
+
+    // For tiny files, the data is contiguous so we get all available bytes.
+    // For large files, we may get fewer bytes due to allocation run boundaries.
+    EXPECT_GT(range.size(), 0);
+    EXPECT_LE(range.size(), expectedAvailable);
+    if (testData.expectTinyPath) {
+      EXPECT_EQ(range.size(), expectedAvailable);
+    }
+
+    // Verify data content matches original file.
+    EXPECT_EQ(
+        std::string_view(range.data(), range.size()),
+        std::string_view(content.data() + testData.offset, range.size()));
+  }
+}
+
+TEST_F(DirectBufferedInputTest, hasCache) {
+  std::string content(1024, 'x');
+  auto readFile = std::make_shared<InMemoryReadFile>(content);
+
+  io::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+
+  auto& ids = fileIds();
+  StringIdLease fileId(ids, "testFile");
+  StringIdLease groupId(ids, "testGroup");
+
+  DirectBufferedInput input(
+      readFile,
+      MetricsLog::voidLog(),
+      std::move(fileId),
+      tracker_,
+      std::move(groupId),
+      dataIoStats_,
+      nullptr,
+      executor_.get(),
+      readerOptions);
+
+  ASSERT_FALSE(input.hasCache());
+  VELOX_ASSERT_THROW(
+      input.cacheRegion(0, 10, std::string_view("0123456789")),
+      "cacheRegion requires a backing cache");
+  VELOX_ASSERT_THROW(
+      input.findCachedRegion(0), "findCachedRegion requires a backing cache");
+}
+
+} // namespace
diff --git a/velox/dwio/common/tests/Lemire/CMakeLists.txt b/velox/dwio/common/tests/Lemire/CMakeLists.txt
new file mode 100644
index 00000000000..16d880cbc2f
--- /dev/null
+++ b/velox/dwio/common/tests/Lemire/CMakeLists.txt
@@ -0,0 +1,17 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_subdirectory(FastPFor)
+
+velox_add_library(velox_lemire_bmipacking32 INTERFACE HEADERS bmipacking32.h)
diff --git a/velox/dwio/common/tests/Lemire/FastPFor/CMakeLists.txt b/velox/dwio/common/tests/Lemire/FastPFor/CMakeLists.txt
index d74b5b7af66..9b16a4ebf7d 100644
--- a/velox/dwio/common/tests/Lemire/FastPFor/CMakeLists.txt
+++ b/velox/dwio/common/tests/Lemire/FastPFor/CMakeLists.txt
@@ -12,5 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 add_library(velox_fastpforlib STATIC bitpacking.cpp)
+velox_add_test_headers(velox_fastpforlib bitpacking.h bitpackinghelpers.h)
 
 target_include_directories(velox_fastpforlib PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
diff --git a/velox/dwio/common/tests/LocalFileSinkTest.cpp b/velox/dwio/common/tests/LocalFileSinkTest.cpp
index c052ce1e064..4eb7cc95433 100644
--- a/velox/dwio/common/tests/LocalFileSinkTest.cpp
+++ b/velox/dwio/common/tests/LocalFileSinkTest.cpp
@@ -17,15 +17,15 @@
 #include "velox/common/base/Fs.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/dwio/common/FileSink.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 #include <gtest/gtest.h>
 
 using namespace ::testing;
-using namespace facebook::velox::exec::test;
 
 namespace facebook::velox::dwio::common {
+using namespace facebook::velox::common::testutil;
 
 class LocalFileSinkTest : public testing::Test {
  protected:
@@ -79,4 +79,74 @@ TEST_F(LocalFileSinkTest, existFileCheck) {
       "File exists");
 }
 
+TEST_F(LocalFileSinkTest, getIoStatisticsReturnsNullWhenNotProvided) {
+  LocalFileSink::registerFactory();
+  auto root = TempDirectoryPath::create();
+  auto filePath = fs::path(root->getPath()) / "test_stats_null.ext";
+
+  auto localFileSink = FileSink::create(
+      fmt::format("file:{}", filePath.string()), {.pool = pool_.get()});
+
+  EXPECT_EQ(localFileSink->getIoStatistics(), nullptr);
+  localFileSink->close();
+}
+
+TEST_F(LocalFileSinkTest, getIoStatisticsReturnsProvidedStats) {
+  LocalFileSink::registerFactory();
+  auto root = TempDirectoryPath::create();
+  auto filePath = fs::path(root->getPath()) / "test_stats_provided.ext";
+
+  IoStatistics ioStats;
+  auto localFileSink = FileSink::create(
+      fmt::format("file:{}", filePath.string()),
+      {.pool = pool_.get(), .stats = &ioStats});
+
+  EXPECT_EQ(localFileSink->getIoStatistics(), &ioStats);
+  localFileSink->close();
+}
+
+TEST_F(LocalFileSinkTest, getFileSystemStatsReturnsNullWhenNotProvided) {
+  LocalFileSink::registerFactory();
+  auto root = TempDirectoryPath::create();
+  auto filePath = fs::path(root->getPath()) / "test_fs_stats_null.ext";
+
+  auto localFileSink = FileSink::create(
+      fmt::format("file:{}", filePath.string()), {.pool = pool_.get()});
+
+  EXPECT_EQ(localFileSink->getFileSystemStats(), nullptr);
+  localFileSink->close();
+}
+
+TEST_F(LocalFileSinkTest, getFileSystemStatsReturnsProvidedStats) {
+  LocalFileSink::registerFactory();
+  auto root = TempDirectoryPath::create();
+  auto filePath = fs::path(root->getPath()) / "test_fs_stats_provided.ext";
+
+  velox::IoStats fileSystemStats;
+  auto localFileSink = FileSink::create(
+      fmt::format("file:{}", filePath.string()),
+      {.pool = pool_.get(), .fileSystemStats = &fileSystemStats});
+
+  EXPECT_EQ(localFileSink->getFileSystemStats(), &fileSystemStats);
+  localFileSink->close();
+}
+
+TEST_F(LocalFileSinkTest, getFileSystemStatsAndIoStatisticsBothProvided) {
+  LocalFileSink::registerFactory();
+  auto root = TempDirectoryPath::create();
+  auto filePath = fs::path(root->getPath()) / "test_both_stats.ext";
+
+  IoStatistics ioStats;
+  velox::IoStats fileSystemStats;
+  auto localFileSink = FileSink::create(
+      fmt::format("file:{}", filePath.string()),
+      {.pool = pool_.get(),
+       .stats = &ioStats,
+       .fileSystemStats = &fileSystemStats});
+
+  EXPECT_EQ(localFileSink->getIoStatistics(), &ioStats);
+  EXPECT_EQ(localFileSink->getFileSystemStats(), &fileSystemStats);
+  localFileSink->close();
+}
+
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/tests/LoggedExceptionTest.cpp b/velox/dwio/common/tests/LoggedExceptionTest.cpp
index 6eea7e8b5c7..0f17e1f50a3 100644
--- a/velox/dwio/common/tests/LoggedExceptionTest.cpp
+++ b/velox/dwio/common/tests/LoggedExceptionTest.cpp
@@ -34,11 +34,12 @@ void testTraceCollectionSwitchControl(bool enabled) {
   try {
     throw LoggedException("Test error message");
   } catch (VeloxException& e) {
-    SCOPED_TRACE(fmt::format(
-        "enabled: {}, user flag: {}, sys flag: {}",
-        enabled,
-        FLAGS_velox_exception_user_stacktrace_enabled,
-        FLAGS_velox_exception_system_stacktrace_enabled));
+    SCOPED_TRACE(
+        fmt::format(
+            "enabled: {}, user flag: {}, sys flag: {}",
+            enabled,
+            FLAGS_velox_exception_user_stacktrace_enabled,
+            FLAGS_velox_exception_system_stacktrace_enabled));
     ASSERT_TRUE(e.exceptionType() == VeloxException::Type::kSystem);
     ASSERT_EQ(enabled, e.stackTrace() != nullptr);
   }
diff --git a/velox/dwio/common/tests/OnDemandUnitLoaderTests.cpp b/velox/dwio/common/tests/OnDemandUnitLoaderTests.cpp
index 178ad21f9b2..245c7d6186d 100644
--- a/velox/dwio/common/tests/OnDemandUnitLoaderTests.cpp
+++ b/velox/dwio/common/tests/OnDemandUnitLoaderTests.cpp
@@ -17,9 +17,8 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/dwio/common/OnDemandUnitLoader.h"
-#include "velox/dwio/common/UnitLoaderTools.h"
+#include "velox/dwio/common/tests/UnitLoaderBaseTest.h"
 #include "velox/dwio/common/tests/utils/UnitLoaderTestTools.h"
 
 using namespace ::testing;
@@ -31,6 +30,38 @@ using facebook::velox::dwio::common::test::getUnitsLoadedWithFalse;
 using facebook::velox::dwio::common::test::LoadUnitMock;
 using facebook::velox::dwio::common::test::ReaderMock;
 
+class OnDemandUnitLoaderCommonTests
+    : public UnitLoaderBaseTest<OnDemandUnitLoaderFactory> {
+ protected:
+  OnDemandUnitLoaderFactory createFactory() override {
+    return OnDemandUnitLoaderFactory(nullptr);
+  }
+};
+
+TEST_F(OnDemandUnitLoaderCommonTests, NoUnitButSkip) {
+  testNoUnitButSkip();
+}
+
+TEST_F(OnDemandUnitLoaderCommonTests, InitialSkip) {
+  testInitialSkip();
+}
+
+TEST_F(OnDemandUnitLoaderCommonTests, CanRequestUnitMultipleTimes) {
+  testCanRequestUnitMultipleTimes();
+}
+
+TEST_F(OnDemandUnitLoaderCommonTests, UnitOutOfRange) {
+  testUnitOutOfRange();
+}
+
+TEST_F(OnDemandUnitLoaderCommonTests, SeekOutOfRange) {
+  testSeekOutOfRange();
+}
+
+TEST_F(OnDemandUnitLoaderCommonTests, SeekOutOfRangeReaderError) {
+  testSeekOutOfRangeReaderError();
+}
+
 TEST(OnDemandUnitLoaderTests, LoadsCorrectlyWithReader) {
   size_t blockedOnIoCount = 0;
   OnDemandUnitLoaderFactory factory([&](auto) { ++blockedOnIoCount; });
@@ -127,96 +158,3 @@ TEST(OnDemandUnitLoaderTests, CanSeek) {
   EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({true, false, false}));
   EXPECT_EQ(blockedOnIoCount, 4);
 }
-
-TEST(OnDemandUnitLoaderTests, SeekOutOfRangeReaderError) {
-  size_t blockedOnIoCount = 0;
-  OnDemandUnitLoaderFactory factory([&](auto) { ++blockedOnIoCount; });
-  ReaderMock readerMock{{10, 20, 30}, {0, 0, 0}, factory, 0};
-  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({false, false, false}));
-  EXPECT_EQ(blockedOnIoCount, 0);
-  readerMock.seek(59);
-
-  readerMock.seek(60);
-
-  VELOX_ASSERT_THROW(
-      readerMock.seek(61),
-      "Can't seek to possition 61 in file. Must be up to 60.");
-}
-
-TEST(OnDemandUnitLoaderTests, SeekOutOfRange) {
-  OnDemandUnitLoaderFactory factory(nullptr);
-  std::vector<std::atomic_bool> unitsLoaded(getUnitsLoadedWithFalse(1));
-  std::vector<std::unique_ptr<LoadUnit>> units;
-  units.push_back(std::make_unique<LoadUnitMock>(10, 0, unitsLoaded, 0));
-
-  auto unitLoader = factory.create(std::move(units), 0);
-
-  unitLoader->onSeek(0, 10);
-
-  VELOX_ASSERT_THROW(unitLoader->onSeek(0, 11), "Row out of range");
-}
-
-TEST(OnDemandUnitLoaderTests, UnitOutOfRange) {
-  OnDemandUnitLoaderFactory factory(nullptr);
-  std::vector<std::atomic_bool> unitsLoaded(getUnitsLoadedWithFalse(1));
-  std::vector<std::unique_ptr<LoadUnit>> units;
-  units.push_back(std::make_unique<LoadUnitMock>(10, 0, unitsLoaded, 0));
-
-  auto unitLoader = factory.create(std::move(units), 0);
-  unitLoader->getLoadedUnit(0);
-
-  VELOX_ASSERT_THROW(unitLoader->getLoadedUnit(1), "Unit out of range");
-}
-
-TEST(OnDemandUnitLoaderTests, CanRequestUnitMultipleTimes) {
-  OnDemandUnitLoaderFactory factory(nullptr);
-  std::vector<std::atomic_bool> unitsLoaded(getUnitsLoadedWithFalse(1));
-  std::vector<std::unique_ptr<LoadUnit>> units;
-  units.push_back(std::make_unique<LoadUnitMock>(10, 0, unitsLoaded, 0));
-
-  auto unitLoader = factory.create(std::move(units), 0);
-  unitLoader->getLoadedUnit(0);
-  unitLoader->getLoadedUnit(0);
-  unitLoader->getLoadedUnit(0);
-}
-
-TEST(OnDemandUnitLoaderTests, InitialSkip) {
-  auto getFactoryWithSkip = [](uint64_t skipToRow) {
-    auto factory = std::make_unique<OnDemandUnitLoaderFactory>(nullptr);
-    std::vector<std::atomic_bool> unitsLoaded(getUnitsLoadedWithFalse(1));
-    std::vector<std::unique_ptr<LoadUnit>> units;
-    units.push_back(std::make_unique<LoadUnitMock>(10, 0, unitsLoaded, 0));
-    units.push_back(std::make_unique<LoadUnitMock>(20, 0, unitsLoaded, 1));
-    units.push_back(std::make_unique<LoadUnitMock>(30, 0, unitsLoaded, 2));
-    factory->create(std::move(units), skipToRow);
-  };
-
-  EXPECT_NO_THROW(getFactoryWithSkip(0));
-  EXPECT_NO_THROW(getFactoryWithSkip(1));
-  EXPECT_NO_THROW(getFactoryWithSkip(9));
-  EXPECT_NO_THROW(getFactoryWithSkip(10));
-  EXPECT_NO_THROW(getFactoryWithSkip(11));
-  EXPECT_NO_THROW(getFactoryWithSkip(29));
-  EXPECT_NO_THROW(getFactoryWithSkip(30));
-  EXPECT_NO_THROW(getFactoryWithSkip(31));
-  EXPECT_NO_THROW(getFactoryWithSkip(59));
-  EXPECT_NO_THROW(getFactoryWithSkip(60));
-  VELOX_ASSERT_THROW(
-      getFactoryWithSkip(61),
-      "Can only skip up to the past-the-end row of the file.");
-  VELOX_ASSERT_THROW(
-      getFactoryWithSkip(100),
-      "Can only skip up to the past-the-end row of the file.");
-}
-
-TEST(OnDemandUnitLoaderTests, NoUnitButSkip) {
-  OnDemandUnitLoaderFactory factory(nullptr);
-  std::vector<std::unique_ptr<LoadUnit>> units;
-
-  EXPECT_NO_THROW(factory.create(std::move(units), 0));
-
-  std::vector<std::unique_ptr<LoadUnit>> units2;
-  VELOX_ASSERT_THROW(
-      factory.create(std::move(units2), 1),
-      "Can only skip up to the past-the-end row of the file.");
-}
diff --git a/velox/dwio/common/tests/OptionsTests.cpp b/velox/dwio/common/tests/OptionsTests.cpp
index 82335821c52..427f086772e 100644
--- a/velox/dwio/common/tests/OptionsTests.cpp
+++ b/velox/dwio/common/tests/OptionsTests.cpp
@@ -25,6 +25,11 @@ TEST(OptionsTests, defaultRowNumberColumnInfoTest) {
   ASSERT_EQ(std::nullopt, rowReaderOptions.rowNumberColumnInfo());
 }
 
+TEST(OptionsTests, fluxFileFormatRoundTrip) {
+  ASSERT_EQ(FileFormat::FLUX, toFileFormat("flux"));
+  ASSERT_EQ("flux", toString(FileFormat::FLUX));
+}
+
 TEST(OptionsTests, setRowNumberColumnInfoTest) {
   RowReaderOptions rowReaderOptions;
   RowNumberColumnInfo rowNumberColumnInfo;
diff --git a/velox/dwio/common/tests/ParallelUnitLoaderTest.cpp b/velox/dwio/common/tests/ParallelUnitLoaderTest.cpp
new file mode 100644
index 00000000000..690acd9fc11
--- /dev/null
+++ b/velox/dwio/common/tests/ParallelUnitLoaderTest.cpp
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/common/ParallelUnitLoader.h"
+#include "velox/dwio/common/OnDemandUnitLoader.h"
+#include "velox/dwio/common/tests/UnitLoaderBaseTest.h"
+#include "velox/dwio/common/tests/utils/UnitLoaderTestTools.h"
+
+#include <folly/executors/CPUThreadPoolExecutor.h>
+#include <folly/futures/Future.h>
+#include <gtest/gtest.h>
+
+using namespace facebook::velox::dwio::common;
+using namespace facebook::velox::dwio::common::test;
+
+class ParallelUnitLoaderTest
+    : public UnitLoaderBaseTest<ParallelUnitLoaderFactory> {
+ protected:
+  ParallelUnitLoaderFactory createFactory() override {
+    return ParallelUnitLoaderFactory(ioExecutor_.get(), 2);
+  }
+
+  std::unique_ptr<folly::CPUThreadPoolExecutor> ioExecutor_ =
+      std::make_unique<folly::CPUThreadPoolExecutor>(10);
+};
+
+TEST_F(ParallelUnitLoaderTest, NoUnitButSkip) {
+  testNoUnitButSkip();
+}
+
+TEST_F(ParallelUnitLoaderTest, InitialSkip) {
+  testInitialSkip();
+}
+
+TEST_F(ParallelUnitLoaderTest, CanRequestUnitMultipleTimes) {
+  testCanRequestUnitMultipleTimes();
+}
+
+TEST_F(ParallelUnitLoaderTest, UnitOutOfRange) {
+  testUnitOutOfRange();
+}
+
+TEST_F(ParallelUnitLoaderTest, SeekOutOfRange) {
+  testSeekOutOfRange();
+}
+
+TEST_F(ParallelUnitLoaderTest, SeekOutOfRangeReaderError) {
+  testSeekOutOfRangeReaderError();
+}
+
+TEST_F(ParallelUnitLoaderTest, LoadsCorrectlyWithReader) {
+  auto factory = createFactory();
+  ReaderMock readerMock{{10, 20, 30}, {0, 0, 0}, factory, 0};
+
+  EXPECT_TRUE(readerMock.read(3)); // Unit: 0, rows: 0-2, load(0)
+  std::this_thread::sleep_for(std::chrono::milliseconds(500));
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({true, true, false}));
+
+  EXPECT_TRUE(readerMock.read(3)); // Unit: 0, rows: 3-5
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({true, true, false}));
+
+  EXPECT_TRUE(readerMock.read(4)); // Unit: 0, rows: 6-9
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({true, true, false}));
+
+  EXPECT_TRUE(readerMock.read(14)); // Unit: 1, rows: 0-13, unload(0), load(1)
+  std::this_thread::sleep_for(std::chrono::milliseconds(500));
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({false, true, true}));
+
+  // will only read 5 rows, no more rows in unit 1
+  EXPECT_TRUE(readerMock.read(10)); // Unit: 1, rows: 14-19
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({false, true, true}));
+
+  EXPECT_TRUE(readerMock.read(30)); // Unit: 2, rows: 0-29, unload(1), load(2)
+  std::this_thread::sleep_for(std::chrono::milliseconds(500));
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({false, false, true}));
+
+  EXPECT_FALSE(readerMock.read(30)); // No more data
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({false, false, true}));
+}
+
+// Performance comparison test
+TEST_F(ParallelUnitLoaderTest, PerformanceComparison) {
+  std::vector<uint64_t> rowsPerUnit = {100, 100, 100, 100, 100, 100, 100, 100};
+  std::vector<uint64_t> ioSizes = {
+      1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024};
+
+  // Measure ParallelUnitLoader performance
+  auto parallelStart = std::chrono::high_resolution_clock::now();
+  {
+    auto factory = createFactory();
+    ReaderMock reader(rowsPerUnit, ioSizes, factory, 0);
+
+    for (size_t i = 0; i < rowsPerUnit.size(); ++i) {
+      uint64_t totalRowsRead = 0;
+      while (totalRowsRead < rowsPerUnit[i]) {
+        reader.read(25);
+        int nextRead = rowsPerUnit[i] - totalRowsRead;
+        totalRowsRead += std::min(25, nextRead);
+      }
+    }
+  }
+  auto parallelEnd = std::chrono::high_resolution_clock::now();
+
+  // Measure OnDemandUnitLoader performance
+  auto onDemandStart = std::chrono::high_resolution_clock::now();
+  {
+    auto factory = std::make_shared<OnDemandUnitLoaderFactory>(nullptr);
+    ReaderMock reader(rowsPerUnit, ioSizes, *factory, 0);
+
+    for (size_t i = 0; i < rowsPerUnit.size(); ++i) {
+      uint64_t totalRowsRead = 0;
+      while (totalRowsRead < rowsPerUnit[i]) {
+        reader.read(25);
+        int nextRead = rowsPerUnit[i] - totalRowsRead;
+        totalRowsRead += std::min(25, nextRead);
+      }
+    }
+  }
+  auto onDemandEnd = std::chrono::high_resolution_clock::now();
+
+  auto parallelDuration = std::chrono::duration_cast<std::chrono::milliseconds>(
+      parallelEnd - parallelStart);
+  auto onDemandDuration = std::chrono::duration_cast<std::chrono::milliseconds>(
+      onDemandEnd - onDemandStart);
+
+  // ParallelUnitLoader should be faster
+  EXPECT_GT(onDemandDuration.count(), parallelDuration.count());
+}
diff --git a/velox/dwio/common/tests/ReadFileInputStreamTests.cpp b/velox/dwio/common/tests/ReadFileInputStreamTests.cpp
index 273b523549f..1b600b6adaf 100644
--- a/velox/dwio/common/tests/ReadFileInputStreamTests.cpp
+++ b/velox/dwio/common/tests/ReadFileInputStreamTests.cpp
@@ -15,8 +15,8 @@
  */
 
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempFilePath.h"
 #include "velox/dwio/common/InputStream.h"
-#include "velox/exec/tests/utils/TempFilePath.h"
 
 #include <string_view>
 #include "folly/io/Cursor.h"
@@ -24,6 +24,7 @@
 #include "gtest/gtest.h"
 
 using namespace facebook::velox;
+using namespace facebook::velox::common::testutil;
 using namespace facebook::velox::dwio::common;
 using facebook::velox::common::Region;
 
@@ -35,7 +36,7 @@ class ReadFileInputStreamTest : public testing::Test {
 };
 
 TEST_F(ReadFileInputStreamTest, LocalReadFile) {
-  auto tempFile = exec::test::TempFilePath::create();
+  auto tempFile = TempFilePath::create();
   const auto& filename = tempFile->getPath();
   remove(filename.c_str());
   {
diff --git a/velox/dwio/common/tests/ReadVuLongBenchmark.cpp b/velox/dwio/common/tests/ReadVuLongBenchmark.cpp
new file mode 100644
index 00000000000..5cc0b2aabb1
--- /dev/null
+++ b/velox/dwio/common/tests/ReadVuLongBenchmark.cpp
@@ -0,0 +1,319 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Benchmark comparing old vs new readVuLong implementation.
+// The "old" version uses UNLIKELY for the first byte termination check.
+// The "new" version (in production IntDecoder.h) uses LIKELY and early return.
+
+#include "folly/Benchmark.h"
+#include "folly/Random.h"
+#include "folly/Varint.h"
+#include "folly/init/Init.h"
+#include "velox/dwio/common/IntCodecCommon.h"
+
+using namespace facebook::velox::dwio::common;
+
+constexpr size_t kNumElements = 1000000;
+
+// Encapsulates benchmark state to avoid global mutable variables.
+struct BenchmarkState {
+  std::vector<char> bufferSmall; // Values 0-127 (1-byte varints)
+  std::vector<char> bufferMedium; // Values 0-16383 (1-2 byte varints)
+  std::vector<char> bufferMixed; // Random uint32 (1-5 byte varints)
+
+  size_t lenSmall{0};
+  size_t lenMedium{0};
+  size_t lenMixed{0};
+
+  size_t numValuesSmall{0};
+  size_t numValuesMedium{0};
+  size_t numValuesMixed{0};
+
+  static BenchmarkState& instance() {
+    static BenchmarkState state;
+    return state;
+  }
+};
+
+// Helper to write a varint to buffer
+size_t writeVulong(uint64_t val, char* buffer, size_t pos) {
+  while (true) {
+    if ((val & ~0x7f) == 0) {
+      buffer[pos++] = static_cast<char>(val);
+      return pos;
+    }
+    buffer[pos++] = static_cast<char>(0x80 | (val & BASE_128_MASK));
+    val = (static_cast<uint64_t>(val) >> 7);
+  }
+}
+
+// OLD implementation: uses UNLIKELY for first byte, no early return
+// This is the original code before the optimization.
+uint64_t readVuLongOld(const char*& bufferStart, const char* bufferEnd) {
+  if (LIKELY(bufferEnd - bufferStart >= folly::kMaxVarintLength64)) {
+    const char* p = bufferStart;
+    uint64_t val;
+    do {
+      int64_t b;
+      b = *p++;
+      val = (b & 0x7f);
+      if (UNLIKELY(b >= 0)) { // OLD: UNLIKELY here
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x7f) << 7;
+      if (UNLIKELY(b >= 0)) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x7f) << 14;
+      if (UNLIKELY(b >= 0)) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x7f) << 21;
+      if (UNLIKELY(b >= 0)) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x7f) << 28;
+      if (UNLIKELY(b >= 0)) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x7f) << 35;
+      if (UNLIKELY(b >= 0)) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x7f) << 42;
+      if (UNLIKELY(b >= 0)) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x7f) << 49;
+      if (UNLIKELY(b >= 0)) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x7f) << 56;
+      if (UNLIKELY(b >= 0)) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x01) << 63;
+    } while (false);
+
+    bufferStart = p;
+    return val;
+  }
+
+  // Slow path
+  uint64_t result = 0;
+  uint64_t offset = 0;
+  signed char ch;
+  do {
+    ch = *(bufferStart++);
+    result |= (ch & BASE_128_MASK) << offset;
+    offset += 7;
+  } while (ch < 0);
+  return result;
+}
+
+// NEW implementation: uses LIKELY for first byte with early return
+// This matches the optimized code in IntDecoder.h
+uint64_t readVuLongNew(const char*& bufferStart, const char* bufferEnd) {
+  if (LIKELY(bufferEnd - bufferStart >= folly::kMaxVarintLength64)) {
+    const char* p = bufferStart;
+    uint64_t val;
+
+    // Fast path for 1-byte varints (values 0-127), which are very common.
+    // This avoids the do-while loop overhead for the most frequent case.
+    int64_t b = *p++;
+    val = (b & 0x7f);
+    if (b >= 0) { // better without likely or unlikely here.
+      bufferStart = p;
+      return val;
+    }
+
+    // Multi-byte varint path
+    do {
+      b = *p++;
+      val |= (b & 0x7f) << 7;
+      if (UNLIKELY(b >= 0)) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x7f) << 14;
+      if (UNLIKELY(b >= 0)) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x7f) << 21;
+      if (UNLIKELY(b >= 0)) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x7f) << 28;
+      if (UNLIKELY(b >= 0)) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x7f) << 35;
+      if (UNLIKELY(b >= 0)) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x7f) << 42;
+      if (UNLIKELY(b >= 0)) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x7f) << 49;
+      if (UNLIKELY(b >= 0)) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x7f) << 56;
+      if (UNLIKELY(b >= 0)) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x01) << 63;
+    } while (false);
+
+    bufferStart = p;
+    return val;
+  }
+
+  // Slow path
+  uint64_t result = 0;
+  uint64_t offset = 0;
+  signed char ch;
+  do {
+    ch = *(bufferStart++);
+    result |= (ch & BASE_128_MASK) << offset;
+    offset += 7;
+  } while (ch < 0);
+  return result;
+}
+
+// Benchmarks for small values (0-127, all 1-byte varints)
+// This is where the optimization should show the biggest improvement.
+BENCHMARK(small_values_old) {
+  auto& state = BenchmarkState::instance();
+  const char* p = state.bufferSmall.data();
+  const char* end = p + state.lenSmall;
+  for (size_t i = 0; i < state.numValuesSmall; ++i) {
+    auto result = readVuLongOld(p, end);
+    folly::doNotOptimizeAway(result);
+  }
+}
+
+BENCHMARK_RELATIVE(small_values_new) {
+  auto& state = BenchmarkState::instance();
+  const char* p = state.bufferSmall.data();
+  const char* end = p + state.lenSmall;
+  for (size_t i = 0; i < state.numValuesSmall; ++i) {
+    auto result = readVuLongNew(p, end);
+    folly::doNotOptimizeAway(result);
+  }
+}
+
+BENCHMARK_DRAW_LINE();
+
+// Benchmarks for medium values (0-16383, mix of 1-2 byte varints)
+BENCHMARK(medium_values_old) {
+  auto& state = BenchmarkState::instance();
+  const char* p = state.bufferMedium.data();
+  const char* end = p + state.lenMedium;
+  for (size_t i = 0; i < state.numValuesMedium; ++i) {
+    auto result = readVuLongOld(p, end);
+    folly::doNotOptimizeAway(result);
+  }
+}
+
+BENCHMARK_RELATIVE(medium_values_new) {
+  auto& state = BenchmarkState::instance();
+  const char* p = state.bufferMedium.data();
+  const char* end = p + state.lenMedium;
+  for (size_t i = 0; i < state.numValuesMedium; ++i) {
+    auto result = readVuLongNew(p, end);
+    folly::doNotOptimizeAway(result);
+  }
+}
+
+BENCHMARK_DRAW_LINE();
+
+// Benchmarks for mixed/random uint32 values (1-5 byte varints)
+BENCHMARK(mixed_values_old) {
+  auto& state = BenchmarkState::instance();
+  const char* p = state.bufferMixed.data();
+  const char* end = p + state.lenMixed;
+  for (size_t i = 0; i < state.numValuesMixed; ++i) {
+    auto result = readVuLongOld(p, end);
+    folly::doNotOptimizeAway(result);
+  }
+}
+
+BENCHMARK_RELATIVE(mixed_values_new) {
+  auto& state = BenchmarkState::instance();
+  const char* p = state.bufferMixed.data();
+  const char* end = p + state.lenMixed;
+  for (size_t i = 0; i < state.numValuesMixed; ++i) {
+    auto result = readVuLongNew(p, end);
+    folly::doNotOptimizeAway(result);
+  }
+}
+
+int32_t main(int32_t argc, char* argv[]) {
+  folly::Init init{&argc, &argv};
+
+  auto& state = BenchmarkState::instance();
+
+  // Populate small values buffer (0-127, all 1-byte varints)
+  state.bufferSmall.resize(kNumElements);
+  size_t pos = 0;
+  state.numValuesSmall = 500000;
+  for (size_t i = 0; i < state.numValuesSmall; i++) {
+    uint64_t val = folly::Random::rand32() % 128; // 0-127
+    pos = writeVulong(val, state.bufferSmall.data(), pos);
+  }
+  state.lenSmall = pos;
+
+  // Populate medium values buffer (0-16383, mix of 1-2 byte varints)
+  state.bufferMedium.resize(kNumElements);
+  pos = 0;
+  state.numValuesMedium = 400000;
+  for (size_t i = 0; i < state.numValuesMedium; i++) {
+    uint64_t val = folly::Random::rand32() % 16384; // 0-16383
+    pos = writeVulong(val, state.bufferMedium.data(), pos);
+  }
+  state.lenMedium = pos;
+
+  // Populate mixed values buffer (random uint32, 1-5 byte varints)
+  state.bufferMixed.resize(kNumElements);
+  pos = 0;
+  state.numValuesMixed = 200000;
+  for (size_t i = 0; i < state.numValuesMixed; i++) {
+    uint64_t val = folly::Random::rand32();
+    pos = writeVulong(val, state.bufferMixed.data(), pos);
+  }
+  state.lenMixed = pos;
+
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/dwio/common/tests/ReaderTest.cpp b/velox/dwio/common/tests/ReaderTest.cpp
index 4b277ff484a..400bd80df93 100644
--- a/velox/dwio/common/tests/ReaderTest.cpp
+++ b/velox/dwio/common/tests/ReaderTest.cpp
@@ -18,6 +18,7 @@
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
+#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 namespace facebook::velox::dwio::common {
@@ -148,34 +149,395 @@ TEST_F(ReaderTest, projectColumnsMutation) {
       makeFlatVector<int64_t>({0, 1, 3, 4, 5, 6, 7, 8, 9}),
   });
   test::assertEqualVectors(expected, actual);
-  random::setSeed(42);
-  random::RandomSkipTracker randomSkip(0.5);
-  mutation.randomSkip = &randomSkip;
-  actual = RowReader::projectColumns(input, spec, &mutation);
-  if constexpr (std::is_same_v<folly::detail::DefaultGenerator, std::mt19937>) {
-#if __APPLE__
-    expected = makeRowVector({
-        makeFlatVector<int64_t>({1, 5, 6, 7, 8, 9}),
-    });
-#else
-    expected = makeRowVector({
-        makeFlatVector<int64_t>({3, 4, 7, 9}),
-    });
-#endif
-#if FOLLY_HAVE_EXTRANDOM_SFMT19937
-  } else if constexpr (std::is_same_v<
-                           folly::detail::DefaultGenerator,
-                           __gnu_cxx::sfmt19937>) {
-    expected = makeRowVector({
-        makeFlatVector<int64_t>({0, 1, 3, 5, 6, 8}),
-    });
-#endif
-  } else {
-    expected = makeRowVector({
-        makeFlatVector<int64_t>({1, 3, 5, 7}),
-    });
+
+  constexpr auto kNumRounds = 1U << 6;
+
+  size_t numNonZero = 0;
+  size_t numNonMax = 0;
+
+  // Test with random skip - use property-based testing instead of hardcoded
+  // outputs to avoid brittleness when folly::Random implementation changes.
+  std::mt19937 seeds;
+  for (size_t round = 0; round < kNumRounds; ++round) {
+    const auto seed = seeds();
+
+    random::setSeed(folly::to_narrow(seed));
+    random::RandomSkipTracker randomSkip(0.5);
+    mutation.randomSkip = &randomSkip;
+    actual = RowReader::projectColumns(input, spec, &mutation);
+
+    // Property 1: Result size should be less than input size (some rows
+    // skipped). With 0.5 sample rate and 9 eligible rows (excluding deleted row
+    // 2), we expect roughly 4-5 rows, but allow wider range for RNG variance.
+    EXPECT_GE(actual->size(), 0);
+    EXPECT_LE(actual->size(), kSize - 1);
+
+    numNonZero += actual->size() > 0;
+    numNonMax += actual->size() < kSize - 1;
+
+    // The result is a RowVector with one child column. Assume it.
+    auto res = actual->as<RowVector>()->childAt(0)->as<SimpleVector<int64_t>>();
+    std::vector<int64_t> vec;
+    vec.reserve(actual->size());
+    for (vector_size_t i = 0; i < actual->size(); ++i) {
+      vec.push_back(res->valueAt(i));
+    }
+
+    // Property 2: All values in result must be from original input.
+    for (auto val : vec) {
+      // Each value must be in valid range
+      EXPECT_GE(val, 0);
+      EXPECT_LT(val, kSize);
+      // Deleted row should never appear
+      EXPECT_NE(val, 2);
+    }
+
+    // Property 3: Values should be in ascending order (projectColumns preserves
+    // order).
+    EXPECT_TRUE(std::is_sorted(vec.begin(), vec.end()));
+
+    // Property 4: No duplicate values (each input row appears at most once).
+    EXPECT_TRUE(std::adjacent_find(vec.begin(), vec.end()) == vec.end());
+
+    // Property 5: With a fixed seed, the result should be deterministic
+    // (same seed = same output, even if we don't know what that output is)
+    random::setSeed(folly::to_narrow(seed));
+    random::RandomSkipTracker randomSkip2(0.5);
+    mutation.randomSkip = &randomSkip2;
+    auto actual2 = RowReader::projectColumns(input, spec, &mutation);
+    test::assertEqualVectors(actual, actual2);
   }
-  test::assertEqualVectors(expected, actual);
+
+  EXPECT_NE(0, numNonZero);
+  EXPECT_NE(0, numNonMax);
+}
+
+TEST_F(ReaderTest, rowRangeEmpty) {
+  // Empty when startRow >= endRow
+  EXPECT_TRUE((RowRange{0, 0}.empty()));
+  EXPECT_TRUE((RowRange{5, 5}.empty()));
+  EXPECT_TRUE((RowRange{10, 5}.empty()));
+
+  // Not empty when startRow < endRow
+  EXPECT_FALSE((RowRange{0, 1}.empty()));
+  EXPECT_FALSE((RowRange{0, 10}.empty()));
+  EXPECT_FALSE((RowRange{5, 10}.empty()));
+}
+
+// Test that projectColumns preserves top level nulls when the input RowVector
+// has null rows.
+TEST_F(ReaderTest, projectColumnsTopLevelNulls) {
+  constexpr int kSize = 10;
+  // All nulls
+  {
+    SCOPED_TRACE("All nulls");
+    auto child = makeFlatVector<int64_t>(kSize, folly::identity);
+    auto input = makeRowVector({child});
+
+    auto nulls = AlignedBuffer::allocate<bool>(kSize, pool());
+    auto* rawNulls = nulls->asMutable<uint64_t>();
+    // Set all bits to 0 (all null)
+    memset(rawNulls, 0, bits::nbytes(kSize));
+    input->setNulls(nulls);
+
+    ASSERT_EQ(BaseVector::countNulls(input->nulls(), kSize), kSize);
+
+    common::ScanSpec spec("<root>");
+    spec.addAllChildFields(*input->type());
+
+    auto actual = RowReader::projectColumns(input, spec, nullptr);
+
+    ASSERT_NE(actual->nulls(), nullptr);
+    EXPECT_EQ(BaseVector::countNulls(actual->nulls(), actual->size()), kSize);
+
+    // Verify the output has the same size
+    EXPECT_EQ(actual->size(), kSize);
+  }
+
+  // Partial nulls.
+  {
+    SCOPED_TRACE("Partial nulls");
+    auto child = makeFlatVector<int64_t>(kSize, folly::identity);
+    auto input = makeRowVector({child});
+
+    auto nulls = AlignedBuffer::allocate<bool>(kSize, pool());
+    auto* rawNulls = nulls->asMutable<uint64_t>();
+
+    // Set rows 0, 2, 4, 6, 8 as null (even indices)
+    memset(rawNulls, 0xFF, bits::nbytes(kSize));
+    for (int i = 0; i < kSize; i += 2) {
+      bits::setNull(rawNulls, i);
+    }
+    input->setNulls(nulls);
+
+    ASSERT_EQ(BaseVector::countNulls(input->nulls(), kSize), 5); // 5 null rows
+
+    common::ScanSpec spec("<root>");
+    spec.addAllChildFields(*input->type());
+
+    // Test without mutation (no filtering)
+    auto actual = RowReader::projectColumns(input, spec, nullptr);
+
+    // Verify nulls are preserved
+    ASSERT_NE(actual->nulls(), nullptr);
+    EXPECT_EQ(BaseVector::countNulls(actual->nulls(), actual->size()), 5);
+    EXPECT_EQ(actual->size(), kSize);
+
+    // Verify specific null positions
+    for (int i = 0; i < kSize; ++i) {
+      EXPECT_EQ(actual->isNullAt(i), (i % 2 == 0))
+          << "Row " << i << " null status mismatch";
+    }
+  }
+
+  // Partial nulls with constant encoding child
+  {
+    SCOPED_TRACE("Constant encoding child");
+    // Create a constant vector (all values are the same)
+    auto constantChild =
+        BaseVector::createConstant(INTEGER(), 42, kSize, pool());
+    auto input = makeRowVector({constantChild});
+
+    auto nulls = AlignedBuffer::allocate<bool>(kSize, pool());
+    auto* rawNulls = nulls->asMutable<uint64_t>();
+
+    // Set rows 0, 2, 4, 6, 8 as null (even indices)
+    memset(rawNulls, 0xFF, bits::nbytes(kSize));
+    for (int i = 0; i < kSize; i += 2) {
+      bits::setNull(rawNulls, i);
+    }
+    input->setNulls(nulls);
+
+    ASSERT_EQ(BaseVector::countNulls(input->nulls(), kSize), 5); // 5 null rows
+    ASSERT_TRUE(constantChild->isConstantEncoding());
+
+    common::ScanSpec spec("<root>");
+    spec.addAllChildFields(*input->type());
+
+    auto actual = RowReader::projectColumns(input, spec, nullptr);
+
+    // Verify nulls are preserved
+    ASSERT_NE(actual->nulls(), nullptr);
+    EXPECT_EQ(BaseVector::countNulls(actual->nulls(), actual->size()), 5);
+    EXPECT_EQ(actual->size(), kSize);
+
+    // Verify specific null positions
+    for (int i = 0; i < kSize; ++i) {
+      EXPECT_EQ(actual->isNullAt(i), (i % 2 == 0))
+          << "Row " << i << " null status mismatch";
+    }
+  }
+
+  // Partial nulls with dictionary encoding child
+  {
+    SCOPED_TRACE("Dictionary encoding child");
+    // Create a dictionary vector wrapping a flat vector
+    auto baseValues = makeFlatVector<int64_t>({10, 20, 30, 40, 50});
+    // Create indices that map to the base values
+    auto indices = makeIndices(kSize, [](auto i) { return i % 5; });
+    auto dictionaryChild =
+        BaseVector::wrapInDictionary(nullptr, indices, kSize, baseValues);
+    auto input = makeRowVector({dictionaryChild});
+
+    auto nulls = AlignedBuffer::allocate<bool>(kSize, pool());
+    auto* rawNulls = nulls->asMutable<uint64_t>();
+
+    // Set rows 0, 2, 4, 6, 8 as null (even indices)
+    memset(rawNulls, 0xFF, bits::nbytes(kSize));
+    for (int i = 0; i < kSize; i += 2) {
+      bits::setNull(rawNulls, i);
+    }
+    input->setNulls(nulls);
+
+    ASSERT_EQ(BaseVector::countNulls(input->nulls(), kSize), 5); // 5 null rows
+    ASSERT_EQ(dictionaryChild->encoding(), VectorEncoding::Simple::DICTIONARY);
+
+    common::ScanSpec spec("<root>");
+    spec.addAllChildFields(*input->type());
+
+    auto actual = RowReader::projectColumns(input, spec, nullptr);
+
+    // Verify nulls are preserved
+    ASSERT_NE(actual->nulls(), nullptr);
+    EXPECT_EQ(BaseVector::countNulls(actual->nulls(), actual->size()), 5);
+    EXPECT_EQ(actual->size(), kSize);
+
+    // Verify specific null positions
+    for (int i = 0; i < kSize; ++i) {
+      EXPECT_EQ(actual->isNullAt(i), (i % 2 == 0))
+          << "Row " << i << " null status mismatch";
+    }
+  }
+
+  // Two columns: constant encoding and dictionary encoding
+  {
+    SCOPED_TRACE("Two columns: constant and dictionary encoding");
+    // Create a constant vector
+    auto constantChild =
+        BaseVector::createConstant(INTEGER(), 42, kSize, pool());
+
+    // Create a dictionary vector
+    auto baseValues = makeFlatVector<int64_t>({100, 200, 300, 400, 500});
+    auto indices = makeIndices(kSize, [](auto i) { return i % 5; });
+    auto dictionaryChild =
+        BaseVector::wrapInDictionary(nullptr, indices, kSize, baseValues);
+
+    auto input = makeRowVector({constantChild, dictionaryChild});
+
+    auto nulls = AlignedBuffer::allocate<bool>(kSize, pool());
+    auto* rawNulls = nulls->asMutable<uint64_t>();
+
+    // Set rows 0, 2, 4, 6, 8 as null (even indices)
+    memset(rawNulls, 0xFF, bits::nbytes(kSize));
+    for (int i = 0; i < kSize; i += 2) {
+      bits::setNull(rawNulls, i);
+    }
+    input->setNulls(nulls);
+
+    ASSERT_EQ(BaseVector::countNulls(input->nulls(), kSize), 5);
+    ASSERT_TRUE(constantChild->isConstantEncoding());
+    ASSERT_EQ(dictionaryChild->encoding(), VectorEncoding::Simple::DICTIONARY);
+
+    common::ScanSpec spec("<root>");
+    spec.addAllChildFields(*input->type());
+
+    auto actual = RowReader::projectColumns(input, spec, nullptr);
+
+    // Verify nulls are preserved
+    ASSERT_NE(actual->nulls(), nullptr);
+    EXPECT_EQ(BaseVector::countNulls(actual->nulls(), actual->size()), 5);
+    EXPECT_EQ(actual->size(), kSize);
+
+    // Verify both children exist
+    auto rowResult = actual->as<RowVector>();
+    ASSERT_EQ(rowResult->childrenSize(), 2);
+
+    // Verify specific null positions
+    for (int i = 0; i < kSize; ++i) {
+      EXPECT_EQ(actual->isNullAt(i), (i % 2 == 0))
+          << "Row " << i << " null status mismatch";
+    }
+  }
+}
+
+// Test that projectColumns correctly filters row-level nulls with mutation
+TEST_F(ReaderTest, projectColumnsFiltersRowNullsWithMutation) {
+  constexpr int kSize = 10;
+
+  // Create a RowVector with some null rows
+  auto child = makeFlatVector<int64_t>(kSize, folly::identity);
+  auto input = makeRowVector({child});
+
+  // Set rows 0, 2, 4, 6, 8 as null (even indices)
+  auto nulls = AlignedBuffer::allocate<bool>(kSize, pool());
+  auto* rawNulls = nulls->asMutable<uint64_t>();
+  memset(rawNulls, 0xFF, bits::nbytes(kSize));
+  for (int i = 0; i < kSize; i += 2) {
+    bits::setNull(rawNulls, i);
+  }
+  input->setNulls(nulls);
+
+  common::ScanSpec spec("<root>");
+  spec.addAllChildFields(*input->type());
+
+  // Delete rows 1 and 3 (odd indices, which are not null)
+  std::vector<uint64_t> deleted(bits::nwords(kSize));
+  bits::setBit(deleted.data(), 1);
+  bits::setBit(deleted.data(), 3);
+  Mutation mutation;
+  mutation.deletedRows = deleted.data();
+
+  auto actual = RowReader::projectColumns(input, spec, &mutation);
+
+  // 8 rows should remain (10 - 2 deleted)
+  EXPECT_EQ(actual->size(), 8);
+
+  // Verify nulls buffer exists
+  ASSERT_NE(actual->nulls(), nullptr);
+
+  // After filtering, the remaining rows are: 0, 2, 4, 5, 6, 7, 8, 9
+  // Of these, 0, 2, 4, 6, 8 were null in the original (indices 0, 1, 2, 4, 6)
+  // So in the output: positions 0, 1, 2, 4, 6 should be null
+  EXPECT_TRUE(actual->isNullAt(0)); // was row 0
+  EXPECT_TRUE(actual->isNullAt(1)); // was row 2
+  EXPECT_TRUE(actual->isNullAt(2)); // was row 4
+  EXPECT_FALSE(actual->isNullAt(3)); // was row 5
+  EXPECT_TRUE(actual->isNullAt(4)); // was row 6
+  EXPECT_FALSE(actual->isNullAt(5)); // was row 7
+  EXPECT_TRUE(actual->isNullAt(6)); // was row 8
+  EXPECT_FALSE(actual->isNullAt(7)); // was row 9
+}
+
+TEST_F(ReaderTest, projectColumnsWithSelectionIdentity) {
+  // No filter: every input row passes, selectedRows is null to signal
+  // identity mapping with input.
+  constexpr int kSize = 5;
+  auto input =
+      makeRowVector({"c0"}, {makeFlatVector<int64_t>(kSize, folly::identity)});
+
+  common::ScanSpec spec("<root>");
+  spec.addAllChildFields(*input->type());
+
+  auto result = RowReader::projectColumnsWithSelection(input, spec, nullptr);
+  EXPECT_EQ(result.output->size(), kSize);
+  EXPECT_EQ(result.selectedRows, nullptr);
+}
+
+TEST_F(ReaderTest, projectColumnsWithSelectionFiltered) {
+  // Filter keeps a subset; selectedRows must list the surviving input
+  // indices in order.
+  constexpr int kSize = 6;
+  auto input =
+      makeRowVector({"c0"}, {makeFlatVector<int64_t>(kSize, folly::identity)});
+
+  common::ScanSpec spec("<root>");
+  spec.addAllChildFields(*input->type());
+  spec.childByName("c0")->setFilter(
+      common::createBigintValues({1, 3, 5}, false));
+
+  auto result = RowReader::projectColumnsWithSelection(input, spec, nullptr);
+  ASSERT_NE(result.selectedRows, nullptr);
+  ASSERT_EQ(result.output->size(), 3);
+  ASSERT_EQ(
+      result.selectedRows->size() / sizeof(vector_size_t),
+      result.output->size());
+  const auto* indices = result.selectedRows->as<vector_size_t>();
+  EXPECT_THAT(
+      std::vector<vector_size_t>(indices, indices + 3),
+      testing::ElementsAre(1, 3, 5));
+}
+
+TEST_F(ReaderTest, projectColumnsWithSelectionAllFiltered) {
+  // Filter rejects every row; output is empty and selectedRows is a
+  // zero-length buffer (non-null) so callers can distinguish "empty after
+  // filtering" from "identity mapping".
+  constexpr int kSize = 4;
+  auto input =
+      makeRowVector({"c0"}, {makeFlatVector<int64_t>(kSize, folly::identity)});
+
+  common::ScanSpec spec("<root>");
+  spec.addAllChildFields(*input->type());
+  spec.childByName("c0")->setFilter(common::createBigintValues({99}, false));
+
+  auto result = RowReader::projectColumnsWithSelection(input, spec, nullptr);
+  EXPECT_EQ(result.output->size(), 0);
+  ASSERT_NE(result.selectedRows, nullptr);
+  EXPECT_EQ(result.selectedRows->size(), 0);
+}
+
+TEST_F(ReaderTest, projectColumnsWithSelectionEmptyInput) {
+  // Empty input: no rows were dropped, so the identity contract holds and
+  // selectedRows must be null. Distinguishes "empty identity" from "all
+  // rows filtered out", which returns a non-null zero-length buffer.
+  auto input =
+      makeRowVector({"c0"}, {makeFlatVector<int64_t>(0, folly::identity)});
+
+  common::ScanSpec spec("<root>");
+  spec.addAllChildFields(*input->type());
+
+  auto result = RowReader::projectColumnsWithSelection(input, spec, nullptr);
+  EXPECT_EQ(result.output->size(), 0);
+  EXPECT_EQ(result.selectedRows, nullptr);
 }
 
 } // namespace
diff --git a/velox/dwio/common/tests/ScanSpecTest.cpp b/velox/dwio/common/tests/ScanSpecTest.cpp
index d61675878d2..96eb4f10dcb 100644
--- a/velox/dwio/common/tests/ScanSpecTest.cpp
+++ b/velox/dwio/common/tests/ScanSpecTest.cpp
@@ -54,6 +54,57 @@ TEST_F(ScanSpecTest, applyFilter) {
       VeloxRuntimeError);
 }
 
+TEST_F(ScanSpecTest, setFilterResetsHasFilter) {
+  auto rowVector = makeRowVector({
+      makeFlatVector<int64_t>(64, folly::identity),
+      makeFlatVector<int64_t>(64, folly::identity),
+  });
+
+  ScanSpec scanSpec("<root>");
+  scanSpec.addAllChildFields(*rowVector->type());
+
+  // Initially no filter, hasFilter should be false.
+  ASSERT_FALSE(scanSpec.hasFilter());
+  ASSERT_FALSE(scanSpec.childByName("c0")->hasFilter());
+  ASSERT_FALSE(scanSpec.childByName("c1")->hasFilter());
+
+  // Set a filter on c0, hasFilter should be true for c0 and root.
+  scanSpec.childByName("c0")->setFilter(createBigintValues({1, 2, 3}, false));
+  ASSERT_FALSE(scanSpec.childByName("c0")->hasFilter());
+  ASSERT_FALSE(scanSpec.hasFilter());
+  // Root's hasFilter_ was cached as false, but setFilter should have reset it.
+  // After setting filter on child, root should report hasFilter as true.
+  scanSpec.resetCachedValues(false);
+  ASSERT_TRUE(scanSpec.hasFilter());
+  ASSERT_TRUE(scanSpec.childByName("c0")->hasFilter());
+
+  // Set filter to nullptr, hasFilter should become false.
+  scanSpec.childByName("c0")->setFilter(nullptr);
+  ASSERT_TRUE(scanSpec.childByName("c0")->hasFilter());
+  ASSERT_TRUE(scanSpec.hasFilter());
+  scanSpec.resetCachedValues(false);
+  ASSERT_FALSE(scanSpec.childByName("c0")->hasFilter());
+  ASSERT_FALSE(scanSpec.hasFilter());
+
+  // Set a new filter on c1, verify hasFilter updates correctly.
+  scanSpec.childByName("c1")->setFilter(
+      std::make_shared<BigintRange>(10, 50, false));
+  ASSERT_FALSE(scanSpec.childByName("c1")->hasFilter());
+  ASSERT_FALSE(scanSpec.childByName("c0")->hasFilter());
+  scanSpec.resetCachedValues(false);
+  ASSERT_FALSE(scanSpec.childByName("c0")->hasFilter());
+  ASSERT_TRUE(scanSpec.childByName("c1")->hasFilter());
+  ASSERT_TRUE(scanSpec.hasFilter());
+
+  // Replace filter on c1 with a different filter.
+  scanSpec.childByName("c1")->setFilter(
+      std::make_shared<BigintRange>(20, 30, false));
+  // hasFilter should still be true after replacing with another filter.
+  ASSERT_TRUE(scanSpec.childByName("c1")->hasFilter());
+  ASSERT_FALSE(scanSpec.childByName("c0")->hasFilter());
+  ASSERT_TRUE(scanSpec.hasFilter());
+}
+
 class TypedScanSpecTest : public testing::TestWithParam<TypePtr>,
                           public test::VectorTestBase {
  protected:
diff --git a/velox/dwio/common/tests/SelectiveColumnReaderTest.cpp b/velox/dwio/common/tests/SelectiveColumnReaderTest.cpp
new file mode 100644
index 00000000000..d4a237d799c
--- /dev/null
+++ b/velox/dwio/common/tests/SelectiveColumnReaderTest.cpp
@@ -0,0 +1,592 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/common/SelectiveColumnReader.h"
+#include "velox/dwio/common/SelectiveColumnReaderInternal.h"
+
+#include <gtest/gtest.h>
+#include <cmath>
+#include <limits>
+#include <numeric>
+
+#include "velox/common/memory/MemoryPool.h"
+#include "velox/dwio/common/FormatData.h"
+#include "velox/dwio/common/TypeWithId.h"
+
+namespace facebook::velox::dwio::common {
+namespace {
+
+TEST(IsDenseTest, empty) {
+  const RowSet rows(nullptr, nullptr);
+  EXPECT_TRUE(isDense(rows));
+}
+
+TEST(IsDenseTest, singleElement) {
+  const std::vector<int32_t> data{0};
+  const RowSet rows(data.data(), data.size());
+  EXPECT_TRUE(isDense(rows));
+}
+
+TEST(IsDenseTest, contiguousFromZero) {
+  const std::vector<int32_t> data{0, 1, 2, 3, 4};
+  const RowSet rows(data.data(), data.size());
+  EXPECT_TRUE(isDense(rows));
+}
+
+TEST(IsDenseTest, sparseRows) {
+  const std::vector<int32_t> data{0, 2, 4};
+  const RowSet rows(data.data(), data.size());
+  EXPECT_FALSE(isDense(rows));
+}
+
+TEST(IsDenseTest, startingFromNonZero) {
+  const std::vector<int32_t> data{1, 2, 3};
+  const RowSet rows(data.data(), data.size());
+  EXPECT_FALSE(isDense(rows));
+}
+
+TEST(IsDenseTest, singleNonZeroElement) {
+  const std::vector<int32_t> data{5};
+  const RowSet rows(data.data(), data.size());
+  EXPECT_FALSE(isDense(rows));
+}
+
+// Minimal FormatData stub for testing SelectiveColumnReader in isolation.
+class StubFormatData : public FormatData {
+ public:
+  void readNulls(
+      vector_size_t /*numValues*/,
+      const uint64_t* /*incomingNulls*/,
+      BufferPtr& nulls,
+      bool /*nullsOnly*/) override {
+    nulls = nullptr;
+  }
+  uint64_t skipNulls(uint64_t numValues, bool /*nullsOnly*/) override {
+    return numValues;
+  }
+  uint64_t skip(uint64_t numValues) override {
+    return numValues;
+  }
+  bool hasNulls() const override {
+    return false;
+  }
+  dwio::common::PositionProvider seekToRowGroup(int64_t /*index*/) override {
+    static std::vector<uint64_t> empty;
+    return dwio::common::PositionProvider(empty);
+  }
+  void filterRowGroups(
+      const velox::common::ScanSpec& /*scanSpec*/,
+      uint64_t /*rowsPerRowGroup*/,
+      const StatsContext& /*writerContext*/,
+      FilterRowGroupsResult& /*result*/) override {}
+};
+
+// Minimal FormatParams stub that produces a StubFormatData.
+class StubFormatParams : public FormatParams {
+ public:
+  StubFormatParams(memory::MemoryPool& pool, ColumnReaderStatistics& stats)
+      : FormatParams(pool, stats) {}
+
+  std::unique_ptr<FormatData> toFormatData(
+      const std::shared_ptr<const dwio::common::TypeWithId>& /*type*/,
+      const velox::common::ScanSpec& /*scanSpec*/) override {
+    return std::make_unique<StubFormatData>();
+  }
+};
+
+// Concrete subclass that exposes getFlatValues and internal state for testing.
+class TestColumnReader : public SelectiveColumnReader {
+ public:
+  TestColumnReader(
+      const TypePtr& requestedType,
+      std::shared_ptr<const dwio::common::TypeWithId> fileType,
+      FormatParams& params,
+      velox::common::ScanSpec& scanSpec)
+      : SelectiveColumnReader(
+            requestedType,
+            std::move(fileType),
+            params,
+            scanSpec) {}
+
+  void read(
+      int64_t /*offset*/,
+      const RowSet& /*rows*/,
+      const uint64_t* /*incomingNulls*/) override {}
+
+  void getValues(const RowSet& /*rows*/, VectorPtr* /*result*/) override {}
+
+  /// Populate the internal values buffer with source data of type T.
+  /// Sets valueSize_, numValues_, mayGetValues_, and inputRows_.
+  /// @note rowNumbers must remain live until getFlatValues is called, as
+  /// inputRows_ stores a non-owning reference.
+  template <typename T>
+  void setupValues(
+      const std::vector<T>& data,
+      const std::vector<int32_t>& rowNumbers) {
+    VELOX_CHECK_EQ(data.size(), rowNumbers.size());
+    const auto n = static_cast<vector_size_t>(data.size());
+    ensureValuesCapacity<T>(n);
+    std::memcpy(rawValues_, data.data(), n * sizeof(T));
+    numValues_ = n;
+    valueSize_ = sizeof(T);
+    mayGetValues_ = true;
+    allNull_ = false;
+    inputRows_ = RowSet(rowNumbers.data(), rowNumbers.size());
+  }
+
+  /// Populate internal values and mark elements null according to the mask.
+  template <typename T>
+  void setupValuesWithNulls(
+      const std::vector<T>& data,
+      const std::vector<bool>& nulls,
+      const std::vector<int32_t>& rowNumbers) {
+    VELOX_CHECK_EQ(data.size(), nulls.size());
+    setupValues(data, rowNumbers);
+    const auto n = static_cast<vector_size_t>(data.size());
+    anyNulls_ = true;
+    resultNulls_ = AlignedBuffer::allocate<bool>(
+        n + simd::kPadding * 8, pool_, bits::kNotNull);
+    rawResultNulls_ = resultNulls_->asMutable<uint64_t>();
+    for (int32_t i = 0; i < n; ++i) {
+      bits::setBit(rawResultNulls_, i, !nulls[i]);
+    }
+  }
+
+  using SelectiveColumnReader::getFlatValues;
+};
+
+class GetFlatValuesTest : public ::testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    pool_ = memory::memoryManager()->addLeafPool("GetFlatValuesTest");
+    stats_ = std::make_unique<ColumnReaderStatistics>();
+    params_ = std::make_unique<StubFormatParams>(*pool_, *stats_);
+    scanSpec_ = std::make_unique<velox::common::ScanSpec>("test");
+    scanSpec_->setProjectOut(true);
+  }
+
+  std::unique_ptr<TestColumnReader> makeReader(
+      const TypePtr& requestedType) const {
+    auto fileType = TypeWithId::create(requestedType);
+    return std::make_unique<TestColumnReader>(
+        requestedType, std::move(fileType), *params_, *scanSpec_);
+  }
+
+  /// Run getFlatValues and verify each element equals static_cast<Target>(src).
+  /// When sparseRows is provided, only those rows are selected from data.
+  template <typename Source, typename Target>
+  void testConversion(
+      const TypePtr& type,
+      const std::vector<Source>& data,
+      const std::vector<int32_t>& sparseRows = {}) {
+    auto reader = makeReader(type);
+    std::vector<int32_t> allRows(data.size());
+    std::iota(allRows.begin(), allRows.end(), 0);
+    reader->setupValues(data, allRows);
+
+    const auto& selectedRows = sparseRows.empty() ? allRows : sparseRows;
+    const RowSet rows(selectedRows.data(), selectedRows.size());
+    VectorPtr result;
+    reader->getFlatValues<Source, Target>(rows, &result, type, true);
+
+    auto* flat = result->as<FlatVector<Target>>();
+    ASSERT_NE(flat, nullptr);
+    ASSERT_EQ(flat->size(), selectedRows.size());
+    for (size_t i = 0; i < selectedRows.size(); ++i) {
+      EXPECT_EQ(flat->valueAt(i), static_cast<Target>(data[selectedRows[i]]))
+          << "Mismatch at index " << i;
+    }
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_;
+  std::unique_ptr<ColumnReaderStatistics> stats_;
+  std::unique_ptr<StubFormatParams> params_;
+  std::unique_ptr<velox::common::ScanSpec> scanSpec_;
+};
+
+// Cross-domain upcast conversions (different sizes, valid via
+// upcastScalarValues).
+
+TEST_F(GetFlatValuesTest, int16ToFloat) {
+  testConversion<int16_t, float>(REAL(), {1, -32'000, 0, 127, 32'767});
+  testConversion<int16_t, float>(REAL(), {1, -32'000, 0, 127, 32'767}, {0, 3});
+}
+
+TEST_F(GetFlatValuesTest, int32ToDouble) {
+  testConversion<int32_t, double>(
+      DOUBLE(), {1, -999'999, 2'147'483'647, 0, -2'147'483'647});
+  testConversion<int32_t, double>(
+      DOUBLE(), {1, -999'999, 2'147'483'647, 0, -2'147'483'647}, {1, 2, 4});
+}
+
+TEST_F(GetFlatValuesTest, int16ToDouble) {
+  testConversion<int16_t, double>(DOUBLE(), {0, 1, -1, 32'767, -32'768});
+  testConversion<int16_t, double>(
+      DOUBLE(), {0, 1, -1, 32'767, -32'768}, {0, 4});
+}
+
+// Same-domain conversions as regression guards.
+
+TEST_F(GetFlatValuesTest, int32ToInt32) {
+  testConversion<int32_t, int32_t>(INTEGER(), {0, 1, -1, 42, 2'147'483'647});
+  testConversion<int32_t, int32_t>(
+      INTEGER(), {0, 1, -1, 42, 2'147'483'647}, {2, 3});
+}
+
+TEST_F(GetFlatValuesTest, int16ToInt32) {
+  testConversion<int16_t, int32_t>(INTEGER(), {0, 1, -1, 32'767, -32'768});
+  testConversion<int16_t, int32_t>(
+      INTEGER(), {0, 1, -1, 32'767, -32'768}, {1, 4});
+}
+
+TEST_F(GetFlatValuesTest, int32ToInt16) {
+  testConversion<int32_t, int16_t>(SMALLINT(), {0, 1, -1, 127, -128});
+  testConversion<int32_t, int16_t>(SMALLINT(), {0, 1, -1, 127, -128}, {0, 2});
+}
+
+TEST_F(GetFlatValuesTest, int64ToInt16) {
+  testConversion<int64_t, int16_t>(SMALLINT(), {0, 1, -1, 127, -128});
+  testConversion<int64_t, int16_t>(SMALLINT(), {0, 1, -1, 127, -128}, {3, 4});
+}
+
+TEST_F(GetFlatValuesTest, int32ToInt8) {
+  testConversion<int32_t, int8_t>(TINYINT(), {0, 1, -1, 42, -100});
+  testConversion<int32_t, int8_t>(TINYINT(), {0, 1, -1, 42, -100}, {1, 3, 4});
+}
+
+TEST_F(GetFlatValuesTest, int16ToInt8) {
+  testConversion<int16_t, int8_t>(TINYINT(), {0, 1, -1, 42, -100});
+  testConversion<int16_t, int8_t>(TINYINT(), {0, 1, -1, 42, -100}, {0, 4});
+}
+
+TEST_F(GetFlatValuesTest, int32ToInt64) {
+  testConversion<int32_t, int64_t>(
+      BIGINT(), {0, 1, -1, 2'147'483'647, -2'147'483'648});
+  testConversion<int32_t, int64_t>(
+      BIGINT(), {0, 1, -1, 2'147'483'647, -2'147'483'648}, {0, 2, 3});
+}
+
+TEST_F(GetFlatValuesTest, int16ToInt64) {
+  testConversion<int16_t, int64_t>(BIGINT(), {0, 1, -1, 32'767, -32'768});
+  testConversion<int16_t, int64_t>(
+      BIGINT(), {0, 1, -1, 32'767, -32'768}, {2, 4});
+}
+
+// HUGEINT widening conversions for Parquet type widening.
+
+TEST_F(GetFlatValuesTest, int128ToInt128) {
+  testConversion<int128_t, int128_t>(DECIMAL(38, 0), {0, 1, -1, 1'000'000});
+  testConversion<int128_t, int128_t>(
+      DECIMAL(38, 0), {0, 1, -1, 1'000'000}, {1, 3});
+}
+
+TEST_F(GetFlatValuesTest, int64ToInt128) {
+  testConversion<int64_t, int128_t>(
+      DECIMAL(38, 0),
+      {0, 1, -1, 9'223'372'036'854'775'807LL, -9'223'372'036'854'775'807LL});
+  testConversion<int64_t, int128_t>(
+      DECIMAL(38, 0),
+      {0, 1, -1, 9'223'372'036'854'775'807LL, -9'223'372'036'854'775'807LL},
+      {0, 3, 4});
+}
+
+TEST_F(GetFlatValuesTest, int32ToInt128) {
+  testConversion<int32_t, int128_t>(
+      DECIMAL(38, 0), {0, 1, -1, 2'147'483'647, -2'147'483'648});
+  testConversion<int32_t, int128_t>(
+      DECIMAL(38, 0), {0, 1, -1, 2'147'483'647, -2'147'483'648}, {1, 4});
+}
+
+TEST_F(GetFlatValuesTest, int16ToInt128) {
+  testConversion<int16_t, int128_t>(
+      DECIMAL(38, 0), {0, 1, -1, 32'767, -32'768});
+  testConversion<int16_t, int128_t>(
+      DECIMAL(38, 0), {0, 1, -1, 32'767, -32'768}, {0, 2, 3});
+}
+
+// Regression guards for existing same-domain paths affected by template
+// changes.
+
+TEST_F(GetFlatValuesTest, int64ToInt64) {
+  testConversion<int64_t, int64_t>(
+      BIGINT(),
+      {0, 1, -1, 9'223'372'036'854'775'807LL, -9'223'372'036'854'775'807LL});
+  testConversion<int64_t, int64_t>(
+      BIGINT(),
+      {0, 1, -1, 9'223'372'036'854'775'807LL, -9'223'372'036'854'775'807LL},
+      {0, 4});
+}
+
+TEST_F(GetFlatValuesTest, int64ToInt32) {
+  testConversion<int64_t, int32_t>(INTEGER(), {0, 1, -1, 42, -100});
+  testConversion<int64_t, int32_t>(INTEGER(), {0, 1, -1, 42, -100}, {2, 3});
+}
+
+TEST_F(GetFlatValuesTest, int16ToInt16) {
+  testConversion<int16_t, int16_t>(SMALLINT(), {0, 1, -1, 32'767, -32'768});
+  testConversion<int16_t, int16_t>(
+      SMALLINT(), {0, 1, -1, 32'767, -32'768}, {1, 2, 4});
+}
+
+// ByteRle conversions (int8_t source).
+
+TEST_F(GetFlatValuesTest, int8ToInt8) {
+  testConversion<int8_t, int8_t>(TINYINT(), {0, 1, -1, 127, -128});
+  testConversion<int8_t, int8_t>(TINYINT(), {0, 1, -1, 127, -128}, {0, 2, 4});
+}
+
+TEST_F(GetFlatValuesTest, int8ToInt16) {
+  testConversion<int8_t, int16_t>(SMALLINT(), {0, 1, -1, 127, -128});
+  testConversion<int8_t, int16_t>(SMALLINT(), {0, 1, -1, 127, -128}, {1, 3});
+}
+
+TEST_F(GetFlatValuesTest, int8ToInt32) {
+  testConversion<int8_t, int32_t>(INTEGER(), {0, 1, -1, 127, -128});
+  testConversion<int8_t, int32_t>(INTEGER(), {0, 1, -1, 127, -128}, {2, 4});
+}
+
+TEST_F(GetFlatValuesTest, int8ToInt64) {
+  testConversion<int8_t, int64_t>(BIGINT(), {0, 1, -1, 127, -128});
+  testConversion<int8_t, int64_t>(BIGINT(), {0, 1, -1, 127, -128}, {0, 3, 4});
+}
+
+// Unsigned integer conversions.
+
+TEST_F(GetFlatValuesTest, uint8ToUint8) {
+  testConversion<uint8_t, uint8_t>(TINYINT(), {0, 1, 42, 255});
+  testConversion<uint8_t, uint8_t>(TINYINT(), {0, 1, 42, 255}, {1, 3});
+}
+
+TEST_F(GetFlatValuesTest, uint16ToUint16) {
+  testConversion<uint16_t, uint16_t>(SMALLINT(), {0, 1, 42, 65'535});
+  testConversion<uint16_t, uint16_t>(SMALLINT(), {0, 1, 42, 65'535}, {0, 2});
+}
+
+TEST_F(GetFlatValuesTest, uint32ToUint8) {
+  testConversion<uint32_t, uint8_t>(TINYINT(), {0, 1, 42, 200});
+  testConversion<uint32_t, uint8_t>(TINYINT(), {0, 1, 42, 200}, {2, 3});
+}
+
+TEST_F(GetFlatValuesTest, uint32ToUint16) {
+  testConversion<uint32_t, uint16_t>(SMALLINT(), {0, 1, 42, 60'000});
+  testConversion<uint32_t, uint16_t>(SMALLINT(), {0, 1, 42, 60'000}, {0, 3});
+}
+
+TEST_F(GetFlatValuesTest, uint32ToUint32) {
+  testConversion<uint32_t, uint32_t>(INTEGER(), {0, 1, 42, 4'294'967'295U});
+  testConversion<uint32_t, uint32_t>(
+      INTEGER(), {0, 1, 42, 4'294'967'295U}, {1, 2});
+}
+
+TEST_F(GetFlatValuesTest, uint32ToUint64) {
+  testConversion<uint32_t, uint64_t>(BIGINT(), {0, 1, 42, 4'294'967'295U});
+  testConversion<uint32_t, uint64_t>(
+      BIGINT(), {0, 1, 42, 4'294'967'295U}, {0, 3});
+}
+
+TEST_F(GetFlatValuesTest, uint64ToUint64) {
+  testConversion<uint64_t, uint64_t>(BIGINT(), {0, 1, 42, 1'000'000'000ULL});
+  testConversion<uint64_t, uint64_t>(
+      BIGINT(), {0, 1, 42, 1'000'000'000ULL}, {1, 3});
+}
+
+TEST_F(GetFlatValuesTest, uint64ToUint128) {
+  testConversion<uint64_t, uint128_t>(
+      DECIMAL(38, 0), {0, 1, 42, 1'000'000'000ULL});
+  testConversion<uint64_t, uint128_t>(
+      DECIMAL(38, 0), {0, 1, 42, 1'000'000'000ULL}, {0, 2, 3});
+}
+
+TEST_F(GetFlatValuesTest, uint128ToUint128) {
+  testConversion<uint128_t, uint128_t>(DECIMAL(38, 0), {0, 1, 42, 1'000'000});
+  testConversion<uint128_t, uint128_t>(
+      DECIMAL(38, 0), {0, 1, 42, 1'000'000}, {1, 2});
+}
+
+// Floating-point conversions.
+
+TEST_F(GetFlatValuesTest, floatToFloat) {
+  testConversion<float, float>(REAL(), {0.0f, 1.5f, -3.14f, 1e10f});
+  testConversion<float, float>(REAL(), {0.0f, 1.5f, -3.14f, 1e10f}, {0, 2});
+}
+
+TEST_F(GetFlatValuesTest, floatToDouble) {
+  testConversion<float, double>(DOUBLE(), {0.0f, 1.5f, -3.14f, 1e10f});
+  testConversion<float, double>(DOUBLE(), {0.0f, 1.5f, -3.14f, 1e10f}, {1, 3});
+}
+
+TEST_F(GetFlatValuesTest, doubleToDouble) {
+  testConversion<double, double>(DOUBLE(), {0.0, 1.5, -3.14, 1e100});
+  testConversion<double, double>(DOUBLE(), {0.0, 1.5, -3.14, 1e100}, {0, 3});
+}
+
+TEST_F(GetFlatValuesTest, floatToDoubleSpecialValues) {
+  auto reader = makeReader(DOUBLE());
+  std::vector<float> data = {
+      std::numeric_limits<float>::quiet_NaN(),
+      std::numeric_limits<float>::infinity(),
+      -std::numeric_limits<float>::infinity(),
+      -0.0f,
+      std::numeric_limits<float>::denorm_min()};
+  std::vector<int32_t> rowNums(data.size());
+  std::iota(rowNums.begin(), rowNums.end(), 0);
+  reader->setupValues(data, rowNums);
+
+  const RowSet rows(rowNums.data(), rowNums.size());
+  VectorPtr result;
+  reader->getFlatValues<float, double>(rows, &result, DOUBLE(), true);
+
+  auto* flat = result->as<FlatVector<double>>();
+  ASSERT_NE(flat, nullptr);
+  ASSERT_EQ(flat->size(), data.size());
+  EXPECT_TRUE(std::isnan(flat->valueAt(0)));
+  EXPECT_EQ(flat->valueAt(1), std::numeric_limits<double>::infinity());
+  EXPECT_EQ(flat->valueAt(2), -std::numeric_limits<double>::infinity());
+  EXPECT_DOUBLE_EQ(flat->valueAt(3), -0.0);
+  EXPECT_TRUE(std::signbit(flat->valueAt(3)));
+  EXPECT_DOUBLE_EQ(
+      flat->valueAt(4),
+      static_cast<double>(std::numeric_limits<float>::denorm_min()));
+}
+
+// Boundary condition: single-element input.
+
+TEST_F(GetFlatValuesTest, singleElement) {
+  testConversion<int32_t, int64_t>(BIGINT(), {42});
+}
+
+// Large-scale conversion: 1024 values with dense and sparse rows.
+
+TEST_F(GetFlatValuesTest, largeScaleInt32ToDouble) {
+  constexpr int kSize = 1024;
+  std::vector<int32_t> data(kSize);
+  for (int i = 0; i < kSize; ++i) {
+    data[i] = i * 7 - 3000;
+  }
+  // Dense.
+  testConversion<int32_t, double>(DOUBLE(), data);
+  // Sparse: every 3rd row.
+  std::vector<int32_t> sparse;
+  for (int i = 0; i < kSize; i += 3) {
+    sparse.push_back(i);
+  }
+  testConversion<int32_t, double>(DOUBLE(), data, sparse);
+}
+
+TEST_F(GetFlatValuesTest, largeScaleInt64ToInt128) {
+  constexpr int kSize = 1024;
+  std::vector<int64_t> data(kSize);
+  for (int i = 0; i < kSize; ++i) {
+    data[i] = static_cast<int64_t>(i) * 123'456'789LL - 50'000'000'000LL;
+  }
+  testConversion<int64_t, int128_t>(DECIMAL(38, 0), data);
+  // Sparse: odd indices.
+  std::vector<int32_t> sparse;
+  for (int i = 1; i < kSize; i += 2) {
+    sparse.push_back(i);
+  }
+  testConversion<int64_t, int128_t>(DECIMAL(38, 0), data, sparse);
+}
+
+TEST_F(GetFlatValuesTest, largeScaleInt32ToInt16) {
+  constexpr int kSize = 1024;
+  std::vector<int32_t> data(kSize);
+  for (int i = 0; i < kSize; ++i) {
+    data[i] = (i % 256) - 128;
+  }
+  testConversion<int32_t, int16_t>(SMALLINT(), data);
+  // Sparse: every 5th row.
+  std::vector<int32_t> sparse;
+  for (int i = 0; i < kSize; i += 5) {
+    sparse.push_back(i);
+  }
+  testConversion<int32_t, int16_t>(SMALLINT(), data, sparse);
+}
+
+// Cross-domain upcast conversion with nulls.
+
+TEST_F(GetFlatValuesTest, int32ToDoubleWithNulls) {
+  auto reader = makeReader(DOUBLE());
+  const std::vector<int32_t> data = {10, 20, 0, 40, 0};
+  const std::vector<bool> nulls = {false, false, true, false, true};
+  std::vector<int32_t> rowNums(data.size());
+  std::iota(rowNums.begin(), rowNums.end(), 0);
+  reader->setupValuesWithNulls(data, nulls, rowNums);
+
+  const RowSet rows(rowNums.data(), rowNums.size());
+  VectorPtr result;
+  reader->getFlatValues<int32_t, double>(rows, &result, DOUBLE(), true);
+
+  auto* flat = result->as<FlatVector<double>>();
+  ASSERT_NE(flat, nullptr);
+  ASSERT_EQ(flat->size(), data.size());
+  EXPECT_DOUBLE_EQ(flat->valueAt(0), 10.0);
+  EXPECT_DOUBLE_EQ(flat->valueAt(1), 20.0);
+  EXPECT_TRUE(flat->isNullAt(2));
+  EXPECT_DOUBLE_EQ(flat->valueAt(3), 40.0);
+  EXPECT_TRUE(flat->isNullAt(4));
+}
+
+// Sparse rows with nulls.
+
+TEST_F(GetFlatValuesTest, int32ToDoubleSparseRowsWithNulls) {
+  auto reader = makeReader(DOUBLE());
+  const std::vector<int32_t> data = {10, 20, 0, 40, 0, 60};
+  const std::vector<bool> nulls = {false, false, true, false, true, false};
+  const std::vector<int32_t> allRows = {0, 1, 2, 3, 4, 5};
+  reader->setupValuesWithNulls(data, nulls, allRows);
+
+  // Select rows {0, 2, 3, 5} — includes null at index 2.
+  const std::vector<int32_t> sparseRows = {0, 2, 3, 5};
+  const RowSet rows(sparseRows.data(), sparseRows.size());
+  VectorPtr result;
+  reader->getFlatValues<int32_t, double>(rows, &result, DOUBLE(), true);
+
+  auto* flat = result->as<FlatVector<double>>();
+  ASSERT_NE(flat, nullptr);
+  ASSERT_EQ(flat->size(), 4);
+  EXPECT_DOUBLE_EQ(flat->valueAt(0), 10.0);
+  EXPECT_TRUE(flat->isNullAt(1));
+  EXPECT_DOUBLE_EQ(flat->valueAt(2), 40.0);
+  EXPECT_DOUBLE_EQ(flat->valueAt(3), 60.0);
+}
+
+TEST_F(GetFlatValuesTest, int64ToInt128SparseRowsWithNulls) {
+  auto reader = makeReader(DECIMAL(38, 0));
+  const std::vector<int64_t> data = {100, 0, 300, 0, 500};
+  const std::vector<bool> nulls = {false, true, false, true, false};
+  const std::vector<int32_t> allRows = {0, 1, 2, 3, 4};
+  reader->setupValuesWithNulls(data, nulls, allRows);
+
+  const std::vector<int32_t> sparseRows = {0, 1, 4};
+  const RowSet rows(sparseRows.data(), sparseRows.size());
+  VectorPtr result;
+  reader->getFlatValues<int64_t, int128_t>(rows, &result, DECIMAL(38, 0), true);
+
+  auto* flat = result->as<FlatVector<int128_t>>();
+  ASSERT_NE(flat, nullptr);
+  ASSERT_EQ(flat->size(), 3);
+  EXPECT_EQ(flat->valueAt(0), 100);
+  EXPECT_TRUE(flat->isNullAt(1));
+  EXPECT_EQ(flat->valueAt(2), 500);
+}
+
+} // namespace
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/tests/SortingWriterTest.cpp b/velox/dwio/common/tests/SortingWriterTest.cpp
index 4beadc61e1a..d13837641c8 100644
--- a/velox/dwio/common/tests/SortingWriterTest.cpp
+++ b/velox/dwio/common/tests/SortingWriterTest.cpp
@@ -43,8 +43,9 @@ class MockWriter : public Writer {
 
   void flush() override {}
 
-  void close() override {
+  std::unique_ptr<FileMetadata> close() override {
     setState(State::kClosed);
+    return nullptr;
   }
 
   void abort() override {
diff --git a/velox/dwio/common/tests/StreamUtilTest.cpp b/velox/dwio/common/tests/StreamUtilTest.cpp
new file mode 100644
index 00000000000..dc1e6b5abfa
--- /dev/null
+++ b/velox/dwio/common/tests/StreamUtilTest.cpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/common/StreamUtil.h"
+
+#include <gtest/gtest.h>
+
+namespace facebook::velox::dwio::common {
+namespace {
+
+template <int kStep>
+void testRowLoop(
+    const int32_t* rows,
+    int32_t begin,
+    int32_t end,
+    const std::vector<int32_t>& expectedDense,
+    const std::vector<int32_t>& expectedSparse,
+    const std::vector<std::pair<int32_t, int32_t>>& expectedSparseN) {
+  std::vector<int32_t> actualDense, actualSparse;
+  std::vector<std::pair<int32_t, int32_t>> actualSparseN;
+  rowLoop<kStep>(
+      rows,
+      begin,
+      end,
+      [&](auto i) { actualDense.push_back(i); },
+      [&](auto i) { actualSparse.push_back(i); },
+      [&](auto i, auto size) { actualSparseN.emplace_back(i, size); });
+  ASSERT_EQ(actualDense, expectedDense);
+  ASSERT_EQ(actualSparse, expectedSparse);
+  ASSERT_EQ(actualSparseN, expectedSparseN);
+}
+
+TEST(StreamUtilTest, rowLoop) {
+  const int32_t rows[] = {
+      0,  1,  2,  3,  4, // Dense
+      5,  7,  9,  11, 13, // Sparse
+      14, 15, 16, 17, 18, // Dense
+      19, 21, 23, 25, 27, // Sparse
+  };
+  testRowLoop<2>(rows, 0, 6, {0, 2, 4}, {}, {});
+  testRowLoop<4>(rows, 0, 6, {0}, {}, {{4, 2}});
+  testRowLoop<4>(rows, 0, 10, {0}, {4}, {{8, 2}});
+  testRowLoop<4>(rows, 10, 20, {10}, {14}, {{18, 2}});
+}
+
+} // namespace
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/tests/TestBufferedInput.cpp b/velox/dwio/common/tests/TestBufferedInput.cpp
deleted file mode 100644
index 6fa5be8da00..00000000000
--- a/velox/dwio/common/tests/TestBufferedInput.cpp
+++ /dev/null
@@ -1,379 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-#include "velox/dwio/common/BufferedInput.h"
-
-using namespace facebook::velox::dwio::common;
-using facebook::velox::common::Region;
-using namespace facebook::velox::memory;
-using namespace ::testing;
-
-namespace {
-
-class ReadFileMock : public ::facebook::velox::ReadFile {
- public:
-  virtual ~ReadFileMock() override = default;
-
-  MOCK_METHOD(
-      std::string_view,
-      pread,
-      (uint64_t offset,
-       uint64_t length,
-       void* buf,
-       facebook::velox::filesystems::File::IoStats* stats),
-      (const, override));
-
-  MOCK_METHOD(bool, shouldCoalesce, (), (const, override));
-  MOCK_METHOD(uint64_t, size, (), (const, override));
-  MOCK_METHOD(uint64_t, memoryUsage, (), (const, override));
-  MOCK_METHOD(std::string, getName, (), (const, override));
-  MOCK_METHOD(uint64_t, getNaturalReadSize, (), (const, override));
-  MOCK_METHOD(
-      uint64_t,
-      preadv,
-      (folly::Range<const Region*> regions,
-       folly::Range<folly::IOBuf*> iobufs,
-       facebook::velox::filesystems::File::IoStats* stats),
-      (const, override));
-};
-
-void expectPreads(
-    ReadFileMock& file,
-    std::string_view content,
-    std::vector<Region> reads) {
-  EXPECT_CALL(file, getName()).WillRepeatedly(Return("mock_name"));
-  EXPECT_CALL(file, size()).WillRepeatedly(Return(content.size()));
-  for (auto& read : reads) {
-    ASSERT_GE(content.size(), read.offset + read.length);
-    EXPECT_CALL(file, pread(read.offset, read.length, _, nullptr))
-        .Times(1)
-        .WillOnce(
-            [content](
-                uint64_t offset,
-                uint64_t length,
-                void* buf,
-                facebook::velox::filesystems::File::IoStats* stats)
-                -> std::string_view {
-              memcpy(buf, content.data() + offset, length);
-              return {content.data() + offset, length};
-            });
-  }
-}
-
-void expectPreadvs(
-    ReadFileMock& file,
-    std::string_view content,
-    std::vector<Region> reads) {
-  EXPECT_CALL(file, getName()).WillRepeatedly(Return("mock_name"));
-  EXPECT_CALL(file, size()).WillRepeatedly(Return(content.size()));
-  EXPECT_CALL(file, preadv(_, _, nullptr))
-      .Times(1)
-      .WillOnce(
-          [content, reads](
-              folly::Range<const Region*> regions,
-              folly::Range<folly::IOBuf*> iobufs,
-              facebook::velox::filesystems::File::IoStats* stats) -> uint64_t {
-            EXPECT_EQ(regions.size(), reads.size());
-            uint64_t length = 0;
-            for (size_t i = 0; i < reads.size(); ++i) {
-              const auto& region = regions[i];
-              const auto& read = reads[i];
-              auto& iobuf = iobufs[i];
-              length += region.length;
-              EXPECT_EQ(region.offset, read.offset);
-              EXPECT_EQ(region.length, read.length);
-              if (!read.label.empty()) {
-                EXPECT_EQ(read.label, region.label);
-              }
-              EXPECT_LE(region.offset + region.length, content.size());
-              iobuf = folly::IOBuf(
-                  folly::IOBuf::COPY_BUFFER,
-                  content.data() + region.offset,
-                  region.length);
-            }
-
-            return length;
-          });
-}
-
-std::optional<std::string> getNext(SeekableInputStream& input) {
-  const void* buf = nullptr;
-  int32_t size;
-  if (input.Next(&buf, &size)) {
-    return std::string(
-        static_cast<const char*>(buf), static_cast<size_t>(size));
-  } else {
-    return std::nullopt;
-  }
-}
-
-class TestBufferedInput : public testing::Test {
- protected:
-  static void SetUpTestCase() {
-    MemoryManager::testingSetInstance(MemoryManager::Options{});
-  }
-
-  const std::shared_ptr<MemoryPool> pool_ = memoryManager()->addLeafPool();
-};
-} // namespace
-
-TEST_F(TestBufferedInput, ZeroLengthStream) {
-  auto readFile =
-      std::make_shared<facebook::velox::InMemoryReadFile>(std::string());
-  BufferedInput input(readFile, *pool_);
-  auto ret = input.enqueue({0, 0});
-  EXPECT_EQ(input.nextFetchSize(), 0);
-  EXPECT_NE(ret, nullptr);
-  const void* buf = nullptr;
-  int32_t size = 1;
-  EXPECT_FALSE(ret->Next(&buf, &size));
-  EXPECT_EQ(size, 0);
-}
-
-TEST_F(TestBufferedInput, UseRead) {
-  std::string content = "hello";
-  auto readFileMock = std::make_shared<ReadFileMock>();
-  expectPreads(*readFileMock, content, {{0, 5}});
-  // Use read
-  BufferedInput input(
-      readFileMock,
-      *pool_,
-      MetricsLog::voidLog(),
-      nullptr,
-      nullptr,
-      10,
-      /* wsVRLoad = */ false);
-  auto ret = input.enqueue({0, 5});
-  ASSERT_NE(ret, nullptr);
-
-  EXPECT_EQ(input.nextFetchSize(), 5);
-  input.load(LogType::TEST);
-
-  auto next = getNext(*ret);
-  ASSERT_TRUE(next.has_value());
-  EXPECT_EQ(next.value(), content);
-}
-
-TEST_F(TestBufferedInput, UseVRead) {
-  std::string content = "hello";
-  auto readFileMock = std::make_shared<ReadFileMock>();
-  expectPreadvs(*readFileMock, content, {{0, 5}});
-  // Use vread
-  BufferedInput input(
-      readFileMock,
-      *pool_,
-      MetricsLog::voidLog(),
-      nullptr,
-      nullptr,
-      10,
-      /* wsVRLoad = */ true);
-  auto ret = input.enqueue({0, 5});
-  ASSERT_NE(ret, nullptr);
-
-  EXPECT_EQ(input.nextFetchSize(), 5);
-  input.load(LogType::TEST);
-
-  auto next = getNext(*ret);
-  ASSERT_TRUE(next.has_value());
-  EXPECT_EQ(next.value(), content);
-}
-
-TEST_F(TestBufferedInput, WillMerge) {
-  std::string content = "hello world";
-  auto readFileMock = std::make_shared<ReadFileMock>();
-
-  // Will merge because the distance is 1 and max distance to merge is 10.
-  // Expect only one call.
-  expectPreads(*readFileMock, content, {{0, 11}});
-
-  BufferedInput input(
-      readFileMock,
-      *pool_,
-      MetricsLog::voidLog(),
-      nullptr,
-      nullptr,
-      10, // Will merge if distance <= 10
-      /* wsVRLoad = */ false);
-
-  auto ret1 = input.enqueue({0, 5});
-  auto ret2 = input.enqueue({6, 5});
-  ASSERT_NE(ret1, nullptr);
-  ASSERT_NE(ret2, nullptr);
-
-  EXPECT_EQ(input.nextFetchSize(), 10);
-  input.load(LogType::TEST);
-
-  auto next1 = getNext(*ret1);
-  ASSERT_TRUE(next1.has_value());
-  EXPECT_EQ(next1.value(), "hello");
-
-  auto next2 = getNext(*ret2);
-  ASSERT_TRUE(next2.has_value());
-  EXPECT_EQ(next2.value(), "world");
-}
-
-TEST_F(TestBufferedInput, WontMerge) {
-  std::string content = "hello  world"; // two spaces
-  auto readFileMock = std::make_shared<ReadFileMock>();
-
-  // Won't merge because the distance is 2 and max distance to merge is 1.
-  // Expect two calls
-  expectPreads(*readFileMock, content, {{0, 5}, {7, 5}});
-
-  BufferedInput input(
-      readFileMock,
-      *pool_,
-      MetricsLog::voidLog(),
-      nullptr,
-      nullptr,
-      1, // Will merge if distance <= 1
-      /* wsVRLoad = */ false);
-
-  auto ret1 = input.enqueue({0, 5});
-  auto ret2 = input.enqueue({7, 5});
-  ASSERT_NE(ret1, nullptr);
-  ASSERT_NE(ret2, nullptr);
-
-  EXPECT_EQ(input.nextFetchSize(), 10);
-  input.load(LogType::TEST);
-
-  auto next1 = getNext(*ret1);
-  ASSERT_TRUE(next1.has_value());
-  EXPECT_EQ(next1.value(), "hello");
-
-  auto next2 = getNext(*ret2);
-  ASSERT_TRUE(next2.has_value());
-  EXPECT_EQ(next2.value(), "world");
-}
-
-TEST_F(TestBufferedInput, ReadSorting) {
-  std::string content = "aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqq";
-  std::vector<Region> regions = {{6, 3}, {24, 3}, {3, 3}, {0, 3}, {29, 3}};
-
-  auto readFileMock = std::make_shared<ReadFileMock>();
-  expectPreads(*readFileMock, content, {{0, 9}, {24, 3}, {29, 3}});
-  BufferedInput input(
-      readFileMock,
-      *pool_,
-      MetricsLog::voidLog(),
-      nullptr,
-      nullptr,
-      1, // Will merge if distance <= 1
-      /* wsVRLoad = */ false);
-
-  std::vector<std::pair<std::unique_ptr<SeekableInputStream>, std::string>>
-      result;
-  result.reserve(regions.size());
-  int64_t bytesToRead = 0;
-  for (auto& region : regions) {
-    bytesToRead += region.length;
-    auto ret = input.enqueue(region);
-    ASSERT_NE(ret, nullptr);
-    result.push_back(
-        {std::move(ret), content.substr(region.offset, region.length)});
-  }
-
-  EXPECT_EQ(input.nextFetchSize(), bytesToRead);
-  input.load(LogType::TEST);
-
-  for (auto& r : result) {
-    auto next = getNext(*r.first);
-    ASSERT_TRUE(next.has_value());
-    EXPECT_EQ(next.value(), r.second);
-  }
-}
-
-TEST_F(TestBufferedInput, VReadSorting) {
-  std::string content = "aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqq";
-  std::vector<Region> regions = {{6, 3}, {24, 3}, {3, 3}, {0, 3}, {29, 3}};
-
-  auto readFileMock = std::make_shared<ReadFileMock>();
-  expectPreadvs(
-      *readFileMock, content, {{0, 3}, {3, 3}, {6, 3}, {24, 3}, {29, 3}});
-  BufferedInput input(
-      readFileMock,
-      *pool_,
-      MetricsLog::voidLog(),
-      nullptr,
-      nullptr,
-      1, // Will merge if distance <= 1
-      /* wsVRLoad = */ true);
-
-  std::vector<std::pair<std::unique_ptr<SeekableInputStream>, std::string>>
-      result;
-  result.reserve(regions.size());
-  int64_t bytesToRead = 0;
-  for (auto& region : regions) {
-    bytesToRead += region.length;
-    auto ret = input.enqueue(region);
-    ASSERT_NE(ret, nullptr);
-    result.push_back(
-        {std::move(ret), content.substr(region.offset, region.length)});
-  }
-
-  EXPECT_EQ(input.nextFetchSize(), bytesToRead);
-  input.load(LogType::TEST);
-
-  for (auto& r : result) {
-    auto next = getNext(*r.first);
-    ASSERT_TRUE(next.has_value());
-    EXPECT_EQ(next.value(), r.second);
-  }
-}
-
-TEST_F(TestBufferedInput, VReadSortingWithLabels) {
-  std::string content = "aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqq";
-  std::vector<std::string> l = {"a", "b", "c", "d", "e"};
-  std::vector<Region> regions = {
-      {6, 3, l[2]}, {24, 3, l[3]}, {3, 3, l[1]}, {0, 3, l[0]}, {29, 3, l[4]}};
-
-  auto readFileMock = std::make_shared<ReadFileMock>();
-  expectPreadvs(
-      *readFileMock,
-      content,
-      {{0, 3, l[0]}, {3, 3, l[1]}, {6, 3, l[2]}, {24, 3, l[3]}, {29, 3, l[4]}});
-  BufferedInput input(
-      readFileMock,
-      *pool_,
-      MetricsLog::voidLog(),
-      nullptr,
-      nullptr,
-      1, // Will merge if distance <= 1
-      /* wsVRLoad = */ true);
-
-  std::vector<std::pair<std::unique_ptr<SeekableInputStream>, std::string>>
-      result;
-  result.reserve(regions.size());
-  int64_t bytesToRead = 0;
-  for (auto& region : regions) {
-    bytesToRead += region.length;
-    auto ret = input.enqueue(region);
-    ASSERT_NE(ret, nullptr);
-    result.push_back(
-        {std::move(ret), content.substr(region.offset, region.length)});
-  }
-
-  EXPECT_EQ(input.nextFetchSize(), bytesToRead);
-  input.load(LogType::TEST);
-
-  for (auto& r : result) {
-    auto next = getNext(*r.first);
-    ASSERT_TRUE(next.has_value());
-    EXPECT_EQ(next.value(), r.second);
-  }
-}
diff --git a/velox/dwio/common/tests/ThrottlerTest.cpp b/velox/dwio/common/tests/ThrottlerTest.cpp
index 773e8d0dd70..12ea0c86d75 100644
--- a/velox/dwio/common/tests/ThrottlerTest.cpp
+++ b/velox/dwio/common/tests/ThrottlerTest.cpp
@@ -110,14 +110,15 @@ TEST_F(ThrottlerTest, throttle) {
     SCOPED_TRACE(fmt::format("signal: {}", Throttler::signalTypeName(signal)));
 
     Throttler::testingReset();
-    Throttler::init(Throttler::Config(
-        true,
-        minThrottleBackoffMs,
-        maxThrottleBackoffMs,
-        2.0,
-        signal == Throttler::SignalType::kLocal ? 2 : 1'000,
-        signal == Throttler::SignalType::kGlobal ? 2 : 1'000,
-        signal == Throttler::SignalType::kNetwork ? 2 : 1'000));
+    Throttler::init(
+        Throttler::Config(
+            true,
+            minThrottleBackoffMs,
+            maxThrottleBackoffMs,
+            2.0,
+            signal == Throttler::SignalType::kLocal ? 2 : 1'000,
+            signal == Throttler::SignalType::kGlobal ? 2 : 1'000,
+            signal == Throttler::SignalType::kNetwork ? 2 : 1'000));
     auto* instance = Throttler::instance();
     const auto& stats = instance->stats();
     ASSERT_EQ(stats.localThrottled, 0);
@@ -186,16 +187,17 @@ TEST_F(ThrottlerTest, expire) {
   for (const auto signal : kSignalTypes) {
     SCOPED_TRACE(fmt::format("signal: {}", Throttler::signalTypeName(signal)));
     Throttler::testingReset();
-    Throttler::init(Throttler::Config(
-        true,
-        minThrottleBackoffMs,
-        maxThrottleBackoffMs,
-        2.0,
-        signal == Throttler::SignalType::kLocal ? 2 : 1'000,
-        signal == Throttler::SignalType::kGlobal ? 2 : 1'000,
-        signal == Throttler::SignalType::kNetwork ? 2 : 1'000,
-        1'000,
-        1'000));
+    Throttler::init(
+        Throttler::Config(
+            true,
+            minThrottleBackoffMs,
+            maxThrottleBackoffMs,
+            2.0,
+            signal == Throttler::SignalType::kLocal ? 2 : 1'000,
+            signal == Throttler::SignalType::kGlobal ? 2 : 1'000,
+            signal == Throttler::SignalType::kNetwork ? 2 : 1'000,
+            1'000,
+            1'000));
     auto* instance = Throttler::instance();
     const auto& stats = instance->stats();
     ASSERT_EQ(stats.localThrottled, 0);
@@ -228,8 +230,9 @@ TEST_F(ThrottlerTest, expire) {
 TEST_F(ThrottlerTest, differentLocals) {
   const uint64_t minThrottleBackoffMs = 1'000;
   const uint64_t maxThrottleBackoffMs = 2'000;
-  Throttler::init(Throttler::Config(
-      true, minThrottleBackoffMs, maxThrottleBackoffMs, 2.0, 2, 1'0000));
+  Throttler::init(
+      Throttler::Config(
+          true, minThrottleBackoffMs, maxThrottleBackoffMs, 2.0, 2, 1'0000));
   auto* instance = Throttler::instance();
   const auto& stats = instance->stats();
   ASSERT_EQ(stats.localThrottled, 0);
@@ -320,8 +323,9 @@ TEST_F(ThrottlerTest, differentLocals) {
 TEST_F(ThrottlerTest, differentGlobals) {
   const uint64_t minThrottleBackoffMs = 1'000;
   const uint64_t maxThrottleBackoffMs = 2'000;
-  Throttler::init(Throttler::Config(
-      true, minThrottleBackoffMs, maxThrottleBackoffMs, 2.0, 1'0000, 2));
+  Throttler::init(
+      Throttler::Config(
+          true, minThrottleBackoffMs, maxThrottleBackoffMs, 2.0, 1'0000, 2));
   auto* instance = Throttler::instance();
   const auto& stats = instance->stats();
   ASSERT_EQ(stats.localThrottled, 0);
@@ -409,14 +413,15 @@ TEST_F(ThrottlerTest, differentGlobals) {
 TEST_F(ThrottlerTest, differentNetworks) {
   const uint64_t minThrottleBackoffMs = 1'000;
   const uint64_t maxThrottleBackoffMs = 2'000;
-  Throttler::init(Throttler::Config(
-      true,
-      minThrottleBackoffMs,
-      maxThrottleBackoffMs,
-      2.0,
-      1'0000,
-      1'0000,
-      2));
+  Throttler::init(
+      Throttler::Config(
+          true,
+          minThrottleBackoffMs,
+          maxThrottleBackoffMs,
+          2.0,
+          1'0000,
+          1'0000,
+          2));
   auto* instance = Throttler::instance();
   const auto& stats = instance->stats();
   ASSERT_EQ(stats.localThrottled, 0);
@@ -511,8 +516,9 @@ TEST_F(ThrottlerTest, maxOfGlobalAndLocal) {
   for (const bool localFirst : {false, true}) {
     SCOPED_TRACE(fmt::format("localFirst: {}", localFirst));
     Throttler::testingReset();
-    Throttler::init(Throttler::Config(
-        true, minThrottleBackoffMs, maxThrottleBackoffMs, 2.0, 2, 2));
+    Throttler::init(
+        Throttler::Config(
+            true, minThrottleBackoffMs, maxThrottleBackoffMs, 2.0, 2, 2));
     auto* instance = Throttler::instance();
     const auto& stats = instance->stats();
     ASSERT_EQ(stats.localThrottled, 0);
@@ -627,16 +633,17 @@ TEST_F(ThrottlerTest, fuzz) {
   const uint32_t maxCacheEntries = 64;
   const uint32_t cacheTTLMs = 10;
   Throttler::testingReset();
-  Throttler::init(Throttler::Config(
-      true,
-      minThrottleBackoffMs,
-      maxThrottleBackoffMs,
-      backoffScaleFactor,
-      minLocalThrottledSignals,
-      minGlobalThrottledSignals,
-      minNetworkThrottledSignals,
-      maxCacheEntries,
-      cacheTTLMs));
+  Throttler::init(
+      Throttler::Config(
+          true,
+          minThrottleBackoffMs,
+          maxThrottleBackoffMs,
+          backoffScaleFactor,
+          minLocalThrottledSignals,
+          minGlobalThrottledSignals,
+          minNetworkThrottledSignals,
+          maxCacheEntries,
+          cacheTTLMs));
   auto* instance = Throttler::instance();
 
   const auto seed = getCurrentTimeMs();
diff --git a/velox/dwio/common/tests/UnitLoaderBaseTest.h b/velox/dwio/common/tests/UnitLoaderBaseTest.h
new file mode 100644
index 00000000000..9faf9bc91b3
--- /dev/null
+++ b/velox/dwio/common/tests/UnitLoaderBaseTest.h
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/dwio/common/UnitLoaderTools.h"
+#include "velox/dwio/common/tests/utils/UnitLoaderTestTools.h"
+
+using facebook::velox::dwio::common::LoadUnit;
+using facebook::velox::dwio::common::test::getUnitsLoadedWithFalse;
+using facebook::velox::dwio::common::test::LoadUnitMock;
+using facebook::velox::dwio::common::test::ReaderMock;
+
+/// Base test class template that provides common test functionality for
+/// different UnitLoader implementations. This template class can be inherited
+/// by specific test classes to get access to common test methods. Each derived
+/// class should provide a createFactory() method that returns the appropriate
+/// factory instance.
+template <typename UnitLoaderFactoryType>
+class UnitLoaderBaseTest : public ::testing::Test {
+ protected:
+  /// Factory method to create the appropriate UnitLoaderFactory instance.
+  /// This method should be implemented by derived classes.
+  virtual UnitLoaderFactoryType createFactory() = 0;
+
+  /// Test that UnitLoader factory handles the case where no units exist but
+  /// skip is requested
+  void testNoUnitButSkip() {
+    UnitLoaderFactoryType factory = createFactory();
+    std::vector<std::unique_ptr<LoadUnit>> units;
+
+    EXPECT_NO_THROW(factory.create(std::move(units), 0));
+
+    std::vector<std::unique_ptr<LoadUnit>> units2;
+    VELOX_ASSERT_THROW(
+        factory.create(std::move(units2), 1),
+        "Can only skip up to the past-the-end row of the file.");
+  }
+
+  /// Test that UnitLoader factory handles initial skip correctly for various
+  /// skip values
+  void testInitialSkip() {
+    auto getFactoryWithSkip = [this](uint64_t skipToRow) {
+      auto factory = createFactory();
+      std::vector<std::atomic_bool> unitsLoaded(getUnitsLoadedWithFalse(3));
+      std::vector<std::unique_ptr<LoadUnit>> units;
+      units.push_back(std::make_unique<LoadUnitMock>(10, 0, unitsLoaded, 0));
+      units.push_back(std::make_unique<LoadUnitMock>(20, 0, unitsLoaded, 1));
+      units.push_back(std::make_unique<LoadUnitMock>(30, 0, unitsLoaded, 2));
+      factory.create(std::move(units), skipToRow);
+    };
+
+    EXPECT_NO_THROW(getFactoryWithSkip(0));
+    EXPECT_NO_THROW(getFactoryWithSkip(1));
+    EXPECT_NO_THROW(getFactoryWithSkip(9));
+    EXPECT_NO_THROW(getFactoryWithSkip(10));
+    EXPECT_NO_THROW(getFactoryWithSkip(11));
+    EXPECT_NO_THROW(getFactoryWithSkip(29));
+    EXPECT_NO_THROW(getFactoryWithSkip(30));
+    EXPECT_NO_THROW(getFactoryWithSkip(31));
+    EXPECT_NO_THROW(getFactoryWithSkip(59));
+    EXPECT_NO_THROW(getFactoryWithSkip(60));
+    VELOX_ASSERT_THROW(
+        getFactoryWithSkip(61),
+        "Can only skip up to the past-the-end row of the file.");
+    VELOX_ASSERT_THROW(
+        getFactoryWithSkip(100),
+        "Can only skip up to the past-the-end row of the file.");
+  }
+
+  /// Test that the same unit can be requested multiple times without issues
+  void testCanRequestUnitMultipleTimes() {
+    auto factory = createFactory();
+    std::vector<std::atomic_bool> unitsLoaded(getUnitsLoadedWithFalse(1));
+    std::vector<std::unique_ptr<LoadUnit>> units;
+    units.push_back(std::make_unique<LoadUnitMock>(10, 0, unitsLoaded, 0));
+
+    auto unitLoader = factory.create(std::move(units), 0);
+    unitLoader->getLoadedUnit(0);
+    unitLoader->getLoadedUnit(0);
+    unitLoader->getLoadedUnit(0);
+  }
+
+  /// Test that requesting a unit index out of range throws an exception
+  void testUnitOutOfRange() {
+    auto factory = createFactory();
+    std::vector<std::atomic_bool> unitsLoaded(getUnitsLoadedWithFalse(1));
+    std::vector<std::unique_ptr<LoadUnit>> units;
+    units.push_back(std::make_unique<LoadUnitMock>(10, 0, unitsLoaded, 0));
+
+    auto unitLoader = factory.create(std::move(units), 0);
+    unitLoader->getLoadedUnit(0);
+
+    VELOX_ASSERT_THROW(unitLoader->getLoadedUnit(1), "Unit out of range");
+  }
+
+  /// Test that seeking out of range throws an exception
+  void testSeekOutOfRange() {
+    auto factory = createFactory();
+    std::vector<std::atomic_bool> unitsLoaded(getUnitsLoadedWithFalse(1));
+    std::vector<std::unique_ptr<LoadUnit>> units;
+    units.push_back(std::make_unique<LoadUnitMock>(10, 0, unitsLoaded, 0));
+
+    auto unitLoader = factory.create(std::move(units), 0);
+
+    unitLoader->onSeek(0, 10);
+
+    VELOX_ASSERT_THROW(unitLoader->onSeek(0, 11), "Row out of range");
+  }
+
+  /// Test that seeking out of range in ReaderMock throws appropriate exception
+  void testSeekOutOfRangeReaderError() {
+    auto factory = createFactory();
+    ReaderMock readerMock{{10, 20, 30}, {0, 0, 0}, factory, 0};
+
+    readerMock.seek(59);
+    readerMock.seek(60);
+
+    VELOX_ASSERT_THROW(
+        readerMock.seek(61),
+        "Can't seek to possition 61 in file. Must be up to 60.");
+  }
+};
diff --git a/velox/dwio/common/tests/WriterTest.cpp b/velox/dwio/common/tests/WriterTest.cpp
index 51e68de59d0..f1118927e30 100644
--- a/velox/dwio/common/tests/WriterTest.cpp
+++ b/velox/dwio/common/tests/WriterTest.cpp
@@ -15,13 +15,47 @@
  */
 
 #include "velox/dwio/common/Writer.h"
+
 #include <gtest/gtest.h>
+
 #include "velox/common/base/tests/GTestUtils.h"
 
 using namespace ::testing;
 
 namespace facebook::velox::dwio::common {
 namespace {
+
+class MockWriter : public Writer {
+ public:
+  MockWriter() = default;
+
+  void setStateForTest(State state) {
+    setState(state);
+  }
+
+  void callCheckRunning() const {
+    checkRunning();
+  }
+
+  bool callIsRunning() const {
+    return isRunning();
+  }
+
+  void write(const VectorPtr& /*data*/) override {}
+
+  void flush() override {}
+
+  bool finish() override {
+    return true;
+  }
+
+  void abort() override {}
+
+  std::unique_ptr<FileMetadata> close() override {
+    return nullptr;
+  }
+};
+
 TEST(WriterTest, stateString) {
   ASSERT_EQ(Writer::stateString(Writer::State::kInit), "INIT");
   ASSERT_EQ(Writer::stateString(Writer::State::kRunning), "RUNNING");
@@ -31,5 +65,91 @@ TEST(WriterTest, stateString) {
   VELOX_ASSERT_THROW(
       Writer::stateString(static_cast<Writer::State>(100)), "BAD STATE: 100");
 }
+
+TEST(WriterTest, checkRunning) {
+  MockWriter writer;
+  VELOX_ASSERT_THROW(writer.callCheckRunning(), "Writer is not running: INIT");
+  writer.setStateForTest(Writer::State::kRunning);
+  ASSERT_NO_THROW(writer.callCheckRunning());
+  writer.setStateForTest(Writer::State::kClosed);
+  VELOX_ASSERT_THROW(
+      writer.callCheckRunning(), "Writer is not running: CLOSED");
+}
+
+TEST(WriterTest, stateTransitions) {
+  MockWriter writer;
+  ASSERT_EQ(writer.state(), Writer::State::kInit);
+
+  // Valid transition: kInit -> kRunning
+  writer.setStateForTest(Writer::State::kRunning);
+  ASSERT_EQ(writer.state(), Writer::State::kRunning);
+
+  // Valid transition: kRunning -> kFinishing
+  writer.setStateForTest(Writer::State::kFinishing);
+  ASSERT_EQ(writer.state(), Writer::State::kFinishing);
+
+  // Valid transition: kFinishing -> kFinishing (reentry)
+  writer.setStateForTest(Writer::State::kFinishing);
+  ASSERT_EQ(writer.state(), Writer::State::kFinishing);
+
+  // Valid transition: kFinishing -> kClosed
+  writer.setStateForTest(Writer::State::kClosed);
+  ASSERT_EQ(writer.state(), Writer::State::kClosed);
+}
+
+TEST(WriterTest, invalidStateTransitions) {
+  {
+    MockWriter writer;
+    // Invalid: kInit -> kClosed
+    VELOX_ASSERT_THROW(
+        writer.setStateForTest(Writer::State::kClosed),
+        "Unexpected state transition from INIT to CLOSED");
+  }
+  {
+    MockWriter writer;
+    // Invalid: kInit -> kFinishing
+    VELOX_ASSERT_THROW(
+        writer.setStateForTest(Writer::State::kFinishing),
+        "Unexpected state transition from INIT to FINISHING");
+  }
+  {
+    MockWriter writer;
+    writer.setStateForTest(Writer::State::kRunning);
+    writer.setStateForTest(Writer::State::kClosed);
+    // Invalid: kClosed -> kRunning
+    VELOX_ASSERT_THROW(
+        writer.setStateForTest(Writer::State::kRunning),
+        "Unexpected state transition from CLOSED to RUNNING");
+  }
+}
+
+TEST(WriterTest, stateGetter) {
+  MockWriter writer;
+  ASSERT_EQ(writer.state(), Writer::State::kInit);
+
+  writer.setStateForTest(Writer::State::kRunning);
+  ASSERT_EQ(writer.state(), Writer::State::kRunning);
+
+  writer.setStateForTest(Writer::State::kFinishing);
+  ASSERT_EQ(writer.state(), Writer::State::kFinishing);
+
+  writer.setStateForTest(Writer::State::kClosed);
+  ASSERT_EQ(writer.state(), Writer::State::kClosed);
+}
+
+TEST(WriterTest, isRunning) {
+  MockWriter writer;
+  ASSERT_FALSE(writer.callIsRunning());
+
+  writer.setStateForTest(Writer::State::kRunning);
+  ASSERT_TRUE(writer.callIsRunning());
+
+  writer.setStateForTest(Writer::State::kFinishing);
+  ASSERT_FALSE(writer.callIsRunning());
+
+  writer.setStateForTest(Writer::State::kClosed);
+  ASSERT_FALSE(writer.callIsRunning());
+}
+
 } // namespace
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/tests/utils/BatchMaker.cpp b/velox/dwio/common/tests/utils/BatchMaker.cpp
index 435e32c39ba..a422c52e00e 100644
--- a/velox/dwio/common/tests/utils/BatchMaker.cpp
+++ b/velox/dwio/common/tests/utils/BatchMaker.cpp
@@ -141,6 +141,18 @@ VectorPtr BatchMaker::createVector<TypeKind::BIGINT>(
     MemoryPool& pool,
     std::mt19937& gen,
     std::function<bool(vector_size_t /*index*/)> isNullAt) {
+  if (type->isTime()) {
+    const bool isMicros = type->equivalent(*TIME_MICRO_UTC());
+    // TIME is milliseconds since midnight; TIME_MICRO_UTC is microseconds.
+    const int64_t maxValue = isMicros ? 86'400'000'000LL : 86'400'000LL;
+    return createScalar<int64_t>(
+        size,
+        gen,
+        [&gen, maxValue]() { return Random::rand64(0, maxValue, gen); },
+        pool,
+        isNullAt,
+        type);
+  }
   return createScalar<int64_t>(
       size,
       gen,
diff --git a/velox/dwio/common/tests/utils/CMakeLists.txt b/velox/dwio/common/tests/utils/CMakeLists.txt
index bbbd5c2ebe5..4ed4335c238 100644
--- a/velox/dwio/common/tests/utils/CMakeLists.txt
+++ b/velox/dwio/common/tests/utils/CMakeLists.txt
@@ -21,6 +21,15 @@ add_library(
   UnitLoaderTestTools.cpp
   E2EFilterTestBase.cpp
 )
+velox_add_test_headers(
+  velox_dwio_common_test_utils
+  BatchMaker.h
+  DataFiles.h
+  DataSetBuilder.h
+  E2EFilterTestBase.h
+  FilterGenerator.h
+  UnitLoaderTestTools.h
+)
 
 target_link_libraries(
   velox_dwio_common_test_utils
@@ -44,3 +53,5 @@ target_link_libraries(
 if(CMAKE_COMPILER_IS_GNUCC AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 9)
   target_link_libraries(velox_dwio_common_test_utils stdc++fs)
 endif()
+
+velox_add_library(velox_lib_test_map_builder INTERFACE HEADERS MapBuilder.h)
diff --git a/velox/dwio/common/tests/utils/DataSetBuilder.cpp b/velox/dwio/common/tests/utils/DataSetBuilder.cpp
index 85c508dd0a3..63c1fdc69e8 100644
--- a/velox/dwio/common/tests/utils/DataSetBuilder.cpp
+++ b/velox/dwio/common/tests/utils/DataSetBuilder.cpp
@@ -47,8 +47,9 @@ DataSetBuilder& DataSetBuilder::makeDataset(
 
   for (size_t i = 0; i < batchCount; ++i) {
     if (withRecursiveNulls) {
-      batches_->push_back(std::static_pointer_cast<RowVector>(
-          BatchMaker::createBatch(rowType, numRows, pool_, nullptr, i)));
+      batches_->push_back(
+          std::static_pointer_cast<RowVector>(
+              BatchMaker::createBatch(rowType, numRows, pool_, nullptr, i)));
     } else {
       batches_->push_back(
           std::static_pointer_cast<RowVector>(BatchMaker::createBatch(
@@ -201,13 +202,13 @@ DataSetBuilder& DataSetBuilder::withStringDistributionForField(
 DataSetBuilder& DataSetBuilder::withUniqueStringsForField(
     const Subfield& field) {
   for (RowVectorPtr batch : *batches_) {
-    auto strings =
+    auto* strings =
         getChildBySubfield(batch.get(), field)->as<FlatVector<StringView>>();
     for (auto row = 0; row < strings->size(); ++row) {
       if (strings->isNullAt(row)) {
         continue;
       }
-      std::string value = strings->valueAt(row);
+      auto value = std::string(strings->valueAt(row));
       value += fmt::format("{}", row);
       strings->set(row, StringView(value));
     }
@@ -282,7 +283,7 @@ DataSetBuilder& DataSetBuilder::makeMapStringValues(
             continue;
           }
           if (!keys->isNullAt(i) && i % 3 == 0) {
-            std::string str = keys->valueAt(i);
+            auto str = std::string(keys->valueAt(i));
             str += "----123456789";
             keys->set(i, StringView(str));
           }
@@ -304,7 +305,7 @@ DataSetBuilder& DataSetBuilder::makeMapStringValues(
             continue;
           }
           if (!values->isNullAt(i) && i % 3 == 0) {
-            std::string str = values->valueAt(i);
+            auto str = std::string(values->valueAt(i));
             str += "----123456789";
             values->set(i, StringView(str));
           }
diff --git a/velox/dwio/common/tests/utils/E2EFilterTestBase.cpp b/velox/dwio/common/tests/utils/E2EFilterTestBase.cpp
index f7656fbd08c..d5d28c9a854 100644
--- a/velox/dwio/common/tests/utils/E2EFilterTestBase.cpp
+++ b/velox/dwio/common/tests/utils/E2EFilterTestBase.cpp
@@ -16,8 +16,12 @@
 
 #include "velox/dwio/common/tests/utils/E2EFilterTestBase.h"
 
+#include <fmt/format.h>
+#include <random>
+
 #include "velox/dwio/common/tests/utils/DataSetBuilder.h"
 #include "velox/expression/Expr.h"
+#include "velox/expression/ExprConstants.h"
 #include "velox/expression/ExprToSubfieldFilter.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 #include "velox/parse/Expressions.h"
@@ -44,10 +48,46 @@ using dwio::common::InMemoryReadFile;
 using dwio::common::MemorySink;
 using velox::common::Subfield;
 
+// Helper to generate monotonic unique values for a given scalar type.
+// Generates values starting from startValue, incrementing by 1 for each row.
+// For ascending order, values go from startValue to startValue + numRows - 1.
+// The globalRowOffset is used to compute the correct value when generating
+// data across multiple batches.
+template <typename T>
+VectorPtr generateStrictSortedVectorImpl(
+    size_t numRows,
+    size_t rowOffset,
+    size_t totalRows,
+    int64_t startValue,
+    bool ascending,
+    memory::MemoryPool* pool) {
+  auto flatVector = BaseVector::create<FlatVector<T>>(
+      CppToType<T>::create(), static_cast<vector_size_t>(numRows), pool);
+  for (vector_size_t i = 0; i < static_cast<vector_size_t>(numRows); ++i) {
+    const size_t nextRowOffset = rowOffset + i;
+    // For ascending: value increases with nextRowOffset
+    // For descending: value decreases (totalRows - 1 - nextRowOffset)
+    const size_t adjustedRowOffset =
+        ascending ? nextRowOffset : (totalRows - 1 - nextRowOffset);
+    if constexpr (std::is_same_v<T, bool>) {
+      // For bool, we can only have 2 unique values, so this type is limited.
+      flatVector->set(i, adjustedRowOffset % 2 == 1);
+    } else if constexpr (std::is_same_v<T, Timestamp>) {
+      flatVector->set(
+          i,
+          Timestamp(startValue + static_cast<int64_t>(adjustedRowOffset), 0));
+    } else {
+      flatVector->set(i, static_cast<T>(startValue + adjustedRowOffset));
+    }
+  }
+  return flatVector;
+}
+
 std::vector<RowVectorPtr> E2EFilterTestBase::makeDataset(
     std::function<void()> customize,
     bool forRowGroupSkip,
-    bool withRecursiveNulls) {
+    bool withRecursiveNulls,
+    const std::vector<std::string>& indexColumns) {
   if (!dataSetBuilder_) {
     dataSetBuilder_ = std::make_unique<DataSetBuilder>(*leafPool_, 0);
   }
@@ -64,9 +104,308 @@ std::vector<RowVectorPtr> E2EFilterTestBase::makeDataset(
   }
 
   std::vector<RowVectorPtr> batches = *dataSetBuilder_->build();
+
+  // Replace index columns with monotonically increasing unique values.
+  if (!indexColumns.empty()) {
+    batches = replaceIndexColumnsWithStrictlySortedData(batches, indexColumns);
+  }
+
   return batches;
 }
 
+std::vector<RowVectorPtr>
+E2EFilterTestBase::replaceIndexColumnsWithStrictlySortedData(
+    const std::vector<RowVectorPtr>& batches,
+    const std::vector<std::string>& indexColumns) {
+  if (batches.empty() || indexColumns.empty()) {
+    return batches;
+  }
+
+  const auto& rowType = batches[0]->type()->asRow();
+
+  // Build index column indices.
+  std::vector<column_index_t> indexColIndices;
+  for (const auto& colName : indexColumns) {
+    auto idx = rowType.getChildIdxIfExists(colName);
+    VELOX_CHECK(
+        idx.has_value(), "Index column '{}' not found in schema", colName);
+    indexColIndices.push_back(idx.value());
+  }
+
+  // Calculate total rows across all batches.
+  size_t totalRows = 0;
+  for (const auto& batch : batches) {
+    totalRows += batch->size();
+  }
+
+  std::vector<RowVectorPtr> result;
+  result.reserve(batches.size());
+  size_t rowOffset = 0;
+
+  for (const auto& batch : batches) {
+    const size_t batchSize = batch->size();
+    std::vector<VectorPtr> newChildren;
+    newChildren.reserve(rowType.size());
+
+    for (size_t colIdx = 0; colIdx < rowType.size(); ++colIdx) {
+      const bool isIndexColumn =
+          std::find(indexColIndices.begin(), indexColIndices.end(), colIdx) !=
+          indexColIndices.end();
+
+      if (isIndexColumn) {
+        // Generate monotonically increasing unique values for index columns.
+        newChildren.push_back(generateStrictSortedVector(
+            rowType.childAt(colIdx),
+            batchSize,
+            rowOffset,
+            /*startValue=*/0,
+            totalRows,
+            /*ascending=*/true,
+            leafPool_.get()));
+      } else {
+        // Keep the original data for non-index columns.
+        newChildren.push_back(batch->childAt(colIdx));
+      }
+    }
+
+    result.push_back(
+        std::make_shared<RowVector>(
+            leafPool_.get(),
+            batch->type(),
+            nullptr,
+            batchSize,
+            std::move(newChildren)));
+    rowOffset += batchSize;
+  }
+
+  return result;
+}
+
+VectorPtr E2EFilterTestBase::generateStrictSortedVector(
+    const TypePtr& type,
+    size_t size,
+    size_t globalRowOffset,
+    int64_t startValue,
+    size_t totalRows,
+    bool ascending,
+    memory::MemoryPool* pool) {
+  switch (type->kind()) {
+    case TypeKind::BOOLEAN:
+      return generateStrictSortedVectorImpl<bool>(
+          size, globalRowOffset, totalRows, startValue, ascending, pool);
+    case TypeKind::TINYINT:
+      return generateStrictSortedVectorImpl<int8_t>(
+          size, globalRowOffset, totalRows, startValue, ascending, pool);
+    case TypeKind::SMALLINT:
+      return generateStrictSortedVectorImpl<int16_t>(
+          size, globalRowOffset, totalRows, startValue, ascending, pool);
+    case TypeKind::INTEGER:
+      return generateStrictSortedVectorImpl<int32_t>(
+          size, globalRowOffset, totalRows, startValue, ascending, pool);
+    case TypeKind::BIGINT:
+      return generateStrictSortedVectorImpl<int64_t>(
+          size, globalRowOffset, totalRows, startValue, ascending, pool);
+    case TypeKind::REAL:
+      return generateStrictSortedVectorImpl<float>(
+          size, globalRowOffset, totalRows, startValue, ascending, pool);
+    case TypeKind::DOUBLE:
+      return generateStrictSortedVectorImpl<double>(
+          size, globalRowOffset, totalRows, startValue, ascending, pool);
+    case TypeKind::TIMESTAMP:
+      return generateStrictSortedVectorImpl<Timestamp>(
+          size, globalRowOffset, totalRows, startValue, ascending, pool);
+    case TypeKind::VARCHAR: {
+      // Generate string keys like "key_00000000", "key_00000001", etc.
+      auto flatVector = BaseVector::create<FlatVector<StringView>>(
+          VARCHAR(), static_cast<vector_size_t>(size), pool);
+      for (vector_size_t i = 0; i < static_cast<vector_size_t>(size); ++i) {
+        const size_t globalIdx = globalRowOffset + i;
+        const size_t adjustedIdx =
+            ascending ? globalIdx : (totalRows - 1 - globalIdx);
+        auto str = fmt::format("key_{:08d}", startValue + adjustedIdx);
+        flatVector->set(i, StringView(str));
+      }
+      return flatVector;
+    }
+    case TypeKind::VARBINARY:
+    case TypeKind::HUGEINT:
+    case TypeKind::ARRAY:
+    case TypeKind::MAP:
+    case TypeKind::ROW:
+    case TypeKind::UNKNOWN:
+    case TypeKind::FUNCTION:
+    case TypeKind::OPAQUE:
+    case TypeKind::INVALID:
+      VELOX_UNREACHABLE(
+          "Unsupported type for generateStrictSortedVector: {}",
+          type->toString());
+  }
+  VELOX_UNREACHABLE();
+}
+
+namespace {
+
+// Computes which unique key a given row belongs to when generating data with
+// duplicates. Each unique key is repeated 1-3 times (randomly determined).
+//
+// The function simulates generating keys from the beginning (row 0) and counts
+// how many unique keys we've passed to reach the given globalRow.
+//
+// Example with seed=42 (which generates duplicate counts: 2, 1, 2, 3, 1, ...):
+//   Row 0 -> Key 0 (first of 2 duplicates)
+//   Row 1 -> Key 0 (second of 2 duplicates)
+//   Row 2 -> Key 1 (first of 1 duplicate, i.e., no duplicate)
+//   Row 3 -> Key 2 (first of 2 duplicates)
+//   Row 4 -> Key 2 (second of 2 duplicates)
+//   Row 5 -> Key 3 (first of 3 duplicates)
+//   Row 6 -> Key 3 (second of 3 duplicates)
+//   Row 7 -> Key 3 (third of 3 duplicates)
+//   Row 8 -> Key 4 (first of 1 duplicate)
+//   ...
+//
+// @param globalRow The row index (0-based) to find the key for
+// @param seed Random seed for reproducibility (default 42)
+// @return The unique key index that this row maps to
+size_t computeUniqueKeyIndex(size_t globalRow, uint32_t seed = 42) {
+  std::mt19937 rng(seed);
+  std::uniform_int_distribution<int> dupDist(1, 3);
+
+  size_t currentRow = 0;
+  size_t uniqueKeyIdx = 0;
+  while (currentRow <= globalRow) {
+    int duplicates = dupDist(rng);
+    if (currentRow + duplicates > globalRow) {
+      return uniqueKeyIdx;
+    }
+    currentRow += duplicates;
+    ++uniqueKeyIdx;
+  }
+  return uniqueKeyIdx;
+}
+
+// Computes the largest unique key index that would be assigned to any row
+// in a dataset of totalRows.
+//
+// This is needed for descending order: to generate descending keys, we need
+// to know the maximum key index so we can reverse the sequence
+// (maxKey - currentKey gives us the descending value).
+//
+// Example: For totalRows=9 with the sequence above:
+//   Row 8 (the last row) maps to Key 4
+//   So computeMaxUniqueKeyIndex(9) returns 4
+//
+// @param totalRows Total number of rows in the dataset
+// @param seed Random seed (must match computeUniqueKeyIndex for consistency)
+// @return The maximum unique key index
+size_t computeMaxUniqueKeyIndex(size_t totalRows, uint32_t seed = 42) {
+  if (totalRows == 0) {
+    return 0;
+  }
+  return computeUniqueKeyIndex(totalRows - 1, seed);
+}
+
+// Generates values with duplicates (1-3 copies per unique key).
+template <typename T>
+VectorPtr generateSortedVectorImpl(
+    size_t numRows,
+    size_t rowOffset,
+    size_t totalRows,
+    int64_t startValue,
+    bool ascending,
+    memory::MemoryPool* pool) {
+  auto flatVector = BaseVector::create<FlatVector<T>>(
+      CppToType<T>::create(), static_cast<vector_size_t>(numRows), pool);
+
+  // For descending order, we need to know the max unique key index
+  const size_t maxUniqueKeyIdx =
+      ascending ? 0 : computeMaxUniqueKeyIndex(totalRows);
+
+  for (vector_size_t i = 0; i < static_cast<vector_size_t>(numRows); ++i) {
+    const size_t globalRow = rowOffset + i;
+    // Get the unique key index for this row position
+    const size_t uniqueKeyIdx = computeUniqueKeyIndex(globalRow);
+    // For descending order, reverse the key index relative to max
+    const size_t adjustedKeyIdx =
+        ascending ? uniqueKeyIdx : (maxUniqueKeyIdx - uniqueKeyIdx);
+
+    if constexpr (std::is_same_v<T, bool>) {
+      flatVector->set(i, adjustedKeyIdx % 2 == 1);
+    } else if constexpr (std::is_same_v<T, Timestamp>) {
+      flatVector->set(
+          i, Timestamp(startValue + static_cast<int64_t>(adjustedKeyIdx), 0));
+    } else {
+      flatVector->set(i, static_cast<T>(startValue + adjustedKeyIdx));
+    }
+  }
+  return flatVector;
+}
+
+} // namespace
+
+VectorPtr E2EFilterTestBase::generateSortedVector(
+    const TypePtr& type,
+    size_t size,
+    size_t globalRowOffset,
+    int64_t startValue,
+    size_t totalRows,
+    bool ascending,
+    memory::MemoryPool* pool) {
+  switch (type->kind()) {
+    case TypeKind::BOOLEAN:
+      return generateSortedVectorImpl<bool>(
+          size, globalRowOffset, totalRows, startValue, ascending, pool);
+    case TypeKind::TINYINT:
+      return generateSortedVectorImpl<int8_t>(
+          size, globalRowOffset, totalRows, startValue, ascending, pool);
+    case TypeKind::SMALLINT:
+      return generateSortedVectorImpl<int16_t>(
+          size, globalRowOffset, totalRows, startValue, ascending, pool);
+    case TypeKind::INTEGER:
+      return generateSortedVectorImpl<int32_t>(
+          size, globalRowOffset, totalRows, startValue, ascending, pool);
+    case TypeKind::BIGINT:
+      return generateSortedVectorImpl<int64_t>(
+          size, globalRowOffset, totalRows, startValue, ascending, pool);
+    case TypeKind::REAL:
+      return generateSortedVectorImpl<float>(
+          size, globalRowOffset, totalRows, startValue, ascending, pool);
+    case TypeKind::DOUBLE:
+      return generateSortedVectorImpl<double>(
+          size, globalRowOffset, totalRows, startValue, ascending, pool);
+    case TypeKind::TIMESTAMP:
+      return generateSortedVectorImpl<Timestamp>(
+          size, globalRowOffset, totalRows, startValue, ascending, pool);
+    case TypeKind::VARCHAR: {
+      // Generate string keys with duplicates
+      auto flatVector = BaseVector::create<FlatVector<StringView>>(
+          VARCHAR(), static_cast<vector_size_t>(size), pool);
+      const size_t maxUniqueKeyIdx =
+          ascending ? 0 : computeMaxUniqueKeyIndex(totalRows);
+      for (vector_size_t i = 0; i < static_cast<vector_size_t>(size); ++i) {
+        const size_t globalRow = globalRowOffset + i;
+        const size_t uniqueKeyIdx = computeUniqueKeyIndex(globalRow);
+        const size_t adjustedIdx =
+            ascending ? uniqueKeyIdx : (maxUniqueKeyIdx - uniqueKeyIdx);
+        auto str = fmt::format("key_{:08d}", startValue + adjustedIdx);
+        flatVector->set(i, StringView(str));
+      }
+      return flatVector;
+    }
+    case TypeKind::VARBINARY:
+    case TypeKind::HUGEINT:
+    case TypeKind::ARRAY:
+    case TypeKind::MAP:
+    case TypeKind::ROW:
+    case TypeKind::UNKNOWN:
+    case TypeKind::FUNCTION:
+    case TypeKind::OPAQUE:
+    case TypeKind::INVALID:
+      VELOX_UNREACHABLE(
+          "Unsupported type for generateSortedVector: {}", type->toString());
+  }
+  VELOX_UNREACHABLE();
+}
+
 void E2EFilterTestBase::makeAllNulls(const std::string& fieldName) {
   dataSetBuilder_->withAllNullsForField(Subfield(fieldName));
 }
@@ -95,6 +434,8 @@ void E2EFilterTestBase::readWithoutFilter(
     uint64_t& time) {
   SCOPED_TRACE("Read without filter");
   dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   dwio::common::RowReaderOptions rowReaderOpts;
   auto input = std::make_unique<BufferedInput>(
       std::make_shared<InMemoryReadFile>(sinkData_), readerOpts.memoryPool());
@@ -149,6 +490,8 @@ void E2EFilterTestBase::readWithFilter(
     bool skipCheck) {
   SCOPED_TRACE("Read with filter");
   dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   dwio::common::RowReaderOptions rowReaderOpts;
   auto input = std::make_unique<BufferedInput>(
       std::make_shared<InMemoryReadFile>(sinkData_), readerOpts.memoryPool());
@@ -167,21 +510,21 @@ void E2EFilterTestBase::readWithFilter(
   auto resultBatch = BaseVector::create(rowType_, 1, leafPool_.get());
   resetReadBatchSizes();
   int32_t clearCnt = 0;
-  auto deletedRowsIter = mutationSpec.deletedRows.begin();
+  auto deletedRowsIter = mutationSpec.deletedRows.cbegin();
   while (true) {
     {
       MicrosecondTimer timer(&time);
       if (++clearCnt % 17 == 0) {
         rowReader->resetFilterCaches();
       }
-      auto nextRowNumber = rowReader->nextRowNumber();
+      const auto nextRowNumber = rowReader->nextRowNumber();
       if (nextRowNumber == RowReader::kAtEnd) {
         break;
       }
       auto readSize = rowReader->nextReadSize(nextReadBatchSize());
       std::vector<uint64_t> isDeleted(bits::nwords(readSize));
       bool haveDelete = false;
-      for (; deletedRowsIter != mutationSpec.deletedRows.end();
+      for (; deletedRowsIter != mutationSpec.deletedRows.cend();
            ++deletedRowsIter) {
         auto i = *deletedRowsIter;
         if (i < nextRowNumber) {
@@ -294,11 +637,13 @@ void E2EFilterTestBase::testReadWithFilterLazy(
 void E2EFilterTestBase::testFilterSpecs(
     const std::vector<RowVectorPtr>& batches,
     const std::vector<FilterSpec>& filterSpecs) {
+  SCOPED_TRACE(FilterGenerator::specsToString(filterSpecs));
   MutationSpec mutations;
   std::vector<uint64_t> hitRows;
   auto filters = filterGenerator_->makeSubfieldFilters(
       filterSpecs, batches, &mutations, hitRows);
   auto spec = filterGenerator_->makeScanSpec(std::move(filters));
+  SCOPED_TRACE(spec->toString());
   uint64_t timeWithFilter = 0;
   readWithFilter(spec, mutations, batches, hitRows, timeWithFilter, false);
 
@@ -405,18 +750,19 @@ void E2EFilterTestBase::testScenario(
     bool wrapInStruct,
     const std::vector<std::string>& filterable,
     int32_t numCombinations,
-    bool withRecursiveNulls) {
+    bool withRecursiveNulls,
+    const std::vector<std::string>& indexColumns) {
   rowType_ = DataSetBuilder::makeRowType(columns, wrapInStruct);
   filterGenerator_ = std::make_unique<FilterGenerator>(rowType_, seed_);
-
-  auto batches = makeDataset(customize, false, withRecursiveNulls);
-  writeToMemory(rowType_, batches, false);
+  auto batches =
+      makeDataset(customize, false, withRecursiveNulls, indexColumns);
+  writeToMemory(rowType_, batches, false, indexColumns);
   testNoRowGroupSkip(batches, filterable, numCombinations);
   testPruningWithFilter(batches, filterable);
 
   if (testRowGroupSkip_) {
-    batches = makeDataset(customize, true, withRecursiveNulls);
-    writeToMemory(rowType_, batches, true);
+    batches = makeDataset(customize, true, withRecursiveNulls, indexColumns);
+    writeToMemory(rowType_, batches, true, indexColumns);
     testRowGroupSkip(batches, filterable);
   }
 }
@@ -484,6 +830,12 @@ void E2EFilterTestBase::testRunLengthDictionaryScenario(
   }
 }
 
+namespace {
+core::ExprPtr parseExpr(const std::string& text) {
+  return parse::DuckSqlExpressionsParser().parseExpr(text);
+}
+} // namespace
+
 void E2EFilterTestBase::testMetadataFilterImpl(
     const std::vector<RowVectorPtr>& batches,
     common::Subfield filterField,
@@ -491,15 +843,31 @@ void E2EFilterTestBase::testMetadataFilterImpl(
     core::ExpressionEvaluator* evaluator,
     const std::string& remainingFilter,
     std::function<bool(int64_t, int64_t)> validationFilter) {
-  SCOPED_TRACE(fmt::format("remainingFilter={}", remainingFilter));
+  SCOPED_TRACE(fmt::format("remainingFilter='{}'", remainingFilter));
+  auto untypedExpr = parseExpr(remainingFilter);
+  auto typedExpr = core::Expressions::inferTypes(
+      untypedExpr, batches[0]->type(), leafPool_.get());
+  testMetadataFilterImpl(
+      batches,
+      std::move(filterField),
+      std::move(filter),
+      evaluator,
+      std::move(typedExpr),
+      std::move(validationFilter));
+}
+
+void E2EFilterTestBase::testMetadataFilterImpl(
+    const std::vector<RowVectorPtr>& batches,
+    common::Subfield filterField,
+    std::unique_ptr<common::Filter> filter,
+    core::ExpressionEvaluator* evaluator,
+    core::TypedExprPtr typedExpr,
+    std::function<bool(int64_t, int64_t)> validationFilter) {
   auto spec = std::make_shared<common::ScanSpec>("<root>");
   if (filter) {
     spec->getOrCreateChild(std::move(filterField))
         ->setFilter(std::move(filter));
   }
-  auto untypedExpr = parse::parseExpr(remainingFilter, {});
-  auto typedExpr = core::Expressions::inferTypes(
-      untypedExpr, batches[0]->type(), leafPool_.get());
   auto metadataFilter =
       std::make_shared<MetadataFilter>(*spec, *typedExpr, evaluator);
   auto specA = spec->getOrCreateChild(common::Subfield("a"));
@@ -512,6 +880,8 @@ void E2EFilterTestBase::testMetadataFilterImpl(
   specC->setProjectOut(true);
   specC->setChannel(0);
   ReaderOptions readerOpts{leafPool_.get()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   RowReaderOptions rowReaderOpts;
   auto input = std::make_unique<BufferedInput>(
       std::make_shared<InMemoryReadFile>(sinkData_), readerOpts.memoryPool());
@@ -580,12 +950,13 @@ void E2EFilterTestBase::testMetadataFilter() {
         nullptr,
         c->size(),
         std::vector<VectorPtr>({c}));
-    batches.push_back(std::make_shared<RowVector>(
-        leafPool_.get(),
-        ROW({{"a", a->type()}, {"b", b->type()}}),
-        nullptr,
-        a->size(),
-        std::vector<VectorPtr>({a, b})));
+    batches.push_back(
+        std::make_shared<RowVector>(
+            leafPool_.get(),
+            ROW({{"a", a->type()}, {"b", b->type()}}),
+            nullptr,
+            a->size(),
+            std::vector<VectorPtr>({a, b})));
   }
   writeToMemory(batches[0]->type(), batches, false);
 
@@ -621,6 +992,56 @@ void E2EFilterTestBase::testMetadataFilter() {
       [](int64_t a, int64_t) {
         return !!(a == 2 || a == 3 || a == 5 || a == 7);
       });
+  {
+    SCOPED_TRACE("remainingFilter='a == 1 or a == 3 or a == 8'");
+    auto typedExpr1 = core::Expressions::inferTypes(
+        parseExpr("a == 1"), batches[0]->type(), leafPool_.get());
+    auto typedExpr2 = core::Expressions::inferTypes(
+        parseExpr("a == 3"), batches[0]->type(), leafPool_.get());
+    auto typedExpr3 = core::Expressions::inferTypes(
+        parseExpr("a == 8"), batches[0]->type(), leafPool_.get());
+
+    auto typedExpr = std::make_shared<core::CallTypedExpr>(
+        velox::BOOLEAN(),
+        std::vector{
+            std::move(typedExpr1),
+            std::move(typedExpr2),
+            std::move(typedExpr3),
+        },
+        expression::kOr);
+    testMetadataFilterImpl(
+        batches,
+        common::Subfield("a"),
+        nullptr,
+        &evaluator,
+        std::move(typedExpr),
+        [](int64_t a, int64_t) { return a == 1 || a == 3 || a == 8; });
+  }
+  {
+    SCOPED_TRACE("remainingFilter='a >= 1 and a <= 100 and a == 8'");
+    auto typedExpr1 = core::Expressions::inferTypes(
+        parseExpr("a >= 1"), batches[0]->type(), leafPool_.get());
+    auto typedExpr2 = core::Expressions::inferTypes(
+        parseExpr("a <= 100"), batches[0]->type(), leafPool_.get());
+    auto typedExpr3 = core::Expressions::inferTypes(
+        parseExpr("b.c != 8"), batches[0]->type(), leafPool_.get());
+
+    auto typedExpr = std::make_shared<core::CallTypedExpr>(
+        velox::BOOLEAN(),
+        std::vector{
+            std::move(typedExpr1),
+            std::move(typedExpr2),
+            std::move(typedExpr3),
+        },
+        expression::kAnd);
+    testMetadataFilterImpl(
+        batches,
+        common::Subfield("a"),
+        nullptr,
+        &evaluator,
+        std::move(typedExpr),
+        [](int64_t a, int64_t c) { return a >= 1 && a <= 100 && c != 8; });
+  }
 
   {
     SCOPED_TRACE("Values not unique in row group");
@@ -645,7 +1066,7 @@ void E2EFilterTestBase::testMetadataFilter() {
     writeToMemory(batches[0]->type(), batches, false);
     auto spec = std::make_shared<common::ScanSpec>("<root>");
     spec->addAllChildFields(*batches[0]->type());
-    auto untypedExpr = parse::parseExpr("a = 1 or b + c = 2", {});
+    auto untypedExpr = parseExpr("a = 1 or b + c = 2");
     auto typedExpr = core::Expressions::inferTypes(
         untypedExpr, batches[0]->type(), leafPool_.get());
     auto metadataFilter =
@@ -724,6 +1145,8 @@ void E2EFilterTestBase::testSubfieldsPruning() {
   specF->childByName(common::ScanSpec::kArrayElementsFieldName)
       ->setFilter(common::createBigintValues({0, 2, 4}, false));
   ReaderOptions readerOpts{leafPool_.get()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   RowReaderOptions rowReaderOpts;
   auto input = std::make_unique<BufferedInput>(
       std::make_shared<InMemoryReadFile>(sinkData_), readerOpts.memoryPool());
@@ -814,6 +1237,8 @@ void E2EFilterTestBase::testMutationCornerCases() {
   auto& rowType = batches[0]->type();
   writeToMemory(rowType, batches, false);
   ReaderOptions readerOpts{leafPool_.get()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   auto input = std::make_unique<BufferedInput>(
       std::make_shared<InMemoryReadFile>(sinkData_), readerOpts.memoryPool());
   auto reader = makeReader(readerOpts, std::move(input));
diff --git a/velox/dwio/common/tests/utils/E2EFilterTestBase.h b/velox/dwio/common/tests/utils/E2EFilterTestBase.h
index 16d30e36a7b..1f97b09a6d9 100644
--- a/velox/dwio/common/tests/utils/E2EFilterTestBase.h
+++ b/velox/dwio/common/tests/utils/E2EFilterTestBase.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include "velox/common/io/IoStatistics.h"
 #include "velox/common/testutil/RandomSeed.h"
 #include "velox/common/time/Timer.h"
 #include "velox/dwio/common/BufferedInput.h"
@@ -64,7 +65,7 @@ class TestingHook : public ValueHook {
     }
   }
 
-  void addValue(vector_size_t row, folly::StringPiece value) override {
+  void addValue(vector_size_t row, std::string_view value) override {
     if constexpr (std::is_same_v<T, StringView>) {
       result_->set(row, StringView(value));
     } else {
@@ -96,6 +97,45 @@ class OwnershipChecker {
 };
 
 class E2EFilterTestBase : public testing::Test {
+ public:
+  // Generates a vector with monotonically increasing/decreasing unique values
+  // for the given scalar type. Supports TINYINT, SMALLINT, INTEGER, BIGINT,
+  // REAL, DOUBLE, TIMESTAMP, and VARCHAR.
+  // @param type The scalar type of the vector to generate.
+  // @param size The number of rows in this batch.
+  // @param globalRowOffset The starting row offset across all batches.
+  // @param startValue The starting value for the sequence.
+  // @param totalRows The total number of rows across all batches.
+  // @param ascending If true, values increase; if false, values decrease.
+  // @param pool The memory pool to allocate the vector from.
+  static VectorPtr generateStrictSortedVector(
+      const TypePtr& type,
+      size_t size,
+      size_t globalRowOffset,
+      int64_t startValue,
+      size_t totalRows,
+      bool ascending,
+      memory::MemoryPool* pool);
+
+  // Generates a vector with monotonically increasing/decreasing values that
+  // may contain duplicates (non-strictly sorted). Each unique value is
+  // repeated 1-3 times randomly.
+  // @param type The scalar type of the vector to generate.
+  // @param size The number of rows in this batch.
+  // @param globalRowOffset The starting row offset across all batches.
+  // @param startValue The starting value for the sequence.
+  // @param totalRows The total number of rows across all batches.
+  // @param ascending If true, values increase; if false, values decrease.
+  // @param pool The memory pool to allocate the vector from.
+  static VectorPtr generateSortedVector(
+      const TypePtr& type,
+      size_t size,
+      size_t globalRowOffset,
+      int64_t startValue,
+      size_t totalRows,
+      bool ascending,
+      memory::MemoryPool* pool);
+
  protected:
   static constexpr int32_t kRowsInGroup = 10'000;
 
@@ -118,7 +158,15 @@ class E2EFilterTestBase : public testing::Test {
   std::vector<RowVectorPtr> makeDataset(
       std::function<void()> customize,
       bool forRowGroupSkip,
-      bool withRecursiveNulls);
+      bool withRecursiveNulls,
+      const std::vector<std::string>& indexColumns = {});
+
+  // Replaces index columns with monotonically increasing unique values.
+  // This ensures the data has sorted, unique keys for index testing
+  // without needing to sort and deduplicate random data.
+  std::vector<RowVectorPtr> replaceIndexColumnsWithStrictlySortedData(
+      const std::vector<RowVectorPtr>& batches,
+      const std::vector<std::string>& indexColumns);
 
   void makeAllNulls(const std::string& fieldName);
 
@@ -208,7 +256,8 @@ class E2EFilterTestBase : public testing::Test {
   virtual void writeToMemory(
       const TypePtr& type,
       const std::vector<RowVectorPtr>& batches,
-      bool forRowGroupSkip) = 0;
+      bool forRowGroupSkip,
+      const std::vector<std::string>& indexColumns = {}) = 0;
 
   virtual std::unique_ptr<dwio::common::Reader> makeReader(
       const dwio::common::ReaderOptions& opts,
@@ -315,7 +364,8 @@ class E2EFilterTestBase : public testing::Test {
       bool wrapInStruct,
       const std::vector<std::string>& filterable,
       int32_t numCombinations,
-      bool withRecursiveNulls = true);
+      bool withRecursiveNulls = true,
+      const std::vector<std::string>& indexColumns = {});
 
   void testRunLengthDictionaryScenario(
       const std::string& columns,
@@ -336,6 +386,14 @@ class E2EFilterTestBase : public testing::Test {
       const std::string& remainingFilter,
       std::function<bool(int64_t a, int64_t c)> validationFilter);
 
+  void testMetadataFilterImpl(
+      const std::vector<RowVectorPtr>& batches,
+      common::Subfield filterField,
+      std::unique_ptr<common::Filter> filter,
+      core::ExpressionEvaluator* evaluator,
+      core::TypedExprPtr typedExpr,
+      std::function<bool(int64_t, int64_t)> validationFilter);
+
  protected:
   void testMetadataFilter();
 
@@ -356,13 +414,17 @@ class E2EFilterTestBase : public testing::Test {
   }
 
   const size_t kBatchCount = 4;
-  // kBatchSize must be greater than 10000 for RowGroup skipping test
+  // kBatchSize must be greater than 10'000 for RowGroup skipping test
   const size_t kBatchSize = 25'000;
 
   std::unique_ptr<test::DataSetBuilder> dataSetBuilder_;
   std::unique_ptr<common::FilterGenerator> filterGenerator_;
   std::shared_ptr<memory::MemoryPool> rootPool_;
   std::shared_ptr<memory::MemoryPool> leafPool_;
+  std::shared_ptr<velox::io::IoStatistics> dataIoStats_ =
+      std::make_shared<velox::io::IoStatistics>();
+  std::shared_ptr<velox::io::IoStatistics> metadataIoStats_ =
+      std::make_shared<velox::io::IoStatistics>();
   std::shared_ptr<const RowType> rowType_;
   std::string sinkData_;
   bool useVInts_ = true;
diff --git a/velox/dwio/common/tests/utils/FilterGenerator.cpp b/velox/dwio/common/tests/utils/FilterGenerator.cpp
index 52cd41fc2b0..420c718c7d7 100644
--- a/velox/dwio/common/tests/utils/FilterGenerator.cpp
+++ b/velox/dwio/common/tests/utils/FilterGenerator.cpp
@@ -319,14 +319,7 @@ std::string FilterGenerator::specsToString(
       out << ", ";
     }
     first = false;
-    out << spec.field;
-    if (spec.filterKind == FilterKind::kIsNull) {
-      out << " is null";
-    } else if (spec.filterKind == FilterKind::kIsNotNull) {
-      out << " is not null";
-    } else {
-      out << ":" << spec.selectPct << "," << spec.startPct << " ";
-    }
+    out << spec.toString();
   }
   return out.str();
 }
@@ -663,7 +656,7 @@ void pruneRandomSubfield(
                 break;
               case TypeKind::VARCHAR:
               case TypeKind::VARBINARY:
-                stringKeys.push_back(
+                stringKeys.emplace_back(
                     keys->asUnchecked<SimpleVector<StringView>>()->valueAt(jj));
                 break;
               default:
diff --git a/velox/dwio/common/tests/utils/FilterGenerator.h b/velox/dwio/common/tests/utils/FilterGenerator.h
index 42368d20ffb..2688441b5a0 100644
--- a/velox/dwio/common/tests/utils/FilterGenerator.h
+++ b/velox/dwio/common/tests/utils/FilterGenerator.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <fmt/format.h>
 #include <folly/Random.h>
 #include <memory>
 
@@ -49,6 +50,17 @@ struct FilterSpec {
         isForRowGroupSkip(isForRowGroupSkip),
         allowNulls_(allowNulls) {}
 
+  std::string toString() const {
+    return fmt::format(
+        "FilterSpec(field={}, startPct={}, selectPct={}, filterKind={}, isForRowGroupSkip={}, allowNulls={})",
+        field,
+        startPct,
+        selectPct,
+        filterKind,
+        isForRowGroupSkip,
+        allowNulls_);
+  }
+
   std::string field;
   float startPct = 50;
   float selectPct = 20;
diff --git a/velox/dwio/common/tests/utils/UnitLoaderTestTools.cpp b/velox/dwio/common/tests/utils/UnitLoaderTestTools.cpp
index e2ec87ae605..0342d0d530e 100644
--- a/velox/dwio/common/tests/utils/UnitLoaderTestTools.cpp
+++ b/velox/dwio/common/tests/utils/UnitLoaderTestTools.cpp
@@ -90,8 +90,9 @@ bool ReaderMock::loadUnit() {
 std::vector<std::unique_ptr<LoadUnit>> ReaderMock::getUnits() {
   std::vector<std::unique_ptr<LoadUnit>> units;
   for (size_t i = 0; i < rowsPerUnit_.size(); ++i) {
-    units.emplace_back(std::make_unique<LoadUnitMock>(
-        rowsPerUnit_[i], ioSizes_[i], unitsLoaded_, i));
+    units.emplace_back(
+        std::make_unique<LoadUnitMock>(
+            rowsPerUnit_[i], ioSizes_[i], unitsLoaded_, i));
   }
   return units;
 }
diff --git a/velox/dwio/common/tests/utils/UnitLoaderTestTools.h b/velox/dwio/common/tests/utils/UnitLoaderTestTools.h
index 9eae97f575c..6c36c10c865 100644
--- a/velox/dwio/common/tests/utils/UnitLoaderTestTools.h
+++ b/velox/dwio/common/tests/utils/UnitLoaderTestTools.h
@@ -32,16 +32,20 @@ class LoadUnitMock : public LoadUnit {
       uint64_t rowCount,
       uint64_t ioSize,
       std::vector<std::atomic_bool>& unitsLoaded,
-      size_t unitId)
+      size_t unitId,
+      std::chrono::milliseconds loadDelay = std::chrono::milliseconds(100))
       : rowCount_{rowCount},
         ioSize_{ioSize},
         unitsLoaded_{unitsLoaded},
-        unitId_{unitId} {}
+        unitId_{unitId},
+        loadDelay_(loadDelay) {}
 
   ~LoadUnitMock() override = default;
 
   void load() override {
     VELOX_CHECK(!isLoaded());
+    // Simulate loading time
+    std::this_thread::sleep_for(loadDelay_);
     unitsLoaded_[unitId_] = true;
   }
 
@@ -67,6 +71,7 @@ class LoadUnitMock : public LoadUnit {
   uint64_t ioSize_;
   std::vector<std::atomic_bool>& unitsLoaded_;
   size_t unitId_;
+  std::chrono::milliseconds loadDelay_;
 };
 
 class ReaderMock {
@@ -82,7 +87,7 @@ class ReaderMock {
   void seek(uint64_t rowNumber);
 
   std::vector<bool> unitsLoaded() const {
-    return {unitsLoaded_.begin(), unitsLoaded_.end()};
+    return {unitsLoaded_.cbegin(), unitsLoaded_.cend()};
   }
 
  private:
diff --git a/velox/dwio/common/wrap/CMakeLists.txt b/velox/dwio/common/wrap/CMakeLists.txt
new file mode 100644
index 00000000000..1d519452e0b
--- /dev/null
+++ b/velox/dwio/common/wrap/CMakeLists.txt
@@ -0,0 +1,17 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+velox_install_library_headers()
+
+# Wrapper headers — verify these are still needed and correctly included.
+velox_add_library(velox_dwio_common_wrap INTERFACE HEADERS zero-copy-stream-wrapper.h)
diff --git a/velox/dwio/dwrf/CMakeLists.txt b/velox/dwio/dwrf/CMakeLists.txt
index 613f69ad2f0..1fe671836e1 100644
--- a/velox/dwio/dwrf/CMakeLists.txt
+++ b/velox/dwio/dwrf/CMakeLists.txt
@@ -22,3 +22,9 @@ elseif(${VELOX_BUILD_TEST_UTILS})
 endif()
 add_subdirectory(utils)
 add_subdirectory(writer)
+
+velox_add_library(velox_dwio_dwrf_register_reader INTERFACE HEADERS RegisterDwrfReader.h)
+
+velox_add_library(velox_dwio_dwrf_register_writer INTERFACE HEADERS RegisterDwrfWriter.h)
+
+velox_install_library_headers()
diff --git a/velox/dwio/dwrf/common/CMakeLists.txt b/velox/dwio/dwrf/common/CMakeLists.txt
index 8a3dc1e393e..311b4ac51ac 100644
--- a/velox/dwio/dwrf/common/CMakeLists.txt
+++ b/velox/dwio/dwrf/common/CMakeLists.txt
@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+add_subdirectory(wrap)
+
 velox_add_library(
   velox_dwio_dwrf_common
   ByteRLE.cpp
@@ -27,6 +29,25 @@ velox_add_library(
   Statistics.cpp
   wrap/orc-proto-wrapper.cpp
   wrap/dwrf-proto-wrapper.cpp
+  HEADERS
+  ByteRLE.h
+  Checksum.h
+  Common.h
+  Compression.h
+  Config.h
+  DecoderUtil.h
+  Decryption.h
+  EncoderUtil.h
+  Encryption.h
+  EncryptionCommon.h
+  EncryptionSpecification.h
+  FileMetadata.h
+  FloatingPointDecoder.h
+  IntEncoder.h
+  NextVisitor.h
+  RLEv1.h
+  RLEv2.h
+  Statistics.h
 )
 
 velox_link_libraries(
diff --git a/velox/dwio/dwrf/common/Checksum.h b/velox/dwio/dwrf/common/Checksum.h
index 6ca7d205d99..0f31dbe19d8 100644
--- a/velox/dwio/dwrf/common/Checksum.h
+++ b/velox/dwio/dwrf/common/Checksum.h
@@ -20,8 +20,7 @@
 #include "velox/dwio/dwrf/common/wrap/dwrf-proto-wrapper.h"
 
 #include <boost/crc.hpp>
-#define XXH_INLINE_ALL
-#include <xxhash.h>
+#include "velox/common/base/XxHashInline.h"
 
 namespace facebook::velox::dwrf {
 
diff --git a/velox/dwio/dwrf/common/Common.h b/velox/dwio/dwrf/common/Common.h
index 783f8a0329d..ae467654c1f 100644
--- a/velox/dwio/dwrf/common/Common.h
+++ b/velox/dwio/dwrf/common/Common.h
@@ -29,11 +29,11 @@
 namespace facebook::velox::dwrf {
 
 // Writer version
-constexpr folly::StringPiece WRITER_NAME_KEY{"orc.writer.name"};
-constexpr folly::StringPiece WRITER_VERSION_KEY{"orc.writer.version"};
-constexpr folly::StringPiece WRITER_HOSTNAME_KEY{"orc.writer.host"};
-constexpr folly::StringPiece kDwioWriter{"dwio"};
-constexpr folly::StringPiece kPrestoWriter{"presto"};
+constexpr std::string_view kWriterNameKey{"orc.writer.name"};
+constexpr std::string_view kWriterVersionKey{"orc.writer.version"};
+constexpr std::string_view kWriterHostnameKey{"orc.writer.host"};
+constexpr std::string_view kDwioWriter{"dwio"};
+constexpr std::string_view kPrestoWriter{"presto"};
 
 enum class DwrfFormat : uint8_t {
   kDwrf = 0,
diff --git a/velox/dwio/dwrf/common/Compression.h b/velox/dwio/dwrf/common/Compression.h
index 0be6a4e0e41..e09ca21a870 100644
--- a/velox/dwio/dwrf/common/Compression.h
+++ b/velox/dwio/dwrf/common/Compression.h
@@ -105,6 +105,7 @@ inline CompressionOptions getDwrfOrcDecompressionOptions(
  * @param input The input stream that is the underlying source
  * @param bufferSize The maximum size of the buffer
  * @param pool The memory pool
+ * @param decompressCounter Optional IoCounter for tracking decompression stats
  */
 inline std::unique_ptr<dwio::common::SeekableInputStream> createDecompressor(
     facebook::velox::common::CompressionKind kind,
@@ -112,16 +113,20 @@ inline std::unique_ptr<dwio::common::SeekableInputStream> createDecompressor(
     uint64_t bufferSize,
     memory::MemoryPool& pool,
     const std::string& streamDebugInfo,
-    const dwio::common::encryption::Decrypter* decryptr = nullptr) {
+    const dwio::common::encryption::Decrypter* decryptr = nullptr,
+    velox::io::IoCounter* decompressCounter = nullptr) {
   const CompressionOptions& options = getDwrfOrcDecompressionOptions(kind);
-  return createDecompressor(
+  return dwio::common::compression::createDecompressor(
       kind,
       std::move(input),
       bufferSize,
       pool,
       options,
       streamDebugInfo,
-      decryptr);
+      decryptr,
+      false,
+      0,
+      decompressCounter);
 }
 
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/common/Config.cpp b/velox/dwio/dwrf/common/Config.cpp
index 8ce1ad5f215..b9c556d8a88 100644
--- a/velox/dwio/dwrf/common/Config.cpp
+++ b/velox/dwio/dwrf/common/Config.cpp
@@ -130,7 +130,7 @@ Config::Entry<const std::vector<uint32_t>> Config::MAP_FLAT_COLS(
     [](const std::string& /* key */, const std::string& val) {
       std::vector<uint32_t> result;
       if (!val.empty()) {
-        std::vector<folly::StringPiece> pieces;
+        std::vector<std::string_view> pieces;
         folly::split(',', val, pieces, true);
         for (const auto& p : pieces) {
           const auto& trimmedCol = folly::trimWhitespace(p);
@@ -182,7 +182,7 @@ Config::Entry<const std::vector<std::vector<std::string>>>
 
 Config::Entry<uint32_t> Config::MAP_FLAT_MAX_KEYS(
     "orc.map.flat.max.keys",
-    20000);
+    30000);
 
 Config::Entry<uint64_t> Config::MAX_DICTIONARY_SIZE(
     "hive.exec.orc.max.dictionary.size",
diff --git a/velox/dwio/dwrf/common/FileMetadata.cpp b/velox/dwio/dwrf/common/FileMetadata.cpp
index ccb9f6faa7f..2b3f2f80d49 100644
--- a/velox/dwio/dwrf/common/FileMetadata.cpp
+++ b/velox/dwio/dwrf/common/FileMetadata.cpp
@@ -37,6 +37,29 @@ CompressionKind orcCompressionToCompressionKind(
   }
   VELOX_FAIL("Unknown compression kind: {}", CompressionKind_Name(compression));
 }
+
+static proto::orc::CompressionKind compressionKindToOrcCompression(
+    CompressionKind compressionKind) {
+  switch (compressionKind) {
+    case CompressionKind::CompressionKind_NONE:
+      return proto::orc::CompressionKind::NONE;
+    case CompressionKind::CompressionKind_ZLIB:
+      return proto::orc::CompressionKind::ZLIB;
+    case CompressionKind::CompressionKind_SNAPPY:
+      return proto::orc::CompressionKind::SNAPPY;
+    case CompressionKind::CompressionKind_LZO:
+      return proto::orc::CompressionKind::LZO;
+    case CompressionKind::CompressionKind_ZSTD:
+      return proto::orc::CompressionKind::ZSTD;
+    case CompressionKind::CompressionKind_LZ4:
+      return proto::orc::CompressionKind::LZ4;
+    case CompressionKind::CompressionKind_GZIP:
+    default:
+      VELOX_FAIL(
+          "Unknown compression kind: {}",
+          compressionKindToString(compressionKind));
+  }
+}
 } // namespace detail
 
 TypeKind TypeWrapper::kind() const {
@@ -102,9 +125,10 @@ TypeKind TypeWrapper::kind() const {
     }
     case proto::orc::Type_Kind_CHAR:
     case proto::orc::Type_Kind_TIMESTAMP_INSTANT:
-      VELOX_FAIL(fmt::format(
-          "{} not supported yet.",
-          proto::orc::Type_Kind_Name(orcPtr()->kind())));
+      VELOX_FAIL(
+          fmt::format(
+              "{} not supported yet.",
+              proto::orc::Type_Kind_Name(orcPtr()->kind())));
     default:
       VELOX_FAIL("Unknown type kind: {}", Type_Kind_Name(orcPtr()->kind()));
   }
@@ -116,4 +140,13 @@ common::CompressionKind PostScript::compression() const {
       : detail::orcCompressionToCompressionKind(orcPtr()->compression());
 }
 
+void PostScriptWriteWrapper::setCompression(
+    common::CompressionKind compressionKind) {
+  format_ == DwrfFormat::kDwrf
+      ? dwrfPtr()->set_compression(
+            static_cast<proto::CompressionKind>(compressionKind))
+      : orcPtr()->set_compression(
+            detail::compressionKindToOrcCompression(compressionKind));
+}
+
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/common/FileMetadata.h b/velox/dwio/dwrf/common/FileMetadata.h
index 87e8c12719f..3665d4b9120 100644
--- a/velox/dwio/dwrf/common/FileMetadata.h
+++ b/velox/dwio/dwrf/common/FileMetadata.h
@@ -19,6 +19,7 @@
 
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/compression/Compression.h"
+#include "velox/dwio/common/OutputStream.h"
 #include "velox/dwio/dwrf/common/Common.h"
 #include "velox/dwio/dwrf/common/wrap/dwrf-proto-wrapper.h"
 #include "velox/dwio/dwrf/common/wrap/orc-proto-wrapper.h"
@@ -43,6 +44,24 @@ class ProtoWrapperBase {
   const void* const impl_;
 };
 
+class ProtoWriteWrapperBase {
+ protected:
+  ProtoWriteWrapperBase(DwrfFormat format, void* impl)
+      : format_{format}, impl_{impl} {}
+
+  DwrfFormat format_;
+  void* impl_;
+
+ public:
+  DwrfFormat format() const {
+    return format_;
+  }
+
+  inline void* rawProtoPtr() const {
+    return impl_;
+  }
+};
+
 /***
  * PostScript that takes the ownership of proto::PostScript /
  *proto::orc::PostScript and provides access to the attributes
@@ -93,6 +112,10 @@ class PostScript {
                                         : orcPtr()->footerlength();
   }
 
+  uint64_t metadataLength() const {
+    return format_ == DwrfFormat::kDwrf ? 0 : orcPtr()->metadatalength();
+  }
+
   bool hasCompression() const {
     return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_compression()
                                         : orcPtr()->has_compression();
@@ -244,6 +267,46 @@ class StripeInformationWrapper : public ProtoWrapperBase {
   }
 };
 
+class ColumnEncodingKindWrapper : public ProtoWrapperBase {
+ public:
+  explicit ColumnEncodingKindWrapper(proto::ColumnEncoding_Kind* stream)
+      : ProtoWrapperBase(DwrfFormat::kDwrf, stream) {}
+
+  explicit ColumnEncodingKindWrapper(proto::orc::ColumnEncoding_Kind* stream)
+      : ProtoWrapperBase(DwrfFormat::kOrc, stream) {}
+};
+
+class ColumnEncodingWrapper : public ProtoWrapperBase {
+ public:
+  explicit ColumnEncodingWrapper(const proto::ColumnEncoding* columnEncoding)
+      : ProtoWrapperBase(DwrfFormat::kDwrf, columnEncoding) {}
+  explicit ColumnEncodingWrapper(
+      const proto::orc::ColumnEncoding* columnEncoding)
+      : ProtoWrapperBase(DwrfFormat::kOrc, columnEncoding) {}
+
+  void Clear() {}
+
+  proto::ColumnEncoding_Kind kind() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->kind();
+  }
+
+  uint32_t node() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->node();
+  }
+
+ private:
+  // private helper with no format checking
+  inline const proto::ColumnEncoding* dwrfPtr() const {
+    return reinterpret_cast<const proto::ColumnEncoding*>(rawProtoPtr());
+  }
+
+  inline const proto::orc::ColumnEncoding* orcPtr() const {
+    return reinterpret_cast<const proto::orc::ColumnEncoding*>(rawProtoPtr());
+  }
+};
+
 class TypeWrapper : public ProtoWrapperBase {
  public:
   explicit TypeWrapper(const proto::Type* t)
@@ -940,6 +1003,1027 @@ class StripeFooterWrapper : public ProtoWrapperBase {
   std::shared_ptr<const proto::orc::StripeFooter> orcStripeFooter_ = nullptr;
 };
 
+class StripeInformationWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit StripeInformationWriteWrapper(
+      proto::StripeInformation* stripeInformation)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, stripeInformation) {}
+
+  explicit StripeInformationWriteWrapper(
+      proto::orc::StripeInformation* stripeInformation)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, stripeInformation) {}
+
+  uint64_t numberOfRows() {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->numberofrows()
+                                        : orcPtr()->numberofrows();
+  }
+
+  uint64_t rawDataSize() {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->rawdatasize() : 0;
+  }
+
+  bool hasChecksum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_checksum() : false;
+  }
+
+  uint64_t checksum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->checksum() : 0;
+  }
+
+  void setNumberOfRows(uint64_t stripeRowCount) {
+    return format_ == DwrfFormat::kDwrf
+        ? dwrfPtr()->set_numberofrows(stripeRowCount)
+        : orcPtr()->set_numberofrows(stripeRowCount);
+  }
+
+  void setRawDataSize(uint64_t rawDataSize) {
+    if (format_ == DwrfFormat::kDwrf) {
+      dwrfPtr()->set_rawdatasize(rawDataSize);
+    }
+  }
+
+  void setChecksum(int64_t checksum) {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    dwrfPtr()->set_checksum(checksum);
+  }
+
+  void setGroupSize(uint64_t groupSize) {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    dwrfPtr()->set_groupsize(groupSize);
+  }
+
+  uint64_t groupSize() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->groupsize();
+  }
+
+  void setOffset(uint64_t offset) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_offset(offset)
+                                 : orcPtr()->set_offset(offset);
+  }
+
+  uint64_t offset() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->offset()
+                                        : orcPtr()->offset();
+  }
+
+  void setIndexLength(uint64_t indexLength) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_indexlength(indexLength)
+                                 : orcPtr()->set_indexlength(indexLength);
+  }
+
+  uint64_t indexLength() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->indexlength()
+                                        : orcPtr()->indexlength();
+  }
+
+  void setDataLength(uint64_t dataLength) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_datalength(dataLength)
+                                 : orcPtr()->set_datalength(dataLength);
+  }
+
+  uint64_t dataLength() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->datalength()
+                                        : orcPtr()->datalength();
+  }
+
+  void setFooterLength(uint64_t footerLength) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_footerlength(footerLength)
+                                 : orcPtr()->set_footerlength(footerLength);
+  }
+
+  uint64_t footerLength() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->footerlength()
+                                        : orcPtr()->footerlength();
+  }
+
+  std::string* addKeyMetadata() {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->add_keymetadata();
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::StripeInformation* dwrfPtr() const {
+    return reinterpret_cast<proto::StripeInformation*>(rawProtoPtr());
+  }
+  inline proto::orc::StripeInformation* orcPtr() const {
+    return reinterpret_cast<proto::orc::StripeInformation*>(rawProtoPtr());
+  }
+};
+
+class TypeKindWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit TypeKindWrapper(proto::Type_Kind* footer)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, footer) {}
+
+  explicit TypeKindWrapper(proto::orc::Type_Kind* footer)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, footer) {}
+};
+
+class TypeWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit TypeWriteWrapper(proto::Type* footer)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, footer) {}
+
+  explicit TypeWriteWrapper(proto::orc::Type* footer)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, footer) {}
+
+  const proto::Type* getDwrfPtr() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return reinterpret_cast<proto::Type*>(rawProtoPtr());
+  }
+
+  const proto::orc::Type* getOrcPtr() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kOrc);
+    return reinterpret_cast<proto::orc::Type*>(rawProtoPtr());
+  }
+
+  void setKind(TypeKindWrapper typeKindWrapper) {
+    format_ == DwrfFormat::kDwrf
+        ? dwrfPtr()->set_kind(*reinterpret_cast<proto::Type_Kind*>(
+              typeKindWrapper.rawProtoPtr()))
+        : orcPtr()->set_kind(*reinterpret_cast<proto::orc::Type_Kind*>(
+              typeKindWrapper.rawProtoPtr()));
+  }
+
+  void setScale(uint32_t scale) {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kOrc);
+    orcPtr()->set_scale(scale);
+  }
+
+  void setPrecision(uint32_t precision) {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kOrc);
+    orcPtr()->set_precision(precision);
+  }
+
+  void addFieldnames(const std::string& fieldName) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->add_fieldnames(fieldName)
+                                 : orcPtr()->add_fieldnames(fieldName);
+  }
+
+  void addSubtypes(int fieldName) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->add_subtypes(fieldName)
+                                 : orcPtr()->add_subtypes(fieldName);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::Type* dwrfPtr() const {
+    return reinterpret_cast<proto::Type*>(rawProtoPtr());
+  }
+  inline proto::orc::Type* orcPtr() const {
+    return reinterpret_cast<proto::orc::Type*>(rawProtoPtr());
+  }
+};
+
+class UserMetadataItemWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit UserMetadataItemWriteWrapper(
+      proto::UserMetadataItem* userMetadataItem)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, userMetadataItem) {}
+
+  explicit UserMetadataItemWriteWrapper(
+      proto::orc::UserMetadataItem* userMetadataItem)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, userMetadataItem) {}
+
+  void setName(const std::string& name) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_name(name)
+                                 : orcPtr()->set_name(name);
+  }
+
+  void setValue(const std::string& value) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_value(value)
+                                 : orcPtr()->set_value(value);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::UserMetadataItem* dwrfPtr() const {
+    return reinterpret_cast<proto::UserMetadataItem*>(rawProtoPtr());
+  }
+  inline proto::orc::UserMetadataItem* orcPtr() const {
+    return reinterpret_cast<proto::orc::UserMetadataItem*>(rawProtoPtr());
+  }
+};
+
+class BucketStatisticsWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit BucketStatisticsWriteWrapper(
+      proto::BucketStatistics* bucketStatistics)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, bucketStatistics) {}
+
+  explicit BucketStatisticsWriteWrapper(
+      proto::orc::BucketStatistics* bucketStatistics)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, bucketStatistics) {}
+
+  int countSize() {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->count_size()
+                                        : orcPtr()->count_size();
+  }
+
+  void addCount(uint64_t count) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->add_count(count)
+                                 : orcPtr()->add_count(count);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::BucketStatistics* dwrfPtr() const {
+    return reinterpret_cast<proto::BucketStatistics*>(rawProtoPtr());
+  }
+  inline proto::orc::BucketStatistics* orcPtr() const {
+    return reinterpret_cast<proto::orc::BucketStatistics*>(rawProtoPtr());
+  }
+};
+
+class IntegerStatisticsWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit IntegerStatisticsWriteWrapper(
+      proto::IntegerStatistics* integerStatistics)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, integerStatistics) {}
+
+  explicit IntegerStatisticsWriteWrapper(
+      proto::orc::IntegerStatistics* integerStatistics)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, integerStatistics) {}
+
+  void setSum(int64_t sum) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_sum(sum)
+                                 : orcPtr()->set_sum(sum);
+  }
+
+  void setMinimum(int64_t minimum) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_minimum(minimum)
+                                 : orcPtr()->set_minimum(minimum);
+  }
+
+  void setMaximum(int64_t maximum) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_maximum(maximum)
+                                 : orcPtr()->set_maximum(maximum);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::IntegerStatistics* dwrfPtr() const {
+    return reinterpret_cast<proto::IntegerStatistics*>(rawProtoPtr());
+  }
+  inline proto::orc::IntegerStatistics* orcPtr() const {
+    return reinterpret_cast<proto::orc::IntegerStatistics*>(rawProtoPtr());
+  }
+};
+
+class DoubleStatisticsWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit DoubleStatisticsWriteWrapper(
+      proto::DoubleStatistics* doubleStatistics)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, doubleStatistics) {}
+
+  explicit DoubleStatisticsWriteWrapper(
+      proto::orc::DoubleStatistics* doubleStatistics)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, doubleStatistics) {}
+
+  void setSum(double sum) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_sum(sum)
+                                 : orcPtr()->set_sum(sum);
+  }
+
+  void setMinimum(double minimum) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_minimum(minimum)
+                                 : orcPtr()->set_minimum(minimum);
+  }
+
+  void setMaximum(double maximum) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_maximum(maximum)
+                                 : orcPtr()->set_maximum(maximum);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::DoubleStatistics* dwrfPtr() const {
+    return reinterpret_cast<proto::DoubleStatistics*>(rawProtoPtr());
+  }
+  inline proto::orc::DoubleStatistics* orcPtr() const {
+    return reinterpret_cast<proto::orc::DoubleStatistics*>(rawProtoPtr());
+  }
+};
+
+class StringStatisticsWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit StringStatisticsWriteWrapper(
+      proto::StringStatistics* stringStatistics)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, stringStatistics) {}
+
+  explicit StringStatisticsWriteWrapper(
+      proto::orc::StringStatistics* stringStatistics)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, stringStatistics) {}
+
+  void setSum(uint64_t sum) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_sum(sum)
+                                 : orcPtr()->set_sum(sum);
+  }
+
+  void setMinimum(std::string minimum) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_minimum(minimum)
+                                 : orcPtr()->set_minimum(minimum);
+  }
+
+  void setMaximum(std::string maximum) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_maximum(maximum)
+                                 : orcPtr()->set_maximum(maximum);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::StringStatistics* dwrfPtr() const {
+    return reinterpret_cast<proto::StringStatistics*>(rawProtoPtr());
+  }
+  inline proto::orc::StringStatistics* orcPtr() const {
+    return reinterpret_cast<proto::orc::StringStatistics*>(rawProtoPtr());
+  }
+};
+
+class BinaryStatisticsWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit BinaryStatisticsWriteWrapper(
+      proto::BinaryStatistics* binaryStatistics)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, binaryStatistics) {}
+
+  explicit BinaryStatisticsWriteWrapper(
+      proto::orc::BinaryStatistics* binaryStatistics)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, binaryStatistics) {}
+
+  void setSum(uint64_t sum) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_sum(sum)
+                                 : orcPtr()->set_sum(sum);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::BinaryStatistics* dwrfPtr() const {
+    return reinterpret_cast<proto::BinaryStatistics*>(rawProtoPtr());
+  }
+  inline proto::orc::BinaryStatistics* orcPtr() const {
+    return reinterpret_cast<proto::orc::BinaryStatistics*>(rawProtoPtr());
+  }
+};
+
+class ColumnStatisticsWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit ColumnStatisticsWriteWrapper(proto::ColumnStatistics* footer)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, footer) {}
+
+  explicit ColumnStatisticsWriteWrapper(proto::orc::ColumnStatistics* footer)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, footer) {}
+
+  void setSize(uint64_t size) {
+    if (format_ == DwrfFormat::kDwrf) {
+      dwrfPtr()->set_size(size);
+    }
+  }
+
+  void setHasNull(bool hasNull) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_hasnull(hasNull)
+                                 : orcPtr()->set_hasnull(hasNull);
+  }
+
+  void setNumberOfValues(uint64_t numberOfValues) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_numberofvalues(numberOfValues)
+                                 : orcPtr()->set_numberofvalues(numberOfValues);
+  }
+
+  void setRawSize(uint64_t rawSize) {
+    if (format_ == DwrfFormat::kDwrf) {
+      dwrfPtr()->set_rawsize(rawSize);
+    }
+  }
+
+  uint64_t getRawSize() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->rawsize();
+  }
+
+  uint64_t getSize() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->size();
+  }
+
+  bool hasMapStatistics() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->has_mapstatistics();
+  }
+
+  proto::MapStatistics* mutableMapStatistics() {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->mutable_mapstatistics();
+  }
+
+  BinaryStatisticsWriteWrapper mutableBinaryStatistics() {
+    return format_ == DwrfFormat::kDwrf
+        ? BinaryStatisticsWriteWrapper(dwrfPtr()->mutable_binarystatistics())
+        : BinaryStatisticsWriteWrapper(orcPtr()->mutable_binarystatistics());
+  }
+
+  StringStatisticsWriteWrapper mutableStringStatistics() {
+    return format_ == DwrfFormat::kDwrf
+        ? StringStatisticsWriteWrapper(dwrfPtr()->mutable_stringstatistics())
+        : StringStatisticsWriteWrapper(orcPtr()->mutable_stringstatistics());
+  }
+
+  DoubleStatisticsWriteWrapper mutableDoubleStatistics() {
+    return format_ == DwrfFormat::kDwrf
+        ? DoubleStatisticsWriteWrapper(dwrfPtr()->mutable_doublestatistics())
+        : DoubleStatisticsWriteWrapper(orcPtr()->mutable_doublestatistics());
+  }
+
+  IntegerStatisticsWriteWrapper mutableIntegerStatistics() {
+    return format_ == DwrfFormat::kDwrf
+        ? IntegerStatisticsWriteWrapper(dwrfPtr()->mutable_intstatistics())
+        : IntegerStatisticsWriteWrapper(orcPtr()->mutable_intstatistics());
+  }
+
+  proto::orc::DateStatistics* mutableDateStatistics() {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kOrc);
+    return orcPtr()->mutable_datestatistics();
+  }
+
+  proto::orc::TimestampStatistics* mutableTimestampStatistics() {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kOrc);
+    return orcPtr()->mutable_timestampstatistics();
+  }
+
+  proto::orc::DecimalStatistics* mutableDecimalStatistics() {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kOrc);
+    return orcPtr()->mutable_decimalstatistics();
+  }
+
+  BucketStatisticsWriteWrapper mutableBucketStatistics() {
+    return format_ == DwrfFormat::kDwrf
+        ? BucketStatisticsWriteWrapper(dwrfPtr()->mutable_bucketstatistics())
+        : BucketStatisticsWriteWrapper(orcPtr()->mutable_bucketstatistics());
+  }
+
+  void reset(const proto::ColumnStatistics* dwrfStatistics) {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    VELOX_CHECK_NOT_NULL(dwrfStatistics);
+    dwrfPtr()->CopyFrom(*dwrfStatistics);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::ColumnStatistics* dwrfPtr() const {
+    return reinterpret_cast<proto::ColumnStatistics*>(rawProtoPtr());
+  }
+  inline proto::orc::ColumnStatistics* orcPtr() const {
+    return reinterpret_cast<proto::orc::ColumnStatistics*>(rawProtoPtr());
+  }
+};
+
+class FooterWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit FooterWriteWrapper(proto::Footer* footer)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, footer) {}
+
+  explicit FooterWriteWrapper(proto::orc::Footer* footer)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, footer) {}
+
+  const proto::Footer* getDwrfPtr() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return reinterpret_cast<proto::Footer*>(rawProtoPtr());
+  }
+
+  proto::Footer* getMutableDwrfPtr() {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return reinterpret_cast<proto::Footer*>(rawProtoPtr());
+  }
+
+  const proto::orc::Footer* getOrcPtr() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kOrc);
+    return reinterpret_cast<proto::orc::Footer*>(rawProtoPtr());
+  }
+
+  const StripeInformationWriteWrapper addStripes() const {
+    return format_ == DwrfFormat::kDwrf
+        ? StripeInformationWriteWrapper(dwrfPtr()->add_stripes())
+        : StripeInformationWriteWrapper(orcPtr()->add_stripes());
+  }
+
+  void setHeaderLength(uint64_t headerLength) const {
+    return format_ == DwrfFormat::kDwrf
+        ? dwrfPtr()->set_headerlength(headerLength)
+        : orcPtr()->set_headerlength(headerLength);
+  }
+
+  void setContentLength(uint64_t contentLength) const {
+    return format_ == DwrfFormat::kDwrf
+        ? dwrfPtr()->set_contentlength(contentLength)
+        : orcPtr()->set_contentlength(contentLength);
+  }
+
+  void setRowIndexStride(uint32_t rowIndexStride) const {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_rowindexstride(rowIndexStride)
+                                 : orcPtr()->set_rowindexstride(rowIndexStride);
+  }
+
+  void setNumberOfRows(uint64_t numberOfRows) const {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_numberofrows(numberOfRows)
+                                 : orcPtr()->set_numberofrows(numberOfRows);
+  }
+
+  void setRawDataSize(uint64_t numberOfRows) const {
+    if (format_ == DwrfFormat::kDwrf) {
+      dwrfPtr()->set_rawdatasize(numberOfRows);
+    }
+  }
+
+  void setWriter(uint32_t writer) const {
+    if (format_ == DwrfFormat::kOrc) {
+      orcPtr()->set_writer(writer);
+    }
+  }
+
+  void setCheckSumAlgorithm(proto::ChecksumAlgorithm checksum) const {
+    if (format_ == DwrfFormat::kDwrf) {
+      dwrfPtr()->set_checksumalgorithm(checksum);
+    }
+  }
+
+  void addStripeCacheOffsets(uint32_t stripeCacheOffsets) const {
+    if (format_ == DwrfFormat::kDwrf) {
+      dwrfPtr()->add_stripecacheoffsets(stripeCacheOffsets);
+    } else {
+      //
+    }
+  }
+
+  TypeWriteWrapper addTypes() const {
+    return format_ == DwrfFormat::kDwrf
+        ? TypeWriteWrapper(dwrfPtr()->add_types())
+        : TypeWriteWrapper(orcPtr()->add_types());
+  }
+
+  UserMetadataItemWriteWrapper addMetadata() const {
+    return format_ == DwrfFormat::kDwrf
+        ? UserMetadataItemWriteWrapper(dwrfPtr()->add_metadata())
+        : UserMetadataItemWriteWrapper(orcPtr()->add_metadata());
+  }
+
+  ColumnStatisticsWriteWrapper addStatistics() const {
+    return format_ == DwrfFormat::kDwrf
+        ? ColumnStatisticsWriteWrapper(dwrfPtr()->add_statistics())
+        : ColumnStatisticsWriteWrapper(orcPtr()->add_statistics());
+  }
+
+  const ::google::protobuf::RepeatedPtrField<
+      ::facebook::velox::dwrf::proto::ColumnStatistics>&
+  statistics() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->statistics();
+  }
+
+  int typesSize() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->types_size()
+                                        : orcPtr()->types_size();
+  }
+
+  int statisticsSize() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->statistics_size()
+                                        : orcPtr()->statistics_size();
+  }
+
+  uint64_t contentLength() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->contentlength()
+                                        : orcPtr()->contentlength();
+  }
+
+  uint64_t numberOfRows() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->numberofrows()
+                                        : orcPtr()->numberofrows();
+  }
+
+  // DWRF-specific fields
+  inline uint64_t rawDataSize() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->rawdatasize();
+  }
+
+  inline int stripesSize() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->stripes_size();
+  }
+
+  inline proto::Encryption* mutableEncryption() {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->mutable_encryption();
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::Footer* dwrfPtr() const {
+    return reinterpret_cast<proto::Footer*>(rawProtoPtr());
+  }
+  inline proto::orc::Footer* orcPtr() const {
+    return reinterpret_cast<proto::orc::Footer*>(rawProtoPtr());
+  }
+};
+
+class RowIndexEntryWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit RowIndexEntryWriteWrapper(proto::RowIndexEntry* rowIndexEntry)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, rowIndexEntry) {}
+
+  explicit RowIndexEntryWriteWrapper(proto::orc::RowIndexEntry* rowIndexEntry)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, rowIndexEntry) {}
+
+  ColumnStatisticsWriteWrapper mutableStatistics() {
+    return format_ == DwrfFormat::kDwrf
+        ? ColumnStatisticsWriteWrapper(dwrfPtr()->mutable_statistics())
+        : ColumnStatisticsWriteWrapper(orcPtr()->mutable_statistics());
+  }
+
+  bool hasStatistics() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_statistics()
+                                        : orcPtr()->has_statistics();
+  }
+
+  void mutablePositions(int start, int num) {
+    return format_ == DwrfFormat::kDwrf
+        ? dwrfPtr()->mutable_positions()->ExtractSubrange(start, num, nullptr)
+        : orcPtr()->mutable_positions()->ExtractSubrange(start, num, nullptr);
+  }
+
+  void addPositions(uint64_t pos) {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->add_positions(pos)
+                                        : orcPtr()->add_positions(pos);
+  }
+
+  uint64_t positionsSize() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->positions_size()
+                                        : orcPtr()->positions_size();
+  }
+
+  const ::google::protobuf::RepeatedField<uint64_t> positions() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->positions()
+                                        : orcPtr()->positions();
+  }
+
+  void clear() {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->Clear()
+                                        : orcPtr()->Clear();
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::RowIndexEntry* dwrfPtr() const {
+    return reinterpret_cast<proto::RowIndexEntry*>(rawProtoPtr());
+  }
+  inline proto::orc::RowIndexEntry* orcPtr() const {
+    return reinterpret_cast<proto::orc::RowIndexEntry*>(rawProtoPtr());
+  }
+};
+
+class RowIndexWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit RowIndexWriteWrapper(proto::RowIndex* rowIndex)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, rowIndex) {}
+
+  explicit RowIndexWriteWrapper(proto::orc::RowIndex* rowIndex)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, rowIndex) {}
+
+  void addEntry(std::unique_ptr<RowIndexEntryWriteWrapper>& entry) {
+    if (format_ == DwrfFormat::kDwrf) {
+      auto e = reinterpret_cast<proto::RowIndexEntry*>(entry->rawProtoPtr());
+      *dwrfPtr()->add_entry() = *e;
+    } else {
+      auto e =
+          reinterpret_cast<proto::orc::RowIndexEntry*>(entry->rawProtoPtr());
+      *orcPtr()->add_entry() = *e;
+    }
+  }
+
+  int32_t entrySize() {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->entry_size()
+                                        : orcPtr()->entry_size();
+  }
+
+  RowIndexEntryWriteWrapper mutableEntry(int32_t index) {
+    return format_ == DwrfFormat::kDwrf
+        ? RowIndexEntryWriteWrapper(dwrfPtr()->mutable_entry(index))
+        : RowIndexEntryWriteWrapper(orcPtr()->mutable_entry(index));
+  }
+
+  void SerializeToZeroCopyStream(
+      dwio::common::BufferedOutputStream* out) const {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->SerializeToZeroCopyStream(out)
+                                 : orcPtr()->SerializeToZeroCopyStream(out);
+  }
+
+  void clear() {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->Clear()
+                                        : orcPtr()->Clear();
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::RowIndex* dwrfPtr() const {
+    return reinterpret_cast<proto::RowIndex*>(rawProtoPtr());
+  }
+  inline proto::orc::RowIndex* orcPtr() const {
+    return reinterpret_cast<proto::orc::RowIndex*>(rawProtoPtr());
+  }
+};
+
+class ColumnEncodingWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit ColumnEncodingWriteWrapper(proto::ColumnEncoding* stream)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, stream) {}
+
+  explicit ColumnEncodingWriteWrapper(proto::orc::ColumnEncoding* stream)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, stream) {}
+
+  void setKind(ColumnEncodingKindWrapper columnEncodingKindWrapper) {
+    format_ == DwrfFormat::kDwrf
+        ? dwrfPtr()->set_kind(
+              *reinterpret_cast<const proto::ColumnEncoding_Kind*>(
+                  columnEncodingKindWrapper.rawProtoPtr()))
+        : orcPtr()->set_kind(
+              *reinterpret_cast<const proto::orc::ColumnEncoding_Kind*>(
+                  columnEncodingKindWrapper.rawProtoPtr()));
+  }
+
+  void setDictionarySize(uint32_t dictionarySize) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_dictionarysize(dictionarySize)
+                                 : orcPtr()->set_dictionarysize(dictionarySize);
+  }
+
+  void setNode(uint32_t node) {
+    if (format_ == DwrfFormat::kDwrf) {
+      dwrfPtr()->set_node(node);
+    }
+  }
+
+  void setSequence(uint32_t sequence) {
+    if (format_ == DwrfFormat::kDwrf) {
+      dwrfPtr()->set_sequence(sequence);
+    }
+  }
+
+  proto::KeyInfo* mutableKey() {
+    return dwrfPtr()->mutable_key();
+  }
+
+  void Clear() {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->Clear() : orcPtr()->Clear();
+  }
+
+  void reset(const proto::ColumnEncoding* dwrfEncoding) {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    VELOX_CHECK_NOT_NULL(dwrfEncoding);
+    dwrfPtr()->CopyFrom(*dwrfEncoding);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::ColumnEncoding* dwrfPtr() const {
+    return reinterpret_cast<proto::ColumnEncoding*>(rawProtoPtr());
+  }
+  inline proto::orc::ColumnEncoding* orcPtr() const {
+    return reinterpret_cast<proto::orc::ColumnEncoding*>(rawProtoPtr());
+  }
+};
+
+class StreamWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit StreamWriteWrapper(proto::Stream* stream)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, stream) {}
+
+  explicit StreamWriteWrapper(proto::orc::Stream* stream)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, stream) {}
+
+  void setOffset(uint64_t offset) {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    dwrfPtr()->set_offset(offset);
+  }
+
+  void setKind(const StreamKind& kind) {
+    format_ == DwrfFormat::kDwrf
+        ? dwrfPtr()->set_kind(static_cast<proto::Stream_Kind>(kind))
+        : orcPtr()->set_kind(static_cast<proto::orc::Stream_Kind>(kind));
+  }
+
+  void setColumn(uint32_t column) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_column(column)
+                                 : orcPtr()->set_column(column);
+  }
+
+  void setLength(uint64_t length) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_length(length)
+                                 : orcPtr()->set_length(length);
+  }
+
+  void setNode(uint32_t node) {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    dwrfPtr()->set_node(node);
+  }
+
+  void setSequence(uint32_t sequence) {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    dwrfPtr()->set_sequence(sequence);
+  }
+
+  void setUseVints(bool useVints) {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    dwrfPtr()->set_usevints(useVints);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::Stream* dwrfPtr() const {
+    return reinterpret_cast<proto::Stream*>(rawProtoPtr());
+  }
+  inline proto::orc::Stream* orcPtr() const {
+    return reinterpret_cast<proto::orc::Stream*>(rawProtoPtr());
+  }
+};
+
+class StripeEncryptionGroupWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit StripeEncryptionGroupWriteWrapper(
+      proto::StripeEncryptionGroup* stripeFooter = nullptr)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, stripeFooter) {}
+
+  // See https://orc.apache.org/specification/ORCv1/
+  explicit StripeEncryptionGroupWriteWrapper(
+      proto::orc::StripeEncryptionVariant* stripeFooter)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, stripeFooter) {}
+
+  void encoding(
+      std::vector<ColumnEncodingWrapper>& columnEncodingWrappers) const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    for (const proto::ColumnEncoding& encoding : dwrfPtr()->encoding()) {
+      auto ce = ColumnEncodingWrapper(&encoding);
+      columnEncodingWrappers.emplace_back(ce);
+    }
+  }
+
+  ColumnEncodingWriteWrapper addEncoding() {
+    return format_ == DwrfFormat::kDwrf
+        ? ColumnEncodingWriteWrapper(dwrfPtr()->add_encoding())
+        : ColumnEncodingWriteWrapper(orcPtr()->add_encoding());
+  }
+
+  StreamWriteWrapper addStreams() {
+    return format_ == DwrfFormat::kDwrf
+        ? StreamWriteWrapper(dwrfPtr()->add_streams())
+        : StreamWriteWrapper(orcPtr()->add_streams());
+  }
+
+  void SerializeToZeroCopyStream(
+      dwio::common::BufferedOutputStream* output) const {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->SerializeToZeroCopyStream(output)
+                                 : orcPtr()->SerializeToZeroCopyStream(output);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::StripeEncryptionGroup* dwrfPtr() const {
+    return reinterpret_cast<proto::StripeEncryptionGroup*>(rawProtoPtr());
+  }
+  inline proto::orc::StripeEncryptionVariant* orcPtr() const {
+    return reinterpret_cast<proto::orc::StripeEncryptionVariant*>(
+        rawProtoPtr());
+  }
+};
+
+class StripeFooterWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit StripeFooterWriteWrapper(proto::StripeFooter* stripeFooter)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, stripeFooter) {}
+
+  explicit StripeFooterWriteWrapper(proto::orc::StripeFooter* stripeFooter)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, stripeFooter) {}
+
+  void encoding(
+      std::vector<ColumnEncodingWrapper>& columnEncodingWrappers) const {
+    if (format_ == DwrfFormat::kDwrf) {
+      for (const proto::ColumnEncoding& encoding : dwrfPtr()->encoding()) {
+        auto ce = ColumnEncodingWrapper(&encoding);
+        columnEncodingWrappers.emplace_back(ce);
+      }
+    } else {
+      for (const proto::orc::ColumnEncoding& encoding : orcPtr()->columns()) {
+        auto ce = ColumnEncodingWrapper(&encoding);
+        columnEncodingWrappers.emplace_back(ce);
+      }
+    }
+  }
+
+  void setWriterTimezone() const {
+    if (format_ == DwrfFormat::kOrc) {
+      // orcPtr()->set_writertimezone("Asia/Shanghai");
+    }
+  }
+
+  StreamWriteWrapper addStreams() {
+    return format_ == DwrfFormat::kDwrf
+        ? StreamWriteWrapper(dwrfPtr()->add_streams())
+        : StreamWriteWrapper(orcPtr()->add_streams());
+  }
+
+  std::string* addEncryptionGroups() {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->add_encryptiongroups();
+  }
+
+  ColumnEncodingWriteWrapper addEncoding() {
+    return format_ == DwrfFormat::kDwrf
+        ? ColumnEncodingWriteWrapper(dwrfPtr()->add_encoding())
+        : ColumnEncodingWriteWrapper(orcPtr()->add_columns());
+  }
+
+  void SerializeToZeroCopyStream(
+      dwio::common::BufferedOutputStream* output) const {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->SerializeToZeroCopyStream(output)
+                                 : orcPtr()->SerializeToZeroCopyStream(output);
+  }
+
+  inline proto::StripeFooter* dwrfPtr() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return reinterpret_cast<proto::StripeFooter*>(rawProtoPtr());
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::orc::StripeFooter* orcPtr() const {
+    return reinterpret_cast<proto::orc::StripeFooter*>(rawProtoPtr());
+  }
+};
+
+class PostScriptWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit PostScriptWriteWrapper(proto::PostScript* postScript)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, postScript) {}
+
+  explicit PostScriptWriteWrapper(proto::orc::PostScript* postScript)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, postScript) {}
+
+  void setWriterVersion(uint32_t writerVersion) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_writerversion(writerVersion)
+                                 : orcPtr()->set_writerversion(6);
+  }
+
+  void addVersion(uint32_t version) {
+    if (format_ == DwrfFormat::kOrc) {
+      orcPtr()->add_version(version);
+    }
+  }
+
+  void setFooterLength(uint64_t footerLength) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_footerlength(footerLength)
+                                 : orcPtr()->set_footerlength(footerLength);
+  }
+
+  void setCompression(common::CompressionKind compressionKind);
+
+  void setCompressionBlockSize(uint64_t compressionBlockSize) {
+    format_ == DwrfFormat::kDwrf
+        ? dwrfPtr()->set_compressionblocksize(compressionBlockSize)
+        : orcPtr()->set_compressionblocksize(compressionBlockSize);
+  }
+
+  void setCacheMode(StripeCacheMode cacheMode) {
+    if (format_ == DwrfFormat::kDwrf) {
+      dwrfPtr()->set_cachemode(static_cast<proto::StripeCacheMode>(cacheMode));
+    }
+  }
+
+  void setCacheSize(uint32_t cacheSize) {
+    if (format_ == DwrfFormat::kDwrf) {
+      dwrfPtr()->set_cachesize(cacheSize);
+    }
+  }
+
+  void setMetaDataLength(uint64_t metaDataLength) {
+    if (format_ == DwrfFormat::kOrc) {
+      orcPtr()->set_metadatalength(metaDataLength);
+    }
+  }
+
+  void SerializeToZeroCopyStream(
+      dwio::common::BufferedOutputStream* out) const {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->SerializeToZeroCopyStream(out)
+                                 : orcPtr()->SerializeToZeroCopyStream(out);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::PostScript* dwrfPtr() const {
+    return reinterpret_cast<proto::PostScript*>(rawProtoPtr());
+  }
+  inline proto::orc::PostScript* orcPtr() const {
+    return reinterpret_cast<proto::orc::PostScript*>(rawProtoPtr());
+  }
+};
+
 } // namespace facebook::velox::dwrf
 
 template <>
diff --git a/velox/dwio/dwrf/common/IntEncoder.h b/velox/dwio/dwrf/common/IntEncoder.h
index 1051967bb39..bba9060a183 100644
--- a/velox/dwio/dwrf/common/IntEncoder.h
+++ b/velox/dwio/dwrf/common/IntEncoder.h
@@ -341,8 +341,9 @@ template <bool isSigned>
     case 57 ... 63:
       return writeVarint<1>(value, buffer);
   }
-  DWIO_RAISE(folly::sformat(
-      "Unexpected leading zeros {} for value {}", leadingZeros, value));
+  DWIO_RAISE(
+      folly::sformat(
+          "Unexpected leading zeros {} for value {}", leadingZeros, value));
 }
 
 template <bool isSigned>
diff --git a/velox/dwio/dwrf/common/RLEv1.h b/velox/dwio/dwrf/common/RLEv1.h
index 082b57c10e0..62ab5d444f1 100644
--- a/velox/dwio/dwrf/common/RLEv1.h
+++ b/velox/dwio/dwrf/common/RLEv1.h
@@ -417,7 +417,7 @@ class RleDecoderV1 : public dwio::common::IntDecoder<isSigned> {
         rows + rowIndex,
         std::min<int32_t>(remainingValues_, numRows - rowIndex));
     const auto endOfRun = currentRow + remainingValues_;
-    const auto bound = std::lower_bound(range.begin(), range.end(), endOfRun);
+    const auto bound = std::lower_bound(range.cbegin(), range.cend(), endOfRun);
     return std::make_pair(bound - range.begin(), bound[-1] - currentRow + 1);
   }
 
diff --git a/velox/dwio/dwrf/common/Statistics.h b/velox/dwio/dwrf/common/Statistics.h
index 864fb08db37..1fb1e78c2b3 100644
--- a/velox/dwio/dwrf/common/Statistics.h
+++ b/velox/dwio/dwrf/common/Statistics.h
@@ -19,7 +19,6 @@
 #include "velox/dwio/common/Statistics.h"
 #include "velox/dwio/dwrf/common/Common.h"
 #include "velox/dwio/dwrf/common/FileMetadata.h"
-#include "velox/dwio/dwrf/common/wrap/dwrf-proto-wrapper.h"
 
 namespace facebook::velox::dwrf {
 
diff --git a/velox/dwio/dwrf/common/wrap/CMakeLists.txt b/velox/dwio/dwrf/common/wrap/CMakeLists.txt
new file mode 100644
index 00000000000..74e338b7507
--- /dev/null
+++ b/velox/dwio/dwrf/common/wrap/CMakeLists.txt
@@ -0,0 +1,24 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+velox_install_library_headers()
+
+# Wrapper headers — verify these are still needed and correctly included.
+velox_add_library(
+  velox_dwio_dwrf_common_wrap
+  INTERFACE
+  HEADERS
+  coded-stream-wrapper.h
+  dwrf-proto-wrapper.h
+  orc-proto-wrapper.h
+)
diff --git a/velox/dwio/dwrf/reader/CMakeLists.txt b/velox/dwio/dwrf/reader/CMakeLists.txt
index 8b6f04ec962..a5a38a0ab73 100644
--- a/velox/dwio/dwrf/reader/CMakeLists.txt
+++ b/velox/dwio/dwrf/reader/CMakeLists.txt
@@ -34,6 +34,32 @@ velox_add_library(
   StripeDictionaryCache.cpp
   StripeReaderBase.cpp
   StripeStream.cpp
+  HEADERS
+  BinaryStreamReader.h
+  ColumnReader.h
+  ConstantColumnReader.h
+  DwrfData.h
+  DwrfReader.h
+  EncodingContext.h
+  FlatMapColumnReader.h
+  ReaderBase.h
+  SelectiveByteRleColumnReader.h
+  SelectiveDecimalColumnReader.h
+  SelectiveDwrfReader.h
+  SelectiveFlatMapColumnReader.h
+  SelectiveFloatingPointColumnReader.h
+  SelectiveIntegerDictionaryColumnReader.h
+  SelectiveIntegerDirectColumnReader.h
+  SelectiveRepeatedColumnReader.h
+  SelectiveStringDictionaryColumnReader.h
+  SelectiveStringDirectColumnReader.h
+  SelectiveStructColumnReader.h
+  SelectiveTimestampColumnReader.h
+  StreamLabels.h
+  StripeDictionaryCache.h
+  StripeMetadataCache.h
+  StripeReaderBase.h
+  StripeStream.h
 )
 
 velox_link_libraries(
diff --git a/velox/dwio/dwrf/reader/ColumnReader.cpp b/velox/dwio/dwrf/reader/ColumnReader.cpp
index 5699694ef7b..0e20372722c 100644
--- a/velox/dwio/dwrf/reader/ColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/ColumnReader.cpp
@@ -1311,7 +1311,7 @@ void StringDictionaryColumnReader::loadStrideDictionary() {
   if (strideDictCount_ > 0) {
     // seek stride dictionary related streams
     std::vector<uint64_t> pos(
-        positions.begin() + positionOffset_, positions.end());
+        positions.cbegin() + positionOffset_, positions.cend());
     dwio::common::PositionProvider pp(pos);
     strideDictStream_->seekToPosition(pp);
     strideDictLengthDecoder_->seekToRowGroup(pp);
@@ -2461,8 +2461,9 @@ std::unique_ptr<ColumnReader> buildByteRleColumnReader(
           RleDecoderFactory<DataT>::get(),
           std::move(flatMapContext));
     default:
-      DWIO_RAISE(fmt::format(
-          "Unsupported upcast to typekind: {}", requestedType->toString()));
+      DWIO_RAISE(
+          fmt::format(
+              "Unsupported upcast to typekind: {}", requestedType->toString()));
   }
 }
 
@@ -2502,9 +2503,10 @@ std::unique_ptr<ColumnReader> buildTypedIntegerColumnReader(
           numBytes,
           std::move(flatMapContext));
     default:
-      DWIO_RAISE(fmt::format(
-          "Unsupported requested integral type: {}",
-          requestedType->toString()));
+      DWIO_RAISE(
+          fmt::format(
+              "Unsupported requested integral type: {}",
+              requestedType->toString()));
   }
 }
 
diff --git a/velox/dwio/dwrf/reader/DwrfData.h b/velox/dwio/dwrf/reader/DwrfData.h
index b4237fef8b9..04fa978a96e 100644
--- a/velox/dwio/dwrf/reader/DwrfData.h
+++ b/velox/dwio/dwrf/reader/DwrfData.h
@@ -100,7 +100,7 @@ class DwrfData : public dwio::common::FormatData {
   static std::vector<uint64_t> toPositionsInner(
       const proto::RowIndexEntry& entry) {
     return std::vector<uint64_t>(
-        entry.positions().begin(), entry.positions().end());
+        entry.positions().cbegin(), entry.positions().cend());
   }
 
   memory::MemoryPool& memoryPool_;
diff --git a/velox/dwio/dwrf/reader/DwrfReader.cpp b/velox/dwio/dwrf/reader/DwrfReader.cpp
index 4f0ca050d58..db2d33b7751 100644
--- a/velox/dwio/dwrf/reader/DwrfReader.cpp
+++ b/velox/dwio/dwrf/reader/DwrfReader.cpp
@@ -19,6 +19,7 @@
 #include <chrono>
 
 #include "velox/dwio/common/OnDemandUnitLoader.h"
+#include "velox/dwio/common/ParallelUnitLoader.h"
 #include "velox/dwio/common/TypeUtils.h"
 #include "velox/dwio/common/exception/Exception.h"
 #include "velox/dwio/dwrf/reader/ColumnReader.h"
@@ -38,24 +39,25 @@ using dwio::common::UnitLoaderFactory;
 class DwrfUnit : public LoadUnit {
  public:
   DwrfUnit(
-      const StripeReaderBase& stripeReaderBase,
+      std::shared_ptr<ReaderBase> readerBase,
       const StrideIndexProvider& strideIndexProvider,
-      dwio::common::ColumnReaderStatistics& columnReaderStatistics,
+      std::shared_ptr<dwio::common::ColumnReaderStatistics> columnReaderStats,
       uint32_t stripeIndex,
       std::shared_ptr<dwio::common::ColumnSelector> columnSelector,
-      const std::shared_ptr<BitSet>& projectedNodes,
+      std::shared_ptr<BitSet> projectedNodes,
       RowReaderOptions options,
-      const dwio::common::ColumnReaderOptions& columnReaderOptions)
-      : stripeReaderBase_{stripeReaderBase},
+      dwio::common::ColumnReaderOptions columnReaderOptions)
+      : stripeReaderBase_{readerBase},
+        memoryPool_(readerBase->memoryPool().shared_from_this()),
         strideIndexProvider_{strideIndexProvider},
-        columnReaderStatistics_{&columnReaderStatistics},
+        columnReaderStats_{std::move(columnReaderStats)},
         stripeIndex_{stripeIndex},
         columnSelector_{std::move(columnSelector)},
-        projectedNodes_{projectedNodes},
+        projectedNodes_{std::move(projectedNodes)},
         options_{std::move(options)},
-        columnReaderOptions_{columnReaderOptions},
+        columnReaderOptions_{std::move(columnReaderOptions)},
         stripeInfo_{
-            stripeReaderBase.getReader().footer().stripes(stripeIndex_)} {}
+            stripeReaderBase_.getReader().footer().stripes(stripeIndex_)} {}
 
   ~DwrfUnit() override = default;
 
@@ -85,14 +87,25 @@ class DwrfUnit : public LoadUnit {
   void loadDecoders();
 
   // Immutables
-  const StripeReaderBase& stripeReaderBase_;
+  const StripeReaderBase stripeReaderBase_;
+  // Not used in DwrfUnit directly, it is to keep memory pool alive for
+  // readerBase
+  const std::shared_ptr<memory::MemoryPool> memoryPool_;
+
+  // SAFETY: This reference is safe despite DwrfUnit potentially outliving
+  // DwrfRowReader during async operations. The reference is only STORED (not
+  // dereferenced) during load() path. Actual dereferencing via
+  // getStrideIndex() only happens during synchronous data reading in
+  // ColumnReader::next(), where DwrfRowReader is guaranteed to be alive.
   const StrideIndexProvider& strideIndexProvider_;
-  dwio::common::ColumnReaderStatistics* const columnReaderStatistics_;
+
+  const std::shared_ptr<dwio::common::ColumnReaderStatistics>
+      columnReaderStats_;
   const uint32_t stripeIndex_;
   const std::shared_ptr<dwio::common::ColumnSelector> columnSelector_;
   const std::shared_ptr<BitSet> projectedNodes_;
   const RowReaderOptions options_;
-  const dwio::common::ColumnReaderOptions& columnReaderOptions_;
+  const dwio::common::ColumnReaderOptions columnReaderOptions_;
   const StripeInformationWrapper stripeInfo_;
 
   // Mutables
@@ -152,7 +165,8 @@ void DwrfUnit::ensureDecoders() {
       stripeInfo_.offset(),
       stripeInfo_.numberOfRows(),
       strideIndexProvider_,
-      stripeIndex_);
+      stripeIndex_,
+      columnReaderStats_.get());
 
   auto* scanSpec = options_.scanSpec().get();
   const auto& fileType = stripeReaderBase_.getReader().schemaWithId();
@@ -168,7 +182,7 @@ void DwrfUnit::ensureDecoders() {
         fileType,
         *stripeStreams_,
         streamLabels,
-        *columnReaderStatistics_,
+        *columnReaderStats_,
         scanSpec,
         flatMapContext,
         /*isRoot=*/true);
@@ -227,6 +241,15 @@ void makeProjectedNodes(
   }
 }
 
+const velox::common::ScanSpec* getChildScanSpec(
+    const velox::common::ScanSpec* scanSpec,
+    const TypeWrapper& nodeType,
+    int32_t childIdx) {
+  return scanSpec != nullptr && childIdx < nodeType.fieldNamesSize()
+      ? scanSpec->childByName(nodeType.fieldNames(childIdx))
+      : nullptr;
+}
+
 } // namespace
 
 DwrfRowReader::DwrfRowReader(
@@ -242,7 +265,11 @@ DwrfRowReader::DwrfRowReader(
                     reader->schema()))},
       decodingTimeCallback_{options_.decodingTimeCallback()},
       strideIndex_{0},
+      columnReaderStats_(
+          std::make_shared<dwio::common::ColumnReaderStatistics>()),
       currentUnit_{nullptr} {
+  columnReaderStats_->initColumnStatsCollection(
+      *getReader().schemaWithId(), options_);
   const auto& fileFooter = getReader().footer();
   const uint32_t numberOfStripes = fileFooter.stripesSize();
   currentStripe_ = numberOfStripes;
@@ -328,22 +355,30 @@ std::unique_ptr<dwio::common::UnitLoader> DwrfRowReader::getUnitLoader() {
   std::vector<std::unique_ptr<LoadUnit>> loadUnits;
   loadUnits.reserve(stripeCeiling_ - firstStripe_);
   for (auto stripe = firstStripe_; stripe < stripeCeiling_; ++stripe) {
-    loadUnits.emplace_back(std::make_unique<DwrfUnit>(
-        /*stripeReaderBase=*/*this,
-        /*strideIndexProvider=*/*this,
-        columnReaderStatistics_,
-        stripe,
-        columnSelector_,
-        projectedNodes_,
-        options_,
-        columnReaderOptions_));
+    loadUnits.emplace_back(
+        std::make_unique<DwrfUnit>(
+            /*readerBase=*/readerBaseShared(),
+            /*strideIndexProvider=*/*this,
+            columnReaderStats_,
+            stripe,
+            columnSelector_,
+            projectedNodes_,
+            options_,
+            columnReaderOptions_));
   }
   std::shared_ptr<UnitLoaderFactory> unitLoaderFactory =
       options_.unitLoaderFactory();
   if (!unitLoaderFactory) {
-    unitLoaderFactory =
-        std::make_shared<dwio::common::OnDemandUnitLoaderFactory>(
-            options_.blockedOnIoCallback());
+    if (loadUnits.size() > 1 && options_.parallelUnitLoadCount() > 1 &&
+        options_.ioExecutor() != nullptr) {
+      unitLoaderFactory =
+          std::make_shared<dwio::common::ParallelUnitLoaderFactory>(
+              options_.ioExecutor(), options_.parallelUnitLoadCount());
+    } else {
+      unitLoaderFactory =
+          std::make_shared<dwio::common::OnDemandUnitLoaderFactory>(
+              options_.blockedOnIoCallback());
+    }
   }
   return unitLoaderFactory->create(std::move(loadUnits), 0);
 }
@@ -567,8 +602,10 @@ int64_t DwrfRowReader::nextRowNumber() {
         const auto skipRows = getReader().randomSkip()->nextSkip();
         if (skipRows >= numStripeRows) {
           getReader().randomSkip()->consume(numStripeRows);
-          const auto numStrides = bits::divRoundUp(numStripeRows, strideSize);
-          skippedStrides_ += numStrides;
+          if (strideSize > 0) {
+            skippedStrides_ += static_cast<int64_t>(
+                bits::divRoundUp(numStripeRows, strideSize));
+          }
           goto advanceToNextStripe;
         }
       }
@@ -578,6 +615,9 @@ int64_t DwrfRowReader::nextRowNumber() {
 
     checkSkipStrides(strideSize);
     if (currentRowInStripe_ < rowsInCurrentStripe_) {
+      if (strideSize > 0 && currentRowInStripe_ % strideSize == 0) {
+        ++processedStrides_;
+      }
       nextRowNumber_ = firstRowOfStripe_[currentStripe_] + currentRowInStripe_;
       return *nextRowNumber_;
     }
@@ -632,6 +672,8 @@ uint64_t DwrfRowReader::next(
     } else {
       previousRow_ = 0;
     }
+    // Collect unit loader stats at the end.
+    unitLoadStats_ = unitLoader_->stats();
     return 0;
   }
 
@@ -668,7 +710,6 @@ void DwrfRowReader::loadCurrentStripe() {
   const auto loadUnitIdx = currentStripe_ - firstStripe_;
   currentUnit_ = castDwrfUnit(&unitLoader_->getLoadedUnit(loadUnitIdx));
   rowsInCurrentStripe_ = currentUnit_->getNumRows();
-  ++processedStrides_;
 }
 
 size_t DwrfRowReader::estimatedReaderMemory() const {
@@ -676,15 +717,17 @@ size_t DwrfRowReader::estimatedReaderMemory() const {
   return 2 * DwrfReader::getMemoryUse(getReader(), -1, *columnSelector_);
 }
 
-bool DwrfRowReader::shouldReadNode(uint32_t nodeId) const {
-  if (columnSelector_) {
-    return columnSelector_->shouldReadNode(nodeId);
-  }
-  return projectedNodes_->contains(nodeId);
+bool DwrfRowReader::shouldReadNode(
+    uint32_t nodeId,
+    const velox::common::ScanSpec* fieldScanSpec) const {
+  bool nodeIdSelected = (columnSelector_)
+      ? columnSelector_->shouldReadNode(nodeId)
+      : projectedNodes_->contains(nodeId);
+  return nodeIdSelected &&
+      !(fieldScanSpec != nullptr && !fieldScanSpec->readFromFile());
 }
 
 namespace {
-
 template <typename T>
 std::optional<uint64_t> getStringOrBinaryColumnSize(
     const dwio::common::ColumnStatistics& stats) {
@@ -703,6 +746,7 @@ std::optional<uint64_t> getStringOrBinaryColumnSize(
 std::optional<size_t> DwrfRowReader::estimatedRowSizeHelper(
     const FooterWrapper& fileFooter,
     const dwio::common::Statistics& stats,
+    const velox::common::ScanSpec* scanSpec,
     uint32_t nodeId) const {
   VELOX_CHECK_LT(nodeId, fileFooter.typesSize(), "Types missing in footer");
 
@@ -757,11 +801,16 @@ std::optional<size_t> DwrfRowReader::estimatedRowSizeHelper(
           ? 0
           : 2 * valueCount * sizeof(vector_size_t);
       for (int32_t i = 0; i < nodeType.subtypesSize(); ++i) {
-        if (!shouldReadNode(nodeType.subtypes(i))) {
+        if (!shouldReadNode(
+                nodeType.subtypes(i),
+                getChildScanSpec(scanSpec, nodeType, i))) {
           continue;
         }
-        const auto subtypeEstimate =
-            estimatedRowSizeHelper(fileFooter, stats, nodeType.subtypes(i));
+        const auto subtypeEstimate = estimatedRowSizeHelper(
+            fileFooter,
+            stats,
+            getChildScanSpec(scanSpec, nodeType, i),
+            nodeType.subtypes(i));
         if (subtypeEstimate.has_value()) {
           totalEstimate += subtypeEstimate.value();
         } else {
@@ -776,26 +825,40 @@ std::optional<size_t> DwrfRowReader::estimatedRowSizeHelper(
 }
 
 std::optional<size_t> DwrfRowReader::estimatedRowSize() const {
+  if (hasRowEstimate_) {
+    return estimatedRowSize_;
+  }
+
   const auto& reader = getReader();
   const auto& fileFooter = reader.footer();
 
+  hasRowEstimate_ = true;
+
   if (!fileFooter.hasNumberOfRows()) {
-    return std::nullopt;
+    estimatedRowSize_ = std::nullopt;
+    return estimatedRowSize_;
   }
 
   if (fileFooter.numberOfRows() < 1) {
-    return 0;
+    estimatedRowSize_ = 0;
+    return estimatedRowSize_;
   }
 
   // Estimate with projections.
   constexpr uint32_t ROOT_NODE_ID = 0;
   const auto stats = reader.statistics();
-  const auto projectedSize =
-      estimatedRowSizeHelper(fileFooter, *stats, ROOT_NODE_ID);
+  const auto projectedSize = estimatedRowSizeHelper(
+      fileFooter,
+      *stats,
+      reader.readerOptions().scanSpec().get(),
+      ROOT_NODE_ID);
   if (projectedSize.has_value()) {
-    return projectedSize.value() / fileFooter.numberOfRows();
+    estimatedRowSize_ = projectedSize.value() / fileFooter.numberOfRows();
+    return estimatedRowSize_;
   }
-  return std::nullopt;
+
+  estimatedRowSize_ = std::nullopt;
+  return estimatedRowSize_;
 }
 
 DwrfReader::DwrfReader(
@@ -817,8 +880,9 @@ DwrfReader::DwrfReader(
 void DwrfReader::updateColumnNamesFromTableSchema() {
   const auto& tableSchema = readerBase_->readerOptions().fileSchema();
   const auto& fileSchema = readerBase_->schema();
-  readerBase_->setSchema(std::dynamic_pointer_cast<const RowType>(
-      updateColumnNames(fileSchema, tableSchema)));
+  readerBase_->setSchema(
+      std::dynamic_pointer_cast<const RowType>(
+          updateColumnNames(fileSchema, tableSchema)));
 }
 
 std::unique_ptr<StripeInformation> DwrfReader::getStripe(
@@ -990,8 +1054,8 @@ uint64_t DwrfReader::getMemoryUse(
 
   // Do we need even more memory to read the footer or the metadata?
   const auto footerLength = readerBase.postScript().footerLength();
-  if (memoryBytes < footerLength + readerBase.footerEstimatedSize()) {
-    memoryBytes = footerLength + readerBase.footerEstimatedSize();
+  if (memoryBytes < footerLength + readerBase.footerSpeculativeIoSize()) {
+    memoryBytes = footerLength + readerBase.footerSpeculativeIoSize();
   }
 
   // Account for firstRowOfStripe.
diff --git a/velox/dwio/dwrf/reader/DwrfReader.h b/velox/dwio/dwrf/reader/DwrfReader.h
index dcb38dbb5a1..6dbae5615df 100644
--- a/velox/dwio/dwrf/reader/DwrfReader.h
+++ b/velox/dwio/dwrf/reader/DwrfReader.h
@@ -111,8 +111,8 @@ class DwrfRowReader : public StrideIndexProvider,
     stats.processedStrides += processedStrides_;
     stats.footerBufferOverread += getReader().footerBufferOverread();
     stats.numStripes += stripeCeiling_ - firstStripe_;
-    stats.columnReaderStatistics.flattenStringDictionaryValues +=
-        columnReaderStatistics_.flattenStringDictionaryValues;
+    stats.columnReaderStats.mergeFrom(*columnReaderStats_);
+    stats.unitLoaderStats.merge(unitLoadStats_);
   }
 
   void resetFilterCaches() override;
@@ -148,11 +148,14 @@ class DwrfRowReader : public StrideIndexProvider,
   }
 
  private:
-  bool shouldReadNode(uint32_t nodeId) const;
+  bool shouldReadNode(
+      uint32_t nodeId,
+      const velox::common::ScanSpec* fieldScanSpec) const;
 
   std::optional<size_t> estimatedRowSizeHelper(
       const FooterWrapper& fileFooter,
       const dwio::common::Statistics& stats,
+      const velox::common::ScanSpec* scanSpec,
       uint32_t nodeId) const;
 
   bool emptyFile() const {
@@ -210,17 +213,22 @@ class DwrfRowReader : public StrideIndexProvider,
   // Number of processed strides.
   int64_t processedStrides_{0};
 
+  dwio::common::UnitLoaderStats unitLoadStats_;
+
   // Set to true after clearing filter caches, i.e. adding a dynamic filter.
   // Causes filters to be re-evaluated against stride stats on next stride
   // instead of next stripe.
   bool recomputeStridesToSkip_{false};
 
-  dwio::common::ColumnReaderStatistics columnReaderStatistics_;
+  std::shared_ptr<dwio::common::ColumnReaderStatistics> columnReaderStats_;
 
   std::optional<int64_t> nextRowNumber_;
 
   std::unique_ptr<dwio::common::UnitLoader> unitLoader_;
   DwrfUnit* currentUnit_;
+
+  mutable std::optional<size_t> estimatedRowSize_;
+  mutable bool hasRowEstimate_{false};
 };
 
 class DwrfReader : public dwio::common::Reader {
diff --git a/velox/dwio/dwrf/reader/FlatMapColumnReader.cpp b/velox/dwio/dwrf/reader/FlatMapColumnReader.cpp
index 22f7220e853..d1a611755bf 100644
--- a/velox/dwio/dwrf/reader/FlatMapColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/FlatMapColumnReader.cpp
@@ -163,12 +163,13 @@ std::vector<std::unique_ptr<KeyNode<T>>> getKeyNodesFiltered(
                 .inMapDecoder = inMapDecoder.get(),
                 .keySelectionCallback = nullptr});
 
-        keyNodes.push_back(std::make_unique<KeyNode<T>>(
-            std::move(valueReader),
-            std::move(inMapDecoder),
-            key,
-            sequence,
-            memoryPool));
+        keyNodes.push_back(
+            std::make_unique<KeyNode<T>>(
+                std::move(valueReader),
+                std::move(inMapDecoder),
+                key,
+                sequence,
+                memoryPool));
       });
 
   keySelectionStats.selectedKeys = keyNodes.size();
diff --git a/velox/dwio/dwrf/reader/ReaderBase.cpp b/velox/dwio/dwrf/reader/ReaderBase.cpp
index c52dcf871a7..2462ed735d9 100644
--- a/velox/dwio/dwrf/reader/ReaderBase.cpp
+++ b/velox/dwio/dwrf/reader/ReaderBase.cpp
@@ -19,12 +19,14 @@
 #include <fmt/format.h>
 
 #include "velox/common/process/TraceContext.h"
+#include "velox/dwio/common/Arena.h"
 #include "velox/dwio/common/Mutation.h"
 #include "velox/dwio/common/exception/Exception.h"
 #include "velox/functions/lib/string/StringImpl.h"
 
 namespace facebook::velox::dwrf {
 
+using dwio::common::ArenaCreate;
 using dwio::common::ColumnStatistics;
 using dwio::common::FileFormat;
 using dwio::common::LogType;
@@ -77,12 +79,6 @@ FooterStatisticsImpl::FooterStatisticsImpl(
   }
 }
 
-ReaderBase::ReaderBase(
-    MemoryPool& pool,
-    std::unique_ptr<dwio::common::BufferedInput> input,
-    FileFormat fileFormat)
-    : ReaderBase(createReaderOptions(pool, fileFormat), std::move(input)) {}
-
 namespace {
 
 template <typename T>
@@ -96,7 +92,7 @@ template <typename T>
 std::unique_ptr<FooterWrapper> parseFooter(
     dwio::common::SeekableInputStream* input,
     google::protobuf::Arena* arena) {
-  auto* impl = google::protobuf::Arena::CreateMessage<T>(arena);
+  auto* impl = ArenaCreate<T>(arena);
   VELOX_CHECK(impl->ParseFromZeroCopyStream(input));
   return std::make_unique<FooterWrapper>(impl);
 }
@@ -115,15 +111,14 @@ ReaderBase::ReaderBase(
   DWIO_ENSURE(fileLength_ > 0, "ORC file is empty");
   VELOX_CHECK_GE(fileLength_, 4, "File size too small");
 
-  const auto preloadFile = fileLength_ <= options_.filePreloadThreshold();
-  const int64_t footerBufSize =
-      std::min(fileLength_, options_.footerEstimatedSize());
-  const uint64_t readSize = preloadFile ? fileLength_ : footerBufSize;
-  if (input_->supportSyncLoad()) {
-    input_->enqueue({fileLength_ - readSize, readSize, "footer"});
-    input_->load(preloadFile ? LogType::FILE : LogType::FOOTER);
+  // Preload small files: one IO for entire file, serving all subsequent reads.
+  if (fileLength_ <= options_.filePreloadThreshold()) {
+    input_->preload();
   }
 
+  const int64_t footerBufSize =
+      std::min(fileLength_, options_.footerSpeculativeIoSize());
+
   // TODO: read footer from spectrum
   auto footerBuffer =
       AlignedBuffer::allocate<char>(footerBufSize, &options_.memoryPool());
@@ -170,11 +165,6 @@ ReaderBase::ReaderBase(
       "Corrupted File, invalid compression kind ",
       postScript_->compression());
 
-  if (input_->supportSyncLoad() && (tailSize > readSize)) {
-    input_->enqueue({fileLength_ - tailSize, tailSize, "footer"});
-    input_->load(LogType::FOOTER);
-  }
-
   BufferPtr fullFooterBuffer;
   char* footerStart;
   if (footerOffset >= footerSize) {
diff --git a/velox/dwio/dwrf/reader/ReaderBase.h b/velox/dwio/dwrf/reader/ReaderBase.h
index 561d88e5684..8a90bdaf0d8 100644
--- a/velox/dwio/dwrf/reader/ReaderBase.h
+++ b/velox/dwio/dwrf/reader/ReaderBase.h
@@ -20,10 +20,10 @@
 #include "velox/dwio/common/BufferedInput.h"
 #include "velox/dwio/common/Options.h"
 #include "velox/dwio/common/SeekableInputStream.h"
+#include "velox/dwio/common/Statistics.h"
 #include "velox/dwio/common/TypeWithId.h"
 #include "velox/dwio/dwrf/common/Compression.h"
 #include "velox/dwio/dwrf/common/Decryption.h"
-#include "velox/dwio/dwrf/common/FileMetadata.h"
 #include "velox/dwio/dwrf/common/Statistics.h"
 #include "velox/dwio/dwrf/reader/StripeMetadataCache.h"
 #include "velox/dwio/dwrf/utils/ProtoUtils.h"
@@ -65,22 +65,22 @@ class ReaderBase {
       const dwio::common::ReaderOptions& options,
       std::unique_ptr<dwio::common::BufferedInput> input);
 
-  /// Creates reader base from buffered input.
-  /// It is kept here for backward compatibility with Meta's internal usage.
-  ReaderBase(
-      memory::MemoryPool& pool,
-      std::unique_ptr<dwio::common::BufferedInput> input,
-      dwio::common::FileFormat fileFormat = dwio::common::FileFormat::DWRF);
-
-  /// Creates reader base from metadata.
+  /// Creates reader base from metadata (for testing).
   ReaderBase(
       memory::MemoryPool& pool,
       std::unique_ptr<dwio::common::BufferedInput> input,
       std::unique_ptr<PostScript> ps,
       const proto::Footer* footer,
       std::unique_ptr<StripeMetadataCache> cache,
-      std::unique_ptr<encryption::DecryptionHandler> handler = nullptr)
-      : options_{dwio::common::ReaderOptions(&pool)},
+      std::unique_ptr<encryption::DecryptionHandler> handler,
+      std::shared_ptr<io::IoStatistics> dataIoStats = nullptr,
+      std::shared_ptr<io::IoStatistics> metadataIoStats = nullptr)
+      : options_{[&] {
+          dwio::common::ReaderOptions opts(&pool);
+          opts.setDataIoStats(std::move(dataIoStats));
+          opts.setMetadataIoStats(std::move(metadataIoStats));
+          return opts;
+        }()},
         input_{std::move(input)},
         fileLength_{0},
         postScript_{std::move(ps)},
@@ -160,8 +160,8 @@ class ReaderBase {
     return *handler_;
   }
 
-  uint64_t footerEstimatedSize() const {
-    return options_.footerEstimatedSize();
+  uint64_t footerSpeculativeIoSize() const {
+    return options_.footerSpeculativeIoSize();
   }
 
   uint64_t fileLength() const {
@@ -199,7 +199,7 @@ class ReaderBase {
   const std::string& writerName() const {
     for (int32_t index = 0; index < footer_->metadataSize(); ++index) {
       auto entry = footer_->metadata(index);
-      if (entry.name() == WRITER_NAME_KEY) {
+      if (entry.name() == kWriterNameKey) {
         return entry.value();
       }
     }
@@ -216,14 +216,16 @@ class ReaderBase {
   std::unique_ptr<dwio::common::SeekableInputStream> createDecompressedStream(
       std::unique_ptr<dwio::common::SeekableInputStream> compressed,
       const std::string& streamDebugInfo,
-      const dwio::common::encryption::Decrypter* decrypter = nullptr) const {
+      const dwio::common::encryption::Decrypter* decrypter = nullptr,
+      velox::io::IoCounter* decompressCounter = nullptr) const {
     return createDecompressor(
         compressionKind(),
         std::move(compressed),
         compressionBlockSize(),
         options_.memoryPool(),
         streamDebugInfo,
-        decrypter);
+        decrypter,
+        decompressCounter);
   }
 
   template <typename T>
@@ -258,14 +260,6 @@ class ReaderBase {
       uint32_t index = 0,
       bool fileColumnNamesReadAsLowerCase = false);
 
-  static dwio::common::ReaderOptions createReaderOptions(
-      memory::MemoryPool& pool,
-      dwio::common::FileFormat fileFormat) {
-    dwio::common::ReaderOptions options(&pool);
-    options.setFileFormat(fileFormat);
-    return options;
-  }
-
   const dwio::common::ReaderOptions options_;
   const std::unique_ptr<dwio::common::BufferedInput> input_;
   const uint64_t fileLength_;
@@ -282,7 +276,7 @@ class ReaderBase {
   RowTypePtr schema_;
   // Lazily populated
   mutable std::shared_ptr<const dwio::common::TypeWithId> schemaWithId_;
-  uint64_t psLength_;
+  uint64_t psLength_{};
 };
 
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.cpp
index ec570ae05b7..09cdd6cd87e 100644
--- a/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.cpp
@@ -20,10 +20,19 @@ namespace facebook::velox::dwrf {
 
 template <typename DataT>
 SelectiveDecimalColumnReader<DataT>::SelectiveDecimalColumnReader(
+    const TypePtr& requestedType,
     const std::shared_ptr<const TypeWithId>& fileType,
     DwrfParams& params,
     common::ScanSpec& scanSpec)
-    : SelectiveColumnReader(fileType->type(), fileType, params, scanSpec) {
+    // Read using requestedType so that values are materialized at the
+    // table-schema scale rather than the file-footer scale. See the header
+    // comment for the Hive ORC DECIMAL(38, 18) footer behavior this works
+    // around.
+    : SelectiveColumnReader(requestedType, fileType, params, scanSpec) {
+  VELOX_CHECK(
+      requestedType_->isDecimal(),
+      "SelectiveDecimalColumnReader requires a decimal requestedType, got {}",
+      requestedType_->toString());
   EncodingKey encodingKey{fileType_->id(), params.flatMapContext().sequence};
   auto& stripe = params.stripeStreams();
   if constexpr (std::is_same_v<DataT, std::int64_t>) {
@@ -51,7 +60,7 @@ SelectiveDecimalColumnReader<DataT>::SelectiveDecimalColumnReader(
   scaleDecoder_ = createRleDecoder</*isSigned*/ true>(
       stripe.getStream(secondary, params.streamLabels().label(), true),
       version_,
-      *memoryPool_,
+      *pool_,
       stripe.getUseVInts(secondary),
       LONG_BYTE_SIZE);
 }
@@ -75,16 +84,17 @@ void SelectiveDecimalColumnReader<DataT>::seekToRowGroup(int64_t index) {
 
 template <typename DataT>
 template <bool kDense>
-void SelectiveDecimalColumnReader<DataT>::readHelper(RowSet rows) {
-  vector_size_t numRows = rows.back() + 1;
+void SelectiveDecimalColumnReader<DataT>::readHelper(
+    const common::Filter* filter,
+    RowSet rows) {
   ExtractToReader extractValues(this);
-  common::AlwaysTrue filter;
+  common::AlwaysTrue alwaysTrue;
   DirectRleColumnVisitor<
       int64_t,
       common::AlwaysTrue,
       decltype(extractValues),
       kDense>
-      visitor(filter, this, rows, extractValues);
+      visitor(alwaysTrue, this, rows, extractValues);
 
   // decode scale stream
   if (version_ == velox::dwrf::RleVersion_1) {
@@ -94,7 +104,7 @@ void SelectiveDecimalColumnReader<DataT>::readHelper(RowSet rows) {
   }
 
   // copy scales into scaleBuffer_
-  ensureCapacity<int64_t>(scaleBuffer_, numValues_, memoryPool_);
+  ensureCapacity<int64_t>(scaleBuffer_, numValues_, pool_);
   scaleBuffer_->setSize(numValues_ * sizeof(int64_t));
   memcpy(
       scaleBuffer_->asMutable<char>(),
@@ -104,14 +114,135 @@ void SelectiveDecimalColumnReader<DataT>::readHelper(RowSet rows) {
   // reset numValues_ before reading values
   numValues_ = 0;
   valueSize_ = sizeof(DataT);
+  vector_size_t numRows = rows.back() + 1;
   ensureValuesCapacity<DataT>(numRows);
 
   // decode value stream
   facebook::velox::dwio::common::
       ColumnVisitor<DataT, common::AlwaysTrue, decltype(extractValues), kDense>
-          valueVisitor(filter, this, rows, extractValues);
+          valueVisitor(alwaysTrue, this, rows, extractValues);
   decodeWithVisitor<DirectDecoder<true>>(valueDecoder_.get(), valueVisitor);
   readOffset_ += numRows;
+
+  // Fill decimals before applying filter.
+  fillDecimals();
+
+  // 'nullsInReadRange_' is the nulls for the entire read range, and if the row
+  // set is not dense, result nulls should be allocated, which represents the
+  // nulls for the selected rows before filtering.
+  const auto rawNulls = nullsInReadRange_
+      ? (kDense ? nullsInReadRange_->as<uint64_t>() : rawResultNulls_)
+      : nullptr;
+  // Process filter.
+  process(filter, rows, rawNulls);
+}
+
+template <typename DataT>
+void SelectiveDecimalColumnReader<DataT>::processNulls(
+    bool isNull,
+    const RowSet& rows,
+    const uint64_t* rawNulls) {
+  if (!rawNulls) {
+    return;
+  }
+  returnReaderNulls_ = false;
+  anyNulls_ = !isNull;
+  allNull_ = isNull;
+
+  auto rawDecimal = values_->asMutable<DataT>();
+  auto rawScale = scaleBuffer_->asMutable<int64_t>();
+
+  vector_size_t idx = 0;
+  if (isNull) {
+    for (vector_size_t i = 0; i < numValues_; i++) {
+      if (bits::isBitNull(rawNulls, i)) {
+        bits::setNull(rawResultNulls_, idx);
+        addOutputRow(rows[i]);
+        idx++;
+      }
+    }
+  } else {
+    for (vector_size_t i = 0; i < numValues_; i++) {
+      if (!bits::isBitNull(rawNulls, i)) {
+        bits::setNull(rawResultNulls_, idx, false);
+        rawDecimal[idx] = rawDecimal[i];
+        rawScale[idx] = rawScale[i];
+        addOutputRow(rows[i]);
+        idx++;
+      }
+    }
+  }
+}
+
+template <typename DataT>
+void SelectiveDecimalColumnReader<DataT>::processFilter(
+    const common::Filter* filter,
+    const RowSet& rows,
+    const uint64_t* rawNulls) {
+  VELOX_CHECK_NOT_NULL(filter, "Filter must not be null.");
+  returnReaderNulls_ = false;
+  anyNulls_ = false;
+  allNull_ = true;
+
+  vector_size_t idx = 0;
+  auto rawDecimal = values_->asMutable<DataT>();
+  for (vector_size_t i = 0; i < numValues_; i++) {
+    if (rawNulls && bits::isBitNull(rawNulls, i)) {
+      if (filter->testNull()) {
+        bits::setNull(rawResultNulls_, idx);
+        addOutputRow(rows[i]);
+        anyNulls_ = true;
+        idx++;
+      }
+    } else {
+      bool tested;
+      if constexpr (std::is_same_v<DataT, int64_t>) {
+        tested = filter->testInt64(rawDecimal[i]);
+      } else {
+        tested = filter->testInt128(rawDecimal[i]);
+      }
+
+      if (tested) {
+        if (rawNulls) {
+          bits::setNull(rawResultNulls_, idx, false);
+        }
+        rawDecimal[idx] = rawDecimal[i];
+        addOutputRow(rows[i]);
+        allNull_ = false;
+        idx++;
+      }
+    }
+  }
+}
+
+template <typename DataT>
+void SelectiveDecimalColumnReader<DataT>::process(
+    const common::Filter* filter,
+    const RowSet& rows,
+    const uint64_t* rawNulls) {
+  if (!filter) {
+    // No filter and "hasDeletion" is false so input rows will be
+    // reused.
+    return;
+  }
+
+  switch (filter->kind()) {
+    case common::FilterKind::kIsNull:
+      processNulls(true, rows, rawNulls);
+      break;
+    case common::FilterKind::kIsNotNull: {
+      if (rawNulls) {
+        processNulls(false, rows, rawNulls);
+      } else {
+        for (vector_size_t i = 0; i < numValues_; i++) {
+          addOutputRow(rows[i]);
+        }
+      }
+      break;
+    }
+    default:
+      processFilter(filter, rows, rawNulls);
+  }
 }
 
 template <typename DataT>
@@ -119,14 +250,23 @@ void SelectiveDecimalColumnReader<DataT>::read(
     int64_t offset,
     const RowSet& rows,
     const uint64_t* incomingNulls) {
-  VELOX_CHECK(!scanSpec_->filter());
   VELOX_CHECK(!scanSpec_->valueHook());
   prepareRead<int64_t>(offset, rows, incomingNulls);
+  if (!scanSpec_->keepValues() && scanSpec_->filter() &&
+      (!resultNulls_ || !resultNulls_->unique() ||
+       resultNulls_->capacity() * 8 < rows.size())) {
+    // Make sure a dedicated resultNulls_ is allocated with enough capacity as
+    // RleDecoder always assumes it is available and 'prepareRead' skips
+    // allocation when the column is not projected.
+    resultNulls_ = AlignedBuffer::allocate<bool>(rows.size(), pool_);
+    rawResultNulls_ = resultNulls_->asMutable<uint64_t>();
+  }
+  rawValues_ = values_->asMutable<char>();
   bool isDense = rows.back() == rows.size() - 1;
   if (isDense) {
-    readHelper<true>(rows);
+    readHelper<true>(scanSpec_->filter(), rows);
   } else {
-    readHelper<false>(rows);
+    readHelper<false>(scanSpec_->filter(), rows);
   }
 }
 
@@ -134,16 +274,17 @@ template <typename DataT>
 void SelectiveDecimalColumnReader<DataT>::getValues(
     const RowSet& rows,
     VectorPtr* result) {
+  getIntValues(rows, requestedType_, result);
+}
+
+template <typename DataT>
+void SelectiveDecimalColumnReader<DataT>::fillDecimals() {
   auto nullsPtr =
       resultNulls() ? resultNulls()->template as<uint64_t>() : nullptr;
   auto scales = scaleBuffer_->as<int64_t>();
   auto values = values_->asMutable<DataT>();
-
   DecimalUtil::fillDecimals<DataT>(
       values, nullsPtr, values, scales, numValues_, scale_);
-
-  rawValues_ = values_->asMutable<char>();
-  getIntValues(rows, requestedType_, result);
 }
 
 template class SelectiveDecimalColumnReader<int64_t>;
diff --git a/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.h b/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.h
index 67a82b051e3..a770fd2d9cd 100644
--- a/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.h
+++ b/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.h
@@ -28,7 +28,16 @@ using namespace dwio::common;
 template <typename DataT>
 class SelectiveDecimalColumnReader : public SelectiveColumnReader {
  public:
+  // requestedType is the DECIMAL type to materialize values as. It must be a
+  // decimal type. Hive's ORC writer always records DECIMAL(38, 18) in the
+  // file footer regardless of the metastore-declared precision/scale; the
+  // per-row scale at which each value was actually written lives in the
+  // SECONDARY (a.k.a. NANO_DATA) stream. The reader uses
+  // requestedType.scale() (the table-schema scale) as the target scale and
+  // rescales each value from its per-row scale, so the output matches what
+  // table consumers expect even when the file footer scale differs.
   SelectiveDecimalColumnReader(
+      const TypePtr& requestedType,
       const std::shared_ptr<const TypeWithId>& fileType,
       DwrfParams& params,
       common::ScanSpec& scanSpec);
@@ -49,7 +58,24 @@ class SelectiveDecimalColumnReader : public SelectiveColumnReader {
 
  private:
   template <bool kDense>
-  void readHelper(RowSet rows);
+  void readHelper(const common::Filter* filter, RowSet rows);
+
+  // Process IsNull and IsNotNull filters.
+  void processNulls(bool isNull, const RowSet& rows, const uint64_t* rawNulls);
+
+  // Process filters on decimal values.
+  void processFilter(
+      const common::Filter* filter,
+      const RowSet& rows,
+      const uint64_t* rawNulls);
+
+  // Dispatch to the respective filter processing based on the filter type.
+  void process(
+      const common::Filter* filter,
+      const RowSet& rows,
+      const uint64_t* rawNulls);
+
+  void fillDecimals();
 
   std::unique_ptr<IntDecoder<true>> valueDecoder_;
   std::unique_ptr<IntDecoder<true>> scaleDecoder_;
diff --git a/velox/dwio/dwrf/reader/SelectiveDwrfReader.cpp b/velox/dwio/dwrf/reader/SelectiveDwrfReader.cpp
index 05c16970ad9..dd12ff7ff04 100644
--- a/velox/dwio/dwrf/reader/SelectiveDwrfReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveDwrfReader.cpp
@@ -81,7 +81,7 @@ std::unique_ptr<SelectiveColumnReader> SelectiveDwrfReader::build(
     case TypeKind::BIGINT:
       if (fileType->type()->isDecimal()) {
         return std::make_unique<SelectiveDecimalColumnReader<int64_t>>(
-            fileType, params, scanSpec);
+            requestedType, fileType, params, scanSpec);
       } else {
         return buildIntegerReader(
             requestedType, fileType, params, LONG_BYTE_SIZE, scanSpec);
@@ -99,6 +99,10 @@ std::unique_ptr<SelectiveColumnReader> SelectiveDwrfReader::build(
         return createSelectiveFlatMapColumnReader(
             columnReaderOptions, requestedType, fileType, params, scanSpec);
       }
+      if (scanSpec.isFlatMapAsStruct()) {
+        return std::make_unique<SelectiveMapAsStructColumnReader>(
+            columnReaderOptions, requestedType, fileType, params, scanSpec);
+      }
       return std::make_unique<SelectiveMapColumnReader>(
           columnReaderOptions, requestedType, fileType, params, scanSpec);
     case TypeKind::REAL:
@@ -146,13 +150,13 @@ std::unique_ptr<SelectiveColumnReader> SelectiveDwrfReader::build(
     case TypeKind::HUGEINT:
       if (fileType->type()->isDecimal()) {
         return std::make_unique<SelectiveDecimalColumnReader<int128_t>>(
-            fileType, params, scanSpec);
+            requestedType, fileType, params, scanSpec);
       }
       [[fallthrough]];
     default:
       VELOX_FAIL(
           "buildReader unhandled type: " +
-          mapTypeKindToName(fileType->type()->kind()));
+          std::string(TypeKindName::toName(fileType->type()->kind())));
   }
 }
 
diff --git a/velox/dwio/dwrf/reader/SelectiveFlatMapColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveFlatMapColumnReader.cpp
index ec3dd9d90b1..57c931e9b46 100644
--- a/velox/dwio/dwrf/reader/SelectiveFlatMapColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveFlatMapColumnReader.cpp
@@ -23,7 +23,6 @@
 #include "velox/vector/FlatMapVector.h"
 
 namespace facebook::velox::dwrf {
-
 namespace {
 
 template <typename T>
@@ -41,7 +40,7 @@ inline dwio::common::flatmap::KeyValue<StringView> extractKey<StringView>(
 template <typename T>
 std::string toString(const T& x) {
   if constexpr (std::is_same_v<T, StringView>) {
-    return x;
+    return std::string(x);
   } else {
     return std::to_string(x);
   }
@@ -207,15 +206,16 @@ class SelectiveFlatMapAsStructReader : public SelectiveStructColumnReaderBase {
             fileType,
             params,
             scanSpec),
-        keyNodes_(getKeyNodes<T>(
-            columnReaderOptions,
-            requestedType,
-            fileType,
-            params,
-            scanSpec,
-            dwio::common::flatmap::FlatMapOutput::kStruct)) {
+        keyNodes_(
+            getKeyNodes<T>(
+                columnReaderOptions,
+                requestedType,
+                fileType,
+                params,
+                scanSpec,
+                dwio::common::flatmap::FlatMapOutput::kStruct)) {
     VELOX_CHECK(
-        !keyNodes_.empty(),
+        !scanSpec.children().empty(),
         "For struct encoding, keys to project must be configured");
     children_.resize(keyNodes_.size());
     for (auto& childSpec : scanSpec.children()) {
@@ -289,13 +289,14 @@ class SelectiveFlatMapReader
             fileType,
             params,
             scanSpec),
-        keyNodes_(getKeyNodes<T>(
-            columnReaderOptions,
-            requestedType,
-            fileType,
-            params,
-            scanSpec,
-            dwio::common::flatmap::FlatMapOutput::kFlatMap)),
+        keyNodes_(
+            getKeyNodes<T>(
+                columnReaderOptions,
+                requestedType,
+                fileType,
+                params,
+                scanSpec,
+                dwio::common::flatmap::FlatMapOutput::kFlatMap)),
         rowsPerRowGroup_(formatData_->rowsPerRowGroup().value()) {
     // Instantiate and populate distinct keys vector.
     keysVector_ = BaseVector::create(
@@ -305,6 +306,14 @@ class SelectiveFlatMapReader
     auto rawKeys = keysVector_->values()->asMutable<T>();
     children_.resize(keyNodes_.size());
 
+    // Invalidate subscripts from previous stripes. The shared ScanSpec
+    // accumulates children across stripes via getOrCreateChild(). Keys
+    // absent in the current stripe must not be accessed via children_,
+    // so mark them constant so read() skips them.
+    for (auto& child : scanSpec.children()) {
+      child->setSubscript(kConstantChildSpecSubscript);
+    }
+
     for (int i = 0; i < keyNodes_.size(); ++i) {
       keyNodes_[i].reader->scanSpec()->setSubscript(i);
       children_[i] = keyNodes_[i].reader.get();
diff --git a/velox/dwio/dwrf/reader/SelectiveIntegerDictionaryColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveIntegerDictionaryColumnReader.cpp
index c2a4edc130a..939f355b7c5 100644
--- a/velox/dwio/dwrf/reader/SelectiveIntegerDictionaryColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveIntegerDictionaryColumnReader.cpp
@@ -45,7 +45,7 @@ SelectiveIntegerDictionaryColumnReader::SelectiveIntegerDictionaryColumnReader(
   dataReader_ = createRleDecoder</*isSigned=*/false>(
       stripe.getStream(si, params.streamLabels().label(), true),
       rleVersion_,
-      *memoryPool_,
+      *pool_,
       dataVInts,
       numBytes);
 
@@ -95,7 +95,7 @@ void SelectiveIntegerDictionaryColumnReader::read(
         ? bits::countNonNulls(nullsInReadRange_->as<uint64_t>(), 0, end)
         : end;
     dwio::common::ensureCapacity<uint64_t>(
-        scanState_.inDictionary, bits::nwords(numFlags), memoryPool_);
+        scanState_.inDictionary, bits::nwords(numFlags), pool_);
     // The in dict buffer may have changed. If no change in
     // dictionary, the raw state will not be updated elsewhere.
     scanState_.rawState.inDictionary = scanState_.inDictionary->as<uint64_t>();
diff --git a/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.cpp
index 6cbfd654a4a..12bd9c7b2a0 100644
--- a/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.cpp
@@ -39,6 +39,30 @@ std::unique_ptr<dwio::common::IntDecoder</*isSigned*/ false>> makeLengthDecoder(
       lenVints,
       dwio::common::INT_BYTE_SIZE);
 }
+
+// Returns true if the MAP extraction type needs the key child reader.
+// When deltaUpdate is set, all child readers are needed regardless of
+// ExtractionType because delta updates (e.g., MAP_CONCAT) operate on the
+// full map.
+bool needsKeyReader(
+    common::ScanSpec::ExtractionType extractionType,
+    bool hasDeltaUpdate) {
+  return hasDeltaUpdate ||
+      extractionType == common::ScanSpec::ExtractionType::kNone ||
+      extractionType == common::ScanSpec::ExtractionType::kKeys;
+}
+
+// Returns true if the MAP extraction type needs the value child reader.
+// When deltaUpdate is set, all child readers are needed regardless of
+// ExtractionType because delta updates (e.g., MAP_CONCAT) operate on the
+// full map.
+bool needsElementReader(
+    common::ScanSpec::ExtractionType extractionType,
+    bool hasDeltaUpdate) {
+  return hasDeltaUpdate ||
+      extractionType == common::ScanSpec::ExtractionType::kNone ||
+      extractionType == common::ScanSpec::ExtractionType::kValues;
+}
 } // namespace
 
 FlatMapContext flatMapContextFromEncodingKey(const EncodingKey& encodingKey) {
@@ -59,8 +83,7 @@ SelectiveListColumnReader::SelectiveListColumnReader(
           fileType,
           params,
           scanSpec),
-      length_(makeLengthDecoder(*fileType_, params, *memoryPool_)) {
-  VELOX_CHECK_EQ(fileType_->id(), fileType->id(), "working on the same node");
+      length_(makeLengthDecoder(*fileType_, params, *pool_)) {
   EncodingKey encodingKey{fileType_->id(), params.flatMapContext().sequence};
   auto& stripe = params.stripeStreams();
   // count the number of selected sub-columns
@@ -70,6 +93,15 @@ SelectiveListColumnReader::SelectiveListColumnReader(
   }
   scanSpec_->children()[0]->setProjectOut(true);
 
+  // For kSize extraction we only need the length stream, so skip creating
+  // the element reader entirely.  This avoids registering its streams and
+  // reduces IO.  When deltaUpdate is set, we still need the element reader
+  // because delta updates operate on the full array.
+  if (scanSpec.extractionType() == common::ScanSpec::ExtractionType::kSize &&
+      !scanSpec.deltaUpdate()) {
+    return;
+  }
+
   auto childParams = DwrfParams(
       stripe,
       params.streamLabels(),
@@ -84,6 +116,53 @@ SelectiveListColumnReader::SelectiveListColumnReader(
   children_ = {child_.get()};
 }
 
+namespace {
+
+void makeMapChildrenReaders(
+    const dwio::common::TypeWithId& fileType,
+    const Type& requestedType,
+    DwrfParams& params,
+    const dwio::common::ColumnReaderOptions& columnReaderOptions,
+    const common::ScanSpec& scanSpec,
+    common::ScanSpec::ExtractionType extractionType,
+    bool hasDeltaUpdate,
+    std::unique_ptr<dwio::common::SelectiveColumnReader>& keyReader,
+    std::unique_ptr<dwio::common::SelectiveColumnReader>& elementReader) {
+  const EncodingKey encodingKey{
+      fileType.id(), params.flatMapContext().sequence};
+  auto& stripe = params.stripeStreams();
+  // Skip creating child readers that extraction pushdown doesn't need.
+  // This avoids registering their streams and reduces IO.
+  if (needsKeyReader(extractionType, hasDeltaUpdate)) {
+    DwrfParams keyParams(
+        stripe,
+        params.streamLabels(),
+        params.runtimeStatistics(),
+        flatMapContextFromEncodingKey(encodingKey));
+    keyReader = SelectiveDwrfReader::build(
+        columnReaderOptions,
+        requestedType.childAt(0),
+        fileType.childAt(0),
+        keyParams,
+        *scanSpec.children()[0]);
+  }
+  if (needsElementReader(extractionType, hasDeltaUpdate)) {
+    DwrfParams elementParams = DwrfParams(
+        stripe,
+        params.streamLabels(),
+        params.runtimeStatistics(),
+        flatMapContextFromEncodingKey(encodingKey));
+    elementReader = SelectiveDwrfReader::build(
+        columnReaderOptions,
+        requestedType.childAt(1),
+        fileType.childAt(1),
+        elementParams,
+        *scanSpec.children()[1]);
+  }
+}
+
+} // namespace
+
 SelectiveMapColumnReader::SelectiveMapColumnReader(
     const dwio::common::ColumnReaderOptions& columnReaderOptions,
     const TypePtr& requestedType,
@@ -95,43 +174,49 @@ SelectiveMapColumnReader::SelectiveMapColumnReader(
           fileType,
           params,
           scanSpec),
-      length_(makeLengthDecoder(*fileType_, params, *memoryPool_)) {
-  VELOX_CHECK_EQ(fileType_->id(), fileType->id(), "working on the same node");
-  const EncodingKey encodingKey{
-      fileType_->id(), params.flatMapContext().sequence};
-  auto& stripe = params.stripeStreams();
-  if (scanSpec_->children().empty()) {
-    scanSpec_->getOrCreateChild(common::ScanSpec::kMapKeysFieldName);
-    scanSpec_->getOrCreateChild(common::ScanSpec::kMapValuesFieldName);
-  }
-  scanSpec_->children()[0]->setProjectOut(true);
-  scanSpec_->children()[1]->setProjectOut(true);
-
-  auto& keyType = requestedType_->childAt(0);
-  auto keyParams = DwrfParams(
-      stripe,
-      params.streamLabels(),
-      params.runtimeStatistics(),
-      flatMapContextFromEncodingKey(encodingKey));
-  keyReader_ = SelectiveDwrfReader::build(
+      length_(makeLengthDecoder(*fileType_, params, *pool_)) {
+  makeMapChildrenReaders(
+      *fileType_,
+      *requestedType_,
+      params,
       columnReaderOptions,
-      keyType,
-      fileType_->childAt(0),
-      keyParams,
-      *scanSpec_->children()[0].get());
+      *scanSpec_,
+      scanSpec.extractionType(),
+      scanSpec.deltaUpdate() != nullptr,
+      keyReader_,
+      elementReader_);
+  if (keyReader_) {
+    children_.push_back(keyReader_.get());
+  }
+  if (elementReader_) {
+    children_.push_back(elementReader_.get());
+  }
+}
 
-  auto& valueType = requestedType_->childAt(1);
-  auto elementParams = DwrfParams(
-      stripe,
-      params.streamLabels(),
-      params.runtimeStatistics(),
-      flatMapContextFromEncodingKey(encodingKey));
-  elementReader_ = SelectiveDwrfReader::build(
+SelectiveMapAsStructColumnReader::SelectiveMapAsStructColumnReader(
+    const dwio::common::ColumnReaderOptions& columnReaderOptions,
+    const TypePtr& requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
+    DwrfParams& params,
+    common::ScanSpec& scanSpec)
+    : dwio::common::SelectiveMapAsStructColumnReader(
+          requestedType,
+          fileType,
+          params,
+          scanSpec),
+      length_(makeLengthDecoder(*fileType_, params, *pool_)) {
+  // MapAsStruct never uses extraction pushdown (asserted in base class),
+  // so always create both readers.
+  makeMapChildrenReaders(
+      *fileType_,
+      *requestedType_,
+      params,
       columnReaderOptions,
-      valueType,
-      fileType_->childAt(1),
-      elementParams,
-      *scanSpec_->children()[1]);
+      mapScanSpec_,
+      common::ScanSpec::ExtractionType::kNone,
+      /*hasDeltaUpdate=*/false,
+      keyReader_,
+      elementReader_);
   children_ = {keyReader_.get(), elementReader_.get()};
 }
 
diff --git a/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.h b/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.h
index ad6e8575bdd..f86aae8d993 100644
--- a/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.h
+++ b/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.h
@@ -34,10 +34,6 @@ class SelectiveListColumnReader
       DwrfParams& params,
       common::ScanSpec& scanSpec);
 
-  void resetFilterCaches() override {
-    child_->resetFilterCaches();
-  }
-
   void seekToRowGroup(int64_t index) override {
     dwio::common::SelectiveListColumnReader::seekToRowGroup(index);
     auto positionsProvider = formatData_->seekToRowGroup(index);
@@ -45,8 +41,10 @@ class SelectiveListColumnReader
 
     VELOX_CHECK(!positionsProvider.hasNext());
 
-    child_->seekToRowGroup(index);
-    child_->setReadOffsetRecursive(0);
+    if (child_) {
+      child_->seekToRowGroup(index);
+      child_->setReadOffsetRecursive(0);
+    }
     childTargetReadOffset_ = 0;
   }
 
@@ -68,24 +66,37 @@ class SelectiveMapColumnReader : public dwio::common::SelectiveMapColumnReader {
       DwrfParams& params,
       common::ScanSpec& scanSpec);
 
-  void resetFilterCaches() override {
-    keyReader_->resetFilterCaches();
-    elementReader_->resetFilterCaches();
-  }
-
   void seekToRowGroup(int64_t index) override {
     dwio::common::SelectiveMapColumnReader::seekToRowGroup(index);
     auto positionsProvider = formatData_->seekToRowGroup(index);
-
     length_->seekToRowGroup(positionsProvider);
-
     VELOX_CHECK(!positionsProvider.hasNext());
+  }
 
-    keyReader_->seekToRowGroup(index);
-    keyReader_->setReadOffsetRecursive(0);
-    elementReader_->seekToRowGroup(index);
-    elementReader_->setReadOffsetRecursive(0);
-    childTargetReadOffset_ = 0;
+  void readLengths(int32_t* lengths, int32_t numLengths, const uint64_t* nulls)
+      override {
+    length_->next(lengths, numLengths, nulls);
+  }
+
+ private:
+  std::unique_ptr<dwio::common::IntDecoder</*isSigned=*/false>> length_;
+};
+
+class SelectiveMapAsStructColumnReader
+    : public dwio::common::SelectiveMapAsStructColumnReader {
+ public:
+  SelectiveMapAsStructColumnReader(
+      const dwio::common::ColumnReaderOptions& columnReaderOptions,
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
+      DwrfParams& params,
+      common::ScanSpec& scanSpec);
+
+  void seekToRowGroup(int64_t index) override {
+    dwio::common::SelectiveMapAsStructColumnReader::seekToRowGroup(index);
+    auto positionsProvider = formatData_->seekToRowGroup(index);
+    length_->seekToRowGroup(positionsProvider);
+    VELOX_CHECK(!positionsProvider.hasNext());
   }
 
   void readLengths(int32_t* lengths, int32_t numLengths, const uint64_t* nulls)
diff --git a/velox/dwio/dwrf/reader/SelectiveStringDictionaryColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveStringDictionaryColumnReader.cpp
index d88b8c24e40..cd0e6b0b15e 100644
--- a/velox/dwio/dwrf/reader/SelectiveStringDictionaryColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveStringDictionaryColumnReader.cpp
@@ -46,7 +46,7 @@ SelectiveStringDictionaryColumnReader::SelectiveStringDictionaryColumnReader(
   dictIndex_ = createRleDecoder</*isSigned*/ false>(
       stripe.getStream(dataId, params.streamLabels().label(), true),
       version_,
-      *memoryPool_,
+      *pool_,
       dictVInts,
       dwio::common::INT_BYTE_SIZE);
 
@@ -59,7 +59,7 @@ SelectiveStringDictionaryColumnReader::SelectiveStringDictionaryColumnReader(
   lengthDecoder_ = createRleDecoder</*isSigned*/ false>(
       stripe.getStream(lenId, params.streamLabels().label(), false),
       version_,
-      *memoryPool_,
+      *pool_,
       lenVInts,
       dwio::common::INT_BYTE_SIZE);
 
@@ -96,7 +96,7 @@ SelectiveStringDictionaryColumnReader::SelectiveStringDictionaryColumnReader(
     strideDictLengthDecoder_ = createRleDecoder</*isSigned*/ false>(
         stripe.getStream(strideDictLenId, params.streamLabels().label(), true),
         version_,
-        *memoryPool_,
+        *pool_,
         strideLenVInt,
         dwio::common::INT_BYTE_SIZE);
   }
@@ -118,7 +118,7 @@ void SelectiveStringDictionaryColumnReader::loadDictionary(
     DictionaryValues& values) {
   // read lengths from length reader
   dwio::common::ensureCapacity<StringView>(
-      values.values, values.numValues, memoryPool_);
+      values.values, values.numValues, pool_);
   // The lengths are read in the low addresses of the string views array.
   auto* lengths = values.values->asMutable<int32_t>();
   lengthDecoder.nextLengths(lengths, values.numValues);
@@ -127,7 +127,7 @@ void SelectiveStringDictionaryColumnReader::loadDictionary(
     stringsBytes += lengths[i];
   }
   // read bytes from underlying string
-  values.strings = AlignedBuffer::allocate<char>(stringsBytes, memoryPool_);
+  values.strings = AlignedBuffer::allocate<char>(stringsBytes, pool_);
   data.readFully(values.strings->asMutable<char>(), stringsBytes);
   // fill the values with StringViews over the strings. 'strings' will
   // exist even if 'stringsBytes' is 0, which can happen if the only
@@ -156,7 +156,7 @@ void SelectiveStringDictionaryColumnReader::loadStrideDictionary() {
   if (scanState_.dictionary2.numValues > 0) {
     // seek stride dictionary related streams
     std::vector<uint64_t> pos(
-        positions.begin() + positionOffset_, positions.end());
+        positions.cbegin() + positionOffset_, positions.cend());
     PositionProvider pp(pos);
     strideDictStream_->seekToPosition(pp);
     strideDictLengthDecoder_->seekToRowGroup(pp);
@@ -182,7 +182,7 @@ void SelectiveStringDictionaryColumnReader::makeDictionaryBaseVector() {
   if (scanState_.dictionary2.numValues) {
     BufferPtr values = AlignedBuffer::allocate<StringView>(
         scanState_.dictionary.numValues + scanState_.dictionary2.numValues,
-        memoryPool_);
+        pool_);
     auto* valuesPtr = values->asMutable<StringView>();
     memcpy(
         valuesPtr,
@@ -194,7 +194,7 @@ void SelectiveStringDictionaryColumnReader::makeDictionaryBaseVector() {
         scanState_.dictionary2.numValues * sizeof(StringView));
 
     dictionaryValues_ = std::make_shared<FlatVector<StringView>>(
-        memoryPool_,
+        pool_,
         fileType_->type(),
         BufferPtr(nullptr), // TODO nulls
         scanState_.dictionary.numValues +
@@ -204,7 +204,7 @@ void SelectiveStringDictionaryColumnReader::makeDictionaryBaseVector() {
             scanState_.dictionary.strings, scanState_.dictionary2.strings});
   } else {
     dictionaryValues_ = std::make_shared<FlatVector<StringView>>(
-        memoryPool_,
+        pool_,
         fileType_->type(),
         BufferPtr(nullptr), // TODO nulls
         scanState_.dictionary.numValues /*length*/,
@@ -230,7 +230,7 @@ void SelectiveStringDictionaryColumnReader::read(
         ? bits::countNonNulls(nullsInReadRange_->as<uint64_t>(), 0, end)
         : end;
     dwio::common::ensureCapacity<uint64_t>(
-        scanState_.inDictionary, bits::nwords(numFlags), memoryPool_);
+        scanState_.inDictionary, bits::nwords(numFlags), pool_);
     // The in dict buffer may have changed. If no change in
     // dictionary, the raw state will not be updated elsewhere.
     scanState_.rawState.inDictionary = scanState_.inDictionary->as<uint64_t>();
@@ -253,7 +253,7 @@ void SelectiveStringDictionaryColumnReader::read(
 
 void SelectiveStringDictionaryColumnReader::makeFlat(VectorPtr* result) {
   auto* indices = reinterpret_cast<const vector_size_t*>(rawValues_);
-  auto values = AlignedBuffer::allocate<StringView>(numValues_, memoryPool_);
+  auto values = AlignedBuffer::allocate<StringView>(numValues_, pool_);
   auto* stringViews = values->asMutable<StringView>();
   std::vector<BufferPtr> stringBuffers;
   auto* stripeDict = scanState_.dictionary.values->as<StringView>();
@@ -278,7 +278,7 @@ void SelectiveStringDictionaryColumnReader::makeFlat(VectorPtr* result) {
     }
   }
   *result = std::make_shared<FlatVector<StringView>>(
-      memoryPool_,
+      pool_,
       requestedType(),
       std::move(nulls),
       numValues_,
@@ -308,7 +308,7 @@ void SelectiveStringDictionaryColumnReader::getValues(
     makeDictionaryBaseVector();
   }
   *result = std::make_shared<DictionaryVector<StringView>>(
-      memoryPool_, resultNulls(), numValues_, dictionaryValues_, values_);
+      pool_, resultNulls(), numValues_, dictionaryValues_, values_);
 }
 
 void SelectiveStringDictionaryColumnReader::ensureInitialized() {
diff --git a/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.cpp
index 657470e9267..2a39829acf8 100644
--- a/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.cpp
@@ -39,7 +39,7 @@ SelectiveStringDirectColumnReader::SelectiveStringDirectColumnReader(
   lengthDecoder_ = createRleDecoder</*isSigned*/ false>(
       stripe.getStream(lenId, params.streamLabels().label(), true),
       rleVersion,
-      *memoryPool_,
+      *pool_,
       lenVInts,
       dwio::common::INT_BYTE_SIZE);
   blobStream_ = stripe.getStream(
@@ -54,7 +54,7 @@ SelectiveStringDirectColumnReader::SelectiveStringDirectColumnReader(
 
 uint64_t SelectiveStringDirectColumnReader::skip(uint64_t numValues) {
   numValues = SelectiveColumnReader::skip(numValues);
-  dwio::common::ensureCapacity<uint32_t>(lengths_, numValues, memoryPool_);
+  dwio::common::ensureCapacity<uint32_t>(lengths_, numValues, pool_);
   lengthDecoder_->nextLengths(lengths_->asMutable<int32_t>(), numValues);
   rawLengths_ = lengths_->as<uint32_t>();
   for (auto i = 0; i < numValues; ++i) {
@@ -318,11 +318,10 @@ inline bool SelectiveStringDirectColumnReader::try8Consecutive(
 void SelectiveStringDirectColumnReader::extractSparse(
     const int32_t* rows,
     int32_t numRows) {
-  dwio::common::rowLoop(
+  dwio::common::rowLoop<8>(
       rows,
       0,
       numRows,
-      8,
       [&](int32_t row) {
         auto start = rangeSum(rawLengths_, 0, lengthIndex_, rows[row]);
         lengthIndex_ = rows[row];
@@ -362,20 +361,19 @@ void SelectiveStringDirectColumnReader::skipInDecode(
   lengthIndex_ += numValues;
 }
 
-folly::StringPiece SelectiveStringDirectColumnReader::readValue(
-    int32_t length) {
+std::string_view SelectiveStringDirectColumnReader::readValue(int32_t length) {
   skipBytes(bytesToSkip_, blobStream_.get(), bufferStart_, bufferEnd_);
   bytesToSkip_ = 0;
   // bufferStart_ may be null if length is 0 and this is the first string
   // we're reading.
   if (bufferEnd_ - bufferStart_ >= length) {
     bytesToSkip_ = length;
-    return folly::StringPiece(bufferStart_, length);
+    return std::string_view(bufferStart_, length);
   }
   tempString_.resize(length);
   readBytes(
       length, blobStream_.get(), tempString_.data(), bufferStart_, bufferEnd_);
-  return folly::StringPiece(tempString_);
+  return std::string_view(tempString_);
 }
 
 template <bool kHasNulls, typename Visitor>
@@ -474,13 +472,12 @@ void SelectiveStringDirectColumnReader::read(
     int64_t offset,
     const RowSet& rows,
     const uint64_t* incomingNulls) {
-  prepareRead<folly::StringPiece>(offset, rows, incomingNulls);
+  prepareRead<std::string_view>(offset, rows, incomingNulls);
   auto numRows = rows.back() + 1;
   auto numNulls = nullsInReadRange_
       ? BaseVector::countNulls(nullsInReadRange_, 0, numRows)
       : 0;
-  dwio::common::ensureCapacity<int32_t>(
-      lengths_, numRows - numNulls, memoryPool_);
+  dwio::common::ensureCapacity<int32_t>(lengths_, numRows - numNulls, pool_);
   lengthDecoder_->nextLengths(
       lengths_->asMutable<int32_t>(), numRows - numNulls);
   rawLengths_ = lengths_->as<uint32_t>();
diff --git a/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.h b/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.h
index 8da1e77401d..e0a2369ceb5 100644
--- a/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.h
+++ b/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.h
@@ -58,7 +58,7 @@ class SelectiveStringDirectColumnReader
   template <bool hasNulls>
   void skipInDecode(int32_t numValues, int32_t current, const uint64_t* nulls);
 
-  folly::StringPiece readValue(int32_t length);
+  std::string_view readValue(int32_t length);
 
   template <bool hasNulls, typename Visitor>
   void decode(const uint64_t* nulls, Visitor visitor);
diff --git a/velox/dwio/dwrf/reader/SelectiveStructColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveStructColumnReader.cpp
index b1f47289505..364270e5391 100644
--- a/velox/dwio/dwrf/reader/SelectiveStructColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveStructColumnReader.cpp
@@ -86,12 +86,13 @@ SelectiveStructColumnReader::SelectiveStructColumnReader(
             .sequence = encodingKey.sequence(),
             .inMapDecoder = nullptr,
             .keySelectionCallback = nullptr});
-    addChild(SelectiveDwrfReader::build(
-        columnReaderOptions,
-        childRequestedType,
-        childFileType,
-        childParams,
-        *childSpec));
+    addChild(
+        SelectiveDwrfReader::build(
+            columnReaderOptions,
+            childRequestedType,
+            childFileType,
+            childParams,
+            *childSpec));
     childSpec->setSubscript(children_.size() - 1);
   }
 }
diff --git a/velox/dwio/dwrf/reader/SelectiveTimestampColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveTimestampColumnReader.cpp
index 10f9be96a57..053c2432e56 100644
--- a/velox/dwio/dwrf/reader/SelectiveTimestampColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveTimestampColumnReader.cpp
@@ -41,7 +41,7 @@ SelectiveTimestampColumnReader::SelectiveTimestampColumnReader(
   seconds_ = createRleDecoder</*isSigned=*/true>(
       stripe.getStream(data, params.streamLabels().label(), true),
       version_,
-      *memoryPool_,
+      *pool_,
       vints,
       LONG_BYTE_SIZE);
   auto nanoData = StripeStreamsUtil::getStreamForKind(
@@ -53,7 +53,7 @@ SelectiveTimestampColumnReader::SelectiveTimestampColumnReader(
   nano_ = createRleDecoder</*isSigned=*/false>(
       stripe.getStream(nanoData, params.streamLabels().label(), true),
       version_,
-      *memoryPool_,
+      *pool_,
       nanoVInts,
       LONG_BYTE_SIZE);
 }
@@ -86,7 +86,7 @@ void SelectiveTimestampColumnReader::read(
       resultNulls_->capacity() * 8 < rows.size()) {
     // Make sure a dedicated resultNulls_ is allocated with enough capacity as
     // RleDecoder always assumes it is available.
-    resultNulls_ = AlignedBuffer::allocate<bool>(rows.size(), memoryPool_);
+    resultNulls_ = AlignedBuffer::allocate<bool>(rows.size(), pool_);
     rawResultNulls_ = resultNulls_->asMutable<uint64_t>();
   }
   bool isDense = rows.back() == rows.size() - 1;
@@ -119,8 +119,7 @@ void SelectiveTimestampColumnReader::readHelper(
 
   // Save the seconds into their own buffer before reading nanos into
   // 'values_'
-  dwio::common::ensureCapacity<uint64_t>(
-      secondsValues_, numValues_, memoryPool_);
+  dwio::common::ensureCapacity<uint64_t>(secondsValues_, numValues_, pool_);
   secondsValues_->setSize(numValues_ * sizeof(int64_t));
   memcpy(
       secondsValues_->asMutable<char>(),
@@ -141,7 +140,7 @@ void SelectiveTimestampColumnReader::readHelper(
   const auto rawNulls = nullsInReadRange_
       ? (isDense ? nullsInReadRange_->as<uint64_t>() : rawResultNulls_)
       : nullptr;
-  auto tsValues = AlignedBuffer::allocate<Timestamp>(numValues_, memoryPool_);
+  auto tsValues = AlignedBuffer::allocate<Timestamp>(numValues_, pool_);
   auto rawTs = tsValues->asMutable<Timestamp>();
 
   for (vector_size_t i = 0; i < numValues_; i++) {
diff --git a/velox/dwio/dwrf/reader/StripeMetadataCache.h b/velox/dwio/dwrf/reader/StripeMetadataCache.h
index 4a7a1125610..9cd5507932d 100644
--- a/velox/dwio/dwrf/reader/StripeMetadataCache.h
+++ b/velox/dwio/dwrf/reader/StripeMetadataCache.h
@@ -95,7 +95,7 @@ class StripeMetadataCache {
     std::vector<uint32_t> offsets;
     offsets.reserve(footer.stripeCacheOffsetsSize());
     const auto& from = footer.stripeCacheOffsets();
-    offsets.assign(from.begin(), from.end());
+    offsets.assign(from.cbegin(), from.cend());
     return offsets;
   }
 
diff --git a/velox/dwio/dwrf/reader/StripeReaderBase.cpp b/velox/dwio/dwrf/reader/StripeReaderBase.cpp
index 44ba6aa81e8..9bc5549d923 100644
--- a/velox/dwio/dwrf/reader/StripeReaderBase.cpp
+++ b/velox/dwio/dwrf/reader/StripeReaderBase.cpp
@@ -16,8 +16,11 @@
 
 #include "velox/dwio/dwrf/reader/StripeReaderBase.h"
 
+#include "velox/dwio/common/Arena.h"
+
 namespace facebook::velox::dwrf {
 
+using dwio::common::ArenaCreate;
 using dwio::common::LogType;
 
 // preload is not considered or mutated if stripe has already been fetched. e.g.
@@ -95,9 +98,7 @@ std::unique_ptr<const StripeMetadata> StripeReaderBase::fetchStripe(
   };
 
   if (fileFooter.format() == DwrfFormat::kDwrf) {
-    auto* rawFooter =
-        google::protobuf::Arena::CreateMessage<proto::StripeFooter>(
-            arena.get());
+    auto* rawFooter = ArenaCreate<proto::StripeFooter>(arena.get());
     ProtoUtils::readProtoInto(
         reader_->createDecompressedStream(
             std::move(footerStream), streamDebugInfo),
@@ -110,9 +111,7 @@ std::unique_ptr<const StripeMetadata> StripeReaderBase::fetchStripe(
 
     return createStripeMetadata(std::move(stripeFooter));
   } else {
-    auto* rawFooter =
-        google::protobuf::Arena::CreateMessage<proto::orc::StripeFooter>(
-            arena.get());
+    auto* rawFooter = ArenaCreate<proto::orc::StripeFooter>(arena.get());
     ProtoUtils::readProtoInto(
         reader_->createDecompressedStream(
             std::move(footerStream), streamDebugInfo),
diff --git a/velox/dwio/dwrf/reader/StripeStream.cpp b/velox/dwio/dwrf/reader/StripeStream.cpp
index 4c9b3ec829a..eb7293b0955 100644
--- a/velox/dwio/dwrf/reader/StripeStream.cpp
+++ b/velox/dwio/dwrf/reader/StripeStream.cpp
@@ -343,10 +343,12 @@ std::unique_ptr<dwio::common::SeekableInputStream> StripeStreamsImpl::getStream(
 
   const auto streamDebugInfo =
       fmt::format("Stripe {} Stream {}", stripeIndex_, si.toString());
+
   return readState_->readerBase->createDecompressedStream(
       std::move(streamInput),
       streamDebugInfo,
-      getDecrypter(si.encodingKey().node()));
+      getDecrypter(si.encodingKey().node()),
+      getDecompressCounter(si.encodingKey().node()));
 }
 
 uint32_t StripeStreamsImpl::visitStreamsOfNode(
diff --git a/velox/dwio/dwrf/reader/StripeStream.h b/velox/dwio/dwrf/reader/StripeStream.h
index cccbf3af875..cba5fc0748e 100644
--- a/velox/dwio/dwrf/reader/StripeStream.h
+++ b/velox/dwio/dwrf/reader/StripeStream.h
@@ -20,6 +20,7 @@
 #include "velox/dwio/common/ColumnSelector.h"
 #include "velox/dwio/common/Options.h"
 #include "velox/dwio/common/SeekableInputStream.h"
+#include "velox/dwio/common/Statistics.h"
 #include "velox/dwio/dwrf/common/Common.h"
 #include "velox/dwio/dwrf/reader/StreamLabels.h"
 #include "velox/dwio/dwrf/reader/StripeDictionaryCache.h"
@@ -229,7 +230,8 @@ class StripeStreamsImpl : public StripeStreamsBase {
       uint64_t stripeStart,
       int64_t stripeNumberOfRows,
       const StrideIndexProvider& provider,
-      uint32_t stripeIndex)
+      uint32_t stripeIndex,
+      dwio::common::ColumnReaderStatistics* columnReaderStats = nullptr)
       : StripeStreamsBase{&readState->readerBase->memoryPool()},
         readState_(std::move(readState)),
         selector_{selector},
@@ -238,7 +240,8 @@ class StripeStreamsImpl : public StripeStreamsBase {
         stripeStart_{stripeStart},
         stripeNumberOfRows_{stripeNumberOfRows},
         provider_(provider),
-        stripeIndex_{stripeIndex} {
+        stripeIndex_{stripeIndex},
+        columnReaderStats_{columnReaderStats} {
     loadStreams();
   }
 
@@ -362,6 +365,14 @@ class StripeStreamsImpl : public StripeStreamsBase {
         : nullptr;
   }
 
+  io::IoCounter* getDecompressCounter(uint32_t nodeId) const {
+    if (!columnReaderStats_ || !columnReaderStats_->columnMetricsSet) {
+      return nullptr;
+    }
+    auto* metrics = columnReaderStats_->columnMetricsSet->getOrCreate(nodeId);
+    return &metrics->decompressCPUTimeNanos;
+  }
+
   void loadStreams();
 
   const std::shared_ptr<StripeReadState> readState_;
@@ -374,6 +385,7 @@ class StripeStreamsImpl : public StripeStreamsBase {
   const int64_t stripeNumberOfRows_;
   const StrideIndexProvider& provider_;
   const uint32_t stripeIndex_;
+  dwio::common::ColumnReaderStatistics* const columnReaderStats_{nullptr};
 
   bool readPlanLoaded_{false};
 
diff --git a/velox/dwio/dwrf/test/CMakeLists.txt b/velox/dwio/dwrf/test/CMakeLists.txt
index cbd29a9ac2f..c373de65143 100644
--- a/velox/dwio/dwrf/test/CMakeLists.txt
+++ b/velox/dwio/dwrf/test/CMakeLists.txt
@@ -70,7 +70,7 @@ target_link_libraries(
   ${TEST_LINK_LIBS}
 )
 
-add_executable(velox_dwio_dwrf_decompression_test TestDecompression.cpp)
+add_executable(velox_dwio_dwrf_decompression_test DecompressionTest.cpp)
 add_test(
   NAME velox_dwio_dwrf_decompression_test
   COMMAND velox_dwio_dwrf_decompression_test
@@ -87,7 +87,7 @@ target_link_libraries(
   ${TEST_LINK_LIBS}
 )
 
-add_executable(velox_dwio_dwrf_stripe_stream_test TestStripeStream.cpp)
+add_executable(velox_dwio_dwrf_stripe_stream_test StripeStreamTest.cpp)
 add_test(velox_dwio_dwrf_stripe_stream_test velox_dwio_dwrf_stripe_stream_test)
 
 target_link_libraries(
@@ -428,6 +428,7 @@ target_link_libraries(
   velox_dwio_dwrf_reader_test
   velox_dwrf_test_utils
   velox_vector_test_lib
+  velox_hive_connector
   velox_link_libs
   Folly::folly
   fmt::fmt
@@ -618,7 +619,7 @@ target_link_libraries(
   velox_dwio_cache_test
   velox_common_io
   velox_link_libs
-  velox_temp_path
+  velox_test_util
   Folly::folly
   fmt::fmt
   lz4::lz4
@@ -626,3 +627,9 @@ target_link_libraries(
   ZLIB::ZLIB
   ${TEST_LINK_LIBS}
 )
+
+velox_add_library(velox_test_column_statistics_base INTERFACE HEADERS ColumnStatisticsBase.h)
+
+velox_add_library(velox_test-read-file INTERFACE HEADERS TestReadFile.h)
+
+velox_add_library(velox_orc-test INTERFACE HEADERS OrcTest.h)
diff --git a/velox/dwio/dwrf/test/CacheInputTest.cpp b/velox/dwio/dwrf/test/CacheInputTest.cpp
index 79ca58b37ab..f06cef3f142 100644
--- a/velox/dwio/dwrf/test/CacheInputTest.cpp
+++ b/velox/dwio/dwrf/test/CacheInputTest.cpp
@@ -24,15 +24,16 @@
 #include "velox/common/io/IoStatistics.h"
 #include "velox/common/io/Options.h"
 #include "velox/common/memory/MmapAllocator.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/dwio/common/CachedBufferedInput.h"
 #include "velox/dwio/dwrf/common/Common.h"
 #include "velox/dwio/dwrf/test/TestReadFile.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 #include <fcntl.h>
 #include <gtest/gtest.h>
 
 using namespace facebook::velox;
+using namespace facebook::velox::common::testutil;
 using namespace facebook::velox::dwio;
 using namespace facebook::velox::dwio::common;
 using namespace facebook::velox::cache;
@@ -62,8 +63,7 @@ class CacheTest : public ::testing::Test {
   void SetUp() override {
     // executor_ = std::make_unique<folly::IOThreadPoolExecutor>(10, 10);
     rng_.seed(1);
-    ioStats_ = std::make_shared<IoStatistics>();
-    fsStats_ = std::make_shared<filesystems::File::IoStats>();
+    ioStats_ = std::make_shared<facebook::velox::IoStats>();
     filesystems::registerLocalFileSystem();
   }
 
@@ -99,7 +99,7 @@ class CacheTest : public ::testing::Test {
     std::unique_ptr<SsdCache> ssd;
     if (ssdBytes > 0) {
       FLAGS_velox_ssd_odirect = false;
-      tempDirectory_ = exec::test::TempDirectoryPath::create();
+      tempDirectory_ = TempDirectoryPath::create();
       const SsdCache::Config config(
           fmt::format("{}/cache", tempDirectory_->getPath()),
           ssdBytes,
@@ -110,19 +110,21 @@ class CacheTest : public ::testing::Test {
           checksumEnabled,
           checksumEnabled);
       ssd = std::make_unique<SsdCache>(config);
-      ssdCacheHelper_ = std::make_unique<test::SsdCacheTestHelper>(ssd.get());
+      ssdCacheHelper_ =
+          std::make_unique<cache::test::SsdCacheTestHelper>(ssd.get());
       groupStats_ = &ssd->groupStats();
     }
-    memory::MmapAllocator::Options options;
+    memory::MemoryAllocator::Options options;
     options.capacity = maxBytes;
     allocator_ = std::make_shared<memory::MmapAllocator>(options);
     cache_ = AsyncDataCache::create(allocator_.get(), std::move(ssd));
     asyncDataCacheHelper_ =
-        std::make_unique<test::AsyncDataCacheTestHelper>(cache_.get());
+        std::make_unique<cache::test::AsyncDataCacheTestHelper>(cache_.get());
     cache_->setVerifyHook(checkEntry);
     for (auto i = 0; i < kMaxStreams; ++i) {
-      streamIds_.push_back(std::make_unique<dwrf::DwrfStreamIdentifier>(
-          i, i, 0, dwrf::StreamKind_DATA));
+      streamIds_.push_back(
+          std::make_unique<dwrf::DwrfStreamIdentifier>(
+              i, i, 0, dwrf::StreamKind_DATA));
     }
     streamStarts_.resize(kMaxStreams + 1);
     streamStarts_[0] = 0;
@@ -149,13 +151,13 @@ class CacheTest : public ::testing::Test {
 
   static void checkEntry(const cache::AsyncDataCacheEntry& entry) {
     uint64_t seed = entry.key().fileNum.id();
-    if (entry.tinyData()) {
-      checkData(entry.tinyData(), entry.offset(), entry.size(), seed);
+    if (entry.hasContiguousData()) {
+      checkData(entry.contiguousData(), entry.offset(), entry.size(), seed);
     } else {
       int64_t bytesLeft = entry.size();
       auto runOffset = entry.offset();
-      for (auto i = 0; i < entry.data().numRuns(); ++i) {
-        auto run = entry.data().runAt(i);
+      for (auto i = 0; i < entry.nonContiguousData().numRuns(); ++i) {
+        auto run = entry.nonContiguousData().runAt(i);
         checkData(
             run.data<char>(),
             runOffset,
@@ -202,7 +204,7 @@ class CacheTest : public ::testing::Test {
     fileIds_.push_back(groupId);
     // Creates an extremely large read file for test.
     auto stream = std::make_shared<TestReadFile>(
-        fileId.id(), 1UL << 63, std::make_shared<filesystems::File::IoStats>());
+        fileId.id(), 1UL << 63, std::make_shared<facebook::velox::IoStats>());
     pathToInput_[fileId.id()] = stream;
     return stream;
   }
@@ -216,12 +218,14 @@ class CacheTest : public ::testing::Test {
       const StringIdLease& fileId,
       const StringIdLease& groupId,
       int64_t offset,
-      bool noCacheRetention,
-      const IoStatisticsPtr& ioStats,
-      const std::shared_ptr<filesystems::File::IoStats>& fsStats) {
+      bool cacheable,
+      const IoStatisticsPtr& ioStatistics,
+      const std::shared_ptr<facebook::velox::IoStats>& ioStats) {
     auto data = std::make_unique<StripeData>();
     auto readOptions = io::ReaderOptions(pool_.get());
-    readOptions.setNoCacheRetention(noCacheRetention);
+    readOptions.setDataIoStats(dataIoStats_);
+    readOptions.setMetadataIoStats(metadataIoStats_);
+    readOptions.setCacheable(cacheable);
     data->input = std::make_unique<CachedBufferedInput>(
         readFile,
         MetricsLog::voidLog(),
@@ -229,8 +233,8 @@ class CacheTest : public ::testing::Test {
         cache_.get(),
         tracker,
         groupId,
+        ioStatistics,
         ioStats,
-        fsStats,
         executor_.get(),
         readOptions);
     data->file = readFile.get();
@@ -345,9 +349,9 @@ class CacheTest : public ::testing::Test {
       int32_t readPctModulo,
       int32_t numStripes,
       int32_t stripeWindow,
-      bool noCacheRetention,
-      const IoStatisticsPtr& ioStats,
-      const std::shared_ptr<filesystems::File::IoStats>& fsStats) {
+      bool cacheable,
+      const IoStatisticsPtr& ioStatistics,
+      const std::shared_ptr<facebook::velox::IoStats>& ioStats) {
     auto tracker = std::make_shared<ScanTracker>(
         "testTracker",
         nullptr,
@@ -375,9 +379,9 @@ class CacheTest : public ::testing::Test {
             fileId,
             groupId,
             prefetchStripeIndex * streamStarts_[kMaxStreams - 1],
-            noCacheRetention,
-            ioStats,
-            fsStats));
+            cacheable,
+            ioStatistics,
+            ioStats));
         if (stripes.back()->input->shouldPreload()) {
           stripes.back()->input->load(LogType::TEST);
           stripes.back()->prefetched = true;
@@ -417,9 +421,9 @@ class CacheTest : public ::testing::Test {
           readPctModulo,
           numStripes,
           stripeWindow,
-          /*noCacheRetention=*/false,
-          ioStats_,
-          fsStats_);
+          /*cacheable=*/true,
+          dataIoStats_,
+          ioStats_);
     }
   }
 
@@ -432,18 +436,22 @@ class CacheTest : public ::testing::Test {
     }
   }
 
+  const std::shared_ptr<IoStatistics> dataIoStats_{
+      std::make_shared<IoStatistics>()};
+  const std::shared_ptr<IoStatistics> metadataIoStats_{
+      std::make_shared<IoStatistics>()};
+
   // Serializes 'pathToInput_' and 'fileIds_' in multithread test.
   std::mutex mutex_;
   std::vector<StringIdLease> fileIds_;
   folly::F14FastMap<uint64_t, std::shared_ptr<TestReadFile>> pathToInput_;
-  std::shared_ptr<exec::test::TempDirectoryPath> tempDirectory_;
+  std::shared_ptr<TempDirectoryPath> tempDirectory_;
   cache::FileGroupStats* groupStats_ = nullptr;
   std::shared_ptr<memory::MemoryAllocator> allocator_;
   std::shared_ptr<AsyncDataCache> cache_;
-  std::unique_ptr<test::AsyncDataCacheTestHelper> asyncDataCacheHelper_;
-  std::unique_ptr<test::SsdCacheTestHelper> ssdCacheHelper_;
-  std::shared_ptr<IoStatistics> ioStats_;
-  std::shared_ptr<filesystems::File::IoStats> fsStats_;
+  std::unique_ptr<cache::test::AsyncDataCacheTestHelper> asyncDataCacheHelper_;
+  std::unique_ptr<cache::test::SsdCacheTestHelper> ssdCacheHelper_;
+  std::shared_ptr<facebook::velox::IoStats> ioStats_;
   std::unique_ptr<folly::IOThreadPoolExecutor> executor_;
   std::shared_ptr<memory::MemoryPool> pool_{
       memory::memoryManager()->addLeafPool()};
@@ -481,10 +489,15 @@ TEST_F(CacheTest, window) {
       cache_.get(),
       tracker,
       groupId,
+      dataIoStats_,
       ioStats_,
-      fsStats_,
       executor_.get(),
-      io::ReaderOptions(pool_.get()));
+      [&] {
+        io::ReaderOptions opts(pool_.get());
+        opts.setDataIoStats(dataIoStats_);
+        opts.setMetadataIoStats(metadataIoStats_);
+        return opts;
+      }());
   auto begin = 4 * kMB;
   auto end = 17 * kMB;
   auto stream = input->read(begin, end - begin, LogType::TEST);
@@ -511,7 +524,7 @@ TEST_F(CacheTest, window) {
   auto clone = cacheInput->clone();
   clone->SkipInt64(100);
   clone->setRemainingBytes(kMB);
-  auto previousRead = ioStats_->rawBytesRead();
+  auto previousRead = dataIoStats_->rawBytesRead();
   EXPECT_TRUE(clone->Next(&buffer, &size));
   // Half MB minus the 100 bytes skipped above should be left in the first load
   // quantum of 8MB.
@@ -520,7 +533,7 @@ TEST_F(CacheTest, window) {
   EXPECT_EQ(kMB / 2 + 100, size);
   // There should be no more data in the window.
   EXPECT_FALSE(clone->Next(&buffer, &size));
-  EXPECT_EQ(kMB, ioStats_->rawBytesRead() - previousRead);
+  EXPECT_EQ(kMB, dataIoStats_->rawBytesRead() - previousRead);
 }
 
 TEST_F(CacheTest, bufferedInput) {
@@ -533,9 +546,9 @@ TEST_F(CacheTest, bufferedInput) {
       10,
       20,
       4,
-      /*noCacheRetention=*/false,
-      ioStats_,
-      fsStats_);
+      /*cacheable=*/true,
+      dataIoStats_,
+      ioStats_);
   readLoop(
       "testfile",
       30,
@@ -543,9 +556,9 @@ TEST_F(CacheTest, bufferedInput) {
       10,
       20,
       4,
-      /*noCacheRetention=*/false,
-      ioStats_,
-      fsStats_);
+      /*cacheable=*/true,
+      dataIoStats_,
+      ioStats_);
   readLoop(
       "testfile2",
       30,
@@ -553,9 +566,9 @@ TEST_F(CacheTest, bufferedInput) {
       70,
       20,
       4,
-      /*noCacheRetention=*/false,
-      ioStats_,
-      fsStats_);
+      /*cacheable=*/true,
+      dataIoStats_,
+      ioStats_);
 }
 
 // Calibrates the data read for a densely and sparsely read stripe of test data.
@@ -578,15 +591,15 @@ TEST_F(CacheTest, ssd) {
       1,
       1,
       1,
-      /*noCacheRetention=*/false,
-      ioStats_,
-      fsStats_);
+      /*cacheable=*/true,
+      dataIoStats_,
+      ioStats_);
   // This is a cold read, so expect no hits.
-  EXPECT_EQ(0, ioStats_->ramHit().sum());
+  EXPECT_EQ(0, dataIoStats_->ramHit().sum());
   // Expect some extra reading from coalescing.
-  EXPECT_LT(0, ioStats_->rawOverreadBytes());
-  auto fullStripeBytes = ioStats_->rawBytesRead();
-  auto bytes = ioStats_->rawBytesRead();
+  EXPECT_LT(0, dataIoStats_->rawOverreadBytes());
+  auto fullStripeBytes = dataIoStats_->rawBytesRead();
+  auto bytes = dataIoStats_->rawBytesRead();
   cache_->clear();
   // We read 10 stripes with some columns sparsely accessed.
   readLoop(
@@ -596,13 +609,13 @@ TEST_F(CacheTest, ssd) {
       10,
       10,
       1,
-      /*noCacheRetention=*/false,
-      ioStats_,
-      fsStats_);
-  auto sparseStripeBytes = (ioStats_->rawBytesRead() - bytes) / 10;
+      /*cacheable=*/true,
+      dataIoStats_,
+      ioStats_);
+  auto sparseStripeBytes = (dataIoStats_->rawBytesRead() - bytes) / 10;
   EXPECT_LT(sparseStripeBytes, fullStripeBytes / 4);
   // Expect the dense fraction of columns to have read ahead.
-  EXPECT_LT(400'000, ioStats_->prefetch().sum());
+  EXPECT_LT(400'000, dataIoStats_->prefetch().sum());
 
   constexpr int32_t kStripesPerFile = 10;
   auto bytesPerFile = fullStripeBytes * kStripesPerFile;
@@ -623,13 +636,13 @@ TEST_F(CacheTest, ssd) {
       kStripesPerFile,
       4);
   // Expect some hits from SSD.
-  EXPECT_LE(kSsdBytes / 8, ioStats_->ssdRead().sum());
+  EXPECT_LE(kSsdBytes / 8, dataIoStats_->ssdRead().sum());
   // We expec some prefetch but the quantity is nondeterminstic
   // because cases where the main thread reads the data ahead of
   // background reader does not count as prefetch even if prefetch was
   // issued. Also, the head of each file does not get prefetched
   // because each file has its own tracker.
-  EXPECT_LE(kSsdBytes / 8, ioStats_->prefetch().sum());
+  EXPECT_LE(kSsdBytes / 8, dataIoStats_->prefetch().sum());
 
   readFiles(
       "prefix1_",
@@ -657,9 +670,9 @@ TEST_F(CacheTest, singleFileThreads) {
           10,
           20,
           4,
-          /*noCacheRetention=*/false,
-          ioStats_,
-          fsStats_);
+          /*cacheable=*/true,
+          dataIoStats_,
+          ioStats_);
     }));
   }
   for (auto i = 0; i < numThreads; ++i) {
@@ -675,16 +688,19 @@ TEST_F(CacheTest, ssdThreads) {
   stats.reserve(kNumThreads);
   std::vector<std::thread> threads;
   threads.reserve(kNumThreads);
-  std::vector<std::shared_ptr<filesystems::File::IoStats>> fsStats;
-  fsStats.reserve(kNumThreads);
+  std::vector<std::shared_ptr<facebook::velox::IoStats>> ioStatsVec;
+  ioStatsVec.reserve(kNumThreads);
 
   // We read 4 files on 8 threads. Threads 0 and 1 read file 0, 2 and 3 read
   // file 1 etc. Each tread reads its file 4 times.
   for (int i = 0; i < kNumThreads; ++i) {
     stats.push_back(std::make_shared<io::IoStatistics>());
-    fsStats.push_back(std::make_shared<filesystems::File::IoStats>());
-    threads.push_back(std::thread(
-        [i, this, threadStats = stats.back(), fsStat = fsStats.back()]() {
+    ioStatsVec.push_back(std::make_shared<facebook::velox::IoStats>());
+    threads.push_back(
+        std::thread([i,
+                     this,
+                     threadStats = stats.back(),
+                     ioStat = ioStatsVec.back()]() {
           for (auto counter = 0; counter < 4; ++counter) {
             readLoop(
                 fmt::format("testfile{}", i / 2),
@@ -693,9 +709,9 @@ TEST_F(CacheTest, ssdThreads) {
                 10,
                 20,
                 2,
-                /*noCacheRetention=*/false,
+                /*cacheable=*/true,
                 threadStats,
-                fsStat);
+                ioStat);
           }
         }));
   }
@@ -725,13 +741,15 @@ class FileWithReadAhead {
       const std::string& name,
       cache::AsyncDataCache* cache,
       IoStatisticsPtr stats,
-      std::shared_ptr<filesystems::File::IoStats> fsStats,
+      std::shared_ptr<facebook::velox::IoStats> ioStats,
       memory::MemoryPool& pool,
       folly::Executor* executor)
       : options_(&pool) {
+    options_.setDataIoStats(dataIoStats_);
+    options_.setMetadataIoStats(metadataIoStats_);
     fileId_ = std::make_unique<StringIdLease>(fileIds(), name);
-    file_ = std::make_shared<TestReadFile>(fileId_->id(), kFileSize, fsStats);
-    options_.setNoCacheRetention(true);
+    file_ = std::make_shared<TestReadFile>(fileId_->id(), kFileSize, ioStats);
+    options_.setCacheable(false);
     bufferedInput_ = std::make_unique<CachedBufferedInput>(
         file_,
         MetricsLog::voidLog(),
@@ -740,13 +758,13 @@ class FileWithReadAhead {
         nullptr,
         StringIdLease{},
         stats,
-        fsStats,
+        ioStats,
         executor,
         options_);
     auto sequential = StreamIdentifier::sequentialFile();
     stream_ = bufferedInput_->enqueue(Region{0, file_->size()}, &sequential);
-    VELOX_CHECK(reinterpret_cast<CacheInputStream*>(stream_.get())
-                    ->testingNoCacheRetention());
+    VELOX_CHECK(!reinterpret_cast<CacheInputStream*>(stream_.get())
+                     ->testingCacheable());
     // Trigger load of next 4MB after reading the first 2MB of the previous 4MB
     // quantum.
     reinterpret_cast<CacheInputStream*>(stream_.get())->setPrefetchPct(50);
@@ -758,6 +776,11 @@ class FileWithReadAhead {
   }
 
  private:
+  std::shared_ptr<io::IoStatistics> dataIoStats_{
+      std::make_shared<io::IoStatistics>()};
+  std::shared_ptr<io::IoStatistics> metadataIoStats_{
+      std::make_shared<io::IoStatistics>()};
+
   std::unique_ptr<StringIdLease> fileId_;
   std::unique_ptr<CachedBufferedInput> bufferedInput_;
   std::unique_ptr<SeekableInputStream> stream_;
@@ -778,8 +801,8 @@ TEST_F(CacheTest, readAhead) {
   stats.reserve(kNumThreads);
   std::vector<std::thread> threads;
   threads.reserve(kNumThreads);
-  std::vector<std::shared_ptr<filesystems::File::IoStats>> fsStats;
-  fsStats.reserve(kNumThreads);
+  std::vector<std::shared_ptr<facebook::velox::IoStats>> ioStatsVec;
+  ioStatsVec.reserve(kNumThreads);
 
   // We read kFilesPerThread on each thread. The files are read in parallel,
   // advancing each file in turn. Read-ahead is triggered when a fraction of the
@@ -787,59 +810,68 @@ TEST_F(CacheTest, readAhead) {
 
   for (int threadIndex = 0; threadIndex < kNumThreads; ++threadIndex) {
     stats.push_back(std::make_shared<io::IoStatistics>());
-    fsStats.push_back(std::make_shared<filesystems::File::IoStats>());
-    threads.push_back(std::thread([threadIndex,
-                                   this,
-                                   threadStats = stats.back(),
-                                   fsStat = fsStats.back()]() {
-      std::vector<std::unique_ptr<FileWithReadAhead>> files;
-      auto firstFileNumber = threadIndex * kFilesPerThread;
-      for (auto i = 0; i < kFilesPerThread; ++i) {
-        auto name = fmt::format("prefetch_{}", i + firstFileNumber);
-        files.push_back(std::make_unique<FileWithReadAhead>(
-            name, cache_.get(), threadStats, fsStat, *pool_, executor_.get()));
-      }
-      std::vector<int64_t> totalRead(kFilesPerThread);
-      std::vector<int64_t> bytesLeft(kFilesPerThread);
-      for (auto counter = 0; counter < 100; ++counter) {
-        for (auto i = 0; i < kFilesPerThread; ++i) {
-          if (!files[i]) {
-            continue; // This set of files is finished.
+    ioStatsVec.push_back(std::make_shared<facebook::velox::IoStats>());
+    threads.push_back(
+        std::thread([threadIndex,
+                     this,
+                     threadStats = stats.back(),
+                     ioStat = ioStatsVec.back()]() {
+          std::vector<std::unique_ptr<FileWithReadAhead>> files;
+          auto firstFileNumber = threadIndex * kFilesPerThread;
+          for (auto i = 0; i < kFilesPerThread; ++i) {
+            auto name = fmt::format("prefetch_{}", i + firstFileNumber);
+            files.push_back(
+                std::make_unique<FileWithReadAhead>(
+                    name,
+                    cache_.get(),
+                    threadStats,
+                    ioStat,
+                    *pool_,
+                    executor_.get()));
           }
-          // Read from the next file. Different files advance at slightly
-          // different rates.
-          auto bytesNeeded = kMinRead + i * 1000;
-          while (bytesLeft[i] < bytesNeeded) {
-            const void* buffer;
-            int32_t size;
-            if (!files[i]->next(buffer, size)) {
-              // End of file. Check that a multiple of file size has been read.
-              EXPECT_EQ(0, totalRead[i] % FileWithReadAhead::kFileSize);
-              if (totalRead[i] >= 3 * FileWithReadAhead::kFileSize) {
-                files[i] = nullptr;
-                break;
+          std::vector<int64_t> totalRead(kFilesPerThread);
+          std::vector<int64_t> bytesLeft(kFilesPerThread);
+          for (auto counter = 0; counter < 100; ++counter) {
+            for (auto i = 0; i < kFilesPerThread; ++i) {
+              if (!files[i]) {
+                continue; // This set of files is finished.
+              }
+              // Read from the next file. Different files advance at slightly
+              // different rates.
+              auto bytesNeeded = kMinRead + i * 1000;
+              while (bytesLeft[i] < bytesNeeded) {
+                const void* buffer;
+                int32_t size;
+                if (!files[i]->next(buffer, size)) {
+                  // End of file. Check that a multiple of file size has been
+                  // read.
+                  EXPECT_EQ(0, totalRead[i] % FileWithReadAhead::kFileSize);
+                  if (totalRead[i] >= 3 * FileWithReadAhead::kFileSize) {
+                    files[i] = nullptr;
+                    break;
+                  }
+                  // Open a new file with a different unique name.
+                  auto newName = fmt::format(
+                      "prefetch_{}",
+                      (static_cast<int64_t>(firstFileNumber) + i + i) *
+                              1000000000 +
+                          totalRead[i]);
+                  files[i] = std::make_unique<FileWithReadAhead>(
+                      newName,
+                      cache_.get(),
+                      threadStats,
+                      ioStat,
+                      *pool_,
+                      executor_.get());
+                  continue;
+                }
+                totalRead[i] += size;
+                bytesLeft[i] += size;
               }
-              // Open a new file with a different unique name.
-              auto newName = fmt::format(
-                  "prefetch_{}",
-                  (static_cast<int64_t>(firstFileNumber) + i + i) * 1000000000 +
-                      totalRead[i]);
-              files[i] = std::make_unique<FileWithReadAhead>(
-                  newName,
-                  cache_.get(),
-                  threadStats,
-                  fsStat,
-                  *pool_,
-                  executor_.get());
-              continue;
+              bytesLeft[i] -= bytesNeeded;
             }
-            totalRead[i] += size;
-            bytesLeft[i] += size;
           }
-          bytesLeft[i] -= bytesNeeded;
-        }
-      }
-    }));
+        }));
   }
   int64_t bytes = 0;
   int32_t count = 0;
@@ -853,29 +885,29 @@ TEST_F(CacheTest, readAhead) {
   LOG(INFO) << count << " prefetches with total " << bytes << " bytes";
 }
 
-TEST_F(CacheTest, noCacheRetention) {
+TEST_F(CacheTest, cacheable) {
   const int64_t cacheSize = 1LL << 30;
   struct {
-    bool noCacheRetention;
+    bool cacheable;
     bool hasSsdCache;
     int readPct;
 
     std::string debugString() const {
       return fmt::format(
-          "noCacheRetention {}, hasSsdCache {}, readPct {}",
-          noCacheRetention,
+          "cacheable {}, hasSsdCache {}, readPct {}",
+          cacheable,
           hasSsdCache,
           readPct);
     }
   } testSettings[] = {
-      {true, true, 100},
-      {true, false, 100},
-      {false, false, 100},
       {false, true, 100},
-      {true, true, 10},
+      {false, false, 100},
       {true, false, 100},
+      {true, true, 100},
+      {false, true, 10},
       {false, false, 100},
-      {false, true, 100}};
+      {true, false, 100},
+      {true, true, 100}};
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
@@ -887,26 +919,26 @@ TEST_F(CacheTest, noCacheRetention) {
 
     // We read one stripe with all columns,
     readLoop(
-        "noCacheRetention",
+        "cacheable",
         20,
         testData.readPct,
         1,
         5,
         1,
-        testData.noCacheRetention,
-        ioStats_,
-        fsStats_);
+        testData.cacheable,
+        dataIoStats_,
+        ioStats_);
     // This is a cold read, so expect no hits.
-    ASSERT_EQ(ioStats_->ramHit().sum(), 0);
+    ASSERT_EQ(dataIoStats_->ramHit().sum(), 0);
     // Only one reference per column so there is no prefetch.
-    ASSERT_LT(0, ioStats_->prefetch().sum());
+    ASSERT_LT(0, dataIoStats_->prefetch().sum());
     // Expect some extra reading from coalescing.
-    ASSERT_LT(0, ioStats_->rawOverreadBytes());
-    ASSERT_LT(0, ioStats_->rawBytesRead());
+    ASSERT_LT(0, dataIoStats_->rawOverreadBytes());
+    ASSERT_LT(0, dataIoStats_->rawBytesRead());
     auto* ssdCache = cache_->ssdCache();
     if (ssdCache != nullptr) {
       ssdCache->waitForWriteToFinish();
-      if (testData.noCacheRetention) {
+      if (!testData.cacheable) {
         ASSERT_EQ(ssdCache->stats().entriesCached, 0);
       } else {
         ASSERT_GT(ssdCache->stats().entriesCached, 0);
@@ -916,8 +948,9 @@ TEST_F(CacheTest, noCacheRetention) {
     const auto cacheEntries = asyncDataCacheHelper_->cacheEntries();
     for (const auto& cacheEntry : cacheEntries) {
       const auto cacheEntryHelper =
-          std::make_unique<test::AsyncDataCacheEntryTestHelper>(cacheEntry);
-      if (testData.noCacheRetention) {
+          std::make_unique<cache::test::AsyncDataCacheEntryTestHelper>(
+              cacheEntry);
+      if (!testData.cacheable) {
         ASSERT_EQ(cacheEntryHelper->accessStats().numUses, 0);
         ASSERT_EQ(cacheEntryHelper->accessStats().lastUse, 0);
       } else {
@@ -937,6 +970,8 @@ TEST_F(CacheTest, loadQuotumTooLarge) {
   auto readFile =
       std::make_shared<TestReadFile>(fileId.id(), 10 << 20, nullptr);
   auto readOptions = io::ReaderOptions(pool_.get());
+  readOptions.setDataIoStats(dataIoStats_);
+  readOptions.setMetadataIoStats(metadataIoStats_);
   readOptions.setLoadQuantum(9 << 20 /*9MB*/);
   VELOX_ASSERT_THROW(
       std::make_unique<CachedBufferedInput>(
@@ -971,10 +1006,15 @@ TEST_F(CacheTest, ssdReadVerification) {
       cache_.get(),
       tracker,
       groupId,
+      dataIoStats_,
       ioStats_,
-      fsStats_,
       executor_.get(),
-      io::ReaderOptions(pool_.get()));
+      [&] {
+        io::ReaderOptions opts(pool_.get());
+        opts.setDataIoStats(dataIoStats_);
+        opts.setMetadataIoStats(metadataIoStats_);
+        return opts;
+      }());
 
   const auto readData = [&](uint32_t numBytesRead) {
     const uint64_t kNumBytesPerRead = 4 << 20;
@@ -999,9 +1039,15 @@ TEST_F(CacheTest, ssdReadVerification) {
   ASSERT_EQ(stats.numHit, 0);
   ASSERT_EQ(stats.ssdStats->entriesRead, 0);
   ASSERT_EQ(stats.ssdStats->readSsdCorruptions, 0);
-  ASSERT_GT(ioStats_->read().sum(), 0);
-  ASSERT_EQ(ioStats_->ramHit().sum(), 0);
-  ASSERT_EQ(ioStats_->ssdRead().sum(), 0);
+  ASSERT_GT(dataIoStats_->read().sum(), 0);
+  ASSERT_EQ(dataIoStats_->ramHit().sum(), 0);
+  ASSERT_EQ(dataIoStats_->ssdRead().sum(), 0);
+  // Cold read should have remote storage latency.
+  ASSERT_GT(dataIoStats_->storageReadLatencyUs().count(), 0);
+  // This test does not use coalesced loading for cold reads, so no coalesced
+  // latency is expected.
+  ASSERT_EQ(dataIoStats_->coalescedSsdLoadLatencyUs().count(), 0);
+  ASSERT_EQ(dataIoStats_->ssdCacheReadLatencyUs().count(), 0);
 
   // Read kSsdBytes of data.
   readData(kSsdBytes);
@@ -1011,9 +1057,10 @@ TEST_F(CacheTest, ssdReadVerification) {
   ASSERT_GT(stats.numHit, 0);
   ASSERT_EQ(stats.ssdStats->entriesRead, 0);
   ASSERT_EQ(stats.ssdStats->readSsdCorruptions, 0);
-  ASSERT_GT(ioStats_->read().sum(), 0);
-  ASSERT_GT(ioStats_->ramHit().sum(), 0);
-  ASSERT_EQ(ioStats_->ssdRead().sum(), 0);
+  ASSERT_GT(dataIoStats_->read().sum(), 0);
+  ASSERT_GT(dataIoStats_->ramHit().sum(), 0);
+  ASSERT_EQ(dataIoStats_->ssdRead().sum(), 0);
+  ASSERT_EQ(dataIoStats_->ssdCacheReadLatencyUs().count(), 0);
 
   // Read kSsdBytes of data.
   readData(kSsdBytes);
@@ -1023,9 +1070,10 @@ TEST_F(CacheTest, ssdReadVerification) {
   ASSERT_GT(stats.numHit, 0);
   ASSERT_GT(stats.ssdStats->entriesRead, 0);
   ASSERT_EQ(stats.ssdStats->readSsdCorruptions, 0);
-  ASSERT_GT(ioStats_->read().sum(), 0);
-  ASSERT_GT(ioStats_->ramHit().sum(), 0);
-  ASSERT_GT(ioStats_->ssdRead().sum(), 0);
+  ASSERT_GT(dataIoStats_->read().sum(), 0);
+  ASSERT_GT(dataIoStats_->ramHit().sum(), 0);
+  ASSERT_GT(dataIoStats_->ssdRead().sum(), 0);
+  ASSERT_GT(dataIoStats_->ssdCacheReadLatencyUs().count(), 0);
 
   // Corrupt SSD cache file.
   corruptSsdFile(fmt::format("{}/cache0", tempDirectory_->getPath()));
@@ -1034,22 +1082,22 @@ TEST_F(CacheTest, ssdReadVerification) {
 
   // Record the baseline stats.
   const auto prevStats = cache_->refreshStats();
-  const auto prevRead = ioStats_->read().sum();
-  const auto prevRamHit = ioStats_->ramHit().sum();
-  const auto prevSsdRead = ioStats_->ssdRead().sum();
+  const auto prevRead = dataIoStats_->read().sum();
+  const auto prevRamHit = dataIoStats_->ramHit().sum();
+  const auto prevSsdRead = dataIoStats_->ssdRead().sum();
 
   // Read from the corrupted cache.
   readData(kSsdBytes);
   waitForWrite();
   stats = cache_->refreshStats();
   // Expect all new reads to be recorded as corruptions.
-  ASSERT_GT(ioStats_->read().sum(), prevRead);
+  ASSERT_GT(dataIoStats_->read().sum(), prevRead);
   ASSERT_GT(stats.ssdStats->readSsdCorruptions, 0);
   ASSERT_EQ(
       stats.ssdStats->readSsdCorruptions,
       stats.ssdStats->entriesRead - prevStats.ssdStats->entriesRead);
   // Expect no new succeeded cache hits.
   ASSERT_EQ(stats.numHit, prevStats.numHit);
-  ASSERT_EQ(ioStats_->ramHit().sum(), prevRamHit);
-  ASSERT_EQ(ioStats_->ssdRead().sum(), prevSsdRead);
+  ASSERT_EQ(dataIoStats_->ramHit().sum(), prevRamHit);
+  ASSERT_EQ(dataIoStats_->ssdRead().sum(), prevSsdRead);
 }
diff --git a/velox/dwio/dwrf/test/ColumnStatisticsBase.h b/velox/dwio/dwrf/test/ColumnStatisticsBase.h
index 32b09aacfcf..e1264cd9f27 100644
--- a/velox/dwio/dwrf/test/ColumnStatisticsBase.h
+++ b/velox/dwio/dwrf/test/ColumnStatisticsBase.h
@@ -18,10 +18,14 @@
 
 #include <gtest/gtest.h>
 
+#include "velox/dwio/common/Arena.h"
 #include "velox/dwio/common/Statistics.h"
 #include "velox/dwio/dwrf/writer/StatisticsBuilder.h"
 
 namespace facebook::velox::dwrf {
+
+using dwio::common::ArenaCreate;
+
 class ColumnStatisticsBase {
  public:
   ColumnStatisticsBase()
@@ -752,8 +756,7 @@ class ColumnStatisticsBase {
 
       if (format == DwrfFormat::kDwrf) {
         auto columnStatistics =
-            google::protobuf::Arena::CreateMessage<proto::ColumnStatistics>(
-                arena_.get());
+            ArenaCreate<proto::ColumnStatistics>(arena_.get());
         if (from == State::kFalse) {
           columnStatistics->set_hasnull(false);
         } else if (from == State::kTrue) {
@@ -762,8 +765,8 @@ class ColumnStatisticsBase {
         target.merge(*buildColumnStatisticsFromProto(
             ColumnStatisticsWrapper(columnStatistics), context()));
       } else {
-        auto columnStatistics = google::protobuf::Arena::CreateMessage<
-            proto::orc::ColumnStatistics>(arena_.get());
+        auto columnStatistics =
+            ArenaCreate<proto::orc::ColumnStatistics>(arena_.get());
         if (from == State::kFalse) {
           columnStatistics->set_hasnull(false);
         } else if (from == State::kTrue) {
diff --git a/velox/dwio/dwrf/test/ColumnWriterIndexTest.cpp b/velox/dwio/dwrf/test/ColumnWriterIndexTest.cpp
index a8abecaed2f..abf23b57b67 100644
--- a/velox/dwio/dwrf/test/ColumnWriterIndexTest.cpp
+++ b/velox/dwio/dwrf/test/ColumnWriterIndexTest.cpp
@@ -371,9 +371,10 @@ class WriterEncodingIndexTest2 {
         }
       }
       proto::StripeFooter stripeFooter;
+      auto sfw = StripeFooterWriteWrapper(&stripeFooter);
       columnWriter->flush(
-          [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-            return *stripeFooter.add_encoding();
+          [&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+            return sfw.addEncoding();
           });
 
       // Simulate continue writing to next stripe, so internally buffered data
@@ -821,9 +822,10 @@ class IntegerColumnWriterDirectEncodingIndexTest : public testing::Test {
         // *all* streams
         EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(positionCount);
         proto::StripeFooter stripeFooter;
+        auto sfw = StripeFooterWriteWrapper(&stripeFooter);
         columnWriter->flush(
-            [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-              return *stripeFooter.add_encoding();
+            [&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+              return sfw.addEncoding();
             });
       } else {
         for (size_t i = 0; i != pageCount; ++i) {
@@ -847,9 +849,10 @@ class IntegerColumnWriterDirectEncodingIndexTest : public testing::Test {
         EXPECT_CALL(*mockIndexBuilderPtr, flush());
         EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(positionCount);
         proto::StripeFooter stripeFooter;
+        auto sfw = StripeFooterWriteWrapper(&stripeFooter);
         columnWriter->flush(
-            [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-              return *stripeFooter.add_encoding();
+            [&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+              return sfw.addEncoding();
             });
       }
 
@@ -972,9 +975,10 @@ class StringColumnWriterDictionaryEncodingIndexTest : public testing::Test {
       // Recording PRESENT stream starting positions for the new stripe.
       EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(4);
       proto::StripeFooter stripeFooter;
+      auto sfw = StripeFooterWriteWrapper(&stripeFooter);
       columnWriter->flush(
-          [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-            return *stripeFooter.add_encoding();
+          [&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+            return sfw.addEncoding();
           });
 
       // Simulate continue writing to next stripe, so internally buffered data
@@ -1128,9 +1132,10 @@ class StringColumnWriterDirectEncodingIndexTest : public testing::Test {
         // *all* streams
         EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(positionCount);
         proto::StripeFooter stripeFooter;
+        auto sfw = StripeFooterWriteWrapper(&stripeFooter);
         columnWriter->flush(
-            [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-              return *stripeFooter.add_encoding();
+            [&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+              return sfw.addEncoding();
             });
       } else {
         for (size_t i = 0; i != pageCount; ++i) {
@@ -1154,9 +1159,10 @@ class StringColumnWriterDirectEncodingIndexTest : public testing::Test {
         EXPECT_CALL(*mockIndexBuilderPtr, flush());
         EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(positionCount);
         proto::StripeFooter stripeFooter;
+        auto sfw = StripeFooterWriteWrapper(&stripeFooter);
         columnWriter->flush(
-            [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-              return *stripeFooter.add_encoding();
+            [&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+              return sfw.addEncoding();
             });
       }
 
@@ -1208,7 +1214,7 @@ class ListColumnWriterEncodingIndexTest : public testing::Test,
                                           public WriterEncodingIndexTest2 {
  public:
   ListColumnWriterEncodingIndexTest()
-      : WriterEncodingIndexTest2(ARRAY(REAL())){};
+      : WriterEncodingIndexTest2(ARRAY(REAL())) {};
 
  protected:
   static void SetUpTestCase() {
diff --git a/velox/dwio/dwrf/test/ColumnWriterStatsTests.cpp b/velox/dwio/dwrf/test/ColumnWriterStatsTests.cpp
index 8dad33a0d98..03cada99169 100644
--- a/velox/dwio/dwrf/test/ColumnWriterStatsTests.cpp
+++ b/velox/dwio/dwrf/test/ColumnWriterStatsTests.cpp
@@ -18,6 +18,7 @@
 #include <gtest/gtest.h>
 
 #include "velox/common/base/Nulls.h"
+#include "velox/common/io/IoStatistics.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/dwio/dwrf/reader/DwrfReader.h"
 #include "velox/dwio/dwrf/writer/FlushPolicy.h"
@@ -194,7 +195,9 @@ class ColumnWriterStatsTest : public ::testing::Test {
         std::make_shared<facebook::velox::InMemoryReadFile>(std::move(data));
     auto input = std::make_unique<BufferedInput>(readFile, *leafPool_);
 
-    dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+    dwio::common::ReaderOptions readerOpts(leafPool_.get());
+    readerOpts.setDataIoStats(dataIoStats_);
+    readerOpts.setMetadataIoStats(metadataIoStats_);
     RowReaderOptions rowReaderOpts;
     auto reader = std::make_unique<DwrfReader>(readerOpts, std::move(input));
     return reader->createRowReader(rowReaderOpts);
@@ -228,6 +231,10 @@ class ColumnWriterStatsTest : public ::testing::Test {
 
   std::shared_ptr<MemoryPool> rootPool_;
   std::shared_ptr<MemoryPool> leafPool_;
+  std::shared_ptr<io::IoStatistics> dataIoStats_ =
+      std::make_shared<io::IoStatistics>();
+  std::shared_ptr<io::IoStatistics> metadataIoStats_ =
+      std::make_shared<io::IoStatistics>();
 };
 
 template <typename T>
diff --git a/velox/dwio/dwrf/test/ColumnWriterTest.cpp b/velox/dwio/dwrf/test/ColumnWriterTest.cpp
index a1820322ddf..804c96f2103 100644
--- a/velox/dwio/dwrf/test/ColumnWriterTest.cpp
+++ b/velox/dwio/dwrf/test/ColumnWriterTest.cpp
@@ -213,7 +213,7 @@ VectorPtr populateBatch(
   auto valuesPtr = values->asMutableRange<T>();
 
   const size_t nulloptCount =
-      std::count(data.begin(), data.end(), std::nullopt);
+      std::count(data.cbegin(), data.cend(), std::nullopt);
   if (nulloptCount == 0) {
     size_t index = 0;
     for (auto val : data) {
@@ -354,12 +354,13 @@ void testDataTypeWriter(
 
   for (auto stripeI = 0; stripeI < stripeCount; ++stripeI) {
     proto::StripeFooter sf;
+    auto sfw = StripeFooterWriteWrapper(&sf);
     for (auto strideI = 0; strideI < strideCount; ++strideI) {
       writer->write(batch, common::Ranges::of(0, size));
       writer->createIndexEntry();
     }
-    writer->flush([&sf](uint32_t /* unused */) -> proto::ColumnEncoding& {
-      return *sf.add_encoding();
+    writer->flush([&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+      return sfw.addEncoding();
     });
 
     TestStripeStreams streams(context, sf, rowType, pool.get());
@@ -1055,6 +1056,7 @@ void testMapWriter(
     }
 
     proto::StripeFooter sf;
+    auto sfw = StripeFooterWriteWrapper(&sf);
     std::vector<VectorPtr> writtenBatches;
 
     // Write map/row
@@ -1072,8 +1074,8 @@ void testMapWriter(
       writtenBatches.push_back(toWrite);
     }
 
-    writer->flush([&sf](uint32_t /* unused */) -> proto::ColumnEncoding& {
-      return *sf.add_encoding();
+    writer->flush([&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+      return sfw.addEncoding();
     });
 
     auto validate = [&](bool returnFlatVector = false) {
@@ -1199,6 +1201,7 @@ void testMapWriterRow(
     }
 
     proto::StripeFooter sf;
+    auto sfw = StripeFooterWriteWrapper(&sf);
     std::vector<VectorPtr> writtenBatches;
 
     // Write map/row
@@ -1210,8 +1213,8 @@ void testMapWriterRow(
     writer->createIndexEntry();
     writtenBatches.push_back(toWrite);
 
-    writer->flush([&sf](uint32_t /* unused */) -> proto::ColumnEncoding& {
-      return *sf.add_encoding();
+    writer->flush([&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+      return sfw.addEncoding();
     });
 
     auto validate = [&](bool returnFlatVector = false) {
@@ -1479,8 +1482,9 @@ void testFlatMapWriter(
   writer->createIndexEntry();
 
   proto::StripeFooter sf;
-  writer->flush([&sf](uint32_t /* unused */) -> proto::ColumnEncoding& {
-    return *sf.add_encoding();
+  auto sfw = StripeFooterWriteWrapper(&sf);
+  writer->flush([&sfw](uint32_t /*unused*/) -> ColumnEncodingWriteWrapper {
+    return sfw.addEncoding();
   });
 
   // Reading the vector out
@@ -1503,6 +1507,93 @@ void testFlatMapWriter(
   }
 }
 
+// Regression test for dangling StringView keys in FlatMapColumnWriter.
+//
+// FlatMapColumnWriter stores StringView keys in an F14NodeMap (valueWriters_).
+// StringView is non-owning — it holds a pointer to external string data.
+// When the input batch is released between writes, the stored StringViews
+// become dangling. On a subsequent write that triggers F14 rehash,
+// F14Table::rehashImpl recomputes hashes from the dangling pointers and
+// hits assertion: hp.second == srcChunk->tag(srcI).
+//
+// This test reproduces the crash by:
+// 1. Writing a batch with long string keys (>12 chars → external pointer)
+// 2. Corrupting the backing buffer to simulate freed memory
+// 3. Writing a second batch with enough new keys to trigger F14 rehash
+//
+// With the bug: crashes with SIGABRT in F14Table::rehashImpl.
+// With the fix: passes (keys are properly owned).
+TEST_F(ColumnWriterTest, TestFlatMapDanglingStringViewKeyOnRehash) {
+  const auto rowType = CppToType<Row<Map<StringView, int32_t>>>::create();
+  const auto writerSchema = TypeWithId::create(rowType);
+  const auto writerDataTypeWithId = writerSchema->childAt(0);
+
+  const auto config = std::make_shared<Config>();
+  config->set(Config::FLATTEN_MAP, true);
+  config->set(Config::MAP_FLAT_COLS, {writerDataTypeWithId->column()});
+  config->set(Config::MAP_FLAT_DISABLE_DICT_ENCODING, true);
+  config->set<uint32_t>(Config::MAP_FLAT_MAX_KEYS, 100);
+
+  WriterContext context{config, memory::memoryManager()->addRootPool()};
+  context.initBuffer();
+  const auto writer = BaseColumnWriter::create(context, *writerDataTypeWithId);
+
+  using b = MapBuilder<StringView, int32_t>;
+
+  // Batch 1: 10 rows, each with one key-value pair.
+  // Keys are >12 chars so StringView uses an external data pointer
+  // (not inline storage). We control the backing buffer so we can
+  // corrupt it after writing to reliably simulate use-after-free.
+  constexpr int kBatch1Size = 10;
+  constexpr int kKeySlotSize = 32;
+  auto keyDataBuf = std::make_unique<char[]>(kBatch1Size * kKeySlotSize);
+
+  {
+    b::rows rows;
+    for (int i = 0; i < kBatch1Size; ++i) {
+      auto key = fmt::format("very_long_string_key_{:04d}", i);
+      ASSERT_GT(key.size(), 12u);
+      memcpy(keyDataBuf.get() + i * kKeySlotSize, key.data(), key.size());
+      StringView sv(
+          keyDataBuf.get() + i * kKeySlotSize,
+          static_cast<int32_t>(key.size()));
+      rows.emplace_back(b::row{b::pair{sv, static_cast<int32_t>(i)}});
+    }
+    auto batch = b::create(*pool_, rows);
+    writer->write(batch, common::Ranges::of(0, batch->size()));
+  }
+
+  // Corrupt batch 1's key data to simulate the input vector's string
+  // buffer being freed and reused. The writer's F14NodeMap still holds
+  // StringView keys pointing into this buffer.
+  memset(keyDataBuf.get(), 0xFF, kBatch1Size * kKeySlotSize);
+
+  // Batch 2: 15 rows with new keys. Combined with batch 1's 10 keys,
+  // the total of 25 unique keys exceeds the F14NodeMap's initial
+  // capacity, triggering rehashImpl. During rehash, F14 recomputes
+  // hashes for batch 1's stored StringView keys — which now point to
+  // corrupted memory — producing different hashes and hitting the
+  // assertion: hp.second == srcChunk->tag(srcI).
+  {
+    std::vector<std::string> keyStrings;
+    keyStrings.reserve(15);
+    for (int i = 0; i < 15; ++i) {
+      keyStrings.push_back(fmt::format("different_long_key_b2_{:04d}", i));
+    }
+    b::rows rows;
+    for (int i = 0; i < 15; ++i) {
+      rows.emplace_back(
+          b::row{b::pair{
+              StringView(keyStrings[i]),
+              static_cast<int32_t>(i + kBatch1Size)}});
+    }
+    auto batch = b::create(*pool_, rows);
+    writer->write(batch, common::Ranges::of(0, batch->size()));
+  }
+
+  writer->createIndexEntry();
+}
+
 TEST_F(ColumnWriterTest, TestFlatMapKeyNotInAllBatches) {
   VectorMaker maker(pool_.get());
   // Test the case where not all keys appear in all batches.
@@ -1846,7 +1937,9 @@ std::unique_ptr<DwrfReader> getDwrfReader(
     MemoryPool& leafPool,
     const std::shared_ptr<const RowType> type,
     const VectorPtr& batch,
-    bool useFlatMap) {
+    bool useFlatMap,
+    std::shared_ptr<io::IoStatistics> dataIoStats,
+    std::shared_ptr<io::IoStatistics> metadataIoStats) {
   auto config = std::make_shared<Config>();
   if (useFlatMap) {
     config->set(Config::FLATTEN_MAP, true);
@@ -1872,6 +1965,8 @@ std::unique_ptr<DwrfReader> getDwrfReader(
 
   std::string data(sinkPtr->data(), sinkPtr->size());
   dwio::common::ReaderOptions readerOpts{&leafPool};
+  readerOpts.setDataIoStats(std::move(dataIoStats));
+  readerOpts.setMetadataIoStats(std::move(metadataIoStats));
   return std::make_unique<DwrfReader>(
       readerOpts,
       std::make_unique<BufferedInput>(
@@ -1894,8 +1989,12 @@ void testMapWriterStats(const std::shared_ptr<const RowType> type) {
   auto rootPool = memory::memoryManager()->addRootPool();
   auto leafPool = memory::memoryManager()->addLeafPool();
   auto batch = BatchMaker::createBatch(type, 10, *leafPool);
-  auto mapReader = getDwrfReader(*rootPool, *leafPool, type, batch, false);
-  auto flatMapReader = getDwrfReader(*rootPool, *leafPool, type, batch, true);
+  auto dataIoStats = std::make_shared<io::IoStatistics>();
+  auto metadataIoStats = std::make_shared<io::IoStatistics>();
+  auto mapReader = getDwrfReader(
+      *rootPool, *leafPool, type, batch, false, dataIoStats, metadataIoStats);
+  auto flatMapReader = getDwrfReader(
+      *rootPool, *leafPool, type, batch, true, dataIoStats, metadataIoStats);
   ASSERT_EQ(
       mapReader->getFooter().statisticsSize(),
       flatMapReader->getFooter().statisticsSize());
@@ -2364,6 +2463,7 @@ struct IntegerColumnWriterTypedTestCase {
 
     for (size_t i = 0; i != flushCount; ++i) {
       proto::StripeFooter stripeFooter;
+      auto sfw = StripeFooterWriteWrapper(&stripeFooter);
       for (size_t j = 0; j != repetitionCount; ++j) {
         columnWriter->write(batch, common::Ranges::of(0, batch->size()));
         postProcess(*columnWriter, i, j);
@@ -2371,8 +2471,8 @@ struct IntegerColumnWriterTypedTestCase {
       }
       // We only flush once per stripe.
       columnWriter->flush(
-          [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-            return *stripeFooter.add_encoding();
+          [&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+            return sfw.addEncoding();
           });
 
       // Read and verify.
@@ -3524,7 +3624,7 @@ struct StringColumnWriterTestCase {
         postProcess{postProcess},
         repetitionCount{repetitionCount},
         flushCount{flushCount},
-        type{CppToType<folly::StringPiece>::create()} {}
+        type{CppToType<std::string_view>::create()} {}
 
   virtual ~StringColumnWriterTestCase() = default;
 
@@ -3598,6 +3698,7 @@ struct StringColumnWriterTestCase {
 
     for (size_t i = 0; i != flushCount; ++i) {
       proto::StripeFooter stripeFooter;
+      auto sfw = StripeFooterWriteWrapper(&stripeFooter);
       // Write Stride
       for (size_t j = 0; j != repetitionCount; ++j) {
         // TODO: break the batch into multiple strides.
@@ -3608,8 +3709,8 @@ struct StringColumnWriterTestCase {
 
       // Flush when all strides are written (once per stripe).
       columnWriter->flush(
-          [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-            return *stripeFooter.add_encoding();
+          [&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+            return sfw.addEncoding();
           });
 
       // Read and verify.
@@ -4438,8 +4539,9 @@ TEST_F(ColumnWriterTest, IntDictWriterDirectValueOverflow) {
   writer->write(vector, common::Ranges::of(0, size));
   writer->createIndexEntry();
   proto::StripeFooter sf;
-  writer->flush([&sf](auto /* unused */) -> proto::ColumnEncoding& {
-    return *sf.add_encoding();
+  auto sfw = StripeFooterWriteWrapper(&sf);
+  writer->flush([&sfw](auto /* unused */) -> ColumnEncodingWriteWrapper {
+    return sfw.addEncoding();
   });
   auto& enc = sf.encoding(0);
   ASSERT_EQ(enc.kind(), proto::ColumnEncoding_Kind_DICTIONARY);
@@ -4483,8 +4585,9 @@ TEST_F(ColumnWriterTest, ShortDictWriterDictValueOverflow) {
   writer->write(vector, common::Ranges::of(0, size));
   writer->createIndexEntry();
   proto::StripeFooter sf;
-  writer->flush([&sf](auto /* unused */) -> proto::ColumnEncoding& {
-    return *sf.add_encoding();
+  auto sfw = StripeFooterWriteWrapper(&sf);
+  writer->flush([&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+    return sfw.addEncoding();
   });
   auto& enc = sf.encoding(0);
   ASSERT_EQ(enc.kind(), proto::ColumnEncoding_Kind_DICTIONARY);
@@ -4524,8 +4627,9 @@ TEST_F(ColumnWriterTest, RemovePresentStream) {
   writer->write(vector, common::Ranges::of(0, size));
   writer->createIndexEntry();
   proto::StripeFooter sf;
-  writer->flush([&sf](auto /* unused */) -> proto::ColumnEncoding& {
-    return *sf.add_encoding();
+  auto sfw = StripeFooterWriteWrapper(&sf);
+  writer->flush([&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+    return sfw.addEncoding();
   });
 
   // get data stream
@@ -4562,8 +4666,9 @@ TEST_F(ColumnWriterTest, ColumnIdInStream) {
   writer->write(vector, common::Ranges::of(0, size));
   writer->createIndexEntry();
   proto::StripeFooter sf;
-  writer->flush([&sf](auto /* unused */) -> proto::ColumnEncoding& {
-    return *sf.add_encoding();
+  auto sfw = StripeFooterWriteWrapper(&sf);
+  writer->flush([&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+    return sfw.addEncoding();
   });
 
   // get data stream
@@ -4691,8 +4796,9 @@ struct DictColumnWriterTestCase {
     writer->createIndexEntry();
 
     proto::StripeFooter sf;
-    writer->flush([&sf](uint32_t /* unused */) -> proto::ColumnEncoding& {
-      return *sf.add_encoding();
+    auto sfw = StripeFooterWriteWrapper(&sf);
+    writer->flush([&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+      return sfw.addEncoding();
     });
 
     // Reading the vector out
diff --git a/velox/dwio/dwrf/test/CompressionTest.cpp b/velox/dwio/dwrf/test/CompressionTest.cpp
index b2230ff21e6..9343af57e6d 100644
--- a/velox/dwio/dwrf/test/CompressionTest.cpp
+++ b/velox/dwio/dwrf/test/CompressionTest.cpp
@@ -401,10 +401,11 @@ TEST_P(CompressionTest, getCompressionBufferOOM) {
       {true, true}, {true, false}, {false, true}, {false, false}};
 
   for (const auto& testData : testSettings) {
-    SCOPED_TRACE(fmt::format(
-        "{} compression {}",
-        testData.debugString(),
-        compressionKindToString(kind_)));
+    SCOPED_TRACE(
+        fmt::format(
+            "{} compression {}",
+            testData.debugString(),
+            compressionKindToString(kind_)));
 
     auto config = std::make_shared<Config>();
     config->set<CompressionKind>(Config::COMPRESSION, kind_);
diff --git a/velox/dwio/dwrf/test/ConfigTests.cpp b/velox/dwio/dwrf/test/ConfigTests.cpp
index 6475d4e89bd..7097f1e1e99 100644
--- a/velox/dwio/dwrf/test/ConfigTests.cpp
+++ b/velox/dwio/dwrf/test/ConfigTests.cpp
@@ -78,6 +78,10 @@ struct ConfigTestParams {
   std::vector<uint32_t> expectedCols{}; // do we expect the spec to be valid
 };
 
+inline void PrintTo(const ConfigTestParams& param, std::ostream* os) {
+  *os << "cols:" << param.inputCols;
+}
+
 TEST(ConfigTests, writerOptionsDefaultConfig) {
   WriterOptions options;
   const facebook::velox::config::ConfigBase base({});
diff --git a/velox/dwio/dwrf/test/DataBufferHolderTests.cpp b/velox/dwio/dwrf/test/DataBufferHolderTests.cpp
index 6b53cbfab22..d4b5f6e1238 100644
--- a/velox/dwio/dwrf/test/DataBufferHolderTests.cpp
+++ b/velox/dwio/dwrf/test/DataBufferHolderTests.cpp
@@ -36,9 +36,15 @@ TEST_F(DataBufferHolderTest, InputCheck) {
   VELOX_ASSERT_THROW((DataBufferHolder{*pool_, 1024, 2048}), "");
   VELOX_ASSERT_THROW((DataBufferHolder{*pool_, 1024, 1024, 1.1f}), "");
 
-  { DataBufferHolder holder{*pool_, 1024}; }
-  { DataBufferHolder holder{*pool_, 1024, 512}; }
-  { DataBufferHolder holder{*pool_, 1024, 512, 3.0f}; }
+  {
+    DataBufferHolder holder{*pool_, 1024};
+  }
+  {
+    DataBufferHolder holder{*pool_, 1024, 512};
+  }
+  {
+    DataBufferHolder holder{*pool_, 1024, 512, 3.0f};
+  }
 }
 
 TEST_F(DataBufferHolderTest, TakeAndGetBuffer) {
diff --git a/velox/dwio/dwrf/test/TestDecompression.cpp b/velox/dwio/dwrf/test/DecompressionTest.cpp
similarity index 96%
rename from velox/dwio/dwrf/test/TestDecompression.cpp
rename to velox/dwio/dwrf/test/DecompressionTest.cpp
index 3dcf5f68e46..7a4d6b28377 100644
--- a/velox/dwio/dwrf/test/TestDecompression.cpp
+++ b/velox/dwio/dwrf/test/DecompressionTest.cpp
@@ -336,7 +336,7 @@ TEST_F(DecompressionTest, testLzoSmall) {
   std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
       CompressionKind_LZO,
       std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))),
+          new SeekableArrayInputStream(buffer, std::size(buffer))),
       128 * 1024);
   const void* ptr;
   int32_t length;
@@ -353,7 +353,7 @@ TEST_F(DecompressionTest, testLzoSmall) {
 TEST_F(DecompressionTest, testLzoLong) {
   // set up a framed lzo buffer with 100,000 'a'
   unsigned char buffer[482];
-  bzero(buffer, VELOX_ARRAY_SIZE(buffer));
+  bzero(buffer, std::size(buffer));
   // header
   buffer[0] = 190;
   buffer[1] = 3;
@@ -378,7 +378,7 @@ TEST_F(DecompressionTest, testLzoLong) {
   std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
       CompressionKind_LZO,
       std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))),
+          new SeekableArrayInputStream(buffer, std::size(buffer))),
       128 * 1024);
   const void* ptr;
   int32_t length;
@@ -413,7 +413,7 @@ TEST_F(DecompressionTest, testLz4Small) {
   std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
       CompressionKind_LZ4,
       std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))),
+          new SeekableArrayInputStream(buffer, std::size(buffer))),
       128 * 1024);
   const void* ptr;
   int32_t length;
@@ -430,7 +430,7 @@ TEST_F(DecompressionTest, testLz4Small) {
 TEST_F(DecompressionTest, testLz4Long) {
   // set up a framed lzo buffer with 100,000 'a'
   unsigned char buffer[406];
-  memset(buffer, 255, VELOX_ARRAY_SIZE(buffer));
+  memset(buffer, 255, std::size(buffer));
   // header
   buffer[0] = 38;
   buffer[1] = 3;
@@ -448,7 +448,7 @@ TEST_F(DecompressionTest, testLz4Long) {
   std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
       CompressionKind_LZ4,
       std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))),
+          new SeekableArrayInputStream(buffer, std::size(buffer))),
       128 * 1024);
   const void* ptr;
   int32_t length;
@@ -465,7 +465,7 @@ TEST_F(DecompressionTest, testCreateZlib) {
   std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
       CompressionKind_ZLIB,
       std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))),
+          new SeekableArrayInputStream(buffer, std::size(buffer))),
       32768);
   EXPECT_EQ(
       "PagedInputStream StreamInfo (Test Decompression) input stream (SeekableArrayInputStream 0 of 8) State (0) remaining length (0)",
@@ -497,7 +497,7 @@ TEST_F(DecompressionTest, testLiteralBlocks) {
   std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
       CompressionKind_ZLIB,
       std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer), 5)),
+          new SeekableArrayInputStream(buffer, std::size(buffer), 5)),
       5);
   EXPECT_EQ(
       "PagedInputStream StreamInfo (Test Decompression) input stream (SeekableArrayInputStream 0 of 23) State (0) remaining length (0)",
@@ -539,7 +539,7 @@ TEST_F(DecompressionTest, testInflate) {
   std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
       CompressionKind_ZLIB,
       std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))),
+          new SeekableArrayInputStream(buffer, std::size(buffer))),
       1000);
   const void* ptr;
   int32_t length;
@@ -552,6 +552,25 @@ TEST_F(DecompressionTest, testInflate) {
   }
 }
 
+TEST_F(DecompressionTest, testSmallBufferInflate) {
+  const unsigned char buffer[] = {
+      0xe, 0x0, 0x0, 0x63, 0x60, 0x64, 0x62, 0xc0, 0x8d, 0x0};
+  const std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
+      CompressionKind_ZLIB,
+      std::make_unique<SeekableArrayInputStream>(buffer, std::size(buffer)),
+      1 // blockSize 1 to test multiple inflate calls during decompression.
+  );
+  const void* ptr;
+  int32_t length;
+  ASSERT_EQ(true, result->Next(&ptr, &length));
+  ASSERT_EQ(30, length);
+  for (int32_t i = 0; i < 10; ++i) {
+    for (int32_t j = 0; j < 3; ++j) {
+      EXPECT_EQ(j, static_cast<const char*>(ptr)[i * 3 + j]);
+    }
+  }
+}
+
 TEST_F(DecompressionTest, testInflateSequence) {
   const unsigned char buffer[] = {0xe,  0x0,  0x0,  0x63, 0x60, 0x64, 0x62,
                                   0xc0, 0x8d, 0x0,  0xe,  0x0,  0x0,  0x63,
@@ -559,7 +578,7 @@ TEST_F(DecompressionTest, testInflateSequence) {
   std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
       CompressionKind_ZLIB,
       std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer), 3)),
+          new SeekableArrayInputStream(buffer, std::size(buffer), 3)),
       1000);
   const void* ptr;
   int32_t length;
@@ -594,7 +613,7 @@ TEST_F(DecompressionTest, testSkipZlib) {
   std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
       CompressionKind_ZLIB,
       std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer), 5)),
+          new SeekableArrayInputStream(buffer, std::size(buffer), 5)),
       5);
   const void* ptr;
   int32_t length;
@@ -906,7 +925,7 @@ class TestSeek : public ::testing::Test {
     size_t arr[][2]{{0, 0}, {0, seekPos}, {offset1, seekPos}, {offset1, 0}};
     char* input[]{input1, input1, input2, input2};
 
-    for (size_t i = 0; i < VELOX_ARRAY_SIZE(arr); ++i) {
+    for (size_t i = 0; i < std::size(arr); ++i) {
       auto pos = arr[i];
       std::vector<uint64_t> list{pos[0], pos[1]};
       PositionProvider pp(list);
@@ -1046,8 +1065,8 @@ class TestingSeekableInputStream : public SeekableInputStream {
     return true;
   }
 
-  google::protobuf::int64 ByteCount() const override {
-    return position_;
+  int64_t ByteCount() const override {
+    return static_cast<int64_t>(position_);
   }
 
   void seekToPosition(PositionProvider& position) override {
@@ -1097,7 +1116,7 @@ TEST_F(TestSeek, uncompressedLarge) {
       entry.getCompressed()[i] = static_cast<char>(i);
     }
     written += runSize + kHeaderSize;
-    data.insert(data.end(), entry.data().begin(), entry.data().end());
+    data.insert(data.end(), entry.data().cbegin(), entry.data().cend());
   }
   auto stream = createTestDecompressor(
       CompressionKind_SNAPPY,
diff --git a/velox/dwio/dwrf/test/DecryptionTests.cpp b/velox/dwio/dwrf/test/DecryptionTests.cpp
index 6a19a41c484..7cff7a4acb2 100644
--- a/velox/dwio/dwrf/test/DecryptionTests.cpp
+++ b/velox/dwio/dwrf/test/DecryptionTests.cpp
@@ -32,7 +32,8 @@ TEST(Decryption, NotEncrypted) {
   HiveTypeParser parser;
   auto type = parser.parse("struct<a:int>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   TestDecrypterFactory factory;
   auto handler = DecryptionHandler::create(footer, &factory);
   ASSERT_FALSE(handler->isEncrypted());
@@ -42,7 +43,8 @@ TEST(Decryption, NoKeyProvider) {
   HiveTypeParser parser;
   auto type = parser.parse("struct<a:int>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   footer.mutable_encryption();
   TestDecrypterFactory factory;
   ASSERT_THROW(
@@ -53,7 +55,8 @@ TEST(Decryption, EmptyGroup) {
   HiveTypeParser parser;
   auto type = parser.parse("struct<a:int>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto enc = footer.mutable_encryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
   TestDecrypterFactory factory;
@@ -65,7 +68,8 @@ TEST(Decryption, EmptyNodes) {
   HiveTypeParser parser;
   auto type = parser.parse("struct<a:int>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto enc = footer.mutable_encryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
   auto group = enc->add_encryptiongroups();
@@ -79,7 +83,8 @@ TEST(Decryption, StatsMismatch) {
   HiveTypeParser parser;
   auto type = parser.parse("struct<a:int>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto enc = footer.mutable_encryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
   auto group = enc->add_encryptiongroups();
@@ -96,7 +101,8 @@ TEST(Decryption, KeyExistenceMismatch) {
   HiveTypeParser parser;
   auto type = parser.parse("struct<a:int>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto enc = footer.mutable_encryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
   for (size_t i = 0; i < 2; ++i) {
@@ -116,7 +122,8 @@ TEST(Decryption, ReuseStripeKey) {
   HiveTypeParser parser;
   auto type = parser.parse("struct<a:int>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto enc = footer.mutable_encryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
   auto group = enc->add_encryptiongroups();
@@ -135,7 +142,8 @@ TEST(Decryption, StripeKeyMismatch) {
   HiveTypeParser parser;
   auto type = parser.parse("struct<a:int>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto enc = footer.mutable_encryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
   auto group = enc->add_encryptiongroups();
@@ -153,7 +161,8 @@ TEST(Decryption, Basic) {
   HiveTypeParser parser;
   auto type = parser.parse("struct<a:int,b:float,c:string,d:double>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto enc = footer.mutable_encryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
   for (auto i = 0; i < 5; ++i) {
@@ -183,7 +192,8 @@ TEST(Decryption, NestedType) {
   auto type = parser.parse(
       "struct<a:int,b:map<float,map<int,double>>,c:struct<a:string,b:int>,d:array<double>>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto enc = footer.mutable_encryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
 
@@ -222,7 +232,8 @@ TEST(Decryption, RootNode) {
   HiveTypeParser parser;
   auto type = parser.parse("struct<a:int,b:int>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto enc = footer.mutable_encryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
   auto group = enc->add_encryptiongroups();
@@ -238,7 +249,8 @@ TEST(Decryption, GroupOverlap) {
   HiveTypeParser parser;
   auto type = parser.parse("struct<a:struct<a:float,b:double>>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto enc = footer.mutable_encryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
 
diff --git a/velox/dwio/dwrf/test/DirectBufferedInputTest.cpp b/velox/dwio/dwrf/test/DirectBufferedInputTest.cpp
index e3ddd5b457d..c7d74c333a6 100644
--- a/velox/dwio/dwrf/test/DirectBufferedInputTest.cpp
+++ b/velox/dwio/dwrf/test/DirectBufferedInputTest.cpp
@@ -52,12 +52,15 @@ class DirectBufferedInputTest : public testing::Test {
 
   void SetUp() override {
     executor_ = std::make_unique<folly::IOThreadPoolExecutor>(10, 10);
-    ioStats_ = std::make_shared<IoStatistics>();
+    ioStatistics_ = std::make_shared<IoStatistics>();
+    metadataIoStats_ = std::make_shared<IoStatistics>();
     fileIoStats_ = std::make_shared<IoStatistics>();
-    fsStats_ = std::make_shared<facebook::velox::filesystems::File::IoStats>();
+    ioStats_ = std::make_shared<facebook::velox::IoStats>();
     tracker_ = std::make_shared<cache::ScanTracker>("", nullptr, kLoadQuantum);
-    file_ = std::make_shared<TestReadFile>(11, 100 << 20, fsStats_);
+    file_ = std::make_shared<TestReadFile>(11, 100 << 20, ioStats_);
     opts_ = std::make_unique<dwio::common::ReaderOptions>(pool_.get());
+    opts_->setDataIoStats(ioStatistics_);
+    opts_->setMetadataIoStats(metadataIoStats_);
     opts_->setLoadQuantum(kLoadQuantum);
   }
 
@@ -66,16 +69,15 @@ class DirectBufferedInputTest : public testing::Test {
   }
 
   std::unique_ptr<DirectBufferedInput> makeInput(
-      const std::shared_ptr<facebook::velox::filesystems::File::IoStats>&
-          fsStats) {
+      const std::shared_ptr<facebook::velox::IoStats>& ioStats) {
     return std::make_unique<DirectBufferedInput>(
         file_,
         dwio::common::MetricsLog::voidLog(),
         StringIdLease{},
         tracker_,
         StringIdLease{},
-        ioStats_,
-        fsStats,
+        ioStatistics_,
+        ioStats,
         executor_.get(),
         *opts_);
   }
@@ -85,10 +87,9 @@ class DirectBufferedInputTest : public testing::Test {
   void testLoads(
       std::vector<TestRegion> regions,
       int32_t numIos,
-      const std::shared_ptr<facebook::velox::filesystems::File::IoStats>&
-          fsStats) {
+      const std::shared_ptr<facebook::velox::IoStats>& ioStats) {
     auto previous = file_->numIos();
-    auto input = makeInput(fsStats);
+    auto input = makeInput(ioStats);
     std::vector<std::unique_ptr<SeekableInputStream>> streams;
     for (auto i = 0; i < regions.size(); ++i) {
       if (regions[i].length > 0) {
@@ -135,9 +136,10 @@ class DirectBufferedInputTest : public testing::Test {
   std::unique_ptr<dwio::common::ReaderOptions> opts_;
   std::shared_ptr<TestReadFile> file_;
   std::shared_ptr<cache::ScanTracker> tracker_;
-  std::shared_ptr<IoStatistics> ioStats_;
+  std::shared_ptr<IoStatistics> ioStatistics_;
+  std::shared_ptr<IoStatistics> metadataIoStats_;
   std::shared_ptr<IoStatistics> fileIoStats_;
-  std::shared_ptr<facebook::velox::filesystems::File::IoStats> fsStats_;
+  std::shared_ptr<facebook::velox::IoStats> ioStats_;
   std::unique_ptr<folly::IOThreadPoolExecutor> executor_;
   std::shared_ptr<memory::MemoryPool> pool_{
       memory::memoryManager()->addLeafPool()};
@@ -154,7 +156,7 @@ TEST_F(DirectBufferedInputTest, basic) {
        {7004000, 2000000},
        {20000000, 10000000}},
       4,
-      fsStats_);
+      ioStats_);
 
   // All but the last coalesce into one , the last is read in 2 parts. The
   // columns are now dense and coalesce goes up to 128MB if gaps are small
@@ -166,55 +168,54 @@ TEST_F(DirectBufferedInputTest, basic) {
        {7004000, 2000000},
        {20000000, 10000000}},
       3,
-      fsStats_);
+      ioStats_);
 
   // Mark the first 4 ranges as densely accessed.
   makeDense(4);
 
   // The first and first part of second coalesce.
-  testLoads({{100, 100}, {1000, 10000000}}, 2, fsStats_);
+  testLoads({{100, 100}, {1000, 10000000}}, 2, ioStats_);
 
   // The first is read in two parts, the tail of the first does not coalesce
   // with the second.
-  testLoads({{1000, 10000000}, {10001000, 1000}}, 3, fsStats_);
+  testLoads({{1000, 10000000}, {10001000, 1000}}, 3, ioStats_);
 
   // One large standalone read in 2 parts.
-  testLoads({{1000, 10000000}}, 2, fsStats_);
+  testLoads({{1000, 10000000}}, 2, ioStats_);
 
   // Small standalone read in 1 part.
-  testLoads({{100, 100}}, 1, fsStats_);
+  testLoads({{100, 100}}, 1, ioStats_);
 
   // Two small far apart
-  testLoads({{100, 100}, {1000000, 100}}, 2, fsStats_);
+  testLoads({{100, 100}, {1000000, 100}}, 2, ioStats_);
   // The two coalesce because the first fits within load quantum + max coalesce
   // distance.
-  testLoads({{1000, 8500000}, {8510000, 1000000}}, 1, fsStats_);
+  testLoads({{1000, 8500000}, {8510000, 1000000}}, 1, ioStats_);
 
   // The two coalesce because the first fits within load quantum + max coalesce
   // distance. The tail of the second does not coalesce.
-  testLoads({{1000, 8500000}, {8510000, 8400000}}, 2, fsStats_);
+  testLoads({{1000, 8500000}, {8510000, 8400000}}, 2, ioStats_);
 
   // The first reads in 2 parts and does not coalesce to the second, which reads
   // in one part.
-  testLoads({{1000, 9000000}, {9010000, 1000000}}, 3, fsStats_);
+  testLoads({{1000, 9000000}, {9010000, 1000000}}, 3, ioStats_);
 }
 
 TEST_F(DirectBufferedInputTest, noRedownloadCoalescedPrefetch) {
-  testLoads({{100, 100}, {201, 1, false}, {202, 100}}, 1, fsStats_);
-  testLoads({{100, 100}, {201, 1, true}, {202, 100}}, 1, fsStats_);
+  testLoads({{100, 100}, {201, 1, false}, {202, 100}}, 1, ioStats_);
+  testLoads({{100, 100}, {201, 1, true}, {202, 100}}, 1, ioStats_);
 }
 
 TEST_F(DirectBufferedInputTest, coalesedPrefetchOverlap) {
   testLoads(
-      {{100, 100}, {201, 1, false}, {201, 2, false}, {203, 100}}, 2, fsStats_);
+      {{100, 100}, {201, 1, false}, {201, 2, false}, {203, 100}}, 2, ioStats_);
   testLoads(
-      {{100, 100}, {201, 1, true}, {201, 2, true}, {203, 100}}, 2, fsStats_);
+      {{100, 100}, {201, 1, true}, {201, 2, true}, {203, 100}}, 2, ioStats_);
 }
 
 TEST_F(DirectBufferedInputTest, ioStatsLifeTimeTest) {
   for (size_t i = 0; i < 10; i++) {
-    auto stats =
-        std::make_shared<facebook::velox::filesystems::File::IoStats>();
+    auto stats = std::make_shared<facebook::velox::IoStats>();
     // Induce a tiny sleep so that we're more likely to destruct the thread as
     // we're trying to bump ioStats inside the test file
     std::thread t([s = stats]() mutable {
diff --git a/velox/dwio/dwrf/test/E2EFilterTest.cpp b/velox/dwio/dwrf/test/E2EFilterTest.cpp
index 43b67e91e55..61d9735af26 100644
--- a/velox/dwio/dwrf/test/E2EFilterTest.cpp
+++ b/velox/dwio/dwrf/test/E2EFilterTest.cpp
@@ -63,7 +63,8 @@ class E2EFilterTest : public E2EFilterTestBase {
   void writeToMemory(
       const TypePtr& type,
       const std::vector<RowVectorPtr>& batches,
-      bool forRowGroupSkip = false) override {
+      bool forRowGroupSkip,
+      const std::vector<std::string>& /*indexColumns*/ = {}) override {
     auto options = createWriterOptions(type);
     int32_t flushCounter = 0;
     // If we test row group skip, we have all the data in one stripe. For
@@ -241,6 +242,62 @@ TEST_F(E2EFilterTest, floatAndDouble) {
       false);
 }
 
+TEST_F(E2EFilterTest, DISABLED_shortDecimal) {
+  // ORC write functionality is not yet supported. Enable this test once it
+  // becomes available and set the file format to ORC at that time.
+  // options.format = DwrfFormat::kOrc;
+  const std::unordered_map<std::string, TypePtr> types = {
+      {"shortdecimal_val:decimal(8, 5)", DECIMAL(8, 5)},
+      {"shortdecimal_val:decimal(10, 5)", DECIMAL(10, 5)},
+      {"shortdecimal_val:decimal(17, 5)", DECIMAL(17, 5)}};
+
+  for (const auto& pair : types) {
+    testWithTypes(
+        pair.first,
+        [&]() {
+          makeIntDistribution<int64_t>(
+              "shortdecimal_val",
+              10, // min
+              100, // max
+              22, // repeats
+              19, // rareFrequency
+              -999, // rareMin
+              30000, // rareMax
+              true);
+        },
+        false,
+        {"shortdecimal_val"},
+        20);
+  }
+}
+
+TEST_F(E2EFilterTest, DISABLED_longDecimal) {
+  // ORC write functionality is not yet supported. Enable this test once it
+  // becomes available and set the file format to ORC at that time.
+  // options.format = DwrfFormat::kOrc;
+  const std::unordered_map<std::string, TypePtr> types = {
+      {"longdecimal_val:decimal(30, 10)", DECIMAL(30, 10)},
+      {"longdecimal_val:decimal(37, 15)", DECIMAL(37, 15)}};
+  for (const auto& pair : types) {
+    testWithTypes(
+        pair.first,
+        [&]() {
+          makeIntDistribution<int128_t>(
+              "longdecimal_val",
+              10, // min
+              100, // max
+              22, // repeats
+              19, // rareFrequency
+              -999, // rareMin
+              30000, // rareMax
+              true);
+        },
+        false,
+        {"longdecimal_val"},
+        20);
+  }
+}
+
 TEST_F(E2EFilterTest, stringDirect) {
   testutil::TestValue::enable();
   bool coverage[2][2]{};
@@ -446,6 +503,32 @@ TEST_F(E2EFilterTest, mutationCornerCases) {
   testMutationCornerCases();
 }
 
+// Verify processedStrides counts actual strides read, not stripes loaded.
+// With multi-stride data, processedStrides + skippedStrides must equal the
+// total number of strides across all stripes.
+TEST_F(E2EFilterTest, processedStridesCount) {
+  rowType_ = test::DataSetBuilder::makeRowType("long_val:bigint", false);
+  filterGenerator_ = std::make_unique<FilterGenerator>(rowType_, seed_);
+  auto customize = [&]() {};
+  auto batches = makeDataset(customize, true, false);
+  writeToMemory(rowType_, batches, true);
+  std::vector<std::string> filterable = {"long_val"};
+  testRowGroupSkip(batches, filterable);
+
+  const auto totalRows = kBatchCount * kBatchSize;
+  const auto totalStrides = (totalRows + kRowsInGroup - 1) / kRowsInGroup;
+  // With 4 batches x 25,000 rows in one stripe and kRowsInGroup=10,000,
+  // totalStrides is 10. The filter must skip some and process the rest.
+  // processedStrides > 1 proves we count per stride, not per stripe
+  // (the old bug gave processedStrides=1 for a single stripe).
+  EXPECT_EQ(10, totalStrides);
+  EXPECT_GT(runtimeStats_.skippedStrides, 0);
+  EXPECT_GT(runtimeStats_.processedStrides, 1);
+  EXPECT_EQ(
+      totalStrides,
+      runtimeStats_.skippedStrides + runtimeStats_.processedStrides);
+}
+
 // Define main so that gflags get processed.
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
diff --git a/velox/dwio/dwrf/test/E2EReaderTest.cpp b/velox/dwio/dwrf/test/E2EReaderTest.cpp
index 6b696392910..05aaa4e84ef 100644
--- a/velox/dwio/dwrf/test/E2EReaderTest.cpp
+++ b/velox/dwio/dwrf/test/E2EReaderTest.cpp
@@ -20,6 +20,7 @@
 #include "folly/Random.h"
 #include "folly/String.h"
 #include "velox/common/file/File.h"
+#include "velox/common/io/IoStatistics.h"
 #include "velox/common/memory/Memory.h"
 #include "velox/dwio/common/FileSink.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
@@ -73,11 +74,11 @@ class ValueTypes {
   }
 
   auto begin() const {
-    return values_.begin();
+    return values_.cbegin();
   }
 
   auto end() const {
-    return values_.end();
+    return values_.cend();
   }
 
   const std::shared_ptr<folly::Executor>& decodingExecutor() const {
@@ -103,6 +104,11 @@ class E2EReaderTest : public testing::TestWithParam<ValueTypes> {
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   }
+
+  std::shared_ptr<io::IoStatistics> dataIoStats_{
+      std::make_shared<io::IoStatistics>()};
+  std::shared_ptr<io::IoStatistics> metadataIoStats_{
+      std::make_shared<io::IoStatistics>()};
 };
 } // namespace
 
@@ -174,7 +180,9 @@ TEST_P(E2EReaderTest, SharedDictionaryFlatmapReadAsStruct) {
   writer->close();
   writer.reset();
 
-  dwio::common::ReaderOptions readerOpts{pool.get()};
+  dwio::common::ReaderOptions readerOpts(pool.get());
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   auto bufferedInput = std::make_unique<BufferedInput>(
       std::make_shared<LocalReadFile>(path), *pool);
   auto reader = DwrfReader::create(std::move(bufferedInput), readerOpts);
@@ -244,127 +252,159 @@ TEST_P(E2EReaderTest, SharedDictionaryFlatmapReadAsStruct) {
 INSTANTIATE_TEST_SUITE_P(
     SingleTypesSerialMap,
     E2EReaderTest,
-    ValuesIn(std::vector<ValueTypes>{
-        ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"tinyint"}),
-        ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"smallint"}),
-        ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"integer"}),
-        ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"bigint"}),
-        ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"string"}),
-        ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"array<tinyint>"}),
-        ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"array<smallint>"}),
-        ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"array<integer>"}),
-        ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"array<bigint>"}),
-        ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"array<string>"})}));
+    ValuesIn(
+        std::vector<ValueTypes>{
+            ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"tinyint"}),
+            ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"smallint"}),
+            ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"integer"}),
+            ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"bigint"}),
+            ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"string"}),
+            ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"array<tinyint>"}),
+            ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"array<smallint>"}),
+            ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"array<integer>"}),
+            ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"array<bigint>"}),
+            ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"array<string>"})}));
 
 INSTANTIATE_TEST_SUITE_P(
     SingleTypesSerialStruct,
     E2EReaderTest,
-    ValuesIn(std::vector<ValueTypes>{
-        ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"tinyint"}),
-        ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"smallint"}),
-        ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"integer"}),
-        ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"bigint"}),
-        ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"string"}),
-        ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"array<tinyint>"}),
-        ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"array<smallint>"}),
-        ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"array<integer>"}),
-        ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"array<bigint>"}),
-        ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"array<string>"})}));
+    ValuesIn(
+        std::vector<ValueTypes>{
+            ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"tinyint"}),
+            ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"smallint"}),
+            ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"integer"}),
+            ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"bigint"}),
+            ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"string"}),
+            ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"array<tinyint>"}),
+            ValueTypes(
+                Decoding::SERIAL,
+                FlatMapAs::STRUCT,
+                {"array<smallint>"}),
+            ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"array<integer>"}),
+            ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"array<bigint>"}),
+            ValueTypes(
+                Decoding::SERIAL,
+                FlatMapAs::STRUCT,
+                {"array<string>"})}));
 
 INSTANTIATE_TEST_SUITE_P(
     AllTypesSerialMap,
     E2EReaderTest,
-    ValuesIn(std::vector<ValueTypes>{ValueTypes(
-        Decoding::SERIAL,
-        FlatMapAs::MAP,
-        {"tinyint",
-         "smallint",
-         "integer",
-         "bigint",
-         "string",
-         "array<tinyint>",
-         "array<smallint>",
-         "array<integer>",
-         "array<bigint>",
-         "array<string>"})}));
+    ValuesIn(
+        std::vector<ValueTypes>{ValueTypes(
+            Decoding::SERIAL,
+            FlatMapAs::MAP,
+            {"tinyint",
+             "smallint",
+             "integer",
+             "bigint",
+             "string",
+             "array<tinyint>",
+             "array<smallint>",
+             "array<integer>",
+             "array<bigint>",
+             "array<string>"})}));
 
 INSTANTIATE_TEST_SUITE_P(
     AllTypesSerialStruct,
     E2EReaderTest,
-    ValuesIn(std::vector<ValueTypes>{ValueTypes(
-        Decoding::SERIAL,
-        FlatMapAs::STRUCT,
-        {"tinyint",
-         "smallint",
-         "integer",
-         "bigint",
-         "string",
-         "array<tinyint>",
-         "array<smallint>",
-         "array<integer>",
-         "array<bigint>",
-         "array<string>"})}));
+    ValuesIn(
+        std::vector<ValueTypes>{ValueTypes(
+            Decoding::SERIAL,
+            FlatMapAs::STRUCT,
+            {"tinyint",
+             "smallint",
+             "integer",
+             "bigint",
+             "string",
+             "array<tinyint>",
+             "array<smallint>",
+             "array<integer>",
+             "array<bigint>",
+             "array<string>"})}));
 
 INSTANTIATE_TEST_SUITE_P(
     SingleTypesParallelMap,
     E2EReaderTest,
-    ValuesIn(std::vector<ValueTypes>{
-        ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"tinyint"}),
-        ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"smallint"}),
-        ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"integer"}),
-        ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"bigint"}),
-        ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"string"}),
-        ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"array<tinyint>"}),
-        ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"array<smallint>"}),
-        ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"array<integer>"}),
-        ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"array<bigint>"}),
-        ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"array<string>"})}));
+    ValuesIn(
+        std::vector<ValueTypes>{
+            ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"tinyint"}),
+            ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"smallint"}),
+            ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"integer"}),
+            ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"bigint"}),
+            ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"string"}),
+            ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"array<tinyint>"}),
+            ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"array<smallint>"}),
+            ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"array<integer>"}),
+            ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"array<bigint>"}),
+            ValueTypes(
+                Decoding::PARALLEL,
+                FlatMapAs::MAP,
+                {"array<string>"})}));
 
 INSTANTIATE_TEST_SUITE_P(
     SingleTypesParallelStruct,
     E2EReaderTest,
-    ValuesIn(std::vector<ValueTypes>{
-        ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"tinyint"}),
-        ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"smallint"}),
-        ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"integer"}),
-        ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"bigint"}),
-        ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"string"}),
-        ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"array<tinyint>"}),
-        ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"array<smallint>"}),
-        ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"array<integer>"}),
-        ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"array<bigint>"}),
-        ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"array<string>"})}));
+    ValuesIn(
+        std::vector<ValueTypes>{
+            ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"tinyint"}),
+            ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"smallint"}),
+            ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"integer"}),
+            ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"bigint"}),
+            ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"string"}),
+            ValueTypes(
+                Decoding::PARALLEL,
+                FlatMapAs::STRUCT,
+                {"array<tinyint>"}),
+            ValueTypes(
+                Decoding::PARALLEL,
+                FlatMapAs::STRUCT,
+                {"array<smallint>"}),
+            ValueTypes(
+                Decoding::PARALLEL,
+                FlatMapAs::STRUCT,
+                {"array<integer>"}),
+            ValueTypes(
+                Decoding::PARALLEL,
+                FlatMapAs::STRUCT,
+                {"array<bigint>"}),
+            ValueTypes(
+                Decoding::PARALLEL,
+                FlatMapAs::STRUCT,
+                {"array<string>"})}));
 
 INSTANTIATE_TEST_SUITE_P(
     AllTypesParallelMap,
     E2EReaderTest,
-    ValuesIn(std::vector<ValueTypes>{ValueTypes(
-        Decoding::PARALLEL,
-        FlatMapAs::MAP,
-        {"tinyint",
-         "smallint",
-         "integer",
-         "bigint",
-         "string",
-         "array<tinyint>",
-         "array<smallint>",
-         "array<integer>",
-         "array<bigint>",
-         "array<string>"})}));
+    ValuesIn(
+        std::vector<ValueTypes>{ValueTypes(
+            Decoding::PARALLEL,
+            FlatMapAs::MAP,
+            {"tinyint",
+             "smallint",
+             "integer",
+             "bigint",
+             "string",
+             "array<tinyint>",
+             "array<smallint>",
+             "array<integer>",
+             "array<bigint>",
+             "array<string>"})}));
 
 INSTANTIATE_TEST_SUITE_P(
     AllTypesParallelStruct,
     E2EReaderTest,
-    ValuesIn(std::vector<ValueTypes>{ValueTypes(
-        Decoding::PARALLEL,
-        FlatMapAs::STRUCT,
-        {"tinyint",
-         "smallint",
-         "integer",
-         "bigint",
-         "string",
-         "array<tinyint>",
-         "array<smallint>",
-         "array<integer>",
-         "array<bigint>",
-         "array<string>"})}));
+    ValuesIn(
+        std::vector<ValueTypes>{ValueTypes(
+            Decoding::PARALLEL,
+            FlatMapAs::STRUCT,
+            {"tinyint",
+             "smallint",
+             "integer",
+             "bigint",
+             "string",
+             "array<tinyint>",
+             "array<smallint>",
+             "array<integer>",
+             "array<bigint>",
+             "array<string>"})}));
diff --git a/velox/dwio/dwrf/test/E2EWriterTest.cpp b/velox/dwio/dwrf/test/E2EWriterTest.cpp
index 321dcbf4802..6ea0ca99849 100644
--- a/velox/dwio/dwrf/test/E2EWriterTest.cpp
+++ b/velox/dwio/dwrf/test/E2EWriterTest.cpp
@@ -18,6 +18,7 @@
 #include <random>
 #include "velox/common/base/SpillConfig.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/io/IoStatistics.h"
 #include "velox/common/memory/tests/SharedArbitratorTestUtil.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/dwio/common/Options.h"
@@ -30,6 +31,7 @@
 #include "velox/dwio/dwrf/reader/DwrfReader.h"
 #include "velox/dwio/dwrf/test/OrcTest.h"
 #include "velox/dwio/dwrf/test/utils/E2EWriterTestUtil.h"
+#include "velox/dwio/dwrf/writer/StatisticsBuilder.h"
 #include "velox/type/fbhive/HiveTypeParser.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 #include "velox/vector/tests/utils/VectorMaker.h"
@@ -61,6 +63,11 @@ class E2EWriterTest : public testing::Test {
     leafPool_ = rootPool_->addLeafChild("leaf");
   }
 
+  std::shared_ptr<io::IoStatistics> dataIoStats_ =
+      std::make_shared<io::IoStatistics>();
+  std::shared_ptr<io::IoStatistics> metadataIoStats_ =
+      std::make_shared<io::IoStatistics>();
+
   static std::unique_ptr<dwrf::DwrfReader> createReader(
       const MemorySink& sink,
       const dwio::common::ReaderOptions& opts) {
@@ -103,7 +110,9 @@ class E2EWriterTest : public testing::Test {
 
     writer.close();
 
-    dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+    dwio::common::ReaderOptions readerOpts(leafPool_.get());
+    readerOpts.setDataIoStats(dataIoStats_);
+    readerOpts.setMetadataIoStats(metadataIoStats_);
     RowReaderOptions rowReaderOpts;
     auto reader = createReader(*sinkPtr, readerOpts);
     auto rowReader = reader->createRowReader(rowReaderOpts);
@@ -165,7 +174,9 @@ class E2EWriterTest : public testing::Test {
 
     writer.close();
 
-    dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+    dwio::common::ReaderOptions readerOpts(leafPool_.get());
+    readerOpts.setDataIoStats(dataIoStats_);
+    readerOpts.setMetadataIoStats(metadataIoStats_);
     RowReaderOptions rowReaderOpts;
     auto reader = createReader(*sinkPtr, readerOpts);
     auto rowReader = reader->createRowReader(rowReaderOpts);
@@ -205,7 +216,7 @@ class E2EWriterTest : public testing::Test {
 
               dwrf::EncodingKey seqEk(valueTypeId, sequence);
               const auto& keyInfo = stripeStreams.getEncoding(seqEk).key();
-              auto key = dwrf::constructKey(keyInfo);
+              auto key = dwrf::MapStatisticsBuilder::constructKey(keyInfo);
               sequenceToKey.emplace(sequence, key);
             });
 
@@ -235,7 +246,8 @@ class E2EWriterTest : public testing::Test {
         const auto& entry = stats.mapStatistics().stats(i);
         ASSERT_TRUE(entry.stats().has_size());
         EXPECT_EQ(
-            featureStreamSizes.at(dwrf::constructKey(entry.key())),
+            featureStreamSizes.at(
+                dwrf::MapStatisticsBuilder::constructKey(entry.key())),
             entry.stats().size());
       }
     }
@@ -261,7 +273,8 @@ class E2EWriterTest : public testing::Test {
         0,
         0,
         writerFlushThresholdSize,
-        "none");
+        "none",
+        0);
   }
 
   std::shared_ptr<MemoryPool> rootPool_;
@@ -565,7 +578,9 @@ TEST_F(E2EWriterTest, PresentStreamIsSuppressedOnFlatMap) {
       config,
       dwrf::E2EWriterTestUtil::simpleFlushPolicyFactory(true));
 
-  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  dwio::common::ReaderOptions readerOpts(leafPool_.get());
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   RowReaderOptions rowReaderOpts;
   auto reader = createReader(*sinkPtr, readerOpts);
   auto rowReader = reader->createRowReader(rowReaderOpts);
@@ -937,7 +952,9 @@ TEST_F(E2EWriterTest, PartialStride) {
   writer.write(batch);
   writer.close();
 
-  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  dwio::common::ReaderOptions readerOpts(leafPool_.get());
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   RowReaderOptions rowReaderOpts;
   auto reader = createReader(*sinkPtr, readerOpts);
   ASSERT_EQ(
@@ -1137,7 +1154,9 @@ class E2EEncryptionTest : public E2EWriterTest {
     writer_->close();
 
     // read it back for compare
-    dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+    dwio::common::ReaderOptions readerOpts(leafPool_.get());
+    readerOpts.setDataIoStats(dataIoStats_);
+    readerOpts.setMetadataIoStats(metadataIoStats_);
     readerOpts.setDecrypterFactory(decrypterFactory);
     return createReader(*sink_, readerOpts);
   }
@@ -2140,9 +2159,10 @@ DEBUG_ONLY_TEST_F(E2EWriterTest, memoryReclaimThreshold) {
   }
   const std::vector<uint64_t> writerFlushThresholdSizes = {0, 1L << 30};
   for (uint64_t writerFlushThresholdSize : writerFlushThresholdSizes) {
-    SCOPED_TRACE(fmt::format(
-        "writerFlushThresholdSize {}",
-        succinctBytes(writerFlushThresholdSize)));
+    SCOPED_TRACE(
+        fmt::format(
+            "writerFlushThresholdSize {}",
+            succinctBytes(writerFlushThresholdSize)));
 
     const common::SpillConfig spillConfig =
         getSpillConfig(10, 20, writerFlushThresholdSize);
diff --git a/velox/dwio/dwrf/test/EncodingManagerTests.cpp b/velox/dwio/dwrf/test/EncodingManagerTests.cpp
index 681e0908157..e53c276e29c 100644
--- a/velox/dwio/dwrf/test/EncodingManagerTests.cpp
+++ b/velox/dwio/dwrf/test/EncodingManagerTests.cpp
@@ -34,10 +34,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         -1,
-        footer.encoding().begin(),
-        footer.encoding().end()};
-    EXPECT_EQ(footer.encoding().begin(), iter.current_);
-    EXPECT_EQ(footer.encoding().end(), iter.currentEnd_);
+        footer.encoding().cbegin(),
+        footer.encoding().cend()};
+    EXPECT_EQ(footer.encoding().cbegin(), iter.current_);
+    EXPECT_EQ(footer.encoding().cend(), iter.currentEnd_);
   }
   {
     // A valid end iterator.
@@ -45,10 +45,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         -1,
-        footer.encoding().end(),
-        footer.encoding().end()};
-    EXPECT_EQ(footer.encoding().end(), iter.current_);
-    EXPECT_EQ(footer.encoding().end(), iter.currentEnd_);
+        footer.encoding().cend(),
+        footer.encoding().cend()};
+    EXPECT_EQ(footer.encoding().cend(), iter.current_);
+    EXPECT_EQ(footer.encoding().cend(), iter.currentEnd_);
   }
   footer.add_encoding();
   // footer [e]
@@ -58,10 +58,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         -1,
-        footer.encoding().begin(),
-        footer.encoding().end()};
-    EXPECT_EQ(footer.encoding().begin(), iter.current_);
-    EXPECT_EQ(footer.encoding().end(), iter.currentEnd_);
+        footer.encoding().cbegin(),
+        footer.encoding().cend()};
+    EXPECT_EQ(footer.encoding().cbegin(), iter.current_);
+    EXPECT_EQ(footer.encoding().cend(), iter.currentEnd_);
   }
   {
     // A valid end iterator.
@@ -69,10 +69,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         -1,
-        footer.encoding().end(),
-        footer.encoding().end()};
-    EXPECT_EQ(footer.encoding().end(), iter.current_);
-    EXPECT_EQ(footer.encoding().end(), iter.currentEnd_);
+        footer.encoding().cend(),
+        footer.encoding().cend()};
+    EXPECT_EQ(footer.encoding().cend(), iter.current_);
+    EXPECT_EQ(footer.encoding().cend(), iter.currentEnd_);
   }
   proto::StripeEncryptionGroup group1;
   proto::StripeEncryptionGroup group2;
@@ -85,10 +85,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         -1,
-        footer.encoding().begin(),
-        footer.encoding().end()};
-    EXPECT_EQ(footer.encoding().begin(), iter.current_);
-    EXPECT_EQ(footer.encoding().end(), iter.currentEnd_);
+        footer.encoding().cbegin(),
+        footer.encoding().cend()};
+    EXPECT_EQ(footer.encoding().cbegin(), iter.current_);
+    EXPECT_EQ(footer.encoding().cend(), iter.currentEnd_);
   }
   {
     // A valid end iterator.
@@ -96,10 +96,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         1,
-        encryptionGroups.at(1).encoding().end(),
-        encryptionGroups.at(1).encoding().end()};
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.current_);
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.currentEnd_);
+        encryptionGroups.at(1).encoding().cend(),
+        encryptionGroups.at(1).encoding().cend()};
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.current_);
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.currentEnd_);
   }
   {
     // An adjusted end iterator.
@@ -107,10 +107,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         -1,
-        footer.encoding().end(),
-        footer.encoding().end()};
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.current_);
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.currentEnd_);
+        footer.encoding().cend(),
+        footer.encoding().cend()};
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.current_);
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.currentEnd_);
   }
   encryptionGroups[1].add_encoding();
   // footer [e]
@@ -120,10 +120,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         -1,
-        footer.encoding().begin(),
-        footer.encoding().end()};
-    EXPECT_EQ(footer.encoding().begin(), iter.current_);
-    EXPECT_EQ(footer.encoding().end(), iter.currentEnd_);
+        footer.encoding().cbegin(),
+        footer.encoding().cend()};
+    EXPECT_EQ(footer.encoding().cbegin(), iter.current_);
+    EXPECT_EQ(footer.encoding().cend(), iter.currentEnd_);
   }
   {
     // An adjusted iterator.
@@ -131,10 +131,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         -1,
-        footer.encoding().end(),
-        footer.encoding().end()};
-    EXPECT_EQ(encryptionGroups.at(1).encoding().begin(), iter.current_);
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.currentEnd_);
+        footer.encoding().cend(),
+        footer.encoding().cend()};
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cbegin(), iter.current_);
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.currentEnd_);
   }
   {
     // An adjusted iterator.
@@ -142,10 +142,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         0,
-        encryptionGroups.at(0).encoding().begin(),
-        encryptionGroups.at(0).encoding().end()};
-    EXPECT_EQ(encryptionGroups.at(1).encoding().begin(), iter.current_);
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.currentEnd_);
+        encryptionGroups.at(0).encoding().cbegin(),
+        encryptionGroups.at(0).encoding().cend()};
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cbegin(), iter.current_);
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.currentEnd_);
   }
   {
     // A valid end iterator.
@@ -153,10 +153,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         1,
-        encryptionGroups.at(1).encoding().end(),
-        encryptionGroups.at(1).encoding().end()};
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.current_);
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.currentEnd_);
+        encryptionGroups.at(1).encoding().cend(),
+        encryptionGroups.at(1).encoding().cend()};
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.current_);
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.currentEnd_);
   }
   footer.Clear();
   // footer []
@@ -167,10 +167,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         -1,
-        footer.encoding().begin(),
-        footer.encoding().end()};
-    EXPECT_EQ(encryptionGroups.at(1).encoding().begin(), iter.current_);
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.currentEnd_);
+        footer.encoding().cbegin(),
+        footer.encoding().cend()};
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cbegin(), iter.current_);
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.currentEnd_);
   }
   {
     // An adjusted iterator further back.
@@ -178,10 +178,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         -1,
-        footer.encoding().end(),
-        footer.encoding().end()};
-    EXPECT_EQ(encryptionGroups.at(1).encoding().begin(), iter.current_);
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.currentEnd_);
+        footer.encoding().cend(),
+        footer.encoding().cend()};
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cbegin(), iter.current_);
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.currentEnd_);
   }
   encryptionGroups.at(1).Clear();
   // footer []
@@ -192,10 +192,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         0,
-        encryptionGroups.at(0).encoding().end(),
-        encryptionGroups.at(0).encoding().end()};
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.current_);
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.currentEnd_);
+        encryptionGroups.at(0).encoding().cend(),
+        encryptionGroups.at(0).encoding().cend()};
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.current_);
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.currentEnd_);
   }
   {
     // An adjusted end iterator further back.
@@ -203,10 +203,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         -1,
-        footer.encoding().end(),
-        footer.encoding().end()};
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.current_);
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.currentEnd_);
+        footer.encoding().cend(),
+        footer.encoding().cend()};
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.current_);
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.currentEnd_);
   }
 }
 
@@ -227,15 +227,15 @@ TEST(TestEncodingIter, EncodingIterBeginAndEnd) {
       footer,
       encryptionGroups,
       -1,
-      footer.encoding().begin(),
-      footer.encoding().end()};
+      footer.encoding().cbegin(),
+      footer.encoding().cend()};
   EXPECT_EQ(begin, EncodingIter::begin(footer, encryptionGroups));
   EncodingIter end{
       footer,
       encryptionGroups,
       1,
-      encryptionGroups.at(1).encoding().end(),
-      encryptionGroups.at(1).encoding().end()};
+      encryptionGroups.at(1).encoding().cend(),
+      encryptionGroups.at(1).encoding().cend()};
   EXPECT_EQ(end, EncodingIter::end(footer, encryptionGroups));
 }
 
diff --git a/velox/dwio/dwrf/test/FlushPolicyTest.cpp b/velox/dwio/dwrf/test/FlushPolicyTest.cpp
index ed10f458aa2..b045326664e 100644
--- a/velox/dwio/dwrf/test/FlushPolicyTest.cpp
+++ b/velox/dwio/dwrf/test/FlushPolicyTest.cpp
@@ -51,8 +51,9 @@ TEST_F(DefaultFlushPolicyTest, StripeProgressTest) {
         testCase.stripeSizeThreshold, /*dictionarySizeThreshold=*/0};
     EXPECT_EQ(
         testCase.shouldFlush,
-        policy.shouldFlush(dwio::common::StripeProgress{
-            .stripeSizeEstimate = testCase.stripeSize}));
+        policy.shouldFlush(
+            dwio::common::StripeProgress{
+                .stripeSizeEstimate = testCase.stripeSize}));
   }
 }
 
@@ -115,8 +116,8 @@ TEST_F(DefaultFlushPolicyTest, AdditionalCriteriaTest) {
           .dictionarySize = 42,
           .decision = FlushDecision::SKIP}};
   for (const auto& testCase : testCases) {
-    DefaultFlushPolicy policy{
-        /*stripeSizeThreshold=*/1000, testCase.dictionarySizeThreshold};
+    DefaultFlushPolicy policy{/*stripeSizeThreshold=*/1000,
+                              testCase.dictionarySizeThreshold};
     EXPECT_EQ(
         testCase.decision,
         policy.shouldFlushDictionary(
diff --git a/velox/dwio/dwrf/test/IndexBuilderTests.cpp b/velox/dwio/dwrf/test/IndexBuilderTests.cpp
index 66969d00790..ee5914e236a 100644
--- a/velox/dwio/dwrf/test/IndexBuilderTests.cpp
+++ b/velox/dwio/dwrf/test/IndexBuilderTests.cpp
@@ -25,17 +25,17 @@ namespace facebook::velox::dwrf {
 
 class IndexBuilderTest : public testing::Test {
  protected:
-  static const proto::RowIndexEntry& getEntry(
+  static const RowIndexEntryWriteWrapper getEntry(
       IndexBuilder& builder,
       size_t index) {
-    return *builder.getEntry(index);
+    return builder.getEntry(index);
   }
 
   static std::vector<uint64_t> getPositions(
       IndexBuilder& builder,
       size_t index) {
-    auto& positions = builder.getEntry(index)->positions();
-    return std::vector<uint64_t>{positions.begin(), positions.end()};
+    auto& positions = builder.getEntry(index).positions();
+    return std::vector<uint64_t>{positions.cbegin(), positions.cend()};
   }
 
   StatisticsBuilderOptions options_{16};
@@ -45,7 +45,7 @@ TEST_F(IndexBuilderTest, Constructor) {
   IndexBuilder builder{nullptr};
   EXPECT_EQ(1, builder.getEntrySize());
   // Ensure a clean start.
-  EXPECT_EQ(0, getEntry(builder, 0).positions_size());
+  EXPECT_EQ(0, getEntry(builder, 0).positionsSize());
 }
 
 TEST_F(IndexBuilderTest, AddEntry) {
@@ -65,8 +65,8 @@ TEST_F(IndexBuilderTest, AddEntry) {
   ASSERT_EQ(51, builder.getEntrySize());
   for (size_t i = 0; i != 50; ++i) {
     // The newly added entries should be empty.
-    EXPECT_EQ(0, getEntry(builder, i + 1).positions_size());
-    EXPECT_TRUE(getEntry(builder, i).has_statistics());
+    EXPECT_EQ(0, getEntry(builder, i + 1).positionsSize());
+    EXPECT_TRUE(getEntry(builder, i).hasStatistics());
   }
 }
 
@@ -94,9 +94,9 @@ TEST_F(IndexBuilderTest, Backfill) {
   IndexBuilder builder{nullptr};
   StatisticsBuilder sb{options_};
   builder.addEntry(sb);
-  ASSERT_EQ(0, getEntry(builder, 0).positions_size());
+  ASSERT_EQ(0, getEntry(builder, 0).positionsSize());
   builder.add(0uL);
-  ASSERT_EQ(0, getEntry(builder, 0).positions_size());
+  ASSERT_EQ(0, getEntry(builder, 0).positionsSize());
   ASSERT_THAT(getPositions(builder, 1), ElementsAreArray({0uL}));
 
   builder.add(42uL, 0);
@@ -112,16 +112,16 @@ TEST_F(IndexBuilderTest, Backfill) {
     builder.addEntry(sb);
   }
   for (size_t i = 2; i != 7; ++i) {
-    ASSERT_EQ(0, getEntry(builder, i).positions_size());
+    ASSERT_EQ(0, getEntry(builder, i).positionsSize());
   }
   builder.add(144uL, 4);
   EXPECT_THAT(getPositions(builder, 0), ElementsAreArray({42uL}));
   EXPECT_THAT(getPositions(builder, 1), ElementsAreArray({0uL, 0uL, 7uL}));
-  ASSERT_EQ(0, getEntry(builder, 2).positions_size());
-  ASSERT_EQ(0, getEntry(builder, 3).positions_size());
+  ASSERT_EQ(0, getEntry(builder, 2).positionsSize());
+  ASSERT_EQ(0, getEntry(builder, 3).positionsSize());
   EXPECT_THAT(getPositions(builder, 4), ElementsAreArray({144uL}));
-  ASSERT_EQ(0, getEntry(builder, 5).positions_size());
-  ASSERT_EQ(0, getEntry(builder, 6).positions_size());
+  ASSERT_EQ(0, getEntry(builder, 5).positionsSize());
+  ASSERT_EQ(0, getEntry(builder, 6).positionsSize());
 }
 
 TEST_F(IndexBuilderTest, RemovePresentStreamPositions) {
diff --git a/velox/dwio/dwrf/test/IntEncoderBenchmark.cpp b/velox/dwio/dwrf/test/IntEncoderBenchmark.cpp
index 644ddab0c58..e79fa02bf75 100644
--- a/velox/dwio/dwrf/test/IntEncoderBenchmark.cpp
+++ b/velox/dwio/dwrf/test/IntEncoderBenchmark.cpp
@@ -117,8 +117,9 @@ FOLLY_ALWAYS_INLINE static int32_t findSetBitsNew(uint64_t value) {
     case 57 ... 63:
       return 1;
   }
-  DWIO_RAISE(folly::sformat(
-      "Unexpected leading zeros {} for value {}", leadingZeros, value));
+  DWIO_RAISE(
+      folly::sformat(
+          "Unexpected leading zeros {} for value {}", leadingZeros, value));
 }
 
 size_t iters = 2000;
diff --git a/velox/dwio/dwrf/test/LayoutPlannerTests.cpp b/velox/dwio/dwrf/test/LayoutPlannerTests.cpp
index a2de14e8e91..32cf1a5062b 100644
--- a/velox/dwio/dwrf/test/LayoutPlannerTests.cpp
+++ b/velox/dwio/dwrf/test/LayoutPlannerTests.cpp
@@ -128,12 +128,12 @@ TEST_F(LayoutPlannerTest, Basic) {
                          uint32_t seq,
                          proto::ColumnEncoding_Kind kind,
                          std::optional<int64_t> key = std::nullopt) {
-    auto& encoding = encodingManager.addEncodingToFooter(node);
-    encoding.set_node(node);
-    encoding.set_sequence(seq);
-    encoding.set_kind(kind);
+    auto encoding = encodingManager.addEncodingToFooter(node);
+    encoding.setNode(node);
+    encoding.setSequence(seq);
+    encoding.setKind(ColumnEncodingKindWrapper(&kind));
     if (key.has_value()) {
-      encoding.mutable_key()->set_intkey(*key);
+      encoding.mutableKey()->set_intkey(*key);
     }
   };
 
diff --git a/velox/dwio/dwrf/test/OrcTest.h b/velox/dwio/dwrf/test/OrcTest.h
index 3bd87c45f07..6b0b3987ac2 100644
--- a/velox/dwio/dwrf/test/OrcTest.h
+++ b/velox/dwio/dwrf/test/OrcTest.h
@@ -28,8 +28,6 @@
 
 namespace facebook::velox::dwrf {
 
-#define VELOX_ARRAY_SIZE(array) (sizeof(array) / sizeof(*array))
-
 using MemoryPool = memory::MemoryPool;
 
 inline std::string getExampleFilePath(const std::string& fileName) {
diff --git a/velox/dwio/dwrf/test/ReaderBaseTests.cpp b/velox/dwio/dwrf/test/ReaderBaseTests.cpp
index 04f0685c252..08eb3897c41 100644
--- a/velox/dwio/dwrf/test/ReaderBaseTests.cpp
+++ b/velox/dwio/dwrf/test/ReaderBaseTests.cpp
@@ -16,7 +16,10 @@
 
 #include <gtest/gtest.h>
 #include <cstring>
+
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/io/IoStatistics.h"
+#include "velox/dwio/common/Arena.h"
 #include "velox/dwio/common/InputStream.h"
 #include "velox/dwio/common/encryption/TestProvider.h"
 #include "velox/dwio/common/exception/Exception.h"
@@ -72,14 +75,14 @@ class EncryptedStatsTest : public Test {
     TestEncrypter encrypter;
     HiveTypeParser parser;
     auto type = parser.parse("struct<a:int,b:struct<a:int,b:int>,c:int,d:int>");
-    auto footer =
-        google::protobuf::Arena::CreateMessage<proto::Footer>(&arena_);
+    auto footer = ArenaCreate<proto::Footer>(&arena_);
+    auto footerWrapper = FooterWriteWrapper(footer);
     // add empty stats to the file
     for (size_t i = 0; i < 7; ++i) {
-      footer->add_statistics()->set_numberofvalues(i);
+      footerWrapper.addStatistics().setNumberOfValues(i);
     }
-    ProtoUtils::writeType(*type, *footer);
-    auto enc = footer->mutable_encryption();
+    ProtoUtils::writeType(*type, footerWrapper);
+    auto enc = footerWrapper.mutableEncryption();
     enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
     auto group = enc->add_encryptiongroups();
     group->add_nodes(1);
@@ -107,9 +110,11 @@ class EncryptedStatsTest : public Test {
         *readerPool_,
         std::make_unique<BufferedInput>(readFile, *readerPool_),
         std::make_unique<PostScript>(std::move(ps)),
-        footer,
+        footerWrapper.getDwrfPtr(),
         nullptr,
-        std::move(handler));
+        std::move(handler),
+        dataIoStats_,
+        metadataIoStats_);
   }
 
   void clearKey(uint32_t groupIdx) {
@@ -125,6 +130,10 @@ class EncryptedStatsTest : public Test {
   std::shared_ptr<MemoryPool> pool_;
   std::shared_ptr<MemoryPool> sinkPool_;
   std::shared_ptr<MemoryPool> readerPool_;
+  std::shared_ptr<facebook::velox::io::IoStatistics> dataIoStats_ =
+      std::make_shared<facebook::velox::io::IoStatistics>();
+  std::shared_ptr<facebook::velox::io::IoStatistics> metadataIoStats_ =
+      std::make_shared<facebook::velox::io::IoStatistics>();
 };
 
 TEST_F(EncryptedStatsTest, statistics) {
@@ -213,6 +222,10 @@ std::unique_ptr<ReaderBase> createCorruptedFileReader(
   auto readFile = std::make_shared<facebook::velox::InMemoryReadFile>(
       std::string(sink.data(), sink.size()));
   facebook::velox::dwio::common::ReaderOptions readerOpts{pool.get()};
+  readerOpts.setDataIoStats(
+      std::make_shared<facebook::velox::io::IoStatistics>());
+  readerOpts.setMetadataIoStats(
+      std::make_shared<facebook::velox::io::IoStatistics>());
   return std::make_unique<ReaderBase>(
       readerOpts, std::make_unique<BufferedInput>(readFile, *pool));
 }
diff --git a/velox/dwio/dwrf/test/ReaderTest.cpp b/velox/dwio/dwrf/test/ReaderTest.cpp
index 08b3bc87f10..6a34d8575fd 100644
--- a/velox/dwio/dwrf/test/ReaderTest.cpp
+++ b/velox/dwio/dwrf/test/ReaderTest.cpp
@@ -18,8 +18,13 @@
 #include <gtest/gtest.h>
 #include "folly/Random.h"
 #include "folly/executors/CPUThreadPoolExecutor.h"
+#include "folly/executors/IOThreadPoolExecutor.h"
 #include "folly/lang/Assume.h"
+#include "folly/synchronization/Baton.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TestValue.h"
+#include "velox/connectors/hive/ExtractionUtils.h"
+#include "velox/connectors/hive/HiveConnectorUtil.h"
 #include "velox/dwio/common/ExecutorBarrier.h"
 #include "velox/dwio/common/FileSink.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
@@ -27,6 +32,7 @@
 #include "velox/dwio/dwrf/reader/DwrfReader.h"
 #include "velox/dwio/dwrf/test/OrcTest.h"
 #include "velox/dwio/dwrf/test/utils/E2EWriterTestUtil.h"
+#include "velox/dwio/dwrf/writer/Writer.h"
 #include "velox/type/fbhive/HiveTypeParser.h"
 #include "velox/vector/ComplexVector.h"
 #include "velox/vector/FlatVector.h"
@@ -38,14 +44,16 @@
 #include <memory>
 #include <numeric>
 
+#include "velox/common/io/IoStatistics.h"
+
+namespace facebook::velox::dwrf {
+namespace {
+
 using namespace ::testing;
 using namespace facebook::velox::dwio::common;
 using namespace facebook::velox::type::fbhive;
-using namespace facebook::velox;
-using namespace facebook::velox::dwrf;
 using namespace facebook::velox::test;
 
-namespace {
 const std::string& getStructFile() {
   static const std::string structFile_ = getExampleFilePath("struct.orc");
   return structFile_;
@@ -74,12 +82,35 @@ const std::shared_ptr<const RowType>& getFlatmapSchema() {
   return schema_;
 }
 
+std::vector<common::Subfield> makeSubfields(
+    const std::vector<std::string>& paths) {
+  std::vector<common::Subfield> subfields;
+  subfields.reserve(paths.size());
+  for (auto& path : paths) {
+    subfields.emplace_back(path);
+  }
+  return subfields;
+}
+
+folly::F14FastMap<std::string, std::vector<const common::Subfield*>>
+groupSubfields(const std::vector<common::Subfield>& subfields) {
+  folly::F14FastMap<std::string, std::vector<const common::Subfield*>> grouped;
+  for (auto& subfield : subfields) {
+    auto& name =
+        static_cast<const common::Subfield::NestedField&>(*subfield.path()[0])
+            .name();
+    grouped[name].push_back(&subfield);
+  }
+  return grouped;
+}
+
 class TestReaderP
     : public testing::TestWithParam</* parallel decoding = */ bool>,
       public VectorTestBase {
  protected:
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+    facebook::velox::common::testutil::TestValue::enable();
   }
 
   folly::Executor* executor() {
@@ -96,12 +127,19 @@ class TestReaderP
 
  private:
   std::unique_ptr<folly::Executor> executor_;
+
+ protected:
+  std::shared_ptr<io::IoStatistics> dataIoStats_{
+      std::make_shared<io::IoStatistics>()};
+  std::shared_ptr<io::IoStatistics> metadataIoStats_{
+      std::make_shared<io::IoStatistics>()};
 };
 
 class TestReader : public testing::Test, public VectorTestBase {
  protected:
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+    facebook::velox::common::testutil::TestValue::enable();
   }
 
   std::vector<VectorPtr> createBatches(
@@ -114,9 +152,12 @@ class TestReader : public testing::Test, public VectorTestBase {
     }
     return batches;
   }
-};
 
-} // namespace
+  std::shared_ptr<io::IoStatistics> dataIoStats_{
+      std::make_shared<io::IoStatistics>()};
+  std::shared_ptr<io::IoStatistics> metadataIoStats_{
+      std::make_shared<io::IoStatistics>()};
+};
 
 TEST_F(TestReader, testWriterVersions) {
   EXPECT_EQ("original", writerVersionToString(ORIGINAL));
@@ -238,13 +279,17 @@ void verifyFlatMapReading(
     const int32_t expectedBatchSize[],
     const int32_t numBatches,
     bool returnFlatVector,
+    const std::shared_ptr<io::IoStatistics>& dataIoStats,
+    const std::shared_ptr<io::IoStatistics>& metadataIoStats,
     const std::vector<uint32_t>& expectedPrefetchRowSizes = {},
     const std::vector<bool>& shouldTryPrefetch = {}) {
   dwio::common::ReaderOptions readerOpts{pool};
+  readerOpts.setDataIoStats(dataIoStats);
+  readerOpts.setMetadataIoStats(metadataIoStats);
 
   /* If an extra sanity check is desired you can uncomment the 2 below lines and
    * re-run */
-  // readerOpts.setFooterEstimatedSize(257);
+  // readerOpts.setFooterSpeculativeIoSize(257);
   // readerOpts.setFilePreloadThreshold(0);
 
   RowReaderOptions rowReaderOpts;
@@ -354,6 +399,11 @@ class TestFlatMapReader : public TestWithParam<bool>, public VectorTestBase {
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   }
+
+  std::shared_ptr<io::IoStatistics> dataIoStats_{
+      std::make_shared<io::IoStatistics>()};
+  std::shared_ptr<io::IoStatistics> metadataIoStats_{
+      std::make_shared<io::IoStatistics>()};
 };
 
 TEST_P(TestFlatMapReader, testReadFlatMapEmptyMap) {
@@ -361,6 +411,8 @@ TEST_P(TestFlatMapReader, testReadFlatMapEmptyMap) {
   auto returnFlatVector = GetParam();
 
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   RowReaderOptions rowReaderOpts;
   rowReaderOpts.setReturnFlatVector(returnFlatVector);
   std::shared_ptr<const RowType> emptyFileType =
@@ -391,6 +443,8 @@ TEST_P(TestFlatMapReader, testStringKeyLifeCycle) {
 
   VectorPtr batch;
   dwio::common::ReaderOptions readerOptions{pool()};
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
 
   {
     RowReaderOptions rowReaderOptions;
@@ -454,7 +508,9 @@ TEST_P(TestFlatMapReader, testReadFlatMapSampleSmallSkips) {
       seeks.data(),
       expectedBatchSize.data(),
       expectedBatchSize.size(),
-      returnFlatVector);
+      returnFlatVector,
+      dataIoStats_,
+      metadataIoStats_);
 }
 
 TEST_P(TestFlatMapReader, testReadFlatMapSampleSmall) {
@@ -469,7 +525,9 @@ TEST_P(TestFlatMapReader, testReadFlatMapSampleSmall) {
       seeks.data(),
       expectedBatchSize.data(),
       expectedBatchSize.size(),
-      returnFlatVector);
+      returnFlatVector,
+      dataIoStats_,
+      metadataIoStats_);
 }
 
 TEST_P(TestFlatMapReader, testReadFlatMapSampleLarge) {
@@ -487,7 +545,9 @@ TEST_P(TestFlatMapReader, testReadFlatMapSampleLarge) {
       seeks.data(),
       expectedBatchSize.data(),
       expectedBatchSize.size(),
-      returnFlatVector);
+      returnFlatVector,
+      dataIoStats_,
+      metadataIoStats_);
 }
 
 VELOX_INSTANTIATE_TEST_SUITE_P(
@@ -502,10 +562,17 @@ class TestFlatMapReaderFlatLayout
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   }
+
+  std::shared_ptr<io::IoStatistics> dataIoStats_{
+      std::make_shared<io::IoStatistics>()};
+  std::shared_ptr<io::IoStatistics> metadataIoStats_{
+      std::make_shared<io::IoStatistics>()};
 };
 
 TEST_P(TestFlatMapReaderFlatLayout, testCompare) {
   dwio::common::ReaderOptions readerOptions{pool()};
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader = DwrfReader::create(
       createFileBufferedInput(getFMSmallFile(), readerOptions.memoryPool()),
       readerOptions);
@@ -539,6 +606,8 @@ TEST_F(TestReader, testReadFlatMapWithKeyFilters) {
   // batch size is set as 1000 in reading
   // file has schema: a int, b struct<a:int, b:float, c:string>, c float
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   RowReaderOptions rowReaderOpts;
   // set map key filter for map1 we only need key=1, and map2 only key-1
   auto cs = std::make_shared<ColumnSelector>(
@@ -592,6 +661,8 @@ TEST_F(TestReader, testReadFlatMapWithKeyRejectList) {
   // batch size is set as 1000 in reading
   // file has schema: a int, b struct<a:int, b:float, c:string>, c float
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   RowReaderOptions rowReaderOpts;
   auto cs = std::make_shared<ColumnSelector>(
       getFlatmapSchema(), std::vector<std::string>{"map1#[\"!2\",\"!3\"]"});
@@ -647,6 +718,8 @@ TEST_F(TestReader, testStatsCallbackFiredWithFiltering) {
       });
 
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
 
   auto reader = DwrfReader::create(
       createFileBufferedInput(getFMSmallFile(), readerOpts.memoryPool()),
@@ -685,6 +758,8 @@ TEST_F(TestReader, testBlockedIoCallbackFiredBlocking) {
   rowReaderOpts.setEagerFirstStripeLoad(false);
 
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
 
   auto reader = DwrfReader::create(
       createFileBufferedInput(getFMLargeFile(), readerOpts.memoryPool()),
@@ -729,6 +804,8 @@ TEST_F(TestReader, DISABLED_testBlockedIoCallbackFiredNonBlocking) {
   rowReaderOpts.setEagerFirstStripeLoad(false);
 
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
 
   auto reader = DwrfReader::create(
       createFileBufferedInput(getFMLargeFile(), readerOpts.memoryPool()),
@@ -778,6 +855,8 @@ TEST_F(TestReader, DISABLED_testBlockedIoCallbackFiredWithFirstStripeLoad) {
   rowReaderOpts.setEagerFirstStripeLoad(true);
 
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
 
   auto reader = DwrfReader::create(
       createFileBufferedInput(getFMLargeFile(), readerOpts.memoryPool()),
@@ -813,6 +892,8 @@ TEST_F(TestReader, DISABLED_testBlockedIoCallbackFiredWithFirstStripeLoad) {
 
 TEST_F(TestReader, testEstimatedSize) {
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   {
     auto reader = DwrfReader::create(
         createFileBufferedInput(getFMSmallFile(), readerOpts.memoryPool()),
@@ -839,6 +920,64 @@ TEST_F(TestReader, testEstimatedSize) {
   }
 }
 
+TEST_F(TestReader, testSubfieldEstimatedSize) {
+  dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
+  std::shared_ptr<const RowType> schema =
+      std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse("struct<\
+              a:int,\
+              b:struct<\
+                  a:int,\
+                  b:float,\
+                  c:string>,\
+              c:float>"));
+
+  std::shared_ptr<const RowType> outputType =
+      std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse("struct<\
+              a:int,\
+              b:struct<\
+                  a:int,\
+                  b:float,\
+                  c:string>>"));
+  // estimation with subfield filtering
+  auto subfields = makeSubfields({"a", "b.b"});
+  folly::F14FastMap<std::string, std::vector<const common::Subfield*>>
+      subfieldsByName = groupSubfields(subfields);
+  auto scanSpec = velox::connector::hive::makeScanSpec(
+      outputType, subfieldsByName, {}, {}, schema, {}, {}, {}, true, pool());
+  readerOpts.setScanSpec(scanSpec);
+
+  auto reader = DwrfReader::create(
+      createFileBufferedInput(getStructFile(), readerOpts.memoryPool()),
+      readerOpts);
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.setScanSpec(scanSpec);
+
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  ASSERT_EQ(rowReader->estimatedRowSize(), 8);
+
+  // estimation with full struct field selection
+  dwio::common::ReaderOptions readerOpts2{pool()};
+  readerOpts2.setDataIoStats(dataIoStats_);
+  readerOpts2.setMetadataIoStats(metadataIoStats_);
+  auto subfields2 = makeSubfields({"a", "b"});
+  folly::F14FastMap<std::string, std::vector<const common::Subfield*>>
+      subfields2ByName = groupSubfields(subfields2);
+  auto scanSpec2 = velox::connector::hive::makeScanSpec(
+      outputType, subfields2ByName, {}, {}, schema, {}, {}, {}, true, pool());
+  readerOpts2.setScanSpec(scanSpec2);
+
+  auto reader2 = DwrfReader::create(
+      createFileBufferedInput(getStructFile(), readerOpts2.memoryPool()),
+      readerOpts2);
+  RowReaderOptions rowReaderOpts2;
+  rowReaderOpts2.setScanSpec(scanSpec2);
+
+  auto rowReader2 = reader2->createRowReader(rowReaderOpts2);
+  ASSERT_EQ(rowReader2->estimatedRowSize(), 15);
+}
+
 TEST_F(TestReader, testStatsCallbackFiredWithoutFiltering) {
   RowReaderOptions rowReaderOpts;
   // Don't apply feature projection here
@@ -858,6 +997,8 @@ TEST_F(TestReader, testStatsCallbackFiredWithoutFiltering) {
       });
 
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
 
   auto reader = DwrfReader::create(
       createFileBufferedInput(getFMSmallFile(), readerOpts.memoryPool()),
@@ -941,8 +1082,12 @@ void verifyFlatmapStructEncoding(
     const std::string& filename,
     const std::vector<int32_t>& keysAsFields,
     const std::vector<int32_t>& keysToSelect,
+    const std::shared_ptr<io::IoStatistics>& dataIoStats,
+    const std::shared_ptr<io::IoStatistics>& metadataIoStats,
     size_t batchSize = 1000) {
   dwio::common::ReaderOptions readerOpts{pool};
+  readerOpts.setDataIoStats(dataIoStats);
+  readerOpts.setMetadataIoStats(metadataIoStats);
   auto reader = DwrfReader::create(
       createFileBufferedInput(filename, readerOpts.memoryPool()), readerOpts);
 
@@ -1009,7 +1154,9 @@ TEST_F(TestReader, testFlatmapAsStructSmall) {
       pool(),
       getFMSmallFile(),
       {1, 2, 3, 4, 5, -99999999 /* does not exist */},
-      {} /* no key filtering */);
+      {} /* no key filtering */,
+      dataIoStats_,
+      metadataIoStats_);
 }
 
 TEST_F(TestReader, testFlatmapAsStructSmallEmptyInmap) {
@@ -1018,6 +1165,8 @@ TEST_F(TestReader, testFlatmapAsStructSmallEmptyInmap) {
       getFMSmallFile(),
       {1, 2, 3, 4, 5, -99999999 /* does not exist */},
       {} /* no key filtering */,
+      dataIoStats_,
+      metadataIoStats_,
       2);
 }
 
@@ -1026,7 +1175,9 @@ TEST_F(TestReader, testFlatmapAsStructLarge) {
       pool(),
       getFMSmallFile(),
       {1, 2, 3, 4, 5, -99999999 /* does not exist */},
-      {} /* no key filtering */);
+      {} /* no key filtering */,
+      dataIoStats_,
+      metadataIoStats_);
 }
 
 TEST_F(TestReader, testFlatmapAsStructWithKeyProjection) {
@@ -1034,7 +1185,9 @@ TEST_F(TestReader, testFlatmapAsStructWithKeyProjection) {
       pool(),
       getFMSmallFile(),
       {1, 2, 3, 4, 5, -99999999 /* does not exist */},
-      {3, 5} /* select only these to read */);
+      {3, 5} /* select only these to read */,
+      dataIoStats_,
+      metadataIoStats_);
 }
 
 TEST_F(TestReader, testFlatmapAsStructRequiringKeyList) {
@@ -1049,12 +1202,15 @@ TEST_F(TestReader, testFlatmapAsStructRequiringKeyList) {
 TEST_F(TestReader, testMismatchSchemaMoreFields) {
   // file has schema: a int, b struct<a:int, b:float, c:string>, c float
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   RowReaderOptions rowReaderOpts;
   std::shared_ptr<const RowType> requestedType =
       std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
           "struct<a:int,b:struct<a:int,b:float,c:string>,c:float,d:string>"));
-  rowReaderOpts.select(std::make_shared<ColumnSelector>(
-      requestedType, std::vector<uint64_t>{1, 2, 3}));
+  rowReaderOpts.select(
+      std::make_shared<ColumnSelector>(
+          requestedType, std::vector<uint64_t>{1, 2, 3}));
   auto reader = DwrfReader::create(
       createFileBufferedInput(getStructFile(), readerOpts.memoryPool()),
       readerOpts);
@@ -1094,12 +1250,15 @@ TEST_F(TestReader, testMismatchSchemaMoreFields) {
 TEST_F(TestReader, testMismatchSchemaFewerFields) {
   // file has schema: a int, b struct<a:int, b:float, c:string>, c float
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   RowReaderOptions rowReaderOpts;
   std::shared_ptr<const RowType> requestedType =
       std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
           "struct<a:int,b:struct<a:int,b:float,c:string>>"));
-  rowReaderOpts.select(std::make_shared<ColumnSelector>(
-      requestedType, std::vector<uint64_t>{1}));
+  rowReaderOpts.select(
+      std::make_shared<ColumnSelector>(
+          requestedType, std::vector<uint64_t>{1}));
   auto reader = DwrfReader::create(
       createFileBufferedInput(getStructFile(), readerOpts.memoryPool()),
       readerOpts);
@@ -1135,13 +1294,16 @@ TEST_F(TestReader, testMismatchSchemaFewerFields) {
 TEST_F(TestReader, testMismatchSchemaNestedMoreFields) {
   // file has schema: a int, b struct<a:int, b:float>, c float
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   RowReaderOptions rowReaderOpts;
   std::shared_ptr<const RowType> requestedType =
       std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
           "struct<a:int,b:struct<a:int,b:float,c:string,d:binary>,c:float>"));
   LOG(INFO) << requestedType->toString();
-  rowReaderOpts.select(std::make_shared<ColumnSelector>(
-      requestedType, std::vector<std::string>{"b.b", "b.c", "b.d", "c"}));
+  rowReaderOpts.select(
+      std::make_shared<ColumnSelector>(
+          requestedType, std::vector<std::string>{"b.b", "b.c", "b.d", "c"}));
   auto reader = DwrfReader::create(
       createFileBufferedInput(getStructFile(), readerOpts.memoryPool()),
       readerOpts);
@@ -1201,12 +1363,15 @@ TEST_F(TestReader, testMismatchSchemaNestedMoreFields) {
 TEST_F(TestReader, testMismatchSchemaNestedFewerFields) {
   // file has schema: a int, b struct<a:int, b:float>, c float
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   RowReaderOptions rowReaderOpts;
   std::shared_ptr<const RowType> requestedType =
       std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
           "struct<a:int,b:struct<a:int,b:float>,c:float>"));
-  rowReaderOpts.select(std::make_shared<ColumnSelector>(
-      requestedType, std::vector<std::string>{"b.b", "c"}));
+  rowReaderOpts.select(
+      std::make_shared<ColumnSelector>(
+          requestedType, std::vector<std::string>{"b.b", "c"}));
   auto reader = DwrfReader::create(
       createFileBufferedInput(getStructFile(), readerOpts.memoryPool()),
       readerOpts);
@@ -1258,12 +1423,15 @@ TEST_F(TestReader, testMismatchSchemaNestedFewerFields) {
 TEST_F(TestReader, testMismatchSchemaIncompatibleNotSelected) {
   // file has schema: a int, b struct<a:int, b:float>, c float
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   RowReaderOptions rowReaderOpts;
   std::shared_ptr<const RowType> requestedType =
       std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
           "struct<a:float,b:struct<a:string,b:float>,c:int>"));
-  rowReaderOpts.select(std::make_shared<ColumnSelector>(
-      requestedType, std::vector<std::string>{"b.b"}));
+  rowReaderOpts.select(
+      std::make_shared<ColumnSelector>(
+          requestedType, std::vector<std::string>{"b.b"}));
   auto reader = DwrfReader::create(
       createFileBufferedInput(getStructFile(), readerOpts.memoryPool()),
       readerOpts);
@@ -1339,6 +1507,8 @@ TEST_F(TestReader, testMismatchSchemaIncompatible) {
 TEST_F(TestReader, fileColumnNamesReadAsLowerCase) {
   // upper.orc holds one columns (Bool_Val: BOOLEAN, b: BIGINT)
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   readerOpts.setFileColumnNamesReadAsLowerCase(true);
   auto reader = DwrfReader::create(
       createFileBufferedInput(
@@ -1353,6 +1523,8 @@ TEST_F(TestReader, fileColumnNamesReadAsLowerCaseComplexStruct) {
   // upper_complex.orc holds type
   // Cc:struct<CcLong0:bigint,CcMap1:map<string,struct<CcArray2:array<struct<CcInt3:int>>>>>
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   readerOpts.setFileColumnNamesReadAsLowerCase(true);
   auto reader = DwrfReader::create(
       createFileBufferedInput(
@@ -1391,8 +1563,10 @@ TEST_F(TestReader, fileColumnNamesReadAsLowerCaseComplexStruct) {
 
 TEST_F(TestReader, TestStripeSizeCallback) {
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   readerOpts.setFilePreloadThreshold(0);
-  readerOpts.setFooterEstimatedSize(17);
+  readerOpts.setFooterSpeculativeIoSize(17);
   RowReaderOptions rowReaderOpts;
 
   std::shared_ptr<const RowType> requestedType = std::dynamic_pointer_cast<
@@ -1419,8 +1593,10 @@ TEST_F(TestReader, TestStripeSizeCallback) {
 
 TEST_F(TestReader, TestStripeSizeCallbackLimitsOneStripe) {
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   readerOpts.setFilePreloadThreshold(0);
-  readerOpts.setFooterEstimatedSize(17);
+  readerOpts.setFooterSpeculativeIoSize(17);
   RowReaderOptions rowReaderOpts;
 
   std::shared_ptr<const RowType> requestedType = std::dynamic_pointer_cast<
@@ -1448,8 +1624,10 @@ TEST_F(TestReader, TestStripeSizeCallbackLimitsOneStripe) {
 
 TEST_F(TestReader, TestStripeSizeCallbackLimitsTwoStripe) {
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   readerOpts.setFilePreloadThreshold(0);
-  readerOpts.setFooterEstimatedSize(17);
+  readerOpts.setFooterSpeculativeIoSize(17);
   RowReaderOptions rowReaderOpts;
 
   std::shared_ptr<const RowType> requestedType = std::dynamic_pointer_cast<
@@ -1740,6 +1918,8 @@ TEST_F(TestReader, testEmptyFile) {
       std::make_shared<InMemoryReadFile>(std::move(data)), *pool());
 
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   RowReaderOptions rowReaderOpts;
 
   auto rowReader = DwrfReader::create(std::move(input), readerOpts)
@@ -1822,7 +2002,9 @@ void testBufferLifeCycle(
     const std::shared_ptr<dwrf::Config>& config,
     std::mt19937& rng,
     size_t batchSize,
-    bool hasNull) {
+    bool hasNull,
+    const std::shared_ptr<io::IoStatistics>& dataIoStats,
+    const std::shared_ptr<io::IoStatistics>& metadataIoStats) {
   std::vector<VectorPtr> batches;
   std::function<bool(vector_size_t)> isNullAt = nullptr;
   if (hasNull) {
@@ -1843,6 +2025,8 @@ void testBufferLifeCycle(
       std::make_shared<InMemoryReadFile>(std::move(data)), *pool);
 
   dwio::common::ReaderOptions readerOpts{pool};
+  readerOpts.setDataIoStats(dataIoStats);
+  readerOpts.setMetadataIoStats(metadataIoStats);
   RowReaderOptions rowReaderOpts;
   rowReaderOpts.setReturnFlatVector(true);
   auto reader = std::make_unique<DwrfReader>(readerOpts, std::move(input));
@@ -1880,7 +2064,9 @@ void testFlatmapAsMapFieldLifeCycle(
     const std::shared_ptr<dwrf::Config>& config,
     std::mt19937& rng,
     size_t batchSize,
-    bool hasNull) {
+    bool hasNull,
+    const std::shared_ptr<io::IoStatistics>& dataIoStats,
+    const std::shared_ptr<io::IoStatistics>& metadataIoStats) {
   std::vector<VectorPtr> batches;
   std::function<bool(vector_size_t)> isNullAt = nullptr;
   if (hasNull) {
@@ -1901,6 +2087,8 @@ void testFlatmapAsMapFieldLifeCycle(
       std::make_shared<InMemoryReadFile>(std::move(data)), *pool);
 
   dwio::common::ReaderOptions readerOpts{pool};
+  readerOpts.setDataIoStats(dataIoStats);
+  readerOpts.setMetadataIoStats(metadataIoStats);
   RowReaderOptions rowReaderOpts;
   rowReaderOpts.setReturnFlatVector(true);
   auto reader = std::make_unique<DwrfReader>(readerOpts, std::move(input));
@@ -1997,8 +2185,24 @@ TEST_F(TestReader, testBufferLifeCycle) {
   std::mt19937 rng{seed};
 
   for (auto i = 0; i < 10; ++i) {
-    testBufferLifeCycle(pool(), schema, config, rng, batchSize, false);
-    testBufferLifeCycle(pool(), schema, config, rng, batchSize, true);
+    testBufferLifeCycle(
+        pool(),
+        schema,
+        config,
+        rng,
+        batchSize,
+        false,
+        dataIoStats_,
+        metadataIoStats_);
+    testBufferLifeCycle(
+        pool(),
+        schema,
+        config,
+        rng,
+        batchSize,
+        true,
+        dataIoStats_,
+        metadataIoStats_);
   }
 }
 
@@ -2016,8 +2220,24 @@ TEST_F(TestReader, testFlatmapAsMapFieldLifeCycle) {
   LOG(INFO) << "seed: " << seed;
   std::mt19937 rng{seed};
 
-  testFlatmapAsMapFieldLifeCycle(pool(), schema, config, rng, batchSize, false);
-  testFlatmapAsMapFieldLifeCycle(pool(), schema, config, rng, batchSize, true);
+  testFlatmapAsMapFieldLifeCycle(
+      pool(),
+      schema,
+      config,
+      rng,
+      batchSize,
+      false,
+      dataIoStats_,
+      metadataIoStats_);
+  testFlatmapAsMapFieldLifeCycle(
+      pool(),
+      schema,
+      config,
+      rng,
+      batchSize,
+      true,
+      dataIoStats_,
+      metadataIoStats_);
 }
 
 TEST_F(TestReader, testFooterWrapper) {
@@ -2081,6 +2301,8 @@ std::pair<std::unique_ptr<dwrf::Writer>, std::unique_ptr<DwrfReader>>
 createWriterReader(
     const std::vector<VectorPtr>& batches,
     memory::MemoryPool* pool,
+    const std::shared_ptr<io::IoStatistics>& dataIoStats,
+    const std::shared_ptr<io::IoStatistics>& metadataIoStats,
     const std::shared_ptr<dwrf::Config>& config =
         std::make_shared<dwrf::Config>(),
     std::function<std::unique_ptr<DWRFFlushPolicy>()> flushPolicy =
@@ -2098,6 +2320,8 @@ createWriterReader(
   auto input = std::make_unique<BufferedInput>(
       std::make_shared<InMemoryReadFile>(std::move(data)), *pool);
   dwio::common::ReaderOptions readerOpts(pool);
+  readerOpts.setDataIoStats(dataIoStats);
+  readerOpts.setMetadataIoStats(metadataIoStats);
   readerOpts.setFileFormat(FileFormat::DWRF);
   auto reader = DwrfReader::create(std::move(input), readerOpts);
   return std::make_pair(std::move(writer), std::move(reader));
@@ -2115,7 +2339,8 @@ TEST_F(TestReader, setRowNumberColumnInfo) {
   };
   auto batches = createBatches(integerValues);
   auto schema = asRowType(batches[0]->type());
-  auto [writer, reader] = createWriterReader(batches, pool());
+  auto [writer, reader] =
+      createWriterReader(batches, pool(), dataIoStats_, metadataIoStats_);
 
   auto spec = std::make_shared<common::ScanSpec>("<root>");
   spec->addAllChildFields(*schema);
@@ -2144,7 +2369,8 @@ TEST_F(TestReader, reuseRowNumberColumn) {
   std::vector<std::vector<int32_t>> integerValues{{0, 1, 2, 3, 4}};
   auto batches = createBatches(integerValues);
   auto schema = asRowType(batches[0]->type());
-  auto [writer, reader] = createWriterReader(batches, pool());
+  auto [writer, reader] =
+      createWriterReader(batches, pool(), dataIoStats_, metadataIoStats_);
 
   auto spec = std::make_shared<common::ScanSpec>("<root>");
   spec->addAllChildFields(*schema);
@@ -2210,7 +2436,8 @@ TEST_F(TestReader, explicitRowNumberColumn) {
       {9, 10, 11, 12, 13, 14, 15},
   };
   auto batches = createBatches(integerValues);
-  auto [writer, reader] = createWriterReader(batches, pool());
+  auto [writer, reader] =
+      createWriterReader(batches, pool(), dataIoStats_, metadataIoStats_);
   auto spec = std::make_shared<common::ScanSpec>("<root>");
   spec->addField("c0", 0);
   spec->addField("$row_number", 1)
@@ -2247,7 +2474,8 @@ TEST_F(TestReader, failToReuseReaderNulls) {
       makeRowVector({"c"}, {makeFlatVector<int64_t>(11, folly::identity)}),
   });
   auto schema = asRowType(data->type());
-  auto [writer, reader] = createWriterReader({data}, pool());
+  auto [writer, reader] =
+      createWriterReader({data}, pool(), dataIoStats_, metadataIoStats_);
   auto spec = std::make_shared<common::ScanSpec>("<root>");
   spec->addAllChildFields(*schema);
   spec->childByName("c0")->childByName("a")->setFilter(
@@ -2269,24 +2497,25 @@ TEST_F(TestReader, failToReuseReaderNulls) {
 TEST_F(TestReader, readFlatMapsSomeEmpty) {
   // Test reading a flat map where the key filter means that some maps are
   // empty.
-  auto keys = makeFlatVector(std::vector<int64_t>{
-      1,
-      2,
-      3,
-      4,
-      5,
-      6, // map 1 has more than just the selected keys.
-      1,
-      2,
-      3, // map 2 has only selected keys.
-      4,
-      5,
-      6, // map 3 has no selected keys.
-      1,
-      2,
-      5,
-      6 // map 4 has some selected keys.
-  });
+  auto keys = makeFlatVector(
+      std::vector<int64_t>{
+          1,
+          2,
+          3,
+          4,
+          5,
+          6, // map 1 has more than just the selected keys.
+          1,
+          2,
+          3, // map 2 has only selected keys.
+          4,
+          5,
+          6, // map 3 has no selected keys.
+          1,
+          2,
+          5,
+          6 // map 4 has some selected keys.
+      });
   auto values = makeFlatVector<int64_t>(16, folly::identity);
   auto maps =
       makeMapVector(std::vector<vector_size_t>{0, 6, 9, 12, 16}, keys, values);
@@ -2297,7 +2526,8 @@ TEST_F(TestReader, readFlatMapsSomeEmpty) {
   config->set(dwrf::Config::FLATTEN_MAP, true);
   config->set(dwrf::Config::MAP_FLAT_COLS, {0});
 
-  auto [writer, reader] = createWriterReader({row}, pool(), config);
+  auto [writer, reader] =
+      createWriterReader({row}, pool(), dataIoStats_, metadataIoStats_, config);
 
   auto schema = asRowType(row->type());
   auto spec = std::make_shared<common::ScanSpec>("<root>");
@@ -2363,7 +2593,8 @@ TEST_F(TestReader, readFlatMapsWithNullMaps) {
   config->set(dwrf::Config::FLATTEN_MAP, true);
   config->set(dwrf::Config::MAP_FLAT_COLS, {0});
 
-  auto [writer, reader] = createWriterReader({row}, pool(), config);
+  auto [writer, reader] =
+      createWriterReader({row}, pool(), dataIoStats_, metadataIoStats_, config);
 
   auto schema = asRowType(row->type());
   auto spec = std::make_shared<common::ScanSpec>("<root>");
@@ -2420,7 +2651,8 @@ TEST_F(TestReader, readFlatMapsAsFlatMaps) {
     config->set(dwrf::Config::FLATTEN_MAP, true);
     config->set(dwrf::Config::MAP_FLAT_COLS, {0});
 
-    auto [writer, reader] = createWriterReader({input}, pool(), config);
+    auto [writer, reader] = createWriterReader(
+        {input}, pool(), dataIoStats_, metadataIoStats_, config);
 
     auto schema = asRowType(input->type());
     auto spec = std::make_shared<common::ScanSpec>("<root>");
@@ -2440,32 +2672,85 @@ TEST_F(TestReader, readFlatMapsAsFlatMaps) {
     assertEqualVectors(flatMap, resultMaps);
   };
 
-  testRoundTrip(makeFlatMapVector<int16_t, float>({
-      {},
-      {{1, 1.9}, {2, 2.1}, {0, 3.12}},
-      {{127, 0.12}},
-  }));
-
-  testRoundTrip(makeFlatMapVector<StringView, StringView>({
-      {{"a", "a1"}},
-      {{"b", "b1"}},
-      {{"c", "c1"}},
-      {{"d", "d1"}},
-  }));
-
-  testRoundTrip(makeNullableFlatMapVector<int32_t, int32_t>({
-      {{{101, 1}, {102, 2}, {103, 3}}},
-      {{{105, 0}, {106, 0}}},
-      {std::nullopt},
-      {{{101, 11}, {103, 13}, {105, std::nullopt}}},
-      {{{101, 1}, {102, 2}, {103, 3}}},
-  }));
-
-  testRoundTrip(makeFlatMapVector<int64_t, int64_t>(
-      {{{0, 0}, {1, 1}, {2, 2}, {3, 3}},
-       {{0, 4}, {1, 5}, {2, 6}, {3, 7}},
-       {{0, 8}, {1, 9}, {2, 10}, {3, 11}},
-       {{0, 12}, {1, 13}, {2, 14}, {3, 15}}}));
+  testRoundTrip(
+      makeFlatMapVector<int16_t, float>({
+          {},
+          {{1, 1.9}, {2, 2.1}, {0, 3.12}},
+          {{127, 0.12}},
+      }));
+
+  testRoundTrip(
+      makeFlatMapVector<StringView, StringView>({
+          {{"a", "a1"}},
+          {{"b", "b1"}},
+          {{"c", "c1"}},
+          {{"d", "d1"}},
+      }));
+
+  testRoundTrip(
+      makeNullableFlatMapVector<int32_t, int32_t>({
+          {{{101, 1}, {102, 2}, {103, 3}}},
+          {{{105, 0}, {106, 0}}},
+          {std::nullopt},
+          {{{101, 11}, {103, 13}, {105, std::nullopt}}},
+          {{{101, 1}, {102, 2}, {103, 3}}},
+      }));
+
+  testRoundTrip(
+      makeFlatMapVector<int64_t, int64_t>(
+          {{{0, 0}, {1, 1}, {2, 2}, {3, 3}},
+           {{0, 4}, {1, 5}, {2, 6}, {3, 7}},
+           {{0, 8}, {1, 9}, {2, 10}, {3, 11}},
+           {{0, 12}, {1, 13}, {2, 14}, {3, 15}}}));
+}
+
+// Regression test: reading a multi-stripe flatmap file with
+// preserveFlatMapsInMemory=true used to crash when stripes had different
+// key sets. The ScanSpec accumulated stale children across stripes, causing
+// out-of-range access on the reader's children_ vector.
+TEST_F(TestReader, readFlatMapMultiStripeDifferentKeys) {
+  // Stripe 1: keys {0, 1, 2, 3, 4} — 5 keys.
+  auto stripe1 = makeRowVector({makeMapVector<int32_t, float>(
+      {{{0, 1.0f}, {1, 2.0f}, {2, 3.0f}, {3, 4.0f}, {4, 5.0f}},
+       {{0, 6.0f}, {1, 7.0f}, {2, 8.0f}, {3, 9.0f}, {4, 10.0f}}})});
+
+  // Stripe 2: keys {0, 1, 2} — fewer keys than stripe 1.
+  auto stripe2 = makeRowVector({makeMapVector<int32_t, float>(
+      {{{0, 11.0f}, {1, 12.0f}, {2, 13.0f}},
+       {{0, 14.0f}, {1, 15.0f}, {2, 16.0f}},
+       {{0, 17.0f}, {1, 18.0f}, {2, 19.0f}}})});
+
+  auto config = std::make_shared<dwrf::Config>();
+  config->set(dwrf::Config::FLATTEN_MAP, true);
+  config->set(dwrf::Config::MAP_FLAT_COLS, {0});
+
+  // simpleFlushPolicyFactory(true) produces one stripe per batch.
+  auto [writer, reader] = createWriterReader(
+      {stripe1, stripe2}, pool(), dataIoStats_, metadataIoStats_, config);
+  ASSERT_EQ(reader->getNumberOfStripes(), 2);
+
+  auto schema = asRowType(stripe1->type());
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addAllChildFields(*schema);
+
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.setScanSpec(spec);
+  rowReaderOpts.setPreserveFlatMapsInMemory(true);
+
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  VectorPtr batch = BaseVector::create(schema, 0, pool());
+
+  uint64_t totalRows = 0;
+  while (rowReader->next(100, batch) > 0) {
+    auto* rowVec = batch->as<RowVector>();
+    // Trigger lazy loading — this is the pattern that used to crash.
+    for (column_index_t i = 0; i < rowVec->childrenSize(); ++i) {
+      auto& child = rowVec->childAt(i);
+      child = BaseVector::loadedVectorShared(child);
+    }
+    totalRows += batch->size();
+  }
+  EXPECT_EQ(totalRows, 5); // 2 rows from stripe 1 + 3 rows from stripe 2.
 }
 
 TEST_F(TestReader, readStructWithWholeBatchFiltered) {
@@ -2492,7 +2777,8 @@ TEST_F(TestReader, readStructWithWholeBatchFiltered) {
       std::make_shared<RowVector>(pool(), rowType, nulls, vectorSize, children);
   auto row = makeRowVector({"c0"}, {c0});
 
-  auto [writer, reader] = createWriterReader({row}, pool());
+  auto [writer, reader] =
+      createWriterReader({row}, pool(), dataIoStats_, metadataIoStats_);
 
   auto schema = asRowType(row->type());
   auto spec = std::make_shared<common::ScanSpec>("<root>");
@@ -2547,6 +2833,8 @@ TEST_F(TestReader, readStringDictionaryAsFlat) {
   auto [writer, reader] = createWriterReader(
       {batch},
       pool(),
+      dataIoStats_,
+      metadataIoStats_,
       std::make_shared<dwrf::Config>(),
       // The always true flush policy would disable dictionary encoding at least
       // for first batch.
@@ -2566,9 +2854,10 @@ TEST_F(TestReader, readStringDictionaryAsFlat) {
   ASSERT_EQ(c0->valueVector()->size(), dictionary.size());
   dwio::common::RuntimeStatistics stats;
   rowReader->updateRuntimeStats(stats);
-  ASSERT_EQ(stats.columnReaderStatistics.flattenStringDictionaryValues, 0);
-  spec->childByName("c0")->setFilter(std::make_unique<common::BytesValues>(
-      std::vector<std::string>{"aaaaaaaaaaaaaaaaaaaa"}, false));
+  ASSERT_EQ(stats.columnReaderStats.flattenStringDictionaryValues, 0);
+  spec->childByName("c0")->setFilter(
+      std::make_unique<common::BytesValues>(
+          std::vector<std::string>{"aaaaaaaaaaaaaaaaaaaa"}, false));
   spec->resetCachedValues(true);
   rowReader = reader->createRowReader(rowReaderOpts);
   ASSERT_EQ(rowReader->next(20, actual), 20);
@@ -2576,7 +2865,7 @@ TEST_F(TestReader, readStringDictionaryAsFlat) {
   ASSERT_TRUE(actual->as<RowVector>()->childAt(0)->isFlatEncoding());
   stats = {};
   rowReader->updateRuntimeStats(stats);
-  ASSERT_EQ(stats.columnReaderStatistics.flattenStringDictionaryValues, 1);
+  ASSERT_EQ(stats.columnReaderStats.flattenStringDictionaryValues, 1);
 }
 
 // A primitive subfield is missing in file, and result is not reused.
@@ -2587,7 +2876,8 @@ TEST_F(TestReader, missingSubfieldsNoResultReusing) {
           makeFlatVector<int64_t>(kSize, folly::identity),
       }),
   });
-  auto [writer, reader] = createWriterReader({batch}, pool());
+  auto [writer, reader] =
+      createWriterReader({batch}, pool(), dataIoStats_, metadataIoStats_);
   auto schema = ROW({{"c0", ROW({{"c0", BIGINT()}, {"c1", VARCHAR()}})}});
   auto spec = std::make_shared<common::ScanSpec>("<root>");
   spec->addAllChildFields(*schema);
@@ -2616,7 +2906,8 @@ TEST_F(TestReader, selectiveStringDirectFastPath) {
       makeFlatVector<int64_t>(17, [](auto i) { return i != 8; }),
       makeFlatVector<StringView>(17, genStr),
   });
-  auto [writer, reader] = createWriterReader({batch}, pool());
+  auto [writer, reader] =
+      createWriterReader({batch}, pool(), dataIoStats_, metadataIoStats_);
   auto schema = asRowType(batch->type());
   auto spec = std::make_shared<common::ScanSpec>("<root>");
   spec->addAllChildFields(*schema);
@@ -2642,7 +2933,8 @@ TEST_F(TestReader, selectiveStringDirect) {
       makeFlatVector<int64_t>(17, [](auto i) { return i != 15; }),
       makeFlatVector<StringView>(17, genStr),
   });
-  auto [writer, reader] = createWriterReader({batch}, pool());
+  auto [writer, reader] =
+      createWriterReader({batch}, pool(), dataIoStats_, metadataIoStats_);
   auto schema = asRowType(batch->type());
   auto spec = std::make_shared<common::ScanSpec>("<root>");
   spec->addAllChildFields(*schema);
@@ -2666,7 +2958,8 @@ TEST_F(TestReader, selectiveFlatMapFastPathAllInlinedStringKeys) {
   auto config = std::make_shared<dwrf::Config>();
   config->set(dwrf::Config::FLATTEN_MAP, true);
   config->set(dwrf::Config::MAP_FLAT_COLS, {0});
-  auto [writer, reader] = createWriterReader({row}, pool(), config);
+  auto [writer, reader] =
+      createWriterReader({row}, pool(), dataIoStats_, metadataIoStats_, config);
   auto schema = asRowType(row->type());
   auto spec = std::make_shared<common::ScanSpec>("<root>");
   spec->addAllChildFields(*schema);
@@ -2685,6 +2978,8 @@ TEST_F(TestReader, skipLongString) {
       std::make_shared<LocalReadFile>(getExampleFilePath("long_string.dwrf")),
       *pool());
   dwio::common::ReaderOptions readerOpts(pool());
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   readerOpts.setFileFormat(FileFormat::DWRF);
   auto reader = DwrfReader::create(std::move(input), readerOpts);
   auto spec = std::make_shared<common::ScanSpec>("<root>");
@@ -2721,3 +3016,820 @@ TEST_F(TestReader, skipLongString) {
     validate(batch);
   }
 }
+
+TEST_F(TestReader, mapAsStruct) {
+  auto row = makeRowVector({
+      makeMapVector<int32_t, int64_t>({{{1, 4}, {2, 5}}, {{1, 6}, {3, 7}}}),
+  });
+  auto [writer, reader] =
+      createWriterReader({row}, pool(), dataIoStats_, metadataIoStats_);
+  auto outType = ROW({"c0"}, {ROW({"3", "1"}, BIGINT())});
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addAllChildFields(*outType);
+  spec->childByName("c0")->setFlatMapAsStruct(true);
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.setScanSpec(spec);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  VectorPtr batch = BaseVector::create(outType, 0, pool());
+  ASSERT_EQ(rowReader->next(10, batch), 2);
+  auto expected = makeRowVector({
+      makeRowVector(
+          {"3", "1"},
+          {
+              makeNullableFlatVector<int64_t>({std::nullopt, 7}),
+              makeFlatVector<int64_t>({4, 6}),
+          }),
+  });
+  assertEqualVectors(expected, batch);
+}
+
+TEST_F(TestReader, mapAsStructFilterAfterRead) {
+  auto row = makeRowVector({
+      makeMapVector<int32_t, int64_t>({{{1, 4}, {2, 5}}, {}, {{1, 6}, {3, 7}}}),
+      makeRowVector(
+          {makeConstant<int64_t>(0, 3)}, [](auto i) { return i == 0; }),
+  });
+  auto [writer, reader] =
+      createWriterReader({row}, pool(), dataIoStats_, metadataIoStats_);
+  auto outType =
+      ROW({"c0", "c1"}, {ROW({"3", "1"}, BIGINT()), ROW({"c0"}, BIGINT())});
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addAllChildFields(*outType);
+  auto* c0Spec = spec->childByName("c0");
+  c0Spec->setFlatMapAsStruct(true);
+  c0Spec->setFilter(std::make_shared<common::IsNotNull>());
+  spec->childByName("c1")->setFilter(std::make_shared<common::IsNotNull>());
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.setScanSpec(spec);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  VectorPtr batch = BaseVector::create(outType, 0, pool());
+  ASSERT_EQ(rowReader->next(10, batch), 3);
+  auto expected = makeRowVector({
+      makeRowVector(
+          {"3", "1"},
+          {
+              makeNullableFlatVector<int64_t>({std::nullopt, 7}),
+              makeNullableFlatVector<int64_t>({std::nullopt, 6}),
+          }),
+      makeRowVector({makeConstant<int64_t>(0, 2)}),
+  });
+  assertEqualVectors(expected, batch);
+}
+
+TEST_F(TestReader, mapAsStructAllEmpty) {
+  auto row = makeRowVector({makeMapVector<int32_t, int64_t>({{}, {}})});
+  auto [writer, reader] =
+      createWriterReader({row}, pool(), dataIoStats_, metadataIoStats_);
+  auto outType = ROW({"c0"}, {ROW({"1"}, BIGINT())});
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addAllChildFields(*outType);
+  spec->childByName("c0")->setFlatMapAsStruct(true);
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.setScanSpec(spec);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  VectorPtr batch = BaseVector::create(outType, 0, pool());
+  ASSERT_EQ(rowReader->next(10, batch), 2);
+  auto expected = makeRowVector({
+      makeRowVector({"1"}, {makeNullConstant(TypeKind::BIGINT, 2)}),
+  });
+  assertEqualVectors(expected, batch);
+}
+
+// Verify DwrfRowReader can be destroyed while ParallelUnitLoader async load()
+// are in progress. This regression test ensures that:
+// 1. ParallelUnitLoader destructor doesn't wait for async load() operations
+// 2. Async load() from DwrfUnit can still function after ParallelUnitLoader
+// destruction and DwrfRowReader destruction, which means all dependencies in
+// DwrfUnit remain valid (eg ReaderBase)
+//
+// If a future change adds an unsafe raw pointer to DwrfUnit's dependencies that
+// would be freed by ParallelUnitLoader or DwrfRowReader's destruction, this
+// test may crash due to use-after-free.
+DEBUG_ONLY_TEST_F(TestReader, asyncLoadSurvivesReaderDestruction) {
+  const int kNumStripes = 2;
+  const int kRowsPerStripe = 100;
+  std::vector<VectorPtr> batches;
+  batches.reserve(kNumStripes);
+  for (int stripe = 0; stripe < kNumStripes; ++stripe) {
+    batches.push_back(makeRowVector({
+        makeFlatVector<int64_t>(
+            kRowsPerStripe,
+            [stripe](auto row) { return stripe * kRowsPerStripe + row; }),
+    }));
+  }
+
+  // Write the DWRF file - force each batch into its own stripe
+  auto config = std::make_shared<dwrf::Config>();
+
+  auto sink =
+      std::make_unique<MemorySink>(1 << 20, FileSink::Options{.pool = pool()});
+  auto* sinkPtr = sink.get();
+  auto writer = E2EWriterTestUtil::writeData(
+      std::move(sink),
+      asRowType(batches[0]->type()),
+      batches,
+      config,
+      // Force flush after each batch to create separate stripes
+      E2EWriterTestUtil::simpleFlushPolicyFactory(true));
+
+  std::string data(sinkPtr->data(), sinkPtr->size());
+  auto input = std::make_unique<BufferedInput>(
+      std::make_shared<InMemoryReadFile>(std::move(data)), *pool());
+
+  std::atomic<int> asyncLoadsStarted{0};
+  std::atomic<int> asyncLoadsCompleted{0};
+  folly::Baton<> readerDestroyed;
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::dwio::common::ParallelUnitLoader::load",
+      std::function<void(void*)>([&](void*) {
+        // Only block the second stripe (index 1) - let the first stripe load
+        // normally so rowReader->next() can complete
+        // fetch_add returns the value before increment: 0 for first, 1 for
+        // second, etc.
+        if (asyncLoadsStarted.fetch_add(1) == 1) {
+          // Block here until reader is destroyed
+          readerDestroyed.wait();
+        }
+        asyncLoadsCompleted.fetch_add(1);
+      }));
+
+  auto ioExecutor = std::make_shared<folly::IOThreadPoolExecutor>(2);
+
+  // Make sure ReaderOptions and DwrfRowReader are freed after {} scope
+  {
+    dwio::common::ReaderOptions readerOpts(pool());
+    readerOpts.setDataIoStats(dataIoStats_);
+    readerOpts.setMetadataIoStats(metadataIoStats_);
+    readerOpts.setFileFormat(FileFormat::DWRF);
+    auto reader = DwrfReader::create(std::move(input), readerOpts);
+
+    // Enable parallel unit load
+    RowReaderOptions rowReaderOpts;
+    rowReaderOpts.setParallelUnitLoadCount(2);
+    rowReaderOpts.setIOExecutor(ioExecutor.get());
+    auto rowReader = reader->createRowReader(rowReaderOpts);
+
+    VectorPtr batch;
+    rowReader->next(50, batch); // Read first stripe
+
+    auto start = std::chrono::steady_clock::now();
+    rowReader.reset();
+    auto duration = std::chrono::steady_clock::now() - start;
+    // Verify destruction was fast (didn't wait for async operations)
+    EXPECT_LT(duration, std::chrono::seconds(1))
+        << "Destruction should not wait for async loads";
+  }
+
+  // Now signal that reader is destroyed
+  readerDestroyed.post();
+
+  // Wait for async loads to complete
+  int maxWaitMs = 2000;
+  int waitedMs = 0;
+  while (asyncLoadsCompleted.load() < 2 && waitedMs < maxWaitMs) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    waitedMs += 100;
+  }
+
+  // Verify that both async loads completed successfully after reader
+  // destruction This proves the fix works: async operations can complete even
+  // after DwrfRowReader is destroyed because LoadUnit is captured as shared_ptr
+  EXPECT_EQ(asyncLoadsCompleted.load(), 2)
+      << "Both async loads should complete even after reader destruction. "
+      << "If this fails, it means async operations are being cancelled or "
+      << "crashing after DwrfRowReader destruction, indicating unsafe pointers.";
+
+  // Clean up
+  ioExecutor->join();
+}
+
+TEST_F(TestReader, extractionTransformMapKeys) {
+  // Write a MAP(VARCHAR, BIGINT) column, read with a ScanSpec transform
+  // that applies MapKeys extraction at the reader level.
+  auto keys = makeFlatVector<StringView>({"a", "b", "c", "d"});
+  auto values = makeFlatVector<int64_t>({1, 2, 3, 4});
+  auto mapVector = makeMapVector({0, 2}, keys, values);
+  auto data = makeRowVector({"col"}, {mapVector});
+  auto schema = asRowType(data->type());
+  auto [writer, reader] =
+      createWriterReader({data}, pool(), dataIoStats_, metadataIoStats_);
+
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addAllChildFields(*schema);
+
+  spec->childByName("col")->setExtractionType(
+      common::ScanSpec::ExtractionType::kKeys);
+
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.setScanSpec(spec);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  auto result = BaseVector::create(schema, 0, pool());
+  ASSERT_EQ(rowReader->next(10, result), 2);
+  auto* row = result->as<RowVector>();
+  auto* resultArray = row->childAt(0)->loadedVector()->as<ArrayVector>();
+  ASSERT_EQ(resultArray->size(), 2);
+  ASSERT_EQ(resultArray->sizeAt(0), 2);
+  ASSERT_EQ(resultArray->sizeAt(1), 2);
+}
+
+TEST_F(TestReader, extractionTransformSize) {
+  // Write a MAP(VARCHAR, BIGINT) column, read with a Size extraction.
+  auto keys = makeFlatVector<StringView>({"a", "b", "c"});
+  auto values = makeFlatVector<int64_t>({1, 2, 3});
+  auto mapVector = makeMapVector({0, 1}, keys, values);
+  auto data = makeRowVector({"col"}, {mapVector});
+  auto schema = asRowType(data->type());
+  auto [writer, reader] =
+      createWriterReader({data}, pool(), dataIoStats_, metadataIoStats_);
+
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addAllChildFields(*schema);
+
+  spec->childByName("col")->setExtractionType(
+      common::ScanSpec::ExtractionType::kSize);
+
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.setScanSpec(spec);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  auto result = BaseVector::create(schema, 0, pool());
+  ASSERT_EQ(rowReader->next(10, result), 2);
+  auto* row = result->as<RowVector>();
+  auto* sizes = row->childAt(0)->loadedVector()->as<FlatVector<int64_t>>();
+  ASSERT_EQ(sizes->size(), 2);
+  ASSERT_EQ(sizes->valueAt(0), 1);
+  ASSERT_EQ(sizes->valueAt(1), 2);
+}
+
+TEST_F(TestReader, extractionMapKeySizeWithSeek) {
+  // Repro for the kSize+MAP+no-deltaUpdate skip() bug.  When kSize is
+  // configured on a MAP column without a delta update, neither keyReader_
+  // nor elementReader_ is created.  Forward seekToRow() after a prior read
+  // triggers SelectiveMapColumnReaderBase::skip() which currently fails
+  // because it requires at least one child reader to read the length stream.
+  constexpr int kNumRows = 100;
+  std::vector<std::string> keyStrs(kNumRows * 2);
+  for (int i = 0; i < kNumRows * 2; ++i) {
+    keyStrs[i] = "k_" + std::to_string(i);
+  }
+  auto keys = makeFlatVector<StringView>(
+      kNumRows * 2, [&](auto i) { return StringView(keyStrs[i]); });
+  auto values = makeFlatVector<int64_t>(kNumRows * 2, folly::identity);
+  std::vector<vector_size_t> offsets(kNumRows);
+  for (int i = 0; i < kNumRows; ++i) {
+    offsets[i] = i * 2;
+  }
+  auto mapVector = makeMapVector(offsets, keys, values);
+  auto data = makeRowVector({"col"}, {mapVector});
+  auto schema = asRowType(data->type());
+  auto [writer, reader] =
+      createWriterReader({data}, pool(), dataIoStats_, metadataIoStats_);
+
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addAllChildFields(*schema);
+  spec->childByName("col")->setExtractionType(
+      common::ScanSpec::ExtractionType::kSize);
+
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.setScanSpec(spec);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  // Read & materialize the first 20 rows.
+  auto result = BaseVector::create(schema, 0, pool());
+  ASSERT_EQ(rowReader->next(20, result), 20);
+  result->as<RowVector>()->childAt(0)->loadedVector();
+
+  // seekToRow advances the map reader from offset 20 to 50, calling skip()
+  // for the 30-row gap.  Without the fix, this VELOX_FAILs at
+  // SelectiveMapColumnReaderBase::skip with "repeated reader with no
+  // children".
+  ASSERT_NO_THROW(dynamic_cast<DwrfRowReader*>(rowReader.get())->seekToRow(50));
+}
+
+TEST_F(TestReader, extractionTransformMapValuesStructField) {
+  // MAP(VARCHAR, ROW(x: INT, y: INT)) with chain
+  // [MapValues, ArrayElements, StructField("x")] -> ARRAY(INT).
+  // The reader handles this natively via kValues on the map and kField on
+  // the values struct, so no post-read transform is needed.
+  auto keys = makeFlatVector<StringView>({"a", "b", "c"});
+  auto structValues = makeRowVector(
+      {"x", "y"},
+      {makeFlatVector<int32_t>({10, 20, 30}),
+       makeFlatVector<int32_t>({100, 200, 300})});
+  auto mapVector = makeMapVector({0, 2}, keys, structValues);
+  auto data = makeRowVector({"col"}, {mapVector});
+  auto schema = asRowType(data->type());
+  auto [writer, reader] =
+      createWriterReader({data}, pool(), dataIoStats_, metadataIoStats_);
+
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addAllChildFields(*schema);
+
+  using connector::hive::applyExtractionChain;
+  using connector::hive::configureExtractionScanSpec;
+  using connector::hive::ExtractionPathElement;
+  using connector::hive::ExtractionPathElementPtr;
+  using connector::hive::ExtractionStep;
+  using connector::hive::NamedExtraction;
+
+  // Configure extraction on the "col" spec with the sub-chain starting
+  // from the MAP type: [MapValues, ArrayElements, StructField("x")].
+  auto mapType = schema->childAt(0);
+  std::vector<NamedExtraction> colExtractions = {
+      {"out",
+       {ExtractionPathElement::simple(ExtractionStep::kMapValues),
+        ExtractionPathElement::simple(ExtractionStep::kArrayElements),
+        ExtractionPathElement::structField("x")},
+       INTEGER()}};
+  auto* colSpec = spec->childByName("col");
+  configureExtractionScanSpec(mapType, colExtractions, *colSpec, pool());
+
+  // Set a full-chain transform for delta update fallback.
+  auto fullChain = colExtractions[0].chain;
+  colSpec->setTransform(
+      [fullChain](const VectorPtr& input, memory::MemoryPool* p) -> VectorPtr {
+        return applyExtractionChain(input, fullChain, p);
+      },
+      ARRAY(INTEGER()));
+
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.setScanSpec(spec);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  auto result = BaseVector::create(schema, 0, pool());
+  ASSERT_EQ(rowReader->next(10, result), 2);
+  auto* row = result->as<RowVector>();
+  auto* resultArray = row->childAt(0)->loadedVector()->as<ArrayVector>();
+  ASSERT_EQ(resultArray->size(), 2);
+  ASSERT_EQ(resultArray->sizeAt(0), 2);
+  ASSERT_EQ(resultArray->sizeAt(1), 1);
+  auto* elements = resultArray->elements()->as<FlatVector<int32_t>>();
+  ASSERT_EQ(elements->valueAt(0), 10);
+  ASSERT_EQ(elements->valueAt(1), 20);
+  ASSERT_EQ(elements->valueAt(2), 30);
+}
+
+TEST_F(TestReader, extractionSizeResultVectorReuse) {
+  // Verify the FlatVector<int64_t> result is reused across batches for
+  // Size extraction (no per-batch allocation).
+  // Write multiple batches to produce multiple reads.
+  constexpr int kNumRows = 200;
+  std::vector<std::string> keyStrs(kNumRows * 2);
+  for (int i = 0; i < kNumRows * 2; ++i) {
+    keyStrs[i] = std::to_string(i);
+  }
+  auto keys = makeFlatVector<StringView>(
+      kNumRows * 2, [&](auto i) { return StringView(keyStrs[i]); });
+  auto values = makeFlatVector<int64_t>(kNumRows * 2, folly::identity);
+  // Each row has 2 map entries.
+  std::vector<vector_size_t> offsets(kNumRows);
+  for (int i = 0; i < kNumRows; ++i) {
+    offsets[i] = i * 2;
+  }
+  auto mapVector = makeMapVector(offsets, keys, values);
+  auto data = makeRowVector({"col"}, {mapVector});
+  auto schema = asRowType(data->type());
+  auto [writer, reader] =
+      createWriterReader({data}, pool(), dataIoStats_, metadataIoStats_);
+
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addAllChildFields(*schema);
+  spec->childByName("col")->setExtractionType(
+      common::ScanSpec::ExtractionType::kSize);
+
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.setScanSpec(spec);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  auto result = BaseVector::create(schema, 0, pool());
+
+  // Read first batch.
+  ASSERT_GT(rowReader->next(50, result), 0);
+  auto* row = result->as<RowVector>();
+  auto* child = row->childAt(0)->loadedVector();
+  ASSERT_TRUE(child->type()->isBigint());
+  auto* firstBatchPtr = child;
+
+  // Read second batch — the FlatVector should be the same object.
+  ASSERT_GT(rowReader->next(50, result), 0);
+  row = result->as<RowVector>();
+  child = row->childAt(0)->loadedVector();
+  ASSERT_EQ(child, firstBatchPtr)
+      << "FlatVector result should be reused across batches for Size extraction";
+
+  // Verify values are correct (each map has 2 entries).
+  auto* sizes = child->as<FlatVector<int64_t>>();
+  for (int i = 0; i < sizes->size(); ++i) {
+    ASSERT_EQ(sizes->valueAt(i), 2);
+  }
+}
+
+TEST_F(TestReader, extractionMapKeysMultipleBatches) {
+  // Verify MapKeys extraction produces correct results across multiple
+  // batches.
+  constexpr int kNumRows = 200;
+  std::vector<std::string> keyStrs(kNumRows * 3);
+  for (int i = 0; i < kNumRows * 3; ++i) {
+    keyStrs[i] = std::to_string(i);
+  }
+  auto keys = makeFlatVector<StringView>(
+      kNumRows * 3, [&](auto i) { return StringView(keyStrs[i]); });
+  auto values = makeFlatVector<int64_t>(kNumRows * 3, folly::identity);
+  std::vector<vector_size_t> offsets(kNumRows);
+  for (int i = 0; i < kNumRows; ++i) {
+    offsets[i] = i * 3;
+  }
+  auto mapVector = makeMapVector(offsets, keys, values);
+  auto data = makeRowVector({"col"}, {mapVector});
+  auto schema = asRowType(data->type());
+  auto [writer, reader] =
+      createWriterReader({data}, pool(), dataIoStats_, metadataIoStats_);
+
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addAllChildFields(*schema);
+  spec->childByName("col")->setExtractionType(
+      common::ScanSpec::ExtractionType::kKeys);
+
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.setScanSpec(spec);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  auto result = BaseVector::create(schema, 0, pool());
+
+  // Read first batch.
+  ASSERT_GT(rowReader->next(50, result), 0);
+  auto* row = result->as<RowVector>();
+  auto* child = row->childAt(0)->loadedVector();
+  ASSERT_TRUE(child->type()->isArray());
+  auto* arr = child->as<ArrayVector>();
+  for (int i = 0; i < arr->size(); ++i) {
+    ASSERT_EQ(arr->sizeAt(i), 3);
+  }
+
+  // Read second batch — verify correctness.
+  ASSERT_GT(rowReader->next(50, result), 0);
+  row = result->as<RowVector>();
+  child = row->childAt(0)->loadedVector();
+  arr = child->as<ArrayVector>();
+  for (int i = 0; i < arr->size(); ++i) {
+    ASSERT_EQ(arr->sizeAt(i), 3);
+  }
+}
+
+TEST_F(TestReader, extractionMapKeysIoReduction) {
+  // Verify that MapKeys extraction produces correct results on a large
+  // dataset.  The extraction pushdown skips decoding the value stream
+  // (seekTo instead of readWithTiming) — this saves CPU but DWRF coalesced
+  // I/O reads the full stripe from storage regardless.  Decode-level savings
+  // are validated by the extractionTransformMapKeys test which verifies the
+  // reader's seekTo behavior.
+  constexpr int kNumRows = 10'000;
+  std::vector<std::string> keyStrs(kNumRows * 2);
+  for (int i = 0; i < kNumRows * 2; ++i) {
+    keyStrs[i] = "key_" + std::to_string(i);
+  }
+  auto keys = makeFlatVector<StringView>(
+      kNumRows * 2, [&](auto i) { return StringView(keyStrs[i]); });
+  auto values = makeFlatVector<int64_t>(kNumRows * 2, folly::identity);
+  std::vector<vector_size_t> offsets(kNumRows);
+  for (int i = 0; i < kNumRows; ++i) {
+    offsets[i] = i * 2;
+  }
+  auto mapVector = makeMapVector(offsets, keys, values);
+  auto data = makeRowVector({"col"}, {mapVector});
+  auto schema = asRowType(data->type());
+  auto [writer, reader] =
+      createWriterReader({data}, pool(), dataIoStats_, metadataIoStats_);
+
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addAllChildFields(*schema);
+  spec->childByName("col")->setExtractionType(
+      common::ScanSpec::ExtractionType::kKeys);
+
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.setScanSpec(spec);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  auto result = BaseVector::create(schema, 0, pool());
+  uint64_t totalRows = 0;
+  while (auto batch = rowReader->next(1'000, result)) {
+    totalRows += batch;
+    auto* row = result->as<RowVector>();
+    auto* arr = row->childAt(0)->loadedVector()->as<ArrayVector>();
+    ASSERT_EQ(arr->size(), batch);
+    for (vector_size_t i = 0; i < arr->size(); ++i) {
+      ASSERT_EQ(arr->sizeAt(i), 2) << "Row " << i << " should have 2 keys";
+    }
+  }
+  ASSERT_EQ(totalRows, kNumRows);
+
+  // Validate IO reduction: MapKeys extraction should read fewer bytes than
+  // a full scan because the values stream is not requested.
+  auto sink =
+      std::make_unique<MemorySink>(1 << 20, FileSink::Options{.pool = pool()});
+  auto* sinkPtr = sink.get();
+  auto writerObj = E2EWriterTestUtil::writeData(
+      std::move(sink),
+      schema,
+      {data},
+      std::make_shared<dwrf::Config>(),
+      E2EWriterTestUtil::simpleFlushPolicyFactory(true));
+  std::string fileData(sinkPtr->data(), sinkPtr->size());
+
+  auto runWithSpec =
+      [&](const std::shared_ptr<common::ScanSpec>& scanSpec) -> uint64_t {
+    auto ioStats = std::make_shared<io::IoStatistics>();
+    // Disable coalescing (maxMergeDistance=0) so each stream is read
+    // separately and rawBytesRead reflects actual stream-level I/O.
+    // Disable file preloading so small files don't bypass per-stream IO.
+    auto input = std::make_unique<BufferedInput>(
+        std::make_shared<InMemoryReadFile>(fileData),
+        *pool(),
+        MetricsLog::voidLog(),
+        ioStats.get(),
+        /*ioStats=*/nullptr,
+        /*maxMergeDistance=*/0);
+    dwio::common::ReaderOptions readerOpts(pool());
+    readerOpts.setDataIoStats(ioStats);
+    readerOpts.setMetadataIoStats(ioStats);
+    readerOpts.setFileFormat(FileFormat::DWRF);
+    readerOpts.setFilePreloadThreshold(0);
+    auto rdr = DwrfReader::create(std::move(input), readerOpts);
+    RowReaderOptions rro;
+    rro.setScanSpec(scanSpec);
+    auto rr = rdr->createRowReader(rro);
+    auto res = BaseVector::create(schema, 0, pool());
+    while (rr->next(kNumRows, res) > 0) {
+    }
+    return ioStats->rawBytesRead();
+  };
+
+  auto fullSpec = std::make_shared<common::ScanSpec>("<root>");
+  fullSpec->addAllChildFields(*schema);
+  auto fullBytes = runWithSpec(fullSpec);
+
+  auto extSpec = std::make_shared<common::ScanSpec>("<root>");
+  extSpec->addAllChildFields(*schema);
+  extSpec->childByName("col")->setExtractionType(
+      common::ScanSpec::ExtractionType::kKeys);
+  auto extBytes = runWithSpec(extSpec);
+
+  ASSERT_GT(fullBytes, 0);
+  ASSERT_LT(extBytes, fullBytes)
+      << "Extraction: " << extBytes << ", Full: " << fullBytes;
+}
+
+TEST_F(TestReader, extractionNestedChainScanSpec) {
+  // Test that a nested extraction chain recursively configures ALL levels
+  // of the ScanSpec, so no post-read transform is needed.
+  //
+  // Schema: ROW(a: MAP(VARCHAR, ROW(x: INT, y: ARRAY(BIGINT))), b: INT)
+  // Chain: [StructField("a"), MapValues, ArrayElements, StructField("y"), Size]
+  //
+  // Expected ScanSpec at each level:
+  //   ROOT ROW: "b" pruned (constant null), "a" not pruned
+  //   "a" MAP: ExtractionType::kValues
+  //   values ROW: "x" pruned (constant null), "y" not pruned
+  //   "y" ARRAY: ExtractionType::kSize
+
+  auto innerStructType = ROW({{"x", INTEGER()}, {"y", ARRAY(BIGINT())}});
+  auto mapType = MAP(VARCHAR(), innerStructType);
+  auto schema = ROW({{"a", mapType}, {"b", INTEGER()}});
+
+  // Build the ScanSpec.
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addAllChildFields(*schema);
+
+  // Build extraction.
+  using connector::hive::configureExtractionScanSpec;
+  using connector::hive::ExtractionPathElement;
+  using connector::hive::ExtractionPathElementPtr;
+  using connector::hive::ExtractionStep;
+  using connector::hive::NamedExtraction;
+
+  std::vector<NamedExtraction> extractions = {
+      {"out",
+       {ExtractionPathElement::structField("a"),
+        ExtractionPathElement::simple(ExtractionStep::kMapValues),
+        ExtractionPathElement::simple(ExtractionStep::kArrayElements),
+        ExtractionPathElement::structField("y"),
+        ExtractionPathElement::simple(ExtractionStep::kSize)},
+       ARRAY(BIGINT())}};
+
+  configureExtractionScanSpec(schema, extractions, *spec, pool());
+
+  // Level 1 (ROOT ROW): "b" pruned, "a" not pruned.
+  auto* bSpec = spec->childByName("b");
+  ASSERT_NE(bSpec, nullptr);
+  ASSERT_TRUE(bSpec->isConstant());
+
+  auto* aSpec = spec->childByName("a");
+  ASSERT_NE(aSpec, nullptr);
+  ASSERT_FALSE(aSpec->isConstant());
+
+  // Level 2 ("a" MAP): ExtractionType::kValues.
+  ASSERT_EQ(aSpec->extractionType(), common::ScanSpec::ExtractionType::kValues);
+
+  // Level 3 (values ROW): "x" pruned, "y" not pruned.
+  auto* valuesSpec = aSpec->childByName(common::ScanSpec::kMapValuesFieldName);
+  ASSERT_NE(valuesSpec, nullptr);
+
+  auto* xSpec = valuesSpec->childByName("x");
+  ASSERT_NE(xSpec, nullptr);
+  ASSERT_TRUE(xSpec->isConstant());
+
+  auto* ySpec = valuesSpec->childByName("y");
+  ASSERT_NE(ySpec, nullptr);
+  ASSERT_FALSE(ySpec->isConstant());
+
+  // Level 4 ("y" ARRAY): ExtractionType::kSize.
+  ASSERT_EQ(ySpec->extractionType(), common::ScanSpec::ExtractionType::kSize);
+
+  // The values struct has kField extraction for "y" (the only needed field).
+  ASSERT_EQ(
+      valuesSpec->extractionType(), common::ScanSpec::ExtractionType::kField);
+
+  // Verify kField targets the correct field index.
+  ASSERT_EQ(valuesSpec->extractionFieldIndex(), 1);
+
+  // Write test data and verify the reader produces correct results.
+  //
+  // Each row i has map: {"k" -> {x: i*10, y: [0..i]}}
+  // So y has (i+1) elements.
+  constexpr int kNumRows = 10;
+  std::vector<StringView> allKeys;
+  std::vector<int32_t> allX;
+  std::vector<std::vector<int64_t>> allY;
+  for (int i = 0; i < kNumRows; ++i) {
+    allKeys.emplace_back("k");
+    allX.push_back(i * 10);
+    std::vector<int64_t> yValues;
+    for (int j = 0; j <= i; ++j) {
+      yValues.push_back(i * 100 + j);
+    }
+    allY.push_back(std::move(yValues));
+  }
+
+  auto keys = makeFlatVector<StringView>(allKeys);
+  auto xFlat = makeFlatVector<int32_t>(allX);
+  auto yArray = makeArrayVector<int64_t>(allY);
+  auto rowValues = makeRowVector({"x", "y"}, {xFlat, yArray});
+
+  // Each row has exactly 1 map entry.
+  std::vector<vector_size_t> mapOffsets(kNumRows);
+  std::iota(mapOffsets.begin(), mapOffsets.end(), 0);
+  auto map = makeMapVector(mapOffsets, keys, rowValues);
+  auto bCol = makeFlatVector<int32_t>(kNumRows, folly::identity);
+  auto batch = makeRowVector({"a", "b"}, {map, bCol});
+
+  auto [writer, reader] =
+      createWriterReader({batch}, pool(), dataIoStats_, metadataIoStats_);
+
+  // Configure the ScanSpec for reading.  In production, the extraction is
+  // applied to the column's spec (not the root), so we configure "a"'s
+  // spec directly with the sub-chain after StructField("a").
+  using connector::hive::applyExtractionChain;
+  auto readSpec = std::make_shared<common::ScanSpec>("<root>");
+  readSpec->addAllChildFields(*schema);
+  auto* readASpec = readSpec->childByName("a");
+
+  // Sub-chain starting from the MAP type: [MapValues, AE, SF("y"), Size].
+  std::vector<NamedExtraction> aExtractions = {
+      {"out",
+       {ExtractionPathElement::simple(ExtractionStep::kMapValues),
+        ExtractionPathElement::simple(ExtractionStep::kArrayElements),
+        ExtractionPathElement::structField("y"),
+        ExtractionPathElement::simple(ExtractionStep::kSize)},
+       ARRAY(BIGINT())}};
+  configureExtractionScanSpec(mapType, aExtractions, *readASpec, pool());
+
+  // Prune "b" as constant null (mimic HiveDataSource behavior).
+  auto* readBSpec = readSpec->childByName("b");
+  readBSpec->setConstantValue(
+      BaseVector::createNullConstant(INTEGER(), 1, pool()));
+
+  // Set a full-chain transform (used as fallback for delta updates).
+  auto fullChain = aExtractions[0].chain;
+  readASpec->setTransform(
+      [fullChain](const VectorPtr& input, memory::MemoryPool* p) -> VectorPtr {
+        return applyExtractionChain(input, fullChain, p);
+      },
+      BIGINT());
+
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.setScanSpec(readSpec);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  auto result = BaseVector::create(schema, 0, pool());
+  ASSERT_TRUE(rowReader->next(kNumRows, result));
+  ASSERT_EQ(result->size(), kNumRows);
+
+  // The reader with kValues extraction on "a" produces an ArrayVector.
+  // The values struct reader has kField extraction for "y", so it
+  // produces the "y" field directly (BIGINT from kSize).  No remaining
+  // transform is needed.  So elements are BIGINT.
+  auto* resultRow = result->as<RowVector>();
+  ASSERT_NE(resultRow, nullptr);
+
+  // "b" should be null (pruned).
+  auto* bResult = resultRow->childAt(1).get();
+  ASSERT_TRUE(bResult->isConstantEncoding());
+
+  // "a" should be an ArrayVector (from kValues extraction).
+  auto* aResult = resultRow->childAt(0)->loadedVector()->as<ArrayVector>();
+  ASSERT_NE(aResult, nullptr);
+
+  // Each element is BIGINT (size of y array).
+  auto* elements = aResult->elements()->asFlatVector<int64_t>();
+  ASSERT_NE(elements, nullptr);
+  for (int i = 0; i < kNumRows; ++i) {
+    ASSERT_EQ(aResult->sizeAt(i), 1) << "Row " << i << " should have 1 entry";
+    // y array had (i+1) elements, so size should be (i+1).
+    ASSERT_EQ(elements->valueAt(aResult->offsetAt(i)), i + 1)
+        << "Incorrect size at row " << i;
+  }
+
+  // Validate IO reduction: nested extraction should read fewer bytes than
+  // a full scan because "b" column, map keys, "x" field, and y array
+  // elements are all skipped.
+  constexpr int kLargeNumRows = 1'000;
+  std::vector<StringView> largeKeys;
+  std::vector<int32_t> largeX;
+  std::vector<std::vector<int64_t>> largeY;
+  for (int i = 0; i < kLargeNumRows; ++i) {
+    largeKeys.emplace_back("k");
+    largeX.push_back(i * 10);
+    std::vector<int64_t> yVals(10);
+    std::iota(yVals.begin(), yVals.end(), i * 100);
+    largeY.push_back(std::move(yVals));
+  }
+  auto largeKeysVec = makeFlatVector<StringView>(largeKeys);
+  auto largeXVec = makeFlatVector<int32_t>(largeX);
+  auto largeYVec = makeArrayVector<int64_t>(largeY);
+  auto largeRowValues = makeRowVector({"x", "y"}, {largeXVec, largeYVec});
+  std::vector<vector_size_t> largeMapOffsets(kLargeNumRows);
+  std::iota(largeMapOffsets.begin(), largeMapOffsets.end(), 0);
+  auto largeMap = makeMapVector(largeMapOffsets, largeKeysVec, largeRowValues);
+  auto largeBCol = makeFlatVector<int32_t>(kLargeNumRows, folly::identity);
+  auto largeBatch = makeRowVector({"a", "b"}, {largeMap, largeBCol});
+
+  auto largeSink =
+      std::make_unique<MemorySink>(1 << 20, FileSink::Options{.pool = pool()});
+  auto* largeSinkPtr = largeSink.get();
+  auto largeWriter = E2EWriterTestUtil::writeData(
+      std::move(largeSink),
+      schema,
+      {largeBatch},
+      std::make_shared<dwrf::Config>(),
+      E2EWriterTestUtil::simpleFlushPolicyFactory(true));
+  std::string largeFileData(largeSinkPtr->data(), largeSinkPtr->size());
+
+  auto runLargeWithSpec =
+      [&](const std::shared_ptr<common::ScanSpec>& scanSpec) -> uint64_t {
+    auto ioStats = std::make_shared<io::IoStatistics>();
+    // Disable coalescing so each stream is read separately.
+    // Disable file preloading so small files don't bypass per-stream IO.
+    auto input = std::make_unique<BufferedInput>(
+        std::make_shared<InMemoryReadFile>(largeFileData),
+        *pool(),
+        MetricsLog::voidLog(),
+        ioStats.get(),
+        /*ioStats=*/nullptr,
+        /*maxMergeDistance=*/0);
+    dwio::common::ReaderOptions readerOpts(pool());
+    readerOpts.setDataIoStats(ioStats);
+    readerOpts.setMetadataIoStats(ioStats);
+    readerOpts.setFileFormat(FileFormat::DWRF);
+    readerOpts.setFilePreloadThreshold(0);
+    auto rdr = DwrfReader::create(std::move(input), readerOpts);
+    RowReaderOptions rro;
+    rro.setScanSpec(scanSpec);
+    auto rr = rdr->createRowReader(rro);
+    auto res = BaseVector::create(schema, 0, pool());
+    while (rr->next(kLargeNumRows, res) > 0) {
+    }
+    return ioStats->rawBytesRead();
+  };
+
+  // Full scan: read all columns.
+  auto fullSpec2 = std::make_shared<common::ScanSpec>("<root>");
+  fullSpec2->addAllChildFields(*schema);
+  auto fullBytes = runLargeWithSpec(fullSpec2);
+
+  // Extraction scan with nested pushdown.
+  auto extSpec2 = std::make_shared<common::ScanSpec>("<root>");
+  extSpec2->addAllChildFields(*schema);
+  configureExtractionScanSpec(schema, extractions, *extSpec2, pool());
+  extSpec2->childByName("b")->setConstantValue(
+      BaseVector::createNullConstant(INTEGER(), 1, pool()));
+  auto extBytes = runLargeWithSpec(extSpec2);
+
+  ASSERT_GT(fullBytes, 0);
+  ASSERT_LT(extBytes, fullBytes)
+      << "Nested extraction: " << extBytes << ", Full: " << fullBytes;
+}
+
+} // namespace
+} // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/test/StripeReaderBaseTests.cpp b/velox/dwio/dwrf/test/StripeReaderBaseTests.cpp
index 4091204ba96..09ab5503f19 100644
--- a/velox/dwio/dwrf/test/StripeReaderBaseTests.cpp
+++ b/velox/dwio/dwrf/test/StripeReaderBaseTests.cpp
@@ -17,6 +17,7 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+#include "velox/common/io/IoStatistics.h"
 #include "velox/dwio/common/encryption/TestProvider.h"
 #include "velox/dwio/dwrf/reader/StripeReaderBase.h"
 #include "velox/dwio/dwrf/utils/ProtoUtils.h"
@@ -42,7 +43,8 @@ class StripeLoadKeysTest : public Test {
     HiveTypeParser parser;
     auto type = parser.parse("struct<a:int>");
     footer_ = std::make_unique<proto::Footer>();
-    ProtoUtils::writeType(*type, *footer_);
+    auto footerWrapper = FooterWriteWrapper(footer_.get());
+    ProtoUtils::writeType(*type, footerWrapper);
     auto enc = footer_->mutable_encryption();
     enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
     auto group = enc->add_encryptiongroups();
@@ -72,7 +74,9 @@ class StripeLoadKeysTest : public Test {
         nullptr,
         footer_.get(),
         nullptr,
-        std::move(handler));
+        std::move(handler),
+        dataIoStats_,
+        metadataIoStats_);
 
     stripeReader_ = std::make_unique<StripeReaderBase>(reader_);
   }
@@ -93,8 +97,8 @@ class StripeLoadKeysTest : public Test {
 
     handler_ = std::move(handler);
 
-    enc_ = const_cast<TestEncryption*>(
-        std::addressof(dynamic_cast<const TestEncryption&>(
+    enc_ = const_cast<TestEncryption*>(std::addressof(
+        dynamic_cast<const TestEncryption&>(
             handler_->getEncryptionProviderByIndex(0))));
   }
 
@@ -103,6 +107,10 @@ class StripeLoadKeysTest : public Test {
   std::unique_ptr<StripeReaderBase> stripeReader_;
   TestEncryption* enc_;
   std::shared_ptr<MemoryPool> pool_;
+  std::shared_ptr<io::IoStatistics> dataIoStats_ =
+      std::make_shared<io::IoStatistics>();
+  std::shared_ptr<io::IoStatistics> metadataIoStats_ =
+      std::make_shared<io::IoStatistics>();
   std::unique_ptr<const proto::StripeFooter> stripeFooter_;
   std::unique_ptr<const encryption::DecryptionHandler> handler_;
   std::unique_ptr<const StripeInformationWrapper> stripeInfo_;
diff --git a/velox/dwio/dwrf/test/TestStripeStream.cpp b/velox/dwio/dwrf/test/StripeStreamTest.cpp
similarity index 92%
rename from velox/dwio/dwrf/test/TestStripeStream.cpp
rename to velox/dwio/dwrf/test/StripeStreamTest.cpp
index 2e9132aeb5f..72bebf35a0d 100644
--- a/velox/dwio/dwrf/test/TestStripeStream.cpp
+++ b/velox/dwio/dwrf/test/StripeStreamTest.cpp
@@ -14,9 +14,11 @@
  * limitations under the License.
  */
 
+#include "velox/dwio/dwrf/reader/StripeStream.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/io/IoStatistics.h"
+#include "velox/dwio/common/Arena.h"
 #include "velox/dwio/common/encryption/TestProvider.h"
-#include "velox/dwio/dwrf/reader/StripeStream.h"
 #include "velox/dwio/dwrf/test/OrcTest.h"
 #include "velox/dwio/dwrf/utils/ProtoUtils.h"
 #include "velox/dwio/dwrf/writer/WriterBase.h"
@@ -42,8 +44,7 @@ class RecordingInputStream : public facebook::velox::InMemoryReadFile {
       uint64_t offset,
       uint64_t length,
       void* buf,
-      facebook::velox::filesystems::File::IoStats* stats =
-          nullptr) const override {
+      const facebook::velox::FileIoContext& context = {}) const override {
     reads_.push_back({offset, length});
     return {static_cast<char*>(buf), length};
   }
@@ -138,6 +139,10 @@ class StripeStreamTest : public testing::TestWithParam<DwrfFormat> {
     MemoryManager::testingSetInstance(MemoryManager::Options{});
   }
   std::shared_ptr<MemoryPool> pool_{memoryManager()->addLeafPool()};
+  std::shared_ptr<facebook::velox::io::IoStatistics> dataIoStats_ =
+      std::make_shared<facebook::velox::io::IoStatistics>();
+  std::shared_ptr<facebook::velox::io::IoStatistics> metadataIoStats_ =
+      std::make_shared<facebook::velox::io::IoStatistics>();
 };
 
 class StripeStreamFormatTypeTest : public testing::TestWithParam<DwrfFormat> {
@@ -146,6 +151,10 @@ class StripeStreamFormatTypeTest : public testing::TestWithParam<DwrfFormat> {
     MemoryManager::testingSetInstance(MemoryManager::Options{});
   }
   std::shared_ptr<MemoryPool> pool_{memoryManager()->addLeafPool()};
+  std::shared_ptr<facebook::velox::io::IoStatistics> dataIoStats_ =
+      std::make_shared<facebook::velox::io::IoStatistics>();
+  std::shared_ptr<facebook::velox::io::IoStatistics> metadataIoStats_ =
+      std::make_shared<facebook::velox::io::IoStatistics>();
   DwrfFormat testParamDwrfFormat_ = GetParam();
 };
 
@@ -158,10 +167,11 @@ INSTANTIATE_TEST_SUITE_P(
 
 TEST_P(StripeStreamFormatTypeTest, planReads) {
   google::protobuf::Arena arena;
-  auto footer = google::protobuf::Arena::CreateMessage<proto::Footer>(&arena);
-  footer->set_rowindexstride(100);
+  auto footer = ArenaCreate<proto::Footer>(&arena);
+  auto footerWrapper = FooterWriteWrapper(footer);
+  footerWrapper.setRowIndexStride(100);
   auto type = HiveTypeParser().parse("struct<a:int,b:float>");
-  ProtoUtils::writeType(*type, *footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto is = std::make_unique<RecordingInputStream>();
   auto isPtr = is.get();
   auto readerBase = std::make_shared<ReaderBase>(
@@ -176,7 +186,10 @@ TEST_P(StripeStreamFormatTypeTest, planReads) {
           true),
       std::make_unique<PostScript>(proto::PostScript{}),
       footer,
-      nullptr);
+      nullptr,
+      nullptr,
+      dataIoStats_,
+      metadataIoStats_);
   ColumnSelector cs{readerBase->schema(), std::vector<uint64_t>{2}, true};
 
   TestDecrypterFactory factory;
@@ -247,10 +260,11 @@ TEST_P(StripeStreamFormatTypeTest, planReads) {
 
 TEST_F(StripeStreamTest, filterSequences) {
   google::protobuf::Arena arena;
-  auto footer = google::protobuf::Arena::CreateMessage<proto::Footer>(&arena);
-  footer->set_rowindexstride(100);
+  auto footer = ArenaCreate<proto::Footer>(&arena);
+  auto footerWrapper = FooterWriteWrapper(footer);
+  footerWrapper.setRowIndexStride(100);
   auto type = HiveTypeParser().parse("struct<a:map<int,float>>");
-  ProtoUtils::writeType(*type, *footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto is = std::make_unique<RecordingInputStream>();
   auto isPtr = is.get();
   auto readerBase = std::make_shared<ReaderBase>(
@@ -258,7 +272,10 @@ TEST_F(StripeStreamTest, filterSequences) {
       std::make_unique<BufferedInput>(std::move(is), *pool_),
       std::make_unique<PostScript>(proto::PostScript{}),
       footer,
-      nullptr);
+      nullptr,
+      nullptr,
+      dataIoStats_,
+      metadataIoStats_);
 
   // mock a filter that we only need one node and one sequence
   ColumnSelector cs{readerBase->schema(), std::vector<std::string>{"a#[1]"}};
@@ -311,10 +328,11 @@ TEST_F(StripeStreamTest, filterSequences) {
 
 TEST_P(StripeStreamFormatTypeTest, zeroLength) {
   google::protobuf::Arena arena;
-  auto footer = google::protobuf::Arena::CreateMessage<proto::Footer>(&arena);
-  footer->set_rowindexstride(100);
+  auto footer = ArenaCreate<proto::Footer>(&arena);
+  auto footerWrapper = FooterWriteWrapper(footer);
+  footerWrapper.setRowIndexStride(100);
   auto type = HiveTypeParser().parse("struct<a:int>");
-  ProtoUtils::writeType(*type, *footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   proto::PostScript ps;
   ps.set_compressionblocksize(1024);
   ps.set_compression(proto::CompressionKind::ZSTD);
@@ -325,7 +343,10 @@ TEST_P(StripeStreamFormatTypeTest, zeroLength) {
       std::make_unique<BufferedInput>(std::move(is), *pool_),
       std::make_unique<PostScript>(std::move(ps)),
       footer,
-      nullptr);
+      nullptr,
+      nullptr,
+      dataIoStats_,
+      metadataIoStats_);
 
   TestDecrypterFactory factory;
   auto handler = DecryptionHandler::create(FooterWrapper(footer), &factory);
@@ -437,12 +458,13 @@ TEST_P(StripeStreamFormatTypeTest, planReadsIndex) {
   index.SerializeToOstream(&buffer);
 
   // build footer
-  auto footer = google::protobuf::Arena::CreateMessage<proto::Footer>(&arena);
-  footer->set_rowindexstride(100);
-  footer->add_stripecacheoffsets(0);
-  footer->add_stripecacheoffsets(buffer.tellp());
+  auto footer = ArenaCreate<proto::Footer>(&arena);
+  auto footerWrapper = FooterWriteWrapper(footer);
+  footerWrapper.setRowIndexStride(100);
+  footerWrapper.addStripeCacheOffsets(0);
+  footerWrapper.addStripeCacheOffsets(buffer.tellp());
   auto type = HiveTypeParser().parse("struct<a:int>");
-  ProtoUtils::writeType(*type, *footer);
+  ProtoUtils::writeType(*type, footerWrapper);
 
   // build cache
   std::string str(buffer.str());
@@ -458,7 +480,10 @@ TEST_P(StripeStreamFormatTypeTest, planReadsIndex) {
       std::make_unique<BufferedInput>(std::move(is), *pool_),
       std::make_unique<PostScript>(std::move(ps)),
       footer,
-      std::move(cache));
+      std::move(cache),
+      nullptr,
+      dataIoStats_,
+      metadataIoStats_);
 
   TestDecrypterFactory factory;
   auto handler = DecryptionHandler::create(FooterWrapper(footer), &factory);
@@ -596,23 +621,24 @@ TEST_F(StripeStreamTest, readEncryptedStreams) {
   proto::PostScript ps;
   ps.set_compression(proto::CompressionKind::ZSTD);
   ps.set_compressionblocksize(256 * 1024);
-  auto footer = google::protobuf::Arena::CreateMessage<proto::Footer>(&arena);
+  auto footer = ArenaCreate<proto::Footer>(&arena);
+  auto footerWrapper = FooterWriteWrapper(footer);
   // a: not encrypted, projected
   // encryption group 1: b, c. projected b.
   // group 2: d. projected d.
   // group 3: e. not projected
   auto type = HiveTypeParser().parse("struct<a:int,b:int,c:int,d:int,e:int>");
-  ProtoUtils::writeType(*type, *footer);
+  ProtoUtils::writeType(*type, footerWrapper);
 
-  auto enc = footer->mutable_encryption();
+  auto enc = footerWrapper.mutableEncryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
   addEncryptionGroup(*enc, {2, 3});
   addEncryptionGroup(*enc, {4});
   addEncryptionGroup(*enc, {5});
 
-  auto stripe = footer->add_stripes();
+  auto stripe = footerWrapper.addStripes();
   for (auto i = 0; i < 3; ++i) {
-    *stripe->add_keymetadata() = folly::to<std::string>("key", i);
+    *stripe.addKeyMetadata() = folly::to<std::string>("key", i);
   }
   TestDecrypterFactory factory;
   auto handler = DecryptionHandler::create(FooterWrapper(footer), &factory);
@@ -643,7 +669,9 @@ TEST_F(StripeStreamTest, readEncryptedStreams) {
       std::make_unique<PostScript>(std::move(ps)),
       footer,
       nullptr,
-      std::move(handler));
+      std::move(handler),
+      dataIoStats_,
+      metadataIoStats_);
   auto stripeMetadata = std::make_unique<const StripeMetadata>(
       &readerBase->bufferedInput(),
       std::move(stripeFooter),
@@ -689,19 +717,20 @@ TEST_F(StripeStreamTest, schemaMismatch) {
   proto::PostScript ps;
   ps.set_compression(proto::CompressionKind::ZSTD);
   ps.set_compressionblocksize(256 * 1024);
-  auto footer = google::protobuf::Arena::CreateMessage<proto::Footer>(&arena);
+  auto footer = ArenaCreate<proto::Footer>(&arena);
+  auto footerWrapper = FooterWriteWrapper(footer);
   // a: not encrypted, has schema change
   // b: encrypted
   // c: not encrypted
   auto type = HiveTypeParser().parse("struct<a:struct<a:int>,b:int,c:int>");
-  ProtoUtils::writeType(*type, *footer);
+  ProtoUtils::writeType(*type, footerWrapper);
 
-  auto enc = footer->mutable_encryption();
+  auto enc = footerWrapper.mutableEncryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
   addEncryptionGroup(*enc, {3});
 
-  auto stripe = footer->add_stripes();
-  *stripe->add_keymetadata() = "key";
+  auto stripe = footerWrapper.addStripes();
+  *stripe.addKeyMetadata() = "key";
   TestDecrypterFactory factory;
   auto handler = DecryptionHandler::create(FooterWrapper(footer), &factory);
   TestEncrypter encrypter;
@@ -726,7 +755,9 @@ TEST_F(StripeStreamTest, schemaMismatch) {
       std::make_unique<PostScript>(std::move(ps)),
       footer,
       nullptr,
-      std::move(handler));
+      std::move(handler),
+      dataIoStats_,
+      metadataIoStats_);
   auto stripeMetadata = std::make_unique<const StripeMetadata>(
       &readerBase->bufferedInput(),
       std::move(stripeFooter),
diff --git a/velox/dwio/dwrf/test/TestByteRle.cpp b/velox/dwio/dwrf/test/TestByteRle.cpp
index ad19d341a50..94f8ecf9da6 100644
--- a/velox/dwio/dwrf/test/TestByteRle.cpp
+++ b/velox/dwio/dwrf/test/TestByteRle.cpp
@@ -39,9 +39,9 @@ std::unique_ptr<ByteRleDecoder> createBooleanDecoder(
 
 TEST(ByteRle, simpleTest) {
   const unsigned char buffer[] = {0x61, 0x00, 0xfd, 0x44, 0x45, 0x46};
-  std::unique_ptr<ByteRleDecoder> rle =
-      createByteDecoder(std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))));
+  std::unique_ptr<ByteRleDecoder> rle = createByteDecoder(
+      std::unique_ptr<SeekableInputStream>(
+          new SeekableArrayInputStream(buffer, std::size(buffer))));
   std::vector<char> data(103);
   rle->next(data.data(), data.size(), nullptr);
 
@@ -54,9 +54,9 @@ TEST(ByteRle, simpleTest) {
 }
 
 TEST(ByteRle, nullTest) {
-  char buffer[258];
-  uint64_t nulls[5];
-  char result[266];
+  char buffer[258] = {'\0'};
+  uint64_t nulls[5] = {'\0'};
+  char result[266] = {'\0'};
   buffer[0] = -128;
   buffer[129] = -128;
   for (int32_t i = 0; i < 128; ++i) {
@@ -66,8 +66,8 @@ TEST(ByteRle, nullTest) {
   for (int32_t i = 0; i < 266; ++i) {
     bits::setNull(nulls, i, i < 10);
   }
-  std::unique_ptr<ByteRleDecoder> rle =
-      createByteDecoder(std::unique_ptr<SeekableInputStream>(
+  std::unique_ptr<ByteRleDecoder> rle = createByteDecoder(
+      std::unique_ptr<SeekableInputStream>(
           new SeekableArrayInputStream(buffer, sizeof(buffer))));
   rle->next(result, sizeof(result), nulls);
   for (size_t i = 0; i < sizeof(result); ++i) {
@@ -93,9 +93,9 @@ TEST(ByteRle, literalCrossBuffer) {
       0x09,
       0x07,
       0x10};
-  std::unique_ptr<ByteRleDecoder> rle =
-      createByteDecoder(std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer), 6)));
+  std::unique_ptr<ByteRleDecoder> rle = createByteDecoder(
+      std::unique_ptr<SeekableInputStream>(
+          new SeekableArrayInputStream(buffer, std::size(buffer), 6)));
   std::vector<char> data(20);
   rle->next(data.data(), data.size(), nullptr);
 
@@ -109,9 +109,9 @@ TEST(ByteRle, literalCrossBuffer) {
 
 TEST(ByteRle, skipLiteralBufferUnderflowTest) {
   const unsigned char buffer[] = {0xf8, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7};
-  std::unique_ptr<ByteRleDecoder> rle =
-      createByteDecoder(std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer), 4)));
+  std::unique_ptr<ByteRleDecoder> rle = createByteDecoder(
+      std::unique_ptr<SeekableInputStream>(
+          new SeekableArrayInputStream(buffer, std::size(buffer), 4)));
   std::vector<char> data(8);
   rle->next(data.data(), 3, nullptr);
   EXPECT_EQ(0x0, data[0]);
@@ -127,9 +127,9 @@ TEST(ByteRle, skipLiteralBufferUnderflowTest) {
 
 TEST(ByteRle, simpleRuns) {
   const unsigned char buffer[] = {0x0d, 0xff, 0x0d, 0xfe, 0x0d, 0xfd};
-  std::unique_ptr<ByteRleDecoder> rle =
-      createByteDecoder(std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))));
+  std::unique_ptr<ByteRleDecoder> rle = createByteDecoder(
+      std::unique_ptr<SeekableInputStream>(
+          new SeekableArrayInputStream(buffer, std::size(buffer))));
   std::vector<char> data(16);
   for (size_t i = 0; i < 3; ++i) {
     rle->next(data.data(), data.size(), nullptr);
@@ -145,9 +145,9 @@ TEST(ByteRle, splitHeader) {
       0x00, 0x01, 0xe0, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
       0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
       0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20};
-  std::unique_ptr<ByteRleDecoder> rle =
-      createByteDecoder(std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer), 1)));
+  std::unique_ptr<ByteRleDecoder> rle = createByteDecoder(
+      std::unique_ptr<SeekableInputStream>(
+          new SeekableArrayInputStream(buffer, std::size(buffer), 1)));
   std::vector<char> data(35);
   rle->next(data.data(), data.size(), nullptr);
   for (size_t i = 0; i < 3; ++i) {
@@ -179,9 +179,9 @@ TEST(ByteRle, splitRuns) {
       0x0e,
       0x0f,
       0x10};
-  std::unique_ptr<ByteRleDecoder> rle =
-      createByteDecoder(std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))));
+  std::unique_ptr<ByteRleDecoder> rle = createByteDecoder(
+      std::unique_ptr<SeekableInputStream>(
+          new SeekableArrayInputStream(buffer, std::size(buffer))));
   std::vector<char> data(5);
   for (size_t i = 0; i < 3; ++i) {
     rle->next(data.data(), data.size(), nullptr);
@@ -227,9 +227,9 @@ TEST(ByteRle, testNulls) {
       0x0f,
       0x3d,
       0xdc};
-  std::unique_ptr<ByteRleDecoder> rle =
-      createByteDecoder(std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer), 3)));
+  std::unique_ptr<ByteRleDecoder> rle = createByteDecoder(
+      std::unique_ptr<SeekableInputStream>(
+          new SeekableArrayInputStream(buffer, std::size(buffer), 3)));
   std::vector<char> data(16, -1);
   std::vector<uint64_t> nulls(1);
   for (size_t i = 0; i < data.size(); ++i) {
@@ -276,9 +276,9 @@ TEST(ByteRle, testAllNulls) {
       0x0f,
       0x3d,
       0xdc};
-  std::unique_ptr<ByteRleDecoder> rle =
-      createByteDecoder(std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))));
+  std::unique_ptr<ByteRleDecoder> rle = createByteDecoder(
+      std::unique_ptr<SeekableInputStream>(
+          new SeekableArrayInputStream(buffer, std::size(buffer))));
   std::vector<char> data(16, -1);
   std::vector<uint64_t> allNull(1, bits::kNull64);
   std::vector<uint64_t> noNull(1, bits::kNotNull64);
@@ -413,7 +413,7 @@ TEST(ByteRle, testSkip) {
       0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
   };
   SeekableInputStream* const stream =
-      new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer));
+      new SeekableArrayInputStream(buffer, std::size(buffer));
   std::unique_ptr<ByteRleDecoder> rle =
       createByteDecoder(std::unique_ptr<SeekableInputStream>(stream));
   std::vector<char> data(1);
@@ -570,7 +570,7 @@ TEST(ByteRle, testSeek) {
       0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
   };
   std::unique_ptr<SeekableInputStream> stream(
-      new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer)));
+      new SeekableArrayInputStream(buffer, std::size(buffer)));
   const uint64_t fileLocs[] = {
       0,    0,    0,    0,    0,    2,    2,    2,    2,    4,    4,    4,
       4,    6,    6,    6,    6,    8,    8,    8,    8,    10,   10,   10,
@@ -907,7 +907,7 @@ TEST(ByteRle, testSeek) {
 
   // Seek to end
   std::vector<uint64_t> position;
-  position.push_back(VELOX_ARRAY_SIZE(buffer));
+  position.push_back(std::size(buffer));
   position.push_back(0);
   PositionProvider pp{position};
   rle->seekToRowGroup(pp);
@@ -916,7 +916,7 @@ TEST(ByteRle, testSeek) {
 
   // Seek to end + 1
   position.clear();
-  position.push_back(VELOX_ARRAY_SIZE(buffer));
+  position.push_back(std::size(buffer));
   position.push_back(1);
   PositionProvider pp2{position};
   rle->seekToRowGroup(pp2);
@@ -926,7 +926,7 @@ TEST(ByteRle, testSeek) {
 TEST(BooleanRle, simpleTest) {
   const unsigned char buffer[] = {0x61, 0xf0, 0xfd, 0x55, 0xAA, 0x55};
   std::unique_ptr<SeekableInputStream> stream(
-      new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer)));
+      new SeekableArrayInputStream(buffer, std::size(buffer)));
   std::unique_ptr<ByteRleDecoder> rle = createBooleanDecoder(std::move(stream));
   std::vector<char> data(50);
   for (size_t i = 0; i < 16; ++i) {
@@ -951,7 +951,7 @@ TEST(BooleanRle, runsTest) {
   const unsigned char buffer[] = {
       0xf7, 0xff, 0x80, 0x3f, 0xe0, 0x0f, 0xf8, 0x03, 0xfe, 0x00};
   std::unique_ptr<SeekableInputStream> stream(
-      new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer)));
+      new SeekableArrayInputStream(buffer, std::size(buffer)));
   std::unique_ptr<ByteRleDecoder> rle = createBooleanDecoder(std::move(stream));
   std::vector<char> data(72);
   rle->next(data.data(), data.size(), nullptr);
@@ -973,7 +973,7 @@ TEST(BooleanRle, runsTestWithNull) {
   const unsigned char buffer[] = {
       0xf7, 0xff, 0x80, 0x3f, 0xe0, 0x0f, 0xf8, 0x03, 0xfe, 0x00};
   std::unique_ptr<SeekableInputStream> stream(
-      new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer)));
+      new SeekableArrayInputStream(buffer, std::size(buffer)));
   std::unique_ptr<ByteRleDecoder> rle = createBooleanDecoder(std::move(stream));
   std::vector<char> data(72);
   std::vector<uint64_t> nulls(bits::nwords(data.size()), bits::kNotNull64);
@@ -1089,7 +1089,7 @@ TEST(BooleanRle, skipTest) {
       0x71, 0xc7, 0x1c, 0x71, 0xc7, 0x1c, 0x71, 0xc7, 0x1c, 0x71, 0xc7, 0x1c,
       0x71, 0xc7, 0x1c, 0x71};
   std::unique_ptr<SeekableInputStream> stream(
-      new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer)));
+      new SeekableArrayInputStream(buffer, std::size(buffer)));
   std::unique_ptr<ByteRleDecoder> rle = createBooleanDecoder(std::move(stream));
   std::vector<char> data(1);
   for (size_t i = 0; i < 16384; i += 5) {
@@ -1200,7 +1200,7 @@ TEST(BooleanRle, skipTestWithNulls) {
       0x71, 0xc7, 0x1c, 0x71, 0xc7, 0x1c, 0x71, 0xc7, 0x1c, 0x71, 0xc7, 0x1c,
       0x71, 0xc7, 0x1c, 0x71};
   std::unique_ptr<SeekableInputStream> stream(
-      new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer)));
+      new SeekableArrayInputStream(buffer, std::size(buffer)));
   std::unique_ptr<ByteRleDecoder> rle = createBooleanDecoder(std::move(stream));
   raw_vector<char> data;
   data.resize(3);
@@ -1365,7 +1365,7 @@ TEST(BooleanRle, seekTest) {
       0x71, 0xc7, 0x1c, 0x71, 0xc7, 0x1c, 0x71, 0xc7, 0x1c, 0x71, 0xc7, 0x1c,
       0x71, 0xc7, 0x1c, 0x71};
   std::unique_ptr<SeekableInputStream> stream(
-      new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer)));
+      new SeekableArrayInputStream(buffer, std::size(buffer)));
   std::unique_ptr<ByteRleDecoder> rle = createBooleanDecoder(std::move(stream));
 
   // Read all 16384 values and validate them.
@@ -1501,7 +1501,7 @@ TEST(BooleanRle, seekTestWithNulls) {
       0x71, 0xc7, 0x1c, 0x71, 0xc7, 0x1c, 0x71, 0xc7, 0x1c, 0x71, 0xc7, 0x1c,
       0x71, 0xc7, 0x1c, 0x71, 0xc7, 0x1c, 0x71, 0xc7, 0x1c, 0x71, 0xc7, 0x1c,
       0x71, 0xc7, 0x1c, 0x71};
-  auto* stream = new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer));
+  auto* stream = new SeekableArrayInputStream(buffer, std::size(buffer));
   auto rle = createBooleanDecoder(std::unique_ptr<SeekableInputStream>(stream));
   ASSERT_EQ(stream->totalRead(), 0);
   auto lastTotalReadBytes = stream->totalRead();
@@ -1519,7 +1519,7 @@ TEST(BooleanRle, seekTestWithNulls) {
     EXPECT_EQ(0, bits::isBitSet(data.data(), i)) << "Output wrong at " << i;
   }
   rle->next(data.data(), data.size(), noNull.data());
-  ASSERT_EQ(getNumReadBytes(), VELOX_ARRAY_SIZE(buffer));
+  ASSERT_EQ(getNumReadBytes(), std::size(buffer));
   for (size_t i = 0; i < data.size(); ++i) {
     EXPECT_EQ(i < 8192 ? i & 1 : (i / 3) & 1, bits::isBitSet(data.data(), i))
         << "Output wrong at " << i;
@@ -1573,7 +1573,7 @@ TEST(BooleanRle, seekBoolAndByteRLE) {
       0xf9, 0xf0, 0xf0, 0xf7, 0x1c, 0x71, 0xc1, 0x80};
 
   std::unique_ptr<SeekableInputStream> stream(
-      new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer)));
+      new SeekableArrayInputStream(buffer, std::size(buffer)));
   std::unique_ptr<ByteRleDecoder> rle = createBooleanDecoder(std::move(stream));
   std::vector<char> data(sizeof(num) / sizeof(char));
   rle->next(data.data(), data.size(), nullptr);
@@ -1596,7 +1596,7 @@ TEST(BooleanRle, seekBoolAndByteRLE) {
 TEST(BooleanRle, skipToEnd) {
   const unsigned char buffer[] = {0xfe, 0xff, 0xff};
   std::unique_ptr<SeekableInputStream> stream(
-      new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer)));
+      new SeekableArrayInputStream(buffer, std::size(buffer)));
   std::unique_ptr<ByteRleDecoder> rle = createBooleanDecoder(std::move(stream));
   char value[1];
   rle->next(value, 1, nullptr);
diff --git a/velox/dwio/dwrf/test/TestColumnReader.cpp b/velox/dwio/dwrf/test/TestColumnReader.cpp
index da7b9f743f6..1ead2ca74b1 100644
--- a/velox/dwio/dwrf/test/TestColumnReader.cpp
+++ b/velox/dwio/dwrf/test/TestColumnReader.cpp
@@ -27,6 +27,7 @@
 #include "velox/vector/ComplexVector.h"
 #include "velox/vector/DictionaryVector.h"
 #include "velox/vector/FlatVector.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
 
 #include <folly/Random.h>
 #include <folly/String.h>
@@ -311,6 +312,10 @@ struct ReaderTestParams {
   }
 };
 
+inline void PrintTo(const ReaderTestParams& param, std::ostream* os) {
+  *os << param.toString();
+}
+
 class TestColumnReader : public testing::TestWithParam<ReaderTestParams>,
                          public ColumnReaderTestBase {
  protected:
@@ -356,6 +361,55 @@ class TestColumnReader : public testing::TestWithParam<ReaderTestParams>,
   bool parallelDecoding() const override {
     return parallelDecoding_;
   }
+
+  // Helper for SelectiveDecimalColumnReader tests that exercise schema
+  // mismatch between the file footer (e.g. Hive ORC's DECIMAL(38, 18))
+  // and the requested table-schema type.
+  template <typename DataT, size_t kDataSize, size_t kScaleSize>
+  void verifyDecimalRequestedType(
+      const unsigned char (&dataBuffer)[kDataSize],
+      const unsigned char (&scaleBuffer)[kScaleSize],
+      const TypePtr& fileType,
+      const TypePtr& requestedType,
+      const std::vector<DataT>& expectedValues) {
+    auto fileRowType = ROW("col_0", fileType);
+    auto requestedRowType = ROW("col_0", requestedType);
+    proto::ColumnEncoding directEncoding;
+    directEncoding.set_kind(proto::ColumnEncoding_Kind_DIRECT);
+    EXPECT_CALL(streams_, getEncodingProxy(_))
+        .WillRepeatedly(Return(&directEncoding));
+
+    EXPECT_CALL(
+        streams_, getStreamProxy(_, proto::Stream_Kind_ROW_INDEX, false))
+        .WillRepeatedly(Return(nullptr));
+    EXPECT_CALL(streams_, getStreamProxy(_, proto::Stream_Kind_PRESENT, false))
+        .WillRepeatedly(Return(nullptr));
+
+    EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
+        .WillRepeatedly(
+            Return(new SeekableArrayInputStream(dataBuffer, kDataSize)));
+    EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_NANO_DATA, true))
+        .WillRepeatedly(
+            Return(new SeekableArrayInputStream(scaleBuffer, kScaleSize)));
+
+    auto scanSpec = std::make_unique<common::ScanSpec>("root");
+    buildReader(requestedRowType, fileRowType, {}, scanSpec.get());
+    VectorPtr batch = newBatch(requestedRowType);
+    skipAndRead(batch, /*readSize=*/expectedValues.size());
+
+    auto actual = getOnlyChild<FlatVector<DataT>>(batch);
+    ASSERT_EQ(expectedValues.size(), batch->size());
+    ASSERT_EQ(0, getNullCount(batch));
+    ASSERT_EQ(0, getNullCount(actual));
+
+    auto* pool = &streams_.getMemoryPool();
+    auto expected = BaseVector::create<FlatVector<DataT>>(
+        requestedType, expectedValues.size(), pool);
+    for (vector_size_t i = 0; i < expectedValues.size(); ++i) {
+      expected->set(i, expectedValues[i]);
+    }
+    facebook::velox::test::assertEqualVectors(expected, actual);
+  }
 };
 
 struct NonSelectiveReaderTestParams {
@@ -370,6 +424,12 @@ struct NonSelectiveReaderTestParams {
   }
 };
 
+inline void PrintTo(
+    const NonSelectiveReaderTestParams& param,
+    std::ostream* os) {
+  *os << param.toString();
+}
+
 // For test cases where SelectiveColumnReader does not have support.
 class TestNonSelectiveColumnReader
     : public testing::TestWithParam<NonSelectiveReaderTestParams>,
@@ -423,6 +483,10 @@ struct SchemaMismatchTestParam {
   }
 };
 
+inline void PrintTo(const SchemaMismatchTestParam& param, std::ostream* os) {
+  *os << param.toString();
+}
+
 class SchemaMismatchTest : public TestWithParam<SchemaMismatchTestParam>,
                            public ColumnReaderTestBase {
  protected:
@@ -517,14 +581,14 @@ TEST_P(TestColumnReader, testBooleanWithNulls) {
   // alternate 4 non-null and 4 null via [0xf0 for x in range(512 / 8)]
   const unsigned char buffer1[] = {0x3d, 0xf0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // [0x0f for x in range(256 / 8)]
   const unsigned char buffer2[] = {0x1d, 0x0f};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:boolean>");
@@ -628,13 +692,13 @@ TEST_P(TestColumnReader, testBooleanSkipsWithNulls) {
   // alternate 4 non-null and 4 null via [0xf0 for x in range(512 / 8)]
   const unsigned char buffer1[] = {0x3d, 0xf0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
   // [0x0f for x in range(128 / 8)]
   const unsigned char buffer2[] = {0x1d, 0x0f};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:boolean>");
@@ -683,8 +747,8 @@ TEST_P(TestColumnReader, testByteWithNulls) {
   // alternate 4 non-null and 4 null via [0xf0 for x in range(512 / 8)]
   const unsigned char buffer1[] = {0x3d, 0xf0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // range(256)
   char buffer[258];
@@ -697,8 +761,8 @@ TEST_P(TestColumnReader, testByteWithNulls) {
     buffer[i + 2] = static_cast<char>(i);
   }
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer, std::size(buffer))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:tinyint>");
@@ -778,8 +842,8 @@ TEST_P(TestColumnReader, testByteSkipsWithNulls) {
   // alternate 4 non-null and 4 null via [0xf0 for x in range(512 / 8)]
   const unsigned char buffer1[] = {0x3d, 0xf0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // range(256)
   char buffer[258];
@@ -792,8 +856,8 @@ TEST_P(TestColumnReader, testByteSkipsWithNulls) {
     buffer[i + 2] = static_cast<char>(i);
   }
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer, std::size(buffer))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:tinyint>");
@@ -856,7 +920,7 @@ TEST_P(TestColumnReader, testIntegerRLEv2) {
   int32_t expects_col0[] = {2110, 2120, 2130, 2140};
   int32_t expects_col1[] = {11, 12, 13, 14};
   int32_t expects_col2[] = {32, 34, 36, 38};
-  int32_t size = VELOX_ARRAY_SIZE(col0);
+  int32_t size = std::size(col0);
 
   // set format
   streams_.setFormat(DwrfFormat::kOrc);
@@ -884,8 +948,8 @@ TEST_P(TestColumnReader, testIntegerRLEv2) {
   // col_0's DATA stream
   EXPECT_CALL(
       streams_, getStreamOrcProxy(1, proto::orc::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer0, VELOX_ARRAY_SIZE(buffer0))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer0, std::size(buffer0))));
   // col_1's DATA stream
   std::array<char, 1024> data;
   std::vector<int64_t> v;
@@ -903,8 +967,8 @@ TEST_P(TestColumnReader, testIntegerRLEv2) {
   // col_2's DATA stream
   EXPECT_CALL(
       streams_, getStreamOrcProxy(3, proto::orc::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType =
@@ -929,7 +993,7 @@ TEST_P(TestColumnReader, testIntegerRLEv2) {
     auto colBatch = getChild<FlatVector<int32_t>>(batch, 0);
     auto colBatch2 = getChild<FlatVector<int32_t>>(batch, 1);
     auto colBatch3 = getChild<FlatVector<int32_t>>(batch, 2);
-    ASSERT_EQ(VELOX_ARRAY_SIZE(expects_col0), colBatch->size());
+    ASSERT_EQ(std::size(expects_col0), colBatch->size());
     ASSERT_EQ(colBatch->size(), colBatch2->size());
     ASSERT_EQ(colBatch2->size(), colBatch3->size());
     for (size_t i = 0; i < batch->size(); ++i) {
@@ -972,8 +1036,8 @@ TEST_P(TestColumnReader, testIntegerWithNulls) {
       .WillRepeatedly(Return(nullptr));
   const unsigned char buffer1[] = {0x16, 0xf0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   char buffer2[1024];
   size_t size = writeRange(buffer2, 0, 100);
@@ -1091,8 +1155,8 @@ TEST_P(TestColumnReader, testIntDictSkipWithNulls) {
       .WillRepeatedly(Return(nullptr));
   const unsigned char buffer1[] = {0x16, 0xaa};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // even row points to dictionary.
   char buffer2[1024];
@@ -1108,8 +1172,8 @@ TEST_P(TestColumnReader, testIntDictSkipWithNulls) {
   const unsigned char buffer3[] = {0x0a, 0xaa};
   EXPECT_CALL(
       streams_, getStreamProxy(1, proto::Stream_Kind_IN_DICTIONARY, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer3, VELOX_ARRAY_SIZE(buffer3))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer3, std::size(buffer3))));
 
   EXPECT_CALL(streams_, genMockDictDataSetter(1, 0))
       .WillRepeatedly(Return([&](BufferPtr& buffer, MemoryPool* pool) {
@@ -1249,21 +1313,21 @@ TEST_P(StringReaderTests, testDictionaryWithNulls) {
       .WillRepeatedly(Return(nullptr));
   const unsigned char buffer1[] = {0x19, 0xf0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
   const unsigned char buffer2[] = {0x2f, 0x00, 0x00, 0x2f, 0x00, 0x01};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
   const unsigned char buffer3[] = {0x4f, 0x52, 0x43, 0x4f, 0x77, 0x65, 0x6e};
   EXPECT_CALL(
       streams_, getStreamProxy(1, proto::Stream_Kind_DICTIONARY_DATA, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer3, VELOX_ARRAY_SIZE(buffer3))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer3, std::size(buffer3))));
   const unsigned char buffer4[] = {0x02, 0x01, 0x03};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer4, VELOX_ARRAY_SIZE(buffer4))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer4, std::size(buffer4))));
 
   TestStrideIndexProvider provider(10000);
   EXPECT_CALL(streams_, getStrideIndexProviderProxy())
@@ -1395,8 +1459,8 @@ TEST_P(StringReaderTests, testStringDictSkipNoNulls) {
   const unsigned char inDict[] = {0x0a, 0xaa};
   EXPECT_CALL(
       streams_, getStreamProxy(1, proto::Stream_Kind_IN_DICTIONARY, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(inDict, VELOX_ARRAY_SIZE(inDict))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(inDict, std::size(inDict))));
 
   auto indexData = index.SerializePartialAsString();
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_ROW_INDEX, _))
@@ -1484,8 +1548,8 @@ TEST_P(StringReaderTests, testStringDictSkipWithNulls) {
       .WillRepeatedly(Return(nullptr));
   const unsigned char present[] = {0x16, 0xaa};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(present, VELOX_ARRAY_SIZE(present))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(present, std::size(present))));
 
   char data[1024];
   data[0] = 0x9c;
@@ -1565,8 +1629,8 @@ TEST_P(StringReaderTests, testStringDictSkipWithNulls) {
   const unsigned char inDict[] = {0x0a, 0xaa};
   EXPECT_CALL(
       streams_, getStreamProxy(1, proto::Stream_Kind_IN_DICTIONARY, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(inDict, VELOX_ARRAY_SIZE(inDict))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(inDict, std::size(inDict))));
 
   auto indexData = index.SerializePartialAsString();
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_ROW_INDEX, _))
@@ -1637,18 +1701,18 @@ TEST_P(TestNonSelectiveColumnReader, testSubstructsWithNulls) {
 
   const unsigned char buffer1[] = {0x16, 0x0f};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   const unsigned char buffer2[] = {0x0a, 0x55};
   EXPECT_CALL(streams_, getStreamProxy(2, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   const unsigned char buffer3[] = {0x04, 0xf0};
   EXPECT_CALL(streams_, getStreamProxy(3, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer3, VELOX_ARRAY_SIZE(buffer3))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer3, std::size(buffer3))));
 
   char buffer4[256];
   size_t size = writeRange(buffer4, 0, 26);
@@ -1723,13 +1787,13 @@ TEST_P(TestColumnReader, testSkipWithNulls) {
   const unsigned char buffer1[] = {
       0x03, 0x00, 0xff, 0x3f, 0x08, 0xff, 0xff, 0xfc, 0x03, 0x00};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
   EXPECT_CALL(streams_, getStreamProxy(2, _, _))
       .WillRepeatedly(Return(nullptr));
   EXPECT_CALL(streams_, getStreamProxy(2, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   TestStrideIndexProvider provider(10000);
   EXPECT_CALL(streams_, getStrideIndexProviderProxy())
@@ -1741,8 +1805,8 @@ TEST_P(TestColumnReader, testSkipWithNulls) {
       .WillRepeatedly(Return(new SeekableArrayInputStream(buffer2, size)));
   const unsigned char buffer3[] = {0x61, 0x01, 0x00};
   EXPECT_CALL(streams_, getStreamProxy(2, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer3, VELOX_ARRAY_SIZE(buffer3))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer3, std::size(buffer3))));
 
   // fill the dictionary with '00' to '99'
   char digits[200];
@@ -1754,12 +1818,12 @@ TEST_P(TestColumnReader, testSkipWithNulls) {
   }
   EXPECT_CALL(
       streams_, getStreamProxy(2, proto::Stream_Kind_DICTIONARY_DATA, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(digits, VELOX_ARRAY_SIZE(digits))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(digits, std::size(digits))));
   const unsigned char buffer4[] = {0x61, 0x00, 0x02};
   EXPECT_CALL(streams_, getStreamProxy(2, proto::Stream_Kind_LENGTH, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer4, VELOX_ARRAY_SIZE(buffer4))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer4, std::size(buffer4))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<myInt:int,myString:string>");
@@ -1838,12 +1902,12 @@ TEST_P(StringReaderTests, testBinaryDirect) {
   }
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
       .WillRepeatedly(
-          Return(new SeekableArrayInputStream(blob, VELOX_ARRAY_SIZE(blob))));
+          Return(new SeekableArrayInputStream(blob, std::size(blob))));
 
   const unsigned char buffer[] = {0x61, 0x00, 0x02};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer, std::size(buffer))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:binary>");
@@ -1892,8 +1956,8 @@ TEST_P(StringReaderTests, testBinaryDirectWithNulls) {
 
   const unsigned char buffer1[] = {0x1d, 0xf0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   char blob[256];
   for (size_t i = 0; i < 8; ++i) {
@@ -1904,12 +1968,12 @@ TEST_P(StringReaderTests, testBinaryDirectWithNulls) {
   }
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
       .WillRepeatedly(
-          Return(new SeekableArrayInputStream(blob, VELOX_ARRAY_SIZE(blob))));
+          Return(new SeekableArrayInputStream(blob, std::size(blob))));
 
   const unsigned char buffer2[] = {0x7d, 0x00, 0x02};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:binary>");
@@ -1969,12 +2033,12 @@ TEST_P(TestColumnReader, testShortBlobError) {
   char blob[100];
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
       .WillRepeatedly(
-          Return(new SeekableArrayInputStream(blob, VELOX_ARRAY_SIZE(blob))));
+          Return(new SeekableArrayInputStream(blob, std::size(blob))));
 
   const unsigned char buffer1[] = {0x61, 0x00, 0x02};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:string>");
@@ -2020,13 +2084,13 @@ TEST_P(StringReaderTests, testStringDirectShortBuffer) {
     }
   }
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(blob, VELOX_ARRAY_SIZE(blob), 3)));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(blob, std::size(blob), 3)));
 
   const unsigned char buffer1[] = {0x61, 0x00, 0x02};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:string>");
@@ -2075,8 +2139,8 @@ TEST_P(StringReaderTests, testStringDirectShortBufferWithNulls) {
 
   const unsigned char buffer1[] = {0x3d, 0xf0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   char blob[512];
   for (size_t i = 0; i < 16; ++i) {
@@ -2086,13 +2150,13 @@ TEST_P(StringReaderTests, testStringDirectShortBufferWithNulls) {
     }
   }
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(blob, VELOX_ARRAY_SIZE(blob), 30)));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(blob, std::size(blob), 30)));
 
   const unsigned char buffer2[] = {0x7d, 0x00, 0x02, 0x7d, 0x00, 0x02};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:string>");
@@ -2154,19 +2218,19 @@ TEST_P(StringReaderTests, testStringDirectNullAcrossWindow) {
 
   const unsigned char isNull[2] = {0xff, 0x7f};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(isNull, VELOX_ARRAY_SIZE(isNull))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(isNull, std::size(isNull))));
 
   const char blob[] = "abcdefg";
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(blob, VELOX_ARRAY_SIZE(blob), 4)));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(blob, std::size(blob), 4)));
 
   // [1] * 7
   const unsigned char lenData[] = {0x04, 0x00, 0x01};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(lenData, VELOX_ARRAY_SIZE(lenData))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(lenData, std::size(lenData))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:string>");
@@ -2250,8 +2314,8 @@ TEST_P(StringReaderTests, testStringDirectSkip) {
       0x01, 0x8a, 0x05, 0x7f, 0x01, 0x8c, 0x06, 0x7f, 0x01, 0x8e,
       0x07, 0x7f, 0x01, 0x90, 0x08, 0x1b, 0x01, 0x92, 0x09};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:string>");
@@ -2298,8 +2362,8 @@ TEST_P(StringReaderTests, testStringDirectSkipWithNulls) {
   // alternate 4 non-null and 4 null via [0xf0 for x in range(2400 / 8)]
   const unsigned char buffer1[] = {0x7f, 0xf0, 0x7f, 0xf0, 0x25, 0xf0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // sum(range(1200))
   const size_t BLOB_SIZE = 719400;
@@ -2323,8 +2387,8 @@ TEST_P(StringReaderTests, testStringDirectSkipWithNulls) {
       0x01, 0x8a, 0x05, 0x7f, 0x01, 0x8c, 0x06, 0x7f, 0x01, 0x8e,
       0x07, 0x7f, 0x01, 0x90, 0x08, 0x1b, 0x01, 0x92, 0x09};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:string>");
@@ -2386,8 +2450,8 @@ TEST_P(TestColumnReader, testList) {
       0x00,
       0x02};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // range(1200)
   char buffer2[8192];
@@ -2435,8 +2499,8 @@ TEST_P(TestNonSelectiveColumnReader, testListPropagateNulls) {
   // set getStream
   const unsigned char buffer[] = {0xff, 0x00};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer, std::size(buffer))));
 
   EXPECT_CALL(streams_, getStreamProxy(2, proto::Stream_Kind_LENGTH, true))
       .WillRepeatedly(Return(new SeekableArrayInputStream(buffer, 0)));
@@ -2477,8 +2541,8 @@ TEST_P(TestNonSelectiveColumnReader, testListWithNulls) {
   // [0xaa for x in range(2048/8)]
   const unsigned char buffer1[] = {0x7f, 0xaa, 0x7b, 0xaa};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   EXPECT_CALL(streams_, getStreamProxy(2, proto::Stream_Kind_PRESENT, false))
       .WillRepeatedly(Return(nullptr));
@@ -2493,8 +2557,8 @@ TEST_P(TestNonSelectiveColumnReader, testListWithNulls) {
                                    0x00, 0x7f, 0x00, 0x00, 0x7f, 0x00, 0x03,
                                    0x6e, 0x00, 0x03, 0xff, 0x13};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // range(2048)
   char buffer3[8192];
@@ -2636,8 +2700,8 @@ TEST_P(TestNonSelectiveColumnReader, testListSkipWithNulls) {
   // [0xaa for x in range(2048/8)]
   const unsigned char buffer1[] = {0x7f, 0xaa, 0x7b, 0xaa};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   EXPECT_CALL(streams_, getStreamProxy(2, proto::Stream_Kind_PRESENT, false))
       .WillRepeatedly(Return(nullptr));
@@ -2652,8 +2716,8 @@ TEST_P(TestNonSelectiveColumnReader, testListSkipWithNulls) {
                                    0x00, 0x7f, 0x00, 0x00, 0x7f, 0x00, 0x03,
                                    0x6e, 0x00, 0x03, 0xff, 0x13};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // range(2048)
   char buffer3[8192];
@@ -2737,8 +2801,8 @@ TEST_P(TestNonSelectiveColumnReader, testListSkipWithNullsNoData) {
   // [0xaa for x in range(2048/8)]
   const unsigned char buffer1[] = {0x7f, 0xaa, 0x7b, 0xaa};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   EXPECT_CALL(streams_, getStreamProxy(2, proto::Stream_Kind_PRESENT, false))
       .WillRepeatedly(Return(nullptr));
@@ -2753,8 +2817,8 @@ TEST_P(TestNonSelectiveColumnReader, testListSkipWithNullsNoData) {
                                    0x00, 0x7f, 0x00, 0x00, 0x7f, 0x00, 0x03,
                                    0x6e, 0x00, 0x03, 0xff, 0x13};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   EXPECT_CALL(streams_, getStreamProxy(2, proto::Stream_Kind_DATA, true))
       .WillRepeatedly(Return(nullptr));
@@ -2815,8 +2879,8 @@ TEST_P(TestNonSelectiveColumnReader, testListWithAllNulls) {
   // set getStream
   const unsigned char buffer[] = {0xff, 0x00};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer, std::size(buffer))));
 
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
       .WillRepeatedly(Return(new SeekableArrayInputStream(buffer, 0)));
@@ -2869,8 +2933,8 @@ TEST_P(TestColumnReader, testMap) {
       0x00,
       0x02};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // range(1200)
   char buffer2[8192];
@@ -2926,8 +2990,8 @@ TEST_P(TestNonSelectiveColumnReader, testMapWithNulls) {
   // [0xaa for x in range(2048/8)]
   const unsigned char buffer1[] = {0x7f, 0xaa, 0x7b, 0xaa};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   EXPECT_CALL(streams_, getStreamProxy(2, proto::Stream_Kind_PRESENT, false))
       .WillRepeatedly(Return(nullptr));
@@ -2935,8 +2999,8 @@ TEST_P(TestNonSelectiveColumnReader, testMapWithNulls) {
   // [0x55 for x in range(2048/8)]
   const unsigned char buffer2[] = {0x7f, 0x55, 0x7b, 0x55};
   EXPECT_CALL(streams_, getStreamProxy(3, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // [1 for x in range(260)] +
   // [4 for x in range(260)] +
@@ -2948,8 +3012,8 @@ TEST_P(TestNonSelectiveColumnReader, testMapWithNulls) {
                                    0x00, 0x7f, 0x00, 0x00, 0x7f, 0x00, 0x03,
                                    0x6e, 0x00, 0x03, 0xff, 0x13};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer3, VELOX_ARRAY_SIZE(buffer3))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer3, std::size(buffer3))));
 
   // range(2048)
   char buffer4[8192];
@@ -3131,8 +3195,8 @@ TEST_P(TestNonSelectiveColumnReader, testMapSkipWithNulls) {
   // [0xaa for x in range(2048/8)]
   const unsigned char buffer1[] = {0x7f, 0xaa, 0x7b, 0xaa};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // [1 for x in range(260)] +
   // [4 for x in range(260)] +
@@ -3144,8 +3208,8 @@ TEST_P(TestNonSelectiveColumnReader, testMapSkipWithNulls) {
                                    0x00, 0x7f, 0x00, 0x00, 0x7f, 0x00, 0x03,
                                    0x6e, 0x00, 0x03, 0xff, 0x13};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // range(2048)
   char buffer3[8192];
@@ -3254,8 +3318,8 @@ TEST_P(TestNonSelectiveColumnReader, testMapSkipWithNullsNoData) {
   // [0xaa for x in range(2048/8)]
   const unsigned char buffer1[] = {0x7f, 0xaa, 0x7b, 0xaa};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // [1 for x in range(260)] +
   // [4 for x in range(260)] +
@@ -3267,8 +3331,8 @@ TEST_P(TestNonSelectiveColumnReader, testMapSkipWithNullsNoData) {
                                    0x00, 0x7f, 0x00, 0x00, 0x7f, 0x00, 0x03,
                                    0x6e, 0x00, 0x03, 0xff, 0x13};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:map<bigint,bigint>>");
@@ -3322,8 +3386,8 @@ TEST_P(TestNonSelectiveColumnReader, testMapWithAllNulls) {
 
   const unsigned char buffer1[] = {0xff, 0x00};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
       .WillRepeatedly(Return(new SeekableArrayInputStream(buffer1, 0)));
@@ -3365,9 +3429,7 @@ TEST_P(TestColumnReader, testFloatBatchNotAligned) {
 
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
       .WillRepeatedly(Return(new SeekableArrayInputStream(
-          byteValues,
-          VELOX_ARRAY_SIZE(byteValues),
-          VELOX_ARRAY_SIZE(byteValues) / 2)));
+          byteValues, std::size(byteValues), std::size(byteValues) / 2)));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<myFloat:float>");
@@ -3403,8 +3465,8 @@ TEST_P(TestColumnReader, testFloatWithNulls) {
   // 13 non-nulls followed by 19 nulls
   const unsigned char buffer1[] = {0xfc, 0xff, 0xf8, 0x0, 0x0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   const float test_vals[] = {
       1.0f,
@@ -3427,8 +3489,8 @@ TEST_P(TestColumnReader, testFloatWithNulls) {
       0x0,  0x80, 0xff, 0xff, 0xff, 0x7f, 0x7f, 0xff, 0xff, 0x7f, 0xff,
       0x1,  0x0,  0x0,  0x0,  0x1,  0x0,  0x0,  0x80};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<myFloat:float>");
@@ -3472,8 +3534,8 @@ TEST_P(TestColumnReader, testFloatSkipWithNulls) {
   // 2 non-nulls, 2 nulls, 2 non-nulls, 2 nulls
   const unsigned char buffer1[] = {0xff, 0xcc};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // 1, 2.5, -100.125, 10000
   const unsigned char buffer2[] = {
@@ -3494,8 +3556,8 @@ TEST_P(TestColumnReader, testFloatSkipWithNulls) {
       0x1c,
       0x46};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<myFloat:float>");
@@ -3563,8 +3625,8 @@ TEST_P(TestColumnReader, testDoubleWithNulls) {
   // 13 non-nulls followed by 19 nulls
   const unsigned char buffer1[] = {0xfc, 0xff, 0xf8, 0x0, 0x0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   const double test_vals[] = {
       1.0,
@@ -3591,8 +3653,8 @@ TEST_P(TestColumnReader, testDoubleWithNulls) {
       0xff, 0xff, 0xef, 0xff, 0x1,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,
       0x1,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x80};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<myDouble:double>");
@@ -3637,16 +3699,16 @@ TEST_P(TestColumnReader, testDoubleSkipWithNulls) {
   // 1 non-null, 5 nulls, 2 non-nulls
   const unsigned char buffer1[] = {0xff, 0x83};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // 1, 2, -2
   const unsigned char buffer2[] = {
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f, 0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<myDouble:double>");
@@ -3713,8 +3775,8 @@ TEST_P(TestColumnReader, testTimestampSkipWithNulls) {
   // 2 non-nulls, 2 nulls, 2 non-nulls, 2 nulls
   const unsigned char buffer1[] = {0xff, 0xcc};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   const unsigned char buffer2[] = {
       0xfc,
@@ -3735,13 +3797,13 @@ TEST_P(TestColumnReader, testTimestampSkipWithNulls) {
       0xd4,
       0x30};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   const unsigned char buffer3[] = {0x1, 0x8, 0x5e};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_NANO_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer3, VELOX_ARRAY_SIZE(buffer3))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer3, std::size(buffer3))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<myTimestamp:timestamp>");
@@ -3831,15 +3893,15 @@ TEST_P(TestColumnReader, testTimestamp) {
       0xba, 0xa0, 0x1a, 0x9d, 0x88, 0xa6, 0x82, 0x1a, 0x9d, 0xba, 0x9c,
       0xe4, 0x19, 0x9d, 0xee, 0xe1, 0xcd, 0x18};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   const unsigned char buffer2[] = {
       0xf6, 0x00, 0xa8, 0xd1, 0xf9, 0xd6, 0x03, 0x00, 0x9e, 0x01, 0xec,
       0x76, 0xf4, 0x76, 0xfc, 0x76, 0x84, 0x77, 0x8c, 0x77, 0xfd, 0x0b};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_NANO_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<myTimestamp:timestamp>");
@@ -3909,13 +3971,13 @@ TEST_P(TestColumnReader, testDecimal64) {
     }
   }
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(new SeekableArrayInputStream(
-          numBuffer, VELOX_ARRAY_SIZE(numBuffer), 3)));
+      .WillRepeatedly(Return(
+          new SeekableArrayInputStream(numBuffer, std::size(numBuffer), 3)));
   // col_0's Secondary Stream
   const unsigned char buffer2[] = {0x3e, 0x00, 0x04}; // [0x02] * 65
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_NANO_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col_0:decimal(12, 2)>");
@@ -3948,19 +4010,19 @@ TEST_P(TestColumnReader, testDecimal64WithSkip) {
   const unsigned char presentBuffer[] = {0xfe, 0xff, 0x80}; // [0xff]
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
       .WillRepeatedly(Return(new SeekableArrayInputStream(
-          presentBuffer, VELOX_ARRAY_SIZE(presentBuffer))));
+          presentBuffer, std::size(presentBuffer))));
   const unsigned char numBuffer[] = {
       0xf8, 0xe8, 0xe2, 0xcf, 0xf4, 0xcb, 0xb6, 0xda, 0x0d, 0x86, 0xc1, 0xcc,
       0xcd, 0x9e, 0xd5, 0xc5, 0x11, 0xb4, 0xf6, 0xfc, 0xf3, 0xb9, 0xba, 0x16,
       0xca, 0xe7, 0xa3, 0xa6, 0xdf, 0x1c, 0xea, 0xad, 0xc0, 0xe5, 0x24, 0xf8,
       0x94, 0x8c, 0x2f, 0x86, 0xa4, 0x3c, 0x94, 0x4d, 0x62};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(new SeekableArrayInputStream(
-          numBuffer, VELOX_ARRAY_SIZE(numBuffer))));
+      .WillRepeatedly(Return(
+          new SeekableArrayInputStream(numBuffer, std::size(numBuffer))));
   const unsigned char buffer1[] = {0x06, 0x00, 0x14}; // [0x0a] * 9
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_NANO_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col_0:decimal(12, 10)>");
@@ -4004,7 +4066,7 @@ TEST_P(TestColumnReader, testDecimal128WithSkip) {
   const unsigned char presentBuffer[] = {0xfe, 0xff, 0xf8};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
       .WillRepeatedly(Return(new SeekableArrayInputStream(
-          presentBuffer, VELOX_ARRAY_SIZE(presentBuffer))));
+          presentBuffer, std::size(presentBuffer))));
   const unsigned char numBuffer[] = {
       0xf8, 0xe8, 0xe2, 0xcf, 0xf4, 0xcb, 0xb6, 0xda, 0x0d, 0x86, 0xc1, 0xcc,
       0xcd, 0x9e, 0xd5, 0xc5, 0x11, 0xb4, 0xf6, 0xfc, 0xf3, 0xb9, 0xba, 0x16,
@@ -4018,12 +4080,12 @@ TEST_P(TestColumnReader, testDecimal128WithSkip) {
       0x93, 0xe8, 0xa3, 0xec, 0xd0, 0x96, 0xd4, 0xcc, 0xf6, 0xac, 0x02,
   };
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(new SeekableArrayInputStream(
-          numBuffer, VELOX_ARRAY_SIZE(numBuffer))));
+      .WillRepeatedly(Return(
+          new SeekableArrayInputStream(numBuffer, std::size(numBuffer))));
   const unsigned char buffer1[] = {0x0a, 0x00, 0x4a}; // [0x02] * 13
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_NANO_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col_0:decimal(38, 37)>");
@@ -4065,6 +4127,71 @@ TEST_P(TestColumnReader, testDecimal128WithSkip) {
       DecimalUtil::toString(intBatch->valueAt(4), decimalType));
 }
 
+// Verify that when the file type doesn't match the metastore type,
+// the metastore type wins and data is rescaled accordingly.
+
+// Integer column (per-row scale=0) stored in an ORC file whose footer
+// declares DECIMAL(38, 18), but the metastore says DECIMAL(20, 0). The
+// reader must produce the original integer values without rescaling.
+TEST_P(TestColumnReader, longDecimalRequestedTypeScaleZero) {
+  const unsigned char dataBuffer[] = {0x02, 0x04, 0x06, 0x08};
+  const unsigned char scaleBuffer[] = {0x01, 0x00, 0x00};
+  verifyDecimalRequestedType<int128_t>(
+      dataBuffer, scaleBuffer, DECIMAL(38, 18), DECIMAL(20, 0), {1, 2, 3, 4});
+}
+
+// Per-row scale (5) already matches the requestedType scale (5); no
+// rescaling expected.
+TEST_P(TestColumnReader, longDecimalRequestedTypeScaleMatchesData) {
+  const unsigned char dataBuffer[] = {0x02, 0x04, 0x06, 0x08};
+  const unsigned char scaleBuffer[] = {0x01, 0x00, 0x0A};
+  verifyDecimalRequestedType<int128_t>(
+      dataBuffer, scaleBuffer, DECIMAL(38, 18), DECIMAL(25, 5), {1, 2, 3, 4});
+}
+
+// Per-row scale (3) is lower than the requestedType scale (5). The reader
+// must upscale by multiplying by 10^(5-3) = 100.
+TEST_P(TestColumnReader, longDecimalRequestedTypeUpscale) {
+  const unsigned char dataBuffer[] = {0x02, 0x04, 0x06, 0x08};
+  const unsigned char scaleBuffer[] = {0x01, 0x00, 0x06};
+  verifyDecimalRequestedType<int128_t>(
+      dataBuffer,
+      scaleBuffer,
+      DECIMAL(38, 18),
+      DECIMAL(25, 5),
+      {100, 200, 300, 400});
+}
+
+// Short decimal (BIGINT, precision<=18). File declares DECIMAL(12, 5),
+// metastore says DECIMAL(10, 2). Reader must downscale by 10^(5-2)=1000.
+TEST_P(TestColumnReader, shortDecimalRequestedTypeDownscale) {
+  const unsigned char dataBuffer[] = {
+      0xD0, 0x0F, 0xA0, 0x1F, 0xF0, 0x2E, 0xC0, 0x3E};
+  const unsigned char scaleBuffer[] = {0x01, 0x00, 0x0A};
+  verifyDecimalRequestedType<int64_t>(
+      dataBuffer, scaleBuffer, DECIMAL(12, 5), DECIMAL(10, 2), {1, 2, 3, 4});
+}
+
+TEST_P(TestColumnReader, decimalRequestedTypeNonDecimalRejected) {
+  proto::ColumnEncoding directEncoding;
+  directEncoding.set_kind(proto::ColumnEncoding_Kind_DIRECT);
+  EXPECT_CALL(streams_, getEncodingProxy(_))
+      .WillRepeatedly(Return(&directEncoding));
+  EXPECT_CALL(streams_, getStreamProxy(_, proto::Stream_Kind_ROW_INDEX, false))
+      .WillRepeatedly(Return(nullptr));
+  EXPECT_CALL(streams_, getStreamProxy(_, proto::Stream_Kind_PRESENT, false))
+      .WillRepeatedly(Return(nullptr));
+
+  auto fileType = ROW("col_0", DECIMAL(38, 18));
+  auto scanSpec = std::make_unique<common::ScanSpec>("root");
+  VELOX_ASSERT_THROW(
+      buildReader(ROW("col_0", BIGINT()), fileType, {}, scanSpec.get()),
+      "Schema mismatch, From Kind: HUGEINT, To Kind: BIGINT");
+  VELOX_ASSERT_THROW(
+      buildReader(ROW("col_0", DOUBLE()), fileType, {}, scanSpec.get()),
+      "Schema mismatch, From Kind: HUGEINT, To Kind: DOUBLE");
+}
+
 TEST_P(TestColumnReader, testLargeSkip) {
   // set getEncoding
   proto::ColumnEncoding directEncoding;
@@ -4087,8 +4214,8 @@ TEST_P(TestColumnReader, testLargeSkip) {
     length[pos + 2] = 0x01;
   }
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(length, VELOX_ARRAY_SIZE(length))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(length, std::size(length))));
 
   char data[1024 * 1024];
   size_t size = writeRange(data, 0, 73200);
diff --git a/velox/dwio/dwrf/test/TestDictionaryEncodingUtils.cpp b/velox/dwio/dwrf/test/TestDictionaryEncodingUtils.cpp
index dc42b6941b1..0fb09b43fa4 100644
--- a/velox/dwio/dwrf/test/TestDictionaryEncodingUtils.cpp
+++ b/velox/dwio/dwrf/test/TestDictionaryEncodingUtils.cpp
@@ -22,7 +22,9 @@
 using namespace testing;
 using namespace facebook::velox::memory;
 
-namespace facebook::velox::dwrf {
+namespace facebook::velox::dwrf::test {
+namespace {
+
 class DictionaryEncodingUtilsTest : public testing::Test {
  protected:
   static void SetUpTestCase() {
@@ -36,7 +38,7 @@ TEST_F(DictionaryEncodingUtilsTest, StringGetSortedIndexLookupTable) {
         bool sort,
         std::function<bool(const StringDictionaryEncoder&, size_t, size_t)>
             ordering,
-        const std::vector<folly::StringPiece>& addKeySequence,
+        const std::vector<std::string_view>& addKeySequence,
         const std::vector<uint32_t>& lookupTable)
         : sort{sort},
           ordering{ordering},
@@ -45,7 +47,7 @@ TEST_F(DictionaryEncodingUtilsTest, StringGetSortedIndexLookupTable) {
     bool sort;
     std::function<bool(const StringDictionaryEncoder&, size_t, size_t)>
         ordering;
-    std::vector<folly::StringPiece> addKeySequence;
+    std::vector<std::string_view> addKeySequence;
     std::vector<uint32_t> lookupTable;
   };
 
@@ -151,7 +153,7 @@ TEST_F(DictionaryEncodingUtilsTest, StringStrideDictOptimization) {
         bool sort,
         std::function<bool(const StringDictionaryEncoder&, size_t, size_t)>
             ordering,
-        const std::vector<folly::StringPiece>& addKeySequence,
+        const std::vector<std::string_view>& addKeySequence,
         const std::vector<uint32_t>& lookupTable,
         const std::vector<bool>& inDict,
         size_t finalDictSize,
@@ -166,7 +168,7 @@ TEST_F(DictionaryEncodingUtilsTest, StringStrideDictOptimization) {
     bool sort;
     std::function<bool(const StringDictionaryEncoder&, size_t, size_t)>
         ordering;
-    std::vector<folly::StringPiece> addKeySequence;
+    std::vector<std::string_view> addKeySequence;
     std::vector<uint32_t> lookupTable;
     std::vector<bool> inDict;
     size_t finalDictSize;
@@ -315,7 +317,7 @@ TEST_F(DictionaryEncodingUtilsTest, StringStrideDictOptimization) {
     dwio::common::DataBuffer<uint32_t> strideDictSizes{
         *pool, rowCount / kStrideSize + 1};
 
-    std::vector<folly::StringPiece> expected{testCase.finalDictSize};
+    std::vector<std::string_view> expected{testCase.finalDictSize};
     std::vector<uint32_t> expectedSize(testCase.finalDictSize);
     for (size_t i = 0; i < testCase.lookupTable.size(); ++i) {
       if (testCase.inDict[i]) {
@@ -368,4 +370,5 @@ TEST_F(DictionaryEncodingUtilsTest, StringStrideDictOptimization) {
   }
 }
 
-} // namespace facebook::velox::dwrf
+} // namespace
+} // namespace facebook::velox::dwrf::test
diff --git a/velox/dwio/dwrf/test/TestDwrfColumnStatistics.cpp b/velox/dwio/dwrf/test/TestDwrfColumnStatistics.cpp
index cf13c6df826..a71ddc8a4bc 100644
--- a/velox/dwio/dwrf/test/TestDwrfColumnStatistics.cpp
+++ b/velox/dwio/dwrf/test/TestDwrfColumnStatistics.cpp
@@ -195,12 +195,12 @@ void checkEntries(
   for (const auto& entry : entries) {
     EXPECT_NE(
         std::find_if(
-            expectedEntries.begin(),
-            expectedEntries.end(),
+            expectedEntries.cbegin(),
+            expectedEntries.cend(),
             [&](const ColumnStatistics& expectedStats) {
               return expectedStats == entry;
             }),
-        expectedEntries.end());
+        expectedEntries.cend());
   }
 }
 
@@ -490,11 +490,11 @@ TEST(MapStatisticsBuilderTest, mergeKeyStats) {
   statsBuilder.increaseRawSize(8);
   mapStatsBuilder.addValues(createKeyInfo(1), statsBuilder);
 
-  keyStats = dynamic_cast<StatisticsBuilder&>(
+  auto& keyStats1 = dynamic_cast<StatisticsBuilder&>(
       *mapStatsBuilder.getEntryStatistics().at(KeyInfo{1}));
-  ASSERT_EQ(2, keyStats.getNumberOfValues());
-  ASSERT_TRUE(keyStats.getRawSize().has_value());
-  ASSERT_EQ(8, keyStats.getRawSize().value());
-  EXPECT_TRUE(keyStats.getSize().has_value());
-  EXPECT_EQ(42, keyStats.getSize().value());
+  ASSERT_EQ(2, keyStats1.getNumberOfValues());
+  ASSERT_TRUE(keyStats1.getRawSize().has_value());
+  ASSERT_EQ(8, keyStats1.getRawSize().value());
+  EXPECT_TRUE(keyStats1.getSize().has_value());
+  EXPECT_EQ(42, keyStats1.getSize().value());
 }
diff --git a/velox/dwio/dwrf/test/TestReadFile.h b/velox/dwio/dwrf/test/TestReadFile.h
index 8501b231ed8..aca3b13cf2a 100644
--- a/velox/dwio/dwrf/test/TestReadFile.h
+++ b/velox/dwio/dwrf/test/TestReadFile.h
@@ -31,7 +31,7 @@ class TestReadFile : public velox::ReadFile {
   TestReadFile(
       uint64_t seed,
       uint64_t length,
-      std::shared_ptr<filesystems::File::IoStats> ioStats)
+      std::shared_ptr<velox::IoStats> ioStats)
       : seed_(seed), length_(length), ioStats_(std::move(ioStats)) {}
 
   uint64_t size() const override {
@@ -42,15 +42,15 @@ class TestReadFile : public velox::ReadFile {
       uint64_t offset,
       uint64_t length,
       void* buffer,
-      filesystems::File::IoStats* stats = nullptr) const override {
+      const FileIoContext& context = {}) const override {
     const uint64_t content = offset + seed_;
     const uint64_t available = std::min(length_ - offset, length);
     int fill;
     for (fill = 0; fill < available; ++fill) {
       reinterpret_cast<char*>(buffer)[fill] = content + fill;
     }
-    if (stats) {
-      stats->addCounter(
+    if (context.ioStats) {
+      context.ioStats->addCounter(
           "read", RuntimeCounter(fill, RuntimeCounter::Unit::kBytes));
     }
     return std::string_view(static_cast<const char*>(buffer), fill);
@@ -59,13 +59,12 @@ class TestReadFile : public velox::ReadFile {
   uint64_t preadv(
       uint64_t offset,
       const std::vector<folly::Range<char*>>& buffers,
-      filesystems::File::IoStats* stats = nullptr) const override {
-    auto res = ReadFile::preadv(offset, buffers, stats);
-    if (stats) {
-      stats->addCounter(
+      const FileIoContext& context = {}) const override {
+    auto res = ReadFile::preadv(offset, buffers, context);
+    if (context.ioStats) {
+      context.ioStats->addCounter(
           "read",
-          RuntimeCounter(
-              static_cast<int64_t>(res), RuntimeCounter::Unit::kBytes));
+          RuntimeCounter(saturateCast(res), RuntimeCounter::Unit::kBytes));
     }
     ++numIos_;
     return res;
@@ -103,7 +102,7 @@ class TestReadFile : public velox::ReadFile {
  private:
   const uint64_t seed_;
   const uint64_t length_;
-  std::shared_ptr<filesystems::File::IoStats> ioStats_;
+  std::shared_ptr<velox::IoStats> ioStats_;
   mutable std::atomic<int64_t> numIos_{0};
 };
 
diff --git a/velox/dwio/dwrf/test/TestRle.cpp b/velox/dwio/dwrf/test/TestRle.cpp
index b779dedff8e..d1fe6f2c813 100644
--- a/velox/dwio/dwrf/test/TestRle.cpp
+++ b/velox/dwio/dwrf/test/TestRle.cpp
@@ -88,7 +88,7 @@ TEST_F(RLEv2Test, basicDelta0) {
   }
 
   const unsigned char bytes[] = {0xc0, 0x13, 0x00, 0x02};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, count), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, count), 3);
@@ -106,7 +106,7 @@ TEST_F(RLEv2Test, basicDelta1) {
 
   const unsigned char bytes[] = {
       0xce, 0x04, 0xe7, 0x07, 0xc8, 0x01, 0x32, 0x19, 0x0f};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
@@ -127,7 +127,7 @@ TEST_F(RLEv2Test, basicDelta2) {
 
   const unsigned char bytes[] = {
       0xce, 0x04, 0xe7, 0x07, 0xc7, 0x01, 0x32, 0x19, 0x23};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
@@ -148,7 +148,7 @@ TEST_F(RLEv2Test, basicDelta3) {
 
   const unsigned char bytes[] = {
       0xce, 0x04, 0xe8, 0x07, 0xc7, 0x01, 0x32, 0x19, 0x0f};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
@@ -169,7 +169,7 @@ TEST_F(RLEv2Test, basicDelta4) {
 
   const unsigned char bytes[] = {
       0xce, 0x04, 0xe8, 0x07, 0xc8, 0x01, 0x32, 0x19, 0x23};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
@@ -188,7 +188,7 @@ TEST_F(RLEv2Test, delta0Width) {
       createRleDecoder<false>(
           std::unique_ptr<dwio::common::SeekableInputStream>(
               new dwio::common::SeekableArrayInputStream(
-                  buffer, VELOX_ARRAY_SIZE(buffer))),
+                  buffer, std::size(buffer))),
           RleVersion_2,
           *pool,
           true /* doesn't matter */,
@@ -219,7 +219,7 @@ TEST_F(RLEv2Test, basicDelta0WithNulls) {
   }
 
   const unsigned char bytes[] = {0xc0, 0x13, 0x00, 0x02};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   const size_t count = values.size();
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, count, nulls), 1, nulls);
@@ -243,7 +243,7 @@ TEST_F(RLEv2Test, shortRepeats) {
   const unsigned char bytes[] = {0x04, 0x00, 0x04, 0x02, 0x04, 0x04, 0x04,
                                  0x06, 0x04, 0x08, 0x04, 0x0a, 0x04, 0x0c,
                                  0x04, 0x0e, 0x04, 0x10, 0x04, 0x12};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, count), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, count), 3);
@@ -266,7 +266,7 @@ TEST_F(RLEv2Test, multiByteShortRepeats) {
                                  0x00, 0x00, 0x3c, 0x80, 0x00, 0x00, 0x00,
                                  0x00, 0x00, 0x00, 0x02, 0x3c, 0x80, 0x00,
                                  0x00, 0x00, 0x00, 0x00, 0x00, 0x04};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, count), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, count), 3);
@@ -280,7 +280,7 @@ TEST_F(RLEv2Test, 0to2Repeat1Direct) {
   std::unique_ptr<dwio::common::IntDecoder<true>> rle = createRleDecoder<true>(
       std::unique_ptr<dwio::common::SeekableInputStream>(
           new dwio::common::SeekableArrayInputStream(
-              buffer, VELOX_ARRAY_SIZE(buffer))),
+              buffer, std::size(buffer))),
       RleVersion_2,
       *pool,
       true /* doesn't matter */,
@@ -302,7 +302,7 @@ TEST_F(RLEv2Test, bitSize2Direct) {
   }
 
   const unsigned char bytes[] = {0x42, 0x13, 0x22, 0x22, 0x22, 0x22, 0x22};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, count), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, count), 3);
@@ -320,7 +320,7 @@ TEST_F(RLEv2Test, bitSize4Direct) {
 
   const unsigned char bytes[] = {
       0x46, 0x13, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
 
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, count), 1);
@@ -360,7 +360,7 @@ TEST_F(RLEv2Test, multipleRunsDirect) {
       0x04,
       0x04,
       0x04};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
 
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
@@ -382,7 +382,7 @@ TEST_F(RLEv2Test, largeNegativesDirect) {
   std::unique_ptr<dwio::common::IntDecoder<true>> rle = createRleDecoder<true>(
       std::unique_ptr<dwio::common::SeekableInputStream>(
           new dwio::common::SeekableArrayInputStream(
-              buffer, VELOX_ARRAY_SIZE(buffer))),
+              buffer, std::size(buffer))),
       RleVersion_2,
       *pool,
       true /* doesn't matter */,
@@ -408,7 +408,7 @@ TEST_F(RLEv2Test, overflowDirect) {
       0x7e, 0x03, 0x7d, 0x45, 0x3c, 0x12, 0x41, 0x48, 0xf4, 0xbe, 0x7d, 0x45,
       0x3c, 0x12, 0x41, 0x48, 0xf4, 0xae, 0x50, 0xce, 0xad, 0x2a, 0x30, 0x0e,
       0xd2, 0x96, 0xfe, 0xd8, 0xd2, 0x38, 0x54, 0x6e, 0x3d, 0x81};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
@@ -445,7 +445,7 @@ TEST_F(RLEv2Test, basicPatched0) {
       0x5a,
       0xfc,
       0xe8};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
@@ -484,7 +484,7 @@ TEST_F(RLEv2Test, basicPatched1) {
       0xe0, 0x78, 0x00, 0x1c, 0x0f, 0x08, 0x06, 0x81, 0xc6, 0x90, 0x80, 0x68,
       0x24, 0x1b, 0x0b, 0x26, 0x83, 0x21, 0x30, 0xe0, 0x98, 0x3c, 0x6f, 0x06,
       0xb7, 0x03, 0x70};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
@@ -544,7 +544,7 @@ TEST_F(RLEv2Test, mixedPatchedAndShortRepeats) {
       0x00, 0x0c, 0x02, 0x08, 0x18, 0x00, 0x40, 0x00, 0x01, 0x00, 0x00, 0x08,
       0x30, 0x33, 0x80, 0x00, 0x02, 0x0c, 0x10, 0x20, 0x20, 0x47, 0x80, 0x13,
       0x4c};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
@@ -579,7 +579,7 @@ TEST_F(RLEv2Test, basicDirectSeek) {
       0x04,
       0x04,
       0x04};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
 
   std::unique_ptr<dwio::common::IntDecoder<true>> rle = createRleDecoder<true>(
       std::unique_ptr<dwio::common::SeekableInputStream>(
@@ -688,7 +688,7 @@ TEST_F(RLEv1Test, simpleTest) {
       createRleDecoder<false>(
           std::unique_ptr<dwio::common::SeekableInputStream>(
               new dwio::common::SeekableArrayInputStream(
-                  buffer, VELOX_ARRAY_SIZE(buffer))),
+                  buffer, std::size(buffer))),
           RleVersion_1,
           *pool,
           true,
@@ -712,7 +712,7 @@ TEST_F(RLEv1Test, signedNullLiteralTest) {
   std::unique_ptr<dwio::common::IntDecoder<true>> rle = createRleDecoder<true>(
       std::unique_ptr<dwio::common::SeekableInputStream>(
           new dwio::common::SeekableArrayInputStream(
-              buffer, VELOX_ARRAY_SIZE(buffer))),
+              buffer, std::size(buffer))),
       RleVersion_1,
       *pool,
       true,
@@ -733,7 +733,7 @@ TEST_F(RLEv1Test, splitHeader) {
       createRleDecoder<false>(
           std::unique_ptr<dwio::common::SeekableInputStream>(
               new dwio::common::SeekableArrayInputStream(
-                  buffer, VELOX_ARRAY_SIZE(buffer), 4)),
+                  buffer, std::size(buffer), 4)),
           RleVersion_1,
           *pool,
           true,
@@ -751,8 +751,7 @@ TEST_F(RLEv1Test, splitRuns) {
   const unsigned char buffer[] = {
       0x7d, 0x01, 0xff, 0x01, 0xfb, 0x01, 0x02, 0x03, 0x04, 0x05};
   dwio::common::SeekableInputStream* const stream =
-      new dwio::common::SeekableArrayInputStream(
-          buffer, VELOX_ARRAY_SIZE(buffer));
+      new dwio::common::SeekableArrayInputStream(buffer, std::size(buffer));
   std::unique_ptr<dwio::common::IntDecoder<false>> rle =
       createRleDecoder<false>(
           std::unique_ptr<dwio::common::SeekableInputStream>(stream),
@@ -784,8 +783,7 @@ TEST_F(RLEv1Test, testSigned) {
   auto pool = memory::memoryManager()->addLeafPool();
   const unsigned char buffer[] = {0x7f, 0xff, 0x20};
   dwio::common::SeekableInputStream* const stream =
-      new dwio::common::SeekableArrayInputStream(
-          buffer, VELOX_ARRAY_SIZE(buffer));
+      new dwio::common::SeekableArrayInputStream(buffer, std::size(buffer));
   std::unique_ptr<dwio::common::IntDecoder<true>> rle = createRleDecoder<true>(
       std::unique_ptr<dwio::common::SeekableInputStream>(stream),
       RleVersion_1,
@@ -808,8 +806,7 @@ TEST_F(RLEv1Test, testNull) {
   auto pool = memory::memoryManager()->addLeafPool();
   const unsigned char buffer[] = {0x75, 0x02, 0x00};
   dwio::common::SeekableInputStream* const stream =
-      new dwio::common::SeekableArrayInputStream(
-          buffer, VELOX_ARRAY_SIZE(buffer));
+      new dwio::common::SeekableArrayInputStream(buffer, std::size(buffer));
   std::unique_ptr<dwio::common::IntDecoder<true>> rle = createRleDecoder<true>(
       std::unique_ptr<dwio::common::SeekableInputStream>(stream),
       RleVersion_1,
@@ -842,8 +839,7 @@ TEST_F(RLEv1Test, testAllNulls) {
                                   0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c,
                                   0x0d, 0x0e, 0x0f, 0x3d, 0x00, 0x12};
   dwio::common::SeekableInputStream* const stream =
-      new dwio::common::SeekableArrayInputStream(
-          buffer, VELOX_ARRAY_SIZE(buffer));
+      new dwio::common::SeekableArrayInputStream(buffer, std::size(buffer));
   std::unique_ptr<dwio::common::IntDecoder<false>> rle =
       createRleDecoder<false>(
           std::unique_ptr<dwio::common::SeekableInputStream>(stream),
@@ -1095,8 +1091,7 @@ TEST_F(RLEv1Test, skipTest) {
       128, 228, 63,  128, 232, 63,  128, 236, 63,  128, 240, 63,  128, 244, 63,
       128, 248, 63,  128, 252, 63};
   dwio::common::SeekableInputStream* const stream =
-      new dwio::common::SeekableArrayInputStream(
-          buffer, VELOX_ARRAY_SIZE(buffer));
+      new dwio::common::SeekableArrayInputStream(buffer, std::size(buffer));
   std::unique_ptr<dwio::common::IntDecoder<true>> rle = createRleDecoder<true>(
       std::unique_ptr<dwio::common::SeekableInputStream>(stream),
       RleVersion_1,
@@ -1872,8 +1867,8 @@ TEST_F(RLEv1Test, seekTest) {
       151, 12,  193, 190, 224, 143, 9,   129, 245, 133, 204, 8,   182, 209, 250,
       178, 8,   148, 139, 144, 193, 11,  230, 182, 245, 164, 7,   149, 204, 161,
       226, 14,  175, 229, 148, 166, 13,  148, 140, 189, 216, 3};
-  auto* stream = new dwio::common::SeekableArrayInputStream(
-      buffer, VELOX_ARRAY_SIZE(buffer));
+  auto* stream =
+      new dwio::common::SeekableArrayInputStream(buffer, std::size(buffer));
   const long junk[] = {
       -1192035722, 1672896916,  1491444859,  -1244121273, -791680696,
       1681943525,  -571055948,  -1744759283, -998345856,  240559198,
@@ -2991,7 +2986,7 @@ TEST_F(RLEv1Test, seekTest) {
   };
   std::vector<int64_t> data(2048);
   rle->next(data.data(), data.size(), nullptr);
-  ASSERT_EQ(getNumReadBytes(), VELOX_ARRAY_SIZE(buffer));
+  ASSERT_EQ(getNumReadBytes(), std::size(buffer));
   for (size_t i = 0; i < data.size(); ++i) {
     if (i < 1024) {
       EXPECT_EQ(i / 4, data[i]) << "Wrong output at " << i;
@@ -3023,7 +3018,7 @@ TEST_F(RLEv1Test, seekTest) {
 
   // Seek to end
   std::vector<uint64_t> position;
-  position.push_back(VELOX_ARRAY_SIZE(buffer));
+  position.push_back(std::size(buffer));
   position.push_back(0);
   dwio::common::PositionProvider pp{position};
   rle->seekToRowGroup(pp);
@@ -3033,7 +3028,7 @@ TEST_F(RLEv1Test, seekTest) {
 
   // Seek to end + 1
   position.clear();
-  position.push_back(VELOX_ARRAY_SIZE(buffer));
+  position.push_back(std::size(buffer));
   position.push_back(1);
   dwio::common::PositionProvider pp2{position};
   // Seek is fine (because it's lazy), but read should fail
@@ -3049,7 +3044,7 @@ TEST_F(RLEv1Test, testLeadingNulls) {
       createRleDecoder<false>(
           std::unique_ptr<dwio::common::SeekableInputStream>(
               new dwio::common::SeekableArrayInputStream(
-                  buffer, VELOX_ARRAY_SIZE(buffer))),
+                  buffer, std::size(buffer))),
           RleVersion_1,
           *pool,
           true,
diff --git a/velox/dwio/dwrf/test/TestStringDictionaryEncoder.cpp b/velox/dwio/dwrf/test/TestStringDictionaryEncoder.cpp
index 2dfd93797ec..f8c33d91ff6 100644
--- a/velox/dwio/dwrf/test/TestStringDictionaryEncoder.cpp
+++ b/velox/dwio/dwrf/test/TestStringDictionaryEncoder.cpp
@@ -20,8 +20,6 @@
 
 DECLARE_bool(velox_enable_memory_usage_track_in_default_memory_pool);
 
-using namespace facebook::velox::memory;
-
 namespace facebook::velox::dwrf {
 
 class TestStringDictionaryEncoder : public ::testing::Test {
@@ -35,10 +33,10 @@ class TestStringDictionaryEncoder : public ::testing::Test {
 TEST_F(TestStringDictionaryEncoder, AddKey) {
   struct TestCase {
     explicit TestCase(
-        const std::vector<folly::StringPiece>& addKeySequence,
+        const std::vector<std::string_view>& addKeySequence,
         const std::vector<size_t>& encodedSequence)
         : addKeySequence{addKeySequence}, encodedSequence{encodedSequence} {}
-    std::vector<folly::StringPiece> addKeySequence;
+    std::vector<std::string_view> addKeySequence;
     std::vector<size_t> encodedSequence;
   };
 
@@ -50,7 +48,7 @@ TEST_F(TestStringDictionaryEncoder, AddKey) {
       TestCase{{"doe", "sow", "sow", "doe", "sow"}, {0, 1, 1, 0, 1}}};
 
   for (const auto& testCase : testCases) {
-    auto pool = memoryManager()->addLeafPool();
+    auto pool = memory::memoryManager()->addLeafPool();
     StringDictionaryEncoder stringDictEncoder{*pool, *pool};
     std::vector<size_t> actualEncodedSequence{};
     for (const auto& key : testCase.addKeySequence) {
@@ -63,14 +61,14 @@ TEST_F(TestStringDictionaryEncoder, AddKey) {
 TEST_F(TestStringDictionaryEncoder, GetIndex) {
   struct TestCase {
     explicit TestCase(
-        const std::vector<folly::StringPiece>& addKeySequence,
-        const std::vector<folly::StringPiece>& getIndexSequence,
+        const std::vector<std::string_view>& addKeySequence,
+        const std::vector<std::string_view>& getIndexSequence,
         const std::vector<size_t>& encodedSequence)
         : addKeySequence{addKeySequence},
           getIndexSequence{getIndexSequence},
           encodedSequence{encodedSequence} {}
-    std::vector<folly::StringPiece> addKeySequence;
-    std::vector<folly::StringPiece> getIndexSequence;
+    std::vector<std::string_view> addKeySequence;
+    std::vector<std::string_view> getIndexSequence;
     std::vector<size_t> encodedSequence;
   };
 
@@ -94,7 +92,7 @@ TEST_F(TestStringDictionaryEncoder, GetIndex) {
           {0, 3, 4, 2, 1, 3, 2, 4, 2, 0, 1, 0, 3}}};
 
   for (const auto& testCase : testCases) {
-    auto pool = memoryManager()->addLeafPool();
+    auto pool = memory::memoryManager()->addLeafPool();
     StringDictionaryEncoder stringDictEncoder{*pool, *pool};
     for (const auto& key : testCase.addKeySequence) {
       stringDictEncoder.addKey(key, 0);
@@ -111,14 +109,14 @@ TEST_F(TestStringDictionaryEncoder, GetIndex) {
 TEST_F(TestStringDictionaryEncoder, GetCount) {
   struct TestCase {
     explicit TestCase(
-        const std::vector<folly::StringPiece>& addKeySequence,
-        const std::vector<folly::StringPiece>& getCountSequence,
+        const std::vector<std::string_view>& addKeySequence,
+        const std::vector<std::string_view>& getCountSequence,
         const std::vector<size_t>& countSequence)
         : addKeySequence{addKeySequence},
           getCountSequence{getCountSequence},
           countSequence{countSequence} {}
-    std::vector<folly::StringPiece> addKeySequence;
-    std::vector<folly::StringPiece> getCountSequence;
+    std::vector<std::string_view> addKeySequence;
+    std::vector<std::string_view> getCountSequence;
     std::vector<size_t> countSequence;
   };
 
@@ -143,7 +141,7 @@ TEST_F(TestStringDictionaryEncoder, GetCount) {
           {3, 2, 3, 3, 2}}};
 
   for (const auto& testCase : testCases) {
-    auto pool = memoryManager()->addLeafPool();
+    auto pool = memory::memoryManager()->addLeafPool();
     StringDictionaryEncoder stringDictEncoder{*pool, *pool};
     for (const auto& key : testCase.addKeySequence) {
       stringDictEncoder.addKey(key, 0);
@@ -161,15 +159,14 @@ TEST_F(TestStringDictionaryEncoder, GetCount) {
 TEST_F(TestStringDictionaryEncoder, GetStride) {
   struct TestCase {
     explicit TestCase(
-        const std::vector<std::pair<folly::StringPiece, size_t>>&
-            addKeySequence,
-        const std::vector<folly::StringPiece>& getStrideSequence,
+        const std::vector<std::pair<std::string_view, size_t>>& addKeySequence,
+        const std::vector<std::string_view>& getStrideSequence,
         const std::vector<size_t>& strideSequence)
         : addKeySequence{addKeySequence},
           getStrideSequence{getStrideSequence},
           strideSequence{strideSequence} {}
-    std::vector<std::pair<folly::StringPiece, size_t>> addKeySequence;
-    std::vector<folly::StringPiece> getStrideSequence;
+    std::vector<std::pair<std::string_view, size_t>> addKeySequence;
+    std::vector<std::string_view> getStrideSequence;
     std::vector<size_t> strideSequence;
   };
 
@@ -197,7 +194,7 @@ TEST_F(TestStringDictionaryEncoder, GetStride) {
           {1, 1, 6, 3, 4}}};
 
   for (const auto& testCase : testCases) {
-    auto pool = memoryManager()->addLeafPool();
+    auto pool = memory::memoryManager()->addLeafPool();
     StringDictionaryEncoder stringDictEncoder{*pool, *pool};
     for (const auto& kv : testCase.addKeySequence) {
       stringDictEncoder.addKey(kv.first, kv.second);
@@ -220,7 +217,7 @@ std::string genPaddedIntegerString(size_t integer, size_t length) {
 }
 
 TEST_F(TestStringDictionaryEncoder, Clear) {
-  auto pool = memoryManager()->addLeafPool();
+  auto pool = memory::memoryManager()->addLeafPool();
   StringDictionaryEncoder stringDictEncoder{*pool, *pool};
   std::string baseString{"jjkkll"};
   for (size_t i = 0; i != 2500; ++i) {
@@ -242,7 +239,7 @@ TEST_F(TestStringDictionaryEncoder, Clear) {
 }
 
 TEST_F(TestStringDictionaryEncoder, MemBenchmark) {
-  auto pool = memoryManager()->addLeafPool();
+  auto pool = memory::memoryManager()->addLeafPool();
   StringDictionaryEncoder stringDictEncoder{*pool, *pool};
   std::string baseString{"jjkkll"};
   for (size_t i = 0; i != 10000; ++i) {
@@ -253,15 +250,15 @@ TEST_F(TestStringDictionaryEncoder, MemBenchmark) {
 }
 
 TEST_F(TestStringDictionaryEncoder, Limit) {
-  auto pool = memoryManager()->addLeafPool();
+  auto pool = memory::memoryManager()->addLeafPool();
   StringDictionaryEncoder encoder{*pool, *pool};
-  encoder.addKey(folly::StringPiece{"abc"}, 0);
+  encoder.addKey(std::string_view{"abc"}, 0);
   dwio::common::DataBuffer<char> buf{*pool};
   buf.resize(std::numeric_limits<uint32_t>::max());
 
   ASSERT_THROW(
       encoder.addKey(
-          folly::StringPiece{
+          std::string_view{
               buf.data(), std::numeric_limits<uint32_t>::max() - 3},
           0),
       dwio::common::exception::LoggedException);
diff --git a/velox/dwio/dwrf/test/WriterContextTest.cpp b/velox/dwio/dwrf/test/WriterContextTest.cpp
index 30cbf19d720..cd67deddb3d 100644
--- a/velox/dwio/dwrf/test/WriterContextTest.cpp
+++ b/velox/dwio/dwrf/test/WriterContextTest.cpp
@@ -219,6 +219,44 @@ TEST_F(WriterContextTest, memory) {
   ASSERT_EQ(context.availableMemoryReservation(), 786368);
 }
 
+TEST_F(WriterContextTest, memoryBudgetDefault) {
+  auto pool = memory::memoryManager()->addRootPool("memoryBudgetDefault");
+  WriterContext context{std::make_shared<Config>(), pool};
+  ASSERT_EQ(context.getMemoryBudget(), pool->maxCapacity());
+}
+
+TEST_F(WriterContextTest, memoryBudgetLessThanPoolCapacity) {
+  const int64_t poolCapacity = 1L << 30;
+  const int64_t budget = 256L << 20;
+  auto pool = memory::memoryManager()->addRootPool(
+      "memoryBudgetLessThanPoolCapacity", poolCapacity);
+  WriterContext context{
+      std::make_shared<Config>(),
+      pool,
+      dwio::common::MetricsLog::voidLog(),
+      nullptr,
+      false,
+      nullptr,
+      budget};
+  ASSERT_EQ(context.getMemoryBudget(), budget);
+}
+
+TEST_F(WriterContextTest, memoryBudgetGreaterThanPoolCapacity) {
+  const int64_t poolCapacity = 256L << 20;
+  const int64_t budget = 1L << 30;
+  auto pool = memory::memoryManager()->addRootPool(
+      "memoryBudgetGreaterThanPoolCapacity", poolCapacity);
+  WriterContext context{
+      std::make_shared<Config>(),
+      pool,
+      dwio::common::MetricsLog::voidLog(),
+      nullptr,
+      false,
+      nullptr,
+      budget};
+  ASSERT_EQ(context.getMemoryBudget(), poolCapacity);
+}
+
 TEST_F(WriterContextTest, abort) {
   auto writerRoot = memory::memoryManager()->addRootPool(
       "abort", 1L << 30, exec::MemoryReclaimer::create());
diff --git a/velox/dwio/dwrf/test/WriterFlushTest.cpp b/velox/dwio/dwrf/test/WriterFlushTest.cpp
index b8dfcac394f..f55d3bc4449 100644
--- a/velox/dwio/dwrf/test/WriterFlushTest.cpp
+++ b/velox/dwio/dwrf/test/WriterFlushTest.cpp
@@ -146,8 +146,9 @@ class MockMemoryPool : public velox::memory::MemoryPool {
     VELOX_UNSUPPORTED("allocateContiguous unsupported");
   }
 
-  void freeContiguous(velox::memory::ContiguousAllocation&
-                      /*unused*/) override {
+  void freeContiguous(
+      velox::memory::ContiguousAllocation&
+      /*unused*/) override {
     VELOX_UNSUPPORTED("freeContiguous unsupported");
   }
 
diff --git a/velox/dwio/dwrf/test/WriterTest.cpp b/velox/dwio/dwrf/test/WriterTest.cpp
index d60683b53c3..e757d574e11 100644
--- a/velox/dwio/dwrf/test/WriterTest.cpp
+++ b/velox/dwio/dwrf/test/WriterTest.cpp
@@ -18,6 +18,7 @@
 #include <gtest/gtest.h>
 #include <stdexcept>
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/io/IoStatistics.h"
 #include "velox/dwio/dwrf/reader/ReaderBase.h"
 #include "velox/dwio/dwrf/writer/WriterBase.h"
 #include "velox/type/fbhive/HiveTypeParser.h"
@@ -61,7 +62,9 @@ class WriterTest : public Test {
     std::string data(sinkPtr_->data(), sinkPtr_->size());
     auto readFile = std::make_shared<InMemoryReadFile>(std::move(data));
     auto input = std::make_unique<BufferedInput>(std::move(readFile), *pool_);
-    dwio::common::ReaderOptions readerOpts{pool_.get()};
+    dwio::common::ReaderOptions readerOpts(pool_.get());
+    readerOpts.setDataIoStats(dataIoStats_);
+    readerOpts.setMetadataIoStats(metadataIoStats_);
     auto reader = std::make_unique<ReaderBase>(readerOpts, std::move(input));
     reader->loadCache();
     return reader;
@@ -75,7 +78,7 @@ class WriterTest : public Test {
     return writer_->getFooter();
   }
 
-  auto& addStripeInfo() {
+  StripeInformationWriteWrapper addStripeInfo() {
     return writer_->addStripeInfo();
   }
 
@@ -91,6 +94,10 @@ class WriterTest : public Test {
   std::shared_ptr<MemoryPool> pool_;
   MemorySink* sinkPtr_;
   std::unique_ptr<WriterBase> writer_;
+  std::shared_ptr<io::IoStatistics> dataIoStats_{
+      std::make_shared<io::IoStatistics>()};
+  std::shared_ptr<io::IoStatistics> metadataIoStats_{
+      std::make_shared<io::IoStatistics>()};
 };
 
 class SupportedCompressionTest
@@ -168,7 +175,7 @@ TEST_P(AllWriterCompressionTest, compression) {
         folly::to<std::string>(i), folly::to<std::string>(i + 1));
   }
   for (size_t i = 0; i < 4; ++i) {
-    getFooter().add_statistics();
+    getFooter()->addStatistics();
   }
 
   if (compressionKind_ == CompressionKind::CompressionKind_SNAPPY ||
@@ -230,7 +237,7 @@ TEST_P(SupportedCompressionTest, WriteFooter) {
         folly::to<std::string>(i), folly::to<std::string>(i + 1));
   }
   for (size_t i = 0; i < 4; ++i) {
-    getFooter().add_statistics();
+    getFooter()->addStatistics();
   }
   writeFooter(*schema);
   writer.close();
@@ -262,11 +269,11 @@ TEST_P(SupportedCompressionTest, WriteFooter) {
   ASSERT_EQ(footer.metadataSize(), 5);
   for (size_t i = 0; i < 4; ++i) {
     auto item = footer.metadata(i);
-    if (item.name() == WRITER_NAME_KEY) {
+    if (item.name() == kWriterNameKey) {
       ASSERT_EQ(item.value(), kDwioWriter);
-    } else if (item.name() == WRITER_VERSION_KEY) {
+    } else if (item.name() == kWriterVersionKey) {
       ASSERT_EQ(item.value(), folly::to<std::string>(reader->writerVersion()));
-    } else if (item.name() == WRITER_HOSTNAME_KEY) {
+    } else if (item.name() == kWriterHostnameKey) {
       ASSERT_EQ(item.value(), process::getHostName());
     } else {
       ASSERT_EQ(
@@ -306,9 +313,9 @@ TEST_P(SupportedCompressionTest, AddStripeInfo) {
   writerSink.addBuffer(*pool_, data.data(), data.size());
   writerSink.setMode(WriterSink::Mode::None);
 
-  auto& ret = addStripeInfo();
-  ASSERT_EQ(ret.numberofrows(), 101);
-  ASSERT_EQ(ret.rawdatasize(), 202);
+  auto ret = addStripeInfo();
+  ASSERT_EQ(ret.numberOfRows(), 101);
+  ASSERT_EQ(ret.rawDataSize(), 202);
   ASSERT_EQ(ret.checksum(), 8963334039576633799);
   writer.close();
 }
@@ -326,14 +333,14 @@ TEST_P(SupportedCompressionTest, NoChecksum) {
   writerSink.addBuffer(*pool_, data.data(), data.size());
   writerSink.setMode(WriterSink::Mode::None);
 
-  auto& ret = addStripeInfo();
-  ASSERT_FALSE(ret.has_checksum());
+  auto ret = addStripeInfo();
+  ASSERT_FALSE(ret.hasChecksum());
 
   std::string typeStr{"struct<a:int,b:float,c:string>"};
   HiveTypeParser parser;
   auto schema = parser.parse(typeStr);
   for (size_t i = 0; i < 4; ++i) {
-    getFooter().add_statistics();
+    getFooter()->addStatistics();
   }
   writeFooter(*schema);
   writer.close();
@@ -368,7 +375,7 @@ TEST_P(SupportedCompressionTest, NoCache) {
   HiveTypeParser parser;
   auto schema = parser.parse(typeStr);
   for (size_t i = 0; i < 4; ++i) {
-    getFooter().add_statistics();
+    getFooter()->addStatistics();
   }
   writeFooter(*schema);
   writer.close();
@@ -456,7 +463,20 @@ class MockFileSink : public dwio::common::FileSink {
 
   MOCK_METHOD(uint64_t, size, (), (const override));
   MOCK_METHOD(bool, isBuffered, (), (const override));
+// On Centos9 the gtest mock header doesn't initialize the
+// buffer_ member in MatcherBase correctly - the default constructor only
+// initializes one: /usr/include/gtest/gtest-matchers.h:302:33 resulting in
+// error:
+// '<unnamed>.testing::Matcher<const
+// facebook::velox::FileIoContext&>::<unnamed>.testing::internal::MatcherBase<const
+// facebook::velox::FileIoContext&>::buffer_' is used uninitialized
+// [-Werror=uninitialized]
+//  302 |       : vtable_(other.vtable_), buffer_(other.buffer_) {
+// Fix: https://github.com/google/googletest/pull/3797
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wuninitialized"
   MOCK_METHOD(void, write, (std::vector<DataBuffer<char>>&));
+#pragma GCC diagnostic pop
 };
 
 TEST_F(WriterTest, FlushWriterSinkUponClose) {
diff --git a/velox/dwio/dwrf/test/utils/CMakeLists.txt b/velox/dwio/dwrf/test/utils/CMakeLists.txt
index 617b9049077..f4cd63e7d71 100644
--- a/velox/dwio/dwrf/test/utils/CMakeLists.txt
+++ b/velox/dwio/dwrf/test/utils/CMakeLists.txt
@@ -13,6 +13,7 @@
 # limitations under the License.
 
 add_library(velox_dwrf_test_utils E2EWriterTestUtil.cpp)
+velox_add_test_headers(velox_dwrf_test_utils E2EWriterTestUtil.h)
 
 target_link_libraries(
   velox_dwrf_test_utils
diff --git a/velox/dwio/dwrf/test/utils/E2EWriterTestUtil.cpp b/velox/dwio/dwrf/test/utils/E2EWriterTestUtil.cpp
index e132023f415..b4098e3ffc7 100644
--- a/velox/dwio/dwrf/test/utils/E2EWriterTestUtil.cpp
+++ b/velox/dwio/dwrf/test/utils/E2EWriterTestUtil.cpp
@@ -17,6 +17,7 @@
 #include "velox/dwio/dwrf/test/utils/E2EWriterTestUtil.h"
 
 #include <gtest/gtest.h>
+#include "velox/common/io/IoStatistics.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/dwio/dwrf/reader/DwrfReader.h"
 #include "velox/dwio/dwrf/writer/FlushPolicy.h"
@@ -114,7 +115,11 @@ namespace facebook::velox::dwrf {
       std::string(sinkPtr->data(), sinkPtr->size()));
   auto input = std::make_unique<BufferedInput>(readFile, pool);
 
-  dwio::common::ReaderOptions readerOpts{&pool};
+  auto dataIoStats = std::make_shared<io::IoStatistics>();
+  auto metadataIoStats = std::make_shared<io::IoStatistics>();
+  dwio::common::ReaderOptions readerOpts(&pool);
+  readerOpts.setDataIoStats(dataIoStats);
+  readerOpts.setMetadataIoStats(metadataIoStats);
   RowReaderOptions rowReaderOpts;
   auto reader = std::make_unique<DwrfReader>(readerOpts, std::move(input));
   EXPECT_GE(numStripesUpper, reader->getNumberOfStripes());
diff --git a/velox/dwio/dwrf/utils/CMakeLists.txt b/velox/dwio/dwrf/utils/CMakeLists.txt
index 74655a9b0b1..82685590d34 100644
--- a/velox/dwio/dwrf/utils/CMakeLists.txt
+++ b/velox/dwio/dwrf/utils/CMakeLists.txt
@@ -16,5 +16,12 @@ if(${VELOX_BUILD_TESTING})
   add_subdirectory(test)
 endif()
 
-velox_add_library(velox_dwio_dwrf_utils ProtoUtils.cpp BitIterator.h)
+velox_add_library(
+  velox_dwio_dwrf_utils
+  ProtoUtils.cpp
+  BitIterator.h
+  HEADERS
+  BufferedWriter.h
+  ProtoUtils.h
+)
 velox_link_libraries(velox_dwio_dwrf_utils velox_dwio_dwrf_common velox_type velox_memory)
diff --git a/velox/dwio/dwrf/utils/ProtoUtils.cpp b/velox/dwio/dwrf/utils/ProtoUtils.cpp
index 405d2e79ddf..8cfbf459440 100644
--- a/velox/dwio/dwrf/utils/ProtoUtils.cpp
+++ b/velox/dwio/dwrf/utils/ProtoUtils.cpp
@@ -51,31 +51,34 @@ CREATE_TYPE_TRAIT(ROW, STRUCT)
 
 void ProtoUtils::writeType(
     const Type& type,
-    proto::Footer& footer,
-    proto::Type* parent) {
-  auto self = footer.add_types();
+    FooterWriteWrapper& footer,
+    TypeWriteWrapper* parent) {
+  auto self = footer.addTypes();
   if (parent) {
-    parent->add_subtypes(footer.types_size() - 1);
+    parent->addSubtypes(footer.typesSize() - 1);
   }
+
   auto kind =
       VELOX_STATIC_FIELD_DYNAMIC_DISPATCH(SchemaType, kind, type.kind());
-  self->set_kind(kind);
+  auto typeKindWrapper = TypeKindWrapper(&kind);
+  self.setKind(typeKindWrapper);
+
   switch (type.kind()) {
     case TypeKind::ROW: {
       auto& row = type.asRow();
       for (size_t i = 0; i < row.size(); ++i) {
-        self->add_fieldnames(row.nameOf(i));
-        writeType(*row.childAt(i), footer, self);
+        self.addFieldnames(row.nameOf(i));
+        writeType(*row.childAt(i), footer, &self);
       }
       break;
     }
     case TypeKind::ARRAY:
-      writeType(*type.asArray().elementType(), footer, self);
+      writeType(*type.asArray().elementType(), footer, &self);
       break;
     case TypeKind::MAP: {
       auto& map = type.asMap();
-      writeType(*map.keyType(), footer, self);
-      writeType(*map.valueType(), footer, self);
+      writeType(*map.keyType(), footer, &self);
+      writeType(*map.valueType(), footer, &self);
       break;
     }
     default:
diff --git a/velox/dwio/dwrf/utils/ProtoUtils.h b/velox/dwio/dwrf/utils/ProtoUtils.h
index bea1d100330..310aaf7eb18 100644
--- a/velox/dwio/dwrf/utils/ProtoUtils.h
+++ b/velox/dwio/dwrf/utils/ProtoUtils.h
@@ -17,6 +17,7 @@
 #pragma once
 
 #include "velox/dwio/common/SeekableInputStream.h"
+#include "velox/dwio/dwrf/common/FileMetadata.h"
 #include "velox/dwio/dwrf/common/wrap/dwrf-proto-wrapper.h"
 #include "velox/type/Type.h"
 
@@ -26,8 +27,8 @@ class ProtoUtils final {
  public:
   static void writeType(
       const Type& type,
-      proto::Footer& footer,
-      proto::Type* parent = nullptr);
+      FooterWriteWrapper&,
+      TypeWriteWrapper* parent = nullptr);
 
   static std::shared_ptr<const Type> fromFooter(
       const proto::Footer& footer,
diff --git a/velox/dwio/dwrf/utils/test/ProtoUtilsTests.cpp b/velox/dwio/dwrf/utils/test/ProtoUtilsTests.cpp
index 92c6d01b00a..f32700513d2 100644
--- a/velox/dwio/dwrf/utils/test/ProtoUtilsTests.cpp
+++ b/velox/dwio/dwrf/utils/test/ProtoUtilsTests.cpp
@@ -31,7 +31,8 @@ TEST(ProtoUtilsTests, AllTypes) {
     HiveTypeParser parser;
     auto schema = parser.parse(type);
     proto::Footer footer;
-    ProtoUtils::writeType(*schema, footer);
+    auto footerWrapper = FooterWriteWrapper(&footer);
+    ProtoUtils::writeType(*schema, footerWrapper);
 
     auto out = ProtoUtils::fromFooter(footer);
     auto str = HiveTypeSerializer::serialize(out);
@@ -45,7 +46,8 @@ TEST(ProtoUtilsTests, Projection) {
   auto schema = parser.parse(
       "struct<a:boolean,b:tinyint,c:smallint,d:struct<a:int,b:int,c:int>>");
   proto::Footer footer;
-  ProtoUtils::writeType(*schema, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*schema, footerWrapper);
 
   auto type = ProtoUtils::fromFooter(
       footer, [](auto id) { return id != 2 && id != 5; });
diff --git a/velox/dwio/dwrf/writer/CMakeLists.txt b/velox/dwio/dwrf/writer/CMakeLists.txt
index ec121ef6aae..3450419be89 100644
--- a/velox/dwio/dwrf/writer/CMakeLists.txt
+++ b/velox/dwio/dwrf/writer/CMakeLists.txt
@@ -25,6 +25,24 @@ velox_add_library(
   WriterBase.cpp
   WriterContext.cpp
   WriterSink.cpp
+  HEADERS
+  ColumnWriter.h
+  DictionaryEncodingUtils.h
+  EntropyEncodingSelector.h
+  FlatMapColumnWriter.h
+  FlushPolicy.h
+  IndexBuilder.h
+  IntegerDictionaryEncoder.h
+  LayoutPlanner.h
+  PhysicalSizeAggregator.h
+  RatioTracker.h
+  StatisticsBuilder.h
+  StatisticsBuilderUtils.h
+  StringDictionaryEncoder.h
+  Writer.h
+  WriterBase.h
+  WriterContext.h
+  WriterSink.h
 )
 
 velox_link_libraries(
diff --git a/velox/dwio/dwrf/writer/ColumnWriter.cpp b/velox/dwio/dwrf/writer/ColumnWriter.cpp
index 2a4cf207796..2100d18fd8a 100644
--- a/velox/dwio/dwrf/writer/ColumnWriter.cpp
+++ b/velox/dwio/dwrf/writer/ColumnWriter.cpp
@@ -68,8 +68,9 @@ class ByteRleColumnWriter : public BaseColumnWriter {
   uint64_t write(const VectorPtr& slice, const common::Ranges& ranges) override;
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride) override {
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride)
+      override {
     BaseColumnWriter::flush(encodingFactory, encodingOverride);
     data_->flush();
   }
@@ -248,8 +249,9 @@ class IntegerColumnWriter : public BaseColumnWriter {
   }
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride) override {
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride)
+      override {
     tryAbandonDictionaries(false);
     initStreamWriters(useDictionaryEncoding_);
 
@@ -287,12 +289,14 @@ class IntegerColumnWriter : public BaseColumnWriter {
 
   // FIXME: call base class set encoding first to deal with sequence and
   // whatnot.
-  void setEncoding(proto::ColumnEncoding& encoding) const override {
+  void setEncoding(ColumnEncodingWriteWrapper& encoding) const override {
     BaseColumnWriter::setEncoding(encoding);
     if (useDictionaryEncoding_) {
-      encoding.set_kind(
-          proto::ColumnEncoding_Kind::ColumnEncoding_Kind_DICTIONARY);
-      encoding.set_dictionarysize(finalDictionarySize_);
+      auto columnEncodingKind =
+          proto::ColumnEncoding_Kind::ColumnEncoding_Kind_DICTIONARY;
+      encoding.setKind(ColumnEncodingKindWrapper(&columnEncodingKind));
+
+      encoding.setDictionarySize(finalDictionarySize_);
     }
   }
 
@@ -679,8 +683,9 @@ class TimestampColumnWriter : public BaseColumnWriter {
   uint64_t write(const VectorPtr& slice, const common::Ranges& ranges) override;
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride) override {
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride)
+      override {
     BaseColumnWriter::flush(encodingFactory, encodingOverride);
     seconds_->flush();
     nanos_->flush();
@@ -788,8 +793,9 @@ class DecimalColumnWriter : public BaseColumnWriter {
   }
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride) override {
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride)
+      override {
     BaseColumnWriter::flush(encodingFactory, encodingOverride);
     unscaledValues_->flush();
     scales_->flush();
@@ -954,8 +960,9 @@ class StringColumnWriter : public BaseColumnWriter {
   }
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride) override {
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride)
+      override {
     tryAbandonDictionaries(false);
     initStreamWriters(useDictionaryEncoding_);
 
@@ -1000,12 +1007,13 @@ class StringColumnWriter : public BaseColumnWriter {
 
   // FIXME: call base class set encoding first to deal with sequence and
   // whatnot.
-  void setEncoding(proto::ColumnEncoding& encoding) const override {
+  void setEncoding(ColumnEncodingWriteWrapper& encoding) const override {
     BaseColumnWriter::setEncoding(encoding);
     if (useDictionaryEncoding_) {
-      encoding.set_kind(
-          proto::ColumnEncoding_Kind::ColumnEncoding_Kind_DICTIONARY);
-      encoding.set_dictionarysize(finalDictionarySize_);
+      auto columnEncodingKind =
+          proto::ColumnEncoding_Kind::ColumnEncoding_Kind_DICTIONARY;
+      encoding.setKind(ColumnEncodingKindWrapper(&columnEncodingKind));
+      encoding.setDictionarySize(finalDictionarySize_);
     }
   }
 
@@ -1230,10 +1238,12 @@ uint64_t StringColumnWriter::writeDict(
   size_t strideIndex = strideOffsets_.size() - 1;
   uint64_t rawSize = 0;
   auto processRow = [&](size_t pos) {
-    auto sp = decodedVector.valueAt<StringView>(pos);
-    rows_.unsafeAppend(dictEncoder_.addKey(sp, strideIndex));
-    statsBuilder.addValues(sp);
-    rawSize += sp.size();
+    auto sv = decodedVector.valueAt<StringView>(pos);
+    // TODO: Remove explicit std::string_view cast.
+    rows_.unsafeAppend(dictEncoder_.addKey(std::string_view(sv), strideIndex));
+    // TODO: Remove explicit std::string_view cast.
+    statsBuilder.addValues(std::string_view(sv));
+    rawSize += sv.size();
   };
 
   uint64_t nullCount = 0;
@@ -1274,10 +1284,11 @@ uint64_t StringColumnWriter::writeDirect(
 
   uint64_t rawSize = 0;
   auto processRow = [&](size_t pos) {
-    auto sp = decodedVector.valueAt<StringView>(pos);
-    auto size = sp.size();
-    dataDirect_->write(sp.data(), size);
-    statsBuilder.addValues(sp);
+    auto sv = decodedVector.valueAt<StringView>(pos);
+    auto size = sv.size();
+    dataDirect_->write(sv.data(), size);
+    // TODO: Remove explicit std::string_view cast.
+    statsBuilder.addValues(std::string_view(sv));
     rawSize += size;
     lengths.unsafeAppend(size);
   };
@@ -1481,8 +1492,9 @@ class FloatColumnWriter : public BaseColumnWriter {
   uint64_t write(const VectorPtr& slice, const common::Ranges& ranges) override;
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride) override {
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride)
+      override {
     BaseColumnWriter::flush(encodingFactory, encodingOverride);
     data_.flush();
   }
@@ -1612,8 +1624,9 @@ class BinaryColumnWriter : public BaseColumnWriter {
   uint64_t write(const VectorPtr& slice, const common::Ranges& ranges) override;
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride) override {
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride)
+      override {
     BaseColumnWriter::flush(encodingFactory, encodingOverride);
     data_.flush();
     lengths_->flush();
@@ -1726,8 +1739,9 @@ class StructColumnWriter : public BaseColumnWriter {
   uint64_t write(const VectorPtr& slice, const common::Ranges& ranges) override;
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride) override {
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride)
+      override {
     BaseColumnWriter::flush(encodingFactory, encodingOverride);
     for (auto& c : children_) {
       c->flush(encodingFactory);
@@ -1855,8 +1869,9 @@ class ListColumnWriter : public BaseColumnWriter {
   uint64_t write(const VectorPtr& slice, const common::Ranges& ranges) override;
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride) override {
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride)
+      override {
     BaseColumnWriter::flush(encodingFactory, encodingOverride);
     lengths_->flush();
     children_.at(0)->flush(encodingFactory);
@@ -1982,8 +1997,9 @@ class MapColumnWriter : public BaseColumnWriter {
   uint64_t write(const VectorPtr& slice, const common::Ranges& ranges) override;
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride) override {
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride)
+      override {
     BaseColumnWriter::flush(encodingFactory, encodingOverride);
     lengths_->flush();
     children_.at(0)->flush(encodingFactory);
@@ -2119,7 +2135,7 @@ std::unique_ptr<BaseColumnWriter> BaseColumnWriter::create(
           "MAP_FLAT_COLS contains column {}, but the root type of this column is {}."
           " Column root types must be of type MAP",
           type.column(),
-          mapTypeKindToName(type.type()->kind()));
+          TypeKindName::toName(type.type()->kind()));
     }
     const auto structColumnKeys =
         context.getConfig(Config::MAP_FLAT_COLS_STRUCT_KEYS);
@@ -2212,7 +2228,7 @@ std::unique_ptr<BaseColumnWriter> BaseColumnWriter::create(
     }
     default:
       VELOX_FAIL(
-          "not supported yet: {}", mapTypeKindToName(type.type()->kind()));
+          "not supported yet: {}", TypeKindName::toName(type.type()->kind()));
   }
 }
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/writer/ColumnWriter.h b/velox/dwio/dwrf/writer/ColumnWriter.h
index 98c5691babb..9fde39f331a 100644
--- a/velox/dwio/dwrf/writer/ColumnWriter.h
+++ b/velox/dwio/dwrf/writer/ColumnWriter.h
@@ -45,12 +45,31 @@ class ColumnWriter {
   virtual void reset() = 0;
 
   virtual void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride =
-          [](auto& /* e */) {}) = 0;
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride =
+          [](auto /* e */) {}) {
+    VELOX_NYI();
+  }
+
+  virtual void flush(
+      std::function<velox::dwrf::proto::ColumnEncoding&(uint32_t)>
+          encodingFactory,
+      std::function<void(velox::dwrf::proto::ColumnEncoding&)>
+          encodingOverride = [](auto& /* e */) {}) {
+    VELOX_NYI();
+  }
 
   virtual uint64_t writeFileStats(
-      std::function<proto::ColumnStatistics&(uint32_t)> statsFactory) const = 0;
+      std::function<ColumnStatisticsWriteWrapper(uint32_t)> statsFactory)
+      const {
+    VELOX_NYI();
+  }
+
+  virtual uint64_t writeFileStats(
+      std::function<velox::dwrf::proto::ColumnStatistics&(uint32_t)>
+          statsFactory) const {
+    VELOX_NYI();
+  }
 
   virtual bool tryAbandonDictionaries(bool force) = 0;
 
@@ -61,11 +80,13 @@ class ColumnWriter {
       const uint32_t sequence)
       : id_{id}, sequence_{sequence}, context_{context} {}
 
-  virtual void setEncoding(proto::ColumnEncoding& encoding) const {
-    encoding.set_kind(proto::ColumnEncoding_Kind::ColumnEncoding_Kind_DIRECT);
-    encoding.set_dictionarysize(0);
-    encoding.set_node(id_);
-    encoding.set_sequence(sequence_);
+  virtual void setEncoding(ColumnEncodingWriteWrapper& columnEncoding) const {
+    auto columnEncodingKind =
+        proto::ColumnEncoding_Kind::ColumnEncoding_Kind_DIRECT;
+    columnEncoding.setKind(ColumnEncodingKindWrapper(&columnEncodingKind));
+    columnEncoding.setDictionarySize(0);
+    columnEncoding.setNode(id_);
+    columnEncoding.setSequence(sequence_);
   }
 
   const uint32_t id_;
@@ -99,9 +120,9 @@ class BaseColumnWriter : public ColumnWriter {
   }
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride =
-          [](auto& /* e */) {}) override {
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride =
+          [](auto /* e */) {}) override {
     if (!isRoot()) {
       present_->flush();
 
@@ -113,21 +134,22 @@ class BaseColumnWriter : public ColumnWriter {
       }
     }
 
-    auto& encoding = encodingFactory(id_);
+    auto encoding = encodingFactory(id_);
     setEncoding(encoding);
     encodingOverride(encoding);
     indexBuilder_->flush();
   }
 
-  uint64_t writeFileStats(std::function<proto::ColumnStatistics&(uint32_t)>
-                              statsFactory) const override {
-    auto& stats = statsFactory(id_);
+  uint64_t writeFileStats(
+      std::function<ColumnStatisticsWriteWrapper(uint32_t)> statsFactory)
+      const override {
+    auto stats = statsFactory(id_);
     fileStatsBuilder_->toProto(stats);
     const uint64_t size = context_.getPhysicalSizeAggregator(id_).getResult();
     for (auto& child : children_) {
       child->writeFileStats(statsFactory);
     }
-    stats.set_size(size);
+    stats.setSize(size);
     return size;
   }
 
@@ -170,7 +192,7 @@ class BaseColumnWriter : public ColumnWriter {
           createBooleanRleEncoder(newStream(StreamKind::StreamKind_PRESENT));
     }
     const auto options =
-        StatisticsBuilderOptions::fromConfig(context.getConfigs());
+        StatisticsBuilder::optionsFromConfig(context.getConfigs());
     indexStatsBuilder_ = StatisticsBuilder::create(*type.type(), options);
     fileStatsBuilder_ = StatisticsBuilder::create(*type.type(), options);
   }
diff --git a/velox/dwio/dwrf/writer/FlatMapColumnWriter.cpp b/velox/dwio/dwrf/writer/FlatMapColumnWriter.cpp
index 0099d52f65e..20d88cd5157 100644
--- a/velox/dwio/dwrf/writer/FlatMapColumnWriter.cpp
+++ b/velox/dwio/dwrf/writer/FlatMapColumnWriter.cpp
@@ -21,7 +21,6 @@
 #include "velox/vector/FlatMapVector.h"
 
 namespace facebook::velox::dwrf {
-
 namespace {
 
 template <typename T>
@@ -62,7 +61,10 @@ FlatMapColumnWriter<K>::FlatMapColumnWriter(
       valueType_{*type.childAt(1)},
       maxKeyCount_{context_.getConfig(Config::MAP_FLAT_MAX_KEYS)},
       collectMapStats_{context.getConfig(Config::MAP_STATISTICS)} {
-  auto options = StatisticsBuilderOptions::fromConfig(context.getConfigs());
+  if constexpr (std::is_same_v<KeyType, StringView>) {
+    stringKeys_.reserve(maxKeyCount_);
+  }
+  auto options = StatisticsBuilder::optionsFromConfig(context.getConfigs());
   keyFileStatsBuilder_ =
       std::unique_ptr<typename TypeInfo<K>::StatisticsBuilder>(
           dynamic_cast<typename TypeInfo<K>::StatisticsBuilder*>(
@@ -84,15 +86,17 @@ FlatMapColumnWriter<K>::FlatMapColumnWriter(
 
 template <TypeKind K>
 void FlatMapColumnWriter<K>::setEncoding(
-    proto::ColumnEncoding& encoding) const {
+    ColumnEncodingWriteWrapper& encoding) const {
   BaseColumnWriter::setEncoding(encoding);
-  encoding.set_kind(proto::ColumnEncoding_Kind::ColumnEncoding_Kind_MAP_FLAT);
+  auto columnEncodingKind =
+      proto::ColumnEncoding_Kind::ColumnEncoding_Kind_MAP_FLAT;
+  encoding.setKind(ColumnEncodingKindWrapper(&columnEncodingKind));
 }
 
 template <TypeKind K>
 void FlatMapColumnWriter<K>::flush(
-    std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-    std::function<void(proto::ColumnEncoding&)> encodingOverride) {
+    std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+    std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride) {
   BaseColumnWriter::flush(encodingFactory, encodingOverride);
 
   for (auto& pair : valueWriters_) {
@@ -136,18 +140,18 @@ void FlatMapColumnWriter<K>::createIndexEntry() {
 
 template <TypeKind K>
 uint64_t FlatMapColumnWriter<K>::writeFileStats(
-    std::function<proto::ColumnStatistics&(uint32_t)> statsFactory) const {
-  auto& stats = statsFactory(id_);
+    std::function<ColumnStatisticsWriteWrapper(uint32_t)> statsFactory) const {
+  auto stats = statsFactory(id_);
   fileStatsBuilder_->toProto(stats);
   uint64_t size = context_.getPhysicalSizeAggregator(id_).getResult();
 
-  auto& keyStats = statsFactory(keyType_.id());
+  auto keyStats = statsFactory(keyType_.id());
   keyFileStatsBuilder_->toProto(keyStats);
   auto keySize = context_.getPhysicalSizeAggregator(keyType_.id()).getResult();
-  keyStats.set_size(keySize);
+  keyStats.setSize(keySize);
 
   valueFileStatsBuilder_->writeFileStats(statsFactory);
-  stats.set_size(size);
+  stats.setSize(size);
   return size;
 }
 
@@ -173,6 +177,7 @@ void FlatMapColumnWriter<K>::reset() {
   BaseColumnWriter::reset();
   clearNodes();
   valueWriters_.clear();
+  stringKeys_.clear();
   rowsInStrides_.clear();
   rowsInCurrentStride_ = 0;
   totalRows_ = 0;
@@ -200,15 +205,26 @@ ValueWriter& FlatMapColumnWriter<K>::getValueWriter(
   }
 
   if (valueWriters_.size() >= maxKeyCount_) {
-    DWIO_RAISE(fmt::format(
-        "Too many map keys requested in (node {}, column {}). Allowed: {}",
-        id_,
-        type_.column(),
-        maxKeyCount_));
+    DWIO_RAISE(
+        fmt::format(
+            "Too many map keys requested in (node {}, column {}). Allowed: {}",
+            id_,
+            type_.column(),
+            maxKeyCount_));
   }
 
   auto keyInfo = getKeyInfo(key);
 
+  // For non-inline StringView keys (>12 chars), store an owned copy of the
+  // string data to prevent dangling pointers when input batches are released
+  // between writes. Inline StringViews are self-contained and safe as-is.
+  if constexpr (std::is_same_v<KeyType, StringView>) {
+    if (!key.isInline()) {
+      stringKeys_.emplace_back(key.data(), key.size());
+      key = StringView(stringKeys_.back());
+    }
+  }
+
   it = valueWriters_
            .emplace(
                std::piecewise_construct,
@@ -252,7 +268,7 @@ uint32_t updateKeyStatistics<TypeKind::VARCHAR>(
     StringView value,
     uint64_t count) {
   auto size = value.size();
-  keyStatsBuilder.addValues(folly::StringPiece{value.data(), size}, count);
+  keyStatsBuilder.addValues(std::string_view{value.data(), size}, count);
   return size * count;
 }
 
diff --git a/velox/dwio/dwrf/writer/FlatMapColumnWriter.h b/velox/dwio/dwrf/writer/FlatMapColumnWriter.h
index c6d706b8a4a..3394ab8a9bc 100644
--- a/velox/dwio/dwrf/writer/FlatMapColumnWriter.h
+++ b/velox/dwio/dwrf/writer/FlatMapColumnWriter.h
@@ -38,7 +38,7 @@ class ValueStatisticsBuilder {
   static std::unique_ptr<const ValueStatisticsBuilder> create(
       WriterContext& context,
       const dwio::common::TypeWithId& root) {
-    auto options = StatisticsBuilderOptions::fromConfig(context.getConfigs());
+    auto options = StatisticsBuilder::optionsFromConfig(context.getConfigs());
     return create_(context, root, options);
   }
 
@@ -53,14 +53,15 @@ class ValueStatisticsBuilder {
   }
 
   uint64_t writeFileStats(
-      std::function<proto::ColumnStatistics&(uint32_t)> statsFactory) const {
-    auto& stats = statsFactory(id_);
+      std::function<ColumnStatisticsWriteWrapper(uint32_t)> statsFactory)
+      const {
+    auto stats = statsFactory(id_);
     statisticsBuilder_->toProto(stats);
     uint64_t size = context_.getPhysicalSizeAggregator(id_).getResult();
     for (int32_t i = 0; i < children_.size(); ++i) {
       children_[i]->writeFileStats(statsFactory);
     }
-    stats.set_size(size);
+    stats.setSize(size);
     return size;
   }
 
@@ -209,10 +210,11 @@ class ValueWriter {
     columnWriter_->createIndexEntry();
   }
 
-  void flush(std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory) {
+  void flush(
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory) {
     inMap_->flush();
-    columnWriter_->flush(encodingFactory, [&](auto& encoding) {
-      *encoding.mutable_key() = keyInfo_;
+    columnWriter_->flush(encodingFactory, [&](auto encoding) {
+      *encoding.mutableKey() = keyInfo_;
     });
   }
 
@@ -290,20 +292,22 @@ class FlatMapColumnWriter : public BaseColumnWriter {
   uint64_t write(const VectorPtr& slice, const common::Ranges& ranges) override;
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride) override;
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride)
+      override;
 
   void createIndexEntry() override;
 
   void reset() override;
 
-  uint64_t writeFileStats(std::function<proto::ColumnStatistics&(uint32_t)>
-                              statsFactory) const override;
+  uint64_t writeFileStats(
+      std::function<ColumnStatisticsWriteWrapper(uint32_t)> statsFactory)
+      const override;
 
  private:
   using KeyType = typename TypeTraits<K>::NativeType;
 
-  void setEncoding(proto::ColumnEncoding& encoding) const override;
+  void setEncoding(ColumnEncodingWriteWrapper& encoding) const override;
 
   ValueWriter& getValueWriter(KeyType key, uint32_t inMapSize);
 
diff --git a/velox/dwio/dwrf/writer/IndexBuilder.h b/velox/dwio/dwrf/writer/IndexBuilder.h
index 57582199fc5..88cbade7dc3 100644
--- a/velox/dwio/dwrf/writer/IndexBuilder.h
+++ b/velox/dwio/dwrf/writer/IndexBuilder.h
@@ -16,12 +16,14 @@
 
 #pragma once
 
+#include "velox/dwio/common/Arena.h"
 #include "velox/dwio/common/OutputStream.h"
 #include "velox/dwio/dwrf/common/wrap/dwrf-proto-wrapper.h"
 #include "velox/dwio/dwrf/writer/StatisticsBuilder.h"
 
 namespace facebook::velox::dwrf {
 
+using dwio::common::ArenaCreate;
 using dwio::common::BufferedOutputStream;
 using dwio::common::PositionRecorder;
 
@@ -35,41 +37,50 @@ constexpr int32_t PRESENT_STREAM_INDEX_ENTRIES_PAGED =
 
 class IndexBuilder : public PositionRecorder {
  public:
-  IndexBuilder(std::unique_ptr<BufferedOutputStream> out)
-      : out_{std::move(out)} {}
+  IndexBuilder(
+      std::unique_ptr<BufferedOutputStream> out,
+      dwio::common::FileFormat fileFormat = dwio::common::FileFormat::DWRF)
+      : out_{std::move(out)},
+        arena_(std::make_unique<google::protobuf::Arena>()) {
+    auto rowIndex = ArenaCreate<proto::RowIndex>(arena_.get());
+    auto rowIndexEntry = ArenaCreate<proto::RowIndexEntry>(arena_.get());
+
+    index_ = std::make_unique<RowIndexWriteWrapper>(rowIndex);
+    entry_ = std::make_unique<RowIndexEntryWriteWrapper>(rowIndexEntry);
+  }
 
   virtual ~IndexBuilder() = default;
 
   void add(uint64_t pos, int32_t index = -1) override {
-    getEntry(index)->add_positions(pos);
+    getEntry(index).addPositions(pos);
   }
 
   virtual void addEntry(const StatisticsBuilder& writer) {
-    auto* stats = entry_.mutable_statistics();
-    writer.toProto(*stats);
-    *index_.add_entry() = entry_;
-    entry_.Clear();
+    auto stats = entry_->mutableStatistics();
+    writer.toProto(stats);
+    index_->addEntry(entry_);
+    entry_->clear();
   }
 
   virtual size_t getEntrySize() const {
-    const int32_t size = index_.entry_size() + 1;
+    const int32_t size = index_->entrySize() + 1;
     VELOX_CHECK_GT(size, 0, "Invalid entry size or missing current entry.");
     return size;
   }
 
   virtual void flush() {
     // remove isPresent positions if none is null
-    index_.SerializeToZeroCopyStream(out_.get());
+    index_->SerializeToZeroCopyStream(out_.get());
     out_->flush();
-    index_.Clear();
-    entry_.Clear();
+    index_->clear();
+    entry_->clear();
   }
 
   void capturePresentStreamOffset() {
     if (!presentStreamOffset_.has_value()) {
-      presentStreamOffset_ = entry_.positions_size();
+      presentStreamOffset_ = entry_->positionsSize();
     } else {
-      DWIO_ENSURE_EQ(presentStreamOffset_.value(), entry_.positions_size());
+      DWIO_ENSURE_EQ(presentStreamOffset_.value(), entry_->positionsSize());
     }
   }
 
@@ -79,27 +90,28 @@ class IndexBuilder : public PositionRecorder {
                                      : PRESENT_STREAM_INDEX_ENTRIES_UNPAGED;
 
     // Only need to process entries that have been added to the row index
-    for (uint32_t i = 0; i < index_.entry_size(); ++i) {
-      index_.mutable_entry(i)->mutable_positions()->ExtractSubrange(
-          presentStreamOffset_.value(), streamCount, nullptr);
+    for (uint32_t i = 0; i < index_->entrySize(); ++i) {
+      index_->mutableEntry(i).mutablePositions(
+          presentStreamOffset_.value(), streamCount);
     }
   }
 
  private:
-  proto::RowIndexEntry* getEntry(int32_t index) {
+  RowIndexEntryWriteWrapper getEntry(int32_t index) {
     if (index < 0) {
-      return &entry_;
-    } else if (index < index_.entry_size()) {
-      return index_.mutable_entry(index);
+      return *entry_;
+    } else if (index < index_->entrySize()) {
+      return index_->mutableEntry(index);
     } else {
-      VELOX_CHECK_EQ(index, index_.entry_size());
-      return &entry_;
+      VELOX_CHECK_EQ(index, index_->entrySize());
+      return *entry_;
     }
   }
 
   const std::unique_ptr<BufferedOutputStream> out_;
-  proto::RowIndex index_;
-  proto::RowIndexEntry entry_;
+  std::unique_ptr<RowIndexWriteWrapper> index_;
+  std::unique_ptr<RowIndexEntryWriteWrapper> entry_;
+  std::unique_ptr<google::protobuf::Arena> arena_;
   std::optional<int32_t> presentStreamOffset_;
 
   friend class IndexBuilderTest;
diff --git a/velox/dwio/dwrf/writer/LayoutPlanner.cpp b/velox/dwio/dwrf/writer/LayoutPlanner.cpp
index 4fcc5668480..334097a435f 100644
--- a/velox/dwio/dwrf/writer/LayoutPlanner.cpp
+++ b/velox/dwio/dwrf/writer/LayoutPlanner.cpp
@@ -16,14 +16,19 @@
 
 #include "velox/dwio/dwrf/writer/LayoutPlanner.h"
 
+#include "velox/dwio/common/Arena.h"
+
 namespace facebook::velox::dwrf {
 
+using dwio::common::ArenaCreate;
+
 StreamList getStreamList(WriterContext& context) {
   StreamList streams;
   streams.reserve(context.getStreamCount());
   context.iterateUnSuppressedStreams([&](auto& pair) {
-    streams.push_back(std::make_pair(
-        std::addressof(pair.first), std::addressof(pair.second)));
+    streams.push_back(
+        std::make_pair(
+            std::addressof(pair.first), std::addressof(pair.second)));
   });
   return streams;
 }
@@ -124,49 +129,54 @@ EncodingIter::pointer EncodingIter::operator->() const {
 
 EncodingManager::EncodingManager(
     const encryption::EncryptionHandler& encryptionHandler)
-    : encryptionHandler_{encryptionHandler} {
+    : encryptionHandler_{encryptionHandler},
+      arena_{std::make_unique<google::protobuf::Arena>()} {
   initEncryptionGroups();
+  auto dwrfStripeFooter = ArenaCreate<proto::StripeFooter>(arena_.get());
+  footer_ = std::make_unique<StripeFooterWriteWrapper>(dwrfStripeFooter);
 }
 
-proto::ColumnEncoding& EncodingManager::addEncodingToFooter(uint32_t nodeId) {
+ColumnEncodingWriteWrapper EncodingManager::addEncodingToFooter(
+    uint32_t nodeId) {
   if (encryptionHandler_.isEncrypted(nodeId)) {
     auto index = encryptionHandler_.getEncryptionGroupIndex(nodeId);
-    return *encryptionGroups_.at(index).add_encoding();
+    return ColumnEncodingWriteWrapper(
+        encryptionGroups_.at(index).add_encoding());
   } else {
-    return *footer_.add_encoding();
+    return footer_->addEncoding();
   }
 }
 
-proto::Stream* EncodingManager::addStreamToFooter(
+StreamWriteWrapper EncodingManager::addStreamToFooter(
     uint32_t nodeId,
     uint32_t& currentIndex) {
   if (encryptionHandler_.isEncrypted(nodeId)) {
     currentIndex = encryptionHandler_.getEncryptionGroupIndex(nodeId);
-    return encryptionGroups_.at(currentIndex).add_streams();
+    return StreamWriteWrapper(encryptionGroups_.at(currentIndex).add_streams());
   } else {
     currentIndex = std::numeric_limits<uint32_t>::max();
-    return footer_.add_streams();
+    return footer_->addStreams();
   }
 }
 
 std::string* EncodingManager::addEncryptionGroupToFooter() {
-  return footer_.add_encryptiongroups();
+  return footer_->addEncryptionGroups();
 }
 
 proto::StripeEncryptionGroup EncodingManager::getEncryptionGroup(uint32_t i) {
   return encryptionGroups_.at(i);
 }
 
-const proto::StripeFooter& EncodingManager::getFooter() const {
-  return footer_;
+const StripeFooterWriteWrapper& EncodingManager::getFooter() const {
+  return *footer_;
 }
 
 EncodingIter EncodingManager::begin() const {
-  return EncodingIter::begin(footer_, encryptionGroups_);
+  return EncodingIter::begin(*footer_->dwrfPtr(), encryptionGroups_);
 }
 
 EncodingIter EncodingManager::end() const {
-  return EncodingIter::end(footer_, encryptionGroups_);
+  return EncodingIter::end(*footer_->dwrfPtr(), encryptionGroups_);
 }
 
 void EncodingManager::initEncryptionGroups() {
diff --git a/velox/dwio/dwrf/writer/LayoutPlanner.h b/velox/dwio/dwrf/writer/LayoutPlanner.h
index 13dc965a652..ac22f9d736f 100644
--- a/velox/dwio/dwrf/writer/LayoutPlanner.h
+++ b/velox/dwio/dwrf/writer/LayoutPlanner.h
@@ -89,11 +89,11 @@ class EncodingManager : public EncodingContainer {
       const encryption::EncryptionHandler& encryptionHandler);
   virtual ~EncodingManager() override = default;
 
-  proto::ColumnEncoding& addEncodingToFooter(uint32_t nodeId);
-  proto::Stream* addStreamToFooter(uint32_t nodeId, uint32_t& currentIndex);
+  ColumnEncodingWriteWrapper addEncodingToFooter(uint32_t nodeId);
+  StreamWriteWrapper addStreamToFooter(uint32_t nodeId, uint32_t& currentIndex);
   std::string* addEncryptionGroupToFooter();
   proto::StripeEncryptionGroup getEncryptionGroup(uint32_t i);
-  const proto::StripeFooter& getFooter() const;
+  const StripeFooterWriteWrapper& getFooter() const;
 
   EncodingIter begin() const override;
   EncodingIter end() const override;
@@ -102,7 +102,8 @@ class EncodingManager : public EncodingContainer {
   void initEncryptionGroups();
 
   const encryption::EncryptionHandler& encryptionHandler_;
-  proto::StripeFooter footer_;
+  std::unique_ptr<StripeFooterWriteWrapper> footer_;
+  std::unique_ptr<google::protobuf::Arena> arena_;
   std::vector<proto::StripeEncryptionGroup> encryptionGroups_;
 };
 
diff --git a/velox/dwio/dwrf/writer/StatisticsBuilder.cpp b/velox/dwio/dwrf/writer/StatisticsBuilder.cpp
index 3000230c115..20d6989d9ef 100644
--- a/velox/dwio/dwrf/writer/StatisticsBuilder.cpp
+++ b/velox/dwio/dwrf/writer/StatisticsBuilder.cpp
@@ -16,113 +16,52 @@
 
 #include "velox/dwio/dwrf/writer/StatisticsBuilder.h"
 
+#include "velox/dwio/common/Arena.h"
+
 namespace facebook::velox::dwrf {
 
+using dwio::common::ArenaCreate;
+
 namespace {
 
-static bool isValidLength(const std::optional<uint64_t>& length) {
+bool isValidLength(const std::optional<uint64_t>& length) {
   return length.has_value() &&
       length.value() <= std::numeric_limits<int64_t>::max();
 }
 
-template <typename T>
-static void mergeCount(std::optional<T>& to, const std::optional<T>& from) {
-  if (to.has_value()) {
-    if (from.has_value()) {
-      to.value() += from.value();
-    } else {
-      to.reset();
-    }
+// Serializes base ColumnStatistics fields to proto.
+void baseToProto(
+    const dwio::common::ColumnStatistics& builder,
+    ColumnStatisticsWriteWrapper& stats) {
+  if (builder.hasNull().has_value()) {
+    stats.setHasNull(builder.hasNull().value());
   }
-}
-
-template <typename T>
-static void mergeMin(std::optional<T>& to, const std::optional<T>& from) {
-  if (to.has_value()) {
-    if (!from.has_value()) {
-      to.reset();
-    } else if (from.value() < to.value()) {
-      to = from;
-    }
+  if (builder.getNumberOfValues().has_value()) {
+    stats.setNumberOfValues(builder.getNumberOfValues().value());
   }
-}
-
-template <typename T>
-static void mergeMax(std::optional<T>& to, const std::optional<T>& from) {
-  if (to.has_value()) {
-    if (!from.has_value()) {
-      to.reset();
-    } else if (from.value() > to.value()) {
-      to = from;
-    }
+  if (builder.getRawSize().has_value()) {
+    stats.setRawSize(builder.getRawSize().value());
+  }
+  if (builder.getSize().has_value()) {
+    stats.setSize(builder.getSize().value());
   }
 }
 
 } // namespace
 
-void StatisticsBuilder::merge(
-    const dwio::common::ColumnStatistics& other,
-    bool ignoreSize) {
-  // Merge valueCount_ only if both sides have it. Otherwise, reset.
-  mergeCount(valueCount_, other.getNumberOfValues());
-
-  // Merge hasNull_. Follow below rule:
-  // self / other => result
-  // true / any => true
-  // unknown / true => true
-  // unknown / unknown or false => unknown
-  // false / unknown => unknown
-  // false / false => false
-  // false / true => true
-  if (!hasNull_.has_value() || !hasNull_.value()) {
-    auto otherHasNull = other.hasNull();
-    if (otherHasNull.has_value()) {
-      if (otherHasNull.value()) {
-        // other is true, set to true
-        hasNull_ = true;
-      }
-      // when other is false, no change is needed
-    } else if (hasNull_.has_value()) {
-      // self value is false and other is unknown, set to unknown
-      hasNull_.reset();
-    }
-  }
-  // Merge rawSize_ the way similar to valueCount_
-  mergeCount(rawSize_, other.getRawSize());
-  if (!ignoreSize) {
-    // Merge size
-    mergeCount(size_, other.getSize());
-  }
-  if (hll_) {
-    auto* otherBuilder = dynamic_cast<const StatisticsBuilder*>(&other);
-    VELOX_CHECK_NOT_NULL(otherBuilder);
-    VELOX_CHECK_NOT_NULL(otherBuilder->hll_);
-    hll_->mergeWith(*otherBuilder->hll_);
-  }
-}
-
-void StatisticsBuilder::toProto(proto::ColumnStatistics& stats) const {
-  if (hasNull_.has_value()) {
-    stats.set_hasnull(hasNull_.value());
-  }
-  if (valueCount_.has_value()) {
-    stats.set_numberofvalues(valueCount_.value());
-  }
-  if (rawSize_.has_value()) {
-    stats.set_rawsize(rawSize_.value());
-  }
-  if (size_.has_value()) {
-    stats.set_size(size_.value());
-  }
+void StatisticsBuilder::toProto(ColumnStatisticsWriteWrapper& stats) const {
+  baseToProto(*this, stats);
 }
 
 std::unique_ptr<dwio::common::ColumnStatistics> StatisticsBuilder::build()
     const {
-  proto::ColumnStatistics stats;
+  auto columnStatistics = ArenaCreate<proto::ColumnStatistics>(arena_.get());
+  auto stats = ColumnStatisticsWriteWrapper(columnStatistics);
   toProto(stats);
+
   StatsContext context{WriterVersion_CURRENT};
-  auto result =
-      buildColumnStatisticsFromProto(ColumnStatisticsWrapper(&stats), context);
+  auto result = buildColumnStatisticsFromProto(
+      ColumnStatisticsWrapper(columnStatistics), context);
   // We do not alter the proto since this is part of the file format
   // and the file format. The distinct count does not exist in the
   // file format but is added here for use in on demand sampling.
@@ -208,204 +147,106 @@ void StatisticsBuilder::createTree(
       DWIO_RAISE("Not supported type: ", kind);
       break;
   }
-  return;
-};
-
-void BooleanStatisticsBuilder::merge(
-    const dwio::common::ColumnStatistics& other,
-    bool ignoreSize) {
-  StatisticsBuilder::merge(other, ignoreSize);
-  auto stats =
-      dynamic_cast<const dwio::common::BooleanColumnStatistics*>(&other);
-  if (!stats) {
-    // We only care about the case when type specific stats is missing yet
-    // it has non-null values.
-    if (!isEmpty(other) && trueCount_.has_value()) {
-      trueCount_.reset();
-    }
-    return;
-  }
-
-  // Now the case when both sides have type specific stats
-  mergeCount(trueCount_, stats->getTrueCount());
 }
 
-void BooleanStatisticsBuilder::toProto(proto::ColumnStatistics& stats) const {
-  StatisticsBuilder::toProto(stats);
-  // Serialize type specific stats only if there is non-null values
-  if (!isEmpty(*this) && trueCount_.has_value()) {
-    auto bStats = stats.mutable_bucketstatistics();
-    DWIO_ENSURE_EQ(bStats->count_size(), 0);
-    bStats->add_count(trueCount_.value());
+void BooleanStatisticsBuilder::toProto(
+    ColumnStatisticsWriteWrapper& stats) const {
+  baseToProto(*this, stats);
+  if (!isAllNull() && trueCount_.has_value()) {
+    auto bStats = stats.mutableBucketStatistics();
+    DWIO_ENSURE_EQ(bStats.countSize(), 0);
+    bStats.addCount(trueCount_.value());
   }
 }
 
-void IntegerStatisticsBuilder::merge(
-    const dwio::common::ColumnStatistics& other,
-    bool ignoreSize) {
-  StatisticsBuilder::merge(other, ignoreSize);
-  auto stats =
-      dynamic_cast<const dwio::common::IntegerColumnStatistics*>(&other);
-  if (!stats) {
-    // We only care about the case when type specific stats is missing yet
-    // it has non-null values.
-    if (!isEmpty(other)) {
-      min_.reset();
-      max_.reset();
-      sum_.reset();
-    }
-    return;
-  }
-
-  // Now the case when both sides have type specific stats
-  mergeMin(min_, stats->getMinimum());
-  mergeMax(max_, stats->getMaximum());
-  mergeWithOverflowCheck(sum_, stats->getSum());
-}
-
-void IntegerStatisticsBuilder::toProto(proto::ColumnStatistics& stats) const {
-  StatisticsBuilder::toProto(stats);
-  // Serialize type specific stats only if there is non-null values
-  if (!isEmpty(*this) &&
+void IntegerStatisticsBuilder::toProto(
+    ColumnStatisticsWriteWrapper& stats) const {
+  baseToProto(*this, stats);
+  if (!isAllNull() &&
       (min_.has_value() || max_.has_value() || sum_.has_value())) {
-    auto iStats = stats.mutable_intstatistics();
+    auto iStats = stats.mutableIntegerStatistics();
     if (min_.has_value()) {
-      iStats->set_minimum(min_.value());
+      iStats.setMinimum(min_.value());
     }
     if (max_.has_value()) {
-      iStats->set_maximum(max_.value());
+      iStats.setMaximum(max_.value());
     }
     if (sum_.has_value()) {
-      iStats->set_sum(sum_.value());
-    }
-  }
-}
-
-void DoubleStatisticsBuilder::merge(
-    const dwio::common::ColumnStatistics& other,
-    bool ignoreSize) {
-  StatisticsBuilder::merge(other, ignoreSize);
-  auto stats =
-      dynamic_cast<const dwio::common::DoubleColumnStatistics*>(&other);
-  if (!stats) {
-    // We only care about the case when type specific stats is missing yet
-    // it has non-null values.
-    if (!isEmpty(other)) {
-      clear();
+      iStats.setSum(sum_.value());
     }
-    return;
-  }
-
-  // Now the case when both sides have type specific stats
-  mergeMin(min_, stats->getMinimum());
-  mergeMax(max_, stats->getMaximum());
-  mergeCount(sum_, stats->getSum());
-  if (sum_.has_value() && std::isnan(sum_.value())) {
-    sum_.reset();
   }
 }
 
-void DoubleStatisticsBuilder::toProto(proto::ColumnStatistics& stats) const {
-  StatisticsBuilder::toProto(stats);
-  // Serialize type specific stats only if there is non-null values
-  if (!isEmpty(*this) &&
+void DoubleStatisticsBuilder::toProto(
+    ColumnStatisticsWriteWrapper& stats) const {
+  baseToProto(*this, stats);
+  if (!isAllNull() &&
       (min_.has_value() || max_.has_value() || sum_.has_value())) {
-    auto dStats = stats.mutable_doublestatistics();
+    auto dStats = stats.mutableDoubleStatistics();
     if (min_.has_value()) {
-      dStats->set_minimum(min_.value());
+      dStats.setMinimum(min_.value());
     }
     if (max_.has_value()) {
-      dStats->set_maximum(max_.value());
+      dStats.setMaximum(max_.value());
     }
     if (sum_.has_value()) {
-      dStats->set_sum(sum_.value());
+      dStats.setSum(sum_.value());
     }
   }
 }
 
-void StringStatisticsBuilder::merge(
-    const dwio::common::ColumnStatistics& other,
-    bool ignoreSize) {
-  // min_/max_ is not initialized with default that can be compared against
-  // easily. So we need to capture whether self is empty and handle
-  // differently.
-  auto isSelfEmpty = isEmpty(*this);
-  StatisticsBuilder::merge(other, ignoreSize);
-  auto stats =
-      dynamic_cast<const dwio::common::StringColumnStatistics*>(&other);
-  if (!stats) {
-    // We only care about the case when type specific stats is missing yet
-    // it has non-null values.
-    if (!isEmpty(other)) {
-      min_.reset();
-      max_.reset();
-      length_.reset();
-    }
-    return;
-  }
-
-  // If the other stats is empty, there is nothing to merge at string stats
-  // level.
-  if (isEmpty(other)) {
-    return;
-  }
-
-  if (isSelfEmpty) {
-    min_ = stats->getMinimum();
-    max_ = stats->getMaximum();
-  } else {
-    mergeMin(min_, stats->getMinimum());
-    mergeMax(max_, stats->getMaximum());
-  }
-
-  mergeWithOverflowCheck(length_, stats->getTotalLength());
-}
-
-void StringStatisticsBuilder::toProto(proto::ColumnStatistics& stats) const {
-  StatisticsBuilder::toProto(stats);
-  // If string value is too long, drop it and fall back to basic stats
-  if (!isEmpty(*this) &&
+void StringStatisticsBuilder::toProto(
+    ColumnStatisticsWriteWrapper& stats) const {
+  baseToProto(*this, stats);
+  if (!isAllNull() &&
       (shouldKeep(min_) || shouldKeep(max_) || isValidLength(length_))) {
-    auto dStats = stats.mutable_stringstatistics();
+    auto dStats = stats.mutableStringStatistics();
     if (isValidLength(length_)) {
-      dStats->set_sum(length_.value());
+      dStats.setSum(length_.value());
     }
 
     if (shouldKeep(min_)) {
-      dStats->set_minimum(min_.value());
+      dStats.setMinimum(min_.value());
     }
 
     if (shouldKeep(max_)) {
-      dStats->set_maximum(max_.value());
+      dStats.setMaximum(max_.value());
     }
   }
 }
 
-void BinaryStatisticsBuilder::merge(
-    const dwio::common::ColumnStatistics& other,
-    bool ignoreSize) {
-  StatisticsBuilder::merge(other, ignoreSize);
-  auto stats =
-      dynamic_cast<const dwio::common::BinaryColumnStatistics*>(&other);
-  if (!stats) {
-    // We only care about the case when type specific stats is missing yet
-    // it has non-null values.
-    if (!isEmpty(other) && length_.has_value()) {
-      length_.reset();
-    }
-    return;
+void BinaryStatisticsBuilder::toProto(
+    ColumnStatisticsWriteWrapper& stats) const {
+  baseToProto(*this, stats);
+  if (!isAllNull() && isValidLength(length_)) {
+    auto bStats = stats.mutableBinaryStatistics();
+    bStats.setSum(length_.value());
   }
-
-  mergeWithOverflowCheck(length_, stats->getTotalLength());
 }
 
-void BinaryStatisticsBuilder::toProto(proto::ColumnStatistics& stats) const {
-  StatisticsBuilder::toProto(stats);
-  // Serialize type specific stats only if there is non-null values
-  if (!isEmpty(*this) && isValidLength(length_)) {
-    auto bStats = stats.mutable_binarystatistics();
-    bStats->set_sum(length_.value());
+dwio::common::KeyInfo MapStatisticsBuilder::constructKey(
+    const dwrf::proto::KeyInfo& keyInfo) {
+  if (keyInfo.has_intkey()) {
+    return dwio::common::KeyInfo{keyInfo.intkey()};
+  } else if (keyInfo.has_byteskey()) {
+    return dwio::common::KeyInfo{keyInfo.byteskey()};
   }
+  VELOX_UNREACHABLE("Illegal null key info");
+}
+
+void MapStatisticsBuilder::addValues(
+    const dwrf::proto::KeyInfo& keyInfo,
+    const StatisticsBuilder& stats) {
+  auto& keyStats = getKeyStats(MapStatisticsBuilder::constructKey(keyInfo));
+  keyStats.merge(stats, /*ignoreSize=*/true);
+}
+
+void MapStatisticsBuilder::incrementSize(
+    const dwrf::proto::KeyInfo& keyInfo,
+    uint64_t size) {
+  auto& keyStats = getKeyStats(MapStatisticsBuilder::constructKey(keyInfo));
+  keyStats.ensureSize();
+  keyStats.incrementSize(size);
 }
 
 void MapStatisticsBuilder::merge(
@@ -414,9 +255,7 @@ void MapStatisticsBuilder::merge(
   StatisticsBuilder::merge(other, ignoreSize);
   auto stats = dynamic_cast<const dwio::common::MapColumnStatistics*>(&other);
   if (!stats) {
-    // We only care about the case when type specific stats is missing yet
-    // it has non-null values.
-    if (!isEmpty(other) && !entryStatistics_.empty()) {
+    if (!other.isAllNull() && !entryStatistics_.empty()) {
       entryStatistics_.clear();
     }
     return;
@@ -427,21 +266,20 @@ void MapStatisticsBuilder::merge(
   }
 }
 
-void MapStatisticsBuilder::toProto(proto::ColumnStatistics& stats) const {
+void MapStatisticsBuilder::toProto(ColumnStatisticsWriteWrapper& stats) const {
   StatisticsBuilder::toProto(stats);
-  if (!isEmpty(*this) && !entryStatistics_.empty()) {
-    auto mapStats = stats.mutable_mapstatistics();
+  if (!isAllNull() && !entryStatistics_.empty()) {
+    auto mapStats = stats.mutableMapStatistics();
     for (const auto& entry : entryStatistics_) {
       auto entryStatistics = mapStats->add_stats();
       const auto& key = entry.first;
-      // Sets the corresponding key. Leave null keys null.
       if (key.intKey.has_value()) {
         entryStatistics->mutable_key()->set_intkey(key.intKey.value());
       } else if (key.bytesKey.has_value()) {
         entryStatistics->mutable_key()->set_byteskey(key.bytesKey.value());
       }
-      dynamic_cast<const StatisticsBuilder&>(*entry.second)
-          .toProto(*entryStatistics->mutable_stats());
+      auto c = ColumnStatisticsWriteWrapper(entryStatistics->mutable_stats());
+      dynamic_cast<const StatisticsBuilder&>(*entry.second).toProto(c);
     }
   }
 }
diff --git a/velox/dwio/dwrf/writer/StatisticsBuilder.h b/velox/dwio/dwrf/writer/StatisticsBuilder.h
index 3441a5ddf9a..7d278163455 100644
--- a/velox/dwio/dwrf/writer/StatisticsBuilder.h
+++ b/velox/dwio/dwrf/writer/StatisticsBuilder.h
@@ -16,425 +16,136 @@
 
 #pragma once
 
-#include <velox/common/base/Exceptions.h>
-#include <velox/common/hyperloglog/SparseHll.h>
+#include "velox/dwio/common/StatisticsBuilder.h"
 #include "velox/dwio/dwrf/common/Config.h"
 #include "velox/dwio/dwrf/common/Statistics.h"
 #include "velox/dwio/dwrf/common/wrap/dwrf-proto-wrapper.h"
-#include "velox/type/Type.h"
 
 namespace facebook::velox::dwrf {
 
-namespace {
-inline bool isEmpty(const dwio::common::ColumnStatistics& stats) {
-  auto valueCount = stats.getNumberOfValues();
-  return valueCount.has_value() && valueCount.value() == 0;
-}
-
-template <typename T>
-static void
-addWithOverflowCheck(std::optional<T>& to, T value, uint64_t count) {
-  if (to.has_value()) {
-    // check overflow. Value is only valid when not overflow
-    T result;
-    auto overflow = __builtin_mul_overflow(value, count, &result);
-    if (!overflow) {
-      overflow = __builtin_add_overflow(to.value(), result, &to.value());
-    }
-    if (overflow) {
-      to.reset();
-    }
-  }
-}
-
-template <typename T>
-static void mergeWithOverflowCheck(
-    std::optional<T>& to,
-    const std::optional<T>& from) {
-  if (to.has_value()) {
-    if (from.has_value()) {
-      auto overflow =
-          __builtin_add_overflow(to.value(), from.value(), &to.value());
-      if (overflow) {
-        to.reset();
-      }
-    } else {
-      to.reset();
-    }
-  }
-}
-
-inline dwio::common::KeyInfo constructKey(const dwrf::proto::KeyInfo& keyInfo) {
-  if (keyInfo.has_intkey()) {
-    return dwio::common::KeyInfo{keyInfo.intkey()};
-  } else if (keyInfo.has_byteskey()) {
-    return dwio::common::KeyInfo{keyInfo.byteskey()};
-  }
-  VELOX_UNREACHABLE("Illegal null key info");
-}
-} // namespace
-
-struct StatisticsBuilderOptions {
-  explicit StatisticsBuilderOptions(
-      uint32_t stringLengthLimit,
-      std::optional<uint64_t> initialSize = std::nullopt,
-      bool countDistincts = false,
-      HashStringAllocator* allocator = nullptr)
-      : stringLengthLimit{stringLengthLimit},
-        initialSize{initialSize},
-        countDistincts(countDistincts),
-        allocator(allocator) {}
-
-  uint32_t stringLengthLimit;
-  std::optional<uint64_t> initialSize;
-  bool countDistincts{false};
-  HashStringAllocator* allocator;
-
-  StatisticsBuilderOptions withoutNumDistinct() const {
-    return StatisticsBuilderOptions(stringLengthLimit, initialSize);
-  }
-
-  static StatisticsBuilderOptions fromConfig(const Config& config) {
-    return StatisticsBuilderOptions{config.get(Config::STRING_STATS_LIMIT)};
-  }
-};
+// Re-export common types into dwrf namespace for backward compatibility.
+using dwio::stats::StatisticsBuilderOptions;
 
-/*
- * Base class for stats builder. Stats builder is used in writer and file merge
- * to collect and merge stats.
- * It can also be used for gathering stats in ad hoc sampling. In this case it
- * may also count distinct values if enabled in 'options'.
- */
-class StatisticsBuilder : public virtual dwio::common::ColumnStatistics {
+/// DWRF-specific StatisticsBuilder that adds proto serialization and
+/// proto-based build() on top of the common StatisticsBuilder.
+class StatisticsBuilder : public virtual dwio::stats::StatisticsBuilder {
  public:
-  /// Constructs with 'options'.
   explicit StatisticsBuilder(const StatisticsBuilderOptions& options)
-      : options_{options} {
-    init();
-  }
+      : dwio::stats::StatisticsBuilder(options),
+        arena_(std::make_unique<google::protobuf::Arena>()) {}
 
   ~StatisticsBuilder() override = default;
 
-  void setHasNull() {
-    hasNull_ = true;
-  }
+  /// Serializes statistics to a proto wrapper.
+  virtual void toProto(ColumnStatisticsWriteWrapper& stats) const;
 
-  void increaseValueCount(uint64_t count = 1) {
-    if (valueCount_.has_value()) {
-      valueCount_.value() += count;
-    }
-  }
-
-  void increaseRawSize(uint64_t rawSize) {
-    if (rawSize_.has_value()) {
-      rawSize_.value() += rawSize;
-    }
-  }
-
-  void clearRawSize() {
-    rawSize_.reset();
-  }
-
-  void ensureSize() {
-    if (!size_.has_value()) {
-      size_ = 0;
-    }
-  }
-
-  void incrementSize(uint64_t size) {
-    if (LIKELY(size_.has_value())) {
-      addWithOverflowCheck(size_, size, /*count=*/1);
-    }
-  }
-
-  template <typename T>
-  void addHash(const T& data) {
-    if (hll_) {
-      hll_->insertHash(folly::hasher<T>()(data));
-    }
-  }
-
-  int64_t cardinality() const {
-    VELOX_CHECK_NOT_NULL(hll_);
-    return hll_->cardinality();
-  }
-
-  /*
-   * Merge stats of same type. This is used in writer to aggregate file level
-   * stats.
-   */
-  virtual void merge(
-      const dwio::common::ColumnStatistics& other,
-      bool ignoreSize = false);
-
-  /*
-   * Reset. Used in the place where row index entry level stats in captured.
-   */
-  virtual void reset() {
-    init();
-  }
-
-  /*
-   * Write stats to proto
-   */
-  virtual void toProto(proto::ColumnStatistics& stats) const;
-
-  std::unique_ptr<dwio::common::ColumnStatistics> build() const;
+  /// Builds a read-only ColumnStatistics by round-tripping through proto.
+  std::unique_ptr<dwio::common::ColumnStatistics> build() const override;
 
+  /// Creates a DWRF-specific StatisticsBuilder for the given type. For MAP
+  /// type, returns a MapStatisticsBuilder.
   static std::unique_ptr<StatisticsBuilder> create(
       const Type& type,
       const StatisticsBuilderOptions& options);
 
-  // for the given type tree, create the a list of stat builders
+  /// For the given type tree, creates a list of DWRF stat builders.
   static void createTree(
       std::vector<std::unique_ptr<StatisticsBuilder>>& statBuilders,
       const Type& type,
       const StatisticsBuilderOptions& options);
 
- private:
-  void init() {
-    valueCount_ = 0;
-    hasNull_ = false;
-    rawSize_ = 0;
-    size_ = options_.initialSize;
-    if (options_.countDistincts) {
-      hll_ = std::make_shared<common::hll::SparseHll>(options_.allocator);
-    }
+  /// Creates StatisticsBuilderOptions from a DWRF Config.
+  static StatisticsBuilderOptions optionsFromConfig(const Config& config) {
+    return StatisticsBuilderOptions{config.get(Config::STRING_STATS_LIMIT)};
   }
 
- protected:
-  StatisticsBuilderOptions options_;
-  std::shared_ptr<common::hll::SparseHll> hll_;
+ private:
+  std::unique_ptr<google::protobuf::Arena> arena_;
 };
 
 class BooleanStatisticsBuilder : public StatisticsBuilder,
-                                 public dwio::common::BooleanColumnStatistics {
+                                 public dwio::stats::BooleanStatisticsBuilder {
  public:
   explicit BooleanStatisticsBuilder(const StatisticsBuilderOptions& options)
-      : StatisticsBuilder{options.withoutNumDistinct()} {
-    init();
-  }
+      : dwio::stats::StatisticsBuilder{options.dropNumDistinct()},
+        StatisticsBuilder{options.dropNumDistinct()},
+        dwio::stats::BooleanStatisticsBuilder{options} {}
 
   ~BooleanStatisticsBuilder() override = default;
 
-  void addValues(bool value, uint64_t count = 1) {
-    increaseValueCount(count);
-    if (trueCount_.has_value() && value) {
-      trueCount_.value() += count;
-    }
-  }
-
-  void merge(
-      const dwio::common::ColumnStatistics& other,
-      bool ignoreSize = false) override;
-
-  void reset() override {
-    StatisticsBuilder::reset();
-    init();
+  std::unique_ptr<dwio::common::ColumnStatistics> build() const override {
+    return StatisticsBuilder::build();
   }
 
-  void toProto(proto::ColumnStatistics& stats) const override;
-
- private:
-  void init() {
-    trueCount_ = 0;
-  }
+  void toProto(ColumnStatisticsWriteWrapper& stats) const override;
 };
 
 class IntegerStatisticsBuilder : public StatisticsBuilder,
-                                 public dwio::common::IntegerColumnStatistics {
+                                 public dwio::stats::IntegerStatisticsBuilder {
  public:
   explicit IntegerStatisticsBuilder(const StatisticsBuilderOptions& options)
-      : StatisticsBuilder{options} {
-    init();
-  }
+      : dwio::stats::StatisticsBuilder{options},
+        StatisticsBuilder{options},
+        dwio::stats::IntegerStatisticsBuilder{options} {}
 
   ~IntegerStatisticsBuilder() override = default;
 
-  void addValues(int64_t value, uint64_t count = 1) {
-    increaseValueCount(count);
-    if (min_.has_value() && value < min_.value()) {
-      min_ = value;
-    }
-    if (max_.has_value() && value > max_.value()) {
-      max_ = value;
-    }
-    addWithOverflowCheck(sum_, value, count);
-    addHash(value);
-  }
-
-  void merge(
-      const dwio::common::ColumnStatistics& other,
-      bool ignoreSize = false) override;
-
-  void reset() override {
-    StatisticsBuilder::reset();
-    init();
+  std::unique_ptr<dwio::common::ColumnStatistics> build() const override {
+    return StatisticsBuilder::build();
   }
 
-  void toProto(proto::ColumnStatistics& stats) const override;
-
- private:
-  void init() {
-    min_ = std::numeric_limits<int64_t>::max();
-    max_ = std::numeric_limits<int64_t>::min();
-    sum_ = 0;
-  }
+  void toProto(ColumnStatisticsWriteWrapper& stats) const override;
 };
 
-static_assert(
-    std::numeric_limits<double>::has_infinity,
-    "infinity not defined");
-
 class DoubleStatisticsBuilder : public StatisticsBuilder,
-                                public dwio::common::DoubleColumnStatistics {
+                                public dwio::stats::DoubleStatisticsBuilder {
  public:
   explicit DoubleStatisticsBuilder(const StatisticsBuilderOptions& options)
-      : StatisticsBuilder{options} {
-    init();
-  }
+      : dwio::stats::StatisticsBuilder{options},
+        StatisticsBuilder{options},
+        dwio::stats::DoubleStatisticsBuilder{options} {}
 
   ~DoubleStatisticsBuilder() override = default;
 
-  void addValues(double value, uint64_t count = 1) {
-    increaseValueCount(count);
-    // min/max/sum is defined only when none of the values added is NaN
-    if (std::isnan(value)) {
-      clear();
-      return;
-    }
-
-    if (min_.has_value() && value < min_.value()) {
-      min_ = value;
-    }
-    if (max_.has_value() && value > max_.value()) {
-      max_ = value;
-    }
-    addHash(value);
-    // value * count sometimes is not same as adding values (count) times. So
-    // add in a loop
-    if (sum_.has_value()) {
-      for (uint64_t i = 0; i < count; ++i) {
-        sum_.value() += value;
-      }
-      if (std::isnan(sum_.value())) {
-        sum_.reset();
-      }
-    }
+  std::unique_ptr<dwio::common::ColumnStatistics> build() const override {
+    return StatisticsBuilder::build();
   }
 
-  void merge(
-      const dwio::common::ColumnStatistics& other,
-      bool ignoreSize = false) override;
-
-  void reset() override {
-    StatisticsBuilder::reset();
-    init();
-  }
-
-  void toProto(proto::ColumnStatistics& stats) const override;
-
- private:
-  void init() {
-    min_ = std::numeric_limits<double>::infinity();
-    max_ = -std::numeric_limits<double>::infinity();
-    sum_ = 0;
-  }
-
-  void clear() {
-    min_.reset();
-    max_.reset();
-    sum_.reset();
-  }
+  void toProto(ColumnStatisticsWriteWrapper& stats) const override;
 };
 
 class StringStatisticsBuilder : public StatisticsBuilder,
-                                public dwio::common::StringColumnStatistics {
+                                public dwio::stats::StringStatisticsBuilder {
  public:
   explicit StringStatisticsBuilder(const StatisticsBuilderOptions& options)
-      : StatisticsBuilder{options}, lengthLimit_{options.stringLengthLimit} {
-    init();
-  }
+      : dwio::stats::StatisticsBuilder{options},
+        StatisticsBuilder{options},
+        dwio::stats::StringStatisticsBuilder{options} {}
 
   ~StringStatisticsBuilder() override = default;
 
-  void addValues(folly::StringPiece value, uint64_t count = 1) {
-    // min_/max_ is not initialized with default that can be compared against
-    // easily. So we need to capture whether self is empty and handle
-    // differently.
-    auto isSelfEmpty = isEmpty(*this);
-    increaseValueCount(count);
-    if (isSelfEmpty) {
-      min_ = value;
-      max_ = value;
-    } else {
-      if (min_.has_value() && value < folly::StringPiece{min_.value()}) {
-        min_ = value;
-      }
-      if (max_.has_value() && value > folly::StringPiece{max_.value()}) {
-        max_ = value;
-      }
-    }
-    addHash(value);
-
-    addWithOverflowCheck<uint64_t>(length_, value.size(), count);
+  std::unique_ptr<dwio::common::ColumnStatistics> build() const override {
+    return StatisticsBuilder::build();
   }
 
-  void merge(
-      const dwio::common::ColumnStatistics& other,
-      bool ignoreSize = false) override;
-
-  void reset() override {
-    StatisticsBuilder::reset();
-    init();
-  }
-
-  void toProto(proto::ColumnStatistics& stats) const override;
-
- private:
-  uint32_t lengthLimit_;
-
-  void init() {
-    min_.reset();
-    max_.reset();
-    length_ = 0;
-  }
-
-  bool shouldKeep(const std::optional<std::string>& val) const {
-    return val.has_value() && val.value().size() <= lengthLimit_;
-  }
+  void toProto(ColumnStatisticsWriteWrapper& stats) const override;
 };
 
 class BinaryStatisticsBuilder : public StatisticsBuilder,
-                                public dwio::common::BinaryColumnStatistics {
+                                public dwio::stats::BinaryStatisticsBuilder {
  public:
   explicit BinaryStatisticsBuilder(const StatisticsBuilderOptions& options)
-      : StatisticsBuilder{options.withoutNumDistinct()} {
-    init();
-  }
+      : dwio::stats::StatisticsBuilder{options.dropNumDistinct()},
+        StatisticsBuilder{options.dropNumDistinct()},
+        dwio::stats::BinaryStatisticsBuilder{options} {}
 
   ~BinaryStatisticsBuilder() override = default;
 
-  void addValues(uint64_t length, uint64_t count = 1) {
-    increaseValueCount(count);
-    addWithOverflowCheck(length_, length, count);
-  }
-
-  void merge(
-      const dwio::common::ColumnStatistics& other,
-      bool ignoreSize = false) override;
-
-  void reset() override {
-    StatisticsBuilder::reset();
-    init();
+  std::unique_ptr<dwio::common::ColumnStatistics> build() const override {
+    return StatisticsBuilder::build();
   }
 
-  void toProto(proto::ColumnStatistics& stats) const override;
-
- private:
-  void init() {
-    length_ = 0;
-  }
+  void toProto(ColumnStatisticsWriteWrapper& stats) const override;
 };
 
 class MapStatisticsBuilder : public StatisticsBuilder,
@@ -443,7 +154,8 @@ class MapStatisticsBuilder : public StatisticsBuilder,
   MapStatisticsBuilder(
       const Type& type,
       const StatisticsBuilderOptions& options)
-      : StatisticsBuilder{options},
+      : dwio::stats::StatisticsBuilder{options},
+        StatisticsBuilder{options},
         valueType_{type.as<velox::TypeKind::MAP>().valueType()} {
     init();
     hll_.reset();
@@ -453,20 +165,9 @@ class MapStatisticsBuilder : public StatisticsBuilder,
 
   void addValues(
       const dwrf::proto::KeyInfo& keyInfo,
-      const StatisticsBuilder& stats) {
-    // Since addValues is called once per key info per stride,
-    // it's ok to just construct the key struct per call.
-    auto& keyStats = getKeyStats(constructKey(keyInfo));
-    keyStats.merge(stats, /*ignoreSize=*/true);
-  }
+      const StatisticsBuilder& stats);
 
-  void incrementSize(const dwrf::proto::KeyInfo& keyInfo, uint64_t size) {
-    // Since incrementSize is called once per key info per stripe,
-    // it's ok to just construct the key struct per call.
-    auto& keyStats = getKeyStats(constructKey(keyInfo));
-    keyStats.ensureSize();
-    keyStats.incrementSize(size);
-  }
+  void incrementSize(const dwrf::proto::KeyInfo& keyInfo, uint64_t size);
 
   void merge(
       const dwio::common::ColumnStatistics& other,
@@ -477,7 +178,11 @@ class MapStatisticsBuilder : public StatisticsBuilder,
     init();
   }
 
-  void toProto(proto::ColumnStatistics& stats) const override;
+  void toProto(ColumnStatisticsWriteWrapper& stats) const override;
+
+  /// Converts a proto KeyInfo to a dwio::common::KeyInfo.
+  static dwio::common::KeyInfo constructKey(
+      const dwrf::proto::KeyInfo& keyInfo);
 
  private:
   void init() {
diff --git a/velox/dwio/dwrf/writer/StatisticsBuilderUtils.cpp b/velox/dwio/dwrf/writer/StatisticsBuilderUtils.cpp
index 3babe373db2..89dbcd1cfef 100644
--- a/velox/dwio/dwrf/writer/StatisticsBuilderUtils.cpp
+++ b/velox/dwio/dwrf/writer/StatisticsBuilderUtils.cpp
@@ -81,18 +81,18 @@ void StatisticsBuilderUtils::addValues(
     const VectorPtr& vector,
     const common::Ranges& ranges) {
   auto nulls = vector->rawNulls();
-  auto data = vector->asFlatVector<StringView>()->rawValues();
+  auto* data = vector->asFlatVector<StringView>()->rawValues();
   if (vector->mayHaveNulls()) {
     for (auto& pos : ranges) {
       if (bits::isBitNull(nulls, pos)) {
         builder.setHasNull();
       } else {
-        builder.addValues(folly::StringPiece{data[pos]});
+        builder.addValues(std::string_view{data[pos]});
       }
     }
   } else {
     for (auto& pos : ranges) {
-      builder.addValues(folly::StringPiece{data[pos]});
+      builder.addValues(std::string_view{data[pos]});
     }
   }
 }
diff --git a/velox/dwio/dwrf/writer/StringDictionaryEncoder.h b/velox/dwio/dwrf/writer/StringDictionaryEncoder.h
index 8ecb635f865..20abfaac858 100644
--- a/velox/dwio/dwrf/writer/StringDictionaryEncoder.h
+++ b/velox/dwio/dwrf/writer/StringDictionaryEncoder.h
@@ -30,22 +30,22 @@ namespace detail {
 
 // Each new string inserted into dictionary is assigned an incrementing id.
 // A set is maintained with all of the DictStringId created. Using
-// Heterogeneous lookup techniques, incoming StringPiece is first looked for
+// Heterogeneous lookup techniques, incoming string_view is first looked for
 // a match in the set. If no match exists a new id is generated and inserted
 // into the set. What is Heterogeneous lookup ?
 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0919r1.html
 // Heterogeneous lookup is not available in standard CPP and proposed for CPP20.
 // Follys:F14* variant supports it, so leveraging folly for now.
 struct StringLookupKey {
-  StringLookupKey(folly::StringPiece sp, uint32_t index)
-      : sp{sp},
+  StringLookupKey(std::string_view sv, uint32_t index)
+      : sv{sv},
         index{index},
         hash{folly::crc32c(
-            reinterpret_cast<const uint8_t*>(sp.data()),
-            sp.size(),
+            reinterpret_cast<const uint8_t*>(sv.data()),
+            sv.size(),
             0 /* seed */)} {}
 
-  const folly::StringPiece sp;
+  const std::string_view sv;
   const uint32_t index;
   const uint32_t hash;
 };
@@ -117,9 +117,9 @@ class StringDictionaryEncoder {
   }
 
   uint32_t
-  addKey(folly::StringPiece sp, uint32_t strideIndex, uint32_t count = 1) {
+  addKey(std::string_view sv, uint32_t strideIndex, uint32_t count = 1) {
     auto newIndex = size();
-    detail::StringLookupKey key{sp, newIndex};
+    detail::StringLookupKey key{sv, newIndex};
     auto result = keyIndex_.insert(key);
     if (!result.second) {
       auto index = result.first->getIndex();
@@ -130,12 +130,12 @@ class StringDictionaryEncoder {
     auto bytesCount = keyBytes_.size();
     if (UNLIKELY(
             newIndex == std::numeric_limits<uint32_t>::max() ||
-            (std::numeric_limits<uint32_t>::max() - bytesCount <= sp.size()))) {
+            (std::numeric_limits<uint32_t>::max() - bytesCount <= sv.size()))) {
       DWIO_RAISE("exceeds dictionary size limit");
     }
 
     // append keys
-    keyBytes_.extendAppend(bytesCount, sp.data(), sp.size());
+    keyBytes_.extendAppend(bytesCount, sv.data(), sv.size());
     keyOffsets_.append(keyBytes_.size());
     hash_.append(key.hash);
     counts_.append(count);
@@ -153,11 +153,11 @@ class StringDictionaryEncoder {
     return firstSeenStrideIndex_[index];
   }
 
-  folly::StringPiece getKey(uint32_t index) const {
+  std::string_view getKey(uint32_t index) const {
     DCHECK(index < keyOffsets_.size() - 1);
     auto startOffset = keyOffsets_[index];
     auto endOffset = keyOffsets_[index + 1];
-    return folly::StringPiece{
+    return std::string_view{
         keyBytes_.data() + startOffset, endOffset - startOffset};
   }
 
@@ -178,8 +178,8 @@ class StringDictionaryEncoder {
   VELOX_FRIEND_TEST(TestStringDictionaryEncoder, Clear);
 
   // Intended for testing only.
-  uint32_t getIndex(folly::StringPiece sp) {
-    detail::StringLookupKey key{sp, 0};
+  uint32_t getIndex(std::string_view sv) {
+    detail::StringLookupKey key{sv, 0};
     auto result = keyIndex_.find(key);
     if (result != keyIndex_.end()) {
       return result->getIndex();
@@ -221,7 +221,7 @@ FOLLY_ALWAYS_INLINE bool DictStringIdEquality::operator()(
 FOLLY_ALWAYS_INLINE bool DictStringIdEquality::operator()(
     detail::StringLookupKey key,
     detail::DictStringId lhs) const {
-  return encoder_.getKey(lhs.getIndex()) == key.sp;
+  return encoder_.getKey(lhs.getIndex()) == key.sv;
 }
 
 FOLLY_ALWAYS_INLINE uint32_t
diff --git a/velox/dwio/dwrf/writer/Writer.cpp b/velox/dwio/dwrf/writer/Writer.cpp
index d6011c38f8d..0133522c7ac 100644
--- a/velox/dwio/dwrf/writer/Writer.cpp
+++ b/velox/dwio/dwrf/writer/Writer.cpp
@@ -58,10 +58,12 @@ uint64_t orcWriterMaxStripeSize(
     const config::ConfigBase& config,
     const config::ConfigBase& session) {
   return config::toCapacity(
-      session.get<std::string>(
-          dwrf::Config::kOrcWriterMaxStripeSizeSession,
-          config.get<std::string>(
-              dwrf::Config::kOrcWriterMaxStripeSize, "64MB")),
+      session
+          .getLegacyWithFallback<std::string>(
+              dwrf::Config::kOrcWriterMaxStripeSizeSession,
+              config,
+              dwrf::Config::kOrcWriterMaxStripeSize)
+          .value_or("64MB"),
       config::CapacityUnit::BYTE);
 }
 
@@ -69,68 +71,66 @@ uint64_t orcWriterMaxDictionaryMemory(
     const config::ConfigBase& config,
     const config::ConfigBase& session) {
   return config::toCapacity(
-      session.get<std::string>(
-          dwrf::Config::kOrcWriterMaxDictionaryMemorySession,
-          config.get<std::string>(
-              dwrf::Config::kOrcWriterMaxDictionaryMemory, "16MB")),
+      session
+          .getLegacyWithFallback<std::string>(
+              dwrf::Config::kOrcWriterMaxDictionaryMemorySession,
+              config,
+              dwrf::Config::kOrcWriterMaxDictionaryMemory)
+          .value_or("16MB"),
       config::CapacityUnit::BYTE);
 }
 
 bool isOrcWriterIntegerDictionaryEncodingEnabled(
     const config::ConfigBase& config,
     const config::ConfigBase& session) {
-  return session.get<bool>(
-      dwrf::Config::kOrcWriterIntegerDictionaryEncodingEnabledSession,
-      config.get<bool>(
-          dwrf::Config::kOrcWriterIntegerDictionaryEncodingEnabled, true));
+  return session
+      .getLegacyWithFallback<bool>(
+          dwrf::Config::kOrcWriterIntegerDictionaryEncodingEnabledSession,
+          config,
+          dwrf::Config::kOrcWriterIntegerDictionaryEncodingEnabled)
+      .value_or(true);
 }
 
 bool isOrcWriterStringDictionaryEncodingEnabled(
     const config::ConfigBase& config,
     const config::ConfigBase& session) {
-  return session.get<bool>(
-      dwrf::Config::kOrcWriterStringDictionaryEncodingEnabledSession,
-      config.get<bool>(
-          dwrf::Config::kOrcWriterStringDictionaryEncodingEnabled, true));
+  return session
+      .getLegacyWithFallback<bool>(
+          dwrf::Config::kOrcWriterStringDictionaryEncodingEnabledSession,
+          config,
+          dwrf::Config::kOrcWriterStringDictionaryEncodingEnabled)
+      .value_or(true);
 }
 
 bool orcWriterLinearStripeSizeHeuristics(
     const config::ConfigBase& config,
     const config::ConfigBase& session) {
-  return session.get<bool>(
-      dwrf::Config::kOrcWriterLinearStripeSizeHeuristicsSession,
-      config.get<bool>(
-          dwrf::Config::kOrcWriterLinearStripeSizeHeuristics, true));
+  return session
+      .getLegacyWithFallback<bool>(
+          dwrf::Config::kOrcWriterLinearStripeSizeHeuristicsSession,
+          config,
+          dwrf::Config::kOrcWriterLinearStripeSizeHeuristics)
+      .value_or(true);
 }
 
 uint64_t orcWriterMinCompressionSize(
     const config::ConfigBase& config,
     const config::ConfigBase& session) {
-  return session.get<uint64_t>(
-      dwrf::Config::kOrcWriterMinCompressionSizeSession,
-      config.get<uint64_t>(dwrf::Config::kOrcWriterMinCompressionSize, 1024));
+  return session
+      .getLegacyWithFallback<uint64_t>(
+          dwrf::Config::kOrcWriterMinCompressionSizeSession,
+          config,
+          dwrf::Config::kOrcWriterMinCompressionSize)
+      .value_or(1024);
 }
 
 std::optional<uint8_t> orcWriterCompressionLevel(
     const config::ConfigBase& config,
     const config::ConfigBase& session) {
-  auto sessionProp =
-      session.get<uint8_t>(dwrf::Config::kOrcWriterCompressionLevelSession);
-
-  if (sessionProp.has_value()) {
-    return sessionProp.value();
-  }
-
-  auto configProp =
-      config.get<uint8_t>(dwrf::Config::kOrcWriterCompressionLevel);
-
-  if (configProp.has_value()) {
-    return configProp.value();
-  }
-
-  // Presto has a single config controlling this value, but different defaults
-  // depending on the compression kind.
-  return std::nullopt;
+  return session.getLegacyWithFallback<uint8_t>(
+      dwrf::Config::kOrcWriterCompressionLevelSession,
+      config,
+      dwrf::Config::kOrcWriterCompressionLevel);
 }
 
 uint8_t orcWriterZLIBCompressionLevel(
@@ -175,7 +175,8 @@ Writer::Writer(
       pool,
       options.sessionTimezone,
       options.adjustTimestampToTimezone,
-      std::move(handler));
+      std::move(handler),
+      options.memoryBudget);
   auto& context = writerBase_->getContext();
   VELOX_CHECK_EQ(
       context.getTotalMemoryUsage(),
@@ -213,10 +214,11 @@ Writer::Writer(
     : Writer{
           std::move(sink),
           options,
-          options.memoryPool->addAggregateChild(fmt::format(
-              "{}.dwrf.{}",
-              options.memoryPool->name(),
-              folly::to<std::string>(folly::Random::rand64())))} {}
+          options.memoryPool->addAggregateChild(
+              fmt::format(
+                  "{}.dwrf.{}",
+                  options.memoryPool->name(),
+                  folly::to<std::string>(folly::Random::rand64())))} {}
 
 void Writer::setMemoryReclaimers(
     const std::shared_ptr<memory::MemoryPool>& pool) {
@@ -521,7 +523,7 @@ void Writer::flushStripe(bool close) {
   const auto& handler = context.getEncryptionHandler();
   EncodingManager encodingManager{handler};
 
-  writer_->flush([&](uint32_t nodeId) -> proto::ColumnEncoding& {
+  writer_->flush([&](uint32_t nodeId) -> ColumnEncodingWriteWrapper {
     return encodingManager.addEncodingToFooter(nodeId);
   });
 
@@ -546,7 +548,8 @@ void Writer::flushStripe(bool close) {
                              const DataBufferHolder& out) {
     uint32_t currentIndex = 0;
     const auto nodeId = stream.encodingKey().node();
-    proto::Stream* s = encodingManager.addStreamToFooter(nodeId, currentIndex);
+    StreamWriteWrapper s =
+        encodingManager.addStreamToFooter(nodeId, currentIndex);
 
     // set offset only when needed, ie. when offset of current stream cannot be
     // calculated based on offset and length of previous stream. In that case,
@@ -554,19 +557,19 @@ void Writer::flushStripe(bool close) {
     // encryption group or neither are encrypted. So the logic is simplified to
     // check if group index are the same for current and previous stream
     if (offset > 0 && lastIndex != currentIndex) {
-      s->set_offset(offset);
+      s.setOffset(offset);
     }
     lastIndex = currentIndex;
 
     // Jolly/Presto readers can't read streams bigger than 2GB.
     writerBase_->validateStreamSize(stream, out.size());
 
-    s->set_kind(static_cast<proto::Stream_Kind>(stream.kind()));
-    s->set_node(nodeId);
-    s->set_column(stream.column());
-    s->set_sequence(stream.encodingKey().sequence());
-    s->set_length(out.size());
-    s->set_usevints(context.getConfig(Config::USE_VINTS));
+    s.setKind(stream.kind());
+    s.setNode(nodeId);
+    s.setColumn(stream.column());
+    s.setSequence(stream.encodingKey().sequence());
+    s.setLength(out.size());
+    s.setUseVints(context.getConfig(Config::USE_VINTS));
     offset += out.size();
 
     context.recordPhysicalSize(stream, out.size());
@@ -619,19 +622,20 @@ void Writer::flushStripe(bool close) {
   VELOX_CHECK_EQ(footerOffset, stripeOffset + dataLength + indexLength);
 
   sink.setMode(WriterSink::Mode::Footer);
-  writerBase_->writeProto(encodingManager.getFooter());
+  encodingManager.getFooter().setWriterTimezone();
+  writerBase_->writeProto(&encodingManager.getFooter());
   sink.setMode(WriterSink::Mode::None);
 
-  auto& stripe = writerBase_->addStripeInfo();
-  stripe.set_offset(stripeOffset);
-  stripe.set_indexlength(indexLength);
-  stripe.set_datalength(dataLength);
-  stripe.set_footerlength(sink.size() - footerOffset);
+  auto stripe = writerBase_->addStripeInfo();
+  stripe.setOffset(stripeOffset);
+  stripe.setIndexLength(indexLength);
+  stripe.setDataLength(dataLength);
+  stripe.setFooterLength(sink.size() - footerOffset);
 
   // set encryption key metadata
   if (handler.isEncrypted() && context.stripeIndex() == 0) {
     for (uint32_t i = 0; i < handler.getEncryptionGroupCount(); ++i) {
-      *stripe.add_keymetadata() =
+      *stripe.addKeyMetadata() =
           handler.getEncryptionProviderByIndex(i).getKey();
     }
   }
@@ -694,10 +698,10 @@ void Writer::flushInternal(bool close) {
       proto::Encryption* encryption = nullptr;
 
       // initialize encryption related metadata only when there is data written
-      if (handler.isEncrypted() && footer.stripes_size() > 0) {
+      if (handler.isEncrypted() && footer->stripesSize() > 0) {
         const auto count = handler.getEncryptionGroupCount();
         stats.resize(count);
-        encryption = footer.mutable_encryption();
+        encryption = footer->mutableEncryption();
         encryption->set_keyprovider(
             encryption::toProto(handler.getKeyProviderType()));
         for (uint32_t i = 0; i < count; ++i) {
@@ -708,25 +712,28 @@ void Writer::flushInternal(bool close) {
       std::optional<uint32_t> lastRoot;
       std::unordered_map<proto::ColumnStatistics*, proto::ColumnStatistics*>
           statsMap;
-      writer_->writeFileStats([&](uint32_t nodeId) -> proto::ColumnStatistics& {
-        auto entry = footer.add_statistics();
-        if (!encryption || !handler.isEncrypted(nodeId)) {
-          return *entry;
-        }
+      writer_->writeFileStats(
+          [&](uint32_t nodeId) -> ColumnStatisticsWriteWrapper {
+            auto entry = footer->addStatistics();
+            if (!encryption || !handler.isEncrypted(nodeId)) {
+              return entry;
+            }
 
-        auto root = handler.getEncryptionRoot(nodeId);
-        auto groupIndex = handler.getEncryptionGroupIndex(nodeId);
-        auto& group = stats.at(groupIndex);
-        if (!lastRoot || root != lastRoot.value()) {
-          // this is a new root, add to the footer, and use a new slot
-          group.emplace_back();
-          encryption->mutable_encryptiongroups(groupIndex)->add_nodes(root);
-        }
-        lastRoot = root;
-        auto encryptedStats = group.back().add_statistics();
-        statsMap[entry] = encryptedStats;
-        return *encryptedStats;
-      });
+            auto root = handler.getEncryptionRoot(nodeId);
+            auto groupIndex = handler.getEncryptionGroupIndex(nodeId);
+            auto& group = stats.at(groupIndex);
+            if (!lastRoot || root != lastRoot.value()) {
+              // this is a new root, add to the footer, and use a new slot
+              group.emplace_back();
+              encryption->mutable_encryptiongroups(groupIndex)->add_nodes(root);
+            }
+            lastRoot = root;
+            auto encryptedStats = group.back().add_statistics();
+            auto cs =
+                reinterpret_cast<proto::ColumnStatistics*>(entry.rawProtoPtr());
+            statsMap[cs] = encryptedStats;
+            return ColumnStatisticsWriteWrapper(encryptedStats);
+          });
 
 #define COPY_STAT(from, to, stat) \
   if (from->has_##stat()) {       \
@@ -770,7 +777,7 @@ void Writer::flushInternal(bool close) {
         dwio::common::MetricsLog::FileCloseMetrics{
             .writerVersion = writerVersionToString(
                 context.getConfig(Config::WRITER_VERSION)),
-            .footerLength = footer.contentlength(),
+            .footerLength = footer->contentLength(),
             .fileSize = sink.size(),
             .cacheSize = sink.getCacheSize(),
             .numCacheBlocks = sink.getCacheOffsets().size() - 1,
@@ -792,7 +799,7 @@ void Writer::flush() {
   flushInternal(false);
 }
 
-void Writer::close() {
+std::unique_ptr<dwio::common::FileMetadata> Writer::close() {
   checkRunning();
   auto exitGuard = folly::makeGuard([this]() {
     flushPolicy_->onClose();
@@ -800,6 +807,7 @@ void Writer::close() {
   });
   flushInternal(true);
   writerBase_->close();
+  return std::make_unique<DwrfFileMetadata>();
 }
 
 void Writer::abort() {
@@ -853,13 +861,22 @@ uint64_t Writer::MemoryReclaimer::reclaim(
     LOG(WARNING)
         << "Can't reclaim from dwrf writer which is under non-reclaimable "
            "section: "
-        << pool->name();
+        << pool->name() << ", root pool: " << pool->root()->name()
+        << ", used: " << succinctBytes(pool->usedBytes())
+        << ", reservation: " << succinctBytes(pool->reservedBytes())
+        << ", root pool reservation: "
+        << succinctBytes(pool->root()->reservedBytes());
     ++stats.numNonReclaimableAttempts;
     return 0;
   }
   if (!writer_->isRunning()) {
     LOG(WARNING) << "Can't reclaim from a not running dwrf writer: "
-                 << pool->name() << ", state: " << writer_->state();
+                 << pool->name() << ", root pool: " << pool->root()->name()
+                 << ", state: " << writer_->state()
+                 << ", used: " << succinctBytes(pool->usedBytes())
+                 << ", reservation: " << succinctBytes(pool->reservedBytes())
+                 << ", root pool reservation: "
+                 << succinctBytes(pool->root()->reservedBytes());
     ++stats.numNonReclaimableAttempts;
     return 0;
   }
diff --git a/velox/dwio/dwrf/writer/Writer.h b/velox/dwio/dwrf/writer/Writer.h
index 3864b57790d..847c0ac3045 100644
--- a/velox/dwio/dwrf/writer/Writer.h
+++ b/velox/dwio/dwrf/writer/Writer.h
@@ -19,6 +19,7 @@
 #include <iterator>
 #include <limits>
 
+#include "velox/dwio/common/FileMetadata.h"
 #include "velox/dwio/common/Writer.h"
 #include "velox/dwio/common/WriterFactory.h"
 #include "velox/dwio/dwrf/common/Encryption.h"
@@ -30,6 +31,9 @@
 
 namespace facebook::velox::dwrf {
 
+/// DWRF-specific file metadata wrapper. Currently a placeholder.
+class DwrfFileMetadata : public dwio::common::FileMetadata {};
+
 struct WriterOptions : public dwio::common::WriterOptions {
   std::shared_ptr<const Config> config = std::make_shared<Config>();
   /// Changes the interface to stream list and encoding iter.
@@ -60,10 +64,11 @@ class Writer : public dwio::common::Writer {
       : Writer{
             std::move(sink),
             options,
-            parentPool.addAggregateChild(fmt::format(
-                "{}.dwrf_{}",
-                parentPool.name(),
-                folly::to<std::string>(folly::Random::rand64())))} {}
+            parentPool.addAggregateChild(
+                fmt::format(
+                    "{}.dwrf_{}",
+                    parentPool.name(),
+                    folly::to<std::string>(folly::Random::rand64())))} {}
 
   Writer(
       std::unique_ptr<dwio::common::FileSink> sink,
@@ -85,7 +90,7 @@ class Writer : public dwio::common::Writer {
     return true;
   }
 
-  virtual void close() override;
+  virtual std::unique_ptr<dwio::common::FileMetadata> close() override;
 
   virtual void abort() override;
 
@@ -134,7 +139,7 @@ class Writer : public dwio::common::Writer {
     return writerBase_->getContext();
   }
 
-  const proto::Footer& getFooter() const {
+  const std::unique_ptr<FooterWriteWrapper>& getFooter() const {
     return writerBase_->getFooter();
   }
 
diff --git a/velox/dwio/dwrf/writer/WriterBase.cpp b/velox/dwio/dwrf/writer/WriterBase.cpp
index 6fd51477d04..dd182917661 100644
--- a/velox/dwio/dwrf/writer/WriterBase.cpp
+++ b/velox/dwio/dwrf/writer/WriterBase.cpp
@@ -22,8 +22,8 @@ namespace facebook::velox::dwrf {
 
 void WriterBase::writeFooter(const Type& type) {
   auto pos = writerSink_->size();
-  footer_.set_headerlength(ORC_MAGIC_LEN);
-  footer_.set_contentlength(pos - ORC_MAGIC_LEN);
+  footer_->setHeaderLength(ORC_MAGIC_LEN);
+  footer_->setContentLength(pos - ORC_MAGIC_LEN);
   writerSink_->setMode(WriterSink::Mode::None);
 
   // write cache when available
@@ -31,45 +31,46 @@ void WriterBase::writeFooter(const Type& type) {
   if (cacheSize > 0) {
     writerSink_->writeCache();
     for (auto& i : writerSink_->getCacheOffsets()) {
-      footer_.add_stripecacheoffsets(i);
+      footer_->addStripeCacheOffsets(i);
     }
     pos = writerSink_->size();
   }
 
-  ProtoUtils::writeType(type, footer_);
-  DWIO_ENSURE_EQ(footer_.types_size(), footer_.statistics_size());
+  ProtoUtils::writeType(type, *footer_);
+  DWIO_ENSURE_EQ(footer_->typesSize(), footer_->statisticsSize());
   auto writerVersion =
       static_cast<uint32_t>(context_->getConfig(Config::WRITER_VERSION));
   writeUserMetadata(writerVersion);
-  footer_.set_numberofrows(context_->fileRowCount());
-  footer_.set_rowindexstride(context_->indexStride());
+  footer_->setNumberOfRows(context_->fileRowCount());
+  footer_->setRowIndexStride(context_->indexStride());
 
   if (context_->fileRawSize() > 0 || context_->fileRowCount() == 0) {
     // ColumnTransformWriter, when rewriting presto written file does not have
     // rawSize.
-    footer_.set_rawdatasize(context_->fileRawSize());
+    footer_->setRawDataSize(context_->fileRawSize());
   }
   auto* checksum = writerSink_->getChecksum();
-  footer_.set_checksumalgorithm(
+  footer_->setCheckSumAlgorithm(
       (checksum != nullptr) ? checksum->getType()
                             : proto::ChecksumAlgorithm::NULL_);
-  writeProto(footer_);
+  writeProto(footer_->getDwrfPtr());
   const auto footerLength = writerSink_->size() - pos;
 
   // write postscript
   pos = writerSink_->size();
-  proto::PostScript ps;
-  ps.set_writerversion(writerVersion);
-  ps.set_footerlength(footerLength);
-  ps.set_compression(
-      static_cast<proto::CompressionKind>(context_->compression()));
+  auto dwrfPostScript = ArenaCreate<proto::PostScript>(arena_.get());
+  std::unique_ptr<PostScriptWriteWrapper> ps =
+      std::make_unique<PostScriptWriteWrapper>(dwrfPostScript);
+  ps->setWriterVersion(writerVersion);
+  ps->setFooterLength(footerLength);
+  ps->setCompression(context_->compression());
   if (context_->compression() !=
       common::CompressionKind::CompressionKind_NONE) {
-    ps.set_compressionblocksize(context_->compressionBlockSize());
+    ps->setCompressionBlockSize(context_->compressionBlockSize());
   }
-  ps.set_cachemode(
-      static_cast<proto::StripeCacheMode>(writerSink_->getCacheMode()));
-  ps.set_cachesize(cacheSize);
+
+  ps->setCacheMode(writerSink_->getCacheMode());
+  ps->setCacheSize(cacheSize);
   writeProto(ps, common::CompressionKind::CompressionKind_NONE);
   auto psLength = writerSink_->size() - pos;
   DWIO_ENSURE_LE(psLength, 0xff, "PostScript is too large: ", psLength);
@@ -80,14 +81,14 @@ void WriterBase::writeFooter(const Type& type) {
 
 void WriterBase::writeUserMetadata(uint32_t writerVersion) {
   // add writer version
-  userMetadata_[std::string{WRITER_NAME_KEY}] = kDwioWriter;
-  userMetadata_[std::string{WRITER_VERSION_KEY}] =
+  userMetadata_[std::string{kWriterNameKey}] = kDwioWriter;
+  userMetadata_[std::string{kWriterVersionKey}] =
       folly::to<std::string>(writerVersion);
-  userMetadata_[std::string{WRITER_HOSTNAME_KEY}] = process::getHostName();
+  userMetadata_[std::string{kWriterHostnameKey}] = process::getHostName();
   std::for_each(userMetadata_.begin(), userMetadata_.end(), [&](auto& pair) {
-    auto item = footer_.add_metadata();
-    item->set_name(pair.first);
-    item->set_value(pair.second);
+    auto item = footer_->addMetadata();
+    item.setName(pair.first);
+    item.setValue(pair.second);
   });
 }
 
diff --git a/velox/dwio/dwrf/writer/WriterBase.h b/velox/dwio/dwrf/writer/WriterBase.h
index e79b9293db9..3c468a370ca 100644
--- a/velox/dwio/dwrf/writer/WriterBase.h
+++ b/velox/dwio/dwrf/writer/WriterBase.h
@@ -17,15 +17,19 @@
 #pragma once
 
 #include "velox/common/base/GTestMacros.h"
+#include "velox/dwio/common/Arena.h"
 #include "velox/dwio/dwrf/writer/WriterContext.h"
 #include "velox/dwio/dwrf/writer/WriterSink.h"
 
 namespace facebook::velox::dwrf {
 
+using dwio::common::ArenaCreate;
+
 class WriterBase {
  public:
   explicit WriterBase(std::unique_ptr<dwio::common::FileSink> sink)
-      : sink_{std::move(sink)} {
+      : sink_{std::move(sink)},
+        arena_(std::make_unique<google::protobuf::Arena>()) {
     VELOX_CHECK_NOT_NULL(sink_);
   }
 
@@ -76,18 +80,22 @@ class WriterBase {
       std::shared_ptr<velox::memory::MemoryPool> pool,
       const tz::TimeZone* sessionTimezone = nullptr,
       const bool adjustTimestampToTimezone = false,
-      std::unique_ptr<encryption::EncryptionHandler> handler = nullptr) {
+      std::unique_ptr<encryption::EncryptionHandler> handler = nullptr,
+      int64_t memoryBudget = std::numeric_limits<int64_t>::max()) {
     context_ = std::make_unique<WriterContext>(
         config,
         std::move(pool),
         sink_->metricsLog(),
         sessionTimezone,
         adjustTimestampToTimezone,
-        std::move(handler));
+        std::move(handler),
+        memoryBudget);
     writerSink_ = std::make_unique<WriterSink>(
         *sink_,
         context_->getMemoryPool(MemoryUsageCategory::OUTPUT_STREAM),
         context_->getConfigs());
+    auto dwrfFooter_ = ArenaCreate<proto::Footer>(arena_.get());
+    footer_ = std::make_unique<FooterWriteWrapper>(dwrfFooter_);
   }
 
   void initBuffers();
@@ -107,7 +115,7 @@ class WriterBase {
     auto holder = context_->newDataBufferHolder();
     auto stream = context_->newStream(kind, *holder);
 
-    t.SerializeToZeroCopyStream(stream.get());
+    t->SerializeToZeroCopyStream(stream.get());
     stream->flush();
 
     writerSink_->addBuffers(*holder);
@@ -131,23 +139,23 @@ class WriterBase {
     }
   }
 
-  proto::StripeInformation& addStripeInfo() {
-    auto stripe = footer_.add_stripes();
-    stripe->set_numberofrows(context_->stripeRowCount());
+  StripeInformationWriteWrapper addStripeInfo() {
+    auto stripe = footer_->addStripes();
+    stripe.setNumberOfRows(context_->stripeRowCount());
     if (context_->stripeRawSize() > 0 || context_->stripeRowCount() == 0) {
       // ColumnTransformWriter, when rewriting presto written
       // file does not have rawSize.
-      stripe->set_rawdatasize(context_->stripeRawSize());
+      stripe.setRawDataSize(context_->stripeRawSize());
     }
 
     auto* checksum = writerSink_->getChecksum();
     if (checksum != nullptr) {
-      stripe->set_checksum(checksum->getDigest());
+      stripe.setChecksum(checksum->getDigest());
     }
-    return *stripe;
+    return stripe;
   }
 
-  proto::Footer& getFooter() {
+  std::unique_ptr<FooterWriteWrapper>& getFooter() {
     return footer_;
   }
 
@@ -170,8 +178,10 @@ class WriterBase {
   std::unique_ptr<WriterContext> context_;
   std::unique_ptr<dwio::common::FileSink> sink_;
   std::unique_ptr<WriterSink> writerSink_;
-  proto::Footer footer_;
+  std::unique_ptr<FooterWriteWrapper> footer_;
+  proto::orc::Metadata metadata_;
   std::unordered_map<std::string, std::string> userMetadata_;
+  std::unique_ptr<google::protobuf::Arena> arena_;
 
   friend class WriterTest;
   VELOX_FRIEND_TEST(WriterBaseTest, FlushWriterSinkUponClose);
diff --git a/velox/dwio/dwrf/writer/WriterContext.cpp b/velox/dwio/dwrf/writer/WriterContext.cpp
index ce02aacf292..84056c95a0e 100644
--- a/velox/dwio/dwrf/writer/WriterContext.cpp
+++ b/velox/dwio/dwrf/writer/WriterContext.cpp
@@ -29,9 +29,11 @@ WriterContext::WriterContext(
     const dwio::common::MetricsLogPtr& metricLogger,
     const tz::TimeZone* sessionTimezone,
     const bool adjustTimestampToTimezone,
-    std::unique_ptr<encryption::EncryptionHandler> handler)
+    std::unique_ptr<encryption::EncryptionHandler> handler,
+    int64_t memoryBudget)
     : config_{config},
       pool_{std::move(pool)},
+      memoryBudget_{memoryBudget},
       dictionaryPool_{
           pool_->addLeafChild(fmt::format("{}.dictionary", pool_->name()))},
       outputStreamPool_{
@@ -69,7 +71,17 @@ WriterContext::WriterContext(
   }
   validateConfigs();
   VLOG(2) << fmt::format(
-      "Compression config: {}", common::compressionKindToString(compression_));
+      "DWRF WriterContext initialized: pool='{}', maxCapacity={}MB, "
+      "memoryBudget={}MB, effectiveBudget={}MB, "
+      "stripeSizeFlushThreshold={}MB, dictionarySizeFlushThreshold={}MB, "
+      "compression={}",
+      pool_->name(),
+      pool_->maxCapacity() / (1024 * 1024),
+      memoryBudget_ / (1024 * 1024),
+      getMemoryBudget() / (1024 * 1024),
+      stripeSizeFlushThreshold_ / (1024 * 1024),
+      dictionarySizeFlushThreshold_ / (1024 * 1024),
+      common::compressionKindToString(compression_));
 }
 
 WriterContext::~WriterContext() {
diff --git a/velox/dwio/dwrf/writer/WriterContext.h b/velox/dwio/dwrf/writer/WriterContext.h
index 9ba444d5317..524ad0fd569 100644
--- a/velox/dwio/dwrf/writer/WriterContext.h
+++ b/velox/dwio/dwrf/writer/WriterContext.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <algorithm>
 #include <limits>
 #include "velox/common/base/GTestMacros.h"
 #include "velox/common/time/CpuWallTimer.h"
@@ -30,6 +31,7 @@
 #include "velox/vector/DecodedVector.h"
 
 namespace facebook::velox::dwrf {
+
 using dwio::common::BufferedOutputStream;
 using dwio::common::DataBufferHolder;
 using dwio::common::compression::CompressionBufferPool;
@@ -45,21 +47,20 @@ class WriterContext : public CompressionBufferPool {
           dwio::common::MetricsLog::voidLog(),
       const tz::TimeZone* sessionTimezone = nullptr,
       const bool adjustTimestampToTimezone = false,
-      std::unique_ptr<encryption::EncryptionHandler> handler = nullptr);
+      std::unique_ptr<encryption::EncryptionHandler> handler = nullptr,
+      int64_t memoryBudget = std::numeric_limits<int64_t>::max());
 
   ~WriterContext() override;
 
   bool hasStream(const DwrfStreamIdentifier& stream) const {
-    return streams_.find(stream) != streams_.end();
+    return streams_.find(stream) != streams_.cend();
   }
 
   const DataBufferHolder& getStream(const DwrfStreamIdentifier& stream) const {
     return streams_.at(stream);
   }
 
-  void addBuffer(
-      const DwrfStreamIdentifier& stream,
-      folly::StringPiece buffer) {
+  void addBuffer(const DwrfStreamIdentifier& stream, std::string_view buffer) {
     streams_.at(stream).take(buffer);
   }
 
@@ -115,7 +116,7 @@ class WriterContext : public CompressionBufferPool {
       velox::memory::MemoryPool& dictionaryPool,
       velox::memory::MemoryPool& generalPool) {
     auto result = dictEncoders_.find(encodingKey);
-    if (result == dictEncoders_.end()) {
+    if (result == dictEncoders_.cend()) {
       auto emplaceResult = dictEncoders_.emplace(
           encodingKey,
           std::make_unique<IntegerDictionaryEncoder<T>>(
@@ -191,7 +192,7 @@ class WriterContext : public CompressionBufferPool {
   int64_t getTotalMemoryUsage() const;
 
   int64_t getMemoryBudget() const {
-    return pool_->maxCapacity();
+    return std::min(memoryBudget_, pool_->maxCapacity());
   }
 
   /// Returns the available memory reservations from all the memory pools.
@@ -233,7 +234,7 @@ class WriterContext : public CompressionBufferPool {
   void removeAllIntDictionaryEncodersOnNode(
       std::function<bool(uint32_t)> predicate) {
     auto iter = dictEncoders_.begin();
-    while (iter != dictEncoders_.end()) {
+    while (iter != dictEncoders_.cend()) {
       if (predicate(iter->first.node())) {
         iter = dictEncoders_.erase(iter);
       } else {
@@ -623,6 +624,7 @@ class WriterContext : public CompressionBufferPool {
 
   const std::shared_ptr<const Config> config_;
   const std::shared_ptr<memory::MemoryPool> pool_;
+  const int64_t memoryBudget_;
   const std::shared_ptr<memory::MemoryPool> dictionaryPool_;
   const std::shared_ptr<memory::MemoryPool> outputStreamPool_;
   const std::shared_ptr<memory::MemoryPool> generalPool_;
diff --git a/velox/dwio/orc/reader/CMakeLists.txt b/velox/dwio/orc/reader/CMakeLists.txt
index 18a977afee3..d17c996e072 100644
--- a/velox/dwio/orc/reader/CMakeLists.txt
+++ b/velox/dwio/orc/reader/CMakeLists.txt
@@ -12,6 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_dwio_orc_reader OrcReader.cpp)
+velox_add_library(velox_dwio_orc_reader OrcReader.cpp HEADERS OrcReader.h)
 
 velox_link_libraries(velox_dwio_orc_reader velox_dwio_dwrf_reader)
diff --git a/velox/dwio/orc/test/ReaderFilterTest.cpp b/velox/dwio/orc/test/ReaderFilterTest.cpp
index 329286f0079..a817a091883 100644
--- a/velox/dwio/orc/test/ReaderFilterTest.cpp
+++ b/velox/dwio/orc/test/ReaderFilterTest.cpp
@@ -47,6 +47,11 @@ class OrcReaderFilterTestP
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   }
+
+  std::shared_ptr<io::IoStatistics> dataIoStats_{
+      std::make_shared<io::IoStatistics>()};
+  std::shared_ptr<io::IoStatistics> metadataIoStats_{
+      std::make_shared<io::IoStatistics>()};
 };
 
 INSTANTIATE_TEST_SUITE_P(
@@ -218,6 +223,8 @@ TEST_P(OrcReaderFilterTestP, tests) {
   std::string fileName = "orc_all_type.orc";
 
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
 
   // To make DwrfReader reads ORC file, setFileFormat to FileFormat::ORC
   readerOpts.setFileFormat(dwio::common::FileFormat::ORC);
diff --git a/velox/dwio/orc/test/ReaderTest.cpp b/velox/dwio/orc/test/ReaderTest.cpp
index db06e778b3e..4345bd4931a 100644
--- a/velox/dwio/orc/test/ReaderTest.cpp
+++ b/velox/dwio/orc/test/ReaderTest.cpp
@@ -16,6 +16,7 @@
 
 #include <gtest/gtest.h>
 
+#include "velox/common/io/IoStatistics.h"
 #include "velox/dwio/dwrf/common/Common.h"
 #include "velox/dwio/dwrf/reader/DwrfReader.h"
 #include "velox/dwio/dwrf/test/OrcTest.h"
@@ -35,6 +36,11 @@ class OrcReaderTest : public testing::Test, public VectorTestBase {
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   }
+
+  std::shared_ptr<io::IoStatistics> dataIoStats_ =
+      std::make_shared<io::IoStatistics>();
+  std::shared_ptr<io::IoStatistics> metadataIoStats_ =
+      std::make_shared<io::IoStatistics>();
 };
 
 inline std::string getExamplesFilePath(const std::string& fileName) {
@@ -47,6 +53,8 @@ TEST_F(OrcReaderTest, testOrcReaderSimple) {
   const std::string simpleTest(
       getExamplesFilePath("TestStringDictionary.testRowIndex.orc"));
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   // To make DwrfReader reads ORC file, setFileFormat to FileFormat::ORC
   readerOpts.setFileFormat(dwio::common::FileFormat::ORC);
   auto reader = DwrfReader::create(
@@ -84,6 +92,8 @@ TEST_F(OrcReaderTest, testOrcReaderComplexTypes) {
            h:struct<\
              i:array<double>>>>>>"));
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   readerOpts.setFileFormat(dwio::common::FileFormat::ORC);
   auto reader = DwrfReader::create(
       createFileBufferedInput(icebergOrc, readerOpts.memoryPool()), readerOpts);
@@ -103,6 +113,8 @@ TEST_F(OrcReaderTest, testOrcReaderComplexTypes) {
 TEST_F(OrcReaderTest, testOrcReaderVarchar) {
   const std::string varcharOrc(getExamplesFilePath("orc_index_int_string.orc"));
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   readerOpts.setFileFormat(dwio::common::FileFormat::ORC);
   auto reader = DwrfReader::create(
       createFileBufferedInput(varcharOrc, readerOpts.memoryPool()), readerOpts);
@@ -134,6 +146,8 @@ TEST_F(OrcReaderTest, testOrcReaderDate) {
   const std::string dateOrc(
       getExamplesFilePath("TestOrcFile.testDate1900.orc"));
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   readerOpts.setFileFormat(dwio::common::FileFormat::ORC);
   auto reader = DwrfReader::create(
       createFileBufferedInput(dateOrc, readerOpts.memoryPool()), readerOpts);
@@ -179,6 +193,8 @@ TEST_F(OrcReaderTest, testOrcReaderDate) {
 TEST_F(OrcReaderTest, testOrcReadAllType) {
   const std::string dateOrc(getExamplesFilePath("orc_all_type.orc"));
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   readerOpts.setFileFormat(dwio::common::FileFormat::ORC);
   auto reader = DwrfReader::create(
       createFileBufferedInput(dateOrc, readerOpts.memoryPool()), readerOpts);
@@ -256,6 +272,8 @@ TEST_F(OrcReaderTest, testOrcRlev2) {
   spec->addAllChildFields(*schema);
 
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   readerOpts.setScanSpec(spec);
   readerOpts.setFileFormat(dwio::common::FileFormat::ORC);
 
@@ -361,6 +379,11 @@ class OrcReaderTestP : public testing::TestWithParam<OrcFileDescription>,
     return test::getDataFilePath(
         "velox/dwio/orc/test", "examples/expected/" + GetParam().json);
   }
+
+  std::shared_ptr<io::IoStatistics> dataIoStats_ =
+      std::make_shared<io::IoStatistics>();
+  std::shared_ptr<io::IoStatistics> metadataIoStats_ =
+      std::make_shared<io::IoStatistics>();
 };
 
 TEST_P(
@@ -368,6 +391,8 @@ TEST_P(
     DwrfReader_FetchesOrcMetadata_ExpectCorrectFooterAndMetadata) {
   const std::string dateOrc(getFilename());
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   readerOpts.setFileFormat(dwio::common::FileFormat::ORC);
   auto reader = DwrfReader::create(
       createFileBufferedInput(dateOrc, readerOpts.memoryPool()), readerOpts);
@@ -390,8 +415,8 @@ TEST_P(
   auto rowReader = reader->createRowReader(rowReaderOptions);
 
   for (std::map<std::string, std::string>::const_iterator itr =
-           GetParam().userMeta.begin();
-       itr != GetParam().userMeta.end();
+           GetParam().userMeta.cbegin();
+       itr != GetParam().userMeta.cend();
        ++itr) {
     ASSERT_EQ(true, reader->hasMetadataValue(itr->first));
     std::string val = reader->getMetadataValue(itr->first);
@@ -409,6 +434,8 @@ TEST_P(OrcReaderTestP, DwrfRowReader_ReadAllColumnTypes_ExpectedRowDataRead) {
 
   const std::string dateOrc(getFilename());
   dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   readerOpts.setFileFormat(dwio::common::FileFormat::ORC);
   readerOpts.setScanSpec(scanSpec);
 
diff --git a/velox/dwio/parquet/CMakeLists.txt b/velox/dwio/parquet/CMakeLists.txt
index c40f352d0bb..c6f4fb10ceb 100644
--- a/velox/dwio/parquet/CMakeLists.txt
+++ b/velox/dwio/parquet/CMakeLists.txt
@@ -23,8 +23,15 @@ if(VELOX_ENABLE_PARQUET)
   endif()
 endif()
 
-velox_add_library(velox_dwio_parquet_reader RegisterParquetReader.cpp)
+velox_add_library(
+  velox_dwio_parquet_reader
+  RegisterParquetReader.cpp
+  HEADERS
+  RegisterParquetReader.h
+  RegisterParquetWriter.h
+)
 velox_add_library(velox_dwio_parquet_writer RegisterParquetWriter.cpp)
+velox_add_library(velox_dwio_parquet_field_id INTERFACE ParquetFieldId.h)
 
 if(VELOX_ENABLE_PARQUET)
   velox_link_libraries(velox_dwio_parquet_reader velox_dwio_native_parquet_reader xsimd)
diff --git a/velox/dwio/parquet/ParquetFieldId.h b/velox/dwio/parquet/ParquetFieldId.h
new file mode 100644
index 00000000000..f440ab37730
--- /dev/null
+++ b/velox/dwio/parquet/ParquetFieldId.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <vector>
+
+namespace facebook::velox::parquet {
+/// Parquet field IDs during write operations. Each ID must be unique positive
+/// number, do not need to be sequential.
+/// Used to explicitly control field ID assignment in the Parquet schema.
+struct ParquetFieldId {
+  int32_t fieldId;
+  std::vector<ParquetFieldId> children;
+};
+} // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/common/BloomFilter.cpp b/velox/dwio/parquet/common/BloomFilter.cpp
index 211b842cf9e..d8617a80728 100644
--- a/velox/dwio/parquet/common/BloomFilter.cpp
+++ b/velox/dwio/parquet/common/BloomFilter.cpp
@@ -73,31 +73,25 @@ void BlockSplitBloomFilter::init(const uint8_t* bitset, uint32_t numBytes) {
 }
 
 static void validateBloomFilterHeader(const thrift::BloomFilterHeader& header) {
-  std::stringstream error;
   if (!header.algorithm.__isset.BLOCK) {
-    error << "Unsupported Bloom filter algorithm: ";
-    error << header.algorithm;
-    VELOX_FAIL(error.str());
+    VELOX_FAIL("Unsupported Bloom filter algorithm");
   }
 
   if (!header.hash.__isset.XXHASH) {
-    error << "Unsupported Bloom filter hash: ", error << header.hash;
-    VELOX_FAIL(error.str());
+    VELOX_FAIL("Unsupported Bloom filter hash");
   }
 
   if (!header.compression.__isset.UNCOMPRESSED) {
-    error << "Unsupported Bloom filter compression: ",
-        error << header.compression;
-    VELOX_FAIL(error.str());
+    VELOX_FAIL("Unsupported Bloom filter compression");
   }
 
   if (header.numBytes <= 0 ||
       static_cast<uint32_t>(header.numBytes) >
           BloomFilter::kMaximumBloomFilterBytes) {
-    error << "Bloom filter size is incorrect: " << header.numBytes
-          << ". Must be in range (" << 0 << ", "
-          << BloomFilter::kMaximumBloomFilterBytes << "].";
-    VELOX_FAIL(error.str());
+    VELOX_FAIL(
+        "Bloom filter size is incorrect: {}. Must be in range (0, {}].",
+        header.numBytes,
+        BloomFilter::kMaximumBloomFilterBytes);
   }
 }
 
@@ -188,9 +182,7 @@ void BlockSplitBloomFilter::writeTo(
     memBuffer->resetBuffer();
     header.write(protocol.get());
   } catch (std::exception& e) {
-    std::stringstream ss;
-    ss << "Couldn't serialize thrift: " << e.what() << "\n";
-    VELOX_FAIL(ss.str());
+    VELOX_FAIL("Couldn't serialize thrift: {}", e.what());
   }
   uint8_t* outBuffer;
   uint32_t outLength;
diff --git a/velox/dwio/parquet/common/CMakeLists.txt b/velox/dwio/parquet/common/CMakeLists.txt
index 159067602e9..4f1256edd75 100644
--- a/velox/dwio/parquet/common/CMakeLists.txt
+++ b/velox/dwio/parquet/common/CMakeLists.txt
@@ -18,6 +18,15 @@ velox_add_library(
   XxHasher.cpp
   LevelComparison.cpp
   LevelConversion.cpp
+  HEADERS
+  BitStreamUtilsInternal.h
+  BloomFilter.h
+  Hasher.h
+  LevelComparison.h
+  LevelConversion.h
+  LevelConversionUtil.h
+  RleEncodingInternal.h
+  XxHasher.h
 )
 
 velox_link_libraries(
diff --git a/velox/dwio/parquet/common/XxHasher.cpp b/velox/dwio/parquet/common/XxHasher.cpp
index df189a972b6..93ee12f1b60 100644
--- a/velox/dwio/parquet/common/XxHasher.cpp
+++ b/velox/dwio/parquet/common/XxHasher.cpp
@@ -18,8 +18,7 @@
 
 #include "XxHasher.h"
 
-#define XXH_INLINE_ALL
-#include <xxhash.h>
+#include "velox/common/base/XxHashInline.h"
 
 namespace facebook::velox::parquet {
 
diff --git a/velox/dwio/parquet/reader/CMakeLists.txt b/velox/dwio/parquet/reader/CMakeLists.txt
index 292285da9b5..d73c8a31c67 100644
--- a/velox/dwio/parquet/reader/CMakeLists.txt
+++ b/velox/dwio/parquet/reader/CMakeLists.txt
@@ -26,6 +26,30 @@ velox_add_library(
   StructColumnReader.cpp
   StringColumnReader.cpp
   SemanticVersion.cpp
+  HEADERS
+  BooleanColumnReader.h
+  BooleanDecoder.h
+  DeltaBpDecoder.h
+  DeltaByteArrayDecoder.h
+  FloatingPointColumnReader.h
+  IntegerColumnReader.h
+  Metadata.h
+  NestedStructureDecoder.h
+  PageReader.h
+  ParquetColumnReader.h
+  ParquetData.h
+  ParquetReader.h
+  ParquetStatsContext.h
+  ParquetTypeWithId.h
+  RepeatedColumnReader.h
+  RleBpDataDecoder.h
+  RleBpDecoder.h
+  SemanticVersion.h
+  StringColumnReader.h
+  StringDecoder.h
+  StructColumnReader.h
+  TimeColumnReader.h
+  TimestampColumnReader.h
 )
 
 velox_link_libraries(
diff --git a/velox/dwio/parquet/reader/DeltaBpDecoder.h b/velox/dwio/parquet/reader/DeltaBpDecoder.h
index 59ec359ce43..43024cfad4a 100644
--- a/velox/dwio/parquet/reader/DeltaBpDecoder.h
+++ b/velox/dwio/parquet/reader/DeltaBpDecoder.h
@@ -16,8 +16,10 @@
 
 #pragma once
 
+#include <folly/Varint.h>
 #include "velox/common/base/BitUtil.h"
 #include "velox/common/base/Exceptions.h"
+#include "velox/common/base/Nulls.h"
 
 namespace facebook::velox::parquet {
 
@@ -127,8 +129,8 @@ class DeltaBpDecoder {
     VELOX_CHECK_EQ(
         valuesPerBlock_ % 128,
         0,
-        "the number of values in a block must be multiple of 128, but it's " +
-            std::to_string(valuesPerBlock_));
+        "the number of values in a block must be multiple of 128, but it's {}",
+        valuesPerBlock_);
     VELOX_CHECK_GT(
         miniBlocksPerBlock_, 0, "cannot have zero miniblock per block");
     valuesPerMiniBlock_ = valuesPerBlock_ / miniBlocksPerBlock_;
@@ -137,8 +139,8 @@ class DeltaBpDecoder {
     VELOX_CHECK_EQ(
         valuesPerMiniBlock_ % 32,
         0,
-        "the number of values in a miniblock must be multiple of 32, but it's " +
-            std::to_string(valuesPerMiniBlock_));
+        "the number of values in a miniblock must be multiple of 32, but it's {}",
+        valuesPerMiniBlock_);
 
     totalValuesRemaining_ = totalValueCount_;
     deltaBitWidths_.resize(miniBlocksPerBlock_);
diff --git a/velox/dwio/parquet/reader/DeltaByteArrayDecoder.h b/velox/dwio/parquet/reader/DeltaByteArrayDecoder.h
index 74e4d9001c7..b8ad2d18d48 100644
--- a/velox/dwio/parquet/reader/DeltaByteArrayDecoder.h
+++ b/velox/dwio/parquet/reader/DeltaByteArrayDecoder.h
@@ -17,60 +17,16 @@
 #pragma once
 
 #include "velox/common/base/BitUtil.h"
+#include "velox/common/base/Nulls.h"
 #include "velox/dwio/parquet/reader/DeltaBpDecoder.h"
 
 namespace facebook::velox::parquet {
 
-// DeltaByteArrayDecoder is adapted from Apache Arrow:
-// https://github.com/apache/arrow/blob/apache-arrow-15.0.0/cpp/src/parquet/encoding.cc#L2758-L2889
-class DeltaLengthByteArrayDecoder {
+class DeltaByteArrayDecoderBase {
  public:
-  explicit DeltaLengthByteArrayDecoder(const char* start) {
-    lengthDecoder_ = std::make_unique<DeltaBpDecoder>(start);
-    decodeLengths();
-    bufferStart_ = lengthDecoder_->bufferStart();
-  }
-
-  std::string_view readString() {
-    const int64_t length = bufferedLength_[lengthIdx_++];
-    VELOX_CHECK_GE(length, 0, "negative string delta length");
-    bufferStart_ += length;
-    return std::string_view(bufferStart_ - length, length);
-  }
+  virtual ~DeltaByteArrayDecoderBase() = default;
 
- private:
-  void decodeLengths() {
-    int64_t numLength = lengthDecoder_->validValuesCount();
-    bufferedLength_.resize(numLength);
-    lengthDecoder_->readValues<uint32_t>(bufferedLength_.data(), numLength);
-
-    lengthIdx_ = 0;
-    numValidValues_ = numLength;
-  }
-
-  const char* bufferStart_;
-  std::unique_ptr<DeltaBpDecoder> lengthDecoder_;
-  int32_t numValidValues_{0};
-  uint32_t lengthIdx_{0};
-  std::vector<uint32_t> bufferedLength_;
-};
-
-// DeltaByteArrayDecoder is adapted from Apache Arrow:
-// https://github.com/apache/arrow/blob/apache-arrow-15.0.0/cpp/src/parquet/encoding.cc#L3301-L3545
-class DeltaByteArrayDecoder {
- public:
-  explicit DeltaByteArrayDecoder(const char* start) {
-    prefixLenDecoder_ = std::make_unique<DeltaBpDecoder>(start);
-    int64_t numPrefix = prefixLenDecoder_->validValuesCount();
-    bufferedPrefixLength_.resize(numPrefix);
-    prefixLenDecoder_->readValues<uint32_t>(
-        bufferedPrefixLength_.data(), numPrefix);
-    prefixLenOffset_ = 0;
-    numValidValues_ = numPrefix;
-
-    suffixDecoder_ = std::make_unique<DeltaLengthByteArrayDecoder>(
-        prefixLenDecoder_->bufferStart());
-  }
+  virtual std::string_view readString() = 0;
 
   void skip(uint64_t numValues) {
     skip<false>(numValues, 0, nullptr);
@@ -120,8 +76,61 @@ class DeltaByteArrayDecoder {
       }
     }
   }
+};
+
+// DeltaByteArrayDecoder is adapted from Apache Arrow:
+// https://github.com/apache/arrow/blob/apache-arrow-15.0.0/cpp/src/parquet/encoding.cc#L2758-L2889
+class DeltaLengthByteArrayDecoder : public DeltaByteArrayDecoderBase {
+ public:
+  explicit DeltaLengthByteArrayDecoder(const char* start) {
+    lengthDecoder_ = std::make_unique<DeltaBpDecoder>(start);
+    decodeLengths();
+    bufferStart_ = lengthDecoder_->bufferStart();
+  }
+
+  std::string_view readString() override {
+    const int64_t length = bufferedLength_[lengthIdx_++];
+    VELOX_CHECK_GE(length, 0, "negative string delta length");
+    bufferStart_ += length;
+    return std::string_view(bufferStart_ - length, length);
+  }
+
+ private:
+  void decodeLengths() {
+    int64_t numLength = lengthDecoder_->validValuesCount();
+    bufferedLength_.resize(numLength);
+    lengthDecoder_->readValues<uint32_t>(
+        bufferedLength_.data(), static_cast<int32_t>(numLength));
+
+    lengthIdx_ = 0;
+    numValidValues_ = static_cast<int32_t>(numLength);
+  }
+
+  const char* bufferStart_;
+  std::unique_ptr<DeltaBpDecoder> lengthDecoder_;
+  int32_t numValidValues_{0};
+  uint32_t lengthIdx_{0};
+  std::vector<uint32_t> bufferedLength_;
+};
+
+// DeltaByteArrayDecoder is adapted from Apache Arrow:
+// https://github.com/apache/arrow/blob/apache-arrow-15.0.0/cpp/src/parquet/encoding.cc#L3301-L3545
+class DeltaByteArrayDecoder : public DeltaByteArrayDecoderBase {
+ public:
+  explicit DeltaByteArrayDecoder(const char* start) {
+    prefixLenDecoder_ = std::make_unique<DeltaBpDecoder>(start);
+    int64_t numPrefix = prefixLenDecoder_->validValuesCount();
+    bufferedPrefixLength_.resize(numPrefix);
+    prefixLenDecoder_->readValues<uint32_t>(
+        bufferedPrefixLength_.data(), static_cast<int32_t>(numPrefix));
+    prefixLenOffset_ = 0;
+    numValidValues_ = static_cast<int32_t>(numPrefix);
+
+    suffixDecoder_ = std::make_unique<DeltaLengthByteArrayDecoder>(
+        prefixLenDecoder_->bufferStart());
+  }
 
-  std::string_view readString() {
+  std::string_view readString() override {
     auto suffix = suffixDecoder_->readString();
     bool isFirstRun = (prefixLenOffset_ == 0);
     const int64_t prefixLength = bufferedPrefixLength_[prefixLenOffset_++];
diff --git a/velox/dwio/parquet/reader/FloatingPointColumnReader.h b/velox/dwio/parquet/reader/FloatingPointColumnReader.h
index cac475c0ee9..1a3fc9c4c58 100644
--- a/velox/dwio/parquet/reader/FloatingPointColumnReader.h
+++ b/velox/dwio/parquet/reader/FloatingPointColumnReader.h
@@ -36,6 +36,13 @@ class FloatingPointColumnReader
       ParquetParams& params,
       common::ScanSpec& scanSpec);
 
+  // Parquet floating point reader always supports a bulk path
+  static constexpr bool kHasBulkPath = true;
+
+  bool hasBulkPath() const override {
+    return kHasBulkPath;
+  }
+
   void seekToRowGroup(int64_t index) override {
     base::seekToRowGroup(index);
     this->scanState().clear();
@@ -66,7 +73,16 @@ FloatingPointColumnReader<TData, TRequested>::FloatingPointColumnReader(
           requestedType,
           std::move(fileType),
           params,
-          scanSpec) {}
+          scanSpec) {
+  VELOX_DCHECK(
+      (this->requestedType_->kind() == TypeKind::REAL &&
+       std::is_same_v<TRequested, float>) ||
+          (this->requestedType_->kind() == TypeKind::DOUBLE &&
+           std::is_same_v<TRequested, double>),
+      "TRequested type mismatch: template parameter is {}, but requestedType is {}",
+      folly::demangle(typeid(TRequested)),
+      this->requestedType_->toString());
+}
 
 template <typename TData, typename TRequested>
 uint64_t FloatingPointColumnReader<TData, TRequested>::skip(
diff --git a/velox/dwio/parquet/reader/IntegerColumnReader.h b/velox/dwio/parquet/reader/IntegerColumnReader.h
index 8c2aa2b4df1..fe8afcf90ce 100644
--- a/velox/dwio/parquet/reader/IntegerColumnReader.h
+++ b/velox/dwio/parquet/reader/IntegerColumnReader.h
@@ -17,6 +17,10 @@
 #pragma once
 
 #include "velox/dwio/common/SelectiveIntegerColumnReader.h"
+#include "velox/dwio/parquet/reader/ParquetColumnReader.h"
+#include "velox/dwio/parquet/reader/ParquetData.h"
+#include "velox/dwio/parquet/reader/ParquetTypeWithId.h"
+#include "velox/type/DecimalUtil.h"
 
 namespace facebook::velox::parquet {
 
@@ -61,6 +65,9 @@ class IntegerColumnReader : public dwio::common::SelectiveIntegerColumnReader {
       getUnsignedIntValues(rows, requestedType_, result);
     } else {
       getIntValues(rows, requestedType_, result);
+      if (requestedType_->isDecimal() && !allNull_) {
+        rescaleDecimalValues(fileType, *result);
+      }
     }
   }
 
@@ -82,6 +89,67 @@ class IntegerColumnReader : public dwio::common::SelectiveIntegerColumnReader {
   void readWithVisitor(const RowSet& rows, ColumnVisitor visitor) {
     formatData_->as<ParquetData>().readWithVisitor(visitor);
   }
+
+ private:
+  // Rescales integer or decimal values to match the requested decimal type.
+  // For INT->Decimal, fileScale is 0; for Decimal->Decimal, fileScale comes
+  // from the file's decimal type.
+  void rescaleDecimalValues(
+      const ParquetTypeWithId& fileType,
+      VectorPtr& result) {
+    int32_t requestedScale = getDecimalPrecisionScale(*requestedType_).second;
+    int32_t fileScale = fileType.type()->isDecimal()
+        ? getDecimalPrecisionScale(*fileType.type()).second
+        : 0;
+    int32_t scaleAdjust = requestedScale - fileScale;
+    VELOX_USER_CHECK_GE(
+        scaleAdjust,
+        0,
+        "Parquet does not support scale narrowing: {}",
+        scaleAdjust);
+    VELOX_USER_CHECK_LE(
+        scaleAdjust,
+        LongDecimalType::kMaxPrecision,
+        "Scale adjustment exceeds max decimal precision: {}",
+        scaleAdjust);
+
+    if (scaleAdjust > 0) {
+      if (requestedType_->isShortDecimal()) {
+        // Safe to cast: kPowersOfTen[scaleAdjust] fits in int64_t because
+        // scaleAdjust <= maxPrecision(18) and 10^18 < 2^63.
+        applyDecimalScaleMultiplier<int64_t>(
+            result,
+            static_cast<int64_t>(DecimalUtil::kPowersOfTen[scaleAdjust]));
+      } else {
+        applyDecimalScaleMultiplier<int128_t>(
+            result, DecimalUtil::kPowersOfTen[scaleAdjust]);
+      }
+    }
+  }
+
+  /// Multiplies all non-null values in result by multiplier.
+  /// Overflow is impossible because convertType validates precInc >= scaleInc,
+  /// guaranteeing that originalValue * 10^scaleAdjust fits within the target
+  /// precision.
+  template <typename T>
+  void applyDecimalScaleMultiplier(const VectorPtr& result, T multiplier)
+      const {
+    auto* flat = result->asUnchecked<FlatVector<T>>();
+    auto* rawValues = flat->mutableRawValues();
+    const auto* rawNulls = flat->rawNulls();
+    const auto size = flat->size();
+    if (!rawNulls) {
+      for (vector_size_t i = 0; i < size; ++i) {
+        rawValues[i] *= multiplier;
+      }
+    } else {
+      for (vector_size_t i = 0; i < size; ++i) {
+        if (bits::isBitSet(rawNulls, i)) {
+          rawValues[i] *= multiplier;
+        }
+      }
+    }
+  }
 };
 
 } // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/reader/Metadata.cpp b/velox/dwio/parquet/reader/Metadata.cpp
index e801386e523..05f3de17519 100644
--- a/velox/dwio/parquet/reader/Metadata.cpp
+++ b/velox/dwio/parquet/reader/Metadata.cpp
@@ -26,6 +26,20 @@ inline const T load(const char* ptr) {
   return ret;
 }
 
+inline std::optional<int64_t> decodeInt64Stat(const std::string& bytes) {
+  switch (bytes.size()) {
+    case sizeof(int64_t):
+      return load<int64_t>(bytes.data());
+    case sizeof(int32_t):
+      // Parquet stores Time types as int32_t (for milliseconds), but Velox's
+      // Time type is always int64_t, so we need to load sizeof(int32_t) and
+      // cast to int64_t.
+      return static_cast<int64_t>(load<int32_t>(bytes.data()));
+    default:
+      return std::nullopt;
+  }
+}
+
 template <typename T>
 inline std::optional<T> getMin(const thrift::Statistics& columnChunkStats) {
   return columnChunkStats.__isset.min_value
@@ -44,6 +58,24 @@ inline std::optional<T> getMax(const thrift::Statistics& columnChunkStats) {
              : std::nullopt);
 }
 
+template <>
+inline std::optional<int64_t> getMin(
+    const thrift::Statistics& columnChunkStats) {
+  return columnChunkStats.__isset.min_value
+      ? decodeInt64Stat(columnChunkStats.min_value)
+      : (columnChunkStats.__isset.min ? decodeInt64Stat(columnChunkStats.min)
+                                      : std::nullopt);
+}
+
+template <>
+inline std::optional<int64_t> getMax(
+    const thrift::Statistics& columnChunkStats) {
+  return columnChunkStats.__isset.max_value
+      ? decodeInt64Stat(columnChunkStats.max_value)
+      : (columnChunkStats.__isset.max ? decodeInt64Stat(columnChunkStats.max)
+                                      : std::nullopt);
+}
+
 template <>
 inline std::optional<std::string> getMin(
     const thrift::Statistics& columnChunkStats) {
@@ -156,22 +188,16 @@ common::CompressionKind thriftCodecToCompressionKind(
   switch (codec) {
     case thrift::CompressionCodec::UNCOMPRESSED:
       return common::CompressionKind::CompressionKind_NONE;
-      break;
     case thrift::CompressionCodec::SNAPPY:
       return common::CompressionKind::CompressionKind_SNAPPY;
-      break;
     case thrift::CompressionCodec::GZIP:
       return common::CompressionKind::CompressionKind_GZIP;
-      break;
     case thrift::CompressionCodec::LZO:
       return common::CompressionKind::CompressionKind_LZO;
-      break;
     case thrift::CompressionCodec::LZ4:
       return common::CompressionKind::CompressionKind_LZ4;
-      break;
     case thrift::CompressionCodec::ZSTD:
       return common::CompressionKind::CompressionKind_ZSTD;
-      break;
     case thrift::CompressionCodec::LZ4_RAW:
       return common::CompressionKind::CompressionKind_LZ4;
     default:
@@ -321,8 +347,9 @@ FileMetaDataPtr::FileMetaDataPtr(const void* metadata) : ptr_(metadata) {}
 FileMetaDataPtr::~FileMetaDataPtr() = default;
 
 RowGroupMetaDataPtr FileMetaDataPtr::rowGroup(int i) const {
-  return RowGroupMetaDataPtr(reinterpret_cast<const void*>(
-      &thriftFileMetaDataPtr(ptr_)->row_groups[i]));
+  return RowGroupMetaDataPtr(
+      reinterpret_cast<const void*>(
+          &thriftFileMetaDataPtr(ptr_)->row_groups[i]));
 }
 
 int64_t FileMetaDataPtr::numRows() const {
@@ -356,7 +383,7 @@ std::string FileMetaDataPtr::keyValueMetadataValue(
       return thriftFileMetaDataPtr(ptr_)->key_value_metadata[i].value;
     }
   }
-  VELOX_FAIL(fmt::format("Input key {} is not in the key value metadata", key));
+  VELOX_FAIL("Input key {} is not in the key value metadata", key);
 }
 
 std::string FileMetaDataPtr::createdBy() const {
diff --git a/velox/dwio/parquet/reader/PageReader.cpp b/velox/dwio/parquet/reader/PageReader.cpp
index 879a97a51f3..7202adde6fb 100644
--- a/velox/dwio/parquet/reader/PageReader.cpp
+++ b/velox/dwio/parquet/reader/PageReader.cpp
@@ -16,12 +16,15 @@
 
 #include "velox/dwio/parquet/reader/PageReader.h"
 
+#include <snappy.h>
+#include <zstd.h>
+
 #include "velox/common/testutil/TestValue.h"
+#include "velox/common/time/Timer.h"
 #include "velox/dwio/common/BufferUtil.h"
 #include "velox/dwio/common/ColumnVisitors.h"
 #include "velox/dwio/parquet/common/LevelConversion.h"
 #include "velox/dwio/parquet/thrift/ThriftTransport.h"
-
 #include "velox/vector/FlatVector.h"
 
 #include <thrift/protocol/TCompactProtocol.h> // @manual
@@ -87,7 +90,12 @@ PageHeader PageReader::readPageHeader() {
   if (bufferEnd_ == bufferStart_) {
     const void* buffer;
     int32_t size;
-    inputStream_->Next(&buffer, &size);
+    uint64_t readUs{0};
+    {
+      MicrosecondTimer timer(&readUs);
+      inputStream_->Next(&buffer, &size);
+    }
+    stats_.pageLoadTimeNs.increment(readUs * 1'000);
     bufferStart_ = reinterpret_cast<const char*>(buffer);
     bufferEnd_ = bufferStart_ + size;
   }
@@ -106,26 +114,31 @@ PageHeader PageReader::readPageHeader() {
 }
 
 const char* PageReader::readBytes(int32_t size, BufferPtr& copy) {
-  if (bufferEnd_ == bufferStart_) {
-    const void* buffer = nullptr;
-    int32_t bufferSize = 0;
-    if (!inputStream_->Next(&buffer, &bufferSize)) {
-      VELOX_FAIL("Read past end");
+  uint64_t readUs{0};
+  {
+    MicrosecondTimer timer(&readUs);
+    if (bufferEnd_ == bufferStart_) {
+      const void* buffer = nullptr;
+      int32_t bufferSize = 0;
+      if (!inputStream_->Next(&buffer, &bufferSize)) {
+        VELOX_FAIL("Read past end");
+      }
+      bufferStart_ = reinterpret_cast<const char*>(buffer);
+      bufferEnd_ = bufferStart_ + bufferSize;
     }
-    bufferStart_ = reinterpret_cast<const char*>(buffer);
-    bufferEnd_ = bufferStart_ + bufferSize;
-  }
-  if (bufferEnd_ - bufferStart_ >= size) {
-    bufferStart_ += size;
-    return bufferStart_ - size;
-  }
-  dwio::common::ensureCapacity<char>(copy, size, &pool_);
-  dwio::common::readBytes(
-      size,
-      inputStream_.get(),
-      copy->asMutable<char>(),
-      bufferStart_,
-      bufferEnd_);
+    if (bufferEnd_ - bufferStart_ >= size) {
+      bufferStart_ += size;
+      return bufferStart_ - size;
+    }
+    dwio::common::ensureCapacity<char>(copy, size, &pool_);
+    dwio::common::readBytes(
+        size,
+        inputStream_.get(),
+        copy->asMutable<char>(),
+        bufferStart_,
+        bufferEnd_);
+  }
+  stats_.pageLoadTimeNs.increment(readUs * 1'000);
   return copy->as<char>();
 }
 
@@ -133,27 +146,59 @@ const char* PageReader::decompressData(
     const char* pageData,
     uint32_t compressedSize,
     uint32_t uncompressedSize) {
-  std::unique_ptr<dwio::common::SeekableInputStream> inputStream =
-      std::make_unique<dwio::common::SeekableArrayInputStream>(
-          pageData, compressedSize, 0);
-  auto streamDebugInfo =
-      fmt::format("Page Reader: Stream {}", inputStream_->getName());
-  std::unique_ptr<dwio::common::SeekableInputStream> decompressedStream =
-      dwio::common::compression::createDecompressor(
-          codec_,
-          std::move(inputStream),
-          uncompressedSize,
-          pool_,
-          getParquetDecompressionOptions(codec_),
-          streamDebugInfo,
-          nullptr,
-          true,
-          compressedSize);
-
   dwio::common::ensureCapacity<char>(
       decompressedData_, uncompressedSize, &pool_);
-  decompressedStream->readFully(
-      decompressedData_->asMutable<char>(), uncompressedSize);
+  auto* dest = decompressedData_->asMutable<char>();
+
+  switch (codec_) {
+    case common::CompressionKind::CompressionKind_SNAPPY: {
+      size_t actualUncompressedSize;
+      VELOX_CHECK(
+          snappy::GetUncompressedLength(
+              pageData, compressedSize, &actualUncompressedSize),
+          "Snappy: failed to get uncompressed length from corrupt data");
+      VELOX_CHECK_EQ(actualUncompressedSize, uncompressedSize);
+      VELOX_CHECK(
+          snappy::RawUncompress(pageData, compressedSize, dest),
+          "Snappy decompression failed");
+      break;
+    }
+    case common::CompressionKind::CompressionKind_ZSTD: {
+      thread_local std::unique_ptr<ZSTD_DCtx, size_t (*)(ZSTD_DCtx*)> zstdCtx{
+          ZSTD_createDCtx(), ZSTD_freeDCtx};
+      VELOX_CHECK_NOT_NULL(zstdCtx);
+      const auto actualUncompressedSize = ZSTD_decompressDCtx(
+          zstdCtx.get(), dest, uncompressedSize, pageData, compressedSize);
+      VELOX_CHECK(
+          !ZSTD_isError(actualUncompressedSize),
+          "ZSTD decompression failed: {}",
+          ZSTD_getErrorName(actualUncompressedSize));
+      VELOX_CHECK_EQ(actualUncompressedSize, uncompressedSize);
+      break;
+    }
+    default: {
+      // Fallback to stream-based decompression for other codecs (gzip, lz4,
+      // lzo).
+      std::unique_ptr<dwio::common::SeekableInputStream> inputStream =
+          std::make_unique<dwio::common::SeekableArrayInputStream>(
+              pageData, compressedSize, 0);
+      auto streamDebugInfo =
+          fmt::format("Page Reader: Stream {}", inputStream_->getName());
+      std::unique_ptr<dwio::common::SeekableInputStream> decompressedStream =
+          dwio::common::compression::createDecompressor(
+              codec_,
+              std::move(inputStream),
+              uncompressedSize,
+              pool_,
+              getParquetDecompressionOptions(codec_),
+              streamDebugInfo,
+              nullptr,
+              true,
+              compressedSize);
+      decompressedStream->readFully(dest, uncompressedSize);
+      break;
+    }
+  }
 
   return decompressedData_->as<char>();
 }
@@ -222,18 +267,42 @@ void PageReader::prepareDataPageV1(const PageHeader& pageHeader, int64_t row) {
       pageHeader.compressed_page_size,
       pageHeader.uncompressed_page_size);
   auto pageEnd = pageData_ + pageHeader.uncompressed_page_size;
+  auto remainingBytes = pageHeader.uncompressed_page_size;
   if (maxRepeat_ > 0) {
+    VELOX_CHECK_GE(
+        remainingBytes,
+        sizeof(int32_t),
+        "Insufficient bytes for repetition level length (corrupt data page?)");
     uint32_t repeatLength = readField<int32_t>(pageData_);
+    remainingBytes -= sizeof(int32_t);
+    VELOX_CHECK_LE(
+        repeatLength,
+        remainingBytes,
+        "Repetition level length {} exceeds remaining page size {} (corrupt data page?)",
+        repeatLength,
+        remainingBytes);
     repeatDecoder_ = std::make_unique<RleDecoder>(
         reinterpret_cast<const uint8_t*>(pageData_),
         repeatLength,
         ::arrow::bit_util::NumRequiredBits(maxRepeat_));
 
     pageData_ += repeatLength;
+    remainingBytes -= repeatLength;
   }
 
   if (maxDefine_ > 0) {
+    VELOX_CHECK_GE(
+        remainingBytes,
+        sizeof(uint32_t),
+        "Insufficient bytes for definition level length (corrupt data page?)");
     auto defineLength = readField<uint32_t>(pageData_);
+    remainingBytes -= sizeof(uint32_t);
+    VELOX_CHECK_LE(
+        defineLength,
+        remainingBytes,
+        "Definition level length {} exceeds remaining page size {} (corrupt data page?)",
+        defineLength,
+        remainingBytes);
     if (maxDefine_ == 1) {
       defineDecoder_ = std::make_unique<RleBpDecoder>(
           pageData_,
@@ -278,6 +347,13 @@ void PageReader::prepareDataPageV2(const PageHeader& pageHeader, int64_t row) {
       pageHeader.data_page_header_v2.repetition_levels_byte_length;
 
   auto bytes = pageHeader.compressed_page_size;
+  VELOX_CHECK_LE(
+      static_cast<uint64_t>(repeatLength) + defineLength,
+      bytes,
+      "Repetition and definition level lengths ({} + {}) exceed compressed page size {} (corrupt data page?)",
+      repeatLength,
+      defineLength,
+      bytes);
   pageData_ = readBytes(bytes, pageBuffer_);
 
   if (repeatLength) {
@@ -368,12 +444,17 @@ void PageReader::prepareDictionary(const PageHeader& pageHeader) {
       if (pageData_) {
         memcpy(dictionary_.values->asMutable<char>(), pageData_, numBytes);
       } else {
-        dwio::common::readBytes(
-            numBytes,
-            inputStream_.get(),
-            dictionary_.values->asMutable<char>(),
-            bufferStart_,
-            bufferEnd_);
+        uint64_t readUs{0};
+        {
+          MicrosecondTimer timer(&readUs);
+          dwio::common::readBytes(
+              numBytes,
+              inputStream_.get(),
+              dictionary_.values->asMutable<char>(),
+              bufferStart_,
+              bufferEnd_);
+        }
+        stats_.pageLoadTimeNs.increment(readUs * 1'000);
       }
       if (type_->type()->isShortDecimal() &&
           parquetType == thrift::Type::INT32) {
@@ -403,12 +484,17 @@ void PageReader::prepareDictionary(const PageHeader& pageHeader) {
       if (pageData_) {
         memcpy(dictionary_.values->asMutable<char>(), pageData_, numBytes);
       } else {
-        dwio::common::readBytes(
-            numBytes,
-            inputStream_.get(),
-            dictionary_.values->asMutable<char>(),
-            bufferStart_,
-            bufferEnd_);
+        uint64_t readUs{0};
+        {
+          MicrosecondTimer timer(&readUs);
+          dwio::common::readBytes(
+              numBytes,
+              inputStream_.get(),
+              dictionary_.values->asMutable<char>(),
+              bufferStart_,
+              bufferEnd_);
+        }
+        stats_.pageLoadTimeNs.increment(readUs * 1'000);
       }
       // Expand the Parquet type length values to Velox type length.
       // We start from the end to allow in-place expansion.
@@ -435,8 +521,13 @@ void PageReader::prepareDictionary(const PageHeader& pageHeader) {
       if (pageData_) {
         memcpy(strings, pageData_, numBytes);
       } else {
-        dwio::common::readBytes(
-            numBytes, inputStream_.get(), strings, bufferStart_, bufferEnd_);
+        uint64_t readUs{0};
+        {
+          MicrosecondTimer timer(&readUs);
+          dwio::common::readBytes(
+              numBytes, inputStream_.get(), strings, bufferStart_, bufferEnd_);
+        }
+        stats_.pageLoadTimeNs.increment(readUs * 1'000);
       }
       auto header = strings;
       for (auto i = 0; i < dictionary_.numValues; ++i) {
@@ -452,18 +543,24 @@ void PageReader::prepareDictionary(const PageHeader& pageHeader) {
       auto numParquetBytes = dictionary_.numValues * parquetTypeLength;
       auto veloxTypeLength = type_->type()->cppSizeInBytes();
       auto numVeloxBytes = dictionary_.numValues * veloxTypeLength;
+      VELOX_CHECK_LE(numParquetBytes, numVeloxBytes);
       dictionary_.values = AlignedBuffer::allocate<char>(numVeloxBytes, &pool_);
       auto data = dictionary_.values->asMutable<char>();
       // Read the data bytes.
       if (pageData_) {
         memcpy(data, pageData_, numParquetBytes);
       } else {
-        dwio::common::readBytes(
-            numParquetBytes,
-            inputStream_.get(),
-            data,
-            bufferStart_,
-            bufferEnd_);
+        uint64_t readUs{0};
+        {
+          MicrosecondTimer timer(&readUs);
+          dwio::common::readBytes(
+              numParquetBytes,
+              inputStream_.get(),
+              data,
+              bufferStart_,
+              bufferEnd_);
+        }
+        stats_.pageLoadTimeNs.increment(readUs * 1'000);
       }
       if (type_->type()->isShortDecimal()) {
         // Parquet decimal values have a fixed typeLength_ and are in big-endian
@@ -752,6 +849,13 @@ void PageReader::makeDecoder() {
         break;
       }
       [[fallthrough]];
+    case Encoding::DELTA_LENGTH_BYTE_ARRAY:
+      if (parquetType == thrift::Type::BYTE_ARRAY) {
+        deltaLengthByteArrDecoder_ =
+            std::make_unique<DeltaLengthByteArrayDecoder>(pageData_);
+        break;
+      }
+      [[fallthrough]];
     default:
       VELOX_UNSUPPORTED("Encoding not supported yet: {}", encoding_);
   }
@@ -794,6 +898,8 @@ void PageReader::skip(int64_t numRows) {
     deltaBpDecoder_->skip(toSkip);
   } else if (deltaByteArrDecoder_) {
     deltaByteArrDecoder_->skip(toSkip);
+  } else if (deltaLengthByteArrDecoder_) {
+    deltaLengthByteArrDecoder_->skip(toSkip);
   } else if (rleBooleanDecoder_) {
     rleBooleanDecoder_->skip(toSkip);
   } else {
diff --git a/velox/dwio/parquet/reader/PageReader.h b/velox/dwio/parquet/reader/PageReader.h
index c377100428a..f0ad90dd1c0 100644
--- a/velox/dwio/parquet/reader/PageReader.h
+++ b/velox/dwio/parquet/reader/PageReader.h
@@ -42,6 +42,7 @@ class PageReader {
       ParquetTypeWithIdPtr fileType,
       common::CompressionKind codec,
       int64_t chunkSize,
+      dwio::common::ColumnReaderStatistics& stats,
       const tz::TimeZone* sessionTimezone)
       : pool_(pool),
         inputStream_(std::move(stream)),
@@ -52,6 +53,7 @@ class PageReader {
         codec_(codec),
         chunkSize_(chunkSize),
         nullConcatenation_(pool_),
+        stats_(stats),
         sessionTimezone_(sessionTimezone) {
     type_->makeLevelInfo(leafInfo_);
   }
@@ -62,15 +64,19 @@ class PageReader {
       memory::MemoryPool& pool,
       common::CompressionKind codec,
       int64_t chunkSize,
-      const tz::TimeZone* sessionTimezone = nullptr)
+      dwio::common::ColumnReaderStatistics& stats,
+      const tz::TimeZone* sessionTimezone = nullptr,
+      int32_t maxRepeat = 0,
+      int32_t maxDefine = 1)
       : pool_(pool),
         inputStream_(std::move(stream)),
-        maxRepeat_(0),
-        maxDefine_(1),
+        maxRepeat_(maxRepeat),
+        maxDefine_(maxDefine),
         isTopLevel_(maxRepeat_ == 0 && maxDefine_ <= 1),
         codec_(codec),
         chunkSize_(chunkSize),
         nullConcatenation_(pool_),
+        stats_(stats),
         sessionTimezone_(sessionTimezone) {}
 
   /// Advances 'numRows' top level rows.
@@ -264,7 +270,7 @@ class PageReader {
   template <
       typename Visitor,
       typename std::enable_if<
-          !std::is_same_v<typename Visitor::DataType, folly::StringPiece> &&
+          !std::is_same_v<typename Visitor::DataType, std::string_view> &&
               !std::is_same_v<typename Visitor::DataType, int8_t>,
           int>::type = 0>
   void
@@ -300,7 +306,7 @@ class PageReader {
   template <
       typename Visitor,
       typename std::enable_if<
-          std::is_same_v<typename Visitor::DataType, folly::StringPiece>,
+          std::is_same_v<typename Visitor::DataType, std::string_view>,
           int>::type = 0>
   void
   callDecoder(const uint64_t* nulls, bool& nullsFromFastPath, Visitor visitor) {
@@ -312,6 +318,9 @@ class PageReader {
       } else if (encoding_ == thrift::Encoding::DELTA_BYTE_ARRAY) {
         nullsFromFastPath = false;
         deltaByteArrDecoder_->readWithVisitor<true>(nulls, visitor);
+      } else if (encoding_ == thrift::Encoding::DELTA_LENGTH_BYTE_ARRAY) {
+        nullsFromFastPath = false;
+        deltaLengthByteArrDecoder_->readWithVisitor<true>(nulls, visitor);
       } else {
         nullsFromFastPath = false;
         stringDecoder_->readWithVisitor<true>(nulls, visitor);
@@ -322,6 +331,8 @@ class PageReader {
         dictionaryIdDecoder_->readWithVisitor<false>(nullptr, dictVisitor);
       } else if (encoding_ == thrift::Encoding::DELTA_BYTE_ARRAY) {
         deltaByteArrDecoder_->readWithVisitor<false>(nulls, visitor);
+      } else if (encoding_ == thrift::Encoding::DELTA_LENGTH_BYTE_ARRAY) {
+        deltaLengthByteArrDecoder_->readWithVisitor<false>(nulls, visitor);
       } else {
         stringDecoder_->readWithVisitor<false>(nulls, visitor);
       }
@@ -359,14 +370,17 @@ class PageReader {
   // Returns the number of passed rows/values gathered by
   // 'reader'. Only numRows() is set for a filter-only case, only
   // numValues() is set for a non-filtered case.
-  template <bool hasFilter>
-  static int32_t numRowsInReader(
-      const dwio::common::SelectiveColumnReader& reader) {
+  template <bool hasFilter, bool hasHook>
+  static int32_t numValuesRead(
+      const dwio::common::SelectiveColumnReader& reader,
+      const int32_t numPageRowsRead) {
+    if (hasHook) {
+      return numPageRowsRead;
+    }
     if (hasFilter) {
       return reader.numRows();
-    } else {
-      return reader.numValues();
     }
+    return reader.numValues();
   }
 
   memory::MemoryPool& pool_;
@@ -502,6 +516,8 @@ class PageReader {
   // Base values of dictionary when reading a string dictionary.
   VectorPtr dictionaryValues_;
 
+  dwio::common::ColumnReaderStatistics& stats_;
+
   const tz::TimeZone* sessionTimezone_{nullptr};
 
   // Decoders. Only one will be set at a time.
@@ -511,6 +527,7 @@ class PageReader {
   std::unique_ptr<BooleanDecoder> booleanDecoder_;
   std::unique_ptr<DeltaBpDecoder> deltaBpDecoder_;
   std::unique_ptr<DeltaByteArrayDecoder> deltaByteArrDecoder_;
+  std::unique_ptr<DeltaLengthByteArrayDecoder> deltaLengthByteArrDecoder_;
   std::unique_ptr<RleBpDataDecoder> rleBooleanDecoder_;
   // Add decoders for other encodings here.
 };
@@ -537,6 +554,10 @@ void PageReader::readWithVisitor(Visitor& visitor) {
       !std::is_same_v<typename Visitor::FilterType, common::AlwaysTrue>;
   constexpr bool filterOnly =
       std::is_same_v<typename Visitor::Extract, dwio::common::DropValues>;
+  constexpr bool hasHook = Visitor::kHasHook;
+  static_assert(
+      !(hasFilter && hasHook), "hasFilter and hasHook cannot both be true");
+
   bool mayProduceNulls = !filterOnly && visitor.allowNulls();
   auto rows = visitor.rows();
   auto numRows = visitor.numRows();
@@ -544,11 +565,13 @@ void PageReader::readWithVisitor(Visitor& visitor) {
   startVisit(folly::Range<const vector_size_t*>(rows, numRows));
   rowsCopy_ = &visitor.rowsCopy();
   folly::Range<const vector_size_t*> pageRows;
+  int32_t numPageRowsRead = 0;
   const uint64_t* nulls = nullptr;
   bool isMultiPage = false;
   while (rowsForPage(reader, hasFilter, mayProduceNulls, pageRows, nulls)) {
     bool nullsFromFastPath = false;
-    int32_t numValuesBeforePage = numRowsInReader<hasFilter>(reader);
+    const int32_t numValuesBeforePage =
+        numValuesRead<hasFilter, hasHook>(reader, numPageRowsRead);
     visitor.setNumValuesBias(numValuesBeforePage);
     visitor.setRows(pageRows);
     callDecoder(nulls, nullsFromFastPath, visitor);
@@ -571,20 +594,23 @@ void PageReader::readWithVisitor(Visitor& visitor) {
         }
         if (!nulls) {
           nullConcatenation_.appendOnes(
-              numRowsInReader<hasFilter>(reader) - numValuesBeforePage);
+              numValuesRead<hasFilter, hasHook>(reader, numPageRowsRead) -
+              numValuesBeforePage);
         } else if (reader.returnReaderNulls()) {
           // Nulls from decoding go directly to result.
           nullConcatenation_.append(
               reader.nullsInReadRange()->template as<uint64_t>(),
               0,
-              numRowsInReader<hasFilter>(reader) - numValuesBeforePage);
+              numValuesRead<hasFilter, hasHook>(reader, numPageRowsRead) -
+                  numValuesBeforePage);
         } else {
           // Add the nulls produced from the decoder to the result.
           auto firstNullIndex = nullsFromFastPath ? 0 : numValuesBeforePage;
           nullConcatenation_.append(
               reader.mutableNulls(0),
               firstNullIndex,
-              firstNullIndex + numRowsInReader<hasFilter>(reader) -
+              firstNullIndex +
+                  numValuesRead<hasFilter, hasHook>(reader, numPageRowsRead) -
                   numValuesBeforePage);
         }
       }
@@ -598,6 +624,7 @@ void PageReader::readWithVisitor(Visitor& visitor) {
     if (hasFilter && rowNumberBias_) {
       reader.offsetOutputRows(numValuesBeforePage, rowNumberBias_);
     }
+    numPageRowsRead += pageRows.size();
   }
   if (isMultiPage) {
     reader.setNulls(mayProduceNulls ? nullConcatenation_.buffer() : nullptr);
diff --git a/velox/dwio/parquet/reader/ParquetColumnReader.cpp b/velox/dwio/parquet/reader/ParquetColumnReader.cpp
index 0b69f446280..b041d9f94be 100644
--- a/velox/dwio/parquet/reader/ParquetColumnReader.cpp
+++ b/velox/dwio/parquet/reader/ParquetColumnReader.cpp
@@ -27,6 +27,7 @@
 #include "velox/dwio/parquet/reader/RepeatedColumnReader.h"
 #include "velox/dwio/parquet/reader/StringColumnReader.h"
 #include "velox/dwio/parquet/reader/StructColumnReader.h"
+#include "velox/dwio/parquet/reader/TimeColumnReader.h"
 #include "velox/dwio/parquet/reader/TimestampColumnReader.h"
 #include "velox/dwio/parquet/thrift/ParquetThriftTypes.h"
 
@@ -39,8 +40,20 @@ std::unique_ptr<dwio::common::SelectiveColumnReader> ParquetColumnReader::build(
     const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     ParquetParams& params,
     common::ScanSpec& scanSpec) {
+  VELOX_CHECK_EQ(
+      static_cast<int>(scanSpec.extractionType()),
+      static_cast<int>(common::ScanSpec::ExtractionType::kNone),
+      "Parquet reader does not support extraction pushdown");
   auto colName = scanSpec.fieldName();
 
+  if (fileType->type()->isTime()) {
+    VELOX_CHECK(
+        fileType->type()->equivalent(*TIME()) ||
+        fileType->type()->equivalent(*TIME_MICRO_UTC()));
+    return std::make_unique<TimeColumnReader>(
+        requestedType, fileType, params, scanSpec);
+  }
+
   switch (fileType->type()->kind()) {
     case TypeKind::INTEGER:
     case TypeKind::BIGINT:
@@ -51,8 +64,13 @@ std::unique_ptr<dwio::common::SelectiveColumnReader> ParquetColumnReader::build(
           requestedType, fileType, params, scanSpec);
 
     case TypeKind::REAL:
-      return std::make_unique<FloatingPointColumnReader<float, float>>(
-          requestedType, fileType, params, scanSpec);
+      if (requestedType->kind() == TypeKind::REAL) {
+        return std::make_unique<FloatingPointColumnReader<float, float>>(
+            requestedType, fileType, params, scanSpec);
+      } else {
+        return std::make_unique<FloatingPointColumnReader<float, double>>(
+            requestedType, fileType, params, scanSpec);
+      }
     case TypeKind::DOUBLE:
       return std::make_unique<FloatingPointColumnReader<double, double>>(
           requestedType, fileType, params, scanSpec);
@@ -65,9 +83,11 @@ std::unique_ptr<dwio::common::SelectiveColumnReader> ParquetColumnReader::build(
     case TypeKind::VARCHAR:
       return std::make_unique<StringColumnReader>(fileType, params, scanSpec);
 
-    case TypeKind::ARRAY:
+    case TypeKind::ARRAY: {
+      VELOX_CHECK(requestedType->isArray(), "Requested type must be array");
       return std::make_unique<ListColumnReader>(
           columnReaderOptions, requestedType, fileType, params, scanSpec);
+    }
 
     case TypeKind::MAP:
       return std::make_unique<MapColumnReader>(
@@ -97,7 +117,7 @@ std::unique_ptr<dwio::common::SelectiveColumnReader> ParquetColumnReader::build(
     default:
       VELOX_FAIL(
           "buildReader unhandled type: " +
-          mapTypeKindToName(fileType->type()->kind()));
+          std::string(TypeKindName::toName(fileType->type()->kind())));
   }
 }
 
diff --git a/velox/dwio/parquet/reader/ParquetData.cpp b/velox/dwio/parquet/reader/ParquetData.cpp
index 788d04e3962..d91e07949c5 100644
--- a/velox/dwio/parquet/reader/ParquetData.cpp
+++ b/velox/dwio/parquet/reader/ParquetData.cpp
@@ -25,7 +25,7 @@ std::unique_ptr<dwio::common::FormatData> ParquetParams::toFormatData(
     const std::shared_ptr<const dwio::common::TypeWithId>& type,
     const common::ScanSpec& /*scanSpec*/) {
   return std::make_unique<ParquetData>(
-      type, metaData_, pool(), sessionTimezone_);
+      type, metaData_, pool(), runtimeStatistics(), sessionTimezone_);
 }
 
 void ParquetData::filterRowGroups(
@@ -128,6 +128,7 @@ dwio::common::PositionProvider ParquetData::seekToRowGroup(int64_t index) {
       type_,
       metadata.compression(),
       metadata.totalCompressedSize(),
+      stats_,
       sessionTimezone_);
   return dwio::common::PositionProvider(empty);
 }
@@ -137,7 +138,8 @@ std::pair<int64_t, int64_t> ParquetData::getRowGroupRegion(
   auto rowGroup = fileMetaDataPtr_.rowGroup(index);
 
   VELOX_CHECK_GT(rowGroup.numColumns(), 0);
-  auto fileOffset = rowGroup.hasFileOffset() ? rowGroup.fileOffset()
+  auto fileOffset = (rowGroup.hasFileOffset() && rowGroup.fileOffset() != 0)
+      ? rowGroup.fileOffset()
       : rowGroup.columnChunk(0).hasDictionaryPageOffset()
       ? rowGroup.columnChunk(0).dictionaryPageOffset()
       : rowGroup.columnChunk(0).dataPageOffset();
diff --git a/velox/dwio/parquet/reader/ParquetData.h b/velox/dwio/parquet/reader/ParquetData.h
index 1ea4a1e8c77..9926202491d 100644
--- a/velox/dwio/parquet/reader/ParquetData.h
+++ b/velox/dwio/parquet/reader/ParquetData.h
@@ -63,6 +63,7 @@ class ParquetData : public dwio::common::FormatData {
       const std::shared_ptr<const dwio::common::TypeWithId>& type,
       const FileMetaDataPtr fileMetadataPtr,
       memory::MemoryPool& pool,
+      dwio::common::ColumnReaderStatistics& stats,
       const tz::TimeZone* sessionTimezone)
       : pool_(pool),
         type_(std::static_pointer_cast<const ParquetTypeWithId>(type)),
@@ -70,6 +71,7 @@ class ParquetData : public dwio::common::FormatData {
         maxDefine_(type_->maxDefine_),
         maxRepeat_(type_->maxRepeat_),
         rowsInRowGroup_(-1),
+        stats_(stats),
         sessionTimezone_(sessionTimezone) {}
 
   /// Prepares to read data for 'index'th row group.
@@ -90,8 +92,9 @@ class ParquetData : public dwio::common::FormatData {
     return reader_.get();
   }
 
-  // Reads null flags for 'numValues' next top level rows. The first 'numValues'
-  // bits of 'nulls' are set and the reader is advanced by numValues'.
+  // Reads null flags for 'numValues' next top level rows. The first
+  // 'numValues' bits of 'nulls' are set and the reader is advanced by
+  // numValues'.
   void readNullsOnly(int32_t numValues, BufferPtr& nulls) {
     reader_->readNullsOnly(numValues, nulls);
   }
@@ -100,8 +103,9 @@ class ParquetData : public dwio::common::FormatData {
     return maxDefine_ > 0;
   }
 
-  /// Sets nulls to be returned by readNulls(). Nulls for non-leaf readers come
-  /// from leaf repdefs which are gathered before descending the reader tree.
+  /// Sets nulls to be returned by readNulls(). Nulls for non-leaf readers
+  /// come from leaf repdefs which are gathered before descending the reader
+  /// tree.
   void setNulls(BufferPtr& nulls, int32_t numValues) {
     if (nulls || numValues) {
       VELOX_CHECK_EQ(presetNullsConsumed_, presetNullsSize_);
@@ -120,8 +124,8 @@ class ParquetData : public dwio::common::FormatData {
       const uint64_t* incomingNulls,
       BufferPtr& nulls,
       bool nullsOnly = false) override {
-    // If the query accesses only nulls, read the nulls from the pages in range.
-    // If nulls are preread, return those minus any skipped.
+    // If the query accesses only nulls, read the nulls from the pages in
+    // range. If nulls are preread, return those minus any skipped.
     if (presetNulls_) {
       VELOX_CHECK_LE(numValues, presetNullsSize_ - presetNullsConsumed_);
       if (!presetNullsConsumed_ && numValues == presetNullsSize_) {
@@ -144,8 +148,8 @@ class ParquetData : public dwio::common::FormatData {
       readNullsOnly(numValues, nulls);
       return;
     }
-    // There are no column-level nulls in Parquet, only page-level ones, so this
-    // is always non-null.
+    // There are no column-level nulls in Parquet, only page-level ones, so
+    // this is always non-null.
     nulls = nullptr;
   }
 
@@ -219,6 +223,7 @@ class ParquetData : public dwio::common::FormatData {
   const uint32_t maxDefine_;
   const uint32_t maxRepeat_;
   int64_t rowsInRowGroup_;
+  dwio::common::ColumnReaderStatistics& stats_;
   const tz::TimeZone* sessionTimezone_;
   std::unique_ptr<PageReader> reader_;
 
diff --git a/velox/dwio/parquet/reader/ParquetReader.cpp b/velox/dwio/parquet/reader/ParquetReader.cpp
index 955abc91b8a..005be63f15e 100644
--- a/velox/dwio/parquet/reader/ParquetReader.cpp
+++ b/velox/dwio/parquet/reader/ParquetReader.cpp
@@ -18,7 +18,9 @@
 
 #include <thrift/protocol/TCompactProtocol.h> //@manual
 
+#include "velox/dwio/common/StatisticsBuilder.h"
 #include "velox/dwio/parquet/reader/ParquetColumnReader.h"
+#include "velox/dwio/parquet/reader/ParquetStatsContext.h"
 #include "velox/dwio/parquet/reader/StructColumnReader.h"
 #include "velox/dwio/parquet/thrift/ThriftTransport.h"
 #include "velox/functions/lib/string/StringImpl.h"
@@ -27,16 +29,109 @@ namespace facebook::velox::parquet {
 
 namespace {
 
+/// Finds the node with the given ID in the TypeWithId tree. Uses a full
+/// traversal because Parquet's TypeWithId nodes all share the same maxId
+/// (the global max schema element index), so the maxId-based pruning used
+/// by ORC/DWRF does not work here.
+const dwio::common::TypeWithId* findNode(
+    const dwio::common::TypeWithId& root,
+    uint32_t nodeId) {
+  if (root.id() == nodeId) {
+    return &root;
+  }
+  for (auto i = 0; i < root.size(); ++i) {
+    if (auto* result = findNode(*root.childAt(i), nodeId)) {
+      return result;
+    }
+  }
+  return nullptr;
+}
+
 bool isParquetReservedKeyword(
     std::string name,
     uint32_t parentSchemaIdx,
     uint32_t curSchemaIdx) {
-  return ((parentSchemaIdx == 0 && curSchemaIdx == 0) || name == "key_value" ||
-          name == "key" || name == "value" || name == "list" ||
-          name == "element" || name == "bag" || name == "array_element")
+  // We skip this for the top-level nodes.
+  return ((parentSchemaIdx == 0 && curSchemaIdx == 0) ||
+          (parentSchemaIdx != 0 &&
+           (name == "key_value" || name == "key" || name == "value" ||
+            name == "list" || name == "element" || name == "bag" ||
+            name == "array_element")))
       ? true
       : false;
 }
+
+// An unannotated array in Parquet is a repeated field that is not explicitly
+// marked as a LIST logical type. If current schema element is a repeated field
+// and the requested type is an array, we treat the current schema element as an
+// unannotated array, and returns true if the element type is compatible with
+// the physical type.
+bool isCompatible(
+    const TypePtr& requestedType,
+    bool isRepeated,
+    const std::function<bool(const TypePtr&)>& isCompatibleFunc) {
+  return isCompatibleFunc(requestedType) ||
+      (requestedType->isArray() && isRepeated &&
+       isCompatibleFunc(requestedType->asArray().elementType()));
+}
+
+// Checks if a decimal type has enough integer precision to hold all values
+// of the given Parquet physical int type.
+bool hasEnoughDecimalPrecision(const TypePtr& type, int32_t minIntegerDigits) {
+  if (!type->isDecimal()) {
+    return false;
+  }
+  auto [precision, scale] = getDecimalPrecisionScale(*type);
+  return (precision - scale) >= minIntegerDigits;
+}
+
+// Checks if a type is compatible with an INT32 physical type.
+// INT_8, INT_16, and INT_32 are all stored as Parquet INT32.
+// 'minTypeKind' is the smallest Velox type that matches the file's
+// converted type annotation (TINYINT for INT_8, SMALLINT for INT_16,
+// INTEGER for INT_32 or unannotated INT32).
+// For decimal targets, requires precision - scale >= 10.
+// When 'allowNarrowing' is true, any integer type is accepted and the
+// value is silently truncated on overflow. When false, only same-size
+// or wider types are allowed.
+bool isInt32Compatible(
+    const TypePtr& type,
+    TypeKind minTypeKind,
+    bool allowNarrowing) {
+  static_assert(
+      TypeKind::TINYINT < TypeKind::SMALLINT &&
+          TypeKind::SMALLINT < TypeKind::INTEGER &&
+          TypeKind::INTEGER < TypeKind::BIGINT,
+      "TypeKind enum ordering mismatch");
+
+  if (type->isDecimal()) {
+    return hasEnoughDecimalPrecision(type, 10);
+  }
+
+  auto kind = type->kind();
+  switch (kind) {
+    case TypeKind::TINYINT:
+    case TypeKind::SMALLINT:
+    case TypeKind::INTEGER:
+    case TypeKind::BIGINT:
+      return allowNarrowing || kind >= minTypeKind;
+    case TypeKind::DOUBLE:
+      return true;
+    default:
+      return false;
+  }
+}
+
+// Checks whether the given type is compatible with a Parquet INT64 source.
+// Accepts BIGINT identity mapping and Decimal targets with sufficient
+// precision (precision - scale >= 20, covering the full INT64 range).
+bool isInt64Compatible(const TypePtr& type) {
+  if (type->isDecimal()) {
+    return hasEnoughDecimalPrecision(type, 20);
+  }
+  return type->kind() == TypeKind::BIGINT;
+}
+
 } // namespace
 
 /// Metadata and options for reading Parquet.
@@ -138,7 +233,7 @@ class ReaderBase {
       bool fileColumnNamesReadAsLowerCase);
 
   memory::MemoryPool& pool_;
-  const uint64_t footerEstimatedSize_;
+  const uint64_t footerSpeculativeIoSize_;
   const uint64_t filePreloadThreshold_;
   // Copy of options. Must be owned by 'this'.
   const dwio::common::ReaderOptions options_;
@@ -159,7 +254,7 @@ ReaderBase::ReaderBase(
     std::unique_ptr<dwio::common::BufferedInput> input,
     const dwio::common::ReaderOptions& options)
     : pool_{options.memoryPool()},
-      footerEstimatedSize_{options.footerEstimatedSize()},
+      footerSpeculativeIoSize_{options.footerSpeculativeIoSize()},
       filePreloadThreshold_{options.filePreloadThreshold()},
       options_{options},
       input_{std::move(input)},
@@ -174,8 +269,8 @@ ReaderBase::ReaderBase(
 
 void ReaderBase::loadFileMetaData() {
   bool preloadFile =
-      fileLength_ <= std::max(filePreloadThreshold_, footerEstimatedSize_);
-  uint64_t readSize = preloadFile ? fileLength_ : footerEstimatedSize_;
+      fileLength_ <= std::max(filePreloadThreshold_, footerSpeculativeIoSize_);
+  uint64_t readSize = preloadFile ? fileLength_ : footerSpeculativeIoSize_;
 
   std::unique_ptr<dwio::common::SeekableInputStream> stream;
   if (preloadFile) {
@@ -308,8 +403,7 @@ std::unique_ptr<ParquetTypeWithId> ReaderBase::getParquetColumnInfo(
     name = functions::stringImpl::utf8StrToLowerCopy(name);
   }
 
-  if ((!options_.useColumnNamesForColumnMapping()) &&
-      (options_.fileSchema() != nullptr)) {
+  if (!options_.useColumnNamesForColumnMapping() && options_.fileSchema()) {
     if (isParquetReservedKeyword(name, parentSchemaIdx, curSchemaIdx)) {
       columnNames.push_back(name);
     }
@@ -337,21 +431,37 @@ std::unique_ptr<ParquetTypeWithId> ReaderBase::getParquetColumnInfo(
 
       TypePtr childRequestedType = nullptr;
       bool followChild = true;
-      if (requestedType && requestedType->isRow()) {
-        auto requestedRowType =
-            std::dynamic_pointer_cast<const velox::RowType>(requestedType);
-        if (options_.useColumnNamesForColumnMapping()) {
-          auto fileTypeIdx = requestedRowType->getChildIdxIfExists(childName);
-          if (fileTypeIdx.has_value()) {
-            childRequestedType = requestedRowType->childAt(*fileTypeIdx);
+
+      {
+        RowTypePtr requestedRowType = nullptr;
+        if (requestedType) {
+          if (requestedType->isRow()) {
+            requestedRowType =
+                std::dynamic_pointer_cast<const velox::RowType>(requestedType);
+          } else if (
+              requestedType->isArray() && isRepeated &&
+              requestedType->asArray().elementType()->isRow()) {
+            // Handle the case of unannotated array of structs (repeated group
+            // without LIST annotation).
+            requestedRowType = std::dynamic_pointer_cast<const velox::RowType>(
+                requestedType->asArray().elementType());
           }
-        } else {
-          // Handle schema evolution.
-          if (i < requestedRowType->size()) {
-            columnNames.push_back(requestedRowType->nameOf(i));
-            childRequestedType = requestedRowType->childAt(i);
+        }
+
+        if (requestedRowType) {
+          if (options_.useColumnNamesForColumnMapping()) {
+            auto fileTypeIdx = requestedRowType->getChildIdxIfExists(childName);
+            if (fileTypeIdx.has_value()) {
+              childRequestedType = requestedRowType->childAt(*fileTypeIdx);
+            }
           } else {
-            followChild = false;
+            // Handle schema evolution.
+            if (i < requestedRowType->size()) {
+              columnNames.push_back(requestedRowType->nameOf(i));
+              childRequestedType = requestedRowType->childAt(i);
+            } else {
+              followChild = false;
+            }
           }
         }
       }
@@ -534,20 +644,21 @@ std::unique_ptr<ParquetTypeWithId> ReaderBase::getParquetColumnInfo(
             // In this legacy case, there is no middle layer between "array"
             // node and the children nodes. Below creates this dummy middle
             // layer to mimic the non-legacy case and fill the gap.
-            rowChildren.emplace_back(std::make_unique<ParquetTypeWithId>(
-                childrenRowType,
-                std::move(children),
-                curSchemaIdx,
-                maxSchemaElementIdx,
-                ParquetTypeWithId::kNonLeaf,
-                "dummy",
-                std::nullopt,
-                std::nullopt,
-                std::nullopt,
-                maxRepeat,
-                maxDefine,
-                isOptional,
-                isRepeated));
+            rowChildren.emplace_back(
+                std::make_unique<ParquetTypeWithId>(
+                    childrenRowType,
+                    std::move(children),
+                    curSchemaIdx,
+                    maxSchemaElementIdx,
+                    ParquetTypeWithId::kNonLeaf,
+                    "dummy",
+                    std::nullopt,
+                    std::nullopt,
+                    std::nullopt,
+                    maxRepeat,
+                    maxDefine,
+                    isOptional,
+                    isRepeated));
             auto res = std::make_unique<ParquetTypeWithId>(
                 TypeFactory<TypeKind::ARRAY>::create(childrenRowType),
                 std::move(rowChildren),
@@ -598,20 +709,21 @@ std::unique_ptr<ParquetTypeWithId> ReaderBase::getParquetColumnInfo(
           // In this legacy case, there is no middle layer between "array"
           // node and the children nodes. Below creates this dummy middle
           // layer to mimic the non-legacy case and fill the gap.
-          rowChildren.emplace_back(std::make_unique<ParquetTypeWithId>(
-              childrenRowType,
-              std::move(children),
-              curSchemaIdx,
-              maxSchemaElementIdx,
-              ParquetTypeWithId::kNonLeaf,
-              "dummy",
-              std::nullopt,
-              std::nullopt,
-              std::nullopt,
-              maxRepeat,
-              maxDefine,
-              isOptional,
-              isRepeated));
+          rowChildren.emplace_back(
+              std::make_unique<ParquetTypeWithId>(
+                  childrenRowType,
+                  std::move(children),
+                  curSchemaIdx,
+                  maxSchemaElementIdx,
+                  ParquetTypeWithId::kNonLeaf,
+                  "dummy",
+                  std::nullopt,
+                  std::nullopt,
+                  std::nullopt,
+                  maxRepeat,
+                  maxDefine,
+                  isOptional,
+                  isRepeated));
           return std::make_unique<ParquetTypeWithId>(
               TypeFactory<TypeKind::ARRAY>::create(childrenRowType),
               std::move(rowChildren),
@@ -720,8 +832,13 @@ TypePtr ReaderBase::convertType(
           schemaElement.__isset.type_length,
       "FIXED_LEN_BYTE_ARRAY requires length to be set");
 
-  static std::string_view kTypeMappingErrorFmtStr =
-      "Converted type {} is not allowed for requested type {}";
+  static constexpr const char* kTypeMappingErrorFmtStr =
+      "Converted type {} is not allowed for requested type {} for file column '{}'";
+
+  const bool isRepeated = schemaElement.__isset.repetition_type &&
+      schemaElement.repetition_type == thrift::FieldRepetitionType::REPEATED;
+  const bool allowNarrowing = options_.allowInt32Narrowing();
+
   if (schemaElement.__isset.converted_type) {
     switch (schemaElement.converted_type) {
       case thrift::ConvertedType::INT_8:
@@ -732,13 +849,18 @@ TypePtr ReaderBase::convertType(
             "{} converted type can only be set for value of thrift::Type::INT32",
             schemaElement.converted_type);
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::TINYINT ||
-                requestedType->kind() == TypeKind::SMALLINT ||
-                requestedType->kind() == TypeKind::INTEGER ||
-                requestedType->kind() == TypeKind::BIGINT,
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [&](const TypePtr& type) {
+                      return isInt32Compatible(
+                          type, TypeKind::TINYINT, allowNarrowing);
+                    }),
             kTypeMappingErrorFmtStr,
             "TINYINT",
-            requestedType->toString());
+            requestedType->toString(),
+            schemaElement.name);
         return TINYINT();
 
       case thrift::ConvertedType::INT_16:
@@ -749,12 +871,18 @@ TypePtr ReaderBase::convertType(
             "{} converted type can only be set for value of thrift::Type::INT32",
             schemaElement.converted_type);
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::SMALLINT ||
-                requestedType->kind() == TypeKind::INTEGER ||
-                requestedType->kind() == TypeKind::BIGINT,
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [&](const TypePtr& type) {
+                      return isInt32Compatible(
+                          type, TypeKind::SMALLINT, allowNarrowing);
+                    }),
             kTypeMappingErrorFmtStr,
             "SMALLINT",
-            requestedType->toString());
+            requestedType->toString(),
+            schemaElement.name);
         return SMALLINT();
 
       case thrift::ConvertedType::INT_32:
@@ -765,11 +893,18 @@ TypePtr ReaderBase::convertType(
             "{} converted type can only be set for value of thrift::Type::INT32",
             schemaElement.converted_type);
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::INTEGER ||
-                requestedType->kind() == TypeKind::BIGINT,
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [&](const TypePtr& type) {
+                      return isInt32Compatible(
+                          type, TypeKind::INTEGER, allowNarrowing);
+                    }),
             kTypeMappingErrorFmtStr,
             "INTEGER",
-            requestedType->toString());
+            requestedType->toString(),
+            schemaElement.name);
         return INTEGER();
 
       case thrift::ConvertedType::INT_64:
@@ -777,13 +912,15 @@ TypePtr ReaderBase::convertType(
         VELOX_CHECK_EQ(
             schemaElement.type,
             thrift::Type::INT64,
-            "{} converted type can only be set for value of thrift::Type::INT32",
+            "{} converted type can only be set for value of thrift::Type::INT64",
             schemaElement.converted_type);
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::BIGINT,
+            !requestedType ||
+                isCompatible(requestedType, isRepeated, isInt64Compatible),
             kTypeMappingErrorFmtStr,
             "BIGINT",
-            requestedType->toString());
+            requestedType->toString(),
+            schemaElement.name);
         return BIGINT();
 
       case thrift::ConvertedType::DATE:
@@ -792,10 +929,15 @@ TypePtr ReaderBase::convertType(
             thrift::Type::INT32,
             "DATE converted type can only be set for value of thrift::Type::INT32");
         VELOX_CHECK(
-            !requestedType || requestedType->isDate(),
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [](const TypePtr& type) { return type->isDate(); }),
             kTypeMappingErrorFmtStr,
             "DATE",
-            requestedType->toString());
+            requestedType->toString(),
+            schemaElement.name);
         return DATE();
 
       case thrift::ConvertedType::TIMESTAMP_MICROS:
@@ -805,10 +947,17 @@ TypePtr ReaderBase::convertType(
             thrift::Type::INT64,
             "TIMESTAMP_MICROS or TIMESTAMP_MILLIS converted type can only be set for value of thrift::Type::INT64");
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::TIMESTAMP,
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [](const TypePtr& type) {
+                      return type->kind() == TypeKind::TIMESTAMP;
+                    }),
             kTypeMappingErrorFmtStr,
             "TIMESTAMP",
-            requestedType->toString());
+            requestedType->toString(),
+            schemaElement.name);
         return TIMESTAMP();
 
       case thrift::ConvertedType::DECIMAL: {
@@ -817,39 +966,35 @@ TypePtr ReaderBase::convertType(
             "DECIMAL requires a length and scale specifier!");
         const auto schemaElementPrecision = schemaElement.precision;
         const auto schemaElementScale = schemaElement.scale;
-        // A long decimal requested type cannot read a value of a short decimal.
-        // As a result, the mapping from short to long decimal is currently
-        // restricted.
         auto type = DECIMAL(schemaElementPrecision, schemaElementScale);
         if (requestedType) {
           VELOX_CHECK(
-              requestedType->isDecimal(),
+              isCompatible(
+                  requestedType,
+                  isRepeated,
+                  [](const TypePtr& type) { return type->isDecimal(); }),
               kTypeMappingErrorFmtStr,
               "DECIMAL",
-              requestedType->toString());
-          // Reading short decimals with a long decimal requested type is not
-          // yet possible. To allow for correct interpretation of the values,
-          // the scale of the file type and requested type must match while
-          // precision may be larger.
-          if (requestedType->isShortDecimal()) {
-            const auto& shortDecimalType = requestedType->asShortDecimal();
-            VELOX_CHECK(
-                type->isShortDecimal() &&
-                    shortDecimalType.precision() >= schemaElementPrecision &&
-                    shortDecimalType.scale() == schemaElementScale,
-                kTypeMappingErrorFmtStr,
-                type->toString(),
-                requestedType->toString());
-          } else {
-            const auto& longDecimalType = requestedType->asLongDecimal();
-            VELOX_CHECK(
-                type->isLongDecimal() &&
-                    longDecimalType.precision() >= schemaElementPrecision &&
-                    longDecimalType.scale() == schemaElementScale,
-                kTypeMappingErrorFmtStr,
-                type->toString(),
-                requestedType->toString());
-          }
+              requestedType->toString(),
+              schemaElement.name);
+          // Allow decimal widening: precision may be larger and scale may
+          // increase as long as precisionIncrease >= scaleIncrease.
+          // Short-to-long decimal crossing is handled by getDecimalValues
+          // via the upcast path.
+          VELOX_CHECK(
+              isCompatible(
+                  requestedType,
+                  isRepeated,
+                  [&](const TypePtr& type) {
+                    auto [precision, scale] = getDecimalPrecisionScale(*type);
+                    auto precisionInc = precision - schemaElementPrecision;
+                    auto scaleInc = scale - schemaElementScale;
+                    return scaleInc >= 0 && precisionInc >= scaleInc;
+                  }),
+              kTypeMappingErrorFmtStr,
+              type->toString(),
+              requestedType->toString(),
+              schemaElement.name);
         }
         return type;
       }
@@ -859,10 +1004,17 @@ TypePtr ReaderBase::convertType(
           case thrift::Type::BYTE_ARRAY:
           case thrift::Type::FIXED_LEN_BYTE_ARRAY:
             VELOX_CHECK(
-                !requestedType || requestedType->kind() == TypeKind::VARCHAR,
+                !requestedType ||
+                    isCompatible(
+                        requestedType,
+                        isRepeated,
+                        [](const TypePtr& type) {
+                          return type->kind() == TypeKind::VARCHAR;
+                        }),
                 kTypeMappingErrorFmtStr,
                 "VARCHAR",
-                requestedType->toString());
+                requestedType->toString(),
+                schemaElement.name);
             return VARCHAR();
           default:
             VELOX_FAIL(
@@ -874,17 +1026,58 @@ TypePtr ReaderBase::convertType(
             thrift::Type::BYTE_ARRAY,
             "ENUM converted type can only be set for value of thrift::Type::BYTE_ARRAY");
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::VARCHAR,
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [](const TypePtr& type) {
+                      return type->kind() == TypeKind::VARCHAR;
+                    }),
             kTypeMappingErrorFmtStr,
             "VARCHAR",
-            requestedType->toString());
+            requestedType->toString(),
+            schemaElement.name);
         return VARCHAR();
       }
+      case thrift::ConvertedType::TIME_MILLIS:
+        VELOX_CHECK_EQ(
+            schemaElement.type,
+            thrift::Type::INT32,
+            "TIME_MILLIS converted type can only be set for value of thrift::Type::INT32");
+        VELOX_CHECK(
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [](const TypePtr& type) {
+                      return type->equivalent(*TIME());
+                    }),
+            kTypeMappingErrorFmtStr,
+            "TIME",
+            requestedType->toString(),
+            schemaElement.name);
+        return TIME();
+
+      case thrift::ConvertedType::TIME_MICROS: {
+        VELOX_CHECK_EQ(
+            schemaElement.type,
+            thrift::Type::INT64,
+            "TIME_MICROS converted type can only be set for value of thrift::Type::INT64");
+        const bool isCompatibleRequestedType = !requestedType ||
+            isCompatible(requestedType, isRepeated, [](const TypePtr& type) {
+              return type->equivalent(*TIME_MICRO_UTC());
+            });
+        VELOX_CHECK(
+            isCompatibleRequestedType,
+            kTypeMappingErrorFmtStr,
+            "TIME MICRO UTC",
+            requestedType->toString());
+        return TIME_MICRO_UTC();
+      }
+
       case thrift::ConvertedType::MAP:
       case thrift::ConvertedType::MAP_KEY_VALUE:
       case thrift::ConvertedType::LIST:
-      case thrift::ConvertedType::TIME_MILLIS:
-      case thrift::ConvertedType::TIME_MICROS:
       case thrift::ConvertedType::JSON:
       case thrift::ConvertedType::BSON:
       case thrift::ConvertedType::INTERVAL:
@@ -897,68 +1090,120 @@ TypePtr ReaderBase::convertType(
     switch (schemaElement.type) {
       case thrift::Type::type::BOOLEAN:
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::BOOLEAN,
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [](const TypePtr& type) {
+                      return type->kind() == TypeKind::BOOLEAN;
+                    }),
             kTypeMappingErrorFmtStr,
             "BOOLEAN",
-            requestedType->toString());
+            requestedType->toString(),
+            schemaElement.name);
         return BOOLEAN();
       case thrift::Type::type::INT32:
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::INTEGER ||
-                requestedType->kind() == TypeKind::BIGINT,
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [&](const TypePtr& type) {
+                      return isInt32Compatible(
+                          type, TypeKind::INTEGER, allowNarrowing);
+                    }),
             kTypeMappingErrorFmtStr,
             "INTEGER",
-            requestedType->toString());
+            requestedType->toString(),
+            schemaElement.name);
         return INTEGER();
       case thrift::Type::type::INT64:
         // For Int64 Timestamp in nano precision
         if (schemaElement.__isset.logicalType &&
             schemaElement.logicalType.__isset.TIMESTAMP) {
           VELOX_CHECK(
-              !requestedType || requestedType->kind() == TypeKind::TIMESTAMP,
+              !requestedType ||
+                  isCompatible(
+                      requestedType,
+                      isRepeated,
+                      [](const TypePtr& type) {
+                        return type->kind() == TypeKind::TIMESTAMP;
+                      }),
               kTypeMappingErrorFmtStr,
               "TIMESTAMP",
-              requestedType->toString());
+              requestedType->toString(),
+              schemaElement.name);
           return TIMESTAMP();
         }
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::BIGINT,
+            !requestedType ||
+                isCompatible(requestedType, isRepeated, isInt64Compatible),
             kTypeMappingErrorFmtStr,
             "BIGINT",
-            requestedType->toString());
+            requestedType->toString(),
+            schemaElement.name);
         return BIGINT();
       case thrift::Type::type::INT96:
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::TIMESTAMP,
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [](const TypePtr& type) {
+                      return type->kind() == TypeKind::TIMESTAMP;
+                    }),
             kTypeMappingErrorFmtStr,
             "TIMESTAMP",
-            requestedType->toString());
+            requestedType->toString(),
+            schemaElement.name);
         return TIMESTAMP(); // INT96 only maps to a timestamp
       case thrift::Type::type::FLOAT:
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::REAL ||
-                requestedType->kind() == TypeKind::DOUBLE,
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [](const TypePtr& type) {
+                      return type->kind() == TypeKind::REAL ||
+                          type->kind() == TypeKind::DOUBLE;
+                    }),
             kTypeMappingErrorFmtStr,
             "REAL",
-            requestedType->toString());
+            requestedType->toString(),
+            schemaElement.name);
         return REAL();
       case thrift::Type::type::DOUBLE:
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::DOUBLE,
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [](const TypePtr& type) {
+                      return type->kind() == TypeKind::DOUBLE;
+                    }),
             kTypeMappingErrorFmtStr,
             "DOUBLE",
-            requestedType->toString());
+            requestedType->toString(),
+            schemaElement.name);
         return DOUBLE();
       case thrift::Type::type::BYTE_ARRAY:
       case thrift::Type::type::FIXED_LEN_BYTE_ARRAY:
-        if (requestedType && requestedType->isVarchar()) {
+        if (requestedType &&
+            isCompatible(requestedType, isRepeated, [](const TypePtr& type) {
+              return type->isVarchar();
+            })) {
           return VARCHAR();
         } else {
           VELOX_CHECK(
-              !requestedType || requestedType->isVarbinary(),
+              !requestedType ||
+                  isCompatible(
+                      requestedType,
+                      isRepeated,
+                      [](const TypePtr& type) { return type->isVarbinary(); }),
               kTypeMappingErrorFmtStr,
               "VARBINARY",
-              requestedType->toString());
+              requestedType->toString(),
+              schemaElement.name);
           return VARBINARY();
         }
 
@@ -1099,7 +1344,8 @@ class ParquetRowReader::Impl {
     uint64_t rowNumber = 0;
     for (auto i = 0; i < rowGroups_.size(); i++) {
       VELOX_CHECK_GT(rowGroups_[i].columns.size(), 0);
-      auto fileOffset = rowGroups_[i].__isset.file_offset
+      auto fileOffset =
+          (rowGroups_[i].__isset.file_offset && rowGroups_[i].file_offset != 0)
           ? rowGroups_[i].file_offset
           : rowGroups_[i].columns[0].meta_data.__isset.dictionary_page_offset
           ? rowGroups_[i].columns[0].meta_data.dictionary_page_offset
@@ -1178,14 +1424,21 @@ class ParquetRowReader::Impl {
   std::optional<size_t> estimatedRowSize() const {
     auto index =
         nextRowGroupIdsIdx_ < 1 ? 0 : rowGroupIds_[nextRowGroupIdsIdx_ - 1];
-    return readerBase_->rowGroupUncompressedSize(
-               index, *readerBase_->schemaWithId()) /
+    if (index == lastRowGroupWithRowEstimate_) {
+      return estimatedRowSize_;
+    }
+    estimatedRowSize_ = readerBase_->rowGroupUncompressedSize(
+                            index, *readerBase_->schemaWithId()) /
         rowGroups_[index].num_rows;
+    lastRowGroupWithRowEstimate_ = index;
+    return estimatedRowSize_;
   }
 
   void updateRuntimeStats(dwio::common::RuntimeStatistics& stats) const {
     stats.skippedStrides += skippedStrides_;
     stats.processedStrides += rowGroupIds_.size();
+    stats.columnReaderStats.pageLoadTimeNs.merge(
+        columnReaderStats_.pageLoadTimeNs);
   }
 
   void resetFilterCaches() {
@@ -1237,6 +1490,9 @@ class ParquetRowReader::Impl {
   ParquetStatsContext parquetStatsContext_;
 
   dwio::common::ColumnReaderStatistics columnReaderStats_;
+
+  mutable std::optional<size_t> estimatedRowSize_;
+  mutable int32_t lastRowGroupWithRowEstimate_{-1};
 };
 
 ParquetRowReader::ParquetRowReader(
@@ -1290,6 +1546,43 @@ std::optional<uint64_t> ParquetReader::numberOfRows() const {
   return readerBase_->thriftFileMetaData().num_rows;
 }
 
+std::unique_ptr<dwio::common::ColumnStatistics> ParquetReader::columnStatistics(
+    uint32_t index) const {
+  auto node = findNode(*readerBase_->schemaWithId(), index);
+  if (!node) {
+    return nullptr;
+  }
+  auto& parquetNode = static_cast<const ParquetTypeWithId&>(*node);
+  if (!parquetNode.isLeaf()) {
+    return nullptr;
+  }
+
+  auto fileMetaData = readerBase_->fileMetaData();
+  const auto numRowGroups = fileMetaData.numRowGroups();
+  if (numRowGroups == 0) {
+    return nullptr;
+  }
+
+  // Merge per-row-group statistics into file-level statistics.
+  dwio::stats::StatisticsBuilderOptions options{
+      /*stringLengthLimit=*/std::numeric_limits<uint32_t>::max()};
+  auto builder =
+      dwio::stats::StatisticsBuilder::create(*parquetNode.type(), options);
+
+  for (int i = 0; i < numRowGroups; ++i) {
+    auto rowGroup = fileMetaData.rowGroup(i);
+    auto columnChunk = rowGroup.columnChunk(parquetNode.column());
+    if (!columnChunk.hasStatistics()) {
+      return nullptr;
+    }
+    auto rowGroupStats =
+        columnChunk.getColumnStatistics(parquetNode.type(), rowGroup.numRows());
+    builder->merge(*rowGroupStats);
+  }
+
+  return builder->build();
+}
+
 const velox::RowTypePtr& ParquetReader::rowType() const {
   return readerBase_->schema();
 }
diff --git a/velox/dwio/parquet/reader/ParquetReader.h b/velox/dwio/parquet/reader/ParquetReader.h
index de6d7a9966d..dbaa8414d92 100644
--- a/velox/dwio/parquet/reader/ParquetReader.h
+++ b/velox/dwio/parquet/reader/ParquetReader.h
@@ -19,7 +19,6 @@
 #include "velox/dwio/common/Reader.h"
 #include "velox/dwio/common/ReaderFactory.h"
 #include "velox/dwio/parquet/reader/Metadata.h"
-#include "velox/dwio/parquet/reader/ParquetStatsContext.h"
 
 namespace facebook::velox::dwio::common {
 
@@ -92,9 +91,7 @@ class ParquetReader : public dwio::common::Reader {
   std::optional<uint64_t> numberOfRows() const override;
 
   std::unique_ptr<dwio::common::ColumnStatistics> columnStatistics(
-      uint32_t index) const override {
-    return nullptr;
-  }
+      uint32_t index) const override;
 
   const velox::RowTypePtr& rowType() const override;
 
diff --git a/velox/dwio/parquet/reader/ParquetTypeWithId.cpp b/velox/dwio/parquet/reader/ParquetTypeWithId.cpp
index 1581fa63934..aab2e71fba7 100644
--- a/velox/dwio/parquet/reader/ParquetTypeWithId.cpp
+++ b/velox/dwio/parquet/reader/ParquetTypeWithId.cpp
@@ -53,23 +53,24 @@ ParquetTypeWithId::moveChildren() const&& {
     auto precision = parquetChild->precision_;
     auto scale = parquetChild->scale_;
     auto typeLength = parquetChild->typeLength_;
-    children.push_back(std::make_unique<ParquetTypeWithId>(
-        std::move(type),
-        std::move(*parquetChild).moveChildren(),
-        id,
-        maxId,
-        column,
-        std::move(name),
-        parquetType,
-        std::move(logicalType),
-        std::move(convertedType),
-        maxRepeat,
-        maxDefine,
-        isOptional,
-        isRepeated,
-        precision,
-        scale,
-        typeLength));
+    children.push_back(
+        std::make_unique<ParquetTypeWithId>(
+            std::move(type),
+            std::move(*parquetChild).moveChildren(),
+            id,
+            maxId,
+            column,
+            std::move(name),
+            parquetType,
+            std::move(logicalType),
+            std::move(convertedType),
+            maxRepeat,
+            maxDefine,
+            isOptional,
+            isRepeated,
+            precision,
+            scale,
+            typeLength));
   }
   return children;
 }
diff --git a/velox/dwio/parquet/reader/RepeatedColumnReader.cpp b/velox/dwio/parquet/reader/RepeatedColumnReader.cpp
index 8cd75156747..0d71733bf32 100644
--- a/velox/dwio/parquet/reader/RepeatedColumnReader.cpp
+++ b/velox/dwio/parquet/reader/RepeatedColumnReader.cpp
@@ -153,8 +153,6 @@ void MapColumnReader::seekToRowGroup(int64_t index) {
   BufferPtr noBuffer;
   formatData_->as<ParquetData>().setNulls(noBuffer, 0);
   lengths_.setLengths(nullptr);
-  keyReader_->seekToRowGroup(index);
-  elementReader_->seekToRowGroup(index);
 }
 
 void MapColumnReader::skipUnreadLengths() {
@@ -173,10 +171,10 @@ void MapColumnReader::setLengthsFromRepDefs(PageReader& pageReader) {
   auto repDefRange = pageReader.repDefRange();
   int32_t numRepDefs = repDefRange.second - repDefRange.first;
   BufferPtr lengths = std::move(lengths_.lengths());
-  dwio::common::ensureCapacity<int32_t>(lengths, numRepDefs, memoryPool_);
+  dwio::common::ensureCapacity<int32_t>(lengths, numRepDefs, pool_);
   memset(lengths->asMutable<uint64_t>(), 0, lengths->size());
   dwio::common::ensureCapacity<uint64_t>(
-      nullsInReadRange_, bits::nwords(numRepDefs), memoryPool_);
+      nullsInReadRange_, bits::nwords(numRepDefs), pool_);
   auto numLists = pageReader.getLengthsAndNulls(
       LevelMode::kList,
       levelInfo_,
@@ -282,10 +280,10 @@ void ListColumnReader::setLengthsFromRepDefs(PageReader& pageReader) {
   auto repDefRange = pageReader.repDefRange();
   int32_t numRepDefs = repDefRange.second - repDefRange.first;
   BufferPtr lengths = std::move(lengths_.lengths());
-  dwio::common::ensureCapacity<int32_t>(lengths, numRepDefs + 1, memoryPool_);
+  dwio::common::ensureCapacity<int32_t>(lengths, numRepDefs + 1, pool_);
   memset(lengths->asMutable<uint64_t>(), 0, lengths->size());
   dwio::common::ensureCapacity<uint64_t>(
-      nullsInReadRange_, bits::nwords(numRepDefs + 1), memoryPool_);
+      nullsInReadRange_, bits::nwords(numRepDefs + 1), pool_);
   auto numLists = pageReader.getLengthsAndNulls(
       LevelMode::kList,
       levelInfo_,
diff --git a/velox/dwio/parquet/reader/RleBpDecoder.h b/velox/dwio/parquet/reader/RleBpDecoder.h
index ac07ed76ad0..5856de775e2 100644
--- a/velox/dwio/parquet/reader/RleBpDecoder.h
+++ b/velox/dwio/parquet/reader/RleBpDecoder.h
@@ -37,7 +37,7 @@ class RleBpDecoder {
   /// Decode @param numValues number of values and copy the decoded values into
   /// @param outputBuffer
   template <typename T>
-  void next(T* FOLLY_NONNULL& outputBuffer, uint64_t numValues) {
+  void next(T * FOLLY_NONNULL & outputBuffer, uint64_t numValues) {
     while (numValues > 0) {
       if (numRemainingUnpackedValues_ > 0) {
         auto numValuesToRead =
@@ -103,7 +103,7 @@ class RleBpDecoder {
 
   template <typename T>
   inline void copyRemainingUnpackedValues(
-      T* FOLLY_NONNULL& outputBuffer,
+      T * FOLLY_NONNULL & outputBuffer,
       int8_t numValues) {
     VELOX_CHECK_LE(numValues, numRemainingUnpackedValues_);
 
diff --git a/velox/dwio/parquet/reader/SemanticVersion.cpp b/velox/dwio/parquet/reader/SemanticVersion.cpp
index fa7851cb7db..a7c1892f7cf 100644
--- a/velox/dwio/parquet/reader/SemanticVersion.cpp
+++ b/velox/dwio/parquet/reader/SemanticVersion.cpp
@@ -67,7 +67,7 @@ bool SemanticVersion::shouldIgnoreStatistics(thrift::Type::type type) const {
   if (this->application_ != "parquet-mr") {
     return false;
   }
-  static SemanticVersion threshold(1, 8, 1);
+  static SemanticVersion threshold(1, 8, 2);
   return *this < threshold;
 }
 
diff --git a/velox/dwio/parquet/reader/StringColumnReader.cpp b/velox/dwio/parquet/reader/StringColumnReader.cpp
index ac678b7f0a3..75a62914fd4 100644
--- a/velox/dwio/parquet/reader/StringColumnReader.cpp
+++ b/velox/dwio/parquet/reader/StringColumnReader.cpp
@@ -35,7 +35,7 @@ void StringColumnReader::read(
     int64_t offset,
     const RowSet& rows,
     const uint64_t* incomingNulls) {
-  prepareRead<folly::StringPiece>(offset, rows, incomingNulls);
+  prepareRead<std::string_view>(offset, rows, incomingNulls);
   dwio::common::StringColumnReadWithVisitorHelper<true, false>(
       *this, rows)([&](auto visitor) {
     formatData_->as<ParquetData>().readWithVisitor(visitor);
@@ -50,7 +50,7 @@ void StringColumnReader::getValues(const RowSet& rows, VectorPtr* result) {
     compactScalarValues<int32_t, int32_t>(rows, false);
 
     *result = std::make_shared<DictionaryVector<StringView>>(
-        memoryPool_, resultNulls(), numValues_, dictionaryValues, values_);
+        pool_, resultNulls(), numValues_, dictionaryValues, values_);
     return;
   }
   rawStringBuffer_ = nullptr;
@@ -83,7 +83,7 @@ void StringColumnReader::dedictionarize() {
       }
       auto& view = dict->valueAt(indices[i]);
       numValues_ = i;
-      addStringValue(folly::StringPiece(view.data(), view.size()));
+      addStringValue(std::string_view(view.data(), view.size()));
     }
     numValues_ = numValues;
   }
diff --git a/velox/dwio/parquet/reader/StringDecoder.h b/velox/dwio/parquet/reader/StringDecoder.h
index 2bff5285e3c..03805b5659f 100644
--- a/velox/dwio/parquet/reader/StringDecoder.h
+++ b/velox/dwio/parquet/reader/StringDecoder.h
@@ -90,15 +90,15 @@ class StringDecoder {
     return *reinterpret_cast<const int32_t*>(buffer);
   }
 
-  folly::StringPiece readString() {
+  std::string_view readString() {
     auto length = lengthAt(bufferStart_);
     bufferStart_ += length + sizeof(int32_t);
-    return folly::StringPiece(bufferStart_ - length, length);
+    return std::string_view(bufferStart_ - length, length);
   }
 
-  folly::StringPiece readFixedString() {
+  std::string_view readFixedString() {
     bufferStart_ += fixedLength_;
-    return folly::StringPiece(bufferStart_ - fixedLength_, fixedLength_);
+    return std::string_view(bufferStart_ - fixedLength_, fixedLength_);
   }
 
   const char* bufferStart_;
diff --git a/velox/dwio/parquet/reader/StructColumnReader.cpp b/velox/dwio/parquet/reader/StructColumnReader.cpp
index 694f334c51a..fbfffbe585f 100644
--- a/velox/dwio/parquet/reader/StructColumnReader.cpp
+++ b/velox/dwio/parquet/reader/StructColumnReader.cpp
@@ -46,12 +46,13 @@ StructColumnReader::StructColumnReader(
     auto childFileType = fileType_->childByName(childSpec->fieldName());
     auto childRequestedType =
         requestedType_->asRow().findChild(childSpec->fieldName());
-    addChild(ParquetColumnReader::build(
-        columnReaderOptions,
-        childRequestedType,
-        childFileType,
-        params,
-        *childSpec));
+    addChild(
+        ParquetColumnReader::build(
+            columnReaderOptions,
+            childRequestedType,
+            childFileType,
+            params,
+            *childSpec));
 
     childSpecs[i]->setSubscript(children_.size() - 1);
   }
@@ -185,7 +186,7 @@ void StructColumnReader::setNullsFromRepDefs(PageReader& pageReader) {
   auto repDefRange = pageReader.repDefRange();
   int32_t numRepDefs = repDefRange.second - repDefRange.first;
   dwio::common::ensureCapacity<uint64_t>(
-      nullsInReadRange_, bits::nwords(numRepDefs), memoryPool_);
+      nullsInReadRange_, bits::nwords(numRepDefs), pool_);
   auto numStructs = pageReader.getLengthsAndNulls(
       levelMode_,
       levelInfo_,
diff --git a/velox/dwio/parquet/reader/TimeColumnReader.h b/velox/dwio/parquet/reader/TimeColumnReader.h
new file mode 100644
index 00000000000..111f6eaa213
--- /dev/null
+++ b/velox/dwio/parquet/reader/TimeColumnReader.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/dwio/parquet/reader/IntegerColumnReader.h"
+#include "velox/dwio/parquet/reader/ParquetColumnReader.h"
+#include "velox/dwio/parquet/thrift/ParquetThriftTypes.h"
+
+namespace facebook::velox::parquet {
+
+/// Column reader for Parquet TIME type.
+/// Handles conversion from:
+/// - Parquet TIME_MILLIS (INT32, milliseconds) to Velox TIME (BIGINT,
+///   milliseconds).
+/// - Parquet TIME_MICROS (INT64, microseconds) to Velox TIME MICRO UTC
+///   (BIGINT, microseconds).
+class TimeColumnReader : public IntegerColumnReader {
+ public:
+  TimeColumnReader(
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
+      ParquetParams& params,
+      common::ScanSpec& scanSpec)
+      : IntegerColumnReader(requestedType, fileType, params, scanSpec) {
+    const auto typeWithId =
+        std::static_pointer_cast<const ParquetTypeWithId>(fileType_);
+    if (auto logicalType = typeWithId->logicalType_) {
+      VELOX_CHECK(logicalType->__isset.TIME);
+      const auto unit = logicalType->TIME.unit;
+      VELOX_CHECK(
+          unit.__isset.MILLIS || unit.__isset.MICROS,
+          "TIME precision other than milliseconds or microseconds is not supported");
+      isMicros_ = unit.__isset.MICROS;
+    } else if (auto convertedType = typeWithId->convertedType_) {
+      VELOX_CHECK(
+          convertedType == thrift::ConvertedType::type::TIME_MILLIS ||
+              convertedType == thrift::ConvertedType::type::TIME_MICROS,
+          "TIME converted type other than TIME_MILLIS or TIME_MICROS is not supported");
+      isMicros_ = convertedType == thrift::ConvertedType::type::TIME_MICROS;
+    } else {
+      VELOX_NYI("Logical type and converted type are not provided for TIME.");
+    }
+  }
+
+  void read(
+      int64_t offset,
+      const RowSet& rows,
+      const uint64_t* /*incomingNulls*/) override {
+    // Velox represents TIME as BIGINT (8 bytes) for both precisions.
+    // Parquet stores TIME_MILLIS as INT32 (4 bytes) and TIME_MICROS as
+    // INT64 (8 bytes). Dispatch on the physical width.
+    const int32_t physicalWidth = isMicros_ ? 8 : 4;
+    VELOX_WIDTH_DISPATCH(physicalWidth, prepareRead, offset, rows, nullptr);
+    readCommon<IntegerColumnReader, true>(rows);
+    readOffset_ += rows.back() + 1;
+  }
+
+ private:
+  // True for TIME_MICROS (INT64), false for TIME_MILLIS (INT32).
+  bool isMicros_{false};
+};
+
+} // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/reader/TimestampColumnReader.h b/velox/dwio/parquet/reader/TimestampColumnReader.h
index 909577ddd89..c32de51e106 100644
--- a/velox/dwio/parquet/reader/TimestampColumnReader.h
+++ b/velox/dwio/parquet/reader/TimestampColumnReader.h
@@ -182,13 +182,14 @@ class TimestampColumnReader : public IntegerColumnReader {
       filters.reserve(multiRange->filters().size());
       for (const auto& filter : multiRange->filters()) {
         if (auto* range = dynamic_cast<common::TimestampRange*>(filter.get())) {
-          filters.emplace_back(std::make_unique<ParquetTimestampRange<T>>(
-              range->lower(),
-              range->upper(),
-              range->nullAllowed(),
-              filePrecision_));
+          filters.emplace_back(
+              std::make_unique<ParquetTimestampRange<T>>(
+                  range->lower(),
+                  range->upper(),
+                  range->nullAllowed(),
+                  filePrecision_));
         } else {
-          filters.emplace_back(filter->clone(range->nullAllowed()));
+          filters.emplace_back(filter->clone(filter->nullAllowed()));
         }
       }
       auto newMultiRange =
diff --git a/velox/dwio/parquet/tests/CMakeLists.txt b/velox/dwio/parquet/tests/CMakeLists.txt
index dc09a85c4fd..de1431e8866 100644
--- a/velox/dwio/parquet/tests/CMakeLists.txt
+++ b/velox/dwio/parquet/tests/CMakeLists.txt
@@ -19,7 +19,7 @@ set(
   velox_exec_test_lib
   velox_dwio_parquet_reader
   velox_dwio_parquet_writer
-  velox_temp_path
+  velox_test_util
   GTest::gtest
   GTest::gtest_main
   GTest::gmock
@@ -47,3 +47,5 @@ target_link_libraries(
 )
 
 file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/examples DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+
+velox_add_library(velox_dwio_parquet_test_base INTERFACE HEADERS ParquetTestBase.h)
diff --git a/velox/dwio/parquet/tests/ParquetTestBase.h b/velox/dwio/parquet/tests/ParquetTestBase.h
index c867978a0a5..fd2cef91546 100644
--- a/velox/dwio/parquet/tests/ParquetTestBase.h
+++ b/velox/dwio/parquet/tests/ParquetTestBase.h
@@ -19,17 +19,20 @@
 #include <gtest/gtest.h>
 #include <string>
 #include "velox/common/base/Fs.h"
+#include "velox/common/file/File.h"
+#include "velox/common/io/IoStatistics.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/dwio/common/FileSink.h"
 #include "velox/dwio/common/Reader.h"
 #include "velox/dwio/common/tests/utils/DataFiles.h"
 #include "velox/dwio/parquet/reader/PageReader.h"
 #include "velox/dwio/parquet/reader/ParquetReader.h"
 #include "velox/dwio/parquet/writer/Writer.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
 namespace facebook::velox::parquet {
+using TempDirectoryPath = common::testutil::TempDirectoryPath;
 
 class ParquetTestBase : public testing::Test,
                         public velox::test::VectorTestBase {
@@ -42,7 +45,7 @@ class ParquetTestBase : public testing::Test,
     dwio::common::LocalFileSink::registerFactory();
     rootPool_ = memory::memoryManager()->addRootPool("ParquetTests");
     leafPool_ = rootPool_->addLeafChild("ParquetTests");
-    tempPath_ = exec::test::TempDirectoryPath::create();
+    tempPath_ = TempDirectoryPath::create();
   }
 
   static RowTypePtr sampleSchema() {
@@ -191,10 +194,55 @@ class ParquetTestBase : public testing::Test,
         "velox/dwio/parquet/tests/reader", "../examples/" + fileName);
   }
 
+  dwio::common::MemorySink* write(
+      const RowVectorPtr& data,
+      const WriterOptions& writerOptions) {
+    auto sink = std::make_unique<dwio::common::MemorySink>(
+        200 * 1024 * 1024,
+        dwio::common::FileSink::Options{.pool = leafPool_.get()});
+    auto* sinkPtr = sink.get();
+    auto writer = std::make_unique<Writer>(
+        std::move(sink), writerOptions, data->rowType());
+    writer->write(data);
+    writer->close();
+    writers_.push_back(std::move(writer));
+    return sinkPtr;
+  }
+
+  dwio::common::MemorySink* write(
+      const RowVectorPtr& data,
+      std::unordered_map<std::string, std::string> configFromFile = {},
+      std::unordered_map<std::string, std::string> sessionProperties = {}) {
+    parquet::WriterOptions writerOptions;
+    writerOptions.memoryPool = rootPool_.get();
+    auto connectorConfig = config::ConfigBase(std::move(configFromFile));
+    auto connectorSessionProperties =
+        config::ConfigBase(std::move(sessionProperties));
+    writerOptions.processConfigs(connectorConfig, connectorSessionProperties);
+    return write(data, writerOptions);
+  }
+
+  std::unique_ptr<ParquetReader> createReaderInMemory(
+      const dwio::common::MemorySink& sink,
+      const dwio::common::ReaderOptions& opts) {
+    std::string data(sink.data(), sink.size());
+    return std::make_unique<ParquetReader>(
+        std::make_unique<dwio::common::BufferedInput>(
+            std::make_shared<InMemoryReadFile>(std::move(data)),
+            opts.memoryPool()),
+        opts);
+  }
+
   static constexpr uint64_t kRowsInRowGroup = 10'000;
   static constexpr uint64_t kBytesInRowGroup = 128 * 1'024 * 1'024;
   std::shared_ptr<memory::MemoryPool> rootPool_;
   std::shared_ptr<memory::MemoryPool> leafPool_;
-  std::shared_ptr<exec::test::TempDirectoryPath> tempPath_;
+  std::shared_ptr<velox::io::IoStatistics> dataIoStats_ =
+      std::make_shared<velox::io::IoStatistics>();
+  std::shared_ptr<velox::io::IoStatistics> metadataIoStats_ =
+      std::make_shared<velox::io::IoStatistics>();
+  std::shared_ptr<TempDirectoryPath> tempPath_;
+  // Stores writers created by write() helper to keep sinks alive for reading.
+  std::vector<std::unique_ptr<Writer>> writers_;
 };
 } // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/tests/ParquetTpchTest.cpp b/velox/dwio/parquet/tests/ParquetTpchTest.cpp
index 615476c54b6..1dd5b4ef80d 100644
--- a/velox/dwio/parquet/tests/ParquetTpchTest.cpp
+++ b/velox/dwio/parquet/tests/ParquetTpchTest.cpp
@@ -18,6 +18,8 @@
 #include <vector>
 
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/connectors/tpch/TpchConnector.h"
 #include "velox/dwio/parquet/RegisterParquetReader.h"
@@ -25,7 +27,6 @@
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/exec/tests/utils/TpchQueryBuilder.h"
 #include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
@@ -34,6 +35,7 @@
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
+using namespace facebook::velox::common::testutil;
 
 class ParquetTpchTest : public testing::Test {
  protected:
@@ -60,22 +62,24 @@ class ParquetTpchTest : public testing::Test {
         kHiveConnectorId,
         std::make_shared<config::ConfigBase>(
             std::unordered_map<std::string, std::string>()));
-    connector::registerConnector(hiveConnector);
+    connector::ConnectorRegistry::global().insert(
+        hiveConnector->connectorId(), hiveConnector);
 
     connector::tpch::TpchConnectorFactory tpchFactory;
     auto tpchConnector = tpchFactory.newConnector(
         kTpchConnectorId,
         std::make_shared<config::ConfigBase>(
             std::unordered_map<std::string, std::string>()));
-    connector::registerConnector(tpchConnector);
+    connector::ConnectorRegistry::global().insert(
+        tpchConnector->connectorId(), tpchConnector);
 
     saveTpchTablesAsParquet();
     tpchBuilder_->initialize(tempDirectory_->getPath());
   }
 
   static void TearDownTestSuite() {
-    connector::unregisterConnector(kHiveConnectorId);
-    connector::unregisterConnector(kTpchConnectorId);
+    connector::ConnectorRegistry::global().erase(kHiveConnectorId);
+    connector::ConnectorRegistry::global().erase(kTpchConnectorId);
     parquet::unregisterParquetReaderFactory();
     parquet::unregisterParquetWriterFactory();
   }
@@ -94,8 +98,8 @@ class ParquetTpchTest : public testing::Test {
       auto plan = PlanBuilder()
                       .tpchTableScan(table, std::move(columnNames), 0.01)
                       .planNode();
-      auto split =
-          exec::Split(std::make_shared<connector::tpch::TpchConnectorSplit>(
+      auto split = exec::Split(
+          std::make_shared<connector::tpch::TpchConnectorSplit>(
               kTpchConnectorId, /*cacheable=*/true, 1, 0));
 
       auto rows =
diff --git a/velox/dwio/parquet/tests/common/LevelConversionTest.cpp b/velox/dwio/parquet/tests/common/LevelConversionTest.cpp
index e3ff3a7e6e9..f7274b7c974 100644
--- a/velox/dwio/parquet/tests/common/LevelConversionTest.cpp
+++ b/velox/dwio/parquet/tests/common/LevelConversionTest.cpp
@@ -160,38 +160,37 @@ MultiLevelTestData TriplyNestedList() {
   // [[[]], [[], [1, 2]], null, [[3]]],
   // null,
   // []
-  return MultiLevelTestData{
-      /*defLevels=*/std::vector<int16_t>{
-          2,
-          7,
-          6,
-          7,
-          5,
-          3, // first row
-          5,
-          5,
-          7,
-          7,
-          2,
-          7, // second row
-          0, // third row
-          1},
-      /*repLevels=*/
-      std::vector<int16_t>{
-          0,
-          1,
-          3,
-          3,
-          2,
-          1, // first row
-          0,
-          1,
-          2,
-          3,
-          1,
-          1, // second row
-          0,
-          0}};
+  return MultiLevelTestData{/*defLevels=*/std::vector<int16_t>{
+                                2,
+                                7,
+                                6,
+                                7,
+                                5,
+                                3, // first row
+                                5,
+                                5,
+                                7,
+                                7,
+                                2,
+                                7, // second row
+                                0, // third row
+                                1},
+                            /*repLevels=*/
+                            std::vector<int16_t>{
+                                0,
+                                1,
+                                3,
+                                3,
+                                2,
+                                1, // first row
+                                0,
+                                1,
+                                2,
+                                3,
+                                1,
+                                1, // second row
+                                0,
+                                0}};
 }
 
 template <typename ConverterType>
diff --git a/velox/dwio/parquet/tests/examples/nested_array_struct.parquet b/velox/dwio/parquet/tests/examples/nested_array_struct.parquet
new file mode 100644
index 00000000000..41a43fa35d3
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/nested_array_struct.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/proto_repeated_string.parquet b/velox/dwio/parquet/tests/examples/proto_repeated_string.parquet
new file mode 100644
index 00000000000..8a7eea601d0
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/proto_repeated_string.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/zero_offset_row_group.parquet b/velox/dwio/parquet/tests/examples/zero_offset_row_group.parquet
new file mode 100644
index 00000000000..3b41425516e
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/zero_offset_row_group.parquet differ
diff --git a/velox/dwio/parquet/tests/reader/CMakeLists.txt b/velox/dwio/parquet/tests/reader/CMakeLists.txt
index 8fe4b353e87..55b4d51506f 100644
--- a/velox/dwio/parquet/tests/reader/CMakeLists.txt
+++ b/velox/dwio/parquet/tests/reader/CMakeLists.txt
@@ -39,6 +39,7 @@ target_link_libraries(
 )
 
 add_library(velox_dwio_parquet_reader_benchmark_lib ParquetReaderBenchmark.cpp)
+velox_add_test_headers(velox_dwio_parquet_reader_benchmark_lib ParquetReaderBenchmark.h)
 target_link_libraries(
   velox_dwio_parquet_reader_benchmark_lib
   velox_dwio_parquet_reader
@@ -59,6 +60,7 @@ endif()
 add_executable(
   velox_dwio_parquet_reader_test
   ParquetReaderTest.cpp
+  ParquetReaderWideningTest.cpp
   ParquetReaderBenchmarkTest.cpp
   BloomFilterTest.cpp
 )
diff --git a/velox/dwio/parquet/tests/reader/E2EFilterTest.cpp b/velox/dwio/parquet/tests/reader/E2EFilterTest.cpp
index d718c29b0c1..d323989918b 100644
--- a/velox/dwio/parquet/tests/reader/E2EFilterTest.cpp
+++ b/velox/dwio/parquet/tests/reader/E2EFilterTest.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "velox/common/io/IoStatistics.h"
 #include "velox/dwio/common/tests/utils/E2EFilterTestBase.h"
 #include "velox/dwio/parquet/reader/ParquetReader.h"
 #include "velox/dwio/parquet/reader/ParquetTypeWithId.h"
@@ -59,7 +60,8 @@ class E2EFilterTest : public E2EFilterTestBase,
   void writeToMemory(
       const TypePtr& type,
       const std::vector<RowVectorPtr>& batches,
-      bool forRowGroupSkip = false) override {
+      bool forRowGroupSkip = false,
+      const std::vector<std::string>& /*indexColumns*/ = {}) override {
     auto sink = std::make_unique<MemorySink>(
         200 * 1024 * 1024, FileSink::Options{.pool = leafPool_.get()});
     auto* sinkPtr = sink.get();
@@ -90,6 +92,10 @@ class E2EFilterTest : public E2EFilterTestBase,
     return std::make_unique<ParquetReader>(std::move(input), opts);
   }
 
+  std::shared_ptr<velox::io::IoStatistics> dataIoStats_ =
+      std::make_shared<velox::io::IoStatistics>();
+  std::shared_ptr<velox::io::IoStatistics> metadataIoStats_ =
+      std::make_shared<velox::io::IoStatistics>();
   std::unique_ptr<facebook::velox::parquet::Writer> writer_;
   facebook::velox::parquet::WriterOptions options_;
   uint64_t rowsInRowGroup_ = 10'000;
@@ -99,8 +105,9 @@ class E2EFilterTest : public E2EFilterTestBase,
 TEST_F(E2EFilterTest, writerMagic) {
   rowType_ = ROW({"c0"}, {INTEGER()});
   std::vector<RowVectorPtr> batches;
-  batches.push_back(std::static_pointer_cast<RowVector>(
-      test::BatchMaker::createBatch(rowType_, 20000, *leafPool_, nullptr, 0)));
+  batches.push_back(
+      std::static_pointer_cast<RowVector>(test::BatchMaker::createBatch(
+          rowType_, 20000, *leafPool_, nullptr, 0)));
   writeToMemory(rowType_, batches, false);
   auto data = sinkData_.data();
   auto size = sinkData_.size();
@@ -136,7 +143,7 @@ TEST_F(E2EFilterTest, integerDirect) {
 TEST_F(E2EFilterTest, integerDeltaBinaryPack) {
   options_.enableDictionary = false;
   options_.encoding =
-      facebook::velox::parquet::arrow::Encoding::DELTA_BINARY_PACKED;
+      facebook::velox::parquet::arrow::Encoding::kDeltaBinaryPacked;
 
   testWithTypes(
       "short_val:smallint,"
@@ -525,7 +532,24 @@ TEST_F(E2EFilterTest, stringDictionary) {
 TEST_F(E2EFilterTest, stringDeltaByteArray) {
   options_.enableDictionary = false;
   options_.encoding =
-      facebook::velox::parquet::arrow::Encoding::DELTA_BYTE_ARRAY;
+      facebook::velox::parquet::arrow::Encoding::kDeltaByteArray;
+
+  testWithTypes(
+      "string_val:string,"
+      "string_val_2:string",
+      [&]() {
+        makeStringUnique("string_val");
+        makeStringUnique("string_val_2");
+      },
+      true,
+      {"string_val", "string_val_2"},
+      20);
+}
+
+TEST_F(E2EFilterTest, stringDeltaLengthByteArray) {
+  options_.enableDictionary = false;
+  options_.encoding =
+      facebook::velox::parquet::arrow::Encoding::kDeltaLengthByteArray;
 
   testWithTypes(
       "string_val:string,"
@@ -657,11 +681,14 @@ TEST_F(E2EFilterTest, largeMetadata) {
 
   rowType_ = ROW({"c0"}, {INTEGER()});
   std::vector<RowVectorPtr> batches;
-  batches.push_back(std::static_pointer_cast<RowVector>(
-      test::BatchMaker::createBatch(rowType_, 1000, *leafPool_, nullptr, 0)));
+  batches.push_back(
+      std::static_pointer_cast<RowVector>(test::BatchMaker::createBatch(
+          rowType_, 1000, *leafPool_, nullptr, 0)));
   writeToMemory(rowType_, batches, false);
-  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
-  readerOpts.setFooterEstimatedSize(1024);
+  dwio::common::ReaderOptions readerOpts(leafPool_.get());
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
+  readerOpts.setFooterSpeculativeIoSize(1024);
   readerOpts.setFilePreloadThreshold(1024 * 8);
   dwio::common::RowReaderOptions rowReaderOpts;
   auto input = std::make_unique<BufferedInput>(
@@ -689,16 +716,113 @@ TEST_F(E2EFilterTest, date) {
       20);
 }
 
+TEST_F(E2EFilterTest, time) {
+  struct {
+    parquet::arrow::Encoding::type encoding;
+    bool enableDictionary;
+    bool keepNulls;
+  } testCases[] = {
+      {parquet::arrow::Encoding::kPlain, false, true},
+      {parquet::arrow::Encoding::kPlain, true, true},
+      {parquet::arrow::Encoding::kDeltaBinaryPacked, false, false},
+      {parquet::arrow::Encoding::kDeltaBinaryPacked, false, true},
+  };
+
+  for (const auto& testCase : testCases) {
+    options_.encoding = testCase.encoding;
+    bool enableDictionary = testCase.enableDictionary;
+    bool keepNulls = testCase.keepNulls;
+    SCOPED_TRACE(
+        fmt::format(
+            "Encoding: {}, Dictionary: {}, KeepNulls: {}",
+            static_cast<int>(options_.encoding),
+            enableDictionary,
+            keepNulls));
+
+    options_.enableDictionary = enableDictionary;
+    options_.dataPageSize = 4 * 1024;
+    const int valMax = enableDictionary ? 1000 : 86399999;
+
+    testWithTypes(
+        "time_val:time",
+        [&]() {
+          makeIntDistribution<int64_t>(
+              "time_val",
+              0, // min
+              valMax, // max
+              22, // repeats
+              19, // rareFrequency
+              0, // rareMin
+              valMax, // rareMax
+              keepNulls); // keepNulls
+        },
+        false,
+        {"time_val"},
+        20);
+  }
+}
+
+TEST_F(E2EFilterTest, timeMicros) {
+  struct {
+    parquet::arrow::Encoding::type encoding;
+    bool enableDictionary;
+    bool keepNulls;
+  } testCases[] = {
+      {parquet::arrow::Encoding::kPlain, false, true},
+      {parquet::arrow::Encoding::kPlain, true, true},
+      {parquet::arrow::Encoding::kDeltaBinaryPacked, false, false},
+      {parquet::arrow::Encoding::kDeltaBinaryPacked, false, true},
+  };
+
+  for (const auto& testCase : testCases) {
+    options_.encoding = testCase.encoding;
+    bool enableDictionary = testCase.enableDictionary;
+    bool keepNulls = testCase.keepNulls;
+    SCOPED_TRACE(
+        fmt::format(
+            "Encoding: {}, Dictionary: {}, KeepNulls: {}",
+            static_cast<int>(options_.encoding),
+            enableDictionary,
+            keepNulls));
+
+    options_.enableDictionary = enableDictionary;
+    options_.dataPageSize = 4 * 1024;
+    // Microseconds since midnight up to 86,399,999,999 (one second short of
+    // 24 h). Use a smaller cap when forcing a dictionary so values are dense.
+    const int64_t valMax = enableDictionary ? 1'000 : 86'399'999'999LL;
+
+    testWithTypes(
+        "time_val:time_micro_utc",
+        [&]() {
+          makeIntDistribution<int64_t>(
+              "time_val",
+              0, // min
+              valMax, // max
+              22, // repeats
+              19, // rareFrequency
+              0, // rareMin
+              valMax, // rareMax
+              keepNulls); // keepNulls
+        },
+        false,
+        {"time_val"},
+        20);
+  }
+}
+
 TEST_F(E2EFilterTest, combineRowGroup) {
   rowsInRowGroup_ = 5;
   rowType_ = ROW({"c0"}, {INTEGER()});
   std::vector<RowVectorPtr> batches;
   for (int i = 0; i < 5; i++) {
-    batches.push_back(std::static_pointer_cast<RowVector>(
-        test::BatchMaker::createBatch(rowType_, 1, *leafPool_, nullptr, 0)));
+    batches.push_back(
+        std::static_pointer_cast<RowVector>(test::BatchMaker::createBatch(
+            rowType_, 1, *leafPool_, nullptr, 0)));
   }
   writeToMemory(rowType_, batches, false);
-  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  dwio::common::ReaderOptions readerOpts(leafPool_.get());
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   auto input = std::make_unique<BufferedInput>(
       std::make_shared<InMemoryReadFile>(sinkData_), readerOpts.memoryPool());
   auto reader = makeReader(readerOpts, std::move(input));
@@ -707,13 +831,115 @@ TEST_F(E2EFilterTest, combineRowGroup) {
   EXPECT_EQ(parquetReader.numberOfRows(), 5);
 }
 
+// Reproduces the real-world scenario from the bug report. Parquet-mr 1.8.1
+// computed binary column min/max using signed byte ordering, which differs from
+// the unsigned lexicographic (memcmp) ordering Velox uses.
+//
+// With signed byte ordering:  三星应用商店 < 360手机助手 < vivo预装
+// With memcmp byte ordering:  360手机助手  < vivo预装    < 三星应用商店
+//
+// A row group containing {"三星应用商店", "vivo预装"} has memcmp-based stats
+// min="vivo预装", max="三星应用商店". A filter for "360手机助手" falls below
+// the memcmp min, so the row group would be incorrectly skipped — even though
+// it should match under the signed ordering that parquet-mr 1.8.1 used to write
+// the stats.
+TEST_F(E2EFilterTest, parquetMRVersionStringStatsRowGroupFiltering) {
+  const std::string kSanXing = "三星应用商店";
+  const std::string kVivo = "vivo预装";
+  const std::string k360 = "360手机助手";
+
+  auto rowType = ROW({"s"}, {VARCHAR()});
+
+  auto writeAndGetStats = [&](const std::string& createdBy,
+                              RuntimeStatistics& stats) {
+    options_.memoryPool = E2EFilterTestBase::rootPool_.get();
+    options_.createdBy = createdBy;
+    // Flush after every 5 rows to create separate row groups.
+    options_.flushPolicyFactory = []() {
+      return std::make_unique<LambdaFlushPolicy>(
+          /*rowsInRowGroup=*/5,
+          /*bytesInRowGroup=*/1'024 * 1'024,
+          []() { return false; });
+    };
+
+    auto sink = std::make_unique<MemorySink>(
+        200 * 1024 * 1024, FileSink::Options{.pool = leafPool_.get()});
+    auto* sinkPtr = sink.get();
+    auto writer =
+        std::make_unique<parquet::Writer>(std::move(sink), options_, rowType);
+    // Row group 1: contains the value we will filter for ("360手机助手").
+    writer->write(makeRowVector(
+        {"s"},
+        {makeFlatVector<std::string>(
+            {k360, kSanXing, kVivo, k360, kSanXing})}));
+    // Row group 2: does not contain "360手机助手".
+    writer->write(makeRowVector(
+        {"s"},
+        {makeFlatVector<std::string>(
+            {kSanXing, kVivo, kSanXing, kVivo, kSanXing})}));
+    writer->close();
+
+    dwio::common::ReaderOptions readerOptions(leafPool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
+    auto input = std::make_unique<BufferedInput>(
+        std::make_shared<InMemoryReadFile>(
+            std::string(sinkPtr->data(), sinkPtr->size())),
+        readerOptions.memoryPool());
+    auto reader = makeReader(readerOptions, std::move(input));
+    auto& parquetReader = dynamic_cast<ParquetReader&>(*reader);
+    EXPECT_EQ(parquetReader.fileMetaData().numRowGroups(), 2);
+
+    auto scanSpec = std::make_shared<ScanSpec>("");
+    scanSpec->addAllChildFields(*rowType);
+    // Equality filter: s = "360手机助手".
+    scanSpec->getOrCreateChild(Subfield("s"))
+        ->setFilter(
+            std::make_unique<BytesRange>(
+                k360, false, false, k360, false, false, false));
+
+    RowReaderOptions rowReaderOpts;
+    rowReaderOpts.select(
+        std::make_shared<ColumnSelector>(rowType, rowType->names()));
+    rowReaderOpts.setScanSpec(scanSpec);
+    auto rowReader = reader->createRowReader(rowReaderOpts);
+
+    VectorPtr result = BaseVector::create(rowType, 1, leafPool_.get());
+    uint64_t totalRows{0};
+    while (rowReader->next(1'000, result)) {
+      totalRows += result->size();
+    }
+    EXPECT_EQ(totalRows, 2);
+
+    rowReader->updateRuntimeStats(stats);
+  };
+
+  // parquet-mr 1.8.2: stats are trusted. Under memcmp ordering, row group 1
+  // has min="360手机助手" max="三星应用商店" which contains "360手机助手", so
+  // it is read. Row group 2 has min="vivo预装" max="三星应用商店" which does
+  // not contain "360手机助手" (it falls below memcmp min), so it is skipped.
+  RuntimeStatistics stats182;
+  writeAndGetStats("parquet-mr version 1.8.2", stats182);
+  EXPECT_EQ(stats182.skippedStrides, 1);
+  EXPECT_EQ(stats182.processedStrides, 1);
+
+  // parquet-mr 1.8.1: stats are untrusted (signed byte ordering bug), so no
+  // row groups are skipped. Both row groups are scanned.
+  RuntimeStatistics stats181;
+  writeAndGetStats("parquet-mr version 1.8.1", stats181);
+  EXPECT_EQ(stats181.skippedStrides, 0);
+  EXPECT_EQ(stats181.processedStrides, 2);
+}
+
 TEST_F(E2EFilterTest, writeDecimalAsInteger) {
   auto rowVector = makeRowVector(
       {makeFlatVector<int64_t>({1, 2}, DECIMAL(8, 2)),
        makeFlatVector<int64_t>({1, 2}, DECIMAL(10, 2)),
        makeFlatVector<int128_t>({1, 2}, DECIMAL(19, 2))});
   writeToMemory(rowVector->type(), {rowVector}, false);
-  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  dwio::common::ReaderOptions readerOpts(leafPool_.get());
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   auto input = std::make_unique<BufferedInput>(
       std::make_shared<InMemoryReadFile>(sinkData_), readerOpts.memoryPool());
   auto reader = makeReader(readerOpts, std::move(input));
@@ -738,7 +964,9 @@ TEST_F(E2EFilterTest, configurableWriteSchema) {
     }
 
     writeToMemory(newType, batches, false);
-    dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+    dwio::common::ReaderOptions readerOpts(leafPool_.get());
+    readerOpts.setDataIoStats(dataIoStats_);
+    readerOpts.setMetadataIoStats(metadataIoStats_);
     auto input = std::make_unique<BufferedInput>(
         std::make_shared<InMemoryReadFile>(sinkData_), readerOpts.memoryPool());
     auto reader = makeReader(readerOpts, std::move(input));
@@ -777,7 +1005,7 @@ TEST_F(E2EFilterTest, configurableWriteSchema) {
 
 TEST_F(E2EFilterTest, booleanRle) {
   options_.enableDictionary = false;
-  options_.encoding = facebook::velox::parquet::arrow::Encoding::RLE;
+  options_.encoding = facebook::velox::parquet::arrow::Encoding::kRle;
   options_.useParquetDataPageV2 = true;
 
   testWithTypes(
diff --git a/velox/dwio/parquet/tests/reader/ParquetPageReaderTest.cpp b/velox/dwio/parquet/tests/reader/ParquetPageReaderTest.cpp
index 5145dcfdc8c..bda28a60ee1 100644
--- a/velox/dwio/parquet/tests/reader/ParquetPageReaderTest.cpp
+++ b/velox/dwio/parquet/tests/reader/ParquetPageReaderTest.cpp
@@ -15,7 +15,12 @@
  */
 
 #include "velox/dwio/parquet/reader/PageReader.h"
+
+#include <thrift/protocol/TCompactProtocol.h>
+#include <thrift/transport/TBufferTransports.h>
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/dwio/parquet/tests/ParquetTestBase.h"
+#include "velox/dwio/parquet/thrift/ParquetThriftTypes.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::common;
@@ -31,11 +36,13 @@ TEST_F(ParquetPageReaderTest, smallPage) {
   auto headerSize = file->getLength();
   auto inputStream = std::make_unique<SeekableFileInputStream>(
       std::move(file), 0, headerSize, *leafPool_, LogType::TEST);
+  dwio::common::ColumnReaderStatistics stats;
   auto pageReader = std::make_unique<PageReader>(
       std::move(inputStream),
       *leafPool_,
       common::CompressionKind::CompressionKind_GZIP,
-      headerSize);
+      headerSize,
+      stats);
   auto header = pageReader->readPageHeader();
   EXPECT_EQ(header.type, thrift::PageType::type::DATA_PAGE);
   EXPECT_EQ(header.uncompressed_page_size, 16950);
@@ -50,6 +57,7 @@ TEST_F(ParquetPageReaderTest, smallPage) {
   auto maxValue = header.data_page_header.statistics.max_value;
   EXPECT_EQ(minValue, expectedMinValue);
   EXPECT_EQ(maxValue, expectedMaxValue);
+  EXPECT_GT(stats.pageLoadTimeNs.sum(), 0);
 }
 
 TEST_F(ParquetPageReaderTest, largePage) {
@@ -59,11 +67,13 @@ TEST_F(ParquetPageReaderTest, largePage) {
   auto headerSize = file->getLength();
   auto inputStream = std::make_unique<SeekableFileInputStream>(
       std::move(file), 0, headerSize, *leafPool_, LogType::TEST);
+  dwio::common::ColumnReaderStatistics stats;
   auto pageReader = std::make_unique<PageReader>(
       std::move(inputStream),
       *leafPool_,
       common::CompressionKind::CompressionKind_GZIP,
-      headerSize);
+      headerSize,
+      stats);
   auto header = pageReader->readPageHeader();
 
   EXPECT_EQ(header.type, thrift::PageType::type::DATA_PAGE);
@@ -79,6 +89,7 @@ TEST_F(ParquetPageReaderTest, largePage) {
   auto maxValue = header.data_page_header.statistics.max_value;
   EXPECT_EQ(minValue, expectedMinValue);
   EXPECT_EQ(maxValue, expectedMaxValue);
+  EXPECT_GT(stats.pageLoadTimeNs.sum(), 0);
 }
 
 TEST_F(ParquetPageReaderTest, corruptedPageHeader) {
@@ -92,11 +103,13 @@ TEST_F(ParquetPageReaderTest, corruptedPageHeader) {
   // In the corrupted_page_header, the min_value length is set incorrectly on
   // purpose. This is to simulate the situation where the Parquet Page Header is
   // corrupted. And an error is expected to be thrown.
+  dwio::common::ColumnReaderStatistics stats;
   auto pageReader = std::make_unique<PageReader>(
       std::move(inputStream),
       *leafPool_,
       common::CompressionKind::CompressionKind_GZIP,
-      headerSize);
+      headerSize,
+      stats);
 
   EXPECT_THROW(pageReader->readPageHeader(), VeloxException);
 }
@@ -108,3 +121,417 @@ TEST(CompressionOptionsTest, testCompressionOptions) {
       options.format.zlib.windowBits,
       dwio::common::compression::Compressor::PARQUET_ZLIB_WINDOW_BITS);
 }
+
+// Test that prepareDictionary rejects FIXED_LEN_BYTE_ARRAY dictionary pages
+// where the Parquet type length exceeds the Velox type length.  This guards
+// against heap buffer overflow from malicious Parquet files that have a patched
+// precision (e.g. decimal128 with typeLength=16 but precision lowered to make
+// Velox choose int64_t with cppSizeInBytes=8).
+TEST_F(ParquetPageReaderTest, fixedLenByteArrayDictOverflow) {
+  // Simulate the exploit: Parquet FIXED_LEN_BYTE_ARRAY with typeLength=16
+  // but Velox sees SHORT_DECIMAL (precision=10) which is int64_t (8 bytes).
+  // Without the check, prepareDictionary would allocate numValues*8 bytes
+  // but memcpy numValues*16 bytes, causing a heap overflow.
+  constexpr int32_t kNumDictValues = 4;
+  constexpr int32_t kParquetTypeLength = 16;
+  constexpr int32_t kDictPageSize = kNumDictValues * kParquetTypeLength;
+
+  // Create a DICTIONARY_PAGE header.
+  thrift::PageHeader dictHeader;
+  dictHeader.__set_type(thrift::PageType::DICTIONARY_PAGE);
+  dictHeader.__set_uncompressed_page_size(kDictPageSize);
+  dictHeader.__set_compressed_page_size(kDictPageSize);
+  thrift::DictionaryPageHeader dictPageHeader;
+  dictPageHeader.__set_num_values(kNumDictValues);
+  dictPageHeader.__set_encoding(thrift::Encoding::PLAIN);
+  dictHeader.__set_dictionary_page_header(dictPageHeader);
+
+  auto transport = std::make_shared<apache::thrift::transport::TMemoryBuffer>();
+  apache::thrift::protocol::TCompactProtocolT<
+      apache::thrift::transport::TMemoryBuffer>
+      protocol(transport);
+  dictHeader.write(&protocol);
+  std::string dictHeaderBytes = transport->getBufferAsString();
+
+  // Dictionary page data (content doesn't matter, check fires before read).
+  std::string dictPageData(kDictPageSize, '\0');
+
+  // Create a DATA_PAGE header so seekToPage can find a data page after the
+  // dictionary page.
+  constexpr int32_t kDataPageSize = 8;
+  thrift::PageHeader dataHeader;
+  dataHeader.__set_type(thrift::PageType::DATA_PAGE);
+  dataHeader.__set_uncompressed_page_size(kDataPageSize);
+  dataHeader.__set_compressed_page_size(kDataPageSize);
+  thrift::DataPageHeader dataPageHeader;
+  dataPageHeader.__set_num_values(1);
+  dataPageHeader.__set_encoding(thrift::Encoding::RLE_DICTIONARY);
+  dataPageHeader.__set_definition_level_encoding(thrift::Encoding::RLE);
+  dataPageHeader.__set_repetition_level_encoding(thrift::Encoding::RLE);
+  dataHeader.__set_data_page_header(dataPageHeader);
+
+  auto transport2 =
+      std::make_shared<apache::thrift::transport::TMemoryBuffer>();
+  apache::thrift::protocol::TCompactProtocolT<
+      apache::thrift::transport::TMemoryBuffer>
+      protocol2(transport2);
+  dataHeader.write(&protocol2);
+  std::string dataHeaderBytes = transport2->getBufferAsString();
+
+  std::string dataPageData(kDataPageSize, '\0');
+
+  // Combine: dict header + dict data + data header + data data.
+  std::string fullData =
+      dictHeaderBytes + dictPageData + dataHeaderBytes + dataPageData;
+
+  auto inputStream = std::make_unique<SeekableArrayInputStream>(
+      fullData.data(), fullData.size());
+
+  // Construct ParquetTypeWithId: SHORT_DECIMAL (precision=10, cppSizeInBytes=8)
+  // with parquetType=FIXED_LEN_BYTE_ARRAY and typeLength=16.
+  auto fileType = std::make_shared<const ParquetTypeWithId>(
+      DECIMAL(10, 2),
+      std::vector<std::unique_ptr<dwio::common::TypeWithId>>{},
+      /*id=*/0,
+      /*maxId=*/0,
+      /*column=*/0,
+      "test_col",
+      thrift::Type::FIXED_LEN_BYTE_ARRAY,
+      std::nullopt,
+      std::nullopt,
+      /*maxRepeat=*/0,
+      /*maxDefine=*/1,
+      /*isOptional=*/true,
+      /*isRepeated=*/false,
+      /*precision=*/10,
+      /*scale=*/2,
+      /*typeLength=*/kParquetTypeLength);
+
+  dwio::common::ColumnReaderStatistics stats;
+  auto pageReader = std::make_unique<PageReader>(
+      std::move(inputStream),
+      *leafPool_,
+      fileType,
+      common::CompressionKind::CompressionKind_NONE,
+      fullData.size(),
+      stats,
+      nullptr);
+
+  // skip(1) triggers seekToPage() -> prepareDictionary().
+  // The VELOX_CHECK_LE should fire because numParquetBytes (4*16=64) >
+  // numVeloxBytes (4*8=32).
+  VELOX_ASSERT_THROW(pageReader->skip(1), "");
+}
+
+namespace {
+
+// Helper to serialize a PageHeader using Thrift compact protocol.
+std::string serializePageHeader(const thrift::PageHeader& header) {
+  auto transport = std::make_shared<apache::thrift::transport::TMemoryBuffer>();
+  apache::thrift::protocol::TCompactProtocolT<
+      apache::thrift::transport::TMemoryBuffer>
+      protocol(transport);
+  header.write(&protocol);
+  return transport->getBufferAsString();
+}
+
+// Helper to create a DATA_PAGE header with specified sizes.
+thrift::PageHeader createDataPageV1Header(
+    int32_t uncompressedSize,
+    int32_t compressedSize,
+    int32_t numValues) {
+  thrift::PageHeader header;
+  header.__set_type(thrift::PageType::DATA_PAGE);
+  header.__set_uncompressed_page_size(uncompressedSize);
+  header.__set_compressed_page_size(compressedSize);
+
+  thrift::DataPageHeader dataHeader;
+  dataHeader.__set_num_values(numValues);
+  dataHeader.__set_encoding(thrift::Encoding::PLAIN);
+  dataHeader.__set_definition_level_encoding(thrift::Encoding::RLE);
+  dataHeader.__set_repetition_level_encoding(thrift::Encoding::RLE);
+  header.__set_data_page_header(dataHeader);
+
+  return header;
+}
+
+// Helper to create a DATA_PAGE_V2 header with specified sizes.
+thrift::PageHeader createDataPageV2Header(
+    int32_t uncompressedSize,
+    int32_t compressedSize,
+    int32_t numValues,
+    int32_t definitionLevelsByteLength,
+    int32_t repetitionLevelsByteLength) {
+  thrift::PageHeader header;
+  header.__set_type(thrift::PageType::DATA_PAGE_V2);
+  header.__set_uncompressed_page_size(uncompressedSize);
+  header.__set_compressed_page_size(compressedSize);
+
+  thrift::DataPageHeaderV2 dataHeader;
+  dataHeader.__set_num_values(numValues);
+  dataHeader.__set_num_nulls(0);
+  dataHeader.__set_num_rows(numValues);
+  dataHeader.__set_encoding(thrift::Encoding::PLAIN);
+  dataHeader.__set_definition_levels_byte_length(definitionLevelsByteLength);
+  dataHeader.__set_repetition_levels_byte_length(repetitionLevelsByteLength);
+  dataHeader.__set_is_compressed(false);
+  header.__set_data_page_header_v2(dataHeader);
+
+  return header;
+}
+
+} // namespace
+
+// Test that prepareDataPageV1 rejects pages with defineLength exceeding page
+// size. This guards against heap buffer overflow from corrupt Parquet files.
+TEST_F(ParquetPageReaderTest, corruptDefineLengthV1) {
+  // Create a DATA_PAGE header with small page size.
+  constexpr int32_t kPageSize = 20;
+  auto pageHeader = createDataPageV1Header(kPageSize, kPageSize, 100);
+  std::string headerBytes = serializePageHeader(pageHeader);
+
+  // Create corrupt page data where defineLength (first 4 bytes after
+  // decompression for maxDefine > 0) is huge. Since compression is NONE, the
+  // "decompressed" data is the raw page data.
+  std::string pageData(kPageSize, '\0');
+  // Set defineLength to a huge value (0x7FFFFFF0) that exceeds page size.
+  uint32_t corruptDefineLength = 0x7FFFFFF0;
+  memcpy(pageData.data(), &corruptDefineLength, sizeof(uint32_t));
+
+  // Combine header and page data.
+  std::string fullData = headerBytes + pageData;
+
+  // Create an input stream from the crafted data.
+  auto inputStream = std::make_unique<SeekableArrayInputStream>(
+      fullData.data(), fullData.size());
+
+  dwio::common::ColumnReaderStatistics stats;
+  // Create PageReader with maxRepeat=0, maxDefine=1 (so defineLength is read)
+  // and no compression (so page data is used directly).
+  auto pageReader = std::make_unique<PageReader>(
+      std::move(inputStream),
+      *leafPool_,
+      common::CompressionKind::CompressionKind_NONE,
+      fullData.size(),
+      stats,
+      nullptr,
+      0,
+      1);
+
+  // Calling skip(1) triggers seekToPage() which calls prepareDataPageV1().
+  // The bounds check should throw when defineLength exceeds page size.
+  VELOX_ASSERT_THROW(
+      pageReader->skip(1), "Definition level length 2147483632 exceeds");
+}
+
+// Test that prepareDataPageV1 rejects pages with repeatLength exceeding page
+// size. This guards against heap buffer overflow from corrupt Parquet files.
+TEST_F(ParquetPageReaderTest, corruptRepeatLengthV1) {
+  // Create a DATA_PAGE header with small page size.
+  constexpr int32_t kPageSize = 20;
+  auto pageHeader = createDataPageV1Header(kPageSize, kPageSize, 100);
+  std::string headerBytes = serializePageHeader(pageHeader);
+
+  // Create corrupt page data where repeatLength (first 4 bytes after
+  // decompression for maxRepeat > 0) is huge. Since compression is NONE, the
+  // "decompressed" data is the raw page data.
+  std::string pageData(kPageSize, '\0');
+  // Set repeatLength to a huge value (0x7FFFFFF0) that exceeds page size.
+  uint32_t corruptRepeatLength = 0x7FFFFFF0;
+  memcpy(pageData.data(), &corruptRepeatLength, sizeof(uint32_t));
+
+  // Combine header and page data.
+  std::string fullData = headerBytes + pageData;
+
+  // Create an input stream from the crafted data.
+  auto inputStream = std::make_unique<SeekableArrayInputStream>(
+      fullData.data(), fullData.size());
+
+  dwio::common::ColumnReaderStatistics stats;
+  // Create PageReader with maxRepeat=1 (so repeatLength is read), maxDefine=0,
+  // and no compression (so page data is used directly).
+  auto pageReader = std::make_unique<PageReader>(
+      std::move(inputStream),
+      *leafPool_,
+      common::CompressionKind::CompressionKind_NONE,
+      fullData.size(),
+      stats,
+      nullptr,
+      1,
+      0);
+
+  // Calling skip(1) triggers seekToPage() which calls prepareDataPageV1().
+  // The bounds check should throw when repeatLength exceeds page size.
+  VELOX_ASSERT_THROW(
+      pageReader->skip(1), "Repetition level length 2147483632 exceeds");
+}
+
+// Test that prepareDataPageV2 rejects pages where repetition + definition
+// level lengths exceed compressed page size.
+TEST_F(ParquetPageReaderTest, corruptLevelLengthsV2) {
+  // Create a DATA_PAGE_V2 header with small page size but huge level lengths.
+  constexpr int32_t kPageSize = 20;
+  // Set level lengths that exceed the page size.
+  constexpr int32_t kCorruptRepeatLength = 0x7FFFFFF0;
+  constexpr int32_t kCorruptDefineLength = 100;
+  auto pageHeader = createDataPageV2Header(
+      kPageSize, kPageSize, 100, kCorruptDefineLength, kCorruptRepeatLength);
+  std::string headerBytes = serializePageHeader(pageHeader);
+
+  // Create page data (content doesn't matter since validation should fail
+  // before reading it).
+  std::string pageData(kPageSize, '\0');
+
+  // Combine header and page data.
+  std::string fullData = headerBytes + pageData;
+
+  // Create an input stream from the crafted data.
+  auto inputStream = std::make_unique<SeekableArrayInputStream>(
+      fullData.data(), fullData.size());
+
+  dwio::common::ColumnReaderStatistics stats;
+  // maxRepeat and maxDefine don't affect V2 validation since the lengths
+  // are in the header, not the page data.
+  auto pageReader = std::make_unique<PageReader>(
+      std::move(inputStream),
+      *leafPool_,
+      common::CompressionKind::CompressionKind_NONE,
+      fullData.size(),
+      stats,
+      nullptr,
+      1,
+      1);
+
+  // Calling skip(1) triggers seekToPage() which calls prepareDataPageV2().
+  // The bounds check should throw when level lengths exceed page size.
+  VELOX_ASSERT_THROW(
+      pageReader->skip(1),
+      "Repetition and definition level lengths (2147483632 + 100) exceed");
+}
+
+// Test that prepareDataPageV1 rejects pages that are too small to contain
+// the repetition level length field (4 bytes).
+TEST_F(ParquetPageReaderTest, insufficientBytesForRepeatLengthV1) {
+  // Create a DATA_PAGE header with page size too small for the 4-byte
+  // repetition level length field.
+  constexpr int32_t kPageSize = 2; // Less than sizeof(int32_t)
+  auto pageHeader = createDataPageV1Header(kPageSize, kPageSize, 100);
+  std::string headerBytes = serializePageHeader(pageHeader);
+
+  // Create minimal page data.
+  std::string pageData(kPageSize, '\0');
+
+  // Combine header and page data.
+  std::string fullData = headerBytes + pageData;
+
+  // Create an input stream from the crafted data.
+  auto inputStream = std::make_unique<SeekableArrayInputStream>(
+      fullData.data(), fullData.size());
+
+  dwio::common::ColumnReaderStatistics stats;
+  // PageReader with maxRepeat > 0 would try to read repeatLength but page
+  // is too small.
+  auto pageReader = std::make_unique<PageReader>(
+      std::move(inputStream),
+      *leafPool_,
+      common::CompressionKind::CompressionKind_NONE,
+      fullData.size(),
+      stats,
+      nullptr,
+      1,
+      0);
+
+  // Calling skip(1) triggers seekToPage() which calls prepareDataPageV1().
+  // The bounds check should throw when page is too small to hold repeatLength.
+  VELOX_ASSERT_THROW(
+      pageReader->skip(1), "Insufficient bytes for repetition level length");
+}
+
+// Test that prepareDataPageV1 rejects pages where there are insufficient bytes
+// remaining for the definition level length field after reading repetition
+// levels.
+TEST_F(ParquetPageReaderTest, insufficientBytesForDefineLengthV1) {
+  // Create a DATA_PAGE header with page size that can hold repetition level
+  // length (4 bytes) plus a small repeatLength value, but not enough remaining
+  // for the definition level length field.
+  constexpr int32_t kPageSize = 6; // 4 bytes for repeatLength field + 2 bytes
+  auto pageHeader = createDataPageV1Header(kPageSize, kPageSize, 100);
+  std::string headerBytes = serializePageHeader(pageHeader);
+
+  // Create page data with a small repeatLength that leaves insufficient bytes
+  // for defineLength.
+  std::string pageData(kPageSize, '\0');
+  // Set repeatLength to 0 (valid), leaving only 2 bytes which is insufficient
+  // for the 4-byte defineLength field.
+  uint32_t repeatLength = 0;
+  memcpy(pageData.data(), &repeatLength, sizeof(uint32_t));
+
+  // Combine header and page data.
+  std::string fullData = headerBytes + pageData;
+
+  // Create an input stream from the crafted data.
+  auto inputStream = std::make_unique<SeekableArrayInputStream>(
+      fullData.data(), fullData.size());
+
+  dwio::common::ColumnReaderStatistics stats;
+  // PageReader with both maxRepeat > 0 and maxDefine > 0 would read
+  // repeatLength (0), advance past it, then try to read defineLength but
+  // there are insufficient bytes remaining.
+  auto pageReader = std::make_unique<PageReader>(
+      std::move(inputStream),
+      *leafPool_,
+      common::CompressionKind::CompressionKind_NONE,
+      fullData.size(),
+      stats,
+      nullptr,
+      1,
+      1);
+
+  // Calling skip(1) triggers seekToPage() which calls prepareDataPageV1().
+  // The bounds check should throw when there are insufficient bytes for
+  // defineLength.
+  VELOX_ASSERT_THROW(
+      pageReader->skip(1), "Insufficient bytes for definition level length");
+}
+
+// Test that prepareDataPageV2 rejects pages where only the repetition level
+// length exceeds the page size (without combining with definition length).
+TEST_F(ParquetPageReaderTest, corruptRepeatLengthOnlyV2) {
+  // Create a DATA_PAGE_V2 header where just the repetition level length
+  // exceeds the page size.
+  constexpr int32_t kPageSize = 20;
+  constexpr int32_t kCorruptRepeatLength = 0x7FFFFFF0;
+  constexpr int32_t kDefineLength = 0; // No definition levels
+  auto pageHeader = createDataPageV2Header(
+      kPageSize, kPageSize, 100, kDefineLength, kCorruptRepeatLength);
+  std::string headerBytes = serializePageHeader(pageHeader);
+
+  // Create page data.
+  std::string pageData(kPageSize, '\0');
+
+  // Combine header and page data.
+  std::string fullData = headerBytes + pageData;
+
+  // Create an input stream from the crafted data.
+  auto inputStream = std::make_unique<SeekableArrayInputStream>(
+      fullData.data(), fullData.size());
+
+  dwio::common::ColumnReaderStatistics stats;
+  // maxRepeat and maxDefine don't affect V2 validation since the lengths
+  // are in the header, not the page data.
+  auto pageReader = std::make_unique<PageReader>(
+      std::move(inputStream),
+      *leafPool_,
+      common::CompressionKind::CompressionKind_NONE,
+      fullData.size(),
+      stats,
+      nullptr,
+      1,
+      0);
+
+  // Calling skip(1) triggers seekToPage() which calls prepareDataPageV2().
+  // The bounds check should throw when repeatLength exceeds page size.
+  VELOX_ASSERT_THROW(
+      pageReader->skip(1),
+      "Repetition and definition level lengths (2147483632 + 0) exceed");
+}
diff --git a/velox/dwio/parquet/tests/reader/ParquetReaderBenchmark.cpp b/velox/dwio/parquet/tests/reader/ParquetReaderBenchmark.cpp
index 976d021d87e..02cbe4a5129 100644
--- a/velox/dwio/parquet/tests/reader/ParquetReaderBenchmark.cpp
+++ b/velox/dwio/parquet/tests/reader/ParquetReaderBenchmark.cpp
@@ -96,7 +96,9 @@ std::shared_ptr<ScanSpec> ParquetReaderBenchmark::createScanSpec(
 std::unique_ptr<RowReader> ParquetReaderBenchmark::createReader(
     std::shared_ptr<ScanSpec> scanSpec,
     const RowTypePtr& rowType) {
-  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  dwio::common::ReaderOptions readerOpts(leafPool_.get());
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   auto input = std::make_unique<BufferedInput>(
       std::make_shared<LocalReadFile>(fileFolder_->getPath() + "/" + fileName_),
       readerOpts.memoryPool());
diff --git a/velox/dwio/parquet/tests/reader/ParquetReaderBenchmark.h b/velox/dwio/parquet/tests/reader/ParquetReaderBenchmark.h
index 07f2913a89f..680a27b10ca 100644
--- a/velox/dwio/parquet/tests/reader/ParquetReaderBenchmark.h
+++ b/velox/dwio/parquet/tests/reader/ParquetReaderBenchmark.h
@@ -15,6 +15,8 @@
  */
 #pragma once
 
+#include "velox/common/io/IoStatistics.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/dwio/common/FileSink.h"
 #include "velox/dwio/common/Options.h"
 #include "velox/dwio/common/Statistics.h"
@@ -22,13 +24,14 @@
 #include "velox/dwio/parquet/RegisterParquetReader.h"
 #include "velox/dwio/parquet/reader/ParquetReader.h"
 #include "velox/dwio/parquet/writer/Writer.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 #include <folly/Benchmark.h>
 #include <folly/init/Init.h>
 
 namespace facebook::velox::parquet::test {
 
+using TempDirectoryPath = common::testutil::TempDirectoryPath;
+
 constexpr uint32_t kNumRowsPerBatch = 60000;
 constexpr uint32_t kNumBatches = 50;
 constexpr uint32_t kNumRowsPerRowGroup = 10000;
@@ -104,13 +107,17 @@ class ParquetReaderBenchmark {
 
  private:
   const std::string fileName_ = "test.parquet";
-  const std::shared_ptr<facebook::velox::exec::test::TempDirectoryPath>
-      fileFolder_ = facebook::velox::exec::test::TempDirectoryPath::create();
+  const std::shared_ptr<TempDirectoryPath> fileFolder_ =
+      TempDirectoryPath::create();
   const bool disableDictionary_;
 
   std::unique_ptr<facebook::velox::test::DataSetBuilder> dataSetBuilder_;
   std::shared_ptr<facebook::velox::memory::MemoryPool> rootPool_;
   std::shared_ptr<facebook::velox::memory::MemoryPool> leafPool_;
+  std::shared_ptr<facebook::velox::io::IoStatistics> dataIoStats_ =
+      std::make_shared<facebook::velox::io::IoStatistics>();
+  std::shared_ptr<facebook::velox::io::IoStatistics> metadataIoStats_ =
+      std::make_shared<facebook::velox::io::IoStatistics>();
   std::unique_ptr<facebook::velox::parquet::Writer> writer_;
   facebook::velox::dwio::common::RuntimeStatistics runtimeStats_;
 };
diff --git a/velox/dwio/parquet/tests/reader/ParquetReaderTest.cpp b/velox/dwio/parquet/tests/reader/ParquetReaderTest.cpp
index d336db9ac4f..00446d11e70 100644
--- a/velox/dwio/parquet/tests/reader/ParquetReaderTest.cpp
+++ b/velox/dwio/parquet/tests/reader/ParquetReaderTest.cpp
@@ -15,7 +15,11 @@
  */
 
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/dwio/common/Mutation.h"
+#include "velox/dwio/parquet/reader/ParquetStatsContext.h"
+#include "velox/dwio/parquet/reader/SemanticVersion.h"
 #include "velox/dwio/parquet/tests/ParquetTestBase.h"
+#include "velox/dwio/parquet/thrift/ParquetThriftTypes.h"
 #include "velox/expression/ExprToSubfieldFilter.h"
 #include "velox/vector/tests/utils/VectorMaker.h"
 
@@ -31,7 +35,9 @@ class ParquetReaderTest : public ParquetTestBase {
       const RowTypePtr& rowType) {
     const std::string sample(getExampleFilePath(fileName));
 
-    dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+    dwio::common::ReaderOptions readerOptions(leafPool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
     auto reader = createReader(sample, readerOptions);
 
     RowReaderOptions rowReaderOpts;
@@ -57,7 +63,9 @@ class ParquetReaderTest : public ParquetTestBase {
       FilterMap filters,
       const RowVectorPtr& expected) {
     const auto filePath(getExampleFilePath(fileName));
-    dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+    dwio::common::ReaderOptions readerOpts(leafPool_.get());
+    readerOpts.setDataIoStats(dataIoStats_);
+    readerOpts.setMetadataIoStats(metadataIoStats_);
     auto reader = createReader(filePath, readerOpts);
     assertReadWithReaderAndFilters(
         std::move(reader), fileName, fileSchema, std::move(filters), expected);
@@ -72,7 +80,9 @@ TEST_F(ParquetReaderTest, parseSample) {
   //   b: [1.0..20.0]
   const std::string sample(getExampleFilePath("sample.parquet"));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOptions);
   EXPECT_EQ(reader->numberOfRows(), 20ULL);
 
@@ -121,7 +131,9 @@ TEST_F(ParquetReaderTest, parseEmptyNestedList) {
   const std::string sample(
       getExampleFilePath("parse_empty_nested_list.parquet"));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOptions);
   EXPECT_EQ(reader->numberOfRows(), 1000ULL);
 
@@ -179,7 +191,9 @@ TEST_F(ParquetReaderTest, parseUnannotatedList) {
   // }
   const std::string sample(getExampleFilePath("unannotated_list.parquet"));
 
-  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  dwio::common::ReaderOptions readerOpts(leafPool_.get());
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOpts);
 
   EXPECT_EQ(reader->numberOfRows(), 22ULL);
@@ -234,7 +248,9 @@ TEST_F(ParquetReaderTest, parseUnannotatedMap) {
   const std::string filename("unnotated_map.parquet");
   const std::string sample(getExampleFilePath(filename));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOptions);
 
   auto type = reader->typeWithId();
@@ -273,7 +289,9 @@ TEST_F(ParquetReaderTest, parseLegacyListWithMultipleChildren) {
   const std::string filename("listmultiplechildren.parquet");
   const std::string sample(getExampleFilePath(filename));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOptions);
 
   auto type = reader->typeWithId();
@@ -332,7 +350,9 @@ TEST_F(ParquetReaderTest, parseArrayOfRowHiveReservedKeywords) {
   const std::string sample(
       getExampleFilePath("array_of_row_hive_reserved_keywords.parquet"));
 
-  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  dwio::common::ReaderOptions readerOpts(leafPool_.get());
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOpts);
   EXPECT_EQ(reader->rowType()->toString(), expectedVeloxType);
   EXPECT_EQ(reader->numberOfRows(), 6ULL);
@@ -383,7 +403,9 @@ TEST_F(ParquetReaderTest, parseArrayOfRowHiveReservedKeywords) {
 TEST_F(ParquetReaderTest, parseSampleRange1) {
   const std::string sample(getExampleFilePath("sample.parquet"));
 
-  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  dwio::common::ReaderOptions readerOpts(leafPool_.get());
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOpts);
 
   auto rowReaderOpts = getReaderOpts(sampleSchema());
@@ -402,7 +424,9 @@ TEST_F(ParquetReaderTest, parseSampleRange1) {
 TEST_F(ParquetReaderTest, parseSampleRange2) {
   const std::string sample(getExampleFilePath("sample.parquet"));
 
-  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  dwio::common::ReaderOptions readerOpts(leafPool_.get());
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOpts);
 
   auto rowReaderOpts = getReaderOpts(sampleSchema());
@@ -421,7 +445,9 @@ TEST_F(ParquetReaderTest, parseSampleRange2) {
 TEST_F(ParquetReaderTest, parseSampleEmptyRange) {
   const std::string sample(getExampleFilePath("sample.parquet"));
 
-  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  dwio::common::ReaderOptions readerOpts(leafPool_.get());
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOpts);
 
   auto rowReaderOpts = getReaderOpts(sampleSchema());
@@ -439,7 +465,9 @@ TEST_F(ParquetReaderTest, parseReadAsLowerCase) {
   // 2 rows.
   const std::string upper(getExampleFilePath("upper.parquet"));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto outputRowType = ROW({"a", "b"}, {BIGINT(), BIGINT()});
   readerOptions.setFileSchema(outputRowType);
   readerOptions.setFileColumnNamesReadAsLowerCase(true);
@@ -475,7 +503,9 @@ TEST_F(ParquetReaderTest, parseRowMapArrayReadAsLowerCase) {
   // +-----------------------+
   const std::string upper(getExampleFilePath("upper_complex.parquet"));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileColumnNamesReadAsLowerCase(true);
   auto reader = createReader(upper, readerOptions);
 
@@ -518,7 +548,9 @@ TEST_F(ParquetReaderTest, parseEmpty) {
   // 0 rows.
   const std::string empty(getExampleFilePath("empty.parquet"));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(empty, readerOptions);
   EXPECT_EQ(reader->numberOfRows(), 0ULL);
 
@@ -540,7 +572,9 @@ TEST_F(ParquetReaderTest, parseInt) {
   //   bigint: [1000 .. 1009]
   const std::string sample(getExampleFilePath("int.parquet"));
 
-  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  dwio::common::ReaderOptions readerOpts(leafPool_.get());
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOpts);
 
   EXPECT_EQ(reader->numberOfRows(), 10ULL);
@@ -575,7 +609,9 @@ TEST_F(ParquetReaderTest, parseUnsignedInt1) {
   //   uint64: [18446744073709551615, 2000000000000000000, 3000000000000000000]
   const std::string sample(getExampleFilePath("uint.parquet"));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOptions);
 
   EXPECT_EQ(reader->numberOfRows(), 3ULL);
@@ -595,8 +631,9 @@ TEST_F(ParquetReaderTest, parseUnsignedInt1) {
           {TINYINT(), SMALLINT(), INTEGER(), BIGINT()});
 
   RowReaderOptions rowReaderOpts;
-  rowReaderOpts.select(std::make_shared<dwio::common::ColumnSelector>(
-      rowType, rowType->names()));
+  rowReaderOpts.select(
+      std::make_shared<dwio::common::ColumnSelector>(
+          rowType, rowType->names()));
   rowReaderOpts.setScanSpec(makeScanSpec(rowType));
   auto rowReader = reader->createRowReader(rowReaderOpts);
 
@@ -678,7 +715,9 @@ TEST_F(ParquetReaderTest, parseDate) {
   //   date: [1969-12-27 .. 1970-01-20]
   const std::string sample(getExampleFilePath("date.parquet"));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOptions);
 
   EXPECT_EQ(reader->numberOfRows(), 25ULL);
@@ -705,7 +744,9 @@ TEST_F(ParquetReaderTest, parseRowMapArray) {
   // ARRAY(INTEGER)) c1) c)
   const std::string sample(getExampleFilePath("row_map_array.parquet"));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOptions);
 
   EXPECT_EQ(reader->numberOfRows(), 1ULL);
@@ -738,7 +779,9 @@ TEST_F(ParquetReaderTest, parseRowMapArray) {
 TEST_F(ParquetReaderTest, projectNoColumns) {
   // This is the case for count(*).
   auto rowType = ROW({}, {});
-  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  dwio::common::ReaderOptions readerOpts(leafPool_.get());
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(getExampleFilePath("sample.parquet"), readerOpts);
   RowReaderOptions rowReaderOpts;
   rowReaderOpts.setScanSpec(makeScanSpec(rowType));
@@ -762,7 +805,9 @@ TEST_F(ParquetReaderTest, parseIntDecimal) {
   //   a: [11.11, 11.11, 22.22, 22.22, 33.33, 33.33]
   //   b: [11.11, 11.11, 22.22, 22.22, 33.33, 33.33]
   auto rowType = ROW({"a", "b"}, {DECIMAL(7, 2), DECIMAL(14, 2)});
-  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  dwio::common::ReaderOptions readerOpts(leafPool_.get());
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   const std::string decimal_dict(getExampleFilePath("decimal_dict.parquet"));
 
   auto reader = createReader(decimal_dict, readerOpts);
@@ -816,7 +861,9 @@ TEST_F(ParquetReaderTest, parseMapKeyValueAsMap) {
 
   const std::string sample(getExampleFilePath("map_key_value.parquet"));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOptions);
   EXPECT_EQ(reader->numberOfRows(), 1ULL);
 
@@ -864,7 +911,9 @@ TEST_F(ParquetReaderTest, parseRowArrayTest) {
   const std::string sample(
       getExampleFilePath("proto-struct-with-array.parquet"));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOptions);
   EXPECT_EQ(reader->numberOfRows(), 1ULL);
   auto type = reader->typeWithId();
@@ -1149,7 +1198,9 @@ TEST_F(ParquetReaderTest, filterRowGroups) {
   // decimal_no_ColumnMetadata.parquet has one columns a: DECIMAL(9,1). It
   // doesn't have ColumnMetaData, and rowGroups_[0].columns[0].file_offset is 0.
   auto rowType = ROW({"_c0"}, {DECIMAL(9, 1)});
-  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  dwio::common::ReaderOptions readerOpts(leafPool_.get());
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
   const std::string decimal_dict(
       getExampleFilePath("decimal_no_ColumnMetadata.parquet"));
 
@@ -1161,11 +1212,42 @@ TEST_F(ParquetReaderTest, filterRowGroups) {
   EXPECT_EQ(reader->numberOfRows(), 10ULL);
 }
 
+TEST_F(ParquetReaderTest, shouldIgnoreStatsForParquetMRVersions) {
+  SemanticVersion v181("parquet-mr", 1, 8, 1);
+  ParquetStatsContext ctx181{std::optional<SemanticVersion>(v181)};
+  EXPECT_TRUE(ctx181.shouldIgnoreStatistics(thrift::Type::BYTE_ARRAY))
+      << "ParquetStatsContext(parquet-mr 1.8.1) should ignore string stats";
+
+  SemanticVersion v182("parquet-mr", 1, 8, 2);
+  ParquetStatsContext ctx182{std::optional<SemanticVersion>(v182)};
+  EXPECT_FALSE(ctx182.shouldIgnoreStatistics(thrift::Type::BYTE_ARRAY))
+      << "ParquetStatsContext(parquet-mr 1.8.2) should not ignore string stats";
+}
+
+// This test is to verify filterRowGroups() doesn't fail if offset is 0
+TEST_F(ParquetReaderTest, filterRowGroupsWithZeroOffset) {
+  auto rowType = ROW({"IDX"}, {INTEGER()});
+  dwio::common::ReaderOptions readerOpts(leafPool_.get());
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
+  const std::string zeroOffsetPath(
+      getExampleFilePath("zero_offset_row_group.parquet"));
+
+  auto reader = createReader(zeroOffsetPath, readerOpts);
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.setScanSpec(makeScanSpec(rowType));
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  EXPECT_EQ(reader->numberOfRows(), 1L);
+}
+
 TEST_F(ParquetReaderTest, parseLongTagged) {
   // This is a case for long with annonation read
   const std::string sample(getExampleFilePath("tagged_long.parquet"));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOptions);
 
   EXPECT_EQ(reader->numberOfRows(), 4ULL);
@@ -1183,7 +1265,9 @@ TEST_F(ParquetReaderTest, preloadSmallFile) {
   auto file = std::make_shared<LocalReadFile>(sample);
   auto input = std::make_unique<BufferedInput>(file, *leafPool_);
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader =
       std::make_unique<ParquetReader>(std::move(input), readerOptions);
 
@@ -1196,7 +1280,7 @@ TEST_F(ParquetReaderTest, preloadSmallFile) {
   const auto fileSize = file->size();
   ASSERT_TRUE(
       fileSize <= dwio::common::ReaderOptions::kDefaultFilePreloadThreshold ||
-      fileSize <= dwio::common::ReaderOptions::kDefaultFooterEstimatedSize);
+      fileSize <= dwio::common::ReaderOptions::kDefaultFooterSpeculativeIoSize);
 
   // Check the whole file already loaded.
   ASSERT_EQ(file->bytesRead(), fileSize);
@@ -1217,7 +1301,9 @@ TEST_F(ParquetReaderTest, prefetchRowGroups) {
   const std::string sample(getExampleFilePath("multiple_row_groups.parquet"));
   const int numRowGroups = 4;
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   // Disable preload of file.
   readerOptions.setFilePreloadThreshold(0);
 
@@ -1270,7 +1356,9 @@ TEST_F(ParquetReaderTest, testEmptyRowGroups) {
   // empty_row_groups.parquet contains empty row groups
   const std::string sample(getExampleFilePath("empty_row_groups.parquet"));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOptions);
   EXPECT_EQ(reader->numberOfRows(), 5ULL);
 
@@ -1296,7 +1384,9 @@ TEST_F(ParquetReaderTest, testEnumType) {
   // enum_type.parquet contains 1 column (ENUM) with 3 rows.
   const std::string sample(getExampleFilePath("enum_type.parquet"));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOptions);
   EXPECT_EQ(reader->numberOfRows(), 3ULL);
 
@@ -1321,7 +1411,9 @@ TEST_F(ParquetReaderTest, readVarbinaryFromFLBA) {
   const std::string filename("varbinary_flba.parquet");
   const std::string sample(getExampleFilePath(filename));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOptions);
 
   auto type = reader->typeWithId();
@@ -1352,7 +1444,9 @@ TEST_F(ParquetReaderTest, readBinaryAsStringFromNation) {
   const std::string filename("nation.parquet");
   const std::string sample(getExampleFilePath(filename));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto outputRowType =
       ROW({"nationkey", "name", "regionkey", "comment"},
           {BIGINT(), VARCHAR(), BIGINT(), VARCHAR()});
@@ -1383,7 +1477,9 @@ TEST_F(ParquetReaderTest, readComplexType) {
   const std::string filename("complex_with_varchar_varbinary.parquet");
   const std::string sample(getExampleFilePath(filename));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto outputRowType =
       ROW({"a", "b", "c", "d"},
           {ARRAY(VARCHAR()),
@@ -1430,7 +1526,9 @@ TEST_F(ParquetReaderTest, readFixedLenBinaryAsStringFromUuid) {
   const std::string filename("uuid.parquet");
   const std::string sample(getExampleFilePath(filename));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto outputRowType = ROW({"uuid_field"}, {VARCHAR()});
 
   readerOptions.setFileSchema(outputRowType);
@@ -1458,7 +1556,9 @@ TEST_F(ParquetReaderTest, readFixedLenBinaryAsStringFromUuid) {
 TEST_F(ParquetReaderTest, testV2PageWithZeroMaxDefRep) {
   const std::string sample(getExampleFilePath("v2_page.parquet"));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOptions);
   EXPECT_EQ(reader->numberOfRows(), 5ULL);
 
@@ -1482,7 +1582,9 @@ TEST_F(ParquetReaderTest, testV2PageWithZeroMaxDefRep) {
 TEST_F(ParquetReaderTest, readComplexTypeWithV2Page) {
   const std::string sample(getExampleFilePath("complex_type_v2_page.parquet"));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOptions);
   EXPECT_EQ(reader->numberOfRows(), 1ULL);
 
@@ -1522,7 +1624,9 @@ TEST_F(ParquetReaderTest, arrayOfMapOfIntKeyArrayValue) {
       "ROW<test:ARRAY<MAP<VARCHAR,ARRAY<INTEGER>>>>";
   const std::string sample(
       getExampleFilePath("array_of_map_of_int_key_array_value.parquet"));
-  facebook::velox::dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  facebook::velox::dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOptions);
   EXPECT_EQ(reader->rowType()->toString(), expectedVeloxType);
   auto type = reader->typeWithId();
@@ -1555,7 +1659,9 @@ TEST_F(ParquetReaderTest, arrayOfMapOfIntKeyStructValue) {
       "ROW<test:ARRAY<MAP<INTEGER,ROW<stringfield:VARCHAR,longfield:BIGINT>>>>";
   const std::string sample(
       getExampleFilePath("array_of_map_of_int_key_struct_value.parquet"));
-  facebook::velox::dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  facebook::velox::dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOptions);
   EXPECT_EQ(reader->rowType()->toString(), expectedVeloxType);
   auto type = reader->typeWithId();
@@ -1589,7 +1695,9 @@ TEST_F(ParquetReaderTest, struct_of_array_of_array) {
       "ROW<test:ROW<stringarrayfield:ARRAY<ARRAY<VARCHAR>>,intarrayfield:ARRAY<ARRAY<INTEGER>>>>";
   const std::string sample(
       getExampleFilePath("struct_of_array_of_array.parquet"));
-  facebook::velox::dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  facebook::velox::dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOptions);
   auto type = reader->typeWithId();
   EXPECT_EQ(type->size(), 1ULL);
@@ -1653,7 +1761,9 @@ TEST_F(ParquetReaderTest, struct_of_array_of_array) {
 TEST_F(ParquetReaderTest, testLzoDataPage) {
   const std::string sample(getExampleFilePath("lzo.parquet"));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOptions);
   EXPECT_EQ(reader->numberOfRows(), 23'547ULL);
 
@@ -1688,7 +1798,9 @@ TEST_F(ParquetReaderTest, testLzoDataPage) {
 TEST_F(ParquetReaderTest, testEmptyV2DataPage) {
   const std::string sample(getExampleFilePath("empty_v2datapage.parquet"));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader = createReader(sample, readerOptions);
   EXPECT_EQ(reader->numberOfRows(), 30001ULL);
 
@@ -1720,7 +1832,9 @@ TEST_F(ParquetReaderTest, parquet251) {
 TEST_F(ParquetReaderTest, fileColumnVarcharToMetadataColumnMismatchTest) {
   const std::string sample(getExampleFilePath("nation.parquet"));
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
 
   auto runVarcharColTest = [&](const TypePtr& requestedType) {
     // The type in the file is a BYTE_ARRAY resolving to VARCHAR.
@@ -1738,7 +1852,7 @@ TEST_F(ParquetReaderTest, fileColumnVarcharToMetadataColumnMismatchTest) {
     VELOX_ASSERT_THROW(
         createReader(sample, readerOptions),
         fmt::format(
-            "Converted type VARCHAR is not allowed for requested type {}",
+            "Converted type VARCHAR is not allowed for requested type {} for file column 'name'",
             requestedType->toString()));
   };
 
@@ -1757,3 +1871,270 @@ TEST_F(ParquetReaderTest, fileColumnVarcharToMetadataColumnMismatchTest) {
     runVarcharColTest(type);
   }
 }
+
+TEST_F(ParquetReaderTest, readerWithSchema) {
+  // Create an in-memory writer.
+  auto sink = std::make_unique<MemorySink>(
+      1024 * 1024, dwio::common::FileSink::Options{.pool = leafPool_.get()});
+  auto sinkPtr = sink.get();
+  const auto data = makeRowVector(
+      {makeFlatVector<int64_t>({1}),
+       makeArrayVectorFromJson<int32_t>({"[4 ,5]"})});
+  parquet::WriterOptions writerOptions;
+  writerOptions.memoryPool = leafPool_.get();
+
+  // key, element are Parquet reserved keywords.
+  // Ensure we handle them properly during the schema inference.
+  auto schema = ROW({"key", "element"}, {BIGINT(), ARRAY(INTEGER())});
+
+  auto writer = std::make_unique<facebook::velox::parquet::Writer>(
+      std::move(sink), writerOptions, rootPool_, schema);
+  writer->write(data);
+  writer->close();
+
+  // Create the reader.
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  readerOptions.setFileSchema(schema);
+  std::string dataBuf(sinkPtr->data(), sinkPtr->size());
+  auto file = std::make_shared<InMemoryReadFile>(std::move(dataBuf));
+  auto buffer = std::make_unique<dwio::common::BufferedInput>(
+      file, readerOptions.memoryPool());
+  ParquetReader reader(std::move(buffer), readerOptions);
+
+  EXPECT_EQ(reader.rowType()->toString(), schema->toString());
+}
+
+TEST_F(ParquetReaderTest, columnStatistics) {
+  auto data = makeRowVector(
+      {"a", "b", "c"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+          makeFlatVector<double>({1.1, 2.2, 3.3, 4.4, 5.5}),
+          makeFlatVector<std::string>({"aaa", "bbb", "ccc", "ddd", "eee"}),
+      });
+
+  auto* sink = write(data);
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  auto reader = createReaderInMemory(*sink, readerOptions);
+  const auto& schema = reader->typeWithId();
+
+  // Root ROW type — no stats for non-leaf.
+  EXPECT_EQ(reader->columnStatistics(schema->id()), nullptr);
+
+  // Out of range.
+  EXPECT_EQ(reader->columnStatistics(schema->maxId() + 1), nullptr);
+
+  // BIGINT column.
+  {
+    auto stats = reader->columnStatistics(schema->childByName("a")->id());
+    ASSERT_NE(stats, nullptr);
+    EXPECT_EQ(stats->getNumberOfValues(), 5);
+    EXPECT_FALSE(stats->hasNull().value());
+    auto* intStats =
+        dynamic_cast<dwio::common::IntegerColumnStatistics*>(stats.get());
+    ASSERT_NE(intStats, nullptr);
+    EXPECT_EQ(intStats->getMinimum(), 1);
+    EXPECT_EQ(intStats->getMaximum(), 5);
+  }
+
+  // DOUBLE column.
+  {
+    auto stats = reader->columnStatistics(schema->childByName("b")->id());
+    ASSERT_NE(stats, nullptr);
+    EXPECT_EQ(stats->getNumberOfValues(), 5);
+    EXPECT_FALSE(stats->hasNull().value());
+    auto* doubleStats =
+        dynamic_cast<dwio::common::DoubleColumnStatistics*>(stats.get());
+    ASSERT_NE(doubleStats, nullptr);
+    EXPECT_EQ(doubleStats->getMinimum(), 1.1);
+    EXPECT_EQ(doubleStats->getMaximum(), 5.5);
+  }
+
+  // VARCHAR column.
+  {
+    auto stats = reader->columnStatistics(schema->childByName("c")->id());
+    ASSERT_NE(stats, nullptr);
+    EXPECT_EQ(stats->getNumberOfValues(), 5);
+    EXPECT_FALSE(stats->hasNull().value());
+    auto* stringStats =
+        dynamic_cast<dwio::common::StringColumnStatistics*>(stats.get());
+    ASSERT_NE(stringStats, nullptr);
+    EXPECT_EQ(stringStats->getMinimum(), "aaa");
+    EXPECT_EQ(stringStats->getMaximum(), "eee");
+  }
+}
+
+TEST_F(ParquetReaderTest, columnStatisticsWithNulls) {
+  auto data = makeRowVector(
+      {"a"},
+      {
+          makeNullableFlatVector<int64_t>(
+              {1, std::nullopt, 3, std::nullopt, 5}),
+      });
+
+  auto* sink = write(data);
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  auto reader = createReaderInMemory(*sink, readerOptions);
+  const auto& schema = reader->typeWithId();
+
+  auto stats = reader->columnStatistics(schema->childByName("a")->id());
+  ASSERT_NE(stats, nullptr);
+  EXPECT_EQ(stats->getNumberOfValues(), 3);
+  EXPECT_TRUE(stats->hasNull().value());
+  auto* intStats =
+      dynamic_cast<dwio::common::IntegerColumnStatistics*>(stats.get());
+  ASSERT_NE(intStats, nullptr);
+  EXPECT_EQ(intStats->getMinimum(), 1);
+  EXPECT_EQ(intStats->getMaximum(), 5);
+}
+
+TEST_F(ParquetReaderTest, columnStatisticsMultipleRowGroups) {
+  // Use a small flush size to force multiple row groups.
+  parquet::WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.get();
+  writerOptions.flushPolicyFactory = []() {
+    return std::make_unique<parquet::LambdaFlushPolicy>(
+        /*rowsInRowGroup=*/5,
+        /*bytesInRowGroup=*/1'024 * 1'024,
+        []() { return false; });
+  };
+
+  auto data = makeRowVector(
+      {"a"},
+      {
+          makeFlatVector<int64_t>({10, 20, 30, 40, 50, 1, 2, 3, 4, 5}),
+      });
+
+  auto* sink = write(data, writerOptions);
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  auto reader = createReaderInMemory(*sink, readerOptions);
+
+  // Verify we have multiple row groups.
+  ASSERT_GT(reader->fileMetaData().numRowGroups(), 1);
+
+  const auto& schema = reader->typeWithId();
+  auto stats = reader->columnStatistics(schema->childByName("a")->id());
+  ASSERT_NE(stats, nullptr);
+  EXPECT_EQ(stats->getNumberOfValues(), 10);
+  EXPECT_FALSE(stats->hasNull().value());
+  auto* intStats =
+      dynamic_cast<dwio::common::IntegerColumnStatistics*>(stats.get());
+  ASSERT_NE(intStats, nullptr);
+  // Global min/max across all row groups.
+  EXPECT_EQ(intStats->getMinimum(), 1);
+  EXPECT_EQ(intStats->getMaximum(), 50);
+}
+
+TEST_F(ParquetReaderTest, readTimeMillis) {
+  // Write TIME data using the parquet writer.
+  // The writer exports Velox TIME as Arrow time32 with milliseconds unit,
+  // which maps to Parquet TIME_MILLIS (INT32).
+  const auto rowType = ROW({"time_col"}, {TIME()});
+
+  auto data = makeRowVector(
+      rowType->names(),
+      {makeNullableFlatVector<int64_t>(
+          {1, 1'000, 3'600'000, std::nullopt, 43'200'000, 86'399'999},
+          TIME())});
+  auto sink = write(data);
+
+  dwio::common::ReaderOptions readerOpts(leafPool_.get());
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
+  auto reader = createReaderInMemory(*sink, readerOpts);
+
+  EXPECT_EQ(reader->numberOfRows(), 6ULL);
+
+  auto type = reader->typeWithId();
+  EXPECT_EQ(type->size(), 1ULL);
+  auto col0 = type->childAt(0);
+  EXPECT_TRUE(col0->type()->isTime());
+
+  auto rowReaderOpts = getReaderOpts(rowType);
+  rowReaderOpts.setScanSpec(makeScanSpec(rowType));
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  assertReadWithReaderAndExpected(rowType, *rowReader, data, *leafPool_);
+}
+
+TEST_F(ParquetReaderTest, readTimeMicros) {
+  // Write TIME MICRO UTC data using the parquet writer.
+  // The writer exports Velox TIME MICRO UTC as Arrow time64 with microseconds
+  // unit, which maps to Parquet TIME_MICROS (INT64).
+  const auto rowType = ROW({"time_col"}, {TIME_MICRO_UTC()});
+
+  auto data = makeRowVector(
+      rowType->names(),
+      {makeNullableFlatVector<int64_t>(
+          {0,
+           1,
+           1'000,
+           3'600'000'000,
+           std::nullopt,
+           43'200'000'000,
+           86'399'999'999},
+          TIME_MICRO_UTC())});
+  auto sink = write(data);
+
+  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
+  auto reader = createReaderInMemory(*sink, readerOpts);
+
+  EXPECT_EQ(reader->numberOfRows(), 7ULL);
+
+  auto type = reader->typeWithId();
+  EXPECT_EQ(type->size(), 1ULL);
+  auto col0 = type->childAt(0);
+  EXPECT_TRUE(col0->type()->isTime());
+  EXPECT_TRUE(col0->type()->equivalent(*TIME_MICRO_UTC()));
+
+  auto rowReaderOpts = getReaderOpts(rowType);
+  rowReaderOpts.setScanSpec(makeScanSpec(rowType));
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  assertReadWithReaderAndExpected(rowType, *rowReader, data, *leafPool_);
+}
+
+TEST_F(ParquetReaderTest, readTimeWithMultipleColumns) {
+  const auto rowType =
+      ROW({"id", "time_col", "name"}, {INTEGER(), TIME(), VARCHAR()});
+
+  auto data = makeRowVector(
+      rowType->names(),
+      {
+          makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+          makeFlatVector<int64_t>(
+              {0, 1'000, 3'600'000, 43'200'000, 86'399'999}, TIME()),
+          makeFlatVector<StringView>({"a", "b", "c", "d", "e"}),
+      });
+
+  auto sink = write(data);
+
+  dwio::common::ReaderOptions readerOpts(leafPool_.get());
+  readerOpts.setDataIoStats(dataIoStats_);
+  readerOpts.setMetadataIoStats(metadataIoStats_);
+  auto reader = createReaderInMemory(*sink, readerOpts);
+
+  EXPECT_EQ(reader->numberOfRows(), 5ULL);
+
+  auto type = reader->typeWithId();
+  EXPECT_EQ(type->size(), 3ULL);
+  EXPECT_EQ(type->childAt(0)->type()->kind(), TypeKind::INTEGER);
+  EXPECT_TRUE(type->childAt(1)->type()->isTime());
+  EXPECT_EQ(type->childAt(2)->type()->kind(), TypeKind::VARCHAR);
+
+  auto rowReaderOpts = getReaderOpts(rowType);
+  rowReaderOpts.setScanSpec(makeScanSpec(rowType));
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  assertReadWithReaderAndExpected(rowType, *rowReader, data, *leafPool_);
+}
diff --git a/velox/dwio/parquet/tests/reader/ParquetReaderWideningTest.cpp b/velox/dwio/parquet/tests/reader/ParquetReaderWideningTest.cpp
new file mode 100644
index 00000000000..557b24bb5df
--- /dev/null
+++ b/velox/dwio/parquet/tests/reader/ParquetReaderWideningTest.cpp
@@ -0,0 +1,1512 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/dwio/common/Mutation.h"
+#include "velox/dwio/parquet/tests/ParquetTestBase.h"
+#include "velox/expression/ExprToSubfieldFilter.h"
+#include "velox/vector/tests/utils/VectorMaker.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::common;
+using namespace facebook::velox::dwio::common;
+using namespace facebook::velox::parquet;
+
+class ParquetReaderWideningTest : public ParquetTestBase {
+ public:
+  std::unique_ptr<dwio::common::RowReader> createWideningRowReader(
+      const RowVectorPtr& writeData,
+      const RowTypePtr& readSchema,
+      bool allowInt32Narrowing = false) {
+    auto* sink = write(writeData);
+    dwio::common::ReaderOptions readerOptions(leafPool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
+    readerOptions.setFileSchema(readSchema);
+    readerOptions.setAllowInt32Narrowing(allowInt32Narrowing);
+    auto reader = createReaderInMemory(*sink, readerOptions);
+    auto rowReaderOpts = getReaderOpts(readSchema);
+    rowReaderOpts.setScanSpec(makeScanSpec(readSchema));
+    return reader->createRowReader(rowReaderOpts);
+  }
+
+  /// Writes Parquet data with one schema and reads it back with a wider schema,
+  /// then verifies the result matches the expected output.
+  void assertWideningReads(
+      const RowVectorPtr& writeData,
+      const RowTypePtr& readSchema,
+      const RowVectorPtr& expected) {
+    auto rowReader = createWideningRowReader(writeData, readSchema);
+    assertReadWithReaderAndExpected(
+        readSchema, *rowReader, expected, *leafPool_);
+  }
+
+  /// Writes Parquet data and reads it back with a narrower schema
+  /// (allowInt32Narrowing enabled), then verifies the result.
+  void assertNarrowingReads(
+      const RowVectorPtr& writeData,
+      const RowTypePtr& readSchema,
+      const RowVectorPtr& expected) {
+    auto rowReader = createWideningRowReader(
+        writeData, readSchema, /*allowInt32Narrowing=*/true);
+    assertReadWithReaderAndExpected(
+        readSchema, *rowReader, expected, *leafPool_);
+  }
+
+  /// Writes Parquet data, reads with widening schema + filter, verifies result.
+  void assertWideningWithFilter(
+      const RowVectorPtr& writeData,
+      const RowTypePtr& readSchema,
+      std::unique_ptr<common::Filter> filter,
+      const RowVectorPtr& expected,
+      bool allowInt32Narrowing = false) {
+    auto* sink = write(writeData);
+    dwio::common::ReaderOptions readerOptions(leafPool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
+    readerOptions.setFileSchema(readSchema);
+    readerOptions.setAllowInt32Narrowing(allowInt32Narrowing);
+    auto reader = createReaderInMemory(*sink, readerOptions);
+    auto rowReaderOpts = getReaderOpts(readSchema);
+    auto scanSpec = makeScanSpec(readSchema);
+    auto* child = scanSpec->getOrCreateChild(common::Subfield("col"));
+    child->setFilter(std::move(filter));
+    rowReaderOpts.setScanSpec(scanSpec);
+    auto rowReader = reader->createRowReader(rowReaderOpts);
+    assertReadWithReaderAndExpected(
+        readSchema, *rowReader, expected, *leafPool_);
+  }
+
+  /// Verifies that reading in-memory Parquet data with a mismatched schema
+  /// throws an exception whose message contains both the source type name and
+  /// "is not allowed for requested type".
+  void assertWideningThrows(
+      const RowVectorPtr& writeData,
+      const RowTypePtr& readSchema,
+      const std::string& sourceTypeName) {
+    auto* sink = write(writeData);
+    dwio::common::ReaderOptions readerOptions(leafPool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
+    readerOptions.setFileSchema(readSchema);
+    VELOX_ASSERT_THROW(
+        createReaderInMemory(*sink, readerOptions),
+        "Converted type " + sourceTypeName +
+            " is not allowed for requested type");
+  }
+};
+
+// Comprehensive test matrix covering all combinations:
+// - Nulls: No nulls, With nulls
+// - Dictionary: Enabled, Disabled
+// - Filter: None, IsNull, IsNotNull, Value filter
+// - Density: Dense (no deletions), Non-dense (with deletions/mutations)
+
+enum class FloatToDoubleFilter {
+  kNone,
+  kIsNull,
+  kIsNotNull,
+  kGreaterThanOrEqual, // Value filter: greater than or equal to a threshold
+  kMultiRange, // MultiRange filter: a < X OR a > Y
+};
+
+struct FloatToDoubleSpec {
+  std::vector<std::optional<float>> values;
+  std::vector<int64_t> ids;
+  bool enableDictionary{true};
+  FloatToDoubleFilter filter{FloatToDoubleFilter::kNone};
+  std::optional<double> filterValue; // Value for value-based filters
+  std::optional<double> filterLowerValue; // Lower bound for MultiRange filter
+  std::optional<double> filterUpperValue; // Upper bound for MultiRange filter
+  std::vector<vector_size_t> deletedRows;
+};
+
+struct FloatToDoubleTestParam {
+  bool hasNulls;
+  bool enableDictionary;
+  FloatToDoubleFilter filter;
+  bool isDense;
+
+  std::string toString() const {
+    return fmt::format(
+        "Nulls_{}_Dict_{}_Filter_{}_Dense_{}",
+        hasNulls ? "Yes" : "No",
+        enableDictionary ? "Yes" : "No",
+        filterName(filter),
+        isDense ? "Yes" : "No");
+  }
+
+  static std::string filterName(FloatToDoubleFilter filter) {
+    switch (filter) {
+      case FloatToDoubleFilter::kNone:
+        return "None";
+      case FloatToDoubleFilter::kIsNull:
+        return "IsNull";
+      case FloatToDoubleFilter::kIsNotNull:
+        return "IsNotNull";
+      case FloatToDoubleFilter::kGreaterThanOrEqual:
+        return "GreaterThanOrEqual";
+      case FloatToDoubleFilter::kMultiRange:
+        return "MultiRange";
+      default:
+        return "Unknown";
+    }
+  }
+};
+
+class FloatToDoubleEvolutionTest
+    : public ParquetReaderWideningTest,
+      public testing::WithParamInterface<FloatToDoubleTestParam> {
+ public:
+  static std::vector<FloatToDoubleTestParam> getTestParams() {
+    std::vector<FloatToDoubleTestParam> params;
+    for (bool hasNulls : {false, true}) {
+      for (bool enableDictionary : {false, true}) {
+        // When hasNulls is false, only test kNone, kGreaterThanOrEqual, and
+        // kMultiRange filter (kIsNull would match nothing, kIsNotNull is
+        // equivalent to kNone)
+        std::vector<FloatToDoubleFilter> filters;
+        if (hasNulls) {
+          filters = {
+              FloatToDoubleFilter::kNone,
+              FloatToDoubleFilter::kIsNull,
+              FloatToDoubleFilter::kIsNotNull,
+              FloatToDoubleFilter::kGreaterThanOrEqual,
+              FloatToDoubleFilter::kMultiRange};
+        } else {
+          filters = {
+              FloatToDoubleFilter::kNone,
+              FloatToDoubleFilter::kGreaterThanOrEqual,
+              FloatToDoubleFilter::kMultiRange};
+        }
+
+        for (auto filter : filters) {
+          for (bool isDense : {true, false}) {
+            params.push_back({hasNulls, enableDictionary, filter, isDense});
+          }
+        }
+      }
+    }
+    return params;
+  }
+
+  void runFloatToDoubleScenario(const FloatToDoubleSpec& spec);
+};
+
+void FloatToDoubleEvolutionTest::runFloatToDoubleScenario(
+    const FloatToDoubleSpec& spec) {
+  ASSERT_EQ(spec.values.size(), spec.ids.size());
+  const vector_size_t numRows = spec.ids.size();
+
+  auto floatVector = makeNullableFlatVector<float>(spec.values);
+  auto idVector =
+      makeFlatVector<int64_t>(numRows, [&](auto row) { return spec.ids[row]; });
+
+  RowVectorPtr writeData = makeRowVector({floatVector, idVector});
+  RowTypePtr writeSchema = ROW({"float_col", "id"}, {REAL(), BIGINT()});
+
+  auto sink = std::make_unique<MemorySink>(
+      1024 * 1024, dwio::common::FileSink::Options{.pool = leafPool_.get()});
+  auto sinkPtr = sink.get();
+
+  parquet::WriterOptions writerOptions;
+  writerOptions.memoryPool = leafPool_.get();
+  writerOptions.enableDictionary = spec.enableDictionary;
+
+  auto writer = std::make_unique<facebook::velox::parquet::Writer>(
+      std::move(sink), writerOptions, rootPool_, writeSchema);
+  writer->write(writeData);
+  writer->close();
+
+  RowTypePtr readSchema = ROW({"float_col", "id"}, {DOUBLE(), BIGINT()});
+
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  readerOptions.setFileSchema(readSchema);
+
+  std::string dataBuf(sinkPtr->data(), sinkPtr->size());
+  auto file = std::make_shared<InMemoryReadFile>(std::move(dataBuf));
+  auto buffer = std::make_unique<dwio::common::BufferedInput>(
+      file, readerOptions.memoryPool());
+  auto reader =
+      std::make_unique<ParquetReader>(std::move(buffer), readerOptions);
+
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.select(
+      std::make_shared<facebook::velox::dwio::common::ColumnSelector>(
+          readSchema, readSchema->names()));
+  auto scanSpec = makeScanSpec(readSchema);
+
+  // Apply IsNull or IsNotNull filter if specified
+  switch (spec.filter) {
+    case FloatToDoubleFilter::kNone:
+      break;
+    case FloatToDoubleFilter::kIsNull: {
+      auto* floatChild =
+          scanSpec->getOrCreateChild(common::Subfield("float_col"));
+      floatChild->setFilter(exec::isNull());
+      break;
+    }
+    case FloatToDoubleFilter::kIsNotNull: {
+      auto* floatChild =
+          scanSpec->getOrCreateChild(common::Subfield("float_col"));
+      floatChild->setFilter(exec::isNotNull());
+      break;
+    }
+    case FloatToDoubleFilter::kGreaterThanOrEqual: {
+      ASSERT_TRUE(spec.filterValue.has_value());
+      auto* floatChild =
+          scanSpec->getOrCreateChild(common::Subfield("float_col"));
+      floatChild->setFilter(
+          exec::greaterThanOrEqualDouble(spec.filterValue.value()));
+      break;
+    }
+    case FloatToDoubleFilter::kMultiRange: {
+      ASSERT_TRUE(spec.filterLowerValue.has_value());
+      ASSERT_TRUE(spec.filterUpperValue.has_value());
+      auto* floatChild =
+          scanSpec->getOrCreateChild(common::Subfield("float_col"));
+      // Create a MultiRange filter: a < lower OR a > upper
+      floatChild->setFilter(
+          exec::orFilter(
+              exec::lessThanDouble(spec.filterLowerValue.value()),
+              exec::greaterThanDouble(spec.filterUpperValue.value())));
+      break;
+    }
+  }
+
+  rowReaderOpts.setScanSpec(scanSpec);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  std::vector<bool> deletedFlags(numRows, false);
+  for (auto index : spec.deletedRows) {
+    ASSERT_LT(index, numRows);
+    deletedFlags[index] = true;
+  }
+
+  std::vector<vector_size_t> expectedIndices;
+  expectedIndices.reserve(numRows);
+  for (vector_size_t row = 0; row < numRows; ++row) {
+    if (deletedFlags[row]) {
+      continue;
+    }
+
+    bool passes = false;
+    switch (spec.filter) {
+      case FloatToDoubleFilter::kNone:
+        passes = true;
+        break;
+      case FloatToDoubleFilter::kIsNull:
+        passes = !spec.values[row].has_value();
+        break;
+      case FloatToDoubleFilter::kIsNotNull:
+        passes = spec.values[row].has_value();
+        break;
+      case FloatToDoubleFilter::kGreaterThanOrEqual:
+        passes = spec.values[row].has_value() &&
+            static_cast<double>(*spec.values[row]) >= spec.filterValue.value();
+        break;
+      case FloatToDoubleFilter::kMultiRange:
+        passes = spec.values[row].has_value() &&
+            (static_cast<double>(*spec.values[row]) <
+                 spec.filterLowerValue.value() ||
+             static_cast<double>(*spec.values[row]) >
+                 spec.filterUpperValue.value());
+        break;
+    }
+
+    if (passes) {
+      expectedIndices.push_back(row);
+    }
+  }
+
+  std::vector<std::optional<double>> expectedDoubles(expectedIndices.size());
+  for (size_t i = 0; i < expectedIndices.size(); ++i) {
+    const auto originalIndex = expectedIndices[i];
+    if (!spec.values[originalIndex].has_value()) {
+      expectedDoubles[i] = std::nullopt;
+    } else {
+      expectedDoubles[i] = static_cast<double>(*spec.values[originalIndex]);
+    }
+  }
+
+  auto expectedFloat = makeNullableFlatVector<double>(expectedDoubles);
+  auto expectedId = makeFlatVector<int64_t>(
+      expectedIndices.size(),
+      [&](auto row) { return spec.ids[expectedIndices[row]]; });
+  RowVectorPtr expected = makeRowVector({expectedFloat, expectedId});
+
+  if (spec.deletedRows.empty() && spec.filter != FloatToDoubleFilter::kIsNull &&
+      spec.filter != FloatToDoubleFilter::kIsNotNull &&
+      spec.filter != FloatToDoubleFilter::kGreaterThanOrEqual &&
+      spec.filter != FloatToDoubleFilter::kMultiRange) {
+    assertReadWithReaderAndExpected(
+        readSchema, *rowReader, expected, *leafPool_);
+    return;
+  }
+
+  VectorPtr result = BaseVector::create(readSchema, 0, leafPool_.get());
+  vector_size_t scanned = 0;
+  std::vector<uint64_t> deleted(bits::nwords(numRows), 0);
+  if (spec.deletedRows.empty()) {
+    scanned = rowReader->next(numRows, result);
+  } else {
+    for (auto index : spec.deletedRows) {
+      bits::setBit(deleted.data(), index);
+    }
+    dwio::common::Mutation mutation;
+    mutation.deletedRows = deleted.data();
+    scanned = rowReader->next(numRows, result, &mutation);
+  }
+
+  EXPECT_GT(scanned, 0);
+  EXPECT_GE(scanned, expected->size());
+  ASSERT_TRUE(result != nullptr);
+  auto rowVector = result->as<RowVector>();
+  ASSERT_TRUE(rowVector != nullptr);
+  ASSERT_EQ(rowVector->size(), expected->size());
+  assertEqualVectorPart(expected, result, 0);
+}
+
+TEST_P(FloatToDoubleEvolutionTest, readFloatToDouble) {
+  const auto& param = GetParam();
+  FloatToDoubleSpec spec;
+  constexpr vector_size_t kSize = 200;
+  spec.enableDictionary = param.enableDictionary;
+  spec.values.resize(kSize);
+  spec.ids.resize(kSize);
+
+  for (vector_size_t row = 0; row < kSize; ++row) {
+    if (param.hasNulls && row % 5 == 0) {
+      spec.values[row] = std::nullopt;
+    } else {
+      // Use a value pattern that works for both dictionary and direct encoding
+      float val =
+          static_cast<float>(row % 10) * 1.1f + static_cast<float>(row) * 0.01f;
+      spec.values[row] = val;
+    }
+    spec.ids[row] = row;
+  }
+
+  spec.filter = param.filter;
+
+  // Set filter value for value-based filters
+  if (param.filter == FloatToDoubleFilter::kGreaterThanOrEqual) {
+    // Filter values greater than or equal to 5.0 (this should match
+    // approximately half the rows)
+    spec.filterValue = 5.0;
+  } else if (param.filter == FloatToDoubleFilter::kMultiRange) {
+    // Filter values < 3.0 OR > 7.0
+    spec.filterLowerValue = 3.0;
+    spec.filterUpperValue = 7.0;
+  }
+
+  if (!param.isDense) {
+    // Add some deleted rows scattered throughout
+    spec.deletedRows = {5, 20, 55, 99, 150, 199};
+  }
+
+  runFloatToDoubleScenario(spec);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    FloatToDoubleEvolution,
+    FloatToDoubleEvolutionTest,
+    testing::ValuesIn(FloatToDoubleEvolutionTest::getTestParams()),
+    [](const testing::TestParamInfo<FloatToDoubleTestParam>& info) {
+      return info.param.toString();
+    });
+
+// Type widening tests: verify reading Parquet columns with a wider target
+// type than the physical type stored in the file.
+
+TEST_F(ParquetReaderWideningTest, intToShortDecimalWidening) {
+  auto writeData = makeRowVector({makeFlatVector<int32_t>(
+      {0, 1, -1, 100, -100, 2'147'483'647, -2'147'483'648})});
+  auto expected = makeRowVector({makeFlatVector<int64_t>(
+      {0, 100, -100, 10'000, -10'000, 214'748'364'700LL, -214'748'364'800LL},
+      DECIMAL(12, 2))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(12, 2)}), expected);
+}
+
+TEST_F(ParquetReaderWideningTest, smallintToShortDecimalWidening) {
+  auto writeData = makeRowVector(
+      {makeFlatVector<int16_t>({0, 1, -1, 100, 32'767, -32'768})});
+  auto expected = makeRowVector({makeFlatVector<int64_t>(
+      {0, 100, -100, 10'000, 3'276'700, -3'276'800}, DECIMAL(12, 2))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(12, 2)}), expected);
+}
+
+TEST_F(ParquetReaderWideningTest, tinyintToShortDecimalWidening) {
+  auto writeData =
+      makeRowVector({makeFlatVector<int8_t>({0, 1, -1, 100, 127, -128})});
+  auto expected = makeRowVector({makeFlatVector<int64_t>(
+      {0, 100, -100, 10'000, 12'700, -12'800}, DECIMAL(12, 2))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(12, 2)}), expected);
+}
+
+// Parquet stores TINYINT as INT32, so the minimum precision for decimal
+// widening is precision-scale >= 10 (same as INT32). Test exact boundary.
+TEST_F(ParquetReaderWideningTest, tinyintToDecimalMinPrecisionWidening) {
+  auto writeData =
+      makeRowVector({makeFlatVector<int8_t>({0, 1, -1, 127, -128})});
+  auto expected = makeRowVector(
+      {makeFlatVector<int64_t>({0, 1, -1, 127, -128}, DECIMAL(10, 0))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(10, 0)}), expected);
+}
+
+// Parquet stores SMALLINT as INT32, so decimal widening requires
+// precision-scale >= 10 (same as INT32). Test exact boundary.
+TEST_F(ParquetReaderWideningTest, smallintToDecimalMinPrecisionWidening) {
+  auto writeData =
+      makeRowVector({makeFlatVector<int16_t>({0, 1, -1, 32'767, -32'768})});
+  auto expected = makeRowVector(
+      {makeFlatVector<int64_t>({0, 1, -1, 32'767, -32'768}, DECIMAL(10, 0))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(10, 0)}), expected);
+}
+
+// Byte -> Long Decimal. Parquet stores TINYINT as INT32.
+TEST_F(ParquetReaderWideningTest, tinyintToLongDecimalWidening) {
+  auto writeData =
+      makeRowVector({makeFlatVector<int8_t>({0, 1, -1, 127, -128})});
+  auto expected = makeRowVector(
+      {makeFlatVector<int128_t>({0, 1, -1, 127, -128}, DECIMAL(20, 0))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(20, 0)}), expected);
+}
+
+// Short -> Long Decimal. Parquet stores SMALLINT as INT32.
+TEST_F(ParquetReaderWideningTest, smallintToLongDecimalWidening) {
+  auto writeData =
+      makeRowVector({makeFlatVector<int16_t>({0, 1, -1, 32'767, -32'768})});
+  auto expected = makeRowVector(
+      {makeFlatVector<int128_t>({0, 1, -1, 32'767, -32'768}, DECIMAL(20, 0))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(20, 0)}), expected);
+}
+
+TEST_F(ParquetReaderWideningTest, bigintToLongDecimalWidening) {
+  auto writeData = makeRowVector({makeFlatVector<int64_t>(
+      {0, 1, -1, 1'000'000'000'000LL, -1'000'000'000'000LL})});
+  auto expected = makeRowVector({makeFlatVector<int128_t>(
+      {0,
+       100'000,
+       -100'000,
+       static_cast<int128_t>(1'000'000'000'000LL) * 100'000,
+       static_cast<int128_t>(-1'000'000'000'000LL) * 100'000},
+      DECIMAL(25, 5))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(25, 5)}), expected);
+}
+
+TEST_F(ParquetReaderWideningTest, decimalToDecimalWidening) {
+  auto writeData = makeRowVector(
+      {makeFlatVector<int64_t>({1111, 2222, 3333, -4444, 0}, DECIMAL(7, 2))});
+  // Each value v becomes v * 10^(4-2) = v * 100.
+  auto expected = makeRowVector({makeFlatVector<int64_t>(
+      {111'100, 222'200, 333'300, -444'400, 0}, DECIMAL(10, 4))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(10, 4)}), expected);
+}
+
+TEST_F(ParquetReaderWideningTest, decimalToDecimalPrecisionOnlyWidening) {
+  auto writeData = makeRowVector(
+      {makeFlatVector<int64_t>({1111, 2222, 3333, -4444, 0}, DECIMAL(7, 2))});
+  auto expected = makeRowVector(
+      {makeFlatVector<int64_t>({1111, 2222, 3333, -4444, 0}, DECIMAL(10, 2))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(10, 2)}), expected);
+}
+
+// Decimal long -> long, precision-only widening (scale stays the same).
+TEST_F(ParquetReaderWideningTest, decimalLongToLongPrecisionOnlyWidening) {
+  auto writeData = makeRowVector(
+      {makeFlatVector<int128_t>({1111, -2222, 0}, DECIMAL(20, 2))});
+  auto expected = makeRowVector(
+      {makeFlatVector<int128_t>({1111, -2222, 0}, DECIMAL(22, 2))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(22, 2)}), expected);
+}
+
+TEST_F(ParquetReaderWideningTest, decimalToDecimalWideningWithNulls) {
+  auto writeData = makeRowVector({makeNullableFlatVector<int64_t>(
+      {std::nullopt, 1111, std::nullopt, -4444, 0, std::nullopt},
+      DECIMAL(7, 2))});
+  // Each value v becomes v * 10^(4-2) = v * 100.
+  auto expected = makeRowVector({makeNullableFlatVector<int64_t>(
+      {std::nullopt, 111'100, std::nullopt, -444'400, 0, std::nullopt},
+      DECIMAL(10, 4))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(10, 4)}), expected);
+}
+
+TEST_F(ParquetReaderWideningTest, intToDecimalWideningWithNulls) {
+  auto writeData = makeRowVector({makeNullableFlatVector<int32_t>(
+      {std::nullopt, 42, std::nullopt, -7, 0, std::nullopt})});
+  auto expected = makeRowVector({makeNullableFlatVector<int64_t>(
+      {std::nullopt, 4200, std::nullopt, -700, 0, std::nullopt},
+      DECIMAL(12, 2))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(12, 2)}), expected);
+}
+
+// All-null column: getDecimalValues must handle ConstantVector (all nulls)
+// without crashing when scaleAdjust > 0.
+TEST_F(ParquetReaderWideningTest, intToDecimalWideningAllNull) {
+  auto writeData = makeRowVector({makeNullableFlatVector<int32_t>(
+      {std::nullopt, std::nullopt, std::nullopt})});
+  auto expected = makeRowVector({makeNullableFlatVector<int64_t>(
+      {std::nullopt, std::nullopt, std::nullopt}, DECIMAL(12, 2))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(12, 2)}), expected);
+}
+
+TEST_F(ParquetReaderWideningTest, decimalToDecimalWideningAllNull) {
+  auto writeData = makeRowVector({makeNullableFlatVector<int64_t>(
+      {std::nullopt, std::nullopt, std::nullopt}, DECIMAL(7, 2))});
+  auto expected = makeRowVector({makeNullableFlatVector<int64_t>(
+      {std::nullopt, std::nullopt, std::nullopt}, DECIMAL(10, 4))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(10, 4)}), expected);
+}
+
+// INT32 -> SMALLINT narrowing. Parquet stores both as INT32; reading with
+// a narrower type truncates to 16 bits via static_cast.
+TEST_F(ParquetReaderWideningTest, intToSmallintNarrowing) {
+  auto writeData =
+      makeRowVector({makeFlatVector<int32_t>({0, 1, -1, 100, -100})});
+  auto expected =
+      makeRowVector({makeFlatVector<int16_t>({0, 1, -1, 100, -100})});
+  assertNarrowingReads(writeData, ROW({"col"}, {SMALLINT()}), expected);
+}
+
+TEST_F(ParquetReaderWideningTest, smallintToTinyintNarrowing) {
+  auto writeData =
+      makeRowVector({makeFlatVector<int16_t>({0, 1, -1, 42, -42})});
+  auto expected = makeRowVector({makeFlatVector<int8_t>({0, 1, -1, 42, -42})});
+  assertNarrowingReads(writeData, ROW({"col"}, {TINYINT()}), expected);
+}
+
+TEST_F(ParquetReaderWideningTest, shortToIntegerWidening) {
+  auto writeData =
+      makeRowVector({makeFlatVector<int16_t>({0, 1, -1, 32'767, -32'768})});
+  auto expected =
+      makeRowVector({makeFlatVector<int32_t>({0, 1, -1, 32'767, -32'768})});
+  assertWideningReads(writeData, ROW({"col"}, {INTEGER()}), expected);
+}
+
+TEST_F(ParquetReaderWideningTest, intToBigintWidening) {
+  auto writeData = makeRowVector(
+      {makeFlatVector<int32_t>({0, 1, -1, 2'147'483'647, -2'147'483'648})});
+  auto expected = makeRowVector(
+      {makeFlatVector<int64_t>({0, 1, -1, 2'147'483'647, -2'147'483'648})});
+  assertWideningReads(writeData, ROW({"col"}, {BIGINT()}), expected);
+}
+
+// INT32 -> SMALLINT overflow: 32768 truncates to -32768.
+TEST_F(ParquetReaderWideningTest, intToSmallintOverflow) {
+  auto writeData = makeRowVector({makeFlatVector<int32_t>({32'768})});
+  auto expected = makeRowVector({makeFlatVector<int16_t>({-32'768})});
+  assertNarrowingReads(writeData, ROW({"col"}, {SMALLINT()}), expected);
+}
+
+// INT16 -> TINYINT overflow: 128 truncates to -128.
+TEST_F(ParquetReaderWideningTest, smallintToTinyintOverflow) {
+  auto writeData = makeRowVector({makeFlatVector<int16_t>({128})});
+  auto expected = makeRowVector({makeFlatVector<int8_t>({-128})});
+  assertNarrowingReads(writeData, ROW({"col"}, {TINYINT()}), expected);
+}
+
+// INT32 -> DOUBLE works because sizeof(int32_t)=4 != sizeof(double)=8,
+// so getFlatValues takes the upcastScalarValues path.
+TEST_F(ParquetReaderWideningTest, intToDoubleWidening) {
+  auto writeData = makeRowVector({makeFlatVector<int32_t>(
+      {0, 1, -1, 100, -100, 2'147'483'647, -2'147'483'648})});
+  auto expected = makeRowVector({makeFlatVector<double>(
+      {0.0, 1.0, -1.0, 100.0, -100.0, 2'147'483'647.0, -2'147'483'648.0})});
+  assertWideningReads(writeData, ROW({"col"}, {DOUBLE()}), expected);
+}
+
+TEST_F(ParquetReaderWideningTest, intToDoubleWideningWithNulls) {
+  auto writeData = makeRowVector({makeNullableFlatVector<int32_t>(
+      {std::nullopt, 42, std::nullopt, -7, 0, std::nullopt})});
+  auto expected = makeRowVector({makeNullableFlatVector<double>(
+      {std::nullopt, 42.0, std::nullopt, -7.0, 0.0, std::nullopt})});
+  assertWideningReads(writeData, ROW({"col"}, {DOUBLE()}), expected);
+}
+
+// Byte/Short -> Double widening. Parquet stores both as INT32.
+TEST_F(ParquetReaderWideningTest, tinyintToDoubleWidening) {
+  auto writeData =
+      makeRowVector({makeFlatVector<int8_t>({0, 1, -1, 127, -128})});
+  auto expected =
+      makeRowVector({makeFlatVector<double>({0.0, 1.0, -1.0, 127.0, -128.0})});
+  assertWideningReads(writeData, ROW({"col"}, {DOUBLE()}), expected);
+}
+
+TEST_F(ParquetReaderWideningTest, smallintToDoubleWidening) {
+  auto writeData =
+      makeRowVector({makeFlatVector<int16_t>({0, 1, -1, 32'767, -32'768})});
+  auto expected = makeRowVector(
+      {makeFlatVector<double>({0.0, 1.0, -1.0, 32'767.0, -32'768.0})});
+  assertWideningReads(writeData, ROW({"col"}, {DOUBLE()}), expected);
+}
+
+// INT -> Decimal with scale=0 (exact boundary: p-s=10 for INT32).
+TEST_F(ParquetReaderWideningTest, intToDecimalScale0Widening) {
+  auto writeData =
+      makeRowVector({makeFlatVector<int32_t>({0, 42, -42, 2'147'483'647})});
+  auto expected = makeRowVector(
+      {makeFlatVector<int64_t>({0, 42, -42, 2'147'483'647}, DECIMAL(10, 0))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(10, 0)}), expected);
+}
+
+// INT -> Decimal with scale=1 (p-s=10, minimum boundary with nonzero scale).
+TEST_F(ParquetReaderWideningTest, intToDecimalScale1Widening) {
+  auto writeData = makeRowVector({makeFlatVector<int32_t>({0, 5, -5, 100})});
+  auto expected = makeRowVector(
+      {makeFlatVector<int64_t>({0, 50, -50, 1000}, DECIMAL(11, 1))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(11, 1)}), expected);
+}
+
+// Byte -> Decimal with nonzero scale. Values multiplied by 10^scale.
+TEST_F(ParquetReaderWideningTest, tinyintToDecimalWithScaleWidening) {
+  auto writeData =
+      makeRowVector({makeFlatVector<int8_t>({0, 1, -1, 127, -128})});
+  auto expected = makeRowVector(
+      {makeFlatVector<int64_t>({0, 10, -10, 1'270, -1'280}, DECIMAL(11, 1))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(11, 1)}), expected);
+}
+
+// Short -> Decimal with nonzero scale. Values multiplied by 10^scale.
+TEST_F(ParquetReaderWideningTest, smallintToDecimalWithScaleWidening) {
+  auto writeData =
+      makeRowVector({makeFlatVector<int16_t>({0, 1, -1, 32'767, -32'768})});
+  auto expected = makeRowVector({makeFlatVector<int64_t>(
+      {0, 10, -10, 327'670, -327'680}, DECIMAL(11, 1))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(11, 1)}), expected);
+}
+
+// INT32 -> Long Decimal (crossing short/long boundary).
+TEST_F(ParquetReaderWideningTest, intToLongDecimalWidening) {
+  auto writeData = makeRowVector(
+      {makeFlatVector<int32_t>({0, 1, -1, 2'147'483'647, -2'147'483'648})});
+  auto expected = makeRowVector({makeFlatVector<int128_t>(
+      {0, 1, -1, 2'147'483'647, -2'147'483'648}, DECIMAL(20, 0))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(20, 0)}), expected);
+}
+
+// BIGINT -> Decimal(38,0), maximum precision long decimal.
+TEST_F(ParquetReaderWideningTest, bigintToMaxPrecisionDecimalWidening) {
+  auto writeData = makeRowVector(
+      {makeFlatVector<int64_t>({0, 1, -1, 9'223'372'036'854'775'807LL})});
+  auto expected = makeRowVector({makeFlatVector<int128_t>(
+      {0, 1, -1, static_cast<int128_t>(9'223'372'036'854'775'807LL)},
+      DECIMAL(38, 0))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(38, 0)}), expected);
+}
+
+// BIGINT -> Decimal(21,1), INT64 with nonzero scale.
+TEST_F(ParquetReaderWideningTest, bigintToDecimalWithScaleWidening) {
+  auto writeData =
+      makeRowVector({makeFlatVector<int64_t>({0, 1, -1, 999'999})});
+  auto expected = makeRowVector(
+      {makeFlatVector<int128_t>({0, 10, -10, 9'999'990}, DECIMAL(21, 1))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(21, 1)}), expected);
+}
+
+// Decimal short -> long decimal crossing: file stores int64 (short decimal),
+// requested type is int128 (long decimal). getIntValues upcasts int64->int128.
+TEST_F(ParquetReaderWideningTest, decimalShortToLongWidening) {
+  auto writeData = makeRowVector(
+      {makeFlatVector<int64_t>({1111, -2222, 0, 99999}, DECIMAL(5, 2))});
+  auto expected = makeRowVector(
+      {makeFlatVector<int128_t>({1111, -2222, 0, 99999}, DECIMAL(20, 2))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(20, 2)}), expected);
+}
+
+TEST_F(ParquetReaderWideningTest, decimalShortToLongWithScaleWidening) {
+  auto writeData =
+      makeRowVector({makeFlatVector<int64_t>({1111, -2222, 0}, DECIMAL(5, 2))});
+  // v * 10^(4-2) = v * 100
+  auto expected = makeRowVector(
+      {makeFlatVector<int128_t>({111'100, -222'200, 0}, DECIMAL(20, 4))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(20, 4)}), expected);
+}
+
+// INT -> Decimal(38,0) max precision.
+TEST_F(ParquetReaderWideningTest, smallintToMaxPrecisionDecimalWidening) {
+  auto writeData = makeRowVector({makeFlatVector<int16_t>({0, 1, -1, 32'767})});
+  auto expected = makeRowVector(
+      {makeFlatVector<int128_t>({0, 1, -1, 32'767}, DECIMAL(38, 0))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(38, 0)}), expected);
+}
+
+TEST_F(ParquetReaderWideningTest, intToMaxPrecisionDecimalWidening) {
+  auto writeData =
+      makeRowVector({makeFlatVector<int32_t>({0, 1, -1, 2'147'483'647})});
+  auto expected = makeRowVector(
+      {makeFlatVector<int128_t>({0, 1, -1, 2'147'483'647}, DECIMAL(38, 0))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(38, 0)}), expected);
+}
+
+// Decimal(5,2) -> (10,7) -- short to short with large scale increase.
+TEST_F(ParquetReaderWideningTest, decimalWideningLargeScaleIncrease) {
+  auto writeData =
+      makeRowVector({makeFlatVector<int64_t>({1111, -2222, 0}, DECIMAL(5, 2))});
+  // v * 10^(7-2) = v * 100000
+  auto expected = makeRowVector({makeFlatVector<int64_t>(
+      {111'100'000, -222'200'000, 0}, DECIMAL(10, 7))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(10, 7)}), expected);
+}
+
+// Decimal(5,2) -> (20,17) -- short to long with large scale increase.
+TEST_F(ParquetReaderWideningTest, decimalShortToLongLargeScaleWidening) {
+  auto writeData =
+      makeRowVector({makeFlatVector<int64_t>({1111, -2222, 0}, DECIMAL(5, 2))});
+  // v * 10^(17-2) = v * 10^15
+  auto expected = makeRowVector({makeFlatVector<int128_t>(
+      {static_cast<int128_t>(1111) * 1'000'000'000'000'000LL,
+       static_cast<int128_t>(-2222) * 1'000'000'000'000'000LL,
+       0},
+      DECIMAL(20, 17))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(20, 17)}), expected);
+}
+
+// Decimal(10,2) -> (12,4) -- short to short with precision and scale increase.
+TEST_F(ParquetReaderWideningTest, decimalShortWideningPrecisionAndScale) {
+  auto writeData = makeRowVector(
+      {makeFlatVector<int64_t>({12345, -67890, 0}, DECIMAL(10, 2))});
+  // v * 10^(4-2) = v * 100
+  auto expected = makeRowVector(
+      {makeFlatVector<int64_t>({1'234'500, -6'789'000, 0}, DECIMAL(12, 4))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(12, 4)}), expected);
+}
+
+// Decimal(10,2) -> (20,12) -- short to long with large scale increase.
+TEST_F(
+    ParquetReaderWideningTest,
+    decimalShortToLongLargeScaleWideningHighPrecision) {
+  auto writeData = makeRowVector(
+      {makeFlatVector<int64_t>({12345, -67890, 0}, DECIMAL(10, 2))});
+  // v * 10^(12-2) = v * 10^10
+  auto expected = makeRowVector({makeFlatVector<int128_t>(
+      {static_cast<int128_t>(12345) * 10'000'000'000LL,
+       static_cast<int128_t>(-67890) * 10'000'000'000LL,
+       0},
+      DECIMAL(20, 12))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(20, 12)}), expected);
+}
+
+// Decimal(20,2) -> (22,4) -- long to long with scale increase.
+TEST_F(ParquetReaderWideningTest, decimalLongToLongWithScaleWidening) {
+  auto writeData = makeRowVector(
+      {makeFlatVector<int128_t>({12345, -67890, 0}, DECIMAL(20, 2))});
+  // v * 10^(4-2) = v * 100
+  auto expected = makeRowVector(
+      {makeFlatVector<int128_t>({1'234'500, -6'789'000, 0}, DECIMAL(22, 4))});
+  assertWideningReads(writeData, ROW({"col"}, {DECIMAL(22, 4)}), expected);
+}
+
+TEST_F(ParquetReaderWideningTest, typeWideningRejectionIncompatibleTypes) {
+  // INT32 -> FLOAT is not supported. FLOAT has only ~7 significant digits
+  // vs INT32's 10, which would cause silent precision loss.
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int32_t>({1, 2, 3})}),
+      ROW({"col"}, {REAL()}),
+      "INTEGER");
+
+  // BIGINT -> DOUBLE is not supported.
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int64_t>({1, 2, 3})}),
+      ROW({"col"}, {DOUBLE()}),
+      "BIGINT");
+
+  // BIGINT -> INTEGER/SMALLINT/TINYINT narrowing is not supported.
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int64_t>({1, 2, 3})}),
+      ROW({"col"}, {INTEGER()}),
+      "BIGINT");
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int64_t>({1, 2, 3})}),
+      ROW({"col"}, {SMALLINT()}),
+      "BIGINT");
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int64_t>({1, 2, 3})}),
+      ROW({"col"}, {TINYINT()}),
+      "BIGINT");
+
+  // DOUBLE -> FLOAT/INTEGER is not supported.
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<double>({1.0, 2.0, 3.0})}),
+      ROW({"col"}, {REAL()}),
+      "DOUBLE");
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<double>({1.0, 2.0, 3.0})}),
+      ROW({"col"}, {INTEGER()}),
+      "DOUBLE");
+
+  // FLOAT -> INTEGER/BIGINT is not supported.
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<float>({1.0f, 2.0f, 3.0f})}),
+      ROW({"col"}, {INTEGER()}),
+      "REAL");
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<float>({1.0f, 2.0f})}),
+      ROW({"col"}, {BIGINT()}),
+      "REAL");
+
+  // BIGINT -> FLOAT is not supported (precision loss).
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int64_t>({1, 2})}),
+      ROW({"col"}, {REAL()}),
+      "BIGINT");
+}
+
+TEST_F(ParquetReaderWideningTest, typeWideningRejectionIntDecimalPrecision) {
+  // INT32 -> DECIMAL(8,0). p-s=8 < 10, insufficient for INT32.
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int32_t>({1, 2, 3})}),
+      ROW({"col"}, {DECIMAL(8, 0)}),
+      "INTEGER");
+
+  // TINYINT -> DECIMAL(9,0). Parquet stores TINYINT as INT32, so the
+  // minimum precision is p-s >= 10. p-s=9 < 10.
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int8_t>({1, 2, 3})}),
+      ROW({"col"}, {DECIMAL(9, 0)}),
+      "TINYINT");
+
+  // SMALLINT -> DECIMAL(9,0). Same as TINYINT: stored as INT32, p-s=9 < 10.
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int16_t>({1, 2, 3})}),
+      ROW({"col"}, {DECIMAL(9, 0)}),
+      "SMALLINT");
+
+  // BIGINT -> DECIMAL(18,0). p-s=18 < 20, insufficient for INT64.
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int64_t>({1, 2, 3})}),
+      ROW({"col"}, {DECIMAL(18, 0)}),
+      "BIGINT");
+
+  // Exact boundary: INT32 -> DECIMAL(9,0), p-s=9 < 10.
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int32_t>({1, 2, 3})}),
+      ROW({"col"}, {DECIMAL(9, 0)}),
+      "INTEGER");
+
+  // Exact boundary: BIGINT -> DECIMAL(19,0), p-s=19 < 20.
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int64_t>({1, 2, 3})}),
+      ROW({"col"}, {DECIMAL(19, 0)}),
+      "BIGINT");
+
+  // Rejection with nonzero scale: p-s must still meet the threshold.
+  // TINYINT -> DECIMAL(3,1). p-s=2 < 10.
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int8_t>({1, 2})}),
+      ROW({"col"}, {DECIMAL(3, 1)}),
+      "TINYINT");
+
+  // INT32 -> DECIMAL(10,1). p-s=9 < 10.
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int32_t>({1, 2})}),
+      ROW({"col"}, {DECIMAL(10, 1)}),
+      "INTEGER");
+
+  // BIGINT -> DECIMAL(20,1). p-s=19 < 20.
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int64_t>({1, 2})}),
+      ROW({"col"}, {DECIMAL(20, 1)}),
+      "BIGINT");
+
+  // INT->Decimal with insufficient precision (various small precisions).
+  auto tinyintData = makeRowVector({makeFlatVector<int8_t>({1})});
+  auto smallintData = makeRowVector({makeFlatVector<int16_t>({1})});
+  auto intData = makeRowVector({makeFlatVector<int32_t>({1})});
+  auto bigintData = makeRowVector({makeFlatVector<int64_t>({1})});
+  assertWideningThrows(tinyintData, ROW({"col"}, {DECIMAL(1, 0)}), "TINYINT");
+  assertWideningThrows(tinyintData, ROW({"col"}, {DECIMAL(2, 0)}), "TINYINT");
+  assertWideningThrows(tinyintData, ROW({"col"}, {DECIMAL(3, 0)}), "TINYINT");
+  assertWideningThrows(smallintData, ROW({"col"}, {DECIMAL(3, 0)}), "SMALLINT");
+  assertWideningThrows(smallintData, ROW({"col"}, {DECIMAL(4, 0)}), "SMALLINT");
+  assertWideningThrows(smallintData, ROW({"col"}, {DECIMAL(5, 0)}), "SMALLINT");
+  assertWideningThrows(intData, ROW({"col"}, {DECIMAL(5, 0)}), "INTEGER");
+  assertWideningThrows(bigintData, ROW({"col"}, {DECIMAL(10, 0)}), "BIGINT");
+
+  // INT->Decimal with nonzero scale, insufficient precision.
+  assertWideningThrows(tinyintData, ROW({"col"}, {DECIMAL(4, 1)}), "TINYINT");
+  assertWideningThrows(smallintData, ROW({"col"}, {DECIMAL(6, 1)}), "SMALLINT");
+  assertWideningThrows(smallintData, ROW({"col"}, {DECIMAL(5, 1)}), "SMALLINT");
+}
+
+TEST_F(
+    ParquetReaderWideningTest,
+    typeWideningRejectionDecimalPrecisionDecrease) {
+  // Decimal precision decrease.
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int64_t>({1111}, DECIMAL(10, 2))}),
+      ROW({"col"}, {DECIMAL(5, 2)}),
+      "DECIMAL(10, 2)");
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int128_t>({1111}, DECIMAL(20, 2))}),
+      ROW({"col"}, {DECIMAL(5, 2)}),
+      "DECIMAL(20, 2)");
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int64_t>({1111}, DECIMAL(12, 2))}),
+      ROW({"col"}, {DECIMAL(10, 2)}),
+      "DECIMAL(12, 2)");
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int128_t>({1111}, DECIMAL(20, 2))}),
+      ROW({"col"}, {DECIMAL(10, 2)}),
+      "DECIMAL(20, 2)");
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int128_t>({1111}, DECIMAL(22, 2))}),
+      ROW({"col"}, {DECIMAL(20, 2)}),
+      "DECIMAL(22, 2)");
+
+  // Decimal precision+scale decrease (precInc < 0).
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int64_t>({1111}, DECIMAL(10, 7))}),
+      ROW({"col"}, {DECIMAL(5, 2)}),
+      "DECIMAL(10, 7)");
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int128_t>({1111}, DECIMAL(20, 17))}),
+      ROW({"col"}, {DECIMAL(5, 2)}),
+      "DECIMAL(20, 17)");
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int64_t>({1111}, DECIMAL(12, 4))}),
+      ROW({"col"}, {DECIMAL(10, 2)}),
+      "DECIMAL(12, 4)");
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int128_t>({1111}, DECIMAL(20, 17))}),
+      ROW({"col"}, {DECIMAL(10, 2)}),
+      "DECIMAL(20, 17)");
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int128_t>({1111}, DECIMAL(22, 4))}),
+      ROW({"col"}, {DECIMAL(20, 2)}),
+      "DECIMAL(22, 4)");
+}
+
+TEST_F(ParquetReaderWideningTest, typeWideningRejectionDecimalScaleViolation) {
+  // DECIMAL(7,2) -> DECIMAL(8,5). scaleInc=3 > precInc=1.
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int64_t>({1111, 2222}, DECIMAL(7, 2))}),
+      ROW({"col"}, {DECIMAL(8, 5)}),
+      "DECIMAL(7, 2)");
+
+  // DECIMAL(7,2) -> DECIMAL(6,2). Precision decrease is not allowed.
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int64_t>({1111, 2222}, DECIMAL(7, 2))}),
+      ROW({"col"}, {DECIMAL(6, 2)}),
+      "DECIMAL(7, 2)");
+
+  // DECIMAL(7,4) -> DECIMAL(8,2). Scale narrowing (scaleInc < 0) is rejected.
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int64_t>({1111, 2222}, DECIMAL(7, 4))}),
+      ROW({"col"}, {DECIMAL(8, 2)}),
+      "DECIMAL(7, 4)");
+
+  // Scale decrease with precision increase (scaleInc < 0).
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int64_t>({1111}, DECIMAL(10, 6))}),
+      ROW({"col"}, {DECIMAL(12, 4)}),
+      "DECIMAL(10, 6)");
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int128_t>({1111}, DECIMAL(20, 7))}),
+      ROW({"col"}, {DECIMAL(22, 5)}),
+      "DECIMAL(20, 7)");
+
+  // Precision decrease with scale increase.
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int64_t>({1111}, DECIMAL(12, 4))}),
+      ROW({"col"}, {DECIMAL(10, 6)}),
+      "DECIMAL(12, 4)");
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int128_t>({1111}, DECIMAL(22, 5))}),
+      ROW({"col"}, {DECIMAL(20, 7)}),
+      "DECIMAL(22, 5)");
+
+  // scaleInc > precInc (not enough precision for the scale increase).
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int64_t>({1111}, DECIMAL(5, 2))}),
+      ROW({"col"}, {DECIMAL(6, 4)}),
+      "DECIMAL(5, 2)");
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int64_t>({1111}, DECIMAL(10, 4))}),
+      ROW({"col"}, {DECIMAL(12, 7)}),
+      "DECIMAL(10, 4)");
+  assertWideningThrows(
+      makeRowVector({makeFlatVector<int128_t>({1111}, DECIMAL(20, 5))}),
+      ROW({"col"}, {DECIMAL(22, 8)}),
+      "DECIMAL(20, 5)");
+}
+
+// Verify allowInt32Narrowing flag on ReaderOptions.
+TEST_F(ParquetReaderWideningTest, allowInt32Narrowing) {
+  // Write INT32 data with values that exercise truncation edge cases.
+  auto data = makeRowVector(
+      {"c1"},
+      {makeFlatVector<int32_t>(
+          {0,
+           127,
+           128,
+           255,
+           256,
+           32767,
+           32768,
+           65535,
+           -1,
+           -128,
+           -129,
+           std::numeric_limits<int32_t>::min(),
+           std::numeric_limits<int32_t>::max()})});
+  auto* sink = write(data);
+
+  // Default: flag is false.
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  ASSERT_FALSE(readerOptions.allowInt32Narrowing());
+
+  // INT32->TINYINT narrowing rejected by default.
+  readerOptions.setFileSchema(ROW({"c1"}, {TINYINT()}));
+  VELOX_ASSERT_THROW(
+      createReaderInMemory(*sink, readerOptions),
+      "is not allowed for requested type");
+
+  // INT32->SMALLINT narrowing rejected by default.
+  readerOptions.setFileSchema(ROW({"c1"}, {SMALLINT()}));
+  VELOX_ASSERT_THROW(
+      createReaderInMemory(*sink, readerOptions),
+      "is not allowed for requested type");
+
+  // Annotated type-matching always works without the flag.
+  // INT_8 -> TINYINT: write as TINYINT (produces INT_8 annotation), read back.
+  {
+    auto readSchema = ROW({"c1"}, {TINYINT()});
+    auto tinyData =
+        makeRowVector({"c1"}, {makeFlatVector<int8_t>({-128, -1, 0, 1, 127})});
+    auto* tinySink = write(tinyData);
+    readerOptions.setFileSchema(readSchema);
+    auto reader = createReaderInMemory(*tinySink, readerOptions);
+    auto rowReaderOpts = getReaderOpts(readSchema);
+    rowReaderOpts.setScanSpec(makeScanSpec(readSchema));
+    auto rowReader = reader->createRowReader(rowReaderOpts);
+    assertReadWithReaderAndExpected(
+        readSchema, *rowReader, tinyData, *leafPool_);
+  }
+
+  // INT_16 -> SMALLINT: write as SMALLINT (produces INT_16 annotation), read
+  // back.
+  {
+    auto readSchema = ROW({"c1"}, {SMALLINT()});
+    auto smallData = makeRowVector(
+        {"c1"}, {makeFlatVector<int16_t>({-32768, -1, 0, 1, 32767})});
+    auto* smallSink = write(smallData);
+    readerOptions.setFileSchema(readSchema);
+    auto reader = createReaderInMemory(*smallSink, readerOptions);
+    auto rowReaderOpts = getReaderOpts(readSchema);
+    rowReaderOpts.setScanSpec(makeScanSpec(readSchema));
+    auto rowReader = reader->createRowReader(rowReaderOpts);
+    assertReadWithReaderAndExpected(
+        readSchema, *rowReader, smallData, *leafPool_);
+  }
+
+  // With flag enabled, narrowing is allowed with silent truncation.
+  readerOptions.setAllowInt32Narrowing(true);
+
+  // INT32->TINYINT: values are truncated via static_cast<int8_t>.
+  {
+    auto readSchema = ROW({"c1"}, {TINYINT()});
+    readerOptions.setFileSchema(readSchema);
+    auto reader = createReaderInMemory(*sink, readerOptions);
+
+    auto rowReaderOpts = getReaderOpts(readSchema);
+    rowReaderOpts.setScanSpec(makeScanSpec(readSchema));
+    auto rowReader = reader->createRowReader(rowReaderOpts);
+
+    auto expected = makeRowVector(
+        {"c1"},
+        {makeFlatVector<int8_t>(
+            {static_cast<int8_t>(0),
+             static_cast<int8_t>(127),
+             static_cast<int8_t>(128), // -128
+             static_cast<int8_t>(255), // -1
+             static_cast<int8_t>(256), // 0
+             static_cast<int8_t>(32767), // -1
+             static_cast<int8_t>(32768), // 0
+             static_cast<int8_t>(65535), // -1
+             static_cast<int8_t>(-1), // -1
+             static_cast<int8_t>(-128), // -128
+             static_cast<int8_t>(-129), // 127
+             static_cast<int8_t>(std::numeric_limits<int32_t>::min()),
+             static_cast<int8_t>(std::numeric_limits<int32_t>::max())})});
+    assertReadWithReaderAndExpected(
+        readSchema, *rowReader, expected, *leafPool_);
+  }
+
+  // INT32->SMALLINT: values are truncated via static_cast<int16_t>.
+  {
+    auto readSchema = ROW({"c1"}, {SMALLINT()});
+    readerOptions.setFileSchema(readSchema);
+    auto reader = createReaderInMemory(*sink, readerOptions);
+
+    auto rowReaderOpts = getReaderOpts(readSchema);
+    rowReaderOpts.setScanSpec(makeScanSpec(readSchema));
+    auto rowReader = reader->createRowReader(rowReaderOpts);
+
+    auto expected = makeRowVector(
+        {"c1"},
+        {makeFlatVector<int16_t>(
+            {static_cast<int16_t>(0),
+             static_cast<int16_t>(127),
+             static_cast<int16_t>(128),
+             static_cast<int16_t>(255),
+             static_cast<int16_t>(256),
+             static_cast<int16_t>(32767),
+             static_cast<int16_t>(32768), // -32768
+             static_cast<int16_t>(65535), // -1
+             static_cast<int16_t>(-1), // -1
+             static_cast<int16_t>(-128), // -128
+             static_cast<int16_t>(-129), // -129
+             static_cast<int16_t>(std::numeric_limits<int32_t>::min()),
+             static_cast<int16_t>(std::numeric_limits<int32_t>::max())})});
+    assertReadWithReaderAndExpected(
+        readSchema, *rowReader, expected, *leafPool_);
+  }
+}
+
+// INT -> Integer widening + filter.
+TEST_F(ParquetReaderWideningTest, tinyintToSmallintWideningWithFilter) {
+  auto writeData =
+      makeRowVector({"col"}, {makeFlatVector<int8_t>({-10, 0, 10, 50, 127})});
+  auto expected =
+      makeRowVector({"col"}, {makeFlatVector<int16_t>({0, 10, 50, 127})});
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {SMALLINT()}),
+      exec::greaterThanOrEqual(0),
+      expected);
+}
+
+TEST_F(ParquetReaderWideningTest, tinyintToIntegerWideningWithFilter) {
+  auto writeData =
+      makeRowVector({"col"}, {makeFlatVector<int8_t>({-10, 0, 10, 50, 127})});
+  auto expected =
+      makeRowVector({"col"}, {makeFlatVector<int32_t>({0, 10, 50, 127})});
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {INTEGER()}),
+      exec::greaterThanOrEqual(0),
+      expected);
+}
+
+TEST_F(ParquetReaderWideningTest, shortToIntegerWideningWithFilter) {
+  auto writeData = makeRowVector(
+      {"col"}, {makeFlatVector<int16_t>({-100, 0, 50, 100, 32'767})});
+  auto expected =
+      makeRowVector({"col"}, {makeFlatVector<int32_t>({50, 100, 32'767})});
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {INTEGER()}),
+      exec::greaterThanOrEqual(50),
+      expected);
+}
+
+TEST_F(ParquetReaderWideningTest, intToBigintWideningWithFilter) {
+  auto writeData = makeRowVector(
+      {"col"}, {makeFlatVector<int32_t>({-100, 0, 50, 100, 2'000'000})});
+  auto expected =
+      makeRowVector({"col"}, {makeFlatVector<int64_t>({50, 100, 2'000'000})});
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {BIGINT()}),
+      exec::greaterThanOrEqual(50),
+      expected);
+}
+
+// INT -> DOUBLE widening + filter.
+TEST_F(ParquetReaderWideningTest, intToDoubleWideningWithFilter) {
+  auto writeData =
+      makeRowVector({"col"}, {makeFlatVector<int32_t>({-100, 0, 50, 100})});
+  auto expected =
+      makeRowVector({"col"}, {makeFlatVector<double>({50.0, 100.0})});
+  // BigintRange filter.
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {DOUBLE()}),
+      exec::greaterThanOrEqual(50),
+      expected);
+}
+
+TEST_F(ParquetReaderWideningTest, tinyintToDoubleWideningWithFilter) {
+  auto writeData =
+      makeRowVector({"col"}, {makeFlatVector<int8_t>({-10, 0, 10, 50})});
+  auto expected =
+      makeRowVector({"col"}, {makeFlatVector<double>({0.0, 10.0, 50.0})});
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {DOUBLE()}),
+      exec::greaterThanOrEqual(0),
+      expected);
+}
+
+// DoubleRange filter not yet supported for widened columns. See #16895.
+TEST_F(
+    ParquetReaderWideningTest,
+    DISABLED_intToDoubleWideningWithDoubleRangeFilter) {
+  auto writeData =
+      makeRowVector({"col"}, {makeFlatVector<int32_t>({-100, 0, 50, 100})});
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {DOUBLE()}),
+      exec::greaterThanOrEqualDouble(50.0),
+      makeRowVector({"col"}, {makeFlatVector<double>({50.0, 100.0})}));
+}
+
+// INT -> Decimal widening + filter.
+TEST_F(ParquetReaderWideningTest, intToDecimalWideningWithFilter) {
+  auto writeData =
+      makeRowVector({"col"}, {makeFlatVector<int32_t>({-100, 0, 50, 100})});
+  // Scale 0.
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {DECIMAL(10, 0)}),
+      exec::greaterThanOrEqual(50),
+      makeRowVector(
+          {"col"}, {makeFlatVector<int64_t>({50, 100}, DECIMAL(10, 0))}));
+}
+
+// Scale > 0 not yet supported for filter pushdown with widening. See #16895.
+TEST_F(
+    ParquetReaderWideningTest,
+    DISABLED_intToDecimalWithScaleWideningWithFilter) {
+  auto writeData =
+      makeRowVector({"col"}, {makeFlatVector<int32_t>({-100, 0, 50, 100})});
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {DECIMAL(12, 2)}),
+      exec::greaterThanOrEqual(5'000),
+      makeRowVector(
+          {"col"}, {makeFlatVector<int64_t>({5'000, 10'000}, DECIMAL(12, 2))}));
+}
+
+// HugeintRange filter not yet supported for widened columns. See #16895.
+TEST_F(ParquetReaderWideningTest, DISABLED_bigintToDecimalWideningWithFilter) {
+  auto writeData =
+      makeRowVector({"col"}, {makeFlatVector<int64_t>({-100, 0, 50, 100})});
+  // BIGINT -> Decimal(25, 5).
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {DECIMAL(25, 5)}),
+      exec::greaterThanOrEqualHugeint(int128_t(50) * 100'000),
+      makeRowVector(
+          {"col"},
+          {makeFlatVector<int128_t>(
+              {int128_t(50) * 100'000, int128_t(100) * 100'000},
+              DECIMAL(25, 5))}));
+  // BIGINT -> Decimal(38, 0).
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {DECIMAL(38, 0)}),
+      exec::greaterThanOrEqualHugeint(int128_t(50)),
+      makeRowVector(
+          {"col"}, {makeFlatVector<int128_t>({50, 100}, DECIMAL(38, 0))}));
+  // BIGINT -> Decimal(21, 1).
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {DECIMAL(21, 1)}),
+      exec::greaterThanOrEqualHugeint(int128_t(50) * 10),
+      makeRowVector(
+          {"col"},
+          {makeFlatVector<int128_t>(
+              {int128_t(50) * 10, int128_t(100) * 10}, DECIMAL(21, 1))}));
+}
+
+// Decimal -> Decimal (short->short) + filter.
+TEST_F(ParquetReaderWideningTest, decimalShortToShortWideningWithFilter) {
+  auto writeData = makeRowVector(
+      {"col"},
+      {makeFlatVector<int64_t>({-1'000, 0, 5'000, 10'000}, DECIMAL(7, 2))});
+  // Scale unchanged: DECIMAL(7,2) -> DECIMAL(10,2).
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {DECIMAL(10, 2)}),
+      exec::greaterThanOrEqual(5'000),
+      makeRowVector(
+          {"col"}, {makeFlatVector<int64_t>({5'000, 10'000}, DECIMAL(10, 2))}));
+}
+
+// Scale changed: DECIMAL(7,2) -> DECIMAL(10,4). See #16895.
+TEST_F(
+    ParquetReaderWideningTest,
+    DISABLED_decimalScaleChangeWideningWithFilter) {
+  auto writeData = makeRowVector(
+      {"col"},
+      {makeFlatVector<int64_t>({-1'000, 0, 5'000, 10'000}, DECIMAL(7, 2))});
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {DECIMAL(10, 4)}),
+      exec::greaterThanOrEqual(500'000),
+      makeRowVector(
+          {"col"},
+          {makeFlatVector<int64_t>({500'000, 1'000'000}, DECIMAL(10, 4))}));
+}
+
+// Cases have different failure modes: same-scale fails on HugeintRange crash,
+// scale-change fails on unscaled value mismatch. See #16895.
+TEST_F(
+    ParquetReaderWideningTest,
+    DISABLED_decimalShortToLongWideningWithFilter) {
+  auto writeData = makeRowVector(
+      {"col"},
+      {makeFlatVector<int64_t>({-1'000, 0, 5'000, 10'000}, DECIMAL(5, 2))});
+  // Scale unchanged: DECIMAL(5,2) -> DECIMAL(20,2).
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {DECIMAL(20, 2)}),
+      exec::greaterThanOrEqualHugeint(int128_t(5'000)),
+      makeRowVector(
+          {"col"},
+          {makeFlatVector<int128_t>({5'000, 10'000}, DECIMAL(20, 2))}));
+  // Scale changed: DECIMAL(5,2) -> DECIMAL(20,4).
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {DECIMAL(20, 4)}),
+      exec::greaterThanOrEqualHugeint(int128_t(500'000)),
+      makeRowVector(
+          {"col"},
+          {makeFlatVector<int128_t>({500'000, 1'000'000}, DECIMAL(20, 4))}));
+  // Large scale increase: DECIMAL(5,2) -> DECIMAL(10,7).
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {DECIMAL(10, 7)}),
+      exec::greaterThanOrEqual(500'000'000),
+      makeRowVector(
+          {"col"},
+          {makeFlatVector<int64_t>(
+              {500'000'000, 1'000'000'000}, DECIMAL(10, 7))}));
+  // Precision and scale increase: DECIMAL(5,2) -> DECIMAL(12,4).
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {DECIMAL(12, 4)}),
+      exec::greaterThanOrEqual(500'000),
+      makeRowVector(
+          {"col"},
+          {makeFlatVector<int64_t>({500'000, 1'000'000}, DECIMAL(12, 4))}));
+}
+
+// HugeintRange filter with scale change not yet supported. See #16895.
+TEST_F(
+    ParquetReaderWideningTest,
+    DISABLED_decimalLongToLongWideningWithFilter) {
+  auto writeData = makeRowVector(
+      {"col"},
+      {makeFlatVector<int128_t>({-1'000, 0, 5'000, 10'000}, DECIMAL(20, 2))});
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {DECIMAL(22, 4)}),
+      exec::greaterThanOrEqualHugeint(int128_t(500'000)),
+      makeRowVector(
+          {"col"},
+          {makeFlatVector<int128_t>({500'000, 1'000'000}, DECIMAL(22, 4))}));
+}
+
+// INT32 narrowing + filter.
+TEST_F(ParquetReaderWideningTest, intNarrowingFilterBehavior) {
+  // INT32 -> TINYINT with filter x in [0, 127] (TINYINT range).
+  // INT32 value 200 fails filter (200 > 127), so it is filtered out.
+  auto writeData =
+      makeRowVector({"col"}, {makeFlatVector<int32_t>({-10, 0, 50, 127, 200})});
+  auto expected =
+      makeRowVector({"col"}, {makeFlatVector<int8_t>({0, 50, 127})});
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {TINYINT()}),
+      std::make_unique<common::BigintRange>(0, 127, /*nullAllowed=*/false),
+      expected,
+      /*allowInt32Narrowing=*/true);
+}
+
+// Null filter tests.
+TEST_F(ParquetReaderWideningTest, intToBigintWideningNullFilter) {
+  auto writeData = makeRowVector(
+      {"col"},
+      {makeNullableFlatVector<int32_t>({0, std::nullopt, 50, std::nullopt})});
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {BIGINT()}),
+      exec::isNull(),
+      makeRowVector(
+          {"col"},
+          {makeNullableFlatVector<int64_t>({std::nullopt, std::nullopt})}));
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {BIGINT()}),
+      exec::isNotNull(),
+      makeRowVector({"col"}, {makeFlatVector<int64_t>({0, 50})}));
+}
+
+TEST_F(ParquetReaderWideningTest, intToDoubleWideningNullFilter) {
+  auto writeData = makeRowVector(
+      {"col"},
+      {makeNullableFlatVector<int32_t>({0, std::nullopt, 50, std::nullopt})});
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {DOUBLE()}),
+      exec::isNull(),
+      makeRowVector(
+          {"col"},
+          {makeNullableFlatVector<double>({std::nullopt, std::nullopt})}));
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {DOUBLE()}),
+      exec::isNotNull(),
+      makeRowVector({"col"}, {makeFlatVector<double>({0.0, 50.0})}));
+}
+
+TEST_F(ParquetReaderWideningTest, intToDecimalScale0NullFilter) {
+  auto writeData = makeRowVector(
+      {"col"},
+      {makeNullableFlatVector<int32_t>({0, std::nullopt, 50, std::nullopt})});
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {DECIMAL(10, 0)}),
+      exec::isNull(),
+      makeRowVector(
+          {"col"},
+          {makeNullableFlatVector<int64_t>(
+              {std::nullopt, std::nullopt}, DECIMAL(10, 0))}));
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {DECIMAL(10, 0)}),
+      exec::isNotNull(),
+      makeRowVector(
+          {"col"}, {makeFlatVector<int64_t>({0, 50}, DECIMAL(10, 0))}));
+}
+
+TEST_F(ParquetReaderWideningTest, decimalPrecisionOnlyNullFilter) {
+  auto writeData = makeRowVector(
+      {"col"},
+      {makeNullableFlatVector<int64_t>(
+          {1'000, std::nullopt, 5'000, std::nullopt}, DECIMAL(7, 2))});
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {DECIMAL(10, 2)}),
+      exec::isNull(),
+      makeRowVector(
+          {"col"},
+          {makeNullableFlatVector<int64_t>(
+              {std::nullopt, std::nullopt}, DECIMAL(10, 2))}));
+  assertWideningWithFilter(
+      writeData,
+      ROW({"col"}, {DECIMAL(10, 2)}),
+      exec::isNotNull(),
+      makeRowVector(
+          {"col"}, {makeFlatVector<int64_t>({1'000, 5'000}, DECIMAL(10, 2))}));
+}
diff --git a/velox/dwio/parquet/tests/reader/ParquetTableScanTest.cpp b/velox/dwio/parquet/tests/reader/ParquetTableScanTest.cpp
index 96c4a3a4051..786a1d2ddfc 100644
--- a/velox/dwio/parquet/tests/reader/ParquetTableScanTest.cpp
+++ b/velox/dwio/parquet/tests/reader/ParquetTableScanTest.cpp
@@ -17,6 +17,8 @@
 #include <folly/init/Init.h>
 
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/io/IoStatistics.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/dwio/common/tests/utils/DataFiles.h" // @manual
 #include "velox/dwio/parquet/RegisterParquetReader.h" // @manual
 #include "velox/dwio/parquet/reader/PageReader.h" // @manual
@@ -24,7 +26,6 @@
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h" // @manual
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/type/tests/SubfieldFiltersBuilder.h"
 #include "velox/type/tz/TimeZoneMap.h"
 
@@ -37,6 +38,7 @@ using namespace facebook::velox::connector::hive;
 using namespace facebook::velox::exec::test;
 using namespace facebook::velox::parquet;
 using namespace facebook::velox::test;
+using namespace facebook::velox::common::testutil;
 
 class ParquetTableScanTest : public HiveConnectorTestBase {
  protected:
@@ -48,26 +50,29 @@ class ParquetTableScanTest : public HiveConnectorTestBase {
   }
 
   void assertSelect(
+      std::vector<std::shared_ptr<connector::ConnectorSplit>> splits,
       std::vector<std::string>&& outputColumnNames,
       const std::string& sql) {
     auto rowType = getRowType(std::move(outputColumnNames));
 
     auto plan = PlanBuilder().tableScan(rowType).planNode();
 
-    assertQuery(plan, splits_, sql);
+    assertQuery(plan, splits, sql);
   }
 
   void assertSelectWithDataColumns(
+      std::vector<std::shared_ptr<connector::ConnectorSplit>> splits,
       std::vector<std::string>&& outputColumnNames,
       const RowTypePtr& dataColumns,
       const std::string& sql) {
     auto rowType = getRowType(std::move(outputColumnNames));
     auto plan =
         PlanBuilder().tableScan(rowType, {}, "", dataColumns).planNode();
-    assertQuery(plan, splits_, sql);
+    assertQuery(plan, splits, sql);
   }
 
   void assertSelectWithAssignments(
+      std::vector<std::shared_ptr<connector::ConnectorSplit>> splits,
       std::vector<std::string>&& outputColumnNames,
       const connector::ColumnHandleMap& assignments,
       const std::string& sql) {
@@ -75,10 +80,11 @@ class ParquetTableScanTest : public HiveConnectorTestBase {
     auto plan = PlanBuilder()
                     .tableScan(rowType, {}, "", nullptr, assignments)
                     .planNode();
-    assertQuery(plan, splits_, sql);
+    assertQuery(plan, splits, sql);
   }
 
   void assertSelectWithFilter(
+      std::vector<std::shared_ptr<connector::ConnectorSplit>> splits,
       std::vector<std::string>&& outputColumnNames,
       const std::vector<std::string>& subfieldFilters,
       const std::string& remainingFilter,
@@ -99,12 +105,13 @@ class ParquetTableScanTest : public HiveConnectorTestBase {
         .connectorSessionProperty(
             kHiveConnectorId,
             HiveConfig::kReadTimestampUnitSession,
-            std::to_string(static_cast<int>(timestampPrecision_)))
-        .splits(splits_)
+            std::to_string(static_cast<int>(readTimestampPrecision_)))
+        .splits(splits)
         .assertResults(sql);
   }
 
   void assertSelectWithAgg(
+      std::vector<std::shared_ptr<connector::ConnectorSplit>> splits,
       std::vector<std::string>&& outputColumnNames,
       const std::vector<std::string>& aggregates,
       const std::vector<std::string>& groupingKeys,
@@ -116,10 +123,11 @@ class ParquetTableScanTest : public HiveConnectorTestBase {
                     .singleAggregation(groupingKeys, aggregates)
                     .planNode();
 
-    assertQuery(plan, splits_, sql);
+    assertQuery(plan, splits, sql);
   }
 
   void assertSelectWithFilterAndAgg(
+      std::vector<std::shared_ptr<connector::ConnectorSplit>> splits,
       std::vector<std::string>&& outputColumnNames,
       const std::vector<std::string>& filters,
       const std::vector<std::string>& aggregates,
@@ -132,18 +140,19 @@ class ParquetTableScanTest : public HiveConnectorTestBase {
                     .singleAggregation(groupingKeys, aggregates)
                     .planNode();
 
-    assertQuery(plan, splits_, sql);
+    assertQuery(plan, splits, sql);
   }
 
   void assertSelectWithTimezone(
+      std::vector<std::shared_ptr<connector::ConnectorSplit>> connectorSplits,
       std::vector<std::string>&& outputColumnNames,
       const std::string& sql,
       const std::string& sessionTimezone) {
     auto rowType = getRowType(std::move(outputColumnNames));
     auto plan = PlanBuilder().tableScan(rowType).planNode();
     std::vector<exec::Split> splits;
-    splits.reserve(splits_.size());
-    for (const auto& connectorSplit : splits_) {
+    splits.reserve(connectorSplits.size());
+    for (const auto& connectorSplit : connectorSplits) {
       splits.emplace_back(folly::copy(connectorSplit), -1);
     }
 
@@ -153,24 +162,16 @@ class ParquetTableScanTest : public HiveConnectorTestBase {
         .assertResults(sql);
   }
 
-  void loadData(
-      const std::string& filePath,
-      RowTypePtr rowType,
-      RowVectorPtr data,
-      const std::optional<
-          std::unordered_map<std::string, std::optional<std::string>>>&
-          partitionKeys = std::nullopt,
-      const std::optional<std::unordered_map<std::string, std::string>>&
-          infoColumns = std::nullopt) {
-    splits_ = {makeSplit(filePath, partitionKeys, infoColumns)};
+  void loadData(RowTypePtr rowType, RowVectorPtr data) {
     rowType_ = rowType;
     createDuckDbTable({data});
   }
 
   void loadDataWithRowType(const std::string& filePath, RowVectorPtr data) {
-    splits_ = {makeSplit(filePath)};
     auto pool = facebook::velox::memory::memoryManager()->addLeafPool();
     dwio::common::ReaderOptions readerOpts{pool.get()};
+    readerOpts.setDataIoStats(dataIoStats_);
+    readerOpts.setMetadataIoStats(metadataIoStats_);
     auto reader = std::make_unique<ParquetReader>(
         std::make_unique<facebook::velox::dwio::common::BufferedInput>(
             std::make_shared<LocalReadFile>(filePath), readerOpts.memoryPool()),
@@ -213,10 +214,6 @@ class ParquetTableScanTest : public HiveConnectorTestBase {
         rootPool_->addAggregateChild("ParquetTableScanTest.Writer");
     options.memoryPool = childPool.get();
 
-    if (options.parquetWriteTimestampUnit.has_value()) {
-      timestampPrecision_ = options.parquetWriteTimestampUnit.value();
-    }
-
     auto writer = std::make_unique<Writer>(
         std::move(sink), options, asRowType(data[0]->type()));
 
@@ -226,77 +223,102 @@ class ParquetTableScanTest : public HiveConnectorTestBase {
     writer->close();
   }
 
-  void testTimestampRead(const WriterOptions& options) {
-    auto stringToTimestamp = [](std::string_view view) {
-      return util::fromTimestampString(
-                 view.data(),
-                 view.size(),
-                 util::TimestampParseMode::kPrestoCast)
-          .thenOrThrow(folly::identity, [&](const Status& status) {
-            VELOX_USER_FAIL("{}", status.message());
-          });
-    };
-    std::vector<std::string_view> views = {
-        "2015-06-01 19:34:56.007",
-        "2015-06-02 19:34:56.12306",
-        "2001-02-03 03:34:06.056",
-        "1998-03-01 08:01:06.996669",
-        "2022-12-23 03:56:01",
-        "1980-01-24 00:23:07",
-        "1999-12-08 13:39:26.123456",
-        "2023-04-21 09:09:34.5",
-        "2000-09-12 22:36:29",
-        "2007-12-12 04:27:56.999",
-    };
-    std::vector<Timestamp> values;
-    values.reserve(views.size());
-    for (auto view : views) {
-      values.emplace_back(stringToTimestamp(view));
-    }
-
+  void testTimestampRead(
+      const WriterOptions& options,
+      TimestampPrecision readTimestampPrecision) {
+    VELOX_CHECK(options.parquetWriteTimestampUnit.has_value());
+    const auto [values, expectedValues] = timestampValues(
+        options.parquetWriteTimestampUnit.value(), readTimestampPrecision);
     auto vector = makeRowVector(
         {"t"},
         {
             makeFlatVector<Timestamp>(values),
         });
-    auto schema = asRowType(vector->type());
     auto file = TempFilePath::create();
     writeToParquetFile(file->getPath(), {vector}, options);
-    loadData(file->getPath(), schema, vector);
-
-    assertSelectWithFilter({"t"}, {}, "", "SELECT t from tmp");
+    loadData(
+        asRowType(vector->type()),
+        makeRowVector(
+            {"t"},
+            {
+                makeFlatVector<Timestamp>(expectedValues),
+            }));
+
+    readTimestampPrecision_ = readTimestampPrecision;
+    auto guard = folly::makeGuard(
+        [&] { readTimestampPrecision_ = kDefaultReadTimestampPrecision; });
+    assertSelectWithFilter(
+        {makeSplit(file->getPath())}, {"t"}, {}, "", "SELECT t from tmp");
     assertSelectWithFilter(
+        {makeSplit(file->getPath())},
         {"t"},
         {},
         "t < TIMESTAMP '2000-09-12 22:36:29'",
         "SELECT t from tmp where t < TIMESTAMP '2000-09-12 22:36:29'");
     assertSelectWithFilter(
+        {makeSplit(file->getPath())},
         {"t"},
         {},
         "t <= TIMESTAMP '2000-09-12 22:36:29'",
         "SELECT t from tmp where t <= TIMESTAMP '2000-09-12 22:36:29'");
     assertSelectWithFilter(
+        {makeSplit(file->getPath())},
         {"t"},
         {},
         "t > TIMESTAMP '1980-01-24 00:23:07'",
         "SELECT t from tmp where t > TIMESTAMP '1980-01-24 00:23:07'");
     assertSelectWithFilter(
+        {makeSplit(file->getPath())},
         {"t"},
         {},
         "t >= TIMESTAMP '1980-01-24 00:23:07'",
         "SELECT t from tmp where t >= TIMESTAMP '1980-01-24 00:23:07'");
     assertSelectWithFilter(
+        {makeSplit(file->getPath())},
         {"t"},
         {},
         "t == TIMESTAMP '2022-12-23 03:56:01'",
         "SELECT t from tmp where t == TIMESTAMP '2022-12-23 03:56:01'");
     assertSelectWithFilter(
+        {makeSplit(file->getPath())},
         {"t"},
         {},
         "not(eq(t, TIMESTAMP '2000-09-12 22:36:29'))",
         "SELECT t from tmp where t != TIMESTAMP '2000-09-12 22:36:29'");
   }
 
+  void testTimestampUtcRead(
+      const WriterOptions& options,
+      TimestampPrecision readTimestampPrecision) {
+    VELOX_CHECK(options.parquetWriteTimestampUnit.has_value());
+    const auto [values, expectedValues] = timestampValues(
+        options.parquetWriteTimestampUnit.value(), readTimestampPrecision);
+    auto vector = makeRowVector(
+        {"t"},
+        {
+            makeFlatVector<Timestamp>(values, TIMESTAMP_UTC()),
+        });
+    auto file = TempFilePath::create();
+    writeToParquetFile(file->getPath(), {vector}, options);
+
+    loadData(
+        ROW({"t"}, {TIMESTAMP_UTC()}),
+        makeRowVector(
+            {"t"},
+            {
+                // Expect values are used for creating duckdb table, so keep
+                // using TIMESTAMP here.
+                makeFlatVector<Timestamp>(expectedValues),
+            }));
+
+    readTimestampPrecision_ = readTimestampPrecision;
+    auto guard = folly::makeGuard(
+        [&] { readTimestampPrecision_ = kDefaultReadTimestampPrecision; });
+
+    assertSelectWithFilter(
+        {makeSplit(file->getPath())}, {"t"}, {}, "", "SELECT t from tmp");
+  }
+
  private:
   RowTypePtr getRowType(std::vector<std::string>&& outputColumnNames) const {
     std::vector<TypePtr> types;
@@ -307,14 +329,70 @@ class ParquetTableScanTest : public HiveConnectorTestBase {
     return ROW(std::move(outputColumnNames), std::move(types));
   }
 
+  std::pair<std::vector<Timestamp>, std::vector<Timestamp>> timestampValues(
+      TimestampPrecision writeTimestampPrecision,
+      TimestampPrecision readTimestampPrecision) {
+    auto stringToTimestamp = [](std::string_view view) {
+      return util::fromTimestampString(
+                 view.data(),
+                 view.size(),
+                 util::TimestampParseMode::kPrestoCast)
+          .value();
+    };
+    std::vector<std::string_view> views = {
+        "2015-06-01 19:34:56.007",
+        "2015-06-02 19:34:56.12306",
+        "2001-02-03 03:34:06.056",
+        "1998-03-01 08:01:06.996669",
+        "2022-12-23 03:56:01",
+        "1980-01-24 00:23:07",
+        "1999-12-08 13:39:26.123456",
+        "2023-04-21 09:09:34.5",
+        "2000-09-12 22:36:29",
+        "2007-12-12 04:27:56.999",
+    };
+
+    std::vector<Timestamp> values;
+    std::vector<Timestamp> expectedValues;
+    values.reserve(views.size());
+    for (auto view : views) {
+      auto ts = stringToTimestamp(view);
+      values.emplace_back(ts);
+      if (readTimestampPrecision == TimestampPrecision::kMilliseconds) {
+        expectedValues.emplace_back(Timestamp::fromMillis(ts.toMillis()));
+        continue;
+      }
+      if (readTimestampPrecision == TimestampPrecision::kMicroseconds) {
+        if (writeTimestampPrecision == TimestampPrecision::kMilliseconds) {
+          expectedValues.emplace_back(
+              Timestamp::fromMicros(ts.toMillis() * 1'000));
+          continue;
+        }
+        if (writeTimestampPrecision == TimestampPrecision::kMicroseconds) {
+          expectedValues.emplace_back(Timestamp::fromMicros(ts.toMicros()));
+          continue;
+        }
+      }
+      VELOX_NYI(
+          "Not implemented, read precision: {}, write precision: {}",
+          static_cast<int>(readTimestampPrecision),
+          static_cast<int>(writeTimestampPrecision));
+    }
+    return {values, expectedValues};
+  }
+
   RowTypePtr rowType_;
-  std::vector<std::shared_ptr<connector::ConnectorSplit>> splits_;
-  TimestampPrecision timestampPrecision_ = TimestampPrecision::kMicroseconds;
+  const TimestampPrecision kDefaultReadTimestampPrecision =
+      TimestampPrecision::kMicroseconds;
+  TimestampPrecision readTimestampPrecision_ = kDefaultReadTimestampPrecision;
+  std::shared_ptr<io::IoStatistics> dataIoStats_ =
+      std::make_shared<io::IoStatistics>();
+  std::shared_ptr<io::IoStatistics> metadataIoStats_ =
+      std::make_shared<io::IoStatistics>();
 };
 
 TEST_F(ParquetTableScanTest, basic) {
   loadData(
-      getExampleFilePath("sample.parquet"),
       ROW({"a", "b"}, {BIGINT(), DOUBLE()}),
       makeRowVector(
           {"a", "b"},
@@ -324,64 +402,111 @@ TEST_F(ParquetTableScanTest, basic) {
           }));
 
   // Plain select.
-  assertSelect({"a"}, "SELECT a FROM tmp");
-  assertSelect({"b"}, "SELECT b FROM tmp");
-  assertSelect({"a", "b"}, "SELECT a, b FROM tmp");
-  assertSelect({"b", "a"}, "SELECT b, a FROM tmp");
+  const auto filePath = getExampleFilePath("sample.parquet");
+  assertSelect({makeSplit(filePath)}, {"a"}, "SELECT a FROM tmp");
+  assertSelect({makeSplit(filePath)}, {"b"}, "SELECT b FROM tmp");
+  assertSelect({makeSplit(filePath)}, {"a", "b"}, "SELECT a, b FROM tmp");
+  assertSelect({makeSplit(filePath)}, {"b", "a"}, "SELECT b, a FROM tmp");
 
   // With filters.
-  assertSelectWithFilter({"a"}, {"a < 3"}, "", "SELECT a FROM tmp WHERE a < 3");
   assertSelectWithFilter(
-      {"a", "b"}, {"a < 3"}, "", "SELECT a, b FROM tmp WHERE a < 3");
+      {makeSplit(filePath)},
+      {"a"},
+      {"a < 3"},
+      "",
+      "SELECT a FROM tmp WHERE a < 3");
   assertSelectWithFilter(
-      {"b", "a"}, {"a < 3"}, "", "SELECT b, a FROM tmp WHERE a < 3");
+      {makeSplit(filePath)},
+      {"a", "b"},
+      {"a < 3"},
+      "",
+      "SELECT a, b FROM tmp WHERE a < 3");
+  assertSelectWithFilter(
+      {makeSplit(filePath)},
+      {"b", "a"},
+      {"a < 3"},
+      "",
+      "SELECT b, a FROM tmp WHERE a < 3");
   assertSelectWithFilter(
-      {"a", "b"}, {"a < 0"}, "", "SELECT a, b FROM tmp WHERE a < 0");
+      {makeSplit(filePath)},
+      {"a", "b"},
+      {"a < 0"},
+      "",
+      "SELECT a, b FROM tmp WHERE a < 0");
 
   assertSelectWithFilter(
-      {"b"}, {"b < DOUBLE '2.0'"}, "", "SELECT b FROM tmp WHERE b < 2.0");
+      {makeSplit(filePath)},
+      {"b"},
+      {"b < DOUBLE '2.0'"},
+      "",
+      "SELECT b FROM tmp WHERE b < 2.0");
   assertSelectWithFilter(
+      {makeSplit(filePath)},
       {"a", "b"},
       {"b >= DOUBLE '2.0'"},
       "",
       "SELECT a, b FROM tmp WHERE b >= 2.0");
   assertSelectWithFilter(
+      {makeSplit(filePath)},
       {"b", "a"},
       {"b <= DOUBLE '2.0'"},
       "",
       "SELECT b, a FROM tmp WHERE b <= 2.0");
   assertSelectWithFilter(
+      {makeSplit(filePath)},
       {"a", "b"},
       {"b < DOUBLE '0.0'"},
       "",
       "SELECT a, b FROM tmp WHERE b < 0.0");
 
   // With aggregations.
-  assertSelectWithAgg({"a"}, {"sum(a)"}, {}, "SELECT sum(a) FROM tmp");
-  assertSelectWithAgg({"b"}, {"max(b)"}, {}, "SELECT max(b) FROM tmp");
   assertSelectWithAgg(
-      {"a", "b"}, {"min(a)", "max(b)"}, {}, "SELECT min(a), max(b) FROM tmp");
+      {makeSplit(filePath)}, {"a"}, {"sum(a)"}, {}, "SELECT sum(a) FROM tmp");
+  assertSelectWithAgg(
+      {makeSplit(filePath)}, {"b"}, {"max(b)"}, {}, "SELECT max(b) FROM tmp");
+  assertSelectWithAgg(
+      {makeSplit(filePath)},
+      {"a", "b"},
+      {"min(a)", "max(b)"},
+      {},
+      "SELECT min(a), max(b) FROM tmp");
   assertSelectWithAgg(
-      {"b", "a"}, {"max(b)"}, {"a"}, "SELECT max(b), a FROM tmp GROUP BY a");
+      {makeSplit(filePath)},
+      {"b", "a"},
+      {"max(b)"},
+      {"a"},
+      "SELECT max(b), a FROM tmp GROUP BY a");
   assertSelectWithAgg(
-      {"a", "b"}, {"max(a)"}, {"b"}, "SELECT max(a), b FROM tmp GROUP BY b");
+      {makeSplit(filePath)},
+      {"a", "b"},
+      {"max(a)"},
+      {"b"},
+      "SELECT max(a), b FROM tmp GROUP BY b");
 
   // With filter and aggregation.
   assertSelectWithFilterAndAgg(
-      {"a"}, {"a < 3"}, {"sum(a)"}, {}, "SELECT sum(a) FROM tmp WHERE a < 3");
+      {makeSplit(filePath)},
+      {"a"},
+      {"a < 3"},
+      {"sum(a)"},
+      {},
+      "SELECT sum(a) FROM tmp WHERE a < 3");
   assertSelectWithFilterAndAgg(
+      {makeSplit(filePath)},
       {"a", "b"},
       {"a < 3"},
       {"sum(b)"},
       {},
       "SELECT sum(b) FROM tmp WHERE a < 3");
   assertSelectWithFilterAndAgg(
+      {makeSplit(filePath)},
       {"a", "b"},
       {"a < 3"},
       {"min(a)", "max(b)"},
       {},
       "SELECT min(a), max(b) FROM tmp WHERE a < 3");
   assertSelectWithFilterAndAgg(
+      {makeSplit(filePath)},
       {"b", "a"},
       {"a < 3"},
       {"max(b)"},
@@ -428,6 +553,39 @@ TEST_F(ParquetTableScanTest, aggregatePushdown) {
   assertEqualVectors(rows->childAt(1), valuesVector);
 }
 
+TEST_F(ParquetTableScanTest, aggregatePushdownToSmallPages) {
+  const std::vector<std::string> columnNames = {"a", "b", "c"};
+  const auto expectedRowVector = makeRowVector(
+      {makeFlatVector<int16_t>({1, 2, 4}),
+       makeFlatVector<int64_t>({7, 9, 13})});
+  const auto outputType = ROW(columnNames, {SMALLINT(), SMALLINT(), VARCHAR()});
+  std::vector<RowVectorPtr> data;
+  for (auto row = 0; row < 10; ++row) {
+    data.emplace_back(makeRowVector(
+        columnNames,
+        {
+            makeFlatVector<int16_t>({static_cast<int16_t>(row % 5)}),
+            makeFlatVector<int16_t>({static_cast<int16_t>(row)}),
+            makeFlatVector<std::string>({std::to_string(row)}),
+        }));
+  }
+  const auto filePath = TempFilePath::create();
+  WriterOptions options;
+  options.dataPageSize = 1;
+  writeToParquetFile(filePath->getPath(), data, options);
+  const auto plan =
+      PlanBuilder(pool())
+          .tableScan(
+              outputType,
+              {},
+              "c <> '' AND a in (1::smallint, 2::smallint, 4::smallint)")
+          .singleAggregation({"a"}, {"sum(b) as s"})
+          .planNode();
+  AssertQueryBuilder(plan)
+      .split(makeSplit(filePath->getPath()))
+      .assertResults(expectedRowVector);
+}
+
 TEST_F(ParquetTableScanTest, countStar) {
   // sample.parquet holds two columns (a: BIGINT, b: DOUBLE) and
   // 20 rows.
@@ -452,7 +610,6 @@ TEST_F(ParquetTableScanTest, decimalSubfieldFilter) {
   std::vector<int64_t> unscaledShortValues(20);
   std::iota(unscaledShortValues.begin(), unscaledShortValues.end(), 10001);
   loadData(
-      getExampleFilePath("decimal.parquet"),
       ROW({"a"}, {DECIMAL(5, 2)}),
       makeRowVector(
           {"a"},
@@ -460,17 +617,39 @@ TEST_F(ParquetTableScanTest, decimalSubfieldFilter) {
               makeFlatVector(unscaledShortValues, DECIMAL(5, 2)),
           }));
 
+  const auto filePath = getExampleFilePath("decimal.parquet");
   assertSelectWithFilter(
-      {"a"}, {"a < 100.07"}, "", "SELECT a FROM tmp WHERE a < 100.07");
+      {makeSplit(filePath)},
+      {"a"},
+      {"a < 100.07"},
+      "",
+      "SELECT a FROM tmp WHERE a < 100.07");
   assertSelectWithFilter(
-      {"a"}, {"a <= 100.07"}, "", "SELECT a FROM tmp WHERE a <= 100.07");
+      {makeSplit(filePath)},
+      {"a"},
+      {"a <= 100.07"},
+      "",
+      "SELECT a FROM tmp WHERE a <= 100.07");
   assertSelectWithFilter(
-      {"a"}, {"a > 100.07"}, "", "SELECT a FROM tmp WHERE a > 100.07");
+      {makeSplit(filePath)},
+      {"a"},
+      {"a > 100.07"},
+      "",
+      "SELECT a FROM tmp WHERE a > 100.07");
   assertSelectWithFilter(
-      {"a"}, {"a >= 100.07"}, "", "SELECT a FROM tmp WHERE a >= 100.07");
+      {makeSplit(filePath)},
+      {"a"},
+      {"a >= 100.07"},
+      "",
+      "SELECT a FROM tmp WHERE a >= 100.07");
   assertSelectWithFilter(
-      {"a"}, {"a = 100.07"}, "", "SELECT a FROM tmp WHERE a = 100.07");
+      {makeSplit(filePath)},
+      {"a"},
+      {"a = 100.07"},
+      "",
+      "SELECT a FROM tmp WHERE a = 100.07");
   assertSelectWithFilter(
+      {makeSplit(filePath)},
       {"a"},
       {"a BETWEEN 100.07 AND 100.12"},
       "",
@@ -478,11 +657,19 @@ TEST_F(ParquetTableScanTest, decimalSubfieldFilter) {
 
   VELOX_ASSERT_THROW(
       assertSelectWithFilter(
-          {"a"}, {"a < 1000.7"}, "", "SELECT a FROM tmp WHERE a < 1000.7"),
+          {makeSplit(filePath)},
+          {"a"},
+          {"a < 1000.7"},
+          "",
+          "SELECT a FROM tmp WHERE a < 1000.7"),
       "Scalar function signature is not supported: lt(DECIMAL(5, 2), DECIMAL(5, 1))");
   VELOX_ASSERT_THROW(
       assertSelectWithFilter(
-          {"a"}, {"a = 1000.7"}, "", "SELECT a FROM tmp WHERE a = 1000.7"),
+          {makeSplit(filePath)},
+          {"a"},
+          {"a = 1000.7"},
+          "",
+          "SELECT a FROM tmp WHERE a = 1000.7"),
       "Scalar function signature is not supported: eq(DECIMAL(5, 2), DECIMAL(5, 1))");
 }
 
@@ -490,7 +677,6 @@ TEST_F(ParquetTableScanTest, map) {
   auto vector = makeMapVector<StringView, StringView>({{{"name", "gluten"}}});
 
   loadData(
-      getExampleFilePath("types.parquet"),
       ROW({"map"}, {MAP(VARCHAR(), VARCHAR())}),
       makeRowVector(
           {"map"},
@@ -498,40 +684,50 @@ TEST_F(ParquetTableScanTest, map) {
               vector,
           }));
 
-  assertSelectWithFilter({"map"}, {}, "", "SELECT map FROM tmp");
+  assertSelectWithFilter(
+      {makeSplit(getExampleFilePath("types.parquet"))},
+      {"map"},
+      {},
+      "",
+      "SELECT map FROM tmp");
 }
 
 TEST_F(ParquetTableScanTest, nullMap) {
-  auto path = getExampleFilePath("null_map.parquet");
   loadData(
-      path,
       ROW({"i", "c"}, {VARCHAR(), MAP(VARCHAR(), VARCHAR())}),
       makeRowVector(
           {"i", "c"},
           {makeConstant<std::string>("1", 1),
            makeNullableMapVector<std::string, std::string>({std::nullopt})}));
 
-  assertSelectWithFilter({"i", "c"}, {}, "", "SELECT i, c FROM tmp");
+  assertSelectWithFilter(
+      {makeSplit(getExampleFilePath("null_map.parquet"))},
+      {"i", "c"},
+      {},
+      "",
+      "SELECT i, c FROM tmp");
 }
 
 TEST_F(ParquetTableScanTest, singleRowStruct) {
   auto vector = makeArrayVector<int32_t>({{}});
   loadData(
-      getExampleFilePath("single_row_struct.parquet"),
       ROW({"s"}, {ROW({"a", "b"}, {BIGINT(), BIGINT()})}),
       makeRowVector(
           {"s"},
           {
               vector,
           }));
-
-  assertSelectWithFilter({"s"}, {}, "", "SELECT (0, 1)");
+  assertSelectWithFilter(
+      {makeSplit(getExampleFilePath("single_row_struct.parquet"))},
+      {"s"},
+      {},
+      "",
+      "SELECT (0, 1)");
 }
 
 TEST_F(ParquetTableScanTest, array) {
   auto vector = makeArrayVector<int32_t>({});
   loadData(
-      getExampleFilePath("old_repeated_int.parquet"),
       ROW({"repeatedInt"}, {ARRAY(INTEGER())}),
       makeRowVector(
           {"repeatedInt"},
@@ -539,8 +735,79 @@ TEST_F(ParquetTableScanTest, array) {
               vector,
           }));
 
+  const auto filePath = getExampleFilePath("old_repeated_int.parquet");
   assertSelectWithFilter(
-      {"repeatedInt"}, {}, "", "SELECT UNNEST(array[array[1,2,3]])");
+      {makeSplit(filePath)}, {"repeatedInt"}, {}, "", "SELECT [1,2,3]");
+
+  // Set the requested type for unannotated array.
+  auto rowType = ROW({"repeatedInt"}, {ARRAY(INTEGER())});
+  auto plan = PlanBuilder(pool_.get())
+                  .tableScan(rowType, {}, "", rowType, {})
+                  .planNode();
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .splits({makeSplit(filePath)})
+      .assertResults("SELECT [1,2,3]");
+
+  // Throws when reading repeated values as scalar type.
+  rowType = ROW({"repeatedInt"}, {INTEGER()});
+  plan = PlanBuilder(pool_.get())
+             .tableScan(rowType, {}, "", rowType, {})
+             .planNode();
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan, duckDbQueryRunner_)
+          .splits({makeSplit(filePath)})
+          .assertResults(""),
+      "Requested type must be array");
+
+  rowType = ROW({"mystring"}, {ARRAY(VARCHAR())});
+  plan = PlanBuilder(pool_.get())
+             .tableScan(rowType, {}, "", rowType, {})
+             .planNode();
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .splits({makeSplit(getExampleFilePath("proto_repeated_string.parquet"))})
+      .assertResults(
+          "SELECT UNNEST(array[array['hello', 'world'], array['good','bye'], array['one', 'two', 'three']])");
+
+  rowType =
+      ROW({"primitive", "myComplex"},
+          {INTEGER(),
+           ARRAY(
+               ROW({"id", "repeatedMessage"},
+                   {INTEGER(), ARRAY(ROW({"someId"}, {INTEGER()}))}))});
+  plan = PlanBuilder(pool_.get())
+             .tableScan(rowType, {}, "", rowType, {})
+             .planNode();
+
+  // Construct the expected vector.
+  auto someIdVector = makeArrayOfRowVector(
+      ROW({"someId"}, {INTEGER()}),
+      {
+          {variant::row({3})},
+          {variant::row({6})},
+          {variant::row({9})},
+      });
+  auto rowVector = makeRowVector(
+      {"id", "repeatedMessage"},
+      {
+          makeFlatVector<int32_t>({1, 4, 7}),
+          someIdVector,
+      });
+  auto expected = makeRowVector(
+      {"primitive", "myComplex"},
+      {
+          makeFlatVector<int32_t>({2, 5, 8}),
+          makeArrayVector({0, 1, 2}, rowVector),
+      });
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .connectorSessionProperty(
+          kHiveConnectorId,
+          connector::hive::HiveConfig::kParquetUseColumnNamesSession,
+          "true")
+      .splits({makeSplit(getExampleFilePath("nested_array_struct.parquet"))})
+      .assertResults(expected);
 }
 
 // Optional array with required elements.
@@ -548,7 +815,6 @@ TEST_F(ParquetTableScanTest, optArrayReqEle) {
   auto vector = makeArrayVector<StringView>({});
 
   loadData(
-      getExampleFilePath("array_0.parquet"),
       ROW({"_1"}, {ARRAY(VARCHAR())}),
       makeRowVector(
           {"_1"},
@@ -557,6 +823,7 @@ TEST_F(ParquetTableScanTest, optArrayReqEle) {
           }));
 
   assertSelectWithFilter(
+      {makeSplit(getExampleFilePath("array_0.parquet"))},
       {"_1"},
       {},
       "",
@@ -568,7 +835,6 @@ TEST_F(ParquetTableScanTest, reqArrayReqEle) {
   auto vector = makeArrayVector<StringView>({});
 
   loadData(
-      getExampleFilePath("array_1.parquet"),
       ROW({"_1"}, {ARRAY(VARCHAR())}),
       makeRowVector(
           {"_1"},
@@ -577,6 +843,7 @@ TEST_F(ParquetTableScanTest, reqArrayReqEle) {
           }));
 
   assertSelectWithFilter(
+      {makeSplit(getExampleFilePath("array_1.parquet"))},
       {"_1"},
       {},
       "",
@@ -588,7 +855,6 @@ TEST_F(ParquetTableScanTest, reqArrayOptEle) {
   auto vector = makeArrayVector<StringView>({});
 
   loadData(
-      getExampleFilePath("array_2.parquet"),
       ROW({"_1"}, {ARRAY(VARCHAR())}),
       makeRowVector(
           {"_1"},
@@ -597,6 +863,7 @@ TEST_F(ParquetTableScanTest, reqArrayOptEle) {
           }));
 
   assertSelectWithFilter(
+      {makeSplit(getExampleFilePath("array_2.parquet"))},
       {"_1"},
       {},
       "",
@@ -615,6 +882,7 @@ TEST_F(ParquetTableScanTest, arrayOfArrayTest) {
           }));
 
   assertSelectWithFilter(
+      {makeSplit(getExampleFilePath("array_of_array1.parquet"))},
       {"_1"},
       {},
       "",
@@ -626,7 +894,6 @@ TEST_F(ParquetTableScanTest, reqArrayLegacy) {
   auto vector = makeArrayVector<StringView>({});
 
   loadData(
-      getExampleFilePath("array_3.parquet"),
       ROW({"element"}, {ARRAY(VARCHAR())}),
       makeRowVector(
           {"element"},
@@ -635,6 +902,7 @@ TEST_F(ParquetTableScanTest, reqArrayLegacy) {
           }));
 
   assertSelectWithFilter(
+      {makeSplit(getExampleFilePath("array_3.parquet"))},
       {"element"},
       {},
       "",
@@ -643,7 +911,6 @@ TEST_F(ParquetTableScanTest, reqArrayLegacy) {
 
 TEST_F(ParquetTableScanTest, filterOnNestedArray) {
   loadData(
-      getExampleFilePath("struct_of_array.parquet"),
       ROW({"struct"},
           {ROW({"a0", "a1"}, {ARRAY(VARCHAR()), ARRAY(INTEGER())})}),
       makeRowVector(
@@ -653,7 +920,11 @@ TEST_F(ParquetTableScanTest, filterOnNestedArray) {
           }));
 
   assertSelectWithFilter(
-      {"struct"}, {}, "struct.a0 is null", "SELECT ROW(NULL, NULL)");
+      {makeSplit(getExampleFilePath("struct_of_array.parquet"))},
+      {"struct"},
+      {},
+      "struct.a0 is null",
+      "SELECT ROW(NULL, NULL)");
 }
 
 TEST_F(ParquetTableScanTest, readAsLowerCase) {
@@ -669,16 +940,19 @@ TEST_F(ParquetTableScanTest, readAsLowerCase) {
   createDuckDbTable(vectors);
 
   auto plan = PlanBuilder().tableScan(ROW({"a"}, {BIGINT()})).planNode();
-  auto split = makeSplit(filePath->getPath());
 
   AssertQueryBuilder(plan, duckDbQueryRunner_)
       .connectorSessionProperty(
           kHiveConnectorId,
           connector::hive::HiveConfig::kFileColumnNamesReadAsLowerCaseSession,
           "true")
-      .split(split)
+      .split(makeSplit(filePath->getPath()))
       .assertResults("SELECT A FROM tmp");
 
+  // Wait for all tasks to be deleted to avoid race condition between async IO
+  // preloading and TempFilePath destruction.
+  waitForAllTasksToBeDeleted();
+
   // Test reading table with non-ascii names.
   auto vectorsNonAsciiNames = {makeRowVector(
       {"Товары", "国Ⅵ", "\uFF21", "\uFF22"},
@@ -688,8 +962,9 @@ TEST_F(ParquetTableScanTest, readAsLowerCase) {
           makeFlatVector<float>(20, [](auto row) { return row + 1; }),
           makeFlatVector<int32_t>(20, [](auto row) { return row + 1; }),
       })};
-  filePath = TempFilePath::create();
-  writeToParquetFile(filePath->getPath(), vectorsNonAsciiNames, options);
+
+  auto filePath2 = TempFilePath::create();
+  writeToParquetFile(filePath2->getPath(), vectorsNonAsciiNames, options);
   createDuckDbTable(vectorsNonAsciiNames);
 
   plan = PlanBuilder()
@@ -697,15 +972,16 @@ TEST_F(ParquetTableScanTest, readAsLowerCase) {
                  ROW({"товары", "国ⅵ", "\uFF41", "\uFF42"},
                      {BIGINT(), DOUBLE(), REAL(), INTEGER()}))
              .planNode();
-  split = makeSplit(filePath->getPath());
 
   AssertQueryBuilder(plan, duckDbQueryRunner_)
       .connectorSessionProperty(
           kHiveConnectorId,
           connector::hive::HiveConfig::kFileColumnNamesReadAsLowerCaseSession,
           "true")
-      .split(split)
+      .split(makeSplit(filePath2->getPath()))
       .assertResults("SELECT * FROM tmp");
+
+  waitForAllTasksToBeDeleted();
 }
 
 TEST_F(ParquetTableScanTest, rowIndex) {
@@ -713,7 +989,6 @@ TEST_F(ParquetTableScanTest, rowIndex) {
   // case 1: file not have `_tmp_metadata_row_index`, scan generate it for user.
   auto filePath = getExampleFilePath("sample.parquet");
   loadData(
-      filePath,
       ROW({"a", "b", "_tmp_metadata_row_index", kPath},
           {BIGINT(), DOUBLE(), BIGINT(), VARCHAR()}),
       makeRowVector(
@@ -724,42 +999,62 @@ TEST_F(ParquetTableScanTest, rowIndex) {
               makeFlatVector<int64_t>(20, [](auto row) { return row; }),
               makeFlatVector<std::string>(
                   20, [filePath](auto row) { return filePath; }),
-          }),
-      std::nullopt,
-      std::unordered_map<std::string, std::string>{{kPath, filePath}});
+          }));
   connector::ColumnHandleMap assignments;
   assignments["a"] = std::make_shared<connector::hive::HiveColumnHandle>(
       "a",
-      connector::hive::HiveColumnHandle::ColumnType::kRegular,
+      connector::hive::FileColumnHandle::ColumnType::kRegular,
       BIGINT(),
       BIGINT());
   assignments["b"] = std::make_shared<connector::hive::HiveColumnHandle>(
       "b",
-      connector::hive::HiveColumnHandle::ColumnType::kRegular,
+      connector::hive::FileColumnHandle::ColumnType::kRegular,
       DOUBLE(),
       DOUBLE());
   assignments[kPath] = synthesizedColumn(kPath, VARCHAR());
   assignments["_tmp_metadata_row_index"] =
       std::make_shared<connector::hive::HiveColumnHandle>(
           "_tmp_metadata_row_index",
-          connector::hive::HiveColumnHandle::ColumnType::kRowIndex,
+          connector::hive::FileColumnHandle::ColumnType::kRowIndex,
           BIGINT(),
           BIGINT());
 
-  assertSelect({"a"}, "SELECT a FROM tmp");
+  assertSelect(
+      {makeSplit(
+          filePath,
+          std::nullopt,
+          std::unordered_map<std::string, std::string>{{kPath, filePath}})},
+      {"a"},
+      "SELECT a FROM tmp");
   assertSelectWithAssignments(
+      {makeSplit(
+          filePath,
+          std::nullopt,
+          std::unordered_map<std::string, std::string>{{kPath, filePath}})},
       {"a", "_tmp_metadata_row_index"},
       assignments,
       "SELECT a, _tmp_metadata_row_index FROM tmp");
   assertSelectWithAssignments(
+      {makeSplit(
+          filePath,
+          std::nullopt,
+          std::unordered_map<std::string, std::string>{{kPath, filePath}})},
       {"_tmp_metadata_row_index", "a"},
       assignments,
       "SELECT _tmp_metadata_row_index, a FROM tmp");
   assertSelectWithAssignments(
+      {makeSplit(
+          filePath,
+          std::nullopt,
+          std::unordered_map<std::string, std::string>{{kPath, filePath}})},
       {"_tmp_metadata_row_index"},
       assignments,
       "SELECT _tmp_metadata_row_index FROM tmp");
   assertSelectWithAssignments(
+      {makeSplit(
+          filePath,
+          std::nullopt,
+          std::unordered_map<std::string, std::string>{{kPath, filePath}})},
       {kPath, "_tmp_metadata_row_index"},
       assignments,
       fmt::format("SELECT {}, _tmp_metadata_row_index FROM tmp", kPath));
@@ -767,7 +1062,6 @@ TEST_F(ParquetTableScanTest, rowIndex) {
   // case 2: file has `_tmp_metadata_row_index` column, then use user data
   // insteads of generating it.
   loadData(
-      getExampleFilePath("sample_with_rowindex.parquet"),
       ROW({"a", "b", "_tmp_metadata_row_index"},
           {BIGINT(), DOUBLE(), BIGINT()}),
       makeRowVector(
@@ -778,8 +1072,10 @@ TEST_F(ParquetTableScanTest, rowIndex) {
               makeFlatVector<int64_t>(20, [](auto row) { return row + 1; }),
           }));
 
-  assertSelect({"a"}, "SELECT a FROM tmp");
+  filePath = getExampleFilePath("sample_with_rowindex.parquet");
+  assertSelect({makeSplit(filePath)}, {"a"}, "SELECT a FROM tmp");
   assertSelect(
+      {makeSplit(filePath)},
       {"a", "_tmp_metadata_row_index"},
       "SELECT a, _tmp_metadata_row_index FROM tmp");
 }
@@ -799,27 +1095,30 @@ TEST_F(ParquetTableScanTest, rowIndex) {
 // VALUES (1, 1), (2, null),(3, null);
 TEST_F(ParquetTableScanTest, filterNullIcebergPartition) {
   loadData(
-      getExampleFilePath("icebergNullIcebergPartition.parquet"),
       ROW({"c0", "c1"}, {BIGINT(), BIGINT()}),
       makeRowVector(
           {"c0", "c1"},
           {
               makeFlatVector<int64_t>(std::vector<int64_t>{2, 3}),
               makeNullableFlatVector<int64_t>({std::nullopt, std::nullopt}),
-          }),
-      std::unordered_map<std::string, std::optional<std::string>>{
-          {"c1", std::nullopt}});
+          }));
 
   std::shared_ptr<connector::ColumnHandle> c0 = makeColumnHandle(
-      "c0", BIGINT(), BIGINT(), {}, HiveColumnHandle::ColumnType::kRegular);
+      "c0", BIGINT(), BIGINT(), {}, FileColumnHandle::ColumnType::kRegular);
   std::shared_ptr<connector::ColumnHandle> c1 = makeColumnHandle(
       "c1",
       BIGINT(),
       BIGINT(),
       {},
-      HiveColumnHandle::ColumnType::kPartitionKey);
+      FileColumnHandle::ColumnType::kPartitionKey);
 
+  const auto filePath =
+      getExampleFilePath("icebergNullIcebergPartition.parquet");
   assertSelectWithFilter(
+      {makeSplit(
+          filePath,
+          std::unordered_map<std::string, std::optional<std::string>>{
+              {"c1", std::nullopt}})},
       {"c0", "c1"},
       {"c1 IS NOT NULL"},
       "",
@@ -827,6 +1126,10 @@ TEST_F(ParquetTableScanTest, filterNullIcebergPartition) {
       connector::ColumnHandleMap{{"c0", c0}, {"c1", c1}});
 
   assertSelectWithFilter(
+      {makeSplit(
+          filePath,
+          std::unordered_map<std::string, std::optional<std::string>>{
+              {"c1", std::nullopt}})},
       {"c0", "c1"},
       {"c1 IS NULL"},
       "",
@@ -844,7 +1147,6 @@ TEST_F(ParquetTableScanTest, sessionTimezone) {
   // Read sample.parquet to verify if the sessionTimezone in the PageReader
   // meets expectations.
   loadData(
-      getExampleFilePath("sample.parquet"),
       ROW({"a", "b"}, {BIGINT(), DOUBLE()}),
       makeRowVector(
           {"a", "b"},
@@ -853,48 +1155,90 @@ TEST_F(ParquetTableScanTest, sessionTimezone) {
               makeFlatVector<double>(20, [](auto row) { return row + 1; }),
           }));
 
-  assertSelectWithTimezone({"a"}, "SELECT a FROM tmp", "Asia/Shanghai");
+  assertSelectWithTimezone(
+      {makeSplit(getExampleFilePath("sample.parquet"))},
+      {"a"},
+      "SELECT a FROM tmp",
+      "Asia/Shanghai");
 }
 
-TEST_F(ParquetTableScanTest, timestampInt64Dictionary) {
+TEST_F(ParquetTableScanTest, timestampInt64DictionaryMicro) {
   WriterOptions options;
   options.writeInt96AsTimestamp = false;
   options.enableDictionary = true;
   options.parquetWriteTimestampUnit = TimestampPrecision::kMicroseconds;
-  testTimestampRead(options);
+  testTimestampRead(options, TimestampPrecision::kMicroseconds);
+  testTimestampRead(options, TimestampPrecision::kMilliseconds);
+}
+
+TEST_F(ParquetTableScanTest, timestampInt64DictionaryMilli) {
+  WriterOptions options;
+  options.writeInt96AsTimestamp = false;
+  options.enableDictionary = true;
+  options.parquetWriteTimestampUnit = TimestampPrecision::kMilliseconds;
+  testTimestampRead(options, TimestampPrecision::kMicroseconds);
+  testTimestampRead(options, TimestampPrecision::kMilliseconds);
 }
 
-TEST_F(ParquetTableScanTest, timestampInt64Plain) {
+TEST_F(ParquetTableScanTest, timestampInt64PlainMicro) {
   WriterOptions options;
   options.writeInt96AsTimestamp = false;
   options.enableDictionary = false;
   options.parquetWriteTimestampUnit = TimestampPrecision::kMicroseconds;
-  testTimestampRead(options);
+  testTimestampRead(options, TimestampPrecision::kMicroseconds);
+  testTimestampRead(options, TimestampPrecision::kMilliseconds);
 }
 
-TEST_F(ParquetTableScanTest, timestampInt96Dictionary) {
+TEST_F(ParquetTableScanTest, timestampInt64PlainMilli) {
+  WriterOptions options;
+  options.writeInt96AsTimestamp = false;
+  options.enableDictionary = false;
+  options.parquetWriteTimestampUnit = TimestampPrecision::kMilliseconds;
+  testTimestampRead(options, TimestampPrecision::kMicroseconds);
+  testTimestampRead(options, TimestampPrecision::kMilliseconds);
+}
+
+TEST_F(ParquetTableScanTest, timestampInt96DictionaryMicro) {
   WriterOptions options;
   options.writeInt96AsTimestamp = true;
   options.enableDictionary = true;
   options.parquetWriteTimestampUnit = TimestampPrecision::kMicroseconds;
-  testTimestampRead(options);
+  testTimestampRead(options, TimestampPrecision::kMicroseconds);
+  testTimestampRead(options, TimestampPrecision::kMilliseconds);
+}
+
+TEST_F(ParquetTableScanTest, timestampInt96DictionaryMilli) {
+  WriterOptions options;
+  options.writeInt96AsTimestamp = true;
+  options.enableDictionary = true;
+  options.parquetWriteTimestampUnit = TimestampPrecision::kMilliseconds;
+  testTimestampRead(options, TimestampPrecision::kMicroseconds);
+  testTimestampRead(options, TimestampPrecision::kMilliseconds);
 }
 
-TEST_F(ParquetTableScanTest, timestampInt96Plain) {
+TEST_F(ParquetTableScanTest, timestampInt96PlainMicro) {
   WriterOptions options;
   options.writeInt96AsTimestamp = true;
   options.enableDictionary = false;
   options.parquetWriteTimestampUnit = TimestampPrecision::kMicroseconds;
-  testTimestampRead(options);
+  testTimestampRead(options, TimestampPrecision::kMicroseconds);
+  testTimestampRead(options, TimestampPrecision::kMilliseconds);
+}
+
+TEST_F(ParquetTableScanTest, timestampInt96PlainMilli) {
+  WriterOptions options;
+  options.writeInt96AsTimestamp = true;
+  options.enableDictionary = false;
+  options.parquetWriteTimestampUnit = TimestampPrecision::kMilliseconds;
+  testTimestampRead(options, TimestampPrecision::kMicroseconds);
+  testTimestampRead(options, TimestampPrecision::kMilliseconds);
 }
 
 TEST_F(ParquetTableScanTest, timestampConvertedType) {
   auto stringToTimestamp = [](std::string_view view) {
     return util::fromTimestampString(
                view.data(), view.size(), util::TimestampParseMode::kPrestoCast)
-        .thenOrThrow(folly::identity, [&](const Status& status) {
-          VELOX_USER_FAIL("{}", status.message());
-        });
+        .value();
   };
   std::vector<std::string_view> expected = {
       "1970-01-01 00:00:00.010",
@@ -913,10 +1257,14 @@ TEST_F(ParquetTableScanTest, timestampConvertedType) {
           makeFlatVector<Timestamp>(values),
       });
   const auto schema = asRowType(vector->type());
-  const auto path = getExampleFilePath("tmmillis_i64.parquet");
-  loadData(path, schema, vector);
+  loadData(schema, vector);
 
-  assertSelectWithFilter({"time"}, {}, "", "SELECT time from tmp");
+  assertSelectWithFilter(
+      {makeSplit(getExampleFilePath("tmmillis_i64.parquet"))},
+      {"time"},
+      {},
+      "",
+      "SELECT time from tmp");
 }
 
 TEST_F(ParquetTableScanTest, timestampPrecisionMicrosecond) {
@@ -950,6 +1298,42 @@ TEST_F(ParquetTableScanTest, timestampPrecisionMicrosecond) {
   }
 }
 
+TEST_F(ParquetTableScanTest, timestampUtcPlainMicro) {
+  parquet::WriterOptions options;
+  options.writeInt96AsTimestamp = false;
+  options.enableDictionary = false;
+  options.parquetWriteTimestampUnit = TimestampPrecision::kMicroseconds;
+  testTimestampUtcRead(options, TimestampPrecision::kMicroseconds);
+  testTimestampUtcRead(options, TimestampPrecision::kMilliseconds);
+}
+
+TEST_F(ParquetTableScanTest, timestampUtcDictionaryMicro) {
+  parquet::WriterOptions options;
+  options.writeInt96AsTimestamp = false;
+  options.enableDictionary = true;
+  options.parquetWriteTimestampUnit = TimestampPrecision::kMicroseconds;
+  testTimestampUtcRead(options, TimestampPrecision::kMicroseconds);
+  testTimestampUtcRead(options, TimestampPrecision::kMilliseconds);
+}
+
+TEST_F(ParquetTableScanTest, timestampUtcPlainMilli) {
+  parquet::WriterOptions options;
+  options.writeInt96AsTimestamp = false;
+  options.enableDictionary = false;
+  options.parquetWriteTimestampUnit = TimestampPrecision::kMilliseconds;
+  testTimestampUtcRead(options, TimestampPrecision::kMicroseconds);
+  testTimestampUtcRead(options, TimestampPrecision::kMilliseconds);
+}
+
+TEST_F(ParquetTableScanTest, timestampUtcDictionaryMilli) {
+  parquet::WriterOptions options;
+  options.writeInt96AsTimestamp = false;
+  options.enableDictionary = true;
+  options.parquetWriteTimestampUnit = TimestampPrecision::kMilliseconds;
+  testTimestampUtcRead(options, TimestampPrecision::kMicroseconds);
+  testTimestampUtcRead(options, TimestampPrecision::kMilliseconds);
+}
+
 TEST_F(ParquetTableScanTest, testColumnNotExists) {
   auto rowType =
       ROW({"a", "b", "not_exists", "not_exists_array", "not_exists_map"},
@@ -963,7 +1347,6 @@ TEST_F(ParquetTableScanTest, testColumnNotExists) {
   //  optional double b;
   // }
   loadData(
-      getExampleFilePath("sample.parquet"),
       rowType,
       makeRowVector(
           {"a", "b"},
@@ -973,6 +1356,7 @@ TEST_F(ParquetTableScanTest, testColumnNotExists) {
           }));
 
   assertSelectWithDataColumns(
+      {makeSplit(getExampleFilePath("sample.parquet"))},
       {"a", "b", "not_exists", "not_exists_array", "not_exists_map"},
       rowType,
       "SELECT a, b, NULL, NULL, NULL FROM tmp");
@@ -998,8 +1382,8 @@ TEST_F(ParquetTableScanTest, schemaMatchWithComplexTypes) {
       {"p", "m", "a"},
       {primitiveVector, mapVector, arrayVector}); // columns in data file
 
-  const std::shared_ptr<exec::test::TempDirectoryPath> dataFileFolder =
-      exec::test::TempDirectoryPath::create();
+  const std::shared_ptr<TempDirectoryPath> dataFileFolder =
+      TempDirectoryPath::create();
   auto filePath = dataFileFolder->getPath() + "/" + "nested_data.parquet";
   WriterOptions options;
   options.writeInt96AsTimestamp = false;
@@ -1022,8 +1406,8 @@ TEST_F(ParquetTableScanTest, schemaMatchWithComplexTypes) {
           .project({"p1", "m1[0].aa1", "m1[1].bb1", "a1[1].aa1", "a1[2].bb1"})
           .planNode();
 
-  auto split = makeSplit(filePath);
-  auto result = AssertQueryBuilder(op).split(split).copyResults(pool());
+  auto result =
+      AssertQueryBuilder(op).split(makeSplit(filePath)).copyResults(pool());
 
   ASSERT_EQ(result->size(), kSize);
   auto rows = result->as<RowVector>();
@@ -1049,7 +1433,7 @@ TEST_F(ParquetTableScanTest, schemaMatchWithComplexTypes) {
                    kHiveConnectorId,
                    connector::hive::HiveConfig::kParquetUseColumnNamesSession,
                    "true")
-               .split(split)
+               .split(makeSplit(filePath))
                .copyResults(pool());
   rows = result->as<RowVector>();
   // check for rest of the selected columns
@@ -1074,8 +1458,8 @@ TEST_F(ParquetTableScanTest, schemaMatch) {
       {makeFlatVector<int64_t>(kSize, [](auto row) { return row; }),
        makeFlatVector<int64_t>(kSize, [](auto row) { return row * 4; })});
 
-  const std::shared_ptr<exec::test::TempDirectoryPath> dataFileFolder =
-      exec::test::TempDirectoryPath::create();
+  const std::shared_ptr<TempDirectoryPath> dataFileFolder =
+      TempDirectoryPath::create();
   auto filePath = dataFileFolder->getPath() + "/" + "data.parquet";
   WriterOptions options;
   options.writeInt96AsTimestamp = false;
@@ -1089,8 +1473,8 @@ TEST_F(ParquetTableScanTest, schemaMatch) {
                 .endTableScan()
                 .planNode();
 
-  auto split = makeSplit(filePath);
-  auto result = AssertQueryBuilder(op).split(split).copyResults(pool());
+  auto result =
+      AssertQueryBuilder(op).split(makeSplit(filePath)).copyResults(pool());
   auto rows = result->as<RowVector>();
 
   assertEqualVectors(rows->childAt(0), dataFileVectors->childAt(0));
@@ -1106,7 +1490,7 @@ TEST_F(ParquetTableScanTest, schemaMatch) {
            .endTableScan()
            .planNode();
   EXPECT_THROW(
-      AssertQueryBuilder(op).split(split).copyResults(pool()),
+      AssertQueryBuilder(op).split(makeSplit(filePath)).copyResults(pool()),
       VeloxRuntimeError);
 
   // Now run query with column mapping using names, now c2 columns will match in
@@ -1123,7 +1507,7 @@ TEST_F(ParquetTableScanTest, schemaMatch) {
                    kHiveConnectorId,
                    connector::hive::HiveConfig::kParquetUseColumnNamesSession,
                    "true")
-               .split(split)
+               .split(makeSplit(filePath))
                .copyResults(pool());
 
   rows = result->as<RowVector>();
@@ -1143,7 +1527,7 @@ TEST_F(ParquetTableScanTest, schemaMatch) {
            .planNode();
 
   EXPECT_THROW(
-      AssertQueryBuilder(op).split(split).copyResults(pool()),
+      AssertQueryBuilder(op).split(makeSplit(filePath)).copyResults(pool()),
       VeloxRuntimeError);
 
   // Schema evolution remove column.
@@ -1156,7 +1540,8 @@ TEST_F(ParquetTableScanTest, schemaMatch) {
            .project({"c1"})
            .planNode();
 
-  result = AssertQueryBuilder(op).split(split).copyResults(pool());
+  result =
+      AssertQueryBuilder(op).split(makeSplit(filePath)).copyResults(pool());
   rows = result->as<RowVector>();
   assertEqualVectors(rows->childAt(0), dataFileVectors->childAt(0));
 
@@ -1170,7 +1555,8 @@ TEST_F(ParquetTableScanTest, schemaMatch) {
            .project({"c1", "c2", "c3"})
            .planNode();
 
-  result = AssertQueryBuilder(op).split(split).copyResults(pool());
+  result =
+      AssertQueryBuilder(op).split(makeSplit(filePath)).copyResults(pool());
   rows = result->as<RowVector>();
   assertEqualVectors(rows->childAt(0), dataFileVectors->childAt(0));
   assertEqualVectors(rows->childAt(1), dataFileVectors->childAt(1));
@@ -1183,17 +1569,17 @@ TEST_F(ParquetTableScanTest, deltaByteArray) {
   createDuckDbTable("expected", {expected});
 
   auto vector = makeFlatVector<StringView>({{}});
-  loadData(
-      getExampleFilePath("delta_byte_array.parquet"),
-      ROW({"a"}, {VARCHAR()}),
-      makeRowVector({"a"}, {vector}));
-  assertSelect({"a"}, "SELECT a from expected");
+  loadData(ROW({"a"}, {VARCHAR()}), makeRowVector({"a"}, {vector}));
+  assertSelect(
+      {makeSplit(getExampleFilePath("delta_byte_array.parquet"))},
+      {"a"},
+      "SELECT a from expected");
 }
 
 TEST_F(ParquetTableScanTest, booleanRle) {
   WriterOptions options;
   options.enableDictionary = false;
-  options.encoding = facebook::velox::parquet::arrow::Encoding::RLE;
+  options.encoding = facebook::velox::parquet::arrow::Encoding::kRle;
   options.useParquetDataPageV2 = true;
 
   auto allTrue = [](vector_size_t row) -> bool { return true; };
@@ -1218,30 +1604,30 @@ TEST_F(ParquetTableScanTest, booleanRle) {
   auto schema = asRowType(vector->type());
   auto file = TempFilePath::create();
   writeToParquetFile(file->getPath(), {vector}, options);
-  loadData(file->getPath(), schema, vector);
+  loadData(schema, vector);
 
   std::shared_ptr<connector::ColumnHandle> c0 = makeColumnHandle(
-      "c0", BOOLEAN(), BOOLEAN(), {}, HiveColumnHandle::ColumnType::kRegular);
+      "c0", BOOLEAN(), BOOLEAN(), {}, FileColumnHandle::ColumnType::kRegular);
   std::shared_ptr<connector::ColumnHandle> c1 = makeColumnHandle(
-      "c1", BOOLEAN(), BOOLEAN(), {}, HiveColumnHandle::ColumnType::kRegular);
+      "c1", BOOLEAN(), BOOLEAN(), {}, FileColumnHandle::ColumnType::kRegular);
   std::shared_ptr<connector::ColumnHandle> c2 = makeColumnHandle(
-      "c2", BOOLEAN(), BOOLEAN(), {}, HiveColumnHandle::ColumnType::kRegular);
+      "c2", BOOLEAN(), BOOLEAN(), {}, FileColumnHandle::ColumnType::kRegular);
   std::shared_ptr<connector::ColumnHandle> c3 = makeColumnHandle(
-      "c3", BOOLEAN(), BOOLEAN(), {}, HiveColumnHandle::ColumnType::kRegular);
+      "c3", BOOLEAN(), BOOLEAN(), {}, FileColumnHandle::ColumnType::kRegular);
   std::shared_ptr<connector::ColumnHandle> c4 = makeColumnHandle(
-      "c4", BOOLEAN(), BOOLEAN(), {}, HiveColumnHandle::ColumnType::kRegular);
+      "c4", BOOLEAN(), BOOLEAN(), {}, FileColumnHandle::ColumnType::kRegular);
 
-  assertSelect({"c0"}, "SELECT c0 FROM tmp");
-  assertSelect({"c1"}, "SELECT c1 FROM tmp");
-  assertSelect({"c2"}, "SELECT c2 FROM tmp");
-  assertSelect({"c3"}, "SELECT c3 FROM tmp");
-  assertSelect({"c4"}, "SELECT c4 FROM tmp");
+  assertSelect({makeSplit(file->getPath())}, {"c0"}, "SELECT c0 FROM tmp");
+  assertSelect({makeSplit(file->getPath())}, {"c1"}, "SELECT c1 FROM tmp");
+  assertSelect({makeSplit(file->getPath())}, {"c2"}, "SELECT c2 FROM tmp");
+  assertSelect({makeSplit(file->getPath())}, {"c3"}, "SELECT c3 FROM tmp");
+  assertSelect({makeSplit(file->getPath())}, {"c4"}, "SELECT c4 FROM tmp");
 }
 
 TEST_F(ParquetTableScanTest, singleBooleanRle) {
   WriterOptions options;
   options.enableDictionary = false;
-  options.encoding = facebook::velox::parquet::arrow::Encoding::RLE;
+  options.encoding = facebook::velox::parquet::arrow::Encoding::kRle;
   options.useParquetDataPageV2 = true;
 
   auto vector = makeRowVector(
@@ -1254,18 +1640,18 @@ TEST_F(ParquetTableScanTest, singleBooleanRle) {
   auto schema = asRowType(vector->type());
   auto file = TempFilePath::create();
   writeToParquetFile(file->getPath(), {vector}, options);
-  loadData(file->getPath(), schema, vector);
+  loadData(schema, vector);
 
   std::shared_ptr<connector::ColumnHandle> c0 = makeColumnHandle(
-      "c0", BOOLEAN(), BOOLEAN(), {}, HiveColumnHandle::ColumnType::kRegular);
+      "c0", BOOLEAN(), BOOLEAN(), {}, FileColumnHandle::ColumnType::kRegular);
   std::shared_ptr<connector::ColumnHandle> c1 = makeColumnHandle(
-      "c1", BOOLEAN(), BOOLEAN(), {}, HiveColumnHandle::ColumnType::kRegular);
+      "c1", BOOLEAN(), BOOLEAN(), {}, FileColumnHandle::ColumnType::kRegular);
   std::shared_ptr<connector::ColumnHandle> c2 = makeColumnHandle(
-      "c2", BOOLEAN(), BOOLEAN(), {}, HiveColumnHandle::ColumnType::kRegular);
+      "c2", BOOLEAN(), BOOLEAN(), {}, FileColumnHandle::ColumnType::kRegular);
 
-  assertSelect({"c0"}, "SELECT c0 FROM tmp");
-  assertSelect({"c1"}, "SELECT c1 FROM tmp");
-  assertSelect({"c2"}, "SELECT c2 FROM tmp");
+  assertSelect({makeSplit(file->getPath())}, {"c0"}, "SELECT c0 FROM tmp");
+  assertSelect({makeSplit(file->getPath())}, {"c1"}, "SELECT c1 FROM tmp");
+  assertSelect({makeSplit(file->getPath())}, {"c2"}, "SELECT c2 FROM tmp");
 }
 
 TEST_F(ParquetTableScanTest, intToBigintRead) {
@@ -1276,8 +1662,8 @@ TEST_F(ParquetTableScanTest, intToBigintRead) {
   RowVectorPtr bigintDataFileVectors = makeRowVector(
       {"c1"}, {makeFlatVector<int64_t>(kSize, [](auto row) { return row; })});
 
-  const std::shared_ptr<exec::test::TempDirectoryPath> dataFileFolder =
-      exec::test::TempDirectoryPath::create();
+  const std::shared_ptr<TempDirectoryPath> dataFileFolder =
+      TempDirectoryPath::create();
   auto filePath = dataFileFolder->getPath() + "/" + "data.parquet";
   WriterOptions options;
   options.writeInt96AsTimestamp = false;
@@ -1298,6 +1684,116 @@ TEST_F(ParquetTableScanTest, intToBigintRead) {
   assertEqualVectors(bigintDataFileVectors->childAt(0), rows->childAt(0));
 }
 
+TEST_F(ParquetTableScanTest, intNarrowingRejectedByDefault) {
+  // Narrowing conversions are rejected when allowInt32Narrowing is false
+  // (default). Each case writes a wider integer column and reads as a narrower
+  // type, expecting an exception from convertType.
+  auto assertNarrowingThrows = [&](const VectorPtr& sourceVector,
+                                   const TypePtr& targetType) {
+    auto vectors = makeRowVector({"c1"}, {sourceVector});
+    auto dataFile = TempFilePath::create();
+    writeToParquetFile(dataFile->getPath(), {vectors}, WriterOptions{});
+    auto rowType = ROW({"c1"}, {targetType});
+    auto op = PlanBuilder()
+                  .startTableScan()
+                  .outputType(rowType)
+                  .dataColumns(rowType)
+                  .endTableScan()
+                  .planNode();
+    VELOX_ASSERT_THROW(
+        AssertQueryBuilder(op)
+            .split(makeSplit(dataFile->getPath()))
+            .copyResults(pool()),
+        "is not allowed for requested type");
+  };
+
+  assertNarrowingThrows(makeFlatVector<int16_t>({1, 2}), TINYINT());
+  assertNarrowingThrows(makeFlatVector<int32_t>({1, 2}), SMALLINT());
+  assertNarrowingThrows(makeFlatVector<int32_t>({1, 2}), TINYINT());
+}
+
+TEST_F(ParquetTableScanTest, intReadWithNarrowerType) {
+  // Reading a wider integer as a narrower one causes unchecked truncation and
+  // two's complement reinterpretation, resulting in values INT_MAX becoming -1.
+  // Only INT32 physical type narrowing is supported (INT_16 -> TINYINT,
+  // INT_32 -> SMALLINT/TINYINT). INT64 -> INT32 is not allowed.
+  RowVectorPtr intVectors = makeRowVector(
+      {"c1", "c2", "c3"},
+      {
+          makeFlatVector<int16_t>(
+              {123,
+               std::numeric_limits<int8_t>::max(),
+               std::numeric_limits<int8_t>::min(),
+               std::numeric_limits<int16_t>::max(),
+               std::numeric_limits<int16_t>::min()}),
+          makeFlatVector<int32_t>(
+              {123,
+               std::numeric_limits<int16_t>::max(),
+               std::numeric_limits<int16_t>::min(),
+               std::numeric_limits<int32_t>::max(),
+               std::numeric_limits<int32_t>::min()}),
+          makeFlatVector<int32_t>(
+              {123,
+               std::numeric_limits<int8_t>::max(),
+               std::numeric_limits<int8_t>::min(),
+               std::numeric_limits<int32_t>::max(),
+               std::numeric_limits<int32_t>::min()}),
+      });
+
+  RowVectorPtr smallerIntVectors = makeRowVector(
+      {"c1", "c2", "c3"},
+      {
+          makeFlatVector<int8_t>({
+              123,
+              std::numeric_limits<int8_t>::max(),
+              std::numeric_limits<int8_t>::min(),
+              -1,
+              0,
+          }),
+          makeFlatVector<int16_t>({
+              123,
+              std::numeric_limits<int16_t>::max(),
+              std::numeric_limits<int16_t>::min(),
+              -1,
+              0,
+          }),
+          makeFlatVector<int8_t>({
+              123,
+              std::numeric_limits<int8_t>::max(),
+              std::numeric_limits<int8_t>::min(),
+              -1,
+              0,
+          }),
+      });
+
+  auto dataFile = TempFilePath::create();
+  WriterOptions options;
+  writeToParquetFile(dataFile->getPath(), {intVectors}, options);
+
+  auto rowType = ROW({"c1", "c2", "c3"}, {TINYINT(), SMALLINT(), TINYINT()});
+  auto op = PlanBuilder()
+                .startTableScan()
+                .outputType(rowType)
+                .dataColumns(rowType)
+                .endTableScan()
+                .planNode();
+
+  auto split = makeSplit(dataFile->getPath());
+  auto result =
+      AssertQueryBuilder(op)
+          .connectorSessionProperty(
+              kHiveConnectorId,
+              connector::hive::HiveConfig::kAllowInt32NarrowingSession,
+              "true")
+          .split(split)
+          .copyResults(pool());
+  auto rows = result->as<RowVector>();
+
+  assertEqualVectors(smallerIntVectors->childAt(0), rows->childAt(0));
+  assertEqualVectors(smallerIntVectors->childAt(1), rows->childAt(1));
+  assertEqualVectors(smallerIntVectors->childAt(2), rows->childAt(2));
+}
+
 TEST_F(ParquetTableScanTest, shortAndLongDecimalReadWithLargerPrecision) {
   // decimal.parquet holds two columns (a: DECIMAL(5, 2), b: DECIMAL(20, 5)) and
   // 20 rows (10 rows per group). Data is in plain uncompressed format:
@@ -1324,8 +1820,8 @@ TEST_F(ParquetTableScanTest, shortAndLongDecimalReadWithLargerPrecision) {
       {makeFlatVector<int64_t>(unscaledShortValues, DECIMAL(8, 2)),
        makeFlatVector<int128_t>(longDecimalValues, DECIMAL(22, 5))});
 
-  const std::shared_ptr<exec::test::TempDirectoryPath> dataFileFolder =
-      exec::test::TempDirectoryPath::create();
+  const std::shared_ptr<TempDirectoryPath> dataFileFolder =
+      TempDirectoryPath::create();
   auto filePath = getExampleFilePath("decimal.parquet");
 
   auto rowType = ROW({"c1", "c2"}, {DECIMAL(8, 2), DECIMAL(22, 5)});
@@ -1344,6 +1840,200 @@ TEST_F(ParquetTableScanTest, shortAndLongDecimalReadWithLargerPrecision) {
   assertEqualVectors(expectedDecimalVectors->childAt(1), rows->childAt(1));
 }
 
+TEST_F(ParquetTableScanTest, inFilter) {
+  auto vectors = {makeRowVector(
+      {"name"},
+      {
+          makeNullableFlatVector<std::string>(
+              {"mary", "martin", "lucy", "alex", std::nullopt, "mary", "dan"}),
+      })};
+  auto filePath = TempFilePath::create();
+  WriterOptions options;
+  writeToParquetFile(filePath->getPath(), vectors, options);
+  createDuckDbTable(vectors);
+
+  // Test in.
+  auto plan = PlanBuilder(pool_.get())
+                  .tableScan(
+                      ROW({"name"}, {VARCHAR()}),
+                      {"name in ('alex', 'leo', 'mary', null, 'victor')"},
+                      "")
+                  .planNode();
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .split(makeSplit(filePath->getPath()))
+      .assertResults(
+          "SELECT name FROM tmp where name in ('alex', 'leo', 'mary', null, 'victor')");
+
+  // Test not in.
+  plan = PlanBuilder(pool_.get())
+             .tableScan(
+                 ROW({"name"}, {VARCHAR()}),
+                 {"name not in ('alex', 'leo', 'mary', null, 'victor')"},
+                 "")
+             .planNode();
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .split(makeSplit(filePath->getPath()))
+      .assertResults(
+          "SELECT name FROM tmp where name not in ('alex', 'leo', 'mary', null, 'victor')");
+}
+
+TEST_F(ParquetTableScanTest, reusedLazyVectors) {
+  const std::vector<std::string> columnNames = {"a", "b"};
+  std::vector<RowVectorPtr> data;
+  for (auto row = 0; row < 10; ++row) {
+    data.emplace_back(makeRowVector(
+        columnNames,
+        {
+            makeFlatVector<int64_t>({static_cast<int64_t>(row % 5)}),
+            makeFlatVector<int64_t>({static_cast<int64_t>(row)}),
+        }));
+  }
+  const auto expectedRowVector = makeRowVector(
+      {makeFlatVector<int64_t>({0, 1, 2, 3, 4}),
+       makeFlatVector<int64_t>({5, 7, 9, 11, 13}),
+       makeFlatVector<int64_t>({5, 7, 9, 11, 13})});
+
+  const auto filePath = TempFilePath::create();
+  WriterOptions options;
+  writeToParquetFile(filePath->getPath(), data, options);
+
+  const auto plan = PlanBuilder()
+                        .tableScan(ROW(columnNames, {BIGINT(), BIGINT()}))
+                        .project({"a as c1", "b as c2", "b as c3"})
+                        .singleAggregation({"c1"}, {"sum(c2)", "sum(c3)"})
+                        .planNode();
+  AssertQueryBuilder(plan)
+      .split(makeSplit(filePath->getPath()))
+      .assertResults(expectedRowVector);
+}
+
+// Verify that entire Parquet files are pruned based on file-level column
+// statistics when the filter eliminates all data in the file.
+TEST_F(ParquetTableScanTest, statsBasedFileSkipping) {
+  WriterOptions options;
+  std::vector<std::string> filePaths;
+  std::vector<RowVectorPtr> dataVectors;
+  const vector_size_t numRows = 100;
+  filePaths.push_back(TempFilePath::create()->getPath());
+  dataVectors.push_back(makeRowVector(
+      {"c0", "c1", "c2"},
+      {
+          makeFlatVector<int64_t>(numRows, [](auto row) { return row; }),
+          makeFlatVector<double>(
+              numRows, [](auto row) { return static_cast<double>(row); }),
+          makeFlatVector<StringView>(
+              numRows,
+              [](auto row) {
+                static std::vector<StringView> values = {"a", "b", "c", "d"};
+                return values[row % values.size()];
+              }),
+      }));
+  // File 1: integers [0, 99], doubles [0.0, 99.0], strings ["a".."d"].
+  writeToParquetFile(filePaths.back(), dataVectors, options);
+
+  filePaths.push_back(TempFilePath::create()->getPath());
+  dataVectors.push_back(makeRowVector(
+      {"c0", "c1", "c2"},
+      {
+          makeFlatVector<int64_t>(numRows, [](auto row) { return row + 200; }),
+          makeFlatVector<double>(numRows, [](auto row) { return row + 200; }),
+          makeFlatVector<StringView>(
+              numRows,
+              [](auto row) {
+                static std::vector<StringView> values = {"p", "q", "r", "s"};
+                return values[row % values.size()];
+              }),
+      }));
+  // File 2: integers [200, 299], doubles [200.0, 299.0], strings ["p".."s"].
+  writeToParquetFile(filePaths.back(), {dataVectors.back()}, options);
+
+  createDuckDbTable(dataVectors);
+
+  auto makeSplits = [&]() {
+    std::vector<std::shared_ptr<connector::ConnectorSplit>> splits;
+    for (const auto& path : filePaths) {
+      splits.push_back(makeSplit(path));
+    }
+    return splits;
+  };
+
+  auto testFileSkipping = [&](const std::string& filter,
+                              int32_t expectedSkipped,
+                              int32_t expectedProcessed) {
+    SCOPED_TRACE(filter);
+    auto plan = PlanBuilder(pool_.get())
+                    .tableScan(dataVectors.back()->rowType(), {filter})
+                    .planNode();
+    auto task = AssertQueryBuilder(plan, duckDbQueryRunner_)
+                    .splits(makeSplits())
+                    .assertResults("SELECT * FROM tmp WHERE " + filter);
+    auto stats =
+        task->taskStats().pipelineStats[0].operatorStats[0].runtimeStats;
+    EXPECT_EQ(stats["skippedSplits"].sum, expectedSkipped);
+    EXPECT_EQ(stats["processedSplits"].sum, expectedProcessed);
+  };
+
+  // Neither file has values > 1000, both files skipped.
+  testFileSkipping("c0 > 1000", 2, 0);
+  // Neither file has values < 0, both files skipped.
+  testFileSkipping("c0 < 0", 2, 0);
+  // Low-range file (max=99) is skipped, high-range file is read.
+  testFileSkipping("c0 >= 200", 1, 1);
+  // High-range file (min=200) is skipped, low-range file is read.
+  testFileSkipping("c0 <= 99", 1, 1);
+  // Double column: both files skipped.
+  testFileSkipping("c1 > 500.0", 2, 0);
+  // String column: low-range has ["a".."d"], high-range has ["p".."s"], both
+  // skipped.
+  testFileSkipping("c2 = 'z'", 2, 0);
+  // Matches both files, no files skipped.
+  testFileSkipping("c0 >= 0", 0, 2);
+}
+
+TEST_F(ParquetTableScanTest, fileFormatRuntimeStats) {
+  auto rowType = ROW({"a", "b"}, {BIGINT(), DOUBLE()});
+  auto vector = makeRowVector(
+      {"a", "b"},
+      {
+          makeFlatVector<int64_t>(100, [](auto row) { return row; }),
+          makeFlatVector<double>(100, [](auto row) { return row * 1.5; }),
+      });
+  std::vector<RowVectorPtr> vectors = {vector};
+
+  // Write one Parquet file and one DWRF file.
+  auto parquetFile = TempFilePath::create();
+  WriterOptions parquetOptions;
+  parquetOptions.memoryPool = rootPool_.get();
+  writeToParquetFile(parquetFile->getPath(), vectors, parquetOptions);
+
+  auto dwrfFile = TempFilePath::create();
+  writeToFile(dwrfFile->getPath(), vectors);
+
+  // DuckDB reference table with data from both files.
+  std::vector<RowVectorPtr> allVectors = {vector, vector};
+  createDuckDbTable(allVectors);
+
+  auto parquetSplit = makeHiveConnectorSplits(
+      parquetFile->getPath(), 1, dwio::common::FileFormat::PARQUET);
+  auto dwrfSplit = makeHiveConnectorSplits(
+      dwrfFile->getPath(), 1, dwio::common::FileFormat::DWRF);
+
+  auto plan = PlanBuilder().tableScan(asRowType(vectors[0]->type())).planNode();
+
+  auto task = AssertQueryBuilder(plan, duckDbQueryRunner_)
+                  .splits({parquetSplit[0], dwrfSplit[0]})
+                  .assertResults("SELECT * FROM tmp");
+
+  auto stats = task->taskStats().pipelineStats[0].operatorStats[0].runtimeStats;
+  ASSERT_EQ(stats.count("fileFormat.parquet"), 1);
+  ASSERT_EQ(stats.at("fileFormat.parquet").sum, 1);
+  ASSERT_EQ(stats.count("fileFormat.dwrf"), 1);
+  ASSERT_EQ(stats.at("fileFormat.dwrf").sum, 1);
+
+  task.reset();
+  waitForAllTasksToBeDeleted();
+}
+
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   folly::Init init{&argc, &argv, false};
diff --git a/velox/dwio/parquet/tests/writer/CMakeLists.txt b/velox/dwio/parquet/tests/writer/CMakeLists.txt
index a6b9daec340..6948dbfcf70 100644
--- a/velox/dwio/parquet/tests/writer/CMakeLists.txt
+++ b/velox/dwio/parquet/tests/writer/CMakeLists.txt
@@ -26,7 +26,6 @@ target_link_libraries(
   velox_dwio_common_test_utils
   velox_vector_fuzzer
   velox_caching
-  Boost::regex
   velox_link_libs
   Folly::folly
   ${TEST_LINK_LIBS}
@@ -34,7 +33,7 @@ target_link_libraries(
   fmt::fmt
 )
 
-add_executable(velox_parquet_writer_test ParquetWriterTest.cpp)
+add_executable(velox_parquet_writer_test ParquetWriterFieldIdTest.cpp ParquetWriterTest.cpp)
 
 add_test(
   NAME velox_parquet_writer_test
@@ -44,12 +43,12 @@ add_test(
 
 target_link_libraries(
   velox_parquet_writer_test
+  velox_dwio_arrow_parquet_writer_test_lib
   velox_dwio_parquet_writer
   velox_dwio_parquet_reader
   velox_dwio_common_test_utils
   velox_caching
   velox_link_libs
-  Boost::regex
   Folly::folly
   ${TEST_LINK_LIBS}
   GTest::gtest
diff --git a/velox/dwio/parquet/tests/writer/ParquetWriterFieldIdTest.cpp b/velox/dwio/parquet/tests/writer/ParquetWriterFieldIdTest.cpp
new file mode 100644
index 00000000000..097dd14740c
--- /dev/null
+++ b/velox/dwio/parquet/tests/writer/ParquetWriterFieldIdTest.cpp
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/parquet/writer/arrow/tests/TestUtil.h"
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/dwio/parquet/tests/ParquetTestBase.h"
+#include "velox/dwio/parquet/writer/arrow/Schema.h"
+#include "velox/dwio/parquet/writer/arrow/tests/FileReader.h"
+
+namespace {
+
+using namespace facebook::velox;
+using namespace facebook::velox::dwio::common;
+using namespace facebook::velox::parquet;
+
+class ParquetWriterFieldIdTest : public ParquetTestBase,
+                                 public ::testing::WithParamInterface<bool> {};
+
+TEST_P(ParquetWriterFieldIdTest, fieldIds) {
+  auto schema =
+      ROW({"p", "s", "a", "m"},
+          {BIGINT(),
+           ROW({"x", "y"}, {INTEGER(), VARCHAR()}),
+           ARRAY(INTEGER()),
+           MAP(VARCHAR(), INTEGER())});
+  constexpr int32_t kRows = 10;
+  auto data = makeRowVector(
+      {"p", "s", "a", "m"},
+      {makeFlatVector<int64_t>(kRows, [](auto row) { return row; }),
+       makeRowVector(
+           {"x", "y"},
+           {makeFlatVector<int32_t>(kRows, [](auto row) { return row; }),
+            makeFlatVector<std::string>(kRows, [](auto) { return "z"; })}),
+       makeArrayVectorFromJson<int32_t>(std::vector<std::string>(kRows, "[3]")),
+       makeMapVectorFromJson<std::string, int32_t>(
+           std::vector<std::string>(kRows, R"({"k": 4})"))});
+
+  parquet::WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.get();
+
+  if (GetParam()) {
+    // Provide Parquet field IDs aligned with the Velox schema tree.
+    // p -> 10.
+    // s -> 20, children: x -> 21, y -> 22.
+    // a -> 30, list element -> 31.
+    // m -> 40, children: key -> 41, value -> 42.
+    writerOptions.parquetFieldIds = {
+        ParquetFieldId{10, {}},
+        ParquetFieldId{20, {ParquetFieldId{21, {}}, ParquetFieldId{22, {}}}},
+        ParquetFieldId{30, {ParquetFieldId{31, {}}}},
+        ParquetFieldId{40, {ParquetFieldId{41, {}}, ParquetFieldId{42, {}}}},
+    };
+  }
+
+  auto* sinkPtr = write(data, writerOptions);
+
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  auto parquetReader = createReaderInMemory(*sinkPtr, readerOptions);
+  EXPECT_EQ(parquetReader->numberOfRows(), kRows);
+  auto veloxRowType = parquetReader->rowType();
+  EXPECT_EQ(*veloxRowType, *schema);
+
+  std::string_view sinkData(sinkPtr->data(), sinkPtr->size());
+  auto arrowBufferReader = std::make_shared<::arrow::io::BufferReader>(
+      std::make_shared<::arrow::Buffer>(
+          reinterpret_cast<const uint8_t*>(sinkData.data()), sinkData.size()));
+
+  auto fileReader = parquet::arrow::ParquetFileReader::open(arrowBufferReader);
+  auto metadata = fileReader->metadata();
+  auto* descr = metadata->schema();
+  auto* root = descr->groupNode();
+
+  ASSERT_EQ(root->fieldCount(), 4);
+
+  auto exp = [&](int32_t expectedFieldId) {
+    return GetParam() ? expectedFieldId : -1;
+  };
+
+  // Top-level field IDs.
+  EXPECT_EQ(root->field(0)->fieldId(), exp(10));
+  EXPECT_EQ(root->field(1)->fieldId(), exp(20));
+  EXPECT_EQ(root->field(2)->fieldId(), exp(30));
+  EXPECT_EQ(root->field(3)->fieldId(), exp(40));
+
+  using GroupNode = parquet::arrow::schema::GroupNode;
+  auto* s = static_cast<const GroupNode*>(root->field(1).get());
+  EXPECT_EQ(s->field(0)->fieldId(), exp(21));
+  EXPECT_EQ(s->field(1)->fieldId(), exp(22));
+
+  auto* a = static_cast<const GroupNode*>(root->field(2).get());
+  // LIST logical group has one repeated child (the array entries); dive once
+  // more to the element.
+  auto* listEntries = a->field(0).get();
+  auto* listGroup = static_cast<const GroupNode*>(listEntries);
+  auto* element = listGroup->field(0).get();
+  EXPECT_EQ(element->fieldId(), exp(31));
+
+  auto* m = static_cast<const GroupNode*>(root->field(3).get());
+  auto* keyValue = m->field(0).get();
+  auto* keyValueGroup = static_cast<const GroupNode*>(keyValue);
+  EXPECT_EQ(keyValueGroup->field(0)->fieldId(), exp(41));
+  EXPECT_EQ(keyValueGroup->field(1)->fieldId(), exp(42));
+}
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    ParquetWriterFieldIdTest,
+    ParquetWriterFieldIdTest,
+    ::testing::Values(false, true));
+
+} // namespace
diff --git a/velox/dwio/parquet/tests/writer/ParquetWriterTest.cpp b/velox/dwio/parquet/tests/writer/ParquetWriterTest.cpp
index d22cbba6389..7d61caf4778 100644
--- a/velox/dwio/parquet/tests/writer/ParquetWriterTest.cpp
+++ b/velox/dwio/parquet/tests/writer/ParquetWriterTest.cpp
@@ -19,18 +19,20 @@
 #include "velox/dwio/parquet/writer/arrow/tests/TestUtil.h"
 
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/common/testutil/TestValue.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/hive/HiveConnector.h" // @manual
 #include "velox/core/QueryCtx.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/dwio/parquet/RegisterParquetWriter.h" // @manual
 #include "velox/dwio/parquet/reader/PageReader.h"
 #include "velox/dwio/parquet/tests/ParquetTestBase.h"
+#include "velox/dwio/parquet/writer/WriterConfig.h"
 #include "velox/exec/Cursor.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/exec/tests/utils/QueryAssertions.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 namespace {
 
@@ -39,6 +41,7 @@ using namespace facebook::velox::common;
 using namespace facebook::velox::dwio::common;
 using namespace facebook::velox::exec::test;
 using namespace facebook::velox::parquet;
+using namespace facebook::velox::common::testutil;
 
 class ParquetWriterTest : public ParquetTestBase {
  protected:
@@ -51,10 +54,15 @@ class ParquetWriterTest : public ParquetTestBase {
         kHiveConnectorId,
         std::make_shared<config::ConfigBase>(
             std::unordered_map<std::string, std::string>()));
-    connector::registerConnector(hiveConnector);
+    connector::ConnectorRegistry::global().insert(
+        hiveConnector->connectorId(), hiveConnector);
     parquet::registerParquetWriterFactory();
   }
 
+  void TearDown() override {
+    writers_.clear();
+  }
+
   std::unique_ptr<RowReader> createRowReaderWithSchema(
       const std::unique_ptr<Reader> reader,
       const RowTypePtr& rowType) {
@@ -63,20 +71,52 @@ class ParquetWriterTest : public ParquetTestBase {
     rowReaderOpts.setScanSpec(scanSpec);
     auto rowReader = reader->createRowReader(rowReaderOpts);
     return rowReader;
-  };
+  }
 
-  std::unique_ptr<facebook::velox::parquet::ParquetReader> createReaderInMemory(
-      const dwio::common::MemorySink& sink,
-      const dwio::common::ReaderOptions& opts) {
-    std::string data(sink.data(), sink.size());
-    return std::make_unique<facebook::velox::parquet::ParquetReader>(
-        std::make_unique<dwio::common::BufferedInput>(
-            std::make_shared<InMemoryReadFile>(std::move(data)),
-            opts.memoryPool()),
-        opts);
-  };
+  RowVectorPtr makeSmallintTestData(int64_t rows) {
+    auto data = makeRowVector({
+        makeFlatVector<int16_t>(rows, [](auto row) { return row + 1; }),
+    });
+    return data;
+  }
+
+  RowVectorPtr makeTimestampTestData(int64_t rows) {
+    auto data = makeRowVector({makeFlatVector<Timestamp>(
+        rows, [](auto row) { return Timestamp(row, row); })});
+    return data;
+  }
+
+  thrift::PageHeader readPageHeader(
+      MemorySink* sinkPtr,
+      int64_t offsetFromDataPage) {
+    dwio::common::ReaderOptions readerOptions(leafPool_.get());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
+    auto reader = createReaderInMemory(*sinkPtr, readerOptions);
+
+    auto colChunkPtr = reader->fileMetaData().rowGroup(0).columnChunk(0);
+    std::string_view sinkData(sinkPtr->data(), sinkPtr->size());
+
+    auto readFile = std::make_shared<InMemoryReadFile>(sinkData);
+    auto file = std::make_shared<ReadFileInputStream>(std::move(readFile));
+
+    auto inputStream = std::make_unique<SeekableFileInputStream>(
+        std::move(file),
+        colChunkPtr.dataPageOffset() + offsetFromDataPage,
+        150,
+        *leafPool_,
+        LogType::TEST);
+    auto pageReader = std::make_unique<PageReader>(
+        std::move(inputStream),
+        *leafPool_,
+        colChunkPtr.compression(),
+        colChunkPtr.totalCompressedSize(),
+        stats);
+    return pageReader->readPageHeader();
+  }
 
   inline static const std::string kHiveConnectorId = "test-hive";
+  dwio::common::ColumnReaderStatistics stats;
 };
 
 class ArrowMemoryPool final : public ::arrow::MemoryPool {
@@ -147,76 +187,24 @@ std::vector<CompressionKind> params = {
 };
 
 TEST_F(ParquetWriterTest, dictionaryEncodingWithDictionaryPageSize) {
-  const auto schema = ROW({"c0"}, {SMALLINT()});
   constexpr int64_t kRows = 10'000;
-  const auto data = makeRowVector({
-      makeFlatVector<int16_t>(kRows, [](auto row) { return row + 1; }),
-  });
+  const auto data = makeSmallintTestData(kRows);
 
   // Write Parquet test data, then read and return the DataPage
   // (thrift::PageType::type) used.
   const auto testEnableDictionaryAndDictionaryPageSizeToGetPageHeader =
       [&](std::unordered_map<std::string, std::string> configFromFile,
           std::unordered_map<std::string, std::string> sessionProperties,
-          bool isFirstPageOrSecondPage) {
-        // Create an in-memory writer.
-        auto sink = std::make_unique<MemorySink>(
-            200 * 1024 * 1024,
-            dwio::common::FileSink::Options{.pool = leafPool_.get()});
-        auto sinkPtr = sink.get();
-        parquet::WriterOptions writerOptions;
-        writerOptions.memoryPool = leafPool_.get();
-
-        auto connectorConfig = config::ConfigBase(std::move(configFromFile));
-        auto connectorSessionProperties =
-            config::ConfigBase(std::move(sessionProperties));
-
-        writerOptions.processConfigs(
-            connectorConfig, connectorSessionProperties);
-        auto writer = std::make_unique<parquet::Writer>(
-            std::move(sink), writerOptions, rootPool_, schema);
-        writer->write(data);
-        writer->close();
-
-        // Read to identify DataPage used.
-        dwio::common::ReaderOptions readerOptions{leafPool_.get()};
-        auto reader = createReaderInMemory(*sinkPtr, readerOptions);
-
-        auto colChunkPtr = reader->fileMetaData().rowGroup(0).columnChunk(0);
-        std::string_view sinkData(sinkPtr->data(), sinkPtr->size());
-
-        auto readFile = std::make_shared<InMemoryReadFile>(sinkData);
-        auto file = std::make_shared<ReadFileInputStream>(std::move(readFile));
-
-        if (isFirstPageOrSecondPage) {
-          auto inputStream = std::make_unique<SeekableFileInputStream>(
-              std::move(file),
-              colChunkPtr.dataPageOffset(),
-              150,
-              *leafPool_,
-              LogType::TEST);
-          auto pageReader = std::make_unique<PageReader>(
-              std::move(inputStream),
-              *leafPool_,
-              colChunkPtr.compression(),
-              colChunkPtr.totalCompressedSize());
-          return pageReader->readPageHeader();
+          bool isFirstPage) {
+        auto* sinkPtr = write(
+            data, std::move(configFromFile), std::move(sessionProperties));
+        if (isFirstPage) {
+          return readPageHeader(sinkPtr, 0);
         }
         constexpr int64_t kFirstDataPageCompressedSize = 1291;
         constexpr int64_t kFirstDataPageHeaderSize = 48;
-        auto inputStream = std::make_unique<SeekableFileInputStream>(
-            std::move(file),
-            colChunkPtr.dataPageOffset() + kFirstDataPageCompressedSize +
-                kFirstDataPageHeaderSize,
-            150,
-            *leafPool_,
-            LogType::TEST);
-        auto pageReader = std::make_unique<PageReader>(
-            std::move(inputStream),
-            *leafPool_,
-            colChunkPtr.compression(),
-            colChunkPtr.totalCompressedSize());
-        return pageReader->readPageHeader();
+        return readPageHeader(
+            sinkPtr, kFirstDataPageCompressedSize + kFirstDataPageHeaderSize);
       };
 
   // Test default config (i.e., no explicit config)
@@ -247,13 +235,16 @@ TEST_F(ParquetWriterTest, dictionaryEncodingWithDictionaryPageSize) {
   // page size limit, the default is 1MB (same as data page default size) then
   // there will be only one data page contains all data encoded with dictionary
   const std::unordered_map<std::string, std::string> normalConfigFromFile = {
-      {parquet::WriterOptions::kParquetHiveConnectorEnableDictionary, "true"},
-      {parquet::WriterOptions::kParquetHiveConnectorDictionaryPageSizeLimit,
+      {config::ConfigBase::toConfigKey(
+           parquet::WriterConfig::kParquetSessionEnableDictionary),
+       "true"},
+      {config::ConfigBase::toConfigKey(
+           parquet::WriterConfig::kParquetSessionDictionaryPageSizeLimit),
        "1B"},
   };
   const std::unordered_map<std::string, std::string> normalSessionProperties = {
-      {parquet::WriterOptions::kParquetSessionEnableDictionary, "true"},
-      {parquet::WriterOptions::kParquetSessionDictionaryPageSizeLimit, "1B"},
+      {parquet::WriterConfig::kParquetSessionEnableDictionary, "true"},
+      {parquet::WriterConfig::kParquetSessionDictionaryPageSizeLimit, "1B"},
   };
 
   // Here we are reading the second data page. If we don't set the dictionary
@@ -273,12 +264,13 @@ TEST_F(ParquetWriterTest, dictionaryEncodingWithDictionaryPageSize) {
   const std::string invalidEnableDictionaryValue{"NaB"};
   const std::unordered_map<std::string, std::string>
       incorrectEnableDictionaryConfigFromFile = {
-          {parquet::WriterOptions::kParquetHiveConnectorEnableDictionary,
+          {config::ConfigBase::toConfigKey(
+               parquet::WriterConfig::kParquetSessionEnableDictionary),
            invalidEnableDictionaryValue},
       };
   const std::unordered_map<std::string, std::string>
       incorrectEnableDictionarySessionProperties = {
-          {parquet::WriterOptions::kParquetSessionEnableDictionary,
+          {parquet::WriterConfig::kParquetSessionEnableDictionary,
            invalidEnableDictionaryValue},
       };
 
@@ -297,12 +289,13 @@ TEST_F(ParquetWriterTest, dictionaryEncodingWithDictionaryPageSize) {
   const std::string invalidDictionaryPageSizeValue{"NaN"};
   const std::unordered_map<std::string, std::string>
       incorrectDictionaryPageSizeConfigFromFile = {
-          {parquet::WriterOptions::kParquetHiveConnectorDictionaryPageSizeLimit,
+          {config::ConfigBase::toConfigKey(
+               parquet::WriterConfig::kParquetSessionDictionaryPageSizeLimit),
            invalidDictionaryPageSizeValue},
       };
   const std::unordered_map<std::string, std::string>
       incorrectDictionaryPageSizeSessionProperties = {
-          {parquet::WriterOptions::kParquetSessionDictionaryPageSizeLimit,
+          {parquet::WriterConfig::kParquetSessionDictionaryPageSizeLimit,
            invalidDictionaryPageSizeValue},
       };
 
@@ -317,70 +310,30 @@ TEST_F(ParquetWriterTest, dictionaryEncodingWithDictionaryPageSize) {
 }
 
 TEST_F(ParquetWriterTest, dictionaryEncodingOff) {
-  const auto schema = ROW({"c0"}, {SMALLINT()});
   constexpr int64_t kRows = 10'000;
-  const auto data = makeRowVector({
-      makeFlatVector<int16_t>(kRows, [](auto row) { return row + 1; }),
-  });
+  const auto data = makeSmallintTestData(kRows);
 
   // Write Parquet test data, then read and return the DataPage
   // (thrift::PageType::type) used.
   const auto testEnableDictionaryAndDictionaryPageSizeToGetPageHeader =
       [&](std::unordered_map<std::string, std::string> configFromFile,
           std::unordered_map<std::string, std::string> sessionProperties) {
-        // Create an in-memory writer.
-        auto sink = std::make_unique<MemorySink>(
-            200 * 1024 * 1024,
-            dwio::common::FileSink::Options{.pool = leafPool_.get()});
-        auto sinkPtr = sink.get();
-        parquet::WriterOptions writerOptions;
-        writerOptions.memoryPool = leafPool_.get();
-
-        auto connectorConfig = config::ConfigBase(std::move(configFromFile));
-        auto connectorSessionProperties =
-            config::ConfigBase(std::move(sessionProperties));
-
-        writerOptions.processConfigs(
-            connectorConfig, connectorSessionProperties);
-        auto writer = std::make_unique<parquet::Writer>(
-            std::move(sink), writerOptions, rootPool_, schema);
-        writer->write(data);
-        writer->close();
-
-        // Read to identify DataPage used.
-        dwio::common::ReaderOptions readerOptions{leafPool_.get()};
-        auto reader = createReaderInMemory(*sinkPtr, readerOptions);
-
-        auto colChunkPtr = reader->fileMetaData().rowGroup(0).columnChunk(0);
-        std::string_view sinkData(sinkPtr->data(), sinkPtr->size());
-
-        auto readFile = std::make_shared<InMemoryReadFile>(sinkData);
-        auto file = std::make_shared<ReadFileInputStream>(std::move(readFile));
-
-        auto inputStream = std::make_unique<SeekableFileInputStream>(
-            std::move(file),
-            colChunkPtr.dataPageOffset(),
-            150,
-            *leafPool_,
-            LogType::TEST);
-        auto pageReader = std::make_unique<PageReader>(
-            std::move(inputStream),
-            *leafPool_,
-            colChunkPtr.compression(),
-            colChunkPtr.totalCompressedSize());
-        return pageReader->readPageHeader();
+        auto* sinkPtr = write(
+            data, std::move(configFromFile), std::move(sessionProperties));
+        return readPageHeader(sinkPtr, 0);
       };
 
   // Test only dictionary off without dictionary page size configured
 
   const std::unordered_map<std::string, std::string>
       withoutPageSizeConfigFromFile = {
-          {parquet::WriterOptions::kParquetHiveConnectorEnableDictionary,
+          {config::ConfigBase::toConfigKey(
+               parquet::WriterConfig::kParquetSessionEnableDictionary),
            "false"},
       };
   const std::unordered_map<std::string, std::string>
       withoutPageSizeSessionProperties = {
-          {parquet::WriterOptions::kParquetSessionEnableDictionary, "false"},
+          {parquet::WriterConfig::kParquetSessionEnableDictionary, "false"},
       };
 
   const auto withoutPageSizeHeader =
@@ -401,16 +354,17 @@ TEST_F(ParquetWriterTest, dictionaryEncodingOff) {
 
   const std::unordered_map<std::string, std::string>
       withPageSizeConfigFromFile = {
-          {parquet::WriterOptions::kParquetHiveConnectorEnableDictionary,
+          {config::ConfigBase::toConfigKey(
+               parquet::WriterConfig::kParquetSessionEnableDictionary),
            "false"},
-          {parquet::WriterOptions::kParquetHiveConnectorDictionaryPageSizeLimit,
+          {config::ConfigBase::toConfigKey(
+               parquet::WriterConfig::kParquetSessionDictionaryPageSizeLimit),
            "1B"},
       };
   const std::unordered_map<std::string, std::string>
       withPageSizeSessionProperties = {
-          {parquet::WriterOptions::kParquetSessionEnableDictionary, "false"},
-          {parquet::WriterOptions::kParquetSessionDictionaryPageSizeLimit,
-           "1B"},
+          {parquet::WriterConfig::kParquetSessionEnableDictionary, "false"},
+          {parquet::WriterConfig::kParquetSessionDictionaryPageSizeLimit, "1B"},
       };
 
   const auto withPageSizeHeader =
@@ -446,27 +400,20 @@ TEST_F(ParquetWriterTest, compression) {
       makeFlatVector<double>(kRows, [](auto row) { return row - 25; }),
   });
 
-  // Create an in-memory writer
-  auto sink = std::make_unique<MemorySink>(
-      200 * 1024 * 1024,
-      dwio::common::FileSink::Options{.pool = leafPool_.get()});
-  auto sinkPtr = sink.get();
-  facebook::velox::parquet::WriterOptions writerOptions;
-  writerOptions.memoryPool = leafPool_.get();
+  parquet::WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.get();
   writerOptions.compressionKind = CompressionKind::CompressionKind_SNAPPY;
 
   const auto& fieldNames = schema->names();
-
   for (int i = 0; i < params.size(); i++) {
     writerOptions.columnCompressionsMap[fieldNames[i]] = params[i];
   }
 
-  auto writer = std::make_unique<facebook::velox::parquet::Writer>(
-      std::move(sink), writerOptions, rootPool_, schema);
-  writer->write(data);
-  writer->close();
+  auto* sinkPtr = write(data, writerOptions);
 
-  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto reader = createReaderInMemory(*sinkPtr, readerOptions);
 
   ASSERT_EQ(reader->numberOfRows(), kRows);
@@ -481,61 +428,20 @@ TEST_F(ParquetWriterTest, compression) {
 
   auto rowReader = createRowReaderWithSchema(std::move(reader), schema);
   assertReadWithReaderAndExpected(schema, *rowReader, data, *leafPool_);
-};
+}
 
 TEST_F(ParquetWriterTest, testPageSizeAndBatchSizeConfiguration) {
-  const auto schema = ROW({"c0"}, {SMALLINT()});
   constexpr int64_t kRows = 10'000;
-  const auto data = makeRowVector({
-      makeFlatVector<int16_t>(kRows, [](auto row) { return row + 1; }),
-  });
+  const auto data = makeSmallintTestData(kRows);
 
   // Write Parquet test data, then read and return the DataPage
   // (thrift::PageType::type) used.
   const auto testPageSizeAndBatchSizeToGetPageHeader =
       [&](std::unordered_map<std::string, std::string> configFromFile,
           std::unordered_map<std::string, std::string> sessionProperties) {
-        // Create an in-memory writer.
-        auto sink = std::make_unique<MemorySink>(
-            200 * 1024 * 1024,
-            dwio::common::FileSink::Options{.pool = leafPool_.get()});
-        auto sinkPtr = sink.get();
-        parquet::WriterOptions writerOptions;
-        writerOptions.memoryPool = leafPool_.get();
-
-        auto connectorConfig = config::ConfigBase(std::move(configFromFile));
-        auto connectorSessionProperties =
-            config::ConfigBase(std::move(sessionProperties));
-
-        writerOptions.processConfigs(
-            connectorConfig, connectorSessionProperties);
-        auto writer = std::make_unique<parquet::Writer>(
-            std::move(sink), writerOptions, rootPool_, schema);
-        writer->write(data);
-        writer->close();
-
-        // Read to identify DataPage used.
-        dwio::common::ReaderOptions readerOptions{leafPool_.get()};
-        auto reader = createReaderInMemory(*sinkPtr, readerOptions);
-
-        auto colChunkPtr = reader->fileMetaData().rowGroup(0).columnChunk(0);
-        std::string_view sinkData(sinkPtr->data(), sinkPtr->size());
-
-        auto readFile = std::make_shared<InMemoryReadFile>(sinkData);
-        auto file = std::make_shared<ReadFileInputStream>(std::move(readFile));
-
-        auto inputStream = std::make_unique<SeekableFileInputStream>(
-            std::move(file),
-            colChunkPtr.dataPageOffset(),
-            150,
-            *leafPool_,
-            LogType::TEST);
-        auto pageReader = std::make_unique<PageReader>(
-            std::move(inputStream),
-            *leafPool_,
-            colChunkPtr.compression(),
-            colChunkPtr.totalCompressedSize());
-        return pageReader->readPageHeader();
+        auto* sinkPtr = write(
+            data, std::move(configFromFile), std::move(sessionProperties));
+        return readPageHeader(sinkPtr, 0);
       };
 
   // Test default config (i.e., no explicit config)
@@ -564,12 +470,16 @@ TEST_F(ParquetWriterTest, testPageSizeAndBatchSizeConfiguration) {
   // of values in each page can be divided by 97, it means the batch size is
   // applied (default is 1024)
   const std::unordered_map<std::string, std::string> normalConfigFromFile = {
-      {parquet::WriterOptions::kParquetHiveConnectorWritePageSize, "2KB"},
-      {parquet::WriterOptions::kParquetHiveConnectorWriteBatchSize, "97"},
+      {config::ConfigBase::toConfigKey(
+           parquet::WriterConfig::kParquetSessionWritePageSize),
+       "2KB"},
+      {config::ConfigBase::toConfigKey(
+           parquet::WriterConfig::kParquetSessionWriteBatchSize),
+       "97"},
   };
   const std::unordered_map<std::string, std::string> normalSessionProperties = {
-      {parquet::WriterOptions::kParquetSessionWritePageSize, "2KB"},
-      {parquet::WriterOptions::kParquetSessionWriteBatchSize, "97"},
+      {parquet::WriterConfig::kParquetSessionWritePageSize, "2KB"},
+      {parquet::WriterConfig::kParquetSessionWriteBatchSize, "97"},
   };
   const auto normalHeader = testPageSizeAndBatchSizeToGetPageHeader(
       normalConfigFromFile, normalSessionProperties);
@@ -588,12 +498,13 @@ TEST_F(ParquetWriterTest, testPageSizeAndBatchSizeConfiguration) {
   const std::string invalidPageSizeAndBatchSizeValue{"NaN"};
   const std::unordered_map<std::string, std::string>
       incorrectPageSizeConfigFromFile = {
-          {parquet::WriterOptions::kParquetHiveConnectorWritePageSize,
+          {config::ConfigBase::toConfigKey(
+               parquet::WriterConfig::kParquetSessionWritePageSize),
            invalidPageSizeAndBatchSizeValue},
       };
   const std::unordered_map<std::string, std::string>
       incorrectPageSizeSessionPropertiesFromFile = {
-          {parquet::WriterOptions::kParquetSessionWritePageSize,
+          {parquet::WriterConfig::kParquetSessionWritePageSize,
            invalidPageSizeAndBatchSizeValue},
       };
 
@@ -609,12 +520,13 @@ TEST_F(ParquetWriterTest, testPageSizeAndBatchSizeConfiguration) {
 
   const std::unordered_map<std::string, std::string>
       incorrectBatchSizeConfigFromFile = {
-          {parquet::WriterOptions::kParquetHiveConnectorWriteBatchSize,
+          {config::ConfigBase::toConfigKey(
+               parquet::WriterConfig::kParquetSessionWriteBatchSize),
            invalidPageSizeAndBatchSizeValue},
       };
   const std::unordered_map<std::string, std::string>
       incorrectBatchSizeSessionPropertiesFromFile = {
-          {parquet::WriterOptions::kParquetSessionWriteBatchSize,
+          {parquet::WriterConfig::kParquetSessionWriteBatchSize,
            invalidPageSizeAndBatchSizeValue},
       };
 
@@ -629,7 +541,6 @@ TEST_F(ParquetWriterTest, testPageSizeAndBatchSizeConfiguration) {
 }
 
 TEST_F(ParquetWriterTest, toggleDataPageVersion) {
-  auto schema = ROW({"c0"}, {INTEGER()});
   const int64_t kRows = 1;
   const auto data = makeRowVector({
       makeFlatVector<int32_t>(kRows, [](auto row) { return 987; }),
@@ -640,50 +551,9 @@ TEST_F(ParquetWriterTest, toggleDataPageVersion) {
   const auto testDataPageVersion =
       [&](std::unordered_map<std::string, std::string> configFromFile,
           std::unordered_map<std::string, std::string> sessionProperties) {
-        // Create an in-memory writer.
-        auto sink = std::make_unique<MemorySink>(
-            200 * 1024 * 1024,
-            dwio::common::FileSink::Options{.pool = leafPool_.get()});
-        auto sinkPtr = sink.get();
-        parquet::WriterOptions writerOptions;
-        writerOptions.memoryPool = leafPool_.get();
-
-        // Simulate setting of Hive config & connector session properties, then
-        // write test data.
-        auto connectorConfig = config::ConfigBase(std::move(configFromFile));
-        auto connectorSessionProperties =
-            config::ConfigBase(std::move(sessionProperties));
-
-        writerOptions.processConfigs(
-            connectorConfig, connectorSessionProperties);
-        auto writer = std::make_unique<parquet::Writer>(
-            std::move(sink), writerOptions, rootPool_, schema);
-        writer->write(data);
-        writer->close();
-
-        // Read to identify DataPage used.
-        dwio::common::ReaderOptions readerOptions{leafPool_.get()};
-        auto reader = createReaderInMemory(*sinkPtr, readerOptions);
-
-        auto colChunkPtr = reader->fileMetaData().rowGroup(0).columnChunk(0);
-        std::string_view sinkData(sinkPtr->data(), sinkPtr->size());
-
-        auto readFile = std::make_shared<InMemoryReadFile>(sinkData);
-        auto file = std::make_shared<ReadFileInputStream>(std::move(readFile));
-
-        auto inputStream = std::make_unique<SeekableFileInputStream>(
-            std::move(file),
-            colChunkPtr.dataPageOffset(),
-            150,
-            *leafPool_,
-            LogType::TEST);
-        auto pageReader = std::make_unique<PageReader>(
-            std::move(inputStream),
-            *leafPool_,
-            colChunkPtr.compression(),
-            colChunkPtr.totalCompressedSize());
-
-        return pageReader->readPageHeader().type;
+        auto* sinkPtr = write(
+            data, std::move(configFromFile), std::move(sessionProperties));
+        return readPageHeader(sinkPtr, 0).type;
       };
 
   // Test default behavior - DataPage should be V1.
@@ -691,7 +561,9 @@ TEST_F(ParquetWriterTest, toggleDataPageVersion) {
 
   // Simulate setting DataPage version to V2 via Hive config from file.
   std::unordered_map<std::string, std::string> configFromFile = {
-      {parquet::WriterOptions::kParquetHiveConnectorDataPageVersion, "V2"}};
+      {config::ConfigBase::toConfigKey(
+           parquet::WriterConfig::kParquetSessionDataPageVersion),
+       "V2"}};
 
   ASSERT_EQ(
       testDataPageVersion(configFromFile, {}),
@@ -699,7 +571,9 @@ TEST_F(ParquetWriterTest, toggleDataPageVersion) {
 
   // Simulate setting DataPage version to V1 via Hive config from file.
   configFromFile = {
-      {parquet::WriterOptions::kParquetHiveConnectorDataPageVersion, "V1"}};
+      {config::ConfigBase::toConfigKey(
+           parquet::WriterConfig::kParquetSessionDataPageVersion),
+       "V1"}};
 
   ASSERT_EQ(
       testDataPageVersion(configFromFile, {}),
@@ -707,7 +581,7 @@ TEST_F(ParquetWriterTest, toggleDataPageVersion) {
 
   // Simulate setting DataPage version to V2 via connector session property.
   std::unordered_map<std::string, std::string> sessionProperties = {
-      {parquet::WriterOptions::kParquetSessionDataPageVersion, "V2"}};
+      {parquet::WriterConfig::kParquetSessionDataPageVersion, "V2"}};
 
   ASSERT_EQ(
       testDataPageVersion({}, sessionProperties),
@@ -715,7 +589,7 @@ TEST_F(ParquetWriterTest, toggleDataPageVersion) {
 
   // Simulate setting DataPage version to V1 via connector session property.
   sessionProperties = {
-      {parquet::WriterOptions::kParquetSessionDataPageVersion, "V1"}};
+      {parquet::WriterConfig::kParquetSessionDataPageVersion, "V1"}};
 
   ASSERT_EQ(
       testDataPageVersion({}, sessionProperties),
@@ -725,9 +599,11 @@ TEST_F(ParquetWriterTest, toggleDataPageVersion) {
   // and to V2 via Hive config from file. Session property should take
   // precedence.
   sessionProperties = {
-      {parquet::WriterOptions::kParquetSessionDataPageVersion, "V1"}};
+      {parquet::WriterConfig::kParquetSessionDataPageVersion, "V1"}};
   configFromFile = {
-      {parquet::WriterOptions::kParquetHiveConnectorDataPageVersion, "V2"}};
+      {config::ConfigBase::toConfigKey(
+           parquet::WriterConfig::kParquetSessionDataPageVersion),
+       "V2"}};
 
   ASSERT_EQ(
       testDataPageVersion({}, sessionProperties),
@@ -737,9 +613,11 @@ TEST_F(ParquetWriterTest, toggleDataPageVersion) {
   // and to V1 via Hive config from file. Session property should take
   // precedence.
   sessionProperties = {
-      {parquet::WriterOptions::kParquetSessionDataPageVersion, "V2"}};
+      {parquet::WriterConfig::kParquetSessionDataPageVersion, "V2"}};
   configFromFile = {
-      {parquet::WriterOptions::kParquetHiveConnectorDataPageVersion, "V1"}};
+      {config::ConfigBase::toConfigKey(
+           parquet::WriterConfig::kParquetSessionDataPageVersion),
+       "V1"}};
 
   ASSERT_EQ(
       testDataPageVersion({}, sessionProperties),
@@ -758,22 +636,14 @@ DEBUG_ONLY_TEST_F(ParquetWriterTest, unitFromWriterOptions) {
             ASSERT_EQ(tsType->timezone(), "America/Los_Angeles");
           })));
 
-  const auto data = makeRowVector({makeFlatVector<Timestamp>(
-      10'000, [](auto row) { return Timestamp(row, row); })});
+  const auto data = makeTimestampTestData(10'000);
   parquet::WriterOptions writerOptions;
-  writerOptions.memoryPool = leafPool_.get();
+  writerOptions.memoryPool = rootPool_.get();
   writerOptions.parquetWriteTimestampUnit = TimestampPrecision::kMicroseconds;
   writerOptions.parquetWriteTimestampTimeZone = "America/Los_Angeles";
 
-  // Create an in-memory writer.
-  auto sink = std::make_unique<MemorySink>(
-      200 * 1024 * 1024,
-      dwio::common::FileSink::Options{.pool = leafPool_.get()});
-  auto writer = std::make_unique<parquet::Writer>(
-      std::move(sink), writerOptions, rootPool_, ROW({"c0"}, {TIMESTAMP()}));
-  writer->write(data);
-  writer->close();
-};
+  write(data, writerOptions);
+}
 
 DEBUG_ONLY_TEST_F(ParquetWriterTest, parquetWriteTimestampTimeZoneWithDefault) {
   SCOPED_TESTVALUE_SET(
@@ -787,42 +657,28 @@ DEBUG_ONLY_TEST_F(ParquetWriterTest, parquetWriteTimestampTimeZoneWithDefault) {
             ASSERT_EQ(tsType->timezone(), "");
           })));
 
-  const auto data = makeRowVector({makeFlatVector<Timestamp>(
-      10'000, [](auto row) { return Timestamp(row, row); })});
+  const auto data = makeTimestampTestData(10'000);
   parquet::WriterOptions writerOptions;
-  writerOptions.memoryPool = leafPool_.get();
+  writerOptions.memoryPool = rootPool_.get();
   writerOptions.parquetWriteTimestampUnit = TimestampPrecision::kMicroseconds;
 
-  // Create an in-memory writer.
-  auto sink = std::make_unique<MemorySink>(
-      200 * 1024 * 1024,
-      dwio::common::FileSink::Options{.pool = leafPool_.get()});
-  auto writer = std::make_unique<parquet::Writer>(
-      std::move(sink), writerOptions, rootPool_, ROW({"c0"}, {TIMESTAMP()}));
-  writer->write(data);
-  writer->close();
-};
+  write(data, writerOptions);
+}
 
 TEST_F(ParquetWriterTest, parquetWriteWithArrowMemoryPool) {
-  const auto data = makeRowVector({makeFlatVector<Timestamp>(
-      10'000, [](auto row) { return Timestamp(row, row); })});
+  const auto data = makeTimestampTestData(10'000);
   parquet::WriterOptions writerOptions;
-  writerOptions.memoryPool = leafPool_.get();
+  writerOptions.memoryPool = rootPool_.get();
   writerOptions.arrowMemoryPool = std::make_shared<ArrowMemoryPool>();
 
-  // Create an in-memory writer.
-  auto sink = std::make_unique<MemorySink>(
-      200 * 1024 * 1024,
-      dwio::common::FileSink::Options{.pool = leafPool_.get()});
-  auto writer = std::make_unique<parquet::Writer>(
-      std::move(sink), writerOptions, rootPool_, ROW({"c0"}, {TIMESTAMP()}));
-  writer->write(data);
-  writer->close();
-};
+  write(data, writerOptions);
+}
 
 TEST_F(ParquetWriterTest, updateWriterOptionsFromHiveConfig) {
   std::unordered_map<std::string, std::string> configFromFile = {
-      {parquet::WriterOptions::kParquetSessionWriteTimestampUnit, "3"}};
+      {config::ConfigBase::toConfigKey(
+           parquet::WriterConfig::kParquetSessionWriteTimestampUnit),
+       "3"}};
   const config::ConfigBase connectorConfig(std::move(configFromFile));
   const config::ConfigBase connectorSessionProperties({});
 
@@ -906,20 +762,6 @@ TEST_F(ParquetWriterTest, dictionaryEncodedVector) {
         return wrappedVectors;
       };
 
-  const auto writeToFile = [this](const RowVectorPtr& data) {
-    parquet::WriterOptions writerOptions;
-    writerOptions.memoryPool = leafPool_.get();
-
-    // Create an in-memory writer.
-    auto sink = std::make_unique<MemorySink>(
-        200 * 1024 * 1024,
-        dwio::common::FileSink::Options{.pool = leafPool_.get()});
-    auto writer = std::make_unique<parquet::Writer>(
-        std::move(sink), writerOptions, rootPool_, asRowType(data->type()));
-    writer->write(data);
-    writer->close();
-  };
-
   // Dictionary encoded vectors with complex type.
   const auto size = 10'000;
   auto wrappedVectors = wrapDictionaryVectors({
@@ -934,7 +776,8 @@ TEST_F(ParquetWriterTest, dictionaryEncodedVector) {
           *leafPool_),
   });
 
-  writeToFile(makeRowVector(wrappedVectors));
+  auto data = makeRowVector(wrappedVectors);
+  write(data);
 
   // Dictionary encoded constant vector of scalar type.
   const auto constantVector = makeConstant(static_cast<int64_t>(123'456), size);
@@ -944,8 +787,38 @@ TEST_F(ParquetWriterTest, dictionaryEncodedVector) {
   VELOX_CHECK_NOT_NULL(wrappedVector->valueVector());
   EXPECT_FALSE(wrappedVector->wrappedVector()->isFlatEncoding());
 
-  writeToFile(makeRowVector({wrappedVector}));
-};
+  data = makeRowVector({wrappedVector});
+  write(data);
+}
+
+TEST_F(ParquetWriterTest, allNulls) {
+  auto schema = ROW({"c0"}, {INTEGER()});
+  const int64_t kRows = 4096;
+  // Create a column with all elements being null.
+  auto nulls = makeNulls(kRows, [](auto /*row*/) { return true; });
+  auto flatVector = std::make_shared<FlatVector<int32_t>>(
+      pool_.get(),
+      schema->childAt(0),
+      nulls,
+      kRows,
+      /*values=*/nullptr,
+      std::vector<BufferPtr>());
+  auto data = std::make_shared<RowVector>(
+      pool_.get(), schema, nullptr, kRows, std::vector<VectorPtr>{flatVector});
+
+  auto* sinkPtr = write(data);
+
+  dwio::common::ReaderOptions readerOptions(leafPool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  auto reader = createReaderInMemory(*sinkPtr, readerOptions);
+
+  ASSERT_EQ(reader->numberOfRows(), kRows);
+  ASSERT_EQ(*reader->rowType(), *schema);
+
+  auto rowReader = createRowReaderWithSchema(std::move(reader), schema);
+  assertReadWithReaderAndExpected(schema, *rowReader, data, *leafPool_);
+}
 
 } // namespace
 
diff --git a/velox/dwio/parquet/thrift/CMakeLists.txt b/velox/dwio/parquet/thrift/CMakeLists.txt
index ee6fe26e8c8..57aed73c01a 100644
--- a/velox/dwio/parquet/thrift/CMakeLists.txt
+++ b/velox/dwio/parquet/thrift/CMakeLists.txt
@@ -12,5 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_dwio_parquet_thrift ParquetThriftTypes.cpp)
+velox_add_library(
+  velox_dwio_parquet_thrift
+  ParquetThriftTypes.cpp
+  HEADERS
+  ParquetThriftTypes.h
+  ThriftTransport.h
+)
 velox_link_libraries(velox_dwio_parquet_thrift arrow thrift Boost::headers fmt::fmt)
diff --git a/velox/dwio/parquet/writer/CMakeLists.txt b/velox/dwio/parquet/writer/CMakeLists.txt
index 37040ec54a3..c131f59ea36 100644
--- a/velox/dwio/parquet/writer/CMakeLists.txt
+++ b/velox/dwio/parquet/writer/CMakeLists.txt
@@ -14,7 +14,7 @@
 
 add_subdirectory(arrow)
 
-velox_add_library(velox_dwio_arrow_parquet_writer Writer.cpp)
+velox_add_library(velox_dwio_arrow_parquet_writer Writer.cpp HEADERS Writer.h)
 
 velox_link_libraries(
   velox_dwio_arrow_parquet_writer
@@ -22,6 +22,9 @@ velox_link_libraries(
   velox_dwio_arrow_parquet_writer_util_lib
   velox_dwio_common
   velox_arrow_bridge
+  velox_exec
   arrow
   fmt::fmt
 )
+
+velox_add_library(velox_writer_config INTERFACE HEADERS WriterConfig.h)
diff --git a/velox/dwio/parquet/writer/Writer.cpp b/velox/dwio/parquet/writer/Writer.cpp
index 2444fa247cc..8cf29529238 100644
--- a/velox/dwio/parquet/writer/Writer.cpp
+++ b/velox/dwio/parquet/writer/Writer.cpp
@@ -15,6 +15,10 @@
  */
 
 #include "velox/dwio/parquet/writer/Writer.h"
+
+#include <algorithm>
+#include <exception>
+
 #include <arrow/c/bridge.h>
 #include <arrow/io/interfaces.h>
 #include <arrow/table.h>
@@ -22,6 +26,7 @@
 #include "velox/common/config/Config.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/core/QueryConfig.h"
+#include "velox/dwio/parquet/writer/arrow/ArrowSchema.h"
 #include "velox/dwio/parquet/writer/arrow/Properties.h"
 #include "velox/dwio/parquet/writer/arrow/Writer.h"
 #include "velox/exec/MemoryReclaimer.h"
@@ -133,13 +138,13 @@ std::shared_ptr<WriterProperties> getArrowParquetWriterOptions(
   WriterProperties::Builder* properties = &builder;
   if (options.enableDictionary.value_or(
           facebook::velox::parquet::arrow::DEFAULT_IS_DICTIONARY_ENABLED)) {
-    properties = properties->enable_dictionary();
-    properties = properties->dictionary_pagesize_limit(
+    properties = properties->enableDictionary();
+    properties = properties->dictionaryPagesizeLimit(
         options.dictionaryPageSizeLimit.value_or(
             facebook::velox::parquet::arrow::
                 DEFAULT_DICTIONARY_PAGE_SIZE_LIMIT));
   } else {
-    properties = properties->disable_dictionary();
+    properties = properties->disableDictionary();
   }
   properties = properties->compression(getArrowParquetCompression(
       options.compressionKind.value_or(common::CompressionKind_NONE)));
@@ -149,30 +154,30 @@ std::shared_ptr<WriterProperties> getArrowParquetWriterOptions(
         getArrowParquetCompression(columnCompressionValues.second));
   }
   properties = properties->encoding(options.encoding);
-  properties = properties->data_pagesize(options.dataPageSize.value_or(
+  properties = properties->dataPagesize(options.dataPageSize.value_or(
       facebook::velox::parquet::arrow::kDefaultDataPageSize));
-  properties = properties->write_batch_size(options.batchSize.value_or(
+  properties = properties->writeBatchSize(options.batchSize.value_or(
       facebook::velox::parquet::arrow::DEFAULT_WRITE_BATCH_SIZE));
-  properties = properties->max_row_group_length(
+  properties = properties->maxRowGroupLength(
       static_cast<int64_t>(flushPolicy->rowsInRowGroup()));
-  properties = properties->codec_options(options.codecOptions);
-  properties = properties->enable_store_decimal_as_integer();
+  properties = properties->codecOptions(options.codecOptions);
+  properties = properties->enableStoreDecimalAsInteger();
   if (options.useParquetDataPageV2.value_or(false)) {
-    properties =
-        properties->data_page_version(arrow::ParquetDataPageVersion::V2);
+    properties = properties->dataPageVersion(arrow::ParquetDataPageVersion::V2);
   } else {
-    properties =
-        properties->data_page_version(arrow::ParquetDataPageVersion::V1);
+    properties = properties->dataPageVersion(arrow::ParquetDataPageVersion::V1);
   }
   if (options.createdBy.has_value()) {
-    properties = properties->created_by(options.createdBy.value());
+    properties = properties->createdBy(options.createdBy.value());
   }
   return properties->build();
 }
 
-void validateSchemaRecursive(const RowTypePtr& schema) {
-  // Check the schema's field names is not empty and unique.
-  VELOX_USER_CHECK_NOT_NULL(schema, "Field schema must not be empty.");
+void validateSchemaRecursive(
+    const RowTypePtr& schema,
+    const std::vector<ParquetFieldId>& parquetFieldIds) {
+  // Check the schema's field names are not empty and unique.
+  VELOX_USER_CHECK_NOT_NULL(schema, "Schema must not be empty.");
   const auto& fieldNames = schema->names();
 
   folly::F14FastSet<std::string> uniqueNames;
@@ -185,137 +190,163 @@ void validateSchemaRecursive(const RowTypePtr& schema) {
         name);
   }
 
+  if (!parquetFieldIds.empty()) {
+    VELOX_USER_CHECK_EQ(parquetFieldIds.size(), schema->size());
+  }
+
   for (auto i = 0; i < schema->size(); ++i) {
-    if (auto childSchema =
-            std::dynamic_pointer_cast<const RowType>(schema->childAt(i))) {
-      validateSchemaRecursive(childSchema);
+    const auto& childType = schema->childAt(i);
+    const auto& childFieldIds =
+        parquetFieldIds.empty() ? parquetFieldIds : parquetFieldIds[i].children;
+
+    if (childType->isRow()) {
+      validateSchemaRecursive(
+          std::dynamic_pointer_cast<const RowType>(childType), childFieldIds);
+    } else if (childType->isArray()) {
+      if (!parquetFieldIds.empty()) {
+        VELOX_USER_CHECK_EQ(parquetFieldIds[i].children.size(), 1);
+      }
+      const auto& elementType = childType->asArray().elementType();
+      if (elementType->isRow()) {
+        validateSchemaRecursive(
+            std::dynamic_pointer_cast<const RowType>(elementType),
+            childFieldIds.empty() ? childFieldIds : childFieldIds[0].children);
+      }
+    } else if (childType->isMap()) {
+      if (!parquetFieldIds.empty()) {
+        VELOX_USER_CHECK_EQ(parquetFieldIds[i].children.size(), 2);
+      }
+      const auto& mapType = childType->asMap();
+      if (mapType.keyType()->isRow()) {
+        validateSchemaRecursive(
+            std::dynamic_pointer_cast<const RowType>(mapType.keyType()),
+            childFieldIds.empty() ? childFieldIds : childFieldIds[0].children);
+      }
+      if (mapType.valueType()->isRow()) {
+        validateSchemaRecursive(
+            std::dynamic_pointer_cast<const RowType>(mapType.valueType()),
+            childFieldIds.empty() ? childFieldIds : childFieldIds[1].children);
+      }
     }
   }
 }
 
-std::shared_ptr<::arrow::Field> updateFieldNameRecursive(
+std::shared_ptr<::arrow::Field> updateFieldNameAndIdRecursive(
     const std::shared_ptr<::arrow::Field>& field,
     const Type& type,
+    const ParquetFieldId* fieldId,
     const std::string& name = "") {
+  auto newField = name.empty() ? field : field->WithName(name);
+
+  if (fieldId) {
+    newField =
+        newField->WithMetadata(arrow::arrow::fieldIdMetadata(fieldId->fieldId));
+  }
+
   if (type.isRow()) {
     auto& rowType = type.asRow();
-    auto newField = field->WithName(name);
     auto structType =
         std::dynamic_pointer_cast<::arrow::StructType>(newField->type());
     auto childrenSize = rowType.size();
+    VELOX_CHECK(!fieldId || childrenSize <= fieldId->children.size());
     std::vector<std::shared_ptr<::arrow::Field>> newFields;
     newFields.reserve(childrenSize);
-    for (auto i = 0; i < childrenSize; i++) {
-      newFields.push_back(updateFieldNameRecursive(
-          structType->fields()[i], *rowType.childAt(i), rowType.nameOf(i)));
+    for (auto i = 0; i < childrenSize; ++i) {
+      const auto* childSetting = fieldId ? &fieldId->children.at(i) : nullptr;
+      newFields.push_back(updateFieldNameAndIdRecursive(
+          structType->fields()[i],
+          *rowType.childAt(i),
+          childSetting,
+          rowType.nameOf(i)));
     }
-    return newField->WithType(::arrow::struct_(newFields));
+    newField = newField->WithType(::arrow::struct_(newFields));
   } else if (type.isArray()) {
-    auto newField = field->WithName(name);
     auto listType =
         std::dynamic_pointer_cast<::arrow::BaseListType>(newField->type());
     auto elementType = type.asArray().elementType();
     auto elementField = listType->value_field();
-    return newField->WithType(
-        ::arrow::list(updateFieldNameRecursive(elementField, *elementType)));
+    const auto* childSetting = fieldId ? &fieldId->children.at(0) : nullptr;
+    auto updatedElementField =
+        updateFieldNameAndIdRecursive(elementField, *elementType, childSetting);
+    newField = newField->WithType(::arrow::list(updatedElementField));
   } else if (type.isMap()) {
     auto mapType = type.asMap();
-    auto newField = field->WithName(name);
     auto arrowMapType =
         std::dynamic_pointer_cast<::arrow::MapType>(newField->type());
-    auto newKeyField =
-        updateFieldNameRecursive(arrowMapType->key_field(), *mapType.keyType());
-    auto newValueField = updateFieldNameRecursive(
-        arrowMapType->item_field(), *mapType.valueType());
-    return newField->WithType(
-        ::arrow::map(newKeyField->type(), newValueField->type()));
-  } else if (name != "") {
-    return field->WithName(name);
-  } else {
-    return field;
+    const auto* keySetting = fieldId ? &fieldId->children.at(0) : nullptr;
+    const auto* valueSetting = fieldId ? &fieldId->children.at(1) : nullptr;
+    auto newKeyField = updateFieldNameAndIdRecursive(
+        arrowMapType->key_field(), *mapType.keyType(), keySetting);
+    auto newValueField = updateFieldNameAndIdRecursive(
+        arrowMapType->item_field(), *mapType.valueType(), valueSetting);
+    newField = newField->WithType(
+        std::make_shared<::arrow::MapType>(newKeyField, newValueField));
   }
-}
 
-std::optional<TimestampPrecision> getTimestampUnit(
-    const config::ConfigBase& config,
-    const char* configKey) {
-  if (const auto unit = config.get<uint8_t>(configKey)) {
-    VELOX_CHECK(
-        unit == 3 /*milli*/ || unit == 6 /*micro*/ || unit == 9 /*nano*/,
-        "Invalid timestamp unit: {}",
-        unit.value());
-    return std::optional(static_cast<TimestampPrecision>(unit.value()));
-  }
-  return std::nullopt;
+  return newField;
 }
 
-std::optional<std::string> getTimestampTimeZone(
-    const config::ConfigBase& config,
-    const char* configKey) {
-  if (const auto timezone = config.get<std::string>(configKey)) {
-    return timezone.value();
+std::optional<TimestampPrecision> toTimestampPrecision(
+    std::optional<uint8_t> unit) {
+  if (!unit) {
+    return std::nullopt;
   }
-  return std::nullopt;
+  VELOX_CHECK(
+      *unit == 3 /*milli*/ || *unit == 6 /*micro*/ || *unit == 9 /*nano*/,
+      "Invalid timestamp unit: {}",
+      *unit);
+  return static_cast<TimestampPrecision>(*unit);
 }
 
-std::optional<bool> isParquetEnableDictionary(
-    const config::ConfigBase& config,
-    const char* configKey) {
-  try {
-    if (const auto enableDictionary = config.get<bool>(configKey)) {
-      return enableDictionary.value();
-    }
-  } catch (const folly::ConversionError& e) {
-    VELOX_USER_FAIL(
-        "Invalid parquet writer enable dictionary option: {}", e.what());
-  }
-  return std::nullopt;
+// Converts a string to TimestampPrecision. Accepts numeric values "3" (milli),
+// "6" (micro), or "9" (nano).
+TimestampPrecision stringToTimestampPrecision(const std::string& value) {
+  return toTimestampPrecision(std::optional{folly::to<uint8_t>(value)}).value();
 }
 
-std::optional<bool> getParquetDataPageVersion(
-    const config::ConfigBase& config,
-    const char* configKey) {
-  if (const auto version = config.get<std::string>(configKey)) {
-    if (version == "V1") {
-      return false;
-    } else if (version == "V2") {
-      return true;
-    } else {
-      VELOX_FAIL("Unsupported parquet datapage version {}", version.value());
-    }
+std::optional<bool> isParquetV2(std::optional<std::string> version) {
+  if (!version) {
+    return std::nullopt;
+  }
+  if (version == "V1") {
+    return false;
   }
-  return std::nullopt;
+  if (version == "V2") {
+    return true;
+  }
+  VELOX_FAIL("Unsupported parquet datapage version {}", *version);
 }
 
-std::optional<int64_t> getParquetPageSize(
-    const config::ConfigBase& config,
-    const char* configKey) {
-  if (const auto pageSize = config.get<std::string>(configKey)) {
-    return config::toCapacity(pageSize.value(), config::CapacityUnit::BYTE);
+std::optional<int64_t> toParquetPageSize(std::optional<std::string> pageSize) {
+  if (!pageSize) {
+    return std::nullopt;
   }
-  return std::nullopt;
+  return config::toCapacity(*pageSize, config::CapacityUnit::BYTE);
 }
 
-std::optional<int64_t> getParquetBatchSize(
-    const config::ConfigBase& config,
-    const char* configKey) {
+std::optional<bool> toParquetEnableDictionary(
+    std::optional<std::string> enableDictionary) {
+  if (!enableDictionary) {
+    return std::nullopt;
+  }
   try {
-    if (const auto batchSize = config.get<int64_t>(configKey)) {
-      return batchSize.value();
-    }
-  } catch (const folly::ConversionError& e) {
-    VELOX_USER_FAIL("Invalid parquet writer batch size: {}", e.what());
+    return folly::to<bool>(*enableDictionary);
+  } catch (const std::exception& e) {
+    VELOX_USER_FAIL(
+        "Invalid parquet writer enable dictionary option: {}", e.what());
   }
-  return std::nullopt;
 }
 
-std::optional<std::string> getParquetCreatedBy(
-    const config::ConfigBase& config,
-    const char* configKey) {
-  if (config.get<std::string>(configKey).has_value()) {
-    return config.get<std::string>(configKey).value();
+std::optional<int64_t> toParquetBatchSize(
+    std::optional<std::string> batchSize) {
+  if (!batchSize) {
+    return std::nullopt;
+  }
+  try {
+    return folly::to<int64_t>(*batchSize);
+  } catch (const std::exception& e) {
+    VELOX_USER_FAIL("Invalid parquet writer batch size: {}", e.what());
   }
-  return std::nullopt;
 }
 
 } // namespace
@@ -327,13 +358,14 @@ Writer::Writer(
     RowTypePtr schema)
     : pool_(std::move(pool)),
       generalPool_{pool_->addLeafChild(".general")},
-      stream_(std::make_shared<ArrowDataBufferSink>(
-          std::move(sink),
-          *generalPool_,
-          options.bufferGrowRatio)),
+      stream_(
+          std::make_shared<ArrowDataBufferSink>(
+              std::move(sink),
+              *generalPool_,
+              options.bufferGrowRatio)),
       arrowContext_(std::make_shared<ArrowContext>()),
       schema_(std::move(schema)) {
-  validateSchemaRecursive(schema_);
+  validateSchemaRecursive(schema_, options.parquetFieldIds);
 
   if (options.flushPolicyFactory) {
     castUniquePointer(options.flushPolicyFactory(), flushPolicy_);
@@ -351,6 +383,7 @@ Writer::Writer(
   setMemoryReclaimers();
   writeInt96AsTimestamp_ = options.writeInt96AsTimestamp;
   arrowMemoryPool_ = options.arrowMemoryPool;
+  parquetFieldIds_ = std::move(options.parquetFieldIds);
 }
 
 Writer::Writer(
@@ -360,9 +393,10 @@ Writer::Writer(
     : Writer{
           std::move(sink),
           options,
-          options.memoryPool->addAggregateChild(fmt::format(
-              "writer_node_{}",
-              folly::to<std::string>(folly::Random::rand64()))),
+          options.memoryPool->addAggregateChild(
+              fmt::format(
+                  "writer_node_{}",
+                  folly::to<std::string>(folly::Random::rand64()))),
           std::move(schema)} {}
 
 void Writer::flush() {
@@ -370,12 +404,12 @@ void Writer::flush() {
     if (!arrowContext_->writer) {
       ArrowWriterProperties::Builder builder;
       if (writeInt96AsTimestamp_) {
-        builder.enable_deprecated_int96_timestamps();
+        builder.enableDeprecatedInt96Timestamps();
       }
       auto arrowProperties = builder.build();
       PARQUET_ASSIGN_OR_THROW(
           arrowContext_->writer,
-          FileWriter::Open(
+          FileWriter::open(
               *arrowContext_->schema.get(),
               arrowMemoryPool_.get(),
               stream_,
@@ -397,7 +431,7 @@ void Writer::flush() {
         arrowContext_->schema,
         std::move(chunks),
         static_cast<int64_t>(arrowContext_->stagingRows));
-    PARQUET_THROW_NOT_OK(arrowContext_->writer->WriteTable(
+    PARQUET_THROW_NOT_OK(arrowContext_->writer->writeTable(
         *table, static_cast<int64_t>(flushPolicy_->rowsInRowGroup())));
     PARQUET_THROW_NOT_OK(stream_->Flush());
     for (auto& chunk : arrowContext_->stagingChunks) {
@@ -445,9 +479,15 @@ void Writer::write(const VectorPtr& data) {
       "facebook::velox::parquet::Writer::write", arrowSchema.get());
   std::vector<std::shared_ptr<::arrow::Field>> newFields;
   auto childSize = schema_->size();
+  if (!parquetFieldIds_.empty()) {
+    VELOX_CHECK(childSize == parquetFieldIds_.size());
+  }
   for (auto i = 0; i < childSize; i++) {
-    newFields.push_back(updateFieldNameRecursive(
-        arrowSchema->fields()[i], *schema_->childAt(i), schema_->nameOf(i)));
+    newFields.push_back(updateFieldNameAndIdRecursive(
+        arrowSchema->fields()[i],
+        *schema_->childAt(i),
+        !parquetFieldIds_.empty() ? &parquetFieldIds_.at(i) : nullptr,
+        schema_->nameOf(i)));
   }
 
   PARQUET_ASSIGN_OR_THROW(
@@ -478,24 +518,30 @@ void Writer::write(const VectorPtr& data) {
 }
 
 bool Writer::isCodecAvailable(common::CompressionKind compression) {
-  return arrow::util::Codec::IsAvailable(
+  return arrow::util::Codec::isAvailable(
       getArrowParquetCompression(compression));
 }
 
 void Writer::newRowGroup(int32_t numRows) {
-  PARQUET_THROW_NOT_OK(arrowContext_->writer->NewRowGroup(numRows));
+  PARQUET_THROW_NOT_OK(arrowContext_->writer->newRowGroup(numRows));
 }
 
-void Writer::close() {
+std::unique_ptr<dwio::common::FileMetadata> Writer::close() {
   flush();
 
+  std::unique_ptr<ParquetFileMetadata> parquetFileMetadata;
   if (arrowContext_->writer) {
-    PARQUET_THROW_NOT_OK(arrowContext_->writer->Close());
+    PARQUET_THROW_NOT_OK(arrowContext_->writer->close());
+    parquetFileMetadata = std::make_unique<ParquetFileMetadata>(
+        arrowContext_->writer->metadata());
     arrowContext_->writer.reset();
   }
+
   PARQUET_THROW_NOT_OK(stream_->Close());
 
   arrowContext_->stagingChunks.clear();
+
+  return parquetFileMetadata;
 }
 
 void Writer::abort() {
@@ -560,11 +606,29 @@ void WriterOptions::processConfigs(
   VELOX_CHECK_NOT_NULL(
       parquetWriterOptions, "Expected a Parquet WriterOptions object.");
 
+  // Check serdeParameters for timestamp settings first (highest priority).
+  auto serdeTimestampUnitIt =
+      serdeParameters.find(WriterConfig::kParquetSerdeTimestampUnit);
+  if (serdeTimestampUnitIt != serdeParameters.end()) {
+    parquetWriteTimestampUnit =
+        stringToTimestampPrecision(serdeTimestampUnitIt->second);
+  }
+
+  auto serdeTimestampTimezoneIt =
+      serdeParameters.find(WriterConfig::kParquetSerdeTimestampTimezone);
+  if (serdeTimestampTimezoneIt != serdeParameters.end()) {
+    // Empty string means no timezone conversion (nullopt).
+    if (serdeTimestampTimezoneIt->second.empty()) {
+      parquetWriteTimestampTimeZone = std::nullopt;
+    } else {
+      parquetWriteTimestampTimeZone = serdeTimestampTimezoneIt->second;
+    }
+  }
+
   if (!parquetWriteTimestampUnit) {
     parquetWriteTimestampUnit =
-        getTimestampUnit(session, kParquetSessionWriteTimestampUnit).has_value()
-        ? getTimestampUnit(session, kParquetSessionWriteTimestampUnit)
-        : getTimestampUnit(connectorConfig, kParquetSessionWriteTimestampUnit);
+        toTimestampPrecision(session.getWithFallback<uint8_t>(
+            WriterConfig::kParquetSessionWriteTimestampUnit, connectorConfig));
   }
   if (!parquetWriteTimestampTimeZone) {
     parquetWriteTimestampTimeZone = parquetWriterOptions->sessionTimezoneName;
@@ -572,50 +636,56 @@ void WriterOptions::processConfigs(
 
   if (!enableDictionary) {
     enableDictionary =
-        isParquetEnableDictionary(session, kParquetSessionEnableDictionary)
-            .has_value()
-        ? isParquetEnableDictionary(session, kParquetSessionEnableDictionary)
-        : isParquetEnableDictionary(
-              connectorConfig, kParquetHiveConnectorEnableDictionary);
+        toParquetEnableDictionary(session.getWithFallback<std::string>(
+            WriterConfig::kParquetSessionEnableDictionary, connectorConfig));
   }
 
   if (!dictionaryPageSizeLimit) {
     dictionaryPageSizeLimit =
-        getParquetPageSize(session, kParquetSessionDictionaryPageSizeLimit)
-            .has_value()
-        ? getParquetPageSize(session, kParquetSessionDictionaryPageSizeLimit)
-        : getParquetPageSize(
-              connectorConfig, kParquetHiveConnectorDictionaryPageSizeLimit);
+        toParquetPageSize(session.getWithFallback<std::string>(
+            WriterConfig::kParquetSessionDictionaryPageSizeLimit,
+            connectorConfig));
   }
 
   if (!useParquetDataPageV2) {
-    useParquetDataPageV2 =
-        getParquetDataPageVersion(session, kParquetSessionDataPageVersion)
-            .has_value()
-        ? getParquetDataPageVersion(session, kParquetSessionDataPageVersion)
-        : getParquetDataPageVersion(
-              connectorConfig, kParquetHiveConnectorDataPageVersion);
+    useParquetDataPageV2 = isParquetV2(session.getWithFallback<std::string>(
+        WriterConfig::kParquetSessionDataPageVersion, connectorConfig));
   }
 
   if (!dataPageSize) {
-    dataPageSize =
-        getParquetPageSize(session, kParquetSessionWritePageSize).has_value()
-        ? getParquetPageSize(session, kParquetSessionWritePageSize)
-        : getParquetPageSize(
-              connectorConfig, kParquetHiveConnectorWritePageSize);
+    dataPageSize = toParquetPageSize(session.getWithFallback<std::string>(
+        WriterConfig::kParquetSessionWritePageSize, connectorConfig));
   }
 
   if (!batchSize) {
-    batchSize =
-        getParquetBatchSize(session, kParquetSessionWriteBatchSize).has_value()
-        ? getParquetBatchSize(session, kParquetSessionWriteBatchSize)
-        : getParquetBatchSize(
-              connectorConfig, kParquetHiveConnectorWriteBatchSize);
+    batchSize = toParquetBatchSize(session.getWithFallback<std::string>(
+        WriterConfig::kParquetSessionWriteBatchSize, connectorConfig));
   }
 
   if (!createdBy) {
-    createdBy =
-        getParquetCreatedBy(connectorConfig, kParquetHiveConnectorCreatedBy);
+    createdBy = session.getWithFallback<std::string>(
+        WriterConfig::kParquetHiveConnectorCreatedBy, connectorConfig);
+  }
+
+  // Parquet only updates ioStats_->rawBytesWritten() when a row group is
+  // flushed. With the default flush policy (1M rows / 128MB), small
+  // maxTargetFileBytes_ would never trigger rotation because rawBytesWritten()
+  // stays at 0 while data is buffered. To honor maxTargetFileBytes_, cap the
+  // row group byte threshold so we flush earlier and rawBytesWritten() grows
+  // during writes.
+  auto maxTargetFileSize =
+      toParquetPageSize(session.getWithFallback<std::string>(
+          WriterConfig::kParquetSessionMaxTargetFileSize, connectorConfig));
+  if (maxTargetFileSize.has_value()) {
+    if (!flushPolicyFactory) {
+      auto bytesInRowGroup = std::min<int64_t>(
+          DefaultFlushPolicy::kDefaultBytesInRowGroup,
+          maxTargetFileSize.value());
+      flushPolicyFactory = [bytesInRowGroup]() {
+        return std::make_unique<DefaultFlushPolicy>(
+            DefaultFlushPolicy::kDefaultRowsInGroup, bytesInRowGroup);
+      };
+    }
   }
 }
 
diff --git a/velox/dwio/parquet/writer/Writer.h b/velox/dwio/parquet/writer/Writer.h
index 7deca7ee670..3046424a6f9 100644
--- a/velox/dwio/parquet/writer/Writer.h
+++ b/velox/dwio/parquet/writer/Writer.h
@@ -20,11 +20,15 @@
 #include "velox/common/compression/Compression.h"
 #include "velox/common/config/Config.h"
 #include "velox/dwio/common/DataBuffer.h"
+#include "velox/dwio/common/FileMetadata.h"
 #include "velox/dwio/common/FileSink.h"
 #include "velox/dwio/common/FlushPolicy.h"
 #include "velox/dwio/common/Options.h"
 #include "velox/dwio/common/Writer.h"
 #include "velox/dwio/common/WriterFactory.h"
+#include "velox/dwio/parquet/ParquetFieldId.h"
+#include "velox/dwio/parquet/writer/WriterConfig.h"
+#include "velox/dwio/parquet/writer/arrow/Metadata.h"
 #include "velox/dwio/parquet/writer/arrow/Types.h"
 #include "velox/dwio/parquet/writer/arrow/util/Compression.h"
 #include "velox/vector/ComplexVector.h"
@@ -38,13 +42,32 @@ class ArrowDataBufferSink;
 
 struct ArrowContext;
 
+/// Parquet-specific file metadata wrapper. Provides access to the underlying
+/// arrow::FileMetaData.
+class ParquetFileMetadata : public dwio::common::FileMetadata {
+ public:
+  explicit ParquetFileMetadata(std::shared_ptr<arrow::FileMetaData> metadata)
+      : metadata_(std::move(metadata)) {}
+
+  std::shared_ptr<arrow::FileMetaData> arrowMetadata() const {
+    return metadata_;
+  }
+
+ private:
+  std::shared_ptr<arrow::FileMetaData> metadata_;
+};
+
 class DefaultFlushPolicy : public dwio::common::FlushPolicy {
  public:
   DefaultFlushPolicy()
-      : rowsInRowGroup_(1'024 * 1'024), bytesInRowGroup_(128 * 1'024 * 1'024) {}
+      : rowsInRowGroup_(kDefaultRowsInGroup),
+        bytesInRowGroup_(kDefaultBytesInRowGroup) {}
   DefaultFlushPolicy(uint64_t rowsInRowGroup, int64_t bytesInRowGroup)
       : rowsInRowGroup_(rowsInRowGroup), bytesInRowGroup_(bytesInRowGroup) {}
 
+  static constexpr uint64_t kDefaultRowsInGroup{1'024 * 1'024};
+  static constexpr int64_t kDefaultBytesInRowGroup{128 * 1'024 * 1'024};
+
   bool shouldFlush(
       const dwio::common::StripeProgress& stripeProgress) override {
     return stripeProgress.stripeRowCount >= rowsInRowGroup_ ||
@@ -94,7 +117,7 @@ struct WriterOptions : public dwio::common::WriterOptions {
   // folly/FBVector(https://github.com/facebook/folly/blob/main/folly/docs/FBVector.md#memory-handling).
   double bufferGrowRatio = 1.5;
 
-  arrow::Encoding::type encoding = arrow::Encoding::PLAIN;
+  arrow::Encoding::type encoding = arrow::Encoding::kPlain;
 
   std::shared_ptr<CodecOptions> codecOptions;
   std::unordered_map<std::string, common::CompressionKind>
@@ -116,36 +139,11 @@ struct WriterOptions : public dwio::common::WriterOptions {
 
   std::shared_ptr<arrow::MemoryPool> arrowMemoryPool;
 
-  // Parsing session and hive configs.
-
-  // This isn't a typo; session and hive connector config names are different
-  // ('_' vs '-').
-  static constexpr const char* kParquetSessionWriteTimestampUnit =
-      "hive.parquet.writer.timestamp_unit";
-  static constexpr const char* kParquetHiveConnectorWriteTimestampUnit =
-      "hive.parquet.writer.timestamp-unit";
-  static constexpr const char* kParquetSessionEnableDictionary =
-      "hive.parquet.writer.enable_dictionary";
-  static constexpr const char* kParquetHiveConnectorEnableDictionary =
-      "hive.parquet.writer.enable-dictionary";
-  static constexpr const char* kParquetSessionDictionaryPageSizeLimit =
-      "hive.parquet.writer.dictionary_page_size_limit";
-  static constexpr const char* kParquetHiveConnectorDictionaryPageSizeLimit =
-      "hive.parquet.writer.dictionary-page-size-limit";
-  static constexpr const char* kParquetSessionDataPageVersion =
-      "hive.parquet.writer.datapage_version";
-  static constexpr const char* kParquetHiveConnectorDataPageVersion =
-      "hive.parquet.writer.datapage-version";
-  static constexpr const char* kParquetSessionWritePageSize =
-      "hive.parquet.writer.page_size";
-  static constexpr const char* kParquetHiveConnectorWritePageSize =
-      "hive.parquet.writer.page-size";
-  static constexpr const char* kParquetSessionWriteBatchSize =
-      "hive.parquet.writer.batch_size";
-  static constexpr const char* kParquetHiveConnectorWriteBatchSize =
-      "hive.parquet.writer.batch-size";
-  static constexpr const char* kParquetHiveConnectorCreatedBy =
-      "hive.parquet.writer.created-by";
+  /// Optional field IDs to assign to columns in the Parquet schema.
+  /// If provided, the writer will use these IDs for the schema fields.
+  /// If not provided, the field_id will be -1.
+  /// The structure should match the schema hierarchy with nested children.
+  std::vector<ParquetFieldId> parquetFieldIds;
 
   // Process hive connector and session configs.
   void processConfigs(
@@ -188,10 +186,11 @@ class Writer : public dwio::common::Writer {
     return true;
   }
 
-  // Closes 'this', After close, data can no longer be added and the completed
+  // Closes 'this'. After close, data can no longer be added and the completed
   // Parquet file is flushed into 'sink' provided at construction. 'sink' stays
-  // live until destruction of 'this'.
-  void close() override;
+  // live until destruction of 'this'. Returns file metadata, or null if no
+  // metadata is available (e.g. for an empty file).
+  std::unique_ptr<dwio::common::FileMetadata> close() override;
 
   void abort() override;
 
@@ -214,6 +213,8 @@ class Writer : public dwio::common::Writer {
 
   std::shared_ptr<ArrowContext> arrowContext_;
 
+  std::vector<ParquetFieldId> parquetFieldIds_;
+
   std::unique_ptr<DefaultFlushPolicy> flushPolicy_;
 
   const RowTypePtr schema_;
diff --git a/velox/dwio/parquet/writer/WriterConfig.h b/velox/dwio/parquet/writer/WriterConfig.h
new file mode 100644
index 00000000000..ee8788f74b9
--- /dev/null
+++ b/velox/dwio/parquet/writer/WriterConfig.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+namespace facebook::velox::parquet {
+
+/// Config constants for the Parquet writer.
+///
+/// IMPORTANT: These constants are kept in a separate header rather than in
+/// Writer.h because Gluten's WholeStageResultIterator.cc needs access to these
+/// configuration constants but cannot include Writer.h due to Arrow header
+/// conflicts. This separation allows external code to reference these constants
+/// without pulling in Arrow dependencies.
+struct WriterConfig {
+  // Parsing session and hive configs.
+
+  // This isn't a typo; session and hive connector config names are different
+  // ('_' vs '-').
+  static constexpr const char* kParquetSessionWriteTimestampUnit =
+      "hive.parquet.writer.timestamp_unit";
+  static constexpr const char* kParquetHiveConnectorWriteTimestampUnit =
+      "hive.parquet.writer.timestamp-unit";
+  static constexpr const char* kParquetSessionEnableDictionary =
+      "hive.parquet.writer.enable_dictionary";
+  static constexpr const char* kParquetHiveConnectorEnableDictionary =
+      "hive.parquet.writer.enable-dictionary";
+  static constexpr const char* kParquetSessionDictionaryPageSizeLimit =
+      "hive.parquet.writer.dictionary_page_size_limit";
+  static constexpr const char* kParquetHiveConnectorDictionaryPageSizeLimit =
+      "hive.parquet.writer.dictionary-page-size-limit";
+  static constexpr const char* kParquetSessionDataPageVersion =
+      "hive.parquet.writer.datapage_version";
+  static constexpr const char* kParquetHiveConnectorDataPageVersion =
+      "hive.parquet.writer.datapage-version";
+  static constexpr const char* kParquetSessionWritePageSize =
+      "hive.parquet.writer.page_size";
+  static constexpr const char* kParquetHiveConnectorWritePageSize =
+      "hive.parquet.writer.page-size";
+  static constexpr const char* kParquetSessionWriteBatchSize =
+      "hive.parquet.writer.batch_size";
+  static constexpr const char* kParquetHiveConnectorWriteBatchSize =
+      "hive.parquet.writer.batch-size";
+  static constexpr const char* kParquetHiveConnectorCreatedBy =
+      "hive.parquet.writer.created-by";
+
+  // Use the same property name from HiveConfig::kMaxTargetFileSize.
+  static constexpr const char* kParquetConnectorMaxTargetFileSize =
+      "max-target-file-size";
+  static constexpr const char* kParquetSessionMaxTargetFileSize =
+      "max_target_file_size";
+  // Serde parameter keys for timestamp settings. These can be set via
+  // serdeParameters map to override the default timestamp behavior.
+  // The timezone key accepts a timezone string or empty string to disable
+  // timezone conversion.
+  static constexpr const char* kParquetSerdeTimestampUnit =
+      "parquet.writer.timestamp.unit";
+  static constexpr const char* kParquetSerdeTimestampTimezone =
+      "parquet.writer.timestamp.timezone";
+};
+
+} // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/writer/arrow/ArrowSchema.cpp b/velox/dwio/parquet/writer/arrow/ArrowSchema.cpp
index de5a2382198..a514c33a5da 100644
--- a/velox/dwio/parquet/writer/arrow/ArrowSchema.cpp
+++ b/velox/dwio/parquet/writer/arrow/ArrowSchema.cpp
@@ -59,35 +59,35 @@ using schema::PrimitiveNode;
 
 using ParquetType = Type;
 
-// ----------------------------------------------------------------------
-// Parquet to Arrow schema conversion
+// ----------------------------------------------------------------------.
+// Parquet to Arrow schema conversion.
 
 namespace {
 
 /// Increments levels according to the cardinality of node.
-void IncrementLevels(LevelInfo& current_levels, const schema::Node& node) {
-  if (node.is_repeated()) {
-    current_levels.IncrementRepeated();
+void incrementLevels(LevelInfo& currentLevels, const schema::Node& node) {
+  if (node.isRepeated()) {
+    currentLevels.IncrementRepeated();
     return;
   }
-  if (node.is_optional()) {
-    current_levels.IncrementOptional();
+  if (node.isOptional()) {
+    currentLevels.IncrementOptional();
     return;
   }
 }
 
-/// Like std::string_view::ends_with in C++20
-inline bool EndsWith(std::string_view s, std::string_view suffix) {
+/// Like std::string_view::ends_with in C++20.
+inline bool endsWith(std::string_view s, std::string_view suffix) {
   return s.length() >= suffix.length() &&
       (s.empty() || s.substr(s.length() - suffix.length()) == suffix);
 }
 
 namespace detail {
 template <typename T, typename = void>
-struct can_to_chars : public std::false_type {};
+struct CanToChars : public std::false_type {};
 
 template <typename T>
-struct can_to_chars<
+struct CanToChars<
     T,
     std::void_t<decltype(std::to_chars(
         std::declval<char*>(),
@@ -101,9 +101,9 @@ struct can_to_chars<
 /// This is useful as some C++ libraries do not implement all specified
 /// overloads for std::to_chars.
 template <typename T>
-inline constexpr bool have_to_chars = detail::can_to_chars<T>::value;
+inline constexpr bool haveToChars = detail::CanToChars<T>::value;
 
-/// \brief An ergonomic wrapper around std::to_chars, returning a std::string
+/// \brief An ergonomic wrapper around std::to_chars, returning a std::string.
 ///
 /// For most inputs, the std::string result will not incur any heap allocation
 /// thanks to small string optimization.
@@ -111,10 +111,10 @@ inline constexpr bool have_to_chars = detail::can_to_chars<T>::value;
 /// Compared to std::to_string, this function gives locale-agnostic results
 /// and might also be faster.
 template <typename T, typename... Args>
-std::string ToChars(T value, Args&&... args) {
-  if constexpr (!have_to_chars<T>) {
-    // Some C++ standard libraries do not yet implement std::to_chars for all
-    // types, in which case we have to fallback to std::string.
+std::string toChars(T value, Args&&... args) {
+  if constexpr (!haveToChars<T>) {
+    // Some C++ standard libraries do not yet implement std::to_chars for all.
+    // Types, in which case we have to fallback to std::string.
     return std::to_string(value);
   } else {
     // According to various sources, the GNU libstdc++ and Microsoft's C++ STL
@@ -134,86 +134,86 @@ std::string ToChars(T value, Args&&... args) {
   }
 }
 
-Repetition::type RepetitionFromNullable(bool is_nullable) {
-  return is_nullable ? Repetition::OPTIONAL : Repetition::REQUIRED;
+Repetition::type repetitionFromNullable(bool isNullable) {
+  return isNullable ? Repetition::kOptional : Repetition::kRequired;
 }
 
-Status FieldToNode(
+Status fieldToNode(
     const std::string& name,
     const std::shared_ptr<Field>& field,
     const WriterProperties& properties,
-    const ArrowWriterProperties& arrow_properties,
+    const ArrowWriterProperties& arrowProperties,
     NodePtr* out);
 
-Status ListToNode(
+Status listToNode(
     const std::shared_ptr<::arrow::BaseListType>& type,
     const std::string& name,
     bool nullable,
-    int field_id,
+    int fieldId,
     const WriterProperties& properties,
-    const ArrowWriterProperties& arrow_properties,
+    const ArrowWriterProperties& arrowProperties,
     NodePtr* out) {
   NodePtr element;
-  std::string value_name = arrow_properties.compliant_nested_types()
+  std::string valueName = arrowProperties.compliantNestedTypes()
       ? "element"
       : type->value_field()->name();
-  RETURN_NOT_OK(FieldToNode(
-      value_name, type->value_field(), properties, arrow_properties, &element));
+  RETURN_NOT_OK(fieldToNode(
+      valueName, type->value_field(), properties, arrowProperties, &element));
 
-  NodePtr list = GroupNode::Make("list", Repetition::REPEATED, {element});
-  *out = GroupNode::Make(
+  NodePtr List = GroupNode::make("list", Repetition::kRepeated, {element});
+  *out = GroupNode::make(
       name,
-      RepetitionFromNullable(nullable),
-      {list},
-      LogicalType::List(),
-      field_id);
+      repetitionFromNullable(nullable),
+      {List},
+      LogicalType::list(),
+      fieldId);
   return Status::OK();
 }
 
-Status MapToNode(
+Status mapToNode(
     const std::shared_ptr<::arrow::MapType>& type,
     const std::string& name,
     bool nullable,
-    int field_id,
+    int fieldId,
     const WriterProperties& properties,
-    const ArrowWriterProperties& arrow_properties,
+    const ArrowWriterProperties& arrowProperties,
     NodePtr* out) {
   // TODO: Should we offer a non-compliant mode that forwards the type names?
-  NodePtr key_node;
-  RETURN_NOT_OK(FieldToNode(
-      "key", type->key_field(), properties, arrow_properties, &key_node));
+  NodePtr keyNode;
+  RETURN_NOT_OK(fieldToNode(
+      "key", type->key_field(), properties, arrowProperties, &keyNode));
 
-  NodePtr value_node;
-  RETURN_NOT_OK(FieldToNode(
-      "value", type->item_field(), properties, arrow_properties, &value_node));
+  NodePtr valueNode;
+  RETURN_NOT_OK(fieldToNode(
+      "value", type->item_field(), properties, arrowProperties, &valueNode));
 
-  NodePtr key_value = GroupNode::Make(
-      "key_value", Repetition::REPEATED, {key_node, value_node});
-  *out = GroupNode::Make(
+  NodePtr keyValue =
+      GroupNode::make("key_value", Repetition::kRepeated, {keyNode, valueNode});
+  *out = GroupNode::make(
       name,
-      RepetitionFromNullable(nullable),
-      {key_value},
-      LogicalType::Map(),
-      field_id);
+      repetitionFromNullable(nullable),
+      {keyValue},
+      LogicalType::map(),
+      fieldId);
   return Status::OK();
 }
 
-Status StructToNode(
+Status structToNode(
     const std::shared_ptr<::arrow::StructType>& type,
     const std::string& name,
     bool nullable,
-    int field_id,
+    int fieldId,
     const WriterProperties& properties,
-    const ArrowWriterProperties& arrow_properties,
+    const ArrowWriterProperties& arrowProperties,
     NodePtr* out) {
   std::vector<NodePtr> children(type->num_fields());
   if (type->num_fields() != 0) {
     for (int i = 0; i < type->num_fields(); i++) {
-      RETURN_NOT_OK(FieldToNode(
+      RETURN_NOT_OK(fieldToNode(
           type->field(i)->name(),
           type->field(i),
           properties,
-          arrow_properties,
+          arrowProperties,
           &children[i]));
     }
   } else {
@@ -227,71 +227,65 @@ Status StructToNode(
         "Consider adding a dummy child field.");
   }
 
-  *out = GroupNode::Make(
-      name, RepetitionFromNullable(nullable), children, nullptr, field_id);
+  *out = GroupNode::make(
+      name, repetitionFromNullable(nullable), children, nullptr, fieldId);
   return Status::OK();
 }
 
 static std::shared_ptr<const LogicalType>
-TimestampLogicalTypeFromArrowTimestamp(
-    const ::arrow::TimestampType& timestamp_type,
-    ::arrow::TimeUnit::type time_unit) {
-  const bool utc = !(timestamp_type.timezone().empty());
+timestampLogicalTypeFromArrowTimestamp(
+    const ::arrow::TimestampType& timestampType,
+    ::arrow::TimeUnit::type timeUnit) {
+  const bool utc = !(timestampType.timezone().empty());
   // ARROW-5878(wesm): for forward compatibility reasons, and because
   // there's no other way to signal to old readers that values are
   // timestamps, we force the ConvertedType field to be set to the
   // corresponding TIMESTAMP_* value. This does cause some ambiguity
   // as Parquet readers have not been consistent about the
   // interpretation of TIMESTAMP_* values as being UTC-normalized.
-  switch (time_unit) {
+  switch (timeUnit) {
     case ::arrow::TimeUnit::MILLI:
-      return LogicalType::Timestamp(
-          utc,
-          LogicalType::TimeUnit::MILLIS,
-          /*is_from_converted_type=*/false,
-          /*force_set_converted_type=*/true);
+      return LogicalType::timestamp(
+          utc, LogicalType::TimeUnit::kMillis, false, true);
     case ::arrow::TimeUnit::MICRO:
-      return LogicalType::Timestamp(
-          utc,
-          LogicalType::TimeUnit::MICROS,
-          /*is_from_converted_type=*/false,
-          /*force_set_converted_type=*/true);
+      return LogicalType::timestamp(
+          utc, LogicalType::TimeUnit::kMicros, false, true);
     case ::arrow::TimeUnit::NANO:
-      return LogicalType::Timestamp(utc, LogicalType::TimeUnit::NANOS);
+      return LogicalType::timestamp(utc, LogicalType::TimeUnit::kNanos);
     case ::arrow::TimeUnit::SECOND:
       // No equivalent parquet logical type.
       break;
   }
-  return LogicalType::None();
+  return LogicalType::none();
 }
 
-static Status GetTimestampMetadata(
+static Status getTimestampMetadata(
     const ::arrow::TimestampType& type,
     const WriterProperties& properties,
-    const ArrowWriterProperties& arrow_properties,
-    ParquetType::type* physical_type,
-    std::shared_ptr<const LogicalType>* logical_type) {
-  const bool coerce = arrow_properties.coerce_timestamps_enabled();
-  const auto target_unit =
-      coerce ? arrow_properties.coerce_timestamps_unit() : type.unit();
+    const ArrowWriterProperties& arrowProperties,
+    ParquetType::type* physicalType,
+    std::shared_ptr<const LogicalType>* logicalType) {
+  const bool coerce = arrowProperties.coerceTimestampsEnabled();
+  const auto targetUnit =
+      coerce ? arrowProperties.coerceTimestampsUnit() : type.unit();
   const auto version = properties.version();
 
   // The user is explicitly asking for Impala int96 encoding, there is no
   // logical type.
-  if (arrow_properties.support_deprecated_int96_timestamps()) {
-    *physical_type = ParquetType::INT96;
+  if (arrowProperties.supportDeprecatedInt96Timestamps()) {
+    *physicalType = ParquetType::kInt96;
     return Status::OK();
   }
 
-  *physical_type = ParquetType::INT64;
-  *logical_type = TimestampLogicalTypeFromArrowTimestamp(type, target_unit);
+  *physicalType = ParquetType::kInt64;
+  *logicalType = timestampLogicalTypeFromArrowTimestamp(type, targetUnit);
 
   // The user is explicitly asking for timestamp data to be converted to the
   // specified units (target_unit).
   if (coerce) {
     if (version == ParquetVersion::PARQUET_1_0 ||
         version == ParquetVersion::PARQUET_2_4) {
-      switch (target_unit) {
+      switch (targetUnit) {
         case ::arrow::TimeUnit::MILLI:
         case ::arrow::TimeUnit::MICRO:
           break;
@@ -299,12 +293,12 @@ static Status GetTimestampMetadata(
         case ::arrow::TimeUnit::SECOND:
           return Status::NotImplemented(
               "For Parquet version ",
-              ParquetVersionToString(version),
+              parquetVersionToString(version),
               ", can only coerce Arrow timestamps to "
               "milliseconds or microseconds");
       }
     } else {
-      switch (target_unit) {
+      switch (targetUnit) {
         case ::arrow::TimeUnit::MILLI:
         case ::arrow::TimeUnit::MICRO:
         case ::arrow::TimeUnit::NANO:
@@ -312,7 +306,7 @@ static Status GetTimestampMetadata(
         case ::arrow::TimeUnit::SECOND:
           return Status::NotImplemented(
               "For Parquet version ",
-              ParquetVersionToString(version),
+              parquetVersionToString(version),
               ", can only coerce Arrow timestamps to "
               "milliseconds, microseconds, or nanoseconds");
       }
@@ -320,24 +314,25 @@ static Status GetTimestampMetadata(
     return Status::OK();
   }
 
-  // The user implicitly wants timestamp data to retain its original time units,
-  // however the ConvertedType field used to indicate logical types for Parquet
-  // version <= 2.4 fields does not allow for nanosecond time units and so
-  // nanoseconds must be coerced to microseconds.
+  // The user implicitly wants timestamp data to retain its original time
+  // units. However, the ConvertedType field used to indicate logical types for
+  // Parquet version <= 2.4 fields does not allow for nanosecond time units and
+  // so nanoseconds must be coerced to microseconds.
   if ((version == ParquetVersion::PARQUET_1_0 ||
        version == ParquetVersion::PARQUET_2_4) &&
       type.unit() == ::arrow::TimeUnit::NANO) {
-    *logical_type =
-        TimestampLogicalTypeFromArrowTimestamp(type, ::arrow::TimeUnit::MICRO);
+    *logicalType =
+        timestampLogicalTypeFromArrowTimestamp(type, ::arrow::TimeUnit::MICRO);
     return Status::OK();
   }
 
-  // The user implicitly wants timestamp data to retain its original time units,
-  // however the Arrow seconds time unit can not be represented (annotated) in
-  // any version of Parquet and so must be coerced to milliseconds.
+  // The user implicitly wants timestamp data to retain its original time
+  // units. However, the Arrow seconds time unit can not be represented
+  // (annotated) in any version of Parquet and so must be coerced to
+  // milliseconds.
   if (type.unit() == ::arrow::TimeUnit::SECOND) {
-    *logical_type =
-        TimestampLogicalTypeFromArrowTimestamp(type, ::arrow::TimeUnit::MILLI);
+    *logicalType =
+        timestampLogicalTypeFromArrowTimestamp(type, ::arrow::TimeUnit::MILLI);
     return Status::OK();
   }
 
@@ -346,15 +341,7 @@ static Status GetTimestampMetadata(
 
 static constexpr char FIELD_ID_KEY[] = "PARQUET:field_id";
 
-std::shared_ptr<::arrow::KeyValueMetadata> FieldIdMetadata(int field_id) {
-  if (field_id >= 0) {
-    return ::arrow::key_value_metadata({FIELD_ID_KEY}, {ToChars(field_id)});
-  } else {
-    return nullptr;
-  }
-}
-
-int FieldIdFromMetadata(
+int fieldIdFromMetadata(
     const std::shared_ptr<const ::arrow::KeyValueMetadata>& metadata) {
   if (!metadata) {
     return -1;
@@ -363,31 +350,31 @@ int FieldIdFromMetadata(
   if (key < 0) {
     return -1;
   }
-  std::string field_id_str = metadata->value(key);
-  int field_id;
+  std::string fieldIdStr = metadata->value(key);
+  int fieldId;
   if (::arrow::internal::ParseValue<::arrow::Int32Type>(
-          field_id_str.c_str(), field_id_str.length(), &field_id)) {
-    if (field_id < 0) {
-      // Thrift should convert any negative value to null but normalize to -1
-      // here in case we later check this in logic.
+          fieldIdStr.c_str(), fieldIdStr.length(), &fieldId)) {
+    if (fieldId < 0) {
+      // Thrift should convert any negative value to null but normalize to -1.
+      // Here in case we later check this in logic.
       return -1;
     }
-    return field_id;
+    return fieldId;
   } else {
     return -1;
   }
 }
 
-Status FieldToNode(
+Status fieldToNode(
     const std::string& name,
     const std::shared_ptr<Field>& field,
     const WriterProperties& properties,
-    const ArrowWriterProperties& arrow_properties,
+    const ArrowWriterProperties& arrowProperties,
     NodePtr* out) {
-  std::shared_ptr<const LogicalType> logical_type = LogicalType::None();
+  std::shared_ptr<const LogicalType> logicalType = LogicalType::none();
   ParquetType::type type;
-  Repetition::type repetition = RepetitionFromNullable(field->nullable());
-  int field_id = FieldIdFromMetadata(field->metadata());
+  Repetition::type repetition = repetitionFromNullable(field->nullable());
+  int fieldId = fieldIdFromMetadata(field->metadata());
 
   int length = -1;
   int precision = -1;
@@ -395,186 +382,181 @@ Status FieldToNode(
 
   switch (field->type()->id()) {
     case ArrowTypeId::NA: {
-      type = ParquetType::INT32;
-      logical_type = LogicalType::Null();
-      if (repetition != Repetition::OPTIONAL) {
+      type = ParquetType::kInt32;
+      logicalType = LogicalType::nullType();
+      if (repetition != Repetition::kOptional) {
         return Status::Invalid("NullType Arrow field must be nullable");
       }
     } break;
     case ArrowTypeId::BOOL:
-      type = ParquetType::BOOLEAN;
+      type = ParquetType::kBoolean;
       break;
     case ArrowTypeId::UINT8:
-      type = ParquetType::INT32;
-      logical_type = LogicalType::Int(8, false);
+      type = ParquetType::kInt32;
+      logicalType = LogicalType::intType(8, false);
       break;
     case ArrowTypeId::INT8:
-      type = ParquetType::INT32;
-      logical_type = LogicalType::Int(8, true);
+      type = ParquetType::kInt32;
+      logicalType = LogicalType::intType(8, true);
       break;
     case ArrowTypeId::UINT16:
-      type = ParquetType::INT32;
-      logical_type = LogicalType::Int(16, false);
+      type = ParquetType::kInt32;
+      logicalType = LogicalType::intType(16, false);
       break;
     case ArrowTypeId::INT16:
-      type = ParquetType::INT32;
-      logical_type = LogicalType::Int(16, true);
+      type = ParquetType::kInt32;
+      logicalType = LogicalType::intType(16, true);
       break;
     case ArrowTypeId::UINT32:
       if (properties.version() == ParquetVersion::PARQUET_1_0) {
-        type = ParquetType::INT64;
+        type = ParquetType::kInt64;
       } else {
-        type = ParquetType::INT32;
-        logical_type = LogicalType::Int(32, false);
+        type = ParquetType::kInt32;
+        logicalType = LogicalType::intType(32, false);
       }
       break;
     case ArrowTypeId::INT32:
-      type = ParquetType::INT32;
+      type = ParquetType::kInt32;
       break;
     case ArrowTypeId::UINT64:
-      type = ParquetType::INT64;
-      logical_type = LogicalType::Int(64, false);
+      type = ParquetType::kInt64;
+      logicalType = LogicalType::intType(64, false);
       break;
     case ArrowTypeId::INT64:
-      type = ParquetType::INT64;
+      type = ParquetType::kInt64;
       break;
     case ArrowTypeId::FLOAT:
-      type = ParquetType::FLOAT;
+      type = ParquetType::kFloat;
       break;
     case ArrowTypeId::DOUBLE:
-      type = ParquetType::DOUBLE;
+      type = ParquetType::kDouble;
       break;
     case ArrowTypeId::LARGE_STRING:
     case ArrowTypeId::STRING:
-      type = ParquetType::BYTE_ARRAY;
-      logical_type = LogicalType::String();
+      type = ParquetType::kByteArray;
+      logicalType = LogicalType::string();
       break;
     case ArrowTypeId::LARGE_BINARY:
     case ArrowTypeId::BINARY:
-      type = ParquetType::BYTE_ARRAY;
+      type = ParquetType::kByteArray;
       break;
     case ArrowTypeId::FIXED_SIZE_BINARY: {
-      type = ParquetType::FIXED_LEN_BYTE_ARRAY;
-      const auto& fixed_size_binary_type =
+      type = ParquetType::kFixedLenByteArray;
+      const auto& fixedSizeBinaryType =
           static_cast<const ::arrow::FixedSizeBinaryType&>(*field->type());
-      length = fixed_size_binary_type.byte_width();
+      length = fixedSizeBinaryType.byte_width();
     } break;
     case ArrowTypeId::DECIMAL128:
     case ArrowTypeId::DECIMAL256: {
-      const auto& decimal_type =
+      const auto& decimalType =
           static_cast<const ::arrow::DecimalType&>(*field->type());
-      precision = decimal_type.precision();
-      scale = decimal_type.scale();
-      if (properties.store_decimal_as_integer() && 1 <= precision &&
+      precision = decimalType.precision();
+      scale = decimalType.scale();
+      if (properties.storeDecimalAsInteger() && 1 <= precision &&
           precision <= 18) {
-        type = precision <= 9 ? ParquetType ::INT32 : ParquetType ::INT64;
+        type = precision <= 9 ? ParquetType::kInt32 : ParquetType::kInt64;
       } else {
-        type = ParquetType::FIXED_LEN_BYTE_ARRAY;
+        type = ParquetType::kFixedLenByteArray;
         length = DecimalType::DecimalSize(precision);
       }
       PARQUET_CATCH_NOT_OK(
-          logical_type = LogicalType::Decimal(precision, scale));
+          logicalType = LogicalType::decimal(precision, scale));
     } break;
     case ArrowTypeId::DATE32:
-      type = ParquetType::INT32;
-      logical_type = LogicalType::Date();
+      type = ParquetType::kInt32;
+      logicalType = LogicalType::date();
       break;
     case ArrowTypeId::DATE64:
-      type = ParquetType::INT32;
-      logical_type = LogicalType::Date();
+      type = ParquetType::kInt32;
+      logicalType = LogicalType::date();
       break;
     case ArrowTypeId::TIMESTAMP:
-      RETURN_NOT_OK(GetTimestampMetadata(
+      RETURN_NOT_OK(getTimestampMetadata(
           static_cast<::arrow::TimestampType&>(*field->type()),
           properties,
-          arrow_properties,
+          arrowProperties,
           &type,
-          &logical_type));
+          &logicalType));
       break;
     case ArrowTypeId::TIME32:
-      type = ParquetType::INT32;
-      logical_type = LogicalType::Time(
-          /*is_adjusted_to_utc=*/true, LogicalType::TimeUnit::MILLIS);
+      type = ParquetType::kInt32;
+      logicalType = LogicalType::time(true, LogicalType::TimeUnit::kMillis);
       break;
     case ArrowTypeId::TIME64: {
-      type = ParquetType::INT64;
-      auto time_type = static_cast<::arrow::Time64Type*>(field->type().get());
-      if (time_type->unit() == ::arrow::TimeUnit::NANO) {
-        logical_type = LogicalType::Time(
-            /*is_adjusted_to_utc=*/true, LogicalType::TimeUnit::NANOS);
+      type = ParquetType::kInt64;
+      auto timeType = static_cast<::arrow::Time64Type*>(field->type().get());
+      if (timeType->unit() == ::arrow::TimeUnit::NANO) {
+        logicalType = LogicalType::time(true, LogicalType::TimeUnit::kNanos);
       } else {
-        logical_type = LogicalType::Time(
-            /*is_adjusted_to_utc=*/true, LogicalType::TimeUnit::MICROS);
+        logicalType = LogicalType::time(true, LogicalType::TimeUnit::kMicros);
       }
     } break;
     case ArrowTypeId::DURATION:
-      type = ParquetType::INT64;
+      type = ParquetType::kInt64;
       break;
     case ArrowTypeId::STRUCT: {
-      auto struct_type =
+      auto structType =
           std::static_pointer_cast<::arrow::StructType>(field->type());
-      return StructToNode(
-          struct_type,
+      return structToNode(
+          structType,
           name,
           field->nullable(),
-          field_id,
+          fieldId,
           properties,
-          arrow_properties,
+          arrowProperties,
           out);
     }
     case ArrowTypeId::FIXED_SIZE_LIST:
     case ArrowTypeId::LARGE_LIST:
     case ArrowTypeId::LIST: {
-      auto list_type =
+      auto listType =
           std::static_pointer_cast<::arrow::BaseListType>(field->type());
-      return ListToNode(
-          list_type,
+      return listToNode(
+          listType,
           name,
           field->nullable(),
-          field_id,
+          fieldId,
           properties,
-          arrow_properties,
+          arrowProperties,
           out);
     }
     case ArrowTypeId::DICTIONARY: {
       // Parquet has no Dictionary type, dictionary-encoded is handled on
       // the encoding, not the schema level.
-      const ::arrow::DictionaryType& dict_type =
+      const ::arrow::DictionaryType& dictType =
           static_cast<const ::arrow::DictionaryType&>(*field->type());
-      std::shared_ptr<::arrow::Field> unpacked_field = ::arrow::field(
-          name, dict_type.value_type(), field->nullable(), field->metadata());
-      return FieldToNode(
-          name, unpacked_field, properties, arrow_properties, out);
+      std::shared_ptr<::arrow::Field> unpackedField = ::arrow::field(
+          name, dictType.value_type(), field->nullable(), field->metadata());
+      return fieldToNode(name, unpackedField, properties, arrowProperties, out);
     }
     case ArrowTypeId::EXTENSION: {
-      auto ext_type =
+      auto extType =
           std::static_pointer_cast<::arrow::ExtensionType>(field->type());
-      std::shared_ptr<::arrow::Field> storage_field = ::arrow::field(
-          name, ext_type->storage_type(), field->nullable(), field->metadata());
-      return FieldToNode(
-          name, storage_field, properties, arrow_properties, out);
+      std::shared_ptr<::arrow::Field> storageField = ::arrow::field(
+          name, extType->storage_type(), field->nullable(), field->metadata());
+      return fieldToNode(name, storageField, properties, arrowProperties, out);
     }
     case ArrowTypeId::MAP: {
-      auto map_type = std::static_pointer_cast<::arrow::MapType>(field->type());
-      return MapToNode(
-          map_type,
+      auto mapType = std::static_pointer_cast<::arrow::MapType>(field->type());
+      return mapToNode(
+          mapType,
           name,
           field->nullable(),
-          field_id,
+          fieldId,
           properties,
-          arrow_properties,
+          arrowProperties,
           out);
     }
 
     default: {
-      // TODO: DENSE_UNION, SPARE_UNION, JSON_SCALAR, DECIMAL_TEXT, VARCHAR
+      // TODO: DENSE_UNION, SPARE_UNION, JSON_SCALAR, DECIMAL_TEXT, VARCHAR.
       return Status::NotImplemented(
           "Unhandled type for Arrow to Parquet schema conversion: ",
           field->type()->ToString());
     }
   }
 
-  PARQUET_CATCH_NOT_OK(*out = PrimitiveNode::Make(name, repetition, logical_type, type, length, field_id));
+  PARQUET_CATCH_NOT_OK(*out = PrimitiveNode::make(name, repetition, logicalType, type, length, fieldId));
 
   return Status::OK();
 }
@@ -584,165 +566,164 @@ struct SchemaTreeContext {
   ArrowReaderProperties properties;
   const SchemaDescriptor* schema;
 
-  void LinkParent(const SchemaField* child, const SchemaField* parent) {
-    manifest->child_to_parent[child] = parent;
+  void linkParent(const SchemaField* child, const SchemaField* parent) {
+    manifest->childToParent[child] = parent;
   }
 
-  void RecordLeaf(const SchemaField* leaf) {
-    manifest->column_index_to_field[leaf->column_index] = leaf;
+  void recordLeaf(const SchemaField* leaf) {
+    manifest->columnIndexToField[leaf->columnIndex] = leaf;
   }
 };
 
-bool IsDictionaryReadSupported(const ArrowType& type) {
-  // Only supported currently for BYTE_ARRAY types
+bool isDictionaryReadSupported(const ArrowType& type) {
+  // Only supported currently for BYTE_ARRAY types.
   return type.id() == ::arrow::Type::BINARY ||
       type.id() == ::arrow::Type::STRING;
 }
 
-// ----------------------------------------------------------------------
-// Schema logic
+// ----------------------------------------------------------------------.
+// Schema logic.
 
-::arrow::Result<std::shared_ptr<ArrowType>> GetTypeForNode(
-    int column_index,
-    const schema::PrimitiveNode& primitive_node,
+::arrow::Result<std::shared_ptr<ArrowType>> getTypeForNode(
+    int columnIndex,
+    const schema::PrimitiveNode& primitiveNode,
     SchemaTreeContext* ctx) {
   ARROW_ASSIGN_OR_RAISE(
-      std::shared_ptr<ArrowType> storage_type,
-      GetArrowType(
-          primitive_node, ctx->properties.coerce_int96_timestamp_unit()));
-  if (ctx->properties.read_dictionary(column_index) &&
-      IsDictionaryReadSupported(*storage_type)) {
-    return ::arrow::dictionary(::arrow::int32(), storage_type);
+      std::shared_ptr<ArrowType> storageType,
+      getArrowType(primitiveNode, ctx->properties.coerceInt96TimestampUnit()));
+  if (ctx->properties.readDictionary(columnIndex) &&
+      isDictionaryReadSupported(*storageType)) {
+    return ::arrow::dictionary(::arrow::int32(), storageType);
   }
-  return storage_type;
+  return storageType;
 }
 
-Status NodeToSchemaField(
+Status nodeToSchemaField(
     const Node& node,
-    LevelInfo current_levels,
+    LevelInfo currentLevels,
     SchemaTreeContext* ctx,
     const SchemaField* parent,
     SchemaField* out);
 
-Status GroupToSchemaField(
-    const GroupNode& node,
-    LevelInfo current_levels,
+Status groupToSchemaField(
+    const GroupNode& groupNode,
+    LevelInfo currentLevels,
     SchemaTreeContext* ctx,
     const SchemaField* parent,
     SchemaField* out);
 
-Status PopulateLeaf(
-    int column_index,
+Status populateLeaf(
+    int columnIndex,
     const std::shared_ptr<Field>& field,
-    LevelInfo current_levels,
+    LevelInfo currentLevels,
     SchemaTreeContext* ctx,
     const SchemaField* parent,
     SchemaField* out) {
   out->field = field;
-  out->column_index = column_index;
-  out->level_info = current_levels;
-  ctx->RecordLeaf(out);
-  ctx->LinkParent(out, parent);
+  out->columnIndex = columnIndex;
+  out->levelInfo = currentLevels;
+  ctx->recordLeaf(out);
+  ctx->linkParent(out, parent);
   return Status::OK();
 }
 
 // Special case mentioned in the format spec:
-//   If the name is array or ends in _tuple, this should be a list of struct
+//   If the name is array or ends in _tuple, this should be a list of struct,
 //   even for single child elements.
-bool HasStructListName(const GroupNode& node) {
-  ::std::string_view name{node.name()};
-  return name == "array" || EndsWith(name, "_tuple");
+bool hasStructListName(const GroupNode& groupNode) {
+  ::std::string_view name{groupNode.name()};
+  return name == "array" || endsWith(name, "_tuple");
 }
 
-Status GroupToStruct(
-    const GroupNode& node,
-    LevelInfo current_levels,
+Status groupToStruct(
+    const GroupNode& groupNode,
+    LevelInfo currentLevels,
     SchemaTreeContext* ctx,
     const SchemaField* parent,
     SchemaField* out) {
-  std::vector<std::shared_ptr<Field>> arrow_fields;
-  out->children.resize(node.field_count());
+  std::vector<std::shared_ptr<Field>> arrowFields;
+  out->children.resize(groupNode.fieldCount());
   // All level increments for the node are expected to happen by callers.
   // This is required because repeated elements need to have their own
   // SchemaField.
 
-  for (int i = 0; i < node.field_count(); i++) {
-    RETURN_NOT_OK(NodeToSchemaField(
-        *node.field(i), current_levels, ctx, out, &out->children[i]));
-    arrow_fields.push_back(out->children[i].field);
+  for (int i = 0; i < groupNode.fieldCount(); i++) {
+    RETURN_NOT_OK(nodeToSchemaField(
+        *groupNode.field(i), currentLevels, ctx, out, &out->children[i]));
+    arrowFields.push_back(out->children[i].field);
   }
-  auto struct_type = ::arrow::struct_(arrow_fields);
+  auto structType = ::arrow::struct_(arrowFields);
   out->field = ::arrow::field(
-      node.name(),
-      struct_type,
-      node.is_optional(),
-      FieldIdMetadata(node.field_id()));
-  out->level_info = current_levels;
+      groupNode.name(),
+      structType,
+      groupNode.isOptional(),
+      fieldIdMetadata(groupNode.fieldId()));
+  out->levelInfo = currentLevels;
   return Status::OK();
 }
 
-Status ListToSchemaField(
+Status listToSchemaField(
     const GroupNode& group,
-    LevelInfo current_levels,
+    LevelInfo currentLevels,
     SchemaTreeContext* ctx,
     const SchemaField* parent,
     SchemaField* out);
 
-Status MapToSchemaField(
+Status mapToSchemaField(
     const GroupNode& group,
-    LevelInfo current_levels,
+    LevelInfo currentLevels,
     SchemaTreeContext* ctx,
     const SchemaField* parent,
     SchemaField* out) {
-  if (group.field_count() != 1) {
+  if (group.fieldCount() != 1) {
     return Status::Invalid("MAP-annotated groups must have a single child.");
   }
-  if (group.is_repeated()) {
+  if (group.isRepeated()) {
     return Status::Invalid("MAP-annotated groups must not be repeated.");
   }
 
-  const Node& key_value_node = *group.field(0);
+  const Node& keyValueNode = *group.field(0);
 
-  if (!key_value_node.is_repeated()) {
+  if (!keyValueNode.isRepeated()) {
     return Status::Invalid(
         "Non-repeated key value in a MAP-annotated group are not supported.");
   }
 
-  if (!key_value_node.is_group()) {
+  if (!keyValueNode.isGroup()) {
     return Status::Invalid("Key-value node must be a group.");
   }
 
-  const GroupNode& key_value = checked_cast<const GroupNode&>(key_value_node);
-  if (key_value.field_count() != 1 && key_value.field_count() != 2) {
+  const GroupNode& keyValue = checked_cast<const GroupNode&>(keyValueNode);
+  if (keyValue.fieldCount() != 1 && keyValue.fieldCount() != 2) {
     return Status::Invalid(
         "Key-value map node must have 1 or 2 child elements. Found: ",
-        key_value.field_count());
+        keyValue.fieldCount());
   }
-  const Node& key_node = *key_value.field(0);
-  if (!key_node.is_required()) {
+  const Node& keyNode = *keyValue.field(0);
+  if (!keyNode.isRequired()) {
     return Status::Invalid("Map keys must be annotated as required.");
   }
-  // Arrow doesn't support 1 column maps (i.e. Sets).  The options are to either
-  // make the values column nullable, or process the map as a list.  We choose
-  // the latter as it is simpler.
-  if (key_value.field_count() == 1) {
-    return ListToSchemaField(group, current_levels, ctx, parent, out);
+  // Arrow doesn't support 1 column maps (i.e. Sets).  The options are to
+  // either make the values column nullable, or process the map as a list.  We
+  // choose the latter as it is simpler.
+  if (keyValue.fieldCount() == 1) {
+    return listToSchemaField(group, currentLevels, ctx, parent, out);
   }
 
-  IncrementLevels(current_levels, group);
-  int16_t repeated_ancestor_def_level = current_levels.IncrementRepeated();
+  incrementLevels(currentLevels, group);
+  int16_t repeatedAncestorDefLevel = currentLevels.IncrementRepeated();
 
   out->children.resize(1);
-  SchemaField* key_value_field = &out->children[0];
+  SchemaField* keyValueField = &out->children[0];
 
-  key_value_field->children.resize(2);
-  SchemaField* key_field = &key_value_field->children[0];
-  SchemaField* value_field = &key_value_field->children[1];
+  keyValueField->children.resize(2);
+  SchemaField* keyField = &keyValueField->children[0];
+  SchemaField* valueField = &keyValueField->children[1];
 
-  ctx->LinkParent(out, parent);
-  ctx->LinkParent(key_value_field, out);
-  ctx->LinkParent(key_field, key_value_field);
-  ctx->LinkParent(value_field, key_value_field);
+  ctx->linkParent(out, parent);
+  ctx->linkParent(keyValueField, out);
+  ctx->linkParent(keyField, keyValueField);
+  ctx->linkParent(valueField, keyValueField);
 
   // required/optional group name=whatever {
   //   repeated group name=key_values{
@@ -752,60 +733,60 @@ Status MapToSchemaField(
   // }
   //
 
-  RETURN_NOT_OK(NodeToSchemaField(
-      *key_value.field(0), current_levels, ctx, key_value_field, key_field));
-  RETURN_NOT_OK(NodeToSchemaField(
-      *key_value.field(1), current_levels, ctx, key_value_field, value_field));
+  RETURN_NOT_OK(nodeToSchemaField(
+      *keyValue.field(0), currentLevels, ctx, keyValueField, keyField));
+  RETURN_NOT_OK(nodeToSchemaField(
+      *keyValue.field(1), currentLevels, ctx, keyValueField, valueField));
 
-  key_value_field->field = ::arrow::field(
+  keyValueField->field = ::arrow::field(
       group.name(),
-      ::arrow::struct_({key_field->field, value_field->field}),
-      /*nullable=*/false,
-      FieldIdMetadata(key_value.field_id()));
-  key_value_field->level_info = current_levels;
+      ::arrow::struct_({keyField->field, valueField->field}),
+      false,
+      fieldIdMetadata(keyValue.fieldId()));
+  keyValueField->levelInfo = currentLevels;
 
   out->field = ::arrow::field(
       group.name(),
-      std::make_shared<::arrow::MapType>(key_value_field->field),
-      group.is_optional(),
-      FieldIdMetadata(group.field_id()));
-  out->level_info = current_levels;
-  // At this point current levels contains the def level for this list,
-  // we need to reset to the prior parent.
-  out->level_info.repeatedAncestorDefLevel = repeated_ancestor_def_level;
+      std::make_shared<::arrow::MapType>(keyValueField->field),
+      group.isOptional(),
+      fieldIdMetadata(group.fieldId()));
+  out->levelInfo = currentLevels;
+  // At this point current levels contains the def level for this list.
+  // We need to reset to the prior parent.
+  out->levelInfo.repeatedAncestorDefLevel = repeatedAncestorDefLevel;
   return Status::OK();
 }
 
-Status ListToSchemaField(
+Status listToSchemaField(
     const GroupNode& group,
-    LevelInfo current_levels,
+    LevelInfo currentLevels,
     SchemaTreeContext* ctx,
     const SchemaField* parent,
     SchemaField* out) {
-  if (group.field_count() != 1) {
+  if (group.fieldCount() != 1) {
     return Status::Invalid("LIST-annotated groups must have a single child.");
   }
-  if (group.is_repeated()) {
+  if (group.isRepeated()) {
     return Status::Invalid("LIST-annotated groups must not be repeated.");
   }
-  IncrementLevels(current_levels, group);
+  incrementLevels(currentLevels, group);
 
-  out->children.resize(group.field_count());
-  SchemaField* child_field = &out->children[0];
+  out->children.resize(group.fieldCount());
+  SchemaField* childField = &out->children[0];
 
-  ctx->LinkParent(out, parent);
-  ctx->LinkParent(child_field, out);
+  ctx->linkParent(out, parent);
+  ctx->linkParent(childField, out);
 
-  const Node& list_node = *group.field(0);
+  const Node& listNode = *group.field(0);
 
-  if (!list_node.is_repeated()) {
+  if (!listNode.isRepeated()) {
     return Status::Invalid(
         "Non-repeated nodes in a LIST-annotated group are not supported.");
   }
 
-  int16_t repeated_ancestor_def_level = current_levels.IncrementRepeated();
-  if (list_node.is_group()) {
-    // Resolve 3-level encoding
+  int16_t repeatedAncestorDefLevel = currentLevels.IncrementRepeated();
+  if (listNode.isGroup()) {
+    // Resolve 3-level encoding.
     //
     // required/optional group name=whatever {
     //   repeated group name=list {
@@ -813,9 +794,9 @@ Status ListToSchemaField(
     //   }
     // }
     //
-    // yields list<item: TYPE ?nullable> ?nullable
+    // Yields list<item: TYPE ?nullable> ?nullable.
     //
-    // We distinguish the special case that we have
+    // We distinguish the special case that we have.
     //
     // required/optional group name=whatever {
     //   repeated group name=array or $SOMETHING_tuple {
@@ -824,160 +805,152 @@ Status ListToSchemaField(
     // }
     //
     // In this latter case, the inner type of the list should be a struct
-    // rather than a primitive value
+    // rather than a primitive value.
     //
-    // yields list<item: struct<item: TYPE ?nullable> not null> ?nullable
-    const auto& list_group = static_cast<const GroupNode&>(list_node);
+    // Yields list<item: struct<item: TYPE ?nullable> not null> ?nullable.
+    const auto& listGroup = static_cast<const GroupNode&>(listNode);
     // Special case mentioned in the format spec:
-    //   If the name is array or ends in _tuple, this should be a list of struct
-    //   even for single child elements.
-    if (list_group.field_count() == 1 && !HasStructListName(list_group)) {
-      // List of primitive type
-      RETURN_NOT_OK(NodeToSchemaField(
-          *list_group.field(0), current_levels, ctx, out, child_field));
+    //   If the name is array or ends in _tuple, this should be a list of
+    //   struct, even for single child elements.
+    if (listGroup.fieldCount() == 1 && !hasStructListName(listGroup)) {
+      // List of primitive type.
+      RETURN_NOT_OK(nodeToSchemaField(
+          *listGroup.field(0), currentLevels, ctx, out, childField));
     } else {
       RETURN_NOT_OK(
-          GroupToStruct(list_group, current_levels, ctx, out, child_field));
+          groupToStruct(listGroup, currentLevels, ctx, out, childField));
     }
   } else {
-    // Two-level list encoding
+    // Two-level list encoding.
     //
     // required/optional group LIST {
     //   repeated TYPE;
     // }
-    const auto& primitive_node = static_cast<const PrimitiveNode&>(list_node);
-    int column_index = ctx->schema->GetColumnIndex(primitive_node);
+    const auto& primitiveNode = static_cast<const PrimitiveNode&>(listNode);
+    int columnIndex = ctx->schema->getColumnIndex(primitiveNode);
     ARROW_ASSIGN_OR_RAISE(
         std::shared_ptr<ArrowType> type,
-        GetTypeForNode(column_index, primitive_node, ctx));
-    auto item_field = ::arrow::field(
-        list_node.name(),
-        type,
-        /*nullable=*/false,
-        FieldIdMetadata(list_node.field_id()));
-    RETURN_NOT_OK(PopulateLeaf(
-        column_index, item_field, current_levels, ctx, out, child_field));
+        getTypeForNode(columnIndex, primitiveNode, ctx));
+    auto itemField = ::arrow::field(
+        listNode.name(), type, false, fieldIdMetadata(listNode.fieldId()));
+    RETURN_NOT_OK(populateLeaf(
+        columnIndex, itemField, currentLevels, ctx, out, childField));
   }
   out->field = ::arrow::field(
       group.name(),
-      ::arrow::list(child_field->field),
-      group.is_optional(),
-      FieldIdMetadata(group.field_id()));
-  out->level_info = current_levels;
-  // At this point current levels contains the def level for this list,
-  // we need to reset to the prior parent.
-  out->level_info.repeatedAncestorDefLevel = repeated_ancestor_def_level;
+      ::arrow::list(childField->field),
+      group.isOptional(),
+      fieldIdMetadata(group.fieldId()));
+  out->levelInfo = currentLevels;
+  // At this point current levels contains the def level for this list.
+  // We need to reset to the prior parent.
+  out->levelInfo.repeatedAncestorDefLevel = repeatedAncestorDefLevel;
   return Status::OK();
 }
 
-Status GroupToSchemaField(
-    const GroupNode& node,
-    LevelInfo current_levels,
+Status groupToSchemaField(
+    const GroupNode& groupNode,
+    LevelInfo currentLevels,
     SchemaTreeContext* ctx,
     const SchemaField* parent,
     SchemaField* out) {
-  if (node.logical_type()->is_list()) {
-    return ListToSchemaField(node, current_levels, ctx, parent, out);
-  } else if (node.logical_type()->is_map()) {
-    return MapToSchemaField(node, current_levels, ctx, parent, out);
+  if (groupNode.logicalType()->isList()) {
+    return listToSchemaField(groupNode, currentLevels, ctx, parent, out);
+  } else if (groupNode.logicalType()->isMap()) {
+    return mapToSchemaField(groupNode, currentLevels, ctx, parent, out);
   }
   std::shared_ptr<ArrowType> type;
-  if (node.is_repeated()) {
-    // Simple repeated struct
+  if (groupNode.isRepeated()) {
+    // Simple repeated struct.
     //
     // repeated group $NAME {
-    //   r/o TYPE[0] f0
-    //   r/o TYPE[1] f1
+    //   R/o TYPE[0] f0.
+    //   R/o TYPE[1] f1.
     // }
     out->children.resize(1);
 
-    int16_t repeated_ancestor_def_level = current_levels.IncrementRepeated();
+    int16_t repeatedAncestorDefLevel = currentLevels.IncrementRepeated();
     RETURN_NOT_OK(
-        GroupToStruct(node, current_levels, ctx, out, &out->children[0]));
+        groupToStruct(groupNode, currentLevels, ctx, out, &out->children[0]));
     out->field = ::arrow::field(
-        node.name(),
+        groupNode.name(),
         ::arrow::list(out->children[0].field),
-        /*nullable=*/false,
-        FieldIdMetadata(node.field_id()));
-
-    ctx->LinkParent(&out->children[0], out);
-    out->level_info = current_levels;
-    // At this point current_levels contains this list as the def level, we need
-    // to use the previous ancestor of this list.
-    out->level_info.repeatedAncestorDefLevel = repeated_ancestor_def_level;
+        false,
+        fieldIdMetadata(groupNode.fieldId()));
+
+    ctx->linkParent(&out->children[0], out);
+    out->levelInfo = currentLevels;
+    // At this point current_levels contains this list as the def level, we
+    // need to use the previous ancestor of this list.
+    out->levelInfo.repeatedAncestorDefLevel = repeatedAncestorDefLevel;
     return Status::OK();
   } else {
-    IncrementLevels(current_levels, node);
-    return GroupToStruct(node, current_levels, ctx, parent, out);
+    incrementLevels(currentLevels, groupNode);
+    return groupToStruct(groupNode, currentLevels, ctx, parent, out);
   }
 }
 
-Status NodeToSchemaField(
+Status nodeToSchemaField(
     const Node& node,
-    LevelInfo current_levels,
+    LevelInfo currentLevels,
     SchemaTreeContext* ctx,
     const SchemaField* parent,
     SchemaField* out) {
   // Workhorse function for converting a Parquet schema node to an Arrow
   // type. Handles different conventions for nested data.
 
-  ctx->LinkParent(out, parent);
+  ctx->linkParent(out, parent);
 
-  // Now, walk the schema and create a ColumnDescriptor for each leaf node
-  if (node.is_group()) {
-    // A nested field, but we don't know what kind yet
-    return GroupToSchemaField(
-        static_cast<const GroupNode&>(node), current_levels, ctx, parent, out);
+  // Now, walk the schema and create a ColumnDescriptor for each leaf node.
+  if (node.isGroup()) {
+    // A nested field, but we don't know what kind yet.
+    return groupToSchemaField(
+        static_cast<const GroupNode&>(node), currentLevels, ctx, parent, out);
   } else {
-    // Either a normal flat primitive type, or a list type encoded with 1-level
-    // list encoding. Note that the 3-level encoding is the form recommended by
-    // the parquet specification, but technically we can have either
+    // Either a normal flat primitive type, or a list type encoded with 1-level.
+    // List encoding. Note that the 3-level encoding is the form recommended by
+    // the Parquet specification, but technically we can have either.
     //
-    // required/optional $TYPE $FIELD_NAME
+    // Required/optional $TYPE $FIELD_NAME.
     //
-    // or
+    // Or.
     //
-    // repeated $TYPE $FIELD_NAME
-    const auto& primitive_node = static_cast<const PrimitiveNode&>(node);
-    int column_index = ctx->schema->GetColumnIndex(primitive_node);
+    // Repeated $TYPE $FIELD_NAME.
+    const auto& primitiveNode = static_cast<const PrimitiveNode&>(node);
+    int columnIndex = ctx->schema->getColumnIndex(primitiveNode);
     ARROW_ASSIGN_OR_RAISE(
         std::shared_ptr<ArrowType> type,
-        GetTypeForNode(column_index, primitive_node, ctx));
-    if (node.is_repeated()) {
+        getTypeForNode(columnIndex, primitiveNode, ctx));
+    if (node.isRepeated()) {
       // One-level list encoding, e.g.
       // a: repeated int32;
-      int16_t repeated_ancestor_def_level = current_levels.IncrementRepeated();
+      int16_t repeatedAncestorDefLevel = currentLevels.IncrementRepeated();
       out->children.resize(1);
-      auto child_field = ::arrow::field(node.name(), type, /*nullable=*/false);
-      RETURN_NOT_OK(PopulateLeaf(
-          column_index,
-          child_field,
-          current_levels,
-          ctx,
-          out,
-          &out->children[0]));
+      auto childField = ::arrow::field(node.name(), type, false);
+      RETURN_NOT_OK(populateLeaf(
+          columnIndex, childField, currentLevels, ctx, out, &out->children[0]));
 
       out->field = ::arrow::field(
           node.name(),
-          ::arrow::list(child_field),
-          /*nullable=*/false,
-          FieldIdMetadata(node.field_id()));
-      out->level_info = current_levels;
+          ::arrow::list(childField),
+          false,
+          fieldIdMetadata(node.fieldId()));
+      out->levelInfo = currentLevels;
       // At this point current_levels has consider this list the ancestor so
       // restore the actual ancestor.
-      out->level_info.repeatedAncestorDefLevel = repeated_ancestor_def_level;
+      out->levelInfo.repeatedAncestorDefLevel = repeatedAncestorDefLevel;
       return Status::OK();
     } else {
-      IncrementLevels(current_levels, node);
-      // A normal (required/optional) primitive node
-      return PopulateLeaf(
-          column_index,
+      incrementLevels(currentLevels, node);
+      // A normal (required/optional) primitive node.
+      return populateLeaf(
+          columnIndex,
           ::arrow::field(
               node.name(),
               type,
-              node.is_optional(),
-              FieldIdMetadata(node.field_id())),
-          current_levels,
+              node.isOptional(),
+              fieldIdMetadata(node.fieldId())),
+          currentLevels,
           ctx,
           parent,
           out);
@@ -985,93 +958,93 @@ Status NodeToSchemaField(
   }
 }
 
-// Get the original Arrow schema, as serialized in the Parquet metadata
-Status GetOriginSchema(
+// Get the original Arrow schema, as serialized in the Parquet metadata.
+Status getOriginSchema(
     const std::shared_ptr<const KeyValueMetadata>& metadata,
-    std::shared_ptr<const KeyValueMetadata>* clean_metadata,
+    std::shared_ptr<const KeyValueMetadata>* cleanMetadata,
     std::shared_ptr<::arrow::Schema>* out) {
   if (metadata == nullptr) {
     *out = nullptr;
-    *clean_metadata = nullptr;
+    *cleanMetadata = nullptr;
     return Status::OK();
   }
 
   static const std::string kArrowSchemaKey = "ARROW:schema";
-  int schema_index = metadata->FindKey(kArrowSchemaKey);
-  if (schema_index == -1) {
+  int schemaIndex = metadata->FindKey(kArrowSchemaKey);
+  if (schemaIndex == -1) {
     *out = nullptr;
-    *clean_metadata = metadata;
+    *cleanMetadata = metadata;
     return Status::OK();
   }
 
   // The original Arrow schema was serialized using the store_schema option.
   // We deserialize it here and use it to inform read options such as
   // dictionary-encoded fields.
-  auto decoded = ::arrow::util::base64_decode(metadata->value(schema_index));
-  auto schema_buf = std::make_shared<Buffer>(decoded);
+  auto decoded = ::arrow::util::base64_decode(metadata->value(schemaIndex));
+  auto schemaBuf = std::make_shared<Buffer>(decoded);
 
-  ::arrow::ipc::DictionaryMemo dict_memo;
-  ::arrow::io::BufferReader input(schema_buf);
+  ::arrow::ipc::DictionaryMemo dictMemo;
+  ::arrow::io::BufferReader input(schemaBuf);
 
-  ARROW_ASSIGN_OR_RAISE(*out, ::arrow::ipc::ReadSchema(&input, &dict_memo));
+  ARROW_ASSIGN_OR_RAISE(*out, ::arrow::ipc::ReadSchema(&input, &dictMemo));
 
   if (metadata->size() > 1) {
-    // Copy the metadata without the schema key
-    auto new_metadata = ::arrow::key_value_metadata({}, {});
-    new_metadata->reserve(metadata->size() - 1);
+    // Copy the metadata without the schema key.
+    auto newMetadata = ::arrow::key_value_metadata({}, {});
+    newMetadata->reserve(metadata->size() - 1);
     for (int64_t i = 0; i < metadata->size(); ++i) {
-      if (i == schema_index)
+      if (i == schemaIndex)
         continue;
-      new_metadata->Append(metadata->key(i), metadata->value(i));
+      newMetadata->Append(metadata->key(i), metadata->value(i));
     }
-    *clean_metadata = new_metadata;
+    *cleanMetadata = newMetadata;
   } else {
-    // No other keys, let metadata be null
-    *clean_metadata = nullptr;
+    // No other keys, let metadata be null.
+    *cleanMetadata = nullptr;
   }
   return Status::OK();
 }
 
-// Restore original Arrow field information that was serialized as Parquet
+// Restore original Arrow field information that was serialized as Parquet.
 // metadata but that is not necessarily present in the field reconstituted from
 // Parquet data (for example, Parquet timestamp types doesn't carry timezone
 // information).
 
-Result<bool> ApplyOriginalMetadata(
-    const Field& origin_field,
+Result<bool> applyOriginalMetadata(
+    const Field& originField,
     SchemaField* inferred);
 
-std::function<std::shared_ptr<::arrow::DataType>(FieldVector)> GetNestedFactory(
-    const ArrowType& origin_type,
-    const ArrowType& inferred_type) {
-  switch (inferred_type.id()) {
+std::function<std::shared_ptr<::arrow::DataType>(FieldVector)> getNestedFactory(
+    const ArrowType& originType,
+    const ArrowType& inferredType) {
+  switch (inferredType.id()) {
     case ::arrow::Type::STRUCT:
-      if (origin_type.id() == ::arrow::Type::STRUCT) {
+      if (originType.id() == ::arrow::Type::STRUCT) {
         return [](FieldVector fields) {
           return ::arrow::struct_(std::move(fields));
         };
       }
       break;
     case ::arrow::Type::LIST:
-      if (origin_type.id() == ::arrow::Type::LIST) {
+      if (originType.id() == ::arrow::Type::LIST) {
         return [](FieldVector fields) {
           VELOX_DCHECK_EQ(fields.size(), 1);
           return ::arrow::list(std::move(fields[0]));
         };
       }
-      if (origin_type.id() == ::arrow::Type::LARGE_LIST) {
+      if (originType.id() == ::arrow::Type::LARGE_LIST) {
         return [](FieldVector fields) {
           VELOX_DCHECK_EQ(fields.size(), 1);
           return ::arrow::large_list(std::move(fields[0]));
         };
       }
-      if (origin_type.id() == ::arrow::Type::FIXED_SIZE_LIST) {
-        const auto list_size =
-            checked_cast<const ::arrow::FixedSizeListType&>(origin_type)
+      if (originType.id() == ::arrow::Type::FIXED_SIZE_LIST) {
+        const auto listSize =
+            checked_cast<const ::arrow::FixedSizeListType&>(originType)
                 .list_size();
-        return [list_size](FieldVector fields) {
+        return [listSize](FieldVector fields) {
           VELOX_DCHECK_EQ(fields.size(), 1);
-          return ::arrow::fixed_size_list(std::move(fields[0]), list_size);
+          return ::arrow::fixed_size_list(std::move(fields[0]), listSize);
         };
       }
       break;
@@ -1081,140 +1054,140 @@ std::function<std::shared_ptr<::arrow::DataType>(FieldVector)> GetNestedFactory(
   return {};
 }
 
-Result<bool> ApplyOriginalStorageMetadata(
-    const Field& origin_field,
+Result<bool> applyOriginalStorageMetadata(
+    const Field& originField,
     SchemaField* inferred) {
   bool modified = false;
 
-  auto& origin_type = origin_field.type();
-  auto& inferred_type = inferred->field->type();
+  auto& originType = originField.type();
+  auto& inferredType = inferred->field->type();
 
-  const int num_children = inferred_type->num_fields();
+  const int numChildren = inferredType->num_fields();
 
-  if (num_children > 0 && origin_type->num_fields() == num_children) {
-    VELOX_DCHECK_EQ(static_cast<int>(inferred->children.size()), num_children);
-    const auto factory = GetNestedFactory(*origin_type, *inferred_type);
+  if (numChildren > 0 && originType->num_fields() == numChildren) {
+    VELOX_DCHECK_EQ(static_cast<int>(inferred->children.size()), numChildren);
+    const auto factory = getNestedFactory(*originType, *inferredType);
     if (factory) {
       // The type may be modified (e.g. LargeList) while the children stay the
-      // same
-      modified |= origin_type->id() != inferred_type->id();
+      // same.
+      modified |= originType->id() != inferredType->id();
 
-      // Apply original metadata recursively to children
-      for (int i = 0; i < inferred_type->num_fields(); ++i) {
+      // Apply original metadata recursively to children.
+      for (int i = 0; i < inferredType->num_fields(); ++i) {
         ARROW_ASSIGN_OR_RAISE(
-            const bool child_modified,
-            ApplyOriginalMetadata(
-                *origin_type->field(i), &inferred->children[i]));
-        modified |= child_modified;
+            const bool childModified,
+            applyOriginalMetadata(
+                *originType->field(i), &inferred->children[i]));
+        modified |= childModified;
       }
       if (modified) {
-        // Recreate this field using the modified child fields
-        ::arrow::FieldVector modified_children(inferred_type->num_fields());
-        for (int i = 0; i < inferred_type->num_fields(); ++i) {
-          modified_children[i] = inferred->children[i].field;
+        // Recreate this field using the modified child fields.
+        ::arrow::FieldVector modifiedChildren(inferredType->num_fields());
+        for (int i = 0; i < inferredType->num_fields(); ++i) {
+          modifiedChildren[i] = inferred->children[i].field;
         }
         inferred->field =
-            inferred->field->WithType(factory(std::move(modified_children)));
+            inferred->field->WithType(factory(std::move(modifiedChildren)));
       }
     }
   }
 
-  if (origin_type->id() == ::arrow::Type::TIMESTAMP &&
-      inferred_type->id() == ::arrow::Type::TIMESTAMP) {
-    // Restore time zone, if any
-    const auto& ts_type =
-        checked_cast<const ::arrow::TimestampType&>(*inferred_type);
-    const auto& ts_origin_type =
-        checked_cast<const ::arrow::TimestampType&>(*origin_type);
+  if (originType->id() == ::arrow::Type::TIMESTAMP &&
+      inferredType->id() == ::arrow::Type::TIMESTAMP) {
+    // Restore time zone, if any.
+    const auto& tsType =
+        checked_cast<const ::arrow::TimestampType&>(*inferredType);
+    const auto& tsOriginType =
+        checked_cast<const ::arrow::TimestampType&>(*originType);
 
     // If the data is tz-aware, then set the original time zone, since Parquet
-    // has no native storage for timezones
-    if (ts_type.timezone() == "UTC" && !ts_origin_type.timezone().empty()) {
-      if (ts_type.unit() == ts_origin_type.unit()) {
-        inferred->field = inferred->field->WithType(origin_type);
+    // has no native storage for timezones.
+    if (tsType.timezone() == "UTC" && !tsOriginType.timezone().empty()) {
+      if (tsType.unit() == tsOriginType.unit()) {
+        inferred->field = inferred->field->WithType(originType);
       } else {
-        auto ts_type_new =
-            ::arrow::timestamp(ts_type.unit(), ts_origin_type.timezone());
-        inferred->field = inferred->field->WithType(ts_type_new);
+        auto tsTypeNew =
+            ::arrow::timestamp(tsType.unit(), tsOriginType.timezone());
+        inferred->field = inferred->field->WithType(tsTypeNew);
       }
     }
     modified = true;
   }
 
-  if (origin_type->id() == ::arrow::Type::DURATION &&
-      inferred_type->id() == ::arrow::Type::INT64) {
+  if (originType->id() == ::arrow::Type::DURATION &&
+      inferredType->id() == ::arrow::Type::INT64) {
     // Read back int64 arrays as duration.
-    inferred->field = inferred->field->WithType(origin_type);
+    inferred->field = inferred->field->WithType(originType);
     modified = true;
   }
 
-  if (origin_type->id() == ::arrow::Type::DICTIONARY &&
-      inferred_type->id() != ::arrow::Type::DICTIONARY &&
-      IsDictionaryReadSupported(*inferred_type)) {
+  if (originType->id() == ::arrow::Type::DICTIONARY &&
+      inferredType->id() != ::arrow::Type::DICTIONARY &&
+      isDictionaryReadSupported(*inferredType)) {
     // Direct dictionary reads are only supported for a couple primitive types,
     // so no need to recurse on value types.
-    const auto& dict_origin_type =
-        checked_cast<const ::arrow::DictionaryType&>(*origin_type);
-    inferred->field = inferred->field->WithType(::arrow::dictionary(
-        ::arrow::int32(), inferred_type, dict_origin_type.ordered()));
+    const auto& dictOriginType =
+        checked_cast<const ::arrow::DictionaryType&>(*originType);
+    inferred->field = inferred->field->WithType(
+        ::arrow::dictionary(
+            ::arrow::int32(), inferredType, dictOriginType.ordered()));
     modified = true;
   }
 
-  if ((origin_type->id() == ::arrow::Type::LARGE_BINARY &&
-       inferred_type->id() == ::arrow::Type::BINARY) ||
-      (origin_type->id() == ::arrow::Type::LARGE_STRING &&
-       inferred_type->id() == ::arrow::Type::STRING)) {
+  if ((originType->id() == ::arrow::Type::LARGE_BINARY &&
+       inferredType->id() == ::arrow::Type::BINARY) ||
+      (originType->id() == ::arrow::Type::LARGE_STRING &&
+       inferredType->id() == ::arrow::Type::STRING)) {
     // Read back binary-like arrays with the intended offset width.
-    inferred->field = inferred->field->WithType(origin_type);
+    inferred->field = inferred->field->WithType(originType);
     modified = true;
   }
 
-  if (origin_type->id() == ::arrow::Type::DECIMAL256 &&
-      inferred_type->id() == ::arrow::Type::DECIMAL128) {
-    inferred->field = inferred->field->WithType(origin_type);
+  if (originType->id() == ::arrow::Type::DECIMAL256 &&
+      inferredType->id() == ::arrow::Type::DECIMAL128) {
+    inferred->field = inferred->field->WithType(originType);
     modified = true;
   }
 
-  // Restore field metadata
-  std::shared_ptr<const KeyValueMetadata> field_metadata =
-      origin_field.metadata();
-  if (field_metadata != nullptr) {
+  // Restore field metadata.
+  std::shared_ptr<const KeyValueMetadata> fieldMetadata =
+      originField.metadata();
+  if (fieldMetadata != nullptr) {
     if (inferred->field->metadata()) {
-      // Prefer the metadata keys (like field_id) from the current metadata
-      field_metadata = field_metadata->Merge(*inferred->field->metadata());
+      // Prefer the metadata keys (like field_id) from the current metadata.
+      fieldMetadata = fieldMetadata->Merge(*inferred->field->metadata());
     }
-    inferred->field = inferred->field->WithMetadata(field_metadata);
+    inferred->field = inferred->field->WithMetadata(fieldMetadata);
     modified = true;
   }
 
   return modified;
 }
 
-Result<bool> ApplyOriginalMetadata(
-    const Field& origin_field,
+Result<bool> applyOriginalMetadata(
+    const Field& originField,
     SchemaField* inferred) {
   bool modified = false;
 
-  auto& origin_type = origin_field.type();
+  auto& originType = originField.type();
 
-  if (origin_type->id() == ::arrow::Type::EXTENSION) {
-    const auto& ex_type =
-        checked_cast<const ::arrow::ExtensionType&>(*origin_type);
-    auto origin_storage_field = origin_field.WithType(ex_type.storage_type());
+  if (originType->id() == ::arrow::Type::EXTENSION) {
+    const auto& exType =
+        checked_cast<const ::arrow::ExtensionType&>(*originType);
+    auto originStorageField = originField.WithType(exType.storage_type());
 
-    // Apply metadata recursively to storage type
-    RETURN_NOT_OK(
-        ApplyOriginalStorageMetadata(*origin_storage_field, inferred));
+    // Apply metadata recursively to storage type.
+    RETURN_NOT_OK(applyOriginalStorageMetadata(*originStorageField, inferred));
 
     // Restore extension type, if the storage type is the same as inferred
-    // from the Parquet type
-    if (ex_type.storage_type()->Equals(*inferred->field->type())) {
-      inferred->field = inferred->field->WithType(origin_type);
+    // from the Parquet type.
+    if (exType.storage_type()->Equals(*inferred->field->type())) {
+      inferred->field = inferred->field->WithType(originType);
     }
     modified = true;
   } else {
     ARROW_ASSIGN_OR_RAISE(
-        modified, ApplyOriginalStorageMetadata(origin_field, inferred));
+        modified, applyOriginalStorageMetadata(originField, inferred));
   }
 
   return modified;
@@ -1222,79 +1195,87 @@ Result<bool> ApplyOriginalMetadata(
 
 } // namespace
 
-Status FieldToNode(
+std::shared_ptr<::arrow::KeyValueMetadata> fieldIdMetadata(int fieldId) {
+  if (fieldId >= 0) {
+    return ::arrow::key_value_metadata({FIELD_ID_KEY}, {toChars(fieldId)});
+  } else {
+    return nullptr;
+  }
+}
+
+Status fieldToNode(
     const std::shared_ptr<Field>& field,
     const WriterProperties& properties,
-    const ArrowWriterProperties& arrow_properties,
+    const ArrowWriterProperties& arrowProperties,
     NodePtr* out) {
-  return FieldToNode(field->name(), field, properties, arrow_properties, out);
+  return fieldToNode(field->name(), field, properties, arrowProperties, out);
 }
 
-Status ToParquetSchema(
-    const ::arrow::Schema* arrow_schema,
+Status toParquetSchema(
+    const ::arrow::Schema* arrowSchema,
     const WriterProperties& properties,
-    const ArrowWriterProperties& arrow_properties,
+    const ArrowWriterProperties& arrowProperties,
     std::shared_ptr<SchemaDescriptor>* out) {
-  std::vector<NodePtr> nodes(arrow_schema->num_fields());
-  for (int i = 0; i < arrow_schema->num_fields(); i++) {
-    RETURN_NOT_OK(FieldToNode(
-        arrow_schema->field(i), properties, arrow_properties, &nodes[i]));
+  std::vector<NodePtr> nodes(arrowSchema->num_fields());
+  for (int i = 0; i < arrowSchema->num_fields(); i++) {
+    RETURN_NOT_OK(fieldToNode(
+        arrowSchema->field(i), properties, arrowProperties, &nodes[i]));
   }
 
-  NodePtr schema = GroupNode::Make("schema", Repetition::REQUIRED, nodes);
+  NodePtr schema = GroupNode::make("schema", Repetition::kRequired, nodes);
   *out = std::make_shared<SchemaDescriptor>();
-  PARQUET_CATCH_NOT_OK((*out)->Init(schema));
+  PARQUET_CATCH_NOT_OK((*out)->init(schema));
 
   return Status::OK();
 }
 
-Status ToParquetSchema(
-    const ::arrow::Schema* arrow_schema,
+Status toParquetSchema(
+    const ::arrow::Schema* arrowSchema,
     const WriterProperties& properties,
     std::shared_ptr<SchemaDescriptor>* out) {
-  return ToParquetSchema(
-      arrow_schema, properties, *default_arrow_writer_properties(), out);
+  return toParquetSchema(
+      arrowSchema, properties, *defaultArrowWriterProperties(), out);
 }
 
-Status FromParquetSchema(
+Status fromParquetSchema(
     const SchemaDescriptor* schema,
     const ArrowReaderProperties& properties,
-    const std::shared_ptr<const KeyValueMetadata>& key_value_metadata,
+    const std::shared_ptr<const KeyValueMetadata>& keyValueMetadata,
     std::shared_ptr<::arrow::Schema>* out) {
   SchemaManifest manifest;
   RETURN_NOT_OK(
-      SchemaManifest::Make(schema, key_value_metadata, properties, &manifest));
-  std::vector<std::shared_ptr<Field>> fields(manifest.schema_fields.size());
+      SchemaManifest::make(schema, keyValueMetadata, properties, &manifest));
+  std::vector<std::shared_ptr<Field>> fields(manifest.schemaFields.size());
 
   for (int i = 0; i < static_cast<int>(fields.size()); i++) {
-    const auto& schema_field = manifest.schema_fields[i];
-    fields[i] = schema_field.field;
+    const auto& schemaField = manifest.schemaFields[i];
+    fields[i] = schemaField.field;
   }
-  if (manifest.origin_schema) {
+  if (manifest.originSchema) {
     // ARROW-8980: If the ARROW:schema was in the input metadata, then
-    // manifest.origin_schema will have it scrubbed out
-    *out = ::arrow::schema(fields, manifest.origin_schema->metadata());
+    // manifest.originSchema will have it scrubbed out.
+    *out = ::arrow::schema(fields, manifest.originSchema->metadata());
   } else {
-    *out = ::arrow::schema(fields, key_value_metadata);
+    *out = ::arrow::schema(fields, keyValueMetadata);
   }
   return Status::OK();
 }
 
-Status FromParquetSchema(
-    const SchemaDescriptor* parquet_schema,
+Status fromParquetSchema(
+    const SchemaDescriptor* parquetSchema,
     const ArrowReaderProperties& properties,
     std::shared_ptr<::arrow::Schema>* out) {
-  return FromParquetSchema(parquet_schema, properties, nullptr, out);
+  return fromParquetSchema(parquetSchema, properties, nullptr, out);
 }
 
-Status FromParquetSchema(
-    const SchemaDescriptor* parquet_schema,
+Status fromParquetSchema(
+    const SchemaDescriptor* parquetSchema,
     std::shared_ptr<::arrow::Schema>* out) {
   ArrowReaderProperties properties;
-  return FromParquetSchema(parquet_schema, properties, nullptr, out);
+  return fromParquetSchema(parquetSchema, properties, nullptr, out);
 }
 
-Status SchemaManifest::Make(
+Status SchemaManifest::make(
     const SchemaDescriptor* schema,
     const std::shared_ptr<const KeyValueMetadata>& metadata,
     const ArrowReaderProperties& properties,
@@ -1303,38 +1284,34 @@ Status SchemaManifest::Make(
   ctx.manifest = manifest;
   ctx.properties = properties;
   ctx.schema = schema;
-  const GroupNode& schema_node = *schema->group_node();
+  const GroupNode& schemaNode = *schema->groupNode();
   manifest->descr = schema;
-  manifest->schema_fields.resize(schema_node.field_count());
-
-  // Try to deserialize original Arrow schema
-  RETURN_NOT_OK(GetOriginSchema(
-      metadata, &manifest->schema_metadata, &manifest->origin_schema));
-  // Ignore original schema if it's not compatible with the Parquet schema
-  if (manifest->origin_schema != nullptr &&
-      manifest->origin_schema->num_fields() != schema_node.field_count()) {
-    manifest->origin_schema = nullptr;
+  manifest->schemaFields.resize(schemaNode.fieldCount());
+
+  // Try to deserialize original Arrow schema.
+  RETURN_NOT_OK(getOriginSchema(
+      metadata, &manifest->schemaMetadata, &manifest->originSchema));
+  // Ignore original schema if it's not compatible with the Parquet schema.
+  if (manifest->originSchema != nullptr &&
+      manifest->originSchema->num_fields() != schemaNode.fieldCount()) {
+    manifest->originSchema = nullptr;
   }
 
-  for (int i = 0; i < static_cast<int>(schema_node.field_count()); ++i) {
-    SchemaField* out_field = &manifest->schema_fields[i];
-    RETURN_NOT_OK(NodeToSchemaField(
-        *schema_node.field(i),
-        LevelInfo(),
-        &ctx,
-        /*parent=*/nullptr,
-        out_field));
+  for (int i = 0; i < static_cast<int>(schemaNode.fieldCount()); ++i) {
+    SchemaField* outField = &manifest->schemaFields[i];
+    RETURN_NOT_OK(nodeToSchemaField(
+        *schemaNode.field(i), LevelInfo(), &ctx, nullptr, outField));
 
-    // TODO(wesm): as follow up to ARROW-3246, we should really pass the origin
+    // TODO(wesm): As follow up to ARROW-3246, we should really pass the origin
     // schema (if any) through all functions in the schema reconstruction, but
     // I'm being lazy and just setting dictionary fields at the top level for
-    // now
-    if (manifest->origin_schema == nullptr) {
+    // now.
+    if (manifest->originSchema == nullptr) {
       continue;
     }
 
-    auto& origin_field = manifest->origin_schema->field(i);
-    RETURN_NOT_OK(ApplyOriginalMetadata(*origin_field, out_field));
+    auto& originField = manifest->originSchema->field(i);
+    RETURN_NOT_OK(applyOriginalMetadata(*originField, outField));
   }
   return Status::OK();
 }
diff --git a/velox/dwio/parquet/writer/arrow/ArrowSchema.h b/velox/dwio/parquet/writer/arrow/ArrowSchema.h
index 8302bc1cdb1..6a49edce39c 100644
--- a/velox/dwio/parquet/writer/arrow/ArrowSchema.h
+++ b/velox/dwio/parquet/writer/arrow/ArrowSchema.h
@@ -47,153 +47,155 @@ namespace arrow {
 /// @{
 
 PARQUET_EXPORT
-::arrow::Status FieldToNode(
+::arrow::Status fieldToNode(
     const std::shared_ptr<::arrow::Field>& field,
     const WriterProperties& properties,
-    const ArrowWriterProperties& arrow_properties,
+    const ArrowWriterProperties& arrowProperties,
     schema::NodePtr* out);
 
 PARQUET_EXPORT
-::arrow::Status ToParquetSchema(
-    const ::arrow::Schema* arrow_schema,
+::arrow::Status toParquetSchema(
+    const ::arrow::Schema* arrowSchema,
     const WriterProperties& properties,
-    const ArrowWriterProperties& arrow_properties,
+    const ArrowWriterProperties& arrowProperties,
     std::shared_ptr<SchemaDescriptor>* out);
 
 PARQUET_EXPORT
-::arrow::Status ToParquetSchema(
-    const ::arrow::Schema* arrow_schema,
+::arrow::Status toParquetSchema(
+    const ::arrow::Schema* arrowSchema,
     const WriterProperties& properties,
     std::shared_ptr<SchemaDescriptor>* out);
 
 /// @}
 
 /// \defgroup parquet-to-arrow-schema-conversion Functions to convert a Parquet
-/// schema into an Arrow schema.
+/// schema into an arrow schema.
 ///
 /// @{
 
 PARQUET_EXPORT
-::arrow::Status FromParquetSchema(
-    const SchemaDescriptor* parquet_schema,
+::arrow::Status fromParquetSchema(
+    const SchemaDescriptor* parquetSchema,
     const ArrowReaderProperties& properties,
-    const std::shared_ptr<const ::arrow::KeyValueMetadata>& key_value_metadata,
+    const std::shared_ptr<const ::arrow::KeyValueMetadata>& keyValueMetadata,
     std::shared_ptr<::arrow::Schema>* out);
 
 PARQUET_EXPORT
-::arrow::Status FromParquetSchema(
-    const SchemaDescriptor* parquet_schema,
+::arrow::Status fromParquetSchema(
+    const SchemaDescriptor* parquetSchema,
     const ArrowReaderProperties& properties,
     std::shared_ptr<::arrow::Schema>* out);
 
 PARQUET_EXPORT
-::arrow::Status FromParquetSchema(
-    const SchemaDescriptor* parquet_schema,
+::arrow::Status fromParquetSchema(
+    const SchemaDescriptor* parquetSchema,
     std::shared_ptr<::arrow::Schema>* out);
 
 /// @}
 
-/// \brief Bridge between an arrow::Field and parquet column indices.
+/// \brief Bridge between an arrow::Field and Parquet column indices.
 struct PARQUET_EXPORT SchemaField {
   std::shared_ptr<::arrow::Field> field;
   std::vector<SchemaField> children;
 
-  // Only set for leaf nodes
-  int column_index = -1;
+  // Only set for leaf nodes.
+  int columnIndex = -1;
 
-  LevelInfo level_info;
+  LevelInfo levelInfo;
 
-  bool is_leaf() const {
-    return column_index != -1;
+  bool isLeaf() const {
+    return columnIndex != -1;
   }
 };
 
 /// \brief Bridge between a parquet Schema and an arrow Schema.
 ///
-/// Expose parquet columns as a tree structure. Useful traverse and link
-/// between arrow's Schema and parquet's Schema.
+/// Expose Parquet columns as a tree structure. Useful to traverse and link
+/// between Arrow and Parquet schemas.
 struct PARQUET_EXPORT SchemaManifest {
-  static ::arrow::Status Make(
+  static ::arrow::Status make(
       const SchemaDescriptor* schema,
       const std::shared_ptr<const ::arrow::KeyValueMetadata>& metadata,
       const ArrowReaderProperties& properties,
       SchemaManifest* manifest);
 
   const SchemaDescriptor* descr;
-  std::shared_ptr<::arrow::Schema> origin_schema;
-  std::shared_ptr<const ::arrow::KeyValueMetadata> schema_metadata;
-  std::vector<SchemaField> schema_fields;
+  std::shared_ptr<::arrow::Schema> originSchema;
+  std::shared_ptr<const ::arrow::KeyValueMetadata> schemaMetadata;
+  std::vector<SchemaField> schemaFields;
 
-  std::unordered_map<int, const SchemaField*> column_index_to_field;
-  std::unordered_map<const SchemaField*, const SchemaField*> child_to_parent;
+  std::unordered_map<int, const SchemaField*> columnIndexToField;
+  std::unordered_map<const SchemaField*, const SchemaField*> childToParent;
 
-  ::arrow::Status GetColumnField(int column_index, const SchemaField** out)
+  ::arrow::Status getColumnField(int columnIndex, const SchemaField** out)
       const {
-    auto it = column_index_to_field.find(column_index);
-    if (it == column_index_to_field.end()) {
+    auto it = columnIndexToField.find(columnIndex);
+    if (it == columnIndexToField.end()) {
       return ::arrow::Status::KeyError(
           "Column index ",
-          column_index,
+          columnIndex,
           " not found in schema manifest, may be malformed");
     }
     *out = it->second;
     return ::arrow::Status::OK();
   }
 
-  const SchemaField* GetParent(const SchemaField* field) const {
-    // Returns nullptr also if not found
-    auto it = child_to_parent.find(field);
-    if (it == child_to_parent.end()) {
+  const SchemaField* getParent(const SchemaField* field) const {
+    // Returns nullptr also if not found.
+    auto it = childToParent.find(field);
+    if (it == childToParent.end()) {
       return NULLPTR;
     }
     return it->second;
   }
 
   /// Coalesce a list of field indices (relative to the equivalent
-  /// arrow::Schema) which correspond to the column root (first node below the
-  /// parquet schema's root group) of each leaf referenced in column_indices.
+  /// Arrow schema) which correspond to the column root (first node below the
+  /// Parquet schema's root group) of each leaf referenced in columnIndices.
   ///
-  /// For example, for leaves `a.b.c`, `a.b.d.e`, and `i.j.k`
-  /// (column_indices=[0,1,3]) the roots are `a` and `i` (return=[0,2]).
+  /// For example, for leaves `a.b.c`, `a.b.d.e`, and `i.j.k`.
+  /// (Column_indices=[0,1,3]) the roots are `a` and `i` (return=[0,2]).
   ///
-  /// root
-  /// -- a  <------
-  /// -- -- b  |  |
-  /// -- -- -- c  |
-  /// -- -- -- d  |
-  /// -- -- -- -- e
-  /// -- f
-  /// -- -- g
-  /// -- -- -- h
-  /// -- i  <---
-  /// -- -- j  |
-  /// -- -- -- k
-  ::arrow::Result<std::vector<int>> GetFieldIndices(
-      const std::vector<int>& column_indices) const {
-    const schema::GroupNode* group = descr->group_node();
-    std::unordered_set<int> already_added;
+  /// Root.
+  /// -- A  <------.
+  /// -- -- B  |  |.
+  /// -- -- -- C  |.
+  /// -- -- -- D  |.
+  /// -- -- -- -- E.
+  /// -- F.
+  /// -- -- G.
+  /// -- -- -- H.
+  /// -- I  <---.
+  /// -- -- J  |.
+  /// -- -- -- K.
+  ::arrow::Result<std::vector<int>> getFieldIndices(
+      const std::vector<int>& columnIndices) const {
+    const schema::GroupNode* group = descr->groupNode();
+    std::unordered_set<int> alreadyAdded;
 
     std::vector<int> out;
-    for (int column_idx : column_indices) {
-      if (column_idx < 0 || column_idx >= descr->num_columns()) {
+    for (int columnIdx : columnIndices) {
+      if (columnIdx < 0 || columnIdx >= descr->numColumns()) {
         return ::arrow::Status::IndexError(
-            "Column index ", column_idx, " is not valid");
+            "Column index ", columnIdx, " is not valid");
       }
 
-      auto field_node = descr->GetColumnRoot(column_idx);
-      auto field_idx = group->FieldIndex(*field_node);
-      if (field_idx == -1) {
+      auto fieldNode = descr->getColumnRoot(columnIdx);
+      auto fieldIdx = group->fieldIndex(*fieldNode);
+      if (fieldIdx == -1) {
         return ::arrow::Status::IndexError(
-            "Column index ", column_idx, " is not valid");
+            "Column index ", columnIdx, " is not valid");
       }
 
-      if (already_added.insert(field_idx).second) {
-        out.push_back(field_idx);
+      if (alreadyAdded.insert(fieldIdx).second) {
+        out.push_back(fieldIdx);
       }
     }
     return out;
   }
 };
 
+std::shared_ptr<::arrow::KeyValueMetadata> fieldIdMetadata(int32_t fieldId);
+
 } // namespace arrow
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/ArrowSchemaInternal.cpp b/velox/dwio/parquet/writer/arrow/ArrowSchemaInternal.cpp
index 246df606ce3..8681462bfc7 100644
--- a/velox/dwio/parquet/writer/arrow/ArrowSchemaInternal.cpp
+++ b/velox/dwio/parquet/writer/arrow/ArrowSchemaInternal.cpp
@@ -30,217 +30,216 @@ using ::arrow::Result;
 using ::arrow::Status;
 using ::arrow::internal::checked_cast;
 
-Result<std::shared_ptr<ArrowType>> MakeArrowDecimal(
-    const LogicalType& logical_type) {
-  const auto& decimal = checked_cast<const DecimalLogicalType&>(logical_type);
+Result<std::shared_ptr<ArrowType>> makeArrowDecimal(
+    const LogicalType& logicalType) {
+  const auto& decimal = checked_cast<const DecimalLogicalType&>(logicalType);
   if (decimal.precision() <= ::arrow::Decimal128Type::kMaxPrecision) {
     return ::arrow::Decimal128Type::Make(decimal.precision(), decimal.scale());
   }
   return ::arrow::Decimal256Type::Make(decimal.precision(), decimal.scale());
 }
 
-Result<std::shared_ptr<ArrowType>> MakeArrowInt(
-    const LogicalType& logical_type) {
-  const auto& integer = checked_cast<const IntLogicalType&>(logical_type);
-  switch (integer.bit_width()) {
+Result<std::shared_ptr<ArrowType>> makeArrowInt(
+    const LogicalType& logicalType) {
+  const auto& integer = checked_cast<const IntLogicalType&>(logicalType);
+  switch (integer.bitWidth()) {
     case 8:
-      return integer.is_signed() ? ::arrow::int8() : ::arrow::uint8();
+      return integer.isSigned() ? ::arrow::int8() : ::arrow::uint8();
     case 16:
-      return integer.is_signed() ? ::arrow::int16() : ::arrow::uint16();
+      return integer.isSigned() ? ::arrow::int16() : ::arrow::uint16();
     case 32:
-      return integer.is_signed() ? ::arrow::int32() : ::arrow::uint32();
+      return integer.isSigned() ? ::arrow::int32() : ::arrow::uint32();
     default:
       return Status::TypeError(
-          logical_type.ToString(), " can not annotate physical type Int32");
+          logicalType.toString(), " can not annotate physical type Int32");
   }
 }
 
-Result<std::shared_ptr<ArrowType>> MakeArrowInt64(
-    const LogicalType& logical_type) {
-  const auto& integer = checked_cast<const IntLogicalType&>(logical_type);
-  switch (integer.bit_width()) {
+Result<std::shared_ptr<ArrowType>> makeArrowInt64(
+    const LogicalType& logicalType) {
+  const auto& integer = checked_cast<const IntLogicalType&>(logicalType);
+  switch (integer.bitWidth()) {
     case 64:
-      return integer.is_signed() ? ::arrow::int64() : ::arrow::uint64();
+      return integer.isSigned() ? ::arrow::int64() : ::arrow::uint64();
     default:
       return Status::TypeError(
-          logical_type.ToString(), " can not annotate physical type Int64");
+          logicalType.toString(), " can not annotate physical type Int64");
   }
 }
 
-Result<std::shared_ptr<ArrowType>> MakeArrowTime32(
-    const LogicalType& logical_type) {
-  const auto& time = checked_cast<const TimeLogicalType&>(logical_type);
-  switch (time.time_unit()) {
-    case LogicalType::TimeUnit::MILLIS:
+Result<std::shared_ptr<ArrowType>> makeArrowTime32(
+    const LogicalType& logicalType) {
+  const auto& time = checked_cast<const TimeLogicalType&>(logicalType);
+  switch (time.timeUnit()) {
+    case LogicalType::TimeUnit::kMillis:
       return ::arrow::time32(::arrow::TimeUnit::MILLI);
     default:
       return Status::TypeError(
-          logical_type.ToString(), " can not annotate physical type Time32");
+          logicalType.toString(), " can not annotate physical type Time32");
   }
 }
 
-Result<std::shared_ptr<ArrowType>> MakeArrowTime64(
-    const LogicalType& logical_type) {
-  const auto& time = checked_cast<const TimeLogicalType&>(logical_type);
-  switch (time.time_unit()) {
-    case LogicalType::TimeUnit::MICROS:
+Result<std::shared_ptr<ArrowType>> makeArrowTime64(
+    const LogicalType& logicalType) {
+  const auto& time = checked_cast<const TimeLogicalType&>(logicalType);
+  switch (time.timeUnit()) {
+    case LogicalType::TimeUnit::kMicros:
       return ::arrow::time64(::arrow::TimeUnit::MICRO);
-    case LogicalType::TimeUnit::NANOS:
+    case LogicalType::TimeUnit::kNanos:
       return ::arrow::time64(::arrow::TimeUnit::NANO);
     default:
       return Status::TypeError(
-          logical_type.ToString(), " can not annotate physical type Time64");
+          logicalType.toString(), " can not annotate physical type Time64");
   }
 }
 
-Result<std::shared_ptr<ArrowType>> MakeArrowTimestamp(
-    const LogicalType& logical_type) {
+Result<std::shared_ptr<ArrowType>> makeArrowTimestamp(
+    const LogicalType& logicalType) {
   const auto& timestamp =
-      checked_cast<const TimestampLogicalType&>(logical_type);
-  const bool utc_normalized = timestamp.is_from_converted_type()
-      ? false
-      : timestamp.is_adjusted_to_utc();
-  static const char* utc_timezone = "UTC";
-  switch (timestamp.time_unit()) {
-    case LogicalType::TimeUnit::MILLIS:
+      checked_cast<const TimestampLogicalType&>(logicalType);
+  const bool utcNormalized =
+      timestamp.isFromConvertedType() ? false : timestamp.isAdjustedToUtc();
+  static const char* utcTimezone = "UTC";
+  switch (timestamp.timeUnit()) {
+    case LogicalType::TimeUnit::kMillis:
       return (
-          utc_normalized
-              ? ::arrow::timestamp(::arrow::TimeUnit::MILLI, utc_timezone)
+          utcNormalized
+              ? ::arrow::timestamp(::arrow::TimeUnit::MILLI, utcTimezone)
               : ::arrow::timestamp(::arrow::TimeUnit::MILLI));
-    case LogicalType::TimeUnit::MICROS:
+    case LogicalType::TimeUnit::kMicros:
       return (
-          utc_normalized
-              ? ::arrow::timestamp(::arrow::TimeUnit::MICRO, utc_timezone)
+          utcNormalized
+              ? ::arrow::timestamp(::arrow::TimeUnit::MICRO, utcTimezone)
               : ::arrow::timestamp(::arrow::TimeUnit::MICRO));
-    case LogicalType::TimeUnit::NANOS:
+    case LogicalType::TimeUnit::kNanos:
       return (
-          utc_normalized
-              ? ::arrow::timestamp(::arrow::TimeUnit::NANO, utc_timezone)
+          utcNormalized
+              ? ::arrow::timestamp(::arrow::TimeUnit::NANO, utcTimezone)
               : ::arrow::timestamp(::arrow::TimeUnit::NANO));
     default:
       return Status::TypeError(
           "Unrecognized time unit in timestamp logical_type: ",
-          logical_type.ToString());
+          logicalType.toString());
   }
 }
 
-Result<std::shared_ptr<ArrowType>> FromByteArray(
-    const LogicalType& logical_type) {
-  switch (logical_type.type()) {
-    case LogicalType::Type::STRING:
+Result<std::shared_ptr<ArrowType>> fromByteArray(
+    const LogicalType& logicalType) {
+  switch (logicalType.type()) {
+    case LogicalType::Type::kString:
       return ::arrow::utf8();
-    case LogicalType::Type::DECIMAL:
-      return MakeArrowDecimal(logical_type);
-    case LogicalType::Type::NONE:
-    case LogicalType::Type::ENUM:
-    case LogicalType::Type::JSON:
-    case LogicalType::Type::BSON:
+    case LogicalType::Type::kDecimal:
+      return makeArrowDecimal(logicalType);
+    case LogicalType::Type::kNone:
+    case LogicalType::Type::kEnum:
+    case LogicalType::Type::kJson:
+    case LogicalType::Type::kBson:
       return ::arrow::binary();
     default:
       return Status::NotImplemented(
           "Unhandled logical logical_type ",
-          logical_type.ToString(),
+          logicalType.toString(),
           " for binary array");
   }
 }
 
-Result<std::shared_ptr<ArrowType>> FromFLBA(
-    const LogicalType& logical_type,
-    int32_t physical_length) {
-  switch (logical_type.type()) {
-    case LogicalType::Type::DECIMAL:
-      return MakeArrowDecimal(logical_type);
-    case LogicalType::Type::NONE:
-    case LogicalType::Type::INTERVAL:
-    case LogicalType::Type::UUID:
-      return ::arrow::fixed_size_binary(physical_length);
+Result<std::shared_ptr<ArrowType>> fromFLBA(
+    const LogicalType& logicalType,
+    int32_t physicalLength) {
+  switch (logicalType.type()) {
+    case LogicalType::Type::kDecimal:
+      return makeArrowDecimal(logicalType);
+    case LogicalType::Type::kNone:
+    case LogicalType::Type::kInterval:
+    case LogicalType::Type::kUuid:
+      return ::arrow::fixed_size_binary(physicalLength);
     default:
       return Status::NotImplemented(
           "Unhandled logical logical_type ",
-          logical_type.ToString(),
+          logicalType.toString(),
           " for fixed-length binary array");
   }
 }
 
-::arrow::Result<std::shared_ptr<ArrowType>> FromInt32(
-    const LogicalType& logical_type) {
-  switch (logical_type.type()) {
-    case LogicalType::Type::INT:
-      return MakeArrowInt(logical_type);
-    case LogicalType::Type::DATE:
+::arrow::Result<std::shared_ptr<ArrowType>> fromInt32(
+    const LogicalType& logicalType) {
+  switch (logicalType.type()) {
+    case LogicalType::Type::kInt:
+      return makeArrowInt(logicalType);
+    case LogicalType::Type::kDate:
       return ::arrow::date32();
-    case LogicalType::Type::TIME:
-      return MakeArrowTime32(logical_type);
-    case LogicalType::Type::DECIMAL:
-      return MakeArrowDecimal(logical_type);
-    case LogicalType::Type::NONE:
+    case LogicalType::Type::kTime:
+      return makeArrowTime32(logicalType);
+    case LogicalType::Type::kDecimal:
+      return makeArrowDecimal(logicalType);
+    case LogicalType::Type::kNone:
       return ::arrow::int32();
     default:
       return Status::NotImplemented(
-          "Unhandled logical type ", logical_type.ToString(), " for INT32");
+          "Unhandled logical type ", logicalType.toString(), " for INT32");
   }
 }
 
-Result<std::shared_ptr<ArrowType>> FromInt64(const LogicalType& logical_type) {
-  switch (logical_type.type()) {
-    case LogicalType::Type::INT:
-      return MakeArrowInt64(logical_type);
-    case LogicalType::Type::DECIMAL:
-      return MakeArrowDecimal(logical_type);
-    case LogicalType::Type::TIMESTAMP:
-      return MakeArrowTimestamp(logical_type);
-    case LogicalType::Type::TIME:
-      return MakeArrowTime64(logical_type);
-    case LogicalType::Type::NONE:
+Result<std::shared_ptr<ArrowType>> fromInt64(const LogicalType& logicalType) {
+  switch (logicalType.type()) {
+    case LogicalType::Type::kInt:
+      return makeArrowInt64(logicalType);
+    case LogicalType::Type::kDecimal:
+      return makeArrowDecimal(logicalType);
+    case LogicalType::Type::kTimestamp:
+      return makeArrowTimestamp(logicalType);
+    case LogicalType::Type::kTime:
+      return makeArrowTime64(logicalType);
+    case LogicalType::Type::kNone:
       return ::arrow::int64();
     default:
       return Status::NotImplemented(
-          "Unhandled logical type ", logical_type.ToString(), " for INT64");
+          "Unhandled logical type ", logicalType.toString(), " for INT64");
   }
 }
 
-Result<std::shared_ptr<ArrowType>> GetArrowType(
-    Type::type physical_type,
-    const LogicalType& logical_type,
-    int type_length,
-    const ::arrow::TimeUnit::type int96_arrow_time_unit) {
-  if (logical_type.is_invalid() || logical_type.is_null()) {
+Result<std::shared_ptr<ArrowType>> getArrowType(
+    Type::type physicalType,
+    const LogicalType& logicalType,
+    int typeLength,
+    const ::arrow::TimeUnit::type int96ArrowTimeUnit) {
+  if (logicalType.isInvalid() || logicalType.isNull()) {
     return ::arrow::null();
   }
 
-  switch (physical_type) {
-    case ParquetType::BOOLEAN:
+  switch (physicalType) {
+    case ParquetType::kBoolean:
       return ::arrow::boolean();
-    case ParquetType::INT32:
-      return FromInt32(logical_type);
-    case ParquetType::INT64:
-      return FromInt64(logical_type);
-    case ParquetType::INT96:
-      return ::arrow::timestamp(int96_arrow_time_unit);
-    case ParquetType::FLOAT:
+    case ParquetType::kInt32:
+      return fromInt32(logicalType);
+    case ParquetType::kInt64:
+      return fromInt64(logicalType);
+    case ParquetType::kInt96:
+      return ::arrow::timestamp(int96ArrowTimeUnit);
+    case ParquetType::kFloat:
       return ::arrow::float32();
-    case ParquetType::DOUBLE:
+    case ParquetType::kDouble:
       return ::arrow::float64();
-    case ParquetType::BYTE_ARRAY:
-      return FromByteArray(logical_type);
-    case ParquetType::FIXED_LEN_BYTE_ARRAY:
-      return FromFLBA(logical_type, type_length);
+    case ParquetType::kByteArray:
+      return fromByteArray(logicalType);
+    case ParquetType::kFixedLenByteArray:
+      return fromFLBA(logicalType, typeLength);
     default: {
-      // PARQUET-1565: This can occur if the file is corrupt
+      // PARQUET-1565: This can occur if the file is corrupt.
       return Status::IOError(
-          "Invalid physical column type: ", TypeToString(physical_type));
+          "Invalid physical column type: ", typeToString(physicalType));
     }
   }
 }
 
-Result<std::shared_ptr<ArrowType>> GetArrowType(
+Result<std::shared_ptr<ArrowType>> getArrowType(
     const schema::PrimitiveNode& primitive,
-    const ::arrow::TimeUnit::type int96_arrow_time_unit) {
-  return GetArrowType(
-      primitive.physical_type(),
-      *primitive.logical_type(),
-      primitive.type_length(),
-      int96_arrow_time_unit);
+    const ::arrow::TimeUnit::type int96ArrowTimeUnit) {
+  return getArrowType(
+      primitive.physicalType(),
+      *primitive.logicalType(),
+      primitive.typeLength(),
+      int96ArrowTimeUnit);
 }
 
 } // namespace facebook::velox::parquet::arrow::arrow
diff --git a/velox/dwio/parquet/writer/arrow/ArrowSchemaInternal.h b/velox/dwio/parquet/writer/arrow/ArrowSchemaInternal.h
index 8b7b443db53..ebe29843a54 100644
--- a/velox/dwio/parquet/writer/arrow/ArrowSchemaInternal.h
+++ b/velox/dwio/parquet/writer/arrow/ArrowSchemaInternal.h
@@ -29,29 +29,29 @@ namespace facebook::velox::parquet::arrow::arrow {
 
 using ::arrow::Result;
 
-Result<std::shared_ptr<::arrow::DataType>> FromByteArray(
-    const LogicalType& logical_type);
-Result<std::shared_ptr<::arrow::DataType>> FromFLBA(
-    const LogicalType& logical_type,
-    int32_t physical_length);
-Result<std::shared_ptr<::arrow::DataType>> FromInt32(
-    const LogicalType& logical_type);
-Result<std::shared_ptr<::arrow::DataType>> FromInt64(
-    const LogicalType& logical_type);
-
-Result<std::shared_ptr<::arrow::DataType>> GetArrowType(
-    Type::type physical_type,
-    const LogicalType& logical_type,
-    int type_length);
-
-Result<std::shared_ptr<::arrow::DataType>> GetArrowType(
-    Type::type physical_type,
-    const LogicalType& logical_type,
-    int type_length,
-    ::arrow::TimeUnit::type int96_arrow_time_unit = ::arrow::TimeUnit::NANO);
-
-Result<std::shared_ptr<::arrow::DataType>> GetArrowType(
+Result<std::shared_ptr<::arrow::DataType>> fromByteArray(
+    const LogicalType& logicalType);
+Result<std::shared_ptr<::arrow::DataType>> fromFLBA(
+    const LogicalType& logicalType,
+    int32_t physicalLength);
+Result<std::shared_ptr<::arrow::DataType>> fromInt32(
+    const LogicalType& logicalType);
+Result<std::shared_ptr<::arrow::DataType>> fromInt64(
+    const LogicalType& logicalType);
+
+Result<std::shared_ptr<::arrow::DataType>> getArrowType(
+    Type::type physicalType,
+    const LogicalType& logicalType,
+    int typeLength);
+
+Result<std::shared_ptr<::arrow::DataType>> getArrowType(
+    Type::type physicalType,
+    const LogicalType& logicalType,
+    int typeLength,
+    ::arrow::TimeUnit::type int96ArrowTimeUnit = ::arrow::TimeUnit::NANO);
+
+Result<std::shared_ptr<::arrow::DataType>> getArrowType(
     const schema::PrimitiveNode& primitive,
-    ::arrow::TimeUnit::type int96_arrow_time_unit = ::arrow::TimeUnit::NANO);
+    ::arrow::TimeUnit::type int96ArrowTimeUnit = ::arrow::TimeUnit::NANO);
 
 } // namespace facebook::velox::parquet::arrow::arrow
diff --git a/velox/dwio/parquet/writer/arrow/CMakeLists.txt b/velox/dwio/parquet/writer/arrow/CMakeLists.txt
index b70c5f25e9b..b00b2f8a662 100644
--- a/velox/dwio/parquet/writer/arrow/CMakeLists.txt
+++ b/velox/dwio/parquet/writer/arrow/CMakeLists.txt
@@ -37,8 +37,33 @@ velox_add_library(
   Properties.cpp
   Schema.cpp
   Statistics.cpp
+  StringTruncation.cpp
   Types.cpp
   Writer.cpp
+  HEADERS
+  ArrowSchema.h
+  ArrowSchemaInternal.h
+  ColumnPage.h
+  ColumnWriter.h
+  Encoding.h
+  Encryption.h
+  EncryptionInternal.h
+  Exception.h
+  FileDecryptorInternal.h
+  FileEncryptorInternal.h
+  FileWriter.h
+  Metadata.h
+  PageIndex.h
+  PathInternal.h
+  Platform.h
+  Properties.h
+  Schema.h
+  SchemaInternal.h
+  Statistics.h
+  StringTruncation.h
+  ThriftInternal.h
+  Types.h
+  Writer.h
 )
 
 velox_link_libraries(
diff --git a/velox/dwio/parquet/writer/arrow/ColumnPage.h b/velox/dwio/parquet/writer/arrow/ColumnPage.h
index f6c20de01c8..df514dcc8f6 100644
--- a/velox/dwio/parquet/writer/arrow/ColumnPage.h
+++ b/velox/dwio/parquet/writer/arrow/ColumnPage.h
@@ -35,11 +35,11 @@ namespace facebook::velox::parquet::arrow {
 
 // TODO: Parallel processing is not yet safe because of memory-ownership
 // semantics (the PageReader may or may not own the memory referenced by a
-// page)
+// page).
 //
 // TODO(wesm): In the future Parquet implementations may store the crc code
 // in facebook::velox::parquet::thrift::PageHeader. parquet-mr currently does
-// not, so we also skip it here, both on the read and write path
+// not, so we also skip it here, both on the read and write path.
 class Page {
  public:
   Page(const std::shared_ptr<::arrow::Buffer>& buffer, PageType::type type)
@@ -53,12 +53,12 @@ class Page {
     return buffer_;
   }
 
-  // @returns: a pointer to the page's data
+  // @returns: A pointer to the page's data.
   const uint8_t* data() const {
     return buffer_->data();
   }
 
-  // @returns: the total size in bytes of the page's data buffer
+  // @returns: The total size in bytes of the page's data buffer.
   int32_t size() const {
     return static_cast<int32_t>(buffer_->size());
   }
@@ -68,26 +68,26 @@ class Page {
   PageType::type type_;
 };
 
-/// \brief Base type for DataPageV1 and DataPageV2 including common attributes
+/// \brief Base type for DataPageV1 and DataPageV2 including common attributes.
 class DataPage : public Page {
  public:
-  int32_t num_values() const {
-    return num_values_;
+  int32_t numValues() const {
+    return numValues_;
   }
   Encoding::type encoding() const {
     return encoding_;
   }
-  int64_t uncompressed_size() const {
-    return uncompressed_size_;
+  int64_t uncompressedSize() const {
+    return uncompressedSize_;
   }
   const EncodedStatistics& statistics() const {
     return statistics_;
   }
   /// Return the row ordinal within the row group to the first row in the data
-  /// page. Currently it is only present from data pages created by ColumnWriter
-  /// in order to collect page index.
-  std::optional<int64_t> first_row_index() const {
-    return first_row_index_;
+  /// page. Currently it is only present from data pages created by
+  /// ColumnWriter in order to collect page index.
+  std::optional<int64_t> firstRowIndex() const {
+    return firstRowIndex_;
   }
 
   virtual ~DataPage() = default;
@@ -96,145 +96,145 @@ class DataPage : public Page {
   DataPage(
       PageType::type type,
       const std::shared_ptr<::arrow::Buffer>& buffer,
-      int32_t num_values,
+      int32_t numValues,
       Encoding::type encoding,
-      int64_t uncompressed_size,
+      int64_t uncompressedSize,
       const EncodedStatistics& statistics = EncodedStatistics(),
-      std::optional<int64_t> first_row_index = std::nullopt)
+      std::optional<int64_t> firstRowIndex = std::nullopt)
       : Page(buffer, type),
-        num_values_(num_values),
+        numValues_(numValues),
         encoding_(encoding),
-        uncompressed_size_(uncompressed_size),
+        uncompressedSize_(uncompressedSize),
         statistics_(statistics),
-        first_row_index_(std::move(first_row_index)) {}
+        firstRowIndex_(std::move(firstRowIndex)) {}
 
-  int32_t num_values_;
+  int32_t numValues_;
   Encoding::type encoding_;
-  int64_t uncompressed_size_;
+  int64_t uncompressedSize_;
   EncodedStatistics statistics_;
   /// Row ordinal within the row group to the first row in the data page.
-  std::optional<int64_t> first_row_index_;
+  std::optional<int64_t> firstRowIndex_;
 };
 
 class DataPageV1 : public DataPage {
  public:
   DataPageV1(
       const std::shared_ptr<::arrow::Buffer>& buffer,
-      int32_t num_values,
+      int32_t numValues,
       Encoding::type encoding,
-      Encoding::type definition_level_encoding,
-      Encoding::type repetition_level_encoding,
-      int64_t uncompressed_size,
+      Encoding::type definitionLevelEncoding,
+      Encoding::type repetitionLevelEncoding,
+      int64_t uncompressedSize,
       const EncodedStatistics& statistics = EncodedStatistics(),
-      std::optional<int64_t> first_row_index = std::nullopt)
+      std::optional<int64_t> firstRowIndex = std::nullopt)
       : DataPage(
-            PageType::DATA_PAGE,
+            PageType::kDataPage,
             buffer,
-            num_values,
+            numValues,
             encoding,
-            uncompressed_size,
+            uncompressedSize,
             statistics,
-            std::move(first_row_index)),
-        definition_level_encoding_(definition_level_encoding),
-        repetition_level_encoding_(repetition_level_encoding) {}
+            std::move(firstRowIndex)),
+        definitionLevelEncoding_(definitionLevelEncoding),
+        repetitionLevelEncoding_(repetitionLevelEncoding) {}
 
-  Encoding::type repetition_level_encoding() const {
-    return repetition_level_encoding_;
+  Encoding::type repetitionLevelEncoding() const {
+    return repetitionLevelEncoding_;
   }
 
-  Encoding::type definition_level_encoding() const {
-    return definition_level_encoding_;
+  Encoding::type definitionLevelEncoding() const {
+    return definitionLevelEncoding_;
   }
 
  private:
-  Encoding::type definition_level_encoding_;
-  Encoding::type repetition_level_encoding_;
+  Encoding::type definitionLevelEncoding_;
+  Encoding::type repetitionLevelEncoding_;
 };
 
 class DataPageV2 : public DataPage {
  public:
   DataPageV2(
       const std::shared_ptr<::arrow::Buffer>& buffer,
-      int32_t num_values,
-      int32_t num_nulls,
-      int32_t num_rows,
+      int32_t numValues,
+      int32_t numNulls,
+      int32_t numRows,
       Encoding::type encoding,
-      int32_t definition_levels_byte_length,
-      int32_t repetition_levels_byte_length,
-      int64_t uncompressed_size,
-      bool is_compressed = false,
+      int32_t definitionLevelsByteLength,
+      int32_t repetitionLevelsByteLength,
+      int64_t uncompressedSize,
+      bool isCompressed = false,
       const EncodedStatistics& statistics = EncodedStatistics(),
-      std::optional<int64_t> first_row_index = std::nullopt)
+      std::optional<int64_t> firstRowIndex = std::nullopt)
       : DataPage(
-            PageType::DATA_PAGE_V2,
+            PageType::kDataPageV2,
             buffer,
-            num_values,
+            numValues,
             encoding,
-            uncompressed_size,
+            uncompressedSize,
             statistics,
-            std::move(first_row_index)),
-        num_nulls_(num_nulls),
-        num_rows_(num_rows),
-        definition_levels_byte_length_(definition_levels_byte_length),
-        repetition_levels_byte_length_(repetition_levels_byte_length),
-        is_compressed_(is_compressed) {}
+            std::move(firstRowIndex)),
+        numNulls_(numNulls),
+        numRows_(numRows),
+        definitionLevelsByteLength_(definitionLevelsByteLength),
+        repetitionLevelsByteLength_(repetitionLevelsByteLength),
+        isCompressed_(isCompressed) {}
 
-  int32_t num_nulls() const {
-    return num_nulls_;
+  int32_t numNulls() const {
+    return numNulls_;
   }
 
-  int32_t num_rows() const {
-    return num_rows_;
+  int32_t numRows() const {
+    return numRows_;
   }
 
-  int32_t definition_levels_byte_length() const {
-    return definition_levels_byte_length_;
+  int32_t definitionLevelsByteLength() const {
+    return definitionLevelsByteLength_;
   }
 
-  int32_t repetition_levels_byte_length() const {
-    return repetition_levels_byte_length_;
+  int32_t repetitionLevelsByteLength() const {
+    return repetitionLevelsByteLength_;
   }
 
-  bool is_compressed() const {
-    return is_compressed_;
+  bool isCompressed() const {
+    return isCompressed_;
   }
 
  private:
-  int32_t num_nulls_;
-  int32_t num_rows_;
-  int32_t definition_levels_byte_length_;
-  int32_t repetition_levels_byte_length_;
-  bool is_compressed_;
+  int32_t numNulls_;
+  int32_t numRows_;
+  int32_t definitionLevelsByteLength_;
+  int32_t repetitionLevelsByteLength_;
+  bool isCompressed_;
 };
 
 class DictionaryPage : public Page {
  public:
   DictionaryPage(
       const std::shared_ptr<::arrow::Buffer>& buffer,
-      int32_t num_values,
+      int32_t numValues,
       Encoding::type encoding,
-      bool is_sorted = false)
-      : Page(buffer, PageType::DICTIONARY_PAGE),
-        num_values_(num_values),
+      bool isSorted = false)
+      : Page(buffer, PageType::kDictionaryPage),
+        numValues_(numValues),
         encoding_(encoding),
-        is_sorted_(is_sorted) {}
+        isSorted_(isSorted) {}
 
-  int32_t num_values() const {
-    return num_values_;
+  int32_t numValues() const {
+    return numValues_;
   }
 
   Encoding::type encoding() const {
     return encoding_;
   }
 
-  bool is_sorted() const {
-    return is_sorted_;
+  bool isSorted() const {
+    return isSorted_;
   }
 
  private:
-  int32_t num_values_;
+  int32_t numValues_;
   Encoding::type encoding_;
-  bool is_sorted_;
+  bool isSorted_;
 };
 
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/ColumnWriter.cpp b/velox/dwio/parquet/writer/arrow/ColumnWriter.cpp
index d69c8ac6a12..1ba58979697 100644
--- a/velox/dwio/parquet/writer/arrow/ColumnWriter.cpp
+++ b/velox/dwio/parquet/writer/arrow/ColumnWriter.cpp
@@ -69,7 +69,7 @@ using arrow::internal::checked_cast;
 using arrow::internal::checked_pointer_cast;
 
 namespace arrow {
-fmt::underlying_t<Type::type> format_as(Type::type type) {
+fmt::underlying_t<Type::type> formatAs(Type::type type) {
   return fmt::underlying(type);
 }
 }; // namespace arrow
@@ -79,14 +79,14 @@ using util::CodecOptions;
 
 namespace {
 
-// Visitor that exracts the value buffer from a FlatArray at a given offset.
+// Visitor that extracts the value buffer from a FlatArray at a given offset.
 struct ValueBufferSlicer {
   template <typename T>
-  ::arrow::enable_if_base_binary<typename T::TypeClass, Status> Visit(
+  ::arrow::enable_if_base_binary<typename T::TypeClass, Status> visit(
       const T& array,
       std::shared_ptr<Buffer>* buffer) {
     auto data = array.data();
-    *buffer = SliceBuffer(
+    *buffer = ::arrow::SliceBuffer(
         data->buffers[1],
         data->offset * sizeof(typename T::offset_type),
         data->length * sizeof(typename T::offset_type));
@@ -94,11 +94,11 @@ struct ValueBufferSlicer {
   }
 
   template <typename T>
-  ::arrow::enable_if_fixed_size_binary<typename T::TypeClass, Status> Visit(
+  ::arrow::enable_if_fixed_size_binary<typename T::TypeClass, Status> visit(
       const T& array,
       std::shared_ptr<Buffer>* buffer) {
     auto data = array.data();
-    *buffer = SliceBuffer(
+    *buffer = ::arrow::SliceBuffer(
         data->buffers[1],
         data->offset * array.byte_width(),
         data->length * array.byte_width());
@@ -110,9 +110,9 @@ struct ValueBufferSlicer {
       ::arrow::has_c_type<typename T::TypeClass>::value &&
           !std::is_same<BooleanType, typename T::TypeClass>::value,
       Status>
-  Visit(const T& array, std::shared_ptr<Buffer>* buffer) {
+  visit(const T& array, std::shared_ptr<Buffer>* buffer) {
     auto data = array.data();
-    *buffer = SliceBuffer(
+    *buffer = ::arrow::SliceBuffer(
         data->buffers[1],
         ::arrow::TypeTraits<typename T::TypeClass>::bytes_required(
             data->offset),
@@ -121,12 +121,12 @@ struct ValueBufferSlicer {
     return Status::OK();
   }
 
-  Status Visit(
+  Status visit(
       const ::arrow::BooleanArray& array,
       std::shared_ptr<Buffer>* buffer) {
     auto data = array.data();
     if (::arrow::bit_util::IsMultipleOf8(data->offset)) {
-      *buffer = SliceBuffer(
+      *buffer = ::arrow::SliceBuffer(
           data->buffers[1],
           ::arrow::bit_util::BytesForBits(data->offset),
           ::arrow::bit_util::BytesForBits(data->length));
@@ -139,7 +139,7 @@ struct ValueBufferSlicer {
     return Status::OK();
   }
 #define NOT_IMPLEMENTED_VISIT(ArrowTypePrefix)            \
-  Status Visit(                                           \
+  Status visit(                                           \
       const ::arrow::ArrowTypePrefix##Array& array,       \
       std::shared_ptr<Buffer>* buffer) {                  \
     return Status::NotImplemented(                        \
@@ -165,25 +165,25 @@ struct ValueBufferSlicer {
   MemoryPool* pool_;
 };
 
-LevelInfo ComputeLevelInfo(const ColumnDescriptor* descr) {
-  LevelInfo level_info;
-  level_info.defLevel = descr->max_definition_level();
-  level_info.repLevel = descr->max_repetition_level();
+LevelInfo computeLevelInfo(const ColumnDescriptor* descr) {
+  LevelInfo levelInfo;
+  levelInfo.defLevel = descr->maxDefinitionLevel();
+  levelInfo.repLevel = descr->maxRepetitionLevel();
 
-  int16_t min_spaced_def_level = descr->max_definition_level();
-  const schema::Node* node = descr->schema_node().get();
-  while (node != nullptr && !node->is_repeated()) {
-    if (node->is_optional()) {
-      min_spaced_def_level--;
+  int16_t minSpacedDefLevel = descr->maxDefinitionLevel();
+  const schema::Node* node = descr->schemaNode().get();
+  while (node != nullptr && !node->isRepeated()) {
+    if (node->isOptional()) {
+      minSpacedDefLevel--;
     }
     node = node->parent();
   }
-  level_info.repeatedAncestorDefLevel = min_spaced_def_level;
-  return level_info;
+  levelInfo.repeatedAncestorDefLevel = minSpacedDefLevel;
+  return levelInfo;
 }
 
 template <class T>
-inline const T* AddIfNotNull(const T* base, int64_t offset) {
+inline const T* addIfNotNull(const T* base, int64_t offset) {
   if (base != nullptr) {
     return base + offset;
   }
@@ -195,23 +195,23 @@ inline const T* AddIfNotNull(const T* base, int64_t offset) {
 LevelEncoder::LevelEncoder() {}
 LevelEncoder::~LevelEncoder() {}
 
-void LevelEncoder::Init(
+void LevelEncoder::init(
     Encoding::type encoding,
-    int16_t max_level,
-    int num_buffered_values,
+    int16_t maxLevel,
+    int numBufferedValues,
     uint8_t* data,
-    int data_size) {
-  bit_width_ = ::arrow::bit_util::Log2(max_level + 1);
+    int dataSize) {
+  bitWidth_ = ::arrow::bit_util::Log2(maxLevel + 1);
   encoding_ = encoding;
   switch (encoding) {
-    case Encoding::RLE: {
-      rle_encoder_ = std::make_unique<RleEncoder>(data, data_size, bit_width_);
+    case Encoding::kRle: {
+      rleEncoder_ = std::make_unique<RleEncoder>(data, dataSize, bitWidth_);
       break;
     }
-    case Encoding::BIT_PACKED: {
-      int num_bytes = static_cast<int>(
-          ::arrow::bit_util::BytesForBits(num_buffered_values * bit_width_));
-      bit_packed_encoder_ = std::make_unique<BitWriter>(data, num_bytes);
+    case Encoding::kBitPacked: {
+      int numBytes = static_cast<int>(
+          ::arrow::bit_util::BytesForBits(numBufferedValues * bitWidth_));
+      bitPackedEncoder_ = std::make_unique<BitWriter>(data, numBytes);
       break;
     }
     default:
@@ -219,60 +219,60 @@ void LevelEncoder::Init(
   }
 }
 
-int LevelEncoder::MaxBufferSize(
+int LevelEncoder::maxBufferSize(
     Encoding::type encoding,
-    int16_t max_level,
-    int num_buffered_values) {
-  int bit_width = ::arrow::bit_util::Log2(max_level + 1);
-  int num_bytes = 0;
+    int16_t maxLevel,
+    int numBufferedValues) {
+  int bitWidth = ::arrow::bit_util::Log2(maxLevel + 1);
+  int numBytes = 0;
   switch (encoding) {
-    case Encoding::RLE: {
+    case Encoding::kRle: {
       // TODO: Due to the way we currently check if the buffer is full enough,
       // we need to have MinBufferSize as head room.
-      num_bytes = RleEncoder::MaxBufferSize(bit_width, num_buffered_values) +
-          RleEncoder::MinBufferSize(bit_width);
+      numBytes = RleEncoder::MaxBufferSize(bitWidth, numBufferedValues) +
+          RleEncoder::MinBufferSize(bitWidth);
       break;
     }
-    case Encoding::BIT_PACKED: {
-      num_bytes = static_cast<int>(
-          ::arrow::bit_util::BytesForBits(num_buffered_values * bit_width));
+    case Encoding::kBitPacked: {
+      numBytes = static_cast<int>(
+          ::arrow::bit_util::BytesForBits(numBufferedValues * bitWidth));
       break;
     }
     default:
       throw ParquetException("Unknown encoding type for levels.");
   }
-  return num_bytes;
+  return numBytes;
 }
 
-int LevelEncoder::Encode(int batch_size, const int16_t* levels) {
-  int num_encoded = 0;
-  if (!rle_encoder_ && !bit_packed_encoder_) {
+int LevelEncoder::encode(int batchSize, const int16_t* levels) {
+  int numEncoded = 0;
+  if (!rleEncoder_ && !bitPackedEncoder_) {
     throw ParquetException("Level encoders are not initialized.");
   }
 
-  if (encoding_ == Encoding::RLE) {
-    for (int i = 0; i < batch_size; ++i) {
-      if (!rle_encoder_->Put(*(levels + i))) {
+  if (encoding_ == Encoding::kRle) {
+    for (int i = 0; i < batchSize; ++i) {
+      if (!rleEncoder_->Put(*(levels + i))) {
         break;
       }
-      ++num_encoded;
+      ++numEncoded;
     }
-    rle_encoder_->Flush();
-    rle_length_ = rle_encoder_->len();
+    rleEncoder_->Flush();
+    rleLength_ = rleEncoder_->len();
   } else {
-    for (int i = 0; i < batch_size; ++i) {
-      if (!bit_packed_encoder_->PutValue(*(levels + i), bit_width_)) {
+    for (int i = 0; i < batchSize; ++i) {
+      if (!bitPackedEncoder_->PutValue(*(levels + i), bitWidth_)) {
         break;
       }
-      ++num_encoded;
+      ++numEncoded;
     }
-    bit_packed_encoder_->Flush();
+    bitPackedEncoder_->Flush();
   }
-  return num_encoded;
+  return numEncoded;
 }
 
-// ----------------------------------------------------------------------
-// PageWriter implementation
+// ----------------------------------------------------------------------.
+// PageWriter implementation.
 
 // This subclass delimits pages appearing in a serialized stream, each preceded
 // by a serialized Thrift facebook::velox::parquet::thrift::PageHeader
@@ -283,611 +283,608 @@ class SerializedPageWriter : public PageWriter {
       std::shared_ptr<ArrowOutputStream> sink,
       Compression::type codec,
       ColumnChunkMetaDataBuilder* metadata,
-      int16_t row_group_ordinal,
-      int16_t column_chunk_ordinal,
-      bool use_page_checksum_verification,
+      int16_t rowGroupOrdinal,
+      int16_t columnChunkOrdinal,
+      bool usePageChecksumVerification,
       MemoryPool* pool = ::arrow::default_memory_pool(),
-      std::shared_ptr<Encryptor> meta_encryptor = nullptr,
-      std::shared_ptr<Encryptor> data_encryptor = nullptr,
-      ColumnIndexBuilder* column_index_builder = nullptr,
-      OffsetIndexBuilder* offset_index_builder = nullptr,
-      const CodecOptions& codec_options = CodecOptions{})
+      std::shared_ptr<Encryptor> metaEncryptor = nullptr,
+      std::shared_ptr<Encryptor> dataEncryptor = nullptr,
+      ColumnIndexBuilder* columnIndexBuilder = nullptr,
+      OffsetIndexBuilder* offsetIndexBuilder = nullptr,
+      const CodecOptions& codecOptions = CodecOptions{})
       : sink_(std::move(sink)),
         metadata_(metadata),
         pool_(pool),
-        num_values_(0),
-        dictionary_page_offset_(0),
-        data_page_offset_(0),
-        total_uncompressed_size_(0),
-        total_compressed_size_(0),
-        page_ordinal_(0),
-        row_group_ordinal_(row_group_ordinal),
-        column_ordinal_(column_chunk_ordinal),
-        page_checksum_verification_(use_page_checksum_verification),
-        meta_encryptor_(std::move(meta_encryptor)),
-        data_encryptor_(std::move(data_encryptor)),
-        encryption_buffer_(AllocateBuffer(pool, 0)),
-        column_index_builder_(column_index_builder),
-        offset_index_builder_(offset_index_builder) {
-    if (data_encryptor_ != nullptr || meta_encryptor_ != nullptr) {
-      InitEncryption();
-    }
-    compressor_ = GetCodec(codec, codec_options);
-    thrift_serializer_ = std::make_unique<ThriftSerializer>();
-  }
-
-  int64_t WriteDictionaryPage(const DictionaryPage& page) override {
-    int64_t uncompressed_size = page.size();
-    std::shared_ptr<Buffer> compressed_data;
-    if (has_compressor()) {
+        numValues_(0),
+        dictionaryPageOffset_(0),
+        dataPageOffset_(0),
+        totalUncompressedSize_(0),
+        totalCompressedSize_(0),
+        pageOrdinal_(0),
+        rowGroupOrdinal_(rowGroupOrdinal),
+        columnOrdinal_(columnChunkOrdinal),
+        pageChecksumVerification_(usePageChecksumVerification),
+        metaEncryptor_(std::move(metaEncryptor)),
+        dataEncryptor_(std::move(dataEncryptor)),
+        encryptionBuffer_(allocateBuffer(pool, 0)),
+        columnIndexBuilder_(columnIndexBuilder),
+        offsetIndexBuilder_(offsetIndexBuilder) {
+    if (dataEncryptor_ != nullptr || metaEncryptor_ != nullptr) {
+      initEncryption();
+    }
+    compressor_ = getCodec(codec, codecOptions);
+    thriftSerializer_ = std::make_unique<ThriftSerializer>();
+  }
+
+  int64_t writeDictionaryPage(const DictionaryPage& page) override {
+    int64_t uncompressedSize = page.size();
+    std::shared_ptr<Buffer> compressedData;
+    if (hasCompressor()) {
       auto buffer = std::static_pointer_cast<ResizableBuffer>(
-          AllocateBuffer(pool_, uncompressed_size));
-      Compress(*(page.buffer().get()), buffer.get());
-      compressed_data = std::static_pointer_cast<Buffer>(buffer);
+          allocateBuffer(pool_, uncompressedSize));
+      compress(*(page.buffer().get()), buffer.get());
+      compressedData = std::static_pointer_cast<Buffer>(buffer);
     } else {
-      compressed_data = page.buffer();
+      compressedData = page.buffer();
     }
 
-    facebook::velox::parquet::thrift::DictionaryPageHeader dict_page_header;
-    dict_page_header.__set_num_values(page.num_values());
-    dict_page_header.__set_encoding(ToThrift(page.encoding()));
-    dict_page_header.__set_is_sorted(page.is_sorted());
+    facebook::velox::parquet::thrift::DictionaryPageHeader dictPageHeader;
+    dictPageHeader.__set_num_values(page.numValues());
+    dictPageHeader.__set_encoding(toThrift(page.encoding()));
+    dictPageHeader.__set_is_sorted(page.isSorted());
 
-    const uint8_t* output_data_buffer = compressed_data->data();
-    int32_t output_data_len = static_cast<int32_t>(compressed_data->size());
+    const uint8_t* outputDataBuffer = compressedData->data();
+    int32_t outputDataLen = static_cast<int32_t>(compressedData->size());
 
-    if (data_encryptor_.get()) {
-      UpdateEncryption(encryption::kDictionaryPage);
-      PARQUET_THROW_NOT_OK(encryption_buffer_->Resize(
-          data_encryptor_->CiphertextSizeDelta() + output_data_len, false));
-      output_data_len = data_encryptor_->Encrypt(
-          compressed_data->data(),
-          output_data_len,
-          encryption_buffer_->mutable_data());
-      output_data_buffer = encryption_buffer_->data();
+    if (dataEncryptor_.get()) {
+      updateEncryption(encryption::kDictionaryPage);
+      PARQUET_THROW_NOT_OK(encryptionBuffer_->Resize(
+          dataEncryptor_->ciphertextSizeDelta() + outputDataLen, false));
+      outputDataLen = dataEncryptor_->encrypt(
+          compressedData->data(),
+          outputDataLen,
+          encryptionBuffer_->mutable_data());
+      outputDataBuffer = encryptionBuffer_->data();
     }
 
-    facebook::velox::parquet::thrift::PageHeader page_header;
-    page_header.__set_type(
+    facebook::velox::parquet::thrift::PageHeader pageHeader;
+    pageHeader.__set_type(
         facebook::velox::parquet::thrift::PageType::DICTIONARY_PAGE);
-    page_header.__set_uncompressed_page_size(
-        static_cast<int32_t>(uncompressed_size));
-    page_header.__set_compressed_page_size(
-        static_cast<int32_t>(output_data_len));
-    page_header.__set_dictionary_page_header(dict_page_header);
-    if (page_checksum_verification_) {
+    pageHeader.__set_uncompressed_page_size(
+        static_cast<int32_t>(uncompressedSize));
+    pageHeader.__set_compressed_page_size(static_cast<int32_t>(outputDataLen));
+    pageHeader.__set_dictionary_page_header(dictPageHeader);
+    if (pageChecksumVerification_) {
       uint32_t crc32 =
-          internal::crc32(/* prev */ 0, output_data_buffer, output_data_len);
-      page_header.__set_crc(static_cast<int32_t>(crc32));
+          internal::crc32(/* prev */ 0, outputDataBuffer, outputDataLen);
+      pageHeader.__set_crc(static_cast<int32_t>(crc32));
     }
 
-    PARQUET_ASSIGN_OR_THROW(int64_t start_pos, sink_->Tell());
-    if (dictionary_page_offset_ == 0) {
-      dictionary_page_offset_ = start_pos;
+    PARQUET_ASSIGN_OR_THROW(int64_t startPos, sink_->Tell());
+    if (dictionaryPageOffset_ == 0) {
+      dictionaryPageOffset_ = startPos;
     }
 
-    if (meta_encryptor_) {
-      UpdateEncryption(encryption::kDictionaryPageHeader);
+    if (metaEncryptor_) {
+      updateEncryption(encryption::kDictionaryPageHeader);
     }
-    const int64_t header_size = thrift_serializer_->Serialize(
-        &page_header, sink_.get(), meta_encryptor_);
+    const int64_t headerSize =
+        thriftSerializer_->serialize(&pageHeader, sink_.get(), metaEncryptor_);
 
-    PARQUET_THROW_NOT_OK(sink_->Write(output_data_buffer, output_data_len));
+    PARQUET_THROW_NOT_OK(sink_->Write(outputDataBuffer, outputDataLen));
 
-    total_uncompressed_size_ += uncompressed_size + header_size;
-    total_compressed_size_ += output_data_len + header_size;
-    ++dict_encoding_stats_[page.encoding()];
-    return uncompressed_size + header_size;
+    totalUncompressedSize_ += uncompressedSize + headerSize;
+    totalCompressedSize_ += outputDataLen + headerSize;
+    ++dictEncodingStats_[page.encoding()];
+    return uncompressedSize + headerSize;
   }
 
-  void Close(bool has_dictionary, bool fallback) override {
-    if (meta_encryptor_ != nullptr) {
-      UpdateEncryption(encryption::kColumnMetaData);
+  void close(bool hasDictionary, bool fallback) override {
+    if (metaEncryptor_ != nullptr) {
+      updateEncryption(encryption::kColumnMetaData);
     }
 
     // Serialized page writer does not need to adjust page offsets.
-    FinishPageIndexes(/*final_position=*/0);
+    finishPageIndexes(0);
 
-    // index_page_offset = -1 since they are not supported
-    metadata_->Finish(
-        num_values_,
-        dictionary_page_offset_,
+    // Index_page_offset = -1 since they are not supported.
+    metadata_->finish(
+        numValues_,
+        dictionaryPageOffset_,
         -1,
-        data_page_offset_,
-        total_compressed_size_,
-        total_uncompressed_size_,
-        has_dictionary,
+        dataPageOffset_,
+        totalCompressedSize_,
+        totalUncompressedSize_,
+        hasDictionary,
         fallback,
-        dict_encoding_stats_,
-        data_encoding_stats_,
-        meta_encryptor_);
-    // Write metadata at end of column chunk
-    metadata_->WriteTo(sink_.get());
+        dictEncodingStats_,
+        dataEncodingStats_,
+        metaEncryptor_);
+    // Write metadata at end of column chunk.
+    metadata_->writeTo(sink_.get());
   }
 
   /**
    * Compress a buffer.
    */
-  void Compress(const Buffer& src_buffer, ResizableBuffer* dest_buffer)
-      override {
+  void compress(const Buffer& srcBuffer, ResizableBuffer* destBuffer) override {
     VELOX_DCHECK_NOT_NULL(compressor_);
 
-    // Compress the data
-    int64_t max_compressed_size =
-        compressor_->MaxCompressedLen(src_buffer.size(), src_buffer.data());
+    // Compress the data.
+    int64_t maxCompressedSize =
+        compressor_->maxCompressedLen(srcBuffer.size(), srcBuffer.data());
 
-    // Use Arrow::Buffer::shrink_to_fit = false
-    // underlying buffer only keeps growing. Resize to a smaller size does not
+    // Use Arrow::Buffer::shrink_to_fit = false.
+    // Underlying buffer only keeps growing. Resize to a smaller size does not
     // reallocate.
-    PARQUET_THROW_NOT_OK(dest_buffer->Resize(max_compressed_size, false));
+    PARQUET_THROW_NOT_OK(destBuffer->Resize(maxCompressedSize, false));
 
     PARQUET_ASSIGN_OR_THROW(
-        int64_t compressed_size,
-        compressor_->Compress(
-            src_buffer.size(),
-            src_buffer.data(),
-            max_compressed_size,
-            dest_buffer->mutable_data()));
-    PARQUET_THROW_NOT_OK(dest_buffer->Resize(compressed_size, false));
-  }
-
-  int64_t WriteDataPage(const DataPage& page) override {
-    const int64_t uncompressed_size = page.uncompressed_size();
-    std::shared_ptr<Buffer> compressed_data = page.buffer();
-    const uint8_t* output_data_buffer = compressed_data->data();
-    int32_t output_data_len = static_cast<int32_t>(compressed_data->size());
-
-    if (data_encryptor_.get()) {
-      PARQUET_THROW_NOT_OK(encryption_buffer_->Resize(
-          data_encryptor_->CiphertextSizeDelta() + output_data_len, false));
-      UpdateEncryption(encryption::kDataPage);
-      output_data_len = data_encryptor_->Encrypt(
-          compressed_data->data(),
-          output_data_len,
-          encryption_buffer_->mutable_data());
-      output_data_buffer = encryption_buffer_->data();
-    }
-
-    facebook::velox::parquet::thrift::PageHeader page_header;
-    page_header.__set_uncompressed_page_size(
-        static_cast<int32_t>(uncompressed_size));
-    page_header.__set_compressed_page_size(
-        static_cast<int32_t>(output_data_len));
-
-    if (page_checksum_verification_) {
+        int64_t compressedSize,
+        compressor_->compress(
+            srcBuffer.size(),
+            srcBuffer.data(),
+            maxCompressedSize,
+            destBuffer->mutable_data()));
+    PARQUET_THROW_NOT_OK(destBuffer->Resize(compressedSize, false));
+  }
+
+  int64_t writeDataPage(const DataPage& page) override {
+    const int64_t uncompressedSize = page.uncompressedSize();
+    std::shared_ptr<Buffer> compressedData = page.buffer();
+    const uint8_t* outputDataBuffer = compressedData->data();
+    int32_t outputDataLen = static_cast<int32_t>(compressedData->size());
+
+    if (dataEncryptor_.get()) {
+      PARQUET_THROW_NOT_OK(encryptionBuffer_->Resize(
+          dataEncryptor_->ciphertextSizeDelta() + outputDataLen, false));
+      updateEncryption(encryption::kDataPage);
+      outputDataLen = dataEncryptor_->encrypt(
+          compressedData->data(),
+          outputDataLen,
+          encryptionBuffer_->mutable_data());
+      outputDataBuffer = encryptionBuffer_->data();
+    }
+
+    facebook::velox::parquet::thrift::PageHeader pageHeader;
+    pageHeader.__set_uncompressed_page_size(
+        static_cast<int32_t>(uncompressedSize));
+    pageHeader.__set_compressed_page_size(static_cast<int32_t>(outputDataLen));
+
+    if (pageChecksumVerification_) {
       uint32_t crc32 =
-          internal::crc32(/* prev */ 0, output_data_buffer, output_data_len);
-      page_header.__set_crc(static_cast<int32_t>(crc32));
+          internal::crc32(/* prev */ 0, outputDataBuffer, outputDataLen);
+      pageHeader.__set_crc(static_cast<int32_t>(crc32));
     }
 
-    if (page.type() == PageType::DATA_PAGE) {
-      const DataPageV1& v1_page = checked_cast<const DataPageV1&>(page);
-      SetDataPageHeader(page_header, v1_page);
-    } else if (page.type() == PageType::DATA_PAGE_V2) {
-      const DataPageV2& v2_page = checked_cast<const DataPageV2&>(page);
-      SetDataPageV2Header(page_header, v2_page);
+    if (page.type() == PageType::kDataPage) {
+      const DataPageV1& v1Page = checked_cast<const DataPageV1&>(page);
+      setDataPageHeader(pageHeader, v1Page);
+    } else if (page.type() == PageType::kDataPageV2) {
+      const DataPageV2& v2Page = checked_cast<const DataPageV2&>(page);
+      setDataPageV2Header(pageHeader, v2Page);
     } else {
       throw ParquetException("Unexpected page type");
     }
 
-    PARQUET_ASSIGN_OR_THROW(int64_t start_pos, sink_->Tell());
-    if (page_ordinal_ == 0) {
-      data_page_offset_ = start_pos;
+    PARQUET_ASSIGN_OR_THROW(int64_t startPos, sink_->Tell());
+    if (pageOrdinal_ == 0) {
+      dataPageOffset_ = startPos;
     }
 
-    if (meta_encryptor_) {
-      UpdateEncryption(encryption::kDataPageHeader);
+    if (metaEncryptor_) {
+      updateEncryption(encryption::kDataPageHeader);
     }
-    const int64_t header_size = thrift_serializer_->Serialize(
-        &page_header, sink_.get(), meta_encryptor_);
-    PARQUET_THROW_NOT_OK(sink_->Write(output_data_buffer, output_data_len));
+    const int64_t headerSize =
+        thriftSerializer_->serialize(&pageHeader, sink_.get(), metaEncryptor_);
+    PARQUET_THROW_NOT_OK(sink_->Write(outputDataBuffer, outputDataLen));
 
-    /// Collect page index
-    if (column_index_builder_ != nullptr) {
-      column_index_builder_->AddPage(page.statistics());
+    /// Collect page index.
+    if (columnIndexBuilder_ != nullptr) {
+      columnIndexBuilder_->addPage(page.statistics());
     }
-    if (offset_index_builder_ != nullptr) {
-      const int64_t compressed_size = output_data_len + header_size;
-      if (compressed_size > std::numeric_limits<int32_t>::max()) {
+    if (offsetIndexBuilder_ != nullptr) {
+      const int64_t compressedSize = outputDataLen + headerSize;
+      if (compressedSize > std::numeric_limits<int32_t>::max()) {
         throw ParquetException("Compressed page size overflows to INT32_MAX.");
       }
-      if (!page.first_row_index().has_value()) {
+      if (!page.firstRowIndex().has_value()) {
         throw ParquetException("First row index is not set in data page.");
       }
-      /// start_pos is a relative offset in the buffered mode. It should be
-      /// adjusted via OffsetIndexBuilder::Finish() after BufferedPageWriter
+      /// startPos is a relative offset in the buffered mode. It should be
+      /// adjusted via OffsetIndexBuilder::finish() after BufferedPageWriter
       /// has flushed all data pages.
-      offset_index_builder_->AddPage(
-          start_pos,
-          static_cast<int32_t>(compressed_size),
-          *page.first_row_index());
+      offsetIndexBuilder_->addPage(
+          startPos,
+          static_cast<int32_t>(compressedSize),
+          *page.firstRowIndex());
     }
 
-    total_uncompressed_size_ += uncompressed_size + header_size;
-    total_compressed_size_ += output_data_len + header_size;
-    num_values_ += page.num_values();
-    ++data_encoding_stats_[page.encoding()];
-    ++page_ordinal_;
-    return uncompressed_size + header_size;
+    totalUncompressedSize_ += uncompressedSize + headerSize;
+    totalCompressedSize_ += outputDataLen + headerSize;
+    numValues_ += page.numValues();
+    ++dataEncodingStats_[page.encoding()];
+    ++pageOrdinal_;
+    return uncompressedSize + headerSize;
   }
 
-  void SetDataPageHeader(
-      facebook::velox::parquet::thrift::PageHeader& page_header,
+  void setDataPageHeader(
+      facebook::velox::parquet::thrift::PageHeader& pageHeader,
       const DataPageV1& page) {
-    facebook::velox::parquet::thrift::DataPageHeader data_page_header;
-    data_page_header.__set_num_values(page.num_values());
-    data_page_header.__set_encoding(ToThrift(page.encoding()));
-    data_page_header.__set_definition_level_encoding(
-        ToThrift(page.definition_level_encoding()));
-    data_page_header.__set_repetition_level_encoding(
-        ToThrift(page.repetition_level_encoding()));
+    facebook::velox::parquet::thrift::DataPageHeader dataPageHeader;
+    dataPageHeader.__set_num_values(page.numValues());
+    dataPageHeader.__set_encoding(toThrift(page.encoding()));
+    dataPageHeader.__set_definition_level_encoding(
+        toThrift(page.definitionLevelEncoding()));
+    dataPageHeader.__set_repetition_level_encoding(
+        toThrift(page.repetitionLevelEncoding()));
 
     // Write page statistics only when page index is not enabled.
-    if (column_index_builder_ == nullptr) {
-      data_page_header.__set_statistics(ToThrift(page.statistics()));
+    if (columnIndexBuilder_ == nullptr) {
+      dataPageHeader.__set_statistics(toThrift(page.statistics()));
     }
 
-    page_header.__set_type(
+    pageHeader.__set_type(
         facebook::velox::parquet::thrift::PageType::DATA_PAGE);
-    page_header.__set_data_page_header(data_page_header);
+    pageHeader.__set_data_page_header(dataPageHeader);
   }
 
-  void SetDataPageV2Header(
-      facebook::velox::parquet::thrift::PageHeader& page_header,
+  void setDataPageV2Header(
+      facebook::velox::parquet::thrift::PageHeader& pageHeader,
       const DataPageV2& page) {
-    facebook::velox::parquet::thrift::DataPageHeaderV2 data_page_header;
-    data_page_header.__set_num_values(page.num_values());
-    data_page_header.__set_num_nulls(page.num_nulls());
-    data_page_header.__set_num_rows(page.num_rows());
-    data_page_header.__set_encoding(ToThrift(page.encoding()));
+    facebook::velox::parquet::thrift::DataPageHeaderV2 dataPageHeader;
+    dataPageHeader.__set_num_values(page.numValues());
+    dataPageHeader.__set_num_nulls(page.numNulls());
+    dataPageHeader.__set_num_rows(page.numRows());
+    dataPageHeader.__set_encoding(toThrift(page.encoding()));
 
-    data_page_header.__set_definition_levels_byte_length(
-        page.definition_levels_byte_length());
-    data_page_header.__set_repetition_levels_byte_length(
-        page.repetition_levels_byte_length());
+    dataPageHeader.__set_definition_levels_byte_length(
+        page.definitionLevelsByteLength());
+    dataPageHeader.__set_repetition_levels_byte_length(
+        page.repetitionLevelsByteLength());
 
-    data_page_header.__set_is_compressed(page.is_compressed());
+    dataPageHeader.__set_is_compressed(page.isCompressed());
 
     // Write page statistics only when page index is not enabled.
-    if (column_index_builder_ == nullptr) {
-      data_page_header.__set_statistics(ToThrift(page.statistics()));
+    if (columnIndexBuilder_ == nullptr) {
+      dataPageHeader.__set_statistics(toThrift(page.statistics()));
     }
 
-    page_header.__set_type(
+    pageHeader.__set_type(
         facebook::velox::parquet::thrift::PageType::DATA_PAGE_V2);
-    page_header.__set_data_page_header_v2(data_page_header);
+    pageHeader.__set_data_page_header_v2(dataPageHeader);
   }
 
   /// \brief Finish page index builders and update the stream offset to adjust
   /// page offsets.
-  void FinishPageIndexes(int64_t final_position) {
-    if (column_index_builder_ != nullptr) {
-      column_index_builder_->Finish();
+  void finishPageIndexes(int64_t finalPosition) {
+    if (columnIndexBuilder_ != nullptr) {
+      columnIndexBuilder_->finish();
     }
-    if (offset_index_builder_ != nullptr) {
-      offset_index_builder_->Finish(final_position);
+    if (offsetIndexBuilder_ != nullptr) {
+      offsetIndexBuilder_->finish(finalPosition);
     }
   }
 
-  bool has_compressor() override {
+  bool hasCompressor() override {
     return (compressor_ != nullptr);
   }
 
-  int64_t num_values() {
-    return num_values_;
+  int64_t numValues() {
+    return numValues_;
   }
 
-  int64_t dictionary_page_offset() {
-    return dictionary_page_offset_;
+  int64_t dictionaryPageOffset() {
+    return dictionaryPageOffset_;
   }
 
-  int64_t data_page_offset() {
-    return data_page_offset_;
+  int64_t dataPageOffset() {
+    return dataPageOffset_;
   }
 
-  int64_t total_compressed_size() {
-    return total_compressed_size_;
+  int64_t totalCompressedSize() {
+    return totalCompressedSize_;
   }
 
-  int64_t total_uncompressed_size() {
-    return total_uncompressed_size_;
+  int64_t totalUncompressedSize() {
+    return totalUncompressedSize_;
   }
 
-  int64_t total_compressed_bytes_written() const override {
-    return total_compressed_size_;
+  int64_t totalCompressedBytesWritten() const override {
+    return totalCompressedSize_;
   }
 
-  bool page_checksum_verification() {
-    return page_checksum_verification_;
+  bool pageChecksumVerification() {
+    return pageChecksumVerification_;
   }
 
  private:
-  // To allow UpdateEncryption on Close
+  // To allow updateEncryption on close.
   friend class BufferedPageWriter;
 
-  void InitEncryption() {
+  void initEncryption() {
     // Prepare the AAD for quick update later.
-    if (data_encryptor_ != nullptr) {
-      data_page_aad_ = encryption::CreateModuleAad(
-          data_encryptor_->file_aad(),
+    if (dataEncryptor_ != nullptr) {
+      dataPageAad_ = encryption::createModuleAad(
+          dataEncryptor_->fileAad(),
           encryption::kDataPage,
-          row_group_ordinal_,
-          column_ordinal_,
+          rowGroupOrdinal_,
+          columnOrdinal_,
           kNonPageOrdinal);
     }
-    if (meta_encryptor_ != nullptr) {
-      data_page_header_aad_ = encryption::CreateModuleAad(
-          meta_encryptor_->file_aad(),
+    if (metaEncryptor_ != nullptr) {
+      dataPageHeaderAad_ = encryption::createModuleAad(
+          metaEncryptor_->fileAad(),
           encryption::kDataPageHeader,
-          row_group_ordinal_,
-          column_ordinal_,
+          rowGroupOrdinal_,
+          columnOrdinal_,
           kNonPageOrdinal);
     }
   }
 
-  void UpdateEncryption(int8_t module_type) {
-    switch (module_type) {
+  void updateEncryption(int8_t moduleType) {
+    switch (moduleType) {
       case encryption::kColumnMetaData: {
-        meta_encryptor_->UpdateAad(encryption::CreateModuleAad(
-            meta_encryptor_->file_aad(),
-            module_type,
-            row_group_ordinal_,
-            column_ordinal_,
-            kNonPageOrdinal));
+        metaEncryptor_->updateAad(
+            encryption::createModuleAad(
+                metaEncryptor_->fileAad(),
+                moduleType,
+                rowGroupOrdinal_,
+                columnOrdinal_,
+                kNonPageOrdinal));
         break;
       }
       case encryption::kDataPage: {
-        encryption::QuickUpdatePageAad(page_ordinal_, &data_page_aad_);
-        data_encryptor_->UpdateAad(data_page_aad_);
+        encryption::quickUpdatePageAad(pageOrdinal_, &dataPageAad_);
+        dataEncryptor_->updateAad(dataPageAad_);
         break;
       }
       case encryption::kDataPageHeader: {
-        encryption::QuickUpdatePageAad(page_ordinal_, &data_page_header_aad_);
-        meta_encryptor_->UpdateAad(data_page_header_aad_);
+        encryption::quickUpdatePageAad(pageOrdinal_, &dataPageHeaderAad_);
+        metaEncryptor_->updateAad(dataPageHeaderAad_);
         break;
       }
       case encryption::kDictionaryPageHeader: {
-        meta_encryptor_->UpdateAad(encryption::CreateModuleAad(
-            meta_encryptor_->file_aad(),
-            module_type,
-            row_group_ordinal_,
-            column_ordinal_,
-            kNonPageOrdinal));
+        metaEncryptor_->updateAad(
+            encryption::createModuleAad(
+                metaEncryptor_->fileAad(),
+                moduleType,
+                rowGroupOrdinal_,
+                columnOrdinal_,
+                kNonPageOrdinal));
         break;
       }
       case encryption::kDictionaryPage: {
-        data_encryptor_->UpdateAad(encryption::CreateModuleAad(
-            data_encryptor_->file_aad(),
-            module_type,
-            row_group_ordinal_,
-            column_ordinal_,
-            kNonPageOrdinal));
+        dataEncryptor_->updateAad(
+            encryption::createModuleAad(
+                dataEncryptor_->fileAad(),
+                moduleType,
+                rowGroupOrdinal_,
+                columnOrdinal_,
+                kNonPageOrdinal));
         break;
       }
       default:
-        throw ParquetException("Unknown module type in UpdateEncryption");
+        throw ParquetException("Unknown module type in updateEncryption");
     }
   }
 
   std::shared_ptr<ArrowOutputStream> sink_;
   ColumnChunkMetaDataBuilder* metadata_;
   MemoryPool* pool_;
-  int64_t num_values_;
-  int64_t dictionary_page_offset_;
-  int64_t data_page_offset_;
-  // The uncompressed page size the page writer has already
-  //  written.
-  int64_t total_uncompressed_size_;
-  // The compressed page size the page writer has already
-  //  written.
-  // If the column is UNCOMPRESSED, the size would be
-  //  equal to `total_uncompressed_size_`.
-  int64_t total_compressed_size_;
-  int32_t page_ordinal_;
-  int16_t row_group_ordinal_;
-  int16_t column_ordinal_;
-  bool page_checksum_verification_;
-
-  std::unique_ptr<ThriftSerializer> thrift_serializer_;
+  int64_t numValues_;
+  int64_t dictionaryPageOffset_;
+  int64_t dataPageOffset_;
+  // The uncompressed page size the page writer has already written.
+  int64_t totalUncompressedSize_;
+  // The compressed page size the page writer has already written.
+  // If the column is UNCOMPRESSED, the size would be equal to
+  // totalUncompressedSize_.
+  int64_t totalCompressedSize_;
+  int32_t pageOrdinal_;
+  int16_t rowGroupOrdinal_;
+  int16_t columnOrdinal_;
+  bool pageChecksumVerification_;
+
+  std::unique_ptr<ThriftSerializer> thriftSerializer_;
 
   // Compression codec to use.
   std::unique_ptr<util::Codec> compressor_;
 
-  std::string data_page_aad_;
-  std::string data_page_header_aad_;
+  std::string dataPageAad_;
+  std::string dataPageHeaderAad_;
 
-  std::shared_ptr<Encryptor> meta_encryptor_;
-  std::shared_ptr<Encryptor> data_encryptor_;
+  std::shared_ptr<Encryptor> metaEncryptor_;
+  std::shared_ptr<Encryptor> dataEncryptor_;
 
-  std::shared_ptr<ResizableBuffer> encryption_buffer_;
+  std::shared_ptr<ResizableBuffer> encryptionBuffer_;
 
-  std::map<Encoding::type, int32_t> dict_encoding_stats_;
-  std::map<Encoding::type, int32_t> data_encoding_stats_;
+  std::map<Encoding::type, int32_t> dictEncodingStats_;
+  std::map<Encoding::type, int32_t> dataEncodingStats_;
 
-  ColumnIndexBuilder* column_index_builder_;
-  OffsetIndexBuilder* offset_index_builder_;
+  ColumnIndexBuilder* columnIndexBuilder_;
+  OffsetIndexBuilder* offsetIndexBuilder_;
 };
 
-// This implementation of the PageWriter writes to the final sink on Close .
+// This implementation of the PageWriter writes to the final sink on close.
 class BufferedPageWriter : public PageWriter {
  public:
   BufferedPageWriter(
       std::shared_ptr<ArrowOutputStream> sink,
       Compression::type codec,
       ColumnChunkMetaDataBuilder* metadata,
-      int16_t row_group_ordinal,
-      int16_t current_column_ordinal,
-      bool use_page_checksum_verification,
+      int16_t rowGroupOrdinal,
+      int16_t currentColumnOrdinal,
+      bool usePageChecksumVerification,
       MemoryPool* pool = ::arrow::default_memory_pool(),
-      std::shared_ptr<Encryptor> meta_encryptor = nullptr,
-      std::shared_ptr<Encryptor> data_encryptor = nullptr,
-      ColumnIndexBuilder* column_index_builder = nullptr,
-      OffsetIndexBuilder* offset_index_builder = nullptr,
-      const CodecOptions& codec_options = CodecOptions{})
-      : final_sink_(std::move(sink)),
+      std::shared_ptr<Encryptor> metaEncryptor = nullptr,
+      std::shared_ptr<Encryptor> dataEncryptor = nullptr,
+      ColumnIndexBuilder* columnIndexBuilder = nullptr,
+      OffsetIndexBuilder* offsetIndexBuilder = nullptr,
+      const CodecOptions& codecOptions = CodecOptions{})
+      : finalSink_(std::move(sink)),
         metadata_(metadata),
-        has_dictionary_pages_(false) {
-    in_memory_sink_ = CreateOutputStream(pool);
+        hasDictionaryPages_(false) {
+    inMemorySink_ = createOutputStream(pool);
     pager_ = std::make_unique<SerializedPageWriter>(
-        in_memory_sink_,
+        inMemorySink_,
         codec,
         metadata,
-        row_group_ordinal,
-        current_column_ordinal,
-        use_page_checksum_verification,
+        rowGroupOrdinal,
+        currentColumnOrdinal,
+        usePageChecksumVerification,
         pool,
-        std::move(meta_encryptor),
-        std::move(data_encryptor),
-        column_index_builder,
-        offset_index_builder,
-        codec_options);
+        std::move(metaEncryptor),
+        std::move(dataEncryptor),
+        columnIndexBuilder,
+        offsetIndexBuilder,
+        codecOptions);
   }
 
-  int64_t WriteDictionaryPage(const DictionaryPage& page) override {
-    has_dictionary_pages_ = true;
-    return pager_->WriteDictionaryPage(page);
+  int64_t writeDictionaryPage(const DictionaryPage& page) override {
+    hasDictionaryPages_ = true;
+    return pager_->writeDictionaryPage(page);
   }
 
-  void Close(bool has_dictionary, bool fallback) override {
-    if (pager_->meta_encryptor_ != nullptr) {
-      pager_->UpdateEncryption(encryption::kColumnMetaData);
+  void close(bool hasDictionary, bool fallback) override {
+    if (pager_->metaEncryptor_ != nullptr) {
+      pager_->updateEncryption(encryption::kColumnMetaData);
     }
-    // index_page_offset = -1 since they are not supported
-    PARQUET_ASSIGN_OR_THROW(int64_t final_position, final_sink_->Tell());
-    // dictionary page offset should be 0 iff there are no dictionary pages
-    auto dictionary_page_offset = has_dictionary_pages_
-        ? pager_->dictionary_page_offset() + final_position
+    // Index_page_offset = -1 since they are not supported.
+    PARQUET_ASSIGN_OR_THROW(int64_t finalPosition, finalSink_->Tell());
+    // Dictionary page offset should be 0 iff there are no dictionary pages.
+    auto dictionaryPageOffset = hasDictionaryPages_
+        ? pager_->dictionaryPageOffset() + finalPosition
         : 0;
-    metadata_->Finish(
-        pager_->num_values(),
-        dictionary_page_offset,
+    metadata_->finish(
+        pager_->numValues(),
+        dictionaryPageOffset,
         -1,
-        pager_->data_page_offset() + final_position,
-        pager_->total_compressed_size(),
-        pager_->total_uncompressed_size(),
-        has_dictionary,
+        pager_->dataPageOffset() + finalPosition,
+        pager_->totalCompressedSize(),
+        pager_->totalUncompressedSize(),
+        hasDictionary,
         fallback,
-        pager_->dict_encoding_stats_,
-        pager_->data_encoding_stats_,
-        pager_->meta_encryptor_);
+        pager_->dictEncodingStats_,
+        pager_->dataEncodingStats_,
+        pager_->metaEncryptor_);
 
-    // Write metadata at end of column chunk
-    metadata_->WriteTo(in_memory_sink_.get());
+    // Write metadata at end of column chunk.
+    metadata_->writeTo(inMemorySink_.get());
 
     // Buffered page writer needs to adjust page offsets.
-    pager_->FinishPageIndexes(final_position);
+    pager_->finishPageIndexes(finalPosition);
 
-    // flush everything to the serialized sink
-    PARQUET_ASSIGN_OR_THROW(auto buffer, in_memory_sink_->Finish());
-    PARQUET_THROW_NOT_OK(final_sink_->Write(buffer));
+    // Flush everything to the serialized sink.
+    PARQUET_ASSIGN_OR_THROW(auto buffer, inMemorySink_->Finish());
+    PARQUET_THROW_NOT_OK(finalSink_->Write(buffer));
   }
 
-  int64_t WriteDataPage(const DataPage& page) override {
-    return pager_->WriteDataPage(page);
+  int64_t writeDataPage(const DataPage& page) override {
+    return pager_->writeDataPage(page);
   }
 
-  void Compress(const Buffer& src_buffer, ResizableBuffer* dest_buffer)
-      override {
-    pager_->Compress(src_buffer, dest_buffer);
+  void compress(const Buffer& srcBuffer, ResizableBuffer* destBuffer) override {
+    pager_->compress(srcBuffer, destBuffer);
   }
 
-  bool has_compressor() override {
-    return pager_->has_compressor();
+  bool hasCompressor() override {
+    return pager_->hasCompressor();
   }
 
-  int64_t total_compressed_bytes_written() const override {
-    return pager_->total_compressed_bytes_written();
+  int64_t totalCompressedBytesWritten() const override {
+    return pager_->totalCompressedBytesWritten();
   }
 
  private:
-  std::shared_ptr<ArrowOutputStream> final_sink_;
+  std::shared_ptr<ArrowOutputStream> finalSink_;
   ColumnChunkMetaDataBuilder* metadata_;
-  std::shared_ptr<::arrow::io::BufferOutputStream> in_memory_sink_;
+  std::shared_ptr<::arrow::io::BufferOutputStream> inMemorySink_;
   std::unique_ptr<SerializedPageWriter> pager_;
-  bool has_dictionary_pages_;
+  bool hasDictionaryPages_;
 };
 
-std::unique_ptr<PageWriter> PageWriter::Open(
+std::unique_ptr<PageWriter> PageWriter::open(
     std::shared_ptr<ArrowOutputStream> sink,
     Compression::type codec,
     ColumnChunkMetaDataBuilder* metadata,
-    int16_t row_group_ordinal,
-    int16_t column_chunk_ordinal,
+    int16_t rowGroupOrdinal,
+    int16_t columnChunkOrdinal,
     MemoryPool* pool,
-    bool buffered_row_group,
-    std::shared_ptr<Encryptor> meta_encryptor,
-    std::shared_ptr<Encryptor> data_encryptor,
-    bool page_write_checksum_enabled,
-    ColumnIndexBuilder* column_index_builder,
-    OffsetIndexBuilder* offset_index_builder,
-    const CodecOptions& codec_options) {
-  if (buffered_row_group) {
+    bool bufferedRowGroup,
+    std::shared_ptr<Encryptor> metaEncryptor,
+    std::shared_ptr<Encryptor> dataEncryptor,
+    bool pageWriteChecksumEnabled,
+    ColumnIndexBuilder* columnIndexBuilder,
+    OffsetIndexBuilder* offsetIndexBuilder,
+    const CodecOptions& codecOptions) {
+  if (bufferedRowGroup) {
     return std::unique_ptr<PageWriter>(new BufferedPageWriter(
         std::move(sink),
         codec,
         metadata,
-        row_group_ordinal,
-        column_chunk_ordinal,
-        page_write_checksum_enabled,
+        rowGroupOrdinal,
+        columnChunkOrdinal,
+        pageWriteChecksumEnabled,
         pool,
-        std::move(meta_encryptor),
-        std::move(data_encryptor),
-        column_index_builder,
-        offset_index_builder,
-        codec_options));
+        std::move(metaEncryptor),
+        std::move(dataEncryptor),
+        columnIndexBuilder,
+        offsetIndexBuilder,
+        codecOptions));
   } else {
     return std::unique_ptr<PageWriter>(new SerializedPageWriter(
         std::move(sink),
         codec,
         metadata,
-        row_group_ordinal,
-        column_chunk_ordinal,
-        page_write_checksum_enabled,
+        rowGroupOrdinal,
+        columnChunkOrdinal,
+        pageWriteChecksumEnabled,
         pool,
-        std::move(meta_encryptor),
-        std::move(data_encryptor),
-        column_index_builder,
-        offset_index_builder,
-        codec_options));
+        std::move(metaEncryptor),
+        std::move(dataEncryptor),
+        columnIndexBuilder,
+        offsetIndexBuilder,
+        codecOptions));
   }
 }
 
-std::unique_ptr<PageWriter> PageWriter::Open(
+std::unique_ptr<PageWriter> PageWriter::open(
     std::shared_ptr<ArrowOutputStream> sink,
     Compression::type codec,
-    int compression_level,
+    int compressionLevel,
     ColumnChunkMetaDataBuilder* metadata,
-    int16_t row_group_ordinal,
-    int16_t column_chunk_ordinal,
+    int16_t rowGroupOrdinal,
+    int16_t columnChunkOrdinal,
     MemoryPool* pool,
-    bool buffered_row_group,
-    std::shared_ptr<Encryptor> meta_encryptor,
-    std::shared_ptr<Encryptor> data_encryptor,
-    bool page_write_checksum_enabled,
-    ColumnIndexBuilder* column_index_builder,
-    OffsetIndexBuilder* offset_index_builder) {
-  return PageWriter::Open(
+    bool bufferedRowGroup,
+    std::shared_ptr<Encryptor> metaEncryptor,
+    std::shared_ptr<Encryptor> dataEncryptor,
+    bool pageWriteChecksumEnabled,
+    ColumnIndexBuilder* columnIndexBuilder,
+    OffsetIndexBuilder* offsetIndexBuilder) {
+  return PageWriter::open(
       sink,
       codec,
       metadata,
-      row_group_ordinal,
-      column_chunk_ordinal,
+      rowGroupOrdinal,
+      columnChunkOrdinal,
       pool,
-      buffered_row_group,
-      meta_encryptor,
-      data_encryptor,
-      page_write_checksum_enabled,
-      column_index_builder,
-      offset_index_builder,
-      CodecOptions{compression_level});
+      bufferedRowGroup,
+      metaEncryptor,
+      dataEncryptor,
+      pageWriteChecksumEnabled,
+      columnIndexBuilder,
+      offsetIndexBuilder,
+      CodecOptions{compressionLevel});
 }
-// ----------------------------------------------------------------------
-// ColumnWriter
+// ----------------------------------------------------------------------.
+// ColumnWriter.
 
-const std::shared_ptr<WriterProperties>& default_writer_properties() {
-  static std::shared_ptr<WriterProperties> default_writer_properties =
+const std::shared_ptr<WriterProperties>& defaultWriterProperties() {
+  static std::shared_ptr<WriterProperties> defaultWriterProperties =
       WriterProperties::Builder().build();
-  return default_writer_properties;
+  return defaultWriterProperties;
 }
 
 class ColumnWriterImpl {
@@ -895,118 +892,118 @@ class ColumnWriterImpl {
   ColumnWriterImpl(
       ColumnChunkMetaDataBuilder* metadata,
       std::unique_ptr<PageWriter> pager,
-      const bool use_dictionary,
+      const bool useDictionary,
       Encoding::type encoding,
       const WriterProperties* properties)
       : metadata_(metadata),
         descr_(metadata->descr()),
-        level_info_(ComputeLevelInfo(metadata->descr())),
+        levelInfo_(computeLevelInfo(metadata->descr())),
         pager_(std::move(pager)),
-        has_dictionary_(use_dictionary),
+        hasDictionary_(useDictionary),
         encoding_(encoding),
         properties_(properties),
-        allocator_(properties->memory_pool()),
-        num_buffered_values_(0),
-        num_buffered_encoded_values_(0),
-        num_buffered_nulls_(0),
-        num_buffered_rows_(0),
-        rows_written_(0),
-        total_bytes_written_(0),
-        total_compressed_bytes_(0),
+        allocator_(properties->memoryPool()),
+        numBufferedValues_(0),
+        numBufferedEncodedValues_(0),
+        numBufferedNulls_(0),
+        numBufferedRows_(0),
+        rowsWritten_(0),
+        totalBytesWritten_(0),
+        totalCompressedBytes_(0),
         closed_(false),
         fallback_(false),
-        definition_levels_sink_(allocator_),
-        repetition_levels_sink_(allocator_) {
-    definition_levels_rle_ = std::static_pointer_cast<ResizableBuffer>(
-        AllocateBuffer(allocator_, 0));
-    repetition_levels_rle_ = std::static_pointer_cast<ResizableBuffer>(
-        AllocateBuffer(allocator_, 0));
-    uncompressed_data_ = std::static_pointer_cast<ResizableBuffer>(
-        AllocateBuffer(allocator_, 0));
+        definitionLevelsSink_(allocator_),
+        repetitionLevelsSink_(allocator_) {
+    definitionLevelsRle_ = std::static_pointer_cast<ResizableBuffer>(
+        allocateBuffer(allocator_, 0));
+    repetitionLevelsRle_ = std::static_pointer_cast<ResizableBuffer>(
+        allocateBuffer(allocator_, 0));
+    uncompressedData_ = std::static_pointer_cast<ResizableBuffer>(
+        allocateBuffer(allocator_, 0));
 
-    if (pager_->has_compressor()) {
-      compressor_temp_buffer_ = std::static_pointer_cast<ResizableBuffer>(
-          AllocateBuffer(allocator_, 0));
+    if (pager_->hasCompressor()) {
+      compressorTempBuffer_ = std::static_pointer_cast<ResizableBuffer>(
+          allocateBuffer(allocator_, 0));
     }
   }
 
   virtual ~ColumnWriterImpl() = default;
 
-  int64_t Close();
+  int64_t close();
 
  protected:
-  virtual std::shared_ptr<Buffer> GetValuesBuffer() = 0;
+  virtual std::shared_ptr<Buffer> getValuesBuffer() = 0;
 
-  // Serializes Dictionary Page if enabled
-  virtual void WriteDictionaryPage() = 0;
+  // Serializes Dictionary Page if enabled.
+  virtual void writeDictionaryPage() = 0;
 
-  // Plain-encoded statistics of the current page
-  virtual EncodedStatistics GetPageStatistics() = 0;
+  // Plain-encoded statistics of the current page.
+  virtual EncodedStatistics getPageStatistics() = 0;
 
-  // Plain-encoded statistics of the whole chunk
-  virtual EncodedStatistics GetChunkStatistics() = 0;
+  // Plain-encoded statistics of the whole chunk.
+  virtual EncodedStatistics getChunkStatistics() = 0;
 
-  // Merges page statistics into chunk statistics, then resets the values
-  virtual void ResetPageStatistics() = 0;
+  // Merges page statistics into chunk statistics, then resets the values.
+  virtual void resetPageStatistics() = 0;
 
-  // Adds Data Pages to an in memory buffer in dictionary encoding mode
-  // Serializes the Data Pages in other encoding modes
-  void AddDataPage();
+  // Adds Data Pages to an in memory buffer in dictionary encoding mode.
+  // Serializes the Data Pages in other encoding modes.
+  void addDataPage();
 
-  void BuildDataPageV1(
-      int64_t definition_levels_rle_size,
-      int64_t repetition_levels_rle_size,
-      int64_t uncompressed_size,
+  void buildDataPageV1(
+      int64_t definitionLevelsRleSize,
+      int64_t repetitionLevelsRleSize,
+      int64_t uncompressedSize,
       const std::shared_ptr<Buffer>& values);
 
-  void BuildDataPageV2(
-      int64_t definition_levels_rle_size,
-      int64_t repetition_levels_rle_size,
-      int64_t uncompressed_size,
+  void buildDataPageV2(
+      int64_t definitionLevelsRleSize,
+      int64_t repetitionLevelsRleSize,
+      int64_t uncompressedSize,
       const std::shared_ptr<Buffer>& values);
 
-  // Serializes Data Pages
-  void WriteDataPage(const DataPage& page) {
-    total_bytes_written_ += pager_->WriteDataPage(page);
+  // Serializes Data Pages.
+  void writeDataPage(const DataPage& page) {
+    totalBytesWritten_ += pager_->writeDataPage(page);
   }
 
-  // Write multiple definition levels
-  void WriteDefinitionLevels(int64_t num_levels, const int16_t* levels) {
+  // Write multiple definition levels.
+  void writeDefinitionLevels(int64_t numLevels, const int16_t* levels) {
     VELOX_DCHECK(!closed_);
     PARQUET_THROW_NOT_OK(
-        definition_levels_sink_.Append(levels, sizeof(int16_t) * num_levels));
+        definitionLevelsSink_.Append(levels, sizeof(int16_t) * numLevels));
   }
 
-  // Write multiple repetition levels
-  void WriteRepetitionLevels(int64_t num_levels, const int16_t* levels) {
+  // Write multiple repetition levels.
+  void writeRepetitionLevels(int64_t numLevels, const int16_t* levels) {
     VELOX_DCHECK(!closed_);
     PARQUET_THROW_NOT_OK(
-        repetition_levels_sink_.Append(levels, sizeof(int16_t) * num_levels));
+        repetitionLevelsSink_.Append(levels, sizeof(int16_t) * numLevels));
   }
 
-  // RLE encode the src_buffer into dest_buffer and return the encoded size
-  int64_t RleEncodeLevels(
-      const void* src_buffer,
-      ResizableBuffer* dest_buffer,
-      int16_t max_level,
-      bool include_length_prefix = true);
+  // RLE encode the src_buffer into dest_buffer and return the encoded size.
+  int64_t rleEncodeLevels(
+      const void* srcBuffer,
+      ResizableBuffer* destBuffer,
+      int16_t maxLevel,
+      bool includeLengthPrefix = true);
 
-  // Serialize the buffered Data Pages
-  void FlushBufferedDataPages();
+  // Serialize the buffered Data Pages.
+  void flushBufferedDataPages();
 
   ColumnChunkMetaDataBuilder* metadata_;
   const ColumnDescriptor* descr_;
-  // scratch buffer if validity bits need to be recalculated.
-  std::shared_ptr<ResizableBuffer> bits_buffer_;
-  const LevelInfo level_info_;
+  // Scratch buffer if validity bits need to be recalculated.
+  std::shared_ptr<ResizableBuffer> bitsBuffer_;
+  const LevelInfo levelInfo_;
 
   std::unique_ptr<PageWriter> pager_;
 
-  bool has_dictionary_;
+  bool hasDictionary_;
   Encoding::type encoding_;
   const WriterProperties* properties_;
 
-  LevelEncoder level_encoder_;
+  LevelEncoder levelEncoder_;
 
   MemoryPool* allocator_;
 
@@ -1016,1160 +1013,1131 @@ class ColumnWriterImpl {
   // values. For repeated or optional values, there may be fewer data values
   // than levels, and this tells you how many encoded levels there are in that
   // case.
-  int64_t num_buffered_values_;
+  int64_t numBufferedValues_;
 
   // The total number of stored values in the data page. For repeated or
-  // optional values, this number may be lower than num_buffered_values_.
-  int64_t num_buffered_encoded_values_;
+  // optional values, this number may be lower than numBufferedValues_.
+  int64_t numBufferedEncodedValues_;
 
   // The total number of nulls stored in the data page.
-  int64_t num_buffered_nulls_;
+  int64_t numBufferedNulls_;
 
   // Total number of rows buffered in the data page.
-  int64_t num_buffered_rows_;
+  int64_t numBufferedRows_;
 
-  // Total number of rows written with this ColumnWriter
-  int64_t rows_written_;
+  // Total number of rows written with this ColumnWriter.
+  int64_t rowsWritten_;
 
-  // Records the total number of uncompressed bytes written by the serializer
-  int64_t total_bytes_written_;
+  // Records the total number of uncompressed bytes written by the serializer.
+  int64_t totalBytesWritten_;
 
-  // Records the current number of compressed bytes in a column
-  // These bytes are unwritten to `pager_` yet
-  int64_t total_compressed_bytes_;
+  // Records the current number of compressed bytes in a column.
+  // These bytes are unwritten to `pager_` yet.
+  int64_t totalCompressedBytes_;
 
-  // Flag to check if the Writer has been closed
+  // Flag to check if the Writer has been closed.
   bool closed_;
 
-  // Flag to infer if dictionary encoding has fallen back to PLAIN
+  // Flag to infer if dictionary encoding has fallen back to PLAIN.
   bool fallback_;
 
-  ::arrow::BufferBuilder definition_levels_sink_;
-  ::arrow::BufferBuilder repetition_levels_sink_;
+  ::arrow::BufferBuilder definitionLevelsSink_;
+  ::arrow::BufferBuilder repetitionLevelsSink_;
 
-  std::shared_ptr<ResizableBuffer> definition_levels_rle_;
-  std::shared_ptr<ResizableBuffer> repetition_levels_rle_;
+  std::shared_ptr<ResizableBuffer> definitionLevelsRle_;
+  std::shared_ptr<ResizableBuffer> repetitionLevelsRle_;
 
-  std::shared_ptr<ResizableBuffer> uncompressed_data_;
-  std::shared_ptr<ResizableBuffer> compressor_temp_buffer_;
+  std::shared_ptr<ResizableBuffer> uncompressedData_;
+  std::shared_ptr<ResizableBuffer> compressorTempBuffer_;
 
-  std::vector<std::unique_ptr<DataPage>> data_pages_;
+  std::vector<std::unique_ptr<DataPage>> dataPages_;
 
  private:
-  void InitSinks() {
-    definition_levels_sink_.Rewind(0);
-    repetition_levels_sink_.Rewind(0);
+  void initSinks() {
+    definitionLevelsSink_.Rewind(0);
+    repetitionLevelsSink_.Rewind(0);
   }
 
-  // Concatenate the encoded levels and values into one buffer
-  void ConcatenateBuffers(
-      int64_t definition_levels_rle_size,
-      int64_t repetition_levels_rle_size,
+  // Concatenate the encoded levels and values into one buffer.
+  void concatenateBuffers(
+      int64_t definitionLevelsRleSize,
+      int64_t repetitionLevelsRleSize,
       const std::shared_ptr<Buffer>& values,
       uint8_t* combined) {
-    memcpy(
-        combined, repetition_levels_rle_->data(), repetition_levels_rle_size);
-    combined += repetition_levels_rle_size;
-    memcpy(
-        combined, definition_levels_rle_->data(), definition_levels_rle_size);
-    combined += definition_levels_rle_size;
+    memcpy(combined, repetitionLevelsRle_->data(), repetitionLevelsRleSize);
+    combined += repetitionLevelsRleSize;
+    memcpy(combined, definitionLevelsRle_->data(), definitionLevelsRleSize);
+    combined += definitionLevelsRleSize;
     memcpy(combined, values->data(), values->size());
   }
 };
 
-// return the size of the encoded buffer
-int64_t ColumnWriterImpl::RleEncodeLevels(
-    const void* src_buffer,
-    ResizableBuffer* dest_buffer,
-    int16_t max_level,
-    bool include_length_prefix) {
+// Return the size of the encoded buffer.
+int64_t ColumnWriterImpl::rleEncodeLevels(
+    const void* srcBuffer,
+    ResizableBuffer* destBuffer,
+    int16_t maxLevel,
+    bool includeLengthPrefix) {
   // V1 DataPage includes the length of the RLE level as a prefix.
-  int32_t prefix_size = include_length_prefix ? sizeof(int32_t) : 0;
-
-  // TODO: This only works with due to some RLE specifics
-  int64_t rle_size =
-      LevelEncoder::MaxBufferSize(
-          Encoding::RLE, max_level, static_cast<int>(num_buffered_values_)) +
-      prefix_size;
-
-  // Use Arrow::Buffer::shrink_to_fit = false
-  // underlying buffer only keeps growing. Resize to a smaller size does not
-  // reallocate.
-  PARQUET_THROW_NOT_OK(dest_buffer->Resize(rle_size, false));
-
-  level_encoder_.Init(
-      Encoding::RLE,
-      max_level,
-      static_cast<int>(num_buffered_values_),
-      dest_buffer->mutable_data() + prefix_size,
-      static_cast<int>(dest_buffer->size() - prefix_size));
-  VELOX_DEBUG_ONLY int encoded = level_encoder_.Encode(
-      static_cast<int>(num_buffered_values_),
-      reinterpret_cast<const int16_t*>(src_buffer));
-  VELOX_DCHECK_EQ(encoded, num_buffered_values_);
-
-  if (include_length_prefix) {
-    reinterpret_cast<int32_t*>(dest_buffer->mutable_data())[0] =
-        level_encoder_.len();
-  }
-
-  return level_encoder_.len() + prefix_size;
+  int32_t prefixSize = includeLengthPrefix ? sizeof(int32_t) : 0;
+
+  // TODO: This only works due to some RLE specifics.
+  int64_t rleSize =
+      LevelEncoder::maxBufferSize(
+          Encoding::kRle, maxLevel, static_cast<int>(numBufferedValues_)) +
+      prefixSize;
+
+  // Use Arrow::Buffer::shrink_to_fit = false.
+  // Underlying buffer only keeps growing. Resize to a smaller size does not.
+  // Reallocate.
+  PARQUET_THROW_NOT_OK(destBuffer->Resize(rleSize, false));
+
+  levelEncoder_.init(
+      Encoding::kRle,
+      maxLevel,
+      static_cast<int>(numBufferedValues_),
+      destBuffer->mutable_data() + prefixSize,
+      static_cast<int>(destBuffer->size() - prefixSize));
+  VELOX_DEBUG_ONLY int encoded = levelEncoder_.encode(
+      static_cast<int>(numBufferedValues_),
+      reinterpret_cast<const int16_t*>(srcBuffer));
+  VELOX_DCHECK_EQ(encoded, numBufferedValues_);
+
+  if (includeLengthPrefix) {
+    reinterpret_cast<int32_t*>(destBuffer->mutable_data())[0] =
+        levelEncoder_.len();
+  }
+
+  return levelEncoder_.len() + prefixSize;
 }
 
-void ColumnWriterImpl::AddDataPage() {
-  int64_t definition_levels_rle_size = 0;
-  int64_t repetition_levels_rle_size = 0;
+void ColumnWriterImpl::addDataPage() {
+  int64_t definitionLevelsRleSize = 0;
+  int64_t repetitionLevelsRleSize = 0;
 
-  std::shared_ptr<Buffer> values = GetValuesBuffer();
-  bool is_v1_data_page =
-      properties_->data_page_version() == ParquetDataPageVersion::V1;
+  std::shared_ptr<Buffer> values = getValuesBuffer();
+  bool isV1DataPage =
+      properties_->dataPageVersion() == ParquetDataPageVersion::V1;
 
-  if (descr_->max_definition_level() > 0) {
-    definition_levels_rle_size = RleEncodeLevels(
-        definition_levels_sink_.data(),
-        definition_levels_rle_.get(),
-        descr_->max_definition_level(),
-        /*include_length_prefix=*/is_v1_data_page);
+  if (descr_->maxDefinitionLevel() > 0) {
+    definitionLevelsRleSize = rleEncodeLevels(
+        definitionLevelsSink_.data(),
+        definitionLevelsRle_.get(),
+        descr_->maxDefinitionLevel(),
+        isV1DataPage);
   }
 
-  if (descr_->max_repetition_level() > 0) {
-    repetition_levels_rle_size = RleEncodeLevels(
-        repetition_levels_sink_.data(),
-        repetition_levels_rle_.get(),
-        descr_->max_repetition_level(),
-        /*include_length_prefix=*/is_v1_data_page);
+  if (descr_->maxRepetitionLevel() > 0) {
+    repetitionLevelsRleSize = rleEncodeLevels(
+        repetitionLevelsSink_.data(),
+        repetitionLevelsRle_.get(),
+        descr_->maxRepetitionLevel(),
+        isV1DataPage);
   }
 
-  int64_t uncompressed_size =
-      definition_levels_rle_size + repetition_levels_rle_size + values->size();
+  int64_t uncompressedSize =
+      definitionLevelsRleSize + repetitionLevelsRleSize + values->size();
 
-  if (is_v1_data_page) {
-    BuildDataPageV1(
-        definition_levels_rle_size,
-        repetition_levels_rle_size,
-        uncompressed_size,
+  if (isV1DataPage) {
+    buildDataPageV1(
+        definitionLevelsRleSize,
+        repetitionLevelsRleSize,
+        uncompressedSize,
         values);
   } else {
-    BuildDataPageV2(
-        definition_levels_rle_size,
-        repetition_levels_rle_size,
-        uncompressed_size,
+    buildDataPageV2(
+        definitionLevelsRleSize,
+        repetitionLevelsRleSize,
+        uncompressedSize,
         values);
   }
 
   // Re-initialize the sinks for next Page.
-  InitSinks();
-  num_buffered_values_ = 0;
-  num_buffered_encoded_values_ = 0;
-  num_buffered_rows_ = 0;
-  num_buffered_nulls_ = 0;
+  initSinks();
+  numBufferedValues_ = 0;
+  numBufferedEncodedValues_ = 0;
+  numBufferedRows_ = 0;
+  numBufferedNulls_ = 0;
 }
 
-void ColumnWriterImpl::BuildDataPageV1(
-    int64_t definition_levels_rle_size,
-    int64_t repetition_levels_rle_size,
-    int64_t uncompressed_size,
+void ColumnWriterImpl::buildDataPageV1(
+    int64_t definitionLevelsRleSize,
+    int64_t repetitionLevelsRleSize,
+    int64_t uncompressedSize,
     const std::shared_ptr<Buffer>& values) {
-  // Use Arrow::Buffer::shrink_to_fit = false
-  // underlying buffer only keeps growing. Resize to a smaller size does not
-  // reallocate.
-  PARQUET_THROW_NOT_OK(uncompressed_data_->Resize(uncompressed_size, false));
-  ConcatenateBuffers(
-      definition_levels_rle_size,
-      repetition_levels_rle_size,
+  // Use Arrow::Buffer::shrink_to_fit = false.
+  // Underlying buffer only keeps growing. Resize to a smaller size does not.
+  // Reallocate.
+  PARQUET_THROW_NOT_OK(uncompressedData_->Resize(uncompressedSize, false));
+  concatenateBuffers(
+      definitionLevelsRleSize,
+      repetitionLevelsRleSize,
       values,
-      uncompressed_data_->mutable_data());
-
-  EncodedStatistics page_stats = GetPageStatistics();
-  page_stats.ApplyStatSizeLimits(
-      properties_->max_statistics_size(descr_->path()));
-  page_stats.set_is_signed(SortOrder::SIGNED == descr_->sort_order());
-  ResetPageStatistics();
-
-  std::shared_ptr<Buffer> compressed_data;
-  if (pager_->has_compressor()) {
-    pager_->Compress(
-        *(uncompressed_data_.get()), compressor_temp_buffer_.get());
-    compressed_data = compressor_temp_buffer_;
+      uncompressedData_->mutable_data());
+
+  EncodedStatistics pageStats = getPageStatistics();
+  pageStats.applyStatSizeLimits(properties_->maxStatisticsSize(descr_->path()));
+  pageStats.setIsSigned(SortOrder::kSigned == descr_->sortOrder());
+  resetPageStatistics();
+
+  std::shared_ptr<Buffer> compressedData;
+  if (pager_->hasCompressor()) {
+    pager_->compress(*(uncompressedData_.get()), compressorTempBuffer_.get());
+    compressedData = compressorTempBuffer_;
   } else {
-    compressed_data = uncompressed_data_;
+    compressedData = uncompressedData_;
   }
 
-  int32_t num_values = static_cast<int32_t>(num_buffered_values_);
-  int64_t first_row_index = rows_written_ - num_buffered_rows_;
+  int32_t numValues = static_cast<int32_t>(numBufferedValues_);
+  int64_t firstRowIndex = rowsWritten_ - numBufferedRows_;
 
-  // Write the page to OutputStream eagerly if there is no dictionary or
-  // if dictionary encoding has fallen back to PLAIN
-  if (has_dictionary_ &&
+  // Write the page to OutputStream eagerly if there is no dictionary or.
+  // If dictionary encoding has fallen back to PLAIN.
+  if (hasDictionary_ &&
       !fallback_) { // Save pages until end of dictionary encoding
     PARQUET_ASSIGN_OR_THROW(
-        auto compressed_data_copy,
-        compressed_data->CopySlice(0, compressed_data->size(), allocator_));
-    std::unique_ptr<DataPage> page_ptr = std::make_unique<DataPageV1>(
-        compressed_data_copy,
-        num_values,
+        auto compressedDataCopy,
+        compressedData->CopySlice(0, compressedData->size(), allocator_));
+    std::unique_ptr<DataPage> pagePtr = std::make_unique<DataPageV1>(
+        compressedDataCopy,
+        numValues,
         encoding_,
-        Encoding::RLE,
-        Encoding::RLE,
-        uncompressed_size,
-        page_stats,
-        first_row_index);
-    total_compressed_bytes_ +=
-        page_ptr->size() + sizeof(facebook::velox::parquet::thrift::PageHeader);
-
-    data_pages_.push_back(std::move(page_ptr));
+        Encoding::kRle,
+        Encoding::kRle,
+        uncompressedSize,
+        pageStats,
+        firstRowIndex);
+    totalCompressedBytes_ +=
+        pagePtr->size() + sizeof(facebook::velox::parquet::thrift::PageHeader);
+
+    dataPages_.push_back(std::move(pagePtr));
   } else { // Eagerly write pages
     DataPageV1 page(
-        compressed_data,
-        num_values,
+        compressedData,
+        numValues,
         encoding_,
-        Encoding::RLE,
-        Encoding::RLE,
-        uncompressed_size,
-        page_stats,
-        first_row_index);
-    WriteDataPage(page);
+        Encoding::kRle,
+        Encoding::kRle,
+        uncompressedSize,
+        pageStats,
+        firstRowIndex);
+    writeDataPage(page);
   }
 }
 
-void ColumnWriterImpl::BuildDataPageV2(
-    int64_t definition_levels_rle_size,
-    int64_t repetition_levels_rle_size,
-    int64_t uncompressed_size,
+void ColumnWriterImpl::buildDataPageV2(
+    int64_t definitionLevelsRleSize,
+    int64_t repetitionLevelsRleSize,
+    int64_t uncompressedSize,
     const std::shared_ptr<Buffer>& values) {
   // Compress the values if needed. Repetition and definition levels are
   // uncompressed in V2.
-  std::shared_ptr<Buffer> compressed_values;
-  if (pager_->has_compressor()) {
-    pager_->Compress(*values, compressor_temp_buffer_.get());
-    compressed_values = compressor_temp_buffer_;
+  std::shared_ptr<Buffer> compressedValues;
+  if (pager_->hasCompressor()) {
+    pager_->compress(*values, compressorTempBuffer_.get());
+    compressedValues = compressorTempBuffer_;
   } else {
-    compressed_values = values;
+    compressedValues = values;
   }
 
-  // Concatenate uncompressed levels and the possibly compressed values
-  int64_t combined_size = definition_levels_rle_size +
-      repetition_levels_rle_size + compressed_values->size();
+  // Concatenate uncompressed levels and the possibly compressed values.
+  int64_t combinedSize = definitionLevelsRleSize + repetitionLevelsRleSize +
+      compressedValues->size();
   std::shared_ptr<ResizableBuffer> combined =
-      AllocateBuffer(allocator_, combined_size);
+      allocateBuffer(allocator_, combinedSize);
 
-  ConcatenateBuffers(
-      definition_levels_rle_size,
-      repetition_levels_rle_size,
-      compressed_values,
+  concatenateBuffers(
+      definitionLevelsRleSize,
+      repetitionLevelsRleSize,
+      compressedValues,
       combined->mutable_data());
 
-  EncodedStatistics page_stats = GetPageStatistics();
-  page_stats.ApplyStatSizeLimits(
-      properties_->max_statistics_size(descr_->path()));
-  page_stats.set_is_signed(SortOrder::SIGNED == descr_->sort_order());
-  ResetPageStatistics();
-
-  int32_t num_values = static_cast<int32_t>(num_buffered_values_);
-  int32_t null_count = static_cast<int32_t>(num_buffered_nulls_);
-  int32_t num_rows = static_cast<int32_t>(num_buffered_rows_);
-  int32_t def_levels_byte_length =
-      static_cast<int32_t>(definition_levels_rle_size);
-  int32_t rep_levels_byte_length =
-      static_cast<int32_t>(repetition_levels_rle_size);
-  int64_t first_row_index = rows_written_ - num_buffered_rows_;
-
-  // page_stats.null_count is not set when page_statistics_ is nullptr. It is
+  EncodedStatistics pageStats = getPageStatistics();
+  pageStats.applyStatSizeLimits(properties_->maxStatisticsSize(descr_->path()));
+  pageStats.setIsSigned(SortOrder::kSigned == descr_->sortOrder());
+  resetPageStatistics();
+
+  int32_t numValues = static_cast<int32_t>(numBufferedValues_);
+  int32_t nullCount = static_cast<int32_t>(numBufferedNulls_);
+  int32_t numRows = static_cast<int32_t>(numBufferedRows_);
+  int32_t defLevelsByteLength = static_cast<int32_t>(definitionLevelsRleSize);
+  int32_t repLevelsByteLength = static_cast<int32_t>(repetitionLevelsRleSize);
+  int64_t firstRowIndex = rowsWritten_ - numBufferedRows_;
+
+  // pageStats.null_count is not set when page_statistics_ is nullptr. It is
   // only used here for safety check.
-  VELOX_DCHECK(
-      !page_stats.has_null_count || page_stats.null_count == null_count);
+  VELOX_DCHECK(!pageStats.hasNullCount || pageStats.nullCount == nullCount);
 
-  // Write the page to OutputStream eagerly if there is no dictionary or
-  // if dictionary encoding has fallen back to PLAIN
-  if (has_dictionary_ &&
+  // Write the page to OutputStream eagerly if there is no dictionary or.
+  // If dictionary encoding has fallen back to PLAIN.
+  if (hasDictionary_ &&
       !fallback_) { // Save pages until end of dictionary encoding
     PARQUET_ASSIGN_OR_THROW(
-        auto data_copy, combined->CopySlice(0, combined->size(), allocator_));
-    std::unique_ptr<DataPage> page_ptr = std::make_unique<DataPageV2>(
+        auto dataCopy, combined->CopySlice(0, combined->size(), allocator_));
+    std::unique_ptr<DataPage> pagePtr = std::make_unique<DataPageV2>(
         combined,
-        num_values,
-        null_count,
-        num_rows,
+        numValues,
+        nullCount,
+        numRows,
         encoding_,
-        def_levels_byte_length,
-        rep_levels_byte_length,
-        uncompressed_size,
-        pager_->has_compressor(),
-        page_stats,
-        first_row_index);
-    total_compressed_bytes_ +=
-        page_ptr->size() + sizeof(facebook::velox::parquet::thrift::PageHeader);
-    data_pages_.push_back(std::move(page_ptr));
+        defLevelsByteLength,
+        repLevelsByteLength,
+        uncompressedSize,
+        pager_->hasCompressor(),
+        pageStats,
+        firstRowIndex);
+    totalCompressedBytes_ +=
+        pagePtr->size() + sizeof(facebook::velox::parquet::thrift::PageHeader);
+    dataPages_.push_back(std::move(pagePtr));
   } else {
     DataPageV2 page(
         combined,
-        num_values,
-        null_count,
-        num_rows,
+        numValues,
+        nullCount,
+        numRows,
         encoding_,
-        def_levels_byte_length,
-        rep_levels_byte_length,
-        uncompressed_size,
-        pager_->has_compressor(),
-        page_stats,
-        first_row_index);
-    WriteDataPage(page);
+        defLevelsByteLength,
+        repLevelsByteLength,
+        uncompressedSize,
+        pager_->hasCompressor(),
+        pageStats,
+        firstRowIndex);
+    writeDataPage(page);
   }
 }
 
-int64_t ColumnWriterImpl::Close() {
+int64_t ColumnWriterImpl::close() {
   if (!closed_) {
     closed_ = true;
-    if (has_dictionary_ && !fallback_) {
-      WriteDictionaryPage();
+    if (hasDictionary_ && !fallback_) {
+      writeDictionaryPage();
     }
 
-    FlushBufferedDataPages();
+    flushBufferedDataPages();
 
-    EncodedStatistics chunk_statistics = GetChunkStatistics();
-    chunk_statistics.ApplyStatSizeLimits(
-        properties_->max_statistics_size(descr_->path()));
-    chunk_statistics.set_is_signed(SortOrder::SIGNED == descr_->sort_order());
+    EncodedStatistics chunkStatistics = getChunkStatistics();
+    chunkStatistics.applyStatSizeLimits(
+        properties_->maxStatisticsSize(descr_->path()));
+    chunkStatistics.setIsSigned(SortOrder::kSigned == descr_->sortOrder());
 
-    // Write stats only if the column has at least one row written
-    if (rows_written_ > 0 && chunk_statistics.is_set()) {
-      metadata_->SetStatistics(chunk_statistics);
+    // Write stats only if the column has at least one row written.
+    if (rowsWritten_ > 0 && chunkStatistics.isSet()) {
+      metadata_->setStatistics(chunkStatistics);
     }
-    pager_->Close(has_dictionary_, fallback_);
+    pager_->close(hasDictionary_, fallback_);
   }
 
-  return total_bytes_written_;
+  return totalBytesWritten_;
 }
 
-void ColumnWriterImpl::FlushBufferedDataPages() {
-  // Write all outstanding data to a new page
-  if (num_buffered_values_ > 0) {
-    AddDataPage();
+void ColumnWriterImpl::flushBufferedDataPages() {
+  // Write all outstanding data to a new page.
+  if (numBufferedValues_ > 0) {
+    addDataPage();
   }
-  for (const auto& page_ptr : data_pages_) {
-    WriteDataPage(*page_ptr);
+  for (const auto& pagePtr : dataPages_) {
+    writeDataPage(*pagePtr);
   }
-  data_pages_.clear();
-  total_compressed_bytes_ = 0;
+  dataPages_.clear();
+  totalCompressedBytes_ = 0;
 }
 
-// ----------------------------------------------------------------------
-// TypedColumnWriter
+// ----------------------------------------------------------------------.
+// TypedColumnWriter.
 
 template <typename Action>
-inline void DoInBatches(int64_t total, int64_t batch_size, Action&& action) {
-  int64_t num_batches = static_cast<int>(total / batch_size);
-  for (int round = 0; round < num_batches; round++) {
-    action(round * batch_size, batch_size, /*check_page_size=*/true);
+inline void doInBatches(int64_t total, int64_t batchSize, Action&& action) {
+  int64_t numBatches = static_cast<int>(total / batchSize);
+  for (int round = 0; round < numBatches; round++) {
+    action(round * batchSize, batchSize, true);
   }
-  // Write the remaining values
-  if (total % batch_size > 0) {
-    action(
-        num_batches * batch_size, total % batch_size, /*check_page_size=*/true);
+  // Write the remaining values.
+  if (total % batchSize > 0) {
+    action(numBatches * batchSize, total % batchSize, true);
   }
 }
 
 template <typename Action>
-inline void DoInBatches(
-    const int16_t* def_levels,
-    const int16_t* rep_levels,
-    int64_t num_levels,
-    int64_t batch_size,
+inline void doInBatches(
+    const int16_t* defLevels,
+    const int16_t* repLevels,
+    int64_t numLevels,
+    int64_t batchSize,
     Action&& action,
-    bool pages_change_on_record_boundaries) {
-  if (!pages_change_on_record_boundaries || !rep_levels) {
-    // If rep_levels is null, then we are writing a non-repeated column.
+    bool pagesChangeOnRecordBoundaries) {
+  if (!pagesChangeOnRecordBoundaries || !repLevels) {
+    // If repLevels is null, then we are writing a non-repeated column.
     // In this case, every record contains only one level.
-    return DoInBatches(num_levels, batch_size, std::forward<Action>(action));
+    return doInBatches(numLevels, batchSize, std::forward<Action>(action));
   }
 
   int64_t offset = 0;
-  while (offset < num_levels) {
-    int64_t end_offset = std::min(offset + batch_size, num_levels);
+  while (offset < numLevels) {
+    int64_t endOffset = std::min(offset + batchSize, numLevels);
 
-    // Find next record boundary (i.e. ref_level = 0)
-    while (end_offset < num_levels && rep_levels[end_offset] != 0) {
-      end_offset++;
+    // Find next record boundary (i.e. repLevel = 0).
+    while (endOffset < numLevels && repLevels[endOffset] != 0) {
+      endOffset++;
     }
 
-    if (end_offset < num_levels) {
-      // This is not the last chunk of batch and end_offset is a record
+    if (endOffset < numLevels) {
+      // This is not the last chunk of batch and endOffset is a record
       // boundary. It is a good chance to check the page size.
-      action(offset, end_offset - offset, /*check_page_size=*/true);
+      action(offset, endOffset - offset, true);
     } else {
-      VELOX_DCHECK_EQ(end_offset, num_levels);
-      // This is the last chunk of batch, and we do not know whether end_offset
+      VELOX_DCHECK_EQ(endOffset, numLevels);
+      // This is the last chunk of batch, and we do not know whether endOffset
       // is a record boundary. Find the offset to beginning of last record in
       // this chunk, so we can check page size.
-      int64_t last_record_begin_offset = num_levels - 1;
-      while (last_record_begin_offset >= offset &&
-             rep_levels[last_record_begin_offset] != 0) {
-        last_record_begin_offset--;
+      int64_t lastRecordBeginOffset = numLevels - 1;
+      while (lastRecordBeginOffset >= offset &&
+             repLevels[lastRecordBeginOffset] != 0) {
+        lastRecordBeginOffset--;
       }
 
-      if (offset < last_record_begin_offset) {
+      if (offset < lastRecordBeginOffset) {
         // We have found the beginning of last record and can check page size.
-        action(
-            offset,
-            last_record_begin_offset - offset,
-            /*check_page_size=*/true);
-        offset = last_record_begin_offset;
+        action(offset, lastRecordBeginOffset - offset, true);
+        offset = lastRecordBeginOffset;
       }
 
       // There is no record boundary in this chunk and cannot check page size.
-      action(offset, end_offset - offset, /*check_page_size=*/false);
+      action(offset, endOffset - offset, false);
     }
 
-    offset = end_offset;
+    offset = endOffset;
   }
 }
 
-bool DictionaryDirectWriteSupported(const ::arrow::Array& array) {
-  VELOX_DCHECK_EQ(array.type_id(), ::arrow::Type::DICTIONARY);
-  const ::arrow::DictionaryType& dict_type =
+bool dictionaryDirectWriteSupported(const ::arrow::Array& array) {
+  VELOX_DCHECK_EQ(
+      static_cast<int>(array.type_id()),
+      static_cast<int>(::arrow::Type::DICTIONARY));
+  const ::arrow::DictionaryType& dictType =
       static_cast<const ::arrow::DictionaryType&>(*array.type());
-  return ::arrow::is_base_binary_like(dict_type.value_type()->id());
+  return ::arrow::is_base_binary_like(dictType.value_type()->id());
 }
 
-Status ConvertDictionaryToDense(
+Status convertDictionaryToDense(
     const ::arrow::Array& array,
     MemoryPool* pool,
     std::shared_ptr<::arrow::Array>* out) {
-  const ::arrow::DictionaryType& dict_type =
+  const ::arrow::DictionaryType& dictType =
       static_cast<const ::arrow::DictionaryType&>(*array.type());
 
   ::arrow::compute::ExecContext ctx(pool);
   ARROW_ASSIGN_OR_RAISE(
-      Datum cast_output,
+      Datum castOutput,
       ::arrow::compute::Cast(
           array.data(),
-          dict_type.value_type(),
-          ::arrow::compute::CastOptions(),
+          dictType.value_type(),
+          ::arrow::compute::CastOptions::Safe(),
           &ctx));
-  *out = cast_output.make_array();
+  *out = castOutput.make_array();
   return Status::OK();
 }
 
-static inline bool IsDictionaryEncoding(Encoding::type encoding) {
-  return encoding == Encoding::PLAIN_DICTIONARY;
+static inline bool isDictionaryEncoding(Encoding::type encoding) {
+  return encoding == Encoding::kPlainDictionary;
 }
 
 template <typename DType>
 class TypedColumnWriterImpl : public ColumnWriterImpl,
                               public TypedColumnWriter<DType> {
  public:
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
 
   TypedColumnWriterImpl(
       ColumnChunkMetaDataBuilder* metadata,
       std::unique_ptr<PageWriter> pager,
-      const bool use_dictionary,
+      const bool useDictionary,
       Encoding::type encoding,
       const WriterProperties* properties)
       : ColumnWriterImpl(
             metadata,
             std::move(pager),
-            use_dictionary,
+            useDictionary,
             encoding,
             properties) {
-    current_encoder_ = MakeEncoder(
-        DType::type_num,
+    currentEncoder_ = makeEncoder(
+        DType::typeNum,
         encoding,
-        use_dictionary,
+        useDictionary,
         descr_,
-        properties->memory_pool());
+        properties->memoryPool());
 
     // We have to dynamic_cast as some compilers don't want to static_cast
     // through virtual inheritance.
-    current_value_encoder_ =
-        dynamic_cast<TypedEncoder<DType>*>(current_encoder_.get());
+    currentValueEncoder_ =
+        dynamic_cast<TypedEncoder<DType>*>(currentEncoder_.get());
 
-    // Will be null if not using dictionary, but that's ok
-    current_dict_encoder_ =
-        dynamic_cast<DictEncoder<DType>*>(current_encoder_.get());
+    // Will be null if not using dictionary, but that's ok.
+    currentDictEncoder_ =
+        dynamic_cast<DictEncoder<DType>*>(currentEncoder_.get());
 
-    if (properties->statistics_enabled(descr_->path()) &&
-        (SortOrder::UNKNOWN != descr_->sort_order())) {
-      page_statistics_ = MakeStatistics<DType>(descr_, allocator_);
-      chunk_statistics_ = MakeStatistics<DType>(descr_, allocator_);
+    if (properties->statisticsEnabled(descr_->path()) &&
+        (SortOrder::kUnknown != descr_->sortOrder())) {
+      pageStatistics_ = makeStatistics<DType>(descr_, allocator_);
+      chunkStatistics_ = makeStatistics<DType>(descr_, allocator_);
     }
-    pages_change_on_record_boundaries_ =
-        properties->data_page_version() == ParquetDataPageVersion::V2 ||
-        properties->page_index_enabled(descr_->path());
+    pagesChangeOnRecordBoundaries_ =
+        properties->dataPageVersion() == ParquetDataPageVersion::V2 ||
+        properties->pageIndexEnabled(descr_->path());
   }
 
-  int64_t Close() override {
-    return ColumnWriterImpl::Close();
+  int64_t close() override {
+    return ColumnWriterImpl::close();
   }
 
-  int64_t WriteBatch(
-      int64_t num_values,
-      const int16_t* def_levels,
-      const int16_t* rep_levels,
+  int64_t writeBatch(
+      int64_t numValues,
+      const int16_t* defLevels,
+      const int16_t* repLevels,
       const T* values) override {
-    // We check for DataPage limits only after we have inserted the values. If a
-    // user writes a large number of values, the DataPage size can be much above
-    // the limit. The purpose of this chunking is to bound this. Even if a user
-    // writes large number of values, the chunking will ensure the AddDataPage()
-    // is called at a reasonable pagesize limit
-    int64_t value_offset = 0;
-
-    auto WriteChunk = [&](int64_t offset, int64_t batch_size, bool check_page) {
-      int64_t values_to_write = WriteLevels(
-          batch_size,
-          AddIfNotNull(def_levels, offset),
-          AddIfNotNull(rep_levels, offset));
-
-      // PARQUET-780
-      if (values_to_write > 0) {
+    // We check for DataPage limits only after we have inserted the values. If
+    // a user writes a large number of values, the DataPage size can be much
+    // above the limit. The purpose of this chunking is to bound this. Even if
+    // a user writes large number of values, the chunking will ensure the
+    // addDataPage() is called at a reasonable pagesize limit.
+    int64_t valueOffset = 0;
+
+    auto writeChunk = [&](int64_t offset, int64_t batchSize, bool checkPage) {
+      int64_t valuesToWrite = writeLevels(
+          batchSize,
+          addIfNotNull(defLevels, offset),
+          addIfNotNull(repLevels, offset));
+
+      // PARQUET-780.
+      if (valuesToWrite > 0) {
         VELOX_DCHECK_NOT_NULL(values);
       }
-      const int64_t num_nulls = batch_size - values_to_write;
-      WriteValues(
-          AddIfNotNull(values, value_offset), values_to_write, num_nulls);
-      CommitWriteAndCheckPageLimit(
-          batch_size, values_to_write, num_nulls, check_page);
-      value_offset += values_to_write;
+      const int64_t numNulls = batchSize - valuesToWrite;
+      writeValues(addIfNotNull(values, valueOffset), valuesToWrite, numNulls);
+      commitWriteAndCheckPageLimit(
+          batchSize, valuesToWrite, numNulls, checkPage);
+      valueOffset += valuesToWrite;
 
       // Dictionary size checked separately from data page size since we
-      // circumvent this check when writing ::arrow::DictionaryArray directly
-      CheckDictionarySizeLimit();
+      // circumvent this check when writing ::arrow::DictionaryArray directly.
+      checkDictionarySizeLimit();
     };
-    DoInBatches(
-        def_levels,
-        rep_levels,
-        num_values,
-        properties_->write_batch_size(),
-        WriteChunk,
-        pages_change_on_record_boundaries());
-    return value_offset;
-  }
-
-  void WriteBatchSpaced(
-      int64_t num_values,
-      const int16_t* def_levels,
-      const int16_t* rep_levels,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+    doInBatches(
+        defLevels,
+        repLevels,
+        numValues,
+        properties_->writeBatchSize(),
+        writeChunk,
+        pagesChangeOnRecordBoundaries());
+    return valueOffset;
+  }
+
+  void writeBatchSpaced(
+      int64_t numValues,
+      const int16_t* defLevels,
+      const int16_t* repLevels,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       const T* values) override {
-    // Like WriteBatch, but for spaced values
-    int64_t value_offset = 0;
-    auto WriteChunk = [&](int64_t offset, int64_t batch_size, bool check_page) {
-      int64_t batch_num_values = 0;
-      int64_t batch_num_spaced_values = 0;
-      int64_t null_count;
-      MaybeCalculateValidityBits(
-          AddIfNotNull(def_levels, offset),
-          batch_size,
-          &batch_num_values,
-          &batch_num_spaced_values,
-          &null_count);
-
-      WriteLevelsSpaced(
-          batch_size,
-          AddIfNotNull(def_levels, offset),
-          AddIfNotNull(rep_levels, offset));
-      if (bits_buffer_ != nullptr) {
-        WriteValuesSpaced(
-            AddIfNotNull(values, value_offset),
-            batch_num_values,
-            batch_num_spaced_values,
-            bits_buffer_->data(),
-            /*valid_bits_offset=*/0,
-            /*num_levels=*/batch_size,
-            null_count);
+    // Like WriteBatch, but for spaced values.
+    int64_t valueOffset = 0;
+    auto writeChunk = [&](int64_t offset, int64_t batchSize, bool checkPage) {
+      int64_t batchNumValues = 0;
+      int64_t batchNumSpacedValues = 0;
+      int64_t nullCount;
+      maybeCalculateValidityBits(
+          addIfNotNull(defLevels, offset),
+          batchSize,
+          &batchNumValues,
+          &batchNumSpacedValues,
+          &nullCount);
+
+      writeLevelsSpaced(
+          batchSize,
+          addIfNotNull(defLevels, offset),
+          addIfNotNull(repLevels, offset));
+      if (bitsBuffer_ != nullptr) {
+        writeValuesSpaced(
+            addIfNotNull(values, valueOffset),
+            batchNumValues,
+            batchNumSpacedValues,
+            bitsBuffer_->data(),
+            0,
+            batchSize,
+            nullCount);
       } else {
-        WriteValuesSpaced(
-            AddIfNotNull(values, value_offset),
-            batch_num_values,
-            batch_num_spaced_values,
-            valid_bits,
-            valid_bits_offset + value_offset,
-            /*num_levels=*/batch_size,
-            null_count);
+        writeValuesSpaced(
+            addIfNotNull(values, valueOffset),
+            batchNumValues,
+            batchNumSpacedValues,
+            validBits,
+            validBitsOffset + valueOffset,
+            batchSize,
+            nullCount);
       }
-      CommitWriteAndCheckPageLimit(
-          batch_size, batch_num_spaced_values, null_count, check_page);
-      value_offset += batch_num_spaced_values;
+      commitWriteAndCheckPageLimit(
+          batchSize, batchNumSpacedValues, nullCount, checkPage);
+      valueOffset += batchNumSpacedValues;
 
       // Dictionary size checked separately from data page size since we
-      // circumvent this check when writing ::arrow::DictionaryArray directly
-      CheckDictionarySizeLimit();
+      // circumvent this check when writing ::arrow::DictionaryArray directly.
+      checkDictionarySizeLimit();
     };
-    DoInBatches(
-        def_levels,
-        rep_levels,
-        num_values,
-        properties_->write_batch_size(),
-        WriteChunk,
-        pages_change_on_record_boundaries());
-  }
-
-  Status WriteArrow(
-      const int16_t* def_levels,
-      const int16_t* rep_levels,
-      int64_t num_levels,
-      const ::arrow::Array& leaf_array,
+    doInBatches(
+        defLevels,
+        repLevels,
+        numValues,
+        properties_->writeBatchSize(),
+        writeChunk,
+        pagesChangeOnRecordBoundaries());
+  }
+
+  Status writeArrow(
+      const int16_t* defLevels,
+      const int16_t* repLevels,
+      int64_t numLevels,
+      const ::arrow::Array& leafArray,
       ArrowWriteContext* ctx,
-      bool leaf_field_nullable) override {
+      bool leafFieldNullable) override {
     BEGIN_PARQUET_CATCH_EXCEPTIONS
-    // Leaf nulls are canonical when there is only a single null element after a
-    // list and it is at the leaf.
-    bool single_nullable_element =
-        (level_info_.defLevel == level_info_.repeatedAncestorDefLevel + 1) &&
-        leaf_field_nullable;
-    bool maybe_parent_nulls =
-        level_info_.HasNullableValues() && !single_nullable_element;
-    if (maybe_parent_nulls) {
+    // Leaf nulls are canonical when there is only a single null element after
+    // a list and it is at the leaf.
+    bool singleNullableElement =
+        (levelInfo_.defLevel == levelInfo_.repeatedAncestorDefLevel + 1) &&
+        leafFieldNullable;
+    bool maybeParentNulls =
+        levelInfo_.HasNullableValues() && !singleNullableElement;
+    if (maybeParentNulls) {
       ARROW_ASSIGN_OR_RAISE(
-          bits_buffer_,
+          bitsBuffer_,
           ::arrow::AllocateResizableBuffer(
-              ::arrow::bit_util::BytesForBits(properties_->write_batch_size()),
-              ctx->memory_pool));
-      bits_buffer_->ZeroPadding();
+              ::arrow::bit_util::BytesForBits(properties_->writeBatchSize()),
+              ctx->memoryPool));
+      bitsBuffer_->ZeroPadding();
     }
 
-    if (leaf_array.type()->id() == ::arrow::Type::DICTIONARY) {
-      return WriteArrowDictionary(
-          def_levels,
-          rep_levels,
-          num_levels,
-          leaf_array,
-          ctx,
-          maybe_parent_nulls);
+    if (leafArray.type()->id() == ::arrow::Type::DICTIONARY) {
+      return writeArrowDictionary(
+          defLevels, repLevels, numLevels, leafArray, ctx, maybeParentNulls);
     } else {
-      return WriteArrowDense(
-          def_levels,
-          rep_levels,
-          num_levels,
-          leaf_array,
-          ctx,
-          maybe_parent_nulls);
+      return writeArrowDense(
+          defLevels, repLevels, numLevels, leafArray, ctx, maybeParentNulls);
     }
     END_PARQUET_CATCH_EXCEPTIONS
   }
 
-  int64_t EstimatedBufferedValueBytes() const override {
-    return current_encoder_->EstimatedDataEncodedSize();
+  int64_t estimatedBufferedValueBytes() const override {
+    return currentEncoder_->estimatedDataEncodedSize();
   }
 
  protected:
-  std::shared_ptr<Buffer> GetValuesBuffer() override {
-    return current_encoder_->FlushValues();
+  std::shared_ptr<Buffer> getValuesBuffer() override {
+    return currentEncoder_->flushValues();
   }
 
   // Internal function to handle direct writing of ::arrow::DictionaryArray,
   // since the standard logic concerning dictionary size limits and fallback to
-  // plain encoding is circumvented
-  Status WriteArrowDictionary(
-      const int16_t* def_levels,
-      const int16_t* rep_levels,
-      int64_t num_levels,
+  // plain encoding is circumvented.
+  Status writeArrowDictionary(
+      const int16_t* defLevels,
+      const int16_t* repLevels,
+      int64_t numLevels,
       const ::arrow::Array& array,
       ArrowWriteContext* context,
-      bool maybe_parent_nulls);
+      bool maybeParentNulls);
 
-  Status WriteArrowDense(
-      const int16_t* def_levels,
-      const int16_t* rep_levels,
-      int64_t num_levels,
+  Status writeArrowDense(
+      const int16_t* defLevels,
+      const int16_t* repLevels,
+      int64_t numLevels,
       const ::arrow::Array& array,
       ArrowWriteContext* context,
-      bool maybe_parent_nulls);
+      bool maybeParentNulls);
 
-  void WriteDictionaryPage() override {
-    VELOX_DCHECK(current_dict_encoder_);
-    std::shared_ptr<ResizableBuffer> buffer = AllocateBuffer(
-        properties_->memory_pool(), current_dict_encoder_->dict_encoded_size());
-    current_dict_encoder_->WriteDict(buffer->mutable_data());
+  void writeDictionaryPage() override {
+    VELOX_DCHECK(currentDictEncoder_);
+    std::shared_ptr<ResizableBuffer> buffer = allocateBuffer(
+        properties_->memoryPool(), currentDictEncoder_->dictEncodedSize());
+    currentDictEncoder_->writeDict(buffer->mutable_data());
 
     DictionaryPage page(
         buffer,
-        current_dict_encoder_->num_entries(),
-        properties_->dictionary_page_encoding());
-    total_bytes_written_ += pager_->WriteDictionaryPage(page);
+        currentDictEncoder_->numEntries(),
+        properties_->dictionaryPageEncoding());
+    totalBytesWritten_ += pager_->writeDictionaryPage(page);
   }
 
-  EncodedStatistics GetPageStatistics() override {
+  EncodedStatistics getPageStatistics() override {
     EncodedStatistics result;
-    if (page_statistics_)
-      result = page_statistics_->Encode();
+    if (pageStatistics_)
+      result = pageStatistics_->encode();
     return result;
   }
 
-  EncodedStatistics GetChunkStatistics() override {
+  EncodedStatistics getChunkStatistics() override {
     EncodedStatistics result;
-    if (chunk_statistics_)
-      result = chunk_statistics_->Encode();
+    if (chunkStatistics_)
+      result = chunkStatistics_->encode();
     return result;
   }
 
-  void ResetPageStatistics() override {
-    if (chunk_statistics_ != nullptr) {
-      chunk_statistics_->Merge(*page_statistics_);
-      page_statistics_->Reset();
+  void resetPageStatistics() override {
+    if (chunkStatistics_ != nullptr) {
+      chunkStatistics_->merge(*pageStatistics_);
+      pageStatistics_->reset();
     }
   }
 
   Type::type type() const override {
-    return descr_->physical_type();
+    return descr_->physicalType();
   }
 
   const ColumnDescriptor* descr() const override {
     return descr_;
   }
 
-  int64_t rows_written() const override {
-    return rows_written_;
+  int64_t rowsWritten() const override {
+    return rowsWritten_;
   }
 
-  int64_t total_compressed_bytes() const override {
-    return total_compressed_bytes_;
+  int64_t totalCompressedBytes() const override {
+    return totalCompressedBytes_;
   }
 
-  int64_t total_bytes_written() const override {
-    return total_bytes_written_;
+  int64_t totalBytesWritten() const override {
+    return totalBytesWritten_;
   }
 
-  int64_t total_compressed_bytes_written() const override {
-    return pager_->total_compressed_bytes_written();
+  int64_t totalCompressedBytesWritten() const override {
+    return pager_->totalCompressedBytesWritten();
   }
 
   const WriterProperties* properties() override {
     return properties_;
   }
 
-  bool pages_change_on_record_boundaries() const {
-    return pages_change_on_record_boundaries_;
+  bool pagesChangeOnRecordBoundaries() const {
+    return pagesChangeOnRecordBoundaries_;
   }
 
  private:
   using ValueEncoderType = typename EncodingTraits<DType>::Encoder;
   using TypedStats = TypedStatistics<DType>;
-  std::unique_ptr<Encoder> current_encoder_;
-  // Downcasted observers of current_encoder_.
+  std::unique_ptr<Encoder> currentEncoder_;
+  // Downcasted observers of currentEncoder_.
   // The downcast is performed once as opposed to at every use since
   // dynamic_cast is so expensive, and static_cast is not available due
   // to virtual inheritance.
-  ValueEncoderType* current_value_encoder_;
-  DictEncoder<DType>* current_dict_encoder_;
-  std::shared_ptr<TypedStats> page_statistics_;
-  std::shared_ptr<TypedStats> chunk_statistics_;
-  bool pages_change_on_record_boundaries_;
+  ValueEncoderType* currentValueEncoder_;
+  DictEncoder<DType>* currentDictEncoder_;
+  std::shared_ptr<TypedStats> pageStatistics_;
+  std::shared_ptr<TypedStats> chunkStatistics_;
+  bool pagesChangeOnRecordBoundaries_;
 
   // If writing a sequence of ::arrow::DictionaryArray to the writer, we keep
-  // the dictionary passed to DictEncoder<T>::PutDictionary so we can check
+  // the dictionary passed to DictEncoder<T>::putDictionary so we can check
   // subsequent array chunks to see either if materialization is required (in
-  // which case we call back to the dense write path)
-  std::shared_ptr<::arrow::Array> preserved_dictionary_;
-
-  int64_t WriteLevels(
-      int64_t num_values,
-      const int16_t* def_levels,
-      const int16_t* rep_levels) {
-    int64_t values_to_write = 0;
-    // If the field is required and non-repeated, there are no definition levels
-    if (descr_->max_definition_level() > 0) {
-      for (int64_t i = 0; i < num_values; ++i) {
-        if (def_levels[i] == descr_->max_definition_level()) {
-          ++values_to_write;
+  // which case we call back to the dense write path).
+  std::shared_ptr<::arrow::Array> preservedDictionary_;
+
+  int64_t writeLevels(
+      int64_t numValues,
+      const int16_t* defLevels,
+      const int16_t* repLevels) {
+    int64_t valuesToWrite = 0;
+    // If the field is required and non-repeated, there are no definition
+    // levels.
+    if (descr_->maxDefinitionLevel() > 0) {
+      for (int64_t i = 0; i < numValues; ++i) {
+        if (defLevels[i] == descr_->maxDefinitionLevel()) {
+          ++valuesToWrite;
         }
       }
 
-      WriteDefinitionLevels(num_values, def_levels);
+      writeDefinitionLevels(numValues, defLevels);
     } else {
-      // Required field, write all values
-      values_to_write = num_values;
-    }
-
-    // Not present for non-repeated fields
-    if (descr_->max_repetition_level() > 0) {
-      // A row could include more than one value
-      // Count the occasions where we start a new row
-      for (int64_t i = 0; i < num_values; ++i) {
-        if (rep_levels[i] == 0) {
-          rows_written_++;
-          num_buffered_rows_++;
+      // Required field, write all values.
+      valuesToWrite = numValues;
+    }
+
+    // Not present for non-repeated fields.
+    if (descr_->maxRepetitionLevel() > 0) {
+      // A row could include more than one value.
+      // Count the occasions where we start a new row.
+      for (int64_t i = 0; i < numValues; ++i) {
+        if (repLevels[i] == 0) {
+          rowsWritten_++;
+          numBufferedRows_++;
         }
       }
 
-      WriteRepetitionLevels(num_values, rep_levels);
+      writeRepetitionLevels(numValues, repLevels);
     } else {
-      // Each value is exactly one row
-      rows_written_ += num_values;
-      num_buffered_rows_ += num_values;
+      // Each value is exactly one row.
+      rowsWritten_ += numValues;
+      numBufferedRows_ += numValues;
     }
-    return values_to_write;
+    return valuesToWrite;
   }
 
   // This method will always update the three output parameters,
-  // out_values_to_write, out_spaced_values_to_write and null_count.
+  // outValuesToWrite, outSpacedValuesToWrite and nullCount.
   // Additionally it will update the validity bitmap if required (i.e. if at
   // least one level of nullable structs directly precede the leaf node).
-  void MaybeCalculateValidityBits(
-      const int16_t* def_levels,
-      int64_t batch_size,
-      int64_t* out_values_to_write,
-      int64_t* out_spaced_values_to_write,
-      int64_t* null_count) {
-    if (bits_buffer_ == nullptr) {
-      if (level_info_.defLevel == 0) {
+  void maybeCalculateValidityBits(
+      const int16_t* defLevels,
+      int64_t batchSize,
+      int64_t* outValuesToWrite,
+      int64_t* outSpacedValuesToWrite,
+      int64_t* nullCount) {
+    if (bitsBuffer_ == nullptr) {
+      if (levelInfo_.defLevel == 0) {
         // In this case def levels should be null and we only
         // need to output counts which will always be equal to
-        // the batch size passed in (max def_level == 0 indicates
+        // the batch size passed in (max defLevel == 0 indicates
         // there cannot be repeated or null fields).
-        VELOX_DCHECK_NULL(def_levels);
-        *out_values_to_write = batch_size;
-        *out_spaced_values_to_write = batch_size;
-        *null_count = 0;
+        VELOX_DCHECK_NULL(defLevels);
+        *outValuesToWrite = batchSize;
+        *outSpacedValuesToWrite = batchSize;
+        *nullCount = 0;
       } else {
-        for (int x = 0; x < batch_size; x++) {
-          *out_values_to_write += def_levels[x] == level_info_.defLevel ? 1 : 0;
-          *out_spaced_values_to_write +=
-              def_levels[x] >= level_info_.repeatedAncestorDefLevel ? 1 : 0;
+        for (int x = 0; x < batchSize; x++) {
+          *outValuesToWrite += defLevels[x] == levelInfo_.defLevel ? 1 : 0;
+          *outSpacedValuesToWrite +=
+              defLevels[x] >= levelInfo_.repeatedAncestorDefLevel ? 1 : 0;
         }
-        *null_count = batch_size - *out_values_to_write;
+        *nullCount = batchSize - *outValuesToWrite;
       }
       return;
     }
     // Shrink to fit possible causes another allocation, and would only be
     // necessary on the last batch.
-    int64_t new_bitmap_size = ::arrow::bit_util::BytesForBits(batch_size);
-    if (new_bitmap_size != bits_buffer_->size()) {
-      PARQUET_THROW_NOT_OK(
-          bits_buffer_->Resize(new_bitmap_size, /*shrink_to_fit=*/false));
-      bits_buffer_->ZeroPadding();
+    int64_t newBitmapSize = ::arrow::bit_util::BytesForBits(batchSize);
+    if (newBitmapSize != bitsBuffer_->size()) {
+      PARQUET_THROW_NOT_OK(bitsBuffer_->Resize(newBitmapSize, false));
+      bitsBuffer_->ZeroPadding();
     }
     ValidityBitmapInputOutput io;
-    io.validBits = bits_buffer_->mutable_data();
-    io.valuesReadUpperBound = batch_size;
-    DefLevelsToBitmap(def_levels, batch_size, level_info_, &io);
-    *out_values_to_write = io.valuesRead - io.nullCount;
-    *out_spaced_values_to_write = io.valuesRead;
-    *null_count = io.nullCount;
+    io.validBits = bitsBuffer_->mutable_data();
+    io.valuesReadUpperBound = batchSize;
+    DefLevelsToBitmap(defLevels, batchSize, levelInfo_, &io);
+    *outValuesToWrite = io.valuesRead - io.nullCount;
+    *outSpacedValuesToWrite = io.valuesRead;
+    *nullCount = io.nullCount;
   }
 
-  Result<std::shared_ptr<Array>> MaybeReplaceValidity(
+  Result<std::shared_ptr<Array>> maybeReplaceValidity(
       std::shared_ptr<Array> array,
-      int64_t new_null_count,
-      ::arrow::MemoryPool* memory_pool) {
-    if (bits_buffer_ == nullptr) {
+      int64_t newNullCount,
+      ::arrow::MemoryPool* memoryPool) {
+    if (bitsBuffer_ == nullptr) {
       return array;
     }
     std::vector<std::shared_ptr<Buffer>> buffers = array->data()->buffers;
     if (buffers.empty()) {
       return array;
     }
-    buffers[0] = bits_buffer_;
+    buffers[0] = bitsBuffer_;
     // Should be a leaf array.
     VELOX_DCHECK_GT(buffers.size(), 1);
-    ValueBufferSlicer slicer{memory_pool};
+    ValueBufferSlicer slicer{memoryPool};
     if (array->data()->offset > 0) {
-      RETURN_NOT_OK(util::VisitArrayInline(*array, &slicer, &buffers[1]));
-    }
-    return ::arrow::MakeArray(std::make_shared<ArrayData>(
-        array->type(), array->length(), std::move(buffers), new_null_count));
-  }
-
-  void WriteLevelsSpaced(
-      int64_t num_levels,
-      const int16_t* def_levels,
-      const int16_t* rep_levels) {
-    // If the field is required and non-repeated, there are no definition levels
-    if (descr_->max_definition_level() > 0) {
-      WriteDefinitionLevels(num_levels, def_levels);
-    }
-    // Not present for non-repeated fields
-    if (descr_->max_repetition_level() > 0) {
-      // A row could include more than one value
-      // Count the occasions where we start a new row
-      for (int64_t i = 0; i < num_levels; ++i) {
-        if (rep_levels[i] == 0) {
-          rows_written_++;
-          num_buffered_rows_++;
+      RETURN_NOT_OK(util::visitArrayInline(*array, &slicer, &buffers[1]));
+    }
+    return ::arrow::MakeArray(
+        std::make_shared<ArrayData>(
+            array->type(), array->length(), std::move(buffers), newNullCount));
+  }
+
+  void writeLevelsSpaced(
+      int64_t numLevels,
+      const int16_t* defLevels,
+      const int16_t* repLevels) {
+    // If the field is required and non-repeated, there are no definition
+    // levels.
+    if (descr_->maxDefinitionLevel() > 0) {
+      writeDefinitionLevels(numLevels, defLevels);
+    }
+    // Not present for non-repeated fields.
+    if (descr_->maxRepetitionLevel() > 0) {
+      // A row could include more than one value.
+      // Count the occasions where we start a new row.
+      for (int64_t i = 0; i < numLevels; ++i) {
+        if (repLevels[i] == 0) {
+          rowsWritten_++;
+          numBufferedRows_++;
         }
       }
-      WriteRepetitionLevels(num_levels, rep_levels);
+      writeRepetitionLevels(numLevels, repLevels);
     } else {
-      // Each value is exactly one row
-      rows_written_ += num_levels;
-      num_buffered_rows_ += num_levels;
+      // Each value is exactly one row.
+      rowsWritten_ += numLevels;
+      numBufferedRows_ += numLevels;
     }
   }
 
-  void CommitWriteAndCheckPageLimit(
-      int64_t num_levels,
-      int64_t num_values,
-      int64_t num_nulls,
-      bool check_page_size) {
-    num_buffered_values_ += num_levels;
-    num_buffered_encoded_values_ += num_values;
-    num_buffered_nulls_ += num_nulls;
+  void commitWriteAndCheckPageLimit(
+      int64_t numLevels,
+      int64_t numValues,
+      int64_t numNulls,
+      bool checkPageSize) {
+    numBufferedValues_ += numLevels;
+    numBufferedEncodedValues_ += numValues;
+    numBufferedNulls_ += numNulls;
 
-    if (check_page_size &&
-        current_encoder_->EstimatedDataEncodedSize() >=
-            properties_->data_pagesize()) {
-      AddDataPage();
+    if (checkPageSize &&
+        currentEncoder_->estimatedDataEncodedSize() >=
+            properties_->dataPagesize()) {
+      addDataPage();
     }
   }
 
-  void FallbackToPlainEncoding() {
-    if (IsDictionaryEncoding(current_encoder_->encoding())) {
-      WriteDictionaryPage();
-      // Serialize the buffered Dictionary Indices
-      FlushBufferedDataPages();
+  void fallbackToPlainEncoding() {
+    if (isDictionaryEncoding(currentEncoder_->encoding())) {
+      writeDictionaryPage();
+      // Serialize the buffered dictionary indices.
+      flushBufferedDataPages();
       fallback_ = true;
-      // Only PLAIN encoding is supported for fallback in V1
-      current_encoder_ = MakeEncoder(
-          DType::type_num,
-          Encoding::PLAIN,
+      // Only PLAIN encoding is supported for fallback in V1.
+      currentEncoder_ = makeEncoder(
+          DType::typeNum,
+          Encoding::kPlain,
           false,
           descr_,
-          properties_->memory_pool());
-      current_value_encoder_ =
-          dynamic_cast<ValueEncoderType*>(current_encoder_.get());
-      current_dict_encoder_ = nullptr; // not using dict
-      encoding_ = Encoding::PLAIN;
+          properties_->memoryPool());
+      currentValueEncoder_ =
+          dynamic_cast<ValueEncoderType*>(currentEncoder_.get());
+      currentDictEncoder_ = nullptr; // not using dict
+      encoding_ = Encoding::kPlain;
     }
   }
 
-  // Checks if the Dictionary Page size limit is reached
-  // If the limit is reached, the Dictionary and Data Pages are serialized
-  // The encoding is switched to PLAIN
+  // Checks if the Dictionary Page size limit is reached.
+  // If the limit is reached, the Dictionary and Data Pages are serialized.
+  // The encoding is switched to PLAIN.
   //
   // Only one Dictionary Page is written.
   // Fallback to PLAIN if dictionary page limit is reached.
-  void CheckDictionarySizeLimit() {
-    if (!has_dictionary_ || fallback_) {
+  void checkDictionarySizeLimit() {
+    if (!hasDictionary_ || fallback_) {
       // Either not using dictionary encoding, or we have already fallen back
-      // to PLAIN encoding because the size threshold was reached
+      // to PLAIN encoding because the size threshold was reached.
       return;
     }
 
-    if (current_dict_encoder_->dict_encoded_size() >=
-        properties_->dictionary_pagesize_limit()) {
-      FallbackToPlainEncoding();
+    if (currentDictEncoder_->dictEncodedSize() >=
+        properties_->dictionaryPagesizeLimit()) {
+      fallbackToPlainEncoding();
     }
   }
 
-  void WriteValues(const T* values, int64_t num_values, int64_t num_nulls) {
-    current_value_encoder_->Put(values, static_cast<int>(num_values));
-    if (page_statistics_ != nullptr) {
-      page_statistics_->Update(values, num_values, num_nulls);
+  void writeValues(const T* values, int64_t numValues, int64_t numNulls) {
+    currentValueEncoder_->put(values, static_cast<int>(numValues));
+    if (pageStatistics_ != nullptr) {
+      pageStatistics_->update(values, numValues, numNulls);
     }
   }
 
   /// \brief Write values with spaces and update page statistics accordingly.
   ///
-  /// \param values input buffer of values to write, including spaces.
-  /// \param num_values number of non-null values in the values buffer.
-  /// \param num_spaced_values length of values buffer, including spaces and
-  /// does not
-  ///   count some nulls from ancestor (e.g. empty lists).
-  /// \param valid_bits validity bitmap of values buffer, which does not include
-  /// some
-  ///   nulls from ancestor (e.g. empty lists).
-  /// \param valid_bits_offset offset to valid_bits bitmap.
-  /// \param num_levels number of levels to write, including nulls from values
-  /// buffer
-  ///   and nulls from ancestor (e.g. empty lists).
-  /// \param num_nulls number of nulls in the values buffer as well as nulls
-  /// from the
-  ///   ancestor (e.g. empty lists).
-  void WriteValuesSpaced(
+  /// @param values input buffer of values to write, including spaces.
+  /// @param numValues number of non-null values in the values buffer.
+  /// @param numSpacedValues length of values buffer, including spaces and
+  /// does not count some nulls from ancestor (e.g. empty lists).
+  /// @param validBits validity bitmap of values buffer, which does not
+  /// include some nulls from ancestor (e.g. empty lists).
+  /// @param validBitsOffset offset to validBits bitmap.
+  /// @param numLevels number of levels to write, including nulls from values
+  /// buffer and nulls from ancestor (e.g. empty lists).
+  /// @param numNulls number of nulls in the values buffer as well as nulls
+  /// from the ancestor (e.g. empty lists).
+  void writeValuesSpaced(
       const T* values,
-      int64_t num_values,
-      int64_t num_spaced_values,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      int64_t num_levels,
-      int64_t num_nulls) {
-    if (num_values != num_spaced_values) {
-      current_value_encoder_->PutSpaced(
+      int64_t numValues,
+      int64_t numSpacedValues,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      int64_t numLevels,
+      int64_t numNulls) {
+    if (numValues != numSpacedValues) {
+      currentValueEncoder_->putSpaced(
           values,
-          static_cast<int>(num_spaced_values),
-          valid_bits,
-          valid_bits_offset);
+          static_cast<int>(numSpacedValues),
+          validBits,
+          validBitsOffset);
     } else {
-      current_value_encoder_->Put(values, static_cast<int>(num_values));
+      currentValueEncoder_->put(values, static_cast<int>(numValues));
     }
-    if (page_statistics_ != nullptr) {
-      page_statistics_->UpdateSpaced(
+    if (pageStatistics_ != nullptr) {
+      pageStatistics_->updateSpaced(
           values,
-          valid_bits,
-          valid_bits_offset,
-          num_spaced_values,
-          num_values,
-          num_nulls);
+          validBits,
+          validBitsOffset,
+          numSpacedValues,
+          numValues,
+          numNulls);
     }
   }
 };
 
 template <typename DType>
-Status TypedColumnWriterImpl<DType>::WriteArrowDictionary(
-    const int16_t* def_levels,
-    const int16_t* rep_levels,
-    int64_t num_levels,
+Status TypedColumnWriterImpl<DType>::writeArrowDictionary(
+    const int16_t* defLevels,
+    const int16_t* repLevels,
+    int64_t numLevels,
     const ::arrow::Array& array,
     ArrowWriteContext* ctx,
-    bool maybe_parent_nulls) {
+    bool maybeParentNulls) {
   // If this is the first time writing a DictionaryArray, then there's
   // a few possible paths to take:
   //
-  // - If dictionary encoding is not enabled, convert to densely
-  //   encoded and call WriteArrow
-  // - Dictionary encoding enabled
+  // - If dictionary encoding is not enabled, convert to densely.
+  //   Encoded and call WriteArrow.
+  // - Dictionary encoding enabled.
   //   - If this is the first time this is called, then we call
-  //     PutDictionary into the encoder and then PutIndices on each
+  //     putDictionary into the encoder and then putIndices on each
   //     chunk. We store the dictionary that was written in
-  //     preserved_dictionary_ so that subsequent calls to this method
-  //     can make sure the dictionary has not changed
+  //     preservedDictionary_ so that subsequent calls to this method
+  //     can make sure the dictionary has not changed.
   //   - On subsequent calls, we have to check whether the dictionary
   //     has changed. If it has, then we trigger the varying
   //     dictionary path and materialize each chunk and then call
-  //     WriteArrow with that
-  auto WriteDense = [&] {
-    std::shared_ptr<::arrow::Array> dense_array;
-    RETURN_NOT_OK(ConvertDictionaryToDense(
-        array, properties_->memory_pool(), &dense_array));
-    return WriteArrowDense(
-        def_levels,
-        rep_levels,
-        num_levels,
-        *dense_array,
-        ctx,
-        maybe_parent_nulls);
+  //     writeArrow with that.
+  auto writeDense = [&] {
+    std::shared_ptr<::arrow::Array> denseArray;
+    RETURN_NOT_OK(convertDictionaryToDense(
+        array, properties_->memoryPool(), &denseArray));
+    return writeArrowDense(
+        defLevels, repLevels, numLevels, *denseArray, ctx, maybeParentNulls);
   };
 
-  if (!IsDictionaryEncoding(current_encoder_->encoding()) ||
-      !DictionaryDirectWriteSupported(array)) {
+  if (!isDictionaryEncoding(currentEncoder_->encoding()) ||
+      !dictionaryDirectWriteSupported(array)) {
     // No longer dictionary-encoding for whatever reason, maybe we never were
-    // or we decided to stop. Note that WriteArrow can be invoked multiple
+    // or we decided to stop. Note that writeArrow can be invoked multiple
     // times with both dense and dictionary-encoded versions of the same data
     // without a problem. Any dense data will be hashed to indices until the
     // dictionary page limit is reached, at which everything (dictionary and
-    // dense) will fall back to plain encoding
-    return WriteDense();
+    // dense) will fall back to plain encoding.
+    return writeDense();
   }
 
-  auto dict_encoder = dynamic_cast<DictEncoder<DType>*>(current_encoder_.get());
+  auto dictEncoder = dynamic_cast<DictEncoder<DType>*>(currentEncoder_.get());
   const auto& data = checked_cast<const ::arrow::DictionaryArray&>(array);
   std::shared_ptr<::arrow::Array> dictionary = data.dictionary();
   std::shared_ptr<::arrow::Array> indices = data.indices();
 
-  auto update_stats = [&](int64_t num_chunk_levels,
-                          const std::shared_ptr<Array>& chunk_indices) {
-    // TODO(PARQUET-2068) This approach may make two copies.  First, a copy of
+  auto updateStats = [&](int64_t numChunkLevels,
+                         const std::shared_ptr<Array>& chunkIndices) {
+    // TODO(PARQUET-2068) This approach may make two copies. First, a copy of
     // the indices array to a (hopefully smaller) referenced indices array.
-    // Second, a copy of the values array to a (probably not smaller) referenced
-    // values array.
+    // Second, a copy of the values array to a (probably not smaller)
+    // referenced values array.
     //
-    // Once the MinMax kernel supports all data types we should use that kernel
-    // instead as it does not make any copies.
-    ::arrow::compute::ExecContext exec_ctx(ctx->memory_pool);
-    exec_ctx.set_use_threads(false);
+    // Once the MinMax kernel supports all data types we should use that kernel.
+    // Instead as it does not make any copies.
+    ::arrow::compute::ExecContext execCtx(ctx->memoryPool);
+    execCtx.set_use_threads(false);
 
-    std::shared_ptr<::arrow::Array> referenced_dictionary;
+    std::shared_ptr<::arrow::Array> referencedDictionary;
     PARQUET_ASSIGN_OR_THROW(
-        ::arrow::Datum referenced_indices,
-        ::arrow::compute::Unique(*chunk_indices, &exec_ctx));
+        ::arrow::Datum referencedIndices,
+        ::arrow::compute::Unique(*chunkIndices, &execCtx));
 
-    // On first run, we might be able to re-use the existing dictionary
-    if (referenced_indices.length() == dictionary->length()) {
-      referenced_dictionary = dictionary;
+    // On first run, we might be able to re-use the existing dictionary.
+    if (referencedIndices.length() == dictionary->length()) {
+      referencedDictionary = dictionary;
     } else {
       PARQUET_ASSIGN_OR_THROW(
-          ::arrow::Datum referenced_dictionary_datum,
+          ::arrow::Datum referencedDictionaryDatum,
           ::arrow::compute::Take(
               dictionary,
-              referenced_indices,
-              ::arrow::compute::TakeOptions(/*boundscheck=*/false),
-              &exec_ctx));
-      referenced_dictionary = referenced_dictionary_datum.make_array();
+              referencedIndices,
+              ::arrow::compute::TakeOptions::NoBoundsCheck(),
+              &execCtx));
+      referencedDictionary = referencedDictionaryDatum.make_array();
     }
 
-    int64_t non_null_count =
-        chunk_indices->length() - chunk_indices->null_count();
-    page_statistics_->IncrementNullCount(num_chunk_levels - non_null_count);
-    page_statistics_->IncrementNumValues(non_null_count);
-    page_statistics_->Update(*referenced_dictionary, /*update_counts=*/false);
-  };
-
-  int64_t value_offset = 0;
-  auto WriteIndicesChunk = [&](int64_t offset,
-                               int64_t batch_size,
-                               bool check_page) {
-    int64_t batch_num_values = 0;
-    int64_t batch_num_spaced_values = 0;
-    int64_t null_count = ::arrow::kUnknownNullCount;
-    // Bits is not null for nullable values.  At this point in the code we can't
-    // determine if the leaf array has the same null values as any parents it
-    // might have had so we need to recompute it from def levels.
-    MaybeCalculateValidityBits(
-        AddIfNotNull(def_levels, offset),
-        batch_size,
-        &batch_num_values,
-        &batch_num_spaced_values,
-        &null_count);
-    WriteLevelsSpaced(
-        batch_size,
-        AddIfNotNull(def_levels, offset),
-        AddIfNotNull(rep_levels, offset));
-    std::shared_ptr<Array> writeable_indices =
-        indices->Slice(value_offset, batch_num_spaced_values);
-    if (page_statistics_) {
-      update_stats(/*num_chunk_levels=*/batch_size, writeable_indices);
-    }
-    PARQUET_ASSIGN_OR_THROW(
-        writeable_indices,
-        MaybeReplaceValidity(writeable_indices, null_count, ctx->memory_pool));
-    dict_encoder->PutIndices(*writeable_indices);
-    CommitWriteAndCheckPageLimit(
-        batch_size, batch_num_values, null_count, check_page);
-    value_offset += batch_num_spaced_values;
+    int64_t nonNullCount = chunkIndices->length() - chunkIndices->null_count();
+    pageStatistics_->incrementNullCount(numChunkLevels - nonNullCount);
+    pageStatistics_->incrementNumValues(nonNullCount);
+    pageStatistics_->update(*referencedDictionary, false);
   };
 
-  // Handle seeing dictionary for the first time
-  if (!preserved_dictionary_) {
-    // It's a new dictionary. Call PutDictionary and keep track of it
-    PARQUET_CATCH_NOT_OK(dict_encoder->PutDictionary(*dictionary));
-
-    // If there were duplicate value in the dictionary, the encoder's memo table
-    // will be out of sync with the indices in the Arrow array.
-    // The easiest solution for this uncommon case is to fallback to plain
+  int64_t valueOffset = 0;
+  auto writeIndicesChunk =
+      [&](int64_t offset, int64_t batchSize, bool checkPage) {
+        int64_t batchNumValues = 0;
+        int64_t batchNumSpacedValues = 0;
+        int64_t nullCount = ::arrow::kUnknownNullCount;
+        // Bits is not null for nullable values.  At this point in the code we
+        // can't. Determine if the leaf array has the same null values as any
+        // parents it. Might have had so we need to recompute it from def
+        // levels.
+        maybeCalculateValidityBits(
+            addIfNotNull(defLevels, offset),
+            batchSize,
+            &batchNumValues,
+            &batchNumSpacedValues,
+            &nullCount);
+        writeLevelsSpaced(
+            batchSize,
+            addIfNotNull(defLevels, offset),
+            addIfNotNull(repLevels, offset));
+        std::shared_ptr<Array> writeableIndices =
+            indices->Slice(valueOffset, batchNumSpacedValues);
+        if (pageStatistics_) {
+          updateStats(batchSize, writeableIndices);
+        }
+        PARQUET_ASSIGN_OR_THROW(
+            writeableIndices,
+            maybeReplaceValidity(writeableIndices, nullCount, ctx->memoryPool));
+        dictEncoder->putIndices(*writeableIndices);
+        commitWriteAndCheckPageLimit(
+            batchSize, batchNumValues, nullCount, checkPage);
+        valueOffset += batchNumSpacedValues;
+      };
+
+  // Handle seeing dictionary for the first time.
+  if (!preservedDictionary_) {
+    // It's a new dictionary. Call PutDictionary and keep track of it.
+    PARQUET_CATCH_NOT_OK(dictEncoder->putDictionary(*dictionary));
+
+    // If there were duplicate value in the dictionary, the encoder's memo
+    // table will be out of sync with the indices in the Arrow array. The
+    // easiest solution for this uncommon case is to fallback to plain
     // encoding.
-    if (dict_encoder->num_entries() != dictionary->length()) {
-      PARQUET_CATCH_NOT_OK(FallbackToPlainEncoding());
-      return WriteDense();
+    if (dictEncoder->numEntries() != dictionary->length()) {
+      PARQUET_CATCH_NOT_OK(fallbackToPlainEncoding());
+      return writeDense();
     }
 
-    preserved_dictionary_ = dictionary;
-  } else if (!dictionary->Equals(*preserved_dictionary_)) {
-    // Dictionary has changed
-    PARQUET_CATCH_NOT_OK(FallbackToPlainEncoding());
-    return WriteDense();
+    preservedDictionary_ = dictionary;
+  } else if (!dictionary->Equals(*preservedDictionary_)) {
+    // Dictionary has changed.
+    PARQUET_CATCH_NOT_OK(fallbackToPlainEncoding());
+    return writeDense();
   }
 
-  PARQUET_CATCH_NOT_OK(DoInBatches(
-      def_levels,
-      rep_levels,
-      num_levels,
-      properties_->write_batch_size(),
-      WriteIndicesChunk,
-      pages_change_on_record_boundaries()));
+  PARQUET_CATCH_NOT_OK(doInBatches(
+      defLevels,
+      repLevels,
+      numLevels,
+      properties_->writeBatchSize(),
+      writeIndicesChunk,
+      pagesChangeOnRecordBoundaries()));
   return Status::OK();
 }
 
-// ----------------------------------------------------------------------
-// Direct Arrow write path
+// ----------------------------------------------------------------------.
+// Direct Arrow write path.
 
 template <typename ParquetType, typename ArrowType, typename Enable = void>
 struct SerializeFunctor {
   using ArrowCType = typename ArrowType::c_type;
   using ArrayType = typename ::arrow::TypeTraits<ArrowType>::ArrayType;
-  using ParquetCType = typename ParquetType::c_type;
+  using ParquetCType = typename ParquetType::CType;
   Status
-  Serialize(const ArrayType& array, ArrowWriteContext*, ParquetCType* out) {
+  serialize(const ArrayType& array, ArrowWriteContext*, ParquetCType* out) {
     const ArrowCType* input = array.raw_values();
     if (array.null_count() > 0) {
       for (int i = 0; i < array.length(); i++) {
@@ -2183,34 +2151,34 @@ struct SerializeFunctor {
 };
 
 template <typename ParquetType, typename ArrowType>
-Status WriteArrowSerialize(
+Status writeArrowSerialize(
     const ::arrow::Array& array,
-    int64_t num_levels,
-    const int16_t* def_levels,
-    const int16_t* rep_levels,
+    int64_t numLevels,
+    const int16_t* defLevels,
+    const int16_t* repLevels,
     ArrowWriteContext* ctx,
     TypedColumnWriter<ParquetType>* writer,
-    bool maybe_parent_nulls) {
-  using ParquetCType = typename ParquetType::c_type;
+    bool maybeParentNulls) {
+  using ParquetCType = typename ParquetType::CType;
   using ArrayType = typename ::arrow::TypeTraits<ArrowType>::ArrayType;
 
   ParquetCType* buffer = nullptr;
   PARQUET_THROW_NOT_OK(
-      ctx->GetScratchData<ParquetCType>(array.length(), &buffer));
+      ctx->getScratchData<ParquetCType>(array.length(), &buffer));
 
   SerializeFunctor<ParquetType, ArrowType> functor;
   RETURN_NOT_OK(
-      functor.Serialize(checked_cast<const ArrayType&>(array), ctx, buffer));
-  bool no_nulls = writer->descr()->schema_node()->is_required() ||
-      (array.null_count() == 0);
-  if (!maybe_parent_nulls && no_nulls) {
+      functor.serialize(checked_cast<const ArrayType&>(array), ctx, buffer));
+  bool noNulls =
+      writer->descr()->schemaNode()->isRequired() || (array.null_count() == 0);
+  if (!maybeParentNulls && noNulls) {
     PARQUET_CATCH_NOT_OK(
-        writer->WriteBatch(num_levels, def_levels, rep_levels, buffer));
+        writer->writeBatch(numLevels, defLevels, repLevels, buffer));
   } else {
-    PARQUET_CATCH_NOT_OK(writer->WriteBatchSpaced(
-        num_levels,
-        def_levels,
-        rep_levels,
+    PARQUET_CATCH_NOT_OK(writer->writeBatchSpaced(
+        numLevels,
+        defLevels,
+        repLevels,
         array.null_bitmap_data(),
         array.offset(),
         buffer));
@@ -2219,34 +2187,34 @@ Status WriteArrowSerialize(
 }
 
 template <typename ParquetType>
-Status WriteArrowZeroCopy(
+Status writeArrowZeroCopy(
     const ::arrow::Array& array,
-    int64_t num_levels,
-    const int16_t* def_levels,
-    const int16_t* rep_levels,
+    int64_t numLevels,
+    const int16_t* defLevels,
+    const int16_t* repLevels,
     ArrowWriteContext* ctx,
     TypedColumnWriter<ParquetType>* writer,
-    bool maybe_parent_nulls) {
-  using T = typename ParquetType::c_type;
+    bool maybeParentNulls) {
+  using T = typename ParquetType::CType;
   const auto& data = static_cast<const ::arrow::PrimitiveArray&>(array);
   const T* values = nullptr;
-  // The values buffer may be null if the array is empty (ARROW-2744)
+  // The values buffer may be null if the array is empty (ARROW-2744).
   if (data.values() != nullptr) {
     values = reinterpret_cast<const T*>(data.values()->data()) + data.offset();
   } else {
     VELOX_DCHECK_EQ(data.length(), 0);
   }
-  bool no_nulls = writer->descr()->schema_node()->is_required() ||
-      (array.null_count() == 0);
+  bool noNulls =
+      writer->descr()->schemaNode()->isRequired() || (array.null_count() == 0);
 
-  if (!maybe_parent_nulls && no_nulls) {
+  if (!maybeParentNulls && noNulls) {
     PARQUET_CATCH_NOT_OK(
-        writer->WriteBatch(num_levels, def_levels, rep_levels, values));
+        writer->writeBatch(numLevels, defLevels, repLevels, values));
   } else {
-    PARQUET_CATCH_NOT_OK(writer->WriteBatchSpaced(
-        num_levels,
-        def_levels,
-        rep_levels,
+    PARQUET_CATCH_NOT_OK(writer->writeBatchSpaced(
+        numLevels,
+        defLevels,
+        repLevels,
         data.null_bitmap_data(),
         data.offset(),
         values));
@@ -2254,41 +2222,29 @@ Status WriteArrowZeroCopy(
   return Status::OK();
 }
 
-#define WRITE_SERIALIZE_CASE(ArrowEnum, ArrowType, ParquetType)  \
-  case ::arrow::Type::ArrowEnum:                                 \
-    return WriteArrowSerialize<ParquetType, ::arrow::ArrowType>( \
-        array,                                                   \
-        num_levels,                                              \
-        def_levels,                                              \
-        rep_levels,                                              \
-        ctx,                                                     \
-        this,                                                    \
-        maybe_parent_nulls);
-
-#define WRITE_ZERO_COPY_CASE(ArrowEnum, ArrowType, ParquetType) \
-  case ::arrow::Type::ArrowEnum:                                \
-    return WriteArrowZeroCopy<ParquetType>(                     \
-        array,                                                  \
-        num_levels,                                             \
-        def_levels,                                             \
-        rep_levels,                                             \
-        ctx,                                                    \
-        this,                                                   \
-        maybe_parent_nulls);
+#define WRITE_SERIALIZE_CASE(Arrowenum, ArrowType, ParquetType)  \
+  case ::arrow::Type::Arrowenum:                                 \
+    return writeArrowSerialize<ParquetType, ::arrow::ArrowType>( \
+        array, numLevels, defLevels, repLevels, ctx, this, maybeParentNulls);
+
+#define WRITE_ZERO_COPY_CASE(Arrowenum, ArrowType, ParquetType) \
+  case ::arrow::Type::Arrowenum:                                \
+    return writeArrowZeroCopy<ParquetType>(                     \
+        array, numLevels, defLevels, repLevels, ctx, this, maybeParentNulls);
 
 #define ARROW_UNSUPPORTED()                                          \
   std::stringstream ss;                                              \
   ss << "Arrow type " << array.type()->ToString()                    \
-     << " cannot be written to Parquet type " << descr_->ToString(); \
+     << " cannot be written to Parquet type " << descr_->toString(); \
   return Status::Invalid(ss.str());
 
-// ----------------------------------------------------------------------
-// Write Arrow to BooleanType
+// ----------------------------------------------------------------------.
+// Write Arrow to BooleanType.
 
 template <>
 struct SerializeFunctor<BooleanType, ::arrow::BooleanType> {
   Status
-  Serialize(const ::arrow::BooleanArray& data, ArrowWriteContext*, bool* out) {
+  serialize(const ::arrow::BooleanArray& data, ArrowWriteContext*, bool* out) {
     for (int i = 0; i < data.length(); i++) {
       *out++ = data.Value(i);
     }
@@ -2297,26 +2253,26 @@ struct SerializeFunctor<BooleanType, ::arrow::BooleanType> {
 };
 
 template <>
-Status TypedColumnWriterImpl<BooleanType>::WriteArrowDense(
-    const int16_t* def_levels,
-    const int16_t* rep_levels,
-    int64_t num_levels,
+Status TypedColumnWriterImpl<BooleanType>::writeArrowDense(
+    const int16_t* defLevels,
+    const int16_t* repLevels,
+    int64_t numLevels,
     const ::arrow::Array& array,
     ArrowWriteContext* ctx,
-    bool maybe_parent_nulls) {
+    bool maybeParentNulls) {
   if (array.type_id() != ::arrow::Type::BOOL) {
     ARROW_UNSUPPORTED();
   }
-  return WriteArrowSerialize<BooleanType, ::arrow::BooleanType>(
-      array, num_levels, def_levels, rep_levels, ctx, this, maybe_parent_nulls);
+  return writeArrowSerialize<BooleanType, ::arrow::BooleanType>(
+      array, numLevels, defLevels, repLevels, ctx, this, maybeParentNulls);
 }
 
-// ----------------------------------------------------------------------
-// Write Arrow types to INT32
+// ----------------------------------------------------------------------.
+// Write Arrow types to INT32.
 
 template <>
 struct SerializeFunctor<Int32Type, ::arrow::Date64Type> {
-  Status Serialize(
+  Status serialize(
       const ::arrow::Date64Array& array,
       ArrowWriteContext*,
       int32_t* out) {
@@ -2335,20 +2291,20 @@ struct SerializeFunctor<
     ::arrow::enable_if_t<
         ::arrow::is_decimal_type<ArrowType>::value&& ::arrow::internal::
             IsOneOf<ParquetType, Int32Type, Int64Type>::value>> {
-  using value_type = typename ParquetType::c_type;
+  using ValueType = typename ParquetType::CType;
 
-  Status Serialize(
+  Status serialize(
       const typename ::arrow::TypeTraits<ArrowType>::ArrayType& array,
       ArrowWriteContext* ctx,
-      value_type* out) {
+      ValueType* out) {
     if (array.null_count() == 0) {
       for (int64_t i = 0; i < array.length(); i++) {
-        out[i] = TransferValue<ArrowType::kByteWidth>(array.Value(i));
+        out[i] = transferValue<ArrowType::kByteWidth>(array.Value(i));
       }
     } else {
       for (int64_t i = 0; i < array.length(); i++) {
         out[i] = array.IsValid(i)
-            ? TransferValue<ArrowType::kByteWidth>(array.Value(i))
+            ? transferValue<ArrowType::kByteWidth>(array.Value(i))
             : 0;
       }
     }
@@ -2356,20 +2312,20 @@ struct SerializeFunctor<
     return Status::OK();
   }
 
-  template <int byte_width>
-  value_type TransferValue(const uint8_t* in) const {
+  template <int byteWidth>
+  ValueType transferValue(const uint8_t* in) const {
     static_assert(
-        byte_width == 16 || byte_width == 32,
+        byteWidth == 16 || byteWidth == 32,
         "only 16 and 32 byte Decimals supported");
-    value_type value = 0;
-    if constexpr (byte_width == 16) {
-      ::arrow::Decimal128 decimal_value(in);
-      PARQUET_THROW_NOT_OK(decimal_value.ToInteger(&value));
+    ValueType value = 0;
+    if constexpr (byteWidth == 16) {
+      ::arrow::Decimal128 decimalValue(in);
+      PARQUET_ASSIGN_OR_THROW(value, decimalValue.ToInteger<ValueType>());
     } else {
-      ::arrow::Decimal256 decimal_value(in);
+      ::arrow::Decimal256 decimalValue(in);
       // Decimal256 does not provide ToInteger, but we are sure it fits in the
       // target integer type.
-      value = static_cast<value_type>(decimal_value.low_bits());
+      value = static_cast<ValueType>(decimalValue.low_bits());
     }
     return value;
   }
@@ -2377,7 +2333,7 @@ struct SerializeFunctor<
 
 template <>
 struct SerializeFunctor<Int32Type, ::arrow::Time32Type> {
-  Status Serialize(
+  Status serialize(
       const ::arrow::Time32Array& array,
       ArrowWriteContext*,
       int32_t* out) {
@@ -2395,17 +2351,17 @@ struct SerializeFunctor<Int32Type, ::arrow::Time32Type> {
 };
 
 template <>
-Status TypedColumnWriterImpl<Int32Type>::WriteArrowDense(
-    const int16_t* def_levels,
-    const int16_t* rep_levels,
-    int64_t num_levels,
+Status TypedColumnWriterImpl<Int32Type>::writeArrowDense(
+    const int16_t* defLevels,
+    const int16_t* repLevels,
+    int64_t numLevels,
     const ::arrow::Array& array,
     ArrowWriteContext* ctx,
-    bool maybe_parent_nulls) {
+    bool maybeParentNulls) {
   switch (array.type()->id()) {
     case ::arrow::Type::NA: {
       PARQUET_CATCH_NOT_OK(
-          WriteBatch(num_levels, def_levels, rep_levels, nullptr));
+          writeBatch(numLevels, defLevels, repLevels, nullptr));
     } break;
       WRITE_SERIALIZE_CASE(INT8, Int8Type, Int32Type)
       WRITE_SERIALIZE_CASE(UINT8, UInt8Type, Int32Type)
@@ -2424,16 +2380,16 @@ Status TypedColumnWriterImpl<Int32Type>::WriteArrowDense(
   return Status::OK();
 }
 
-// ----------------------------------------------------------------------
-// Write Arrow to Int64 and Int96
+// ----------------------------------------------------------------------.
+// Write Arrow to Int64 and Int96.
 
-#define INT96_CONVERT_LOOP(ConversionFunction) \
+#define INT96_CONVERT_LOOP(conversionFunction) \
   for (int64_t i = 0; i < array.length(); i++) \
-    ConversionFunction(input[i], &out[i]);
+    conversionFunction(input[i], &out[i]);
 
 template <>
 struct SerializeFunctor<Int96Type, ::arrow::TimestampType> {
-  Status Serialize(
+  Status serialize(
       const ::arrow::TimestampArray& array,
       ArrowWriteContext*,
       Int96* out) {
@@ -2442,16 +2398,16 @@ struct SerializeFunctor<Int96Type, ::arrow::TimestampType> {
         static_cast<const ::arrow::TimestampType&>(*array.type());
     switch (type.unit()) {
       case ::arrow::TimeUnit::NANO:
-        INT96_CONVERT_LOOP(internal::NanosecondsToImpalaTimestamp);
+        INT96_CONVERT_LOOP(internal::nanosecondsToImpalaTimestamp);
         break;
       case ::arrow::TimeUnit::MICRO:
-        INT96_CONVERT_LOOP(internal::MicrosecondsToImpalaTimestamp);
+        INT96_CONVERT_LOOP(internal::microsecondsToImpalaTimestamp);
         break;
       case ::arrow::TimeUnit::MILLI:
-        INT96_CONVERT_LOOP(internal::MillisecondsToImpalaTimestamp);
+        INT96_CONVERT_LOOP(internal::millisecondsToImpalaTimestamp);
         break;
       case ::arrow::TimeUnit::SECOND:
-        INT96_CONVERT_LOOP(internal::SecondsToImpalaTimestamp);
+        INT96_CONVERT_LOOP(internal::secondsToImpalaTimestamp);
         break;
     }
     return Status::OK();
@@ -2463,22 +2419,22 @@ struct SerializeFunctor<Int96Type, ::arrow::TimestampType> {
 #define COERCE_MULTIPLY +1
 
 static std::pair<int, int64_t> kTimestampCoercionFactors[4][4] = {
-    // from seconds ...
+    // From seconds ...
     {{COERCE_INVALID, 0}, // ... to seconds
      {COERCE_MULTIPLY, 1000}, // ... to millis
      {COERCE_MULTIPLY, 1000000}, // ... to micros
      {COERCE_MULTIPLY, INT64_C(1000000000)}}, // ... to nanos
-    // from millis ...
+    // From millis ...
     {{COERCE_INVALID, 0},
      {COERCE_MULTIPLY, 1},
      {COERCE_MULTIPLY, 1000},
      {COERCE_MULTIPLY, 1000000}},
-    // from micros ...
+    // From micros ...
     {{COERCE_INVALID, 0},
      {COERCE_DIVIDE, 1000},
      {COERCE_MULTIPLY, 1},
      {COERCE_MULTIPLY, 1000}},
-    // from nanos ...
+    // From nanos ...
     {{COERCE_INVALID, 0},
      {COERCE_DIVIDE, 1000000},
      {COERCE_DIVIDE, 1000},
@@ -2486,29 +2442,29 @@ static std::pair<int, int64_t> kTimestampCoercionFactors[4][4] = {
 
 template <>
 struct SerializeFunctor<Int64Type, ::arrow::TimestampType> {
-  Status Serialize(
+  Status serialize(
       const ::arrow::TimestampArray& array,
       ArrowWriteContext* ctx,
       int64_t* out) {
-    const auto& source_type =
+    const auto& sourceType =
         static_cast<const ::arrow::TimestampType&>(*array.type());
-    auto source_unit = source_type.unit();
+    auto sourceUnit = sourceType.unit();
     const int64_t* values = array.raw_values();
 
-    ::arrow::TimeUnit::type target_unit =
-        ctx->properties->coerce_timestamps_unit();
-    auto target_type = ::arrow::timestamp(target_unit);
-    bool truncation_allowed = ctx->properties->truncated_timestamps_allowed();
+    ::arrow::TimeUnit::type targetUnit =
+        ctx->properties->coerceTimestampsUnit();
+    auto targetType = ::arrow::timestamp(targetUnit);
+    bool truncationAllowed = ctx->properties->truncatedTimestampsAllowed();
 
-    auto DivideBy = [&](const int64_t factor) {
+    auto divideBy = [&](const int64_t factor) {
       for (int64_t i = 0; i < array.length(); i++) {
-        if (!truncation_allowed && array.IsValid(i) &&
+        if (!truncationAllowed && array.IsValid(i) &&
             (values[i] % factor != 0)) {
           return Status::Invalid(
               "Casting from ",
-              source_type.ToString(),
+              sourceType.ToString(),
               " to ",
-              target_type->ToString(),
+              targetType->ToString(),
               " would lose data: ",
               values[i]);
         }
@@ -2517,7 +2473,7 @@ struct SerializeFunctor<Int64Type, ::arrow::TimestampType> {
       return Status::OK();
     };
 
-    auto MultiplyBy = [&](const int64_t factor) {
+    auto multiplyBy = [&](const int64_t factor) {
       for (int64_t i = 0; i < array.length(); i++) {
         out[i] = values[i] * factor;
       }
@@ -2525,13 +2481,13 @@ struct SerializeFunctor<Int64Type, ::arrow::TimestampType> {
     };
 
     const auto& coercion =
-        kTimestampCoercionFactors[static_cast<int>(source_unit)]
-                                 [static_cast<int>(target_unit)];
+        kTimestampCoercionFactors[static_cast<int>(sourceUnit)]
+                                 [static_cast<int>(targetUnit)];
 
-    // .first -> coercion operation; .second -> scale factor
+    // first -> coercion operation; second -> scale factor.
     VELOX_DCHECK_NE(coercion.first, COERCE_INVALID);
-    return coercion.first == COERCE_DIVIDE ? DivideBy(coercion.second)
-                                           : MultiplyBy(coercion.second);
+    return coercion.first == COERCE_DIVIDE ? divideBy(coercion.second)
+                                           : multiplyBy(coercion.second);
   }
 };
 
@@ -2539,98 +2495,85 @@ struct SerializeFunctor<Int64Type, ::arrow::TimestampType> {
 #undef COERCE_INVALID
 #undef COERCE_MULTIPLY
 
-Status WriteTimestamps(
+Status writeTimestamps(
     const ::arrow::Array& values,
-    int64_t num_levels,
-    const int16_t* def_levels,
-    const int16_t* rep_levels,
+    int64_t numLevels,
+    const int16_t* defLevels,
+    const int16_t* repLevels,
     ArrowWriteContext* ctx,
     TypedColumnWriter<Int64Type>* writer,
-    bool maybe_parent_nulls) {
-  const auto& source_type =
+    bool maybeParentNulls) {
+  const auto& sourceType =
       static_cast<const ::arrow::TimestampType&>(*values.type());
 
-  auto WriteCoerce = [&](const ArrowWriterProperties* properties) {
-    ArrowWriteContext temp_ctx = *ctx;
-    temp_ctx.properties = properties;
-    return WriteArrowSerialize<Int64Type, ::arrow::TimestampType>(
+  auto writeCoerce = [&](const ArrowWriterProperties* properties) {
+    ArrowWriteContext tempCtx = *ctx;
+    tempCtx.properties = properties;
+    return writeArrowSerialize<Int64Type, ::arrow::TimestampType>(
         values,
-        num_levels,
-        def_levels,
-        rep_levels,
-        &temp_ctx,
+        numLevels,
+        defLevels,
+        repLevels,
+        &tempCtx,
         writer,
-        maybe_parent_nulls);
+        maybeParentNulls);
   };
 
   const ParquetVersion::type version = writer->properties()->version();
 
-  if (ctx->properties->coerce_timestamps_enabled()) {
-    // User explicitly requested coercion to specific unit
-    if (source_type.unit() == ctx->properties->coerce_timestamps_unit()) {
-      // No data conversion necessary
-      return WriteArrowZeroCopy<Int64Type>(
+  if (ctx->properties->coerceTimestampsEnabled()) {
+    // User explicitly requested coercion to specific unit.
+    if (sourceType.unit() == ctx->properties->coerceTimestampsUnit()) {
+      // No data conversion necessary.
+      return writeArrowZeroCopy<Int64Type>(
           values,
-          num_levels,
-          def_levels,
-          rep_levels,
+          numLevels,
+          defLevels,
+          repLevels,
           ctx,
           writer,
-          maybe_parent_nulls);
+          maybeParentNulls);
     } else {
-      return WriteCoerce(ctx->properties);
+      return writeCoerce(ctx->properties);
     }
   } else if (
       (version == ParquetVersion::PARQUET_1_0 ||
        version == ParquetVersion::PARQUET_2_4) &&
-      source_type.unit() == ::arrow::TimeUnit::NANO) {
-    // Absent superseding user instructions, when writing Parquet version <= 2.4
-    // files, timestamps in nanoseconds are coerced to microseconds
+      sourceType.unit() == ::arrow::TimeUnit::NANO) {
+    // Absent superseding user instructions, when writing Parquet version
+    // Files, timestamps in nanoseconds are coerced to microseconds.
     std::shared_ptr<ArrowWriterProperties> properties =
         (ArrowWriterProperties::Builder())
-            .coerce_timestamps(::arrow::TimeUnit::MICRO)
-            ->disallow_truncated_timestamps()
+            .coerceTimestamps(::arrow::TimeUnit::MICRO)
+            ->disallowTruncatedTimestamps()
             ->build();
-    return WriteCoerce(properties.get());
-  } else if (source_type.unit() == ::arrow::TimeUnit::SECOND) {
-    // Absent superseding user instructions, timestamps in seconds are coerced
-    // to milliseconds
+    return writeCoerce(properties.get());
+  } else if (sourceType.unit() == ::arrow::TimeUnit::SECOND) {
+    // To milliseconds.
     std::shared_ptr<ArrowWriterProperties> properties =
         (ArrowWriterProperties::Builder())
-            .coerce_timestamps(::arrow::TimeUnit::MILLI)
+            .coerceTimestamps(::arrow::TimeUnit::MILLI)
             ->build();
-    return WriteCoerce(properties.get());
+    return writeCoerce(properties.get());
   } else {
-    // No data conversion necessary
-    return WriteArrowZeroCopy<Int64Type>(
-        values,
-        num_levels,
-        def_levels,
-        rep_levels,
-        ctx,
-        writer,
-        maybe_parent_nulls);
+    // No data conversion necessary.
+    return writeArrowZeroCopy<Int64Type>(
+        values, numLevels, defLevels, repLevels, ctx, writer, maybeParentNulls);
   }
 }
 
 template <>
-Status TypedColumnWriterImpl<Int64Type>::WriteArrowDense(
-    const int16_t* def_levels,
-    const int16_t* rep_levels,
-    int64_t num_levels,
+Status TypedColumnWriterImpl<Int64Type>::writeArrowDense(
+    const int16_t* defLevels,
+    const int16_t* repLevels,
+    int64_t numLevels,
     const ::arrow::Array& array,
     ArrowWriteContext* ctx,
-    bool maybe_parent_nulls) {
+    bool maybeParentNulls) {
   switch (array.type()->id()) {
     case ::arrow::Type::TIMESTAMP:
-      return WriteTimestamps(
-          array,
-          num_levels,
-          def_levels,
-          rep_levels,
-          ctx,
-          this,
-          maybe_parent_nulls);
+      return writeTimestamps(
+          array, numLevels, defLevels, repLevels, ctx, this, maybeParentNulls);
       WRITE_ZERO_COPY_CASE(INT64, Int64Type, Int64Type)
       WRITE_SERIALIZE_CASE(UINT32, UInt32Type, Int64Type)
       WRITE_SERIALIZE_CASE(UINT64, UInt64Type, Int64Type)
@@ -2644,116 +2587,115 @@ Status TypedColumnWriterImpl<Int64Type>::WriteArrowDense(
 }
 
 template <>
-Status TypedColumnWriterImpl<Int96Type>::WriteArrowDense(
-    const int16_t* def_levels,
-    const int16_t* rep_levels,
-    int64_t num_levels,
+Status TypedColumnWriterImpl<Int96Type>::writeArrowDense(
+    const int16_t* defLevels,
+    const int16_t* repLevels,
+    int64_t numLevels,
     const ::arrow::Array& array,
     ArrowWriteContext* ctx,
-    bool maybe_parent_nulls) {
+    bool maybeParentNulls) {
   if (array.type_id() != ::arrow::Type::TIMESTAMP) {
     ARROW_UNSUPPORTED();
   }
-  return WriteArrowSerialize<Int96Type, ::arrow::TimestampType>(
-      array, num_levels, def_levels, rep_levels, ctx, this, maybe_parent_nulls);
+  return writeArrowSerialize<Int96Type, ::arrow::TimestampType>(
+      array, numLevels, defLevels, repLevels, ctx, this, maybeParentNulls);
 }
 
-// ----------------------------------------------------------------------
-// Floating point types
+// ----------------------------------------------------------------------.
+// Floating point types.
 
 template <>
-Status TypedColumnWriterImpl<FloatType>::WriteArrowDense(
-    const int16_t* def_levels,
-    const int16_t* rep_levels,
-    int64_t num_levels,
+Status TypedColumnWriterImpl<FloatType>::writeArrowDense(
+    const int16_t* defLevels,
+    const int16_t* repLevels,
+    int64_t numLevels,
     const ::arrow::Array& array,
     ArrowWriteContext* ctx,
-    bool maybe_parent_nulls) {
+    bool maybeParentNulls) {
   if (array.type_id() != ::arrow::Type::FLOAT) {
     ARROW_UNSUPPORTED();
   }
-  return WriteArrowZeroCopy<FloatType>(
-      array, num_levels, def_levels, rep_levels, ctx, this, maybe_parent_nulls);
+  return writeArrowZeroCopy<FloatType>(
+      array, numLevels, defLevels, repLevels, ctx, this, maybeParentNulls);
 }
 
 template <>
-Status TypedColumnWriterImpl<DoubleType>::WriteArrowDense(
-    const int16_t* def_levels,
-    const int16_t* rep_levels,
-    int64_t num_levels,
+Status TypedColumnWriterImpl<DoubleType>::writeArrowDense(
+    const int16_t* defLevels,
+    const int16_t* repLevels,
+    int64_t numLevels,
     const ::arrow::Array& array,
     ArrowWriteContext* ctx,
-    bool maybe_parent_nulls) {
+    bool maybeParentNulls) {
   if (array.type_id() != ::arrow::Type::DOUBLE) {
     ARROW_UNSUPPORTED();
   }
-  return WriteArrowZeroCopy<DoubleType>(
-      array, num_levels, def_levels, rep_levels, ctx, this, maybe_parent_nulls);
+  return writeArrowZeroCopy<DoubleType>(
+      array, numLevels, defLevels, repLevels, ctx, this, maybeParentNulls);
 }
 
-// ----------------------------------------------------------------------
-// Write Arrow to BYTE_ARRAY
+// ----------------------------------------------------------------------.
+// Write Arrow to BYTE_ARRAY.
 
 template <>
-Status TypedColumnWriterImpl<ByteArrayType>::WriteArrowDense(
-    const int16_t* def_levels,
-    const int16_t* rep_levels,
-    int64_t num_levels,
+Status TypedColumnWriterImpl<ByteArrayType>::writeArrowDense(
+    const int16_t* defLevels,
+    const int16_t* repLevels,
+    int64_t numLevels,
     const ::arrow::Array& array,
     ArrowWriteContext* ctx,
-    bool maybe_parent_nulls) {
+    bool maybeParentNulls) {
   if (!::arrow::is_base_binary_like(array.type()->id())) {
     ARROW_UNSUPPORTED();
   }
 
-  int64_t value_offset = 0;
-  auto WriteChunk = [&](int64_t offset, int64_t batch_size, bool check_page) {
-    int64_t batch_num_values = 0;
-    int64_t batch_num_spaced_values = 0;
-    int64_t null_count = 0;
-
-    MaybeCalculateValidityBits(
-        AddIfNotNull(def_levels, offset),
-        batch_size,
-        &batch_num_values,
-        &batch_num_spaced_values,
-        &null_count);
-    WriteLevelsSpaced(
-        batch_size,
-        AddIfNotNull(def_levels, offset),
-        AddIfNotNull(rep_levels, offset));
-    std::shared_ptr<Array> data_slice =
-        array.Slice(value_offset, batch_num_spaced_values);
+  int64_t valueOffset = 0;
+  auto writeChunk = [&](int64_t offset, int64_t batchSize, bool checkPage) {
+    int64_t batchNumValues = 0;
+    int64_t batchNumSpacedValues = 0;
+    int64_t nullCount = 0;
+
+    maybeCalculateValidityBits(
+        addIfNotNull(defLevels, offset),
+        batchSize,
+        &batchNumValues,
+        &batchNumSpacedValues,
+        &nullCount);
+    writeLevelsSpaced(
+        batchSize,
+        addIfNotNull(defLevels, offset),
+        addIfNotNull(repLevels, offset));
+    std::shared_ptr<Array> dataSlice =
+        array.Slice(valueOffset, batchNumSpacedValues);
     PARQUET_ASSIGN_OR_THROW(
-        data_slice,
-        MaybeReplaceValidity(data_slice, null_count, ctx->memory_pool));
+        dataSlice, maybeReplaceValidity(dataSlice, nullCount, ctx->memoryPool));
 
-    current_encoder_->Put(*data_slice);
+    currentEncoder_->put(*dataSlice);
     // Null values in ancestors count as nulls.
-    const int64_t non_null = data_slice->length() - data_slice->null_count();
-    if (page_statistics_ != nullptr) {
-      page_statistics_->Update(*data_slice, /*update_counts=*/false);
-      page_statistics_->IncrementNullCount(batch_size - non_null);
-      page_statistics_->IncrementNumValues(non_null);
-    }
-    CommitWriteAndCheckPageLimit(
-        batch_size, batch_num_values, batch_size - non_null, check_page);
-    CheckDictionarySizeLimit();
-    value_offset += batch_num_spaced_values;
+    const int64_t nonNull = dataSlice->length() - dataSlice->null_count();
+    if (pageStatistics_ != nullptr) {
+      pageStatistics_->update(*dataSlice, false);
+      pageStatistics_->incrementNullCount(batchSize - nonNull);
+      pageStatistics_->incrementNumValues(nonNull);
+    }
+    commitWriteAndCheckPageLimit(
+        batchSize, batchNumValues, batchSize - nonNull, checkPage);
+    checkDictionarySizeLimit();
+    valueOffset += batchNumSpacedValues;
   };
 
-  PARQUET_CATCH_NOT_OK(DoInBatches(
-      def_levels,
-      rep_levels,
-      num_levels,
-      properties_->write_batch_size(),
-      WriteChunk,
-      pages_change_on_record_boundaries()));
+  PARQUET_CATCH_NOT_OK(doInBatches(
+      defLevels,
+      repLevels,
+      numLevels,
+      properties_->writeBatchSize(),
+      writeChunk,
+      pagesChangeOnRecordBoundaries()));
   return Status::OK();
 }
 
-// ----------------------------------------------------------------------
-// Write Arrow to FIXED_LEN_BYTE_ARRAY
+// ----------------------------------------------------------------------.
+// Write Arrow to FIXED_LEN_BYTE_ARRAY.
 
 template <typename ParquetType, typename ArrowType>
 struct SerializeFunctor<
@@ -2762,13 +2704,13 @@ struct SerializeFunctor<
     ::arrow::enable_if_t<
         ::arrow::is_fixed_size_binary_type<ArrowType>::value &&
         !::arrow::is_decimal_type<ArrowType>::value>> {
-  Status Serialize(
+  Status serialize(
       const ::arrow::FixedSizeBinaryArray& array,
       ArrowWriteContext*,
       FLBA* out) {
     if (array.null_count() == 0) {
-      // no nulls, just dump the data
-      // todo(advancedxy): use a writeBatch to avoid this step
+      // No nulls, just dump the data.
+      // Todo(advancedxy): use a writeBatch to avoid this step.
       for (int64_t i = 0; i < array.length(); i++) {
         out[i] = FixedLenByteArray(array.GetValue(i));
       }
@@ -2783,8 +2725,8 @@ struct SerializeFunctor<
   }
 };
 
-// ----------------------------------------------------------------------
-// Write Arrow to Decimal128
+// ----------------------------------------------------------------------.
+// Write Arrow to Decimal128.
 
 // Requires a custom serializer because decimal in parquet are in big-endian
 // format. Thus, a temporary local buffer is required.
@@ -2796,22 +2738,22 @@ struct SerializeFunctor<
         ::arrow::is_decimal_type<ArrowType>::value &&
         !::arrow::internal::IsOneOf<ParquetType, Int32Type, Int64Type>::
             value>> {
-  Status Serialize(
+  Status serialize(
       const typename ::arrow::TypeTraits<ArrowType>::ArrayType& array,
       ArrowWriteContext* ctx,
       FLBA* out) {
-    AllocateScratch(array, ctx);
-    auto offset = Offset(array);
+    allocateScratch(array, ctx);
+    auto decimalOffsetValue = decimalOffset(array);
 
     if (array.null_count() == 0) {
       for (int64_t i = 0; i < array.length(); i++) {
-        out[i] = FixDecimalEndianess<ArrowType::kByteWidth>(
-            array.GetValue(i), offset);
+        out[i] = fixDecimalEndianess<ArrowType::kByteWidth>(
+            array.GetValue(i), decimalOffsetValue);
       }
     } else {
       for (int64_t i = 0; i < array.length(); i++) {
-        out[i] = array.IsValid(i) ? FixDecimalEndianess<ArrowType::kByteWidth>(
-                                        array.GetValue(i), offset)
+        out[i] = array.IsValid(i) ? fixDecimalEndianess<ArrowType::kByteWidth>(
+                                        array.GetValue(i), decimalOffsetValue)
                                   : FixedLenByteArray();
       }
     }
@@ -2819,57 +2761,56 @@ struct SerializeFunctor<
     return Status::OK();
   }
 
-  // Parquet's Decimal are stored with FixedLength values where the length is
-  // proportional to the precision. Arrow's Decimal are always stored with 16/32
-  // bytes. Thus the internal FLBA pointer must be adjusted by the offset
-  // calculated here.
-  int32_t Offset(const Array& array) {
-    auto decimal_type =
-        checked_pointer_cast<::arrow::DecimalType>(array.type());
-    return decimal_type->byte_width() -
-        ::arrow::DecimalType::DecimalSize(decimal_type->precision());
+  // Parquet's decimals are stored with FixedLength values where the
+  // length is proportional to the precision. Arrow's Decimal are always stored
+  // with 16 or 32 bytes. Thus the internal FLBA pointer must be adjusted by the
+  // offset calculated here.
+  int32_t decimalOffset(const Array& array) {
+    auto decimalType = checked_pointer_cast<::arrow::DecimalType>(array.type());
+    return decimalType->byte_width() -
+        ::arrow::DecimalType::DecimalSize(decimalType->precision());
   }
 
-  void AllocateScratch(
+  void allocateScratch(
       const typename ::arrow::TypeTraits<ArrowType>::ArrayType& array,
       ArrowWriteContext* ctx) {
-    int64_t non_null_count = array.length() - array.null_count();
-    int64_t size = non_null_count * ArrowType::kByteWidth;
-    scratch_buffer = AllocateBuffer(ctx->memory_pool, size);
-    scratch = reinterpret_cast<int64_t*>(scratch_buffer->mutable_data());
+    int64_t nonNullCount = array.length() - array.null_count();
+    int64_t size = nonNullCount * ArrowType::kByteWidth;
+    scratchBuffer = allocateBuffer(ctx->memoryPool, size);
+    scratch = reinterpret_cast<int64_t*>(scratchBuffer->mutable_data());
   }
 
-  template <int byte_width>
-  FixedLenByteArray FixDecimalEndianess(const uint8_t* in, int64_t offset) {
-    const auto* u64_in = reinterpret_cast<const int64_t*>(in);
+  template <int byteWidth>
+  FixedLenByteArray fixDecimalEndianess(const uint8_t* in, int64_t offset) {
+    const auto* u64In = reinterpret_cast<const int64_t*>(in);
     auto out = reinterpret_cast<const uint8_t*>(scratch) + offset;
     static_assert(
-        byte_width == 16 || byte_width == 32,
+        byteWidth == 16 || byteWidth == 32,
         "only 16 and 32 byte Decimals supported");
-    if (byte_width == 32) {
-      *scratch++ = ::arrow::bit_util::ToBigEndian(u64_in[3]);
-      *scratch++ = ::arrow::bit_util::ToBigEndian(u64_in[2]);
-      *scratch++ = ::arrow::bit_util::ToBigEndian(u64_in[1]);
-      *scratch++ = ::arrow::bit_util::ToBigEndian(u64_in[0]);
+    if (byteWidth == 32) {
+      *scratch++ = ::arrow::bit_util::ToBigEndian(u64In[3]);
+      *scratch++ = ::arrow::bit_util::ToBigEndian(u64In[2]);
+      *scratch++ = ::arrow::bit_util::ToBigEndian(u64In[1]);
+      *scratch++ = ::arrow::bit_util::ToBigEndian(u64In[0]);
     } else {
-      *scratch++ = ::arrow::bit_util::ToBigEndian(u64_in[1]);
-      *scratch++ = ::arrow::bit_util::ToBigEndian(u64_in[0]);
+      *scratch++ = ::arrow::bit_util::ToBigEndian(u64In[1]);
+      *scratch++ = ::arrow::bit_util::ToBigEndian(u64In[0]);
     }
     return FixedLenByteArray(out);
   }
 
-  std::shared_ptr<ResizableBuffer> scratch_buffer;
+  std::shared_ptr<ResizableBuffer> scratchBuffer;
   int64_t* scratch;
 };
 
 template <>
-Status TypedColumnWriterImpl<FLBAType>::WriteArrowDense(
-    const int16_t* def_levels,
-    const int16_t* rep_levels,
-    int64_t num_levels,
+Status TypedColumnWriterImpl<FLBAType>::writeArrowDense(
+    const int16_t* defLevels,
+    const int16_t* repLevels,
+    int64_t numLevels,
     const ::arrow::Array& array,
     ArrowWriteContext* ctx,
-    bool maybe_parent_nulls) {
+    bool maybeParentNulls) {
   switch (array.type()->id()) {
     WRITE_SERIALIZE_CASE(FIXED_SIZE_BINARY, FixedSizeBinaryType, FLBAType)
     WRITE_SERIALIZE_CASE(DECIMAL128, Decimal128Type, FLBAType)
@@ -2880,60 +2821,60 @@ Status TypedColumnWriterImpl<FLBAType>::WriteArrowDense(
   return Status::OK();
 }
 
-// ----------------------------------------------------------------------
-// Dynamic column writer constructor
+// ----------------------------------------------------------------------.
+// Dynamic column writer constructor.
 
-std::shared_ptr<ColumnWriter> ColumnWriter::Make(
+std::shared_ptr<ColumnWriter> ColumnWriter::make(
     ColumnChunkMetaDataBuilder* metadata,
     std::unique_ptr<PageWriter> pager,
     const WriterProperties* properties) {
   const ColumnDescriptor* descr = metadata->descr();
-  const bool use_dictionary = properties->dictionary_enabled(descr->path()) &&
-      descr->physical_type() != Type::BOOLEAN;
+  const bool useDictionary = properties->dictionaryEnabled(descr->path()) &&
+      descr->physicalType() != Type::kBoolean;
   Encoding::type encoding = properties->encoding(descr->path());
 
-  if (encoding == Encoding::UNKNOWN) {
+  if (encoding == Encoding::kUnknown) {
     // TODO: Arrow uses RLE by default for boolean columns. Since Velox can't
     // read RLEs yet, we disable this check. Re-enable once Velox's native
     // reader supports RLE.
-    // encoding = (descr->physical_type() == Type::BOOLEAN &&
+    // Encoding = (descr->physical_type() == Type::kBoolean &&.
     //            properties->version() != ParquetVersion::PARQUET_1_0)
-    //               ? Encoding::RLE
+    //               ? Encoding::RLE.
     //               : Encoding::PLAIN;
-    encoding = Encoding::PLAIN;
+    encoding = Encoding::kPlain;
   }
-  if (use_dictionary) {
-    encoding = properties->dictionary_index_encoding();
+  if (useDictionary) {
+    encoding = properties->dictionaryIndexEncoding();
   }
-  switch (descr->physical_type()) {
-    case Type::BOOLEAN:
+  switch (descr->physicalType()) {
+    case Type::kBoolean:
       return std::make_shared<TypedColumnWriterImpl<BooleanType>>(
-          metadata, std::move(pager), use_dictionary, encoding, properties);
-    case Type::INT32:
+          metadata, std::move(pager), useDictionary, encoding, properties);
+    case Type::kInt32:
       return std::make_shared<TypedColumnWriterImpl<Int32Type>>(
-          metadata, std::move(pager), use_dictionary, encoding, properties);
-    case Type::INT64:
+          metadata, std::move(pager), useDictionary, encoding, properties);
+    case Type::kInt64:
       return std::make_shared<TypedColumnWriterImpl<Int64Type>>(
-          metadata, std::move(pager), use_dictionary, encoding, properties);
-    case Type::INT96:
+          metadata, std::move(pager), useDictionary, encoding, properties);
+    case Type::kInt96:
       return std::make_shared<TypedColumnWriterImpl<Int96Type>>(
-          metadata, std::move(pager), use_dictionary, encoding, properties);
-    case Type::FLOAT:
+          metadata, std::move(pager), useDictionary, encoding, properties);
+    case Type::kFloat:
       return std::make_shared<TypedColumnWriterImpl<FloatType>>(
-          metadata, std::move(pager), use_dictionary, encoding, properties);
-    case Type::DOUBLE:
+          metadata, std::move(pager), useDictionary, encoding, properties);
+    case Type::kDouble:
       return std::make_shared<TypedColumnWriterImpl<DoubleType>>(
-          metadata, std::move(pager), use_dictionary, encoding, properties);
-    case Type::BYTE_ARRAY:
+          metadata, std::move(pager), useDictionary, encoding, properties);
+    case Type::kByteArray:
       return std::make_shared<TypedColumnWriterImpl<ByteArrayType>>(
-          metadata, std::move(pager), use_dictionary, encoding, properties);
-    case Type::FIXED_LEN_BYTE_ARRAY:
+          metadata, std::move(pager), useDictionary, encoding, properties);
+    case Type::kFixedLenByteArray:
       return std::make_shared<TypedColumnWriterImpl<FLBAType>>(
-          metadata, std::move(pager), use_dictionary, encoding, properties);
+          metadata, std::move(pager), useDictionary, encoding, properties);
     default:
       ParquetException::NYI("type reader not implemented");
   }
-  // Unreachable code, but suppress compiler warning
+  // Unreachable code, but suppress compiler warning.
   return std::shared_ptr<ColumnWriter>(nullptr);
 }
 
diff --git a/velox/dwio/parquet/writer/arrow/ColumnWriter.h b/velox/dwio/parquet/writer/arrow/ColumnWriter.h
index 90a9b96ab65..52699ca2969 100644
--- a/velox/dwio/parquet/writer/arrow/ColumnWriter.h
+++ b/velox/dwio/parquet/writer/arrow/ColumnWriter.h
@@ -60,218 +60,218 @@ class PARQUET_EXPORT LevelEncoder {
   LevelEncoder();
   ~LevelEncoder();
 
-  static int MaxBufferSize(
+  static int maxBufferSize(
       Encoding::type encoding,
-      int16_t max_level,
-      int num_buffered_values);
+      int16_t maxLevel,
+      int numBufferedValues);
 
   // Initialize the LevelEncoder.
-  void Init(
+  void init(
       Encoding::type encoding,
-      int16_t max_level,
-      int num_buffered_values,
+      int16_t maxLevel,
+      int numBufferedValues,
       uint8_t* data,
-      int data_size);
+      int dataSize);
 
   // Encodes a batch of levels from an array and returns the number of levels
-  // encoded
-  int Encode(int batch_size, const int16_t* levels);
+  // encoded.
+  int encode(int batchSize, const int16_t* levels);
 
   int32_t len() {
-    if (encoding_ != Encoding::RLE) {
+    if (encoding_ != Encoding::kRle) {
       throw ParquetException("Only implemented for RLE encoding");
     }
-    return rle_length_;
+    return rleLength_;
   }
 
  private:
-  int bit_width_;
-  int rle_length_;
+  int bitWidth_;
+  int rleLength_;
   Encoding::type encoding_;
-  std::unique_ptr<RleEncoder> rle_encoder_;
-  std::unique_ptr<BitWriter> bit_packed_encoder_;
+  std::unique_ptr<RleEncoder> rleEncoder_;
+  std::unique_ptr<BitWriter> bitPackedEncoder_;
 };
 
 class PARQUET_EXPORT PageWriter {
  public:
   virtual ~PageWriter() {}
 
-  static std::unique_ptr<PageWriter> Open(
+  static std::unique_ptr<PageWriter> open(
       std::shared_ptr<ArrowOutputStream> sink,
       Compression::type codec,
       ColumnChunkMetaDataBuilder* metadata,
-      int16_t row_group_ordinal = -1,
-      int16_t column_chunk_ordinal = -1,
+      int16_t rowGroupOrdinal = -1,
+      int16_t columnChunkOrdinal = -1,
       ::arrow::MemoryPool* pool = ::arrow::default_memory_pool(),
-      bool buffered_row_group = false,
-      std::shared_ptr<Encryptor> header_encryptor = NULLPTR,
-      std::shared_ptr<Encryptor> data_encryptor = NULLPTR,
-      bool page_write_checksum_enabled = false,
-      // column_index_builder MUST outlive the PageWriter
-      ColumnIndexBuilder* column_index_builder = NULLPTR,
-      // offset_index_builder MUST outlive the PageWriter
-      OffsetIndexBuilder* offset_index_builder = NULLPTR,
-      const util::CodecOptions& codec_options = util::CodecOptions{});
+      bool bufferedRowGroup = false,
+      std::shared_ptr<Encryptor> headerEncryptor = NULLPTR,
+      std::shared_ptr<Encryptor> dataEncryptor = NULLPTR,
+      bool pageWriteChecksumEnabled = false,
+      // columnIndexBuilder must outlive the PageWriter.
+      ColumnIndexBuilder* columnIndexBuilder = NULLPTR,
+      // offsetIndexBuilder must outlive the PageWriter.
+      OffsetIndexBuilder* offsetIndexBuilder = NULLPTR,
+      const util::CodecOptions& codecOptions = util::CodecOptions{});
 
   // TODO: remove this and port to new signature.
   // ARROW_DEPRECATED(
-  //    "Deprecated in 13.0.0. Use CodecOptions-taking overload instead.")
-  static std::unique_ptr<PageWriter> Open(
+  //    "Deprecated in 13.0.0. Use codecOptions-taking overload instead.")
+  static std::unique_ptr<PageWriter> open(
       std::shared_ptr<ArrowOutputStream> sink,
       Compression::type codec,
-      int compression_level,
+      int compressionLevel,
       ColumnChunkMetaDataBuilder* metadata,
-      int16_t row_group_ordinal = -1,
-      int16_t column_chunk_ordinal = -1,
+      int16_t rowGroupOrdinal = -1,
+      int16_t columnChunkOrdinal = -1,
       ::arrow::MemoryPool* pool = ::arrow::default_memory_pool(),
-      bool buffered_row_group = false,
-      std::shared_ptr<Encryptor> header_encryptor = NULLPTR,
-      std::shared_ptr<Encryptor> data_encryptor = NULLPTR,
-      bool page_write_checksum_enabled = false,
-      // column_index_builder MUST outlive the PageWriter
-      ColumnIndexBuilder* column_index_builder = NULLPTR,
-      // offset_index_builder MUST outlive the PageWriter
-      OffsetIndexBuilder* offset_index_builder = NULLPTR);
-
-  // The Column Writer decides if dictionary encoding is used if set and
+      bool bufferedRowGroup = false,
+      std::shared_ptr<Encryptor> headerEncryptor = NULLPTR,
+      std::shared_ptr<Encryptor> dataEncryptor = NULLPTR,
+      bool pageWriteChecksumEnabled = false,
+      // columnIndexBuilder must outlive the PageWriter.
+      ColumnIndexBuilder* columnIndexBuilder = NULLPTR,
+      // offsetIndexBuilder must outlive the PageWriter.
+      OffsetIndexBuilder* offsetIndexBuilder = NULLPTR);
+
+  // The column writer decides if dictionary encoding is used, if set, and
   // if the dictionary encoding has fallen back to default encoding on reaching
-  // dictionary page limit
-  virtual void Close(bool has_dictionary, bool fallback) = 0;
+  // dictionary page limit.
+  virtual void close(bool hasDictionary, bool fallback) = 0;
 
-  // Return the number of uncompressed bytes written (including header size)
-  virtual int64_t WriteDataPage(const DataPage& page) = 0;
+  // Return the number of uncompressed bytes written (including header size).
+  virtual int64_t writeDataPage(const DataPage& page) = 0;
 
-  // Return the number of uncompressed bytes written (including header size)
-  virtual int64_t WriteDictionaryPage(const DictionaryPage& page) = 0;
+  // Return the number of uncompressed bytes written (including header size).
+  virtual int64_t writeDictionaryPage(const DictionaryPage& page) = 0;
 
   /// \brief The total number of bytes written as serialized data and
   /// dictionary pages to the sink so far.
-  virtual int64_t total_compressed_bytes_written() const = 0;
+  virtual int64_t totalCompressedBytesWritten() const = 0;
 
-  virtual bool has_compressor() = 0;
+  virtual bool hasCompressor() = 0;
 
-  virtual void Compress(
-      const ::arrow::Buffer& src_buffer,
-      ::arrow::ResizableBuffer* dest_buffer) = 0;
+  virtual void compress(
+      const ::arrow::Buffer& srcBuffer,
+      ::arrow::ResizableBuffer* destBuffer) = 0;
 };
 
 class PARQUET_EXPORT ColumnWriter {
  public:
   virtual ~ColumnWriter() = default;
 
-  static std::shared_ptr<ColumnWriter> Make(
+  static std::shared_ptr<ColumnWriter> make(
       ColumnChunkMetaDataBuilder*,
       std::unique_ptr<PageWriter>,
       const WriterProperties* properties);
 
   /// \brief Closes the ColumnWriter, commits any buffered values to pages.
-  /// \return Total size of the column in bytes
-  virtual int64_t Close() = 0;
+  /// \return Total size of the column in bytes.
+  virtual int64_t close() = 0;
 
-  /// \brief The physical Parquet type of the column
+  /// \brief The physical Parquet type of the column.
   virtual Type::type type() const = 0;
 
-  /// \brief The schema for the column
+  /// \brief The schema for the column.
   virtual const ColumnDescriptor* descr() const = 0;
 
-  /// \brief The number of rows written so far
-  virtual int64_t rows_written() const = 0;
+  /// \brief The number of rows written so far.
+  virtual int64_t rowsWritten() const = 0;
 
   /// \brief The total size of the compressed pages + page headers. Values
-  /// are still buffered and not written to a pager yet
+  /// are still buffered and not written to a pager yet.
   ///
-  /// So in un-buffered mode, it always returns 0
-  virtual int64_t total_compressed_bytes() const = 0;
+  /// So in unbuffered mode, it always returns 0.
+  virtual int64_t totalCompressedBytes() const = 0;
 
   /// \brief The total number of bytes written as serialized data and
-  /// dictionary pages to the ColumnChunk so far
+  /// dictionary pages to the ColumnChunk so far.
   /// These bytes are uncompressed bytes.
-  virtual int64_t total_bytes_written() const = 0;
+  virtual int64_t totalBytesWritten() const = 0;
 
   /// \brief The total number of bytes written as serialized data and
   /// dictionary pages to the ColumnChunk so far.
   /// If the column is uncompressed, the value would be equal to
-  /// total_bytes_written().
-  virtual int64_t total_compressed_bytes_written() const = 0;
+  /// totalBytesWritten().
+  virtual int64_t totalCompressedBytesWritten() const = 0;
 
-  /// \brief The file-level writer properties
+  /// \brief The file-level writer properties.
   virtual const WriterProperties* properties() = 0;
 
   /// \brief Write Apache Arrow columnar data directly to ColumnWriter. Returns
   /// error status if the array data type is not compatible with the concrete
   /// writer type.
   ///
-  /// leaf_array is always a primitive (possibly dictionary encoded type).
-  /// Leaf_field_nullable indicates whether the leaf array is considered
+  /// leafArray is always a primitive (possibly dictionary encoded type).
+  /// leafFieldNullable indicates whether the leaf array is considered
   /// nullable according to its schema in a Table or its parent array.
-  virtual ::arrow::Status WriteArrow(
-      const int16_t* def_levels,
-      const int16_t* rep_levels,
-      int64_t num_levels,
-      const ::arrow::Array& leaf_array,
+  virtual ::arrow::Status writeArrow(
+      const int16_t* defLevels,
+      const int16_t* repLevels,
+      int64_t numLevels,
+      const ::arrow::Array& leafArray,
       ArrowWriteContext* ctx,
-      bool leaf_field_nullable) = 0;
+      bool leafFieldNullable) = 0;
 };
 
 // API to write values to a single column. This is the main client facing API.
 template <typename DType>
 class TypedColumnWriter : public ColumnWriter {
  public:
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
 
   // Write a batch of repetition levels, definition levels, and values to the
   // column.
-  // `num_values` is the number of logical leaf values.
-  // `def_levels` (resp. `rep_levels`) can be null if the column's max
+  // 'numValues' is the number of logical leaf values.
+  // `defLevels` (resp. `repLevels`) can be null if the column's max
   // definition level (resp. max repetition level) is 0. If not null, each of
-  // `def_levels` and `rep_levels` must have at least `num_values`.
+  // `defLevels` and `repLevels` must have at least `numValues`.
   //
   // The number of physical values written (taken from `values`) is returned.
-  // It can be smaller than `num_values` is there are some undefined values.
-  virtual int64_t WriteBatch(
-      int64_t num_values,
-      const int16_t* def_levels,
-      const int16_t* rep_levels,
+  // It can be smaller than `numValues` if there are some undefined values.
+  virtual int64_t writeBatch(
+      int64_t numValues,
+      const int16_t* defLevels,
+      const int16_t* repLevels,
       const T* values) = 0;
 
   /// Write a batch of repetition levels, definition levels, and values to the
   /// column.
   ///
-  /// In comparison to WriteBatch the length of repetition and definition levels
-  /// is the same as of the number of values read for max_definition_level == 1.
-  /// In the case of max_definition_level > 1, the repetition and definition
-  /// levels are larger than the values but the values include the null entries
-  /// with definition_level == (max_definition_level - 1). Thus we have to
-  /// differentiate in the parameters of this function if the input has the
-  /// length of num_values or the _number of rows in the lowest nesting level_.
+  /// In comparison to writeBatch() the length of repetition and definition
+  /// levels is the same as of the number of values read for
+  /// maxDefinitionLevel == 1. In the case of maxDefinitionLevel > 1, the
+  /// repetition and definition levels are larger than the values but the values
+  /// include the null entries with definitionLevel == (maxDefinitionLevel -
+  /// 1). Thus we have to differentiate in the parameters of this function if
+  /// the input has the length of numValues or the _number of rows in the lowest
+  /// nesting level.
   ///
   /// In the case that the most inner node in the Parquet is required, the
   /// _number of rows in the lowest nesting level_ is equal to the number of
   /// non-null values. If the inner-most schema node is optional, the _number of
   /// rows in the lowest nesting level_ also includes all values with
-  /// definition_level == (max_definition_level - 1).
+  /// definitionLevel == (maxDefinitionLevel - 1).
   ///
-  /// @param num_values number of levels to write.
-  /// @param def_levels The Parquet definition levels, length is num_values
-  /// @param rep_levels The Parquet repetition levels, length is num_values
-  /// @param valid_bits Bitmap that indicates if the row is null on the lowest
-  /// nesting
-  ///   level. The length is number of rows in the lowest nesting level.
-  /// @param valid_bits_offset The offset in bits of the valid_bits where the
+  /// @param numValues Number of levels to write.
+  /// @param defLevels The Parquet definition levels, length is numValues.
+  /// @param repLevels The Parquet repetition levels, length is numValues.
+  /// @param validBits Bitmap that indicates if the row is null on the lowest
+  /// nesting level. The length is number of rows in the lowest nesting level.
+  /// @param validBitsOffset The offset in bits of the validBits where the
   ///   first relevant bit resides.
   /// @param values The values in the lowest nested level including
   ///   spacing for nulls on the lowest levels; input has the length
   ///   of the number of rows on the lowest nesting level.
-  virtual void WriteBatchSpaced(
-      int64_t num_values,
-      const int16_t* def_levels,
-      const int16_t* rep_levels,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  virtual void writeBatchSpaced(
+      int64_t numValues,
+      const int16_t* defLevels,
+      const int16_t* repLevels,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       const T* values) = 0;
 
   // Estimated size of the values that are not written to a page yet
-  virtual int64_t EstimatedBufferedValueBytes() const = 0;
+  virtual int64_t estimatedBufferedValueBytes() const = 0;
 };
 
 using BoolWriter = TypedColumnWriter<BooleanType>;
@@ -285,57 +285,57 @@ using FixedLenByteArrayWriter = TypedColumnWriter<FLBAType>;
 
 namespace internal {
 
-// Timestamp conversion constants
+// Timestamp conversion constants.
 constexpr int64_t kJulianEpochOffsetDays = INT64_C(2440588);
 
 template <int64_t UnitPerDay, int64_t NanosecondsPerUnit>
-inline void ArrowTimestampToImpalaTimestamp(
-    const int64_t time,
-    Int96* impala_timestamp) {
-  int64_t julian_days = (time / UnitPerDay) + kJulianEpochOffsetDays;
-  (*impala_timestamp).value[2] = (uint32_t)julian_days;
-
-  int64_t last_day_units = time % UnitPerDay;
-  auto last_day_nanos = last_day_units * NanosecondsPerUnit;
-  // impala_timestamp will be unaligned every other entry so do memcpy instead
+inline void arrowTimestampToImpalaTimestamp(
+    const int64_t Time,
+    Int96* impalaTimestamp) {
+  int64_t julianDays = (Time / UnitPerDay) + kJulianEpochOffsetDays;
+  (*impalaTimestamp).value[2] = (uint32_t)julianDays;
+
+  int64_t lastDayUnits = Time % UnitPerDay;
+  auto lastDayNanos = lastDayUnits * NanosecondsPerUnit;
+  // impalaTimestamp will be unaligned every other entry so do memcpy instead
   // of assign and reinterpret cast to avoid undefined behavior.
-  std::memcpy(impala_timestamp, &last_day_nanos, sizeof(int64_t));
+  std::memcpy(impalaTimestamp, &lastDayNanos, sizeof(int64_t));
 }
 
 constexpr int64_t kSecondsInNanos = INT64_C(1000000000);
 
-inline void SecondsToImpalaTimestamp(
+inline void secondsToImpalaTimestamp(
     const int64_t seconds,
-    Int96* impala_timestamp) {
-  ArrowTimestampToImpalaTimestamp<kSecondsPerDay, kSecondsInNanos>(
-      seconds, impala_timestamp);
+    Int96* impalaTimestamp) {
+  arrowTimestampToImpalaTimestamp<kSecondsPerDay, kSecondsInNanos>(
+      seconds, impalaTimestamp);
 }
 
 constexpr int64_t kMillisecondsInNanos = kSecondsInNanos / INT64_C(1000);
 
-inline void MillisecondsToImpalaTimestamp(
+inline void millisecondsToImpalaTimestamp(
     const int64_t milliseconds,
-    Int96* impala_timestamp) {
-  ArrowTimestampToImpalaTimestamp<kMillisecondsPerDay, kMillisecondsInNanos>(
-      milliseconds, impala_timestamp);
+    Int96* impalaTimestamp) {
+  arrowTimestampToImpalaTimestamp<kMillisecondsPerDay, kMillisecondsInNanos>(
+      milliseconds, impalaTimestamp);
 }
 
 constexpr int64_t kMicrosecondsInNanos = kMillisecondsInNanos / INT64_C(1000);
 
-inline void MicrosecondsToImpalaTimestamp(
+inline void microsecondsToImpalaTimestamp(
     const int64_t microseconds,
-    Int96* impala_timestamp) {
-  ArrowTimestampToImpalaTimestamp<kMicrosecondsPerDay, kMicrosecondsInNanos>(
-      microseconds, impala_timestamp);
+    Int96* impalaTimestamp) {
+  arrowTimestampToImpalaTimestamp<kMicrosecondsPerDay, kMicrosecondsInNanos>(
+      microseconds, impalaTimestamp);
 }
 
 constexpr int64_t kNanosecondsInNanos = INT64_C(1);
 
-inline void NanosecondsToImpalaTimestamp(
+inline void nanosecondsToImpalaTimestamp(
     const int64_t nanoseconds,
-    Int96* impala_timestamp) {
-  ArrowTimestampToImpalaTimestamp<kNanosecondsPerDay, kNanosecondsInNanos>(
-      nanoseconds, impala_timestamp);
+    Int96* impalaTimestamp) {
+  arrowTimestampToImpalaTimestamp<kNanosecondsPerDay, kNanosecondsInNanos>(
+      nanoseconds, impalaTimestamp);
 }
 
 } // namespace internal
diff --git a/velox/dwio/parquet/writer/arrow/Encoding.cpp b/velox/dwio/parquet/writer/arrow/Encoding.cpp
index 996d6455d06..f907b3e86be 100644
--- a/velox/dwio/parquet/writer/arrow/Encoding.cpp
+++ b/velox/dwio/parquet/writer/arrow/Encoding.cpp
@@ -40,7 +40,6 @@
 #include "arrow/util/bitmap_ops.h"
 #include "arrow/util/bitmap_writer.h"
 #include "arrow/util/checked_cast.h"
-#include "arrow/util/logging.h"
 #include "arrow/util/ubsan.h"
 #include "arrow/visit_data_inline.h"
 
@@ -59,9 +58,9 @@ using ::arrow::MemoryPool;
 using ::arrow::ResizableBuffer;
 using arrow::Status;
 using arrow::VisitNullBitmapInline;
-using arrow::internal::AddWithOverflow;
+using arrow::internal::addWithOverflow;
 using arrow::internal::checked_cast;
-using arrow::internal::MultiplyWithOverflow;
+using arrow::internal::multiplyWithOverflow;
 using arrow::internal::SubtractWithOverflow;
 using std::string_view;
 
@@ -80,14 +79,14 @@ inline std::enable_if_t<std::is_trivially_copyable_v<T>, T> SafeLoadAs(
 }
 
 template <typename T>
-inline std::enable_if_t<std::is_trivially_copyable_v<T>, T> SafeLoad(
+inline std::enable_if_t<std::is_trivially_copyable_v<T>, T> safeLoad(
     const T* unaligned) {
   std::remove_const_t<T> ret;
   std::memcpy(&ret, unaligned, sizeof(T));
   return ret;
 }
 
-std::shared_ptr<ResizableBuffer> AllocateBuffer(
+std::shared_ptr<ResizableBuffer> allocateBuffer(
     MemoryPool* pool,
     int64_t size) {
   PARQUET_ASSIGN_OR_THROW(
@@ -108,93 +107,91 @@ class EncoderImpl : virtual public Encoder {
       : descr_(descr),
         encoding_(encoding),
         pool_(pool),
-        type_length_(descr ? descr->type_length() : -1) {}
+        typeLength_(descr ? descr->typeLength() : -1) {}
 
   Encoding::type encoding() const override {
     return encoding_;
   }
 
-  MemoryPool* memory_pool() const override {
+  MemoryPool* memoryPool() const override {
     return pool_;
   }
 
  protected:
-  // For accessing type-specific metadata, like FIXED_LEN_BYTE_ARRAY
+  // For accessing type-specific metadata, like FIXED_LEN_BYTE_ARRAY.
   const ColumnDescriptor* descr_;
   const Encoding::type encoding_;
   MemoryPool* pool_;
 
-  /// Type length from descr
-  int type_length_;
+  /// Type length from descr.
+  int typeLength_;
 };
 
-// ----------------------------------------------------------------------
-// Plain encoder implementation
+// ----------------------------------------------------------------------.
+// Plain encoder implementation.
 
 template <typename DType>
 class PlainEncoder : public EncoderImpl, virtual public TypedEncoder<DType> {
  public:
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
 
   explicit PlainEncoder(const ColumnDescriptor* descr, MemoryPool* pool)
-      : EncoderImpl(descr, Encoding::PLAIN, pool), sink_(pool) {}
+      : EncoderImpl(descr, Encoding::kPlain, pool), sink_(pool) {}
 
-  int64_t EstimatedDataEncodedSize() override {
+  int64_t estimatedDataEncodedSize() override {
     return sink_.length();
   }
 
-  std::shared_ptr<::arrow::Buffer> FlushValues() override {
+  std::shared_ptr<::arrow::Buffer> flushValues() override {
     std::shared_ptr<Buffer> buffer;
     PARQUET_THROW_NOT_OK(sink_.Finish(&buffer));
     return buffer;
   }
 
-  using TypedEncoder<DType>::Put;
+  using TypedEncoder<DType>::put;
 
-  void Put(const T* buffer, int num_values) override;
+  void put(const T* buffer, int numValues) override;
 
-  void Put(const ::arrow::Array& values) override;
+  void put(const ::arrow::Array& values) override;
 
-  void PutSpaced(
+  void putSpaced(
       const T* src,
-      int num_values,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset) override {
-    if (valid_bits != NULLPTR) {
-      PARQUET_ASSIGN_OR_THROW(
-          auto buffer,
-          ::arrow::AllocateBuffer(num_values * sizeof(T), this->memory_pool()));
+      int numValues,
+      const uint8_t* validBits,
+      int64_t validBitsOffset) override {
+    if (validBits != NULLPTR) {
+      auto buffer = allocateBuffer(this->memoryPool(), numValues * sizeof(T));
       T* data = reinterpret_cast<T*>(buffer->mutable_data());
-      int num_valid_values = ::arrow::util::internal::SpacedCompress<T>(
-          src, num_values, valid_bits, valid_bits_offset, data);
-      Put(data, num_valid_values);
+      int numValidValues = ::arrow::util::internal::SpacedCompress<T>(
+          src, numValues, validBits, validBitsOffset, data);
+      put(data, numValidValues);
     } else {
-      Put(src, num_values);
+      put(src, numValues);
     }
   }
 
-  void UnsafePutByteArray(const void* data, uint32_t length) {
+  void unsafePutByteArray(const void* data, uint32_t length) {
     VELOX_DCHECK(length == 0 || data != nullptr, "Value ptr cannot be NULL");
     sink_.UnsafeAppend(&length, sizeof(uint32_t));
     sink_.UnsafeAppend(data, static_cast<int64_t>(length));
   }
 
-  void Put(const ByteArray& val) {
-    // Write the result to the output stream
+  void put(const ByteArray& val) {
+    // Write the result to the output stream.
     const int64_t increment = static_cast<int64_t>(val.len + sizeof(uint32_t));
     if (ARROW_PREDICT_FALSE(sink_.length() + increment > sink_.capacity())) {
       PARQUET_THROW_NOT_OK(sink_.Reserve(increment));
     }
-    UnsafePutByteArray(val.ptr, val.len);
+    unsafePutByteArray(val.ptr, val.len);
   }
 
  protected:
   template <typename ArrayType>
-  void PutBinaryArray(const ArrayType& array) {
-    const int64_t total_bytes =
+  void putBinaryArray(const ArrayType& array) {
+    const int64_t totalBytes =
         array.value_offset(array.length()) - array.value_offset(0);
     PARQUET_THROW_NOT_OK(
-        sink_.Reserve(total_bytes + array.length() * sizeof(uint32_t)));
+        sink_.Reserve(totalBytes + array.length() * sizeof(uint32_t)));
 
     PARQUET_THROW_NOT_OK(
         ::arrow::VisitArraySpanInline<typename ArrayType::TypeClass>(
@@ -204,7 +201,7 @@ class PlainEncoder : public EncoderImpl, virtual public TypedEncoder<DType> {
                 return Status::Invalid(
                     "Parquet cannot store strings with size 2GB or more");
               }
-              UnsafePutByteArray(
+              unsafePutByteArray(
                   view.data(), static_cast<uint32_t>(view.size()));
               return Status::OK();
             },
@@ -215,125 +212,125 @@ class PlainEncoder : public EncoderImpl, virtual public TypedEncoder<DType> {
 };
 
 template <typename DType>
-void PlainEncoder<DType>::Put(const T* buffer, int num_values) {
-  if (num_values > 0) {
-    PARQUET_THROW_NOT_OK(sink_.Append(buffer, num_values * sizeof(T)));
+void PlainEncoder<DType>::put(const T* buffer, int numValues) {
+  if (numValues > 0) {
+    PARQUET_THROW_NOT_OK(sink_.Append(buffer, numValues * sizeof(T)));
   }
 }
 
 template <>
-inline void PlainEncoder<ByteArrayType>::Put(
+inline void PlainEncoder<ByteArrayType>::put(
     const ByteArray* src,
-    int num_values) {
-  for (int i = 0; i < num_values; ++i) {
-    Put(src[i]);
+    int numValues) {
+  for (int i = 0; i < numValues; ++i) {
+    put(src[i]);
   }
 }
 
 template <typename ArrayType>
-void DirectPutImpl(const ::arrow::Array& values, ::arrow::BufferBuilder* sink) {
+void directPutImpl(const ::arrow::Array& values, ::arrow::BufferBuilder* sink) {
   if (values.type_id() != ArrayType::TypeClass::type_id) {
-    std::string type_name = ArrayType::TypeClass::type_name();
+    std::string typeName = ArrayType::TypeClass::type_name();
     throw ParquetException(
-        "direct put to " + type_name + " from " + values.type()->ToString() +
+        "direct put to " + typeName + " from " + values.type()->ToString() +
         " not supported");
   }
 
-  using value_type = typename ArrayType::value_type;
-  constexpr auto value_size = sizeof(value_type);
-  auto raw_values = checked_cast<const ArrayType&>(values).raw_values();
+  using ValueType = typename ArrayType::value_type;
+  constexpr auto valueSize = sizeof(ValueType);
+  auto rawValues = checked_cast<const ArrayType&>(values).raw_values();
 
   if (values.null_count() == 0) {
-    // no nulls, just dump the data
-    PARQUET_THROW_NOT_OK(
-        sink->Append(raw_values, values.length() * value_size));
+    // No nulls, just dump the data.
+    PARQUET_THROW_NOT_OK(sink->Append(rawValues, values.length() * valueSize));
   } else {
     PARQUET_THROW_NOT_OK(
-        sink->Reserve((values.length() - values.null_count()) * value_size));
+        sink->Reserve((values.length() - values.null_count()) * valueSize));
 
     for (int64_t i = 0; i < values.length(); i++) {
       if (values.IsValid(i)) {
-        sink->UnsafeAppend(&raw_values[i], value_size);
+        sink->UnsafeAppend(&rawValues[i], valueSize);
       }
     }
   }
 }
 
 template <>
-void PlainEncoder<Int32Type>::Put(const ::arrow::Array& values) {
-  DirectPutImpl<::arrow::Int32Array>(values, &sink_);
+void PlainEncoder<Int32Type>::put(const ::arrow::Array& values) {
+  directPutImpl<::arrow::Int32Array>(values, &sink_);
 }
 
 template <>
-void PlainEncoder<Int64Type>::Put(const ::arrow::Array& values) {
-  DirectPutImpl<::arrow::Int64Array>(values, &sink_);
+void PlainEncoder<Int64Type>::put(const ::arrow::Array& values) {
+  directPutImpl<::arrow::Int64Array>(values, &sink_);
 }
 
 template <>
-void PlainEncoder<Int96Type>::Put(const ::arrow::Array& values) {
+void PlainEncoder<Int96Type>::put(const ::arrow::Array& values) {
   ParquetException::NYI("direct put to Int96");
 }
 
 template <>
-void PlainEncoder<FloatType>::Put(const ::arrow::Array& values) {
-  DirectPutImpl<::arrow::FloatArray>(values, &sink_);
+void PlainEncoder<FloatType>::put(const ::arrow::Array& values) {
+  directPutImpl<::arrow::FloatArray>(values, &sink_);
 }
 
 template <>
-void PlainEncoder<DoubleType>::Put(const ::arrow::Array& values) {
-  DirectPutImpl<::arrow::DoubleArray>(values, &sink_);
+void PlainEncoder<DoubleType>::put(const ::arrow::Array& values) {
+  directPutImpl<::arrow::DoubleArray>(values, &sink_);
 }
 
 template <typename DType>
-void PlainEncoder<DType>::Put(const ::arrow::Array& values) {
+void PlainEncoder<DType>::put(const ::arrow::Array& values) {
   ParquetException::NYI("direct put of " + values.type()->ToString());
 }
 
-void AssertBaseBinary(const ::arrow::Array& values) {
+void assertBaseBinary(const ::arrow::Array& values) {
   if (!::arrow::is_base_binary_like(values.type_id())) {
     throw ParquetException("Only BaseBinaryArray and subclasses supported");
   }
 }
 
 template <>
-inline void PlainEncoder<ByteArrayType>::Put(const ::arrow::Array& values) {
-  AssertBaseBinary(values);
+inline void PlainEncoder<ByteArrayType>::put(const ::arrow::Array& values) {
+  assertBaseBinary(values);
 
   if (::arrow::is_binary_like(values.type_id())) {
-    PutBinaryArray(checked_cast<const ::arrow::BinaryArray&>(values));
+    putBinaryArray(checked_cast<const ::arrow::BinaryArray&>(values));
   } else {
     VELOX_DCHECK(::arrow::is_large_binary_like(values.type_id()));
-    PutBinaryArray(checked_cast<const ::arrow::LargeBinaryArray&>(values));
+    putBinaryArray(checked_cast<const ::arrow::LargeBinaryArray&>(values));
   }
 }
 
-void AssertFixedSizeBinary(const ::arrow::Array& values, int type_length) {
+void assertFixedSizeBinary(const ::arrow::Array& values, int typeLength) {
   if (values.type_id() != ::arrow::Type::FIXED_SIZE_BINARY &&
-      values.type_id() != ::arrow::Type::DECIMAL) {
+      values.type_id() != ::arrow::Type::DECIMAL128 &&
+      values.type_id() != ::arrow::Type::DECIMAL256) {
     throw ParquetException(
         "Only FixedSizeBinaryArray and subclasses supported");
   }
   if (checked_cast<const ::arrow::FixedSizeBinaryType&>(*values.type())
-          .byte_width() != type_length) {
+          .byte_width() != typeLength) {
     throw ParquetException(
         "Size mismatch: " + values.type()->ToString() + " should have been " +
-        std::to_string(type_length) + " wide");
+        std::to_string(typeLength) + " wide");
   }
 }
 
 template <>
-inline void PlainEncoder<FLBAType>::Put(const ::arrow::Array& values) {
-  AssertFixedSizeBinary(values, descr_->type_length());
+inline void PlainEncoder<FLBAType>::put(const ::arrow::Array& values) {
+  assertFixedSizeBinary(values, descr_->typeLength());
   const auto& data = checked_cast<const ::arrow::FixedSizeBinaryArray&>(values);
 
   if (data.null_count() == 0) {
-    // no nulls, just dump the data
+    // No nulls, just dump the data.
     PARQUET_THROW_NOT_OK(
         sink_.Append(data.raw_values(), data.length() * data.byte_width()));
   } else {
-    const int64_t total_bytes = data.length() * data.byte_width() -
+    const int64_t totalBytes = data.length() * data.byte_width() -
         data.null_count() * data.byte_width();
-    PARQUET_THROW_NOT_OK(sink_.Reserve(total_bytes));
+    PARQUET_THROW_NOT_OK(sink_.Reserve(totalBytes));
     for (int64_t i = 0; i < data.length(); i++) {
       if (data.IsValid(i)) {
         sink_.UnsafeAppend(data.Value(i), data.byte_width());
@@ -343,16 +340,16 @@ inline void PlainEncoder<FLBAType>::Put(const ::arrow::Array& values) {
 }
 
 template <>
-inline void PlainEncoder<FLBAType>::Put(
+inline void PlainEncoder<FLBAType>::put(
     const FixedLenByteArray* src,
-    int num_values) {
-  if (descr_->type_length() == 0) {
+    int numValues) {
+  if (descr_->typeLength() == 0) {
     return;
   }
-  for (int i = 0; i < num_values; ++i) {
-    // Write the result to the output stream
+  for (int i = 0; i < numValues; ++i) {
+    // Write the result to the output stream.
     VELOX_DCHECK(src[i].ptr != nullptr, "Value ptr cannot be NULL");
-    PARQUET_THROW_NOT_OK(sink_.Append(src[i].ptr, descr_->type_length()));
+    PARQUET_THROW_NOT_OK(sink_.Append(src[i].ptr, descr_->typeLength()));
   }
 }
 
@@ -361,34 +358,32 @@ class PlainEncoder<BooleanType> : public EncoderImpl,
                                   virtual public BooleanEncoder {
  public:
   explicit PlainEncoder(const ColumnDescriptor* descr, MemoryPool* pool)
-      : EncoderImpl(descr, Encoding::PLAIN, pool), sink_(pool) {}
+      : EncoderImpl(descr, Encoding::kPlain, pool), sink_(pool) {}
 
-  int64_t EstimatedDataEncodedSize() override;
-  std::shared_ptr<::arrow::Buffer> FlushValues() override;
+  int64_t estimatedDataEncodedSize() override;
+  std::shared_ptr<::arrow::Buffer> flushValues() override;
 
-  void Put(const bool* src, int num_values) override;
+  void put(const bool* src, int numValues) override;
 
-  void Put(const std::vector<bool>& src, int num_values) override;
+  void put(const std::vector<bool>& src, int numValues) override;
 
-  void PutSpaced(
+  void putSpaced(
       const bool* src,
-      int num_values,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset) override {
-    if (valid_bits != NULLPTR) {
-      PARQUET_ASSIGN_OR_THROW(
-          auto buffer,
-          ::arrow::AllocateBuffer(num_values * sizeof(T), this->memory_pool()));
+      int numValues,
+      const uint8_t* validBits,
+      int64_t validBitsOffset) override {
+    if (validBits != NULLPTR) {
+      auto buffer = allocateBuffer(this->memoryPool(), numValues * sizeof(T));
       T* data = reinterpret_cast<T*>(buffer->mutable_data());
-      int num_valid_values = ::arrow::util::internal::SpacedCompress<T>(
-          src, num_values, valid_bits, valid_bits_offset, data);
-      Put(data, num_valid_values);
+      int numValidValues = ::arrow::util::internal::SpacedCompress<T>(
+          src, numValues, validBits, validBitsOffset, data);
+      put(data, numValidValues);
     } else {
-      Put(src, num_values);
+      put(src, numValues);
     }
   }
 
-  void Put(const ::arrow::Array& values) override {
+  void put(const ::arrow::Array& values) override {
     if (values.type_id() != ::arrow::Type::BOOL) {
       throw ParquetException(
           "direct put to boolean from " + values.type()->ToString() +
@@ -397,7 +392,7 @@ class PlainEncoder<BooleanType> : public EncoderImpl,
     const auto& data = checked_cast<const ::arrow::BooleanArray&>(values);
 
     if (data.null_count() == 0) {
-      // no nulls, just dump the data
+      // No nulls, just dump the data.
       PARQUET_THROW_NOT_OK(sink_.Reserve(data.length()));
       sink_.UnsafeAppend(
           data.data()->GetValues<uint8_t>(1, 0), data.offset(), data.length());
@@ -415,46 +410,46 @@ class PlainEncoder<BooleanType> : public EncoderImpl,
   ::arrow::TypedBufferBuilder<bool> sink_;
 
   template <typename SequenceType>
-  void PutImpl(const SequenceType& src, int num_values);
+  void putImpl(const SequenceType& src, int numValues);
 };
 
 template <typename SequenceType>
-void PlainEncoder<BooleanType>::PutImpl(
+void PlainEncoder<BooleanType>::putImpl(
     const SequenceType& src,
-    int num_values) {
-  PARQUET_THROW_NOT_OK(sink_.Reserve(num_values));
-  for (int i = 0; i < num_values; ++i) {
+    int numValues) {
+  PARQUET_THROW_NOT_OK(sink_.Reserve(numValues));
+  for (int i = 0; i < numValues; ++i) {
     sink_.UnsafeAppend(src[i]);
   }
 }
 
-int64_t PlainEncoder<BooleanType>::EstimatedDataEncodedSize() {
+int64_t PlainEncoder<BooleanType>::estimatedDataEncodedSize() {
   return ::arrow::bit_util::BytesForBits(sink_.length());
 }
 
-std::shared_ptr<::arrow::Buffer> PlainEncoder<BooleanType>::FlushValues() {
+std::shared_ptr<::arrow::Buffer> PlainEncoder<BooleanType>::flushValues() {
   std::shared_ptr<Buffer> buffer;
   PARQUET_THROW_NOT_OK(sink_.Finish(&buffer));
   return buffer;
 }
 
-void PlainEncoder<BooleanType>::Put(const bool* src, int num_values) {
-  PutImpl(src, num_values);
+void PlainEncoder<BooleanType>::put(const bool* src, int numValues) {
+  putImpl(src, numValues);
 }
 
-void PlainEncoder<BooleanType>::Put(
+void PlainEncoder<BooleanType>::put(
     const std::vector<bool>& src,
-    int num_values) {
-  PutImpl(src, num_values);
+    int numValues) {
+  putImpl(src, numValues);
 }
 
-// ----------------------------------------------------------------------
-// DictEncoder<T> implementations
+// ----------------------------------------------------------------------.
+// DictEncoder<T> implementations.
 
 template <typename DType>
 struct DictEncoderTraits {
-  using c_type = typename DType::c_type;
-  using MemoTableType = arrow::internal::ScalarMemoTable<c_type>;
+  using CType = typename DType::CType;
+  using MemoTableType = arrow::internal::ScalarMemoTable<CType>;
 };
 
 template <>
@@ -469,16 +464,16 @@ struct DictEncoderTraits<FLBAType> {
       arrow::internal::BinaryMemoTable<::arrow::BinaryBuilder>;
 };
 
-// Initially 1024 elements
+// Initially 1024 elements.
 static constexpr int32_t kInitialHashTableSize = 1 << 10;
 
-int RlePreserveBufferSize(int num_values, int bit_width) {
+int rlePreserveBufferSize(int numValues, int bitWidth) {
   // Note: because of the way RleEncoder::CheckBufferFull()
-  // is called, we have to reserve an extra "RleEncoder::MinBufferSize"
+  // is called, we have to Reserve an extra "RleEncoder::MinBufferSize"
   // bytes. These extra bytes won't be used but not reserving them
   // would cause the encoder to fail.
-  return RleEncoder::MaxBufferSize(bit_width, num_values) +
-      RleEncoder::MinBufferSize(bit_width);
+  return RleEncoder::MaxBufferSize(bitWidth, numValues) +
+      RleEncoder::MinBufferSize(bitWidth);
 }
 
 /// See the dictionary encoding section of
@@ -493,103 +488,103 @@ class DictEncoderImpl : public EncoderImpl, virtual public DictEncoder<DType> {
   using MemoTableType = typename DictEncoderTraits<DType>::MemoTableType;
 
  public:
-  typedef typename DType::c_type T;
+  typedef typename DType::CType T;
 
   /// In data page, the bit width used to encode the entry
   /// ids stored as 1 byte (max bit width = 32).
   constexpr static int32_t kDataPageBitWidthBytes = 1;
 
   explicit DictEncoderImpl(const ColumnDescriptor* desc, MemoryPool* pool)
-      : EncoderImpl(desc, Encoding::PLAIN_DICTIONARY, pool),
-        buffered_indices_(::arrow::stl::allocator<int32_t>(pool)),
-        dict_encoded_size_(0),
-        memo_table_(pool, kInitialHashTableSize) {}
+      : EncoderImpl(desc, Encoding::kPlainDictionary, pool),
+        bufferedIndices_(::arrow::stl::allocator<int32_t>(pool)),
+        dictEncodedSize_(0),
+        memoTable_(pool, kInitialHashTableSize) {}
 
   ~DictEncoderImpl() = default;
 
-  int dict_encoded_size() const override {
-    return dict_encoded_size_;
+  int dictEncodedSize() const override {
+    return dictEncodedSize_;
   }
 
-  int WriteIndices(uint8_t* buffer, int buffer_len) override {
-    // Write bit width in first byte
-    *buffer = static_cast<uint8_t>(bit_width());
+  int writeIndices(uint8_t* buffer, int bufferLen) override {
+    // Write bit width in first byte.
+    *buffer = static_cast<uint8_t>(bitWidth());
     ++buffer;
-    --buffer_len;
+    --bufferLen;
 
-    RleEncoder encoder(buffer, buffer_len, bit_width());
+    RleEncoder encoder(buffer, bufferLen, bitWidth());
 
-    for (int32_t index : buffered_indices_) {
+    for (int32_t index : bufferedIndices_) {
       if (ARROW_PREDICT_FALSE(!encoder.Put(index)))
         return -1;
     }
     encoder.Flush();
 
-    ClearIndices();
+    clearIndices();
     return kDataPageBitWidthBytes + encoder.len();
   }
 
-  void set_type_length(int type_length) {
-    this->type_length_ = type_length;
+  void setTypeLength(int typeLength) {
+    this->typeLength_ = typeLength;
   }
 
   /// Returns a conservative estimate of the number of bytes needed to encode
   /// the buffered indices. Used to size the buffer passed to WriteIndices().
-  int64_t EstimatedDataEncodedSize() override {
+  int64_t estimatedDataEncodedSize() override {
     return kDataPageBitWidthBytes +
-        RlePreserveBufferSize(
-               static_cast<int>(buffered_indices_.size()), bit_width());
+        rlePreserveBufferSize(
+               static_cast<int>(bufferedIndices_.size()), bitWidth());
   }
 
   /// The minimum bit width required to encode the currently buffered indices.
-  int bit_width() const override {
-    if (ARROW_PREDICT_FALSE(num_entries() == 0))
+  int bitWidth() const override {
+    if (ARROW_PREDICT_FALSE(numEntries() == 0))
       return 0;
-    if (ARROW_PREDICT_FALSE(num_entries() == 1))
+    if (ARROW_PREDICT_FALSE(numEntries() == 1))
       return 1;
-    return ::arrow::bit_util::Log2(num_entries());
+    return ::arrow::bit_util::Log2(numEntries());
   }
 
   /// Encode value. Note that this does not actually write any data, just
   /// buffers the value's index to be written later.
-  inline void Put(const T& value);
+  inline void put(const T& value);
 
-  // Not implemented for other data types
-  inline void PutByteArray(const void* ptr, int32_t length);
+  // Not implemented for other data types.
+  inline void putByteArray(const void* ptr, int32_t length);
 
-  void Put(const T* src, int num_values) override {
-    for (int32_t i = 0; i < num_values; i++) {
-      Put(SafeLoad(src + i));
+  void put(const T* src, int numValues) override {
+    for (int32_t i = 0; i < numValues; i++) {
+      put(safeLoad(src + i));
     }
   }
 
-  void PutSpaced(
+  void putSpaced(
       const T* src,
-      int num_values,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset) override {
+      int numValues,
+      const uint8_t* validBits,
+      int64_t validBitsOffset) override {
     ::arrow::internal::VisitSetBitRunsVoid(
-        valid_bits,
-        valid_bits_offset,
-        num_values,
+        validBits,
+        validBitsOffset,
+        numValues,
         [&](int64_t position, int64_t length) {
           for (int64_t i = 0; i < length; i++) {
-            Put(SafeLoad(src + i + position));
+            put(safeLoad(src + i + position));
           }
         });
   }
 
-  using TypedEncoder<DType>::Put;
+  using TypedEncoder<DType>::put;
 
-  void Put(const ::arrow::Array& values) override;
-  void PutDictionary(const ::arrow::Array& values) override;
+  void put(const ::arrow::Array& values) override;
+  void putDictionary(const ::arrow::Array& values) override;
 
   template <typename ArrowType, typename T = typename ArrowType::c_type>
-  void PutIndicesTyped(const ::arrow::Array& data) {
+  void putIndicesTyped(const ::arrow::Array& data) {
     auto values = data.data()->GetValues<T>(1);
-    size_t buffer_position = buffered_indices_.size();
-    buffered_indices_.resize(
-        buffer_position +
+    size_t bufferPosition = bufferedIndices_.size();
+    bufferedIndices_.resize(
+        bufferPosition +
         static_cast<size_t>(data.length() - data.null_count()));
     ::arrow::internal::VisitSetBitRunsVoid(
         data.null_bitmap_data(),
@@ -597,60 +592,60 @@ class DictEncoderImpl : public EncoderImpl, virtual public DictEncoder<DType> {
         data.length(),
         [&](int64_t position, int64_t length) {
           for (int64_t i = 0; i < length; ++i) {
-            buffered_indices_[buffer_position++] =
+            bufferedIndices_[bufferPosition++] =
                 static_cast<int32_t>(values[i + position]);
           }
         });
   }
 
-  void PutIndices(const ::arrow::Array& data) override {
+  void putIndices(const ::arrow::Array& data) override {
     switch (data.type()->id()) {
       case ::arrow::Type::UINT8:
       case ::arrow::Type::INT8:
-        return PutIndicesTyped<::arrow::UInt8Type>(data);
+        return putIndicesTyped<::arrow::UInt8Type>(data);
       case ::arrow::Type::UINT16:
       case ::arrow::Type::INT16:
-        return PutIndicesTyped<::arrow::UInt16Type>(data);
+        return putIndicesTyped<::arrow::UInt16Type>(data);
       case ::arrow::Type::UINT32:
       case ::arrow::Type::INT32:
-        return PutIndicesTyped<::arrow::UInt32Type>(data);
+        return putIndicesTyped<::arrow::UInt32Type>(data);
       case ::arrow::Type::UINT64:
       case ::arrow::Type::INT64:
-        return PutIndicesTyped<::arrow::UInt64Type>(data);
+        return putIndicesTyped<::arrow::UInt64Type>(data);
       default:
         throw ParquetException("Passed non-integer array to PutIndices");
     }
   }
 
-  std::shared_ptr<::arrow::Buffer> FlushValues() override {
+  std::shared_ptr<::arrow::Buffer> flushValues() override {
     std::shared_ptr<ResizableBuffer> buffer =
-        AllocateBuffer(this->pool_, EstimatedDataEncodedSize());
-    int result_size = WriteIndices(
-        buffer->mutable_data(), static_cast<int>(EstimatedDataEncodedSize()));
-    PARQUET_THROW_NOT_OK(buffer->Resize(result_size, false));
+        allocateBuffer(this->pool_, estimatedDataEncodedSize());
+    int resultSize = writeIndices(
+        buffer->mutable_data(), static_cast<int>(estimatedDataEncodedSize()));
+    PARQUET_THROW_NOT_OK(buffer->Resize(resultSize, false));
     return std::move(buffer);
   }
 
   /// Writes out the encoded dictionary to buffer. buffer must be preallocated
   /// to dict_encoded_size() bytes.
-  void WriteDict(uint8_t* buffer) const override;
+  void writeDict(uint8_t* buffer) const override;
 
   /// The number of entries in the dictionary.
-  int num_entries() const override {
-    return memo_table_.size();
+  int numEntries() const override {
+    return memoTable_.size();
   }
 
  private:
   /// Clears all the indices (but leaves the dictionary).
-  void ClearIndices() {
-    buffered_indices_.clear();
+  void clearIndices() {
+    bufferedIndices_.clear();
   }
 
   /// Indices that have not yet be written out by WriteIndices().
-  ArrowPoolVector<int32_t> buffered_indices_;
+  ArrowPoolVector<int32_t> bufferedIndices_;
 
   template <typename ArrayType>
-  void PutBinaryArray(const ArrayType& array) {
+  void putBinaryArray(const ArrayType& array) {
     PARQUET_THROW_NOT_OK(
         ::arrow::VisitArraySpanInline<typename ArrayType::TypeClass>(
             *array.data(),
@@ -659,14 +654,14 @@ class DictEncoderImpl : public EncoderImpl, virtual public DictEncoder<DType> {
                 return Status::Invalid(
                     "Parquet cannot store strings with size 2GB or more");
               }
-              PutByteArray(view.data(), static_cast<uint32_t>(view.size()));
+              putByteArray(view.data(), static_cast<uint32_t>(view.size()));
               return Status::OK();
             },
             []() { return Status::OK(); }));
   }
 
   template <typename ArrayType>
-  void PutBinaryDictionaryArray(const ArrayType& array) {
+  void putBinaryDictionaryArray(const ArrayType& array) {
     VELOX_DCHECK_EQ(array.null_count(), 0);
     for (int64_t i = 0; i < array.length(); i++) {
       auto v = array.GetView(i);
@@ -674,31 +669,31 @@ class DictEncoderImpl : public EncoderImpl, virtual public DictEncoder<DType> {
         throw ParquetException(
             "Parquet cannot store strings with size 2GB or more");
       }
-      dict_encoded_size_ += static_cast<int>(v.size() + sizeof(uint32_t));
-      int32_t unused_memo_index;
-      PARQUET_THROW_NOT_OK(memo_table_.GetOrInsert(
-          v.data(), static_cast<int32_t>(v.size()), &unused_memo_index));
+      dictEncodedSize_ += static_cast<int>(v.size() + sizeof(uint32_t));
+      int32_t unusedMemoIndex;
+      PARQUET_THROW_NOT_OK(memoTable_.getOrInsert(
+          v.data(), static_cast<int32_t>(v.size()), &unusedMemoIndex));
     }
   }
 
   /// The number of bytes needed to encode the dictionary.
-  int dict_encoded_size_;
+  int dictEncodedSize_;
 
-  MemoTableType memo_table_;
+  MemoTableType memoTable_;
 };
 
 template <typename DType>
-void DictEncoderImpl<DType>::WriteDict(uint8_t* buffer) const {
-  // For primitive types, only a memcpy
+void DictEncoderImpl<DType>::writeDict(uint8_t* buffer) const {
+  // For primitive types, only a memcpy.
   VELOX_DCHECK_EQ(
-      static_cast<size_t>(dict_encoded_size_), sizeof(T) * memo_table_.size());
-  memo_table_.CopyValues(0 /* start_pos */, reinterpret_cast<T*>(buffer));
+      static_cast<size_t>(dictEncodedSize_), sizeof(T) * memoTable_.size());
+  memoTable_.copyValues(0 /* start_pos */, reinterpret_cast<T*>(buffer));
 }
 
-// ByteArray and FLBA already have the dictionary encoded in their data heaps
+// ByteArray and FLBA already have the dictionary encoded in their data heaps.
 template <>
-void DictEncoderImpl<ByteArrayType>::WriteDict(uint8_t* buffer) const {
-  memo_table_.VisitValues(0, [&buffer](std::string_view v) {
+void DictEncoderImpl<ByteArrayType>::writeDict(uint8_t* buffer) const {
+  memoTable_.visitValues(0, [&buffer](std::string_view v) {
     uint32_t len = static_cast<uint32_t>(v.length());
     memcpy(buffer, &len, sizeof(len));
     buffer += sizeof(len);
@@ -708,231 +703,231 @@ void DictEncoderImpl<ByteArrayType>::WriteDict(uint8_t* buffer) const {
 }
 
 template <>
-void DictEncoderImpl<FLBAType>::WriteDict(uint8_t* buffer) const {
-  memo_table_.VisitValues(0, [&](std::string_view v) {
-    VELOX_DCHECK_EQ(v.length(), static_cast<size_t>(type_length_));
-    memcpy(buffer, v.data(), type_length_);
-    buffer += type_length_;
+void DictEncoderImpl<FLBAType>::writeDict(uint8_t* buffer) const {
+  memoTable_.visitValues(0, [&](std::string_view v) {
+    VELOX_DCHECK_EQ(v.length(), static_cast<size_t>(typeLength_));
+    memcpy(buffer, v.data(), typeLength_);
+    buffer += typeLength_;
   });
 }
 
 template <typename DType>
-inline void DictEncoderImpl<DType>::Put(const T& v) {
-  // Put() implementation for primitive types
-  auto on_found = [](int32_t memo_index) {};
-  auto on_not_found = [this](int32_t memo_index) {
-    dict_encoded_size_ += static_cast<int>(sizeof(T));
+inline void DictEncoderImpl<DType>::put(const T& v) {
+  // Put() implementation for primitive types.
+  auto onFound = [](int32_t memoIndex) {};
+  auto onNotFound = [this](int32_t memoIndex) {
+    dictEncodedSize_ += static_cast<int>(sizeof(T));
   };
 
-  int32_t memo_index;
+  int32_t memoIndex;
   PARQUET_THROW_NOT_OK(
-      memo_table_.GetOrInsert(v, on_found, on_not_found, &memo_index));
-  buffered_indices_.push_back(memo_index);
+      memoTable_.getOrInsert(v, onFound, onNotFound, &memoIndex));
+  bufferedIndices_.push_back(memoIndex);
 }
 
 template <typename DType>
-inline void DictEncoderImpl<DType>::PutByteArray(
+inline void DictEncoderImpl<DType>::putByteArray(
     const void* ptr,
     int32_t length) {
   VELOX_DCHECK(false);
 }
 
 template <>
-inline void DictEncoderImpl<ByteArrayType>::PutByteArray(
+inline void DictEncoderImpl<ByteArrayType>::putByteArray(
     const void* ptr,
     int32_t length) {
   static const uint8_t empty[] = {0};
 
-  auto on_found = [](int32_t memo_index) {};
-  auto on_not_found = [&](int32_t memo_index) {
-    dict_encoded_size_ += static_cast<int>(length + sizeof(uint32_t));
+  auto onFound = [](int32_t memoIndex) {};
+  auto onNotFound = [&](int32_t memoIndex) {
+    dictEncodedSize_ += static_cast<int>(length + sizeof(uint32_t));
   };
 
   VELOX_DCHECK(ptr != nullptr || length == 0);
   ptr = (ptr != nullptr) ? ptr : empty;
-  int32_t memo_index;
-  PARQUET_THROW_NOT_OK(memo_table_.GetOrInsert(
-      ptr, length, on_found, on_not_found, &memo_index));
-  buffered_indices_.push_back(memo_index);
+  int32_t memoIndex;
+  PARQUET_THROW_NOT_OK(
+      memoTable_.getOrInsert(ptr, length, onFound, onNotFound, &memoIndex));
+  bufferedIndices_.push_back(memoIndex);
 }
 
 template <>
-inline void DictEncoderImpl<ByteArrayType>::Put(const ByteArray& val) {
-  return PutByteArray(val.ptr, static_cast<int32_t>(val.len));
+inline void DictEncoderImpl<ByteArrayType>::put(const ByteArray& val) {
+  return putByteArray(val.ptr, static_cast<int32_t>(val.len));
 }
 
 template <>
-inline void DictEncoderImpl<FLBAType>::Put(const FixedLenByteArray& v) {
+inline void DictEncoderImpl<FLBAType>::put(const FixedLenByteArray& v) {
   static const uint8_t empty[] = {0};
 
-  auto on_found = [](int32_t memo_index) {};
-  auto on_not_found = [this](int32_t memo_index) {
-    dict_encoded_size_ += type_length_;
+  auto onFound = [](int32_t memoIndex) {};
+  auto onNotFound = [this](int32_t memoIndex) {
+    dictEncodedSize_ += typeLength_;
   };
 
-  VELOX_DCHECK(v.ptr != nullptr || type_length_ == 0);
+  VELOX_DCHECK(v.ptr != nullptr || typeLength_ == 0);
   const void* ptr = (v.ptr != nullptr) ? v.ptr : empty;
-  int32_t memo_index;
-  PARQUET_THROW_NOT_OK(memo_table_.GetOrInsert(
-      ptr, type_length_, on_found, on_not_found, &memo_index));
-  buffered_indices_.push_back(memo_index);
+  int32_t memoIndex;
+  PARQUET_THROW_NOT_OK(memoTable_.getOrInsert(
+      ptr, typeLength_, onFound, onNotFound, &memoIndex));
+  bufferedIndices_.push_back(memoIndex);
 }
 
 template <>
-void DictEncoderImpl<Int96Type>::Put(const ::arrow::Array& values) {
+void DictEncoderImpl<Int96Type>::put(const ::arrow::Array& values) {
   ParquetException::NYI("Direct put to Int96");
 }
 
 template <>
-void DictEncoderImpl<Int96Type>::PutDictionary(const ::arrow::Array& values) {
+void DictEncoderImpl<Int96Type>::putDictionary(const ::arrow::Array& values) {
   ParquetException::NYI("Direct put to Int96");
 }
 
 template <typename DType>
-void DictEncoderImpl<DType>::Put(const ::arrow::Array& values) {
+void DictEncoderImpl<DType>::put(const ::arrow::Array& values) {
   using ArrayType =
-      typename ::arrow::CTypeTraits<typename DType::c_type>::ArrayType;
+      typename ::arrow::CTypeTraits<typename DType::CType>::ArrayType;
   const auto& data = checked_cast<const ArrayType&>(values);
   if (data.null_count() == 0) {
-    // no nulls, just dump the data
+    // No nulls, just dump the data.
     for (int64_t i = 0; i < data.length(); i++) {
-      Put(data.Value(i));
+      put(data.Value(i));
     }
   } else {
     for (int64_t i = 0; i < data.length(); i++) {
       if (data.IsValid(i)) {
-        Put(data.Value(i));
+        put(data.Value(i));
       }
     }
   }
 }
 
 template <>
-void DictEncoderImpl<FLBAType>::Put(const ::arrow::Array& values) {
-  AssertFixedSizeBinary(values, type_length_);
+void DictEncoderImpl<FLBAType>::put(const ::arrow::Array& values) {
+  assertFixedSizeBinary(values, typeLength_);
   const auto& data = checked_cast<const ::arrow::FixedSizeBinaryArray&>(values);
   if (data.null_count() == 0) {
-    // no nulls, just dump the data
+    // No nulls, just dump the data.
     for (int64_t i = 0; i < data.length(); i++) {
-      Put(FixedLenByteArray(data.Value(i)));
+      put(FixedLenByteArray(data.Value(i)));
     }
   } else {
-    std::vector<uint8_t> empty(type_length_, 0);
+    std::vector<uint8_t> empty(typeLength_, 0);
     for (int64_t i = 0; i < data.length(); i++) {
       if (data.IsValid(i)) {
-        Put(FixedLenByteArray(data.Value(i)));
+        put(FixedLenByteArray(data.Value(i)));
       }
     }
   }
 }
 
 template <>
-void DictEncoderImpl<ByteArrayType>::Put(const ::arrow::Array& values) {
-  AssertBaseBinary(values);
+void DictEncoderImpl<ByteArrayType>::put(const ::arrow::Array& values) {
+  assertBaseBinary(values);
   if (::arrow::is_binary_like(values.type_id())) {
-    PutBinaryArray(checked_cast<const ::arrow::BinaryArray&>(values));
+    putBinaryArray(checked_cast<const ::arrow::BinaryArray&>(values));
   } else {
     VELOX_DCHECK(::arrow::is_large_binary_like(values.type_id()));
-    PutBinaryArray(checked_cast<const ::arrow::LargeBinaryArray&>(values));
+    putBinaryArray(checked_cast<const ::arrow::LargeBinaryArray&>(values));
   }
 }
 
 template <typename DType>
-void AssertCanPutDictionary(
+void assertCanPutDictionary(
     DictEncoderImpl<DType>* encoder,
     const ::arrow::Array& dict) {
   if (dict.null_count() > 0) {
     throw ParquetException("Inserted dictionary cannot cannot contain nulls");
   }
 
-  if (encoder->num_entries() > 0) {
+  if (encoder->numEntries() > 0) {
     throw ParquetException(
         "Can only call PutDictionary on an empty DictEncoder");
   }
 }
 
 template <typename DType>
-void DictEncoderImpl<DType>::PutDictionary(const ::arrow::Array& values) {
-  AssertCanPutDictionary(this, values);
+void DictEncoderImpl<DType>::putDictionary(const ::arrow::Array& values) {
+  assertCanPutDictionary(this, values);
 
   using ArrayType =
-      typename ::arrow::CTypeTraits<typename DType::c_type>::ArrayType;
+      typename ::arrow::CTypeTraits<typename DType::CType>::ArrayType;
   const auto& data = checked_cast<const ArrayType&>(values);
 
-  dict_encoded_size_ +=
-      static_cast<int>(sizeof(typename DType::c_type) * data.length());
+  dictEncodedSize_ +=
+      static_cast<int>(sizeof(typename DType::CType) * data.length());
   for (int64_t i = 0; i < data.length(); i++) {
-    int32_t unused_memo_index;
+    int32_t unusedMemoIndex;
     PARQUET_THROW_NOT_OK(
-        memo_table_.GetOrInsert(data.Value(i), &unused_memo_index));
+        memoTable_.getOrInsert(data.Value(i), &unusedMemoIndex));
   }
 }
 
 template <>
-void DictEncoderImpl<FLBAType>::PutDictionary(const ::arrow::Array& values) {
-  AssertFixedSizeBinary(values, type_length_);
-  AssertCanPutDictionary(this, values);
+void DictEncoderImpl<FLBAType>::putDictionary(const ::arrow::Array& values) {
+  assertFixedSizeBinary(values, typeLength_);
+  assertCanPutDictionary(this, values);
 
   const auto& data = checked_cast<const ::arrow::FixedSizeBinaryArray&>(values);
 
-  dict_encoded_size_ += static_cast<int>(type_length_ * data.length());
+  dictEncodedSize_ += static_cast<int>(typeLength_ * data.length());
   for (int64_t i = 0; i < data.length(); i++) {
-    int32_t unused_memo_index;
-    PARQUET_THROW_NOT_OK(memo_table_.GetOrInsert(
-        data.Value(i), type_length_, &unused_memo_index));
+    int32_t unusedMemoIndex;
+    PARQUET_THROW_NOT_OK(
+        memoTable_.getOrInsert(data.Value(i), typeLength_, &unusedMemoIndex));
   }
 }
 
 template <>
-void DictEncoderImpl<ByteArrayType>::PutDictionary(
+void DictEncoderImpl<ByteArrayType>::putDictionary(
     const ::arrow::Array& values) {
-  AssertBaseBinary(values);
-  AssertCanPutDictionary(this, values);
+  assertBaseBinary(values);
+  assertCanPutDictionary(this, values);
 
   if (::arrow::is_binary_like(values.type_id())) {
-    PutBinaryDictionaryArray(checked_cast<const ::arrow::BinaryArray&>(values));
+    putBinaryDictionaryArray(checked_cast<const ::arrow::BinaryArray&>(values));
   } else {
     VELOX_DCHECK(::arrow::is_large_binary_like(values.type_id()));
-    PutBinaryDictionaryArray(
+    putBinaryDictionaryArray(
         checked_cast<const ::arrow::LargeBinaryArray&>(values));
   }
 }
 
-// ----------------------------------------------------------------------
-// ByteStreamSplitEncoder<T> implementations
+// ----------------------------------------------------------------------.
+// ByteStreamSplitEncoder<T> implementations.
 
 template <typename DType>
 class ByteStreamSplitEncoder : public EncoderImpl,
                                virtual public TypedEncoder<DType> {
  public:
-  using T = typename DType::c_type;
-  using TypedEncoder<DType>::Put;
+  using T = typename DType::CType;
+  using TypedEncoder<DType>::put;
 
   explicit ByteStreamSplitEncoder(
       const ColumnDescriptor* descr,
       ::arrow::MemoryPool* pool = ::arrow::default_memory_pool());
 
-  int64_t EstimatedDataEncodedSize() override;
-  std::shared_ptr<::arrow::Buffer> FlushValues() override;
+  int64_t estimatedDataEncodedSize() override;
+  std::shared_ptr<::arrow::Buffer> flushValues() override;
 
-  void Put(const T* buffer, int num_values) override;
-  void Put(const ::arrow::Array& values) override;
-  void PutSpaced(
+  void put(const T* buffer, int numValues) override;
+  void put(const ::arrow::Array& values) override;
+  void putSpaced(
       const T* src,
-      int num_values,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset) override;
+      int numValues,
+      const uint8_t* validBits,
+      int64_t validBitsOffset) override;
 
  protected:
   template <typename ArrowType>
-  void PutImpl(const ::arrow::Array& values) {
+  void putImpl(const ::arrow::Array& values) {
     if (values.type_id() != ArrowType::type_id) {
       throw ParquetException(
           std::string() + "direct put to " + ArrowType::type_name() + " from " +
           values.type()->ToString() + " not supported");
     }
     const auto& data = *values.data();
-    PutSpaced(
+    putSpaced(
         data.GetValues<typename ArrowType::c_type>(1),
         static_cast<int>(data.length),
         data.GetValues<uint8_t>(0, 0),
@@ -940,82 +935,79 @@ class ByteStreamSplitEncoder : public EncoderImpl,
   }
 
   ::arrow::BufferBuilder sink_;
-  int64_t num_values_in_buffer_;
+  int64_t numValuesInBuffer_;
 };
 
 template <typename DType>
 ByteStreamSplitEncoder<DType>::ByteStreamSplitEncoder(
     const ColumnDescriptor* descr,
     ::arrow::MemoryPool* pool)
-    : EncoderImpl(descr, Encoding::BYTE_STREAM_SPLIT, pool),
+    : EncoderImpl(descr, Encoding::kByteStreamSplit, pool),
       sink_{pool},
-      num_values_in_buffer_{0} {}
+      numValuesInBuffer_{0} {}
 
 template <typename DType>
-int64_t ByteStreamSplitEncoder<DType>::EstimatedDataEncodedSize() {
+int64_t ByteStreamSplitEncoder<DType>::estimatedDataEncodedSize() {
   return sink_.length();
 }
 
 template <typename DType>
-std::shared_ptr<::arrow::Buffer> ByteStreamSplitEncoder<DType>::FlushValues() {
-  std::shared_ptr<ResizableBuffer> output_buffer =
-      AllocateBuffer(this->memory_pool(), EstimatedDataEncodedSize());
-  uint8_t* output_buffer_raw = output_buffer->mutable_data();
-  const uint8_t* raw_values = sink_.data();
-  ByteStreamSplitEncode<T>(
-      raw_values, num_values_in_buffer_, output_buffer_raw);
+std::shared_ptr<::arrow::Buffer> ByteStreamSplitEncoder<DType>::flushValues() {
+  std::shared_ptr<ResizableBuffer> outputBuffer =
+      allocateBuffer(this->memoryPool(), estimatedDataEncodedSize());
+  uint8_t* outputBufferRaw = outputBuffer->mutable_data();
+  const uint8_t* rawValues = sink_.data();
+  byteStreamSplitEncode<T>(rawValues, numValuesInBuffer_, outputBufferRaw);
   sink_.Reset();
-  num_values_in_buffer_ = 0;
-  return std::move(output_buffer);
+  numValuesInBuffer_ = 0;
+  return std::move(outputBuffer);
 }
 
 template <typename DType>
-void ByteStreamSplitEncoder<DType>::Put(const T* buffer, int num_values) {
-  if (num_values > 0) {
-    PARQUET_THROW_NOT_OK(sink_.Append(buffer, num_values * sizeof(T)));
-    num_values_in_buffer_ += num_values;
+void ByteStreamSplitEncoder<DType>::put(const T* buffer, int numValues) {
+  if (numValues > 0) {
+    PARQUET_THROW_NOT_OK(sink_.Append(buffer, numValues * sizeof(T)));
+    numValuesInBuffer_ += numValues;
   }
 }
 
 template <>
-void ByteStreamSplitEncoder<FloatType>::Put(const ::arrow::Array& values) {
-  PutImpl<::arrow::FloatType>(values);
+void ByteStreamSplitEncoder<FloatType>::put(const ::arrow::Array& values) {
+  putImpl<::arrow::FloatType>(values);
 }
 
 template <>
-void ByteStreamSplitEncoder<DoubleType>::Put(const ::arrow::Array& values) {
-  PutImpl<::arrow::DoubleType>(values);
+void ByteStreamSplitEncoder<DoubleType>::put(const ::arrow::Array& values) {
+  putImpl<::arrow::DoubleType>(values);
 }
 
 template <typename DType>
-void ByteStreamSplitEncoder<DType>::PutSpaced(
+void ByteStreamSplitEncoder<DType>::putSpaced(
     const T* src,
-    int num_values,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset) {
-  if (valid_bits != NULLPTR) {
-    PARQUET_ASSIGN_OR_THROW(
-        auto buffer,
-        ::arrow::AllocateBuffer(num_values * sizeof(T), this->memory_pool()));
+    int numValues,
+    const uint8_t* validBits,
+    int64_t validBitsOffset) {
+  if (validBits != NULLPTR) {
+    auto buffer = allocateBuffer(this->memoryPool(), numValues * sizeof(T));
     T* data = reinterpret_cast<T*>(buffer->mutable_data());
-    int num_valid_values = ::arrow::util::internal::SpacedCompress<T>(
-        src, num_values, valid_bits, valid_bits_offset, data);
-    Put(data, num_valid_values);
+    int numValidValues = ::arrow::util::internal::SpacedCompress<T>(
+        src, numValues, validBits, validBitsOffset, data);
+    put(data, numValidValues);
   } else {
-    Put(src, num_values);
+    put(src, numValues);
   }
 }
 
 class DecoderImpl : virtual public Decoder {
  public:
-  void SetData(int num_values, const uint8_t* data, int len) override {
-    num_values_ = num_values;
+  void setData(int numValues, const uint8_t* data, int len) override {
+    numValues_ = numValues;
     data_ = data;
     len_ = len;
   }
 
-  int values_left() const override {
-    return num_values_;
+  int valuesLeft() const override {
+    return numValues_;
   }
   Encoding::type encoding() const override {
     return encoding_;
@@ -1025,343 +1017,340 @@ class DecoderImpl : virtual public Decoder {
   explicit DecoderImpl(const ColumnDescriptor* descr, Encoding::type encoding)
       : descr_(descr),
         encoding_(encoding),
-        num_values_(0),
+        numValues_(0),
         data_(NULLPTR),
         len_(0) {}
 
-  // For accessing type-specific metadata, like FIXED_LEN_BYTE_ARRAY
+  // For accessing type-specific metadata, like FIXED_LEN_BYTE_ARRAY.
   const ColumnDescriptor* descr_;
 
   const Encoding::type encoding_;
-  int num_values_;
+  int numValues_;
   const uint8_t* data_;
   int len_;
-  int type_length_;
+  int typeLength_;
 };
 
 template <typename DType>
 class PlainDecoder : public DecoderImpl, virtual public TypedDecoder<DType> {
  public:
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
   explicit PlainDecoder(const ColumnDescriptor* descr);
 
-  int Decode(T* buffer, int max_values) override;
-
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      typename EncodingTraits<DType>::Accumulator* builder) override;
-
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      typename EncodingTraits<DType>::DictAccumulator* builder) override;
+  int decode(T* buffer, int maxValues) override;
+
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      typename EncodingTraits<DType>::Accumulator* Builder) override;
+
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      typename EncodingTraits<DType>::DictAccumulator* Builder) override;
 };
 
 template <>
-inline int PlainDecoder<Int96Type>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<Int96Type>::Accumulator* builder) {
+inline int PlainDecoder<Int96Type>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<Int96Type>::Accumulator* Builder) {
   ParquetException::NYI("DecodeArrow not supported for Int96");
 }
 
 template <>
-inline int PlainDecoder<Int96Type>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<Int96Type>::DictAccumulator* builder) {
+inline int PlainDecoder<Int96Type>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<Int96Type>::DictAccumulator* Builder) {
   ParquetException::NYI("DecodeArrow not supported for Int96");
 }
 
 template <>
-inline int PlainDecoder<BooleanType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<BooleanType>::DictAccumulator* builder) {
+inline int PlainDecoder<BooleanType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<BooleanType>::DictAccumulator* Builder) {
   ParquetException::NYI("dictionaries of BooleanType");
 }
 
 template <typename DType>
-int PlainDecoder<DType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<DType>::Accumulator* builder) {
-  using value_type = typename DType::c_type;
+int PlainDecoder<DType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<DType>::Accumulator* Builder) {
+  using ValueType = typename DType::CType;
 
-  constexpr int value_size = static_cast<int>(sizeof(value_type));
-  int values_decoded = num_values - null_count;
-  if (ARROW_PREDICT_FALSE(len_ < value_size * values_decoded)) {
-    ParquetException::EofException();
+  constexpr int valueSize = static_cast<int>(sizeof(ValueType));
+  int valuesDecoded = numValues - nullCount;
+  if (ARROW_PREDICT_FALSE(len_ < valueSize * valuesDecoded)) {
+    ParquetException::eofException();
   }
 
-  PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
+  PARQUET_THROW_NOT_OK(Builder->Reserve(numValues));
 
   VisitNullBitmapInline(
-      valid_bits,
-      valid_bits_offset,
-      num_values,
-      null_count,
+      validBits,
+      validBitsOffset,
+      numValues,
+      nullCount,
       [&]() {
-        builder->UnsafeAppend(SafeLoadAs<value_type>(data_));
-        data_ += sizeof(value_type);
+        Builder->UnsafeAppend(SafeLoadAs<ValueType>(data_));
+        data_ += sizeof(ValueType);
       },
-      [&]() { builder->UnsafeAppendNull(); });
+      [&]() { Builder->UnsafeAppendNull(); });
 
-  num_values_ -= values_decoded;
-  len_ -= sizeof(value_type) * values_decoded;
-  return values_decoded;
+  numValues_ -= valuesDecoded;
+  len_ -= sizeof(ValueType) * valuesDecoded;
+  return valuesDecoded;
 }
 
 template <typename DType>
-int PlainDecoder<DType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<DType>::DictAccumulator* builder) {
-  using value_type = typename DType::c_type;
+int PlainDecoder<DType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<DType>::DictAccumulator* Builder) {
+  using ValueType = typename DType::CType;
 
-  constexpr int value_size = static_cast<int>(sizeof(value_type));
-  int values_decoded = num_values - null_count;
-  if (ARROW_PREDICT_FALSE(len_ < value_size * values_decoded)) {
-    ParquetException::EofException();
+  constexpr int valueSize = static_cast<int>(sizeof(ValueType));
+  int valuesDecoded = numValues - nullCount;
+  if (ARROW_PREDICT_FALSE(len_ < valueSize * valuesDecoded)) {
+    ParquetException::eofException();
   }
 
-  PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
+  PARQUET_THROW_NOT_OK(Builder->Reserve(numValues));
 
   VisitNullBitmapInline(
-      valid_bits,
-      valid_bits_offset,
-      num_values,
-      null_count,
+      validBits,
+      validBitsOffset,
+      numValues,
+      nullCount,
       [&]() {
-        PARQUET_THROW_NOT_OK(builder->Append(SafeLoadAs<value_type>(data_)));
-        data_ += sizeof(value_type);
+        PARQUET_THROW_NOT_OK(Builder->Append(SafeLoadAs<ValueType>(data_)));
+        data_ += sizeof(ValueType);
       },
-      [&]() { PARQUET_THROW_NOT_OK(builder->AppendNull()); });
+      [&]() { PARQUET_THROW_NOT_OK(Builder->AppendNull()); });
 
-  num_values_ -= values_decoded;
-  len_ -= sizeof(value_type) * values_decoded;
-  return values_decoded;
+  numValues_ -= valuesDecoded;
+  len_ -= sizeof(ValueType) * valuesDecoded;
+  return valuesDecoded;
 }
 
-// Decode routine templated on C++ type rather than type enum
+// Decode routine templated on C++ type rather than type enum.
 template <typename T>
-inline int DecodePlain(
+inline int decodePlain(
     const uint8_t* data,
-    int64_t data_size,
-    int num_values,
-    int type_length,
+    int64_t dataSize,
+    int numValues,
+    int typeLength,
     T* out) {
-  int64_t bytes_to_decode = num_values * static_cast<int64_t>(sizeof(T));
-  if (bytes_to_decode > data_size || bytes_to_decode > INT_MAX) {
-    ParquetException::EofException();
+  int64_t bytesToDecode = numValues * static_cast<int64_t>(sizeof(T));
+  if (bytesToDecode > dataSize || bytesToDecode > INT_MAX) {
+    ParquetException::eofException();
   }
-  // If bytes_to_decode == 0, data could be null
-  if (bytes_to_decode > 0) {
-    memcpy(out, data, bytes_to_decode);
+  // If bytes_to_decode == 0, data could be null.
+  if (bytesToDecode > 0) {
+    memcpy(out, data, bytesToDecode);
   }
-  return static_cast<int>(bytes_to_decode);
+  return static_cast<int>(bytesToDecode);
 }
 
 template <typename DType>
 PlainDecoder<DType>::PlainDecoder(const ColumnDescriptor* descr)
-    : DecoderImpl(descr, Encoding::PLAIN) {
-  if (descr_ && descr_->physical_type() == Type::FIXED_LEN_BYTE_ARRAY) {
-    type_length_ = descr_->type_length();
+    : DecoderImpl(descr, Encoding::kPlain) {
+  if (descr_ && descr_->physicalType() == Type::kFixedLenByteArray) {
+    typeLength_ = descr_->typeLength();
   } else {
-    type_length_ = -1;
+    typeLength_ = -1;
   }
 }
 
-// Template specialization for BYTE_ARRAY. The written values do not own their
-// own data.
+// Template specialization for BYTE_ARRAY. The written values do not own their.
+// Own data.
 
 static inline int64_t
-ReadByteArray(const uint8_t* data, int64_t data_size, ByteArray* out) {
-  if (ARROW_PREDICT_FALSE(data_size < 4)) {
-    ParquetException::EofException();
+readByteArray(const uint8_t* data, int64_t dataSize, ByteArray* out) {
+  if (ARROW_PREDICT_FALSE(dataSize < 4)) {
+    ParquetException::eofException();
   }
   const int32_t len = SafeLoadAs<int32_t>(data);
   if (len < 0) {
     throw ParquetException("Invalid BYTE_ARRAY value");
   }
-  const int64_t consumed_length = static_cast<int64_t>(len) + 4;
-  if (ARROW_PREDICT_FALSE(data_size < consumed_length)) {
-    ParquetException::EofException();
+  const int64_t consumedLength = static_cast<int64_t>(len) + 4;
+  if (ARROW_PREDICT_FALSE(dataSize < consumedLength)) {
+    ParquetException::eofException();
   }
   *out = ByteArray{static_cast<uint32_t>(len), data + 4};
-  return consumed_length;
+  return consumedLength;
 }
 
 template <>
-inline int DecodePlain<ByteArray>(
+inline int decodePlain<ByteArray>(
     const uint8_t* data,
-    int64_t data_size,
-    int num_values,
-    int type_length,
+    int64_t dataSize,
+    int numValues,
+    int typeLength,
     ByteArray* out) {
-  int bytes_decoded = 0;
-  for (int i = 0; i < num_values; ++i) {
-    const auto increment = ReadByteArray(data, data_size, out + i);
-    if (ARROW_PREDICT_FALSE(increment > INT_MAX - bytes_decoded)) {
+  int bytesDecoded = 0;
+  for (int i = 0; i < numValues; ++i) {
+    const auto increment = readByteArray(data, dataSize, out + i);
+    if (ARROW_PREDICT_FALSE(increment > INT_MAX - bytesDecoded)) {
       throw ParquetException("BYTE_ARRAY chunk too large");
     }
     data += increment;
-    data_size -= increment;
-    bytes_decoded += static_cast<int>(increment);
+    dataSize -= increment;
+    bytesDecoded += static_cast<int>(increment);
   }
-  return bytes_decoded;
+  return bytesDecoded;
 }
 
-// Template specialization for FIXED_LEN_BYTE_ARRAY. The written values do not
-// own their own data.
+// Template specialization for FIXED_LEN_BYTE_ARRAY. The written values do not.
+// Own their own data.
 template <>
-inline int DecodePlain<FixedLenByteArray>(
+inline int decodePlain<FixedLenByteArray>(
     const uint8_t* data,
-    int64_t data_size,
-    int num_values,
-    int type_length,
+    int64_t dataSize,
+    int numValues,
+    int typeLength,
     FixedLenByteArray* out) {
-  int64_t bytes_to_decode = static_cast<int64_t>(type_length) * num_values;
-  if (bytes_to_decode > data_size || bytes_to_decode > INT_MAX) {
-    ParquetException::EofException();
+  int64_t bytesToDecode = static_cast<int64_t>(typeLength) * numValues;
+  if (bytesToDecode > dataSize || bytesToDecode > INT_MAX) {
+    ParquetException::eofException();
   }
-  for (int i = 0; i < num_values; ++i) {
+  for (int i = 0; i < numValues; ++i) {
     out[i].ptr = data;
-    data += type_length;
-    data_size -= type_length;
+    data += typeLength;
+    dataSize -= typeLength;
   }
-  return static_cast<int>(bytes_to_decode);
+  return static_cast<int>(bytesToDecode);
 }
 
 template <typename DType>
-int PlainDecoder<DType>::Decode(T* buffer, int max_values) {
-  max_values = std::min(max_values, num_values_);
-  int bytes_consumed =
-      DecodePlain<T>(data_, len_, max_values, type_length_, buffer);
-  data_ += bytes_consumed;
-  len_ -= bytes_consumed;
-  num_values_ -= max_values;
-  return max_values;
+int PlainDecoder<DType>::decode(T* buffer, int maxValues) {
+  maxValues = std::min(maxValues, numValues_);
+  int bytesConsumed =
+      decodePlain<T>(data_, len_, maxValues, typeLength_, buffer);
+  data_ += bytesConsumed;
+  len_ -= bytesConsumed;
+  numValues_ -= maxValues;
+  return maxValues;
 }
 
 class PlainBooleanDecoder : public DecoderImpl, virtual public BooleanDecoder {
  public:
   explicit PlainBooleanDecoder(const ColumnDescriptor* descr);
-  void SetData(int num_values, const uint8_t* data, int len) override;
-
-  // Two flavors of bool decoding
-  int Decode(uint8_t* buffer, int max_values) override;
-  int Decode(bool* buffer, int max_values) override;
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  void setData(int numValues, const uint8_t* data, int len) override;
+
+  // Two flavors of bool decoding.
+  int decode(uint8_t* buffer, int maxValues) override;
+  int decode(bool* buffer, int maxValues) override;
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<BooleanType>::Accumulator* out) override;
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<BooleanType>::DictAccumulator* out) override;
 
  private:
-  std::unique_ptr<BitReader> bit_reader_;
+  std::unique_ptr<BitReader> bitReader_;
 };
 
 PlainBooleanDecoder::PlainBooleanDecoder(const ColumnDescriptor* descr)
-    : DecoderImpl(descr, Encoding::PLAIN) {}
+    : DecoderImpl(descr, Encoding::kPlain) {}
 
-void PlainBooleanDecoder::SetData(
-    int num_values,
-    const uint8_t* data,
-    int len) {
-  num_values_ = num_values;
-  bit_reader_ = std::make_unique<BitReader>(data, len);
+void PlainBooleanDecoder::setData(int numValues, const uint8_t* data, int len) {
+  numValues_ = numValues;
+  bitReader_ = std::make_unique<BitReader>(data, len);
 }
 
-int PlainBooleanDecoder::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<BooleanType>::Accumulator* builder) {
-  int values_decoded = num_values - null_count;
-  if (ARROW_PREDICT_FALSE(num_values_ < values_decoded)) {
-    ParquetException::EofException();
+int PlainBooleanDecoder::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<BooleanType>::Accumulator* Builder) {
+  int valuesDecoded = numValues - nullCount;
+  if (ARROW_PREDICT_FALSE(numValues_ < valuesDecoded)) {
+    ParquetException::eofException();
   }
 
-  PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
+  PARQUET_THROW_NOT_OK(Builder->Reserve(numValues));
 
   VisitNullBitmapInline(
-      valid_bits,
-      valid_bits_offset,
-      num_values,
-      null_count,
+      validBits,
+      validBitsOffset,
+      numValues,
+      nullCount,
       [&]() {
         bool value;
-        ARROW_IGNORE_EXPR(bit_reader_->GetValue(1, &value));
-        builder->UnsafeAppend(value);
+        ((void)(bitReader_->GetValue(1, &value)));
+        Builder->UnsafeAppend(value);
       },
-      [&]() { builder->UnsafeAppendNull(); });
+      [&]() { Builder->UnsafeAppendNull(); });
 
-  num_values_ -= values_decoded;
-  return values_decoded;
+  numValues_ -= valuesDecoded;
+  return valuesDecoded;
 }
 
-inline int PlainBooleanDecoder::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<BooleanType>::DictAccumulator* builder) {
+inline int PlainBooleanDecoder::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<BooleanType>::DictAccumulator* Builder) {
   ParquetException::NYI("dictionaries of BooleanType");
 }
 
-int PlainBooleanDecoder::Decode(uint8_t* buffer, int max_values) {
-  max_values = std::min(max_values, num_values_);
+int PlainBooleanDecoder::decode(uint8_t* buffer, int maxValues) {
+  maxValues = std::min(maxValues, numValues_);
   bool val;
-  ::arrow::internal::BitmapWriter bit_writer(buffer, 0, max_values);
-  for (int i = 0; i < max_values; ++i) {
-    if (!bit_reader_->GetValue(1, &val)) {
-      ParquetException::EofException();
+  ::arrow::internal::BitmapWriter bitWriter(buffer, 0, maxValues);
+  for (int i = 0; i < maxValues; ++i) {
+    if (!bitReader_->GetValue(1, &val)) {
+      ParquetException::eofException();
     }
     if (val) {
-      bit_writer.Set();
+      bitWriter.Set();
     }
-    bit_writer.Next();
+    bitWriter.Next();
   }
-  bit_writer.Finish();
-  num_values_ -= max_values;
-  return max_values;
+  bitWriter.Finish();
+  numValues_ -= maxValues;
+  return maxValues;
 }
 
-int PlainBooleanDecoder::Decode(bool* buffer, int max_values) {
-  max_values = std::min(max_values, num_values_);
-  if (bit_reader_->GetBatch(1, buffer, max_values) != max_values) {
-    ParquetException::EofException();
+int PlainBooleanDecoder::decode(bool* buffer, int maxValues) {
+  maxValues = std::min(maxValues, numValues_);
+  if (bitReader_->GetBatch(1, buffer, maxValues) != maxValues) {
+    ParquetException::eofException();
   }
-  num_values_ -= max_values;
-  return max_values;
+  numValues_ -= maxValues;
+  return maxValues;
 }
 
-// A helper class to abstract away differences between
+// A helper class to abstract away differences between.
 // EncodingTraits<DType>::Accumulator for ByteArrayType and FLBAType.
 template <typename DType>
 struct ArrowBinaryHelper;
@@ -1372,75 +1361,77 @@ struct ArrowBinaryHelper<ByteArrayType> {
 
   ArrowBinaryHelper(Accumulator* acc, int64_t length)
       : acc_(acc),
-        entries_remaining_(length),
-        chunk_space_remaining_(
-            ::arrow::kBinaryMemoryLimit - acc_->builder->value_data_length()) {}
-
-  Status Prepare(std::optional<int64_t> estimated_data_length = {}) {
-    RETURN_NOT_OK(acc_->builder->Reserve(entries_remaining_));
-    if (estimated_data_length.has_value()) {
-      RETURN_NOT_OK(acc_->builder->ReserveData(std::min<int64_t>(
-          *estimated_data_length, ::arrow::kBinaryMemoryLimit)));
+        entriesRemaining_(length),
+        chunkSpaceRemaining_(
+            ::arrow::kBinaryMemoryLimit - acc_->Builder->value_data_length()) {}
+
+  Status prepare(std::optional<int64_t> estimatedDataLength = {}) {
+    RETURN_NOT_OK(acc_->Builder->Reserve(entriesRemaining_));
+    if (estimatedDataLength.has_value()) {
+      RETURN_NOT_OK(acc_->Builder->ReserveData(
+          std::min<int64_t>(
+              *estimatedDataLength, ::arrow::kBinaryMemoryLimit)));
     }
     return Status::OK();
   }
 
-  Status PrepareNextInput(
-      int64_t next_value_length,
-      std::optional<int64_t> estimated_remaining_data_length = {}) {
-    if (ARROW_PREDICT_FALSE(!CanFit(next_value_length))) {
-      // This element would exceed the capacity of a chunk
-      RETURN_NOT_OK(PushChunk());
-      RETURN_NOT_OK(acc_->builder->Reserve(entries_remaining_));
-      if (estimated_remaining_data_length.has_value()) {
-        RETURN_NOT_OK(acc_->builder->ReserveData(std::min<int64_t>(
-            *estimated_remaining_data_length, chunk_space_remaining_)));
+  Status prepareNextInput(
+      int64_t nextValueLength,
+      std::optional<int64_t> estimatedRemainingDataLength = {}) {
+    if (ARROW_PREDICT_FALSE(!canFit(nextValueLength))) {
+      // This element would exceed the capacity of a chunk.
+      RETURN_NOT_OK(pushChunk());
+      RETURN_NOT_OK(acc_->Builder->Reserve(entriesRemaining_));
+      if (estimatedRemainingDataLength.has_value()) {
+        RETURN_NOT_OK(acc_->Builder->ReserveData(
+            std::min<int64_t>(
+                *estimatedRemainingDataLength, chunkSpaceRemaining_)));
       }
     }
     return Status::OK();
   }
 
   void UnsafeAppend(const uint8_t* data, int32_t length) {
-    VELOX_DCHECK(CanFit(length));
-    VELOX_DCHECK_GT(entries_remaining_, 0);
-    chunk_space_remaining_ -= length;
-    --entries_remaining_;
-    acc_->builder->UnsafeAppend(data, length);
+    VELOX_DCHECK(canFit(length));
+    VELOX_DCHECK_GT(entriesRemaining_, 0);
+    chunkSpaceRemaining_ -= length;
+    --entriesRemaining_;
+    acc_->Builder->UnsafeAppend(data, length);
   }
 
   Status Append(const uint8_t* data, int32_t length) {
-    VELOX_DCHECK(CanFit(length));
-    VELOX_DCHECK_GT(entries_remaining_, 0);
-    chunk_space_remaining_ -= length;
-    --entries_remaining_;
-    return acc_->builder->Append(data, length);
+    VELOX_DCHECK(canFit(length));
+    VELOX_DCHECK_GT(entriesRemaining_, 0);
+    chunkSpaceRemaining_ -= length;
+    --entriesRemaining_;
+    return acc_->Builder->Append(data, length);
   }
 
   void UnsafeAppendNull() {
-    --entries_remaining_;
-    acc_->builder->UnsafeAppendNull();
+    --entriesRemaining_;
+    acc_->Builder->UnsafeAppendNull();
   }
 
   Status AppendNull() {
-    --entries_remaining_;
-    return acc_->builder->AppendNull();
+    --entriesRemaining_;
+    return acc_->Builder->AppendNull();
   }
 
  private:
-  Status PushChunk() {
-    ARROW_ASSIGN_OR_RAISE(auto chunk, acc_->builder->Finish());
+  Status pushChunk() {
+    ARROW_ASSIGN_OR_RAISE(auto chunk, acc_->Builder->Finish());
     acc_->chunks.push_back(std::move(chunk));
-    chunk_space_remaining_ = ::arrow::kBinaryMemoryLimit;
+    chunkSpaceRemaining_ = ::arrow::kBinaryMemoryLimit;
     return Status::OK();
   }
 
-  bool CanFit(int64_t length) const {
-    return length <= chunk_space_remaining_;
+  bool canFit(int64_t length) const {
+    return length <= chunkSpaceRemaining_;
   }
 
   Accumulator* acc_;
-  int64_t entries_remaining_;
-  int64_t chunk_space_remaining_;
+  int64_t entriesRemaining_;
+  int64_t chunkSpaceRemaining_;
 };
 
 template <>
@@ -1448,204 +1439,199 @@ struct ArrowBinaryHelper<FLBAType> {
   using Accumulator = typename EncodingTraits<FLBAType>::Accumulator;
 
   ArrowBinaryHelper(Accumulator* acc, int64_t length)
-      : acc_(acc), entries_remaining_(length) {}
+      : acc_(acc), entriesRemaining_(length) {}
 
-  Status Prepare(std::optional<int64_t> estimated_data_length = {}) {
-    return acc_->Reserve(entries_remaining_);
+  Status prepare(std::optional<int64_t> estimatedDataLength = {}) {
+    return acc_->Reserve(entriesRemaining_);
   }
 
-  Status PrepareNextInput(
-      int64_t next_value_length,
-      std::optional<int64_t> estimated_remaining_data_length = {}) {
+  Status prepareNextInput(
+      int64_t nextValueLength,
+      std::optional<int64_t> estimatedRemainingDataLength = {}) {
     return Status::OK();
   }
 
   void UnsafeAppend(const uint8_t* data, int32_t length) {
-    VELOX_DCHECK_GT(entries_remaining_, 0);
-    --entries_remaining_;
+    VELOX_DCHECK_GT(entriesRemaining_, 0);
+    --entriesRemaining_;
     acc_->UnsafeAppend(data);
   }
 
   Status Append(const uint8_t* data, int32_t length) {
-    VELOX_DCHECK_GT(entries_remaining_, 0);
-    --entries_remaining_;
+    VELOX_DCHECK_GT(entriesRemaining_, 0);
+    --entriesRemaining_;
     return acc_->Append(data);
   }
 
   void UnsafeAppendNull() {
-    --entries_remaining_;
+    --entriesRemaining_;
     acc_->UnsafeAppendNull();
   }
 
   Status AppendNull() {
-    --entries_remaining_;
+    --entriesRemaining_;
     return acc_->AppendNull();
   }
 
  private:
   Accumulator* acc_;
-  int64_t entries_remaining_;
+  int64_t entriesRemaining_;
 };
 
 template <>
-inline int PlainDecoder<ByteArrayType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<ByteArrayType>::Accumulator* builder) {
+inline int PlainDecoder<ByteArrayType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<ByteArrayType>::Accumulator* Builder) {
   ParquetException::NYI();
 }
 
 template <>
-inline int PlainDecoder<ByteArrayType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<ByteArrayType>::DictAccumulator* builder) {
+inline int PlainDecoder<ByteArrayType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<ByteArrayType>::DictAccumulator* Builder) {
   ParquetException::NYI();
 }
 
 template <>
-inline int PlainDecoder<FLBAType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<FLBAType>::Accumulator* builder) {
-  int values_decoded = num_values - null_count;
-  if (ARROW_PREDICT_FALSE(len_ < descr_->type_length() * values_decoded)) {
-    ParquetException::EofException();
+inline int PlainDecoder<FLBAType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<FLBAType>::Accumulator* Builder) {
+  int valuesDecoded = numValues - nullCount;
+  if (ARROW_PREDICT_FALSE(len_ < descr_->typeLength() * valuesDecoded)) {
+    ParquetException::eofException();
   }
 
-  PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
+  PARQUET_THROW_NOT_OK(Builder->Reserve(numValues));
 
   VisitNullBitmapInline(
-      valid_bits,
-      valid_bits_offset,
-      num_values,
-      null_count,
+      validBits,
+      validBitsOffset,
+      numValues,
+      nullCount,
       [&]() {
-        builder->UnsafeAppend(data_);
-        data_ += descr_->type_length();
+        Builder->UnsafeAppend(data_);
+        data_ += descr_->typeLength();
       },
-      [&]() { builder->UnsafeAppendNull(); });
+      [&]() { Builder->UnsafeAppendNull(); });
 
-  num_values_ -= values_decoded;
-  len_ -= descr_->type_length() * values_decoded;
-  return values_decoded;
+  numValues_ -= valuesDecoded;
+  len_ -= descr_->typeLength() * valuesDecoded;
+  return valuesDecoded;
 }
 
 template <>
-inline int PlainDecoder<FLBAType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<FLBAType>::DictAccumulator* builder) {
-  int values_decoded = num_values - null_count;
-  if (ARROW_PREDICT_FALSE(len_ < descr_->type_length() * values_decoded)) {
-    ParquetException::EofException();
+inline int PlainDecoder<FLBAType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<FLBAType>::DictAccumulator* Builder) {
+  int valuesDecoded = numValues - nullCount;
+  if (ARROW_PREDICT_FALSE(len_ < descr_->typeLength() * valuesDecoded)) {
+    ParquetException::eofException();
   }
 
-  PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
+  PARQUET_THROW_NOT_OK(Builder->Reserve(numValues));
 
   VisitNullBitmapInline(
-      valid_bits,
-      valid_bits_offset,
-      num_values,
-      null_count,
+      validBits,
+      validBitsOffset,
+      numValues,
+      nullCount,
       [&]() {
-        PARQUET_THROW_NOT_OK(builder->Append(data_));
-        data_ += descr_->type_length();
+        PARQUET_THROW_NOT_OK(Builder->Append(data_));
+        data_ += descr_->typeLength();
       },
-      [&]() { PARQUET_THROW_NOT_OK(builder->AppendNull()); });
+      [&]() { PARQUET_THROW_NOT_OK(Builder->AppendNull()); });
 
-  num_values_ -= values_decoded;
-  len_ -= descr_->type_length() * values_decoded;
-  return values_decoded;
+  numValues_ -= valuesDecoded;
+  len_ -= descr_->typeLength() * valuesDecoded;
+  return valuesDecoded;
 }
 
 class PlainByteArrayDecoder : public PlainDecoder<ByteArrayType>,
                               virtual public ByteArrayDecoder {
  public:
   using Base = PlainDecoder<ByteArrayType>;
-  using Base::DecodeSpaced;
+  using Base::decodeSpaced;
   using Base::PlainDecoder;
 
-  // ----------------------------------------------------------------------
-  // Dictionary read paths
+  // ----------------------------------------------------------------------.
+  // Dictionary read paths.
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      ::arrow::BinaryDictionary32Builder* builder) override {
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      ::arrow::BinaryDictionary32Builder* Builder) override {
     int result = 0;
-    PARQUET_THROW_NOT_OK(DecodeArrow(
-        num_values,
-        null_count,
-        valid_bits,
-        valid_bits_offset,
-        builder,
-        &result));
+    PARQUET_THROW_NOT_OK(decodeArrow(
+        numValues, nullCount, validBits, validBitsOffset, Builder, &result));
     return result;
   }
 
-  // ----------------------------------------------------------------------
-  // Optimized dense binary read paths
+  // ----------------------------------------------------------------------.
+  // Optimized dense binary read paths.
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<ByteArrayType>::Accumulator* out) override {
     int result = 0;
-    PARQUET_THROW_NOT_OK(DecodeArrowDense(
-        num_values, null_count, valid_bits, valid_bits_offset, out, &result));
+    PARQUET_THROW_NOT_OK(decodeArrowDense(
+        numValues, nullCount, validBits, validBitsOffset, out, &result));
     return result;
   }
 
  private:
-  Status DecodeArrowDense(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  Status decodeArrowDense(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<ByteArrayType>::Accumulator* out,
-      int* out_values_decoded) {
-    ArrowBinaryHelper<ByteArrayType> helper(out, num_values);
-    int values_decoded = 0;
+      int* outValuesDecoded) {
+    ArrowBinaryHelper<ByteArrayType> helper(out, numValues);
+    int valuesDecoded = 0;
 
-    RETURN_NOT_OK(helper.Prepare(len_));
+    RETURN_NOT_OK(helper.prepare(len_));
 
     int i = 0;
     RETURN_NOT_OK(VisitNullBitmapInline(
-        valid_bits,
-        valid_bits_offset,
-        num_values,
-        null_count,
+        validBits,
+        validBitsOffset,
+        numValues,
+        nullCount,
         [&]() {
           if (ARROW_PREDICT_FALSE(len_ < 4)) {
-            ParquetException::EofException();
+            ParquetException::eofException();
           }
-          auto value_len = SafeLoadAs<int32_t>(data_);
-          if (ARROW_PREDICT_FALSE(value_len < 0 || value_len > INT32_MAX - 4)) {
+          auto valueLen = SafeLoadAs<int32_t>(data_);
+          if (ARROW_PREDICT_FALSE(valueLen < 0 || valueLen > INT32_MAX - 4)) {
             return Status::Invalid(
-                "Invalid or corrupted value_len '", value_len, "'");
+                "Invalid or corrupted value_len '", valueLen, "'");
           }
-          auto increment = value_len + 4;
+          auto increment = valueLen + 4;
           if (ARROW_PREDICT_FALSE(len_ < increment)) {
-            ParquetException::EofException();
+            ParquetException::eofException();
           }
-          RETURN_NOT_OK(helper.PrepareNextInput(value_len, len_));
-          helper.UnsafeAppend(data_ + 4, value_len);
+          RETURN_NOT_OK(helper.prepareNextInput(valueLen, len_));
+          helper.UnsafeAppend(data_ + 4, valueLen);
           data_ += increment;
           len_ -= increment;
-          ++values_decoded;
+          ++valuesDecoded;
           ++i;
           return Status::OK();
         },
@@ -1655,50 +1641,50 @@ class PlainByteArrayDecoder : public PlainDecoder<ByteArrayType>,
           return Status::OK();
         }));
 
-    num_values_ -= values_decoded;
-    *out_values_decoded = values_decoded;
+    numValues_ -= valuesDecoded;
+    *outValuesDecoded = valuesDecoded;
     return Status::OK();
   }
 
   template <typename BuilderType>
-  Status DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      BuilderType* builder,
-      int* out_values_decoded) {
-    RETURN_NOT_OK(builder->Reserve(num_values));
-    int values_decoded = 0;
+  Status decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      BuilderType* Builder,
+      int* outValuesDecoded) {
+    RETURN_NOT_OK(Builder->Reserve(numValues));
+    int valuesDecoded = 0;
 
     RETURN_NOT_OK(VisitNullBitmapInline(
-        valid_bits,
-        valid_bits_offset,
-        num_values,
-        null_count,
+        validBits,
+        validBitsOffset,
+        numValues,
+        nullCount,
         [&]() {
           if (ARROW_PREDICT_FALSE(len_ < 4)) {
-            ParquetException::EofException();
+            ParquetException::eofException();
           }
-          auto value_len = SafeLoadAs<int32_t>(data_);
-          if (ARROW_PREDICT_FALSE(value_len < 0 || value_len > INT32_MAX - 4)) {
+          auto valueLen = SafeLoadAs<int32_t>(data_);
+          if (ARROW_PREDICT_FALSE(valueLen < 0 || valueLen > INT32_MAX - 4)) {
             return Status::Invalid(
-                "Invalid or corrupted value_len '", value_len, "'");
+                "Invalid or corrupted value_len '", valueLen, "'");
           }
-          auto increment = value_len + 4;
+          auto increment = valueLen + 4;
           if (ARROW_PREDICT_FALSE(len_ < increment)) {
-            ParquetException::EofException();
+            ParquetException::eofException();
           }
-          RETURN_NOT_OK(builder->Append(data_ + 4, value_len));
+          RETURN_NOT_OK(Builder->Append(data_ + 4, valueLen));
           data_ += increment;
           len_ -= increment;
-          ++values_decoded;
+          ++valuesDecoded;
           return Status::OK();
         },
-        [&]() { return builder->AppendNull(); }));
+        [&]() { return Builder->AppendNull(); }));
 
-    num_values_ -= values_decoded;
-    *out_values_decoded = values_decoded;
+    numValues_ -= valuesDecoded;
+    *outValuesDecoded = valuesDecoded;
     return Status::OK();
   }
 };
@@ -1710,486 +1696,474 @@ class PlainFLBADecoder : public PlainDecoder<FLBAType>,
   using Base::PlainDecoder;
 };
 
-// ----------------------------------------------------------------------
-// Dictionary encoding and decoding
+// ----------------------------------------------------------------------.
+// Dictionary encoding and decoding.
 
 template <typename Type>
 class DictDecoderImpl : public DecoderImpl, virtual public DictDecoder<Type> {
  public:
-  typedef typename Type::c_type T;
+  typedef typename Type::CType T;
 
-  // Initializes the dictionary with values from 'dictionary'. The data in
-  // dictionary is not guaranteed to persist in memory after this call so the
-  // dictionary decoder needs to copy the data out if necessary.
+  // Initializes the dictionary with values from 'dictionary'. The data in.
+  // Dictionary is not guaranteed to persist in memory after this call so the.
+  // Dictionary decoder needs to copy the data out if necessary.
   explicit DictDecoderImpl(
       const ColumnDescriptor* descr,
       MemoryPool* pool = ::arrow::default_memory_pool())
-      : DecoderImpl(descr, Encoding::RLE_DICTIONARY),
-        dictionary_(AllocateBuffer(pool, 0)),
-        dictionary_length_(0),
-        byte_array_data_(AllocateBuffer(pool, 0)),
-        byte_array_offsets_(AllocateBuffer(pool, 0)),
-        indices_scratch_space_(AllocateBuffer(pool, 0)) {}
-
-  // Perform type-specific initialization
-  void SetDict(TypedDecoder<Type>* dictionary) override;
-
-  void SetData(int num_values, const uint8_t* data, int len) override {
-    num_values_ = num_values;
+      : DecoderImpl(descr, Encoding::kRleDictionary),
+        dictionary_(allocateBuffer(pool, 0)),
+        dictionaryLength_(0),
+        byteArrayData_(allocateBuffer(pool, 0)),
+        byteArrayOffsets_(allocateBuffer(pool, 0)),
+        indicesScratchSpace_(allocateBuffer(pool, 0)) {}
+
+  // Perform type-specific initialization.
+  void setDict(TypedDecoder<Type>* dictionary) override;
+
+  void setData(int numValues, const uint8_t* data, int len) override {
+    numValues_ = numValues;
     if (len == 0) {
-      // Initialize dummy decoder to avoid crashes later on
-      idx_decoder_ = RleDecoder(data, len, /*bitWidth=*/1);
+      // Initialize dummy decoder to avoid crashes later on.
+      idxDecoder_ = RleDecoder(data, len, 1);
       return;
     }
-    uint8_t bit_width = *data;
-    if (ARROW_PREDICT_FALSE(bit_width > 32)) {
+    uint8_t bitWidth = *data;
+    if (ARROW_PREDICT_FALSE(bitWidth > 32)) {
       throw ParquetException(
-          "Invalid or corrupted bit_width " + std::to_string(bit_width) +
+          "Invalid or corrupted bit_width " + std::to_string(bitWidth) +
           ". Maximum allowed is 32.");
     }
-    idx_decoder_ = RleDecoder(++data, --len, bit_width);
+    idxDecoder_ = RleDecoder(++data, --len, bitWidth);
   }
 
-  int Decode(T* buffer, int num_values) override {
-    num_values = std::min(num_values, num_values_);
-    int decoded_values = idx_decoder_.GetBatchWithDict(
+  int decode(T* buffer, int numValues) override {
+    numValues = std::min(numValues, numValues_);
+    int decodedValues = idxDecoder_.GetBatchWithDict(
         reinterpret_cast<const T*>(dictionary_->data()),
-        dictionary_length_,
+        dictionaryLength_,
         buffer,
-        num_values);
-    if (decoded_values != num_values) {
-      ParquetException::EofException();
+        numValues);
+    if (decodedValues != numValues) {
+      ParquetException::eofException();
     }
-    num_values_ -= num_values;
-    return num_values;
+    numValues_ -= numValues;
+    return numValues;
   }
 
-  int DecodeSpaced(
+  int decodeSpaced(
       T* buffer,
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset) override {
-    num_values = std::min(num_values, num_values_);
-    if (num_values !=
-        idx_decoder_.GetBatchWithDictSpaced(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset) override {
+    numValues = std::min(numValues, numValues_);
+    if (numValues !=
+        idxDecoder_.GetBatchWithDictSpaced(
             reinterpret_cast<const T*>(dictionary_->data()),
-            dictionary_length_,
+            dictionaryLength_,
             buffer,
-            num_values,
-            null_count,
-            valid_bits,
-            valid_bits_offset)) {
-      ParquetException::EofException();
+            numValues,
+            nullCount,
+            validBits,
+            validBitsOffset)) {
+      ParquetException::eofException();
     }
-    num_values_ -= num_values;
-    return num_values;
+    numValues_ -= numValues;
+    return numValues;
   }
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<Type>::Accumulator* out) override;
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<Type>::DictAccumulator* out) override;
 
-  void InsertDictionary(::arrow::ArrayBuilder* builder) override;
-
-  int DecodeIndicesSpaced(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      ::arrow::ArrayBuilder* builder) override {
-    if (num_values > 0) {
-      // TODO(wesm): Refactor to batch reads for improved memory use. It is not
-      // trivial because the null_count is relative to the entire bitmap
-      PARQUET_THROW_NOT_OK(indices_scratch_space_->TypedResize<int32_t>(
-          num_values, /*shrink_to_fit=*/false));
+  void insertDictionary(::arrow::ArrayBuilder* Builder) override;
+
+  int decodeIndicesSpaced(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      ::arrow::ArrayBuilder* Builder) override {
+    if (numValues > 0) {
+      // TODO(wesm): Refactor to batch reads for improved memory use. It is not.
+      // Trivial because the null_count is relative to the entire bitmap.
+      PARQUET_THROW_NOT_OK(
+          indicesScratchSpace_->TypedResize<int32_t>(numValues, false));
     }
 
-    auto indices_buffer =
-        reinterpret_cast<int32_t*>(indices_scratch_space_->mutable_data());
+    auto indicesBuffer =
+        reinterpret_cast<int32_t*>(indicesScratchSpace_->mutable_data());
 
-    if (num_values !=
-        idx_decoder_.GetBatchSpaced(
-            num_values,
-            null_count,
-            valid_bits,
-            valid_bits_offset,
-            indices_buffer)) {
-      ParquetException::EofException();
+    if (numValues !=
+        idxDecoder_.GetBatchSpaced(
+            numValues, nullCount, validBits, validBitsOffset, indicesBuffer)) {
+      ParquetException::eofException();
     }
 
-    // XXX(wesm): Cannot append "valid bits" directly to the builder
-    std::vector<uint8_t> valid_bytes(num_values, 0);
+    // XXX(wesm): Cannot Append "valid bits" directly to the builder.
+    std::vector<uint8_t> validBytes(numValues, 0);
     int64_t i = 0;
     VisitNullBitmapInline(
-        valid_bits,
-        valid_bits_offset,
-        num_values,
-        null_count,
-        [&]() { valid_bytes[i++] = 1; },
+        validBits,
+        validBitsOffset,
+        numValues,
+        nullCount,
+        [&]() { validBytes[i++] = 1; },
         [&]() { ++i; });
 
-    auto binary_builder =
-        checked_cast<::arrow::BinaryDictionary32Builder*>(builder);
-    PARQUET_THROW_NOT_OK(binary_builder->AppendIndices(
-        indices_buffer, num_values, valid_bytes.data()));
-    num_values_ -= num_values - null_count;
-    return num_values - null_count;
-  }
-
-  int DecodeIndices(int num_values, ::arrow::ArrayBuilder* builder) override {
-    num_values = std::min(num_values, num_values_);
-    if (num_values > 0) {
-      // TODO(wesm): Refactor to batch reads for improved memory use. This is
-      // relatively simple here because we don't have to do any bookkeeping of
-      // nulls
-      PARQUET_THROW_NOT_OK(indices_scratch_space_->TypedResize<int32_t>(
-          num_values, /*shrink_to_fit=*/false));
+    auto binaryBuilder =
+        checked_cast<::arrow::BinaryDictionary32Builder*>(Builder);
+    PARQUET_THROW_NOT_OK(binaryBuilder->AppendIndices(
+        indicesBuffer, numValues, validBytes.data()));
+    numValues_ -= numValues - nullCount;
+    return numValues - nullCount;
+  }
+
+  int decodeIndices(int numValues, ::arrow::ArrayBuilder* Builder) override {
+    numValues = std::min(numValues, numValues_);
+    if (numValues > 0) {
+      // TODO(wesm): Refactor to batch reads for improved memory use. This is.
+      // Relatively simple here because we don't have to do any bookkeeping of.
+      // Nulls.
+      PARQUET_THROW_NOT_OK(
+          indicesScratchSpace_->TypedResize<int32_t>(numValues, false));
     }
-    auto indices_buffer =
-        reinterpret_cast<int32_t*>(indices_scratch_space_->mutable_data());
-    if (num_values != idx_decoder_.GetBatch(indices_buffer, num_values)) {
-      ParquetException::EofException();
+    auto indicesBuffer =
+        reinterpret_cast<int32_t*>(indicesScratchSpace_->mutable_data());
+    if (numValues != idxDecoder_.GetBatch(indicesBuffer, numValues)) {
+      ParquetException::eofException();
     }
-    auto binary_builder =
-        checked_cast<::arrow::BinaryDictionary32Builder*>(builder);
+    auto binaryBuilder =
+        checked_cast<::arrow::BinaryDictionary32Builder*>(Builder);
     PARQUET_THROW_NOT_OK(
-        binary_builder->AppendIndices(indices_buffer, num_values));
-    num_values_ -= num_values;
-    return num_values;
+        binaryBuilder->AppendIndices(indicesBuffer, numValues));
+    numValues_ -= numValues;
+    return numValues;
   }
 
-  int DecodeIndices(int num_values, int32_t* indices) override {
-    if (num_values != idx_decoder_.GetBatch(indices, num_values)) {
-      ParquetException::EofException();
+  int decodeIndices(int numValues, int32_t* indices) override {
+    if (numValues != idxDecoder_.GetBatch(indices, numValues)) {
+      ParquetException::eofException();
     }
-    num_values_ -= num_values;
-    return num_values;
+    numValues_ -= numValues;
+    return numValues;
   }
 
-  void GetDictionary(const T** dictionary, int32_t* dictionary_length)
-      override {
-    *dictionary_length = dictionary_length_;
+  void getDictionary(const T** dictionary, int32_t* dictionaryLength) override {
+    *dictionaryLength = dictionaryLength_;
     *dictionary = reinterpret_cast<T*>(dictionary_->mutable_data());
   }
 
  protected:
-  Status IndexInBounds(int32_t index) {
-    if (ARROW_PREDICT_TRUE(0 <= index && index < dictionary_length_)) {
+  Status indexInBounds(int32_t index) {
+    if (ARROW_PREDICT_TRUE(0 <= index && index < dictionaryLength_)) {
       return Status::OK();
     }
     return Status::Invalid("Index not in dictionary bounds");
   }
 
-  inline void DecodeDict(TypedDecoder<Type>* dictionary) {
-    dictionary_length_ = static_cast<int32_t>(dictionary->values_left());
-    PARQUET_THROW_NOT_OK(dictionary_->Resize(
-        dictionary_length_ * sizeof(T),
-        /*shrink_to_fit=*/false));
-    dictionary->Decode(
-        reinterpret_cast<T*>(dictionary_->mutable_data()), dictionary_length_);
+  inline void decodeDict(TypedDecoder<Type>* dictionary) {
+    dictionaryLength_ = static_cast<int32_t>(dictionary->valuesLeft());
+    PARQUET_THROW_NOT_OK(
+        dictionary_->Resize(dictionaryLength_ * sizeof(T), false));
+    dictionary->decode(
+        reinterpret_cast<T*>(dictionary_->mutable_data()), dictionaryLength_);
   }
 
   // Only one is set.
   std::shared_ptr<ResizableBuffer> dictionary_;
 
-  int32_t dictionary_length_;
+  int32_t dictionaryLength_;
 
-  // Data that contains the byte array data (byte_array_dictionary_ just has the
-  // pointers).
-  std::shared_ptr<ResizableBuffer> byte_array_data_;
+  // Data that contains the byte array data (byte_array_dictionary_ just has
+  // the. Pointers).
+  std::shared_ptr<ResizableBuffer> byteArrayData_;
 
-  // Arrow-style byte offsets for each dictionary value. We maintain two
-  // representations of the dictionary, one as ByteArray* for non-Arrow
-  // consumers and this one for Arrow consumers. Since dictionaries are
-  // generally pretty small to begin with this doesn't mean too much extra
-  // memory use in most cases
-  std::shared_ptr<ResizableBuffer> byte_array_offsets_;
+  // Arrow-style byte offsets for each dictionary value. We maintain two.
+  // Representations of the dictionary, one as ByteArray* for non-Arrow.
+  // Consumers and this one for Arrow consumers. Since dictionaries are.
+  // Generally pretty small to begin with this doesn't mean too much extra.
+  // Memory use in most cases.
+  std::shared_ptr<ResizableBuffer> byteArrayOffsets_;
 
-  // Reusable buffer for decoding dictionary indices to be appended to a
-  // BinaryDictionary32Builder
-  std::shared_ptr<ResizableBuffer> indices_scratch_space_;
+  // Reusable buffer for decoding dictionary indices to be appended to a.
+  // BinaryDictionary32Builder.
+  std::shared_ptr<ResizableBuffer> indicesScratchSpace_;
 
-  RleDecoder idx_decoder_;
+  RleDecoder idxDecoder_;
 };
 
 template <typename Type>
-void DictDecoderImpl<Type>::SetDict(TypedDecoder<Type>* dictionary) {
-  DecodeDict(dictionary);
+void DictDecoderImpl<Type>::setDict(TypedDecoder<Type>* dictionary) {
+  decodeDict(dictionary);
 }
 
 template <>
-void DictDecoderImpl<BooleanType>::SetDict(
+void DictDecoderImpl<BooleanType>::setDict(
     TypedDecoder<BooleanType>* dictionary) {
   ParquetException::NYI(
       "Dictionary encoding is not implemented for boolean values");
 }
 
 template <>
-void DictDecoderImpl<ByteArrayType>::SetDict(
+void DictDecoderImpl<ByteArrayType>::setDict(
     TypedDecoder<ByteArrayType>* dictionary) {
-  DecodeDict(dictionary);
+  decodeDict(dictionary);
 
-  auto dict_values = reinterpret_cast<ByteArray*>(dictionary_->mutable_data());
+  auto dictValues = reinterpret_cast<ByteArray*>(dictionary_->mutable_data());
 
-  int total_size = 0;
-  for (int i = 0; i < dictionary_length_; ++i) {
-    total_size += dict_values[i].len;
+  int totalSize = 0;
+  for (int i = 0; i < dictionaryLength_; ++i) {
+    totalSize += dictValues[i].len;
   }
-  PARQUET_THROW_NOT_OK(byte_array_data_->Resize(
-      total_size,
-      /*shrink_to_fit=*/false));
-  PARQUET_THROW_NOT_OK(byte_array_offsets_->Resize(
-      (dictionary_length_ + 1) * sizeof(int32_t),
-      /*shrink_to_fit=*/false));
+  PARQUET_THROW_NOT_OK(byteArrayData_->Resize(totalSize, false));
+  PARQUET_THROW_NOT_OK(byteArrayOffsets_->Resize(
+      (dictionaryLength_ + 1) * sizeof(int32_t), false));
 
   int32_t offset = 0;
-  uint8_t* bytes_data = byte_array_data_->mutable_data();
-  int32_t* bytes_offsets =
-      reinterpret_cast<int32_t*>(byte_array_offsets_->mutable_data());
-  for (int i = 0; i < dictionary_length_; ++i) {
-    memcpy(bytes_data + offset, dict_values[i].ptr, dict_values[i].len);
-    bytes_offsets[i] = offset;
-    dict_values[i].ptr = bytes_data + offset;
-    offset += dict_values[i].len;
-  }
-  bytes_offsets[dictionary_length_] = offset;
+  uint8_t* bytesData = byteArrayData_->mutable_data();
+  int32_t* bytesOffsets =
+      reinterpret_cast<int32_t*>(byteArrayOffsets_->mutable_data());
+  for (int i = 0; i < dictionaryLength_; ++i) {
+    memcpy(bytesData + offset, dictValues[i].ptr, dictValues[i].len);
+    bytesOffsets[i] = offset;
+    dictValues[i].ptr = bytesData + offset;
+    offset += dictValues[i].len;
+  }
+  bytesOffsets[dictionaryLength_] = offset;
 }
 
 template <>
-inline void DictDecoderImpl<FLBAType>::SetDict(
+inline void DictDecoderImpl<FLBAType>::setDict(
     TypedDecoder<FLBAType>* dictionary) {
-  DecodeDict(dictionary);
+  decodeDict(dictionary);
 
-  auto dict_values = reinterpret_cast<FLBA*>(dictionary_->mutable_data());
+  auto dictValues = reinterpret_cast<FLBA*>(dictionary_->mutable_data());
 
-  int fixed_len = descr_->type_length();
-  int total_size = dictionary_length_ * fixed_len;
+  int fixedLen = descr_->typeLength();
+  int totalSize = dictionaryLength_ * fixedLen;
 
-  PARQUET_THROW_NOT_OK(byte_array_data_->Resize(
-      total_size,
-      /*shrink_to_fit=*/false));
-  uint8_t* bytes_data = byte_array_data_->mutable_data();
-  for (int32_t i = 0, offset = 0; i < dictionary_length_;
-       ++i, offset += fixed_len) {
-    memcpy(bytes_data + offset, dict_values[i].ptr, fixed_len);
-    dict_values[i].ptr = bytes_data + offset;
+  PARQUET_THROW_NOT_OK(byteArrayData_->Resize(totalSize, false));
+  uint8_t* bytesData = byteArrayData_->mutable_data();
+  for (int32_t i = 0, offset = 0; i < dictionaryLength_;
+       ++i, offset += fixedLen) {
+    memcpy(bytesData + offset, dictValues[i].ptr, fixedLen);
+    dictValues[i].ptr = bytesData + offset;
   }
 }
 
 template <>
-inline int DictDecoderImpl<Int96Type>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<Int96Type>::Accumulator* builder) {
+inline int DictDecoderImpl<Int96Type>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<Int96Type>::Accumulator* Builder) {
   ParquetException::NYI("DecodeArrow to Int96Type");
 }
 
 template <>
-inline int DictDecoderImpl<Int96Type>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<Int96Type>::DictAccumulator* builder) {
+inline int DictDecoderImpl<Int96Type>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<Int96Type>::DictAccumulator* Builder) {
   ParquetException::NYI("DecodeArrow to Int96Type");
 }
 
 template <>
-inline int DictDecoderImpl<ByteArrayType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<ByteArrayType>::Accumulator* builder) {
+inline int DictDecoderImpl<ByteArrayType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<ByteArrayType>::Accumulator* Builder) {
   ParquetException::NYI("DecodeArrow implemented elsewhere");
 }
 
 template <>
-inline int DictDecoderImpl<ByteArrayType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<ByteArrayType>::DictAccumulator* builder) {
+inline int DictDecoderImpl<ByteArrayType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<ByteArrayType>::DictAccumulator* Builder) {
   ParquetException::NYI("DecodeArrow implemented elsewhere");
 }
 
 template <typename DType>
-int DictDecoderImpl<DType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<DType>::DictAccumulator* builder) {
-  PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
+int DictDecoderImpl<DType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<DType>::DictAccumulator* Builder) {
+  PARQUET_THROW_NOT_OK(Builder->Reserve(numValues));
 
-  auto dict_values =
-      reinterpret_cast<const typename DType::c_type*>(dictionary_->data());
+  auto dictValues =
+      reinterpret_cast<const typename DType::CType*>(dictionary_->data());
 
   VisitNullBitmapInline(
-      valid_bits,
-      valid_bits_offset,
-      num_values,
-      null_count,
+      validBits,
+      validBitsOffset,
+      numValues,
+      nullCount,
       [&]() {
         int32_t index;
-        if (ARROW_PREDICT_FALSE(!idx_decoder_.Get(&index))) {
+        if (ARROW_PREDICT_FALSE(!idxDecoder_.Get(&index))) {
           throw ParquetException("");
         }
-        PARQUET_THROW_NOT_OK(IndexInBounds(index));
-        PARQUET_THROW_NOT_OK(builder->Append(dict_values[index]));
+        PARQUET_THROW_NOT_OK(indexInBounds(index));
+        PARQUET_THROW_NOT_OK(Builder->Append(dictValues[index]));
       },
-      [&]() { PARQUET_THROW_NOT_OK(builder->AppendNull()); });
+      [&]() { PARQUET_THROW_NOT_OK(Builder->AppendNull()); });
 
-  return num_values - null_count;
+  return numValues - nullCount;
 }
 
 template <>
-int DictDecoderImpl<BooleanType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<BooleanType>::DictAccumulator* builder) {
+int DictDecoderImpl<BooleanType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<BooleanType>::DictAccumulator* Builder) {
   ParquetException::NYI("No dictionary encoding for BooleanType");
 }
 
 template <>
-inline int DictDecoderImpl<FLBAType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<FLBAType>::Accumulator* builder) {
-  if (builder->byte_width() != descr_->type_length()) {
+inline int DictDecoderImpl<FLBAType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<FLBAType>::Accumulator* Builder) {
+  if (Builder->byte_width() != descr_->typeLength()) {
     throw ParquetException(
         "Byte width mismatch: builder was " +
-        std::to_string(builder->byte_width()) + " but decoder was " +
-        std::to_string(descr_->type_length()));
+        std::to_string(Builder->byte_width()) + " but decoder was " +
+        std::to_string(descr_->typeLength()));
   }
 
-  PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
+  PARQUET_THROW_NOT_OK(Builder->Reserve(numValues));
 
-  auto dict_values = reinterpret_cast<const FLBA*>(dictionary_->data());
+  auto dictValues = reinterpret_cast<const FLBA*>(dictionary_->data());
 
   VisitNullBitmapInline(
-      valid_bits,
-      valid_bits_offset,
-      num_values,
-      null_count,
+      validBits,
+      validBitsOffset,
+      numValues,
+      nullCount,
       [&]() {
         int32_t index;
-        if (ARROW_PREDICT_FALSE(!idx_decoder_.Get(&index))) {
+        if (ARROW_PREDICT_FALSE(!idxDecoder_.Get(&index))) {
           throw ParquetException("");
         }
-        PARQUET_THROW_NOT_OK(IndexInBounds(index));
-        builder->UnsafeAppend(dict_values[index].ptr);
+        PARQUET_THROW_NOT_OK(indexInBounds(index));
+        Builder->UnsafeAppend(dictValues[index].ptr);
       },
-      [&]() { builder->UnsafeAppendNull(); });
+      [&]() { Builder->UnsafeAppendNull(); });
 
-  return num_values - null_count;
+  return numValues - nullCount;
 }
 
 template <>
-int DictDecoderImpl<FLBAType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<FLBAType>::DictAccumulator* builder) {
-  auto value_type =
-      checked_cast<const ::arrow::DictionaryType&>(*builder->type())
+int DictDecoderImpl<FLBAType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<FLBAType>::DictAccumulator* Builder) {
+  auto valueType =
+      checked_cast<const ::arrow::DictionaryType&>(*Builder->type())
           .value_type();
-  auto byte_width =
-      checked_cast<const ::arrow::FixedSizeBinaryType&>(*value_type)
-          .byte_width();
-  if (byte_width != descr_->type_length()) {
+  auto byteWidth = checked_cast<const ::arrow::FixedSizeBinaryType&>(*valueType)
+                       .byte_width();
+  if (byteWidth != descr_->typeLength()) {
     throw ParquetException(
-        "Byte width mismatch: builder was " + std::to_string(byte_width) +
-        " but decoder was " + std::to_string(descr_->type_length()));
+        "Byte width mismatch: builder was " + std::to_string(byteWidth) +
+        " but decoder was " + std::to_string(descr_->typeLength()));
   }
 
-  PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
+  PARQUET_THROW_NOT_OK(Builder->Reserve(numValues));
 
-  auto dict_values = reinterpret_cast<const FLBA*>(dictionary_->data());
+  auto dictValues = reinterpret_cast<const FLBA*>(dictionary_->data());
 
   VisitNullBitmapInline(
-      valid_bits,
-      valid_bits_offset,
-      num_values,
-      null_count,
+      validBits,
+      validBitsOffset,
+      numValues,
+      nullCount,
       [&]() {
         int32_t index;
-        if (ARROW_PREDICT_FALSE(!idx_decoder_.Get(&index))) {
+        if (ARROW_PREDICT_FALSE(!idxDecoder_.Get(&index))) {
           throw ParquetException("");
         }
-        PARQUET_THROW_NOT_OK(IndexInBounds(index));
-        PARQUET_THROW_NOT_OK(builder->Append(dict_values[index].ptr));
+        PARQUET_THROW_NOT_OK(indexInBounds(index));
+        PARQUET_THROW_NOT_OK(Builder->Append(dictValues[index].ptr));
       },
-      [&]() { PARQUET_THROW_NOT_OK(builder->AppendNull()); });
+      [&]() { PARQUET_THROW_NOT_OK(Builder->AppendNull()); });
 
-  return num_values - null_count;
+  return numValues - nullCount;
 }
 
 template <typename Type>
-int DictDecoderImpl<Type>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<Type>::Accumulator* builder) {
-  PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
+int DictDecoderImpl<Type>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<Type>::Accumulator* Builder) {
+  PARQUET_THROW_NOT_OK(Builder->Reserve(numValues));
 
-  using value_type = typename Type::c_type;
-  auto dict_values = reinterpret_cast<const value_type*>(dictionary_->data());
+  using ValueType = typename Type::CType;
+  auto dictValues = reinterpret_cast<const ValueType*>(dictionary_->data());
 
   VisitNullBitmapInline(
-      valid_bits,
-      valid_bits_offset,
-      num_values,
-      null_count,
+      validBits,
+      validBitsOffset,
+      numValues,
+      nullCount,
       [&]() {
         int32_t index;
-        if (ARROW_PREDICT_FALSE(!idx_decoder_.Get(&index))) {
+        if (ARROW_PREDICT_FALSE(!idxDecoder_.Get(&index))) {
           throw ParquetException("");
         }
-        PARQUET_THROW_NOT_OK(IndexInBounds(index));
-        builder->UnsafeAppend(dict_values[index]);
+        PARQUET_THROW_NOT_OK(indexInBounds(index));
+        Builder->UnsafeAppend(dictValues[index]);
       },
-      [&]() { builder->UnsafeAppendNull(); });
+      [&]() { Builder->UnsafeAppendNull(); });
 
-  return num_values - null_count;
+  return numValues - nullCount;
 }
 
 template <typename Type>
-void DictDecoderImpl<Type>::InsertDictionary(::arrow::ArrayBuilder* builder) {
+void DictDecoderImpl<Type>::insertDictionary(::arrow::ArrayBuilder* Builder) {
   ParquetException::NYI(
       "InsertDictionary only implemented for BYTE_ARRAY types");
 }
 
 template <>
-void DictDecoderImpl<ByteArrayType>::InsertDictionary(
-    ::arrow::ArrayBuilder* builder) {
-  auto binary_builder =
-      checked_cast<::arrow::BinaryDictionary32Builder*>(builder);
+void DictDecoderImpl<ByteArrayType>::insertDictionary(
+    ::arrow::ArrayBuilder* Builder) {
+  auto binaryBuilder =
+      checked_cast<::arrow::BinaryDictionary32Builder*>(Builder);
 
-  // Make a BinaryArray referencing the internal dictionary data
+  // Make a BinaryArray referencing the internal dictionary data.
   auto arr = std::make_shared<::arrow::BinaryArray>(
-      dictionary_length_, byte_array_offsets_, byte_array_data_);
-  PARQUET_THROW_NOT_OK(binary_builder->InsertMemoValues(*arr));
+      dictionaryLength_, byteArrayOffsets_, byteArrayData_);
+  PARQUET_THROW_NOT_OK(binaryBuilder->InsertMemoValues(*arr));
 }
 
 class DictByteArrayDecoderImpl : public DictDecoderImpl<ByteArrayType>,
@@ -2198,497 +2172,489 @@ class DictByteArrayDecoderImpl : public DictDecoderImpl<ByteArrayType>,
   using BASE = DictDecoderImpl<ByteArrayType>;
   using BASE::DictDecoderImpl;
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      ::arrow::BinaryDictionary32Builder* builder) override {
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      ::arrow::BinaryDictionary32Builder* Builder) override {
     int result = 0;
-    if (null_count == 0) {
-      PARQUET_THROW_NOT_OK(DecodeArrowNonNull(num_values, builder, &result));
+    if (nullCount == 0) {
+      PARQUET_THROW_NOT_OK(decodeArrowNonNull(numValues, Builder, &result));
     } else {
-      PARQUET_THROW_NOT_OK(DecodeArrow(
-          num_values,
-          null_count,
-          valid_bits,
-          valid_bits_offset,
-          builder,
-          &result));
+      PARQUET_THROW_NOT_OK(decodeArrow(
+          numValues, nullCount, validBits, validBitsOffset, Builder, &result));
     }
     return result;
   }
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<ByteArrayType>::Accumulator* out) override {
     int result = 0;
-    if (null_count == 0) {
-      PARQUET_THROW_NOT_OK(DecodeArrowDenseNonNull(num_values, out, &result));
+    if (nullCount == 0) {
+      PARQUET_THROW_NOT_OK(decodeArrowDenseNonNull(numValues, out, &result));
     } else {
-      PARQUET_THROW_NOT_OK(DecodeArrowDense(
-          num_values, null_count, valid_bits, valid_bits_offset, out, &result));
+      PARQUET_THROW_NOT_OK(decodeArrowDense(
+          numValues, nullCount, validBits, validBitsOffset, out, &result));
     }
     return result;
   }
 
  private:
-  Status DecodeArrowDense(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  Status decodeArrowDense(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<ByteArrayType>::Accumulator* out,
-      int* out_num_values) {
+      int* outNumValues) {
     constexpr int32_t kBufferSize = 1024;
     int32_t indices[kBufferSize];
 
-    ArrowBinaryHelper<ByteArrayType> helper(out, num_values);
-    RETURN_NOT_OK(helper.Prepare());
-
-    auto dict_values = reinterpret_cast<const ByteArray*>(dictionary_->data());
-    int values_decoded = 0;
-    int num_indices = 0;
-    int pos_indices = 0;
-
-    auto visit_valid = [&](int64_t position) -> Status {
-      if (num_indices == pos_indices) {
-        // Refill indices buffer
-        const auto batch_size = std::min<int32_t>(
-            kBufferSize, num_values - null_count - values_decoded);
-        num_indices = idx_decoder_.GetBatch(indices, batch_size);
-        if (ARROW_PREDICT_FALSE(num_indices < 1)) {
-          return Status::Invalid("Invalid number of indices: ", num_indices);
+    ArrowBinaryHelper<ByteArrayType> helper(out, numValues);
+    RETURN_NOT_OK(helper.prepare());
+
+    auto dictValues = reinterpret_cast<const ByteArray*>(dictionary_->data());
+    int valuesDecoded = 0;
+    int numIndices = 0;
+    int posIndices = 0;
+
+    auto visitValid = [&](int64_t position) -> Status {
+      if (numIndices == posIndices) {
+        // Refill indices buffer.
+        const auto batchSize = std::min<int32_t>(
+            kBufferSize, numValues - nullCount - valuesDecoded);
+        numIndices = idxDecoder_.GetBatch(indices, batchSize);
+        if (ARROW_PREDICT_FALSE(numIndices < 1)) {
+          return Status::Invalid("Invalid number of indices: ", numIndices);
         }
-        pos_indices = 0;
+        posIndices = 0;
       }
-      const auto index = indices[pos_indices++];
-      RETURN_NOT_OK(IndexInBounds(index));
-      const auto& val = dict_values[index];
-      RETURN_NOT_OK(helper.PrepareNextInput(val.len));
+      const auto index = indices[posIndices++];
+      RETURN_NOT_OK(indexInBounds(index));
+      const auto& val = dictValues[index];
+      RETURN_NOT_OK(helper.prepareNextInput(val.len));
       RETURN_NOT_OK(helper.Append(val.ptr, static_cast<int32_t>(val.len)));
-      ++values_decoded;
+      ++valuesDecoded;
       return Status::OK();
     };
 
-    auto visit_null = [&]() -> Status {
+    auto visitNull = [&]() -> Status {
       RETURN_NOT_OK(helper.AppendNull());
       return Status::OK();
     };
 
-    ::arrow::internal::BitBlockCounter bit_blocks(
-        valid_bits, valid_bits_offset, num_values);
+    ::arrow::internal::BitBlockCounter bitBlocks(
+        validBits, validBitsOffset, numValues);
     int64_t position = 0;
-    while (position < num_values) {
-      const auto block = bit_blocks.NextWord();
+    while (position < numValues) {
+      const auto block = bitBlocks.NextWord();
       if (block.AllSet()) {
         for (int64_t i = 0; i < block.length; ++i, ++position) {
-          ARROW_RETURN_NOT_OK(visit_valid(position));
+          ARROW_RETURN_NOT_OK(visitValid(position));
         }
       } else if (block.NoneSet()) {
         for (int64_t i = 0; i < block.length; ++i, ++position) {
-          ARROW_RETURN_NOT_OK(visit_null());
+          ARROW_RETURN_NOT_OK(visitNull());
         }
       } else {
         for (int64_t i = 0; i < block.length; ++i, ++position) {
           if (::arrow::bit_util::GetBit(
-                  valid_bits, valid_bits_offset + position)) {
-            ARROW_RETURN_NOT_OK(visit_valid(position));
+                  validBits, validBitsOffset + position)) {
+            ARROW_RETURN_NOT_OK(visitValid(position));
           } else {
-            ARROW_RETURN_NOT_OK(visit_null());
+            ARROW_RETURN_NOT_OK(visitNull());
           }
         }
       }
     }
 
-    *out_num_values = values_decoded;
+    *outNumValues = valuesDecoded;
     return Status::OK();
   }
 
-  Status DecodeArrowDenseNonNull(
-      int num_values,
+  Status decodeArrowDenseNonNull(
+      int numValues,
       typename EncodingTraits<ByteArrayType>::Accumulator* out,
-      int* out_num_values) {
+      int* outNumValues) {
     constexpr int32_t kBufferSize = 2048;
     int32_t indices[kBufferSize];
-    int values_decoded = 0;
+    int valuesDecoded = 0;
 
-    ArrowBinaryHelper<ByteArrayType> helper(out, num_values);
-    RETURN_NOT_OK(helper.Prepare(len_));
+    ArrowBinaryHelper<ByteArrayType> helper(out, numValues);
+    RETURN_NOT_OK(helper.prepare(len_));
 
-    auto dict_values = reinterpret_cast<const ByteArray*>(dictionary_->data());
+    auto dictValues = reinterpret_cast<const ByteArray*>(dictionary_->data());
 
-    while (values_decoded < num_values) {
-      const int32_t batch_size =
-          std::min<int32_t>(kBufferSize, num_values - values_decoded);
-      const int num_indices = idx_decoder_.GetBatch(indices, batch_size);
-      if (num_indices == 0)
-        ParquetException::EofException();
-      for (int i = 0; i < num_indices; ++i) {
+    while (valuesDecoded < numValues) {
+      const int32_t batchSize =
+          std::min<int32_t>(kBufferSize, numValues - valuesDecoded);
+      const int numIndices = idxDecoder_.GetBatch(indices, batchSize);
+      if (numIndices == 0)
+        ParquetException::eofException();
+      for (int i = 0; i < numIndices; ++i) {
         auto idx = indices[i];
-        RETURN_NOT_OK(IndexInBounds(idx));
-        const auto& val = dict_values[idx];
-        RETURN_NOT_OK(helper.PrepareNextInput(val.len));
+        RETURN_NOT_OK(indexInBounds(idx));
+        const auto& val = dictValues[idx];
+        RETURN_NOT_OK(helper.prepareNextInput(val.len));
         RETURN_NOT_OK(helper.Append(val.ptr, static_cast<int32_t>(val.len)));
       }
-      values_decoded += num_indices;
+      valuesDecoded += numIndices;
     }
-    *out_num_values = values_decoded;
+    *outNumValues = valuesDecoded;
     return Status::OK();
   }
 
   template <typename BuilderType>
-  Status DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      BuilderType* builder,
-      int* out_num_values) {
+  Status decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      BuilderType* Builder,
+      int* outNumValues) {
     constexpr int32_t kBufferSize = 1024;
     int32_t indices[kBufferSize];
 
-    RETURN_NOT_OK(builder->Reserve(num_values));
-    ::arrow::internal::BitmapReader bit_reader(
-        valid_bits, valid_bits_offset, num_values);
+    RETURN_NOT_OK(Builder->Reserve(numValues));
+    ::arrow::internal::BitmapReader bitReader(
+        validBits, validBitsOffset, numValues);
 
-    auto dict_values = reinterpret_cast<const ByteArray*>(dictionary_->data());
+    auto dictValues = reinterpret_cast<const ByteArray*>(dictionary_->data());
 
-    int values_decoded = 0;
-    int num_appended = 0;
-    while (num_appended < num_values) {
-      bool is_valid = bit_reader.IsSet();
-      bit_reader.Next();
+    int valuesDecoded = 0;
+    int numAppended = 0;
+    while (numAppended < numValues) {
+      bool isValid = bitReader.IsSet();
+      bitReader.Next();
 
-      if (is_valid) {
-        int32_t batch_size = std::min<int32_t>(
-            kBufferSize, num_values - num_appended - null_count);
-        int num_indices = idx_decoder_.GetBatch(indices, batch_size);
+      if (isValid) {
+        int32_t batchSize =
+            std::min<int32_t>(kBufferSize, numValues - numAppended - nullCount);
+        int numIndices = idxDecoder_.GetBatch(indices, batchSize);
 
         int i = 0;
         while (true) {
-          // Consume all indices
-          if (is_valid) {
+          // Consume all indices.
+          if (isValid) {
             auto idx = indices[i];
-            RETURN_NOT_OK(IndexInBounds(idx));
-            const auto& val = dict_values[idx];
-            RETURN_NOT_OK(builder->Append(val.ptr, val.len));
+            RETURN_NOT_OK(indexInBounds(idx));
+            const auto& val = dictValues[idx];
+            RETURN_NOT_OK(Builder->Append(val.ptr, val.len));
             ++i;
-            ++values_decoded;
+            ++valuesDecoded;
           } else {
-            RETURN_NOT_OK(builder->AppendNull());
-            --null_count;
+            RETURN_NOT_OK(Builder->AppendNull());
+            --nullCount;
           }
-          ++num_appended;
-          if (i == num_indices) {
-            // Do not advance the bit_reader if we have fulfilled the decode
-            // request
+          ++numAppended;
+          if (i == numIndices) {
+            // Do not advance the bit_reader if we have fulfilled the decode.
+            // Request.
             break;
           }
-          is_valid = bit_reader.IsSet();
-          bit_reader.Next();
+          isValid = bitReader.IsSet();
+          bitReader.Next();
         }
       } else {
-        RETURN_NOT_OK(builder->AppendNull());
-        --null_count;
-        ++num_appended;
+        RETURN_NOT_OK(Builder->AppendNull());
+        --nullCount;
+        ++numAppended;
       }
     }
-    *out_num_values = values_decoded;
+    *outNumValues = valuesDecoded;
     return Status::OK();
   }
 
   template <typename BuilderType>
-  Status DecodeArrowNonNull(
-      int num_values,
-      BuilderType* builder,
-      int* out_num_values) {
+  Status
+  decodeArrowNonNull(int numValues, BuilderType* Builder, int* outNumValues) {
     constexpr int32_t kBufferSize = 2048;
     int32_t indices[kBufferSize];
 
-    RETURN_NOT_OK(builder->Reserve(num_values));
+    RETURN_NOT_OK(Builder->Reserve(numValues));
 
-    auto dict_values = reinterpret_cast<const ByteArray*>(dictionary_->data());
+    auto dictValues = reinterpret_cast<const ByteArray*>(dictionary_->data());
 
-    int values_decoded = 0;
-    while (values_decoded < num_values) {
-      int32_t batch_size =
-          std::min<int32_t>(kBufferSize, num_values - values_decoded);
-      int num_indices = idx_decoder_.GetBatch(indices, batch_size);
-      if (num_indices == 0)
-        ParquetException::EofException();
-      for (int i = 0; i < num_indices; ++i) {
+    int valuesDecoded = 0;
+    while (valuesDecoded < numValues) {
+      int32_t batchSize =
+          std::min<int32_t>(kBufferSize, numValues - valuesDecoded);
+      int numIndices = idxDecoder_.GetBatch(indices, batchSize);
+      if (numIndices == 0)
+        ParquetException::eofException();
+      for (int i = 0; i < numIndices; ++i) {
         auto idx = indices[i];
-        RETURN_NOT_OK(IndexInBounds(idx));
-        const auto& val = dict_values[idx];
-        RETURN_NOT_OK(builder->Append(val.ptr, val.len));
+        RETURN_NOT_OK(indexInBounds(idx));
+        const auto& val = dictValues[idx];
+        RETURN_NOT_OK(Builder->Append(val.ptr, val.len));
       }
-      values_decoded += num_indices;
+      valuesDecoded += numIndices;
     }
-    *out_num_values = values_decoded;
+    *outNumValues = valuesDecoded;
     return Status::OK();
   }
 };
 
-// ----------------------------------------------------------------------
-// DeltaBitPackEncoder
+// ----------------------------------------------------------------------.
+// DeltaBitPackEncoder.
 
-/// DeltaBitPackEncoder is an encoder for the DeltaBinary Packing format
-/// as per the parquet spec. See:
+/// DeltaBitPackEncoder is an encoder for the DeltaBinary Packing format.
+/// As per the parquet spec. See:
 /// https://github.com/apache/parquet-format/blob/master/Encodings.md#delta-encoding-delta_binary_packed--5
 ///
-/// Consists of a header followed by blocks of delta encoded values binary
-/// packed.
+/// Consists of a header followed by blocks of delta encoded values binary.
+/// Packed.
 ///
-///  Format
-///    [header] [block 1] [block 2] ... [block N]
+///  Format.
+///    [Header] [block 1] [block 2] ... [block N].
 ///
-///  Header
-///    [block size] [number of mini blocks per block] [total value count] [first
-///    value]
+///  Header.
+///    [Block size] [number of mini blocks per block] [total value count]
+///    [first. Value].
 ///
-///  Block
-///    [min delta] [list of bitwidths of the mini blocks] [miniblocks]
+///  Block.
+///    [Min delta] [list of bitwidths of the mini blocks] [miniblocks].
 ///
-/// Sets aside bytes at the start of the internal buffer where the header will
-/// be written, and only writes the header when FlushValues is called before
-/// returning it.
+/// Sets aside bytes at the start of the internal buffer where the header will.
+/// Be written, and only writes the header when FlushValues is called before.
+/// Returning it.
 ///
 /// To encode a block, we will:
 ///
-/// 1. Compute the differences between consecutive elements. For the first
-/// element in the block, use the last element in the previous block or, in the
-/// case of the first block, use the first value of the whole sequence, stored
-/// in the header.
+/// 1. Compute the differences between consecutive elements. For the first.
+/// Element in the block, use the last element in the previous block or, in the.
+/// Case of the first block, use the first value of the whole sequence, stored.
+/// In the header.
 ///
 /// 2. Compute the frame of reference (the minimum of the deltas in the block).
-/// Subtract this min delta from all deltas in the block. This guarantees that
-/// all values are non-negative.
+/// Subtract this min delta from all deltas in the block. This guarantees that.
+/// All values are non-negative.
 ///
-/// 3. Encode the frame of reference (min delta) as a zigzag ULEB128 int
-/// followed by the bit widths of the mini blocks and the delta values (minus
-/// the min delta) bit packed per mini block.
+/// 3. Encode the frame of reference (min delta) as a zigzag ULEB128 int.
+/// Followed by the bit widths of the mini blocks and the delta values (minus.
+/// The min delta) bit packed per mini block.
 ///
 /// Supports only INT32 and INT64.
 
 template <typename DType>
 class DeltaBitPackEncoder : public EncoderImpl,
                             virtual public TypedEncoder<DType> {
-  // Maximum possible header size
+  // Maximum possible header size.
   static constexpr uint32_t kMaxPageHeaderWriterSize = 32;
   static constexpr uint32_t kValuesPerBlock =
-      std::is_same_v<int32_t, typename DType::c_type> ? 128 : 256;
+      std::is_same_v<int32_t, typename DType::CType> ? 128 : 256;
   static constexpr uint32_t kMiniBlocksPerBlock = 4;
 
  public:
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
   using UT = std::make_unsigned_t<T>;
-  using TypedEncoder<DType>::Put;
+  using TypedEncoder<DType>::put;
 
   explicit DeltaBitPackEncoder(
       const ColumnDescriptor* descr,
       MemoryPool* pool,
-      const uint32_t values_per_block = kValuesPerBlock,
-      const uint32_t mini_blocks_per_block = kMiniBlocksPerBlock)
-      : EncoderImpl(descr, Encoding::DELTA_BINARY_PACKED, pool),
-        values_per_block_(values_per_block),
-        mini_blocks_per_block_(mini_blocks_per_block),
-        values_per_mini_block_(values_per_block / mini_blocks_per_block),
-        deltas_(values_per_block, ::arrow::stl::allocator<T>(pool)),
-        bits_buffer_(AllocateBuffer(
+      const uint32_t valuesPerBlock = kValuesPerBlock,
+      const uint32_t miniBlocksPerBlock = kMiniBlocksPerBlock)
+      : EncoderImpl(descr, Encoding::kDeltaBinaryPacked, pool),
+        valuesPerBlock_(valuesPerBlock),
+        miniBlocksPerBlock_(miniBlocksPerBlock),
+        valuesPerMiniBlock_(valuesPerBlock / miniBlocksPerBlock),
+        deltas_(valuesPerBlock, ::arrow::stl::allocator<T>(pool)),
+        bitsBuffer_(allocateBuffer(
             pool,
-            (kMiniBlocksPerBlock + values_per_block) * sizeof(T))),
+            (kMiniBlocksPerBlock + valuesPerBlock) * sizeof(T))),
         sink_(pool),
-        bit_writer_(
-            bits_buffer_->mutable_data(),
-            static_cast<int>(bits_buffer_->size())) {
-    if (values_per_block_ % 128 != 0) {
+        bitWriter_(
+            bitsBuffer_->mutable_data(),
+            static_cast<int>(bitsBuffer_->size())) {
+    if (valuesPerBlock_ % 128 != 0) {
       throw ParquetException(
           "the number of values in a block must be multiple of 128, but it's " +
-          std::to_string(values_per_block_));
+          std::to_string(valuesPerBlock_));
     }
-    if (values_per_mini_block_ % 32 != 0) {
+    if (valuesPerMiniBlock_ % 32 != 0) {
       throw ParquetException(
           "the number of values in a miniblock must be multiple of 32, but it's " +
-          std::to_string(values_per_mini_block_));
+          std::to_string(valuesPerMiniBlock_));
     }
-    if (values_per_block % mini_blocks_per_block != 0) {
+    if (valuesPerBlock % miniBlocksPerBlock != 0) {
       throw ParquetException(
           "the number of values per block % number of miniblocks per block must be 0, "
           "but it's " +
-          std::to_string(values_per_block % mini_blocks_per_block));
+          std::to_string(valuesPerBlock % miniBlocksPerBlock));
     }
-    // Reserve enough space at the beginning of the buffer for largest possible
-    // header.
+    // Reserve enough space at the beginning of the buffer for largest possible.
+    // Header.
     PARQUET_THROW_NOT_OK(sink_.Advance(kMaxPageHeaderWriterSize));
   }
 
-  std::shared_ptr<::arrow::Buffer> FlushValues() override;
+  std::shared_ptr<::arrow::Buffer> flushValues() override;
 
-  int64_t EstimatedDataEncodedSize() override {
+  int64_t estimatedDataEncodedSize() override {
     return sink_.length();
   }
 
-  void Put(const ::arrow::Array& values) override;
+  void put(const ::arrow::Array& values) override;
 
-  void Put(const T* buffer, int num_values) override;
+  void put(const T* buffer, int numValues) override;
 
-  void PutSpaced(
+  void putSpaced(
       const T* src,
-      int num_values,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset) override;
+      int numValues,
+      const uint8_t* validBits,
+      int64_t validBitsOffset) override;
 
-  void FlushBlock();
+  void flushBlock();
 
  private:
-  const uint32_t values_per_block_;
-  const uint32_t mini_blocks_per_block_;
-  const uint32_t values_per_mini_block_;
-  uint32_t values_current_block_{0};
-  uint32_t total_value_count_{0};
-  UT first_value_{0};
-  UT current_value_{0};
+  const uint32_t valuesPerBlock_;
+  const uint32_t miniBlocksPerBlock_;
+  const uint32_t valuesPerMiniBlock_;
+  uint32_t valuesCurrentBlock_{0};
+  uint32_t totalValueCount_{0};
+  UT firstValue_{0};
+  UT currentValue_{0};
   ArrowPoolVector<UT> deltas_;
-  std::shared_ptr<ResizableBuffer> bits_buffer_;
+  std::shared_ptr<ResizableBuffer> bitsBuffer_;
   ::arrow::BufferBuilder sink_;
-  BitWriter bit_writer_;
+  BitWriter bitWriter_;
 };
 
 template <typename DType>
-void DeltaBitPackEncoder<DType>::Put(const T* src, int num_values) {
-  if (num_values == 0) {
+void DeltaBitPackEncoder<DType>::put(const T* src, int numValues) {
+  if (numValues == 0) {
     return;
   }
 
   int idx = 0;
-  if (total_value_count_ == 0) {
-    current_value_ = src[0];
-    first_value_ = current_value_;
+  if (totalValueCount_ == 0) {
+    currentValue_ = src[0];
+    firstValue_ = currentValue_;
     idx = 1;
   }
-  total_value_count_ += num_values;
+  totalValueCount_ += numValues;
 
-  while (idx < num_values) {
+  while (idx < numValues) {
     UT value = static_cast<UT>(src[idx]);
-    // Calculate deltas. The possible overflow is handled by use of unsigned
-    // integers making subtraction operations well-defined and correct even in
-    // case of overflow. Encoded integers will wrap back around on decoding. See
-    // http://en.wikipedia.org/wiki/Modular_arithmetic#Integers_modulo_n
-    deltas_[values_current_block_] = value - current_value_;
-    current_value_ = value;
+    // Calculate deltas. The possible overflow is handled by use of unsigned.
+    // Integers making subtraction operations well-defined and correct even in.
+    // Case of overflow. Encoded integers will wrap back around on decoding.
+    // See. http://en.wikipedia.org/wiki/Modular_arithmetic#Integers_modulo_n
+    deltas_[valuesCurrentBlock_] = value - currentValue_;
+    currentValue_ = value;
     idx++;
-    values_current_block_++;
-    if (values_current_block_ == values_per_block_) {
-      FlushBlock();
+    valuesCurrentBlock_++;
+    if (valuesCurrentBlock_ == valuesPerBlock_) {
+      flushBlock();
     }
   }
 }
 
 template <typename DType>
-void DeltaBitPackEncoder<DType>::FlushBlock() {
-  if (values_current_block_ == 0) {
+void DeltaBitPackEncoder<DType>::flushBlock() {
+  if (valuesCurrentBlock_ == 0) {
     return;
   }
 
-  const UT min_delta = *std::min_element(
-      deltas_.begin(), deltas_.begin() + values_current_block_);
-  bit_writer_.PutZigZagVlqInt(static_cast<T>(min_delta));
+  const UT minDelta =
+      *std::min_element(deltas_.begin(), deltas_.begin() + valuesCurrentBlock_);
+  bitWriter_.PutZigZagVlqInt(static_cast<T>(minDelta));
 
-  // Call to GetNextBytePtr reserves mini_blocks_per_block_ bytes of space to
-  // write bit widths of miniblocks as they become known during the encoding.
-  uint8_t* bit_width_data = bit_writer_.GetNextBytePtr(mini_blocks_per_block_);
-  VELOX_DCHECK(bit_width_data != nullptr);
+  // Call to GetNextBytePtr reserves mini_blocks_per_block_ bytes of space to.
+  // Write bit widths of miniblocks as they become known during the encoding.
+  uint8_t* bitWidthData = bitWriter_.GetNextBytePtr(miniBlocksPerBlock_);
+  VELOX_DCHECK(bitWidthData != nullptr);
 
-  const uint32_t num_miniblocks = static_cast<uint32_t>(std::ceil(
-      static_cast<double>(values_current_block_) /
-      static_cast<double>(values_per_mini_block_)));
-  for (uint32_t i = 0; i < num_miniblocks; i++) {
-    const uint32_t values_current_mini_block =
-        std::min(values_per_mini_block_, values_current_block_);
+  const uint32_t numMiniblocks = static_cast<uint32_t>(std::ceil(
+      static_cast<double>(valuesCurrentBlock_) /
+      static_cast<double>(valuesPerMiniBlock_)));
+  for (uint32_t i = 0; i < numMiniblocks; i++) {
+    const uint32_t valuesCurrentMiniBlock =
+        std::min(valuesPerMiniBlock_, valuesCurrentBlock_);
 
-    const uint32_t start = i * values_per_mini_block_;
-    const UT max_delta = *std::max_element(
+    const uint32_t start = i * valuesPerMiniBlock_;
+    const UT maxDelta = *std::max_element(
         deltas_.begin() + start,
-        deltas_.begin() + start + values_current_mini_block);
+        deltas_.begin() + start + valuesCurrentMiniBlock);
 
-    // The minimum number of bits required to write any of values in deltas_
-    // vector. See overflow comment above.
-    const auto bit_width = bit_width_data[i] =
-        ::arrow::bit_util::NumRequiredBits(max_delta - min_delta);
+    // The minimum number of bits required to write any of values in deltas_.
+    // Vector. See overflow comment above.
+    const auto bitWidth = bitWidthData[i] =
+        ::arrow::bit_util::NumRequiredBits(maxDelta - minDelta);
 
-    for (uint32_t j = start; j < start + values_current_mini_block; j++) {
+    for (uint32_t j = start; j < start + valuesCurrentMiniBlock; j++) {
       // See overflow comment above.
-      const UT value = deltas_[j] - min_delta;
-      bit_writer_.PutValue(value, bit_width);
+      const UT value = deltas_[j] - minDelta;
+      bitWriter_.PutValue(value, bitWidth);
     }
-    // If there are not enough values to fill the last mini block, we pad the
-    // mini block with zeroes so that its length is the number of values in a
-    // full mini block multiplied by the bit width.
-    for (uint32_t j = values_current_mini_block; j < values_per_mini_block_;
-         j++) {
-      bit_writer_.PutValue(0, bit_width);
+    // If there are not enough values to fill the last mini block, we pad the.
+    // Mini block with zeroes so that its length is the number of values in a.
+    // Full mini block multiplied by the bit width.
+    for (uint32_t j = valuesCurrentMiniBlock; j < valuesPerMiniBlock_; j++) {
+      bitWriter_.PutValue(0, bitWidth);
     }
-    values_current_block_ -= values_current_mini_block;
+    valuesCurrentBlock_ -= valuesCurrentMiniBlock;
   }
 
-  // If, in the last block, less than <number of miniblocks in a block>
-  // miniblocks are needed to store the values, the bytes storing the bit widths
-  // of the unneeded miniblocks are still present, their value should be zero,
-  // but readers must accept arbitrary values as well.
-  for (uint32_t i = num_miniblocks; i < mini_blocks_per_block_; i++) {
-    bit_width_data[i] = 0;
+  // If, in the last block, less than <number of miniblocks in a block>.
+  // Miniblocks are needed to store the values, the bytes storing the bit
+  // widths. Of the unneeded miniblocks are still present, their value should be
+  // zero,. But readers must accept arbitrary values as well.
+  for (uint32_t i = numMiniblocks; i < miniBlocksPerBlock_; i++) {
+    bitWidthData[i] = 0;
   }
-  VELOX_DCHECK_EQ(values_current_block_, 0);
+  VELOX_DCHECK_EQ(valuesCurrentBlock_, 0);
 
-  bit_writer_.Flush();
+  bitWriter_.Flush();
   PARQUET_THROW_NOT_OK(
-      sink_.Append(bit_writer_.buffer(), bit_writer_.bytesWritten()));
-  bit_writer_.Clear();
+      sink_.Append(bitWriter_.buffer(), bitWriter_.bytesWritten()));
+  bitWriter_.Clear();
 }
 
 template <typename DType>
-std::shared_ptr<::arrow::Buffer> DeltaBitPackEncoder<DType>::FlushValues() {
-  if (values_current_block_ > 0) {
-    FlushBlock();
-  }
-  PARQUET_ASSIGN_OR_THROW(auto buffer, sink_.Finish(/*shrink_to_fit=*/true));
-
-  uint8_t header_buffer_[kMaxPageHeaderWriterSize] = {};
-  BitWriter header_writer(header_buffer_, sizeof(header_buffer_));
-  if (!header_writer.PutVlqInt(values_per_block_) ||
-      !header_writer.PutVlqInt(mini_blocks_per_block_) ||
-      !header_writer.PutVlqInt(total_value_count_) ||
-      !header_writer.PutZigZagVlqInt(static_cast<T>(first_value_))) {
+std::shared_ptr<::arrow::Buffer> DeltaBitPackEncoder<DType>::flushValues() {
+  if (valuesCurrentBlock_ > 0) {
+    flushBlock();
+  }
+  PARQUET_ASSIGN_OR_THROW(auto buffer, sink_.Finish(true));
+
+  uint8_t headerBuffer_[kMaxPageHeaderWriterSize] = {};
+  BitWriter headerWriter(headerBuffer_, sizeof(headerBuffer_));
+  if (!headerWriter.PutVlqInt(valuesPerBlock_) ||
+      !headerWriter.PutVlqInt(miniBlocksPerBlock_) ||
+      !headerWriter.PutVlqInt(totalValueCount_) ||
+      !headerWriter.PutZigZagVlqInt(static_cast<T>(firstValue_))) {
     throw ParquetException("header writing error");
   }
-  header_writer.Flush();
+  headerWriter.Flush();
 
-  // We reserved enough space at the beginning of the buffer for largest
-  // possible header and data was written immediately after. We now write the
-  // header data immediately before the end of reserved space.
-  const size_t offset_bytes =
-      kMaxPageHeaderWriterSize - header_writer.bytesWritten();
+  // We reserved enough space at the beginning of the buffer for largest.
+  // Possible header and data was written immediately after. We now write the.
+  // Header data immediately before the end of reserved space.
+  const size_t offsetBytes =
+      kMaxPageHeaderWriterSize - headerWriter.bytesWritten();
   std::memcpy(
-      buffer->mutable_data() + offset_bytes,
-      header_buffer_,
-      header_writer.bytesWritten());
-
-  // Reset counter of cached values
-  total_value_count_ = 0;
-  // Reserve enough space at the beginning of the buffer for largest possible
-  // header.
+      buffer->mutable_data() + offsetBytes,
+      headerBuffer_,
+      headerWriter.bytesWritten());
+
+  // Reset counter of cached values.
+  totalValueCount_ = 0;
+  // Reserve enough space at the beginning of the buffer for largest possible.
+  // Header.
   PARQUET_THROW_NOT_OK(sink_.Advance(kMaxPageHeaderWriterSize));
 
   // Excess bytes at the beginning are sliced off and ignored.
-  return SliceBuffer(buffer, offset_bytes);
+  return ::arrow::SliceBuffer(buffer, offsetBytes);
 }
 
 template <>
-void DeltaBitPackEncoder<Int32Type>::Put(const ::arrow::Array& values) {
+void DeltaBitPackEncoder<Int32Type>::put(const ::arrow::Array& values) {
   const ::arrow::ArrayData& data = *values.data();
   if (values.type_id() != ::arrow::Type::INT32) {
     throw ParquetException(
@@ -2700,9 +2666,9 @@ void DeltaBitPackEncoder<Int32Type>::Put(const ::arrow::Array& values) {
   }
 
   if (values.null_count() == 0) {
-    Put(data.GetValues<int32_t>(1), static_cast<int>(data.length));
+    put(data.GetValues<int32_t>(1), static_cast<int>(data.length));
   } else {
-    PutSpaced(
+    putSpaced(
         data.GetValues<int32_t>(1),
         static_cast<int>(data.length),
         data.GetValues<uint8_t>(0, 0),
@@ -2711,7 +2677,7 @@ void DeltaBitPackEncoder<Int32Type>::Put(const ::arrow::Array& values) {
 }
 
 template <>
-void DeltaBitPackEncoder<Int64Type>::Put(const ::arrow::Array& values) {
+void DeltaBitPackEncoder<Int64Type>::put(const ::arrow::Array& values) {
   const ::arrow::ArrayData& data = *values.data();
   if (values.type_id() != ::arrow::Type::INT64) {
     throw ParquetException(
@@ -2722,9 +2688,9 @@ void DeltaBitPackEncoder<Int64Type>::Put(const ::arrow::Array& values) {
         "Array cannot be longer than ", std::numeric_limits<int32_t>::max());
   }
   if (values.null_count() == 0) {
-    Put(data.GetValues<int64_t>(1), static_cast<int>(data.length));
+    put(data.GetValues<int64_t>(1), static_cast<int>(data.length));
   } else {
-    PutSpaced(
+    putSpaced(
         data.GetValues<int64_t>(1),
         static_cast<int>(data.length),
         data.GetValues<uint8_t>(0, 0),
@@ -2733,280 +2699,277 @@ void DeltaBitPackEncoder<Int64Type>::Put(const ::arrow::Array& values) {
 }
 
 template <typename DType>
-void DeltaBitPackEncoder<DType>::PutSpaced(
+void DeltaBitPackEncoder<DType>::putSpaced(
     const T* src,
-    int num_values,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset) {
-  if (valid_bits != NULLPTR) {
-    PARQUET_ASSIGN_OR_THROW(
-        auto buffer,
-        ::arrow::AllocateBuffer(num_values * sizeof(T), this->memory_pool()));
+    int numValues,
+    const uint8_t* validBits,
+    int64_t validBitsOffset) {
+  if (validBits != NULLPTR) {
+    auto buffer = allocateBuffer(this->memoryPool(), numValues * sizeof(T));
     T* data = reinterpret_cast<T*>(buffer->mutable_data());
-    int num_valid_values = ::arrow::util::internal::SpacedCompress<T>(
-        src, num_values, valid_bits, valid_bits_offset, data);
-    Put(data, num_valid_values);
+    int numValidValues = ::arrow::util::internal::SpacedCompress<T>(
+        src, numValues, validBits, validBitsOffset, data);
+    put(data, numValidValues);
   } else {
-    Put(src, num_values);
+    put(src, numValues);
   }
 }
 
-// ----------------------------------------------------------------------
-// DeltaBitPackDecoder
+// ----------------------------------------------------------------------.
+// DeltaBitPackDecoder.
 
 template <typename DType>
 class DeltaBitPackDecoder : public DecoderImpl,
                             virtual public TypedDecoder<DType> {
  public:
-  typedef typename DType::c_type T;
+  typedef typename DType::CType T;
   using UT = std::make_unsigned_t<T>;
 
   explicit DeltaBitPackDecoder(
       const ColumnDescriptor* descr,
       MemoryPool* pool = ::arrow::default_memory_pool())
-      : DecoderImpl(descr, Encoding::DELTA_BINARY_PACKED), pool_(pool) {
-    if (DType::type_num != Type::INT32 && DType::type_num != Type::INT64) {
+      : DecoderImpl(descr, Encoding::kDeltaBinaryPacked), pool_(pool) {
+    if (DType::typeNum != Type::kInt32 && DType::typeNum != Type::kInt64) {
       throw ParquetException(
           "Delta bit pack encoding should only be for integer data.");
     }
   }
 
-  void SetData(int num_values, const uint8_t* data, int len) override {
-    // num_values is equal to page's num_values, including null values in this
-    // page
-    this->num_values_ = num_values;
+  void setData(int numValues, const uint8_t* data, int len) override {
+    // Num_values is equal to page's num_values, including null values in this.
+    // Page.
+    this->numValues_ = numValues;
     decoder_ = std::make_shared<BitReader>(data, len);
-    InitHeader();
+    initHeader();
   }
 
-  // Set BitReader which is already initialized by DeltaLengthByteArrayDecoder
-  // or DeltaByteArrayDecoder
-  void SetDecoder(int num_values, std::shared_ptr<BitReader> decoder) {
-    this->num_values_ = num_values;
+  // Set BitReader which is already initialized by DeltaLengthByteArrayDecoder.
+  // Or DeltaByteArrayDecoder.
+  void setDecoder(int numValues, std::shared_ptr<BitReader> decoder) {
+    this->numValues_ = numValues;
     decoder_ = std::move(decoder);
-    InitHeader();
+    initHeader();
   }
 
-  int ValidValuesCount() {
-    // total_values_remaining_ in header ignores of null values
-    return static_cast<int>(total_values_remaining_);
+  int validValuesCount() {
+    // Total_values_remaining_ in header ignores of null values.
+    return static_cast<int>(totalValuesRemaining_);
   }
 
-  int Decode(T* buffer, int max_values) override {
-    return GetInternal(buffer, max_values);
+  int decode(T* buffer, int maxValues) override {
+    return getInternal(buffer, maxValues);
   }
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<DType>::Accumulator* out) override {
-    if (null_count != 0) {
+    if (nullCount != 0) {
       // TODO(ARROW-34660): implement DecodeArrow with null slots.
       ParquetException::NYI("Delta bit pack DecodeArrow with null slots");
     }
-    std::vector<T> values(num_values);
-    int decoded_count = GetInternal(values.data(), num_values);
-    PARQUET_THROW_NOT_OK(out->AppendValues(values.data(), decoded_count));
-    return decoded_count;
+    std::vector<T> values(numValues);
+    int decodedCount = getInternal(values.data(), numValues);
+    PARQUET_THROW_NOT_OK(out->AppendValues(values.data(), decodedCount));
+    return decodedCount;
   }
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<DType>::DictAccumulator* out) override {
-    if (null_count != 0) {
+    if (nullCount != 0) {
       // TODO(ARROW-34660): implement DecodeArrow with null slots.
       ParquetException::NYI("Delta bit pack DecodeArrow with null slots");
     }
-    std::vector<T> values(num_values);
-    int decoded_count = GetInternal(values.data(), num_values);
-    PARQUET_THROW_NOT_OK(out->Reserve(decoded_count));
-    for (int i = 0; i < decoded_count; ++i) {
+    std::vector<T> values(numValues);
+    int decodedCount = getInternal(values.data(), numValues);
+    PARQUET_THROW_NOT_OK(out->Reserve(decodedCount));
+    for (int i = 0; i < decodedCount; ++i) {
       PARQUET_THROW_NOT_OK(out->Append(values[i]));
     }
-    return decoded_count;
+    return decodedCount;
   }
 
  private:
   static constexpr int kMaxDeltaBitWidth = static_cast<int>(sizeof(T) * 8);
 
-  void InitHeader() {
-    if (!decoder_->GetVlqInt(&values_per_block_) ||
-        !decoder_->GetVlqInt(&mini_blocks_per_block_) ||
-        !decoder_->GetVlqInt(&total_value_count_) ||
-        !decoder_->GetZigZagVlqInt(&last_value_)) {
-      ParquetException::EofException("InitHeader EOF");
+  void initHeader() {
+    if (!decoder_->GetVlqInt(&valuesPerBlock_) ||
+        !decoder_->GetVlqInt(&miniBlocksPerBlock_) ||
+        !decoder_->GetVlqInt(&totalValueCount_) ||
+        !decoder_->GetZigZagVlqInt(&lastValue_)) {
+      ParquetException::eofException("InitHeader EOF");
     }
 
-    if (values_per_block_ == 0) {
+    if (valuesPerBlock_ == 0) {
       throw ParquetException("cannot have zero value per block");
     }
-    if (values_per_block_ % 128 != 0) {
+    if (valuesPerBlock_ % 128 != 0) {
       throw ParquetException(
           "the number of values in a block must be multiple of 128, but it's " +
-          std::to_string(values_per_block_));
+          std::to_string(valuesPerBlock_));
     }
-    if (mini_blocks_per_block_ == 0) {
+    if (miniBlocksPerBlock_ == 0) {
       throw ParquetException("cannot have zero miniblock per block");
     }
-    values_per_mini_block_ = values_per_block_ / mini_blocks_per_block_;
-    if (values_per_mini_block_ == 0) {
+    valuesPerMiniBlock_ = valuesPerBlock_ / miniBlocksPerBlock_;
+    if (valuesPerMiniBlock_ == 0) {
       throw ParquetException("cannot have zero value per miniblock");
     }
-    if (values_per_mini_block_ % 32 != 0) {
+    if (valuesPerMiniBlock_ % 32 != 0) {
       throw ParquetException(
           "the number of values in a miniblock must be multiple of 32, but it's " +
-          std::to_string(values_per_mini_block_));
+          std::to_string(valuesPerMiniBlock_));
     }
 
-    total_values_remaining_ = total_value_count_;
-    if (delta_bit_widths_ == nullptr) {
-      delta_bit_widths_ = AllocateBuffer(pool_, mini_blocks_per_block_);
+    totalValuesRemaining_ = totalValueCount_;
+    if (deltaBitWidths_ == nullptr) {
+      deltaBitWidths_ = allocateBuffer(pool_, miniBlocksPerBlock_);
     } else {
-      PARQUET_THROW_NOT_OK(delta_bit_widths_->Resize(
-          mini_blocks_per_block_, /*shrink_to_fit*/ false));
+      PARQUET_THROW_NOT_OK(deltaBitWidths_->Resize(
+          miniBlocksPerBlock_, /*shrink_to_fit*/ false));
     }
-    first_block_initialized_ = false;
-    values_remaining_current_mini_block_ = 0;
+    firstBlockInitialized_ = false;
+    valuesRemainingCurrentMiniBlock_ = 0;
   }
 
-  void InitBlock() {
-    VELOX_DCHECK_GT(total_values_remaining_, 0, "InitBlock called at EOF");
+  void initBlock() {
+    VELOX_DCHECK_GT(totalValuesRemaining_, 0, "InitBlock called at EOF");
 
-    if (!decoder_->GetZigZagVlqInt(&min_delta_))
-      ParquetException::EofException("InitBlock EOF");
+    if (!decoder_->GetZigZagVlqInt(&minDelta_))
+      ParquetException::eofException("InitBlock EOF");
 
-    // read the bitwidth of each miniblock
-    uint8_t* bit_width_data = delta_bit_widths_->mutable_data();
-    for (uint32_t i = 0; i < mini_blocks_per_block_; ++i) {
-      if (!decoder_->GetAligned<uint8_t>(1, bit_width_data + i)) {
-        ParquetException::EofException("Decode bit-width EOF");
+    // Read the bitwidth of each miniblock.
+    uint8_t* bitWidthData = deltaBitWidths_->mutable_data();
+    for (uint32_t i = 0; i < miniBlocksPerBlock_; ++i) {
+      if (!decoder_->GetAligned(1, bitWidthData + i)) {
+        ParquetException::eofException("Decode bit-width EOF");
       }
-      // Note that non-conformant bitwidth entries are allowed by the Parquet
-      // spec for extraneous miniblocks in the last block (GH-14923), so we
-      // check the bitwidths when actually using them (see InitMiniBlock()).
+      // Note that non-conformant bitwidth entries are allowed by the Parquet.
+      // Spec for extraneous miniblocks in the last block (GH-14923), so we.
+      // Check the bitwidths when actually using them (see InitMiniBlock()).
     }
 
-    mini_block_idx_ = 0;
-    first_block_initialized_ = true;
-    InitMiniBlock(bit_width_data[0]);
+    miniBlockIdx_ = 0;
+    firstBlockInitialized_ = true;
+    initMiniBlock(bitWidthData[0]);
   }
 
-  void InitMiniBlock(int bit_width) {
-    if (ARROW_PREDICT_FALSE(bit_width > kMaxDeltaBitWidth)) {
+  void initMiniBlock(int bitWidth) {
+    if (ARROW_PREDICT_FALSE(bitWidth > kMaxDeltaBitWidth)) {
       throw ParquetException("delta bit width larger than integer bit width");
     }
-    delta_bit_width_ = bit_width;
-    values_remaining_current_mini_block_ = values_per_mini_block_;
+    deltaBitWidth_ = bitWidth;
+    valuesRemainingCurrentMiniBlock_ = valuesPerMiniBlock_;
   }
 
-  int GetInternal(T* buffer, int max_values) {
-    max_values = static_cast<int>(
-        std::min<int64_t>(max_values, total_values_remaining_));
-    if (max_values == 0) {
+  int getInternal(T* buffer, int maxValues) {
+    maxValues =
+        static_cast<int>(std::min<int64_t>(maxValues, totalValuesRemaining_));
+    if (maxValues == 0) {
       return 0;
     }
 
     int i = 0;
 
-    if (ARROW_PREDICT_FALSE(!first_block_initialized_)) {
-      // This is the first time we decode this data page, first output the
-      // last value and initialize the first block.
-      buffer[i++] = last_value_;
-      if (ARROW_PREDICT_FALSE(i == max_values)) {
+    if (ARROW_PREDICT_FALSE(!firstBlockInitialized_)) {
+      // This is the first time we decode this data page, first output the.
+      // Last value and initialize the first block.
+      buffer[i++] = lastValue_;
+      if (ARROW_PREDICT_FALSE(i == maxValues)) {
         // When i reaches max_values here we have two different possibilities:
-        // 1. total_value_count_ == 1, which means that the page may have only
-        //    one value (encoded in the header), and we should not initialize
-        //    any block, nor should we skip any padding bits below.
-        // 2. total_value_count_ != 1, which means we should initialize the
-        //    incoming block for subsequent reads.
-        if (total_value_count_ != 1) {
-          InitBlock();
+        // 1. Total_value_count_ == 1, which means that the page may have only.
+        //    One value (encoded in the header), and we should not initialize.
+        //    Any block, nor should we skip any padding bits below.
+        // 2. Total_value_count_ != 1, which means we should initialize the.
+        //    Incoming block for subsequent reads.
+        if (totalValueCount_ != 1) {
+          initBlock();
         }
-        total_values_remaining_ -= max_values;
-        this->num_values_ -= max_values;
-        return max_values;
+        totalValuesRemaining_ -= maxValues;
+        this->numValues_ -= maxValues;
+        return maxValues;
       }
-      InitBlock();
+      initBlock();
     }
 
-    VELOX_DCHECK(first_block_initialized_);
-    while (i < max_values) {
-      // Ensure we have an initialized mini-block
-      if (ARROW_PREDICT_FALSE(values_remaining_current_mini_block_ == 0)) {
-        ++mini_block_idx_;
-        if (mini_block_idx_ < mini_blocks_per_block_) {
-          InitMiniBlock(delta_bit_widths_->data()[mini_block_idx_]);
+    VELOX_DCHECK(firstBlockInitialized_);
+    while (i < maxValues) {
+      // Ensure we have an initialized mini-block.
+      if (ARROW_PREDICT_FALSE(valuesRemainingCurrentMiniBlock_ == 0)) {
+        ++miniBlockIdx_;
+        if (miniBlockIdx_ < miniBlocksPerBlock_) {
+          initMiniBlock(deltaBitWidths_->data()[miniBlockIdx_]);
         } else {
-          InitBlock();
+          initBlock();
         }
       }
 
-      int values_decode = std::min(
-          values_remaining_current_mini_block_,
-          static_cast<uint32_t>(max_values - i));
-      if (decoder_->GetBatch(delta_bit_width_, buffer + i, values_decode) !=
-          values_decode) {
-        ParquetException::EofException();
+      int valuesDecode = std::min(
+          valuesRemainingCurrentMiniBlock_,
+          static_cast<uint32_t>(maxValues - i));
+      if (decoder_->GetBatch(deltaBitWidth_, buffer + i, valuesDecode) !=
+          valuesDecode) {
+        ParquetException::eofException();
       }
-      for (int j = 0; j < values_decode; ++j) {
-        // Addition between min_delta, packed int and last_value should be
-        // treated as unsigned addition. Overflow is as expected.
-        buffer[i + j] = static_cast<UT>(min_delta_) +
-            static_cast<UT>(buffer[i + j]) + static_cast<UT>(last_value_);
-        last_value_ = buffer[i + j];
+      for (int j = 0; j < valuesDecode; ++j) {
+        // Addition between min_delta, packed int and last_value should be.
+        // Treated as unsigned addition. Overflow is as expected.
+        buffer[i + j] = static_cast<UT>(minDelta_) +
+            static_cast<UT>(buffer[i + j]) + static_cast<UT>(lastValue_);
+        lastValue_ = buffer[i + j];
       }
-      values_remaining_current_mini_block_ -= values_decode;
-      i += values_decode;
+      valuesRemainingCurrentMiniBlock_ -= valuesDecode;
+      i += valuesDecode;
     }
-    total_values_remaining_ -= max_values;
-    this->num_values_ -= max_values;
-
-    if (ARROW_PREDICT_FALSE(total_values_remaining_ == 0)) {
-      uint32_t padding_bits =
-          values_remaining_current_mini_block_ * delta_bit_width_;
-      // skip the padding bits
-      if (!decoder_->Advance(padding_bits)) {
-        ParquetException::EofException();
+    totalValuesRemaining_ -= maxValues;
+    this->numValues_ -= maxValues;
+
+    if (ARROW_PREDICT_FALSE(totalValuesRemaining_ == 0)) {
+      uint32_t paddingBits = valuesRemainingCurrentMiniBlock_ * deltaBitWidth_;
+      // Skip the padding bits.
+      if (!decoder_->Advance(paddingBits)) {
+        ParquetException::eofException();
       }
-      values_remaining_current_mini_block_ = 0;
+      valuesRemainingCurrentMiniBlock_ = 0;
     }
-    return max_values;
+    return maxValues;
   }
 
   MemoryPool* pool_;
   std::shared_ptr<BitReader> decoder_;
-  uint32_t values_per_block_;
-  uint32_t mini_blocks_per_block_;
-  uint32_t values_per_mini_block_;
-  uint32_t total_value_count_;
-
-  uint32_t total_values_remaining_;
-  // Remaining values in current mini block. If the current block is the last
-  // mini block, values_remaining_current_mini_block_ may greater than
-  // total_values_remaining_.
-  uint32_t values_remaining_current_mini_block_;
-
-  // If the page doesn't contain any block, `first_block_initialized_` will
-  // always be false. Otherwise, it will be true when first block initialized.
-  bool first_block_initialized_;
-  T min_delta_;
-  uint32_t mini_block_idx_;
-  std::shared_ptr<ResizableBuffer> delta_bit_widths_;
-  int delta_bit_width_;
-
-  T last_value_;
+  uint32_t valuesPerBlock_;
+  uint32_t miniBlocksPerBlock_;
+  uint32_t valuesPerMiniBlock_;
+  uint32_t totalValueCount_;
+
+  uint32_t totalValuesRemaining_;
+  // Remaining values in current mini block. If the current block is the last.
+  // Mini block, values_remaining_current_mini_block_ may greater than.
+  // Total_values_remaining_.
+  uint32_t valuesRemainingCurrentMiniBlock_;
+
+  // If the page doesn't contain any block, `first_block_initialized_` will.
+  // Always be false. Otherwise, it will be true when first block initialized.
+  bool firstBlockInitialized_;
+  T minDelta_;
+  uint32_t miniBlockIdx_;
+  std::shared_ptr<ResizableBuffer> deltaBitWidths_;
+  int deltaBitWidth_;
+
+  T lastValue_;
 };
 
-// ----------------------------------------------------------------------
-// DELTA_LENGTH_BYTE_ARRAY
+// ----------------------------------------------------------------------.
+// DELTA_LENGTH_BYTE_ARRAY.
 
-// ----------------------------------------------------------------------
-// DeltaLengthByteArrayEncoder
+// ----------------------------------------------------------------------.
+// DeltaLengthByteArrayEncoder.
 
 template <typename DType>
 class DeltaLengthByteArrayEncoder : public EncoderImpl,
@@ -3017,33 +2980,33 @@ class DeltaLengthByteArrayEncoder : public EncoderImpl,
       MemoryPool* pool)
       : EncoderImpl(
             descr,
-            Encoding::DELTA_LENGTH_BYTE_ARRAY,
+            Encoding::kDeltaLengthByteArray,
             pool = ::arrow::default_memory_pool()),
         sink_(pool),
-        length_encoder_(nullptr, pool),
-        encoded_size_{0} {}
+        lengthEncoder_(nullptr, pool),
+        encodedSize_{0} {}
 
-  std::shared_ptr<::arrow::Buffer> FlushValues() override;
+  std::shared_ptr<::arrow::Buffer> flushValues() override;
 
-  int64_t EstimatedDataEncodedSize() override {
-    return encoded_size_ + length_encoder_.EstimatedDataEncodedSize();
+  int64_t estimatedDataEncodedSize() override {
+    return encodedSize_ + lengthEncoder_.estimatedDataEncodedSize();
   }
 
-  using TypedEncoder<ByteArrayType>::Put;
+  using TypedEncoder<ByteArrayType>::put;
 
-  void Put(const ::arrow::Array& values) override;
+  void put(const ::arrow::Array& values) override;
 
-  void Put(const T* buffer, int num_values) override;
+  void put(const T* buffer, int numValues) override;
 
-  void PutSpaced(
+  void putSpaced(
       const T* src,
-      int num_values,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset) override;
+      int numValues,
+      const uint8_t* validBits,
+      int64_t validBitsOffset) override;
 
  protected:
   template <typename ArrayType>
-  void PutBinaryArray(const ArrayType& array) {
+  void putBinaryArray(const ArrayType& array) {
     PARQUET_THROW_NOT_OK(
         ::arrow::VisitArraySpanInline<typename ArrayType::TypeClass>(
             *array.data(),
@@ -3052,7 +3015,7 @@ class DeltaLengthByteArrayEncoder : public EncoderImpl,
                 return Status::Invalid(
                     "Parquet cannot store strings with size 2GB or more");
               }
-              length_encoder_.Put({static_cast<int32_t>(view.length())}, 1);
+              lengthEncoder_.put({static_cast<int32_t>(view.length())}, 1);
               PARQUET_THROW_NOT_OK(sink_.Append(view.data(), view.length()));
               return Status::OK();
             },
@@ -3060,91 +3023,89 @@ class DeltaLengthByteArrayEncoder : public EncoderImpl,
   }
 
   ::arrow::BufferBuilder sink_;
-  DeltaBitPackEncoder<Int32Type> length_encoder_;
-  uint32_t encoded_size_;
+  DeltaBitPackEncoder<Int32Type> lengthEncoder_;
+  uint32_t encodedSize_;
 };
 
 template <typename DType>
-void DeltaLengthByteArrayEncoder<DType>::Put(const ::arrow::Array& values) {
-  AssertBaseBinary(values);
+void DeltaLengthByteArrayEncoder<DType>::put(const ::arrow::Array& values) {
+  assertBaseBinary(values);
   if (::arrow::is_binary_like(values.type_id())) {
-    PutBinaryArray(checked_cast<const ::arrow::BinaryArray&>(values));
+    putBinaryArray(checked_cast<const ::arrow::BinaryArray&>(values));
   } else {
-    PutBinaryArray(checked_cast<const ::arrow::LargeBinaryArray&>(values));
+    putBinaryArray(checked_cast<const ::arrow::LargeBinaryArray&>(values));
   }
 }
 
 template <typename DType>
-void DeltaLengthByteArrayEncoder<DType>::Put(const T* src, int num_values) {
-  if (num_values == 0) {
+void DeltaLengthByteArrayEncoder<DType>::put(const T* src, int numValues) {
+  if (numValues == 0) {
     return;
   }
 
   constexpr int kBatchSize = 256;
   std::array<int32_t, kBatchSize> lengths;
-  uint32_t total_increment_size = 0;
-  for (int idx = 0; idx < num_values; idx += kBatchSize) {
-    const int batch_size = std::min(kBatchSize, num_values - idx);
-    for (int j = 0; j < batch_size; ++j) {
+  uint32_t totalIncrementSize = 0;
+  for (int idx = 0; idx < numValues; idx += kBatchSize) {
+    const int batchSize = std::min(kBatchSize, numValues - idx);
+    for (int j = 0; j < batchSize; ++j) {
       const int32_t len = src[idx + j].len;
-      if (AddWithOverflow(total_increment_size, len, &total_increment_size)) {
+      if (addWithOverflow(totalIncrementSize, len, &totalIncrementSize)) {
         throw ParquetException("excess expansion in DELTA_LENGTH_BYTE_ARRAY");
       }
       lengths[j] = len;
     }
-    length_encoder_.Put(lengths.data(), batch_size);
+    lengthEncoder_.put(lengths.data(), batchSize);
   }
 
-  if (AddWithOverflow(encoded_size_, total_increment_size, &encoded_size_)) {
+  if (addWithOverflow(encodedSize_, totalIncrementSize, &encodedSize_)) {
     throw ParquetException("excess expansion in DELTA_LENGTH_BYTE_ARRAY");
   }
-  PARQUET_THROW_NOT_OK(sink_.Reserve(total_increment_size));
-  for (int idx = 0; idx < num_values; idx++) {
+  PARQUET_THROW_NOT_OK(sink_.Reserve(totalIncrementSize));
+  for (int idx = 0; idx < numValues; idx++) {
     sink_.UnsafeAppend(src[idx].ptr, src[idx].len);
   }
 }
 
 template <typename DType>
-void DeltaLengthByteArrayEncoder<DType>::PutSpaced(
+void DeltaLengthByteArrayEncoder<DType>::putSpaced(
     const T* src,
-    int num_values,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset) {
-  if (valid_bits != NULLPTR) {
-    PARQUET_ASSIGN_OR_THROW(
-        auto buffer,
-        ::arrow::AllocateBuffer(num_values * sizeof(T), this->memory_pool()));
+    int numValues,
+    const uint8_t* validBits,
+    int64_t validBitsOffset) {
+  if (validBits != NULLPTR) {
+    auto buffer = allocateBuffer(this->memoryPool(), numValues * sizeof(T));
     T* data = reinterpret_cast<T*>(buffer->mutable_data());
-    int num_valid_values = ::arrow::util::internal::SpacedCompress<T>(
-        src, num_values, valid_bits, valid_bits_offset, data);
-    Put(data, num_valid_values);
+    int numValidValues = ::arrow::util::internal::SpacedCompress<T>(
+        src, numValues, validBits, validBitsOffset, data);
+    put(data, numValidValues);
   } else {
-    Put(src, num_values);
+    put(src, numValues);
   }
 }
 
 template <typename DType>
 std::shared_ptr<::arrow::Buffer>
-DeltaLengthByteArrayEncoder<DType>::FlushValues() {
-  std::shared_ptr<Buffer> encoded_lengths = length_encoder_.FlushValues();
+DeltaLengthByteArrayEncoder<DType>::flushValues() {
+  std::shared_ptr<Buffer> encodedLengths = lengthEncoder_.flushValues();
 
   std::shared_ptr<Buffer> data;
   PARQUET_THROW_NOT_OK(sink_.Finish(&data));
   sink_.Reset();
 
-  PARQUET_THROW_NOT_OK(sink_.Resize(encoded_lengths->size() + data->size()));
+  PARQUET_THROW_NOT_OK(sink_.Resize(encodedLengths->size() + data->size()));
   PARQUET_THROW_NOT_OK(
-      sink_.Append(encoded_lengths->data(), encoded_lengths->size()));
+      sink_.Append(encodedLengths->data(), encodedLengths->size()));
   PARQUET_THROW_NOT_OK(sink_.Append(data->data(), data->size()));
 
   std::shared_ptr<Buffer> buffer;
   PARQUET_THROW_NOT_OK(sink_.Finish(&buffer, true));
-  encoded_size_ = 0;
+  encodedSize_ = 0;
   return buffer;
 }
 
-// ----------------------------------------------------------------------
-// DeltaLengthByteArrayDecoder
+// ----------------------------------------------------------------------.
+// DeltaLengthByteArrayDecoder.
 
 class DeltaLengthByteArrayDecoder : public DecoderImpl,
                                     virtual public TypedDecoder<ByteArrayType> {
@@ -3152,154 +3113,151 @@ class DeltaLengthByteArrayDecoder : public DecoderImpl,
   explicit DeltaLengthByteArrayDecoder(
       const ColumnDescriptor* descr,
       MemoryPool* pool = ::arrow::default_memory_pool())
-      : DecoderImpl(descr, Encoding::DELTA_LENGTH_BYTE_ARRAY),
-        len_decoder_(nullptr, pool),
-        buffered_length_(AllocateBuffer(pool, 0)) {}
+      : DecoderImpl(descr, Encoding::kDeltaLengthByteArray),
+        lenDecoder_(nullptr, pool),
+        bufferedLength_(allocateBuffer(pool, 0)) {}
 
-  void SetData(int num_values, const uint8_t* data, int len) override {
-    DecoderImpl::SetData(num_values, data, len);
+  void setData(int numValues, const uint8_t* data, int len) override {
+    DecoderImpl::setData(numValues, data, len);
     decoder_ = std::make_shared<BitReader>(data, len);
-    DecodeLengths();
+    decodeLengths();
   }
 
-  int Decode(ByteArray* buffer, int max_values) override {
-    // Decode up to `max_values` strings into an internal buffer
-    // and reference them into `buffer`.
-    max_values = std::min(max_values, num_valid_values_);
-    VELOX_DCHECK_GE(max_values, 0);
-    if (max_values == 0) {
+  int decode(ByteArray* buffer, int maxValues) override {
+    // Decode up to `max_values` strings into an internal buffer.
+    // And reference them into `buffer`.
+    maxValues = std::min(maxValues, numValidValues_);
+    VELOX_DCHECK_GE(maxValues, 0);
+    if (maxValues == 0) {
       return 0;
     }
 
-    int32_t data_size = 0;
-    const int32_t* length_ptr =
-        reinterpret_cast<const int32_t*>(buffered_length_->data()) +
-        length_idx_;
-    int bytes_offset = len_ - decoder_->bytesLeft();
-    for (int i = 0; i < max_values; ++i) {
-      int32_t len = length_ptr[i];
+    int32_t dataSize = 0;
+    const int32_t* lengthPtr =
+        reinterpret_cast<const int32_t*>(bufferedLength_->data()) + lengthIdx_;
+    int bytesOffset = len_ - decoder_->bytesLeft();
+    for (int i = 0; i < maxValues; ++i) {
+      int32_t len = lengthPtr[i];
       if (ARROW_PREDICT_FALSE(len < 0)) {
         throw ParquetException("negative string delta length");
       }
       buffer[i].len = len;
-      if (AddWithOverflow(data_size, len, &data_size)) {
+      if (addWithOverflow(dataSize, len, &dataSize)) {
         throw ParquetException("excess expansion in DELTA_(LENGTH_)BYTE_ARRAY");
       }
     }
-    length_idx_ += max_values;
+    lengthIdx_ += maxValues;
     if (ARROW_PREDICT_FALSE(
-            !decoder_->Advance(8 * static_cast<int64_t>(data_size)))) {
-      ParquetException::EofException();
+            !decoder_->Advance(8 * static_cast<int64_t>(dataSize)))) {
+      ParquetException::eofException();
     }
-    const uint8_t* data_ptr = data_ + bytes_offset;
-    for (int i = 0; i < max_values; ++i) {
-      buffer[i].ptr = data_ptr;
-      data_ptr += buffer[i].len;
+    const uint8_t* dataPtr = data_ + bytesOffset;
+    for (int i = 0; i < maxValues; ++i) {
+      buffer[i].ptr = dataPtr;
+      dataPtr += buffer[i].len;
     }
-    this->num_values_ -= max_values;
-    num_valid_values_ -= max_values;
-    return max_values;
+    this->numValues_ -= maxValues;
+    numValidValues_ -= maxValues;
+    return maxValues;
   }
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<ByteArrayType>::Accumulator* out) override {
     int result = 0;
-    PARQUET_THROW_NOT_OK(DecodeArrowDense(
-        num_values, null_count, valid_bits, valid_bits_offset, out, &result));
+    PARQUET_THROW_NOT_OK(decodeArrowDense(
+        numValues, nullCount, validBits, validBitsOffset, out, &result));
     return result;
   }
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<ByteArrayType>::DictAccumulator* out) override {
     ParquetException::NYI(
         "DecodeArrow of DictAccumulator for DeltaLengthByteArrayDecoder");
   }
 
  private:
-  // Decode all the encoded lengths. The decoder_ will be at the start of the
-  // encoded data after that.
-  void DecodeLengths() {
-    len_decoder_.SetDecoder(num_values_, decoder_);
-
-    // get the number of encoded lengths
-    int num_length = len_decoder_.ValidValuesCount();
-    PARQUET_THROW_NOT_OK(
-        buffered_length_->Resize(num_length * sizeof(int32_t)));
-
-    // call len_decoder_.Decode to decode all the lengths.
-    // all the lengths are buffered in buffered_length_.
-    VELOX_DEBUG_ONLY int ret = len_decoder_.Decode(
-        reinterpret_cast<int32_t*>(buffered_length_->mutable_data()),
-        num_length);
-    VELOX_DCHECK_EQ(ret, num_length);
-    length_idx_ = 0;
-    num_valid_values_ = num_length;
-  }
-
-  Status DecodeArrowDense(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  // Decode all the encoded lengths. The decoder_ will be at the start of the.
+  // Encoded data after that.
+  void decodeLengths() {
+    lenDecoder_.setDecoder(numValues_, decoder_);
+
+    // Get the number of encoded lengths.
+    int numLength = lenDecoder_.validValuesCount();
+    PARQUET_THROW_NOT_OK(bufferedLength_->Resize(numLength * sizeof(int32_t)));
+
+    // Call len_decoder_.Decode to decode all the lengths.
+    // All the lengths are buffered in buffered_length_.
+    VELOX_DEBUG_ONLY int ret = lenDecoder_.decode(
+        reinterpret_cast<int32_t*>(bufferedLength_->mutable_data()), numLength);
+    VELOX_DCHECK_EQ(ret, numLength);
+    lengthIdx_ = 0;
+    numValidValues_ = numLength;
+  }
+
+  Status decodeArrowDense(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<ByteArrayType>::Accumulator* out,
-      int* out_num_values) {
-    ArrowBinaryHelper<ByteArrayType> helper(out, num_values);
-    RETURN_NOT_OK(helper.Prepare());
+      int* outNumValues) {
+    ArrowBinaryHelper<ByteArrayType> helper(out, numValues);
+    RETURN_NOT_OK(helper.prepare());
 
-    std::vector<ByteArray> values(num_values - null_count);
-    const int num_valid_values = Decode(values.data(), num_values - null_count);
-    if (ARROW_PREDICT_FALSE(num_values - null_count != num_valid_values)) {
+    std::vector<ByteArray> values(numValues - nullCount);
+    const int numValidValues = decode(values.data(), numValues - nullCount);
+    if (ARROW_PREDICT_FALSE(numValues - nullCount != numValidValues)) {
       throw ParquetException(
           "Expected to decode ",
-          num_values - null_count,
+          numValues - nullCount,
           " values, but decoded ",
-          num_valid_values,
+          numValidValues,
           " values.");
     }
 
-    auto values_ptr = values.data();
-    int value_idx = 0;
+    auto valuesPtr = values.data();
+    int valueIdx = 0;
 
     RETURN_NOT_OK(VisitNullBitmapInline(
-        valid_bits,
-        valid_bits_offset,
-        num_values,
-        null_count,
+        validBits,
+        validBitsOffset,
+        numValues,
+        nullCount,
         [&]() {
-          const auto& val = values_ptr[value_idx];
-          RETURN_NOT_OK(helper.PrepareNextInput(val.len));
+          const auto& val = valuesPtr[valueIdx];
+          RETURN_NOT_OK(helper.prepareNextInput(val.len));
           RETURN_NOT_OK(helper.Append(val.ptr, static_cast<int32_t>(val.len)));
-          ++value_idx;
+          ++valueIdx;
           return Status::OK();
         },
         [&]() {
           RETURN_NOT_OK(helper.AppendNull());
-          --null_count;
+          --nullCount;
           return Status::OK();
         }));
 
-    VELOX_DCHECK_EQ(null_count, 0);
-    *out_num_values = num_valid_values;
+    VELOX_DCHECK_EQ(nullCount, 0);
+    *outNumValues = numValidValues;
     return Status::OK();
   }
 
   std::shared_ptr<BitReader> decoder_;
-  DeltaBitPackDecoder<Int32Type> len_decoder_;
-  int num_valid_values_{0};
-  uint32_t length_idx_{0};
-  std::shared_ptr<ResizableBuffer> buffered_length_;
+  DeltaBitPackDecoder<Int32Type> lenDecoder_;
+  int numValidValues_{0};
+  uint32_t lengthIdx_{0};
+  std::shared_ptr<ResizableBuffer> bufferedLength_;
 };
 
-// ----------------------------------------------------------------------
-// RLE_BOOLEAN_ENCODER
+// ----------------------------------------------------------------------.
+// RLE_BOOLEAN_ENCODER.
 
 class RleBooleanEncoder final : public EncoderImpl,
                                 virtual public BooleanEncoder {
@@ -3307,116 +3265,115 @@ class RleBooleanEncoder final : public EncoderImpl,
   explicit RleBooleanEncoder(
       const ColumnDescriptor* descr,
       ::arrow::MemoryPool* pool)
-      : EncoderImpl(descr, Encoding::RLE, pool),
-        buffered_append_values_(::arrow::stl::allocator<T>(pool)) {}
+      : EncoderImpl(descr, Encoding::kRle, pool),
+        bufferedAppendValues_(::arrow::stl::allocator<T>(pool)) {}
 
-  int64_t EstimatedDataEncodedSize() override {
-    return kRleLengthInBytes + MaxRleBufferSize();
+  int64_t estimatedDataEncodedSize() override {
+    return kRleLengthInBytes + maxRleBufferSize();
   }
 
-  std::shared_ptr<Buffer> FlushValues() override;
+  std::shared_ptr<Buffer> flushValues() override;
 
-  void Put(const T* buffer, int num_values) override;
-  void Put(const ::arrow::Array& values) override {
+  void put(const T* buffer, int numValues) override;
+  void put(const ::arrow::Array& values) override {
     if (values.type_id() != ::arrow::Type::BOOL) {
       throw ParquetException(
           "RleBooleanEncoder expects BooleanArray, got ",
           values.type()->ToString());
     }
-    const auto& boolean_array =
+    const auto& booleanArray =
         checked_cast<const ::arrow::BooleanArray&>(values);
     if (values.null_count() == 0) {
-      for (int i = 0; i < boolean_array.length(); ++i) {
-        // null_count == 0, so just call Value directly is ok.
-        buffered_append_values_.push_back(boolean_array.Value(i));
+      for (int i = 0; i < booleanArray.length(); ++i) {
+        // Null_count == 0, so just call Value directly is ok.
+        bufferedAppendValues_.push_back(booleanArray.Value(i));
       }
     } else {
-      PARQUET_THROW_NOT_OK(::arrow::VisitArraySpanInline<::arrow::BooleanType>(
-          *boolean_array.data(),
-          [&](bool value) {
-            buffered_append_values_.push_back(value);
-            return Status::OK();
-          },
-          []() { return Status::OK(); }));
+      PARQUET_THROW_NOT_OK(
+          ::arrow::VisitArraySpanInline<::arrow::BooleanType>(
+              *booleanArray.data(),
+              [&](bool value) {
+                bufferedAppendValues_.push_back(value);
+                return Status::OK();
+              },
+              []() { return Status::OK(); }));
     }
   }
 
-  void PutSpaced(
+  void putSpaced(
       const T* src,
-      int num_values,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset) override {
-    if (valid_bits != NULLPTR) {
-      PARQUET_ASSIGN_OR_THROW(
-          auto buffer,
-          ::arrow::AllocateBuffer(num_values * sizeof(T), this->memory_pool()));
+      int numValues,
+      const uint8_t* validBits,
+      int64_t validBitsOffset) override {
+    if (validBits != NULLPTR) {
+      auto buffer = allocateBuffer(this->memoryPool(), numValues * sizeof(T));
       T* data = reinterpret_cast<T*>(buffer->mutable_data());
-      int num_valid_values = ::arrow::util::internal::SpacedCompress<T>(
-          src, num_values, valid_bits, valid_bits_offset, data);
-      Put(data, num_valid_values);
+      int numValidValues = ::arrow::util::internal::SpacedCompress<T>(
+          src, numValues, validBits, validBitsOffset, data);
+      put(data, numValidValues);
     } else {
-      Put(src, num_values);
+      put(src, numValues);
     }
   }
 
-  void Put(const std::vector<bool>& src, int num_values) override;
+  void put(const std::vector<bool>& src, int numValues) override;
 
  protected:
   template <typename SequenceType>
-  void PutImpl(const SequenceType& src, int num_values);
+  void putImpl(const SequenceType& src, int numValues);
 
-  int MaxRleBufferSize() const noexcept {
-    return RlePreserveBufferSize(
-        static_cast<int>(buffered_append_values_.size()), kBitWidth);
+  int maxRleBufferSize() const noexcept {
+    return rlePreserveBufferSize(
+        static_cast<int>(bufferedAppendValues_.size()), kBitWidth);
   }
 
   constexpr static int32_t kBitWidth = 1;
-  /// 4 bytes in little-endian, which indicates the length.
+  /// 4 Bytes in little-endian, which indicates the length.
   constexpr static int32_t kRleLengthInBytes = 4;
 
-  // std::vector<bool> in C++ is tricky, because it's a bitmap.
-  // Here RleBooleanEncoder will only append values into it, and
-  // dump values into Buffer, so using it here is ok.
-  ArrowPoolVector<bool> buffered_append_values_;
+  // Std::vector<bool> in C++ is tricky, because it's a bitmap.
+  // Here RleBooleanEncoder will only Append values into it, and.
+  // Dump values into Buffer, so using it here is ok.
+  ArrowPoolVector<bool> bufferedAppendValues_;
 };
 
-void RleBooleanEncoder::Put(const bool* src, int num_values) {
-  PutImpl(src, num_values);
+void RleBooleanEncoder::put(const bool* src, int numValues) {
+  putImpl(src, numValues);
 }
 
-void RleBooleanEncoder::Put(const std::vector<bool>& src, int num_values) {
-  PutImpl(src, num_values);
+void RleBooleanEncoder::put(const std::vector<bool>& src, int numValues) {
+  putImpl(src, numValues);
 }
 
 template <typename SequenceType>
-void RleBooleanEncoder::PutImpl(const SequenceType& src, int num_values) {
-  for (int i = 0; i < num_values; ++i) {
-    buffered_append_values_.push_back(src[i]);
+void RleBooleanEncoder::putImpl(const SequenceType& src, int numValues) {
+  for (int i = 0; i < numValues; ++i) {
+    bufferedAppendValues_.push_back(src[i]);
   }
 }
 
-std::shared_ptr<Buffer> RleBooleanEncoder::FlushValues() {
-  int rle_buffer_size_max = MaxRleBufferSize();
+std::shared_ptr<Buffer> RleBooleanEncoder::flushValues() {
+  int rleBufferSizeMax = maxRleBufferSize();
   std::shared_ptr<ResizableBuffer> buffer =
-      AllocateBuffer(this->pool_, rle_buffer_size_max + kRleLengthInBytes);
+      allocateBuffer(this->pool_, rleBufferSizeMax + kRleLengthInBytes);
   RleEncoder encoder(
       buffer->mutable_data() + kRleLengthInBytes,
-      rle_buffer_size_max,
+      rleBufferSizeMax,
       /*bit_width*/ kBitWidth);
 
-  for (bool value : buffered_append_values_) {
+  for (bool value : bufferedAppendValues_) {
     encoder.Put(value ? 1 : 0);
   }
   encoder.Flush();
   ::arrow::util::SafeStore(
       buffer->mutable_data(), ::arrow::bit_util::ToLittleEndian(encoder.len()));
   PARQUET_THROW_NOT_OK(buffer->Resize(kRleLengthInBytes + encoder.len()));
-  buffered_append_values_.clear();
+  bufferedAppendValues_.clear();
   return buffer;
 }
 
-// ----------------------------------------------------------------------
-// RLE_BOOLEAN_DECODER
+// ----------------------------------------------------------------------.
+// RLE_BOOLEAN_DECODER.
 
 // TODO - Commented out as arrow/util/endian.h needs to be updated first.
 /*
@@ -3433,7 +3390,7 @@ class RleBooleanDecoder : public DecoderImpl, virtual public BooleanDecoder {
       throw ParquetException("Received invalid length : " + std::to_string(len)
 + " (corrupt data page?)");
     }
-    // Load the first 4 bytes in little-endian, which indicates the length
+    // Load the first 4 bytes in little-endian, which indicates the length.
     num_bytes = ::arrow::bit_util::FromLittleEndian(SafeLoadAs<uint32_t>(data));
     if (num_bytes < 0 || num_bytes > static_cast<uint32_t>(len - 4)) {
       throw ParquetException("Received invalid number of bytes : " +
@@ -3501,19 +3458,19 @@ override { if (null_count != 0) {
 };
 */
 
-// ----------------------------------------------------------------------
-// DELTA_BYTE_ARRAY
+// ----------------------------------------------------------------------.
+// DELTA_BYTE_ARRAY.
 
-/// Delta Byte Array encoding also known as incremental encoding or front
-/// compression: for each element in a sequence of strings, store the prefix
-/// length of the previous entry plus the suffix.
+/// Delta Byte Array encoding also known as incremental encoding or front.
+/// Compression: for each element in a sequence of strings, store the prefix.
+/// Length of the previous entry plus the suffix.
 ///
-/// This is stored as a sequence of delta-encoded prefix lengths
-/// (DELTA_BINARY_PACKED), followed by the suffixes encoded as delta length byte
-/// arrays (DELTA_LENGTH_BYTE_ARRAY).
+/// This is stored as a sequence of delta-encoded prefix lengths.
+/// (DELTA_BINARY_PACKED), followed by the suffixes encoded as delta length
+/// byte. Arrays (DELTA_LENGTH_BYTE_ARRAY).
 
-// ----------------------------------------------------------------------
-// DeltaByteArrayEncoder
+// ----------------------------------------------------------------------.
+// DeltaByteArrayEncoder.
 
 template <typename DType>
 class DeltaByteArrayEncoder : public EncoderImpl,
@@ -3521,106 +3478,105 @@ class DeltaByteArrayEncoder : public EncoderImpl,
   static constexpr std::string_view kEmpty = "";
 
  public:
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
 
   explicit DeltaByteArrayEncoder(
       const ColumnDescriptor* descr,
       MemoryPool* pool = ::arrow::default_memory_pool())
-      : EncoderImpl(descr, Encoding::DELTA_BYTE_ARRAY, pool),
+      : EncoderImpl(descr, Encoding::kDeltaByteArray, pool),
         sink_(pool),
-        prefix_length_encoder_(/*descr=*/nullptr, pool),
-        suffix_encoder_(descr, pool),
-        last_value_(""),
+        prefixLengthEncoder_(nullptr, pool),
+        suffixEncoder_(descr, pool),
+        lastValue_(""),
         empty_(
             static_cast<uint32_t>(kEmpty.size()),
             reinterpret_cast<const uint8_t*>(kEmpty.data())) {}
 
-  std::shared_ptr<Buffer> FlushValues() override;
+  std::shared_ptr<Buffer> flushValues() override;
 
-  int64_t EstimatedDataEncodedSize() override {
-    return prefix_length_encoder_.EstimatedDataEncodedSize() +
-        suffix_encoder_.EstimatedDataEncodedSize();
+  int64_t estimatedDataEncodedSize() override {
+    return prefixLengthEncoder_.estimatedDataEncodedSize() +
+        suffixEncoder_.estimatedDataEncodedSize();
   }
 
-  using TypedEncoder<DType>::Put;
+  using TypedEncoder<DType>::put;
 
-  void Put(const ::arrow::Array& values) override;
+  void put(const ::arrow::Array& values) override;
 
-  void Put(const T* buffer, int num_values) override;
+  void put(const T* buffer, int numValues) override;
 
-  void PutSpaced(
+  void putSpaced(
       const T* src,
-      int num_values,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset) override {
-    if (valid_bits != nullptr) {
+      int numValues,
+      const uint8_t* validBits,
+      int64_t validBitsOffset) override {
+    if (validBits != nullptr) {
       if (buffer_ == nullptr) {
         PARQUET_ASSIGN_OR_THROW(
             buffer_,
             ::arrow::AllocateResizableBuffer(
-                num_values * sizeof(T), this->memory_pool()));
+                numValues * sizeof(T), this->memoryPool()));
       } else {
-        PARQUET_THROW_NOT_OK(buffer_->Resize(num_values * sizeof(T), false));
+        PARQUET_THROW_NOT_OK(buffer_->Resize(numValues * sizeof(T), false));
       }
       T* data = reinterpret_cast<T*>(buffer_->mutable_data());
-      int num_valid_values = ::arrow::util::internal::SpacedCompress<T>(
-          src, num_values, valid_bits, valid_bits_offset, data);
-      Put(data, num_valid_values);
+      int numValidValues = ::arrow::util::internal::SpacedCompress<T>(
+          src, numValues, validBits, validBitsOffset, data);
+      put(data, numValidValues);
     } else {
-      Put(src, num_values);
+      put(src, numValues);
     }
   }
 
  protected:
   template <typename VisitorType>
-  void PutInternal(const T* src, int num_values, const VisitorType visitor) {
-    if (num_values == 0) {
+  void putInternal(const T* src, int numValues, const VisitorType visitor) {
+    if (numValues == 0) {
       return;
     }
 
-    std::string_view last_value_view = last_value_;
+    std::string_view lastValueView = lastValue_;
     constexpr int kBatchSize = 256;
-    std::array<int32_t, kBatchSize> prefix_lengths;
+    std::array<int32_t, kBatchSize> prefixLengths;
     std::array<ByteArray, kBatchSize> suffixes;
 
-    for (int i = 0; i < num_values; i += kBatchSize) {
-      const int batch_size = std::min(kBatchSize, num_values - i);
+    for (int i = 0; i < numValues; i += kBatchSize) {
+      const int batchSize = std::min(kBatchSize, numValues - i);
 
-      for (int j = 0; j < batch_size; ++j) {
+      for (int j = 0; j < batchSize; ++j) {
         const int idx = i + j;
         const auto view = visitor[idx];
         const auto len = static_cast<const uint32_t>(view.length());
 
-        uint32_t common_prefix_length = 0;
-        const uint32_t maximum_common_prefix_length =
-            std::min(len, static_cast<uint32_t>(last_value_view.length()));
-        while (common_prefix_length < maximum_common_prefix_length) {
-          if (last_value_view[common_prefix_length] !=
-              view[common_prefix_length]) {
+        uint32_t commonPrefixLength = 0;
+        const uint32_t maximumCommonPrefixLength =
+            std::min(len, static_cast<uint32_t>(lastValueView.length()));
+        while (commonPrefixLength < maximumCommonPrefixLength) {
+          if (lastValueView[commonPrefixLength] != view[commonPrefixLength]) {
             break;
           }
-          common_prefix_length++;
+          commonPrefixLength++;
         }
 
-        last_value_view = view;
-        prefix_lengths[j] = common_prefix_length;
-        const uint32_t suffix_length = len - common_prefix_length;
-        const uint8_t* suffix_ptr = src[idx].ptr + common_prefix_length;
+        lastValueView = view;
+        prefixLengths[j] = commonPrefixLength;
+        const uint32_t suffixLength = len - commonPrefixLength;
+        const uint8_t* suffixPtr = src[idx].ptr + commonPrefixLength;
 
         // Convert to ByteArray, so it can be passed to the suffix_encoder_.
-        const ByteArray suffix(suffix_length, suffix_ptr);
+        const ByteArray suffix(suffixLength, suffixPtr);
         suffixes[j] = suffix;
       }
-      suffix_encoder_.Put(suffixes.data(), batch_size);
-      prefix_length_encoder_.Put(prefix_lengths.data(), batch_size);
+      suffixEncoder_.put(suffixes.data(), batchSize);
+      prefixLengthEncoder_.put(prefixLengths.data(), batchSize);
     }
-    last_value_ = last_value_view;
+    lastValue_ = lastValueView;
   }
 
   template <typename ArrayType>
-  void PutBinaryArray(const ArrayType& array) {
-    auto previous_len = static_cast<uint32_t>(last_value_.length());
-    std::string_view last_value_view = last_value_;
+  void putBinaryArray(const ArrayType& array) {
+    auto previousLen = static_cast<uint32_t>(lastValue_.length());
+    std::string_view lastValueView = lastValue_;
 
     PARQUET_THROW_NOT_OK(
         ::arrow::VisitArraySpanInline<typename ArrayType::TypeClass>(
@@ -3632,44 +3588,44 @@ class DeltaByteArrayEncoder : public EncoderImpl,
               }
               const ByteArray src{std::string_view(view.data(), view.size())};
 
-              uint32_t common_prefix_length = 0;
+              uint32_t commonPrefixLength = 0;
               const uint32_t len = src.len;
-              const uint32_t maximum_common_prefix_length =
-                  std::min(previous_len, len);
-              while (common_prefix_length < maximum_common_prefix_length) {
-                if (last_value_view[common_prefix_length] !=
-                    view[common_prefix_length]) {
+              const uint32_t maximumCommonPrefixLength =
+                  std::min(previousLen, len);
+              while (commonPrefixLength < maximumCommonPrefixLength) {
+                if (lastValueView[commonPrefixLength] !=
+                    view[commonPrefixLength]) {
                   break;
                 }
-                common_prefix_length++;
+                commonPrefixLength++;
               }
-              previous_len = len;
-              prefix_length_encoder_.Put(
-                  {static_cast<int32_t>(common_prefix_length)}, 1);
-
-              last_value_view = std::string_view(view.data(), view.size());
-              const auto suffix_length =
-                  static_cast<uint32_t>(len - common_prefix_length);
-              if (suffix_length == 0) {
-                suffix_encoder_.Put(&empty_, 1);
+              previousLen = len;
+              prefixLengthEncoder_.put(
+                  {static_cast<int32_t>(commonPrefixLength)}, 1);
+
+              lastValueView = std::string_view(view.data(), view.size());
+              const auto suffixLength =
+                  static_cast<uint32_t>(len - commonPrefixLength);
+              if (suffixLength == 0) {
+                suffixEncoder_.put(&empty_, 1);
                 return Status::OK();
               }
-              const uint8_t* suffix_ptr = src.ptr + common_prefix_length;
-              // Convert to ByteArray, so it can be passed to the
-              // suffix_encoder_.
-              const ByteArray suffix(suffix_length, suffix_ptr);
-              suffix_encoder_.Put(&suffix, 1);
+              const uint8_t* suffixPtr = src.ptr + commonPrefixLength;
+              // Convert to ByteArray, so it can be passed to the.
+              // Suffix_encoder_.
+              const ByteArray suffix(suffixLength, suffixPtr);
+              suffixEncoder_.put(&suffix, 1);
 
               return Status::OK();
             },
             []() { return Status::OK(); }));
-    last_value_ = last_value_view;
+    lastValue_ = lastValueView;
   }
 
   ::arrow::BufferBuilder sink_;
-  DeltaBitPackEncoder<Int32Type> prefix_length_encoder_;
-  DeltaLengthByteArrayEncoder<ByteArrayType> suffix_encoder_;
-  std::string last_value_;
+  DeltaBitPackEncoder<Int32Type> prefixLengthEncoder_;
+  DeltaLengthByteArrayEncoder<ByteArrayType> suffixEncoder_;
+  std::string lastValue_;
   const ByteArray empty_;
   std::unique_ptr<ResizableBuffer> buffer_;
 };
@@ -3692,232 +3648,232 @@ struct ByteArrayVisitor {
 
 struct FLBAVisitor {
   const FLBA* src;
-  const uint32_t type_length;
+  const uint32_t typeLength;
 
   std::string_view operator[](int i) const {
     return std::string_view{
-        reinterpret_cast<const char*>(src[i].ptr), type_length};
+        reinterpret_cast<const char*>(src[i].ptr), typeLength};
   }
 
   uint32_t len(int i) const {
-    return type_length;
+    return typeLength;
   }
 };
 
 template <>
-void DeltaByteArrayEncoder<ByteArrayType>::Put(
+void DeltaByteArrayEncoder<ByteArrayType>::put(
     const ByteArray* src,
-    int num_values) {
+    int numValues) {
   auto visitor = ByteArrayVisitor{src};
-  PutInternal<ByteArrayVisitor>(src, num_values, visitor);
+  putInternal<ByteArrayVisitor>(src, numValues, visitor);
 }
 
 template <>
-void DeltaByteArrayEncoder<FLBAType>::Put(const FLBA* src, int num_values) {
-  auto visitor = FLBAVisitor{src, static_cast<uint32_t>(descr_->type_length())};
-  PutInternal<FLBAVisitor>(src, num_values, visitor);
+void DeltaByteArrayEncoder<FLBAType>::put(const FLBA* src, int numValues) {
+  auto visitor = FLBAVisitor{src, static_cast<uint32_t>(descr_->typeLength())};
+  putInternal<FLBAVisitor>(src, numValues, visitor);
 }
 
 template <typename DType>
-void DeltaByteArrayEncoder<DType>::Put(const ::arrow::Array& values) {
+void DeltaByteArrayEncoder<DType>::put(const ::arrow::Array& values) {
   if (::arrow::is_binary_like(values.type_id())) {
-    PutBinaryArray(checked_cast<const ::arrow::BinaryArray&>(values));
+    putBinaryArray(checked_cast<const ::arrow::BinaryArray&>(values));
   } else if (::arrow::is_large_binary_like(values.type_id())) {
-    PutBinaryArray(checked_cast<const ::arrow::LargeBinaryArray&>(values));
+    putBinaryArray(checked_cast<const ::arrow::LargeBinaryArray&>(values));
   } else if (::arrow::is_fixed_size_binary(values.type_id())) {
-    PutBinaryArray(checked_cast<const ::arrow::FixedSizeBinaryArray&>(values));
+    putBinaryArray(checked_cast<const ::arrow::FixedSizeBinaryArray&>(values));
   } else {
     throw ParquetException("Only BaseBinaryArray and subclasses supported");
   }
 }
 
 template <typename DType>
-std::shared_ptr<Buffer> DeltaByteArrayEncoder<DType>::FlushValues() {
-  PARQUET_THROW_NOT_OK(sink_.Resize(EstimatedDataEncodedSize(), false));
+std::shared_ptr<Buffer> DeltaByteArrayEncoder<DType>::flushValues() {
+  PARQUET_THROW_NOT_OK(sink_.Resize(estimatedDataEncodedSize(), false));
 
-  std::shared_ptr<Buffer> prefix_lengths = prefix_length_encoder_.FlushValues();
+  std::shared_ptr<Buffer> prefixLengths = prefixLengthEncoder_.flushValues();
   PARQUET_THROW_NOT_OK(
-      sink_.Append(prefix_lengths->data(), prefix_lengths->size()));
+      sink_.Append(prefixLengths->data(), prefixLengths->size()));
 
-  std::shared_ptr<Buffer> suffixes = suffix_encoder_.FlushValues();
+  std::shared_ptr<Buffer> suffixes = suffixEncoder_.flushValues();
   PARQUET_THROW_NOT_OK(sink_.Append(suffixes->data(), suffixes->size()));
 
   std::shared_ptr<Buffer> buffer;
   PARQUET_THROW_NOT_OK(sink_.Finish(&buffer, true));
-  last_value_.clear();
+  lastValue_.clear();
   return buffer;
 }
 
-// ----------------------------------------------------------------------
-// DeltaByteArrayDecoder
+// ----------------------------------------------------------------------.
+// DeltaByteArrayDecoder.
 
 template <typename DType>
 class DeltaByteArrayDecoderImpl : public DecoderImpl,
                                   virtual public TypedDecoder<DType> {
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
 
  public:
   explicit DeltaByteArrayDecoderImpl(
       const ColumnDescriptor* descr,
       MemoryPool* pool = ::arrow::default_memory_pool())
-      : DecoderImpl(descr, Encoding::DELTA_BYTE_ARRAY),
+      : DecoderImpl(descr, Encoding::kDeltaByteArray),
         pool_(pool),
-        prefix_len_decoder_(nullptr, pool),
-        suffix_decoder_(nullptr, pool),
-        last_value_in_previous_page_(""),
-        buffered_prefix_length_(AllocateBuffer(pool, 0)),
-        buffered_data_(AllocateBuffer(pool, 0)) {}
-
-  void SetData(int num_values, const uint8_t* data, int len) override {
-    num_values_ = num_values;
+        prefixLenDecoder_(nullptr, pool),
+        suffixDecoder_(nullptr, pool),
+        lastValueInPreviousPage_(""),
+        bufferedPrefixLength_(allocateBuffer(pool, 0)),
+        bufferedData_(allocateBuffer(pool, 0)) {}
+
+  void setData(int numValues, const uint8_t* data, int len) override {
+    numValues_ = numValues;
     decoder_ = std::make_shared<BitReader>(data, len);
-    prefix_len_decoder_.SetDecoder(num_values, decoder_);
+    prefixLenDecoder_.setDecoder(numValues, decoder_);
 
-    // get the number of encoded prefix lengths
-    int num_prefix = prefix_len_decoder_.ValidValuesCount();
-    // call prefix_len_decoder_.Decode to decode all the prefix lengths.
-    // all the prefix lengths are buffered in buffered_prefix_length_.
+    // Get the number of encoded prefix lengths.
+    int numPrefix = prefixLenDecoder_.validValuesCount();
+    // Call prefix_len_decoder_.Decode to decode all the prefix lengths.
+    // All the prefix lengths are buffered in buffered_prefix_length_.
     PARQUET_THROW_NOT_OK(
-        buffered_prefix_length_->Resize(num_prefix * sizeof(int32_t)));
-    VELOX_DEBUG_ONLY int ret = prefix_len_decoder_.Decode(
-        reinterpret_cast<int32_t*>(buffered_prefix_length_->mutable_data()),
-        num_prefix);
-    VELOX_DCHECK_EQ(ret, num_prefix);
-    prefix_len_offset_ = 0;
-    num_valid_values_ = num_prefix;
-
-    int bytes_left = decoder_->bytesLeft();
+        bufferedPrefixLength_->Resize(numPrefix * sizeof(int32_t)));
+    VELOX_DEBUG_ONLY int ret = prefixLenDecoder_.decode(
+        reinterpret_cast<int32_t*>(bufferedPrefixLength_->mutable_data()),
+        numPrefix);
+    VELOX_DCHECK_EQ(ret, numPrefix);
+    prefixLenOffset_ = 0;
+    numValidValues_ = numPrefix;
+
+    int bytesLeft = decoder_->bytesLeft();
     // If len < bytes_left, prefix_len_decoder.Decode will throw exception.
-    VELOX_DCHECK_GE(len, bytes_left);
-    int suffix_begins = len - bytes_left;
-    // at this time, the decoder_ will be at the start of the encoded suffix
-    // data.
-    suffix_decoder_.SetData(num_values, data + suffix_begins, bytes_left);
-
-    // TODO: read corrupted files written with bug(PARQUET-246). last_value_
-    // should be set to last_value_in_previous_page_ when decoding a new
+    VELOX_DCHECK_GE(len, bytesLeft);
+    int suffixBegins = len - bytesLeft;
+    // At this time, the decoder_ will be at the start of the encoded suffix.
+    // Data.
+    suffixDecoder_.setData(numValues, data + suffixBegins, bytesLeft);
+
+    // TODO: read corrupted files written with bug(PARQUET-246). last_value_.
+    // Should be set to last_value_in_previous_page_ when decoding a new.
     // page(except the first page)
-    last_value_ = "";
+    lastValue_ = "";
   }
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<DType>::Accumulator* out) override {
     int result = 0;
-    PARQUET_THROW_NOT_OK(DecodeArrowDense(
-        num_values, null_count, valid_bits, valid_bits_offset, out, &result));
+    PARQUET_THROW_NOT_OK(decodeArrowDense(
+        numValues, nullCount, validBits, validBitsOffset, out, &result));
     return result;
   }
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      typename EncodingTraits<DType>::DictAccumulator* builder) override {
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      typename EncodingTraits<DType>::DictAccumulator* Builder) override {
     ParquetException::NYI(
         "DecodeArrow of DictAccumulator for DeltaByteArrayDecoder");
   }
 
  protected:
-  int GetInternal(ByteArray* buffer, int max_values) {
-    // Decode up to `max_values` strings into an internal buffer
-    // and reference them into `buffer`.
-    max_values = std::min(max_values, num_valid_values_);
-    if (max_values == 0) {
-      return max_values;
+  int getInternal(ByteArray* buffer, int maxValues) {
+    // Decode up to `max_values` strings into an internal buffer.
+    // And reference them into `buffer`.
+    maxValues = std::min(maxValues, numValidValues_);
+    if (maxValues == 0) {
+      return maxValues;
     }
 
-    int suffix_read = suffix_decoder_.Decode(buffer, max_values);
-    if (ARROW_PREDICT_FALSE(suffix_read != max_values)) {
-      ParquetException::EofException(
-          "Read " + std::to_string(suffix_read) + ", expecting " +
-          std::to_string(max_values) + " from suffix decoder");
+    int suffixRead = suffixDecoder_.decode(buffer, maxValues);
+    if (ARROW_PREDICT_FALSE(suffixRead != maxValues)) {
+      ParquetException::eofException(
+          "Read " + std::to_string(suffixRead) + ", expecting " +
+          std::to_string(maxValues) + " from suffix decoder");
     }
 
-    int64_t data_size = 0;
-    const int32_t* prefix_len_ptr =
-        reinterpret_cast<const int32_t*>(buffered_prefix_length_->data()) +
-        prefix_len_offset_;
-    for (int i = 0; i < max_values; ++i) {
-      if (ARROW_PREDICT_FALSE(prefix_len_ptr[i] < 0)) {
+    int64_t dataSize = 0;
+    const int32_t* prefixLenPtr =
+        reinterpret_cast<const int32_t*>(bufferedPrefixLength_->data()) +
+        prefixLenOffset_;
+    for (int i = 0; i < maxValues; ++i) {
+      if (ARROW_PREDICT_FALSE(prefixLenPtr[i] < 0)) {
         throw ParquetException("negative prefix length in DELTA_BYTE_ARRAY");
       }
       if (ARROW_PREDICT_FALSE(
-              AddWithOverflow(data_size, prefix_len_ptr[i], &data_size) ||
-              AddWithOverflow(data_size, buffer[i].len, &data_size))) {
+              addWithOverflow(dataSize, prefixLenPtr[i], &dataSize) ||
+              addWithOverflow(dataSize, buffer[i].len, &dataSize))) {
         throw ParquetException("excess expansion in DELTA_BYTE_ARRAY");
       }
     }
-    PARQUET_THROW_NOT_OK(buffered_data_->Resize(data_size));
+    PARQUET_THROW_NOT_OK(bufferedData_->Resize(dataSize));
 
-    string_view prefix{last_value_};
-    uint8_t* data_ptr = buffered_data_->mutable_data();
-    for (int i = 0; i < max_values; ++i) {
+    string_view prefix{lastValue_};
+    uint8_t* dataPtr = bufferedData_->mutable_data();
+    for (int i = 0; i < maxValues; ++i) {
       if (ARROW_PREDICT_FALSE(
-              static_cast<size_t>(prefix_len_ptr[i]) > prefix.length())) {
+              static_cast<size_t>(prefixLenPtr[i]) > prefix.length())) {
         throw ParquetException("prefix length too large in DELTA_BYTE_ARRAY");
       }
-      memcpy(data_ptr, prefix.data(), prefix_len_ptr[i]);
-      // buffer[i] currently points to the string suffix
-      memcpy(data_ptr + prefix_len_ptr[i], buffer[i].ptr, buffer[i].len);
-      buffer[i].ptr = data_ptr;
-      buffer[i].len += prefix_len_ptr[i];
-      data_ptr += buffer[i].len;
+      memcpy(dataPtr, prefix.data(), prefixLenPtr[i]);
+      // Buffer[i] currently points to the string suffix.
+      memcpy(dataPtr + prefixLenPtr[i], buffer[i].ptr, buffer[i].len);
+      buffer[i].ptr = dataPtr;
+      buffer[i].len += prefixLenPtr[i];
+      dataPtr += buffer[i].len;
       prefix = std::string_view{buffer[i]};
     }
-    prefix_len_offset_ += max_values;
-    this->num_values_ -= max_values;
-    num_valid_values_ -= max_values;
-    last_value_ = std::string{prefix};
+    prefixLenOffset_ += maxValues;
+    this->numValues_ -= maxValues;
+    numValidValues_ -= maxValues;
+    lastValue_ = std::string{prefix};
 
-    if (num_valid_values_ == 0) {
-      last_value_in_previous_page_ = last_value_;
+    if (numValidValues_ == 0) {
+      lastValueInPreviousPage_ = lastValue_;
     }
-    return max_values;
+    return maxValues;
   }
 
-  Status DecodeArrowDense(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  Status decodeArrowDense(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<DType>::Accumulator* out,
-      int* out_num_values) {
-    ArrowBinaryHelper<DType> helper(out, num_values);
-    RETURN_NOT_OK(helper.Prepare());
+      int* outNumValues) {
+    ArrowBinaryHelper<DType> helper(out, numValues);
+    RETURN_NOT_OK(helper.prepare());
 
-    std::vector<ByteArray> values(num_values);
-    const int num_valid_values =
-        GetInternal(values.data(), num_values - null_count);
-    VELOX_DCHECK_EQ(num_values - null_count, num_valid_values);
+    std::vector<ByteArray> values(numValues);
+    const int numValidValues =
+        getInternal(values.data(), numValues - nullCount);
+    VELOX_DCHECK_EQ(numValues - nullCount, numValidValues);
 
-    auto values_ptr = reinterpret_cast<const ByteArray*>(values.data());
-    int value_idx = 0;
+    auto valuesPtr = reinterpret_cast<const ByteArray*>(values.data());
+    int valueIdx = 0;
 
     RETURN_NOT_OK(VisitNullBitmapInline(
-        valid_bits,
-        valid_bits_offset,
-        num_values,
-        null_count,
+        validBits,
+        validBitsOffset,
+        numValues,
+        nullCount,
         [&]() {
-          const auto& val = values_ptr[value_idx];
-          RETURN_NOT_OK(helper.PrepareNextInput(val.len));
+          const auto& val = valuesPtr[valueIdx];
+          RETURN_NOT_OK(helper.prepareNextInput(val.len));
           RETURN_NOT_OK(helper.Append(val.ptr, static_cast<int32_t>(val.len)));
-          ++value_idx;
+          ++valueIdx;
           return Status::OK();
         },
         [&]() {
           RETURN_NOT_OK(helper.AppendNull());
-          --null_count;
+          --nullCount;
           return Status::OK();
         }));
 
-    VELOX_DCHECK_EQ(null_count, 0);
-    *out_num_values = num_valid_values;
+    VELOX_DCHECK_EQ(nullCount, 0);
+    *outNumValues = numValidValues;
     return Status::OK();
   }
 
@@ -3925,15 +3881,15 @@ class DeltaByteArrayDecoderImpl : public DecoderImpl,
 
  private:
   std::shared_ptr<BitReader> decoder_;
-  DeltaBitPackDecoder<Int32Type> prefix_len_decoder_;
-  DeltaLengthByteArrayDecoder suffix_decoder_;
-  std::string last_value_;
-  // string buffer for last value in previous page
-  std::string last_value_in_previous_page_;
-  int num_valid_values_{0};
-  uint32_t prefix_len_offset_{0};
-  std::shared_ptr<ResizableBuffer> buffered_prefix_length_;
-  std::shared_ptr<ResizableBuffer> buffered_data_;
+  DeltaBitPackDecoder<Int32Type> prefixLenDecoder_;
+  DeltaLengthByteArrayDecoder suffixDecoder_;
+  std::string lastValue_;
+  // String buffer for last value in previous page.
+  std::string lastValueInPreviousPage_;
+  int numValidValues_{0};
+  uint32_t prefixLenOffset_{0};
+  std::shared_ptr<ResizableBuffer> bufferedPrefixLength_;
+  std::shared_ptr<ResizableBuffer> bufferedData_;
 };
 
 class DeltaByteArrayDecoder : public DeltaByteArrayDecoderImpl<ByteArrayType> {
@@ -3941,8 +3897,8 @@ class DeltaByteArrayDecoder : public DeltaByteArrayDecoderImpl<ByteArrayType> {
   using Base = DeltaByteArrayDecoderImpl<ByteArrayType>;
   using Base::DeltaByteArrayDecoderImpl;
 
-  int Decode(ByteArray* buffer, int max_values) override {
-    return GetInternal(buffer, max_values);
+  int decode(ByteArray* buffer, int maxValues) override {
+    return getInternal(buffer, maxValues);
   }
 };
 
@@ -3953,62 +3909,62 @@ class DeltaByteArrayFLBADecoder : public DeltaByteArrayDecoderImpl<FLBAType>,
   using Base::DeltaByteArrayDecoderImpl;
   using Base::pool_;
 
-  int Decode(FixedLenByteArray* buffer, int max_values) override {
+  int decode(FixedLenByteArray* buffer, int maxValues) override {
     // GetInternal currently only support ByteArray.
-    std::vector<ByteArray> decode_byte_array(max_values);
-    const int decoded_values_size =
-        GetInternal(decode_byte_array.data(), max_values);
-    const uint32_t type_length = descr_->type_length();
+    std::vector<ByteArray> decodeByteArray(maxValues);
+    const int decodedValuesSize =
+        getInternal(decodeByteArray.data(), maxValues);
+    const uint32_t typeLength = descr_->typeLength();
 
-    for (int i = 0; i < decoded_values_size; i++) {
-      if (ARROW_PREDICT_FALSE(decode_byte_array[i].len != type_length)) {
+    for (int i = 0; i < decodedValuesSize; i++) {
+      if (ARROW_PREDICT_FALSE(decodeByteArray[i].len != typeLength)) {
         throw ParquetException("Fixed length byte array length mismatch");
       }
-      buffer[i].ptr = decode_byte_array[i].ptr;
+      buffer[i].ptr = decodeByteArray[i].ptr;
     }
-    return decoded_values_size;
+    return decodedValuesSize;
   }
 };
 
-// ----------------------------------------------------------------------
-// BYTE_STREAM_SPLIT
+// ----------------------------------------------------------------------.
+// BYTE_STREAM_SPLIT.
 
 template <typename DType>
 class ByteStreamSplitDecoder : public DecoderImpl,
                                virtual public TypedDecoder<DType> {
  public:
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
   explicit ByteStreamSplitDecoder(const ColumnDescriptor* descr);
 
-  int Decode(T* buffer, int max_values) override;
+  int decode(T* buffer, int maxValues) override;
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      typename EncodingTraits<DType>::Accumulator* builder) override;
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      typename EncodingTraits<DType>::Accumulator* Builder) override;
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      typename EncodingTraits<DType>::DictAccumulator* builder) override;
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      typename EncodingTraits<DType>::DictAccumulator* Builder) override;
 
-  void SetData(int num_values, const uint8_t* data, int len) override;
+  void setData(int numValues, const uint8_t* data, int len) override;
 
-  T* EnsureDecodeBuffer(int64_t min_values) {
-    const int64_t size = sizeof(T) * min_values;
-    if (!decode_buffer_ || decode_buffer_->size() < size) {
-      PARQUET_ASSIGN_OR_THROW(decode_buffer_, ::arrow::AllocateBuffer(size));
+  T* ensureDecodeBuffer(int64_t minValues) {
+    const int64_t size = sizeof(T) * minValues;
+    if (!decodeBuffer_ || decodeBuffer_->size() < size) {
+      decodeBuffer_ = allocateBuffer(::arrow::default_memory_pool(), size);
     }
-    return reinterpret_cast<T*>(decode_buffer_->mutable_data());
+    return reinterpret_cast<T*>(decodeBuffer_->mutable_data());
   }
 
  private:
-  int num_values_in_buffer_{0};
-  std::shared_ptr<Buffer> decode_buffer_;
+  int numValuesInBuffer_{0};
+  std::shared_ptr<Buffer> decodeBuffer_;
 
   static constexpr size_t kNumStreams = sizeof(T);
 };
@@ -4016,14 +3972,14 @@ class ByteStreamSplitDecoder : public DecoderImpl,
 template <typename DType>
 ByteStreamSplitDecoder<DType>::ByteStreamSplitDecoder(
     const ColumnDescriptor* descr)
-    : DecoderImpl(descr, Encoding::BYTE_STREAM_SPLIT) {}
+    : DecoderImpl(descr, Encoding::kByteStreamSplit) {}
 
 template <typename DType>
-void ByteStreamSplitDecoder<DType>::SetData(
-    int num_values,
+void ByteStreamSplitDecoder<DType>::setData(
+    int numValues,
     const uint8_t* data,
     int len) {
-  if (num_values * static_cast<int64_t>(sizeof(T)) < len) {
+  if (numValues * static_cast<int64_t>(sizeof(T)) < len) {
     throw ParquetException(
         "Data size too large for number of values (padding in byte stream split data "
         "page?)");
@@ -4031,194 +3987,193 @@ void ByteStreamSplitDecoder<DType>::SetData(
   if (len % sizeof(T) != 0) {
     throw ParquetException(
         "ByteStreamSplit data size " + std::to_string(len) +
-        " not aligned with type " + TypeToString(DType::type_num));
+        " not aligned with type " + typeToString(DType::typeNum));
   }
-  num_values = len / sizeof(T);
-  DecoderImpl::SetData(num_values, data, len);
-  num_values_in_buffer_ = num_values_;
+  numValues = len / sizeof(T);
+  DecoderImpl::setData(numValues, data, len);
+  numValuesInBuffer_ = numValues_;
 }
 
 template <typename DType>
-int ByteStreamSplitDecoder<DType>::Decode(T* buffer, int max_values) {
-  const int values_to_decode = std::min(num_values_, max_values);
-  const int num_decoded_previously = num_values_in_buffer_ - num_values_;
-  const uint8_t* data = data_ + num_decoded_previously;
-
-  ByteStreamSplitDecode<T>(
-      data, values_to_decode, num_values_in_buffer_, buffer);
-  num_values_ -= values_to_decode;
-  len_ -= sizeof(T) * values_to_decode;
-  return values_to_decode;
+int ByteStreamSplitDecoder<DType>::decode(T* buffer, int maxValues) {
+  const int valuesToDecode = std::min(numValues_, maxValues);
+  const int numDecodedPreviously = numValuesInBuffer_ - numValues_;
+  const uint8_t* data = data_ + numDecodedPreviously;
+
+  byteStreamSplitDecode<T>(data, valuesToDecode, numValuesInBuffer_, buffer);
+  numValues_ -= valuesToDecode;
+  len_ -= sizeof(T) * valuesToDecode;
+  return valuesToDecode;
 }
 
 template <typename DType>
-int ByteStreamSplitDecoder<DType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<DType>::Accumulator* builder) {
-  constexpr int value_size = static_cast<int>(kNumStreams);
-  int values_decoded = num_values - null_count;
-  if (ARROW_PREDICT_FALSE(len_ < value_size * values_decoded)) {
-    ParquetException::EofException();
-  }
-
-  PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
-
-  const int num_decoded_previously = num_values_in_buffer_ - num_values_;
-  const uint8_t* data = data_ + num_decoded_previously;
+int ByteStreamSplitDecoder<DType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<DType>::Accumulator* Builder) {
+  constexpr int valueSize = static_cast<int>(kNumStreams);
+  int valuesDecoded = numValues - nullCount;
+  if (ARROW_PREDICT_FALSE(len_ < valueSize * valuesDecoded)) {
+    ParquetException::eofException();
+  }
+
+  PARQUET_THROW_NOT_OK(Builder->Reserve(numValues));
+
+  const int numDecodedPreviously = numValuesInBuffer_ - numValues_;
+  const uint8_t* data = data_ + numDecodedPreviously;
   int offset = 0;
 
 #if defined(ARROW_HAVE_SIMD_SPLIT)
-  // Use fast decoding into intermediate buffer.  This will also decode
-  // some null values, but it's fast enough that we don't care.
-  T* decode_out = EnsureDecodeBuffer(values_decoded);
-  ::arrow::util::internal::ByteStreamSplitDecode<T>(
-      data, values_decoded, num_values_in_buffer_, decode_out);
-
-  // XXX If null_count is 0, we could even append in bulk or decode directly
-  // into builder
+  // Use fast decoding into intermediate buffer.  This will also decode.
+  // Some null values, but it's fast enough that we don't care.
+  T* decodeOut = ensureDecodeBuffer(valuesDecoded);
+  ::arrow::util::internal::byte_stream_split_decode<T>(
+      data, valuesDecoded, numValuesInBuffer_, decodeOut);
+
+  // XXX If null_count is 0, we could even Append in bulk or decode directly.
+  // Into builder.
   VisitNullBitmapInline(
-      valid_bits,
-      valid_bits_offset,
-      num_values,
-      null_count,
+      validBits,
+      validBitsOffset,
+      numValues,
+      nullCount,
       [&]() {
-        builder->UnsafeAppend(decode_out[offset]);
+        Builder->UnsafeAppend(decodeOut[offset]);
         ++offset;
       },
-      [&]() { builder->UnsafeAppendNull(); });
+      [&]() { Builder->UnsafeAppendNull(); });
 
 #else
   VisitNullBitmapInline(
-      valid_bits,
-      valid_bits_offset,
-      num_values,
-      null_count,
+      validBits,
+      validBitsOffset,
+      numValues,
+      nullCount,
       [&]() {
-        uint8_t gathered_byte_data[kNumStreams];
+        uint8_t gatheredByteData[kNumStreams];
         for (size_t b = 0; b < kNumStreams; ++b) {
-          const size_t byte_index = b * num_values_in_buffer_ + offset;
-          gathered_byte_data[b] = data[byte_index];
+          const size_t byteIndex = b * numValuesInBuffer_ + offset;
+          gatheredByteData[b] = data[byteIndex];
         }
-        builder->UnsafeAppend(SafeLoadAs<T>(&gathered_byte_data[0]));
+        Builder->UnsafeAppend(SafeLoadAs<T>(&gatheredByteData[0]));
         ++offset;
       },
-      [&]() { builder->UnsafeAppendNull(); });
+      [&]() { Builder->UnsafeAppendNull(); });
 #endif
 
-  num_values_ -= values_decoded;
-  len_ -= sizeof(T) * values_decoded;
-  return values_decoded;
+  numValues_ -= valuesDecoded;
+  len_ -= sizeof(T) * valuesDecoded;
+  return valuesDecoded;
 }
 
 template <typename DType>
-int ByteStreamSplitDecoder<DType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<DType>::DictAccumulator* builder) {
+int ByteStreamSplitDecoder<DType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<DType>::DictAccumulator* Builder) {
   ParquetException::NYI("DecodeArrow for ByteStreamSplitDecoder");
 }
 
 } // namespace
 
-// ----------------------------------------------------------------------
-// Encoder and decoder factory functions
+// ----------------------------------------------------------------------.
+// Encoder and decoder factory functions.
 
-std::unique_ptr<Encoder> MakeEncoder(
-    Type::type type_num,
+std::unique_ptr<Encoder> makeEncoder(
+    Type::type typeNum,
     Encoding::type encoding,
-    bool use_dictionary,
+    bool useDictionary,
     const ColumnDescriptor* descr,
     MemoryPool* pool) {
-  if (use_dictionary) {
-    switch (type_num) {
-      case Type::INT32:
+  if (useDictionary) {
+    switch (typeNum) {
+      case Type::kInt32:
         return std::make_unique<DictEncoderImpl<Int32Type>>(descr, pool);
-      case Type::INT64:
+      case Type::kInt64:
         return std::make_unique<DictEncoderImpl<Int64Type>>(descr, pool);
-      case Type::INT96:
+      case Type::kInt96:
         return std::make_unique<DictEncoderImpl<Int96Type>>(descr, pool);
-      case Type::FLOAT:
+      case Type::kFloat:
         return std::make_unique<DictEncoderImpl<FloatType>>(descr, pool);
-      case Type::DOUBLE:
+      case Type::kDouble:
         return std::make_unique<DictEncoderImpl<DoubleType>>(descr, pool);
-      case Type::BYTE_ARRAY:
+      case Type::kByteArray:
         return std::make_unique<DictEncoderImpl<ByteArrayType>>(descr, pool);
-      case Type::FIXED_LEN_BYTE_ARRAY:
+      case Type::kFixedLenByteArray:
         return std::make_unique<DictEncoderImpl<FLBAType>>(descr, pool);
       default:
         VELOX_DCHECK(false, "Encoder not implemented");
         break;
     }
-  } else if (encoding == Encoding::PLAIN) {
-    switch (type_num) {
-      case Type::BOOLEAN:
+  } else if (encoding == Encoding::kPlain) {
+    switch (typeNum) {
+      case Type::kBoolean:
         return std::make_unique<PlainEncoder<BooleanType>>(descr, pool);
-      case Type::INT32:
+      case Type::kInt32:
         return std::make_unique<PlainEncoder<Int32Type>>(descr, pool);
-      case Type::INT64:
+      case Type::kInt64:
         return std::make_unique<PlainEncoder<Int64Type>>(descr, pool);
-      case Type::INT96:
+      case Type::kInt96:
         return std::make_unique<PlainEncoder<Int96Type>>(descr, pool);
-      case Type::FLOAT:
+      case Type::kFloat:
         return std::make_unique<PlainEncoder<FloatType>>(descr, pool);
-      case Type::DOUBLE:
+      case Type::kDouble:
         return std::make_unique<PlainEncoder<DoubleType>>(descr, pool);
-      case Type::BYTE_ARRAY:
+      case Type::kByteArray:
         return std::make_unique<PlainEncoder<ByteArrayType>>(descr, pool);
-      case Type::FIXED_LEN_BYTE_ARRAY:
+      case Type::kFixedLenByteArray:
         return std::make_unique<PlainEncoder<FLBAType>>(descr, pool);
       default:
         VELOX_DCHECK(false, "Encoder not implemented");
         break;
     }
-  } else if (encoding == Encoding::BYTE_STREAM_SPLIT) {
-    switch (type_num) {
-      case Type::FLOAT:
+  } else if (encoding == Encoding::kByteStreamSplit) {
+    switch (typeNum) {
+      case Type::kFloat:
         return std::make_unique<ByteStreamSplitEncoder<FloatType>>(descr, pool);
-      case Type::DOUBLE:
+      case Type::kDouble:
         return std::make_unique<ByteStreamSplitEncoder<DoubleType>>(
             descr, pool);
       default:
         throw ParquetException(
             "BYTE_STREAM_SPLIT only supports FLOAT and DOUBLE");
     }
-  } else if (encoding == Encoding::DELTA_BINARY_PACKED) {
-    switch (type_num) {
-      case Type::INT32:
+  } else if (encoding == Encoding::kDeltaBinaryPacked) {
+    switch (typeNum) {
+      case Type::kInt32:
         return std::make_unique<DeltaBitPackEncoder<Int32Type>>(descr, pool);
-      case Type::INT64:
+      case Type::kInt64:
         return std::make_unique<DeltaBitPackEncoder<Int64Type>>(descr, pool);
       default:
         throw ParquetException(
             "DELTA_BINARY_PACKED encoder only supports INT32 and INT64");
     }
-  } else if (encoding == Encoding::DELTA_LENGTH_BYTE_ARRAY) {
-    switch (type_num) {
-      case Type::BYTE_ARRAY:
+  } else if (encoding == Encoding::kDeltaLengthByteArray) {
+    switch (typeNum) {
+      case Type::kByteArray:
         return std::make_unique<DeltaLengthByteArrayEncoder<ByteArrayType>>(
             descr, pool);
       default:
         throw ParquetException(
             "DELTA_LENGTH_BYTE_ARRAY only supports BYTE_ARRAY");
     }
-  } else if (encoding == Encoding::RLE) {
-    switch (type_num) {
-      case Type::BOOLEAN:
+  } else if (encoding == Encoding::kRle) {
+    switch (typeNum) {
+      case Type::kBoolean:
         return std::make_unique<RleBooleanEncoder>(descr, pool);
       default:
         throw ParquetException("RLE only supports BOOLEAN");
     }
-  } else if (encoding == Encoding::DELTA_BYTE_ARRAY) {
-    switch (type_num) {
-      case Type::BYTE_ARRAY:
+  } else if (encoding == Encoding::kDeltaByteArray) {
+    switch (typeNum) {
+      case Type::kByteArray:
         return std::make_unique<DeltaByteArrayEncoder<ByteArrayType>>(
             descr, pool);
-      case Type::FIXED_LEN_BYTE_ARRAY:
+      case Type::kFixedLenByteArray:
         return std::make_unique<DeltaByteArrayEncoder<FLBAType>>(descr, pool);
       default:
         throw ParquetException(
@@ -4231,69 +4186,69 @@ std::unique_ptr<Encoder> MakeEncoder(
   return nullptr;
 }
 
-std::unique_ptr<Decoder> MakeDecoder(
-    Type::type type_num,
+std::unique_ptr<Decoder> makeDecoder(
+    Type::type typeNum,
     Encoding::type encoding,
     const ColumnDescriptor* descr,
     ::arrow::MemoryPool* pool) {
-  if (encoding == Encoding::PLAIN) {
-    switch (type_num) {
-      case Type::BOOLEAN:
+  if (encoding == Encoding::kPlain) {
+    switch (typeNum) {
+      case Type::kBoolean:
         return std::make_unique<PlainBooleanDecoder>(descr);
-      case Type::INT32:
+      case Type::kInt32:
         return std::make_unique<PlainDecoder<Int32Type>>(descr);
-      case Type::INT64:
+      case Type::kInt64:
         return std::make_unique<PlainDecoder<Int64Type>>(descr);
-      case Type::INT96:
+      case Type::kInt96:
         return std::make_unique<PlainDecoder<Int96Type>>(descr);
-      case Type::FLOAT:
+      case Type::kFloat:
         return std::make_unique<PlainDecoder<FloatType>>(descr);
-      case Type::DOUBLE:
+      case Type::kDouble:
         return std::make_unique<PlainDecoder<DoubleType>>(descr);
-      case Type::BYTE_ARRAY:
+      case Type::kByteArray:
         return std::make_unique<PlainByteArrayDecoder>(descr);
-      case Type::FIXED_LEN_BYTE_ARRAY:
+      case Type::kFixedLenByteArray:
         return std::make_unique<PlainFLBADecoder>(descr);
       default:
         break;
     }
-  } else if (encoding == Encoding::BYTE_STREAM_SPLIT) {
-    switch (type_num) {
-      case Type::FLOAT:
+  } else if (encoding == Encoding::kByteStreamSplit) {
+    switch (typeNum) {
+      case Type::kFloat:
         return std::make_unique<ByteStreamSplitDecoder<FloatType>>(descr);
-      case Type::DOUBLE:
+      case Type::kDouble:
         return std::make_unique<ByteStreamSplitDecoder<DoubleType>>(descr);
       default:
         throw ParquetException(
             "BYTE_STREAM_SPLIT only supports FLOAT and DOUBLE");
     }
-  } else if (encoding == Encoding::DELTA_BINARY_PACKED) {
-    switch (type_num) {
-      case Type::INT32:
+  } else if (encoding == Encoding::kDeltaBinaryPacked) {
+    switch (typeNum) {
+      case Type::kInt32:
         return std::make_unique<DeltaBitPackDecoder<Int32Type>>(descr, pool);
-      case Type::INT64:
+      case Type::kInt64:
         return std::make_unique<DeltaBitPackDecoder<Int64Type>>(descr, pool);
       default:
         throw ParquetException(
             "DELTA_BINARY_PACKED decoder only supports INT32 and INT64");
     }
-  } else if (encoding == Encoding::DELTA_BYTE_ARRAY) {
-    switch (type_num) {
-      case Type::BYTE_ARRAY:
+  } else if (encoding == Encoding::kDeltaByteArray) {
+    switch (typeNum) {
+      case Type::kByteArray:
         return std::make_unique<DeltaByteArrayDecoder>(descr, pool);
-      case Type::FIXED_LEN_BYTE_ARRAY:
+      case Type::kFixedLenByteArray:
         return std::make_unique<DeltaByteArrayFLBADecoder>(descr, pool);
       default:
         throw ParquetException(
             "DELTA_BYTE_ARRAY only supports BYTE_ARRAY and FIXED_LEN_BYTE_ARRAY");
     }
-  } else if (encoding == Encoding::DELTA_LENGTH_BYTE_ARRAY) {
-    if (type_num == Type::BYTE_ARRAY) {
+  } else if (encoding == Encoding::kDeltaLengthByteArray) {
+    if (typeNum == Type::kByteArray) {
       return std::make_unique<DeltaLengthByteArrayDecoder>(descr, pool);
     }
     throw ParquetException("DELTA_LENGTH_BYTE_ARRAY only supports BYTE_ARRAY");
-  } else if (encoding == Encoding::RLE) {
-    if (type_num == Type::BOOLEAN) {
+  } else if (encoding == Encoding::kRle) {
+    if (typeNum == Type::kBoolean) {
       throw ParquetException("RleBooleanDecoder has been disabled.");
       // return std::make_unique<RleBooleanDecoder>(descr);
     }
@@ -4306,27 +4261,27 @@ std::unique_ptr<Decoder> MakeDecoder(
 }
 
 namespace detail {
-std::unique_ptr<Decoder> MakeDictDecoder(
-    Type::type type_num,
+std::unique_ptr<Decoder> makeDictDecoder(
+    Type::type typeNum,
     const ColumnDescriptor* descr,
     MemoryPool* pool) {
-  switch (type_num) {
-    case Type::BOOLEAN:
+  switch (typeNum) {
+    case Type::kBoolean:
       ParquetException::NYI(
           "Dictionary encoding not implemented for boolean type");
-    case Type::INT32:
+    case Type::kInt32:
       return std::make_unique<DictDecoderImpl<Int32Type>>(descr, pool);
-    case Type::INT64:
+    case Type::kInt64:
       return std::make_unique<DictDecoderImpl<Int64Type>>(descr, pool);
-    case Type::INT96:
+    case Type::kInt96:
       return std::make_unique<DictDecoderImpl<Int96Type>>(descr, pool);
-    case Type::FLOAT:
+    case Type::kFloat:
       return std::make_unique<DictDecoderImpl<FloatType>>(descr, pool);
-    case Type::DOUBLE:
+    case Type::kDouble:
       return std::make_unique<DictDecoderImpl<DoubleType>>(descr, pool);
-    case Type::BYTE_ARRAY:
+    case Type::kByteArray:
       return std::make_unique<DictByteArrayDecoderImpl>(descr, pool);
-    case Type::FIXED_LEN_BYTE_ARRAY:
+    case Type::kFixedLenByteArray:
       return std::make_unique<DictDecoderImpl<FLBAType>>(descr, pool);
     default:
       break;
diff --git a/velox/dwio/parquet/writer/arrow/Encoding.h b/velox/dwio/parquet/writer/arrow/Encoding.h
index b57ee2b68e3..0100136ecf5 100644
--- a/velox/dwio/parquet/writer/arrow/Encoding.h
+++ b/velox/dwio/parquet/writer/arrow/Encoding.h
@@ -144,9 +144,9 @@ struct EncodingTraits<ByteArrayType> {
 
   using ArrowType = ::arrow::BinaryType;
   /// \brief Internal helper class for decoding BYTE_ARRAY data where we can
-  /// overflow the capacity of a single arrow::BinaryArray
+  /// overflow the capacity of a single arrow::BinaryArray.
   struct Accumulator {
-    std::unique_ptr<::arrow::BinaryBuilder> builder;
+    std::unique_ptr<::arrow::BinaryBuilder> Builder;
     std::vector<std::shared_ptr<::arrow::Array>> chunks;
   };
   using DictAccumulator = ::arrow::Dictionary32Builder<::arrow::BinaryType>;
@@ -165,18 +165,18 @@ struct EncodingTraits<FLBAType> {
 
 class ColumnDescriptor;
 
-// Untyped base for all encoders
+// Untyped base for all encoders.
 class Encoder {
  public:
   virtual ~Encoder() = default;
 
-  virtual int64_t EstimatedDataEncodedSize() = 0;
-  virtual std::shared_ptr<::arrow::Buffer> FlushValues() = 0;
+  virtual int64_t estimatedDataEncodedSize() = 0;
+  virtual std::shared_ptr<::arrow::Buffer> flushValues() = 0;
   virtual Encoding::type encoding() const = 0;
 
-  virtual void Put(const ::arrow::Array& values) = 0;
+  virtual void put(const ::arrow::Array& values) = 0;
 
-  virtual ::arrow::MemoryPool* memory_pool() const = 0;
+  virtual ::arrow::MemoryPool* memoryPool() const = 0;
 };
 
 // Base class for value encoders. Since encoders may or not have state (e.g.,
@@ -186,74 +186,74 @@ class Encoder {
 template <typename DType>
 class TypedEncoder : virtual public Encoder {
  public:
-  typedef typename DType::c_type T;
+  typedef typename DType::CType T;
 
-  using Encoder::Put;
+  using Encoder::put;
 
-  virtual void Put(const T* src, int num_values) = 0;
+  virtual void put(const T* src, int numValues) = 0;
 
-  virtual void Put(const std::vector<T>& src, int num_values = -1);
+  virtual void put(const std::vector<T>& src, int numValues = -1);
 
-  virtual void PutSpaced(
+  virtual void putSpaced(
       const T* src,
-      int num_values,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset) = 0;
+      int numValues,
+      const uint8_t* validBits,
+      int64_t validBitsOffset) = 0;
 };
 
 template <typename DType>
-void TypedEncoder<DType>::Put(const std::vector<T>& src, int num_values) {
-  if (num_values == -1) {
-    num_values = static_cast<int>(src.size());
+void TypedEncoder<DType>::put(const std::vector<T>& src, int numValues) {
+  if (numValues == -1) {
+    numValues = static_cast<int>(src.size());
   }
-  Put(src.data(), num_values);
+  put(src.data(), numValues);
 }
 
 template <>
-inline void TypedEncoder<BooleanType>::Put(
+inline void TypedEncoder<BooleanType>::put(
     const std::vector<bool>& src,
-    int num_values) {
+    int numValues) {
   // NOTE(wesm): This stub is here only to satisfy the compiler; it is
-  // overridden later with the actual implementation
+  // overridden later with the actual implementation.
 }
 
-// Base class for dictionary encoders
+// Base class for dictionary encoders.
 template <typename DType>
 class DictEncoder : virtual public TypedEncoder<DType> {
  public:
   /// Writes out any buffered indices to buffer preceded by the bit width of
   /// this data. Returns the number of bytes written. If the supplied buffer is
-  /// not big enough, returns -1. buffer must be preallocated with buffer_len
+  /// not big enough, returns -1. Buffer must be preallocated with buffer_len
   /// bytes. Use EstimatedDataEncodedSize() to size buffer.
-  virtual int WriteIndices(uint8_t* buffer, int buffer_len) = 0;
+  virtual int writeIndices(uint8_t* buffer, int bufferLen) = 0;
 
-  virtual int dict_encoded_size() const = 0;
+  virtual int dictEncodedSize() const = 0;
 
-  virtual int bit_width() const = 0;
+  virtual int bitWidth() const = 0;
 
-  /// Writes out the encoded dictionary to buffer. buffer must be preallocated
+  /// Writes out the encoded dictionary to buffer. Buffer must be preallocated
   /// to dict_encoded_size() bytes.
-  virtual void WriteDict(uint8_t* buffer) const = 0;
+  virtual void writeDict(uint8_t* buffer) const = 0;
 
-  virtual int num_entries() const = 0;
+  virtual int numEntries() const = 0;
 
   /// \brief EXPERIMENTAL: Append dictionary indices into the encoder. It is
   /// assumed (without any boundschecking) that the indices reference
-  /// pre-existing dictionary values
-  /// \param[in] indices the dictionary index values. Only Int32Array currently
-  /// supported
-  virtual void PutIndices(const ::arrow::Array& indices) = 0;
+  /// pre-existing dictionary values.
+  /// \param[in] indices The dictionary index values. Only Int32Array currently
+  /// supported.
+  virtual void putIndices(const ::arrow::Array& indices) = 0;
 
   /// \brief EXPERIMENTAL: Append dictionary into encoder, inserting indices
   /// separately. Currently throws exception if the current dictionary memo is
-  /// non-empty
-  /// \param[in] values the dictionary values. Only valid for certain
-  /// Parquet/Arrow type combinations, like BYTE_ARRAY/BinaryArray
-  virtual void PutDictionary(const ::arrow::Array& values) = 0;
+  /// non-empty.
+  /// \param[in] values The dictionary values. Only valid for certain
+  /// Parquet/Arrow type combinations, like BYTE_ARRAY/BinaryArray.
+  virtual void putDictionary(const ::arrow::Array& values) = 0;
 };
 
-// ----------------------------------------------------------------------
-// Value decoding
+// ----------------------------------------------------------------------.
+// Value decoding.
 
 class Decoder {
  public:
@@ -261,145 +261,145 @@ class Decoder {
 
   // Sets the data for a new page. This will be called multiple times on the
   // same decoder and should reset all internal state.
-  virtual void SetData(int num_values, const uint8_t* data, int len) = 0;
+  virtual void setData(int numValues, const uint8_t* data, int len) = 0;
 
-  // Returns the number of values left (for the last call to SetData()). This is
-  // the number of values left in this page.
-  virtual int values_left() const = 0;
+  // Returns the number of values left (for the last call to SetData()). This
+  // is the number of values left in this page.
+  virtual int valuesLeft() const = 0;
   virtual Encoding::type encoding() const = 0;
 };
 
 template <typename DType>
 class TypedDecoder : virtual public Decoder {
  public:
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
 
-  /// \brief Decode values into a buffer
+  /// \brief Decode values into a buffer.
   ///
   /// Subclasses may override the more specialized Decode methods below.
   ///
-  /// \param[in] buffer destination for decoded values
-  /// \param[in] max_values maximum number of values to decode
+  /// \param[in] buffer Destination for decoded values.
+  /// \param[in] max_values Maximum number of values to decode.
   /// \return The number of values decoded. Should be identical to max_values
   /// except at the end of the current data page.
-  virtual int Decode(T* buffer, int max_values) = 0;
+  virtual int decode(T* buffer, int maxValues) = 0;
 
   /// \brief Decode the values in this data page but leave spaces for null
   /// entries.
   ///
-  /// \param[in] buffer destination for decoded values
-  /// \param[in] num_values size of the def_levels and buffer arrays including
-  /// the number of null slots \param[in] null_count number of null slots
-  /// \param[in] valid_bits bitmap data indicating position of valid slots
-  /// \param[in] valid_bits_offset offset into valid_bits
+  /// \param[in] buffer Destination for decoded values.
+  /// \param[in] num_values Size of the def_levels and buffer arrays including
+  /// the number of null slots \param[in] null_count Number of null slots.
+  /// \param[in] valid_bits Bitmap data indicating position of valid slots.
+  /// \param[in] valid_bits_offset Offset into valid_bits.
   /// \return The number of values decoded, including nulls.
-  virtual int DecodeSpaced(
+  virtual int decodeSpaced(
       T* buffer,
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset) {
-    if (null_count > 0) {
-      int values_to_read = num_values - null_count;
-      int values_read = Decode(buffer, values_to_read);
-      if (values_read != values_to_read) {
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset) {
+    if (nullCount > 0) {
+      int valuesToRead = numValues - nullCount;
+      int valuesRead = decode(buffer, valuesToRead);
+      if (valuesRead != valuesToRead) {
         throw ParquetException(
             "Number of values / definition_levels read did not match");
       }
 
       return ::arrow::util::internal::SpacedExpand<T>(
-          buffer, num_values, null_count, valid_bits, valid_bits_offset);
+          buffer, numValues, nullCount, validBits, validBitsOffset);
     } else {
-      return Decode(buffer, num_values);
+      return decode(buffer, numValues);
     }
   }
 
-  /// \brief Decode into an ArrayBuilder or other accumulator
+  /// \brief Decode into an ArrayBuilder or other accumulator.
   ///
-  /// This function assumes the definition levels were already decoded
-  /// as a validity bitmap in the given `valid_bits`.  `null_count`
+  /// This function assumes the definition levels were already decoded.
+  /// As a validity bitmap in the given `valid_bits`.  `null_count`
   /// is the number of 0s in `valid_bits`.
   /// As a space optimization, it is allowed for `valid_bits` to be null
   /// if `null_count` is zero.
   ///
-  /// \return number of values decoded
-  virtual int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  /// \return Number of values decoded.
+  virtual int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<DType>::Accumulator* out) = 0;
 
-  /// \brief Decode into an ArrayBuilder or other accumulator ignoring nulls
+  /// \brief Decode into an ArrayBuilder or other accumulator ignoring nulls.
   ///
-  /// \return number of values decoded
-  int DecodeArrowNonNull(
-      int num_values,
+  /// \return Number of values decoded.
+  int decodeArrowNonNull(
+      int numValues,
       typename EncodingTraits<DType>::Accumulator* out) {
-    return DecodeArrow(num_values, 0, /*valid_bits=*/NULLPTR, 0, out);
+    return decodeArrow(numValues, 0, NULLPTR, 0, out);
   }
 
-  /// \brief Decode into a DictionaryBuilder
+  /// \brief Decode into a DictionaryBuilder.
   ///
-  /// This function assumes the definition levels were already decoded
-  /// as a validity bitmap in the given `valid_bits`.  `null_count`
+  /// This function assumes the definition levels were already decoded.
+  /// As a validity bitmap in the given `valid_bits`.  `null_count`
   /// is the number of 0s in `valid_bits`.
   /// As a space optimization, it is allowed for `valid_bits` to be null
   /// if `null_count` is zero.
   ///
-  /// \return number of values decoded
-  virtual int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      typename EncodingTraits<DType>::DictAccumulator* builder) = 0;
-
-  /// \brief Decode into a DictionaryBuilder ignoring nulls
+  /// \return Number of values decoded.
+  virtual int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      typename EncodingTraits<DType>::DictAccumulator* Builder) = 0;
+
+  /// \brief Decode into a DictionaryBuilder ignoring nulls.
   ///
-  /// \return number of values decoded
-  int DecodeArrowNonNull(
-      int num_values,
-      typename EncodingTraits<DType>::DictAccumulator* builder) {
-    return DecodeArrow(num_values, 0, /*valid_bits=*/NULLPTR, 0, builder);
+  /// \return Number of values decoded.
+  int decodeArrowNonNull(
+      int numValues,
+      typename EncodingTraits<DType>::DictAccumulator* Builder) {
+    return decodeArrow(numValues, 0, NULLPTR, 0, Builder);
   }
 };
 
 template <typename DType>
 class DictDecoder : virtual public TypedDecoder<DType> {
  public:
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
 
-  virtual void SetDict(TypedDecoder<DType>* dictionary) = 0;
+  virtual void setDict(TypedDecoder<DType>* dictionary) = 0;
 
   /// \brief Insert dictionary values into the Arrow dictionary builder's memo,
-  /// but do not append any indices
-  virtual void InsertDictionary(::arrow::ArrayBuilder* builder) = 0;
+  /// but do not append any indices.
+  virtual void insertDictionary(::arrow::ArrayBuilder* Builder) = 0;
 
   /// \brief Decode only dictionary indices and append to dictionary
   /// builder. The builder must have had the dictionary from this decoder
   /// inserted already.
   ///
   /// \warning Remember to reset the builder each time the dict decoder is
-  /// initialized with a new dictionary page
-  virtual int DecodeIndicesSpaced(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      ::arrow::ArrayBuilder* builder) = 0;
-
-  /// \brief Decode only dictionary indices (no nulls)
+  /// initialized with a new dictionary page.
+  virtual int decodeIndicesSpaced(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      ::arrow::ArrayBuilder* Builder) = 0;
+
+  /// \brief Decode only dictionary indices (no nulls).
   ///
   /// \warning Remember to reset the builder each time the dict decoder is
-  /// initialized with a new dictionary page
-  virtual int DecodeIndices(int num_values, ::arrow::ArrayBuilder* builder) = 0;
+  /// initialized with a new dictionary page.
+  virtual int decodeIndices(int numValues, ::arrow::ArrayBuilder* Builder) = 0;
 
   /// \brief Decode only dictionary indices (no nulls). Same as above
-  /// DecodeIndices but target is an array instead of a builder.
+  /// decodeIndices but target is an array instead of a builder.
   ///
-  /// \note API EXPERIMENTAL
-  virtual int DecodeIndices(int num_values, int32_t* indices) = 0;
+  /// \note API EXPERIMENTAL.
+  virtual int decodeIndices(int numValues, int32_t* indices) = 0;
 
   /// \brief Get dictionary. The reader will call this API when it encounters a
   /// new dictionary.
@@ -408,62 +408,62 @@ class DictDecoder : virtual public TypedDecoder<DType> {
   /// owned by the decoder and is destroyed when the decoder is destroyed.
   /// @param[out] dictionary_length The dictionary length.
   ///
-  /// \note API EXPERIMENTAL
-  virtual void GetDictionary(
+  /// \note API EXPERIMENTAL.
+  virtual void getDictionary(
       const T** dictionary,
-      int32_t* dictionary_length) = 0;
+      int32_t* dictionaryLength) = 0;
 };
 
-// ----------------------------------------------------------------------
-// TypedEncoder specializations, traits, and factory functions
+// ----------------------------------------------------------------------.
+// TypedEncoder specializations, traits, and factory functions.
 
 class BooleanDecoder : virtual public TypedDecoder<BooleanType> {
  public:
-  using TypedDecoder<BooleanType>::Decode;
+  using TypedDecoder<BooleanType>::decode;
 
-  /// \brief Decode and bit-pack values into a buffer
+  /// \brief Decode and bit-pack values into a buffer.
   ///
-  /// \param[in] buffer destination for decoded values
+  /// \param[in] buffer Destination for decoded values.
   /// This buffer will contain bit-packed values.
-  /// \param[in] max_values max values to decode.
+  /// \param[in] max_values Max values to decode.
   /// \return The number of values decoded. Should be identical to max_values
   /// except at the end of the current data page.
-  virtual int Decode(uint8_t* buffer, int max_values) = 0;
+  virtual int decode(uint8_t* buffer, int maxValues) = 0;
 };
 
 class FLBADecoder : virtual public TypedDecoder<FLBAType> {
  public:
-  using TypedDecoder<FLBAType>::DecodeSpaced;
+  using TypedDecoder<FLBAType>::decodeSpaced;
 
   // TODO(wesm): As possible follow-up to PARQUET-1508, we should examine if
   // there is value in adding specialized read methods for
   // FIXED_LEN_BYTE_ARRAY. If only Decimal data can occur with this data type
-  // then perhaps not
+  // then perhaps not.
 };
 
 PARQUET_EXPORT
-std::unique_ptr<Encoder> MakeEncoder(
-    Type::type type_num,
+std::unique_ptr<Encoder> makeEncoder(
+    Type::type typeNum,
     Encoding::type encoding,
-    bool use_dictionary = false,
+    bool useDictionary = false,
     const ColumnDescriptor* descr = NULLPTR,
     ::arrow::MemoryPool* pool = ::arrow::default_memory_pool());
 
 template <typename DType>
-std::unique_ptr<typename EncodingTraits<DType>::Encoder> MakeTypedEncoder(
+std::unique_ptr<typename EncodingTraits<DType>::Encoder> makeTypedEncoder(
     Encoding::type encoding,
-    bool use_dictionary = false,
+    bool useDictionary = false,
     const ColumnDescriptor* descr = NULLPTR,
     ::arrow::MemoryPool* pool = ::arrow::default_memory_pool()) {
   using OutType = typename EncodingTraits<DType>::Encoder;
   std::unique_ptr<Encoder> base =
-      MakeEncoder(DType::type_num, encoding, use_dictionary, descr, pool);
+      makeEncoder(DType::typeNum, encoding, useDictionary, descr, pool);
   return std::unique_ptr<OutType>(dynamic_cast<OutType*>(base.release()));
 }
 
 PARQUET_EXPORT
-std::unique_ptr<Decoder> MakeDecoder(
-    Type::type type_num,
+std::unique_ptr<Decoder> makeDecoder(
+    Type::type typeNum,
     Encoding::type encoding,
     const ColumnDescriptor* descr = NULLPTR,
     ::arrow::MemoryPool* pool = ::arrow::default_memory_pool());
@@ -471,30 +471,30 @@ std::unique_ptr<Decoder> MakeDecoder(
 namespace detail {
 
 PARQUET_EXPORT
-std::unique_ptr<Decoder> MakeDictDecoder(
-    Type::type type_num,
+std::unique_ptr<Decoder> makeDictDecoder(
+    Type::type typeNum,
     const ColumnDescriptor* descr,
     ::arrow::MemoryPool* pool);
 
 } // namespace detail
 
 template <typename DType>
-std::unique_ptr<DictDecoder<DType>> MakeDictDecoder(
+std::unique_ptr<DictDecoder<DType>> makeDictDecoder(
     const ColumnDescriptor* descr = NULLPTR,
     ::arrow::MemoryPool* pool = ::arrow::default_memory_pool()) {
   using OutType = DictDecoder<DType>;
-  auto decoder = detail::MakeDictDecoder(DType::type_num, descr, pool);
+  auto decoder = detail::makeDictDecoder(DType::typeNum, descr, pool);
   return std::unique_ptr<OutType>(dynamic_cast<OutType*>(decoder.release()));
 }
 
 template <typename DType>
-std::unique_ptr<typename EncodingTraits<DType>::Decoder> MakeTypedDecoder(
+std::unique_ptr<typename EncodingTraits<DType>::Decoder> makeTypedDecoder(
     Encoding::type encoding,
     const ColumnDescriptor* descr = NULLPTR,
     ::arrow::MemoryPool* pool = ::arrow::default_memory_pool()) {
   using OutType = typename EncodingTraits<DType>::Decoder;
   std::unique_ptr<Decoder> base =
-      MakeDecoder(DType::type_num, encoding, descr, pool);
+      makeDecoder(DType::typeNum, encoding, descr, pool);
   return std::unique_ptr<OutType>(dynamic_cast<OutType*>(base.release()));
 }
 
diff --git a/velox/dwio/parquet/writer/arrow/Encryption.cpp b/velox/dwio/parquet/writer/arrow/Encryption.cpp
index 2aaa06f680e..984ec118416 100644
--- a/velox/dwio/parquet/writer/arrow/Encryption.cpp
+++ b/velox/dwio/parquet/writer/arrow/Encryption.cpp
@@ -30,159 +30,159 @@
 
 namespace facebook::velox::parquet::arrow {
 
-// integer key retriever
-void IntegerKeyIdRetriever::PutKey(uint32_t key_id, const std::string& key) {
-  key_map_.insert({key_id, key});
+// Integer key retriever.
+void IntegerKeyIdRetriever::putKey(uint32_t keyId, const std::string& key) {
+  keyMap_.insert({keyId, key});
 }
 
-std::string IntegerKeyIdRetriever::GetKey(const std::string& key_metadata) {
-  uint32_t key_id;
-  memcpy(reinterpret_cast<uint8_t*>(&key_id), key_metadata.c_str(), 4);
+std::string IntegerKeyIdRetriever::getKey(const std::string& keyMetadata) {
+  uint32_t keyId;
+  memcpy(reinterpret_cast<uint8_t*>(&keyId), keyMetadata.c_str(), 4);
 
-  return key_map_.at(key_id);
+  return keyMap_.at(keyId);
 }
 
-// string key retriever
-void StringKeyIdRetriever::PutKey(
-    const std::string& key_id,
+// String key retriever.
+void StringKeyIdRetriever::putKey(
+    const std::string& keyId,
     const std::string& key) {
-  key_map_.insert({key_id, key});
+  keyMap_.insert({keyId, key});
 }
 
-std::string StringKeyIdRetriever::GetKey(const std::string& key_id) {
-  return key_map_.at(key_id);
+std::string StringKeyIdRetriever::getKey(const std::string& keyId) {
+  return keyMap_.at(keyId);
 }
 
 ColumnEncryptionProperties::Builder* ColumnEncryptionProperties::Builder::key(
-    std::string column_key) {
-  if (column_key.empty())
+    std::string columnKey) {
+  if (columnKey.empty())
     return this;
 
   VELOX_DCHECK(key_.empty());
-  key_ = column_key;
+  key_ = columnKey;
   return this;
 }
 
 ColumnEncryptionProperties::Builder*
-ColumnEncryptionProperties::Builder::key_metadata(
-    const std::string& key_metadata) {
-  VELOX_DCHECK(!key_metadata.empty());
-  VELOX_DCHECK(key_metadata_.empty());
-  key_metadata_ = key_metadata;
+ColumnEncryptionProperties::Builder::keyMetadata(
+    const std::string& keyMetadata) {
+  VELOX_DCHECK(!keyMetadata.empty());
+  VELOX_DCHECK(keyMetadata_.empty());
+  keyMetadata_ = keyMetadata;
   return this;
 }
 
-ColumnEncryptionProperties::Builder*
-ColumnEncryptionProperties::Builder::key_id(const std::string& key_id) {
-  // key_id is expected to be in UTF8 encoding
+ColumnEncryptionProperties::Builder* ColumnEncryptionProperties::Builder::keyId(
+    const std::string& keyId) {
+  // Key_id is expected to be in UTF8 encoding.
   ::arrow::util::InitializeUTF8();
-  const uint8_t* data = reinterpret_cast<const uint8_t*>(key_id.c_str());
-  if (!::arrow::util::ValidateUTF8(data, key_id.size())) {
+  const uint8_t* data = reinterpret_cast<const uint8_t*>(keyId.c_str());
+  if (!::arrow::util::ValidateUTF8(data, keyId.size())) {
     throw ParquetException("key id should be in UTF8 encoding");
   }
 
-  VELOX_DCHECK(!key_id.empty());
-  this->key_metadata(key_id);
+  VELOX_DCHECK(!keyId.empty());
+  this->keyMetadata(keyId);
   return this;
 }
 
 FileDecryptionProperties::Builder*
-FileDecryptionProperties::Builder::column_keys(
-    const ColumnPathToDecryptionPropertiesMap& column_decryption_properties) {
-  if (column_decryption_properties.size() == 0)
+FileDecryptionProperties::Builder::columnKeys(
+    const ColumnPathToDecryptionPropertiesMap& ColumnDecryptionProperties) {
+  if (ColumnDecryptionProperties.size() == 0)
     return this;
 
-  if (column_decryption_properties_.size() != 0)
+  if (columnDecryptionProperties_.size() != 0)
     throw ParquetException("Column properties already set");
 
-  for (const auto& element : column_decryption_properties) {
-    if (element.second->is_utilized()) {
+  for (const auto& element : ColumnDecryptionProperties) {
+    if (element.second->isUtilized()) {
       throw ParquetException("Column properties utilized in another file");
     }
-    element.second->set_utilized();
+    element.second->setUtilized();
   }
 
-  column_decryption_properties_ = column_decryption_properties;
+  columnDecryptionProperties_ = ColumnDecryptionProperties;
   return this;
 }
 
-void FileDecryptionProperties::WipeOutDecryptionKeys() {
-  footer_key_.clear();
+void FileDecryptionProperties::wipeOutDecryptionKeys() {
+  footerKey_.clear();
 
-  for (const auto& element : column_decryption_properties_) {
-    element.second->WipeOutDecryptionKey();
+  for (const auto& element : columnDecryptionProperties_) {
+    element.second->wipeOutDecryptionKey();
   }
 }
 
-bool FileDecryptionProperties::is_utilized() {
-  if (footer_key_.empty() && column_decryption_properties_.size() == 0 &&
-      aad_prefix_.empty())
+bool FileDecryptionProperties::isUtilized() {
+  if (footerKey_.empty() && columnDecryptionProperties_.size() == 0 &&
+      aadPrefix_.empty())
     return false;
 
   return utilized_;
 }
 
-std::shared_ptr<FileDecryptionProperties> FileDecryptionProperties::DeepClone(
-    std::string new_aad_prefix) {
-  std::string footer_key_copy = footer_key_;
-  ColumnPathToDecryptionPropertiesMap column_decryption_properties_map_copy;
+std::shared_ptr<FileDecryptionProperties> FileDecryptionProperties::deepClone(
+    std::string newAadPrefix) {
+  std::string footerKeyCopy = footerKey_;
+  ColumnPathToDecryptionPropertiesMap columnDecryptionPropertiesMapCopy;
 
-  for (const auto& element : column_decryption_properties_) {
-    column_decryption_properties_map_copy.insert(
-        {element.second->column_path(), element.second->DeepClone()});
+  for (const auto& element : columnDecryptionProperties_) {
+    columnDecryptionPropertiesMapCopy.insert(
+        {element.second->columnPath(), element.second->deepClone()});
   }
 
-  if (new_aad_prefix.empty())
-    new_aad_prefix = aad_prefix_;
+  if (newAadPrefix.empty())
+    newAadPrefix = aadPrefix_;
   return std::shared_ptr<FileDecryptionProperties>(new FileDecryptionProperties(
-      footer_key_copy,
-      key_retriever_,
-      check_plaintext_footer_integrity_,
-      new_aad_prefix,
-      aad_prefix_verifier_,
-      column_decryption_properties_map_copy,
-      plaintext_files_allowed_));
-}
-
-FileDecryptionProperties::Builder*
-FileDecryptionProperties::Builder::footer_key(const std::string footer_key) {
-  if (footer_key.empty()) {
+      footerKeyCopy,
+      keyRetriever_,
+      checkPlaintextFooterIntegrity_,
+      newAadPrefix,
+      aadPrefixVerifier_,
+      columnDecryptionPropertiesMapCopy,
+      plaintextFilesAllowed_));
+}
+
+FileDecryptionProperties::Builder* FileDecryptionProperties::Builder::footerKey(
+    const std::string footerKey) {
+  if (footerKey.empty()) {
     return this;
   }
-  VELOX_DCHECK(footer_key_.empty());
-  footer_key_ = footer_key;
+  VELOX_DCHECK(footerKey_.empty());
+  footerKey_ = footerKey;
   return this;
 }
 
 FileDecryptionProperties::Builder*
-FileDecryptionProperties::Builder::key_retriever(
-    const std::shared_ptr<DecryptionKeyRetriever>& key_retriever) {
-  if (key_retriever == nullptr)
+FileDecryptionProperties::Builder::keyRetriever(
+    const std::shared_ptr<DecryptionKeyRetriever>& keyRetriever) {
+  if (keyRetriever == nullptr)
     return this;
 
-  VELOX_DCHECK_NULL(key_retriever_);
-  key_retriever_ = key_retriever;
+  VELOX_DCHECK_NULL(keyRetriever_);
+  keyRetriever_ = keyRetriever;
   return this;
 }
 
-FileDecryptionProperties::Builder*
-FileDecryptionProperties::Builder::aad_prefix(const std::string& aad_prefix) {
-  if (aad_prefix.empty()) {
+FileDecryptionProperties::Builder* FileDecryptionProperties::Builder::aadPrefix(
+    const std::string& aadPrefix) {
+  if (aadPrefix.empty()) {
     return this;
   }
-  VELOX_DCHECK(aad_prefix_.empty());
-  aad_prefix_ = aad_prefix;
+  VELOX_DCHECK(aadPrefix_.empty());
+  aadPrefix_ = aadPrefix;
   return this;
 }
 
 FileDecryptionProperties::Builder*
-FileDecryptionProperties::Builder::aad_prefix_verifier(
-    std::shared_ptr<AADPrefixVerifier> aad_prefix_verifier) {
-  if (aad_prefix_verifier == nullptr)
+FileDecryptionProperties::Builder::aadPrefixVerifier(
+    std::shared_ptr<AADPrefixVerifier> aadPrefixVerifier) {
+  if (aadPrefixVerifier == nullptr)
     return this;
 
-  VELOX_DCHECK_NULL(aad_prefix_verifier_);
-  aad_prefix_verifier_ = std::move(aad_prefix_verifier);
+  VELOX_DCHECK_NULL(aadPrefixVerifier_);
+  aadPrefixVerifier_ = std::move(aadPrefixVerifier);
   return this;
 }
 
@@ -199,112 +199,112 @@ ColumnDecryptionProperties::Builder* ColumnDecryptionProperties::Builder::key(
 std::shared_ptr<ColumnDecryptionProperties>
 ColumnDecryptionProperties::Builder::build() {
   return std::shared_ptr<ColumnDecryptionProperties>(
-      new ColumnDecryptionProperties(column_path_, key_));
+      new ColumnDecryptionProperties(columnPath_, key_));
 }
 
-void ColumnDecryptionProperties::WipeOutDecryptionKey() {
+void ColumnDecryptionProperties::wipeOutDecryptionKey() {
   key_.clear();
 }
 
 std::shared_ptr<ColumnDecryptionProperties>
-ColumnDecryptionProperties::DeepClone() {
-  std::string key_copy = key_;
+ColumnDecryptionProperties::deepClone() {
+  std::string keyCopy = key_;
   return std::shared_ptr<ColumnDecryptionProperties>(
-      new ColumnDecryptionProperties(column_path_, key_copy));
+      new ColumnDecryptionProperties(columnPath_, keyCopy));
 }
 
 FileEncryptionProperties::Builder*
-FileEncryptionProperties::Builder::footer_key_metadata(
-    const std::string& footer_key_metadata) {
-  if (footer_key_metadata.empty())
+FileEncryptionProperties::Builder::footerKeyMetadata(
+    const std::string& footerKeyMetadata) {
+  if (footerKeyMetadata.empty())
     return this;
 
-  VELOX_DCHECK(footer_key_metadata_.empty());
-  footer_key_metadata_ = footer_key_metadata;
+  VELOX_DCHECK(footerKeyMetadata_.empty());
+  footerKeyMetadata_ = footerKeyMetadata;
   return this;
 }
 
 FileEncryptionProperties::Builder*
-FileEncryptionProperties::Builder::encrypted_columns(
-    const ColumnPathToEncryptionPropertiesMap& encrypted_columns) {
-  if (encrypted_columns.size() == 0)
+FileEncryptionProperties::Builder::encryptedColumns(
+    const ColumnPathToEncryptionPropertiesMap& encryptedColumns) {
+  if (encryptedColumns.size() == 0)
     return this;
 
-  if (encrypted_columns_.size() != 0)
+  if (encryptedColumns_.size() != 0)
     throw ParquetException("Column properties already set");
 
-  for (const auto& element : encrypted_columns) {
-    if (element.second->is_utilized()) {
+  for (const auto& element : encryptedColumns) {
+    if (element.second->isUtilized()) {
       throw ParquetException("Column properties utilized in another file");
     }
-    element.second->set_utilized();
+    element.second->setUtilized();
   }
-  encrypted_columns_ = encrypted_columns;
+  encryptedColumns_ = encryptedColumns;
   return this;
 }
 
-void FileEncryptionProperties::WipeOutEncryptionKeys() {
-  footer_key_.clear();
-  for (const auto& element : encrypted_columns_) {
-    element.second->WipeOutEncryptionKey();
+void FileEncryptionProperties::wipeOutEncryptionKeys() {
+  footerKey_.clear();
+  for (const auto& element : encryptedColumns_) {
+    element.second->wipeOutEncryptionKey();
   }
 }
 
-std::shared_ptr<FileEncryptionProperties> FileEncryptionProperties::DeepClone(
-    std::string new_aad_prefix) {
-  std::string footer_key_copy = footer_key_;
-  ColumnPathToEncryptionPropertiesMap encrypted_columns_map_copy;
+std::shared_ptr<FileEncryptionProperties> FileEncryptionProperties::deepClone(
+    std::string newAadPrefix) {
+  std::string footerKeyCopy = footerKey_;
+  ColumnPathToEncryptionPropertiesMap encryptedColumnsMapCopy;
 
-  for (const auto& element : encrypted_columns_) {
-    encrypted_columns_map_copy.insert(
-        {element.second->column_path(), element.second->DeepClone()});
+  for (const auto& element : encryptedColumns_) {
+    encryptedColumnsMapCopy.insert(
+        {element.second->columnPath(), element.second->deepClone()});
   }
 
-  if (new_aad_prefix.empty())
-    new_aad_prefix = aad_prefix_;
+  if (newAadPrefix.empty())
+    newAadPrefix = aadPrefix_;
   return std::shared_ptr<FileEncryptionProperties>(new FileEncryptionProperties(
       algorithm_.algorithm,
-      footer_key_copy,
-      footer_key_metadata_,
-      encrypted_footer_,
-      new_aad_prefix,
-      store_aad_prefix_in_file_,
-      encrypted_columns_map_copy));
+      footerKeyCopy,
+      footerKeyMetadata_,
+      encryptedFooter_,
+      newAadPrefix,
+      storeAadPrefixInFile_,
+      encryptedColumnsMapCopy));
 }
 
-FileEncryptionProperties::Builder*
-FileEncryptionProperties::Builder::aad_prefix(const std::string& aad_prefix) {
-  if (aad_prefix.empty())
+FileEncryptionProperties::Builder* FileEncryptionProperties::Builder::aadPrefix(
+    const std::string& aadPrefix) {
+  if (aadPrefix.empty())
     return this;
 
-  VELOX_DCHECK(aad_prefix_.empty());
-  aad_prefix_ = aad_prefix;
-  store_aad_prefix_in_file_ = true;
+  VELOX_DCHECK(aadPrefix_.empty());
+  aadPrefix_ = aadPrefix;
+  storeAadPrefixInFile_ = true;
   return this;
 }
 
 FileEncryptionProperties::Builder*
-FileEncryptionProperties::Builder::disable_aad_prefix_storage() {
-  VELOX_DCHECK(!aad_prefix_.empty());
+FileEncryptionProperties::Builder::disableAadPrefixStorage() {
+  VELOX_DCHECK(!aadPrefix_.empty());
 
-  store_aad_prefix_in_file_ = false;
+  storeAadPrefixInFile_ = false;
   return this;
 }
 
 ColumnEncryptionProperties::ColumnEncryptionProperties(
     bool encrypted,
-    const std::string& column_path,
+    const std::string& ColumnPath,
     const std::string& key,
-    const std::string& key_metadata)
-    : column_path_(column_path) {
-  // column encryption properties object (with a column key) can be used for
-  // writing only one file. Upon completion of file writing, the encryption keys
-  // in the properties will be wiped out (set to 0 in memory).
+    const std::string& keyMetadata)
+    : columnPath_(ColumnPath) {
+  // Column encryption properties object (with a column key) can be used for.
+  // Writing only one file. Upon completion of file writing, the encryption
+  // keys. In the properties will be wiped out (set to 0 in memory).
   utilized_ = false;
 
-  VELOX_DCHECK(!column_path.empty());
+  VELOX_DCHECK(!ColumnPath.empty());
   if (!encrypted) {
-    VELOX_DCHECK(key.empty() && key_metadata.empty());
+    VELOX_DCHECK(key.empty() && keyMetadata.empty());
   }
 
   if (!key.empty()) {
@@ -312,22 +312,22 @@ ColumnEncryptionProperties::ColumnEncryptionProperties(
         key.length() == 16 || key.length() == 24 || key.length() == 32);
   }
 
-  encrypted_with_footer_key_ = (encrypted && key.empty());
-  if (encrypted_with_footer_key_) {
-    VELOX_DCHECK(key_metadata.empty());
+  encryptedWithFooterKey_ = (encrypted && key.empty());
+  if (encryptedWithFooterKey_) {
+    VELOX_DCHECK(keyMetadata.empty());
   }
 
   encrypted_ = encrypted;
-  key_metadata_ = key_metadata;
+  keyMetadata_ = keyMetadata;
   key_ = key;
 }
 
 ColumnDecryptionProperties::ColumnDecryptionProperties(
-    const std::string& column_path,
+    const std::string& ColumnPath,
     const std::string& key)
-    : column_path_(column_path) {
+    : columnPath_(ColumnPath) {
   utilized_ = false;
-  VELOX_DCHECK(!column_path.empty());
+  VELOX_DCHECK(!ColumnPath.empty());
 
   if (!key.empty()) {
     VELOX_DCHECK(
@@ -337,74 +337,74 @@ ColumnDecryptionProperties::ColumnDecryptionProperties(
   key_ = key;
 }
 
-std::string FileDecryptionProperties::column_key(
-    const std::string& column_path) const {
-  if (column_decryption_properties_.find(column_path) !=
-      column_decryption_properties_.end()) {
-    auto column_prop = column_decryption_properties_.at(column_path);
-    if (column_prop != nullptr) {
-      return column_prop->key();
+std::string FileDecryptionProperties::columnKey(
+    const std::string& ColumnPath) const {
+  if (columnDecryptionProperties_.find(ColumnPath) !=
+      columnDecryptionProperties_.end()) {
+    auto columnProp = columnDecryptionProperties_.at(ColumnPath);
+    if (columnProp != nullptr) {
+      return columnProp->key();
     }
   }
-  return empty_string_;
+  return emptyString_;
 }
 
 FileDecryptionProperties::FileDecryptionProperties(
-    const std::string& footer_key,
-    std::shared_ptr<DecryptionKeyRetriever> key_retriever,
-    bool check_plaintext_footer_integrity,
-    const std::string& aad_prefix,
-    std::shared_ptr<AADPrefixVerifier> aad_prefix_verifier,
-    const ColumnPathToDecryptionPropertiesMap& column_decryption_properties,
-    bool plaintext_files_allowed) {
+    const std::string& footerKey,
+    std::shared_ptr<DecryptionKeyRetriever> keyRetriever,
+    bool checkPlaintextFooterIntegrity,
+    const std::string& aadPrefix,
+    std::shared_ptr<AADPrefixVerifier> aadPrefixVerifier,
+    const ColumnPathToDecryptionPropertiesMap& ColumnDecryptionProperties,
+    bool plaintextFilesAllowed) {
   VELOX_DCHECK(
-      !footer_key.empty() || nullptr != key_retriever ||
-      0 != column_decryption_properties.size());
+      !footerKey.empty() || nullptr != keyRetriever ||
+      0 != ColumnDecryptionProperties.size());
 
-  if (!footer_key.empty()) {
+  if (!footerKey.empty()) {
     VELOX_DCHECK(
-        footer_key.length() == 16 || footer_key.length() == 24 ||
-        footer_key.length() == 32);
+        footerKey.length() == 16 || footerKey.length() == 24 ||
+        footerKey.length() == 32);
   }
-  if (footer_key.empty() && check_plaintext_footer_integrity) {
-    VELOX_DCHECK_NOT_NULL(key_retriever);
+  if (footerKey.empty() && checkPlaintextFooterIntegrity) {
+    VELOX_DCHECK_NOT_NULL(keyRetriever);
   }
-  aad_prefix_verifier_ = std::move(aad_prefix_verifier);
-  footer_key_ = footer_key;
-  check_plaintext_footer_integrity_ = check_plaintext_footer_integrity;
-  key_retriever_ = std::move(key_retriever);
-  aad_prefix_ = aad_prefix;
-  column_decryption_properties_ = column_decryption_properties;
-  plaintext_files_allowed_ = plaintext_files_allowed;
+  aadPrefixVerifier_ = std::move(aadPrefixVerifier);
+  footerKey_ = footerKey;
+  checkPlaintextFooterIntegrity_ = checkPlaintextFooterIntegrity;
+  keyRetriever_ = std::move(keyRetriever);
+  aadPrefix_ = aadPrefix;
+  columnDecryptionProperties_ = ColumnDecryptionProperties;
+  plaintextFilesAllowed_ = plaintextFilesAllowed;
   utilized_ = false;
 }
 
 FileEncryptionProperties::Builder*
-FileEncryptionProperties::Builder::footer_key_id(const std::string& key_id) {
-  // key_id is expected to be in UTF8 encoding
+FileEncryptionProperties::Builder::footerKeyId(const std::string& keyId) {
+  // Key_id is expected to be in UTF8 encoding.
   ::arrow::util::InitializeUTF8();
-  const uint8_t* data = reinterpret_cast<const uint8_t*>(key_id.c_str());
-  if (!::arrow::util::ValidateUTF8(data, key_id.size())) {
+  const uint8_t* data = reinterpret_cast<const uint8_t*>(keyId.c_str());
+  if (!::arrow::util::ValidateUTF8(data, keyId.size())) {
     throw ParquetException("footer key id should be in UTF8 encoding");
   }
 
-  if (key_id.empty()) {
+  if (keyId.empty()) {
     return this;
   }
 
-  return footer_key_metadata(key_id);
+  return footerKeyMetadata(keyId);
 }
 
 std::shared_ptr<ColumnEncryptionProperties>
-FileEncryptionProperties::column_encryption_properties(
-    const std::string& column_path) {
-  if (encrypted_columns_.size() == 0) {
+FileEncryptionProperties::columnEncryptionProperties(
+    const std::string& columnPath) {
+  if (encryptedColumns_.empty()) {
     auto builder =
-        std::make_shared<ColumnEncryptionProperties::Builder>(column_path);
+        std::make_shared<ColumnEncryptionProperties::Builder>(columnPath);
     return builder->build();
   }
-  if (encrypted_columns_.find(column_path) != encrypted_columns_.end()) {
-    return encrypted_columns_[column_path];
+  if (encryptedColumns_.find(columnPath) != encryptedColumns_.end()) {
+    return encryptedColumns_[columnPath];
   }
 
   return nullptr;
@@ -412,47 +412,47 @@ FileEncryptionProperties::column_encryption_properties(
 
 FileEncryptionProperties::FileEncryptionProperties(
     ParquetCipher::type cipher,
-    const std::string& footer_key,
-    const std::string& footer_key_metadata,
-    bool encrypted_footer,
-    const std::string& aad_prefix,
-    bool store_aad_prefix_in_file,
-    const ColumnPathToEncryptionPropertiesMap& encrypted_columns)
-    : footer_key_(footer_key),
-      footer_key_metadata_(footer_key_metadata),
-      encrypted_footer_(encrypted_footer),
-      aad_prefix_(aad_prefix),
-      store_aad_prefix_in_file_(store_aad_prefix_in_file),
-      encrypted_columns_(encrypted_columns) {
-  // file encryption properties object can be used for writing only one file.
-  // Upon completion of file writing, the encryption keys in the properties will
-  // be wiped out (set to 0 in memory).
+    const std::string& footerKey,
+    const std::string& footerKeyMetadata,
+    bool encryptedFooter,
+    const std::string& aadPrefix,
+    bool storeAadPrefixInFile,
+    const ColumnPathToEncryptionPropertiesMap& encryptedColumns)
+    : footerKey_(footerKey),
+      footerKeyMetadata_(footerKeyMetadata),
+      encryptedFooter_(encryptedFooter),
+      aadPrefix_(aadPrefix),
+      storeAadPrefixInFile_(storeAadPrefixInFile),
+      encryptedColumns_(encryptedColumns) {
+  // File encryption properties object can be used for writing only one file.
+  // Upon completion of file writing, the encryption keys in the properties
+  // will. Be wiped out (set to 0 in memory).
   utilized_ = false;
 
-  VELOX_DCHECK(!footer_key.empty());
-  // footer_key must be either 16, 24 or 32 bytes.
+  VELOX_DCHECK(!footerKey.empty());
+  // Footer_key must be either 16, 24 or 32 bytes.
   VELOX_DCHECK(
-      footer_key.length() == 16 || footer_key.length() == 24 ||
-      footer_key.length() == 32);
+      footerKey.length() == 16 || footerKey.length() == 24 ||
+      footerKey.length() == 32);
 
-  uint8_t aad_file_unique[kAadFileUniqueLength];
-  encryption::RandBytes(aad_file_unique, kAadFileUniqueLength);
-  std::string aad_file_unique_str(
-      reinterpret_cast<char const*>(aad_file_unique), kAadFileUniqueLength);
+  uint8_t aadFileUnique[kAadFileUniqueLength];
+  encryption::randBytes(aadFileUnique, kAadFileUniqueLength);
+  std::string aadFileUniqueStr(
+      reinterpret_cast<char const*>(aadFileUnique), kAadFileUniqueLength);
 
-  bool supply_aad_prefix = false;
-  if (aad_prefix.empty()) {
-    file_aad_ = aad_file_unique_str;
+  bool supplyAadPrefix = false;
+  if (aadPrefix.empty()) {
+    fileAad_ = aadFileUniqueStr;
   } else {
-    file_aad_ = aad_prefix + aad_file_unique_str;
-    if (!store_aad_prefix_in_file)
-      supply_aad_prefix = true;
+    fileAad_ = aadPrefix + aadFileUniqueStr;
+    if (!storeAadPrefixInFile)
+      supplyAadPrefix = true;
   }
   algorithm_.algorithm = cipher;
-  algorithm_.aad.aad_file_unique = aad_file_unique_str;
-  algorithm_.aad.supply_aad_prefix = supply_aad_prefix;
-  if (!aad_prefix.empty() && store_aad_prefix_in_file) {
-    algorithm_.aad.aad_prefix = aad_prefix;
+  algorithm_.aad.aadFileUnique = aadFileUniqueStr;
+  algorithm_.aad.supplyAadPrefix = supplyAadPrefix;
+  if (!aadPrefix.empty() && storeAadPrefixInFile) {
+    algorithm_.aad.aadPrefix = aadPrefix;
   }
 }
 
diff --git a/velox/dwio/parquet/writer/arrow/Encryption.h b/velox/dwio/parquet/writer/arrow/Encryption.h
index df310589a43..1979f189fea 100644
--- a/velox/dwio/parquet/writer/arrow/Encryption.h
+++ b/velox/dwio/parquet/writer/arrow/Encryption.h
@@ -30,7 +30,7 @@
 namespace facebook::velox::parquet::arrow {
 
 static constexpr ParquetCipher::type kDefaultEncryptionAlgorithm =
-    ParquetCipher::AES_GCM_V1;
+    ParquetCipher::kAesGcmV1;
 static constexpr int32_t kMaximalAadMetadataLength = 256;
 static constexpr bool kDefaultEncryptedFooter = true;
 static constexpr bool kDefaultCheckSignature = true;
@@ -47,28 +47,28 @@ using ColumnPathToEncryptionPropertiesMap =
 
 class PARQUET_EXPORT DecryptionKeyRetriever {
  public:
-  virtual std::string GetKey(const std::string& key_metadata) = 0;
+  virtual std::string getKey(const std::string& keyMetadata) = 0;
   virtual ~DecryptionKeyRetriever() {}
 };
 
-/// Simple integer key retriever
+/// Simple integer key retriever.
 class PARQUET_EXPORT IntegerKeyIdRetriever : public DecryptionKeyRetriever {
  public:
-  void PutKey(uint32_t key_id, const std::string& key);
-  std::string GetKey(const std::string& key_metadata) override;
+  void putKey(uint32_t keyId, const std::string& key);
+  std::string getKey(const std::string& keyMetadata) override;
 
  private:
-  std::map<uint32_t, std::string> key_map_;
+  std::map<uint32_t, std::string> keyMap_;
 };
 
-// Simple string key retriever
+// Simple string key retriever.
 class PARQUET_EXPORT StringKeyIdRetriever : public DecryptionKeyRetriever {
  public:
-  void PutKey(const std::string& key_id, const std::string& key);
-  std::string GetKey(const std::string& key_metadata) override;
+  void putKey(const std::string& keyId, const std::string& key);
+  std::string getKey(const std::string& keyMetadata) override;
 
  private:
-  std::map<std::string, std::string> key_map_;
+  std::map<std::string, std::string> keyMap_;
 };
 
 class PARQUET_EXPORT HiddenColumnException : public ParquetException {
@@ -100,66 +100,66 @@ class PARQUET_EXPORT ColumnEncryptionProperties {
 
     /// Convenience builder for encrypted columns.
     explicit Builder(const std::shared_ptr<schema::ColumnPath>& path)
-        : Builder(path->ToDotString(), true) {}
+        : Builder(path->toDotString(), true) {}
 
     /// Set a column-specific key.
     /// If key is not set on an encrypted column, the column will
     /// be encrypted with the footer key.
-    /// keyBytes Key length must be either 16, 24 or 32 bytes.
+    /// KeyBytes Key length must be either 16, 24 or 32 bytes.
     /// The key is cloned, and will be wiped out (array values set to 0) upon
-    /// completion of file writing. Caller is responsible for wiping out the
+    /// completion of file writing. Caller is responsible for wiping out the.
     /// input key array.
-    Builder* key(std::string column_key);
+    Builder* key(std::string columnKey);
 
     /// Set a key retrieval metadata.
-    /// use either key_metadata() or key_id(), not both
-    Builder* key_metadata(const std::string& key_metadata);
+    /// Use either key_metadata() or key_id(), not both.
+    Builder* keyMetadata(const std::string& keyMetadata);
 
     /// A convenience function to set key metadata using a string id.
     /// Set a key retrieval metadata (converted from String).
-    /// use either key_metadata() or key_id(), not both
+    /// Use either key_metadata() or key_id(), not both.
     /// key_id will be converted to metadata (UTF-8 array).
-    Builder* key_id(const std::string& key_id);
+    Builder* keyId(const std::string& keyId);
 
     std::shared_ptr<ColumnEncryptionProperties> build() {
       return std::shared_ptr<ColumnEncryptionProperties>(
           new ColumnEncryptionProperties(
-              encrypted_, column_path_, key_, key_metadata_));
+              encrypted_, columnPath_, key_, keyMetadata_));
     }
 
    private:
-    const std::string column_path_;
+    const std::string columnPath_;
     bool encrypted_;
     std::string key_;
-    std::string key_metadata_;
+    std::string keyMetadata_;
 
     Builder(const std::string path, bool encrypted)
-        : column_path_(path), encrypted_(encrypted) {}
+        : columnPath_(path), encrypted_(encrypted) {}
   };
 
-  std::string column_path() const {
-    return column_path_;
+  std::string columnPath() const {
+    return columnPath_;
   }
-  bool is_encrypted() const {
+  bool isEncrypted() const {
     return encrypted_;
   }
-  bool is_encrypted_with_footer_key() const {
-    return encrypted_with_footer_key_;
+  bool isEncryptedWithFooterKey() const {
+    return encryptedWithFooterKey_;
   }
   std::string key() const {
     return key_;
   }
-  std::string key_metadata() const {
-    return key_metadata_;
+  std::string keyMetadata() const {
+    return keyMetadata_;
   }
 
   /// Upon completion of file writing, the encryption key
   /// will be wiped out.
-  void WipeOutEncryptionKey() {
+  void wipeOutEncryptionKey() {
     key_.clear();
   }
 
-  bool is_utilized() {
+  bool isUtilized() {
     if (key_.empty())
       return false; // can re-use column properties without encryption keys
     return utilized_;
@@ -169,15 +169,15 @@ class PARQUET_EXPORT ColumnEncryptionProperties {
   /// Mark ColumnEncryptionProperties as utilized once it is used in
   /// FileEncryptionProperties as the encryption key will be wiped out upon
   /// completion of file writing.
-  void set_utilized() {
+  void setUtilized() {
     utilized_ = true;
   }
 
-  std::shared_ptr<ColumnEncryptionProperties> DeepClone() {
-    std::string key_copy = key_;
+  std::shared_ptr<ColumnEncryptionProperties> deepClone() {
+    std::string keyCopy = key_;
     return std::shared_ptr<ColumnEncryptionProperties>(
         new ColumnEncryptionProperties(
-            encrypted_, column_path_, key_copy, key_metadata_));
+            encrypted_, columnPath_, keyCopy, keyMetadata_));
   }
 
   ColumnEncryptionProperties() = default;
@@ -185,38 +185,38 @@ class PARQUET_EXPORT ColumnEncryptionProperties {
   ColumnEncryptionProperties(ColumnEncryptionProperties&& other) = default;
 
  private:
-  const std::string column_path_;
+  const std::string columnPath_;
   bool encrypted_;
-  bool encrypted_with_footer_key_;
+  bool encryptedWithFooterKey_;
   std::string key_;
-  std::string key_metadata_;
+  std::string keyMetadata_;
   bool utilized_;
   explicit ColumnEncryptionProperties(
       bool encrypted,
-      const std::string& column_path,
+      const std::string& columnPath,
       const std::string& key,
-      const std::string& key_metadata);
+      const std::string& keyMetadata);
 };
 
 class PARQUET_EXPORT ColumnDecryptionProperties {
  public:
   class PARQUET_EXPORT Builder {
    public:
-    explicit Builder(const std::string& name) : column_path_(name) {}
+    explicit Builder(const std::string& name) : columnPath_(name) {}
 
     explicit Builder(const std::shared_ptr<schema::ColumnPath>& path)
-        : Builder(path->ToDotString()) {}
+        : Builder(path->toDotString()) {}
 
     /// Set an explicit column key. If applied on a file that contains
     /// key metadata for this column the metadata will be ignored,
-    /// the column will be decrypted with this key.
-    /// key length must be either 16, 24 or 32 bytes.
+    /// and the column will be decrypted with this key.
+    /// Key length must be either 16, 24 or 32 bytes.
     Builder* key(const std::string& key);
 
     std::shared_ptr<ColumnDecryptionProperties> build();
 
    private:
-    const std::string column_path_;
+    const std::string columnPath_;
     std::string key_;
   };
 
@@ -224,13 +224,13 @@ class PARQUET_EXPORT ColumnDecryptionProperties {
   ColumnDecryptionProperties(const ColumnDecryptionProperties& other) = default;
   ColumnDecryptionProperties(ColumnDecryptionProperties&& other) = default;
 
-  std::string column_path() const {
-    return column_path_;
+  std::string columnPath() const {
+    return columnPath_;
   }
   std::string key() const {
     return key_;
   }
-  bool is_utilized() {
+  bool isUtilized() {
     return utilized_;
   }
 
@@ -238,26 +238,26 @@ class PARQUET_EXPORT ColumnDecryptionProperties {
   /// Mark ColumnDecryptionProperties as utilized once it is used in
   /// FileDecryptionProperties as the encryption key will be wiped out upon
   /// completion of file reading.
-  void set_utilized() {
+  void setUtilized() {
     utilized_ = true;
   }
 
   /// Upon completion of file reading, the encryption key
   /// will be wiped out.
-  void WipeOutDecryptionKey();
+  void wipeOutDecryptionKey();
 
-  std::shared_ptr<ColumnDecryptionProperties> DeepClone();
+  std::shared_ptr<ColumnDecryptionProperties> deepClone();
 
  private:
-  const std::string column_path_;
+  const std::string columnPath_;
   std::string key_;
   bool utilized_;
 
-  /// This class is only required for setting explicit column decryption keys -
-  /// to override key retriever (or to provide keys when key metadata and/or
+  /// This class is only required for setting explicit column decryption keys -.
+  /// To override key retriever (or to provide keys when key metadata and/or.
   /// key retriever are not available)
   explicit ColumnDecryptionProperties(
-      const std::string& column_path,
+      const std::string& columnPath,
       const std::string& key);
 };
 
@@ -268,7 +268,7 @@ class PARQUET_EXPORT AADPrefixVerifier {
   /// Throws exception if an AAD prefix is wrong.
   /// In a data set, AAD Prefixes should be collected,
   /// and then checked for missing files.
-  virtual void Verify(const std::string& aad_prefix) = 0;
+  virtual void verify(const std::string& aadPrefix) = 0;
   virtual ~AADPrefixVerifier() {}
 };
 
@@ -277,8 +277,8 @@ class PARQUET_EXPORT FileDecryptionProperties {
   class PARQUET_EXPORT Builder {
    public:
     Builder() {
-      check_plaintext_footer_integrity_ = kDefaultCheckSignature;
-      plaintext_files_allowed_ = kDefaultAllowPlaintextFiles;
+      checkPlaintextFooterIntegrity_ = kDefaultCheckSignature;
+      plaintextFilesAllowed_ = kDefaultAllowPlaintextFiles;
     }
 
     /// Set an explicit footer key. If applied on a file that contains
@@ -287,297 +287,297 @@ class PARQUET_EXPORT FileDecryptionProperties {
     /// If explicit key is not set, footer key will be fetched from
     /// key retriever.
     /// With explicit keys or AAD prefix, new encryption properties object must
-    /// be created for each encrypted file. Explicit encryption keys (footer and
-    /// column) are cloned. Upon completion of file reading, the cloned
-    /// encryption keys in the properties will be wiped out (array values set to
-    /// 0). Caller is responsible for wiping out the input key array. param
+    /// be created for each encrypted file. Explicit encryption keys (footer
+    /// and column) are cloned. Upon completion of file reading, the cloned
+    /// encryption keys in the properties will be wiped out (array values set
+    /// to 0). Caller is responsible for wiping out the input key array. param
     /// footerKey Key length must be either 16, 24 or 32 bytes.
-    Builder* footer_key(const std::string footer_key);
+    Builder* footerKey(const std::string footerKey);
 
     /// Set explicit column keys (decryption properties).
     /// Its also possible to set a key retriever on this property object.
-    /// Upon file decryption, availability of explicit keys is checked before
+    /// Upon file decryption, availability of explicit keys is checked before.
     /// invocation of the retriever callback.
     /// If an explicit key is available for a footer or a column,
     /// its key metadata will be ignored.
-    Builder* column_keys(const ColumnPathToDecryptionPropertiesMap&
-                             column_decryption_properties);
+    Builder* columnKeys(
+        const ColumnPathToDecryptionPropertiesMap& columnDecryptionProperties);
 
-    /// Set a key retriever callback. Its also possible to
+    /// Set a key retrieval callback. It is also possible to
     /// set explicit footer or column keys on this file property object.
-    /// Upon file decryption, availability of explicit keys is checked before
+    /// Upon file decryption, availability of explicit keys is checked before.
     /// invocation of the retriever callback.
     /// If an explicit key is available for a footer or a column,
     /// its key metadata will be ignored.
-    Builder* key_retriever(
-        const std::shared_ptr<DecryptionKeyRetriever>& key_retriever);
+    Builder* keyRetriever(
+        const std::shared_ptr<DecryptionKeyRetriever>& keyRetriever);
 
     /// Skip integrity verification of plaintext footers.
-    /// If not called, integrity of plaintext footers will be checked in
+    /// If not called, integrity of plaintext footers will be checked in.
     /// runtime, and an exception will be thrown in the following situations:
-    /// - footer signing key is not available
-    /// (not passed, or not found by key retriever)
-    /// - footer content and signature don't match
-    Builder* disable_footer_signature_verification() {
-      check_plaintext_footer_integrity_ = false;
+    /// - Footer signing key is not available.
+    /// (not passed, or not found by key retriever).
+    /// - Footer content and signature don't match.
+    Builder* disableFooterSignatureVerification() {
+      checkPlaintextFooterIntegrity_ = false;
       return this;
     }
 
     /// Explicitly supply the file AAD prefix.
-    /// A must when a prefix is used for file encryption, but not stored in
-    /// file. If AAD prefix is stored in file, it will be compared to the
-    /// explicitly supplied value and an exception will be thrown if they
+    /// This is mandatory when a prefix is used for file encryption, but not
+    /// stored in file. If AAD prefix is stored in file, it will be compared to
+    /// the explicitly supplied value and an exception will be thrown if they
     /// differ.
-    Builder* aad_prefix(const std::string& aad_prefix);
+    Builder* aadPrefix(const std::string& aadPrefix);
 
     /// Set callback for verification of AAD Prefixes stored in file.
-    Builder* aad_prefix_verifier(
-        std::shared_ptr<AADPrefixVerifier> aad_prefix_verifier);
+    Builder* aadPrefixVerifier(
+        std::shared_ptr<AADPrefixVerifier> aadPrefixVerifier);
 
     /// By default, reading plaintext (unencrypted) files is not
-    /// allowed when using a decryptor
+    /// allowed when using a decryptor.
     /// - in order to detect files that were not encrypted by mistake.
     /// However, the default behavior can be overridden by calling this method.
-    /// The caller should use then a different method to ensure encryption
+    /// The caller should then use a different method to ensure encryption
     /// of files with sensitive data.
-    Builder* plaintext_files_allowed() {
-      plaintext_files_allowed_ = true;
+    Builder* plaintextFilesAllowed() {
+      plaintextFilesAllowed_ = true;
       return this;
     }
 
     std::shared_ptr<FileDecryptionProperties> build() {
       return std::shared_ptr<FileDecryptionProperties>(
           new FileDecryptionProperties(
-              footer_key_,
-              key_retriever_,
-              check_plaintext_footer_integrity_,
-              aad_prefix_,
-              aad_prefix_verifier_,
-              column_decryption_properties_,
-              plaintext_files_allowed_));
+              footerKey_,
+              keyRetriever_,
+              checkPlaintextFooterIntegrity_,
+              aadPrefix_,
+              aadPrefixVerifier_,
+              columnDecryptionProperties_,
+              plaintextFilesAllowed_));
     }
 
    private:
-    std::string footer_key_;
-    std::string aad_prefix_;
-    std::shared_ptr<AADPrefixVerifier> aad_prefix_verifier_;
-    ColumnPathToDecryptionPropertiesMap column_decryption_properties_;
-
-    std::shared_ptr<DecryptionKeyRetriever> key_retriever_;
-    bool check_plaintext_footer_integrity_;
-    bool plaintext_files_allowed_;
+    std::string footerKey_;
+    std::string aadPrefix_;
+    std::shared_ptr<AADPrefixVerifier> aadPrefixVerifier_;
+    ColumnPathToDecryptionPropertiesMap columnDecryptionProperties_;
+
+    std::shared_ptr<DecryptionKeyRetriever> keyRetriever_;
+    bool checkPlaintextFooterIntegrity_;
+    bool plaintextFilesAllowed_;
   };
 
-  std::string column_key(const std::string& column_path) const;
+  std::string columnKey(const std::string& columnPath) const;
 
-  std::string footer_key() const {
-    return footer_key_;
+  std::string footerKey() const {
+    return footerKey_;
   }
 
-  std::string aad_prefix() const {
-    return aad_prefix_;
+  std::string aadPrefix() const {
+    return aadPrefix_;
   }
 
-  const std::shared_ptr<DecryptionKeyRetriever>& key_retriever() const {
-    return key_retriever_;
+  const std::shared_ptr<DecryptionKeyRetriever>& keyRetriever() const {
+    return keyRetriever_;
   }
 
-  bool check_plaintext_footer_integrity() const {
-    return check_plaintext_footer_integrity_;
+  bool checkPlaintextFooterIntegrity() const {
+    return checkPlaintextFooterIntegrity_;
   }
 
-  bool plaintext_files_allowed() const {
-    return plaintext_files_allowed_;
+  bool plaintextFilesAllowed() const {
+    return plaintextFilesAllowed_;
   }
 
-  const std::shared_ptr<AADPrefixVerifier>& aad_prefix_verifier() const {
-    return aad_prefix_verifier_;
+  const std::shared_ptr<AADPrefixVerifier>& aadPrefixVerifier() const {
+    return aadPrefixVerifier_;
   }
 
   /// Upon completion of file reading, the encryption keys in the properties
   /// will be wiped out (array values set to 0).
-  void WipeOutDecryptionKeys();
+  void wipeOutDecryptionKeys();
 
-  bool is_utilized();
+  bool isUtilized();
 
   /// FileDecryptionProperties object can be used for reading one file only.
   /// Mark FileDecryptionProperties as utilized once it is used to read a file
   /// as the encryption keys will be wiped out upon completion of file reading.
-  void set_utilized() {
+  void setUtilized() {
     utilized_ = true;
   }
 
-  /// FileDecryptionProperties object can be used for reading one file only.
+  /// FileDecryptionProperties object can be used for reading one file only
   /// (unless this object keeps the keyRetrieval callback only, and no explicit
   /// keys or aadPrefix).
   /// At the end, keys are wiped out in the memory.
-  /// This method allows to clone identical properties for another file,
+  /// This method allows cloning identical properties for another file,
   /// with an option to update the aadPrefix (if newAadPrefix is null,
-  /// aadPrefix will be cloned too)
-  std::shared_ptr<FileDecryptionProperties> DeepClone(
-      std::string new_aad_prefix = "");
+  /// aadPrefix will be cloned too).
+  std::shared_ptr<FileDecryptionProperties> deepClone(
+      std::string newAadPrefix = "");
 
  private:
-  std::string footer_key_;
-  std::string aad_prefix_;
-  std::shared_ptr<AADPrefixVerifier> aad_prefix_verifier_;
+  std::string footerKey_;
+  std::string aadPrefix_;
+  std::shared_ptr<AADPrefixVerifier> aadPrefixVerifier_;
 
-  const std::string empty_string_ = "";
-  ColumnPathToDecryptionPropertiesMap column_decryption_properties_;
+  const std::string emptyString_ = "";
+  ColumnPathToDecryptionPropertiesMap columnDecryptionProperties_;
 
-  std::shared_ptr<DecryptionKeyRetriever> key_retriever_;
-  bool check_plaintext_footer_integrity_;
-  bool plaintext_files_allowed_;
+  std::shared_ptr<DecryptionKeyRetriever> keyRetriever_;
+  bool checkPlaintextFooterIntegrity_;
+  bool plaintextFilesAllowed_;
   bool utilized_;
 
   FileDecryptionProperties(
-      const std::string& footer_key,
-      std::shared_ptr<DecryptionKeyRetriever> key_retriever,
-      bool check_plaintext_footer_integrity,
-      const std::string& aad_prefix,
-      std::shared_ptr<AADPrefixVerifier> aad_prefix_verifier,
-      const ColumnPathToDecryptionPropertiesMap& column_decryption_properties,
-      bool plaintext_files_allowed);
+      const std::string& footerKey,
+      std::shared_ptr<DecryptionKeyRetriever> keyRetriever,
+      bool checkPlaintextFooterIntegrity,
+      const std::string& aadPrefix,
+      std::shared_ptr<AADPrefixVerifier> aadPrefixVerifier,
+      const ColumnPathToDecryptionPropertiesMap& columnDecryptionProperties,
+      bool plaintextFilesAllowed);
 };
 
 class PARQUET_EXPORT FileEncryptionProperties {
  public:
   class PARQUET_EXPORT Builder {
    public:
-    explicit Builder(const std::string& footer_key)
-        : parquet_cipher_(kDefaultEncryptionAlgorithm),
-          encrypted_footer_(kDefaultEncryptedFooter) {
-      footer_key_ = footer_key;
-      store_aad_prefix_in_file_ = false;
+    explicit Builder(const std::string& footerKey)
+        : parquetCipher_(kDefaultEncryptionAlgorithm),
+          encryptedFooter_(kDefaultEncryptedFooter) {
+      footerKey_ = footerKey;
+      storeAadPrefixInFile_ = false;
     }
 
     /// Create files with plaintext footer.
-    /// If not called, the files will be created with encrypted footer
+    /// If not called, the files will be created with encrypted footer.
     /// (default).
-    Builder* set_plaintext_footer() {
-      encrypted_footer_ = false;
+    Builder* setPlaintextFooter() {
+      encryptedFooter_ = false;
       return this;
     }
 
     /// Set encryption algorithm.
     /// If not called, files will be encrypted with AES_GCM_V1 (default).
-    Builder* algorithm(ParquetCipher::type parquet_cipher) {
-      parquet_cipher_ = parquet_cipher;
+    Builder* algorithm(ParquetCipher::type parquetCipher) {
+      parquetCipher_ = parquetCipher;
       return this;
     }
 
     /// Set a key retrieval metadata (converted from String).
-    /// use either footer_key_metadata or footer_key_id, not both.
-    Builder* footer_key_id(const std::string& key_id);
+    /// Use either footer_key_metadata or footer_key_id, not both.
+    Builder* footerKeyId(const std::string& keyId);
 
     /// Set a key retrieval metadata.
-    /// use either footer_key_metadata or footer_key_id, not both.
-    Builder* footer_key_metadata(const std::string& footer_key_metadata);
+    /// Use either footer_key_metadata or footer_key_id, not both.
+    Builder* footerKeyMetadata(const std::string& footerKeyMetadata);
 
     /// Set the file AAD Prefix.
-    Builder* aad_prefix(const std::string& aad_prefix);
+    Builder* aadPrefix(const std::string& aadPrefix);
 
     /// Skip storing AAD Prefix in file.
     /// If not called, and if AAD Prefix is set, it will be stored.
-    Builder* disable_aad_prefix_storage();
+    Builder* disableAadPrefixStorage();
 
-    /// Set the list of encrypted columns and their properties (keys etc).
+    /// Set the list of encrypted columns and their properties (keys, etc.).
     /// If not called, all columns will be encrypted with the footer key.
     /// If called, the file columns not in the list will be left unencrypted.
-    Builder* encrypted_columns(
-        const ColumnPathToEncryptionPropertiesMap& encrypted_columns);
+    Builder* encryptedColumns(
+        const ColumnPathToEncryptionPropertiesMap& encryptedColumns);
 
     std::shared_ptr<FileEncryptionProperties> build() {
       return std::shared_ptr<FileEncryptionProperties>(
           new FileEncryptionProperties(
-              parquet_cipher_,
-              footer_key_,
-              footer_key_metadata_,
-              encrypted_footer_,
-              aad_prefix_,
-              store_aad_prefix_in_file_,
-              encrypted_columns_));
+              parquetCipher_,
+              footerKey_,
+              footerKeyMetadata_,
+              encryptedFooter_,
+              aadPrefix_,
+              storeAadPrefixInFile_,
+              encryptedColumns_));
     }
 
    private:
-    ParquetCipher::type parquet_cipher_;
-    bool encrypted_footer_;
-    std::string footer_key_;
-    std::string footer_key_metadata_;
-
-    std::string aad_prefix_;
-    bool store_aad_prefix_in_file_;
-    ColumnPathToEncryptionPropertiesMap encrypted_columns_;
+    ParquetCipher::type parquetCipher_;
+    bool encryptedFooter_;
+    std::string footerKey_;
+    std::string footerKeyMetadata_;
+
+    std::string aadPrefix_;
+    bool storeAadPrefixInFile_;
+    ColumnPathToEncryptionPropertiesMap encryptedColumns_;
   };
-  bool encrypted_footer() const {
-    return encrypted_footer_;
+  bool encryptedFooter() const {
+    return encryptedFooter_;
   }
 
   EncryptionAlgorithm algorithm() const {
     return algorithm_;
   }
 
-  std::string footer_key() const {
-    return footer_key_;
+  std::string footerKey() const {
+    return footerKey_;
   }
 
-  std::string footer_key_metadata() const {
-    return footer_key_metadata_;
+  std::string footerKeyMetadata() const {
+    return footerKeyMetadata_;
   }
 
-  std::string file_aad() const {
-    return file_aad_;
+  std::string fileAad() const {
+    return fileAad_;
   }
 
-  std::shared_ptr<ColumnEncryptionProperties> column_encryption_properties(
-      const std::string& column_path);
+  std::shared_ptr<ColumnEncryptionProperties> columnEncryptionProperties(
+      const std::string& columnPath);
 
-  bool is_utilized() const {
+  bool isUtilized() const {
     return utilized_;
   }
 
   /// FileEncryptionProperties object can be used for writing one file only.
   /// Mark FileEncryptionProperties as utilized once it is used to write a file
   /// as the encryption keys will be wiped out upon completion of file writing.
-  void set_utilized() {
+  void setUtilized() {
     utilized_ = true;
   }
 
   /// Upon completion of file writing, the encryption keys
   /// will be wiped out (array values set to 0).
-  void WipeOutEncryptionKeys();
+  void wipeOutEncryptionKeys();
 
-  /// FileEncryptionProperties object can be used for writing one file only.
+  /// FileEncryptionProperties object can be used for writing one file only
   /// (at the end, keys are wiped out in the memory).
-  /// This method allows to clone identical properties for another file,
+  /// This method allows cloning identical properties for another file,
   /// with an option to update the aadPrefix (if newAadPrefix is null,
-  /// aadPrefix will be cloned too)
-  std::shared_ptr<FileEncryptionProperties> DeepClone(
-      std::string new_aad_prefix = "");
+  /// aadPrefix will be cloned too).
+  std::shared_ptr<FileEncryptionProperties> deepClone(
+      std::string newAadPrefix = "");
 
-  ColumnPathToEncryptionPropertiesMap encrypted_columns() const {
-    return encrypted_columns_;
+  ColumnPathToEncryptionPropertiesMap encryptedColumns() const {
+    return encryptedColumns_;
   }
 
  private:
   EncryptionAlgorithm algorithm_;
-  std::string footer_key_;
-  std::string footer_key_metadata_;
-  bool encrypted_footer_;
-  std::string file_aad_;
-  std::string aad_prefix_;
+  std::string footerKey_;
+  std::string footerKeyMetadata_;
+  bool encryptedFooter_;
+  std::string fileAad_;
+  std::string aadPrefix_;
   bool utilized_;
-  bool store_aad_prefix_in_file_;
-  ColumnPathToEncryptionPropertiesMap encrypted_columns_;
+  bool storeAadPrefixInFile_;
+  ColumnPathToEncryptionPropertiesMap encryptedColumns_;
 
   FileEncryptionProperties(
       ParquetCipher::type cipher,
-      const std::string& footer_key,
-      const std::string& footer_key_metadata,
-      bool encrypted_footer,
-      const std::string& aad_prefix,
-      bool store_aad_prefix_in_file,
-      const ColumnPathToEncryptionPropertiesMap& encrypted_columns);
+      const std::string& footerKey,
+      const std::string& footerKeyMetadata,
+      bool encryptedFooter,
+      const std::string& aadPrefix,
+      bool storeAadPrefixInFile,
+      const ColumnPathToEncryptionPropertiesMap& encryptedColumns);
 };
 
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/EncryptionInternal.cpp b/velox/dwio/parquet/writer/arrow/EncryptionInternal.cpp
index 7e988988069..81b4ed26e39 100644
--- a/velox/dwio/parquet/writer/arrow/EncryptionInternal.cpp
+++ b/velox/dwio/parquet/writer/arrow/EncryptionInternal.cpp
@@ -54,10 +54,10 @@ constexpr int kBufferSizeLength = 4;
 class AesEncryptor::AesEncryptorImpl {
  public:
   explicit AesEncryptorImpl(
-      ParquetCipher::type alg_id,
-      int key_len,
+      ParquetCipher::type algId,
+      int keyLen,
       bool metadata,
-      bool write_length);
+      bool writeLength);
 
   ~AesEncryptorImpl() {
     if (nullptr != ctx_) {
@@ -66,179 +66,172 @@ class AesEncryptor::AesEncryptorImpl {
     }
   }
 
-  int Encrypt(
+  int encrypt(
       const uint8_t* plaintext,
-      int plaintext_len,
+      int plaintextLen,
       const uint8_t* key,
-      int key_len,
+      int keyLen,
       const uint8_t* aad,
-      int aad_len,
+      int aadLen,
       uint8_t* ciphertext);
 
-  int SignedFooterEncrypt(
+  int signedFooterEncrypt(
       const uint8_t* footer,
-      int footer_len,
+      int footerLen,
       const uint8_t* key,
-      int key_len,
+      int keyLen,
       const uint8_t* aad,
-      int aad_len,
+      int aadLen,
       const uint8_t* nonce,
-      uint8_t* encrypted_footer);
-  void WipeOut() {
+      uint8_t* encryptedFooter);
+  void wipeOut() {
     if (nullptr != ctx_) {
       EVP_CIPHER_CTX_free(ctx_);
       ctx_ = nullptr;
     }
   }
 
-  int ciphertext_size_delta() {
-    return ciphertext_size_delta_;
+  int ciphertextSizeDelta() {
+    return ciphertextSizeDelta_;
   }
 
  private:
   EVP_CIPHER_CTX* ctx_;
-  int aes_mode_;
-  int key_length_;
-  int ciphertext_size_delta_;
-  int length_buffer_length_;
+  int aesMode_;
+  int keyLength_;
+  int ciphertextSizeDelta_;
+  int lengthBufferLength_;
 
-  int GcmEncrypt(
+  int gcmEncrypt(
       const uint8_t* plaintext,
-      int plaintext_len,
+      int plaintextLen,
       const uint8_t* key,
-      int key_len,
+      int keyLen,
       const uint8_t* nonce,
       const uint8_t* aad,
-      int aad_len,
+      int aadLen,
       uint8_t* ciphertext);
 
-  int CtrEncrypt(
+  int ctrEncrypt(
       const uint8_t* plaintext,
-      int plaintext_len,
+      int plaintextLen,
       const uint8_t* key,
-      int key_len,
+      int keyLen,
       const uint8_t* nonce,
       uint8_t* ciphertext);
 };
 
 AesEncryptor::AesEncryptorImpl::AesEncryptorImpl(
-    ParquetCipher::type alg_id,
-    int key_len,
+    ParquetCipher::type algId,
+    int keyLen,
     bool metadata,
-    bool write_length) {
+    bool writeLength) {
   ctx_ = nullptr;
 
-  length_buffer_length_ = write_length ? kBufferSizeLength : 0;
-  ciphertext_size_delta_ = length_buffer_length_ + kNonceLength;
-  if (metadata || (ParquetCipher::AES_GCM_V1 == alg_id)) {
-    aes_mode_ = kGcmMode;
-    ciphertext_size_delta_ += kGcmTagLength;
+  lengthBufferLength_ = writeLength ? kBufferSizeLength : 0;
+  ciphertextSizeDelta_ = lengthBufferLength_ + kNonceLength;
+  if (metadata || (ParquetCipher::kAesGcmV1 == algId)) {
+    aesMode_ = kGcmMode;
+    ciphertextSizeDelta_ += kGcmTagLength;
   } else {
-    aes_mode_ = kCtrMode;
+    aesMode_ = kCtrMode;
   }
 
-  if (16 != key_len && 24 != key_len && 32 != key_len) {
+  if (16 != keyLen && 24 != keyLen && 32 != keyLen) {
     std::stringstream ss;
-    ss << "Wrong key length: " << key_len;
+    ss << "Wrong key length: " << keyLen;
     throw ParquetException(ss.str());
   }
 
-  key_length_ = key_len;
+  keyLength_ = keyLen;
 
   ctx_ = EVP_CIPHER_CTX_new();
   if (nullptr == ctx_) {
     throw ParquetException("Couldn't init cipher context");
   }
 
-  if (kGcmMode == aes_mode_) {
-    // Init AES-GCM with specified key length
-    if (16 == key_len) {
+  if (kGcmMode == aesMode_) {
+    // Init AES-GCM with specified key length.
+    if (16 == keyLen) {
       ENCRYPT_INIT(ctx_, EVP_aes_128_gcm());
-    } else if (24 == key_len) {
+    } else if (24 == keyLen) {
       ENCRYPT_INIT(ctx_, EVP_aes_192_gcm());
-    } else if (32 == key_len) {
+    } else if (32 == keyLen) {
       ENCRYPT_INIT(ctx_, EVP_aes_256_gcm());
     }
   } else {
-    // Init AES-CTR with specified key length
-    if (16 == key_len) {
+    // Init AES-CTR with specified key length.
+    if (16 == keyLen) {
       ENCRYPT_INIT(ctx_, EVP_aes_128_ctr());
-    } else if (24 == key_len) {
+    } else if (24 == keyLen) {
       ENCRYPT_INIT(ctx_, EVP_aes_192_ctr());
-    } else if (32 == key_len) {
+    } else if (32 == keyLen) {
       ENCRYPT_INIT(ctx_, EVP_aes_256_ctr());
     }
   }
 }
 
-int AesEncryptor::AesEncryptorImpl::SignedFooterEncrypt(
+int AesEncryptor::AesEncryptorImpl::signedFooterEncrypt(
     const uint8_t* footer,
-    int footer_len,
+    int footerLen,
     const uint8_t* key,
-    int key_len,
+    int keyLen,
     const uint8_t* aad,
-    int aad_len,
+    int aadLen,
     const uint8_t* nonce,
-    uint8_t* encrypted_footer) {
-  if (key_length_ != key_len) {
+    uint8_t* encryptedFooter) {
+  if (keyLength_ != keyLen) {
     std::stringstream ss;
-    ss << "Wrong key length " << key_len << ". Should be " << key_length_;
+    ss << "Wrong key length " << keyLen << ". Should be " << keyLength_;
     throw ParquetException(ss.str());
   }
 
-  if (kGcmMode != aes_mode_) {
+  if (kGcmMode != aesMode_) {
     throw ParquetException("Must use AES GCM (metadata) encryptor");
   }
 
-  return GcmEncrypt(
-      footer, footer_len, key, key_len, nonce, aad, aad_len, encrypted_footer);
+  return gcmEncrypt(
+      footer, footerLen, key, keyLen, nonce, aad, aadLen, encryptedFooter);
 }
 
-int AesEncryptor::AesEncryptorImpl::Encrypt(
+int AesEncryptor::AesEncryptorImpl::encrypt(
     const uint8_t* plaintext,
-    int plaintext_len,
+    int plaintextLen,
     const uint8_t* key,
-    int key_len,
+    int keyLen,
     const uint8_t* aad,
-    int aad_len,
+    int aadLen,
     uint8_t* ciphertext) {
-  if (key_length_ != key_len) {
+  if (keyLength_ != keyLen) {
     std::stringstream ss;
-    ss << "Wrong key length " << key_len << ". Should be " << key_length_;
+    ss << "Wrong key length " << keyLen << ". Should be " << keyLength_;
     throw ParquetException(ss.str());
   }
 
   uint8_t nonce[kNonceLength];
   memset(nonce, 0, kNonceLength);
-  // Random nonce
-  RAND_bytes(nonce, sizeof(nonce));
-
-  if (kGcmMode == aes_mode_) {
-    return GcmEncrypt(
-        plaintext,
-        plaintext_len,
-        key,
-        key_len,
-        nonce,
-        aad,
-        aad_len,
-        ciphertext);
-  }
-
-  return CtrEncrypt(plaintext, plaintext_len, key, key_len, nonce, ciphertext);
+  // Random nonce.
+  randBytes(nonce, sizeof(nonce));
+
+  if (kGcmMode == aesMode_) {
+    return gcmEncrypt(
+        plaintext, plaintextLen, key, keyLen, nonce, aad, aadLen, ciphertext);
+  }
+
+  return ctrEncrypt(plaintext, plaintextLen, key, keyLen, nonce, ciphertext);
 }
 
-int AesEncryptor::AesEncryptorImpl::GcmEncrypt(
+int AesEncryptor::AesEncryptorImpl::gcmEncrypt(
     const uint8_t* plaintext,
-    int plaintext_len,
+    int plaintextLen,
     const uint8_t* key,
-    int key_len,
+    int keyLen,
     const uint8_t* nonce,
     const uint8_t* aad,
-    int aad_len,
+    int aadLen,
     uint8_t* ciphertext) {
   int len = 0;
-  int ciphertext_len;
+  int ciphertextLen;
 
   uint8_t tag[kGcmTagLength];
   memset(tag, 0, kGcmTagLength);
@@ -248,170 +241,166 @@ int AesEncryptor::AesEncryptorImpl::GcmEncrypt(
     throw ParquetException("Couldn't set key and nonce");
   }
 
-  // Setting additional authenticated data
+  // Setting additional authenticated data.
   if ((nullptr != aad) &&
-      (1 != EVP_EncryptUpdate(ctx_, nullptr, &len, aad, aad_len))) {
+      (1 != EVP_EncryptUpdate(ctx_, nullptr, &len, aad, aadLen))) {
     throw ParquetException("Couldn't set AAD");
   }
 
-  // Encryption
+  // Encryption.
   if (1 !=
       EVP_EncryptUpdate(
           ctx_,
-          ciphertext + length_buffer_length_ + kNonceLength,
+          ciphertext + lengthBufferLength_ + kNonceLength,
           &len,
           plaintext,
-          plaintext_len)) {
+          plaintextLen)) {
     throw ParquetException("Failed encryption update");
   }
 
-  ciphertext_len = len;
+  ciphertextLen = len;
 
-  // Finalization
+  // Finalization.
   if (1 !=
       EVP_EncryptFinal_ex(
-          ctx_,
-          ciphertext + length_buffer_length_ + kNonceLength + len,
-          &len)) {
+          ctx_, ciphertext + lengthBufferLength_ + kNonceLength + len, &len)) {
     throw ParquetException("Failed encryption finalization");
   }
 
-  ciphertext_len += len;
+  ciphertextLen += len;
 
-  // Getting the tag
+  // Getting the tag.
   if (1 !=
       EVP_CIPHER_CTX_ctrl(ctx_, EVP_CTRL_GCM_GET_TAG, kGcmTagLength, tag)) {
     throw ParquetException("Couldn't get AES-GCM tag");
   }
 
-  // Copying the buffer size, nonce and tag to ciphertext
-  uint32_t buffer_size = kNonceLength + ciphertext_len + kGcmTagLength;
-  if (length_buffer_length_ > 0) {
-    ciphertext[3] = static_cast<uint8_t>(0xff & (buffer_size >> 24));
-    ciphertext[2] = static_cast<uint8_t>(0xff & (buffer_size >> 16));
-    ciphertext[1] = static_cast<uint8_t>(0xff & (buffer_size >> 8));
-    ciphertext[0] = static_cast<uint8_t>(0xff & (buffer_size));
+  // Copying the buffer size, nonce and tag to ciphertext.
+  uint32_t bufferSize = kNonceLength + ciphertextLen + kGcmTagLength;
+  if (lengthBufferLength_ > 0) {
+    ciphertext[3] = static_cast<uint8_t>(0xff & (bufferSize >> 24));
+    ciphertext[2] = static_cast<uint8_t>(0xff & (bufferSize >> 16));
+    ciphertext[1] = static_cast<uint8_t>(0xff & (bufferSize >> 8));
+    ciphertext[0] = static_cast<uint8_t>(0xff & (bufferSize));
   }
-  std::copy(nonce, nonce + kNonceLength, ciphertext + length_buffer_length_);
+  std::copy(nonce, nonce + kNonceLength, ciphertext + lengthBufferLength_);
   std::copy(
       tag,
       tag + kGcmTagLength,
-      ciphertext + length_buffer_length_ + kNonceLength + ciphertext_len);
+      ciphertext + lengthBufferLength_ + kNonceLength + ciphertextLen);
 
-  return length_buffer_length_ + buffer_size;
+  return lengthBufferLength_ + bufferSize;
 }
 
-int AesEncryptor::AesEncryptorImpl::CtrEncrypt(
+int AesEncryptor::AesEncryptorImpl::ctrEncrypt(
     const uint8_t* plaintext,
-    int plaintext_len,
+    int plaintextLen,
     const uint8_t* key,
-    int key_len,
+    int keyLen,
     const uint8_t* nonce,
     uint8_t* ciphertext) {
   int len = 0;
-  int ciphertext_len;
+  int ciphertextLen;
 
-  // Parquet CTR IVs are comprised of a 12-byte nonce and a 4-byte initial
-  // counter field.
-  // The first 31 bits of the initial counter field are set to 0, the last bit
-  // is set to 1.
+  // Parquet CTR IVs are comprised of a 12-byte nonce and a 4-byte initial.
+  // Counter field.
+  // The first 31 bits of the initial counter field are set to 0, the last bit.
+  // Is set to 1.
   uint8_t iv[kCtrIvLength];
   memset(iv, 0, kCtrIvLength);
   std::copy(nonce, nonce + kNonceLength, iv);
   iv[kCtrIvLength - 1] = 1;
 
-  // Setting key and IV
+  // Setting key and IV.
   if (1 != EVP_EncryptInit_ex(ctx_, nullptr, nullptr, key, iv)) {
     throw ParquetException("Couldn't set key and IV");
   }
 
-  // Encryption
+  // Encryption.
   if (1 !=
       EVP_EncryptUpdate(
           ctx_,
-          ciphertext + length_buffer_length_ + kNonceLength,
+          ciphertext + lengthBufferLength_ + kNonceLength,
           &len,
           plaintext,
-          plaintext_len)) {
+          plaintextLen)) {
     throw ParquetException("Failed encryption update");
   }
 
-  ciphertext_len = len;
+  ciphertextLen = len;
 
-  // Finalization
+  // Finalization.
   if (1 !=
       EVP_EncryptFinal_ex(
-          ctx_,
-          ciphertext + length_buffer_length_ + kNonceLength + len,
-          &len)) {
+          ctx_, ciphertext + lengthBufferLength_ + kNonceLength + len, &len)) {
     throw ParquetException("Failed encryption finalization");
   }
 
-  ciphertext_len += len;
+  ciphertextLen += len;
 
-  // Copying the buffer size and nonce to ciphertext
-  uint32_t buffer_size = kNonceLength + ciphertext_len;
-  if (length_buffer_length_ > 0) {
-    ciphertext[3] = static_cast<uint8_t>(0xff & (buffer_size >> 24));
-    ciphertext[2] = static_cast<uint8_t>(0xff & (buffer_size >> 16));
-    ciphertext[1] = static_cast<uint8_t>(0xff & (buffer_size >> 8));
-    ciphertext[0] = static_cast<uint8_t>(0xff & (buffer_size));
+  // Copying the buffer size and nonce to ciphertext.
+  uint32_t bufferSize = kNonceLength + ciphertextLen;
+  if (lengthBufferLength_ > 0) {
+    ciphertext[3] = static_cast<uint8_t>(0xff & (bufferSize >> 24));
+    ciphertext[2] = static_cast<uint8_t>(0xff & (bufferSize >> 16));
+    ciphertext[1] = static_cast<uint8_t>(0xff & (bufferSize >> 8));
+    ciphertext[0] = static_cast<uint8_t>(0xff & (bufferSize));
   }
-  std::copy(nonce, nonce + kNonceLength, ciphertext + length_buffer_length_);
+  std::copy(nonce, nonce + kNonceLength, ciphertext + lengthBufferLength_);
 
-  return length_buffer_length_ + buffer_size;
+  return lengthBufferLength_ + bufferSize;
 }
 
 AesEncryptor::~AesEncryptor() {}
 
-int AesEncryptor::SignedFooterEncrypt(
+int AesEncryptor::signedFooterEncrypt(
     const uint8_t* footer,
-    int footer_len,
+    int footerLen,
     const uint8_t* key,
-    int key_len,
+    int keyLen,
     const uint8_t* aad,
-    int aad_len,
+    int aadLen,
     const uint8_t* nonce,
-    uint8_t* encrypted_footer) {
-  return impl_->SignedFooterEncrypt(
-      footer, footer_len, key, key_len, aad, aad_len, nonce, encrypted_footer);
+    uint8_t* encryptedFooter) {
+  return impl_->signedFooterEncrypt(
+      footer, footerLen, key, keyLen, aad, aadLen, nonce, encryptedFooter);
 }
 
-void AesEncryptor::WipeOut() {
-  impl_->WipeOut();
+void AesEncryptor::wipeOut() {
+  impl_->wipeOut();
 }
 
-int AesEncryptor::CiphertextSizeDelta() {
-  return impl_->ciphertext_size_delta();
+int AesEncryptor::ciphertextSizeDelta() {
+  return impl_->ciphertextSizeDelta();
 }
 
-int AesEncryptor::Encrypt(
+int AesEncryptor::encrypt(
     const uint8_t* plaintext,
-    int plaintext_len,
+    int plaintextLen,
     const uint8_t* key,
-    int key_len,
+    int keyLen,
     const uint8_t* aad,
-    int aad_len,
+    int aadLen,
     uint8_t* ciphertext) {
-  return impl_->Encrypt(
-      plaintext, plaintext_len, key, key_len, aad, aad_len, ciphertext);
+  return impl_->encrypt(
+      plaintext, plaintextLen, key, keyLen, aad, aadLen, ciphertext);
 }
 
 AesEncryptor::AesEncryptor(
-    ParquetCipher::type alg_id,
-    int key_len,
+    ParquetCipher::type algId,
+    int keyLen,
     bool metadata,
-    bool write_length)
+    bool writeLength)
     : impl_{std::unique_ptr<AesEncryptorImpl>(
-          new AesEncryptorImpl(alg_id, key_len, metadata, write_length))} {}
+          new AesEncryptorImpl(algId, keyLen, metadata, writeLength))} {}
 
 class AesDecryptor::AesDecryptorImpl {
  public:
   explicit AesDecryptorImpl(
-      ParquetCipher::type alg_id,
-      int key_len,
+      ParquetCipher::type algId,
+      int keyLen,
       bool metadata,
-      bool contains_length);
+      bool containsLength);
 
   ~AesDecryptorImpl() {
     if (nullptr != ctx_) {
@@ -420,345 +409,344 @@ class AesDecryptor::AesDecryptorImpl {
     }
   }
 
-  int Decrypt(
+  int decrypt(
       const uint8_t* ciphertext,
-      int ciphertext_len,
+      int ciphertextLen,
       const uint8_t* key,
-      int key_len,
+      int keyLen,
       const uint8_t* aad,
-      int aad_len,
+      int aadLen,
       uint8_t* plaintext);
 
-  void WipeOut() {
+  void wipeOut() {
     if (nullptr != ctx_) {
       EVP_CIPHER_CTX_free(ctx_);
       ctx_ = nullptr;
     }
   }
 
-  int ciphertext_size_delta() {
-    return ciphertext_size_delta_;
+  int ciphertextSizeDelta() {
+    return ciphertextSizeDelta_;
   }
 
  private:
   EVP_CIPHER_CTX* ctx_;
-  int aes_mode_;
-  int key_length_;
-  int ciphertext_size_delta_;
-  int length_buffer_length_;
-  int GcmDecrypt(
+  int aesMode_;
+  int keyLength_;
+  int ciphertextSizeDelta_;
+  int lengthBufferLength_;
+  int gcmDecrypt(
       const uint8_t* ciphertext,
-      int ciphertext_len,
+      int ciphertextLen,
       const uint8_t* key,
-      int key_len,
+      int keyLen,
       const uint8_t* aad,
-      int aad_len,
+      int aadLen,
       uint8_t* plaintext);
 
-  int CtrDecrypt(
+  int ctrDecrypt(
       const uint8_t* ciphertext,
-      int ciphertext_len,
+      int ciphertextLen,
       const uint8_t* key,
-      int key_len,
+      int keyLen,
       uint8_t* plaintext);
 };
 
-int AesDecryptor::Decrypt(
+int AesDecryptor::decrypt(
     const uint8_t* plaintext,
-    int plaintext_len,
+    int plaintextLen,
     const uint8_t* key,
-    int key_len,
+    int keyLen,
     const uint8_t* aad,
-    int aad_len,
+    int aadLen,
     uint8_t* ciphertext) {
-  return impl_->Decrypt(
-      plaintext, plaintext_len, key, key_len, aad, aad_len, ciphertext);
+  return impl_->decrypt(
+      plaintext, plaintextLen, key, keyLen, aad, aadLen, ciphertext);
 }
 
-void AesDecryptor::WipeOut() {
-  impl_->WipeOut();
+void AesDecryptor::wipeOut() {
+  impl_->wipeOut();
 }
 
 AesDecryptor::~AesDecryptor() {}
 
 AesDecryptor::AesDecryptorImpl::AesDecryptorImpl(
-    ParquetCipher::type alg_id,
-    int key_len,
+    ParquetCipher::type algId,
+    int keyLen,
     bool metadata,
-    bool contains_length) {
+    bool containsLength) {
   ctx_ = nullptr;
-  length_buffer_length_ = contains_length ? kBufferSizeLength : 0;
-  ciphertext_size_delta_ = length_buffer_length_ + kNonceLength;
-  if (metadata || (ParquetCipher::AES_GCM_V1 == alg_id)) {
-    aes_mode_ = kGcmMode;
-    ciphertext_size_delta_ += kGcmTagLength;
+  lengthBufferLength_ = containsLength ? kBufferSizeLength : 0;
+  ciphertextSizeDelta_ = lengthBufferLength_ + kNonceLength;
+  if (metadata || (ParquetCipher::kAesGcmV1 == algId)) {
+    aesMode_ = kGcmMode;
+    ciphertextSizeDelta_ += kGcmTagLength;
   } else {
-    aes_mode_ = kCtrMode;
+    aesMode_ = kCtrMode;
   }
 
-  if (16 != key_len && 24 != key_len && 32 != key_len) {
+  if (16 != keyLen && 24 != keyLen && 32 != keyLen) {
     std::stringstream ss;
-    ss << "Wrong key length: " << key_len;
+    ss << "Wrong key length: " << keyLen;
     throw ParquetException(ss.str());
   }
 
-  key_length_ = key_len;
+  keyLength_ = keyLen;
 
   ctx_ = EVP_CIPHER_CTX_new();
   if (nullptr == ctx_) {
     throw ParquetException("Couldn't init cipher context");
   }
 
-  if (kGcmMode == aes_mode_) {
-    // Init AES-GCM with specified key length
-    if (16 == key_len) {
+  if (kGcmMode == aesMode_) {
+    // Init AES-GCM with specified key length.
+    if (16 == keyLen) {
       DECRYPT_INIT(ctx_, EVP_aes_128_gcm());
-    } else if (24 == key_len) {
+    } else if (24 == keyLen) {
       DECRYPT_INIT(ctx_, EVP_aes_192_gcm());
-    } else if (32 == key_len) {
+    } else if (32 == keyLen) {
       DECRYPT_INIT(ctx_, EVP_aes_256_gcm());
     }
   } else {
-    // Init AES-CTR with specified key length
-    if (16 == key_len) {
+    // Init AES-CTR with specified key length.
+    if (16 == keyLen) {
       DECRYPT_INIT(ctx_, EVP_aes_128_ctr());
-    } else if (24 == key_len) {
+    } else if (24 == keyLen) {
       DECRYPT_INIT(ctx_, EVP_aes_192_ctr());
-    } else if (32 == key_len) {
+    } else if (32 == keyLen) {
       DECRYPT_INIT(ctx_, EVP_aes_256_ctr());
     }
   }
 }
 
-AesEncryptor* AesEncryptor::Make(
-    ParquetCipher::type alg_id,
-    int key_len,
+AesEncryptor* AesEncryptor::make(
+    ParquetCipher::type algId,
+    int keyLen,
     bool metadata,
-    std::vector<AesEncryptor*>* all_encryptors) {
-  return Make(alg_id, key_len, metadata, true /*write_length*/, all_encryptors);
+    std::vector<AesEncryptor*>* allEncryptors) {
+  return make(algId, keyLen, metadata, true /*write_length*/, allEncryptors);
 }
 
-AesEncryptor* AesEncryptor::Make(
-    ParquetCipher::type alg_id,
-    int key_len,
+AesEncryptor* AesEncryptor::make(
+    ParquetCipher::type algId,
+    int keyLen,
     bool metadata,
-    bool write_length,
-    std::vector<AesEncryptor*>* all_encryptors) {
-  if (ParquetCipher::AES_GCM_V1 != alg_id &&
-      ParquetCipher::AES_GCM_CTR_V1 != alg_id) {
+    bool writeLength,
+    std::vector<AesEncryptor*>* allEncryptors) {
+  if (ParquetCipher::kAesGcmV1 != algId &&
+      ParquetCipher::kAesGcmCtrV1 != algId) {
     std::stringstream ss;
-    ss << "Crypto algorithm " << alg_id << " is not supported";
+    ss << "Crypto algorithm " << algId << " is not supported";
     throw ParquetException(ss.str());
   }
 
-  AesEncryptor* encryptor =
-      new AesEncryptor(alg_id, key_len, metadata, write_length);
-  if (all_encryptors != nullptr)
-    all_encryptors->push_back(encryptor);
-  return encryptor;
+  AesEncryptor* Encryptor =
+      new AesEncryptor(algId, keyLen, metadata, writeLength);
+  if (allEncryptors != nullptr)
+    allEncryptors->push_back(Encryptor);
+  return Encryptor;
 }
 
 AesDecryptor::AesDecryptor(
-    ParquetCipher::type alg_id,
-    int key_len,
+    ParquetCipher::type algId,
+    int keyLen,
     bool metadata,
-    bool contains_length)
+    bool containsLength)
     : impl_{std::unique_ptr<AesDecryptorImpl>(
-          new AesDecryptorImpl(alg_id, key_len, metadata, contains_length))} {}
+          new AesDecryptorImpl(algId, keyLen, metadata, containsLength))} {}
 
-std::shared_ptr<AesDecryptor> AesDecryptor::Make(
-    ParquetCipher::type alg_id,
-    int key_len,
+std::shared_ptr<AesDecryptor> AesDecryptor::make(
+    ParquetCipher::type algId,
+    int keyLen,
     bool metadata,
-    std::vector<std::weak_ptr<AesDecryptor>>* all_decryptors) {
-  if (ParquetCipher::AES_GCM_V1 != alg_id &&
-      ParquetCipher::AES_GCM_CTR_V1 != alg_id) {
+    std::vector<std::weak_ptr<AesDecryptor>>* allDecryptors) {
+  if (ParquetCipher::kAesGcmV1 != algId &&
+      ParquetCipher::kAesGcmCtrV1 != algId) {
     std::stringstream ss;
-    ss << "Crypto algorithm " << alg_id << " is not supported";
+    ss << "Crypto algorithm " << algId << " is not supported";
     throw ParquetException(ss.str());
   }
 
-  auto decryptor = std::make_shared<AesDecryptor>(alg_id, key_len, metadata);
-  if (all_decryptors != nullptr) {
-    all_decryptors->push_back(decryptor);
+  auto Decryptor = std::make_shared<AesDecryptor>(algId, keyLen, metadata);
+  if (allDecryptors != nullptr) {
+    allDecryptors->push_back(Decryptor);
   }
-  return decryptor;
+  return Decryptor;
 }
 
-int AesDecryptor::CiphertextSizeDelta() {
-  return impl_->ciphertext_size_delta();
+int AesDecryptor::ciphertextSizeDelta() {
+  return impl_->ciphertextSizeDelta();
 }
 
-int AesDecryptor::AesDecryptorImpl::GcmDecrypt(
+int AesDecryptor::AesDecryptorImpl::gcmDecrypt(
     const uint8_t* ciphertext,
-    int ciphertext_len,
+    int ciphertextLen,
     const uint8_t* key,
-    int key_len,
+    int keyLen,
     const uint8_t* aad,
-    int aad_len,
+    int aadLen,
     uint8_t* plaintext) {
   int len = 0;
-  int plaintext_len;
+  int plaintextLen;
 
   uint8_t tag[kGcmTagLength];
   memset(tag, 0, kGcmTagLength);
   uint8_t nonce[kNonceLength];
   memset(nonce, 0, kNonceLength);
 
-  if (length_buffer_length_ > 0) {
-    // Extract ciphertext length
-    uint32_t written_ciphertext_len = ((ciphertext[3] & 0xff) << 24) |
+  if (lengthBufferLength_ > 0) {
+    // Extract ciphertext length.
+    uint32_t writtenCiphertextLen = ((ciphertext[3] & 0xff) << 24) |
         ((ciphertext[2] & 0xff) << 16) | ((ciphertext[1] & 0xff) << 8) |
         ((ciphertext[0] & 0xff));
 
-    if (ciphertext_len > 0 &&
-        ciphertext_len != (written_ciphertext_len + length_buffer_length_)) {
+    if (ciphertextLen > 0 &&
+        ciphertextLen != (writtenCiphertextLen + lengthBufferLength_)) {
       throw ParquetException("Wrong ciphertext length");
     }
-    ciphertext_len = written_ciphertext_len + length_buffer_length_;
+    ciphertextLen = writtenCiphertextLen + lengthBufferLength_;
   } else {
-    if (ciphertext_len == 0) {
+    if (ciphertextLen == 0) {
       throw ParquetException("Zero ciphertext length");
     }
   }
 
-  // Extracting IV and tag
+  // Extracting IV and tag.
   std::copy(
-      ciphertext + length_buffer_length_,
-      ciphertext + length_buffer_length_ + kNonceLength,
+      ciphertext + lengthBufferLength_,
+      ciphertext + lengthBufferLength_ + kNonceLength,
       nonce);
   std::copy(
-      ciphertext + ciphertext_len - kGcmTagLength,
-      ciphertext + ciphertext_len,
+      ciphertext + ciphertextLen - kGcmTagLength,
+      ciphertext + ciphertextLen,
       tag);
 
-  // Setting key and IV
+  // Setting key and IV.
   if (1 != EVP_DecryptInit_ex(ctx_, nullptr, nullptr, key, nonce)) {
     throw ParquetException("Couldn't set key and IV");
   }
 
-  // Setting additional authenticated data
+  // Setting additional authenticated data.
   if ((nullptr != aad) &&
-      (1 != EVP_DecryptUpdate(ctx_, nullptr, &len, aad, aad_len))) {
+      (1 != EVP_DecryptUpdate(ctx_, nullptr, &len, aad, aadLen))) {
     throw ParquetException("Couldn't set AAD");
   }
 
-  // Decryption
+  // Decryption.
   if (!EVP_DecryptUpdate(
           ctx_,
           plaintext,
           &len,
-          ciphertext + length_buffer_length_ + kNonceLength,
-          ciphertext_len - length_buffer_length_ - kNonceLength -
-              kGcmTagLength)) {
+          ciphertext + lengthBufferLength_ + kNonceLength,
+          ciphertextLen - lengthBufferLength_ - kNonceLength - kGcmTagLength)) {
     throw ParquetException("Failed decryption update");
   }
 
-  plaintext_len = len;
+  plaintextLen = len;
 
   // Checking the tag (authentication)
   if (!EVP_CIPHER_CTX_ctrl(ctx_, EVP_CTRL_GCM_SET_TAG, kGcmTagLength, tag)) {
     throw ParquetException("Failed authentication");
   }
 
-  // Finalization
+  // Finalization.
   if (1 != EVP_DecryptFinal_ex(ctx_, plaintext + len, &len)) {
     throw ParquetException("Failed decryption finalization");
   }
 
-  plaintext_len += len;
-  return plaintext_len;
+  plaintextLen += len;
+  return plaintextLen;
 }
 
-int AesDecryptor::AesDecryptorImpl::CtrDecrypt(
+int AesDecryptor::AesDecryptorImpl::ctrDecrypt(
     const uint8_t* ciphertext,
-    int ciphertext_len,
+    int ciphertextLen,
     const uint8_t* key,
-    int key_len,
+    int keyLen,
     uint8_t* plaintext) {
   int len = 0;
-  int plaintext_len;
+  int plaintextLen;
 
   uint8_t iv[kCtrIvLength];
   memset(iv, 0, kCtrIvLength);
 
-  if (length_buffer_length_ > 0) {
-    // Extract ciphertext length
-    uint32_t written_ciphertext_len = ((ciphertext[3] & 0xff) << 24) |
+  if (lengthBufferLength_ > 0) {
+    // Extract ciphertext length.
+    uint32_t writtenCiphertextLen = ((ciphertext[3] & 0xff) << 24) |
         ((ciphertext[2] & 0xff) << 16) | ((ciphertext[1] & 0xff) << 8) |
         ((ciphertext[0] & 0xff));
 
-    if (ciphertext_len > 0 &&
-        ciphertext_len != (written_ciphertext_len + length_buffer_length_)) {
+    if (ciphertextLen > 0 &&
+        ciphertextLen != (writtenCiphertextLen + lengthBufferLength_)) {
       throw ParquetException("Wrong ciphertext length");
     }
-    ciphertext_len = written_ciphertext_len;
+    ciphertextLen = writtenCiphertextLen;
   } else {
-    if (ciphertext_len == 0) {
+    if (ciphertextLen == 0) {
       throw ParquetException("Zero ciphertext length");
     }
   }
 
-  // Extracting nonce
+  // Extracting nonce.
   std::copy(
-      ciphertext + length_buffer_length_,
-      ciphertext + length_buffer_length_ + kNonceLength,
+      ciphertext + lengthBufferLength_,
+      ciphertext + lengthBufferLength_ + kNonceLength,
       iv);
-  // Parquet CTR IVs are comprised of a 12-byte nonce and a 4-byte initial
-  // counter field.
-  // The first 31 bits of the initial counter field are set to 0, the last bit
-  // is set to 1.
+  // Parquet CTR IVs are comprised of a 12-byte nonce and a 4-byte initial.
+  // Counter field.
+  // The first 31 bits of the initial counter field are set to 0, the last bit.
+  // Is set to 1.
   iv[kCtrIvLength - 1] = 1;
 
-  // Setting key and IV
+  // Setting key and IV.
   if (1 != EVP_DecryptInit_ex(ctx_, nullptr, nullptr, key, iv)) {
     throw ParquetException("Couldn't set key and IV");
   }
 
-  // Decryption
+  // Decryption.
   if (!EVP_DecryptUpdate(
           ctx_,
           plaintext,
           &len,
-          ciphertext + length_buffer_length_ + kNonceLength,
-          ciphertext_len - kNonceLength)) {
+          ciphertext + lengthBufferLength_ + kNonceLength,
+          ciphertextLen - kNonceLength)) {
     throw ParquetException("Failed decryption update");
   }
 
-  plaintext_len = len;
+  plaintextLen = len;
 
-  // Finalization
+  // Finalization.
   if (1 != EVP_DecryptFinal_ex(ctx_, plaintext + len, &len)) {
     throw ParquetException("Failed decryption finalization");
   }
 
-  plaintext_len += len;
-  return plaintext_len;
+  plaintextLen += len;
+  return plaintextLen;
 }
 
-int AesDecryptor::AesDecryptorImpl::Decrypt(
+int AesDecryptor::AesDecryptorImpl::decrypt(
     const uint8_t* ciphertext,
-    int ciphertext_len,
+    int ciphertextLen,
     const uint8_t* key,
-    int key_len,
+    int keyLen,
     const uint8_t* aad,
-    int aad_len,
+    int aadLen,
     uint8_t* plaintext) {
-  if (key_length_ != key_len) {
+  if (keyLength_ != keyLen) {
     std::stringstream ss;
-    ss << "Wrong key length " << key_len << ". Should be " << key_length_;
+    ss << "Wrong key length " << keyLen << ". Should be " << keyLength_;
     throw ParquetException(ss.str());
   }
 
-  if (kGcmMode == aes_mode_) {
-    return GcmDecrypt(
-        ciphertext, ciphertext_len, key, key_len, aad, aad_len, plaintext);
+  if (kGcmMode == aesMode_) {
+    return gcmDecrypt(
+        ciphertext, ciphertextLen, key, keyLen, aad, aadLen, plaintext);
   }
 
-  return CtrDecrypt(ciphertext, ciphertext_len, key, key_len, plaintext);
+  return ctrDecrypt(ciphertext, ciphertextLen, key, keyLen, plaintext);
 }
 
-static std::string ShortToBytesLe(int16_t input) {
+static std::string shortToBytesLe(int16_t input) {
   int8_t output[2];
   memset(output, 0, 2);
   uint16_t in = static_cast<uint16_t>(input);
@@ -768,66 +756,68 @@ static std::string ShortToBytesLe(int16_t input) {
   return std::string(reinterpret_cast<char const*>(output), 2);
 }
 
-static void CheckPageOrdinal(int32_t page_ordinal) {
-  if (ARROW_PREDICT_FALSE(page_ordinal > std::numeric_limits<int16_t>::max())) {
+static void checkPageOrdinal(int32_t pageOrdinal) {
+  if (ARROW_PREDICT_FALSE(pageOrdinal > std::numeric_limits<int16_t>::max())) {
     throw ParquetException(
         "Encrypted Parquet files can't have more than " +
         std::to_string(std::numeric_limits<int16_t>::max()) +
-        " pages per chunk: got " + std::to_string(page_ordinal));
+        " pages per chunk: got " + std::to_string(pageOrdinal));
   }
 }
 
-std::string CreateModuleAad(
-    const std::string& file_aad,
-    int8_t module_type,
-    int16_t row_group_ordinal,
-    int16_t column_ordinal,
-    int32_t page_ordinal) {
-  CheckPageOrdinal(page_ordinal);
-  const int16_t page_ordinal_short = static_cast<int16_t>(page_ordinal);
-  int8_t type_ordinal_bytes[1];
-  type_ordinal_bytes[0] = module_type;
-  std::string type_ordinal_bytes_str(
-      reinterpret_cast<char const*>(type_ordinal_bytes), 1);
-  if (kFooter == module_type) {
-    std::string result = file_aad + type_ordinal_bytes_str;
+std::string createModuleAad(
+    const std::string& fileAad,
+    int8_t moduleType,
+    int16_t rowGroupOrdinal,
+    int16_t columnOrdinal,
+    int32_t pageOrdinal) {
+  checkPageOrdinal(pageOrdinal);
+  const int16_t pageOrdinalShort = static_cast<int16_t>(pageOrdinal);
+  int8_t typeOrdinalBytes[1];
+  typeOrdinalBytes[0] = moduleType;
+  std::string typeOrdinalBytesStr(
+      reinterpret_cast<char const*>(typeOrdinalBytes), 1);
+  if (kFooter == moduleType) {
+    std::string result = fileAad + typeOrdinalBytesStr;
     return result;
   }
-  std::string row_group_ordinal_bytes = ShortToBytesLe(row_group_ordinal);
-  std::string column_ordinal_bytes = ShortToBytesLe(column_ordinal);
-  if (kDataPage != module_type && kDataPageHeader != module_type) {
+  std::string rowGroupOrdinalBytes = shortToBytesLe(rowGroupOrdinal);
+  std::string columnOrdinalBytes = shortToBytesLe(columnOrdinal);
+  if (kDataPage != moduleType && kDataPageHeader != moduleType) {
     std::ostringstream out;
-    out << file_aad << type_ordinal_bytes_str << row_group_ordinal_bytes
-        << column_ordinal_bytes;
+    out << fileAad << typeOrdinalBytesStr << rowGroupOrdinalBytes
+        << columnOrdinalBytes;
     return out.str();
   }
-  std::string page_ordinal_bytes = ShortToBytesLe(page_ordinal_short);
+  std::string pageOrdinalBytes = shortToBytesLe(pageOrdinalShort);
   std::ostringstream out;
-  out << file_aad << type_ordinal_bytes_str << row_group_ordinal_bytes
-      << column_ordinal_bytes << page_ordinal_bytes;
+  out << fileAad << typeOrdinalBytesStr << rowGroupOrdinalBytes
+      << columnOrdinalBytes << pageOrdinalBytes;
   return out.str();
 }
 
-std::string CreateFooterAad(const std::string& aad_prefix_bytes) {
-  return CreateModuleAad(
-      aad_prefix_bytes,
+std::string createFooterAad(const std::string& aadPrefixBytes) {
+  return createModuleAad(
+      aadPrefixBytes,
       kFooter,
       static_cast<int16_t>(-1),
       static_cast<int16_t>(-1),
       static_cast<int16_t>(-1));
 }
 
-// Update last two bytes with new page ordinal (instead of creating new page AAD
-// from scratch)
-void QuickUpdatePageAad(int32_t new_page_ordinal, std::string* AAD) {
-  CheckPageOrdinal(new_page_ordinal);
-  const std::string page_ordinal_bytes =
-      ShortToBytesLe(static_cast<int16_t>(new_page_ordinal));
-  std::memcpy(AAD->data() + AAD->length() - 2, page_ordinal_bytes.data(), 2);
+// Update last two bytes with new page ordinal (instead of creating new page
+// AAD. from scratch)
+void quickUpdatePageAad(int32_t newPageOrdinal, std::string* AAD) {
+  checkPageOrdinal(newPageOrdinal);
+  const std::string pageOrdinalBytes =
+      shortToBytesLe(static_cast<int16_t>(newPageOrdinal));
+  std::memcpy(AAD->data() + AAD->length() - 2, pageOrdinalBytes.data(), 2);
 }
 
-void RandBytes(unsigned char* buf, int num) {
-  RAND_bytes(buf, num);
+void randBytes(unsigned char* buf, int num) {
+  if (RAND_bytes(buf, num) != 1) {
+    throw ParquetException("Failed to generate random bytes");
+  }
 }
 
 } // namespace facebook::velox::parquet::arrow::encryption
diff --git a/velox/dwio/parquet/writer/arrow/EncryptionInternal.h b/velox/dwio/parquet/writer/arrow/EncryptionInternal.h
index 1d554e5345c..bcb5068479c 100644
--- a/velox/dwio/parquet/writer/arrow/EncryptionInternal.h
+++ b/velox/dwio/parquet/writer/arrow/EncryptionInternal.h
@@ -32,7 +32,7 @@ namespace facebook::velox::parquet::arrow::encryption {
 constexpr int kGcmTagLength = 16;
 constexpr int kNonceLength = 12;
 
-// Module types
+// Module types.
 constexpr int8_t kFooter = 0;
 constexpr int8_t kColumnMetaData = 1;
 constexpr int8_t kDataPage = 2;
@@ -46,58 +46,58 @@ constexpr int8_t kOffsetIndex = 7;
 class AesEncryptor {
  public:
   /// Can serve one key length only. Possible values: 16, 24, 32 bytes.
-  /// If write_length is true, prepend ciphertext length to the ciphertext
+  /// If write_length is true, prepend ciphertext length to the ciphertext.
   explicit AesEncryptor(
-      ParquetCipher::type alg_id,
-      int key_len,
+      ParquetCipher::type algId,
+      int keyLen,
       bool metadata,
-      bool write_length = true);
+      bool writeLength = true);
 
-  static AesEncryptor* Make(
-      ParquetCipher::type alg_id,
-      int key_len,
+  static AesEncryptor* make(
+      ParquetCipher::type algId,
+      int keyLen,
       bool metadata,
-      std::vector<AesEncryptor*>* all_encryptors);
+      std::vector<AesEncryptor*>* allEncryptors);
 
-  static AesEncryptor* Make(
-      ParquetCipher::type alg_id,
-      int key_len,
+  static AesEncryptor* make(
+      ParquetCipher::type algId,
+      int keyLen,
       bool metadata,
-      bool write_length,
-      std::vector<AesEncryptor*>* all_encryptors);
+      bool writeLength,
+      std::vector<AesEncryptor*>* allEncryptors);
 
   ~AesEncryptor();
 
   /// Size difference between plaintext and ciphertext, for this cipher.
-  int CiphertextSizeDelta();
+  int ciphertextSizeDelta();
 
-  /// Encrypts plaintext with the key and aad. Key length is passed only for
-  /// validation. If different from value in constructor, exception will be
-  /// thrown.
-  int Encrypt(
+  /// Encrypts plaintext with the key and aad. Key length is passed only for.
+  /// Validation. If different from value in constructor, exception will be.
+  /// Thrown.
+  int encrypt(
       const uint8_t* plaintext,
-      int plaintext_len,
+      int plaintextLen,
       const uint8_t* key,
-      int key_len,
+      int keyLen,
       const uint8_t* aad,
-      int aad_len,
+      int aadLen,
       uint8_t* ciphertext);
 
   /// Encrypts plaintext footer, in order to compute footer signature (tag).
-  int SignedFooterEncrypt(
+  int signedFooterEncrypt(
       const uint8_t* footer,
-      int footer_len,
+      int footerLen,
       const uint8_t* key,
-      int key_len,
+      int keyLen,
       const uint8_t* aad,
-      int aad_len,
+      int aadLen,
       const uint8_t* nonce,
-      uint8_t* encrypted_footer);
+      uint8_t* encryptedFooter);
 
-  void WipeOut();
+  void wipeOut();
 
  private:
-  // PIMPL Idiom
+  // PIMPL Idiom.
   class AesEncryptorImpl;
   std::unique_ptr<AesEncryptorImpl> impl_;
 };
@@ -106,65 +106,65 @@ class AesEncryptor {
 class AesDecryptor {
  public:
   /// Can serve one key length only. Possible values: 16, 24, 32 bytes.
-  /// If contains_length is true, expect ciphertext length prepended to the
-  /// ciphertext
+  /// If contains_length is true, expect ciphertext length prepended to the.
+  /// Ciphertext.
   explicit AesDecryptor(
-      ParquetCipher::type alg_id,
-      int key_len,
+      ParquetCipher::type algId,
+      int keyLen,
       bool metadata,
-      bool contains_length = true);
+      bool containsLength = true);
 
-  /// \brief Factory function to create an AesDecryptor
+  /// \brief Factory function to create an AesDecryptor.
   ///
-  /// \param alg_id the encryption algorithm to use
+  /// \param alg_id the encryption algorithm to use.
   /// \param key_len key length. Possible values: 16, 24, 32 bytes.
-  /// \param metadata if true then this is a metadata decryptor
-  /// \param all_decryptors A weak reference to all decryptors that need to be
-  /// wiped out when decryption is finished \return shared pointer to a new
-  /// AesDecryptor
-  static std::shared_ptr<AesDecryptor> Make(
-      ParquetCipher::type alg_id,
-      int key_len,
+  /// \param metadata if true then this is a metadata decryptor.
+  /// \param all_decryptors A weak reference to all decryptors that need to be.
+  /// Wiped out when decryption is finished \return shared pointer to a new.
+  /// AesDecryptor.
+  static std::shared_ptr<AesDecryptor> make(
+      ParquetCipher::type algId,
+      int keyLen,
       bool metadata,
-      std::vector<std::weak_ptr<AesDecryptor>>* all_decryptors);
+      std::vector<std::weak_ptr<AesDecryptor>>* allDecryptors);
 
   ~AesDecryptor();
-  void WipeOut();
+  void wipeOut();
 
   /// Size difference between plaintext and ciphertext, for this cipher.
-  int CiphertextSizeDelta();
+  int ciphertextSizeDelta();
 
-  /// Decrypts ciphertext with the key and aad. Key length is passed only for
-  /// validation. If different from value in constructor, exception will be
-  /// thrown.
-  int Decrypt(
+  /// Decrypts ciphertext with the key and aad. Key length is passed only for.
+  /// Validation. If different from value in constructor, exception will be.
+  /// Thrown.
+  int decrypt(
       const uint8_t* ciphertext,
-      int ciphertext_len,
+      int ciphertextLen,
       const uint8_t* key,
-      int key_len,
+      int keyLen,
       const uint8_t* aad,
-      int aad_len,
+      int aadLen,
       uint8_t* plaintext);
 
  private:
-  // PIMPL Idiom
+  // PIMPL Idiom.
   class AesDecryptorImpl;
   std::unique_ptr<AesDecryptorImpl> impl_;
 };
 
-std::string CreateModuleAad(
-    const std::string& file_aad,
-    int8_t module_type,
-    int16_t row_group_ordinal,
-    int16_t column_ordinal,
-    int32_t page_ordinal);
+std::string createModuleAad(
+    const std::string& fileAad,
+    int8_t moduleType,
+    int16_t rowGroupOrdinal,
+    int16_t columnOrdinal,
+    int32_t pageOrdinal);
 
-std::string CreateFooterAad(const std::string& aad_prefix_bytes);
+std::string createFooterAad(const std::string& aadPrefixBytes);
 
-// Update last two bytes of page (or page header) module AAD
-void QuickUpdatePageAad(int32_t new_page_ordinal, std::string* AAD);
+// Update last two bytes of page (or page header) module AAD.
+void quickUpdatePageAad(int32_t newPageOrdinal, std::string* AAD);
 
-// Wraps OpenSSL RAND_bytes function
-void RandBytes(unsigned char* buf, int num);
+// Wraps OpenSSL RAND_bytes function.
+void randBytes(unsigned char* buf, int num);
 
 } // namespace facebook::velox::parquet::arrow::encryption
diff --git a/velox/dwio/parquet/writer/arrow/Exception.h b/velox/dwio/parquet/writer/arrow/Exception.h
index 927df340746..caeed90f08b 100644
--- a/velox/dwio/parquet/writer/arrow/Exception.h
+++ b/velox/dwio/parquet/writer/arrow/Exception.h
@@ -27,12 +27,12 @@
 #include "arrow/util/string_builder.h"
 #include "velox/dwio/parquet/writer/arrow/Platform.h"
 
-// PARQUET-1085
+// PARQUET-1085.
 #if !defined(ARROW_UNUSED)
 #define ARROW_UNUSED(x) UNUSED(x)
 #endif
 
-// Parquet exception to Arrow Status
+// Parquet exception to Arrow Status.
 
 #define BEGIN_PARQUET_CATCH_EXCEPTIONS try {
 #define END_PARQUET_CATCH_EXCEPTIONS                                           \
@@ -44,51 +44,50 @@
     return ::arrow::Status::IOError(e.what());                                 \
   }
 
-// clang-format off
+// clang-format off.
 
-#define PARQUET_CATCH_NOT_OK(s)    \
-  BEGIN_PARQUET_CATCH_EXCEPTIONS   \
-  (s);                             \
+#define PARQUET_CATCH_NOT_OK(s)      \
+  BEGIN_PARQUET_CATCH_EXCEPTIONS(s); \
   END_PARQUET_CATCH_EXCEPTIONS
 
-// clang-format on
+// clang-format on.
 
 #define PARQUET_CATCH_AND_RETURN(s) \
   BEGIN_PARQUET_CATCH_EXCEPTIONS    \
   return (s);                       \
   END_PARQUET_CATCH_EXCEPTIONS
 
-// Arrow Status to Parquet exception
+// Arrow Status to Parquet exception.
 
-#define PARQUET_IGNORE_NOT_OK(s)                                \
-  do {                                                          \
-    ::arrow::Status _s = ::arrow::internal::GenericToStatus(s); \
-    ARROW_UNUSED(_s);                                           \
+#define PARQUET_IGNORE_NOT_OK(s)                               \
+  do {                                                         \
+    ::arrow::Status S = ::arrow::internal::GenericToStatus(s); \
+    ARROW_UNUSED(S);                                           \
   } while (0)
 
 #define PARQUET_THROW_NOT_OK(s)                                        \
   do {                                                                 \
-    ::arrow::Status _s = ::arrow::internal::GenericToStatus(s);        \
-    if (!_s.ok()) {                                                    \
+    ::arrow::Status S = ::arrow::internal::GenericToStatus(s);         \
+    if (!S.ok()) {                                                     \
       throw ::facebook::velox::parquet::arrow::ParquetStatusException( \
-          std::move(_s));                                              \
+          std::move(S));                                               \
     }                                                                  \
   } while (0)
 
-#define PARQUET_ASSIGN_OR_THROW_IMPL(status_name, lhs, rexpr) \
-  auto status_name = (rexpr);                                 \
-  PARQUET_THROW_NOT_OK(status_name.status());                 \
-  lhs = std::move(status_name).ValueOrDie();
+#define PARQUET_ASSIGN_OR_THROW_IMPL(statusName, lhs, rexpr) \
+  auto statusName = (rexpr);                                 \
+  PARQUET_THROW_NOT_OK(statusName.status());                 \
+  lhs = std::move(statusName).ValueOrDie();
 
 #define PARQUET_ASSIGN_OR_THROW(lhs, rexpr) \
   PARQUET_ASSIGN_OR_THROW_IMPL(             \
-      ARROW_ASSIGN_OR_RAISE_NAME(_error_or_value, __COUNTER__), lhs, rexpr);
+      ARROW_ASSIGN_OR_RAISE_NAME(ErrorOrValue, __COUNTER__), lhs, rexpr);
 
 namespace facebook::velox::parquet::arrow {
 
 class ParquetException : public std::exception {
  public:
-  PARQUET_NORETURN static void EofException(const std::string& msg = "") {
+  PARQUET_NORETURN static void eofException(const std::string& msg = "") {
     static std::string prefix = "Unexpected end of stream";
     if (msg.empty()) {
       throw ParquetException(prefix);
@@ -154,13 +153,14 @@ class ParquetInvalidOrCorruptedFileException : public ParquetStatusException {
           int>::type = 0,
       typename... Args>
   explicit ParquetInvalidOrCorruptedFileException(Arg arg, Args&&... args)
-      : ParquetStatusException(::arrow::Status::Invalid(
-            std::forward<Arg>(arg),
-            std::forward<Args>(args)...)) {}
+      : ParquetStatusException(
+            ::arrow::Status::Invalid(
+                std::forward<Arg>(arg),
+                std::forward<Args>(args)...)) {}
 };
 
 template <typename StatusReturnBlock>
-void ThrowNotOk(StatusReturnBlock&& b) {
+void throwNotOk(StatusReturnBlock&& b) {
   PARQUET_THROW_NOT_OK(b());
 }
 
diff --git a/velox/dwio/parquet/writer/arrow/FileDecryptorInternal.cpp b/velox/dwio/parquet/writer/arrow/FileDecryptorInternal.cpp
index 6161a1e4474..ad578784229 100644
--- a/velox/dwio/parquet/writer/arrow/FileDecryptorInternal.cpp
+++ b/velox/dwio/parquet/writer/arrow/FileDecryptorInternal.cpp
@@ -22,30 +22,30 @@
 
 namespace facebook::velox::parquet::arrow {
 
-// Decryptor
+// Decryptor.
 Decryptor::Decryptor(
-    std::shared_ptr<encryption::AesDecryptor> aes_decryptor,
+    std::shared_ptr<encryption::AesDecryptor> aesDecryptor,
     const std::string& key,
-    const std::string& file_aad,
+    const std::string& fileAad,
     const std::string& aad,
     ::arrow::MemoryPool* pool)
-    : aes_decryptor_(aes_decryptor),
+    : aesDecryptor_(aesDecryptor),
       key_(key),
-      file_aad_(file_aad),
+      fileAad_(fileAad),
       aad_(aad),
       pool_(pool) {}
 
-int Decryptor::CiphertextSizeDelta() {
-  return aes_decryptor_->CiphertextSizeDelta();
+int Decryptor::ciphertextSizeDelta() {
+  return aesDecryptor_->ciphertextSizeDelta();
 }
 
-int Decryptor::Decrypt(
+int Decryptor::decrypt(
     const uint8_t* ciphertext,
-    int ciphertext_len,
+    int ciphertextLen,
     uint8_t* plaintext) {
-  return aes_decryptor_->Decrypt(
+  return aesDecryptor_->decrypt(
       ciphertext,
-      ciphertext_len,
+      ciphertextLen,
       str2bytes(key_),
       static_cast<int>(key_.size()),
       str2bytes(aad_),
@@ -53,190 +53,190 @@ int Decryptor::Decrypt(
       plaintext);
 }
 
-// InternalFileDecryptor
+// InternalFileDecryptor.
 InternalFileDecryptor::InternalFileDecryptor(
     FileDecryptionProperties* properties,
-    const std::string& file_aad,
+    const std::string& fileAad,
     ParquetCipher::type algorithm,
-    const std::string& footer_key_metadata,
+    const std::string& footerKeyMetadata,
     ::arrow::MemoryPool* pool)
     : properties_(properties),
-      file_aad_(file_aad),
+      fileAad_(fileAad),
       algorithm_(algorithm),
-      footer_key_metadata_(footer_key_metadata),
+      footerKeyMetadata_(footerKeyMetadata),
       pool_(pool) {
-  if (properties_->is_utilized()) {
+  if (properties_->isUtilized()) {
     throw ParquetException(
         "Re-using decryption properties with explicit keys for another file");
   }
-  properties_->set_utilized();
+  properties_->setUtilized();
 }
 
-void InternalFileDecryptor::WipeOutDecryptionKeys() {
-  properties_->WipeOutDecryptionKeys();
-  for (auto const& i : all_decryptors_) {
-    if (auto aes_decryptor = i.lock()) {
-      aes_decryptor->WipeOut();
+void InternalFileDecryptor::wipeOutDecryptionKeys() {
+  properties_->wipeOutDecryptionKeys();
+  for (auto const& i : allDecryptors_) {
+    if (auto aesDecryptor = i.lock()) {
+      aesDecryptor->wipeOut();
     }
   }
 }
 
-std::string InternalFileDecryptor::GetFooterKey() {
-  std::string footer_key = properties_->footer_key();
-  // ignore footer key metadata if footer key is explicitly set via API
-  if (footer_key.empty()) {
-    if (footer_key_metadata_.empty())
+std::string InternalFileDecryptor::getFooterKey() {
+  std::string footerKey = properties_->footerKey();
+  // Ignore footer key metadata if footer key is explicitly set via API.
+  if (footerKey.empty()) {
+    if (footerKeyMetadata_.empty())
       throw ParquetException("No footer key or key metadata");
-    if (properties_->key_retriever() == nullptr)
+    if (properties_->keyRetriever() == nullptr)
       throw ParquetException("No footer key or key retriever");
     try {
-      footer_key = properties_->key_retriever()->GetKey(footer_key_metadata_);
+      footerKey = properties_->keyRetriever()->getKey(footerKeyMetadata_);
     } catch (KeyAccessDeniedException& e) {
       std::stringstream ss;
       ss << "Footer key: access denied " << e.what() << "\n";
       throw ParquetException(ss.str());
     }
   }
-  if (footer_key.empty()) {
+  if (footerKey.empty()) {
     throw ParquetException(
         "Footer key unavailable. Could not verify "
         "plaintext footer metadata");
   }
-  return footer_key;
+  return footerKey;
 }
 
-std::shared_ptr<Decryptor> InternalFileDecryptor::GetFooterDecryptor() {
-  std::string aad = encryption::CreateFooterAad(file_aad_);
-  return GetFooterDecryptor(aad, true);
+std::shared_ptr<Decryptor> InternalFileDecryptor::getFooterDecryptor() {
+  std::string aad = encryption::createFooterAad(fileAad_);
+  return getFooterDecryptor(aad, true);
 }
 
 std::shared_ptr<Decryptor>
-InternalFileDecryptor::GetFooterDecryptorForColumnMeta(const std::string& aad) {
-  return GetFooterDecryptor(aad, true);
+InternalFileDecryptor::getFooterDecryptorForColumnMeta(const std::string& aad) {
+  return getFooterDecryptor(aad, true);
 }
 
 std::shared_ptr<Decryptor>
-InternalFileDecryptor::GetFooterDecryptorForColumnData(const std::string& aad) {
-  return GetFooterDecryptor(aad, false);
+InternalFileDecryptor::getFooterDecryptorForColumnData(const std::string& aad) {
+  return getFooterDecryptor(aad, false);
 }
 
-std::shared_ptr<Decryptor> InternalFileDecryptor::GetFooterDecryptor(
+std::shared_ptr<Decryptor> InternalFileDecryptor::getFooterDecryptor(
     const std::string& aad,
     bool metadata) {
   if (metadata) {
-    if (footer_metadata_decryptor_ != nullptr)
-      return footer_metadata_decryptor_;
+    if (footerMetadataDecryptor_ != nullptr)
+      return footerMetadataDecryptor_;
   } else {
-    if (footer_data_decryptor_ != nullptr)
-      return footer_data_decryptor_;
+    if (footerDataDecryptor_ != nullptr)
+      return footerDataDecryptor_;
   }
 
-  std::string footer_key = properties_->footer_key();
-  if (footer_key.empty()) {
-    if (footer_key_metadata_.empty())
+  std::string footerKey = properties_->footerKey();
+  if (footerKey.empty()) {
+    if (footerKeyMetadata_.empty())
       throw ParquetException("No footer key or key metadata");
-    if (properties_->key_retriever() == nullptr)
+    if (properties_->keyRetriever() == nullptr)
       throw ParquetException("No footer key or key retriever");
     try {
-      footer_key = properties_->key_retriever()->GetKey(footer_key_metadata_);
+      footerKey = properties_->keyRetriever()->getKey(footerKeyMetadata_);
     } catch (KeyAccessDeniedException& e) {
       std::stringstream ss;
       ss << "Footer key: access denied " << e.what() << "\n";
       throw ParquetException(ss.str());
     }
   }
-  if (footer_key.empty()) {
+  if (footerKey.empty()) {
     throw ParquetException(
         "Invalid footer encryption key. "
         "Could not parse footer metadata");
   }
 
-  // Create both data and metadata decryptors to avoid redundant retrieval of
-  // key from the key_retriever.
-  int key_len = static_cast<int>(footer_key.size());
-  auto aes_metadata_decryptor = encryption::AesDecryptor::Make(
-      algorithm_, key_len, /*metadata=*/true, &all_decryptors_);
-  auto aes_data_decryptor = encryption::AesDecryptor::Make(
-      algorithm_, key_len, /*metadata=*/false, &all_decryptors_);
+  // Create both data and metadata decryptors to avoid redundant retrieval of.
+  // Key from the key_retriever.
+  int keyLen = static_cast<int>(footerKey.size());
+  auto aesMetadataDecryptor =
+      encryption::AesDecryptor::make(algorithm_, keyLen, true, &allDecryptors_);
+  auto aesDataDecryptor = encryption::AesDecryptor::make(
+      algorithm_, keyLen, false, &allDecryptors_);
 
-  footer_metadata_decryptor_ = std::make_shared<Decryptor>(
-      aes_metadata_decryptor, footer_key, file_aad_, aad, pool_);
-  footer_data_decryptor_ = std::make_shared<Decryptor>(
-      aes_data_decryptor, footer_key, file_aad_, aad, pool_);
+  footerMetadataDecryptor_ = std::make_shared<Decryptor>(
+      aesMetadataDecryptor, footerKey, fileAad_, aad, pool_);
+  footerDataDecryptor_ = std::make_shared<Decryptor>(
+      aesDataDecryptor, footerKey, fileAad_, aad, pool_);
 
   if (metadata)
-    return footer_metadata_decryptor_;
-  return footer_data_decryptor_;
+    return footerMetadataDecryptor_;
+  return footerDataDecryptor_;
 }
 
-std::shared_ptr<Decryptor> InternalFileDecryptor::GetColumnMetaDecryptor(
-    const std::string& column_path,
-    const std::string& column_key_metadata,
+std::shared_ptr<Decryptor> InternalFileDecryptor::getColumnMetaDecryptor(
+    const std::string& ColumnPath,
+    const std::string& columnKeyMetadata,
     const std::string& aad) {
-  return GetColumnDecryptor(column_path, column_key_metadata, aad, true);
+  return getColumnDecryptor(ColumnPath, columnKeyMetadata, aad, true);
 }
 
-std::shared_ptr<Decryptor> InternalFileDecryptor::GetColumnDataDecryptor(
-    const std::string& column_path,
-    const std::string& column_key_metadata,
+std::shared_ptr<Decryptor> InternalFileDecryptor::getColumnDataDecryptor(
+    const std::string& ColumnPath,
+    const std::string& columnKeyMetadata,
     const std::string& aad) {
-  return GetColumnDecryptor(column_path, column_key_metadata, aad, false);
+  return getColumnDecryptor(ColumnPath, columnKeyMetadata, aad, false);
 }
 
-std::shared_ptr<Decryptor> InternalFileDecryptor::GetColumnDecryptor(
-    const std::string& column_path,
-    const std::string& column_key_metadata,
+std::shared_ptr<Decryptor> InternalFileDecryptor::getColumnDecryptor(
+    const std::string& ColumnPath,
+    const std::string& columnKeyMetadata,
     const std::string& aad,
     bool metadata) {
-  std::string column_key;
-  // first look if we already got the decryptor from before
+  std::string columnKey;
+  // First look if we already got the decryptor from before.
   if (metadata) {
-    if (column_metadata_map_.find(column_path) != column_metadata_map_.end()) {
-      auto res(column_metadata_map_.at(column_path));
-      res->UpdateAad(aad);
+    if (columnMetadataMap_.find(ColumnPath) != columnMetadataMap_.end()) {
+      auto res(columnMetadataMap_.at(ColumnPath));
+      res->updateAad(aad);
       return res;
     }
   } else {
-    if (column_data_map_.find(column_path) != column_data_map_.end()) {
-      auto res(column_data_map_.at(column_path));
-      res->UpdateAad(aad);
+    if (columnDataMap_.find(ColumnPath) != columnDataMap_.end()) {
+      auto res(columnDataMap_.at(ColumnPath));
+      res->updateAad(aad);
       return res;
     }
   }
 
-  column_key = properties_->column_key(column_path);
+  columnKey = properties_->columnKey(ColumnPath);
   // No explicit column key given via API. Retrieve via key metadata.
-  if (column_key.empty() && !column_key_metadata.empty() &&
-      properties_->key_retriever() != nullptr) {
+  if (columnKey.empty() && !columnKeyMetadata.empty() &&
+      properties_->keyRetriever() != nullptr) {
     try {
-      column_key = properties_->key_retriever()->GetKey(column_key_metadata);
+      columnKey = properties_->keyRetriever()->getKey(columnKeyMetadata);
     } catch (KeyAccessDeniedException& e) {
       std::stringstream ss;
-      ss << "HiddenColumnException, path=" + column_path + " " << e.what()
+      ss << "HiddenColumnException, path=" + ColumnPath + " " << e.what()
          << "\n";
       throw HiddenColumnException(ss.str());
     }
   }
-  if (column_key.empty()) {
-    throw HiddenColumnException("HiddenColumnException, path=" + column_path);
+  if (columnKey.empty()) {
+    throw HiddenColumnException("HiddenColumnException, path=" + ColumnPath);
   }
 
-  // Create both data and metadata decryptors to avoid redundant retrieval of
-  // key using the key_retriever.
-  int key_len = static_cast<int>(column_key.size());
-  auto aes_metadata_decryptor = encryption::AesDecryptor::Make(
-      algorithm_, key_len, /*metadata=*/true, &all_decryptors_);
-  auto aes_data_decryptor = encryption::AesDecryptor::Make(
-      algorithm_, key_len, /*metadata=*/false, &all_decryptors_);
+  // Create both data and metadata decryptors to avoid redundant retrieval of.
+  // Key using the key_retriever.
+  int keyLen = static_cast<int>(columnKey.size());
+  auto aesMetadataDecryptor =
+      encryption::AesDecryptor::make(algorithm_, keyLen, true, &allDecryptors_);
+  auto aesDataDecryptor = encryption::AesDecryptor::make(
+      algorithm_, keyLen, false, &allDecryptors_);
 
-  column_metadata_map_[column_path] = std::make_shared<Decryptor>(
-      aes_metadata_decryptor, column_key, file_aad_, aad, pool_);
-  column_data_map_[column_path] = std::make_shared<Decryptor>(
-      aes_data_decryptor, column_key, file_aad_, aad, pool_);
+  columnMetadataMap_[ColumnPath] = std::make_shared<Decryptor>(
+      aesMetadataDecryptor, columnKey, fileAad_, aad, pool_);
+  columnDataMap_[ColumnPath] = std::make_shared<Decryptor>(
+      aesDataDecryptor, columnKey, fileAad_, aad, pool_);
 
   if (metadata)
-    return column_metadata_map_[column_path];
-  return column_data_map_[column_path];
+    return columnMetadataMap_[ColumnPath];
+  return columnDataMap_[ColumnPath];
 }
 
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/FileDecryptorInternal.h b/velox/dwio/parquet/writer/arrow/FileDecryptorInternal.h
index b2e2de5e7cd..e34e5ba5b17 100644
--- a/velox/dwio/parquet/writer/arrow/FileDecryptorInternal.h
+++ b/velox/dwio/parquet/writer/arrow/FileDecryptorInternal.h
@@ -37,32 +37,29 @@ class FileDecryptionProperties;
 class PARQUET_EXPORT Decryptor {
  public:
   Decryptor(
-      std::shared_ptr<encryption::AesDecryptor> decryptor,
+      std::shared_ptr<encryption::AesDecryptor> Decryptor,
       const std::string& key,
-      const std::string& file_aad,
+      const std::string& fileAad,
       const std::string& aad,
       ::arrow::MemoryPool* pool);
 
-  const std::string& file_aad() const {
-    return file_aad_;
+  const std::string& fileAad() const {
+    return fileAad_;
   }
-  void UpdateAad(const std::string& aad) {
+  void updateAad(const std::string& aad) {
     aad_ = aad;
   }
   ::arrow::MemoryPool* pool() {
     return pool_;
   }
 
-  int CiphertextSizeDelta();
-  int Decrypt(
-      const uint8_t* ciphertext,
-      int ciphertext_len,
-      uint8_t* plaintext);
+  int ciphertextSizeDelta();
+  int decrypt(const uint8_t* ciphertext, int ciphertextLen, uint8_t* plaintext);
 
  private:
-  std::shared_ptr<encryption::AesDecryptor> aes_decryptor_;
+  std::shared_ptr<encryption::AesDecryptor> aesDecryptor_;
   std::string key_;
-  std::string file_aad_;
+  std::string fileAad_;
   std::string aad_;
   ::arrow::MemoryPool* pool_;
 };
@@ -71,72 +68,72 @@ class InternalFileDecryptor {
  public:
   explicit InternalFileDecryptor(
       FileDecryptionProperties* properties,
-      const std::string& file_aad,
+      const std::string& fileAad,
       ParquetCipher::type algorithm,
-      const std::string& footer_key_metadata,
+      const std::string& footerKeyMetadata,
       ::arrow::MemoryPool* pool);
 
-  std::string& file_aad() {
-    return file_aad_;
+  std::string& fileAad() {
+    return fileAad_;
   }
 
-  std::string GetFooterKey();
+  std::string getFooterKey();
 
   ParquetCipher::type algorithm() {
     return algorithm_;
   }
 
-  std::string& footer_key_metadata() {
-    return footer_key_metadata_;
+  std::string& footerKeyMetadata() {
+    return footerKeyMetadata_;
   }
 
   FileDecryptionProperties* properties() {
     return properties_;
   }
 
-  void WipeOutDecryptionKeys();
+  void wipeOutDecryptionKeys();
 
   ::arrow::MemoryPool* pool() {
     return pool_;
   }
 
-  std::shared_ptr<Decryptor> GetFooterDecryptor();
-  std::shared_ptr<Decryptor> GetFooterDecryptorForColumnMeta(
+  std::shared_ptr<Decryptor> getFooterDecryptor();
+  std::shared_ptr<Decryptor> getFooterDecryptorForColumnMeta(
       const std::string& aad = "");
-  std::shared_ptr<Decryptor> GetFooterDecryptorForColumnData(
+  std::shared_ptr<Decryptor> getFooterDecryptorForColumnData(
       const std::string& aad = "");
-  std::shared_ptr<Decryptor> GetColumnMetaDecryptor(
-      const std::string& column_path,
-      const std::string& column_key_metadata,
+  std::shared_ptr<Decryptor> getColumnMetaDecryptor(
+      const std::string& ColumnPath,
+      const std::string& columnKeyMetadata,
       const std::string& aad = "");
-  std::shared_ptr<Decryptor> GetColumnDataDecryptor(
-      const std::string& column_path,
-      const std::string& column_key_metadata,
+  std::shared_ptr<Decryptor> getColumnDataDecryptor(
+      const std::string& ColumnPath,
+      const std::string& columnKeyMetadata,
       const std::string& aad = "");
 
  private:
   FileDecryptionProperties* properties_;
-  // Concatenation of aad_prefix (if exists) and aad_file_unique
-  std::string file_aad_;
-  std::map<std::string, std::shared_ptr<Decryptor>> column_data_map_;
-  std::map<std::string, std::shared_ptr<Decryptor>> column_metadata_map_;
+  // Concatenation of aad_prefix (if exists) and aad_file_unique.
+  std::string fileAad_;
+  std::map<std::string, std::shared_ptr<Decryptor>> columnDataMap_;
+  std::map<std::string, std::shared_ptr<Decryptor>> columnMetadataMap_;
 
-  std::shared_ptr<Decryptor> footer_metadata_decryptor_;
-  std::shared_ptr<Decryptor> footer_data_decryptor_;
+  std::shared_ptr<Decryptor> footerMetadataDecryptor_;
+  std::shared_ptr<Decryptor> footerDataDecryptor_;
   ParquetCipher::type algorithm_;
-  std::string footer_key_metadata_;
-  // A weak reference to all decryptors that need to be wiped out when
-  // decryption is finished
-  std::vector<std::weak_ptr<encryption::AesDecryptor>> all_decryptors_;
+  std::string footerKeyMetadata_;
+  // A weak reference to all decryptors that need to be wiped out when.
+  // Decryption is finished.
+  std::vector<std::weak_ptr<encryption::AesDecryptor>> allDecryptors_;
 
   ::arrow::MemoryPool* pool_;
 
-  std::shared_ptr<Decryptor> GetFooterDecryptor(
+  std::shared_ptr<Decryptor> getFooterDecryptor(
       const std::string& aad,
       bool metadata);
-  std::shared_ptr<Decryptor> GetColumnDecryptor(
-      const std::string& column_path,
-      const std::string& column_key_metadata,
+  std::shared_ptr<Decryptor> getColumnDecryptor(
+      const std::string& ColumnPath,
+      const std::string& columnKeyMetadata,
       const std::string& aad,
       bool metadata = false);
 };
diff --git a/velox/dwio/parquet/writer/arrow/FileEncryptorInternal.cpp b/velox/dwio/parquet/writer/arrow/FileEncryptorInternal.cpp
index 6192156c7b2..74c4c2fbd7f 100644
--- a/velox/dwio/parquet/writer/arrow/FileEncryptorInternal.cpp
+++ b/velox/dwio/parquet/writer/arrow/FileEncryptorInternal.cpp
@@ -22,30 +22,30 @@
 
 namespace facebook::velox::parquet::arrow {
 
-// Encryptor
+// Encryptor.
 Encryptor::Encryptor(
-    encryption::AesEncryptor* aes_encryptor,
+    encryption::AesEncryptor* aesEncryptor,
     const std::string& key,
-    const std::string& file_aad,
+    const std::string& fileAad,
     const std::string& aad,
     ::arrow::MemoryPool* pool)
-    : aes_encryptor_(aes_encryptor),
+    : aesEncryptor_(aesEncryptor),
       key_(key),
-      file_aad_(file_aad),
+      fileAad_(fileAad),
       aad_(aad),
       pool_(pool) {}
 
-int Encryptor::CiphertextSizeDelta() {
-  return aes_encryptor_->CiphertextSizeDelta();
+int Encryptor::ciphertextSizeDelta() {
+  return aesEncryptor_->ciphertextSizeDelta();
 }
 
-int Encryptor::Encrypt(
+int Encryptor::encrypt(
     const uint8_t* plaintext,
-    int plaintext_len,
+    int plaintextLen,
     uint8_t* ciphertext) {
-  return aes_encryptor_->Encrypt(
+  return aesEncryptor_->encrypt(
       plaintext,
-      plaintext_len,
+      plaintextLen,
       str2bytes(key_),
       static_cast<int>(key_.size()),
       str2bytes(aad_),
@@ -53,141 +53,138 @@ int Encryptor::Encrypt(
       ciphertext);
 }
 
-// InternalFileEncryptor
+// InternalFileEncryptor.
 InternalFileEncryptor::InternalFileEncryptor(
     FileEncryptionProperties* properties,
     ::arrow::MemoryPool* pool)
     : properties_(properties), pool_(pool) {
-  if (properties_->is_utilized()) {
+  if (properties_->isUtilized()) {
     throw ParquetException("Re-using encryption properties for another file");
   }
-  properties_->set_utilized();
+  properties_->setUtilized();
 }
 
-void InternalFileEncryptor::WipeOutEncryptionKeys() {
-  properties_->WipeOutEncryptionKeys();
+void InternalFileEncryptor::wipeOutEncryptionKeys() {
+  properties_->wipeOutEncryptionKeys();
 
-  for (auto const& i : all_encryptors_) {
-    i->WipeOut();
+  for (auto const& i : allEncryptors_) {
+    i->wipeOut();
   }
 }
 
-std::shared_ptr<Encryptor> InternalFileEncryptor::GetFooterEncryptor() {
-  if (footer_encryptor_ != nullptr) {
-    return footer_encryptor_;
+std::shared_ptr<Encryptor> InternalFileEncryptor::getFooterEncryptor() {
+  if (footerEncryptor_ != nullptr) {
+    return footerEncryptor_;
   }
 
   ParquetCipher::type algorithm = properties_->algorithm().algorithm;
-  std::string footer_aad = encryption::CreateFooterAad(properties_->file_aad());
-  std::string footer_key = properties_->footer_key();
-  auto aes_encryptor = GetMetaAesEncryptor(algorithm, footer_key.size());
-  footer_encryptor_ = std::make_shared<Encryptor>(
-      aes_encryptor, footer_key, properties_->file_aad(), footer_aad, pool_);
-  return footer_encryptor_;
+  std::string footerAad = encryption::createFooterAad(properties_->fileAad());
+  std::string footerKey = properties_->footerKey();
+  auto aesEncryptor = getMetaAesEncryptor(algorithm, footerKey.size());
+  footerEncryptor_ = std::make_shared<Encryptor>(
+      aesEncryptor, footerKey, properties_->fileAad(), footerAad, pool_);
+  return footerEncryptor_;
 }
 
-std::shared_ptr<Encryptor> InternalFileEncryptor::GetFooterSigningEncryptor() {
-  if (footer_signing_encryptor_ != nullptr) {
-    return footer_signing_encryptor_;
+std::shared_ptr<Encryptor> InternalFileEncryptor::getFooterSigningEncryptor() {
+  if (footerSigningEncryptor_ != nullptr) {
+    return footerSigningEncryptor_;
   }
 
   ParquetCipher::type algorithm = properties_->algorithm().algorithm;
-  std::string footer_aad = encryption::CreateFooterAad(properties_->file_aad());
-  std::string footer_signing_key = properties_->footer_key();
-  auto aes_encryptor =
-      GetMetaAesEncryptor(algorithm, footer_signing_key.size());
-  footer_signing_encryptor_ = std::make_shared<Encryptor>(
-      aes_encryptor,
-      footer_signing_key,
-      properties_->file_aad(),
-      footer_aad,
-      pool_);
-  return footer_signing_encryptor_;
+  std::string footerAad = encryption::createFooterAad(properties_->fileAad());
+  std::string footerSigningKey = properties_->footerKey();
+  auto aesEncryptor = getMetaAesEncryptor(algorithm, footerSigningKey.size());
+  footerSigningEncryptor_ = std::make_shared<Encryptor>(
+      aesEncryptor, footerSigningKey, properties_->fileAad(), footerAad, pool_);
+  return footerSigningEncryptor_;
 }
 
-std::shared_ptr<Encryptor> InternalFileEncryptor::GetColumnMetaEncryptor(
-    const std::string& column_path) {
-  return GetColumnEncryptor(column_path, true);
+std::shared_ptr<Encryptor> InternalFileEncryptor::getColumnMetaEncryptor(
+    const std::string& columnPath) {
+  return getColumnEncryptor(columnPath, true);
 }
 
-std::shared_ptr<Encryptor> InternalFileEncryptor::GetColumnDataEncryptor(
-    const std::string& column_path) {
-  return GetColumnEncryptor(column_path, false);
+std::shared_ptr<Encryptor> InternalFileEncryptor::getColumnDataEncryptor(
+    const std::string& columnPath) {
+  return getColumnEncryptor(columnPath, false);
 }
 
 std::shared_ptr<Encryptor>
-InternalFileEncryptor::InternalFileEncryptor::GetColumnEncryptor(
-    const std::string& column_path,
+InternalFileEncryptor::InternalFileEncryptor::getColumnEncryptor(
+    const std::string& columnPath,
     bool metadata) {
-  // first look if we already got the encryptor from before
+  // First look if we already got the encryptor from before.
   if (metadata) {
-    if (column_metadata_map_.find(column_path) != column_metadata_map_.end()) {
-      return column_metadata_map_.at(column_path);
+    if (columnMetadataMap_.find(columnPath) != columnMetadataMap_.end()) {
+      return columnMetadataMap_.at(columnPath);
     }
   } else {
-    if (column_data_map_.find(column_path) != column_data_map_.end()) {
-      return column_data_map_.at(column_path);
+    if (columnDataMap_.find(columnPath) != columnDataMap_.end()) {
+      return columnDataMap_.at(columnPath);
     }
   }
-  auto column_prop = properties_->column_encryption_properties(column_path);
-  if (column_prop == nullptr) {
+  auto columnProp = properties_->columnEncryptionProperties(columnPath);
+  if (columnProp == nullptr) {
     return nullptr;
   }
 
   std::string key;
-  if (column_prop->is_encrypted_with_footer_key()) {
-    key = properties_->footer_key();
+  if (columnProp->isEncryptedWithFooterKey()) {
+    key = properties_->footerKey();
   } else {
-    key = column_prop->key();
+    key = columnProp->key();
   }
 
   ParquetCipher::type algorithm = properties_->algorithm().algorithm;
-  auto aes_encryptor = metadata ? GetMetaAesEncryptor(algorithm, key.size())
-                                : GetDataAesEncryptor(algorithm, key.size());
+  auto aesEncryptor = metadata ? getMetaAesEncryptor(algorithm, key.size())
+                               : getDataAesEncryptor(algorithm, key.size());
 
-  std::string file_aad = properties_->file_aad();
+  std::string fileAad = properties_->fileAad();
   std::shared_ptr<Encryptor> encryptor =
-      std::make_shared<Encryptor>(aes_encryptor, key, file_aad, "", pool_);
+      std::make_shared<Encryptor>(aesEncryptor, key, fileAad, "", pool_);
   if (metadata)
-    column_metadata_map_[column_path] = encryptor;
+    columnMetadataMap_[columnPath] = encryptor;
   else
-    column_data_map_[column_path] = encryptor;
+    columnDataMap_[columnPath] = encryptor;
 
   return encryptor;
 }
 
-int InternalFileEncryptor::MapKeyLenToEncryptorArrayIndex(int key_len) {
-  if (key_len == 16)
+int InternalFileEncryptor::mapKeyLenToEncryptorArrayIndex(int keyLen) {
+  if (keyLen == 16)
     return 0;
-  else if (key_len == 24)
+  else if (keyLen == 24)
     return 1;
-  else if (key_len == 32)
+  else if (keyLen == 32)
     return 2;
   throw ParquetException("encryption key must be 16, 24 or 32 bytes in length");
 }
 
-encryption::AesEncryptor* InternalFileEncryptor::GetMetaAesEncryptor(
+encryption::AesEncryptor* InternalFileEncryptor::getMetaAesEncryptor(
     ParquetCipher::type algorithm,
-    size_t key_size) {
-  int key_len = static_cast<int>(key_size);
-  int index = MapKeyLenToEncryptorArrayIndex(key_len);
-  if (meta_encryptor_[index] == nullptr) {
-    meta_encryptor_[index].reset(encryption::AesEncryptor::Make(
-        algorithm, key_len, true, &all_encryptors_));
+    size_t keySize) {
+  int keyLen = static_cast<int>(keySize);
+  int index = mapKeyLenToEncryptorArrayIndex(keyLen);
+  if (metaEncryptor_[index] == nullptr) {
+    metaEncryptor_[index].reset(
+        encryption::AesEncryptor::make(
+            algorithm, keyLen, true, &allEncryptors_));
   }
-  return meta_encryptor_[index].get();
+  return metaEncryptor_[index].get();
 }
 
-encryption::AesEncryptor* InternalFileEncryptor::GetDataAesEncryptor(
+encryption::AesEncryptor* InternalFileEncryptor::getDataAesEncryptor(
     ParquetCipher::type algorithm,
-    size_t key_size) {
-  int key_len = static_cast<int>(key_size);
-  int index = MapKeyLenToEncryptorArrayIndex(key_len);
-  if (data_encryptor_[index] == nullptr) {
-    data_encryptor_[index].reset(encryption::AesEncryptor::Make(
-        algorithm, key_len, false, &all_encryptors_));
+    size_t keySize) {
+  int keyLen = static_cast<int>(keySize);
+  int index = mapKeyLenToEncryptorArrayIndex(keyLen);
+  if (dataEncryptor_[index] == nullptr) {
+    dataEncryptor_[index].reset(
+        encryption::AesEncryptor::make(
+            algorithm, keyLen, false, &allEncryptors_));
   }
-  return data_encryptor_[index].get();
+  return dataEncryptor_[index].get();
 }
 
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/FileEncryptorInternal.h b/velox/dwio/parquet/writer/arrow/FileEncryptorInternal.h
index 39f6be4b0e1..eac13b5d2c4 100644
--- a/velox/dwio/parquet/writer/arrow/FileEncryptorInternal.h
+++ b/velox/dwio/parquet/writer/arrow/FileEncryptorInternal.h
@@ -38,44 +38,44 @@ class ColumnEncryptionProperties;
 class PARQUET_EXPORT Encryptor {
  public:
   Encryptor(
-      encryption::AesEncryptor* aes_encryptor,
+      encryption::AesEncryptor* aesEncryptor,
       const std::string& key,
-      const std::string& file_aad,
+      const std::string& fileAad,
       const std::string& aad,
       ::arrow::MemoryPool* pool);
-  const std::string& file_aad() {
-    return file_aad_;
+  const std::string& fileAad() {
+    return fileAad_;
   }
-  void UpdateAad(const std::string& aad) {
+  void updateAad(const std::string& aad) {
     aad_ = aad;
   }
   ::arrow::MemoryPool* pool() {
     return pool_;
   }
 
-  int CiphertextSizeDelta();
-  int Encrypt(const uint8_t* plaintext, int plaintext_len, uint8_t* ciphertext);
+  int ciphertextSizeDelta();
+  int encrypt(const uint8_t* plaintext, int plaintextLen, uint8_t* ciphertext);
 
-  bool EncryptColumnMetaData(
-      bool encrypted_footer,
+  bool encryptColumnMetaData(
+      bool encryptedFooter,
       const std::shared_ptr<ColumnEncryptionProperties>&
-          column_encryption_properties) {
-    // if column is not encrypted then do not encrypt the column metadata
-    if (!column_encryption_properties ||
-        !column_encryption_properties->is_encrypted())
+          ColumnEncryptionProperties) {
+    // If column is not encrypted then do not encrypt the column metadata.
+    if (!ColumnEncryptionProperties ||
+        !ColumnEncryptionProperties->isEncrypted())
       return false;
-    // if plaintext footer then encrypt the column metadata
-    if (!encrypted_footer)
+    // If plaintext footer then encrypt the column metadata.
+    if (!encryptedFooter)
       return true;
-    // if column is not encrypted with footer key then encrypt the column
-    // metadata
-    return !column_encryption_properties->is_encrypted_with_footer_key();
+    // If column is not encrypted with footer key then encrypt the column.
+    // Metadata.
+    return !ColumnEncryptionProperties->isEncryptedWithFooterKey();
   }
 
  private:
-  encryption::AesEncryptor* aes_encryptor_;
+  encryption::AesEncryptor* aesEncryptor_;
   std::string key_;
-  std::string file_aad_;
+  std::string fileAad_;
   std::string aad_;
   ::arrow::MemoryPool* pool_;
 };
@@ -86,44 +86,44 @@ class InternalFileEncryptor {
       FileEncryptionProperties* properties,
       ::arrow::MemoryPool* pool);
 
-  std::shared_ptr<Encryptor> GetFooterEncryptor();
-  std::shared_ptr<Encryptor> GetFooterSigningEncryptor();
-  std::shared_ptr<Encryptor> GetColumnMetaEncryptor(
-      const std::string& column_path);
-  std::shared_ptr<Encryptor> GetColumnDataEncryptor(
-      const std::string& column_path);
-  void WipeOutEncryptionKeys();
+  std::shared_ptr<Encryptor> getFooterEncryptor();
+  std::shared_ptr<Encryptor> getFooterSigningEncryptor();
+  std::shared_ptr<Encryptor> getColumnMetaEncryptor(
+      const std::string& ColumnPath);
+  std::shared_ptr<Encryptor> getColumnDataEncryptor(
+      const std::string& ColumnPath);
+  void wipeOutEncryptionKeys();
 
  private:
   FileEncryptionProperties* properties_;
 
-  std::map<std::string, std::shared_ptr<Encryptor>> column_data_map_;
-  std::map<std::string, std::shared_ptr<Encryptor>> column_metadata_map_;
+  std::map<std::string, std::shared_ptr<Encryptor>> columnDataMap_;
+  std::map<std::string, std::shared_ptr<Encryptor>> columnMetadataMap_;
 
-  std::shared_ptr<Encryptor> footer_signing_encryptor_;
-  std::shared_ptr<Encryptor> footer_encryptor_;
+  std::shared_ptr<Encryptor> footerSigningEncryptor_;
+  std::shared_ptr<Encryptor> footerEncryptor_;
 
-  std::vector<encryption::AesEncryptor*> all_encryptors_;
+  std::vector<encryption::AesEncryptor*> allEncryptors_;
 
-  // Key must be 16, 24 or 32 bytes in length. Thus there could be up to three
-  // types of meta_encryptors and data_encryptors.
-  std::unique_ptr<encryption::AesEncryptor> meta_encryptor_[3];
-  std::unique_ptr<encryption::AesEncryptor> data_encryptor_[3];
+  // Key must be 16, 24 or 32 bytes in length. Thus there could be up to three.
+  // Types of meta_encryptors and data_encryptors.
+  std::unique_ptr<encryption::AesEncryptor> metaEncryptor_[3];
+  std::unique_ptr<encryption::AesEncryptor> dataEncryptor_[3];
 
   ::arrow::MemoryPool* pool_;
 
-  std::shared_ptr<Encryptor> GetColumnEncryptor(
-      const std::string& column_path,
+  std::shared_ptr<Encryptor> getColumnEncryptor(
+      const std::string& ColumnPath,
       bool metadata);
 
-  encryption::AesEncryptor* GetMetaAesEncryptor(
+  encryption::AesEncryptor* getMetaAesEncryptor(
       ParquetCipher::type algorithm,
-      size_t key_len);
-  encryption::AesEncryptor* GetDataAesEncryptor(
+      size_t keyLen);
+  encryption::AesEncryptor* getDataAesEncryptor(
       ParquetCipher::type algorithm,
-      size_t key_len);
+      size_t keyLen);
 
-  int MapKeyLenToEncryptorArrayIndex(int key_len);
+  int mapKeyLenToEncryptorArrayIndex(int keyLen);
 };
 
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/FileWriter.cpp b/velox/dwio/parquet/writer/arrow/FileWriter.cpp
index ea89c4838eb..3e2e49e6e8f 100644
--- a/velox/dwio/parquet/writer/arrow/FileWriter.cpp
+++ b/velox/dwio/parquet/writer/arrow/FileWriter.cpp
@@ -41,256 +41,254 @@ namespace facebook::velox::parquet::arrow {
 
 using schema::GroupNode;
 
-// ----------------------------------------------------------------------
-// RowGroupWriter public API
+// ----------------------------------------------------------------------.
+// RowGroupWriter public API.
 
 RowGroupWriter::RowGroupWriter(std::unique_ptr<Contents> contents)
     : contents_(std::move(contents)) {}
 
-void RowGroupWriter::Close() {
+void RowGroupWriter::close() {
   if (contents_) {
-    contents_->Close();
+    contents_->close();
   }
 }
 
-ColumnWriter* RowGroupWriter::NextColumn() {
-  return contents_->NextColumn();
+ColumnWriter* RowGroupWriter::nextColumn() {
+  return contents_->nextColumn();
 }
 
 ColumnWriter* RowGroupWriter::column(int i) {
   return contents_->column(i);
 }
 
-int64_t RowGroupWriter::total_compressed_bytes() const {
-  return contents_->total_compressed_bytes();
+int64_t RowGroupWriter::totalCompressedBytes() const {
+  return contents_->totalCompressedBytes();
 }
 
-int64_t RowGroupWriter::total_bytes_written() const {
-  return contents_->total_bytes_written();
+int64_t RowGroupWriter::totalBytesWritten() const {
+  return contents_->totalBytesWritten();
 }
 
-int64_t RowGroupWriter::total_compressed_bytes_written() const {
-  return contents_->total_compressed_bytes_written();
+int64_t RowGroupWriter::totalCompressedBytesWritten() const {
+  return contents_->totalCompressedBytesWritten();
 }
 
 bool RowGroupWriter::buffered() const {
   return contents_->buffered();
 }
 
-int RowGroupWriter::current_column() {
-  return contents_->current_column();
+int RowGroupWriter::currentColumn() {
+  return contents_->currentColumn();
 }
 
-int RowGroupWriter::num_columns() const {
-  return contents_->num_columns();
+int RowGroupWriter::numColumns() const {
+  return contents_->numColumns();
 }
 
-int64_t RowGroupWriter::num_rows() const {
-  return contents_->num_rows();
+int64_t RowGroupWriter::numRows() const {
+  return contents_->numRows();
 }
 
-inline void ThrowRowsMisMatchError(int col, int64_t prev, int64_t curr) {
+inline void throwRowsMisMatchError(int col, int64_t prev, int64_t curr) {
   std::stringstream ss;
   ss << "Column " << col << " had " << curr << " while previous column had "
      << prev;
   throw ParquetException(ss.str());
 }
 
-// ----------------------------------------------------------------------
-// RowGroupSerializer
+// ----------------------------------------------------------------------.
+// RowGroupSerializer.
 
-// RowGroupWriter::Contents implementation for the Parquet file specification
+// RowGroupWriter::Contents implementation for the Parquet file specification.
 class RowGroupSerializer : public RowGroupWriter::Contents {
  public:
   RowGroupSerializer(
       std::shared_ptr<ArrowOutputStream> sink,
       RowGroupMetaDataBuilder* metadata,
-      int16_t row_group_ordinal,
+      int16_t rowGroupOrdinal,
       const WriterProperties* properties,
-      bool buffered_row_group = false,
-      InternalFileEncryptor* file_encryptor = nullptr,
-      PageIndexBuilder* page_index_builder = nullptr)
+      bool bufferedRowGroup = false,
+      InternalFileEncryptor* fileEncryptor = nullptr,
+      PageIndexBuilder* pageIndexBuilder = nullptr)
       : sink_(std::move(sink)),
         metadata_(metadata),
         properties_(properties),
-        total_bytes_written_(0),
-        total_compressed_bytes_written_(0),
+        totalBytesWritten_(0),
+        totalCompressedBytesWritten_(0),
         closed_(false),
-        row_group_ordinal_(row_group_ordinal),
-        next_column_index_(0),
-        num_rows_(0),
-        buffered_row_group_(buffered_row_group),
-        file_encryptor_(file_encryptor),
-        page_index_builder_(page_index_builder) {
-    if (buffered_row_group) {
-      InitColumns();
+        rowGroupOrdinal_(rowGroupOrdinal),
+        nextColumnIndex_(0),
+        numRows_(0),
+        bufferedRowGroup_(bufferedRowGroup),
+        fileEncryptor_(fileEncryptor),
+        pageIndexBuilder_(pageIndexBuilder) {
+    if (bufferedRowGroup) {
+      initColumns();
     } else {
-      column_writers_.push_back(nullptr);
+      columnWriters_.push_back(nullptr);
     }
   }
 
-  int num_columns() const override {
-    return metadata_->num_columns();
+  int numColumns() const override {
+    return metadata_->numColumns();
   }
 
-  int64_t num_rows() const override {
-    CheckRowsWritten();
-    // CheckRowsWritten ensures num_rows_ is set correctly
-    return num_rows_;
+  int64_t numRows() const override {
+    checkRowsWritten();
+    // checkRowsWritten() ensures numRows_ is set correctly.
+    return numRows_;
   }
 
-  ColumnWriter* NextColumn() override {
-    if (buffered_row_group_) {
+  ColumnWriter* nextColumn() override {
+    if (bufferedRowGroup_) {
       throw ParquetException(
-          "NextColumn() is not supported when a RowGroup is written by size");
+          "nextColumn() is not supported when a RowGroup is written by size");
     }
 
-    if (column_writers_[0]) {
-      CheckRowsWritten();
+    if (columnWriters_[0]) {
+      checkRowsWritten();
     }
 
-    // Throws an error if more columns are being written
-    auto col_meta = metadata_->NextColumnChunk();
+    // Throws an error if more columns are being written.
+    auto colMeta = metadata_->nextColumnChunk();
 
-    if (column_writers_[0]) {
-      total_bytes_written_ += column_writers_[0]->Close();
-      total_compressed_bytes_written_ +=
-          column_writers_[0]->total_compressed_bytes_written();
+    if (columnWriters_[0]) {
+      totalBytesWritten_ += columnWriters_[0]->close();
+      totalCompressedBytesWritten_ +=
+          columnWriters_[0]->totalCompressedBytesWritten();
     }
 
-    const int32_t column_ordinal = next_column_index_++;
-    const auto& path = col_meta->descr()->path();
-    auto meta_encryptor = file_encryptor_
-        ? file_encryptor_->GetColumnMetaEncryptor(path->ToDotString())
+    const int32_t columnOrdinal = nextColumnIndex_++;
+    const auto& path = colMeta->descr()->path();
+    auto metaEncryptor = fileEncryptor_
+        ? fileEncryptor_->getColumnMetaEncryptor(path->toDotString())
         : nullptr;
-    auto data_encryptor = file_encryptor_
-        ? file_encryptor_->GetColumnDataEncryptor(path->ToDotString())
+    auto dataEncryptor = fileEncryptor_
+        ? fileEncryptor_->getColumnDataEncryptor(path->toDotString())
         : nullptr;
-    auto ci_builder = page_index_builder_ &&
-            properties_->page_index_enabled(path) &&
-            properties_->statistics_enabled(path)
-        ? page_index_builder_->GetColumnIndexBuilder(column_ordinal)
+    auto ciBuilder = pageIndexBuilder_ && properties_->pageIndexEnabled(path) &&
+            properties_->statisticsEnabled(path)
+        ? pageIndexBuilder_->getColumnIndexBuilder(columnOrdinal)
         : nullptr;
-    auto oi_builder =
-        page_index_builder_ && properties_->page_index_enabled(path)
-        ? page_index_builder_->GetOffsetIndexBuilder(column_ordinal)
+    auto oiBuilder = pageIndexBuilder_ && properties_->pageIndexEnabled(path)
+        ? pageIndexBuilder_->getOffsetIndexBuilder(columnOrdinal)
         : nullptr;
-    auto codec_options = properties_->codec_options(path)
-        ? properties_->codec_options(path).get()
+    auto codecOptions = properties_->codecOptions(path)
+        ? properties_->codecOptions(path).get()
         : nullptr;
 
     std::unique_ptr<PageWriter> pager;
-    if (!codec_options) {
-      pager = PageWriter::Open(
+    if (!codecOptions) {
+      pager = PageWriter::open(
           sink_,
           properties_->compression(path),
-          col_meta,
-          row_group_ordinal_,
-          static_cast<int16_t>(column_ordinal),
-          properties_->memory_pool(),
+          colMeta,
+          rowGroupOrdinal_,
+          static_cast<int16_t>(columnOrdinal),
+          properties_->memoryPool(),
           false,
-          meta_encryptor,
-          data_encryptor,
-          properties_->page_checksum_enabled(),
-          ci_builder,
-          oi_builder,
+          metaEncryptor,
+          dataEncryptor,
+          properties_->pageChecksumEnabled(),
+          ciBuilder,
+          oiBuilder,
           CodecOptions());
     } else {
-      pager = PageWriter::Open(
+      pager = PageWriter::open(
           sink_,
           properties_->compression(path),
-          col_meta,
-          row_group_ordinal_,
-          static_cast<int16_t>(column_ordinal),
-          properties_->memory_pool(),
+          colMeta,
+          rowGroupOrdinal_,
+          static_cast<int16_t>(columnOrdinal),
+          properties_->memoryPool(),
           false,
-          meta_encryptor,
-          data_encryptor,
-          properties_->page_checksum_enabled(),
-          ci_builder,
-          oi_builder,
-          *codec_options);
+          metaEncryptor,
+          dataEncryptor,
+          properties_->pageChecksumEnabled(),
+          ciBuilder,
+          oiBuilder,
+          *codecOptions);
     }
-    column_writers_[0] =
-        ColumnWriter::Make(col_meta, std::move(pager), properties_);
-    return column_writers_[0].get();
+    columnWriters_[0] =
+        ColumnWriter::make(colMeta, std::move(pager), properties_);
+    return columnWriters_[0].get();
   }
 
   ColumnWriter* column(int i) override {
-    if (!buffered_row_group_) {
+    if (!bufferedRowGroup_) {
       throw ParquetException(
           "column() is only supported when a BufferedRowGroup is being written");
     }
 
-    if (i >= 0 && i < static_cast<int>(column_writers_.size())) {
-      return column_writers_[i].get();
+    if (i >= 0 && i < static_cast<int>(columnWriters_.size())) {
+      return columnWriters_[i].get();
     }
     return nullptr;
   }
 
-  int current_column() const override {
-    return metadata_->current_column();
+  int currentColumn() const override {
+    return metadata_->currentColumn();
   }
 
-  int64_t total_compressed_bytes() const override {
-    int64_t total_compressed_bytes = 0;
-    for (size_t i = 0; i < column_writers_.size(); i++) {
-      if (column_writers_[i]) {
-        total_compressed_bytes += column_writers_[i]->total_compressed_bytes();
+  int64_t totalCompressedBytes() const override {
+    int64_t totalCompressedBytes = 0;
+    for (size_t i = 0; i < columnWriters_.size(); i++) {
+      if (columnWriters_[i]) {
+        totalCompressedBytes += columnWriters_[i]->totalCompressedBytes();
       }
     }
-    return total_compressed_bytes;
+    return totalCompressedBytes;
   }
 
-  int64_t total_bytes_written() const override {
+  int64_t totalBytesWritten() const override {
     if (closed_) {
-      return total_bytes_written_;
+      return totalBytesWritten_;
     }
-    int64_t total_bytes_written = 0;
-    for (size_t i = 0; i < column_writers_.size(); i++) {
-      if (column_writers_[i]) {
-        total_bytes_written += column_writers_[i]->total_bytes_written();
+    int64_t totalBytesWritten = 0;
+    for (size_t i = 0; i < columnWriters_.size(); i++) {
+      if (columnWriters_[i]) {
+        totalBytesWritten += columnWriters_[i]->totalBytesWritten();
       }
     }
-    return total_bytes_written;
+    return totalBytesWritten;
   }
 
-  int64_t total_compressed_bytes_written() const override {
+  int64_t totalCompressedBytesWritten() const override {
     if (closed_) {
-      return total_compressed_bytes_written_;
+      return totalCompressedBytesWritten_;
     }
-    int64_t total_compressed_bytes_written = 0;
-    for (size_t i = 0; i < column_writers_.size(); i++) {
-      if (column_writers_[i]) {
-        total_compressed_bytes_written +=
-            column_writers_[i]->total_compressed_bytes_written();
+    int64_t totalCompressedBytesWritten = 0;
+    for (size_t i = 0; i < columnWriters_.size(); i++) {
+      if (columnWriters_[i]) {
+        totalCompressedBytesWritten +=
+            columnWriters_[i]->totalCompressedBytesWritten();
       }
     }
-    return total_compressed_bytes_written;
+    return totalCompressedBytesWritten;
   }
 
   bool buffered() const override {
-    return buffered_row_group_;
+    return bufferedRowGroup_;
   }
 
-  void Close() override {
+  void close() override {
     if (!closed_) {
       closed_ = true;
-      CheckRowsWritten();
-
-      // Avoid invalid state if ColumnWriter::Close() throws internally.
-      auto column_writers = std::move(column_writers_);
-      for (size_t i = 0; i < column_writers.size(); i++) {
-        if (column_writers[i]) {
-          total_bytes_written_ += column_writers[i]->Close();
-          total_compressed_bytes_written_ +=
-              column_writers[i]->total_compressed_bytes_written();
+      checkRowsWritten();
+
+      // Avoid invalid state if ColumnWriter::close() throws internally.
+      auto columnWriters = std::move(columnWriters_);
+      for (size_t i = 0; i < columnWriters.size(); i++) {
+        if (columnWriters[i]) {
+          totalBytesWritten_ += columnWriters[i]->close();
+          totalCompressedBytesWritten_ +=
+              columnWriters[i]->totalCompressedBytesWritten();
         }
       }
 
-      // Ensures all columns have been written
-      metadata_->set_num_rows(num_rows_);
-      metadata_->Finish(total_bytes_written_, row_group_ordinal_);
+      // Ensures all columns have been written.
+      metadata_->setNumRows(numRows_);
+      metadata_->finish(totalBytesWritten_, rowGroupOrdinal_);
     }
   }
 
@@ -298,212 +296,204 @@ class RowGroupSerializer : public RowGroupWriter::Contents {
   std::shared_ptr<ArrowOutputStream> sink_;
   mutable RowGroupMetaDataBuilder* metadata_;
   const WriterProperties* properties_;
-  int64_t total_bytes_written_;
-  int64_t total_compressed_bytes_written_;
+  int64_t totalBytesWritten_;
+  int64_t totalCompressedBytesWritten_;
   bool closed_;
-  int16_t row_group_ordinal_;
-  int next_column_index_;
-  mutable int64_t num_rows_;
-  bool buffered_row_group_;
-  InternalFileEncryptor* file_encryptor_;
-  PageIndexBuilder* page_index_builder_;
-
-  void CheckRowsWritten() const {
-    // verify when only one column is written at a time
-    if (!buffered_row_group_ && column_writers_.size() > 0 &&
-        column_writers_[0]) {
-      int64_t current_col_rows = column_writers_[0]->rows_written();
-      if (num_rows_ == 0) {
-        num_rows_ = current_col_rows;
-      } else if (num_rows_ != current_col_rows) {
-        ThrowRowsMisMatchError(next_column_index_, current_col_rows, num_rows_);
+  int16_t rowGroupOrdinal_;
+  int nextColumnIndex_;
+  mutable int64_t numRows_;
+  bool bufferedRowGroup_;
+  InternalFileEncryptor* fileEncryptor_;
+  PageIndexBuilder* pageIndexBuilder_;
+
+  void checkRowsWritten() const {
+    // Verify when only one column is written at a time.
+    if (!bufferedRowGroup_ && columnWriters_.size() > 0 && columnWriters_[0]) {
+      int64_t currentColRows = columnWriters_[0]->rowsWritten();
+      if (numRows_ == 0) {
+        numRows_ = currentColRows;
+      } else if (numRows_ != currentColRows) {
+        throwRowsMisMatchError(nextColumnIndex_, currentColRows, numRows_);
       }
-    } else if (
-        buffered_row_group_ &&
-        column_writers_.size() > 0) { // when
-                                      // buffered_row_group
-                                      // = true
-      VELOX_DCHECK_NOT_NULL(column_writers_[0]);
-      int64_t current_col_rows = column_writers_[0]->rows_written();
-      for (int i = 1; i < static_cast<int>(column_writers_.size()); i++) {
-        VELOX_DCHECK_NOT_NULL(column_writers_[i]);
-        int64_t current_col_rows_i = column_writers_[i]->rows_written();
-        if (current_col_rows != current_col_rows_i) {
-          ThrowRowsMisMatchError(i, current_col_rows_i, current_col_rows);
+    } else if (bufferedRowGroup_ && columnWriters_.size() > 0) {
+      // When bufferedRowGroup = true.
+      VELOX_DCHECK_NOT_NULL(columnWriters_[0]);
+      int64_t currentColRows = columnWriters_[0]->rowsWritten();
+      for (int i = 1; i < static_cast<int>(columnWriters_.size()); i++) {
+        VELOX_DCHECK_NOT_NULL(columnWriters_[i]);
+        int64_t currentColRowsI = columnWriters_[i]->rowsWritten();
+        if (currentColRows != currentColRowsI) {
+          throwRowsMisMatchError(i, currentColRowsI, currentColRows);
         }
       }
-      num_rows_ = current_col_rows;
+      numRows_ = currentColRows;
     }
   }
 
-  void InitColumns() {
-    for (int i = 0; i < num_columns(); i++) {
-      auto col_meta = metadata_->NextColumnChunk();
-      const auto& path = col_meta->descr()->path();
-      const int32_t column_ordinal = next_column_index_++;
-      auto meta_encryptor = file_encryptor_
-          ? file_encryptor_->GetColumnMetaEncryptor(path->ToDotString())
-          : nullptr;
-      auto data_encryptor = file_encryptor_
-          ? file_encryptor_->GetColumnDataEncryptor(path->ToDotString())
+  void initColumns() {
+    for (int i = 0; i < numColumns(); i++) {
+      auto colMeta = metadata_->nextColumnChunk();
+      const auto& path = colMeta->descr()->path();
+      const int32_t columnOrdinal = nextColumnIndex_++;
+      auto metaEncryptor = fileEncryptor_
+          ? fileEncryptor_->getColumnMetaEncryptor(path->toDotString())
           : nullptr;
-      auto ci_builder =
-          page_index_builder_ && properties_->page_index_enabled(path)
-          ? page_index_builder_->GetColumnIndexBuilder(column_ordinal)
+      auto dataEncryptor = fileEncryptor_
+          ? fileEncryptor_->getColumnDataEncryptor(path->toDotString())
           : nullptr;
-      auto oi_builder =
-          page_index_builder_ && properties_->page_index_enabled(path)
-          ? page_index_builder_->GetOffsetIndexBuilder(column_ordinal)
+      auto ciBuilder = pageIndexBuilder_ && properties_->pageIndexEnabled(path)
+          ? pageIndexBuilder_->getColumnIndexBuilder(columnOrdinal)
           : nullptr;
-      auto codec_options = properties_->codec_options(path)
-          ? (properties_->codec_options(path)).get()
+      auto oiBuilder = pageIndexBuilder_ && properties_->pageIndexEnabled(path)
+          ? pageIndexBuilder_->getOffsetIndexBuilder(columnOrdinal)
           : nullptr;
+      auto codecOptions = properties_->codecOptions(path);
 
       std::unique_ptr<PageWriter> pager;
-      if (!codec_options) {
-        pager = PageWriter::Open(
+      if (!codecOptions) {
+        pager = PageWriter::open(
             sink_,
             properties_->compression(path),
-            col_meta,
-            row_group_ordinal_,
-            static_cast<int16_t>(column_ordinal),
-            properties_->memory_pool(),
-            buffered_row_group_,
-            meta_encryptor,
-            data_encryptor,
-            properties_->page_checksum_enabled(),
-            ci_builder,
-            oi_builder,
+            colMeta,
+            rowGroupOrdinal_,
+            static_cast<int16_t>(columnOrdinal),
+            properties_->memoryPool(),
+            bufferedRowGroup_,
+            metaEncryptor,
+            dataEncryptor,
+            properties_->pageChecksumEnabled(),
+            ciBuilder,
+            oiBuilder,
             CodecOptions());
       } else {
-        pager = PageWriter::Open(
+        pager = PageWriter::open(
             sink_,
             properties_->compression(path),
-            col_meta,
-            row_group_ordinal_,
-            static_cast<int16_t>(column_ordinal),
-            properties_->memory_pool(),
-            buffered_row_group_,
-            meta_encryptor,
-            data_encryptor,
-            properties_->page_checksum_enabled(),
-            ci_builder,
-            oi_builder,
-            *codec_options);
+            colMeta,
+            rowGroupOrdinal_,
+            static_cast<int16_t>(columnOrdinal),
+            properties_->memoryPool(),
+            bufferedRowGroup_,
+            metaEncryptor,
+            dataEncryptor,
+            properties_->pageChecksumEnabled(),
+            ciBuilder,
+            oiBuilder,
+            *codecOptions);
       }
-      column_writers_.push_back(
-          ColumnWriter::Make(col_meta, std::move(pager), properties_));
+      columnWriters_.push_back(
+          ColumnWriter::make(colMeta, std::move(pager), properties_));
     }
   }
 
-  std::vector<std::shared_ptr<ColumnWriter>> column_writers_;
+  std::vector<std::shared_ptr<ColumnWriter>> columnWriters_;
 };
 
 // ----------------------------------------------------------------------
-// FileSerializer
+// FileSerializer.
 
 // An implementation of ParquetFileWriter::Contents that deals with the Parquet
-// file structure, Thrift serialization, and other internal matters
+// file structure, Thrift serialization, and other internal matters.
 
 class FileSerializer : public ParquetFileWriter::Contents {
  public:
-  static std::unique_ptr<ParquetFileWriter::Contents> Open(
+  static std::unique_ptr<ParquetFileWriter::Contents> open(
       std::shared_ptr<ArrowOutputStream> sink,
       std::shared_ptr<GroupNode> schema,
       std::shared_ptr<WriterProperties> properties,
-      std::shared_ptr<const KeyValueMetadata> key_value_metadata) {
+      std::shared_ptr<const KeyValueMetadata> keyValueMetadata) {
     std::unique_ptr<ParquetFileWriter::Contents> result(new FileSerializer(
         std::move(sink),
         std::move(schema),
         std::move(properties),
-        std::move(key_value_metadata)));
+        std::move(keyValueMetadata)));
 
     return result;
   }
 
-  void Close() override {
-    if (is_open_) {
-      // If any functions here raise an exception, we set is_open_ to be false
-      // so that this does not get called again (possibly causing segfault)
-      is_open_ = false;
-      if (row_group_writer_) {
-        num_rows_ += row_group_writer_->num_rows();
-        row_group_writer_->Close();
+  void close() override {
+    if (isOpen_) {
+      // If any functions here raise an exception, we set isOpen_ to be false
+      // so that this does not get called again (possibly causing segfault).
+      isOpen_ = false;
+      if (rowGroupWriter_) {
+        numRows_ += rowGroupWriter_->numRows();
+        rowGroupWriter_->close();
       }
-      row_group_writer_.reset();
+      rowGroupWriter_.reset();
 
-      WritePageIndex();
+      writePageIndex();
 
-      // Write magic bytes and metadata
-      auto file_encryption_properties =
-          properties_->file_encryption_properties();
+      // Write magic bytes and metadata.
+      auto fileEncryptionProperties = properties_->fileEncryptionProperties();
 
-      if (file_encryption_properties == nullptr) { // Non encrypted file.
-        file_metadata_ = metadata_->Finish(key_value_metadata_);
-        WriteFileMetaData(*file_metadata_, sink_.get());
-      } else { // Encrypted file
-        CloseEncryptedFile(file_encryption_properties);
+      if (fileEncryptionProperties == nullptr) { // Non encrypted file.
+        fileMetadata_ = metadata_->finish(keyValueMetadata_);
+        writeFileMetaData(*fileMetadata_, sink_.get());
+      } else { // Encrypted file.
+        closeEncryptedFile(fileEncryptionProperties);
       }
     }
   }
 
-  int num_columns() const override {
-    return schema_.num_columns();
+  int numColumns() const override {
+    return schema_.numColumns();
   }
 
-  int num_row_groups() const override {
-    return num_row_groups_;
+  int numRowGroups() const override {
+    return numRowGroups_;
   }
 
-  int64_t num_rows() const override {
-    return num_rows_;
+  int64_t numRows() const override {
+    return numRows_;
   }
 
   const std::shared_ptr<WriterProperties>& properties() const override {
     return properties_;
   }
 
-  RowGroupWriter* AppendRowGroup(bool buffered_row_group) {
-    if (row_group_writer_) {
-      row_group_writer_->Close();
+  RowGroupWriter* appendRowGroup(bool bufferedRowGroup) {
+    if (rowGroupWriter_) {
+      rowGroupWriter_->close();
     }
-    num_row_groups_++;
-    auto rg_metadata = metadata_->AppendRowGroup();
-    if (page_index_builder_) {
-      page_index_builder_->AppendRowGroup();
+    numRowGroups_++;
+    auto rgMetadata = metadata_->appendRowGroup();
+    if (pageIndexBuilder_) {
+      pageIndexBuilder_->appendRowGroup();
     }
     std::unique_ptr<RowGroupWriter::Contents> contents(new RowGroupSerializer(
         sink_,
-        rg_metadata,
-        static_cast<int16_t>(num_row_groups_ - 1),
+        rgMetadata,
+        static_cast<int16_t>(numRowGroups_ - 1),
         properties_.get(),
-        buffered_row_group,
-        file_encryptor_.get(),
-        page_index_builder_.get()));
-    row_group_writer_ = std::make_unique<RowGroupWriter>(std::move(contents));
-    return row_group_writer_.get();
+        bufferedRowGroup,
+        fileEncryptor_.get(),
+        pageIndexBuilder_.get()));
+    rowGroupWriter_ = std::make_unique<RowGroupWriter>(std::move(contents));
+    return rowGroupWriter_.get();
   }
 
-  RowGroupWriter* AppendRowGroup() override {
-    return AppendRowGroup(false);
+  RowGroupWriter* appendRowGroup() override {
+    return appendRowGroup(false);
   }
 
-  RowGroupWriter* AppendBufferedRowGroup() override {
-    return AppendRowGroup(true);
+  RowGroupWriter* appendBufferedRowGroup() override {
+    return appendRowGroup(true);
   }
 
-  void AddKeyValueMetadata(const std::shared_ptr<const KeyValueMetadata>&
-                               key_value_metadata) override {
-    if (key_value_metadata_ == nullptr) {
-      key_value_metadata_ = key_value_metadata;
-    } else if (key_value_metadata != nullptr) {
-      key_value_metadata_ = key_value_metadata_->Merge(*key_value_metadata);
+  void addKeyValueMetadata(
+      const std::shared_ptr<const KeyValueMetadata>& keyValueMetadata)
+      override {
+    if (keyValueMetadata_ == nullptr) {
+      keyValueMetadata_ = keyValueMetadata;
+    } else if (keyValueMetadata != nullptr) {
+      keyValueMetadata_ = keyValueMetadata_->Merge(*keyValueMetadata);
     }
   }
 
   ~FileSerializer() override {
     try {
-      FileSerializer::Close();
+      FileSerializer::close();
     } catch (...) {
     }
   }
@@ -513,105 +503,103 @@ class FileSerializer : public ParquetFileWriter::Contents {
       std::shared_ptr<ArrowOutputStream> sink,
       std::shared_ptr<GroupNode> schema,
       std::shared_ptr<WriterProperties> properties,
-      std::shared_ptr<const KeyValueMetadata> key_value_metadata)
+      std::shared_ptr<const KeyValueMetadata> keyValueMetadata)
       : ParquetFileWriter::Contents(
             std::move(schema),
-            std::move(key_value_metadata)),
+            std::move(keyValueMetadata)),
         sink_(std::move(sink)),
-        is_open_(true),
+        isOpen_(true),
         properties_(std::move(properties)),
-        num_row_groups_(0),
-        num_rows_(0),
-        metadata_(FileMetaDataBuilder::Make(&schema_, properties_)) {
+        numRowGroups_(0),
+        numRows_(0),
+        metadata_(FileMetaDataBuilder::make(&schema_, properties_)) {
     PARQUET_ASSIGN_OR_THROW(int64_t position, sink_->Tell());
     if (position == 0) {
-      StartFile();
+      startFile();
     } else {
       throw ParquetException("Appending to file not implemented.");
     }
   }
 
-  void CloseEncryptedFile(
-      FileEncryptionProperties* file_encryption_properties) {
-    // Encrypted file with encrypted footer
-    if (file_encryption_properties->encrypted_footer()) {
-      // encrypted footer
-      file_metadata_ = metadata_->Finish(key_value_metadata_);
+  void closeEncryptedFile(FileEncryptionProperties* fileEncryptionProperties) {
+    // Encrypted file with encrypted footer.
+    if (fileEncryptionProperties->encryptedFooter()) {
+      // Encrypted footer.
+      fileMetadata_ = metadata_->finish(keyValueMetadata_);
 
       PARQUET_ASSIGN_OR_THROW(int64_t position, sink_->Tell());
-      uint64_t metadata_start = static_cast<uint64_t>(position);
-      auto crypto_metadata = metadata_->GetCryptoMetaData();
-      WriteFileCryptoMetaData(*crypto_metadata, sink_.get());
+      uint64_t metadataStart = static_cast<uint64_t>(position);
+      auto cryptoMetadata = metadata_->getCryptoMetaData();
+      writeFileCryptoMetaData(*cryptoMetadata, sink_.get());
 
-      auto footer_encryptor = file_encryptor_->GetFooterEncryptor();
-      WriteEncryptedFileMetadata(
-          *file_metadata_, sink_.get(), footer_encryptor, true);
+      auto footerEncryptor = fileEncryptor_->getFooterEncryptor();
+      writeEncryptedFileMetadata(
+          *fileMetadata_, sink_.get(), footerEncryptor, true);
       PARQUET_ASSIGN_OR_THROW(position, sink_->Tell());
-      uint32_t footer_and_crypto_len =
-          static_cast<uint32_t>(position - metadata_start);
+      uint32_t footerAndCryptoLen =
+          static_cast<uint32_t>(position - metadataStart);
       PARQUET_THROW_NOT_OK(
-          sink_->Write(reinterpret_cast<uint8_t*>(&footer_and_crypto_len), 4));
+          sink_->Write(reinterpret_cast<uint8_t*>(&footerAndCryptoLen), 4));
       PARQUET_THROW_NOT_OK(sink_->Write(kParquetEMagic, 4));
     } else { // Encrypted file with plaintext footer
-      file_metadata_ = metadata_->Finish(key_value_metadata_);
-      auto footer_signing_encryptor =
-          file_encryptor_->GetFooterSigningEncryptor();
-      WriteEncryptedFileMetadata(
-          *file_metadata_, sink_.get(), footer_signing_encryptor, false);
+      fileMetadata_ = metadata_->finish(keyValueMetadata_);
+      auto footerSigningEncryptor = fileEncryptor_->getFooterSigningEncryptor();
+      writeEncryptedFileMetadata(
+          *fileMetadata_, sink_.get(), footerSigningEncryptor, false);
     }
-    if (file_encryptor_) {
-      file_encryptor_->WipeOutEncryptionKeys();
+    if (fileEncryptor_) {
+      fileEncryptor_->wipeOutEncryptionKeys();
     }
   }
 
-  void WritePageIndex() {
-    if (page_index_builder_ != nullptr) {
-      if (properties_->file_encryption_properties()) {
+  void writePageIndex() {
+    if (pageIndexBuilder_ != nullptr) {
+      if (properties_->fileEncryptionProperties()) {
         throw ParquetException("Encryption is not supported with page index");
       }
 
       // Serialize page index after all row groups have been written and report
       // location to the file metadata.
-      PageIndexLocation page_index_location;
-      page_index_builder_->Finish();
-      page_index_builder_->WriteTo(sink_.get(), &page_index_location);
-      metadata_->SetPageIndexLocation(page_index_location);
+      PageIndexLocation pageIndexLocation;
+      pageIndexBuilder_->finish();
+      pageIndexBuilder_->writeTo(sink_.get(), &pageIndexLocation);
+      metadata_->setPageIndexLocation(pageIndexLocation);
     }
   }
 
   std::shared_ptr<ArrowOutputStream> sink_;
-  bool is_open_;
+  bool isOpen_;
   const std::shared_ptr<WriterProperties> properties_;
-  int num_row_groups_;
-  int64_t num_rows_;
+  int numRowGroups_;
+  int64_t numRows_;
   std::unique_ptr<FileMetaDataBuilder> metadata_;
-  // Only one of the row group writers is active at a time
-  std::unique_ptr<RowGroupWriter> row_group_writer_;
-  std::unique_ptr<PageIndexBuilder> page_index_builder_;
-  std::unique_ptr<InternalFileEncryptor> file_encryptor_;
-
-  void StartFile() {
-    auto file_encryption_properties = properties_->file_encryption_properties();
-    if (file_encryption_properties == nullptr) {
-      // Unencrypted parquet files always start with PAR1
+  // Only one of the row group writers is active at a time.
+  std::unique_ptr<RowGroupWriter> rowGroupWriter_;
+  std::unique_ptr<PageIndexBuilder> pageIndexBuilder_;
+  std::unique_ptr<InternalFileEncryptor> fileEncryptor_;
+
+  void startFile() {
+    auto fileEncryptionProperties = properties_->fileEncryptionProperties();
+    if (fileEncryptionProperties == nullptr) {
+      // Unencrypted parquet files always start with PAR1.
       PARQUET_THROW_NOT_OK(sink_->Write(kParquetMagic, 4));
     } else {
       // Check that all columns in columnEncryptionProperties exist in the
       // schema.
-      auto encrypted_columns = file_encryption_properties->encrypted_columns();
-      // if columnEncryptionProperties is empty, every column in file schema
+      auto encryptedColumns = fileEncryptionProperties->encryptedColumns();
+      // If columnEncryptionProperties is empty, every column in file schema
       // will be encrypted with footer key.
-      if (encrypted_columns.size() != 0) {
-        std::vector<std::string> column_path_vec;
+      if (encryptedColumns.size() != 0) {
+        std::vector<std::string> columnPathVec;
         // First, save all column paths in schema.
-        for (int i = 0; i < num_columns(); i++) {
-          column_path_vec.push_back(schema_.Column(i)->path()->ToDotString());
+        for (int i = 0; i < numColumns(); i++) {
+          columnPathVec.push_back(schema_.column(i)->path()->toDotString());
         }
         // Check if column exists in schema.
-        for (const auto& elem : encrypted_columns) {
-          auto it = std::find(
-              column_path_vec.begin(), column_path_vec.end(), elem.first);
-          if (it == column_path_vec.end()) {
+        for (const auto& elem : encryptedColumns) {
+          auto it =
+              std::find(columnPathVec.begin(), columnPathVec.end(), elem.first);
+          if (it == columnPathVec.end()) {
             std::stringstream ss;
             ss << "Encrypted column " + elem.first + " not in file schema";
             throw ParquetException(ss.str());
@@ -619,9 +607,9 @@ class FileSerializer : public ParquetFileWriter::Contents {
         }
       }
 
-      file_encryptor_ = std::make_unique<InternalFileEncryptor>(
-          file_encryption_properties, properties_->memory_pool());
-      if (file_encryption_properties->encrypted_footer()) {
+      fileEncryptor_ = std::make_unique<InternalFileEncryptor>(
+          fileEncryptionProperties, properties_->memoryPool());
+      if (fileEncryptionProperties->encryptedFooter()) {
         PARQUET_THROW_NOT_OK(sink_->Write(kParquetEMagic, 4));
       } else {
         // Encrypted file with plaintext footer mode.
@@ -629,88 +617,88 @@ class FileSerializer : public ParquetFileWriter::Contents {
       }
     }
 
-    if (properties_->page_index_enabled()) {
-      page_index_builder_ = PageIndexBuilder::Make(&schema_);
+    if (properties_->pageIndexEnabled()) {
+      pageIndexBuilder_ = PageIndexBuilder::make(&schema_);
     }
   }
 };
 
 // ----------------------------------------------------------------------
-// ParquetFileWriter public API
+// ParquetFileWriter public API.
 
 ParquetFileWriter::ParquetFileWriter() {}
 
 ParquetFileWriter::~ParquetFileWriter() {
   try {
-    Close();
+    close();
   } catch (...) {
   }
 }
 
-std::unique_ptr<ParquetFileWriter> ParquetFileWriter::Open(
+std::unique_ptr<ParquetFileWriter> ParquetFileWriter::open(
     std::shared_ptr<::arrow::io::OutputStream> sink,
     std::shared_ptr<GroupNode> schema,
     std::shared_ptr<WriterProperties> properties,
-    std::shared_ptr<const KeyValueMetadata> key_value_metadata) {
-  auto contents = FileSerializer::Open(
+    std::shared_ptr<const KeyValueMetadata> keyValueMetadata) {
+  auto contents = FileSerializer::open(
       std::move(sink),
       std::move(schema),
       std::move(properties),
-      std::move(key_value_metadata));
+      std::move(keyValueMetadata));
   std::unique_ptr<ParquetFileWriter> result(new ParquetFileWriter());
-  result->Open(std::move(contents));
+  result->open(std::move(contents));
   return result;
 }
 
-void WriteFileMetaData(
-    const FileMetaData& file_metadata,
+void writeFileMetaData(
+    const FileMetaData& fileMetadata,
     ArrowOutputStream* sink) {
-  // Write MetaData
+  // Write metadata.
   PARQUET_ASSIGN_OR_THROW(int64_t position, sink->Tell());
-  uint32_t metadata_len = static_cast<uint32_t>(position);
+  uint32_t metadataLen = static_cast<uint32_t>(position);
 
-  file_metadata.WriteTo(sink);
+  fileMetadata.writeTo(sink);
   PARQUET_ASSIGN_OR_THROW(position, sink->Tell());
-  metadata_len = static_cast<uint32_t>(position) - metadata_len;
+  metadataLen = static_cast<uint32_t>(position) - metadataLen;
 
-  // Write Footer
+  // Write Footer.
   PARQUET_THROW_NOT_OK(
-      sink->Write(reinterpret_cast<uint8_t*>(&metadata_len), 4));
+      sink->Write(reinterpret_cast<uint8_t*>(&metadataLen), 4));
   PARQUET_THROW_NOT_OK(sink->Write(kParquetMagic, 4));
 }
 
-void WriteMetaDataFile(
-    const FileMetaData& file_metadata,
+void writeMetaDataFile(
+    const FileMetaData& fileMetadata,
     ArrowOutputStream* sink) {
   PARQUET_THROW_NOT_OK(sink->Write(kParquetMagic, 4));
-  return WriteFileMetaData(file_metadata, sink);
+  return writeFileMetaData(fileMetadata, sink);
 }
 
-void WriteEncryptedFileMetadata(
-    const FileMetaData& file_metadata,
+void writeEncryptedFileMetadata(
+    const FileMetaData& fileMetadata,
     ArrowOutputStream* sink,
     const std::shared_ptr<Encryptor>& encryptor,
-    bool encrypt_footer) {
-  if (encrypt_footer) { // Encrypted file with encrypted footer
-    // encrypt and write to sink
-    file_metadata.WriteTo(sink, encryptor);
+    bool encryptFooter) {
+  if (encryptFooter) { // Encrypted file with encrypted footer.
+    // Encrypt and write to sink.
+    fileMetadata.writeTo(sink, encryptor);
   } else { // Encrypted file with plaintext footer mode.
     PARQUET_ASSIGN_OR_THROW(int64_t position, sink->Tell());
-    uint32_t metadata_len = static_cast<uint32_t>(position);
-    file_metadata.WriteTo(sink, encryptor);
+    uint32_t metadataLen = static_cast<uint32_t>(position);
+    fileMetadata.writeTo(sink, encryptor);
     PARQUET_ASSIGN_OR_THROW(position, sink->Tell());
-    metadata_len = static_cast<uint32_t>(position) - metadata_len;
+    metadataLen = static_cast<uint32_t>(position) - metadataLen;
 
     PARQUET_THROW_NOT_OK(
-        sink->Write(reinterpret_cast<uint8_t*>(&metadata_len), 4));
+        sink->Write(reinterpret_cast<uint8_t*>(&metadataLen), 4));
     PARQUET_THROW_NOT_OK(sink->Write(kParquetMagic, 4));
   }
 }
 
-void WriteFileCryptoMetaData(
-    const FileCryptoMetaData& crypto_metadata,
+void writeFileCryptoMetaData(
+    const FileCryptoMetaData& cryptoMetadata,
     ArrowOutputStream* sink) {
-  crypto_metadata.WriteTo(sink);
+  cryptoMetadata.writeTo(sink);
 }
 
 const SchemaDescriptor* ParquetFileWriter::schema() const {
@@ -718,59 +706,59 @@ const SchemaDescriptor* ParquetFileWriter::schema() const {
 }
 
 const ColumnDescriptor* ParquetFileWriter::descr(int i) const {
-  return contents_->schema()->Column(i);
+  return contents_->schema()->column(i);
 }
 
-int ParquetFileWriter::num_columns() const {
-  return contents_->num_columns();
+int ParquetFileWriter::numColumns() const {
+  return contents_->numColumns();
 }
 
-int64_t ParquetFileWriter::num_rows() const {
-  return contents_->num_rows();
+int64_t ParquetFileWriter::numRows() const {
+  return contents_->numRows();
 }
 
-int ParquetFileWriter::num_row_groups() const {
-  return contents_->num_row_groups();
+int ParquetFileWriter::numRowGroups() const {
+  return contents_->numRowGroups();
 }
 
 const std::shared_ptr<const KeyValueMetadata>&
-ParquetFileWriter::key_value_metadata() const {
-  return contents_->key_value_metadata();
+ParquetFileWriter::keyValueMetadata() const {
+  return contents_->keyValueMetadata();
 }
 
 const std::shared_ptr<FileMetaData> ParquetFileWriter::metadata() const {
-  return file_metadata_;
+  return fileMetadata_;
 }
 
-void ParquetFileWriter::Open(
+void ParquetFileWriter::open(
     std::unique_ptr<ParquetFileWriter::Contents> contents) {
   contents_ = std::move(contents);
 }
 
-void ParquetFileWriter::Close() {
+void ParquetFileWriter::close() {
   if (contents_) {
-    contents_->Close();
-    file_metadata_ = contents_->metadata();
+    contents_->close();
+    fileMetadata_ = contents_->metadata();
     contents_.reset();
   }
 }
 
-RowGroupWriter* ParquetFileWriter::AppendRowGroup() {
-  return contents_->AppendRowGroup();
+RowGroupWriter* ParquetFileWriter::appendRowGroup() {
+  return contents_->appendRowGroup();
 }
 
-RowGroupWriter* ParquetFileWriter::AppendBufferedRowGroup() {
-  return contents_->AppendBufferedRowGroup();
+RowGroupWriter* ParquetFileWriter::appendBufferedRowGroup() {
+  return contents_->appendBufferedRowGroup();
 }
 
-RowGroupWriter* ParquetFileWriter::AppendRowGroup(int64_t num_rows) {
-  return AppendRowGroup();
+RowGroupWriter* ParquetFileWriter::appendRowGroup(int64_t numRows) {
+  return appendRowGroup();
 }
 
-void ParquetFileWriter::AddKeyValueMetadata(
-    const std::shared_ptr<const KeyValueMetadata>& key_value_metadata) {
+void ParquetFileWriter::addKeyValueMetadata(
+    const std::shared_ptr<const KeyValueMetadata>& keyValueMetadata) {
   if (contents_) {
-    contents_->AddKeyValueMetadata(key_value_metadata);
+    contents_->addKeyValueMetadata(keyValueMetadata);
   } else {
     throw ParquetException("Cannot add key-value metadata to closed file");
   }
diff --git a/velox/dwio/parquet/writer/arrow/FileWriter.h b/velox/dwio/parquet/writer/arrow/FileWriter.h
index 27a2eafda03..5e466929769 100644
--- a/velox/dwio/parquet/writer/arrow/FileWriter.h
+++ b/velox/dwio/parquet/writer/arrow/FileWriter.h
@@ -31,34 +31,34 @@ namespace facebook::velox::parquet::arrow {
 
 class ColumnWriter;
 
-// FIXME: copied from reader-internal.cc
+// FIXME: copied from reader-internal.cc.
 static constexpr uint8_t kParquetMagic[4] = {'P', 'A', 'R', '1'};
 static constexpr uint8_t kParquetEMagic[4] = {'P', 'A', 'R', 'E'};
 
 class PARQUET_EXPORT RowGroupWriter {
  public:
   // Forward declare a virtual class 'Contents' to aid dependency injection and
-  // more easily create test fixtures An implementation of the Contents class is
-  // defined in the .cc file
+  // more easily create test fixtures. An implementation of the Contents class
+  // is defined in the .cpp file.
   struct Contents {
     virtual ~Contents() = default;
-    virtual int num_columns() const = 0;
-    virtual int64_t num_rows() const = 0;
+    virtual int numColumns() const = 0;
+    virtual int64_t numRows() const = 0;
 
-    // to be used only with ParquetFileWriter::AppendRowGroup
-    virtual ColumnWriter* NextColumn() = 0;
-    // to be used only with ParquetFileWriter::AppendBufferedRowGroup
+    // To be used only with ParquetFileWriter::AppendRowGroup.
+    virtual ColumnWriter* nextColumn() = 0;
+    // To be used only with ParquetFileWriter::AppendBufferedRowGroup.
     virtual ColumnWriter* column(int i) = 0;
 
-    virtual int current_column() const = 0;
-    virtual void Close() = 0;
+    virtual int currentColumn() const = 0;
+    virtual void close() = 0;
 
-    /// \brief total uncompressed bytes written by the page writer
-    virtual int64_t total_bytes_written() const = 0;
-    /// \brief total bytes still compressed but not written by the page writer
-    virtual int64_t total_compressed_bytes() const = 0;
-    /// \brief total compressed bytes written by the page writer
-    virtual int64_t total_compressed_bytes_written() const = 0;
+    /// \brief Total uncompressed bytes written by the page writer
+    virtual int64_t totalBytesWritten() const = 0;
+    /// \brief Total bytes still compressed but not written by the page writer
+    virtual int64_t totalCompressedBytes() const = 0;
+    /// \brief Total compressed bytes written by the page writer
+    virtual int64_t totalCompressedBytesWritten() const = 0;
 
     virtual bool buffered() const = 0;
   };
@@ -67,208 +67,207 @@ class PARQUET_EXPORT RowGroupWriter {
 
   /// Construct a ColumnWriter for the indicated row group-relative column.
   ///
-  /// To be used only with ParquetFileWriter::AppendRowGroup
+  /// To be used only with ParquetFileWriter::appendRowGroup().
   /// Ownership is solely within the RowGroupWriter. The ColumnWriter is only
-  /// valid until the next call to NextColumn or Close. As the contents are
+  /// valid until the next call to nextColumn() or close(). As the contents are
   /// directly written to the sink, once a new column is started, the contents
   /// of the previous one cannot be modified anymore.
-  ColumnWriter* NextColumn();
-  /// Index of currently written column. Equal to -1 if NextColumn()
+  ColumnWriter* nextColumn();
+  /// Index of currently written column. Equal to -1 if nextColumn()
   /// has not been called yet.
-  int current_column();
-  void Close();
+  int currentColumn();
+  void close();
 
-  int num_columns() const;
+  int numColumns() const;
 
   /// Construct a ColumnWriter for the indicated row group column.
   ///
-  /// To be used only with ParquetFileWriter::AppendBufferedRowGroup
+  /// To be used only with ParquetFileWriter::appendBufferedRowGroup().
   /// Ownership is solely within the RowGroupWriter. The ColumnWriter is
-  /// valid until Close. The contents are buffered in memory and written to sink
-  /// on Close
+  /// valid until close(). The contents are buffered in memory and written to
+  /// sink on close().
   ColumnWriter* column(int i);
 
   /**
    * Number of rows that shall be written as part of this RowGroup.
    */
-  int64_t num_rows() const;
+  int64_t numRows() const;
 
-  /// \brief total uncompressed bytes written by the page writer
-  int64_t total_bytes_written() const;
-  /// \brief total bytes still compressed but not written by the page writer.
+  /// \brief Total uncompressed bytes written by the page writer.
+  int64_t totalBytesWritten() const;
+  /// \brief Total bytes still compressed but not written by the page writer.
   /// It will always return 0 from the SerializedPageWriter.
-  int64_t total_compressed_bytes() const;
-  /// \brief total compressed bytes written by the page writer
-  int64_t total_compressed_bytes_written() const;
-
+  int64_t totalCompressedBytes() const;
+  /// \brief Total compressed bytes written by the page writer
+  int64_t totalCompressedBytesWritten() const;
   /// Returns whether the current RowGroupWriter is in the buffered mode and is
-  /// created by calling ParquetFileWriter::AppendBufferedRowGroup.
+  /// created by calling ParquetFileWriter::appendBufferedRowGroup().
   bool buffered() const;
 
  private:
-  // Holds a pointer to an instance of Contents implementation
+  // Holds a pointer to an instance of Contents implementation.
   std::unique_ptr<Contents> contents_;
 };
 
 PARQUET_EXPORT
-void WriteFileMetaData(
-    const FileMetaData& file_metadata,
+void writeFileMetaData(
+    const FileMetaData& fileMetadata,
     ::arrow::io::OutputStream* sink);
 
 PARQUET_EXPORT
-void WriteMetaDataFile(
-    const FileMetaData& file_metadata,
+void writeMetaDataFile(
+    const FileMetaData& fileMetadata,
     ::arrow::io::OutputStream* sink);
 
 PARQUET_EXPORT
-void WriteEncryptedFileMetadata(
-    const FileMetaData& file_metadata,
+void writeEncryptedFileMetadata(
+    const FileMetaData& fileMetadata,
     ArrowOutputStream* sink,
     const std::shared_ptr<Encryptor>& encryptor,
-    bool encrypt_footer);
+    bool encryptFooter);
 
 PARQUET_EXPORT
-void WriteEncryptedFileMetadata(
-    const FileMetaData& file_metadata,
+void writeEncryptedFileMetadata(
+    const FileMetaData& fileMetadata,
     ::arrow::io::OutputStream* sink,
     const std::shared_ptr<Encryptor>& encryptor = NULLPTR,
-    bool encrypt_footer = false);
+    bool encryptFooter = false);
 PARQUET_EXPORT
-void WriteFileCryptoMetaData(
-    const FileCryptoMetaData& crypto_metadata,
+void writeFileCryptoMetaData(
+    const FileCryptoMetaData& cryptoMetadata,
     ::arrow::io::OutputStream* sink);
 
 class PARQUET_EXPORT ParquetFileWriter {
  public:
   // Forward declare a virtual class 'Contents' to aid dependency injection and
-  // more easily create test fixtures An implementation of the Contents class is
-  // defined in the .cc file
+  // more easily create test fixtures. An implementation of the Contents class
+  // is defined in the .cpp file.
   struct Contents {
     Contents(
         std::shared_ptr<schema::GroupNode> schema,
-        std::shared_ptr<const KeyValueMetadata> key_value_metadata)
-        : schema_(), key_value_metadata_(std::move(key_value_metadata)) {
-      schema_.Init(std::move(schema));
+        std::shared_ptr<const KeyValueMetadata> keyValueMetadata)
+        : schema_(), keyValueMetadata_(std::move(keyValueMetadata)) {
+      schema_.init(std::move(schema));
     }
     virtual ~Contents() {}
-    // Perform any cleanup associated with the file contents
-    virtual void Close() = 0;
+    // Perform any cleanup associated with the file contents.
+    virtual void close() = 0;
 
-    /// \note Deprecated since 1.3.0
-    RowGroupWriter* AppendRowGroup(int64_t num_rows);
+    /// \note Deprecated since 1.3.0.
+    RowGroupWriter* appendRowGroup(int64_t numRows);
 
-    virtual RowGroupWriter* AppendRowGroup() = 0;
-    virtual RowGroupWriter* AppendBufferedRowGroup() = 0;
+    virtual RowGroupWriter* appendRowGroup() = 0;
+    virtual RowGroupWriter* appendBufferedRowGroup() = 0;
 
-    virtual int64_t num_rows() const = 0;
-    virtual int num_columns() const = 0;
-    virtual int num_row_groups() const = 0;
+    virtual int64_t numRows() const = 0;
+    virtual int numColumns() const = 0;
+    virtual int numRowGroups() const = 0;
 
     virtual const std::shared_ptr<WriterProperties>& properties() const = 0;
 
-    const std::shared_ptr<const KeyValueMetadata>& key_value_metadata() const {
-      return key_value_metadata_;
+    const std::shared_ptr<const KeyValueMetadata>& keyValueMetadata() const {
+      return keyValueMetadata_;
     }
 
-    virtual void AddKeyValueMetadata(
-        const std::shared_ptr<const KeyValueMetadata>& key_value_metadata) = 0;
+    virtual void addKeyValueMetadata(
+        const std::shared_ptr<const KeyValueMetadata>& keyValueMetadata) = 0;
 
-    // Return const-pointer to make it clear that this object is not to be
-    // copied
+    // Return const pointer to make it clear that this object is not to be
+    // copied.
     const SchemaDescriptor* schema() const {
       return &schema_;
     }
 
     SchemaDescriptor schema_;
 
-    /// This should be the only place this is stored. Everything else is a const
-    /// reference
-    std::shared_ptr<const KeyValueMetadata> key_value_metadata_;
+    /// This should be the only place this is stored. Everything else is a
+    /// const reference.
+    std::shared_ptr<const KeyValueMetadata> keyValueMetadata_;
 
     const std::shared_ptr<FileMetaData>& metadata() const {
-      return file_metadata_;
+      return fileMetadata_;
     }
-    std::shared_ptr<FileMetaData> file_metadata_;
+    std::shared_ptr<FileMetaData> fileMetadata_;
   };
 
   ParquetFileWriter();
   ~ParquetFileWriter();
 
-  static std::unique_ptr<ParquetFileWriter> Open(
+  static std::unique_ptr<ParquetFileWriter> open(
       std::shared_ptr<::arrow::io::OutputStream> sink,
       std::shared_ptr<schema::GroupNode> schema,
-      std::shared_ptr<WriterProperties> properties =
-          default_writer_properties(),
-      std::shared_ptr<const KeyValueMetadata> key_value_metadata = NULLPTR);
+      std::shared_ptr<WriterProperties> properties = defaultWriterProperties(),
+      std::shared_ptr<const KeyValueMetadata> keyValueMetadata = NULLPTR);
 
-  void Open(std::unique_ptr<Contents> contents);
-  void Close();
+  void open(std::unique_ptr<Contents> contents);
+  void close();
 
   // Construct a RowGroupWriter for the indicated number of rows.
   //
   // Ownership is solely within the ParquetFileWriter. The RowGroupWriter is
-  // only valid until the next call to AppendRowGroup or AppendBufferedRowGroup
-  // or Close.
-  // @param num_rows The number of rows that are stored in the new RowGroup
+  // only valid until the next call to appendRowGroup() or
+  // appendBufferedRowGroup() or close().
+  // @param numRows The number of rows that are stored in the new RowGroup.
   //
-  // \deprecated Since 1.3.0
-  RowGroupWriter* AppendRowGroup(int64_t num_rows);
+  // \deprecated Since 1.3.0.
+  RowGroupWriter* appendRowGroup(int64_t numRows);
 
   /// Construct a RowGroupWriter with an arbitrary number of rows.
   ///
   /// Ownership is solely within the ParquetFileWriter. The RowGroupWriter is
-  /// only valid until the next call to AppendRowGroup or AppendBufferedRowGroup
-  /// or Close.
-  RowGroupWriter* AppendRowGroup();
+  /// only valid until the next call to appendRowGroup() or
+  /// appendBufferedRowGroup() or close().
+  RowGroupWriter* appendRowGroup();
 
   /// Construct a RowGroupWriter that buffers all the values until the RowGroup
-  /// is ready. Use this if you want to write a RowGroup based on a certain size
+  /// is ready. Use this if you want to write a RowGroup based on a certain
+  /// size.
   ///
   /// Ownership is solely within the ParquetFileWriter. The RowGroupWriter is
-  /// only valid until the next call to AppendRowGroup or AppendBufferedRowGroup
-  /// or Close.
-  RowGroupWriter* AppendBufferedRowGroup();
+  /// only valid until the next call to appendRowGroup() or
+  /// appendBufferedRowGroup() or close().
+  RowGroupWriter* appendBufferedRowGroup();
 
   /// \brief Add key-value metadata to the file.
-  /// \param[in] key_value_metadata the metadata to add.
+  /// \param[in] keyValueMetadata The metadata to add.
   /// \note This will overwrite any existing metadata with the same key.
-  /// \throw ParquetException if Close() has been called.
-  void AddKeyValueMetadata(
-      const std::shared_ptr<const KeyValueMetadata>& key_value_metadata);
+  /// \throw ParquetException if close() has been called.
+  void addKeyValueMetadata(
+      const std::shared_ptr<const KeyValueMetadata>& keyValueMetadata);
 
   /// Number of columns.
   ///
-  /// This number is fixed during the lifetime of the writer as it is determined
-  /// via the schema.
-  int num_columns() const;
+  /// This number is fixed during the lifetime of the writer as it is
+  /// determined via the schema.
+  int numColumns() const;
 
   /// Number of rows in the yet started RowGroups.
   ///
   /// Changes on the addition of a new RowGroup.
-  int64_t num_rows() const;
+  int64_t numRows() const;
 
   /// Number of started RowGroups.
-  int num_row_groups() const;
+  int numRowGroups() const;
 
   /// Configuration passed to the writer, e.g. the used Parquet format version.
   const std::shared_ptr<WriterProperties>& properties() const;
 
-  /// Returns the file schema descriptor
+  /// Returns the file schema descriptor.
   const SchemaDescriptor* schema() const;
 
-  /// Returns a column descriptor in schema
+  /// Returns a column descriptor in schema.
   const ColumnDescriptor* descr(int i) const;
 
-  /// Returns the file custom metadata
-  const std::shared_ptr<const KeyValueMetadata>& key_value_metadata() const;
+  /// Returns the file custom metadata.
+  const std::shared_ptr<const KeyValueMetadata>& keyValueMetadata() const;
 
-  /// Returns the file metadata, only available after calling Close().
+  /// Returns the file metadata, only available after calling close().
   const std::shared_ptr<FileMetaData> metadata() const;
 
  private:
-  // Holds a pointer to an instance of Contents implementation
+  // Holds a pointer to an instance of Contents implementation.
   std::unique_ptr<Contents> contents_;
-  std::shared_ptr<FileMetaData> file_metadata_;
+  std::shared_ptr<FileMetaData> fileMetadata_;
 };
 
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/Metadata.cpp b/velox/dwio/parquet/writer/arrow/Metadata.cpp
index ef978a01a74..b62d9ecea85 100644
--- a/velox/dwio/parquet/writer/arrow/Metadata.cpp
+++ b/velox/dwio/parquet/writer/arrow/Metadata.cpp
@@ -62,15 +62,15 @@ const ApplicationVersion& ApplicationVersion::PARQUET_MR_FIXED_STATS_VERSION() {
 
 const ApplicationVersion&
 ApplicationVersion::PARQUET_CPP_10353_FIXED_VERSION() {
-  // parquet-cpp versions released prior to Arrow 3.0 would write DataPageV2
-  // pages with is_compressed==0 but still write compressed data. (See:
-  // ARROW-10353). Parquet 1.5.1 had this problem, and after that we switched to
-  // the application name "parquet-cpp-arrow", so this version is fake.
+  // Parquet-cpp versions released prior to Arrow 3.0 would write DataPageV2.
+  // Pages with is_compressed==0 but still write compressed data. (See:
+  // ARROW-10353). Parquet 1.5.1 had this problem, and after that we switched
+  // to. The application name "parquet-cpp-arrow", so this version is fake.
   static ApplicationVersion version("parquet-cpp", 2, 0, 0);
   return version;
 }
 
-std::string ParquetVersionToString(ParquetVersion::type ver) {
+std::string parquetVersionToString(ParquetVersion::type ver) {
   switch (ver) {
     case ParquetVersion::PARQUET_1_0:
       return "1.0";
@@ -84,294 +84,297 @@ std::string ParquetVersionToString(ParquetVersion::type ver) {
       return "2.6";
   }
 
-  // This should be unreachable
+  // This should be unreachable.
   return "UNKNOWN";
 }
 
 template <typename DType>
-static std::shared_ptr<Statistics> MakeTypedColumnStats(
+static std::shared_ptr<Statistics> makeTypedColumnStats(
     const facebook::velox::parquet::thrift::ColumnMetaData& metadata,
     const ColumnDescriptor* descr) {
-  // If ColumnOrder is defined, return max_value and min_value
-  if (descr->column_order().get_order() == ColumnOrder::TYPE_DEFINED_ORDER) {
-    return MakeStatistics<DType>(
+  // If ColumnOrder is defined, return max_value and min_value.
+  const auto& stats = metadata.statistics;
+  if (descr->columnOrder().order() == ColumnOrder::kTypeDefinedOrder) {
+    return makeStatistics<DType>(
         descr,
-        metadata.statistics.min_value,
-        metadata.statistics.max_value,
-        metadata.num_values - metadata.statistics.null_count,
-        metadata.statistics.null_count,
-        metadata.statistics.distinct_count,
-        metadata.statistics.__isset.max_value ||
-            metadata.statistics.__isset.min_value,
-        metadata.statistics.__isset.null_count,
-        metadata.statistics.__isset.distinct_count);
-  }
-  // Default behavior
-  return MakeStatistics<DType>(
+        stats.min_value,
+        stats.max_value,
+        metadata.num_values - stats.null_count,
+        stats.null_count,
+        stats.distinct_count,
+        stats.__isset.max_value || stats.__isset.min_value,
+        stats.__isset.null_count,
+        stats.__isset.distinct_count,
+        false,
+        0);
+  }
+  // Default behavior.
+  return makeStatistics<DType>(
       descr,
-      metadata.statistics.min,
-      metadata.statistics.max,
-      metadata.num_values - metadata.statistics.null_count,
-      metadata.statistics.null_count,
-      metadata.statistics.distinct_count,
-      metadata.statistics.__isset.max || metadata.statistics.__isset.min,
-      metadata.statistics.__isset.null_count,
-      metadata.statistics.__isset.distinct_count);
-}
-
-std::shared_ptr<Statistics> MakeColumnStats(
+      stats.min,
+      stats.max,
+      metadata.num_values - stats.null_count,
+      stats.null_count,
+      stats.distinct_count,
+      stats.__isset.max || stats.__isset.min,
+      stats.__isset.null_count,
+      stats.__isset.distinct_count,
+      false,
+      0);
+}
+
+std::shared_ptr<Statistics> makeColumnStats(
     const facebook::velox::parquet::thrift::ColumnMetaData& meta_data,
     const ColumnDescriptor* descr) {
   switch (static_cast<Type::type>(meta_data.type)) {
-    case Type::BOOLEAN:
-      return MakeTypedColumnStats<BooleanType>(meta_data, descr);
-    case Type::INT32:
-      return MakeTypedColumnStats<Int32Type>(meta_data, descr);
-    case Type::INT64:
-      return MakeTypedColumnStats<Int64Type>(meta_data, descr);
-    case Type::INT96:
-      return MakeTypedColumnStats<Int96Type>(meta_data, descr);
-    case Type::DOUBLE:
-      return MakeTypedColumnStats<DoubleType>(meta_data, descr);
-    case Type::FLOAT:
-      return MakeTypedColumnStats<FloatType>(meta_data, descr);
-    case Type::BYTE_ARRAY:
-      return MakeTypedColumnStats<ByteArrayType>(meta_data, descr);
-    case Type::FIXED_LEN_BYTE_ARRAY:
-      return MakeTypedColumnStats<FLBAType>(meta_data, descr);
-    case Type::UNDEFINED:
+    case Type::kBoolean:
+      return makeTypedColumnStats<BooleanType>(meta_data, descr);
+    case Type::kInt32:
+      return makeTypedColumnStats<Int32Type>(meta_data, descr);
+    case Type::kInt64:
+      return makeTypedColumnStats<Int64Type>(meta_data, descr);
+    case Type::kInt96:
+      return makeTypedColumnStats<Int96Type>(meta_data, descr);
+    case Type::kDouble:
+      return makeTypedColumnStats<DoubleType>(meta_data, descr);
+    case Type::kFloat:
+      return makeTypedColumnStats<FloatType>(meta_data, descr);
+    case Type::kByteArray:
+      return makeTypedColumnStats<ByteArrayType>(meta_data, descr);
+    case Type::kFixedLenByteArray:
+      return makeTypedColumnStats<FLBAType>(meta_data, descr);
+    case Type::kUndefined:
       break;
   }
   throw ParquetException(
-      "Can't decode page statistics for selected column type");
+      "Can't decode page statistics for selected column type.");
 }
 
-// MetaData Accessor
+// MetaData Accessor.
 
-// ColumnCryptoMetaData
+// ColumnCryptoMetaData.
 class ColumnCryptoMetaData::ColumnCryptoMetaDataImpl {
  public:
   explicit ColumnCryptoMetaDataImpl(
       const facebook::velox::parquet::thrift::ColumnCryptoMetaData*
-          crypto_metadata)
-      : crypto_metadata_(crypto_metadata) {}
+          cryptoMetadata)
+      : cryptoMetadata_(cryptoMetadata) {}
 
-  bool encrypted_with_footer_key() const {
-    return crypto_metadata_->__isset.ENCRYPTION_WITH_FOOTER_KEY;
+  bool encryptedWithFooterKey() const {
+    return cryptoMetadata_->__isset.ENCRYPTION_WITH_FOOTER_KEY;
   }
-  bool encrypted_with_column_key() const {
-    return crypto_metadata_->__isset.ENCRYPTION_WITH_COLUMN_KEY;
+  bool encryptedWithColumnKey() const {
+    return cryptoMetadata_->__isset.ENCRYPTION_WITH_COLUMN_KEY;
   }
-  std::shared_ptr<schema::ColumnPath> path_in_schema() const {
+  std::shared_ptr<schema::ColumnPath> pathInSchema() const {
     return std::make_shared<schema::ColumnPath>(
-        crypto_metadata_->ENCRYPTION_WITH_COLUMN_KEY.path_in_schema);
+        cryptoMetadata_->ENCRYPTION_WITH_COLUMN_KEY.path_in_schema);
   }
-  const std::string& key_metadata() const {
-    return crypto_metadata_->ENCRYPTION_WITH_COLUMN_KEY.key_metadata;
+  const std::string& keyMetadata() const {
+    return cryptoMetadata_->ENCRYPTION_WITH_COLUMN_KEY.key_metadata;
   }
 
  private:
-  const facebook::velox::parquet::thrift::ColumnCryptoMetaData*
-      crypto_metadata_;
+  const facebook::velox::parquet::thrift::ColumnCryptoMetaData* cryptoMetadata_;
 };
 
-std::unique_ptr<ColumnCryptoMetaData> ColumnCryptoMetaData::Make(
+std::unique_ptr<ColumnCryptoMetaData> ColumnCryptoMetaData::make(
     const uint8_t* metadata) {
   return std::unique_ptr<ColumnCryptoMetaData>(
       new ColumnCryptoMetaData(metadata));
 }
 
 ColumnCryptoMetaData::ColumnCryptoMetaData(const uint8_t* metadata)
-    : impl_(std::make_unique<ColumnCryptoMetaDataImpl>(
-          reinterpret_cast<
-              const facebook::velox::parquet::thrift::ColumnCryptoMetaData*>(
-              metadata))) {}
+    : impl_(
+          std::make_unique<ColumnCryptoMetaDataImpl>(
+              reinterpret_cast<const facebook::velox::parquet::thrift::
+                                   ColumnCryptoMetaData*>(metadata))) {}
 
 ColumnCryptoMetaData::~ColumnCryptoMetaData() = default;
 
-std::shared_ptr<schema::ColumnPath> ColumnCryptoMetaData::path_in_schema()
-    const {
-  return impl_->path_in_schema();
+std::shared_ptr<schema::ColumnPath> ColumnCryptoMetaData::pathInSchema() const {
+  return impl_->pathInSchema();
 }
-bool ColumnCryptoMetaData::encrypted_with_footer_key() const {
-  return impl_->encrypted_with_footer_key();
+bool ColumnCryptoMetaData::encryptedWithFooterKey() const {
+  return impl_->encryptedWithFooterKey();
 }
-const std::string& ColumnCryptoMetaData::key_metadata() const {
-  return impl_->key_metadata();
+const std::string& ColumnCryptoMetaData::keyMetadata() const {
+  return impl_->keyMetadata();
 }
 
-// ColumnChunk metadata
+// ColumnChunk metadata.
 class ColumnChunkMetaData::ColumnChunkMetaDataImpl {
  public:
   explicit ColumnChunkMetaDataImpl(
       const facebook::velox::parquet::thrift::ColumnChunk* column,
       const ColumnDescriptor* descr,
-      int16_t row_group_ordinal,
-      int16_t column_ordinal,
+      int16_t rowGroupOrdinal,
+      int16_t columnOrdinal,
       const ReaderProperties& properties,
-      const ApplicationVersion* writer_version,
-      std::shared_ptr<InternalFileDecryptor> file_decryptor)
+      const ApplicationVersion* writerVersion,
+      std::shared_ptr<InternalFileDecryptor> fileDecryptor)
       : column_(column),
         descr_(descr),
         properties_(properties),
-        writer_version_(writer_version) {
-    column_metadata_ = &column->meta_data;
+        writerVersion_(writerVersion) {
+    columnMetadata_ = &column->meta_data;
     if (column->__isset.crypto_metadata) { // column metadata is encrypted
       facebook::velox::parquet::thrift::ColumnCryptoMetaData ccmd =
           column->crypto_metadata;
 
       if (ccmd.__isset.ENCRYPTION_WITH_COLUMN_KEY) {
-        if (file_decryptor != nullptr &&
-            file_decryptor->properties() != nullptr) {
-          // should decrypt metadata
+        if (fileDecryptor != nullptr &&
+            fileDecryptor->properties() != nullptr) {
+          // Should decrypt metadata.
           std::shared_ptr<schema::ColumnPath> path =
               std::make_shared<schema::ColumnPath>(
                   ccmd.ENCRYPTION_WITH_COLUMN_KEY.path_in_schema);
           std::string key_metadata =
               ccmd.ENCRYPTION_WITH_COLUMN_KEY.key_metadata;
 
-          std::string aad_column_metadata = encryption::CreateModuleAad(
-              file_decryptor->file_aad(),
+          std::string aadColumnMetadata = encryption::createModuleAad(
+              fileDecryptor->fileAad(),
               encryption::kColumnMetaData,
-              row_group_ordinal,
-              column_ordinal,
+              rowGroupOrdinal,
+              columnOrdinal,
               static_cast<int16_t>(-1));
-          auto decryptor = file_decryptor->GetColumnMetaDecryptor(
-              path->ToDotString(), key_metadata, aad_column_metadata);
+          auto Decryptor = fileDecryptor->getColumnMetaDecryptor(
+              path->toDotString(), key_metadata, aadColumnMetadata);
           auto len =
               static_cast<uint32_t>(column->encrypted_column_metadata.size());
           ThriftDeserializer deserializer(properties_);
-          deserializer.DeserializeMessage(
+          deserializer.deserializeMessage(
               reinterpret_cast<const uint8_t*>(
                   column->encrypted_column_metadata.c_str()),
               &len,
-              &decrypted_metadata_,
-              decryptor);
-          column_metadata_ = &decrypted_metadata_;
+              &decryptedMetadata_,
+              Decryptor);
+          columnMetadata_ = &decryptedMetadata_;
         } else {
           throw ParquetException(
               "Cannot decrypt ColumnMetadata."
-              " FileDecryption is not setup correctly");
+              " FileDecryption is not setup correctly.");
         }
       }
     }
-    for (const auto& encoding : column_metadata_->encodings) {
-      encodings_.push_back(LoadEnumSafe(&encoding));
+    for (const auto& encoding : columnMetadata_->encodings) {
+      encodings_.push_back(loadenumSafe(&encoding));
     }
-    for (const auto& encoding_stats : column_metadata_->encoding_stats) {
-      encoding_stats_.push_back(
-          {LoadEnumSafe(&encoding_stats.page_type),
-           LoadEnumSafe(&encoding_stats.encoding),
-           encoding_stats.count});
+    for (const auto& encodingStats : columnMetadata_->encoding_stats) {
+      encodingStats_.push_back(
+          {loadenumSafe(&encodingStats.page_type),
+           loadenumSafe(&encodingStats.encoding),
+           encodingStats.count});
     }
-    possible_stats_ = nullptr;
+    possibleStats_ = nullptr;
   }
 
-  bool Equals(const ColumnChunkMetaDataImpl& other) const {
-    return *column_metadata_ == *other.column_metadata_;
+  bool equals(const ColumnChunkMetaDataImpl& other) const {
+    return *columnMetadata_ == *other.columnMetadata_;
   }
 
-  // column chunk
-  inline int64_t file_offset() const {
+  // Column chunk.
+  inline int64_t fileOffset() const {
     return column_->file_offset;
   }
-  inline const std::string& file_path() const {
+  inline const std::string& filePath() const {
     return column_->file_path;
   }
 
   inline Type::type type() const {
-    return LoadEnumSafe(&column_metadata_->type);
+    return loadenumSafe(&columnMetadata_->type);
   }
 
-  inline int64_t num_values() const {
-    return column_metadata_->num_values;
+  inline int64_t numValues() const {
+    return columnMetadata_->num_values;
   }
 
-  std::shared_ptr<schema::ColumnPath> path_in_schema() {
+  std::shared_ptr<schema::ColumnPath> pathInSchema() {
     return std::make_shared<schema::ColumnPath>(
-        column_metadata_->path_in_schema);
-  }
-
-  // Check if statistics are set and are valid
-  // 1) Must be set in the metadata
-  // 2) Statistics must not be corrupted
-  inline bool is_stats_set() const {
-    VELOX_DCHECK_NOT_NULL(writer_version_);
-    // If the column statistics don't exist or column sort order is unknown
-    // we cannot use the column stats
-    if (!column_metadata_->__isset.statistics ||
-        descr_->sort_order() == SortOrder::UNKNOWN) {
+        columnMetadata_->path_in_schema);
+  }
+
+  // Check if statistics are set and are valid.
+  // 1) Must be set in the metadata.
+  // 2) Statistics must not be corrupted.
+  inline bool isStatsSet() const {
+    VELOX_DCHECK_NOT_NULL(writerVersion_);
+    // If the column statistics don't exist or column sort order is unknown,
+    // we cannot use the column stats.
+    if (!columnMetadata_->__isset.statistics ||
+        descr_->sortOrder() == SortOrder::kUnknown) {
       return false;
     }
-    if (possible_stats_ == nullptr) {
-      possible_stats_ = MakeColumnStats(*column_metadata_, descr_);
+    if (possibleStats_ == nullptr) {
+      possibleStats_ = makeColumnStats(*columnMetadata_, descr_);
     }
-    EncodedStatistics encodedStatistics = possible_stats_->Encode();
-    return writer_version_->HasCorrectStatistics(
-        type(), encodedStatistics, descr_->sort_order());
+    EncodedStatistics encodedStats = possibleStats_->encode();
+    return writerVersion_->hasCorrectStatistics(
+        type(), encodedStats, descr_->sortOrder());
   }
 
-  inline std::shared_ptr<Statistics> statistics() const {
-    return is_stats_set() ? possible_stats_ : nullptr;
+  inline std::shared_ptr<::facebook::velox::parquet::arrow::Statistics>
+  statistics() const {
+    return isStatsSet() ? possibleStats_ : nullptr;
   }
 
   inline Compression::type compression() const {
-    return LoadEnumSafe(&column_metadata_->codec);
+    return loadenumSafe(&columnMetadata_->codec);
   }
 
   const std::vector<Encoding::type>& encodings() const {
     return encodings_;
   }
 
-  const std::vector<PageEncodingStats>& encoding_stats() const {
-    return encoding_stats_;
+  const std::vector<PageEncodingStats>& encodingStats() const {
+    return encodingStats_;
   }
 
-  inline std::optional<int64_t> bloom_filter_offset() const {
-    if (column_metadata_->__isset.bloom_filter_offset) {
-      return column_metadata_->bloom_filter_offset;
+  inline std::optional<int64_t> bloomFilterOffset() const {
+    if (columnMetadata_->__isset.bloom_filter_offset) {
+      return columnMetadata_->bloom_filter_offset;
     }
     return std::nullopt;
   }
 
-  inline bool has_dictionary_page() const {
-    return column_metadata_->__isset.dictionary_page_offset;
+  inline bool hasDictionaryPage() const {
+    return columnMetadata_->__isset.dictionary_page_offset;
   }
 
-  inline int64_t dictionary_page_offset() const {
-    return column_metadata_->dictionary_page_offset;
+  inline int64_t dictionaryPageOffset() const {
+    return columnMetadata_->dictionary_page_offset;
   }
 
-  inline int64_t data_page_offset() const {
-    return column_metadata_->data_page_offset;
+  inline int64_t dataPageOffset() const {
+    return columnMetadata_->data_page_offset;
   }
 
-  inline bool has_index_page() const {
-    return column_metadata_->__isset.index_page_offset;
+  inline bool hasIndexPage() const {
+    return columnMetadata_->__isset.index_page_offset;
   }
 
-  inline int64_t index_page_offset() const {
-    return column_metadata_->index_page_offset;
+  inline int64_t indexPageOffset() const {
+    return columnMetadata_->index_page_offset;
   }
 
-  inline int64_t total_compressed_size() const {
-    return column_metadata_->total_compressed_size;
+  inline int64_t totalCompressedSize() const {
+    return columnMetadata_->total_compressed_size;
   }
 
-  inline int64_t total_uncompressed_size() const {
-    return column_metadata_->total_uncompressed_size;
+  inline int64_t totalUncompressedSize() const {
+    return columnMetadata_->total_uncompressed_size;
   }
 
-  inline std::unique_ptr<ColumnCryptoMetaData> crypto_metadata() const {
+  inline std::unique_ptr<ColumnCryptoMetaData> cryptoMetadata() const {
     if (column_->__isset.crypto_metadata) {
-      return ColumnCryptoMetaData::Make(
+      return ColumnCryptoMetaData::make(
           reinterpret_cast<const uint8_t*>(&column_->crypto_metadata));
     } else {
       return nullptr;
     }
   }
 
-  std::optional<IndexLocation> GetColumnIndexLocation() const {
+  std::optional<IndexLocation> getColumnIndexLocation() const {
     if (column_->__isset.column_index_offset &&
         column_->__isset.column_index_length) {
       return IndexLocation{
@@ -380,7 +383,7 @@ class ColumnChunkMetaData::ColumnChunkMetaDataImpl {
     return std::nullopt;
   }
 
-  std::optional<IndexLocation> GetOffsetIndexLocation() const {
+  std::optional<IndexLocation> getOffsetIndexLocation() const {
     if (column_->__isset.offset_index_offset &&
         column_->__isset.offset_index_length) {
       return IndexLocation{
@@ -389,521 +392,529 @@ class ColumnChunkMetaData::ColumnChunkMetaDataImpl {
     return std::nullopt;
   }
 
+  inline int32_t fieldId() const {
+    return descr_->schemaNode()->fieldId();
+  }
+
  private:
-  mutable std::shared_ptr<Statistics> possible_stats_;
+  mutable std::shared_ptr<::facebook::velox::parquet::arrow::Statistics>
+      possibleStats_;
   std::vector<Encoding::type> encodings_;
-  std::vector<PageEncodingStats> encoding_stats_;
+  std::vector<PageEncodingStats> encodingStats_;
   const facebook::velox::parquet::thrift::ColumnChunk* column_;
-  const facebook::velox::parquet::thrift::ColumnMetaData* column_metadata_;
-  facebook::velox::parquet::thrift::ColumnMetaData decrypted_metadata_;
+  const facebook::velox::parquet::thrift::ColumnMetaData* columnMetadata_;
+  facebook::velox::parquet::thrift::ColumnMetaData decryptedMetadata_;
   const ColumnDescriptor* descr_;
   const ReaderProperties properties_;
-  const ApplicationVersion* writer_version_;
+  const ApplicationVersion* writerVersion_;
 };
 
-std::unique_ptr<ColumnChunkMetaData> ColumnChunkMetaData::Make(
+std::unique_ptr<ColumnChunkMetaData> ColumnChunkMetaData::make(
     const void* metadata,
     const ColumnDescriptor* descr,
     const ReaderProperties& properties,
-    const ApplicationVersion* writer_version,
-    int16_t row_group_ordinal,
-    int16_t column_ordinal,
-    std::shared_ptr<InternalFileDecryptor> file_decryptor) {
+    const ApplicationVersion* writerVersion,
+    int16_t rowGroupOrdinal,
+    int16_t columnOrdinal,
+    std::shared_ptr<InternalFileDecryptor> fileDecryptor) {
   return std::unique_ptr<ColumnChunkMetaData>(new ColumnChunkMetaData(
       metadata,
       descr,
-      row_group_ordinal,
-      column_ordinal,
+      rowGroupOrdinal,
+      columnOrdinal,
       properties,
-      writer_version,
-      std::move(file_decryptor)));
+      writerVersion,
+      std::move(fileDecryptor)));
 }
 
-std::unique_ptr<ColumnChunkMetaData> ColumnChunkMetaData::Make(
+std::unique_ptr<ColumnChunkMetaData> ColumnChunkMetaData::make(
     const void* metadata,
     const ColumnDescriptor* descr,
-    const ApplicationVersion* writer_version,
-    int16_t row_group_ordinal,
-    int16_t column_ordinal,
-    std::shared_ptr<InternalFileDecryptor> file_decryptor) {
+    const ApplicationVersion* writerVersion,
+    int16_t rowGroupOrdinal,
+    int16_t columnOrdinal,
+    std::shared_ptr<InternalFileDecryptor> fileDecryptor) {
   return std::unique_ptr<ColumnChunkMetaData>(new ColumnChunkMetaData(
       metadata,
       descr,
-      row_group_ordinal,
-      column_ordinal,
-      default_reader_properties(),
-      writer_version,
-      std::move(file_decryptor)));
+      rowGroupOrdinal,
+      columnOrdinal,
+      defaultReaderProperties(),
+      writerVersion,
+      std::move(fileDecryptor)));
 }
 
 ColumnChunkMetaData::ColumnChunkMetaData(
     const void* metadata,
     const ColumnDescriptor* descr,
-    int16_t row_group_ordinal,
-    int16_t column_ordinal,
+    int16_t rowGroupOrdinal,
+    int16_t columnOrdinal,
     const ReaderProperties& properties,
-    const ApplicationVersion* writer_version,
-    std::shared_ptr<InternalFileDecryptor> file_decryptor)
+    const ApplicationVersion* writerVersion,
+    std::shared_ptr<InternalFileDecryptor> fileDecryptor)
     : impl_{new ColumnChunkMetaDataImpl(
           reinterpret_cast<
               const facebook::velox::parquet::thrift::ColumnChunk*>(metadata),
           descr,
-          row_group_ordinal,
-          column_ordinal,
+          rowGroupOrdinal,
+          columnOrdinal,
           properties,
-          writer_version,
-          std::move(file_decryptor))} {}
+          writerVersion,
+          std::move(fileDecryptor))} {}
 
 ColumnChunkMetaData::~ColumnChunkMetaData() = default;
 
-// column chunk
-int64_t ColumnChunkMetaData::file_offset() const {
-  return impl_->file_offset();
+// Column chunk.
+int64_t ColumnChunkMetaData::fileOffset() const {
+  return impl_->fileOffset();
 }
 
-const std::string& ColumnChunkMetaData::file_path() const {
-  return impl_->file_path();
+const std::string& ColumnChunkMetaData::filePath() const {
+  return impl_->filePath();
 }
 
 Type::type ColumnChunkMetaData::type() const {
   return impl_->type();
 }
 
-int64_t ColumnChunkMetaData::num_values() const {
-  return impl_->num_values();
+int64_t ColumnChunkMetaData::numValues() const {
+  return impl_->numValues();
 }
 
-std::shared_ptr<schema::ColumnPath> ColumnChunkMetaData::path_in_schema()
-    const {
-  return impl_->path_in_schema();
+std::shared_ptr<schema::ColumnPath> ColumnChunkMetaData::pathInSchema() const {
+  return impl_->pathInSchema();
 }
 
 std::shared_ptr<Statistics> ColumnChunkMetaData::statistics() const {
   return impl_->statistics();
 }
 
-bool ColumnChunkMetaData::is_stats_set() const {
-  return impl_->is_stats_set();
+bool ColumnChunkMetaData::isStatsSet() const {
+  return impl_->isStatsSet();
 }
 
-std::optional<int64_t> ColumnChunkMetaData::bloom_filter_offset() const {
-  return impl_->bloom_filter_offset();
+std::optional<int64_t> ColumnChunkMetaData::bloomFilterOffset() const {
+  return impl_->bloomFilterOffset();
 }
 
-bool ColumnChunkMetaData::has_dictionary_page() const {
-  return impl_->has_dictionary_page();
+bool ColumnChunkMetaData::hasDictionaryPage() const {
+  return impl_->hasDictionaryPage();
 }
 
-int64_t ColumnChunkMetaData::dictionary_page_offset() const {
-  return impl_->dictionary_page_offset();
+int64_t ColumnChunkMetaData::dictionaryPageOffset() const {
+  return impl_->dictionaryPageOffset();
 }
 
-int64_t ColumnChunkMetaData::data_page_offset() const {
-  return impl_->data_page_offset();
+int64_t ColumnChunkMetaData::dataPageOffset() const {
+  return impl_->dataPageOffset();
 }
 
-bool ColumnChunkMetaData::has_index_page() const {
-  return impl_->has_index_page();
+bool ColumnChunkMetaData::hasIndexPage() const {
+  return impl_->hasIndexPage();
 }
 
-int64_t ColumnChunkMetaData::index_page_offset() const {
-  return impl_->index_page_offset();
+int64_t ColumnChunkMetaData::indexPageOffset() const {
+  return impl_->indexPageOffset();
 }
 
 Compression::type ColumnChunkMetaData::compression() const {
   return impl_->compression();
 }
 
-bool ColumnChunkMetaData::can_decompress() const {
-  return util::Codec::IsAvailable(compression());
+bool ColumnChunkMetaData::canDecompress() const {
+  return util::Codec::isAvailable(compression());
 }
 
 const std::vector<Encoding::type>& ColumnChunkMetaData::encodings() const {
   return impl_->encodings();
 }
 
-const std::vector<PageEncodingStats>& ColumnChunkMetaData::encoding_stats()
+const std::vector<PageEncodingStats>& ColumnChunkMetaData::encodingStats()
     const {
-  return impl_->encoding_stats();
+  return impl_->encodingStats();
 }
 
-int64_t ColumnChunkMetaData::total_uncompressed_size() const {
-  return impl_->total_uncompressed_size();
+int64_t ColumnChunkMetaData::totalUncompressedSize() const {
+  return impl_->totalUncompressedSize();
 }
 
-int64_t ColumnChunkMetaData::total_compressed_size() const {
-  return impl_->total_compressed_size();
+int64_t ColumnChunkMetaData::totalCompressedSize() const {
+  return impl_->totalCompressedSize();
 }
 
-std::unique_ptr<ColumnCryptoMetaData> ColumnChunkMetaData::crypto_metadata()
+int32_t ColumnChunkMetaData::fieldId() const {
+  return impl_->fieldId();
+}
+
+std::unique_ptr<ColumnCryptoMetaData> ColumnChunkMetaData::cryptoMetadata()
     const {
-  return impl_->crypto_metadata();
+  return impl_->cryptoMetadata();
 }
 
-std::optional<IndexLocation> ColumnChunkMetaData::GetColumnIndexLocation()
+std::optional<IndexLocation> ColumnChunkMetaData::getColumnIndexLocation()
     const {
-  return impl_->GetColumnIndexLocation();
+  return impl_->getColumnIndexLocation();
 }
 
-std::optional<IndexLocation> ColumnChunkMetaData::GetOffsetIndexLocation()
+std::optional<IndexLocation> ColumnChunkMetaData::getOffsetIndexLocation()
     const {
-  return impl_->GetOffsetIndexLocation();
+  return impl_->getOffsetIndexLocation();
 }
 
-bool ColumnChunkMetaData::Equals(const ColumnChunkMetaData& other) const {
-  return impl_->Equals(*other.impl_);
+bool ColumnChunkMetaData::equals(const ColumnChunkMetaData& other) const {
+  return impl_->equals(*other.impl_);
 }
 
-// row-group metadata
+// Row-group metadata.
 class RowGroupMetaData::RowGroupMetaDataImpl {
  public:
   explicit RowGroupMetaDataImpl(
-      const facebook::velox::parquet::thrift::RowGroup* row_group,
+      const facebook::velox::parquet::thrift::RowGroup* rowGroup,
       const SchemaDescriptor* schema,
       const ReaderProperties& properties,
-      const ApplicationVersion* writer_version,
-      std::shared_ptr<InternalFileDecryptor> file_decryptor)
-      : row_group_(row_group),
+      const ApplicationVersion* writerVersion,
+      std::shared_ptr<InternalFileDecryptor> fileDecryptor)
+      : rowGroup_(rowGroup),
         schema_(schema),
         properties_(properties),
-        writer_version_(writer_version),
-        file_decryptor_(std::move(file_decryptor)) {
+        writerVersion_(writerVersion),
+        fileDecryptor_(std::move(fileDecryptor)) {
     if (ARROW_PREDICT_FALSE(
-            row_group_->columns.size() >
+            rowGroup_->columns.size() >
             static_cast<size_t>(std::numeric_limits<int>::max()))) {
       throw ParquetException(
-          "Row group had too many columns: ", row_group_->columns.size());
+          "Row group had too many columns: ", rowGroup_->columns.size());
     }
   }
 
-  bool Equals(const RowGroupMetaDataImpl& other) const {
-    return *row_group_ == *other.row_group_;
+  bool equals(const RowGroupMetaDataImpl& other) const {
+    return *rowGroup_ == *other.rowGroup_;
   }
 
-  inline int num_columns() const {
-    return static_cast<int>(row_group_->columns.size());
+  inline int numColumns() const {
+    return static_cast<int>(rowGroup_->columns.size());
   }
 
-  inline int64_t num_rows() const {
-    return row_group_->num_rows;
+  inline int64_t numRows() const {
+    return rowGroup_->num_rows;
   }
 
-  inline int64_t total_byte_size() const {
-    return row_group_->total_byte_size;
+  inline int64_t totalByteSize() const {
+    return rowGroup_->total_byte_size;
   }
 
-  inline int64_t total_compressed_size() const {
-    return row_group_->total_compressed_size;
+  inline int64_t totalCompressedSize() const {
+    return rowGroup_->total_compressed_size;
   }
 
-  inline int64_t file_offset() const {
-    return row_group_->file_offset;
+  inline int64_t fileOffset() const {
+    return rowGroup_->file_offset;
   }
 
   inline const SchemaDescriptor* schema() const {
     return schema_;
   }
 
-  std::unique_ptr<ColumnChunkMetaData> ColumnChunk(int i) {
-    if (i >= 0 && i < num_columns()) {
-      return ColumnChunkMetaData::Make(
-          &row_group_->columns[i],
-          schema_->Column(i),
+  std::unique_ptr<ColumnChunkMetaData> columnChunk(int i) {
+    if (i >= 0 && i < numColumns()) {
+      return ColumnChunkMetaData::make(
+          &rowGroup_->columns[i],
+          schema_->column(i),
           properties_,
-          writer_version_,
-          row_group_->ordinal,
+          writerVersion_,
+          rowGroup_->ordinal,
           i,
-          file_decryptor_);
+          fileDecryptor_);
     }
     throw ParquetException(
         "The file only has ",
-        num_columns(),
+        numColumns(),
         " columns, requested metadata for column: ",
         i);
   }
 
-  std::vector<SortingColumn> sorting_columns() const {
-    std::vector<SortingColumn> sorting_columns;
-    if (!row_group_->__isset.sorting_columns) {
-      return sorting_columns;
+  std::vector<SortingColumn> sortingColumns() const {
+    std::vector<SortingColumn> sortingColumns;
+    if (!rowGroup_->__isset.sorting_columns) {
+      return sortingColumns;
     }
-    sorting_columns.resize(row_group_->sorting_columns.size());
-    for (size_t i = 0; i < sorting_columns.size(); ++i) {
-      sorting_columns[i] = FromThrift(row_group_->sorting_columns[i]);
+    sortingColumns.resize(rowGroup_->sorting_columns.size());
+    for (size_t i = 0; i < sortingColumns.size(); ++i) {
+      sortingColumns[i] = fromThrift(rowGroup_->sorting_columns[i]);
     }
-    return sorting_columns;
+    return sortingColumns;
   }
 
  private:
-  const facebook::velox::parquet::thrift::RowGroup* row_group_;
+  const facebook::velox::parquet::thrift::RowGroup* rowGroup_;
   const SchemaDescriptor* schema_;
   const ReaderProperties properties_;
-  const ApplicationVersion* writer_version_;
-  std::shared_ptr<InternalFileDecryptor> file_decryptor_;
+  const ApplicationVersion* writerVersion_;
+  std::shared_ptr<InternalFileDecryptor> fileDecryptor_;
 };
 
-std::unique_ptr<RowGroupMetaData> RowGroupMetaData::Make(
+std::unique_ptr<RowGroupMetaData> RowGroupMetaData::make(
     const void* metadata,
     const SchemaDescriptor* schema,
-    const ApplicationVersion* writer_version,
-    std::shared_ptr<InternalFileDecryptor> file_decryptor) {
+    const ApplicationVersion* writerVersion,
+    std::shared_ptr<InternalFileDecryptor> fileDecryptor) {
   return std::unique_ptr<RowGroupMetaData>(new RowGroupMetaData(
       metadata,
       schema,
-      default_reader_properties(),
-      writer_version,
-      std::move(file_decryptor)));
+      defaultReaderProperties(),
+      writerVersion,
+      std::move(fileDecryptor)));
 }
 
-std::unique_ptr<RowGroupMetaData> RowGroupMetaData::Make(
+std::unique_ptr<RowGroupMetaData> RowGroupMetaData::make(
     const void* metadata,
     const SchemaDescriptor* schema,
     const ReaderProperties& properties,
-    const ApplicationVersion* writer_version,
-    std::shared_ptr<InternalFileDecryptor> file_decryptor) {
+    const ApplicationVersion* writerVersion,
+    std::shared_ptr<InternalFileDecryptor> fileDecryptor) {
   return std::unique_ptr<RowGroupMetaData>(new RowGroupMetaData(
-      metadata, schema, properties, writer_version, std::move(file_decryptor)));
+      metadata, schema, properties, writerVersion, std::move(fileDecryptor)));
 }
 
 RowGroupMetaData::RowGroupMetaData(
     const void* metadata,
     const SchemaDescriptor* schema,
     const ReaderProperties& properties,
-    const ApplicationVersion* writer_version,
-    std::shared_ptr<InternalFileDecryptor> file_decryptor)
+    const ApplicationVersion* writerVersion,
+    std::shared_ptr<InternalFileDecryptor> fileDecryptor)
     : impl_{new RowGroupMetaDataImpl(
           reinterpret_cast<const facebook::velox::parquet::thrift::RowGroup*>(
               metadata),
           schema,
           properties,
-          writer_version,
-          std::move(file_decryptor))} {}
+          writerVersion,
+          std::move(fileDecryptor))} {}
 
 RowGroupMetaData::~RowGroupMetaData() = default;
 
-bool RowGroupMetaData::Equals(const RowGroupMetaData& other) const {
-  return impl_->Equals(*other.impl_);
+bool RowGroupMetaData::equals(const RowGroupMetaData& other) const {
+  return impl_->equals(*other.impl_);
 }
 
-int RowGroupMetaData::num_columns() const {
-  return impl_->num_columns();
+int RowGroupMetaData::numColumns() const {
+  return impl_->numColumns();
 }
 
-int64_t RowGroupMetaData::num_rows() const {
-  return impl_->num_rows();
+int64_t RowGroupMetaData::numRows() const {
+  return impl_->numRows();
 }
 
-int64_t RowGroupMetaData::total_byte_size() const {
-  return impl_->total_byte_size();
+int64_t RowGroupMetaData::totalByteSize() const {
+  return impl_->totalByteSize();
 }
 
-int64_t RowGroupMetaData::total_compressed_size() const {
-  return impl_->total_compressed_size();
+int64_t RowGroupMetaData::totalCompressedSize() const {
+  return impl_->totalCompressedSize();
 }
 
-int64_t RowGroupMetaData::file_offset() const {
-  return impl_->file_offset();
+int64_t RowGroupMetaData::fileOffset() const {
+  return impl_->fileOffset();
 }
 
 const SchemaDescriptor* RowGroupMetaData::schema() const {
   return impl_->schema();
 }
 
-std::unique_ptr<ColumnChunkMetaData> RowGroupMetaData::ColumnChunk(
+std::unique_ptr<ColumnChunkMetaData> RowGroupMetaData::columnChunk(
     int i) const {
-  return impl_->ColumnChunk(i);
+  return impl_->columnChunk(i);
 }
 
-bool RowGroupMetaData::can_decompress() const {
-  int n_columns = num_columns();
-  for (int i = 0; i < n_columns; i++) {
-    if (!ColumnChunk(i)->can_decompress()) {
+bool RowGroupMetaData::canDecompress() const {
+  int nColumns = numColumns();
+  for (int i = 0; i < nColumns; i++) {
+    if (!columnChunk(i)->canDecompress()) {
       return false;
     }
   }
   return true;
 }
 
-std::vector<SortingColumn> RowGroupMetaData::sorting_columns() const {
-  return impl_->sorting_columns();
+std::vector<SortingColumn> RowGroupMetaData::sortingColumns() const {
+  return impl_->sortingColumns();
 }
 
-// file metadata
+// File metadata.
 class FileMetaData::FileMetaDataImpl {
  public:
   FileMetaDataImpl() = default;
 
   explicit FileMetaDataImpl(
       const void* metadata,
-      uint32_t* metadata_len,
+      uint32_t* metadataLen,
       ReaderProperties properties,
-      std::shared_ptr<InternalFileDecryptor> file_decryptor = nullptr)
+      std::shared_ptr<InternalFileDecryptor> fileDecryptor = nullptr)
       : properties_(std::move(properties)),
-        file_decryptor_(std::move(file_decryptor)) {
+        fileDecryptor_(std::move(fileDecryptor)) {
     metadata_ =
         std::make_unique<facebook::velox::parquet::thrift::FileMetaData>();
 
-    auto footer_decryptor = file_decryptor_ != nullptr
-        ? file_decryptor_->GetFooterDecryptor()
+    auto footerDecryptor = fileDecryptor_ != nullptr
+        ? fileDecryptor_->getFooterDecryptor()
         : nullptr;
 
     ThriftDeserializer deserializer(properties_);
-    deserializer.DeserializeMessage(
+    deserializer.deserializeMessage(
         reinterpret_cast<const uint8_t*>(metadata),
-        metadata_len,
+        metadataLen,
         metadata_.get(),
-        footer_decryptor);
-    metadata_len_ = *metadata_len;
+        footerDecryptor);
+    metadataLen_ = *metadataLen;
 
     if (metadata_->__isset.created_by) {
-      writer_version_ = ApplicationVersion(metadata_->created_by);
+      writerVersion_ = ApplicationVersion(metadata_->created_by);
     } else {
-      writer_version_ = ApplicationVersion("unknown 0.0.0");
+      writerVersion_ = ApplicationVersion("unknown 0.0.0");
     }
 
-    InitSchema();
-    InitColumnOrders();
-    InitKeyValueMetadata();
+    initSchema();
+    initColumnOrders();
+    initKeyValueMetadata();
   }
 
-  bool VerifySignature(const void* signature) {
-    // verify decryption properties are set
-    if (file_decryptor_ == nullptr) {
+  bool verifySignature(const void* signature) {
+    // Verify decryption properties are set.
+    if (fileDecryptor_ == nullptr) {
       throw ParquetException(
-          "Decryption not set properly. cannot verify signature");
+          "Decryption not set properly. Cannot verify signature.");
     }
-    // serialize the footer
-    uint8_t* serialized_data;
-    uint32_t serialized_len = metadata_len_;
+    // Serialize the footer.
+    uint8_t* serializedData;
+    uint32_t serializedLen = metadataLen_;
     ThriftSerializer serializer;
-    serializer.SerializeToBuffer(
-        metadata_.get(), &serialized_len, &serialized_data);
+    serializer.serializeToBuffer(
+        metadata_.get(), &serializedLen, &serializedData);
 
-    // encrypt with nonce
+    // Encrypt with nonce.
     auto nonce =
         const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(signature));
     auto tag =
         const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(signature)) +
         encryption::kNonceLength;
 
-    std::string key = file_decryptor_->GetFooterKey();
-    std::string aad = encryption::CreateFooterAad(file_decryptor_->file_aad());
+    std::string key = fileDecryptor_->getFooterKey();
+    std::string aad = encryption::createFooterAad(fileDecryptor_->fileAad());
 
-    auto aes_encryptor = encryption::AesEncryptor::Make(
-        file_decryptor_->algorithm(),
+    auto aesEncryptor = encryption::AesEncryptor::make(
+        fileDecryptor_->algorithm(),
         static_cast<int>(key.size()),
         true,
         false /*write_length*/,
         nullptr);
 
-    std::shared_ptr<Buffer> encrypted_buffer =
-        std::static_pointer_cast<ResizableBuffer>(AllocateBuffer(
-            file_decryptor_->pool(),
-            aes_encryptor->CiphertextSizeDelta() + serialized_len));
-    uint32_t encrypted_len = aes_encryptor->SignedFooterEncrypt(
-        serialized_data,
-        serialized_len,
+    std::shared_ptr<Buffer> encryptedBuffer =
+        std::static_pointer_cast<ResizableBuffer>(allocateBuffer(
+            fileDecryptor_->pool(),
+            aesEncryptor->ciphertextSizeDelta() + serializedLen));
+    uint32_t encryptedLen = aesEncryptor->signedFooterEncrypt(
+        serializedData,
+        serializedLen,
         str2bytes(key),
         static_cast<int>(key.size()),
         str2bytes(aad),
         static_cast<int>(aad.size()),
         nonce,
-        encrypted_buffer->mutable_data());
-    // Delete AES encryptor object. It was created only to verify the footer
-    // signature.
-    aes_encryptor->WipeOut();
-    delete aes_encryptor;
+        encryptedBuffer->mutable_data());
+    // Delete AES encryptor object. It was created only to verify the footer.
+    // Signature.
+    aesEncryptor->wipeOut();
+    delete aesEncryptor;
     return 0 ==
-        memcmp(encrypted_buffer->data() + encrypted_len -
+        memcmp(encryptedBuffer->data() + encryptedLen -
                    encryption::kGcmTagLength,
                tag,
                encryption::kGcmTagLength);
   }
 
   inline uint32_t size() const {
-    return metadata_len_;
+    return metadataLen_;
   }
-  inline int num_columns() const {
-    return schema_.num_columns();
+  inline int numColumns() const {
+    return schema_.numColumns();
   }
-  inline int64_t num_rows() const {
+  inline int64_t numRows() const {
     return metadata_->num_rows;
   }
-  inline int num_row_groups() const {
+  inline int numRowGroups() const {
     return static_cast<int>(metadata_->row_groups.size());
   }
   inline int32_t version() const {
     return metadata_->version;
   }
-  inline const std::string& created_by() const {
+  inline const std::string& createdBy() const {
     return metadata_->created_by;
   }
-  inline int num_schema_elements() const {
+  inline int numSchemaElements() const {
     return static_cast<int>(metadata_->schema.size());
   }
 
-  inline bool is_encryption_algorithm_set() const {
+  inline bool isEncryptionAlgorithmSet() const {
     return metadata_->__isset.encryption_algorithm;
   }
-  inline EncryptionAlgorithm encryption_algorithm() {
-    return FromThrift(metadata_->encryption_algorithm);
+  inline EncryptionAlgorithm encryptionAlgorithm() {
+    return fromThrift(metadata_->encryption_algorithm);
   }
-  inline const std::string& footer_signing_key_metadata() {
+  inline const std::string& footerSigningKeyMetadata() {
     return metadata_->footer_signing_key_metadata;
   }
 
-  const ApplicationVersion& writer_version() const {
-    return writer_version_;
+  const ApplicationVersion& writerVersion() const {
+    return writerVersion_;
   }
 
-  void WriteTo(
+  void writeTo(
       ::arrow::io::OutputStream* dst,
       const std::shared_ptr<Encryptor>& encryptor) const {
     ThriftSerializer serializer;
-    // Only in encrypted files with plaintext footers the
-    // encryption_algorithm is set in footer
-    if (is_encryption_algorithm_set()) {
-      uint8_t* serialized_data;
-      uint32_t serialized_len;
-      serializer.SerializeToBuffer(
-          metadata_.get(), &serialized_len, &serialized_data);
-
-      // encrypt the footer key
-      std::vector<uint8_t> encrypted_data(
-          encryptor->CiphertextSizeDelta() + serialized_len);
-      unsigned encrypted_len = encryptor->Encrypt(
-          serialized_data, serialized_len, encrypted_data.data());
-
-      // write unencrypted footer
-      PARQUET_THROW_NOT_OK(dst->Write(serialized_data, serialized_len));
+    // Only in encrypted files with plaintext footers the.
+    // Encryption_algorithm is set in footer.
+    if (isEncryptionAlgorithmSet()) {
+      uint8_t* serializedData;
+      uint32_t serializedLen;
+      serializer.serializeToBuffer(
+          metadata_.get(), &serializedLen, &serializedData);
+
+      // Encrypt the footer key.
+      std::vector<uint8_t> encryptedData(
+          encryptor->ciphertextSizeDelta() + serializedLen);
+      unsigned encryptedLen = encryptor->encrypt(
+          serializedData, serializedLen, encryptedData.data());
+
+      // Write unencrypted footer.
+      PARQUET_THROW_NOT_OK(dst->Write(serializedData, serializedLen));
       // Write signature (nonce and tag)
       PARQUET_THROW_NOT_OK(
-          dst->Write(encrypted_data.data() + 4, encryption::kNonceLength));
+          dst->Write(encryptedData.data() + 4, encryption::kNonceLength));
       PARQUET_THROW_NOT_OK(dst->Write(
-          encrypted_data.data() + encrypted_len - encryption::kGcmTagLength,
+          encryptedData.data() + encryptedLen - encryption::kGcmTagLength,
           encryption::kGcmTagLength));
     } else { // either plaintext file (when encryptor is null)
-      // or encrypted file with encrypted footer
-      serializer.Serialize(metadata_.get(), dst, encryptor);
+      // Or encrypted file with encrypted footer.
+      serializer.serialize(metadata_.get(), dst, encryptor);
     }
   }
 
-  std::unique_ptr<RowGroupMetaData> RowGroup(int i) {
-    if (!(i >= 0 && i < num_row_groups())) {
+  std::unique_ptr<RowGroupMetaData> rowGroup(int i) {
+    if (!(i >= 0 && i < numRowGroups())) {
       std::stringstream ss;
-      ss << "The file only has " << num_row_groups()
+      ss << "The file only has " << numRowGroups()
          << " row groups, requested metadata for row group: " << i;
       throw ParquetException(ss.str());
     }
-    return RowGroupMetaData::Make(
+    return RowGroupMetaData::make(
         &metadata_->row_groups[i],
         &schema_,
         properties_,
-        &writer_version_,
-        file_decryptor_);
+        &writerVersion_,
+        fileDecryptor_);
   }
 
-  bool Equals(const FileMetaDataImpl& other) const {
+  bool equals(const FileMetaDataImpl& other) const {
     return *metadata_ == *other.metadata_;
   }
 
@@ -911,61 +922,60 @@ class FileMetaData::FileMetaDataImpl {
     return &schema_;
   }
 
-  const std::shared_ptr<const KeyValueMetadata>& key_value_metadata() const {
-    return key_value_metadata_;
+  const std::shared_ptr<const KeyValueMetadata>& keyValueMetadata() const {
+    return keyValueMetadata_;
   }
 
-  void set_file_path(const std::string& path) {
-    for (facebook::velox::parquet::thrift::RowGroup& row_group :
+  void setFilePath(const std::string& path) {
+    for (facebook::velox::parquet::thrift::RowGroup& rowGroup :
          metadata_->row_groups) {
       for (facebook::velox::parquet::thrift::ColumnChunk& chunk :
-           row_group.columns) {
+           rowGroup.columns) {
         chunk.__set_file_path(path);
       }
     }
   }
 
-  facebook::velox::parquet::thrift::RowGroup& row_group(int i) {
-    if (!(i >= 0 && i < num_row_groups())) {
+  facebook::velox::parquet::thrift::RowGroup& thriftRowGroup(int i) {
+    if (!(i >= 0 && i < numRowGroups())) {
       std::stringstream ss;
-      ss << "The file only has " << num_row_groups()
+      ss << "The file only has " << numRowGroups()
          << " row groups, requested metadata for row group: " << i;
       throw ParquetException(ss.str());
     }
     return metadata_->row_groups[i];
   }
 
-  void AppendRowGroups(const std::unique_ptr<FileMetaDataImpl>& other) {
-    std::ostringstream diff_output;
-    if (!schema()->Equals(*other->schema(), &diff_output)) {
-      auto msg =
-          "AppendRowGroups requires equal schemas.\n" + diff_output.str();
+  void appendRowGroups(const std::unique_ptr<FileMetaDataImpl>& other) {
+    std::ostringstream diffOutput;
+    if (!schema()->equals(*other->schema(), &diffOutput)) {
+      auto msg = "AppendRowGroups requires equal schemas.\n" + diffOutput.str();
       throw ParquetException(msg);
     }
 
-    // ARROW-13654: `other` may point to self, be careful not to enter an
-    // infinite loop
-    const int n = other->num_row_groups();
-    // ARROW-16613: do not use reserve() as that may suppress overallocation
-    // and incur O(n²) behavior on repeated calls to AppendRowGroups().
-    // (see https://en.cppreference.com/w/cpp/container/vector/reserve
-    //  about inappropriate uses of reserve()).
+    // ARROW-13654: `other` may point to self, be careful not to enter an.
+    // Infinite loop.
+    const int n = other->numRowGroups();
+    // ARROW-16613: do not use reserve() as that may suppress overallocation.
+    // And incur O(n²) behavior on repeated calls to AppendRowGroups().
+    // (See https://en.cppreference.com/w/cpp/container/vector/reserve.
+    //  About inappropriate uses of reserve()).
     const auto start = metadata_->row_groups.size();
     metadata_->row_groups.resize(start + n);
     for (int i = 0; i < n; i++) {
-      metadata_->row_groups[start + i] = other->row_group(i);
+      metadata_->row_groups[start + i] = other->thriftRowGroup(i);
       metadata_->num_rows += metadata_->row_groups[start + i].num_rows;
     }
   }
 
-  std::shared_ptr<FileMetaData> Subset(const std::vector<int>& row_groups) {
-    for (int i : row_groups) {
-      if (i < num_row_groups())
+  std::shared_ptr<FileMetaData> subset(const std::vector<int>& rowGroups) {
+    for (int i : rowGroups) {
+      if (i < numRowGroups())
         continue;
 
       throw ParquetException(
           "The file only has ",
-          num_row_groups(),
+          numRowGroups(),
           " row groups, but requested a subset including row group: ",
           i);
     }
@@ -979,11 +989,11 @@ class FileMetaData::FileMetaDataImpl {
     metadata->version = metadata_->version;
     metadata->schema = metadata_->schema;
 
-    metadata->row_groups.resize(row_groups.size());
+    metadata->row_groups.resize(rowGroups.size());
     int i = 0;
-    for (int selected_index : row_groups) {
-      metadata->num_rows += row_group(selected_index).num_rows;
-      metadata->row_groups[i++] = row_group(selected_index);
+    for (int selectedIndex : rowGroups) {
+      metadata->num_rows += thriftRowGroup(selectedIndex).num_rows;
+      metadata->row_groups[i++] = thriftRowGroup(selectedIndex);
     }
 
     metadata->key_value_metadata = metadata_->key_value_metadata;
@@ -995,56 +1005,75 @@ class FileMetaData::FileMetaDataImpl {
     metadata->__isset = metadata_->__isset;
 
     out->impl_->schema_ = schema_;
-    out->impl_->writer_version_ = writer_version_;
-    out->impl_->key_value_metadata_ = key_value_metadata_;
-    out->impl_->file_decryptor_ = file_decryptor_;
+    out->impl_->writerVersion_ = writerVersion_;
+    out->impl_->keyValueMetadata_ = keyValueMetadata_;
+    out->impl_->fileDecryptor_ = fileDecryptor_;
 
     return out;
   }
 
-  void set_file_decryptor(
-      std::shared_ptr<InternalFileDecryptor> file_decryptor) {
-    file_decryptor_ = file_decryptor;
+  void setFileDecryptor(std::shared_ptr<InternalFileDecryptor> fileDecryptor) {
+    fileDecryptor_ = fileDecryptor;
+  }
+
+  // Set NaN counts from the builder (called during Finish)
+  // This stores total NaN counts per field ID across all row groups.
+  void setNaNCounts(
+      std::unordered_map<int32_t, std::pair<int64_t, bool>> nan_counts) {
+    fieldNanCounts_ = std::move(nan_counts);
+  }
+
+  // Get total NaN count for a specific field ID across all row groups.
+  std::pair<int64_t, bool> getNaNCount(int32_t fieldId) const {
+    auto it = fieldNanCounts_.find(fieldId);
+    if (it != fieldNanCounts_.end()) {
+      return it->second;
+    }
+    return {0, false};
   }
 
  private:
   friend FileMetaDataBuilder;
-  uint32_t metadata_len_ = 0;
+  uint32_t metadataLen_ = 0;
   std::unique_ptr<facebook::velox::parquet::thrift::FileMetaData> metadata_;
   SchemaDescriptor schema_;
-  ApplicationVersion writer_version_;
-  std::shared_ptr<const KeyValueMetadata> key_value_metadata_;
+  ApplicationVersion writerVersion_;
+  std::shared_ptr<const KeyValueMetadata> keyValueMetadata_;
   const ReaderProperties properties_;
-  std::shared_ptr<InternalFileDecryptor> file_decryptor_;
+  std::shared_ptr<InternalFileDecryptor> fileDecryptor_;
+  // Total NaN counts per field ID across all row groups: field_id ->
+  // (nan_count, has_nan_count).
+  std::unordered_map<int32_t, std::pair<int64_t, bool>> fieldNanCounts_;
 
-  void InitSchema() {
+  void initSchema() {
     if (metadata_->schema.empty()) {
       throw ParquetException("Empty file schema (no root)");
     }
-    schema_.Init(schema::Unflatten(
-        &metadata_->schema[0], static_cast<int>(metadata_->schema.size())));
+    schema_.init(
+        schema::unflatten(
+            &metadata_->schema[0], static_cast<int>(metadata_->schema.size())));
   }
 
-  void InitColumnOrders() {
-    // update ColumnOrder
-    std::vector<ColumnOrder> column_orders;
+  void initColumnOrders() {
+    // Update ColumnOrder.
+    std::vector<ColumnOrder> columnOrders;
     if (metadata_->__isset.column_orders) {
-      column_orders.reserve(metadata_->column_orders.size());
-      for (auto column_order : metadata_->column_orders) {
-        if (column_order.__isset.TYPE_ORDER) {
-          column_orders.push_back(ColumnOrder::type_defined_);
+      columnOrders.reserve(metadata_->column_orders.size());
+      for (auto columnOrder : metadata_->column_orders) {
+        if (columnOrder.__isset.TYPE_ORDER) {
+          columnOrders.push_back(ColumnOrder::typeDefined_);
         } else {
-          column_orders.push_back(ColumnOrder::undefined_);
+          columnOrders.push_back(ColumnOrder::undefined_);
         }
       }
     } else {
-      column_orders.resize(schema_.num_columns(), ColumnOrder::undefined_);
+      columnOrders.resize(schema_.numColumns(), ColumnOrder::undefined_);
     }
 
-    schema_.updateColumnOrders(column_orders);
+    schema_.updateColumnOrders(columnOrders);
   }
 
-  void InitKeyValueMetadata() {
+  void initKeyValueMetadata() {
     std::shared_ptr<KeyValueMetadata> metadata = nullptr;
     if (metadata_->__isset.key_value_metadata) {
       metadata = std::make_shared<KeyValueMetadata>();
@@ -1052,96 +1081,96 @@ class FileMetaData::FileMetaDataImpl {
         metadata->Append(it.key, it.value);
       }
     }
-    key_value_metadata_ = std::move(metadata);
+    keyValueMetadata_ = std::move(metadata);
   }
 };
 
-std::shared_ptr<FileMetaData> FileMetaData::Make(
+std::shared_ptr<FileMetaData> FileMetaData::make(
     const void* metadata,
-    uint32_t* metadata_len,
+    uint32_t* metadataLen,
     const ReaderProperties& properties,
-    std::shared_ptr<InternalFileDecryptor> file_decryptor) {
-  // This FileMetaData ctor is private, not compatible with std::make_shared
+    std::shared_ptr<InternalFileDecryptor> fileDecryptor) {
+  // This FileMetaData ctor is private, not compatible with std::make_shared.
   return std::shared_ptr<FileMetaData>(new FileMetaData(
-      metadata, metadata_len, properties, std::move(file_decryptor)));
+      metadata, metadataLen, properties, std::move(fileDecryptor)));
 }
 
-std::shared_ptr<FileMetaData> FileMetaData::Make(
+std::shared_ptr<FileMetaData> FileMetaData::make(
     const void* metadata,
-    uint32_t* metadata_len,
-    std::shared_ptr<InternalFileDecryptor> file_decryptor) {
+    uint32_t* metadataLen,
+    std::shared_ptr<InternalFileDecryptor> fileDecryptor) {
   return std::shared_ptr<FileMetaData>(new FileMetaData(
-      metadata, metadata_len, default_reader_properties(), file_decryptor));
+      metadata, metadataLen, defaultReaderProperties(), fileDecryptor));
 }
 
 FileMetaData::FileMetaData(
     const void* metadata,
-    uint32_t* metadata_len,
+    uint32_t* metadataLen,
     const ReaderProperties& properties,
-    std::shared_ptr<InternalFileDecryptor> file_decryptor)
+    std::shared_ptr<InternalFileDecryptor> fileDecryptor)
     : impl_(new FileMetaDataImpl(
           metadata,
-          metadata_len,
+          metadataLen,
           properties,
-          file_decryptor)) {}
+          fileDecryptor)) {}
 
 FileMetaData::FileMetaData() : impl_(new FileMetaDataImpl()) {}
 
 FileMetaData::~FileMetaData() = default;
 
-bool FileMetaData::Equals(const FileMetaData& other) const {
-  return impl_->Equals(*other.impl_);
+bool FileMetaData::equals(const FileMetaData& other) const {
+  return impl_->equals(*other.impl_);
 }
 
-std::unique_ptr<RowGroupMetaData> FileMetaData::RowGroup(int i) const {
-  return impl_->RowGroup(i);
+std::unique_ptr<RowGroupMetaData> FileMetaData::rowGroup(int i) const {
+  return impl_->rowGroup(i);
 }
 
-bool FileMetaData::VerifySignature(const void* signature) {
-  return impl_->VerifySignature(signature);
+bool FileMetaData::verifySignature(const void* signature) {
+  return impl_->verifySignature(signature);
 }
 
 uint32_t FileMetaData::size() const {
   return impl_->size();
 }
 
-int FileMetaData::num_columns() const {
-  return impl_->num_columns();
+int FileMetaData::numColumns() const {
+  return impl_->numColumns();
 }
 
-int64_t FileMetaData::num_rows() const {
-  return impl_->num_rows();
+int64_t FileMetaData::numRows() const {
+  return impl_->numRows();
 }
 
-int FileMetaData::num_row_groups() const {
-  return impl_->num_row_groups();
+int FileMetaData::numRowGroups() const {
+  return impl_->numRowGroups();
 }
 
-bool FileMetaData::can_decompress() const {
-  int n_row_groups = num_row_groups();
-  for (int i = 0; i < n_row_groups; i++) {
-    if (!RowGroup(i)->can_decompress()) {
+bool FileMetaData::canDecompress() const {
+  int nRowGroups = numRowGroups();
+  for (int i = 0; i < nRowGroups; i++) {
+    if (!rowGroup(i)->canDecompress()) {
       return false;
     }
   }
   return true;
 }
 
-bool FileMetaData::is_encryption_algorithm_set() const {
-  return impl_->is_encryption_algorithm_set();
+bool FileMetaData::isEncryptionAlgorithmSet() const {
+  return impl_->isEncryptionAlgorithmSet();
 }
 
-EncryptionAlgorithm FileMetaData::encryption_algorithm() const {
-  return impl_->encryption_algorithm();
+EncryptionAlgorithm FileMetaData::encryptionAlgorithm() const {
+  return impl_->encryptionAlgorithm();
 }
 
-const std::string& FileMetaData::footer_signing_key_metadata() const {
-  return impl_->footer_signing_key_metadata();
+const std::string& FileMetaData::footerSigningKeyMetadata() const {
+  return impl_->footerSigningKeyMetadata();
 }
 
-void FileMetaData::set_file_decryptor(
-    std::shared_ptr<InternalFileDecryptor> file_decryptor) {
-  impl_->set_file_decryptor(file_decryptor);
+void FileMetaData::setFileDecryptor(
+    std::shared_ptr<InternalFileDecryptor> fileDecryptor) {
+  impl_->setFileDecryptor(fileDecryptor);
 }
 
 ParquetVersion::type FileMetaData::version() const {
@@ -1151,50 +1180,54 @@ ParquetVersion::type FileMetaData::version() const {
     case 2:
       return ParquetVersion::PARQUET_2_LATEST;
     default:
-      // Improperly set version, assuming Parquet 1.0
+      // Improperly set version, assuming Parquet 1.0.
       break;
   }
   return ParquetVersion::PARQUET_1_0;
 }
 
-const ApplicationVersion& FileMetaData::writer_version() const {
-  return impl_->writer_version();
+const ApplicationVersion& FileMetaData::writerVersion() const {
+  return impl_->writerVersion();
 }
 
-const std::string& FileMetaData::created_by() const {
-  return impl_->created_by();
+const std::string& FileMetaData::createdBy() const {
+  return impl_->createdBy();
 }
 
-int FileMetaData::num_schema_elements() const {
-  return impl_->num_schema_elements();
+int FileMetaData::numSchemaElements() const {
+  return impl_->numSchemaElements();
 }
 
 const SchemaDescriptor* FileMetaData::schema() const {
   return impl_->schema();
 }
 
-const std::shared_ptr<const KeyValueMetadata>&
-FileMetaData::key_value_metadata() const {
-  return impl_->key_value_metadata();
+const std::shared_ptr<const KeyValueMetadata>& FileMetaData::keyValueMetadata()
+    const {
+  return impl_->keyValueMetadata();
 }
 
-void FileMetaData::set_file_path(const std::string& path) {
-  impl_->set_file_path(path);
+void FileMetaData::setFilePath(const std::string& path) {
+  impl_->setFilePath(path);
 }
 
-void FileMetaData::AppendRowGroups(const FileMetaData& other) {
-  impl_->AppendRowGroups(other.impl_);
+void FileMetaData::appendRowGroups(const FileMetaData& other) {
+  impl_->appendRowGroups(other.impl_);
 }
 
-std::shared_ptr<FileMetaData> FileMetaData::Subset(
-    const std::vector<int>& row_groups) const {
-  return impl_->Subset(row_groups);
+std::shared_ptr<FileMetaData> FileMetaData::subset(
+    const std::vector<int>& rowGroups) const {
+  return impl_->subset(rowGroups);
 }
 
-void FileMetaData::WriteTo(
+std::pair<int64_t, bool> FileMetaData::getNaNCount(int32_t fieldId) const {
+  return impl_->getNaNCount(fieldId);
+}
+
+void FileMetaData::writeTo(
     ::arrow::io::OutputStream* dst,
     const std::shared_ptr<Encryptor>& encryptor) const {
-  return impl_->WriteTo(dst, encryptor);
+  return impl_->writeTo(dst, encryptor);
 }
 
 class FileCryptoMetaData::FileCryptoMetaDataImpl {
@@ -1203,55 +1236,55 @@ class FileCryptoMetaData::FileCryptoMetaDataImpl {
 
   explicit FileCryptoMetaDataImpl(
       const uint8_t* metadata,
-      uint32_t* metadata_len,
+      uint32_t* metadataLen,
       const ReaderProperties& properties) {
     ThriftDeserializer deserializer(properties);
-    deserializer.DeserializeMessage(metadata, metadata_len, &metadata_);
-    metadata_len_ = *metadata_len;
+    deserializer.deserializeMessage(metadata, metadataLen, &metadata_);
+    metadataLen_ = *metadataLen;
   }
 
-  EncryptionAlgorithm encryption_algorithm() const {
-    return FromThrift(metadata_.encryption_algorithm);
+  EncryptionAlgorithm encryptionAlgorithm() const {
+    return fromThrift(metadata_.encryption_algorithm);
   }
 
-  const std::string& key_metadata() const {
+  const std::string& keyMetadata() const {
     return metadata_.key_metadata;
   }
 
-  void WriteTo(::arrow::io::OutputStream* dst) const {
+  void writeTo(::arrow::io::OutputStream* dst) const {
     ThriftSerializer serializer;
-    serializer.Serialize(&metadata_, dst);
+    serializer.serialize(&metadata_, dst);
   }
 
  private:
   friend FileMetaDataBuilder;
   facebook::velox::parquet::thrift::FileCryptoMetaData metadata_;
-  uint32_t metadata_len_;
+  uint32_t metadataLen_;
 };
 
-EncryptionAlgorithm FileCryptoMetaData::encryption_algorithm() const {
-  return impl_->encryption_algorithm();
+EncryptionAlgorithm FileCryptoMetaData::encryptionAlgorithm() const {
+  return impl_->encryptionAlgorithm();
 }
 
-const std::string& FileCryptoMetaData::key_metadata() const {
-  return impl_->key_metadata();
+const std::string& FileCryptoMetaData::keyMetadata() const {
+  return impl_->keyMetadata();
 }
 
-std::shared_ptr<FileCryptoMetaData> FileCryptoMetaData::Make(
-    const uint8_t* serialized_metadata,
-    uint32_t* metadata_len,
+std::shared_ptr<FileCryptoMetaData> FileCryptoMetaData::make(
+    const uint8_t* serializedMetadata,
+    uint32_t* metadataLen,
     const ReaderProperties& properties) {
   return std::shared_ptr<FileCryptoMetaData>(
-      new FileCryptoMetaData(serialized_metadata, metadata_len, properties));
+      new FileCryptoMetaData(serializedMetadata, metadataLen, properties));
 }
 
 FileCryptoMetaData::FileCryptoMetaData(
-    const uint8_t* serialized_metadata,
-    uint32_t* metadata_len,
+    const uint8_t* serializedMetadata,
+    uint32_t* metadataLen,
     const ReaderProperties& properties)
     : impl_(new FileCryptoMetaDataImpl(
-          serialized_metadata,
-          metadata_len,
+          serializedMetadata,
+          metadataLen,
           properties)) {}
 
 FileCryptoMetaData::FileCryptoMetaData()
@@ -1259,18 +1292,18 @@ FileCryptoMetaData::FileCryptoMetaData()
 
 FileCryptoMetaData::~FileCryptoMetaData() = default;
 
-void FileCryptoMetaData::WriteTo(::arrow::io::OutputStream* dst) const {
-  impl_->WriteTo(dst);
+void FileCryptoMetaData::writeTo(::arrow::io::OutputStream* dst) const {
+  impl_->writeTo(dst);
 }
 
-std::string FileMetaData::SerializeToString() const {
-  // We need to pass in an initial size. Since it will automatically
-  // increase the buffer size to hold the metadata, we just leave it 0.
+std::string FileMetaData::serializeToString() const {
+  // We need to pass in an initial size. Since it will automatically.
+  // Increase the buffer size to hold the metadata, we just leave it 0.
   PARQUET_ASSIGN_OR_THROW(
       auto serializer, ::arrow::io::BufferOutputStream::Create(0));
-  WriteTo(serializer.get());
-  PARQUET_ASSIGN_OR_THROW(auto metadata_buffer, serializer->Finish());
-  return metadata_buffer->ToString();
+  writeTo(serializer.get());
+  PARQUET_ASSIGN_OR_THROW(auto metadataBuffer, serializer->Finish());
+  return metadataBuffer->ToString();
 }
 
 ApplicationVersion::ApplicationVersion(
@@ -1282,609 +1315,618 @@ ApplicationVersion::ApplicationVersion(
       version{major, minor, patch, "", "", ""} {}
 
 namespace {
-// Parse the application version format and set parsed values to
+// Parse the application version format and set parsed values to.
 // ApplicationVersion.
 //
-// The application version format must be compatible parquet-mr's
-// one. See also:
-//   * https://github.com/apache/parquet-mr/blob/master/parquet-common/src/main/java/org/apache/parquet/VersionParser.java
-//   * https://github.com/apache/parquet-mr/blob/master/parquet-common/src/main/java/org/apache/parquet/SemanticVersion.java
+// The application version format must be compatible parquet-mr's.
+// One. See also:
+//   * Https://github.com/apache/parquet-mr/blob/master/parquet-common/src/main/java/org/apache/parquet/VersionParser.java.
+//   * Https://github.com/apache/parquet-mr/blob/master/parquet-common/src/main/java/org/apache/parquet/SemanticVersion.java.
 //
 // The application version format:
-//   "${APPLICATION_NAME}"
-//   "${APPLICATION_NAME} version ${VERSION}"
-//   "${APPLICATION_NAME} version ${VERSION} (build ${BUILD_NAME})"
+//   "${APPLICATION_NAME}".
+//   "${APPLICATION_NAME} version ${VERSION}".
+//   "${APPLICATION_NAME} version ${VERSION} (build ${BUILD_NAME})".
 //
 // Eg:
-//   parquet-cpp
-//   parquet-cpp version 1.5.0ab-xyz5.5.0+cd
+//   Parquet-cpp.
+//   Parquet-cpp version 1.5.0ab-xyz5.5.0+cd.
 //   parquet-cpp version 1.5.0ab-xyz5.5.0+cd (build abcd)
 //
 // The VERSION format:
-//   "${MAJOR}"
-//   "${MAJOR}.${MINOR}"
-//   "${MAJOR}.${MINOR}.${PATCH}"
-//   "${MAJOR}.${MINOR}.${PATCH}${UNKNOWN}"
-//   "${MAJOR}.${MINOR}.${PATCH}${UNKNOWN}-${PRE_RELEASE}"
-//   "${MAJOR}.${MINOR}.${PATCH}${UNKNOWN}-${PRE_RELEASE}+${BUILD_INFO}"
-//   "${MAJOR}.${MINOR}.${PATCH}${UNKNOWN}+${BUILD_INFO}"
-//   "${MAJOR}.${MINOR}.${PATCH}-${PRE_RELEASE}"
-//   "${MAJOR}.${MINOR}.${PATCH}-${PRE_RELEASE}+${BUILD_INFO}"
-//   "${MAJOR}.${MINOR}.${PATCH}+${BUILD_INFO}"
+//   "${MAJOR}".
+//   "${MAJOR}.${MINOR}".
+//   "${MAJOR}.${MINOR}.${PATCH}".
+//   "${MAJOR}.${MINOR}.${PATCH}${UNKNOWN}".
+//   "${MAJOR}.${MINOR}.${PATCH}${UNKNOWN}-${PRE_RELEASE}".
+//   "${MAJOR}.${MINOR}.${PATCH}${UNKNOWN}-${PRE_RELEASE}+${BUILD_INFO}".
+//   "${MAJOR}.${MINOR}.${PATCH}${UNKNOWN}+${BUILD_INFO}".
+//   "${MAJOR}.${MINOR}.${PATCH}-${PRE_RELEASE}".
+//   "${MAJOR}.${MINOR}.${PATCH}-${PRE_RELEASE}+${BUILD_INFO}".
+//   "${MAJOR}.${MINOR}.${PATCH}+${BUILD_INFO}".
 //
 // Eg:
-//   1
-//   1.5
-//   1.5.0
-//   1.5.0ab
-//   1.5.0ab-cdh5.5.0
-//   1.5.0ab-cdh5.5.0+cd
-//   1.5.0ab+cd
-//   1.5.0-cdh5.5.0
-//   1.5.0-cdh5.5.0+cd
-//   1.5.0+cd
+//   1.
+//   1.5.
+//   1.5.0.
+//   1.5.0Ab.
+//   1.5.0Ab-cdh5.5.0.
+//   1.5.0Ab-cdh5.5.0+cd.
+//   1.5.0Ab+cd.
+//   1.5.0-Cdh5.5.0.
+//   1.5.0-Cdh5.5.0+cd.
+//   1.5.0+Cd.
 class ApplicationVersionParser {
  public:
   ApplicationVersionParser(
-      const std::string& created_by,
-      ApplicationVersion& application_version)
-      : created_by_(created_by),
-        application_version_(application_version),
+      const std::string& createdBy,
+      ApplicationVersion& ApplicationVersion)
+      : createdBy_(createdBy),
+        ApplicationVersion_(ApplicationVersion),
         spaces_(" \t\v\r\n\f"),
         digits_("0123456789") {}
 
-  void Parse() {
-    application_version_.application_ = "unknown";
-    application_version_.version = {0, 0, 0, "", "", ""};
+  void parse() {
+    ApplicationVersion_.application_ = "unknown";
+    ApplicationVersion_.version = {0, 0, 0, "", "", ""};
 
-    if (!ParseApplicationName()) {
+    if (!parseApplicationName()) {
       return;
     }
-    if (!ParseVersion()) {
+    if (!parseVersion()) {
       return;
     }
-    if (!ParseBuildName()) {
+    if (!parseBuildName()) {
       return;
     }
   }
 
  private:
-  bool IsSpace(const std::string& string, const size_t& offset) {
-    auto target = ::std::string_view(string).substr(offset, 1);
+  bool isSpace(const std::string& text, const size_t& offset) {
+    auto target = ::std::string_view(text).substr(offset, 1);
     return target.find_first_of(spaces_) != ::std::string_view::npos;
   }
 
-  void RemovePrecedingSpaces(
-      const std::string& string,
+  void removePrecedingSpaces(
+      const std::string& text,
       size_t& start,
       const size_t& end) {
-    while (start < end && IsSpace(string, start)) {
+    while (start < end && isSpace(text, start)) {
       ++start;
     }
   }
 
-  void RemoveTrailingSpaces(
-      const std::string& string,
+  void removeTrailingSpaces(
+      const std::string& text,
       const size_t& start,
       size_t& end) {
-    while (start < (end - 1) && (end - 1) < string.size() &&
-           IsSpace(string, end - 1)) {
+    while (start < (end - 1) && (end - 1) < text.size() &&
+           isSpace(text, end - 1)) {
       --end;
     }
   }
 
-  bool ParseApplicationName() {
-    std::string version_mark(" version ");
-    auto version_mark_position = created_by_.find(version_mark);
-    size_t application_name_end;
+  bool parseApplicationName() {
+    std::string versionMark(" version ");
+    auto versionMarkPosition = createdBy_.find(versionMark);
+    size_t applicationNameEnd;
     // No VERSION and BUILD_NAME.
-    if (version_mark_position == std::string::npos) {
-      version_start_ = std::string::npos;
-      application_name_end = created_by_.size();
+    if (versionMarkPosition == std::string::npos) {
+      versionStart_ = std::string::npos;
+      applicationNameEnd = createdBy_.size();
     } else {
-      version_start_ = version_mark_position + version_mark.size();
-      application_name_end = version_mark_position;
+      versionStart_ = versionMarkPosition + versionMark.size();
+      applicationNameEnd = versionMarkPosition;
     }
 
-    size_t application_name_start = 0;
-    RemovePrecedingSpaces(
-        created_by_, application_name_start, application_name_end);
-    RemoveTrailingSpaces(
-        created_by_, application_name_start, application_name_end);
-    application_version_.application_ = created_by_.substr(
-        application_name_start, application_name_end - application_name_start);
+    size_t applicationNameStart = 0;
+    removePrecedingSpaces(createdBy_, applicationNameStart, applicationNameEnd);
+    removeTrailingSpaces(createdBy_, applicationNameStart, applicationNameEnd);
+    ApplicationVersion_.application_ = createdBy_.substr(
+        applicationNameStart, applicationNameEnd - applicationNameStart);
 
     return true;
   }
 
-  bool ParseVersion() {
+  bool parseVersion() {
     // No VERSION.
-    if (version_start_ == std::string::npos) {
+    if (versionStart_ == std::string::npos) {
       return false;
     }
 
-    RemovePrecedingSpaces(created_by_, version_start_, created_by_.size());
-    version_end_ = created_by_.find(" (", version_start_);
+    removePrecedingSpaces(createdBy_, versionStart_, createdBy_.size());
+    versionEnd_ = createdBy_.find(" (", versionStart_);
     // No BUILD_NAME.
-    if (version_end_ == std::string::npos) {
-      version_end_ = created_by_.size();
+    if (versionEnd_ == std::string::npos) {
+      versionEnd_ = createdBy_.size();
     }
-    RemoveTrailingSpaces(created_by_, version_start_, version_end_);
+    removeTrailingSpaces(createdBy_, versionStart_, versionEnd_);
     // No VERSION.
-    if (version_start_ == version_end_) {
+    if (versionStart_ == versionEnd_) {
       return false;
     }
-    version_string_ =
-        created_by_.substr(version_start_, version_end_ - version_start_);
+    versionString_ =
+        createdBy_.substr(versionStart_, versionEnd_ - versionStart_);
 
-    if (!ParseVersionMajor()) {
+    if (!parseVersionMajor()) {
       return false;
     }
-    if (!ParseVersionMinor()) {
+    if (!parseVersionMinor()) {
       return false;
     }
-    if (!ParseVersionPatch()) {
+    if (!parseVersionPatch()) {
       return false;
     }
-    if (!ParseVersionUnknown()) {
+    if (!parseVersionUnknown()) {
       return false;
     }
-    if (!ParseVersionPreRelease()) {
+    if (!parseVersionPreRelease()) {
       return false;
     }
-    if (!ParseVersionBuildInfo()) {
+    if (!parseVersionBuildInfo()) {
       return false;
     }
 
     return true;
   }
 
-  bool ParseVersionMajor() {
-    size_t version_major_start = 0;
-    auto version_major_end = version_string_.find_first_not_of(digits_);
+  bool parseVersionMajor() {
+    size_t versionMajorStart = 0;
+    auto versionMajorEnd = versionString_.find_first_not_of(digits_);
     // MAJOR only.
-    if (version_major_end == std::string::npos) {
-      version_major_end = version_string_.size();
-      version_parsing_position_ = version_major_end;
+    if (versionMajorEnd == std::string::npos) {
+      versionMajorEnd = versionString_.size();
+      versionParsingPosition_ = versionMajorEnd;
     } else {
       // No ".".
-      if (version_string_[version_major_end] != '.') {
+      if (versionString_[versionMajorEnd] != '.') {
         return false;
       }
       // No MAJOR.
-      if (version_major_end == version_major_start) {
+      if (versionMajorEnd == versionMajorStart) {
         return false;
       }
-      version_parsing_position_ = version_major_end + 1; // +1 is for '.'.
+      versionParsingPosition_ = versionMajorEnd + 1; // +1 is for '.'.
     }
-    auto version_major_string = version_string_.substr(
-        version_major_start, version_major_end - version_major_start);
-    application_version_.version.major = atoi(version_major_string.c_str());
+    auto versionMajorString = versionString_.substr(
+        versionMajorStart, versionMajorEnd - versionMajorStart);
+    ApplicationVersion_.version.major = atoi(versionMajorString.c_str());
     return true;
   }
 
-  bool ParseVersionMinor() {
-    auto version_minor_start = version_parsing_position_;
-    auto version_minor_end =
-        version_string_.find_first_not_of(digits_, version_minor_start);
+  bool parseVersionMinor() {
+    auto versionMinorStart = versionParsingPosition_;
+    auto versionMinorEnd =
+        versionString_.find_first_not_of(digits_, versionMinorStart);
     // MAJOR.MINOR only.
-    if (version_minor_end == std::string::npos) {
-      version_minor_end = version_string_.size();
-      version_parsing_position_ = version_minor_end;
+    if (versionMinorEnd == std::string::npos) {
+      versionMinorEnd = versionString_.size();
+      versionParsingPosition_ = versionMinorEnd;
     } else {
       // No ".".
-      if (version_string_[version_minor_end] != '.') {
+      if (versionString_[versionMinorEnd] != '.') {
         return false;
       }
       // No MINOR.
-      if (version_minor_end == version_minor_start) {
+      if (versionMinorEnd == versionMinorStart) {
         return false;
       }
-      version_parsing_position_ = version_minor_end + 1; // +1 is for '.'.
+      versionParsingPosition_ = versionMinorEnd + 1; // +1 is for '.'.
     }
-    auto version_minor_string = version_string_.substr(
-        version_minor_start, version_minor_end - version_minor_start);
-    application_version_.version.minor = atoi(version_minor_string.c_str());
+    auto versionMinorString = versionString_.substr(
+        versionMinorStart, versionMinorEnd - versionMinorStart);
+    ApplicationVersion_.version.minor = atoi(versionMinorString.c_str());
     return true;
   }
 
-  bool ParseVersionPatch() {
-    auto version_patch_start = version_parsing_position_;
-    auto version_patch_end =
-        version_string_.find_first_not_of(digits_, version_patch_start);
+  bool parseVersionPatch() {
+    auto versionPatchStart = versionParsingPosition_;
+    auto versionPatchEnd =
+        versionString_.find_first_not_of(digits_, versionPatchStart);
     // No UNKNOWN, PRE_RELEASE and BUILD_INFO.
-    if (version_patch_end == std::string::npos) {
-      version_patch_end = version_string_.size();
+    if (versionPatchEnd == std::string::npos) {
+      versionPatchEnd = versionString_.size();
     }
     // No PATCH.
-    if (version_patch_end == version_patch_start) {
+    if (versionPatchEnd == versionPatchStart) {
       return false;
     }
-    auto version_patch_string = version_string_.substr(
-        version_patch_start, version_patch_end - version_patch_start);
-    application_version_.version.patch = atoi(version_patch_string.c_str());
-    version_parsing_position_ = version_patch_end;
+    auto versionPatchString = versionString_.substr(
+        versionPatchStart, versionPatchEnd - versionPatchStart);
+    ApplicationVersion_.version.patch = atoi(versionPatchString.c_str());
+    versionParsingPosition_ = versionPatchEnd;
     return true;
   }
 
-  bool ParseVersionUnknown() {
+  bool parseVersionUnknown() {
     // No UNKNOWN.
-    if (version_parsing_position_ == version_string_.size()) {
+    if (versionParsingPosition_ == versionString_.size()) {
       return true;
     }
-    auto version_unknown_start = version_parsing_position_;
-    auto version_unknown_end =
-        version_string_.find_first_of("-+", version_unknown_start);
-    // No PRE_RELEASE and BUILD_INFO
-    if (version_unknown_end == std::string::npos) {
-      version_unknown_end = version_string_.size();
+    auto versionUnknownStart = versionParsingPosition_;
+    auto versionUnknownEnd =
+        versionString_.find_first_of("-+", versionUnknownStart);
+    // No PRE_RELEASE and BUILD_INFO.
+    if (versionUnknownEnd == std::string::npos) {
+      versionUnknownEnd = versionString_.size();
     }
-    application_version_.version.unknown = version_string_.substr(
-        version_unknown_start, version_unknown_end - version_unknown_start);
-    version_parsing_position_ = version_unknown_end;
+    ApplicationVersion_.version.unknown = versionString_.substr(
+        versionUnknownStart, versionUnknownEnd - versionUnknownStart);
+    versionParsingPosition_ = versionUnknownEnd;
     return true;
   }
 
-  bool ParseVersionPreRelease() {
+  bool parseVersionPreRelease() {
     // No PRE_RELEASE.
-    if (version_parsing_position_ == version_string_.size() ||
-        version_string_[version_parsing_position_] != '-') {
+    if (versionParsingPosition_ == versionString_.size() ||
+        versionString_[versionParsingPosition_] != '-') {
       return true;
     }
 
-    auto version_pre_release_start =
-        version_parsing_position_ + 1; // +1 is for '-'.
-    auto version_pre_release_end =
-        version_string_.find_first_of("+", version_pre_release_start);
-    // No BUILD_INFO
-    if (version_pre_release_end == std::string::npos) {
-      version_pre_release_end = version_string_.size();
+    auto versionPreReleaseStart = versionParsingPosition_ + 1; // +1 is for '-'.
+    auto versionPreReleaseEnd =
+        versionString_.find_first_of("+", versionPreReleaseStart);
+    // No BUILD_INFO.
+    if (versionPreReleaseEnd == std::string::npos) {
+      versionPreReleaseEnd = versionString_.size();
     }
-    application_version_.version.pre_release = version_string_.substr(
-        version_pre_release_start,
-        version_pre_release_end - version_pre_release_start);
-    version_parsing_position_ = version_pre_release_end;
+    ApplicationVersion_.version.preRelease = versionString_.substr(
+        versionPreReleaseStart, versionPreReleaseEnd - versionPreReleaseStart);
+    versionParsingPosition_ = versionPreReleaseEnd;
     return true;
   }
 
-  bool ParseVersionBuildInfo() {
+  bool parseVersionBuildInfo() {
     // No BUILD_INFO.
-    if (version_parsing_position_ == version_string_.size() ||
-        version_string_[version_parsing_position_] != '+') {
+    if (versionParsingPosition_ == versionString_.size() ||
+        versionString_[versionParsingPosition_] != '+') {
       return true;
     }
 
-    auto version_build_info_start =
-        version_parsing_position_ + 1; // +1 is for '+'.
-    application_version_.version.build_info =
-        version_string_.substr(version_build_info_start);
+    auto versionBuildInfoStart = versionParsingPosition_ + 1; // +1 is for '+'.
+    ApplicationVersion_.version.buildInfo =
+        versionString_.substr(versionBuildInfoStart);
     return true;
   }
 
-  bool ParseBuildName() {
-    std::string build_mark(" (build ");
-    auto build_mark_position = created_by_.find(build_mark, version_end_);
+  bool parseBuildName() {
+    std::string buildMark(" (build ");
+    auto buildMarkPosition = createdBy_.find(buildMark, versionEnd_);
     // No BUILD_NAME.
-    if (build_mark_position == std::string::npos) {
+    if (buildMarkPosition == std::string::npos) {
       return false;
     }
-    auto build_name_start = build_mark_position + build_mark.size();
-    RemovePrecedingSpaces(created_by_, build_name_start, created_by_.size());
-    auto build_name_end = created_by_.find_first_of(")", build_name_start);
+    auto buildNameStart = buildMarkPosition + buildMark.size();
+    removePrecedingSpaces(createdBy_, buildNameStart, createdBy_.size());
+    auto buildNameEnd = createdBy_.find_first_of(")", buildNameStart);
     // No end ")".
-    if (build_name_end == std::string::npos) {
+    if (buildNameEnd == std::string::npos) {
       return false;
     }
-    RemoveTrailingSpaces(created_by_, build_name_start, build_name_end);
-    application_version_.build_ =
-        created_by_.substr(build_name_start, build_name_end - build_name_start);
+    removeTrailingSpaces(createdBy_, buildNameStart, buildNameEnd);
+    ApplicationVersion_.build_ =
+        createdBy_.substr(buildNameStart, buildNameEnd - buildNameStart);
 
     return true;
   }
 
-  const std::string& created_by_;
-  ApplicationVersion& application_version_;
+  const std::string& createdBy_;
+  ApplicationVersion& ApplicationVersion_;
 
   // For parsing.
   std::string spaces_;
   std::string digits_;
-  size_t version_parsing_position_;
-  size_t version_start_;
-  size_t version_end_;
-  std::string version_string_;
+  size_t versionParsingPosition_;
+  size_t versionStart_;
+  size_t versionEnd_;
+  std::string versionString_;
 };
 } // namespace
 
-ApplicationVersion::ApplicationVersion(const std::string& created_by) {
-  ApplicationVersionParser parser(created_by, *this);
-  parser.Parse();
+ApplicationVersion::ApplicationVersion(const std::string& createdBy) {
+  ApplicationVersionParser parser(createdBy, *this);
+  parser.parse();
 }
 
-bool ApplicationVersion::VersionLt(
-    const ApplicationVersion& other_version) const {
-  if (application_ != other_version.application_)
+bool ApplicationVersion::versionLt(
+    const ApplicationVersion& otherVersion) const {
+  if (application_ != otherVersion.application_)
     return false;
 
-  if (version.major < other_version.version.major)
+  if (version.major < otherVersion.version.major)
     return true;
-  if (version.major > other_version.version.major)
+  if (version.major > otherVersion.version.major)
     return false;
-  VELOX_DCHECK_EQ(version.major, other_version.version.major);
-  if (version.minor < other_version.version.minor)
+  VELOX_DCHECK_EQ(version.major, otherVersion.version.major);
+  if (version.minor < otherVersion.version.minor)
     return true;
-  if (version.minor > other_version.version.minor)
+  if (version.minor > otherVersion.version.minor)
     return false;
-  VELOX_DCHECK_EQ(version.minor, other_version.version.minor);
-  return version.patch < other_version.version.patch;
+  VELOX_DCHECK_EQ(version.minor, otherVersion.version.minor);
+  return version.patch < otherVersion.version.patch;
 }
 
-bool ApplicationVersion::VersionEq(
-    const ApplicationVersion& other_version) const {
-  return application_ == other_version.application_ &&
-      version.major == other_version.version.major &&
-      version.minor == other_version.version.minor &&
-      version.patch == other_version.version.patch;
+bool ApplicationVersion::versionEq(
+    const ApplicationVersion& otherVersion) const {
+  return application_ == otherVersion.application_ &&
+      version.major == otherVersion.version.major &&
+      version.minor == otherVersion.version.minor &&
+      version.patch == otherVersion.version.patch;
 }
 
 // Reference:
-// parquet-mr/parquet-column/src/main/java/org/apache/parquet/CorruptStatistics.java
-// PARQUET-686 has more discussion on statistics
-bool ApplicationVersion::HasCorrectStatistics(
-    Type::type col_type,
+// Parquet-mr/parquet-column/src/main/java/org/apache/parquet/CorruptStatistics.java.
+// PARQUET-686 has more discussion on statistics.
+bool ApplicationVersion::hasCorrectStatistics(
+    Type::type colType,
     EncodedStatistics& statistics,
-    SortOrder::type sort_order) const {
-  // parquet-cpp version 1.3.0 and parquet-mr 1.10.0 onwards stats are computed
-  // correctly for all types
+    SortOrder::type sortOrder) const {
+  // Parquet-cpp version 1.3.0 and parquet-mr 1.10.0 onwards stats are computed
+  // correctly for all types.
   if ((application_ == "parquet-cpp" &&
-       VersionLt(PARQUET_CPP_FIXED_STATS_VERSION())) ||
+       versionLt(PARQUET_CPP_FIXED_STATS_VERSION())) ||
       (application_ == "parquet-mr" &&
-       VersionLt(PARQUET_MR_FIXED_STATS_VERSION()))) {
-    // Only SIGNED are valid unless max and min are the same
+       versionLt(PARQUET_MR_FIXED_STATS_VERSION()))) {
+    // Only SIGNED are valid unless max and min are the same.
     // (in which case the sort order does not matter)
-    bool max_equals_min = statistics.has_min && statistics.has_max
+    bool maxEqualsMin = statistics.hasMin && statistics.hasMax
         ? statistics.min() == statistics.max()
         : false;
-    if (SortOrder::SIGNED != sort_order && !max_equals_min) {
+    if (SortOrder::kSigned != sortOrder && !maxEqualsMin) {
       return false;
     }
 
-    // Statistics of other types are OK
-    if (col_type != Type::FIXED_LEN_BYTE_ARRAY &&
-        col_type != Type::BYTE_ARRAY) {
+    // Statistics of other types are OK.
+    if (colType != Type::kFixedLenByteArray && colType != Type::kByteArray) {
       return true;
     }
   }
-  // created_by is not populated, which could have been caused by
-  // parquet-mr during the same time as PARQUET-251, see PARQUET-297
+  // Created_by is not populated, which could have been caused by
+  // Parquet-mr during the same time as PARQUET-251, see PARQUET-297.
   if (application_ == "unknown") {
     return true;
   }
 
-  // Unknown sort order has incorrect stats
-  if (SortOrder::UNKNOWN == sort_order) {
+  // Unknown sort order has incorrect stats.
+  if (SortOrder::kUnknown == sortOrder) {
     return false;
   }
 
-  // PARQUET-251
-  if (VersionLt(PARQUET_251_FIXED_VERSION())) {
+  // PARQUET-251.
+  if (versionLt(PARQUET_251_FIXED_VERSION())) {
     return false;
   }
 
   return true;
 }
 
-// MetaData Builders
-// row-group metadata
+// MetaData Builders.
+// Row-group metadata.
 class ColumnChunkMetaDataBuilder::ColumnChunkMetaDataBuilderImpl {
  public:
   explicit ColumnChunkMetaDataBuilderImpl(
       std::shared_ptr<WriterProperties> props,
       const ColumnDescriptor* column)
-      : owned_column_chunk_(new facebook::velox::parquet::thrift::ColumnChunk),
+      : ownedColumnChunk_(new facebook::velox::parquet::thrift::ColumnChunk),
         properties_(std::move(props)),
         column_(column) {
-    Init(owned_column_chunk_.get());
+    init(ownedColumnChunk_.get());
   }
 
   explicit ColumnChunkMetaDataBuilderImpl(
       std::shared_ptr<WriterProperties> props,
       const ColumnDescriptor* column,
-      facebook::velox::parquet::thrift::ColumnChunk* column_chunk)
+      facebook::velox::parquet::thrift::ColumnChunk* columnChunk)
       : properties_(std::move(props)), column_(column) {
-    Init(column_chunk);
+    init(columnChunk);
   }
 
-  const void* contents() const {
-    return column_chunk_;
+  const void* Contents() const {
+    return columnChunk_;
   }
 
-  // column chunk
-  void set_file_path(const std::string& val) {
-    column_chunk_->__set_file_path(val);
+  // Column chunk.
+  void setFilePath(const std::string& val) {
+    columnChunk_->__set_file_path(val);
+  }
+
+  // Column metadata.
+  void setStatistics(const EncodedStatistics& val) {
+    columnChunk_->meta_data.__set_statistics(toThrift(val));
+    // Store NaN count separately since it's not written to the parquet file.
+    if (val.hasNanCount) {
+      nanCount_ = val.nanCount;
+      hasNanCount_ = true;
+    }
   }
 
-  // column metadata
-  void SetStatistics(const EncodedStatistics& val) {
-    column_chunk_->meta_data.__set_statistics(ToThrift(val));
+  int64_t nanCount() const {
+    return nanCount_;
   }
 
-  void Finish(
+  bool hasNanCount() const {
+    return hasNanCount_;
+  }
+
+  void finish(
       int64_t num_values,
       int64_t dictionary_page_offset,
       int64_t index_page_offset,
       int64_t data_page_offset,
-      int64_t compressed_size,
-      int64_t uncompressed_size,
-      bool has_dictionary,
-      bool dictionary_fallback,
-      const std::map<Encoding::type, int32_t>& dict_encoding_stats,
-      const std::map<Encoding::type, int32_t>& data_encoding_stats,
+      int64_t compressedSize,
+      int64_t uncompressedSize,
+      bool hasDictionary,
+      bool dictionaryFallback,
+      const std::map<Encoding::type, int32_t>& dictEncodingStats,
+      const std::map<Encoding::type, int32_t>& dataEncodingStats,
       const std::shared_ptr<Encryptor>& encryptor) {
     if (dictionary_page_offset > 0) {
-      column_chunk_->meta_data.__set_dictionary_page_offset(
+      columnChunk_->meta_data.__set_dictionary_page_offset(
           dictionary_page_offset);
-      column_chunk_->__set_file_offset(
-          dictionary_page_offset + compressed_size);
+      columnChunk_->__set_file_offset(dictionary_page_offset + compressedSize);
     } else {
-      column_chunk_->__set_file_offset(data_page_offset + compressed_size);
+      columnChunk_->__set_file_offset(data_page_offset + compressedSize);
     }
-    column_chunk_->__isset.meta_data = true;
-    column_chunk_->meta_data.__set_num_values(num_values);
+    columnChunk_->__isset.meta_data = true;
+    columnChunk_->meta_data.__set_num_values(num_values);
     if (index_page_offset >= 0) {
-      column_chunk_->meta_data.__set_index_page_offset(index_page_offset);
+      columnChunk_->meta_data.__set_index_page_offset(index_page_offset);
     }
-    column_chunk_->meta_data.__set_data_page_offset(data_page_offset);
-    column_chunk_->meta_data.__set_total_uncompressed_size(uncompressed_size);
-    column_chunk_->meta_data.__set_total_compressed_size(compressed_size);
+    columnChunk_->meta_data.__set_data_page_offset(data_page_offset);
+    columnChunk_->meta_data.__set_total_uncompressed_size(uncompressedSize);
+    columnChunk_->meta_data.__set_total_compressed_size(compressedSize);
 
     std::vector<facebook::velox::parquet::thrift::Encoding::type>
-        thrift_encodings;
+        thriftEncodings;
     std::vector<facebook::velox::parquet::thrift::PageEncodingStats>
-        thrift_encoding_stats;
-    auto add_encoding =
-        [&thrift_encodings](
+        thriftEncodingStats;
+    auto addEncoding =
+        [&thriftEncodings](
             facebook::velox::parquet::thrift::Encoding::type value) {
           auto it = std::find(
-              thrift_encodings.begin(), thrift_encodings.end(), value);
-          if (it == thrift_encodings.end()) {
-            thrift_encodings.push_back(value);
+              thriftEncodings.cbegin(), thriftEncodings.cend(), value);
+          if (it == thriftEncodings.cend()) {
+            thriftEncodings.push_back(value);
           }
         };
-    // Add dictionary page encoding stats
-    if (has_dictionary) {
-      for (const auto& entry : dict_encoding_stats) {
-        facebook::velox::parquet::thrift::PageEncodingStats dict_enc_stat;
-        dict_enc_stat.__set_page_type(
+    // Add dictionary page encoding stats.
+    if (hasDictionary) {
+      for (const auto& entry : dictEncodingStats) {
+        facebook::velox::parquet::thrift::PageEncodingStats dictEncStat;
+        dictEncStat.__set_page_type(
             facebook::velox::parquet::thrift::PageType::DICTIONARY_PAGE);
-        // Dictionary Encoding would be PLAIN_DICTIONARY in v1 and
+        // Dictionary encoding would be PLAIN_DICTIONARY in v1 and
         // PLAIN in v2.
-        facebook::velox::parquet::thrift::Encoding::type dict_encoding =
-            ToThrift(entry.first);
-        dict_enc_stat.__set_encoding(dict_encoding);
-        dict_enc_stat.__set_count(entry.second);
-        thrift_encoding_stats.push_back(dict_enc_stat);
-        add_encoding(dict_encoding);
+        facebook::velox::parquet::thrift::Encoding::type dictEncoding =
+            toThrift(entry.first);
+        dictEncStat.__set_encoding(dictEncoding);
+        dictEncStat.__set_count(entry.second);
+        thriftEncodingStats.push_back(dictEncStat);
+        addEncoding(dictEncoding);
       }
     }
     // Always add encoding for RL/DL.
-    // BIT_PACKED is supported in `LevelEncoder`, but would only be used
-    // in benchmark and testing.
+    // BIT_PACKED is supported in `LevelEncoder`, but would only be used.
+    // In benchmark and testing.
     // And for now, we always add RLE even if there are no levels at all,
     // while parquet-mr is more fine-grained.
-    add_encoding(facebook::velox::parquet::thrift::Encoding::RLE);
-    // Add data page encoding stats
-    for (const auto& entry : data_encoding_stats) {
-      facebook::velox::parquet::thrift::PageEncodingStats data_enc_stat;
-      data_enc_stat.__set_page_type(
+    addEncoding(facebook::velox::parquet::thrift::Encoding::RLE);
+    // Add data page encoding stats.
+    for (const auto& entry : dataEncodingStats) {
+      facebook::velox::parquet::thrift::PageEncodingStats dataEncStat;
+      dataEncStat.__set_page_type(
           facebook::velox::parquet::thrift::PageType::DATA_PAGE);
-      facebook::velox::parquet::thrift::Encoding::type data_encoding =
-          ToThrift(entry.first);
-      data_enc_stat.__set_encoding(data_encoding);
-      data_enc_stat.__set_count(entry.second);
-      thrift_encoding_stats.push_back(data_enc_stat);
-      add_encoding(data_encoding);
-    }
-    column_chunk_->meta_data.__set_encodings(thrift_encodings);
-    column_chunk_->meta_data.__set_encoding_stats(thrift_encoding_stats);
-
-    const auto& encrypt_md = properties_->column_encryption_properties(
-        column_->path()->ToDotString());
-    // column is encrypted
-    if (encrypt_md != nullptr && encrypt_md->is_encrypted()) {
-      column_chunk_->__isset.crypto_metadata = true;
+      facebook::velox::parquet::thrift::Encoding::type dataEncoding =
+          toThrift(entry.first);
+      dataEncStat.__set_encoding(dataEncoding);
+      dataEncStat.__set_count(entry.second);
+      thriftEncodingStats.push_back(dataEncStat);
+      addEncoding(dataEncoding);
+    }
+    columnChunk_->meta_data.__set_encodings(thriftEncodings);
+    columnChunk_->meta_data.__set_encoding_stats(thriftEncodingStats);
+
+    const auto& encryptMd =
+        properties_->columnEncryptionProperties(column_->path()->toDotString());
+    // Column is encrypted.
+    if (encryptMd != nullptr && encryptMd->isEncrypted()) {
+      columnChunk_->__isset.crypto_metadata = true;
       facebook::velox::parquet::thrift::ColumnCryptoMetaData ccmd;
-      if (encrypt_md->is_encrypted_with_footer_key()) {
-        // encrypted with footer key
+      if (encryptMd->isEncryptedWithFooterKey()) {
+        // Encrypted with footer key.
         ccmd.__isset.ENCRYPTION_WITH_FOOTER_KEY = true;
         ccmd.__set_ENCRYPTION_WITH_FOOTER_KEY(
             facebook::velox::parquet::thrift::EncryptionWithFooterKey());
       } else { // encrypted with column key
         facebook::velox::parquet::thrift::EncryptionWithColumnKey eck;
-        eck.__set_key_metadata(encrypt_md->key_metadata());
-        eck.__set_path_in_schema(column_->path()->ToDotVector());
+        eck.__set_key_metadata(encryptMd->keyMetadata());
+        eck.__set_path_in_schema(column_->path()->toDotVector());
         ccmd.__isset.ENCRYPTION_WITH_COLUMN_KEY = true;
         ccmd.__set_ENCRYPTION_WITH_COLUMN_KEY(eck);
       }
-      column_chunk_->__set_crypto_metadata(ccmd);
+      columnChunk_->__set_crypto_metadata(ccmd);
 
-      bool encrypted_footer =
-          properties_->file_encryption_properties()->encrypted_footer();
-      bool encrypt_metadata =
-          !encrypted_footer || !encrypt_md->is_encrypted_with_footer_key();
-      if (encrypt_metadata) {
+      bool encryptedFooter =
+          properties_->fileEncryptionProperties()->encryptedFooter();
+      bool encryptMetadata =
+          !encryptedFooter || !encryptMd->isEncryptedWithFooterKey();
+      if (encryptMetadata) {
         ThriftSerializer serializer;
-        // Serialize and encrypt ColumnMetadata separately
+        // Serialize and encrypt ColumnMetadata separately.
         // Thrift-serialize the ColumnMetaData structure,
         // encrypt it with the column key, and write to
-        // encrypted_column_metadata
-        uint8_t* serialized_data;
-        uint32_t serialized_len;
+        // encrypted_column_metadata.
+        uint8_t* serializedData;
+        uint32_t serializedLen;
 
-        serializer.SerializeToBuffer(
-            &column_chunk_->meta_data, &serialized_len, &serialized_data);
+        serializer.serializeToBuffer(
+            &columnChunk_->meta_data, &serializedLen, &serializedData);
 
-        std::vector<uint8_t> encrypted_data(
-            encryptor->CiphertextSizeDelta() + serialized_len);
-        unsigned encrypted_len = encryptor->Encrypt(
-            serialized_data, serialized_len, encrypted_data.data());
+        std::vector<uint8_t> encryptedData(
+            encryptor->ciphertextSizeDelta() + serializedLen);
+        unsigned encryptedLen = encryptor->encrypt(
+            serializedData, serializedLen, encryptedData.data());
 
         const char* temp = const_cast<const char*>(
-            reinterpret_cast<char*>(encrypted_data.data()));
-        std::string encrypted_column_metadata(temp, encrypted_len);
-        column_chunk_->__set_encrypted_column_metadata(
+            reinterpret_cast<char*>(encryptedData.data()));
+        std::string encrypted_column_metadata(temp, encryptedLen);
+        columnChunk_->__set_encrypted_column_metadata(
             encrypted_column_metadata);
 
-        if (encrypted_footer) {
-          column_chunk_->__isset.meta_data = false;
+        if (encryptedFooter) {
+          columnChunk_->__isset.meta_data = false;
         } else {
-          // Keep redacted metadata version for old readers
-          column_chunk_->__isset.meta_data = true;
-          column_chunk_->meta_data.__isset.statistics = false;
-          column_chunk_->meta_data.__isset.encoding_stats = false;
+          // Keep redacted metadata version for old readers.
+          columnChunk_->__isset.meta_data = true;
+          columnChunk_->meta_data.__isset.statistics = false;
+          columnChunk_->meta_data.__isset.encoding_stats = false;
         }
       }
     }
   }
 
-  void WriteTo(::arrow::io::OutputStream* sink) {
+  void writeTo(::arrow::io::OutputStream* sink) {
     ThriftSerializer serializer;
-    serializer.Serialize(column_chunk_, sink);
+    serializer.serialize(columnChunk_, sink);
   }
 
   const ColumnDescriptor* descr() const {
     return column_;
   }
-  int64_t total_compressed_size() const {
-    return column_chunk_->meta_data.total_compressed_size;
+  int64_t totalCompressedSize() const {
+    return columnChunk_->meta_data.total_compressed_size;
   }
 
  private:
-  void Init(facebook::velox::parquet::thrift::ColumnChunk* column_chunk) {
-    column_chunk_ = column_chunk;
+  void init(facebook::velox::parquet::thrift::ColumnChunk* columnChunk) {
+    columnChunk_ = columnChunk;
 
-    column_chunk_->meta_data.__set_type(ToThrift(column_->physical_type()));
-    column_chunk_->meta_data.__set_path_in_schema(
-        column_->path()->ToDotVector());
-    column_chunk_->meta_data.__set_codec(
-        ToThrift(properties_->compression(column_->path())));
+    columnChunk_->meta_data.__set_type(toThrift(column_->physicalType()));
+    columnChunk_->meta_data.__set_path_in_schema(
+        column_->path()->toDotVector());
+    columnChunk_->meta_data.__set_codec(
+        toThrift(properties_->compression(column_->path())));
   }
 
-  facebook::velox::parquet::thrift::ColumnChunk* column_chunk_;
+  facebook::velox::parquet::thrift::ColumnChunk* columnChunk_;
   std::unique_ptr<facebook::velox::parquet::thrift::ColumnChunk>
-      owned_column_chunk_;
+      ownedColumnChunk_;
   const std::shared_ptr<WriterProperties> properties_;
   const ColumnDescriptor* column_;
+  // NaN count is stored separately since it's not written to the parquet file.
+  int64_t nanCount_ = 0;
+  bool hasNanCount_ = false;
 };
 
-std::unique_ptr<ColumnChunkMetaDataBuilder> ColumnChunkMetaDataBuilder::Make(
+std::unique_ptr<ColumnChunkMetaDataBuilder> ColumnChunkMetaDataBuilder::make(
     std::shared_ptr<WriterProperties> props,
     const ColumnDescriptor* column,
-    void* contents) {
+    void* Contents) {
   return std::unique_ptr<ColumnChunkMetaDataBuilder>(
-      new ColumnChunkMetaDataBuilder(std::move(props), column, contents));
+      new ColumnChunkMetaDataBuilder(std::move(props), column, Contents));
 }
 
-std::unique_ptr<ColumnChunkMetaDataBuilder> ColumnChunkMetaDataBuilder::Make(
+std::unique_ptr<ColumnChunkMetaDataBuilder> ColumnChunkMetaDataBuilder::make(
     std::shared_ptr<WriterProperties> props,
     const ColumnDescriptor* column) {
   return std::unique_ptr<ColumnChunkMetaDataBuilder>(
@@ -1900,65 +1942,73 @@ ColumnChunkMetaDataBuilder::ColumnChunkMetaDataBuilder(
 ColumnChunkMetaDataBuilder::ColumnChunkMetaDataBuilder(
     std::shared_ptr<WriterProperties> props,
     const ColumnDescriptor* column,
-    void* contents)
+    void* Contents)
     : impl_{std::unique_ptr<ColumnChunkMetaDataBuilderImpl>(
           new ColumnChunkMetaDataBuilderImpl(
               std::move(props),
               column,
               reinterpret_cast<facebook::velox::parquet::thrift::ColumnChunk*>(
-                  contents)))} {}
+                  Contents)))} {}
 
 ColumnChunkMetaDataBuilder::~ColumnChunkMetaDataBuilder() = default;
 
-const void* ColumnChunkMetaDataBuilder::contents() const {
-  return impl_->contents();
+const void* ColumnChunkMetaDataBuilder::Contents() const {
+  return impl_->Contents();
 }
 
-void ColumnChunkMetaDataBuilder::set_file_path(const std::string& path) {
-  impl_->set_file_path(path);
+void ColumnChunkMetaDataBuilder::setFilePath(const std::string& path) {
+  impl_->setFilePath(path);
 }
 
-void ColumnChunkMetaDataBuilder::Finish(
+void ColumnChunkMetaDataBuilder::finish(
     int64_t num_values,
     int64_t dictionary_page_offset,
     int64_t index_page_offset,
     int64_t data_page_offset,
-    int64_t compressed_size,
-    int64_t uncompressed_size,
-    bool has_dictionary,
-    bool dictionary_fallback,
-    const std::map<Encoding::type, int32_t>& dict_encoding_stats,
-    const std::map<Encoding::type, int32_t>& data_encoding_stats,
+    int64_t compressedSize,
+    int64_t uncompressedSize,
+    bool hasDictionary,
+    bool dictionaryFallback,
+    const std::map<Encoding::type, int32_t>& dictEncodingStats,
+    const std::map<Encoding::type, int32_t>& dataEncodingStats,
     const std::shared_ptr<Encryptor>& encryptor) {
-  impl_->Finish(
+  impl_->finish(
       num_values,
       dictionary_page_offset,
       index_page_offset,
       data_page_offset,
-      compressed_size,
-      uncompressed_size,
-      has_dictionary,
-      dictionary_fallback,
-      dict_encoding_stats,
-      data_encoding_stats,
+      compressedSize,
+      uncompressedSize,
+      hasDictionary,
+      dictionaryFallback,
+      dictEncodingStats,
+      dataEncodingStats,
       encryptor);
 }
 
-void ColumnChunkMetaDataBuilder::WriteTo(::arrow::io::OutputStream* sink) {
-  impl_->WriteTo(sink);
+void ColumnChunkMetaDataBuilder::writeTo(::arrow::io::OutputStream* sink) {
+  impl_->writeTo(sink);
 }
 
 const ColumnDescriptor* ColumnChunkMetaDataBuilder::descr() const {
   return impl_->descr();
 }
 
-void ColumnChunkMetaDataBuilder::SetStatistics(
+void ColumnChunkMetaDataBuilder::setStatistics(
     const EncodedStatistics& result) {
-  impl_->SetStatistics(result);
+  impl_->setStatistics(result);
+}
+
+int64_t ColumnChunkMetaDataBuilder::totalCompressedSize() const {
+  return impl_->totalCompressedSize();
+}
+
+int64_t ColumnChunkMetaDataBuilder::nanCount() const {
+  return impl_->nanCount();
 }
 
-int64_t ColumnChunkMetaDataBuilder::total_compressed_size() const {
-  return impl_->total_compressed_size();
+bool ColumnChunkMetaDataBuilder::hasNanCount() const {
+  return impl_->hasNanCount();
 }
 
 class RowGroupMetaDataBuilder::RowGroupMetaDataBuilderImpl {
@@ -1966,313 +2016,334 @@ class RowGroupMetaDataBuilder::RowGroupMetaDataBuilderImpl {
   explicit RowGroupMetaDataBuilderImpl(
       std::shared_ptr<WriterProperties> props,
       const SchemaDescriptor* schema,
-      void* contents)
-      : properties_(std::move(props)), schema_(schema), next_column_(0) {
-    row_group_ =
-        reinterpret_cast<facebook::velox::parquet::thrift::RowGroup*>(contents);
-    InitializeColumns(schema->num_columns());
+      void* Contents)
+      : properties_(std::move(props)), schema_(schema), nextColumn_(0) {
+    rowGroup_ =
+        reinterpret_cast<facebook::velox::parquet::thrift::RowGroup*>(Contents);
+    initializeColumns(schema->numColumns());
   }
 
-  ColumnChunkMetaDataBuilder* NextColumnChunk() {
-    if (!(next_column_ < num_columns())) {
+  ColumnChunkMetaDataBuilder* nextColumnChunk() {
+    if (!(nextColumn_ < numColumns())) {
       std::stringstream ss;
-      ss << "The schema only has " << num_columns()
-         << " columns, requested metadata for column: " << next_column_;
+      ss << "The schema only has " << numColumns()
+         << " columns, requested metadata for column: " << nextColumn_;
       throw ParquetException(ss.str());
     }
-    auto column = schema_->Column(next_column_);
-    auto column_builder = ColumnChunkMetaDataBuilder::Make(
-        properties_, column, &row_group_->columns[next_column_++]);
-    auto column_builder_ptr = column_builder.get();
-    column_builders_.push_back(std::move(column_builder));
-    return column_builder_ptr;
+    auto column = schema_->column(nextColumn_);
+    auto columnBuilder = ColumnChunkMetaDataBuilder::make(
+        properties_, column, &rowGroup_->columns[nextColumn_++]);
+    auto columnBuilderPtr = columnBuilder.get();
+    columnBuilders_.push_back(std::move(columnBuilder));
+    return columnBuilderPtr;
   }
 
-  int current_column() {
-    return next_column_ - 1;
+  int currentColumn() {
+    return nextColumn_ - 1;
   }
 
-  void Finish(int64_t total_bytes_written, int16_t row_group_ordinal) {
-    if (!(next_column_ == schema_->num_columns())) {
+  void finish(int64_t totalBytesWritten, int16_t rowGroupOrdinal) {
+    if (!(nextColumn_ == schema_->numColumns())) {
       std::stringstream ss;
-      ss << "Only " << next_column_ - 1 << " out of " << schema_->num_columns()
+      ss << "Only " << nextColumn_ - 1 << " out of " << schema_->numColumns()
          << " columns are initialized";
       throw ParquetException(ss.str());
     }
 
-    int64_t file_offset = 0;
+    int64_t fileOffset = 0;
     int64_t total_compressed_size = 0;
-    for (int i = 0; i < schema_->num_columns(); i++) {
-      if (!(row_group_->columns[i].file_offset >= 0)) {
+    for (int i = 0; i < schema_->numColumns(); i++) {
+      if (!(rowGroup_->columns[i].file_offset >= 0)) {
         std::stringstream ss;
         ss << "Column " << i << " is not complete.";
         throw ParquetException(ss.str());
       }
       if (i == 0) {
-        const facebook::velox::parquet::thrift::ColumnMetaData& first_col =
-            row_group_->columns[0].meta_data;
+        const facebook::velox::parquet::thrift::ColumnMetaData& firstCol =
+            rowGroup_->columns[0].meta_data;
         // As per spec, file_offset for the row group points to the first
         // dictionary or data page of the column.
-        if (first_col.__isset.dictionary_page_offset &&
-            first_col.dictionary_page_offset > 0) {
-          file_offset = first_col.dictionary_page_offset;
+        if (firstCol.__isset.dictionary_page_offset &&
+            firstCol.dictionary_page_offset > 0) {
+          fileOffset = firstCol.dictionary_page_offset;
         } else {
-          file_offset = first_col.data_page_offset;
+          fileOffset = firstCol.data_page_offset;
         }
       }
-      // sometimes column metadata is encrypted and not available to read,
-      // so we must get total_compressed_size from column builder
-      total_compressed_size += column_builders_[i]->total_compressed_size();
+      // Sometimes column metadata is encrypted and not available to read,
+      // so we must get total_compressed_size from column builder.
+      total_compressed_size += columnBuilders_[i]->totalCompressedSize();
     }
 
-    const auto& sorting_columns = properties_->sorting_columns();
-    if (!sorting_columns.empty()) {
+    const auto& sortingColumns = properties_->sortingColumns();
+    if (!sortingColumns.empty()) {
       std::vector<facebook::velox::parquet::thrift::SortingColumn>
-          thrift_sorting_columns(sorting_columns.size());
-      for (size_t i = 0; i < sorting_columns.size(); ++i) {
-        thrift_sorting_columns[i] = ToThrift(sorting_columns[i]);
+          thriftSortingColumns(sortingColumns.size());
+      for (size_t i = 0; i < sortingColumns.size(); ++i) {
+        thriftSortingColumns[i] = toThrift(sortingColumns[i]);
       }
-      row_group_->__set_sorting_columns(std::move(thrift_sorting_columns));
+      rowGroup_->__set_sorting_columns(std::move(thriftSortingColumns));
     }
 
-    row_group_->__set_file_offset(file_offset);
-    row_group_->__set_total_compressed_size(total_compressed_size);
-    row_group_->__set_total_byte_size(total_bytes_written);
-    row_group_->__set_ordinal(row_group_ordinal);
+    rowGroup_->__set_file_offset(fileOffset);
+    rowGroup_->__set_total_compressed_size(total_compressed_size);
+    rowGroup_->__set_total_byte_size(totalBytesWritten);
+    rowGroup_->__set_ordinal(rowGroupOrdinal);
   }
 
-  void set_num_rows(int64_t num_rows) {
-    row_group_->num_rows = num_rows;
+  void setNumRows(int64_t numRows) {
+    rowGroup_->num_rows = numRows;
   }
 
-  int num_columns() {
-    return static_cast<int>(row_group_->columns.size());
+  int numColumns() {
+    return static_cast<int>(rowGroup_->columns.size());
   }
 
-  int64_t num_rows() {
-    return row_group_->num_rows;
+  int64_t numRows() {
+    return rowGroup_->num_rows;
+  }
+
+  // Returns a map of field_id -> (nan_count, has_nan_count).
+  std::unordered_map<int32_t, std::pair<int64_t, bool>> nanCounts() const {
+    std::unordered_map<int32_t, std::pair<int64_t, bool>> result;
+    for (const auto& builder : columnBuilders_) {
+      int32_t field_id = builder->descr()->schemaNode()->fieldId();
+      result[field_id] = {builder->nanCount(), builder->hasNanCount()};
+    }
+    return result;
   }
 
  private:
-  void InitializeColumns(int ncols) {
-    row_group_->columns.resize(ncols);
+  void initializeColumns(int ncols) {
+    rowGroup_->columns.resize(ncols);
   }
 
-  facebook::velox::parquet::thrift::RowGroup* row_group_;
+  facebook::velox::parquet::thrift::RowGroup* rowGroup_;
   const std::shared_ptr<WriterProperties> properties_;
   const SchemaDescriptor* schema_;
-  std::vector<std::unique_ptr<ColumnChunkMetaDataBuilder>> column_builders_;
-  int next_column_;
+  std::vector<std::unique_ptr<ColumnChunkMetaDataBuilder>> columnBuilders_;
+  int nextColumn_;
 };
 
-std::unique_ptr<RowGroupMetaDataBuilder> RowGroupMetaDataBuilder::Make(
+std::unique_ptr<RowGroupMetaDataBuilder> RowGroupMetaDataBuilder::make(
     std::shared_ptr<WriterProperties> props,
     const SchemaDescriptor* schema_,
-    void* contents) {
+    void* Contents) {
   return std::unique_ptr<RowGroupMetaDataBuilder>(
-      new RowGroupMetaDataBuilder(std::move(props), schema_, contents));
+      new RowGroupMetaDataBuilder(std::move(props), schema_, Contents));
 }
 
 RowGroupMetaDataBuilder::RowGroupMetaDataBuilder(
     std::shared_ptr<WriterProperties> props,
     const SchemaDescriptor* schema_,
-    void* contents)
+    void* Contents)
     : impl_{new RowGroupMetaDataBuilderImpl(
           std::move(props),
           schema_,
-          contents)} {}
+          Contents)} {}
 
 RowGroupMetaDataBuilder::~RowGroupMetaDataBuilder() = default;
 
-ColumnChunkMetaDataBuilder* RowGroupMetaDataBuilder::NextColumnChunk() {
-  return impl_->NextColumnChunk();
+ColumnChunkMetaDataBuilder* RowGroupMetaDataBuilder::nextColumnChunk() {
+  return impl_->nextColumnChunk();
+}
+
+int RowGroupMetaDataBuilder::currentColumn() const {
+  return impl_->currentColumn();
 }
 
-int RowGroupMetaDataBuilder::current_column() const {
-  return impl_->current_column();
+int RowGroupMetaDataBuilder::numColumns() {
+  return impl_->numColumns();
 }
 
-int RowGroupMetaDataBuilder::num_columns() {
-  return impl_->num_columns();
+int64_t RowGroupMetaDataBuilder::numRows() {
+  return impl_->numRows();
 }
 
-int64_t RowGroupMetaDataBuilder::num_rows() {
-  return impl_->num_rows();
+void RowGroupMetaDataBuilder::setNumRows(int64_t numRows) {
+  impl_->setNumRows(numRows);
 }
 
-void RowGroupMetaDataBuilder::set_num_rows(int64_t num_rows) {
-  impl_->set_num_rows(num_rows);
+void RowGroupMetaDataBuilder::finish(
+    int64_t totalBytesWritten,
+    int16_t rowGroupOrdinal) {
+  impl_->finish(totalBytesWritten, rowGroupOrdinal);
 }
 
-void RowGroupMetaDataBuilder::Finish(
-    int64_t total_bytes_written,
-    int16_t row_group_ordinal) {
-  impl_->Finish(total_bytes_written, row_group_ordinal);
+std::unordered_map<int32_t, std::pair<int64_t, bool>>
+RowGroupMetaDataBuilder::nanCounts() const {
+  return impl_->nanCounts();
 }
 
-// file metadata
+// File metadata.
 class FileMetaDataBuilder::FileMetaDataBuilderImpl {
  public:
   explicit FileMetaDataBuilderImpl(
       const SchemaDescriptor* schema,
       std::shared_ptr<WriterProperties> props,
-      std::shared_ptr<const KeyValueMetadata> key_value_metadata)
+      std::shared_ptr<const KeyValueMetadata> keyValueMetadata)
       : metadata_(new facebook::velox::parquet::thrift::FileMetaData()),
         properties_(std::move(props)),
         schema_(schema),
-        key_value_metadata_(std::move(key_value_metadata)) {
-    if (properties_->file_encryption_properties() != nullptr &&
-        properties_->file_encryption_properties()->encrypted_footer()) {
+        keyValueMetadata_(std::move(keyValueMetadata)) {
+    if (properties_->fileEncryptionProperties() != nullptr &&
+        properties_->fileEncryptionProperties()->encryptedFooter()) {
       crypto_metadata_.reset(
           new facebook::velox::parquet::thrift::FileCryptoMetaData());
     }
   }
 
-  RowGroupMetaDataBuilder* AppendRowGroup() {
-    row_groups_.emplace_back();
-    current_row_group_builder_ = RowGroupMetaDataBuilder::Make(
-        properties_, schema_, &row_groups_.back());
-    return current_row_group_builder_.get();
-  }
-
-  void SetPageIndexLocation(const PageIndexLocation& location) {
-    auto set_index_location = [this](
-                                  size_t row_group_ordinal,
-                                  const PageIndexLocation::FileIndexLocation&
-                                      file_index_location,
-                                  bool column_index) {
-      auto& row_group_metadata = this->row_groups_.at(row_group_ordinal);
-      auto iter = file_index_location.find(row_group_ordinal);
-      if (iter != file_index_location.cend()) {
-        const auto& row_group_index_location = iter->second;
-        for (size_t i = 0; i < row_group_index_location.size(); ++i) {
-          if (i >= row_group_metadata.columns.size()) {
+  RowGroupMetaDataBuilder* appendRowGroup() {
+    // Accumulate NaN counts from the previous row group before creating a new
+    // one.
+    accumulateNaNCountsFromCurrentRowGroup();
+    rowGroups_.emplace_back();
+    currentRowGroupBuilder_ =
+        RowGroupMetaDataBuilder::make(properties_, schema_, &rowGroups_.back());
+    return currentRowGroupBuilder_.get();
+  }
+
+  void setPageIndexLocation(const PageIndexLocation& location) {
+    auto setIndexLocation = [this](
+                                size_t rowGroupOrdinal,
+                                const PageIndexLocation::FileIndexLocation&
+                                    fileIndexLocation,
+                                bool columnIndex) {
+      auto& rowGroupMetadata = this->rowGroups_.at(rowGroupOrdinal);
+      auto iter = fileIndexLocation.find(rowGroupOrdinal);
+      if (iter != fileIndexLocation.cend()) {
+        const auto& rowGroupIndexLocation = iter->second;
+        for (size_t i = 0; i < rowGroupIndexLocation.size(); ++i) {
+          if (i >= rowGroupMetadata.columns.size()) {
             throw ParquetException(
                 "Cannot find metadata for column ordinal ", i);
           }
-          auto& column_metadata = row_group_metadata.columns.at(i);
-          const auto& index_location = row_group_index_location.at(i);
-          if (index_location.has_value()) {
-            if (column_index) {
-              column_metadata.__set_column_index_offset(index_location->offset);
-              column_metadata.__set_column_index_length(index_location->length);
+          auto& columnMetadata = rowGroupMetadata.columns.at(i);
+          const auto& indexLocation = rowGroupIndexLocation.at(i);
+          if (indexLocation.has_value()) {
+            if (columnIndex) {
+              columnMetadata.__set_column_index_offset(indexLocation->offset);
+              columnMetadata.__set_column_index_length(indexLocation->length);
             } else {
-              column_metadata.__set_offset_index_offset(index_location->offset);
-              column_metadata.__set_offset_index_length(index_location->length);
+              columnMetadata.__set_offset_index_offset(indexLocation->offset);
+              columnMetadata.__set_offset_index_length(indexLocation->length);
             }
           }
         }
       }
     };
 
-    for (size_t i = 0; i < row_groups_.size(); ++i) {
-      set_index_location(i, location.column_index_location, true);
-      set_index_location(i, location.offset_index_location, false);
+    for (size_t i = 0; i < rowGroups_.size(); ++i) {
+      setIndexLocation(i, location.columnIndexLocation, true);
+      setIndexLocation(i, location.offsetIndexLocation, false);
     }
   }
 
-  std::unique_ptr<FileMetaData> Finish(
-      const std::shared_ptr<const KeyValueMetadata>& key_value_metadata) {
-    int64_t total_rows = 0;
-    for (auto row_group : row_groups_) {
-      total_rows += row_group.num_rows;
+  std::unique_ptr<FileMetaData> finish(
+      const std::shared_ptr<const KeyValueMetadata>& keyValueMetadata) {
+    // Accumulate NaN counts from the last row group.
+    accumulateNaNCountsFromCurrentRowGroup();
+
+    int64_t totalRows = 0;
+    for (auto rowGroup : rowGroups_) {
+      totalRows += rowGroup.num_rows;
     }
-    metadata_->__set_num_rows(total_rows);
-    metadata_->__set_row_groups(row_groups_);
+    metadata_->__set_num_rows(totalRows);
+    metadata_->__set_row_groups(rowGroups_);
 
-    if (key_value_metadata_ || key_value_metadata) {
-      if (!key_value_metadata_) {
-        key_value_metadata_ = key_value_metadata;
-      } else if (key_value_metadata) {
-        key_value_metadata_ = key_value_metadata_->Merge(*key_value_metadata);
+    if (keyValueMetadata_ || keyValueMetadata) {
+      if (!keyValueMetadata_) {
+        keyValueMetadata_ = keyValueMetadata;
+      } else if (keyValueMetadata) {
+        keyValueMetadata_ = keyValueMetadata_->Merge(*keyValueMetadata);
       }
       metadata_->key_value_metadata.clear();
-      metadata_->key_value_metadata.reserve(key_value_metadata_->size());
-      for (int64_t i = 0; i < key_value_metadata_->size(); ++i) {
-        facebook::velox::parquet::thrift::KeyValue kv_pair;
-        kv_pair.__set_key(key_value_metadata_->key(i));
-        kv_pair.__set_value(key_value_metadata_->value(i));
-        metadata_->key_value_metadata.push_back(kv_pair);
+      metadata_->key_value_metadata.reserve(keyValueMetadata_->size());
+      for (int64_t i = 0; i < keyValueMetadata_->size(); ++i) {
+        facebook::velox::parquet::thrift::KeyValue kvPair;
+        kvPair.__set_key(keyValueMetadata_->key(i));
+        kvPair.__set_value(keyValueMetadata_->value(i));
+        metadata_->key_value_metadata.push_back(kvPair);
       }
       metadata_->__isset.key_value_metadata = true;
     }
 
-    int32_t file_version = 0;
+    int32_t fileVersion = 0;
     switch (properties_->version()) {
       case ParquetVersion::PARQUET_1_0:
-        file_version = 1;
+        fileVersion = 1;
         break;
       default:
-        file_version = 2;
+        fileVersion = 2;
         break;
     }
-    metadata_->__set_version(file_version);
-    metadata_->__set_created_by(properties_->created_by());
-
-    // Users cannot set the `ColumnOrder` since we do not have user defined sort
-    // order in the spec yet. We always default to `TYPE_DEFINED_ORDER`. We can
-    // expose it in the API once we have user defined sort orders in the Parquet
-    // format. TypeDefinedOrder implies choose SortOrder based on
-    // ConvertedType/PhysicalType
-    facebook::velox::parquet::thrift::TypeDefinedOrder type_defined_order;
-    facebook::velox::parquet::thrift::ColumnOrder column_order;
-    column_order.__set_TYPE_ORDER(type_defined_order);
-    column_order.__isset.TYPE_ORDER = true;
-    metadata_->column_orders.resize(schema_->num_columns(), column_order);
+    metadata_->__set_version(fileVersion);
+    metadata_->__set_created_by(properties_->createdBy());
+
+    // Users cannot set the `ColumnOrder` since we do not have user-defined
+    // sort order in the spec yet. We always default to `TYPE_DEFINED_ORDER`.
+    // We can expose it in the API once we have user-defined sort orders in the
+    // Parquet format. TypeDefinedOrder implies choose SortOrder based on
+    // convertedType/physicalType.
+    facebook::velox::parquet::thrift::TypeDefinedOrder typeDefinedOrder;
+    facebook::velox::parquet::thrift::ColumnOrder columnOrder;
+    columnOrder.__set_TYPE_ORDER(typeDefinedOrder);
+    columnOrder.__isset.TYPE_ORDER = true;
+    metadata_->column_orders.resize(schema_->numColumns(), columnOrder);
     metadata_->__isset.column_orders = true;
 
-    // if plaintext footer, set footer signing algorithm
-    auto file_encryption_properties = properties_->file_encryption_properties();
-    if (file_encryption_properties &&
-        !file_encryption_properties->encrypted_footer()) {
-      EncryptionAlgorithm signing_algorithm;
-      EncryptionAlgorithm algo = file_encryption_properties->algorithm();
-      signing_algorithm.aad.aad_file_unique = algo.aad.aad_file_unique;
-      signing_algorithm.aad.supply_aad_prefix = algo.aad.supply_aad_prefix;
-      if (!algo.aad.supply_aad_prefix) {
-        signing_algorithm.aad.aad_prefix = algo.aad.aad_prefix;
+    // If plaintext footer, set footer signing algorithm.
+    auto fileEncryptionProperties = properties_->fileEncryptionProperties();
+    if (fileEncryptionProperties &&
+        !fileEncryptionProperties->encryptedFooter()) {
+      EncryptionAlgorithm signingAlgorithm;
+      EncryptionAlgorithm algo = fileEncryptionProperties->algorithm();
+      signingAlgorithm.aad.aadFileUnique = algo.aad.aadFileUnique;
+      signingAlgorithm.aad.supplyAadPrefix = algo.aad.supplyAadPrefix;
+      if (!algo.aad.supplyAadPrefix) {
+        signingAlgorithm.aad.aadPrefix = algo.aad.aadPrefix;
       }
-      signing_algorithm.algorithm = ParquetCipher::AES_GCM_V1;
-
-      metadata_->__set_encryption_algorithm(ToThrift(signing_algorithm));
-      const std::string& footer_signing_key_metadata =
-          file_encryption_properties->footer_key_metadata();
-      if (footer_signing_key_metadata.size() > 0) {
-        metadata_->__set_footer_signing_key_metadata(
-            footer_signing_key_metadata);
+      signingAlgorithm.algorithm = ParquetCipher::kAesGcmV1;
+
+      metadata_->__set_encryption_algorithm(toThrift(signingAlgorithm));
+      const std::string& footerSigningKeyMetadata =
+          fileEncryptionProperties->footerKeyMetadata();
+      if (footerSigningKeyMetadata.size() > 0) {
+        metadata_->__set_footer_signing_key_metadata(footerSigningKeyMetadata);
       }
     }
 
-    ToParquet(
-        static_cast<schema::GroupNode*>(schema_->schema_root().get()),
+    toParquet(
+        static_cast<schema::GroupNode*>(schema_->schemaRoot().get()),
         &metadata_->schema);
-    auto file_meta_data = std::unique_ptr<FileMetaData>(new FileMetaData());
-    file_meta_data->impl_->metadata_ = std::move(metadata_);
-    file_meta_data->impl_->InitSchema();
-    file_meta_data->impl_->InitKeyValueMetadata();
-    return file_meta_data;
+    auto fileMetaData = std::unique_ptr<FileMetaData>(new FileMetaData());
+    fileMetaData->impl_->metadata_ = std::move(metadata_);
+    fileMetaData->impl_->initSchema();
+    fileMetaData->impl_->initKeyValueMetadata();
+    // Pass total NaN counts per field ID to FileMetaData.
+    fileMetaData->impl_->setNaNCounts(std::move(fieldNanCounts_));
+    return fileMetaData;
   }
 
-  std::unique_ptr<FileCryptoMetaData> BuildFileCryptoMetaData() {
+  std::unique_ptr<FileCryptoMetaData> buildFileCryptoMetaData() {
     if (crypto_metadata_ == nullptr) {
       return nullptr;
     }
 
-    auto file_encryption_properties = properties_->file_encryption_properties();
+    auto fileEncryptionProperties = properties_->fileEncryptionProperties();
 
     crypto_metadata_->__set_encryption_algorithm(
-        ToThrift(file_encryption_properties->algorithm()));
-    std::string key_metadata =
-        file_encryption_properties->footer_key_metadata();
+        toThrift(fileEncryptionProperties->algorithm()));
+    std::string keyMetadata = fileEncryptionProperties->footerKeyMetadata();
 
-    if (!key_metadata.empty()) {
-      crypto_metadata_->__set_key_metadata(key_metadata);
+    if (!keyMetadata.empty()) {
+      crypto_metadata_->__set_key_metadata(keyMetadata);
     }
 
-    std::unique_ptr<FileCryptoMetaData> file_crypto_metadata(
+    std::unique_ptr<FileCryptoMetaData> fileCryptoMetadata(
         new FileCryptoMetaData());
-    file_crypto_metadata->impl_->metadata_ = std::move(*crypto_metadata_);
-    return file_crypto_metadata;
+    fileCryptoMetadata->impl_->metadata_ = std::move(*crypto_metadata_);
+    return fileCryptoMetadata;
   }
 
  protected:
@@ -2281,23 +2352,42 @@ class FileMetaDataBuilder::FileMetaDataBuilderImpl {
       crypto_metadata_;
 
  private:
+  // Helper to accumulate NaN counts from the current row group builder.
+  void accumulateNaNCountsFromCurrentRowGroup() {
+    if (!currentRowGroupBuilder_) {
+      return;
+    }
+    auto rgNaNCounts = currentRowGroupBuilder_->nanCounts();
+    // Accumulate NaN counts from this row group (keyed by field ID).
+    for (const auto& [fieldId, countPair] : rgNaNCounts) {
+      const auto& [count, has_count] = countPair;
+      if (has_count) {
+        fieldNanCounts_[fieldId].first += count;
+        fieldNanCounts_[fieldId].second = true;
+      }
+    }
+  }
+
   const std::shared_ptr<WriterProperties> properties_;
-  std::vector<facebook::velox::parquet::thrift::RowGroup> row_groups_;
+  std::vector<facebook::velox::parquet::thrift::RowGroup> rowGroups_;
 
-  std::unique_ptr<RowGroupMetaDataBuilder> current_row_group_builder_;
+  std::unique_ptr<RowGroupMetaDataBuilder> currentRowGroupBuilder_;
   const SchemaDescriptor* schema_;
-  std::shared_ptr<const KeyValueMetadata> key_value_metadata_;
+  std::shared_ptr<const KeyValueMetadata> keyValueMetadata_;
+  // Total NaN counts per field ID across all row groups: field_id ->
+  // (nan_count, has_nan_count).
+  std::unordered_map<int32_t, std::pair<int64_t, bool>> fieldNanCounts_;
 };
 
-std::unique_ptr<FileMetaDataBuilder> FileMetaDataBuilder::Make(
+std::unique_ptr<FileMetaDataBuilder> FileMetaDataBuilder::make(
     const SchemaDescriptor* schema,
     std::shared_ptr<WriterProperties> props,
-    std::shared_ptr<const KeyValueMetadata> key_value_metadata) {
+    std::shared_ptr<const KeyValueMetadata> keyValueMetadata) {
   return std::unique_ptr<FileMetaDataBuilder>(new FileMetaDataBuilder(
-      schema, std::move(props), std::move(key_value_metadata)));
+      schema, std::move(props), std::move(keyValueMetadata)));
 }
 
-std::unique_ptr<FileMetaDataBuilder> FileMetaDataBuilder::Make(
+std::unique_ptr<FileMetaDataBuilder> FileMetaDataBuilder::make(
     const SchemaDescriptor* schema,
     std::shared_ptr<WriterProperties> props) {
   return std::unique_ptr<FileMetaDataBuilder>(
@@ -2307,31 +2397,31 @@ std::unique_ptr<FileMetaDataBuilder> FileMetaDataBuilder::Make(
 FileMetaDataBuilder::FileMetaDataBuilder(
     const SchemaDescriptor* schema,
     std::shared_ptr<WriterProperties> props,
-    std::shared_ptr<const KeyValueMetadata> key_value_metadata)
+    std::shared_ptr<const KeyValueMetadata> keyValueMetadata)
     : impl_{
           std::unique_ptr<FileMetaDataBuilderImpl>(new FileMetaDataBuilderImpl(
               schema,
               std::move(props),
-              std::move(key_value_metadata)))} {}
+              std::move(keyValueMetadata)))} {}
 
 FileMetaDataBuilder::~FileMetaDataBuilder() = default;
 
-RowGroupMetaDataBuilder* FileMetaDataBuilder::AppendRowGroup() {
-  return impl_->AppendRowGroup();
+RowGroupMetaDataBuilder* FileMetaDataBuilder::appendRowGroup() {
+  return impl_->appendRowGroup();
 }
 
-void FileMetaDataBuilder::SetPageIndexLocation(
+void FileMetaDataBuilder::setPageIndexLocation(
     const PageIndexLocation& location) {
-  impl_->SetPageIndexLocation(location);
+  impl_->setPageIndexLocation(location);
 }
 
-std::unique_ptr<FileMetaData> FileMetaDataBuilder::Finish(
-    const std::shared_ptr<const KeyValueMetadata>& key_value_metadata) {
-  return impl_->Finish(key_value_metadata);
+std::unique_ptr<FileMetaData> FileMetaDataBuilder::finish(
+    const std::shared_ptr<const KeyValueMetadata>& keyValueMetadata) {
+  return impl_->finish(keyValueMetadata);
 }
 
-std::unique_ptr<FileCryptoMetaData> FileMetaDataBuilder::GetCryptoMetaData() {
-  return impl_->BuildFileCryptoMetaData();
+std::unique_ptr<FileCryptoMetaData> FileMetaDataBuilder::getCryptoMetaData() {
+  return impl_->buildFileCryptoMetaData();
 }
 
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/Metadata.h b/velox/dwio/parquet/writer/arrow/Metadata.h
index c69ee5a03d4..c6104a2a794 100644
--- a/velox/dwio/parquet/writer/arrow/Metadata.h
+++ b/velox/dwio/parquet/writer/arrow/Metadata.h
@@ -23,6 +23,7 @@
 #include <memory>
 #include <optional>
 #include <string>
+#include <unordered_map>
 #include <utility>
 #include <vector>
 
@@ -54,16 +55,16 @@ using KeyValueMetadata = ::arrow::KeyValueMetadata;
 
 class PARQUET_EXPORT ApplicationVersion {
  public:
-  // Known Versions with Issues
+  // Known versions with issues.
   static const ApplicationVersion& PARQUET_251_FIXED_VERSION();
   static const ApplicationVersion& PARQUET_816_FIXED_VERSION();
   static const ApplicationVersion& PARQUET_CPP_FIXED_STATS_VERSION();
   static const ApplicationVersion& PARQUET_MR_FIXED_STATS_VERSION();
   static const ApplicationVersion& PARQUET_CPP_10353_FIXED_VERSION();
 
-  // Application that wrote the file. e.g. "IMPALA"
+  // Application that wrote the file, e.g., "IMPALA".
   std::string application_;
-  // Build name
+  // Build name.
   std::string build_;
 
   // Version of the application that wrote the file, expressed as
@@ -76,37 +77,37 @@ class PARQUET_EXPORT ApplicationVersion {
     int minor;
     int patch;
     std::string unknown;
-    std::string pre_release;
-    std::string build_info;
+    std::string preRelease;
+    std::string buildInfo;
   } version;
 
   ApplicationVersion() = default;
-  explicit ApplicationVersion(const std::string& created_by);
+  explicit ApplicationVersion(const std::string& createdBy);
   ApplicationVersion(std::string application, int major, int minor, int patch);
 
-  // Returns true if version is strictly less than other_version
-  bool VersionLt(const ApplicationVersion& other_version) const;
+  // Returns true if version is strictly less than otherVersion.
+  bool versionLt(const ApplicationVersion& otherVersion) const;
 
-  // Returns true if version is strictly equal with other_version
-  bool VersionEq(const ApplicationVersion& other_version) const;
+  // Returns true if version is strictly equal with otherVersion.
+  bool versionEq(const ApplicationVersion& otherVersion) const;
 
-  // Checks if the Version has the correct statistics for a given column
-  bool HasCorrectStatistics(
+  // Checks if the Version has the correct statistics for a given column.
+  bool hasCorrectStatistics(
       Type::type primitive,
       EncodedStatistics& statistics,
-      SortOrder::type sort_order = SortOrder::SIGNED) const;
+      SortOrder::type sortOrder = SortOrder::kSigned) const;
 };
 
 class PARQUET_EXPORT ColumnCryptoMetaData {
  public:
-  static std::unique_ptr<ColumnCryptoMetaData> Make(const uint8_t* metadata);
+  static std::unique_ptr<ColumnCryptoMetaData> make(const uint8_t* metadata);
   ~ColumnCryptoMetaData();
 
-  bool Equals(const ColumnCryptoMetaData& other) const;
+  bool equals(const ColumnCryptoMetaData& other) const;
 
-  std::shared_ptr<schema::ColumnPath> path_in_schema() const;
-  bool encrypted_with_footer_key() const;
-  const std::string& key_metadata() const;
+  std::shared_ptr<schema::ColumnPath> pathInSchema() const;
+  bool encryptedWithFooterKey() const;
+  const std::string& keyMetadata() const;
 
  private:
   explicit ColumnCryptoMetaData(const uint8_t* metadata);
@@ -115,18 +116,18 @@ class PARQUET_EXPORT ColumnCryptoMetaData {
   std::unique_ptr<ColumnCryptoMetaDataImpl> impl_;
 };
 
-/// \brief Public struct for Thrift PageEncodingStats in ColumnChunkMetaData
+/// \brief Public struct for Thrift PageEncodingStats in ColumnChunkMetaData.
 struct PageEncodingStats {
-  PageType::type page_type;
+  PageType::type pageType;
   Encoding::type encoding;
   int32_t count;
 };
 
 /// \brief Public struct for location to page index in ColumnChunkMetaData.
 struct IndexLocation {
-  /// File offset of the given index, in bytes
+  /// File offset of the given index, in bytes.
   int64_t offset;
-  /// Length of the given index, in bytes
+  /// Length of the given index, in bytes.
   int32_t length;
 };
 
@@ -134,73 +135,74 @@ struct IndexLocation {
 /// facebook::velox::parquet::thrift::ColumnChunkMetaData.
 class PARQUET_EXPORT ColumnChunkMetaData {
  public:
-  // API convenience to get a MetaData accessor
+  // API convenience to get a MetaData accessor.
 
   ARROW_DEPRECATED("Use the ReaderProperties-taking overload")
-  static std::unique_ptr<ColumnChunkMetaData> Make(
+  static std::unique_ptr<ColumnChunkMetaData> make(
       const void* metadata,
       const ColumnDescriptor* descr,
-      const ApplicationVersion* writer_version,
-      int16_t row_group_ordinal = -1,
-      int16_t column_ordinal = -1,
-      std::shared_ptr<InternalFileDecryptor> file_decryptor = NULLPTR);
+      const ApplicationVersion* writerVersion,
+      int16_t rowGroupOrdinal = -1,
+      int16_t columnOrdinal = -1,
+      std::shared_ptr<InternalFileDecryptor> fileDecryptor = NULLPTR);
 
-  static std::unique_ptr<ColumnChunkMetaData> Make(
+  static std::unique_ptr<ColumnChunkMetaData> make(
       const void* metadata,
       const ColumnDescriptor* descr,
-      const ReaderProperties& properties = default_reader_properties(),
-      const ApplicationVersion* writer_version = NULLPTR,
-      int16_t row_group_ordinal = -1,
-      int16_t column_ordinal = -1,
-      std::shared_ptr<InternalFileDecryptor> file_decryptor = NULLPTR);
+      const ReaderProperties& properties = defaultReaderProperties(),
+      const ApplicationVersion* writerVersion = NULLPTR,
+      int16_t rowGroupOrdinal = -1,
+      int16_t columnOrdinal = -1,
+      std::shared_ptr<InternalFileDecryptor> fileDecryptor = NULLPTR);
 
   ~ColumnChunkMetaData();
 
-  bool Equals(const ColumnChunkMetaData& other) const;
+  bool equals(const ColumnChunkMetaData& other) const;
 
-  // column chunk
-  int64_t file_offset() const;
+  // Column chunk.
+  int64_t fileOffset() const;
 
-  // parameter is only used when a dataset is spread across multiple files
-  const std::string& file_path() const;
+  // Parameter is only used when a dataset is spread across multiple files.
+  const std::string& filePath() const;
 
-  // column metadata
-  bool is_metadata_set() const;
+  // Column metadata.
+  bool isMetadataSet() const;
   Type::type type() const;
-  int64_t num_values() const;
-  std::shared_ptr<schema::ColumnPath> path_in_schema() const;
-  bool is_stats_set() const;
+  int64_t numValues() const;
+  std::shared_ptr<schema::ColumnPath> pathInSchema() const;
+  bool isStatsSet() const;
   std::shared_ptr<Statistics> statistics() const;
 
   Compression::type compression() const;
   // Indicate if the ColumnChunk compression is supported by the current
-  // compiled parquet library.
-  bool can_decompress() const;
+  // compiled Parquet library.
+  bool canDecompress() const;
 
   const std::vector<Encoding::type>& encodings() const;
-  const std::vector<PageEncodingStats>& encoding_stats() const;
-  std::optional<int64_t> bloom_filter_offset() const;
-  bool has_dictionary_page() const;
-  int64_t dictionary_page_offset() const;
-  int64_t data_page_offset() const;
-  bool has_index_page() const;
-  int64_t index_page_offset() const;
-  int64_t total_compressed_size() const;
-  int64_t total_uncompressed_size() const;
-  std::unique_ptr<ColumnCryptoMetaData> crypto_metadata() const;
-  std::optional<IndexLocation> GetColumnIndexLocation() const;
-  std::optional<IndexLocation> GetOffsetIndexLocation() const;
+  const std::vector<PageEncodingStats>& encodingStats() const;
+  std::optional<int64_t> bloomFilterOffset() const;
+  bool hasDictionaryPage() const;
+  int64_t dictionaryPageOffset() const;
+  int64_t dataPageOffset() const;
+  bool hasIndexPage() const;
+  int64_t indexPageOffset() const;
+  int64_t totalCompressedSize() const;
+  int64_t totalUncompressedSize() const;
+  int32_t fieldId() const;
+  std::unique_ptr<ColumnCryptoMetaData> cryptoMetadata() const;
+  std::optional<IndexLocation> getColumnIndexLocation() const;
+  std::optional<IndexLocation> getOffsetIndexLocation() const;
 
  private:
   explicit ColumnChunkMetaData(
       const void* metadata,
       const ColumnDescriptor* descr,
-      int16_t row_group_ordinal,
-      int16_t column_ordinal,
+      int16_t rowGroupOrdinal,
+      int16_t columnOrdinal,
       const ReaderProperties& properties,
-      const ApplicationVersion* writer_version = NULLPTR,
-      std::shared_ptr<InternalFileDecryptor> file_decryptor = NULLPTR);
-  // PIMPL Idiom
+      const ApplicationVersion* writerVersion = NULLPTR,
+      std::shared_ptr<InternalFileDecryptor> fileDecryptor = NULLPTR);
+  // PIMPL Idiom.
   class ColumnChunkMetaDataImpl;
   std::unique_ptr<ColumnChunkMetaDataImpl> impl_;
 };
@@ -210,73 +212,73 @@ class PARQUET_EXPORT ColumnChunkMetaData {
 class PARQUET_EXPORT RowGroupMetaData {
  public:
   ARROW_DEPRECATED("Use the ReaderProperties-taking overload")
-  static std::unique_ptr<RowGroupMetaData> Make(
+  static std::unique_ptr<RowGroupMetaData> make(
       const void* metadata,
       const SchemaDescriptor* schema,
-      const ApplicationVersion* writer_version,
-      std::shared_ptr<InternalFileDecryptor> file_decryptor = NULLPTR);
+      const ApplicationVersion* writerVersion,
+      std::shared_ptr<InternalFileDecryptor> fileDecryptor = NULLPTR);
 
   /// \brief Create a RowGroupMetaData from a serialized thrift message.
-  static std::unique_ptr<RowGroupMetaData> Make(
+  static std::unique_ptr<RowGroupMetaData> make(
       const void* metadata,
       const SchemaDescriptor* schema,
-      const ReaderProperties& properties = default_reader_properties(),
-      const ApplicationVersion* writer_version = NULLPTR,
-      std::shared_ptr<InternalFileDecryptor> file_decryptor = NULLPTR);
+      const ReaderProperties& properties = defaultReaderProperties(),
+      const ApplicationVersion* writerVersion = NULLPTR,
+      std::shared_ptr<InternalFileDecryptor> fileDecryptor = NULLPTR);
 
   ~RowGroupMetaData();
 
-  bool Equals(const RowGroupMetaData& other) const;
+  bool equals(const RowGroupMetaData& other) const;
 
   /// \brief The number of columns in this row group. The order must match the
   /// parent's column ordering.
-  int num_columns() const;
+  int numColumns() const;
 
   /// \brief Return the ColumnChunkMetaData of the corresponding column ordinal.
   ///
-  /// WARNING, the returned object references memory location in it's parent
+  /// WARNING: The returned object references memory location in its parent
   /// (RowGroupMetaData) object. Hence, the parent must outlive the returned
   /// object.
   ///
-  /// \param[in] index of the ColumnChunkMetaData to retrieve.
+  /// \param[in] index Index of the ColumnChunkMetaData to retrieve.
   ///
   /// \throws ParquetException if the index is out of bound.
-  std::unique_ptr<ColumnChunkMetaData> ColumnChunk(int index) const;
+  std::unique_ptr<ColumnChunkMetaData> columnChunk(int index) const;
 
   /// \brief Number of rows in this row group.
-  int64_t num_rows() const;
+  int64_t numRows() const;
 
   /// \brief Total byte size of all the uncompressed column data in this row
   /// group.
-  int64_t total_byte_size() const;
+  int64_t totalByteSize() const;
 
   /// \brief Total byte size of all the compressed (and potentially encrypted)
   /// column data in this row group.
   ///
   /// This information is optional and may be 0 if omitted.
-  int64_t total_compressed_size() const;
+  int64_t totalCompressedSize() const;
 
   /// \brief Byte offset from beginning of file to first page (data or
-  /// dictionary) in this row group
+  /// dictionary) in this row group.
   ///
   /// The file_offset field that this method exposes is optional. This method
   /// will return 0 if that field is not set to a meaningful value.
-  int64_t file_offset() const;
-  // Return const-pointer to make it clear that this object is not to be copied
+  int64_t fileOffset() const;
+  // Return const pointer to make it clear that this object is not to be copied.
   const SchemaDescriptor* schema() const;
   // Indicate if all of the RowGroup's ColumnChunks can be decompressed.
-  bool can_decompress() const;
+  bool canDecompress() const;
   // Sorting columns of the row group if any.
-  std::vector<SortingColumn> sorting_columns() const;
+  std::vector<SortingColumn> sortingColumns() const;
 
  private:
   explicit RowGroupMetaData(
       const void* metadata,
       const SchemaDescriptor* schema,
       const ReaderProperties& properties,
-      const ApplicationVersion* writer_version = NULLPTR,
-      std::shared_ptr<InternalFileDecryptor> file_decryptor = NULLPTR);
-  // PIMPL Idiom
+      const ApplicationVersion* writerVersion = NULLPTR,
+      std::shared_ptr<InternalFileDecryptor> fileDecryptor = NULLPTR);
+  // PIMPL Idiom.
   class RowGroupMetaDataImpl;
   std::unique_ptr<RowGroupMetaDataImpl> impl_;
 };
@@ -288,74 +290,74 @@ class FileMetaDataBuilder;
 class PARQUET_EXPORT FileMetaData {
  public:
   ARROW_DEPRECATED("Use the ReaderProperties-taking overload")
-  static std::shared_ptr<FileMetaData> Make(
-      const void* serialized_metadata,
-      uint32_t* inout_metadata_len,
-      std::shared_ptr<InternalFileDecryptor> file_decryptor);
+  static std::shared_ptr<FileMetaData> make(
+      const void* serializedMetadata,
+      uint32_t* inoutMetadataLen,
+      std::shared_ptr<InternalFileDecryptor> fileDecryptor);
 
   /// \brief Create a FileMetaData from a serialized thrift message.
-  static std::shared_ptr<FileMetaData> Make(
-      const void* serialized_metadata,
-      uint32_t* inout_metadata_len,
-      const ReaderProperties& properties = default_reader_properties(),
-      std::shared_ptr<InternalFileDecryptor> file_decryptor = NULLPTR);
+  static std::shared_ptr<FileMetaData> make(
+      const void* serializedMetadata,
+      uint32_t* inoutMetadataLen,
+      const ReaderProperties& properties = defaultReaderProperties(),
+      std::shared_ptr<InternalFileDecryptor> fileDecryptor = NULLPTR);
 
   ~FileMetaData();
 
-  bool Equals(const FileMetaData& other) const;
+  bool equals(const FileMetaData& other) const;
 
-  /// \brief The number of parquet "leaf" columns.
+  /// \brief The number of Parquet "leaf" columns.
   ///
   /// Parquet thrift definition requires that nested schema elements are
   /// flattened. This method returns the number of columns in the flattened
   /// version.
-  /// For instance, if the schema looks like this :
-  /// 0 foo.bar
-  ///       foo.bar.baz           0
-  ///       foo.bar.baz2          1
-  ///   foo.qux                   2
-  /// 1 foo2                      3
-  /// 2 foo3                      4
+  /// For instance, if the schema looks like this:
+  /// 0 Foo.bar
+  ///       Foo.bar.baz           0
+  ///       Foo.bar.baz2          1
+  ///   Foo.qux                   2
+  /// 1 Foo2                      3
+  /// 2 Foo3                      4
   /// This method will return 5, because there are 5 "leaf" fields (so 5
-  /// flattened fields)
-  int num_columns() const;
+  /// flattened fields).
+  int numColumns() const;
 
   /// \brief The number of flattened schema elements.
   ///
   /// Parquet thrift definition requires that nested schema elements are
   /// flattened. This method returns the total number of elements in the
   /// flattened list.
-  int num_schema_elements() const;
+  int numSchemaElements() const;
 
   /// \brief The total number of rows.
-  int64_t num_rows() const;
+  int64_t numRows() const;
 
   /// \brief The number of row groups in the file.
-  int num_row_groups() const;
+  int numRowGroups() const;
 
   /// \brief Return the RowGroupMetaData of the corresponding row group ordinal.
   ///
-  /// WARNING, the returned object references memory location in it's parent
+  /// WARNING: The returned object references memory location in its parent
   /// (FileMetaData) object. Hence, the parent must outlive the returned object.
   ///
-  /// \param[in] index of the RowGroup to retrieve.
+  /// \param[in] index Index of the RowGroup to retrieve.
   ///
   /// \throws ParquetException if the index is out of bound.
-  std::unique_ptr<RowGroupMetaData> RowGroup(int index) const;
+  std::unique_ptr<RowGroupMetaData> rowGroup(int index) const;
 
-  /// \brief Return the "version" of the file
+  /// \brief Return the "version" of the file.
   ///
-  /// WARNING: The value returned by this method is unreliable as 1) the Parquet
-  /// file metadata stores the version as a single integer and 2) some producers
-  /// are known to always write a hardcoded value.  Therefore, you cannot use
-  /// this value to know which features are used in the file.
+  /// WARNING: The value returned by this method is unreliable as 1) the
+  /// Parquet file metadata stores the version as a single integer and 2) some
+  /// producers are known to always write a hardcoded value. Therefore, you
+  /// cannot use this value to know which features are used in the file.
   ParquetVersion::type version() const;
 
   /// \brief Return the application's user-agent string of the writer.
-  const std::string& created_by() const;
+  const std::string& createdBy() const;
 
   /// \brief Return the application's version of the writer.
-  const ApplicationVersion& writer_version() const;
+  const ApplicationVersion& writerVersion() const;
 
   /// \brief Size of the original thrift encoded metadata footer.
   uint32_t size() const;
@@ -364,71 +366,75 @@ class PARQUET_EXPORT FileMetaData {
   /// decompressed.
   ///
   /// This will return false if any of the RowGroup's page is compressed with a
-  /// compression format which is not compiled in the current parquet library.
-  bool can_decompress() const;
+  /// compression format which is not compiled in the current Parquet library.
+  bool canDecompress() const;
 
-  bool is_encryption_algorithm_set() const;
-  EncryptionAlgorithm encryption_algorithm() const;
-  const std::string& footer_signing_key_metadata() const;
+  bool isEncryptionAlgorithmSet() const;
+  EncryptionAlgorithm encryptionAlgorithm() const;
+  const std::string& footerSigningKeyMetadata() const;
 
   /// \brief Verify signature of FileMetaData when file is encrypted but footer
   /// is not encrypted (plaintext footer).
-  bool VerifySignature(const void* signature);
+  bool verifySignature(const void* signature);
 
-  void WriteTo(
+  void writeTo(
       ::arrow::io::OutputStream* dst,
       const std::shared_ptr<Encryptor>& encryptor = NULLPTR) const;
 
   /// \brief Return Thrift-serialized representation of the metadata as a
-  /// string
-  std::string SerializeToString() const;
+  /// string.
+  std::string serializeToString() const;
 
-  // Return const-pointer to make it clear that this object is not to be copied
+  // Return const pointer to make it clear that this object is not to be copied.
   const SchemaDescriptor* schema() const;
 
-  const std::shared_ptr<const KeyValueMetadata>& key_value_metadata() const;
+  const std::shared_ptr<const KeyValueMetadata>& keyValueMetadata() const;
 
   /// \brief Set a path to all ColumnChunk for all RowGroups.
   ///
-  /// Commonly used by systems (Dask, Spark) who generates an metadata-only
-  /// parquet file. The path is usually relative to said index file.
+  /// Commonly used by systems (Dask, Spark) that generate a metadata-only
+  /// Parquet file. The path is usually relative to said index file.
   ///
-  /// \param[in] path to set.
-  void set_file_path(const std::string& path);
+  /// \param[in] path Path to set.
+  void setFilePath(const std::string& path);
 
   /// \brief Merge row groups from another metadata file into this one.
   ///
   /// The schema of the input FileMetaData must be equal to the
   /// schema of this object.
   ///
-  /// This is used by systems who creates an aggregate metadata-only file by
+  /// This is used by systems that create an aggregate metadata-only file by
   /// concatenating the row groups of multiple files. This newly created
   /// metadata file acts as an index of all available row groups.
   ///
-  /// \param[in] other FileMetaData to merge the row groups from.
+  /// \param[in] other Other FileMetaData to merge the row groups from.
   ///
   /// \throws ParquetException if schemas are not equal.
-  void AppendRowGroups(const FileMetaData& other);
+  void appendRowGroups(const FileMetaData& other);
 
-  /// \brief Return a FileMetaData containing a subset of the row groups in this
-  /// FileMetaData.
-  std::shared_ptr<FileMetaData> Subset(
-      const std::vector<int>& row_groups) const;
+  /// \brief Return a FileMetaData containing a subset of the row groups in
+  /// this FileMetaData.
+  std::shared_ptr<FileMetaData> subset(const std::vector<int>& rowGroups) const;
+
+  /// \brief Get total NaN count for a specific field ID across all row groups.
+  /// Returns a pair of (nanCount, hasNanCount).
+  /// NaN counts are collected during writing but not written to the Parquet
+  /// file.
+  std::pair<int64_t, bool> getNaNCount(int32_t fieldId) const;
 
  private:
   friend FileMetaDataBuilder;
   friend class SerializedFile;
 
   explicit FileMetaData(
-      const void* serialized_metadata,
-      uint32_t* metadata_len,
+      const void* serializedMetadata,
+      uint32_t* metadataLen,
       const ReaderProperties& properties,
-      std::shared_ptr<InternalFileDecryptor> file_decryptor = NULLPTR);
+      std::shared_ptr<InternalFileDecryptor> fileDecryptor = NULLPTR);
 
-  void set_file_decryptor(
-      std::shared_ptr<InternalFileDecryptor> file_decryptor);
+  void setFileDecryptor(std::shared_ptr<InternalFileDecryptor> fileDecryptor);
 
-  // PIMPL Idiom
+  // PIMPL Idiom.
   FileMetaData();
   class FileMetaDataImpl;
   std::unique_ptr<FileMetaDataImpl> impl_;
@@ -436,75 +442,81 @@ class PARQUET_EXPORT FileMetaData {
 
 class PARQUET_EXPORT FileCryptoMetaData {
  public:
-  // API convenience to get a MetaData accessor
-  static std::shared_ptr<FileCryptoMetaData> Make(
-      const uint8_t* serialized_metadata,
-      uint32_t* metadata_len,
-      const ReaderProperties& properties = default_reader_properties());
+  // API convenience to get a MetaData accessor.
+  static std::shared_ptr<FileCryptoMetaData> make(
+      const uint8_t* serializedMetadata,
+      uint32_t* metadataLen,
+      const ReaderProperties& properties = defaultReaderProperties());
   ~FileCryptoMetaData();
 
-  EncryptionAlgorithm encryption_algorithm() const;
-  const std::string& key_metadata() const;
+  EncryptionAlgorithm encryptionAlgorithm() const;
+  const std::string& keyMetadata() const;
 
-  void WriteTo(::arrow::io::OutputStream* dst) const;
+  void writeTo(::arrow::io::OutputStream* dst) const;
 
  private:
   friend FileMetaDataBuilder;
   FileCryptoMetaData(
-      const uint8_t* serialized_metadata,
-      uint32_t* metadata_len,
+      const uint8_t* serializedMetadata,
+      uint32_t* metadataLen,
       const ReaderProperties& properties);
 
-  // PIMPL Idiom
+  // PIMPL Idiom.
   FileCryptoMetaData();
   class FileCryptoMetaDataImpl;
   std::unique_ptr<FileCryptoMetaDataImpl> impl_;
 };
 
-// Builder API
+// Builder API.
 class PARQUET_EXPORT ColumnChunkMetaDataBuilder {
  public:
-  // API convenience to get a MetaData reader
-  static std::unique_ptr<ColumnChunkMetaDataBuilder> Make(
+  // API convenience to get a MetaData reader.
+  static std::unique_ptr<ColumnChunkMetaDataBuilder> make(
       std::shared_ptr<WriterProperties> props,
       const ColumnDescriptor* column);
 
-  static std::unique_ptr<ColumnChunkMetaDataBuilder> Make(
+  static std::unique_ptr<ColumnChunkMetaDataBuilder> make(
       std::shared_ptr<WriterProperties> props,
       const ColumnDescriptor* column,
-      void* contents);
+      void* Contents);
 
   ~ColumnChunkMetaDataBuilder();
 
-  // column chunk
-  // Used when a dataset is spread across multiple files
-  void set_file_path(const std::string& path);
-  // column metadata
-  void SetStatistics(const EncodedStatistics& stats);
-  // get the column descriptor
+  // Column chunk.
+  // Used when a dataset is spread across multiple files.
+  void setFilePath(const std::string& path);
+  // Column metadata.
+  void setStatistics(const EncodedStatistics& stats);
+  // Get the column descriptor.
   const ColumnDescriptor* descr() const;
 
-  int64_t total_compressed_size() const;
-  // commit the metadata
-
-  void Finish(
-      int64_t num_values,
-      int64_t dictionary_page_offset,
-      int64_t index_page_offset,
-      int64_t data_page_offset,
-      int64_t compressed_size,
-      int64_t uncompressed_size,
-      bool has_dictionary,
-      bool dictionary_fallback,
-      const std::map<Encoding::type, int32_t>& dict_encoding_stats_,
-      const std::map<Encoding::type, int32_t>& data_encoding_stats_,
+  int64_t totalCompressedSize() const;
+
+  // NaN count accessors - NaN counts are collected during writing but not
+  // written to the parquet file.
+  int64_t nanCount() const;
+
+  bool hasNanCount() const;
+
+  // Commit the metadata.
+  void finish(
+      int64_t numValues,
+      int64_t dictionaryPageOffset,
+      int64_t indexPageOffset,
+      int64_t dataPageOffset,
+      int64_t compressedSize,
+      int64_t uncompressedSize,
+      bool hasDictionary,
+      bool dictionaryFallback,
+      const std::map<Encoding::type, int32_t>& dictEncodingStats,
+      const std::map<Encoding::type, int32_t>& dataEncodingStats,
       const std::shared_ptr<Encryptor>& encryptor = NULLPTR);
 
-  // The metadata contents, suitable for passing to ColumnChunkMetaData::Make
-  const void* contents() const;
+  // The metadata contents, suitable for passing to ColumnChunkMetaData::Make.
+  const void* Contents() const;
 
-  // For writing metadata at end of column chunk
-  void WriteTo(::arrow::io::OutputStream* sink);
+  // For writing metadata at end of column chunk.
+  void writeTo(::arrow::io::OutputStream* sink);
 
  private:
   explicit ColumnChunkMetaDataBuilder(
@@ -513,97 +525,101 @@ class PARQUET_EXPORT ColumnChunkMetaDataBuilder {
   explicit ColumnChunkMetaDataBuilder(
       std::shared_ptr<WriterProperties> props,
       const ColumnDescriptor* column,
-      void* contents);
-  // PIMPL Idiom
+      void* Contents);
+  // PIMPL Idiom.
   class ColumnChunkMetaDataBuilderImpl;
   std::unique_ptr<ColumnChunkMetaDataBuilderImpl> impl_;
 };
 
 class PARQUET_EXPORT RowGroupMetaDataBuilder {
  public:
-  // API convenience to get a MetaData reader
-  static std::unique_ptr<RowGroupMetaDataBuilder> Make(
+  // API convenience to get a MetaData reader.
+  static std::unique_ptr<RowGroupMetaDataBuilder> make(
       std::shared_ptr<WriterProperties> props,
       const SchemaDescriptor* schema_,
-      void* contents);
+      void* Contents);
 
   ~RowGroupMetaDataBuilder();
 
-  ColumnChunkMetaDataBuilder* NextColumnChunk();
-  int num_columns();
-  int64_t num_rows();
-  int current_column() const;
+  ColumnChunkMetaDataBuilder* nextColumnChunk();
+  int numColumns();
+  int64_t numRows();
+  int currentColumn() const;
+
+  void setNumRows(int64_t numRows);
 
-  void set_num_rows(int64_t num_rows);
+  // Get NaN counts for all columns in current row group.
+  // Returns a map of field_id -> (nan_count, has_nan_count).
+  std::unordered_map<int32_t, std::pair<int64_t, bool>> nanCounts() const;
 
-  // commit the metadata
-  void Finish(int64_t total_bytes_written, int16_t row_group_ordinal = -1);
+  // Commit the metadata.
+  void finish(int64_t totalBytesWritten, int16_t rowGroupOrdinal = -1);
 
  private:
   explicit RowGroupMetaDataBuilder(
       std::shared_ptr<WriterProperties> props,
       const SchemaDescriptor* schema_,
-      void* contents);
-  // PIMPL Idiom
+      void* Contents);
+  // PIMPL Idiom.
   class RowGroupMetaDataBuilderImpl;
   std::unique_ptr<RowGroupMetaDataBuilderImpl> impl_;
 };
 
-/// \brief Public struct for location to all page indexes in a parquet file.
+/// \brief Public struct for location to all page indexes in a Parquet file.
 struct PageIndexLocation {
   /// Alias type of page index location of a row group. The index location
   /// is located by column ordinal. If the column does not have the page index,
   /// its value is set to std::nullopt.
   using RowGroupIndexLocation = std::vector<std::optional<IndexLocation>>;
-  /// Alias type of page index location of a parquet file. The index location
+  /// Alias type of page index location of a Parquet file. The index location
   /// is located by the row group ordinal.
   using FileIndexLocation = std::map<size_t, RowGroupIndexLocation>;
-  /// Row group column index locations which uses row group ordinal as the key.
-  FileIndexLocation column_index_location;
-  /// Row group offset index locations which uses row group ordinal as the key.
-  FileIndexLocation offset_index_location;
+  /// Row group column index locations which use row group ordinal as the key.
+  FileIndexLocation columnIndexLocation;
+  /// Row group offset index locations which use row group ordinal as the key.
+  FileIndexLocation offsetIndexLocation;
 };
 
 class PARQUET_EXPORT FileMetaDataBuilder {
  public:
   ARROW_DEPRECATED(
       "Deprecated in 12.0.0. Use overload without KeyValueMetadata instead.")
-  static std::unique_ptr<FileMetaDataBuilder> Make(
+  static std::unique_ptr<FileMetaDataBuilder> make(
       const SchemaDescriptor* schema,
       std::shared_ptr<WriterProperties> props,
-      std::shared_ptr<const KeyValueMetadata> key_value_metadata);
+      std::shared_ptr<const KeyValueMetadata> keyValueMetadata);
 
-  // API convenience to get a MetaData builder
-  static std::unique_ptr<FileMetaDataBuilder> Make(
+  // API convenience to get a MetaData builder.
+  static std::unique_ptr<FileMetaDataBuilder> make(
       const SchemaDescriptor* schema,
       std::shared_ptr<WriterProperties> props);
 
   ~FileMetaDataBuilder();
 
-  // The prior RowGroupMetaDataBuilder (if any) is destroyed
-  RowGroupMetaDataBuilder* AppendRowGroup();
+  // The prior RowGroupMetaDataBuilder (if any) is destroyed.
+  RowGroupMetaDataBuilder* appendRowGroup();
 
-  // Update location to all page indexes in the parquet file
-  void SetPageIndexLocation(const PageIndexLocation& location);
+  // Update location to all page indexes in the Parquet file.
+  void setPageIndexLocation(const PageIndexLocation& location);
 
-  // Complete the Thrift structure
-  std::unique_ptr<FileMetaData> Finish(
-      const std::shared_ptr<const KeyValueMetadata>& key_value_metadata =
+  // Complete the Thrift structure.
+  std::unique_ptr<FileMetaData> finish(
+      const std::shared_ptr<const KeyValueMetadata>& keyValueMetadata =
           NULLPTR);
 
-  // crypto metadata
-  std::unique_ptr<FileCryptoMetaData> GetCryptoMetaData();
+  // Crypto metadata.
+  std::unique_ptr<FileCryptoMetaData> getCryptoMetaData();
 
  private:
   explicit FileMetaDataBuilder(
       const SchemaDescriptor* schema,
       std::shared_ptr<WriterProperties> props,
-      std::shared_ptr<const KeyValueMetadata> key_value_metadata = NULLPTR);
-  // PIMPL Idiom
+      std::shared_ptr<const KeyValueMetadata> keyValueMetadata = NULLPTR);
+  // PIMPL Idiom.
   class FileMetaDataBuilderImpl;
   std::unique_ptr<FileMetaDataBuilderImpl> impl_;
 };
 
-PARQUET_EXPORT std::string ParquetVersionToString(ParquetVersion::type ver);
+PARQUET_EXPORT std::string parquetVersionToString(ParquetVersion::type ver);
 
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/PageIndex.cpp b/velox/dwio/parquet/writer/arrow/PageIndex.cpp
index 465d6e1afec..e07538e83ba 100644
--- a/velox/dwio/parquet/writer/arrow/PageIndex.cpp
+++ b/velox/dwio/parquet/writer/arrow/PageIndex.cpp
@@ -36,55 +36,54 @@ namespace facebook::velox::parquet::arrow {
 namespace {
 
 template <typename DType>
-void Decode(
+void decode(
     std::unique_ptr<typename EncodingTraits<DType>::Decoder>& decoder,
     const std::string& input,
-    std::vector<typename DType::c_type>* output,
-    size_t output_index) {
-  if (ARROW_PREDICT_FALSE(output_index >= output->size())) {
+    std::vector<typename DType::CType>* output,
+    size_t outputIndex) {
+  if (ARROW_PREDICT_FALSE(outputIndex >= output->size())) {
     throw ParquetException("Index out of bound");
   }
 
-  decoder->SetData(
-      /*num_values=*/1,
+  decoder->setData(
+      1,
       reinterpret_cast<const uint8_t*>(input.c_str()),
       static_cast<int>(input.size()));
-  const auto num_values =
-      decoder->Decode(&output->at(output_index), /*max_values=*/1);
-  if (ARROW_PREDICT_FALSE(num_values != 1)) {
+  const auto numValues = decoder->decode(&output->at(outputIndex), 1);
+  if (ARROW_PREDICT_FALSE(numValues != 1)) {
     throw ParquetException("Could not decode statistics value");
   }
 }
 
 template <>
-void Decode<BooleanType>(
+void decode<BooleanType>(
     std::unique_ptr<BooleanDecoder>& decoder,
     const std::string& input,
     std::vector<bool>* output,
-    size_t output_index) {
-  if (ARROW_PREDICT_FALSE(output_index >= output->size())) {
+    size_t outputIndex) {
+  if (ARROW_PREDICT_FALSE(outputIndex >= output->size())) {
     throw ParquetException("Index out of bound");
   }
 
   bool value;
-  decoder->SetData(
-      /*num_values=*/1,
+  decoder->setData(
+      1,
       reinterpret_cast<const uint8_t*>(input.c_str()),
       static_cast<int>(input.size()));
-  const auto num_values = decoder->Decode(&value, /*max_values=*/1);
-  if (ARROW_PREDICT_FALSE(num_values != 1)) {
+  const auto numValues = decoder->decode(&value, 1);
+  if (ARROW_PREDICT_FALSE(numValues != 1)) {
     throw ParquetException("Could not decode statistics value");
   }
-  output->at(output_index) = value;
+  output->at(outputIndex) = value;
 }
 
 template <>
-void Decode<ByteArrayType>(
+void decode<ByteArrayType>(
     std::unique_ptr<ByteArrayDecoder>&,
     const std::string& input,
     std::vector<ByteArray>* output,
-    size_t output_index) {
-  if (ARROW_PREDICT_FALSE(output_index >= output->size())) {
+    size_t outputIndex) {
+  if (ARROW_PREDICT_FALSE(outputIndex >= output->size())) {
     throw ParquetException("Index out of bound");
   }
 
@@ -94,273 +93,265 @@ void Decode<ByteArrayType>(
     throw ParquetException("Invalid encoded byte array length");
   }
 
-  output->at(output_index) = {
-      /*len=*/static_cast<uint32_t>(input.size()),
-      /*ptr=*/reinterpret_cast<const uint8_t*>(input.data())};
+  output->at(outputIndex) = {
+      static_cast<uint32_t>(input.size()),
+      reinterpret_cast<const uint8_t*>(input.data())};
 }
 
 template <typename DType>
 class TypedColumnIndexImpl : public TypedColumnIndex<DType> {
  public:
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
 
   TypedColumnIndexImpl(
       const ColumnDescriptor& descr,
-      facebook::velox::parquet::thrift::ColumnIndex column_index)
-      : column_index_(std::move(column_index)) {
+      facebook::velox::parquet::thrift::ColumnIndex columnIndex)
+      : columnIndex_(std::move(columnIndex)) {
     // Make sure the number of pages is valid and it does not overflow to
     // int32_t.
-    const size_t num_pages = column_index_.null_pages.size();
-    if (num_pages >= static_cast<size_t>(std::numeric_limits<int32_t>::max()) ||
-        column_index_.min_values.size() != num_pages ||
-        column_index_.max_values.size() != num_pages ||
-        (column_index_.__isset.null_counts &&
-         column_index_.null_counts.size() != num_pages)) {
+    const size_t numPages = columnIndex_.null_pages.size();
+    if (numPages >= static_cast<size_t>(std::numeric_limits<int32_t>::max()) ||
+        columnIndex_.min_values.size() != numPages ||
+        columnIndex_.max_values.size() != numPages ||
+        (columnIndex_.__isset.null_counts &&
+         columnIndex_.null_counts.size() != numPages)) {
       throw ParquetException("Invalid column index");
     }
 
-    const size_t num_non_null_pages = static_cast<size_t>(std::accumulate(
-        column_index_.null_pages.cbegin(),
-        column_index_.null_pages.cend(),
+    const size_t numNonNullPages = static_cast<size_t>(std::accumulate(
+        columnIndex_.null_pages.cbegin(),
+        columnIndex_.null_pages.cend(),
         0,
-        [](int32_t num_non_null_pages, bool null_page) {
-          return num_non_null_pages + (null_page ? 0 : 1);
+        [](int32_t numNonNullPages, bool nullPage) {
+          return numNonNullPages + (nullPage ? 0 : 1);
         }));
-    VELOX_DCHECK_LE(num_non_null_pages, num_pages);
+    VELOX_DCHECK_LE(numNonNullPages, numPages);
 
     // Allocate slots for decoded values.
-    min_values_.resize(num_pages);
-    max_values_.resize(num_pages);
-    non_null_page_indices_.reserve(num_non_null_pages);
+    minValues_.resize(numPages);
+    maxValues_.resize(numPages);
+    nonNullPageIndices_.reserve(numNonNullPages);
 
     // Decode min and max values according to the physical type.
-    // Note that null page are skipped.
-    auto plain_decoder = MakeTypedDecoder<DType>(Encoding::PLAIN, &descr);
-    for (size_t i = 0; i < num_pages; ++i) {
-      if (!column_index_.null_pages[i]) {
-        // The check on `num_pages` has guaranteed the cast below is safe.
-        non_null_page_indices_.emplace_back(static_cast<int32_t>(i));
-        Decode<DType>(
-            plain_decoder, column_index_.min_values[i], &min_values_, i);
-        Decode<DType>(
-            plain_decoder, column_index_.max_values[i], &max_values_, i);
+    // Note that null pages are skipped.
+    auto plainDecoder = makeTypedDecoder<DType>(Encoding::kPlain, &descr);
+    for (size_t i = 0; i < numPages; ++i) {
+      if (!columnIndex_.null_pages[i]) {
+        // The check on `numPages` has guaranteed the cast below is safe.
+        nonNullPageIndices_.emplace_back(static_cast<int32_t>(i));
+        decode<DType>(plainDecoder, columnIndex_.min_values[i], &minValues_, i);
+        decode<DType>(plainDecoder, columnIndex_.max_values[i], &maxValues_, i);
       }
     }
-    VELOX_DCHECK_EQ(num_non_null_pages, non_null_page_indices_.size());
+    VELOX_DCHECK_EQ(numNonNullPages, nonNullPageIndices_.size());
   }
 
-  const std::vector<bool>& null_pages() const override {
-    return column_index_.null_pages;
+  const std::vector<bool>& nullPages() const override {
+    return columnIndex_.null_pages;
   }
 
-  const std::vector<std::string>& encoded_min_values() const override {
-    return column_index_.min_values;
+  const std::vector<std::string>& encodedMinValues() const override {
+    return columnIndex_.min_values;
   }
 
-  const std::vector<std::string>& encoded_max_values() const override {
-    return column_index_.max_values;
+  const std::vector<std::string>& encodedMaxValues() const override {
+    return columnIndex_.max_values;
   }
 
-  BoundaryOrder::type boundary_order() const override {
-    return LoadEnumSafe(&column_index_.boundary_order);
+  BoundaryOrder::type boundaryOrder() const override {
+    return loadenumSafe(&columnIndex_.boundary_order);
   }
 
-  bool has_null_counts() const override {
-    return column_index_.__isset.null_counts;
+  bool hasNullCounts() const override {
+    return columnIndex_.__isset.null_counts;
   }
 
-  const std::vector<int64_t>& null_counts() const override {
-    return column_index_.null_counts;
+  const std::vector<int64_t>& nullCounts() const override {
+    return columnIndex_.null_counts;
   }
 
-  const std::vector<int32_t>& non_null_page_indices() const override {
-    return non_null_page_indices_;
+  const std::vector<int32_t>& nonNullPageIndices() const override {
+    return nonNullPageIndices_;
   }
 
-  const std::vector<T>& min_values() const override {
-    return min_values_;
+  const std::vector<T>& minValues() const override {
+    return minValues_;
   }
 
-  const std::vector<T>& max_values() const override {
-    return max_values_;
+  const std::vector<T>& maxValues() const override {
+    return maxValues_;
   }
 
  private:
-  /// Wrapped thrift column index.
-  const facebook::velox::parquet::thrift::ColumnIndex column_index_;
+  /// Wrapped Thrift column index.
+  const facebook::velox::parquet::thrift::ColumnIndex columnIndex_;
   /// Decoded typed min/max values. Undefined for null pages.
-  std::vector<T> min_values_;
-  std::vector<T> max_values_;
+  std::vector<T> minValues_;
+  std::vector<T> maxValues_;
   /// A list of page indices for non-null pages.
-  std::vector<int32_t> non_null_page_indices_;
+  std::vector<int32_t> nonNullPageIndices_;
 };
 
 class OffsetIndexImpl : public OffsetIndex {
  public:
   explicit OffsetIndexImpl(
-      const facebook::velox::parquet::thrift::OffsetIndex& offset_index) {
-    page_locations_.reserve(offset_index.page_locations.size());
-    for (const auto& page_location : offset_index.page_locations) {
-      page_locations_.emplace_back(PageLocation{
-          page_location.offset,
-          page_location.compressed_page_size,
-          page_location.first_row_index});
+      const facebook::velox::parquet::thrift::OffsetIndex& offsetIndex) {
+    pageLocations_.reserve(offsetIndex.page_locations.size());
+    for (const auto& pageLocation : offsetIndex.page_locations) {
+      pageLocations_.emplace_back(
+          PageLocation{
+              pageLocation.offset,
+              pageLocation.compressed_page_size,
+              pageLocation.first_row_index});
     }
   }
 
-  const std::vector<PageLocation>& page_locations() const override {
-    return page_locations_;
+  const std::vector<PageLocation>& pageLocations() const override {
+    return pageLocations_;
   }
 
  private:
-  std::vector<PageLocation> page_locations_;
+  std::vector<PageLocation> pageLocations_;
 };
 
 class RowGroupPageIndexReaderImpl : public RowGroupPageIndexReader {
  public:
   RowGroupPageIndexReaderImpl(
       ::arrow::io::RandomAccessFile* input,
-      std::shared_ptr<RowGroupMetaData> row_group_metadata,
+      std::shared_ptr<RowGroupMetaData> rowGroupMetadata,
       const ReaderProperties& properties,
-      int32_t row_group_ordinal,
-      const RowGroupIndexReadRange& index_read_range,
-      std::shared_ptr<InternalFileDecryptor> file_decryptor)
+      int32_t rowGroupOrdinal,
+      const RowGroupIndexReadRange& indexReadRange,
+      std::shared_ptr<InternalFileDecryptor> fileDecryptor)
       : input_(input),
-        row_group_metadata_(std::move(row_group_metadata)),
+        rowGroupMetadata_(std::move(rowGroupMetadata)),
         properties_(properties),
-        row_group_ordinal_(row_group_ordinal),
-        index_read_range_(index_read_range),
-        file_decryptor_(std::move(file_decryptor)) {}
+        rowGroupOrdinal_(rowGroupOrdinal),
+        indexReadRange_(indexReadRange),
+        fileDecryptor_(std::move(fileDecryptor)) {}
 
   /// Read column index of a column chunk.
-  std::shared_ptr<ColumnIndex> GetColumnIndex(int32_t i) override {
-    if (i < 0 || i >= row_group_metadata_->num_columns()) {
+  std::shared_ptr<ColumnIndex> getColumnIndex(int32_t i) override {
+    if (i < 0 || i >= rowGroupMetadata_->numColumns()) {
       throw ParquetException("Invalid column index at column ordinal ", i);
     }
 
-    auto col_chunk = row_group_metadata_->ColumnChunk(i);
-    std::unique_ptr<ColumnCryptoMetaData> crypto_metadata =
-        col_chunk->crypto_metadata();
-    if (crypto_metadata != nullptr) {
+    auto colChunk = rowGroupMetadata_->columnChunk(i);
+    std::unique_ptr<ColumnCryptoMetaData> cryptoMetadata =
+        colChunk->cryptoMetadata();
+    if (cryptoMetadata != nullptr) {
       ParquetException::NYI("Cannot read encrypted column index yet");
     }
 
-    auto column_index_location = col_chunk->GetColumnIndexLocation();
-    if (!column_index_location.has_value()) {
+    auto columnIndexLocation = colChunk->getColumnIndexLocation();
+    if (!columnIndexLocation.has_value()) {
       return nullptr;
     }
 
-    CheckReadRangeOrThrow(
-        *column_index_location,
-        index_read_range_.column_index,
-        row_group_ordinal_);
+    checkReadRangeOrThrow(
+        *columnIndexLocation, indexReadRange_.columnIndex, rowGroupOrdinal_);
 
-    if (column_index_buffer_ == nullptr) {
+    if (columnIndexBuffer_ == nullptr) {
       PARQUET_ASSIGN_OR_THROW(
-          column_index_buffer_,
+          columnIndexBuffer_,
           input_->ReadAt(
-              index_read_range_.column_index->offset,
-              index_read_range_.column_index->length));
+              indexReadRange_.columnIndex->offset,
+              indexReadRange_.columnIndex->length));
     }
 
-    int64_t buffer_offset =
-        column_index_location->offset - index_read_range_.column_index->offset;
-    // ColumnIndex::Make() requires the type of serialized thrift message to be
-    // uint32_t
-    uint32_t length = static_cast<uint32_t>(column_index_location->length);
-    auto descr = row_group_metadata_->schema()->Column(i);
-    return ColumnIndex::Make(
-        *descr,
-        column_index_buffer_->data() + buffer_offset,
-        length,
-        properties_);
+    int64_t bufferoffset =
+        columnIndexLocation->offset - indexReadRange_.columnIndex->offset;
+    // ColumnIndex::make() requires the type of serialized Thrift message to be
+    // uint32_t.
+    uint32_t length = static_cast<uint32_t>(columnIndexLocation->length);
+    auto descr = rowGroupMetadata_->schema()->column(i);
+    return ColumnIndex::make(
+        *descr, columnIndexBuffer_->data() + bufferoffset, length, properties_);
   }
 
   /// Read offset index of a column chunk.
-  std::shared_ptr<OffsetIndex> GetOffsetIndex(int32_t i) override {
-    if (i < 0 || i >= row_group_metadata_->num_columns()) {
+  std::shared_ptr<OffsetIndex> getOffsetIndex(int32_t i) override {
+    if (i < 0 || i >= rowGroupMetadata_->numColumns()) {
       throw ParquetException("Invalid offset index at column ordinal ", i);
     }
 
-    auto col_chunk = row_group_metadata_->ColumnChunk(i);
-    std::unique_ptr<ColumnCryptoMetaData> crypto_metadata =
-        col_chunk->crypto_metadata();
-    if (crypto_metadata != nullptr) {
+    auto colChunk = rowGroupMetadata_->columnChunk(i);
+    std::unique_ptr<ColumnCryptoMetaData> cryptoMetadata =
+        colChunk->cryptoMetadata();
+    if (cryptoMetadata != nullptr) {
       ParquetException::NYI("Cannot read encrypted offset index yet");
     }
 
-    auto offset_index_location = col_chunk->GetOffsetIndexLocation();
-    if (!offset_index_location.has_value()) {
+    auto offsetIndexLocation = colChunk->getOffsetIndexLocation();
+    if (!offsetIndexLocation.has_value()) {
       return nullptr;
     }
 
-    CheckReadRangeOrThrow(
-        *offset_index_location,
-        index_read_range_.offset_index,
-        row_group_ordinal_);
+    checkReadRangeOrThrow(
+        *offsetIndexLocation, indexReadRange_.offsetIndex, rowGroupOrdinal_);
 
-    if (offset_index_buffer_ == nullptr) {
+    if (offsetIndexBuffer_ == nullptr) {
       PARQUET_ASSIGN_OR_THROW(
-          offset_index_buffer_,
+          offsetIndexBuffer_,
           input_->ReadAt(
-              index_read_range_.offset_index->offset,
-              index_read_range_.offset_index->length));
+              indexReadRange_.offsetIndex->offset,
+              indexReadRange_.offsetIndex->length));
     }
 
-    int64_t buffer_offset =
-        offset_index_location->offset - index_read_range_.offset_index->offset;
-    // OffsetIndex::Make() requires the type of serialized thrift message to be
-    // uint32_t
-    uint32_t length = static_cast<uint32_t>(offset_index_location->length);
-    return OffsetIndex::Make(
-        offset_index_buffer_->data() + buffer_offset, length, properties_);
+    int64_t bufferoffset =
+        offsetIndexLocation->offset - indexReadRange_.offsetIndex->offset;
+    // OffsetIndex::make() requires the type of serialized Thrift message to be
+    // uint32_t.
+    uint32_t length = static_cast<uint32_t>(offsetIndexLocation->length);
+    return OffsetIndex::make(
+        offsetIndexBuffer_->data() + bufferoffset, length, properties_);
   }
 
  private:
-  static void CheckReadRangeOrThrow(
-      const IndexLocation& index_location,
-      const std::optional<::arrow::io::ReadRange>& index_read_range,
-      int32_t row_group_ordinal) {
-    if (!index_read_range.has_value()) {
+  static void checkReadRangeOrThrow(
+      const IndexLocation& indexLocation,
+      const std::optional<::arrow::io::ReadRange>& indexReadRange,
+      int32_t rowGroupOrdinal) {
+    if (!indexReadRange.has_value()) {
       throw ParquetException(
           "Missing page index read range of row group ",
-          row_group_ordinal,
+          rowGroupOrdinal,
           ", it may not exist or has not been requested");
     }
 
     /// The coalesced read range is invalid.
-    if (index_read_range->offset < 0 || index_read_range->length <= 0) {
+    if (indexReadRange->offset < 0 || indexReadRange->length <= 0) {
       throw ParquetException(
           "Invalid page index read range: offset ",
-          index_read_range->offset,
+          indexReadRange->offset,
           " length ",
-          index_read_range->length);
+          indexReadRange->length);
     }
 
     /// The location to page index itself is corrupted.
-    if (index_location.offset < 0 || index_location.length <= 0) {
+    if (indexLocation.offset < 0 || indexLocation.length <= 0) {
       throw ParquetException(
           "Invalid page index location: offset ",
-          index_location.offset,
+          indexLocation.offset,
           " length ",
-          index_location.length);
+          indexLocation.length);
     }
 
     /// Page index location must be within the range of the read range.
-    if (index_location.offset < index_read_range->offset ||
-        index_location.offset + index_location.length >
-            index_read_range->offset + index_read_range->length) {
+    if (indexLocation.offset < indexReadRange->offset ||
+        indexLocation.offset + indexLocation.length >
+            indexReadRange->offset + indexReadRange->length) {
       throw ParquetException(
           "Page index location [offset:",
-          index_location.offset,
+          indexLocation.offset,
           ",length:",
-          index_location.length,
+          indexLocation.length,
           "] is out of range from previous WillNeed request [offset:",
-          index_read_range->offset,
+          indexReadRange->offset,
           ",length:",
-          index_read_range->length,
+          indexReadRange->length,
           "], row group: ",
-          row_group_ordinal);
+          rowGroupOrdinal);
     }
   }
 
@@ -369,107 +360,107 @@ class RowGroupPageIndexReaderImpl : public RowGroupPageIndexReader {
   ::arrow::io::RandomAccessFile* input_;
 
   /// The row group metadata to get column chunk metadata.
-  std::shared_ptr<RowGroupMetaData> row_group_metadata_;
+  std::shared_ptr<RowGroupMetaData> rowGroupMetadata_;
 
   /// Reader properties used to deserialize thrift object.
   const ReaderProperties& properties_;
 
   /// The ordinal of the row group in the file.
-  int32_t row_group_ordinal_;
+  int32_t rowGroupOrdinal_;
 
   /// File offsets and sizes of the page Index of all column chunks in the row
   /// group.
-  RowGroupIndexReadRange index_read_range_;
+  RowGroupIndexReadRange indexReadRange_;
 
   /// File-level decryptor.
-  std::shared_ptr<InternalFileDecryptor> file_decryptor_;
+  std::shared_ptr<InternalFileDecryptor> fileDecryptor_;
 
   /// Buffer to hold the raw bytes of the page index.
   /// Will be set lazily when the corresponding page index is accessed for the
-  /// 1st time.
-  std::shared_ptr<::arrow::Buffer> column_index_buffer_;
-  std::shared_ptr<::arrow::Buffer> offset_index_buffer_;
+  /// first time.
+  std::shared_ptr<::arrow::Buffer> columnIndexBuffer_;
+  std::shared_ptr<::arrow::Buffer> offsetIndexBuffer_;
 };
 
 class PageIndexReaderImpl : public PageIndexReader {
  public:
   PageIndexReaderImpl(
       ::arrow::io::RandomAccessFile* input,
-      std::shared_ptr<FileMetaData> file_metadata,
+      std::shared_ptr<FileMetaData> fileMetadata,
       const ReaderProperties& properties,
-      std::shared_ptr<InternalFileDecryptor> file_decryptor)
+      std::shared_ptr<InternalFileDecryptor> fileDecryptor)
       : input_(input),
-        file_metadata_(std::move(file_metadata)),
+        fileMetadata_(std::move(fileMetadata)),
         properties_(properties),
-        file_decryptor_(std::move(file_decryptor)) {}
+        fileDecryptor_(std::move(fileDecryptor)) {}
 
-  std::shared_ptr<RowGroupPageIndexReader> RowGroup(int i) override {
-    if (i < 0 || i >= file_metadata_->num_row_groups()) {
+  std::shared_ptr<RowGroupPageIndexReader> rowGroup(int i) override {
+    if (i < 0 || i >= fileMetadata_->numRowGroups()) {
       throw ParquetException("Invalid row group ordinal: ", i);
     }
 
-    auto row_group_metadata = file_metadata_->RowGroup(i);
+    auto rowGroupMetadata = fileMetadata_->rowGroup(i);
 
     // Find the read range of the page index of the row group if provided by
-    // WillNeed()
-    RowGroupIndexReadRange index_read_range;
-    auto iter = index_read_ranges_.find(i);
-    if (iter != index_read_ranges_.cend()) {
+    // WillNeed().
+    RowGroupIndexReadRange indexReadRange;
+    auto iter = indexReadRanges_.find(i);
+    if (iter != indexReadRanges_.cend()) {
       /// This row group has been requested by WillNeed(). Only column index
       /// and/or offset index of requested columns can be read.
-      index_read_range = iter->second;
+      indexReadRange = iter->second;
     } else {
-      /// If the row group has not been requested by WillNeed(), by default both
-      /// column index and offset index of all column chunks for the row group
-      /// can be read.
-      index_read_range = PageIndexReader::DeterminePageIndexRangesInRowGroup(
-          *row_group_metadata, {});
+      /// If the row group has not been requested by WillNeed(), by default
+      /// both column index and offset index of all column chunks for the row
+      /// group can be read.
+      indexReadRange = PageIndexReader::determinePageIndexRangesInRowGroup(
+          *rowGroupMetadata, {});
     }
 
-    if (index_read_range.column_index.has_value() ||
-        index_read_range.offset_index.has_value()) {
+    if (indexReadRange.columnIndex.has_value() ||
+        indexReadRange.offsetIndex.has_value()) {
       return std::make_shared<RowGroupPageIndexReaderImpl>(
           input_,
-          std::move(row_group_metadata),
+          std::move(rowGroupMetadata),
           properties_,
           i,
-          index_read_range,
-          file_decryptor_);
+          indexReadRange,
+          fileDecryptor_);
     }
 
     /// The row group does not has page index or has not been requested by
-    /// WillNeed(). Simply returns nullptr.
+    /// willNeed(). Simply returns nullptr.
     return nullptr;
   }
 
-  void WillNeed(
-      const std::vector<int32_t>& row_group_indices,
-      const std::vector<int32_t>& column_indices,
+  void willNeed(
+      const std::vector<int32_t>& rowGroupIndices,
+      const std::vector<int32_t>& columnIndices,
       const PageIndexSelection& selection) override {
-    std::vector<::arrow::io::ReadRange> read_ranges;
-    for (int32_t row_group_ordinal : row_group_indices) {
-      auto read_range = PageIndexReader::DeterminePageIndexRangesInRowGroup(
-          *file_metadata_->RowGroup(row_group_ordinal), column_indices);
-      if (selection.column_index && read_range.column_index.has_value()) {
-        read_ranges.push_back(*read_range.column_index);
+    std::vector<::arrow::io::ReadRange> readRanges;
+    for (int32_t rowGroupOrdinal : rowGroupIndices) {
+      auto readRange = PageIndexReader::determinePageIndexRangesInRowGroup(
+          *fileMetadata_->rowGroup(rowGroupOrdinal), columnIndices);
+      if (selection.columnIndex && readRange.columnIndex.has_value()) {
+        readRanges.push_back(*readRange.columnIndex);
       } else {
         // Mark the column index as not requested.
-        read_range.column_index = std::nullopt;
+        readRange.columnIndex = std::nullopt;
       }
-      if (selection.offset_index && read_range.offset_index.has_value()) {
-        read_ranges.push_back(*read_range.offset_index);
+      if (selection.offsetIndex && readRange.offsetIndex.has_value()) {
+        readRanges.push_back(*readRange.offsetIndex);
       } else {
         // Mark the offset index as not requested.
-        read_range.offset_index = std::nullopt;
+        readRange.offsetIndex = std::nullopt;
       }
-      index_read_ranges_.emplace(row_group_ordinal, std::move(read_range));
+      indexReadRanges_.emplace(rowGroupOrdinal, std::move(readRange));
     }
-    PARQUET_THROW_NOT_OK(input_->WillNeed(read_ranges));
+    PARQUET_THROW_NOT_OK(input_->WillNeed(readRanges));
   }
 
-  void WillNotNeed(const std::vector<int32_t>& row_group_indices) override {
-    for (int32_t row_group_ordinal : row_group_indices) {
-      index_read_ranges_.erase(row_group_ordinal);
+  void willNotNeed(const std::vector<int32_t>& rowGroupIndices) override {
+    for (int32_t rowGroupOrdinal : rowGroupIndices) {
+      indexReadRanges_.erase(rowGroupOrdinal);
     }
   }
 
@@ -478,17 +469,17 @@ class PageIndexReaderImpl : public PageIndexReader {
   ::arrow::io::RandomAccessFile* input_;
 
   /// The file metadata to get row group metadata.
-  std::shared_ptr<FileMetaData> file_metadata_;
+  std::shared_ptr<FileMetaData> fileMetadata_;
 
   /// Reader properties used to deserialize thrift object.
   const ReaderProperties& properties_;
 
   /// File-level decrypter.
-  std::shared_ptr<InternalFileDecryptor> file_decryptor_;
+  std::shared_ptr<InternalFileDecryptor> fileDecryptor_;
 
-  /// Coalesced read ranges of page index of row groups that have been suggested
-  /// by WillNeed(). Key is the row group ordinal.
-  std::unordered_map<int32_t, RowGroupIndexReadRange> index_read_ranges_;
+  /// Coalesced read ranges of page index of row groups that have been
+  /// suggested by WillNeed(). Key is the row group ordinal.
+  std::unordered_map<int32_t, RowGroupIndexReadRange> indexReadRanges_;
 };
 
 /// \brief Internal state of page index builder.
@@ -506,38 +497,38 @@ enum class BuilderState {
 template <typename DType>
 class ColumnIndexBuilderImpl final : public ColumnIndexBuilder {
  public:
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
 
   explicit ColumnIndexBuilderImpl(const ColumnDescriptor* descr)
       : descr_(descr) {
-    /// Initialize the null_counts vector as set. Invalid null_counts vector
-    /// from any page will invalidate the null_counts vector of the column
+    /// Initialize the nullCounts vector as set. Invalid nullCounts vector
+    /// from any page will invalidate the nullCounts vector of the column
     /// index.
-    column_index_.__isset.null_counts = true;
-    column_index_.boundary_order =
+    columnIndex_.__isset.null_counts = true;
+    columnIndex_.boundary_order =
         facebook::velox::parquet::thrift::BoundaryOrder::UNORDERED;
   }
 
-  void AddPage(const EncodedStatistics& stats) override {
+  void addPage(const EncodedStatistics& stats) override {
     if (state_ == BuilderState::kFinished) {
       throw ParquetException("Cannot add page to finished ColumnIndexBuilder.");
     } else if (state_ == BuilderState::kDiscarded) {
-      /// The offset index is discarded. Do nothing.
+      /// The column index is discarded. Do nothing.
       return;
     }
 
     state_ = BuilderState::kStarted;
 
-    if (stats.all_null_value) {
-      column_index_.null_pages.emplace_back(true);
-      column_index_.min_values.emplace_back("");
-      column_index_.max_values.emplace_back("");
-    } else if (stats.has_min && stats.has_max) {
-      const size_t page_ordinal = column_index_.null_pages.size();
-      non_null_page_indices_.emplace_back(page_ordinal);
-      column_index_.min_values.emplace_back(stats.min());
-      column_index_.max_values.emplace_back(stats.max());
-      column_index_.null_pages.emplace_back(false);
+    if (stats.allNullValue) {
+      columnIndex_.null_pages.emplace_back(true);
+      columnIndex_.min_values.emplace_back("");
+      columnIndex_.max_values.emplace_back("");
+    } else if (stats.hasMin && stats.hasMax) {
+      const size_t pageOrdinal = columnIndex_.null_pages.size();
+      nonNullPageIndices_.emplace_back(pageOrdinal);
+      columnIndex_.min_values.emplace_back(stats.min());
+      columnIndex_.max_values.emplace_back(stats.max());
+      columnIndex_.null_pages.emplace_back(false);
     } else {
       /// This is a non-null page but it lacks of meaningful min/max values.
       /// Discard the column index.
@@ -545,15 +536,15 @@ class ColumnIndexBuilderImpl final : public ColumnIndexBuilder {
       return;
     }
 
-    if (column_index_.__isset.null_counts && stats.has_null_count) {
-      column_index_.null_counts.emplace_back(stats.null_count);
+    if (columnIndex_.__isset.null_counts && stats.hasNullCount) {
+      columnIndex_.null_counts.emplace_back(stats.nullCount);
     } else {
-      column_index_.__isset.null_counts = false;
-      column_index_.null_counts.clear();
+      columnIndex_.__isset.null_counts = false;
+      columnIndex_.null_counts.clear();
     }
   }
 
-  void Finish() override {
+  void finish() override {
     switch (state_) {
       case BuilderState::kCreated: {
         /// No page is added. Discard the column index.
@@ -572,93 +563,93 @@ class ColumnIndexBuilderImpl final : public ColumnIndexBuilder {
     state_ = BuilderState::kFinished;
 
     /// Clear null_counts vector because at least one page does not provide it.
-    if (!column_index_.__isset.null_counts) {
-      column_index_.null_counts.clear();
+    if (!columnIndex_.__isset.null_counts) {
+      columnIndex_.null_counts.clear();
     }
 
     /// Decode min/max values according to the data type.
-    const size_t non_null_page_count = non_null_page_indices_.size();
-    std::vector<T> min_values, max_values;
-    min_values.resize(non_null_page_count);
-    max_values.resize(non_null_page_count);
-    auto decoder = MakeTypedDecoder<DType>(Encoding::PLAIN, descr_);
-    for (size_t i = 0; i < non_null_page_count; ++i) {
-      auto page_ordinal = non_null_page_indices_.at(i);
-      Decode<DType>(
-          decoder, column_index_.min_values.at(page_ordinal), &min_values, i);
-      Decode<DType>(
-          decoder, column_index_.max_values.at(page_ordinal), &max_values, i);
+    const size_t nonNullPageCount = nonNullPageIndices_.size();
+    std::vector<T> minValues, maxValues;
+    minValues.resize(nonNullPageCount);
+    maxValues.resize(nonNullPageCount);
+    auto decoder = makeTypedDecoder<DType>(Encoding::kPlain, descr_);
+    for (size_t i = 0; i < nonNullPageCount; ++i) {
+      auto pageOrdinal = nonNullPageIndices_.at(i);
+      decode<DType>(
+          decoder, columnIndex_.min_values.at(pageOrdinal), &minValues, i);
+      decode<DType>(
+          decoder, columnIndex_.max_values.at(pageOrdinal), &maxValues, i);
     }
 
     /// Decide the boundary order from decoded min/max values.
-    auto boundary_order = DetermineBoundaryOrder(min_values, max_values);
-    column_index_.__set_boundary_order(ToThrift(boundary_order));
+    auto boundaryOrder = determineBoundaryOrder(minValues, maxValues);
+    columnIndex_.__set_boundary_order(toThrift(boundaryOrder));
   }
 
-  void WriteTo(::arrow::io::OutputStream* sink) const override {
+  void writeTo(::arrow::io::OutputStream* sink) const override {
     if (state_ == BuilderState::kFinished) {
-      ThriftSerializer{}.Serialize(&column_index_, sink);
+      ThriftSerializer{}.serialize(&columnIndex_, sink);
     }
   }
 
-  std::unique_ptr<ColumnIndex> Build() const override {
+  std::unique_ptr<ColumnIndex> build() const override {
     if (state_ == BuilderState::kFinished) {
       return std::make_unique<TypedColumnIndexImpl<DType>>(
-          *descr_, column_index_);
+          *descr_, columnIndex_);
     }
     return nullptr;
   }
 
  private:
-  BoundaryOrder::type DetermineBoundaryOrder(
-      const std::vector<T>& min_values,
-      const std::vector<T>& max_values) const {
-    VELOX_DCHECK_EQ(min_values.size(), max_values.size());
-    if (min_values.empty()) {
-      return BoundaryOrder::Unordered;
+  BoundaryOrder::type determineBoundaryOrder(
+      const std::vector<T>& minValues,
+      const std::vector<T>& maxValues) const {
+    VELOX_DCHECK_EQ(minValues.size(), maxValues.size());
+    if (minValues.empty()) {
+      return BoundaryOrder::kUnordered;
     }
 
     std::shared_ptr<TypedComparator<DType>> comparator;
     try {
-      comparator = MakeComparator<DType>(descr_);
+      comparator = makeComparator<DType>(descr_);
     } catch (const ParquetException&) {
       /// Simply return unordered for unsupported comparator.
-      return BoundaryOrder::Unordered;
+      return BoundaryOrder::kUnordered;
     }
 
-    /// Check if both min_values and max_values are in ascending order.
-    bool is_ascending = true;
-    for (size_t i = 1; i < min_values.size(); ++i) {
-      if (comparator->Compare(min_values[i], min_values[i - 1]) ||
-          comparator->Compare(max_values[i], max_values[i - 1])) {
-        is_ascending = false;
+    /// Check if both minValues and maxValues are in ascending order.
+    bool isAscending = true;
+    for (size_t i = 1; i < minValues.size(); ++i) {
+      if (comparator->compare(minValues[i], minValues[i - 1]) ||
+          comparator->compare(maxValues[i], maxValues[i - 1])) {
+        isAscending = false;
         break;
       }
     }
-    if (is_ascending) {
-      return BoundaryOrder::Ascending;
+    if (isAscending) {
+      return BoundaryOrder::kAscending;
     }
 
-    /// Check if both min_values and max_values are in descending order.
-    bool is_descending = true;
-    for (size_t i = 1; i < min_values.size(); ++i) {
-      if (comparator->Compare(min_values[i - 1], min_values[i]) ||
-          comparator->Compare(max_values[i - 1], max_values[i])) {
-        is_descending = false;
+    /// Check if both minValues and maxValues are in descending order.
+    bool isDescending = true;
+    for (size_t i = 1; i < minValues.size(); ++i) {
+      if (comparator->compare(minValues[i - 1], minValues[i]) ||
+          comparator->compare(maxValues[i - 1], maxValues[i])) {
+        isDescending = false;
         break;
       }
     }
-    if (is_descending) {
-      return BoundaryOrder::Descending;
+    if (isDescending) {
+      return BoundaryOrder::kDescending;
     }
 
     /// Neither ascending nor descending is detected.
-    return BoundaryOrder::Unordered;
+    return BoundaryOrder::kUnordered;
   }
 
   const ColumnDescriptor* descr_;
-  facebook::velox::parquet::thrift::ColumnIndex column_index_;
-  std::vector<size_t> non_null_page_indices_;
+  facebook::velox::parquet::thrift::ColumnIndex columnIndex_;
+  std::vector<size_t> nonNullPageIndices_;
   BuilderState state_ = BuilderState::kCreated;
 };
 
@@ -666,10 +657,10 @@ class OffsetIndexBuilderImpl final : public OffsetIndexBuilder {
  public:
   OffsetIndexBuilderImpl() = default;
 
-  void AddPage(
+  void addPage(
       int64_t offset,
-      int32_t compressed_page_size,
-      int64_t first_row_index) override {
+      int32_t compressedPageSize,
+      int64_t firstRowIndex) override {
     if (state_ == BuilderState::kFinished) {
       throw ParquetException("Cannot add page to finished OffsetIndexBuilder.");
     } else if (state_ == BuilderState::kDiscarded) {
@@ -679,14 +670,14 @@ class OffsetIndexBuilderImpl final : public OffsetIndexBuilder {
 
     state_ = BuilderState::kStarted;
 
-    facebook::velox::parquet::thrift::PageLocation page_location;
-    page_location.__set_offset(offset);
-    page_location.__set_compressed_page_size(compressed_page_size);
-    page_location.__set_first_row_index(first_row_index);
-    offset_index_.page_locations.emplace_back(std::move(page_location));
+    facebook::velox::parquet::thrift::PageLocation pageLocation;
+    pageLocation.__set_offset(offset);
+    pageLocation.__set_compressed_page_size(compressedPageSize);
+    pageLocation.__set_first_row_index(firstRowIndex);
+    offsetIndex_.page_locations.emplace_back(std::move(pageLocation));
   }
 
-  void Finish(int64_t final_position) override {
+  void finish(int64_t finalPosition) override {
     switch (state_) {
       case BuilderState::kCreated: {
         /// No pages are added. Simply discard the offset index.
@@ -694,10 +685,10 @@ class OffsetIndexBuilderImpl final : public OffsetIndexBuilder {
         break;
       }
       case BuilderState::kStarted: {
-        /// Adjust page offsets according the final position.
-        if (final_position > 0) {
-          for (auto& page_location : offset_index_.page_locations) {
-            page_location.__set_offset(page_location.offset + final_position);
+        /// Adjust page offsets according to the final position.
+        if (finalPosition > 0) {
+          for (auto& pageLocation : offsetIndex_.page_locations) {
+            pageLocation.__set_offset(pageLocation.offset + finalPosition);
           }
         }
         state_ = BuilderState::kFinished;
@@ -709,21 +700,21 @@ class OffsetIndexBuilderImpl final : public OffsetIndexBuilder {
     }
   }
 
-  void WriteTo(::arrow::io::OutputStream* sink) const override {
+  void writeTo(::arrow::io::OutputStream* sink) const override {
     if (state_ == BuilderState::kFinished) {
-      ThriftSerializer{}.Serialize(&offset_index_, sink);
+      ThriftSerializer{}.serialize(&offsetIndex_, sink);
     }
   }
 
-  std::unique_ptr<OffsetIndex> Build() const override {
+  std::unique_ptr<OffsetIndex> build() const override {
     if (state_ == BuilderState::kFinished) {
-      return std::make_unique<OffsetIndexImpl>(offset_index_);
+      return std::make_unique<OffsetIndexImpl>(offsetIndex_);
     }
     return nullptr;
   }
 
  private:
-  facebook::velox::parquet::thrift::OffsetIndex offset_index_;
+  facebook::velox::parquet::thrift::OffsetIndex offsetIndex_;
   BuilderState state_ = BuilderState::kCreated;
 };
 
@@ -732,118 +723,112 @@ class PageIndexBuilderImpl final : public PageIndexBuilder {
   explicit PageIndexBuilderImpl(const SchemaDescriptor* schema)
       : schema_(schema) {}
 
-  void AppendRowGroup() override {
+  void appendRowGroup() override {
     if (finished_) {
       throw ParquetException(
-          "Cannot call AppendRowGroup() to finished PageIndexBuilder.");
+          "Cannot call appendRowGroup() to finished PageIndexBuilder.");
     }
 
     // Append new builders of next row group.
-    const auto num_columns = static_cast<size_t>(schema_->num_columns());
-    column_index_builders_.emplace_back();
-    offset_index_builders_.emplace_back();
-    column_index_builders_.back().resize(num_columns);
-    offset_index_builders_.back().resize(num_columns);
-
-    VELOX_DCHECK_EQ(
-        column_index_builders_.size(), offset_index_builders_.size());
-    VELOX_DCHECK_EQ(column_index_builders_.back().size(), num_columns);
-    VELOX_DCHECK_EQ(offset_index_builders_.back().size(), num_columns);
+    const auto numColumns = static_cast<size_t>(schema_->numColumns());
+    columnIndexBuilders_.emplace_back();
+    offsetIndexBuilders_.emplace_back();
+    columnIndexBuilders_.back().resize(numColumns);
+    offsetIndexBuilders_.back().resize(numColumns);
+
+    VELOX_DCHECK_EQ(columnIndexBuilders_.size(), offsetIndexBuilders_.size());
+    VELOX_DCHECK_EQ(columnIndexBuilders_.back().size(), numColumns);
+    VELOX_DCHECK_EQ(offsetIndexBuilders_.back().size(), numColumns);
   }
 
-  ColumnIndexBuilder* GetColumnIndexBuilder(int32_t i) override {
-    CheckState(i);
+  ColumnIndexBuilder* getColumnIndexBuilder(int32_t i) override {
+    checkState(i);
     std::unique_ptr<ColumnIndexBuilder>& builder =
-        column_index_builders_.back()[i];
+        columnIndexBuilders_.back()[i];
     if (builder == nullptr) {
-      builder = ColumnIndexBuilder::Make(schema_->Column(i));
+      builder = ColumnIndexBuilder::make(schema_->column(i));
     }
     return builder.get();
   }
 
-  OffsetIndexBuilder* GetOffsetIndexBuilder(int32_t i) override {
-    CheckState(i);
+  OffsetIndexBuilder* getOffsetIndexBuilder(int32_t i) override {
+    checkState(i);
     std::unique_ptr<OffsetIndexBuilder>& builder =
-        offset_index_builders_.back()[i];
+        offsetIndexBuilders_.back()[i];
     if (builder == nullptr) {
-      builder = OffsetIndexBuilder::Make();
+      builder = OffsetIndexBuilder::make();
     }
     return builder.get();
   }
 
-  void Finish() override {
+  void finish() override {
     finished_ = true;
   }
 
-  void WriteTo(::arrow::io::OutputStream* sink, PageIndexLocation* location)
+  void writeTo(::arrow::io::OutputStream* sink, PageIndexLocation* location)
       const override {
     if (!finished_) {
       throw ParquetException(
-          "Cannot call WriteTo() to unfinished PageIndexBuilder.");
+          "Cannot call writeTo() to unfinished PageIndexBuilder.");
     }
 
-    location->column_index_location.clear();
-    location->offset_index_location.clear();
+    location->columnIndexLocation.clear();
+    location->offsetIndexLocation.clear();
 
     /// Serialize column index ordered by row group ordinal and then column
     /// ordinal.
-    SerializeIndex(
-        column_index_builders_, sink, &location->column_index_location);
+    serializeIndex(columnIndexBuilders_, sink, &location->columnIndexLocation);
 
     /// Serialize offset index ordered by row group ordinal and then column
     /// ordinal.
-    SerializeIndex(
-        offset_index_builders_, sink, &location->offset_index_location);
+    serializeIndex(offsetIndexBuilders_, sink, &location->offsetIndexLocation);
   }
 
  private:
-  /// Make sure column ordinal is not out of bound and the builder is in good
+  /// Make sure column ordinal is not out of bounds and the builder is in good
   /// state.
-  void CheckState(int32_t column_ordinal) const {
+  void checkState(int32_t columnOrdinal) const {
     if (finished_) {
       throw ParquetException("PageIndexBuilder is already finished.");
     }
-    if (column_ordinal < 0 || column_ordinal >= schema_->num_columns()) {
-      throw ParquetException("Invalid column ordinal: ", column_ordinal);
+    if (columnOrdinal < 0 || columnOrdinal >= schema_->numColumns()) {
+      throw ParquetException("Invalid column ordinal: ", columnOrdinal);
     }
-    if (offset_index_builders_.empty() || column_index_builders_.empty()) {
+    if (offsetIndexBuilders_.empty() || columnIndexBuilders_.empty()) {
       throw ParquetException("No row group appended to PageIndexBuilder.");
     }
   }
 
   template <typename Builder>
-  void SerializeIndex(
+  void serializeIndex(
       const std::vector<std::vector<std::unique_ptr<Builder>>>&
-          page_index_builders,
+          pageIndexBuilders,
       ::arrow::io::OutputStream* sink,
       std::map<size_t, std::vector<std::optional<IndexLocation>>>* location)
       const {
-    const auto num_columns = static_cast<size_t>(schema_->num_columns());
+    const auto numColumns = static_cast<size_t>(schema_->numColumns());
 
     /// Serialize the same kind of page index row group by row group.
-    for (size_t row_group = 0; row_group < page_index_builders.size();
-         ++row_group) {
-      const auto& row_group_page_index_builders =
-          page_index_builders[row_group];
-      VELOX_DCHECK_EQ(row_group_page_index_builders.size(), num_columns);
+    for (size_t rowGroup = 0; rowGroup < pageIndexBuilders.size(); ++rowGroup) {
+      const auto& rowGroupPageIndexBuilders = pageIndexBuilders[rowGroup];
+      VELOX_DCHECK_EQ(rowGroupPageIndexBuilders.size(), numColumns);
 
-      bool has_valid_index = false;
+      bool hasValidIndex = false;
       std::vector<std::optional<IndexLocation>> locations(
-          num_columns, std::nullopt);
-
-      /// In the same row group, serialize the same kind of page index column by
-      /// column.
-      for (size_t column = 0; column < num_columns; ++column) {
-        const auto& column_page_index_builder =
-            row_group_page_index_builders[column];
-        if (column_page_index_builder != nullptr) {
+          numColumns, std::nullopt);
+
+      /// In the same row group, serialize the same kind of page index column
+      /// by column.
+      for (size_t column = 0; column < numColumns; ++column) {
+        const auto& columnPageIndexBuilder = rowGroupPageIndexBuilders[column];
+        if (columnPageIndexBuilder != nullptr) {
           /// Try serializing the page index.
-          PARQUET_ASSIGN_OR_THROW(int64_t pos_before_write, sink->Tell());
-          column_page_index_builder->WriteTo(sink);
-          PARQUET_ASSIGN_OR_THROW(int64_t pos_after_write, sink->Tell());
-          int64_t len = pos_after_write - pos_before_write;
+          PARQUET_ASSIGN_OR_THROW(int64_t posBeforeWrite, sink->Tell());
+          columnPageIndexBuilder->writeTo(sink);
+          PARQUET_ASSIGN_OR_THROW(int64_t posAfterWrite, sink->Tell());
+          int64_t len = posAfterWrite - posBeforeWrite;
 
-          /// The page index is not serialized and skip reporting its location
+          /// The page index is not serialized and skip reporting its location.
           if (len == 0) {
             continue;
           }
@@ -851,180 +836,180 @@ class PageIndexBuilderImpl final : public PageIndexBuilder {
           if (len > std::numeric_limits<int32_t>::max()) {
             throw ParquetException("Page index size overflows to INT32_MAX");
           }
-          locations[column] = {pos_before_write, static_cast<int32_t>(len)};
-          has_valid_index = true;
+          locations[column] = {posBeforeWrite, static_cast<int32_t>(len)};
+          hasValidIndex = true;
         }
       }
 
-      if (has_valid_index) {
-        location->emplace(row_group, std::move(locations));
+      if (hasValidIndex) {
+        location->emplace(rowGroup, std::move(locations));
       }
     }
   }
 
   const SchemaDescriptor* schema_;
   std::vector<std::vector<std::unique_ptr<ColumnIndexBuilder>>>
-      column_index_builders_;
+      columnIndexBuilders_;
   std::vector<std::vector<std::unique_ptr<OffsetIndexBuilder>>>
-      offset_index_builders_;
+      offsetIndexBuilders_;
   bool finished_ = false;
 };
 
 } // namespace
 
-RowGroupIndexReadRange PageIndexReader::DeterminePageIndexRangesInRowGroup(
-    const RowGroupMetaData& row_group_metadata,
+RowGroupIndexReadRange PageIndexReader::determinePageIndexRangesInRowGroup(
+    const RowGroupMetaData& rowGroupMetadata,
     const std::vector<int32_t>& columns) {
-  int64_t ci_start = std::numeric_limits<int64_t>::max();
-  int64_t oi_start = std::numeric_limits<int64_t>::max();
-  int64_t ci_end = -1;
-  int64_t oi_end = -1;
-
-  auto merge_range = [](const std::optional<IndexLocation>& index_location,
-                        int64_t* start,
-                        int64_t* end) {
-    if (index_location.has_value()) {
-      int64_t index_end = 0;
-      if (index_location->offset < 0 || index_location->length <= 0 ||
-          ::arrow::internal::AddWithOverflow(
-              index_location->offset, index_location->length, &index_end)) {
+  int64_t ciStart = std::numeric_limits<int64_t>::max();
+  int64_t oiStart = std::numeric_limits<int64_t>::max();
+  int64_t ciEnd = -1;
+  int64_t oiEnd = -1;
+
+  auto mergeRange = [](const std::optional<IndexLocation>& indexLocation,
+                       int64_t* start,
+                       int64_t* end) {
+    if (indexLocation.has_value()) {
+      int64_t indexEnd = 0;
+      if (indexLocation->offset < 0 || indexLocation->length <= 0 ||
+          ::arrow::internal::addWithOverflow(
+              indexLocation->offset, indexLocation->length, &indexEnd)) {
         throw ParquetException(
             "Invalid page index location: offset ",
-            index_location->offset,
+            indexLocation->offset,
             " length ",
-            index_location->length);
+            indexLocation->length);
       }
-      *start = std::min(*start, index_location->offset);
-      *end = std::max(*end, index_end);
+      *start = std::min(*start, indexLocation->offset);
+      *end = std::max(*end, indexEnd);
     }
   };
 
   if (columns.empty()) {
-    for (int32_t i = 0; i < row_group_metadata.num_columns(); ++i) {
-      auto col_chunk = row_group_metadata.ColumnChunk(i);
-      merge_range(col_chunk->GetColumnIndexLocation(), &ci_start, &ci_end);
-      merge_range(col_chunk->GetOffsetIndexLocation(), &oi_start, &oi_end);
+    for (int32_t i = 0; i < rowGroupMetadata.numColumns(); ++i) {
+      auto colChunk = rowGroupMetadata.columnChunk(i);
+      mergeRange(colChunk->getColumnIndexLocation(), &ciStart, &ciEnd);
+      mergeRange(colChunk->getOffsetIndexLocation(), &oiStart, &oiEnd);
     }
   } else {
     for (int32_t i : columns) {
-      if (i < 0 || i >= row_group_metadata.num_columns()) {
+      if (i < 0 || i >= rowGroupMetadata.numColumns()) {
         throw ParquetException("Invalid column ordinal ", i);
       }
-      auto col_chunk = row_group_metadata.ColumnChunk(i);
-      merge_range(col_chunk->GetColumnIndexLocation(), &ci_start, &ci_end);
-      merge_range(col_chunk->GetOffsetIndexLocation(), &oi_start, &oi_end);
+      auto colChunk = rowGroupMetadata.columnChunk(i);
+      mergeRange(colChunk->getColumnIndexLocation(), &ciStart, &ciEnd);
+      mergeRange(colChunk->getOffsetIndexLocation(), &oiStart, &oiEnd);
     }
   }
 
-  RowGroupIndexReadRange read_range;
-  if (ci_end != -1) {
-    read_range.column_index = {ci_start, ci_end - ci_start};
+  RowGroupIndexReadRange readRange;
+  if (ciEnd != -1) {
+    readRange.columnIndex = {ciStart, ciEnd - ciStart};
   }
-  if (oi_end != -1) {
-    read_range.offset_index = {oi_start, oi_end - oi_start};
+  if (oiEnd != -1) {
+    readRange.offsetIndex = {oiStart, oiEnd - oiStart};
   }
-  return read_range;
+  return readRange;
 }
 
 // ----------------------------------------------------------------------
-// Public factory functions
+// Public factory functions.
 
-std::unique_ptr<ColumnIndex> ColumnIndex::Make(
+std::unique_ptr<ColumnIndex> ColumnIndex::make(
     const ColumnDescriptor& descr,
-    const void* serialized_index,
-    uint32_t index_len,
+    const void* serializedIndex,
+    uint32_t indexLen,
     const ReaderProperties& properties) {
-  facebook::velox::parquet::thrift::ColumnIndex column_index;
+  facebook::velox::parquet::thrift::ColumnIndex columnIndex;
   ThriftDeserializer deserializer(properties);
-  deserializer.DeserializeMessage(
-      reinterpret_cast<const uint8_t*>(serialized_index),
-      &index_len,
-      &column_index);
-  switch (descr.physical_type()) {
-    case Type::BOOLEAN:
+  deserializer.deserializeMessage(
+      reinterpret_cast<const uint8_t*>(serializedIndex),
+      &indexLen,
+      &columnIndex);
+  switch (descr.physicalType()) {
+    case Type::kBoolean:
       return std::make_unique<TypedColumnIndexImpl<BooleanType>>(
-          descr, std::move(column_index));
-    case Type::INT32:
+          descr, std::move(columnIndex));
+    case Type::kInt32:
       return std::make_unique<TypedColumnIndexImpl<Int32Type>>(
-          descr, std::move(column_index));
-    case Type::INT64:
+          descr, std::move(columnIndex));
+    case Type::kInt64:
       return std::make_unique<TypedColumnIndexImpl<Int64Type>>(
-          descr, std::move(column_index));
-    case Type::INT96:
+          descr, std::move(columnIndex));
+    case Type::kInt96:
       return std::make_unique<TypedColumnIndexImpl<Int96Type>>(
-          descr, std::move(column_index));
-    case Type::FLOAT:
+          descr, std::move(columnIndex));
+    case Type::kFloat:
       return std::make_unique<TypedColumnIndexImpl<FloatType>>(
-          descr, std::move(column_index));
-    case Type::DOUBLE:
+          descr, std::move(columnIndex));
+    case Type::kDouble:
       return std::make_unique<TypedColumnIndexImpl<DoubleType>>(
-          descr, std::move(column_index));
-    case Type::BYTE_ARRAY:
+          descr, std::move(columnIndex));
+    case Type::kByteArray:
       return std::make_unique<TypedColumnIndexImpl<ByteArrayType>>(
-          descr, std::move(column_index));
-    case Type::FIXED_LEN_BYTE_ARRAY:
+          descr, std::move(columnIndex));
+    case Type::kFixedLenByteArray:
       return std::make_unique<TypedColumnIndexImpl<FLBAType>>(
-          descr, std::move(column_index));
-    case Type::UNDEFINED:
+          descr, std::move(columnIndex));
+    case Type::kUndefined:
       return nullptr;
   }
   ::arrow::Unreachable("Cannot make ColumnIndex of an unknown type");
   return nullptr;
 }
 
-std::unique_ptr<OffsetIndex> OffsetIndex::Make(
-    const void* serialized_index,
-    uint32_t index_len,
+std::unique_ptr<OffsetIndex> OffsetIndex::make(
+    const void* serializedIndex,
+    uint32_t indexLen,
     const ReaderProperties& properties) {
-  facebook::velox::parquet::thrift::OffsetIndex offset_index;
+  facebook::velox::parquet::thrift::OffsetIndex offsetIndex;
   ThriftDeserializer deserializer(properties);
-  deserializer.DeserializeMessage(
-      reinterpret_cast<const uint8_t*>(serialized_index),
-      &index_len,
-      &offset_index);
-  return std::make_unique<OffsetIndexImpl>(offset_index);
+  deserializer.deserializeMessage(
+      reinterpret_cast<const uint8_t*>(serializedIndex),
+      &indexLen,
+      &offsetIndex);
+  return std::make_unique<OffsetIndexImpl>(offsetIndex);
 }
 
-std::shared_ptr<PageIndexReader> PageIndexReader::Make(
+std::shared_ptr<PageIndexReader> PageIndexReader::make(
     ::arrow::io::RandomAccessFile* input,
-    std::shared_ptr<FileMetaData> file_metadata,
+    std::shared_ptr<FileMetaData> fileMetadata,
     const ReaderProperties& properties,
-    std::shared_ptr<InternalFileDecryptor> file_decryptor) {
+    std::shared_ptr<InternalFileDecryptor> fileDecryptor) {
   return std::make_shared<PageIndexReaderImpl>(
-      input, std::move(file_metadata), properties, std::move(file_decryptor));
+      input, std::move(fileMetadata), properties, std::move(fileDecryptor));
 }
 
-std::unique_ptr<ColumnIndexBuilder> ColumnIndexBuilder::Make(
+std::unique_ptr<ColumnIndexBuilder> ColumnIndexBuilder::make(
     const ColumnDescriptor* descr) {
-  switch (descr->physical_type()) {
-    case Type::BOOLEAN:
+  switch (descr->physicalType()) {
+    case Type::kBoolean:
       return std::make_unique<ColumnIndexBuilderImpl<BooleanType>>(descr);
-    case Type::INT32:
+    case Type::kInt32:
       return std::make_unique<ColumnIndexBuilderImpl<Int32Type>>(descr);
-    case Type::INT64:
+    case Type::kInt64:
       return std::make_unique<ColumnIndexBuilderImpl<Int64Type>>(descr);
-    case Type::INT96:
+    case Type::kInt96:
       return std::make_unique<ColumnIndexBuilderImpl<Int96Type>>(descr);
-    case Type::FLOAT:
+    case Type::kFloat:
       return std::make_unique<ColumnIndexBuilderImpl<FloatType>>(descr);
-    case Type::DOUBLE:
+    case Type::kDouble:
       return std::make_unique<ColumnIndexBuilderImpl<DoubleType>>(descr);
-    case Type::BYTE_ARRAY:
+    case Type::kByteArray:
       return std::make_unique<ColumnIndexBuilderImpl<ByteArrayType>>(descr);
-    case Type::FIXED_LEN_BYTE_ARRAY:
+    case Type::kFixedLenByteArray:
       return std::make_unique<ColumnIndexBuilderImpl<FLBAType>>(descr);
-    case Type::UNDEFINED:
+    case Type::kUndefined:
       return nullptr;
   }
   ::arrow::Unreachable("Cannot make ColumnIndexBuilder of an unknown type");
   return nullptr;
 }
 
-std::unique_ptr<OffsetIndexBuilder> OffsetIndexBuilder::Make() {
+std::unique_ptr<OffsetIndexBuilder> OffsetIndexBuilder::make() {
   return std::make_unique<OffsetIndexBuilderImpl>();
 }
 
-std::unique_ptr<PageIndexBuilder> PageIndexBuilder::Make(
+std::unique_ptr<PageIndexBuilder> PageIndexBuilder::make(
     const SchemaDescriptor* schema) {
   return std::make_unique<PageIndexBuilderImpl>(schema);
 }
@@ -1032,8 +1017,8 @@ std::unique_ptr<PageIndexBuilder> PageIndexBuilder::Make(
 std::ostream& operator<<(
     std::ostream& out,
     const PageIndexSelection& selection) {
-  out << "PageIndexSelection{column_index = " << selection.column_index
-      << ", offset_index = " << selection.offset_index << "}";
+  out << "PageIndexSelection{column_index = " << selection.columnIndex
+      << ", offset_index = " << selection.offsetIndex << "}";
   return out;
 }
 
diff --git a/velox/dwio/parquet/writer/arrow/PageIndex.h b/velox/dwio/parquet/writer/arrow/PageIndex.h
index a246b34da9a..b0833075e51 100644
--- a/velox/dwio/parquet/writer/arrow/PageIndex.h
+++ b/velox/dwio/parquet/writer/arrow/PageIndex.h
@@ -41,72 +41,71 @@ class SchemaDescriptor;
 class PARQUET_EXPORT ColumnIndex {
  public:
   /// \brief Create a ColumnIndex from a serialized thrift message.
-  static std::unique_ptr<ColumnIndex> Make(
+  static std::unique_ptr<ColumnIndex> make(
       const ColumnDescriptor& descr,
-      const void* serialized_index,
-      uint32_t index_len,
+      const void* serializedIndex,
+      uint32_t indexLen,
       const ReaderProperties& properties);
 
   virtual ~ColumnIndex() = default;
 
-  /// \brief A bitmap with a bit set for each data page that has only null
-  /// values.
+  /// Values.
   ///
   /// The length of this vector is equal to the number of data pages in the
   /// column.
-  virtual const std::vector<bool>& null_pages() const = 0;
+  virtual const std::vector<bool>& nullPages() const = 0;
 
   /// \brief A vector of encoded lower bounds for each data page in this column.
   ///
-  /// `null_pages` should be inspected first, as only pages with non-null values
-  /// may have their lower bounds populated.
-  virtual const std::vector<std::string>& encoded_min_values() const = 0;
+  /// `nullPages` should be inspected first, as only pages with non-null
+  /// values may have their lower bounds populated.
+  virtual const std::vector<std::string>& encodedMinValues() const = 0;
 
   /// \brief A vector of encoded upper bounds for each data page in this column.
   ///
-  /// `null_pages` should be inspected first, as only pages with non-null values
-  /// may have their upper bounds populated.
-  virtual const std::vector<std::string>& encoded_max_values() const = 0;
+  /// `nullPages` should be inspected first, as only pages with non-null
+  /// values may have their upper bounds populated.
+  virtual const std::vector<std::string>& encodedMaxValues() const = 0;
 
   /// \brief The ordering of lower and upper bounds.
   ///
   /// The boundary order applies across all lower bounds, and all upper bounds,
   /// respectively. However, the order between lower bounds and upper bounds
   /// cannot be derived from this.
-  virtual BoundaryOrder::type boundary_order() const = 0;
+  virtual BoundaryOrder::type boundaryOrder() const = 0;
 
   /// \brief Whether per-page null count information is available.
-  virtual bool has_null_counts() const = 0;
+  virtual bool hasNullCounts() const = 0;
 
   /// \brief An optional vector with the number of null values in each data
   /// page.
   ///
-  /// `has_null_counts` should be called first to determine if this information
+  /// `hasNullCounts` should be called first to determine if this information
   /// is available.
-  virtual const std::vector<int64_t>& null_counts() const = 0;
+  virtual const std::vector<int64_t>& nullCounts() const = 0;
 
   /// \brief A vector of page indices for non-null pages.
-  virtual const std::vector<int32_t>& non_null_page_indices() const = 0;
+  virtual const std::vector<int32_t>& nonNullPageIndices() const = 0;
 };
 
 /// \brief Typed implementation of ColumnIndex.
 template <typename DType>
 class PARQUET_EXPORT TypedColumnIndex : public ColumnIndex {
  public:
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
 
   /// \brief A vector of lower bounds for each data page in this column.
   ///
-  /// This is like `encoded_min_values`, but with the values decoded according
-  /// to the column's physical type. `min_values` and `max_values` can be used
-  /// together with `boundary_order` in order to prune some data pages when
+  /// This is like `encodedMinValues`, but with the values decoded according
+  /// to the column's physical type. `minValues` and `maxValues` can be used
+  /// together with `boundaryOrder` in order to prune some data pages when
   /// searching for specific values.
-  virtual const std::vector<T>& min_values() const = 0;
+  virtual const std::vector<T>& minValues() const = 0;
 
   /// \brief A vector of upper bounds for each data page in this column.
   ///
-  /// Just like `min_values`, but for upper bounds instead of lower bounds.
-  virtual const std::vector<T>& max_values() const = 0;
+  /// Just like `minValues`, but for upper bounds instead of lower bounds.
+  virtual const std::vector<T>& maxValues() const = 0;
 };
 
 using BoolColumnIndex = TypedColumnIndex<BooleanType>;
@@ -123,9 +122,9 @@ struct PARQUET_EXPORT PageLocation {
   /// File offset of the data page.
   int64_t offset;
   /// Total compressed size of the data page and header.
-  int32_t compressed_page_size;
+  int32_t compressedPageSize;
   /// Row id of the first row in the page within the row group.
-  int64_t first_row_index;
+  int64_t firstRowIndex;
 };
 
 /// \brief OffsetIndex is a proxy around
@@ -133,15 +132,15 @@ struct PARQUET_EXPORT PageLocation {
 class PARQUET_EXPORT OffsetIndex {
  public:
   /// \brief Create a OffsetIndex from a serialized thrift message.
-  static std::unique_ptr<OffsetIndex> Make(
-      const void* serialized_index,
-      uint32_t index_len,
+  static std::unique_ptr<OffsetIndex> make(
+      const void* serializedIndex,
+      uint32_t indexLen,
       const ReaderProperties& properties);
 
   virtual ~OffsetIndex() = default;
 
   /// \brief A vector of locations for each data page in this column.
-  virtual const std::vector<PageLocation>& page_locations() const = 0;
+  virtual const std::vector<PageLocation>& pageLocations() const = 0;
 };
 
 /// \brief Interface for reading the page index for a Parquet row group.
@@ -151,24 +150,24 @@ class PARQUET_EXPORT RowGroupPageIndexReader {
 
   /// \brief Read column index of a column chunk.
   ///
-  /// \param[in] i column ordinal of the column chunk.
-  /// \returns column index of the column or nullptr if it does not exist.
+  /// \param[in] i Column ordinal of the column chunk.
+  /// \returns Column index of the column or nullptr if it does not exist.
   /// \throws ParquetException if the index is out of bound.
-  virtual std::shared_ptr<ColumnIndex> GetColumnIndex(int32_t i) = 0;
+  virtual std::shared_ptr<ColumnIndex> getColumnIndex(int32_t i) = 0;
 
   /// \brief Read offset index of a column chunk.
   ///
-  /// \param[in] i column ordinal of the column chunk.
-  /// \returns offset index of the column or nullptr if it does not exist.
+  /// \param[in] i Column ordinal of the column chunk.
+  /// \returns Offset index of the column or nullptr if it does not exist.
   /// \throws ParquetException if the index is out of bound.
-  virtual std::shared_ptr<OffsetIndex> GetOffsetIndex(int32_t i) = 0;
+  virtual std::shared_ptr<OffsetIndex> getOffsetIndex(int32_t i) = 0;
 };
 
 struct PageIndexSelection {
   /// Specifies whether to read the column index.
-  bool column_index = false;
+  bool columnIndex = false;
   /// Specifies whether to read the offset index.
-  bool offset_index = false;
+  bool offsetIndex = false;
 };
 
 PARQUET_EXPORT
@@ -178,11 +177,11 @@ struct RowGroupIndexReadRange {
   /// Base start and total size of column index of all column chunks in a row
   /// group. If none of the column chunks have column index, it is set to
   /// std::nullopt.
-  std::optional<::arrow::io::ReadRange> column_index = std::nullopt;
+  std::optional<::arrow::io::ReadRange> columnIndex = std::nullopt;
   /// Base start and total size of offset index of all column chunks in a row
   /// group. If none of the column chunks have offset index, it is set to
   /// std::nullopt.
-  std::optional<::arrow::io::ReadRange> offset_index = std::nullopt;
+  std::optional<::arrow::io::ReadRange> offsetIndex = std::nullopt;
 };
 
 /// \brief Interface for reading the page index for a Parquet file.
@@ -191,26 +190,25 @@ class PARQUET_EXPORT PageIndexReader {
   virtual ~PageIndexReader() = default;
 
   /// \brief Create a PageIndexReader instance.
-  /// \returns a PageIndexReader instance.
-  /// WARNING: The returned PageIndexReader references to all the input
+  /// \returns A PageIndexReader instance.
+  /// WARNING: The returned PageIndexReader references all the input
   /// parameters, so it must not outlive all of the input parameters. Usually
   /// these input parameters come from the same ParquetFileReader object, so it
   /// must not outlive the reader that creates this PageIndexReader.
-  static std::shared_ptr<PageIndexReader> Make(
+  static std::shared_ptr<PageIndexReader> make(
       ::arrow::io::RandomAccessFile* input,
-      std::shared_ptr<FileMetaData> file_metadata,
+      std::shared_ptr<FileMetaData> fileMetadata,
       const ReaderProperties& properties,
-      std::shared_ptr<InternalFileDecryptor> file_decryptor = NULLPTR);
+      std::shared_ptr<InternalFileDecryptor> fileDecryptor = NULLPTR);
 
   /// \brief Get the page index reader of a specific row group.
-  /// \param[in] i row group ordinal to get page index reader.
-  /// \returns RowGroupPageIndexReader of the specified row group. A nullptr may
-  /// or may
-  ///          not be returned if the page index for the row group is
-  ///          unavailable. It is the caller's responsibility to check the
-  ///          return value of follow-up calls to the RowGroupPageIndexReader.
+  /// \param[in] i Row group ordinal to get page index reader.
+  /// \returns RowGroupPageIndexReader of the specified row group. A nullptr
+  /// may or may not be returned if the page index for the row group is
+  /// unavailable. It is the caller's responsibility to check the
+  /// return value of follow-up calls to the RowGroupPageIndexReader.
   /// \throws ParquetException if the index is out of bound.
-  virtual std::shared_ptr<RowGroupPageIndexReader> RowGroup(int i) = 0;
+  virtual std::shared_ptr<RowGroupPageIndexReader> rowGroup(int i) = 0;
 
   /// \brief Advise the reader which part of page index will be read later.
   ///
@@ -218,66 +216,61 @@ class PARQUET_EXPORT PageIndexReader {
   /// may be read later to get better performance.
   ///
   /// The contract of this function is as below:
-  /// 1) If WillNeed() has not been called for a specific row group and the page
-  /// index
-  ///    exists, follow-up calls to get column index or offset index of all
-  ///    columns in this row group SHOULD NOT FAIL, but the performance may not
-  ///    be optimal.
-  /// 2) If WillNeed() has been called for a specific row group, follow-up calls
-  /// to get
-  ///    page index are limited to columns and index type requested by
-  ///    WillNeed(). So it MAY FAIL if columns that are not requested by
-  ///    WillNeed() are requested.
-  /// 3) Later calls to WillNeed() MAY OVERRIDE previous calls of same row
-  /// groups. For example, 1) If WillNeed() is not called for row group 0, then
-  /// follow-up calls to read
-  ///    column index and/or offset index of all columns of row group 0 should
-  ///    not fail if its page index exists.
-  /// 2) If WillNeed() is called for columns 0 and 1 for row group 0, then
-  /// follow-up
-  ///    call to read page index of column 2 for row group 0 MAY FAIL even if
-  ///    its page index exists.
-  /// 3) If WillNeed() is called for row group 0 with offset index only, then
-  ///    follow-up call to read column index of row group 0 MAY FAIL even if
-  ///    the column index of this column exists.
-  /// 4) If WillNeed() is called for columns 0 and 1 for row group 0, then later
-  ///    call to WillNeed() for columns 1 and 2 for row group 0. The later one
-  ///    overrides previous call and only columns 1 and 2 of row group 0 are
-  ///    allowed to access.
+  /// 1) If willNeed() has not been called for a specific row group and the
+  /// page index exists, follow-up calls to get column index or offset index of
+  /// all columns in this row group SHOULD NOT FAIL, but the performance may not
+  /// be optimal.
+  /// 2) If willNeed() has been called for a specific row group, follow-up
+  /// calls to get page index are limited to columns and index type requested by
+  /// willNeed(). So it MAY FAIL if columns that are not requested by
+  /// willNeed() are requested.
+  /// 3) Later calls to willNeed() MAY OVERRIDE previous calls of same row
+  /// groups. For example, 1) if willNeed() is not called for row group 0, then
+  /// follow-up calls to read column index and/or offset index of all columns of
+  /// row group 0 should not fail if its page index exists.
+  /// 2) If willNeed() is called for columns 0 and 1 for row group 0, then
+  /// follow-up call to read page index of column 2 for row group 0 MAY FAIL
+  /// even if its page index exists. 3) If willNeed() is called for row group 0
+  /// with offset index only, then follow-up call to read column index of row
+  /// group 0 MAY FAIL even if the column index of this column exists. 4) If
+  /// willNeed() is called for columns 0 and 1 for row group 0, then later call
+  /// to willNeed() for columns 1 and 2 for row group 0. The later one overrides
+  /// previous call and only columns 1 and 2 of row group 0 are allowed to
+  /// access.
   ///
-  /// \param[in] row_group_indices list of row group ordinal to read page index
-  /// later. \param[in] column_indices list of column ordinal to read page index
-  /// later. If it is
-  ///            empty, it means all columns in the row group will be read.
-  /// \param[in] selection which kind of page index is required later.
-  virtual void WillNeed(
-      const std::vector<int32_t>& row_group_indices,
-      const std::vector<int32_t>& column_indices,
+  /// \param[in] rowGroupIndices List of row group ordinal to read page
+  /// index later. \param[in] columnIndices List of column ordinal to
+  /// read page index later. If it is empty, it means all columns in the
+  /// row group will be read.
+  /// \param[in] selection Which kind of page index is required later.
+  virtual void willNeed(
+      const std::vector<int32_t>& rowGroupIndices,
+      const std::vector<int32_t>& columnIndices,
       const PageIndexSelection& selection) = 0;
 
-  /// \brief Advise the reader page index of these row groups will not be read
+  /// \brief Advise the reader page index of these row groups will not be read.
   /// any more.
   ///
   /// The PageIndexReader implementation has the opportunity to cancel any
   /// prefetch or release resource that are related to these row groups.
   ///
-  /// \param[in] row_group_indices list of row group ordinal that whose page
-  /// index will not be accessed any more.
-  virtual void WillNotNeed(const std::vector<int32_t>& row_group_indices) = 0;
+  /// \param[in] rowGroupIndices List of row group ordinal whose page index
+  /// will not be accessed any more.
+  virtual void willNotNeed(const std::vector<int32_t>& rowGroupIndices) = 0;
 
   /// \brief Determine the column index and offset index ranges for the given
   /// row group.
   ///
-  /// \param[in] row_group_metadata row group metadata to get column chunk
-  /// metadata. \param[in] columns list of column ordinals to get page index. If
-  /// the list is empty,
-  ///            it means all columns in the row group.
+  /// \param[in] rowGroupMetadata Row group metadata to get column chunk
+  /// metadata.
+  /// \param[in] columns List of column ordinals to get page index.
+  /// If the list is empty, it means all columns in the row group.
   /// \returns RowGroupIndexReadRange of the specified row group. Throws
   /// ParquetException
   ///          if the selected column ordinal is out of bound or metadata of
   ///          page index is corrupted.
-  static RowGroupIndexReadRange DeterminePageIndexRangesInRowGroup(
-      const RowGroupMetaData& row_group_metadata,
+  static RowGroupIndexReadRange determinePageIndexRangesInRowGroup(
+      const RowGroupMetaData& rowGroupMetadata,
       const std::vector<int32_t>& columns);
 };
 
@@ -286,7 +279,7 @@ class PARQUET_EXPORT PageIndexReader {
 class PARQUET_EXPORT ColumnIndexBuilder {
  public:
   /// \brief API convenience to create a ColumnIndexBuilder.
-  static std::unique_ptr<ColumnIndexBuilder> Make(
+  static std::unique_ptr<ColumnIndexBuilder> make(
       const ColumnDescriptor* descr);
 
   virtual ~ColumnIndexBuilder() = default;
@@ -297,50 +290,50 @@ class PARQUET_EXPORT ColumnIndexBuilder {
   /// not update statistics any more.
   ///
   /// \param stats Page statistics in the encoded form.
-  virtual void AddPage(const EncodedStatistics& stats) = 0;
+  virtual void addPage(const EncodedStatistics& stats) = 0;
 
   /// \brief Complete the column index.
   ///
-  /// Once called, AddPage() can no longer be called.
-  /// WriteTo() and Build() can only called after Finish() has been called.
-  virtual void Finish() = 0;
+  /// Once called, addPage() can no longer be called.
+  /// writeTo() and build() can only called after finish() has been called.
+  virtual void finish() = 0;
 
   /// \brief Serialize the column index thrift message.
   ///
   /// If the ColumnIndexBuilder has seen any corrupted statistics, it will
   /// not write any data to the sink.
   ///
-  /// \param[out] sink output stream to write the serialized message.
-  virtual void WriteTo(::arrow::io::OutputStream* sink) const = 0;
+  /// \param[out] sink Output stream to write the serialized message.
+  virtual void writeTo(::arrow::io::OutputStream* sink) const = 0;
 
   /// \brief Create a ColumnIndex directly.
   ///
   /// \return If the ColumnIndexBuilder has seen any corrupted statistics, it
   /// simply returns nullptr. Otherwise the column index is built and returned.
-  virtual std::unique_ptr<ColumnIndex> Build() const = 0;
+  virtual std::unique_ptr<ColumnIndex> build() const = 0;
 };
 
 /// \brief Interface for collecting offset index of data pages in a column
 /// chunk.
 class PARQUET_EXPORT OffsetIndexBuilder {
  public:
-  /// \brief API convenience to create a OffsetIndexBuilder.
-  static std::unique_ptr<OffsetIndexBuilder> Make();
+  /// \brief API convenience to create an OffsetIndexBuilder.
+  static std::unique_ptr<OffsetIndexBuilder> make();
 
   virtual ~OffsetIndexBuilder() = default;
 
   /// \brief Add page location of a data page.
-  virtual void AddPage(
+  virtual void addPage(
       int64_t offset,
-      int32_t compressed_page_size,
-      int64_t first_row_index) = 0;
+      int32_t compressedPageSize,
+      int64_t firstRowIndex) = 0;
 
   /// \brief Add page location of a data page.
-  void AddPage(const PageLocation& page_location) {
-    AddPage(
-        page_location.offset,
-        page_location.compressed_page_size,
-        page_location.first_row_index);
+  void addPage(const PageLocation& pageLocation) {
+    addPage(
+        pageLocation.offset,
+        pageLocation.compressedPageSize,
+        pageLocation.firstRowIndex);
   }
 
   /// \brief Complete the offset index.
@@ -349,46 +342,46 @@ class PARQUET_EXPORT OffsetIndexBuilder {
   /// sink and the OffsetIndexBuilder has only collected the relative offset
   /// which requires adjustment once they are flushed to the file.
   ///
-  /// \param final_position Final stream offset to add for page offset
+  /// \param finalPosition Final stream offset to add for page offset
   /// adjustment.
-  virtual void Finish(int64_t final_position) = 0;
+  virtual void finish(int64_t finalPosition) = 0;
 
   /// \brief Serialize the offset index thrift message.
   ///
-  /// \param[out] sink output stream to write the serialized message.
-  virtual void WriteTo(::arrow::io::OutputStream* sink) const = 0;
+  /// \param[out] sink Output stream to write the serialized message.
+  virtual void writeTo(::arrow::io::OutputStream* sink) const = 0;
 
   /// \brief Create an OffsetIndex directly.
-  virtual std::unique_ptr<OffsetIndex> Build() const = 0;
+  virtual std::unique_ptr<OffsetIndex> build() const = 0;
 };
 
-/// \brief Interface for collecting page index of a parquet file.
+/// \brief Interface for collecting page index of a Parquet file.
 class PARQUET_EXPORT PageIndexBuilder {
  public:
   /// \brief API convenience to create a PageIndexBuilder.
-  static std::unique_ptr<PageIndexBuilder> Make(const SchemaDescriptor* schema);
+  static std::unique_ptr<PageIndexBuilder> make(const SchemaDescriptor* schema);
 
   virtual ~PageIndexBuilder() = default;
 
   /// \brief Start a new row group.
-  virtual void AppendRowGroup() = 0;
+  virtual void appendRowGroup() = 0;
 
   /// \brief Get the ColumnIndexBuilder from column ordinal.
   ///
   /// \param i Column ordinal.
-  /// \return ColumnIndexBuilder for the column and its memory ownership belongs
-  /// to the PageIndexBuilder.
-  virtual ColumnIndexBuilder* GetColumnIndexBuilder(int32_t i) = 0;
+  /// \return ColumnIndexBuilder for the column and its memory ownership
+  /// belongs to the PageIndexBuilder.
+  virtual ColumnIndexBuilder* getColumnIndexBuilder(int32_t i) = 0;
 
   /// \brief Get the OffsetIndexBuilder from column ordinal.
   ///
   /// \param i Column ordinal.
-  /// \return OffsetIndexBuilder for the column and its memory ownership belongs
-  /// to the PageIndexBuilder.
-  virtual OffsetIndexBuilder* GetOffsetIndexBuilder(int32_t i) = 0;
+  /// \return OffsetIndexBuilder for the column and its memory ownership
+  /// belongs to the PageIndexBuilder.
+  virtual OffsetIndexBuilder* getOffsetIndexBuilder(int32_t i) = 0;
 
   /// \brief Complete the page index builder and no more write is allowed.
-  virtual void Finish() = 0;
+  virtual void finish() = 0;
 
   /// \brief Serialize the page index thrift message.
   ///
@@ -397,7 +390,7 @@ class PARQUET_EXPORT PageIndexBuilder {
   ///
   /// \param[out] sink The output stream to write the page index.
   /// \param[out] location The location of all page index to the start of sink.
-  virtual void WriteTo(
+  virtual void writeTo(
       ::arrow::io::OutputStream* sink,
       PageIndexLocation* location) const = 0;
 };
diff --git a/velox/dwio/parquet/writer/arrow/PathInternal.cpp b/velox/dwio/parquet/writer/arrow/PathInternal.cpp
index 885a8254edd..07541223c60 100644
--- a/velox/dwio/parquet/writer/arrow/PathInternal.cpp
+++ b/velox/dwio/parquet/writer/arrow/PathInternal.cpp
@@ -18,77 +18,77 @@
 
 // Overview.
 //
-// The strategy used for this code for repetition/definition
-// is to dissect the top level array into a list of paths
-// from the top level array to the final primitive (possibly
-// dictionary encoded array). It then evaluates each one of
-// those paths to produce results for the callback iteratively.
+// The strategy used for this code for repetition/definition.
+// Is to dissect the top level array into a list of paths.
+// From the top level array to the final primitive (possibly.
+// Dictionary encoded array). It then evaluates each one of.
+// Those paths to produce results for the callback iteratively.
 //
-// This approach was taken to reduce the aggregate memory required if we were
-// to build all def/rep levels in parallel as apart of a tree traversal.  It
-// also allows for straightforward parallelization at the path level if that is
-// desired in the future.
+// This approach was taken to reduce the aggregate memory required if we were.
+// To build all def/rep levels in parallel as apart of a tree traversal.  It.
+// Also allows for straightforward parallelization at the path level if that is.
+// Desired in the future.
 //
-// The main downside to this approach is it duplicates effort for nodes
-// that share common ancestors. This can be mitigated to some degree
-// by adding in optimizations that detect leaf arrays that share
-// the same common list ancestor and reuse the repetition levels
-// from the first leaf encountered (only definition levels greater
-// the list ancestor need to be re-evaluated. This is left for future
-// work.
+// The main downside to this approach is it duplicates effort for nodes.
+// That share common ancestors. This can be mitigated to some degree.
+// By adding in optimizations that detect leaf arrays that share.
+// The same common list ancestor and reuse the repetition levels.
+// From the first leaf encountered (only definition levels greater.
+// The list ancestor need to be re-evaluated. This is left for future.
+// Work.
 //
 // Algorithm.
 //
 // As mentioned above this code dissects arrays into constituent parts:
-// nullability data, and list offset data. It tries to optimize for
-// some special cases, where it is known ahead of time that a step
-// can be skipped (e.g. a nullable array happens to have all of its
-// values) or batch filled (a nullable array has all null values).
-// One further optimization that is not implemented but could be done
-// in the future is special handling for nested list arrays that
-// have some intermediate data which indicates the final array contains only
-// nulls.
+// Nullability data, and list offset data. It tries to optimize for.
+// Some special cases, where it is known ahead of time that a step.
+// Can be skipped (e.g. a nullable array happens to have all of its.
+// Values) or batch filled (a nullable array has all null values).
+// One further optimization that is not implemented but could be done.
+// In the future is special handling for nested list arrays that.
+// Have some intermediate data which indicates the final array contains only.
+// Nulls.
 //
-// In general, the algorithm attempts to batch work at each node as much
-// as possible.  For nullability nodes this means finding runs of null
-// values and batch filling those interspersed with finding runs of non-null
-// values to process in batch at the next column.
+// In general, the algorithm attempts to batch work at each node as much.
+// As possible.  For nullability nodes this means finding runs of null.
+// Values and batch filling those interspersed with finding runs of non-null.
+// Values to process in batch at the next column.
 //
-// Similarly, list runs of empty lists are all processed in one batch
-// followed by either:
-//    - A single list entry for non-terminal lists (i.e. the upper part of a
+// Similarly, list runs of empty lists are all processed in one batch.
+// Followed by either:
+//    - A single list entry for non-terminal lists (i.e. the upper part of a.
 //    nested list)
-//    - Runs of non-empty lists for the terminal list (i.e. the lowest part of a
-//    nested list).
+//    - Runs of non-empty lists for the terminal list (i.e. the lowest part of
+//    a. Nested list).
 //
 // This makes use of the following observations.
-// 1.  Null values at any node on the path are terminal (repetition and
-// definition
-//     level can be set directly when a Null value is encountered).
+// 1.  Null values at any node on the path are terminal (repetition and.
+// Definition.
+//     Level can be set directly when a Null value is encountered).
 // 2.  Empty lists share this eager termination property with Null values.
-// 3.  In order to keep repetition/definition level populated the algorithm is
-// lazy
-//     in assigning repetition levels. The algorithm tracks whether it is
-//     currently in the middle of a list by comparing the lengths of
-//     repetition/definition levels. If it is currently in the middle of a list
-//     the the number of repetition levels populated will be greater than
-//     definition levels (the start of a List requires adding the first
-//     element). If there are equal numbers of definition and repetition levels
-//     populated this indicates a list is waiting to be started and the next
-//     list encountered will have its repetition level signify the beginning of
-//     the list.
+// 3.  In order to keep repetition/definition level populated the algorithm is.
+// Lazy.
+//     In assigning repetition levels. The algorithm tracks whether it is.
+//     Currently in the middle of a list by comparing the lengths of.
+//     Repetition/definition levels. If it is currently in the middle of a list.
+//     The the number of repetition levels populated will be greater than.
+//     Definition levels (the start of a List requires adding the first.
+//     Element). If there are equal numbers of definition and repetition levels.
+//     Populated this indicates a list is waiting to be started and the next.
+//     List encountered will have its repetition level signify the beginning of.
+//     The list.
 //
 //     Other implementation notes.
 //
-//     This code hasn't been benchmarked (or assembly analyzed) but did the
-//     following as optimizations (yes premature optimization is the root of all
-//     evil).
-//     - This code does not use recursion, instead it constructs its own stack
-//     and manages
-//       updating elements accordingly.
+//     This code hasn't been benchmarked (or assembly analyzed) but did the.
+//     Following as optimizations (yes premature optimization is the root of
+//     all. Evil).
+//     - This code does not use recursion, instead it constructs its own stack.
+//     And manages.
+//       Updating elements accordingly.
 //     - It tries to avoid using Status for common return states.
-//     - Avoids virtual dispatch in favor of if/else statements on a set of well
-//     known classes.
+//     - Avoids virtual dispatch in favor of if/else statements on a set of
+//     well. Known classes.
 
 #include "velox/dwio/parquet/writer/arrow/PathInternal.h"
 
@@ -127,9 +127,8 @@ using ::arrow::TypedBufferBuilder;
 constexpr static int16_t kLevelNotSet = -1;
 
 /// \brief Simple result of a iterating over a column to determine values.
-enum IterationResult {
-  /// Processing is done at this node. Move back up the path
-  /// to continue processing.
+enum IterationResult { /// Processing is done at this node. Move back up the
+                       /// path. To continue processing.
   kDone = -1,
   /// Move down towards the leaf for processing.
   kNext = 1,
@@ -137,339 +136,335 @@ enum IterationResult {
   kError = 2
 };
 
-#define RETURN_IF_ERROR(iteration_result)                  \
-  do {                                                     \
-    if (ARROW_PREDICT_FALSE(iteration_result == kError)) { \
-      return iteration_result;                             \
-    }                                                      \
+#define RETURN_IF_ERROR(iterationResult)                  \
+  do {                                                    \
+    if (ARROW_PREDICT_FALSE(iterationResult == kError)) { \
+      return iterationResult;                             \
+    }                                                     \
   } while (false)
 
-int64_t LazyNullCount(const Array& array) {
+int64_t lazyNullCount(const Array& array) {
   return array.data()->null_count.load();
 }
 
-bool LazyNoNulls(const Array& array) {
-  int64_t null_count = LazyNullCount(array);
-  return null_count == 0 ||
-      // kUnkownNullCount comparison is needed to account
-      // for null arrays.
-      (null_count == ::arrow::kUnknownNullCount &&
+bool lazyNoNulls(const Array& array) {
+  int64_t nullCount = lazyNullCount(array);
+  return nullCount == 0 ||
+      // KUnkownNullCount comparison is needed to account.
+      // For null arrays.
+      (nullCount == ::arrow::kUnknownNullCount &&
        array.null_bitmap_data() == nullptr);
 }
 
 struct PathWriteContext {
   PathWriteContext(
       ::arrow::MemoryPool* pool,
-      std::shared_ptr<::arrow::ResizableBuffer> def_levels_buffer)
-      : rep_levels(pool), def_levels(std::move(def_levels_buffer), pool) {}
-  IterationResult ReserveDefLevels(int64_t elements) {
-    last_status = def_levels.Reserve(elements);
-    if (ARROW_PREDICT_TRUE(last_status.ok())) {
+      std::shared_ptr<::arrow::ResizableBuffer> defLevelsBuffer)
+      : repLevels(pool), defLevels(std::move(defLevelsBuffer), pool) {}
+  IterationResult reserveDefLevels(int64_t elements) {
+    lastStatus = defLevels.Reserve(elements);
+    if (ARROW_PREDICT_TRUE(lastStatus.ok())) {
       return kDone;
     }
     return kError;
   }
 
-  IterationResult AppendDefLevel(int16_t def_level) {
-    last_status = def_levels.Append(def_level);
-    if (ARROW_PREDICT_TRUE(last_status.ok())) {
+  IterationResult appendDefLevel(int16_t defLevel) {
+    lastStatus = defLevels.Append(defLevel);
+    if (ARROW_PREDICT_TRUE(lastStatus.ok())) {
       return kDone;
     }
     return kError;
   }
 
-  IterationResult AppendDefLevels(int64_t count, int16_t def_level) {
-    last_status = def_levels.Append(count, def_level);
-    if (ARROW_PREDICT_TRUE(last_status.ok())) {
+  IterationResult appendDefLevels(int64_t count, int16_t defLevel) {
+    lastStatus = defLevels.Append(count, defLevel);
+    if (ARROW_PREDICT_TRUE(lastStatus.ok())) {
       return kDone;
     }
     return kError;
   }
 
-  void UnsafeAppendDefLevel(int16_t def_level) {
-    def_levels.UnsafeAppend(def_level);
+  void unsafeAppendDefLevel(int16_t defLevel) {
+    defLevels.UnsafeAppend(defLevel);
   }
 
-  IterationResult AppendRepLevel(int16_t rep_level) {
-    last_status = rep_levels.Append(rep_level);
+  IterationResult appendRepLevel(int16_t repLevel) {
+    lastStatus = repLevels.Append(repLevel);
 
-    if (ARROW_PREDICT_TRUE(last_status.ok())) {
+    if (ARROW_PREDICT_TRUE(lastStatus.ok())) {
       return kDone;
     }
     return kError;
   }
 
-  IterationResult AppendRepLevels(int64_t count, int16_t rep_level) {
-    last_status = rep_levels.Append(count, rep_level);
-    if (ARROW_PREDICT_TRUE(last_status.ok())) {
+  IterationResult appendRepLevels(int64_t count, int16_t repLevel) {
+    lastStatus = repLevels.Append(count, repLevel);
+    if (ARROW_PREDICT_TRUE(lastStatus.ok())) {
       return kDone;
     }
     return kError;
   }
 
-  bool EqualRepDefLevelsLengths() const {
-    return rep_levels.length() == def_levels.length();
+  bool equalRepDefLevelsLengths() const {
+    return repLevels.length() == defLevels.length();
   }
 
-  // Incorporates |range| into visited elements. If the |range| is contiguous
-  // with the last range, extend the last range, otherwise add |range|
-  // separately to the list.
-  void RecordPostListVisit(const ElementRange& range) {
-    if (!visited_elements.empty() &&
-        range.start == visited_elements.back().end) {
-      visited_elements.back().end = range.end;
+  // Incorporates |range| into visited elements. If the |range| is contiguous.
+  // With the last range, extend the last range, otherwise add |range|.
+  // Separately to the list.
+  void recordPostListVisit(const ElementRange& range) {
+    if (!visitedElements.empty() && range.start == visitedElements.back().end) {
+      visitedElements.back().end = range.end;
       return;
     }
-    visited_elements.push_back(range);
+    visitedElements.push_back(range);
   }
 
-  Status last_status;
-  TypedBufferBuilder<int16_t> rep_levels;
-  TypedBufferBuilder<int16_t> def_levels;
-  std::vector<ElementRange> visited_elements;
+  Status lastStatus;
+  TypedBufferBuilder<int16_t> repLevels;
+  TypedBufferBuilder<int16_t> defLevels;
+  std::vector<ElementRange> visitedElements;
 };
 
 IterationResult
-FillRepLevels(int64_t count, int16_t rep_level, PathWriteContext* context) {
-  if (rep_level == kLevelNotSet) {
+fillRepLevels(int64_t count, int16_t repLevel, PathWriteContext* context) {
+  if (repLevel == kLevelNotSet) {
     return kDone;
   }
-  int64_t fill_count = count;
-  // This condition occurs (rep and dep levels equals), in one of
-  // in a few cases:
+  int64_t fillCount = count;
+  // This condition occurs (rep and dep levels equals), in one of.
+  // In a few cases:
   // 1.  Before any list is encountered.
-  // 2.  After rep-level has been filled in due to null/empty
-  //     values above it.
+  // 2.  After rep-level has been filled in due to null/empty.
+  //     Values above it.
   // 3.  After finishing a list.
-  if (!context->EqualRepDefLevelsLengths()) {
-    fill_count--;
+  if (!context->equalRepDefLevelsLengths()) {
+    fillCount--;
   }
-  return context->AppendRepLevels(fill_count, rep_level);
+  return context->appendRepLevels(fillCount, repLevel);
 }
 
-// A node for handling an array that is discovered to have all
-// null elements. It is referred to as a TerminalNode because
-// traversal of nodes will not continue it when generating
-// rep/def levels. However, there could be many nested children
-// elements beyond it in the Array that is being processed.
+// A node for handling an array that is discovered to have all.
+// Null elements. It is referred to as a TerminalNode because.
+// Traversal of nodes will not continue it when generating.
+// Rep/def levels. However, there could be many nested children.
+// Elements beyond it in the Array that is being processed.
 class AllNullsTerminalNode {
  public:
   explicit AllNullsTerminalNode(
-      int16_t def_level,
-      int16_t rep_level = kLevelNotSet)
-      : def_level_(def_level), rep_level_(rep_level) {}
-  void SetRepLevelIfNull(int16_t rep_level) {
-    rep_level_ = rep_level;
+      int16_t defLevel,
+      int16_t repLevel = kLevelNotSet)
+      : defLevel_(defLevel), repLevel_(repLevel) {}
+  void setRepLevelIfNull(int16_t repLevel) {
+    repLevel_ = repLevel;
   }
-  IterationResult Run(const ElementRange& range, PathWriteContext* context) {
-    int64_t size = range.Size();
-    RETURN_IF_ERROR(FillRepLevels(size, rep_level_, context));
-    return context->AppendDefLevels(size, def_level_);
+  IterationResult run(const ElementRange& range, PathWriteContext* context) {
+    int64_t size = range.size();
+    RETURN_IF_ERROR(fillRepLevels(size, repLevel_, context));
+    return context->appendDefLevels(size, defLevel_);
   }
 
  private:
-  int16_t def_level_;
-  int16_t rep_level_;
+  int16_t defLevel_;
+  int16_t repLevel_;
 };
 
-// Handles the case where all remaining arrays until the leaf have no nulls
-// (and are not interrupted by lists). Unlike AllNullsTerminalNode this is
-// always the last node in a path. We don't need an analogue to the
-// AllNullsTerminalNode because if all values are present at an intermediate
-// array no node is added for it (the def-level for the next nullable node is
-// incremented).
+// Handles the case where all remaining arrays until the leaf have no nulls.
+// (And are not interrupted by lists). Unlike AllNullsTerminalNode this is.
+// Always the last node in a path. We don't need an analogue to the.
+// AllNullsTerminalNode because if all values are present at an intermediate.
+// Array no node is added for it (the def-level for the next nullable node is.
+// Incremented).
 struct AllPresentTerminalNode {
-  IterationResult Run(const ElementRange& range, PathWriteContext* context) {
-    return context->AppendDefLevels(range.end - range.start, def_level);
-    // No need to worry about rep levels, because this state should
-    // only be applicable for after all list/repeated values
-    // have been evaluated in the path.
+  IterationResult run(const ElementRange& range, PathWriteContext* context) {
+    return context->appendDefLevels(range.end - range.start, defLevel);
+    // No need to worry about rep levels, because this state should.
+    // Only be applicable for after all list/repeated values.
+    // Have been evaluated in the path.
   }
-  int16_t def_level;
+  int16_t defLevel;
 };
 
-/// Node for handling the case when the leaf-array is nullable
-/// and contains null elements.
+/// Node for handling the case when the leaf-array is nullable.
+/// And contains null elements.
 struct NullableTerminalNode {
   NullableTerminalNode() = default;
 
   NullableTerminalNode(
       const uint8_t* bitmap,
-      int64_t element_offset,
-      int16_t def_level_if_present)
+      int64_t elementOffset,
+      int16_t defLevelIfPresent)
       : bitmap_(bitmap),
-        element_offset_(element_offset),
-        def_level_if_present_(def_level_if_present),
-        def_level_if_null_(def_level_if_present - 1) {}
+        elementOffset_(elementOffset),
+        defLevelIfPresent_(defLevelIfPresent),
+        defLevelIfNull_(defLevelIfPresent - 1) {}
 
-  IterationResult Run(const ElementRange& range, PathWriteContext* context) {
-    int64_t elements = range.Size();
-    RETURN_IF_ERROR(context->ReserveDefLevels(elements));
+  IterationResult run(const ElementRange& range, PathWriteContext* context) {
+    int64_t elements = range.size();
+    RETURN_IF_ERROR(context->reserveDefLevels(elements));
 
     VELOX_DCHECK_GT(elements, 0);
 
-    auto bit_visitor = [&](bool is_set) {
-      context->UnsafeAppendDefLevel(
-          is_set ? def_level_if_present_ : def_level_if_null_);
+    auto bitVisitor = [&](bool isSet) {
+      context->unsafeAppendDefLevel(
+          isSet ? defLevelIfPresent_ : defLevelIfNull_);
     };
 
     if (elements > 16) { // 16 guarantees at least one unrolled loop.
       ::arrow::internal::VisitBitsUnrolled(
-          bitmap_, range.start + element_offset_, elements, bit_visitor);
+          bitmap_, range.start + elementOffset_, elements, bitVisitor);
     } else {
       ::arrow::internal::VisitBits(
-          bitmap_, range.start + element_offset_, elements, bit_visitor);
+          bitmap_, range.start + elementOffset_, elements, bitVisitor);
     }
     return kDone;
   }
   const uint8_t* bitmap_;
-  int64_t element_offset_;
-  int16_t def_level_if_present_;
-  int16_t def_level_if_null_;
+  int64_t elementOffset_;
+  int16_t defLevelIfPresent_;
+  int16_t defLevelIfNull_;
 };
 
-// List nodes handle populating rep_level for Arrow Lists and def-level for
-// empty lists. Nullability (both list and children) is handled by other Nodes.
-// By construction all list nodes will be intermediate nodes (they will always
-// be followed by at least one other node).
+// List nodes handle populating rep_level for Arrow Lists and def-level for.
+// Empty lists. Nullability (both list and children) is handled by other Nodes.
+// By construction all list nodes will be intermediate nodes (they will always.
+// Be followed by at least one other node).
 //
 // Type parameters:
-//    |RangeSelector| - A strategy for determine the the range of the child node
-//    to process.
-//       this varies depending on the type of list (int32_t* offsets, int64_t*
-//       offsets of fixed.
+//    |RangeSelector| - A strategy for determine the the range of the child
+//    node. To process.
+//       This varies depending on the type of list (int32_t* offsets, int64_t*.
+//       Offsets of fixed.
 template <typename RangeSelector>
 class ListPathNode {
  public:
-  ListPathNode(
-      RangeSelector selector,
-      int16_t rep_lev,
-      int16_t def_level_if_empty)
+  ListPathNode(RangeSelector selector, int16_t repLev, int16_t defLevelIfEmpty)
       : selector_(std::move(selector)),
-        prev_rep_level_(rep_lev - 1),
-        rep_level_(rep_lev),
-        def_level_if_empty_(def_level_if_empty) {}
+        prevRepLevel_(repLev - 1),
+        repLevel_(repLev),
+        defLevelIfEmpty_(defLevelIfEmpty) {}
 
-  int16_t rep_level() const {
-    return rep_level_;
+  int16_t repLevel() const {
+    return repLevel_;
   }
 
-  IterationResult Run(
+  IterationResult run(
       ElementRange* range,
-      ElementRange* child_range,
+      ElementRange* childRange,
       PathWriteContext* context) {
-    if (range->Empty()) {
+    if (range->empty()) {
       return kDone;
     }
     // Find the first non-empty list (skipping a run of empties).
-    int64_t empty_elements = 0;
+    int64_t emptyElements = 0;
     do {
       // Retrieve the range of elements that this list contains.
-      *child_range = selector_.GetRange(range->start);
-      if (!child_range->Empty()) {
+      *childRange = selector_.getRange(range->start);
+      if (!childRange->empty()) {
         break;
       }
-      ++empty_elements;
+      ++emptyElements;
       ++range->start;
-    } while (!range->Empty());
+    } while (!range->empty());
 
     // Post condition:
     //   * range is either empty (we are done processing at this node)
-    //     or start corresponds a non-empty list.
-    //   * If range is non-empty child_range contains
-    //     the bounds of non-empty list.
+    //     Or start corresponds a non-empty list.
+    //   * If range is non-empty child_range contains.
+    //     The bounds of non-empty list.
 
     // Handle any skipped over empty lists.
-    if (empty_elements > 0) {
-      RETURN_IF_ERROR(FillRepLevels(empty_elements, prev_rep_level_, context));
+    if (emptyElements > 0) {
+      RETURN_IF_ERROR(fillRepLevels(emptyElements, prevRepLevel_, context));
       RETURN_IF_ERROR(
-          context->AppendDefLevels(empty_elements, def_level_if_empty_));
+          context->appendDefLevels(emptyElements, defLevelIfEmpty_));
     }
-    // Start of a new list. Note that for nested lists adding the element
-    // here effectively suppresses this code until we either encounter null
-    // elements or empty lists between here and the innermost list (since
-    // we make the rep levels repetition and definition levels unequal).
-    // Similarly when we are backtracking up the stack the repetition and
-    // definition levels are again equal so if we encounter an intermediate list
-    // with more elements this will detect it as a new list.
-    if (context->EqualRepDefLevelsLengths() && !range->Empty()) {
-      RETURN_IF_ERROR(context->AppendRepLevel(prev_rep_level_));
+    // Start of a new list. Note that for nested lists adding the element.
+    // Here effectively suppresses this code until we either encounter null.
+    // Elements or empty lists between here and the innermost list (since.
+    // We make the rep levels repetition and definition levels unequal).
+    // Similarly when we are backtracking up the stack the repetition and.
+    // Definition levels are again equal so if we encounter an intermediate
+    // list. With more elements this will detect it as a new list.
+    if (context->equalRepDefLevelsLengths() && !range->empty()) {
+      RETURN_IF_ERROR(context->appendRepLevel(prevRepLevel_));
     }
 
-    if (range->Empty()) {
+    if (range->empty()) {
       return kDone;
     }
 
     ++range->start;
-    if (is_last_) {
-      // If this is the last repeated node, we can extend try
-      // to extend the child range as wide as possible before
-      // continuing to the next node.
-      return FillForLast(range, child_range, context);
+    if (isLast_) {
+      // If this is the last repeated node, we can extend try.
+      // To extend the child range as wide as possible before.
+      // Continuing to the next node.
+      return fillForLast(range, childRange, context);
     }
     return kNext;
   }
 
-  void SetLast() {
-    is_last_ = true;
+  void setLast() {
+    isLast_ = true;
   }
 
  private:
-  IterationResult FillForLast(
+  IterationResult fillForLast(
       ElementRange* range,
-      ElementRange* child_range,
+      ElementRange* childRange,
       PathWriteContext* context) {
     // First fill int the remainder of the list.
-    RETURN_IF_ERROR(FillRepLevels(child_range->Size(), rep_level_, context));
+    RETURN_IF_ERROR(fillRepLevels(childRange->size(), repLevel_, context));
     // Once we've reached this point the following preconditions should hold:
     // 1.  There are no more repeated path nodes to deal with.
-    // 2.  All elements in |range| represent contiguous elements in the
-    //     child array (Null values would have shortened the range to ensure
-    //     all remaining list elements are present (though they may be empty
-    //     lists)).
-    // 3.  No element of range spans a parent list (intermediate
-    //     list nodes only handle one list entry at a time).
+    // 2.  All elements in |range| represent contiguous elements in the.
+    //     Child array (Null values would have shortened the range to ensure.
+    //     All remaining list elements are present (though they may be empty.
+    //     Lists)).
+    // 3.  No element of range spans a parent list (intermediate.
+    //     List nodes only handle one list entry at a time).
     //
-    // Given these preconditions it should be safe to fill runs on non-empty
-    // lists here and expand the range in the child node accordingly.
-
-    while (!range->Empty()) {
-      ElementRange size_check = selector_.GetRange(range->start);
-      if (size_check.Empty()) {
-        // The empty range will need to be handled after we pass down the
-        // accumulated range because it affects def_level placement and we need
-        // to get the children def_levels entered first.
+    // Given these preconditions it should be safe to fill runs on non-empty.
+    // Lists here and expand the range in the child node accordingly.
+
+    while (!range->empty()) {
+      ElementRange sizeCheck = selector_.getRange(range->start);
+      if (sizeCheck.empty()) {
+        // The empty range will need to be handled after we pass down the.
+        // Accumulated range because it affects def_level placement and we need.
+        // To get the children def_levels entered first.
         break;
       }
-      // This is the start of a new list. We can be sure it only applies
-      // to the previous list (and doesn't jump to the start of any list
-      // further up in nesting due to the constraints mentioned at the start
-      // of the function).
-      RETURN_IF_ERROR(context->AppendRepLevel(prev_rep_level_));
+      // This is the start of a new list. We can be sure it only applies.
+      // To the previous list (and doesn't jump to the start of any list.
+      // Further up in nesting due to the constraints mentioned at the start.
+      // Of the function).
+      RETURN_IF_ERROR(context->appendRepLevel(prevRepLevel_));
       RETURN_IF_ERROR(
-          context->AppendRepLevels(size_check.Size() - 1, rep_level_));
-      VELOX_DCHECK_EQ(size_check.start, child_range->end);
-      child_range->end = size_check.end;
+          context->appendRepLevels(sizeCheck.size() - 1, repLevel_));
+      VELOX_DCHECK_EQ(sizeCheck.start, childRange->end);
+      childRange->end = sizeCheck.end;
       ++range->start;
     }
 
-    // Do book-keeping to track the elements of the arrays that are actually
-    // visited beyond this point.  This is necessary to identify "gaps" in
-    // values that should not be processed (written out to parquet).
-    context->RecordPostListVisit(*child_range);
+    // Do book-keeping to track the elements of the arrays that are actually.
+    // Visited beyond this point.  This is necessary to identify "gaps" in.
+    // Values that should not be processed (written out to parquet).
+    context->recordPostListVisit(*childRange);
     return kNext;
   }
 
   RangeSelector selector_;
-  int16_t prev_rep_level_;
-  int16_t rep_level_;
-  int16_t def_level_if_empty_;
-  bool is_last_ = false;
+  int16_t prevRepLevel_;
+  int16_t repLevel_;
+  int16_t defLevelIfEmpty_;
+  bool isLast_ = false;
 };
 
 template <typename OffsetType>
 struct VarRangeSelector {
-  ElementRange GetRange(int64_t index) const {
+  ElementRange getRange(int64_t index) const {
     return ElementRange{offsets[index], offsets[index + 1]};
   }
 
@@ -478,76 +473,76 @@ struct VarRangeSelector {
 };
 
 struct FixedSizedRangeSelector {
-  ElementRange GetRange(int64_t index) const {
-    int64_t start = index * list_size;
-    return ElementRange{start, start + list_size};
+  ElementRange getRange(int64_t index) const {
+    int64_t start = index * listSize;
+    return ElementRange{start, start + listSize};
   }
-  int list_size;
+  int listSize;
 };
 
 // An intermediate node that handles null values.
 class NullableNode {
  public:
   NullableNode(
-      const uint8_t* null_bitmap,
-      int64_t entry_offset,
-      int16_t def_level_if_null,
-      int16_t rep_level_if_null = kLevelNotSet)
-      : null_bitmap_(null_bitmap),
-        entry_offset_(entry_offset),
-        valid_bits_reader_(MakeReader(ElementRange{0, 0})),
-        def_level_if_null_(def_level_if_null),
-        rep_level_if_null_(rep_level_if_null),
-        new_range_(true) {}
-
-  void SetRepLevelIfNull(int16_t rep_level) {
-    rep_level_if_null_ = rep_level;
-  }
-
-  ::arrow::internal::BitRunReader MakeReader(const ElementRange& range) {
+      const uint8_t* nullBitmap,
+      int64_t entryOffset,
+      int16_t defLevelIfNull,
+      int16_t repLevelIfNull = kLevelNotSet)
+      : nullBitmap_(nullBitmap),
+        entryOffset_(entryOffset),
+        validBitsReader_(makeReader(ElementRange{0, 0})),
+        defLevelIfNull_(defLevelIfNull),
+        repLevelIfNull_(repLevelIfNull),
+        newRange_(true) {}
+
+  void setRepLevelIfNull(int16_t repLevel) {
+    repLevelIfNull_ = repLevel;
+  }
+
+  ::arrow::internal::BitRunReader makeReader(const ElementRange& range) {
     return ::arrow::internal::BitRunReader(
-        null_bitmap_, entry_offset_ + range.start, range.Size());
+        nullBitmap_, entryOffset_ + range.start, range.size());
   }
 
-  IterationResult Run(
+  IterationResult run(
       ElementRange* range,
-      ElementRange* child_range,
+      ElementRange* childRange,
       PathWriteContext* context) {
-    if (new_range_) {
+    if (newRange_) {
       // Reset the reader each time we are starting fresh on a range.
-      // We can't rely on continuity because nulls above can
-      // cause discontinuities.
-      valid_bits_reader_ = MakeReader(*range);
+      // We can't rely on continuity because nulls above can.
+      // Cause discontinuities.
+      validBitsReader_ = makeReader(*range);
     }
-    child_range->start = range->start;
-    ::arrow::internal::BitRun run = valid_bits_reader_.NextRun();
+    childRange->start = range->start;
+    ::arrow::internal::BitRun run = validBitsReader_.NextRun();
     if (!run.set) {
       range->start += run.length;
-      RETURN_IF_ERROR(FillRepLevels(run.length, rep_level_if_null_, context));
-      RETURN_IF_ERROR(context->AppendDefLevels(run.length, def_level_if_null_));
-      run = valid_bits_reader_.NextRun();
+      RETURN_IF_ERROR(fillRepLevels(run.length, repLevelIfNull_, context));
+      RETURN_IF_ERROR(context->appendDefLevels(run.length, defLevelIfNull_));
+      run = validBitsReader_.NextRun();
     }
-    if (range->Empty()) {
-      new_range_ = true;
+    if (range->empty()) {
+      newRange_ = true;
       return kDone;
     }
-    child_range->end = child_range->start = range->start;
-    child_range->end += run.length;
+    childRange->end = childRange->start = range->start;
+    childRange->end += run.length;
 
-    VELOX_DCHECK(!child_range->Empty());
-    range->start += child_range->Size();
-    new_range_ = false;
+    VELOX_DCHECK(!childRange->empty());
+    range->start += childRange->size();
+    newRange_ = false;
     return kNext;
   }
 
-  const uint8_t* null_bitmap_;
-  int64_t entry_offset_;
-  ::arrow::internal::BitRunReader valid_bits_reader_;
-  int16_t def_level_if_null_;
-  int16_t rep_level_if_null_;
+  const uint8_t* nullBitmap_;
+  int64_t entryOffset_;
+  ::arrow::internal::BitRunReader validBitsReader_;
+  int16_t defLevelIfNull_;
+  int16_t repLevelIfNull_;
 
   // Whether the next invocation will be a new range.
-  bool new_range_ = true;
+  bool newRange_ = true;
 };
 
 using ListNode = ListPathNode<VarRangeSelector<int32_t>>;
@@ -569,181 +564,180 @@ struct PathInfo {
       AllNullsTerminalNode>;
 
   std::vector<Node> path;
-  std::shared_ptr<Array> primitive_array;
-  int16_t max_def_level = 0;
-  int16_t max_rep_level = 0;
-  bool has_dictionary = false;
-  bool leaf_is_nullable = false;
+  std::shared_ptr<Array> primitiveArray;
+  int16_t maxDefLevel = 0;
+  int16_t maxRepLevel = 0;
+  bool hasDictionary = false;
+  bool leafIsNullable = false;
 };
 
 /// Contains logic for writing a single leaf node to parquet.
 /// This tracks the path from root to leaf.
 ///
-/// |writer| will be called after all of the definition/repetition
-/// values have been calculated for root_range with the calculated
-/// values. It is intended to abstract the complexity of writing
-/// the levels and values to parquet.
-Status WritePath(
-    ElementRange root_range,
-    PathInfo* path_info,
-    ArrowWriteContext* arrow_context,
+/// |Writer| will be called after all of the definition/repetition.
+/// Values have been calculated for root_range with the calculated.
+/// Values. It is intended to abstract the complexity of writing.
+/// The levels and values to parquet.
+Status writePath(
+    ElementRange rootRange,
+    PathInfo* pathInfo,
+    ArrowWriteContext* arrowContext,
     MultipathLevelBuilder::CallbackFunction writer) {
-  std::vector<ElementRange> stack(path_info->path.size());
-  MultipathLevelBuilderResult builder_result;
-  builder_result.leaf_array = path_info->primitive_array;
-  builder_result.leaf_is_nullable = path_info->leaf_is_nullable;
-
-  if (path_info->max_def_level == 0) {
-    // This case only occurs when there are no nullable or repeated
-    // columns in the path from the root to leaf.
-    int64_t leaf_length = builder_result.leaf_array->length();
-    builder_result.def_rep_level_count = leaf_length;
-    builder_result.post_list_visited_elements.push_back({0, leaf_length});
-    return writer(builder_result);
-  }
-  stack[0] = root_range;
-  RETURN_NOT_OK(arrow_context->def_levels_buffer->Resize(
-      /*new_size=*/0, /*shrink_to_fit*/ false));
+  std::vector<ElementRange> stack(pathInfo->path.size());
+  MultipathLevelBuilderResult builderResult;
+  builderResult.leafArray = pathInfo->primitiveArray;
+  builderResult.leafIsNullable = pathInfo->leafIsNullable;
+
+  if (pathInfo->maxDefLevel == 0) {
+    // This case only occurs when there are no nullable or repeated.
+    // Columns in the path from the root to leaf.
+    int64_t leafLength = builderResult.leafArray->length();
+    builderResult.defRepLevelCount = leafLength;
+    builderResult.postListVisitedElements.push_back({0, leafLength});
+    return writer(builderResult);
+  }
+  stack[0] = rootRange;
+  RETURN_NOT_OK(
+      arrowContext->defLevelsBuffer->Resize(0, /*shrink_to_fit*/ false));
   PathWriteContext context(
-      arrow_context->memory_pool, arrow_context->def_levels_buffer);
-  // We should need at least this many entries so reserve the space ahead of
-  // time.
-  RETURN_NOT_OK(context.def_levels.Reserve(root_range.Size()));
-  if (path_info->max_rep_level > 0) {
-    RETURN_NOT_OK(context.rep_levels.Reserve(root_range.Size()));
-  }
-
-  auto stack_base = &stack[0];
-  auto stack_position = stack_base;
-  // This is the main loop for calculated rep/def levels. The nodes
-  // in the path implement a chain-of-responsibility like pattern
-  // where each node can add some number of repetition/definition
-  // levels to PathWriteContext and also delegate to the next node
+      arrowContext->memoryPool, arrowContext->defLevelsBuffer);
+  // We should need at least this many entries so reserve the space ahead of.
+  // Time.
+  RETURN_NOT_OK(context.defLevels.Reserve(rootRange.size()));
+  if (pathInfo->maxRepLevel > 0) {
+    RETURN_NOT_OK(context.repLevels.Reserve(rootRange.size()));
+  }
+
+  auto stackBase = &stack[0];
+  auto stackPosition = stackBase;
+  // This is the main loop for calculated rep/def levels. The nodes.
+  // In the path implement a chain-of-responsibility like pattern.
+  // Where each node can add some number of repetition/definition.
+  // Levels to PathWriteContext and also delegate to the next node.
   // in the path to add values. The values are added through each Run(...)
-  // call and the choice to delegate to the next node (or return to the
-  // previous node) is communicated by the return value of Run(...).
-  // The loop terminates after the first node indicates all values in
-  // |root_range| are processed.
-  while (stack_position >= stack_base) {
-    PathInfo::Node& node = path_info->path[stack_position - stack_base];
+  // Call and the choice to delegate to the next node (or return to the.
+  // Previous node) is communicated by the return value of Run(...).
+  // The loop terminates after the first node indicates all values in.
+  // |Root_range| are processed.
+  while (stackPosition >= stackBase) {
+    PathInfo::Node& Node = pathInfo->path[stackPosition - stackBase];
     struct {
-      IterationResult operator()(NullableNode& node) {
-        return node.Run(stack_position, stack_position + 1, context);
+      IterationResult operator()(NullableNode& Node) {
+        return Node.run(stackPosition, stackPosition + 1, context);
       }
-      IterationResult operator()(ListNode& node) {
-        return node.Run(stack_position, stack_position + 1, context);
+      IterationResult operator()(ListNode& Node) {
+        return Node.run(stackPosition, stackPosition + 1, context);
       }
-      IterationResult operator()(NullableTerminalNode& node) {
-        return node.Run(*stack_position, context);
+      IterationResult operator()(NullableTerminalNode& Node) {
+        return Node.run(*stackPosition, context);
       }
-      IterationResult operator()(FixedSizeListNode& node) {
-        return node.Run(stack_position, stack_position + 1, context);
+      IterationResult operator()(FixedSizeListNode& Node) {
+        return Node.run(stackPosition, stackPosition + 1, context);
       }
-      IterationResult operator()(AllPresentTerminalNode& node) {
-        return node.Run(*stack_position, context);
+      IterationResult operator()(AllPresentTerminalNode& Node) {
+        return Node.run(*stackPosition, context);
       }
-      IterationResult operator()(AllNullsTerminalNode& node) {
-        return node.Run(*stack_position, context);
+      IterationResult operator()(AllNullsTerminalNode& Node) {
+        return Node.run(*stackPosition, context);
       }
-      IterationResult operator()(LargeListNode& node) {
-        return node.Run(stack_position, stack_position + 1, context);
+      IterationResult operator()(LargeListNode& Node) {
+        return Node.run(stackPosition, stackPosition + 1, context);
       }
-      ElementRange* stack_position;
+      ElementRange* stackPosition;
       PathWriteContext* context;
-    } visitor = {stack_position, &context};
+    } visitor = {stackPosition, &context};
 
-    IterationResult result = std::visit(visitor, node);
+    IterationResult result = std::visit(visitor, Node);
 
     if (ARROW_PREDICT_FALSE(result == kError)) {
-      VELOX_DCHECK(!context.last_status.ok());
-      return context.last_status;
+      VELOX_DCHECK(!context.lastStatus.ok());
+      return context.lastStatus;
     }
-    stack_position += static_cast<int>(result);
-  }
-  RETURN_NOT_OK(context.last_status);
-  builder_result.def_rep_level_count = context.def_levels.length();
-
-  if (context.rep_levels.length() > 0) {
-    // This case only occurs when there was a repeated element that needs to be
-    // processed.
-    builder_result.rep_levels = context.rep_levels.data();
-    std::swap(
-        builder_result.post_list_visited_elements, context.visited_elements);
-    // If it is possible when processing lists that all lists where empty. In
-    // this case no elements would have been added to
-    // post_list_visited_elements. By added an empty element we avoid special
-    // casing in downstream consumers.
-    if (builder_result.post_list_visited_elements.empty()) {
-      builder_result.post_list_visited_elements.push_back({0, 0});
+    stackPosition += static_cast<int>(result);
+  }
+  RETURN_NOT_OK(context.lastStatus);
+  builderResult.defRepLevelCount = context.defLevels.length();
+
+  if (context.repLevels.length() > 0) {
+    // This case only occurs when there was a repeated element that needs to be.
+    // Processed.
+    builderResult.repLevels = context.repLevels.data();
+    std::swap(builderResult.postListVisitedElements, context.visitedElements);
+    // If it is possible when processing lists that all lists where empty. In.
+    // This case no elements would have been added to.
+    // Post_list_visited_elements. By added an empty element we avoid special.
+    // Casing in downstream consumers.
+    if (builderResult.postListVisitedElements.empty()) {
+      builderResult.postListVisitedElements.push_back({0, 0});
     }
   } else {
-    builder_result.post_list_visited_elements.push_back(
-        {0, builder_result.leaf_array->length()});
-    builder_result.rep_levels = nullptr;
+    builderResult.postListVisitedElements.push_back(
+        {0, builderResult.leafArray->length()});
+    builderResult.repLevels = nullptr;
   }
 
-  builder_result.def_levels = context.def_levels.data();
-  return writer(builder_result);
+  builderResult.defLevels = context.defLevels.data();
+  return writer(builderResult);
 }
 
 struct FixupVisitor {
-  int max_rep_level = -1;
-  int16_t rep_level_if_null = kLevelNotSet;
+  int maxRepLevel = -1;
+  int16_t repLevelIfNull = kLevelNotSet;
 
   template <typename T>
-  void HandleListNode(T& arg) {
-    if (arg.rep_level() == max_rep_level) {
-      arg.SetLast();
-      // after the last list node we don't need to fill
-      // rep levels on null.
-      rep_level_if_null = kLevelNotSet;
+  void handleListNode(T& arg) {
+    if (arg.repLevel() == maxRepLevel) {
+      arg.setLast();
+      // After the last list node we don't need to fill.
+      // Rep levels on null.
+      repLevelIfNull = kLevelNotSet;
     } else {
-      rep_level_if_null = arg.rep_level();
+      repLevelIfNull = arg.repLevel();
     }
   }
-  void operator()(ListNode& node) {
-    HandleListNode(node);
+  void operator()(ListNode& Node) {
+    handleListNode(Node);
   }
-  void operator()(LargeListNode& node) {
-    HandleListNode(node);
+  void operator()(LargeListNode& Node) {
+    handleListNode(Node);
   }
-  void operator()(FixedSizeListNode& node) {
-    HandleListNode(node);
+  void operator()(FixedSizeListNode& Node) {
+    handleListNode(Node);
   }
 
   // For non-list intermediate nodes.
   template <typename T>
-  void HandleIntermediateNode(T& arg) {
-    if (rep_level_if_null != kLevelNotSet) {
-      arg.SetRepLevelIfNull(rep_level_if_null);
+  void handleIntermediateNode(T& arg) {
+    if (repLevelIfNull != kLevelNotSet) {
+      arg.setRepLevelIfNull(repLevelIfNull);
     }
   }
 
   void operator()(NullableNode& arg) {
-    HandleIntermediateNode(arg);
+    handleIntermediateNode(arg);
   }
 
   void operator()(AllNullsTerminalNode& arg) {
-    // Even though no processing happens past this point we
-    // still need to adjust it if a list occurred after an
-    // all null array.
-    HandleIntermediateNode(arg);
+    // Even though no processing happens past this point we.
+    // Still need to adjust it if a list occurred after an.
+    // All null array.
+    handleIntermediateNode(arg);
   }
 
   void operator()(NullableTerminalNode&) {}
   void operator()(AllPresentTerminalNode&) {}
 };
 
-PathInfo Fixup(PathInfo info) {
-  // We only need to fixup the path if there were repeated
-  // elements on it.
-  if (info.max_rep_level == 0) {
+PathInfo fixup(PathInfo info) {
+  // We only need to fixup the path if there were repeated.
+  // Elements on it.
+  if (info.maxRepLevel == 0) {
     return info;
   }
   FixupVisitor visitor;
-  visitor.max_rep_level = info.max_rep_level;
-  if (visitor.max_rep_level > 0) {
-    visitor.rep_level_if_null = 0;
+  visitor.maxRepLevel = info.maxRepLevel;
+  if (visitor.maxRepLevel > 0) {
+    visitor.repLevelIfNull = 0;
   }
   for (size_t x = 0; x < info.path.size(); x++) {
     std::visit(visitor, info.path[x]);
@@ -753,34 +747,33 @@ PathInfo Fixup(PathInfo info) {
 
 class PathBuilder {
  public:
-  explicit PathBuilder(bool start_nullable)
-      : nullable_in_parent_(start_nullable) {}
+  explicit PathBuilder(bool startNullable) : nullableInParent_(startNullable) {}
   template <typename T>
-  void AddTerminalInfo(const T& array) {
-    info_.leaf_is_nullable = nullable_in_parent_;
-    if (nullable_in_parent_) {
-      info_.max_def_level++;
+  void addTerminalInfo(const T& array) {
+    info_.leafIsNullable = nullableInParent_;
+    if (nullableInParent_) {
+      info_.maxDefLevel++;
     }
-    // We don't use null_count() because if the null_count isn't known
-    // and the array does in fact contain nulls, we will end up
-    // traversing the null bitmap twice (once here and once when calculating
-    // rep/def levels).
-    if (LazyNoNulls(array)) {
-      info_.path.emplace_back(AllPresentTerminalNode{info_.max_def_level});
-    } else if (LazyNullCount(array) == array.length()) {
-      info_.path.emplace_back(AllNullsTerminalNode(info_.max_def_level - 1));
+    // We don't use null_count() because if the null_count isn't known.
+    // And the array does in fact contain nulls, we will end up.
+    // Traversing the null bitmap twice (once here and once when calculating.
+    // Rep/def levels).
+    if (lazyNoNulls(array)) {
+      info_.path.emplace_back(AllPresentTerminalNode{info_.maxDefLevel});
+    } else if (lazyNullCount(array) == array.length()) {
+      info_.path.emplace_back(AllNullsTerminalNode(info_.maxDefLevel - 1));
     } else {
       info_.path.emplace_back(NullableTerminalNode(
-          array.null_bitmap_data(), array.offset(), info_.max_def_level));
+          array.null_bitmap_data(), array.offset(), info_.maxDefLevel));
     }
-    info_.primitive_array = std::make_shared<T>(array.data());
-    paths_.push_back(Fixup(info_));
+    info_.primitiveArray = std::make_shared<T>(array.data());
+    paths_.push_back(fixup(info_));
   }
 
   template <typename T>
   ::arrow::enable_if_t<std::is_base_of<::arrow::FlatArray, T>::value, Status>
   Visit(const T& array) {
-    AddTerminalInfo(array);
+    addTerminalInfo(array);
     return Status::OK();
   }
 
@@ -790,23 +783,23 @@ class PathBuilder {
           std::is_same<::arrow::LargeListArray, T>::value,
       Status>
   Visit(const T& array) {
-    MaybeAddNullable(array);
+    maybeAddNullable(array);
     // Increment necessary due to empty lists.
-    info_.max_def_level++;
-    info_.max_rep_level++;
-    // raw_value_offsets() accounts for any slice offset.
-    ListPathNode<VarRangeSelector<typename T::offset_type>> node(
+    info_.maxDefLevel++;
+    info_.maxRepLevel++;
+    // Raw_value_offsets() accounts for any slice offset.
+    ListPathNode<VarRangeSelector<typename T::offset_type>> Node(
         VarRangeSelector<typename T::offset_type>{array.raw_value_offsets()},
-        info_.max_rep_level,
-        info_.max_def_level - 1);
-    info_.path.emplace_back(std::move(node));
-    nullable_in_parent_ = array.list_type()->value_field()->nullable();
+        info_.maxRepLevel,
+        info_.maxDefLevel - 1);
+    info_.path.emplace_back(std::move(Node));
+    nullableInParent_ = array.list_type()->value_field()->nullable();
     return VisitInline(*array.values());
   }
 
   Status Visit(const ::arrow::DictionaryArray& array) {
-    // Only currently handle DictionaryArray where the dictionary is a
-    // primitive type
+    // Only currently handle DictionaryArray where the dictionary is a.
+    // Primitive type.
     if (array.dict_type()->value_type()->num_fields() > 0) {
       return Status::NotImplemented(
           "Writing DictionaryArray with nested dictionary "
@@ -817,35 +810,35 @@ class PathBuilder {
           "Writing DictionaryArray with null encoded in dictionary "
           "type not yet supported");
     }
-    AddTerminalInfo(array);
+    addTerminalInfo(array);
     return Status::OK();
   }
 
-  void MaybeAddNullable(const Array& array) {
-    if (!nullable_in_parent_) {
+  void maybeAddNullable(const Array& array) {
+    if (!nullableInParent_) {
       return;
     }
-    info_.max_def_level++;
-    // We don't use null_count() because if the null_count isn't known
-    // and the array does in fact contain nulls, we will end up
-    // traversing the null bitmap twice (once here and once when calculating
-    // rep/def levels). Because this isn't terminal this might not be
-    // the right decision for structs that share the same nullable
-    // parents.
-    if (LazyNoNulls(array)) {
-      // Don't add anything because there won't be any point checking
-      // null values for the array.  There will always be at least
-      // one more array to handle nullability.
+    info_.maxDefLevel++;
+    // We don't use null_count() because if the null_count isn't known.
+    // And the array does in fact contain nulls, we will end up.
+    // Traversing the null bitmap twice (once here and once when calculating.
+    // Rep/def levels). Because this isn't terminal this might not be.
+    // The right decision for structs that share the same nullable.
+    // Parents.
+    if (lazyNoNulls(array)) {
+      // Don't add anything because there won't be any point checking.
+      // Null values for the array.  There will always be at least.
+      // One more array to handle nullability.
       return;
     }
-    if (LazyNullCount(array) == array.length()) {
-      info_.path.emplace_back(AllNullsTerminalNode(info_.max_def_level - 1));
+    if (lazyNullCount(array) == array.length()) {
+      info_.path.emplace_back(AllNullsTerminalNode(info_.maxDefLevel - 1));
       return;
     }
     info_.path.emplace_back(NullableNode(
         array.null_bitmap_data(),
         array.offset(),
-        /* def_level_if_null = */ info_.max_def_level - 1));
+        /* def_level_if_null = */ info_.maxDefLevel - 1));
   }
 
   Status VisitInline(const Array& array);
@@ -855,29 +848,29 @@ class PathBuilder {
   }
 
   Status Visit(const ::arrow::StructArray& array) {
-    MaybeAddNullable(array);
-    PathInfo info_backup = info_;
+    maybeAddNullable(array);
+    PathInfo infoBackup = info_;
     for (int x = 0; x < array.num_fields(); x++) {
-      nullable_in_parent_ = array.type()->field(x)->nullable();
+      nullableInParent_ = array.type()->field(x)->nullable();
       RETURN_NOT_OK(VisitInline(*array.field(x)));
-      info_ = info_backup;
+      info_ = infoBackup;
     }
     return Status::OK();
   }
 
   Status Visit(const ::arrow::FixedSizeListArray& array) {
-    MaybeAddNullable(array);
-    int32_t list_size = array.list_type()->list_size();
-    // Technically we could encode fixed size lists with two level encodings
-    // but since we always use 3 level encoding we increment def levels as
-    // well.
-    info_.max_def_level++;
-    info_.max_rep_level++;
+    maybeAddNullable(array);
+    int32_t listSize = array.list_type()->list_size();
+    // Technically we could encode fixed size lists with two level encodings.
+    // But since we always use 3 level encoding we increment def levels as.
+    // Well.
+    info_.maxDefLevel++;
+    info_.maxRepLevel++;
     info_.path.emplace_back(FixedSizeListNode(
-        FixedSizedRangeSelector{list_size},
-        info_.max_rep_level,
-        info_.max_def_level));
-    nullable_in_parent_ = array.list_type()->value_field()->nullable();
+        FixedSizedRangeSelector{listSize},
+        info_.maxRepLevel,
+        info_.maxDefLevel));
+    nullableInParent_ = array.list_type()->value_field()->nullable();
     if (array.offset() > 0) {
       return VisitInline(*array.values()->Slice(array.value_offset(0)));
     }
@@ -888,10 +881,10 @@ class PathBuilder {
     return VisitInline(*array.storage());
   }
 
-#define NOT_IMPLEMENTED_VISIT(ArrowTypePrefix)                             \
-  Status Visit(const ::arrow::ArrowTypePrefix##Array& array) {             \
-    return Status::NotImplemented("Level generation for " #ArrowTypePrefix \
-                                  " not supported yet");                   \
+#define NOT_IMPLEMENTED_VISIT(ArrowTypePrefix)                          \
+  Status Visit(const ::arrow::ArrowTypePrefix##Array& array) {          \
+    return Status::NotImplemented(                                      \
+        "Level generation for " #ArrowTypePrefix " not supported yet"); \
   }
 
   // Types not yet supported in Parquet.
@@ -908,7 +901,7 @@ class PathBuilder {
  private:
   PathInfo info_;
   std::vector<PathInfo> paths_;
-  bool nullable_in_parent_;
+  bool nullableInParent_;
 };
 
 Status PathBuilder::VisitInline(const Array& array) {
@@ -922,65 +915,65 @@ class MultipathLevelBuilderImpl : public MultipathLevelBuilder {
  public:
   MultipathLevelBuilderImpl(
       std::shared_ptr<::arrow::ArrayData> data,
-      std::unique_ptr<PathBuilder> path_builder)
-      : root_range_{0, data->length},
+      std::unique_ptr<PathBuilder> pathBuilder)
+      : rootRange_{0, data->length},
         data_(std::move(data)),
-        path_builder_(std::move(path_builder)) {}
+        pathBuilder_(std::move(pathBuilder)) {}
 
-  int GetLeafCount() const override {
-    return static_cast<int>(path_builder_->paths().size());
+  int getLeafCount() const override {
+    return static_cast<int>(pathBuilder_->paths().size());
   }
 
-  ::arrow::Status Write(
-      int leaf_index,
+  ::arrow::Status write(
+      int leafIndex,
       ArrowWriteContext* context,
-      CallbackFunction write_leaf_callback) override {
-    if (ARROW_PREDICT_FALSE(leaf_index < 0 || leaf_index >= GetLeafCount())) {
+      CallbackFunction writeLeafCallback) override {
+    if (ARROW_PREDICT_FALSE(leafIndex < 0 || leafIndex >= getLeafCount())) {
       return Status::Invalid(
           "Column index out of bounds (got ",
-          leaf_index,
+          leafIndex,
           ", should be "
           "between 0 and ",
-          GetLeafCount(),
+          getLeafCount(),
           ")");
     }
 
-    return WritePath(
-        root_range_,
-        &path_builder_->paths()[leaf_index],
+    return writePath(
+        rootRange_,
+        &pathBuilder_->paths()[leafIndex],
         context,
-        std::move(write_leaf_callback));
+        std::move(writeLeafCallback));
   }
 
  private:
-  ElementRange root_range_;
+  ElementRange rootRange_;
   // Reference holder to ensure the data stays valid.
   std::shared_ptr<::arrow::ArrayData> data_;
-  std::unique_ptr<PathBuilder> path_builder_;
+  std::unique_ptr<PathBuilder> pathBuilder_;
 };
 
-// static
+// Static.
 ::arrow::Result<std::unique_ptr<MultipathLevelBuilder>>
-MultipathLevelBuilder::Make(
+MultipathLevelBuilder::make(
     const ::arrow::Array& array,
-    bool array_field_nullable) {
-  auto constructor = std::make_unique<PathBuilder>(array_field_nullable);
-  RETURN_NOT_OK(VisitArrayInline(array, constructor.get()));
+    bool arrayFieldNullable) {
+  auto constructor = std::make_unique<PathBuilder>(arrayFieldNullable);
+  RETURN_NOT_OK(::arrow::VisitArrayInline(array, constructor.get()));
   return std::make_unique<MultipathLevelBuilderImpl>(
       array.data(), std::move(constructor));
 }
 
-// static
-Status MultipathLevelBuilder::Write(
+// Static.
+Status MultipathLevelBuilder::write(
     const Array& array,
-    bool array_field_nullable,
+    bool arrayFieldNullable,
     ArrowWriteContext* context,
     MultipathLevelBuilder::CallbackFunction callback) {
   ARROW_ASSIGN_OR_RAISE(
-      std::unique_ptr<MultipathLevelBuilder> builder,
-      MultipathLevelBuilder::Make(array, array_field_nullable));
-  for (int leaf_idx = 0; leaf_idx < builder->GetLeafCount(); leaf_idx++) {
-    RETURN_NOT_OK(builder->Write(leaf_idx, context, callback));
+      std::unique_ptr<MultipathLevelBuilder> Builder,
+      MultipathLevelBuilder::make(array, arrayFieldNullable));
+  for (int leafIdx = 0; leafIdx < Builder->getLeafCount(); leafIdx++) {
+    RETURN_NOT_OK(Builder->write(leafIdx, context, callback));
   }
   return Status::OK();
 }
diff --git a/velox/dwio/parquet/writer/arrow/PathInternal.h b/velox/dwio/parquet/writer/arrow/PathInternal.h
index ccf69cea5eb..55e467ddf9a 100644
--- a/velox/dwio/parquet/writer/arrow/PathInternal.h
+++ b/velox/dwio/parquet/writer/arrow/PathInternal.h
@@ -40,11 +40,11 @@ struct ArrowWriteContext;
 
 namespace arrow {
 
-// This files contain internal implementation details and should not be
-// considered part of the public API.
+// This files contain internal implementation details and should not be.
+// Considered part of the public API.
 
-// The MultipathLevelBuilder is intended to fully support all Arrow nested types
-// that map to parquet types (i.e. Everything but Unions).
+// The MultipathLevelBuilder is intended to fully support all Arrow nested
+// types. That map to parquet types (i.e. Everything but Unions).
 //
 
 /// \brief Half open range of elements in an array.
@@ -54,111 +54,111 @@ struct ElementRange {
   /// Upper bound of range (exclusive)
   int64_t end;
 
-  bool Empty() const {
+  bool empty() const {
     return start == end;
   }
 
-  int64_t Size() const {
+  int64_t size() const {
     return end - start;
   }
 };
 
-/// \brief Result for a single leaf array when running the builder on the
-/// its root.
+/// \brief Result for a single leaf array when running the builder on the.
+/// Its root.
 struct MultipathLevelBuilderResult {
-  /// \brief The Array containing only the values to write (after all nesting
-  /// has been processed.
+  /// \brief The Array containing only the values to write (after all nesting.
+  /// Has been processed.
   ///
-  /// No additional processing is done on this array (it is copied as is when
-  /// visited via a DFS).
-  std::shared_ptr<::arrow::Array> leaf_array;
+  /// No additional processing is done on this array (it is copied as is when.
+  /// Visited via a DFS).
+  std::shared_ptr<::arrow::Array> leafArray;
 
   /// \brief Might be null.
-  const int16_t* def_levels = nullptr;
+  const int16_t* defLevels = nullptr;
 
   /// \brief  Might be null.
-  const int16_t* rep_levels = nullptr;
+  const int16_t* repLevels = nullptr;
 
   /// \brief Number of items (int16_t) contained in def/rep_levels when present.
-  int64_t def_rep_level_count = 0;
+  int64_t defRepLevelCount = 0;
 
-  /// \brief Contains element ranges of the required visiting on the
-  /// descendants of the final list ancestor for any leaf node.
+  /// \brief Contains element ranges of the required visiting on the.
+  /// Descendants of the final list ancestor for any leaf node.
   ///
-  /// The algorithm will attempt to consolidate visited ranges into
-  /// the smallest number possible.
+  /// The algorithm will attempt to consolidate visited ranges into.
+  /// The smallest number possible.
   ///
-  /// This data is necessary to pass along because after producing
-  /// def-rep levels for each leaf array it is impossible to determine
-  /// which values have to be sent to parquet when a null list value
-  /// in a nullable ListArray is non-empty.
+  /// This data is necessary to pass along because after producing.
+  /// Def-rep levels for each leaf array it is impossible to determine.
+  /// Which values have to be sent to parquet when a null list value.
+  /// In a nullable ListArray is non-empty.
   ///
-  /// This allows for the parquet writing to determine which values ultimately
-  /// needs to be written.
-  std::vector<ElementRange> post_list_visited_elements;
+  /// This allows for the parquet writing to determine which values ultimately.
+  /// Needs to be written.
+  std::vector<ElementRange> postListVisitedElements;
 
   /// Whether the leaf array is nullable.
-  bool leaf_is_nullable;
+  bool leafIsNullable;
 };
 
-/// \brief Logic for being able to write out nesting (rep/def level) data that
-/// is needed for writing to parquet.
+/// \brief Logic for being able to write out nesting (rep/def level) data that.
+/// Is needed for writing to parquet.
 class PARQUET_EXPORT MultipathLevelBuilder {
  public:
-  /// \brief A callback function that will receive results from the call to
-  /// Write(...) below.  The MultipathLevelBuilderResult passed in will
-  /// only remain valid for the function call (i.e. storing it and relying
-  /// for its data to be consistent afterwards will result in undefined
-  /// behavior.
+  /// \brief A callback function that will receive results from the call to.
+  /// Write(...) below.  The MultipathLevelBuilderResult passed in will.
+  /// Only remain valid for the function call (i.e. storing it and relying.
+  /// For its data to be consistent afterwards will result in undefined.
+  /// Behavior.
   using CallbackFunction =
       std::function<::arrow::Status(const MultipathLevelBuilderResult&)>;
 
   /// \brief Determine rep/def level information for the array.
   ///
-  /// The callback will be invoked for each leaf Array that is a
-  /// descendant of array.  Each leaf array is processed in a depth
-  /// first traversal-order.
+  /// The callback will be invoked for each leaf Array that is a.
+  /// Descendant of array.  Each leaf array is processed in a depth.
+  /// First traversal-order.
   ///
   /// \param[in] array The array to process.
-  /// \param[in] array_field_nullable Whether the algorithm should consider
-  ///   the the array column as nullable (as determined by its type's parent
-  ///   field).
+  /// \param[in] array_field_nullable Whether the algorithm should consider.
+  ///   The the array column as nullable (as determined by its type's parent.
+  ///   Field).
   /// \param[in, out] context for use when allocating memory, etc.
   /// \param[out] write_leaf_callback Callback to receive results.
   /// There will be one call to the write_leaf_callback for each leaf node.
-  static ::arrow::Status Write(
+  static ::arrow::Status write(
       const ::arrow::Array& array,
-      bool array_field_nullable,
+      bool arrayFieldNullable,
       ArrowWriteContext* context,
-      CallbackFunction write_leaf_callback);
+      CallbackFunction writeLeafCallback);
 
   /// \brief Construct a new instance of the builder.
   ///
   /// \param[in] array The array to process.
-  /// \param[in] array_field_nullable Whether the algorithm should consider
-  ///   the the array column as nullable (as determined by its type's parent
-  ///   field).
-  static ::arrow::Result<std::unique_ptr<MultipathLevelBuilder>> Make(
+  /// \param[in] array_field_nullable Whether the algorithm should consider.
+  ///   The the array column as nullable (as determined by its type's parent.
+  ///   Field).
+  static ::arrow::Result<std::unique_ptr<MultipathLevelBuilder>> make(
       const ::arrow::Array& array,
-      bool array_field_nullable);
+      bool arrayFieldNullable);
 
   virtual ~MultipathLevelBuilder() = default;
 
-  /// \brief Returns the number of leaf columns that need to be written
-  /// to Parquet.
-  virtual int GetLeafCount() const = 0;
+  /// \brief Returns the number of leaf columns that need to be written.
+  /// To Parquet.
+  virtual int getLeafCount() const = 0;
 
-  /// \brief Calls write_leaf_callback with the MultipathLevelBuilderResult
-  /// corresponding to |leaf_index|.
+  /// \brief Calls write_leaf_callback with the MultipathLevelBuilderResult.
+  /// Corresponding to |leaf_index|.
   ///
-  /// \param[in] leaf_index The index of the leaf column to write.  Must be in
-  /// the range [0, GetLeafCount()]. \param[in, out] context for use when
-  /// allocating memory, etc. \param[out] write_leaf_callback Callback to
-  /// receive the result.
-  virtual ::arrow::Status Write(
-      int leaf_index,
+  /// \param[in] leaf_index The index of the leaf column to write.  Must be in.
+  /// The range [0, GetLeafCount()]. \param[in, out] context for use when.
+  /// Allocating memory, etc. \param[out] write_leaf_callback Callback to.
+  /// Receive the result.
+  virtual ::arrow::Status write(
+      int leafIndex,
       ArrowWriteContext* context,
-      CallbackFunction write_leaf_callback) = 0;
+      CallbackFunction writeLeafCallback) = 0;
 };
 
 } // namespace arrow
diff --git a/velox/dwio/parquet/writer/arrow/Platform.cpp b/velox/dwio/parquet/writer/arrow/Platform.cpp
index 66f27575d5d..c3d3e758a6e 100644
--- a/velox/dwio/parquet/writer/arrow/Platform.cpp
+++ b/velox/dwio/parquet/writer/arrow/Platform.cpp
@@ -27,7 +27,7 @@
 
 namespace facebook::velox::parquet::arrow {
 
-std::shared_ptr<::arrow::io::BufferOutputStream> CreateOutputStream(
+std::shared_ptr<::arrow::io::BufferOutputStream> createOutputStream(
     MemoryPool* pool) {
   PARQUET_ASSIGN_OR_THROW(
       auto stream,
@@ -35,7 +35,7 @@ std::shared_ptr<::arrow::io::BufferOutputStream> CreateOutputStream(
   return stream;
 }
 
-std::shared_ptr<ResizableBuffer> AllocateBuffer(
+std::shared_ptr<ResizableBuffer> allocateBuffer(
     MemoryPool* pool,
     int64_t size) {
   PARQUET_ASSIGN_OR_THROW(
diff --git a/velox/dwio/parquet/writer/arrow/Platform.h b/velox/dwio/parquet/writer/arrow/Platform.h
index 467d2364bf7..f3ac272ca80 100644
--- a/velox/dwio/parquet/writer/arrow/Platform.h
+++ b/velox/dwio/parquet/writer/arrow/Platform.h
@@ -31,14 +31,14 @@
 
 #if defined(_MSC_VER)
 #pragma warning(push)
-// Disable warning for STL types usage in DLL interface
+// Disable warning for STL types usage in DLL interface.
 // https://web.archive.org/web/20130317015847/http://connect.microsoft.com/VisualStudio/feedback/details/696593/vc-10-vs-2010-basic-string-exports
 #pragma warning(disable : 4275 4251)
-// Disable diamond inheritance warnings
+// Disable diamond inheritance warnings.
 #pragma warning(disable : 4250)
-// Disable macro redefinition warnings
+// Disable macro redefinition warnings.
 #pragma warning(disable : 4005)
-// Disable extern before exported template warnings
+// Disable extern before exported template warnings.
 #pragma warning(disable : 4910)
 #else
 #pragma GCC diagnostic ignored "-Wattributes"
@@ -79,7 +79,7 @@
 #define PARQUET_DEPRECATED ARROW_DEPRECATED
 
 // If ARROW_VALGRIND set when compiling unit tests, also define
-// PARQUET_VALGRIND
+// PARQUET_VALGRIND.
 #ifdef ARROW_VALGRIND
 #define PARQUET_VALGRIND
 #endif
@@ -100,11 +100,11 @@ constexpr int64_t kDefaultOutputStreamSize = 1024;
 constexpr int16_t kNonPageOrdinal = static_cast<int16_t>(-1);
 
 PARQUET_EXPORT
-std::shared_ptr<::arrow::io::BufferOutputStream> CreateOutputStream(
+std::shared_ptr<::arrow::io::BufferOutputStream> createOutputStream(
     ::arrow::MemoryPool* pool = ::arrow::default_memory_pool());
 
 PARQUET_EXPORT
-std::shared_ptr<ResizableBuffer> AllocateBuffer(
+std::shared_ptr<ResizableBuffer> allocateBuffer(
     ::arrow::MemoryPool* pool = ::arrow::default_memory_pool(),
     int64_t size = 0);
 
diff --git a/velox/dwio/parquet/writer/arrow/Properties.cpp b/velox/dwio/parquet/writer/arrow/Properties.cpp
index c7588e79973..dc8e49bf63d 100644
--- a/velox/dwio/parquet/writer/arrow/Properties.cpp
+++ b/velox/dwio/parquet/writer/arrow/Properties.cpp
@@ -27,32 +27,32 @@
 
 namespace facebook::velox::parquet::arrow {
 
-ReaderProperties default_reader_properties() {
-  static ReaderProperties default_reader_properties;
-  return default_reader_properties;
+ReaderProperties defaultReaderProperties() {
+  static ReaderProperties defaultReaderProperties;
+  return defaultReaderProperties;
 }
 
-std::shared_ptr<ArrowInputStream> ReaderProperties::GetStream(
+std::shared_ptr<ArrowInputStream> ReaderProperties::getStream(
     std::shared_ptr<ArrowInputFile> source,
     int64_t start,
-    int64_t num_bytes) {
-  if (buffered_stream_enabled_) {
-    // ARROW-6180 / PARQUET-1636 Create isolated reader that references segment
-    // of source
+    int64_t numBytes) {
+  if (bufferedStreamEnabled_) {
+    // ARROW-6180 / PARQUET-1636 Create isolated reader that references segment.
+    // Of source.
     PARQUET_ASSIGN_OR_THROW(
-        std::shared_ptr<::arrow::io::InputStream> safe_stream,
-        ::arrow::io::RandomAccessFile::GetStream(source, start, num_bytes));
+        std::shared_ptr<::arrow::io::InputStream> safeStream,
+        ::arrow::io::RandomAccessFile::GetStream(source, start, numBytes));
     PARQUET_ASSIGN_OR_THROW(
         auto stream,
         ::arrow::io::BufferedInputStream::Create(
-            buffer_size_, pool_, safe_stream, num_bytes));
+            bufferSize_, pool_, safeStream, numBytes));
     return std::move(stream);
   } else {
-    PARQUET_ASSIGN_OR_THROW(auto data, source->ReadAt(start, num_bytes));
+    PARQUET_ASSIGN_OR_THROW(auto data, source->ReadAt(start, numBytes));
 
-    if (data->size() != num_bytes) {
+    if (data->size() != numBytes) {
       std::stringstream ss;
-      ss << "Tried reading " << num_bytes << " bytes starting at position "
+      ss << "Tried reading " << numBytes << " bytes starting at position "
          << start << " from file but only got " << data->size();
       throw ParquetException(ss.str());
     }
@@ -65,15 +65,15 @@ ::arrow::internal::Executor* ArrowWriterProperties::executor() const {
                               : ::arrow::internal::GetCpuThreadPool();
 }
 
-ArrowReaderProperties default_arrow_reader_properties() {
-  static ArrowReaderProperties default_reader_props;
-  return default_reader_props;
+ArrowReaderProperties defaultArrowReaderProperties() {
+  static ArrowReaderProperties defaultReaderProps;
+  return defaultReaderProps;
 }
 
-std::shared_ptr<ArrowWriterProperties> default_arrow_writer_properties() {
-  static std::shared_ptr<ArrowWriterProperties> default_writer_properties =
+std::shared_ptr<ArrowWriterProperties> defaultArrowWriterProperties() {
+  static std::shared_ptr<ArrowWriterProperties> defaultWriterProperties =
       ArrowWriterProperties::Builder().build();
-  return default_writer_properties;
+  return defaultWriterProperties;
 }
 
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/Properties.h b/velox/dwio/parquet/writer/arrow/Properties.h
index 815e2c7d6f5..60cd17ff426 100644
--- a/velox/dwio/parquet/writer/arrow/Properties.h
+++ b/velox/dwio/parquet/writer/arrow/Properties.h
@@ -34,7 +34,7 @@
 #include "velox/dwio/parquet/writer/arrow/Types.h"
 #include "velox/dwio/parquet/writer/arrow/util/Compression.h"
 
-// Define the parquet created by version.
+// Define the Parquet created by version.
 #define CREATED_BY_VERSION "parquet-cpp-velox"
 // Velox has no versioning yet. Set default 0.0.0.
 #define VELOX_VERSION "0.0.0"
@@ -43,7 +43,7 @@ namespace facebook::velox::parquet::arrow {
 
 using facebook::velox::parquet::arrow::util::CodecOptions;
 
-/// \brief Feature selection when writing Parquet files
+/// \brief Feature selection when writing Parquet files.
 ///
 /// `ParquetVersion::type` governs which data types are allowed and how they
 /// are represented. For example, uint32_t data will be written differently
@@ -55,21 +55,20 @@ using facebook::velox::parquet::arrow::util::CodecOptions;
 /// ArrowWriterProperties.
 struct ParquetVersion {
   enum type : int {
-    /// Enable only pre-2.2 Parquet format features when writing
+    /// Enable only pre-2.2 Parquet format features when writing.
     ///
     /// This setting is useful for maximum compatibility with legacy readers.
-    /// Note that logical types may still be emitted, as long they have a
-    /// corresponding converted type.
+    /// Corresponds to a converted type.
     PARQUET_1_0,
 
-    /// DEPRECATED: Enable Parquet format 2.6 features
+    /// DEPRECATED: Enable Parquet format 2.6 features.
     ///
     /// This misleadingly named enum value is roughly similar to PARQUET_2_6.
     PARQUET_2_0 ARROW_DEPRECATED_ENUM_VALUE(
         "use PARQUET_2_4 or PARQUET_2_6 "
         "for fine-grained feature selection"),
 
-    /// Enable Parquet format 2.4 and earlier features when writing
+    /// Enable Parquet format 2.4 and earlier features when writing.
     ///
     /// This enables UINT32 as well as logical types which don't have
     /// a corresponding converted type.
@@ -77,23 +76,21 @@ struct ParquetVersion {
     /// Note: Parquet format 2.4.0 was released in October 2017.
     PARQUET_2_4,
 
-    /// Enable Parquet format 2.6 and earlier features when writing
+    /// Enable Parquet format 2.6 and earlier features when writing.
     ///
-    /// This enables the NANOS time unit in addition to the PARQUET_2_4
-    /// features.
+    /// units in addition to the PARQUET_2_4 features.
     ///
     /// Note: Parquet format 2.6.0 was released in September 2018.
     PARQUET_2_6,
 
-    /// Enable latest Parquet format 2.x features
+    /// Enable latest Parquet format 2.x features.
     ///
-    /// This value is equal to the greatest 2.x version supported by
-    /// this library.
+    /// The version supported by this library.
     PARQUET_2_LATEST = PARQUET_2_6
   };
 };
 
-/// Controls serialization format of data pages.  parquet-format v2.0.0
+/// Controls serialization format of data pages. Parquet-format v2.0.0
 /// introduced a new data page metadata type DataPageV2 and serialized page
 /// structure (for example, encoded levels are no longer compressed). Prior to
 /// the completion of PARQUET-457 in 2020, this library did not implement
@@ -117,96 +114,96 @@ class PARQUET_EXPORT ReaderProperties {
   explicit ReaderProperties(MemoryPool* pool = ::arrow::default_memory_pool())
       : pool_(pool) {}
 
-  MemoryPool* memory_pool() const {
+  MemoryPool* memoryPool() const {
     return pool_;
   }
 
-  std::shared_ptr<ArrowInputStream> GetStream(
+  std::shared_ptr<ArrowInputStream> getStream(
       std::shared_ptr<ArrowInputFile> source,
       int64_t start,
-      int64_t num_bytes);
+      int64_t numBytes);
 
   /// Buffered stream reading allows the user to control the memory usage of
-  /// parquet readers. This ensure that all `RandomAccessFile::ReadAt` calls are
-  /// wrapped in a buffered reader that uses a fix sized buffer (of size
-  /// `buffer_size()`) instead of the full size of the ReadAt.
+  /// Parquet readers. This ensure that all `RandomAccessFile::ReadAt` calls
+  /// are wrapped in a buffered reader that uses a fix sized buffer (of size
+  /// `bufferSize()`) instead of the full size of the ReadAt.
   ///
-  /// The primary reason for this control knobs is for resource control and not
+  /// The primary reason for this control knob is for resource control and not
   /// performance.
-  bool is_buffered_stream_enabled() const {
-    return buffered_stream_enabled_;
+  bool isBufferedStreamEnabled() const {
+    return bufferedStreamEnabled_;
   }
   /// Enable buffered stream reading.
-  void enable_buffered_stream() {
-    buffered_stream_enabled_ = true;
+  void enableBufferedStream() {
+    bufferedStreamEnabled_ = true;
   }
   /// Disable buffered stream reading.
-  void disable_buffered_stream() {
-    buffered_stream_enabled_ = false;
+  void disableBufferedStream() {
+    bufferedStreamEnabled_ = false;
   }
 
   /// Return the size of the buffered stream buffer.
-  int64_t buffer_size() const {
-    return buffer_size_;
+  int64_t bufferSize() const {
+    return bufferSize_;
   }
   /// Set the size of the buffered stream buffer in bytes.
-  void set_buffer_size(int64_t size) {
-    buffer_size_ = size;
+  void setBufferSize(int64_t size) {
+    bufferSize_ = size;
   }
 
   /// \brief Return the size limit on thrift strings.
   ///
   /// This limit helps prevent space and time bombs in files, but may need to
   /// be increased in order to read files with especially large headers.
-  int32_t thrift_string_size_limit() const {
-    return thrift_string_size_limit_;
+  int32_t thriftStringSizeLimit() const {
+    return thriftStringSizeLimit_;
   }
   /// Set the size limit on thrift strings.
-  void set_thrift_string_size_limit(int32_t size) {
-    thrift_string_size_limit_ = size;
+  void setThriftStringSizeLimit(int32_t size) {
+    thriftStringSizeLimit_ = size;
   }
 
   /// \brief Return the size limit on thrift containers.
   ///
   /// This limit helps prevent space and time bombs in files, but may need to
   /// be increased in order to read files with especially large headers.
-  int32_t thrift_container_size_limit() const {
-    return thrift_container_size_limit_;
+  int32_t thriftContainerSizeLimit() const {
+    return thriftContainerSizeLimit_;
   }
   /// Set the size limit on thrift containers.
-  void set_thrift_container_size_limit(int32_t size) {
-    thrift_container_size_limit_ = size;
+  void setThriftContainerSizeLimit(int32_t size) {
+    thriftContainerSizeLimit_ = size;
   }
 
   /// Set the decryption properties.
-  void file_decryption_properties(
+  void setFileDecryptionProperties(
       std::shared_ptr<FileDecryptionProperties> decryption) {
-    file_decryption_properties_ = std::move(decryption);
+    fileDecryptionProperties_ = std::move(decryption);
   }
   /// Return the decryption properties.
-  const std::shared_ptr<FileDecryptionProperties>& file_decryption_properties()
+  const std::shared_ptr<FileDecryptionProperties>& fileDecryptionProperties()
       const {
-    return file_decryption_properties_;
+    return fileDecryptionProperties_;
   }
 
-  bool page_checksum_verification() const {
-    return page_checksum_verification_;
+  bool pageChecksumVerification() const {
+    return pageChecksumVerification_;
   }
-  void set_page_checksum_verification(bool check_crc) {
-    page_checksum_verification_ = check_crc;
+  void setPageChecksumVerification(bool checkCrc) {
+    pageChecksumVerification_ = checkCrc;
   }
 
  private:
   MemoryPool* pool_;
-  int64_t buffer_size_ = kDefaultBufferSize;
-  int32_t thrift_string_size_limit_ = kDefaultThriftStringSizeLimit;
-  int32_t thrift_container_size_limit_ = kDefaultThriftContainerSizeLimit;
-  bool buffered_stream_enabled_ = false;
-  bool page_checksum_verification_ = false;
-  std::shared_ptr<FileDecryptionProperties> file_decryption_properties_;
+  int64_t bufferSize_ = kDefaultBufferSize;
+  int32_t thriftStringSizeLimit_ = kDefaultThriftStringSizeLimit;
+  int32_t thriftContainerSizeLimit_ = kDefaultThriftContainerSizeLimit;
+  bool bufferedStreamEnabled_ = false;
+  bool pageChecksumVerification_ = false;
+  std::shared_ptr<FileDecryptionProperties> fileDecryptionProperties_;
 };
 
-ReaderProperties PARQUET_EXPORT default_reader_properties();
+ReaderProperties PARQUET_EXPORT defaultReaderProperties();
 
 static constexpr int64_t kDefaultDataPageSize = 1024 * 1024;
 static constexpr bool DEFAULT_IS_DICTIONARY_ENABLED = true;
@@ -216,7 +213,7 @@ static constexpr int64_t DEFAULT_WRITE_BATCH_SIZE = 1024;
 static constexpr int64_t DEFAULT_MAX_ROW_GROUP_LENGTH = 1024 * 1024;
 static constexpr bool DEFAULT_ARE_STATISTICS_ENABLED = true;
 static constexpr int64_t DEFAULT_MAX_STATISTICS_SIZE = 4096;
-static constexpr Encoding::type DEFAULT_ENCODING = Encoding::UNKNOWN;
+static constexpr Encoding::type DEFAULT_ENCODING = Encoding::kUnknown;
 static const char DEFAULT_CREATED_BY[] = CREATED_BY_VERSION;
 static constexpr Compression::type DEFAULT_COMPRESSION_TYPE =
     Compression::UNCOMPRESSED;
@@ -227,50 +224,50 @@ class PARQUET_EXPORT ColumnProperties {
   ColumnProperties(
       Encoding::type encoding = DEFAULT_ENCODING,
       Compression::type codec = DEFAULT_COMPRESSION_TYPE,
-      bool dictionary_enabled = DEFAULT_IS_DICTIONARY_ENABLED,
-      bool statistics_enabled = DEFAULT_ARE_STATISTICS_ENABLED,
-      size_t max_stats_size = DEFAULT_MAX_STATISTICS_SIZE,
-      bool page_index_enabled = DEFAULT_IS_PAGE_INDEX_ENABLED)
+      bool dictionaryEnabled = DEFAULT_IS_DICTIONARY_ENABLED,
+      bool statisticsEnabled = DEFAULT_ARE_STATISTICS_ENABLED,
+      size_t maxStatsSize = DEFAULT_MAX_STATISTICS_SIZE,
+      bool pageIndexEnabled = DEFAULT_IS_PAGE_INDEX_ENABLED)
       : encoding_(encoding),
         codec_(codec),
-        dictionary_enabled_(dictionary_enabled),
-        statistics_enabled_(statistics_enabled),
-        max_stats_size_(max_stats_size),
-        page_index_enabled_(page_index_enabled) {}
+        dictionaryEnabled_(dictionaryEnabled),
+        statisticsEnabled_(statisticsEnabled),
+        maxStatsSize_(maxStatsSize),
+        pageIndexEnabled_(pageIndexEnabled) {}
 
-  void set_encoding(Encoding::type encoding) {
+  void setEncoding(Encoding::type encoding) {
     encoding_ = encoding;
   }
 
-  void set_compression(Compression::type codec) {
+  void setCompression(Compression::type codec) {
     codec_ = codec;
   }
 
-  void set_dictionary_enabled(bool dictionary_enabled) {
-    dictionary_enabled_ = dictionary_enabled;
+  void setDictionaryEnabled(bool dictionaryEnabled) {
+    dictionaryEnabled_ = dictionaryEnabled;
   }
 
-  void set_statistics_enabled(bool statistics_enabled) {
-    statistics_enabled_ = statistics_enabled;
+  void setStatisticsEnabled(bool statisticsEnabled) {
+    statisticsEnabled_ = statisticsEnabled;
   }
 
-  void set_max_statistics_size(size_t max_stats_size) {
-    max_stats_size_ = max_stats_size;
+  void setMaxStatisticsSize(size_t maxStatsSize) {
+    maxStatsSize_ = maxStatsSize;
   }
 
-  void set_compression_level(int compression_level) {
-    if (!codec_options_) {
-      codec_options_ = std::make_shared<CodecOptions>();
+  void setCompressionLevel(int compressionLevel) {
+    if (!codecOptions_) {
+      codecOptions_ = std::make_shared<CodecOptions>();
     }
-    codec_options_->compression_level = compression_level;
+    codecOptions_->compressionLevel = compressionLevel;
   }
 
-  void set_codec_options(const std::shared_ptr<CodecOptions>& codec_options) {
-    codec_options_ = codec_options;
+  void setCodecOptions(const std::shared_ptr<CodecOptions>& codecOptions) {
+    codecOptions_ = codecOptions;
   }
 
-  void set_page_index_enabled(bool page_index_enabled) {
-    page_index_enabled_ = page_index_enabled;
+  void setPageIndexEnabled(bool pageIndexEnabled) {
+    pageIndexEnabled_ = pageIndexEnabled;
   }
 
   Encoding::type encoding() const {
@@ -281,38 +278,38 @@ class PARQUET_EXPORT ColumnProperties {
     return codec_;
   }
 
-  bool dictionary_enabled() const {
-    return dictionary_enabled_;
+  bool dictionaryEnabled() const {
+    return dictionaryEnabled_;
   }
 
-  bool statistics_enabled() const {
-    return statistics_enabled_;
+  bool statisticsEnabled() const {
+    return statisticsEnabled_;
   }
 
-  size_t max_statistics_size() const {
-    return max_stats_size_;
+  size_t maxStatisticsSize() const {
+    return maxStatsSize_;
   }
 
-  int compression_level() const {
-    return codec_options_->compression_level;
+  int compressionLevel() const {
+    return codecOptions_->compressionLevel;
   }
 
-  const std::shared_ptr<CodecOptions>& codec_options() const {
-    return codec_options_;
+  const std::shared_ptr<CodecOptions>& codecOptions() const {
+    return codecOptions_;
   }
 
-  bool page_index_enabled() const {
-    return page_index_enabled_;
+  bool pageIndexEnabled() const {
+    return pageIndexEnabled_;
   }
 
  private:
   Encoding::type encoding_;
   Compression::type codec_;
-  bool dictionary_enabled_;
-  bool statistics_enabled_;
-  size_t max_stats_size_;
-  std::shared_ptr<CodecOptions> codec_options_;
-  bool page_index_enabled_;
+  bool dictionaryEnabled_;
+  bool statisticsEnabled_;
+  size_t maxStatsSize_;
+  std::shared_ptr<CodecOptions> codecOptions_;
+  bool pageIndexEnabled_;
 };
 
 class PARQUET_EXPORT WriterProperties {
@@ -321,95 +318,94 @@ class PARQUET_EXPORT WriterProperties {
    public:
     Builder()
         : pool_(::arrow::default_memory_pool()),
-          dictionary_pagesize_limit_(DEFAULT_DICTIONARY_PAGE_SIZE_LIMIT),
-          write_batch_size_(DEFAULT_WRITE_BATCH_SIZE),
-          max_row_group_length_(DEFAULT_MAX_ROW_GROUP_LENGTH),
+          dictionaryPagesizeLimit_(DEFAULT_DICTIONARY_PAGE_SIZE_LIMIT),
+          writeBatchSize_(DEFAULT_WRITE_BATCH_SIZE),
+          maxRowGroupLength_(DEFAULT_MAX_ROW_GROUP_LENGTH),
           pagesize_(kDefaultDataPageSize),
           version_(ParquetVersion::PARQUET_2_6),
-          data_page_version_(ParquetDataPageVersion::V1),
-          created_by_(
+          dataPageVersion_(ParquetDataPageVersion::V1),
+          createdBy_(
               DEFAULT_CREATED_BY + std::string(" version ") + VELOX_VERSION),
-          store_decimal_as_integer_(false),
-          page_checksum_enabled_(false) {}
+          storeDecimalAsInteger_(false),
+          pageChecksumEnabled_(false) {}
     virtual ~Builder() {}
 
     /// Specify the memory pool for the writer. Default default_memory_pool.
-    Builder* memory_pool(MemoryPool* pool) {
+    Builder* memoryPool(MemoryPool* pool) {
       pool_ = pool;
       return this;
     }
 
     /// Enable dictionary encoding in general for all columns. Default enabled.
-    Builder* enable_dictionary() {
-      default_column_properties_.set_dictionary_enabled(true);
+    Builder* enableDictionary() {
+      defaultColumnProperties_.setDictionaryEnabled(true);
       return this;
     }
 
     /// Disable dictionary encoding in general for all columns. Default enabled.
-    Builder* disable_dictionary() {
-      default_column_properties_.set_dictionary_enabled(false);
+    Builder* disableDictionary() {
+      defaultColumnProperties_.setDictionaryEnabled(false);
       return this;
     }
 
     /// Enable dictionary encoding for column specified by `path`. Default
     /// enabled.
-    Builder* enable_dictionary(const std::string& path) {
-      dictionary_enabled_[path] = true;
+    Builder* enableDictionary(const std::string& path) {
+      dictionaryEnabled_[path] = true;
       return this;
     }
 
     /// Enable dictionary encoding for column specified by `path`. Default
     /// enabled.
-    Builder* enable_dictionary(
-        const std::shared_ptr<schema::ColumnPath>& path) {
-      return this->enable_dictionary(path->ToDotString());
+    Builder* enableDictionary(const std::shared_ptr<schema::ColumnPath>& path) {
+      return this->enableDictionary(path->toDotString());
     }
 
     /// Disable dictionary encoding for column specified by `path`. Default
     /// enabled.
-    Builder* disable_dictionary(const std::string& path) {
-      dictionary_enabled_[path] = false;
+    Builder* disableDictionary(const std::string& path) {
+      dictionaryEnabled_[path] = false;
       return this;
     }
 
     /// Disable dictionary encoding for column specified by `path`. Default
     /// enabled.
-    Builder* disable_dictionary(
+    Builder* disableDictionary(
         const std::shared_ptr<schema::ColumnPath>& path) {
-      return this->disable_dictionary(path->ToDotString());
+      return this->disableDictionary(path->toDotString());
     }
 
     /// Specify the dictionary page size limit per row group. Default 1MB.
-    Builder* dictionary_pagesize_limit(int64_t dictionary_psize_limit) {
-      dictionary_pagesize_limit_ = dictionary_psize_limit;
+    Builder* dictionaryPagesizeLimit(int64_t dictionaryPsizeLimit) {
+      dictionaryPagesizeLimit_ = dictionaryPsizeLimit;
       return this;
     }
 
     /// Specify the write batch size while writing batches of Arrow values into
     /// Parquet. Default 1024.
-    Builder* write_batch_size(int64_t write_batch_size) {
-      write_batch_size_ = write_batch_size;
+    Builder* writeBatchSize(int64_t writeBatchSize) {
+      writeBatchSize_ = writeBatchSize;
       return this;
     }
 
     /// Specify the max number of rows to put in a single row group.
     /// Default 1Mi rows.
-    Builder* max_row_group_length(int64_t max_row_group_length) {
-      max_row_group_length_ = max_row_group_length;
+    Builder* maxRowGroupLength(int64_t maxRowGroupLength) {
+      maxRowGroupLength_ = maxRowGroupLength;
       return this;
     }
 
     /// Specify the data page size.
     /// Default 1MB.
-    Builder* data_pagesize(int64_t pg_size) {
-      pagesize_ = pg_size;
+    Builder* dataPagesize(int64_t pgSize) {
+      pagesize_ = pgSize;
       return this;
     }
 
     /// Specify the data page version.
     /// Default V1.
-    Builder* data_page_version(ParquetDataPageVersion data_page_version) {
-      data_page_version_ = data_page_version;
+    Builder* dataPageVersion(ParquetDataPageVersion dataPageVersion) {
+      dataPageVersion_ = dataPageVersion;
       return this;
     }
 
@@ -420,75 +416,75 @@ class PARQUET_EXPORT WriterProperties {
       return this;
     }
 
-    Builder* created_by(const std::string& created_by) {
-      created_by_ = created_by;
+    Builder* createdBy(const std::string& createdBy) {
+      createdBy_ = createdBy;
       return this;
     }
 
-    Builder* enable_page_checksum() {
-      page_checksum_enabled_ = true;
+    Builder* enablePageChecksum() {
+      pageChecksumEnabled_ = true;
       return this;
     }
 
-    Builder* disable_page_checksum() {
-      page_checksum_enabled_ = false;
+    Builder* disablePageChecksum() {
+      pageChecksumEnabled_ = false;
       return this;
     }
 
-    /// \brief Define the encoding that is used when we don't utilise dictionary
-    /// encoding.
+    /// \brief Define the encoding that is used when we don't utilise
+    /// dictionary encoding.
     //
-    /// This either apply if dictionary encoding is disabled or if we fallback
-    /// as the dictionary grew too large.
-    Builder* encoding(Encoding::type encoding_type) {
-      if (encoding_type == Encoding::PLAIN_DICTIONARY ||
-          encoding_type == Encoding::RLE_DICTIONARY) {
+    /// This either applies if dictionary encoding is disabled or if we
+    /// fallback because the dictionary grew too large.
+    Builder* encoding(Encoding::type encodingType) {
+      if (encodingType == Encoding::kPlainDictionary ||
+          encodingType == Encoding::kRleDictionary) {
         throw ParquetException(
             "Can't use dictionary encoding as fallback encoding");
       }
 
-      default_column_properties_.set_encoding(encoding_type);
+      defaultColumnProperties_.setEncoding(encodingType);
       return this;
     }
 
-    /// \brief Define the encoding that is used when we don't utilise dictionary
-    /// encoding.
+    /// \brief Define the encoding that is used when we don't utilise
+    /// dictionary encoding.
     //
-    /// This either apply if dictionary encoding is disabled or if we fallback
-    /// as the dictionary grew too large.
-    Builder* encoding(const std::string& path, Encoding::type encoding_type) {
-      if (encoding_type == Encoding::PLAIN_DICTIONARY ||
-          encoding_type == Encoding::RLE_DICTIONARY) {
+    /// This either applies if dictionary encoding is disabled or if we
+    /// fallback because the dictionary grew too large.
+    Builder* encoding(const std::string& path, Encoding::type encodingType) {
+      if (encodingType == Encoding::kPlainDictionary ||
+          encodingType == Encoding::kRleDictionary) {
         throw ParquetException(
             "Can't use dictionary encoding as fallback encoding");
       }
 
-      encodings_[path] = encoding_type;
+      encodings_[path] = encodingType;
       return this;
     }
 
-    /// \brief Define the encoding that is used when we don't utilise dictionary
-    /// encoding.
+    /// \brief Define the encoding that is used when we don't utilise
+    /// dictionary encoding.
     //
-    /// This either apply if dictionary encoding is disabled or if we fallback
-    /// as the dictionary grew too large.
+    /// This either applies if dictionary encoding is disabled or if we
+    /// fallback because the dictionary grew too large.
     Builder* encoding(
         const std::shared_ptr<schema::ColumnPath>& path,
-        Encoding::type encoding_type) {
-      return this->encoding(path->ToDotString(), encoding_type);
+        Encoding::type encodingType) {
+      return this->encoding(path->toDotString(), encodingType);
     }
 
     /// Specify compression codec in general for all columns.
     /// Default UNCOMPRESSED.
     Builder* compression(Compression::type codec) {
-      default_column_properties_.set_compression(codec);
+      defaultColumnProperties_.setCompression(codec);
       return this;
     }
 
     /// Specify max statistics size to store min max value.
     /// Default 4KB.
-    Builder* max_statistics_size(size_t max_stats_sz) {
-      default_column_properties_.set_max_statistics_size(max_stats_sz);
+    Builder* maxStatisticsSize(size_t maxStatsSz) {
+      defaultColumnProperties_.setMaxStatisticsSize(maxStatsSz);
       return this;
     }
 
@@ -504,126 +500,125 @@ class PARQUET_EXPORT WriterProperties {
     Builder* compression(
         const std::shared_ptr<schema::ColumnPath>& path,
         Compression::type codec) {
-      return this->compression(path->ToDotString(), codec);
+      return this->compression(path->toDotString(), codec);
     }
 
-    /// \brief Specify the default compression level for the compressor in
-    /// every column.  In case a column does not have an explicitly specified
-    /// compression level, the default one would be used.
+    /// \brief Specify the default compression level for the compressor
+    /// in every column. In case a column does not have an explicitly
+    /// specified compression level, the default one would be used.
     ///
-    /// The provided compression level is compressor specific. The user would
-    /// have to familiarize oneself with the available levels for the selected
-    /// compressor.  If the compressor does not allow for selecting different
-    /// compression levels, calling this function would not have any effect.
-    /// Parquet and Arrow do not validate the passed compression level.  If no
-    /// level is selected by the user or if the special
-    /// std::numeric_limits<int>::min() value is passed, then Arrow selects the
-    /// compression level.
+    /// The provided compression level is compressor specific. The user
+    /// would have to familiarize oneself with the available levels for
+    /// the selected compressor. If the compressor does not allow for
+    /// selecting different compression levels, calling this function
+    /// would not have any effect. Parquet and Arrow do not validate the
+    /// passed compression level. If no level is selected by the user or
+    /// if the special std::numeric_limits<int>::min() value is passed,
+    /// then Arrow selects the compression level.
     ///
-    /// If other compressor-specific options need to be set in addition to the
-    /// compression level, use the codec_options method.
-    Builder* compression_level(int compression_level) {
-      default_column_properties_.set_compression_level(compression_level);
+    /// If other compressor-specific options need to be set in addition
+    /// to the compression level, use the codec_options method.
+    Builder* compressionLevel(int compressionLevel) {
+      defaultColumnProperties_.setCompressionLevel(compressionLevel);
       return this;
     }
 
-    /// \brief Specify a compression level for the compressor for the column
-    /// described by path.
+    /// \brief Specify a compression level for the compressor for the
+    /// column described by path.
     ///
-    /// The provided compression level is compressor specific. The user would
-    /// have to familiarize oneself with the available levels for the selected
-    /// compressor.  If the compressor does not allow for selecting different
-    /// compression levels, calling this function would not have any effect.
-    /// Parquet and Arrow do not validate the passed compression level.  If no
-    /// level is selected by the user or if the special
-    /// std::numeric_limits<int>::min() value is passed, then Arrow selects the
-    /// compression level.
-    Builder* compression_level(const std::string& path, int compression_level) {
-      if (!codec_options_[path]) {
-        codec_options_[path] = std::make_shared<CodecOptions>();
+    /// The provided compression level is compressor specific. The user
+    /// would have to familiarize oneself with the available levels for
+    /// the selected compressor. If the compressor does not allow for
+    /// selecting different compression levels, calling this function
+    /// would not have any effect. Parquet and Arrow do not validate the
+    /// passed compression level. If no level is selected by the user or
+    /// if the special std::numeric_limits<int>::min() value is passed,
+    /// then Arrow selects the compression level.
+    Builder* compressionLevel(const std::string& path, int compressionLevel) {
+      if (!codecOptions_[path]) {
+        codecOptions_[path] = std::make_shared<CodecOptions>();
       }
-      codec_options_[path]->compression_level = compression_level;
+      codecOptions_[path]->compressionLevel = compressionLevel;
       return this;
     }
 
-    /// \brief Specify a compression level for the compressor for the column
-    /// described by path.
+    /// \brief Specify a compression level for the compressor for the
+    /// column described by path.
     ///
-    /// The provided compression level is compressor specific. The user would
-    /// have to familiarize oneself with the available levels for the selected
-    /// compressor.  If the compressor does not allow for selecting different
-    /// compression levels, calling this function would not have any effect.
-    /// Parquet and Arrow do not validate the passed compression level.  If no
-    /// level is selected by the user or if the special
-    /// std::numeric_limits<int>::min() value is passed, then Arrow selects the
-    /// compression level.
-    Builder* compression_level(
+    /// The provided compression level is compressor specific. The user
+    /// would have to familiarize oneself with the available levels for
+    /// the selected compressor. If the compressor does not allow for
+    /// selecting different compression levels, calling this function
+    /// would not have any effect. Parquet and Arrow do not validate the
+    /// passed compression level. If no level is selected by the user or
+    /// if the special std::numeric_limits<int>::min() value is passed,
+    /// then Arrow selects the compression level.
+    Builder* compressionLevel(
         const std::shared_ptr<schema::ColumnPath>& path,
-        int compression_level) {
-      return this->compression_level(path->ToDotString(), compression_level);
+        int compressionLevel) {
+      return this->compressionLevel(path->toDotString(), compressionLevel);
     }
 
     /// \brief Specify the default codec options for the compressor in
     /// every column.
     ///
-    /// The codec options allow configuring the compression level as well
-    /// as other codec-specific options.
-    Builder* codec_options(const std::shared_ptr<CodecOptions>& codec_options) {
-      default_column_properties_.set_codec_options(codec_options);
+    /// The codec options allow configuring the compression level as
+    /// well as other codec-specific options.
+    Builder* codecOptions(const std::shared_ptr<CodecOptions>& codecOptions) {
+      defaultColumnProperties_.setCodecOptions(codecOptions);
       return this;
     }
 
-    /// \brief Specify the codec options for the compressor for the column
-    /// described by path.
-    Builder* codec_options(
+    /// \brief Specify the codec options for the compressor for the
+    /// column described by path.
+    Builder* codecOptions(
         const std::string& path,
-        const std::shared_ptr<CodecOptions>& codec_options) {
-      codec_options_[path] = codec_options;
+        const std::shared_ptr<CodecOptions>& codecOptions) {
+      codecOptions_[path] = codecOptions;
       return this;
     }
 
-    /// \brief Specify the codec options for the compressor for the column
-    /// described by path.
-    Builder* codec_options(
+    /// \brief Specify the codec options for the compressor for the
+    /// column described by path.
+    Builder* codecOptions(
         const std::shared_ptr<schema::ColumnPath>& path,
-        const std::shared_ptr<CodecOptions>& codec_options) {
-      return this->codec_options(path->ToDotString(), codec_options);
+        const std::shared_ptr<CodecOptions>& codecOptions) {
+      return this->codecOptions(path->toDotString(), codecOptions);
     }
 
     /// Define the file encryption properties.
     /// Default NULL.
     Builder* encryption(
-        std::shared_ptr<FileEncryptionProperties> file_encryption_properties) {
-      file_encryption_properties_ = std::move(file_encryption_properties);
+        std::shared_ptr<FileEncryptionProperties> fileEncryptionProperties) {
+      fileEncryptionProperties_ = std::move(fileEncryptionProperties);
       return this;
     }
 
     /// Enable statistics in general.
     /// Default enabled.
-    Builder* enable_statistics() {
-      default_column_properties_.set_statistics_enabled(true);
+    Builder* enableStatistics() {
+      defaultColumnProperties_.setStatisticsEnabled(true);
       return this;
     }
 
     /// Disable statistics in general.
     /// Default enabled.
-    Builder* disable_statistics() {
-      default_column_properties_.set_statistics_enabled(false);
+    Builder* disableStatistics() {
+      defaultColumnProperties_.setStatisticsEnabled(false);
       return this;
     }
 
     /// Enable statistics for the column specified by `path`.
     /// Default enabled.
-    Builder* enable_statistics(const std::string& path) {
-      statistics_enabled_[path] = true;
+    Builder* enableStatistics(const std::string& path) {
+      statisticsEnabled_[path] = true;
       return this;
     }
 
     /// Enable statistics for the column specified by `path`.
     /// Default enabled.
-    Builder* enable_statistics(
-        const std::shared_ptr<schema::ColumnPath>& path) {
-      return this->enable_statistics(path->ToDotString());
+    Builder* enableStatistics(const std::shared_ptr<schema::ColumnPath>& path) {
+      return this->enableStatistics(path->toDotString());
     }
 
     /// Define the sorting columns.
@@ -632,307 +627,312 @@ class PARQUET_EXPORT WriterProperties {
     /// If sorting columns are set, user should ensure that records
     /// are sorted by sorting columns. Otherwise, the storing data
     /// will be inconsistent with sorting_columns metadata.
-    Builder* set_sorting_columns(std::vector<SortingColumn> sorting_columns) {
-      sorting_columns_ = std::move(sorting_columns);
+    Builder* setSortingColumns(std::vector<SortingColumn> sortingColumns) {
+      sortingColumns_ = std::move(sortingColumns);
       return this;
     }
 
     /// Disable statistics for the column specified by `path`.
     /// Default enabled.
-    Builder* disable_statistics(const std::string& path) {
-      statistics_enabled_[path] = false;
+    Builder* disableStatistics(const std::string& path) {
+      statisticsEnabled_[path] = false;
       return this;
     }
 
     /// Disable statistics for the column specified by `path`.
     /// Default enabled.
-    Builder* disable_statistics(
+    Builder* disableStatistics(
         const std::shared_ptr<schema::ColumnPath>& path) {
-      return this->disable_statistics(path->ToDotString());
+      return this->disableStatistics(path->toDotString());
     }
 
-    /// Allow decimals with 1 <= precision <= 18 to be stored as integers.
+    /// Allow decimals with 1 <= precision <= 18 to be stored as
+    /// integers.
     ///
-    /// In Parquet, DECIMAL can be stored in any of the following physical
-    /// types:
-    /// - int32: for 1 <= precision <= 9.
-    /// - int64: for 10 <= precision <= 18.
-    /// - fixed_len_byte_array: precision is limited by the array size.
-    ///   Length n can store <= floor(log_10(2^(8*n - 1) - 1)) base-10 digits.
-    /// - binary: precision is unlimited. The minimum number of bytes to store
+    /// In Parquet, DECIMAL can be stored in any of the following
+    /// physical types:
+    /// - Int32: For 1 <= precision <= 9.
+    /// - Int64: For 10 <= precision <= 18.
+    /// - Fixed_len_byte_array: Precision is limited by the array size.
+    ///   Length n can store <= floor(log_10(2^(8*n - 1) - 1)) base-10
+    ///   digits.
+    /// - Binary: Precision is unlimited. The minimum number of bytes to
+    /// store
     ///   the unscaled value is used.
     ///
-    /// By default, this is DISABLED and all decimal types annotate
-    /// fixed_len_byte_array.
+    /// By default, this is DISABLED and all decimal types annotate.
+    /// Fixed_len_byte_array.
     ///
-    /// When enabled, the C++ writer will use following physical types to store
-    /// decimals:
-    /// - int32: for 1 <= precision <= 9.
-    /// - int64: for 10 <= precision <= 18.
-    /// - fixed_len_byte_array: for precision > 18.
+    /// When enabled, the C++ writer will use following physical types
+    /// to store decimals:
+    /// - Int32: For 1 <= precision <= 9.
+    /// - Int64: For 10 <= precision <= 18.
+    /// - Fixed_len_byte_array: For precision > 18.
     ///
-    /// As a consequence, decimal columns stored in integer types are more
-    /// compact.
-    Builder* enable_store_decimal_as_integer() {
-      store_decimal_as_integer_ = true;
+    /// As a consequence, decimal columns stored in integer types are
+    /// more compact.
+    Builder* enableStoreDecimalAsInteger() {
+      storeDecimalAsInteger_ = true;
       return this;
     }
 
-    /// Disable decimal logical type with 1 <= precision <= 18 to be stored as
-    /// integer physical type.
+    /// Disable decimal logical type with 1 <= precision <= 18 to be
+    /// stored as integer physical type.
     ///
     /// Default disabled.
-    Builder* disable_store_decimal_as_integer() {
-      store_decimal_as_integer_ = false;
+    Builder* disableStoreDecimalAsInteger() {
+      storeDecimalAsInteger_ = false;
       return this;
     }
 
-    /// Enable writing page index in general for all columns. Default disabled.
+    /// Enable writing page index in general for all columns. Default
+    /// disabled.
     ///
-    /// Writing statistics to the page index disables the old method of writing
-    /// statistics to each data page header.
-    /// The page index makes filtering more efficient than the page header, as
-    /// it gathers all the statistics for a Parquet file in a single place,
+    /// Writing statistics to the page index disables the old method of
+    /// writing statistics to each data page header. The page index
+    /// makes filtering more efficient than the page header, as it
+    /// gathers all the statistics for a Parquet file in a single place,
     /// avoiding scattered I/O.
     ///
     /// Please check the link below for more details:
     /// https://github.com/apache/parquet-format/blob/master/PageIndex.md
-    Builder* enable_write_page_index() {
-      default_column_properties_.set_page_index_enabled(true);
+    Builder* enableWritePageIndex() {
+      defaultColumnProperties_.setPageIndexEnabled(true);
       return this;
     }
 
-    /// Disable writing page index in general for all columns. Default disabled.
-    Builder* disable_write_page_index() {
-      default_column_properties_.set_page_index_enabled(false);
+    /// Disable writing page index in general for all columns. Default
+    /// disabled.
+    Builder* disableWritePageIndex() {
+      defaultColumnProperties_.setPageIndexEnabled(false);
       return this;
     }
 
-    /// Enable writing page index for column specified by `path`. Default
-    /// disabled.
-    Builder* enable_write_page_index(const std::string& path) {
-      page_index_enabled_[path] = true;
+    /// Enable writing page index for column specified by `path`.
+    /// Default disabled.
+    Builder* enableWritePageIndex(const std::string& path) {
+      pageIndexEnabled_[path] = true;
       return this;
     }
 
-    /// Enable writing page index for column specified by `path`. Default
-    /// disabled.
-    Builder* enable_write_page_index(
+    /// Enable writing page index for column specified by `path`.
+    /// Default disabled.
+    Builder* enableWritePageIndex(
         const std::shared_ptr<schema::ColumnPath>& path) {
-      return this->enable_write_page_index(path->ToDotString());
+      return this->enableWritePageIndex(path->toDotString());
     }
 
-    /// Disable writing page index for column specified by `path`. Default
-    /// disabled.
-    Builder* disable_write_page_index(const std::string& path) {
-      page_index_enabled_[path] = false;
+    /// Disable writing page index for column specified by `path`.
+    /// Default disabled.
+    Builder* disableWritePageIndex(const std::string& path) {
+      pageIndexEnabled_[path] = false;
       return this;
     }
 
-    /// Disable writing page index for column specified by `path`. Default
-    /// disabled.
-    Builder* disable_write_page_index(
+    /// Disable writing page index for column specified by `path`.
+    /// Default disabled.
+    Builder* disableWritePageIndex(
         const std::shared_ptr<schema::ColumnPath>& path) {
-      return this->disable_write_page_index(path->ToDotString());
+      return this->disableWritePageIndex(path->toDotString());
     }
 
     /// \brief Build the WriterProperties with the builder parameters.
     /// \return The WriterProperties defined by the builder.
     std::shared_ptr<WriterProperties> build() {
-      std::unordered_map<std::string, ColumnProperties> column_properties;
+      std::unordered_map<std::string, ColumnProperties> columnProperties;
       auto get = [&](const std::string& key) -> ColumnProperties& {
-        auto it = column_properties.find(key);
-        if (it == column_properties.end())
-          return column_properties[key] = default_column_properties_;
+        auto it = columnProperties.find(key);
+        if (it == columnProperties.end())
+          return columnProperties[key] = defaultColumnProperties_;
         else
           return it->second;
       };
 
       for (const auto& item : encodings_)
-        get(item.first).set_encoding(item.second);
+        get(item.first).setEncoding(item.second);
       for (const auto& item : codecs_)
-        get(item.first).set_compression(item.second);
-      for (const auto& item : codec_options_)
-        get(item.first).set_codec_options(item.second);
-      for (const auto& item : dictionary_enabled_)
-        get(item.first).set_dictionary_enabled(item.second);
-      for (const auto& item : statistics_enabled_)
-        get(item.first).set_statistics_enabled(item.second);
-      for (const auto& item : page_index_enabled_)
-        get(item.first).set_page_index_enabled(item.second);
+        get(item.first).setCompression(item.second);
+      for (const auto& item : codecOptions_)
+        get(item.first).setCodecOptions(item.second);
+      for (const auto& item : dictionaryEnabled_)
+        get(item.first).setDictionaryEnabled(item.second);
+      for (const auto& item : statisticsEnabled_)
+        get(item.first).setStatisticsEnabled(item.second);
+      for (const auto& item : pageIndexEnabled_)
+        get(item.first).setPageIndexEnabled(item.second);
 
       return std::shared_ptr<WriterProperties>(new WriterProperties(
           pool_,
-          dictionary_pagesize_limit_,
-          write_batch_size_,
-          max_row_group_length_,
+          dictionaryPagesizeLimit_,
+          writeBatchSize_,
+          maxRowGroupLength_,
           pagesize_,
           version_,
-          created_by_,
-          page_checksum_enabled_,
-          std::move(file_encryption_properties_),
-          default_column_properties_,
-          column_properties,
-          data_page_version_,
-          store_decimal_as_integer_,
-          std::move(sorting_columns_)));
+          createdBy_,
+          pageChecksumEnabled_,
+          std::move(fileEncryptionProperties_),
+          defaultColumnProperties_,
+          columnProperties,
+          dataPageVersion_,
+          storeDecimalAsInteger_,
+          std::move(sortingColumns_)));
     }
 
    private:
     MemoryPool* pool_;
-    int64_t dictionary_pagesize_limit_;
-    int64_t write_batch_size_;
-    int64_t max_row_group_length_;
+    int64_t dictionaryPagesizeLimit_;
+    int64_t writeBatchSize_;
+    int64_t maxRowGroupLength_;
     int64_t pagesize_;
     ParquetVersion::type version_;
-    ParquetDataPageVersion data_page_version_;
-    std::string created_by_;
-    bool store_decimal_as_integer_;
-    bool page_checksum_enabled_;
+    ParquetDataPageVersion dataPageVersion_;
+    std::string createdBy_;
+    bool storeDecimalAsInteger_;
+    bool pageChecksumEnabled_;
 
-    std::shared_ptr<FileEncryptionProperties> file_encryption_properties_;
+    std::shared_ptr<FileEncryptionProperties> fileEncryptionProperties_;
 
     // If empty, there is no sorting columns.
-    std::vector<SortingColumn> sorting_columns_;
+    std::vector<SortingColumn> sortingColumns_;
 
-    // Settings used for each column unless overridden in any of the maps below
-    ColumnProperties default_column_properties_;
+    // Settings used for each column unless overridden in any of the
+    // maps below.
+    ColumnProperties defaultColumnProperties_;
     std::unordered_map<std::string, Encoding::type> encodings_;
     std::unordered_map<std::string, Compression::type> codecs_;
     std::unordered_map<std::string, std::shared_ptr<CodecOptions>>
-        codec_options_;
-    std::unordered_map<std::string, bool> dictionary_enabled_;
-    std::unordered_map<std::string, bool> statistics_enabled_;
-    std::unordered_map<std::string, bool> page_index_enabled_;
+        codecOptions_;
+    std::unordered_map<std::string, bool> dictionaryEnabled_;
+    std::unordered_map<std::string, bool> statisticsEnabled_;
+    std::unordered_map<std::string, bool> pageIndexEnabled_;
   };
 
-  inline MemoryPool* memory_pool() const {
+  inline MemoryPool* memoryPool() const {
     return pool_;
   }
 
-  inline int64_t dictionary_pagesize_limit() const {
-    return dictionary_pagesize_limit_;
+  inline int64_t dictionaryPagesizeLimit() const {
+    return dictionaryPagesizeLimit_;
   }
 
-  inline int64_t write_batch_size() const {
-    return write_batch_size_;
+  inline int64_t writeBatchSize() const {
+    return writeBatchSize_;
   }
 
-  inline int64_t max_row_group_length() const {
-    return max_row_group_length_;
+  inline int64_t maxRowGroupLength() const {
+    return maxRowGroupLength_;
   }
 
-  inline int64_t data_pagesize() const {
+  inline int64_t dataPagesize() const {
     return pagesize_;
   }
 
-  inline ParquetDataPageVersion data_page_version() const {
-    return parquet_data_page_version_;
+  inline ParquetDataPageVersion dataPageVersion() const {
+    return parquetDataPageVersion_;
   }
 
   inline ParquetVersion::type version() const {
-    return parquet_version_;
+    return parquetVersion_;
   }
 
-  inline std::string created_by() const {
-    return parquet_created_by_;
+  inline std::string createdBy() const {
+    return parquetCreatedBy_;
   }
 
-  inline bool store_decimal_as_integer() const {
-    return store_decimal_as_integer_;
+  inline bool storeDecimalAsInteger() const {
+    return storeDecimalAsInteger_;
   }
 
-  inline bool page_checksum_enabled() const {
-    return page_checksum_enabled_;
+  inline bool pageChecksumEnabled() const {
+    return pageChecksumEnabled_;
   }
 
-  inline Encoding::type dictionary_index_encoding() const {
-    if (parquet_version_ == ParquetVersion::PARQUET_1_0) {
-      return Encoding::PLAIN_DICTIONARY;
+  inline Encoding::type dictionaryIndexEncoding() const {
+    if (parquetVersion_ == ParquetVersion::PARQUET_1_0) {
+      return Encoding::kPlainDictionary;
     } else {
-      return Encoding::RLE_DICTIONARY;
+      return Encoding::kRleDictionary;
     }
   }
 
-  inline Encoding::type dictionary_page_encoding() const {
-    if (parquet_version_ == ParquetVersion::PARQUET_1_0) {
-      return Encoding::PLAIN_DICTIONARY;
+  inline Encoding::type dictionaryPageEncoding() const {
+    if (parquetVersion_ == ParquetVersion::PARQUET_1_0) {
+      return Encoding::kPlainDictionary;
     } else {
-      return Encoding::PLAIN;
+      return Encoding::kPlain;
     }
   }
 
-  const ColumnProperties& column_properties(
+  const ColumnProperties& columnProperties(
       const std::shared_ptr<schema::ColumnPath>& path) const {
-    auto it = column_properties_.find(path->ToDotString());
-    if (it != column_properties_.end())
+    auto it = columnProperties_.find(path->toDotString());
+    if (it != columnProperties_.end())
       return it->second;
-    return default_column_properties_;
+    return defaultColumnProperties_;
   }
 
   Encoding::type encoding(
       const std::shared_ptr<schema::ColumnPath>& path) const {
-    return column_properties(path).encoding();
+    return columnProperties(path).encoding();
   }
 
   Compression::type compression(
       const std::shared_ptr<schema::ColumnPath>& path) const {
-    return column_properties(path).compression();
+    return columnProperties(path).compression();
   }
 
-  int compression_level(const std::shared_ptr<schema::ColumnPath>& path) const {
-    return column_properties(path).compression_level();
+  int compressionLevel(const std::shared_ptr<schema::ColumnPath>& path) const {
+    return columnProperties(path).compressionLevel();
   }
 
-  const std::shared_ptr<CodecOptions> codec_options(
+  const std::shared_ptr<CodecOptions> codecOptions(
       const std::shared_ptr<schema::ColumnPath>& path) const {
-    return column_properties(path).codec_options();
+    return columnProperties(path).codecOptions();
   }
 
-  bool dictionary_enabled(
+  bool dictionaryEnabled(
       const std::shared_ptr<schema::ColumnPath>& path) const {
-    return column_properties(path).dictionary_enabled();
+    return columnProperties(path).dictionaryEnabled();
   }
 
-  const std::vector<SortingColumn>& sorting_columns() const {
-    return sorting_columns_;
+  const std::vector<SortingColumn>& sortingColumns() const {
+    return sortingColumns_;
   }
 
-  bool statistics_enabled(
+  bool statisticsEnabled(
       const std::shared_ptr<schema::ColumnPath>& path) const {
-    return column_properties(path).statistics_enabled();
+    return columnProperties(path).statisticsEnabled();
   }
 
-  size_t max_statistics_size(
+  size_t maxStatisticsSize(
       const std::shared_ptr<schema::ColumnPath>& path) const {
-    return column_properties(path).max_statistics_size();
+    return columnProperties(path).maxStatisticsSize();
   }
 
-  bool page_index_enabled(
-      const std::shared_ptr<schema::ColumnPath>& path) const {
-    return column_properties(path).page_index_enabled();
+  bool pageIndexEnabled(const std::shared_ptr<schema::ColumnPath>& path) const {
+    return columnProperties(path).pageIndexEnabled();
   }
 
-  bool page_index_enabled() const {
-    if (default_column_properties_.page_index_enabled()) {
+  bool pageIndexEnabled() const {
+    if (defaultColumnProperties_.pageIndexEnabled()) {
       return true;
     }
-    for (const auto& item : column_properties_) {
-      if (item.second.page_index_enabled()) {
+    for (const auto& item : columnProperties_) {
+      if (item.second.pageIndexEnabled()) {
         return true;
       }
     }
     return false;
   }
 
-  inline FileEncryptionProperties* file_encryption_properties() const {
-    return file_encryption_properties_.get();
+  inline FileEncryptionProperties* fileEncryptionProperties() const {
+    return fileEncryptionProperties_.get();
   }
 
-  std::shared_ptr<ColumnEncryptionProperties> column_encryption_properties(
+  std::shared_ptr<ColumnEncryptionProperties> columnEncryptionProperties(
       const std::string& path) const {
-    if (file_encryption_properties_) {
-      return file_encryption_properties_->column_encryption_properties(path);
+    if (fileEncryptionProperties_) {
+      return fileEncryptionProperties_->columnEncryptionProperties(path);
     } else {
       return NULLPTR;
     }
@@ -941,103 +941,103 @@ class PARQUET_EXPORT WriterProperties {
  private:
   explicit WriterProperties(
       MemoryPool* pool,
-      int64_t dictionary_pagesize_limit,
-      int64_t write_batch_size,
-      int64_t max_row_group_length,
+      int64_t dictionaryPagesizeLimit,
+      int64_t writeBatchSize,
+      int64_t maxRowGroupLength,
       int64_t pagesize,
       ParquetVersion::type version,
-      const std::string& created_by,
-      bool page_write_checksum_enabled,
-      std::shared_ptr<FileEncryptionProperties> file_encryption_properties,
-      const ColumnProperties& default_column_properties,
-      const std::unordered_map<std::string, ColumnProperties>&
-          column_properties,
-      ParquetDataPageVersion data_page_version,
-      bool store_short_decimal_as_integer,
-      std::vector<SortingColumn> sorting_columns)
+      const std::string& createdBy,
+      bool pageWriteChecksumEnabled,
+      std::shared_ptr<FileEncryptionProperties> fileEncryptionProperties,
+      const ColumnProperties& defaultColumnProperties,
+      const std::unordered_map<std::string, ColumnProperties>& columnProperties,
+      ParquetDataPageVersion dataPageVersion,
+      bool storeShortDecimalAsInteger,
+      std::vector<SortingColumn> sortingColumns)
       : pool_(pool),
-        dictionary_pagesize_limit_(dictionary_pagesize_limit),
-        write_batch_size_(write_batch_size),
-        max_row_group_length_(max_row_group_length),
+        dictionaryPagesizeLimit_(dictionaryPagesizeLimit),
+        writeBatchSize_(writeBatchSize),
+        maxRowGroupLength_(maxRowGroupLength),
         pagesize_(pagesize),
-        parquet_data_page_version_(data_page_version),
-        parquet_version_(version),
-        parquet_created_by_(created_by),
-        store_decimal_as_integer_(store_short_decimal_as_integer),
-        page_checksum_enabled_(page_write_checksum_enabled),
-        file_encryption_properties_(file_encryption_properties),
-        sorting_columns_(std::move(sorting_columns)),
-        default_column_properties_(default_column_properties),
-        column_properties_(column_properties) {}
+        parquetDataPageVersion_(dataPageVersion),
+        parquetVersion_(version),
+        parquetCreatedBy_(createdBy),
+        storeDecimalAsInteger_(storeShortDecimalAsInteger),
+        pageChecksumEnabled_(pageWriteChecksumEnabled),
+        fileEncryptionProperties_(std::move(fileEncryptionProperties)),
+        sortingColumns_(std::move(sortingColumns)),
+        defaultColumnProperties_(defaultColumnProperties),
+        columnProperties_(columnProperties) {}
 
   MemoryPool* pool_;
-  int64_t dictionary_pagesize_limit_;
-  int64_t write_batch_size_;
-  int64_t max_row_group_length_;
+  int64_t dictionaryPagesizeLimit_;
+  int64_t writeBatchSize_;
+  int64_t maxRowGroupLength_;
   int64_t pagesize_;
-  ParquetDataPageVersion parquet_data_page_version_;
-  ParquetVersion::type parquet_version_;
-  std::string parquet_created_by_;
-  bool store_decimal_as_integer_;
-  bool page_checksum_enabled_;
+  ParquetDataPageVersion parquetDataPageVersion_;
+  ParquetVersion::type parquetVersion_;
+  std::string parquetCreatedBy_;
+  bool storeDecimalAsInteger_;
+  bool pageChecksumEnabled_;
 
-  std::shared_ptr<FileEncryptionProperties> file_encryption_properties_;
+  std::shared_ptr<FileEncryptionProperties> fileEncryptionProperties_;
 
-  std::vector<SortingColumn> sorting_columns_;
+  std::vector<SortingColumn> sortingColumns_;
 
-  ColumnProperties default_column_properties_;
-  std::unordered_map<std::string, ColumnProperties> column_properties_;
+  ColumnProperties defaultColumnProperties_;
+  std::unordered_map<std::string, ColumnProperties> columnProperties_;
 };
 
 PARQUET_EXPORT const std::shared_ptr<WriterProperties>&
-default_writer_properties();
+defaultWriterProperties();
 
-// ----------------------------------------------------------------------
-// Properties specific to Apache Arrow columnar read and write
+// ----------------------------------------------------------------------.
+// Properties specific to Apache Arrow columnar read and write.
 
 static constexpr bool kArrowDefaultUseThreads = false;
 
-// Default number of rows to read when using ::arrow::RecordBatchReader
+// Default number of rows to read when using ::arrow::RecordBatchReader.
 static constexpr int64_t kArrowDefaultBatchSize = 64 * 1024;
 
 /// EXPERIMENTAL: Properties for configuring FileReader behavior.
 class PARQUET_EXPORT ArrowReaderProperties {
  public:
-  explicit ArrowReaderProperties(bool use_threads = kArrowDefaultUseThreads)
-      : use_threads_(use_threads),
-        read_dict_indices_(),
-        batch_size_(kArrowDefaultBatchSize),
-        pre_buffer_(false),
-        cache_options_(::arrow::io::CacheOptions::Defaults()),
-        coerce_int96_timestamp_unit_(::arrow::TimeUnit::NANO) {}
-
-  /// \brief Set whether to use the IO thread pool to parse columns in parallel.
+  explicit ArrowReaderProperties(bool useThreads = kArrowDefaultUseThreads)
+      : useThreads_(useThreads),
+        readDictIndices_(),
+        batchSize_(kArrowDefaultBatchSize),
+        preBuffer_(false),
+        cacheOptions_(::arrow::io::CacheOptions::Defaults()),
+        coerceInt96TimestampUnit_(::arrow::TimeUnit::NANO) {}
+
+  /// \brief Set whether to use the IO thread pool to parse columns in
+  /// parallel.
   ///
   /// Default is false.
-  void set_use_threads(bool use_threads) {
-    use_threads_ = use_threads;
+  void setUseThreads(bool useThreads) {
+    useThreads_ = useThreads;
   }
   /// Return whether will use multiple threads.
-  bool use_threads() const {
-    return use_threads_;
+  bool useThreads() const {
+    return useThreads_;
   }
 
-  /// \brief Set whether to read a particular column as dictionary encoded.
+  /// \brief Set whether to read a particular column as dictionary
+  /// encoded.
   ///
-  /// If the file metadata contains a serialized Arrow schema, then ...
-  ////
-  /// This is only supported for columns with a Parquet physical type of
+  /// If the file metadata contains a serialized Arrow schema, then this
+  /// is only supported for columns with a Parquet physical type of
   /// BYTE_ARRAY, such as string or binary types.
-  void set_read_dictionary(int column_index, bool read_dict) {
-    if (read_dict) {
-      read_dict_indices_.insert(column_index);
+  void setReadDictionary(int columnIndex, bool readDict) {
+    if (readDict) {
+      readDictIndices_.insert(columnIndex);
     } else {
-      read_dict_indices_.erase(column_index);
+      readDictIndices_.erase(columnIndex);
     }
   }
   /// Return whether the column at the index will be read as dictionary.
-  bool read_dictionary(int column_index) const {
-    if (read_dict_indices_.find(column_index) != read_dict_indices_.end()) {
+  bool readDictionary(int columnIndex) const {
+    if (readDictIndices_.find(columnIndex) != readDictIndices_.end()) {
       return true;
     } else {
       return false;
@@ -1048,71 +1048,71 @@ class PARQUET_EXPORT ArrowReaderProperties {
   ///
   /// Will only be fewer rows when there are no more rows in the file.
   /// Note that some APIs such as ReadTable may ignore this setting.
-  void set_batch_size(int64_t batch_size) {
-    batch_size_ = batch_size;
+  void setBatchSize(int64_t batchSize) {
+    batchSize_ = batchSize;
   }
   /// Return the batch size in rows.
   ///
   /// Note that some APIs such as ReadTable may ignore this setting.
-  int64_t batch_size() const {
-    return batch_size_;
+  int64_t batchSize() const {
+    return batchSize_;
   }
 
   /// Enable read coalescing (default false).
   ///
-  /// When enabled, the Arrow reader will pre-buffer necessary regions
-  /// of the file in-memory. This is intended to improve performance on
-  /// high-latency filesystems (e.g. Amazon S3).
-  void set_pre_buffer(bool pre_buffer) {
-    pre_buffer_ = pre_buffer;
+  /// When enabled, the Arrow reader will pre-buffer necessary regions.
+  /// Of the file in-memory. This is intended to improve performance on.
+  /// High-latency filesystems (e.g. Amazon S3).
+  void setPreBuffer(bool preBuffer) {
+    preBuffer_ = preBuffer;
   }
   /// Return whether read coalescing is enabled.
-  bool pre_buffer() const {
-    return pre_buffer_;
+  bool preBuffer() const {
+    return preBuffer_;
   }
 
-  /// Set options for read coalescing. This can be used to tune the
-  /// implementation for characteristics of different filesystems.
-  void set_cache_options(::arrow::io::CacheOptions options) {
-    cache_options_ = options;
+  /// Set options for read coalescing. This can be used to tune the.
+  /// Implementation for characteristics of different filesystems.
+  void setCacheOptions(::arrow::io::CacheOptions options) {
+    cacheOptions_ = options;
   }
   /// Return the options for read coalescing.
-  const ::arrow::io::CacheOptions& cache_options() const {
-    return cache_options_;
+  const ::arrow::io::CacheOptions& cacheOptions() const {
+    return cacheOptions_;
   }
 
   /// Set execution context for read coalescing.
-  void set_io_context(const ::arrow::io::IOContext& ctx) {
-    io_context_ = ctx;
+  void setIoContext(const ::arrow::io::IOContext& ctx) {
+    ioContext_ = ctx;
   }
   /// Return the execution context used for read coalescing.
-  const ::arrow::io::IOContext& io_context() const {
-    return io_context_;
+  const ::arrow::io::IOContext& ioContext() const {
+    return ioContext_;
   }
 
-  /// Set timestamp unit to use for deprecated INT96-encoded timestamps
-  /// (default is NANO).
-  void set_coerce_int96_timestamp_unit(::arrow::TimeUnit::type unit) {
-    coerce_int96_timestamp_unit_ = unit;
+  /// Set timestamp unit to use for deprecated INT96-encoded timestamps.
+  /// (Default is NANO).
+  void setCoerceInt96TimestampUnit(::arrow::TimeUnit::type unit) {
+    coerceInt96TimestampUnit_ = unit;
   }
 
-  ::arrow::TimeUnit::type coerce_int96_timestamp_unit() const {
-    return coerce_int96_timestamp_unit_;
+  ::arrow::TimeUnit::type coerceInt96TimestampUnit() const {
+    return coerceInt96TimestampUnit_;
   }
 
  private:
-  bool use_threads_;
-  std::unordered_set<int> read_dict_indices_;
-  int64_t batch_size_;
-  bool pre_buffer_;
-  ::arrow::io::IOContext io_context_;
-  ::arrow::io::CacheOptions cache_options_;
-  ::arrow::TimeUnit::type coerce_int96_timestamp_unit_;
+  bool useThreads_;
+  std::unordered_set<int> readDictIndices_;
+  int64_t batchSize_;
+  bool preBuffer_;
+  ::arrow::io::IOContext ioContext_;
+  ::arrow::io::CacheOptions cacheOptions_;
+  ::arrow::TimeUnit::type coerceInt96TimestampUnit_;
 };
 
-/// EXPERIMENTAL: Constructs the default ArrowReaderProperties
+/// EXPERIMENTAL: Constructs the default ArrowReaderProperties.
 PARQUET_EXPORT
-ArrowReaderProperties default_arrow_reader_properties();
+ArrowReaderProperties defaultArrowReaderProperties();
 
 class PARQUET_EXPORT ArrowWriterProperties {
  public:
@@ -1123,106 +1123,110 @@ class PARQUET_EXPORT ArrowWriterProperties {
   class Builder {
    public:
     Builder()
-        : write_timestamps_as_int96_(false),
-          coerce_timestamps_enabled_(false),
-          coerce_timestamps_unit_(::arrow::TimeUnit::SECOND),
-          truncated_timestamps_allowed_(false),
-          store_schema_(false),
-          compliant_nested_types_(true),
-          engine_version_(V2),
-          use_threads_(kArrowDefaultUseThreads),
+        : writeTimestampsAsInt96_(false),
+          coerceTimestampsEnabled_(false),
+          coerceTimestampsUnit_(::arrow::TimeUnit::SECOND),
+          truncatedTimestampsAllowed_(false),
+          storeSchema_(false),
+          compliantNestedTypes_(true),
+          engineVersion_(V2),
+          useThreads_(kArrowDefaultUseThreads),
           executor_(NULLPTR) {}
     virtual ~Builder() = default;
 
-    /// \brief Disable writing legacy int96 timestamps (default disabled).
-    Builder* disable_deprecated_int96_timestamps() {
-      write_timestamps_as_int96_ = false;
+    /// \brief Disable writing legacy int96 timestamps (default
+    /// disabled).
+    Builder* disableDeprecatedInt96Timestamps() {
+      writeTimestampsAsInt96_ = false;
       return this;
     }
 
-    /// \brief Enable writing legacy int96 timestamps (default disabled).
+    /// \brief Enable writing legacy int96 timestamps (default
+    /// disabled).
     ///
-    /// May be turned on to write timestamps compatible with older Parquet
-    /// writers. This takes precedent over coerce_timestamps.
-    Builder* enable_deprecated_int96_timestamps() {
-      write_timestamps_as_int96_ = true;
+    /// May be turned on to write timestamps compatible with older
+    /// Parquet writers. This takes precedent over coerceTimestamps.
+    Builder* enableDeprecatedInt96Timestamps() {
+      writeTimestampsAsInt96_ = true;
       return this;
     }
 
     /// \brief Coerce all timestamps to the specified time unit.
     /// \param unit time unit to truncate to.
-    /// For Parquet versions 1.0 and 2.4, nanoseconds are casted to
-    /// microseconds.
-    Builder* coerce_timestamps(::arrow::TimeUnit::type unit) {
-      coerce_timestamps_enabled_ = true;
-      coerce_timestamps_unit_ = unit;
+    /// For Parquet versions 1.0 and 2.4, nanoseconds are casted to.
+    /// Microseconds.
+    Builder* coerceTimestamps(::arrow::TimeUnit::type unit) {
+      coerceTimestampsEnabled_ = true;
+      coerceTimestampsUnit_ = unit;
       return this;
     }
 
     /// \brief Allow loss of data when truncating timestamps.
     ///
     /// This is disallowed by default and an error will be returned.
-    Builder* allow_truncated_timestamps() {
-      truncated_timestamps_allowed_ = true;
+    Builder* allowTruncatedTimestamps() {
+      truncatedTimestampsAllowed_ = true;
       return this;
     }
 
-    /// \brief Disallow loss of data when truncating timestamps (default).
-    Builder* disallow_truncated_timestamps() {
-      truncated_timestamps_allowed_ = false;
+    /// \brief Disallow loss of data when truncating timestamps
+    /// (default).
+    Builder* disallowTruncatedTimestamps() {
+      truncatedTimestampsAllowed_ = false;
       return this;
     }
 
-    /// \brief EXPERIMENTAL: Write binary serialized Arrow schema to the file,
-    /// to enable certain read options (like "read_dictionary") to be set
-    /// automatically
-    Builder* store_schema() {
-      store_schema_ = true;
+    /// \brief EXPERIMENTAL: Write binary serialized Arrow schema to the
+    /// file, to enable certain read options (like "read_dictionary") to
+    /// be set automatically.
+    Builder* storeSchema() {
+      storeSchema_ = true;
       return this;
     }
 
-    /// \brief When enabled, will not preserve Arrow field names for list types.
+    /// \brief When enabled, will not preserve Arrow field names for
+    /// list types.
     ///
-    /// Instead of using the field names Arrow uses for the values array of
-    /// list types (default "item"), will use "element", as is specified in
-    /// the Parquet spec.
+    /// Instead of using the field names Arrow uses for the values array
+    /// of. List types (default "item"), will use "element", as is
+    /// specified in. The Parquet spec.
     ///
     /// This is enabled by default.
-    Builder* enable_compliant_nested_types() {
-      compliant_nested_types_ = true;
+    Builder* enableCompliantNestedTypes() {
+      compliantNestedTypes_ = true;
       return this;
     }
 
     /// Preserve Arrow list field name.
-    Builder* disable_compliant_nested_types() {
-      compliant_nested_types_ = false;
+    Builder* disableCompliantNestedTypes() {
+      compliantNestedTypes_ = false;
       return this;
     }
 
     /// Set the version of the Parquet writer engine.
-    Builder* set_engine_version(EngineVersion version) {
-      engine_version_ = version;
+    Builder* setEngineVersion(EngineVersion version) {
+      engineVersion_ = version;
       return this;
     }
 
-    /// \brief Set whether to use multiple threads to write columns
-    /// in parallel in the buffered row group mode.
+    /// \brief Set whether to use multiple threads to write columns.
+    /// In parallel in the buffered row group mode.
     ///
-    /// WARNING: If writing multiple files in parallel in the same
-    /// executor, deadlock may occur if use_threads is true. Please
-    /// disable it in this case.
+    /// WARNING: If writing multiple files in parallel in the same.
+    /// Executor, deadlock may occur if use_threads is true. Please.
+    /// Disable it in this case.
     ///
     /// Default is false.
-    Builder* set_use_threads(bool use_threads) {
-      use_threads_ = use_threads;
+    Builder* setUseThreads(bool useThreads) {
+      useThreads_ = useThreads;
       return this;
     }
 
-    /// \brief Set the executor to write columns in parallel in the
-    /// buffered row group mode.
+    /// \brief Set the executor to write columns in parallel in the.
+    /// Buffered row group mode.
     ///
     /// Default is nullptr and the default cpu executor will be used.
-    Builder* set_executor(::arrow::internal::Executor* executor) {
+    Builder* setExecutor(::arrow::internal::Executor* executor) {
       executor_ = executor;
       return this;
     }
@@ -1230,72 +1234,74 @@ class PARQUET_EXPORT ArrowWriterProperties {
     /// Create the final properties.
     std::shared_ptr<ArrowWriterProperties> build() {
       return std::shared_ptr<ArrowWriterProperties>(new ArrowWriterProperties(
-          write_timestamps_as_int96_,
-          coerce_timestamps_enabled_,
-          coerce_timestamps_unit_,
-          truncated_timestamps_allowed_,
-          store_schema_,
-          compliant_nested_types_,
-          engine_version_,
-          use_threads_,
+          writeTimestampsAsInt96_,
+          coerceTimestampsEnabled_,
+          coerceTimestampsUnit_,
+          truncatedTimestampsAllowed_,
+          storeSchema_,
+          compliantNestedTypes_,
+          engineVersion_,
+          useThreads_,
           executor_));
     }
 
    private:
-    bool write_timestamps_as_int96_;
+    bool writeTimestampsAsInt96_;
 
-    bool coerce_timestamps_enabled_;
-    ::arrow::TimeUnit::type coerce_timestamps_unit_;
-    bool truncated_timestamps_allowed_;
+    bool coerceTimestampsEnabled_;
+    ::arrow::TimeUnit::type coerceTimestampsUnit_;
+    bool truncatedTimestampsAllowed_;
 
-    bool store_schema_;
-    bool compliant_nested_types_;
-    EngineVersion engine_version_;
+    bool storeSchema_;
+    bool compliantNestedTypes_;
+    EngineVersion engineVersion_;
 
-    bool use_threads_;
+    bool useThreads_;
     ::arrow::internal::Executor* executor_;
   };
 
-  bool support_deprecated_int96_timestamps() const {
-    return write_timestamps_as_int96_;
+  bool supportDeprecatedInt96Timestamps() const {
+    return writeTimestampsAsInt96_;
   }
 
-  bool coerce_timestamps_enabled() const {
-    return coerce_timestamps_enabled_;
+  bool coerceTimestampsEnabled() const {
+    return coerceTimestampsEnabled_;
   }
-  ::arrow::TimeUnit::type coerce_timestamps_unit() const {
-    return coerce_timestamps_unit_;
+  ::arrow::TimeUnit::type coerceTimestampsUnit() const {
+    return coerceTimestampsUnit_;
   }
 
-  bool truncated_timestamps_allowed() const {
-    return truncated_timestamps_allowed_;
+  bool truncatedTimestampsAllowed() const {
+    return truncatedTimestampsAllowed_;
   }
 
-  bool store_schema() const {
-    return store_schema_;
+  bool storeSchema() const {
+    return storeSchema_;
   }
 
-  /// \brief Enable nested type naming according to the parquet specification.
+  /// \brief Enable nested type naming according to the parquet
+  /// specification.
   ///
-  /// Older versions of arrow wrote out field names for nested lists based on
-  /// the name of the field.  According to the parquet specification they should
-  /// always be "element".
-  bool compliant_nested_types() const {
-    return compliant_nested_types_;
+  /// Older versions of arrow wrote out field names for nested lists
+  /// based on the name of the field. According to the Parquet
+  /// specification they should always be "element".
+  bool compliantNestedTypes() const {
+    return compliantNestedTypes_;
   }
 
-  /// \brief The underlying engine version to use when writing Arrow data.
+  /// \brief The underlying engine version to use when writing Arrow
+  /// data.
   ///
-  /// V2 is currently the latest V1 is considered deprecated but left in
-  /// place in case there are bugs detected in V2.
-  EngineVersion engine_version() const {
-    return engine_version_;
+  /// V2 is currently the latest V1 is considered deprecated but left
+  /// in. Place in case there are bugs detected in V2.
+  EngineVersion engineVersion() const {
+    return engineVersion_;
   }
 
-  /// \brief Returns whether the writer will use multiple threads
-  /// to write columns in parallel in the buffered row group mode.
-  bool use_threads() const {
-    return use_threads_;
+  /// \brief Returns whether the writer will use multiple threads.
+  /// To write columns in parallel in the buffered row group mode.
+  bool useThreads() const {
+    return useThreads_;
   }
 
   /// \brief Returns the executor used to write columns in parallel.
@@ -1303,65 +1309,64 @@ class PARQUET_EXPORT ArrowWriterProperties {
 
  private:
   explicit ArrowWriterProperties(
-      bool write_nanos_as_int96,
-      bool coerce_timestamps_enabled,
-      ::arrow::TimeUnit::type coerce_timestamps_unit,
-      bool truncated_timestamps_allowed,
-      bool store_schema,
-      bool compliant_nested_types,
-      EngineVersion engine_version,
-      bool use_threads,
+      bool writeNanosAsInt96,
+      bool coerceTimestampsEnabled,
+      ::arrow::TimeUnit::type coerceTimestampsUnit,
+      bool truncatedTimestampsAllowed,
+      bool storeSchema,
+      bool compliantNestedTypes,
+      EngineVersion engineVersion,
+      bool useThreads,
       ::arrow::internal::Executor* executor)
-      : write_timestamps_as_int96_(write_nanos_as_int96),
-        coerce_timestamps_enabled_(coerce_timestamps_enabled),
-        coerce_timestamps_unit_(coerce_timestamps_unit),
-        truncated_timestamps_allowed_(truncated_timestamps_allowed),
-        store_schema_(store_schema),
-        compliant_nested_types_(compliant_nested_types),
-        engine_version_(engine_version),
-        use_threads_(use_threads),
+      : writeTimestampsAsInt96_(writeNanosAsInt96),
+        coerceTimestampsEnabled_(coerceTimestampsEnabled),
+        coerceTimestampsUnit_(coerceTimestampsUnit),
+        truncatedTimestampsAllowed_(truncatedTimestampsAllowed),
+        storeSchema_(storeSchema),
+        compliantNestedTypes_(compliantNestedTypes),
+        engineVersion_(engineVersion),
+        useThreads_(useThreads),
         executor_(executor) {}
 
-  const bool write_timestamps_as_int96_;
-  const bool coerce_timestamps_enabled_;
-  const ::arrow::TimeUnit::type coerce_timestamps_unit_;
-  const bool truncated_timestamps_allowed_;
-  const bool store_schema_;
-  const bool compliant_nested_types_;
-  const EngineVersion engine_version_;
-  const bool use_threads_;
+  const bool writeTimestampsAsInt96_;
+  const bool coerceTimestampsEnabled_;
+  const ::arrow::TimeUnit::type coerceTimestampsUnit_;
+  const bool truncatedTimestampsAllowed_;
+  const bool storeSchema_;
+  const bool compliantNestedTypes_;
+  const EngineVersion engineVersion_;
+  const bool useThreads_;
   ::arrow::internal::Executor* executor_;
 };
 
-/// \brief State object used for writing Arrow data directly to a Parquet
-/// column chunk. API possibly not stable
+/// \brief State object used for writing Arrow data directly to a
+/// Parquet. Column chunk. API possibly not stable.
 struct ArrowWriteContext {
-  ArrowWriteContext(MemoryPool* memory_pool, ArrowWriterProperties* properties)
-      : memory_pool(memory_pool),
+  ArrowWriteContext(MemoryPool* memoryPool, ArrowWriterProperties* properties)
+      : memoryPool(memoryPool),
         properties(properties),
-        data_buffer(AllocateBuffer(memory_pool)),
-        def_levels_buffer(AllocateBuffer(memory_pool)) {}
+        dataBuffer(allocateBuffer(memoryPool)),
+        defLevelsBuffer(allocateBuffer(memoryPool)) {}
 
   template <typename T>
-  ::arrow::Status GetScratchData(const int64_t num_values, T** out) {
-    ARROW_RETURN_NOT_OK(
-        this->data_buffer->Resize(num_values * sizeof(T), false));
-    *out = reinterpret_cast<T*>(this->data_buffer->mutable_data());
+  ::arrow::Status getScratchData(const int64_t numValues, T** out) {
+    ARROW_RETURN_NOT_OK(this->dataBuffer->Resize(numValues * sizeof(T), false));
+    *out = reinterpret_cast<T*>(this->dataBuffer->mutable_data());
     return ::arrow::Status::OK();
   }
 
-  MemoryPool* memory_pool;
+  MemoryPool* memoryPool;
   const ArrowWriterProperties* properties;
 
-  // Buffer used for storing the data of an array converted to the physical type
-  // as expected by parquet-cpp.
-  std::shared_ptr<ResizableBuffer> data_buffer;
+  // Buffer used for storing the data of an array converted to the
+  // physical type. As expected by parquet-cpp.
+  std::shared_ptr<ResizableBuffer> dataBuffer;
 
-  // We use the shared ownership of this buffer
-  std::shared_ptr<ResizableBuffer> def_levels_buffer;
+  // We use the shared ownership of this buffer.
+  std::shared_ptr<ResizableBuffer> defLevelsBuffer;
 };
 
 PARQUET_EXPORT
-std::shared_ptr<ArrowWriterProperties> default_arrow_writer_properties();
+std::shared_ptr<ArrowWriterProperties> defaultArrowWriterProperties();
 
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/Schema.cpp b/velox/dwio/parquet/writer/arrow/Schema.cpp
index 1280f8a05c6..3a431bb5c70 100644
--- a/velox/dwio/parquet/writer/arrow/Schema.cpp
+++ b/velox/dwio/parquet/writer/arrow/Schema.cpp
@@ -34,19 +34,18 @@ using facebook::velox::parquet::thrift::SchemaElement;
 namespace facebook::velox::parquet::arrow {
 namespace {
 
-void ThrowInvalidLogicalType(const LogicalType& logical_type) {
+void throwInvalidLogicalType(const LogicalType& logicalType) {
   std::stringstream ss;
-  ss << "Invalid logical type: " << logical_type.ToString();
+  ss << "Invalid logical type: " << logicalType.toString();
   throw ParquetException(ss.str());
 }
 
-void CheckColumnBounds(int column_index, size_t max_columns) {
+void checkColumnBounds(int columnIndex, size_t maxColumns) {
   if (ARROW_PREDICT_FALSE(
-          column_index < 0 ||
-          static_cast<size_t>(column_index) >= max_columns)) {
+          columnIndex < 0 || static_cast<size_t>(columnIndex) >= maxColumns)) {
     std::stringstream ss;
-    ss << "Invalid Column Index: " << column_index
-       << " Num columns: " << max_columns;
+    ss << "Invalid Column Index: " << columnIndex
+       << " Num columns: " << maxColumns;
     throw ParquetException(ss.str());
   }
 }
@@ -55,10 +54,10 @@ void CheckColumnBounds(int column_index, size_t max_columns) {
 
 namespace schema {
 
-// ----------------------------------------------------------------------
-// ColumnPath
+// ----------------------------------------------------------------------.
+// ColumnPath.
 
-std::shared_ptr<ColumnPath> ColumnPath::FromDotString(
+std::shared_ptr<ColumnPath> ColumnPath::fromDotString(
     const std::string& dotstring) {
   std::stringstream ss(dotstring);
   std::string item;
@@ -69,33 +68,33 @@ std::shared_ptr<ColumnPath> ColumnPath::FromDotString(
   return std::make_shared<ColumnPath>(std::move(path));
 }
 
-std::shared_ptr<ColumnPath> ColumnPath::FromNode(const Node& node) {
-  // Build the path in reverse order as we traverse the nodes to the top
+std::shared_ptr<ColumnPath> ColumnPath::fromNode(const Node& node) {
+  // Build the path in reverse order as we traverse the nodes to the top.
   std::vector<std::string> rpath_;
   const Node* cursor = &node;
-  // The schema node is not part of the ColumnPath
+  // The schema node is not part of the ColumnPath.
   while (cursor->parent()) {
     rpath_.push_back(cursor->name());
     cursor = cursor->parent();
   }
 
-  // Build ColumnPath in correct order
+  // Build ColumnPath in correct order.
   std::vector<std::string> path(rpath_.crbegin(), rpath_.crend());
   return std::make_shared<ColumnPath>(std::move(path));
 }
 
 std::shared_ptr<ColumnPath> ColumnPath::extend(
-    const std::string& node_name) const {
+    const std::string& nodeName) const {
   std::vector<std::string> path;
   path.reserve(path_.size() + 1);
   path.resize(path_.size() + 1);
   std::copy(path_.cbegin(), path_.cend(), path.begin());
-  path[path_.size()] = node_name;
+  path[path_.size()] = nodeName;
 
   return std::make_shared<ColumnPath>(std::move(path));
 }
 
-std::string ColumnPath::ToDotString() const {
+std::string ColumnPath::toDotString() const {
   std::stringstream ss;
   for (auto it = path_.cbegin(); it != path_.cend(); ++it) {
     if (it != path_.cbegin()) {
@@ -106,70 +105,69 @@ std::string ColumnPath::ToDotString() const {
   return ss.str();
 }
 
-const std::vector<std::string>& ColumnPath::ToDotVector() const {
+const std::vector<std::string>& ColumnPath::toDotVector() const {
   return path_;
 }
 
-// ----------------------------------------------------------------------
-// Base node
+// ----------------------------------------------------------------------.
+// Base node.
 
 const std::shared_ptr<ColumnPath> Node::path() const {
   // TODO(itaiin): Cache the result, or more precisely, cache ->ToDotString()
-  //    since it is being used to access the leaf nodes
-  return ColumnPath::FromNode(*this);
+  //    Since it is being used to access the leaf nodes.
+  return ColumnPath::fromNode(*this);
 }
 
-bool Node::EqualsInternal(const Node* other) const {
+bool Node::equalsInternal(const Node* other) const {
   return type_ == other->type_ && name_ == other->name_ &&
       repetition_ == other->repetition_ &&
-      converted_type_ == other->converted_type_ &&
-      field_id_ == other->field_id() &&
-      logical_type_->Equals(*(other->logical_type()));
+      convertedType_ == other->convertedType_ && fieldId_ == other->fieldId() &&
+      logicalType_->equals(*(other->logicalType()));
 }
 
-void Node::SetParent(const Node* parent) {
+void Node::setParent(const Node* parent) {
   parent_ = parent;
 }
 
-// ----------------------------------------------------------------------
-// Primitive node
+// ----------------------------------------------------------------------.
+// Primitive node.
 
 PrimitiveNode::PrimitiveNode(
     const std::string& name,
     Repetition::type repetition,
     Type::type type,
-    ConvertedType::type converted_type,
+    ConvertedType::type convertedType,
     int length,
     int precision,
     int scale,
     int id)
-    : Node(Node::PRIMITIVE, name, repetition, converted_type, id),
-      physical_type_(type),
-      type_length_(length) {
+    : Node(Node::kPrimitive, name, repetition, convertedType, id),
+      physicalType_(type),
+      typeLength_(length) {
   std::stringstream ss;
 
-  // PARQUET-842: In an earlier revision, decimal_metadata_.isset was being
-  // set to true, but Impala will raise an incompatible metadata in such cases
-  memset(&decimal_metadata_, 0, sizeof(decimal_metadata_));
+  // PARQUET-842: In an earlier revision, decimalMetadata_.isset was being
+  // set to true, but Impala will raise an incompatible metadata in such cases.
+  memset(&decimalMetadata_, 0, sizeof(decimalMetadata_));
 
-  // Check if the physical and logical types match
-  // Mapping referred from Apache parquet-mr as on 2016-02-22
-  switch (converted_type) {
-    case ConvertedType::NONE:
-      // Logical type not set
+  // Check if the physical and logical types match.
+  // Mapping referred from Apache parquet-mr as on 2016-02-22.
+  switch (convertedType) {
+    case ConvertedType::kNone:
+      // Logical type not set.
       break;
-    case ConvertedType::UTF8:
-    case ConvertedType::JSON:
-    case ConvertedType::BSON:
-      if (type != Type::BYTE_ARRAY) {
-        ss << ConvertedTypeToString(converted_type);
+    case ConvertedType::kUtf8:
+    case ConvertedType::kJson:
+    case ConvertedType::kBson:
+      if (type != Type::kByteArray) {
+        ss << convertedTypeToString(convertedType);
         ss << " can only annotate BYTE_ARRAY fields";
         throw ParquetException(ss.str());
       }
       break;
-    case ConvertedType::DECIMAL:
-      if ((type != Type::INT32) && (type != Type::INT64) &&
-          (type != Type::BYTE_ARRAY) && (type != Type::FIXED_LEN_BYTE_ARRAY)) {
+    case ConvertedType::kDecimal:
+      if ((type != Type::kInt32) && (type != Type::kInt64) &&
+          (type != Type::kByteArray) && (type != Type::kFixedLenByteArray)) {
         ss << "DECIMAL can only annotate INT32, INT64, BYTE_ARRAY, and FIXED";
         throw ParquetException(ss.str());
       }
@@ -188,174 +186,173 @@ PrimitiveNode::PrimitiveNode(
         ss << " cannot be greater than precision " << precision;
         throw ParquetException(ss.str());
       }
-      decimal_metadata_.isset = true;
-      decimal_metadata_.precision = precision;
-      decimal_metadata_.scale = scale;
+      decimalMetadata_.isset = true;
+      decimalMetadata_.precision = precision;
+      decimalMetadata_.scale = scale;
       break;
-    case ConvertedType::DATE:
-    case ConvertedType::TIME_MILLIS:
-    case ConvertedType::UINT_8:
-    case ConvertedType::UINT_16:
-    case ConvertedType::UINT_32:
-    case ConvertedType::INT_8:
-    case ConvertedType::INT_16:
-    case ConvertedType::INT_32:
-      if (type != Type::INT32) {
-        ss << ConvertedTypeToString(converted_type);
+    case ConvertedType::kDate:
+    case ConvertedType::kTimeMillis:
+    case ConvertedType::kUint8:
+    case ConvertedType::kUint16:
+    case ConvertedType::kUint32:
+    case ConvertedType::kInt8:
+    case ConvertedType::kInt16:
+    case ConvertedType::kInt32:
+      if (type != Type::kInt32) {
+        ss << convertedTypeToString(convertedType);
         ss << " can only annotate INT32";
         throw ParquetException(ss.str());
       }
       break;
-    case ConvertedType::TIME_MICROS:
-    case ConvertedType::TIMESTAMP_MILLIS:
-    case ConvertedType::TIMESTAMP_MICROS:
-    case ConvertedType::UINT_64:
-    case ConvertedType::INT_64:
-      if (type != Type::INT64) {
-        ss << ConvertedTypeToString(converted_type);
+    case ConvertedType::kTimeMicros:
+    case ConvertedType::kTimestampMillis:
+    case ConvertedType::kTimestampMicros:
+    case ConvertedType::kUint64:
+    case ConvertedType::kInt64:
+      if (type != Type::kInt64) {
+        ss << convertedTypeToString(convertedType);
         ss << " can only annotate INT64";
         throw ParquetException(ss.str());
       }
       break;
-    case ConvertedType::INTERVAL:
-      if ((type != Type::FIXED_LEN_BYTE_ARRAY) || (length != 12)) {
+    case ConvertedType::kInterval:
+      if ((type != Type::kFixedLenByteArray) || (length != 12)) {
         ss << "INTERVAL can only annotate FIXED_LEN_BYTE_ARRAY(12)";
         throw ParquetException(ss.str());
       }
       break;
-    case ConvertedType::ENUM:
-      if (type != Type::BYTE_ARRAY) {
+    case ConvertedType::kEnum:
+      if (type != Type::kByteArray) {
         ss << "ENUM can only annotate BYTE_ARRAY fields";
         throw ParquetException(ss.str());
       }
       break;
-    case ConvertedType::NA:
-      // NA can annotate any type
+    case ConvertedType::kNa:
+      // NA can annotate any type.
       break;
     default:
-      ss << ConvertedTypeToString(converted_type);
+      ss << convertedTypeToString(convertedType);
       ss << " cannot be applied to a primitive type";
       throw ParquetException(ss.str());
   }
-  // For forward compatibility, create an equivalent logical type
-  logical_type_ =
-      LogicalType::FromConvertedType(converted_type_, decimal_metadata_);
-  if (!(logical_type_ && !logical_type_->is_nested() &&
-        logical_type_->is_compatible(converted_type_, decimal_metadata_))) {
-    ThrowInvalidLogicalType(*logical_type_);
+  // For forward compatibility, create an equivalent logical type.
+  logicalType_ =
+      LogicalType::fromConvertedType(convertedType_, decimalMetadata_);
+  if (!(logicalType_ && !logicalType_->isNested() &&
+        logicalType_->isCompatible(convertedType_, decimalMetadata_))) {
+    throwInvalidLogicalType(*logicalType_);
   }
 
-  if (type == Type::FIXED_LEN_BYTE_ARRAY) {
+  if (type == Type::kFixedLenByteArray) {
     if (length <= 0) {
       ss << "Invalid FIXED_LEN_BYTE_ARRAY length: " << length;
       throw ParquetException(ss.str());
     }
-    type_length_ = length;
+    typeLength_ = length;
   }
 }
 
 PrimitiveNode::PrimitiveNode(
     const std::string& name,
     Repetition::type repetition,
-    std::shared_ptr<const LogicalType> logical_type,
-    Type::type physical_type,
-    int physical_length,
+    std::shared_ptr<const LogicalType> logicalType,
+    Type::type physicalType,
+    int physicalLength,
     int id)
-    : Node(Node::PRIMITIVE, name, repetition, std::move(logical_type), id),
-      physical_type_(physical_type),
-      type_length_(physical_length) {
+    : Node(Node::kPrimitive, name, repetition, std::move(logicalType), id),
+      physicalType_(physicalType),
+      typeLength_(physicalLength) {
   std::stringstream error;
-  if (logical_type_) {
-    // Check for logical type <=> node type consistency
-    if (!logical_type_->is_nested()) {
-      // Check for logical type <=> physical type consistency
-      if (logical_type_->is_applicable(physical_type, physical_length)) {
+  if (logicalType_) {
+    // Check for logical type <=> node type consistency.
+    if (!logicalType_->isNested()) {
+      // Check for logical type <=> physical type consistency.
+      if (logicalType_->isApplicable(physicalType, physicalLength)) {
         // For backward compatibility, assign equivalent legacy
-        // converted type (if possible)
-        converted_type_ = logical_type_->ToConvertedType(&decimal_metadata_);
+        // converted type (if possible).
+        convertedType_ = logicalType_->toConvertedType(&decimalMetadata_);
       } else {
-        error << logical_type_->ToString();
+        error << logicalType_->toString();
         error << " can not be applied to primitive type ";
-        error << TypeToString(physical_type);
+        error << typeToString(physicalType);
         throw ParquetException(error.str());
       }
     } else {
       error << "Nested logical type ";
-      error << logical_type_->ToString();
+      error << logicalType_->toString();
       error << " can not be applied to non-group node";
       throw ParquetException(error.str());
     }
   } else {
-    logical_type_ = NoLogicalType::Make();
-    converted_type_ = logical_type_->ToConvertedType(&decimal_metadata_);
+    logicalType_ = NoLogicalType::make();
+    convertedType_ = logicalType_->toConvertedType(&decimalMetadata_);
   }
-  if (!(logical_type_ && !logical_type_->is_nested() &&
-        logical_type_->is_compatible(converted_type_, decimal_metadata_))) {
-    ThrowInvalidLogicalType(*logical_type_);
+  if (!(logicalType_ && !logicalType_->isNested() &&
+        logicalType_->isCompatible(convertedType_, decimalMetadata_))) {
+    throwInvalidLogicalType(*logicalType_);
   }
 
-  if (physical_type == Type::FIXED_LEN_BYTE_ARRAY) {
-    if (physical_length <= 0) {
-      error << "Invalid FIXED_LEN_BYTE_ARRAY length: " << physical_length;
+  if (physicalType == Type::kFixedLenByteArray) {
+    if (physicalLength <= 0) {
+      error << "Invalid FIXED_LEN_BYTE_ARRAY length: " << physicalLength;
       throw ParquetException(error.str());
     }
   }
 }
 
-bool PrimitiveNode::EqualsInternal(const PrimitiveNode* other) const {
-  bool is_equal = true;
-  if (physical_type_ != other->physical_type_) {
+bool PrimitiveNode::equalsInternal(const PrimitiveNode* other) const {
+  bool isEqual = true;
+  if (physicalType_ != other->physicalType_) {
     return false;
   }
-  if (converted_type_ == ConvertedType::DECIMAL) {
-    is_equal &=
-        (decimal_metadata_.precision == other->decimal_metadata_.precision) &&
-        (decimal_metadata_.scale == other->decimal_metadata_.scale);
+  if (convertedType_ == ConvertedType::kDecimal) {
+    isEqual &=
+        (decimalMetadata_.precision == other->decimalMetadata_.precision) &&
+        (decimalMetadata_.scale == other->decimalMetadata_.scale);
   }
-  if (physical_type_ == Type::FIXED_LEN_BYTE_ARRAY) {
-    is_equal &= (type_length_ == other->type_length_);
+  if (physicalType_ == Type::kFixedLenByteArray) {
+    isEqual &= (typeLength_ == other->typeLength_);
   }
-  return is_equal;
+  return isEqual;
 }
 
-bool PrimitiveNode::Equals(const Node* other) const {
-  if (!Node::EqualsInternal(other)) {
+bool PrimitiveNode::equals(const Node* other) const {
+  if (!Node::equalsInternal(other)) {
     return false;
   }
-  return EqualsInternal(static_cast<const PrimitiveNode*>(other));
+  return equalsInternal(static_cast<const PrimitiveNode*>(other));
 }
 
-void PrimitiveNode::Visit(Node::Visitor* visitor) {
-  visitor->Visit(this);
+void PrimitiveNode::visit(Node::Visitor* visitor) {
+  visitor->visit(this);
 }
 
-void PrimitiveNode::VisitConst(Node::ConstVisitor* visitor) const {
-  visitor->Visit(this);
+void PrimitiveNode::visitConst(Node::ConstVisitor* visitor) const {
+  visitor->visit(this);
 }
 
-// ----------------------------------------------------------------------
-// Group node
+// ----------------------------------------------------------------------.
+// Group node.
 
 GroupNode::GroupNode(
     const std::string& name,
     Repetition::type repetition,
     const NodeVector& fields,
-    ConvertedType::type converted_type,
+    ConvertedType::type convertedType,
     int id)
-    : Node(Node::GROUP, name, repetition, converted_type, id), fields_(fields) {
-  // For forward compatibility, create an equivalent logical type
-  logical_type_ = LogicalType::FromConvertedType(converted_type_);
-  if (!(logical_type_ &&
-        (logical_type_->is_nested() || logical_type_->is_none()) &&
-        logical_type_->is_compatible(converted_type_))) {
-    ThrowInvalidLogicalType(*logical_type_);
+    : Node(Node::kGroup, name, repetition, convertedType, id), fields_(fields) {
+  // For forward compatibility, create an equivalent logical type.
+  logicalType_ = LogicalType::fromConvertedType(convertedType_);
+  if (!(logicalType_ && (logicalType_->isNested() || logicalType_->isNone()) &&
+        logicalType_->isCompatible(convertedType_))) {
+    throwInvalidLogicalType(*logicalType_);
   }
 
-  field_name_to_idx_.clear();
-  auto field_idx = 0;
+  fieldNameToIdx_.clear();
+  auto fieldIdx = 0;
   for (NodePtr& field : fields_) {
-    field->SetParent(this);
-    field_name_to_idx_.emplace(field->name(), field_idx++);
+    field->setParent(this);
+    fieldNameToIdx_.emplace(field->name(), fieldIdx++);
   }
 }
 
@@ -363,74 +360,73 @@ GroupNode::GroupNode(
     const std::string& name,
     Repetition::type repetition,
     const NodeVector& fields,
-    std::shared_ptr<const LogicalType> logical_type,
+    std::shared_ptr<const LogicalType> logicalType,
     int id)
-    : Node(Node::GROUP, name, repetition, std::move(logical_type), id),
+    : Node(Node::kGroup, name, repetition, std::move(logicalType), id),
       fields_(fields) {
-  if (logical_type_) {
-    // Check for logical type <=> node type consistency
-    if (logical_type_->is_nested()) {
-      // For backward compatibility, assign equivalent legacy converted type (if
-      // possible)
-      converted_type_ = logical_type_->ToConvertedType(nullptr);
+  if (logicalType_) {
+    // Check for logical type <=> node type consistency.
+    if (logicalType_->isNested()) {
+      // For backward compatibility, assign equivalent legacy converted type
+      // (if possible).
+      convertedType_ = logicalType_->toConvertedType(nullptr);
     } else {
       std::stringstream error;
       error << "Logical type ";
-      error << logical_type_->ToString();
+      error << logicalType_->toString();
       error << " can not be applied to group node";
       throw ParquetException(error.str());
     }
   } else {
-    logical_type_ = NoLogicalType::Make();
-    converted_type_ = logical_type_->ToConvertedType(nullptr);
+    logicalType_ = NoLogicalType::make();
+    convertedType_ = logicalType_->toConvertedType(nullptr);
   }
-  if (!(logical_type_ &&
-        (logical_type_->is_nested() || logical_type_->is_none()) &&
-        logical_type_->is_compatible(converted_type_))) {
-    ThrowInvalidLogicalType(*logical_type_);
+  if (!(logicalType_ && (logicalType_->isNested() || logicalType_->isNone()) &&
+        logicalType_->isCompatible(convertedType_))) {
+    throwInvalidLogicalType(*logicalType_);
   }
 
-  field_name_to_idx_.clear();
-  auto field_idx = 0;
+  fieldNameToIdx_.clear();
+  auto fieldIdx = 0;
   for (NodePtr& field : fields_) {
-    field->SetParent(this);
-    field_name_to_idx_.emplace(field->name(), field_idx++);
+    field->setParent(this);
+    fieldNameToIdx_.emplace(field->name(), fieldIdx++);
   }
 }
 
-bool GroupNode::EqualsInternal(const GroupNode* other) const {
+bool GroupNode::equalsInternal(const GroupNode* other) const {
   if (this == other) {
     return true;
   }
-  if (this->field_count() != other->field_count()) {
+  if (this->fieldCount() != other->fieldCount()) {
     return false;
   }
-  for (int i = 0; i < this->field_count(); ++i) {
-    if (!this->field(i)->Equals(other->field(i).get())) {
+  for (int i = 0; i < this->fieldCount(); ++i) {
+    if (!this->field(i)->equals(other->field(i).get())) {
       return false;
     }
   }
   return true;
 }
 
-bool GroupNode::Equals(const Node* other) const {
-  if (!Node::EqualsInternal(other)) {
+bool GroupNode::equals(const Node* other) const {
+  if (!Node::equalsInternal(other)) {
     return false;
   }
-  return EqualsInternal(static_cast<const GroupNode*>(other));
+  return equalsInternal(static_cast<const GroupNode*>(other));
 }
 
-int GroupNode::FieldIndex(const std::string& name) const {
-  auto search = field_name_to_idx_.find(name);
-  if (search == field_name_to_idx_.end()) {
-    // Not found
+int GroupNode::fieldIndex(const std::string& name) const {
+  auto search = fieldNameToIdx_.find(name);
+  if (search == fieldNameToIdx_.end()) {
+    // Not found.
     return -1;
   }
   return search->second;
 }
 
-int GroupNode::FieldIndex(const Node& node) const {
-  auto search = field_name_to_idx_.equal_range(node.name());
+int GroupNode::fieldIndex(const Node& node) const {
+  auto search = fieldNameToIdx_.equal_range(node.name());
   for (auto it = search.first; it != search.second; ++it) {
     const int idx = it->second;
     if (&node == field(idx).get()) {
@@ -440,223 +436,222 @@ int GroupNode::FieldIndex(const Node& node) const {
   return -1;
 }
 
-void GroupNode::Visit(Node::Visitor* visitor) {
-  visitor->Visit(this);
+void GroupNode::visit(Node::Visitor* visitor) {
+  visitor->visit(this);
 }
 
-void GroupNode::VisitConst(Node::ConstVisitor* visitor) const {
-  visitor->Visit(this);
+void GroupNode::visitConst(Node::ConstVisitor* visitor) const {
+  visitor->visit(this);
 }
 
-// ----------------------------------------------------------------------
-// Node construction from Parquet metadata
+// ----------------------------------------------------------------------.
+// Node construction from Parquet metadata.
 
-std::unique_ptr<Node> GroupNode::FromParquet(
-    const void* opaque_element,
+std::unique_ptr<Node> GroupNode::fromParquet(
+    const void* opaqueElement,
     NodeVector fields) {
   const facebook::velox::parquet::thrift::SchemaElement* element =
       static_cast<const facebook::velox::parquet::thrift::SchemaElement*>(
-          opaque_element);
+          opaqueElement);
 
-  int field_id = -1;
+  int fieldId = -1;
   if (element->__isset.field_id) {
-    field_id = element->field_id;
+    fieldId = element->field_id;
   }
 
-  std::unique_ptr<GroupNode> group_node;
+  std::unique_ptr<GroupNode> groupNode;
   if (element->__isset.logicalType) {
-    // updated writer with logical type present
-    group_node = std::unique_ptr<GroupNode>(new GroupNode(
+    // Updated writer with logical type present.
+    groupNode = std::unique_ptr<GroupNode>(new GroupNode(
         element->name,
-        LoadEnumSafe(&element->repetition_type),
+        loadenumSafe(&element->repetition_type),
         fields,
-        LogicalType::FromThrift(element->logicalType),
-        field_id));
+        LogicalType::fromThrift(element->logicalType),
+        fieldId));
   } else {
-    group_node = std::unique_ptr<GroupNode>(new GroupNode(
+    groupNode = std::unique_ptr<GroupNode>(new GroupNode(
         element->name,
-        LoadEnumSafe(&element->repetition_type),
+        loadenumSafe(&element->repetition_type),
         fields,
         (element->__isset.converted_type
-             ? LoadEnumSafe(&element->converted_type)
-             : ConvertedType::NONE),
-        field_id));
+             ? loadenumSafe(&element->converted_type)
+             : ConvertedType::kNone),
+        fieldId));
   }
 
-  return std::unique_ptr<Node>(group_node.release());
+  return std::unique_ptr<Node>(groupNode.release());
 }
 
-std::unique_ptr<Node> PrimitiveNode::FromParquet(const void* opaque_element) {
+std::unique_ptr<Node> PrimitiveNode::fromParquet(const void* opaqueElement) {
   const facebook::velox::parquet::thrift::SchemaElement* element =
       static_cast<const facebook::velox::parquet::thrift::SchemaElement*>(
-          opaque_element);
+          opaqueElement);
 
-  int field_id = -1;
+  int fieldId = -1;
   if (element->__isset.field_id) {
-    field_id = element->field_id;
+    fieldId = element->field_id;
   }
 
-  std::unique_ptr<PrimitiveNode> primitive_node;
+  std::unique_ptr<PrimitiveNode> primitiveNode;
   if (element->__isset.logicalType) {
-    // updated writer with logical type present
-    primitive_node = std::unique_ptr<PrimitiveNode>(new PrimitiveNode(
+    // Updated writer with logical type present.
+    primitiveNode = std::unique_ptr<PrimitiveNode>(new PrimitiveNode(
         element->name,
-        LoadEnumSafe(&element->repetition_type),
-        LogicalType::FromThrift(element->logicalType),
-        LoadEnumSafe(&element->type),
+        loadenumSafe(&element->repetition_type),
+        LogicalType::fromThrift(element->logicalType),
+        loadenumSafe(&element->type),
         element->type_length,
-        field_id));
+        fieldId));
   } else if (element->__isset.converted_type) {
-    // legacy writer with converted type present
-    primitive_node = std::unique_ptr<PrimitiveNode>(new PrimitiveNode(
+    // Legacy writer with converted type present.
+    primitiveNode = std::unique_ptr<PrimitiveNode>(new PrimitiveNode(
         element->name,
-        LoadEnumSafe(&element->repetition_type),
-        LoadEnumSafe(&element->type),
-        LoadEnumSafe(&element->converted_type),
+        loadenumSafe(&element->repetition_type),
+        loadenumSafe(&element->type),
+        loadenumSafe(&element->converted_type),
         element->type_length,
         element->precision,
         element->scale,
-        field_id));
+        fieldId));
   } else {
-    // logical type not present
-    primitive_node = std::unique_ptr<PrimitiveNode>(new PrimitiveNode(
+    // Logical type not present.
+    primitiveNode = std::unique_ptr<PrimitiveNode>(new PrimitiveNode(
         element->name,
-        LoadEnumSafe(&element->repetition_type),
-        NoLogicalType::Make(),
-        LoadEnumSafe(&element->type),
+        loadenumSafe(&element->repetition_type),
+        NoLogicalType::make(),
+        loadenumSafe(&element->type),
         element->type_length,
-        field_id));
+        fieldId));
   }
 
-  // Return as unique_ptr to the base type
-  return std::unique_ptr<Node>(primitive_node.release());
+  // Return as unique_ptr to the base type.
+  return std::unique_ptr<Node>(primitiveNode.release());
 }
 
-bool GroupNode::HasRepeatedFields() const {
-  for (int i = 0; i < this->field_count(); ++i) {
+bool GroupNode::hasRepeatedFields() const {
+  for (int i = 0; i < this->fieldCount(); ++i) {
     auto field = this->field(i);
-    if (field->repetition() == Repetition::REPEATED) {
+    if (field->repetition() == Repetition::kRepeated) {
       return true;
     }
-    if (field->is_group()) {
+    if (field->isGroup()) {
       const auto& group = static_cast<const GroupNode&>(*field);
-      return group.HasRepeatedFields();
+      return group.hasRepeatedFields();
     }
   }
   return false;
 }
 
-void GroupNode::ToParquet(void* opaque_element) const {
+void GroupNode::toParquet(void* opaqueElement) const {
   facebook::velox::parquet::thrift::SchemaElement* element =
       static_cast<facebook::velox::parquet::thrift::SchemaElement*>(
-          opaque_element);
+          opaqueElement);
   element->__set_name(name_);
-  element->__set_num_children(field_count());
-  element->__set_repetition_type(ToThrift(repetition_));
-  if (converted_type_ != ConvertedType::NONE) {
-    element->__set_converted_type(ToThrift(converted_type_));
+  element->__set_num_children(fieldCount());
+  element->__set_repetition_type(toThrift(repetition_));
+  if (convertedType_ != ConvertedType::kNone) {
+    element->__set_converted_type(toThrift(convertedType_));
   }
-  if (field_id_ >= 0) {
-    element->__set_field_id(field_id_);
+  if (fieldId_ >= 0) {
+    element->__set_field_id(fieldId_);
   }
-  if (logical_type_ && logical_type_->is_serialized()) {
-    element->__set_logicalType(logical_type_->ToThrift());
+  if (logicalType_ && logicalType_->isSerialized()) {
+    element->__set_logicalType(logicalType_->toThrift());
   }
   return;
 }
 
-void PrimitiveNode::ToParquet(void* opaque_element) const {
+void PrimitiveNode::toParquet(void* opaqueElement) const {
   facebook::velox::parquet::thrift::SchemaElement* element =
       static_cast<facebook::velox::parquet::thrift::SchemaElement*>(
-          opaque_element);
+          opaqueElement);
   element->__set_name(name_);
-  element->__set_repetition_type(ToThrift(repetition_));
-  if (converted_type_ != ConvertedType::NONE) {
-    if (converted_type_ != ConvertedType::NA) {
-      element->__set_converted_type(ToThrift(converted_type_));
+  element->__set_repetition_type(toThrift(repetition_));
+  if (convertedType_ != ConvertedType::kNone) {
+    if (convertedType_ != ConvertedType::kNa) {
+      element->__set_converted_type(toThrift(convertedType_));
     } else {
-      // ConvertedType::NA is an unreleased, obsolete synonym for
-      // LogicalType::Null. Never emit it (see PARQUET-1990 for discussion).
-      if (!logical_type_ || !logical_type_->is_null()) {
+      // ConvertedType::kNa is an unreleased, obsolete synonym for.
+      // LogicalType::nullType. Never emit it (see PARQUET-1990 for discussion).
+      if (!logicalType_ || !logicalType_->isNull()) {
         throw ParquetException(
-            "ConvertedType::NA is obsolete, please use LogicalType::Null instead");
+            "ConvertedType::kNa is obsolete, please use LogicalType::nullType instead");
       }
     }
   }
-  if (field_id_ >= 0) {
-    element->__set_field_id(field_id_);
+  if (fieldId_ >= 0) {
+    element->__set_field_id(fieldId_);
   }
-  if (logical_type_ && logical_type_->is_serialized() &&
-      // TODO(tpboudreau): remove the following conjunct to enable serialization
-      // of IntervalTypes after parquet.thrift recognizes them
-      !logical_type_->is_interval()) {
-    element->__set_logicalType(logical_type_->ToThrift());
+  if (logicalType_ && logicalType_->isSerialized() &&
+      // TODO(tpboudreau): remove the following conjunct to enable
+      // serialization. Of IntervalTypes after parquet.thrift recognizes them.
+      !logicalType_->isInterval()) {
+    element->__set_logicalType(logicalType_->toThrift());
   }
-  element->__set_type(ToThrift(physical_type_));
-  if (physical_type_ == Type::FIXED_LEN_BYTE_ARRAY) {
-    element->__set_type_length(type_length_);
+  element->__set_type(toThrift(physicalType_));
+  if (physicalType_ == Type::kFixedLenByteArray) {
+    element->__set_type_length(typeLength_);
   }
-  if (decimal_metadata_.isset) {
-    element->__set_precision(decimal_metadata_.precision);
-    element->__set_scale(decimal_metadata_.scale);
+  if (decimalMetadata_.isset) {
+    element->__set_precision(decimalMetadata_.precision);
+    element->__set_scale(decimalMetadata_.scale);
   }
   return;
 }
 
-// ----------------------------------------------------------------------
-// Schema converters
+// ----------------------------------------------------------------------.
+// Schema converters.
 
-std::unique_ptr<Node> Unflatten(
+std::unique_ptr<Node> unflatten(
     const facebook::velox::parquet::thrift::SchemaElement* elements,
     int length) {
   if (elements[0].num_children == 0) {
     if (length == 1) {
-      // Degenerate case of Parquet file with no columns
-      return GroupNode::FromParquet(elements, {});
+      // Degenerate case of Parquet file with no columns.
+      return GroupNode::fromParquet(elements, {});
     } else {
       throw ParquetException(
           "Parquet schema had multiple nodes but root had no children");
     }
   }
 
-  // We don't check that the root node is repeated since this is not
-  // consistently set by implementations
+  // We don't check that the root node is repeated since this is not.
+  // Consistently set by implementations.
 
   int pos = 0;
 
-  std::function<std::unique_ptr<Node>()> NextNode = [&]() {
+  std::function<std::unique_ptr<Node>()> nextNode = [&]() {
     if (pos == length) {
       throw ParquetException("Malformed schema: not enough elements");
     }
     const SchemaElement& element = elements[pos++];
-    const void* opaque_element = static_cast<const void*>(&element);
+    const void* opaqueElement = static_cast<const void*>(&element);
 
     if (element.num_children == 0 && element.__isset.type) {
-      // Leaf (primitive) node: always has a type
-      return PrimitiveNode::FromParquet(opaque_element);
+      // Leaf (primitive) node: always has a type.
+      return PrimitiveNode::fromParquet(opaqueElement);
     } else {
       // Group node (may have 0 children, but cannot have a type)
       NodeVector fields;
       for (int i = 0; i < element.num_children; ++i) {
-        std::unique_ptr<Node> field = NextNode();
-        fields.push_back(NodePtr(field.release()));
+        fields.emplace_back(nextNode());
       }
-      return GroupNode::FromParquet(opaque_element, std::move(fields));
+      return GroupNode::fromParquet(opaqueElement, std::move(fields));
     }
   };
-  return NextNode();
+  return nextNode();
 }
 
-std::shared_ptr<SchemaDescriptor> FromParquet(
+std::shared_ptr<SchemaDescriptor> fromParquet(
     const std::vector<SchemaElement>& schema) {
   if (schema.empty()) {
     throw ParquetException("Empty file schema (no root)");
   }
   std::unique_ptr<Node> root =
-      Unflatten(&schema[0], static_cast<int>(schema.size()));
+      unflatten(&schema[0], static_cast<int>(schema.size()));
   std::shared_ptr<SchemaDescriptor> descr =
       std::make_shared<SchemaDescriptor>();
-  descr->Init(
+  descr->init(
       std::shared_ptr<GroupNode>(static_cast<GroupNode*>(root.release())));
   return descr;
 }
@@ -667,15 +662,15 @@ class SchemaVisitor : public Node::ConstVisitor {
       std::vector<facebook::velox::parquet::thrift::SchemaElement>* elements)
       : elements_(elements) {}
 
-  void Visit(const Node* node) override {
+  void visit(const Node* node) override {
     facebook::velox::parquet::thrift::SchemaElement element;
-    node->ToParquet(&element);
+    node->toParquet(&element);
     elements_->push_back(element);
 
-    if (node->is_group()) {
-      const GroupNode* group_node = static_cast<const GroupNode*>(node);
-      for (int i = 0; i < group_node->field_count(); ++i) {
-        group_node->field(i)->VisitConst(this);
+    if (node->isGroup()) {
+      const GroupNode* groupNode = static_cast<const GroupNode*>(node);
+      for (int i = 0; i < groupNode->fieldCount(); ++i) {
+        groupNode->field(i)->visitConst(this);
       }
     }
   }
@@ -684,25 +679,25 @@ class SchemaVisitor : public Node::ConstVisitor {
   std::vector<facebook::velox::parquet::thrift::SchemaElement>* elements_;
 };
 
-void ToParquet(
+void toParquet(
     const GroupNode* schema,
     std::vector<facebook::velox::parquet::thrift::SchemaElement>* out) {
   SchemaVisitor visitor(out);
-  schema->VisitConst(&visitor);
+  schema->visitConst(&visitor);
 }
 
-// ----------------------------------------------------------------------
-// Schema printing
+// ----------------------------------------------------------------------.
+// Schema printing.
 
-static void PrintRepLevel(Repetition::type repetition, std::ostream& stream) {
+static void printRepLevel(Repetition::type repetition, std::ostream& stream) {
   switch (repetition) {
-    case Repetition::REQUIRED:
+    case Repetition::kRequired:
       stream << "required";
       break;
-    case Repetition::OPTIONAL:
+    case Repetition::kOptional:
       stream << "optional";
       break;
-    case Repetition::REPEATED:
+    case Repetition::kRepeated:
       stream << "repeated";
       break;
     default:
@@ -710,113 +705,113 @@ static void PrintRepLevel(Repetition::type repetition, std::ostream& stream) {
   }
 }
 
-static void PrintType(const PrimitiveNode* node, std::ostream& stream) {
-  switch (node->physical_type()) {
-    case Type::BOOLEAN:
+static void printType(const PrimitiveNode* Node, std::ostream& stream) {
+  switch (Node->physicalType()) {
+    case Type::kBoolean:
       stream << "boolean";
       break;
-    case Type::INT32:
+    case Type::kInt32:
       stream << "int32";
       break;
-    case Type::INT64:
+    case Type::kInt64:
       stream << "int64";
       break;
-    case Type::INT96:
+    case Type::kInt96:
       stream << "int96";
       break;
-    case Type::FLOAT:
+    case Type::kFloat:
       stream << "float";
       break;
-    case Type::DOUBLE:
+    case Type::kDouble:
       stream << "double";
       break;
-    case Type::BYTE_ARRAY:
+    case Type::kByteArray:
       stream << "binary";
       break;
-    case Type::FIXED_LEN_BYTE_ARRAY:
-      stream << "fixed_len_byte_array(" << node->type_length() << ")";
+    case Type::kFixedLenByteArray:
+      stream << "fixed_len_byte_array(" << Node->typeLength() << ")";
       break;
     default:
       break;
   }
 }
 
-static void PrintConvertedType(
-    const PrimitiveNode* node,
+static void printConvertedType(
+    const PrimitiveNode* Node,
     std::ostream& stream) {
-  auto lt = node->converted_type();
-  auto la = node->logical_type();
-  if (la && la->is_valid() && !la->is_none()) {
-    stream << " (" << la->ToString() << ")";
-  } else if (lt == ConvertedType::DECIMAL) {
-    stream << " (" << ConvertedTypeToString(lt) << "("
-           << node->decimal_metadata().precision << ","
-           << node->decimal_metadata().scale << "))";
-  } else if (lt != ConvertedType::NONE) {
-    stream << " (" << ConvertedTypeToString(lt) << ")";
+  auto lt = Node->convertedType();
+  auto la = Node->logicalType();
+  if (la && la->isValid() && !la->isNone()) {
+    stream << " (" << la->toString() << ")";
+  } else if (lt == ConvertedType::kDecimal) {
+    stream << " (" << convertedTypeToString(lt) << "("
+           << Node->decimalMetadata().precision << ","
+           << Node->decimalMetadata().scale << "))";
+  } else if (lt != ConvertedType::kNone) {
+    stream << " (" << convertedTypeToString(lt) << ")";
   }
 }
 
 struct SchemaPrinter : public Node::ConstVisitor {
-  explicit SchemaPrinter(std::ostream& stream, int indent_width)
-      : stream_(stream), indent_(0), indent_width_(2) {}
+  explicit SchemaPrinter(std::ostream& stream, int indentWidth)
+      : stream_(stream), indent_(0), indentWidth_(2) {}
 
-  void Indent() {
+  void indent() {
     if (indent_ > 0) {
       std::string spaces(indent_, ' ');
       stream_ << spaces;
     }
   }
 
-  void Visit(const Node* node) {
-    Indent();
-    if (node->is_group()) {
-      Visit(static_cast<const GroupNode*>(node));
+  void visit(const Node* Node) {
+    indent();
+    if (Node->isGroup()) {
+      visit(static_cast<const GroupNode*>(Node));
     } else {
-      // Primitive
-      Visit(static_cast<const PrimitiveNode*>(node));
+      // Primitive.
+      visit(static_cast<const PrimitiveNode*>(Node));
     }
   }
 
-  void Visit(const PrimitiveNode* node) {
-    PrintRepLevel(node->repetition(), stream_);
+  void visit(const PrimitiveNode* Node) {
+    printRepLevel(Node->repetition(), stream_);
     stream_ << " ";
-    PrintType(node, stream_);
-    stream_ << " field_id=" << node->field_id() << " " << node->name();
-    PrintConvertedType(node, stream_);
+    printType(Node, stream_);
+    stream_ << " field_id=" << Node->fieldId() << " " << Node->name();
+    printConvertedType(Node, stream_);
     stream_ << ";" << std::endl;
   }
 
-  void Visit(const GroupNode* node) {
-    PrintRepLevel(node->repetition(), stream_);
-    stream_ << " group " << "field_id=" << node->field_id() << " "
-            << node->name();
-    auto lt = node->converted_type();
-    auto la = node->logical_type();
-    if (la && la->is_valid() && !la->is_none()) {
-      stream_ << " (" << la->ToString() << ")";
-    } else if (lt != ConvertedType::NONE) {
-      stream_ << " (" << ConvertedTypeToString(lt) << ")";
+  void visit(const GroupNode* Node) {
+    printRepLevel(Node->repetition(), stream_);
+    stream_ << " group " << "field_id=" << Node->fieldId() << " "
+            << Node->name();
+    auto lt = Node->convertedType();
+    auto la = Node->logicalType();
+    if (la && la->isValid() && !la->isNone()) {
+      stream_ << " (" << la->toString() << ")";
+    } else if (lt != ConvertedType::kNone) {
+      stream_ << " (" << convertedTypeToString(lt) << ")";
     }
     stream_ << " {" << std::endl;
 
-    indent_ += indent_width_;
-    for (int i = 0; i < node->field_count(); ++i) {
-      node->field(i)->VisitConst(this);
+    indent_ += indentWidth_;
+    for (int i = 0; i < Node->fieldCount(); ++i) {
+      Node->field(i)->visitConst(this);
     }
-    indent_ -= indent_width_;
-    Indent();
+    indent_ -= indentWidth_;
+    indent();
     stream_ << "}" << std::endl;
   }
 
   std::ostream& stream_;
   int indent_;
-  int indent_width_;
+  int indentWidth_;
 };
 
-void PrintSchema(const Node* schema, std::ostream& stream, int indent_width) {
-  SchemaPrinter printer(stream, indent_width);
-  printer.Visit(schema);
+void printSchema(const Node* schema, std::ostream& stream, int indentWidth) {
+  SchemaPrinter printer(stream, indentWidth);
+  printer.visit(schema);
 }
 
 } // namespace schema
@@ -827,74 +822,74 @@ using schema::Node;
 using schema::NodePtr;
 using schema::PrimitiveNode;
 
-void SchemaDescriptor::Init(std::unique_ptr<schema::Node> schema) {
-  Init(NodePtr(schema.release()));
+void SchemaDescriptor::init(std::unique_ptr<schema::Node> schema) {
+  init(NodePtr(schema.release()));
 }
 
 class SchemaUpdater : public Node::Visitor {
  public:
-  explicit SchemaUpdater(const std::vector<ColumnOrder>& column_orders)
-      : column_orders_(column_orders), leaf_count_(0) {}
-
-  void Visit(Node* node) override {
-    if (node->is_group()) {
-      GroupNode* group_node = static_cast<GroupNode*>(node);
-      for (int i = 0; i < group_node->field_count(); ++i) {
-        group_node->field(i)->Visit(this);
+  explicit SchemaUpdater(const std::vector<ColumnOrder>& columnOrders)
+      : columnOrders_(columnOrders), leafCount_(0) {}
+
+  void visit(Node* node) override {
+    if (node->isGroup()) {
+      GroupNode* groupNode = static_cast<GroupNode*>(node);
+      for (int i = 0; i < groupNode->fieldCount(); ++i) {
+        groupNode->field(i)->visit(this);
       }
     } else { // leaf node
-      PrimitiveNode* leaf_node = static_cast<PrimitiveNode*>(node);
-      leaf_node->SetColumnOrder(column_orders_[leaf_count_++]);
+      PrimitiveNode* leafNode = static_cast<PrimitiveNode*>(node);
+      leafNode->setColumnOrder(columnOrders_[leafCount_++]);
     }
   }
 
  private:
-  const std::vector<ColumnOrder>& column_orders_;
-  int leaf_count_;
+  const std::vector<ColumnOrder>& columnOrders_;
+  int leafCount_;
 };
 
 void SchemaDescriptor::updateColumnOrders(
-    const std::vector<ColumnOrder>& column_orders) {
-  if (static_cast<int>(column_orders.size()) != num_columns()) {
+    const std::vector<ColumnOrder>& columnOrders) {
+  if (static_cast<int>(columnOrders.size()) != numColumns()) {
     throw ParquetException("Malformed schema: not enough ColumnOrder values");
   }
-  SchemaUpdater visitor(column_orders);
-  const_cast<GroupNode*>(group_node_)->Visit(&visitor);
+  SchemaUpdater visitor(columnOrders);
+  const_cast<GroupNode*>(groupNode_)->visit(&visitor);
 }
 
-void SchemaDescriptor::Init(NodePtr schema) {
+void SchemaDescriptor::init(NodePtr schema) {
   schema_ = std::move(schema);
 
-  if (!schema_->is_group()) {
+  if (!schema_->isGroup()) {
     throw ParquetException("Must initialize with a schema group");
   }
 
-  group_node_ = static_cast<const GroupNode*>(schema_.get());
+  groupNode_ = static_cast<const GroupNode*>(schema_.get());
   leaves_.clear();
 
-  for (int i = 0; i < group_node_->field_count(); ++i) {
-    BuildTree(group_node_->field(i), 0, 0, group_node_->field(i));
+  for (int i = 0; i < groupNode_->fieldCount(); ++i) {
+    buildTree(groupNode_->field(i), 0, 0, groupNode_->field(i));
   }
 }
 
-bool SchemaDescriptor::Equals(
+bool SchemaDescriptor::equals(
     const SchemaDescriptor& other,
-    std::ostream* diff_output) const {
-  if (this->num_columns() != other.num_columns()) {
-    if (diff_output != nullptr) {
-      *diff_output << "This schema has " << this->num_columns()
-                   << " columns, other has " << other.num_columns();
+    std::ostream* diffOutput) const {
+  if (this->numColumns() != other.numColumns()) {
+    if (diffOutput != nullptr) {
+      *diffOutput << "This schema has " << this->numColumns()
+                  << " columns, other has " << other.numColumns();
     }
     return false;
   }
 
-  for (int i = 0; i < this->num_columns(); ++i) {
-    if (!this->Column(i)->Equals(*other.Column(i))) {
-      if (diff_output != nullptr) {
-        *diff_output << "The two columns with index " << i << " differ."
-                     << std::endl
-                     << this->Column(i)->ToString() << std::endl
-                     << other.Column(i)->ToString() << std::endl;
+  for (int i = 0; i < this->numColumns(); ++i) {
+    if (!this->column(i)->equals(*other.column(i))) {
+      if (diffOutput != nullptr) {
+        *diffOutput << "The two columns with index " << i << " differ."
+                    << std::endl
+                    << this->column(i)->toString() << std::endl
+                    << other.column(i)->toString() << std::endl;
       }
       return false;
     }
@@ -903,149 +898,147 @@ bool SchemaDescriptor::Equals(
   return true;
 }
 
-void SchemaDescriptor::BuildTree(
-    const NodePtr& node,
-    int16_t max_def_level,
-    int16_t max_rep_level,
+void SchemaDescriptor::buildTree(
+    const NodePtr& Node,
+    int16_t maxDefLevel,
+    int16_t maxRepLevel,
     const NodePtr& base) {
-  if (node->is_optional()) {
-    ++max_def_level;
-  } else if (node->is_repeated()) {
+  if (Node->isOptional()) {
+    ++maxDefLevel;
+  } else if (Node->isRepeated()) {
     // Repeated fields add a definition level. This is used to distinguish
     // between an empty list and a list with an item in it.
-    ++max_rep_level;
-    ++max_def_level;
+    ++maxRepLevel;
+    ++maxDefLevel;
   }
 
-  // Now, walk the schema and create a ColumnDescriptor for each leaf node
-  if (node->is_group()) {
-    const GroupNode* group = static_cast<const GroupNode*>(node.get());
-    for (int i = 0; i < group->field_count(); ++i) {
-      BuildTree(group->field(i), max_def_level, max_rep_level, base);
+  // Now, walk the schema and create a ColumnDescriptor for each leaf node.
+  if (Node->isGroup()) {
+    const GroupNode* group = static_cast<const GroupNode*>(Node.get());
+    for (int i = 0; i < group->fieldCount(); ++i) {
+      buildTree(group->field(i), maxDefLevel, maxRepLevel, base);
     }
   } else {
-    node_to_leaf_index_[static_cast<const PrimitiveNode*>(node.get())] =
+    nodeToLeafIndex_[static_cast<const PrimitiveNode*>(Node.get())] =
         static_cast<int>(leaves_.size());
 
-    // Primitive node, append to leaves
-    leaves_.push_back(
-        ColumnDescriptor(node, max_def_level, max_rep_level, this));
-    leaf_to_base_.emplace(static_cast<int>(leaves_.size()) - 1, base);
-    leaf_to_idx_.emplace(
-        node->path()->ToDotString(), static_cast<int>(leaves_.size()) - 1);
+    // Primitive node, append to leaves.
+    leaves_.emplace_back(Node, maxDefLevel, maxRepLevel, this);
+    leafToBase_.emplace(static_cast<int>(leaves_.size()) - 1, base);
+    leafToIdx_.emplace(
+        Node->path()->toDotString(), static_cast<int>(leaves_.size()) - 1);
   }
 }
 
-int SchemaDescriptor::GetColumnIndex(const PrimitiveNode& node) const {
-  auto it = node_to_leaf_index_.find(&node);
-  if (it == node_to_leaf_index_.end()) {
+int SchemaDescriptor::getColumnIndex(const PrimitiveNode& Node) const {
+  auto it = nodeToLeafIndex_.find(&Node);
+  if (it == nodeToLeafIndex_.end()) {
     return -1;
   }
   return it->second;
 }
 
 ColumnDescriptor::ColumnDescriptor(
-    schema::NodePtr node,
-    int16_t max_definition_level,
-    int16_t max_repetition_level,
-    const SchemaDescriptor* schema_descr)
-    : node_(std::move(node)),
-      max_definition_level_(max_definition_level),
-      max_repetition_level_(max_repetition_level) {
-  if (!node_->is_primitive()) {
+    schema::NodePtr Node,
+    int16_t maxDefinitionLevel,
+    int16_t maxRepetitionLevel,
+    const SchemaDescriptor* schemaDescr)
+    : node_(std::move(Node)),
+      maxDefinitionLevel_(maxDefinitionLevel),
+      maxRepetitionLevel_(maxRepetitionLevel) {
+  if (!node_->isPrimitive()) {
     throw ParquetException("Must be a primitive type");
   }
-  primitive_node_ = static_cast<const PrimitiveNode*>(node_.get());
+  primitiveNode_ = static_cast<const PrimitiveNode*>(node_.get());
 }
 
-bool ColumnDescriptor::Equals(const ColumnDescriptor& other) const {
-  return primitive_node_->Equals(other.primitive_node_) &&
-      max_repetition_level() == other.max_repetition_level() &&
-      max_definition_level() == other.max_definition_level();
+bool ColumnDescriptor::equals(const ColumnDescriptor& other) const {
+  return primitiveNode_->equals(other.primitiveNode_) &&
+      maxRepetitionLevel() == other.maxRepetitionLevel() &&
+      maxDefinitionLevel() == other.maxDefinitionLevel();
 }
 
-const ColumnDescriptor* SchemaDescriptor::Column(int i) const {
-  CheckColumnBounds(i, leaves_.size());
+const ColumnDescriptor* SchemaDescriptor::column(int i) const {
+  checkColumnBounds(i, leaves_.size());
   return &leaves_[i];
 }
 
-int SchemaDescriptor::ColumnIndex(const std::string& node_path) const {
-  auto search = leaf_to_idx_.find(node_path);
-  if (search == leaf_to_idx_.end()) {
-    // Not found
+int SchemaDescriptor::columnIndex(const std::string& nodePath) const {
+  auto search = leafToIdx_.find(nodePath);
+  if (search == leafToIdx_.end()) {
+    // Not found.
     return -1;
   }
   return search->second;
 }
 
-int SchemaDescriptor::ColumnIndex(const Node& node) const {
-  auto search = leaf_to_idx_.equal_range(node.path()->ToDotString());
+int SchemaDescriptor::columnIndex(const Node& node) const {
+  auto search = leafToIdx_.equal_range(node.path()->toDotString());
   for (auto it = search.first; it != search.second; ++it) {
     const int idx = it->second;
-    if (&node == Column(idx)->schema_node().get()) {
+    if (&node == column(idx)->schemaNode().get()) {
       return idx;
     }
   }
   return -1;
 }
 
-const schema::Node* SchemaDescriptor::GetColumnRoot(int i) const {
-  CheckColumnBounds(i, leaves_.size());
-  return leaf_to_base_.find(i)->second.get();
+const schema::Node* SchemaDescriptor::getColumnRoot(int i) const {
+  checkColumnBounds(i, leaves_.size());
+  return leafToBase_.find(i)->second.get();
 }
 
-bool SchemaDescriptor::HasRepeatedFields() const {
-  return group_node_->HasRepeatedFields();
+bool SchemaDescriptor::hasRepeatedFields() const {
+  return groupNode_->hasRepeatedFields();
 }
 
-std::string SchemaDescriptor::ToString() const {
+std::string SchemaDescriptor::toString() const {
   std::ostringstream ss;
-  PrintSchema(schema_.get(), ss);
+  printSchema(schema_.get(), ss);
   return ss.str();
 }
 
-std::string ColumnDescriptor::ToString() const {
+std::string ColumnDescriptor::toString() const {
   std::ostringstream ss;
   ss << "column descriptor = {" << std::endl
      << "  name: " << name() << "," << std::endl
-     << "  path: " << path()->ToDotString() << "," << std::endl
-     << "  physical_type: " << TypeToString(physical_type()) << "," << std::endl
-     << "  converted_type: " << ConvertedTypeToString(converted_type()) << ","
+     << "  path: " << path()->toDotString() << "," << std::endl
+     << "  physical_type: " << typeToString(physicalType()) << "," << std::endl
+     << "  converted_type: " << convertedTypeToString(convertedType()) << ","
      << std::endl
-     << "  logical_type: " << logical_type()->ToString() << "," << std::endl
-     << "  max_definition_level: " << max_definition_level() << "," << std::endl
-     << "  max_repetition_level: " << max_repetition_level() << ","
-     << std::endl;
-
-  if (physical_type() ==
-      ::facebook::velox::parquet::arrow::Type::FIXED_LEN_BYTE_ARRAY) {
-    ss << "  length: " << type_length() << "," << std::endl;
+     << "  logical_type: " << logicalType()->toString() << "," << std::endl
+     << "  max_definition_level: " << maxDefinitionLevel() << "," << std::endl
+     << "  max_repetition_level: " << maxRepetitionLevel() << "," << std::endl;
+
+  if (physicalType() ==
+      ::facebook::velox::parquet::arrow::Type::kFixedLenByteArray) {
+    ss << "  length: " << typeLength() << "," << std::endl;
   }
 
-  if (converted_type() ==
-      ::facebook::velox::parquet::arrow::ConvertedType::DECIMAL) {
-    ss << "  precision: " << type_precision() << "," << std::endl
-       << "  scale: " << type_scale() << "," << std::endl;
+  if (convertedType() ==
+      ::facebook::velox::parquet::arrow::ConvertedType::kDecimal) {
+    ss << "  precision: " << typePrecision() << "," << std::endl
+       << "  scale: " << typeScale() << "," << std::endl;
   }
 
   ss << "}";
   return ss.str();
 }
 
-int ColumnDescriptor::type_scale() const {
-  return primitive_node_->decimal_metadata().scale;
+int ColumnDescriptor::typeScale() const {
+  return primitiveNode_->decimalMetadata().scale;
 }
 
-int ColumnDescriptor::type_precision() const {
-  return primitive_node_->decimal_metadata().precision;
+int ColumnDescriptor::typePrecision() const {
+  return primitiveNode_->decimalMetadata().precision;
 }
 
-int ColumnDescriptor::type_length() const {
-  return primitive_node_->type_length();
+int ColumnDescriptor::typeLength() const {
+  return primitiveNode_->typeLength();
 }
 
 const std::shared_ptr<ColumnPath> ColumnDescriptor::path() const {
-  return primitive_node_->path();
+  return primitiveNode_->path();
 }
 
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/Schema.h b/velox/dwio/parquet/writer/arrow/Schema.h
index e71493d751d..d9f77840024 100644
--- a/velox/dwio/parquet/writer/arrow/Schema.h
+++ b/velox/dwio/parquet/writer/arrow/Schema.h
@@ -16,8 +16,8 @@
 
 // Adapted from Apache Arrow.
 
-// This module contains the logical parquet-cpp types (independent of Thrift
-// structures), schema nodes, and related type tools
+// This module contains the logical Parquet-cpp types (independent of Thrift
+// structures), schema nodes, and related type tools.
 
 #pragma once
 
@@ -42,23 +42,23 @@ class Node;
 
 // List encodings: using the terminology from Impala to define different styles
 // of representing logical lists (a.k.a. ARRAY types) in Parquet schemas. Since
-// the converted type named in the Parquet metadata is ConvertedType::LIST we
+// the converted type named in the Parquet metadata is ConvertedType::kList we
 // use that terminology here. It also helps distinguish from the *_ARRAY
 // primitive types.
 //
-// One-level encoding: Only allows required lists with required cells
-//   repeated value_type name
+// One-level encoding: Only allows required lists with required cells.
+//   Repeated value_type name.
 //
-// Two-level encoding: Enables optional lists with only required cells
-//   <required/optional> group list
-//     repeated value_type item
+// Two-level encoding: Enables optional lists with only required cells.
+//   <Required/optional> group list.
+//     Repeated value_type item.
 //
-// Three-level encoding: Enables optional lists with optional cells
-//   <required/optional> group bag
-//     repeated group list
-//       <required/optional> value_type item
+// Three-level encoding: Enables optional lists with optional cells.
+//   <Required/optional> group bag.
+//     Repeated group list.
+//       <Required/optional> value_type item.
 //
-// 2- and 1-level encoding are respectively equivalent to 3-level encoding with
+// 2- And 1-level encoding are respectively equivalent to 3-level encoding with
 // the non-repeated nodes set to required.
 //
 // The "official" encoding recommended in the Parquet spec is the 3-level, and
@@ -67,13 +67,13 @@ class Node;
 // "in the wild" we need to be able to interpret the associated definition
 // levels in the context of the actual encoding used in the file.
 //
-// NB: Some Parquet writers may not set ConvertedType::LIST on the repeated
+// NB: Some Parquet writers may not set ConvertedType::kList on the repeated
 // SchemaElement, which could make things challenging if we are trying to infer
 // that a sequence of nodes semantically represents an array according to one
 // of these encodings (versus a struct containing an array). We should refuse
 // the temptation to guess, as they say.
 struct ListEncoding {
-  enum type { ONE_LEVEL, TWO_LEVEL, THREE_LEVEL };
+  enum type { kOneLevel, kTwoLevel, kThreeLevel };
 };
 
 class PARQUET_EXPORT ColumnPath {
@@ -83,53 +83,53 @@ class PARQUET_EXPORT ColumnPath {
   explicit ColumnPath(std::vector<std::string>&& path)
       : path_(std::move(path)) {}
 
-  static std::shared_ptr<ColumnPath> FromDotString(
+  static std::shared_ptr<ColumnPath> fromDotString(
       const std::string& dotstring);
-  static std::shared_ptr<ColumnPath> FromNode(const Node& node);
+  static std::shared_ptr<ColumnPath> fromNode(const Node& Node);
 
-  std::shared_ptr<ColumnPath> extend(const std::string& node_name) const;
-  std::string ToDotString() const;
-  const std::vector<std::string>& ToDotVector() const;
+  std::shared_ptr<ColumnPath> extend(const std::string& nodeName) const;
+  std::string toDotString() const;
+  const std::vector<std::string>& toDotVector() const;
 
  protected:
   std::vector<std::string> path_;
 };
 
 // Base class for logical schema types. A type has a name, repetition level,
-// and optionally a logical type (ConvertedType in Parquet metadata parlance)
+// and optionally a logical type (ConvertedType in Parquet metadata parlance)..
 class PARQUET_EXPORT Node {
  public:
-  enum type { PRIMITIVE, GROUP };
+  enum type { kPrimitive, kGroup };
 
   virtual ~Node() {}
 
-  bool is_primitive() const {
-    return type_ == Node::PRIMITIVE;
+  bool isPrimitive() const {
+    return type_ == Node::kPrimitive;
   }
 
-  bool is_group() const {
-    return type_ == Node::GROUP;
+  bool isGroup() const {
+    return type_ == Node::kGroup;
   }
 
-  bool is_optional() const {
-    return repetition_ == Repetition::OPTIONAL;
+  bool isOptional() const {
+    return repetition_ == Repetition::kOptional;
   }
 
-  bool is_repeated() const {
-    return repetition_ == Repetition::REPEATED;
+  bool isRepeated() const {
+    return repetition_ == Repetition::kRepeated;
   }
 
-  bool is_required() const {
-    return repetition_ == Repetition::REQUIRED;
+  bool isRequired() const {
+    return repetition_ == Repetition::kRequired;
   }
 
-  virtual bool Equals(const Node* other) const = 0;
+  virtual bool equals(const Node* other) const = 0;
 
   const std::string& name() const {
     return name_;
   }
 
-  Node::type node_type() const {
+  Node::type nodeType() const {
     return type_;
   }
 
@@ -137,19 +137,19 @@ class PARQUET_EXPORT Node {
     return repetition_;
   }
 
-  ConvertedType::type converted_type() const {
-    return converted_type_;
+  ConvertedType::type convertedType() const {
+    return convertedType_;
   }
 
-  const std::shared_ptr<const LogicalType>& logical_type() const {
-    return logical_type_;
+  const std::shared_ptr<const LogicalType>& logicalType() const {
+    return logicalType_;
   }
 
-  /// \brief The field_id value for the serialized SchemaElement. If the
-  /// field_id is less than 0 (e.g. -1), it will not be set when serialized to
+  /// \brief The fieldId value for the serialized SchemaElement. If the
+  /// fieldId is less than 0 (e.g. -1), it will not be set when serialized to
   /// Thrift.
-  int field_id() const {
-    return field_id_;
+  int fieldId() const {
+    return fieldId_;
   }
 
   const Node* parent() const {
@@ -158,24 +158,24 @@ class PARQUET_EXPORT Node {
 
   const std::shared_ptr<ColumnPath> path() const;
 
-  virtual void ToParquet(void* element) const = 0;
+  virtual void toParquet(void* element) const = 0;
 
-  // Node::Visitor abstract class for walking schemas with the visitor pattern
+  // Node::Visitor abstract class for walking schemas with the visitor pattern.
   class Visitor {
    public:
     virtual ~Visitor() {}
 
-    virtual void Visit(Node* node) = 0;
+    virtual void visit(Node* Node) = 0;
   };
   class ConstVisitor {
    public:
     virtual ~ConstVisitor() {}
 
-    virtual void Visit(const Node* node) = 0;
+    virtual void visit(const Node* Node) = 0;
   };
 
-  virtual void Visit(Visitor* visitor) = 0;
-  virtual void VisitConst(ConstVisitor* visitor) const = 0;
+  virtual void visit(Visitor* visitor) = 0;
+  virtual void visitConst(ConstVisitor* visitor) const = 0;
 
  protected:
   friend class GroupNode;
@@ -184,188 +184,188 @@ class PARQUET_EXPORT Node {
       Node::type type,
       const std::string& name,
       Repetition::type repetition,
-      ConvertedType::type converted_type = ConvertedType::NONE,
-      int field_id = -1)
+      ConvertedType::type convertedType = ConvertedType::kNone,
+      int fieldId = -1)
       : type_(type),
         name_(name),
         repetition_(repetition),
-        converted_type_(converted_type),
-        field_id_(field_id),
+        convertedType_(convertedType),
+        fieldId_(fieldId),
         parent_(NULLPTR) {}
 
   Node(
       Node::type type,
       const std::string& name,
       Repetition::type repetition,
-      std::shared_ptr<const LogicalType> logical_type,
-      int field_id = -1)
+      std::shared_ptr<const LogicalType> logicalType,
+      int fieldId = -1)
       : type_(type),
         name_(name),
         repetition_(repetition),
-        logical_type_(std::move(logical_type)),
-        field_id_(field_id),
+        logicalType_(std::move(logicalType)),
+        fieldId_(fieldId),
         parent_(NULLPTR) {}
 
   Node::type type_;
   std::string name_;
   Repetition::type repetition_;
-  ConvertedType::type converted_type_;
-  std::shared_ptr<const LogicalType> logical_type_;
-  int field_id_;
+  ConvertedType::type convertedType_;
+  std::shared_ptr<const LogicalType> logicalType_;
+  int fieldId_;
   // Nodes should not be shared, they have a single parent.
   const Node* parent_;
 
-  bool EqualsInternal(const Node* other) const;
-  void SetParent(const Node* p_parent);
+  bool equalsInternal(const Node* other) const;
+  void setParent(const Node* pParent);
 
  private:
   PARQUET_DISALLOW_COPY_AND_ASSIGN(Node);
 };
 
-// Save our breath all over the place with these typedefs
+// Save our breath all over the place with these typedefs.
 using NodePtr = std::shared_ptr<Node>;
 using NodeVector = std::vector<NodePtr>;
 
 // A type that is one of the primitive Parquet storage types. In addition to
 // the other type metadata (name, repetition level, logical type), also has the
 // physical storage type and their type-specific metadata (byte width, decimal
-// parameters)
+// parameters).
 class PARQUET_EXPORT PrimitiveNode : public Node {
  public:
-  static std::unique_ptr<Node> FromParquet(const void* opaque_element);
+  static std::unique_ptr<Node> fromParquet(const void* opaqueElement);
 
-  // A field_id -1 (or any negative value) will be serialized as null in Thrift
-  static inline NodePtr Make(
+  // A field_id -1 (or any negative value) will be serialized as null in Thrift.
+  static inline NodePtr make(
       const std::string& name,
       Repetition::type repetition,
       Type::type type,
-      ConvertedType::type converted_type = ConvertedType::NONE,
+      ConvertedType::type convertedType = ConvertedType::kNone,
       int length = -1,
       int precision = -1,
       int scale = -1,
-      int field_id = -1) {
+      int fieldId = -1) {
     return NodePtr(new PrimitiveNode(
         name,
         repetition,
         type,
-        converted_type,
+        convertedType,
         length,
         precision,
         scale,
-        field_id));
+        fieldId));
   }
 
-  // If no logical type, pass LogicalType::None() or nullptr
-  // A field_id -1 (or any negative value) will be serialized as null in Thrift
-  static inline NodePtr Make(
+  // If no logical type, pass LogicalType::None() or nullptr.
+  // A field_id -1 (or any negative value) will be serialized as null in Thrift.
+  static inline NodePtr make(
       const std::string& name,
       Repetition::type repetition,
-      std::shared_ptr<const LogicalType> logical_type,
-      Type::type primitive_type,
-      int primitive_length = -1,
-      int field_id = -1) {
+      std::shared_ptr<const LogicalType> logicalType,
+      Type::type primitiveType,
+      int primitiveLength = -1,
+      int fieldId = -1) {
     return NodePtr(new PrimitiveNode(
         name,
         repetition,
-        std::move(logical_type),
-        primitive_type,
-        primitive_length,
-        field_id));
+        std::move(logicalType),
+        primitiveType,
+        primitiveLength,
+        fieldId));
   }
 
-  bool Equals(const Node* other) const override;
+  bool equals(const Node* other) const override;
 
-  Type::type physical_type() const {
-    return physical_type_;
+  Type::type physicalType() const {
+    return physicalType_;
   }
 
-  ColumnOrder column_order() const {
-    return column_order_;
+  ColumnOrder columnOrder() const {
+    return columnOrder_;
   }
 
-  void SetColumnOrder(ColumnOrder column_order) {
-    column_order_ = column_order;
+  void setColumnOrder(ColumnOrder columnOrder) {
+    columnOrder_ = columnOrder;
   }
 
-  int32_t type_length() const {
-    return type_length_;
+  int32_t typeLength() const {
+    return typeLength_;
   }
 
-  const DecimalMetadata& decimal_metadata() const {
-    return decimal_metadata_;
+  const DecimalMetadata& decimalMetadata() const {
+    return decimalMetadata_;
   }
 
-  void ToParquet(void* element) const override;
-  void Visit(Visitor* visitor) override;
-  void VisitConst(ConstVisitor* visitor) const override;
+  void toParquet(void* element) const override;
+  void visit(Visitor* visitor) override;
+  void visitConst(ConstVisitor* visitor) const override;
 
  private:
   PrimitiveNode(
       const std::string& name,
       Repetition::type repetition,
       Type::type type,
-      ConvertedType::type converted_type = ConvertedType::NONE,
+      ConvertedType::type convertedType = ConvertedType::kNone,
       int length = -1,
       int precision = -1,
       int scale = -1,
-      int field_id = -1);
+      int fieldId = -1);
 
   PrimitiveNode(
       const std::string& name,
       Repetition::type repetition,
-      std::shared_ptr<const LogicalType> logical_type,
-      Type::type primitive_type,
-      int primitive_length = -1,
-      int field_id = -1);
+      std::shared_ptr<const LogicalType> logicalType,
+      Type::type primitiveType,
+      int primitiveLength = -1,
+      int fieldId = -1);
 
-  Type::type physical_type_;
-  int32_t type_length_;
-  DecimalMetadata decimal_metadata_;
-  ColumnOrder column_order_;
+  Type::type physicalType_;
+  int32_t typeLength_;
+  DecimalMetadata decimalMetadata_;
+  ColumnOrder columnOrder_;
 
-  // For FIXED_LEN_BYTE_ARRAY
-  void SetTypeLength(int32_t length) {
-    type_length_ = length;
+  // For FIXED_LEN_BYTE_ARRAY.
+  void setTypeLength(int32_t length) {
+    typeLength_ = length;
   }
 
-  bool EqualsInternal(const PrimitiveNode* other) const;
+  bool equalsInternal(const PrimitiveNode* other) const;
 
   FRIEND_TEST(TestPrimitiveNode, Attrs);
-  FRIEND_TEST(TestPrimitiveNode, Equals);
+  FRIEND_TEST(TestPrimitiveNode, equals);
   FRIEND_TEST(TestPrimitiveNode, PhysicalLogicalMapping);
-  FRIEND_TEST(TestPrimitiveNode, FromParquet);
+  FRIEND_TEST(TestPrimitiveNode, fromParquet);
 };
 
 class PARQUET_EXPORT GroupNode : public Node {
  public:
-  static std::unique_ptr<Node> FromParquet(
-      const void* opaque_element,
+  static std::unique_ptr<Node> fromParquet(
+      const void* opaqueElement,
       NodeVector fields = {});
 
-  // A field_id -1 (or any negative value) will be serialized as null in Thrift
-  static inline NodePtr Make(
+  // A field_id -1 (or any negative value) will be serialized as null in Thrift.
+  static inline NodePtr make(
       const std::string& name,
       Repetition::type repetition,
       const NodeVector& fields,
-      ConvertedType::type converted_type = ConvertedType::NONE,
-      int field_id = -1) {
+      ConvertedType::type convertedType = ConvertedType::kNone,
+      int fieldId = -1) {
     return NodePtr(
-        new GroupNode(name, repetition, fields, converted_type, field_id));
+        new GroupNode(name, repetition, fields, convertedType, fieldId));
   }
 
-  // If no logical type, pass nullptr
-  // A field_id -1 (or any negative value) will be serialized as null in Thrift
-  static inline NodePtr Make(
+  // If no logical type, pass nullptr.
+  // A field_id -1 (or any negative value) will be serialized as null in Thrift.
+  static inline NodePtr make(
       const std::string& name,
       Repetition::type repetition,
       const NodeVector& fields,
-      std::shared_ptr<const LogicalType> logical_type,
-      int field_id = -1) {
+      std::shared_ptr<const LogicalType> logicalType,
+      int fieldId = -1) {
     return NodePtr(
-        new GroupNode(name, repetition, fields, logical_type, field_id));
+        new GroupNode(name, repetition, fields, logicalType, fieldId));
   }
 
-  bool Equals(const Node* other) const override;
+  bool equals(const Node* other) const override;
 
   const NodePtr& field(int i) const {
     return fields_[i];
@@ -373,80 +373,80 @@ class PARQUET_EXPORT GroupNode : public Node {
   // Get the index of a field by its name, or negative value if not found.
   // If several fields share the same name, it is unspecified which one
   // is returned.
-  int FieldIndex(const std::string& name) const;
+  int fieldIndex(const std::string& name) const;
   // Get the index of a field by its node, or negative value if not found.
-  int FieldIndex(const Node& node) const;
+  int fieldIndex(const Node& node) const;
 
-  int field_count() const {
+  int fieldCount() const {
     return static_cast<int>(fields_.size());
   }
 
-  void ToParquet(void* element) const override;
-  void Visit(Visitor* visitor) override;
-  void VisitConst(ConstVisitor* visitor) const override;
+  void toParquet(void* element) const override;
+  void visit(Visitor* visitor) override;
+  void visitConst(ConstVisitor* visitor) const override;
 
   /// \brief Return true if this node or any child node has REPEATED repetition
-  /// type
-  bool HasRepeatedFields() const;
+  /// type.
+  bool hasRepeatedFields() const;
 
  private:
   GroupNode(
       const std::string& name,
       Repetition::type repetition,
       const NodeVector& fields,
-      ConvertedType::type converted_type = ConvertedType::NONE,
-      int field_id = -1);
+      ConvertedType::type convertedType = ConvertedType::kNone,
+      int fieldId = -1);
 
   GroupNode(
       const std::string& name,
       Repetition::type repetition,
       const NodeVector& fields,
-      std::shared_ptr<const LogicalType> logical_type,
-      int field_id = -1);
+      std::shared_ptr<const LogicalType> logicalType,
+      int fieldId = -1);
 
   NodeVector fields_;
-  bool EqualsInternal(const GroupNode* other) const;
+  bool equalsInternal(const GroupNode* other) const;
 
-  // Mapping between field name to the field index
-  std::unordered_multimap<std::string, int> field_name_to_idx_;
+  // Mapping between field name to the field index.
+  std::unordered_multimap<std::string, int> fieldNameToIdx_;
 
   FRIEND_TEST(TestGroupNode, Attrs);
-  FRIEND_TEST(TestGroupNode, Equals);
-  FRIEND_TEST(TestGroupNode, FieldIndex);
+  FRIEND_TEST(TestGroupNode, equals);
+  FRIEND_TEST(TestGroupNode, fieldIndex);
   FRIEND_TEST(TestGroupNode, FieldIndexDuplicateName);
 };
 
-// ----------------------------------------------------------------------
-// Convenience primitive type factory functions
-
-#define PRIMITIVE_FACTORY(FuncName, TYPE)                 \
-  static inline NodePtr FuncName(                         \
-      const std::string& name,                            \
-      Repetition::type repetition = Repetition::OPTIONAL, \
-      int field_id = -1) {                                \
-    return PrimitiveNode::Make(                           \
-        name,                                             \
-        repetition,                                       \
-        Type::TYPE,                                       \
-        ConvertedType::NONE,                              \
-        /*length=*/-1,                                    \
-        /*precision=*/-1,                                 \
-        /*scale=*/-1,                                     \
-        field_id);                                        \
-  }
-
-PRIMITIVE_FACTORY(Boolean, BOOLEAN)
-PRIMITIVE_FACTORY(Int32, INT32)
-PRIMITIVE_FACTORY(Int64, INT64)
-PRIMITIVE_FACTORY(Int96, INT96)
-PRIMITIVE_FACTORY(Float, FLOAT)
-PRIMITIVE_FACTORY(Double, DOUBLE)
-PRIMITIVE_FACTORY(ByteArray, BYTE_ARRAY)
-
-void PARQUET_EXPORT PrintSchema(
+// ----------------------------------------------------------------------.
+// Convenience primitive type factory functions.
+
+#define PRIMITIVE_FACTORY(funcName, TYPE)                  \
+  static inline NodePtr funcName(                          \
+      const std::string& name,                             \
+      Repetition::type repetition = Repetition::kOptional, \
+      int fieldId = -1) {                                  \
+    return PrimitiveNode::make(                            \
+        name,                                              \
+        repetition,                                        \
+        Type::TYPE,                                        \
+        ConvertedType::kNone,                              \
+        -1,                                                \
+        -1,                                                \
+        -1,                                                \
+        fieldId);                                          \
+  }
+
+PRIMITIVE_FACTORY(boolean, kBoolean)
+PRIMITIVE_FACTORY(int32, kInt32)
+PRIMITIVE_FACTORY(int64, kInt64)
+PRIMITIVE_FACTORY(int96, kInt96)
+PRIMITIVE_FACTORY(floatType, kFloat)
+PRIMITIVE_FACTORY(doubleType, kDouble)
+PRIMITIVE_FACTORY(byteArray, kByteArray)
+
+void PARQUET_EXPORT printSchema(
     const schema::Node* schema,
     std::ostream& stream,
-    int indent_width = 2);
+    int indentWidth = 2);
 
 } // namespace schema
 
@@ -458,166 +458,165 @@ void PARQUET_EXPORT PrintSchema(
 class PARQUET_EXPORT ColumnDescriptor {
  public:
   ColumnDescriptor(
-      schema::NodePtr node,
-      int16_t max_definition_level,
-      int16_t max_repetition_level,
-      const SchemaDescriptor* schema_descr = NULLPTR);
+      schema::NodePtr Node,
+      int16_t maxDefinitionLevel,
+      int16_t maxRepetitionLevel,
+      const SchemaDescriptor* schemaDescr = NULLPTR);
 
-  bool Equals(const ColumnDescriptor& other) const;
+  bool equals(const ColumnDescriptor& other) const;
 
-  int16_t max_definition_level() const {
-    return max_definition_level_;
+  int16_t maxDefinitionLevel() const {
+    return maxDefinitionLevel_;
   }
 
-  int16_t max_repetition_level() const {
-    return max_repetition_level_;
+  int16_t maxRepetitionLevel() const {
+    return maxRepetitionLevel_;
   }
 
-  Type::type physical_type() const {
-    return primitive_node_->physical_type();
+  Type::type physicalType() const {
+    return primitiveNode_->physicalType();
   }
 
-  ConvertedType::type converted_type() const {
-    return primitive_node_->converted_type();
+  ConvertedType::type convertedType() const {
+    return primitiveNode_->convertedType();
   }
 
-  const std::shared_ptr<const LogicalType>& logical_type() const {
-    return primitive_node_->logical_type();
+  const std::shared_ptr<const LogicalType>& logicalType() const {
+    return primitiveNode_->logicalType();
   }
 
-  ColumnOrder column_order() const {
-    return primitive_node_->column_order();
+  ColumnOrder columnOrder() const {
+    return primitiveNode_->columnOrder();
   }
 
-  SortOrder::type sort_order() const {
-    auto la = logical_type();
-    auto pt = physical_type();
-    return la ? GetSortOrder(la, pt) : GetSortOrder(converted_type(), pt);
+  SortOrder::type sortOrder() const {
+    auto la = logicalType();
+    auto pt = physicalType();
+    return la ? getSortOrder(la, pt) : getSortOrder(convertedType(), pt);
   }
 
   const std::string& name() const {
-    return primitive_node_->name();
+    return primitiveNode_->name();
   }
 
   const std::shared_ptr<schema::ColumnPath> path() const;
 
-  const schema::NodePtr& schema_node() const {
+  const schema::NodePtr& schemaNode() const {
     return node_;
   }
 
-  std::string ToString() const;
+  std::string toString() const;
 
-  int type_length() const;
+  int typeLength() const;
 
-  int type_precision() const;
+  int typePrecision() const;
 
-  int type_scale() const;
+  int typeScale() const;
 
  private:
   schema::NodePtr node_;
-  const schema::PrimitiveNode* primitive_node_;
+  const schema::PrimitiveNode* primitiveNode_;
 
-  int16_t max_definition_level_;
-  int16_t max_repetition_level_;
+  int16_t maxDefinitionLevel_;
+  int16_t maxRepetitionLevel_;
 };
 
 // Container for the converted Parquet schema with a computed information from
-// the schema analysis needed for file reading
+// the schema analysis needed for file reading.
 //
-// * Column index to Node
-// * Max repetition / definition levels for each primitive node
+// * Column index to Node.
+// * Max repetition / definition levels for each primitive node.
 //
 // The ColumnDescriptor objects produced by this class can be used to assist in
 // the reconstruction of fully materialized data structures from the
-// repetition-definition level encoding of nested data
+// repetition-definition level encoding of nested data.
 //
-// TODO(wesm): this object can be recomputed from a Schema
+// TODO(wesm): This object can be recomputed from a Schema.
 class PARQUET_EXPORT SchemaDescriptor {
  public:
   SchemaDescriptor() {}
   ~SchemaDescriptor() {}
 
-  // Analyze the schema
-  void Init(std::unique_ptr<schema::Node> schema);
-  void Init(schema::NodePtr schema);
+  // Analyze the schema.
+  void init(std::unique_ptr<schema::Node> schema);
+  void init(schema::NodePtr schema);
 
-  const ColumnDescriptor* Column(int i) const;
+  const ColumnDescriptor* column(int i) const;
 
   // Get the index of a column by its dotstring path, or negative value if not
   // found. If several columns share the same dotstring path, it is unspecified
   // which one is returned.
-  int ColumnIndex(const std::string& node_path) const;
+  int columnIndex(const std::string& nodePath) const;
   // Get the index of a column by its node, or negative value if not found.
-  int ColumnIndex(const schema::Node& node) const;
+  int columnIndex(const schema::Node& node) const;
 
-  bool Equals(
-      const SchemaDescriptor& other,
-      std::ostream* diff_output = NULLPTR) const;
+  bool equals(const SchemaDescriptor& other, std::ostream* diffOutput = NULLPTR)
+      const;
 
-  // The number of physical columns appearing in the file
-  int num_columns() const {
+  // The number of physical columns appearing in the file.
+  int numColumns() const {
     return static_cast<int>(leaves_.size());
   }
 
-  const schema::NodePtr& schema_root() const {
+  const schema::NodePtr& schemaRoot() const {
     return schema_;
   }
 
-  const schema::GroupNode* group_node() const {
-    return group_node_;
+  const schema::GroupNode* groupNode() const {
+    return groupNode_;
   }
 
-  // Returns the root (child of the schema root) node of the leaf(column) node
-  const schema::Node* GetColumnRoot(int i) const;
+  // Returns the root (child of the schema root) node of the leaf (column) node.
+  const schema::Node* getColumnRoot(int i) const;
 
   const std::string& name() const {
-    return group_node_->name();
+    return groupNode_->name();
   }
 
-  std::string ToString() const;
+  std::string toString() const;
 
-  void updateColumnOrders(const std::vector<ColumnOrder>& column_orders);
+  void updateColumnOrders(const std::vector<ColumnOrder>& columnOrders);
 
   /// \brief Return column index corresponding to a particular
-  /// PrimitiveNode. Returns -1 if not found
-  int GetColumnIndex(const schema::PrimitiveNode& node) const;
+  /// PrimitiveNode. Returns -1 if not found.
+  int getColumnIndex(const schema::PrimitiveNode& node) const;
 
-  /// \brief Return true if any field or their children have REPEATED repetition
-  /// type
-  bool HasRepeatedFields() const;
+  /// \brief Return true if any field or their children have REPEATED
+  /// repetition type.
+  bool hasRepeatedFields() const;
 
  private:
   friend class ColumnDescriptor;
 
-  // Root Node
+  // Root Node.
   schema::NodePtr schema_;
-  // Root Node
-  const schema::GroupNode* group_node_;
+  // Root Node.
+  const schema::GroupNode* groupNode_;
 
-  void BuildTree(
-      const schema::NodePtr& node,
-      int16_t max_def_level,
-      int16_t max_rep_level,
+  void buildTree(
+      const schema::NodePtr& Node,
+      int16_t maxDefLevel,
+      int16_t maxRepLevel,
       const schema::NodePtr& base);
 
-  // Result of leaf node / tree analysis
+  // Result of leaf node / tree analysis.
   std::vector<ColumnDescriptor> leaves_;
 
-  std::unordered_map<const schema::PrimitiveNode*, int> node_to_leaf_index_;
+  std::unordered_map<const schema::PrimitiveNode*, int> nodeToLeafIndex_;
 
   // Mapping between leaf nodes and root group of leaf (first node
-  // below the schema's root group)
+  // below the schema's root group).
   //
-  // For example, the leaf `a.b.c.d` would have a link back to `a`
+  // For example, the leaf `a.b.c.d` would have a link back to `a`.
   //
-  // -- a  <------
-  // -- -- b     |
-  // -- -- -- c  |
-  // -- -- -- -- d
-  std::unordered_map<int, schema::NodePtr> leaf_to_base_;
-
-  // Mapping between ColumnPath DotString to the leaf index
-  std::unordered_multimap<std::string, int> leaf_to_idx_;
+  // -- A  <------.
+  // -- -- B     |.
+  // -- -- -- C  |.
+  // -- -- -- -- D.
+  std::unordered_map<int, schema::NodePtr> leafToBase_;
+
+  // Mapping between ColumnPath DotString to the leaf index.
+  std::unordered_multimap<std::string, int> leafToIdx_;
 };
 
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/SchemaInternal.h b/velox/dwio/parquet/writer/arrow/SchemaInternal.h
index 7b8e9e5c073..85eae7b7e87 100644
--- a/velox/dwio/parquet/writer/arrow/SchemaInternal.h
+++ b/velox/dwio/parquet/writer/arrow/SchemaInternal.h
@@ -16,7 +16,7 @@
 
 // Adapted from Apache Arrow.
 
-// Non-public Thrift schema serialization utilities
+// Non-public Thrift schema serialization utilities.
 
 #pragma once
 
@@ -35,23 +35,23 @@ class SchemaElement;
 
 namespace schema {
 
-// ----------------------------------------------------------------------
-// Conversion from Parquet Thrift metadata
+// ----------------------------------------------------------------------.
+// Conversion from Parquet Thrift metadata.
 
 PARQUET_EXPORT
-std::shared_ptr<SchemaDescriptor> FromParquet(
+std::shared_ptr<SchemaDescriptor> fromParquet(
     const std::vector<facebook::velox::parquet::thrift::SchemaElement>& schema);
 
 PARQUET_EXPORT
-std::unique_ptr<Node> Unflatten(
+std::unique_ptr<Node> unflatten(
     const facebook::velox::parquet::thrift::SchemaElement* elements,
     int length);
 
-// ----------------------------------------------------------------------
-// Conversion to Parquet Thrift metadata
+// ----------------------------------------------------------------------.
+// Conversion to Parquet Thrift metadata.
 
 PARQUET_EXPORT
-void ToParquet(
+void toParquet(
     const GroupNode* schema,
     std::vector<facebook::velox::parquet::thrift::SchemaElement>* out);
 
diff --git a/velox/dwio/parquet/writer/arrow/Statistics.cpp b/velox/dwio/parquet/writer/arrow/Statistics.cpp
index 757ac36b62e..3d88fc41d33 100644
--- a/velox/dwio/parquet/writer/arrow/Statistics.cpp
+++ b/velox/dwio/parquet/writer/arrow/Statistics.cpp
@@ -39,6 +39,10 @@
 #include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/Platform.h"
 #include "velox/dwio/parquet/writer/arrow/Schema.h"
+#include "velox/dwio/parquet/writer/arrow/StringTruncation.h"
+
+#include "velox/type/DecimalUtil.h"
+#include "velox/type/HugeInt.h"
 
 using arrow::default_memory_pool;
 using arrow::MemoryPool;
@@ -53,21 +57,21 @@ inline std::enable_if_t<
     std::is_trivially_copyable_v<T> && std::is_trivially_copyable_v<U> &&
         sizeof(T) == sizeof(U),
     U>
-SafeCopy(T value) {
+safeCopy(T value) {
   std::remove_const_t<U> ret;
   std::memcpy(&ret, &value, sizeof(T));
   return ret;
 }
 
 template <typename T>
-inline std::enable_if_t<std::is_trivially_copyable_v<T>, T> SafeLoad(
+inline std::enable_if_t<std::is_trivially_copyable_v<T>, T> safeLoad(
     const T* unaligned) {
   std::remove_const_t<T> ret;
   std::memcpy(&ret, unaligned, sizeof(T));
   return ret;
 }
 
-std::shared_ptr<ResizableBuffer> AllocateBuffer(
+std::shared_ptr<ResizableBuffer> allocateBuffer(
     MemoryPool* pool,
     int64_t size) {
   PARQUET_ASSIGN_OR_THROW(
@@ -76,94 +80,99 @@ std::shared_ptr<ResizableBuffer> AllocateBuffer(
 }
 
 // ----------------------------------------------------------------------
-// Comparator implementations
+// Comparator implementations.
 
-constexpr int value_length(int value_length, const ByteArray& value) {
+constexpr int valueLength(int valueLength, const ByteArray& value) {
   return value.len;
 }
-constexpr int value_length(int type_length, const FLBA& value) {
-  return type_length;
+constexpr int valueLength(int typeLength, const FLBA& value) {
+  return typeLength;
 }
 
-template <typename DType, bool is_signed>
+template <typename DType, bool isSigned>
 struct CompareHelper {
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
 
   static_assert(
       !std::is_unsigned<T>::value || std::is_same<T, bool>::value,
       "T is an unsigned numeric");
 
-  constexpr static T DefaultMin() {
+  constexpr static T defaultMin() {
+    if constexpr (std::is_floating_point_v<T>) {
+      return std::numeric_limits<T>::infinity();
+    }
     return std::numeric_limits<T>::max();
   }
-  constexpr static T DefaultMax() {
-    return std::numeric_limits<T>::lowest();
+  constexpr static T defaultMax() {
+    if constexpr (std::is_floating_point_v<T>) {
+      return -std::numeric_limits<T>::infinity();
+    }
+    return std::numeric_limits<T>::min();
   }
 
   // MSVC17 fix, isnan is not overloaded for IntegralType as per C++11
   // standard requirements.
   template <typename T1 = T>
-  static ::arrow::enable_if_t<std::is_floating_point<T1>::value, T> Coalesce(
+  static ::arrow::enable_if_t<std::is_floating_point<T1>::value, T> coalesce(
       T val,
       T fallback) {
     return std::isnan(val) ? fallback : val;
   }
 
   template <typename T1 = T>
-  static ::arrow::enable_if_t<!std::is_floating_point<T1>::value, T> Coalesce(
+  static ::arrow::enable_if_t<!std::is_floating_point<T1>::value, T> coalesce(
       T val,
       T fallback) {
     return val;
   }
 
-  static inline bool Compare(int type_length, const T& a, const T& b) {
+  static inline bool compare(int typeLength, const T& a, const T& b) {
     return a < b;
   }
 
-  static T Min(int type_length, T a, T b) {
+  static T min(int typeLength, T a, T b) {
     return a < b ? a : b;
   }
-  static T Max(int type_length, T a, T b) {
+  static T max(int typeLength, T a, T b) {
     return a < b ? b : a;
   }
 };
 
 template <typename DType>
 struct UnsignedCompareHelperBase {
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
   using UCType = typename std::make_unsigned<T>::type;
 
   static_assert(!std::is_same<T, UCType>::value, "T is unsigned");
   static_assert(sizeof(T) == sizeof(UCType), "T and UCType not the same size");
 
-  // NOTE: according to the C++ spec, unsigned-to-signed conversion is
+  // NOTE: According to the C++ spec, unsigned-to-signed conversion is
   // implementation-defined if the original value does not fit in the signed
-  // type (i.e., two's complement cannot be assumed even on mainstream machines,
-  // because the compiler may decide otherwise).  Hence the use of `SafeCopy`
-  // below for deterministic bit-casting.
-  // (see "Integer conversions" in
-  //  https://en.cppreference.com/w/cpp/language/implicit_conversion)
+  // type (i.e., two's complement cannot be assumed even on mainstream
+  // machines, because the compiler may decide otherwise).  Hence the use of
+  // `safeCopy` below for deterministic bit-casting. (See "Integer conversions"
+  // in https://en.cppreference.com/w/cpp/language/implicit_conversion).
 
-  static const T DefaultMin() {
-    return SafeCopy<T>(std::numeric_limits<UCType>::max());
+  static const T defaultMin() {
+    return safeCopy<T>(std::numeric_limits<UCType>::max());
   }
-  static const T DefaultMax() {
+  static const T defaultMax() {
     return 0;
   }
 
-  static T Coalesce(T val, T fallback) {
+  static T coalesce(T val, T fallback) {
     return val;
   }
 
-  static bool Compare(int type_length, T a, T b) {
-    return SafeCopy<UCType>(a) < SafeCopy<UCType>(b);
+  static bool compare(int typeLength, T a, T b) {
+    return safeCopy<UCType>(a) < safeCopy<UCType>(b);
   }
 
-  static T Min(int type_length, T a, T b) {
-    return Compare(type_length, a, b) ? a : b;
+  static T min(int typeLength, T a, T b) {
+    return compare(typeLength, a, b) ? a : b;
   }
-  static T Max(int type_length, T a, T b) {
-    return Compare(type_length, a, b) ? b : a;
+  static T max(int typeLength, T a, T b) {
+    return compare(typeLength, a, b) ? b : a;
   }
 };
 
@@ -175,208 +184,207 @@ template <>
 struct CompareHelper<Int64Type, false>
     : public UnsignedCompareHelperBase<Int64Type> {};
 
-template <bool is_signed>
-struct CompareHelper<Int96Type, is_signed> {
-  using T = typename Int96Type::c_type;
-  using msb_type =
-      typename std::conditional<is_signed, int32_t, uint32_t>::type;
+template <bool isSigned>
+struct CompareHelper<Int96Type, isSigned> {
+  using T = typename Int96Type::CType;
+  using MsbType = typename std::conditional<isSigned, int32_t, uint32_t>::type;
 
-  static T DefaultMin() {
-    uint32_t kMsbMax = SafeCopy<uint32_t>(std::numeric_limits<msb_type>::max());
+  static T defaultMin() {
+    uint32_t kMsbMax = safeCopy<uint32_t>(std::numeric_limits<MsbType>::max());
     uint32_t kMax = std::numeric_limits<uint32_t>::max();
     return {kMax, kMax, kMsbMax};
   }
-  static T DefaultMax() {
-    uint32_t kMsbMin = SafeCopy<uint32_t>(std::numeric_limits<msb_type>::min());
+  static T defaultMax() {
+    uint32_t kMsbMin = safeCopy<uint32_t>(std::numeric_limits<MsbType>::min());
     uint32_t kMin = std::numeric_limits<uint32_t>::min();
     return {kMin, kMin, kMsbMin};
   }
-  static T Coalesce(T val, T fallback) {
+  static T coalesce(T val, T fallback) {
     return val;
   }
 
-  static inline bool Compare(int type_length, const T& a, const T& b) {
+  static inline bool compare(int typeLength, const T& a, const T& b) {
     if (a.value[2] != b.value[2]) {
-      // Only the MSB bit is by Signed comparison. For little-endian, this is
+      // Only the MSB bit is by signed comparison. For little-endian, this is
       // the last bit of Int96 type.
-      return SafeCopy<msb_type>(a.value[2]) < SafeCopy<msb_type>(b.value[2]);
+      return safeCopy<MsbType>(a.value[2]) < safeCopy<MsbType>(b.value[2]);
     } else if (a.value[1] != b.value[1]) {
       return (a.value[1] < b.value[1]);
     }
     return (a.value[0] < b.value[0]);
   }
 
-  static T Min(int type_length, const T& a, const T& b) {
-    return Compare(0, a, b) ? a : b;
+  static T min(int typeLength, const T& a, const T& b) {
+    return compare(0, a, b) ? a : b;
   }
-  static T Max(int type_length, const T& a, const T& b) {
-    return Compare(0, a, b) ? b : a;
+  static T max(int typeLength, const T& a, const T& b) {
+    return compare(0, a, b) ? b : a;
   }
 };
 
-template <typename T, bool is_signed>
+template <typename T, bool isSigned>
 struct BinaryLikeComparer {};
 
 template <typename T>
-struct BinaryLikeComparer<T, /*is_signed=*/false> {
-  static bool Compare(int type_length, const T& a, const T& b) {
-    int a_length = value_length(type_length, a);
-    int b_length = value_length(type_length, b);
+struct BinaryLikeComparer<T, false> {
+  static bool compare(int typeLength, const T& a, const T& b) {
+    int aLength = valueLength(typeLength, a);
+    int bLength = valueLength(typeLength, b);
     // Unsigned comparison is used for non-numeric types so straight
-    // lexicographic comparison makes sense. (a.ptr is always unsigned)....
+    // lexicographic comparison makes sense (a.ptr is always unsigned).
     return std::lexicographical_compare(
-        a.ptr, a.ptr + a_length, b.ptr, b.ptr + b_length);
+        a.ptr, a.ptr + aLength, b.ptr, b.ptr + bLength);
   }
 };
 
 template <typename T>
-struct BinaryLikeComparer<T, /*is_signed=*/true> {
-  static bool Compare(int type_length, const T& a, const T& b) {
+struct BinaryLikeComparer<T, true> {
+  static bool compare(int typeLength, const T& a, const T& b) {
     // Is signed is used for integers encoded as big-endian twos
-    // complement integers. (e.g. decimals).
-    int a_length = value_length(type_length, a);
-    int b_length = value_length(type_length, b);
+    // complement integers (e.g., decimals).
+    int aLength = valueLength(typeLength, a);
+    int bLength = valueLength(typeLength, b);
 
     // At least of the lengths is zero.
-    if (a_length == 0 || b_length == 0) {
-      return a_length == 0 && b_length > 0;
+    if (aLength == 0 || bLength == 0) {
+      return aLength == 0 && bLength > 0;
     }
 
-    int8_t first_a = *a.ptr;
-    int8_t first_b = *b.ptr;
+    int8_t firstA = *a.ptr;
+    int8_t firstB = *b.ptr;
     // We can short circuit for different signed numbers or
     // for equal length bytes arrays that have different first bytes.
     // The equality requirement is necessary for sign extension cases.
-    // 0xFF10 should be equal to 0x10 (due to big endian sign extension).
-    if ((0x80 & first_a) != (0x80 & first_b) ||
-        (a_length == b_length && first_a != first_b)) {
-      return first_a < first_b;
+    // 0xff10 should be equal to 0x10 (due to big-endian sign extension).
+    if ((0x80 & firstA) != (0x80 & firstB) ||
+        (aLength == bLength && firstA != firstB)) {
+      return firstA < firstB;
     }
     // When the lengths are unequal and the numbers are of the same
     // sign we need to do comparison by sign extending the shorter
     // value first, and once we get to equal sized arrays, lexicographical
     // unsigned comparison of everything but the first byte is sufficient.
-    const uint8_t* a_start = a.ptr;
-    const uint8_t* b_start = b.ptr;
-    if (a_length != b_length) {
-      const uint8_t* lead_start = nullptr;
-      const uint8_t* lead_end = nullptr;
-      if (a_length > b_length) {
-        int lead_length = a_length - b_length;
-        lead_start = a.ptr;
-        lead_end = a.ptr + lead_length;
-        a_start += lead_length;
+    const uint8_t* aStart = a.ptr;
+    const uint8_t* bStart = b.ptr;
+    if (aLength != bLength) {
+      const uint8_t* leadStart = nullptr;
+      const uint8_t* leadEnd = nullptr;
+      if (aLength > bLength) {
+        int leadLength = aLength - bLength;
+        leadStart = a.ptr;
+        leadEnd = a.ptr + leadLength;
+        aStart += leadLength;
       } else {
-        VELOX_DCHECK_LT(a_length, b_length);
-        int lead_length = b_length - a_length;
-        lead_start = b.ptr;
-        lead_end = b.ptr + lead_length;
-        b_start += lead_length;
+        VELOX_DCHECK_LT(aLength, bLength);
+        int leadLength = bLength - aLength;
+        leadStart = b.ptr;
+        leadEnd = b.ptr + leadLength;
+        bStart += leadLength;
       }
       // Compare extra bytes to the sign extension of the first
       // byte of the other number.
-      uint8_t extension = first_a < 0 ? 0xFF : 0;
-      bool not_equal =
-          std::any_of(lead_start, lead_end, [extension](uint8_t a) {
-            return extension != a;
-          });
-      if (not_equal) {
+      uint8_t extension = firstA < 0 ? 0xFF : 0;
+      bool notEqual = std::any_of(leadStart, leadEnd, [extension](uint8_t a) {
+        return extension != a;
+      });
+      if (notEqual) {
         // Since sign extension are extrema values for unsigned bytes:
         //
         // Four cases exist:
-        //    negative values:
-        //      b is the longer value.
-        //        b must be the lesser value: return false
-        //      else:
-        //        a must be the lesser value: return true
+        //    Negative values:
+        //      B is the longer value.
+        //        B must be the lesser value: return false.
+        //      Else:
+        //        A must be the lesser value: return true.
         //
-        //    positive values:
-        //      b is the longer value.
-        //        values in b must be greater than a: return true
-        //      else:
-        //        values in a must be greater than b: return false
-        bool negative_values = first_a < 0;
-        bool b_longer = a_length < b_length;
-        return negative_values != b_longer;
+        //    Positive values:
+        //      B is the longer value.
+        //        Values in b must be greater than a: return true.
+        //      Else:
+        //        Values in a must be greater than b: return false.
+        bool negativeValues = firstA < 0;
+        bool bLonger = aLength < bLength;
+        return negativeValues != bLonger;
       }
     } else {
-      a_start++;
-      b_start++;
+      aStart++;
+      bStart++;
     }
     return std::lexicographical_compare(
-        a_start, a.ptr + a_length, b_start, b.ptr + b_length);
+        aStart, a.ptr + aLength, bStart, b.ptr + bLength);
   }
 };
 
-template <typename DType, bool is_signed>
+template <typename DType, bool isSigned>
 struct BinaryLikeCompareHelperBase {
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
 
-  static T DefaultMin() {
+  static T defaultMin() {
     return {};
   }
-  static T DefaultMax() {
+  static T defaultMax() {
     return {};
   }
-  static T Coalesce(T val, T fallback) {
+  static T coalesce(T val, T fallback) {
     return val;
   }
 
-  static inline bool Compare(int type_length, const T& a, const T& b) {
-    return BinaryLikeComparer<T, is_signed>::Compare(type_length, a, b);
+  static inline bool compare(int typeLength, const T& a, const T& b) {
+    return BinaryLikeComparer<T, isSigned>::compare(typeLength, a, b);
   }
-  static T Min(int type_length, const T& a, const T& b) {
+  static T min(int typeLength, const T& a, const T& b) {
     if (a.ptr == nullptr)
       return b;
     if (b.ptr == nullptr)
       return a;
-    return Compare(type_length, a, b) ? a : b;
+    return compare(typeLength, a, b) ? a : b;
   }
 
-  static T Max(int type_length, const T& a, const T& b) {
+  static T max(int typeLength, const T& a, const T& b) {
     if (a.ptr == nullptr)
       return b;
     if (b.ptr == nullptr)
       return a;
-    return Compare(type_length, a, b) ? b : a;
+    return compare(typeLength, a, b) ? b : a;
   }
 };
 
-template <bool is_signed>
-struct CompareHelper<ByteArrayType, is_signed>
-    : public BinaryLikeCompareHelperBase<ByteArrayType, is_signed> {};
+template <bool isSigned>
+struct CompareHelper<ByteArrayType, isSigned>
+    : public BinaryLikeCompareHelperBase<ByteArrayType, isSigned> {};
 
-template <bool is_signed>
-struct CompareHelper<FLBAType, is_signed>
-    : public BinaryLikeCompareHelperBase<FLBAType, is_signed> {};
+template <bool isSigned>
+struct CompareHelper<FLBAType, isSigned>
+    : public BinaryLikeCompareHelperBase<FLBAType, isSigned> {};
 
 using ::std::optional;
 
 template <typename T>
 ::arrow::enable_if_t<std::is_integral<T>::value, optional<std::pair<T, T>>>
-CleanStatistic(std::pair<T, T> min_max) {
-  return min_max;
+cleanStatistic(std::pair<T, T> minMax) {
+  return minMax;
 }
 
 // In case of floating point types, the following rules are applied (as per
 // upstream parquet-mr):
 // - If any of min/max is NaN, return nothing.
-// - If min is 0.0f, replace with -0.0f
-// - If max is -0.0f, replace with 0.0f
+// - If min is infinity and max is -infinity, return nothing.
+// - If min is 0.0f, replace with -0.0f.
+// - If max is -0.0f, replace with 0.0f.
 template <typename T>
 ::arrow::
     enable_if_t<std::is_floating_point<T>::value, optional<std::pair<T, T>>>
-    CleanStatistic(std::pair<T, T> min_max) {
-  T min = min_max.first;
-  T max = min_max.second;
+    cleanStatistic(std::pair<T, T> minMax) {
+  T min = minMax.first;
+  T max = minMax.second;
 
   // Ignore if one of the value is nan.
   if (std::isnan(min) || std::isnan(max)) {
     return ::std::nullopt;
   }
 
-  if (min == std::numeric_limits<T>::max() &&
-      max == std::numeric_limits<T>::lowest()) {
+  if (min == std::numeric_limits<T>::infinity() &&
+      max == -std::numeric_limits<T>::infinity()) {
     return ::std::nullopt;
   }
 
@@ -393,141 +401,139 @@ ::arrow::
   return {{min, max}};
 }
 
-optional<std::pair<FLBA, FLBA>> CleanStatistic(std::pair<FLBA, FLBA> min_max) {
-  if (min_max.first.ptr == nullptr || min_max.second.ptr == nullptr) {
+optional<std::pair<FLBA, FLBA>> cleanStatistic(std::pair<FLBA, FLBA> minMax) {
+  if (minMax.first.ptr == nullptr || minMax.second.ptr == nullptr) {
     return ::std::nullopt;
   }
-  return min_max;
+  return minMax;
 }
 
-optional<std::pair<ByteArray, ByteArray>> CleanStatistic(
-    std::pair<ByteArray, ByteArray> min_max) {
-  if (min_max.first.ptr == nullptr || min_max.second.ptr == nullptr) {
+optional<std::pair<ByteArray, ByteArray>> cleanStatistic(
+    std::pair<ByteArray, ByteArray> minMax) {
+  if (minMax.first.ptr == nullptr || minMax.second.ptr == nullptr) {
     return ::std::nullopt;
   }
-  return min_max;
+  return minMax;
 }
 
-template <bool is_signed, typename DType>
+template <bool isSigned, typename DType>
 class TypedComparatorImpl : virtual public TypedComparator<DType> {
  public:
-  using T = typename DType::c_type;
-  using Helper = CompareHelper<DType, is_signed>;
+  using T = typename DType::CType;
+  using Helper = CompareHelper<DType, isSigned>;
 
-  explicit TypedComparatorImpl(int type_length = -1)
-      : type_length_(type_length) {}
+  explicit TypedComparatorImpl(int typeLength = -1) : typeLength_(typeLength) {}
 
-  bool CompareInline(const T& a, const T& b) const {
-    return Helper::Compare(type_length_, a, b);
+  bool compareInline(const T& a, const T& b) const {
+    return Helper::compare(typeLength_, a, b);
   }
 
-  bool Compare(const T& a, const T& b) override {
-    return CompareInline(a, b);
+  bool compare(const T& a, const T& b) override {
+    return compareInline(a, b);
   }
 
-  std::pair<T, T> GetMinMax(const T* values, int64_t length) override {
+  std::pair<T, T> getMinMax(const T* values, int64_t length) override {
     VELOX_DCHECK_GT(length, 0);
 
-    T min = Helper::DefaultMin();
-    T max = Helper::DefaultMax();
+    T min = Helper::defaultMin();
+    T max = Helper::defaultMax();
 
     for (int64_t i = 0; i < length; i++) {
-      const auto val = SafeLoad(values + i);
-      min = Helper::Min(
-          type_length_, min, Helper::Coalesce(val, Helper::DefaultMin()));
-      max = Helper::Max(
-          type_length_, max, Helper::Coalesce(val, Helper::DefaultMax()));
+      const auto val = safeLoad(values + i);
+      min = Helper::min(
+          typeLength_, min, Helper::coalesce(val, Helper::defaultMin()));
+      max = Helper::max(
+          typeLength_, max, Helper::coalesce(val, Helper::defaultMax()));
     }
 
     return {min, max};
   }
 
-  std::pair<T, T> GetMinMaxSpaced(
+  std::pair<T, T> getMinMaxSpaced(
       const T* values,
       int64_t length,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset) override {
+      const uint8_t* validBits,
+      int64_t validBitsOffset) override {
     VELOX_DCHECK_GT(length, 0);
 
-    T min = Helper::DefaultMin();
-    T max = Helper::DefaultMax();
+    T min = Helper::defaultMin();
+    T max = Helper::defaultMax();
 
     ::arrow::internal::VisitSetBitRunsVoid(
-        valid_bits,
-        valid_bits_offset,
+        validBits,
+        validBitsOffset,
         length,
         [&](int64_t position, int64_t length) {
           for (int64_t i = 0; i < length; i++) {
-            const auto val = SafeLoad(values + i + position);
-            min = Helper::Min(
-                type_length_, min, Helper::Coalesce(val, Helper::DefaultMin()));
-            max = Helper::Max(
-                type_length_, max, Helper::Coalesce(val, Helper::DefaultMax()));
+            const auto val = safeLoad(values + i + position);
+            min = Helper::min(
+                typeLength_, min, Helper::coalesce(val, Helper::defaultMin()));
+            max = Helper::max(
+                typeLength_, max, Helper::coalesce(val, Helper::defaultMax()));
           }
         });
 
     return {min, max};
   }
 
-  std::pair<T, T> GetMinMax(const ::arrow::Array& values) override;
+  std::pair<T, T> getMinMax(const ::arrow::Array& values) override;
 
  private:
-  int type_length_;
+  int typeLength_;
 };
 
-// ARROW-11675: A hand-written version of GetMinMax(), to work around
+// ARROW-11675: A hand-written version of getMinMax(), to work around
 // what looks like a MSVC code generation bug.
-// This does not seem to be required for GetMinMaxSpaced().
+// This does not seem to be required for getMinMaxSpaced().
 template <>
-std::pair<int32_t, int32_t>
-TypedComparatorImpl</*is_signed=*/false, Int32Type>::GetMinMax(
+std::pair<int32_t, int32_t> TypedComparatorImpl<false, Int32Type>::getMinMax(
     const int32_t* values,
     int64_t length) {
   VELOX_DCHECK_GT(length, 0);
 
-  const uint32_t* unsigned_values = reinterpret_cast<const uint32_t*>(values);
+  const uint32_t* unsignedValues = reinterpret_cast<const uint32_t*>(values);
   uint32_t min = std::numeric_limits<uint32_t>::max();
   uint32_t max = std::numeric_limits<uint32_t>::lowest();
 
   for (int64_t i = 0; i < length; i++) {
-    const auto val = unsigned_values[i];
+    const auto val = unsignedValues[i];
     min = std::min<uint32_t>(min, val);
     max = std::max<uint32_t>(max, val);
   }
 
-  return {SafeCopy<int32_t>(min), SafeCopy<int32_t>(max)};
+  return {safeCopy<int32_t>(min), safeCopy<int32_t>(max)};
 }
 
-template <bool is_signed, typename DType>
-std::pair<typename DType::c_type, typename DType::c_type>
-TypedComparatorImpl<is_signed, DType>::GetMinMax(const ::arrow::Array& values) {
+template <bool isSigned, typename DType>
+std::pair<typename DType::CType, typename DType::CType>
+TypedComparatorImpl<isSigned, DType>::getMinMax(const ::arrow::Array& values) {
   ParquetException::NYI(values.type()->ToString());
 }
 
-template <bool is_signed>
-std::pair<ByteArray, ByteArray> GetMinMaxBinaryHelper(
-    const TypedComparatorImpl<is_signed, ByteArrayType>& comparator,
+template <bool isSigned>
+std::pair<ByteArray, ByteArray> getMinMaxBinaryHelper(
+    const TypedComparatorImpl<isSigned, ByteArrayType>& Comparator,
     const ::arrow::Array& values) {
-  using Helper = CompareHelper<ByteArrayType, is_signed>;
+  using Helper = CompareHelper<ByteArrayType, isSigned>;
 
-  ByteArray min = Helper::DefaultMin();
-  ByteArray max = Helper::DefaultMax();
-  constexpr int type_length = -1;
+  ByteArray min = Helper::defaultMin();
+  ByteArray max = Helper::defaultMax();
+  constexpr int typeLength = -1;
 
-  const auto valid_func = [&](std::string_view val) {
+  const auto validFunc = [&](std::string_view val) {
     ByteArray ba{std::string_view(val.data(), val.size())};
-    min = Helper::Min(type_length, ba, min);
-    max = Helper::Max(type_length, ba, max);
+    min = Helper::min(typeLength, ba, min);
+    max = Helper::max(typeLength, ba, max);
   };
-  const auto null_func = [&]() {};
+  const auto nullFunc = [&]() {};
 
   if (::arrow::is_binary_like(values.type_id())) {
     ::arrow::VisitArraySpanInline<::arrow::BinaryType>(
-        *values.data(), std::move(valid_func), std::move(null_func));
+        *values.data(), std::move(validFunc), std::move(nullFunc));
   } else {
     VELOX_DCHECK(::arrow::is_large_binary_like(values.type_id()));
     ::arrow::VisitArraySpanInline<::arrow::LargeBinaryType>(
-        *values.data(), std::move(valid_func), std::move(null_func));
+        *values.data(), std::move(validFunc), std::move(nullFunc));
   }
 
   return {min, max};
@@ -535,181 +541,215 @@ std::pair<ByteArray, ByteArray> GetMinMaxBinaryHelper(
 
 template <>
 std::pair<ByteArray, ByteArray>
-TypedComparatorImpl<true, ByteArrayType>::GetMinMax(
+TypedComparatorImpl<true, ByteArrayType>::getMinMax(
     const ::arrow::Array& values) {
-  return GetMinMaxBinaryHelper<true>(*this, values);
+  return getMinMaxBinaryHelper<true>(*this, values);
 }
 
 template <>
 std::pair<ByteArray, ByteArray>
-TypedComparatorImpl<false, ByteArrayType>::GetMinMax(
+TypedComparatorImpl<false, ByteArrayType>::getMinMax(
     const ::arrow::Array& values) {
-  return GetMinMaxBinaryHelper<false>(*this, values);
+  return getMinMaxBinaryHelper<false>(*this, values);
+}
+
+template <typename T>
+std::string encodeDecimalToBigEndian(T value) {
+  uint8_t buffer[sizeof(T)];
+  if constexpr (std::is_same_v<T, int64_t>) {
+    *reinterpret_cast<int64_t*>(buffer) = ::arrow::bit_util::ToBigEndian(value);
+  } else if constexpr (std::is_same_v<T, int128_t>) {
+    *reinterpret_cast<int128_t*>(buffer) = DecimalUtil::bigEndian(value);
+  }
+  return std::string(reinterpret_cast<const char*>(buffer), sizeof(T));
 }
 
 template <typename DType>
 class TypedStatisticsImpl : public TypedStatistics<DType> {
  public:
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
 
-  // Create an empty stats.
+  // Create an empty statistics.
   TypedStatisticsImpl(const ColumnDescriptor* descr, MemoryPool* pool)
       : descr_(descr),
         pool_(pool),
-        min_buffer_(AllocateBuffer(pool_, 0)),
-        max_buffer_(AllocateBuffer(pool_, 0)) {
-    auto comp = Comparator::Make(descr);
+        minBuffer_(allocateBuffer(pool_, 0)),
+        maxBuffer_(allocateBuffer(pool_, 0)) {
+    auto comp = Comparator::make(descr);
     comparator_ = std::static_pointer_cast<TypedComparator<DType>>(comp);
-    TypedStatisticsImpl::Reset();
+    TypedStatisticsImpl::reset();
   }
 
   // Create stats from provided values.
   TypedStatisticsImpl(
       const T& min,
       const T& max,
-      int64_t num_values,
-      int64_t null_count,
-      int64_t distinct_count)
+      int64_t numValues,
+      int64_t nullCount,
+      int64_t distinctCount)
       : pool_(default_memory_pool()),
-        min_buffer_(AllocateBuffer(pool_, 0)),
-        max_buffer_(AllocateBuffer(pool_, 0)) {
-    TypedStatisticsImpl::IncrementNumValues(num_values);
-    TypedStatisticsImpl::IncrementNullCount(null_count);
-    SetDistinctCount(distinct_count);
+        minBuffer_(allocateBuffer(pool_, 0)),
+        maxBuffer_(allocateBuffer(pool_, 0)) {
+    TypedStatisticsImpl::incrementNumValues(numValues);
+    TypedStatisticsImpl::incrementNullCount(nullCount);
+    setDistinctCount(distinctCount);
 
-    Copy(min, &min_, min_buffer_.get());
-    Copy(max, &max_, max_buffer_.get());
-    has_min_max_ = true;
+    copy(min, &min_, minBuffer_.get());
+    copy(max, &max_, maxBuffer_.get());
+    hasMinMax_ = true;
   }
 
   // Create stats from a thrift Statistics object.
   TypedStatisticsImpl(
       const ColumnDescriptor* descr,
-      const std::string& encoded_min,
-      const std::string& encoded_max,
-      int64_t num_values,
-      int64_t null_count,
-      int64_t distinct_count,
-      bool has_min_max,
-      bool has_null_count,
-      bool has_distinct_count,
+      const std::string& encodedMin,
+      const std::string& encodedMax,
+      int64_t numValues,
+      int64_t nullCount,
+      int64_t distinctCount,
+      bool hasMinMax,
+      bool hasNullCount,
+      bool hasDistinctCount,
+      bool hasNaNCount,
+      int64_t nanCount,
       MemoryPool* pool)
       : TypedStatisticsImpl(descr, pool) {
-    TypedStatisticsImpl::IncrementNumValues(num_values);
-    if (has_null_count) {
-      TypedStatisticsImpl::IncrementNullCount(null_count);
+    TypedStatisticsImpl::incrementNumValues(numValues);
+    if (hasNullCount) {
+      TypedStatisticsImpl::incrementNullCount(nullCount);
     } else {
-      has_null_count_ = false;
+      hasNullCount_ = false;
     }
-    if (has_distinct_count) {
-      SetDistinctCount(distinct_count);
+    if (hasDistinctCount) {
+      setDistinctCount(distinctCount);
     } else {
-      has_distinct_count_ = false;
+      hasDistinctCount_ = false;
     }
 
-    if (!encoded_min.empty()) {
-      PlainDecode(encoded_min, &min_);
+    if (hasNaNCount) {
+      incrementNaNValues(nanCount);
+    } else {
+      hasNanCount_ = false;
+    }
+
+    if (!encodedMin.empty()) {
+      plainDecode(encodedMin, &min_);
     }
-    if (!encoded_max.empty()) {
-      PlainDecode(encoded_max, &max_);
+    if (!encodedMax.empty()) {
+      plainDecode(encodedMax, &max_);
     }
-    has_min_max_ = has_min_max;
+    hasMinMax_ = hasMinMax;
   }
 
-  bool HasDistinctCount() const override {
-    return has_distinct_count_;
+  bool hasDistinctCount() const override {
+    return hasDistinctCount_;
   };
-  bool HasMinMax() const override {
-    return has_min_max_;
+  bool hasMinMax() const override {
+    return hasMinMax_;
   }
-  bool HasNullCount() const override {
-    return has_null_count_;
+  bool hasNullCount() const override {
+    return hasNullCount_;
   };
 
-  void IncrementNullCount(int64_t n) override {
-    statistics_.null_count += n;
-    has_null_count_ = true;
+  bool hasNaNCount() const override {
+    return hasNanCount_;
   }
 
-  void IncrementNumValues(int64_t n) override {
-    num_values_ += n;
+  void incrementNullCount(int64_t n) override {
+    statistics_.nullCount += n;
+    hasNullCount_ = true;
   }
 
-  bool Equals(const Statistics& raw_other) const override {
-    if (physical_type() != raw_other.physical_type())
+  void incrementNumValues(int64_t n) override {
+    numValues_ += n;
+  }
+
+  void incrementNaNValues(int64_t n) override {
+    if (n > 0) {
+      nanCount_ += n;
+      hasNanCount_ = true;
+    }
+  }
+
+  bool equals(const Statistics& rawOther) const override {
+    if (physicalType() != rawOther.physicalType())
       return false;
 
-    const auto& other = checked_cast<const TypedStatisticsImpl&>(raw_other);
+    const auto& other = checked_cast<const TypedStatisticsImpl&>(rawOther);
 
-    if (has_min_max_ != other.has_min_max_)
+    if (hasMinMax_ != other.hasMinMax_)
       return false;
-    if (has_min_max_) {
-      if (!MinMaxEqual(other))
+    if (hasMinMax_) {
+      if (!minMaxEqual(other))
         return false;
     }
 
-    return null_count() == other.null_count() &&
-        distinct_count() == other.distinct_count() &&
-        num_values() == other.num_values();
+    return nullCount() == other.nullCount() &&
+        distinctCount() == other.distinctCount() &&
+        numValues() == other.numValues();
   }
 
-  bool MinMaxEqual(const TypedStatisticsImpl& other) const;
+  bool minMaxEqual(const TypedStatisticsImpl& other) const;
 
-  void Reset() override {
-    ResetCounts();
-    ResetHasFlags();
+  void reset() override {
+    resetCounts();
+    resetHasFlags();
   }
 
-  void SetMinMax(const T& arg_min, const T& arg_max) override {
-    SetMinMaxPair({arg_min, arg_max});
+  void setMinMax(const T& argMin, const T& argMax) override {
+    setMinMaxPair({argMin, argMax});
   }
 
-  void Merge(const TypedStatistics<DType>& other) override {
-    this->num_values_ += other.num_values();
-    // null_count is always valid when merging page statistics into
+  void merge(const TypedStatistics<DType>& other) override {
+    this->numValues_ += other.numValues();
+    // nullCount is always valid when merging page statistics into
     // column chunk statistics.
-    if (other.HasNullCount()) {
-      this->statistics_.null_count += other.null_count();
+    if (other.hasNullCount()) {
+      this->statistics_.nullCount += other.nullCount();
     } else {
-      this->has_null_count_ = false;
+      this->hasNullCount_ = false;
+    }
+    if (other.hasNaNCount()) {
+      this->nanCount_ += other.nanCount();
+      this->hasNanCount_ = true;
     }
-    if (has_distinct_count_ && other.HasDistinctCount() &&
-        (distinct_count() == 0 || other.distinct_count() == 0)) {
+    if (hasDistinctCount_ && other.hasDistinctCount() &&
+        (distinctCount() == 0 || other.distinctCount() == 0)) {
       // We can merge distinct counts if either side is zero.
-      statistics_.distinct_count =
-          std::max(statistics_.distinct_count, other.distinct_count());
+      statistics_.distinctCount =
+          std::max(statistics_.distinctCount, other.distinctCount());
     } else {
-      // Otherwise clear has_distinct_count_ as distinct count cannot be merged.
-      this->has_distinct_count_ = false;
+      // Otherwise clear hasDistinctCount_ as distinct count cannot be merged.
+      this->hasDistinctCount_ = false;
     }
     // Do not clear min/max here if the other side does not provide
     // min/max which may happen when other is an empty stats or all
     // its values are null and/or NaN.
-    if (other.HasMinMax()) {
-      SetMinMax(other.min(), other.max());
+    if (other.hasMinMax()) {
+      setMinMax(other.min(), other.max());
     }
   }
 
-  void Update(const T* values, int64_t num_values, int64_t null_count) override;
-  void UpdateSpaced(
+  void update(const T* values, int64_t numValues, int64_t nullCount) override;
+  void updateSpaced(
       const T* values,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      int64_t num_spaced_values,
-      int64_t num_values,
-      int64_t null_count) override;
-
-  void Update(const ::arrow::Array& values, bool update_counts) override {
-    if (update_counts) {
-      IncrementNullCount(values.null_count());
-      IncrementNumValues(values.length() - values.null_count());
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      int64_t numSpacedValues,
+      int64_t numValues,
+      int64_t nullCount) override;
+
+  void update(const ::arrow::Array& values, bool updateCounts) override {
+    if (updateCounts) {
+      incrementNullCount(values.null_count());
+      incrementNumValues(values.length() - values.null_count());
     }
 
     if (values.null_count() == values.length()) {
       return;
     }
 
-    SetMinMaxPair(comparator_->GetMinMax(values));
+    setMinMaxPair(comparator_->getMinMax(values));
   }
 
   const T& min() const override {
@@ -720,158 +760,296 @@ class TypedStatisticsImpl : public TypedStatistics<DType> {
     return max_;
   }
 
-  Type::type physical_type() const override {
-    return descr_->physical_type();
+  Type::type physicalType() const override {
+    return descr_->physicalType();
   }
 
   const ColumnDescriptor* descr() const override {
     return descr_;
   }
 
-  std::string EncodeMin() const override {
+  std::string encodeMin() const override {
     std::string s;
-    if (HasMinMax())
-      this->PlainEncode(min_, &s);
+    if (hasMinMax())
+      this->plainEncode(min_, &s);
     return s;
   }
 
-  std::string EncodeMax() const override {
+  std::string encodeMax() const override {
     std::string s;
-    if (HasMinMax())
-      this->PlainEncode(max_, &s);
+    if (hasMinMax())
+      this->plainEncode(max_, &s);
     return s;
   }
 
-  EncodedStatistics Encode() override {
+  std::string icebergLowerBoundInclusive(int32_t truncateTo) const override {
+    if constexpr (std::is_same_v<T, int64_t>) {
+      if (descr_->logicalType()->isDecimal()) {
+        return encodeDecimalToBigEndian(min_);
+      }
+    }
+    if constexpr (std::is_same_v<T, int128_t>) {
+      return encodeDecimalToBigEndian(min_);
+    }
+    if constexpr (std::is_same_v<T, ByteArray>) {
+      // STRING columns truncate by UTF-8 code points; BINARY/VARBINARY
+      // columns truncate by raw bytes (mirrors the upper-bound dispatch).
+      const std::string_view minView(min_);
+      const auto truncatedMin = descr_->logicalType()->isString()
+          ? truncateUtf8(minView, truncateTo)
+          : minView.substr(
+                0,
+                std::min(
+                    minView.size(),
+                    static_cast<size_t>(std::max(truncateTo, 0))));
+      std::string s;
+      this->plainEncode(
+          ByteArray(
+              truncatedMin.size(),
+              reinterpret_cast<const uint8_t*>(truncatedMin.data())),
+          &s);
+      return s;
+    }
+    return encodeMin();
+  }
+
+  std::optional<std::string> icebergUpperBoundExclusive(
+      int32_t truncateTo) const override {
+    if constexpr (std::is_same_v<T, int64_t>) {
+      if (descr_->logicalType()->isDecimal()) {
+        return encodeDecimalToBigEndian(max_);
+      }
+    }
+    if constexpr (std::is_same_v<T, int128_t>) {
+      return encodeDecimalToBigEndian(max_);
+    }
+    if constexpr (std::is_same_v<T, ByteArray>) {
+      // For ByteArray, we need to determine if this is UTF-8 text (STRING)
+      // or raw binary data (BINARY/VARBINARY). The Parquet logical type tells
+      // us this.
+      const bool isUtf8String = descr_->logicalType()->isString();
+
+      std::optional<std::string> truncatedMax;
+
+      if (isUtf8String) {
+        // Use UTF-8 string logic for STRING type
+        truncatedMax = roundUpUtf8(std::string_view(max_), truncateTo);
+      } else {
+        // Use binary byte logic for BINARY type (VARBINARY)
+        // Implementation follows Apache Iceberg's
+        // BinaryUtil.truncateBinaryMax()
+        truncatedMax = roundUpBinary(std::string_view(max_), truncateTo);
+      }
+
+      if (!truncatedMax.has_value()) {
+        return std::nullopt;
+      }
+      std::string s;
+      this->plainEncode(
+          ByteArray(
+              truncatedMax->size(),
+              reinterpret_cast<const uint8_t*>(truncatedMax->data())),
+          &s);
+      return s;
+    }
+    return encodeMax();
+  }
+
+  EncodedStatistics encode() override {
     EncodedStatistics s;
-    if (HasMinMax()) {
-      s.set_min(this->EncodeMin());
-      s.set_max(this->EncodeMax());
+    if (hasMinMax()) {
+      s.setMin(this->encodeMin());
+      s.setMax(this->encodeMax());
     }
-    if (HasNullCount()) {
-      s.set_null_count(this->null_count());
-      // num_values_ is reliable and it means number of non-null values.
-      s.all_null_value = num_values_ == 0;
+    if (hasNullCount()) {
+      s.setNullCount(this->nullCount());
+      // numValues_ is reliable and it means the number of non-null values.
+      s.allNullValue = numValues_ == 0;
     }
-    if (HasDistinctCount()) {
-      s.set_distinct_count(this->distinct_count());
+    if (hasDistinctCount()) {
+      s.setDistinctCount(this->distinctCount());
+    }
+    if (hasNanCount_) {
+      s.set_nan_count(nanCount_);
     }
     return s;
   }
 
-  int64_t null_count() const override {
-    return statistics_.null_count;
+  int64_t nullCount() const override {
+    return statistics_.nullCount;
+  }
+  int64_t distinctCount() const override {
+    return statistics_.distinctCount;
+  }
+  int64_t numValues() const override {
+    return numValues_;
+  }
+
+  int64_t nanCount() const override {
+    return nanCount_;
   }
-  int64_t distinct_count() const override {
-    return statistics_.distinct_count;
+
+  bool maxGreaterThan(const Statistics& other) const override {
+    const auto* typedOther =
+        dynamic_cast<const TypedStatisticsImpl<DType>*>(&other);
+    return comparator_->compare(max_, typedOther->max_) ? false : true;
   }
-  int64_t num_values() const override {
-    return num_values_;
+
+  bool minLessThan(const Statistics& other) const override {
+    const auto* typedOther =
+        dynamic_cast<const TypedStatisticsImpl<DType>*>(&other);
+    return comparator_->compare(min_, typedOther->min_) ? true : false;
   }
 
  private:
   const ColumnDescriptor* descr_;
-  bool has_min_max_ = false;
-  bool has_null_count_ = false;
-  bool has_distinct_count_ = false;
+  bool hasMinMax_ = false;
+  bool hasNullCount_ = false;
+  bool hasDistinctCount_ = false;
+  bool hasNanCount_ = false;
   T min_;
   T max_;
   ::arrow::MemoryPool* pool_;
   // Number of non-null values.
-  // Please note that num_values_ is reliable when has_null_count_ is set.
-  // When has_null_count_ is not set, e.g. a page statistics created from
-  // a statistics thrift message which doesn't have the optional null_count,
-  // `num_values_` may include null values.
-  int64_t num_values_ = 0;
+  // Please note that numValues_ is reliable when hasNullCount_ is set.
+  // When hasNullCount_ is not set, e.g., a page statistics created from
+  // a statistics thrift message which doesn't have the optional nullCount,
+  // `numValues_` may include null values.
+  int64_t numValues_ = 0;
+  // NaN count is tracked separately since it's not written to the parquet file.
+  int64_t nanCount_ = 0;
   EncodedStatistics statistics_;
   std::shared_ptr<TypedComparator<DType>> comparator_;
-  std::shared_ptr<ResizableBuffer> min_buffer_, max_buffer_;
+  std::shared_ptr<ResizableBuffer> minBuffer_, maxBuffer_;
 
-  void PlainEncode(const T& src, std::string* dst) const;
-  void PlainDecode(const std::string& src, T* dst) const;
+  void plainEncode(const T& src, std::string* dst) const;
+  void plainDecode(const std::string& src, T* dst) const;
 
-  void Copy(const T& src, T* dst, ResizableBuffer*) {
+  void copy(const T& src, T* dst, ResizableBuffer*) {
     *dst = src;
   }
 
-  void SetDistinctCount(int64_t n) {
-    // distinct count can only be "set", and cannot be incremented.
-    statistics_.distinct_count = n;
-    has_distinct_count_ = true;
+  void setDistinctCount(int64_t n) {
+    // Distinct count can only be "set", and cannot be incremented.
+    statistics_.distinctCount = n;
+    hasDistinctCount_ = true;
   }
 
-  void ResetCounts() {
-    this->statistics_.null_count = 0;
-    this->statistics_.distinct_count = 0;
-    this->num_values_ = 0;
+  void resetCounts() {
+    this->statistics_.nullCount = 0;
+    this->statistics_.distinctCount = 0;
+    this->numValues_ = 0;
+    this->nanCount_ = 0;
   }
 
-  void ResetHasFlags() {
-    // has_min_max_ will only be set when it meets any valid value.
-    this->has_min_max_ = false;
-    // has_distinct_count_ will only be set once SetDistinctCount()
-    // is called because distinct count calculation is not cheap and
+  void resetHasFlags() {
+    // hasMinMax_ will only be set when it meets any valid value.
+    this->hasMinMax_ = false;
+    // hasDistinctCount_ will only be set once setDistinctCount()
+    // is called because distinct count calculation is not cheap and.
     // disabled by default.
-    this->has_distinct_count_ = false;
+    this->hasDistinctCount_ = false;
     // Null count calculation is cheap and enabled by default.
-    this->has_null_count_ = true;
+    this->hasNullCount_ = true;
+    this->hasNanCount_ = false;
   }
 
-  void SetMinMaxPair(std::pair<T, T> min_max) {
-    // CleanStatistic can return a nullopt in case of erroneous values, e.g. NaN
-    auto maybe_min_max = CleanStatistic(min_max);
-    if (!maybe_min_max)
+  void setMinMaxPair(std::pair<T, T> minMax) {
+    // CleanStatistic can return a nullopt in case of erroneous values, e.g.
+    // NaN.
+    auto maybeMinMax = cleanStatistic(minMax);
+    if (!maybeMinMax)
       return;
 
-    auto min = maybe_min_max.value().first;
-    auto max = maybe_min_max.value().second;
+    auto min = maybeMinMax.value().first;
+    auto max = maybeMinMax.value().second;
 
-    if (!has_min_max_) {
-      has_min_max_ = true;
-      Copy(min, &min_, min_buffer_.get());
-      Copy(max, &max_, max_buffer_.get());
+    if (!hasMinMax_) {
+      hasMinMax_ = true;
+      copy(min, &min_, minBuffer_.get());
+      copy(max, &max_, maxBuffer_.get());
     } else {
-      Copy(
-          comparator_->Compare(min_, min) ? min_ : min,
+      copy(
+          comparator_->compare(min_, min) ? min_ : min,
           &min_,
-          min_buffer_.get());
-      Copy(
-          comparator_->Compare(max_, max) ? max : max_,
+          minBuffer_.get());
+      copy(
+          comparator_->compare(max_, max) ? max : max_,
           &max_,
-          max_buffer_.get());
+          maxBuffer_.get());
+    }
+  }
+
+  int64_t countNaN(const T* values, int64_t length) {
+    if constexpr (!std::is_floating_point_v<T>) {
+      return 0;
+    } else {
+      int64_t count = 0;
+      for (auto i = 0; i < length; i++) {
+        const auto val = safeLoad(values + i);
+        if (std::isnan(val)) {
+          count++;
+        }
+      }
+      return count;
+    }
+  }
+
+  int64_t countNaNSpaced(
+      const T* values,
+      int64_t length,
+      const uint8_t* validBits,
+      int64_t validBitsOffset) {
+    if constexpr (!std::is_floating_point_v<T>) {
+      return 0;
+    } else {
+      int64_t count = 0;
+      ::arrow::internal::VisitSetBitRunsVoid(
+          validBits,
+          validBitsOffset,
+          length,
+          [&](int64_t position, int64_t runLength) {
+            for (auto i = 0; i < runLength; i++) {
+              const auto val = safeLoad(values + i + position);
+              if (std::isnan(val)) {
+                count++;
+              }
+            }
+          });
+      return count;
     }
   }
 };
 
 template <>
-inline bool TypedStatisticsImpl<FLBAType>::MinMaxEqual(
+inline bool TypedStatisticsImpl<FLBAType>::minMaxEqual(
     const TypedStatisticsImpl<FLBAType>& other) const {
-  uint32_t len = descr_->type_length();
+  uint32_t len = descr_->typeLength();
   return std::memcmp(min_.ptr, other.min_.ptr, len) == 0 &&
       std::memcmp(max_.ptr, other.max_.ptr, len) == 0;
 }
 
 template <typename DType>
-bool TypedStatisticsImpl<DType>::MinMaxEqual(
+bool TypedStatisticsImpl<DType>::minMaxEqual(
     const TypedStatisticsImpl<DType>& other) const {
   return min_ == other.min_ && max_ == other.max_;
 }
 
 template <>
-inline void TypedStatisticsImpl<FLBAType>::Copy(
+inline void TypedStatisticsImpl<FLBAType>::copy(
     const FLBA& src,
     FLBA* dst,
     ResizableBuffer* buffer) {
   if (dst->ptr == src.ptr)
     return;
-  uint32_t len = descr_->type_length();
+  uint32_t len = descr_->typeLength();
   PARQUET_THROW_NOT_OK(buffer->Resize(len, false));
   std::memcpy(buffer->mutable_data(), src.ptr, len);
   *dst = FLBA(buffer->data());
 }
 
 template <>
-inline void TypedStatisticsImpl<ByteArrayType>::Copy(
+inline void TypedStatisticsImpl<ByteArrayType>::copy(
     const ByteArray& src,
     ByteArray* dst,
     ResizableBuffer* buffer) {
@@ -883,71 +1061,75 @@ inline void TypedStatisticsImpl<ByteArrayType>::Copy(
 }
 
 template <typename DType>
-void TypedStatisticsImpl<DType>::Update(
+void TypedStatisticsImpl<DType>::update(
     const T* values,
-    int64_t num_values,
-    int64_t null_count) {
-  VELOX_DCHECK_GE(num_values, 0);
-  VELOX_DCHECK_GE(null_count, 0);
+    int64_t numValues,
+    int64_t nullCount) {
+  VELOX_DCHECK_GE(numValues, 0);
+  VELOX_DCHECK_GE(nullCount, 0);
 
-  IncrementNullCount(null_count);
-  IncrementNumValues(num_values);
+  incrementNullCount(nullCount);
+  incrementNumValues(numValues);
 
-  if (num_values == 0)
+  if (numValues == 0)
     return;
-  SetMinMaxPair(comparator_->GetMinMax(values, num_values));
+  setMinMaxPair(comparator_->getMinMax(values, numValues));
+  incrementNaNValues(countNaN(values, numValues));
 }
 
 template <typename DType>
-void TypedStatisticsImpl<DType>::UpdateSpaced(
+void TypedStatisticsImpl<DType>::updateSpaced(
     const T* values,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    int64_t num_spaced_values,
-    int64_t num_values,
-    int64_t null_count) {
-  VELOX_DCHECK_GE(num_values, 0);
-  VELOX_DCHECK_GE(null_count, 0);
-
-  IncrementNullCount(null_count);
-  IncrementNumValues(num_values);
-
-  if (num_values == 0)
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    int64_t numSpacedValues,
+    int64_t numValues,
+    int64_t nullCount) {
+  VELOX_DCHECK_GE(numValues, 0);
+  VELOX_DCHECK_GE(nullCount, 0);
+
+  incrementNullCount(nullCount);
+  incrementNumValues(numValues);
+
+  if (numValues == 0)
     return;
-  SetMinMaxPair(comparator_->GetMinMaxSpaced(
-      values, num_spaced_values, valid_bits, valid_bits_offset));
+  setMinMaxPair(comparator_->getMinMaxSpaced(
+      values, numSpacedValues, validBits, validBitsOffset));
+  incrementNaNValues(
+      countNaNSpaced(values, numSpacedValues, validBits, validBitsOffset));
 }
 
 template <typename DType>
-void TypedStatisticsImpl<DType>::PlainEncode(const T& src, std::string* dst)
+void TypedStatisticsImpl<DType>::plainEncode(const T& src, std::string* dst)
     const {
-  auto encoder = MakeTypedEncoder<DType>(Encoding::PLAIN, false, descr_, pool_);
-  encoder->Put(&src, 1);
-  auto buffer = encoder->FlushValues();
+  auto encoder =
+      makeTypedEncoder<DType>(Encoding::kPlain, false, descr_, pool_);
+  encoder->put(&src, 1);
+  auto buffer = encoder->flushValues();
   auto ptr = reinterpret_cast<const char*>(buffer->data());
   dst->assign(ptr, buffer->size());
 }
 
 template <typename DType>
-void TypedStatisticsImpl<DType>::PlainDecode(const std::string& src, T* dst)
+void TypedStatisticsImpl<DType>::plainDecode(const std::string& src, T* dst)
     const {
-  auto decoder = MakeTypedDecoder<DType>(Encoding::PLAIN, descr_);
-  decoder->SetData(
+  auto decoder = makeTypedDecoder<DType>(Encoding::kPlain, descr_);
+  decoder->setData(
       1,
       reinterpret_cast<const uint8_t*>(src.c_str()),
       static_cast<int>(src.size()));
-  decoder->Decode(dst, 1);
+  decoder->decode(dst, 1);
 }
 
 template <>
-void TypedStatisticsImpl<ByteArrayType>::PlainEncode(
+void TypedStatisticsImpl<ByteArrayType>::plainEncode(
     const T& src,
     std::string* dst) const {
   dst->assign(reinterpret_cast<const char*>(src.ptr), src.len);
 }
 
 template <>
-void TypedStatisticsImpl<ByteArrayType>::PlainDecode(
+void TypedStatisticsImpl<ByteArrayType>::plainDecode(
     const std::string& src,
     T* dst) const {
   dst->len = static_cast<uint32_t>(src.size());
@@ -957,47 +1139,47 @@ void TypedStatisticsImpl<ByteArrayType>::PlainDecode(
 } // namespace
 
 // ----------------------------------------------------------------------
-// Public factory functions
-
-std::shared_ptr<Comparator> Comparator::Make(
-    Type::type physical_type,
-    SortOrder::type sort_order,
-    int type_length) {
-  if (SortOrder::SIGNED == sort_order) {
-    switch (physical_type) {
-      case Type::BOOLEAN:
+// Public factory functions.
+
+std::shared_ptr<Comparator> Comparator::make(
+    Type::type physicalType,
+    SortOrder::type sortOrder,
+    int typeLength) {
+  if (SortOrder::kSigned == sortOrder) {
+    switch (physicalType) {
+      case Type::kBoolean:
         return std::make_shared<TypedComparatorImpl<true, BooleanType>>();
-      case Type::INT32:
+      case Type::kInt32:
         return std::make_shared<TypedComparatorImpl<true, Int32Type>>();
-      case Type::INT64:
+      case Type::kInt64:
         return std::make_shared<TypedComparatorImpl<true, Int64Type>>();
-      case Type::INT96:
+      case Type::kInt96:
         return std::make_shared<TypedComparatorImpl<true, Int96Type>>();
-      case Type::FLOAT:
+      case Type::kFloat:
         return std::make_shared<TypedComparatorImpl<true, FloatType>>();
-      case Type::DOUBLE:
+      case Type::kDouble:
         return std::make_shared<TypedComparatorImpl<true, DoubleType>>();
-      case Type::BYTE_ARRAY:
+      case Type::kByteArray:
         return std::make_shared<TypedComparatorImpl<true, ByteArrayType>>();
-      case Type::FIXED_LEN_BYTE_ARRAY:
+      case Type::kFixedLenByteArray:
         return std::make_shared<TypedComparatorImpl<true, FLBAType>>(
-            type_length);
+            typeLength);
       default:
         ParquetException::NYI("Signed Compare not implemented");
     }
-  } else if (SortOrder::UNSIGNED == sort_order) {
-    switch (physical_type) {
-      case Type::INT32:
+  } else if (SortOrder::kUnsigned == sortOrder) {
+    switch (physicalType) {
+      case Type::kInt32:
         return std::make_shared<TypedComparatorImpl<false, Int32Type>>();
-      case Type::INT64:
+      case Type::kInt64:
         return std::make_shared<TypedComparatorImpl<false, Int64Type>>();
-      case Type::INT96:
+      case Type::kInt96:
         return std::make_shared<TypedComparatorImpl<false, Int96Type>>();
-      case Type::BYTE_ARRAY:
+      case Type::kByteArray:
         return std::make_shared<TypedComparatorImpl<false, ByteArrayType>>();
-      case Type::FIXED_LEN_BYTE_ARRAY:
+      case Type::kFixedLenByteArray:
         return std::make_shared<TypedComparatorImpl<false, FLBAType>>(
-            type_length);
+            typeLength);
       default:
         ParquetException::NYI("Unsigned Compare not implemented");
     }
@@ -1007,58 +1189,57 @@ std::shared_ptr<Comparator> Comparator::Make(
   return nullptr;
 }
 
-std::shared_ptr<Comparator> Comparator::Make(const ColumnDescriptor* descr) {
-  return Make(
-      descr->physical_type(), descr->sort_order(), descr->type_length());
+std::shared_ptr<Comparator> Comparator::make(const ColumnDescriptor* descr) {
+  return make(descr->physicalType(), descr->sortOrder(), descr->typeLength());
 }
 
-std::shared_ptr<Statistics> Statistics::Make(
+std::shared_ptr<Statistics> Statistics::make(
     const ColumnDescriptor* descr,
     ::arrow::MemoryPool* pool) {
-  switch (descr->physical_type()) {
-    case Type::BOOLEAN:
+  switch (descr->physicalType()) {
+    case Type::kBoolean:
       return std::make_shared<TypedStatisticsImpl<BooleanType>>(descr, pool);
-    case Type::INT32:
+    case Type::kInt32:
       return std::make_shared<TypedStatisticsImpl<Int32Type>>(descr, pool);
-    case Type::INT64:
+    case Type::kInt64:
       return std::make_shared<TypedStatisticsImpl<Int64Type>>(descr, pool);
-    case Type::FLOAT:
+    case Type::kFloat:
       return std::make_shared<TypedStatisticsImpl<FloatType>>(descr, pool);
-    case Type::DOUBLE:
+    case Type::kDouble:
       return std::make_shared<TypedStatisticsImpl<DoubleType>>(descr, pool);
-    case Type::BYTE_ARRAY:
+    case Type::kByteArray:
       return std::make_shared<TypedStatisticsImpl<ByteArrayType>>(descr, pool);
-    case Type::FIXED_LEN_BYTE_ARRAY:
+    case Type::kFixedLenByteArray:
       return std::make_shared<TypedStatisticsImpl<FLBAType>>(descr, pool);
     default:
       ParquetException::NYI("Statistics not implemented");
   }
 }
 
-std::shared_ptr<Statistics> Statistics::Make(
-    Type::type physical_type,
+std::shared_ptr<Statistics> Statistics::make(
+    Type::type physicalType,
     const void* min,
     const void* max,
-    int64_t num_values,
-    int64_t null_count,
-    int64_t distinct_count) {
-#define MAKE_STATS(CAP_TYPE, KLASS)                            \
-  case Type::CAP_TYPE:                                         \
-    return std::make_shared<TypedStatisticsImpl<KLASS>>(       \
-        *reinterpret_cast<const typename KLASS::c_type*>(min), \
-        *reinterpret_cast<const typename KLASS::c_type*>(max), \
-        num_values,                                            \
-        null_count,                                            \
-        distinct_count)
-
-  switch (physical_type) {
-    MAKE_STATS(BOOLEAN, BooleanType);
-    MAKE_STATS(INT32, Int32Type);
-    MAKE_STATS(INT64, Int64Type);
-    MAKE_STATS(FLOAT, FloatType);
-    MAKE_STATS(DOUBLE, DoubleType);
-    MAKE_STATS(BYTE_ARRAY, ByteArrayType);
-    MAKE_STATS(FIXED_LEN_BYTE_ARRAY, FLBAType);
+    int64_t numValues,
+    int64_t nullCount,
+    int64_t distinctCount) {
+#define MAKE_STATS(CAP_TYPE, KLASS)                           \
+  case Type::CAP_TYPE:                                        \
+    return std::make_shared<TypedStatisticsImpl<KLASS>>(      \
+        *reinterpret_cast<const typename KLASS::CType*>(min), \
+        *reinterpret_cast<const typename KLASS::CType*>(max), \
+        numValues,                                            \
+        nullCount,                                            \
+        distinctCount)
+
+  switch (physicalType) {
+    MAKE_STATS(kBoolean, BooleanType);
+    MAKE_STATS(kInt32, Int32Type);
+    MAKE_STATS(kInt64, Int64Type);
+    MAKE_STATS(kFloat, FloatType);
+    MAKE_STATS(kDouble, DoubleType);
+    MAKE_STATS(kByteArray, ByteArrayType);
+    MAKE_STATS(kFixedLenByteArray, FLBAType);
     default:
       break;
   }
@@ -1067,58 +1248,64 @@ std::shared_ptr<Statistics> Statistics::Make(
   return nullptr;
 }
 
-std::shared_ptr<Statistics> Statistics::Make(
+std::shared_ptr<Statistics> Statistics::make(
     const ColumnDescriptor* descr,
-    const EncodedStatistics* encoded_stats,
-    int64_t num_values,
+    const EncodedStatistics* encodedStats,
+    int64_t numValues,
     ::arrow::MemoryPool* pool) {
-  VELOX_DCHECK(encoded_stats != nullptr);
-  return Make(
+  VELOX_DCHECK(encodedStats != nullptr);
+  return make(
       descr,
-      encoded_stats->min(),
-      encoded_stats->max(),
-      num_values,
-      encoded_stats->null_count,
-      encoded_stats->distinct_count,
-      encoded_stats->has_min && encoded_stats->has_max,
-      encoded_stats->has_null_count,
-      encoded_stats->has_distinct_count,
+      encodedStats->min(),
+      encodedStats->max(),
+      numValues,
+      encodedStats->nullCount,
+      encodedStats->distinctCount,
+      encodedStats->hasMin && encodedStats->hasMax,
+      encodedStats->hasNullCount,
+      encodedStats->hasDistinctCount,
+      encodedStats->hasNanCount,
+      encodedStats->nanCount,
       pool);
 }
 
-std::shared_ptr<Statistics> Statistics::Make(
+std::shared_ptr<Statistics> Statistics::make(
     const ColumnDescriptor* descr,
-    const std::string& encoded_min,
-    const std::string& encoded_max,
-    int64_t num_values,
-    int64_t null_count,
-    int64_t distinct_count,
-    bool has_min_max,
-    bool has_null_count,
-    bool has_distinct_count,
+    const std::string& encodedMin,
+    const std::string& encodedMax,
+    int64_t numValues,
+    int64_t nullCount,
+    int64_t distinctCount,
+    bool hasMinMax,
+    bool hasNullCount,
+    bool hasDistinctCount,
+    bool hasNaNCount,
+    int64_t nanCount,
     ::arrow::MemoryPool* pool) {
 #define MAKE_STATS(CAP_TYPE, KLASS)                      \
   case Type::CAP_TYPE:                                   \
     return std::make_shared<TypedStatisticsImpl<KLASS>>( \
         descr,                                           \
-        encoded_min,                                     \
-        encoded_max,                                     \
-        num_values,                                      \
-        null_count,                                      \
-        distinct_count,                                  \
-        has_min_max,                                     \
-        has_null_count,                                  \
-        has_distinct_count,                              \
+        encodedMin,                                      \
+        encodedMax,                                      \
+        numValues,                                       \
+        nullCount,                                       \
+        distinctCount,                                   \
+        hasMinMax,                                       \
+        hasNullCount,                                    \
+        hasDistinctCount,                                \
+        hasNaNCount,                                     \
+        nanCount,                                        \
         pool)
 
-  switch (descr->physical_type()) {
-    MAKE_STATS(BOOLEAN, BooleanType);
-    MAKE_STATS(INT32, Int32Type);
-    MAKE_STATS(INT64, Int64Type);
-    MAKE_STATS(FLOAT, FloatType);
-    MAKE_STATS(DOUBLE, DoubleType);
-    MAKE_STATS(BYTE_ARRAY, ByteArrayType);
-    MAKE_STATS(FIXED_LEN_BYTE_ARRAY, FLBAType);
+  switch (descr->physicalType()) {
+    MAKE_STATS(kBoolean, BooleanType);
+    MAKE_STATS(kInt32, Int32Type);
+    MAKE_STATS(kInt64, Int64Type);
+    MAKE_STATS(kFloat, FloatType);
+    MAKE_STATS(kDouble, DoubleType);
+    MAKE_STATS(kByteArray, ByteArrayType);
+    MAKE_STATS(kFixedLenByteArray, FLBAType);
     default:
       break;
   }
diff --git a/velox/dwio/parquet/writer/arrow/Statistics.h b/velox/dwio/parquet/writer/arrow/Statistics.h
index 6abf66b0b20..64295487359 100644
--- a/velox/dwio/parquet/writer/arrow/Statistics.h
+++ b/velox/dwio/parquet/writer/arrow/Statistics.h
@@ -40,30 +40,28 @@ namespace facebook::velox::parquet::arrow {
 class ColumnDescriptor;
 
 // ----------------------------------------------------------------------
-// Value comparator interfaces
+// Value Comparator interfaces.
 
-/// \brief Base class for value comparators. Generally used with
-/// TypedComparator<T>
+/// \brief Base class for value Comparators. Generally used with
+/// TypedComparator<T>.
 class PARQUET_EXPORT Comparator {
  public:
   virtual ~Comparator() {}
 
-  /// \brief Create a comparator explicitly from physical type and
-  /// sort order
-  /// \param[in] physical_type the physical type for the typed
-  /// comparator
-  /// \param[in] sort_order either SortOrder::SIGNED or
-  /// SortOrder::UNSIGNED
-  /// \param[in] type_length for FIXED_LEN_BYTE_ARRAY only
-  static std::shared_ptr<Comparator> Make(
-      Type::type physical_type,
-      SortOrder::type sort_order,
-      int type_length = -1);
-
-  /// \brief Create typed comparator inferring default sort order from
-  /// ColumnDescriptor
-  /// \param[in] descr the Parquet column schema
-  static std::shared_ptr<Comparator> Make(const ColumnDescriptor* descr);
+  /// \brief Create a Comparator explicitly from physical type and
+  /// sort order.
+  /// \param[in] physicalType Physical type for the typed
+  /// Comparator.
+  /// \param[in] sortOrder Either SortOrder::kSigned or
+  /// SortOrder::kUnsigned.
+  /// \param[in] typeLength For FIXED_LEN_BYTE_ARRAY only.
+  static std::shared_ptr<Comparator>
+  make(Type::type physicalType, SortOrder::type sortOrder, int typeLength = -1);
+
+  /// \brief Create typed Comparator inferring default sort order from
+  /// ColumnDescriptor.
+  /// \param[in] descr the Parquet column schema.
+  static std::shared_ptr<Comparator> make(const ColumnDescriptor* descr);
 };
 
 /// \brief Interface for comparison of physical types according to the
@@ -71,54 +69,54 @@ class PARQUET_EXPORT Comparator {
 template <typename DType>
 class TypedComparator : public Comparator {
  public:
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
 
   /// \brief Scalar comparison of two elements, return true if first
-  /// is strictly less than the second
-  virtual bool Compare(const T& a, const T& b) = 0;
+  /// is strictly less than the second.
+  virtual bool compare(const T& a, const T& b) = 0;
 
   /// \brief Compute maximum and minimum elements in a batch of
-  /// elements without any nulls
-  virtual std::pair<T, T> GetMinMax(const T* values, int64_t length) = 0;
+  /// elements without any nulls.
+  virtual std::pair<T, T> getMinMax(const T* values, int64_t length) = 0;
 
   /// \brief Compute minimum and maximum elements from an Arrow array. Only
   /// valid for certain Parquet Type / Arrow Type combinations, like BYTE_ARRAY
-  /// / arrow::BinaryArray
-  virtual std::pair<T, T> GetMinMax(const ::arrow::Array& values) = 0;
+  /// / Arrow::BinaryArray.
+  virtual std::pair<T, T> getMinMax(const ::arrow::Array& values) = 0;
 
   /// \brief Compute maximum and minimum elements in a batch of
   /// elements with accompanying bitmap indicating which elements are
-  /// included (bit set) and excluded (bit not set)
+  /// included (bit set) and excluded (bit not set).
   ///
-  /// \param[in] values the sequence of values
-  /// \param[in] length the length of the sequence
-  /// \param[in] valid_bits a bitmap indicating which elements are
-  /// included (1) or excluded (0)
-  /// \param[in] valid_bits_offset the bit offset into the bitmap of
-  /// the first element in the sequence
-  virtual std::pair<T, T> GetMinMaxSpaced(
+  /// \param[in] values The sequence of values.
+  /// \param[in] length The length of the sequence.
+  /// \param[in] validBits A bitmap indicating which elements are
+  /// included (1) or excluded (0).
+  /// \param[in] validBitsOffset The bit offset into the bitmap of
+  /// the first element in the sequence.
+  virtual std::pair<T, T> getMinMaxSpaced(
       const T* values,
       int64_t length,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset) = 0;
+      const uint8_t* validBits,
+      int64_t validBitsOffset) = 0;
 };
 
-/// \brief Typed version of Comparator::Make
+/// \brief Typed version of Comparator::Make.
 template <typename DType>
-std::shared_ptr<TypedComparator<DType>> MakeComparator(
-    Type::type physical_type,
-    SortOrder::type sort_order,
-    int type_length = -1) {
+std::shared_ptr<TypedComparator<DType>> makeComparator(
+    Type::type physicalType,
+    SortOrder::type sortOrder,
+    int typeLength = -1) {
   return std::static_pointer_cast<TypedComparator<DType>>(
-      Comparator::Make(physical_type, sort_order, type_length));
+      Comparator::make(physicalType, sortOrder, typeLength));
 }
 
-/// \brief Typed version of Comparator::Make
+/// \brief Typed version of Comparator::Make.
 template <typename DType>
-std::shared_ptr<TypedComparator<DType>> MakeComparator(
+std::shared_ptr<TypedComparator<DType>> makeComparator(
     const ColumnDescriptor* descr) {
   return std::static_pointer_cast<TypedComparator<DType>>(
-      Comparator::Make(descr));
+      Comparator::make(descr));
 }
 
 // ----------------------------------------------------------------------
@@ -127,7 +125,7 @@ std::shared_ptr<TypedComparator<DType>> MakeComparator(
 /// and read from Parquet serialized metadata.
 class PARQUET_EXPORT EncodedStatistics {
   std::string max_, min_;
-  bool is_signed_ = false;
+  bool isSigned_ = false;
 
  public:
   EncodedStatistics() = default;
@@ -139,236 +137,300 @@ class PARQUET_EXPORT EncodedStatistics {
     return min_;
   }
 
-  int64_t null_count = 0;
-  int64_t distinct_count = 0;
+  int64_t nullCount = 0;
+  int64_t distinctCount = 0;
+  int64_t nanCount = 0;
 
-  bool has_min = false;
-  bool has_max = false;
-  bool has_null_count = false;
-  bool has_distinct_count = false;
+  bool hasMin = false;
+  bool hasMax = false;
+  bool hasNullCount = false;
+  bool hasDistinctCount = false;
+  bool hasNanCount = false;
 
   // When all values in the statistics are null, it is set to true.
   // Otherwise, at least one value is not null, or we are not sure at all.
   // Page index requires this information to decide whether a data page
   // is a null page or not.
-  bool all_null_value = false;
+  bool allNullValue = false;
 
-  // From parquet-mr
+  // From parquet-mr.
   // Don't write stats larger than the max size rather than truncating. The
   // rationale is that some engines may use the minimum value in the page as
   // the true minimum for aggregations and there is no way to mark that a
   // value has been truncated and is a lower bound and not in the page.
-  void ApplyStatSizeLimits(size_t length) {
+  void applyStatSizeLimits(size_t length) {
     if (max_.length() > length) {
-      has_max = false;
+      hasMax = false;
       max_.clear();
     }
     if (min_.length() > length) {
-      has_min = false;
+      hasMin = false;
       min_.clear();
     }
   }
 
-  bool is_set() const {
-    return has_min || has_max || has_null_count || has_distinct_count;
+  bool isSet() const {
+    return hasMin || hasMax || hasNullCount || hasDistinctCount;
   }
 
-  bool is_signed() const {
-    return is_signed_;
+  bool isSigned() const {
+    return isSigned_;
   }
 
-  void set_is_signed(bool is_signed) {
-    is_signed_ = is_signed;
+  void setIsSigned(bool isSigned) {
+    isSigned_ = isSigned;
   }
 
-  EncodedStatistics& set_max(std::string value) {
+  EncodedStatistics& setMax(std::string value) {
     max_ = std::move(value);
-    has_max = true;
+    hasMax = true;
     return *this;
   }
 
-  EncodedStatistics& set_min(std::string value) {
+  EncodedStatistics& setMin(std::string value) {
     min_ = std::move(value);
-    has_min = true;
+    hasMin = true;
     return *this;
   }
 
-  EncodedStatistics& set_null_count(int64_t value) {
-    null_count = value;
-    has_null_count = true;
+  EncodedStatistics& setNullCount(int64_t value) {
+    nullCount = value;
+    hasNullCount = true;
     return *this;
   }
 
-  EncodedStatistics& set_distinct_count(int64_t value) {
-    distinct_count = value;
-    has_distinct_count = true;
+  EncodedStatistics& setDistinctCount(int64_t value) {
+    distinctCount = value;
+    hasDistinctCount = true;
+    return *this;
+  }
+
+  EncodedStatistics& set_nan_count(int64_t value) {
+    nanCount = value;
+    hasNanCount = true;
     return *this;
   }
 };
 
-/// \brief Base type for computing column statistics while writing a file
+/// \brief Base type for computing column statistics while writing a file.
 class PARQUET_EXPORT Statistics {
  public:
   virtual ~Statistics() {}
 
   /// \brief Create a new statistics instance given a column schema
-  /// definition
-  /// \param[in] descr the column schema
-  /// \param[in] pool a memory pool to use for any memory allocations, optional
-  static std::shared_ptr<Statistics> Make(
+  /// definition.
+  /// \param[in] descr The column schema.
+  /// \param[in] pool A memory pool to use for any memory allocations, optional.
+  static std::shared_ptr<Statistics> make(
       const ColumnDescriptor* descr,
       ::arrow::MemoryPool* pool = ::arrow::default_memory_pool());
 
   /// \brief Create a new statistics instance given a column schema
-  /// definition and pre-existing state
-  /// \param[in] descr the column schema
-  /// \param[in] encoded_min the encoded minimum value
-  /// \param[in] encoded_max the encoded maximum value
-  /// \param[in] num_values total number of values
-  /// \param[in] null_count number of null values
-  /// \param[in] distinct_count number of distinct values
-  /// \param[in] has_min_max whether the min/max statistics are set
-  /// \param[in] has_null_count whether the null_count statistics are set
-  /// \param[in] has_distinct_count whether the distinct_count statistics are
-  /// set \param[in] pool a memory pool to use for any memory allocations,
-  /// optional
-  static std::shared_ptr<Statistics> Make(
+  /// definition and pre-existing state.
+  /// \param[in] descr The column schema.
+  /// \param[in] encodedMin The encoded minimum value.
+  /// \param[in] encodedMax The encoded maximum value.
+  /// \param[in] numValues Total number of values.
+  /// \param[in] nullCount Number of null values.
+  /// \param[in] distinctCount Number of distinct values.
+  /// \param[in] hasMinMax Whether the min/max statistics are set.
+  /// \param[in] hasNullCount Whether the nullCount statistics are set.
+  /// \param[in] hasDistinctCount Whether the distinctCount statistics are set.
+  /// \param[in] pool A memory pool to use for any memory allocations,
+  /// optional.
+  static std::shared_ptr<Statistics> make(
       const ColumnDescriptor* descr,
-      const std::string& encoded_min,
-      const std::string& encoded_max,
-      int64_t num_values,
-      int64_t null_count,
-      int64_t distinct_count,
-      bool has_min_max,
-      bool has_null_count,
-      bool has_distinct_count,
+      const std::string& encodedMin,
+      const std::string& encodedMax,
+      int64_t numValues,
+      int64_t nullCount,
+      int64_t distinctCount,
+      bool hasMinMax,
+      bool hasNullCount,
+      bool hasDistinctCount,
+      bool hasNaNCount,
+      int64_t nanCount,
       ::arrow::MemoryPool* pool = ::arrow::default_memory_pool());
 
   // Helper function to convert EncodedStatistics to Statistics.
-  // EncodedStatistics does not contain number of non-null values, and it can be
-  // passed using the num_values parameter.
-  static std::shared_ptr<Statistics> Make(
+  // EncodedStatistics does not contain number of non-null values, and it can
+  // be passed using the numValues parameter.
+  static std::shared_ptr<Statistics> make(
       const ColumnDescriptor* descr,
-      const EncodedStatistics* encoded_statistics,
-      int64_t num_values = -1,
+      const EncodedStatistics* encodedStats,
+      int64_t numValues = -1,
       ::arrow::MemoryPool* pool = ::arrow::default_memory_pool());
 
-  /// \brief Return true if the count of null values is set
-  virtual bool HasNullCount() const = 0;
+  /// \brief Return true if the count of null values is set.
+  virtual bool hasNullCount() const = 0;
+
+  /// \brief The number of null values, may not be set.
+  virtual int64_t nullCount() const = 0;
 
-  /// \brief The number of null values, may not be set
-  virtual int64_t null_count() const = 0;
+  /// \brief Return true if the count of distinct values is set.
+  virtual bool hasDistinctCount() const = 0;
 
-  /// \brief Return true if the count of distinct values is set
-  virtual bool HasDistinctCount() const = 0;
+  /// \brief The number of distinct values, may not be set.
+  virtual int64_t distinctCount() const = 0;
 
-  /// \brief The number of distinct values, may not be set
-  virtual int64_t distinct_count() const = 0;
+  /// \brief The number of non-null values in the column.
+  virtual int64_t numValues() const = 0;
 
-  /// \brief The number of non-null values in the column
-  virtual int64_t num_values() const = 0;
+  /// \brief Return true if the count of nan values is set.
+  virtual bool hasNaNCount() const = 0;
+
+  /// \brief The number of NaN values, may not be set.
+  virtual int64_t nanCount() const = 0;
 
   /// \brief Return true if the min and max statistics are set. Obtain
-  /// with TypedStatistics<T>::min and max
-  virtual bool HasMinMax() const = 0;
+  /// with TypedStatistics<T>::min and max.
+  virtual bool hasMinMax() const = 0;
+
+  /// \brief Reset state of object to initial (no data observed) state.
+  virtual void reset() = 0;
+
+  /// \brief Plain-encoded minimum value.
+  virtual std::string encodeMin() const = 0;
 
-  /// \brief Reset state of object to initial (no data observed) state
-  virtual void Reset() = 0;
+  /// \brief Plain-encoded maximum value.
+  virtual std::string encodeMax() const = 0;
 
-  /// \brief Plain-encoded minimum value
-  virtual std::string EncodeMin() const = 0;
+  /// \brief Encoded lower bound value compatible with Iceberg.
+  ///
+  /// Returns an encoded value guaranteed to be <= the actual minimum value.
+  /// For string types, truncates to at most \p truncateTo Unicode code
+  /// points. For decimal types, encodes the value in big-endian format as
+  /// required by Iceberg's single-value serialization specification. For
+  /// all other data types, uses the same plain encoding as Parquet.
+  /// (Returns the exact encoded minimum value).
+  ///
+  /// @param truncateTo Maximum number of Unicode code points for string
+  /// types.
+  virtual std::string icebergLowerBoundInclusive(int32_t truncateTo) const = 0;
 
-  /// \brief Plain-encoded maximum value
-  virtual std::string EncodeMax() const = 0;
+  /// \brief Encoded upper bound value compatible with Iceberg.
+  ///
+  /// Returns an encoded value guaranteed to be >= the actual maximum value.
+  /// For string types:
+  /// - If the maximum value has <= \p truncateTo Unicode code points,
+  /// returns the exact encoded maximum value (inclusive upper bound).
+  /// - If the maximum value has > \p truncateTo Unicode code points,
+  /// truncates to \p truncateTo code points and increments the last code point
+  /// to produce an exclusive upper bound that is greater than the maximum
+  /// value.
+  /// - Returns std::nullopt if no valid upper bound can be computed (e.g.,
+  /// all code points in the truncated portion are at the maximum Unicode
+  /// value U+10FFFF). This allows distinguishing between "upper bound is
+  /// empty string" and "no valid upper bound exists".
+  /// For decimal types, encodes the value in big-endian format as required
+  /// by Iceberg's single-value serialization specification. For all other
+  /// data types, uses the same plain encoding as Parquet. (Returns the
+  /// exact encoded maximum value).
+  ///
+  /// @param truncateTo Maximum number of Unicode code points for string
+  /// types.
+  /// @return Encoded upper bound value, or std::nullopt if no valid upper
+  ///         bound can be computed.
+  virtual std::optional<std::string> icebergUpperBoundExclusive(
+      int32_t truncateTo) const = 0;
 
-  /// \brief The finalized encoded form of the statistics for transport
-  virtual EncodedStatistics Encode() = 0;
+  /// \brief The finalized encoded form of the statistics for transport.
+  virtual EncodedStatistics encode() = 0;
 
-  /// \brief The physical type of the column schema
-  virtual Type::type physical_type() const = 0;
+  /// \brief The physical type of the column schema.
+  virtual Type::type physicalType() const = 0;
 
-  /// \brief The full type descriptor from the column schema
+  /// \brief The full type descriptor from the column schema.
   virtual const ColumnDescriptor* descr() const = 0;
 
-  /// \brief Check two Statistics for equality
-  virtual bool Equals(const Statistics& other) const = 0;
+  /// \brief Check two Statistics for equality.
+  virtual bool equals(const Statistics& other) const = 0;
+
+  /// \brief Return true if this object's max is greater than the other's
+  /// max.
+  /// \param[in] other The Statistics object to compare against.
+  virtual bool maxGreaterThan(const Statistics& other) const = 0;
+
+  /// \brief Return true if this object's min is less than the other's min.
+  /// \param[in] other The Statistics object to compare against.
+  virtual bool minLessThan(const Statistics& other) const = 0;
 
  protected:
-  static std::shared_ptr<Statistics> Make(
-      Type::type physical_type,
+  static std::shared_ptr<Statistics> make(
+      Type::type physicalType,
       const void* min,
       const void* max,
-      int64_t num_values,
-      int64_t null_count,
-      int64_t distinct_count);
+      int64_t numValues,
+      int64_t nullCount,
+      int64_t distinctCount);
 };
 
-/// \brief A typed implementation of Statistics
+/// \brief A typed implementation of Statistics.
 template <typename DType>
 class TypedStatistics : public Statistics {
  public:
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
 
-  /// \brief The current minimum value
+  /// \brief The current minimum value.
   virtual const T& min() const = 0;
 
-  /// \brief The current maximum value
+  /// \brief The current maximum value.
   virtual const T& max() const = 0;
 
-  /// \brief Update state with state of another Statistics object
-  virtual void Merge(const TypedStatistics<DType>& other) = 0;
+  /// \brief Update state with state of another Statistics object.
+  virtual void merge(const TypedStatistics<DType>& other) = 0;
 
-  /// \brief Batch statistics update
+  /// \brief Batch statistics update.
   virtual void
-  Update(const T* values, int64_t num_values, int64_t null_count) = 0;
-
-  /// \brief Batch statistics update with supplied validity bitmap
-  /// \param[in] values pointer to column values
-  /// \param[in] valid_bits Pointer to bitmap representing if values are
-  /// non-null. \param[in] valid_bits_offset Offset offset into valid_bits where
-  /// the slice of
-  ///                              data begins.
-  /// \param[in] num_spaced_values The length of values in values/valid_bits to
-  /// inspect
-  ///                              when calculating statistics. This can be
-  ///                              smaller than num_values+null_count as
-  ///                              null_count can include nulls from parents
-  ///                              while num_spaced_values does not.
-  /// \param[in] num_values Number of values that are not null.
-  /// \param[in] null_count Number of values that are null.
-  virtual void UpdateSpaced(
+  update(const T* values, int64_t numValues, int64_t nullCount) = 0;
+
+  /// \brief Batch statistics update with supplied validity bitmap.
+  /// \param[in] values Pointer to column values.
+  /// \param[in] validBits Pointer to bitmap representing if values are
+  /// non-null. \param[in] validBitsOffset Offset offset into validBits
+  /// where the slice of data begins.
+  /// \param[in] numSpacedValues The length of values in values/validBits to
+  /// inspect when calculating statistics. This can be smaller than
+  /// numValues + nullCount as nullCount can include nulls from parents
+  /// while numSpacedValues does not.
+  /// \param[in] numValues Number of values that are not null.
+  /// \param[in] nullCount Number of values that are null.
+  virtual void updateSpaced(
       const T* values,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      int64_t num_spaced_values,
-      int64_t num_values,
-      int64_t null_count) = 0;
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      int64_t numSpacedValues,
+      int64_t numValues,
+      int64_t nullCount) = 0;
 
   /// \brief EXPERIMENTAL: Update statistics with an Arrow array without
   /// conversion to a primitive Parquet C type. Only implemented for certain
   /// Parquet type / Arrow type combinations like BYTE_ARRAY /
-  /// arrow::BinaryArray
+  /// Arrow::BinaryArray.
   ///
-  /// If update_counts is true then the null_count and num_values will be
-  /// updated based on the null_count of values.  Set to false if these are
+  /// If updateCounts is true then the nullCount and numValues will be
+  /// updated based on the nullCount of values. Set to false if these are
   /// updated elsewhere (e.g. when updating a dictionary where the counts are
-  /// taken from the indices and not the values)
-  virtual void Update(
+  /// taken from the indices and not the values).
+  virtual void update(
       const ::arrow::Array& values,
-      bool update_counts = true) = 0;
+      bool updateCounts = true) = 0;
+
+  /// \brief Set min and max values to particular values.
+  virtual void setMinMax(const T& min, const T& max) = 0;
 
-  /// \brief Set min and max values to particular values
-  virtual void SetMinMax(const T& min, const T& max) = 0;
+  /// \brief Increments the null count directly.
+  /// Use Update to extract the null count from data.  Use this if you
+  /// determine the null count through some other means (e.g. dictionary arrays
+  /// where the null count is determined from the indices).
+  virtual void incrementNullCount(int64_t n) = 0;
 
-  /// \brief Increments the null count directly
-  /// Use Update to extract the null count from data.  Use this if you determine
-  /// the null count through some other means (e.g. dictionary arrays where the
-  /// null count is determined from the indices)
-  virtual void IncrementNullCount(int64_t n) = 0;
+  /// \brief Increments the number of values directly.
+  /// The same note on IncrementNullCount applies here.
+  virtual void incrementNumValues(int64_t n) = 0;
 
-  /// \brief Increments the number of values directly
-  /// The same note on IncrementNullCount applies here
-  virtual void IncrementNumValues(int64_t n) = 0;
+  /// \brief Increments the NaN count directly.
+  virtual void incrementNaNValues(int64_t n) = 0;
 };
 
 using BoolStatistics = TypedStatistics<BooleanType>;
@@ -379,55 +441,59 @@ using DoubleStatistics = TypedStatistics<DoubleType>;
 using ByteArrayStatistics = TypedStatistics<ByteArrayType>;
 using FLBAStatistics = TypedStatistics<FLBAType>;
 
-/// \brief Typed version of Statistics::Make
+/// \brief Typed version of Statistics::Make.
 template <typename DType>
-std::shared_ptr<TypedStatistics<DType>> MakeStatistics(
+std::shared_ptr<TypedStatistics<DType>> makeStatistics(
     const ColumnDescriptor* descr,
     ::arrow::MemoryPool* pool = ::arrow::default_memory_pool()) {
   return std::static_pointer_cast<TypedStatistics<DType>>(
-      Statistics::Make(descr, pool));
+      Statistics::make(descr, pool));
 }
 
-/// \brief Create Statistics initialized to a particular state
-/// \param[in] min the minimum value
-/// \param[in] max the minimum value
-/// \param[in] num_values number of values
-/// \param[in] null_count number of null values
-/// \param[in] distinct_count number of distinct values
+/// \brief Create Statistics initialized to a particular state.
+/// \param[in] min The minimum value.
+/// \param[in] max The maximum value.
+/// \param[in] numValues number of values.
+/// \param[in] nullCount Number of null values.
+/// \param[in] distinctCount Number of distinct values.
 template <typename DType>
-std::shared_ptr<TypedStatistics<DType>> MakeStatistics(
-    const typename DType::c_type& min,
-    const typename DType::c_type& max,
-    int64_t num_values,
-    int64_t null_count,
-    int64_t distinct_count) {
-  return std::static_pointer_cast<TypedStatistics<DType>>(Statistics::Make(
-      DType::type_num, &min, &max, num_values, null_count, distinct_count));
+std::shared_ptr<TypedStatistics<DType>> makeStatistics(
+    const typename DType::CType& min,
+    const typename DType::CType& max,
+    int64_t numValues,
+    int64_t nullCount,
+    int64_t distinctCount) {
+  return std::static_pointer_cast<TypedStatistics<DType>>(Statistics::make(
+      DType::typeNum, &min, &max, numValues, nullCount, distinctCount));
 }
 
-/// \brief Typed version of Statistics::Make
+/// \brief Typed version of Statistics::Make.
 template <typename DType>
-std::shared_ptr<TypedStatistics<DType>> MakeStatistics(
+std::shared_ptr<TypedStatistics<DType>> makeStatistics(
     const ColumnDescriptor* descr,
-    const std::string& encoded_min,
-    const std::string& encoded_max,
-    int64_t num_values,
-    int64_t null_count,
-    int64_t distinct_count,
-    bool has_min_max,
-    bool has_null_count,
-    bool has_distinct_count,
+    const std::string& encodedMin,
+    const std::string& encodedMax,
+    int64_t numValues,
+    int64_t nullCount,
+    int64_t distinctCount,
+    bool hasMinMax,
+    bool hasNullCount,
+    bool hasDistinctCount,
+    bool hasNaNCount,
+    int64_t nanCount,
     ::arrow::MemoryPool* pool = ::arrow::default_memory_pool()) {
-  return std::static_pointer_cast<TypedStatistics<DType>>(Statistics::Make(
+  return std::static_pointer_cast<TypedStatistics<DType>>(Statistics::make(
       descr,
-      encoded_min,
-      encoded_max,
-      num_values,
-      null_count,
-      distinct_count,
-      has_min_max,
-      has_null_count,
-      has_distinct_count,
+      encodedMin,
+      encodedMax,
+      numValues,
+      nullCount,
+      distinctCount,
+      hasMinMax,
+      hasNullCount,
+      hasDistinctCount,
+      hasNaNCount,
+      nanCount,
       pool));
 }
 
diff --git a/velox/dwio/parquet/writer/arrow/StringTruncation.cpp b/velox/dwio/parquet/writer/arrow/StringTruncation.cpp
new file mode 100644
index 00000000000..a7b4bad6bcb
--- /dev/null
+++ b/velox/dwio/parquet/writer/arrow/StringTruncation.cpp
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/parquet/writer/arrow/StringTruncation.h"
+
+#include <folly/CPortability.h>
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include "velox/functions/lib/string/StringCore.h"
+#include "velox/functions/lib/string/StringImpl.h"
+
+namespace facebook::velox::parquet::arrow {
+
+// Import necessary functions from stringImpl namespace
+using facebook::velox::functions::stringCore::isAscii;
+using facebook::velox::functions::stringImpl::cappedByteLength;
+
+namespace {
+
+// Increments a Unicode code point to the next valid Unicode scalar value.
+// Returns 0 if overflow (input is max code point).
+FOLLY_ALWAYS_INLINE int32_t incrementCodePoint(int32_t codePoint) {
+  static constexpr int32_t kMaxCodePoint = 0x10FFFF;
+  static constexpr int32_t kMinSurrogate = 0xD800;
+  static constexpr int32_t kMaxSurrogate = 0xDFFF;
+  if (codePoint == (kMinSurrogate - 1)) {
+    // Skip the surrogate range.
+    return kMaxSurrogate + 1;
+  } else if (codePoint == kMaxCodePoint) {
+    return 0;
+  }
+  return codePoint + 1;
+}
+
+// ASCII fast-path for roundUp.
+FOLLY_ALWAYS_INLINE std::optional<std::string> roundUpAscii(
+    std::string_view input,
+    int32_t numCodePoints) {
+  const size_t truncatedLength =
+      std::min(input.size(), static_cast<size_t>(numCodePoints));
+
+  if (truncatedLength == input.size()) {
+    return std::string(input);
+  }
+
+  if (truncatedLength == 0) {
+    return std::nullopt;
+  }
+
+  for (int32_t i = truncatedLength - 1; i >= 0; --i) {
+    const auto byte = static_cast<unsigned char>(input[i]);
+    if (byte < 0x7F) {
+      std::string result(input.data(), i);
+      result.push_back(static_cast<char>(byte + 1));
+      return result;
+    }
+  }
+
+  // All bytes are 0x7F (DEL character), no valid upper bound.
+  return std::nullopt;
+}
+
+// Unicode path for roundUp.
+FOLLY_ALWAYS_INLINE std::optional<std::string> roundUpUnicode(
+    std::string_view input,
+    int32_t numCodePoints) {
+  const auto truncatedLength = cappedByteLength<false>(input, numCodePoints);
+
+  if (truncatedLength == input.size()) {
+    return std::string(input);
+  }
+
+  if (truncatedLength == 0) {
+    return std::nullopt;
+  }
+
+  const char* data = input.data();
+  const char* truncatedEnd = data + truncatedLength;
+
+  // Collect the byte offset of each code point.
+  std::vector<size_t> codePointOffsets;
+  codePointOffsets.reserve(numCodePoints);
+  const char* current = data;
+  while (current < truncatedEnd) {
+    codePointOffsets.push_back(current - data);
+    int32_t charLength;
+    utf8proc_codepoint(current, truncatedEnd, charLength);
+    current += charLength;
+  }
+
+  // Try incrementing from the last code point backwards.
+  for (int32_t i = codePointOffsets.size() - 1; i >= 0; --i) {
+    const char* pos = data + codePointOffsets[i];
+    int32_t charLength;
+    const auto codePoint = utf8proc_codepoint(pos, truncatedEnd, charLength);
+    const auto nextCodePoint = incrementCodePoint(codePoint);
+    if (nextCodePoint != 0) {
+      std::string result(data, codePointOffsets[i]);
+      char buffer[4];
+      const auto bytesWritten = utf8proc_encode_char(
+          nextCodePoint, reinterpret_cast<utf8proc_uint8_t*>(buffer));
+      result.append(buffer, bytesWritten);
+      return result;
+    }
+  }
+
+  // No valid upper bound can be found.
+  return std::nullopt;
+}
+
+} // namespace
+
+std::string_view truncateUtf8(std::string_view input, int32_t numCodePoints) {
+  if (isAscii(input.data(), input.size())) {
+    return std::string_view(
+        input.data(), std::min(input.size(), (size_t)numCodePoints));
+  }
+  const auto truncatedLength = cappedByteLength<false>(input, numCodePoints);
+  return std::string_view(input.data(), truncatedLength);
+}
+
+std::optional<std::string> roundUpUtf8(
+    std::string_view input,
+    int32_t numCodePoints) {
+  if (isAscii(input.data(), input.size())) {
+    return roundUpAscii(input, numCodePoints);
+  }
+  return roundUpUnicode(input, numCodePoints);
+}
+
+std::optional<std::string> roundUpBinary(
+    std::string_view input,
+    int32_t truncateLength) {
+  if (truncateLength <= 0) {
+    return std::nullopt;
+  }
+
+  const size_t length = static_cast<size_t>(truncateLength);
+  if (input.size() <= length) {
+    return std::string(input);
+  }
+
+  // Create a mutable copy of the truncated input.
+  std::string result(input.data(), length);
+
+  // Try incrementing bytes from the end.
+  for (size_t i = length; i-- > 0;) {
+    unsigned char byte = static_cast<unsigned char>(result[i]);
+
+    if (byte != 0xFF) { // Can increment without overflow.
+      result[i] = static_cast<char>(byte + 1);
+      // Truncate to i + 1 bytes (remove trailing bytes after increment point).
+      result.resize(i + 1);
+      return result;
+    }
+    // If byte == 0xFF, it will overflow, continue to previous byte.
+  }
+
+  // All bytes were 0xFF and overflowed - no valid upper bound.
+  return std::nullopt;
+}
+
+} // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/StringTruncation.h b/velox/dwio/parquet/writer/arrow/StringTruncation.h
new file mode 100644
index 00000000000..2a0fcb35ec4
--- /dev/null
+++ b/velox/dwio/parquet/writer/arrow/StringTruncation.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <string_view>
+
+namespace facebook::velox::parquet::arrow {
+
+/// Truncates a UTF-8 encoded string to at most 'numCodePoints' Unicode code
+/// points. Returns a string_view pointing to the truncated portion of the
+/// input string. This is used for computing lower bound statistics,
+/// as the truncated string is guaranteed to be less than or equal to the
+/// original string in lexicographic order.
+///
+/// @param input The UTF-8 encoded input string.
+/// @param numCodePoints Maximum number of Unicode code points to retain.
+/// @return A string_view of the truncated string.
+std::string_view truncateUtf8(std::string_view input, int32_t numCodePoints);
+
+/// Rounds up a UTF-8 encoded string to produce an exclusive upper bound.
+/// The result is guaranteed to be greater than any string that shares the
+/// same prefix up to 'numCodePoints' code points. This is used for computing
+/// upper bound statistics.
+///
+/// The function behaves as follows:
+/// - If the string has fewer than or equal to 'numCodePoints' code points,
+///   returns the original string unchanged.
+/// - Otherwise, truncates to 'numCodePoints' code points and increments
+///   code points from the last to the first, returning immediately on the
+///   first successful increment.
+/// - If no code point can be incremented (e.g., all are at max value
+///   U+10FFFF), returns std::nullopt.
+///
+/// @param input The UTF-8 encoded input string.
+/// @param numCodePoints Maximum number of Unicode code points to retain.
+/// @return A new string containing the rounded-up result, or std::nullopt if
+///         no valid upper bound can be computed.
+std::optional<std::string> roundUpUtf8(
+    std::string_view input,
+    int32_t numCodePoints);
+
+/// Computes an upper bound for binary data by truncating to a specified length
+/// and incrementing the last byte that is not 0xFF.
+///
+/// This function is used for computing upper bounds on binary statistics
+/// (e.g., for Parquet file metadata). It follows the algorithm described in
+/// Apache Iceberg's BinaryUtil.truncateBinaryMax().
+///
+/// The algorithm:
+/// 1. If the input is shorter than or equal to truncateLength, return it as-is.
+/// 2. Otherwise, truncate to truncateLength bytes.
+/// 3. Starting from the last byte, find the first byte that is not 0xFF.
+/// 4. Increment that byte and truncate everything after it.
+/// 5. If all bytes are 0xFF, return std::nullopt (no valid upper bound).
+///
+/// @param input The binary data as a string_view.
+/// @param truncateLength Maximum number of bytes to retain before incrementing.
+/// @return An optional string containing the upper bound, or std::nullopt if
+///         no valid upper bound exists (e.g., all bytes are 0xFF).
+std::optional<std::string> roundUpBinary(
+    std::string_view input,
+    int32_t truncateLength);
+
+} // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/ThriftInternal.h b/velox/dwio/parquet/writer/arrow/ThriftInternal.h
index a6383474d23..2ce0e151741 100644
--- a/velox/dwio/parquet/writer/arrow/ThriftInternal.h
+++ b/velox/dwio/parquet/writer/arrow/ThriftInternal.h
@@ -46,38 +46,38 @@
 
 namespace facebook::velox::parquet::arrow {
 
-// ----------------------------------------------------------------------
-// Convert Thrift enums to Parquet enums
+// ----------------------------------------------------------------------.
+// Convert Thrift enums to Parquet enums.
 
 // Unsafe enum converters (input is not checked for validity)
 
-static inline Type::type FromThriftUnsafe(
+static inline Type::type fromThriftUnsafe(
     facebook::velox::parquet::thrift::Type::type type) {
   return static_cast<Type::type>(type);
 }
 
-static inline ConvertedType::type FromThriftUnsafe(
+static inline ConvertedType::type fromThriftUnsafe(
     facebook::velox::parquet::thrift::ConvertedType::type type) {
-  // item 0 is NONE
+  // Item 0 is NONE.
   return static_cast<ConvertedType::type>(static_cast<int>(type) + 1);
 }
 
-static inline Repetition::type FromThriftUnsafe(
+static inline Repetition::type fromThriftUnsafe(
     facebook::velox::parquet::thrift::FieldRepetitionType::type type) {
   return static_cast<Repetition::type>(type);
 }
 
-static inline Encoding::type FromThriftUnsafe(
+static inline Encoding::type fromThriftUnsafe(
     facebook::velox::parquet::thrift::Encoding::type type) {
   return static_cast<Encoding::type>(type);
 }
 
-static inline PageType::type FromThriftUnsafe(
+static inline PageType::type fromThriftUnsafe(
     facebook::velox::parquet::thrift::PageType::type type) {
   return static_cast<PageType::type>(type);
 }
 
-static inline Compression::type FromThriftUnsafe(
+static inline Compression::type fromThriftUnsafe(
     facebook::velox::parquet::thrift::CompressionCodec::type type) {
   switch (type) {
     case facebook::velox::parquet::thrift::CompressionCodec::UNCOMPRESSED:
@@ -102,7 +102,7 @@ static inline Compression::type FromThriftUnsafe(
   }
 }
 
-static inline BoundaryOrder::type FromThriftUnsafe(
+static inline BoundaryOrder::type fromThriftUnsafe(
     facebook::velox::parquet::thrift::BoundaryOrder::type type) {
   return static_cast<BoundaryOrder::type>(type);
 }
@@ -110,131 +110,131 @@ static inline BoundaryOrder::type FromThriftUnsafe(
 namespace internal {
 
 template <typename T>
-struct ThriftEnumTypeTraits {};
+struct ThriftenumTypeTraits {};
 
 template <>
-struct ThriftEnumTypeTraits<::facebook::velox::parquet::thrift::Type::type> {
-  using ParquetEnum = Type;
+struct ThriftenumTypeTraits<::facebook::velox::parquet::thrift::Type::type> {
+  using Parquetenum = Type;
 };
 
 template <>
-struct ThriftEnumTypeTraits<
+struct ThriftenumTypeTraits<
     ::facebook::velox::parquet::thrift::ConvertedType::type> {
-  using ParquetEnum = ConvertedType;
+  using Parquetenum = ConvertedType;
 };
 
 template <>
-struct ThriftEnumTypeTraits<
+struct ThriftenumTypeTraits<
     ::facebook::velox::parquet::thrift::FieldRepetitionType::type> {
-  using ParquetEnum = Repetition;
+  using Parquetenum = Repetition;
 };
 
 template <>
-struct ThriftEnumTypeTraits<
+struct ThriftenumTypeTraits<
     ::facebook::velox::parquet::thrift::Encoding::type> {
-  using ParquetEnum = Encoding;
+  using Parquetenum = Encoding;
 };
 
 template <>
-struct ThriftEnumTypeTraits<
+struct ThriftenumTypeTraits<
     ::facebook::velox::parquet::thrift::PageType::type> {
-  using ParquetEnum = PageType;
+  using Parquetenum = PageType;
 };
 
 template <>
-struct ThriftEnumTypeTraits<
+struct ThriftenumTypeTraits<
     ::facebook::velox::parquet::thrift::BoundaryOrder::type> {
-  using ParquetEnum = BoundaryOrder;
+  using Parquetenum = BoundaryOrder;
 };
 
-// If the parquet file is corrupted it is possible the enum value decoded
-// will not be in the range of defined values, which is undefined behaviour.
+// If the parquet file is corrupted it is possible the enum value decoded.
+// Will not be in the range of defined values, which is undefined behaviour.
 // This facility prevents this by loading the value as the underlying type
 // and checking to make sure it is in range.
 
 template <
-    typename EnumType,
-    typename EnumTypeRaw = typename std::underlying_type<EnumType>::type>
-inline static EnumTypeRaw LoadEnumRaw(const EnumType* in) {
-  EnumTypeRaw raw_value;
+    typename enumType,
+    typename enumTypeRaw = typename std::underlying_type<enumType>::type>
+inline static enumTypeRaw loadenumRaw(const enumType* in) {
+  enumTypeRaw rawValue;
   // Use memcpy(), as a regular cast would be undefined behaviour on invalid
-  // values
-  memcpy(&raw_value, in, sizeof(EnumType));
-  return raw_value;
+  // values.
+  memcpy(&rawValue, in, sizeof(enumType));
+  return rawValue;
 }
 
 template <typename ApiType>
 struct SafeLoader {
-  using ApiTypeEnum = typename ApiType::type;
-  using ApiTypeRawEnum = typename std::underlying_type<ApiTypeEnum>::type;
+  using ApiTypeenum = typename ApiType::type;
+  using ApiTypeRawenum = typename std::underlying_type<ApiTypeenum>::type;
 
   template <typename ThriftType>
-  inline static ApiTypeRawEnum LoadRaw(const ThriftType* in) {
+  inline static ApiTypeRawenum loadRaw(const ThriftType* in) {
     static_assert(
-        sizeof(ApiTypeEnum) == sizeof(ThriftType),
+        sizeof(ApiTypeenum) == sizeof(ThriftType),
         "parquet type should always be the same size as thrift type");
-    return static_cast<ApiTypeRawEnum>(LoadEnumRaw(in));
+    return static_cast<ApiTypeRawenum>(loadenumRaw(in));
   }
 
   template <typename ThriftType, bool IsUnsigned = true>
-  inline static ApiTypeEnum LoadChecked(
+  inline static ApiTypeenum loadChecked(
       const typename std::enable_if<IsUnsigned, ThriftType>::type* in) {
-    auto raw_value = LoadRaw(in);
+    auto rawValue = loadRaw(in);
     if (ARROW_PREDICT_FALSE(
-            raw_value >= static_cast<ApiTypeRawEnum>(ApiType::UNDEFINED))) {
-      return ApiType::UNDEFINED;
+            rawValue >= static_cast<ApiTypeRawenum>(ApiType::kUndefined))) {
+      return ApiType::kUndefined;
     }
-    return FromThriftUnsafe(static_cast<ThriftType>(raw_value));
+    return fromThriftUnsafe(static_cast<ThriftType>(rawValue));
   }
 
   template <typename ThriftType, bool IsUnsigned = false>
-  inline static ApiTypeEnum LoadChecked(
+  inline static ApiTypeenum loadChecked(
       const typename std::enable_if<!IsUnsigned, ThriftType>::type* in) {
-    auto raw_value = LoadRaw(in);
+    auto rawValue = loadRaw(in);
     if (ARROW_PREDICT_FALSE(
-            raw_value >= static_cast<ApiTypeRawEnum>(ApiType::UNDEFINED) ||
-            raw_value < 0)) {
-      return ApiType::UNDEFINED;
+            rawValue >= static_cast<ApiTypeRawenum>(ApiType::kUndefined) ||
+            rawValue < 0)) {
+      return ApiType::kUndefined;
     }
-    return FromThriftUnsafe(static_cast<ThriftType>(raw_value));
+    return fromThriftUnsafe(static_cast<ThriftType>(rawValue));
   }
 
   template <typename ThriftType>
-  inline static ApiTypeEnum Load(const ThriftType* in) {
-    return LoadChecked<ThriftType, std::is_unsigned<ApiTypeRawEnum>::value>(in);
+  inline static ApiTypeenum load(const ThriftType* in) {
+    return loadChecked<ThriftType, std::is_unsigned<ApiTypeRawenum>::value>(in);
   }
 };
 
 } // namespace internal
 
-// Safe enum loader: will check for invalid enum value before converting
+// Safe enum loader: will check for invalid enum value before converting.
 
 template <
     typename ThriftType,
-    typename ParquetEnum =
-        typename internal::ThriftEnumTypeTraits<ThriftType>::ParquetEnum>
-inline typename ParquetEnum::type LoadEnumSafe(const ThriftType* in) {
-  return internal::SafeLoader<ParquetEnum>::Load(in);
+    typename Parquetenum =
+        typename internal::ThriftenumTypeTraits<ThriftType>::Parquetenum>
+inline typename Parquetenum::type loadenumSafe(const ThriftType* in) {
+  return internal::SafeLoader<Parquetenum>::load(in);
 }
 
-inline typename Compression::type LoadEnumSafe(
+inline typename Compression::type loadenumSafe(
     const facebook::velox::parquet::thrift::CompressionCodec::type* in) {
-  const auto raw_value = internal::LoadEnumRaw(in);
+  const auto rawValue = internal::loadenumRaw(in);
   // Check bounds manually, as Compression::type doesn't have the same values
   // as facebook::velox::parquet::thrift::CompressionCodec.
-  const auto min_value = static_cast<decltype(raw_value)>(
+  const auto minValue = static_cast<decltype(rawValue)>(
       facebook::velox::parquet::thrift::CompressionCodec::UNCOMPRESSED);
-  const auto max_value = static_cast<decltype(raw_value)>(
+  const auto maxValue = static_cast<decltype(rawValue)>(
       facebook::velox::parquet::thrift::CompressionCodec::LZ4_RAW);
-  if (raw_value < min_value || raw_value > max_value) {
+  if (rawValue < minValue || rawValue > maxValue) {
     return Compression::UNCOMPRESSED;
   }
-  return FromThriftUnsafe(*in);
+  return fromThriftUnsafe(*in);
 }
 
-// Safe non-enum converters
+// Safe non-enum converters.
 
-static inline AadMetadata FromThrift(
+static inline AadMetadata fromThrift(
     facebook::velox::parquet::thrift::AesGcmV1 aesGcmV1) {
   return AadMetadata{
       aesGcmV1.aad_prefix,
@@ -242,7 +242,7 @@ static inline AadMetadata FromThrift(
       aesGcmV1.supply_aad_prefix};
 }
 
-static inline AadMetadata FromThrift(
+static inline AadMetadata fromThrift(
     facebook::velox::parquet::thrift::AesGcmCtrV1 aesGcmCtrV1) {
   return AadMetadata{
       aesGcmCtrV1.aad_prefix,
@@ -250,67 +250,68 @@ static inline AadMetadata FromThrift(
       aesGcmCtrV1.supply_aad_prefix};
 }
 
-static inline EncryptionAlgorithm FromThrift(
+static inline EncryptionAlgorithm fromThrift(
     facebook::velox::parquet::thrift::EncryptionAlgorithm encryption) {
-  EncryptionAlgorithm encryption_algorithm;
+  EncryptionAlgorithm encryptionAlgorithm;
 
   if (encryption.__isset.AES_GCM_V1) {
-    encryption_algorithm.algorithm = ParquetCipher::AES_GCM_V1;
-    encryption_algorithm.aad = FromThrift(encryption.AES_GCM_V1);
+    encryptionAlgorithm.algorithm = ParquetCipher::kAesGcmV1;
+    encryptionAlgorithm.aad = fromThrift(encryption.AES_GCM_V1);
   } else if (encryption.__isset.AES_GCM_CTR_V1) {
-    encryption_algorithm.algorithm = ParquetCipher::AES_GCM_CTR_V1;
-    encryption_algorithm.aad = FromThrift(encryption.AES_GCM_CTR_V1);
+    encryptionAlgorithm.algorithm = ParquetCipher::kAesGcmCtrV1;
+    encryptionAlgorithm.aad = fromThrift(encryption.AES_GCM_CTR_V1);
   } else {
     throw ParquetException("Unsupported algorithm");
   }
-  return encryption_algorithm;
+  return encryptionAlgorithm;
 }
 
-static inline SortingColumn FromThrift(
-    facebook::velox::parquet::thrift::SortingColumn thrift_sorting_column) {
-  SortingColumn sorting_column;
-  sorting_column.column_idx = thrift_sorting_column.column_idx;
-  sorting_column.nulls_first = thrift_sorting_column.nulls_first;
-  sorting_column.descending = thrift_sorting_column.descending;
-  return sorting_column;
+static inline SortingColumn fromThrift(
+    facebook::velox::parquet::thrift::SortingColumn thriftSortingColumn) {
+  SortingColumn sortingColumn;
+  sortingColumn.columnIdx = thriftSortingColumn.column_idx;
+  sortingColumn.nullsFirst = thriftSortingColumn.nulls_first;
+  sortingColumn.descending = thriftSortingColumn.descending;
+  return sortingColumn;
 }
 
-// ----------------------------------------------------------------------
-// Convert Thrift enums from Parquet enums
+// ----------------------------------------------------------------------.
+// Convert Thrift enums from Parquet enums.
 
-static inline facebook::velox::parquet::thrift::Type::type ToThrift(
+static inline facebook::velox::parquet::thrift::Type::type toThrift(
     Type::type type) {
   return static_cast<facebook::velox::parquet::thrift::Type::type>(type);
 }
 
-static fmt::underlying_t<ConvertedType::type> format_as(
+static fmt::underlying_t<ConvertedType::type> formatAs(
     ConvertedType::type type) {
   return fmt::underlying(type);
 }
 
-static inline facebook::velox::parquet::thrift::ConvertedType::type ToThrift(
+static inline facebook::velox::parquet::thrift::ConvertedType::type toThrift(
     ConvertedType::type type) {
-  // item 0 is NONE
-  VELOX_DCHECK_NE(type, ConvertedType::NONE);
+  // Item 0 is NONE.
+  const int typeValue = static_cast<int>(type);
+  VELOX_DCHECK_NE(typeValue, static_cast<int>(ConvertedType::kNone));
   // it is forbidden to emit "NA" (PARQUET-1990)
-  VELOX_DCHECK_NE(type, ConvertedType::NA);
-  VELOX_DCHECK_NE(type, ConvertedType::UNDEFINED);
+  VELOX_DCHECK_NE(typeValue, static_cast<int>(ConvertedType::kNa));
+  VELOX_DCHECK_NE(typeValue, static_cast<int>(ConvertedType::kUndefined));
   return static_cast<facebook::velox::parquet::thrift::ConvertedType::type>(
-      static_cast<int>(type) - 1);
+      typeValue - 1);
 }
 
 static inline facebook::velox::parquet::thrift::FieldRepetitionType::type
-ToThrift(Repetition::type type) {
+toThrift(Repetition::type type) {
   return static_cast<
       facebook::velox::parquet::thrift::FieldRepetitionType::type>(type);
 }
 
-static inline facebook::velox::parquet::thrift::Encoding::type ToThrift(
+static inline facebook::velox::parquet::thrift::Encoding::type toThrift(
     Encoding::type type) {
   return static_cast<facebook::velox::parquet::thrift::Encoding::type>(type);
 }
 
-static inline facebook::velox::parquet::thrift::CompressionCodec::type ToThrift(
+static inline facebook::velox::parquet::thrift::CompressionCodec::type toThrift(
     Compression::type type) {
   switch (type) {
     case Compression::UNCOMPRESSED:
@@ -326,7 +327,7 @@ static inline facebook::velox::parquet::thrift::CompressionCodec::type ToThrift(
     case Compression::LZ4:
       return facebook::velox::parquet::thrift::CompressionCodec::LZ4_RAW;
     case Compression::LZ4_HADOOP:
-      // Deprecated "LZ4" Parquet compression has Hadoop-specific framing
+      // Deprecated "LZ4" Parquet compression has Hadoop-specific framing.
       return facebook::velox::parquet::thrift::CompressionCodec::LZ4;
     case Compression::ZSTD:
       return facebook::velox::parquet::thrift::CompressionCodec::ZSTD;
@@ -336,12 +337,12 @@ static inline facebook::velox::parquet::thrift::CompressionCodec::type ToThrift(
   }
 }
 
-static inline facebook::velox::parquet::thrift::BoundaryOrder::type ToThrift(
+static inline facebook::velox::parquet::thrift::BoundaryOrder::type toThrift(
     BoundaryOrder::type type) {
   switch (type) {
-    case BoundaryOrder::Unordered:
-    case BoundaryOrder::Ascending:
-    case BoundaryOrder::Descending:
+    case BoundaryOrder::kUnordered:
+    case BoundaryOrder::kAscending:
+    case BoundaryOrder::kDescending:
       return static_cast<facebook::velox::parquet::thrift::BoundaryOrder::type>(
           type);
     default:
@@ -350,82 +351,82 @@ static inline facebook::velox::parquet::thrift::BoundaryOrder::type ToThrift(
   }
 }
 
-static inline facebook::velox::parquet::thrift::SortingColumn ToThrift(
-    SortingColumn sorting_column) {
-  facebook::velox::parquet::thrift::SortingColumn thrift_sorting_column;
-  thrift_sorting_column.column_idx = sorting_column.column_idx;
-  thrift_sorting_column.descending = sorting_column.descending;
-  thrift_sorting_column.nulls_first = sorting_column.nulls_first;
-  return thrift_sorting_column;
+static inline facebook::velox::parquet::thrift::SortingColumn toThrift(
+    SortingColumn sortingColumn) {
+  facebook::velox::parquet::thrift::SortingColumn thriftSortingColumn;
+  thriftSortingColumn.column_idx = sortingColumn.columnIdx;
+  thriftSortingColumn.descending = sortingColumn.descending;
+  thriftSortingColumn.nulls_first = sortingColumn.nullsFirst;
+  return thriftSortingColumn;
 }
 
-static inline facebook::velox::parquet::thrift::Statistics ToThrift(
+static inline facebook::velox::parquet::thrift::Statistics toThrift(
     const EncodedStatistics& stats) {
-  facebook::velox::parquet::thrift::Statistics statistics;
-  if (stats.has_min) {
-    statistics.__set_min_value(stats.min());
+  facebook::velox::parquet::thrift::Statistics Statistics;
+  if (stats.hasMin) {
+    Statistics.__set_min_value(stats.min());
     // If the order is SIGNED, then the old min value must be set too.
-    // This for backward compatibility
-    if (stats.is_signed()) {
-      statistics.__set_min(stats.min());
+    // This for backward compatibility.
+    if (stats.isSigned()) {
+      Statistics.__set_min(stats.min());
     }
   }
-  if (stats.has_max) {
-    statistics.__set_max_value(stats.max());
+  if (stats.hasMax) {
+    Statistics.__set_max_value(stats.max());
     // If the order is SIGNED, then the old max value must be set too.
-    // This for backward compatibility
-    if (stats.is_signed()) {
-      statistics.__set_max(stats.max());
+    // This for backward compatibility.
+    if (stats.isSigned()) {
+      Statistics.__set_max(stats.max());
     }
   }
-  if (stats.has_null_count) {
-    statistics.__set_null_count(stats.null_count);
+  if (stats.hasNullCount) {
+    Statistics.__set_null_count(stats.nullCount);
   }
-  if (stats.has_distinct_count) {
-    statistics.__set_distinct_count(stats.distinct_count);
+  if (stats.hasDistinctCount) {
+    Statistics.__set_distinct_count(stats.distinctCount);
   }
 
-  return statistics;
+  return Statistics;
 }
 
-static inline facebook::velox::parquet::thrift::AesGcmV1 ToAesGcmV1Thrift(
+static inline facebook::velox::parquet::thrift::AesGcmV1 toAesGcmV1Thrift(
     AadMetadata aad) {
   facebook::velox::parquet::thrift::AesGcmV1 aesGcmV1;
-  // aad_file_unique is always set
-  aesGcmV1.__set_aad_file_unique(aad.aad_file_unique);
-  aesGcmV1.__set_supply_aad_prefix(aad.supply_aad_prefix);
-  if (!aad.aad_prefix.empty()) {
-    aesGcmV1.__set_aad_prefix(aad.aad_prefix);
+  // Aad_file_unique is always set.
+  aesGcmV1.__set_aad_file_unique(aad.aadFileUnique);
+  aesGcmV1.__set_supply_aad_prefix(aad.supplyAadPrefix);
+  if (!aad.aadPrefix.empty()) {
+    aesGcmV1.__set_aad_prefix(aad.aadPrefix);
   }
   return aesGcmV1;
 }
 
-static inline facebook::velox::parquet::thrift::AesGcmCtrV1 ToAesGcmCtrV1Thrift(
+static inline facebook::velox::parquet::thrift::AesGcmCtrV1 toAesGcmCtrV1Thrift(
     AadMetadata aad) {
   facebook::velox::parquet::thrift::AesGcmCtrV1 aesGcmCtrV1;
-  // aad_file_unique is always set
-  aesGcmCtrV1.__set_aad_file_unique(aad.aad_file_unique);
-  aesGcmCtrV1.__set_supply_aad_prefix(aad.supply_aad_prefix);
-  if (!aad.aad_prefix.empty()) {
-    aesGcmCtrV1.__set_aad_prefix(aad.aad_prefix);
+  // Aad_file_unique is always set.
+  aesGcmCtrV1.__set_aad_file_unique(aad.aadFileUnique);
+  aesGcmCtrV1.__set_supply_aad_prefix(aad.supplyAadPrefix);
+  if (!aad.aadPrefix.empty()) {
+    aesGcmCtrV1.__set_aad_prefix(aad.aadPrefix);
   }
   return aesGcmCtrV1;
 }
 
-static inline facebook::velox::parquet::thrift::EncryptionAlgorithm ToThrift(
+static inline facebook::velox::parquet::thrift::EncryptionAlgorithm toThrift(
     EncryptionAlgorithm encryption) {
-  facebook::velox::parquet::thrift::EncryptionAlgorithm encryption_algorithm;
-  if (encryption.algorithm == ParquetCipher::AES_GCM_V1) {
-    encryption_algorithm.__set_AES_GCM_V1(ToAesGcmV1Thrift(encryption.aad));
+  facebook::velox::parquet::thrift::EncryptionAlgorithm encryptionAlgorithm;
+  if (encryption.algorithm == ParquetCipher::kAesGcmV1) {
+    encryptionAlgorithm.__set_AES_GCM_V1(toAesGcmV1Thrift(encryption.aad));
   } else {
-    encryption_algorithm.__set_AES_GCM_CTR_V1(
-        ToAesGcmCtrV1Thrift(encryption.aad));
+    encryptionAlgorithm.__set_AES_GCM_CTR_V1(
+        toAesGcmCtrV1Thrift(encryption.aad));
   }
-  return encryption_algorithm;
+  return encryptionAlgorithm;
 }
 
-// ----------------------------------------------------------------------
-// Thrift struct serialization / deserialization utilities
+// ----------------------------------------------------------------------.
+// Thrift struct serialization / deserialization utilities.
 
 using ThriftBuffer = apache::thrift::transport::TMemoryBuffer;
 
@@ -433,43 +434,43 @@ class ThriftDeserializer {
  public:
   explicit ThriftDeserializer(const ReaderProperties& properties)
       : ThriftDeserializer(
-            properties.thrift_string_size_limit(),
-            properties.thrift_container_size_limit()) {}
+            properties.thriftStringSizeLimit(),
+            properties.thriftContainerSizeLimit()) {}
 
-  ThriftDeserializer(int32_t string_size_limit, int32_t container_size_limit)
-      : string_size_limit_(string_size_limit),
-        container_size_limit_(container_size_limit) {}
+  ThriftDeserializer(int32_t stringSizeLimit, int32_t containerSizeLimit)
+      : stringSizeLimit_(stringSizeLimit),
+        containerSizeLimit_(containerSizeLimit) {}
 
   // Deserialize a thrift message from buf/len.  buf/len must at least contain
   // all the bytes needed to store the thrift message.  On return, len will be
   // set to the actual length of the header.
   template <class T>
-  void DeserializeMessage(
+  void deserializeMessage(
       const uint8_t* buf,
       uint32_t* len,
-      T* deserialized_msg,
-      const std::shared_ptr<Decryptor>& decryptor = NULLPTR) {
-    if (decryptor == NULLPTR) {
-      // thrift message is not encrypted
-      DeserializeUnencryptedMessage(buf, len, deserialized_msg);
+      T* deserializedMsg,
+      const std::shared_ptr<Decryptor>& Decryptor = NULLPTR) {
+    if (Decryptor == NULLPTR) {
+      // Thrift message is not encrypted.
+      deserializeUnencryptedMessage(buf, len, deserializedMsg);
     } else {
-      // thrift message is encrypted
+      // Thrift message is encrypted.
       uint32_t clen;
       clen = *len;
-      // decrypt
-      auto decrypted_buffer =
-          std::static_pointer_cast<ResizableBuffer>(AllocateBuffer(
-              decryptor->pool(),
-              static_cast<int64_t>(clen - decryptor->CiphertextSizeDelta())));
-      const uint8_t* cipher_buf = buf;
-      uint32_t decrypted_buffer_len =
-          decryptor->Decrypt(cipher_buf, 0, decrypted_buffer->mutable_data());
-      if (decrypted_buffer_len <= 0) {
+      // Decrypt.
+      auto decryptedBuffer =
+          std::static_pointer_cast<ResizableBuffer>(allocateBuffer(
+              Decryptor->pool(),
+              static_cast<int64_t>(clen - Decryptor->ciphertextSizeDelta())));
+      const uint8_t* cipherBuf = buf;
+      uint32_t decryptedBufferLen =
+          Decryptor->decrypt(cipherBuf, 0, decryptedBuffer->mutable_data());
+      if (decryptedBufferLen <= 0) {
         throw ParquetException("Couldn't decrypt buffer\n");
       }
-      *len = decrypted_buffer_len + decryptor->CiphertextSizeDelta();
-      DeserializeUnencryptedMessage(
-          decrypted_buffer->data(), &decrypted_buffer_len, deserialized_msg);
+      *len = decryptedBufferLen + Decryptor->ciphertextSizeDelta();
+      deserializeUnencryptedMessage(
+          decryptedBuffer->data(), &decryptedBufferLen, deserializedMsg);
     }
   }
 
@@ -477,7 +478,7 @@ class ThriftDeserializer {
   // On Thrift 0.14.0+, we want to use TConfiguration to raise the max message
   // size limit (ARROW-13655).  If we wanted to protect against huge messages,
   // we could do it ourselves since we know the message size up front.
-  std::shared_ptr<ThriftBuffer> CreateReadOnlyMemoryBuffer(
+  std::shared_ptr<ThriftBuffer> createReadOnlyMemoryBuffer(
       uint8_t* buf,
       uint32_t len) {
 #if PARQUET_THRIFT_VERSION_MAJOR > 0 || PARQUET_THRIFT_VERSION_MINOR >= 14
@@ -491,84 +492,84 @@ class ThriftDeserializer {
   }
 
   template <class T>
-  void DeserializeUnencryptedMessage(
+  void deserializeUnencryptedMessage(
       const uint8_t* buf,
       uint32_t* len,
-      T* deserialized_msg) {
+      T* deserializedMsg) {
     // Deserialize msg bytes into c++ thrift msg using memory transport.
-    auto tmem_transport =
-        CreateReadOnlyMemoryBuffer(const_cast<uint8_t*>(buf), *len);
+    auto tmemTransport =
+        createReadOnlyMemoryBuffer(const_cast<uint8_t*>(buf), *len);
     apache::thrift::protocol::TCompactProtocolFactoryT<ThriftBuffer>
-        tproto_factory;
-    // Protect against CPU and memory bombs
-    tproto_factory.setStringSizeLimit(string_size_limit_);
-    tproto_factory.setContainerSizeLimit(container_size_limit_);
-    auto tproto = tproto_factory.getProtocol(tmem_transport);
+        tprotoFactory;
+    // Protect against CPU and memory bombs.
+    tprotoFactory.setStringSizeLimit(stringSizeLimit_);
+    tprotoFactory.setContainerSizeLimit(containerSizeLimit_);
+    auto tproto = tprotoFactory.getProtocol(tmemTransport);
     try {
-      deserialized_msg->read(tproto.get());
+      deserializedMsg->read(tproto.get());
     } catch (std::exception& e) {
       std::stringstream ss;
       ss << "Couldn't deserialize thrift: " << e.what() << "\n";
       throw ParquetException(ss.str());
     }
-    uint32_t bytes_left = tmem_transport->available_read();
-    *len = *len - bytes_left;
+    uint32_t bytesLeft = tmemTransport->available_read();
+    *len = *len - bytesLeft;
   }
 
-  const int32_t string_size_limit_;
-  const int32_t container_size_limit_;
+  const int32_t stringSizeLimit_;
+  const int32_t containerSizeLimit_;
 };
 
 /// Utility class to serialize thrift objects to a binary format.  This object
 /// should be reused if possible to reuse the underlying memory.
-/// Note: thrift will encode NULLs into the serialized buffer so it is not valid
-/// to treat it as a string.
+/// Note: thrift will encode NULLs into the serialized buffer so it is not
+/// valid. To treat it as a string.
 class ThriftSerializer {
  public:
-  explicit ThriftSerializer(int initial_buffer_size = 1024)
-      : mem_buffer_(new ThriftBuffer(initial_buffer_size)) {
+  explicit ThriftSerializer(int initialBufferSize = 1024)
+      : memBuffer_(std::make_shared<ThriftBuffer>(initialBufferSize)) {
     apache::thrift::protocol::TCompactProtocolFactoryT<ThriftBuffer> factory;
-    protocol_ = factory.getProtocol(mem_buffer_);
+    protocol_ = factory.getProtocol(memBuffer_);
   }
 
   /// Serialize obj into a memory buffer.  The result is returned in buffer/len.
   /// The memory returned is owned by this object and will be invalid when
   /// another object is serialized.
   template <class T>
-  void SerializeToBuffer(const T* obj, uint32_t* len, uint8_t** buffer) {
-    SerializeObject(obj);
-    mem_buffer_->getBuffer(buffer, len);
+  void serializeToBuffer(const T* obj, uint32_t* len, uint8_t** buffer) {
+    serializeObject(obj);
+    memBuffer_->getBuffer(buffer, len);
   }
 
   template <class T>
-  void SerializeToString(const T* obj, std::string* result) {
-    SerializeObject(obj);
-    *result = mem_buffer_->getBufferAsString();
+  void serializeToString(const T* obj, std::string* result) {
+    serializeObject(obj);
+    *result = memBuffer_->getBufferAsString();
   }
 
   template <class T>
-  int64_t Serialize(
+  int64_t serialize(
       const T* obj,
       ArrowOutputStream* out,
-      const std::shared_ptr<Encryptor>& encryptor = NULLPTR) {
-    uint8_t* out_buffer;
-    uint32_t out_length;
-    SerializeToBuffer(obj, &out_length, &out_buffer);
-
-    // obj is not encrypted
-    if (encryptor == NULLPTR) {
-      PARQUET_THROW_NOT_OK(out->Write(out_buffer, out_length));
-      return static_cast<int64_t>(out_length);
+      const std::shared_ptr<Encryptor>& Encryptor = NULLPTR) {
+    uint8_t* outBuffer;
+    uint32_t outLength;
+    serializeToBuffer(obj, &outLength, &outBuffer);
+
+    // Obj is not encrypted.
+    if (Encryptor == NULLPTR) {
+      PARQUET_THROW_NOT_OK(out->Write(outBuffer, outLength));
+      return static_cast<int64_t>(outLength);
     } else { // obj is encrypted
-      return SerializeEncryptedObj(out, out_buffer, out_length, encryptor);
+      return serializeEncryptedObj(out, outBuffer, outLength, Encryptor);
     }
   }
 
  private:
   template <class T>
-  void SerializeObject(const T* obj) {
+  void serializeObject(const T* obj) {
     try {
-      mem_buffer_->resetBuffer();
+      memBuffer_->resetBuffer();
       obj->write(protocol_.get());
     } catch (std::exception& e) {
       std::stringstream ss;
@@ -577,24 +578,24 @@ class ThriftSerializer {
     }
   }
 
-  int64_t SerializeEncryptedObj(
+  int64_t serializeEncryptedObj(
       ArrowOutputStream* out,
-      uint8_t* out_buffer,
-      uint32_t out_length,
-      const std::shared_ptr<Encryptor>& encryptor) {
-    auto cipher_buffer =
-        std::static_pointer_cast<ResizableBuffer>(AllocateBuffer(
-            encryptor->pool(),
+      uint8_t* outBuffer,
+      uint32_t outLength,
+      const std::shared_ptr<Encryptor>& Encryptor) {
+    auto cipherBuffer =
+        std::static_pointer_cast<ResizableBuffer>(allocateBuffer(
+            Encryptor->pool(),
             static_cast<int64_t>(
-                encryptor->CiphertextSizeDelta() + out_length)));
-    int cipher_buffer_len = encryptor->Encrypt(
-        out_buffer, out_length, cipher_buffer->mutable_data());
+                Encryptor->ciphertextSizeDelta() + outLength)));
+    int cipherBufferLen =
+        Encryptor->encrypt(outBuffer, outLength, cipherBuffer->mutable_data());
 
-    PARQUET_THROW_NOT_OK(out->Write(cipher_buffer->data(), cipher_buffer_len));
-    return static_cast<int64_t>(cipher_buffer_len);
+    PARQUET_THROW_NOT_OK(out->Write(cipherBuffer->data(), cipherBufferLen));
+    return static_cast<int64_t>(cipherBufferLen);
   }
 
-  std::shared_ptr<ThriftBuffer> mem_buffer_;
+  std::shared_ptr<ThriftBuffer> memBuffer_;
   std::shared_ptr<apache::thrift::protocol::TProtocol> protocol_;
 };
 
diff --git a/velox/dwio/parquet/writer/arrow/Types.cpp b/velox/dwio/parquet/writer/arrow/Types.cpp
index 929f664f309..4dc5f465883 100644
--- a/velox/dwio/parquet/writer/arrow/Types.cpp
+++ b/velox/dwio/parquet/writer/arrow/Types.cpp
@@ -32,12 +32,12 @@ using arrow::internal::checked_cast;
 
 namespace facebook::velox::parquet::arrow {
 
-fmt::underlying_t<LogicalType::TimeUnit::unit> format_as(
-    LogicalType::TimeUnit::unit unit) {
+fmt::underlying_t<LogicalType::TimeUnit::Unit> formatAs(
+    LogicalType::TimeUnit::Unit unit) {
   return fmt::underlying(unit);
 }
 
-bool IsCodecSupported(Compression::type codec) {
+bool isCodecSupported(Compression::type codec) {
   switch (codec) {
     case Compression::UNCOMPRESSED:
     case Compression::SNAPPY:
@@ -52,13 +52,13 @@ bool IsCodecSupported(Compression::type codec) {
   }
 }
 
-std::unique_ptr<util::Codec> GetCodec(Compression::type codec) {
-  return GetCodec(codec, util::CodecOptions());
+std::unique_ptr<util::Codec> getCodec(Compression::type codec) {
+  return getCodec(codec, util::CodecOptions());
 }
 
-std::unique_ptr<util::Codec> GetCodec(
+std::unique_ptr<util::Codec> getCodec(
     Compression::type codec,
-    const util::CodecOptions& codec_options) {
+    const util::CodecOptions& codecOptions) {
   std::unique_ptr<util::Codec> result;
   if (codec == Compression::LZO) {
     throw ParquetException(
@@ -66,479 +66,473 @@ std::unique_ptr<util::Codec> GetCodec(
         "general, it is currently not supported by the C++ implementation.");
   }
 
-  if (!IsCodecSupported(codec)) {
+  if (!isCodecSupported(codec)) {
     std::stringstream ss;
-    ss << "Codec type " << util::Codec::GetCodecAsString(codec)
+    ss << "Codec type " << util::Codec::getCodecAsString(codec)
        << " not supported in Parquet format";
     throw ParquetException(ss.str());
   }
 
-  PARQUET_ASSIGN_OR_THROW(result, util::Codec::Create(codec, codec_options));
+  PARQUET_ASSIGN_OR_THROW(result, util::Codec::create(codec, codecOptions));
   return result;
 }
 
-// use compression level to create Codec
-std::unique_ptr<util::Codec> GetCodec(
+// Use compression level to create Codec.
+std::unique_ptr<util::Codec> getCodec(
     Compression::type codec,
-    int compression_level) {
-  return GetCodec(codec, util::CodecOptions{compression_level});
+    int compressionLevel) {
+  return getCodec(codec, util::CodecOptions{compressionLevel});
 }
 
-bool PageCanUseChecksum(PageType::type pageType) {
+bool pageCanUseChecksum(PageType::type pageType) {
   switch (pageType) {
-    case PageType::type::DATA_PAGE:
-    case PageType::type::DATA_PAGE_V2:
-    case PageType::type::DICTIONARY_PAGE:
+    case PageType::type::kDataPage:
+    case PageType::type::kDataPageV2:
+    case PageType::type::kDictionaryPage:
       return true;
     default:
       return false;
   }
 }
 
-std::string FormatStatValue(Type::type parquet_type, ::std::string_view val) {
+std::string formatStatValue(Type::type parquetType, ::std::string_view val) {
   std::stringstream result;
 
   const char* bytes = val.data();
-  switch (parquet_type) {
-    case Type::BOOLEAN:
+  switch (parquetType) {
+    case Type::kBoolean:
       result << reinterpret_cast<const bool*>(bytes)[0];
       break;
-    case Type::INT32:
+    case Type::kInt32:
       result << reinterpret_cast<const int32_t*>(bytes)[0];
       break;
-    case Type::INT64:
+    case Type::kInt64:
       result << reinterpret_cast<const int64_t*>(bytes)[0];
       break;
-    case Type::DOUBLE:
+    case Type::kDouble:
       result << reinterpret_cast<const double*>(bytes)[0];
       break;
-    case Type::FLOAT:
+    case Type::kFloat:
       result << reinterpret_cast<const float*>(bytes)[0];
       break;
-    case Type::INT96: {
-      auto const i32_val = reinterpret_cast<const int32_t*>(bytes);
-      result << i32_val[0] << " " << i32_val[1] << " " << i32_val[2];
+    case Type::kInt96: {
+      auto const i32Val = reinterpret_cast<const int32_t*>(bytes);
+      result << i32Val[0] << " " << i32Val[1] << " " << i32Val[2];
       break;
     }
-    case Type::BYTE_ARRAY: {
+    case Type::kByteArray: {
       return std::string(val);
     }
-    case Type::FIXED_LEN_BYTE_ARRAY: {
+    case Type::kFixedLenByteArray: {
       return std::string(val);
     }
-    case Type::UNDEFINED:
+    case Type::kUndefined:
     default:
       break;
   }
   return result.str();
 }
 
-std::string EncodingToString(Encoding::type t) {
+std::string encodingToString(Encoding::type t) {
   switch (t) {
-    case Encoding::PLAIN:
+    case Encoding::kPlain:
       return "PLAIN";
-    case Encoding::PLAIN_DICTIONARY:
+    case Encoding::kPlainDictionary:
       return "PLAIN_DICTIONARY";
-    case Encoding::RLE:
+    case Encoding::kRle:
       return "RLE";
-    case Encoding::BIT_PACKED:
+    case Encoding::kBitPacked:
       return "BIT_PACKED";
-    case Encoding::DELTA_BINARY_PACKED:
+    case Encoding::kDeltaBinaryPacked:
       return "DELTA_BINARY_PACKED";
-    case Encoding::DELTA_LENGTH_BYTE_ARRAY:
+    case Encoding::kDeltaLengthByteArray:
       return "DELTA_LENGTH_BYTE_ARRAY";
-    case Encoding::DELTA_BYTE_ARRAY:
+    case Encoding::kDeltaByteArray:
       return "DELTA_BYTE_ARRAY";
-    case Encoding::RLE_DICTIONARY:
+    case Encoding::kRleDictionary:
       return "RLE_DICTIONARY";
-    case Encoding::BYTE_STREAM_SPLIT:
+    case Encoding::kByteStreamSplit:
       return "BYTE_STREAM_SPLIT";
     default:
       return "UNKNOWN";
   }
 }
 
-std::string TypeToString(Type::type t) {
+std::string typeToString(Type::type t) {
   switch (t) {
-    case Type::BOOLEAN:
+    case Type::kBoolean:
       return "BOOLEAN";
-    case Type::INT32:
+    case Type::kInt32:
       return "INT32";
-    case Type::INT64:
+    case Type::kInt64:
       return "INT64";
-    case Type::INT96:
+    case Type::kInt96:
       return "INT96";
-    case Type::FLOAT:
+    case Type::kFloat:
       return "FLOAT";
-    case Type::DOUBLE:
+    case Type::kDouble:
       return "DOUBLE";
-    case Type::BYTE_ARRAY:
+    case Type::kByteArray:
       return "BYTE_ARRAY";
-    case Type::FIXED_LEN_BYTE_ARRAY:
+    case Type::kFixedLenByteArray:
       return "FIXED_LEN_BYTE_ARRAY";
-    case Type::UNDEFINED:
+    case Type::kUndefined:
     default:
       return "UNKNOWN";
   }
 }
 
-std::string ConvertedTypeToString(ConvertedType::type t) {
+std::string convertedTypeToString(ConvertedType::type t) {
   switch (t) {
-    case ConvertedType::NONE:
+    case ConvertedType::kNone:
       return "NONE";
-    case ConvertedType::UTF8:
+    case ConvertedType::kUtf8:
       return "UTF8";
-    case ConvertedType::MAP:
+    case ConvertedType::kMap:
       return "MAP";
-    case ConvertedType::MAP_KEY_VALUE:
+    case ConvertedType::kMapKeyValue:
       return "MAP_KEY_VALUE";
-    case ConvertedType::LIST:
+    case ConvertedType::kList:
       return "LIST";
-    case ConvertedType::ENUM:
+    case ConvertedType::kEnum:
       return "ENUM";
-    case ConvertedType::DECIMAL:
+    case ConvertedType::kDecimal:
       return "DECIMAL";
-    case ConvertedType::DATE:
+    case ConvertedType::kDate:
       return "DATE";
-    case ConvertedType::TIME_MILLIS:
+    case ConvertedType::kTimeMillis:
       return "TIME_MILLIS";
-    case ConvertedType::TIME_MICROS:
+    case ConvertedType::kTimeMicros:
       return "TIME_MICROS";
-    case ConvertedType::TIMESTAMP_MILLIS:
+    case ConvertedType::kTimestampMillis:
       return "TIMESTAMP_MILLIS";
-    case ConvertedType::TIMESTAMP_MICROS:
+    case ConvertedType::kTimestampMicros:
       return "TIMESTAMP_MICROS";
-    case ConvertedType::UINT_8:
+    case ConvertedType::kUint8:
       return "UINT_8";
-    case ConvertedType::UINT_16:
+    case ConvertedType::kUint16:
       return "UINT_16";
-    case ConvertedType::UINT_32:
+    case ConvertedType::kUint32:
       return "UINT_32";
-    case ConvertedType::UINT_64:
+    case ConvertedType::kUint64:
       return "UINT_64";
-    case ConvertedType::INT_8:
+    case ConvertedType::kInt8:
       return "INT_8";
-    case ConvertedType::INT_16:
+    case ConvertedType::kInt16:
       return "INT_16";
-    case ConvertedType::INT_32:
+    case ConvertedType::kInt32:
       return "INT_32";
-    case ConvertedType::INT_64:
+    case ConvertedType::kInt64:
       return "INT_64";
-    case ConvertedType::JSON:
+    case ConvertedType::kJson:
       return "JSON";
-    case ConvertedType::BSON:
+    case ConvertedType::kBson:
       return "BSON";
-    case ConvertedType::INTERVAL:
+    case ConvertedType::kInterval:
       return "INTERVAL";
-    case ConvertedType::UNDEFINED:
+    case ConvertedType::kUndefined:
     default:
       return "UNKNOWN";
   }
 }
 
-int GetTypeByteSize(Type::type parquet_type) {
-  switch (parquet_type) {
-    case Type::BOOLEAN:
-      return type_traits<BooleanType::type_num>::value_byte_size;
-    case Type::INT32:
-      return type_traits<Int32Type::type_num>::value_byte_size;
-    case Type::INT64:
-      return type_traits<Int64Type::type_num>::value_byte_size;
-    case Type::INT96:
-      return type_traits<Int96Type::type_num>::value_byte_size;
-    case Type::DOUBLE:
-      return type_traits<DoubleType::type_num>::value_byte_size;
-    case Type::FLOAT:
-      return type_traits<FloatType::type_num>::value_byte_size;
-    case Type::BYTE_ARRAY:
-      return type_traits<ByteArrayType::type_num>::value_byte_size;
-    case Type::FIXED_LEN_BYTE_ARRAY:
-      return type_traits<FLBAType::type_num>::value_byte_size;
-    case Type::UNDEFINED:
+int getTypeByteSize(Type::type parquetType) {
+  switch (parquetType) {
+    case Type::kBoolean:
+      return TypeTraits<BooleanType::typeNum>::valueByteSize;
+    case Type::kInt32:
+      return TypeTraits<Int32Type::typeNum>::valueByteSize;
+    case Type::kInt64:
+      return TypeTraits<Int64Type::typeNum>::valueByteSize;
+    case Type::kInt96:
+      return TypeTraits<Int96Type::typeNum>::valueByteSize;
+    case Type::kDouble:
+      return TypeTraits<DoubleType::typeNum>::valueByteSize;
+    case Type::kFloat:
+      return TypeTraits<FloatType::typeNum>::valueByteSize;
+    case Type::kByteArray:
+      return TypeTraits<ByteArrayType::typeNum>::valueByteSize;
+    case Type::kFixedLenByteArray:
+      return TypeTraits<FLBAType::typeNum>::valueByteSize;
+    case Type::kUndefined:
     default:
       return 0;
   }
   return 0;
 }
 
-// Return the Sort Order of the Parquet Physical Types
-SortOrder::type DefaultSortOrder(Type::type primitive) {
+// Return the Sort Order of the Parquet Physical Types.
+SortOrder::type defaultSortOrder(Type::type primitive) {
   switch (primitive) {
-    case Type::BOOLEAN:
-    case Type::INT32:
-    case Type::INT64:
-    case Type::FLOAT:
-    case Type::DOUBLE:
-      return SortOrder::SIGNED;
-    case Type::BYTE_ARRAY:
-    case Type::FIXED_LEN_BYTE_ARRAY:
-      return SortOrder::UNSIGNED;
-    case Type::INT96:
-    case Type::UNDEFINED:
-      return SortOrder::UNKNOWN;
+    case Type::kBoolean:
+    case Type::kInt32:
+    case Type::kInt64:
+    case Type::kFloat:
+    case Type::kDouble:
+      return SortOrder::kSigned;
+    case Type::kByteArray:
+    case Type::kFixedLenByteArray:
+      return SortOrder::kUnsigned;
+    case Type::kInt96:
+    case Type::kUndefined:
+      return SortOrder::kUnknown;
   }
-  return SortOrder::UNKNOWN;
+  return SortOrder::kUnknown;
 }
 
-// Return the SortOrder of the Parquet Types using Logical or Physical Types
-SortOrder::type GetSortOrder(
+// Return the SortOrder of the Parquet Types using Logical or Physical Types.
+SortOrder::type getSortOrder(
     ConvertedType::type converted,
     Type::type primitive) {
-  if (converted == ConvertedType::NONE)
-    return DefaultSortOrder(primitive);
+  if (converted == ConvertedType::kNone)
+    return defaultSortOrder(primitive);
   switch (converted) {
-    case ConvertedType::INT_8:
-    case ConvertedType::INT_16:
-    case ConvertedType::INT_32:
-    case ConvertedType::INT_64:
-    case ConvertedType::DATE:
-    case ConvertedType::TIME_MICROS:
-    case ConvertedType::TIME_MILLIS:
-    case ConvertedType::TIMESTAMP_MICROS:
-    case ConvertedType::TIMESTAMP_MILLIS:
-      return SortOrder::SIGNED;
-    case ConvertedType::UINT_8:
-    case ConvertedType::UINT_16:
-    case ConvertedType::UINT_32:
-    case ConvertedType::UINT_64:
-    case ConvertedType::ENUM:
-    case ConvertedType::UTF8:
-    case ConvertedType::BSON:
-    case ConvertedType::JSON:
-      return SortOrder::UNSIGNED;
-    case ConvertedType::DECIMAL:
-    case ConvertedType::LIST:
-    case ConvertedType::MAP:
-    case ConvertedType::MAP_KEY_VALUE:
-    case ConvertedType::INTERVAL:
-    case ConvertedType::NONE: // required instead of default
-    case ConvertedType::NA: // required instead of default
-    case ConvertedType::UNDEFINED:
-      return SortOrder::UNKNOWN;
+    case ConvertedType::kInt8:
+    case ConvertedType::kInt16:
+    case ConvertedType::kInt32:
+    case ConvertedType::kInt64:
+    case ConvertedType::kDate:
+    case ConvertedType::kTimeMicros:
+    case ConvertedType::kTimeMillis:
+    case ConvertedType::kTimestampMicros:
+    case ConvertedType::kTimestampMillis:
+      return SortOrder::kSigned;
+    case ConvertedType::kUint8:
+    case ConvertedType::kUint16:
+    case ConvertedType::kUint32:
+    case ConvertedType::kUint64:
+    case ConvertedType::kEnum:
+    case ConvertedType::kUtf8:
+    case ConvertedType::kBson:
+    case ConvertedType::kJson:
+      return SortOrder::kUnsigned;
+    case ConvertedType::kDecimal:
+    case ConvertedType::kList:
+    case ConvertedType::kMap:
+    case ConvertedType::kMapKeyValue:
+    case ConvertedType::kInterval:
+    case ConvertedType::kNone: // required instead of default
+    case ConvertedType::kNa: // required instead of default
+    case ConvertedType::kUndefined:
+      return SortOrder::kUnknown;
   }
-  return SortOrder::UNKNOWN;
+  return SortOrder::kUnknown;
 }
 
-SortOrder::type GetSortOrder(
-    const std::shared_ptr<const LogicalType>& logical_type,
+SortOrder::type getSortOrder(
+    const std::shared_ptr<const LogicalType>& logicalType,
     Type::type primitive) {
-  SortOrder::type o = SortOrder::UNKNOWN;
-  if (logical_type && logical_type->is_valid()) {
+  SortOrder::type o = SortOrder::kUnknown;
+  if (logicalType && logicalType->isValid()) {
     o =
-        (logical_type->is_none() ? DefaultSortOrder(primitive)
-                                 : logical_type->sort_order());
+        (logicalType->isNone() ? defaultSortOrder(primitive)
+                               : logicalType->sortOrder());
   }
   return o;
 }
 
-ColumnOrder ColumnOrder::undefined_ = ColumnOrder(ColumnOrder::UNDEFINED);
-ColumnOrder ColumnOrder::type_defined_ =
-    ColumnOrder(ColumnOrder::TYPE_DEFINED_ORDER);
-
-// Static methods for LogicalType class
-
-std::shared_ptr<const LogicalType> LogicalType::FromConvertedType(
-    const ConvertedType::type converted_type,
-    const schema::DecimalMetadata converted_decimal_metadata) {
-  switch (converted_type) {
-    case ConvertedType::UTF8:
-      return StringLogicalType::Make();
-    case ConvertedType::MAP_KEY_VALUE:
-    case ConvertedType::MAP:
-      return MapLogicalType::Make();
-    case ConvertedType::LIST:
-      return ListLogicalType::Make();
-    case ConvertedType::ENUM:
-      return EnumLogicalType::Make();
-    case ConvertedType::DECIMAL:
-      return DecimalLogicalType::Make(
-          converted_decimal_metadata.precision,
-          converted_decimal_metadata.scale);
-    case ConvertedType::DATE:
-      return DateLogicalType::Make();
-    case ConvertedType::TIME_MILLIS:
-      return TimeLogicalType::Make(true, LogicalType::TimeUnit::MILLIS);
-    case ConvertedType::TIME_MICROS:
-      return TimeLogicalType::Make(true, LogicalType::TimeUnit::MICROS);
-    case ConvertedType::TIMESTAMP_MILLIS:
-      return TimestampLogicalType::Make(
-          true,
-          LogicalType::TimeUnit::MILLIS,
-          /*is_from_converted_type=*/true,
-          /*force_set_converted_type=*/false);
-    case ConvertedType::TIMESTAMP_MICROS:
-      return TimestampLogicalType::Make(
-          true,
-          LogicalType::TimeUnit::MICROS,
-          /*is_from_converted_type=*/true,
-          /*force_set_converted_type=*/false);
-    case ConvertedType::INTERVAL:
-      return IntervalLogicalType::Make();
-    case ConvertedType::INT_8:
-      return IntLogicalType::Make(8, true);
-    case ConvertedType::INT_16:
-      return IntLogicalType::Make(16, true);
-    case ConvertedType::INT_32:
-      return IntLogicalType::Make(32, true);
-    case ConvertedType::INT_64:
-      return IntLogicalType::Make(64, true);
-    case ConvertedType::UINT_8:
-      return IntLogicalType::Make(8, false);
-    case ConvertedType::UINT_16:
-      return IntLogicalType::Make(16, false);
-    case ConvertedType::UINT_32:
-      return IntLogicalType::Make(32, false);
-    case ConvertedType::UINT_64:
-      return IntLogicalType::Make(64, false);
-    case ConvertedType::JSON:
-      return JSONLogicalType::Make();
-    case ConvertedType::BSON:
-      return BSONLogicalType::Make();
-    case ConvertedType::NA:
-      return NullLogicalType::Make();
-    case ConvertedType::NONE:
-      return NoLogicalType::Make();
-    case ConvertedType::UNDEFINED:
-      return UndefinedLogicalType::Make();
+ColumnOrder ColumnOrder::undefined_ = ColumnOrder(ColumnOrder::kUndefined);
+ColumnOrder ColumnOrder::typeDefined_ =
+    ColumnOrder(ColumnOrder::kTypeDefinedOrder);
+
+// Static methods for LogicalType class.
+
+std::shared_ptr<const LogicalType> LogicalType::fromConvertedType(
+    const ConvertedType::type convertedType,
+    const schema::DecimalMetadata convertedDecimalMetadata) {
+  switch (convertedType) {
+    case ConvertedType::kUtf8:
+      return StringLogicalType::make();
+    case ConvertedType::kMapKeyValue:
+    case ConvertedType::kMap:
+      return MapLogicalType::make();
+    case ConvertedType::kList:
+      return ListLogicalType::make();
+    case ConvertedType::kEnum:
+      return EnumLogicalType::make();
+    case ConvertedType::kDecimal:
+      return DecimalLogicalType::make(
+          convertedDecimalMetadata.precision, convertedDecimalMetadata.scale);
+    case ConvertedType::kDate:
+      return DateLogicalType::make();
+    case ConvertedType::kTimeMillis:
+      return TimeLogicalType::make(true, LogicalType::TimeUnit::kMillis);
+    case ConvertedType::kTimeMicros:
+      return TimeLogicalType::make(true, LogicalType::TimeUnit::kMicros);
+    case ConvertedType::kTimestampMillis:
+      return TimestampLogicalType::make(
+          true, LogicalType::TimeUnit::kMillis, true, false);
+    case ConvertedType::kTimestampMicros:
+      return TimestampLogicalType::make(
+          true, LogicalType::TimeUnit::kMicros, true, false);
+    case ConvertedType::kInterval:
+      return IntervalLogicalType::make();
+    case ConvertedType::kInt8:
+      return IntLogicalType::make(8, true);
+    case ConvertedType::kInt16:
+      return IntLogicalType::make(16, true);
+    case ConvertedType::kInt32:
+      return IntLogicalType::make(32, true);
+    case ConvertedType::kInt64:
+      return IntLogicalType::make(64, true);
+    case ConvertedType::kUint8:
+      return IntLogicalType::make(8, false);
+    case ConvertedType::kUint16:
+      return IntLogicalType::make(16, false);
+    case ConvertedType::kUint32:
+      return IntLogicalType::make(32, false);
+    case ConvertedType::kUint64:
+      return IntLogicalType::make(64, false);
+    case ConvertedType::kJson:
+      return JsonLogicalType::make();
+    case ConvertedType::kBson:
+      return BsonLogicalType::make();
+    case ConvertedType::kNa:
+      return NullLogicalType::make();
+    case ConvertedType::kNone:
+      return NoLogicalType::make();
+    case ConvertedType::kUndefined:
+      return UndefinedLogicalType::make();
   }
-  return UndefinedLogicalType::Make();
+  return UndefinedLogicalType::make();
 }
 
-std::shared_ptr<const LogicalType> LogicalType::FromThrift(
+std::shared_ptr<const LogicalType> LogicalType::fromThrift(
     const facebook::velox::parquet::thrift::LogicalType& type) {
   if (type.__isset.STRING) {
-    return StringLogicalType::Make();
+    return StringLogicalType::make();
   } else if (type.__isset.MAP) {
-    return MapLogicalType::Make();
+    return MapLogicalType::make();
   } else if (type.__isset.LIST) {
-    return ListLogicalType::Make();
+    return ListLogicalType::make();
   } else if (type.__isset.ENUM) {
-    return EnumLogicalType::Make();
+    return EnumLogicalType::make();
   } else if (type.__isset.DECIMAL) {
-    return DecimalLogicalType::Make(type.DECIMAL.precision, type.DECIMAL.scale);
+    return DecimalLogicalType::make(type.DECIMAL.precision, type.DECIMAL.scale);
   } else if (type.__isset.DATE) {
-    return DateLogicalType::Make();
+    return DateLogicalType::make();
   } else if (type.__isset.TIME) {
-    LogicalType::TimeUnit::unit unit;
+    LogicalType::TimeUnit::Unit unit;
     if (type.TIME.unit.__isset.MILLIS) {
-      unit = LogicalType::TimeUnit::MILLIS;
+      unit = LogicalType::TimeUnit::kMillis;
     } else if (type.TIME.unit.__isset.MICROS) {
-      unit = LogicalType::TimeUnit::MICROS;
+      unit = LogicalType::TimeUnit::kMicros;
     } else if (type.TIME.unit.__isset.NANOS) {
-      unit = LogicalType::TimeUnit::NANOS;
+      unit = LogicalType::TimeUnit::kNanos;
     } else {
-      unit = LogicalType::TimeUnit::UNKNOWN;
+      unit = LogicalType::TimeUnit::kUnknown;
     }
-    return TimeLogicalType::Make(type.TIME.isAdjustedToUTC, unit);
+    return TimeLogicalType::make(type.TIME.isAdjustedToUTC, unit);
   } else if (type.__isset.TIMESTAMP) {
-    LogicalType::TimeUnit::unit unit;
+    LogicalType::TimeUnit::Unit unit;
     if (type.TIMESTAMP.unit.__isset.MILLIS) {
-      unit = LogicalType::TimeUnit::MILLIS;
+      unit = LogicalType::TimeUnit::kMillis;
     } else if (type.TIMESTAMP.unit.__isset.MICROS) {
-      unit = LogicalType::TimeUnit::MICROS;
+      unit = LogicalType::TimeUnit::kMicros;
     } else if (type.TIMESTAMP.unit.__isset.NANOS) {
-      unit = LogicalType::TimeUnit::NANOS;
+      unit = LogicalType::TimeUnit::kNanos;
     } else {
-      unit = LogicalType::TimeUnit::UNKNOWN;
+      unit = LogicalType::TimeUnit::kUnknown;
     }
-    return TimestampLogicalType::Make(type.TIMESTAMP.isAdjustedToUTC, unit);
+    return TimestampLogicalType::make(type.TIMESTAMP.isAdjustedToUTC, unit);
     // TODO(tpboudreau): activate the commented code after parquet.thrift
-    // recognizes IntervalType as a LogicalType
-    //} else if (type.__isset.INTERVAL) {
-    //  return IntervalLogicalType::Make();
+    // recognizes IntervalType as a LogicalType.
+    // } else if (type.__isset.INTERVAL) {
+    //   return IntervalLogicalType::make();
   } else if (type.__isset.INTEGER) {
-    return IntLogicalType::Make(
+    return IntLogicalType::make(
         static_cast<int>(type.INTEGER.bitWidth), type.INTEGER.isSigned);
   } else if (type.__isset.UNKNOWN) {
-    return NullLogicalType::Make();
+    return NullLogicalType::make();
   } else if (type.__isset.JSON) {
-    return JSONLogicalType::Make();
+    return JsonLogicalType::make();
   } else if (type.__isset.BSON) {
-    return BSONLogicalType::Make();
+    return BsonLogicalType::make();
   } else if (type.__isset.UUID) {
-    return UUIDLogicalType::Make();
+    return UuidLogicalType::make();
   } else {
     throw ParquetException(
         "Metadata contains Thrift LogicalType that is not recognized");
   }
 }
 
-std::shared_ptr<const LogicalType> LogicalType::String() {
-  return StringLogicalType::Make();
+std::shared_ptr<const LogicalType> LogicalType::string() {
+  return StringLogicalType::make();
 }
 
-std::shared_ptr<const LogicalType> LogicalType::Map() {
-  return MapLogicalType::Make();
+std::shared_ptr<const LogicalType> LogicalType::map() {
+  return MapLogicalType::make();
 }
 
-std::shared_ptr<const LogicalType> LogicalType::List() {
-  return ListLogicalType::Make();
+std::shared_ptr<const LogicalType> LogicalType::list() {
+  return ListLogicalType::make();
 }
 
-std::shared_ptr<const LogicalType> LogicalType::Enum() {
-  return EnumLogicalType::Make();
+std::shared_ptr<const LogicalType> LogicalType::enumType() {
+  return EnumLogicalType::make();
 }
 
-std::shared_ptr<const LogicalType> LogicalType::Decimal(
+std::shared_ptr<const LogicalType> LogicalType::decimal(
     int32_t precision,
     int32_t scale) {
-  return DecimalLogicalType::Make(precision, scale);
+  return DecimalLogicalType::make(precision, scale);
 }
 
-std::shared_ptr<const LogicalType> LogicalType::Date() {
-  return DateLogicalType::Make();
+std::shared_ptr<const LogicalType> LogicalType::date() {
+  return DateLogicalType::make();
 }
 
-std::shared_ptr<const LogicalType> LogicalType::Time(
-    bool is_adjusted_to_utc,
-    LogicalType::TimeUnit::unit time_unit) {
-  VELOX_DCHECK_NE(time_unit, LogicalType::TimeUnit::UNKNOWN);
-  return TimeLogicalType::Make(is_adjusted_to_utc, time_unit);
+std::shared_ptr<const LogicalType> LogicalType::time(
+    bool isAdjustedToUtc,
+    LogicalType::TimeUnit::Unit timeUnit) {
+  VELOX_DCHECK_NE(
+      static_cast<int>(timeUnit),
+      static_cast<int>(LogicalType::TimeUnit::kUnknown));
+  return TimeLogicalType::make(isAdjustedToUtc, timeUnit);
 }
 
-std::shared_ptr<const LogicalType> LogicalType::Timestamp(
-    bool is_adjusted_to_utc,
-    LogicalType::TimeUnit::unit time_unit,
-    bool is_from_converted_type,
-    bool force_set_converted_type) {
-  VELOX_DCHECK_NE(time_unit, LogicalType::TimeUnit::UNKNOWN);
-  return TimestampLogicalType::Make(
-      is_adjusted_to_utc,
-      time_unit,
-      is_from_converted_type,
-      force_set_converted_type);
+std::shared_ptr<const LogicalType> LogicalType::timestamp(
+    bool isAdjustedToUtc,
+    LogicalType::TimeUnit::Unit timeUnit,
+    bool isFromConvertedType,
+    bool forceSetConvertedType) {
+  VELOX_DCHECK_NE(
+      static_cast<int>(timeUnit),
+      static_cast<int>(LogicalType::TimeUnit::kUnknown));
+  return TimestampLogicalType::make(
+      isAdjustedToUtc, timeUnit, isFromConvertedType, forceSetConvertedType);
 }
 
-std::shared_ptr<const LogicalType> LogicalType::Interval() {
-  return IntervalLogicalType::Make();
+std::shared_ptr<const LogicalType> LogicalType::interval() {
+  return IntervalLogicalType::make();
 }
 
-std::shared_ptr<const LogicalType> LogicalType::Int(
-    int bit_width,
-    bool is_signed) {
+std::shared_ptr<const LogicalType> LogicalType::intType(
+    int bitWidth,
+    bool isSigned) {
   VELOX_DCHECK(
-      bit_width == 64 || bit_width == 32 || bit_width == 16 || bit_width == 8);
-  return IntLogicalType::Make(bit_width, is_signed);
+      bitWidth == 64 || bitWidth == 32 || bitWidth == 16 || bitWidth == 8);
+  return IntLogicalType::make(bitWidth, isSigned);
 }
 
-std::shared_ptr<const LogicalType> LogicalType::Null() {
-  return NullLogicalType::Make();
+std::shared_ptr<const LogicalType> LogicalType::nullType() {
+  return NullLogicalType::make();
 }
 
-std::shared_ptr<const LogicalType> LogicalType::JSON() {
-  return JSONLogicalType::Make();
+std::shared_ptr<const LogicalType> LogicalType::json() {
+  return JsonLogicalType::make();
 }
 
-std::shared_ptr<const LogicalType> LogicalType::BSON() {
-  return BSONLogicalType::Make();
+std::shared_ptr<const LogicalType> LogicalType::bson() {
+  return BsonLogicalType::make();
 }
 
-std::shared_ptr<const LogicalType> LogicalType::UUID() {
-  return UUIDLogicalType::Make();
+std::shared_ptr<const LogicalType> LogicalType::uuid() {
+  return UuidLogicalType::make();
 }
 
-std::shared_ptr<const LogicalType> LogicalType::None() {
-  return NoLogicalType::Make();
+std::shared_ptr<const LogicalType> LogicalType::none() {
+  return NoLogicalType::make();
 }
 
 /*
@@ -554,44 +548,44 @@ std::shared_ptr<const LogicalType> LogicalType::None() {
  * overridden.
  */
 
-// LogicalTypeImpl base class
+// LogicalTypeImpl base class.
 
 class LogicalType::Impl {
  public:
-  virtual bool is_applicable(
-      parquet::Type::type primitive_type,
-      int32_t primitive_length = -1) const = 0;
+  virtual bool isApplicable(
+      parquet::Type::type primitiveType,
+      int32_t primitiveLength = -1) const = 0;
 
-  virtual bool is_compatible(
-      ConvertedType::type converted_type,
-      schema::DecimalMetadata converted_decimal_metadata = {false, -1, -1})
+  virtual bool isCompatible(
+      ConvertedType::type convertedType,
+      schema::DecimalMetadata convertedDecimalMetadata = {false, -1, -1})
       const = 0;
 
-  virtual ConvertedType::type ToConvertedType(
-      schema::DecimalMetadata* out_decimal_metadata) const = 0;
+  virtual ConvertedType::type toConvertedType(
+      schema::DecimalMetadata* outDecimalMetadata) const = 0;
 
-  virtual std::string ToString() const = 0;
+  virtual std::string toString() const = 0;
 
-  virtual bool is_serialized() const {
+  virtual bool isSerialized() const {
     return !(
-        type_ == LogicalType::Type::NONE ||
-        type_ == LogicalType::Type::UNDEFINED);
+        type_ == LogicalType::Type::kNone ||
+        type_ == LogicalType::Type::kUndefined);
   }
 
-  virtual std::string ToJSON() const {
+  virtual std::string toJson() const {
     std::stringstream json;
-    json << R"({"Type": ")" << ToString() << R"("})";
+    json << R"({"Type": ")" << toString() << R"("})";
     return json.str();
   }
 
-  virtual facebook::velox::parquet::thrift::LogicalType ToThrift() const {
-    // logical types inheriting this method should never be serialized
+  virtual facebook::velox::parquet::thrift::LogicalType toThrift() const {
+    // Logical types inheriting this method should never be serialized.
     std::stringstream ss;
-    ss << "Logical type " << ToString() << " should not be serialized";
+    ss << "Logical type " << toString() << " should not be serialized";
     throw ParquetException(ss.str());
   }
 
-  virtual bool Equals(const LogicalType& other) const {
+  virtual bool equals(const LogicalType& other) const {
     return other.type() == type_;
   }
 
@@ -599,7 +593,7 @@ class LogicalType::Impl {
     return type_;
   }
 
-  SortOrder::type sort_order() const {
+  SortOrder::type sortOrder() const {
     return order_;
   }
 
@@ -628,9 +622,9 @@ class LogicalType::Impl {
   class Interval;
   class Int;
   class Null;
-  class JSON;
-  class BSON;
-  class UUID;
+  class Json;
+  class Bson;
+  class Uuid;
   class No;
   class Undefined;
 
@@ -639,202 +633,203 @@ class LogicalType::Impl {
   Impl() = default;
 
  private:
-  LogicalType::Type::type type_ = LogicalType::Type::UNDEFINED;
-  SortOrder::type order_ = SortOrder::UNKNOWN;
+  LogicalType::Type::type type_ = LogicalType::Type::kUndefined;
+  SortOrder::type order_ = SortOrder::kUnknown;
 };
 
-// Special methods for public LogicalType class
+// Special methods for public LogicalType class.
 
 LogicalType::LogicalType() = default;
 LogicalType::~LogicalType() noexcept = default;
 
-// Delegating methods for public LogicalType class
+// Delegating methods for public LogicalType class.
 
-bool LogicalType::is_applicable(
-    parquet::Type::type primitive_type,
-    int32_t primitive_length) const {
-  return impl_->is_applicable(primitive_type, primitive_length);
+bool LogicalType::isApplicable(
+    parquet::Type::type primitiveType,
+    int32_t primitiveLength) const {
+  return impl_->isApplicable(primitiveType, primitiveLength);
 }
 
-bool LogicalType::is_compatible(
-    ConvertedType::type converted_type,
-    schema::DecimalMetadata converted_decimal_metadata) const {
-  return impl_->is_compatible(converted_type, converted_decimal_metadata);
+bool LogicalType::isCompatible(
+    ConvertedType::type convertedType,
+    schema::DecimalMetadata convertedDecimalMetadata) const {
+  return impl_->isCompatible(convertedType, convertedDecimalMetadata);
 }
 
-ConvertedType::type LogicalType::ToConvertedType(
-    schema::DecimalMetadata* out_decimal_metadata) const {
-  return impl_->ToConvertedType(out_decimal_metadata);
+ConvertedType::type LogicalType::toConvertedType(
+    schema::DecimalMetadata* outDecimalMetadata) const {
+  return impl_->toConvertedType(outDecimalMetadata);
 }
 
-std::string LogicalType::ToString() const {
-  return impl_->ToString();
+std::string LogicalType::toString() const {
+  return impl_->toString();
 }
 
-std::string LogicalType::ToJSON() const {
-  return impl_->ToJSON();
+std::string LogicalType::toJson() const {
+  return impl_->toJson();
 }
 
-facebook::velox::parquet::thrift::LogicalType LogicalType::ToThrift() const {
-  return impl_->ToThrift();
+facebook::velox::parquet::thrift::LogicalType LogicalType::toThrift() const {
+  return impl_->toThrift();
 }
 
-bool LogicalType::Equals(const LogicalType& other) const {
-  return impl_->Equals(other);
+bool LogicalType::equals(const LogicalType& other) const {
+  return impl_->equals(other);
 }
 
 LogicalType::Type::type LogicalType::type() const {
   return impl_->type();
 }
 
-SortOrder::type LogicalType::sort_order() const {
-  return impl_->sort_order();
+SortOrder::type LogicalType::sortOrder() const {
+  return impl_->sortOrder();
 }
 
-// Type checks for public LogicalType class
+// Type checks for public LogicalType class.
 
-bool LogicalType::is_string() const {
-  return impl_->type() == LogicalType::Type::STRING;
+bool LogicalType::isString() const {
+  return impl_->type() == LogicalType::Type::kString;
 }
-bool LogicalType::is_map() const {
-  return impl_->type() == LogicalType::Type::MAP;
+bool LogicalType::isMap() const {
+  return impl_->type() == LogicalType::Type::kMap;
 }
-bool LogicalType::is_list() const {
-  return impl_->type() == LogicalType::Type::LIST;
+bool LogicalType::isList() const {
+  return impl_->type() == LogicalType::Type::kList;
 }
-bool LogicalType::is_enum() const {
-  return impl_->type() == LogicalType::Type::ENUM;
+bool LogicalType::isEnum() const {
+  return impl_->type() == LogicalType::Type::kEnum;
 }
-bool LogicalType::is_decimal() const {
-  return impl_->type() == LogicalType::Type::DECIMAL;
+bool LogicalType::isDecimal() const {
+  return impl_->type() == LogicalType::Type::kDecimal;
 }
-bool LogicalType::is_date() const {
-  return impl_->type() == LogicalType::Type::DATE;
+bool LogicalType::isDate() const {
+  return impl_->type() == LogicalType::Type::kDate;
 }
-bool LogicalType::is_time() const {
-  return impl_->type() == LogicalType::Type::TIME;
+bool LogicalType::isTime() const {
+  return impl_->type() == LogicalType::Type::kTime;
 }
-bool LogicalType::is_timestamp() const {
-  return impl_->type() == LogicalType::Type::TIMESTAMP;
+bool LogicalType::isTimestamp() const {
+  return impl_->type() == LogicalType::Type::kTimestamp;
 }
-bool LogicalType::is_interval() const {
-  return impl_->type() == LogicalType::Type::INTERVAL;
+bool LogicalType::isInterval() const {
+  return impl_->type() == LogicalType::Type::kInterval;
 }
-bool LogicalType::is_int() const {
-  return impl_->type() == LogicalType::Type::INT;
+bool LogicalType::isInt() const {
+  return impl_->type() == LogicalType::Type::kInt;
 }
-bool LogicalType::is_null() const {
-  return impl_->type() == LogicalType::Type::NIL;
+bool LogicalType::isNull() const {
+  return impl_->type() == LogicalType::Type::kNil;
 }
-bool LogicalType::is_JSON() const {
-  return impl_->type() == LogicalType::Type::JSON;
+bool LogicalType::isJson() const {
+  return impl_->type() == LogicalType::Type::kJson;
 }
-bool LogicalType::is_BSON() const {
-  return impl_->type() == LogicalType::Type::BSON;
+bool LogicalType::isBson() const {
+  return impl_->type() == LogicalType::Type::kBson;
 }
-bool LogicalType::is_UUID() const {
-  return impl_->type() == LogicalType::Type::UUID;
+bool LogicalType::isUuid() const {
+  return impl_->type() == LogicalType::Type::kUuid;
 }
-bool LogicalType::is_none() const {
-  return impl_->type() == LogicalType::Type::NONE;
+bool LogicalType::isNone() const {
+  return impl_->type() == LogicalType::Type::kNone;
 }
-bool LogicalType::is_valid() const {
-  return impl_->type() != LogicalType::Type::UNDEFINED;
+bool LogicalType::isValid() const {
+  return impl_->type() != LogicalType::Type::kUndefined;
 }
-bool LogicalType::is_invalid() const {
-  return !is_valid();
+bool LogicalType::isInvalid() const {
+  return !isValid();
 }
-bool LogicalType::is_nested() const {
-  return (impl_->type() == LogicalType::Type::LIST) ||
-      (impl_->type() == LogicalType::Type::MAP);
+bool LogicalType::isNested() const {
+  return (impl_->type() == LogicalType::Type::kList) ||
+      (impl_->type() == LogicalType::Type::kMap);
 }
-bool LogicalType::is_nonnested() const {
-  return !is_nested();
+bool LogicalType::isNonnested() const {
+  return !isNested();
 }
-bool LogicalType::is_serialized() const {
-  return impl_->is_serialized();
+bool LogicalType::isSerialized() const {
+  return impl_->isSerialized();
 }
 
-// LogicalTypeImpl intermediate "compatibility" classes
+// LogicalTypeImpl intermediate "compatibility" classes.
 
 class LogicalType::Impl::Compatible : public virtual LogicalType::Impl {
  protected:
   Compatible() = default;
 };
 
-#define set_decimal_metadata(m___, i___, p___, s___) \
-  {                                                  \
-    if (m___) {                                      \
-      (m___)->isset = (i___);                        \
-      (m___)->scale = (s___);                        \
-      (m___)->precision = (p___);                    \
-    }                                                \
+#define setDecimalMetadata(m___, i___, p___, s___) \
+  {                                                \
+    if (m___) {                                    \
+      (m___)->isset = (i___);                      \
+      (m___)->scale = (s___);                      \
+      (m___)->precision = (p___);                  \
+    }                                              \
   }
 
-#define reset_decimal_metadata(m___) \
-  { set_decimal_metadata(m___, false, -1, -1); }
+#define resetDecimalMetadata(m___)           \
+  {                                          \
+    setDecimalMetadata(m___, false, -1, -1); \
+  }
 
-// For logical types that always translate to the same converted type
+// For logical types that always translate to the same converted type.
 class LogicalType::Impl::SimpleCompatible
     : public virtual LogicalType::Impl::Compatible {
  public:
-  bool is_compatible(
-      ConvertedType::type converted_type,
-      schema::DecimalMetadata converted_decimal_metadata) const override {
-    return (converted_type == converted_type_) &&
-        !converted_decimal_metadata.isset;
+  bool isCompatible(
+      ConvertedType::type convertedType,
+      schema::DecimalMetadata convertedDecimalMetadata) const override {
+    return (convertedType == convertedType_) && !convertedDecimalMetadata.isset;
   }
 
-  ConvertedType::type ToConvertedType(
-      schema::DecimalMetadata* out_decimal_metadata) const override {
-    reset_decimal_metadata(out_decimal_metadata);
-    return converted_type_;
+  ConvertedType::type toConvertedType(
+      schema::DecimalMetadata* outDecimalMetadata) const override {
+    resetDecimalMetadata(outDecimalMetadata);
+    return convertedType_;
   }
 
  protected:
-  explicit SimpleCompatible(ConvertedType::type c) : converted_type_(c) {}
+  explicit SimpleCompatible(ConvertedType::type c) : convertedType_(c) {}
 
  private:
-  ConvertedType::type converted_type_ = ConvertedType::NA;
+  ConvertedType::type convertedType_ = ConvertedType::kNa;
 };
 
-// For logical types that have no corresponding converted type
+// For logical types that have no corresponding converted type.
 class LogicalType::Impl::Incompatible : public virtual LogicalType::Impl {
  public:
-  bool is_compatible(
-      ConvertedType::type converted_type,
-      schema::DecimalMetadata converted_decimal_metadata) const override {
-    return (converted_type == ConvertedType::NONE ||
-            converted_type == ConvertedType::NA) &&
-        !converted_decimal_metadata.isset;
+  bool isCompatible(
+      ConvertedType::type convertedType,
+      schema::DecimalMetadata convertedDecimalMetadata) const override {
+    return (convertedType == ConvertedType::kNone ||
+            convertedType == ConvertedType::kNa) &&
+        !convertedDecimalMetadata.isset;
   }
 
-  ConvertedType::type ToConvertedType(
-      schema::DecimalMetadata* out_decimal_metadata) const override {
-    reset_decimal_metadata(out_decimal_metadata);
-    return ConvertedType::NONE;
+  ConvertedType::type toConvertedType(
+      schema::DecimalMetadata* outDecimalMetadata) const override {
+    resetDecimalMetadata(outDecimalMetadata);
+    return ConvertedType::kNone;
   }
 
  protected:
   Incompatible() = default;
 };
 
-// LogicalTypeImpl intermediate "applicability" classes
+// LogicalTypeImpl intermediate "applicability" classes.
 
 class LogicalType::Impl::Applicable : public virtual LogicalType::Impl {
  protected:
   Applicable() = default;
 };
 
-// For logical types that can apply only to a single
-// physical type
+// For logical types that can apply only to a single.
+// Physical type.
 class LogicalType::Impl::SimpleApplicable
     : public virtual LogicalType::Impl::Applicable {
  public:
-  bool is_applicable(
-      parquet::Type::type primitive_type,
-      int32_t primitive_length = -1) const override {
-    return primitive_type == type_;
+  bool isApplicable(
+      parquet::Type::type primitiveType,
+      int32_t primitiveLength = -1) const override {
+    return primitiveType == type_;
   }
 
  protected:
@@ -844,15 +839,15 @@ class LogicalType::Impl::SimpleApplicable
   parquet::Type::type type_;
 };
 
-// For logical types that can apply only to a particular
-// physical type and physical length combination
+// For logical types that can apply only to a particular.
+// Physical type and physical length combination.
 class LogicalType::Impl::TypeLengthApplicable
     : public virtual LogicalType::Impl::Applicable {
  public:
-  bool is_applicable(
-      parquet::Type::type primitive_type,
-      int32_t primitive_length = -1) const override {
-    return primitive_type == type_ && primitive_length == length_;
+  bool isApplicable(
+      parquet::Type::type primitiveType,
+      int32_t primitiveLength = -1) const override {
+    return primitiveType == type_ && primitiveLength == length_;
   }
 
  protected:
@@ -864,13 +859,13 @@ class LogicalType::Impl::TypeLengthApplicable
   int32_t length_;
 };
 
-// For logical types that can apply to any physical type
+// For logical types that can apply to any physical type.
 class LogicalType::Impl::UniversalApplicable
     : public virtual LogicalType::Impl::Applicable {
  public:
-  bool is_applicable(
-      parquet::Type::type primitive_type,
-      int32_t primitive_length = -1) const override {
+  bool isApplicable(
+      parquet::Type::type primitiveType,
+      int32_t primitiveLength = -1) const override {
     return true;
   }
 
@@ -878,13 +873,13 @@ class LogicalType::Impl::UniversalApplicable
   UniversalApplicable() = default;
 };
 
-// For logical types that can never apply to any primitive
-// physical type
+// For logical types that can never apply to any primitive.
+// Physical type.
 class LogicalType::Impl::Inapplicable : public virtual LogicalType::Impl {
  public:
-  bool is_applicable(
-      parquet::Type::type primitive_type,
-      int32_t primitive_length = -1) const override {
+  bool isApplicable(
+      parquet::Type::type primitiveType,
+      int32_t primitiveLength = -1) const override {
     return false;
   }
 
@@ -892,15 +887,15 @@ class LogicalType::Impl::Inapplicable : public virtual LogicalType::Impl {
   Inapplicable() = default;
 };
 
-// LogicalType implementation final classes
+// LogicalType implementation final classes.
 
 #define OVERRIDE_TOSTRING(n___)           \
-  std::string ToString() const override { \
+  std::string toString() const override { \
     return #n___;                         \
   }
 
 #define OVERRIDE_TOTHRIFT(t___, s___)                                       \
-  facebook::velox::parquet::thrift::LogicalType ToThrift() const override { \
+  facebook::velox::parquet::thrift::LogicalType toThrift() const override { \
     facebook::velox::parquet::thrift::LogicalType type;                     \
     facebook::velox::parquet::thrift::t___ subtype;                         \
     type.__set_##s___(subtype);                                             \
@@ -918,20 +913,20 @@ class LogicalType::Impl::String final
 
  private:
   String()
-      : LogicalType::Impl(LogicalType::Type::STRING, SortOrder::UNSIGNED),
-        LogicalType::Impl::SimpleCompatible(ConvertedType::UTF8),
-        LogicalType::Impl::SimpleApplicable(parquet::Type::BYTE_ARRAY) {}
+      : LogicalType::Impl(LogicalType::Type::kString, SortOrder::kUnsigned),
+        LogicalType::Impl::SimpleCompatible(ConvertedType::kUtf8),
+        LogicalType::Impl::SimpleApplicable(parquet::Type::kByteArray) {}
 };
 
-// Each public logical type class's Make() creation method instantiates a
-// corresponding LogicalType::Impl::* object and installs that implementation in
-// the logical type it returns.
+// Each public logical type class's Make() creation method instantiates a.
+// Corresponding LogicalType::Impl::* object and installs that implementation
+// in. The logical type it returns.
 
 #define GENERATE_MAKE(a___)                                      \
-  std::shared_ptr<const LogicalType> a___##LogicalType::Make() { \
-    auto* logical_type = new a___##LogicalType();                \
-    logical_type->impl_.reset(new LogicalType::Impl::a___());    \
-    return std::shared_ptr<const LogicalType>(logical_type);     \
+  std::shared_ptr<const LogicalType> a___##LogicalType::make() { \
+    auto* logicalType = new a___##LogicalType();                 \
+    logicalType->impl_.reset(new LogicalType::Impl::a___());     \
+    return std::shared_ptr<const LogicalType>(logicalType);      \
   }
 
 GENERATE_MAKE(String)
@@ -941,12 +936,12 @@ class LogicalType::Impl::Map final : public LogicalType::Impl::SimpleCompatible,
  public:
   friend class MapLogicalType;
 
-  bool is_compatible(
-      ConvertedType::type converted_type,
-      schema::DecimalMetadata converted_decimal_metadata) const override {
-    return (converted_type == ConvertedType::MAP ||
-            converted_type == ConvertedType::MAP_KEY_VALUE) &&
-        !converted_decimal_metadata.isset;
+  bool isCompatible(
+      ConvertedType::type convertedType,
+      schema::DecimalMetadata convertedDecimalMetadata) const override {
+    return (convertedType == ConvertedType::kMap ||
+            convertedType == ConvertedType::kMapKeyValue) &&
+        !convertedDecimalMetadata.isset;
   }
 
   OVERRIDE_TOSTRING(Map)
@@ -954,8 +949,8 @@ class LogicalType::Impl::Map final : public LogicalType::Impl::SimpleCompatible,
 
  private:
   Map()
-      : LogicalType::Impl(LogicalType::Type::MAP, SortOrder::UNKNOWN),
-        LogicalType::Impl::SimpleCompatible(ConvertedType::MAP) {}
+      : LogicalType::Impl(LogicalType::Type::kMap, SortOrder::kUnknown),
+        LogicalType::Impl::SimpleCompatible(ConvertedType::kMap) {}
 };
 
 GENERATE_MAKE(Map)
@@ -971,8 +966,8 @@ class LogicalType::Impl::List final
 
  private:
   List()
-      : LogicalType::Impl(LogicalType::Type::LIST, SortOrder::UNKNOWN),
-        LogicalType::Impl::SimpleCompatible(ConvertedType::LIST) {}
+      : LogicalType::Impl(LogicalType::Type::kList, SortOrder::kUnknown),
+        LogicalType::Impl::SimpleCompatible(ConvertedType::kList) {}
 };
 
 GENERATE_MAKE(List)
@@ -988,34 +983,34 @@ class LogicalType::Impl::Enum final
 
  private:
   Enum()
-      : LogicalType::Impl(LogicalType::Type::ENUM, SortOrder::UNSIGNED),
-        LogicalType::Impl::SimpleCompatible(ConvertedType::ENUM),
-        LogicalType::Impl::SimpleApplicable(parquet::Type::BYTE_ARRAY) {}
+      : LogicalType::Impl(LogicalType::Type::kEnum, SortOrder::kUnsigned),
+        LogicalType::Impl::SimpleCompatible(ConvertedType::kEnum),
+        LogicalType::Impl::SimpleApplicable(parquet::Type::kByteArray) {}
 };
 
 GENERATE_MAKE(Enum)
 
 // The parameterized logical types (currently Decimal, Time, Timestamp, and Int)
-// generally can't reuse the simple method implementations available in the base
-// and intermediate classes and must (re)implement them all
+// Generally can't reuse the simple method implementations available in the
+// base. And intermediate classes and must (re)implement them all.
 
 class LogicalType::Impl::Decimal final : public LogicalType::Impl::Compatible,
                                          public LogicalType::Impl::Applicable {
  public:
   friend class DecimalLogicalType;
 
-  bool is_applicable(
-      parquet::Type::type primitive_type,
-      int32_t primitive_length = -1) const override;
-  bool is_compatible(
-      ConvertedType::type converted_type,
-      schema::DecimalMetadata converted_decimal_metadata) const override;
-  ConvertedType::type ToConvertedType(
-      schema::DecimalMetadata* out_decimal_metadata) const override;
-  std::string ToString() const override;
-  std::string ToJSON() const override;
-  facebook::velox::parquet::thrift::LogicalType ToThrift() const override;
-  bool Equals(const LogicalType& other) const override;
+  bool isApplicable(
+      parquet::Type::type primitiveType,
+      int32_t primitiveLength = -1) const override;
+  bool isCompatible(
+      ConvertedType::type convertedType,
+      schema::DecimalMetadata convertedDecimalMetadata) const override;
+  ConvertedType::type toConvertedType(
+      schema::DecimalMetadata* outDecimalMetadata) const override;
+  std::string toString() const override;
+  std::string toJson() const override;
+  facebook::velox::parquet::thrift::LogicalType toThrift() const override;
+  bool equals(const LogicalType& other) const override;
 
   int32_t precision() const {
     return precision_;
@@ -1026,38 +1021,38 @@ class LogicalType::Impl::Decimal final : public LogicalType::Impl::Compatible,
 
  private:
   Decimal(int32_t p, int32_t s)
-      : LogicalType::Impl(LogicalType::Type::DECIMAL, SortOrder::SIGNED),
+      : LogicalType::Impl(LogicalType::Type::kDecimal, SortOrder::kSigned),
         precision_(p),
         scale_(s) {}
   int32_t precision_ = -1;
   int32_t scale_ = -1;
 };
 
-bool LogicalType::Impl::Decimal::is_applicable(
-    parquet::Type::type primitive_type,
-    int32_t primitive_length) const {
+bool LogicalType::Impl::Decimal::isApplicable(
+    parquet::Type::type primitiveType,
+    int32_t primitiveLength) const {
   bool ok = false;
-  switch (primitive_type) {
-    case parquet::Type::INT32: {
+  switch (primitiveType) {
+    case parquet::Type::kInt32: {
       ok = (1 <= precision_) && (precision_ <= 9);
     } break;
-    case parquet::Type::INT64: {
+    case parquet::Type::kInt64: {
       ok = (1 <= precision_) && (precision_ <= 18);
       if (precision_ < 10) {
-        // FIXME(tpb): warn that INT32 could be used
+        // FIXME(tpb): warn that INT32 could be used.
       }
     } break;
-    case parquet::Type::FIXED_LEN_BYTE_ARRAY: {
-      // If the primitive length is larger than this we will overflow int32 when
-      // calculating precision.
-      if (primitive_length <= 0 || primitive_length > 891723282) {
+    case parquet::Type::kFixedLenByteArray: {
+      // If the primitive length is larger than this we will overflow int32
+      // when. Calculating precision.
+      if (primitiveLength <= 0 || primitiveLength > 891723282) {
         ok = false;
         break;
       }
       ok = precision_ <= static_cast<int32_t>(std::floor(
-                             std::log10(2) * ((8.0 * primitive_length) - 1.0)));
+                             std::log10(2) * ((8.0 * primitiveLength) - 1.0)));
     } break;
-    case parquet::Type::BYTE_ARRAY: {
+    case parquet::Type::kByteArray: {
       ok = true;
     } break;
     default: {
@@ -1066,28 +1061,28 @@ bool LogicalType::Impl::Decimal::is_applicable(
   return ok;
 }
 
-bool LogicalType::Impl::Decimal::is_compatible(
-    ConvertedType::type converted_type,
-    schema::DecimalMetadata converted_decimal_metadata) const {
-  return converted_type == ConvertedType::DECIMAL &&
-      (converted_decimal_metadata.isset &&
-       converted_decimal_metadata.scale == scale_ &&
-       converted_decimal_metadata.precision == precision_);
+bool LogicalType::Impl::Decimal::isCompatible(
+    ConvertedType::type convertedType,
+    schema::DecimalMetadata convertedDecimalMetadata) const {
+  return convertedType == ConvertedType::kDecimal &&
+      (convertedDecimalMetadata.isset &&
+       convertedDecimalMetadata.scale == scale_ &&
+       convertedDecimalMetadata.precision == precision_);
 }
 
-ConvertedType::type LogicalType::Impl::Decimal::ToConvertedType(
-    schema::DecimalMetadata* out_decimal_metadata) const {
-  set_decimal_metadata(out_decimal_metadata, true, precision_, scale_);
-  return ConvertedType::DECIMAL;
+ConvertedType::type LogicalType::Impl::Decimal::toConvertedType(
+    schema::DecimalMetadata* outDecimalMetadata) const {
+  setDecimalMetadata(outDecimalMetadata, true, precision_, scale_);
+  return ConvertedType::kDecimal;
 }
 
-std::string LogicalType::Impl::Decimal::ToString() const {
+std::string LogicalType::Impl::Decimal::toString() const {
   std::stringstream type;
   type << "Decimal(precision=" << precision_ << ", scale=" << scale_ << ")";
   return type.str();
 }
 
-std::string LogicalType::Impl::Decimal::ToJSON() const {
+std::string LogicalType::Impl::Decimal::toJson() const {
   std::stringstream json;
   json << R"({"Type": "Decimal", "precision": )" << precision_
        << R"(, "scale": )" << scale_ << "}";
@@ -1095,27 +1090,27 @@ std::string LogicalType::Impl::Decimal::ToJSON() const {
 }
 
 facebook::velox::parquet::thrift::LogicalType
-LogicalType::Impl::Decimal::ToThrift() const {
+LogicalType::Impl::Decimal::toThrift() const {
   facebook::velox::parquet::thrift::LogicalType type;
-  facebook::velox::parquet::thrift::DecimalType decimal_type;
-  decimal_type.__set_precision(precision_);
-  decimal_type.__set_scale(scale_);
-  type.__set_DECIMAL(decimal_type);
+  facebook::velox::parquet::thrift::DecimalType decimalType;
+  decimalType.__set_precision(precision_);
+  decimalType.__set_scale(scale_);
+  type.__set_DECIMAL(decimalType);
   return type;
 }
 
-bool LogicalType::Impl::Decimal::Equals(const LogicalType& other) const {
+bool LogicalType::Impl::Decimal::equals(const LogicalType& other) const {
   bool eq = false;
-  if (other.is_decimal()) {
-    const auto& other_decimal = checked_cast<const DecimalLogicalType&>(other);
+  if (other.isDecimal()) {
+    const auto& otherDecimal = checked_cast<const DecimalLogicalType&>(other);
     eq =
-        (precision_ == other_decimal.precision() &&
-         scale_ == other_decimal.scale());
+        (precision_ == otherDecimal.precision() &&
+         scale_ == otherDecimal.scale());
   }
   return eq;
 }
 
-std::shared_ptr<const LogicalType> DecimalLogicalType::Make(
+std::shared_ptr<const LogicalType> DecimalLogicalType::make(
     int32_t precision,
     int32_t scale) {
   if (precision < 1) {
@@ -1127,9 +1122,9 @@ std::shared_ptr<const LogicalType> DecimalLogicalType::Make(
         "Scale must be a non-negative integer that does not exceed precision for "
         "Decimal logical type");
   }
-  auto* logical_type = new DecimalLogicalType();
-  logical_type->impl_.reset(new LogicalType::Impl::Decimal(precision, scale));
-  return std::shared_ptr<const LogicalType>(logical_type);
+  auto* logicalType = new DecimalLogicalType();
+  logicalType->impl_.reset(new LogicalType::Impl::Decimal(precision, scale));
+  return std::shared_ptr<const LogicalType>(logicalType);
 }
 
 int32_t DecimalLogicalType::precision() const {
@@ -1151,164 +1146,165 @@ class LogicalType::Impl::Date final
 
  private:
   Date()
-      : LogicalType::Impl(LogicalType::Type::DATE, SortOrder::SIGNED),
-        LogicalType::Impl::SimpleCompatible(ConvertedType::DATE),
-        LogicalType::Impl::SimpleApplicable(parquet::Type::INT32) {}
+      : LogicalType::Impl(LogicalType::Type::kDate, SortOrder::kSigned),
+        LogicalType::Impl::SimpleCompatible(ConvertedType::kDate),
+        LogicalType::Impl::SimpleApplicable(parquet::Type::kInt32) {}
 };
 
 GENERATE_MAKE(Date)
 
-#define time_unit_string(u___)                                          \
-  ((u___) == LogicalType::TimeUnit::MILLIS                              \
-       ? "milliseconds"                                                 \
-       : ((u___) == LogicalType::TimeUnit::MICROS                       \
-              ? "microseconds"                                          \
-              : ((u___) == LogicalType::TimeUnit::NANOS ? "nanoseconds" \
-                                                        : "unknown")))
+#define timeUnitString(u___)                                             \
+  ((u___) == LogicalType::TimeUnit::kMillis                              \
+       ? "milliseconds"                                                  \
+       : ((u___) == LogicalType::TimeUnit::kMicros                       \
+              ? "microseconds"                                           \
+              : ((u___) == LogicalType::TimeUnit::kNanos ? "nanoseconds" \
+                                                         : "unknown")))
 
 class LogicalType::Impl::Time final : public LogicalType::Impl::Compatible,
                                       public LogicalType::Impl::Applicable {
  public:
   friend class TimeLogicalType;
 
-  bool is_applicable(
-      parquet::Type::type primitive_type,
-      int32_t primitive_length = -1) const override;
-  bool is_compatible(
-      ConvertedType::type converted_type,
-      schema::DecimalMetadata converted_decimal_metadata) const override;
-  ConvertedType::type ToConvertedType(
-      schema::DecimalMetadata* out_decimal_metadata) const override;
-  std::string ToString() const override;
-  std::string ToJSON() const override;
-  facebook::velox::parquet::thrift::LogicalType ToThrift() const override;
-  bool Equals(const LogicalType& other) const override;
-
-  bool is_adjusted_to_utc() const {
+  bool isApplicable(
+      parquet::Type::type primitiveType,
+      int32_t primitiveLength = -1) const override;
+  bool isCompatible(
+      ConvertedType::type convertedType,
+      schema::DecimalMetadata convertedDecimalMetadata) const override;
+  ConvertedType::type toConvertedType(
+      schema::DecimalMetadata* outDecimalMetadata) const override;
+  std::string toString() const override;
+  std::string toJson() const override;
+  facebook::velox::parquet::thrift::LogicalType toThrift() const override;
+  bool equals(const LogicalType& other) const override;
+
+  bool isAdjustedToUtc() const {
     return adjusted_;
   }
-  LogicalType::TimeUnit::unit time_unit() const {
+  LogicalType::TimeUnit::Unit timeUnit() const {
     return unit_;
   }
 
  private:
-  Time(bool a, LogicalType::TimeUnit::unit u)
-      : LogicalType::Impl(LogicalType::Type::TIME, SortOrder::SIGNED),
+  Time(bool a, LogicalType::TimeUnit::Unit u)
+      : LogicalType::Impl(LogicalType::Type::kTime, SortOrder::kSigned),
         adjusted_(a),
         unit_(u) {}
   bool adjusted_ = false;
-  LogicalType::TimeUnit::unit unit_;
+  LogicalType::TimeUnit::Unit unit_;
 };
 
-bool LogicalType::Impl::Time::is_applicable(
-    parquet::Type::type primitive_type,
-    int32_t primitive_length) const {
-  return (primitive_type == parquet::Type::INT32 &&
-          unit_ == LogicalType::TimeUnit::MILLIS) ||
-      (primitive_type == parquet::Type::INT64 &&
-       (unit_ == LogicalType::TimeUnit::MICROS ||
-        unit_ == LogicalType::TimeUnit::NANOS));
+bool LogicalType::Impl::Time::isApplicable(
+    parquet::Type::type primitiveType,
+    int32_t primitiveLength) const {
+  return (primitiveType == parquet::Type::kInt32 &&
+          unit_ == LogicalType::TimeUnit::kMillis) ||
+      (primitiveType == parquet::Type::kInt64 &&
+       (unit_ == LogicalType::TimeUnit::kMicros ||
+        unit_ == LogicalType::TimeUnit::kNanos));
 }
 
-bool LogicalType::Impl::Time::is_compatible(
-    ConvertedType::type converted_type,
-    schema::DecimalMetadata converted_decimal_metadata) const {
-  if (converted_decimal_metadata.isset) {
+bool LogicalType::Impl::Time::isCompatible(
+    ConvertedType::type convertedType,
+    schema::DecimalMetadata convertedDecimalMetadata) const {
+  if (convertedDecimalMetadata.isset) {
     return false;
-  } else if (adjusted_ && unit_ == LogicalType::TimeUnit::MILLIS) {
-    return converted_type == ConvertedType::TIME_MILLIS;
-  } else if (adjusted_ && unit_ == LogicalType::TimeUnit::MICROS) {
-    return converted_type == ConvertedType::TIME_MICROS;
+  } else if (adjusted_ && unit_ == LogicalType::TimeUnit::kMillis) {
+    return convertedType == ConvertedType::kTimeMillis;
+  } else if (adjusted_ && unit_ == LogicalType::TimeUnit::kMicros) {
+    return convertedType == ConvertedType::kTimeMicros;
   } else {
-    return (converted_type == ConvertedType::NONE) ||
-        (converted_type == ConvertedType::NA);
+    return (convertedType == ConvertedType::kNone) ||
+        (convertedType == ConvertedType::kNa);
   }
 }
 
-ConvertedType::type LogicalType::Impl::Time::ToConvertedType(
-    schema::DecimalMetadata* out_decimal_metadata) const {
-  reset_decimal_metadata(out_decimal_metadata);
+ConvertedType::type LogicalType::Impl::Time::toConvertedType(
+    schema::DecimalMetadata* outDecimalMetadata) const {
+  resetDecimalMetadata(outDecimalMetadata);
   if (adjusted_) {
-    if (unit_ == LogicalType::TimeUnit::MILLIS) {
-      return ConvertedType::TIME_MILLIS;
-    } else if (unit_ == LogicalType::TimeUnit::MICROS) {
-      return ConvertedType::TIME_MICROS;
+    if (unit_ == LogicalType::TimeUnit::kMillis) {
+      return ConvertedType::kTimeMillis;
+    } else if (unit_ == LogicalType::TimeUnit::kMicros) {
+      return ConvertedType::kTimeMicros;
     }
   }
-  return ConvertedType::NONE;
+  return ConvertedType::kNone;
 }
 
-std::string LogicalType::Impl::Time::ToString() const {
+std::string LogicalType::Impl::Time::toString() const {
   std::stringstream type;
   type << "Time(isAdjustedToUTC=" << std::boolalpha << adjusted_
-       << ", timeUnit=" << time_unit_string(unit_) << ")";
+       << ", timeUnit=" << timeUnitString(unit_) << ")";
   return type.str();
 }
 
-std::string LogicalType::Impl::Time::ToJSON() const {
+std::string LogicalType::Impl::Time::toJson() const {
   std::stringstream json;
   json << R"({"Type": "Time", "isAdjustedToUTC": )" << std::boolalpha
-       << adjusted_ << R"(, "timeUnit": ")" << time_unit_string(unit_)
-       << R"("})";
+       << adjusted_ << R"(, "timeUnit": ")" << timeUnitString(unit_) << R"("})";
   return json.str();
 }
 
 facebook::velox::parquet::thrift::LogicalType
-LogicalType::Impl::Time::ToThrift() const {
+LogicalType::Impl::Time::toThrift() const {
   facebook::velox::parquet::thrift::LogicalType type;
-  facebook::velox::parquet::thrift::TimeType time_type;
-  facebook::velox::parquet::thrift::TimeUnit time_unit;
-  VELOX_DCHECK_NE(unit_, LogicalType::TimeUnit::UNKNOWN);
-  if (unit_ == LogicalType::TimeUnit::MILLIS) {
+  facebook::velox::parquet::thrift::TimeType timeType;
+  facebook::velox::parquet::thrift::TimeUnit timeUnit;
+  VELOX_DCHECK_NE(
+      static_cast<int>(unit_),
+      static_cast<int>(LogicalType::TimeUnit::kUnknown));
+  if (unit_ == LogicalType::TimeUnit::kMillis) {
     facebook::velox::parquet::thrift::MilliSeconds millis;
-    time_unit.__set_MILLIS(millis);
-  } else if (unit_ == LogicalType::TimeUnit::MICROS) {
+    timeUnit.__set_MILLIS(millis);
+  } else if (unit_ == LogicalType::TimeUnit::kMicros) {
     facebook::velox::parquet::thrift::MicroSeconds micros;
-    time_unit.__set_MICROS(micros);
-  } else if (unit_ == LogicalType::TimeUnit::NANOS) {
+    timeUnit.__set_MICROS(micros);
+  } else if (unit_ == LogicalType::TimeUnit::kNanos) {
     facebook::velox::parquet::thrift::NanoSeconds nanos;
-    time_unit.__set_NANOS(nanos);
+    timeUnit.__set_NANOS(nanos);
   }
-  time_type.__set_isAdjustedToUTC(adjusted_);
-  time_type.__set_unit(time_unit);
-  type.__set_TIME(time_type);
+  timeType.__set_isAdjustedToUTC(adjusted_);
+  timeType.__set_unit(timeUnit);
+  type.__set_TIME(timeType);
   return type;
 }
 
-bool LogicalType::Impl::Time::Equals(const LogicalType& other) const {
+bool LogicalType::Impl::Time::equals(const LogicalType& other) const {
   bool eq = false;
-  if (other.is_time()) {
-    const auto& other_time = checked_cast<const TimeLogicalType&>(other);
+  if (other.isTime()) {
+    const auto& otherTime = checked_cast<const TimeLogicalType&>(other);
     eq =
-        (adjusted_ == other_time.is_adjusted_to_utc() &&
-         unit_ == other_time.time_unit());
+        (adjusted_ == otherTime.isAdjustedToUtc() &&
+         unit_ == otherTime.timeUnit());
   }
   return eq;
 }
 
-std::shared_ptr<const LogicalType> TimeLogicalType::Make(
-    bool is_adjusted_to_utc,
-    LogicalType::TimeUnit::unit time_unit) {
-  if (time_unit == LogicalType::TimeUnit::MILLIS ||
-      time_unit == LogicalType::TimeUnit::MICROS ||
-      time_unit == LogicalType::TimeUnit::NANOS) {
-    auto* logical_type = new TimeLogicalType();
-    logical_type->impl_.reset(
-        new LogicalType::Impl::Time(is_adjusted_to_utc, time_unit));
-    return std::shared_ptr<const LogicalType>(logical_type);
+std::shared_ptr<const LogicalType> TimeLogicalType::make(
+    bool isAdjustedToUtc,
+    LogicalType::TimeUnit::Unit timeUnit) {
+  if (timeUnit == LogicalType::TimeUnit::kMillis ||
+      timeUnit == LogicalType::TimeUnit::kMicros ||
+      timeUnit == LogicalType::TimeUnit::kNanos) {
+    auto* logicalType = new TimeLogicalType();
+    logicalType->impl_.reset(
+        new LogicalType::Impl::Time(isAdjustedToUtc, timeUnit));
+    return std::shared_ptr<const LogicalType>(logicalType);
   } else {
     throw ParquetException(
         "TimeUnit must be one of MILLIS, MICROS, or NANOS for Time logical type");
   }
 }
 
-bool TimeLogicalType::is_adjusted_to_utc() const {
+bool TimeLogicalType::isAdjustedToUtc() const {
   return (dynamic_cast<const LogicalType::Impl::Time&>(*impl_))
-      .is_adjusted_to_utc();
+      .isAdjustedToUtc();
 }
 
-LogicalType::TimeUnit::unit TimeLogicalType::time_unit() const {
-  return (dynamic_cast<const LogicalType::Impl::Time&>(*impl_)).time_unit();
+LogicalType::TimeUnit::Unit TimeLogicalType::timeUnit() const {
+  return (dynamic_cast<const LogicalType::Impl::Time&>(*impl_)).timeUnit();
 }
 
 class LogicalType::Impl::Timestamp final
@@ -1317,183 +1313,180 @@ class LogicalType::Impl::Timestamp final
  public:
   friend class TimestampLogicalType;
 
-  bool is_serialized() const override;
-  bool is_compatible(
-      ConvertedType::type converted_type,
-      schema::DecimalMetadata converted_decimal_metadata) const override;
-  ConvertedType::type ToConvertedType(
-      schema::DecimalMetadata* out_decimal_metadata) const override;
-  std::string ToString() const override;
-  std::string ToJSON() const override;
-  facebook::velox::parquet::thrift::LogicalType ToThrift() const override;
-  bool Equals(const LogicalType& other) const override;
-
-  bool is_adjusted_to_utc() const {
+  bool isSerialized() const override;
+  bool isCompatible(
+      ConvertedType::type convertedType,
+      schema::DecimalMetadata convertedDecimalMetadata) const override;
+  ConvertedType::type toConvertedType(
+      schema::DecimalMetadata* outDecimalMetadata) const override;
+  std::string toString() const override;
+  std::string toJson() const override;
+  facebook::velox::parquet::thrift::LogicalType toThrift() const override;
+  bool equals(const LogicalType& other) const override;
+
+  bool isAdjustedToUtc() const {
     return adjusted_;
   }
-  LogicalType::TimeUnit::unit time_unit() const {
+  LogicalType::TimeUnit::Unit timeUnit() const {
     return unit_;
   }
 
-  bool is_from_converted_type() const {
-    return is_from_converted_type_;
+  bool isFromConvertedType() const {
+    return isFromConvertedType_;
   }
-  bool force_set_converted_type() const {
-    return force_set_converted_type_;
+  bool forceSetConvertedType() const {
+    return forceSetConvertedType_;
   }
 
  private:
   Timestamp(
       bool adjusted,
-      LogicalType::TimeUnit::unit unit,
-      bool is_from_converted_type,
-      bool force_set_converted_type)
-      : LogicalType::Impl(LogicalType::Type::TIMESTAMP, SortOrder::SIGNED),
-        LogicalType::Impl::SimpleApplicable(parquet::Type::INT64),
+      LogicalType::TimeUnit::Unit Unit,
+      bool isFromConvertedType,
+      bool forceSetConvertedType)
+      : LogicalType::Impl(LogicalType::Type::kTimestamp, SortOrder::kSigned),
+        LogicalType::Impl::SimpleApplicable(parquet::Type::kInt64),
         adjusted_(adjusted),
-        unit_(unit),
-        is_from_converted_type_(is_from_converted_type),
-        force_set_converted_type_(force_set_converted_type) {}
+        unit_(Unit),
+        isFromConvertedType_(isFromConvertedType),
+        forceSetConvertedType_(forceSetConvertedType) {}
   bool adjusted_ = false;
-  LogicalType::TimeUnit::unit unit_;
-  bool is_from_converted_type_ = false;
-  bool force_set_converted_type_ = false;
+  LogicalType::TimeUnit::Unit unit_;
+  bool isFromConvertedType_ = false;
+  bool forceSetConvertedType_ = false;
 };
 
-bool LogicalType::Impl::Timestamp::is_serialized() const {
-  return !is_from_converted_type_;
+bool LogicalType::Impl::Timestamp::isSerialized() const {
+  return !isFromConvertedType_;
 }
 
-bool LogicalType::Impl::Timestamp::is_compatible(
-    ConvertedType::type converted_type,
-    schema::DecimalMetadata converted_decimal_metadata) const {
-  if (converted_decimal_metadata.isset) {
+bool LogicalType::Impl::Timestamp::isCompatible(
+    ConvertedType::type convertedType,
+    schema::DecimalMetadata convertedDecimalMetadata) const {
+  if (convertedDecimalMetadata.isset) {
     return false;
-  } else if (unit_ == LogicalType::TimeUnit::MILLIS) {
-    if (adjusted_ || force_set_converted_type_) {
-      return converted_type == ConvertedType::TIMESTAMP_MILLIS;
+  } else if (unit_ == LogicalType::TimeUnit::kMillis) {
+    if (adjusted_ || forceSetConvertedType_) {
+      return convertedType == ConvertedType::kTimestampMillis;
     } else {
-      return (converted_type == ConvertedType::NONE) ||
-          (converted_type == ConvertedType::NA);
+      return (convertedType == ConvertedType::kNone) ||
+          (convertedType == ConvertedType::kNa);
     }
-  } else if (unit_ == LogicalType::TimeUnit::MICROS) {
-    if (adjusted_ || force_set_converted_type_) {
-      return converted_type == ConvertedType::TIMESTAMP_MICROS;
+  } else if (unit_ == LogicalType::TimeUnit::kMicros) {
+    if (adjusted_ || forceSetConvertedType_) {
+      return convertedType == ConvertedType::kTimestampMicros;
     } else {
-      return (converted_type == ConvertedType::NONE) ||
-          (converted_type == ConvertedType::NA);
+      return (convertedType == ConvertedType::kNone) ||
+          (convertedType == ConvertedType::kNa);
     }
   } else {
-    return (converted_type == ConvertedType::NONE) ||
-        (converted_type == ConvertedType::NA);
+    return (convertedType == ConvertedType::kNone) ||
+        (convertedType == ConvertedType::kNa);
   }
 }
 
-ConvertedType::type LogicalType::Impl::Timestamp::ToConvertedType(
-    schema::DecimalMetadata* out_decimal_metadata) const {
-  reset_decimal_metadata(out_decimal_metadata);
-  if (adjusted_ || force_set_converted_type_) {
-    if (unit_ == LogicalType::TimeUnit::MILLIS) {
-      return ConvertedType::TIMESTAMP_MILLIS;
-    } else if (unit_ == LogicalType::TimeUnit::MICROS) {
-      return ConvertedType::TIMESTAMP_MICROS;
+ConvertedType::type LogicalType::Impl::Timestamp::toConvertedType(
+    schema::DecimalMetadata* outDecimalMetadata) const {
+  resetDecimalMetadata(outDecimalMetadata);
+  if (adjusted_ || forceSetConvertedType_) {
+    if (unit_ == LogicalType::TimeUnit::kMillis) {
+      return ConvertedType::kTimestampMillis;
+    } else if (unit_ == LogicalType::TimeUnit::kMicros) {
+      return ConvertedType::kTimestampMicros;
     }
   }
-  return ConvertedType::NONE;
+  return ConvertedType::kNone;
 }
 
-std::string LogicalType::Impl::Timestamp::ToString() const {
+std::string LogicalType::Impl::Timestamp::toString() const {
   std::stringstream type;
   type << "Timestamp(isAdjustedToUTC=" << std::boolalpha << adjusted_
-       << ", timeUnit=" << time_unit_string(unit_)
-       << ", is_from_converted_type=" << is_from_converted_type_
-       << ", force_set_converted_type=" << force_set_converted_type_ << ")";
+       << ", timeUnit=" << timeUnitString(unit_)
+       << ", is_from_converted_type=" << isFromConvertedType_
+       << ", force_set_converted_type=" << forceSetConvertedType_ << ")";
   return type.str();
 }
 
-std::string LogicalType::Impl::Timestamp::ToJSON() const {
+std::string LogicalType::Impl::Timestamp::toJson() const {
   std::stringstream json;
   json << R"({"Type": "Timestamp", "isAdjustedToUTC": )" << std::boolalpha
-       << adjusted_ << R"(, "timeUnit": ")" << time_unit_string(unit_) << R"(")"
-       << R"(, "is_from_converted_type": )" << is_from_converted_type_
-       << R"(, "force_set_converted_type": )" << force_set_converted_type_
-       << R"(})";
+       << adjusted_ << R"(, "timeUnit": ")" << timeUnitString(unit_) << R"(")"
+       << R"(, "isFromConvertedType": )" << isFromConvertedType_
+       << R"(, "forceSetConvertedType": )" << forceSetConvertedType_ << R"(})";
   return json.str();
 }
 
 facebook::velox::parquet::thrift::LogicalType
-LogicalType::Impl::Timestamp::ToThrift() const {
+LogicalType::Impl::Timestamp::toThrift() const {
   facebook::velox::parquet::thrift::LogicalType type;
-  facebook::velox::parquet::thrift::TimestampType timestamp_type;
-  facebook::velox::parquet::thrift::TimeUnit time_unit;
-  VELOX_DCHECK_NE(unit_, LogicalType::TimeUnit::UNKNOWN);
-  if (unit_ == LogicalType::TimeUnit::MILLIS) {
+  facebook::velox::parquet::thrift::TimestampType timestampType;
+  facebook::velox::parquet::thrift::TimeUnit timeUnit;
+  VELOX_DCHECK_NE(
+      static_cast<int>(unit_),
+      static_cast<int>(LogicalType::TimeUnit::kUnknown));
+  if (unit_ == LogicalType::TimeUnit::kMillis) {
     facebook::velox::parquet::thrift::MilliSeconds millis;
-    time_unit.__set_MILLIS(millis);
-  } else if (unit_ == LogicalType::TimeUnit::MICROS) {
+    timeUnit.__set_MILLIS(millis);
+  } else if (unit_ == LogicalType::TimeUnit::kMicros) {
     facebook::velox::parquet::thrift::MicroSeconds micros;
-    time_unit.__set_MICROS(micros);
-  } else if (unit_ == LogicalType::TimeUnit::NANOS) {
+    timeUnit.__set_MICROS(micros);
+  } else if (unit_ == LogicalType::TimeUnit::kNanos) {
     facebook::velox::parquet::thrift::NanoSeconds nanos;
-    time_unit.__set_NANOS(nanos);
+    timeUnit.__set_NANOS(nanos);
   }
-  timestamp_type.__set_isAdjustedToUTC(adjusted_);
-  timestamp_type.__set_unit(time_unit);
-  type.__set_TIMESTAMP(timestamp_type);
+  timestampType.__set_isAdjustedToUTC(adjusted_);
+  timestampType.__set_unit(timeUnit);
+  type.__set_TIMESTAMP(timestampType);
   return type;
 }
 
-bool LogicalType::Impl::Timestamp::Equals(const LogicalType& other) const {
+bool LogicalType::Impl::Timestamp::equals(const LogicalType& other) const {
   bool eq = false;
-  if (other.is_timestamp()) {
-    const auto& other_timestamp =
+  if (other.isTimestamp()) {
+    const auto& otherTimestamp =
         checked_cast<const TimestampLogicalType&>(other);
     eq =
-        (adjusted_ == other_timestamp.is_adjusted_to_utc() &&
-         unit_ == other_timestamp.time_unit());
+        (adjusted_ == otherTimestamp.isAdjustedToUtc() &&
+         unit_ == otherTimestamp.timeUnit());
   }
   return eq;
 }
 
-std::shared_ptr<const LogicalType> TimestampLogicalType::Make(
-    bool is_adjusted_to_utc,
-    LogicalType::TimeUnit::unit time_unit,
-    bool is_from_converted_type,
-    bool force_set_converted_type) {
-  if (time_unit == LogicalType::TimeUnit::MILLIS ||
-      time_unit == LogicalType::TimeUnit::MICROS ||
-      time_unit == LogicalType::TimeUnit::NANOS) {
-    auto* logical_type = new TimestampLogicalType();
-    logical_type->impl_.reset(new LogicalType::Impl::Timestamp(
-        is_adjusted_to_utc,
-        time_unit,
-        is_from_converted_type,
-        force_set_converted_type));
-    return std::shared_ptr<const LogicalType>(logical_type);
+std::shared_ptr<const LogicalType> TimestampLogicalType::make(
+    bool isAdjustedToUtc,
+    LogicalType::TimeUnit::Unit timeUnit,
+    bool isFromConvertedType,
+    bool forceSetConvertedType) {
+  if (timeUnit == LogicalType::TimeUnit::kMillis ||
+      timeUnit == LogicalType::TimeUnit::kMicros ||
+      timeUnit == LogicalType::TimeUnit::kNanos) {
+    auto* logicalType = new TimestampLogicalType();
+    logicalType->impl_.reset(new LogicalType::Impl::Timestamp(
+        isAdjustedToUtc, timeUnit, isFromConvertedType, forceSetConvertedType));
+    return std::shared_ptr<const LogicalType>(logicalType);
   } else {
     throw ParquetException(
         "TimeUnit must be one of MILLIS, MICROS, or NANOS for Timestamp logical type");
   }
 }
 
-bool TimestampLogicalType::is_adjusted_to_utc() const {
+bool TimestampLogicalType::isAdjustedToUtc() const {
   return (dynamic_cast<const LogicalType::Impl::Timestamp&>(*impl_))
-      .is_adjusted_to_utc();
+      .isAdjustedToUtc();
 }
 
-LogicalType::TimeUnit::unit TimestampLogicalType::time_unit() const {
-  return (dynamic_cast<const LogicalType::Impl::Timestamp&>(*impl_))
-      .time_unit();
+LogicalType::TimeUnit::Unit TimestampLogicalType::timeUnit() const {
+  return (dynamic_cast<const LogicalType::Impl::Timestamp&>(*impl_)).timeUnit();
 }
 
-bool TimestampLogicalType::is_from_converted_type() const {
+bool TimestampLogicalType::isFromConvertedType() const {
   return (dynamic_cast<const LogicalType::Impl::Timestamp&>(*impl_))
-      .is_from_converted_type();
+      .isFromConvertedType();
 }
 
-bool TimestampLogicalType::force_set_converted_type() const {
+bool TimestampLogicalType::forceSetConvertedType() const {
   return (dynamic_cast<const LogicalType::Impl::Timestamp&>(*impl_))
-      .force_set_converted_type();
+      .forceSetConvertedType();
 }
 
 class LogicalType::Impl::Interval final
@@ -1503,16 +1496,16 @@ class LogicalType::Impl::Interval final
   friend class IntervalLogicalType;
 
   OVERRIDE_TOSTRING(Interval)
-  // TODO(tpboudreau): uncomment the following line to enable serialization
-  // after parquet.thrift recognizes IntervalType as a ConvertedType
+  // TODO(tpboudreau): uncomment the following line to enable serialization.
+  // After parquet.thrift recognizes IntervalType as a ConvertedType.
   // OVERRIDE_TOTHRIFT(IntervalType, INTERVAL)
 
  private:
   Interval()
-      : LogicalType::Impl(LogicalType::Type::INTERVAL, SortOrder::UNKNOWN),
-        LogicalType::Impl::SimpleCompatible(ConvertedType::INTERVAL),
+      : LogicalType::Impl(LogicalType::Type::kInterval, SortOrder::kUnknown),
+        LogicalType::Impl::SimpleCompatible(ConvertedType::kInterval),
         LogicalType::Impl::TypeLengthApplicable(
-            parquet::Type::FIXED_LEN_BYTE_ARRAY,
+            parquet::Type::kFixedLenByteArray,
             12) {}
 };
 
@@ -1523,152 +1516,152 @@ class LogicalType::Impl::Int final : public LogicalType::Impl::Compatible,
  public:
   friend class IntLogicalType;
 
-  bool is_applicable(
-      parquet::Type::type primitive_type,
-      int32_t primitive_length = -1) const override;
-  bool is_compatible(
-      ConvertedType::type converted_type,
-      schema::DecimalMetadata converted_decimal_metadata) const override;
-  ConvertedType::type ToConvertedType(
-      schema::DecimalMetadata* out_decimal_metadata) const override;
-  std::string ToString() const override;
-  std::string ToJSON() const override;
-  facebook::velox::parquet::thrift::LogicalType ToThrift() const override;
-  bool Equals(const LogicalType& other) const override;
-
-  int bit_width() const {
+  bool isApplicable(
+      parquet::Type::type primitiveType,
+      int32_t primitiveLength = -1) const override;
+  bool isCompatible(
+      ConvertedType::type convertedType,
+      schema::DecimalMetadata convertedDecimalMetadata) const override;
+  ConvertedType::type toConvertedType(
+      schema::DecimalMetadata* outDecimalMetadata) const override;
+  std::string toString() const override;
+  std::string toJson() const override;
+  facebook::velox::parquet::thrift::LogicalType toThrift() const override;
+  bool equals(const LogicalType& other) const override;
+
+  int bitWidth() const {
     return width_;
   }
-  bool is_signed() const {
+  bool isSigned() const {
     return signed_;
   }
 
  private:
-  Int(int w, bool s)
+  Int(int width, bool isSigned)
       : LogicalType::Impl(
-            LogicalType::Type::INT,
-            (s ? SortOrder::SIGNED : SortOrder::UNSIGNED)),
-        width_(w),
-        signed_(s) {}
+            LogicalType::Type::kInt,
+            (isSigned ? SortOrder::kSigned : SortOrder::kUnsigned)),
+        width_(width),
+        signed_(isSigned) {}
   int width_ = 0;
   bool signed_ = false;
 };
 
-bool LogicalType::Impl::Int::is_applicable(
-    parquet::Type::type primitive_type,
-    int32_t primitive_length) const {
-  return (primitive_type == parquet::Type::INT32 && width_ <= 32) ||
-      (primitive_type == parquet::Type::INT64 && width_ == 64);
+bool LogicalType::Impl::Int::isApplicable(
+    parquet::Type::type primitiveType,
+    int32_t primitiveLength) const {
+  return (primitiveType == parquet::Type::kInt32 && width_ <= 32) ||
+      (primitiveType == parquet::Type::kInt64 && width_ == 64);
 }
 
-bool LogicalType::Impl::Int::is_compatible(
-    ConvertedType::type converted_type,
-    schema::DecimalMetadata converted_decimal_metadata) const {
-  if (converted_decimal_metadata.isset) {
+bool LogicalType::Impl::Int::isCompatible(
+    ConvertedType::type convertedType,
+    schema::DecimalMetadata convertedDecimalMetadata) const {
+  if (convertedDecimalMetadata.isset) {
     return false;
   } else if (signed_ && width_ == 8) {
-    return converted_type == ConvertedType::INT_8;
+    return convertedType == ConvertedType::kInt8;
   } else if (signed_ && width_ == 16) {
-    return converted_type == ConvertedType::INT_16;
+    return convertedType == ConvertedType::kInt16;
   } else if (signed_ && width_ == 32) {
-    return converted_type == ConvertedType::INT_32;
+    return convertedType == ConvertedType::kInt32;
   } else if (signed_ && width_ == 64) {
-    return converted_type == ConvertedType::INT_64;
+    return convertedType == ConvertedType::kInt64;
   } else if (!signed_ && width_ == 8) {
-    return converted_type == ConvertedType::UINT_8;
+    return convertedType == ConvertedType::kUint8;
   } else if (!signed_ && width_ == 16) {
-    return converted_type == ConvertedType::UINT_16;
+    return convertedType == ConvertedType::kUint16;
   } else if (!signed_ && width_ == 32) {
-    return converted_type == ConvertedType::UINT_32;
+    return convertedType == ConvertedType::kUint32;
   } else if (!signed_ && width_ == 64) {
-    return converted_type == ConvertedType::UINT_64;
+    return convertedType == ConvertedType::kUint64;
   } else {
     return false;
   }
 }
 
-ConvertedType::type LogicalType::Impl::Int::ToConvertedType(
-    schema::DecimalMetadata* out_decimal_metadata) const {
-  reset_decimal_metadata(out_decimal_metadata);
+ConvertedType::type LogicalType::Impl::Int::toConvertedType(
+    schema::DecimalMetadata* outDecimalMetadata) const {
+  resetDecimalMetadata(outDecimalMetadata);
   if (signed_) {
     switch (width_) {
       case 8:
-        return ConvertedType::INT_8;
+        return ConvertedType::kInt8;
       case 16:
-        return ConvertedType::INT_16;
+        return ConvertedType::kInt16;
       case 32:
-        return ConvertedType::INT_32;
+        return ConvertedType::kInt32;
       case 64:
-        return ConvertedType::INT_64;
+        return ConvertedType::kInt64;
     }
   } else { // unsigned
     switch (width_) {
       case 8:
-        return ConvertedType::UINT_8;
+        return ConvertedType::kUint8;
       case 16:
-        return ConvertedType::UINT_16;
+        return ConvertedType::kUint16;
       case 32:
-        return ConvertedType::UINT_32;
+        return ConvertedType::kUint32;
       case 64:
-        return ConvertedType::UINT_64;
+        return ConvertedType::kUint64;
     }
   }
-  return ConvertedType::NONE;
+  return ConvertedType::kNone;
 }
 
-std::string LogicalType::Impl::Int::ToString() const {
+std::string LogicalType::Impl::Int::toString() const {
   std::stringstream type;
   type << "Int(bitWidth=" << width_ << ", isSigned=" << std::boolalpha
        << signed_ << ")";
   return type.str();
 }
 
-std::string LogicalType::Impl::Int::ToJSON() const {
+std::string LogicalType::Impl::Int::toJson() const {
   std::stringstream json;
-  json << R"({"Type": "Int", "bitWidth": )" << width_ << R"(, "isSigned": )"
+  json << R"({"Type": "int", "bitWidth": )" << width_ << R"(, "isSigned": )"
        << std::boolalpha << signed_ << "}";
   return json.str();
 }
 
-facebook::velox::parquet::thrift::LogicalType LogicalType::Impl::Int::ToThrift()
+facebook::velox::parquet::thrift::LogicalType LogicalType::Impl::Int::toThrift()
     const {
   facebook::velox::parquet::thrift::LogicalType type;
-  facebook::velox::parquet::thrift::IntType int_type;
+  facebook::velox::parquet::thrift::IntType intType;
   VELOX_DCHECK(width_ == 64 || width_ == 32 || width_ == 16 || width_ == 8);
-  int_type.__set_bitWidth(static_cast<int8_t>(width_));
-  int_type.__set_isSigned(signed_);
-  type.__set_INTEGER(int_type);
+  intType.__set_bitWidth(static_cast<int8_t>(width_));
+  intType.__set_isSigned(signed_);
+  type.__set_INTEGER(intType);
   return type;
 }
 
-bool LogicalType::Impl::Int::Equals(const LogicalType& other) const {
+bool LogicalType::Impl::Int::equals(const LogicalType& other) const {
   bool eq = false;
-  if (other.is_int()) {
-    const auto& other_int = checked_cast<const IntLogicalType&>(other);
-    eq = (width_ == other_int.bit_width() && signed_ == other_int.is_signed());
+  if (other.isInt()) {
+    const auto& otherInt = checked_cast<const IntLogicalType&>(other);
+    eq = (width_ == otherInt.bitWidth() && signed_ == otherInt.isSigned());
   }
   return eq;
 }
 
-std::shared_ptr<const LogicalType> IntLogicalType::Make(
-    int bit_width,
-    bool is_signed) {
-  if (bit_width == 8 || bit_width == 16 || bit_width == 32 || bit_width == 64) {
-    auto* logical_type = new IntLogicalType();
-    logical_type->impl_.reset(new LogicalType::Impl::Int(bit_width, is_signed));
-    return std::shared_ptr<const LogicalType>(logical_type);
+std::shared_ptr<const LogicalType> IntLogicalType::make(
+    int bitWidth,
+    bool isSigned) {
+  if (bitWidth == 8 || bitWidth == 16 || bitWidth == 32 || bitWidth == 64) {
+    auto* logicalType = new IntLogicalType();
+    logicalType->impl_.reset(new LogicalType::Impl::Int(bitWidth, isSigned));
+    return std::shared_ptr<const LogicalType>(logicalType);
   } else {
     throw ParquetException(
         "Bit width must be exactly 8, 16, 32, or 64 for Int logical type");
   }
 }
 
-int IntLogicalType::bit_width() const {
-  return (dynamic_cast<const LogicalType::Impl::Int&>(*impl_)).bit_width();
+int IntLogicalType::bitWidth() const {
+  return (dynamic_cast<const LogicalType::Impl::Int&>(*impl_)).bitWidth();
 }
 
-bool IntLogicalType::is_signed() const {
-  return (dynamic_cast<const LogicalType::Impl::Int&>(*impl_)).is_signed();
+bool IntLogicalType::isSigned() const {
+  return (dynamic_cast<const LogicalType::Impl::Int&>(*impl_)).isSigned();
 }
 
 class LogicalType::Impl::Null final
@@ -1681,65 +1674,65 @@ class LogicalType::Impl::Null final
   OVERRIDE_TOTHRIFT(NullType, UNKNOWN)
 
  private:
-  Null() : LogicalType::Impl(LogicalType::Type::NIL, SortOrder::UNKNOWN) {}
+  Null() : LogicalType::Impl(LogicalType::Type::kNil, SortOrder::kUnknown) {}
 };
 
 GENERATE_MAKE(Null)
 
-class LogicalType::Impl::JSON final
+class LogicalType::Impl::Json final
     : public LogicalType::Impl::SimpleCompatible,
       public LogicalType::Impl::SimpleApplicable {
  public:
-  friend class JSONLogicalType;
+  friend class JsonLogicalType;
 
   OVERRIDE_TOSTRING(JSON)
   OVERRIDE_TOTHRIFT(JsonType, JSON)
 
  private:
-  JSON()
-      : LogicalType::Impl(LogicalType::Type::JSON, SortOrder::UNSIGNED),
-        LogicalType::Impl::SimpleCompatible(ConvertedType::JSON),
-        LogicalType::Impl::SimpleApplicable(parquet::Type::BYTE_ARRAY) {}
+  Json()
+      : LogicalType::Impl(LogicalType::Type::kJson, SortOrder::kUnsigned),
+        LogicalType::Impl::SimpleCompatible(ConvertedType::kJson),
+        LogicalType::Impl::SimpleApplicable(parquet::Type::kByteArray) {}
 };
 
-GENERATE_MAKE(JSON)
+GENERATE_MAKE(Json)
 
-class LogicalType::Impl::BSON final
+class LogicalType::Impl::Bson final
     : public LogicalType::Impl::SimpleCompatible,
       public LogicalType::Impl::SimpleApplicable {
  public:
-  friend class BSONLogicalType;
+  friend class BsonLogicalType;
 
   OVERRIDE_TOSTRING(BSON)
   OVERRIDE_TOTHRIFT(BsonType, BSON)
 
  private:
-  BSON()
-      : LogicalType::Impl(LogicalType::Type::BSON, SortOrder::UNSIGNED),
-        LogicalType::Impl::SimpleCompatible(ConvertedType::BSON),
-        LogicalType::Impl::SimpleApplicable(parquet::Type::BYTE_ARRAY) {}
+  Bson()
+      : LogicalType::Impl(LogicalType::Type::kBson, SortOrder::kUnsigned),
+        LogicalType::Impl::SimpleCompatible(ConvertedType::kBson),
+        LogicalType::Impl::SimpleApplicable(parquet::Type::kByteArray) {}
 };
 
-GENERATE_MAKE(BSON)
+GENERATE_MAKE(Bson)
 
-class LogicalType::Impl::UUID final
+class LogicalType::Impl::Uuid final
     : public LogicalType::Impl::Incompatible,
       public LogicalType::Impl::TypeLengthApplicable {
  public:
-  friend class UUIDLogicalType;
+  friend class UuidLogicalType;
 
   OVERRIDE_TOSTRING(UUID)
   OVERRIDE_TOTHRIFT(UUIDType, UUID)
 
  private:
-  UUID()
-      : LogicalType::Impl(LogicalType::Type::UUID, SortOrder::UNSIGNED),
+  Uuid()
+      : LogicalType::Impl(LogicalType::Type::kUuid, SortOrder::kUnsigned),
         LogicalType::Impl::TypeLengthApplicable(
-            parquet::Type::FIXED_LEN_BYTE_ARRAY,
+            parquet::Type::kFixedLenByteArray,
             16) {}
 };
 
-GENERATE_MAKE(UUID)
+GENERATE_MAKE(Uuid)
 
 class LogicalType::Impl::No final
     : public LogicalType::Impl::SimpleCompatible,
@@ -1751,8 +1744,8 @@ class LogicalType::Impl::No final
 
  private:
   No()
-      : LogicalType::Impl(LogicalType::Type::NONE, SortOrder::UNKNOWN),
-        LogicalType::Impl::SimpleCompatible(ConvertedType::NONE) {}
+      : LogicalType::Impl(LogicalType::Type::kNone, SortOrder::kUnknown),
+        LogicalType::Impl::SimpleCompatible(ConvertedType::kNone) {}
 };
 
 GENERATE_MAKE(No)
@@ -1767,8 +1760,8 @@ class LogicalType::Impl::Undefined final
 
  private:
   Undefined()
-      : LogicalType::Impl(LogicalType::Type::UNDEFINED, SortOrder::UNKNOWN),
-        LogicalType::Impl::SimpleCompatible(ConvertedType::UNDEFINED) {}
+      : LogicalType::Impl(LogicalType::Type::kUndefined, SortOrder::kUnknown),
+        LogicalType::Impl::SimpleCompatible(ConvertedType::kUndefined) {}
 };
 
 GENERATE_MAKE(Undefined)
diff --git a/velox/dwio/parquet/writer/arrow/Types.h b/velox/dwio/parquet/writer/arrow/Types.h
index 24727b1c05c..0bf8274a542 100644
--- a/velox/dwio/parquet/writer/arrow/Types.h
+++ b/velox/dwio/parquet/writer/arrow/Types.h
@@ -40,8 +40,8 @@ class Codec;
 
 namespace facebook::velox::parquet::arrow {
 
-// ----------------------------------------------------------------------
-// Metadata enums to match Thrift metadata
+// ----------------------------------------------------------------------.
+// Metadata enums to match Thrift metadata.
 //
 // The reason we maintain our own enums is to avoid transitive dependency on
 // the compiled Thrift headers (and thus thrift/Thrift.h) for users of the
@@ -51,21 +51,21 @@ namespace facebook::velox::parquet::arrow {
 //
 // We can also add special values like NONE to distinguish between metadata
 // values being set and not set. As an example consider ConvertedType and
-// CompressionCodec
+// CompressionCodec.
 
-// Mirrors parquet::Type
+// Mirrors parquet::Type.
 struct Type {
   enum type {
-    BOOLEAN = 0,
-    INT32 = 1,
-    INT64 = 2,
-    INT96 = 3,
-    FLOAT = 4,
-    DOUBLE = 5,
-    BYTE_ARRAY = 6,
-    FIXED_LEN_BYTE_ARRAY = 7,
+    kBoolean = 0,
+    kInt32 = 1,
+    kInt64 = 2,
+    kInt96 = 3,
+    kFloat = 4,
+    kDouble = 5,
+    kByteArray = 6,
+    kFixedLenByteArray = 7,
     // Should always be last element.
-    UNDEFINED = 8
+    kUndefined = 8
   };
 };
 
@@ -74,69 +74,70 @@ namespace parquet {
 using Type = facebook::velox::parquet::arrow::Type;
 }
 
-// Mirrors parquet::ConvertedType
+// Mirrors parquet::ConvertedType.
 struct ConvertedType {
   enum type {
-    NONE, // Not a real converted type, but means no converted type is specified
-    UTF8,
-    MAP,
-    MAP_KEY_VALUE,
-    LIST,
-    ENUM,
-    DECIMAL,
-    DATE,
-    TIME_MILLIS,
-    TIME_MICROS,
-    TIMESTAMP_MILLIS,
-    TIMESTAMP_MICROS,
-    UINT_8,
-    UINT_16,
-    UINT_32,
-    UINT_64,
-    INT_8,
-    INT_16,
-    INT_32,
-    INT_64,
-    JSON,
-    BSON,
-    INTERVAL,
+    kNone, // Not a real converted type, but means no converted type is
+           // specified
+    kUtf8,
+    kMap,
+    kMapKeyValue,
+    kList,
+    kEnum,
+    kDecimal,
+    kDate,
+    kTimeMillis,
+    kTimeMicros,
+    kTimestampMillis,
+    kTimestampMicros,
+    kUint8,
+    kUint16,
+    kUint32,
+    kUint64,
+    kInt8,
+    kInt16,
+    kInt32,
+    kInt64,
+    kJson,
+    kBson,
+    kInterval,
     // DEPRECATED INVALID ConvertedType for all-null data.
-    // Only useful for reading legacy files written out by interim Parquet C++
-    // releases. For writing, always emit LogicalType::Null instead. See
-    // PARQUET-1990.
-    NA = 25,
-    UNDEFINED = 26 // Not a real converted type; should always be last element
+    // Only useful for reading legacy files written out by interim Parquet
+    // C++ releases. For writing, always emit LogicalType::nullType instead.
+    // See PARQUET-1990.
+    kNa = 25,
+    kUndefined = 26 // Not a real converted type; should always be last element
   };
 };
 
-// forward declaration
+// Forward declaration.
 namespace format {
 
 class LogicalType;
 
 }
 
-// Mirrors parquet::FieldRepetitionType
+// Mirrors parquet::FieldRepetitionType.
 struct Repetition {
   enum type {
-    REQUIRED = 0,
-    OPTIONAL = 1,
-    REPEATED = 2,
-    /*Always last*/ UNDEFINED = 3
+    kRequired = 0,
+    kOptional = 1,
+    kRepeated = 2,
+    /*Always last*/ kUndefined = 3
   };
 };
 
 // Reference:
-// parquet-mr/parquet-hadoop/src/main/java/org/apache/parquet/
-//                            format/converter/ParquetMetadataConverter.java
-// Sort order for page and column statistics. Types are associated with sort
-// orders (e.g., UTF8 columns should use UNSIGNED) and column stats are
-// aggregated using a sort order. As of parquet-format version 2.3.1, the
-// order used to aggregate stats is always SIGNED and is not stored in the
+// Parquet-mr/parquet-hadoop/src/main/java/org/apache/parquet/.
+//                            Format/converter/ParquetMetadataConverter.java.
+// Sort order for page and column statistics. Types are associated with sort.
+// Orders (e.g., UTF8 columns should use UNSIGNED) and column stats are.
+// Aggregated using a sort order. As of parquet-format version 2.3.1, the.
+// Order used to aggregate stats is always SIGNED and is not stored in the.
 // Parquet file. These stats are discarded for types that need unsigned.
 // See PARQUET-686.
 struct SortOrder {
-  enum type { SIGNED, UNSIGNED, UNKNOWN };
+  enum type { kSigned, kUnsigned, kUnknown };
 };
 
 namespace schema {
@@ -154,149 +155,147 @@ class PARQUET_EXPORT LogicalType {
  public:
   struct Type {
     enum type {
-      UNDEFINED = 0, // Not a real logical type
-      STRING = 1,
-      MAP,
-      LIST,
-      ENUM,
-      DECIMAL,
-      DATE,
-      TIME,
-      TIMESTAMP,
-      INTERVAL,
-      INT,
-      NIL, // Thrift NullType: annotates data that is always null
-      JSON,
-      BSON,
-      UUID,
-      NONE // Not a real logical type; should always be last element
+      kUndefined = 0, // Not a real logical type
+      kString = 1,
+      kMap,
+      kList,
+      kEnum,
+      kDecimal,
+      kDate,
+      kTime,
+      kTimestamp,
+      kInterval,
+      kInt,
+      kNil, // Thrift NullType: annotates data that is always null
+      kJson,
+      kBson,
+      kUuid,
+      kNone // Not a real logical type; should always be last element
     };
   };
 
   struct TimeUnit {
-    enum unit { UNKNOWN = 0, MILLIS = 1, MICROS, NANOS };
+    enum Unit { kUnknown = 0, kMillis = 1, kMicros, kNanos };
   };
 
   /// \brief If possible, return a logical type equivalent to the given legacy
   /// converted type (and decimal metadata if applicable).
-  static std::shared_ptr<const LogicalType> FromConvertedType(
-      const ConvertedType::type converted_type,
-      const schema::DecimalMetadata converted_decimal_metadata = {
-          false,
-          -1,
-          -1});
+  static std::shared_ptr<const LogicalType> fromConvertedType(
+      const ConvertedType::type convertedType,
+      const schema::DecimalMetadata convertedDecimalMetadata = {false, -1, -1});
 
   /// \brief Return the logical type represented by the Thrift intermediary
   /// object.
-  static std::shared_ptr<const LogicalType> FromThrift(
-      const facebook::velox::parquet::thrift::LogicalType& thrift_logical_type);
+  static std::shared_ptr<const LogicalType> fromThrift(
+      const facebook::velox::parquet::thrift::LogicalType& thriftLogicalType);
 
   /// \brief Return the explicitly requested logical type.
-  static std::shared_ptr<const LogicalType> String();
-  static std::shared_ptr<const LogicalType> Map();
-  static std::shared_ptr<const LogicalType> List();
-  static std::shared_ptr<const LogicalType> Enum();
-  static std::shared_ptr<const LogicalType> Decimal(
+  static std::shared_ptr<const LogicalType> string();
+  static std::shared_ptr<const LogicalType> map();
+  static std::shared_ptr<const LogicalType> list();
+  static std::shared_ptr<const LogicalType> enumType();
+  static std::shared_ptr<const LogicalType> decimal(
       int32_t precision,
       int32_t scale = 0);
-  static std::shared_ptr<const LogicalType> Date();
-  static std::shared_ptr<const LogicalType> Time(
-      bool is_adjusted_to_utc,
-      LogicalType::TimeUnit::unit time_unit);
-
-  /// \brief Create a Timestamp logical type
-  /// \param[in] is_adjusted_to_utc set true if the data is UTC-normalized
-  /// \param[in] time_unit the resolution of the timestamp
-  /// \param[in] is_from_converted_type if true, the timestamp was generated
-  /// by translating a legacy converted type of TIMESTAMP_MILLIS or
+  static std::shared_ptr<const LogicalType> date();
+  static std::shared_ptr<const LogicalType> time(
+      bool isAdjustedToUtc,
+      LogicalType::TimeUnit::Unit timeUnit);
+
+  /// \brief Create a Timestamp logical type.
+  /// \param[in] is_adjusted_to_utc Set true if the data is UTC-normalized.
+  /// \param[in] time_unit The resolution of the timestamp.
+  /// \param[in] is_from_converted_type If true, the timestamp was generated.
+  /// By translating a legacy converted type of TIMESTAMP_MILLIS or
   /// TIMESTAMP_MICROS. Default is false.
-  /// \param[in] force_set_converted_type if true, always set the
-  /// legacy ConvertedType TIMESTAMP_MICROS and TIMESTAMP_MILLIS
-  /// metadata. Default is false
-  static std::shared_ptr<const LogicalType> Timestamp(
-      bool is_adjusted_to_utc,
-      LogicalType::TimeUnit::unit time_unit,
-      bool is_from_converted_type = false,
-      bool force_set_converted_type = false);
-
-  static std::shared_ptr<const LogicalType> Interval();
-  static std::shared_ptr<const LogicalType> Int(int bit_width, bool is_signed);
-
-  /// \brief Create a logical type for data that's always null
+  /// \param[in] force_set_converted_type If true, always set the
+  /// legacy ConvertedType TIMESTAMP_MICROS and TIMESTAMP_MILLIS.
+  /// metadata. Default is false.
+  static std::shared_ptr<const LogicalType> timestamp(
+      bool isAdjustedToUtc,
+      LogicalType::TimeUnit::Unit timeUnit,
+      bool isFromConvertedType = false,
+      bool forceSetConvertedType = false);
+
+  static std::shared_ptr<const LogicalType> interval();
+  static std::shared_ptr<const LogicalType> intType(
+      int bitWidth,
+      bool isSigned);
+
+  /// \brief Create a logical type for data that's always null.
   ///
   /// Any physical type can be annotated with this logical type.
-  static std::shared_ptr<const LogicalType> Null();
+  static std::shared_ptr<const LogicalType> nullType();
 
-  static std::shared_ptr<const LogicalType> JSON();
-  static std::shared_ptr<const LogicalType> BSON();
-  static std::shared_ptr<const LogicalType> UUID();
+  static std::shared_ptr<const LogicalType> json();
+  static std::shared_ptr<const LogicalType> bson();
+  static std::shared_ptr<const LogicalType> uuid();
 
-  /// \brief Create a placeholder for when no logical type is specified
-  static std::shared_ptr<const LogicalType> None();
+  /// \brief Create a placeholder for when no logical type is specified.
+  static std::shared_ptr<const LogicalType> none();
 
-  /// \brief Return true if this logical type is consistent with the given
-  /// underlying physical type.
-  bool is_applicable(
-      parquet::Type::type primitive_type,
-      int32_t primitive_length = -1) const;
+  /// \brief Return true if this logical type is consistent with the given.
+  /// Underlying physical type.
+  bool isApplicable(
+      parquet::Type::type primitiveType,
+      int32_t primitiveLength = -1) const;
 
   /// \brief Return true if this logical type is equivalent to the given legacy
   /// converted type (and decimal metadata if applicable).
-  bool is_compatible(
-      ConvertedType::type converted_type,
-      schema::DecimalMetadata converted_decimal_metadata = {false, -1, -1})
-      const;
+  bool isCompatible(
+      ConvertedType::type convertedType,
+      schema::DecimalMetadata convertedDecimalMetadata = {false, -1, -1}) const;
 
-  /// \brief If possible, return the legacy converted type (and decimal metadata
-  /// if applicable) equivalent to this logical type.
-  ConvertedType::type ToConvertedType(
-      schema::DecimalMetadata* out_decimal_metadata) const;
+  /// \brief If possible, return the legacy converted type (and decimal
+  /// metadata if applicable) equivalent to this logical type.
+  ConvertedType::type toConvertedType(
+      schema::DecimalMetadata* outDecimalMetadata) const;
 
   /// \brief Return a printable representation of this logical type.
-  std::string ToString() const;
+  std::string toString() const;
 
   /// \brief Return a JSON representation of this logical type.
-  std::string ToJSON() const;
+  std::string toJson() const;
 
   /// \brief Return a serializable Thrift object for this logical type.
-  facebook::velox::parquet::thrift::LogicalType ToThrift() const;
+  facebook::velox::parquet::thrift::LogicalType toThrift() const;
 
-  /// \brief Return true if the given logical type is equivalent to this logical
-  /// type.
-  bool Equals(const LogicalType& other) const;
+  /// \brief Return true if the given logical type is equivalent to this
+  /// logical type.
+  bool equals(const LogicalType& other) const;
 
   /// \brief Return the enumerated type of this logical type.
   LogicalType::Type::type type() const;
 
   /// \brief Return the appropriate sort order for this logical type.
-  SortOrder::type sort_order() const;
+  SortOrder::type sortOrder() const;
 
   // Type checks ...
-  bool is_string() const;
-  bool is_map() const;
-  bool is_list() const;
-  bool is_enum() const;
-  bool is_decimal() const;
-  bool is_date() const;
-  bool is_time() const;
-  bool is_timestamp() const;
-  bool is_interval() const;
-  bool is_int() const;
-  bool is_null() const;
-  bool is_JSON() const;
-  bool is_BSON() const;
-  bool is_UUID() const;
-  bool is_none() const;
+  bool isString() const;
+  bool isMap() const;
+  bool isList() const;
+  bool isEnum() const;
+  bool isDecimal() const;
+  bool isDate() const;
+  bool isTime() const;
+  bool isTimestamp() const;
+  bool isInterval() const;
+  bool isInt() const;
+  bool isNull() const;
+  bool isJson() const;
+  bool isBson() const;
+  bool isUuid() const;
+  bool isNone() const;
   /// \brief Return true if this logical type is of a known type.
-  bool is_valid() const;
-  bool is_invalid() const;
-  /// \brief Return true if this logical type is suitable for a schema
+  bool isValid() const;
+  bool isInvalid() const;
+  /// \brief Return true if this logical type is suitable for a schema.
   /// GroupNode.
-  bool is_nested() const;
-  bool is_nonnested() const;
-  /// \brief Return true if this logical type is included in the Thrift output
-  /// for its node.
-  bool is_serialized() const;
+  bool isNested() const;
+  bool isNonnested() const;
+  /// \brief Return true if this logical type is included in the Thrift output.
+  /// For its node.
+  bool isSerialized() const;
 
   LogicalType(const LogicalType&) = delete;
   LogicalType& operator=(const LogicalType&) = delete;
@@ -312,7 +311,7 @@ class PARQUET_EXPORT LogicalType {
 /// \brief Allowed for physical type BYTE_ARRAY, must be encoded as UTF-8.
 class PARQUET_EXPORT StringLogicalType : public LogicalType {
  public:
-  static std::shared_ptr<const LogicalType> Make();
+  static std::shared_ptr<const LogicalType> make();
 
  private:
   StringLogicalType() = default;
@@ -321,7 +320,7 @@ class PARQUET_EXPORT StringLogicalType : public LogicalType {
 /// \brief Allowed for group nodes only.
 class PARQUET_EXPORT MapLogicalType : public LogicalType {
  public:
-  static std::shared_ptr<const LogicalType> Make();
+  static std::shared_ptr<const LogicalType> make();
 
  private:
   MapLogicalType() = default;
@@ -330,7 +329,7 @@ class PARQUET_EXPORT MapLogicalType : public LogicalType {
 /// \brief Allowed for group nodes only.
 class PARQUET_EXPORT ListLogicalType : public LogicalType {
  public:
-  static std::shared_ptr<const LogicalType> Make();
+  static std::shared_ptr<const LogicalType> make();
 
  private:
   ListLogicalType() = default;
@@ -339,17 +338,17 @@ class PARQUET_EXPORT ListLogicalType : public LogicalType {
 /// \brief Allowed for physical type BYTE_ARRAY, must be encoded as UTF-8.
 class PARQUET_EXPORT EnumLogicalType : public LogicalType {
  public:
-  static std::shared_ptr<const LogicalType> Make();
+  static std::shared_ptr<const LogicalType> make();
 
  private:
   EnumLogicalType() = default;
 };
 
-/// \brief Allowed for physical type INT32, INT64, FIXED_LEN_BYTE_ARRAY, or
+/// \brief Allowed for physical type INT32, INT64, FIXED_LEN_BYTE_ARRAY, or.
 /// BYTE_ARRAY, depending on the precision.
 class PARQUET_EXPORT DecimalLogicalType : public LogicalType {
  public:
-  static std::shared_ptr<const LogicalType> Make(
+  static std::shared_ptr<const LogicalType> make(
       int32_t precision,
       int32_t scale = 0);
   int32_t precision() const;
@@ -362,21 +361,21 @@ class PARQUET_EXPORT DecimalLogicalType : public LogicalType {
 /// \brief Allowed for physical type INT32.
 class PARQUET_EXPORT DateLogicalType : public LogicalType {
  public:
-  static std::shared_ptr<const LogicalType> Make();
+  static std::shared_ptr<const LogicalType> make();
 
  private:
   DateLogicalType() = default;
 };
 
-/// \brief Allowed for physical type INT32 (for MILLIS) or INT64 (for MICROS and
-/// NANOS).
+/// \brief Allowed for physical type INT32 (for MILLIS) or INT64 (for MICROS
+/// and NANOS).
 class PARQUET_EXPORT TimeLogicalType : public LogicalType {
  public:
-  static std::shared_ptr<const LogicalType> Make(
-      bool is_adjusted_to_utc,
-      LogicalType::TimeUnit::unit time_unit);
-  bool is_adjusted_to_utc() const;
-  LogicalType::TimeUnit::unit time_unit() const;
+  static std::shared_ptr<const LogicalType> make(
+      bool isAdjustedToUtc,
+      LogicalType::TimeUnit::Unit timeUnit);
+  bool isAdjustedToUtc() const;
+  LogicalType::TimeUnit::Unit timeUnit() const;
 
  private:
   TimeLogicalType() = default;
@@ -385,41 +384,41 @@ class PARQUET_EXPORT TimeLogicalType : public LogicalType {
 /// \brief Allowed for physical type INT64.
 class PARQUET_EXPORT TimestampLogicalType : public LogicalType {
  public:
-  static std::shared_ptr<const LogicalType> Make(
-      bool is_adjusted_to_utc,
-      LogicalType::TimeUnit::unit time_unit,
-      bool is_from_converted_type = false,
-      bool force_set_converted_type = false);
-  bool is_adjusted_to_utc() const;
-  LogicalType::TimeUnit::unit time_unit() const;
+  static std::shared_ptr<const LogicalType> make(
+      bool isAdjustedToUtc,
+      LogicalType::TimeUnit::Unit timeUnit,
+      bool isFromConvertedType = false,
+      bool forceSetConvertedType = false);
+  bool isAdjustedToUtc() const;
+  LogicalType::TimeUnit::Unit timeUnit() const;
 
-  /// \brief If true, will not set LogicalType in Thrift metadata
-  bool is_from_converted_type() const;
+  /// \brief If true, will not set LogicalType in Thrift metadata.
+  bool isFromConvertedType() const;
 
-  /// \brief If true, will set ConvertedType for micros and millis
-  /// resolution in legacy ConvertedType Thrift metadata
-  bool force_set_converted_type() const;
+  /// \brief If true, will set ConvertedType for micros and millis.
+  /// Resolution in legacy ConvertedType Thrift metadata.
+  bool forceSetConvertedType() const;
 
  private:
   TimestampLogicalType() = default;
 };
 
-/// \brief Allowed for physical type FIXED_LEN_BYTE_ARRAY with length 12
+/// \brief Allowed for physical type FIXED_LEN_BYTE_ARRAY with length 12.
 class PARQUET_EXPORT IntervalLogicalType : public LogicalType {
  public:
-  static std::shared_ptr<const LogicalType> Make();
+  static std::shared_ptr<const LogicalType> make();
 
  private:
   IntervalLogicalType() = default;
 };
 
-/// \brief Allowed for physical type INT32 (for bit widths 8, 16, and 32) and
+/// \brief Allowed for physical type INT32 (for bit widths 8, 16, and 32) and.
 /// INT64 (for bit width 64).
 class PARQUET_EXPORT IntLogicalType : public LogicalType {
  public:
-  static std::shared_ptr<const LogicalType> Make(int bit_width, bool is_signed);
-  int bit_width() const;
-  bool is_signed() const;
+  static std::shared_ptr<const LogicalType> make(int bitWidth, bool isSigned);
+  int bitWidth() const;
+  bool isSigned() const;
 
  private:
   IntLogicalType() = default;
@@ -428,110 +427,110 @@ class PARQUET_EXPORT IntLogicalType : public LogicalType {
 /// \brief Allowed for any physical type.
 class PARQUET_EXPORT NullLogicalType : public LogicalType {
  public:
-  static std::shared_ptr<const LogicalType> Make();
+  static std::shared_ptr<const LogicalType> make();
 
  private:
   NullLogicalType() = default;
 };
 
 /// \brief Allowed for physical type BYTE_ARRAY.
-class PARQUET_EXPORT JSONLogicalType : public LogicalType {
+class PARQUET_EXPORT JsonLogicalType : public LogicalType {
  public:
-  static std::shared_ptr<const LogicalType> Make();
+  static std::shared_ptr<const LogicalType> make();
 
  private:
-  JSONLogicalType() = default;
+  JsonLogicalType() = default;
 };
 
 /// \brief Allowed for physical type BYTE_ARRAY.
-class PARQUET_EXPORT BSONLogicalType : public LogicalType {
+class PARQUET_EXPORT BsonLogicalType : public LogicalType {
  public:
-  static std::shared_ptr<const LogicalType> Make();
+  static std::shared_ptr<const LogicalType> make();
 
  private:
-  BSONLogicalType() = default;
+  BsonLogicalType() = default;
 };
 
-/// \brief Allowed for physical type FIXED_LEN_BYTE_ARRAY with length 16,
-/// must encode raw UUID bytes.
-class PARQUET_EXPORT UUIDLogicalType : public LogicalType {
+/// \brief Allowed for physical type FIXED_LEN_BYTE_ARRAY with length 16,.
+/// Must encode raw UUID bytes.
+class PARQUET_EXPORT UuidLogicalType : public LogicalType {
  public:
-  static std::shared_ptr<const LogicalType> Make();
+  static std::shared_ptr<const LogicalType> make();
 
  private:
-  UUIDLogicalType() = default;
+  UuidLogicalType() = default;
 };
 
 /// \brief Allowed for any physical type.
 class PARQUET_EXPORT NoLogicalType : public LogicalType {
  public:
-  static std::shared_ptr<const LogicalType> Make();
+  static std::shared_ptr<const LogicalType> make();
 
  private:
   NoLogicalType() = default;
 };
 
-// Internal API, for unrecognized logical types
+// Internal API, for unrecognized logical types.
 class PARQUET_EXPORT UndefinedLogicalType : public LogicalType {
  public:
-  static std::shared_ptr<const LogicalType> Make();
+  static std::shared_ptr<const LogicalType> make();
 
  private:
   UndefinedLogicalType() = default;
 };
 
-// Data encodings. Mirrors parquet::Encoding
+// Data encodings. Mirrors parquet::Encoding.
 struct Encoding {
   enum type {
-    PLAIN = 0,
-    PLAIN_DICTIONARY = 2,
-    RLE = 3,
-    BIT_PACKED = 4,
-    DELTA_BINARY_PACKED = 5,
-    DELTA_LENGTH_BYTE_ARRAY = 6,
-    DELTA_BYTE_ARRAY = 7,
-    RLE_DICTIONARY = 8,
-    BYTE_STREAM_SPLIT = 9,
-    // Should always be last element (except UNKNOWN)
-    UNDEFINED = 10,
-    UNKNOWN = 999
+    kPlain = 0,
+    kPlainDictionary = 2,
+    kRle = 3,
+    kBitPacked = 4,
+    kDeltaBinaryPacked = 5,
+    kDeltaLengthByteArray = 6,
+    kDeltaByteArray = 7,
+    kRleDictionary = 8,
+    kByteStreamSplit = 9,
+    // Should always be last element (except UNKNOWN).
+    kUndefined = 10,
+    kUnknown = 999
   };
 };
 
-// Exposed data encodings. It is the encoding of the data read from the file,
-// rather than the encoding of the data in the file. E.g., the data encoded as
-// RLE_DICTIONARY in the file can be read as dictionary indices by RLE
-// decoding, in which case the data read from the file is DICTIONARY encoded.
+// Exposed data encodings. It is the encoding of the data read from the file,.
+// Rather than the encoding of the data in the file. E.g., the data encoded as.
+// RLE_DICTIONARY in the file can be read as dictionary indices by RLE.
+// Decoding, in which case the data read from the file is DICTIONARY encoded.
 enum class ExposedEncoding {
-  NO_ENCODING = 0, // data is not encoded, i.e. already decoded during reading
-  DICTIONARY = 1
+  kNoEncoding = 0, // data is not encoded, i.e. already decoded during reading
+  kDictionary = 1
 };
 
-/// \brief Return true if Parquet supports indicated compression type
+/// \brief Return true if Parquet supports indicated compression type.
 PARQUET_EXPORT
-bool IsCodecSupported(Compression::type codec);
+bool isCodecSupported(Compression::type codec);
 
 PARQUET_EXPORT
-std::unique_ptr<util::Codec> GetCodec(Compression::type codec);
+std::unique_ptr<util::Codec> getCodec(Compression::type codec);
 
 PARQUET_EXPORT
-std::unique_ptr<util::Codec> GetCodec(
+std::unique_ptr<util::Codec> getCodec(
     Compression::type codec,
-    const util::CodecOptions& codec_options);
+    const util::CodecOptions& codecOptions);
 
 PARQUET_EXPORT
-std::unique_ptr<util::Codec> GetCodec(
+std::unique_ptr<util::Codec> getCodec(
     Compression::type codec,
-    int compression_level);
+    int compressionLevel);
 
 struct ParquetCipher {
-  enum type { AES_GCM_V1 = 0, AES_GCM_CTR_V1 = 1 };
+  enum type { kAesGcmV1 = 0, kAesGcmCtrV1 = 1 };
 };
 
 struct AadMetadata {
-  std::string aad_prefix;
-  std::string aad_file_unique;
-  bool supply_aad_prefix;
+  std::string aadPrefix;
+  std::string aadFileUnique;
+  bool supplyAadPrefix;
 };
 
 struct EncryptionAlgorithm {
@@ -539,71 +538,69 @@ struct EncryptionAlgorithm {
   AadMetadata aad;
 };
 
-// parquet::PageType
+// Parquet::PageType.
 struct PageType {
   enum type {
-    DATA_PAGE,
-    INDEX_PAGE,
-    DICTIONARY_PAGE,
-    DATA_PAGE_V2,
-    // Should always be last element
-    UNDEFINED
+    kDataPage,
+    kIndexPage,
+    kDictionaryPage,
+    kDataPageV2,
+    // Should always be last element.
+    kUndefined
   };
 };
 
-bool PageCanUseChecksum(PageType::type pageType);
+bool pageCanUseChecksum(PageType::type pageType);
 
 class ColumnOrder {
  public:
-  enum type { UNDEFINED, TYPE_DEFINED_ORDER };
-  explicit ColumnOrder(ColumnOrder::type column_order)
-      : column_order_(column_order) {}
-  // Default to Type Defined Order
-  ColumnOrder() : column_order_(type::TYPE_DEFINED_ORDER) {}
-  ColumnOrder::type get_order() {
-    return column_order_;
+  enum type { kUndefined, kTypeDefinedOrder };
+  explicit ColumnOrder(ColumnOrder::type order) : columnOrder_(order) {}
+  // Default to Type Defined Order.
+  ColumnOrder() : columnOrder_(type::kTypeDefinedOrder) {}
+  ColumnOrder::type order() const {
+    return columnOrder_;
   }
 
   static ColumnOrder undefined_;
-  static ColumnOrder type_defined_;
+  static ColumnOrder typeDefined_;
 
  private:
-  ColumnOrder::type column_order_;
+  ColumnOrder::type columnOrder_;
 };
 
-/// \brief BoundaryOrder is a proxy around
-/// facebook::velox::parquet::thrift::BoundaryOrder.
+/// \brief BoundaryOrder is a proxy around.
+/// Facebook::velox::parquet::thrift::BoundaryOrder.
 struct BoundaryOrder {
   enum type {
-    Unordered = 0,
-    Ascending = 1,
-    Descending = 2,
-    // Should always be last element
-    UNDEFINED = 3
+    kUnordered = 0,
+    kAscending = 1,
+    kDescending = 2,
+    // Should always be last element.
+    kUndefined = 3
   };
 };
 
-/// \brief SortingColumn is a proxy around
-/// facebook::velox::parquet::thrift::SortingColumn.
+/// \brief SortingColumn is a proxy around.
+/// Facebook::velox::parquet::thrift::SortingColumn.
 struct PARQUET_EXPORT SortingColumn {
   // The column index (in this row group)
-  int32_t column_idx;
+  int32_t columnIdx;
 
   // If true, indicates this column is sorted in descending order.
   bool descending;
 
-  // If true, nulls will come before non-null values, otherwise, nulls go at the
-  // end.
-  bool nulls_first;
+  // If true, nulls will come before non-null values, otherwise, nulls go at
+  // the. End.
+  bool nullsFirst;
 };
 
 inline bool operator==(const SortingColumn& left, const SortingColumn& right) {
-  return left.nulls_first == right.nulls_first &&
-      left.descending == right.descending &&
-      left.column_idx == right.column_idx;
+  return left.nullsFirst == right.nullsFirst &&
+      left.descending == right.descending && left.columnIdx == right.columnIdx;
 }
 
-// ----------------------------------------------------------------------
+// ----------------------------------------------------------------------.
 
 struct ByteArray {
   ByteArray() : len(0), ptr(NULLPTR) {}
@@ -637,11 +634,11 @@ using FLBA = FixedLenByteArray;
 
 // Julian day at unix epoch.
 //
-// The Julian Day Number (JDN) is the integer assigned to a whole solar day in
-// the Julian day count starting from noon Universal time, with Julian day
-// number 0 assigned to the day starting at noon on Monday, January 1, 4713 BC,
-// proleptic Julian calendar (November 24, 4714 BC, in the proleptic Gregorian
-// calendar),
+// The Julian Day Number (JDN) is the integer assigned to a whole solar day in.
+// The Julian day count starting from noon Universal time, with Julian day.
+// Number 0 assigned to the day starting at noon on Monday, January 1, 4713 BC,.
+// Proleptic Julian calendar (November 24, 4714 BC, in the proleptic Gregorian.
+// Calendar),.
 constexpr int64_t kJulianToUnixEpochDays = INT64_C(2440588);
 constexpr int64_t kSecondsPerDay = INT64_C(60 * 60 * 24);
 constexpr int64_t kMillisecondsPerDay = kSecondsPerDay * INT64_C(1000);
@@ -657,24 +654,24 @@ inline bool operator==(const Int96& left, const Int96& right) {
   return std::equal(left.value, left.value + 3, right.value);
 }
 
-static inline std::string ByteArrayToString(const ByteArray& a) {
+static inline std::string byteArrayToString(const ByteArray& a) {
   return std::string(reinterpret_cast<const char*>(a.ptr), a.len);
 }
 
-static inline void Int96SetNanoSeconds(Int96& i96, int64_t nanoseconds) {
+static inline void int96SetNanoSeconds(Int96& i96, int64_t nanoseconds) {
   std::memcpy(&i96.value, &nanoseconds, sizeof(nanoseconds));
 }
 
 struct DecodedInt96 {
-  uint64_t days_since_epoch;
+  uint64_t daysSinceEpoch;
   uint64_t nanoseconds;
 };
 
-static inline DecodedInt96 DecodeInt96Timestamp(const Int96& i96) {
-  // We do the computations in the unsigned domain to avoid unsigned behaviour
-  // on overflow.
+static inline DecodedInt96 decodeInt96Timestamp(const Int96& i96) {
+  // We do the computations in the unsigned domain to avoid unsigned behaviour.
+  // On overflow.
   DecodedInt96 result;
-  result.days_since_epoch =
+  result.daysSinceEpoch =
       i96.value[2] - static_cast<uint64_t>(kJulianToUnixEpochDays);
   result.nanoseconds = 0;
 
@@ -682,40 +679,40 @@ static inline DecodedInt96 DecodeInt96Timestamp(const Int96& i96) {
   return result;
 }
 
-static inline int64_t Int96GetNanoSeconds(const Int96& i96) {
-  const auto decoded = DecodeInt96Timestamp(i96);
+static inline int64_t int96GetNanoSeconds(const Int96& i96) {
+  const auto decoded = decodeInt96Timestamp(i96);
   return static_cast<int64_t>(
-      decoded.days_since_epoch * kNanosecondsPerDay + decoded.nanoseconds);
+      decoded.daysSinceEpoch * kNanosecondsPerDay + decoded.nanoseconds);
 }
 
-static inline int64_t Int96GetMicroSeconds(const Int96& i96) {
-  const auto decoded = DecodeInt96Timestamp(i96);
+static inline int64_t int96GetMicroSeconds(const Int96& i96) {
+  const auto decoded = decodeInt96Timestamp(i96);
   uint64_t microseconds = decoded.nanoseconds / static_cast<uint64_t>(1000);
   return static_cast<int64_t>(
-      decoded.days_since_epoch * kMicrosecondsPerDay + microseconds);
+      decoded.daysSinceEpoch * kMicrosecondsPerDay + microseconds);
 }
 
-static inline int64_t Int96GetMilliSeconds(const Int96& i96) {
-  const auto decoded = DecodeInt96Timestamp(i96);
+static inline int64_t int96GetMilliSeconds(const Int96& i96) {
+  const auto decoded = decodeInt96Timestamp(i96);
   uint64_t milliseconds = decoded.nanoseconds / static_cast<uint64_t>(1000000);
   return static_cast<int64_t>(
-      decoded.days_since_epoch * kMillisecondsPerDay + milliseconds);
+      decoded.daysSinceEpoch * kMillisecondsPerDay + milliseconds);
 }
 
-static inline int64_t Int96GetSeconds(const Int96& i96) {
-  const auto decoded = DecodeInt96Timestamp(i96);
+static inline int64_t int96GetSeconds(const Int96& i96) {
+  const auto decoded = decodeInt96Timestamp(i96);
   uint64_t seconds = decoded.nanoseconds / static_cast<uint64_t>(1000000000);
   return static_cast<int64_t>(
-      decoded.days_since_epoch * kSecondsPerDay + seconds);
+      decoded.daysSinceEpoch * kSecondsPerDay + seconds);
 }
 
-static inline std::string Int96ToString(const Int96& a) {
+static inline std::string int96ToString(const Int96& a) {
   std::ostringstream result;
   std::copy(a.value, a.value + 3, std::ostream_iterator<uint32_t>(result, " "));
   return result.str();
 }
 
-static inline std::string FixedLenByteArrayToString(
+static inline std::string fixedLenByteArrayToString(
     const FixedLenByteArray& a,
     int len) {
   std::ostringstream result;
@@ -724,115 +721,115 @@ static inline std::string FixedLenByteArrayToString(
 }
 
 template <Type::type TYPE>
-struct type_traits {};
+struct TypeTraits {};
 
 template <>
-struct type_traits<Type::BOOLEAN> {
-  using value_type = bool;
+struct TypeTraits<Type::kBoolean> {
+  using ValueType = bool;
 
-  static constexpr int value_byte_size = 1;
-  static constexpr const char* printf_code = "d";
+  static constexpr int valueByteSize = 1;
+  static constexpr const char* printfCode = "d";
 };
 
 template <>
-struct type_traits<Type::INT32> {
-  using value_type = int32_t;
+struct TypeTraits<Type::kInt32> {
+  using ValueType = int32_t;
 
-  static constexpr int value_byte_size = 4;
-  static constexpr const char* printf_code = "d";
+  static constexpr int valueByteSize = 4;
+  static constexpr const char* printfCode = "d";
 };
 
 template <>
-struct type_traits<Type::INT64> {
-  using value_type = int64_t;
+struct TypeTraits<Type::kInt64> {
+  using ValueType = int64_t;
 
-  static constexpr int value_byte_size = 8;
-  static constexpr const char* printf_code =
+  static constexpr int valueByteSize = 8;
+  static constexpr const char* printfCode =
       (sizeof(long) == 64) ? "ld" : "lld"; // NOLINT: runtime/int
 };
 
 template <>
-struct type_traits<Type::INT96> {
-  using value_type = Int96;
+struct TypeTraits<Type::kInt96> {
+  using ValueType = Int96;
 
-  static constexpr int value_byte_size = 12;
-  static constexpr const char* printf_code = "s";
+  static constexpr int valueByteSize = 12;
+  static constexpr const char* printfCode = "s";
 };
 
 template <>
-struct type_traits<Type::FLOAT> {
-  using value_type = float;
+struct TypeTraits<Type::kFloat> {
+  using ValueType = float;
 
-  static constexpr int value_byte_size = 4;
-  static constexpr const char* printf_code = "f";
+  static constexpr int valueByteSize = 4;
+  static constexpr const char* printfCode = "f";
 };
 
 template <>
-struct type_traits<Type::DOUBLE> {
-  using value_type = double;
+struct TypeTraits<Type::kDouble> {
+  using ValueType = double;
 
-  static constexpr int value_byte_size = 8;
-  static constexpr const char* printf_code = "lf";
+  static constexpr int valueByteSize = 8;
+  static constexpr const char* printfCode = "lf";
 };
 
 template <>
-struct type_traits<Type::BYTE_ARRAY> {
-  using value_type = ByteArray;
+struct TypeTraits<Type::kByteArray> {
+  using ValueType = ByteArray;
 
-  static constexpr int value_byte_size = sizeof(ByteArray);
-  static constexpr const char* printf_code = "s";
+  static constexpr int valueByteSize = sizeof(ByteArray);
+  static constexpr const char* printfCode = "s";
 };
 
 template <>
-struct type_traits<Type::FIXED_LEN_BYTE_ARRAY> {
-  using value_type = FixedLenByteArray;
+struct TypeTraits<Type::kFixedLenByteArray> {
+  using ValueType = FixedLenByteArray;
 
-  static constexpr int value_byte_size = sizeof(FixedLenByteArray);
-  static constexpr const char* printf_code = "s";
+  static constexpr int valueByteSize = sizeof(FixedLenByteArray);
+  static constexpr const char* printfCode = "s";
 };
 
 template <Type::type TYPE>
 struct PhysicalType {
-  using c_type = typename type_traits<TYPE>::value_type;
-  static constexpr Type::type type_num = TYPE;
+  using CType = typename TypeTraits<TYPE>::ValueType;
+  static constexpr Type::type typeNum = TYPE;
 };
 
-using BooleanType = PhysicalType<Type::BOOLEAN>;
-using Int32Type = PhysicalType<Type::INT32>;
-using Int64Type = PhysicalType<Type::INT64>;
-using Int96Type = PhysicalType<Type::INT96>;
-using FloatType = PhysicalType<Type::FLOAT>;
-using DoubleType = PhysicalType<Type::DOUBLE>;
-using ByteArrayType = PhysicalType<Type::BYTE_ARRAY>;
-using FLBAType = PhysicalType<Type::FIXED_LEN_BYTE_ARRAY>;
+using BooleanType = PhysicalType<Type::kBoolean>;
+using Int32Type = PhysicalType<Type::kInt32>;
+using Int64Type = PhysicalType<Type::kInt64>;
+using Int96Type = PhysicalType<Type::kInt96>;
+using FloatType = PhysicalType<Type::kFloat>;
+using DoubleType = PhysicalType<Type::kDouble>;
+using ByteArrayType = PhysicalType<Type::kByteArray>;
+using FLBAType = PhysicalType<Type::kFixedLenByteArray>;
 
 template <typename Type>
-inline std::string format_fwf(int width) {
+inline std::string formatFwf(int width) {
   std::stringstream ss;
-  ss << "%-" << width << type_traits<Type::type_num>::printf_code;
+  ss << "%-" << width << TypeTraits<Type::typeNum>::printfCode;
   return ss.str();
 }
 
-PARQUET_EXPORT std::string EncodingToString(Encoding::type t);
+PARQUET_EXPORT std::string encodingToString(Encoding::type t);
 
-PARQUET_EXPORT std::string ConvertedTypeToString(ConvertedType::type t);
+PARQUET_EXPORT std::string convertedTypeToString(ConvertedType::type t);
 
-PARQUET_EXPORT std::string TypeToString(Type::type t);
+PARQUET_EXPORT std::string typeToString(Type::type t);
 
-PARQUET_EXPORT std::string FormatStatValue(
-    Type::type parquet_type,
+PARQUET_EXPORT std::string formatStatValue(
+    Type::type parquetType,
     ::std::string_view val);
 
-PARQUET_EXPORT int GetTypeByteSize(Type::type t);
+PARQUET_EXPORT int getTypeByteSize(Type::type t);
 
-PARQUET_EXPORT SortOrder::type DefaultSortOrder(Type::type primitive);
+PARQUET_EXPORT SortOrder::type defaultSortOrder(Type::type primitive);
 
-PARQUET_EXPORT SortOrder::type GetSortOrder(
+PARQUET_EXPORT SortOrder::type getSortOrder(
     ConvertedType::type converted,
     Type::type primitive);
 
-PARQUET_EXPORT SortOrder::type GetSortOrder(
-    const std::shared_ptr<const LogicalType>& logical_type,
+PARQUET_EXPORT SortOrder::type getSortOrder(
+    const std::shared_ptr<const LogicalType>& logicalType,
     Type::type primitive);
 
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/Writer.cpp b/velox/dwio/parquet/writer/arrow/Writer.cpp
index e6572bb764d..1d078d8bb7b 100644
--- a/velox/dwio/parquet/writer/arrow/Writer.cpp
+++ b/velox/dwio/parquet/writer/arrow/Writer.cpp
@@ -75,233 +75,232 @@ using schema::GroupNode;
 
 namespace {
 
-int CalculateLeafCount(const DataType* type) {
+int calculateLeafCount(const DataType* type) {
   if (type->id() == ::arrow::Type::EXTENSION) {
     type = checked_cast<const ExtensionType&>(*type).storage_type().get();
   }
-  // Note num_fields() can be 0 for an empty struct type
+  // Note numFields() can be 0 for an empty struct type.
   if (!::arrow::is_nested(type->id())) {
     // Primitive type.
     return 1;
   }
 
-  int num_leaves = 0;
+  int numLeaves = 0;
   for (const auto& field : type->fields()) {
-    num_leaves += CalculateLeafCount(field->type().get());
+    numLeaves += calculateLeafCount(field->type().get());
   }
-  return num_leaves;
+  return numLeaves;
 }
 
 // Determines if the |schema_field|'s root ancestor is nullable.
-bool HasNullableRoot(
-    const SchemaManifest& schema_manifest,
-    const SchemaField* schema_field) {
-  VELOX_DCHECK_NOT_NULL(schema_field);
-  const SchemaField* current_field = schema_field;
-  bool nullable = schema_field->field->nullable();
-  while (current_field != nullptr) {
-    nullable = current_field->field->nullable();
-    current_field = schema_manifest.GetParent(current_field);
+bool hasNullableRoot(
+    const SchemaManifest& schemaManifest,
+    const SchemaField* schemaField) {
+  VELOX_DCHECK_NOT_NULL(schemaField);
+  const SchemaField* currentField = schemaField;
+  bool nullable = schemaField->field->nullable();
+  while (currentField != nullptr) {
+    nullable = currentField->field->nullable();
+    currentField = schemaManifest.getParent(currentField);
   }
   return nullable;
 }
 
-// Manages writing nested parquet columns with support for all nested types
-// supported by parquet.
+// Manages writing nested parquet columns with support for all nested types.
+// Supported by Parquet.
 class ArrowColumnWriterV2 {
  public:
-  // Constructs a new object (use Make() method below to construct from
-  // A ChunkedArray).
-  // level_builders should contain one MultipathLevelBuilder per chunk of the
-  // Arrow-column to write.
+  // Constructs a new object (use make() method below to construct from
+  // a ChunkedArray).
+  // LevelBuilders should contain one MultipathLevelBuilder per chunk of the
+  // arrow-column to write.
   ArrowColumnWriterV2(
-      std::vector<std::unique_ptr<MultipathLevelBuilder>> level_builders,
-      int start_leaf_column_index,
-      int leaf_count,
-      RowGroupWriter* row_group_writer)
-      : level_builders_(std::move(level_builders)),
-        start_leaf_column_index_(start_leaf_column_index),
-        leaf_count_(leaf_count),
-        row_group_writer_(row_group_writer) {}
-
-  // Writes out all leaf parquet columns to the RowGroupWriter that this
+      std::vector<std::unique_ptr<MultipathLevelBuilder>> levelBuilders,
+      int startLeafColumnIndex,
+      int leafCount,
+      RowGroupWriter* rowGroupWriter)
+      : levelBuilders_(std::move(levelBuilders)),
+        startLeafColumnIndex_(startLeafColumnIndex),
+        leafCount_(leafCount),
+        rowGroupWriter_(rowGroupWriter) {}
+
+  // Writes out all leaf Parquet columns to the rowGroupWriter that this
   // object was constructed with.  Each leaf column is written fully before
   // the next column is written (i.e. no buffering is assumed).
   //
   // Columns are written in DFS order.
-  Status Write(ArrowWriteContext* ctx) {
-    for (int leaf_idx = 0; leaf_idx < leaf_count_; leaf_idx++) {
-      ColumnWriter* column_writer;
-      if (row_group_writer_->buffered()) {
-        const int column_index = start_leaf_column_index_ + leaf_idx;
+  Status write(ArrowWriteContext* ctx) {
+    for (int leafIdx = 0; leafIdx < leafCount_; leafIdx++) {
+      ColumnWriter* columnWriter;
+      if (rowGroupWriter_->buffered()) {
+        const int columnIndex = startLeafColumnIndex_ + leafIdx;
         PARQUET_CATCH_NOT_OK(
-            column_writer = row_group_writer_->column(column_index));
+            columnWriter = rowGroupWriter_->column(columnIndex));
       } else {
-        PARQUET_CATCH_NOT_OK(column_writer = row_group_writer_->NextColumn());
+        PARQUET_CATCH_NOT_OK(columnWriter = rowGroupWriter_->nextColumn());
       }
-      for (auto& level_builder : level_builders_) {
-        RETURN_NOT_OK(level_builder->Write(
-            leaf_idx, ctx, [&](const MultipathLevelBuilderResult& result) {
-              size_t visited_component_size =
-                  result.post_list_visited_elements.size();
-              VELOX_DCHECK_GT(visited_component_size, 0);
-              if (visited_component_size != 1) {
+      for (auto& levelBuilder : levelBuilders_) {
+        RETURN_NOT_OK(levelBuilder->write(
+            leafIdx, ctx, [&](const MultipathLevelBuilderResult& result) {
+              size_t visitedComponentSize =
+                  result.postListVisitedElements.size();
+              VELOX_DCHECK_GT(visitedComponentSize, 0);
+              if (visitedComponentSize != 1) {
                 return Status::NotImplemented(
                     "Lists with non-zero length null components are not supported");
               }
-              const ElementRange& range = result.post_list_visited_elements[0];
-              std::shared_ptr<Array> values_array =
-                  result.leaf_array->Slice(range.start, range.Size());
-
-              return column_writer->WriteArrow(
-                  result.def_levels,
-                  result.rep_levels,
-                  result.def_rep_level_count,
-                  *values_array,
+              const ElementRange& range = result.postListVisitedElements[0];
+              std::shared_ptr<Array> valuesArray =
+                  result.leafArray->Slice(range.start, range.size());
+
+              return columnWriter->writeArrow(
+                  result.defLevels,
+                  result.repLevels,
+                  result.defRepLevelCount,
+                  *valuesArray,
                   ctx,
-                  result.leaf_is_nullable);
+                  result.leafIsNullable);
             }));
       }
 
-      if (!row_group_writer_->buffered()) {
-        PARQUET_CATCH_NOT_OK(column_writer->Close());
+      if (!rowGroupWriter_->buffered()) {
+        PARQUET_CATCH_NOT_OK(columnWriter->close());
       }
     }
     return Status::OK();
   }
 
-  // Make a new object by converting each chunk in |data| to a
   // MultipathLevelBuilder.
   //
   // It is necessary to create a new builder per array because the
   // MultipathlevelBuilder extracts the data necessary for writing each leaf
-  // column at construction time. (it optimizes based on null count) and with
+  // column at construction time (it optimizes based on null count) and with
   // slicing via |offset| ephemeral chunks are created which need to be tracked
-  // across each leaf column-write. This decision could potentially be revisited
-  // if we wanted to use "buffered" RowGroupWriters (we could construct each
-  // builder on demand in that case).
-  static ::arrow::Result<std::unique_ptr<ArrowColumnWriterV2>> Make(
+  // across each leaf column-write. This decision could potentially be
+  // revisited if we wanted to use "buffered" RowGroupWriters (we could
+  // construct each builder on demand in that case).
+  static ::arrow::Result<std::unique_ptr<ArrowColumnWriterV2>> make(
       const ChunkedArray& data,
       int64_t offset,
       const int64_t size,
-      const SchemaManifest& schema_manifest,
-      RowGroupWriter* row_group_writer,
-      int start_leaf_column_index = -1) {
-    int64_t absolute_position = 0;
-    int chunk_index = 0;
-    int64_t chunk_offset = 0;
+      const SchemaManifest& schemaManifest,
+      RowGroupWriter* rowGroupWriter,
+      int startLeafColumnIndex = -1) {
+    int64_t absolutePosition = 0;
+    int chunkIndex = 0;
+    int64_t chunkOffset = 0;
     if (data.length() == 0) {
       return std::make_unique<ArrowColumnWriterV2>(
           std::vector<std::unique_ptr<MultipathLevelBuilder>>{},
-          start_leaf_column_index,
-          CalculateLeafCount(data.type().get()),
-          row_group_writer);
+          startLeafColumnIndex,
+          calculateLeafCount(data.type().get()),
+          rowGroupWriter);
     }
-    while (chunk_index < data.num_chunks() && absolute_position < offset) {
-      const int64_t chunk_length = data.chunk(chunk_index)->length();
-      if (absolute_position + chunk_length > offset) {
+    while (chunkIndex < data.num_chunks() && absolutePosition < offset) {
+      const int64_t chunkLength = data.chunk(chunkIndex)->length();
+      if (absolutePosition + chunkLength > offset) {
         // Relative offset into the chunk to reach the desired start offset for
-        // writing
-        chunk_offset = offset - absolute_position;
+        // writing.
+        chunkOffset = offset - absolutePosition;
         break;
       } else {
-        ++chunk_index;
-        absolute_position += chunk_length;
+        ++chunkIndex;
+        absolutePosition += chunkLength;
       }
     }
 
-    if (absolute_position >= data.length()) {
+    if (absolutePosition >= data.length()) {
       return Status::Invalid(
           "Cannot write data at offset past end of chunked array");
     }
 
-    int64_t values_written = 0;
+    int64_t valuesWritten = 0;
     std::vector<std::unique_ptr<MultipathLevelBuilder>> builders;
-    const int leaf_count = CalculateLeafCount(data.type().get());
-    bool is_nullable = false;
+    const int leafCount = calculateLeafCount(data.type().get());
+    bool isNullable = false;
 
-    int column_index = 0;
-    if (row_group_writer->buffered()) {
-      column_index = start_leaf_column_index;
+    int columnIndex = 0;
+    if (rowGroupWriter->buffered()) {
+      columnIndex = startLeafColumnIndex;
     } else {
-      // The row_group_writer hasn't been advanced yet so add 1 to the current
+      // The rowGroupWriter hasn't been advanced yet so add 1 to the current
       // which is the one this instance will start writing for.
-      column_index = row_group_writer->current_column() + 1;
+      columnIndex = rowGroupWriter->currentColumn() + 1;
     }
 
-    for (int leaf_offset = 0; leaf_offset < leaf_count; ++leaf_offset) {
-      const SchemaField* schema_field = nullptr;
-      RETURN_NOT_OK(schema_manifest.GetColumnField(
-          column_index + leaf_offset, &schema_field));
-      bool nullable_root = HasNullableRoot(schema_manifest, schema_field);
-      if (leaf_offset == 0) {
-        is_nullable = nullable_root;
+    for (int leafOffset = 0; leafOffset < leafCount; ++leafOffset) {
+      const SchemaField* schemaField = nullptr;
+      RETURN_NOT_OK(schemaManifest.getColumnField(
+          columnIndex + leafOffset, &schemaField));
+      bool nullableRoot = hasNullableRoot(schemaManifest, schemaField);
+      if (leafOffset == 0) {
+        isNullable = nullableRoot;
       }
 
 // Don't validate common ancestry for all leafs if not in debug.
 #ifndef NDEBUG
       break;
 #else
-      if (is_nullable != nullable_root) {
+      if (isNullable != nullableRoot) {
         return Status::UnknownError(
             "Unexpected mismatched nullability between column index",
-            column_index + leaf_offset,
+            columnIndex + leafOffset,
             " and ",
-            column_index);
+            columnIndex);
       }
 #endif
     }
-    while (values_written < size) {
-      const Array& chunk = *data.chunk(chunk_index);
-      const int64_t available_values = chunk.length() - chunk_offset;
-      const int64_t chunk_write_size =
-          std::min(size - values_written, available_values);
+    while (valuesWritten < size) {
+      const Array& chunk = *data.chunk(chunkIndex);
+      const int64_t availableValues = chunk.length() - chunkOffset;
+      const int64_t chunkWriteSize =
+          std::min(size - valuesWritten, availableValues);
 
       // The chunk offset here will be 0 except for possibly the first chunk
-      // because of the advancing logic above
-      std::shared_ptr<Array> array_to_write =
-          chunk.Slice(chunk_offset, chunk_write_size);
+      // because of the advancing logic above.
+      std::shared_ptr<Array> arrayToWrite =
+          chunk.Slice(chunkOffset, chunkWriteSize);
 
-      if (array_to_write->length() > 0) {
+      if (arrayToWrite->length() > 0) {
         ARROW_ASSIGN_OR_RAISE(
             std::unique_ptr<MultipathLevelBuilder> builder,
-            MultipathLevelBuilder::Make(*array_to_write, is_nullable));
-        if (leaf_count != builder->GetLeafCount()) {
+            MultipathLevelBuilder::make(*arrayToWrite, isNullable));
+        if (leafCount != builder->getLeafCount()) {
           return Status::UnknownError(
               "data type leaf_count != builder_leaf_count",
-              leaf_count,
+              leafCount,
               " ",
-              builder->GetLeafCount());
+              builder->getLeafCount());
         }
         builders.emplace_back(std::move(builder));
       }
 
-      if (chunk_write_size == available_values) {
-        chunk_offset = 0;
-        ++chunk_index;
+      if (chunkWriteSize == availableValues) {
+        chunkOffset = 0;
+        ++chunkIndex;
       }
-      values_written += chunk_write_size;
+      valuesWritten += chunkWriteSize;
     }
     return std::make_unique<ArrowColumnWriterV2>(
-        std::move(builders), column_index, leaf_count, row_group_writer);
+        std::move(builders), columnIndex, leafCount, rowGroupWriter);
   }
 
-  int leaf_count() const {
-    return leaf_count_;
+  int leafCount() const {
+    return leafCount_;
   }
 
  private:
   // One builder per column-chunk.
-  std::vector<std::unique_ptr<MultipathLevelBuilder>> level_builders_;
-  int start_leaf_column_index_;
-  int leaf_count_;
-  RowGroupWriter* row_group_writer_;
+  std::vector<std::unique_ptr<MultipathLevelBuilder>> levelBuilders_;
+  int startLeafColumnIndex_;
+  int leafCount_;
+  RowGroupWriter* rowGroupWriter_;
 };
 
 } // namespace
 
 // ----------------------------------------------------------------------
-// FileWriter implementation
+// FileWriter implementation.
 
 class FileWriterImpl : public FileWriter {
  public:
@@ -309,94 +308,93 @@ class FileWriterImpl : public FileWriter {
       std::shared_ptr<::arrow::Schema> schema,
       MemoryPool* pool,
       std::unique_ptr<ParquetFileWriter> writer,
-      std::shared_ptr<ArrowWriterProperties> arrow_properties)
+      std::shared_ptr<ArrowWriterProperties> arrowProperties)
       : schema_(std::move(schema)),
         writer_(std::move(writer)),
-        row_group_writer_(nullptr),
-        column_write_context_(pool, arrow_properties.get()),
-        arrow_properties_(std::move(arrow_properties)),
+        rowGroupWriter_(nullptr),
+        columnWriteContext_(pool, arrowProperties.get()),
+        arrowProperties_(std::move(arrowProperties)),
         closed_(false) {
-    if (arrow_properties_->use_threads()) {
-      parallel_column_write_contexts_.reserve(schema_->num_fields());
+    if (arrowProperties_->useThreads()) {
+      parallelColumnWriteContexts_.reserve(schema_->num_fields());
       for (int i = 0; i < schema_->num_fields(); ++i) {
         // Explicitly create each ArrowWriteContext object to avoid
-        // unintentional call of the copy constructor. Otherwise, the buffers in
-        // the type of sharad_ptr will be shared among all contexts.
-        parallel_column_write_contexts_.emplace_back(
-            pool, arrow_properties_.get());
+        // unintentional call of the copy constructor. Otherwise, the buffers
+        // in the type of shared_ptr will be shared among all contexts.
+        parallelColumnWriteContexts_.emplace_back(pool, arrowProperties_.get());
       }
     }
   }
 
-  Status Init() {
-    return SchemaManifest::Make(
+  Status init() {
+    return SchemaManifest::make(
         writer_->schema(),
-        /*schema_metadata=*/nullptr,
-        default_arrow_reader_properties(),
-        &schema_manifest_);
+        nullptr,
+        defaultArrowReaderProperties(),
+        &schemaManifest_);
   }
 
-  Status NewRowGroup(int64_t chunk_size) override {
-    if (row_group_writer_ != nullptr) {
-      PARQUET_CATCH_NOT_OK(row_group_writer_->Close());
+  Status newRowGroup(int64_t chunkSize) override {
+    if (rowGroupWriter_ != nullptr) {
+      PARQUET_CATCH_NOT_OK(rowGroupWriter_->close());
     }
-    PARQUET_CATCH_NOT_OK(row_group_writer_ = writer_->AppendRowGroup());
+    PARQUET_CATCH_NOT_OK(rowGroupWriter_ = writer_->appendRowGroup());
     return Status::OK();
   }
 
-  Status Close() override {
+  Status close() override {
     if (!closed_) {
-      // Make idempotent
+      // Make idempotent.
       closed_ = true;
-      if (row_group_writer_ != nullptr) {
-        PARQUET_CATCH_NOT_OK(row_group_writer_->Close());
+      if (rowGroupWriter_ != nullptr) {
+        PARQUET_CATCH_NOT_OK(rowGroupWriter_->close());
       }
-      PARQUET_CATCH_NOT_OK(writer_->Close());
+      PARQUET_CATCH_NOT_OK(writer_->close());
     }
     return Status::OK();
   }
 
-  Status WriteColumnChunk(const Array& data) override {
+  Status writeColumnChunk(const Array& data) override {
     // A bit awkward here since cannot instantiate ChunkedArray from const
-    // Array&
+    // Array&.
     auto chunk = ::arrow::MakeArray(data.data());
-    auto chunked_array = std::make_shared<::arrow::ChunkedArray>(chunk);
-    return WriteColumnChunk(chunked_array, 0, data.length());
+    auto chunkedArray = std::make_shared<::arrow::ChunkedArray>(chunk);
+    return writeColumnChunk(chunkedArray, 0, data.length());
   }
 
-  Status WriteColumnChunk(
+  Status writeColumnChunk(
       const std::shared_ptr<ChunkedArray>& data,
       int64_t offset,
       int64_t size) override {
-    if (arrow_properties_->engine_version() == ArrowWriterProperties::V2 ||
-        arrow_properties_->engine_version() == ArrowWriterProperties::V1) {
-      if (row_group_writer_->buffered()) {
+    if (arrowProperties_->engineVersion() == ArrowWriterProperties::V2 ||
+        arrowProperties_->engineVersion() == ArrowWriterProperties::V1) {
+      if (rowGroupWriter_->buffered()) {
         return Status::Invalid(
             "Cannot write column chunk into the buffered row group.");
       }
       ARROW_ASSIGN_OR_RAISE(
           std::unique_ptr<ArrowColumnWriterV2> writer,
-          ArrowColumnWriterV2::Make(
-              *data, offset, size, schema_manifest_, row_group_writer_));
-      return writer->Write(&column_write_context_);
+          ArrowColumnWriterV2::make(
+              *data, offset, size, schemaManifest_, rowGroupWriter_));
+      return writer->write(&columnWriteContext_);
     }
 
     return Status::NotImplemented("Unknown engine version.");
   }
 
-  Status WriteColumnChunk(
+  Status writeColumnChunk(
       const std::shared_ptr<::arrow::ChunkedArray>& data) override {
-    return WriteColumnChunk(data, 0, data->length());
+    return writeColumnChunk(data, 0, data->length());
   }
 
   std::shared_ptr<::arrow::Schema> schema() const override {
     return schema_;
   }
 
-  Status WriteTable(const Table& table, int64_t chunk_size) override {
+  Status writeTable(const Table& table, int64_t chunkSize) override {
     RETURN_NOT_OK(table.Validate());
 
-    if (chunk_size <= 0 && table.num_rows() > 0) {
+    if (chunkSize <= 0 && table.num_rows() > 0) {
       return Status::Invalid("chunk size per row_group must be greater than 0");
     } else if (!table.schema()->Equals(*schema_, false)) {
       return Status::Invalid(
@@ -405,87 +403,86 @@ class FileWriterImpl : public FileWriter {
           "' this:'",
           schema_->ToString(),
           "'");
-    } else if (chunk_size > this->properties().max_row_group_length()) {
-      chunk_size = this->properties().max_row_group_length();
+    } else if (chunkSize > this->properties().maxRowGroupLength()) {
+      chunkSize = this->properties().maxRowGroupLength();
     }
 
-    auto WriteRowGroup = [&](int64_t offset, int64_t size) {
-      RETURN_NOT_OK(NewRowGroup(size));
+    auto writeRowGroup = [&](int64_t offset, int64_t size) {
+      RETURN_NOT_OK(newRowGroup(size));
       for (int i = 0; i < table.num_columns(); i++) {
-        RETURN_NOT_OK(WriteColumnChunk(table.column(i), offset, size));
+        RETURN_NOT_OK(writeColumnChunk(table.column(i), offset, size));
       }
       return Status::OK();
     };
 
     if (table.num_rows() == 0) {
-      // Append a row group with 0 rows
-      RETURN_NOT_OK_ELSE(WriteRowGroup(0, 0), PARQUET_IGNORE_NOT_OK(Close()));
+      // Append a row group with 0 rows.
+      RETURN_NOT_OK_ELSE(writeRowGroup(0, 0), PARQUET_IGNORE_NOT_OK(close()));
       return Status::OK();
     }
 
-    for (int chunk = 0; chunk * chunk_size < table.num_rows(); chunk++) {
-      int64_t offset = chunk * chunk_size;
+    for (int chunk = 0; chunk * chunkSize < table.num_rows(); chunk++) {
+      int64_t offset = chunk * chunkSize;
       RETURN_NOT_OK_ELSE(
-          WriteRowGroup(
-              offset, std::min(chunk_size, table.num_rows() - offset)),
-          PARQUET_IGNORE_NOT_OK(Close()));
+          writeRowGroup(offset, std::min(chunkSize, table.num_rows() - offset)),
+          PARQUET_IGNORE_NOT_OK(close()));
     }
     return Status::OK();
   }
 
-  Status NewBufferedRowGroup() override {
-    if (row_group_writer_ != nullptr) {
-      PARQUET_CATCH_NOT_OK(row_group_writer_->Close());
+  Status newBufferedRowGroup() override {
+    if (rowGroupWriter_ != nullptr) {
+      PARQUET_CATCH_NOT_OK(rowGroupWriter_->close());
     }
-    PARQUET_CATCH_NOT_OK(row_group_writer_ = writer_->AppendBufferedRowGroup());
+    PARQUET_CATCH_NOT_OK(rowGroupWriter_ = writer_->appendBufferedRowGroup());
     return Status::OK();
   }
 
-  Status WriteRecordBatch(const RecordBatch& batch) override {
+  Status writeRecordBatch(const RecordBatch& batch) override {
     if (batch.num_rows() == 0) {
       return Status::OK();
     }
 
     // Max number of rows allowed in a row group.
-    const int64_t max_row_group_length =
-        this->properties().max_row_group_length();
+    const int64_t maxRowGroupLength = this->properties().maxRowGroupLength();
 
-    if (row_group_writer_ == nullptr || !row_group_writer_->buffered() ||
-        row_group_writer_->num_rows() >= max_row_group_length) {
-      RETURN_NOT_OK(NewBufferedRowGroup());
+    if (rowGroupWriter_ == nullptr || !rowGroupWriter_->buffered() ||
+        rowGroupWriter_->numRows() >= maxRowGroupLength) {
+      RETURN_NOT_OK(newBufferedRowGroup());
     }
 
-    auto WriteBatch = [&](int64_t offset, int64_t size) {
+    auto writeBatch = [&](int64_t offset, int64_t size) {
       std::vector<std::unique_ptr<ArrowColumnWriterV2>> writers;
-      int column_index_start = 0;
+      int columnIndexStart = 0;
 
       for (int i = 0; i < batch.num_columns(); i++) {
-        ChunkedArray chunked_array{batch.column(i)};
+        ChunkedArray chunkedArray{batch.column(i)};
         ARROW_ASSIGN_OR_RAISE(
             std::unique_ptr<ArrowColumnWriterV2> writer,
-            ArrowColumnWriterV2::Make(
-                chunked_array,
+            ArrowColumnWriterV2::make(
+                chunkedArray,
                 offset,
                 size,
-                schema_manifest_,
-                row_group_writer_,
-                column_index_start));
-        column_index_start += writer->leaf_count();
-        if (arrow_properties_->use_threads()) {
+                schemaManifest_,
+                rowGroupWriter_,
+                columnIndexStart));
+        columnIndexStart += writer->leafCount();
+        if (arrowProperties_->useThreads()) {
           writers.emplace_back(std::move(writer));
         } else {
-          RETURN_NOT_OK(writer->Write(&column_write_context_));
+          RETURN_NOT_OK(writer->write(&columnWriteContext_));
         }
       }
 
-      if (arrow_properties_->use_threads()) {
-        VELOX_DCHECK_EQ(parallel_column_write_contexts_.size(), writers.size());
-        RETURN_NOT_OK(::arrow::internal::ParallelFor(
-            static_cast<int>(writers.size()),
-            [&](int i) {
-              return writers[i]->Write(&parallel_column_write_contexts_[i]);
-            },
-            arrow_properties_->executor()));
+      if (arrowProperties_->useThreads()) {
+        VELOX_DCHECK_EQ(parallelColumnWriteContexts_.size(), writers.size());
+        RETURN_NOT_OK(
+            ::arrow::internal::ParallelFor(
+                static_cast<int>(writers.size()),
+                [&](int i) {
+                  return writers[i]->write(&parallelColumnWriteContexts_[i]);
+                },
+                arrowProperties_->executor()));
       }
 
       return Status::OK();
@@ -493,15 +490,15 @@ class FileWriterImpl : public FileWriter {
 
     int64_t offset = 0;
     while (offset < batch.num_rows()) {
-      const int64_t batch_size = std::min(
-          max_row_group_length - row_group_writer_->num_rows(),
+      const int64_t batchSize = std::min(
+          maxRowGroupLength - rowGroupWriter_->numRows(),
           batch.num_rows() - offset);
-      RETURN_NOT_OK(WriteBatch(offset, batch_size));
-      offset += batch_size;
+      RETURN_NOT_OK(writeBatch(offset, batchSize));
+      offset += batchSize;
 
       // Flush current row group if it is full.
-      if (row_group_writer_->num_rows() >= max_row_group_length) {
-        RETURN_NOT_OK(NewBufferedRowGroup());
+      if (rowGroupWriter_->numRows() >= maxRowGroupLength) {
+        RETURN_NOT_OK(newBufferedRowGroup());
       }
     }
 
@@ -512,8 +509,8 @@ class FileWriterImpl : public FileWriter {
     return *writer_->properties();
   }
 
-  ::arrow::MemoryPool* memory_pool() const override {
-    return column_write_context_.memory_pool;
+  ::arrow::MemoryPool* memoryPool() const override {
+    return columnWriteContext_.memoryPool;
   }
 
   const std::shared_ptr<FileMetaData> metadata() const override {
@@ -525,36 +522,36 @@ class FileWriterImpl : public FileWriter {
 
   std::shared_ptr<::arrow::Schema> schema_;
 
-  SchemaManifest schema_manifest_;
+  SchemaManifest schemaManifest_;
 
   std::unique_ptr<ParquetFileWriter> writer_;
-  RowGroupWriter* row_group_writer_;
-  ArrowWriteContext column_write_context_;
-  std::shared_ptr<ArrowWriterProperties> arrow_properties_;
+  RowGroupWriter* rowGroupWriter_;
+  ArrowWriteContext columnWriteContext_;
+  std::shared_ptr<ArrowWriterProperties> arrowProperties_;
   bool closed_;
 
-  /// If arrow_properties_.use_threads() is true, the vector size is equal to
+  /// If arrowProperties_->useThreads() is true, the vector size is equal to
   /// schema_->num_fields() to make it thread-safe. Otherwise, the vector is
-  /// empty and column_write_context_ above is shared by all columns.
-  std::vector<ArrowWriteContext> parallel_column_write_contexts_;
+  /// empty and columnWriteContext_ above is shared by all columns.
+  std::vector<ArrowWriteContext> parallelColumnWriteContexts_;
 };
 
 FileWriter::~FileWriter() {}
 
-Status FileWriter::Make(
+Status FileWriter::make(
     ::arrow::MemoryPool* pool,
     std::unique_ptr<ParquetFileWriter> writer,
     std::shared_ptr<::arrow::Schema> schema,
-    std::shared_ptr<ArrowWriterProperties> arrow_properties,
+    std::shared_ptr<ArrowWriterProperties> arrowProperties,
     std::unique_ptr<FileWriter>* out) {
   std::unique_ptr<FileWriterImpl> impl(new FileWriterImpl(
-      std::move(schema), pool, std::move(writer), std::move(arrow_properties)));
-  RETURN_NOT_OK(impl->Init());
+      std::move(schema), pool, std::move(writer), std::move(arrowProperties)));
+  RETURN_NOT_OK(impl->init());
   *out = std::move(impl);
   return Status::OK();
 }
 
-Status FileWriter::Open(
+Status FileWriter::open(
     const ::arrow::Schema& schema,
     ::arrow::MemoryPool* pool,
     std::shared_ptr<::arrow::io::OutputStream> sink,
@@ -562,21 +559,21 @@ Status FileWriter::Open(
     std::unique_ptr<FileWriter>* writer) {
   ARROW_ASSIGN_OR_RAISE(
       *writer,
-      Open(
+      open(
           std::move(schema),
           pool,
           std::move(sink),
           std::move(properties),
-          default_arrow_writer_properties()));
+          defaultArrowWriterProperties()));
   return Status::OK();
 }
 
-Status GetSchemaMetadata(
+Status getSchemaMetadata(
     const ::arrow::Schema& schema,
     ::arrow::MemoryPool* pool,
     const ArrowWriterProperties& properties,
     std::shared_ptr<const KeyValueMetadata>* out) {
-  if (!properties.store_schema()) {
+  if (!properties.storeSchema()) {
     *out = nullptr;
     return Status::OK();
   }
@@ -593,102 +590,102 @@ Status GetSchemaMetadata(
       std::shared_ptr<Buffer> serialized,
       ::arrow::ipc::SerializeSchema(schema, pool));
 
-  // The serialized schema is not UTF-8, which is required for Thrift
-  std::string schema_as_string = serialized->ToString();
-  std::string schema_base64 = ::arrow::util::base64_encode(schema_as_string);
-  result->Append(kArrowSchemaKey, schema_base64);
+  // The serialized schema is not UTF-8, which is required for Thrift.
+  std::string schemaAsString = serialized->ToString();
+  std::string schemaBase64 = ::arrow::util::base64_encode(schemaAsString);
+  result->Append(kArrowSchemaKey, schemaBase64);
   *out = result;
   return Status::OK();
 }
 
-Status FileWriter::Open(
+Status FileWriter::open(
     const ::arrow::Schema& schema,
     ::arrow::MemoryPool* pool,
     std::shared_ptr<::arrow::io::OutputStream> sink,
     std::shared_ptr<WriterProperties> properties,
-    std::shared_ptr<ArrowWriterProperties> arrow_properties,
+    std::shared_ptr<ArrowWriterProperties> arrowProperties,
     std::unique_ptr<FileWriter>* writer) {
   ARROW_ASSIGN_OR_RAISE(
       *writer,
-      Open(
+      open(
           std::move(schema),
           pool,
           std::move(sink),
           std::move(properties),
-          arrow_properties));
+          arrowProperties));
   return Status::OK();
 }
 
-Result<std::unique_ptr<FileWriter>> FileWriter::Open(
+Result<std::unique_ptr<FileWriter>> FileWriter::open(
     const ::arrow::Schema& schema,
     ::arrow::MemoryPool* pool,
     std::shared_ptr<::arrow::io::OutputStream> sink,
     std::shared_ptr<WriterProperties> properties,
-    std::shared_ptr<ArrowWriterProperties> arrow_properties) {
-  std::shared_ptr<SchemaDescriptor> parquet_schema;
-  RETURN_NOT_OK(ToParquetSchema(
-      &schema, *properties, *arrow_properties, &parquet_schema));
+    std::shared_ptr<ArrowWriterProperties> arrowProperties) {
+  std::shared_ptr<SchemaDescriptor> parquetSchema;
+  RETURN_NOT_OK(
+      toParquetSchema(&schema, *properties, *arrowProperties, &parquetSchema));
 
-  auto schema_node =
-      std::static_pointer_cast<GroupNode>(parquet_schema->schema_root());
+  auto schemaNode =
+      std::static_pointer_cast<GroupNode>(parquetSchema->schemaRoot());
 
   std::shared_ptr<const KeyValueMetadata> metadata;
-  RETURN_NOT_OK(GetSchemaMetadata(schema, pool, *arrow_properties, &metadata));
+  RETURN_NOT_OK(getSchemaMetadata(schema, pool, *arrowProperties, &metadata));
 
-  std::unique_ptr<ParquetFileWriter> base_writer;
+  std::unique_ptr<ParquetFileWriter> baseWriter;
   PARQUET_CATCH_NOT_OK(
-      base_writer = ParquetFileWriter::Open(
+      baseWriter = ParquetFileWriter::open(
           std::move(sink),
-          schema_node,
+          schemaNode,
           std::move(properties),
           std::move(metadata)));
 
   std::unique_ptr<FileWriter> writer;
-  auto schema_ptr = std::make_shared<::arrow::Schema>(schema);
-  RETURN_NOT_OK(Make(
+  auto schemaPtr = std::make_shared<::arrow::Schema>(schema);
+  RETURN_NOT_OK(make(
       pool,
-      std::move(base_writer),
-      std::move(schema_ptr),
-      std::move(arrow_properties),
+      std::move(baseWriter),
+      std::move(schemaPtr),
+      std::move(arrowProperties),
       &writer));
 
   return writer;
 }
 
-Status WriteFileMetaData(
-    const FileMetaData& file_metadata,
+Status writeFileMetaData(
+    const FileMetaData& fileMetadata,
     ::arrow::io::OutputStream* sink) {
-  PARQUET_CATCH_NOT_OK(::facebook::velox::parquet::arrow::WriteFileMetaData(
-      file_metadata, sink));
+  PARQUET_CATCH_NOT_OK(
+      ::facebook::velox::parquet::arrow::writeFileMetaData(fileMetadata, sink));
   return Status::OK();
 }
 
-Status WriteMetaDataFile(
-    const FileMetaData& file_metadata,
+Status writeMetaDataFile(
+    const FileMetaData& fileMetadata,
     ::arrow::io::OutputStream* sink) {
-  PARQUET_CATCH_NOT_OK(::facebook::velox::parquet::arrow::WriteMetaDataFile(
-      file_metadata, sink));
+  PARQUET_CATCH_NOT_OK(
+      ::facebook::velox::parquet::arrow::writeMetaDataFile(fileMetadata, sink));
   return Status::OK();
 }
 
-Status WriteTable(
+Status writeTable(
     const ::arrow::Table& table,
     ::arrow::MemoryPool* pool,
     std::shared_ptr<::arrow::io::OutputStream> sink,
-    int64_t chunk_size,
+    int64_t chunkSize,
     std::shared_ptr<WriterProperties> properties,
-    std::shared_ptr<ArrowWriterProperties> arrow_properties) {
+    std::shared_ptr<ArrowWriterProperties> arrowProperties) {
   std::unique_ptr<FileWriter> writer;
   ARROW_ASSIGN_OR_RAISE(
       writer,
-      FileWriter::Open(
+      FileWriter::open(
           *table.schema(),
           pool,
           std::move(sink),
           std::move(properties),
-          std::move(arrow_properties)));
-  RETURN_NOT_OK(writer->WriteTable(table, chunk_size));
-  return writer->Close();
+          std::move(arrowProperties)));
+  RETURN_NOT_OK(writer->writeTable(table, chunkSize));
+  return writer->close();
 }
 
 } // namespace facebook::velox::parquet::arrow::arrow
diff --git a/velox/dwio/parquet/writer/arrow/Writer.h b/velox/dwio/parquet/writer/arrow/Writer.h
index 441b4096acb..840d11cbc4e 100644
--- a/velox/dwio/parquet/writer/arrow/Writer.h
+++ b/velox/dwio/parquet/writer/arrow/Writer.h
@@ -41,47 +41,47 @@ class ParquetFileWriter;
 
 namespace arrow {
 
-/// \brief Iterative FileWriter class
+/// \brief Iterative FileWriter class.
 ///
 /// For basic usage, can write a Table at a time, creating one or more row
 /// groups per write call.
 ///
-/// For advanced usage, can write column-by-column: Start a new RowGroup or
-/// Chunk with NewRowGroup, then write column-by-column the whole column chunk.
+/// For advanced usage, can write column-by-column: Start a new row group or
+/// chunk with newRowGroup(), then write column-by-column the whole column
+/// chunk.
 ///
 /// If PARQUET:field_id is present as a metadata key on a field, and the
 /// corresponding value is a nonnegative integer, then it will be used as the
-/// field_id in the parquet file.
+/// field_id in the Parquet file.
 class PARQUET_EXPORT FileWriter {
  public:
-  static ::arrow::Status Make(
+  static ::arrow::Status make(
       MemoryPool* pool,
       std::unique_ptr<ParquetFileWriter> writer,
       std::shared_ptr<::arrow::Schema> schema,
-      std::shared_ptr<ArrowWriterProperties> arrow_properties,
+      std::shared_ptr<ArrowWriterProperties> arrowProperties,
       std::unique_ptr<FileWriter>* out);
 
   /// \brief Try to create an Arrow to Parquet file writer.
   ///
-  /// \param schema schema of data that will be passed.
-  /// \param pool memory pool to use.
-  /// \param sink output stream to write Parquet data.
-  /// \param properties general Parquet writer properties.
+  /// \param schema Schema of data that will be passed.
+  /// \param pool Memory pool to use.
+  /// \param sink Output stream to write Parquet data.
+  /// \param properties General Parquet writer properties.
   /// \param arrow_properties Arrow-specific writer properties.
   ///
-  /// \since 11.0.0
-  static ::arrow::Result<std::unique_ptr<FileWriter>> Open(
+  /// \since 11.0.0.
+  static ::arrow::Result<std::unique_ptr<FileWriter>> open(
       const ::arrow::Schema& schema,
       MemoryPool* pool,
       std::shared_ptr<::arrow::io::OutputStream> sink,
-      std::shared_ptr<WriterProperties> properties =
-          default_writer_properties(),
-      std::shared_ptr<ArrowWriterProperties> arrow_properties =
-          default_arrow_writer_properties());
+      std::shared_ptr<WriterProperties> properties = defaultWriterProperties(),
+      std::shared_ptr<ArrowWriterProperties> arrowProperties =
+          defaultArrowWriterProperties());
 
   ARROW_DEPRECATED(
       "Deprecated in 11.0.0. Use Result-returning variants instead.")
-  static ::arrow::Status Open(
+  static ::arrow::Status open(
       const ::arrow::Schema& schema,
       MemoryPool* pool,
       std::shared_ptr<::arrow::io::OutputStream> sink,
@@ -89,12 +89,12 @@ class PARQUET_EXPORT FileWriter {
       std::unique_ptr<FileWriter>* writer);
   ARROW_DEPRECATED(
       "Deprecated in 11.0.0. Use Result-returning variants instead.")
-  static ::arrow::Status Open(
+  static ::arrow::Status open(
       const ::arrow::Schema& schema,
       MemoryPool* pool,
       std::shared_ptr<::arrow::io::OutputStream> sink,
       std::shared_ptr<WriterProperties> properties,
-      std::shared_ptr<ArrowWriterProperties> arrow_properties,
+      std::shared_ptr<ArrowWriterProperties> arrowProperties,
       std::unique_ptr<FileWriter>* writer);
 
   /// Return the Arrow schema to be written to.
@@ -103,74 +103,74 @@ class PARQUET_EXPORT FileWriter {
   /// \brief Write a Table to Parquet.
   ///
   /// \param table Arrow table to write.
-  /// \param chunk_size maximum number of rows to write per row group.
-  virtual ::arrow::Status WriteTable(
+  /// \param chunk_size Maximum number of rows to write per row group.
+  virtual ::arrow::Status writeTable(
       const ::arrow::Table& table,
-      int64_t chunk_size = DEFAULT_MAX_ROW_GROUP_LENGTH) = 0;
+      int64_t chunkSize = DEFAULT_MAX_ROW_GROUP_LENGTH) = 0;
 
   /// \brief Start a new row group.
   ///
   /// Returns an error if not all columns have been written.
   ///
-  /// \param chunk_size the number of rows in the next row group.
-  virtual ::arrow::Status NewRowGroup(int64_t chunk_size) = 0;
+  /// \param chunk_size The number of rows in the next row group.
+  virtual ::arrow::Status newRowGroup(int64_t chunkSize) = 0;
 
   /// \brief Write ColumnChunk in row group using an array.
-  virtual ::arrow::Status WriteColumnChunk(const ::arrow::Array& data) = 0;
+  virtual ::arrow::Status writeColumnChunk(const ::arrow::Array& data) = 0;
 
-  /// \brief Write ColumnChunk in row group using slice of a ChunkedArray
-  virtual ::arrow::Status WriteColumnChunk(
+  /// \brief Write ColumnChunk in row group using slice of a ChunkedArray.
+  virtual ::arrow::Status writeColumnChunk(
       const std::shared_ptr<::arrow::ChunkedArray>& data,
       int64_t offset,
       int64_t size) = 0;
 
-  /// \brief Write ColumnChunk in a row group using a ChunkedArray
-  virtual ::arrow::Status WriteColumnChunk(
+  /// \brief Write ColumnChunk in a row group using a ChunkedArray.
+  virtual ::arrow::Status writeColumnChunk(
       const std::shared_ptr<::arrow::ChunkedArray>& data) = 0;
 
   /// \brief Start a new buffered row group.
   ///
   /// Returns an error if not all columns have been written.
-  virtual ::arrow::Status NewBufferedRowGroup() = 0;
+  virtual ::arrow::Status newBufferedRowGroup() = 0;
 
   /// \brief Write a RecordBatch into the buffered row group.
   ///
-  /// Multiple RecordBatches can be written into the same row group
-  /// through this method.
+  /// Multiple RecordBatches can be written into the same row group through this
+  /// method.
   ///
-  /// WriterProperties.max_row_group_length() is respected and a new
+  /// WriterProperties.maxRowGroupLength() is respected and a new
   /// row group will be created if the current row group exceeds the
   /// limit.
   ///
-  /// Batches get flushed to the output stream once NewBufferedRowGroup()
-  /// or Close() is called.
+  /// Batches get flushed to the output stream once newBufferedRowGroup()
+  /// or close() is called.
   ///
   /// WARNING: If you are writing multiple files in parallel in the same
-  /// executor, deadlock may occur if ArrowWriterProperties::use_threads
-  /// is set to true to write columns in parallel. Please disable use_threads
+  /// executor, deadlock may occur if ArrowWriterProperties::useThreads
+  /// is set to true to write columns in parallel. Please disable useThreads
   /// option in this case.
-  virtual ::arrow::Status WriteRecordBatch(
+  virtual ::arrow::Status writeRecordBatch(
       const ::arrow::RecordBatch& batch) = 0;
 
   /// \brief Write the footer and close the file.
-  virtual ::arrow::Status Close() = 0;
+  virtual ::arrow::Status close() = 0;
   virtual ~FileWriter();
 
-  virtual MemoryPool* memory_pool() const = 0;
-  /// \brief Return the file metadata, only available after calling Close().
+  virtual MemoryPool* memoryPool() const = 0;
+  /// \brief Return the file metadata, only available after calling close().
   virtual const std::shared_ptr<FileMetaData> metadata() const = 0;
 };
 
-/// \brief Write Parquet file metadata only to indicated Arrow OutputStream
+/// \brief Write Parquet file metadata only to indicated Arrow OutputStream.
 PARQUET_EXPORT
-::arrow::Status WriteFileMetaData(
-    const FileMetaData& file_metadata,
+::arrow::Status writeFileMetaData(
+    const FileMetaData& fileMetadata,
     ::arrow::io::OutputStream* sink);
 
-/// \brief Write metadata-only Parquet file to indicated Arrow OutputStream
+/// \brief Write metadata-only Parquet file to indicated Arrow OutputStream.
 PARQUET_EXPORT
-::arrow::Status WriteMetaDataFile(
-    const FileMetaData& file_metadata,
+::arrow::Status writeMetaDataFile(
+    const FileMetaData& fileMetadata,
     ::arrow::io::OutputStream* sink);
 
 /// \brief Write a Table to Parquet.
@@ -178,20 +178,20 @@ ::arrow::Status WriteMetaDataFile(
 /// This writes one table in a single shot. To write a Parquet file with
 /// multiple tables iteratively, see parquet::arrow::FileWriter.
 ///
-/// \param table Table to write.
-/// \param pool memory pool to use.
-/// \param sink output stream to write Parquet data.
-/// \param chunk_size maximum number of rows to write per row group.
-/// \param properties general Parquet writer properties.
+/// \param table Arrow table to write.
+/// \param pool Memory pool to use.
+/// \param sink Output stream to write Parquet data.
+/// \param chunk_size Maximum number of rows to write per row group.
+/// \param properties General Parquet writer properties.
 /// \param arrow_properties Arrow-specific writer properties.
-::arrow::Status PARQUET_EXPORT WriteTable(
+::arrow::Status PARQUET_EXPORT writeTable(
     const ::arrow::Table& table,
     MemoryPool* pool,
     std::shared_ptr<::arrow::io::OutputStream> sink,
-    int64_t chunk_size = DEFAULT_MAX_ROW_GROUP_LENGTH,
-    std::shared_ptr<WriterProperties> properties = default_writer_properties(),
-    std::shared_ptr<ArrowWriterProperties> arrow_properties =
-        default_arrow_writer_properties());
+    int64_t chunkSize = DEFAULT_MAX_ROW_GROUP_LENGTH,
+    std::shared_ptr<WriterProperties> properties = defaultWriterProperties(),
+    std::shared_ptr<ArrowWriterProperties> arrowProperties =
+        defaultArrowWriterProperties());
 
 } // namespace arrow
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/tests/BloomFilter.cpp b/velox/dwio/parquet/writer/arrow/tests/BloomFilter.cpp
index 866aa8ada61..b60ef1f10ae 100644
--- a/velox/dwio/parquet/writer/arrow/tests/BloomFilter.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/BloomFilter.cpp
@@ -33,50 +33,49 @@ namespace facebook::velox::parquet::arrow {
 
 BlockSplitBloomFilter::BlockSplitBloomFilter(::arrow::MemoryPool* pool)
     : pool_(pool),
-      hash_strategy_(HashStrategy::XXHASH),
+      hashStrategy_(HashStrategy::XXHASH),
       algorithm_(Algorithm::BLOCK),
-      compression_strategy_(CompressionStrategy::UNCOMPRESSED) {}
+      compressionStrategy_(CompressionStrategy::UNCOMPRESSED) {}
 
-void BlockSplitBloomFilter::Init(uint32_t num_bytes) {
-  if (num_bytes < kMinimumBloomFilterBytes) {
-    num_bytes = kMinimumBloomFilterBytes;
+void BlockSplitBloomFilter::init(uint32_t numBytes) {
+  if (numBytes < kMinimumBloomFilterBytes) {
+    numBytes = kMinimumBloomFilterBytes;
   }
 
   // Get next power of 2 if it is not power of 2.
-  if ((num_bytes & (num_bytes - 1)) != 0) {
-    num_bytes = static_cast<uint32_t>(::arrow::bit_util::NextPower2(num_bytes));
+  if ((numBytes & (numBytes - 1)) != 0) {
+    numBytes = static_cast<uint32_t>(::arrow::bit_util::NextPower2(numBytes));
   }
 
-  if (num_bytes > kMaximumBloomFilterBytes) {
-    num_bytes = kMaximumBloomFilterBytes;
+  if (numBytes > kMaximumBloomFilterBytes) {
+    numBytes = kMaximumBloomFilterBytes;
   }
 
-  num_bytes_ = num_bytes;
-  PARQUET_ASSIGN_OR_THROW(data_, ::arrow::AllocateBuffer(num_bytes_, pool_));
-  memset(data_->mutable_data(), 0, num_bytes_);
+  numBytes_ = numBytes;
+  PARQUET_ASSIGN_OR_THROW(data_, ::arrow::AllocateBuffer(numBytes_, pool_));
+  memset(data_->mutable_data(), 0, numBytes_);
 
   this->hasher_ = std::make_unique<XxHasher>();
 }
 
-void BlockSplitBloomFilter::Init(const uint8_t* bitset, uint32_t num_bytes) {
+void BlockSplitBloomFilter::init(const uint8_t* bitset, uint32_t numBytes) {
   VELOX_DCHECK_NOT_NULL(bitset);
 
-  if (num_bytes < kMinimumBloomFilterBytes ||
-      num_bytes > kMaximumBloomFilterBytes ||
-      (num_bytes & (num_bytes - 1)) != 0) {
+  if (numBytes < kMinimumBloomFilterBytes ||
+      numBytes > kMaximumBloomFilterBytes || (numBytes & (numBytes - 1)) != 0) {
     throw ParquetException("Given length of bitset is illegal");
   }
 
-  num_bytes_ = num_bytes;
-  PARQUET_ASSIGN_OR_THROW(data_, ::arrow::AllocateBuffer(num_bytes_, pool_));
-  memcpy(data_->mutable_data(), bitset, num_bytes_);
+  numBytes_ = numBytes;
+  PARQUET_ASSIGN_OR_THROW(data_, ::arrow::AllocateBuffer(numBytes_, pool_));
+  memcpy(data_->mutable_data(), bitset, numBytes_);
 
   this->hasher_ = std::make_unique<XxHasher>();
 }
 
 static constexpr uint32_t kBloomFilterHeaderSizeGuess = 256;
 
-static ::arrow::Status ValidateBloomFilterHeader(
+static ::arrow::Status validateBloomFilterHeader(
     const facebook::velox::parquet::thrift::BloomFilterHeader& header) {
   if (!header.algorithm.__isset.BLOCK) {
     return ::arrow::Status::Invalid(
@@ -106,71 +105,69 @@ static ::arrow::Status ValidateBloomFilterHeader(
   return ::arrow::Status::OK();
 }
 
-BlockSplitBloomFilter BlockSplitBloomFilter::Deserialize(
+BlockSplitBloomFilter BlockSplitBloomFilter::deserialize(
     const ReaderProperties& properties,
     ArrowInputStream* input) {
-  // NOTE: we don't know the bloom filter header size upfront, and we can't rely
-  // on InputStream::Peek() which isn't always implemented. Therefore, we must
-  // first Read() with an upper bound estimate of the header size, then once we
-  // know the bloom filter data size, we can Read() the exact number of
-  // remaining data bytes.
+  // NOTE: we don't know the bloom filter header size upfront, and we can't
+  // rely. On InputStream::Peek() which isn't always implemented. Therefore, we
+  // must. First Read() with an upper bound estimate of the header size, then
+  // once we. Know the bloom filter data size, we can Read() the exact number
+  // of. Remaining data bytes.
   ThriftDeserializer deserializer(properties);
   facebook::velox::parquet::thrift::BloomFilterHeader header;
 
-  // Read and deserialize bloom filter header
+  // Read and deserialize bloom filter header.
   PARQUET_ASSIGN_OR_THROW(
-      auto header_buf, input->Read(kBloomFilterHeaderSizeGuess));
-  // This gets used, then set by DeserializeThriftMsg
-  uint32_t header_size = static_cast<uint32_t>(header_buf->size());
+      auto headerBuf, input->Read(kBloomFilterHeaderSizeGuess));
+  // This gets used, then set by DeserializeThriftMsg.
+  uint32_t headerSize = static_cast<uint32_t>(headerBuf->size());
   try {
-    deserializer.DeserializeMessage(
-        reinterpret_cast<const uint8_t*>(header_buf->data()),
-        &header_size,
+    deserializer.deserializeMessage(
+        reinterpret_cast<const uint8_t*>(headerBuf->data()),
+        &headerSize,
         &header);
-    VELOX_DCHECK_LE(header_size, header_buf->size());
+    VELOX_DCHECK_LE(headerSize, headerBuf->size());
   } catch (std::exception& e) {
     std::stringstream ss;
     ss << "Deserializing bloom filter header failed.\n" << e.what();
     throw ParquetException(ss.str());
   }
-  PARQUET_THROW_NOT_OK(ValidateBloomFilterHeader(header));
+  PARQUET_THROW_NOT_OK(validateBloomFilterHeader(header));
 
-  const int32_t bloom_filter_size = header.numBytes;
-  if (bloom_filter_size + header_size <= header_buf->size()) {
-    // The bloom filter data is entirely contained in the buffer we just read
-    // => just return it.
-    BlockSplitBloomFilter bloom_filter(properties.memory_pool());
-    bloom_filter.Init(header_buf->data() + header_size, bloom_filter_size);
-    return bloom_filter;
+  const int32_t bloomFilterSize = header.numBytes;
+  if (bloomFilterSize + headerSize <= headerBuf->size()) {
+    // The bloom filter data is entirely contained in the buffer we just read.
+    // => Just return it.
+    BlockSplitBloomFilter bloomFilter(properties.memoryPool());
+    bloomFilter.init(headerBuf->data() + headerSize, bloomFilterSize);
+    return bloomFilter;
   }
-  // We have read a part of the bloom filter already, copy it to the target
-  // buffer and read the remaining part from the InputStream.
-  auto buffer = AllocateBuffer(properties.memory_pool(), bloom_filter_size);
+  // We have read a part of the bloom filter already, copy it to the target.
+  // Buffer and read the remaining part from the InputStream.
+  auto buffer = allocateBuffer(properties.memoryPool(), bloomFilterSize);
 
-  const auto bloom_filter_bytes_in_header = header_buf->size() - header_size;
-  if (bloom_filter_bytes_in_header > 0) {
+  const auto bloomFilterBytesInHeader = headerBuf->size() - headerSize;
+  if (bloomFilterBytesInHeader > 0) {
     std::memcpy(
         buffer->mutable_data(),
-        header_buf->data() + header_size,
-        bloom_filter_bytes_in_header);
+        headerBuf->data() + headerSize,
+        bloomFilterBytesInHeader);
   }
 
-  const auto required_read_size =
-      bloom_filter_size - bloom_filter_bytes_in_header;
+  const auto requiredReadSize = bloomFilterSize - bloomFilterBytesInHeader;
   PARQUET_ASSIGN_OR_THROW(
-      auto read_size,
+      auto readSize,
       input->Read(
-          required_read_size,
-          buffer->mutable_data() + bloom_filter_bytes_in_header));
-  if (ARROW_PREDICT_FALSE(read_size < required_read_size)) {
+          requiredReadSize, buffer->mutable_data() + bloomFilterBytesInHeader));
+  if (ARROW_PREDICT_FALSE(readSize < requiredReadSize)) {
     throw ParquetException("Bloom Filter read failed: not enough data");
   }
-  BlockSplitBloomFilter bloom_filter(properties.memory_pool());
-  bloom_filter.Init(buffer->data(), bloom_filter_size);
-  return bloom_filter;
+  BlockSplitBloomFilter bloomFilter(properties.memoryPool());
+  bloomFilter.init(buffer->data(), bloomFilterSize);
+  return bloomFilter;
 }
 
-void BlockSplitBloomFilter::WriteTo(ArrowOutputStream* sink) const {
+void BlockSplitBloomFilter::writeTo(ArrowOutputStream* sink) const {
   VELOX_DCHECK_NOT_NULL(sink);
 
   facebook::velox::parquet::thrift::BloomFilterHeader header;
@@ -180,29 +177,29 @@ void BlockSplitBloomFilter::WriteTo(ArrowOutputStream* sink) const {
   }
   header.algorithm.__set_BLOCK(
       facebook::velox::parquet::thrift::SplitBlockAlgorithm());
-  if (ARROW_PREDICT_FALSE(hash_strategy_ != HashStrategy::XXHASH)) {
+  if (ARROW_PREDICT_FALSE(hashStrategy_ != HashStrategy::XXHASH)) {
     throw ParquetException(
         "BloomFilter does not support Hash other than XXHASH");
   }
   header.hash.__set_XXHASH(facebook::velox::parquet::thrift::XxHash());
   if (ARROW_PREDICT_FALSE(
-          compression_strategy_ != CompressionStrategy::UNCOMPRESSED)) {
+          compressionStrategy_ != CompressionStrategy::UNCOMPRESSED)) {
     throw ParquetException(
         "BloomFilter does not support Compression other than UNCOMPRESSED");
   }
   header.compression.__set_UNCOMPRESSED(
       facebook::velox::parquet::thrift::Uncompressed());
-  header.__set_numBytes(num_bytes_);
+  header.__set_numBytes(numBytes_);
 
   ThriftSerializer serializer;
-  serializer.Serialize(&header, sink);
+  serializer.serialize(&header, sink);
 
-  PARQUET_THROW_NOT_OK(sink->Write(data_->data(), num_bytes_));
+  PARQUET_THROW_NOT_OK(sink->Write(data_->data(), numBytes_));
 }
 
-bool BlockSplitBloomFilter::FindHash(uint64_t hash) const {
-  const uint32_t bucket_index = static_cast<uint32_t>(
-      ((hash >> 32) * (num_bytes_ / kBytesPerFilterBlock)) >> 32);
+bool BlockSplitBloomFilter::findHash(uint64_t hash) const {
+  const uint32_t bucketIndex = static_cast<uint32_t>(
+      ((hash >> 32) * (numBytes_ / kBytesPerFilterBlock)) >> 32);
   const uint32_t key = static_cast<uint32_t>(hash);
   const uint32_t* bitset32 = reinterpret_cast<const uint32_t*>(data_->data());
 
@@ -210,35 +207,35 @@ bool BlockSplitBloomFilter::FindHash(uint64_t hash) const {
     // Calculate mask for key in the given bitset.
     const uint32_t mask = UINT32_C(0x1) << ((key * SALT[i]) >> 27);
     if (ARROW_PREDICT_FALSE(
-            0 == (bitset32[kBitsSetPerBlock * bucket_index + i] & mask))) {
+            0 == (bitset32[kBitsSetPerBlock * bucketIndex + i] & mask))) {
       return false;
     }
   }
   return true;
 }
 
-void BlockSplitBloomFilter::InsertHashImpl(uint64_t hash) {
-  const uint32_t bucket_index = static_cast<uint32_t>(
-      ((hash >> 32) * (num_bytes_ / kBytesPerFilterBlock)) >> 32);
+void BlockSplitBloomFilter::insertHashImpl(uint64_t hash) {
+  const uint32_t bucketIndex = static_cast<uint32_t>(
+      ((hash >> 32) * (numBytes_ / kBytesPerFilterBlock)) >> 32);
   const uint32_t key = static_cast<uint32_t>(hash);
   uint32_t* bitset32 = reinterpret_cast<uint32_t*>(data_->mutable_data());
 
   for (int i = 0; i < kBitsSetPerBlock; i++) {
     // Calculate mask for key in the given bitset.
     const uint32_t mask = UINT32_C(0x1) << ((key * SALT[i]) >> 27);
-    bitset32[bucket_index * kBitsSetPerBlock + i] |= mask;
+    bitset32[bucketIndex * kBitsSetPerBlock + i] |= mask;
   }
 }
 
-void BlockSplitBloomFilter::InsertHash(uint64_t hash) {
-  InsertHashImpl(hash);
+void BlockSplitBloomFilter::insertHash(uint64_t hash) {
+  insertHashImpl(hash);
 }
 
-void BlockSplitBloomFilter::InsertHashes(
+void BlockSplitBloomFilter::insertHashes(
     const uint64_t* hashes,
-    int num_values) {
-  for (int i = 0; i < num_values; ++i) {
-    InsertHashImpl(hashes[i]);
+    int numValues) {
+  for (int i = 0; i < numValues; ++i) {
+    insertHashImpl(hashes[i]);
   }
 }
 
diff --git a/velox/dwio/parquet/writer/arrow/tests/BloomFilter.h b/velox/dwio/parquet/writer/arrow/tests/BloomFilter.h
index 4637921fefd..2f36cc7ae01 100644
--- a/velox/dwio/parquet/writer/arrow/tests/BloomFilter.h
+++ b/velox/dwio/parquet/writer/arrow/tests/BloomFilter.h
@@ -32,153 +32,154 @@
 
 namespace facebook::velox::parquet::arrow {
 
-// A Bloom filter is a compact structure to indicate whether an item is not in a
-// set or probably in a set. The Bloom filter usually consists of a bit set that
-// represents a set of elements, a hash strategy and a Bloom filter algorithm.
+// A Bloom filter is a compact structure to indicate whether an item is not in
+// a. Set or probably in a set. The Bloom filter usually consists of a bit set
+// that. Represents a set of elements, a hash strategy and a Bloom filter
+// algorithm.
 class PARQUET_EXPORT BloomFilter {
  public:
-  // Maximum Bloom filter size, it sets to HDFS default block size 128MB
+  // Maximum Bloom filter size, it sets to HDFS default block size 128MB.
   // This value will be reconsidered when implementing Bloom filter producer.
   static constexpr uint32_t kMaximumBloomFilterBytes = 128 * 1024 * 1024;
 
   /// Determine whether an element exist in set or not.
   ///
   /// @param hash the element to contain.
-  /// @return false if value is definitely not in set, and true means PROBABLY
-  /// in set.
-  virtual bool FindHash(uint64_t hash) const = 0;
+  /// @return false if value is definitely not in set, and true means PROBABLY.
+  /// In set.
+  virtual bool findHash(uint64_t hash) const = 0;
 
   /// Insert element to set represented by Bloom filter bitset.
   /// @param hash the hash of value to insert into Bloom filter.
-  virtual void InsertHash(uint64_t hash) = 0;
+  virtual void insertHash(uint64_t hash) = 0;
 
   /// Insert elements to set represented by Bloom filter bitset.
   /// @param hashes the hash values to insert into Bloom filter.
   /// @param num_values the number of hash values to insert.
-  virtual void InsertHashes(const uint64_t* hashes, int num_values) = 0;
+  virtual void insertHashes(const uint64_t* hashes, int numValues) = 0;
 
-  /// Write this Bloom filter to an output stream. A Bloom filter structure
-  /// should include bitset length, hash strategy, algorithm, and bitset.
+  /// Write this Bloom filter to an output stream. A Bloom filter structure.
+  /// Should include bitset length, hash strategy, algorithm, and bitset.
   ///
-  /// @param sink the output stream to write
-  virtual void WriteTo(ArrowOutputStream* sink) const = 0;
+  /// @param sink the output stream to write.
+  virtual void writeTo(ArrowOutputStream* sink) const = 0;
 
-  /// Get the number of bytes of bitset
-  virtual uint32_t GetBitsetSize() const = 0;
+  /// Get the number of bytes of bitset.
+  virtual uint32_t getBitsetSize() const = 0;
 
   /// Compute hash for 32 bits value by using its plain encoding result.
   ///
   /// @param value the value to hash.
   /// @return hash result.
-  virtual uint64_t Hash(int32_t value) const = 0;
+  virtual uint64_t hash(int32_t value) const = 0;
 
   /// Compute hash for 64 bits value by using its plain encoding result.
   ///
   /// @param value the value to hash.
   /// @return hash result.
-  virtual uint64_t Hash(int64_t value) const = 0;
+  virtual uint64_t hash(int64_t value) const = 0;
 
   /// Compute hash for float value by using its plain encoding result.
   ///
   /// @param value the value to hash.
   /// @return hash result.
-  virtual uint64_t Hash(float value) const = 0;
+  virtual uint64_t hash(float value) const = 0;
 
   /// Compute hash for double value by using its plain encoding result.
   ///
   /// @param value the value to hash.
   /// @return hash result.
-  virtual uint64_t Hash(double value) const = 0;
+  virtual uint64_t hash(double value) const = 0;
 
   /// Compute hash for Int96 value by using its plain encoding result.
   ///
   /// @param value the value to hash.
   /// @return hash result.
-  virtual uint64_t Hash(const Int96* value) const = 0;
+  virtual uint64_t hash(const Int96* value) const = 0;
 
   /// Compute hash for ByteArray value by using its plain encoding result.
   ///
   /// @param value the value to hash.
   /// @return hash result.
-  virtual uint64_t Hash(const ByteArray* value) const = 0;
+  virtual uint64_t hash(const ByteArray* value) const = 0;
 
-  /// Compute hash for fixed byte array value by using its plain encoding
-  /// result.
+  /// Compute hash for fixed byte array value by using its plain encoding.
+  /// Result.
   ///
   /// @param value the value address.
   /// @param len the value length.
   /// @return hash result.
-  virtual uint64_t Hash(const FLBA* value, uint32_t len) const = 0;
+  virtual uint64_t hash(const FLBA* value, uint32_t len) const = 0;
 
-  /// Batch compute hashes for 32 bits values by using its plain encoding
-  /// result.
+  /// Batch compute hashes for 32 bits values by using its plain encoding.
+  /// Result.
   ///
   /// @param values values a pointer to the values to hash.
   /// @param num_values the number of values to hash.
-  /// @param hashes a pointer to the output hash values, its length should be
-  /// equal to num_values.
-  virtual void Hashes(const int32_t* values, int num_values, uint64_t* hashes)
+  /// @param hashes a pointer to the output hash values, its length should be.
+  /// Equal to num_values.
+  virtual void hashes(const int32_t* values, int numValues, uint64_t* hashes)
       const = 0;
 
-  /// Batch compute hashes for 64 bits values by using its plain encoding
-  /// result.
+  /// Batch compute hashes for 64 bits values by using its plain encoding.
+  /// Result.
   ///
   /// @param values values a pointer to the values to hash.
   /// @param num_values the number of values to hash.
-  /// @param hashes a pointer to the output hash values, its length should be
-  /// equal to num_values.
-  virtual void Hashes(const int64_t* values, int num_values, uint64_t* hashes)
+  /// @param hashes a pointer to the output hash values, its length should be.
+  /// Equal to num_values.
+  virtual void hashes(const int64_t* values, int numValues, uint64_t* hashes)
       const = 0;
 
   /// Batch compute hashes for float values by using its plain encoding result.
   ///
   /// @param values values a pointer to the values to hash.
   /// @param num_values the number of values to hash.
-  /// @param hashes a pointer to the output hash values, its length should be
-  /// equal to num_values.
-  virtual void Hashes(const float* values, int num_values, uint64_t* hashes)
+  /// @param hashes a pointer to the output hash values, its length should be.
+  /// Equal to num_values.
+  virtual void hashes(const float* values, int numValues, uint64_t* hashes)
       const = 0;
 
   /// Batch compute hashes for double values by using its plain encoding result.
   ///
   /// @param values values a pointer to the values to hash.
   /// @param num_values the number of values to hash.
-  /// @param hashes a pointer to the output hash values, its length should be
-  /// equal to num_values.
-  virtual void Hashes(const double* values, int num_values, uint64_t* hashes)
+  /// @param hashes a pointer to the output hash values, its length should be.
+  /// Equal to num_values.
+  virtual void hashes(const double* values, int numValues, uint64_t* hashes)
       const = 0;
 
   /// Batch compute hashes for Int96 values by using its plain encoding result.
   ///
   /// @param values values a pointer to the values to hash.
   /// @param num_values the number of values to hash.
-  /// @param hashes a pointer to the output hash values, its length should be
-  /// equal to num_values.
-  virtual void Hashes(const Int96* values, int num_values, uint64_t* hashes)
+  /// @param hashes a pointer to the output hash values, its length should be.
+  /// Equal to num_values.
+  virtual void hashes(const Int96* values, int numValues, uint64_t* hashes)
       const = 0;
 
-  /// Batch compute hashes for ByteArray values by using its plain encoding
-  /// result.
+  /// Batch compute hashes for ByteArray values by using its plain encoding.
+  /// Result.
   ///
   /// @param values values a pointer to the values to hash.
   /// @param num_values the number of values to hash.
-  /// @param hashes a pointer to the output hash values, its length should be
-  /// equal to num_values.
-  virtual void Hashes(const ByteArray* values, int num_values, uint64_t* hashes)
+  /// @param hashes a pointer to the output hash values, its length should be.
+  /// Equal to num_values.
+  virtual void hashes(const ByteArray* values, int numValues, uint64_t* hashes)
       const = 0;
 
-  /// Batch compute hashes for fixed byte array values by using its plain
-  /// encoding result.
+  /// Batch compute hashes for fixed byte array values by using its plain.
+  /// Encoding result.
   ///
   /// @param values values a pointer to the values to hash.
   /// @param type_len the value length.
   /// @param num_values the number of values to hash.
-  /// @param hashes a pointer to the output hash values, its length should be
-  /// equal to num_values.
-  virtual void Hashes(
+  /// @param hashes a pointer to the output hash values, its length should be.
+  /// Equal to num_values.
+  virtual void hashes(
       const FLBA* values,
-      uint32_t type_len,
-      int num_values,
+      uint32_t typeLen,
+      int numValues,
       uint64_t* hashes) const = 0;
 
   virtual ~BloomFilter() = default;
@@ -193,13 +194,13 @@ class PARQUET_EXPORT BloomFilter {
   enum class CompressionStrategy : uint32_t { UNCOMPRESSED = 0 };
 };
 
-/// The BlockSplitBloomFilter is implemented using block-based Bloom filters
-/// from Putze et al.'s "Cache-,Hash- and Space-Efficient Bloom filters". The
-/// basic idea is to hash the item to a tiny Bloom filter which size fit a
-/// single cache line or smaller.
+/// The BlockSplitBloomFilter is implemented using block-based Bloom filters.
+/// From Putze et al.'s "Cache-,Hash- and Space-Efficient Bloom filters". The.
+/// Basic idea is to hash the item to a tiny Bloom filter which size fit a.
+/// Single cache line or smaller.
 ///
-/// This implementation sets 8 bits in each tiny Bloom filter. Each tiny Bloom
-/// filter is 32 bytes to take advantage of 32-byte SIMD instructions.
+/// This implementation sets 8 bits in each tiny Bloom filter. Each tiny Bloom.
+/// Filter is 32 bytes to take advantage of 32-byte SIMD instructions.
 class PARQUET_EXPORT BlockSplitBloomFilter : public BloomFilter {
  public:
   /// The constructor of BlockSplitBloomFilter. It uses XXH64 as hash function.
@@ -208,170 +209,171 @@ class PARQUET_EXPORT BlockSplitBloomFilter : public BloomFilter {
   explicit BlockSplitBloomFilter(
       ::arrow::MemoryPool* pool = ::arrow::default_memory_pool());
 
-  /// Initialize the BlockSplitBloomFilter. The range of num_bytes should be
-  /// within [kMinimumBloomFilterBytes, kMaximumBloomFilterBytes], it will be
-  /// rounded up/down to lower/upper bound if num_bytes is out of range and also
-  /// will be rounded up to a power of 2.
+  /// Initialize the BlockSplitBloomFilter. The range of num_bytes should be.
+  /// Within [kMinimumBloomFilterBytes, kMaximumBloomFilterBytes], it will be.
+  /// Rounded up/down to lower/upper bound if num_bytes is out of range and
+  /// also. Will be rounded up to a power of 2.
   ///
   /// @param num_bytes The number of bytes to store Bloom filter bitset.
-  void Init(uint32_t num_bytes);
+  void init(uint32_t numBytes);
 
-  /// Initialize the BlockSplitBloomFilter. It copies the bitset as underlying
-  /// bitset because the given bitset may not satisfy the 32-byte alignment
-  /// requirement which may lead to segfault when performing SIMD instructions.
-  /// It is the caller's responsibility to free the bitset passed in. This is
-  /// used when reconstructing a Bloom filter from a parquet file.
+  /// Initialize the BlockSplitBloomFilter. It copies the bitset as underlying.
+  /// Bitset because the given bitset may not satisfy the 32-byte alignment.
+  /// Requirement which may lead to segfault when performing SIMD instructions.
+  /// It is the caller's responsibility to free the bitset passed in. This is.
+  /// Used when reconstructing a Bloom filter from a parquet file.
   ///
   /// @param bitset The given bitset to initialize the Bloom filter.
   /// @param num_bytes  The number of bytes of given bitset.
-  void Init(const uint8_t* bitset, uint32_t num_bytes);
+  void init(const uint8_t* bitset, uint32_t numBytes);
 
   /// Minimum Bloom filter size, it sets to 32 bytes to fit a tiny Bloom filter.
   static constexpr uint32_t kMinimumBloomFilterBytes = 32;
 
-  /// Calculate optimal size according to the number of distinct values and
-  /// false positive probability.
+  /// Calculate optimal size according to the number of distinct values and.
+  /// False positive probability.
   ///
   /// @param ndv The number of distinct values.
   /// @param fpp The false positive probability.
-  /// @return it always return a value between kMinimumBloomFilterBytes and
-  /// kMaximumBloomFilterBytes, and the return value is always a power of 2
-  static uint32_t OptimalNumOfBytes(uint32_t ndv, double fpp) {
-    uint32_t optimal_num_of_bits = OptimalNumOfBits(ndv, fpp);
-    VELOX_DCHECK(::arrow::bit_util::IsMultipleOf8(optimal_num_of_bits));
-    return optimal_num_of_bits >> 3;
+  /// @return it always return a value between kMinimumBloomFilterBytes and.
+  /// KMaximumBloomFilterBytes, and the return value is always a power of 2.
+  static uint32_t optimalNumOfBytes(uint32_t ndv, double fpp) {
+    uint32_t optimalNumBits = optimalNumOfBits(ndv, fpp);
+    VELOX_DCHECK(::arrow::bit_util::IsMultipleOf8(optimalNumBits));
+    return optimalNumBits >> 3;
   }
 
-  /// Calculate optimal size according to the number of distinct values and
-  /// false positive probability.
+  /// Calculate optimal size according to the number of distinct values and.
+  /// False positive probability.
   ///
   /// @param ndv The number of distinct values.
   /// @param fpp The false positive probability.
-  /// @return it always return a value between kMinimumBloomFilterBytes * 8 and
-  /// kMaximumBloomFilterBytes * 8, and the return value is always a power of 16
-  static uint32_t OptimalNumOfBits(uint32_t ndv, double fpp) {
+  /// @return it always return a value between kMinimumBloomFilterBytes * 8 and.
+  /// KMaximumBloomFilterBytes * 8, and the return value is always a power
+  /// of 16.
+  static uint32_t optimalNumOfBits(uint32_t ndv, double fpp) {
     VELOX_DCHECK(fpp > 0.0 && fpp < 1.0);
     const double m = -8.0 * ndv / log(1 - pow(fpp, 1.0 / 8));
-    uint32_t num_bits;
+    uint32_t numBits;
 
     // Handle overflow.
     if (m < 0 || m > kMaximumBloomFilterBytes << 3) {
-      num_bits = static_cast<uint32_t>(kMaximumBloomFilterBytes << 3);
+      numBits = static_cast<uint32_t>(kMaximumBloomFilterBytes << 3);
     } else {
-      num_bits = static_cast<uint32_t>(m);
+      numBits = static_cast<uint32_t>(m);
     }
 
-    // Round up to lower bound
-    if (num_bits < kMinimumBloomFilterBytes << 3) {
-      num_bits = kMinimumBloomFilterBytes << 3;
+    // Round up to lower bound.
+    if (numBits < kMinimumBloomFilterBytes << 3) {
+      numBits = kMinimumBloomFilterBytes << 3;
     }
 
     // Get next power of 2 if bits is not power of 2.
-    if ((num_bits & (num_bits - 1)) != 0) {
-      num_bits = static_cast<uint32_t>(::arrow::bit_util::NextPower2(num_bits));
+    if ((numBits & (numBits - 1)) != 0) {
+      numBits = static_cast<uint32_t>(::arrow::bit_util::NextPower2(numBits));
     }
 
-    // Round down to upper bound
-    if (num_bits > kMaximumBloomFilterBytes << 3) {
-      num_bits = kMaximumBloomFilterBytes << 3;
+    // Round down to upper bound.
+    if (numBits > kMaximumBloomFilterBytes << 3) {
+      numBits = kMaximumBloomFilterBytes << 3;
     }
 
-    return num_bits;
+    return numBits;
   }
 
-  bool FindHash(uint64_t hash) const override;
-  void InsertHash(uint64_t hash) override;
-  void InsertHashes(const uint64_t* hashes, int num_values) override;
-  void WriteTo(ArrowOutputStream* sink) const override;
-  uint32_t GetBitsetSize() const override {
-    return num_bytes_;
+  bool findHash(uint64_t hash) const override;
+  void insertHash(uint64_t hash) override;
+  void insertHashes(const uint64_t* hashes, int numValues) override;
+  void writeTo(ArrowOutputStream* sink) const override;
+  uint32_t getBitsetSize() const override {
+    return numBytes_;
   }
 
-  uint64_t Hash(int32_t value) const override {
-    return hasher_->Hash(value);
+  uint64_t hash(int32_t value) const override {
+    return hasher_->hash(value);
   }
-  uint64_t Hash(int64_t value) const override {
-    return hasher_->Hash(value);
+  uint64_t hash(int64_t value) const override {
+    return hasher_->hash(value);
   }
-  uint64_t Hash(float value) const override {
-    return hasher_->Hash(value);
+  uint64_t hash(float value) const override {
+    return hasher_->hash(value);
   }
-  uint64_t Hash(double value) const override {
-    return hasher_->Hash(value);
+  uint64_t hash(double value) const override {
+    return hasher_->hash(value);
   }
-  uint64_t Hash(const Int96* value) const override {
-    return hasher_->Hash(value);
+  uint64_t hash(const Int96* value) const override {
+    return hasher_->hash(value);
   }
-  uint64_t Hash(const ByteArray* value) const override {
-    return hasher_->Hash(value);
+  uint64_t hash(const ByteArray* value) const override {
+    return hasher_->hash(value);
   }
-  uint64_t Hash(const FLBA* value, uint32_t len) const override {
-    return hasher_->Hash(value, len);
+  uint64_t hash(const FLBA* value, uint32_t len) const override {
+    return hasher_->hash(value, len);
   }
 
-  void Hashes(const int32_t* values, int num_values, uint64_t* hashes)
+  void hashes(const int32_t* values, int numValues, uint64_t* hashes)
       const override {
-    hasher_->Hashes(values, num_values, hashes);
+    hasher_->hashes(values, numValues, hashes);
   }
-  void Hashes(const int64_t* values, int num_values, uint64_t* hashes)
+  void hashes(const int64_t* values, int numValues, uint64_t* hashes)
       const override {
-    hasher_->Hashes(values, num_values, hashes);
+    hasher_->hashes(values, numValues, hashes);
   }
-  void Hashes(const float* values, int num_values, uint64_t* hashes)
+  void hashes(const float* values, int numValues, uint64_t* hashes)
       const override {
-    hasher_->Hashes(values, num_values, hashes);
+    hasher_->hashes(values, numValues, hashes);
   }
-  void Hashes(const double* values, int num_values, uint64_t* hashes)
+  void hashes(const double* values, int numValues, uint64_t* hashes)
       const override {
-    hasher_->Hashes(values, num_values, hashes);
+    hasher_->hashes(values, numValues, hashes);
   }
-  void Hashes(const Int96* values, int num_values, uint64_t* hashes)
+  void hashes(const Int96* values, int numValues, uint64_t* hashes)
       const override {
-    hasher_->Hashes(values, num_values, hashes);
+    hasher_->hashes(values, numValues, hashes);
   }
-  void Hashes(const ByteArray* values, int num_values, uint64_t* hashes)
+  void hashes(const ByteArray* values, int numValues, uint64_t* hashes)
       const override {
-    hasher_->Hashes(values, num_values, hashes);
+    hasher_->hashes(values, numValues, hashes);
   }
-  void Hashes(
+  void hashes(
       const FLBA* values,
-      uint32_t type_len,
-      int num_values,
+      uint32_t typeLen,
+      int numValues,
       uint64_t* hashes) const override {
-    hasher_->Hashes(values, type_len, num_values, hashes);
+    hasher_->hashes(values, typeLen, numValues, hashes);
   }
 
-  uint64_t Hash(const int32_t* value) const {
-    return hasher_->Hash(*value);
+  uint64_t hash(const int32_t* value) const {
+    return hasher_->hash(*value);
   }
-  uint64_t Hash(const int64_t* value) const {
-    return hasher_->Hash(*value);
+  uint64_t hash(const int64_t* value) const {
+    return hasher_->hash(*value);
   }
-  uint64_t Hash(const float* value) const {
-    return hasher_->Hash(*value);
+  uint64_t hash(const float* value) const {
+    return hasher_->hash(*value);
   }
-  uint64_t Hash(const double* value) const {
-    return hasher_->Hash(*value);
+  uint64_t hash(const double* value) const {
+    return hasher_->hash(*value);
   }
 
-  /// Deserialize the Bloom filter from an input stream. It is used when
-  /// reconstructing a Bloom filter from a parquet filter.
+  /// Deserialize the Bloom filter from an input stream. It is used when.
+  /// Reconstructing a Bloom filter from a parquet filter.
   ///
   /// @param properties The parquet reader properties.
-  /// @param input_stream The input stream from which to construct the Bloom
-  /// filter.
+  /// @param input_stream The input stream from which to construct the Bloom.
+  /// Filter.
   /// @return The BlockSplitBloomFilter.
-  static BlockSplitBloomFilter Deserialize(
+  static BlockSplitBloomFilter deserialize(
       const ReaderProperties& properties,
-      ArrowInputStream* input_stream);
+      ArrowInputStream* inputStream);
 
  private:
-  inline void InsertHashImpl(uint64_t hash);
+  inline void insertHashImpl(uint64_t hash);
 
   // Bytes in a tiny Bloom filter block.
   static constexpr int kBytesPerFilterBlock = 32;
 
-  // The number of bits to be set in each tiny Bloom filter
+  // The number of bits to be set in each tiny Bloom filter.
   static constexpr int kBitsSetPerBlock = 8;
 
   // A mask structure used to set bits in each tiny Bloom filter.
@@ -379,8 +381,8 @@ class PARQUET_EXPORT BlockSplitBloomFilter : public BloomFilter {
     uint32_t item[kBitsSetPerBlock];
   };
 
-  // The block-based algorithm needs eight odd SALT values to calculate eight
-  // indexes of bit to set, one bit in each 32-bit word.
+  // The block-based algorithm needs eight odd SALT values to calculate eight.
+  // Indexes of bit to set, one bit in each 32-bit word.
   static constexpr uint32_t SALT[kBitsSetPerBlock] = {
       0x47b6137bU,
       0x44974d91U,
@@ -391,23 +393,23 @@ class PARQUET_EXPORT BlockSplitBloomFilter : public BloomFilter {
       0x9efc4947U,
       0x5c6bfb31U};
 
-  // Memory pool to allocate aligned buffer for bitset
+  // Memory pool to allocate aligned buffer for bitset.
   ::arrow::MemoryPool* pool_;
 
   // The underlying buffer of bitset.
   std::shared_ptr<Buffer> data_;
 
   // The number of bytes of Bloom filter bitset.
-  uint32_t num_bytes_;
+  uint32_t numBytes_;
 
   // Hash strategy used in this Bloom filter.
-  HashStrategy hash_strategy_;
+  HashStrategy hashStrategy_;
 
   // Algorithm used in this Bloom filter.
   Algorithm algorithm_;
 
   // Compression used in this Bloom filter.
-  CompressionStrategy compression_strategy_;
+  CompressionStrategy compressionStrategy_;
 
   // The hash pointer points to actual hash class used.
   std::unique_ptr<Hasher> hasher_;
diff --git a/velox/dwio/parquet/writer/arrow/tests/BloomFilterReader.cpp b/velox/dwio/parquet/writer/arrow/tests/BloomFilterReader.cpp
index 152ebf32d77..88c15ed6cbd 100644
--- a/velox/dwio/parquet/writer/arrow/tests/BloomFilterReader.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/BloomFilterReader.cpp
@@ -27,76 +27,76 @@ class RowGroupBloomFilterReaderImpl final : public RowGroupBloomFilterReader {
  public:
   RowGroupBloomFilterReaderImpl(
       std::shared_ptr<::arrow::io::RandomAccessFile> input,
-      std::shared_ptr<RowGroupMetaData> row_group_metadata,
+      std::shared_ptr<RowGroupMetaData> rowGroupMetadata,
       const ReaderProperties& properties)
       : input_(std::move(input)),
-        row_group_metadata_(std::move(row_group_metadata)),
+        rowGroupMetadata_(std::move(rowGroupMetadata)),
         properties_(properties) {}
 
-  std::unique_ptr<BloomFilter> GetColumnBloomFilter(int i) override;
+  std::unique_ptr<BloomFilter> getColumnBloomFilter(int i) override;
 
  private:
   /// The input stream that can perform random access read.
   std::shared_ptr<::arrow::io::RandomAccessFile> input_;
 
   /// The row group metadata to get column chunk metadata.
-  std::shared_ptr<RowGroupMetaData> row_group_metadata_;
+  std::shared_ptr<RowGroupMetaData> rowGroupMetadata_;
 
   /// Reader properties used to deserialize thrift object.
   const ReaderProperties& properties_;
 };
 
 std::unique_ptr<BloomFilter>
-RowGroupBloomFilterReaderImpl::GetColumnBloomFilter(int i) {
-  if (i < 0 || i >= row_group_metadata_->num_columns()) {
+RowGroupBloomFilterReaderImpl::getColumnBloomFilter(int i) {
+  if (i < 0 || i >= rowGroupMetadata_->numColumns()) {
     throw ParquetException("Invalid column index at column ordinal ", i);
   }
 
-  auto col_chunk = row_group_metadata_->ColumnChunk(i);
-  std::unique_ptr<ColumnCryptoMetaData> crypto_metadata =
-      col_chunk->crypto_metadata();
-  if (crypto_metadata != nullptr) {
+  auto colChunk = rowGroupMetadata_->columnChunk(i);
+  std::unique_ptr<ColumnCryptoMetaData> cryptoMetadata =
+      colChunk->cryptoMetadata();
+  if (cryptoMetadata != nullptr) {
     ParquetException::NYI("Cannot read encrypted bloom filter yet");
   }
 
-  auto bloom_filter_offset = col_chunk->bloom_filter_offset();
-  if (!bloom_filter_offset.has_value()) {
+  auto bloomFilterOffset = colChunk->bloomFilterOffset();
+  if (!bloomFilterOffset.has_value()) {
     return nullptr;
   }
-  PARQUET_ASSIGN_OR_THROW(auto file_size, input_->GetSize());
-  if (file_size <= *bloom_filter_offset) {
+  PARQUET_ASSIGN_OR_THROW(auto fileSize, input_->GetSize());
+  if (fileSize <= *bloomFilterOffset) {
     throw ParquetException("file size less or equal than bloom offset");
   }
   auto stream = ::arrow::io::RandomAccessFile::GetStream(
-      input_, *bloom_filter_offset, file_size - *bloom_filter_offset);
-  auto bloom_filter =
-      BlockSplitBloomFilter::Deserialize(properties_, stream->get());
-  return std::make_unique<BlockSplitBloomFilter>(std::move(bloom_filter));
+      input_, *bloomFilterOffset, fileSize - *bloomFilterOffset);
+  auto bloomFilter =
+      BlockSplitBloomFilter::deserialize(properties_, stream->get());
+  return std::make_unique<BlockSplitBloomFilter>(std::move(bloomFilter));
 }
 
 class BloomFilterReaderImpl final : public BloomFilterReader {
  public:
   BloomFilterReaderImpl(
       std::shared_ptr<::arrow::io::RandomAccessFile> input,
-      std::shared_ptr<FileMetaData> file_metadata,
+      std::shared_ptr<FileMetaData> fileMetadata,
       const ReaderProperties& properties,
-      std::shared_ptr<InternalFileDecryptor> file_decryptor)
+      std::shared_ptr<InternalFileDecryptor> fileDecryptor)
       : input_(std::move(input)),
-        file_metadata_(std::move(file_metadata)),
+        fileMetadata_(std::move(fileMetadata)),
         properties_(properties) {
-    if (file_decryptor != nullptr) {
+    if (fileDecryptor != nullptr) {
       ParquetException::NYI("BloomFilter decryption is not yet supported");
     }
   }
 
-  std::shared_ptr<RowGroupBloomFilterReader> RowGroup(int i) {
-    if (i < 0 || i >= file_metadata_->num_row_groups()) {
+  std::shared_ptr<RowGroupBloomFilterReader> rowGroup(int i) {
+    if (i < 0 || i >= fileMetadata_->numRowGroups()) {
       throw ParquetException("Invalid row group ordinal: ", i);
     }
 
-    auto row_group_metadata = file_metadata_->RowGroup(i);
+    auto rowGroupMetadata = fileMetadata_->rowGroup(i);
     return std::make_shared<RowGroupBloomFilterReaderImpl>(
-        input_, std::move(row_group_metadata), properties_);
+        input_, std::move(rowGroupMetadata), properties_);
   }
 
  private:
@@ -104,19 +104,19 @@ class BloomFilterReaderImpl final : public BloomFilterReader {
   std::shared_ptr<::arrow::io::RandomAccessFile> input_;
 
   /// The file metadata to get row group metadata.
-  std::shared_ptr<FileMetaData> file_metadata_;
+  std::shared_ptr<FileMetaData> fileMetadata_;
 
   /// Reader properties used to deserialize thrift object.
   const ReaderProperties& properties_;
 };
 
-std::unique_ptr<BloomFilterReader> BloomFilterReader::Make(
+std::unique_ptr<BloomFilterReader> BloomFilterReader::make(
     std::shared_ptr<::arrow::io::RandomAccessFile> input,
-    std::shared_ptr<FileMetaData> file_metadata,
+    std::shared_ptr<FileMetaData> fileMetadata,
     const ReaderProperties& properties,
-    std::shared_ptr<InternalFileDecryptor> file_decryptor) {
+    std::shared_ptr<InternalFileDecryptor> fileDecryptor) {
   return std::make_unique<BloomFilterReaderImpl>(
-      std::move(input), file_metadata, properties, std::move(file_decryptor));
+      std::move(input), fileMetadata, properties, std::move(fileDecryptor));
 }
 
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/tests/BloomFilterReader.h b/velox/dwio/parquet/writer/arrow/tests/BloomFilterReader.h
index ac32d66a688..c6089cc9f04 100644
--- a/velox/dwio/parquet/writer/arrow/tests/BloomFilterReader.h
+++ b/velox/dwio/parquet/writer/arrow/tests/BloomFilterReader.h
@@ -35,9 +35,9 @@ class PARQUET_EXPORT RowGroupBloomFilterReader {
   ///
   /// \param[in] i column ordinal of the column chunk.
   /// \returns bloom filter of the column or nullptr if it does not exist.
-  /// \throws ParquetException if the index is out of bound, or read bloom
-  /// filter failed.
-  virtual std::unique_ptr<BloomFilter> GetColumnBloomFilter(int i) = 0;
+  /// \throws ParquetException if the index is out of bound, or read bloom.
+  /// Filter failed.
+  virtual std::unique_ptr<BloomFilter> getColumnBloomFilter(int i) = 0;
 };
 
 /// \brief Interface for reading the bloom filter for a Parquet file.
@@ -47,25 +47,25 @@ class PARQUET_EXPORT BloomFilterReader {
 
   /// \brief Create a BloomFilterReader instance.
   /// \returns a BloomFilterReader instance.
-  /// WARNING: The returned BloomFilterReader references to all the input
-  /// parameters, so it must not outlive all of the input parameters. Usually
-  /// these input parameters come from the same ParquetFileReader object, so it
-  /// must not outlive the reader that creates this BloomFilterReader.
-  static std::unique_ptr<BloomFilterReader> Make(
+  /// WARNING: The returned BloomFilterReader references to all the input.
+  /// Parameters, so it must not outlive all of the input parameters. Usually.
+  /// These input parameters come from the same ParquetFileReader object, so it.
+  /// Must not outlive the reader that creates this BloomFilterReader.
+  static std::unique_ptr<BloomFilterReader> make(
       std::shared_ptr<::arrow::io::RandomAccessFile> input,
-      std::shared_ptr<FileMetaData> file_metadata,
+      std::shared_ptr<FileMetaData> fileMetadata,
       const ReaderProperties& properties,
-      std::shared_ptr<InternalFileDecryptor> file_decryptor = NULLPTR);
+      std::shared_ptr<InternalFileDecryptor> fileDecryptor = NULLPTR);
 
   /// \brief Get the bloom filter reader of a specific row group.
   /// \param[in] i row group ordinal to get bloom filter reader.
-  /// \returns RowGroupBloomFilterReader of the specified row group. A nullptr
-  /// may or may
-  ///          not be returned if the bloom filter for the row group is
-  ///          unavailable. It is the caller's responsibility to check the
-  ///          return value of follow-up calls to the RowGroupBloomFilterReader.
+  /// \returns RowGroupBloomFilterReader of the specified row group. A nullptr.
+  /// May or may.
+  ///          Not be returned if the bloom filter for the row group is.
+  ///          Unavailable. It is the caller's responsibility to check the.
+  ///          Return value of follow-up calls to the RowGroupBloomFilterReader.
   /// \throws ParquetException if the index is out of bound.
-  virtual std::shared_ptr<RowGroupBloomFilterReader> RowGroup(int i) = 0;
+  virtual std::shared_ptr<RowGroupBloomFilterReader> rowGroup(int i) = 0;
 };
 
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/tests/BloomFilterTest.cpp b/velox/dwio/parquet/writer/arrow/tests/BloomFilterTest.cpp
index 644fda5a678..158023f24c5 100644
--- a/velox/dwio/parquet/writer/arrow/tests/BloomFilterTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/BloomFilterTest.cpp
@@ -43,21 +43,21 @@ namespace facebook::velox::parquet::arrow {
 namespace test {
 
 TEST(ConstructorTest, TestBloomFilter) {
-  BlockSplitBloomFilter bloom_filter;
-  EXPECT_NO_THROW(bloom_filter.Init(1000));
+  BlockSplitBloomFilter BloomFilter;
+  EXPECT_NO_THROW(BloomFilter.init(1000));
 
-  // It throws because the length cannot be zero
+  // It throws because the length cannot be zero.
   std::unique_ptr<uint8_t[]> bitset1(new uint8_t[1024]());
-  EXPECT_THROW(bloom_filter.Init(bitset1.get(), 0), ParquetException);
+  EXPECT_THROW(BloomFilter.init(bitset1.get(), 0), ParquetException);
 
-  // It throws because the number of bytes of Bloom filter bitset must be a
-  // power of 2.
+  // It throws because the number of bytes of Bloom filter bitset must be a.
+  // Power of 2.
   std::unique_ptr<uint8_t[]> bitset2(new uint8_t[1024]());
-  EXPECT_THROW(bloom_filter.Init(bitset2.get(), 1023), ParquetException);
+  EXPECT_THROW(BloomFilter.init(bitset2.get(), 1023), ParquetException);
 }
 
-// The BasicTest is used to test basic operations including InsertHash, FindHash
-// and serializing and de-serializing.
+// The BasicTest is used to test basic operations including InsertHash,
+// FindHash. And serializing and de-serializing.
 TEST(BasicTest, TestBloomFilter) {
   const std::vector<uint32_t> kBloomFilterSizes = {
       32, 64, 128, 256, 512, 1024, 2048};
@@ -68,72 +68,72 @@ TEST(BasicTest, TestBloomFilter) {
   const std::vector<int32_t> kNegativeIntLookups = {
       0, 11, 12, 13, -2, -3, 43, 1 << 27, 1 << 28};
 
-  for (const auto bloom_filter_bytes : kBloomFilterSizes) {
-    BlockSplitBloomFilter bloom_filter;
-    bloom_filter.Init(bloom_filter_bytes);
+  for (const auto bloomFilterBytes : kBloomFilterSizes) {
+    BlockSplitBloomFilter BloomFilter;
+    BloomFilter.init(bloomFilterBytes);
 
-    // Empty bloom filter deterministically returns false
+    // Empty bloom filter deterministically returns false.
     for (const auto v : kIntInserts) {
-      EXPECT_FALSE(bloom_filter.FindHash(bloom_filter.Hash(v)));
+      EXPECT_FALSE(BloomFilter.findHash(BloomFilter.hash(v)));
     }
     for (const auto v : kFloatInserts) {
-      EXPECT_FALSE(bloom_filter.FindHash(bloom_filter.Hash(v)));
+      EXPECT_FALSE(BloomFilter.findHash(BloomFilter.hash(v)));
     }
 
-    // Insert all values
+    // Insert all values.
     for (const auto v : kIntInserts) {
-      bloom_filter.InsertHash(bloom_filter.Hash(v));
+      BloomFilter.insertHash(BloomFilter.hash(v));
     }
     for (const auto v : kFloatInserts) {
-      bloom_filter.InsertHash(bloom_filter.Hash(v));
+      BloomFilter.insertHash(BloomFilter.hash(v));
     }
 
-    // They should always lookup successfully
+    // They should always lookup successfully.
     for (const auto v : kIntInserts) {
-      EXPECT_TRUE(bloom_filter.FindHash(bloom_filter.Hash(v)));
+      EXPECT_TRUE(BloomFilter.findHash(BloomFilter.hash(v)));
     }
     for (const auto v : kFloatInserts) {
-      EXPECT_TRUE(bloom_filter.FindHash(bloom_filter.Hash(v)));
+      EXPECT_TRUE(BloomFilter.findHash(BloomFilter.hash(v)));
     }
 
-    // Values not inserted in the filter should only rarely lookup successfully
-    int false_positives = 0;
+    // Values not inserted in the filter should only rarely lookup successfully.
+    int falsePositives = 0;
     for (const auto v : kNegativeIntLookups) {
-      false_positives += bloom_filter.FindHash(bloom_filter.Hash(v));
+      falsePositives += BloomFilter.findHash(BloomFilter.hash(v));
     }
     // (this is a crude check, see FPPTest below for a more rigorous formula)
-    EXPECT_LE(false_positives, 2);
+    EXPECT_LE(falsePositives, 2);
 
-    // Serialize Bloom filter to memory output stream
-    auto sink = CreateOutputStream();
-    bloom_filter.WriteTo(sink.get());
+    // Serialize Bloom filter to memory output stream.
+    auto sink = createOutputStream();
+    BloomFilter.writeTo(sink.get());
 
-    // Deserialize Bloom filter from memory
+    // Deserialize Bloom filter from memory.
     ASSERT_OK_AND_ASSIGN(auto buffer, sink->Finish());
     ::arrow::io::BufferReader source(buffer);
 
-    ReaderProperties reader_properties;
-    BlockSplitBloomFilter de_bloom =
-        BlockSplitBloomFilter::Deserialize(reader_properties, &source);
+    ReaderProperties ReaderProperties;
+    BlockSplitBloomFilter deBloom =
+        BlockSplitBloomFilter::deserialize(ReaderProperties, &source);
 
-    // Lookup previously inserted values
+    // Lookup previously inserted values.
     for (const auto v : kIntInserts) {
-      EXPECT_TRUE(de_bloom.FindHash(de_bloom.Hash(v)));
+      EXPECT_TRUE(deBloom.findHash(deBloom.hash(v)));
     }
     for (const auto v : kFloatInserts) {
-      EXPECT_TRUE(de_bloom.FindHash(de_bloom.Hash(v)));
+      EXPECT_TRUE(deBloom.findHash(deBloom.hash(v)));
     }
-    false_positives = 0;
+    falsePositives = 0;
     for (const auto v : kNegativeIntLookups) {
-      false_positives += de_bloom.FindHash(de_bloom.Hash(v));
+      falsePositives += deBloom.findHash(deBloom.hash(v));
     }
-    EXPECT_LE(false_positives, 2);
+    EXPECT_LE(falsePositives, 2);
   }
 }
 
 // Helper function to generate random string.
-std::string GetRandomString(uint32_t length) {
-  // Character set used to generate random string
+std::string getRandomString(uint32_t length) {
+  // Character set used to generate random string.
   const std::string charset =
       "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 
@@ -152,51 +152,50 @@ TEST(FPPTest, TestBloomFilter) {
   // It counts the number of times FindHash returns true.
   int exist = 0;
 
-  // Total count of elements that will be used
+  // Total count of elements that will be used.
 #ifdef PARQUET_VALGRIND
-  const int total_count = 5000;
+  const int totalCount = 5000;
 #else
-  const int total_count = 100000;
+  const int totalCount = 100000;
 #endif
 
-  // Bloom filter fpp parameter
+  // Bloom filter fpp parameter.
   const double fpp = 0.01;
 
   std::vector<std::string> members;
-  BlockSplitBloomFilter bloom_filter;
-  bloom_filter.Init(BlockSplitBloomFilter::OptimalNumOfBytes(total_count, fpp));
-
-  // Insert elements into the Bloom filter
-  for (int i = 0; i < total_count; i++) {
-    // Insert random string which length is 8
-    std::string tmp = GetRandomString(8);
-    const ByteArray byte_array(
-        8, reinterpret_cast<const uint8_t*>(tmp.c_str()));
+  BlockSplitBloomFilter BloomFilter;
+  BloomFilter.init(BlockSplitBloomFilter::optimalNumOfBytes(totalCount, fpp));
+
+  // Insert elements into the Bloom filter.
+  for (int i = 0; i < totalCount; i++) {
+    // Insert random string which length is 8.
+    std::string tmp = getRandomString(8);
+    const ByteArray ByteArray(8, reinterpret_cast<const uint8_t*>(tmp.c_str()));
     members.push_back(tmp);
-    bloom_filter.InsertHash(bloom_filter.Hash(&byte_array));
+    BloomFilter.insertHash(BloomFilter.hash(&ByteArray));
   }
 
-  for (int i = 0; i < total_count; i++) {
-    const ByteArray byte_array1(
+  for (int i = 0; i < totalCount; i++) {
+    const ByteArray byteArray1(
         8, reinterpret_cast<const uint8_t*>(members[i].c_str()));
-    ASSERT_TRUE(bloom_filter.FindHash(bloom_filter.Hash(&byte_array1)));
-    std::string tmp = GetRandomString(7);
-    const ByteArray byte_array2(
+    ASSERT_TRUE(BloomFilter.findHash(BloomFilter.hash(&byteArray1)));
+    std::string tmp = getRandomString(7);
+    const ByteArray byteArray2(
         7, reinterpret_cast<const uint8_t*>(tmp.c_str()));
 
-    if (bloom_filter.FindHash(bloom_filter.Hash(&byte_array2))) {
+    if (BloomFilter.findHash(BloomFilter.hash(&byteArray2))) {
       exist++;
     }
   }
 
   // The exist should be probably less than 1000 according default FPP 0.01.
-  EXPECT_LT(exist, total_count * fpp);
+  EXPECT_LT(exist, totalCount * fpp);
 }
 
-// The CompatibilityTest is used to test cross compatibility with parquet-mr, it
-// reads the Bloom filter binary generated by the Bloom filter class in the
-// parquet-mr project and tests whether the values inserted before could be
-// filtered or not.
+// The CompatibilityTest is used to test cross compatibility with parquet-mr,
+// it. Reads the Bloom filter binary generated by the Bloom filter class in the.
+// Parquet-mr project and tests whether the values inserted before could be.
+// Filtered or not.
 
 // TODO: disabled as it requires Arrow parquet data dir.
 // The Bloom filter binary is generated by three steps in from Parquet-mr.
@@ -231,11 +230,11 @@ uint8_t*>(test_string[i].c_str()));
     EXPECT_TRUE(bloom_filter1.FindHash(bloom_filter1.Hash(&tmp)));
   }
 
-  // The following is used to check whether the new created Bloom filter in
+  // The following is used to check whether the new created Bloom filter in.
 parquet-cpp is
-  // byte-for-byte identical to file at bloom_data_path which is created from
+  // Byte-for-byte identical to file at bloom_data_path which is created from.
 parquet-mr
-  // with same inserted hashes.
+  // With same inserted hashes.
   BlockSplitBloomFilter bloom_filter2;
   bloom_filter2.Init(bloom_filter1.GetBitsetSize());
   for (int i = 0; i < 4; i++) {
@@ -245,7 +244,7 @@ uint8_t*>(test_string[i].c_str()));
     bloom_filter2.InsertHash(bloom_filter2.Hash(&byte_array));
   }
 
-  // Serialize Bloom filter to memory output stream
+  // Serialize Bloom filter to memory output stream.
   auto sink = CreateOutputStream();
   bloom_filter2.WriteTo(sink.get());
   PARQUET_ASSIGN_OR_THROW(auto buffer1, sink->Finish());
@@ -258,18 +257,18 @@ uint8_t*>(test_string[i].c_str()));
 }
 */
 
-// OptimalValueTest is used to test whether OptimalNumOfBits returns expected
-// numbers according to formula:
+// OptimalValueTest is used to test whether OptimalNumOfBits returns expected.
+// Numbers according to formula:
 //     num_of_bits = -8.0 * ndv / log(1 - pow(fpp, 1.0 / 8.0))
-// where ndv is the number of distinct values and fpp is the false positive
-// probability. Also it is used to test whether OptimalNumOfBits returns value
-// between [MINIMUM_BLOOM_FILTER_SIZE, MAXIMUM_BLOOM_FILTER_SIZE].
+// Where ndv is the number of distinct values and fpp is the false positive.
+// Probability. Also it is used to test whether OptimalNumOfBits returns value.
+// Between [MINIMUM_BLOOM_FILTER_SIZE, MAXIMUM_BLOOM_FILTER_SIZE].
 TEST(OptimalValueTest, TestBloomFilter) {
   auto testOptimalNumEstimation = [](uint32_t ndv,
                                      double fpp,
-                                     uint32_t num_bits) {
-    EXPECT_EQ(BlockSplitBloomFilter::OptimalNumOfBits(ndv, fpp), num_bits);
-    EXPECT_EQ(BlockSplitBloomFilter::OptimalNumOfBytes(ndv, fpp), num_bits / 8);
+                                     uint32_t numBits) {
+    EXPECT_EQ(BlockSplitBloomFilter::optimalNumOfBits(ndv, fpp), numBits);
+    EXPECT_EQ(BlockSplitBloomFilter::optimalNumOfBytes(ndv, fpp), numBits / 8);
   };
 
   testOptimalNumEstimation(256, 0.01, UINT32_C(4096));
@@ -292,7 +291,7 @@ TEST(OptimalValueTest, TestBloomFilter) {
   testOptimalNumEstimation(700, 0.05, UINT32_C(8192));
   testOptimalNumEstimation(1500, 0.05, UINT32_C(16384));
 
-  // Boundary check
+  // Boundary check.
   testOptimalNumEstimation(
       4, 0.01, BlockSplitBloomFilter::kMinimumBloomFilterBytes * 8);
   testOptimalNumEstimation(
@@ -308,8 +307,8 @@ TEST(OptimalValueTest, TestBloomFilter) {
       BlockSplitBloomFilter::kMaximumBloomFilterBytes * 8);
 }
 
-// The test below is plainly copied from parquet-mr and serves as a basic sanity
-// check of our XXH64 wrapper.
+// The test below is plainly copied from parquet-mr and serves as a basic
+// sanity. Check of our XXH64 wrapper.
 const int64_t HASHES_OF_LOOPING_BYTES_WITH_SEED_0[32] = {
     -1205034819632174695L, -1642502924627794072L, 5216751715308240086L,
     -1889335612763511331L, -13835840860730338L,   -2521325055659080948L,
@@ -351,33 +350,32 @@ TEST(XxHashTest, TestBloomFilter) {
   uint8_t bytes[kNumValues] = {};
 
   for (int i = 0; i < kNumValues; i++) {
-    ByteArray byte_array(i, bytes);
+    ByteArray ByteArray(i, bytes);
     bytes[i] = i;
 
-    auto hasher_seed_0 = std::make_unique<XxHasher>();
+    auto hasherSeed0 = std::make_unique<XxHasher>();
     EXPECT_EQ(
-        HASHES_OF_LOOPING_BYTES_WITH_SEED_0[i],
-        hasher_seed_0->Hash(&byte_array))
+        HASHES_OF_LOOPING_BYTES_WITH_SEED_0[i], hasherSeed0->hash(&ByteArray))
         << "Hash with seed 0 Error: " << i;
   }
 }
 
-// Same as TestBloomFilter but using Batch interface
+// Same as TestBloomFilter but using Batch interface.
 TEST(XxHashTest, TestBloomFilterHashes) {
   constexpr int kNumValues = 32;
   uint8_t bytes[kNumValues] = {};
 
-  std::vector<ByteArray> byte_array_vector;
+  std::vector<ByteArray> byteArrayVector;
   for (int i = 0; i < kNumValues; i++) {
     bytes[i] = i;
-    byte_array_vector.emplace_back(i, bytes);
+    byteArrayVector.emplace_back(i, bytes);
   }
-  auto hasher_seed_0 = std::make_unique<XxHasher>();
+  auto hasherSeed0 = std::make_unique<XxHasher>();
   std::vector<uint64_t> hashes;
   hashes.resize(kNumValues);
-  hasher_seed_0->Hashes(
-      byte_array_vector.data(),
-      static_cast<int>(byte_array_vector.size()),
+  hasherSeed0->hashes(
+      byteArrayVector.data(),
+      static_cast<int>(byteArrayVector.size()),
       hashes.data());
   for (int i = 0; i < kNumValues; i++) {
     EXPECT_EQ(HASHES_OF_LOOPING_BYTES_WITH_SEED_0[i], hashes[i])
@@ -391,17 +389,17 @@ class TestBatchBloomFilter : public testing::Test {
   constexpr static int kTestDataSize = 64;
 
   // GenerateTestData with size 64.
-  std::vector<typename DType::c_type> GenerateTestData();
+  std::vector<typename DType::CType> generateTestData();
 
-  // The Lifetime owner for Test data
+  // The Lifetime owner for Test data.
   std::vector<uint8_t> members;
 };
 
 template <typename DType>
-std::vector<typename DType::c_type>
-TestBatchBloomFilter<DType>::GenerateTestData() {
-  std::vector<typename DType::c_type> values(kTestDataSize);
-  GenerateData(kTestDataSize, values.data(), &members);
+std::vector<typename DType::CType>
+TestBatchBloomFilter<DType>::generateTestData() {
+  std::vector<typename DType::CType> values(kTestDataSize);
+  generateData(kTestDataSize, values.data(), &members);
   return values;
 }
 
@@ -418,58 +416,58 @@ using BloomFilterTestTypes = ::testing::Types<
 TYPED_TEST_SUITE(TestBatchBloomFilter, BloomFilterTestTypes);
 
 TYPED_TEST(TestBatchBloomFilter, Basic) {
-  using Type = typename TypeParam::c_type;
-  std::vector<Type> test_data = TestFixture::GenerateTestData();
-  BlockSplitBloomFilter batch_insert_filter;
+  using Type = typename TypeParam::CType;
+  std::vector<Type> testData = TestFixture::generateTestData();
+  BlockSplitBloomFilter batchInsertFilter;
   BlockSplitBloomFilter filter;
 
-  // Bloom filter fpp parameter
+  // Bloom filter fpp parameter.
   const double fpp = 0.05;
-  filter.Init(BlockSplitBloomFilter::OptimalNumOfBytes(
-      TestFixture::kTestDataSize, fpp));
-  batch_insert_filter.Init(BlockSplitBloomFilter::OptimalNumOfBytes(
-      TestFixture::kTestDataSize, fpp));
+  filter.init(
+      BlockSplitBloomFilter::optimalNumOfBytes(
+          TestFixture::kTestDataSize, fpp));
+  batchInsertFilter.init(
+      BlockSplitBloomFilter::optimalNumOfBytes(
+          TestFixture::kTestDataSize, fpp));
 
   std::vector<uint64_t> hashes;
-  for (const Type& value : test_data) {
+  for (const Type& value : testData) {
     uint64_t hash = 0;
     if constexpr (std::is_same_v<Type, FLBA>) {
-      hash = filter.Hash(&value, kGenerateDataFLBALength);
+      hash = filter.hash(&value, kGenerateDataFLBALength);
     } else {
-      hash = filter.Hash(&value);
+      hash = filter.hash(&value);
     }
     hashes.push_back(hash);
   }
 
-  std::vector<uint64_t> batch_hashes(test_data.size());
+  std::vector<uint64_t> batchHashes(testData.size());
   if constexpr (std::is_same_v<Type, FLBA>) {
-    batch_insert_filter.Hashes(
-        test_data.data(),
+    batchInsertFilter.hashes(
+        testData.data(),
         kGenerateDataFLBALength,
-        static_cast<int>(test_data.size()),
-        batch_hashes.data());
+        static_cast<int>(testData.size()),
+        batchHashes.data());
   } else {
-    batch_insert_filter.Hashes(
-        test_data.data(),
-        static_cast<int>(test_data.size()),
-        batch_hashes.data());
+    batchInsertFilter.hashes(
+        testData.data(), static_cast<int>(testData.size()), batchHashes.data());
   }
 
-  EXPECT_EQ(hashes, batch_hashes);
+  EXPECT_EQ(hashes, batchHashes);
 
   std::shared_ptr<Buffer> buffer;
-  std::shared_ptr<Buffer> batch_insert_buffer;
+  std::shared_ptr<Buffer> batchInsertBuffer;
   {
-    auto sink = CreateOutputStream();
-    filter.WriteTo(sink.get());
+    auto sink = createOutputStream();
+    filter.writeTo(sink.get());
     ASSERT_OK_AND_ASSIGN(buffer, sink->Finish());
   }
   {
-    auto sink = CreateOutputStream();
-    batch_insert_filter.WriteTo(sink.get());
-    ASSERT_OK_AND_ASSIGN(batch_insert_buffer, sink->Finish());
+    auto sink = createOutputStream();
+    batchInsertFilter.writeTo(sink.get());
+    ASSERT_OK_AND_ASSIGN(batchInsertBuffer, sink->Finish());
   }
-  AssertBufferEqual(*buffer, *batch_insert_buffer);
+  ::arrow::AssertBufferEqual(*buffer, *batchInsertBuffer);
 }
 
 } // namespace test
diff --git a/velox/dwio/parquet/writer/arrow/tests/CMakeLists.txt b/velox/dwio/parquet/writer/arrow/tests/CMakeLists.txt
index 5906a75516d..19e3d0e3b92 100644
--- a/velox/dwio/parquet/writer/arrow/tests/CMakeLists.txt
+++ b/velox/dwio/parquet/writer/arrow/tests/CMakeLists.txt
@@ -25,6 +25,7 @@ add_executable(
   PropertiesTest.cpp
   SchemaTest.cpp
   StatisticsTest.cpp
+  StringTruncationTest.cpp
   TypesTest.cpp
 )
 
@@ -39,7 +40,7 @@ target_link_libraries(
   arrow
   arrow_testing
   velox_dwio_native_parquet_reader
-  velox_temp_path
+  velox_test_util
 )
 
 add_library(
@@ -52,6 +53,17 @@ add_library(
   TestUtil.cpp
   XxHasher.cpp
 )
+velox_add_test_headers(
+  velox_dwio_arrow_parquet_writer_test_lib
+  BloomFilter.h
+  BloomFilterReader.h
+  ColumnReader.h
+  ColumnScanner.h
+  FileReader.h
+  Hasher.h
+  TestUtil.h
+  XxHasher.h
+)
 
 target_link_libraries(
   velox_dwio_arrow_parquet_writer_test_lib
diff --git a/velox/dwio/parquet/writer/arrow/tests/ColumnReader.cpp b/velox/dwio/parquet/writer/arrow/tests/ColumnReader.cpp
index 30dd2def721..916f93b76e4 100644
--- a/velox/dwio/parquet/writer/arrow/tests/ColumnReader.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/ColumnReader.cpp
@@ -62,100 +62,99 @@ namespace bit_util = arrow::bit_util;
 
 namespace facebook::velox::parquet::arrow {
 
-fmt::underlying_t<Type::type> format_as(Type::type type) {
+fmt::underlying_t<Type::type> formatAs(Type::type type) {
   return fmt::underlying(type);
 }
 
 namespace {
 
-// The minimum number of repetition/definition levels to decode at a time, for
-// better vectorized performance when doing many smaller record reads
+// The minimum number of repetition/definition levels to decode at a time, for.
+// Better vectorized performance when doing many smaller record reads.
 constexpr int64_t kMinLevelBatchSize = 1024;
 
 // Batch size for reading and throwing away values during skip.
 // Both RecordReader and the ColumnReader use this for skipping.
 constexpr int64_t kSkipScratchBatchSize = 1024;
 
-inline bool HasSpacedValues(const ColumnDescriptor* descr) {
-  if (descr->max_repetition_level() > 0) {
-    // repeated+flat case
-    return !descr->schema_node()->is_required();
+inline bool hasSpacedValues(const ColumnDescriptor* descr) {
+  if (descr->maxRepetitionLevel() > 0) {
+    // Repeated+flat case.
+    return !descr->schemaNode()->isRequired();
   } else {
-    // non-repeated+nested case
-    // Find if a node forces nulls in the lowest level along the hierarchy
-    const schema::Node* node = descr->schema_node().get();
-    while (node) {
-      if (node->is_optional()) {
+    // Non-repeated+nested case.
+    // Find if a node forces nulls in the lowest level along the hierarchy.
+    const schema::Node* Node = descr->schemaNode().get();
+    while (Node) {
+      if (Node->isOptional()) {
         return true;
       }
-      node = node->parent();
+      Node = Node->parent();
     }
     return false;
   }
 }
 
 // Throws exception if number_decoded does not match expected.
-inline void CheckNumberDecoded(int64_t number_decoded, int64_t expected) {
-  if (ARROW_PREDICT_FALSE(number_decoded != expected)) {
-    ParquetException::EofException(
-        "Decoded values " + std::to_string(number_decoded) +
+inline void checkNumberDecoded(int64_t numberDecoded, int64_t expected) {
+  if (ARROW_PREDICT_FALSE(numberDecoded != expected)) {
+    ParquetException::eofException(
+        "Decoded values " + std::to_string(numberDecoded) +
         " does not match expected " + std::to_string(expected));
   }
 }
 } // namespace
 
-LevelDecoder::LevelDecoder() : num_values_remaining_(0) {}
+LevelDecoder::LevelDecoder() : numValuesRemaining_(0) {}
 
 LevelDecoder::~LevelDecoder() {}
 
-int LevelDecoder::SetData(
+int LevelDecoder::setData(
     Encoding::type encoding,
-    int16_t max_level,
-    int num_buffered_values,
+    int16_t maxLevel,
+    int numBufferedValues,
     const uint8_t* data,
-    int32_t data_size) {
-  max_level_ = max_level;
-  int32_t num_bytes = 0;
+    int32_t dataSize) {
+  maxLevel_ = maxLevel;
+  int32_t numBytes = 0;
   encoding_ = encoding;
-  num_values_remaining_ = num_buffered_values;
-  bit_width_ = ::arrow::bit_util::Log2(max_level + 1);
+  numValuesRemaining_ = numBufferedValues;
+  bitWidth_ = ::arrow::bit_util::Log2(maxLevel + 1);
   switch (encoding) {
-    case Encoding::RLE: {
-      if (data_size < 4) {
+    case Encoding::kRle: {
+      if (dataSize < 4) {
         throw ParquetException("Received invalid levels (corrupt data page?)");
       }
-      num_bytes = ::arrow::util::SafeLoadAs<int32_t>(data);
-      if (num_bytes < 0 || num_bytes > data_size - 4) {
+      numBytes = ::arrow::util::SafeLoadAs<int32_t>(data);
+      if (numBytes < 0 || numBytes > dataSize - 4) {
         throw ParquetException(
             "Received invalid number of bytes (corrupt data page?)");
       }
-      const uint8_t* decoder_data = data + 4;
-      if (!rle_decoder_) {
-        rle_decoder_ =
-            std::make_unique<RleDecoder>(decoder_data, num_bytes, bit_width_);
+      const uint8_t* decoderData = data + 4;
+      if (!rleDecoder_) {
+        rleDecoder_ =
+            std::make_unique<RleDecoder>(decoderData, numBytes, bitWidth_);
       } else {
-        rle_decoder_->Reset(decoder_data, num_bytes, bit_width_);
+        rleDecoder_->Reset(decoderData, numBytes, bitWidth_);
       }
-      return 4 + num_bytes;
+      return 4 + numBytes;
     }
-    case Encoding::BIT_PACKED: {
-      int num_bits = 0;
-      if (MultiplyWithOverflow(num_buffered_values, bit_width_, &num_bits)) {
+    case Encoding::kBitPacked: {
+      int32_t numBits = 0;
+      if (MultiplyWithOverflow(numBufferedValues, bitWidth_, &numBits)) {
         throw ParquetException(
             "Number of buffered values too large (corrupt data page?)");
       }
-      num_bytes =
-          static_cast<int32_t>(::arrow::bit_util::BytesForBits(num_bits));
-      if (num_bytes < 0 || num_bytes > data_size - 4) {
+      numBytes = static_cast<int32_t>(::arrow::bit_util::BytesForBits(numBits));
+      if (numBytes < 0 || numBytes > dataSize - 4) {
         throw ParquetException(
             "Received invalid number of bytes (corrupt data page?)");
       }
-      if (!bit_packed_decoder_) {
-        bit_packed_decoder_ = std::make_unique<BitReader>(data, num_bytes);
+      if (!bitPackedDecoder_) {
+        bitPackedDecoder_ = std::make_unique<BitReader>(data, numBytes);
       } else {
-        bit_packed_decoder_->Reset(data, num_bytes);
+        bitPackedDecoder_->Reset(data, numBytes);
       }
-      return num_bytes;
+      return numBytes;
     }
     default:
       throw ParquetException("Unknown encoding type for levels.");
@@ -163,265 +162,263 @@ int LevelDecoder::SetData(
   return -1;
 }
 
-void LevelDecoder::SetDataV2(
-    int32_t num_bytes,
-    int16_t max_level,
-    int num_buffered_values,
+void LevelDecoder::setDataV2(
+    int32_t numBytes,
+    int16_t maxLevel,
+    int numBufferedValues,
     const uint8_t* data) {
-  max_level_ = max_level;
-  // Repetition and definition levels always uses RLE encoding
-  // in the DataPageV2 format.
-  if (num_bytes < 0) {
+  maxLevel_ = maxLevel;
+  // Repetition and definition levels always uses RLE encoding.
+  // In the DataPageV2 format.
+  if (numBytes < 0) {
     throw ParquetException("Invalid page header (corrupt data page?)");
   }
-  encoding_ = Encoding::RLE;
-  num_values_remaining_ = num_buffered_values;
-  bit_width_ = ::arrow::bit_util::Log2(max_level + 1);
+  encoding_ = Encoding::kRle;
+  numValuesRemaining_ = numBufferedValues;
+  bitWidth_ = ::arrow::bit_util::Log2(maxLevel + 1);
 
-  if (!rle_decoder_) {
-    rle_decoder_ = std::make_unique<RleDecoder>(data, num_bytes, bit_width_);
+  if (!rleDecoder_) {
+    rleDecoder_ = std::make_unique<RleDecoder>(data, numBytes, bitWidth_);
   } else {
-    rle_decoder_->Reset(data, num_bytes, bit_width_);
+    rleDecoder_->Reset(data, numBytes, bitWidth_);
   }
 }
 
-int LevelDecoder::Decode(int batch_size, int16_t* levels) {
-  int num_decoded = 0;
+int LevelDecoder::decode(int batchSize, int16_t* levels) {
+  int numDecoded = 0;
 
-  int num_values = std::min(num_values_remaining_, batch_size);
-  if (encoding_ == Encoding::RLE) {
-    num_decoded = rle_decoder_->GetBatch(levels, num_values);
+  int numValues = std::min(numValuesRemaining_, batchSize);
+  if (encoding_ == Encoding::kRle) {
+    numDecoded = rleDecoder_->GetBatch(levels, numValues);
   } else {
-    num_decoded = bit_packed_decoder_->GetBatch(bit_width_, levels, num_values);
+    numDecoded = bitPackedDecoder_->GetBatch(bitWidth_, levels, numValues);
   }
-  if (num_decoded > 0) {
-    MinMax min_max = FindMinMax(levels, num_decoded);
-    if (ARROW_PREDICT_FALSE(min_max.min < 0 || min_max.max > max_level_)) {
+  if (numDecoded > 0) {
+    MinMax minMax = FindMinMax(levels, numDecoded);
+    if (ARROW_PREDICT_FALSE(minMax.min < 0 || minMax.max > maxLevel_)) {
       std::stringstream ss;
-      ss << "Malformed levels. min: " << min_max.min << " max: " << min_max.max
-         << " out of range.  Max Level: " << max_level_;
+      ss << "Malformed levels. min: " << minMax.min << " max: " << minMax.max
+         << " out of range.  Max Level: " << maxLevel_;
       throw ParquetException(ss.str());
     }
   }
-  num_values_remaining_ -= num_decoded;
-  return num_decoded;
+  numValuesRemaining_ -= numDecoded;
+  return numDecoded;
 }
 
 namespace {
 
-// Extracts encoded statistics from V1 and V2 data page headers
+// Extracts encoded statistics from V1 and V2 data page headers.
 template <typename H>
-EncodedStatistics ExtractStatsFromHeader(const H& header) {
-  EncodedStatistics page_statistics;
+EncodedStatistics extractStatsFromHeader(const H& header) {
+  EncodedStatistics pageStatistics;
   if (!header.__isset.statistics) {
-    return page_statistics;
+    return pageStatistics;
   }
   const facebook::velox::parquet::thrift::Statistics& stats = header.statistics;
-  // Use the new V2 min-max statistics over the former one if it is filled
+  // Use the new V2 min-max statistics over the former one if it is filled.
   if (stats.__isset.max_value || stats.__isset.min_value) {
     // TODO: check if the column_order is TYPE_DEFINED_ORDER.
     if (stats.__isset.max_value) {
-      page_statistics.set_max(stats.max_value);
+      pageStatistics.setMax(stats.max_value);
     }
     if (stats.__isset.min_value) {
-      page_statistics.set_min(stats.min_value);
+      pageStatistics.setMin(stats.min_value);
     }
   } else if (stats.__isset.max || stats.__isset.min) {
     // TODO: check created_by to see if it is corrupted for some types.
     // TODO: check if the sort_order is SIGNED.
     if (stats.__isset.max) {
-      page_statistics.set_max(stats.max);
+      pageStatistics.setMax(stats.max);
     }
     if (stats.__isset.min) {
-      page_statistics.set_min(stats.min);
+      pageStatistics.setMin(stats.min);
     }
   }
   if (stats.__isset.null_count) {
-    page_statistics.set_null_count(stats.null_count);
+    pageStatistics.setNullCount(stats.null_count);
   }
   if (stats.__isset.distinct_count) {
-    page_statistics.set_distinct_count(stats.distinct_count);
+    pageStatistics.setDistinctCount(stats.distinct_count);
   }
-  return page_statistics;
+  return pageStatistics;
 }
 
-void CheckNumValuesInHeader(int num_values) {
-  if (num_values < 0) {
+void checkNumValuesInHeader(int numValues) {
+  if (numValues < 0) {
     throw ParquetException("Invalid page header (negative number of values)");
   }
 }
 
-// ----------------------------------------------------------------------
-// SerializedPageReader deserializes Thrift metadata and pages that have been
-// assembled in a serialized stream for storing in a Parquet files
+// ----------------------------------------------------------------------.
+// SerializedPageReader deserializes Thrift metadata and pages that have been.
+// Assembled in a serialized stream for storing in a Parquet files.
 
-// This subclass delimits pages appearing in a serialized stream, each preceded
-// by a serialized Thrift facebook::velox::parquet::thrift::PageHeader
-// indicating the type of each page and the page metadata.
+// This subclass delimits pages appearing in a serialized stream, each preceded.
+// By a serialized Thrift facebook::velox::parquet::thrift::PageHeader.
+// Indicating the type of each page and the page metadata.
 class SerializedPageReader : public PageReader {
  public:
   SerializedPageReader(
       std::shared_ptr<ArrowInputStream> stream,
-      int64_t total_num_values,
-      Compression::type codec,
+      int64_t totalNumValues,
+      Compression::type Codec,
       const ReaderProperties& properties,
-      const CryptoContext* crypto_ctx,
-      bool always_compressed)
+      const CryptoContext* cryptoCtx,
+      bool alwaysCompressed)
       : properties_(properties),
         stream_(std::move(stream)),
-        decompression_buffer_(AllocateBuffer(properties_.memory_pool(), 0)),
-        page_ordinal_(0),
-        seen_num_values_(0),
-        total_num_values_(total_num_values),
-        decryption_buffer_(AllocateBuffer(properties_.memory_pool(), 0)) {
-    if (crypto_ctx != nullptr) {
-      crypto_ctx_ = *crypto_ctx;
-      InitDecryption();
+        decompressionBuffer_(allocateBuffer(properties_.memoryPool(), 0)),
+        pageOrdinal_(0),
+        seenNumValues_(0),
+        totalNumValues_(totalNumValues),
+        decryptionBuffer_(allocateBuffer(properties_.memoryPool(), 0)) {
+    if (cryptoCtx != nullptr) {
+      cryptoCtx_ = *cryptoCtx;
+      initDecryption();
     }
-    max_page_header_size_ = kDefaultMaxPageHeaderSize;
-    decompressor_ = GetCodec(codec);
-    always_compressed_ = always_compressed;
+    maxPageHeaderSize_ = kDefaultMaxPageHeaderSize;
+    decompressor_ = getCodec(Codec);
+    alwaysCompressed_ = alwaysCompressed;
   }
 
-  // Implement the PageReader interface
+  // Implement the PageReader interface.
   //
-  // The returned Page contains references that aren't guaranteed to live
-  // beyond the next call to NextPage(). SerializedPageReader reuses the
-  // decryption and decompression buffers internally, so if NextPage() is
-  // called then the content of previous page might be invalidated.
-  std::shared_ptr<Page> NextPage() override;
+  // The returned Page contains references that aren't guaranteed to live.
+  // Beyond the next call to NextPage(). SerializedPageReader reuses the.
+  // Decryption and decompression buffers internally, so if NextPage() is.
+  // Called then the content of previous page might be invalidated.
+  std::shared_ptr<Page> nextPage() override;
 
-  void set_max_page_header_size(uint32_t size) override {
-    max_page_header_size_ = size;
+  void setMaxPageHeaderSize(uint32_t size) override {
+    maxPageHeaderSize_ = size;
   }
 
  private:
-  void UpdateDecryption(
-      const std::shared_ptr<Decryptor>& decryptor,
-      int8_t module_type,
-      std::string* page_aad);
+  void updateDecryption(
+      const std::shared_ptr<Decryptor>& Decryptor,
+      int8_t moduleType,
+      std::string* pageAad);
 
-  void InitDecryption();
+  void initDecryption();
 
-  std::shared_ptr<Buffer> DecompressIfNeeded(
-      std::shared_ptr<Buffer> page_buffer,
-      int compressed_len,
-      int uncompressed_len,
-      int levels_byte_len = 0);
+  std::shared_ptr<Buffer> decompressIfNeeded(
+      std::shared_ptr<Buffer> pageBuffer,
+      int compressedLen,
+      int uncompressedLen,
+      int levelsByteLen = 0);
 
-  // Returns true for non-data pages, and if we should skip based on
-  // data_page_filter_. Performs basic checks on values in the page header.
+  // Returns true for non-data pages, and if we should skip based on.
+  // Data_page_filter_. Performs basic checks on values in the page header.
   // Fills in data_page_statistics.
-  bool ShouldSkipPage(EncodedStatistics* data_page_statistics);
+  bool shouldSkipPage(EncodedStatistics* dataPageStatistics);
 
   const ReaderProperties properties_;
   std::shared_ptr<ArrowInputStream> stream_;
 
-  facebook::velox::parquet::thrift::PageHeader current_page_header_;
-  std::shared_ptr<Page> current_page_;
+  facebook::velox::parquet::thrift::PageHeader currentPageHeader_;
+  std::shared_ptr<Page> currentPage_;
 
   // Compression codec to use.
   std::unique_ptr<util::Codec> decompressor_;
-  std::shared_ptr<ResizableBuffer> decompression_buffer_;
+  std::shared_ptr<ResizableBuffer> decompressionBuffer_;
 
-  bool always_compressed_;
+  bool alwaysCompressed_;
 
-  // The fields below are used for calculation of AAD (additional authenticated
-  // data) suffix which is part of the Parquet Modular Encryption. The AAD
-  // suffix for a parquet module is built internally by concatenating different
-  // parts some of which include the row group ordinal, column ordinal and page
-  // ordinal. Please refer to the encryption specification for more details:
+  // The fields below are used for calculation of AAD (additional authenticated.
+  // Data) suffix which is part of the Parquet Modular Encryption. The AAD.
+  // Suffix for a parquet module is built internally by concatenating different.
+  // Parts some of which include the row group ordinal, column ordinal and page.
+  // Ordinal. Please refer to the encryption specification for more details:
   // https://github.com/apache/parquet-format/blob/encryption/Encryption.md#44-additional-authenticated-data
 
-  // The ordinal fields in the context below are used for AAD suffix
-  // calculation.
-  CryptoContext crypto_ctx_;
-  int32_t page_ordinal_; // page ordinal does not count the dictionary page
+  // The ordinal fields in the context below are used for AAD suffix.
+  // Calculation.
+  CryptoContext cryptoCtx_;
+  int32_t pageOrdinal_; // page ordinal does not count the dictionary page
 
-  // Maximum allowed page size
-  uint32_t max_page_header_size_;
+  // Maximum allowed page size.
+  uint32_t maxPageHeaderSize_;
 
-  // Number of values read in data pages so far
-  int64_t seen_num_values_;
+  // Number of values read in data pages so far.
+  int64_t seenNumValues_;
 
-  // Number of values in all the data pages
-  int64_t total_num_values_;
+  // Number of values in all the data pages.
+  int64_t totalNumValues_;
 
-  // data_page_aad_ and data_page_header_aad_ contain the AAD for data page and
-  // data page header in a single column respectively. While calculating AAD for
-  // different pages in a single column the pages AAD is updated by only the
-  // page ordinal.
-  std::string data_page_aad_;
-  std::string data_page_header_aad_;
-  // Encryption
-  std::shared_ptr<ResizableBuffer> decryption_buffer_;
+  // Data_page_aad_ and data_page_header_aad_ contain the AAD for data page and.
+  // Data page header in a single column respectively. While calculating AAD
+  // for. Different pages in a single column the pages AAD is updated by only
+  // the. Page ordinal.
+  std::string dataPageAad_;
+  std::string dataPageHeaderAad_;
+  // Encryption.
+  std::shared_ptr<ResizableBuffer> decryptionBuffer_;
 };
 
-void SerializedPageReader::InitDecryption() {
+void SerializedPageReader::initDecryption() {
   // Prepare the AAD for quick update later.
-  if (crypto_ctx_.data_decryptor != nullptr) {
-    VELOX_DCHECK(!crypto_ctx_.data_decryptor->file_aad().empty());
-    data_page_aad_ = encryption::CreateModuleAad(
-        crypto_ctx_.data_decryptor->file_aad(),
+  if (cryptoCtx_.dataDecryptor != nullptr) {
+    VELOX_DCHECK(!cryptoCtx_.dataDecryptor->fileAad().empty());
+    dataPageAad_ = encryption::createModuleAad(
+        cryptoCtx_.dataDecryptor->fileAad(),
         encryption::kDataPage,
-        crypto_ctx_.row_group_ordinal,
-        crypto_ctx_.column_ordinal,
+        cryptoCtx_.rowGroupOrdinal,
+        cryptoCtx_.columnOrdinal,
         kNonPageOrdinal);
   }
-  if (crypto_ctx_.meta_decryptor != nullptr) {
-    VELOX_DCHECK(!crypto_ctx_.meta_decryptor->file_aad().empty());
-    data_page_header_aad_ = encryption::CreateModuleAad(
-        crypto_ctx_.meta_decryptor->file_aad(),
+  if (cryptoCtx_.metaDecryptor != nullptr) {
+    VELOX_DCHECK(!cryptoCtx_.metaDecryptor->fileAad().empty());
+    dataPageHeaderAad_ = encryption::createModuleAad(
+        cryptoCtx_.metaDecryptor->fileAad(),
         encryption::kDataPageHeader,
-        crypto_ctx_.row_group_ordinal,
-        crypto_ctx_.column_ordinal,
+        cryptoCtx_.rowGroupOrdinal,
+        cryptoCtx_.columnOrdinal,
         kNonPageOrdinal);
   }
 }
 
-void SerializedPageReader::UpdateDecryption(
-    const std::shared_ptr<Decryptor>& decryptor,
-    int8_t module_type,
-    std::string* page_aad) {
-  VELOX_DCHECK_NOT_NULL(decryptor);
-  if (crypto_ctx_.start_decrypt_with_dictionary_page) {
-    std::string aad = encryption::CreateModuleAad(
-        decryptor->file_aad(),
-        module_type,
-        crypto_ctx_.row_group_ordinal,
-        crypto_ctx_.column_ordinal,
+void SerializedPageReader::updateDecryption(
+    const std::shared_ptr<Decryptor>& Decryptor,
+    int8_t moduleType,
+    std::string* pageAad) {
+  VELOX_DCHECK_NOT_NULL(Decryptor);
+  if (cryptoCtx_.startDecryptWithDictionaryPage) {
+    std::string aad = encryption::createModuleAad(
+        Decryptor->fileAad(),
+        moduleType,
+        cryptoCtx_.rowGroupOrdinal,
+        cryptoCtx_.columnOrdinal,
         kNonPageOrdinal);
-    decryptor->UpdateAad(aad);
+    Decryptor->updateAad(aad);
   } else {
-    encryption::QuickUpdatePageAad(page_ordinal_, page_aad);
-    decryptor->UpdateAad(*page_aad);
+    encryption::quickUpdatePageAad(pageOrdinal_, pageAad);
+    Decryptor->updateAad(*pageAad);
   }
 }
 
-bool SerializedPageReader::ShouldSkipPage(
-    EncodedStatistics* data_page_statistics) {
-  const PageType::type page_type = LoadEnumSafe(&current_page_header_.type);
-  if (page_type == PageType::DATA_PAGE) {
+bool SerializedPageReader::shouldSkipPage(
+    EncodedStatistics* dataPageStatistics) {
+  const PageType::type pageType = loadenumSafe(&currentPageHeader_.type);
+  if (pageType == PageType::kDataPage) {
     const facebook::velox::parquet::thrift::DataPageHeader& header =
-        current_page_header_.data_page_header;
-    CheckNumValuesInHeader(header.num_values);
-    *data_page_statistics = ExtractStatsFromHeader(header);
-    seen_num_values_ += header.num_values;
-    if (data_page_filter_) {
-      const EncodedStatistics* filter_statistics =
-          data_page_statistics->is_set() ? data_page_statistics : nullptr;
-      DataPageStats data_page_stats(
-          filter_statistics,
-          header.num_values,
-          /*num_rows=*/std::nullopt);
-      if (data_page_filter_(data_page_stats)) {
+        currentPageHeader_.data_page_header;
+    checkNumValuesInHeader(header.num_values);
+    *dataPageStatistics = extractStatsFromHeader(header);
+    seenNumValues_ += header.num_values;
+    if (dataPageFilter_) {
+      const EncodedStatistics* filterStatistics =
+          dataPageStatistics->isSet() ? dataPageStatistics : nullptr;
+      DataPageStats dataPageStats(
+          filterStatistics, header.num_values, std::nullopt);
+      if (dataPageFilter_(dataPageStats)) {
         return true;
       }
     }
-  } else if (page_type == PageType::DATA_PAGE_V2) {
+  } else if (pageType == PageType::kDataPageV2) {
     const facebook::velox::parquet::thrift::DataPageHeaderV2& header =
-        current_page_header_.data_page_header_v2;
-    CheckNumValuesInHeader(header.num_values);
+        currentPageHeader_.data_page_header_v2;
+    checkNumValuesInHeader(header.num_values);
     if (header.num_rows < 0) {
       throw ParquetException("Invalid page header (negative number of rows)");
     }
@@ -430,204 +427,200 @@ bool SerializedPageReader::ShouldSkipPage(
       throw ParquetException(
           "Invalid page header (negative levels byte length)");
     }
-    *data_page_statistics = ExtractStatsFromHeader(header);
-    seen_num_values_ += header.num_values;
-    if (data_page_filter_) {
-      const EncodedStatistics* filter_statistics =
-          data_page_statistics->is_set() ? data_page_statistics : nullptr;
-      DataPageStats data_page_stats(
-          filter_statistics, header.num_values, header.num_rows);
-      if (data_page_filter_(data_page_stats)) {
+    *dataPageStatistics = extractStatsFromHeader(header);
+    seenNumValues_ += header.num_values;
+    if (dataPageFilter_) {
+      const EncodedStatistics* filterStatistics =
+          dataPageStatistics->isSet() ? dataPageStatistics : nullptr;
+      DataPageStats dataPageStats(
+          filterStatistics, header.num_values, header.num_rows);
+      if (dataPageFilter_(dataPageStats)) {
         return true;
       }
     }
-  } else if (page_type == PageType::DICTIONARY_PAGE) {
-    const facebook::velox::parquet::thrift::DictionaryPageHeader& dict_header =
-        current_page_header_.dictionary_page_header;
-    CheckNumValuesInHeader(dict_header.num_values);
+  } else if (pageType == PageType::kDictionaryPage) {
+    const facebook::velox::parquet::thrift::DictionaryPageHeader& dictHeader =
+        currentPageHeader_.dictionary_page_header;
+    checkNumValuesInHeader(dictHeader.num_values);
   } else {
-    // We don't know what this page type is. We're allowed to skip non-data
-    // pages.
+    // We don't know what this page type is. We're allowed to skip non-data.
+    // Pages.
     return true;
   }
   return false;
 }
 
-std::shared_ptr<Page> SerializedPageReader::NextPage() {
+std::shared_ptr<Page> SerializedPageReader::nextPage() {
   ThriftDeserializer deserializer(properties_);
 
-  // Loop here because there may be unhandled page types that we skip until
-  // finding a page that we do know what to do with
-  while (seen_num_values_ < total_num_values_) {
-    uint32_t header_size = 0;
-    uint32_t allowed_page_size = kDefaultPageHeaderSize;
+  // Loop here because there may be unhandled page types that we skip until.
+  // Finding a page that we do know what to do with.
+  while (seenNumValues_ < totalNumValues_) {
+    uint32_t headerSize = 0;
+    uint32_t allowedPageSize = kDefaultPageHeaderSize;
 
-    // Page headers can be very large because of page statistics
-    // We try to deserialize a larger buffer progressively
-    // until a maximum allowed header limit
+    // Page headers can be very large because of page statistics.
+    // We try to deserialize a larger buffer progressively.
+    // Until a maximum allowed header limit.
     while (true) {
-      PARQUET_ASSIGN_OR_THROW(auto view, stream_->Peek(allowed_page_size));
+      PARQUET_ASSIGN_OR_THROW(auto view, stream_->Peek(allowedPageSize));
       if (view.size() == 0) {
         return std::shared_ptr<Page>(nullptr);
       }
 
-      // This gets used, then set by DeserializeThriftMsg
-      header_size = static_cast<uint32_t>(view.size());
+      // This gets used, then set by DeserializeThriftMsg.
+      headerSize = static_cast<uint32_t>(view.size());
       try {
-        if (crypto_ctx_.meta_decryptor != nullptr) {
-          UpdateDecryption(
-              crypto_ctx_.meta_decryptor,
+        if (cryptoCtx_.metaDecryptor != nullptr) {
+          updateDecryption(
+              cryptoCtx_.metaDecryptor,
               encryption::kDictionaryPageHeader,
-              &data_page_header_aad_);
+              &dataPageHeaderAad_);
         }
         // Reset current page header to avoid unclearing the __isset flag.
-        current_page_header_ = facebook::velox::parquet::thrift::PageHeader();
-        deserializer.DeserializeMessage(
+        currentPageHeader_ = facebook::velox::parquet::thrift::PageHeader();
+        deserializer.deserializeMessage(
             reinterpret_cast<const uint8_t*>(view.data()),
-            &header_size,
-            &current_page_header_,
-            crypto_ctx_.meta_decryptor);
+            &headerSize,
+            &currentPageHeader_,
+            cryptoCtx_.metaDecryptor);
         break;
       } catch (std::exception& e) {
-        // Failed to deserialize. Double the allowed page header size and try
-        // again
+        // Failed to deserialize. Double the allowed page header size and try.
+        // Again.
         std::stringstream ss;
         ss << e.what();
-        allowed_page_size *= 2;
-        if (allowed_page_size > max_page_header_size_) {
+        allowedPageSize *= 2;
+        if (allowedPageSize > maxPageHeaderSize_) {
           ss << "Deserializing page header failed.\n";
           throw ParquetException(ss.str());
         }
       }
     }
-    // Advance the stream offset
-    PARQUET_THROW_NOT_OK(stream_->Advance(header_size));
+    // Advance the stream offset.
+    PARQUET_THROW_NOT_OK(stream_->Advance(headerSize));
 
-    int compressed_len = current_page_header_.compressed_page_size;
-    int uncompressed_len = current_page_header_.uncompressed_page_size;
-    if (compressed_len < 0 || uncompressed_len < 0) {
+    int compressedLen = currentPageHeader_.compressed_page_size;
+    int uncompressedLen = currentPageHeader_.uncompressed_page_size;
+    if (compressedLen < 0 || uncompressedLen < 0) {
       throw ParquetException("Invalid page header");
     }
 
-    EncodedStatistics data_page_statistics;
-    if (ShouldSkipPage(&data_page_statistics)) {
-      PARQUET_THROW_NOT_OK(stream_->Advance(compressed_len));
+    EncodedStatistics dataPageStatistics;
+    if (shouldSkipPage(&dataPageStatistics)) {
+      PARQUET_THROW_NOT_OK(stream_->Advance(compressedLen));
       continue;
     }
 
-    if (crypto_ctx_.data_decryptor != nullptr) {
-      UpdateDecryption(
-          crypto_ctx_.data_decryptor,
-          encryption::kDictionaryPage,
-          &data_page_aad_);
+    if (cryptoCtx_.dataDecryptor != nullptr) {
+      updateDecryption(
+          cryptoCtx_.dataDecryptor, encryption::kDictionaryPage, &dataPageAad_);
     }
 
     // Read the compressed data page.
-    PARQUET_ASSIGN_OR_THROW(auto page_buffer, stream_->Read(compressed_len));
-    if (page_buffer->size() != compressed_len) {
+    PARQUET_ASSIGN_OR_THROW(auto pageBuffer, stream_->Read(compressedLen));
+    if (pageBuffer->size() != compressedLen) {
       std::stringstream ss;
-      ss << "Page was smaller (" << page_buffer->size() << ") than expected ("
-         << compressed_len << ")";
-      ParquetException::EofException(ss.str());
+      ss << "Page was smaller (" << pageBuffer->size() << ") than expected ("
+         << compressedLen << ")";
+      ParquetException::eofException(ss.str());
     }
 
-    const PageType::type page_type = LoadEnumSafe(&current_page_header_.type);
+    const PageType::type pageType = loadenumSafe(&currentPageHeader_.type);
 
-    if (properties_.page_checksum_verification() &&
-        current_page_header_.__isset.crc && PageCanUseChecksum(page_type)) {
-      // verify crc
+    if (properties_.pageChecksumVerification() &&
+        currentPageHeader_.__isset.crc && pageCanUseChecksum(pageType)) {
+      // Verify crc.
       uint32_t checksum = ::arrow::internal::crc32(
-          /* prev */ 0, page_buffer->data(), compressed_len);
-      if (static_cast<int32_t>(checksum) != current_page_header_.crc) {
+          /* prev */ 0, pageBuffer->data(), compressedLen);
+      if (static_cast<int32_t>(checksum) != currentPageHeader_.crc) {
         throw ParquetException(
             "could not verify page integrity, CRC checksum verification failed for "
             "page_ordinal " +
-            std::to_string(page_ordinal_));
+            std::to_string(pageOrdinal_));
       }
     }
 
-    // Decrypt it if we need to
-    if (crypto_ctx_.data_decryptor != nullptr) {
-      PARQUET_THROW_NOT_OK(decryption_buffer_->Resize(
-          compressed_len - crypto_ctx_.data_decryptor->CiphertextSizeDelta(),
-          /*shrink_to_fit=*/false));
-      compressed_len = crypto_ctx_.data_decryptor->Decrypt(
-          page_buffer->data(),
-          compressed_len,
-          decryption_buffer_->mutable_data());
+    // Decrypt it if we need to.
+    if (cryptoCtx_.dataDecryptor != nullptr) {
+      PARQUET_THROW_NOT_OK(decryptionBuffer_->Resize(
+          compressedLen - cryptoCtx_.dataDecryptor->ciphertextSizeDelta(),
+          false));
+      compressedLen = cryptoCtx_.dataDecryptor->decrypt(
+          pageBuffer->data(), compressedLen, decryptionBuffer_->mutable_data());
 
-      page_buffer = decryption_buffer_;
+      pageBuffer = decryptionBuffer_;
     }
 
-    if (page_type == PageType::DICTIONARY_PAGE) {
-      crypto_ctx_.start_decrypt_with_dictionary_page = false;
-      const facebook::velox::parquet::thrift::DictionaryPageHeader&
-          dict_header = current_page_header_.dictionary_page_header;
-      bool is_sorted =
-          dict_header.__isset.is_sorted ? dict_header.is_sorted : false;
+    if (pageType == PageType::kDictionaryPage) {
+      cryptoCtx_.startDecryptWithDictionaryPage = false;
+      const facebook::velox::parquet::thrift::DictionaryPageHeader& dictHeader =
+          currentPageHeader_.dictionary_page_header;
+      bool isSorted =
+          dictHeader.__isset.is_sorted ? dictHeader.is_sorted : false;
 
-      page_buffer = DecompressIfNeeded(
-          std::move(page_buffer), compressed_len, uncompressed_len);
+      pageBuffer = decompressIfNeeded(
+          std::move(pageBuffer), compressedLen, uncompressedLen);
 
       return std::make_shared<DictionaryPage>(
-          page_buffer,
-          dict_header.num_values,
-          LoadEnumSafe(&dict_header.encoding),
-          is_sorted);
-    } else if (page_type == PageType::DATA_PAGE) {
-      ++page_ordinal_;
+          pageBuffer,
+          dictHeader.num_values,
+          loadenumSafe(&dictHeader.encoding),
+          isSorted);
+    } else if (pageType == PageType::kDataPage) {
+      ++pageOrdinal_;
       const facebook::velox::parquet::thrift::DataPageHeader& header =
-          current_page_header_.data_page_header;
-      page_buffer = DecompressIfNeeded(
-          std::move(page_buffer), compressed_len, uncompressed_len);
+          currentPageHeader_.data_page_header;
+      pageBuffer = decompressIfNeeded(
+          std::move(pageBuffer), compressedLen, uncompressedLen);
 
       return std::make_shared<DataPageV1>(
-          page_buffer,
+          pageBuffer,
           header.num_values,
-          LoadEnumSafe(&header.encoding),
-          LoadEnumSafe(&header.definition_level_encoding),
-          LoadEnumSafe(&header.repetition_level_encoding),
-          uncompressed_len,
-          data_page_statistics);
-    } else if (page_type == PageType::DATA_PAGE_V2) {
-      ++page_ordinal_;
+          loadenumSafe(&header.encoding),
+          loadenumSafe(&header.definition_level_encoding),
+          loadenumSafe(&header.repetition_level_encoding),
+          uncompressedLen,
+          dataPageStatistics);
+    } else if (pageType == PageType::kDataPageV2) {
+      ++pageOrdinal_;
       const facebook::velox::parquet::thrift::DataPageHeaderV2& header =
-          current_page_header_.data_page_header_v2;
+          currentPageHeader_.data_page_header_v2;
 
       // Arrow prior to 3.0.0 set is_compressed to false but still compressed.
-      bool is_compressed =
+      bool isCompressed =
           (header.__isset.is_compressed ? header.is_compressed : false) ||
-          always_compressed_;
+          alwaysCompressed_;
 
-      // Uncompress if needed
-      int levels_byte_len;
+      // Uncompress if needed.
+      int levelsByteLen;
       if (AddWithOverflow(
               header.definition_levels_byte_length,
               header.repetition_levels_byte_length,
-              &levels_byte_len)) {
+              &levelsByteLen)) {
         throw ParquetException("Levels size too large (corrupt file?)");
       }
-      // DecompressIfNeeded doesn't take `is_compressed` into account as
-      // it's page type-agnostic.
-      if (is_compressed) {
-        page_buffer = DecompressIfNeeded(
-            std::move(page_buffer),
-            compressed_len,
-            uncompressed_len,
-            levels_byte_len);
+      // DecompressIfNeeded doesn't take `is_compressed` into account as.
+      // It's page type-agnostic.
+      if (isCompressed) {
+        pageBuffer = decompressIfNeeded(
+            std::move(pageBuffer),
+            compressedLen,
+            uncompressedLen,
+            levelsByteLen);
       }
 
       return std::make_shared<DataPageV2>(
-          page_buffer,
+          pageBuffer,
           header.num_values,
           header.num_nulls,
           header.num_rows,
-          LoadEnumSafe(&header.encoding),
+          loadenumSafe(&header.encoding),
           header.definition_levels_byte_length,
           header.repetition_levels_byte_length,
-          uncompressed_len,
-          is_compressed,
-          data_page_statistics);
+          uncompressedLen,
+          isCompressed,
+          dataPageStatistics);
     } else {
       throw ParquetException(
           "Internal error, we have already skipped non-data pages in ShouldSkipPage()");
@@ -636,204 +629,200 @@ std::shared_ptr<Page> SerializedPageReader::NextPage() {
   return std::shared_ptr<Page>(nullptr);
 }
 
-std::shared_ptr<Buffer> SerializedPageReader::DecompressIfNeeded(
-    std::shared_ptr<Buffer> page_buffer,
-    int compressed_len,
-    int uncompressed_len,
-    int levels_byte_len) {
+std::shared_ptr<Buffer> SerializedPageReader::decompressIfNeeded(
+    std::shared_ptr<Buffer> pageBuffer,
+    int compressedLen,
+    int uncompressedLen,
+    int levelsByteLen) {
   if (decompressor_ == nullptr) {
-    return page_buffer;
+    return pageBuffer;
   }
-  if (compressed_len < levels_byte_len || uncompressed_len < levels_byte_len) {
+  if (compressedLen < levelsByteLen || uncompressedLen < levelsByteLen) {
     throw ParquetException("Invalid page header");
   }
 
   // Grow the uncompressed buffer if we need to.
-  PARQUET_THROW_NOT_OK(
-      decompression_buffer_->Resize(uncompressed_len, /*shrink_to_fit=*/false));
+  PARQUET_THROW_NOT_OK(decompressionBuffer_->Resize(uncompressedLen, false));
 
-  if (levels_byte_len > 0) {
-    // First copy the levels as-is
-    uint8_t* decompressed = decompression_buffer_->mutable_data();
-    memcpy(decompressed, page_buffer->data(), levels_byte_len);
+  if (levelsByteLen > 0) {
+    // First copy the levels as-is.
+    uint8_t* decompressed = decompressionBuffer_->mutable_data();
+    memcpy(decompressed, pageBuffer->data(), levelsByteLen);
   }
 
-  // Decompress the values
-  PARQUET_THROW_NOT_OK(decompressor_->Decompress(
-      compressed_len - levels_byte_len,
-      page_buffer->data() + levels_byte_len,
-      uncompressed_len - levels_byte_len,
-      decompression_buffer_->mutable_data() + levels_byte_len));
+  // Decompress the values.
+  PARQUET_THROW_NOT_OK(decompressor_->decompress(
+      compressedLen - levelsByteLen,
+      pageBuffer->data() + levelsByteLen,
+      uncompressedLen - levelsByteLen,
+      decompressionBuffer_->mutable_data() + levelsByteLen));
 
-  return decompression_buffer_;
+  return decompressionBuffer_;
 }
 
 } // namespace
 
-std::unique_ptr<PageReader> PageReader::Open(
+std::unique_ptr<PageReader> PageReader::open(
     std::shared_ptr<ArrowInputStream> stream,
-    int64_t total_num_values,
-    Compression::type codec,
+    int64_t totalNumValues,
+    Compression::type Codec,
     const ReaderProperties& properties,
-    bool always_compressed,
+    bool alwaysCompressed,
     const CryptoContext* ctx) {
   return std::unique_ptr<PageReader>(new SerializedPageReader(
       std::move(stream),
-      total_num_values,
-      codec,
+      totalNumValues,
+      Codec,
       properties,
       ctx,
-      always_compressed));
+      alwaysCompressed));
 }
 
-std::unique_ptr<PageReader> PageReader::Open(
+std::unique_ptr<PageReader> PageReader::open(
     std::shared_ptr<ArrowInputStream> stream,
-    int64_t total_num_values,
-    Compression::type codec,
-    bool always_compressed,
+    int64_t totalNumValues,
+    Compression::type Codec,
+    bool alwaysCompressed,
     ::arrow::MemoryPool* pool,
     const CryptoContext* ctx) {
   return std::unique_ptr<PageReader>(new SerializedPageReader(
       std::move(stream),
-      total_num_values,
-      codec,
+      totalNumValues,
+      Codec,
       ReaderProperties(pool),
       ctx,
-      always_compressed));
+      alwaysCompressed));
 }
 
 namespace {
 
-// ----------------------------------------------------------------------
-// Impl base class for TypedColumnReader and RecordReader
+// ----------------------------------------------------------------------.
+// Impl base class for TypedColumnReader and RecordReader.
 
-// PLAIN_DICTIONARY is deprecated but used to be used as a dictionary index
-// encoding.
-static bool IsDictionaryIndexEncoding(const Encoding::type& e) {
-  return e == Encoding::RLE_DICTIONARY || e == Encoding::PLAIN_DICTIONARY;
+// PLAIN_DICTIONARY is deprecated but used to be used as a dictionary index.
+// Encoding.
+static bool isDictionaryIndexEncoding(const Encoding::type& e) {
+  return e == Encoding::kRleDictionary || e == Encoding::kPlainDictionary;
 }
 
 template <typename DType>
 class ColumnReaderImplBase {
  public:
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
 
   ColumnReaderImplBase(const ColumnDescriptor* descr, ::arrow::MemoryPool* pool)
       : descr_(descr),
-        max_def_level_(descr->max_definition_level()),
-        max_rep_level_(descr->max_repetition_level()),
-        num_buffered_values_(0),
-        num_decoded_values_(0),
+        maxDefLevel_(descr->maxDefinitionLevel()),
+        maxRepLevel_(descr->maxRepetitionLevel()),
+        numBufferedValues_(0),
+        numDecodedValues_(0),
         pool_(pool),
-        current_decoder_(nullptr),
-        current_encoding_(Encoding::UNKNOWN) {}
+        currentDecoder_(nullptr),
+        currentEncoding_(Encoding::kUnknown) {}
 
   virtual ~ColumnReaderImplBase() = default;
 
  protected:
-  // Read up to batch_size values from the current data page into the
-  // pre-allocated memory T*
+  // Read up to batch_size values from the current data page into the.
+  // Pre-allocated memory T*.
   //
-  // @returns: the number of values read into the out buffer
-  int64_t ReadValues(int64_t batch_size, T* out) {
-    int64_t num_decoded =
-        current_decoder_->Decode(out, static_cast<int>(batch_size));
-    return num_decoded;
+  // @returns: the number of values read into the out buffer.
+  int64_t readValues(int64_t batchSize, T* out) {
+    int64_t numDecoded =
+        currentDecoder_->decode(out, static_cast<int>(batchSize));
+    return numDecoded;
   }
 
-  // Read up to batch_size values from the current data page into the
-  // pre-allocated memory T*, leaving spaces for null entries according
-  // to the def_levels.
+  // Read up to batch_size values from the current data page into the.
+  // Pre-allocated memory T*, leaving spaces for null entries according.
+  // To the def_levels.
   //
-  // @returns: the number of values read into the out buffer
-  int64_t ReadValuesSpaced(
-      int64_t batch_size,
+  // @returns: the number of values read into the out buffer.
+  int64_t readValuesSpaced(
+      int64_t batchSize,
       T* out,
-      int64_t null_count,
-      uint8_t* valid_bits,
-      int64_t valid_bits_offset) {
-    return current_decoder_->DecodeSpaced(
+      int64_t nullCount,
+      uint8_t* validBits,
+      int64_t validBitsOffset) {
+    return currentDecoder_->decodeSpaced(
         out,
-        static_cast<int>(batch_size),
-        static_cast<int>(null_count),
-        valid_bits,
-        valid_bits_offset);
+        static_cast<int>(batchSize),
+        static_cast<int>(nullCount),
+        validBits,
+        validBitsOffset);
   }
 
-  // Read multiple definition levels into preallocated memory
+  // Read multiple definition levels into preallocated memory.
   //
-  // Returns the number of decoded definition levels
-  int64_t ReadDefinitionLevels(int64_t batch_size, int16_t* levels) {
-    if (max_def_level_ == 0) {
+  // Returns the number of decoded definition levels.
+  int64_t readDefinitionLevels(int64_t batchSize, int16_t* levels) {
+    if (maxDefLevel_ == 0) {
       return 0;
     }
-    return definition_level_decoder_.Decode(
-        static_cast<int>(batch_size), levels);
+    return definitionLevelDecoder_.decode(static_cast<int>(batchSize), levels);
   }
 
-  bool HasNextInternal() {
-    // Either there is no data page available yet, or the data page has been
-    // exhausted
-    if (num_buffered_values_ == 0 ||
-        num_decoded_values_ == num_buffered_values_) {
-      if (!ReadNewPage() || num_buffered_values_ == 0) {
+  bool hasNextInternal() {
+    // Either there is no data page available yet, or the data page has been.
+    // Exhausted.
+    if (numBufferedValues_ == 0 || numDecodedValues_ == numBufferedValues_) {
+      if (!readNewPage() || numBufferedValues_ == 0) {
         return false;
       }
     }
     return true;
   }
 
-  // Read multiple repetition levels into preallocated memory
-  // Returns the number of decoded repetition levels
-  int64_t ReadRepetitionLevels(int64_t batch_size, int16_t* levels) {
-    if (max_rep_level_ == 0) {
+  // Read multiple repetition levels into preallocated memory.
+  // Returns the number of decoded repetition levels.
+  int64_t readRepetitionLevels(int64_t batchSize, int16_t* levels) {
+    if (maxRepLevel_ == 0) {
       return 0;
     }
-    return repetition_level_decoder_.Decode(
-        static_cast<int>(batch_size), levels);
+    return repetitionLevelDecoder_.decode(static_cast<int>(batchSize), levels);
   }
 
-  // Advance to the next data page
-  bool ReadNewPage() {
+  // Advance to the next data page.
+  bool readNewPage() {
     // Loop until we find the next data page.
     while (true) {
-      current_page_ = pager_->NextPage();
-      if (!current_page_) {
-        // EOS
+      currentPage_ = pager_->nextPage();
+      if (!currentPage_) {
+        // EOS.
         return false;
       }
 
-      if (current_page_->type() == PageType::DICTIONARY_PAGE) {
-        ConfigureDictionary(
-            static_cast<const DictionaryPage*>(current_page_.get()));
+      if (currentPage_->type() == PageType::kDictionaryPage) {
+        configureDictionary(
+            static_cast<const DictionaryPage*>(currentPage_.get()));
         continue;
-      } else if (current_page_->type() == PageType::DATA_PAGE) {
-        const auto page = std::static_pointer_cast<DataPageV1>(current_page_);
-        const int64_t levels_byte_size = InitializeLevelDecoders(
+      } else if (currentPage_->type() == PageType::kDataPage) {
+        const auto page = std::static_pointer_cast<DataPageV1>(currentPage_);
+        const int64_t levelsByteSize = initializeLevelDecoders(
             *page,
-            page->repetition_level_encoding(),
-            page->definition_level_encoding());
-        InitializeDataDecoder(*page, levels_byte_size);
+            page->repetitionLevelEncoding(),
+            page->definitionLevelEncoding());
+        initializeDataDecoder(*page, levelsByteSize);
         return true;
-      } else if (current_page_->type() == PageType::DATA_PAGE_V2) {
-        const auto page = std::static_pointer_cast<DataPageV2>(current_page_);
-        int64_t levels_byte_size = InitializeLevelDecodersV2(*page);
-        InitializeDataDecoder(*page, levels_byte_size);
+      } else if (currentPage_->type() == PageType::kDataPageV2) {
+        const auto page = std::static_pointer_cast<DataPageV2>(currentPage_);
+        int64_t levelsByteSize = initializeLevelDecodersV2(*page);
+        initializeDataDecoder(*page, levelsByteSize);
         return true;
       } else {
-        // We don't know what this page type is. We're allowed to skip non-data
-        // pages.
+        // We don't know what this page type is. We're allowed to skip non-data.
+        // Pages.
         continue;
       }
     }
     return true;
   }
 
-  void ConfigureDictionary(const DictionaryPage* page) {
+  void configureDictionary(const DictionaryPage* page) {
     int encoding = static_cast<int>(page->encoding());
-    if (page->encoding() == Encoding::PLAIN_DICTIONARY ||
-        page->encoding() == Encoding::PLAIN) {
-      encoding = static_cast<int>(Encoding::RLE_DICTIONARY);
+    if (page->encoding() == Encoding::kPlainDictionary ||
+        page->encoding() == Encoding::kPlain) {
+      encoding = static_cast<int>(Encoding::kRleDictionary);
     }
 
     auto it = decoders_.find(encoding);
@@ -841,20 +830,20 @@ class ColumnReaderImplBase {
       throw ParquetException("Column cannot have more than one dictionary.");
     }
 
-    if (page->encoding() == Encoding::PLAIN_DICTIONARY ||
-        page->encoding() == Encoding::PLAIN) {
-      auto dictionary = MakeTypedDecoder<DType>(Encoding::PLAIN, descr_);
-      dictionary->SetData(page->num_values(), page->data(), page->size());
+    if (page->encoding() == Encoding::kPlainDictionary ||
+        page->encoding() == Encoding::kPlain) {
+      auto dictionary = makeTypedDecoder<DType>(Encoding::kPlain, descr_);
+      dictionary->setData(page->numValues(), page->data(), page->size());
 
-      // The dictionary is fully decoded during DictionaryDecoder::Init, so the
-      // DictionaryPage buffer is no longer required after this step
+      // The dictionary is fully decoded during DictionaryDecoder::Init, so the.
+      // DictionaryPage buffer is no longer required after this step.
       //
-      // TODO(wesm): investigate whether this all-or-nothing decoding of the
-      // dictionary makes sense and whether performance can be improved
+      // TODO(wesm): investigate whether this all-or-nothing decoding of the.
+      // Dictionary makes sense and whether performance can be improved.
 
       std::unique_ptr<DictDecoder<DType>> decoder =
-          MakeDictDecoder<DType>(descr_, pool_);
-      decoder->SetDict(dictionary.get());
+          makeDictDecoder<DType>(descr_, pool_);
+      decoder->setDict(dictionary.get());
       decoders_[encoding] = std::unique_ptr<DecoderType>(
           dynamic_cast<DecoderType*>(decoder.release()));
     } else {
@@ -862,164 +851,164 @@ class ColumnReaderImplBase {
           "only plain dictionary encoding has been implemented");
     }
 
-    new_dictionary_ = true;
-    current_decoder_ = decoders_[encoding].get();
-    VELOX_DCHECK(current_decoder_);
+    newDictionary_ = true;
+    currentDecoder_ = decoders_[encoding].get();
+    VELOX_DCHECK(currentDecoder_);
   }
 
   // Initialize repetition and definition level decoders on the next data page.
 
-  // If the data page includes repetition and definition levels, we
-  // initialize the level decoders and return the number of encoded level bytes.
+  // If the data page includes repetition and definition levels, we.
+  // Initialize the level decoders and return the number of encoded level bytes.
   // The return value helps determine the number of bytes in the encoded data.
-  int64_t InitializeLevelDecoders(
+  int64_t initializeLevelDecoders(
       const DataPage& page,
-      Encoding::type repetition_level_encoding,
-      Encoding::type definition_level_encoding) {
+      Encoding::type repetitionLevelEncoding,
+      Encoding::type definitionLevelEncoding) {
     // Read a data page.
-    num_buffered_values_ = page.num_values();
+    numBufferedValues_ = page.numValues();
 
-    // Have not decoded any values from the data page yet
-    num_decoded_values_ = 0;
+    // Have not decoded any values from the data page yet.
+    numDecodedValues_ = 0;
 
     const uint8_t* buffer = page.data();
-    int32_t levels_byte_size = 0;
-    int32_t max_size = page.size();
+    int32_t levelsByteSize = 0;
+    int32_t maxSize = page.size();
 
     // Data page Layout: Repetition Levels - Definition Levels - encoded values.
     // Levels are encoded as rle or bit-packed.
-    // Init repetition levels
-    if (max_rep_level_ > 0) {
-      int32_t rep_levels_bytes = repetition_level_decoder_.SetData(
-          repetition_level_encoding,
-          max_rep_level_,
-          static_cast<int>(num_buffered_values_),
+    // Init repetition levels.
+    if (maxRepLevel_ > 0) {
+      int32_t repLevelsBytes = repetitionLevelDecoder_.setData(
+          repetitionLevelEncoding,
+          maxRepLevel_,
+          static_cast<int>(numBufferedValues_),
           buffer,
-          max_size);
-      buffer += rep_levels_bytes;
-      levels_byte_size += rep_levels_bytes;
-      max_size -= rep_levels_bytes;
-    }
-    // TODO figure a way to set max_def_level_ to 0
-    // if the initial value is invalid
-
-    // Init definition levels
-    if (max_def_level_ > 0) {
-      int32_t def_levels_bytes = definition_level_decoder_.SetData(
-          definition_level_encoding,
-          max_def_level_,
-          static_cast<int>(num_buffered_values_),
+          maxSize);
+      buffer += repLevelsBytes;
+      levelsByteSize += repLevelsBytes;
+      maxSize -= repLevelsBytes;
+    }
+    // TODO figure a way to set max_def_level_ to 0.
+    // If the initial value is invalid.
+
+    // Init definition levels.
+    if (maxDefLevel_ > 0) {
+      int32_t defLevelsBytes = definitionLevelDecoder_.setData(
+          definitionLevelEncoding,
+          maxDefLevel_,
+          static_cast<int>(numBufferedValues_),
           buffer,
-          max_size);
-      levels_byte_size += def_levels_bytes;
-      max_size -= def_levels_bytes;
+          maxSize);
+      levelsByteSize += defLevelsBytes;
+      maxSize -= defLevelsBytes;
     }
 
-    return levels_byte_size;
+    return levelsByteSize;
   }
 
-  int64_t InitializeLevelDecodersV2(const DataPageV2& page) {
+  int64_t initializeLevelDecodersV2(const DataPageV2& page) {
     // Read a data page.
-    num_buffered_values_ = page.num_values();
+    numBufferedValues_ = page.numValues();
 
-    // Have not decoded any values from the data page yet
-    num_decoded_values_ = 0;
+    // Have not decoded any values from the data page yet.
+    numDecodedValues_ = 0;
     const uint8_t* buffer = page.data();
 
-    const int64_t total_levels_length =
-        static_cast<int64_t>(page.repetition_levels_byte_length()) +
-        page.definition_levels_byte_length();
+    const int64_t totalLevelsLength =
+        static_cast<int64_t>(page.repetitionLevelsByteLength()) +
+        page.definitionLevelsByteLength();
 
-    if (total_levels_length > page.size()) {
+    if (totalLevelsLength > page.size()) {
       throw ParquetException(
           "Data page too small for levels (corrupt header?)");
     }
 
-    if (max_rep_level_ > 0) {
-      repetition_level_decoder_.SetDataV2(
-          page.repetition_levels_byte_length(),
-          max_rep_level_,
-          static_cast<int>(num_buffered_values_),
+    if (maxRepLevel_ > 0) {
+      repetitionLevelDecoder_.setDataV2(
+          page.repetitionLevelsByteLength(),
+          maxRepLevel_,
+          static_cast<int>(numBufferedValues_),
           buffer);
     }
-    // ARROW-17453: Even if max_rep_level_ is 0, there may still be
-    // repetition level bytes written and/or reported in the header by
+    // ARROW-17453: Even if max_rep_level_ is 0, there may still be.
+    // Repetition level bytes written and/or reported in the header by.
     // some writers (e.g. Athena)
-    buffer += page.repetition_levels_byte_length();
+    buffer += page.repetitionLevelsByteLength();
 
-    if (max_def_level_ > 0) {
-      definition_level_decoder_.SetDataV2(
-          page.definition_levels_byte_length(),
-          max_def_level_,
-          static_cast<int>(num_buffered_values_),
+    if (maxDefLevel_ > 0) {
+      definitionLevelDecoder_.setDataV2(
+          page.definitionLevelsByteLength(),
+          maxDefLevel_,
+          static_cast<int>(numBufferedValues_),
           buffer);
     }
 
-    return total_levels_length;
+    return totalLevelsLength;
   }
 
-  // Get a decoder object for this page or create a new decoder if this is the
-  // first page with this encoding.
-  void InitializeDataDecoder(const DataPage& page, int64_t levels_byte_size) {
-    const uint8_t* buffer = page.data() + levels_byte_size;
-    const int64_t data_size = page.size() - levels_byte_size;
+  // Get a decoder object for this page or create a new decoder if this is the.
+  // First page with this encoding.
+  void initializeDataDecoder(const DataPage& page, int64_t levelsByteSize) {
+    const uint8_t* buffer = page.data() + levelsByteSize;
+    const int64_t dataSize = page.size() - levelsByteSize;
 
-    if (data_size < 0) {
+    if (dataSize < 0) {
       throw ParquetException("Page smaller than size of encoded levels");
     }
 
     Encoding::type encoding = page.encoding();
 
-    if (IsDictionaryIndexEncoding(encoding)) {
-      encoding = Encoding::RLE_DICTIONARY;
+    if (isDictionaryIndexEncoding(encoding)) {
+      encoding = Encoding::kRleDictionary;
     }
 
     auto it = decoders_.find(static_cast<int>(encoding));
     if (it != decoders_.end()) {
       VELOX_DCHECK_NOT_NULL(it->second.get());
-      current_decoder_ = it->second.get();
+      currentDecoder_ = it->second.get();
     } else {
       switch (encoding) {
-        case Encoding::PLAIN: {
-          auto decoder = MakeTypedDecoder<DType>(Encoding::PLAIN, descr_);
-          current_decoder_ = decoder.get();
+        case Encoding::kPlain: {
+          auto decoder = makeTypedDecoder<DType>(Encoding::kPlain, descr_);
+          currentDecoder_ = decoder.get();
           decoders_[static_cast<int>(encoding)] = std::move(decoder);
           break;
         }
-        case Encoding::BYTE_STREAM_SPLIT: {
+        case Encoding::kByteStreamSplit: {
           auto decoder =
-              MakeTypedDecoder<DType>(Encoding::BYTE_STREAM_SPLIT, descr_);
-          current_decoder_ = decoder.get();
+              makeTypedDecoder<DType>(Encoding::kByteStreamSplit, descr_);
+          currentDecoder_ = decoder.get();
           decoders_[static_cast<int>(encoding)] = std::move(decoder);
           break;
         }
-        case Encoding::RLE: {
-          auto decoder = MakeTypedDecoder<DType>(Encoding::RLE, descr_);
-          current_decoder_ = decoder.get();
+        case Encoding::kRle: {
+          auto decoder = makeTypedDecoder<DType>(Encoding::kRle, descr_);
+          currentDecoder_ = decoder.get();
           decoders_[static_cast<int>(encoding)] = std::move(decoder);
           break;
         }
-        case Encoding::RLE_DICTIONARY:
+        case Encoding::kRleDictionary:
           throw ParquetException("Dictionary page must be before data page.");
 
-        case Encoding::DELTA_BINARY_PACKED: {
+        case Encoding::kDeltaBinaryPacked: {
           auto decoder =
-              MakeTypedDecoder<DType>(Encoding::DELTA_BINARY_PACKED, descr_);
-          current_decoder_ = decoder.get();
+              makeTypedDecoder<DType>(Encoding::kDeltaBinaryPacked, descr_);
+          currentDecoder_ = decoder.get();
           decoders_[static_cast<int>(encoding)] = std::move(decoder);
           break;
         }
-        case Encoding::DELTA_BYTE_ARRAY: {
+        case Encoding::kDeltaByteArray: {
           auto decoder =
-              MakeTypedDecoder<DType>(Encoding::DELTA_BYTE_ARRAY, descr_);
-          current_decoder_ = decoder.get();
+              makeTypedDecoder<DType>(Encoding::kDeltaByteArray, descr_);
+          currentDecoder_ = decoder.get();
           decoders_[static_cast<int>(encoding)] = std::move(decoder);
           break;
         }
-        case Encoding::DELTA_LENGTH_BYTE_ARRAY: {
-          auto decoder = MakeTypedDecoder<DType>(
-              Encoding::DELTA_LENGTH_BYTE_ARRAY, descr_);
-          current_decoder_ = decoder.get();
+        case Encoding::kDeltaLengthByteArray: {
+          auto decoder =
+              makeTypedDecoder<DType>(Encoding::kDeltaLengthByteArray, descr_);
+          currentDecoder_ = decoder.get();
           decoders_[static_cast<int>(encoding)] = std::move(decoder);
           break;
         }
@@ -1028,73 +1017,73 @@ class ColumnReaderImplBase {
           throw ParquetException("Unknown encoding type.");
       }
     }
-    current_encoding_ = encoding;
-    current_decoder_->SetData(
-        static_cast<int>(num_buffered_values_),
+    currentEncoding_ = encoding;
+    currentDecoder_->setData(
+        static_cast<int>(numBufferedValues_),
         buffer,
-        static_cast<int>(data_size));
+        static_cast<int>(dataSize));
   }
 
-  int64_t available_values_current_page() const {
-    return num_buffered_values_ - num_decoded_values_;
+  int64_t availableValuesCurrentPage() const {
+    return numBufferedValues_ - numDecodedValues_;
   }
 
   const ColumnDescriptor* descr_;
-  const int16_t max_def_level_;
-  const int16_t max_rep_level_;
+  const int16_t maxDefLevel_;
+  const int16_t maxRepLevel_;
 
   std::unique_ptr<PageReader> pager_;
-  std::shared_ptr<Page> current_page_;
+  std::shared_ptr<Page> currentPage_;
 
-  // Not set if full schema for this field has no optional or repeated elements
-  LevelDecoder definition_level_decoder_;
+  // Not set if full schema for this field has no optional or repeated elements.
+  LevelDecoder definitionLevelDecoder_;
 
   // Not set for flat schemas.
-  LevelDecoder repetition_level_decoder_;
+  LevelDecoder repetitionLevelDecoder_;
 
-  // The total number of values stored in the data page. This is the maximum of
-  // the number of encoded definition levels or encoded values. For
-  // non-repeated, required columns, this is equal to the number of encoded
-  // values. For repeated or optional values, there may be fewer data values
-  // than levels, and this tells you how many encoded levels there are in that
-  // case.
-  int64_t num_buffered_values_;
+  // The total number of values stored in the data page. This is the maximum of.
+  // The number of encoded definition levels or encoded values. For.
+  // Non-repeated, required columns, this is equal to the number of encoded.
+  // Values. For repeated or optional values, there may be fewer data values.
+  // Than levels, and this tells you how many encoded levels there are in that.
+  // Case.
+  int64_t numBufferedValues_;
 
-  // The number of values from the current data page that have been decoded
-  // into memory
-  int64_t num_decoded_values_;
+  // The number of values from the current data page that have been decoded.
+  // Into memory.
+  int64_t numDecodedValues_;
 
   ::arrow::MemoryPool* pool_;
 
   using DecoderType = TypedDecoder<DType>;
-  DecoderType* current_decoder_;
-  Encoding::type current_encoding_;
+  DecoderType* currentDecoder_;
+  Encoding::type currentEncoding_;
 
-  /// Flag to signal when a new dictionary has been set, for the benefit of
-  /// DictionaryRecordReader
-  bool new_dictionary_;
+  /// Flag to signal when a new dictionary has been set, for the benefit of.
+  /// DictionaryRecordReader.
+  bool newDictionary_;
 
-  // The exposed encoding
-  ExposedEncoding exposed_encoding_ = ExposedEncoding::NO_ENCODING;
+  // The exposed encoding.
+  ExposedEncoding exposedEncoding_ = ExposedEncoding::kNoEncoding;
 
-  // Map of encoding type to the respective decoder object. For example, a
-  // column chunk's data pages may include both dictionary-encoded and
-  // plain-encoded data.
+  // Map of encoding type to the respective decoder object. For example, a.
+  // Column chunk's data pages may include both dictionary-encoded and.
+  // Plain-encoded data.
   std::unordered_map<int, std::unique_ptr<DecoderType>> decoders_;
 
-  void ConsumeBufferedValues(int64_t num_values) {
-    num_decoded_values_ += num_values;
+  void consumeBufferedValues(int64_t numValues) {
+    numDecodedValues_ += numValues;
   }
 };
 
-// ----------------------------------------------------------------------
-// TypedColumnReader implementations
+// ----------------------------------------------------------------------.
+// TypedColumnReader implementations.
 
 template <typename DType>
 class TypedColumnReaderImpl : public TypedColumnReader<DType>,
                               public ColumnReaderImplBase<DType> {
  public:
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
 
   TypedColumnReaderImpl(
       const ColumnDescriptor* descr,
@@ -1104,114 +1093,114 @@ class TypedColumnReaderImpl : public TypedColumnReader<DType>,
     this->pager_ = std::move(pager);
   }
 
-  bool HasNext() override {
-    return this->HasNextInternal();
+  bool hasNext() override {
+    return this->hasNextInternal();
   }
 
-  int64_t ReadBatch(
-      int64_t batch_size,
-      int16_t* def_levels,
-      int16_t* rep_levels,
+  int64_t readBatch(
+      int64_t batchSize,
+      int16_t* defLevels,
+      int16_t* repLevels,
       T* values,
-      int64_t* values_read) override;
+      int64_t* valuesRead) override;
 
-  int64_t ReadBatchSpaced(
-      int64_t batch_size,
-      int16_t* def_levels,
-      int16_t* rep_levels,
+  int64_t readBatchSpaced(
+      int64_t batchSize,
+      int16_t* defLevels,
+      int16_t* repLevels,
       T* values,
-      uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      int64_t* levels_read,
-      int64_t* values_read,
-      int64_t* null_count) override;
+      uint8_t* validBits,
+      int64_t validBitsOffset,
+      int64_t* levelsRead,
+      int64_t* valuesRead,
+      int64_t* nullCount) override;
 
-  int64_t Skip(int64_t num_values_to_skip) override;
+  int64_t skip(int64_t numValuesToSkip) override;
 
   Type::type type() const override {
-    return this->descr_->physical_type();
+    return this->descr_->physicalType();
   }
 
   const ColumnDescriptor* descr() const override {
     return this->descr_;
   }
 
-  ExposedEncoding GetExposedEncoding() override {
-    return this->exposed_encoding_;
+  ExposedEncoding getExposedEncoding() override {
+    return this->exposedEncoding_;
   };
 
-  int64_t ReadBatchWithDictionary(
-      int64_t batch_size,
-      int16_t* def_levels,
-      int16_t* rep_levels,
+  int64_t readBatchWithDictionary(
+      int64_t batchSize,
+      int16_t* defLevels,
+      int16_t* repLevels,
       int32_t* indices,
-      int64_t* indices_read,
+      int64_t* indicesRead,
       const T** dict,
-      int32_t* dict_len) override;
+      int32_t* dictLen) override;
 
  protected:
-  void SetExposedEncoding(ExposedEncoding encoding) override {
-    this->exposed_encoding_ = encoding;
+  void setExposedEncoding(ExposedEncoding encoding) override {
+    this->exposedEncoding_ = encoding;
   }
 
-  // Allocate enough scratch space to accommodate skipping 16-bit levels or any
-  // value type.
-  void InitScratchForSkip();
+  // Allocate enough scratch space to accommodate skipping 16-bit levels or any.
+  // Value type.
+  void initScratchForSkip();
 
-  // Scratch space for reading and throwing away rep/def levels and values when
-  // skipping.
-  std::shared_ptr<ResizableBuffer> scratch_for_skip_;
+  // Scratch space for reading and throwing away rep/def levels and values when.
+  // Skipping.
+  std::shared_ptr<ResizableBuffer> scratchForSkip_;
 
  private:
-  // Read dictionary indices. Similar to ReadValues but decode data to
-  // dictionary indices. This function is called only by
+  // Read dictionary indices. Similar to ReadValues but decode data to.
+  // Dictionary indices. This function is called only by.
   // ReadBatchWithDictionary().
-  int64_t ReadDictionaryIndices(int64_t indices_to_read, int32_t* indices) {
-    auto decoder = dynamic_cast<DictDecoder<DType>*>(this->current_decoder_);
-    return decoder->DecodeIndices(static_cast<int>(indices_to_read), indices);
+  int64_t readDictionaryIndices(int64_t indicesToRead, int32_t* indices) {
+    auto decoder = dynamic_cast<DictDecoder<DType>*>(this->currentDecoder_);
+    return decoder->decodeIndices(static_cast<int>(indicesToRead), indices);
   }
 
-  // Get dictionary. The dictionary should have been set by SetDict(). The
-  // dictionary is owned by the internal decoder and is destroyed when the
-  // reader is destroyed. This function is called only by
+  // Get dictionary. The dictionary should have been set by SetDict(). The.
+  // Dictionary is owned by the internal decoder and is destroyed when the.
+  // Reader is destroyed. This function is called only by.
   // ReadBatchWithDictionary() after dictionary is configured.
-  void GetDictionary(const T** dictionary, int32_t* dictionary_length) {
-    auto decoder = dynamic_cast<DictDecoder<DType>*>(this->current_decoder_);
-    decoder->GetDictionary(dictionary, dictionary_length);
-  }
-
-  // Read definition and repetition levels. Also return the number of definition
-  // levels and number of values to read. This function is called before reading
-  // values.
-  void ReadLevels(
-      int64_t batch_size,
-      int16_t* def_levels,
-      int16_t* rep_levels,
-      int64_t* num_def_levels,
-      int64_t* values_to_read) {
-    batch_size = std::min(
-        batch_size, this->num_buffered_values_ - this->num_decoded_values_);
-
-    // If the field is required and non-repeated, there are no definition levels
-    if (this->max_def_level_ > 0 && def_levels != nullptr) {
-      *num_def_levels = this->ReadDefinitionLevels(batch_size, def_levels);
-      // TODO(wesm): this tallying of values-to-decode can be performed with
-      // better cache-efficiency if fused with the level decoding.
-      for (int64_t i = 0; i < *num_def_levels; ++i) {
-        if (def_levels[i] == this->max_def_level_) {
-          ++(*values_to_read);
+  void getDictionary(const T** dictionary, int32_t* dictionaryLength) {
+    auto decoder = dynamic_cast<DictDecoder<DType>*>(this->currentDecoder_);
+    decoder->getDictionary(dictionary, dictionaryLength);
+  }
+
+  // Read definition and repetition levels. Also return the number of
+  // definition. Levels and number of values to read. This function is called
+  // before reading. Values.
+  void readLevels(
+      int64_t batchSize,
+      int16_t* defLevels,
+      int16_t* repLevels,
+      int64_t* numDefLevels,
+      int64_t* valuesToRead) {
+    batchSize =
+        std::min(batchSize, this->numBufferedValues_ - this->numDecodedValues_);
+
+    // If the field is required and non-repeated, there are no definition
+    // levels.
+    if (this->maxDefLevel_ > 0 && defLevels != nullptr) {
+      *numDefLevels = this->readDefinitionLevels(batchSize, defLevels);
+      // TODO(wesm): this tallying of values-to-decode can be performed with.
+      // Better cache-efficiency if fused with the level decoding.
+      for (int64_t i = 0; i < *numDefLevels; ++i) {
+        if (defLevels[i] == this->maxDefLevel_) {
+          ++(*valuesToRead);
         }
       }
     } else {
-      // Required field, read all values
-      *values_to_read = batch_size;
+      // Required field, read all values.
+      *valuesToRead = batchSize;
     }
 
-    // Not present for non-repeated fields
-    if (this->max_rep_level_ > 0 && rep_levels != nullptr) {
-      int64_t num_rep_levels =
-          this->ReadRepetitionLevels(batch_size, rep_levels);
-      if (def_levels != nullptr && *num_def_levels != num_rep_levels) {
+    // Not present for non-repeated fields.
+    if (this->maxRepLevel_ > 0 && repLevels != nullptr) {
+      int64_t numRepLevels = this->readRepetitionLevels(batchSize, repLevels);
+      if (defLevels != nullptr && *numDefLevels != numRepLevels) {
         throw ParquetException(
             "Number of decoded rep / def levels did not match");
       }
@@ -1220,277 +1209,267 @@ class TypedColumnReaderImpl : public TypedColumnReader<DType>,
 };
 
 template <typename DType>
-int64_t TypedColumnReaderImpl<DType>::ReadBatchWithDictionary(
-    int64_t batch_size,
-    int16_t* def_levels,
-    int16_t* rep_levels,
+int64_t TypedColumnReaderImpl<DType>::readBatchWithDictionary(
+    int64_t batchSize,
+    int16_t* defLevels,
+    int16_t* repLevels,
     int32_t* indices,
-    int64_t* indices_read,
+    int64_t* indicesRead,
     const T** dict,
-    int32_t* dict_len) {
-  bool has_dict_output = dict != nullptr && dict_len != nullptr;
+    int32_t* dictLen) {
+  bool hasDictOutput = dict != nullptr && dictLen != nullptr;
   // Similar logic as ReadValues to get pages.
-  if (!HasNext()) {
-    *indices_read = 0;
-    if (has_dict_output) {
+  if (!hasNext()) {
+    *indicesRead = 0;
+    if (hasDictOutput) {
       *dict = nullptr;
-      *dict_len = 0;
+      *dictLen = 0;
     }
     return 0;
   }
 
   // Verify the current data page is dictionary encoded.
-  if (this->current_encoding_ != Encoding::RLE_DICTIONARY) {
+  if (this->currentEncoding_ != Encoding::kRleDictionary) {
     std::stringstream ss;
     ss << "Data page is not dictionary encoded. Encoding: "
-       << EncodingToString(this->current_encoding_);
+       << encodingToString(this->currentEncoding_);
     throw ParquetException(ss.str());
   }
 
   // Get dictionary pointer and length.
-  if (has_dict_output) {
-    GetDictionary(dict, dict_len);
+  if (hasDictOutput) {
+    getDictionary(dict, dictLen);
   }
 
   // Similar logic as ReadValues to get def levels and rep levels.
-  int64_t num_def_levels = 0;
-  int64_t indices_to_read = 0;
-  ReadLevels(
-      batch_size, def_levels, rep_levels, &num_def_levels, &indices_to_read);
+  int64_t numDefLevels = 0;
+  int64_t indicesToRead = 0;
+  readLevels(batchSize, defLevels, repLevels, &numDefLevels, &indicesToRead);
 
   // Read dictionary indices.
-  *indices_read = ReadDictionaryIndices(indices_to_read, indices);
-  int64_t total_indices = std::max<int64_t>(num_def_levels, *indices_read);
+  *indicesRead = readDictionaryIndices(indicesToRead, indices);
+  int64_t totalIndices = std::max<int64_t>(numDefLevels, *indicesRead);
   // Some callers use a batch size of 0 just to get the dictionary.
-  int64_t expected_values = std::min(
-      batch_size, this->num_buffered_values_ - this->num_decoded_values_);
-  if (total_indices == 0 && expected_values > 0) {
+  int64_t expectedValues =
+      std::min(batchSize, this->numBufferedValues_ - this->numDecodedValues_);
+  if (totalIndices == 0 && expectedValues > 0) {
     std::stringstream ss;
-    ss << "Read 0 values, expected " << expected_values;
-    ParquetException::EofException(ss.str());
+    ss << "Read 0 values, expected " << expectedValues;
+    ParquetException::eofException(ss.str());
   }
-  this->ConsumeBufferedValues(total_indices);
+  this->consumeBufferedValues(totalIndices);
 
-  return total_indices;
+  return totalIndices;
 }
 
 template <typename DType>
-int64_t TypedColumnReaderImpl<DType>::ReadBatch(
-    int64_t batch_size,
-    int16_t* def_levels,
-    int16_t* rep_levels,
+int64_t TypedColumnReaderImpl<DType>::readBatch(
+    int64_t batchSize,
+    int16_t* defLevels,
+    int16_t* repLevels,
     T* values,
-    int64_t* values_read) {
-  // HasNext invokes ReadNewPage
-  if (!HasNext()) {
-    *values_read = 0;
+    int64_t* valuesRead) {
+  // HasNext invokes ReadNewPage.
+  if (!hasNext()) {
+    *valuesRead = 0;
     return 0;
   }
 
-  // TODO(wesm): keep reading data pages until batch_size is reached, or the
-  // row group is finished
-  int64_t num_def_levels = 0;
-  int64_t values_to_read = 0;
-  ReadLevels(
-      batch_size, def_levels, rep_levels, &num_def_levels, &values_to_read);
+  // TODO(wesm): keep reading data pages until batch_size is reached, or the.
+  // Row group is finished.
+  int64_t numDefLevels = 0;
+  int64_t valuesToRead = 0;
+  readLevels(batchSize, defLevels, repLevels, &numDefLevels, &valuesToRead);
 
-  *values_read = this->ReadValues(values_to_read, values);
-  int64_t total_values = std::max<int64_t>(num_def_levels, *values_read);
-  int64_t expected_values = std::min(
-      batch_size, this->num_buffered_values_ - this->num_decoded_values_);
-  if (total_values == 0 && expected_values > 0) {
+  *valuesRead = this->readValues(valuesToRead, values);
+  int64_t totalValues = std::max<int64_t>(numDefLevels, *valuesRead);
+  int64_t expectedValues =
+      std::min(batchSize, this->numBufferedValues_ - this->numDecodedValues_);
+  if (totalValues == 0 && expectedValues > 0) {
     std::stringstream ss;
-    ss << "Read 0 values, expected " << expected_values;
-    ParquetException::EofException(ss.str());
+    ss << "Read 0 values, expected " << expectedValues;
+    ParquetException::eofException(ss.str());
   }
-  this->ConsumeBufferedValues(total_values);
+  this->consumeBufferedValues(totalValues);
 
-  return total_values;
+  return totalValues;
 }
 
 template <typename DType>
-int64_t TypedColumnReaderImpl<DType>::ReadBatchSpaced(
-    int64_t batch_size,
-    int16_t* def_levels,
-    int16_t* rep_levels,
+int64_t TypedColumnReaderImpl<DType>::readBatchSpaced(
+    int64_t batchSize,
+    int16_t* defLevels,
+    int16_t* repLevels,
     T* values,
-    uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    int64_t* levels_read,
-    int64_t* values_read,
-    int64_t* null_count_out) {
-  // HasNext invokes ReadNewPage
-  if (!HasNext()) {
-    *levels_read = 0;
-    *values_read = 0;
-    *null_count_out = 0;
+    uint8_t* validBits,
+    int64_t validBitsOffset,
+    int64_t* levelsRead,
+    int64_t* valuesRead,
+    int64_t* nullCountOut) {
+  // HasNext invokes ReadNewPage.
+  if (!hasNext()) {
+    *levelsRead = 0;
+    *valuesRead = 0;
+    *nullCountOut = 0;
     return 0;
   }
 
-  int64_t total_values;
-  // TODO(wesm): keep reading data pages until batch_size is reached, or the
-  // row group is finished
-  batch_size = std::min(
-      batch_size, this->num_buffered_values_ - this->num_decoded_values_);
+  int64_t totalValues;
+  // TODO(wesm): keep reading data pages until batch_size is reached, or the.
+  // Row group is finished.
+  batchSize =
+      std::min(batchSize, this->numBufferedValues_ - this->numDecodedValues_);
 
-  // If the field is required and non-repeated, there are no definition levels
-  if (this->max_def_level_ > 0) {
-    int64_t num_def_levels = this->ReadDefinitionLevels(batch_size, def_levels);
+  // If the field is required and non-repeated, there are no definition levels.
+  if (this->maxDefLevel_ > 0) {
+    int64_t numDefLevels = this->readDefinitionLevels(batchSize, defLevels);
 
-    // Not present for non-repeated fields
-    if (this->max_rep_level_ > 0) {
-      int64_t num_rep_levels =
-          this->ReadRepetitionLevels(batch_size, rep_levels);
-      if (num_def_levels != num_rep_levels) {
+    // Not present for non-repeated fields.
+    if (this->maxRepLevel_ > 0) {
+      int64_t numRepLevels = this->readRepetitionLevels(batchSize, repLevels);
+      if (numDefLevels != numRepLevels) {
         throw ParquetException(
             "Number of decoded rep / def levels did not match");
       }
     }
 
-    const bool has_spaced_values = HasSpacedValues(this->descr_);
-    int64_t null_count = 0;
-    if (!has_spaced_values) {
-      int values_to_read = 0;
-      for (int64_t i = 0; i < num_def_levels; ++i) {
-        if (def_levels[i] == this->max_def_level_) {
-          ++values_to_read;
+    const bool hasSpacedValuesFlag = hasSpacedValues(this->descr_);
+    int64_t nullCount = 0;
+    if (!hasSpacedValuesFlag) {
+      int valuesToRead = 0;
+      for (int64_t i = 0; i < numDefLevels; ++i) {
+        if (defLevels[i] == this->maxDefLevel_) {
+          ++valuesToRead;
         }
       }
-      total_values = this->ReadValues(values_to_read, values);
+      totalValues = this->readValues(valuesToRead, values);
       ::arrow::bit_util::SetBitsTo(
-          valid_bits,
-          valid_bits_offset,
-          /*length=*/total_values,
-          /*bits_are_set=*/true);
-      *values_read = total_values;
+          validBits, validBitsOffset, totalValues, true);
+      *valuesRead = totalValues;
     } else {
       LevelInfo info;
-      info.repeatedAncestorDefLevel = this->max_def_level_ - 1;
-      info.defLevel = this->max_def_level_;
-      info.repLevel = this->max_rep_level_;
-      ValidityBitmapInputOutput validity_io;
-      validity_io.valuesReadUpperBound = num_def_levels;
-      validity_io.validBits = valid_bits;
-      validity_io.validBitsOffset = valid_bits_offset;
-      validity_io.nullCount = null_count;
-      validity_io.valuesRead = *values_read;
-
-      DefLevelsToBitmap(def_levels, num_def_levels, info, &validity_io);
-      null_count = validity_io.nullCount;
-      *values_read = validity_io.valuesRead;
-
-      total_values = this->ReadValuesSpaced(
-          *values_read,
+      info.repeatedAncestorDefLevel = this->maxDefLevel_ - 1;
+      info.defLevel = this->maxDefLevel_;
+      info.repLevel = this->maxRepLevel_;
+      ValidityBitmapInputOutput validityIo;
+      validityIo.valuesReadUpperBound = numDefLevels;
+      validityIo.validBits = validBits;
+      validityIo.validBitsOffset = validBitsOffset;
+      validityIo.nullCount = nullCount;
+      validityIo.valuesRead = *valuesRead;
+
+      DefLevelsToBitmap(defLevels, numDefLevels, info, &validityIo);
+      nullCount = validityIo.nullCount;
+      *valuesRead = validityIo.valuesRead;
+
+      totalValues = this->readValuesSpaced(
+          *valuesRead,
           values,
-          static_cast<int>(null_count),
-          valid_bits,
-          valid_bits_offset);
+          static_cast<int>(nullCount),
+          validBits,
+          validBitsOffset);
     }
-    *levels_read = num_def_levels;
-    *null_count_out = null_count;
+    *levelsRead = numDefLevels;
+    *nullCountOut = nullCount;
 
   } else {
-    // Required field, read all values
-    total_values = this->ReadValues(batch_size, values);
-    ::arrow::bit_util::SetBitsTo(
-        valid_bits,
-        valid_bits_offset,
-        /*length=*/total_values,
-        /*bits_are_set=*/true);
-    *null_count_out = 0;
-    *values_read = total_values;
-    *levels_read = total_values;
-  }
-
-  this->ConsumeBufferedValues(*levels_read);
-  return total_values;
+    // Required field, read all values.
+    totalValues = this->readValues(batchSize, values);
+    ::arrow::bit_util::SetBitsTo(validBits, validBitsOffset, totalValues, true);
+    *nullCountOut = 0;
+    *valuesRead = totalValues;
+    *levelsRead = totalValues;
+  }
+
+  this->consumeBufferedValues(*levelsRead);
+  return totalValues;
 }
 
 template <typename DType>
-void TypedColumnReaderImpl<DType>::InitScratchForSkip() {
-  if (this->scratch_for_skip_ == nullptr) {
-    int value_size = type_traits<DType::type_num>::value_byte_size;
-    this->scratch_for_skip_ = AllocateBuffer(
+void TypedColumnReaderImpl<DType>::initScratchForSkip() {
+  if (this->scratchForSkip_ == nullptr) {
+    int valueSize = TypeTraits<DType::typeNum>::valueByteSize;
+    this->scratchForSkip_ = allocateBuffer(
         this->pool_,
-        kSkipScratchBatchSize * std::max<int>(sizeof(int16_t), value_size));
+        kSkipScratchBatchSize * std::max<int>(sizeof(int16_t), valueSize));
   }
 }
 
 template <typename DType>
-int64_t TypedColumnReaderImpl<DType>::Skip(int64_t num_values_to_skip) {
-  int64_t values_to_skip = num_values_to_skip;
+int64_t TypedColumnReaderImpl<DType>::skip(int64_t numValuesToSkip) {
+  int64_t valuesToSkip = numValuesToSkip;
   // Optimization: Do not call HasNext() when values_to_skip == 0.
-  while (values_to_skip > 0 && HasNext()) {
-    // If the number of values to skip is more than the number of undecoded
-    // values, skip the Page.
-    const int64_t available_values = this->available_values_current_page();
-    if (values_to_skip >= available_values) {
-      values_to_skip -= available_values;
-      this->ConsumeBufferedValues(available_values);
+  while (valuesToSkip > 0 && hasNext()) {
+    // If the number of values to skip is more than the number of undecoded.
+    // Values, skip the Page.
+    const int64_t availableValues = this->availableValuesCurrentPage();
+    if (valuesToSkip >= availableValues) {
+      valuesToSkip -= availableValues;
+      this->consumeBufferedValues(availableValues);
     } else {
-      // We need to read this Page
-      // Jump to the right offset in the Page
-      int64_t values_read = 0;
-      InitScratchForSkip();
-      VELOX_DCHECK_NOT_NULL(this->scratch_for_skip_);
+      // We need to read this Page.
+      // Jump to the right offset in the Page.
+      int64_t valuesRead = 0;
+      initScratchForSkip();
+      VELOX_DCHECK_NOT_NULL(this->scratchForSkip_);
       do {
-        int64_t batch_size = std::min(kSkipScratchBatchSize, values_to_skip);
-        values_read = ReadBatch(
-            static_cast<int>(batch_size),
-            reinterpret_cast<int16_t*>(this->scratch_for_skip_->mutable_data()),
-            reinterpret_cast<int16_t*>(this->scratch_for_skip_->mutable_data()),
-            reinterpret_cast<T*>(this->scratch_for_skip_->mutable_data()),
-            &values_read);
-        values_to_skip -= values_read;
-      } while (values_read > 0 && values_to_skip > 0);
-    }
-  }
-  return num_values_to_skip - values_to_skip;
+        int64_t batchSize = std::min(kSkipScratchBatchSize, valuesToSkip);
+        valuesRead = readBatch(
+            static_cast<int>(batchSize),
+            reinterpret_cast<int16_t*>(this->scratchForSkip_->mutable_data()),
+            reinterpret_cast<int16_t*>(this->scratchForSkip_->mutable_data()),
+            reinterpret_cast<T*>(this->scratchForSkip_->mutable_data()),
+            &valuesRead);
+        valuesToSkip -= valuesRead;
+      } while (valuesRead > 0 && valuesToSkip > 0);
+    }
+  }
+  return numValuesToSkip - valuesToSkip;
 }
 
 } // namespace
 
-// ----------------------------------------------------------------------
-// Dynamic column reader constructor
+// ----------------------------------------------------------------------.
+// Dynamic column reader constructor.
 
-std::shared_ptr<ColumnReader> ColumnReader::Make(
+std::shared_ptr<ColumnReader> ColumnReader::make(
     const ColumnDescriptor* descr,
     std::unique_ptr<PageReader> pager,
     MemoryPool* pool) {
-  switch (descr->physical_type()) {
-    case Type::BOOLEAN:
+  switch (descr->physicalType()) {
+    case Type::kBoolean:
       return std::make_shared<TypedColumnReaderImpl<BooleanType>>(
           descr, std::move(pager), pool);
-    case Type::INT32:
+    case Type::kInt32:
       return std::make_shared<TypedColumnReaderImpl<Int32Type>>(
           descr, std::move(pager), pool);
-    case Type::INT64:
+    case Type::kInt64:
       return std::make_shared<TypedColumnReaderImpl<Int64Type>>(
           descr, std::move(pager), pool);
-    case Type::INT96:
+    case Type::kInt96:
       return std::make_shared<TypedColumnReaderImpl<Int96Type>>(
           descr, std::move(pager), pool);
-    case Type::FLOAT:
+    case Type::kFloat:
       return std::make_shared<TypedColumnReaderImpl<FloatType>>(
           descr, std::move(pager), pool);
-    case Type::DOUBLE:
+    case Type::kDouble:
       return std::make_shared<TypedColumnReaderImpl<DoubleType>>(
           descr, std::move(pager), pool);
-    case Type::BYTE_ARRAY:
+    case Type::kByteArray:
       return std::make_shared<TypedColumnReaderImpl<ByteArrayType>>(
           descr, std::move(pager), pool);
-    case Type::FIXED_LEN_BYTE_ARRAY:
+    case Type::kFixedLenByteArray:
       return std::make_shared<TypedColumnReaderImpl<FLBAType>>(
           descr, std::move(pager), pool);
     default:
       ParquetException::NYI("type reader not implemented");
   }
-  // Unreachable code, but suppress compiler warning
+  // Unreachable code, but suppress compiler warning.
   return std::shared_ptr<ColumnReader>(nullptr);
 }
 
-// ----------------------------------------------------------------------
-// RecordReader
+// ----------------------------------------------------------------------.
+// RecordReader.
 
 namespace internal {
 
@@ -1500,526 +1479,515 @@ template <typename DType>
 class TypedRecordReader : public TypedColumnReaderImpl<DType>,
                           virtual public RecordReader {
  public:
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
   using BASE = TypedColumnReaderImpl<DType>;
   TypedRecordReader(
       const ColumnDescriptor* descr,
-      LevelInfo leaf_info,
+      LevelInfo leafInfo,
       MemoryPool* pool,
-      bool read_dense_for_nullable)
+      bool readDenseForNullable)
       // Pager must be set using SetPageReader.
       : BASE(descr, /* pager = */ nullptr, pool) {
-    leaf_info_ = leaf_info;
-    nullable_values_ = leaf_info_.HasNullableValues();
-    at_record_start_ = true;
-    values_written_ = 0;
-    null_count_ = 0;
-    values_capacity_ = 0;
-    levels_written_ = 0;
-    levels_position_ = 0;
-    levels_capacity_ = 0;
-    read_dense_for_nullable_ = read_dense_for_nullable;
-    uses_values_ = !(descr->physical_type() == Type::BYTE_ARRAY);
-
-    if (uses_values_) {
-      values_ = AllocateBuffer(pool);
-    }
-    valid_bits_ = AllocateBuffer(pool);
-    def_levels_ = AllocateBuffer(pool);
-    rep_levels_ = AllocateBuffer(pool);
-    TypedRecordReader::Reset();
-  }
-
-  // Compute the values capacity in bytes for the given number of elements
-  int64_t bytes_for_values(int64_t nitems) const {
-    int64_t type_size = GetTypeByteSize(this->descr_->physical_type());
-    int64_t bytes_for_values = -1;
-    if (MultiplyWithOverflow(nitems, type_size, &bytes_for_values)) {
+    leafInfo_ = leafInfo;
+    nullableValues_ = leafInfo_.HasNullableValues();
+    atRecordStart_ = true;
+    valuesWritten_ = 0;
+    nullCount_ = 0;
+    valuesCapacity_ = 0;
+    levelsWritten_ = 0;
+    levelsPosition_ = 0;
+    levelsCapacity_ = 0;
+    readDenseForNullable_ = readDenseForNullable;
+    usesValues_ = !(descr->physicalType() == Type::kByteArray);
+
+    if (usesValues_) {
+      values_ = allocateBuffer(pool);
+    }
+    validBits_ = allocateBuffer(pool);
+    defLevels_ = allocateBuffer(pool);
+    repLevels_ = allocateBuffer(pool);
+    TypedRecordReader::reset();
+  }
+
+  // Compute the values capacity in bytes for the given number of elements.
+  int64_t bytesForValues(int64_t nitems) const {
+    int64_t typeSize = getTypeByteSize(this->descr_->physicalType());
+    int64_t bytesForValues = -1;
+    if (MultiplyWithOverflow(nitems, typeSize, &bytesForValues)) {
       throw ParquetException("Total size of items too large");
     }
-    return bytes_for_values;
+    return bytesForValues;
   }
 
-  int64_t ReadRecords(int64_t num_records) override {
-    if (num_records == 0)
+  int64_t readRecords(int64_t numRecords) override {
+    if (numRecords == 0)
       return 0;
-    // Delimit records, then read values at the end
-    int64_t records_read = 0;
+    // Delimit records, then read values at the end.
+    int64_t recordsRead = 0;
 
-    if (has_values_to_process()) {
-      records_read += ReadRecordData(num_records);
+    if (hasValuesToProcess()) {
+      recordsRead += readRecordData(numRecords);
     }
 
-    int64_t level_batch_size =
-        std::max<int64_t>(kMinLevelBatchSize, num_records);
+    int64_t levelBatchSize = std::max<int64_t>(kMinLevelBatchSize, numRecords);
 
-    // If we are in the middle of a record, we continue until reaching the
-    // desired number of records or the end of the current record if we've found
-    // enough records
-    while (!at_record_start_ || records_read < num_records) {
+    // If we are in the middle of a record, we continue until reaching the.
+    // Desired number of records or the end of the current record if we've
+    // found. Enough records.
+    while (!atRecordStart_ || recordsRead < numRecords) {
       // Is there more data to read in this row group?
-      if (!this->HasNextInternal()) {
-        if (!at_record_start_) {
-          // We ended the row group while inside a record that we haven't seen
-          // the end of yet. So increment the record count for the last record
-          // in the row group
-          ++records_read;
-          at_record_start_ = true;
+      if (!this->hasNextInternal()) {
+        if (!atRecordStart_) {
+          // We ended the row group while inside a record that we haven't seen.
+          // The end of yet. So increment the record count for the last record.
+          // In the row group.
+          ++recordsRead;
+          atRecordStart_ = true;
         }
         break;
       }
 
-      /// We perform multiple batch reads until we either exhaust the row group
-      /// or observe the desired number of records
-      int64_t batch_size =
-          std::min(level_batch_size, this->available_values_current_page());
+      /// We perform multiple batch reads until we either exhaust the row group.
+      /// Or observe the desired number of records.
+      int64_t batchSize =
+          std::min(levelBatchSize, this->availableValuesCurrentPage());
 
-      // No more data in column
-      if (batch_size == 0) {
+      // No more data in column.
+      if (batchSize == 0) {
         break;
       }
 
-      if (this->max_def_level_ > 0) {
-        ReserveLevels(batch_size);
+      if (this->maxDefLevel_ > 0) {
+        reserveLevels(batchSize);
 
-        int16_t* def_levels = this->def_levels() + levels_written_;
-        int16_t* rep_levels = this->rep_levels() + levels_written_;
+        int16_t* defLevels = this->defLevels() + levelsWritten_;
+        int16_t* repLevels = this->repLevels() + levelsWritten_;
 
-        // Not present for non-repeated fields
-        int64_t levels_read = 0;
-        if (this->max_rep_level_ > 0) {
-          levels_read = this->ReadDefinitionLevels(batch_size, def_levels);
-          if (this->ReadRepetitionLevels(batch_size, rep_levels) !=
-              levels_read) {
+        // Not present for non-repeated fields.
+        int64_t levelsRead = 0;
+        if (this->maxRepLevel_ > 0) {
+          levelsRead = this->readDefinitionLevels(batchSize, defLevels);
+          if (this->readRepetitionLevels(batchSize, repLevels) != levelsRead) {
             throw ParquetException(
                 "Number of decoded rep / def levels did not match");
           }
-        } else if (this->max_def_level_ > 0) {
-          levels_read = this->ReadDefinitionLevels(batch_size, def_levels);
+        } else if (this->maxDefLevel_ > 0) {
+          levelsRead = this->readDefinitionLevels(batchSize, defLevels);
         }
 
-        // Exhausted column chunk
-        if (levels_read == 0) {
+        // Exhausted column chunk.
+        if (levelsRead == 0) {
           break;
         }
 
-        levels_written_ += levels_read;
-        records_read += ReadRecordData(num_records - records_read);
+        levelsWritten_ += levelsRead;
+        recordsRead += readRecordData(numRecords - recordsRead);
       } else {
-        // No repetition or definition levels
-        batch_size = std::min(num_records - records_read, batch_size);
-        records_read += ReadRecordData(batch_size);
+        // No repetition or definition levels.
+        batchSize = std::min(numRecords - recordsRead, batchSize);
+        recordsRead += readRecordData(batchSize);
       }
     }
 
-    return records_read;
+    return recordsRead;
   }
 
   // Throw away levels from start_levels_position to levels_position_.
-  // Will update levels_position_, levels_written_, and levels_capacity_
-  // accordingly and move the levels to left to fill in the gap.
+  // Will update levels_position_, levels_written_, and levels_capacity_.
+  // Accordingly and move the levels to left to fill in the gap.
   // It will resize the buffer without releasing the memory allocation.
-  void ThrowAwayLevels(int64_t start_levels_position) {
-    VELOX_DCHECK_LE(levels_position_, levels_written_);
-    VELOX_DCHECK_LE(start_levels_position, levels_position_);
-    VELOX_DCHECK_GT(this->max_def_level_, 0);
-    VELOX_DCHECK_NOT_NULL(def_levels_);
+  void throwAwayLevels(int64_t startLevelsPosition) {
+    VELOX_DCHECK_LE(levelsPosition_, levelsWritten_);
+    VELOX_DCHECK_LE(startLevelsPosition, levelsPosition_);
+    VELOX_DCHECK_GT(this->maxDefLevel_, 0);
+    VELOX_DCHECK_NOT_NULL(defLevels_);
 
-    int64_t gap = levels_position_ - start_levels_position;
+    int64_t gap = levelsPosition_ - startLevelsPosition;
     if (gap == 0)
       return;
 
-    int64_t levels_remaining = levels_written_ - gap;
+    int64_t levelsRemaining = levelsWritten_ - gap;
 
-    auto left_shift = [&](::arrow::ResizableBuffer* buffer) {
+    auto leftShift = [&](::arrow::ResizableBuffer* buffer) {
       int16_t* data = reinterpret_cast<int16_t*>(buffer->mutable_data());
       std::copy(
-          data + levels_position_,
-          data + levels_written_,
-          data + start_levels_position);
-      PARQUET_THROW_NOT_OK(buffer->Resize(
-          levels_remaining * sizeof(int16_t),
-          /*shrink_to_fit=*/false));
+          data + levelsPosition_,
+          data + levelsWritten_,
+          data + startLevelsPosition);
+      PARQUET_THROW_NOT_OK(
+          buffer->Resize(levelsRemaining * sizeof(int16_t), false));
     };
 
-    left_shift(def_levels_.get());
+    leftShift(defLevels_.get());
 
-    if (this->max_rep_level_ > 0) {
-      VELOX_DCHECK_NOT_NULL(rep_levels_);
-      left_shift(rep_levels_.get());
+    if (this->maxRepLevel_ > 0) {
+      VELOX_DCHECK_NOT_NULL(repLevels_);
+      leftShift(repLevels_.get());
     }
 
-    levels_written_ -= gap;
-    levels_position_ -= gap;
-    levels_capacity_ -= gap;
+    levelsWritten_ -= gap;
+    levelsPosition_ -= gap;
+    levelsCapacity_ -= gap;
   }
 
-  // Skip records that we have in our buffer. This function is only for
-  // non-repeated fields.
-  int64_t SkipRecordsInBufferNonRepeated(int64_t num_records) {
-    VELOX_DCHECK_EQ(this->max_rep_level_, 0);
-    if (!this->has_values_to_process() || num_records == 0)
+  // Skip records that we have in our buffer. This function is only for.
+  // Non-repeated fields.
+  int64_t skipRecordsInBufferNonRepeated(int64_t numRecords) {
+    VELOX_DCHECK_EQ(this->maxRepLevel_, 0);
+    if (!this->hasValuesToProcess() || numRecords == 0)
       return 0;
 
-    int64_t remaining_records = levels_written_ - levels_position_;
-    int64_t skipped_records = std::min(num_records, remaining_records);
-    int64_t start_levels_position = levels_position_;
+    int64_t remainingRecords = levelsWritten_ - levelsPosition_;
+    int64_t skippedRecords = std::min(numRecords, remainingRecords);
+    int64_t startLevelsPosition = levelsPosition_;
     // Since there is no repetition, number of levels equals number of records.
-    levels_position_ += skipped_records;
+    levelsPosition_ += skippedRecords;
 
-    // We skipped the levels by incrementing 'levels_position_'. For values
-    // we do not have a buffer, so we need to read them and throw them away.
+    // We skipped the levels by incrementing 'levels_position_'. For values.
+    // We do not have a buffer, so we need to read them and throw them away.
     // First we need to figure out how many present/not-null values there are.
-    std::shared_ptr<::arrow::ResizableBuffer> valid_bits;
-    valid_bits = AllocateBuffer(this->pool_);
-    PARQUET_THROW_NOT_OK(valid_bits->Resize(
-        ::arrow::bit_util::BytesForBits(skipped_records),
-        /*shrink_to_fit=*/true));
-    ValidityBitmapInputOutput validity_io;
-    validity_io.valuesReadUpperBound = skipped_records;
-    validity_io.validBits = valid_bits->mutable_data();
-    validity_io.validBitsOffset = 0;
+    std::shared_ptr<::arrow::ResizableBuffer> validBits;
+    validBits = allocateBuffer(this->pool_);
+    PARQUET_THROW_NOT_OK(validBits->Resize(
+        ::arrow::bit_util::BytesForBits(skippedRecords), true));
+    ValidityBitmapInputOutput validityIo;
+    validityIo.valuesReadUpperBound = skippedRecords;
+    validityIo.validBits = validBits->mutable_data();
+    validityIo.validBitsOffset = 0;
     DefLevelsToBitmap(
-        def_levels() + start_levels_position,
-        skipped_records,
-        this->leaf_info_,
-        &validity_io);
-    int64_t values_to_read = validity_io.valuesRead - validity_io.nullCount;
-
-    // Now that we have figured out number of values to read, we do not need
-    // these levels anymore. We will remove these values from the buffer.
-    // This requires shifting the levels in the buffer to left. So this will
-    // update levels_position_ and levels_written_.
-    ThrowAwayLevels(start_levels_position);
-    // For values, we do not have them in buffer, so we will read them and
-    // throw them away.
-    ReadAndThrowAwayValues(values_to_read);
+        defLevels() + startLevelsPosition,
+        skippedRecords,
+        this->leafInfo_,
+        &validityIo);
+    int64_t valuesToRead = validityIo.valuesRead - validityIo.nullCount;
+
+    // Now that we have figured out number of values to read, we do not need.
+    // These levels anymore. We will remove these values from the buffer.
+    // This requires shifting the levels in the buffer to left. So this will.
+    // Update levels_position_ and levels_written_.
+    throwAwayLevels(startLevelsPosition);
+    // For values, we do not have them in buffer, so we will read them and.
+    // Throw them away.
+    readAndThrowAwayValues(valuesToRead);
 
     // Mark the levels as read in the underlying column reader.
-    this->ConsumeBufferedValues(skipped_records);
+    this->consumeBufferedValues(skippedRecords);
 
-    return skipped_records;
+    return skippedRecords;
   }
 
-  // Attempts to skip num_records from the buffer. Will throw away levels
-  // and corresponding values for the records it skipped and consumes them from
-  // the underlying decoder. Will advance levels_position_ and update
-  // at_record_start_.
+  // Attempts to skip num_records from the buffer. Will throw away levels.
+  // And corresponding values for the records it skipped and consumes them from.
+  // The underlying decoder. Will advance levels_position_ and update.
+  // At_record_start_.
   // Returns how many records were skipped.
-  int64_t DelimitAndSkipRecordsInBuffer(int64_t num_records) {
-    if (num_records == 0)
+  int64_t delimitAndSkipRecordsInBuffer(int64_t numRecords) {
+    if (numRecords == 0)
       return 0;
-    // Look at the buffered levels, delimit them based on
-    // (rep_level == 0), report back how many records are in there, and
-    // fill in how many not-null values (def_level == max_def_level_).
+    // Look at the buffered levels, delimit them based on.
+    // (Rep_level == 0), report back how many records are in there, and.
+    // Fill in how many not-null values (def_level == max_def_level_).
     // DelimitRecords updates levels_position_.
-    int64_t start_levels_position = levels_position_;
-    int64_t values_seen = 0;
-    int64_t skipped_records = DelimitRecords(num_records, &values_seen);
-    ReadAndThrowAwayValues(values_seen);
+    int64_t startLevelsPosition = levelsPosition_;
+    int64_t valuesSeen = 0;
+    int64_t skippedRecords = delimitRecords(numRecords, &valuesSeen);
+    readAndThrowAwayValues(valuesSeen);
     // Mark those levels and values as consumed in the underlying page.
-    // This must be done before we throw away levels since it updates
-    // levels_position_ and levels_written_.
-    this->ConsumeBufferedValues(levels_position_ - start_levels_position);
+    // This must be done before we throw away levels since it updates.
+    // Levels_position_ and levels_written_.
+    this->consumeBufferedValues(levelsPosition_ - startLevelsPosition);
     // Updated levels_position_ and levels_written_.
-    ThrowAwayLevels(start_levels_position);
-    return skipped_records;
+    throwAwayLevels(startLevelsPosition);
+    return skippedRecords;
   }
 
-  // Skip records for repeated fields. For repeated fields, we are technically
-  // reading and throwing away the levels and values since we do not know the
-  // record boundaries in advance. Keep filling the buffer and skipping until we
-  // reach the desired number of records or we run out of values in the column
-  // chunk. Returns number of skipped records.
-  int64_t SkipRecordsRepeated(int64_t num_records) {
-    VELOX_DCHECK_GT(this->max_rep_level_, 0);
-    int64_t skipped_records = 0;
+  // Skip records for repeated fields. For repeated fields, we are technically.
+  // Reading and throwing away the levels and values since we do not know the.
+  // Record boundaries in advance. Keep filling the buffer and skipping until
+  // we. Reach the desired number of records or we run out of values in the
+  // column. Chunk. Returns number of skipped records.
+  int64_t skipRecordsRepeated(int64_t numRecords) {
+    VELOX_DCHECK_GT(this->maxRepLevel_, 0);
+    int64_t skippedRecords = 0;
 
     // First consume what is in the buffer.
-    if (levels_position_ < levels_written_) {
+    if (levelsPosition_ < levelsWritten_) {
       // This updates at_record_start_.
-      skipped_records = DelimitAndSkipRecordsInBuffer(num_records);
+      skippedRecords = delimitAndSkipRecordsInBuffer(numRecords);
     }
 
-    int64_t level_batch_size =
-        std::max<int64_t>(kMinLevelBatchSize, num_records - skipped_records);
+    int64_t levelBatchSize =
+        std::max<int64_t>(kMinLevelBatchSize, numRecords - skippedRecords);
 
-    // If 'at_record_start_' is false, but (skipped_records == num_records), it
-    // means that for the last record that was counted, we have not seen all
-    // of its values yet.
-    while (!at_record_start_ || skipped_records < num_records) {
+    // If 'at_record_start_' is false, but (skipped_records == num_records), it.
+    // Means that for the last record that was counted, we have not seen all.
+    // Of its values yet.
+    while (!atRecordStart_ || skippedRecords < numRecords) {
       // Is there more data to read in this row group?
       // HasNextInternal() will advance to the next page if necessary.
-      if (!this->HasNextInternal()) {
-        if (!at_record_start_) {
-          // We ended the row group while inside a record that we haven't seen
-          // the end of yet. So increment the record count for the last record
-          // in the row group
-          ++skipped_records;
-          at_record_start_ = true;
+      if (!this->hasNextInternal()) {
+        if (!atRecordStart_) {
+          // We ended the row group while inside a record that we haven't seen.
+          // The end of yet. So increment the record count for the last record.
+          // In the row group.
+          ++skippedRecords;
+          atRecordStart_ = true;
         }
         break;
       }
 
       // Read some more levels.
-      int64_t batch_size =
-          std::min(level_batch_size, this->available_values_current_page());
+      int64_t batchSize =
+          std::min(levelBatchSize, this->availableValuesCurrentPage());
       // No more data in column. This must be an empty page.
-      // If we had exhausted the last page, HasNextInternal() must have advanced
-      // to the next page. So there must be available values to process.
-      if (batch_size == 0) {
+      // If we had exhausted the last page, HasNextInternal() must have
+      // advanced. To the next page. So there must be available values to
+      // process.
+      if (batchSize == 0) {
         break;
       }
 
-      // For skipping we will read the levels and append them to the end
-      // of the def_levels and rep_levels just like for read.
-      ReserveLevels(batch_size);
+      // For skipping we will read the levels and append them to the end.
+      // Of the def_levels and rep_levels just like for read.
+      reserveLevels(batchSize);
 
-      int16_t* def_levels = this->def_levels() + levels_written_;
-      int16_t* rep_levels = this->rep_levels() + levels_written_;
+      int16_t* defLevels = this->defLevels() + levelsWritten_;
+      int16_t* repLevels = this->repLevels() + levelsWritten_;
 
-      int64_t levels_read = 0;
-      levels_read = this->ReadDefinitionLevels(batch_size, def_levels);
-      if (this->ReadRepetitionLevels(batch_size, rep_levels) != levels_read) {
+      int64_t levelsRead = 0;
+      levelsRead = this->readDefinitionLevels(batchSize, defLevels);
+      if (this->readRepetitionLevels(batchSize, repLevels) != levelsRead) {
         throw ParquetException(
             "Number of decoded rep / def levels did not match");
       }
 
-      levels_written_ += levels_read;
-      int64_t remaining_records = num_records - skipped_records;
+      levelsWritten_ += levelsRead;
+      int64_t remainingRecords = numRecords - skippedRecords;
       // This updates at_record_start_.
-      skipped_records += DelimitAndSkipRecordsInBuffer(remaining_records);
+      skippedRecords += delimitAndSkipRecordsInBuffer(remainingRecords);
     }
 
-    return skipped_records;
+    return skippedRecords;
   }
 
   // Read 'num_values' values and throw them away.
   // Throws an error if it could not read 'num_values'.
-  void ReadAndThrowAwayValues(int64_t num_values) {
-    int64_t values_left = num_values;
-    int64_t values_read = 0;
-
-    // Allocate enough scratch space to accommodate 16-bit levels or any
-    // value type
-    this->InitScratchForSkip();
-    VELOX_DCHECK_NOT_NULL(this->scratch_for_skip_);
+  void readAndThrowAwayValues(int64_t numValues) {
+    int64_t valuesLeft = numValues;
+    int64_t valuesRead = 0;
+
+    // Allocate enough scratch space to accommodate 16-bit levels or any.
+    // Value type.
+    this->initScratchForSkip();
+    VELOX_DCHECK_NOT_NULL(this->scratchForSkip_);
     do {
-      int64_t batch_size =
-          std::min<int64_t>(kSkipScratchBatchSize, values_left);
-      values_read = this->ReadValues(
-          batch_size,
-          reinterpret_cast<T*>(this->scratch_for_skip_->mutable_data()));
-      values_left -= values_read;
-    } while (values_read > 0 && values_left > 0);
-    if (values_left > 0) {
+      int64_t batchSize = std::min<int64_t>(kSkipScratchBatchSize, valuesLeft);
+      valuesRead = this->readValues(
+          batchSize,
+          reinterpret_cast<T*>(this->scratchForSkip_->mutable_data()));
+      valuesLeft -= valuesRead;
+    } while (valuesRead > 0 && valuesLeft > 0);
+    if (valuesLeft > 0) {
       std::stringstream ss;
-      ss << "Could not read and throw away " << num_values << " values";
+      ss << "Could not read and throw away " << numValues << " values";
       throw ParquetException(ss.str());
     }
   }
 
-  int64_t SkipRecords(int64_t num_records) override {
-    if (num_records == 0)
+  int64_t skipRecords(int64_t numRecords) override {
+    if (numRecords == 0)
       return 0;
 
-    // Top level required field. Number of records equals to number of levels,
-    // and there is not read-ahead for levels.
-    if (this->max_rep_level_ == 0 && this->max_def_level_ == 0) {
-      return this->Skip(num_records);
+    // Top level required field. Number of records equals to number of levels,.
+    // And there is not read-ahead for levels.
+    if (this->maxRepLevel_ == 0 && this->maxDefLevel_ == 0) {
+      return this->skip(numRecords);
     }
-    int64_t skipped_records = 0;
-    if (this->max_rep_level_ == 0) {
+    int64_t skippedRecords = 0;
+    if (this->maxRepLevel_ == 0) {
       // Non-repeated optional field.
       // First consume whatever is in the buffer.
-      skipped_records = SkipRecordsInBufferNonRepeated(num_records);
+      skippedRecords = skipRecordsInBufferNonRepeated(numRecords);
 
-      VELOX_DCHECK_LE(skipped_records, num_records);
+      VELOX_DCHECK_LE(skippedRecords, numRecords);
 
-      // For records that we have not buffered, we will use the column
-      // reader's Skip to do the remaining Skip. Since the field is not
-      // repeated number of levels to skip is the same as number of records
-      // to skip.
-      skipped_records += this->Skip(num_records - skipped_records);
+      // For records that we have not buffered, we will use the column.
+      // Reader's Skip to do the remaining Skip. Since the field is not.
+      // Repeated number of levels to skip is the same as number of records.
+      // To skip.
+      skippedRecords += this->skip(numRecords - skippedRecords);
     } else {
-      skipped_records += this->SkipRecordsRepeated(num_records);
+      skippedRecords += this->skipRecordsRepeated(numRecords);
     }
-    return skipped_records;
+    return skippedRecords;
   }
 
-  // We may outwardly have the appearance of having exhausted a column chunk
-  // when in fact we are in the middle of processing the last batch
-  bool has_values_to_process() const {
-    return levels_position_ < levels_written_;
+  // We may outwardly have the appearance of having exhausted a column chunk.
+  // When in fact we are in the middle of processing the last batch.
+  bool hasValuesToProcess() const {
+    return levelsPosition_ < levelsWritten_;
   }
 
-  std::shared_ptr<ResizableBuffer> ReleaseValues() override {
-    if (uses_values_) {
+  std::shared_ptr<ResizableBuffer> releaseValues() override {
+    if (usesValues_) {
       auto result = values_;
-      PARQUET_THROW_NOT_OK(result->Resize(
-          bytes_for_values(values_written_), /*shrink_to_fit=*/true));
-      values_ = AllocateBuffer(this->pool_);
-      values_capacity_ = 0;
+      PARQUET_THROW_NOT_OK(
+          result->Resize(bytesForValues(valuesWritten_), true));
+      values_ = allocateBuffer(this->pool_);
+      valuesCapacity_ = 0;
       return result;
     } else {
       return nullptr;
     }
   }
 
-  std::shared_ptr<ResizableBuffer> ReleaseIsValid() override {
-    if (nullable_values()) {
-      auto result = valid_bits_;
+  std::shared_ptr<ResizableBuffer> releaseIsValid() override {
+    if (nullableValues()) {
+      auto result = validBits_;
       PARQUET_THROW_NOT_OK(result->Resize(
-          ::arrow::bit_util::BytesForBits(values_written_),
-          /*shrink_to_fit=*/true));
-      valid_bits_ = AllocateBuffer(this->pool_);
+          ::arrow::bit_util::BytesForBits(valuesWritten_), true));
+      validBits_ = allocateBuffer(this->pool_);
       return result;
     } else {
       return nullptr;
     }
   }
 
-  // Process written repetition/definition levels to reach the end of
-  // records. Only used for repeated fields.
-  // Process no more levels than necessary to delimit the indicated
-  // number of logical records. Updates internal state of RecordReader
+  // Process written repetition/definition levels to reach the end of.
+  // Records. Only used for repeated fields.
+  // Process no more levels than necessary to delimit the indicated.
+  // Number of logical records. Updates internal state of RecordReader.
   //
-  // \return Number of records delimited
-  int64_t DelimitRecords(int64_t num_records, int64_t* values_seen) {
-    int64_t values_to_read = 0;
-    int64_t records_read = 0;
-
-    const int16_t* def_levels = this->def_levels() + levels_position_;
-    const int16_t* rep_levels = this->rep_levels() + levels_position_;
-
-    VELOX_DCHECK_GT(this->max_rep_level_, 0);
-
-    // Count logical records and number of values to read
-    while (levels_position_ < levels_written_) {
-      const int16_t rep_level = *rep_levels++;
-      if (rep_level == 0) {
-        // If at_record_start_ is true, we are seeing the start of a record
-        // for the second time, such as after repeated calls to
-        // DelimitRecords. In this case we must continue until we find
-        // another record start or exhausting the ColumnChunk
-        if (!at_record_start_) {
+  // \return Number of records delimited.
+  int64_t delimitRecords(int64_t numRecords, int64_t* valuesSeen) {
+    int64_t valuesToRead = 0;
+    int64_t recordsRead = 0;
+
+    const int16_t* defLevels = this->defLevels() + levelsPosition_;
+    const int16_t* repLevels = this->repLevels() + levelsPosition_;
+
+    VELOX_DCHECK_GT(this->maxRepLevel_, 0);
+
+    // Count logical records and number of values to read.
+    while (levelsPosition_ < levelsWritten_) {
+      const int16_t repLevel = *repLevels++;
+      if (repLevel == 0) {
+        // If at_record_start_ is true, we are seeing the start of a record.
+        // For the second time, such as after repeated calls to.
+        // DelimitRecords. In this case we must continue until we find.
+        // Another record start or exhausting the ColumnChunk.
+        if (!atRecordStart_) {
           // We've reached the end of a record; increment the record count.
-          ++records_read;
-          if (records_read == num_records) {
-            // We've found the number of records we were looking for. Set
-            // at_record_start_ to true and break
-            at_record_start_ = true;
+          ++recordsRead;
+          if (recordsRead == numRecords) {
+            // We've found the number of records we were looking for. Set.
+            // At_record_start_ to true and break.
+            atRecordStart_ = true;
             break;
           }
         }
       }
-      // We have decided to consume the level at this position; therefore we
-      // must advance until we find another record boundary
-      at_record_start_ = false;
+      // We have decided to consume the level at this position; therefore we.
+      // Must advance until we find another record boundary.
+      atRecordStart_ = false;
 
-      const int16_t def_level = *def_levels++;
-      if (def_level == this->max_def_level_) {
-        ++values_to_read;
+      const int16_t defLevel = *defLevels++;
+      if (defLevel == this->maxDefLevel_) {
+        ++valuesToRead;
       }
-      ++levels_position_;
+      ++levelsPosition_;
     }
-    *values_seen = values_to_read;
-    return records_read;
+    *valuesSeen = valuesToRead;
+    return recordsRead;
   }
 
-  void Reserve(int64_t capacity) override {
-    ReserveLevels(capacity);
-    ReserveValues(capacity);
+  void reserve(int64_t capacity) override {
+    reserveLevels(capacity);
+    reserveValues(capacity);
   }
 
-  int64_t UpdateCapacity(int64_t capacity, int64_t size, int64_t extra_size) {
-    if (extra_size < 0) {
+  int64_t updateCapacity(int64_t capacity, int64_t size, int64_t extraSize) {
+    if (extraSize < 0) {
       throw ParquetException("Negative size (corrupt file?)");
     }
-    int64_t target_size = -1;
-    if (AddWithOverflow(size, extra_size, &target_size)) {
+    int64_t targetSize = -1;
+    if (AddWithOverflow(size, extraSize, &targetSize)) {
       throw ParquetException("Allocation size too large (corrupt file?)");
     }
-    if (target_size >= (1LL << 62)) {
+    if (targetSize >= (1LL << 62)) {
       throw ParquetException("Allocation size too large (corrupt file?)");
     }
-    if (capacity >= target_size) {
+    if (capacity >= targetSize) {
       return capacity;
     }
-    return ::arrow::bit_util::NextPower2(target_size);
+    return ::arrow::bit_util::NextPower2(targetSize);
   }
 
-  void ReserveLevels(int64_t extra_levels) {
-    if (this->max_def_level_ > 0) {
-      const int64_t new_levels_capacity =
-          UpdateCapacity(levels_capacity_, levels_written_, extra_levels);
-      if (new_levels_capacity > levels_capacity_) {
+  void reserveLevels(int64_t extraLevels) {
+    if (this->maxDefLevel_ > 0) {
+      const int64_t newLevelsCapacity =
+          updateCapacity(levelsCapacity_, levelsWritten_, extraLevels);
+      if (newLevelsCapacity > levelsCapacity_) {
         constexpr auto kItemSize = static_cast<int64_t>(sizeof(int16_t));
-        int64_t capacity_in_bytes = -1;
+        int64_t capacityInBytes = -1;
         if (MultiplyWithOverflow(
-                new_levels_capacity, kItemSize, &capacity_in_bytes)) {
+                newLevelsCapacity, kItemSize, &capacityInBytes)) {
           throw ParquetException("Allocation size too large (corrupt file?)");
         }
-        PARQUET_THROW_NOT_OK(
-            def_levels_->Resize(capacity_in_bytes, /*shrink_to_fit=*/false));
-        if (this->max_rep_level_ > 0) {
-          PARQUET_THROW_NOT_OK(
-              rep_levels_->Resize(capacity_in_bytes, /*shrink_to_fit=*/false));
+        PARQUET_THROW_NOT_OK(defLevels_->Resize(capacityInBytes, false));
+        if (this->maxRepLevel_ > 0) {
+          PARQUET_THROW_NOT_OK(repLevels_->Resize(capacityInBytes, false));
         }
-        levels_capacity_ = new_levels_capacity;
+        levelsCapacity_ = newLevelsCapacity;
       }
     }
   }
 
-  void ReserveValues(int64_t extra_values) {
-    const int64_t new_values_capacity =
-        UpdateCapacity(values_capacity_, values_written_, extra_values);
-    if (new_values_capacity > values_capacity_) {
-      // XXX(wesm): A hack to avoid memory allocation when reading directly
-      // into builder classes
-      if (uses_values_) {
-        PARQUET_THROW_NOT_OK(values_->Resize(
-            bytes_for_values(new_values_capacity),
-            /*shrink_to_fit=*/false));
-      }
-      values_capacity_ = new_values_capacity;
-    }
-    if (nullable_values() && !read_dense_for_nullable_) {
-      int64_t valid_bytes_new =
-          ::arrow::bit_util::BytesForBits(values_capacity_);
-      if (valid_bits_->size() < valid_bytes_new) {
-        int64_t valid_bytes_old =
-            ::arrow::bit_util::BytesForBits(values_written_);
+  void reserveValues(int64_t extraValues) {
+    const int64_t newValuesCapacity =
+        updateCapacity(valuesCapacity_, valuesWritten_, extraValues);
+    if (newValuesCapacity > valuesCapacity_) {
+      // XXX(wesm): A hack to avoid memory allocation when reading directly.
+      // Into builder classes.
+      if (usesValues_) {
         PARQUET_THROW_NOT_OK(
-            valid_bits_->Resize(valid_bytes_new, /*shrink_to_fit=*/false));
+            values_->Resize(bytesForValues(newValuesCapacity), false));
+      }
+      valuesCapacity_ = newValuesCapacity;
+    }
+    if (nullableValues() && !readDenseForNullable_) {
+      int64_t validBytesNew = ::arrow::bit_util::BytesForBits(valuesCapacity_);
+      if (validBits_->size() < validBytesNew) {
+        int64_t validBytesOld = ::arrow::bit_util::BytesForBits(valuesWritten_);
+        PARQUET_THROW_NOT_OK(validBits_->Resize(validBytesNew, false));
 
-        // Avoid valgrind warnings
+        // Avoid valgrind warnings.
         memset(
-            valid_bits_->mutable_data() + valid_bytes_old,
+            validBits_->mutable_data() + validBytesOld,
             0,
-            valid_bytes_new - valid_bytes_old);
+            validBytesNew - validBytesOld);
       }
     }
   }
 
-  void Reset() override {
-    ResetValues();
+  void reset() override {
+    resetValues();
 
-    if (levels_written_ > 0) {
+    if (levelsWritten_ > 0) {
       // Throw away levels from 0 to levels_position_.
-      ThrowAwayLevels(0);
+      throwAwayLevels(0);
     }
 
-    // Call Finish on the binary builders to reset them
+    // Call Finish on the binary builders to reset them.
   }
 
-  void SetPageReader(std::unique_ptr<PageReader> reader) override {
-    at_record_start_ = true;
+  void setPageReader(std::unique_ptr<PageReader> reader) override {
+    atRecordStart_ = true;
     this->pager_ = std::move(reader);
-    ResetDecoders();
+    resetDecoders();
   }
 
-  bool HasMoreData() const override {
+  bool hasMoreData() const override {
     return this->pager_ != nullptr;
   }
 
@@ -2027,239 +1995,237 @@ class TypedRecordReader : public TypedColumnReaderImpl<DType>,
     return this->descr_;
   }
 
-  // Dictionary decoders must be reset when advancing row groups
-  void ResetDecoders() {
+  // Dictionary decoders must be reset when advancing row groups.
+  void resetDecoders() {
     this->decoders_.clear();
   }
 
-  virtual void ReadValuesSpaced(int64_t values_with_nulls, int64_t null_count) {
-    uint8_t* valid_bits = valid_bits_->mutable_data();
-    const int64_t valid_bits_offset = values_written_;
-
-    int64_t num_decoded = this->current_decoder_->DecodeSpaced(
-        ValuesHead<T>(),
-        static_cast<int>(values_with_nulls),
-        static_cast<int>(null_count),
-        valid_bits,
-        valid_bits_offset);
-    CheckNumberDecoded(num_decoded, values_with_nulls);
-  }
-
-  virtual void ReadValuesDense(int64_t values_to_read) {
-    int64_t num_decoded = this->current_decoder_->Decode(
-        ValuesHead<T>(), static_cast<int>(values_to_read));
-    CheckNumberDecoded(num_decoded, values_to_read);
-  }
-
-  // Reads repeated records and returns number of records read. Fills in
-  // values_to_read and null_count.
-  int64_t ReadRepeatedRecords(
-      int64_t num_records,
-      int64_t* values_to_read,
-      int64_t* null_count) {
-    const int64_t start_levels_position = levels_position_;
-    // Note that repeated records may be required or nullable. If they have
-    // an optional parent in the path, they will be nullable, otherwise,
-    // they are required. We use leaf_info_->HasNullableValues() that looks
-    // at repeated_ancestor_def_level to determine if it is required or
-    // nullable. Even if they are required, we may have to read ahead and
-    // delimit the records to get the right number of values and they will
-    // have associated levels.
-    int64_t records_read = DelimitRecords(num_records, values_to_read);
-    if (!nullable_values() || read_dense_for_nullable_) {
-      ReadValuesDense(*values_to_read);
-      // null_count is always 0 for required.
-      VELOX_DCHECK_EQ(*null_count, 0);
+  virtual void readValuesSpaced(int64_t valuesWithNulls, int64_t nullCount) {
+    uint8_t* validBits = validBits_->mutable_data();
+    const int64_t validBitsOffset = valuesWritten_;
+
+    int64_t numDecoded = this->currentDecoder_->decodeSpaced(
+        valuesHead<T>(),
+        static_cast<int>(valuesWithNulls),
+        static_cast<int>(nullCount),
+        validBits,
+        validBitsOffset);
+    checkNumberDecoded(numDecoded, valuesWithNulls);
+  }
+
+  virtual void readValuesDense(int64_t valuesToRead) {
+    int64_t numDecoded = this->currentDecoder_->decode(
+        valuesHead<T>(), static_cast<int>(valuesToRead));
+    checkNumberDecoded(numDecoded, valuesToRead);
+  }
+
+  // Reads repeated records and returns number of records read. Fills in.
+  // Values_to_read and null_count.
+  int64_t readRepeatedRecords(
+      int64_t numRecords,
+      int64_t* valuesToRead,
+      int64_t* nullCount) {
+    const int64_t startLevelsPosition = levelsPosition_;
+    // Note that repeated records may be required or nullable. If they have.
+    // An optional parent in the path, they will be nullable, otherwise,.
+    // They are required. We use leaf_info_->HasNullableValues() that looks.
+    // At repeated_ancestor_def_level to determine if it is required or.
+    // Nullable. Even if they are required, we may have to read ahead and.
+    // Delimit the records to get the right number of values and they will.
+    // Have associated levels.
+    int64_t recordsRead = delimitRecords(numRecords, valuesToRead);
+    if (!nullableValues() || readDenseForNullable_) {
+      readValuesDense(*valuesToRead);
+      // Null_count is always 0 for required.
+      VELOX_DCHECK_EQ(*nullCount, 0);
     } else {
-      ReadSpacedForOptionalOrRepeated(
-          start_levels_position, values_to_read, null_count);
-    }
-    return records_read;
-  }
-
-  // Reads optional records and returns number of records read. Fills in
-  // values_to_read and null_count.
-  int64_t ReadOptionalRecords(
-      int64_t num_records,
-      int64_t* values_to_read,
-      int64_t* null_count) {
-    const int64_t start_levels_position = levels_position_;
-    // No repetition levels, skip delimiting logic. Each level represents a
-    // null or not null entry
-    int64_t records_read =
-        std::min<int64_t>(levels_written_ - levels_position_, num_records);
+      readSpacedForOptionalOrRepeated(
+          startLevelsPosition, valuesToRead, nullCount);
+    }
+    return recordsRead;
+  }
+
+  // Reads optional records and returns number of records read. Fills in.
+  // Values_to_read and null_count.
+  int64_t readOptionalRecords(
+      int64_t numRecords,
+      int64_t* valuesToRead,
+      int64_t* nullCount) {
+    const int64_t startLevelsPosition = levelsPosition_;
+    // No repetition levels, skip delimiting logic. Each level represents a.
+    // Null or not null entry.
+    int64_t recordsRead =
+        std::min<int64_t>(levelsWritten_ - levelsPosition_, numRecords);
     // This is advanced by DelimitRecords for the repeated field case above.
-    levels_position_ += records_read;
+    levelsPosition_ += recordsRead;
 
     // Optional fields are always nullable.
-    if (read_dense_for_nullable_) {
-      ReadDenseForOptional(start_levels_position, values_to_read);
-      // We don't need to update null_count when reading dense. It should be
-      // already set to 0.
-      VELOX_DCHECK_EQ(*null_count, 0);
+    if (readDenseForNullable_) {
+      readDenseForOptional(startLevelsPosition, valuesToRead);
+      // We don't need to update null_count when reading dense. It should be.
+      // Already set to 0.
+      VELOX_DCHECK_EQ(*nullCount, 0);
     } else {
-      ReadSpacedForOptionalOrRepeated(
-          start_levels_position, values_to_read, null_count);
+      readSpacedForOptionalOrRepeated(
+          startLevelsPosition, valuesToRead, nullCount);
     }
-    return records_read;
+    return recordsRead;
   }
 
-  // Reads required records and returns number of records read. Fills in
-  // values_to_read.
-  int64_t ReadRequiredRecords(int64_t num_records, int64_t* values_to_read) {
-    *values_to_read = num_records;
-    ReadValuesDense(*values_to_read);
-    return num_records;
+  // Reads required records and returns number of records read. Fills in.
+  // Values_to_read.
+  int64_t readRequiredRecords(int64_t numRecords, int64_t* valuesToRead) {
+    *valuesToRead = numRecords;
+    readValuesDense(*valuesToRead);
+    return numRecords;
   }
 
-  // Reads dense for optional records. First it figures out how many values to
-  // read.
-  void ReadDenseForOptional(
-      int64_t start_levels_position,
-      int64_t* values_to_read) {
-    // levels_position_ must already be incremented based on number of records
-    // read.
-    VELOX_DCHECK_GE(levels_position_, start_levels_position);
+  // Reads dense for optional records. First it figures out how many values to.
+  // Read.
+  void readDenseForOptional(
+      int64_t startLevelsPosition,
+      int64_t* valuesToRead) {
+    // Levels_position_ must already be incremented based on number of records.
+    // Read.
+    VELOX_DCHECK_GE(levelsPosition_, startLevelsPosition);
 
     // When reading dense we need to figure out number of values to read.
-    const int16_t* def_levels = this->def_levels();
-    for (int64_t i = start_levels_position; i < levels_position_; ++i) {
-      if (def_levels[i] == this->max_def_level_) {
-        ++(*values_to_read);
+    const int16_t* defLevels = this->defLevels();
+    for (int64_t i = startLevelsPosition; i < levelsPosition_; ++i) {
+      if (defLevels[i] == this->maxDefLevel_) {
+        ++(*valuesToRead);
       }
     }
-    ReadValuesDense(*values_to_read);
+    readValuesDense(*valuesToRead);
   }
 
   // Reads spaced for optional or repeated fields.
-  void ReadSpacedForOptionalOrRepeated(
-      int64_t start_levels_position,
-      int64_t* values_to_read,
-      int64_t* null_count) {
-    // levels_position_ must already be incremented based on number of records
-    // read.
-    VELOX_DCHECK_GE(levels_position_, start_levels_position);
-    ValidityBitmapInputOutput validity_io;
-    validity_io.valuesReadUpperBound = levels_position_ - start_levels_position;
-    validity_io.validBits = valid_bits_->mutable_data();
-    validity_io.validBitsOffset = values_written_;
+  void readSpacedForOptionalOrRepeated(
+      int64_t startLevelsPosition,
+      int64_t* valuesToRead,
+      int64_t* nullCount) {
+    // Levels_position_ must already be incremented based on number of records.
+    // Read.
+    VELOX_DCHECK_GE(levelsPosition_, startLevelsPosition);
+    ValidityBitmapInputOutput validityIo;
+    validityIo.valuesReadUpperBound = levelsPosition_ - startLevelsPosition;
+    validityIo.validBits = validBits_->mutable_data();
+    validityIo.validBitsOffset = valuesWritten_;
 
     DefLevelsToBitmap(
-        def_levels() + start_levels_position,
-        levels_position_ - start_levels_position,
-        leaf_info_,
-        &validity_io);
-    *values_to_read = validity_io.valuesRead - validity_io.nullCount;
-    *null_count = validity_io.nullCount;
-    VELOX_DCHECK_GE(*values_to_read, 0);
-    VELOX_DCHECK_GE(*null_count, 0);
-    ReadValuesSpaced(validity_io.valuesRead, *null_count);
+        defLevels() + startLevelsPosition,
+        levelsPosition_ - startLevelsPosition,
+        leafInfo_,
+        &validityIo);
+    *valuesToRead = validityIo.valuesRead - validityIo.nullCount;
+    *nullCount = validityIo.nullCount;
+    VELOX_DCHECK_GE(*valuesToRead, 0);
+    VELOX_DCHECK_GE(*nullCount, 0);
+    readValuesSpaced(validityIo.valuesRead, *nullCount);
   }
 
   // Return number of logical records read.
   // Updates levels_position_, values_written_, and null_count_.
-  int64_t ReadRecordData(int64_t num_records) {
-    // Conservative upper bound
-    const int64_t possible_num_values =
-        std::max<int64_t>(num_records, levels_written_ - levels_position_);
-    ReserveValues(possible_num_values);
-
-    const int64_t start_levels_position = levels_position_;
-
-    // To be updated by the function calls below for each of the repetition
-    // types.
-    int64_t records_read = 0;
-    int64_t values_to_read = 0;
-    int64_t null_count = 0;
-    if (this->max_rep_level_ > 0) {
+  int64_t readRecordData(int64_t numRecords) {
+    // Conservative upper bound.
+    const int64_t possibleNumValues =
+        std::max<int64_t>(numRecords, levelsWritten_ - levelsPosition_);
+    reserveValues(possibleNumValues);
+
+    const int64_t startLevelsPosition = levelsPosition_;
+
+    // To be updated by the function calls below for each of the repetition.
+    // Types.
+    int64_t recordsRead = 0;
+    int64_t valuesToRead = 0;
+    int64_t nullCount = 0;
+    if (this->maxRepLevel_ > 0) {
       // Repeated fields may be nullable or not.
       // This call updates levels_position_.
-      records_read =
-          ReadRepeatedRecords(num_records, &values_to_read, &null_count);
-    } else if (this->max_def_level_ > 0) {
+      recordsRead = readRepeatedRecords(numRecords, &valuesToRead, &nullCount);
+    } else if (this->maxDefLevel_ > 0) {
       // Non-repeated optional values are always nullable.
       // This call updates levels_position_.
-      VELOX_DCHECK(nullable_values());
-      records_read =
-          ReadOptionalRecords(num_records, &values_to_read, &null_count);
+      VELOX_DCHECK(nullableValues());
+      recordsRead = readOptionalRecords(numRecords, &valuesToRead, &nullCount);
     } else {
-      VELOX_DCHECK(!nullable_values());
-      records_read = ReadRequiredRecords(num_records, &values_to_read);
+      VELOX_DCHECK(!nullableValues());
+      recordsRead = readRequiredRecords(numRecords, &valuesToRead);
       // We don't need to update null_count, since it is 0.
     }
 
-    VELOX_DCHECK_GE(records_read, 0);
-    VELOX_DCHECK_GE(values_to_read, 0);
-    VELOX_DCHECK_GE(null_count, 0);
+    VELOX_DCHECK_GE(recordsRead, 0);
+    VELOX_DCHECK_GE(valuesToRead, 0);
+    VELOX_DCHECK_GE(nullCount, 0);
 
-    if (read_dense_for_nullable_) {
-      values_written_ += values_to_read;
-      VELOX_DCHECK_EQ(null_count, 0);
+    if (readDenseForNullable_) {
+      valuesWritten_ += valuesToRead;
+      VELOX_DCHECK_EQ(nullCount, 0);
     } else {
-      values_written_ += values_to_read + null_count;
-      null_count_ += null_count;
+      valuesWritten_ += valuesToRead + nullCount;
+      nullCount_ += nullCount;
     }
-    // Total values, including null spaces, if any
-    if (this->max_def_level_ > 0) {
-      // Optional, repeated, or some mix thereof
-      this->ConsumeBufferedValues(levels_position_ - start_levels_position);
+    // Total values, including null spaces, if any.
+    if (this->maxDefLevel_ > 0) {
+      // Optional, repeated, or some mix thereof.
+      this->consumeBufferedValues(levelsPosition_ - startLevelsPosition);
     } else {
-      // Flat, non-repeated
-      this->ConsumeBufferedValues(values_to_read);
+      // Flat, non-repeated.
+      this->consumeBufferedValues(valuesToRead);
     }
 
-    return records_read;
+    return recordsRead;
   }
 
-  void DebugPrintState() override {
-    const int16_t* def_levels = this->def_levels();
-    const int16_t* rep_levels = this->rep_levels();
-    const int64_t total_levels_read = levels_position_;
+  void debugPrintState() override {
+    const int16_t* defLevels = this->defLevels();
+    const int16_t* repLevels = this->repLevels();
+    const int64_t totalLevelsRead = levelsPosition_;
 
     const T* vals = reinterpret_cast<const T*>(this->values());
 
-    if (leaf_info_.defLevel > 0) {
+    if (leafInfo_.defLevel > 0) {
       std::cout << "def levels: ";
-      for (int64_t i = 0; i < total_levels_read; ++i) {
-        std::cout << def_levels[i] << " ";
+      for (int64_t i = 0; i < totalLevelsRead; ++i) {
+        std::cout << defLevels[i] << " ";
       }
       std::cout << std::endl;
     }
 
-    if (leaf_info_.repLevel > 0) {
+    if (leafInfo_.repLevel > 0) {
       std::cout << "rep levels: ";
-      for (int64_t i = 0; i < total_levels_read; ++i) {
-        std::cout << rep_levels[i] << " ";
+      for (int64_t i = 0; i < totalLevelsRead; ++i) {
+        std::cout << repLevels[i] << " ";
       }
       std::cout << std::endl;
     }
 
     std::cout << "values: ";
-    for (int64_t i = 0; i < this->values_written(); ++i) {
+    for (int64_t i = 0; i < this->valuesWritten(); ++i) {
       std::cout << vals[i] << " ";
     }
     std::cout << std::endl;
   }
 
-  void ResetValues() {
-    if (values_written_ > 0) {
-      // Resize to 0, but do not shrink to fit
-      if (uses_values_) {
-        PARQUET_THROW_NOT_OK(values_->Resize(0, /*shrink_to_fit=*/false));
+  void resetValues() {
+    if (valuesWritten_ > 0) {
+      // Resize to 0, but do not shrink to fit.
+      if (usesValues_) {
+        PARQUET_THROW_NOT_OK(values_->Resize(0, false));
       }
-      PARQUET_THROW_NOT_OK(valid_bits_->Resize(0, /*shrink_to_fit=*/false));
-      values_written_ = 0;
-      values_capacity_ = 0;
-      null_count_ = 0;
+      PARQUET_THROW_NOT_OK(validBits_->Resize(0, false));
+      valuesWritten_ = 0;
+      valuesCapacity_ = 0;
+      nullCount_ = 0;
     }
   }
 
  protected:
   template <typename T>
-  T* ValuesHead() {
-    return reinterpret_cast<T*>(values_->mutable_data()) + values_written_;
+  T* valuesHead() {
+    return reinterpret_cast<T*>(values_->mutable_data()) + valuesWritten_;
   }
-  LevelInfo leaf_info_;
+  LevelInfo leafInfo_;
 };
 
 class FLBARecordReader : public TypedRecordReader<FLBAType>,
@@ -2267,62 +2233,64 @@ class FLBARecordReader : public TypedRecordReader<FLBAType>,
  public:
   FLBARecordReader(
       const ColumnDescriptor* descr,
-      LevelInfo leaf_info,
+      LevelInfo leafInfo,
       ::arrow::MemoryPool* pool,
-      bool read_dense_for_nullable)
+      bool readDenseForNullable)
       : TypedRecordReader<FLBAType>(
             descr,
-            leaf_info,
+            leafInfo,
             pool,
-            read_dense_for_nullable),
+            readDenseForNullable),
         builder_(nullptr) {
-    VELOX_DCHECK_EQ(descr_->physical_type(), Type::FIXED_LEN_BYTE_ARRAY);
-    int byte_width = descr_->type_length();
+    VELOX_DCHECK_EQ(
+        static_cast<int>(descr_->physicalType()),
+        static_cast<int>(Type::kFixedLenByteArray));
+    int byteWidth = descr_->typeLength();
     std::shared_ptr<::arrow::DataType> type =
-        ::arrow::fixed_size_binary(byte_width);
+        ::arrow::fixed_size_binary(byteWidth);
     builder_ =
         std::make_unique<::arrow::FixedSizeBinaryBuilder>(type, this->pool_);
   }
 
-  ::arrow::ArrayVector GetBuilderChunks() override {
+  ::arrow::ArrayVector getBuilderChunks() override {
     std::shared_ptr<::arrow::Array> chunk;
     PARQUET_THROW_NOT_OK(builder_->Finish(&chunk));
     return ::arrow::ArrayVector({chunk});
   }
 
-  void ReadValuesDense(int64_t values_to_read) override {
-    auto values = ValuesHead<FLBA>();
-    int64_t num_decoded = this->current_decoder_->Decode(
-        values, static_cast<int>(values_to_read));
-    CheckNumberDecoded(num_decoded, values_to_read);
+  void readValuesDense(int64_t valuesToRead) override {
+    auto values = valuesHead<FLBA>();
+    int64_t numDecoded =
+        this->currentDecoder_->decode(values, static_cast<int>(valuesToRead));
+    checkNumberDecoded(numDecoded, valuesToRead);
 
-    for (int64_t i = 0; i < num_decoded; i++) {
+    for (int64_t i = 0; i < numDecoded; i++) {
       PARQUET_THROW_NOT_OK(builder_->Append(values[i].ptr));
     }
-    ResetValues();
+    resetValues();
   }
 
-  void ReadValuesSpaced(int64_t values_to_read, int64_t null_count) override {
-    uint8_t* valid_bits = valid_bits_->mutable_data();
-    const int64_t valid_bits_offset = values_written_;
-    auto values = ValuesHead<FLBA>();
+  void readValuesSpaced(int64_t valuesToRead, int64_t nullCount) override {
+    uint8_t* validBits = validBits_->mutable_data();
+    const int64_t validBitsOffset = valuesWritten_;
+    auto values = valuesHead<FLBA>();
 
-    int64_t num_decoded = this->current_decoder_->DecodeSpaced(
+    int64_t numDecoded = this->currentDecoder_->decodeSpaced(
         values,
-        static_cast<int>(values_to_read),
-        static_cast<int>(null_count),
-        valid_bits,
-        valid_bits_offset);
-    VELOX_DCHECK_EQ(num_decoded, values_to_read);
-
-    for (int64_t i = 0; i < num_decoded; i++) {
-      if (::arrow::bit_util::GetBit(valid_bits, valid_bits_offset + i)) {
+        static_cast<int>(valuesToRead),
+        static_cast<int>(nullCount),
+        validBits,
+        validBitsOffset);
+    VELOX_DCHECK_EQ(numDecoded, valuesToRead);
+
+    for (int64_t i = 0; i < numDecoded; i++) {
+      if (::arrow::bit_util::GetBit(validBits, validBitsOffset + i)) {
         PARQUET_THROW_NOT_OK(builder_->Append(values[i].ptr));
       } else {
         PARQUET_THROW_NOT_OK(builder_->AppendNull());
       }
     }
-    ResetValues();
+    resetValues();
   }
 
  private:
@@ -2334,49 +2302,51 @@ class ByteArrayChunkedRecordReader : public TypedRecordReader<ByteArrayType>,
  public:
   ByteArrayChunkedRecordReader(
       const ColumnDescriptor* descr,
-      LevelInfo leaf_info,
+      LevelInfo leafInfo,
       ::arrow::MemoryPool* pool,
-      bool read_dense_for_nullable)
+      bool readDenseForNullable)
       : TypedRecordReader<ByteArrayType>(
             descr,
-            leaf_info,
+            leafInfo,
             pool,
-            read_dense_for_nullable) {
-    VELOX_DCHECK_EQ(descr_->physical_type(), Type::BYTE_ARRAY);
-    accumulator_.builder = std::make_unique<::arrow::BinaryBuilder>(pool);
+            readDenseForNullable) {
+    VELOX_DCHECK_EQ(
+        static_cast<int>(descr_->physicalType()),
+        static_cast<int>(Type::kByteArray));
+    accumulator_.Builder = std::make_unique<::arrow::BinaryBuilder>(pool);
   }
 
-  ::arrow::ArrayVector GetBuilderChunks() override {
+  ::arrow::ArrayVector getBuilderChunks() override {
     ::arrow::ArrayVector result = accumulator_.chunks;
-    if (result.size() == 0 || accumulator_.builder->length() > 0) {
-      std::shared_ptr<::arrow::Array> last_chunk;
-      PARQUET_THROW_NOT_OK(accumulator_.builder->Finish(&last_chunk));
-      result.push_back(std::move(last_chunk));
+    if (result.size() == 0 || accumulator_.Builder->length() > 0) {
+      std::shared_ptr<::arrow::Array> lastChunk;
+      PARQUET_THROW_NOT_OK(accumulator_.Builder->Finish(&lastChunk));
+      result.push_back(std::move(lastChunk));
     }
     accumulator_.chunks = {};
     return result;
   }
 
-  void ReadValuesDense(int64_t values_to_read) override {
-    int64_t num_decoded = this->current_decoder_->DecodeArrowNonNull(
-        static_cast<int>(values_to_read), &accumulator_);
-    CheckNumberDecoded(num_decoded, values_to_read);
-    ResetValues();
+  void readValuesDense(int64_t valuesToRead) override {
+    int64_t numDecoded = this->currentDecoder_->decodeArrowNonNull(
+        static_cast<int>(valuesToRead), &accumulator_);
+    checkNumberDecoded(numDecoded, valuesToRead);
+    resetValues();
   }
 
-  void ReadValuesSpaced(int64_t values_to_read, int64_t null_count) override {
-    int64_t num_decoded = this->current_decoder_->DecodeArrow(
-        static_cast<int>(values_to_read),
-        static_cast<int>(null_count),
-        valid_bits_->mutable_data(),
-        values_written_,
+  void readValuesSpaced(int64_t valuesToRead, int64_t nullCount) override {
+    int64_t numDecoded = this->currentDecoder_->decodeArrow(
+        static_cast<int>(valuesToRead),
+        static_cast<int>(nullCount),
+        validBits_->mutable_data(),
+        valuesWritten_,
         &accumulator_);
-    CheckNumberDecoded(num_decoded, values_to_read - null_count);
-    ResetValues();
+    checkNumberDecoded(numDecoded, valuesToRead - nullCount);
+    resetValues();
   }
 
  private:
-  // Helper data structure for accumulating builder chunks
+  // Helper data structure for accumulating builder chunks.
   typename EncodingTraits<ByteArrayType>::Accumulator accumulator_;
 };
 
@@ -2385,166 +2355,166 @@ class ByteArrayDictionaryRecordReader : public TypedRecordReader<ByteArrayType>,
  public:
   ByteArrayDictionaryRecordReader(
       const ColumnDescriptor* descr,
-      LevelInfo leaf_info,
+      LevelInfo leafInfo,
       ::arrow::MemoryPool* pool,
-      bool read_dense_for_nullable)
+      bool readDenseForNullable)
       : TypedRecordReader<ByteArrayType>(
             descr,
-            leaf_info,
+            leafInfo,
             pool,
-            read_dense_for_nullable),
+            readDenseForNullable),
         builder_(pool) {
-    this->read_dictionary_ = true;
+    this->readDictionary_ = true;
   }
 
-  std::shared_ptr<::arrow::ChunkedArray> GetResult() override {
-    FlushBuilder();
+  std::shared_ptr<::arrow::ChunkedArray> getResult() override {
+    flushBuilder();
     std::vector<std::shared_ptr<::arrow::Array>> result;
-    std::swap(result, result_chunks_);
+    std::swap(result, resultChunks_);
     return std::make_shared<::arrow::ChunkedArray>(
         std::move(result), builder_.type());
   }
 
-  void FlushBuilder() {
+  void flushBuilder() {
     if (builder_.length() > 0) {
       std::shared_ptr<::arrow::Array> chunk;
       PARQUET_THROW_NOT_OK(builder_.Finish(&chunk));
-      result_chunks_.emplace_back(std::move(chunk));
+      resultChunks_.emplace_back(std::move(chunk));
 
-      // Also clears the dictionary memo table
+      // Also clears the dictionary memo table.
       builder_.Reset();
     }
   }
 
-  void MaybeWriteNewDictionary() {
-    if (this->new_dictionary_) {
-      /// If there is a new dictionary, we may need to flush the builder, then
-      /// insert the new dictionary values
-      FlushBuilder();
+  void maybeWriteNewDictionary() {
+    if (this->newDictionary_) {
+      /// If there is a new dictionary, we may need to flush the builder, then.
+      /// Insert the new dictionary values.
+      flushBuilder();
       builder_.ResetFull();
-      auto decoder = dynamic_cast<BinaryDictDecoder*>(this->current_decoder_);
-      decoder->InsertDictionary(&builder_);
-      this->new_dictionary_ = false;
+      auto decoder = dynamic_cast<BinaryDictDecoder*>(this->currentDecoder_);
+      decoder->insertDictionary(&builder_);
+      this->newDictionary_ = false;
     }
   }
 
-  void ReadValuesDense(int64_t values_to_read) override {
-    int64_t num_decoded = 0;
-    if (current_encoding_ == Encoding::RLE_DICTIONARY) {
-      MaybeWriteNewDictionary();
-      auto decoder = dynamic_cast<BinaryDictDecoder*>(this->current_decoder_);
-      num_decoded =
-          decoder->DecodeIndices(static_cast<int>(values_to_read), &builder_);
+  void readValuesDense(int64_t valuesToRead) override {
+    int64_t numDecoded = 0;
+    if (currentEncoding_ == Encoding::kRleDictionary) {
+      maybeWriteNewDictionary();
+      auto decoder = dynamic_cast<BinaryDictDecoder*>(this->currentDecoder_);
+      numDecoded =
+          decoder->decodeIndices(static_cast<int>(valuesToRead), &builder_);
     } else {
-      num_decoded = this->current_decoder_->DecodeArrowNonNull(
-          static_cast<int>(values_to_read), &builder_);
+      numDecoded = this->currentDecoder_->decodeArrowNonNull(
+          static_cast<int>(valuesToRead), &builder_);
 
-      /// Flush values since they have been copied into the builder
-      ResetValues();
+      /// Flush values since they have been copied into the builder.
+      resetValues();
     }
-    CheckNumberDecoded(num_decoded, values_to_read);
+    checkNumberDecoded(numDecoded, valuesToRead);
   }
 
-  void ReadValuesSpaced(int64_t values_to_read, int64_t null_count) override {
-    VELOX_DEBUG_ONLY int64_t num_decoded = 0;
-    if (current_encoding_ == Encoding::RLE_DICTIONARY) {
-      MaybeWriteNewDictionary();
-      auto decoder = dynamic_cast<BinaryDictDecoder*>(this->current_decoder_);
-      num_decoded = decoder->DecodeIndicesSpaced(
-          static_cast<int>(values_to_read),
-          static_cast<int>(null_count),
-          valid_bits_->mutable_data(),
-          values_written_,
+  void readValuesSpaced(int64_t valuesToRead, int64_t nullCount) override {
+    VELOX_DEBUG_ONLY int64_t numDecoded = 0;
+    if (currentEncoding_ == Encoding::kRleDictionary) {
+      maybeWriteNewDictionary();
+      auto decoder = dynamic_cast<BinaryDictDecoder*>(this->currentDecoder_);
+      numDecoded = decoder->decodeIndicesSpaced(
+          static_cast<int>(valuesToRead),
+          static_cast<int>(nullCount),
+          validBits_->mutable_data(),
+          valuesWritten_,
           &builder_);
     } else {
-      num_decoded = this->current_decoder_->DecodeArrow(
-          static_cast<int>(values_to_read),
-          static_cast<int>(null_count),
-          valid_bits_->mutable_data(),
-          values_written_,
+      numDecoded = this->currentDecoder_->decodeArrow(
+          static_cast<int>(valuesToRead),
+          static_cast<int>(nullCount),
+          validBits_->mutable_data(),
+          valuesWritten_,
           &builder_);
 
-      /// Flush values since they have been copied into the builder
-      ResetValues();
+      /// Flush values since they have been copied into the builder.
+      resetValues();
     }
-    VELOX_DCHECK_EQ(num_decoded, values_to_read - null_count);
+    VELOX_DCHECK_EQ(numDecoded, valuesToRead - nullCount);
   }
 
  private:
   using BinaryDictDecoder = DictDecoder<ByteArrayType>;
 
   ::arrow::BinaryDictionary32Builder builder_;
-  std::vector<std::shared_ptr<::arrow::Array>> result_chunks_;
+  std::vector<std::shared_ptr<::arrow::Array>> resultChunks_;
 };
 
-// TODO(wesm): Implement these to some satisfaction
+// TODO(wesm): Implement these to some satisfaction.
 template <>
-void TypedRecordReader<Int96Type>::DebugPrintState() {}
+void TypedRecordReader<Int96Type>::debugPrintState() {}
 
 template <>
-void TypedRecordReader<ByteArrayType>::DebugPrintState() {}
+void TypedRecordReader<ByteArrayType>::debugPrintState() {}
 
 template <>
-void TypedRecordReader<FLBAType>::DebugPrintState() {}
+void TypedRecordReader<FLBAType>::debugPrintState() {}
 
-std::shared_ptr<RecordReader> MakeByteArrayRecordReader(
+std::shared_ptr<RecordReader> makeByteArrayRecordReader(
     const ColumnDescriptor* descr,
-    LevelInfo leaf_info,
+    LevelInfo leafInfo,
     ::arrow::MemoryPool* pool,
-    bool read_dictionary,
-    bool read_dense_for_nullable) {
-  if (read_dictionary) {
+    bool readDictionary,
+    bool readDenseForNullable) {
+  if (readDictionary) {
     return std::make_shared<ByteArrayDictionaryRecordReader>(
-        descr, leaf_info, pool, read_dense_for_nullable);
+        descr, leafInfo, pool, readDenseForNullable);
   } else {
     return std::make_shared<ByteArrayChunkedRecordReader>(
-        descr, leaf_info, pool, read_dense_for_nullable);
+        descr, leafInfo, pool, readDenseForNullable);
   }
 }
 
 } // namespace
 
-std::shared_ptr<RecordReader> RecordReader::Make(
+std::shared_ptr<RecordReader> RecordReader::make(
     const ColumnDescriptor* descr,
-    LevelInfo leaf_info,
+    LevelInfo leafInfo,
     MemoryPool* pool,
-    bool read_dictionary,
-    bool read_dense_for_nullable) {
-  switch (descr->physical_type()) {
-    case Type::BOOLEAN:
+    bool readDictionary,
+    bool readDenseForNullable) {
+  switch (descr->physicalType()) {
+    case Type::kBoolean:
       return std::make_shared<TypedRecordReader<BooleanType>>(
-          descr, leaf_info, pool, read_dense_for_nullable);
-    case Type::INT32:
+          descr, leafInfo, pool, readDenseForNullable);
+    case Type::kInt32:
       return std::make_shared<TypedRecordReader<Int32Type>>(
-          descr, leaf_info, pool, read_dense_for_nullable);
-    case Type::INT64:
+          descr, leafInfo, pool, readDenseForNullable);
+    case Type::kInt64:
       return std::make_shared<TypedRecordReader<Int64Type>>(
-          descr, leaf_info, pool, read_dense_for_nullable);
-    case Type::INT96:
+          descr, leafInfo, pool, readDenseForNullable);
+    case Type::kInt96:
       return std::make_shared<TypedRecordReader<Int96Type>>(
-          descr, leaf_info, pool, read_dense_for_nullable);
-    case Type::FLOAT:
+          descr, leafInfo, pool, readDenseForNullable);
+    case Type::kFloat:
       return std::make_shared<TypedRecordReader<FloatType>>(
-          descr, leaf_info, pool, read_dense_for_nullable);
-    case Type::DOUBLE:
+          descr, leafInfo, pool, readDenseForNullable);
+    case Type::kDouble:
       return std::make_shared<TypedRecordReader<DoubleType>>(
-          descr, leaf_info, pool, read_dense_for_nullable);
-    case Type::BYTE_ARRAY: {
-      return MakeByteArrayRecordReader(
-          descr, leaf_info, pool, read_dictionary, read_dense_for_nullable);
+          descr, leafInfo, pool, readDenseForNullable);
+    case Type::kByteArray: {
+      return makeByteArrayRecordReader(
+          descr, leafInfo, pool, readDictionary, readDenseForNullable);
     }
-    case Type::FIXED_LEN_BYTE_ARRAY:
+    case Type::kFixedLenByteArray:
       return std::make_shared<FLBARecordReader>(
-          descr, leaf_info, pool, read_dense_for_nullable);
+          descr, leafInfo, pool, readDenseForNullable);
     default: {
-      // PARQUET-1481: This can occur if the file is corrupt
+      // PARQUET-1481: This can occur if the file is corrupt.
       std::stringstream ss;
       ss << "Invalid physical column type: "
-         << static_cast<int>(descr->physical_type());
+         << static_cast<int>(descr->physicalType());
       throw ParquetException(ss.str());
     }
   }
-  // Unreachable code, but suppress compiler warning
+  // Unreachable code, but suppress compiler warning.
   return nullptr;
 }
 
diff --git a/velox/dwio/parquet/writer/arrow/tests/ColumnReader.h b/velox/dwio/parquet/writer/arrow/tests/ColumnReader.h
index 6936aa618e5..07faa918e27 100644
--- a/velox/dwio/parquet/writer/arrow/tests/ColumnReader.h
+++ b/velox/dwio/parquet/writer/arrow/tests/ColumnReader.h
@@ -51,32 +51,32 @@ namespace facebook::velox::parquet::arrow {
 class Decryptor;
 class Page;
 
-// 16 MB is the default maximum page header size
+// 16 MB is the default maximum page header size.
 static constexpr uint32_t kDefaultMaxPageHeaderSize = 16 * 1024 * 1024;
 
-// 16 KB is the default expected page header size
+// 16 KB is the default expected page header size.
 static constexpr uint32_t kDefaultPageHeaderSize = 16 * 1024;
 
-// \brief DataPageStats stores encoded statistics and number of values/rows for
-// a page.
+// \brief DataPageStats stores encoded statistics and number of values/rows for.
+// A page.
 struct PARQUET_EXPORT DataPageStats {
   DataPageStats(
-      const EncodedStatistics* encoded_statistics,
-      int32_t num_values,
-      std::optional<int32_t> num_rows)
-      : encoded_statistics(encoded_statistics),
-        num_values(num_values),
-        num_rows(num_rows) {}
+      const EncodedStatistics* encodedStatistics,
+      int32_t numValues,
+      std::optional<int32_t> numRows)
+      : encodedStatistics(encodedStatistics),
+        numValues(numValues),
+        numRows(numRows) {}
 
   // Encoded statistics extracted from the page header.
   // Nullptr if there are no statistics in the page header.
-  const EncodedStatistics* encoded_statistics;
+  const EncodedStatistics* encodedStatistics;
   // Number of values stored in the page. Filled for both V1 and V2 data pages.
-  // For repeated fields, this can be greater than number of rows. For
-  // non-repeated fields, this will be the same as the number of rows.
-  int32_t num_values;
+  // For repeated fields, this can be greater than number of rows. For.
+  // Non-repeated fields, this will be the same as the number of rows.
+  int32_t numValues;
   // Number of rows stored in the page. std::nullopt if not available.
-  std::optional<int32_t> num_rows;
+  std::optional<int32_t> numRows;
 };
 
 class PARQUET_EXPORT LevelDecoder {
@@ -84,456 +84,456 @@ class PARQUET_EXPORT LevelDecoder {
   LevelDecoder();
   ~LevelDecoder();
 
-  // Initialize the LevelDecoder state with new data
-  // and return the number of bytes consumed
-  int SetData(
+  // Initialize the LevelDecoder state with new data.
+  // And return the number of bytes consumed.
+  int setData(
       Encoding::type encoding,
-      int16_t max_level,
-      int num_buffered_values,
+      int16_t maxLevel,
+      int numBufferedValues,
       const uint8_t* data,
-      int32_t data_size);
+      int32_t dataSize);
 
-  void SetDataV2(
-      int32_t num_bytes,
-      int16_t max_level,
-      int num_buffered_values,
+  void setDataV2(
+      int32_t numBytes,
+      int16_t maxLevel,
+      int numBufferedValues,
       const uint8_t* data);
 
-  // Decodes a batch of levels into an array and returns the number of levels
-  // decoded
-  int Decode(int batch_size, int16_t* levels);
+  // Decodes a batch of levels into an array and returns the number of levels.
+  // Decoded.
+  int decode(int batchSize, int16_t* levels);
 
  private:
-  int bit_width_;
-  int num_values_remaining_;
+  int bitWidth_;
+  int numValuesRemaining_;
   Encoding::type encoding_;
-  std::unique_ptr<RleDecoder> rle_decoder_;
-  std::unique_ptr<BitReader> bit_packed_decoder_;
-  int16_t max_level_;
+  std::unique_ptr<RleDecoder> rleDecoder_;
+  std::unique_ptr<BitReader> bitPackedDecoder_;
+  int16_t maxLevel_;
 };
 
 struct CryptoContext {
   CryptoContext(
-      bool start_with_dictionary_page,
-      int16_t rg_ordinal,
-      int16_t col_ordinal,
+      bool startWithDictionaryPage,
+      int16_t rgOrdinal,
+      int16_t colOrdinal,
       std::shared_ptr<Decryptor> meta,
       std::shared_ptr<Decryptor> data)
-      : start_decrypt_with_dictionary_page(start_with_dictionary_page),
-        row_group_ordinal(rg_ordinal),
-        column_ordinal(col_ordinal),
-        meta_decryptor(std::move(meta)),
-        data_decryptor(std::move(data)) {}
+      : startDecryptWithDictionaryPage(startWithDictionaryPage),
+        rowGroupOrdinal(rgOrdinal),
+        columnOrdinal(colOrdinal),
+        metaDecryptor(std::move(meta)),
+        dataDecryptor(std::move(data)) {}
   CryptoContext() {}
 
-  bool start_decrypt_with_dictionary_page = false;
-  int16_t row_group_ordinal = -1;
-  int16_t column_ordinal = -1;
-  std::shared_ptr<Decryptor> meta_decryptor;
-  std::shared_ptr<Decryptor> data_decryptor;
+  bool startDecryptWithDictionaryPage = false;
+  int16_t rowGroupOrdinal = -1;
+  int16_t columnOrdinal = -1;
+  std::shared_ptr<Decryptor> metaDecryptor;
+  std::shared_ptr<Decryptor> dataDecryptor;
 };
 
-// Abstract page iterator interface. This way, we can feed column pages to the
-// ColumnReader through whatever mechanism we choose
+// Abstract page iterator interface. This way, we can feed column pages to the.
+// ColumnReader through whatever mechanism we choose.
 class PARQUET_EXPORT PageReader {
   using DataPageFilter = std::function<bool(const DataPageStats&)>;
 
  public:
   virtual ~PageReader() = default;
 
-  static std::unique_ptr<PageReader> Open(
+  static std::unique_ptr<PageReader> open(
       std::shared_ptr<ArrowInputStream> stream,
-      int64_t total_num_values,
-      Compression::type codec,
-      bool always_compressed = false,
+      int64_t totalNumValues,
+      Compression::type Codec,
+      bool alwaysCompressed = false,
       ::arrow::MemoryPool* pool = ::arrow::default_memory_pool(),
       const CryptoContext* ctx = NULLPTR);
-  static std::unique_ptr<PageReader> Open(
+  static std::unique_ptr<PageReader> open(
       std::shared_ptr<ArrowInputStream> stream,
-      int64_t total_num_values,
-      Compression::type codec,
+      int64_t totalNumValues,
+      Compression::type Codec,
       const ReaderProperties& properties,
-      bool always_compressed = false,
+      bool alwaysCompressed = false,
       const CryptoContext* ctx = NULLPTR);
 
-  // If data_page_filter is present (not null), NextPage() will call the
-  // callback function exactly once per page in the order the pages appear in
-  // the column. If the callback function returns true the page will be
-  // skipped. The callback will be called only if the page type is DATA_PAGE or
+  // If data_page_filter is present (not null), NextPage() will call the.
+  // Callback function exactly once per page in the order the pages appear in.
+  // The column. If the callback function returns true the page will be.
+  // Skipped. The callback will be called only if the page type is DATA_PAGE or.
   // DATA_PAGE_V2. Dictionary pages will not be skipped.
-  // Caller is responsible for checking that statistics are correct using
+  // Caller is responsible for checking that statistics are correct using.
   // ApplicationVersion::HasCorrectStatistics().
-  // \note API EXPERIMENTAL
-  void set_data_page_filter(DataPageFilter data_page_filter) {
-    data_page_filter_ = std::move(data_page_filter);
+  // \note API EXPERIMENTAL.
+  void setDataPageFilter(DataPageFilter dataPageFilter) {
+    dataPageFilter_ = std::move(dataPageFilter);
   }
 
-  // @returns: shared_ptr<Page>(nullptr) on EOS, std::shared_ptr<Page>
-  // containing new Page otherwise
+  // @returns: shared_ptr<Page>(nullptr) on EOS, std::shared_ptr<Page>.
+  // Containing new Page otherwise.
   //
-  // The returned Page may contain references that aren't guaranteed to live
-  // beyond the next call to NextPage().
-  virtual std::shared_ptr<Page> NextPage() = 0;
+  // The returned Page may contain references that aren't guaranteed to live.
+  // Beyond the next call to NextPage().
+  virtual std::shared_ptr<Page> nextPage() = 0;
 
-  virtual void set_max_page_header_size(uint32_t size) = 0;
+  virtual void setMaxPageHeaderSize(uint32_t size) = 0;
 
  protected:
   // Callback that decides if we should skip a page or not.
-  DataPageFilter data_page_filter_;
+  DataPageFilter dataPageFilter_;
 };
 
 class PARQUET_EXPORT ColumnReader {
  public:
   virtual ~ColumnReader() = default;
 
-  static std::shared_ptr<ColumnReader> Make(
+  static std::shared_ptr<ColumnReader> make(
       const ColumnDescriptor* descr,
       std::unique_ptr<PageReader> pager,
       ::arrow::MemoryPool* pool = ::arrow::default_memory_pool());
 
   // Returns true if there are still values in this column.
-  virtual bool HasNext() = 0;
+  virtual bool hasNext() = 0;
 
   virtual Type::type type() const = 0;
 
   virtual const ColumnDescriptor* descr() const = 0;
 
-  // Get the encoding that can be exposed by this reader. If it returns
-  // dictionary encoding, then ReadBatchWithDictionary can be used to read data.
+  // Get the encoding that can be exposed by this reader. If it returns.
+  // Dictionary encoding, then ReadBatchWithDictionary can be used to read data.
   //
-  // \note API EXPERIMENTAL
-  virtual ExposedEncoding GetExposedEncoding() = 0;
+  // \note API EXPERIMENTAL.
+  virtual ExposedEncoding getExposedEncoding() = 0;
 
  protected:
   friend class RowGroupReader;
   // Set the encoding that can be exposed by this reader.
   //
-  // \note API EXPERIMENTAL
-  virtual void SetExposedEncoding(ExposedEncoding encoding) = 0;
+  // \note API EXPERIMENTAL.
+  virtual void setExposedEncoding(ExposedEncoding encoding) = 0;
 };
 
 // API to read values from a single column. This is a main client facing API.
 template <typename DType>
 class TypedColumnReader : public ColumnReader {
  public:
-  typedef typename DType::c_type T;
+  typedef typename DType::CType T;
 
-  // Read a batch of repetition levels, definition levels, and values from the
-  // column.
+  // Read a batch of repetition levels, definition levels, and values from the.
+  // Column.
   //
-  // Since null values are not stored in the values, the number of values read
-  // may be less than the number of repetition and definition levels. With
-  // nested data this is almost certainly true.
+  // Since null values are not stored in the values, the number of values read.
+  // May be less than the number of repetition and definition levels. With.
+  // Nested data this is almost certainly true.
   //
   // Set def_levels or rep_levels to nullptr if you want to skip reading them.
-  // This is only safe if you know through some other source that there are no
-  // undefined values.
+  // This is only safe if you know through some other source that there are no.
+  // Undefined values.
   //
-  // To fully exhaust a row group, you must read batches until the number of
-  // values read reaches the number of stored values according to the metadata.
+  // To fully exhaust a row group, you must read batches until the number of.
+  // Values read reaches the number of stored values according to the metadata.
   //
-  // This API is the same for both V1 and V2 of the DataPage
+  // This API is the same for both V1 and V2 of the DataPage.
   //
-  // @returns: actual number of levels read (see values_read for number of
+  // @returns: actual number of levels read (see values_read for number of.
   // values read)
-  virtual int64_t ReadBatch(
-      int64_t batch_size,
-      int16_t* def_levels,
-      int16_t* rep_levels,
+  virtual int64_t readBatch(
+      int64_t batchSize,
+      int16_t* defLevels,
+      int16_t* repLevels,
       T* values,
-      int64_t* values_read) = 0;
+      int64_t* valuesRead) = 0;
 
-  /// Read a batch of repetition levels, definition levels, and values from the
-  /// column and leave spaces for null entries on the lowest level in the values
-  /// buffer.
+  /// Read a batch of repetition levels, definition levels, and values from the.
+  /// Column and leave spaces for null entries on the lowest level in the
+  /// values. Buffer.
   ///
-  /// In comparison to ReadBatch the length of repetition and definition levels
-  /// is the same as of the number of values read for max_definition_level == 1.
-  /// In the case of max_definition_level > 1, the repetition and definition
-  /// levels are larger than the values but the values include the null entries
-  /// with definition_level == (max_definition_level - 1).
+  /// In comparison to ReadBatch the length of repetition and definition levels.
+  /// Is the same as of the number of values read for max_definition_level == 1.
+  /// In the case of max_definition_level > 1, the repetition and definition.
+  /// Levels are larger than the values but the values include the null entries.
+  /// With definition_level == (max_definition_level - 1).
   ///
-  /// To fully exhaust a row group, you must read batches until the number of
-  /// values read reaches the number of stored values according to the metadata.
+  /// To fully exhaust a row group, you must read batches until the number of.
+  /// Values read reaches the number of stored values according to the metadata.
   ///
-  /// @param batch_size the number of levels to read
-  /// @param[out] def_levels The Parquet definition levels, output has
-  ///   the length levels_read.
-  /// @param[out] rep_levels The Parquet repetition levels, output has
-  ///   the length levels_read.
-  /// @param[out] values The values in the lowest nested level including
-  ///   spacing for nulls on the lowest levels; output has the length
-  ///   values_read.
-  /// @param[out] valid_bits Memory allocated for a bitmap that indicates if
-  ///   the row is null or on the maximum definition level. For performance
-  ///   reasons the underlying buffer should be able to store 1 bit more than
-  ///   required. If this requires an additional byte, this byte is only read
-  ///   but never written to.
-  /// @param valid_bits_offset The offset in bits of the valid_bits where the
-  ///   first relevant bit resides.
-  /// @param[out] levels_read The number of repetition/definition levels that
-  /// were read.
-  /// @param[out] values_read The number of values read, this includes all
-  ///   non-null entries as well as all null-entries on the lowest level
+  /// @param batch_size the number of levels to read.
+  /// @param[out] def_levels The Parquet definition levels, output has.
+  ///   The length levels_read.
+  /// @param[out] rep_levels The Parquet repetition levels, output has.
+  ///   The length levels_read.
+  /// @param[out] values The values in the lowest nested level including.
+  ///   Spacing for nulls on the lowest levels; output has the length.
+  ///   Values_read.
+  /// @param[out] valid_bits Memory allocated for a bitmap that indicates if.
+  ///   The row is null or on the maximum definition level. For performance.
+  ///   Reasons the underlying buffer should be able to store 1 bit more than.
+  ///   Required. If this requires an additional byte, this byte is only read.
+  ///   But never written to.
+  /// @param valid_bits_offset The offset in bits of the valid_bits where the.
+  ///   First relevant bit resides.
+  /// @param[out] levels_read The number of repetition/definition levels that.
+  /// Were read.
+  /// @param[out] values_read The number of values read, this includes all.
+  ///   Non-null entries as well as all null-entries on the lowest level.
   ///   (i.e. definition_level == max_definition_level - 1)
   /// @param[out] null_count The number of nulls on the lowest levels.
   ///   (i.e. (values_read - null_count) is total number of non-null entries)
   ///
-  /// \deprecated Since 4.0.0
+  /// \deprecated Since 4.0.0.
   ARROW_DEPRECATED(
       "Doesn't handle nesting correctly and unused outside of unit tests.")
-  virtual int64_t ReadBatchSpaced(
-      int64_t batch_size,
-      int16_t* def_levels,
-      int16_t* rep_levels,
+  virtual int64_t readBatchSpaced(
+      int64_t batchSize,
+      int16_t* defLevels,
+      int16_t* repLevels,
       T* values,
-      uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      int64_t* levels_read,
-      int64_t* values_read,
-      int64_t* null_count) = 0;
-
-  // Skip reading values. This method will work for both repeated and
-  // non-repeated fields. Note that this method is skipping values and not
-  // records. This distinction is important for repeated fields, meaning that
-  // we are not skipping over the values to the next record. For example,
-  // consider the following two consecutive records containing one repeated
-  // field:
-  // {[1, 2, 3]}, {[4, 5]}. If we Skip(2), our next read value will be 3, which
-  // is inside the first record.
+      uint8_t* validBits,
+      int64_t validBitsOffset,
+      int64_t* levelsRead,
+      int64_t* valuesRead,
+      int64_t* nullCount) = 0;
+
+  // Skip reading values. This method will work for both repeated and.
+  // Non-repeated fields. Note that this method is skipping values and not.
+  // Records. This distinction is important for repeated fields, meaning that.
+  // We are not skipping over the values to the next record. For example,.
+  // Consider the following two consecutive records containing one repeated.
+  // Field:
+  // {[1, 2, 3]}, {[4, 5]}. If we Skip(2), our next read value will be 3, which.
+  // Is inside the first record.
   // Returns the number of values skipped.
-  virtual int64_t Skip(int64_t num_values_to_skip) = 0;
+  virtual int64_t skip(int64_t numValuesToSkip) = 0;
 
-  // Read a batch of repetition levels, definition levels, and indices from the
-  // column. And read the dictionary if a dictionary page is encountered during
-  // reading pages. This API is similar to ReadBatch(), with ability to read
-  // dictionary and indices. It is only valid to call this method  when the
-  // reader can expose dictionary encoding. (i.e., the reader's
+  // Read a batch of repetition levels, definition levels, and indices from the.
+  // Column. And read the dictionary if a dictionary page is encountered during.
+  // Reading pages. This API is similar to ReadBatch(), with ability to read.
+  // Dictionary and indices. It is only valid to call this method  when the.
+  // Reader can expose dictionary encoding. (i.e., the reader's.
   // GetExposedEncoding() returns DICTIONARY).
   //
-  // The dictionary is read along with the data page. When there's no data page,
-  // the dictionary won't be returned.
+  // The dictionary is read along with the data page. When there's no data
+  // page,. The dictionary won't be returned.
   //
-  // @param batch_size The batch size to read
+  // @param batch_size The batch size to read.
   // @param[out] def_levels The Parquet definition levels.
   // @param[out] rep_levels The Parquet repetition levels.
   // @param[out] indices The dictionary indices.
   // @param[out] indices_read The number of indices read.
-  // @param[out] dict The pointer to dictionary values. It will return nullptr
-  // if there's no data page. Each column chunk only has one dictionary page.
-  // The dictionary is owned by the reader, so the caller is responsible for
-  // copying the dictionary values before the reader gets destroyed.
-  // @param[out] dict_len The dictionary length. It will return 0 if there's no
-  // data page.
-  // @returns: actual number of levels read (see indices_read for number of
-  // indices read
+  // @param[out] dict The pointer to dictionary values. It will return nullptr.
+  // If there's no data page. Each column chunk only has one dictionary page.
+  // The dictionary is owned by the reader, so the caller is responsible for.
+  // Copying the dictionary values before the reader gets destroyed.
+  // @param[out] dict_len The dictionary length. It will return 0 if there's no.
+  // Data page.
+  // @returns: actual number of levels read (see indices_read for number of.
+  // Indices read.
   //
-  // \note API EXPERIMENTAL
-  virtual int64_t ReadBatchWithDictionary(
-      int64_t batch_size,
-      int16_t* def_levels,
-      int16_t* rep_levels,
+  // \note API EXPERIMENTAL.
+  virtual int64_t readBatchWithDictionary(
+      int64_t batchSize,
+      int16_t* defLevels,
+      int16_t* repLevels,
       int32_t* indices,
-      int64_t* indices_read,
+      int64_t* indicesRead,
       const T** dict,
-      int32_t* dict_len) = 0;
+      int32_t* dictLen) = 0;
 };
 
 namespace internal {
 
-/// \brief Stateful column reader that delimits semantic records for both flat
-/// and nested columns
+/// \brief Stateful column reader that delimits semantic records for both flat.
+/// And nested columns.
 ///
-/// \note API EXPERIMENTAL
-/// \since 1.3.0
+/// \note API EXPERIMENTAL.
+/// \since 1.3.0.
 class PARQUET_EXPORT RecordReader {
  public:
   /// \brief Creates a record reader.
-  /// @param descr Column descriptor
-  /// @param leaf_info Level info, used to determine if a column is nullable or
-  /// not
-  /// @param pool Memory pool to use for buffering values and rep/def levels
-  /// @param read_dictionary True if reading directly as Arrow
-  /// dictionary-encoded
-  /// @param read_dense_for_nullable True if reading dense and not leaving space
-  /// for null values
-  static std::shared_ptr<RecordReader> Make(
+  /// @param descr Column descriptor.
+  /// @param leaf_info Level info, used to determine if a column is nullable or.
+  /// Not.
+  /// @param pool Memory pool to use for buffering values and rep/def levels.
+  /// @param read_dictionary True if reading directly as Arrow.
+  /// Dictionary-encoded.
+  /// @param read_dense_for_nullable True if reading dense and not leaving
+  /// space. For null values.
+  static std::shared_ptr<RecordReader> make(
       const ColumnDescriptor* descr,
-      LevelInfo leaf_info,
+      LevelInfo leafInfo,
       ::arrow::MemoryPool* pool = ::arrow::default_memory_pool(),
-      bool read_dictionary = false,
-      bool read_dense_for_nullable = false);
+      bool readDictionary = false,
+      bool readDenseForNullable = false);
 
   virtual ~RecordReader() = default;
 
-  /// \brief Attempt to read indicated number of records from column chunk
-  /// Note that for repeated fields, a record may have more than one value
-  /// and all of them are read. If read_dense_for_nullable() it will
-  /// not leave any space for null values. Otherwise, it will read spaced.
-  /// \return number of records read
-  virtual int64_t ReadRecords(int64_t num_records) = 0;
+  /// \brief Attempt to read indicated number of records from column chunk.
+  /// Note that for repeated fields, a record may have more than one value.
+  /// And all of them are read. If read_dense_for_nullable() it will.
+  /// Not leave any space for null values. Otherwise, it will read spaced.
+  /// \return number of records read.
+  virtual int64_t readRecords(int64_t numRecords) = 0;
 
   /// \brief Attempt to skip indicated number of records from column chunk.
-  /// Note that for repeated fields, a record may have more than one value
-  /// and all of them are skipped.
-  /// \return number of records skipped
-  virtual int64_t SkipRecords(int64_t num_records) = 0;
+  /// Note that for repeated fields, a record may have more than one value.
+  /// And all of them are skipped.
+  /// \return number of records skipped.
+  virtual int64_t skipRecords(int64_t numRecords) = 0;
 
-  /// \brief Pre-allocate space for data. Results in better flat read
-  /// performance
-  virtual void Reserve(int64_t num_values) = 0;
+  /// \brief Pre-allocate space for data. Results in better flat read.
+  /// Performance.
+  virtual void reserve(int64_t numValues) = 0;
 
-  /// \brief Clear consumed values and repetition/definition levels as the
-  /// result of calling ReadRecords
+  /// \brief Clear consumed values and repetition/definition levels as the.
+  /// Result of calling ReadRecords.
   /// For FLBA and ByteArray types, call GetBuilderChunks() to reset them.
-  virtual void Reset() = 0;
+  virtual void reset() = 0;
 
-  /// \brief Transfer filled values buffer to caller. A new one will be
-  /// allocated in subsequent ReadRecords calls
-  virtual std::shared_ptr<ResizableBuffer> ReleaseValues() = 0;
+  /// \brief Transfer filled values buffer to caller. A new one will be.
+  /// Allocated in subsequent ReadRecords calls.
+  virtual std::shared_ptr<ResizableBuffer> releaseValues() = 0;
 
-  /// \brief Transfer filled validity bitmap buffer to caller. A new one will
-  /// be allocated in subsequent ReadRecords calls
-  virtual std::shared_ptr<ResizableBuffer> ReleaseIsValid() = 0;
+  /// \brief Transfer filled validity bitmap buffer to caller. A new one will.
+  /// Be allocated in subsequent ReadRecords calls.
+  virtual std::shared_ptr<ResizableBuffer> releaseIsValid() = 0;
 
-  /// \brief Return true if the record reader has more internal data yet to
-  /// process
-  virtual bool HasMoreData() const = 0;
+  /// \brief Return true if the record reader has more internal data yet to.
+  /// Process.
+  virtual bool hasMoreData() const = 0;
 
-  /// \brief Advance record reader to the next row group. Must be set before
-  /// any records could be read/skipped.
-  /// \param[in] reader obtained from RowGroupReader::GetColumnPageReader
-  virtual void SetPageReader(std::unique_ptr<PageReader> reader) = 0;
+  /// \brief Advance record reader to the next row group. Must be set before.
+  /// Any records could be read/skipped.
+  /// \param[in] reader obtained from RowGroupReader::GetColumnPageReader.
+  virtual void setPageReader(std::unique_ptr<PageReader> reader) = 0;
 
   /// \brief Returns the underlying column reader's descriptor.
   virtual const ColumnDescriptor* descr() const = 0;
 
-  virtual void DebugPrintState() = 0;
+  virtual void debugPrintState() = 0;
 
-  /// \brief Decoded definition levels
-  int16_t* def_levels() const {
-    return reinterpret_cast<int16_t*>(def_levels_->mutable_data());
+  /// \brief Decoded definition levels.
+  int16_t* defLevels() const {
+    return reinterpret_cast<int16_t*>(defLevels_->mutable_data());
   }
 
-  /// \brief Decoded repetition levels
-  int16_t* rep_levels() const {
-    return reinterpret_cast<int16_t*>(rep_levels_->mutable_data());
+  /// \brief Decoded repetition levels.
+  int16_t* repLevels() const {
+    return reinterpret_cast<int16_t*>(repLevels_->mutable_data());
   }
 
-  /// \brief Decoded values, including nulls, if any
-  /// FLBA and ByteArray types do not use this array and read into their own
-  /// builders.
+  /// \brief Decoded values, including nulls, if any.
+  /// FLBA and ByteArray types do not use this array and read into their own.
+  /// Builders.
   uint8_t* values() const {
     return values_->mutable_data();
   }
 
   /// \brief Number of values written, including space left for nulls if any.
-  /// If this Reader was constructed with read_dense_for_nullable(), there is no
-  /// space for nulls and null_count() will be 0. There is no
-  /// read-ahead/buffering for values. For FLBA and ByteArray types this value
-  /// reflects the values written with the last ReadRecords call since those
-  /// readers will reset the values after each call.
-  int64_t values_written() const {
-    return values_written_;
+  /// If this Reader was constructed with read_dense_for_nullable(), there is
+  /// no. Space for nulls and null_count() will be 0. There is no.
+  /// Read-ahead/buffering for values. For FLBA and ByteArray types this value.
+  /// Reflects the values written with the last ReadRecords call since those.
+  /// Readers will reset the values after each call.
+  int64_t valuesWritten() const {
+    return valuesWritten_;
   }
 
-  /// \brief Number of definition / repetition levels (from those that have
-  /// been decoded) that have been consumed inside the reader.
-  int64_t levels_position() const {
-    return levels_position_;
+  /// \brief Number of definition / repetition levels (from those that have.
+  /// Been decoded) that have been consumed inside the reader.
+  int64_t levelsPosition() const {
+    return levelsPosition_;
   }
 
-  /// \brief Number of definition / repetition levels that have been written
-  /// internally in the reader. This may be larger than values_written() because
-  /// for repeated fields we need to look at the levels in advance to figure out
-  /// the record boundaries.
-  int64_t levels_written() const {
-    return levels_written_;
+  /// \brief Number of definition / repetition levels that have been written.
+  /// Internally in the reader. This may be larger than values_written()
+  /// because. For repeated fields we need to look at the levels in advance to
+  /// figure out. The record boundaries.
+  int64_t levelsWritten() const {
+    return levelsWritten_;
   }
 
-  /// \brief Number of nulls in the leaf that we have read so far into the
-  /// values vector. This is only valid when !read_dense_for_nullable(). When
-  /// read_dense_for_nullable() it will always be 0.
-  int64_t null_count() const {
-    return null_count_;
+  /// \brief Number of nulls in the leaf that we have read so far into the.
+  /// Values vector. This is only valid when !read_dense_for_nullable(). When.
+  /// Read_dense_for_nullable() it will always be 0.
+  int64_t nullCount() const {
+    return nullCount_;
   }
 
-  /// \brief True if the leaf values are nullable
-  bool nullable_values() const {
-    return nullable_values_;
+  /// \brief True if the leaf values are nullable.
+  bool nullableValues() const {
+    return nullableValues_;
   }
 
-  /// \brief True if reading directly as Arrow dictionary-encoded
-  bool read_dictionary() const {
-    return read_dictionary_;
+  /// \brief True if reading directly as Arrow dictionary-encoded.
+  bool readDictionary() const {
+    return readDictionary_;
   }
 
   /// \brief True if reading dense for nullable columns.
-  bool read_dense_for_nullable() const {
-    return read_dense_for_nullable_;
+  bool readDenseForNullable() const {
+    return readDenseForNullable_;
   }
 
  protected:
-  /// \brief Indicates if we can have nullable values. Note that repeated fields
-  /// may or may not be nullable.
-  bool nullable_values_;
+  /// \brief Indicates if we can have nullable values. Note that repeated
+  /// fields. May or may not be nullable.
+  bool nullableValues_;
 
-  bool at_record_start_;
-  int64_t records_read_;
+  bool atRecordStart_;
+  int64_t recordsRead_;
 
-  /// \brief Stores values. These values are populated based on each ReadRecords
-  /// call. No extra values are buffered for the next call. SkipRecords will not
-  /// add any value to this buffer.
+  /// \brief Stores values. These values are populated based on each
+  /// ReadRecords. Call. No extra values are buffered for the next call.
+  /// SkipRecords will not. Add any value to this buffer.
   std::shared_ptr<::arrow::ResizableBuffer> values_;
-  /// \brief False for BYTE_ARRAY, in which case we don't allocate the values
-  /// buffer and we directly read into builder classes.
-  bool uses_values_;
+  /// \brief False for BYTE_ARRAY, in which case we don't allocate the values.
+  /// Buffer and we directly read into builder classes.
+  bool usesValues_;
 
   /// \brief Values that we have read into 'values_' + 'null_count_'.
-  int64_t values_written_;
-  int64_t values_capacity_;
-  int64_t null_count_;
-
-  /// \brief Each bit corresponds to one element in 'values_' and specifies if
-  /// it is null or not null. Not set if read_dense_for_nullable_ is true.
-  std::shared_ptr<::arrow::ResizableBuffer> valid_bits_;
-
-  /// \brief Buffer for definition levels. May contain more levels than
-  /// is actually read. This is because we read levels ahead to
-  /// figure out record boundaries for repeated fields.
-  /// For flat required fields, 'def_levels_' and 'rep_levels_' are not
-  ///  populated. For non-repeated fields 'rep_levels_' is not populated.
-  /// 'def_levels_' and 'rep_levels_' must be of the same size if present.
-  std::shared_ptr<::arrow::ResizableBuffer> def_levels_;
-  /// \brief Buffer for repetition levels. Only populated for repeated
-  /// fields.
-  std::shared_ptr<::arrow::ResizableBuffer> rep_levels_;
-
-  /// \brief Number of definition / repetition levels that have been written
-  /// internally in the reader. This may be larger than values_written() since
-  /// for repeated fields we need to look at the levels in advance to figure out
-  /// the record boundaries.
-  int64_t levels_written_;
+  int64_t valuesWritten_;
+  int64_t valuesCapacity_;
+  int64_t nullCount_;
+
+  /// \brief Each bit corresponds to one element in 'values_' and specifies if.
+  /// It is null or not null. Not set if read_dense_for_nullable_ is true.
+  std::shared_ptr<::arrow::ResizableBuffer> validBits_;
+
+  /// \brief Buffer for definition levels. May contain more levels than.
+  /// Is actually read. This is because we read levels ahead to.
+  /// Figure out record boundaries for repeated fields.
+  /// For flat required fields, 'def_levels_' and 'rep_levels_' are not.
+  ///  Populated. For non-repeated fields 'rep_levels_' is not populated.
+  /// 'Def_levels_' and 'rep_levels_' must be of the same size if present.
+  std::shared_ptr<::arrow::ResizableBuffer> defLevels_;
+  /// \brief Buffer for repetition levels. Only populated for repeated.
+  /// Fields.
+  std::shared_ptr<::arrow::ResizableBuffer> repLevels_;
+
+  /// \brief Number of definition / repetition levels that have been written.
+  /// Internally in the reader. This may be larger than values_written() since.
+  /// For repeated fields we need to look at the levels in advance to figure
+  /// out. The record boundaries.
+  int64_t levelsWritten_;
   /// \brief Position of the next level that should be consumed.
-  int64_t levels_position_;
-  int64_t levels_capacity_;
+  int64_t levelsPosition_;
+  int64_t levelsCapacity_;
 
-  bool read_dictionary_ = false;
-  // If true, we will not leave any space for the null values in the values_
-  // vector.
-  bool read_dense_for_nullable_ = false;
+  bool readDictionary_ = false;
+  // If true, we will not leave any space for the null values in the values_.
+  // Vector.
+  bool readDenseForNullable_ = false;
 };
 
 class BinaryRecordReader : virtual public RecordReader {
  public:
-  virtual std::vector<std::shared_ptr<::arrow::Array>> GetBuilderChunks() = 0;
+  virtual std::vector<std::shared_ptr<::arrow::Array>> getBuilderChunks() = 0;
 };
 
-/// \brief Read records directly to dictionary-encoded Arrow form (int32
-/// indices). Only valid for BYTE_ARRAY columns
+/// \brief Read records directly to dictionary-encoded Arrow form (int32.
+/// Indices). Only valid for BYTE_ARRAY columns.
 class DictionaryRecordReader : virtual public RecordReader {
  public:
-  virtual std::shared_ptr<::arrow::ChunkedArray> GetResult() = 0;
+  virtual std::shared_ptr<::arrow::ChunkedArray> getResult() = 0;
 };
 
 } // namespace internal
diff --git a/velox/dwio/parquet/writer/arrow/tests/ColumnReaderTest.cpp b/velox/dwio/parquet/writer/arrow/tests/ColumnReaderTest.cpp
index 0deb1540244..f4ff80e472e 100644
--- a/velox/dwio/parquet/writer/arrow/tests/ColumnReaderTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/ColumnReaderTest.cpp
@@ -50,32 +50,32 @@ using testing::ElementsAre;
 namespace test {
 
 template <typename T>
-static inline bool vector_equal_with_def_levels(
+static inline bool vectorEqualWithDefLevels(
     const std::vector<T>& left,
-    const std::vector<int16_t>& def_levels,
-    int16_t max_def_levels,
-    int16_t max_rep_levels,
+    const std::vector<int16_t>& defLevels,
+    int16_t maxDefLevels,
+    int16_t maxRepLevels,
     const std::vector<T>& right) {
-  size_t i_left = 0;
-  size_t i_right = 0;
-  for (size_t i = 0; i < def_levels.size(); i++) {
-    if (def_levels[i] == max_def_levels) {
-      // Compare
-      if (left[i_left] != right[i_right]) {
-        std::cerr << "index " << i << " left was " << left[i_left]
+  size_t iLeft = 0;
+  size_t iRight = 0;
+  for (size_t i = 0; i < defLevels.size(); i++) {
+    if (defLevels[i] == maxDefLevels) {
+      // Compare.
+      if (left[iLeft] != right[iRight]) {
+        std::cerr << "index " << i << " left was " << left[iLeft]
                   << " right was " << right[i] << std::endl;
         return false;
       }
-      i_left++;
-      i_right++;
-    } else if (def_levels[i] == (max_def_levels - 1)) {
-      // Null entry on the lowest nested level
-      i_right++;
-    } else if (def_levels[i] < (max_def_levels - 1)) {
-      // Null entry on a higher nesting level, only supported for non-repeating
-      // data
-      if (max_rep_levels == 0) {
-        i_right++;
+      iLeft++;
+      iRight++;
+    } else if (defLevels[i] == (maxDefLevels - 1)) {
+      // Null entry on the lowest nested level.
+      iRight++;
+    } else if (defLevels[i] < (maxDefLevels - 1)) {
+      // Null entry on a higher nesting level, only supported for non-repeating.
+      // Data.
+      if (maxRepLevels == 0) {
+        iRight++;
       }
     }
   }
@@ -85,684 +85,670 @@ static inline bool vector_equal_with_def_levels(
 
 class TestPrimitiveReader : public ::testing::Test {
  public:
-  void InitReader(const ColumnDescriptor* d) {
+  void initReader(const ColumnDescriptor* d) {
     auto pager = std::make_unique<MockPageReader>(pages_);
-    reader_ = ColumnReader::Make(d, std::move(pager));
+    reader_ = ColumnReader::make(d, std::move(pager));
   }
 
-  void CheckResults() {
-    std::vector<int32_t> vresult(num_values_, -1);
-    std::vector<int16_t> dresult(num_levels_, -1);
-    std::vector<int16_t> rresult(num_levels_, -1);
-    int64_t values_read = 0;
-    int total_values_read = 0;
-    int batch_actual = 0;
+  void checkResults() {
+    std::vector<int32_t> vresult(numValues_, -1);
+    std::vector<int16_t> dresult(numLevels_, -1);
+    std::vector<int16_t> rresult(numLevels_, -1);
+    int64_t valuesRead = 0;
+    int totalValuesRead = 0;
+    int batchActual = 0;
 
     Int32Reader* reader = static_cast<Int32Reader*>(reader_.get());
-    int32_t batch_size = 8;
+    int32_t batchSize = 8;
     int batch = 0;
-    // This will cover both the cases
+    // This will cover both the cases.
     // 1) batch_size < page_size (multiple ReadBatch from a single page)
     // 2) batch_size > page_size (BatchRead limits to a single page)
     do {
-      batch = static_cast<int>(reader->ReadBatch(
-          batch_size,
-          &dresult[0] + batch_actual,
-          &rresult[0] + batch_actual,
-          &vresult[0] + total_values_read,
-          &values_read));
-      total_values_read += static_cast<int>(values_read);
-      batch_actual += batch;
-      batch_size = std::min(1 << 24, std::max(batch_size * 2, 4096));
+      batch = static_cast<int>(reader->readBatch(
+          batchSize,
+          &dresult[0] + batchActual,
+          &rresult[0] + batchActual,
+          &vresult[0] + totalValuesRead,
+          &valuesRead));
+      totalValuesRead += static_cast<int>(valuesRead);
+      batchActual += batch;
+      batchSize = std::min(1 << 24, std::max(batchSize * 2, 4096));
     } while (batch > 0);
 
-    ASSERT_EQ(num_levels_, batch_actual);
-    ASSERT_EQ(num_values_, total_values_read);
-    ASSERT_TRUE(vector_equal(values_, vresult));
-    if (max_def_level_ > 0) {
-      ASSERT_TRUE(vector_equal(def_levels_, dresult));
+    ASSERT_EQ(numLevels_, batchActual);
+    ASSERT_EQ(numValues_, totalValuesRead);
+    ASSERT_TRUE(vectorEqual(values_, vresult));
+    if (maxDefLevel_ > 0) {
+      ASSERT_TRUE(vectorEqual(defLevels_, dresult));
     }
-    if (max_rep_level_ > 0) {
-      ASSERT_TRUE(vector_equal(rep_levels_, rresult));
+    if (maxRepLevel_ > 0) {
+      ASSERT_TRUE(vectorEqual(repLevels_, rresult));
     }
-    // catch improper writes at EOS
-    batch_actual = static_cast<int>(
-        reader->ReadBatch(5, nullptr, nullptr, nullptr, &values_read));
-    ASSERT_EQ(0, batch_actual);
-    ASSERT_EQ(0, values_read);
+    // Catch improper writes at EOS.
+    batchActual = static_cast<int>(
+        reader->readBatch(5, nullptr, nullptr, nullptr, &valuesRead));
+    ASSERT_EQ(0, batchActual);
+    ASSERT_EQ(0, valuesRead);
   }
-  void CheckResultsSpaced() {
-    std::vector<int32_t> vresult(num_levels_, -1);
-    std::vector<int16_t> dresult(num_levels_, -1);
-    std::vector<int16_t> rresult(num_levels_, -1);
-    std::vector<uint8_t> valid_bits(num_levels_, 255);
-    int total_values_read = 0;
-    int batch_actual = 0;
-    int levels_actual = 0;
-    int64_t null_count = -1;
-    int64_t levels_read = 0;
-    int64_t values_read;
+  void checkResultsSpaced() {
+    std::vector<int32_t> vresult(numLevels_, -1);
+    std::vector<int16_t> dresult(numLevels_, -1);
+    std::vector<int16_t> rresult(numLevels_, -1);
+    std::vector<uint8_t> validBits(numLevels_, 255);
+    int totalValuesRead = 0;
+    int batchActual = 0;
+    int levelsActual = 0;
+    int64_t nullCount = -1;
+    int64_t levelsRead = 0;
+    int64_t valuesRead;
 
     Int32Reader* reader = static_cast<Int32Reader*>(reader_.get());
-    int32_t batch_size = 8;
+    int32_t batchSize = 8;
     int batch = 0;
-    // This will cover both the cases
+    // This will cover both the cases.
     // 1) batch_size < page_size (multiple ReadBatch from a single page)
     // 2) batch_size > page_size (BatchRead limits to a single page)
     do {
       ARROW_SUPPRESS_DEPRECATION_WARNING
-      batch = static_cast<int>(reader->ReadBatchSpaced(
-          batch_size,
-          dresult.data() + levels_actual,
-          rresult.data() + levels_actual,
-          vresult.data() + batch_actual,
-          valid_bits.data() + batch_actual,
+      batch = static_cast<int>(reader->readBatchSpaced(
+          batchSize,
+          dresult.data() + levelsActual,
+          rresult.data() + levelsActual,
+          vresult.data() + batchActual,
+          validBits.data() + batchActual,
           0,
-          &levels_read,
-          &values_read,
-          &null_count));
+          &levelsRead,
+          &valuesRead,
+          &nullCount));
       ARROW_UNSUPPRESS_DEPRECATION_WARNING
-      total_values_read += batch - static_cast<int>(null_count);
-      batch_actual += batch;
-      levels_actual += static_cast<int>(levels_read);
-      batch_size = std::min(1 << 24, std::max(batch_size * 2, 4096));
-    } while ((batch > 0) || (levels_read > 0));
-
-    ASSERT_EQ(num_levels_, levels_actual);
-    ASSERT_EQ(num_values_, total_values_read);
-    if (max_def_level_ > 0) {
-      ASSERT_TRUE(vector_equal(def_levels_, dresult));
-      ASSERT_TRUE(vector_equal_with_def_levels(
-          values_, dresult, max_def_level_, max_rep_level_, vresult));
+      totalValuesRead += batch - static_cast<int>(nullCount);
+      batchActual += batch;
+      levelsActual += static_cast<int>(levelsRead);
+      batchSize = std::min(1 << 24, std::max(batchSize * 2, 4096));
+    } while ((batch > 0) || (levelsRead > 0));
+
+    ASSERT_EQ(numLevels_, levelsActual);
+    ASSERT_EQ(numValues_, totalValuesRead);
+    if (maxDefLevel_ > 0) {
+      ASSERT_TRUE(vectorEqual(defLevels_, dresult));
+      ASSERT_TRUE(vectorEqualWithDefLevels(
+          values_, dresult, maxDefLevel_, maxRepLevel_, vresult));
     } else {
-      ASSERT_TRUE(vector_equal(values_, vresult));
+      ASSERT_TRUE(vectorEqual(values_, vresult));
     }
-    if (max_rep_level_ > 0) {
-      ASSERT_TRUE(vector_equal(rep_levels_, rresult));
+    if (maxRepLevel_ > 0) {
+      ASSERT_TRUE(vectorEqual(repLevels_, rresult));
     }
-    // catch improper writes at EOS
+    // Catch improper writes at EOS.
     ARROW_SUPPRESS_DEPRECATION_WARNING
-    batch_actual = static_cast<int>(reader->ReadBatchSpaced(
+    batchActual = static_cast<int>(reader->readBatchSpaced(
         5,
         nullptr,
         nullptr,
         nullptr,
-        valid_bits.data(),
+        validBits.data(),
         0,
-        &levels_read,
-        &values_read,
-        &null_count));
+        &levelsRead,
+        &valuesRead,
+        &nullCount));
     ARROW_UNSUPPRESS_DEPRECATION_WARNING
-    ASSERT_EQ(0, batch_actual);
-    ASSERT_EQ(0, null_count);
+    ASSERT_EQ(0, batchActual);
+    ASSERT_EQ(0, nullCount);
   }
 
-  void Clear() {
+  void clear() {
     values_.clear();
-    def_levels_.clear();
-    rep_levels_.clear();
+    defLevels_.clear();
+    repLevels_.clear();
     pages_.clear();
     reader_.reset();
   }
 
   void
-  ExecutePlain(int num_pages, int levels_per_page, const ColumnDescriptor* d) {
-    num_values_ = MakePages<Int32Type>(
+  executePlain(int numPages, int levelsPerPage, const ColumnDescriptor* d) {
+    numValues_ = makePages<Int32Type>(
         d,
-        num_pages,
-        levels_per_page,
-        def_levels_,
-        rep_levels_,
+        numPages,
+        levelsPerPage,
+        defLevels_,
+        repLevels_,
         values_,
-        data_buffer_,
+        dataBuffer_,
         pages_,
-        Encoding::PLAIN);
-    num_levels_ = num_pages * levels_per_page;
-    InitReader(d);
-    CheckResults();
-    Clear();
+        Encoding::kPlain);
+    numLevels_ = numPages * levelsPerPage;
+    initReader(d);
+    checkResults();
+    clear();
 
-    num_values_ = MakePages<Int32Type>(
+    numValues_ = makePages<Int32Type>(
         d,
-        num_pages,
-        levels_per_page,
-        def_levels_,
-        rep_levels_,
+        numPages,
+        levelsPerPage,
+        defLevels_,
+        repLevels_,
         values_,
-        data_buffer_,
+        dataBuffer_,
         pages_,
-        Encoding::PLAIN);
-    num_levels_ = num_pages * levels_per_page;
-    InitReader(d);
-    CheckResultsSpaced();
-    Clear();
+        Encoding::kPlain);
+    numLevels_ = numPages * levelsPerPage;
+    initReader(d);
+    checkResultsSpaced();
+    clear();
   }
 
-  void
-  ExecuteDict(int num_pages, int levels_per_page, const ColumnDescriptor* d) {
-    num_values_ = MakePages<Int32Type>(
+  void executeDict(int numPages, int levelsPerPage, const ColumnDescriptor* d) {
+    numValues_ = makePages<Int32Type>(
         d,
-        num_pages,
-        levels_per_page,
-        def_levels_,
-        rep_levels_,
+        numPages,
+        levelsPerPage,
+        defLevels_,
+        repLevels_,
         values_,
-        data_buffer_,
+        dataBuffer_,
         pages_,
-        Encoding::RLE_DICTIONARY);
-    num_levels_ = num_pages * levels_per_page;
-    InitReader(d);
-    CheckResults();
-    Clear();
+        Encoding::kRleDictionary);
+    numLevels_ = numPages * levelsPerPage;
+    initReader(d);
+    checkResults();
+    clear();
 
-    num_values_ = MakePages<Int32Type>(
+    numValues_ = makePages<Int32Type>(
         d,
-        num_pages,
-        levels_per_page,
-        def_levels_,
-        rep_levels_,
+        numPages,
+        levelsPerPage,
+        defLevels_,
+        repLevels_,
         values_,
-        data_buffer_,
+        dataBuffer_,
         pages_,
-        Encoding::RLE_DICTIONARY);
-    num_levels_ = num_pages * levels_per_page;
-    InitReader(d);
-    CheckResultsSpaced();
-    Clear();
+        Encoding::kRleDictionary);
+    numLevels_ = numPages * levelsPerPage;
+    initReader(d);
+    checkResultsSpaced();
+    clear();
   }
 
  protected:
-  int num_levels_;
-  int num_values_;
-  int16_t max_def_level_;
-  int16_t max_rep_level_;
+  int numLevels_;
+  int numValues_;
+  int16_t maxDefLevel_;
+  int16_t maxRepLevel_;
   std::vector<std::shared_ptr<Page>> pages_;
   std::shared_ptr<ColumnReader> reader_;
   std::vector<int32_t> values_;
-  std::vector<int16_t> def_levels_;
-  std::vector<int16_t> rep_levels_;
-  std::vector<uint8_t> data_buffer_; // For BA and FLBA
+  std::vector<int16_t> defLevels_;
+  std::vector<int16_t> repLevels_;
+  std::vector<uint8_t> dataBuffer_; // For BA and FLBA
 };
 
 TEST_F(TestPrimitiveReader, TestInt32FlatRequired) {
-  int levels_per_page = 100;
-  int num_pages = 50;
-  max_def_level_ = 0;
-  max_rep_level_ = 0;
-  NodePtr type = schema::Int32("a", Repetition::REQUIRED);
-  const ColumnDescriptor descr(type, max_def_level_, max_rep_level_);
-  ASSERT_NO_FATAL_FAILURE(ExecutePlain(num_pages, levels_per_page, &descr));
-  ASSERT_NO_FATAL_FAILURE(ExecuteDict(num_pages, levels_per_page, &descr));
+  int levelsPerPage = 100;
+  int numPages = 50;
+  maxDefLevel_ = 0;
+  maxRepLevel_ = 0;
+  NodePtr type = schema::int32("a", Repetition::kRequired);
+  const ColumnDescriptor descr(type, maxDefLevel_, maxRepLevel_);
+  ASSERT_NO_FATAL_FAILURE(executePlain(numPages, levelsPerPage, &descr));
+  ASSERT_NO_FATAL_FAILURE(executeDict(numPages, levelsPerPage, &descr));
 }
 
 TEST_F(TestPrimitiveReader, TestInt32FlatOptional) {
-  int levels_per_page = 100;
-  int num_pages = 50;
-  max_def_level_ = 4;
-  max_rep_level_ = 0;
-  NodePtr type = schema::Int32("b", Repetition::OPTIONAL);
-  const ColumnDescriptor descr(type, max_def_level_, max_rep_level_);
-  ASSERT_NO_FATAL_FAILURE(ExecutePlain(num_pages, levels_per_page, &descr));
-  ASSERT_NO_FATAL_FAILURE(ExecuteDict(num_pages, levels_per_page, &descr));
+  int levelsPerPage = 100;
+  int numPages = 50;
+  maxDefLevel_ = 4;
+  maxRepLevel_ = 0;
+  NodePtr type = schema::int32("b", Repetition::kOptional);
+  const ColumnDescriptor descr(type, maxDefLevel_, maxRepLevel_);
+  ASSERT_NO_FATAL_FAILURE(executePlain(numPages, levelsPerPage, &descr));
+  ASSERT_NO_FATAL_FAILURE(executeDict(numPages, levelsPerPage, &descr));
 }
 
 TEST_F(TestPrimitiveReader, TestInt32FlatRepeated) {
-  int levels_per_page = 100;
-  int num_pages = 50;
-  max_def_level_ = 4;
-  max_rep_level_ = 2;
-  NodePtr type = schema::Int32("c", Repetition::REPEATED);
-  const ColumnDescriptor descr(type, max_def_level_, max_rep_level_);
-  ASSERT_NO_FATAL_FAILURE(ExecutePlain(num_pages, levels_per_page, &descr));
-  ASSERT_NO_FATAL_FAILURE(ExecuteDict(num_pages, levels_per_page, &descr));
+  int levelsPerPage = 100;
+  int numPages = 50;
+  maxDefLevel_ = 4;
+  maxRepLevel_ = 2;
+  NodePtr type = schema::int32("c", Repetition::kRepeated);
+  const ColumnDescriptor descr(type, maxDefLevel_, maxRepLevel_);
+  ASSERT_NO_FATAL_FAILURE(executePlain(numPages, levelsPerPage, &descr));
+  ASSERT_NO_FATAL_FAILURE(executeDict(numPages, levelsPerPage, &descr));
 }
 
 // Tests skipping around page boundaries.
 TEST_F(TestPrimitiveReader, TestSkipAroundPageBoundries) {
-  int levels_per_page = 100;
-  int num_pages = 7;
-  max_def_level_ = 0;
-  max_rep_level_ = 0;
-  NodePtr type = schema::Int32("b", Repetition::REQUIRED);
-  const ColumnDescriptor descr(type, max_def_level_, max_rep_level_);
-  MakePages<Int32Type>(
+  int levelsPerPage = 100;
+  int numPages = 7;
+  maxDefLevel_ = 0;
+  maxRepLevel_ = 0;
+  NodePtr type = schema::int32("b", Repetition::kRequired);
+  const ColumnDescriptor descr(type, maxDefLevel_, maxRepLevel_);
+  makePages<Int32Type>(
       &descr,
-      num_pages,
-      levels_per_page,
-      def_levels_,
-      rep_levels_,
+      numPages,
+      levelsPerPage,
+      defLevels_,
+      repLevels_,
       values_,
-      data_buffer_,
+      dataBuffer_,
       pages_,
-      Encoding::PLAIN);
-  InitReader(&descr);
-  std::vector<int32_t> vresult(levels_per_page / 2, -1);
-  std::vector<int16_t> dresult(levels_per_page / 2, -1);
-  std::vector<int16_t> rresult(levels_per_page / 2, -1);
+      Encoding::kPlain);
+  initReader(&descr);
+  std::vector<int32_t> vresult(levelsPerPage / 2, -1);
+  std::vector<int16_t> dresult(levelsPerPage / 2, -1);
+  std::vector<int16_t> rresult(levelsPerPage / 2, -1);
 
   Int32Reader* reader = static_cast<Int32Reader*>(reader_.get());
-  int64_t values_read = 0;
+  int64_t valuesRead = 0;
 
   // 1) skip_size > page_size (multiple pages skipped)
-  // Skip first 2 pages
-  int64_t levels_skipped = reader->Skip(2 * levels_per_page);
-  ASSERT_EQ(2 * levels_per_page, levels_skipped);
-  // Read half a page
-  reader->ReadBatch(
-      levels_per_page / 2,
+  // Skip first 2 pages.
+  int64_t levelsSkipped = reader->skip(2 * levelsPerPage);
+  ASSERT_EQ(2 * levelsPerPage, levelsSkipped);
+  // Read half a page.
+  reader->readBatch(
+      levelsPerPage / 2,
       dresult.data(),
       rresult.data(),
       vresult.data(),
-      &values_read);
-  std::vector<int32_t> sub_values(
-      values_.begin() + 2 * levels_per_page,
-      values_.begin() + static_cast<int>(2.5 * levels_per_page));
-  ASSERT_TRUE(vector_equal(sub_values, vresult));
+      &valuesRead);
+  std::vector<int32_t> subValues(
+      values_.begin() + 2 * levelsPerPage,
+      values_.begin() + static_cast<int>(2.5 * levelsPerPage));
+  ASSERT_TRUE(vectorEqual(subValues, vresult));
 
   // 2) skip_size == page_size (skip across two pages from page 2.5 to 3.5)
-  levels_skipped = reader->Skip(levels_per_page);
-  ASSERT_EQ(levels_per_page, levels_skipped);
+  levelsSkipped = reader->skip(levelsPerPage);
+  ASSERT_EQ(levelsPerPage, levelsSkipped);
   // Read half a page (page 3.5 to 4)
-  reader->ReadBatch(
-      levels_per_page / 2,
+  reader->readBatch(
+      levelsPerPage / 2,
       dresult.data(),
       rresult.data(),
       vresult.data(),
-      &values_read);
-  sub_values.clear();
-  sub_values.insert(
-      sub_values.end(),
-      values_.begin() + static_cast<int>(3.5 * levels_per_page),
-      values_.begin() + 4 * levels_per_page);
-  ASSERT_TRUE(vector_equal(sub_values, vresult));
+      &valuesRead);
+  subValues.clear();
+  subValues.insert(
+      subValues.end(),
+      values_.begin() + static_cast<int>(3.5 * levelsPerPage),
+      values_.begin() + 4 * levelsPerPage);
+  ASSERT_TRUE(vectorEqual(subValues, vresult));
 
   // 3) skip_size == page_size (skip page 4 from start of the page to the end)
-  levels_skipped = reader->Skip(levels_per_page);
-  ASSERT_EQ(levels_per_page, levels_skipped);
+  levelsSkipped = reader->skip(levelsPerPage);
+  ASSERT_EQ(levelsPerPage, levelsSkipped);
   // Read half a page (page 5 to 5.5)
-  reader->ReadBatch(
-      levels_per_page / 2,
+  reader->readBatch(
+      levelsPerPage / 2,
       dresult.data(),
       rresult.data(),
       vresult.data(),
-      &values_read);
-  sub_values.clear();
-  sub_values.insert(
-      sub_values.end(),
-      values_.begin() + static_cast<int>(5.0 * levels_per_page),
-      values_.begin() + static_cast<int>(5.5 * levels_per_page));
-  ASSERT_TRUE(vector_equal(sub_values, vresult));
+      &valuesRead);
+  subValues.clear();
+  subValues.insert(
+      subValues.end(),
+      values_.begin() + static_cast<int>(5.0 * levelsPerPage),
+      values_.begin() + static_cast<int>(5.5 * levelsPerPage));
+  ASSERT_TRUE(vectorEqual(subValues, vresult));
 
   // 4) skip_size < page_size (skip limited to a single page)
   // Skip half a page (page 5.5 to 6)
-  levels_skipped = reader->Skip(levels_per_page / 2);
-  ASSERT_EQ(0.5 * levels_per_page, levels_skipped);
+  levelsSkipped = reader->skip(levelsPerPage / 2);
+  ASSERT_EQ(0.5 * levelsPerPage, levelsSkipped);
   // Read half a page (6 to 6.5)
-  reader->ReadBatch(
-      levels_per_page / 2,
+  reader->readBatch(
+      levelsPerPage / 2,
       dresult.data(),
       rresult.data(),
       vresult.data(),
-      &values_read);
-  sub_values.clear();
-  sub_values.insert(
-      sub_values.end(),
-      values_.begin() + static_cast<int>(6.0 * levels_per_page),
-      values_.begin() + static_cast<int>(6.5 * levels_per_page));
-  ASSERT_TRUE(vector_equal(sub_values, vresult));
-
-  // 5) skip_size = 0
-  levels_skipped = reader->Skip(0);
-  ASSERT_EQ(0, levels_skipped);
+      &valuesRead);
+  subValues.clear();
+  subValues.insert(
+      subValues.end(),
+      values_.begin() + static_cast<int>(6.0 * levelsPerPage),
+      values_.begin() + static_cast<int>(6.5 * levelsPerPage));
+  ASSERT_TRUE(vectorEqual(subValues, vresult));
+
+  // 5) Skip_size = 0.
+  levelsSkipped = reader->skip(0);
+  ASSERT_EQ(0, levelsSkipped);
 
   // 6) Skip past the end page.
-  levels_skipped = reader->Skip(levels_per_page / 2 + 10);
-  ASSERT_EQ(levels_per_page / 2, levels_skipped);
+  levelsSkipped = reader->skip(levelsPerPage / 2 + 10);
+  ASSERT_EQ(levelsPerPage / 2, levelsSkipped);
 
   values_.clear();
-  def_levels_.clear();
-  rep_levels_.clear();
+  defLevels_.clear();
+  repLevels_.clear();
   pages_.clear();
   reader_.reset();
 }
 
-// Skip with repeated field. This test makes it clear that we are skipping
-// values and not records.
+// Skip with repeated field. This test makes it clear that we are skipping.
+// Values and not records.
 TEST_F(TestPrimitiveReader, TestSkipRepeatedField) {
   // Example schema: message M { repeated int32 b = 1 }
-  max_def_level_ = 1;
-  max_rep_level_ = 1;
-  NodePtr type = schema::Int32("b", Repetition::REPEATED);
-  const ColumnDescriptor descr(type, max_def_level_, max_rep_level_);
+  maxDefLevel_ = 1;
+  maxRepLevel_ = 1;
+  NodePtr type = schema::int32("b", Repetition::kRepeated);
+  const ColumnDescriptor descr(type, maxDefLevel_, maxRepLevel_);
   // Example rows: {}, {[10, 10]}, {[20, 20, 20]}
   std::vector<int32_t> values = {10, 10, 20, 20, 20};
-  std::vector<int16_t> def_levels = {0, 1, 1, 1, 1, 1};
-  std::vector<int16_t> rep_levels = {0, 0, 1, 0, 1, 1};
-  num_values_ = static_cast<int>(def_levels.size());
-  std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
+  std::vector<int16_t> defLevels = {0, 1, 1, 1, 1, 1};
+  std::vector<int16_t> repLevels = {0, 0, 1, 0, 1, 1};
+  numValues_ = static_cast<int>(defLevels.size());
+  std::shared_ptr<DataPageV1> page = makeDataPage<Int32Type>(
       &descr,
       values,
-      num_values_,
-      Encoding::PLAIN,
-      /*indices=*/{},
-      /*indices_size=*/0,
-      def_levels,
-      max_def_level_,
-      rep_levels,
-      max_rep_level_);
+      numValues_,
+      Encoding::kPlain,
+      {},
+      0,
+      defLevels,
+      maxDefLevel_,
+      repLevels,
+      maxRepLevel_);
 
   pages_.push_back(std::move(page));
 
-  InitReader(&descr);
+  initReader(&descr);
   Int32Reader* reader = static_cast<Int32Reader*>(reader_.get());
 
   // Vecotrs to hold read values, definition levels, and repetition levels.
-  std::vector<int32_t> read_vals(4, -1);
-  std::vector<int16_t> read_defs(4, -1);
-  std::vector<int16_t> read_reps(4, -1);
+  std::vector<int32_t> readVals(4, -1);
+  std::vector<int16_t> readDefs(4, -1);
+  std::vector<int16_t> readReps(4, -1);
 
   // Skip two levels.
-  int64_t levels_skipped = reader->Skip(2);
-  ASSERT_EQ(2, levels_skipped);
-
-  int64_t num_read_values = 0;
-  // Read the next set of values
-  reader->ReadBatch(
-      10,
-      read_defs.data(),
-      read_reps.data(),
-      read_vals.data(),
-      &num_read_values);
-  ASSERT_EQ(num_read_values, 4);
+  int64_t levelsSkipped = reader->skip(2);
+  ASSERT_EQ(2, levelsSkipped);
+
+  int64_t numReadValues = 0;
+  // Read the next set of values.
+  reader->readBatch(
+      10, readDefs.data(), readReps.data(), readVals.data(), &numReadValues);
+  ASSERT_EQ(numReadValues, 4);
   // Note that we end up in the record with {[10, 10]}
-  ASSERT_TRUE(vector_equal({10, 20, 20, 20}, read_vals));
-  ASSERT_TRUE(vector_equal({1, 1, 1, 1}, read_defs));
-  ASSERT_TRUE(vector_equal({1, 0, 1, 1}, read_reps));
-
-  // No values remain in data page
-  levels_skipped = reader->Skip(2);
-  ASSERT_EQ(0, levels_skipped);
-  reader->ReadBatch(
-      10,
-      read_defs.data(),
-      read_reps.data(),
-      read_vals.data(),
-      &num_read_values);
-  ASSERT_EQ(num_read_values, 0);
+  ASSERT_TRUE(vectorEqual({10, 20, 20, 20}, readVals));
+  ASSERT_TRUE(vectorEqual({1, 1, 1, 1}, readDefs));
+  ASSERT_TRUE(vectorEqual({1, 0, 1, 1}, readReps));
+
+  // No values remain in data page.
+  levelsSkipped = reader->skip(2);
+  ASSERT_EQ(0, levelsSkipped);
+  reader->readBatch(
+      10, readDefs.data(), readReps.data(), readVals.data(), &numReadValues);
+  ASSERT_EQ(numReadValues, 0);
 }
 
 // Page claims to have two values but only 1 is present.
 TEST_F(TestPrimitiveReader, TestReadValuesMissing) {
-  max_def_level_ = 1;
-  max_rep_level_ = 0;
-  constexpr int batch_size = 1;
+  maxDefLevel_ = 1;
+  maxRepLevel_ = 0;
+  constexpr int batchSize = 1;
   std::vector<bool> values(1, false);
-  std::vector<int16_t> input_def_levels(1, 1);
-  NodePtr type = schema::Boolean("a", Repetition::OPTIONAL);
-  const ColumnDescriptor descr(type, max_def_level_, max_rep_level_);
+  std::vector<int16_t> inputDefLevels(1, 1);
+  NodePtr type = schema::boolean("a", Repetition::kOptional);
+  const ColumnDescriptor descr(type, maxDefLevel_, maxRepLevel_);
 
-  // The data page falls back to plain encoding
-  std::shared_ptr<ResizableBuffer> dummy = AllocateBuffer();
-  std::shared_ptr<DataPageV1> data_page = MakeDataPage<BooleanType>(
+  // The data page falls back to plain encoding.
+  std::shared_ptr<ResizableBuffer> dummy = allocateBuffer();
+  std::shared_ptr<DataPageV1> dataPage = makeDataPage<BooleanType>(
       &descr,
       values,
-      /*num_vals=*/2,
-      Encoding::PLAIN,
-      /*indices=*/{},
-      /*indices_size=*/0,
-      /*def_levels=*/input_def_levels,
-      max_def_level_,
-      /*rep_levels=*/{},
-      /*max_rep_level=*/0);
-  pages_.push_back(data_page);
-  InitReader(&descr);
+      2,
+      Encoding::kPlain,
+      {},
+      0,
+      inputDefLevels,
+      maxDefLevel_,
+      {},
+      0);
+  pages_.push_back(dataPage);
+  initReader(&descr);
   auto reader = static_cast<BoolReader*>(reader_.get());
-  ASSERT_TRUE(reader->HasNext());
-  std::vector<int16_t> def_levels(batch_size, 0);
-  std::vector<int16_t> rep_levels(batch_size, 0);
-  bool values_out[batch_size];
-  int64_t values_read;
+  ASSERT_TRUE(reader->hasNext());
+  std::vector<int16_t> defLevels(batchSize, 0);
+  std::vector<int16_t> repLevels(batchSize, 0);
+  bool valuesOut[batchSize];
+  int64_t valuesRead;
   EXPECT_EQ(
       1,
-      reader->ReadBatch(
-          batch_size,
-          def_levels.data(),
-          rep_levels.data(),
-          values_out,
-          &values_read));
+      reader->readBatch(
+          batchSize,
+          defLevels.data(),
+          repLevels.data(),
+          valuesOut,
+          &valuesRead));
   ASSERT_THROW(
-      reader->ReadBatch(
-          batch_size,
-          def_levels.data(),
-          rep_levels.data(),
-          values_out,
-          &values_read),
+      reader->readBatch(
+          batchSize,
+          defLevels.data(),
+          repLevels.data(),
+          valuesOut,
+          &valuesRead),
       ParquetException);
 }
 
-// Repetition level byte length reported in Page but Max Repetition level
-// is zero for the column.
+// Repetition level byte length reported in Page but Max Repetition level.
+// Is zero for the column.
 TEST_F(TestPrimitiveReader, TestRepetitionLvlBytesWithMaxRepetitionZero) {
-  constexpr int batch_size = 4;
-  max_def_level_ = 1;
-  max_rep_level_ = 0;
-  NodePtr type = schema::Int32("a", Repetition::OPTIONAL);
-  const ColumnDescriptor descr(type, max_def_level_, max_rep_level_);
-  // Bytes here came from the example parquet file in ARROW-17453's int32
-  // column which was delta bit-packed. The key part is the first three
-  // bytes: the page header reports 1 byte for repetition levels even
-  // though the max rep level is 0. If that byte isn't skipped then
-  // we get def levels of [1, 1, 0, 0] instead of the correct [1, 1, 1, 0].
-  const std::vector<uint8_t> page_data{0x3,  0x3, 0x7, 0x80, 0x1, 0x4, 0x3,
-                                       0x18, 0x1, 0x2, 0x0,  0x0, 0x0, 0xc,
-                                       0x0,  0x0, 0x0, 0x0,  0x0, 0x0, 0x0};
-
-  std::shared_ptr<DataPageV2> data_page = std::make_shared<DataPageV2>(
-      Buffer::Wrap(page_data.data(), page_data.size()),
+  constexpr int batchSize = 4;
+  maxDefLevel_ = 1;
+  maxRepLevel_ = 0;
+  NodePtr type = schema::int32("a", Repetition::kOptional);
+  const ColumnDescriptor descr(type, maxDefLevel_, maxRepLevel_);
+  // Bytes here came from the example parquet file in ARROW-17453's int32.
+  // Column which was delta bit-packed. The key part is the first three.
+  // Bytes: the page header reports 1 byte for repetition levels even.
+  // Though the max rep level is 0. If that byte isn't skipped then.
+  // We get def levels of [1, 1, 0, 0] instead of the correct [1, 1, 1, 0].
+  const std::vector<uint8_t> pageData{0x3,  0x3, 0x7, 0x80, 0x1, 0x4, 0x3,
+                                      0x18, 0x1, 0x2, 0x0,  0x0, 0x0, 0xc,
+                                      0x0,  0x0, 0x0, 0x0,  0x0, 0x0, 0x0};
+
+  std::shared_ptr<DataPageV2> dataPage = std::make_shared<DataPageV2>(
+      Buffer::Wrap(pageData.data(), pageData.size()),
       4,
       1,
       4,
-      Encoding::DELTA_BINARY_PACKED,
+      Encoding::kDeltaBinaryPacked,
       2,
       1,
       21);
 
-  pages_.push_back(data_page);
-  InitReader(&descr);
+  pages_.push_back(dataPage);
+  initReader(&descr);
   auto reader = static_cast<Int32Reader*>(reader_.get());
-  int16_t def_levels_out[batch_size];
-  int32_t values[batch_size];
-  int64_t values_read;
-  ASSERT_TRUE(reader->HasNext());
+  int16_t defLevelsOut[batchSize];
+  int32_t values[batchSize];
+  int64_t valuesRead;
+  ASSERT_TRUE(reader->hasNext());
   EXPECT_EQ(
       4,
-      reader->ReadBatch(
-          batch_size,
-          def_levels_out,
-          /*replevels=*/nullptr,
-          values,
-          &values_read));
-  EXPECT_EQ(3, values_read);
+      reader->readBatch(batchSize, defLevelsOut, nullptr, values, &valuesRead));
+  EXPECT_EQ(3, valuesRead);
 }
 
 // Page claims to have two values but only 1 is present.
 TEST_F(TestPrimitiveReader, TestReadValuesMissingWithDictionary) {
-  constexpr int batch_size = 1;
-  max_def_level_ = 1;
-  max_rep_level_ = 0;
-  NodePtr type = schema::Int32("a", Repetition::OPTIONAL);
-  const ColumnDescriptor descr(type, max_def_level_, max_rep_level_);
-  std::shared_ptr<ResizableBuffer> dummy = AllocateBuffer();
-
-  std::shared_ptr<DictionaryPage> dict_page =
-      std::make_shared<DictionaryPage>(dummy, 0, Encoding::PLAIN);
-  std::vector<int16_t> input_def_levels(1, 0);
-  std::shared_ptr<DataPageV1> data_page = MakeDataPage<Int32Type>(
+  constexpr int batchSize = 1;
+  maxDefLevel_ = 1;
+  maxRepLevel_ = 0;
+  NodePtr type = schema::int32("a", Repetition::kOptional);
+  const ColumnDescriptor descr(type, maxDefLevel_, maxRepLevel_);
+  std::shared_ptr<ResizableBuffer> dummy = allocateBuffer();
+
+  std::shared_ptr<DictionaryPage> dictPage =
+      std::make_shared<DictionaryPage>(dummy, 0, Encoding::kPlain);
+  std::vector<int16_t> inputDefLevels(1, 0);
+  std::shared_ptr<DataPageV1> dataPage = makeDataPage<Int32Type>(
       &descr,
       {},
-      /*num_vals=*/2,
-      Encoding::RLE_DICTIONARY,
-      /*indices=*/{},
-      /*indices_size=*/0,
-      /*def_levels=*/input_def_levels,
-      max_def_level_,
-      /*rep_levels=*/{},
-      /*max_rep_level=*/0);
-  pages_.push_back(dict_page);
-  pages_.push_back(data_page);
-  InitReader(&descr);
+      2,
+      Encoding::kRleDictionary,
+      {},
+      0,
+      inputDefLevels,
+      maxDefLevel_,
+      {},
+      0);
+  pages_.push_back(dictPage);
+  pages_.push_back(dataPage);
+  initReader(&descr);
   auto reader = static_cast<ByteArrayReader*>(reader_.get());
   const ByteArray* dict = nullptr;
-  int32_t dict_len = 0;
-  int64_t indices_read = 0;
-  int32_t indices[batch_size];
-  int16_t def_levels_out[batch_size];
-  ASSERT_TRUE(reader->HasNext());
+  int32_t dictLen = 0;
+  int64_t indicesRead = 0;
+  int32_t indices[batchSize];
+  int16_t defLevelsOut[batchSize];
+  ASSERT_TRUE(reader->hasNext());
   EXPECT_EQ(
       1,
-      reader->ReadBatchWithDictionary(
-          batch_size,
-          def_levels_out,
-          /*rep_levels=*/nullptr,
+      reader->readBatchWithDictionary(
+          batchSize,
+          defLevelsOut,
+          nullptr,
           indices,
-          &indices_read,
+          &indicesRead,
           &dict,
-          &dict_len));
+          &dictLen));
   ASSERT_THROW(
-      reader->ReadBatchWithDictionary(
-          batch_size,
-          def_levels_out,
-          /*rep_levels=*/nullptr,
+      reader->readBatchWithDictionary(
+          batchSize,
+          defLevelsOut,
+          nullptr,
           indices,
-          &indices_read,
+          &indicesRead,
           &dict,
-          &dict_len),
+          &dictLen),
       ParquetException);
 }
 
 TEST_F(TestPrimitiveReader, TestDictionaryEncodedPages) {
-  max_def_level_ = 0;
-  max_rep_level_ = 0;
-  NodePtr type = schema::Int32("a", Repetition::REQUIRED);
-  const ColumnDescriptor descr(type, max_def_level_, max_rep_level_);
-  std::shared_ptr<ResizableBuffer> dummy = AllocateBuffer();
-
-  std::shared_ptr<DictionaryPage> dict_page =
-      std::make_shared<DictionaryPage>(dummy, 0, Encoding::PLAIN);
-  std::shared_ptr<DataPageV1> data_page = MakeDataPage<Int32Type>(
-      &descr, {}, 0, Encoding::RLE_DICTIONARY, {}, 0, {}, 0, {}, 0);
-  pages_.push_back(dict_page);
-  pages_.push_back(data_page);
-  InitReader(&descr);
-  // Tests Dict : PLAIN, Data : RLE_DICTIONARY
-  ASSERT_NO_THROW(reader_->HasNext());
+  maxDefLevel_ = 0;
+  maxRepLevel_ = 0;
+  NodePtr type = schema::int32("a", Repetition::kRequired);
+  const ColumnDescriptor descr(type, maxDefLevel_, maxRepLevel_);
+  std::shared_ptr<ResizableBuffer> dummy = allocateBuffer();
+
+  std::shared_ptr<DictionaryPage> dictPage =
+      std::make_shared<DictionaryPage>(dummy, 0, Encoding::kPlain);
+  std::shared_ptr<DataPageV1> dataPage = makeDataPage<Int32Type>(
+      &descr, {}, 0, Encoding::kRleDictionary, {}, 0, {}, 0, {}, 0);
+  pages_.push_back(dictPage);
+  pages_.push_back(dataPage);
+  initReader(&descr);
+  // Tests Dict : PLAIN, Data : RLE_DICTIONARY.
+  ASSERT_NO_THROW(reader_->hasNext());
   pages_.clear();
 
-  dict_page =
-      std::make_shared<DictionaryPage>(dummy, 0, Encoding::PLAIN_DICTIONARY);
-  data_page = MakeDataPage<Int32Type>(
-      &descr, {}, 0, Encoding::PLAIN_DICTIONARY, {}, 0, {}, 0, {}, 0);
-  pages_.push_back(dict_page);
-  pages_.push_back(data_page);
-  InitReader(&descr);
-  // Tests Dict : PLAIN_DICTIONARY, Data : PLAIN_DICTIONARY
-  ASSERT_NO_THROW(reader_->HasNext());
+  dictPage =
+      std::make_shared<DictionaryPage>(dummy, 0, Encoding::kPlainDictionary);
+  dataPage = makeDataPage<Int32Type>(
+      &descr, {}, 0, Encoding::kPlainDictionary, {}, 0, {}, 0, {}, 0);
+  pages_.push_back(dictPage);
+  pages_.push_back(dataPage);
+  initReader(&descr);
+  // Tests Dict : PLAIN_DICTIONARY, Data : PLAIN_DICTIONARY.
+  ASSERT_NO_THROW(reader_->hasNext());
   pages_.clear();
 
-  data_page = MakeDataPage<Int32Type>(
-      &descr, {}, 0, Encoding::RLE_DICTIONARY, {}, 0, {}, 0, {}, 0);
-  pages_.push_back(data_page);
-  InitReader(&descr);
-  // Tests dictionary page must occur before data page
-  ASSERT_THROW(reader_->HasNext(), ParquetException);
+  dataPage = makeDataPage<Int32Type>(
+      &descr, {}, 0, Encoding::kRleDictionary, {}, 0, {}, 0, {}, 0);
+  pages_.push_back(dataPage);
+  initReader(&descr);
+  // Tests dictionary page must occur before data page.
+  ASSERT_THROW(reader_->hasNext(), ParquetException);
   pages_.clear();
 
-  dict_page =
-      std::make_shared<DictionaryPage>(dummy, 0, Encoding::DELTA_BYTE_ARRAY);
-  pages_.push_back(dict_page);
-  InitReader(&descr);
-  // Tests only RLE_DICTIONARY is supported
-  ASSERT_THROW(reader_->HasNext(), ParquetException);
+  dictPage =
+      std::make_shared<DictionaryPage>(dummy, 0, Encoding::kDeltaByteArray);
+  pages_.push_back(dictPage);
+  initReader(&descr);
+  // Tests only RLE_DICTIONARY is supported.
+  ASSERT_THROW(reader_->hasNext(), ParquetException);
   pages_.clear();
 
-  std::shared_ptr<DictionaryPage> dict_page1 =
-      std::make_shared<DictionaryPage>(dummy, 0, Encoding::PLAIN_DICTIONARY);
-  std::shared_ptr<DictionaryPage> dict_page2 =
-      std::make_shared<DictionaryPage>(dummy, 0, Encoding::PLAIN);
-  pages_.push_back(dict_page1);
-  pages_.push_back(dict_page2);
-  InitReader(&descr);
-  // Column cannot have more than one dictionary
-  ASSERT_THROW(reader_->HasNext(), ParquetException);
+  std::shared_ptr<DictionaryPage> dictPage1 =
+      std::make_shared<DictionaryPage>(dummy, 0, Encoding::kPlainDictionary);
+  std::shared_ptr<DictionaryPage> dictPage2 =
+      std::make_shared<DictionaryPage>(dummy, 0, Encoding::kPlain);
+  pages_.push_back(dictPage1);
+  pages_.push_back(dictPage2);
+  initReader(&descr);
+  // Column cannot have more than one dictionary.
+  ASSERT_THROW(reader_->hasNext(), ParquetException);
   pages_.clear();
 
-  data_page = MakeDataPage<Int32Type>(
-      &descr, {}, 0, Encoding::DELTA_BYTE_ARRAY, {}, 0, {}, 0, {}, 0);
-  pages_.push_back(data_page);
-  InitReader(&descr);
-  // unsupported encoding
-  ASSERT_THROW(reader_->HasNext(), ParquetException);
+  dataPage = makeDataPage<Int32Type>(
+      &descr, {}, 0, Encoding::kDeltaByteArray, {}, 0, {}, 0, {}, 0);
+  pages_.push_back(dataPage);
+  initReader(&descr);
+  // Unsupported encoding.
+  ASSERT_THROW(reader_->hasNext(), ParquetException);
   pages_.clear();
 }
 
 TEST_F(TestPrimitiveReader, TestDictionaryEncodedPagesWithExposeEncoding) {
-  max_def_level_ = 0;
-  max_rep_level_ = 0;
-  int levels_per_page = 100;
-  int num_pages = 5;
-  std::vector<int16_t> def_levels;
-  std::vector<int16_t> rep_levels;
+  maxDefLevel_ = 0;
+  maxRepLevel_ = 0;
+  int levelsPerPage = 100;
+  int numPages = 5;
+  std::vector<int16_t> defLevels;
+  std::vector<int16_t> repLevels;
   std::vector<ByteArray> values;
   std::vector<uint8_t> buffer;
-  NodePtr type = schema::ByteArray("a", Repetition::REQUIRED);
-  const ColumnDescriptor descr(type, max_def_level_, max_rep_level_);
+  NodePtr type = schema::byteArray("a", Repetition::kRequired);
+  const ColumnDescriptor descr(type, maxDefLevel_, maxRepLevel_);
 
-  // Fully dictionary encoded
-  MakePages<ByteArrayType>(
+  // Fully dictionary encoded.
+  makePages<ByteArrayType>(
       &descr,
-      num_pages,
-      levels_per_page,
-      def_levels,
-      rep_levels,
+      numPages,
+      levelsPerPage,
+      defLevels,
+      repLevels,
       values,
       buffer,
       pages_,
-      Encoding::RLE_DICTIONARY);
-  InitReader(&descr);
+      Encoding::kRleDictionary);
+  initReader(&descr);
 
   auto reader = static_cast<ByteArrayReader*>(reader_.get());
   const ByteArray* dict = nullptr;
-  int32_t dict_len = 0;
-  int64_t total_indices = 0;
-  int64_t indices_read = 0;
-  int64_t value_size = values.size();
-  auto indices = std::make_unique<int32_t[]>(value_size);
-  while (total_indices < value_size && reader->HasNext()) {
-    const ByteArray* tmp_dict = nullptr;
-    int32_t tmp_dict_len = 0;
-    EXPECT_NO_THROW(reader->ReadBatchWithDictionary(
-        value_size,
-        /*def_levels=*/nullptr,
-        /*rep_levels=*/nullptr,
-        indices.get() + total_indices,
-        &indices_read,
-        &tmp_dict,
-        &tmp_dict_len));
-    if (tmp_dict != nullptr) {
-      // Dictionary is read along with data
-      EXPECT_GT(indices_read, 0);
-      dict = tmp_dict;
-      dict_len = tmp_dict_len;
+  int32_t dictLen = 0;
+  int64_t totalIndices = 0;
+  int64_t indicesRead = 0;
+  int64_t valueSize = values.size();
+  auto indices = std::make_unique<int32_t[]>(valueSize);
+  while (totalIndices < valueSize && reader->hasNext()) {
+    const ByteArray* tmpDict = nullptr;
+    int32_t tmpDictLen = 0;
+    EXPECT_NO_THROW(reader->readBatchWithDictionary(
+        valueSize,
+        nullptr,
+        nullptr,
+        indices.get() + totalIndices,
+        &indicesRead,
+        &tmpDict,
+        &tmpDictLen));
+    if (tmpDict != nullptr) {
+      // Dictionary is read along with data.
+      EXPECT_GT(indicesRead, 0);
+      dict = tmpDict;
+      dictLen = tmpDictLen;
     } else {
-      // Dictionary is not read when there's no data
-      EXPECT_EQ(indices_read, 0);
+      // Dictionary is not read when there's no data.
+      EXPECT_EQ(indicesRead, 0);
     }
-    total_indices += indices_read;
+    totalIndices += indicesRead;
   }
 
-  EXPECT_EQ(total_indices, value_size);
-  for (int64_t i = 0; i < total_indices; ++i) {
-    EXPECT_LT(indices[i], dict_len);
+  EXPECT_EQ(totalIndices, valueSize);
+  for (int64_t i = 0; i < totalIndices; ++i) {
+    EXPECT_LT(indices[i], dictLen);
     EXPECT_EQ(dict[indices[i]].len, values[i].len);
     EXPECT_EQ(memcmp(dict[indices[i]].ptr, values[i].ptr, values[i].len), 0);
   }
@@ -770,68 +756,68 @@ TEST_F(TestPrimitiveReader, TestDictionaryEncodedPagesWithExposeEncoding) {
 }
 
 TEST_F(TestPrimitiveReader, TestNonDictionaryEncodedPagesWithExposeEncoding) {
-  max_def_level_ = 0;
-  max_rep_level_ = 0;
-  int64_t value_size = 100;
-  std::vector<int32_t> values(value_size, 0);
-  NodePtr type = schema::Int32("a", Repetition::REQUIRED);
-  const ColumnDescriptor descr(type, max_def_level_, max_rep_level_);
-
-  // The data page falls back to plain encoding
-  std::shared_ptr<ResizableBuffer> dummy = AllocateBuffer();
-  std::shared_ptr<DictionaryPage> dict_page =
-      std::make_shared<DictionaryPage>(dummy, 0, Encoding::PLAIN);
-  std::shared_ptr<DataPageV1> data_page = MakeDataPage<Int32Type>(
+  maxDefLevel_ = 0;
+  maxRepLevel_ = 0;
+  int64_t valueSize = 100;
+  std::vector<int32_t> values(valueSize, 0);
+  NodePtr type = schema::int32("a", Repetition::kRequired);
+  const ColumnDescriptor descr(type, maxDefLevel_, maxRepLevel_);
+
+  // The data page falls back to plain encoding.
+  std::shared_ptr<ResizableBuffer> dummy = allocateBuffer();
+  std::shared_ptr<DictionaryPage> dictPage =
+      std::make_shared<DictionaryPage>(dummy, 0, Encoding::kPlain);
+  std::shared_ptr<DataPageV1> dataPage = makeDataPage<Int32Type>(
       &descr,
       values,
-      static_cast<int>(value_size),
-      Encoding::PLAIN,
-      /*indices=*/{},
-      /*indices_size=*/0,
-      /*def_levels=*/{},
-      /*max_def_level=*/0,
-      /*rep_levels=*/{},
-      /*max_rep_level=*/0);
-  pages_.push_back(dict_page);
-  pages_.push_back(data_page);
-  InitReader(&descr);
+      static_cast<int>(valueSize),
+      Encoding::kPlain,
+      {},
+      0,
+      {},
+      0,
+      {},
+      0);
+  pages_.push_back(dictPage);
+  pages_.push_back(dataPage);
+  initReader(&descr);
 
   auto reader = static_cast<ByteArrayReader*>(reader_.get());
   const ByteArray* dict = nullptr;
-  int32_t dict_len = 0;
-  int64_t indices_read = 0;
-  auto indices = std::make_unique<int32_t[]>(value_size);
-  // Dictionary cannot be exposed when it's not fully dictionary encoded
+  int32_t dictLen = 0;
+  int64_t indicesRead = 0;
+  auto indices = std::make_unique<int32_t[]>(valueSize);
+  // Dictionary cannot be exposed when it's not fully dictionary encoded.
   EXPECT_THROW(
-      reader->ReadBatchWithDictionary(
-          value_size,
-          /*def_levels=*/nullptr,
-          /*rep_levels=*/nullptr,
+      reader->readBatchWithDictionary(
+          valueSize,
+          nullptr,
+          nullptr,
           indices.get(),
-          &indices_read,
+          &indicesRead,
           &dict,
-          &dict_len),
+          &dictLen),
       ParquetException);
   pages_.clear();
 }
 
 namespace {
 
-LevelInfo ComputeLevelInfo(const ColumnDescriptor* descr) {
-  LevelInfo level_info;
-  level_info.defLevel = descr->max_definition_level();
-  level_info.repLevel = descr->max_repetition_level();
+LevelInfo computeLevelInfo(const ColumnDescriptor* descr) {
+  LevelInfo levelInfo;
+  levelInfo.defLevel = descr->maxDefinitionLevel();
+  levelInfo.repLevel = descr->maxRepetitionLevel();
 
-  int16_t min_spaced_def_level = descr->max_definition_level();
-  const schema::Node* node = descr->schema_node().get();
-  while (node != nullptr && !node->is_repeated()) {
-    if (node->is_optional()) {
-      min_spaced_def_level--;
+  int16_t minSpacedDefLevel = descr->maxDefinitionLevel();
+  const schema::Node* Node = descr->schemaNode().get();
+  while (Node != nullptr && !Node->isRepeated()) {
+    if (Node->isOptional()) {
+      minSpacedDefLevel--;
     }
-    node = node->parent();
+    Node = Node->parent();
   }
-  level_info.repeatedAncestorDefLevel = min_spaced_def_level;
-  return level_info;
+  levelInfo.repeatedAncestorDefLevel = minSpacedDefLevel;
+  return levelInfo;
 }
 
 } // namespace
@@ -842,1277 +828,995 @@ class RecordReaderPrimitiveTypeTest
  public:
   const int32_t kNullValue = -1;
 
-  void Init(NodePtr column) {
-    NodePtr root = GroupNode::Make("root", Repetition::REQUIRED, {column});
-    schema_descriptor_.Init(root);
-    descr_ = schema_descriptor_.Column(0);
-    record_reader_ = internal::RecordReader::Make(
+  void init(NodePtr column) {
+    NodePtr root = GroupNode::make("root", Repetition::kRequired, {column});
+    schemaDescriptor_.init(root);
+    descr_ = schemaDescriptor_.column(0);
+    recordReader_ = internal::RecordReader::make(
         descr_,
-        ComputeLevelInfo(descr_),
+        computeLevelInfo(descr_),
         ::arrow::default_memory_pool(),
-        /*read_dictionary=*/false,
+        false,
         GetParam());
   }
 
-  void CheckReadValues(
-      std::vector<int32_t> expected_values,
-      std::vector<int16_t> expected_defs,
-      std::vector<int16_t> expected_reps) {
-    const auto read_values =
-        reinterpret_cast<const int32_t*>(record_reader_->values());
-    std::vector<int32_t> read_vals(
-        read_values, read_values + record_reader_->values_written());
-    ASSERT_EQ(read_vals.size(), expected_values.size());
-    for (size_t i = 0; i < expected_values.size(); ++i) {
-      if (expected_values[i] != kNullValue) {
-        ASSERT_EQ(expected_values[i], read_values[i]);
+  void checkReadValues(
+      std::vector<int32_t> expectedValues,
+      std::vector<int16_t> expectedDefs,
+      std::vector<int16_t> expectedReps) {
+    const auto readValues =
+        reinterpret_cast<const int32_t*>(recordReader_->values());
+    std::vector<int32_t> readVals(
+        readValues, readValues + recordReader_->valuesWritten());
+    ASSERT_EQ(readVals.size(), expectedValues.size());
+    for (size_t i = 0; i < expectedValues.size(); ++i) {
+      if (expectedValues[i] != kNullValue) {
+        ASSERT_EQ(expectedValues[i], readValues[i]);
       }
     }
 
-    if (!descr_->schema_node()->is_required()) {
-      std::vector<int16_t> read_defs(
-          record_reader_->def_levels(),
-          record_reader_->def_levels() + record_reader_->levels_position());
-      ASSERT_TRUE(vector_equal(expected_defs, read_defs));
+    if (!descr_->schemaNode()->isRequired()) {
+      std::vector<int16_t> readDefs(
+          recordReader_->defLevels(),
+          recordReader_->defLevels() + recordReader_->levelsPosition());
+      ASSERT_TRUE(vectorEqual(expectedDefs, readDefs));
     }
 
-    if (descr_->schema_node()->is_repeated()) {
-      std::vector<int16_t> read_reps(
-          record_reader_->rep_levels(),
-          record_reader_->rep_levels() + record_reader_->levels_position());
-      ASSERT_TRUE(vector_equal(expected_reps, read_reps));
+    if (descr_->schemaNode()->isRepeated()) {
+      std::vector<int16_t> readReps(
+          recordReader_->repLevels(),
+          recordReader_->repLevels() + recordReader_->levelsPosition());
+      ASSERT_TRUE(vectorEqual(expectedReps, readReps));
     }
   }
 
-  void CheckState(
-      int64_t values_written,
-      int64_t null_count,
-      int64_t levels_written,
-      int64_t levels_position) {
-    ASSERT_EQ(record_reader_->values_written(), values_written);
-    ASSERT_EQ(record_reader_->null_count(), null_count);
-    ASSERT_EQ(record_reader_->levels_written(), levels_written);
-    ASSERT_EQ(record_reader_->levels_position(), levels_position);
+  void checkState(
+      int64_t valuesWritten,
+      int64_t nullCount,
+      int64_t levelsWritten,
+      int64_t levelsPosition) {
+    ASSERT_EQ(recordReader_->valuesWritten(), valuesWritten);
+    ASSERT_EQ(recordReader_->nullCount(), nullCount);
+    ASSERT_EQ(recordReader_->levelsWritten(), levelsWritten);
+    ASSERT_EQ(recordReader_->levelsPosition(), levelsPosition);
   }
 
  protected:
-  SchemaDescriptor schema_descriptor_;
-  std::shared_ptr<internal::RecordReader> record_reader_;
+  SchemaDescriptor schemaDescriptor_;
+  std::shared_ptr<internal::RecordReader> recordReader_;
   const ColumnDescriptor* descr_;
 };
 
-// Tests reading a required field. The expected results are the same for
-// reading dense and spaced.
+// Tests reading a required field. The expected results are the same for.
+// Reading dense and spaced.
 TEST_P(RecordReaderPrimitiveTypeTest, ReadRequired) {
-  Init(schema::Int32("b", Repetition::REQUIRED));
+  init(schema::int32("b", Repetition::kRequired));
 
   // Records look like: {10, 20, 20, 30, 30, 30}
   std::vector<std::shared_ptr<Page>> pages;
   std::vector<int32_t> values = {10, 20, 20, 30, 30, 30};
-  std::vector<int16_t> def_levels = {};
-  std::vector<int16_t> rep_levels = {};
+  std::vector<int16_t> defLevels = {};
+  std::vector<int16_t> repLevels = {};
 
-  std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
+  std::shared_ptr<DataPageV1> page = makeDataPage<Int32Type>(
       descr_,
       values,
-      /*num_vals=*/static_cast<int>(def_levels.size()),
-      Encoding::PLAIN,
-      /*indices=*/{},
-      /*indices_size=*/0,
-      def_levels,
-      descr_->max_definition_level(),
-      rep_levels,
-      descr_->max_repetition_level());
+      static_cast<int>(defLevels.size()),
+      Encoding::kPlain,
+      {},
+      0,
+      defLevels,
+      descr_->maxDefinitionLevel(),
+      repLevels,
+      descr_->maxRepetitionLevel());
   pages.push_back(std::move(page));
   auto pager = std::make_unique<MockPageReader>(pages);
-  record_reader_->SetPageReader(std::move(pager));
-
-  // Read [10]
-  int64_t records_read = record_reader_->ReadRecords(/*num_records=*/1);
-  ASSERT_EQ(records_read, 1);
-  CheckState(
-      /*values_written=*/1,
-      /*null_count=*/0,
-      /*levels_written=*/0,
-      /*levels_position=*/0);
-  CheckReadValues(
-      /*expected_values=*/{10},
-      /*expected_defs=*/{},
-      /*expected_reps=*/{});
-  record_reader_->Reset();
-  CheckState(
-      /*values_written=*/0,
-      /*null_count=*/0,
-      /*levels_written=*/0,
-      /*levels_position=*/0);
-
-  // Read 20, 20, 30, 30, 30
-  records_read = record_reader_->ReadRecords(/*num_records=*/10);
-  ASSERT_EQ(records_read, 5);
-  CheckState(
-      /*values_written=*/5,
-      /*null_count=*/0,
-      /*levels_written=*/0,
-      /*levels_position=*/0);
-  CheckReadValues(
-      /*expected_values=*/{20, 20, 30, 30, 30},
-      /*expected_defs=*/{},
-      /*expected_reps=*/{});
-  record_reader_->Reset();
-  CheckState(
-      /*values_written=*/0,
-      /*null_count=*/0,
-      /*levels_written=*/0,
-      /*levels_position=*/0);
+  recordReader_->setPageReader(std::move(pager));
+
+  // Read [10].
+  int64_t recordsRead = recordReader_->readRecords(1);
+  ASSERT_EQ(recordsRead, 1);
+  checkState(1, 0, 0, 0);
+  checkReadValues({10}, {}, {});
+  recordReader_->reset();
+  checkState(0, 0, 0, 0);
+
+  // Read 20, 20, 30, 30, 30.
+  recordsRead = recordReader_->readRecords(10);
+  ASSERT_EQ(recordsRead, 5);
+  checkState(5, 0, 0, 0);
+  checkReadValues({20, 20, 30, 30, 30}, {}, {});
+  recordReader_->reset();
+  checkState(0, 0, 0, 0);
 }
 
 // Tests reading an optional field.
-// Use a max definition field > 1 to test both cases where parent is present or
-// parent is missing.
+// Use a max definition field > 1 to test both cases where parent is present or.
+// Parent is missing.
 TEST_P(RecordReaderPrimitiveTypeTest, ReadOptional) {
-  NodePtr column = GroupNode::Make(
+  NodePtr column = GroupNode::make(
       "a",
-      Repetition::OPTIONAL,
-      {PrimitiveNode::Make(
-          "element", Repetition::OPTIONAL, ParquetType::INT32)});
-  Init(column);
+      Repetition::kOptional,
+      {PrimitiveNode::make(
+          "element", Repetition::kOptional, ParquetType::kInt32)});
+  init(column);
 
   // Records look like: {10, null, 20, 20, null, 30, 30, 30, null}
   std::vector<std::shared_ptr<Page>> pages;
   std::vector<int32_t> values = {10, 20, 20, 30, 30, 30};
-  std::vector<int16_t> def_levels = {2, 0, 2, 2, 1, 2, 2, 2, 0};
+  std::vector<int16_t> defLevels = {2, 0, 2, 2, 1, 2, 2, 2, 0};
 
-  std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
+  std::shared_ptr<DataPageV1> page = makeDataPage<Int32Type>(
       descr_,
       values,
-      /*num_vals=*/static_cast<int>(def_levels.size()),
-      Encoding::PLAIN,
-      /*indices=*/{},
-      /*indices_size=*/0,
-      def_levels,
-      descr_->max_definition_level(),
-      /*rep_levels=*/{},
-      descr_->max_repetition_level());
+      static_cast<int>(defLevels.size()),
+      Encoding::kPlain,
+      {},
+      0,
+      defLevels,
+      descr_->maxDefinitionLevel(),
+      {},
+      descr_->maxRepetitionLevel());
   pages.push_back(std::move(page));
   auto pager = std::make_unique<MockPageReader>(pages);
-  record_reader_->SetPageReader(std::move(pager));
-
-  // Read 10, null
-  int64_t records_read = record_reader_->ReadRecords(/*num_records=*/2);
-  ASSERT_EQ(records_read, 2);
-  if (GetParam() == /*read_dense_for_nullable=*/true) {
-    CheckState(
-        /*values_written=*/1,
-        /*null_count=*/0,
-        /*levels_written=*/9,
-        /*levels_position=*/2);
-    CheckReadValues(
-        /*expected_values=*/{10},
-        /*expected_defs=*/{2, 0},
-        /*expected_reps=*/{});
+  recordReader_->setPageReader(std::move(pager));
+
+  // Read 10, null.
+  int64_t recordsRead = recordReader_->readRecords(2);
+  ASSERT_EQ(recordsRead, 2);
+  if (GetParam() == true) {
+    checkState(1, 0, 9, 2);
+    checkReadValues({10}, {2, 0}, {});
   } else {
-    CheckState(
-        /*values_written=*/2,
-        /*null_count=*/1,
-        /*levels_written=*/9,
-        /*levels_position=*/2);
-    CheckReadValues(
-        /*expected_values=*/{10, kNullValue},
-        /*expected_defs=*/{2, 0},
-        /*expected_reps=*/{});
+    checkState(2, 1, 9, 2);
+    checkReadValues({10, kNullValue}, {2, 0}, {});
   }
-  record_reader_->Reset();
-  CheckState(
-      /*values_written=*/0,
-      /*null_count=*/0,
-      /*levels_written=*/7,
-      /*levels_position=*/0);
-
-  // Read 20, 20, null (parent present), 30, 30, 30
-  records_read = record_reader_->ReadRecords(/*num_records=*/6);
-  ASSERT_EQ(records_read, 6);
-  if (GetParam() == /*read_dense_for_nullable=*/true) {
-    CheckState(
-        /*values_written=*/5,
-        /*null_count=*/0,
-        /*levels_written=*/7,
-        /*levels_position=*/6);
-    CheckReadValues(
-        /*expected_values=*/{20, 20, 30, 30, 30},
-        /*expected_defs=*/{2, 2, 1, 2, 2, 2},
-        /*expected_reps=*/{});
+  recordReader_->reset();
+  checkState(0, 0, 7, 0);
+
+  // Read 20, 20, null (parent present), 30, 30, 30.
+  recordsRead = recordReader_->readRecords(6);
+  ASSERT_EQ(recordsRead, 6);
+  if (GetParam() == true) {
+    checkState(5, 0, 7, 6);
+    checkReadValues({20, 20, 30, 30, 30}, {2, 2, 1, 2, 2, 2}, {});
   } else {
-    CheckState(
-        /*values_written=*/6,
-        /*null_count=*/1,
-        /*levels_written=*/7,
-        /*levels_position=*/6);
-    CheckReadValues(
-        /*expected_values=*/{20, 20, kNullValue, 30, 30, 30},
-        /*expected_defs=*/{2, 2, 1, 2, 2, 2},
-        /*expected_reps=*/{});
+    checkState(6, 1, 7, 6);
+    checkReadValues({20, 20, kNullValue, 30, 30, 30}, {2, 2, 1, 2, 2, 2}, {});
   }
-  record_reader_->Reset();
-  CheckState(
-      /*values_written=*/0,
-      /*null_count=*/0,
-      /*levels_written=*/1,
-      /*levels_position=*/0);
+  recordReader_->reset();
+  checkState(0, 0, 1, 0);
 
   // Read the last null value and read past the end.
-  records_read = record_reader_->ReadRecords(/*num_records=*/3);
-  ASSERT_EQ(records_read, 1);
-  if (GetParam() == /*read_dense_for_nullable=*/true) {
-    CheckState(
-        /*values_written=*/0,
-        /*null_count=*/0,
-        /*levels_written=*/1,
-        /*levels_position=*/1);
-    CheckReadValues(
-        /*expected_values=*/{},
-        /*expected_defs=*/{0},
-        /*expected_reps=*/{});
+  recordsRead = recordReader_->readRecords(3);
+  ASSERT_EQ(recordsRead, 1);
+  if (GetParam() == true) {
+    checkState(0, 0, 1, 1);
+    checkReadValues({}, {0}, {});
   } else {
-    CheckState(
-        /*values_written=*/1,
-        /*null_count=*/1,
-        /*levels_written=*/1,
-        /*levels_position=*/1);
-    CheckReadValues(
-        /*expected_values=*/{kNullValue},
-        /*expected_defs=*/{0},
-        /*expected_reps=*/{});
+    checkState(1, 1, 1, 1);
+    checkReadValues({kNullValue}, {0}, {});
   }
-  record_reader_->Reset();
-  CheckState(
-      /*values_written=*/0,
-      /*null_count=*/0,
-      /*levels_written=*/0,
-      /*levels_position=*/0);
+  recordReader_->reset();
+  checkState(0, 0, 0, 0);
 }
 
-// Tests reading a required repeated field. The results are the same for reading
-// dense or spaced.
+// Tests reading a required repeated field. The results are the same for
+// reading. Dense or spaced.
 TEST_P(RecordReaderPrimitiveTypeTest, ReadRequiredRepeated) {
-  NodePtr column = GroupNode::Make(
+  NodePtr column = GroupNode::make(
       "p",
-      Repetition::REQUIRED,
-      {GroupNode::Make(
+      Repetition::kRequired,
+      {GroupNode::make(
           "list",
-          Repetition::REPEATED,
-          {PrimitiveNode::Make(
-              "element", Repetition::REQUIRED, ParquetType::INT32)})});
-  Init(column);
+          Repetition::kRepeated,
+          {PrimitiveNode::make(
+              "element", Repetition::kRequired, ParquetType::kInt32)})});
+  init(column);
 
   // Records look like: {[10], [20, 20], [30, 30, 30]}
   std::vector<std::shared_ptr<Page>> pages;
   std::vector<int32_t> values = {10, 20, 20, 30, 30, 30};
-  std::vector<int16_t> def_levels = {1, 1, 1, 1, 1, 1};
-  std::vector<int16_t> rep_levels = {0, 0, 1, 0, 1, 1};
+  std::vector<int16_t> defLevels = {1, 1, 1, 1, 1, 1};
+  std::vector<int16_t> repLevels = {0, 0, 1, 0, 1, 1};
 
-  std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
+  std::shared_ptr<DataPageV1> page = makeDataPage<Int32Type>(
       descr_,
       values,
-      /*num_vals=*/static_cast<int>(def_levels.size()),
-      Encoding::PLAIN,
-      /*indices=*/{},
-      /*indices_size=*/0,
-      def_levels,
-      descr_->max_definition_level(),
-      rep_levels,
-      descr_->max_repetition_level());
+      static_cast<int>(defLevels.size()),
+      Encoding::kPlain,
+      {},
+      0,
+      defLevels,
+      descr_->maxDefinitionLevel(),
+      repLevels,
+      descr_->maxRepetitionLevel());
   pages.push_back(std::move(page));
   auto pager = std::make_unique<MockPageReader>(pages);
-  record_reader_->SetPageReader(std::move(pager));
-
-  // Read [10]
-  int64_t records_read = record_reader_->ReadRecords(/*num_records=*/1);
-  ASSERT_EQ(records_read, 1);
-  CheckState(
-      /*values_written=*/1,
-      /*null_count=*/0,
-      /*levels_written=*/6,
-      /*levels_position=*/1);
-  CheckReadValues(
-      /*expected_values=*/{10},
-      /*expected_defs=*/{1},
-      /*expected_reps=*/{0});
-  record_reader_->Reset();
-  CheckState(
-      /*values_written=*/0,
-      /*null_count=*/0,
-      /*levels_written=*/5,
-      /*levels_position=*/0);
-
-  // Read [20, 20], [30, 30, 30]
-  records_read = record_reader_->ReadRecords(/*num_records=*/3);
-  ASSERT_EQ(records_read, 2);
-  CheckState(
-      /*values_written=*/5,
-      /*null_count=*/0,
-      /*levels_written=*/5,
-      /*levels_position=*/5);
-  CheckReadValues(
-      /*expected_values=*/{20, 20, 30, 30, 30},
-      /*expected_defs=*/{1, 1, 1, 1, 1},
-      /*expected_reps=*/{0, 1, 0, 1, 1});
-  record_reader_->Reset();
-  CheckState(
-      /*values_written=*/0,
-      /*null_count=*/0,
-      /*levels_written=*/0,
-      /*levels_position=*/0);
+  recordReader_->setPageReader(std::move(pager));
+
+  // Read [10].
+  int64_t recordsRead = recordReader_->readRecords(1);
+  ASSERT_EQ(recordsRead, 1);
+  checkState(1, 0, 6, 1);
+  checkReadValues({10}, {1}, {0});
+  recordReader_->reset();
+  checkState(0, 0, 5, 0);
+
+  // Read [20, 20], [30, 30, 30].
+  recordsRead = recordReader_->readRecords(3);
+  ASSERT_EQ(recordsRead, 2);
+  checkState(5, 0, 5, 5);
+  checkReadValues({20, 20, 30, 30, 30}, {1, 1, 1, 1, 1}, {0, 1, 0, 1, 1});
+  recordReader_->reset();
+  checkState(0, 0, 0, 0);
 }
 
-// Tests reading a nullable repeated field. Tests reading null values at
-// differnet levels and reading an empty list.
+// Tests reading a nullable repeated field. Tests reading null values at.
+// Differnet levels and reading an empty list.
 TEST_P(RecordReaderPrimitiveTypeTest, ReadNullableRepeated) {
-  NodePtr column = GroupNode::Make(
+  NodePtr column = GroupNode::make(
       "p",
-      Repetition::OPTIONAL,
-      {GroupNode::Make(
+      Repetition::kOptional,
+      {GroupNode::make(
           "list",
-          Repetition::REPEATED,
-          {PrimitiveNode::Make(
-              "element", Repetition::OPTIONAL, ParquetType::INT32)})});
-  Init(column);
+          Repetition::kRepeated,
+          {PrimitiveNode::make(
+              "element", Repetition::kOptional, ParquetType::kInt32)})});
+  init(column);
 
   // Records look like: {[10], null, [20, 20], [], [30, 30, null, 30]}
-  // Some explanation regarding the behavior. When reading spaced, for an empty
-  // list or for a top-level null, we do not leave a space and we do not count
-  // it towards null_count.  For a leaf-level null, we leave a space for it and
-  // we count it towards null_count. When reading dense, null_count is always 0,
-  // and we do not leave any space for values.
+  // Some explanation regarding the behavior. When reading spaced, for an empty.
+  // List or for a top-level null, we do not leave a space and we do not count.
+  // It towards null_count.  For a leaf-level null, we leave a space for it and.
+  // We count it towards null_count. When reading dense, null_count is always
+  // 0,. And we do not leave any space for values.
   std::vector<std::shared_ptr<Page>> pages;
   std::vector<int32_t> values = {10, 20, 20, 30, 30, 30};
-  std::vector<int16_t> def_levels = {3, 0, 3, 3, 1, 3, 3, 2, 3};
-  std::vector<int16_t> rep_levels = {0, 0, 0, 1, 0, 0, 1, 1, 1};
+  std::vector<int16_t> defLevels = {3, 0, 3, 3, 1, 3, 3, 2, 3};
+  std::vector<int16_t> repLevels = {0, 0, 0, 1, 0, 0, 1, 1, 1};
 
-  std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
+  std::shared_ptr<DataPageV1> page = makeDataPage<Int32Type>(
       descr_,
       values,
-      /*num_vals=*/static_cast<int>(def_levels.size()),
-      Encoding::PLAIN,
-      /*indices=*/{},
-      /*indices_size=*/0,
-      def_levels,
-      descr_->max_definition_level(),
-      rep_levels,
-      descr_->max_repetition_level());
+      static_cast<int>(defLevels.size()),
+      Encoding::kPlain,
+      {},
+      0,
+      defLevels,
+      descr_->maxDefinitionLevel(),
+      repLevels,
+      descr_->maxRepetitionLevel());
   pages.push_back(std::move(page));
   auto pager = std::make_unique<MockPageReader>(pages);
-  record_reader_->SetPageReader(std::move(pager));
+  recordReader_->setPageReader(std::move(pager));
 
   // Test reading 0 records.
-  int64_t records_read = record_reader_->ReadRecords(/*num_records=*/0);
-  ASSERT_EQ(records_read, 0);
+  int64_t recordsRead = recordReader_->readRecords(0);
+  ASSERT_EQ(recordsRead, 0);
 
   // Test the descr() accessor.
-  ASSERT_EQ(record_reader_->descr()->max_definition_level(), 3);
+  ASSERT_EQ(recordReader_->descr()->maxDefinitionLevel(), 3);
 
-  // Read [10], null
+  // Read [10], null.
   // We do not read this null for both reading dense and spaced.
-  records_read = record_reader_->ReadRecords(/*num_records=*/2);
-  ASSERT_EQ(records_read, 2);
-  if (GetParam() == /*read_dense_for_nullable=*/true) {
-    CheckState(
-        /*values_written=*/1,
-        /*null_count=*/0,
-        /*levels_written=*/9,
-        /*levels_position=*/2);
-    CheckReadValues(
-        /*expected_values=*/{10},
-        /*expected_defs=*/{3, 0},
-        /*expected_reps=*/{0, 0});
+  recordsRead = recordReader_->readRecords(2);
+  ASSERT_EQ(recordsRead, 2);
+  if (GetParam() == true) {
+    checkState(1, 0, 9, 2);
+    checkReadValues({10}, {3, 0}, {0, 0});
   } else {
-    CheckState(
-        /*values_written=*/1,
-        /*null_count=*/0,
-        /*levels_written=*/9,
-        /*levels_position=*/2);
-    CheckReadValues(
-        /*expected_values=*/{10},
-        /*expected_defs=*/{3, 0},
-        /*expected_reps=*/{0, 0});
+    checkState(1, 0, 9, 2);
+    checkReadValues({10}, {3, 0}, {0, 0});
   }
-  record_reader_->Reset();
-  CheckState(
-      /*values_written=*/0,
-      /*null_count=*/0,
-      /*levels_written=*/7,
-      /*levels_position=*/0);
-
-  // Read [20, 20], []
-  // We do not read any value for this, it will be counted towards null count
-  // when reading spaced.
-  records_read = record_reader_->ReadRecords(/*num_records=*/2);
-  ASSERT_EQ(records_read, 2);
-  if (GetParam() == /*read_dense_for_nullable=*/true) {
-    CheckState(
-        /*values_written=*/2,
-        /*null_count=*/0,
-        /*levels_written=*/7,
-        /*levels_position=*/3);
-    CheckReadValues(
-        /*expected_values=*/{20, 20},
-        /*expected_defs=*/{3, 3, 1},
-        /*expected_reps=*/{0, 1, 0});
+  recordReader_->reset();
+  checkState(0, 0, 7, 0);
+
+  // Read [20, 20], [].
+  // We do not read any value for this, it will be counted towards null count.
+  // When reading spaced.
+  recordsRead = recordReader_->readRecords(2);
+  ASSERT_EQ(recordsRead, 2);
+  if (GetParam() == true) {
+    checkState(2, 0, 7, 3);
+    checkReadValues({20, 20}, {3, 3, 1}, {0, 1, 0});
   } else {
-    CheckState(
-        /*values_written=*/2,
-        /*null_count=*/0,
-        /*levels_written=*/7,
-        /*levels_position=*/3);
-    CheckReadValues(
-        /*expected_values=*/{20, 20},
-        /*expected_defs=*/{3, 3, 1},
-        /*expected_reps=*/{0, 1, 0});
+    checkState(2, 0, 7, 3);
+    checkReadValues({20, 20}, {3, 3, 1}, {0, 1, 0});
   }
-  record_reader_->Reset();
-  CheckState(
-      /*values_written=*/0,
-      /*null_count=*/0,
-      /*levels_written=*/4,
-      /*levels_position=*/0);
+  recordReader_->reset();
+  checkState(0, 0, 4, 0);
 
   // Test reading 0 records.
-  records_read = record_reader_->ReadRecords(/*num_records=*/0);
-  ASSERT_EQ(records_read, 0);
+  recordsRead = recordReader_->readRecords(0);
+  ASSERT_EQ(recordsRead, 0);
 
   // Read the last record.
-  records_read = record_reader_->ReadRecords(/*num_records=*/1);
-  ASSERT_EQ(records_read, 1);
-  if (GetParam() == /*read_dense_for_nullable=*/true) {
-    CheckState(
-        /*values_written=*/3,
-        /*null_count=*/0,
-        /*levels_written=*/4,
-        /*levels_position=*/4);
-    CheckReadValues(
-        /*expected_values=*/{30, 30, 30},
-        /*expected_defs=*/{3, 3, 2, 3},
-        /*expected_reps=*/{0, 1, 1, 1});
+  recordsRead = recordReader_->readRecords(1);
+  ASSERT_EQ(recordsRead, 1);
+  if (GetParam() == true) {
+    checkState(3, 0, 4, 4);
+    checkReadValues({30, 30, 30}, {3, 3, 2, 3}, {0, 1, 1, 1});
   } else {
-    CheckState(
-        /*values_written=*/4,
-        /*null_count=*/1,
-        /*levels_written=*/4,
-        /*levels_position=*/4);
-    CheckReadValues(
-        /*expected_values=*/{30, 30, kNullValue, 30},
-        /*expected_defs=*/{3, 3, 2, 3},
-        /*expected_reps=*/{0, 1, 1, 1});
+    checkState(4, 1, 4, 4);
+    checkReadValues({30, 30, kNullValue, 30}, {3, 3, 2, 3}, {0, 1, 1, 1});
   }
-  record_reader_->Reset();
-  CheckState(
-      /*values_written=*/0,
-      /*null_count=*/0,
-      /*levels_written=*/0,
-      /*levels_position=*/0);
+  recordReader_->reset();
+  checkState(0, 0, 0, 0);
 }
 
 // Test that we can skip required top level field.
 TEST_P(RecordReaderPrimitiveTypeTest, SkipRequiredTopLevel) {
-  Init(schema::Int32("b", Repetition::REQUIRED));
+  init(schema::int32("b", Repetition::kRequired));
 
   std::vector<std::shared_ptr<Page>> pages;
   std::vector<int32_t> values = {10, 20, 20, 30, 30, 30};
-  std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
+  std::shared_ptr<DataPageV1> page = makeDataPage<Int32Type>(
       descr_,
       values,
-      /*num_vals=*/static_cast<int>(values.size()),
-      Encoding::PLAIN,
-      /*indices=*/{},
-      /*indices_size=*/0,
-      /*def_levels=*/{},
-      descr_->max_definition_level(),
-      /*rep_levels=*/{},
-      descr_->max_repetition_level());
+      static_cast<int>(values.size()),
+      Encoding::kPlain,
+      {},
+      0,
+      {},
+      descr_->maxDefinitionLevel(),
+      {},
+      descr_->maxRepetitionLevel());
   pages.push_back(std::move(page));
   auto pager = std::make_unique<MockPageReader>(pages);
-  record_reader_->SetPageReader(std::move(pager));
-
-  int64_t records_skipped = record_reader_->SkipRecords(/*num_records=*/3);
-  ASSERT_EQ(records_skipped, 3);
-  CheckState(
-      /*values_written=*/0,
-      /*null_count=*/0,
-      /*levels_written=*/0,
-      /*levels_position=*/0);
-
-  int64_t records_read = record_reader_->ReadRecords(/*num_records=*/2);
-  ASSERT_EQ(records_read, 2);
-  CheckState(
-      /*values_written=*/2,
-      /*null_count=*/0,
-      /*levels_written=*/0,
-      /*levels_position=*/0);
-  CheckReadValues(
-      /*expected_values=*/{30, 30},
-      /*expected_defs=*/{},
-      /*expected_reps=*/{});
-  record_reader_->Reset();
-  CheckState(
-      /*values_written=*/0,
-      /*null_count=*/0,
-      /*levels_written=*/0,
-      /*levels_position=*/0);
+  recordReader_->setPageReader(std::move(pager));
+
+  int64_t recordsSkipped = recordReader_->skipRecords(3);
+  ASSERT_EQ(recordsSkipped, 3);
+  checkState(0, 0, 0, 0);
+
+  int64_t recordsRead = recordReader_->readRecords(2);
+  ASSERT_EQ(recordsRead, 2);
+  checkState(2, 0, 0, 0);
+  checkReadValues({30, 30}, {}, {});
+  recordReader_->reset();
+  checkState(0, 0, 0, 0);
 }
 
 // Skip an optional field. Intentionally included some null values.
 TEST_P(RecordReaderPrimitiveTypeTest, SkipOptional) {
-  Init(schema::Int32("b", Repetition::OPTIONAL));
+  init(schema::int32("b", Repetition::kOptional));
 
   // Records look like {null, 10, 20, 30, null, 40, 50, 60}
   std::vector<std::shared_ptr<Page>> pages;
   std::vector<int32_t> values = {10, 20, 30, 40, 50, 60};
-  std::vector<int16_t> def_levels = {0, 1, 1, 0, 1, 1, 1, 1};
+  std::vector<int16_t> defLevels = {0, 1, 1, 0, 1, 1, 1, 1};
 
-  std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
+  std::shared_ptr<DataPageV1> page = makeDataPage<Int32Type>(
       descr_,
       values,
-      /*num_vals=*/static_cast<int>(values.size()),
-      Encoding::PLAIN,
-      /*indices=*/{},
-      /*indices_size=*/0,
-      def_levels,
-      descr_->max_definition_level(),
-      /*rep_levels=*/{},
-      descr_->max_repetition_level());
+      static_cast<int>(values.size()),
+      Encoding::kPlain,
+      {},
+      0,
+      defLevels,
+      descr_->maxDefinitionLevel(),
+      {},
+      descr_->maxRepetitionLevel());
   pages.push_back(std::move(page));
   auto pager = std::make_unique<MockPageReader>(pages);
-  record_reader_->SetPageReader(std::move(pager));
+  recordReader_->setPageReader(std::move(pager));
 
   {
     // Skip {null, 10}
     // This also tests when we start with a Skip.
-    int64_t records_skipped = record_reader_->SkipRecords(/*num_records=*/2);
-    ASSERT_EQ(records_skipped, 2);
-    CheckState(
-        /*values_written=*/0,
-        /*null_count=*/0,
-        /*levels_written=*/0,
-        /*levels_position=*/0);
+    int64_t recordsSkipped = recordReader_->skipRecords(2);
+    ASSERT_EQ(recordsSkipped, 2);
+    checkState(0, 0, 0, 0);
   }
 
   {
     // Read 3 records: {20, null, 30}
-    int64_t records_read = record_reader_->ReadRecords(/*num_records=*/3);
-
-    ASSERT_EQ(records_read, 3);
-    if (GetParam() == /*read_dense_for_nullable=*/true) {
-      // We had skipped 2 of the levels above. So there is only 6 left in total
-      // to read, and we read 3 of them here.
-      CheckState(
-          /*values_written=*/2,
-          /*null_count=*/0,
-          /*levels_written=*/6,
-          /*levels_position=*/3);
-      CheckReadValues(
-          /*expected_values=*/{20, 30},
-          /*expected_defs=*/{1, 0, 1},
-          /*expected_reps=*/{});
+    int64_t recordsRead = recordReader_->readRecords(3);
+
+    ASSERT_EQ(recordsRead, 3);
+    if (GetParam() == true) {
+      // We had skipped 2 of the levels above. So there is only 6 left in total.
+      // To read, and we read 3 of them here.
+      checkState(2, 0, 6, 3);
+      checkReadValues({20, 30}, {1, 0, 1}, {});
     } else {
-      CheckState(
-          /*values_written=*/3,
-          /*null_count=*/1,
-          /*levels_written=*/6,
-          /*levels_position=*/3);
-      CheckReadValues(
-          /*expected_values=*/{20, kNullValue, 30},
-          /*expected_defs=*/{1, 0, 1},
-          /*expected_reps=*/{});
+      checkState(3, 1, 6, 3);
+      checkReadValues({20, kNullValue, 30}, {1, 0, 1}, {});
     }
 
-    record_reader_->Reset();
+    recordReader_->reset();
   }
 
   {
     // Skip {40, 50}.
-    int64_t records_skipped = record_reader_->SkipRecords(/*num_records=*/2);
-    ASSERT_EQ(records_skipped, 2);
-    CheckState(
-        /*values_written=*/0,
-        /*null_count=*/0,
-        /*levels_written=*/1,
-        /*levels_position=*/0);
-    CheckReadValues(
-        /*expected_values=*/{},
-        /*expected_defs=*/{},
-        /*expected_reps=*/{});
+    int64_t recordsSkipped = recordReader_->skipRecords(2);
+    ASSERT_EQ(recordsSkipped, 2);
+    checkState(0, 0, 1, 0);
+    checkReadValues({}, {}, {});
     // Try reset after a Skip.
-    record_reader_->Reset();
-    CheckState(
-        /*values_written=*/0,
-        /*null_count=*/0,
-        /*levels_written=*/1,
-        /*levels_position=*/0);
+    recordReader_->reset();
+    checkState(0, 0, 1, 0);
   }
 
   {
     // Read to the end of the column. Read {60}
-    // This test checks that ReadAndThrowAwayValues works, since if it
-    // does not we would read the wrong values.
-    int64_t records_read = record_reader_->ReadRecords(/*num_records=*/1);
-
-    ASSERT_EQ(records_read, 1);
-    CheckState(
-        /*values_written=*/1,
-        /*null_count=*/0,
-        /*levels_written=*/1,
-        /*levels_position=*/1);
-    CheckReadValues(
-        /*expected_values=*/{60},
-        /*expected_defs=*/{1},
-        /*expected_reps=*/{});
+    // This test checks that ReadAndThrowAwayValues works, since if it.
+    // Does not we would read the wrong values.
+    int64_t recordsRead = recordReader_->readRecords(1);
+
+    ASSERT_EQ(recordsRead, 1);
+    checkState(1, 0, 1, 1);
+    checkReadValues({60}, {1}, {});
   }
 
   // We have exhausted all the records.
-  ASSERT_EQ(record_reader_->ReadRecords(/*num_records=*/3), 0);
-  ASSERT_EQ(record_reader_->SkipRecords(/*num_records=*/3), 0);
+  ASSERT_EQ(recordReader_->readRecords(3), 0);
+  ASSERT_EQ(recordReader_->skipRecords(3), 0);
 }
 
 // Test skipping for repeated fields.
 TEST_P(RecordReaderPrimitiveTypeTest, SkipRepeated) {
-  Init(schema::Int32("b", Repetition::REPEATED));
+  init(schema::int32("b", Repetition::kRepeated));
 
   // Records look like {null, [20, 20, 20], null, [30, 30], [40]}
   std::vector<std::shared_ptr<Page>> pages;
   std::vector<int32_t> values = {20, 20, 20, 30, 30, 40};
-  std::vector<int16_t> def_levels = {0, 1, 1, 1, 0, 1, 1, 1};
-  std::vector<int16_t> rep_levels = {0, 0, 1, 1, 0, 0, 1, 0};
+  std::vector<int16_t> defLevels = {0, 1, 1, 1, 0, 1, 1, 1};
+  std::vector<int16_t> repLevels = {0, 0, 1, 1, 0, 0, 1, 0};
 
-  std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
+  std::shared_ptr<DataPageV1> page = makeDataPage<Int32Type>(
       descr_,
       values,
-      /*num_vals=*/static_cast<int>(values.size()),
-      Encoding::PLAIN,
-      /*indices=*/{},
-      /*indices_size=*/0,
-      def_levels,
-      descr_->max_definition_level(),
-      rep_levels,
-      descr_->max_repetition_level());
+      static_cast<int>(values.size()),
+      Encoding::kPlain,
+      {},
+      0,
+      defLevels,
+      descr_->maxDefinitionLevel(),
+      repLevels,
+      descr_->maxRepetitionLevel());
   pages.push_back(std::move(page));
   auto pager = std::make_unique<MockPageReader>(pages);
-  record_reader_->SetPageReader(std::move(pager));
+  recordReader_->setPageReader(std::move(pager));
 
   {
     // Skip 0 records.
-    int64_t records_skipped = record_reader_->SkipRecords(/*num_records=*/0);
-    ASSERT_EQ(records_skipped, 0);
+    int64_t recordsSkipped = recordReader_->skipRecords(0);
+    ASSERT_EQ(recordsSkipped, 0);
   }
 
   {
     // This should skip the first null record.
-    int64_t records_skipped = record_reader_->SkipRecords(/*num_records=*/1);
-    ASSERT_EQ(records_skipped, 1);
-    ASSERT_EQ(record_reader_->values_written(), 0);
-    ASSERT_EQ(record_reader_->null_count(), 0);
-    // For repeated fields, we need to read the levels to find the record
-    // boundaries and skip. So some levels are read, however, the skipped
+    int64_t recordsSkipped = recordReader_->skipRecords(1);
+    ASSERT_EQ(recordsSkipped, 1);
+    ASSERT_EQ(recordReader_->valuesWritten(), 0);
+    ASSERT_EQ(recordReader_->nullCount(), 0);
+    // For repeated fields, we need to read the levels to find the record.
+    // Boundaries and skip. So some levels are read, however, the skipped.
     // level should not be there after the skip. That's why levels_position()
-    // is 0.
-    CheckState(
-        /*values_written=*/0,
-        /*null_count=*/0,
-        /*levels_written=*/7,
-        /*levels_position=*/0);
-    CheckReadValues(
-        /*expected_values=*/{},
-        /*expected_defs=*/{},
-        /*expected_reps=*/{});
+    // Is 0.
+    checkState(0, 0, 7, 0);
+    checkReadValues({}, {}, {});
   }
 
   {
-    // Read [20, 20, 20]
-    int64_t records_read = record_reader_->ReadRecords(/*num_records=*/1);
-    ASSERT_EQ(records_read, 1);
-    CheckState(
-        /*values_written=*/3,
-        /*null_count=*/0,
-        /*levels_written=*/7,
-        /*levels_position=*/3);
-    CheckReadValues(
-        /*expected_values=*/{20, 20, 20},
-        /*expected_defs=*/{1, 1, 1},
-        /*expected_reps=*/{0, 1, 1});
+    // Read [20, 20, 20].
+    int64_t recordsRead = recordReader_->readRecords(1);
+    ASSERT_EQ(recordsRead, 1);
+    checkState(3, 0, 7, 3);
+    checkReadValues({20, 20, 20}, {1, 1, 1}, {0, 1, 1});
   }
 
   {
     // Skip 0 records.
-    int64_t records_skipped = record_reader_->SkipRecords(/*num_records=*/0);
-    ASSERT_EQ(records_skipped, 0);
+    int64_t recordsSkipped = recordReader_->skipRecords(0);
+    ASSERT_EQ(recordsSkipped, 0);
   }
 
   {
-    // Skip the null record and also skip [30, 30]
-    int64_t records_skipped = record_reader_->SkipRecords(/*num_records=*/2);
-    ASSERT_EQ(records_skipped, 2);
+    // Skip the null record and also skip [30, 30].
+    int64_t recordsSkipped = recordReader_->skipRecords(2);
+    ASSERT_EQ(recordsSkipped, 2);
     // We remove the skipped levels from the buffer.
-    CheckState(
-        /*values_written=*/3,
-        /*null_count=*/0,
-        /*levels_written=*/4,
-        /*levels_position=*/3);
-    CheckReadValues(
-        /*expected_values=*/{20, 20, 20},
-        /*expected_defs=*/{1, 1, 1},
-        /*expected_reps=*/{0, 1, 1});
+    checkState(3, 0, 4, 3);
+    checkReadValues({20, 20, 20}, {1, 1, 1}, {0, 1, 1});
   }
 
   {
-    // Read [40]
-    int64_t records_read = record_reader_->ReadRecords(/*num_records=*/1);
-    ASSERT_EQ(records_read, 1);
-    CheckState(
-        /*values_written=*/4,
-        /*null_count=*/0,
-        /*levels_written=*/4,
-        /*levels_position=*/4);
-    CheckReadValues(
-        /*expected_values=*/{20, 20, 20, 40},
-        /*expected_defs=*/{1, 1, 1, 1},
-        /*expected_reps=*/{0, 1, 1, 0});
+    // Read [40].
+    int64_t recordsRead = recordReader_->readRecords(1);
+    ASSERT_EQ(recordsRead, 1);
+    checkState(4, 0, 4, 4);
+    checkReadValues({20, 20, 20, 40}, {1, 1, 1, 1}, {0, 1, 1, 0});
   }
 }
 
-// Tests that for repeated fields, we first consume what is in the buffer
-// before reading more levels.
+// Tests that for repeated fields, we first consume what is in the buffer.
+// Before reading more levels.
 TEST_P(RecordReaderPrimitiveTypeTest, SkipRepeatedConsumeBufferFirst) {
-  Init(schema::Int32("b", Repetition::REPEATED));
+  init(schema::int32("b", Repetition::kRepeated));
 
   std::vector<std::shared_ptr<Page>> pages;
   std::vector<int32_t> values(2048, 10);
-  std::vector<int16_t> def_levels(2048, 1);
-  std::vector<int16_t> rep_levels(2048, 0);
+  std::vector<int16_t> defLevels(2048, 1);
+  std::vector<int16_t> repLevels(2048, 0);
 
-  std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
+  std::shared_ptr<DataPageV1> page = makeDataPage<Int32Type>(
       descr_,
       values,
-      /*num_vals=*/static_cast<int>(values.size()),
-      Encoding::PLAIN,
-      /*indices=*/{},
-      /*indices_size=*/0,
-      def_levels,
-      descr_->max_definition_level(),
-      rep_levels,
-      descr_->max_repetition_level());
+      static_cast<int>(values.size()),
+      Encoding::kPlain,
+      {},
+      0,
+      defLevels,
+      descr_->maxDefinitionLevel(),
+      repLevels,
+      descr_->maxRepetitionLevel());
   pages.push_back(std::move(page));
   auto pager = std::make_unique<MockPageReader>(pages);
-  record_reader_->SetPageReader(std::move(pager));
+  recordReader_->setPageReader(std::move(pager));
   {
-    // Read 1000 records. We will read 1024 levels because that is the minimum
-    // number of levels to read.
-    int64_t records_read = record_reader_->ReadRecords(/*num_records=*/1000);
-    ASSERT_EQ(records_read, 1000);
-    CheckState(
-        /*values_written=*/1000,
-        /*null_count=*/0,
-        /*levels_written=*/1024,
-        /*levels_position=*/1000);
-    std::vector<int32_t> expected_values(1000, 10);
-    std::vector<int16_t> expected_def_levels(1000, 1);
-    std::vector<int16_t> expected_rep_levels(1000, 0);
-    CheckReadValues(expected_values, expected_def_levels, expected_rep_levels);
+    // Read 1000 records. We will read 1024 levels because that is the minimum.
+    // Number of levels to read.
+    int64_t recordsRead = recordReader_->readRecords(1000);
+    ASSERT_EQ(recordsRead, 1000);
+    checkState(1000, 0, 1024, 1000);
+    std::vector<int32_t> expectedValues(1000, 10);
+    std::vector<int16_t> expectedDefLevels(1000, 1);
+    std::vector<int16_t> expectedRepLevels(1000, 0);
+    checkReadValues(expectedValues, expectedDefLevels, expectedRepLevels);
     // Reset removes the already consumed values and levels.
-    record_reader_->Reset();
+    recordReader_->reset();
   }
 
   { // Skip 12 records. Since we already have 24 in the buffer, we should not be
-    // reading any more levels into the buffer, we will just consume 12 of it.
-    int64_t records_skipped = record_reader_->SkipRecords(/*num_records=*/12);
-    ASSERT_EQ(records_skipped, 12);
-    CheckState(
-        /*values_written=*/0,
-        /*null_count=*/0,
-        /*levels_written=*/12,
-        /*levels_position=*/0);
+    // Reading any more levels into the buffer, we will just consume 12 of it.
+    int64_t recordsSkipped = recordReader_->skipRecords(12);
+    ASSERT_EQ(recordsSkipped, 12);
+    checkState(0, 0, 12, 0);
     // Everthing is empty because we reset the reader before this skip.
-    CheckReadValues(
-        /*expected_values=*/{},
-        /*expected_def_levels=*/{},
-        /*expected_rep_levels=*/{});
+    checkReadValues({}, {}, {});
   }
 }
 
 // Test reading when one record spans multiple pages for a repeated field.
 TEST_P(RecordReaderPrimitiveTypeTest, ReadPartialRecord) {
-  Init(schema::Int32("b", Repetition::REPEATED));
+  init(schema::int32("b", Repetition::kRepeated));
 
   std::vector<std::shared_ptr<Page>> pages;
 
   // Page 1: {[10], [20, 20, 20 ... } continues to next page.
   {
-    std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
+    std::shared_ptr<DataPageV1> page = makeDataPage<Int32Type>(
         descr_,
-        /*values=*/{10, 20, 20, 20},
-        /*num_vals=*/4,
-        Encoding::PLAIN,
-        /*indices=*/{},
-        /*indices_size=*/0,
-        /*def_levels=*/{1, 1, 1, 1},
-        descr_->max_definition_level(),
-        /*rep_levels=*/{0, 0, 1, 1},
-        descr_->max_repetition_level());
+        {10, 20, 20, 20},
+        4,
+        Encoding::kPlain,
+        {},
+        0,
+        {1, 1, 1, 1},
+        descr_->maxDefinitionLevel(),
+        {0, 0, 1, 1},
+        descr_->maxRepetitionLevel());
     pages.push_back(std::move(page));
   }
 
   // Page 2: {... 20, 20, ...} continues from previous page and to next page.
   {
-    std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
+    std::shared_ptr<DataPageV1> page = makeDataPage<Int32Type>(
         descr_,
-        /*values=*/{20, 20},
-        /*num_vals=*/2,
-        Encoding::PLAIN,
-        /*indices=*/{},
-        /*indices_size=*/0,
-        /*def_levels=*/{1, 1},
-        descr_->max_definition_level(),
-        /*rep_levels=*/{1, 1},
-        descr_->max_repetition_level());
+        {20, 20},
+        2,
+        Encoding::kPlain,
+        {},
+        0,
+        {1, 1},
+        descr_->maxDefinitionLevel(),
+        {1, 1},
+        descr_->maxRepetitionLevel());
     pages.push_back(std::move(page));
   }
 
   // Page 3: { ... 20], [30]} continues from previous page.
   {
-    std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
+    std::shared_ptr<DataPageV1> page = makeDataPage<Int32Type>(
         descr_,
-        /*values=*/{20, 30},
-        /*num_vals=*/2,
-        Encoding::PLAIN,
-        /*indices=*/{},
-        /*indices_size=*/0,
-        /*def_levels=*/{1, 1},
-        descr_->max_definition_level(),
-        /*rep_levels=*/{1, 0},
-        descr_->max_repetition_level());
+        {20, 30},
+        2,
+        Encoding::kPlain,
+        {},
+        0,
+        {1, 1},
+        descr_->maxDefinitionLevel(),
+        {1, 0},
+        descr_->maxRepetitionLevel());
     pages.push_back(std::move(page));
   }
 
   auto pager = std::make_unique<MockPageReader>(pages);
-  record_reader_->SetPageReader(std::move(pager));
+  recordReader_->setPageReader(std::move(pager));
 
   {
-    // Read [10]
-    int64_t records_read = record_reader_->ReadRecords(/*num_records=*/1);
-    ASSERT_EQ(records_read, 1);
-    CheckState(
-        /*values_written=*/1,
-        /*null_count=*/0,
-        /*levels_written=*/4,
-        /*levels_position=*/1);
-    CheckReadValues(
-        /*expected_values=*/{10},
-        /*expected_defs=*/{1},
-        /*expected_reps=*/{0});
+    // Read [10].
+    int64_t recordsRead = recordReader_->readRecords(1);
+    ASSERT_EQ(recordsRead, 1);
+    checkState(1, 0, 4, 1);
+    checkReadValues({10}, {1}, {0});
   }
 
   {
     // Read [20, 20, 20, 20, 20, 20] that spans multiple pages.
-    int64_t records_read = record_reader_->ReadRecords(/*num_records=*/1);
-    ASSERT_EQ(records_read, 1);
-    CheckState(
-        /*values_written=*/7,
-        /*null_count=*/0,
-        /*levels_written=*/8,
-        /*levels_position=*/7);
-    CheckReadValues(
-        /*expected_values=*/{10, 20, 20, 20, 20, 20, 20},
-        /*expected_defs=*/{1, 1, 1, 1, 1, 1, 1},
-        /*expected_reps=*/{0, 0, 1, 1, 1, 1, 1});
+    int64_t recordsRead = recordReader_->readRecords(1);
+    ASSERT_EQ(recordsRead, 1);
+    checkState(7, 0, 8, 7);
+    checkReadValues(
+        {10, 20, 20, 20, 20, 20, 20},
+        {1, 1, 1, 1, 1, 1, 1},
+        {0, 0, 1, 1, 1, 1, 1});
   }
 
   {
-    // Read [30]
-    int64_t records_read = record_reader_->ReadRecords(/*num_records=*/1);
-    ASSERT_EQ(records_read, 1);
-    CheckState(
-        /*values_written=*/8,
-        /*null_count=*/0,
-        /*levels_written=*/8,
-        /*levels_position=*/8);
-    CheckReadValues(
-        /*expected_values=*/{10, 20, 20, 20, 20, 20, 20, 30},
-        /*expected_defs=*/{1, 1, 1, 1, 1, 1, 1, 1},
-        /*expected_reps=*/{0, 0, 1, 1, 1, 1, 1, 0});
+    // Read [30].
+    int64_t recordsRead = recordReader_->readRecords(1);
+    ASSERT_EQ(recordsRead, 1);
+    checkState(8, 0, 8, 8);
+    checkReadValues(
+        {10, 20, 20, 20, 20, 20, 20, 30},
+        {1, 1, 1, 1, 1, 1, 1, 1},
+        {0, 0, 1, 1, 1, 1, 1, 0});
   }
 }
 
-// Test skipping for repeated fields for the case when one record spans multiple
-// pages.
+// Test skipping for repeated fields for the case when one record spans
+// multiple. Pages.
 TEST_P(RecordReaderPrimitiveTypeTest, SkipPartialRecord) {
-  Init(schema::Int32("b", Repetition::REPEATED));
+  init(schema::int32("b", Repetition::kRepeated));
 
   std::vector<std::shared_ptr<Page>> pages;
 
   // Page 1: {[10], [20, 20, 20 ... } continues to next page.
   {
-    std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
+    std::shared_ptr<DataPageV1> page = makeDataPage<Int32Type>(
         descr_,
-        /*values=*/{10, 20, 20, 20},
-        /*num_vals=*/4,
-        Encoding::PLAIN,
-        /*indices=*/{},
-        /*indices_size=*/0,
-        /*def_levels=*/{1, 1, 1, 1},
-        descr_->max_definition_level(),
-        /*rep_levels=*/{0, 0, 1, 1},
-        descr_->max_repetition_level());
+        {10, 20, 20, 20},
+        4,
+        Encoding::kPlain,
+        {},
+        0,
+        {1, 1, 1, 1},
+        descr_->maxDefinitionLevel(),
+        {0, 0, 1, 1},
+        descr_->maxRepetitionLevel());
     pages.push_back(std::move(page));
   }
 
   // Page 2: {... 20, 20, ...} continues from previous page and to next page.
   {
-    std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
+    std::shared_ptr<DataPageV1> page = makeDataPage<Int32Type>(
         descr_,
-        /*values=*/{20, 20},
-        /*num_vals=*/2,
-        Encoding::PLAIN,
-        /*indices=*/{},
-        /*indices_size=*/0,
-        /*def_levels=*/{1, 1},
-        descr_->max_definition_level(),
-        /*rep_levels=*/{1, 1},
-        descr_->max_repetition_level());
+        {20, 20},
+        2,
+        Encoding::kPlain,
+        {},
+        0,
+        {1, 1},
+        descr_->maxDefinitionLevel(),
+        {1, 1},
+        descr_->maxRepetitionLevel());
     pages.push_back(std::move(page));
   }
 
   // Page 3: { ... 20, [30]} continues from previous page.
   {
-    std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
+    std::shared_ptr<DataPageV1> page = makeDataPage<Int32Type>(
         descr_,
-        /*values=*/{20, 30},
-        /*num_vals=*/2,
-        Encoding::PLAIN,
-        /*indices=*/{},
-        /*indices_size=*/0,
-        /*def_levels=*/{1, 1},
-        descr_->max_definition_level(),
-        /*rep_levels=*/{1, 0},
-        descr_->max_repetition_level());
+        {20, 30},
+        2,
+        Encoding::kPlain,
+        {},
+        0,
+        {1, 1},
+        descr_->maxDefinitionLevel(),
+        {1, 0},
+        descr_->maxRepetitionLevel());
     pages.push_back(std::move(page));
   }
 
   auto pager = std::make_unique<MockPageReader>(pages);
-  record_reader_->SetPageReader(std::move(pager));
+  recordReader_->setPageReader(std::move(pager));
 
   {
-    // Read [10]
-    int64_t records_read = record_reader_->ReadRecords(/*num_records=*/1);
-    ASSERT_EQ(records_read, 1);
+    // Read [10].
+    int64_t recordsRead = recordReader_->readRecords(1);
+    ASSERT_EQ(recordsRead, 1);
     // There are 4 levels in the first page.
-    CheckState(
-        /*values_written=*/1,
-        /*null_count=*/0,
-        /*levels_written=*/4,
-        /*levels_position=*/1);
-    CheckReadValues(
-        /*expected_values=*/{10},
-        /*expected_defs=*/{1},
-        /*expected_reps=*/{0});
+    checkState(1, 0, 4, 1);
+    checkReadValues({10}, {1}, {0});
   }
 
   {
     // Skip the record that goes across pages.
-    int64_t records_skipped = record_reader_->SkipRecords(/*num_records=*/1);
-    ASSERT_EQ(records_skipped, 1);
-    CheckState(
-        /*values_written=*/1,
-        /*null_count=*/0,
-        /*levels_written=*/2,
-        /*levels_position=*/1);
-    CheckReadValues(
-        /*expected_values=*/{10},
-        /*expected_defs=*/{1},
-        /*expected_reps=*/{0});
+    int64_t recordsSkipped = recordReader_->skipRecords(1);
+    ASSERT_EQ(recordsSkipped, 1);
+    checkState(1, 0, 2, 1);
+    checkReadValues({10}, {1}, {0});
   }
 
   {
-    // Read [30]
-    int64_t records_read = record_reader_->ReadRecords(/*num_records=*/1);
-
-    ASSERT_EQ(records_read, 1);
-    CheckState(
-        /*values_written=*/2,
-        /*null_count=*/0,
-        /*levels_written=*/2,
-        /*levels_position=*/2);
-    CheckReadValues(
-        /*expected_values=*/{10, 30},
-        /*expected_defs=*/{1, 1},
-        /*expected_reps=*/{0, 0});
+    // Read [30].
+    int64_t recordsRead = recordReader_->readRecords(1);
+
+    ASSERT_EQ(recordsRead, 1);
+    checkState(2, 0, 2, 2);
+    checkReadValues({10, 30}, {1, 1}, {0, 0});
   }
 }
 
 INSTANTIATE_TEST_SUITE_P(
     RecordReaderPrimitveTypeTests,
     RecordReaderPrimitiveTypeTest,
-    ::testing::Values(/*read_dense_for_nullable=*/true, false),
+    ::testing::Values(true, false),
     testing::PrintToStringParamName());
 
 // Parameterized test for FLBA record reader.
 class FLBARecordReaderTest : public ::testing::TestWithParam<bool> {
  public:
-  bool read_dense_for_nullable() {
+  bool readDenseForNullable() {
     return GetParam();
   }
 
-  void
-  MakeRecordReader(int levels_per_page, int num_pages, int FLBA_type_length) {
-    levels_per_page_ = levels_per_page;
-    FLBA_type_length_ = FLBA_type_length;
-    LevelInfo level_info;
-    level_info.defLevel = 1;
-    level_info.repLevel = 0;
-    NodePtr type = schema::PrimitiveNode::Make(
+  void makeRecordReader(int levelsPerPage, int numPages, int flbaTypeLength) {
+    levelsPerPage_ = levelsPerPage;
+    flbaTypeLength_ = flbaTypeLength;
+    LevelInfo levelInfo;
+    levelInfo.defLevel = 1;
+    levelInfo.repLevel = 0;
+    NodePtr type = schema::PrimitiveNode::make(
         "b",
-        Repetition::OPTIONAL,
-        Type::FIXED_LEN_BYTE_ARRAY,
-        ConvertedType::NONE,
-        FLBA_type_length_);
+        Repetition::kOptional,
+        Type::kFixedLenByteArray,
+        ConvertedType::kNone,
+        flbaTypeLength_);
     descr_ = std::make_unique<ColumnDescriptor>(
-        type, level_info.defLevel, level_info.repLevel);
-    MakePages<FLBAType>(
+        type, levelInfo.defLevel, levelInfo.repLevel);
+    makePages<FLBAType>(
         descr_.get(),
-        num_pages,
-        levels_per_page,
-        def_levels_,
-        rep_levels_,
+        numPages,
+        levelsPerPage,
+        defLevels_,
+        repLevels_,
         values_,
         buffer_,
         pages_,
-        Encoding::PLAIN);
+        Encoding::kPlain);
     auto pager = std::make_unique<MockPageReader>(pages_);
-    record_reader_ = internal::RecordReader::Make(
+    recordReader_ = internal::RecordReader::make(
         descr_.get(),
-        level_info,
+        levelInfo,
         ::arrow::default_memory_pool(),
-        /*read_dictionary=*/false,
-        read_dense_for_nullable());
-    record_reader_->SetPageReader(std::move(pager));
+        false,
+        readDenseForNullable());
+    recordReader_->setPageReader(std::move(pager));
   }
 
   // Returns expected values in row range.
   // We need this since some values are null.
-  std::vector<std::string_view> expected_values(int start, int end) {
+  std::vector<std::string_view> expectedValues(int start, int end) {
     std::vector<std::string_view> result;
     // Find out where in the values_ vector we start from.
-    size_t values_index = 0;
+    size_t valuesIndex = 0;
     for (int i = 0; i < start; ++i) {
-      if (def_levels_[i] != 0) {
-        ++values_index;
+      if (defLevels_[i] != 0) {
+        ++valuesIndex;
       }
     }
 
     for (int i = start; i < end; ++i) {
-      if (def_levels_[i] == 0) {
-        if (!read_dense_for_nullable()) {
+      if (defLevels_[i] == 0) {
+        if (!readDenseForNullable()) {
           result.emplace_back();
         }
         continue;
       }
       result.emplace_back(
-          reinterpret_cast<const char*>(values_[values_index].ptr),
-          FLBA_type_length_);
-      ++values_index;
+          reinterpret_cast<const char*>(values_[valuesIndex].ptr),
+          flbaTypeLength_);
+      ++valuesIndex;
     }
     return result;
   }
 
-  void CheckReadValues(int start, int end) {
-    auto binary_reader =
-        dynamic_cast<BinaryRecordReader*>(record_reader_.get());
-    ASSERT_NE(binary_reader, nullptr);
+  void checkReadValues(int start, int end) {
+    auto binaryReader = dynamic_cast<BinaryRecordReader*>(recordReader_.get());
+    ASSERT_NE(binaryReader, nullptr);
     // Chunks are reset after this call.
-    ::arrow::ArrayVector array_vector = binary_reader->GetBuilderChunks();
-    ASSERT_EQ(array_vector.size(), 1);
-    auto binary_array =
-        dynamic_cast<::arrow::FixedSizeBinaryArray*>(array_vector[0].get());
-
-    ASSERT_NE(binary_array, nullptr);
-    ASSERT_EQ(binary_array->length(), record_reader_->values_written());
-    if (read_dense_for_nullable()) {
-      ASSERT_EQ(binary_array->null_count(), 0);
-      ASSERT_EQ(record_reader_->null_count(), 0);
+    ::arrow::ArrayVector arrayVector = binaryReader->getBuilderChunks();
+    ASSERT_EQ(arrayVector.size(), 1);
+    auto binaryArray =
+        dynamic_cast<::arrow::FixedSizeBinaryArray*>(arrayVector[0].get());
+
+    ASSERT_NE(binaryArray, nullptr);
+    ASSERT_EQ(binaryArray->length(), recordReader_->valuesWritten());
+    if (readDenseForNullable()) {
+      ASSERT_EQ(binaryArray->null_count(), 0);
+      ASSERT_EQ(recordReader_->nullCount(), 0);
     } else {
-      ASSERT_EQ(binary_array->null_count(), record_reader_->null_count());
+      ASSERT_EQ(binaryArray->null_count(), recordReader_->nullCount());
     }
 
-    std::vector<std::string_view> expected = expected_values(start, end);
+    std::vector<std::string_view> expected = expectedValues(start, end);
     for (size_t i = 0; i < expected.size(); ++i) {
-      if (def_levels_[i + start] == 0) {
-        ASSERT_EQ(!read_dense_for_nullable(), binary_array->IsNull(i));
+      if (defLevels_[i + start] == 0) {
+        ASSERT_EQ(!readDenseForNullable(), binaryArray->IsNull(i));
       } else {
-        ASSERT_EQ(expected[i].compare(binary_array->GetView(i)), 0);
-        ASSERT_FALSE(binary_array->IsNull(i));
+        ASSERT_EQ(expected[i].compare(binaryArray->GetView(i)), 0);
+        ASSERT_FALSE(binaryArray->IsNull(i));
       }
     }
   }
 
  protected:
-  std::shared_ptr<internal::RecordReader> record_reader_;
+  std::shared_ptr<internal::RecordReader> recordReader_;
 
  private:
-  int levels_per_page_;
-  int FLBA_type_length_;
+  int levelsPerPage_;
+  int flbaTypeLength_;
   std::vector<std::shared_ptr<Page>> pages_;
-  std::vector<int16_t> def_levels_;
-  std::vector<int16_t> rep_levels_;
+  std::vector<int16_t> defLevels_;
+  std::vector<int16_t> repLevels_;
   std::vector<FixedLenByteArray> values_;
   std::vector<uint8_t> buffer_;
   std::unique_ptr<ColumnDescriptor> descr_;
 };
 
-// Similar to above, except for Byte arrays. FLBA and Byte arrays are
-// sufficiently different to warrant a separate class for readability.
+// Similar to above, except for Byte arrays. FLBA and Byte arrays are.
+// Sufficiently different to warrant a separate class for readability.
 class ByteArrayRecordReaderTest : public ::testing::TestWithParam<bool> {
  public:
-  bool read_dense_for_nullable() {
+  bool readDenseForNullable() {
     return GetParam();
   }
 
-  void MakeRecordReader(int levels_per_page, int num_pages) {
-    levels_per_page_ = levels_per_page;
-    LevelInfo level_info;
-    level_info.defLevel = 1;
-    level_info.repLevel = 0;
-    NodePtr type = schema::ByteArray("b", Repetition::OPTIONAL);
+  void makeRecordReader(int levelsPerPage, int numPages) {
+    levelsPerPage_ = levelsPerPage;
+    LevelInfo levelInfo;
+    levelInfo.defLevel = 1;
+    levelInfo.repLevel = 0;
+    NodePtr type = schema::byteArray("b", Repetition::kOptional);
     descr_ = std::make_unique<ColumnDescriptor>(
-        type, level_info.defLevel, level_info.repLevel);
-    MakePages<ByteArrayType>(
+        type, levelInfo.defLevel, levelInfo.repLevel);
+    makePages<ByteArrayType>(
         descr_.get(),
-        num_pages,
-        levels_per_page,
-        def_levels_,
-        rep_levels_,
+        numPages,
+        levelsPerPage,
+        defLevels_,
+        repLevels_,
         values_,
         buffer_,
         pages_,
-        Encoding::PLAIN);
+        Encoding::kPlain);
 
     auto pager = std::make_unique<MockPageReader>(pages_);
 
-    record_reader_ = internal::RecordReader::Make(
+    recordReader_ = internal::RecordReader::make(
         descr_.get(),
-        level_info,
+        levelInfo,
         ::arrow::default_memory_pool(),
-        /*read_dictionary=*/false,
-        read_dense_for_nullable());
-    record_reader_->SetPageReader(std::move(pager));
+        false,
+        readDenseForNullable());
+    recordReader_->setPageReader(std::move(pager));
   }
 
   // Returns expected values in row range.
   // We need this since some values are null.
-  std::vector<std::string_view> expected_values(int start, int end) {
+  std::vector<std::string_view> expectedValues(int start, int end) {
     std::vector<std::string_view> result;
     // Find out where in the values_ vector we start from.
-    size_t values_index = 0;
+    size_t valuesIndex = 0;
     for (int i = 0; i < start; ++i) {
-      if (def_levels_[i] != 0) {
-        ++values_index;
+      if (defLevels_[i] != 0) {
+        ++valuesIndex;
       }
     }
 
     for (int i = start; i < end; ++i) {
-      if (def_levels_[i] == 0) {
-        if (!read_dense_for_nullable()) {
+      if (defLevels_[i] == 0) {
+        if (!readDenseForNullable()) {
           result.emplace_back();
         }
         continue;
       }
       result.emplace_back(
-          reinterpret_cast<const char*>(values_[values_index].ptr),
-          values_[values_index].len);
-      ++values_index;
+          reinterpret_cast<const char*>(values_[valuesIndex].ptr),
+          values_[valuesIndex].len);
+      ++valuesIndex;
     }
     return result;
   }
 
-  void CheckReadValues(int start, int end) {
-    auto binary_reader =
-        dynamic_cast<BinaryRecordReader*>(record_reader_.get());
-    ASSERT_NE(binary_reader, nullptr);
+  void checkReadValues(int start, int end) {
+    auto binaryReader = dynamic_cast<BinaryRecordReader*>(recordReader_.get());
+    ASSERT_NE(binaryReader, nullptr);
     // Chunks are reset after this call.
-    ::arrow::ArrayVector array_vector = binary_reader->GetBuilderChunks();
-    ASSERT_EQ(array_vector.size(), 1);
-    ::arrow::BinaryArray* binary_array =
-        dynamic_cast<::arrow::BinaryArray*>(array_vector[0].get());
-
-    ASSERT_NE(binary_array, nullptr);
-    ASSERT_EQ(binary_array->length(), record_reader_->values_written());
-    if (read_dense_for_nullable()) {
-      ASSERT_EQ(binary_array->null_count(), 0);
-      ASSERT_EQ(record_reader_->null_count(), 0);
+    ::arrow::ArrayVector arrayVector = binaryReader->getBuilderChunks();
+    ASSERT_EQ(arrayVector.size(), 1);
+    ::arrow::BinaryArray* binaryArray =
+        dynamic_cast<::arrow::BinaryArray*>(arrayVector[0].get());
+
+    ASSERT_NE(binaryArray, nullptr);
+    ASSERT_EQ(binaryArray->length(), recordReader_->valuesWritten());
+    if (readDenseForNullable()) {
+      ASSERT_EQ(binaryArray->null_count(), 0);
+      ASSERT_EQ(recordReader_->nullCount(), 0);
     } else {
-      ASSERT_EQ(binary_array->null_count(), record_reader_->null_count());
+      ASSERT_EQ(binaryArray->null_count(), recordReader_->nullCount());
     }
 
-    std::vector<std::string_view> expected = expected_values(start, end);
+    std::vector<std::string_view> expected = expectedValues(start, end);
     for (size_t i = 0; i < expected.size(); ++i) {
-      if (def_levels_[i + start] == 0) {
-        ASSERT_EQ(!read_dense_for_nullable(), binary_array->IsNull(i));
+      if (defLevels_[i + start] == 0) {
+        ASSERT_EQ(!readDenseForNullable(), binaryArray->IsNull(i));
       } else {
-        ASSERT_EQ(expected[i].compare(binary_array->GetView(i)), 0);
-        ASSERT_FALSE(binary_array->IsNull(i));
+        ASSERT_EQ(expected[i].compare(binaryArray->GetView(i)), 0);
+        ASSERT_FALSE(binaryArray->IsNull(i));
       }
     }
   }
 
  protected:
-  std::shared_ptr<internal::RecordReader> record_reader_;
+  std::shared_ptr<internal::RecordReader> recordReader_;
 
  private:
-  int levels_per_page_;
+  int levelsPerPage_;
   std::vector<std::shared_ptr<Page>> pages_;
-  std::vector<int16_t> def_levels_;
-  std::vector<int16_t> rep_levels_;
+  std::vector<int16_t> defLevels_;
+  std::vector<int16_t> repLevels_;
   std::vector<ByteArray> values_;
   std::vector<uint8_t> buffer_;
   std::unique_ptr<ColumnDescriptor> descr_;
 };
 
 // Tests reading and skipping a ByteArray field.
-// The binary readers only differ in DeocdeDense and DecodeSpaced functions, so
-// testing optional is sufficient in excercising those code paths.
+// The binary readers only differ in DeocdeDense and DecodeSpaced functions, so.
+// Testing optional is sufficient in excercising those code paths.
 TEST_P(ByteArrayRecordReaderTest, ReadAndSkipOptional) {
-  MakeRecordReader(/*levels_per_page=*/90, /*num_pages=*/1);
+  makeRecordReader(90, 1);
 
   // Read one-third of the page.
-  ASSERT_EQ(record_reader_->ReadRecords(/*num_records=*/30), 30);
-  CheckReadValues(0, 30);
-  record_reader_->Reset();
+  ASSERT_EQ(recordReader_->readRecords(30), 30);
+  checkReadValues(0, 30);
+  recordReader_->reset();
 
   // Skip 30 records.
-  ASSERT_EQ(record_reader_->SkipRecords(/*num_records=*/30), 30);
+  ASSERT_EQ(recordReader_->skipRecords(30), 30);
 
-  // Read 60 more records. Only 30 will be read, since we read 30 and skipped
-  // 30, so only 30 is left.
-  ASSERT_EQ(record_reader_->ReadRecords(/*num_records=*/60), 30);
-  CheckReadValues(60, 90);
-  record_reader_->Reset();
+  // Read 60 more records. Only 30 will be read, since we read 30 and skipped.
+  // 30, So only 30 is left.
+  ASSERT_EQ(recordReader_->readRecords(60), 30);
+  checkReadValues(60, 90);
+  recordReader_->reset();
 }
 
 // Tests reading and skipping an optional FLBA field.
-// The binary readers only differ in DeocdeDense and DecodeSpaced functions, so
-// testing optional is sufficient in excercising those code paths.
+// The binary readers only differ in DeocdeDense and DecodeSpaced functions, so.
+// Testing optional is sufficient in excercising those code paths.
 TEST_P(FLBARecordReaderTest, ReadAndSkipOptional) {
-  MakeRecordReader(
-      /*levels_per_page=*/90, /*num_pages=*/1, /*FLBA_type_length=*/4);
+  makeRecordReader(90, 1, 4);
 
   // Read one-third of the page.
-  ASSERT_EQ(record_reader_->ReadRecords(/*num_records=*/30), 30);
-  CheckReadValues(0, 30);
-  record_reader_->Reset();
+  ASSERT_EQ(recordReader_->readRecords(30), 30);
+  checkReadValues(0, 30);
+  recordReader_->reset();
 
   // Skip 30 records.
-  ASSERT_EQ(record_reader_->SkipRecords(/*num_records=*/30), 30);
+  ASSERT_EQ(recordReader_->skipRecords(30), 30);
 
-  // Read 60 more records. Only 30 will be read, since we read 30 and skipped
-  // 30, so only 30 is left.
-  ASSERT_EQ(record_reader_->ReadRecords(/*num_records=*/60), 30);
-  CheckReadValues(60, 90);
-  record_reader_->Reset();
+  // Read 60 more records. Only 30 will be read, since we read 30 and skipped.
+  // 30, So only 30 is left.
+  ASSERT_EQ(recordReader_->readRecords(60), 30);
+  checkReadValues(60, 90);
+  recordReader_->reset();
 }
 
 INSTANTIATE_TEST_SUITE_P(
@@ -2130,142 +1834,142 @@ class RecordReaderStressTest
     : public ::testing::TestWithParam<Repetition::type> {};
 
 TEST_P(RecordReaderStressTest, StressTest) {
-  LevelInfo level_info;
+  LevelInfo levelInfo;
   // Define these boolean variables for improving readability below.
   bool repeated = false, required = false;
-  if (GetParam() == Repetition::REQUIRED) {
-    level_info.defLevel = 0;
-    level_info.repLevel = 0;
+  if (GetParam() == Repetition::kRequired) {
+    levelInfo.defLevel = 0;
+    levelInfo.repLevel = 0;
     required = true;
-  } else if (GetParam() == Repetition::OPTIONAL) {
-    level_info.defLevel = 1;
-    level_info.repLevel = 0;
+  } else if (GetParam() == Repetition::kOptional) {
+    levelInfo.defLevel = 1;
+    levelInfo.repLevel = 0;
   } else {
-    level_info.defLevel = 1;
-    level_info.repLevel = 1;
+    levelInfo.defLevel = 1;
+    levelInfo.repLevel = 1;
     repeated = true;
   }
 
-  NodePtr type = schema::Int32("b", GetParam());
-  const ColumnDescriptor descr(type, level_info.defLevel, level_info.repLevel);
+  NodePtr type = schema::int32("b", GetParam());
+  const ColumnDescriptor descr(type, levelInfo.defLevel, levelInfo.repLevel);
 
   auto seed1 = static_cast<uint32_t>(time(0));
   std::default_random_engine gen(seed1);
   // Generate random number of pages with random number of values per page.
   std::uniform_int_distribution<int> d(0, 2000);
-  const int num_pages = d(gen);
-  const int levels_per_page = d(gen);
+  const int numPages = d(gen);
+  const int levelsPerPage = d(gen);
   std::vector<int32_t> values;
-  std::vector<int16_t> def_levels;
-  std::vector<int16_t> rep_levels;
-  std::vector<uint8_t> data_buffer;
+  std::vector<int16_t> defLevels;
+  std::vector<int16_t> repLevels;
+  std::vector<uint8_t> dataBuffer;
   std::vector<std::shared_ptr<Page>> pages;
   auto seed2 = static_cast<uint32_t>(time(0));
-  // Uses time(0) as seed so it would run a different test every time it is
-  // run.
-  MakePages<Int32Type>(
+  // Uses time(0) as seed so it would run a different test every time it is.
+  // Run.
+  makePages<Int32Type>(
       &descr,
-      num_pages,
-      levels_per_page,
-      def_levels,
-      rep_levels,
+      numPages,
+      levelsPerPage,
+      defLevels,
+      repLevels,
       values,
-      data_buffer,
+      dataBuffer,
       pages,
-      Encoding::PLAIN,
+      Encoding::kPlain,
       seed2);
   std::unique_ptr<PageReader> pager;
   pager.reset(new test::MockPageReader(pages));
 
   // Set up the RecordReader.
-  std::shared_ptr<internal::RecordReader> record_reader =
-      internal::RecordReader::Make(&descr, level_info);
-  record_reader->SetPageReader(std::move(pager));
+  std::shared_ptr<internal::RecordReader> recordReader =
+      internal::RecordReader::make(&descr, levelInfo);
+  recordReader->setPageReader(std::move(pager));
 
   // Figure out how many total records.
-  int total_records = 0;
+  int totalRecords = 0;
   if (repeated) {
-    for (int16_t rep : rep_levels) {
+    for (int16_t rep : repLevels) {
       if (rep == 0) {
-        ++total_records;
+        ++totalRecords;
       }
     }
   } else {
-    total_records = static_cast<int>(def_levels.size());
+    totalRecords = static_cast<int>(defLevels.size());
   }
 
   // Generate a sequence of reads and skips.
-  int records_left = total_records;
+  int recordsLeft = totalRecords;
   // The first element of the pair is 1 if SkipRecords and 0 if ReadRecords.
-  // The second element indicates the number of records for reading or
-  // skipping.
+  // The second element indicates the number of records for reading or.
+  // Skipping.
   std::vector<std::pair<bool, int>> sequence;
-  while (records_left > 0) {
-    std::uniform_int_distribution<int> d(0, records_left);
+  while (recordsLeft > 0) {
+    std::uniform_int_distribution<int> d(0, recordsLeft);
     // Generate a number to decide if this is a skip or read.
-    bool is_skip = d(gen) < records_left / 2;
-    int num_records = d(gen);
+    bool isSkip = d(gen) < recordsLeft / 2;
+    int numRecords = d(gen);
 
-    sequence.emplace_back(is_skip, num_records);
-    records_left -= num_records;
+    sequence.emplace_back(isSkip, numRecords);
+    recordsLeft -= numRecords;
   }
 
-  // The levels_index and values_index are over the original vectors that have
-  // all the rep/def values for all the records. In the following loop, we will
-  // read/skip a numebr of records and Reset the reader after each iteration.
+  // The levels_index and values_index are over the original vectors that have.
+  // All the rep/def values for all the records. In the following loop, we will.
+  // Read/skip a numebr of records and Reset the reader after each iteration.
   // This is on-par with how the record reader is used.
-  size_t levels_index = 0;
-  size_t values_index = 0;
-  for (const auto& [is_skip, num_records] : sequence) {
+  size_t levelsIndex = 0;
+  size_t valuesIndex = 0;
+  for (const auto& [isSkip, numRecords] : sequence) {
     // Reset the reader before the next round of read/skip.
-    record_reader->Reset();
+    recordReader->reset();
 
     // Prepare the expected result and do the SkipRecords and ReadRecords.
-    std::vector<int32_t> expected_values;
-    std::vector<int16_t> expected_def_levels;
-    std::vector<int16_t> expected_rep_levels;
-    bool inside_repeated_field = false;
-
-    int read_records = 0;
-    while (read_records < num_records || inside_repeated_field) {
-      if (!repeated || (repeated && rep_levels[levels_index] == 0)) {
-        ++read_records;
+    std::vector<int32_t> expectedValues;
+    std::vector<int16_t> expectedDefLevels;
+    std::vector<int16_t> expectedRepLevels;
+    bool insideRepeatedField = false;
+
+    int readRecords = 0;
+    while (readRecords < numRecords || insideRepeatedField) {
+      if (!repeated || (repeated && repLevels[levelsIndex] == 0)) {
+        ++readRecords;
       }
 
-      bool has_value = required ||
-          (!required && def_levels[levels_index] == level_info.defLevel);
+      bool hasValue = required ||
+          (!required && defLevels[levelsIndex] == levelInfo.defLevel);
 
-      // If we are not skipping, we need to update the expected values and
-      // rep/defs. If we are skipping, we just keep going.
-      if (!is_skip) {
+      // If we are not skipping, we need to update the expected values and.
+      // Rep/defs. If we are skipping, we just keep going.
+      if (!isSkip) {
         if (!required) {
-          expected_def_levels.push_back(def_levels[levels_index]);
-          if (!has_value) {
-            expected_values.push_back(-1);
+          expectedDefLevels.push_back(defLevels[levelsIndex]);
+          if (!hasValue) {
+            expectedValues.push_back(-1);
           }
         }
         if (repeated) {
-          expected_rep_levels.push_back(rep_levels[levels_index]);
+          expectedRepLevels.push_back(repLevels[levelsIndex]);
         }
-        if (has_value) {
-          expected_values.push_back(values[values_index]);
+        if (hasValue) {
+          expectedValues.push_back(values[valuesIndex]);
         }
       }
 
-      if (has_value) {
-        ++values_index;
+      if (hasValue) {
+        ++valuesIndex;
       }
 
-      // If we are in the middle of a repeated field, we should keep going
-      // until we consume it all.
-      if (repeated && levels_index + 1 < rep_levels.size() &&
-          rep_levels[levels_index + 1] == 1) {
-        inside_repeated_field = true;
+      // If we are in the middle of a repeated field, we should keep going.
+      // Until we consume it all.
+      if (repeated && levelsIndex + 1 < repLevels.size() &&
+          repLevels[levelsIndex + 1] == 1) {
+        insideRepeatedField = true;
       } else {
-        inside_repeated_field = false;
+        insideRepeatedField = false;
       }
 
-      ++levels_index;
+      ++levelsIndex;
     }
 
     // Print out the seeds with each failing ASSERT to easily reproduce the bug.
@@ -2273,50 +1977,50 @@ TEST_P(RecordReaderStressTest, StressTest) {
         "seeds: " + std::to_string(seed1) + " " + std::to_string(seed2);
 
     // Perform the actual read/skip.
-    if (is_skip) {
-      int64_t skipped_records = record_reader->SkipRecords(num_records);
-      ASSERT_EQ(skipped_records, num_records) << seeds;
+    if (isSkip) {
+      int64_t skippedRecords = recordReader->skipRecords(numRecords);
+      ASSERT_EQ(skippedRecords, numRecords) << seeds;
     } else {
-      int64_t read_records = record_reader->ReadRecords(num_records);
-      ASSERT_EQ(read_records, num_records) << seeds;
+      int64_t readRecords = recordReader->readRecords(numRecords);
+      ASSERT_EQ(readRecords, numRecords) << seeds;
     }
 
-    const auto read_values =
-        reinterpret_cast<const int32_t*>(record_reader->values());
+    const auto readValues =
+        reinterpret_cast<const int32_t*>(recordReader->values());
     if (required) {
-      ASSERT_EQ(record_reader->null_count(), 0) << seeds;
+      ASSERT_EQ(recordReader->nullCount(), 0) << seeds;
     }
-    std::vector<int32_t> read_vals(
-        read_values, read_values + record_reader->values_written());
-    for (size_t i = 0; i < expected_values.size(); ++i) {
-      if (expected_values[i] != -1) {
-        ASSERT_EQ(read_vals[i], expected_values[i]) << seeds;
+    std::vector<int32_t> readVals(
+        readValues, readValues + recordReader->valuesWritten());
+    for (size_t i = 0; i < expectedValues.size(); ++i) {
+      if (expectedValues[i] != -1) {
+        ASSERT_EQ(readVals[i], expectedValues[i]) << seeds;
       }
     }
 
     if (!required) {
-      std::vector<int16_t> read_def_levels(
-          record_reader->def_levels(),
-          record_reader->def_levels() + record_reader->levels_position());
-      ASSERT_TRUE(vector_equal(read_def_levels, expected_def_levels)) << seeds;
+      std::vector<int16_t> readDefLevels(
+          recordReader->defLevels(),
+          recordReader->defLevels() + recordReader->levelsPosition());
+      ASSERT_TRUE(vectorEqual(readDefLevels, expectedDefLevels)) << seeds;
     }
 
     if (repeated) {
-      std::vector<int16_t> read_rep_levels(
-          record_reader->rep_levels(),
-          record_reader->rep_levels() + record_reader->levels_position());
-      ASSERT_TRUE(vector_equal(read_rep_levels, expected_rep_levels)) << seeds;
+      std::vector<int16_t> readRepLevels(
+          recordReader->repLevels(),
+          recordReader->repLevels() + recordReader->levelsPosition());
+      ASSERT_TRUE(vectorEqual(readRepLevels, expectedRepLevels)) << seeds;
     }
   }
 }
 
 INSTANTIATE_TEST_SUITE_P(
-    Repetition_type,
+    repetitionType,
     RecordReaderStressTest,
     ::testing::Values(
-        Repetition::REQUIRED,
-        Repetition::OPTIONAL,
-        Repetition::REPEATED));
+        Repetition::kRequired,
+        Repetition::kOptional,
+        Repetition::kRepeated));
 
 } // namespace test
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/tests/ColumnScanner.cpp b/velox/dwio/parquet/writer/arrow/tests/ColumnScanner.cpp
index 030f9c1c446..7404949a2b2 100644
--- a/velox/dwio/parquet/writer/arrow/tests/ColumnScanner.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/ColumnScanner.cpp
@@ -27,78 +27,78 @@ using arrow::MemoryPool;
 
 namespace facebook::velox::parquet::arrow {
 
-std::shared_ptr<Scanner> Scanner::Make(
-    std::shared_ptr<ColumnReader> col_reader,
-    int64_t batch_size,
+std::shared_ptr<Scanner> Scanner::make(
+    std::shared_ptr<ColumnReader> colReader,
+    int64_t batchSize,
     MemoryPool* pool) {
-  switch (col_reader->type()) {
-    case Type::BOOLEAN:
+  switch (colReader->type()) {
+    case Type::kBoolean:
       return std::make_shared<BoolScanner>(
-          std::move(col_reader), batch_size, pool);
-    case Type::INT32:
+          std::move(colReader), batchSize, pool);
+    case Type::kInt32:
       return std::make_shared<Int32Scanner>(
-          std::move(col_reader), batch_size, pool);
-    case Type::INT64:
+          std::move(colReader), batchSize, pool);
+    case Type::kInt64:
       return std::make_shared<Int64Scanner>(
-          std::move(col_reader), batch_size, pool);
-    case Type::INT96:
+          std::move(colReader), batchSize, pool);
+    case Type::kInt96:
       return std::make_shared<Int96Scanner>(
-          std::move(col_reader), batch_size, pool);
-    case Type::FLOAT:
+          std::move(colReader), batchSize, pool);
+    case Type::kFloat:
       return std::make_shared<FloatScanner>(
-          std::move(col_reader), batch_size, pool);
-    case Type::DOUBLE:
+          std::move(colReader), batchSize, pool);
+    case Type::kDouble:
       return std::make_shared<DoubleScanner>(
-          std::move(col_reader), batch_size, pool);
-    case Type::BYTE_ARRAY:
+          std::move(colReader), batchSize, pool);
+    case Type::kByteArray:
       return std::make_shared<ByteArrayScanner>(
-          std::move(col_reader), batch_size, pool);
-    case Type::FIXED_LEN_BYTE_ARRAY:
+          std::move(colReader), batchSize, pool);
+    case Type::kFixedLenByteArray:
       return std::make_shared<FixedLenByteArrayScanner>(
-          std::move(col_reader), batch_size, pool);
+          std::move(colReader), batchSize, pool);
     default:
       ParquetException::NYI("type reader not implemented");
   }
-  // Unreachable code, but suppress compiler warning
+  // Unreachable code, but suppress compiler warning.
   return std::shared_ptr<Scanner>(nullptr);
 }
 
-int64_t ScanAllValues(
-    int32_t batch_size,
-    int16_t* def_levels,
-    int16_t* rep_levels,
+int64_t scanAllValues(
+    int32_t batchSize,
+    int16_t* defLevels,
+    int16_t* repLevels,
     uint8_t* values,
-    int64_t* values_buffered,
+    int64_t* valuesBuffered,
     ColumnReader* reader) {
   switch (reader->type()) {
-    case parquet::Type::BOOLEAN:
-      return ScanAll<BoolReader>(
-          batch_size, def_levels, rep_levels, values, values_buffered, reader);
-    case parquet::Type::INT32:
-      return ScanAll<Int32Reader>(
-          batch_size, def_levels, rep_levels, values, values_buffered, reader);
-    case parquet::Type::INT64:
-      return ScanAll<Int64Reader>(
-          batch_size, def_levels, rep_levels, values, values_buffered, reader);
-    case parquet::Type::INT96:
-      return ScanAll<Int96Reader>(
-          batch_size, def_levels, rep_levels, values, values_buffered, reader);
-    case parquet::Type::FLOAT:
-      return ScanAll<FloatReader>(
-          batch_size, def_levels, rep_levels, values, values_buffered, reader);
-    case parquet::Type::DOUBLE:
-      return ScanAll<DoubleReader>(
-          batch_size, def_levels, rep_levels, values, values_buffered, reader);
-    case parquet::Type::BYTE_ARRAY:
-      return ScanAll<ByteArrayReader>(
-          batch_size, def_levels, rep_levels, values, values_buffered, reader);
-    case parquet::Type::FIXED_LEN_BYTE_ARRAY:
-      return ScanAll<FixedLenByteArrayReader>(
-          batch_size, def_levels, rep_levels, values, values_buffered, reader);
+    case parquet::Type::kBoolean:
+      return scanAll<BoolReader>(
+          batchSize, defLevels, repLevels, values, valuesBuffered, reader);
+    case parquet::Type::kInt32:
+      return scanAll<Int32Reader>(
+          batchSize, defLevels, repLevels, values, valuesBuffered, reader);
+    case parquet::Type::kInt64:
+      return scanAll<Int64Reader>(
+          batchSize, defLevels, repLevels, values, valuesBuffered, reader);
+    case parquet::Type::kInt96:
+      return scanAll<Int96Reader>(
+          batchSize, defLevels, repLevels, values, valuesBuffered, reader);
+    case parquet::Type::kFloat:
+      return scanAll<FloatReader>(
+          batchSize, defLevels, repLevels, values, valuesBuffered, reader);
+    case parquet::Type::kDouble:
+      return scanAll<DoubleReader>(
+          batchSize, defLevels, repLevels, values, valuesBuffered, reader);
+    case parquet::Type::kByteArray:
+      return scanAll<ByteArrayReader>(
+          batchSize, defLevels, repLevels, values, valuesBuffered, reader);
+    case parquet::Type::kFixedLenByteArray:
+      return scanAll<FixedLenByteArrayReader>(
+          batchSize, defLevels, repLevels, values, valuesBuffered, reader);
     default:
       ParquetException::NYI("type reader not implemented");
   }
-  // Unreachable code, but suppress compiler warning
+  // Unreachable code, but suppress compiler warning.
   return 0;
 }
 
diff --git a/velox/dwio/parquet/writer/arrow/tests/ColumnScanner.h b/velox/dwio/parquet/writer/arrow/tests/ColumnScanner.h
index 5729a4c05ce..907def5f954 100644
--- a/velox/dwio/parquet/writer/arrow/tests/ColumnScanner.h
+++ b/velox/dwio/parquet/writer/arrow/tests/ColumnScanner.h
@@ -41,227 +41,227 @@ class PARQUET_EXPORT Scanner {
  public:
   explicit Scanner(
       std::shared_ptr<ColumnReader> reader,
-      int64_t batch_size = DEFAULT_SCANNER_BATCH_SIZE,
+      int64_t batchSize = DEFAULT_SCANNER_BATCH_SIZE,
       ::arrow::MemoryPool* pool = ::arrow::default_memory_pool())
-      : batch_size_(batch_size),
-        level_offset_(0),
-        levels_buffered_(0),
-        value_buffer_(AllocateBuffer(pool)),
-        value_offset_(0),
-        values_buffered_(0),
+      : batchSize_(batchSize),
+        levelOffset_(0),
+        levelsBuffered_(0),
+        valueBuffer_(allocateBuffer(pool)),
+        valueOffset_(0),
+        valuesBuffered_(0),
         reader_(std::move(reader)) {
-    def_levels_.resize(descr()->max_definition_level() > 0 ? batch_size_ : 0);
-    rep_levels_.resize(descr()->max_repetition_level() > 0 ? batch_size_ : 0);
+    defLevels_.resize(descr()->maxDefinitionLevel() > 0 ? batchSize_ : 0);
+    repLevels_.resize(descr()->maxRepetitionLevel() > 0 ? batchSize_ : 0);
   }
 
   virtual ~Scanner() {}
 
-  static std::shared_ptr<Scanner> Make(
-      std::shared_ptr<ColumnReader> col_reader,
-      int64_t batch_size = DEFAULT_SCANNER_BATCH_SIZE,
+  static std::shared_ptr<Scanner> make(
+      std::shared_ptr<ColumnReader> colReader,
+      int64_t batchSize = DEFAULT_SCANNER_BATCH_SIZE,
       ::arrow::MemoryPool* pool = ::arrow::default_memory_pool());
 
   virtual void
-  PrintNext(std::ostream& out, int width, bool with_levels = false) = 0;
+  printNext(std::ostream& out, int width, bool withLevels = false) = 0;
 
-  bool HasNext() {
-    return level_offset_ < levels_buffered_ || reader_->HasNext();
+  bool hasNext() {
+    return levelOffset_ < levelsBuffered_ || reader_->hasNext();
   }
 
   const ColumnDescriptor* descr() const {
     return reader_->descr();
   }
 
-  int64_t batch_size() const {
-    return batch_size_;
+  int64_t batchSize() const {
+    return batchSize_;
   }
 
-  void SetBatchSize(int64_t batch_size) {
-    batch_size_ = batch_size;
+  void setBatchSize(int64_t batchSize) {
+    batchSize_ = batchSize;
   }
 
  protected:
-  int64_t batch_size_;
+  int64_t batchSize_;
 
-  std::vector<int16_t> def_levels_;
-  std::vector<int16_t> rep_levels_;
-  int level_offset_;
-  int levels_buffered_;
+  std::vector<int16_t> defLevels_;
+  std::vector<int16_t> repLevels_;
+  int levelOffset_;
+  int levelsBuffered_;
 
-  std::shared_ptr<ResizableBuffer> value_buffer_;
-  int value_offset_;
-  int64_t values_buffered_;
+  std::shared_ptr<ResizableBuffer> valueBuffer_;
+  int valueOffset_;
+  int64_t valuesBuffered_;
   std::shared_ptr<ColumnReader> reader_;
 };
 
 template <typename DType>
 class PARQUET_TEMPLATE_CLASS_EXPORT TypedScanner : public Scanner {
  public:
-  typedef typename DType::c_type T;
+  typedef typename DType::CType T;
 
   explicit TypedScanner(
       std::shared_ptr<ColumnReader> reader,
-      int64_t batch_size = DEFAULT_SCANNER_BATCH_SIZE,
+      int64_t batchSize = DEFAULT_SCANNER_BATCH_SIZE,
       ::arrow::MemoryPool* pool = ::arrow::default_memory_pool())
-      : Scanner(std::move(reader), batch_size, pool) {
-    typed_reader_ = static_cast<TypedColumnReader<DType>*>(reader_.get());
-    int value_byte_size = type_traits<DType::type_num>::value_byte_size;
-    PARQUET_THROW_NOT_OK(value_buffer_->Resize(batch_size_ * value_byte_size));
-    values_ = reinterpret_cast<T*>(value_buffer_->mutable_data());
+      : Scanner(std::move(reader), batchSize, pool) {
+    typedReader_ = static_cast<TypedColumnReader<DType>*>(reader_.get());
+    int valueByteSize = TypeTraits<DType::typeNum>::valueByteSize;
+    PARQUET_THROW_NOT_OK(valueBuffer_->Resize(batchSize_ * valueByteSize));
+    values_ = reinterpret_cast<T*>(valueBuffer_->mutable_data());
   }
 
   virtual ~TypedScanner() {}
 
-  bool NextLevels(int16_t* def_level, int16_t* rep_level) {
-    if (level_offset_ == levels_buffered_) {
-      levels_buffered_ = static_cast<int>(typed_reader_->ReadBatch(
-          static_cast<int>(batch_size_),
-          def_levels_.data(),
-          rep_levels_.data(),
+  bool nextLevels(int16_t* defLevel, int16_t* repLevel) {
+    if (levelOffset_ == levelsBuffered_) {
+      levelsBuffered_ = static_cast<int>(typedReader_->readBatch(
+          static_cast<int>(batchSize_),
+          defLevels_.data(),
+          repLevels_.data(),
           values_,
-          &values_buffered_));
+          &valuesBuffered_));
 
-      value_offset_ = 0;
-      level_offset_ = 0;
-      if (!levels_buffered_) {
+      valueOffset_ = 0;
+      levelOffset_ = 0;
+      if (!levelsBuffered_) {
         return false;
       }
     }
-    *def_level =
-        descr()->max_definition_level() > 0 ? def_levels_[level_offset_] : 0;
-    *rep_level =
-        descr()->max_repetition_level() > 0 ? rep_levels_[level_offset_] : 0;
-    level_offset_++;
+    *defLevel =
+        descr()->maxDefinitionLevel() > 0 ? defLevels_[levelOffset_] : 0;
+    *repLevel =
+        descr()->maxRepetitionLevel() > 0 ? repLevels_[levelOffset_] : 0;
+    levelOffset_++;
     return true;
   }
 
-  bool Next(T* val, int16_t* def_level, int16_t* rep_level, bool* is_null) {
-    if (level_offset_ == levels_buffered_) {
-      if (!HasNext()) {
-        // Out of data pages
+  bool next(T* val, int16_t* defLevel, int16_t* repLevel, bool* isNull) {
+    if (levelOffset_ == levelsBuffered_) {
+      if (!hasNext()) {
+        // Out of data pages.
         return false;
       }
     }
 
-    NextLevels(def_level, rep_level);
-    *is_null = *def_level < descr()->max_definition_level();
+    nextLevels(defLevel, repLevel);
+    *isNull = *defLevel < descr()->maxDefinitionLevel();
 
-    if (*is_null) {
+    if (*isNull) {
       return true;
     }
 
-    if (value_offset_ == values_buffered_) {
+    if (valueOffset_ == valuesBuffered_) {
       throw ParquetException("Value was non-null, but has not been buffered");
     }
-    *val = values_[value_offset_++];
+    *val = values_[valueOffset_++];
     return true;
   }
 
-  // Returns true if there is a next value
-  bool NextValue(T* val, bool* is_null) {
-    if (level_offset_ == levels_buffered_) {
-      if (!HasNext()) {
-        // Out of data pages
+  // Returns true if there is a next value.
+  bool nextValue(T* val, bool* isNull) {
+    if (levelOffset_ == levelsBuffered_) {
+      if (!hasNext()) {
+        // Out of data pages.
         return false;
       }
     }
 
-    // Out of values
-    int16_t def_level = -1;
-    int16_t rep_level = -1;
-    NextLevels(&def_level, &rep_level);
-    *is_null = def_level < descr()->max_definition_level();
+    // Out of values.
+    int16_t defLevel = -1;
+    int16_t repLevel = -1;
+    nextLevels(&defLevel, &repLevel);
+    *isNull = defLevel < descr()->maxDefinitionLevel();
 
-    if (*is_null) {
+    if (*isNull) {
       return true;
     }
 
-    if (value_offset_ == values_buffered_) {
+    if (valueOffset_ == valuesBuffered_) {
       throw ParquetException("Value was non-null, but has not been buffered");
     }
-    *val = values_[value_offset_++];
+    *val = values_[valueOffset_++];
     return true;
   }
 
   virtual void
-  PrintNext(std::ostream& out, int width, bool with_levels = false) {
+  printNext(std::ostream& out, int width, bool withLevels = false) {
     T val{};
-    int16_t def_level = -1;
-    int16_t rep_level = -1;
-    bool is_null = false;
+    int16_t defLevel = -1;
+    int16_t repLevel = -1;
+    bool isNull = false;
     char buffer[80];
 
-    if (!Next(&val, &def_level, &rep_level, &is_null)) {
+    if (!next(&val, &defLevel, &repLevel, &isNull)) {
       throw ParquetException("No more values buffered");
     }
 
-    if (with_levels) {
-      out << "  D:" << def_level << " R:" << rep_level << " ";
-      if (!is_null) {
+    if (withLevels) {
+      out << "  D:" << defLevel << " R:" << repLevel << " ";
+      if (!isNull) {
         out << "V:";
       }
     }
 
-    if (is_null) {
-      std::string null_fmt = format_fwf<ByteArrayType>(width);
-      snprintf(buffer, sizeof(buffer), null_fmt.c_str(), "NULL");
+    if (isNull) {
+      std::string nullFmt = formatFwf<ByteArrayType>(width);
+      snprintf(buffer, sizeof(buffer), nullFmt.c_str(), "NULL");
     } else {
-      FormatValue(&val, buffer, sizeof(buffer), width);
+      formatValue(&val, buffer, sizeof(buffer), width);
     }
     out << buffer;
   }
 
  private:
-  // The ownership of this object is expressed through the reader_ variable in
-  // the base
-  TypedColumnReader<DType>* typed_reader_;
+  // The ownership of this object is expressed through the reader_ variable in.
+  // The base.
+  TypedColumnReader<DType>* typedReader_;
 
-  inline void FormatValue(void* val, char* buffer, int bufsize, int width);
+  inline void formatValue(void* val, char* buffer, int bufsize, int width);
 
   T* values_;
 };
 
 template <typename DType>
-inline void TypedScanner<DType>::FormatValue(
+inline void TypedScanner<DType>::formatValue(
     void* val,
     char* buffer,
     int bufsize,
     int width) {
-  std::string fmt = format_fwf<DType>(width);
+  std::string fmt = formatFwf<DType>(width);
   snprintf(buffer, bufsize, fmt.c_str(), *reinterpret_cast<T*>(val));
 }
 
 template <>
-inline void TypedScanner<Int96Type>::FormatValue(
+inline void TypedScanner<Int96Type>::formatValue(
     void* val,
     char* buffer,
     int bufsize,
     int width) {
-  std::string fmt = format_fwf<Int96Type>(width);
-  std::string result = Int96ToString(*reinterpret_cast<Int96*>(val));
+  std::string fmt = formatFwf<Int96Type>(width);
+  std::string result = int96ToString(*reinterpret_cast<Int96*>(val));
   snprintf(buffer, bufsize, fmt.c_str(), result.c_str());
 }
 
 template <>
-inline void TypedScanner<ByteArrayType>::FormatValue(
+inline void TypedScanner<ByteArrayType>::formatValue(
     void* val,
     char* buffer,
     int bufsize,
     int width) {
-  std::string fmt = format_fwf<ByteArrayType>(width);
-  std::string result = ByteArrayToString(*reinterpret_cast<ByteArray*>(val));
+  std::string fmt = formatFwf<ByteArrayType>(width);
+  std::string result = byteArrayToString(*reinterpret_cast<ByteArray*>(val));
   snprintf(buffer, bufsize, fmt.c_str(), result.c_str());
 }
 
 template <>
-inline void TypedScanner<FLBAType>::FormatValue(
+inline void TypedScanner<FLBAType>::formatValue(
     void* val,
     char* buffer,
     int bufsize,
     int width) {
-  std::string fmt = format_fwf<FLBAType>(width);
-  std::string result = FixedLenByteArrayToString(
-      *reinterpret_cast<FixedLenByteArray*>(val), descr()->type_length());
+  std::string fmt = formatFwf<FLBAType>(width);
+  std::string result = fixedLenByteArrayToString(
+      *reinterpret_cast<FixedLenByteArray*>(val), descr()->typeLength());
   snprintf(buffer, bufsize, fmt.c_str(), result.c_str());
 }
 
@@ -275,26 +275,26 @@ typedef TypedScanner<ByteArrayType> ByteArrayScanner;
 typedef TypedScanner<FLBAType> FixedLenByteArrayScanner;
 
 template <typename RType>
-int64_t ScanAll(
-    int32_t batch_size,
-    int16_t* def_levels,
-    int16_t* rep_levels,
+int64_t scanAll(
+    int32_t batchSize,
+    int16_t* defLevels,
+    int16_t* repLevels,
     uint8_t* values,
-    int64_t* values_buffered,
+    int64_t* valuesBuffered,
     ColumnReader* reader) {
   typedef typename RType::T Type;
-  auto typed_reader = static_cast<RType*>(reader);
+  auto typedReader = static_cast<RType*>(reader);
   auto vals = reinterpret_cast<Type*>(&values[0]);
-  return typed_reader->ReadBatch(
-      batch_size, def_levels, rep_levels, vals, values_buffered);
+  return typedReader->readBatch(
+      batchSize, defLevels, repLevels, vals, valuesBuffered);
 }
 
-int64_t PARQUET_EXPORT ScanAllValues(
-    int32_t batch_size,
-    int16_t* def_levels,
-    int16_t* rep_levels,
+int64_t PARQUET_EXPORT scanAllValues(
+    int32_t batchSize,
+    int16_t* defLevels,
+    int16_t* repLevels,
     uint8_t* values,
-    int64_t* values_buffered,
+    int64_t* valuesBuffered,
     ColumnReader* reader);
 
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/tests/ColumnWriterTest.cpp b/velox/dwio/parquet/writer/arrow/tests/ColumnWriterTest.cpp
index 4d9b10f3568..d9716a76580 100644
--- a/velox/dwio/parquet/writer/arrow/tests/ColumnWriterTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/ColumnWriterTest.cpp
@@ -56,15 +56,15 @@ const int SMALL_SIZE = 100;
 const int LARGE_SIZE = 10000;
 // Very large size to test dictionary fallback.
 const int VERY_LARGE_SIZE = 40000;
-// Reduced dictionary page size to use for testing dictionary fallback with
-// valgrind
+// Reduced dictionary page size to use for testing dictionary fallback with.
+// Valgrind.
 const int64_t DICTIONARY_PAGE_SIZE = 1024;
 #else
 // Larger size to test some corner cases, only used in some specific cases.
 const int LARGE_SIZE = 100000;
 // Very large size to test dictionary fallback.
 const int VERY_LARGE_SIZE = 400000;
-// Dictionary page size to use for testing dictionary fallback
+// Dictionary page size to use for testing dictionary fallback.
 const int64_t DICTIONARY_PAGE_SIZE = 1024 * 1024;
 #endif
 
@@ -72,62 +72,62 @@ template <typename TestType>
 class TestPrimitiveWriter : public PrimitiveTypedTest<TestType> {
  public:
   void SetUp() {
-    this->SetupValuesOut(SMALL_SIZE);
-    writer_properties_ = default_writer_properties();
-    definition_levels_out_.resize(SMALL_SIZE);
-    repetition_levels_out_.resize(SMALL_SIZE);
+    this->setupValuesOut(SMALL_SIZE);
+    writerProperties_ = defaultWriterProperties();
+    definitionLevelsOut_.resize(SMALL_SIZE);
+    repetitionLevelsOut_.resize(SMALL_SIZE);
 
-    this->SetUpSchema(Repetition::REQUIRED);
+    this->setUpSchema(Repetition::kRequired);
 
-    descr_ = this->schema_.Column(0);
+    descr_ = this->schema_.column(0);
   }
 
-  Type::type type_num() {
-    return TestType::type_num;
+  Type::type typeNum() {
+    return TestType::typeNum;
   }
 
-  void BuildReader(
-      int64_t num_rows,
+  void buildReader(
+      int64_t numRows,
       Compression::type compression = Compression::UNCOMPRESSED,
-      bool page_checksum_verify = false) {
+      bool pageChecksumVerify = false) {
     ASSERT_OK_AND_ASSIGN(auto buffer, sink_->Finish());
     auto source = std::make_shared<::arrow::io::BufferReader>(buffer);
     ReaderProperties readerProperties;
-    readerProperties.set_page_checksum_verification(page_checksum_verify);
-    std::unique_ptr<PageReader> page_reader = PageReader::Open(
-        std::move(source), num_rows, compression, readerProperties);
+    readerProperties.setPageChecksumVerification(pageChecksumVerify);
+    std::unique_ptr<PageReader> pageReader = PageReader::open(
+        std::move(source), numRows, compression, readerProperties);
     reader_ = std::static_pointer_cast<TypedColumnReader<TestType>>(
-        ColumnReader::Make(this->descr_, std::move(page_reader)));
+        ColumnReader::make(this->descr_, std::move(pageReader)));
   }
 
-  std::shared_ptr<TypedColumnWriter<TestType>> BuildWriter(
-      int64_t output_size = SMALL_SIZE,
-      const ColumnProperties& column_properties = ColumnProperties(),
+  std::shared_ptr<TypedColumnWriter<TestType>> buildWriter(
+      int64_t outputSize = SMALL_SIZE,
+      const ColumnProperties& columnProps = ColumnProperties(),
       const ParquetVersion::type version = ParquetVersion::PARQUET_1_0,
-      bool enable_checksum = false) {
-    sink_ = CreateOutputStream();
-    WriterProperties::Builder wp_builder;
-    wp_builder.version(version);
-    if (column_properties.encoding() == Encoding::PLAIN_DICTIONARY ||
-        column_properties.encoding() == Encoding::RLE_DICTIONARY) {
-      wp_builder.enable_dictionary();
-      wp_builder.dictionary_pagesize_limit(DICTIONARY_PAGE_SIZE);
+      bool enableChecksum = false) {
+    sink_ = createOutputStream();
+    WriterProperties::Builder wpBuilder;
+    wpBuilder.version(version);
+    if (columnProps.encoding() == Encoding::kPlainDictionary ||
+        columnProps.encoding() == Encoding::kRleDictionary) {
+      wpBuilder.enableDictionary();
+      wpBuilder.dictionaryPagesizeLimit(DICTIONARY_PAGE_SIZE);
     } else {
-      wp_builder.disable_dictionary();
-      wp_builder.encoding(column_properties.encoding());
+      wpBuilder.disableDictionary();
+      wpBuilder.encoding(columnProps.encoding());
     }
-    if (enable_checksum) {
-      wp_builder.enable_page_checksum();
+    if (enableChecksum) {
+      wpBuilder.enablePageChecksum();
     }
-    wp_builder.max_statistics_size(column_properties.max_statistics_size());
-    writer_properties_ = wp_builder.build();
+    wpBuilder.maxStatisticsSize(columnProps.maxStatisticsSize());
+    writerProperties_ = wpBuilder.build();
 
     metadata_ =
-        ColumnChunkMetaDataBuilder::Make(writer_properties_, this->descr_);
-    std::unique_ptr<PageWriter> pager = PageWriter::Open(
+        ColumnChunkMetaDataBuilder::make(writerProperties_, this->descr_);
+    std::unique_ptr<PageWriter> pager = PageWriter::open(
         sink_,
-        column_properties.compression(),
-        Codec::UseDefaultCompressionLevel(),
+        columnProps.compression(),
+        Codec::useDefaultCompressionLevel(),
         metadata_.get(),
         /* row_group_ordinal */ -1,
         /* column_chunk_ordinal*/ -1,
@@ -135,374 +135,366 @@ class TestPrimitiveWriter : public PrimitiveTypedTest<TestType> {
         /* buffered_row_group */ false,
         /* header_encryptor */ NULLPTR,
         /* data_encryptor */ NULLPTR,
-        enable_checksum);
-    std::shared_ptr<ColumnWriter> writer = ColumnWriter::Make(
-        metadata_.get(), std::move(pager), writer_properties_.get());
+        enableChecksum);
+    std::shared_ptr<ColumnWriter> writer = ColumnWriter::make(
+        metadata_.get(), std::move(pager), writerProperties_.get());
     return std::static_pointer_cast<TypedColumnWriter<TestType>>(writer);
   }
 
-  void ReadColumn(
+  void readColumn(
       Compression::type compression = Compression::UNCOMPRESSED,
-      bool page_checksum_verify = false) {
-    BuildReader(
-        static_cast<int64_t>(this->values_out_.size()),
+      bool pageChecksumVerify = false) {
+    buildReader(
+        static_cast<int64_t>(this->valuesOut_.size()),
         compression,
-        page_checksum_verify);
-    reader_->ReadBatch(
-        static_cast<int>(this->values_out_.size()),
-        definition_levels_out_.data(),
-        repetition_levels_out_.data(),
-        this->values_out_ptr_,
-        &values_read_);
-    this->SyncValuesOut();
+        pageChecksumVerify);
+    reader_->readBatch(
+        static_cast<int>(this->valuesOut_.size()),
+        definitionLevelsOut_.data(),
+        repetitionLevelsOut_.data(),
+        this->valuesOutPtr_,
+        &valuesRead_);
+    this->syncValuesOut();
   }
 
-  void ReadColumnFully(
+  void readColumnFully(
       Compression::type compression = Compression::UNCOMPRESSED,
-      bool page_checksum_verify = false);
+      bool pageChecksumVerify = false);
 
-  void TestRequiredWithEncoding(Encoding::type encoding) {
-    return TestRequiredWithSettings(
+  void testRequiredWithEncoding(Encoding::type encoding) {
+    return testRequiredWithSettings(
         encoding, Compression::UNCOMPRESSED, false, false);
   }
 
-  void TestRequiredWithSettings(
+  void testRequiredWithSettings(
       Encoding::type encoding,
       Compression::type compression,
-      bool enable_dictionary,
-      bool enable_statistics,
-      int64_t num_rows = SMALL_SIZE,
-      int compression_level = Codec::UseDefaultCompressionLevel(),
-      bool enable_checksum = false) {
-    this->GenerateData(num_rows);
-
-    this->WriteRequiredWithSettings(
+      bool enableDictionary,
+      bool enableStatistics,
+      int64_t numRows = SMALL_SIZE,
+      int compressionLevel = Codec::useDefaultCompressionLevel(),
+      bool enableChecksum = false) {
+    this->generateData(numRows);
+
+    this->writeRequiredWithSettings(
         encoding,
         compression,
-        enable_dictionary,
-        enable_statistics,
-        compression_level,
-        num_rows,
-        enable_checksum);
+        enableDictionary,
+        enableStatistics,
+        compressionLevel,
+        numRows,
+        enableChecksum);
     ASSERT_NO_FATAL_FAILURE(
-        this->ReadAndCompare(compression, num_rows, enable_checksum));
+        this->readAndCompare(compression, numRows, enableChecksum));
 
-    this->WriteRequiredWithSettingsSpaced(
+    this->writeRequiredWithSettingsSpaced(
         encoding,
         compression,
-        enable_dictionary,
-        enable_statistics,
-        num_rows,
-        compression_level,
-        enable_checksum);
+        enableDictionary,
+        enableStatistics,
+        numRows,
+        compressionLevel,
+        enableChecksum);
     ASSERT_NO_FATAL_FAILURE(
-        this->ReadAndCompare(compression, num_rows, enable_checksum));
+        this->readAndCompare(compression, numRows, enableChecksum));
   }
 
-  void TestDictionaryFallbackEncoding(ParquetVersion::type version) {
-    this->GenerateData(VERY_LARGE_SIZE);
-    ColumnProperties column_properties;
-    column_properties.set_dictionary_enabled(true);
+  void testDictionaryFallbackEncoding(ParquetVersion::type version) {
+    this->generateData(VERY_LARGE_SIZE);
+    ColumnProperties columnProperties;
+    columnProperties.setDictionaryEnabled(true);
 
     if (version == ParquetVersion::PARQUET_1_0) {
-      column_properties.set_encoding(Encoding::PLAIN_DICTIONARY);
+      columnProperties.setEncoding(Encoding::kPlainDictionary);
     } else {
-      column_properties.set_encoding(Encoding::RLE_DICTIONARY);
+      columnProperties.setEncoding(Encoding::kRleDictionary);
     }
 
-    auto writer =
-        this->BuildWriter(VERY_LARGE_SIZE, column_properties, version);
+    auto writer = this->buildWriter(VERY_LARGE_SIZE, columnProperties, version);
 
-    writer->WriteBatch(
-        this->values_.size(), nullptr, nullptr, this->values_ptr_);
-    writer->Close();
+    writer->writeBatch(
+        this->values_.size(), nullptr, nullptr, this->valuesPtr_);
+    writer->close();
 
-    // Read all rows so we are sure that also the non-dictionary pages are read
-    // correctly
-    this->SetupValuesOut(VERY_LARGE_SIZE);
-    this->ReadColumnFully();
-    ASSERT_EQ(VERY_LARGE_SIZE, this->values_read_);
+    // Read all rows so we are sure that also the non-dictionary pages are read.
+    // Correctly.
+    this->setupValuesOut(VERY_LARGE_SIZE);
+    this->readColumnFully();
+    ASSERT_EQ(VERY_LARGE_SIZE, this->valuesRead_);
     this->values_.resize(VERY_LARGE_SIZE);
-    ASSERT_EQ(this->values_, this->values_out_);
-    std::vector<Encoding::type> encodings_vector = this->metadata_encodings();
+    ASSERT_EQ(this->values_, this->valuesOut_);
+    std::vector<Encoding::type> encodingsVector = this->metadataEncodings();
     std::set<Encoding::type> encodings(
-        encodings_vector.begin(), encodings_vector.end());
+        encodingsVector.cbegin(), encodingsVector.cend());
 
-    if (this->type_num() == Type::BOOLEAN) {
-      // Dictionary encoding is not allowed for boolean type
-      // There are 2 encodings (PLAIN, RLE) in a non dictionary encoding case
-      std::set<Encoding::type> expected({Encoding::PLAIN, Encoding::RLE});
+    if (this->typeNum() == Type::kBoolean) {
+      // Dictionary encoding is not allowed for boolean type.
+      // There are 2 encodings (PLAIN, RLE) in a non dictionary encoding case.
+      std::set<Encoding::type> expected({Encoding::kPlain, Encoding::kRle});
       ASSERT_EQ(encodings, expected);
     } else if (version == ParquetVersion::PARQUET_1_0) {
-      // There are 3 encodings (PLAIN_DICTIONARY, PLAIN, RLE) in a fallback case
-      // for version 1.0
+      // There are 3 encodings (PLAIN_DICTIONARY, PLAIN, RLE) in a fallback
+      // case. For version 1.0.
       std::set<Encoding::type> expected(
-          {Encoding::PLAIN_DICTIONARY, Encoding::PLAIN, Encoding::RLE});
+          {Encoding::kPlainDictionary, Encoding::kPlain, Encoding::kRle});
       ASSERT_EQ(encodings, expected);
     } else {
-      // There are 3 encodings (RLE_DICTIONARY, PLAIN, RLE) in a fallback case
-      // for version 2.0
+      // There are 3 encodings (RLE_DICTIONARY, PLAIN, RLE) in a fallback case.
+      // For version 2.0.
       std::set<Encoding::type> expected(
-          {Encoding::RLE_DICTIONARY, Encoding::PLAIN, Encoding::RLE});
+          {Encoding::kRleDictionary, Encoding::kPlain, Encoding::kRle});
       ASSERT_EQ(encodings, expected);
     }
 
-    std::vector<PageEncodingStats> encoding_stats =
-        this->metadata_encoding_stats();
-    if (this->type_num() == Type::BOOLEAN) {
-      ASSERT_EQ(encoding_stats[0].encoding, Encoding::PLAIN);
-      ASSERT_EQ(encoding_stats[0].page_type, PageType::DATA_PAGE);
+    std::vector<PageEncodingStats> encodingStats =
+        this->metadataEncodingStats();
+    if (this->typeNum() == Type::kBoolean) {
+      ASSERT_EQ(encodingStats[0].encoding, Encoding::kPlain);
+      ASSERT_EQ(encodingStats[0].pageType, PageType::kDataPage);
     } else if (version == ParquetVersion::PARQUET_1_0) {
       std::vector<Encoding::type> expected(
-          {Encoding::PLAIN_DICTIONARY,
-           Encoding::PLAIN,
-           Encoding::PLAIN_DICTIONARY});
-      ASSERT_EQ(encoding_stats[0].encoding, expected[0]);
-      ASSERT_EQ(encoding_stats[0].page_type, PageType::DICTIONARY_PAGE);
-      for (size_t i = 1; i < encoding_stats.size(); i++) {
-        ASSERT_EQ(encoding_stats[i].encoding, expected[i]);
-        ASSERT_EQ(encoding_stats[i].page_type, PageType::DATA_PAGE);
+          {Encoding::kPlainDictionary,
+           Encoding::kPlain,
+           Encoding::kPlainDictionary});
+      ASSERT_EQ(encodingStats[0].encoding, expected[0]);
+      ASSERT_EQ(encodingStats[0].pageType, PageType::kDictionaryPage);
+      for (size_t i = 1; i < encodingStats.size(); i++) {
+        ASSERT_EQ(encodingStats[i].encoding, expected[i]);
+        ASSERT_EQ(encodingStats[i].pageType, PageType::kDataPage);
       }
     } else {
       std::vector<Encoding::type> expected(
-          {Encoding::PLAIN, Encoding::PLAIN, Encoding::RLE_DICTIONARY});
-      ASSERT_EQ(encoding_stats[0].encoding, expected[0]);
-      ASSERT_EQ(encoding_stats[0].page_type, PageType::DICTIONARY_PAGE);
-      for (size_t i = 1; i < encoding_stats.size(); i++) {
-        ASSERT_EQ(encoding_stats[i].encoding, expected[i]);
-        ASSERT_EQ(encoding_stats[i].page_type, PageType::DATA_PAGE);
+          {Encoding::kPlain, Encoding::kPlain, Encoding::kRleDictionary});
+      ASSERT_EQ(encodingStats[0].encoding, expected[0]);
+      ASSERT_EQ(encodingStats[0].pageType, PageType::kDictionaryPage);
+      for (size_t i = 1; i < encodingStats.size(); i++) {
+        ASSERT_EQ(encodingStats[i].encoding, expected[i]);
+        ASSERT_EQ(encodingStats[i].pageType, PageType::kDataPage);
       }
     }
   }
 
-  void WriteRequiredWithSettings(
+  void writeRequiredWithSettings(
       Encoding::type encoding,
       Compression::type compression,
-      bool enable_dictionary,
-      bool enable_statistics,
-      int compression_level,
-      int64_t num_rows,
-      bool enable_checksum) {
-    ColumnProperties column_properties(
-        encoding, compression, enable_dictionary, enable_statistics);
-    column_properties.set_compression_level(compression_level);
-    std::shared_ptr<TypedColumnWriter<TestType>> writer = this->BuildWriter(
-        num_rows,
-        column_properties,
-        ParquetVersion::PARQUET_1_0,
-        enable_checksum);
-    writer->WriteBatch(
-        this->values_.size(), nullptr, nullptr, this->values_ptr_);
-    // The behaviour should be independent from the number of Close() calls
-    writer->Close();
-    writer->Close();
+      bool enableDictionary,
+      bool enableStatistics,
+      int compressionLevel,
+      int64_t numRows,
+      bool enableChecksum) {
+    ColumnProperties columnProperties(
+        encoding, compression, enableDictionary, enableStatistics);
+    columnProperties.setCompressionLevel(compressionLevel);
+    std::shared_ptr<TypedColumnWriter<TestType>> writer = this->buildWriter(
+        numRows, columnProperties, ParquetVersion::PARQUET_1_0, enableChecksum);
+    writer->writeBatch(
+        this->values_.size(), nullptr, nullptr, this->valuesPtr_);
+    // The behaviour should be independent from the number of Close() calls.
+    writer->close();
+    writer->close();
   }
 
-  void WriteRequiredWithSettingsSpaced(
+  void writeRequiredWithSettingsSpaced(
       Encoding::type encoding,
       Compression::type compression,
-      bool enable_dictionary,
-      bool enable_statistics,
-      int64_t num_rows,
-      int compression_level,
-      bool enable_checksum) {
-    std::vector<uint8_t> valid_bits(
+      bool enableDictionary,
+      bool enableStatistics,
+      int64_t numRows,
+      int compressionLevel,
+      bool enableChecksum) {
+    std::vector<uint8_t> validBits(
         ::arrow::bit_util::BytesForBits(
             static_cast<uint32_t>(this->values_.size())) +
             1,
         255);
-    ColumnProperties column_properties(
-        encoding, compression, enable_dictionary, enable_statistics);
-    column_properties.set_compression_level(compression_level);
-    std::shared_ptr<TypedColumnWriter<TestType>> writer = this->BuildWriter(
-        num_rows,
-        column_properties,
-        ParquetVersion::PARQUET_1_0,
-        enable_checksum);
-    writer->WriteBatchSpaced(
+    ColumnProperties columnProperties(
+        encoding, compression, enableDictionary, enableStatistics);
+    columnProperties.setCompressionLevel(compressionLevel);
+    std::shared_ptr<TypedColumnWriter<TestType>> writer = this->buildWriter(
+        numRows, columnProperties, ParquetVersion::PARQUET_1_0, enableChecksum);
+    writer->writeBatchSpaced(
         this->values_.size(),
         nullptr,
         nullptr,
-        valid_bits.data(),
+        validBits.data(),
         0,
-        this->values_ptr_);
-    // The behaviour should be independent from the number of Close() calls
-    writer->Close();
-    writer->Close();
+        this->valuesPtr_);
+    // The behaviour should be independent from the number of Close() calls.
+    writer->close();
+    writer->close();
   }
 
-  void ReadAndCompare(
+  void readAndCompare(
       Compression::type compression,
-      int64_t num_rows,
-      bool page_checksum_verify) {
-    this->SetupValuesOut(num_rows);
-    this->ReadColumnFully(compression, page_checksum_verify);
-    auto comparator = MakeComparator<TestType>(this->descr_);
+      int64_t numRows,
+      bool pageChecksumVerify) {
+    this->setupValuesOut(numRows);
+    this->readColumnFully(compression, pageChecksumVerify);
+    auto Comparator = makeComparator<TestType>(this->descr_);
     for (size_t i = 0; i < this->values_.size(); i++) {
-      if (comparator->Compare(this->values_[i], this->values_out_[i]) ||
-          comparator->Compare(this->values_out_[i], this->values_[i])) {
+      if (Comparator->compare(this->values_[i], this->valuesOut_[i]) ||
+          Comparator->compare(this->valuesOut_[i], this->values_[i])) {
         ARROW_SCOPED_TRACE("i = ", i);
       }
-      ASSERT_FALSE(comparator->Compare(this->values_[i], this->values_out_[i]));
-      ASSERT_FALSE(comparator->Compare(this->values_out_[i], this->values_[i]));
+      ASSERT_FALSE(Comparator->compare(this->values_[i], this->valuesOut_[i]));
+      ASSERT_FALSE(Comparator->compare(this->valuesOut_[i], this->values_[i]));
     }
-    ASSERT_EQ(this->values_, this->values_out_);
+    ASSERT_EQ(this->values_, this->valuesOut_);
   }
 
-  int64_t metadata_num_values() {
+  int64_t metadataNumValues() {
     // Metadata accessor must be created lazily.
-    // This is because the ColumnChunkMetaData semantics dictate the metadata
-    // object is complete (no changes to the metadata buffer can be made after
+    // This is because the ColumnChunkMetaData semantics dictate the metadata.
+    // Object is complete (no changes to the metadata buffer can be made after.
     // instantiation)
-    auto metadata_accessor =
-        ColumnChunkMetaData::Make(metadata_->contents(), this->descr_);
-    return metadata_accessor->num_values();
+    auto metadataAccessor =
+        ColumnChunkMetaData::make(metadata_->Contents(), this->descr_);
+    return metadataAccessor->numValues();
   }
 
-  bool metadata_is_stats_set() {
+  bool metadataIsStatsSet() {
     // Metadata accessor must be created lazily.
-    // This is because the ColumnChunkMetaData semantics dictate the metadata
-    // object is complete (no changes to the metadata buffer can be made after
+    // This is because the ColumnChunkMetaData semantics dictate the metadata.
+    // Object is complete (no changes to the metadata buffer can be made after.
     // instantiation)
-    ApplicationVersion app_version(this->writer_properties_->created_by());
-    auto metadata_accessor = ColumnChunkMetaData::Make(
-        metadata_->contents(),
+    ApplicationVersion appVersion(this->writerProperties_->createdBy());
+    auto metadataAccessor = ColumnChunkMetaData::make(
+        metadata_->Contents(),
         this->descr_,
-        default_reader_properties(),
-        &app_version);
-    return metadata_accessor->is_stats_set();
+        defaultReaderProperties(),
+        &appVersion);
+    return metadataAccessor->isStatsSet();
   }
 
-  std::pair<bool, bool> metadata_stats_has_min_max() {
+  std::pair<bool, bool> metadataStatsHasMinMax() {
     // Metadata accessor must be created lazily.
-    // This is because the ColumnChunkMetaData semantics dictate the metadata
-    // object is complete (no changes to the metadata buffer can be made after
+    // This is because the ColumnChunkMetaData semantics dictate the metadata.
+    // Object is complete (no changes to the metadata buffer can be made after.
     // instantiation)
-    ApplicationVersion app_version(this->writer_properties_->created_by());
-    auto metadata_accessor = ColumnChunkMetaData::Make(
-        metadata_->contents(),
+    ApplicationVersion appVersion(this->writerProperties_->createdBy());
+    auto metadataAccessor = ColumnChunkMetaData::make(
+        metadata_->Contents(),
         this->descr_,
-        default_reader_properties(),
-        &app_version);
-    auto encoded_stats = metadata_accessor->statistics()->Encode();
-    return {encoded_stats.has_min, encoded_stats.has_max};
+        defaultReaderProperties(),
+        &appVersion);
+    auto encodedStats = metadataAccessor->statistics()->encode();
+    return {encodedStats.hasMin, encodedStats.hasMax};
   }
 
-  std::vector<Encoding::type> metadata_encodings() {
+  std::vector<Encoding::type> metadataEncodings() {
     // Metadata accessor must be created lazily.
-    // This is because the ColumnChunkMetaData semantics dictate the metadata
-    // object is complete (no changes to the metadata buffer can be made after
+    // This is because the ColumnChunkMetaData semantics dictate the metadata.
+    // Object is complete (no changes to the metadata buffer can be made after.
     // instantiation)
-    auto metadata_accessor =
-        ColumnChunkMetaData::Make(metadata_->contents(), this->descr_);
-    return metadata_accessor->encodings();
+    auto metadataAccessor =
+        ColumnChunkMetaData::make(metadata_->Contents(), this->descr_);
+    return metadataAccessor->encodings();
   }
 
-  std::vector<PageEncodingStats> metadata_encoding_stats() {
+  std::vector<PageEncodingStats> metadataEncodingStats() {
     // Metadata accessor must be created lazily.
-    // This is because the ColumnChunkMetaData semantics dictate the metadata
-    // object is complete (no changes to the metadata buffer can be made after
+    // This is because the ColumnChunkMetaData semantics dictate the metadata.
+    // Object is complete (no changes to the metadata buffer can be made after.
     // instantiation)
-    auto metadata_accessor =
-        ColumnChunkMetaData::Make(metadata_->contents(), this->descr_);
-    return metadata_accessor->encoding_stats();
+    auto metadataAccessor =
+        ColumnChunkMetaData::make(metadata_->Contents(), this->descr_);
+    return metadataAccessor->encodingStats();
   }
 
  protected:
-  int64_t values_read_;
-  // Keep the reader alive as for ByteArray the lifetime of the ByteArray
-  // content is bound to the reader.
+  int64_t valuesRead_;
+  // Keep the reader alive as for ByteArray the lifetime of the ByteArray.
+  // Content is bound to the reader.
   std::shared_ptr<TypedColumnReader<TestType>> reader_;
 
-  std::vector<int16_t> definition_levels_out_;
-  std::vector<int16_t> repetition_levels_out_;
+  std::vector<int16_t> definitionLevelsOut_;
+  std::vector<int16_t> repetitionLevelsOut_;
 
   const ColumnDescriptor* descr_;
 
  private:
   std::unique_ptr<ColumnChunkMetaDataBuilder> metadata_;
   std::shared_ptr<::arrow::io::BufferOutputStream> sink_;
-  std::shared_ptr<WriterProperties> writer_properties_;
-  std::vector<std::vector<uint8_t>> data_buffer_;
+  std::shared_ptr<WriterProperties> writerProperties_;
+  std::vector<std::vector<uint8_t>> dataBuffer_;
 };
 
 template <typename TestType>
-void TestPrimitiveWriter<TestType>::ReadColumnFully(
+void TestPrimitiveWriter<TestType>::readColumnFully(
     Compression::type compression,
-    bool page_checksum_verify) {
-  int64_t total_values = static_cast<int64_t>(this->values_out_.size());
-  BuildReader(total_values, compression, page_checksum_verify);
-  values_read_ = 0;
-  while (values_read_ < total_values) {
-    int64_t values_read_recently = 0;
-    reader_->ReadBatch(
-        static_cast<int>(this->values_out_.size()) -
-            static_cast<int>(values_read_),
-        definition_levels_out_.data() + values_read_,
-        repetition_levels_out_.data() + values_read_,
-        this->values_out_ptr_ + values_read_,
-        &values_read_recently);
-    values_read_ += values_read_recently;
+    bool pageChecksumVerify) {
+  int64_t totalValues = static_cast<int64_t>(this->valuesOut_.size());
+  buildReader(totalValues, compression, pageChecksumVerify);
+  valuesRead_ = 0;
+  while (valuesRead_ < totalValues) {
+    int64_t valuesReadRecently = 0;
+    reader_->readBatch(
+        static_cast<int>(this->valuesOut_.size()) -
+            static_cast<int>(valuesRead_),
+        definitionLevelsOut_.data() + valuesRead_,
+        repetitionLevelsOut_.data() + valuesRead_,
+        this->valuesOutPtr_ + valuesRead_,
+        &valuesReadRecently);
+    valuesRead_ += valuesReadRecently;
   }
-  this->SyncValuesOut();
+  this->syncValuesOut();
 }
 
 template <>
-void TestPrimitiveWriter<Int96Type>::ReadAndCompare(
+void TestPrimitiveWriter<Int96Type>::readAndCompare(
     Compression::type compression,
-    int64_t num_rows,
-    bool page_checksum_verify) {
-  this->SetupValuesOut(num_rows);
-  this->ReadColumnFully(compression, page_checksum_verify);
+    int64_t numRows,
+    bool pageChecksumVerify) {
+  this->setupValuesOut(numRows);
+  this->readColumnFully(compression, pageChecksumVerify);
 
-  auto comparator = MakeComparator<Int96Type>(Type::INT96, SortOrder::SIGNED);
+  auto Comparator = makeComparator<Int96Type>(Type::kInt96, SortOrder::kSigned);
   for (size_t i = 0; i < this->values_.size(); i++) {
-    if (comparator->Compare(this->values_[i], this->values_out_[i]) ||
-        comparator->Compare(this->values_out_[i], this->values_[i])) {
+    if (Comparator->compare(this->values_[i], this->valuesOut_[i]) ||
+        Comparator->compare(this->valuesOut_[i], this->values_[i])) {
       ARROW_SCOPED_TRACE("i = ", i);
     }
-    ASSERT_FALSE(comparator->Compare(this->values_[i], this->values_out_[i]));
-    ASSERT_FALSE(comparator->Compare(this->values_out_[i], this->values_[i]));
+    ASSERT_FALSE(Comparator->compare(this->values_[i], this->valuesOut_[i]));
+    ASSERT_FALSE(Comparator->compare(this->valuesOut_[i], this->values_[i]));
   }
-  ASSERT_EQ(this->values_, this->values_out_);
+  ASSERT_EQ(this->values_, this->valuesOut_);
 }
 
 template <>
-void TestPrimitiveWriter<FLBAType>::ReadColumnFully(
+void TestPrimitiveWriter<FLBAType>::readColumnFully(
     Compression::type compression,
-    bool page_checksum_verify) {
-  int64_t total_values = static_cast<int64_t>(this->values_out_.size());
-  BuildReader(total_values, compression, page_checksum_verify);
-  this->data_buffer_.clear();
-
-  values_read_ = 0;
-  while (values_read_ < total_values) {
-    int64_t values_read_recently = 0;
-    reader_->ReadBatch(
-        static_cast<int>(this->values_out_.size()) -
-            static_cast<int>(values_read_),
-        definition_levels_out_.data() + values_read_,
-        repetition_levels_out_.data() + values_read_,
-        this->values_out_ptr_ + values_read_,
-        &values_read_recently);
-
-    // Copy contents of the pointers
-    std::vector<uint8_t> data(
-        values_read_recently * this->descr_->type_length());
-    uint8_t* data_ptr = data.data();
-    for (int64_t i = 0; i < values_read_recently; i++) {
+    bool pageChecksumVerify) {
+  int64_t totalValues = static_cast<int64_t>(this->valuesOut_.size());
+  buildReader(totalValues, compression, pageChecksumVerify);
+  this->dataBuffer_.clear();
+
+  valuesRead_ = 0;
+  while (valuesRead_ < totalValues) {
+    int64_t valuesReadRecently = 0;
+    reader_->readBatch(
+        static_cast<int>(this->valuesOut_.size()) -
+            static_cast<int>(valuesRead_),
+        definitionLevelsOut_.data() + valuesRead_,
+        repetitionLevelsOut_.data() + valuesRead_,
+        this->valuesOutPtr_ + valuesRead_,
+        &valuesReadRecently);
+
+    // Copy contents of the pointers.
+    std::vector<uint8_t> data(valuesReadRecently * this->descr_->typeLength());
+    uint8_t* dataPtr = data.data();
+    for (int64_t i = 0; i < valuesReadRecently; i++) {
       memcpy(
-          data_ptr + this->descr_->type_length() * i,
-          this->values_out_[i + values_read_].ptr,
-          this->descr_->type_length());
-      this->values_out_[i + values_read_].ptr =
-          data_ptr + this->descr_->type_length() * i;
+          dataPtr + this->descr_->typeLength() * i,
+          this->valuesOut_[i + valuesRead_].ptr,
+          this->descr_->typeLength());
+      this->valuesOut_[i + valuesRead_].ptr =
+          dataPtr + this->descr_->typeLength() * i;
     }
-    data_buffer_.emplace_back(std::move(data));
+    dataBuffer_.emplace_back(std::move(data));
 
-    values_read_ += values_read_recently;
+    valuesRead_ += valuesReadRecently;
   }
-  this->SyncValuesOut();
+  this->syncValuesOut();
 }
 
 typedef ::testing::Types<
@@ -524,11 +516,11 @@ using TestByteArrayValuesWriter = TestPrimitiveWriter<ByteArrayType>;
 using TestFixedLengthByteArrayValuesWriter = TestPrimitiveWriter<FLBAType>;
 
 TYPED_TEST(TestPrimitiveWriter, RequiredPlain) {
-  this->TestRequiredWithEncoding(Encoding::PLAIN);
+  this->testRequiredWithEncoding(Encoding::kPlain);
 }
 
 TYPED_TEST(TestPrimitiveWriter, RequiredDictionary) {
-  this->TestRequiredWithEncoding(Encoding::PLAIN_DICTIONARY);
+  this->testRequiredWithEncoding(Encoding::kPlainDictionary);
 }
 
 /*
@@ -542,15 +534,15 @@ TYPED_TEST(TestPrimitiveWriter, RequiredBitPacked) {
 */
 
 TEST_F(TestValuesWriterInt32Type, RequiredDeltaBinaryPacked) {
-  this->TestRequiredWithEncoding(Encoding::DELTA_BINARY_PACKED);
+  this->testRequiredWithEncoding(Encoding::kDeltaBinaryPacked);
 }
 
 TEST_F(TestValuesWriterInt64Type, RequiredDeltaBinaryPacked) {
-  this->TestRequiredWithEncoding(Encoding::DELTA_BINARY_PACKED);
+  this->testRequiredWithEncoding(Encoding::kDeltaBinaryPacked);
 }
 
 TEST_F(TestByteArrayValuesWriter, RequiredDeltaLengthByteArray) {
-  this->TestRequiredWithEncoding(Encoding::DELTA_LENGTH_BYTE_ARRAY);
+  this->testRequiredWithEncoding(Encoding::kDeltaLengthByteArray);
 }
 
 /*
@@ -564,432 +556,423 @@ TEST_F(TestFixedLengthByteArrayValuesWriter, RequiredDeltaByteArray) {
 */
 
 TYPED_TEST(TestPrimitiveWriter, RequiredRLEDictionary) {
-  this->TestRequiredWithEncoding(Encoding::RLE_DICTIONARY);
+  this->testRequiredWithEncoding(Encoding::kRleDictionary);
 }
 
 TYPED_TEST(TestPrimitiveWriter, RequiredPlainWithStats) {
-  this->TestRequiredWithSettings(
-      Encoding::PLAIN, Compression::UNCOMPRESSED, false, true, LARGE_SIZE);
+  this->testRequiredWithSettings(
+      Encoding::kPlain, Compression::UNCOMPRESSED, false, true, LARGE_SIZE);
 }
 
 TYPED_TEST(TestPrimitiveWriter, RequiredPlainWithSnappyCompression) {
-  this->TestRequiredWithSettings(
-      Encoding::PLAIN, Compression::SNAPPY, false, false, LARGE_SIZE);
+  this->testRequiredWithSettings(
+      Encoding::kPlain, Compression::SNAPPY, false, false, LARGE_SIZE);
 }
 
 TYPED_TEST(TestPrimitiveWriter, RequiredPlainWithStatsAndSnappyCompression) {
-  this->TestRequiredWithSettings(
-      Encoding::PLAIN, Compression::SNAPPY, false, true, LARGE_SIZE);
+  this->testRequiredWithSettings(
+      Encoding::kPlain, Compression::SNAPPY, false, true, LARGE_SIZE);
 }
 
 #ifdef ARROW_WITH_BROTLI
 TYPED_TEST(TestPrimitiveWriter, RequiredPlainWithBrotliCompression) {
-  this->TestRequiredWithSettings(
-      Encoding::PLAIN, Compression::BROTLI, false, false, LARGE_SIZE);
+  this->testRequiredWithSettings(
+      Encoding::kPlain, Compression::BROTLI, false, false, LARGE_SIZE);
 }
 
 TYPED_TEST(TestPrimitiveWriter, RequiredPlainWithBrotliCompressionAndLevel) {
-  this->TestRequiredWithSettings(
-      Encoding::PLAIN, Compression::BROTLI, false, false, LARGE_SIZE, 10);
+  this->testRequiredWithSettings(
+      Encoding::kPlain, Compression::BROTLI, false, false, LARGE_SIZE, 10);
 }
 
 TYPED_TEST(TestPrimitiveWriter, RequiredPlainWithStatsAndBrotliCompression) {
-  this->TestRequiredWithSettings(
-      Encoding::PLAIN, Compression::BROTLI, false, true, LARGE_SIZE);
+  this->testRequiredWithSettings(
+      Encoding::kPlain, Compression::BROTLI, false, true, LARGE_SIZE);
 }
 
 #endif
 
 TYPED_TEST(TestPrimitiveWriter, RequiredPlainWithGzipCompression) {
-  this->TestRequiredWithSettings(
-      Encoding::PLAIN, Compression::GZIP, false, false, LARGE_SIZE);
+  this->testRequiredWithSettings(
+      Encoding::kPlain, Compression::GZIP, false, false, LARGE_SIZE);
 }
 
 TYPED_TEST(TestPrimitiveWriter, RequiredPlainWithGzipCompressionAndLevel) {
-  this->TestRequiredWithSettings(
-      Encoding::PLAIN, Compression::GZIP, false, false, LARGE_SIZE, 10);
+  this->testRequiredWithSettings(
+      Encoding::kPlain, Compression::GZIP, false, false, LARGE_SIZE, 10);
 }
 
 TYPED_TEST(TestPrimitiveWriter, RequiredPlainWithStatsAndGzipCompression) {
-  this->TestRequiredWithSettings(
-      Encoding::PLAIN, Compression::GZIP, false, true, LARGE_SIZE);
+  this->testRequiredWithSettings(
+      Encoding::kPlain, Compression::GZIP, false, true, LARGE_SIZE);
 }
 
 TYPED_TEST(TestPrimitiveWriter, RequiredPlainWithLz4Compression) {
-  this->TestRequiredWithSettings(
-      Encoding::PLAIN, Compression::LZ4, false, false, LARGE_SIZE);
+  this->testRequiredWithSettings(
+      Encoding::kPlain, Compression::LZ4, false, false, LARGE_SIZE);
 }
 
 TYPED_TEST(TestPrimitiveWriter, RequiredPlainWithStatsAndLz4Compression) {
-  this->TestRequiredWithSettings(
-      Encoding::PLAIN, Compression::LZ4, false, true, LARGE_SIZE);
+  this->testRequiredWithSettings(
+      Encoding::kPlain, Compression::LZ4, false, true, LARGE_SIZE);
 }
 
 TYPED_TEST(TestPrimitiveWriter, RequiredPlainWithZstdCompression) {
-  this->TestRequiredWithSettings(
-      Encoding::PLAIN, Compression::ZSTD, false, false, LARGE_SIZE);
+  this->testRequiredWithSettings(
+      Encoding::kPlain, Compression::ZSTD, false, false, LARGE_SIZE);
 }
 
 TYPED_TEST(TestPrimitiveWriter, RequiredPlainWithZstdCompressionAndLevel) {
-  this->TestRequiredWithSettings(
-      Encoding::PLAIN, Compression::ZSTD, false, false, LARGE_SIZE, 6);
+  this->testRequiredWithSettings(
+      Encoding::kPlain, Compression::ZSTD, false, false, LARGE_SIZE, 6);
 }
 
 TYPED_TEST(TestPrimitiveWriter, RequiredPlainWithStatsAndZstdCompression) {
-  this->TestRequiredWithSettings(
-      Encoding::PLAIN, Compression::ZSTD, false, true, LARGE_SIZE);
+  this->testRequiredWithSettings(
+      Encoding::kPlain, Compression::ZSTD, false, true, LARGE_SIZE);
 }
 
 TYPED_TEST(TestPrimitiveWriter, Optional) {
-  // Optional and non-repeated, with definition levels
-  // but no repetition levels
-  this->SetUpSchema(Repetition::OPTIONAL);
+  // Optional and non-repeated, with definition levels.
+  // But no repetition levels.
+  this->setUpSchema(Repetition::kOptional);
 
-  this->GenerateData(SMALL_SIZE);
-  std::vector<int16_t> definition_levels(SMALL_SIZE, 1);
-  definition_levels[1] = 0;
+  this->generateData(SMALL_SIZE);
+  std::vector<int16_t> definitionLevels(SMALL_SIZE, 1);
+  definitionLevels[1] = 0;
 
-  auto writer = this->BuildWriter();
-  writer->WriteBatch(
-      this->values_.size(),
-      definition_levels.data(),
-      nullptr,
-      this->values_ptr_);
-  writer->Close();
+  auto writer = this->buildWriter();
+  writer->writeBatch(
+      this->values_.size(), definitionLevels.data(), nullptr, this->valuesPtr_);
+  writer->close();
 
-  // PARQUET-703
-  ASSERT_EQ(100, this->metadata_num_values());
+  // PARQUET-703.
+  ASSERT_EQ(100, this->metadataNumValues());
 
-  this->ReadColumn();
-  ASSERT_EQ(99, this->values_read_);
-  this->values_out_.resize(99);
+  this->readColumn();
+  ASSERT_EQ(99, this->valuesRead_);
+  this->valuesOut_.resize(99);
   this->values_.resize(99);
-  ASSERT_EQ(this->values_, this->values_out_);
+  ASSERT_EQ(this->values_, this->valuesOut_);
 }
 
 TYPED_TEST(TestPrimitiveWriter, OptionalSpaced) {
-  // Optional and non-repeated, with definition levels
-  // but no repetition levels
-  this->SetUpSchema(Repetition::OPTIONAL);
+  // Optional and non-repeated, with definition levels.
+  // But no repetition levels.
+  this->setUpSchema(Repetition::kOptional);
 
-  this->GenerateData(SMALL_SIZE);
-  std::vector<int16_t> definition_levels(SMALL_SIZE, 1);
-  std::vector<uint8_t> valid_bits(
+  this->generateData(SMALL_SIZE);
+  std::vector<int16_t> definitionLevels(SMALL_SIZE, 1);
+  std::vector<uint8_t> validBits(
       ::arrow::bit_util::BytesForBits(SMALL_SIZE), 255);
 
-  definition_levels[SMALL_SIZE - 1] = 0;
-  ::arrow::bit_util::ClearBit(valid_bits.data(), SMALL_SIZE - 1);
-  definition_levels[1] = 0;
-  ::arrow::bit_util::ClearBit(valid_bits.data(), 1);
+  definitionLevels[SMALL_SIZE - 1] = 0;
+  ::arrow::bit_util::ClearBit(validBits.data(), SMALL_SIZE - 1);
+  definitionLevels[1] = 0;
+  ::arrow::bit_util::ClearBit(validBits.data(), 1);
 
-  auto writer = this->BuildWriter();
-  writer->WriteBatchSpaced(
+  auto writer = this->buildWriter();
+  writer->writeBatchSpaced(
       this->values_.size(),
-      definition_levels.data(),
+      definitionLevels.data(),
       nullptr,
-      valid_bits.data(),
+      validBits.data(),
       0,
-      this->values_ptr_);
-  writer->Close();
+      this->valuesPtr_);
+  writer->close();
 
-  // PARQUET-703
-  ASSERT_EQ(100, this->metadata_num_values());
+  // PARQUET-703.
+  ASSERT_EQ(100, this->metadataNumValues());
 
-  this->ReadColumn();
-  ASSERT_EQ(98, this->values_read_);
-  this->values_out_.resize(98);
+  this->readColumn();
+  ASSERT_EQ(98, this->valuesRead_);
+  this->valuesOut_.resize(98);
   this->values_.resize(99);
   this->values_.erase(this->values_.begin() + 1);
-  ASSERT_EQ(this->values_, this->values_out_);
+  ASSERT_EQ(this->values_, this->valuesOut_);
 }
 
 TYPED_TEST(TestPrimitiveWriter, Repeated) {
-  // Optional and repeated, so definition and repetition levels
-  this->SetUpSchema(Repetition::REPEATED);
+  // Optional and repeated, so definition and repetition levels.
+  this->setUpSchema(Repetition::kRepeated);
 
-  this->GenerateData(SMALL_SIZE);
-  std::vector<int16_t> definition_levels(SMALL_SIZE, 1);
-  definition_levels[1] = 0;
-  std::vector<int16_t> repetition_levels(SMALL_SIZE, 0);
+  this->generateData(SMALL_SIZE);
+  std::vector<int16_t> definitionLevels(SMALL_SIZE, 1);
+  definitionLevels[1] = 0;
+  std::vector<int16_t> repetitionLevels(SMALL_SIZE, 0);
 
-  auto writer = this->BuildWriter();
-  writer->WriteBatch(
+  auto writer = this->buildWriter();
+  writer->writeBatch(
       this->values_.size(),
-      definition_levels.data(),
-      repetition_levels.data(),
-      this->values_ptr_);
-  writer->Close();
-
-  this->ReadColumn();
-  ASSERT_EQ(SMALL_SIZE - 1, this->values_read_);
-  this->values_out_.resize(SMALL_SIZE - 1);
+      definitionLevels.data(),
+      repetitionLevels.data(),
+      this->valuesPtr_);
+  writer->close();
+
+  this->readColumn();
+  ASSERT_EQ(SMALL_SIZE - 1, this->valuesRead_);
+  this->valuesOut_.resize(SMALL_SIZE - 1);
   this->values_.resize(SMALL_SIZE - 1);
-  ASSERT_EQ(this->values_, this->values_out_);
+  ASSERT_EQ(this->values_, this->valuesOut_);
 }
 
 TYPED_TEST(TestPrimitiveWriter, RequiredLargeChunk) {
-  this->GenerateData(LARGE_SIZE);
+  this->generateData(LARGE_SIZE);
 
-  // Test case 1: required and non-repeated, so no definition or repetition
-  // levels
-  auto writer = this->BuildWriter(LARGE_SIZE);
-  writer->WriteBatch(this->values_.size(), nullptr, nullptr, this->values_ptr_);
-  writer->Close();
+  // Test case 1: required and non-repeated, so no definition or repetition.
+  // Levels.
+  auto writer = this->buildWriter(LARGE_SIZE);
+  writer->writeBatch(this->values_.size(), nullptr, nullptr, this->valuesPtr_);
+  writer->close();
 
-  // Just read the first SMALL_SIZE rows to ensure we could read it back in
-  this->ReadColumn();
-  ASSERT_EQ(SMALL_SIZE, this->values_read_);
+  // Just read the first SMALL_SIZE rows to ensure we could read it back in.
+  this->readColumn();
+  ASSERT_EQ(SMALL_SIZE, this->valuesRead_);
   this->values_.resize(SMALL_SIZE);
-  ASSERT_EQ(this->values_, this->values_out_);
+  ASSERT_EQ(this->values_, this->valuesOut_);
 }
 
-// Test cases for dictionary fallback encoding
-TYPED_TEST(TestPrimitiveWriter, DictionaryFallbackVersion1_0) {
-  this->TestDictionaryFallbackEncoding(ParquetVersion::PARQUET_1_0);
+// Test cases for dictionary fallback encoding.
+TYPED_TEST(TestPrimitiveWriter, dictionaryfallbackversion10) {
+  this->testDictionaryFallbackEncoding(ParquetVersion::PARQUET_1_0);
 }
 
-TYPED_TEST(TestPrimitiveWriter, DictionaryFallbackVersion2_0) {
-  this->TestDictionaryFallbackEncoding(ParquetVersion::PARQUET_2_4);
-  this->TestDictionaryFallbackEncoding(ParquetVersion::PARQUET_2_6);
+TYPED_TEST(TestPrimitiveWriter, dictionaryfallbackversion20) {
+  this->testDictionaryFallbackEncoding(ParquetVersion::PARQUET_2_4);
+  this->testDictionaryFallbackEncoding(ParquetVersion::PARQUET_2_6);
 }
 
 TEST(TestWriter, NullValuesBuffer) {
-  std::shared_ptr<::arrow::io::BufferOutputStream> sink = CreateOutputStream();
-
-  const auto item_node = schema::PrimitiveNode::Make(
-      "item", Repetition::REQUIRED, LogicalType::Int(32, true), Type::INT32);
-  const auto list_node =
-      schema::GroupNode::Make("list", Repetition::REPEATED, {item_node});
-  const auto column_node = schema::GroupNode::Make(
+  std::shared_ptr<::arrow::io::BufferOutputStream> sink = createOutputStream();
+
+  const auto itemNode = schema::PrimitiveNode::make(
+      "item",
+      Repetition::kRequired,
+      LogicalType::intType(32, true),
+      Type::kInt32);
+  const auto listNode =
+      schema::GroupNode::make("list", Repetition::kRepeated, {itemNode});
+  const auto columnNode = schema::GroupNode::make(
       "array_of_ints_column",
-      Repetition::OPTIONAL,
-      {list_node},
-      LogicalType::List());
-  const auto schema_node =
-      schema::GroupNode::Make("schema", Repetition::REQUIRED, {column_node});
-
-  auto file_writer = ParquetFileWriter::Open(
-      sink, std::dynamic_pointer_cast<schema::GroupNode>(schema_node));
-  auto group_writer = file_writer->AppendRowGroup();
-  auto column_writer = group_writer->NextColumn();
-  auto typed_writer = dynamic_cast<Int32Writer*>(column_writer);
-
-  const int64_t num_values = 1;
-  const int16_t def_levels[] = {0};
-  const int16_t rep_levels[] = {0};
-  const uint8_t valid_bits[] = {0};
-  const int64_t valid_bits_offset = 0;
+      Repetition::kOptional,
+      {listNode},
+      LogicalType::list());
+  const auto schemaNode =
+      schema::GroupNode::make("schema", Repetition::kRequired, {columnNode});
+
+  auto fileWriter = ParquetFileWriter::open(
+      sink, std::dynamic_pointer_cast<schema::GroupNode>(schemaNode));
+  auto groupWriter = fileWriter->appendRowGroup();
+  auto columnWriter = groupWriter->nextColumn();
+  auto typedWriter = dynamic_cast<Int32Writer*>(columnWriter);
+
+  const int64_t numValues = 1;
+  const int16_t defLevels[] = {0};
+  const int16_t repLevels[] = {0};
+  const uint8_t validBits[] = {0};
+  const int64_t validBitsOffset = 0;
   const int32_t* values = nullptr;
 
-  typed_writer->WriteBatchSpaced(
-      num_values,
-      def_levels,
-      rep_levels,
-      valid_bits,
-      valid_bits_offset,
-      values);
+  typedWriter->writeBatchSpaced(
+      numValues, defLevels, repLevels, validBits, validBitsOffset, values);
 }
 
 TYPED_TEST(TestPrimitiveWriter, RequiredPlainChecksum) {
-  this->TestRequiredWithSettings(
-      Encoding::PLAIN,
+  this->testRequiredWithSettings(
+      Encoding::kPlain,
       Compression::UNCOMPRESSED,
       /* enable_dictionary */ false,
       false,
       SMALL_SIZE,
-      Codec::UseDefaultCompressionLevel(),
+      Codec::useDefaultCompressionLevel(),
       /* enable_checksum */ true);
 }
 
 TYPED_TEST(TestPrimitiveWriter, RequiredDictChecksum) {
-  this->TestRequiredWithSettings(
-      Encoding::PLAIN,
+  this->testRequiredWithSettings(
+      Encoding::kPlain,
       Compression::UNCOMPRESSED,
       /* enable_dictionary */ true,
       false,
       SMALL_SIZE,
-      Codec::UseDefaultCompressionLevel(),
+      Codec::useDefaultCompressionLevel(),
       /* enable_checksum */ true);
 }
 
-// PARQUET-719
-// Test case for NULL values
+// PARQUET-719.
+// Test case for NULL values.
 TEST_F(TestValuesWriterInt32Type, OptionalNullValueChunk) {
-  this->SetUpSchema(Repetition::OPTIONAL);
+  this->setUpSchema(Repetition::kOptional);
 
-  this->GenerateData(LARGE_SIZE);
+  this->generateData(LARGE_SIZE);
 
-  std::vector<int16_t> definition_levels(LARGE_SIZE, 0);
-  std::vector<int16_t> repetition_levels(LARGE_SIZE, 0);
+  std::vector<int16_t> definitionLevels(LARGE_SIZE, 0);
+  std::vector<int16_t> repetitionLevels(LARGE_SIZE, 0);
 
-  auto writer = this->BuildWriter(LARGE_SIZE);
-  // All values being written are NULL
-  writer->WriteBatch(
+  auto writer = this->buildWriter(LARGE_SIZE);
+  // All values being written are NULL.
+  writer->writeBatch(
       this->values_.size(),
-      definition_levels.data(),
-      repetition_levels.data(),
+      definitionLevels.data(),
+      repetitionLevels.data(),
       nullptr);
-  writer->Close();
+  writer->close();
 
-  // Just read the first SMALL_SIZE rows to ensure we could read it back in
-  this->ReadColumn();
-  ASSERT_EQ(0, this->values_read_);
+  // Just read the first SMALL_SIZE rows to ensure we could read it back in.
+  this->readColumn();
+  ASSERT_EQ(0, this->valuesRead_);
 }
 
-// PARQUET-764
-// Correct bitpacking for boolean write at non-byte boundaries
+// PARQUET-764.
+// Correct bitpacking for boolean write at non-byte boundaries.
 using TestBooleanValuesWriter = TestPrimitiveWriter<BooleanType>;
 TEST_F(TestBooleanValuesWriter, AlternateBooleanValues) {
-  this->SetUpSchema(Repetition::REQUIRED);
-  auto writer = this->BuildWriter();
+  this->setUpSchema(Repetition::kRequired);
+  auto writer = this->buildWriter();
   for (int i = 0; i < SMALL_SIZE; i++) {
     bool value = (i % 2 == 0) ? true : false;
-    writer->WriteBatch(1, nullptr, nullptr, &value);
+    writer->writeBatch(1, nullptr, nullptr, &value);
   }
-  writer->Close();
-  this->ReadColumn();
+  writer->close();
+  this->readColumn();
   for (int i = 0; i < SMALL_SIZE; i++) {
-    ASSERT_EQ((i % 2 == 0) ? true : false, this->values_out_[i]) << i;
+    ASSERT_EQ((i % 2 == 0) ? true : false, this->valuesOut_[i]) << i;
   }
 }
 
-// PARQUET-979
-// Prevent writing large MIN, MAX stats
+// PARQUET-979.
+// Prevent writing large MIN, MAX stats.
 TEST_F(TestByteArrayValuesWriter, OmitStats) {
-  int min_len = 1024 * 4;
-  int max_len = 1024 * 8;
-  this->SetUpSchema(Repetition::REQUIRED);
-  auto writer = this->BuildWriter();
+  int minLen = 1024 * 4;
+  int maxLen = 1024 * 8;
+  this->setUpSchema(Repetition::kRequired);
+  auto writer = this->buildWriter();
 
   values_.resize(SMALL_SIZE);
-  InitWideByteArrayValues(
-      SMALL_SIZE, this->values_, this->buffer_, min_len, max_len);
-  writer->WriteBatch(SMALL_SIZE, nullptr, nullptr, this->values_.data());
-  writer->Close();
-
-  auto has_min_max = this->metadata_stats_has_min_max();
-  ASSERT_FALSE(has_min_max.first);
-  ASSERT_FALSE(has_min_max.second);
+  initWideByteArrayValues(
+      SMALL_SIZE, this->values_, this->buffer_, minLen, maxLen);
+  writer->writeBatch(SMALL_SIZE, nullptr, nullptr, this->values_.data());
+  writer->close();
+
+  auto hasMinMax = this->metadataStatsHasMinMax();
+  ASSERT_FALSE(hasMinMax.first);
+  ASSERT_FALSE(hasMinMax.second);
 }
 
-// PARQUET-1405
-// Prevent writing large stats in the DataPageHeader
+// PARQUET-1405.
+// Prevent writing large stats in the DataPageHeader.
 TEST_F(TestByteArrayValuesWriter, OmitDataPageStats) {
-  int min_len = static_cast<int>(std::pow(10, 7));
-  int max_len = static_cast<int>(std::pow(10, 7));
-  this->SetUpSchema(Repetition::REQUIRED);
-  ColumnProperties column_properties;
-  column_properties.set_statistics_enabled(false);
-  auto writer = this->BuildWriter(SMALL_SIZE, column_properties);
+  int minLen = static_cast<int>(std::pow(10, 7));
+  int maxLen = static_cast<int>(std::pow(10, 7));
+  this->setUpSchema(Repetition::kRequired);
+  ColumnProperties columnProperties;
+  columnProperties.setStatisticsEnabled(false);
+  auto writer = this->buildWriter(SMALL_SIZE, columnProperties);
 
   values_.resize(1);
-  InitWideByteArrayValues(1, this->values_, this->buffer_, min_len, max_len);
-  writer->WriteBatch(1, nullptr, nullptr, this->values_.data());
-  writer->Close();
+  initWideByteArrayValues(1, this->values_, this->buffer_, minLen, maxLen);
+  writer->writeBatch(1, nullptr, nullptr, this->values_.data());
+  writer->close();
 
-  ASSERT_NO_THROW(this->ReadColumn());
+  ASSERT_NO_THROW(this->readColumn());
 }
 
 TEST_F(TestByteArrayValuesWriter, LimitStats) {
-  int min_len = 1024 * 4;
-  int max_len = 1024 * 8;
-  this->SetUpSchema(Repetition::REQUIRED);
-  ColumnProperties column_properties;
-  column_properties.set_max_statistics_size(static_cast<size_t>(max_len));
-  auto writer = this->BuildWriter(SMALL_SIZE, column_properties);
+  int minLen = 1024 * 4;
+  int maxLen = 1024 * 8;
+  this->setUpSchema(Repetition::kRequired);
+  ColumnProperties columnProperties;
+  columnProperties.setMaxStatisticsSize(static_cast<size_t>(maxLen));
+  auto writer = this->buildWriter(SMALL_SIZE, columnProperties);
 
   values_.resize(SMALL_SIZE);
-  InitWideByteArrayValues(
-      SMALL_SIZE, this->values_, this->buffer_, min_len, max_len);
-  writer->WriteBatch(SMALL_SIZE, nullptr, nullptr, this->values_.data());
-  writer->Close();
+  initWideByteArrayValues(
+      SMALL_SIZE, this->values_, this->buffer_, minLen, maxLen);
+  writer->writeBatch(SMALL_SIZE, nullptr, nullptr, this->values_.data());
+  writer->close();
 
-  ASSERT_TRUE(this->metadata_is_stats_set());
+  ASSERT_TRUE(this->metadataIsStatsSet());
 }
 
 TEST_F(TestByteArrayValuesWriter, CheckDefaultStats) {
-  this->SetUpSchema(Repetition::REQUIRED);
-  auto writer = this->BuildWriter();
-  this->GenerateData(SMALL_SIZE);
+  this->setUpSchema(Repetition::kRequired);
+  auto writer = this->buildWriter();
+  this->generateData(SMALL_SIZE);
 
-  writer->WriteBatch(SMALL_SIZE, nullptr, nullptr, this->values_ptr_);
-  writer->Close();
+  writer->writeBatch(SMALL_SIZE, nullptr, nullptr, this->valuesPtr_);
+  writer->close();
 
-  ASSERT_TRUE(this->metadata_is_stats_set());
+  ASSERT_TRUE(this->metadataIsStatsSet());
 }
 
 TEST(TestColumnWriter, RepeatedListsUpdateSpacedBug) {
-  // In ARROW-3930 we discovered a bug when writing from Arrow when we had data
-  // that looks like this:
+  // In ARROW-3930 we discovered a bug when writing from Arrow when we had data.
+  // That looks like this:
   //
-  // [null, [0, 1, null, 2, 3, 4, null]]
+  // [Null, [0, 1, null, 2, 3, 4, null]].
 
-  // Create schema
-  NodePtr item = schema::Int32("item"); // optional item
-  NodePtr list(
-      GroupNode::Make("b", Repetition::REPEATED, {item}, ConvertedType::LIST));
+  // Create schema.
+  NodePtr item = schema::int32("item"); // optional item
+  NodePtr List(
+      GroupNode::make(
+          "b", Repetition::kRepeated, {item}, ConvertedType::kList));
   NodePtr bag(
-      GroupNode::Make("bag", Repetition::OPTIONAL, {list})); // optional list
+      GroupNode::make("bag", Repetition::kOptional, {List})); // optional list
   std::vector<NodePtr> fields = {bag};
-  NodePtr root = GroupNode::Make("schema", Repetition::REPEATED, fields);
+  NodePtr root = GroupNode::make("schema", Repetition::kRepeated, fields);
 
   SchemaDescriptor schema;
-  schema.Init(root);
+  schema.init(root);
 
-  auto sink = CreateOutputStream();
+  auto sink = createOutputStream();
   auto props = WriterProperties::Builder().build();
 
-  auto metadata = ColumnChunkMetaDataBuilder::Make(props, schema.Column(0));
-  std::unique_ptr<PageWriter> pager = PageWriter::Open(
+  auto metadata = ColumnChunkMetaDataBuilder::make(props, schema.column(0));
+  std::unique_ptr<PageWriter> pager = PageWriter::open(
       sink,
       Compression::UNCOMPRESSED,
-      Codec::UseDefaultCompressionLevel(),
+      Codec::useDefaultCompressionLevel(),
       metadata.get());
   std::shared_ptr<ColumnWriter> writer =
-      ColumnWriter::Make(metadata.get(), std::move(pager), props.get());
-  auto typed_writer =
+      ColumnWriter::make(metadata.get(), std::move(pager), props.get());
+  auto typedWriter =
       std::static_pointer_cast<TypedColumnWriter<Int32Type>>(writer);
 
-  std::vector<int16_t> def_levels = {1, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 3};
-  std::vector<int16_t> rep_levels = {0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+  std::vector<int16_t> defLevels = {1, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 3};
+  std::vector<int16_t> repLevels = {0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
   std::vector<int32_t> values = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
 
-  // Write the values into uninitialized memory
-  ASSERT_OK_AND_ASSIGN(auto values_buffer, ::arrow::AllocateBuffer(64));
-  memcpy(values_buffer->mutable_data(), values.data(), 13 * sizeof(int32_t));
-  auto values_data = reinterpret_cast<const int32_t*>(values_buffer->data());
+  // Write the values into uninitialized memory.
+  ASSERT_OK_AND_ASSIGN(auto valuesBuffer, ::arrow::AllocateBuffer(64));
+  memcpy(valuesBuffer->mutable_data(), values.data(), 13 * sizeof(int32_t));
+  auto valuesData = reinterpret_cast<const int32_t*>(valuesBuffer->data());
 
-  std::shared_ptr<Buffer> valid_bits;
+  std::shared_ptr<Buffer> validBits;
   ASSERT_OK_AND_ASSIGN(
-      valid_bits,
+      validBits,
       ::arrow::internal::BytesToBits({1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1}));
 
-  // valgrind will warn about out of bounds access into def_levels_data
-  typed_writer->WriteBatchSpaced(
-      14,
-      def_levels.data(),
-      rep_levels.data(),
-      valid_bits->data(),
-      0,
-      values_data);
-  writer->Close();
+  // Valgrind will warn about out of bounds access into def_levels_data.
+  typedWriter->writeBatchSpaced(
+      14, defLevels.data(), repLevels.data(), validBits->data(), 0, valuesData);
+  writer->close();
 }
 
-void GenerateLevels(
-    int min_repeat_factor,
-    int max_repeat_factor,
-    int max_level,
-    std::vector<int16_t>& input_levels) {
-  // for each repetition count up to max_repeat_factor
-  for (int repeat = min_repeat_factor; repeat <= max_repeat_factor; repeat++) {
-    // repeat count increases by a factor of 2 for every iteration
-    int repeat_count = (1 << repeat);
-    // generate levels for repetition count up to the maximum level
+void generateLevels(
+    int minRepeatFactor,
+    int maxRepeatFactor,
+    int maxLevel,
+    std::vector<int16_t>& inputLevels) {
+  // For each repetition count up to max_repeat_factor.
+  for (int repeat = minRepeatFactor; repeat <= maxRepeatFactor; repeat++) {
+    // Repeat count increases by a factor of 2 for every iteration.
+    int repeatCount = (1 << repeat);
+    // Generate levels for repetition count up to the maximum level.
     int16_t value = 0;
     int bwidth = 0;
-    while (value <= max_level) {
-      for (int i = 0; i < repeat_count; i++) {
-        input_levels.push_back(value);
+    while (value <= maxLevel) {
+      for (int i = 0; i < repeatCount; i++) {
+        inputLevels.push_back(value);
       }
       value = static_cast<int16_t>((2 << bwidth) - 1);
       bwidth++;
@@ -997,186 +980,185 @@ void GenerateLevels(
   }
 }
 
-void EncodeLevels(
+void encodeLevels(
     Encoding::type encoding,
-    int16_t max_level,
-    int num_levels,
-    const int16_t* input_levels,
+    int16_t maxLevel,
+    int numLevels,
+    const int16_t* inputLevels,
     std::vector<uint8_t>& bytes) {
   LevelEncoder encoder;
-  int levels_count = 0;
-  bytes.resize(2 * num_levels);
-  ASSERT_EQ(2 * num_levels, static_cast<int>(bytes.size()));
-  // encode levels
-  if (encoding == Encoding::RLE) {
-    // leave space to write the rle length value
-    encoder.Init(
+  int levelsCount = 0;
+  bytes.resize(2 * numLevels);
+  ASSERT_EQ(2 * numLevels, static_cast<int>(bytes.size()));
+  // Encode levels.
+  if (encoding == Encoding::kRle) {
+    // Leave space to write the rle length value.
+    encoder.init(
         encoding,
-        max_level,
-        num_levels,
+        maxLevel,
+        numLevels,
         bytes.data() + sizeof(int32_t),
         static_cast<int>(bytes.size()));
 
-    levels_count = encoder.Encode(num_levels, input_levels);
+    levelsCount = encoder.encode(numLevels, inputLevels);
     (reinterpret_cast<int32_t*>(bytes.data()))[0] = encoder.len();
   } else {
-    encoder.Init(
+    encoder.init(
         encoding,
-        max_level,
-        num_levels,
+        maxLevel,
+        numLevels,
         bytes.data(),
         static_cast<int>(bytes.size()));
-    levels_count = encoder.Encode(num_levels, input_levels);
+    levelsCount = encoder.encode(numLevels, inputLevels);
   }
-  ASSERT_EQ(num_levels, levels_count);
+  ASSERT_EQ(numLevels, levelsCount);
 }
 
-void VerifyDecodingLevels(
+void verifyDecodingLevels(
     Encoding::type encoding,
-    int16_t max_level,
-    std::vector<int16_t>& input_levels,
+    int16_t maxLevel,
+    std::vector<int16_t>& inputLevels,
     std::vector<uint8_t>& bytes) {
   LevelDecoder decoder;
-  int levels_count = 0;
-  std::vector<int16_t> output_levels;
-  int num_levels = static_cast<int>(input_levels.size());
+  int levelsCount = 0;
+  std::vector<int16_t> outputLevels;
+  int numLevels = static_cast<int>(inputLevels.size());
 
-  output_levels.resize(num_levels);
-  ASSERT_EQ(num_levels, static_cast<int>(output_levels.size()));
+  outputLevels.resize(numLevels);
+  ASSERT_EQ(numLevels, static_cast<int>(outputLevels.size()));
 
-  // Decode levels and test with multiple decode calls
-  decoder.SetData(
+  // Decode levels and test with multiple decode calls.
+  decoder.setData(
       encoding,
-      max_level,
-      num_levels,
+      maxLevel,
+      numLevels,
       bytes.data(),
       static_cast<int32_t>(bytes.size()));
-  int decode_count = 4;
-  int num_inner_levels = num_levels / decode_count;
-  // Try multiple decoding on a single SetData call
-  for (int ct = 0; ct < decode_count; ct++) {
-    int offset = ct * num_inner_levels;
-    levels_count = decoder.Decode(num_inner_levels, output_levels.data());
-    ASSERT_EQ(num_inner_levels, levels_count);
-    for (int i = 0; i < num_inner_levels; i++) {
-      EXPECT_EQ(input_levels[i + offset], output_levels[i]);
+  int decodeCount = 4;
+  int numInnerLevels = numLevels / decodeCount;
+  // Try multiple decoding on a single SetData call.
+  for (int ct = 0; ct < decodeCount; ct++) {
+    int Offset = ct * numInnerLevels;
+    levelsCount = decoder.decode(numInnerLevels, outputLevels.data());
+    ASSERT_EQ(numInnerLevels, levelsCount);
+    for (int i = 0; i < numInnerLevels; i++) {
+      EXPECT_EQ(inputLevels[i + Offset], outputLevels[i]);
     }
   }
-  // check the remaining levels
-  int num_levels_completed = decode_count * (num_levels / decode_count);
-  int num_remaining_levels = num_levels - num_levels_completed;
-  if (num_remaining_levels > 0) {
-    levels_count = decoder.Decode(num_remaining_levels, output_levels.data());
-    ASSERT_EQ(num_remaining_levels, levels_count);
-    for (int i = 0; i < num_remaining_levels; i++) {
-      EXPECT_EQ(input_levels[i + num_levels_completed], output_levels[i]);
+  // Check the remaining levels.
+  int numLevelsCompleted = decodeCount * (numLevels / decodeCount);
+  int numRemainingLevels = numLevels - numLevelsCompleted;
+  if (numRemainingLevels > 0) {
+    levelsCount = decoder.decode(numRemainingLevels, outputLevels.data());
+    ASSERT_EQ(numRemainingLevels, levelsCount);
+    for (int i = 0; i < numRemainingLevels; i++) {
+      EXPECT_EQ(inputLevels[i + numLevelsCompleted], outputLevels[i]);
     }
   }
-  // Test zero Decode values
-  ASSERT_EQ(0, decoder.Decode(1, output_levels.data()));
+  // Test zero Decode values.
+  ASSERT_EQ(0, decoder.decode(1, outputLevels.data()));
 }
 
-void VerifyDecodingMultipleSetData(
+void verifyDecodingMultipleSetData(
     Encoding::type encoding,
-    int16_t max_level,
-    std::vector<int16_t>& input_levels,
+    int16_t maxLevel,
+    std::vector<int16_t>& inputLevels,
     std::vector<std::vector<uint8_t>>& bytes) {
   LevelDecoder decoder;
-  int levels_count = 0;
-  std::vector<int16_t> output_levels;
-
-  // Decode levels and test with multiple SetData calls
-  int setdata_count = static_cast<int>(bytes.size());
-  int num_levels = static_cast<int>(input_levels.size()) / setdata_count;
-  output_levels.resize(num_levels);
-  // Try multiple SetData
-  for (int ct = 0; ct < setdata_count; ct++) {
-    int offset = ct * num_levels;
-    ASSERT_EQ(num_levels, static_cast<int>(output_levels.size()));
-    decoder.SetData(
+  int levelsCount = 0;
+  std::vector<int16_t> outputLevels;
+
+  // Decode levels and test with multiple SetData calls.
+  int setdataCount = static_cast<int>(bytes.size());
+  int numLevels = static_cast<int>(inputLevels.size()) / setdataCount;
+  outputLevels.resize(numLevels);
+  // Try multiple SetData.
+  for (int ct = 0; ct < setdataCount; ct++) {
+    int Offset = ct * numLevels;
+    ASSERT_EQ(numLevels, static_cast<int>(outputLevels.size()));
+    decoder.setData(
         encoding,
-        max_level,
-        num_levels,
+        maxLevel,
+        numLevels,
         bytes[ct].data(),
         static_cast<int32_t>(bytes[ct].size()));
-    levels_count = decoder.Decode(num_levels, output_levels.data());
-    ASSERT_EQ(num_levels, levels_count);
-    for (int i = 0; i < num_levels; i++) {
-      EXPECT_EQ(input_levels[i + offset], output_levels[i]);
+    levelsCount = decoder.decode(numLevels, outputLevels.data());
+    ASSERT_EQ(numLevels, levelsCount);
+    for (int i = 0; i < numLevels; i++) {
+      EXPECT_EQ(inputLevels[i + Offset], outputLevels[i]);
     }
   }
 }
 
-// Test levels with maximum bit-width from 1 to 8
-// increase the repetition count for each iteration by a factor of 2
+// Test levels with maximum bit-width from 1 to 8.
+// Increase the repetition count for each iteration by a factor of 2.
 TEST(TestLevels, TestLevelsDecodeMultipleBitWidth) {
-  int min_repeat_factor = 0;
-  int max_repeat_factor = 7; // 128
-  int max_bit_width = 8;
-  std::vector<int16_t> input_levels;
+  int minRepeatFactor = 0;
+  int maxRepeatFactor = 7; // 128
+  int maxBitWidth = 8;
+  std::vector<int16_t> inputLevels;
   std::vector<uint8_t> bytes;
-  Encoding::type encodings[2] = {Encoding::RLE, Encoding::BIT_PACKED};
+  Encoding::type encodings[2] = {Encoding::kRle, Encoding::kBitPacked};
 
-  // for each encoding
+  // For each encoding.
   for (int encode = 0; encode < 2; encode++) {
     Encoding::type encoding = encodings[encode];
-    // BIT_PACKED requires a sequence of at least 8
-    if (encoding == Encoding::BIT_PACKED)
-      min_repeat_factor = 3;
-    // for each maximum bit-width
-    for (int bit_width = 1; bit_width <= max_bit_width; bit_width++) {
-      // find the maximum level for the current bit_width
-      int16_t max_level = static_cast<int16_t>((1 << bit_width) - 1);
-      // Generate levels
-      GenerateLevels(
-          min_repeat_factor, max_repeat_factor, max_level, input_levels);
-      ASSERT_NO_FATAL_FAILURE(EncodeLevels(
+    // BIT_PACKED requires a sequence of at least 8.
+    if (encoding == Encoding::kBitPacked)
+      minRepeatFactor = 3;
+    // For each maximum bit-width.
+    for (int bitWidth = 1; bitWidth <= maxBitWidth; bitWidth++) {
+      // Find the maximum level for the current bit_width.
+      int16_t maxLevel = static_cast<int16_t>((1 << bitWidth) - 1);
+      // Generate levels.
+      generateLevels(minRepeatFactor, maxRepeatFactor, maxLevel, inputLevels);
+      ASSERT_NO_FATAL_FAILURE(encodeLevels(
           encoding,
-          max_level,
-          static_cast<int>(input_levels.size()),
-          input_levels.data(),
+          maxLevel,
+          static_cast<int>(inputLevels.size()),
+          inputLevels.data(),
           bytes));
       ASSERT_NO_FATAL_FAILURE(
-          VerifyDecodingLevels(encoding, max_level, input_levels, bytes));
-      input_levels.clear();
+          verifyDecodingLevels(encoding, maxLevel, inputLevels, bytes));
+      inputLevels.clear();
     }
   }
 }
 
-// Test multiple decoder SetData calls
+// Test multiple decoder SetData calls.
 TEST(TestLevels, TestLevelsDecodeMultipleSetData) {
-  int min_repeat_factor = 3;
-  int max_repeat_factor = 7; // 128
-  int bit_width = 8;
-  int16_t max_level = static_cast<int16_t>((1 << bit_width) - 1);
-  std::vector<int16_t> input_levels;
+  int minRepeatFactor = 3;
+  int maxRepeatFactor = 7; // 128
+  int bitWidth = 8;
+  int16_t maxLevel = static_cast<int16_t>((1 << bitWidth) - 1);
+  std::vector<int16_t> inputLevels;
   std::vector<std::vector<uint8_t>> bytes;
-  Encoding::type encodings[2] = {Encoding::RLE, Encoding::BIT_PACKED};
-  GenerateLevels(min_repeat_factor, max_repeat_factor, max_level, input_levels);
-  int num_levels = static_cast<int>(input_levels.size());
-  int setdata_factor = 8;
-  int split_level_size = num_levels / setdata_factor;
-  bytes.resize(setdata_factor);
-
-  // for each encoding
+  Encoding::type encodings[2] = {Encoding::kRle, Encoding::kBitPacked};
+  generateLevels(minRepeatFactor, maxRepeatFactor, maxLevel, inputLevels);
+  int numLevels = static_cast<int>(inputLevels.size());
+  int setdataFactor = 8;
+  int splitLevelSize = numLevels / setdataFactor;
+  bytes.resize(setdataFactor);
+
+  // For each encoding.
   for (int encode = 0; encode < 2; encode++) {
     Encoding::type encoding = encodings[encode];
-    for (int rf = 0; rf < setdata_factor; rf++) {
-      int offset = rf * split_level_size;
-      ASSERT_NO_FATAL_FAILURE(EncodeLevels(
+    for (int rf = 0; rf < setdataFactor; rf++) {
+      int Offset = rf * splitLevelSize;
+      ASSERT_NO_FATAL_FAILURE(encodeLevels(
           encoding,
-          max_level,
-          split_level_size,
-          reinterpret_cast<int16_t*>(input_levels.data()) + offset,
+          maxLevel,
+          splitLevelSize,
+          reinterpret_cast<int16_t*>(inputLevels.data()) + Offset,
           bytes[rf]));
     }
-    ASSERT_NO_FATAL_FAILURE(VerifyDecodingMultipleSetData(
-        encoding, max_level, input_levels, bytes));
+    ASSERT_NO_FATAL_FAILURE(
+        verifyDecodingMultipleSetData(encoding, maxLevel, inputLevels, bytes));
   }
 }
 
 TEST(TestLevelEncoder, MinimumBufferSize) {
-  // PARQUET-676, PARQUET-698
+  // PARQUET-676, PARQUET-698.
   const int kNumToEncode = 1024;
 
   std::vector<int16_t> levels;
@@ -1189,23 +1171,23 @@ TEST(TestLevelEncoder, MinimumBufferSize) {
   }
 
   std::vector<uint8_t> output(
-      LevelEncoder::MaxBufferSize(Encoding::RLE, 1, kNumToEncode));
+      LevelEncoder::maxBufferSize(Encoding::kRle, 1, kNumToEncode));
 
   LevelEncoder encoder;
-  encoder.Init(
-      Encoding::RLE,
+  encoder.init(
+      Encoding::kRle,
       1,
       kNumToEncode,
       output.data(),
       static_cast<int>(output.size()));
-  int encode_count = encoder.Encode(kNumToEncode, levels.data());
+  int encodeCount = encoder.encode(kNumToEncode, levels.data());
 
-  ASSERT_EQ(kNumToEncode, encode_count);
+  ASSERT_EQ(kNumToEncode, encodeCount);
 }
 
 TEST(TestLevelEncoder, MinimumBufferSize2) {
-  // PARQUET-708
-  // Test the worst case for bit_width=2 consisting of
+  // PARQUET-708.
+  // Test the worst case for bit_width=2 consisting of.
   // LiteralRun(size=8)
   // RepeatedRun(size=8)
   // LiteralRun(size=8)
@@ -1214,8 +1196,8 @@ TEST(TestLevelEncoder, MinimumBufferSize2) {
 
   std::vector<int16_t> levels;
   for (int i = 0; i < kNumToEncode; ++i) {
-    // This forces a literal run of 00000001
-    // followed by eight 1s
+    // This forces a literal run of 00000001.
+    // Followed by eight 1s.
     if ((i % 16) < 7) {
       levels.push_back(0);
     } else {
@@ -1223,332 +1205,326 @@ TEST(TestLevelEncoder, MinimumBufferSize2) {
     }
   }
 
-  for (int16_t bit_width = 1; bit_width <= 8; bit_width++) {
+  for (int16_t bitWidth = 1; bitWidth <= 8; bitWidth++) {
     std::vector<uint8_t> output(
-        LevelEncoder::MaxBufferSize(Encoding::RLE, bit_width, kNumToEncode));
+        LevelEncoder::maxBufferSize(Encoding::kRle, bitWidth, kNumToEncode));
 
     LevelEncoder encoder;
-    encoder.Init(
-        Encoding::RLE,
-        bit_width,
+    encoder.init(
+        Encoding::kRle,
+        bitWidth,
         kNumToEncode,
         output.data(),
         static_cast<int>(output.size()));
-    int encode_count = encoder.Encode(kNumToEncode, levels.data());
+    int encodeCount = encoder.encode(kNumToEncode, levels.data());
 
-    ASSERT_EQ(kNumToEncode, encode_count);
+    ASSERT_EQ(kNumToEncode, encodeCount);
   }
 }
 
 TEST(TestColumnWriter, WriteDataPageV2Header) {
-  auto sink = CreateOutputStream();
-  auto schema = std::static_pointer_cast<GroupNode>(GroupNode::Make(
+  auto sink = createOutputStream();
+  auto schema = std::static_pointer_cast<GroupNode>(GroupNode::make(
       "schema",
-      Repetition::REQUIRED,
+      Repetition::kRequired,
       {
-          schema::Int32("required", Repetition::REQUIRED),
-          schema::Int32("optional", Repetition::OPTIONAL),
-          schema::Int32("repeated", Repetition::REPEATED),
+          schema::int32("required", Repetition::kRequired),
+          schema::int32("optional", Repetition::kOptional),
+          schema::int32("repeated", Repetition::kRepeated),
       }));
   auto properties = WriterProperties::Builder()
-                        .disable_dictionary()
-                        ->data_page_version(ParquetDataPageVersion::V2)
+                        .disableDictionary()
+                        ->dataPageVersion(ParquetDataPageVersion::V2)
                         ->build();
-  auto file_writer = ParquetFileWriter::Open(sink, schema, properties);
-  auto rg_writer = file_writer->AppendRowGroup();
+  auto fileWriter = ParquetFileWriter::open(sink, schema, properties);
+  auto rgWriter = fileWriter->appendRowGroup();
 
-  constexpr int32_t num_rows = 100;
+  constexpr int32_t numRows = 100;
 
-  auto required_writer = static_cast<Int32Writer*>(rg_writer->NextColumn());
-  for (int32_t i = 0; i < num_rows; i++) {
-    required_writer->WriteBatch(1, nullptr, nullptr, &i);
+  auto requiredWriter = static_cast<Int32Writer*>(rgWriter->nextColumn());
+  for (int32_t i = 0; i < numRows; i++) {
+    requiredWriter->writeBatch(1, nullptr, nullptr, &i);
   }
 
   // Write a null value at every other row.
-  auto optional_writer = static_cast<Int32Writer*>(rg_writer->NextColumn());
-  for (int32_t i = 0; i < num_rows; i++) {
-    int16_t definition_level = i % 2 == 0 ? 1 : 0;
-    optional_writer->WriteBatch(1, &definition_level, nullptr, &i);
+  auto optionalWriter = static_cast<Int32Writer*>(rgWriter->nextColumn());
+  for (int32_t i = 0; i < numRows; i++) {
+    int16_t definitionLevel = i % 2 == 0 ? 1 : 0;
+    optionalWriter->writeBatch(1, &definitionLevel, nullptr, &i);
   }
 
   // Each row has repeated twice.
-  auto repeated_writer = static_cast<Int32Writer*>(rg_writer->NextColumn());
-  for (int i = 0; i < 2 * num_rows; i++) {
+  auto repeatedWriter = static_cast<Int32Writer*>(rgWriter->nextColumn());
+  for (int i = 0; i < 2 * numRows; i++) {
     int32_t value = i * 1000;
-    int16_t definition_level = 1;
-    int16_t repetition_level = i % 2 == 0 ? 1 : 0;
-    repeated_writer->WriteBatch(
-        1, &definition_level, &repetition_level, &value);
+    int16_t definitionLevel = 1;
+    int16_t repetitionLevel = i % 2 == 0 ? 1 : 0;
+    repeatedWriter->writeBatch(1, &definitionLevel, &repetitionLevel, &value);
   }
 
-  ASSERT_NO_THROW(file_writer->Close());
+  ASSERT_NO_THROW(fileWriter->close());
   ASSERT_OK_AND_ASSIGN(auto buffer, sink->Finish());
-  auto file_reader = ParquetFileReader::Open(
+  auto fileReader = ParquetFileReader::open(
       std::make_shared<::arrow::io::BufferReader>(buffer),
-      default_reader_properties());
-  auto metadata = file_reader->metadata();
-  ASSERT_EQ(1, metadata->num_row_groups());
-  auto row_group_reader = file_reader->RowGroup(0);
+      defaultReaderProperties());
+  auto metadata = fileReader->metadata();
+  ASSERT_EQ(1, metadata->numRowGroups());
+  auto rowGroupReader = fileReader->rowGroup(0);
 
   // Verify required column.
   {
-    auto page_reader = row_group_reader->GetColumnPageReader(0);
-    auto page = page_reader->NextPage();
+    auto pageReader = rowGroupReader->getColumnPageReader(0);
+    auto page = pageReader->nextPage();
     ASSERT_NE(page, nullptr);
-    auto data_page = std::static_pointer_cast<DataPageV2>(page);
-    EXPECT_EQ(num_rows, data_page->num_rows());
-    EXPECT_EQ(num_rows, data_page->num_values());
-    EXPECT_EQ(0, data_page->num_nulls());
-    EXPECT_EQ(page_reader->NextPage(), nullptr);
+    auto dataPage = std::static_pointer_cast<DataPageV2>(page);
+    EXPECT_EQ(numRows, dataPage->numRows());
+    EXPECT_EQ(numRows, dataPage->numValues());
+    EXPECT_EQ(0, dataPage->numNulls());
+    EXPECT_EQ(pageReader->nextPage(), nullptr);
   }
 
   // Verify optional column.
   {
-    auto page_reader = row_group_reader->GetColumnPageReader(1);
-    auto page = page_reader->NextPage();
+    auto pageReader = rowGroupReader->getColumnPageReader(1);
+    auto page = pageReader->nextPage();
     ASSERT_NE(page, nullptr);
-    auto data_page = std::static_pointer_cast<DataPageV2>(page);
-    EXPECT_EQ(num_rows, data_page->num_rows());
-    EXPECT_EQ(num_rows, data_page->num_values());
-    EXPECT_EQ(num_rows / 2, data_page->num_nulls());
-    EXPECT_EQ(page_reader->NextPage(), nullptr);
+    auto dataPage = std::static_pointer_cast<DataPageV2>(page);
+    EXPECT_EQ(numRows, dataPage->numRows());
+    EXPECT_EQ(numRows, dataPage->numValues());
+    EXPECT_EQ(numRows / 2, dataPage->numNulls());
+    EXPECT_EQ(pageReader->nextPage(), nullptr);
   }
 
   // Verify repeated column.
   {
-    auto page_reader = row_group_reader->GetColumnPageReader(2);
-    auto page = page_reader->NextPage();
+    auto pageReader = rowGroupReader->getColumnPageReader(2);
+    auto page = pageReader->nextPage();
     ASSERT_NE(page, nullptr);
-    auto data_page = std::static_pointer_cast<DataPageV2>(page);
-    EXPECT_EQ(num_rows, data_page->num_rows());
-    EXPECT_EQ(num_rows * 2, data_page->num_values());
-    EXPECT_EQ(0, data_page->num_nulls());
-    EXPECT_EQ(page_reader->NextPage(), nullptr);
+    auto dataPage = std::static_pointer_cast<DataPageV2>(page);
+    EXPECT_EQ(numRows, dataPage->numRows());
+    EXPECT_EQ(numRows * 2, dataPage->numValues());
+    EXPECT_EQ(0, dataPage->numNulls());
+    EXPECT_EQ(pageReader->nextPage(), nullptr);
   }
 }
 
-// The test below checks that data page v2 changes on record boundaries for
+// The test below checks that data page v2 changes on record boundaries for.
 // all repetition types (i.e. required, optional, and repeated)
 TEST(TestColumnWriter, WriteDataPagesChangeOnRecordBoundaries) {
-  auto sink = CreateOutputStream();
-  auto schema = std::static_pointer_cast<GroupNode>(GroupNode::Make(
+  auto sink = createOutputStream();
+  auto schema = std::static_pointer_cast<GroupNode>(GroupNode::make(
       "schema",
-      Repetition::REQUIRED,
-      {schema::Int32("required", Repetition::REQUIRED),
-       schema::Int32("optional", Repetition::OPTIONAL),
-       schema::Int32("repeated", Repetition::REPEATED)}));
+      Repetition::kRequired,
+      {schema::int32("required", Repetition::kRequired),
+       schema::int32("optional", Repetition::kOptional),
+       schema::int32("repeated", Repetition::kRepeated)}));
   // Write at most 11 levels per batch.
-  constexpr int64_t batch_size = 11;
+  constexpr int64_t batchSize = 11;
   auto properties =
       WriterProperties::Builder()
-          .disable_dictionary()
-          ->data_page_version(ParquetDataPageVersion::V2)
-          ->write_batch_size(batch_size)
-          ->data_pagesize(1) /* every page size check creates a new page */
+          .disableDictionary()
+          ->dataPageVersion(ParquetDataPageVersion::V2)
+          ->writeBatchSize(batchSize)
+          ->dataPagesize(1) /* every page size check creates a new page */
           ->build();
-  auto file_writer = ParquetFileWriter::Open(sink, schema, properties);
-  auto rg_writer = file_writer->AppendRowGroup();
-
-  constexpr int32_t num_levels = 100;
-  const std::vector<int32_t> values(num_levels, 1024);
-  std::array<int16_t, num_levels> def_levels;
-  std::array<int16_t, num_levels> rep_levels;
-  for (int32_t i = 0; i < num_levels; i++) {
-    def_levels[i] = i % 2 == 0 ? 1 : 0;
-    rep_levels[i] = i % 2 == 0 ? 0 : 1;
+  auto fileWriter = ParquetFileWriter::open(sink, schema, properties);
+  auto rgWriter = fileWriter->appendRowGroup();
+
+  constexpr int32_t numLevels = 100;
+  const std::vector<int32_t> values(numLevels, 1024);
+  std::array<int16_t, numLevels> defLevels;
+  std::array<int16_t, numLevels> repLevels;
+  for (int32_t i = 0; i < numLevels; i++) {
+    defLevels[i] = i % 2 == 0 ? 1 : 0;
+    repLevels[i] = i % 2 == 0 ? 0 : 1;
   }
 
-  auto required_writer = static_cast<Int32Writer*>(rg_writer->NextColumn());
-  required_writer->WriteBatch(num_levels, nullptr, nullptr, values.data());
+  auto requiredWriter = static_cast<Int32Writer*>(rgWriter->nextColumn());
+  requiredWriter->writeBatch(numLevels, nullptr, nullptr, values.data());
 
   // Write a null value at every other row.
-  auto optional_writer = static_cast<Int32Writer*>(rg_writer->NextColumn());
-  optional_writer->WriteBatch(
-      num_levels, def_levels.data(), nullptr, values.data());
+  auto optionalWriter = static_cast<Int32Writer*>(rgWriter->nextColumn());
+  optionalWriter->writeBatch(
+      numLevels, defLevels.data(), nullptr, values.data());
 
   // Each row has repeated twice.
-  auto repeated_writer = static_cast<Int32Writer*>(rg_writer->NextColumn());
-  repeated_writer->WriteBatch(
-      num_levels, def_levels.data(), rep_levels.data(), values.data());
-  repeated_writer->WriteBatch(
-      num_levels, def_levels.data(), rep_levels.data(), values.data());
+  auto repeatedWriter = static_cast<Int32Writer*>(rgWriter->nextColumn());
+  repeatedWriter->writeBatch(
+      numLevels, defLevels.data(), repLevels.data(), values.data());
+  repeatedWriter->writeBatch(
+      numLevels, defLevels.data(), repLevels.data(), values.data());
 
-  ASSERT_NO_THROW(file_writer->Close());
+  ASSERT_NO_THROW(fileWriter->close());
   ASSERT_OK_AND_ASSIGN(auto buffer, sink->Finish());
-  auto file_reader = ParquetFileReader::Open(
+  auto fileReader = ParquetFileReader::open(
       std::make_shared<::arrow::io::BufferReader>(buffer),
-      default_reader_properties());
-  auto metadata = file_reader->metadata();
-  ASSERT_EQ(1, metadata->num_row_groups());
-  auto row_group_reader = file_reader->RowGroup(0);
+      defaultReaderProperties());
+  auto metadata = fileReader->metadata();
+  ASSERT_EQ(1, metadata->numRowGroups());
+  auto rowGroupReader = fileReader->rowGroup(0);
 
   // Check if pages are changed on record boundaries.
-  constexpr int num_columns = 3;
-  const std::array<int64_t, num_columns> expected_num_pages = {10, 10, 19};
-  for (int i = 0; i < num_columns; ++i) {
-    auto page_reader = row_group_reader->GetColumnPageReader(i);
-    int64_t num_rows = 0;
-    int64_t num_pages = 0;
+  constexpr int numColumns = 3;
+  const std::array<int64_t, numColumns> expectedNumPages = {10, 10, 19};
+  for (int i = 0; i < numColumns; ++i) {
+    auto pageReader = rowGroupReader->getColumnPageReader(i);
+    int64_t numRows = 0;
+    int64_t numPages = 0;
     std::shared_ptr<Page> page;
-    while ((page = page_reader->NextPage()) != nullptr) {
-      auto data_page = std::static_pointer_cast<DataPageV2>(page);
+    while ((page = pageReader->nextPage()) != nullptr) {
+      auto dataPage = std::static_pointer_cast<DataPageV2>(page);
       if (i < 2) {
-        EXPECT_EQ(data_page->num_values(), data_page->num_rows());
+        EXPECT_EQ(dataPage->numValues(), dataPage->numRows());
       } else {
-        // Make sure repeated column has 2 values per row and not span multiple
-        // pages.
-        EXPECT_EQ(data_page->num_values(), 2 * data_page->num_rows());
+        // Make sure repeated column has 2 values per row and not span multiple.
+        // Pages.
+        EXPECT_EQ(dataPage->numValues(), 2 * dataPage->numRows());
       }
-      num_rows += data_page->num_rows();
-      num_pages++;
+      numRows += dataPage->numRows();
+      numPages++;
     }
-    EXPECT_EQ(num_levels, num_rows);
-    EXPECT_EQ(expected_num_pages[i], num_pages);
+    EXPECT_EQ(numLevels, numRows);
+    EXPECT_EQ(expectedNumPages[i], numPages);
   }
 }
 
-// The test below checks that data page v2 changes on record boundaries for
-// repeated columns with small batches.
+// The test below checks that data page v2 changes on record boundaries for.
+// Repeated columns with small batches.
 TEST(TestColumnWriter, WriteDataPagesChangeOnRecordBoundariesWithSmallBatches) {
-  auto sink = CreateOutputStream();
-  auto schema = std::static_pointer_cast<GroupNode>(GroupNode::Make(
+  auto sink = createOutputStream();
+  auto schema = std::static_pointer_cast<GroupNode>(GroupNode::make(
       "schema",
-      Repetition::REQUIRED,
-      {schema::Int32("tiny_repeat", Repetition::REPEATED),
-       schema::Int32("small_repeat", Repetition::REPEATED),
-       schema::Int32("medium_repeat", Repetition::REPEATED),
-       schema::Int32("large_repeat", Repetition::REPEATED)}));
-
-  // The batch_size is large enough so each WriteBatch call checks page size at
-  // most once.
-  constexpr int64_t batch_size = std::numeric_limits<int64_t>::max();
+      Repetition::kRequired,
+      {schema::int32("tiny_repeat", Repetition::kRepeated),
+       schema::int32("small_repeat", Repetition::kRepeated),
+       schema::int32("medium_repeat", Repetition::kRepeated),
+       schema::int32("large_repeat", Repetition::kRepeated)}));
+
+  // The batch_size is large enough so each WriteBatch call checks page size at.
+  // Most once.
+  constexpr int64_t batchSize = std::numeric_limits<int64_t>::max();
   auto properties =
       WriterProperties::Builder()
-          .disable_dictionary()
-          ->data_page_version(ParquetDataPageVersion::V2)
-          ->write_batch_size(batch_size)
-          ->data_pagesize(1) /* every page size check creates a new page */
+          .disableDictionary()
+          ->dataPageVersion(ParquetDataPageVersion::V2)
+          ->writeBatchSize(batchSize)
+          ->dataPagesize(1) /* every page size check creates a new page */
           ->build();
-  auto file_writer = ParquetFileWriter::Open(sink, schema, properties);
-  auto rg_writer = file_writer->AppendRowGroup();
+  auto fileWriter = ParquetFileWriter::open(sink, schema, properties);
+  auto rgWriter = fileWriter->appendRowGroup();
 
-  constexpr int32_t num_cols = 4;
-  constexpr int64_t num_rows = 400;
-  constexpr int64_t num_levels = 100;
-  constexpr std::array<int64_t, num_cols> num_levels_per_row_by_col = {
+  constexpr int32_t numCols = 4;
+  constexpr int64_t numRows = 400;
+  constexpr int64_t numLevels = 100;
+  constexpr std::array<int64_t, numCols> numLevelsPerRowByCol = {
       1, 50, 99, 150};
 
   // All values are not null and fixed to 1024 for simplicity.
-  const std::vector<int32_t> values(num_levels, 1024);
-  const std::vector<int16_t> def_levels(num_levels, 1);
-  std::vector<int16_t> rep_levels(num_levels, 0);
-
-  for (int32_t i = 0; i < num_cols; ++i) {
-    auto writer = static_cast<Int32Writer*>(rg_writer->NextColumn());
-    const auto num_levels_per_row = num_levels_per_row_by_col[i];
-    int64_t num_rows_written = 0;
-    int64_t num_levels_written_curr_row = 0;
-    while (num_rows_written < num_rows) {
-      int32_t num_levels_to_write = 0;
-      while (num_levels_to_write < num_levels) {
-        if (num_levels_written_curr_row == 0) {
+  const std::vector<int32_t> values(numLevels, 1024);
+  const std::vector<int16_t> defLevels(numLevels, 1);
+  std::vector<int16_t> repLevels(numLevels, 0);
+
+  for (int32_t i = 0; i < numCols; ++i) {
+    auto writer = static_cast<Int32Writer*>(rgWriter->nextColumn());
+    const auto numLevelsPerRow = numLevelsPerRowByCol[i];
+    int64_t numRowsWritten = 0;
+    int64_t numLevelsWrittenCurrRow = 0;
+    while (numRowsWritten < numRows) {
+      int32_t numLevelsToWrite = 0;
+      while (numLevelsToWrite < numLevels) {
+        if (numLevelsWrittenCurrRow == 0) {
           // A new record.
-          rep_levels[num_levels_to_write++] = 0;
+          repLevels[numLevelsToWrite++] = 0;
         } else {
-          rep_levels[num_levels_to_write++] = 1;
+          repLevels[numLevelsToWrite++] = 1;
         }
 
-        if (++num_levels_written_curr_row == num_levels_per_row) {
+        if (++numLevelsWrittenCurrRow == numLevelsPerRow) {
           // Current row has enough levels.
-          num_levels_written_curr_row = 0;
-          if (++num_rows_written == num_rows) {
+          numLevelsWrittenCurrRow = 0;
+          if (++numRowsWritten == numRows) {
             // Enough rows have been written.
             break;
           }
         }
       }
 
-      writer->WriteBatch(
-          num_levels_to_write,
-          def_levels.data(),
-          rep_levels.data(),
-          values.data());
+      writer->writeBatch(
+          numLevelsToWrite, defLevels.data(), repLevels.data(), values.data());
     }
   }
 
-  ASSERT_NO_THROW(file_writer->Close());
+  ASSERT_NO_THROW(fileWriter->close());
   ASSERT_OK_AND_ASSIGN(auto buffer, sink->Finish());
-  auto file_reader = ParquetFileReader::Open(
+  auto fileReader = ParquetFileReader::open(
       std::make_shared<::arrow::io::BufferReader>(buffer),
-      default_reader_properties());
-  auto metadata = file_reader->metadata();
-  ASSERT_EQ(1, metadata->num_row_groups());
-  auto row_group_reader = file_reader->RowGroup(0);
+      defaultReaderProperties());
+  auto metadata = fileReader->metadata();
+  ASSERT_EQ(1, metadata->numRowGroups());
+  auto rowGroupReader = fileReader->rowGroup(0);
 
   // Check if pages are changed on record boundaries.
-  const std::array<int64_t, num_cols> expect_num_pages_by_col = {
-      5, 201, 397, 201};
-  const std::array<int64_t, num_cols> expect_num_rows_1st_page_by_col = {
-      99, 1, 1, 1};
-  const std::array<int64_t, num_cols> expect_num_vals_1st_page_by_col = {
+  const std::array<int64_t, numCols> expectNumPagesByCol = {5, 201, 397, 201};
+  const std::array<int64_t, numCols> expectNumRows1stPageByCol = {99, 1, 1, 1};
+  const std::array<int64_t, numCols> expectNumVals1stPageByCol = {
       99, 50, 99, 150};
-  for (int32_t i = 0; i < num_cols; ++i) {
-    auto page_reader = row_group_reader->GetColumnPageReader(i);
-    int64_t num_rows_read = 0;
-    int64_t num_pages_read = 0;
-    int64_t num_values_read = 0;
+  for (int32_t i = 0; i < numCols; ++i) {
+    auto pageReader = rowGroupReader->getColumnPageReader(i);
+    int64_t numRowsRead = 0;
+    int64_t numPagesRead = 0;
+    int64_t numValuesRead = 0;
     std::shared_ptr<Page> page;
-    while ((page = page_reader->NextPage()) != nullptr) {
-      auto data_page = std::static_pointer_cast<DataPageV2>(page);
-      num_values_read += data_page->num_values();
-      num_rows_read += data_page->num_rows();
-      if (num_pages_read++ == 0) {
-        EXPECT_EQ(expect_num_rows_1st_page_by_col[i], data_page->num_rows());
-        EXPECT_EQ(expect_num_vals_1st_page_by_col[i], data_page->num_values());
+    while ((page = pageReader->nextPage()) != nullptr) {
+      auto dataPage = std::static_pointer_cast<DataPageV2>(page);
+      numValuesRead += dataPage->numValues();
+      numRowsRead += dataPage->numRows();
+      if (numPagesRead++ == 0) {
+        EXPECT_EQ(expectNumRows1stPageByCol[i], dataPage->numRows());
+        EXPECT_EQ(expectNumVals1stPageByCol[i], dataPage->numValues());
       }
     }
-    EXPECT_EQ(num_rows, num_rows_read);
-    EXPECT_EQ(expect_num_pages_by_col[i], num_pages_read);
-    EXPECT_EQ(num_levels_per_row_by_col[i] * num_rows, num_values_read);
+    EXPECT_EQ(numRows, numRowsRead);
+    EXPECT_EQ(expectNumPagesByCol[i], numPagesRead);
+    EXPECT_EQ(numLevelsPerRowByCol[i] * numRows, numValuesRead);
   }
 }
 
 class ColumnWriterTestSizeEstimated : public ::testing::Test {
  public:
   void SetUp() {
-    sink_ = CreateOutputStream();
-    node_ = std::static_pointer_cast<GroupNode>(GroupNode::Make(
+    sink_ = createOutputStream();
+    node_ = std::static_pointer_cast<GroupNode>(GroupNode::make(
         "schema",
-        Repetition::REQUIRED,
+        Repetition::kRequired,
         {
-            schema::Int32("required", Repetition::REQUIRED),
+            schema::int32("required", Repetition::kRequired),
         }));
     std::vector<schema::NodePtr> fields;
-    schema_descriptor_ = std::make_unique<SchemaDescriptor>();
-    schema_descriptor_->Init(node_);
+    schemaDescriptor_ = std::make_unique<SchemaDescriptor>();
+    schemaDescriptor_->init(node_);
   }
 
-  std::shared_ptr<Int32Writer> BuildWriter(
+  std::shared_ptr<Int32Writer> buildWriter(
       Compression::type compression,
       bool buffered,
-      bool enable_dictionary = false) {
-    auto builder = WriterProperties::Builder();
-    builder.disable_dictionary()
+      bool enableDictionary = false) {
+    auto Builder = WriterProperties::Builder();
+    Builder.disableDictionary()
         ->compression(compression)
-        ->data_pagesize(100 * sizeof(int));
-    if (enable_dictionary) {
-      builder.enable_dictionary();
+        ->dataPagesize(100 * sizeof(int));
+    if (enableDictionary) {
+      Builder.enableDictionary();
     } else {
-      builder.disable_dictionary();
+      Builder.disableDictionary();
     }
-    writer_properties_ = builder.build();
-    metadata_ = ColumnChunkMetaDataBuilder::Make(
-        writer_properties_, schema_descriptor_->Column(0));
+    writerProperties_ = Builder.build();
+    metadata_ = ColumnChunkMetaDataBuilder::make(
+        writerProperties_, schemaDescriptor_->column(0));
 
-    std::unique_ptr<PageWriter> pager = PageWriter::Open(
+    std::unique_ptr<PageWriter> pager = PageWriter::open(
         sink_,
         compression,
-        Codec::UseDefaultCompressionLevel(),
+        Codec::useDefaultCompressionLevel(),
         metadata_.get(),
         /* row_group_ordinal */ -1,
         /* column_chunk_ordinal*/ -1,
@@ -1557,165 +1533,165 @@ class ColumnWriterTestSizeEstimated : public ::testing::Test {
         /* header_encryptor */ NULLPTR,
         /* data_encryptor */ NULLPTR,
         /* enable_checksum */ false);
-    return std::static_pointer_cast<Int32Writer>(ColumnWriter::Make(
-        metadata_.get(), std::move(pager), writer_properties_.get()));
+    return std::static_pointer_cast<Int32Writer>(ColumnWriter::make(
+        metadata_.get(), std::move(pager), writerProperties_.get()));
   }
 
   std::shared_ptr<::arrow::io::BufferOutputStream> sink_;
   std::shared_ptr<GroupNode> node_;
-  std::unique_ptr<SchemaDescriptor> schema_descriptor_;
+  std::unique_ptr<SchemaDescriptor> schemaDescriptor_;
 
-  std::shared_ptr<WriterProperties> writer_properties_;
+  std::shared_ptr<WriterProperties> writerProperties_;
   std::unique_ptr<ColumnChunkMetaDataBuilder> metadata_;
 };
 
 TEST_F(ColumnWriterTestSizeEstimated, NonBuffered) {
-  auto required_writer =
-      this->BuildWriter(Compression::UNCOMPRESSED, /* buffered*/ false);
-  // Write half page, page will not be flushed after loop
+  auto requiredWriter =
+      this->buildWriter(Compression::UNCOMPRESSED, /* buffered*/ false);
+  // Write half page, page will not be flushed after loop.
   for (int32_t i = 0; i < 50; i++) {
-    required_writer->WriteBatch(1, nullptr, nullptr, &i);
+    requiredWriter->writeBatch(1, nullptr, nullptr, &i);
   }
-  // Page not flushed, check size
-  EXPECT_EQ(0, required_writer->total_bytes_written());
-  EXPECT_EQ(0, required_writer->total_compressed_bytes()); // unbuffered
-  EXPECT_EQ(0, required_writer->total_compressed_bytes_written());
-  // Write half page, page be flushed after loop
+  // Page not flushed, check size.
+  EXPECT_EQ(0, requiredWriter->totalBytesWritten());
+  EXPECT_EQ(0, requiredWriter->totalCompressedBytes()); // unbuffered
+  EXPECT_EQ(0, requiredWriter->totalCompressedBytesWritten());
+  // Write half page, page be flushed after loop.
   for (int32_t i = 0; i < 50; i++) {
-    required_writer->WriteBatch(1, nullptr, nullptr, &i);
+    requiredWriter->writeBatch(1, nullptr, nullptr, &i);
   }
-  // Page flushed, check size
-  EXPECT_LT(400, required_writer->total_bytes_written());
-  EXPECT_EQ(0, required_writer->total_compressed_bytes());
-  EXPECT_LT(400, required_writer->total_compressed_bytes_written());
-
-  // Test after closed
-  int64_t written_size = required_writer->Close();
-  EXPECT_EQ(0, required_writer->total_compressed_bytes());
-  EXPECT_EQ(written_size, required_writer->total_bytes_written());
-  // uncompressed writer should be equal
-  EXPECT_EQ(written_size, required_writer->total_compressed_bytes_written());
+  // Page flushed, check size.
+  EXPECT_LT(400, requiredWriter->totalBytesWritten());
+  EXPECT_EQ(0, requiredWriter->totalCompressedBytes());
+  EXPECT_LT(400, requiredWriter->totalCompressedBytesWritten());
+
+  // Test after closed.
+  int64_t writtenSize = requiredWriter->close();
+  EXPECT_EQ(0, requiredWriter->totalCompressedBytes());
+  EXPECT_EQ(writtenSize, requiredWriter->totalBytesWritten());
+  // Uncompressed writer should be equal.
+  EXPECT_EQ(writtenSize, requiredWriter->totalCompressedBytesWritten());
 }
 
 TEST_F(ColumnWriterTestSizeEstimated, Buffered) {
-  auto required_writer =
-      this->BuildWriter(Compression::UNCOMPRESSED, /* buffered*/ true);
-  // Write half page, page will not be flushed after loop
+  auto requiredWriter =
+      this->buildWriter(Compression::UNCOMPRESSED, /* buffered*/ true);
+  // Write half page, page will not be flushed after loop.
   for (int32_t i = 0; i < 50; i++) {
-    required_writer->WriteBatch(1, nullptr, nullptr, &i);
+    requiredWriter->writeBatch(1, nullptr, nullptr, &i);
   }
-  // Page not flushed, check size
-  EXPECT_EQ(0, required_writer->total_bytes_written());
-  EXPECT_EQ(0, required_writer->total_compressed_bytes()); // buffered
-  EXPECT_EQ(0, required_writer->total_compressed_bytes_written());
-  // Write half page, page be flushed after loop
+  // Page not flushed, check size.
+  EXPECT_EQ(0, requiredWriter->totalBytesWritten());
+  EXPECT_EQ(0, requiredWriter->totalCompressedBytes()); // buffered
+  EXPECT_EQ(0, requiredWriter->totalCompressedBytesWritten());
+  // Write half page, page be flushed after loop.
   for (int32_t i = 0; i < 50; i++) {
-    required_writer->WriteBatch(1, nullptr, nullptr, &i);
+    requiredWriter->writeBatch(1, nullptr, nullptr, &i);
   }
-  // Page flushed, check size
-  EXPECT_LT(400, required_writer->total_bytes_written());
-  EXPECT_EQ(0, required_writer->total_compressed_bytes());
-  EXPECT_LT(400, required_writer->total_compressed_bytes_written());
-
-  // Test after closed
-  int64_t written_size = required_writer->Close();
-  EXPECT_EQ(0, required_writer->total_compressed_bytes());
-  EXPECT_EQ(written_size, required_writer->total_bytes_written());
-  // uncompressed writer should be equal
-  EXPECT_EQ(written_size, required_writer->total_compressed_bytes_written());
+  // Page flushed, check size.
+  EXPECT_LT(400, requiredWriter->totalBytesWritten());
+  EXPECT_EQ(0, requiredWriter->totalCompressedBytes());
+  EXPECT_LT(400, requiredWriter->totalCompressedBytesWritten());
+
+  // Test after closed.
+  int64_t writtenSize = requiredWriter->close();
+  EXPECT_EQ(0, requiredWriter->totalCompressedBytes());
+  EXPECT_EQ(writtenSize, requiredWriter->totalBytesWritten());
+  // Uncompressed writer should be equal.
+  EXPECT_EQ(writtenSize, requiredWriter->totalCompressedBytesWritten());
 }
 
 TEST_F(ColumnWriterTestSizeEstimated, NonBufferedDictionary) {
-  auto required_writer =
-      this->BuildWriter(Compression::UNCOMPRESSED, /* buffered*/ false, true);
-  // for dict, keep all values equal
-  int32_t dict_value = 1;
+  auto requiredWriter =
+      this->buildWriter(Compression::UNCOMPRESSED, /* buffered*/ false, true);
+  // For dict, keep all values equal.
+  int32_t dictValue = 1;
   for (int32_t i = 0; i < 50; i++) {
-    required_writer->WriteBatch(1, nullptr, nullptr, &dict_value);
+    requiredWriter->writeBatch(1, nullptr, nullptr, &dictValue);
   }
-  // Page not flushed, check size
-  EXPECT_EQ(0, required_writer->total_bytes_written());
-  EXPECT_EQ(0, required_writer->total_compressed_bytes());
-  EXPECT_EQ(0, required_writer->total_compressed_bytes_written());
-  // write a huge batch to trigger page flush
+  // Page not flushed, check size.
+  EXPECT_EQ(0, requiredWriter->totalBytesWritten());
+  EXPECT_EQ(0, requiredWriter->totalCompressedBytes());
+  EXPECT_EQ(0, requiredWriter->totalCompressedBytesWritten());
+  // Write a huge batch to trigger page flush.
   for (int32_t i = 0; i < 50000; i++) {
-    required_writer->WriteBatch(1, nullptr, nullptr, &dict_value);
+    requiredWriter->writeBatch(1, nullptr, nullptr, &dictValue);
   }
-  // Page flushed, check size
-  EXPECT_EQ(0, required_writer->total_bytes_written());
-  EXPECT_LT(400, required_writer->total_compressed_bytes());
-  EXPECT_EQ(0, required_writer->total_compressed_bytes_written());
-
-  required_writer->Close();
-
-  // Test after closed
-  int64_t written_size = required_writer->Close();
-  EXPECT_EQ(0, required_writer->total_compressed_bytes());
-  EXPECT_EQ(written_size, required_writer->total_bytes_written());
-  // uncompressed writer should be equal
-  EXPECT_EQ(written_size, required_writer->total_compressed_bytes_written());
+  // Page flushed, check size.
+  EXPECT_EQ(0, requiredWriter->totalBytesWritten());
+  EXPECT_LT(400, requiredWriter->totalCompressedBytes());
+  EXPECT_EQ(0, requiredWriter->totalCompressedBytesWritten());
+
+  requiredWriter->close();
+
+  // Test after closed.
+  int64_t writtenSize = requiredWriter->close();
+  EXPECT_EQ(0, requiredWriter->totalCompressedBytes());
+  EXPECT_EQ(writtenSize, requiredWriter->totalBytesWritten());
+  // Uncompressed writer should be equal.
+  EXPECT_EQ(writtenSize, requiredWriter->totalCompressedBytesWritten());
 }
 
 TEST_F(ColumnWriterTestSizeEstimated, BufferedCompression) {
-  auto required_writer = this->BuildWriter(Compression::SNAPPY, true);
+  auto requiredWriter = this->buildWriter(Compression::SNAPPY, true);
 
-  // Write half page
+  // Write half page.
   for (int32_t i = 0; i < 50; i++) {
-    required_writer->WriteBatch(1, nullptr, nullptr, &i);
+    requiredWriter->writeBatch(1, nullptr, nullptr, &i);
   }
-  // Page not flushed, check size
-  EXPECT_EQ(0, required_writer->total_bytes_written());
-  EXPECT_EQ(0, required_writer->total_compressed_bytes()); // buffered
-  EXPECT_EQ(0, required_writer->total_compressed_bytes_written());
+  // Page not flushed, check size.
+  EXPECT_EQ(0, requiredWriter->totalBytesWritten());
+  EXPECT_EQ(0, requiredWriter->totalCompressedBytes()); // buffered
+  EXPECT_EQ(0, requiredWriter->totalCompressedBytesWritten());
   for (int32_t i = 0; i < 50; i++) {
-    required_writer->WriteBatch(1, nullptr, nullptr, &i);
+    requiredWriter->writeBatch(1, nullptr, nullptr, &i);
   }
-  // Page flushed, check size
-  EXPECT_LT(400, required_writer->total_bytes_written());
-  EXPECT_EQ(0, required_writer->total_compressed_bytes());
+  // Page flushed, check size.
+  EXPECT_LT(400, requiredWriter->totalBytesWritten());
+  EXPECT_EQ(0, requiredWriter->totalCompressedBytes());
   EXPECT_LT(
-      required_writer->total_compressed_bytes_written(),
-      required_writer->total_bytes_written());
-
-  // Test after closed
-  int64_t written_size = required_writer->Close();
-  EXPECT_EQ(0, required_writer->total_compressed_bytes());
-  EXPECT_EQ(written_size, required_writer->total_bytes_written());
-  EXPECT_GT(written_size, required_writer->total_compressed_bytes_written());
+      requiredWriter->totalCompressedBytesWritten(),
+      requiredWriter->totalBytesWritten());
+
+  // Test after closed.
+  int64_t writtenSize = requiredWriter->close();
+  EXPECT_EQ(0, requiredWriter->totalCompressedBytes());
+  EXPECT_EQ(writtenSize, requiredWriter->totalBytesWritten());
+  EXPECT_GT(writtenSize, requiredWriter->totalCompressedBytesWritten());
 }
 
 TEST(TestColumnWriter, WriteDataPageV2HeaderNullCount) {
-  auto sink = CreateOutputStream();
-  auto list_type = GroupNode::Make(
+  auto sink = createOutputStream();
+  auto listType = GroupNode::make(
       "list",
-      Repetition::REPEATED,
-      {schema::Int32("elem", Repetition::OPTIONAL)});
-  auto schema = std::static_pointer_cast<GroupNode>(GroupNode::Make(
+      Repetition::kRepeated,
+      {schema::int32("elem", Repetition::kOptional)});
+  auto schema = std::static_pointer_cast<GroupNode>(GroupNode::make(
       "schema",
-      Repetition::REQUIRED,
+      Repetition::kRequired,
       {
-          schema::Int32("non_null", Repetition::OPTIONAL),
-          schema::Int32("half_null", Repetition::OPTIONAL),
-          schema::Int32("all_null", Repetition::OPTIONAL),
-          GroupNode::Make("half_null_list", Repetition::OPTIONAL, {list_type}),
-          GroupNode::Make("half_empty_list", Repetition::OPTIONAL, {list_type}),
-          GroupNode::Make(
-              "half_list_of_null", Repetition::OPTIONAL, {list_type}),
-          GroupNode::Make("all_single_list", Repetition::OPTIONAL, {list_type}),
+          schema::int32("non_null", Repetition::kOptional),
+          schema::int32("half_null", Repetition::kOptional),
+          schema::int32("all_null", Repetition::kOptional),
+          GroupNode::make("half_null_list", Repetition::kOptional, {listType}),
+          GroupNode::make("half_empty_list", Repetition::kOptional, {listType}),
+          GroupNode::make(
+              "half_list_of_null", Repetition::kOptional, {listType}),
+          GroupNode::make("all_single_list", Repetition::kOptional, {listType}),
       }));
   auto properties = WriterProperties::Builder()
                         /* Use V2 data page to read null_count from header */
-                        .data_page_version(ParquetDataPageVersion::V2)
+                        .dataPageVersion(ParquetDataPageVersion::V2)
                         /* Disable stats to test null_count is properly set */
-                        ->disable_statistics()
-                        ->disable_dictionary()
+                        ->disableStatistics()
+                        ->disableDictionary()
                         ->build();
-  auto file_writer = ParquetFileWriter::Open(sink, schema, properties);
-  auto rg_writer = file_writer->AppendRowGroup();
+  auto fileWriter = ParquetFileWriter::open(sink, schema, properties);
+  auto rgWriter = fileWriter->appendRowGroup();
 
-  constexpr int32_t num_rows = 10;
-  constexpr int32_t num_cols = 7;
-  const std::vector<std::vector<int16_t>> def_levels_by_col = {
+  constexpr int32_t numRows = 10;
+  constexpr int32_t numCols = 7;
+  const std::vector<std::vector<int16_t>> defLevelsByCol = {
       {1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
       {1, 0, 1, 0, 1, 0, 1, 0, 1, 0},
       {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
@@ -1724,43 +1700,43 @@ TEST(TestColumnWriter, WriteDataPageV2HeaderNullCount) {
       {2, 3, 2, 3, 2, 3, 2, 3, 2, 3},
       {3, 3, 3, 3, 3, 3, 3, 3, 3, 3},
   };
-  const std::vector<int16_t> ref_levels(num_rows, 0);
-  const std::vector<int32_t> values(num_rows, 123);
-  const std::vector<int64_t> expect_null_count_by_col = {0, 5, 10, 5, 5, 5, 0};
-
-  for (int32_t i = 0; i < num_cols; ++i) {
-    auto writer = static_cast<Int32Writer*>(rg_writer->NextColumn());
-    writer->WriteBatch(
-        num_rows,
-        def_levels_by_col[i].data(),
-        i >= 3 ? ref_levels.data() : nullptr,
+  const std::vector<int16_t> refLevels(numRows, 0);
+  const std::vector<int32_t> values(numRows, 123);
+  const std::vector<int64_t> expectNullCountByCol = {0, 5, 10, 5, 5, 5, 0};
+
+  for (int32_t i = 0; i < numCols; ++i) {
+    auto writer = static_cast<Int32Writer*>(rgWriter->nextColumn());
+    writer->writeBatch(
+        numRows,
+        defLevelsByCol[i].data(),
+        i >= 3 ? refLevels.data() : nullptr,
         values.data());
   }
 
-  ASSERT_NO_THROW(file_writer->Close());
+  ASSERT_NO_THROW(fileWriter->close());
   ASSERT_OK_AND_ASSIGN(auto buffer, sink->Finish());
-  auto file_reader = ParquetFileReader::Open(
+  auto fileReader = ParquetFileReader::open(
       std::make_shared<::arrow::io::BufferReader>(buffer),
-      default_reader_properties());
-  auto metadata = file_reader->metadata();
-  ASSERT_EQ(1, metadata->num_row_groups());
-  auto row_group_reader = file_reader->RowGroup(0);
+      defaultReaderProperties());
+  auto metadata = fileReader->metadata();
+  ASSERT_EQ(1, metadata->numRowGroups());
+  auto rowGroupReader = fileReader->rowGroup(0);
 
   std::shared_ptr<Page> page;
-  for (int32_t i = 0; i < num_cols; ++i) {
-    auto page_reader = row_group_reader->GetColumnPageReader(i);
-    int64_t num_nulls_read = 0;
-    int64_t num_rows_read = 0;
-    int64_t num_values_read = 0;
-    while ((page = page_reader->NextPage()) != nullptr) {
-      auto data_page = std::static_pointer_cast<DataPageV2>(page);
-      num_nulls_read += data_page->num_nulls();
-      num_rows_read += data_page->num_rows();
-      num_values_read += data_page->num_values();
+  for (int32_t i = 0; i < numCols; ++i) {
+    auto pageReader = rowGroupReader->getColumnPageReader(i);
+    int64_t numNullsRead = 0;
+    int64_t numRowsRead = 0;
+    int64_t numValuesRead = 0;
+    while ((page = pageReader->nextPage()) != nullptr) {
+      auto dataPage = std::static_pointer_cast<DataPageV2>(page);
+      numNullsRead += dataPage->numNulls();
+      numRowsRead += dataPage->numRows();
+      numValuesRead += dataPage->numValues();
     }
-    EXPECT_EQ(expect_null_count_by_col[i], num_nulls_read);
-    EXPECT_EQ(num_rows, num_rows_read);
-    EXPECT_EQ(num_rows, num_values_read);
+    EXPECT_EQ(expectNullCountByCol[i], numNullsRead);
+    EXPECT_EQ(numRows, numRowsRead);
+    EXPECT_EQ(numRows, numValuesRead);
   }
 }
 
diff --git a/velox/dwio/parquet/writer/arrow/tests/EncodingTest.cpp b/velox/dwio/parquet/writer/arrow/tests/EncodingTest.cpp
index 92570dc139a..ab97f63702f 100644
--- a/velox/dwio/parquet/writer/arrow/tests/EncodingTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/EncodingTest.cpp
@@ -68,8 +68,8 @@ namespace facebook::velox::parquet::arrow {
 namespace {
 
 constexpr int64_t kInMemoryDefaultCapacity = 1024;
-// The Parquet spec isn't very clear whether ByteArray lengths are signed or
-// unsigned, but the Java implementation uses signed ints.
+// The Parquet spec isn't very clear whether ByteArray lengths are signed or.
+// Unsigned, but the Java implementation uses signed ints.
 constexpr size_t kMaxByteArraySize = std::numeric_limits<int32_t>::max();
 
 class EncoderImpl : virtual public Encoder {
@@ -81,93 +81,91 @@ class EncoderImpl : virtual public Encoder {
       : descr_(descr),
         encoding_(encoding),
         pool_(pool),
-        type_length_(descr ? descr->type_length() : -1) {}
+        typeLength_(descr ? descr->typeLength() : -1) {}
 
   Encoding::type encoding() const override {
     return encoding_;
   }
 
-  MemoryPool* memory_pool() const override {
+  MemoryPool* memoryPool() const override {
     return pool_;
   }
 
  protected:
-  // For accessing type-specific metadata, like FIXED_LEN_BYTE_ARRAY
+  // For accessing type-specific metadata, like FIXED_LEN_BYTE_ARRAY.
   const ColumnDescriptor* descr_;
   const Encoding::type encoding_;
   MemoryPool* pool_;
 
-  /// Type length from descr
-  int type_length_;
+  /// Type length from descr.
+  int typeLength_;
 };
 
-// ----------------------------------------------------------------------
-// Plain encoder implementation
+// ----------------------------------------------------------------------.
+// Plain encoder implementation.
 
 template <typename DType>
 class PlainEncoder : public EncoderImpl, virtual public TypedEncoder<DType> {
  public:
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
 
   explicit PlainEncoder(const ColumnDescriptor* descr, MemoryPool* pool)
-      : EncoderImpl(descr, Encoding::PLAIN, pool), sink_(pool) {}
+      : EncoderImpl(descr, Encoding::kPlain, pool), sink_(pool) {}
 
-  int64_t EstimatedDataEncodedSize() override {
+  int64_t estimatedDataEncodedSize() override {
     return sink_.length();
   }
 
-  std::shared_ptr<Buffer> FlushValues() override {
+  std::shared_ptr<Buffer> flushValues() override {
     std::shared_ptr<Buffer> buffer;
     PARQUET_THROW_NOT_OK(sink_.Finish(&buffer));
     return buffer;
   }
 
-  using TypedEncoder<DType>::Put;
+  using TypedEncoder<DType>::put;
 
-  void Put(const T* buffer, int num_values) override;
+  void put(const T* buffer, int numValues) override;
 
-  void Put(const ::arrow::Array& values) override;
+  void put(const ::arrow::Array& values) override;
 
-  void PutSpaced(
+  void putSpaced(
       const T* src,
-      int num_values,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset) override {
-    if (valid_bits != NULLPTR) {
-      PARQUET_ASSIGN_OR_THROW(
-          auto buffer,
-          ::arrow::AllocateBuffer(num_values * sizeof(T), this->memory_pool()));
+      int numValues,
+      const uint8_t* validBits,
+      int64_t validBitsOffset) override {
+    if (validBits != NULLPTR) {
+      auto buffer = allocateBuffer(this->memoryPool(), numValues * sizeof(T));
       T* data = reinterpret_cast<T*>(buffer->mutable_data());
-      int num_valid_values = ::arrow::util::internal::SpacedCompress<T>(
-          src, num_values, valid_bits, valid_bits_offset, data);
-      Put(data, num_valid_values);
+      int numValidValues = ::arrow::util::internal::SpacedCompress<T>(
+          src, numValues, validBits, validBitsOffset, data);
+      put(data, numValidValues);
     } else {
-      Put(src, num_values);
+      put(src, numValues);
     }
   }
 
-  void UnsafePutByteArray(const void* data, uint32_t length) {
+  void unsafePutByteArray(const void* data, uint32_t length) {
     VELOX_DCHECK(length == 0 || data != nullptr, "Value ptr cannot be NULL");
     sink_.UnsafeAppend(&length, sizeof(uint32_t));
     sink_.UnsafeAppend(data, static_cast<int64_t>(length));
   }
 
-  void Put(const ByteArray& val) {
-    // Write the result to the output stream
+  void put(const ByteArray& val) {
+    // Write the result to the output stream.
     const int64_t increment = static_cast<int64_t>(val.len + sizeof(uint32_t));
     if (ARROW_PREDICT_FALSE(sink_.length() + increment > sink_.capacity())) {
       PARQUET_THROW_NOT_OK(sink_.Reserve(increment));
     }
-    UnsafePutByteArray(val.ptr, val.len);
+    unsafePutByteArray(val.ptr, val.len);
   }
 
  protected:
   template <typename ArrayType>
-  void PutBinaryArray(const ArrayType& array) {
-    const int64_t total_bytes =
+  void putBinaryArray(const ArrayType& array) {
+    const int64_t totalBytes =
         array.value_offset(array.length()) - array.value_offset(0);
     PARQUET_THROW_NOT_OK(
-        sink_.Reserve(total_bytes + array.length() * sizeof(uint32_t)));
+        sink_.Reserve(totalBytes + array.length() * sizeof(uint32_t)));
 
     PARQUET_THROW_NOT_OK(
         ::arrow::VisitArraySpanInline<typename ArrayType::TypeClass>(
@@ -177,7 +175,7 @@ class PlainEncoder : public EncoderImpl, virtual public TypedEncoder<DType> {
                 return Status::Invalid(
                     "Parquet cannot store strings with size 2GB or more");
               }
-              UnsafePutByteArray(
+              unsafePutByteArray(
                   view.data(), static_cast<uint32_t>(view.size()));
               return Status::OK();
             },
@@ -188,125 +186,124 @@ class PlainEncoder : public EncoderImpl, virtual public TypedEncoder<DType> {
 };
 
 template <typename DType>
-void PlainEncoder<DType>::Put(const T* buffer, int num_values) {
-  if (num_values > 0) {
-    PARQUET_THROW_NOT_OK(sink_.Append(buffer, num_values * sizeof(T)));
+void PlainEncoder<DType>::put(const T* buffer, int numValues) {
+  if (numValues > 0) {
+    PARQUET_THROW_NOT_OK(sink_.Append(buffer, numValues * sizeof(T)));
   }
 }
 
 template <>
-inline void PlainEncoder<ByteArrayType>::Put(
+inline void PlainEncoder<ByteArrayType>::put(
     const ByteArray* src,
-    int num_values) {
-  for (int i = 0; i < num_values; ++i) {
-    Put(src[i]);
+    int numValues) {
+  for (int i = 0; i < numValues; ++i) {
+    put(src[i]);
   }
 }
 
 template <typename ArrayType>
-void DirectPutImpl(const ::arrow::Array& values, ::arrow::BufferBuilder* sink) {
+void directPutImpl(const ::arrow::Array& values, ::arrow::BufferBuilder* sink) {
   if (values.type_id() != ArrayType::TypeClass::type_id) {
-    std::string type_name = ArrayType::TypeClass::type_name();
+    std::string typeName = ArrayType::TypeClass::type_name();
     throw ParquetException(
-        "direct put to " + type_name + " from " + values.type()->ToString() +
+        "direct put to " + typeName + " from " + values.type()->ToString() +
         " not supported");
   }
 
-  using value_type = typename ArrayType::value_type;
-  constexpr auto value_size = sizeof(value_type);
+  using ValueType = typename ArrayType::value_type;
+  constexpr auto valueSize = sizeof(ValueType);
   auto raw_values = checked_cast<const ArrayType&>(values).raw_values();
 
   if (values.null_count() == 0) {
-    // no nulls, just dump the data
-    PARQUET_THROW_NOT_OK(
-        sink->Append(raw_values, values.length() * value_size));
+    // No nulls, just dump the data.
+    PARQUET_THROW_NOT_OK(sink->Append(raw_values, values.length() * valueSize));
   } else {
     PARQUET_THROW_NOT_OK(
-        sink->Reserve((values.length() - values.null_count()) * value_size));
+        sink->Reserve((values.length() - values.null_count()) * valueSize));
 
     for (int64_t i = 0; i < values.length(); i++) {
       if (values.IsValid(i)) {
-        sink->UnsafeAppend(&raw_values[i], value_size);
+        sink->UnsafeAppend(&raw_values[i], valueSize);
       }
     }
   }
 }
 
 template <>
-void PlainEncoder<Int32Type>::Put(const ::arrow::Array& values) {
-  DirectPutImpl<::arrow::Int32Array>(values, &sink_);
+void PlainEncoder<Int32Type>::put(const ::arrow::Array& values) {
+  directPutImpl<::arrow::Int32Array>(values, &sink_);
 }
 
 template <>
-void PlainEncoder<Int64Type>::Put(const ::arrow::Array& values) {
-  DirectPutImpl<::arrow::Int64Array>(values, &sink_);
+void PlainEncoder<Int64Type>::put(const ::arrow::Array& values) {
+  directPutImpl<::arrow::Int64Array>(values, &sink_);
 }
 
 template <>
-void PlainEncoder<Int96Type>::Put(const ::arrow::Array& values) {
+void PlainEncoder<Int96Type>::put(const ::arrow::Array& values) {
   ParquetException::NYI("direct put to Int96");
 }
 
 template <>
-void PlainEncoder<FloatType>::Put(const ::arrow::Array& values) {
-  DirectPutImpl<::arrow::FloatArray>(values, &sink_);
+void PlainEncoder<FloatType>::put(const ::arrow::Array& values) {
+  directPutImpl<::arrow::FloatArray>(values, &sink_);
 }
 
 template <>
-void PlainEncoder<DoubleType>::Put(const ::arrow::Array& values) {
-  DirectPutImpl<::arrow::DoubleArray>(values, &sink_);
+void PlainEncoder<DoubleType>::put(const ::arrow::Array& values) {
+  directPutImpl<::arrow::DoubleArray>(values, &sink_);
 }
 
 template <typename DType>
-void PlainEncoder<DType>::Put(const ::arrow::Array& values) {
+void PlainEncoder<DType>::put(const ::arrow::Array& values) {
   ParquetException::NYI("direct put of " + values.type()->ToString());
 }
 
-void AssertBaseBinary(const ::arrow::Array& values) {
+void assertBaseBinary(const ::arrow::Array& values) {
   if (!::arrow::is_base_binary_like(values.type_id())) {
     throw ParquetException("Only BaseBinaryArray and subclasses supported");
   }
 }
 
 template <>
-inline void PlainEncoder<ByteArrayType>::Put(const ::arrow::Array& values) {
-  AssertBaseBinary(values);
+inline void PlainEncoder<ByteArrayType>::put(const ::arrow::Array& values) {
+  assertBaseBinary(values);
 
   if (::arrow::is_binary_like(values.type_id())) {
-    PutBinaryArray(checked_cast<const ::arrow::BinaryArray&>(values));
+    putBinaryArray(checked_cast<const ::arrow::BinaryArray&>(values));
   } else {
     VELOX_DCHECK(::arrow::is_large_binary_like(values.type_id()));
-    PutBinaryArray(checked_cast<const ::arrow::LargeBinaryArray&>(values));
+    putBinaryArray(checked_cast<const ::arrow::LargeBinaryArray&>(values));
   }
 }
 
-void AssertFixedSizeBinary(const ::arrow::Array& values, int type_length) {
+void assertFixedSizeBinary(const ::arrow::Array& values, int typeLength) {
   if (values.type_id() != ::arrow::Type::FIXED_SIZE_BINARY &&
-      values.type_id() != ::arrow::Type::DECIMAL) {
+      values.type_id() != ::arrow::Type::DECIMAL128) {
     throw ParquetException(
         "Only FixedSizeBinaryArray and subclasses supported");
   }
   if (checked_cast<const ::arrow::FixedSizeBinaryType&>(*values.type())
-          .byte_width() != type_length) {
+          .byte_width() != typeLength) {
     throw ParquetException(
         "Size mismatch: " + values.type()->ToString() + " should have been " +
-        std::to_string(type_length) + " wide");
+        std::to_string(typeLength) + " wide");
   }
 }
 
 template <>
-inline void PlainEncoder<FLBAType>::Put(const ::arrow::Array& values) {
-  AssertFixedSizeBinary(values, descr_->type_length());
+inline void PlainEncoder<FLBAType>::put(const ::arrow::Array& values) {
+  assertFixedSizeBinary(values, descr_->typeLength());
   const auto& data = checked_cast<const ::arrow::FixedSizeBinaryArray&>(values);
 
   if (data.null_count() == 0) {
-    // no nulls, just dump the data
+    // No nulls, just dump the data.
     PARQUET_THROW_NOT_OK(
         sink_.Append(data.raw_values(), data.length() * data.byte_width()));
   } else {
-    const int64_t total_bytes = data.length() * data.byte_width() -
+    const int64_t totalBytes = data.length() * data.byte_width() -
         data.null_count() * data.byte_width();
-    PARQUET_THROW_NOT_OK(sink_.Reserve(total_bytes));
+    PARQUET_THROW_NOT_OK(sink_.Reserve(totalBytes));
     for (int64_t i = 0; i < data.length(); i++) {
       if (data.IsValid(i)) {
         sink_.UnsafeAppend(data.Value(i), data.byte_width());
@@ -316,16 +313,16 @@ inline void PlainEncoder<FLBAType>::Put(const ::arrow::Array& values) {
 }
 
 template <>
-inline void PlainEncoder<FLBAType>::Put(
+inline void PlainEncoder<FLBAType>::put(
     const FixedLenByteArray* src,
-    int num_values) {
-  if (descr_->type_length() == 0) {
+    int numValues) {
+  if (descr_->typeLength() == 0) {
     return;
   }
-  for (int i = 0; i < num_values; ++i) {
-    // Write the result to the output stream
+  for (int i = 0; i < numValues; ++i) {
+    // Write the result to the output stream.
     VELOX_DCHECK_NOT_NULL(src[i].ptr, "Value ptr cannot be NULL");
-    PARQUET_THROW_NOT_OK(sink_.Append(src[i].ptr, descr_->type_length()));
+    PARQUET_THROW_NOT_OK(sink_.Append(src[i].ptr, descr_->typeLength()));
   }
 }
 
@@ -334,40 +331,38 @@ class PlainEncoder<BooleanType> : public EncoderImpl,
                                   virtual public BooleanEncoder {
  public:
   explicit PlainEncoder(const ColumnDescriptor* descr, MemoryPool* pool)
-      : EncoderImpl(descr, Encoding::PLAIN, pool),
-        bits_available_(kInMemoryDefaultCapacity * 8),
-        bits_buffer_(AllocateBuffer(pool, kInMemoryDefaultCapacity)),
+      : EncoderImpl(descr, Encoding::kPlain, pool),
+        bitsAvailable_(kInMemoryDefaultCapacity * 8),
+        bitsBuffer_(allocateBuffer(pool, kInMemoryDefaultCapacity)),
         sink_(pool),
-        bit_writer_(
-            bits_buffer_->mutable_data(),
-            static_cast<int>(bits_buffer_->size())) {}
+        bitWriter_(
+            bitsBuffer_->mutable_data(),
+            static_cast<int>(bitsBuffer_->size())) {}
 
-  int64_t EstimatedDataEncodedSize() override;
-  std::shared_ptr<Buffer> FlushValues() override;
+  int64_t estimatedDataEncodedSize() override;
+  std::shared_ptr<Buffer> flushValues() override;
 
-  void Put(const bool* src, int num_values) override;
+  void put(const bool* src, int numValues) override;
 
-  void Put(const std::vector<bool>& src, int num_values) override;
+  void put(const std::vector<bool>& src, int numValues) override;
 
-  void PutSpaced(
+  void putSpaced(
       const bool* src,
-      int num_values,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset) override {
-    if (valid_bits != NULLPTR) {
-      PARQUET_ASSIGN_OR_THROW(
-          auto buffer,
-          ::arrow::AllocateBuffer(num_values * sizeof(T), this->memory_pool()));
+      int numValues,
+      const uint8_t* validBits,
+      int64_t validBitsOffset) override {
+    if (validBits != NULLPTR) {
+      auto buffer = allocateBuffer(this->memoryPool(), numValues * sizeof(T));
       T* data = reinterpret_cast<T*>(buffer->mutable_data());
-      int num_valid_values = ::arrow::util::internal::SpacedCompress<T>(
-          src, num_values, valid_bits, valid_bits_offset, data);
-      Put(data, num_valid_values);
+      int numValidValues = ::arrow::util::internal::SpacedCompress<T>(
+          src, numValues, validBits, validBitsOffset, data);
+      put(data, numValidValues);
     } else {
-      Put(src, num_values);
+      put(src, numValues);
     }
   }
 
-  void Put(const ::arrow::Array& values) override {
+  void put(const ::arrow::Array& values) override {
     if (values.type_id() != ::arrow::Type::BOOL) {
       throw ParquetException(
           "direct put to boolean from " + values.type()->ToString() +
@@ -378,19 +373,19 @@ class PlainEncoder<BooleanType> : public EncoderImpl,
     if (data.null_count() == 0) {
       PARQUET_THROW_NOT_OK(
           sink_.Reserve(::arrow::bit_util::BytesForBits(data.length())));
-      // no nulls, just dump the data
+      // No nulls, just dump the data.
       ::arrow::internal::CopyBitmap(
-          data.data()->GetValues<uint8_t>(1),
+          data.data()->GetValues<uint8_t>(1, 0),
           data.offset(),
           data.length(),
           sink_.mutable_data(),
           sink_.length());
     } else {
-      auto n_valid =
+      auto nValid =
           ::arrow::bit_util::BytesForBits(data.length() - data.null_count());
-      PARQUET_THROW_NOT_OK(sink_.Reserve(n_valid));
+      PARQUET_THROW_NOT_OK(sink_.Reserve(nValid));
       ::arrow::internal::FirstTimeBitmapWriter writer(
-          sink_.mutable_data(), sink_.length(), n_valid);
+          sink_.mutable_data(), sink_.length(), nValid);
 
       for (int64_t i = 0; i < data.length(); i++) {
         if (data.IsValid(i)) {
@@ -408,69 +403,69 @@ class PlainEncoder<BooleanType> : public EncoderImpl,
   }
 
  private:
-  int bits_available_;
-  std::shared_ptr<ResizableBuffer> bits_buffer_;
+  int bitsAvailable_;
+  std::shared_ptr<ResizableBuffer> bitsBuffer_;
   ::arrow::BufferBuilder sink_;
-  BitWriter bit_writer_;
+  BitWriter bitWriter_;
 
   template <typename SequenceType>
-  void PutImpl(const SequenceType& src, int num_values);
+  void putImpl(const SequenceType& src, int numValues);
 };
 
 template <typename SequenceType>
-void PlainEncoder<BooleanType>::PutImpl(
+void PlainEncoder<BooleanType>::putImpl(
     const SequenceType& src,
-    int num_values) {
-  int bit_offset = 0;
-  if (bits_available_ > 0) {
-    int bits_to_write = std::min(bits_available_, num_values);
-    for (int i = 0; i < bits_to_write; i++) {
-      bit_writer_.PutValue(src[i], 1);
-    }
-    bits_available_ -= bits_to_write;
-    bit_offset = bits_to_write;
-
-    if (bits_available_ == 0) {
-      bit_writer_.Flush();
+    int numValues) {
+  int bitOffset = 0;
+  if (bitsAvailable_ > 0) {
+    int bitsToWrite = std::min(bitsAvailable_, numValues);
+    for (int i = 0; i < bitsToWrite; i++) {
+      bitWriter_.PutValue(src[i], 1);
+    }
+    bitsAvailable_ -= bitsToWrite;
+    bitOffset = bitsToWrite;
+
+    if (bitsAvailable_ == 0) {
+      bitWriter_.Flush();
       PARQUET_THROW_NOT_OK(
-          sink_.Append(bit_writer_.buffer(), bit_writer_.bytesWritten()));
-      bit_writer_.Clear();
+          sink_.Append(bitWriter_.buffer(), bitWriter_.bytesWritten()));
+      bitWriter_.Clear();
     }
   }
 
-  int bits_remaining = num_values - bit_offset;
-  while (bit_offset < num_values) {
-    bits_available_ = static_cast<int>(bits_buffer_->size()) * 8;
+  int bitsRemaining = numValues - bitOffset;
+  while (bitOffset < numValues) {
+    bitsAvailable_ = static_cast<int>(bitsBuffer_->size()) * 8;
 
-    int bits_to_write = std::min(bits_available_, bits_remaining);
-    for (int i = bit_offset; i < bit_offset + bits_to_write; i++) {
-      bit_writer_.PutValue(src[i], 1);
+    int bitsToWrite = std::min(bitsAvailable_, bitsRemaining);
+    for (int i = bitOffset; i < bitOffset + bitsToWrite; i++) {
+      bitWriter_.PutValue(src[i], 1);
     }
-    bit_offset += bits_to_write;
-    bits_available_ -= bits_to_write;
-    bits_remaining -= bits_to_write;
+    bitOffset += bitsToWrite;
+    bitsAvailable_ -= bitsToWrite;
+    bitsRemaining -= bitsToWrite;
 
-    if (bits_available_ == 0) {
-      bit_writer_.Flush();
+    if (bitsAvailable_ == 0) {
+      bitWriter_.Flush();
       PARQUET_THROW_NOT_OK(
-          sink_.Append(bit_writer_.buffer(), bit_writer_.bytesWritten()));
-      bit_writer_.Clear();
+          sink_.Append(bitWriter_.buffer(), bitWriter_.bytesWritten()));
+      bitWriter_.Clear();
     }
   }
 }
 
-int64_t PlainEncoder<BooleanType>::EstimatedDataEncodedSize() {
+int64_t PlainEncoder<BooleanType>::estimatedDataEncodedSize() {
   int64_t position = sink_.length();
-  return position + bit_writer_.bytesWritten();
+  return position + bitWriter_.bytesWritten();
 }
 
-std::shared_ptr<Buffer> PlainEncoder<BooleanType>::FlushValues() {
-  if (bits_available_ > 0) {
-    bit_writer_.Flush();
+std::shared_ptr<Buffer> PlainEncoder<BooleanType>::flushValues() {
+  if (bitsAvailable_ > 0) {
+    bitWriter_.Flush();
     PARQUET_THROW_NOT_OK(
-        sink_.Append(bit_writer_.buffer(), bit_writer_.bytesWritten()));
-    bit_writer_.Clear();
-    bits_available_ = static_cast<int>(bits_buffer_->size()) * 8;
+        sink_.Append(bitWriter_.buffer(), bitWriter_.bytesWritten()));
+    bitWriter_.Clear();
+    bitsAvailable_ = static_cast<int>(bitsBuffer_->size()) * 8;
   }
 
   std::shared_ptr<Buffer> buffer;
@@ -478,23 +473,23 @@ std::shared_ptr<Buffer> PlainEncoder<BooleanType>::FlushValues() {
   return buffer;
 }
 
-void PlainEncoder<BooleanType>::Put(const bool* src, int num_values) {
-  PutImpl(src, num_values);
+void PlainEncoder<BooleanType>::put(const bool* src, int numValues) {
+  putImpl(src, numValues);
 }
 
-void PlainEncoder<BooleanType>::Put(
+void PlainEncoder<BooleanType>::put(
     const std::vector<bool>& src,
-    int num_values) {
-  PutImpl(src, num_values);
+    int numValues) {
+  putImpl(src, numValues);
 }
 
-// ----------------------------------------------------------------------
-// DictEncoder<T> implementations
+// ----------------------------------------------------------------------.
+// DictEncoder<T> implementations.
 
 template <typename DType>
 struct DictEncoderTraits {
-  using c_type = typename DType::c_type;
-  using MemoTableType = ::arrow::internal::ScalarMemoTable<c_type>;
+  using CType = typename DType::CType;
+  using MemoTableType = ::arrow::internal::ScalarMemoTable<CType>;
 };
 
 template <>
@@ -509,129 +504,129 @@ struct DictEncoderTraits<FLBAType> {
       ::arrow::internal::BinaryMemoTable<::arrow::BinaryBuilder>;
 };
 
-// Initially 1024 elements
+// Initially 1024 elements.
 static constexpr int32_t kInitialHashTableSize = 1 << 10;
 
-int RlePreserveBufferSize(int num_values, int bit_width) {
+int rlePreserveBufferSize(int numValues, int bitWidth) {
   // Note: because of the way RleEncoder::CheckBufferFull()
-  // is called, we have to reserve an extra "RleEncoder::MinBufferSize"
-  // bytes. These extra bytes won't be used but not reserving them
-  // would cause the encoder to fail.
-  return RleEncoder::MaxBufferSize(bit_width, num_values) +
-      RleEncoder::MinBufferSize(bit_width);
+  // Is called, we have to reserve an extra "RleEncoder::MinBufferSize".
+  // Bytes. These extra bytes won't be used but not reserving them.
+  // Would cause the encoder to fail.
+  return RleEncoder::MaxBufferSize(bitWidth, numValues) +
+      RleEncoder::MinBufferSize(bitWidth);
 }
 
-/// See the dictionary encoding section of
+/// See the dictionary encoding section of.
 /// https://github.com/Parquet/parquet-format.  The encoding supports
-/// streaming encoding. Values are encoded as they are added while the
-/// dictionary is being constructed. At any time, the buffered values
-/// can be written out with the current dictionary size. More values
-/// can then be added to the encoder, including new dictionary
-/// entries.
+/// Streaming encoding. Values are encoded as they are added while the.
+/// Dictionary is being constructed. At any time, the buffered values.
+/// Can be written out with the current dictionary size. More values.
+/// Can then be added to the encoder, including new dictionary.
+/// Entries.
 template <typename DType>
 class DictEncoderImpl : public EncoderImpl, virtual public DictEncoder<DType> {
   using MemoTableType = typename DictEncoderTraits<DType>::MemoTableType;
 
  public:
-  typedef typename DType::c_type T;
+  typedef typename DType::CType T;
 
-  /// In data page, the bit width used to encode the entry
-  /// ids stored as 1 byte (max bit width = 32).
+  /// In data page, the bit width used to encode the entry.
+  /// Ids stored as 1 byte (max bit width = 32).
   constexpr static int32_t kDataPageBitWidthBytes = 1;
 
   explicit DictEncoderImpl(const ColumnDescriptor* desc, MemoryPool* pool)
-      : EncoderImpl(desc, Encoding::PLAIN_DICTIONARY, pool),
-        buffered_indices_(::arrow::stl::allocator<int32_t>(pool)),
-        dict_encoded_size_(0),
-        memo_table_(pool, kInitialHashTableSize) {}
+      : EncoderImpl(desc, Encoding::kPlainDictionary, pool),
+        bufferedIndices_(::arrow::stl::allocator<int32_t>(pool)),
+        dictEncodedSize_(0),
+        memoTable_(pool, kInitialHashTableSize) {}
 
   ~DictEncoderImpl() override {
-    VELOX_DCHECK(buffered_indices_.empty());
+    VELOX_DCHECK(bufferedIndices_.empty());
   }
 
-  int dict_encoded_size() const override {
-    return dict_encoded_size_;
+  int dictEncodedSize() const override {
+    return dictEncodedSize_;
   }
 
-  int WriteIndices(uint8_t* buffer, int buffer_len) override {
-    // Write bit width in first byte
-    *buffer = static_cast<uint8_t>(bit_width());
+  int writeIndices(uint8_t* buffer, int bufferLen) override {
+    // Write bit width in first byte.
+    *buffer = static_cast<uint8_t>(bitWidth());
     ++buffer;
-    --buffer_len;
+    --bufferLen;
 
-    RleEncoder encoder(buffer, buffer_len, bit_width());
+    RleEncoder encoder(buffer, bufferLen, bitWidth());
 
-    for (int32_t index : buffered_indices_) {
+    for (int32_t index : bufferedIndices_) {
       if (ARROW_PREDICT_FALSE(!encoder.Put(index)))
         return -1;
     }
     encoder.Flush();
 
-    ClearIndices();
+    clearIndices();
     return kDataPageBitWidthBytes + encoder.len();
   }
 
-  void set_type_length(int type_length) {
-    this->type_length_ = type_length;
+  void setTypeLength(int typeLength) {
+    this->typeLength_ = typeLength;
   }
 
-  /// Returns a conservative estimate of the number of bytes needed to encode
-  /// the buffered indices. Used to size the buffer passed to WriteIndices().
-  int64_t EstimatedDataEncodedSize() override {
+  /// Returns a conservative estimate of the number of bytes needed to encode.
+  /// The buffered indices. Used to size the buffer passed to WriteIndices().
+  int64_t estimatedDataEncodedSize() override {
     return kDataPageBitWidthBytes +
-        RlePreserveBufferSize(
-               static_cast<int>(buffered_indices_.size()), bit_width());
+        rlePreserveBufferSize(
+               static_cast<int>(bufferedIndices_.size()), bitWidth());
   }
 
   /// The minimum bit width required to encode the currently buffered indices.
-  int bit_width() const override {
-    if (ARROW_PREDICT_FALSE(num_entries() == 0))
+  int bitWidth() const override {
+    if (ARROW_PREDICT_FALSE(numEntries() == 0))
       return 0;
-    if (ARROW_PREDICT_FALSE(num_entries() == 1))
+    if (ARROW_PREDICT_FALSE(numEntries() == 1))
       return 1;
-    return ::arrow::bit_util::Log2(num_entries());
+    return ::arrow::bit_util::Log2(numEntries());
   }
 
-  /// Encode value. Note that this does not actually write any data, just
-  /// buffers the value's index to be written later.
-  inline void Put(const T& value);
+  /// Encode value. Note that this does not actually write any data, just.
+  /// Buffers the value's index to be written later.
+  inline void put(const T& value);
 
-  // Not implemented for other data types
-  inline void PutByteArray(const void* ptr, int32_t length);
+  // Not implemented for other data types.
+  inline void putByteArray(const void* ptr, int32_t length);
 
-  void Put(const T* src, int num_values) override {
-    for (int32_t i = 0; i < num_values; i++) {
-      Put(SafeLoad(src + i));
+  void put(const T* src, int numValues) override {
+    for (int32_t i = 0; i < numValues; i++) {
+      put(SafeLoad(src + i));
     }
   }
 
-  void PutSpaced(
+  void putSpaced(
       const T* src,
-      int num_values,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset) override {
+      int numValues,
+      const uint8_t* validBits,
+      int64_t validBitsOffset) override {
     ::arrow::internal::VisitSetBitRunsVoid(
-        valid_bits,
-        valid_bits_offset,
-        num_values,
+        validBits,
+        validBitsOffset,
+        numValues,
         [&](int64_t position, int64_t length) {
           for (int64_t i = 0; i < length; i++) {
-            Put(SafeLoad(src + i + position));
+            put(SafeLoad(src + i + position));
           }
         });
   }
 
-  using TypedEncoder<DType>::Put;
+  using TypedEncoder<DType>::put;
 
-  void Put(const ::arrow::Array& values) override;
-  void PutDictionary(const ::arrow::Array& values) override;
+  void put(const ::arrow::Array& values) override;
+  void putDictionary(const ::arrow::Array& values) override;
 
   template <typename ArrowType, typename T = typename ArrowType::c_type>
-  void PutIndicesTyped(const ::arrow::Array& data) {
+  void putIndicesTyped(const ::arrow::Array& data) {
     auto values = data.data()->GetValues<T>(1);
-    size_t buffer_position = buffered_indices_.size();
-    buffered_indices_.resize(
-        buffer_position +
+    size_t bufferPosition = bufferedIndices_.size();
+    bufferedIndices_.resize(
+        bufferPosition +
         static_cast<size_t>(data.length() - data.null_count()));
     ::arrow::internal::VisitSetBitRunsVoid(
         data.null_bitmap_data(),
@@ -639,60 +634,60 @@ class DictEncoderImpl : public EncoderImpl, virtual public DictEncoder<DType> {
         data.length(),
         [&](int64_t position, int64_t length) {
           for (int64_t i = 0; i < length; ++i) {
-            buffered_indices_[buffer_position++] =
+            bufferedIndices_[bufferPosition++] =
                 static_cast<int32_t>(values[i + position]);
           }
         });
   }
 
-  void PutIndices(const ::arrow::Array& data) override {
+  void putIndices(const ::arrow::Array& data) override {
     switch (data.type()->id()) {
       case ::arrow::Type::UINT8:
       case ::arrow::Type::INT8:
-        return PutIndicesTyped<::arrow::UInt8Type>(data);
+        return putIndicesTyped<::arrow::UInt8Type>(data);
       case ::arrow::Type::UINT16:
       case ::arrow::Type::INT16:
-        return PutIndicesTyped<::arrow::UInt16Type>(data);
+        return putIndicesTyped<::arrow::UInt16Type>(data);
       case ::arrow::Type::UINT32:
       case ::arrow::Type::INT32:
-        return PutIndicesTyped<::arrow::UInt32Type>(data);
+        return putIndicesTyped<::arrow::UInt32Type>(data);
       case ::arrow::Type::UINT64:
       case ::arrow::Type::INT64:
-        return PutIndicesTyped<::arrow::UInt64Type>(data);
+        return putIndicesTyped<::arrow::UInt64Type>(data);
       default:
         throw ParquetException("Passed non-integer array to PutIndices");
     }
   }
 
-  std::shared_ptr<Buffer> FlushValues() override {
+  std::shared_ptr<Buffer> flushValues() override {
     std::shared_ptr<ResizableBuffer> buffer =
-        AllocateBuffer(this->pool_, EstimatedDataEncodedSize());
-    int result_size = WriteIndices(
-        buffer->mutable_data(), static_cast<int>(EstimatedDataEncodedSize()));
-    PARQUET_THROW_NOT_OK(buffer->Resize(result_size, false));
+        allocateBuffer(this->pool_, estimatedDataEncodedSize());
+    int resultSize = writeIndices(
+        buffer->mutable_data(), static_cast<int>(estimatedDataEncodedSize()));
+    PARQUET_THROW_NOT_OK(buffer->Resize(resultSize, false));
     return std::move(buffer);
   }
 
-  /// Writes out the encoded dictionary to buffer. buffer must be preallocated
-  /// to dict_encoded_size() bytes.
-  void WriteDict(uint8_t* buffer) const override;
+  /// Writes out the encoded dictionary to buffer. buffer must be preallocated.
+  /// To dict_encoded_size() bytes.
+  void writeDict(uint8_t* buffer) const override;
 
   /// The number of entries in the dictionary.
-  int num_entries() const override {
-    return memo_table_.size();
+  int numEntries() const override {
+    return memoTable_.size();
   }
 
  private:
   /// Clears all the indices (but leaves the dictionary).
-  void ClearIndices() {
-    buffered_indices_.clear();
+  void clearIndices() {
+    bufferedIndices_.clear();
   }
 
   /// Indices that have not yet be written out by WriteIndices().
-  ArrowPoolVector<int32_t> buffered_indices_;
+  ArrowPoolVector<int32_t> bufferedIndices_;
 
   template <typename ArrayType>
-  void PutBinaryArray(const ArrayType& array) {
+  void putBinaryArray(const ArrayType& array) {
     PARQUET_THROW_NOT_OK(
         ::arrow::VisitArraySpanInline<typename ArrayType::TypeClass>(
             *array.data(),
@@ -701,14 +696,14 @@ class DictEncoderImpl : public EncoderImpl, virtual public DictEncoder<DType> {
                 return Status::Invalid(
                     "Parquet cannot store strings with size 2GB or more");
               }
-              PutByteArray(view.data(), static_cast<uint32_t>(view.size()));
+              putByteArray(view.data(), static_cast<uint32_t>(view.size()));
               return Status::OK();
             },
             []() { return Status::OK(); }));
   }
 
   template <typename ArrayType>
-  void PutBinaryDictionaryArray(const ArrayType& array) {
+  void putBinaryDictionaryArray(const ArrayType& array) {
     VELOX_DCHECK_EQ(array.null_count(), 0);
     for (int64_t i = 0; i < array.length(); i++) {
       auto v = array.GetView(i);
@@ -716,31 +711,31 @@ class DictEncoderImpl : public EncoderImpl, virtual public DictEncoder<DType> {
         throw ParquetException(
             "Parquet cannot store strings with size 2GB or more");
       }
-      dict_encoded_size_ += static_cast<int>(v.size() + sizeof(uint32_t));
-      int32_t unused_memo_index;
-      PARQUET_THROW_NOT_OK(memo_table_.GetOrInsert(
-          v.data(), static_cast<int32_t>(v.size()), &unused_memo_index));
+      dictEncodedSize_ += static_cast<int>(v.size() + sizeof(uint32_t));
+      int32_t unusedMemoIndex;
+      PARQUET_THROW_NOT_OK(memoTable_.GetOrInsert(
+          v.data(), static_cast<int32_t>(v.size()), &unusedMemoIndex));
     }
   }
 
   /// The number of bytes needed to encode the dictionary.
-  int dict_encoded_size_;
+  int dictEncodedSize_;
 
-  MemoTableType memo_table_;
+  MemoTableType memoTable_;
 };
 
 template <typename DType>
-void DictEncoderImpl<DType>::WriteDict(uint8_t* buffer) const {
-  // For primitive types, only a memcpy
+void DictEncoderImpl<DType>::writeDict(uint8_t* buffer) const {
+  // For primitive types, only a memcpy.
   VELOX_DCHECK_EQ(
-      static_cast<size_t>(dict_encoded_size_), sizeof(T) * memo_table_.size());
-  memo_table_.CopyValues(0 /* start_pos */, reinterpret_cast<T*>(buffer));
+      static_cast<size_t>(dictEncodedSize_), sizeof(T) * memoTable_.size());
+  memoTable_.CopyValues(0 /* start_pos */, reinterpret_cast<T*>(buffer));
 }
 
-// ByteArray and FLBA already have the dictionary encoded in their data heaps
+// ByteArray and FLBA already have the dictionary encoded in their data heaps.
 template <>
-void DictEncoderImpl<ByteArrayType>::WriteDict(uint8_t* buffer) const {
-  memo_table_.VisitValues(0, [&buffer](::std::string_view v) {
+void DictEncoderImpl<ByteArrayType>::writeDict(uint8_t* buffer) const {
+  memoTable_.VisitValues(0, [&buffer](::std::string_view v) {
     uint32_t len = static_cast<uint32_t>(v.length());
     memcpy(buffer, &len, sizeof(len));
     buffer += sizeof(len);
@@ -750,231 +745,231 @@ void DictEncoderImpl<ByteArrayType>::WriteDict(uint8_t* buffer) const {
 }
 
 template <>
-void DictEncoderImpl<FLBAType>::WriteDict(uint8_t* buffer) const {
-  memo_table_.VisitValues(0, [&](::std::string_view v) {
-    VELOX_DCHECK_EQ(v.length(), static_cast<size_t>(type_length_));
-    memcpy(buffer, v.data(), type_length_);
-    buffer += type_length_;
+void DictEncoderImpl<FLBAType>::writeDict(uint8_t* buffer) const {
+  memoTable_.VisitValues(0, [&](::std::string_view v) {
+    VELOX_DCHECK_EQ(v.length(), static_cast<size_t>(typeLength_));
+    memcpy(buffer, v.data(), typeLength_);
+    buffer += typeLength_;
   });
 }
 
 template <typename DType>
-inline void DictEncoderImpl<DType>::Put(const T& v) {
-  // Put() implementation for primitive types
-  auto on_found = [](int32_t memo_index) {};
-  auto on_not_found = [this](int32_t memo_index) {
-    dict_encoded_size_ += static_cast<int>(sizeof(T));
+inline void DictEncoderImpl<DType>::put(const T& v) {
+  // Put() implementation for primitive types.
+  auto onFound = [](int32_t memoIndex) {};
+  auto onNotFound = [this](int32_t memoIndex) {
+    dictEncodedSize_ += static_cast<int>(sizeof(T));
   };
 
-  int32_t memo_index;
+  int32_t memoIndex;
   PARQUET_THROW_NOT_OK(
-      memo_table_.GetOrInsert(v, on_found, on_not_found, &memo_index));
-  buffered_indices_.push_back(memo_index);
+      memoTable_.GetOrInsert(v, onFound, onNotFound, &memoIndex));
+  bufferedIndices_.push_back(memoIndex);
 }
 
 template <typename DType>
-inline void DictEncoderImpl<DType>::PutByteArray(
+inline void DictEncoderImpl<DType>::putByteArray(
     const void* ptr,
     int32_t length) {
   VELOX_DCHECK(false);
 }
 
 template <>
-inline void DictEncoderImpl<ByteArrayType>::PutByteArray(
+inline void DictEncoderImpl<ByteArrayType>::putByteArray(
     const void* ptr,
     int32_t length) {
   static const uint8_t empty[] = {0};
 
-  auto on_found = [](int32_t memo_index) {};
-  auto on_not_found = [&](int32_t memo_index) {
-    dict_encoded_size_ += static_cast<int>(length + sizeof(uint32_t));
+  auto onFound = [](int32_t memoIndex) {};
+  auto onNotFound = [&](int32_t memoIndex) {
+    dictEncodedSize_ += static_cast<int>(length + sizeof(uint32_t));
   };
 
   VELOX_DCHECK(ptr != nullptr || length == 0);
   ptr = (ptr != nullptr) ? ptr : empty;
-  int32_t memo_index;
-  PARQUET_THROW_NOT_OK(memo_table_.GetOrInsert(
-      ptr, length, on_found, on_not_found, &memo_index));
-  buffered_indices_.push_back(memo_index);
+  int32_t memoIndex;
+  PARQUET_THROW_NOT_OK(
+      memoTable_.GetOrInsert(ptr, length, onFound, onNotFound, &memoIndex));
+  bufferedIndices_.push_back(memoIndex);
 }
 
 template <>
-inline void DictEncoderImpl<ByteArrayType>::Put(const ByteArray& val) {
-  return PutByteArray(val.ptr, static_cast<int32_t>(val.len));
+inline void DictEncoderImpl<ByteArrayType>::put(const ByteArray& val) {
+  return putByteArray(val.ptr, static_cast<int32_t>(val.len));
 }
 
 template <>
-inline void DictEncoderImpl<FLBAType>::Put(const FixedLenByteArray& v) {
+inline void DictEncoderImpl<FLBAType>::put(const FixedLenByteArray& v) {
   static const uint8_t empty[] = {0};
 
-  auto on_found = [](int32_t memo_index) {};
-  auto on_not_found = [this](int32_t memo_index) {
-    dict_encoded_size_ += type_length_;
+  auto onFound = [](int32_t memoIndex) {};
+  auto onNotFound = [this](int32_t memoIndex) {
+    dictEncodedSize_ += typeLength_;
   };
 
-  VELOX_DCHECK(v.ptr != nullptr || type_length_ == 0);
+  VELOX_DCHECK(v.ptr != nullptr || typeLength_ == 0);
   const void* ptr = (v.ptr != nullptr) ? v.ptr : empty;
-  int32_t memo_index;
-  PARQUET_THROW_NOT_OK(memo_table_.GetOrInsert(
-      ptr, type_length_, on_found, on_not_found, &memo_index));
-  buffered_indices_.push_back(memo_index);
+  int32_t memoIndex;
+  PARQUET_THROW_NOT_OK(memoTable_.GetOrInsert(
+      ptr, typeLength_, onFound, onNotFound, &memoIndex));
+  bufferedIndices_.push_back(memoIndex);
 }
 
 template <>
-void DictEncoderImpl<Int96Type>::Put(const ::arrow::Array& values) {
+void DictEncoderImpl<Int96Type>::put(const ::arrow::Array& values) {
   ParquetException::NYI("Direct put to Int96");
 }
 
 template <>
-void DictEncoderImpl<Int96Type>::PutDictionary(const ::arrow::Array& values) {
+void DictEncoderImpl<Int96Type>::putDictionary(const ::arrow::Array& values) {
   ParquetException::NYI("Direct put to Int96");
 }
 
 template <typename DType>
-void DictEncoderImpl<DType>::Put(const ::arrow::Array& values) {
+void DictEncoderImpl<DType>::put(const ::arrow::Array& values) {
   using ArrayType =
-      typename ::arrow::CTypeTraits<typename DType::c_type>::ArrayType;
+      typename ::arrow::CTypeTraits<typename DType::CType>::ArrayType;
   const auto& data = checked_cast<const ArrayType&>(values);
   if (data.null_count() == 0) {
-    // no nulls, just dump the data
+    // No nulls, just dump the data.
     for (int64_t i = 0; i < data.length(); i++) {
-      Put(data.Value(i));
+      put(data.Value(i));
     }
   } else {
     for (int64_t i = 0; i < data.length(); i++) {
       if (data.IsValid(i)) {
-        Put(data.Value(i));
+        put(data.Value(i));
       }
     }
   }
 }
 
 template <>
-void DictEncoderImpl<FLBAType>::Put(const ::arrow::Array& values) {
-  AssertFixedSizeBinary(values, type_length_);
+void DictEncoderImpl<FLBAType>::put(const ::arrow::Array& values) {
+  assertFixedSizeBinary(values, typeLength_);
   const auto& data = checked_cast<const ::arrow::FixedSizeBinaryArray&>(values);
   if (data.null_count() == 0) {
-    // no nulls, just dump the data
+    // No nulls, just dump the data.
     for (int64_t i = 0; i < data.length(); i++) {
-      Put(FixedLenByteArray(data.Value(i)));
+      put(FixedLenByteArray(data.Value(i)));
     }
   } else {
-    std::vector<uint8_t> empty(type_length_, 0);
+    std::vector<uint8_t> empty(typeLength_, 0);
     for (int64_t i = 0; i < data.length(); i++) {
       if (data.IsValid(i)) {
-        Put(FixedLenByteArray(data.Value(i)));
+        put(FixedLenByteArray(data.Value(i)));
       }
     }
   }
 }
 
 template <>
-void DictEncoderImpl<ByteArrayType>::Put(const ::arrow::Array& values) {
-  AssertBaseBinary(values);
+void DictEncoderImpl<ByteArrayType>::put(const ::arrow::Array& values) {
+  assertBaseBinary(values);
   if (::arrow::is_binary_like(values.type_id())) {
-    PutBinaryArray(checked_cast<const ::arrow::BinaryArray&>(values));
+    putBinaryArray(checked_cast<const ::arrow::BinaryArray&>(values));
   } else {
     VELOX_DCHECK(::arrow::is_large_binary_like(values.type_id()));
-    PutBinaryArray(checked_cast<const ::arrow::LargeBinaryArray&>(values));
+    putBinaryArray(checked_cast<const ::arrow::LargeBinaryArray&>(values));
   }
 }
 
 template <typename DType>
-void AssertCanPutDictionary(
+void assertCanPutDictionary(
     DictEncoderImpl<DType>* encoder,
     const ::arrow::Array& dict) {
   if (dict.null_count() > 0) {
     throw ParquetException("Inserted dictionary cannot cannot contain nulls");
   }
 
-  if (encoder->num_entries() > 0) {
+  if (encoder->numEntries() > 0) {
     throw ParquetException(
         "Can only call PutDictionary on an empty DictEncoder");
   }
 }
 
 template <typename DType>
-void DictEncoderImpl<DType>::PutDictionary(const ::arrow::Array& values) {
-  AssertCanPutDictionary(this, values);
+void DictEncoderImpl<DType>::putDictionary(const ::arrow::Array& values) {
+  assertCanPutDictionary(this, values);
 
   using ArrayType =
-      typename ::arrow::CTypeTraits<typename DType::c_type>::ArrayType;
+      typename ::arrow::CTypeTraits<typename DType::CType>::ArrayType;
   const auto& data = checked_cast<const ArrayType&>(values);
 
-  dict_encoded_size_ +=
-      static_cast<int>(sizeof(typename DType::c_type) * data.length());
+  dictEncodedSize_ +=
+      static_cast<int>(sizeof(typename DType::CType) * data.length());
   for (int64_t i = 0; i < data.length(); i++) {
-    int32_t unused_memo_index;
+    int32_t unusedMemoIndex;
     PARQUET_THROW_NOT_OK(
-        memo_table_.GetOrInsert(data.Value(i), &unused_memo_index));
+        memoTable_.GetOrInsert(data.Value(i), &unusedMemoIndex));
   }
 }
 
 template <>
-void DictEncoderImpl<FLBAType>::PutDictionary(const ::arrow::Array& values) {
-  AssertFixedSizeBinary(values, type_length_);
-  AssertCanPutDictionary(this, values);
+void DictEncoderImpl<FLBAType>::putDictionary(const ::arrow::Array& values) {
+  assertFixedSizeBinary(values, typeLength_);
+  assertCanPutDictionary(this, values);
 
   const auto& data = checked_cast<const ::arrow::FixedSizeBinaryArray&>(values);
 
-  dict_encoded_size_ += static_cast<int>(type_length_ * data.length());
+  dictEncodedSize_ += static_cast<int>(typeLength_ * data.length());
   for (int64_t i = 0; i < data.length(); i++) {
-    int32_t unused_memo_index;
-    PARQUET_THROW_NOT_OK(memo_table_.GetOrInsert(
-        data.Value(i), type_length_, &unused_memo_index));
+    int32_t unusedMemoIndex;
+    PARQUET_THROW_NOT_OK(
+        memoTable_.GetOrInsert(data.Value(i), typeLength_, &unusedMemoIndex));
   }
 }
 
 template <>
-void DictEncoderImpl<ByteArrayType>::PutDictionary(
+void DictEncoderImpl<ByteArrayType>::putDictionary(
     const ::arrow::Array& values) {
-  AssertBaseBinary(values);
-  AssertCanPutDictionary(this, values);
+  assertBaseBinary(values);
+  assertCanPutDictionary(this, values);
 
   if (::arrow::is_binary_like(values.type_id())) {
-    PutBinaryDictionaryArray(checked_cast<const ::arrow::BinaryArray&>(values));
+    putBinaryDictionaryArray(checked_cast<const ::arrow::BinaryArray&>(values));
   } else {
     VELOX_DCHECK(::arrow::is_large_binary_like(values.type_id()));
-    PutBinaryDictionaryArray(
+    putBinaryDictionaryArray(
         checked_cast<const ::arrow::LargeBinaryArray&>(values));
   }
 }
 
-// ----------------------------------------------------------------------
-// ByteStreamSplitEncoder<T> implementations
+// ----------------------------------------------------------------------.
+// ByteStreamSplitEncoder<T> implementations.
 
 template <typename DType>
 class ByteStreamSplitEncoder : public EncoderImpl,
                                virtual public TypedEncoder<DType> {
  public:
-  using T = typename DType::c_type;
-  using TypedEncoder<DType>::Put;
+  using T = typename DType::CType;
+  using TypedEncoder<DType>::put;
 
   explicit ByteStreamSplitEncoder(
       const ColumnDescriptor* descr,
       ::arrow::MemoryPool* pool = ::arrow::default_memory_pool());
 
-  int64_t EstimatedDataEncodedSize() override;
-  std::shared_ptr<Buffer> FlushValues() override;
+  int64_t estimatedDataEncodedSize() override;
+  std::shared_ptr<Buffer> flushValues() override;
 
-  void Put(const T* buffer, int num_values) override;
-  void Put(const ::arrow::Array& values) override;
-  void PutSpaced(
+  void put(const T* buffer, int numValues) override;
+  void put(const ::arrow::Array& values) override;
+  void putSpaced(
       const T* src,
-      int num_values,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset) override;
+      int numValues,
+      const uint8_t* validBits,
+      int64_t validBitsOffset) override;
 
  protected:
   template <typename ArrowType>
-  void PutImpl(const ::arrow::Array& values) {
+  void putImpl(const ::arrow::Array& values) {
     if (values.type_id() != ArrowType::type_id) {
       throw ParquetException(
           std::string() + "direct put to " + ArrowType::type_name() + " from " +
           values.type()->ToString() + " not supported");
     }
     const auto& data = *values.data();
-    PutSpaced(
+    putSpaced(
         data.GetValues<typename ArrowType::c_type>(1),
         static_cast<int>(data.length),
         data.GetValues<uint8_t>(0, 0),
@@ -982,82 +977,79 @@ class ByteStreamSplitEncoder : public EncoderImpl,
   }
 
   ::arrow::BufferBuilder sink_;
-  int64_t num_values_in_buffer_;
+  int64_t numValuesInBuffer_;
 };
 
 template <typename DType>
 ByteStreamSplitEncoder<DType>::ByteStreamSplitEncoder(
     const ColumnDescriptor* descr,
     ::arrow::MemoryPool* pool)
-    : EncoderImpl(descr, Encoding::BYTE_STREAM_SPLIT, pool),
+    : EncoderImpl(descr, Encoding::kByteStreamSplit, pool),
       sink_{pool},
-      num_values_in_buffer_{0} {}
+      numValuesInBuffer_{0} {}
 
 template <typename DType>
-int64_t ByteStreamSplitEncoder<DType>::EstimatedDataEncodedSize() {
+int64_t ByteStreamSplitEncoder<DType>::estimatedDataEncodedSize() {
   return sink_.length();
 }
 
 template <typename DType>
-std::shared_ptr<Buffer> ByteStreamSplitEncoder<DType>::FlushValues() {
-  std::shared_ptr<ResizableBuffer> output_buffer =
-      AllocateBuffer(this->memory_pool(), EstimatedDataEncodedSize());
-  uint8_t* output_buffer_raw = output_buffer->mutable_data();
+std::shared_ptr<Buffer> ByteStreamSplitEncoder<DType>::flushValues() {
+  std::shared_ptr<ResizableBuffer> outputBuffer =
+      allocateBuffer(this->memoryPool(), estimatedDataEncodedSize());
+  uint8_t* outputBufferRaw = outputBuffer->mutable_data();
   const uint8_t* raw_values = sink_.data();
-  ByteStreamSplitEncode<T>(
-      raw_values, num_values_in_buffer_, output_buffer_raw);
+  byteStreamSplitEncode<T>(raw_values, numValuesInBuffer_, outputBufferRaw);
   sink_.Reset();
-  num_values_in_buffer_ = 0;
-  return std::move(output_buffer);
+  numValuesInBuffer_ = 0;
+  return std::move(outputBuffer);
 }
 
 template <typename DType>
-void ByteStreamSplitEncoder<DType>::Put(const T* buffer, int num_values) {
-  if (num_values > 0) {
-    PARQUET_THROW_NOT_OK(sink_.Append(buffer, num_values * sizeof(T)));
-    num_values_in_buffer_ += num_values;
+void ByteStreamSplitEncoder<DType>::put(const T* buffer, int numValues) {
+  if (numValues > 0) {
+    PARQUET_THROW_NOT_OK(sink_.Append(buffer, numValues * sizeof(T)));
+    numValuesInBuffer_ += numValues;
   }
 }
 
 template <>
-void ByteStreamSplitEncoder<FloatType>::Put(const ::arrow::Array& values) {
-  PutImpl<::arrow::FloatType>(values);
+void ByteStreamSplitEncoder<FloatType>::put(const ::arrow::Array& values) {
+  putImpl<::arrow::FloatType>(values);
 }
 
 template <>
-void ByteStreamSplitEncoder<DoubleType>::Put(const ::arrow::Array& values) {
-  PutImpl<::arrow::DoubleType>(values);
+void ByteStreamSplitEncoder<DoubleType>::put(const ::arrow::Array& values) {
+  putImpl<::arrow::DoubleType>(values);
 }
 
 template <typename DType>
-void ByteStreamSplitEncoder<DType>::PutSpaced(
+void ByteStreamSplitEncoder<DType>::putSpaced(
     const T* src,
-    int num_values,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset) {
-  if (valid_bits != NULLPTR) {
-    PARQUET_ASSIGN_OR_THROW(
-        auto buffer,
-        ::arrow::AllocateBuffer(num_values * sizeof(T), this->memory_pool()));
+    int numValues,
+    const uint8_t* validBits,
+    int64_t validBitsOffset) {
+  if (validBits != NULLPTR) {
+    auto buffer = allocateBuffer(this->memoryPool(), numValues * sizeof(T));
     T* data = reinterpret_cast<T*>(buffer->mutable_data());
-    int num_valid_values = ::arrow::util::internal::SpacedCompress<T>(
-        src, num_values, valid_bits, valid_bits_offset, data);
-    Put(data, num_valid_values);
+    int numValidValues = ::arrow::util::internal::SpacedCompress<T>(
+        src, numValues, validBits, validBitsOffset, data);
+    put(data, numValidValues);
   } else {
-    Put(src, num_values);
+    put(src, numValues);
   }
 }
 
 class DecoderImpl : virtual public Decoder {
  public:
-  void SetData(int num_values, const uint8_t* data, int len) override {
-    num_values_ = num_values;
+  void setData(int numValues, const uint8_t* data, int len) override {
+    numValues_ = numValues;
     data_ = data;
     len_ = len;
   }
 
-  int values_left() const override {
-    return num_values_;
+  int valuesLeft() const override {
+    return numValues_;
   }
   Encoding::type encoding() const override {
     return encoding_;
@@ -1067,553 +1059,545 @@ class DecoderImpl : virtual public Decoder {
   explicit DecoderImpl(const ColumnDescriptor* descr, Encoding::type encoding)
       : descr_(descr),
         encoding_(encoding),
-        num_values_(0),
+        numValues_(0),
         data_(NULLPTR),
         len_(0) {}
 
-  // For accessing type-specific metadata, like FIXED_LEN_BYTE_ARRAY
+  // For accessing type-specific metadata, like FIXED_LEN_BYTE_ARRAY.
   const ColumnDescriptor* descr_;
 
   const Encoding::type encoding_;
-  int num_values_;
+  int numValues_;
   const uint8_t* data_;
   int len_;
-  int type_length_;
+  int typeLength_;
 };
 
 template <typename DType>
 class PlainDecoder : public DecoderImpl, virtual public TypedDecoder<DType> {
  public:
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
   explicit PlainDecoder(const ColumnDescriptor* descr);
 
-  int Decode(T* buffer, int max_values) override;
-
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      typename EncodingTraits<DType>::Accumulator* builder) override;
-
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      typename EncodingTraits<DType>::DictAccumulator* builder) override;
+  int decode(T* buffer, int maxValues) override;
+
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      typename EncodingTraits<DType>::Accumulator* Builder) override;
+
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      typename EncodingTraits<DType>::DictAccumulator* Builder) override;
 };
 
 template <>
-inline int PlainDecoder<Int96Type>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<Int96Type>::Accumulator* builder) {
+inline int PlainDecoder<Int96Type>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<Int96Type>::Accumulator* Builder) {
   ParquetException::NYI("DecodeArrow not supported for Int96");
 }
 
 template <>
-inline int PlainDecoder<Int96Type>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<Int96Type>::DictAccumulator* builder) {
+inline int PlainDecoder<Int96Type>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<Int96Type>::DictAccumulator* Builder) {
   ParquetException::NYI("DecodeArrow not supported for Int96");
 }
 
 template <>
-inline int PlainDecoder<BooleanType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<BooleanType>::DictAccumulator* builder) {
+inline int PlainDecoder<BooleanType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<BooleanType>::DictAccumulator* Builder) {
   ParquetException::NYI("dictionaries of BooleanType");
 }
 
 template <typename DType>
-int PlainDecoder<DType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<DType>::Accumulator* builder) {
-  using value_type = typename DType::c_type;
+int PlainDecoder<DType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<DType>::Accumulator* Builder) {
+  using ValueType = typename DType::CType;
 
-  constexpr int value_size = static_cast<int>(sizeof(value_type));
-  int values_decoded = num_values - null_count;
-  if (ARROW_PREDICT_FALSE(len_ < value_size * values_decoded)) {
-    ParquetException::EofException();
+  constexpr int valueSize = static_cast<int>(sizeof(ValueType));
+  int valuesDecoded = numValues - nullCount;
+  if (ARROW_PREDICT_FALSE(len_ < valueSize * valuesDecoded)) {
+    ParquetException::eofException();
   }
 
-  PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
+  PARQUET_THROW_NOT_OK(Builder->Reserve(numValues));
 
   VisitNullBitmapInline(
-      valid_bits,
-      valid_bits_offset,
-      num_values,
-      null_count,
+      validBits,
+      validBitsOffset,
+      numValues,
+      nullCount,
       [&]() {
-        builder->UnsafeAppend(SafeLoadAs<value_type>(data_));
-        data_ += sizeof(value_type);
+        Builder->UnsafeAppend(SafeLoadAs<ValueType>(data_));
+        data_ += sizeof(ValueType);
       },
-      [&]() { builder->UnsafeAppendNull(); });
+      [&]() { Builder->UnsafeAppendNull(); });
 
-  num_values_ -= values_decoded;
-  len_ -= sizeof(value_type) * values_decoded;
-  return values_decoded;
+  numValues_ -= valuesDecoded;
+  len_ -= sizeof(ValueType) * valuesDecoded;
+  return valuesDecoded;
 }
 
 template <typename DType>
-int PlainDecoder<DType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<DType>::DictAccumulator* builder) {
-  using value_type = typename DType::c_type;
+int PlainDecoder<DType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<DType>::DictAccumulator* Builder) {
+  using ValueType = typename DType::CType;
 
-  constexpr int value_size = static_cast<int>(sizeof(value_type));
-  int values_decoded = num_values - null_count;
-  if (ARROW_PREDICT_FALSE(len_ < value_size * values_decoded)) {
-    ParquetException::EofException();
+  constexpr int valueSize = static_cast<int>(sizeof(ValueType));
+  int valuesDecoded = numValues - nullCount;
+  if (ARROW_PREDICT_FALSE(len_ < valueSize * valuesDecoded)) {
+    ParquetException::eofException();
   }
 
-  PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
+  PARQUET_THROW_NOT_OK(Builder->Reserve(numValues));
 
   VisitNullBitmapInline(
-      valid_bits,
-      valid_bits_offset,
-      num_values,
-      null_count,
+      validBits,
+      validBitsOffset,
+      numValues,
+      nullCount,
       [&]() {
-        PARQUET_THROW_NOT_OK(builder->Append(SafeLoadAs<value_type>(data_)));
-        data_ += sizeof(value_type);
+        PARQUET_THROW_NOT_OK(Builder->Append(SafeLoadAs<ValueType>(data_)));
+        data_ += sizeof(ValueType);
       },
-      [&]() { PARQUET_THROW_NOT_OK(builder->AppendNull()); });
+      [&]() { PARQUET_THROW_NOT_OK(Builder->AppendNull()); });
 
-  num_values_ -= values_decoded;
-  len_ -= sizeof(value_type) * values_decoded;
-  return values_decoded;
+  numValues_ -= valuesDecoded;
+  len_ -= sizeof(ValueType) * valuesDecoded;
+  return valuesDecoded;
 }
 
-// Decode routine templated on C++ type rather than type enum
+// Decode routine templated on C++ type rather than type enum.
 template <typename T>
-inline int DecodePlain(
+inline int decodePlain(
     const uint8_t* data,
-    int64_t data_size,
-    int num_values,
-    int type_length,
+    int64_t dataSize,
+    int numValues,
+    int typeLength,
     T* out) {
-  int64_t bytes_to_decode = num_values * static_cast<int64_t>(sizeof(T));
-  if (bytes_to_decode > data_size || bytes_to_decode > INT_MAX) {
-    ParquetException::EofException();
+  int64_t bytesToDecode = numValues * static_cast<int64_t>(sizeof(T));
+  if (bytesToDecode > dataSize || bytesToDecode > INT_MAX) {
+    ParquetException::eofException();
   }
-  // If bytes_to_decode == 0, data could be null
-  if (bytes_to_decode > 0) {
-    memcpy(out, data, bytes_to_decode);
+  // If bytes_to_decode == 0, data could be null.
+  if (bytesToDecode > 0) {
+    memcpy(out, data, bytesToDecode);
   }
-  return static_cast<int>(bytes_to_decode);
+  return static_cast<int>(bytesToDecode);
 }
 
 template <typename DType>
 PlainDecoder<DType>::PlainDecoder(const ColumnDescriptor* descr)
-    : DecoderImpl(descr, Encoding::PLAIN) {
-  if (descr_ && descr_->physical_type() == Type::FIXED_LEN_BYTE_ARRAY) {
-    type_length_ = descr_->type_length();
+    : DecoderImpl(descr, Encoding::kPlain) {
+  if (descr_ && descr_->physicalType() == Type::kFixedLenByteArray) {
+    typeLength_ = descr_->typeLength();
   } else {
-    type_length_ = -1;
+    typeLength_ = -1;
   }
 }
 
-// Template specialization for BYTE_ARRAY. The written values do not own their
-// own data.
+// Template specialization for BYTE_ARRAY. The written values do not own their.
+// Own data.
 
 static inline int64_t
-ReadByteArray(const uint8_t* data, int64_t data_size, ByteArray* out) {
-  if (ARROW_PREDICT_FALSE(data_size < 4)) {
-    ParquetException::EofException();
+readByteArray(const uint8_t* data, int64_t dataSize, ByteArray* out) {
+  if (ARROW_PREDICT_FALSE(dataSize < 4)) {
+    ParquetException::eofException();
   }
   const int32_t len = SafeLoadAs<int32_t>(data);
   if (len < 0) {
     throw ParquetException("Invalid BYTE_ARRAY value");
   }
-  const int64_t consumed_length = static_cast<int64_t>(len) + 4;
-  if (ARROW_PREDICT_FALSE(data_size < consumed_length)) {
-    ParquetException::EofException();
+  const int64_t consumedLength = static_cast<int64_t>(len) + 4;
+  if (ARROW_PREDICT_FALSE(dataSize < consumedLength)) {
+    ParquetException::eofException();
   }
   *out = ByteArray{static_cast<uint32_t>(len), data + 4};
-  return consumed_length;
+  return consumedLength;
 }
 
 template <>
-inline int DecodePlain<ByteArray>(
+inline int decodePlain<ByteArray>(
     const uint8_t* data,
-    int64_t data_size,
-    int num_values,
-    int type_length,
+    int64_t dataSize,
+    int numValues,
+    int typeLength,
     ByteArray* out) {
-  int bytes_decoded = 0;
-  for (int i = 0; i < num_values; ++i) {
-    const auto increment = ReadByteArray(data, data_size, out + i);
-    if (ARROW_PREDICT_FALSE(increment > INT_MAX - bytes_decoded)) {
+  int bytesDecoded = 0;
+  for (int i = 0; i < numValues; ++i) {
+    const auto increment = readByteArray(data, dataSize, out + i);
+    if (ARROW_PREDICT_FALSE(increment > INT_MAX - bytesDecoded)) {
       throw ParquetException("BYTE_ARRAY chunk too large");
     }
     data += increment;
-    data_size -= increment;
-    bytes_decoded += static_cast<int>(increment);
+    dataSize -= increment;
+    bytesDecoded += static_cast<int>(increment);
   }
-  return bytes_decoded;
+  return bytesDecoded;
 }
 
-// Template specialization for FIXED_LEN_BYTE_ARRAY. The written values do not
-// own their own data.
+// Template specialization for FIXED_LEN_BYTE_ARRAY. The written values do not.
+// Own their own data.
 template <>
-inline int DecodePlain<FixedLenByteArray>(
+inline int decodePlain<FixedLenByteArray>(
     const uint8_t* data,
-    int64_t data_size,
-    int num_values,
-    int type_length,
+    int64_t dataSize,
+    int numValues,
+    int typeLength,
     FixedLenByteArray* out) {
-  int64_t bytes_to_decode = static_cast<int64_t>(type_length) * num_values;
-  if (bytes_to_decode > data_size || bytes_to_decode > INT_MAX) {
-    ParquetException::EofException();
+  int64_t bytesToDecode = static_cast<int64_t>(typeLength) * numValues;
+  if (bytesToDecode > dataSize || bytesToDecode > INT_MAX) {
+    ParquetException::eofException();
   }
-  for (int i = 0; i < num_values; ++i) {
+  for (int i = 0; i < numValues; ++i) {
     out[i].ptr = data;
-    data += type_length;
-    data_size -= type_length;
+    data += typeLength;
+    dataSize -= typeLength;
   }
-  return static_cast<int>(bytes_to_decode);
+  return static_cast<int>(bytesToDecode);
 }
 
 template <typename DType>
-int PlainDecoder<DType>::Decode(T* buffer, int max_values) {
-  max_values = std::min(max_values, num_values_);
-  int bytes_consumed =
-      DecodePlain<T>(data_, len_, max_values, type_length_, buffer);
-  data_ += bytes_consumed;
-  len_ -= bytes_consumed;
-  num_values_ -= max_values;
-  return max_values;
+int PlainDecoder<DType>::decode(T* buffer, int maxValues) {
+  maxValues = std::min(maxValues, numValues_);
+  int bytesConsumed =
+      decodePlain<T>(data_, len_, maxValues, typeLength_, buffer);
+  data_ += bytesConsumed;
+  len_ -= bytesConsumed;
+  numValues_ -= maxValues;
+  return maxValues;
 }
 
 class PlainBooleanDecoder : public DecoderImpl, virtual public BooleanDecoder {
  public:
   explicit PlainBooleanDecoder(const ColumnDescriptor* descr);
-  void SetData(int num_values, const uint8_t* data, int len) override;
-
-  // Two flavors of bool decoding
-  int Decode(uint8_t* buffer, int max_values) override;
-  int Decode(bool* buffer, int max_values) override;
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  void setData(int numValues, const uint8_t* data, int len) override;
+
+  // Two flavors of bool decoding.
+  int decode(uint8_t* buffer, int maxValues) override;
+  int decode(bool* buffer, int maxValues) override;
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<BooleanType>::Accumulator* out) override;
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<BooleanType>::DictAccumulator* out) override;
 
  private:
-  std::unique_ptr<BitReader> bit_reader_;
+  std::unique_ptr<BitReader> bitReader_;
 };
 
 PlainBooleanDecoder::PlainBooleanDecoder(const ColumnDescriptor* descr)
-    : DecoderImpl(descr, Encoding::PLAIN) {}
+    : DecoderImpl(descr, Encoding::kPlain) {}
 
-void PlainBooleanDecoder::SetData(
-    int num_values,
-    const uint8_t* data,
-    int len) {
-  num_values_ = num_values;
-  bit_reader_ = std::make_unique<BitReader>(data, len);
+void PlainBooleanDecoder::setData(int numValues, const uint8_t* data, int len) {
+  numValues_ = numValues;
+  bitReader_ = std::make_unique<BitReader>(data, len);
 }
 
-int PlainBooleanDecoder::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<BooleanType>::Accumulator* builder) {
-  int values_decoded = num_values - null_count;
-  if (ARROW_PREDICT_FALSE(num_values_ < values_decoded)) {
-    ParquetException::EofException();
+int PlainBooleanDecoder::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<BooleanType>::Accumulator* Builder) {
+  int valuesDecoded = numValues - nullCount;
+  if (ARROW_PREDICT_FALSE(numValues_ < valuesDecoded)) {
+    ParquetException::eofException();
   }
 
-  PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
+  PARQUET_THROW_NOT_OK(Builder->Reserve(numValues));
 
   VisitNullBitmapInline(
-      valid_bits,
-      valid_bits_offset,
-      num_values,
-      null_count,
+      validBits,
+      validBitsOffset,
+      numValues,
+      nullCount,
       [&]() {
         bool value;
-        ARROW_IGNORE_EXPR(bit_reader_->GetValue(1, &value));
-        builder->UnsafeAppend(value);
+        ARROW_IGNORE_EXPR(bitReader_->GetValue(1, &value));
+        Builder->UnsafeAppend(value);
       },
-      [&]() { builder->UnsafeAppendNull(); });
+      [&]() { Builder->UnsafeAppendNull(); });
 
-  num_values_ -= values_decoded;
-  return values_decoded;
+  numValues_ -= valuesDecoded;
+  return valuesDecoded;
 }
 
-inline int PlainBooleanDecoder::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<BooleanType>::DictAccumulator* builder) {
+inline int PlainBooleanDecoder::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<BooleanType>::DictAccumulator* Builder) {
   ParquetException::NYI("dictionaries of BooleanType");
 }
 
-int PlainBooleanDecoder::Decode(uint8_t* buffer, int max_values) {
-  max_values = std::min(max_values, num_values_);
+int PlainBooleanDecoder::decode(uint8_t* buffer, int maxValues) {
+  maxValues = std::min(maxValues, numValues_);
   bool val;
-  ::arrow::internal::BitmapWriter bit_writer(buffer, 0, max_values);
-  for (int i = 0; i < max_values; ++i) {
-    if (!bit_reader_->GetValue(1, &val)) {
-      ParquetException::EofException();
+  ::arrow::internal::BitmapWriter bitWriter(buffer, 0, maxValues);
+  for (int i = 0; i < maxValues; ++i) {
+    if (!bitReader_->GetValue(1, &val)) {
+      ParquetException::eofException();
     }
     if (val) {
-      bit_writer.Set();
+      bitWriter.Set();
     }
-    bit_writer.Next();
+    bitWriter.Next();
   }
-  bit_writer.Finish();
-  num_values_ -= max_values;
-  return max_values;
+  bitWriter.Finish();
+  numValues_ -= maxValues;
+  return maxValues;
 }
 
-int PlainBooleanDecoder::Decode(bool* buffer, int max_values) {
-  max_values = std::min(max_values, num_values_);
-  if (bit_reader_->GetBatch(1, buffer, max_values) != max_values) {
-    ParquetException::EofException();
+int PlainBooleanDecoder::decode(bool* buffer, int maxValues) {
+  maxValues = std::min(maxValues, numValues_);
+  if (bitReader_->GetBatch(1, buffer, maxValues) != maxValues) {
+    ParquetException::eofException();
   }
-  num_values_ -= max_values;
-  return max_values;
+  numValues_ -= maxValues;
+  return maxValues;
 }
 
 struct ArrowBinaryHelper {
   explicit ArrowBinaryHelper(
       typename EncodingTraits<ByteArrayType>::Accumulator* out) {
     this->out = out;
-    this->builder = out->builder.get();
-    this->chunk_space_remaining =
-        ::arrow::kBinaryMemoryLimit - this->builder->value_data_length();
+    this->Builder = out->Builder.get();
+    this->chunkSpaceRemaining =
+        ::arrow::kBinaryMemoryLimit - this->Builder->value_data_length();
   }
 
-  Status PushChunk() {
+  Status pushChunk() {
     std::shared_ptr<::arrow::Array> result;
-    RETURN_NOT_OK(builder->Finish(&result));
+    RETURN_NOT_OK(Builder->Finish(&result));
     out->chunks.push_back(result);
-    chunk_space_remaining = ::arrow::kBinaryMemoryLimit;
+    chunkSpaceRemaining = ::arrow::kBinaryMemoryLimit;
     return Status::OK();
   }
 
-  bool CanFit(int64_t length) const {
-    return length <= chunk_space_remaining;
+  bool canFit(int64_t length) const {
+    return length <= chunkSpaceRemaining;
   }
 
   void UnsafeAppend(const uint8_t* data, int32_t length) {
-    chunk_space_remaining -= length;
-    builder->UnsafeAppend(data, length);
+    chunkSpaceRemaining -= length;
+    Builder->UnsafeAppend(data, length);
   }
 
   void UnsafeAppendNull() {
-    builder->UnsafeAppendNull();
+    Builder->UnsafeAppendNull();
   }
 
-  Status Append(const uint8_t* data, int32_t length) {
-    chunk_space_remaining -= length;
-    return builder->Append(data, length);
+  Status append(const uint8_t* data, int32_t length) {
+    chunkSpaceRemaining -= length;
+    return Builder->Append(data, length);
   }
 
-  Status AppendNull() {
-    return builder->AppendNull();
+  Status appendNull() {
+    return Builder->AppendNull();
   }
 
   typename EncodingTraits<ByteArrayType>::Accumulator* out;
-  ::arrow::BinaryBuilder* builder;
-  int64_t chunk_space_remaining;
+  ::arrow::BinaryBuilder* Builder;
+  int64_t chunkSpaceRemaining;
 };
 
 template <>
-inline int PlainDecoder<ByteArrayType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<ByteArrayType>::Accumulator* builder) {
+inline int PlainDecoder<ByteArrayType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<ByteArrayType>::Accumulator* Builder) {
   ParquetException::NYI();
 }
 
 template <>
-inline int PlainDecoder<ByteArrayType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<ByteArrayType>::DictAccumulator* builder) {
+inline int PlainDecoder<ByteArrayType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<ByteArrayType>::DictAccumulator* Builder) {
   ParquetException::NYI();
 }
 
 template <>
-inline int PlainDecoder<FLBAType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<FLBAType>::Accumulator* builder) {
-  int values_decoded = num_values - null_count;
-  if (ARROW_PREDICT_FALSE(len_ < descr_->type_length() * values_decoded)) {
-    ParquetException::EofException();
+inline int PlainDecoder<FLBAType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<FLBAType>::Accumulator* Builder) {
+  int valuesDecoded = numValues - nullCount;
+  if (ARROW_PREDICT_FALSE(len_ < descr_->typeLength() * valuesDecoded)) {
+    ParquetException::eofException();
   }
 
-  PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
+  PARQUET_THROW_NOT_OK(Builder->Reserve(numValues));
 
   VisitNullBitmapInline(
-      valid_bits,
-      valid_bits_offset,
-      num_values,
-      null_count,
+      validBits,
+      validBitsOffset,
+      numValues,
+      nullCount,
       [&]() {
-        builder->UnsafeAppend(data_);
-        data_ += descr_->type_length();
+        Builder->UnsafeAppend(data_);
+        data_ += descr_->typeLength();
       },
-      [&]() { builder->UnsafeAppendNull(); });
+      [&]() { Builder->UnsafeAppendNull(); });
 
-  num_values_ -= values_decoded;
-  len_ -= descr_->type_length() * values_decoded;
-  return values_decoded;
+  numValues_ -= valuesDecoded;
+  len_ -= descr_->typeLength() * valuesDecoded;
+  return valuesDecoded;
 }
 
 template <>
-inline int PlainDecoder<FLBAType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<FLBAType>::DictAccumulator* builder) {
-  int values_decoded = num_values - null_count;
-  if (ARROW_PREDICT_FALSE(len_ < descr_->type_length() * values_decoded)) {
-    ParquetException::EofException();
+inline int PlainDecoder<FLBAType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<FLBAType>::DictAccumulator* Builder) {
+  int valuesDecoded = numValues - nullCount;
+  if (ARROW_PREDICT_FALSE(len_ < descr_->typeLength() * valuesDecoded)) {
+    ParquetException::eofException();
   }
 
-  PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
+  PARQUET_THROW_NOT_OK(Builder->Reserve(numValues));
 
   VisitNullBitmapInline(
-      valid_bits,
-      valid_bits_offset,
-      num_values,
-      null_count,
+      validBits,
+      validBitsOffset,
+      numValues,
+      nullCount,
       [&]() {
-        PARQUET_THROW_NOT_OK(builder->Append(data_));
-        data_ += descr_->type_length();
+        PARQUET_THROW_NOT_OK(Builder->Append(data_));
+        data_ += descr_->typeLength();
       },
-      [&]() { PARQUET_THROW_NOT_OK(builder->AppendNull()); });
+      [&]() { PARQUET_THROW_NOT_OK(Builder->AppendNull()); });
 
-  num_values_ -= values_decoded;
-  len_ -= descr_->type_length() * values_decoded;
-  return values_decoded;
+  numValues_ -= valuesDecoded;
+  len_ -= descr_->typeLength() * valuesDecoded;
+  return valuesDecoded;
 }
 
 class PlainByteArrayDecoder : public PlainDecoder<ByteArrayType>,
                               virtual public ByteArrayDecoder {
  public:
   using Base = PlainDecoder<ByteArrayType>;
-  using Base::DecodeSpaced;
+  using Base::decodeSpaced;
   using Base::PlainDecoder;
 
-  // ----------------------------------------------------------------------
-  // Dictionary read paths
+  // ----------------------------------------------------------------------.
+  // Dictionary read paths.
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      ::arrow::BinaryDictionary32Builder* builder) override {
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      ::arrow::BinaryDictionary32Builder* Builder) override {
     int result = 0;
-    PARQUET_THROW_NOT_OK(DecodeArrow(
-        num_values,
-        null_count,
-        valid_bits,
-        valid_bits_offset,
-        builder,
-        &result));
+    PARQUET_THROW_NOT_OK(decodeArrow(
+        numValues, nullCount, validBits, validBitsOffset, Builder, &result));
     return result;
   }
 
-  // ----------------------------------------------------------------------
-  // Optimized dense binary read paths
+  // ----------------------------------------------------------------------.
+  // Optimized dense binary read paths.
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<ByteArrayType>::Accumulator* out) override {
     int result = 0;
-    PARQUET_THROW_NOT_OK(DecodeArrowDense(
-        num_values, null_count, valid_bits, valid_bits_offset, out, &result));
+    PARQUET_THROW_NOT_OK(decodeArrowDense(
+        numValues, nullCount, validBits, validBitsOffset, out, &result));
     return result;
   }
 
  private:
-  Status DecodeArrowDense(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  Status decodeArrowDense(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<ByteArrayType>::Accumulator* out,
-      int* out_values_decoded) {
+      int* outValuesDecoded) {
     ArrowBinaryHelper helper(out);
-    int values_decoded = 0;
+    int valuesDecoded = 0;
 
-    RETURN_NOT_OK(helper.builder->Reserve(num_values));
-    RETURN_NOT_OK(helper.builder->ReserveData(
-        std::min<int64_t>(len_, helper.chunk_space_remaining)));
+    RETURN_NOT_OK(helper.Builder->Reserve(numValues));
+    RETURN_NOT_OK(helper.Builder->ReserveData(
+        std::min<int64_t>(len_, helper.chunkSpaceRemaining)));
 
     int i = 0;
     RETURN_NOT_OK(VisitNullBitmapInline(
-        valid_bits,
-        valid_bits_offset,
-        num_values,
-        null_count,
+        validBits,
+        validBitsOffset,
+        numValues,
+        nullCount,
         [&]() {
           if (ARROW_PREDICT_FALSE(len_ < 4)) {
-            ParquetException::EofException();
+            ParquetException::eofException();
           }
-          auto value_len = SafeLoadAs<int32_t>(data_);
-          if (ARROW_PREDICT_FALSE(value_len < 0 || value_len > INT32_MAX - 4)) {
+          auto valueLen = SafeLoadAs<int32_t>(data_);
+          if (ARROW_PREDICT_FALSE(valueLen < 0 || valueLen > INT32_MAX - 4)) {
             return Status::Invalid(
-                "Invalid or corrupted value_len '", value_len, "'");
+                "Invalid or corrupted value_len '", valueLen, "'");
           }
-          auto increment = value_len + 4;
+          auto increment = valueLen + 4;
           if (ARROW_PREDICT_FALSE(len_ < increment)) {
-            ParquetException::EofException();
+            ParquetException::eofException();
           }
-          if (ARROW_PREDICT_FALSE(!helper.CanFit(value_len))) {
-            // This element would exceed the capacity of a chunk
-            RETURN_NOT_OK(helper.PushChunk());
-            RETURN_NOT_OK(helper.builder->Reserve(num_values - i));
-            RETURN_NOT_OK(helper.builder->ReserveData(
-                std::min<int64_t>(len_, helper.chunk_space_remaining)));
+          if (ARROW_PREDICT_FALSE(!helper.canFit(valueLen))) {
+            // This element would exceed the capacity of a chunk.
+            RETURN_NOT_OK(helper.pushChunk());
+            RETURN_NOT_OK(helper.Builder->Reserve(numValues - i));
+            RETURN_NOT_OK(helper.Builder->ReserveData(
+                std::min<int64_t>(len_, helper.chunkSpaceRemaining)));
           }
-          helper.UnsafeAppend(data_ + 4, value_len);
+          helper.UnsafeAppend(data_ + 4, valueLen);
           data_ += increment;
           len_ -= increment;
-          ++values_decoded;
+          ++valuesDecoded;
           ++i;
           return Status::OK();
         },
@@ -1623,50 +1607,50 @@ class PlainByteArrayDecoder : public PlainDecoder<ByteArrayType>,
           return Status::OK();
         }));
 
-    num_values_ -= values_decoded;
-    *out_values_decoded = values_decoded;
+    numValues_ -= valuesDecoded;
+    *outValuesDecoded = valuesDecoded;
     return Status::OK();
   }
 
   template <typename BuilderType>
-  Status DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      BuilderType* builder,
-      int* out_values_decoded) {
-    RETURN_NOT_OK(builder->Reserve(num_values));
-    int values_decoded = 0;
+  Status decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      BuilderType* Builder,
+      int* outValuesDecoded) {
+    RETURN_NOT_OK(Builder->Reserve(numValues));
+    int valuesDecoded = 0;
 
     RETURN_NOT_OK(VisitNullBitmapInline(
-        valid_bits,
-        valid_bits_offset,
-        num_values,
-        null_count,
+        validBits,
+        validBitsOffset,
+        numValues,
+        nullCount,
         [&]() {
           if (ARROW_PREDICT_FALSE(len_ < 4)) {
-            ParquetException::EofException();
+            ParquetException::eofException();
           }
-          auto value_len = SafeLoadAs<int32_t>(data_);
-          if (ARROW_PREDICT_FALSE(value_len < 0 || value_len > INT32_MAX - 4)) {
+          auto valueLen = SafeLoadAs<int32_t>(data_);
+          if (ARROW_PREDICT_FALSE(valueLen < 0 || valueLen > INT32_MAX - 4)) {
             return Status::Invalid(
-                "Invalid or corrupted value_len '", value_len, "'");
+                "Invalid or corrupted value_len '", valueLen, "'");
           }
-          auto increment = value_len + 4;
+          auto increment = valueLen + 4;
           if (ARROW_PREDICT_FALSE(len_ < increment)) {
-            ParquetException::EofException();
+            ParquetException::eofException();
           }
-          RETURN_NOT_OK(builder->Append(data_ + 4, value_len));
+          RETURN_NOT_OK(Builder->Append(data_ + 4, valueLen));
           data_ += increment;
           len_ -= increment;
-          ++values_decoded;
+          ++valuesDecoded;
           return Status::OK();
         },
-        [&]() { return builder->AppendNull(); }));
+        [&]() { return Builder->AppendNull(); }));
 
-    num_values_ -= values_decoded;
-    *out_values_decoded = values_decoded;
+    numValues_ -= valuesDecoded;
+    *outValuesDecoded = valuesDecoded;
     return Status::OK();
   }
 };
@@ -1678,486 +1662,475 @@ class PlainFLBADecoder : public PlainDecoder<FLBAType>,
   using Base::PlainDecoder;
 };
 
-// ----------------------------------------------------------------------
-// Dictionary encoding and decoding
+// ----------------------------------------------------------------------.
+// Dictionary encoding and decoding.
 
 template <typename Type>
 class DictDecoderImpl : public DecoderImpl, virtual public DictDecoder<Type> {
  public:
-  typedef typename Type::c_type T;
+  typedef typename Type::CType T;
 
-  // Initializes the dictionary with values from 'dictionary'. The data in
-  // dictionary is not guaranteed to persist in memory after this call so the
-  // dictionary decoder needs to copy the data out if necessary.
+  // Initializes the dictionary with values from 'dictionary'. The data in.
+  // Dictionary is not guaranteed to persist in memory after this call so the.
+  // Dictionary decoder needs to copy the data out if necessary.
   explicit DictDecoderImpl(
       const ColumnDescriptor* descr,
       MemoryPool* pool = ::arrow::default_memory_pool())
-      : DecoderImpl(descr, Encoding::RLE_DICTIONARY),
-        dictionary_(AllocateBuffer(pool, 0)),
-        dictionary_length_(0),
-        byte_array_data_(AllocateBuffer(pool, 0)),
-        byte_array_offsets_(AllocateBuffer(pool, 0)),
-        indices_scratch_space_(AllocateBuffer(pool, 0)) {}
-
-  // Perform type-specific initiatialization
-  void SetDict(TypedDecoder<Type>* dictionary) override;
-
-  void SetData(int num_values, const uint8_t* data, int len) override {
-    num_values_ = num_values;
+      : DecoderImpl(descr, Encoding::kRleDictionary),
+        dictionary_(allocateBuffer(pool, 0)),
+        dictionaryLength_(0),
+        byteArrayData_(allocateBuffer(pool, 0)),
+        byteArrayOffsets_(allocateBuffer(pool, 0)),
+        indicesScratchSpace_(allocateBuffer(pool, 0)) {}
+
+  // Perform type-specific initiatialization.
+  void setDict(TypedDecoder<Type>* dictionary) override;
+
+  void setData(int numValues, const uint8_t* data, int len) override {
+    numValues_ = numValues;
     if (len == 0) {
-      // Initialize dummy decoder to avoid crashes later on
-      idx_decoder_ = RleDecoder(data, len, /*bitWidth=*/1);
+      // Initialize dummy decoder to avoid crashes later on.
+      idxDecoder_ = RleDecoder(data, len, 1);
       return;
     }
-    uint8_t bit_width = *data;
-    if (ARROW_PREDICT_FALSE(bit_width > 32)) {
+    uint8_t bitWidth = *data;
+    if (ARROW_PREDICT_FALSE(bitWidth > 32)) {
       throw ParquetException(
-          "Invalid or corrupted bit_width " + std::to_string(bit_width) +
+          "Invalid or corrupted bit_width " + std::to_string(bitWidth) +
           ". Maximum allowed is 32.");
     }
-    idx_decoder_ = RleDecoder(++data, --len, bit_width);
+    idxDecoder_ = RleDecoder(++data, --len, bitWidth);
   }
 
-  int Decode(T* buffer, int num_values) override {
-    num_values = std::min(num_values, num_values_);
-    int decoded_values = idx_decoder_.GetBatchWithDict(
+  int decode(T* buffer, int numValues) override {
+    numValues = std::min(numValues, numValues_);
+    int decodedValues = idxDecoder_.GetBatchWithDict(
         reinterpret_cast<const T*>(dictionary_->data()),
-        dictionary_length_,
+        dictionaryLength_,
         buffer,
-        num_values);
-    if (decoded_values != num_values) {
-      ParquetException::EofException();
+        numValues);
+    if (decodedValues != numValues) {
+      ParquetException::eofException();
     }
-    num_values_ -= num_values;
-    return num_values;
+    numValues_ -= numValues;
+    return numValues;
   }
 
-  int DecodeSpaced(
+  int decodeSpaced(
       T* buffer,
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset) override {
-    num_values = std::min(num_values, num_values_);
-    if (num_values !=
-        idx_decoder_.GetBatchWithDictSpaced(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset) override {
+    numValues = std::min(numValues, numValues_);
+    if (numValues !=
+        idxDecoder_.GetBatchWithDictSpaced(
             reinterpret_cast<const T*>(dictionary_->data()),
-            dictionary_length_,
+            dictionaryLength_,
             buffer,
-            num_values,
-            null_count,
-            valid_bits,
-            valid_bits_offset)) {
-      ParquetException::EofException();
+            numValues,
+            nullCount,
+            validBits,
+            validBitsOffset)) {
+      ParquetException::eofException();
     }
-    num_values_ -= num_values;
-    return num_values;
+    numValues_ -= numValues;
+    return numValues;
   }
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<Type>::Accumulator* out) override;
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<Type>::DictAccumulator* out) override;
 
-  void InsertDictionary(::arrow::ArrayBuilder* builder) override;
-
-  int DecodeIndicesSpaced(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      ::arrow::ArrayBuilder* builder) override {
-    if (num_values > 0) {
-      // TODO(wesm): Refactor to batch reads for improved memory use. It is not
-      // trivial because the null_count is relative to the entire bitmap
-      PARQUET_THROW_NOT_OK(indices_scratch_space_->TypedResize<int32_t>(
-          num_values, /*shrink_to_fit=*/false));
+  void insertDictionary(::arrow::ArrayBuilder* Builder) override;
+
+  int decodeIndicesSpaced(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      ::arrow::ArrayBuilder* Builder) override {
+    if (numValues > 0) {
+      // TODO(wesm): Refactor to batch reads for improved memory use. It is not.
+      // Trivial because the null_count is relative to the entire bitmap.
+      PARQUET_THROW_NOT_OK(
+          indicesScratchSpace_->TypedResize<int32_t>(numValues, false));
     }
 
-    auto indices_buffer =
-        reinterpret_cast<int32_t*>(indices_scratch_space_->mutable_data());
+    auto indicesBuffer =
+        reinterpret_cast<int32_t*>(indicesScratchSpace_->mutable_data());
 
-    if (num_values !=
-        idx_decoder_.GetBatchSpaced(
-            num_values,
-            null_count,
-            valid_bits,
-            valid_bits_offset,
-            indices_buffer)) {
-      ParquetException::EofException();
+    if (numValues !=
+        idxDecoder_.GetBatchSpaced(
+            numValues, nullCount, validBits, validBitsOffset, indicesBuffer)) {
+      ParquetException::eofException();
     }
 
-    // XXX(wesm): Cannot append "valid bits" directly to the builder
-    std::vector<uint8_t> valid_bytes(num_values, 0);
+    // XXX(wesm): Cannot append "valid bits" directly to the builder.
+    std::vector<uint8_t> validBytes(numValues, 0);
     int64_t i = 0;
     VisitNullBitmapInline(
-        valid_bits,
-        valid_bits_offset,
-        num_values,
-        null_count,
-        [&]() { valid_bytes[i++] = 1; },
+        validBits,
+        validBitsOffset,
+        numValues,
+        nullCount,
+        [&]() { validBytes[i++] = 1; },
         [&]() { ++i; });
 
-    auto binary_builder =
-        checked_cast<::arrow::BinaryDictionary32Builder*>(builder);
-    PARQUET_THROW_NOT_OK(binary_builder->AppendIndices(
-        indices_buffer, num_values, valid_bytes.data()));
-    num_values_ -= num_values - null_count;
-    return num_values - null_count;
-  }
-
-  int DecodeIndices(int num_values, ::arrow::ArrayBuilder* builder) override {
-    num_values = std::min(num_values, num_values_);
-    if (num_values > 0) {
-      // TODO(wesm): Refactor to batch reads for improved memory use. This is
-      // relatively simple here because we don't have to do any bookkeeping of
-      // nulls
-      PARQUET_THROW_NOT_OK(indices_scratch_space_->TypedResize<int32_t>(
-          num_values, /*shrink_to_fit=*/false));
-    }
-    auto indices_buffer =
-        reinterpret_cast<int32_t*>(indices_scratch_space_->mutable_data());
-    if (num_values != idx_decoder_.GetBatch(indices_buffer, num_values)) {
-      ParquetException::EofException();
-    }
-    auto binary_builder =
-        checked_cast<::arrow::BinaryDictionary32Builder*>(builder);
+    auto binaryBuilder =
+        checked_cast<::arrow::BinaryDictionary32Builder*>(Builder);
+    PARQUET_THROW_NOT_OK(binaryBuilder->AppendIndices(
+        indicesBuffer, numValues, validBytes.data()));
+    numValues_ -= numValues - nullCount;
+    return numValues - nullCount;
+  }
+
+  int decodeIndices(int numValues, ::arrow::ArrayBuilder* Builder) override {
+    numValues = std::min(numValues, numValues_);
+    if (numValues > 0) {
+      // TODO(wesm): Refactor to batch reads for improved memory use. This is.
+      // Relatively simple here because we don't have to do any bookkeeping of.
+      // Nulls.
+      PARQUET_THROW_NOT_OK(
+          indicesScratchSpace_->TypedResize<int32_t>(numValues, false));
+    }
+    auto indicesBuffer =
+        reinterpret_cast<int32_t*>(indicesScratchSpace_->mutable_data());
+    if (numValues != idxDecoder_.GetBatch(indicesBuffer, numValues)) {
+      ParquetException::eofException();
+    }
+    auto binaryBuilder =
+        checked_cast<::arrow::BinaryDictionary32Builder*>(Builder);
     PARQUET_THROW_NOT_OK(
-        binary_builder->AppendIndices(indices_buffer, num_values));
-    num_values_ -= num_values;
-    return num_values;
+        binaryBuilder->AppendIndices(indicesBuffer, numValues));
+    numValues_ -= numValues;
+    return numValues;
   }
 
-  int DecodeIndices(int num_values, int32_t* indices) override {
-    if (num_values != idx_decoder_.GetBatch(indices, num_values)) {
-      ParquetException::EofException();
+  int decodeIndices(int numValues, int32_t* indices) override {
+    if (numValues != idxDecoder_.GetBatch(indices, numValues)) {
+      ParquetException::eofException();
     }
-    num_values_ -= num_values;
-    return num_values;
+    numValues_ -= numValues;
+    return numValues;
   }
 
-  void GetDictionary(const T** dictionary, int32_t* dictionary_length)
-      override {
-    *dictionary_length = dictionary_length_;
+  void getDictionary(const T** dictionary, int32_t* dictionaryLength) override {
+    *dictionaryLength = dictionaryLength_;
     *dictionary = reinterpret_cast<T*>(dictionary_->mutable_data());
   }
 
  protected:
-  Status IndexInBounds(int32_t index) {
-    if (ARROW_PREDICT_TRUE(0 <= index && index < dictionary_length_)) {
+  Status indexInBounds(int32_t index) {
+    if (ARROW_PREDICT_TRUE(0 <= index && index < dictionaryLength_)) {
       return Status::OK();
     }
     return Status::Invalid("Index not in dictionary bounds");
   }
 
-  inline void DecodeDict(TypedDecoder<Type>* dictionary) {
-    dictionary_length_ = static_cast<int32_t>(dictionary->values_left());
-    PARQUET_THROW_NOT_OK(dictionary_->Resize(
-        dictionary_length_ * sizeof(T),
-        /*shrink_to_fit=*/false));
-    dictionary->Decode(
-        reinterpret_cast<T*>(dictionary_->mutable_data()), dictionary_length_);
+  inline void decodeDict(TypedDecoder<Type>* dictionary) {
+    dictionaryLength_ = static_cast<int32_t>(dictionary->valuesLeft());
+    PARQUET_THROW_NOT_OK(
+        dictionary_->Resize(dictionaryLength_ * sizeof(T), false));
+    dictionary->decode(
+        reinterpret_cast<T*>(dictionary_->mutable_data()), dictionaryLength_);
   }
 
   // Only one is set.
   std::shared_ptr<ResizableBuffer> dictionary_;
 
-  int32_t dictionary_length_;
+  int32_t dictionaryLength_;
 
-  // Data that contains the byte array data (byte_array_dictionary_ just has the
-  // pointers).
-  std::shared_ptr<ResizableBuffer> byte_array_data_;
+  // Data that contains the byte array data (byte_array_dictionary_ just has
+  // the. Pointers).
+  std::shared_ptr<ResizableBuffer> byteArrayData_;
 
-  // Arrow-style byte offsets for each dictionary value. We maintain two
-  // representations of the dictionary, one as ByteArray* for non-Arrow
-  // consumers and this one for Arrow consumers. Since dictionaries are
-  // generally pretty small to begin with this doesn't mean too much extra
-  // memory use in most cases
-  std::shared_ptr<ResizableBuffer> byte_array_offsets_;
+  // Arrow-style byte offsets for each dictionary value. We maintain two.
+  // Representations of the dictionary, one as ByteArray* for non-Arrow.
+  // Consumers and this one for Arrow consumers. Since dictionaries are.
+  // Generally pretty small to begin with this doesn't mean too much extra.
+  // Memory use in most cases.
+  std::shared_ptr<ResizableBuffer> byteArrayOffsets_;
 
-  // Reusable buffer for decoding dictionary indices to be appended to a
-  // BinaryDictionary32Builder
-  std::shared_ptr<ResizableBuffer> indices_scratch_space_;
+  // Reusable buffer for decoding dictionary indices to be appended to a.
+  // BinaryDictionary32Builder.
+  std::shared_ptr<ResizableBuffer> indicesScratchSpace_;
 
-  RleDecoder idx_decoder_;
+  RleDecoder idxDecoder_;
 };
 
 template <typename Type>
-void DictDecoderImpl<Type>::SetDict(TypedDecoder<Type>* dictionary) {
-  DecodeDict(dictionary);
+void DictDecoderImpl<Type>::setDict(TypedDecoder<Type>* dictionary) {
+  decodeDict(dictionary);
 }
 
 template <>
-void DictDecoderImpl<BooleanType>::SetDict(
+void DictDecoderImpl<BooleanType>::setDict(
     TypedDecoder<BooleanType>* dictionary) {
   ParquetException::NYI(
       "Dictionary encoding is not implemented for boolean values");
 }
 
 template <>
-void DictDecoderImpl<ByteArrayType>::SetDict(
+void DictDecoderImpl<ByteArrayType>::setDict(
     TypedDecoder<ByteArrayType>* dictionary) {
-  DecodeDict(dictionary);
+  decodeDict(dictionary);
 
-  auto dict_values = reinterpret_cast<ByteArray*>(dictionary_->mutable_data());
+  auto dictValues = reinterpret_cast<ByteArray*>(dictionary_->mutable_data());
 
-  int total_size = 0;
-  for (int i = 0; i < dictionary_length_; ++i) {
-    total_size += dict_values[i].len;
+  int totalSize = 0;
+  for (int i = 0; i < dictionaryLength_; ++i) {
+    totalSize += dictValues[i].len;
   }
-  PARQUET_THROW_NOT_OK(byte_array_data_->Resize(
-      total_size,
-      /*shrink_to_fit=*/false));
-  PARQUET_THROW_NOT_OK(byte_array_offsets_->Resize(
-      (dictionary_length_ + 1) * sizeof(int32_t),
-      /*shrink_to_fit=*/false));
+  PARQUET_THROW_NOT_OK(byteArrayData_->Resize(totalSize, false));
+  PARQUET_THROW_NOT_OK(byteArrayOffsets_->Resize(
+      (dictionaryLength_ + 1) * sizeof(int32_t), false));
 
   int32_t offset = 0;
-  uint8_t* bytes_data = byte_array_data_->mutable_data();
-  int32_t* bytes_offsets =
-      reinterpret_cast<int32_t*>(byte_array_offsets_->mutable_data());
-  for (int i = 0; i < dictionary_length_; ++i) {
-    memcpy(bytes_data + offset, dict_values[i].ptr, dict_values[i].len);
-    bytes_offsets[i] = offset;
-    dict_values[i].ptr = bytes_data + offset;
-    offset += dict_values[i].len;
+  uint8_t* bytesData = byteArrayData_->mutable_data();
+  int32_t* bytesOffsets =
+      reinterpret_cast<int32_t*>(byteArrayOffsets_->mutable_data());
+  for (int i = 0; i < dictionaryLength_; ++i) {
+    memcpy(bytesData + offset, dictValues[i].ptr, dictValues[i].len);
+    bytesOffsets[i] = offset;
+    dictValues[i].ptr = bytesData + offset;
+    offset += dictValues[i].len;
   }
-  bytes_offsets[dictionary_length_] = offset;
+  bytesOffsets[dictionaryLength_] = offset;
 }
 
 template <>
-inline void DictDecoderImpl<FLBAType>::SetDict(
+inline void DictDecoderImpl<FLBAType>::setDict(
     TypedDecoder<FLBAType>* dictionary) {
-  DecodeDict(dictionary);
+  decodeDict(dictionary);
 
-  auto dict_values = reinterpret_cast<FLBA*>(dictionary_->mutable_data());
+  auto dictValues = reinterpret_cast<FLBA*>(dictionary_->mutable_data());
 
-  int fixed_len = descr_->type_length();
-  int total_size = dictionary_length_ * fixed_len;
+  int fixedLen = descr_->typeLength();
+  int totalSize = dictionaryLength_ * fixedLen;
 
-  PARQUET_THROW_NOT_OK(byte_array_data_->Resize(
-      total_size,
-      /*shrink_to_fit=*/false));
-  uint8_t* bytes_data = byte_array_data_->mutable_data();
-  for (int32_t i = 0, offset = 0; i < dictionary_length_;
-       ++i, offset += fixed_len) {
-    memcpy(bytes_data + offset, dict_values[i].ptr, fixed_len);
-    dict_values[i].ptr = bytes_data + offset;
+  PARQUET_THROW_NOT_OK(byteArrayData_->Resize(totalSize, false));
+  uint8_t* bytesData = byteArrayData_->mutable_data();
+  for (int32_t i = 0, offset = 0; i < dictionaryLength_;
+       ++i, offset += fixedLen) {
+    memcpy(bytesData + offset, dictValues[i].ptr, fixedLen);
+    dictValues[i].ptr = bytesData + offset;
   }
 }
 
 template <>
-inline int DictDecoderImpl<Int96Type>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<Int96Type>::Accumulator* builder) {
+inline int DictDecoderImpl<Int96Type>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<Int96Type>::Accumulator* Builder) {
   ParquetException::NYI("DecodeArrow to Int96Type");
 }
 
 template <>
-inline int DictDecoderImpl<Int96Type>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<Int96Type>::DictAccumulator* builder) {
+inline int DictDecoderImpl<Int96Type>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<Int96Type>::DictAccumulator* Builder) {
   ParquetException::NYI("DecodeArrow to Int96Type");
 }
 
 template <>
-inline int DictDecoderImpl<ByteArrayType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<ByteArrayType>::Accumulator* builder) {
+inline int DictDecoderImpl<ByteArrayType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<ByteArrayType>::Accumulator* Builder) {
   ParquetException::NYI("DecodeArrow implemented elsewhere");
 }
 
 template <>
-inline int DictDecoderImpl<ByteArrayType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<ByteArrayType>::DictAccumulator* builder) {
+inline int DictDecoderImpl<ByteArrayType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<ByteArrayType>::DictAccumulator* Builder) {
   ParquetException::NYI("DecodeArrow implemented elsewhere");
 }
 
 template <typename DType>
-int DictDecoderImpl<DType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<DType>::DictAccumulator* builder) {
-  PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
+int DictDecoderImpl<DType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<DType>::DictAccumulator* Builder) {
+  PARQUET_THROW_NOT_OK(Builder->Reserve(numValues));
 
-  auto dict_values =
-      reinterpret_cast<const typename DType::c_type*>(dictionary_->data());
+  auto dictValues =
+      reinterpret_cast<const typename DType::CType*>(dictionary_->data());
 
   VisitNullBitmapInline(
-      valid_bits,
-      valid_bits_offset,
-      num_values,
-      null_count,
+      validBits,
+      validBitsOffset,
+      numValues,
+      nullCount,
       [&]() {
         int32_t index;
-        if (ARROW_PREDICT_FALSE(!idx_decoder_.Get(&index))) {
+        if (ARROW_PREDICT_FALSE(!idxDecoder_.Get(&index))) {
           throw ParquetException("");
         }
-        PARQUET_THROW_NOT_OK(IndexInBounds(index));
-        PARQUET_THROW_NOT_OK(builder->Append(dict_values[index]));
+        PARQUET_THROW_NOT_OK(indexInBounds(index));
+        PARQUET_THROW_NOT_OK(Builder->Append(dictValues[index]));
       },
-      [&]() { PARQUET_THROW_NOT_OK(builder->AppendNull()); });
+      [&]() { PARQUET_THROW_NOT_OK(Builder->AppendNull()); });
 
-  return num_values - null_count;
+  return numValues - nullCount;
 }
 
 template <>
-int DictDecoderImpl<BooleanType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<BooleanType>::DictAccumulator* builder) {
+int DictDecoderImpl<BooleanType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<BooleanType>::DictAccumulator* Builder) {
   ParquetException::NYI("No dictionary encoding for BooleanType");
 }
 
 template <>
-inline int DictDecoderImpl<FLBAType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<FLBAType>::Accumulator* builder) {
-  if (builder->byte_width() != descr_->type_length()) {
+inline int DictDecoderImpl<FLBAType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<FLBAType>::Accumulator* Builder) {
+  if (Builder->byte_width() != descr_->typeLength()) {
     throw ParquetException(
         "Byte width mismatch: builder was " +
-        std::to_string(builder->byte_width()) + " but decoder was " +
-        std::to_string(descr_->type_length()));
+        std::to_string(Builder->byte_width()) + " but decoder was " +
+        std::to_string(descr_->typeLength()));
   }
 
-  PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
+  PARQUET_THROW_NOT_OK(Builder->Reserve(numValues));
 
-  auto dict_values = reinterpret_cast<const FLBA*>(dictionary_->data());
+  auto dictValues = reinterpret_cast<const FLBA*>(dictionary_->data());
 
   VisitNullBitmapInline(
-      valid_bits,
-      valid_bits_offset,
-      num_values,
-      null_count,
+      validBits,
+      validBitsOffset,
+      numValues,
+      nullCount,
       [&]() {
         int32_t index;
-        if (ARROW_PREDICT_FALSE(!idx_decoder_.Get(&index))) {
+        if (ARROW_PREDICT_FALSE(!idxDecoder_.Get(&index))) {
           throw ParquetException("");
         }
-        PARQUET_THROW_NOT_OK(IndexInBounds(index));
-        builder->UnsafeAppend(dict_values[index].ptr);
+        PARQUET_THROW_NOT_OK(indexInBounds(index));
+        Builder->UnsafeAppend(dictValues[index].ptr);
       },
-      [&]() { builder->UnsafeAppendNull(); });
+      [&]() { Builder->UnsafeAppendNull(); });
 
-  return num_values - null_count;
+  return numValues - nullCount;
 }
 
 template <>
-int DictDecoderImpl<FLBAType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<FLBAType>::DictAccumulator* builder) {
-  auto value_type =
-      checked_cast<const ::arrow::DictionaryType&>(*builder->type())
+int DictDecoderImpl<FLBAType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<FLBAType>::DictAccumulator* Builder) {
+  auto ValueType =
+      checked_cast<const ::arrow::DictionaryType&>(*Builder->type())
           .value_type();
   auto byte_width =
-      checked_cast<const ::arrow::FixedSizeBinaryType&>(*value_type)
+      checked_cast<const ::arrow::FixedSizeBinaryType&>(*ValueType)
           .byte_width();
-  if (byte_width != descr_->type_length()) {
+  if (byte_width != descr_->typeLength()) {
     throw ParquetException(
         "Byte width mismatch: builder was " + std::to_string(byte_width) +
-        " but decoder was " + std::to_string(descr_->type_length()));
+        " but decoder was " + std::to_string(descr_->typeLength()));
   }
 
-  PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
+  PARQUET_THROW_NOT_OK(Builder->Reserve(numValues));
 
-  auto dict_values = reinterpret_cast<const FLBA*>(dictionary_->data());
+  auto dictValues = reinterpret_cast<const FLBA*>(dictionary_->data());
 
   VisitNullBitmapInline(
-      valid_bits,
-      valid_bits_offset,
-      num_values,
-      null_count,
+      validBits,
+      validBitsOffset,
+      numValues,
+      nullCount,
       [&]() {
         int32_t index;
-        if (ARROW_PREDICT_FALSE(!idx_decoder_.Get(&index))) {
+        if (ARROW_PREDICT_FALSE(!idxDecoder_.Get(&index))) {
           throw ParquetException("");
         }
-        PARQUET_THROW_NOT_OK(IndexInBounds(index));
-        PARQUET_THROW_NOT_OK(builder->Append(dict_values[index].ptr));
+        PARQUET_THROW_NOT_OK(indexInBounds(index));
+        PARQUET_THROW_NOT_OK(Builder->Append(dictValues[index].ptr));
       },
-      [&]() { PARQUET_THROW_NOT_OK(builder->AppendNull()); });
+      [&]() { PARQUET_THROW_NOT_OK(Builder->AppendNull()); });
 
-  return num_values - null_count;
+  return numValues - nullCount;
 }
 
 template <typename Type>
-int DictDecoderImpl<Type>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<Type>::Accumulator* builder) {
-  PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
+int DictDecoderImpl<Type>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<Type>::Accumulator* Builder) {
+  PARQUET_THROW_NOT_OK(Builder->Reserve(numValues));
 
-  using value_type = typename Type::c_type;
-  auto dict_values = reinterpret_cast<const value_type*>(dictionary_->data());
+  using ValueType = typename Type::CType;
+  auto dictValues = reinterpret_cast<const ValueType*>(dictionary_->data());
 
   VisitNullBitmapInline(
-      valid_bits,
-      valid_bits_offset,
-      num_values,
-      null_count,
+      validBits,
+      validBitsOffset,
+      numValues,
+      nullCount,
       [&]() {
         int32_t index;
-        if (ARROW_PREDICT_FALSE(!idx_decoder_.Get(&index))) {
+        if (ARROW_PREDICT_FALSE(!idxDecoder_.Get(&index))) {
           throw ParquetException("");
         }
-        PARQUET_THROW_NOT_OK(IndexInBounds(index));
-        builder->UnsafeAppend(dict_values[index]);
+        PARQUET_THROW_NOT_OK(indexInBounds(index));
+        Builder->UnsafeAppend(dictValues[index]);
       },
-      [&]() { builder->UnsafeAppendNull(); });
+      [&]() { Builder->UnsafeAppendNull(); });
 
-  return num_values - null_count;
+  return numValues - nullCount;
 }
 
 template <typename Type>
-void DictDecoderImpl<Type>::InsertDictionary(::arrow::ArrayBuilder* builder) {
+void DictDecoderImpl<Type>::insertDictionary(::arrow::ArrayBuilder* Builder) {
   ParquetException::NYI(
       "InsertDictionary only implemented for BYTE_ARRAY types");
 }
 
 template <>
-void DictDecoderImpl<ByteArrayType>::InsertDictionary(
-    ::arrow::ArrayBuilder* builder) {
-  auto binary_builder =
-      checked_cast<::arrow::BinaryDictionary32Builder*>(builder);
+void DictDecoderImpl<ByteArrayType>::insertDictionary(
+    ::arrow::ArrayBuilder* Builder) {
+  auto binaryBuilder =
+      checked_cast<::arrow::BinaryDictionary32Builder*>(Builder);
 
-  // Make a BinaryArray referencing the internal dictionary data
+  // Make a BinaryArray referencing the internal dictionary data.
   auto arr = std::make_shared<::arrow::BinaryArray>(
-      dictionary_length_, byte_array_offsets_, byte_array_data_);
-  PARQUET_THROW_NOT_OK(binary_builder->InsertMemoValues(*arr));
+      dictionaryLength_, byteArrayOffsets_, byteArrayData_);
+  PARQUET_THROW_NOT_OK(binaryBuilder->InsertMemoValues(*arr));
 }
 
 class DictByteArrayDecoderImpl : public DictDecoderImpl<ByteArrayType>,
@@ -2166,498 +2139,490 @@ class DictByteArrayDecoderImpl : public DictDecoderImpl<ByteArrayType>,
   using BASE = DictDecoderImpl<ByteArrayType>;
   using BASE::DictDecoderImpl;
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      ::arrow::BinaryDictionary32Builder* builder) override {
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      ::arrow::BinaryDictionary32Builder* Builder) override {
     int result = 0;
-    if (null_count == 0) {
-      PARQUET_THROW_NOT_OK(DecodeArrowNonNull(num_values, builder, &result));
+    if (nullCount == 0) {
+      PARQUET_THROW_NOT_OK(decodeArrowNonNull(numValues, Builder, &result));
     } else {
-      PARQUET_THROW_NOT_OK(DecodeArrow(
-          num_values,
-          null_count,
-          valid_bits,
-          valid_bits_offset,
-          builder,
-          &result));
+      PARQUET_THROW_NOT_OK(decodeArrow(
+          numValues, nullCount, validBits, validBitsOffset, Builder, &result));
     }
     return result;
   }
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<ByteArrayType>::Accumulator* out) override {
     int result = 0;
-    if (null_count == 0) {
-      PARQUET_THROW_NOT_OK(DecodeArrowDenseNonNull(num_values, out, &result));
+    if (nullCount == 0) {
+      PARQUET_THROW_NOT_OK(decodeArrowDenseNonNull(numValues, out, &result));
     } else {
-      PARQUET_THROW_NOT_OK(DecodeArrowDense(
-          num_values, null_count, valid_bits, valid_bits_offset, out, &result));
+      PARQUET_THROW_NOT_OK(decodeArrowDense(
+          numValues, nullCount, validBits, validBitsOffset, out, &result));
     }
     return result;
   }
 
  private:
-  Status DecodeArrowDense(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  Status decodeArrowDense(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<ByteArrayType>::Accumulator* out,
-      int* out_num_values) {
+      int* outNumValues) {
     constexpr int32_t kBufferSize = 1024;
     int32_t indices[kBufferSize];
 
     ArrowBinaryHelper helper(out);
 
-    auto dict_values = reinterpret_cast<const ByteArray*>(dictionary_->data());
-    int values_decoded = 0;
-    int num_indices = 0;
-    int pos_indices = 0;
-
-    auto visit_valid = [&](int64_t position) -> Status {
-      if (num_indices == pos_indices) {
-        // Refill indices buffer
-        const auto batch_size = std::min<int32_t>(
-            kBufferSize, num_values - null_count - values_decoded);
-        num_indices = idx_decoder_.GetBatch(indices, batch_size);
-        if (ARROW_PREDICT_FALSE(num_indices < 1)) {
-          return Status::Invalid("Invalid number of indices: ", num_indices);
+    auto dictValues = reinterpret_cast<const ByteArray*>(dictionary_->data());
+    int valuesDecoded = 0;
+    int numIndices = 0;
+    int posIndices = 0;
+
+    auto visitValid = [&](int64_t position) -> Status {
+      if (numIndices == posIndices) {
+        // Refill indices buffer.
+        const auto batchSize = std::min<int32_t>(
+            kBufferSize, numValues - nullCount - valuesDecoded);
+        numIndices = idxDecoder_.GetBatch(indices, batchSize);
+        if (ARROW_PREDICT_FALSE(numIndices < 1)) {
+          return Status::Invalid("Invalid number of indices: ", numIndices);
         }
-        pos_indices = 0;
+        posIndices = 0;
       }
-      const auto index = indices[pos_indices++];
-      RETURN_NOT_OK(IndexInBounds(index));
-      const auto& val = dict_values[index];
-      if (ARROW_PREDICT_FALSE(!helper.CanFit(val.len))) {
-        RETURN_NOT_OK(helper.PushChunk());
+      const auto index = indices[posIndices++];
+      RETURN_NOT_OK(indexInBounds(index));
+      const auto& val = dictValues[index];
+      if (ARROW_PREDICT_FALSE(!helper.canFit(val.len))) {
+        RETURN_NOT_OK(helper.pushChunk());
       }
-      RETURN_NOT_OK(helper.Append(val.ptr, static_cast<int32_t>(val.len)));
-      ++values_decoded;
+      RETURN_NOT_OK(helper.append(val.ptr, static_cast<int32_t>(val.len)));
+      ++valuesDecoded;
       return Status::OK();
     };
 
-    auto visit_null = [&]() -> Status {
-      RETURN_NOT_OK(helper.AppendNull());
+    auto visitNull = [&]() -> Status {
+      RETURN_NOT_OK(helper.appendNull());
       return Status::OK();
     };
 
-    ::arrow::internal::BitBlockCounter bit_blocks(
-        valid_bits, valid_bits_offset, num_values);
+    ::arrow::internal::BitBlockCounter bitBlocks(
+        validBits, validBitsOffset, numValues);
     int64_t position = 0;
-    while (position < num_values) {
-      const auto block = bit_blocks.NextWord();
+    while (position < numValues) {
+      const auto block = bitBlocks.NextWord();
       if (block.AllSet()) {
         for (int64_t i = 0; i < block.length; ++i, ++position) {
-          ARROW_RETURN_NOT_OK(visit_valid(position));
+          ARROW_RETURN_NOT_OK(visitValid(position));
         }
       } else if (block.NoneSet()) {
         for (int64_t i = 0; i < block.length; ++i, ++position) {
-          ARROW_RETURN_NOT_OK(visit_null());
+          ARROW_RETURN_NOT_OK(visitNull());
         }
       } else {
         for (int64_t i = 0; i < block.length; ++i, ++position) {
           if (::arrow::bit_util::GetBit(
-                  valid_bits, valid_bits_offset + position)) {
-            ARROW_RETURN_NOT_OK(visit_valid(position));
+                  validBits, validBitsOffset + position)) {
+            ARROW_RETURN_NOT_OK(visitValid(position));
           } else {
-            ARROW_RETURN_NOT_OK(visit_null());
+            ARROW_RETURN_NOT_OK(visitNull());
           }
         }
       }
     }
 
-    *out_num_values = values_decoded;
+    *outNumValues = valuesDecoded;
     return Status::OK();
   }
 
-  Status DecodeArrowDenseNonNull(
-      int num_values,
+  Status decodeArrowDenseNonNull(
+      int numValues,
       typename EncodingTraits<ByteArrayType>::Accumulator* out,
-      int* out_num_values) {
+      int* outNumValues) {
     constexpr int32_t kBufferSize = 2048;
     int32_t indices[kBufferSize];
-    int values_decoded = 0;
+    int valuesDecoded = 0;
 
     ArrowBinaryHelper helper(out);
-    auto dict_values = reinterpret_cast<const ByteArray*>(dictionary_->data());
-
-    while (values_decoded < num_values) {
-      int32_t batch_size =
-          std::min<int32_t>(kBufferSize, num_values - values_decoded);
-      int num_indices = idx_decoder_.GetBatch(indices, batch_size);
-      if (num_indices == 0)
-        ParquetException::EofException();
-      for (int i = 0; i < num_indices; ++i) {
+    auto dictValues = reinterpret_cast<const ByteArray*>(dictionary_->data());
+
+    while (valuesDecoded < numValues) {
+      int32_t batchSize =
+          std::min<int32_t>(kBufferSize, numValues - valuesDecoded);
+      int numIndices = idxDecoder_.GetBatch(indices, batchSize);
+      if (numIndices == 0)
+        ParquetException::eofException();
+      for (int i = 0; i < numIndices; ++i) {
         auto idx = indices[i];
-        RETURN_NOT_OK(IndexInBounds(idx));
-        const auto& val = dict_values[idx];
-        if (ARROW_PREDICT_FALSE(!helper.CanFit(val.len))) {
-          RETURN_NOT_OK(helper.PushChunk());
+        RETURN_NOT_OK(indexInBounds(idx));
+        const auto& val = dictValues[idx];
+        if (ARROW_PREDICT_FALSE(!helper.canFit(val.len))) {
+          RETURN_NOT_OK(helper.pushChunk());
         }
-        RETURN_NOT_OK(helper.Append(val.ptr, static_cast<int32_t>(val.len)));
+        RETURN_NOT_OK(helper.append(val.ptr, static_cast<int32_t>(val.len)));
       }
-      values_decoded += num_indices;
+      valuesDecoded += numIndices;
     }
-    *out_num_values = values_decoded;
+    *outNumValues = valuesDecoded;
     return Status::OK();
   }
 
   template <typename BuilderType>
-  Status DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      BuilderType* builder,
-      int* out_num_values) {
+  Status decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      BuilderType* Builder,
+      int* outNumValues) {
     constexpr int32_t kBufferSize = 1024;
     int32_t indices[kBufferSize];
 
-    RETURN_NOT_OK(builder->Reserve(num_values));
-    ::arrow::internal::BitmapReader bit_reader(
-        valid_bits, valid_bits_offset, num_values);
+    RETURN_NOT_OK(Builder->Reserve(numValues));
+    ::arrow::internal::BitmapReader bitReader(
+        validBits, validBitsOffset, numValues);
 
-    auto dict_values = reinterpret_cast<const ByteArray*>(dictionary_->data());
+    auto dictValues = reinterpret_cast<const ByteArray*>(dictionary_->data());
 
-    int values_decoded = 0;
-    int num_appended = 0;
-    while (num_appended < num_values) {
-      bool is_valid = bit_reader.IsSet();
-      bit_reader.Next();
+    int valuesDecoded = 0;
+    int numAppended = 0;
+    while (numAppended < numValues) {
+      bool IsValid = bitReader.IsSet();
+      bitReader.Next();
 
-      if (is_valid) {
-        int32_t batch_size = std::min<int32_t>(
-            kBufferSize, num_values - num_appended - null_count);
-        int num_indices = idx_decoder_.GetBatch(indices, batch_size);
+      if (IsValid) {
+        int32_t batchSize =
+            std::min<int32_t>(kBufferSize, numValues - numAppended - nullCount);
+        int numIndices = idxDecoder_.GetBatch(indices, batchSize);
 
         int i = 0;
         while (true) {
-          // Consume all indices
-          if (is_valid) {
+          // Consume all indices.
+          if (IsValid) {
             auto idx = indices[i];
-            RETURN_NOT_OK(IndexInBounds(idx));
-            const auto& val = dict_values[idx];
-            RETURN_NOT_OK(builder->Append(val.ptr, val.len));
+            RETURN_NOT_OK(indexInBounds(idx));
+            const auto& val = dictValues[idx];
+            RETURN_NOT_OK(Builder->Append(val.ptr, val.len));
             ++i;
-            ++values_decoded;
+            ++valuesDecoded;
           } else {
-            RETURN_NOT_OK(builder->AppendNull());
-            --null_count;
+            RETURN_NOT_OK(Builder->AppendNull());
+            --nullCount;
           }
-          ++num_appended;
-          if (i == num_indices) {
-            // Do not advance the bit_reader if we have fulfilled the decode
-            // request
+          ++numAppended;
+          if (i == numIndices) {
+            // Do not advance the bit_reader if we have fulfilled the decode.
+            // Request.
             break;
           }
-          is_valid = bit_reader.IsSet();
-          bit_reader.Next();
+          IsValid = bitReader.IsSet();
+          bitReader.Next();
         }
       } else {
-        RETURN_NOT_OK(builder->AppendNull());
-        --null_count;
-        ++num_appended;
+        RETURN_NOT_OK(Builder->AppendNull());
+        --nullCount;
+        ++numAppended;
       }
     }
-    *out_num_values = values_decoded;
+    *outNumValues = valuesDecoded;
     return Status::OK();
   }
 
   template <typename BuilderType>
-  Status DecodeArrowNonNull(
-      int num_values,
-      BuilderType* builder,
-      int* out_num_values) {
+  Status
+  decodeArrowNonNull(int numValues, BuilderType* Builder, int* outNumValues) {
     constexpr int32_t kBufferSize = 2048;
     int32_t indices[kBufferSize];
 
-    RETURN_NOT_OK(builder->Reserve(num_values));
+    RETURN_NOT_OK(Builder->Reserve(numValues));
 
-    auto dict_values = reinterpret_cast<const ByteArray*>(dictionary_->data());
+    auto dictValues = reinterpret_cast<const ByteArray*>(dictionary_->data());
 
-    int values_decoded = 0;
-    while (values_decoded < num_values) {
-      int32_t batch_size =
-          std::min<int32_t>(kBufferSize, num_values - values_decoded);
-      int num_indices = idx_decoder_.GetBatch(indices, batch_size);
-      if (num_indices == 0)
-        ParquetException::EofException();
-      for (int i = 0; i < num_indices; ++i) {
+    int valuesDecoded = 0;
+    while (valuesDecoded < numValues) {
+      int32_t batchSize =
+          std::min<int32_t>(kBufferSize, numValues - valuesDecoded);
+      int numIndices = idxDecoder_.GetBatch(indices, batchSize);
+      if (numIndices == 0)
+        ParquetException::eofException();
+      for (int i = 0; i < numIndices; ++i) {
         auto idx = indices[i];
-        RETURN_NOT_OK(IndexInBounds(idx));
-        const auto& val = dict_values[idx];
-        RETURN_NOT_OK(builder->Append(val.ptr, val.len));
+        RETURN_NOT_OK(indexInBounds(idx));
+        const auto& val = dictValues[idx];
+        RETURN_NOT_OK(Builder->Append(val.ptr, val.len));
       }
-      values_decoded += num_indices;
+      valuesDecoded += numIndices;
     }
-    *out_num_values = values_decoded;
+    *outNumValues = valuesDecoded;
     return Status::OK();
   }
 };
 
-// ----------------------------------------------------------------------
-// DeltaBitPackEncoder
+// ----------------------------------------------------------------------.
+// DeltaBitPackEncoder.
 
-/// DeltaBitPackEncoder is an encoder for the DeltaBinary Packing format
-/// as per the parquet spec. See:
+/// DeltaBitPackEncoder is an encoder for the DeltaBinary Packing format.
+/// As per the parquet spec. See:
 /// https://github.com/apache/parquet-format/blob/master/Encodings.md#delta-encoding-delta_binary_packed--5
 ///
-/// Consists of a header followed by blocks of delta encoded values binary
-/// packed.
+/// Consists of a header followed by blocks of delta encoded values binary.
+/// Packed.
 ///
-///  Format
-///    [header] [block 1] [block 2] ... [block N]
+///  Format.
+///    [Header] [block 1] [block 2] ... [block N].
 ///
-///  Header
-///    [block size] [number of mini blocks per block] [total value count] [first
-///    value]
+///  Header.
+///    [Block size] [number of mini blocks per block] [total value count]
+///    [first. Value].
 ///
-///  Block
-///    [min delta] [list of bitwidths of the mini blocks] [miniblocks]
+///  Block.
+///    [Min delta] [list of bitwidths of the mini blocks] [miniblocks].
 ///
-/// Sets aside bytes at the start of the internal buffer where the header will
-/// be written, and only writes the header when FlushValues is called before
-/// returning it.
+/// Sets aside bytes at the start of the internal buffer where the header will.
+/// Be written, and only writes the header when FlushValues is called before.
+/// Returning it.
 ///
 /// To encode a block, we will:
 ///
-/// 1. Compute the differences between consecutive elements. For the first
-/// element in the block, use the last element in the previous block or, in the
-/// case of the first block, use the first value of the whole sequence, stored
-/// in the header.
+/// 1. Compute the differences between consecutive elements. For the first.
+/// Element in the block, use the last element in the previous block or, in the.
+/// Case of the first block, use the first value of the whole sequence, stored.
+/// In the header.
 ///
 /// 2. Compute the frame of reference (the minimum of the deltas in the block).
-/// Subtract this min delta from all deltas in the block. This guarantees that
-/// all values are non-negative.
+/// Subtract this min delta from all deltas in the block. This guarantees that.
+/// All values are non-negative.
 ///
-/// 3. Encode the frame of reference (min delta) as a zigzag ULEB128 int
-/// followed by the bit widths of the mini blocks and the delta values (minus
-/// the min delta) bit packed per mini block.
+/// 3. Encode the frame of reference (min delta) as a zigzag ULEB128 int.
+/// Followed by the bit widths of the mini blocks and the delta values (minus.
+/// The min delta) bit packed per mini block.
 ///
 /// Supports only INT32 and INT64.
 
 template <typename DType>
 class DeltaBitPackEncoder : public EncoderImpl,
                             virtual public TypedEncoder<DType> {
-  // Maximum possible header size
+  // Maximum possible header size.
   static constexpr uint32_t kMaxPageHeaderWriterSize = 32;
   static constexpr uint32_t kValuesPerBlock =
-      std::is_same_v<int32_t, typename DType::c_type> ? 128 : 256;
+      std::is_same_v<int32_t, typename DType::CType> ? 128 : 256;
   static constexpr uint32_t kMiniBlocksPerBlock = 4;
 
  public:
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
   using UT = std::make_unsigned_t<T>;
-  using TypedEncoder<DType>::Put;
+  using TypedEncoder<DType>::put;
 
   explicit DeltaBitPackEncoder(
       const ColumnDescriptor* descr,
       MemoryPool* pool,
-      const uint32_t values_per_block = kValuesPerBlock,
-      const uint32_t mini_blocks_per_block = kMiniBlocksPerBlock)
-      : EncoderImpl(descr, Encoding::DELTA_BINARY_PACKED, pool),
-        values_per_block_(values_per_block),
-        mini_blocks_per_block_(mini_blocks_per_block),
-        values_per_mini_block_(values_per_block / mini_blocks_per_block),
-        deltas_(values_per_block, ::arrow::stl::allocator<T>(pool)),
-        bits_buffer_(AllocateBuffer(
+      const uint32_t valuesPerBlock = kValuesPerBlock,
+      const uint32_t miniBlocksPerBlock = kMiniBlocksPerBlock)
+      : EncoderImpl(descr, Encoding::kDeltaBinaryPacked, pool),
+        valuesPerBlock_(valuesPerBlock),
+        miniBlocksPerBlock_(miniBlocksPerBlock),
+        valuesPerMiniBlock_(valuesPerBlock / miniBlocksPerBlock),
+        deltas_(valuesPerBlock, ::arrow::stl::allocator<T>(pool)),
+        bitsBuffer_(allocateBuffer(
             pool,
-            (kMiniBlocksPerBlock + values_per_block) * sizeof(T))),
+            (kMiniBlocksPerBlock + valuesPerBlock) * sizeof(T))),
         sink_(pool),
-        bit_writer_(
-            bits_buffer_->mutable_data(),
-            static_cast<int>(bits_buffer_->size())) {
-    if (values_per_block_ % 128 != 0) {
+        bitWriter_(
+            bitsBuffer_->mutable_data(),
+            static_cast<int>(bitsBuffer_->size())) {
+    if (valuesPerBlock_ % 128 != 0) {
       throw ParquetException(
           "the number of values in a block must be multiple of 128, but it's " +
-          std::to_string(values_per_block_));
+          std::to_string(valuesPerBlock_));
     }
-    if (values_per_mini_block_ % 32 != 0) {
+    if (valuesPerMiniBlock_ % 32 != 0) {
       throw ParquetException(
           "the number of values in a miniblock must be multiple of 32, but it's " +
-          std::to_string(values_per_mini_block_));
+          std::to_string(valuesPerMiniBlock_));
     }
-    if (values_per_block % mini_blocks_per_block != 0) {
+    if (valuesPerBlock % miniBlocksPerBlock != 0) {
       throw ParquetException(
           "the number of values per block % number of miniblocks per block must be 0, "
           "but it's " +
-          std::to_string(values_per_block % mini_blocks_per_block));
+          std::to_string(valuesPerBlock % miniBlocksPerBlock));
     }
-    // Reserve enough space at the beginning of the buffer for largest possible
-    // header.
+    // Reserve enough space at the beginning of the buffer for largest possible.
+    // Header.
     PARQUET_THROW_NOT_OK(sink_.Advance(kMaxPageHeaderWriterSize));
   }
 
-  std::shared_ptr<Buffer> FlushValues() override;
+  std::shared_ptr<Buffer> flushValues() override;
 
-  int64_t EstimatedDataEncodedSize() override {
+  int64_t estimatedDataEncodedSize() override {
     return sink_.length();
   }
 
-  void Put(const ::arrow::Array& values) override;
+  void put(const ::arrow::Array& values) override;
 
-  void Put(const T* buffer, int num_values) override;
+  void put(const T* buffer, int numValues) override;
 
-  void PutSpaced(
+  void putSpaced(
       const T* src,
-      int num_values,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset) override;
+      int numValues,
+      const uint8_t* validBits,
+      int64_t validBitsOffset) override;
 
-  void FlushBlock();
+  void flushBlock();
 
  private:
-  const uint32_t values_per_block_;
-  const uint32_t mini_blocks_per_block_;
-  const uint32_t values_per_mini_block_;
-  uint32_t values_current_block_{0};
-  uint32_t total_value_count_{0};
-  UT first_value_{0};
-  UT current_value_{0};
+  const uint32_t valuesPerBlock_;
+  const uint32_t miniBlocksPerBlock_;
+  const uint32_t valuesPerMiniBlock_;
+  uint32_t valuesCurrentBlock_{0};
+  uint32_t totalValueCount_{0};
+  UT firstValue_{0};
+  UT currentValue_{0};
   ArrowPoolVector<UT> deltas_;
-  std::shared_ptr<ResizableBuffer> bits_buffer_;
+  std::shared_ptr<ResizableBuffer> bitsBuffer_;
   ::arrow::BufferBuilder sink_;
-  BitWriter bit_writer_;
+  BitWriter bitWriter_;
 };
 
 template <typename DType>
-void DeltaBitPackEncoder<DType>::Put(const T* src, int num_values) {
-  if (num_values == 0) {
+void DeltaBitPackEncoder<DType>::put(const T* src, int numValues) {
+  if (numValues == 0) {
     return;
   }
 
   int idx = 0;
-  if (total_value_count_ == 0) {
-    current_value_ = src[0];
-    first_value_ = current_value_;
+  if (totalValueCount_ == 0) {
+    currentValue_ = src[0];
+    firstValue_ = currentValue_;
     idx = 1;
   }
-  total_value_count_ += num_values;
+  totalValueCount_ += numValues;
 
-  while (idx < num_values) {
+  while (idx < numValues) {
     UT value = static_cast<UT>(src[idx]);
-    // Calculate deltas. The possible overflow is handled by use of unsigned
-    // integers making subtraction operations well-defined and correct even in
-    // case of overflow. Encoded integers will wrap back around on decoding. See
-    // http://en.wikipedia.org/wiki/Modular_arithmetic#Integers_modulo_n
-    deltas_[values_current_block_] = value - current_value_;
-    current_value_ = value;
+    // Calculate deltas. The possible overflow is handled by use of unsigned.
+    // Integers making subtraction operations well-defined and correct even in.
+    // Case of overflow. Encoded integers will wrap back around on decoding.
+    // See. http://en.wikipedia.org/wiki/Modular_arithmetic#Integers_modulo_n
+    deltas_[valuesCurrentBlock_] = value - currentValue_;
+    currentValue_ = value;
     idx++;
-    values_current_block_++;
-    if (values_current_block_ == values_per_block_) {
-      FlushBlock();
+    valuesCurrentBlock_++;
+    if (valuesCurrentBlock_ == valuesPerBlock_) {
+      flushBlock();
     }
   }
 }
 
 template <typename DType>
-void DeltaBitPackEncoder<DType>::FlushBlock() {
-  if (values_current_block_ == 0) {
+void DeltaBitPackEncoder<DType>::flushBlock() {
+  if (valuesCurrentBlock_ == 0) {
     return;
   }
 
-  const UT min_delta = *std::min_element(
-      deltas_.begin(), deltas_.begin() + values_current_block_);
-  bit_writer_.PutZigZagVlqInt(static_cast<T>(min_delta));
+  const UT minDelta =
+      *std::min_element(deltas_.begin(), deltas_.begin() + valuesCurrentBlock_);
+  bitWriter_.PutZigZagVlqInt(static_cast<T>(minDelta));
 
-  // Call to GetNextBytePtr reserves mini_blocks_per_block_ bytes of space to
-  // write bit widths of miniblocks as they become known during the encoding.
-  uint8_t* bit_width_data = bit_writer_.GetNextBytePtr(mini_blocks_per_block_);
-  VELOX_DCHECK(bit_width_data != nullptr);
+  // Call to GetNextBytePtr reserves mini_blocks_per_block_ bytes of space to.
+  // Write bit widths of miniblocks as they become known during the encoding.
+  uint8_t* bitWidthData = bitWriter_.GetNextBytePtr(miniBlocksPerBlock_);
+  VELOX_DCHECK(bitWidthData != nullptr);
 
-  const uint32_t num_miniblocks = static_cast<uint32_t>(std::ceil(
-      static_cast<double>(values_current_block_) /
-      static_cast<double>(values_per_mini_block_)));
-  for (uint32_t i = 0; i < num_miniblocks; i++) {
-    const uint32_t values_current_mini_block =
-        std::min(values_per_mini_block_, values_current_block_);
+  const uint32_t numMiniblocks = static_cast<uint32_t>(std::ceil(
+      static_cast<double>(valuesCurrentBlock_) /
+      static_cast<double>(valuesPerMiniBlock_)));
+  for (uint32_t i = 0; i < numMiniblocks; i++) {
+    const uint32_t valuesCurrentMiniBlock =
+        std::min(valuesPerMiniBlock_, valuesCurrentBlock_);
 
-    const uint32_t start = i * values_per_mini_block_;
-    const UT max_delta = *std::max_element(
+    const uint32_t start = i * valuesPerMiniBlock_;
+    const UT maxDelta = *std::max_element(
         deltas_.begin() + start,
-        deltas_.begin() + start + values_current_mini_block);
+        deltas_.begin() + start + valuesCurrentMiniBlock);
 
-    // The minimum number of bits required to write any of values in deltas_
-    // vector. See overflow comment above.
-    const auto bit_width = bit_width_data[i] =
-        ::arrow::bit_util::NumRequiredBits(max_delta - min_delta);
+    // The minimum number of bits required to write any of values in deltas_.
+    // Vector. See overflow comment above.
+    const auto bitWidth = bitWidthData[i] =
+        ::arrow::bit_util::NumRequiredBits(maxDelta - minDelta);
 
-    for (uint32_t j = start; j < start + values_current_mini_block; j++) {
+    for (uint32_t j = start; j < start + valuesCurrentMiniBlock; j++) {
       // See overflow comment above.
-      const UT value = deltas_[j] - min_delta;
-      bit_writer_.PutValue(value, bit_width);
+      const UT value = deltas_[j] - minDelta;
+      bitWriter_.PutValue(value, bitWidth);
     }
-    // If there are not enough values to fill the last mini block, we pad the
-    // mini block with zeroes so that its length is the number of values in a
-    // full mini block multiplied by the bit width.
-    for (uint32_t j = values_current_mini_block; j < values_per_mini_block_;
-         j++) {
-      bit_writer_.PutValue(0, bit_width);
+    // If there are not enough values to fill the last mini block, we pad the.
+    // Mini block with zeroes so that its length is the number of values in a.
+    // Full mini block multiplied by the bit width.
+    for (uint32_t j = valuesCurrentMiniBlock; j < valuesPerMiniBlock_; j++) {
+      bitWriter_.PutValue(0, bitWidth);
     }
-    values_current_block_ -= values_current_mini_block;
+    valuesCurrentBlock_ -= valuesCurrentMiniBlock;
   }
 
-  // If, in the last block, less than <number of miniblocks in a block>
-  // miniblocks are needed to store the values, the bytes storing the bit widths
-  // of the unneeded miniblocks are still present, their value should be zero,
-  // but readers must accept arbitrary values as well.
-  for (uint32_t i = num_miniblocks; i < mini_blocks_per_block_; i++) {
-    bit_width_data[i] = 0;
+  // If, in the last block, less than <number of miniblocks in a block>.
+  // Miniblocks are needed to store the values, the bytes storing the bit
+  // widths. Of the unneeded miniblocks are still present, their value should be
+  // zero,. But readers must accept arbitrary values as well.
+  for (uint32_t i = numMiniblocks; i < miniBlocksPerBlock_; i++) {
+    bitWidthData[i] = 0;
   }
-  VELOX_DCHECK_EQ(values_current_block_, 0);
+  VELOX_DCHECK_EQ(valuesCurrentBlock_, 0);
 
-  bit_writer_.Flush();
+  bitWriter_.Flush();
   PARQUET_THROW_NOT_OK(
-      sink_.Append(bit_writer_.buffer(), bit_writer_.bytesWritten()));
-  bit_writer_.Clear();
+      sink_.Append(bitWriter_.buffer(), bitWriter_.bytesWritten()));
+  bitWriter_.Clear();
 }
 
 template <typename DType>
-std::shared_ptr<Buffer> DeltaBitPackEncoder<DType>::FlushValues() {
-  if (values_current_block_ > 0) {
-    FlushBlock();
-  }
-  PARQUET_ASSIGN_OR_THROW(auto buffer, sink_.Finish(/*shrink_to_fit=*/true));
-
-  uint8_t header_buffer_[kMaxPageHeaderWriterSize] = {};
-  BitWriter header_writer(header_buffer_, sizeof(header_buffer_));
-  if (!header_writer.PutVlqInt(values_per_block_) ||
-      !header_writer.PutVlqInt(mini_blocks_per_block_) ||
-      !header_writer.PutVlqInt(total_value_count_) ||
-      !header_writer.PutZigZagVlqInt(static_cast<T>(first_value_))) {
+std::shared_ptr<Buffer> DeltaBitPackEncoder<DType>::flushValues() {
+  if (valuesCurrentBlock_ > 0) {
+    flushBlock();
+  }
+  PARQUET_ASSIGN_OR_THROW(auto buffer, sink_.Finish(true));
+
+  uint8_t headerBuffer_[kMaxPageHeaderWriterSize] = {};
+  BitWriter headerWriter(headerBuffer_, sizeof(headerBuffer_));
+  if (!headerWriter.PutVlqInt(valuesPerBlock_) ||
+      !headerWriter.PutVlqInt(miniBlocksPerBlock_) ||
+      !headerWriter.PutVlqInt(totalValueCount_) ||
+      !headerWriter.PutZigZagVlqInt(static_cast<T>(firstValue_))) {
     throw ParquetException("header writing error");
   }
-  header_writer.Flush();
+  headerWriter.Flush();
 
-  // We reserved enough space at the beginning of the buffer for largest
-  // possible header and data was written immediately after. We now write the
-  // header data immediately before the end of reserved space.
-  const size_t offset_bytes =
-      kMaxPageHeaderWriterSize - header_writer.bytesWritten();
+  // We reserved enough space at the beginning of the buffer for largest.
+  // Possible header and data was written immediately after. We now write the.
+  // Header data immediately before the end of reserved space.
+  const size_t offsetBytes =
+      kMaxPageHeaderWriterSize - headerWriter.bytesWritten();
   std::memcpy(
-      buffer->mutable_data() + offset_bytes,
-      header_buffer_,
-      header_writer.bytesWritten());
-
-  // Reset counter of cached values
-  total_value_count_ = 0;
-  // Reserve enough space at the beginning of the buffer for largest possible
-  // header.
+      buffer->mutable_data() + offsetBytes,
+      headerBuffer_,
+      headerWriter.bytesWritten());
+
+  // Reset counter of cached values.
+  totalValueCount_ = 0;
+  // Reserve enough space at the beginning of the buffer for largest possible.
+  // Header.
   PARQUET_THROW_NOT_OK(sink_.Advance(kMaxPageHeaderWriterSize));
 
   // Excess bytes at the beginning are sliced off and ignored.
-  return SliceBuffer(buffer, offset_bytes);
+  return ::arrow::SliceBuffer(buffer, offsetBytes);
 }
 
 template <>
-void DeltaBitPackEncoder<Int32Type>::Put(const ::arrow::Array& values) {
+void DeltaBitPackEncoder<Int32Type>::put(const ::arrow::Array& values) {
   const ::arrow::ArrayData& data = *values.data();
   if (values.type_id() != ::arrow::Type::INT32) {
     throw ParquetException(
@@ -2669,9 +2634,9 @@ void DeltaBitPackEncoder<Int32Type>::Put(const ::arrow::Array& values) {
   }
 
   if (values.null_count() == 0) {
-    Put(data.GetValues<int32_t>(1), static_cast<int>(data.length));
+    put(data.GetValues<int32_t>(1), static_cast<int>(data.length));
   } else {
-    PutSpaced(
+    putSpaced(
         data.GetValues<int32_t>(1),
         static_cast<int>(data.length),
         data.GetValues<uint8_t>(0, 0),
@@ -2680,7 +2645,7 @@ void DeltaBitPackEncoder<Int32Type>::Put(const ::arrow::Array& values) {
 }
 
 template <>
-void DeltaBitPackEncoder<Int64Type>::Put(const ::arrow::Array& values) {
+void DeltaBitPackEncoder<Int64Type>::put(const ::arrow::Array& values) {
   const ::arrow::ArrayData& data = *values.data();
   if (values.type_id() != ::arrow::Type::INT64) {
     throw ParquetException(
@@ -2691,9 +2656,9 @@ void DeltaBitPackEncoder<Int64Type>::Put(const ::arrow::Array& values) {
         "Array cannot be longer than ", std::numeric_limits<int32_t>::max());
   }
   if (values.null_count() == 0) {
-    Put(data.GetValues<int64_t>(1), static_cast<int>(data.length));
+    put(data.GetValues<int64_t>(1), static_cast<int>(data.length));
   } else {
-    PutSpaced(
+    putSpaced(
         data.GetValues<int64_t>(1),
         static_cast<int>(data.length),
         data.GetValues<uint8_t>(0, 0),
@@ -2702,275 +2667,272 @@ void DeltaBitPackEncoder<Int64Type>::Put(const ::arrow::Array& values) {
 }
 
 template <typename DType>
-void DeltaBitPackEncoder<DType>::PutSpaced(
+void DeltaBitPackEncoder<DType>::putSpaced(
     const T* src,
-    int num_values,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset) {
-  if (valid_bits != NULLPTR) {
-    PARQUET_ASSIGN_OR_THROW(
-        auto buffer,
-        ::arrow::AllocateBuffer(num_values * sizeof(T), this->memory_pool()));
+    int numValues,
+    const uint8_t* validBits,
+    int64_t validBitsOffset) {
+  if (validBits != NULLPTR) {
+    auto buffer = allocateBuffer(this->memoryPool(), numValues * sizeof(T));
     T* data = reinterpret_cast<T*>(buffer->mutable_data());
-    int num_valid_values = ::arrow::util::internal::SpacedCompress<T>(
-        src, num_values, valid_bits, valid_bits_offset, data);
-    Put(data, num_valid_values);
+    int numValidValues = ::arrow::util::internal::SpacedCompress<T>(
+        src, numValues, validBits, validBitsOffset, data);
+    put(data, numValidValues);
   } else {
-    Put(src, num_values);
+    put(src, numValues);
   }
 }
 
-// ----------------------------------------------------------------------
-// DeltaBitPackDecoder
+// ----------------------------------------------------------------------.
+// DeltaBitPackDecoder.
 
 template <typename DType>
 class DeltaBitPackDecoder : public DecoderImpl,
                             virtual public TypedDecoder<DType> {
  public:
-  typedef typename DType::c_type T;
+  typedef typename DType::CType T;
   using UT = std::make_unsigned_t<T>;
 
   explicit DeltaBitPackDecoder(
       const ColumnDescriptor* descr,
       MemoryPool* pool = ::arrow::default_memory_pool())
-      : DecoderImpl(descr, Encoding::DELTA_BINARY_PACKED), pool_(pool) {
-    if (DType::type_num != Type::INT32 && DType::type_num != Type::INT64) {
+      : DecoderImpl(descr, Encoding::kDeltaBinaryPacked), pool_(pool) {
+    if (DType::typeNum != Type::kInt32 && DType::typeNum != Type::kInt64) {
       throw ParquetException(
           "Delta bit pack encoding should only be for integer data.");
     }
   }
 
-  void SetData(int num_values, const uint8_t* data, int len) override {
-    // num_values is equal to page's num_values, including null values in this
-    // page
-    this->num_values_ = num_values;
+  void setData(int numValues, const uint8_t* data, int len) override {
+    // Num_values is equal to page's num_values, including null values in this.
+    // Page.
+    this->numValues_ = numValues;
     decoder_ = std::make_shared<BitReader>(data, len);
-    InitHeader();
+    initHeader();
   }
 
-  // Set BitReader which is already initialized by DeltaLengthByteArrayDecoder
-  // or DeltaByteArrayDecoder
-  void SetDecoder(int num_values, std::shared_ptr<BitReader> decoder) {
-    this->num_values_ = num_values;
+  // Set BitReader which is already initialized by DeltaLengthByteArrayDecoder.
+  // Or DeltaByteArrayDecoder.
+  void setDecoder(int numValues, std::shared_ptr<BitReader> decoder) {
+    this->numValues_ = numValues;
     decoder_ = std::move(decoder);
-    InitHeader();
+    initHeader();
   }
 
-  int ValidValuesCount() {
-    // total_values_remaining_ in header ignores of null values
-    return static_cast<int>(total_values_remaining_);
+  int validValuesCount() {
+    // Total_values_remaining_ in header ignores of null values.
+    return static_cast<int>(totalValuesRemaining_);
   }
 
-  int Decode(T* buffer, int max_values) override {
-    return GetInternal(buffer, max_values);
+  int decode(T* buffer, int maxValues) override {
+    return getInternal(buffer, maxValues);
   }
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<DType>::Accumulator* out) override {
-    if (null_count != 0) {
+    if (nullCount != 0) {
       // TODO(ARROW-34660): implement DecodeArrow with null slots.
       ParquetException::NYI("Delta bit pack DecodeArrow with null slots");
     }
-    std::vector<T> values(num_values);
-    int decoded_count = GetInternal(values.data(), num_values);
-    PARQUET_THROW_NOT_OK(out->AppendValues(values.data(), decoded_count));
-    return decoded_count;
+    std::vector<T> values(numValues);
+    int decodedCount = getInternal(values.data(), numValues);
+    PARQUET_THROW_NOT_OK(out->AppendValues(values.data(), decodedCount));
+    return decodedCount;
   }
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<DType>::DictAccumulator* out) override {
-    if (null_count != 0) {
+    if (nullCount != 0) {
       // TODO(ARROW-34660): implement DecodeArrow with null slots.
       ParquetException::NYI("Delta bit pack DecodeArrow with null slots");
     }
-    std::vector<T> values(num_values);
-    int decoded_count = GetInternal(values.data(), num_values);
-    PARQUET_THROW_NOT_OK(out->Reserve(decoded_count));
-    for (int i = 0; i < decoded_count; ++i) {
+    std::vector<T> values(numValues);
+    int decodedCount = getInternal(values.data(), numValues);
+    PARQUET_THROW_NOT_OK(out->Reserve(decodedCount));
+    for (int i = 0; i < decodedCount; ++i) {
       PARQUET_THROW_NOT_OK(out->Append(values[i]));
     }
-    return decoded_count;
+    return decodedCount;
   }
 
  private:
   static constexpr int kMaxDeltaBitWidth = static_cast<int>(sizeof(T) * 8);
 
-  void InitHeader() {
-    if (!decoder_->GetVlqInt(&values_per_block_) ||
-        !decoder_->GetVlqInt(&mini_blocks_per_block_) ||
-        !decoder_->GetVlqInt(&total_value_count_) ||
-        !decoder_->GetZigZagVlqInt(&last_value_)) {
-      ParquetException::EofException("InitHeader EOF");
+  void initHeader() {
+    if (!decoder_->GetVlqInt(&valuesPerBlock_) ||
+        !decoder_->GetVlqInt(&miniBlocksPerBlock_) ||
+        !decoder_->GetVlqInt(&totalValueCount_) ||
+        !decoder_->GetZigZagVlqInt(&lastValue_)) {
+      ParquetException::eofException("InitHeader EOF");
     }
 
-    if (values_per_block_ == 0) {
+    if (valuesPerBlock_ == 0) {
       throw ParquetException("cannot have zero value per block");
     }
-    if (values_per_block_ % 128 != 0) {
+    if (valuesPerBlock_ % 128 != 0) {
       throw ParquetException(
           "the number of values in a block must be multiple of 128, but it's " +
-          std::to_string(values_per_block_));
+          std::to_string(valuesPerBlock_));
     }
-    if (mini_blocks_per_block_ == 0) {
+    if (miniBlocksPerBlock_ == 0) {
       throw ParquetException("cannot have zero miniblock per block");
     }
-    values_per_mini_block_ = values_per_block_ / mini_blocks_per_block_;
-    if (values_per_mini_block_ == 0) {
+    valuesPerMiniBlock_ = valuesPerBlock_ / miniBlocksPerBlock_;
+    if (valuesPerMiniBlock_ == 0) {
       throw ParquetException("cannot have zero value per miniblock");
     }
-    if (values_per_mini_block_ % 32 != 0) {
+    if (valuesPerMiniBlock_ % 32 != 0) {
       throw ParquetException(
           "the number of values in a miniblock must be multiple of 32, but it's " +
-          std::to_string(values_per_mini_block_));
+          std::to_string(valuesPerMiniBlock_));
     }
 
-    total_values_remaining_ = total_value_count_;
-    if (delta_bit_widths_ == nullptr) {
-      delta_bit_widths_ = AllocateBuffer(pool_, mini_blocks_per_block_);
+    totalValuesRemaining_ = totalValueCount_;
+    if (deltaBitWidths_ == nullptr) {
+      deltaBitWidths_ = allocateBuffer(pool_, miniBlocksPerBlock_);
     } else {
-      PARQUET_THROW_NOT_OK(delta_bit_widths_->Resize(
-          mini_blocks_per_block_, /*shrink_to_fit*/ false));
+      PARQUET_THROW_NOT_OK(deltaBitWidths_->Resize(
+          miniBlocksPerBlock_, /*shrink_to_fit*/ false));
     }
-    first_block_initialized_ = false;
-    values_remaining_current_mini_block_ = 0;
+    firstBlockInitialized_ = false;
+    valuesRemainingCurrentMiniBlock_ = 0;
   }
 
-  void InitBlock() {
-    VELOX_DCHECK_GT(total_values_remaining_, 0, "InitBlock called at EOF");
+  void initBlock() {
+    VELOX_DCHECK_GT(totalValuesRemaining_, 0, "InitBlock called at EOF");
 
-    if (!decoder_->GetZigZagVlqInt(&min_delta_))
-      ParquetException::EofException("InitBlock EOF");
+    if (!decoder_->GetZigZagVlqInt(&minDelta_))
+      ParquetException::eofException("InitBlock EOF");
 
-    // read the bitwidth of each miniblock
-    uint8_t* bit_width_data = delta_bit_widths_->mutable_data();
-    for (uint32_t i = 0; i < mini_blocks_per_block_; ++i) {
-      if (!decoder_->GetAligned<uint8_t>(1, bit_width_data + i)) {
-        ParquetException::EofException("Decode bit-width EOF");
+    // Read the bitwidth of each miniblock.
+    uint8_t* bitWidthData = deltaBitWidths_->mutable_data();
+    for (uint32_t i = 0; i < miniBlocksPerBlock_; ++i) {
+      if (!decoder_->GetAligned<uint8_t>(1, bitWidthData + i)) {
+        ParquetException::eofException("Decode bit-width EOF");
       }
-      // Note that non-conformant bitwidth entries are allowed by the Parquet
-      // spec for extraneous miniblocks in the last block (GH-14923), so we
-      // check the bitwidths when actually using them (see InitMiniBlock()).
+      // Note that non-conformant bitwidth entries are allowed by the Parquet.
+      // Spec for extraneous miniblocks in the last block (GH-14923), so we.
+      // Check the bitwidths when actually using them (see InitMiniBlock()).
     }
 
-    mini_block_idx_ = 0;
-    first_block_initialized_ = true;
-    InitMiniBlock(bit_width_data[0]);
+    miniBlockIdx_ = 0;
+    firstBlockInitialized_ = true;
+    initMiniBlock(bitWidthData[0]);
   }
 
-  void InitMiniBlock(int bit_width) {
-    if (ARROW_PREDICT_FALSE(bit_width > kMaxDeltaBitWidth)) {
+  void initMiniBlock(int bitWidth) {
+    if (ARROW_PREDICT_FALSE(bitWidth > kMaxDeltaBitWidth)) {
       throw ParquetException("delta bit width larger than integer bit width");
     }
-    delta_bit_width_ = bit_width;
-    values_remaining_current_mini_block_ = values_per_mini_block_;
+    deltaBitWidth_ = bitWidth;
+    valuesRemainingCurrentMiniBlock_ = valuesPerMiniBlock_;
   }
 
-  int GetInternal(T* buffer, int max_values) {
-    max_values = static_cast<int>(
-        std::min<int64_t>(max_values, total_values_remaining_));
-    if (max_values == 0) {
+  int getInternal(T* buffer, int maxValues) {
+    maxValues =
+        static_cast<int>(std::min<int64_t>(maxValues, totalValuesRemaining_));
+    if (maxValues == 0) {
       return 0;
     }
 
     int i = 0;
-    while (i < max_values) {
-      if (ARROW_PREDICT_FALSE(values_remaining_current_mini_block_ == 0)) {
-        if (ARROW_PREDICT_FALSE(!first_block_initialized_)) {
-          buffer[i++] = last_value_;
+    while (i < maxValues) {
+      if (ARROW_PREDICT_FALSE(valuesRemainingCurrentMiniBlock_ == 0)) {
+        if (ARROW_PREDICT_FALSE(!firstBlockInitialized_)) {
+          buffer[i++] = lastValue_;
           VELOX_DCHECK_EQ(i, 1); // we're at the beginning of the page
-          if (ARROW_PREDICT_FALSE(i == max_values)) {
-            // When block is uninitialized and i reaches max_values we have two
-            // different possibilities:
-            // 1. total_value_count_ == 1, which means that the page may have
-            // only one value (encoded in the header), and we should not
-            // initialize any block.
-            // 2. total_value_count_ != 1, which means we should initialize the
-            // incoming block for subsequent reads.
-            if (total_value_count_ != 1) {
-              InitBlock();
+          if (ARROW_PREDICT_FALSE(i == maxValues)) {
+            // When block is uninitialized and i reaches max_values we have two.
+            // Different possibilities:
+            // 1. Total_value_count_ == 1, which means that the page may have.
+            // Only one value (encoded in the header), and we should not.
+            // Initialize any block.
+            // 2. Total_value_count_ != 1, which means we should initialize the.
+            // Incoming block for subsequent reads.
+            if (totalValueCount_ != 1) {
+              initBlock();
             }
             break;
           }
-          InitBlock();
+          initBlock();
         } else {
-          ++mini_block_idx_;
-          if (mini_block_idx_ < mini_blocks_per_block_) {
-            InitMiniBlock(delta_bit_widths_->data()[mini_block_idx_]);
+          ++miniBlockIdx_;
+          if (miniBlockIdx_ < miniBlocksPerBlock_) {
+            initMiniBlock(deltaBitWidths_->data()[miniBlockIdx_]);
           } else {
-            InitBlock();
+            initBlock();
           }
         }
       }
 
-      int values_decode = std::min(
-          values_remaining_current_mini_block_,
-          static_cast<uint32_t>(max_values - i));
-      if (decoder_->GetBatch(delta_bit_width_, buffer + i, values_decode) !=
-          values_decode) {
-        ParquetException::EofException();
+      int valuesDecode = std::min(
+          valuesRemainingCurrentMiniBlock_,
+          static_cast<uint32_t>(maxValues - i));
+      if (decoder_->GetBatch(deltaBitWidth_, buffer + i, valuesDecode) !=
+          valuesDecode) {
+        ParquetException::eofException();
       }
-      for (int j = 0; j < values_decode; ++j) {
-        // Addition between min_delta, packed int and last_value should be
-        // treated as unsigned addition. Overflow is as expected.
-        buffer[i + j] = static_cast<UT>(min_delta_) +
-            static_cast<UT>(buffer[i + j]) + static_cast<UT>(last_value_);
-        last_value_ = buffer[i + j];
+      for (int j = 0; j < valuesDecode; ++j) {
+        // Addition between min_delta, packed int and last_value should be.
+        // Treated as unsigned addition. Overflow is as expected.
+        buffer[i + j] = static_cast<UT>(minDelta_) +
+            static_cast<UT>(buffer[i + j]) + static_cast<UT>(lastValue_);
+        lastValue_ = buffer[i + j];
       }
-      values_remaining_current_mini_block_ -= values_decode;
-      i += values_decode;
-    }
-    total_values_remaining_ -= max_values;
-    this->num_values_ -= max_values;
-
-    if (ARROW_PREDICT_FALSE(total_values_remaining_ == 0)) {
-      uint32_t padding_bits =
-          values_remaining_current_mini_block_ * delta_bit_width_;
-      // skip the padding bits
-      if (!decoder_->Advance(padding_bits)) {
-        ParquetException::EofException();
+      valuesRemainingCurrentMiniBlock_ -= valuesDecode;
+      i += valuesDecode;
+    }
+    totalValuesRemaining_ -= maxValues;
+    this->numValues_ -= maxValues;
+
+    if (ARROW_PREDICT_FALSE(totalValuesRemaining_ == 0)) {
+      uint32_t paddingBits = valuesRemainingCurrentMiniBlock_ * deltaBitWidth_;
+      // Skip the padding bits.
+      if (!decoder_->Advance(paddingBits)) {
+        ParquetException::eofException();
       }
-      values_remaining_current_mini_block_ = 0;
+      valuesRemainingCurrentMiniBlock_ = 0;
     }
-    return max_values;
+    return maxValues;
   }
 
   MemoryPool* pool_;
   std::shared_ptr<BitReader> decoder_;
-  uint32_t values_per_block_;
-  uint32_t mini_blocks_per_block_;
-  uint32_t values_per_mini_block_;
-  uint32_t total_value_count_;
-
-  uint32_t total_values_remaining_;
-  // Remaining values in current mini block. If the current block is the last
-  // mini block, values_remaining_current_mini_block_ may greater than
-  // total_values_remaining_.
-  uint32_t values_remaining_current_mini_block_;
-
-  // If the page doesn't contain any block, `first_block_initialized_` will
-  // always be false. Otherwise, it will be true when first block initialized.
-  bool first_block_initialized_;
-  T min_delta_;
-  uint32_t mini_block_idx_;
-  std::shared_ptr<ResizableBuffer> delta_bit_widths_;
-  int delta_bit_width_;
-
-  T last_value_;
+  uint32_t valuesPerBlock_;
+  uint32_t miniBlocksPerBlock_;
+  uint32_t valuesPerMiniBlock_;
+  uint32_t totalValueCount_;
+
+  uint32_t totalValuesRemaining_;
+  // Remaining values in current mini block. If the current block is the last.
+  // Mini block, values_remaining_current_mini_block_ may greater than.
+  // Total_values_remaining_.
+  uint32_t valuesRemainingCurrentMiniBlock_;
+
+  // If the page doesn't contain any block, `first_block_initialized_` will.
+  // Always be false. Otherwise, it will be true when first block initialized.
+  bool firstBlockInitialized_;
+  T minDelta_;
+  uint32_t miniBlockIdx_;
+  std::shared_ptr<ResizableBuffer> deltaBitWidths_;
+  int deltaBitWidth_;
+
+  T lastValue_;
 };
 
-// ----------------------------------------------------------------------
-// DELTA_LENGTH_BYTE_ARRAY
+// ----------------------------------------------------------------------.
+// DELTA_LENGTH_BYTE_ARRAY.
 
-// ----------------------------------------------------------------------
-// DeltaLengthByteArrayEncoder
+// ----------------------------------------------------------------------.
+// DeltaLengthByteArrayEncoder.
 
 template <typename DType>
 class DeltaLengthByteArrayEncoder : public EncoderImpl,
@@ -2981,33 +2943,33 @@ class DeltaLengthByteArrayEncoder : public EncoderImpl,
       MemoryPool* pool)
       : EncoderImpl(
             descr,
-            Encoding::DELTA_LENGTH_BYTE_ARRAY,
+            Encoding::kDeltaLengthByteArray,
             pool = ::arrow::default_memory_pool()),
         sink_(pool),
-        length_encoder_(nullptr, pool),
-        encoded_size_{0} {}
+        lengthEncoder_(nullptr, pool),
+        encodedSize_{0} {}
 
-  std::shared_ptr<Buffer> FlushValues() override;
+  std::shared_ptr<Buffer> flushValues() override;
 
-  int64_t EstimatedDataEncodedSize() override {
-    return encoded_size_ + length_encoder_.EstimatedDataEncodedSize();
+  int64_t estimatedDataEncodedSize() override {
+    return encodedSize_ + lengthEncoder_.estimatedDataEncodedSize();
   }
 
-  using TypedEncoder<ByteArrayType>::Put;
+  using TypedEncoder<ByteArrayType>::put;
 
-  void Put(const ::arrow::Array& values) override;
+  void put(const ::arrow::Array& values) override;
 
-  void Put(const T* buffer, int num_values) override;
+  void put(const T* buffer, int numValues) override;
 
-  void PutSpaced(
+  void putSpaced(
       const T* src,
-      int num_values,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset) override;
+      int numValues,
+      const uint8_t* validBits,
+      int64_t validBitsOffset) override;
 
  protected:
   template <typename ArrayType>
-  void PutBinaryArray(const ArrayType& array) {
+  void putBinaryArray(const ArrayType& array) {
     PARQUET_THROW_NOT_OK(
         ::arrow::VisitArraySpanInline<typename ArrayType::TypeClass>(
             *array.data(),
@@ -3016,7 +2978,7 @@ class DeltaLengthByteArrayEncoder : public EncoderImpl,
                 return Status::Invalid(
                     "Parquet cannot store strings with size 2GB or more");
               }
-              length_encoder_.Put({static_cast<int32_t>(view.length())}, 1);
+              lengthEncoder_.put({static_cast<int32_t>(view.length())}, 1);
               PARQUET_THROW_NOT_OK(sink_.Append(view.data(), view.length()));
               return Status::OK();
             },
@@ -3024,90 +2986,88 @@ class DeltaLengthByteArrayEncoder : public EncoderImpl,
   }
 
   ::arrow::BufferBuilder sink_;
-  DeltaBitPackEncoder<Int32Type> length_encoder_;
-  uint32_t encoded_size_;
+  DeltaBitPackEncoder<Int32Type> lengthEncoder_;
+  uint32_t encodedSize_;
 };
 
 template <typename DType>
-void DeltaLengthByteArrayEncoder<DType>::Put(const ::arrow::Array& values) {
-  AssertBaseBinary(values);
+void DeltaLengthByteArrayEncoder<DType>::put(const ::arrow::Array& values) {
+  assertBaseBinary(values);
   if (::arrow::is_binary_like(values.type_id())) {
-    PutBinaryArray(checked_cast<const ::arrow::BinaryArray&>(values));
+    putBinaryArray(checked_cast<const ::arrow::BinaryArray&>(values));
   } else {
-    PutBinaryArray(checked_cast<const ::arrow::LargeBinaryArray&>(values));
+    putBinaryArray(checked_cast<const ::arrow::LargeBinaryArray&>(values));
   }
 }
 
 template <typename DType>
-void DeltaLengthByteArrayEncoder<DType>::Put(const T* src, int num_values) {
-  if (num_values == 0) {
+void DeltaLengthByteArrayEncoder<DType>::put(const T* src, int numValues) {
+  if (numValues == 0) {
     return;
   }
 
   constexpr int kBatchSize = 256;
   std::array<int32_t, kBatchSize> lengths;
-  uint32_t total_increment_size = 0;
-  for (int idx = 0; idx < num_values; idx += kBatchSize) {
-    const int batch_size = std::min(kBatchSize, num_values - idx);
-    for (int j = 0; j < batch_size; ++j) {
+  uint32_t totalIncrementSize = 0;
+  for (int idx = 0; idx < numValues; idx += kBatchSize) {
+    const int batchSize = std::min(kBatchSize, numValues - idx);
+    for (int j = 0; j < batchSize; ++j) {
       const int32_t len = src[idx + j].len;
-      if (AddWithOverflow(total_increment_size, len, &total_increment_size)) {
+      if (AddWithOverflow(totalIncrementSize, len, &totalIncrementSize)) {
         throw ParquetException("excess expansion in DELTA_LENGTH_BYTE_ARRAY");
       }
       lengths[j] = len;
     }
-    length_encoder_.Put(lengths.data(), batch_size);
+    lengthEncoder_.put(lengths.data(), batchSize);
   }
 
-  if (AddWithOverflow(encoded_size_, total_increment_size, &encoded_size_)) {
+  if (AddWithOverflow(encodedSize_, totalIncrementSize, &encodedSize_)) {
     throw ParquetException("excess expansion in DELTA_LENGTH_BYTE_ARRAY");
   }
-  PARQUET_THROW_NOT_OK(sink_.Reserve(total_increment_size));
-  for (int idx = 0; idx < num_values; idx++) {
+  PARQUET_THROW_NOT_OK(sink_.Reserve(totalIncrementSize));
+  for (int idx = 0; idx < numValues; idx++) {
     sink_.UnsafeAppend(src[idx].ptr, src[idx].len);
   }
 }
 
 template <typename DType>
-void DeltaLengthByteArrayEncoder<DType>::PutSpaced(
+void DeltaLengthByteArrayEncoder<DType>::putSpaced(
     const T* src,
-    int num_values,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset) {
-  if (valid_bits != NULLPTR) {
-    PARQUET_ASSIGN_OR_THROW(
-        auto buffer,
-        ::arrow::AllocateBuffer(num_values * sizeof(T), this->memory_pool()));
+    int numValues,
+    const uint8_t* validBits,
+    int64_t validBitsOffset) {
+  if (validBits != NULLPTR) {
+    auto buffer = allocateBuffer(this->memoryPool(), numValues * sizeof(T));
     T* data = reinterpret_cast<T*>(buffer->mutable_data());
-    int num_valid_values = ::arrow::util::internal::SpacedCompress<T>(
-        src, num_values, valid_bits, valid_bits_offset, data);
-    Put(data, num_valid_values);
+    int numValidValues = ::arrow::util::internal::SpacedCompress<T>(
+        src, numValues, validBits, validBitsOffset, data);
+    put(data, numValidValues);
   } else {
-    Put(src, num_values);
+    put(src, numValues);
   }
 }
 
 template <typename DType>
-std::shared_ptr<Buffer> DeltaLengthByteArrayEncoder<DType>::FlushValues() {
-  std::shared_ptr<Buffer> encoded_lengths = length_encoder_.FlushValues();
+std::shared_ptr<Buffer> DeltaLengthByteArrayEncoder<DType>::flushValues() {
+  std::shared_ptr<Buffer> encodedLengths = lengthEncoder_.flushValues();
 
   std::shared_ptr<Buffer> data;
   PARQUET_THROW_NOT_OK(sink_.Finish(&data));
   sink_.Reset();
 
-  PARQUET_THROW_NOT_OK(sink_.Resize(encoded_lengths->size() + data->size()));
+  PARQUET_THROW_NOT_OK(sink_.Resize(encodedLengths->size() + data->size()));
   PARQUET_THROW_NOT_OK(
-      sink_.Append(encoded_lengths->data(), encoded_lengths->size()));
+      sink_.Append(encodedLengths->data(), encodedLengths->size()));
   PARQUET_THROW_NOT_OK(sink_.Append(data->data(), data->size()));
 
   std::shared_ptr<Buffer> buffer;
   PARQUET_THROW_NOT_OK(sink_.Finish(&buffer, true));
-  encoded_size_ = 0;
+  encodedSize_ = 0;
   return buffer;
 }
 
-// ----------------------------------------------------------------------
-// DeltaLengthByteArrayDecoder
+// ----------------------------------------------------------------------.
+// DeltaLengthByteArrayDecoder.
 
 class DeltaLengthByteArrayDecoder : public DecoderImpl,
                                     virtual public TypedDecoder<ByteArrayType> {
@@ -3115,155 +3075,152 @@ class DeltaLengthByteArrayDecoder : public DecoderImpl,
   explicit DeltaLengthByteArrayDecoder(
       const ColumnDescriptor* descr,
       MemoryPool* pool = ::arrow::default_memory_pool())
-      : DecoderImpl(descr, Encoding::DELTA_LENGTH_BYTE_ARRAY),
-        len_decoder_(nullptr, pool),
-        buffered_length_(AllocateBuffer(pool, 0)) {}
+      : DecoderImpl(descr, Encoding::kDeltaLengthByteArray),
+        lenDecoder_(nullptr, pool),
+        bufferedLength_(allocateBuffer(pool, 0)) {}
 
-  void SetData(int num_values, const uint8_t* data, int len) override {
-    DecoderImpl::SetData(num_values, data, len);
+  void setData(int numValues, const uint8_t* data, int len) override {
+    DecoderImpl::setData(numValues, data, len);
     decoder_ = std::make_shared<BitReader>(data, len);
-    DecodeLengths();
+    decodeLengths();
   }
 
-  int Decode(ByteArray* buffer, int max_values) override {
-    // Decode up to `max_values` strings into an internal buffer
-    // and reference them into `buffer`.
-    max_values = std::min(max_values, num_valid_values_);
-    VELOX_DCHECK_GE(max_values, 0);
-    if (max_values == 0) {
+  int decode(ByteArray* buffer, int maxValues) override {
+    // Decode up to `max_values` strings into an internal buffer.
+    // And reference them into `buffer`.
+    maxValues = std::min(maxValues, numValidValues_);
+    VELOX_DCHECK_GE(maxValues, 0);
+    if (maxValues == 0) {
       return 0;
     }
 
-    int32_t data_size = 0;
-    const int32_t* length_ptr =
-        reinterpret_cast<const int32_t*>(buffered_length_->data()) +
-        length_idx_;
-    int bytes_offset = len_ - decoder_->bytesLeft();
-    for (int i = 0; i < max_values; ++i) {
-      int32_t len = length_ptr[i];
+    int32_t dataSize = 0;
+    const int32_t* lengthPtr =
+        reinterpret_cast<const int32_t*>(bufferedLength_->data()) + lengthIdx_;
+    int bytesOffset = len_ - decoder_->bytesLeft();
+    for (int i = 0; i < maxValues; ++i) {
+      int32_t len = lengthPtr[i];
       if (ARROW_PREDICT_FALSE(len < 0)) {
         throw ParquetException("negative string delta length");
       }
       buffer[i].len = len;
-      if (AddWithOverflow(data_size, len, &data_size)) {
+      if (AddWithOverflow(dataSize, len, &dataSize)) {
         throw ParquetException("excess expansion in DELTA_(LENGTH_)BYTE_ARRAY");
       }
     }
-    length_idx_ += max_values;
+    lengthIdx_ += maxValues;
     if (ARROW_PREDICT_FALSE(
-            !decoder_->Advance(8 * static_cast<int64_t>(data_size)))) {
-      ParquetException::EofException();
+            !decoder_->Advance(8 * static_cast<int64_t>(dataSize)))) {
+      ParquetException::eofException();
     }
-    const uint8_t* data_ptr = data_ + bytes_offset;
-    for (int i = 0; i < max_values; ++i) {
-      buffer[i].ptr = data_ptr;
-      data_ptr += buffer[i].len;
+    const uint8_t* dataPtr = data_ + bytesOffset;
+    for (int i = 0; i < maxValues; ++i) {
+      buffer[i].ptr = dataPtr;
+      dataPtr += buffer[i].len;
     }
-    this->num_values_ -= max_values;
-    num_valid_values_ -= max_values;
-    return max_values;
+    this->numValues_ -= maxValues;
+    numValidValues_ -= maxValues;
+    return maxValues;
   }
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<ByteArrayType>::Accumulator* out) override {
     int result = 0;
-    PARQUET_THROW_NOT_OK(DecodeArrowDense(
-        num_values, null_count, valid_bits, valid_bits_offset, out, &result));
+    PARQUET_THROW_NOT_OK(decodeArrowDense(
+        numValues, nullCount, validBits, validBitsOffset, out, &result));
     return result;
   }
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<ByteArrayType>::DictAccumulator* out) override {
     ParquetException::NYI(
         "DecodeArrow of DictAccumulator for DeltaLengthByteArrayDecoder");
   }
 
  private:
-  // Decode all the encoded lengths. The decoder_ will be at the start of the
-  // encoded data after that.
-  void DecodeLengths() {
-    len_decoder_.SetDecoder(num_values_, decoder_);
-
-    // get the number of encoded lengths
-    int num_length = len_decoder_.ValidValuesCount();
-    PARQUET_THROW_NOT_OK(
-        buffered_length_->Resize(num_length * sizeof(int32_t)));
-
-    // call len_decoder_.Decode to decode all the lengths.
-    // all the lengths are buffered in buffered_length_.
-    VELOX_DEBUG_ONLY int ret = len_decoder_.Decode(
-        reinterpret_cast<int32_t*>(buffered_length_->mutable_data()),
-        num_length);
-    VELOX_DCHECK_EQ(ret, num_length);
-    length_idx_ = 0;
-    num_valid_values_ = num_length;
-  }
-
-  Status DecodeArrowDense(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  // Decode all the encoded lengths. The decoder_ will be at the start of the.
+  // Encoded data after that.
+  void decodeLengths() {
+    lenDecoder_.setDecoder(numValues_, decoder_);
+
+    // Get the number of encoded lengths.
+    int numLength = lenDecoder_.validValuesCount();
+    PARQUET_THROW_NOT_OK(bufferedLength_->Resize(numLength * sizeof(int32_t)));
+
+    // Call len_decoder_.Decode to decode all the lengths.
+    // All the lengths are buffered in buffered_length_.
+    VELOX_DEBUG_ONLY int ret = lenDecoder_.decode(
+        reinterpret_cast<int32_t*>(bufferedLength_->mutable_data()), numLength);
+    VELOX_DCHECK_EQ(ret, numLength);
+    lengthIdx_ = 0;
+    numValidValues_ = numLength;
+  }
+
+  Status decodeArrowDense(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<ByteArrayType>::Accumulator* out,
-      int* out_num_values) {
+      int* outNumValues) {
     ArrowBinaryHelper helper(out);
 
-    std::vector<ByteArray> values(num_values - null_count);
-    const int num_valid_values = Decode(values.data(), num_values - null_count);
-    if (ARROW_PREDICT_FALSE(num_values - null_count != num_valid_values)) {
+    std::vector<ByteArray> values(numValues - nullCount);
+    const int numValidValues = decode(values.data(), numValues - nullCount);
+    if (ARROW_PREDICT_FALSE(numValues - nullCount != numValidValues)) {
       throw ParquetException(
           "Expected to decode ",
-          num_values - null_count,
+          numValues - nullCount,
           " values, but decoded ",
-          num_valid_values,
+          numValidValues,
           " values.");
     }
 
-    auto values_ptr = values.data();
-    int value_idx = 0;
+    auto valuesPtr = values.data();
+    int valueIdx = 0;
 
     RETURN_NOT_OK(VisitNullBitmapInline(
-        valid_bits,
-        valid_bits_offset,
-        num_values,
-        null_count,
+        validBits,
+        validBitsOffset,
+        numValues,
+        nullCount,
         [&]() {
-          const auto& val = values_ptr[value_idx];
-          if (ARROW_PREDICT_FALSE(!helper.CanFit(val.len))) {
-            RETURN_NOT_OK(helper.PushChunk());
+          const auto& val = valuesPtr[valueIdx];
+          if (ARROW_PREDICT_FALSE(!helper.canFit(val.len))) {
+            RETURN_NOT_OK(helper.pushChunk());
           }
-          RETURN_NOT_OK(helper.Append(val.ptr, static_cast<int32_t>(val.len)));
-          ++value_idx;
+          RETURN_NOT_OK(helper.append(val.ptr, static_cast<int32_t>(val.len)));
+          ++valueIdx;
           return Status::OK();
         },
         [&]() {
-          RETURN_NOT_OK(helper.AppendNull());
-          --null_count;
+          RETURN_NOT_OK(helper.appendNull());
+          --nullCount;
           return Status::OK();
         }));
 
-    VELOX_DCHECK_EQ(null_count, 0);
-    *out_num_values = num_valid_values;
+    VELOX_DCHECK_EQ(nullCount, 0);
+    *outNumValues = numValidValues;
     return Status::OK();
   }
 
   std::shared_ptr<BitReader> decoder_;
-  DeltaBitPackDecoder<Int32Type> len_decoder_;
-  int num_valid_values_;
-  uint32_t length_idx_;
-  std::shared_ptr<ResizableBuffer> buffered_length_;
+  DeltaBitPackDecoder<Int32Type> lenDecoder_;
+  int numValidValues_;
+  uint32_t lengthIdx_;
+  std::shared_ptr<ResizableBuffer> bufferedLength_;
 };
 
-// ----------------------------------------------------------------------
-// RLE_BOOLEAN_ENCODER
+// ----------------------------------------------------------------------.
+// RLE_BOOLEAN_ENCODER.
 
 class RleBooleanEncoder final : public EncoderImpl,
                                 virtual public BooleanEncoder {
@@ -3271,199 +3228,195 @@ class RleBooleanEncoder final : public EncoderImpl,
   explicit RleBooleanEncoder(
       const ColumnDescriptor* descr,
       ::arrow::MemoryPool* pool)
-      : EncoderImpl(descr, Encoding::RLE, pool),
-        buffered_append_values_(::arrow::stl::allocator<T>(pool)) {}
+      : EncoderImpl(descr, Encoding::kRle, pool),
+        bufferedAppendValues_(::arrow::stl::allocator<T>(pool)) {}
 
-  int64_t EstimatedDataEncodedSize() override {
-    return kRleLengthInBytes + MaxRleBufferSize();
+  int64_t estimatedDataEncodedSize() override {
+    return kRleLengthInBytes + maxRleBufferSize();
   }
 
-  std::shared_ptr<Buffer> FlushValues() override;
+  std::shared_ptr<Buffer> flushValues() override;
 
-  void Put(const T* buffer, int num_values) override;
-  void Put(const ::arrow::Array& values) override {
+  void put(const T* buffer, int numValues) override;
+  void put(const ::arrow::Array& values) override {
     if (values.type_id() != ::arrow::Type::BOOL) {
       throw ParquetException(
           "RleBooleanEncoder expects BooleanArray, got ",
           values.type()->ToString());
     }
-    const auto& boolean_array =
+    const auto& booleanArray =
         checked_cast<const ::arrow::BooleanArray&>(values);
     if (values.null_count() == 0) {
-      for (int i = 0; i < boolean_array.length(); ++i) {
-        // null_count == 0, so just call Value directly is ok.
-        buffered_append_values_.push_back(boolean_array.Value(i));
+      for (int i = 0; i < booleanArray.length(); ++i) {
+        // Null_count == 0, so just call Value directly is ok.
+        bufferedAppendValues_.push_back(booleanArray.Value(i));
       }
     } else {
-      PARQUET_THROW_NOT_OK(::arrow::VisitArraySpanInline<::arrow::BooleanType>(
-          *boolean_array.data(),
-          [&](bool value) {
-            buffered_append_values_.push_back(value);
-            return Status::OK();
-          },
-          []() { return Status::OK(); }));
+      PARQUET_THROW_NOT_OK(
+          ::arrow::VisitArraySpanInline<::arrow::BooleanType>(
+              *booleanArray.data(),
+              [&](bool value) {
+                bufferedAppendValues_.push_back(value);
+                return Status::OK();
+              },
+              []() { return Status::OK(); }));
     }
   }
 
-  void PutSpaced(
+  void putSpaced(
       const T* src,
-      int num_values,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset) override {
-    if (valid_bits != NULLPTR) {
-      PARQUET_ASSIGN_OR_THROW(
-          auto buffer,
-          ::arrow::AllocateBuffer(num_values * sizeof(T), this->memory_pool()));
+      int numValues,
+      const uint8_t* validBits,
+      int64_t validBitsOffset) override {
+    if (validBits != NULLPTR) {
+      auto buffer = allocateBuffer(this->memoryPool(), numValues * sizeof(T));
       T* data = reinterpret_cast<T*>(buffer->mutable_data());
-      int num_valid_values = ::arrow::util::internal::SpacedCompress<T>(
-          src, num_values, valid_bits, valid_bits_offset, data);
-      Put(data, num_valid_values);
+      int numValidValues = ::arrow::util::internal::SpacedCompress<T>(
+          src, numValues, validBits, validBitsOffset, data);
+      put(data, numValidValues);
     } else {
-      Put(src, num_values);
+      put(src, numValues);
     }
   }
 
-  void Put(const std::vector<bool>& src, int num_values) override;
+  void put(const std::vector<bool>& src, int numValues) override;
 
  protected:
   template <typename SequenceType>
-  void PutImpl(const SequenceType& src, int num_values);
+  void putImpl(const SequenceType& src, int numValues);
 
-  int MaxRleBufferSize() const noexcept {
-    return RlePreserveBufferSize(
-        static_cast<int>(buffered_append_values_.size()), kBitWidth);
+  int maxRleBufferSize() const noexcept {
+    return rlePreserveBufferSize(
+        static_cast<int>(bufferedAppendValues_.size()), kBitWidth);
   }
 
   constexpr static int32_t kBitWidth = 1;
-  /// 4 bytes in little-endian, which indicates the length.
+  /// 4 Bytes in little-endian, which indicates the length.
   constexpr static int32_t kRleLengthInBytes = 4;
 
-  // std::vector<bool> in C++ is tricky, because it's a bitmap.
-  // Here RleBooleanEncoder will only append values into it, and
-  // dump values into Buffer, so using it here is ok.
-  ArrowPoolVector<bool> buffered_append_values_;
+  // Std::vector<bool> in C++ is tricky, because it's a bitmap.
+  // Here RleBooleanEncoder will only append values into it, and.
+  // Dump values into Buffer, so using it here is ok.
+  ArrowPoolVector<bool> bufferedAppendValues_;
 };
 
-void RleBooleanEncoder::Put(const bool* src, int num_values) {
-  PutImpl(src, num_values);
+void RleBooleanEncoder::put(const bool* src, int numValues) {
+  putImpl(src, numValues);
 }
 
-void RleBooleanEncoder::Put(const std::vector<bool>& src, int num_values) {
-  PutImpl(src, num_values);
+void RleBooleanEncoder::put(const std::vector<bool>& src, int numValues) {
+  putImpl(src, numValues);
 }
 
 template <typename SequenceType>
-void RleBooleanEncoder::PutImpl(const SequenceType& src, int num_values) {
-  for (int i = 0; i < num_values; ++i) {
-    buffered_append_values_.push_back(src[i]);
+void RleBooleanEncoder::putImpl(const SequenceType& src, int numValues) {
+  for (int i = 0; i < numValues; ++i) {
+    bufferedAppendValues_.push_back(src[i]);
   }
 }
 
-std::shared_ptr<Buffer> RleBooleanEncoder::FlushValues() {
-  int rle_buffer_size_max = MaxRleBufferSize();
+std::shared_ptr<Buffer> RleBooleanEncoder::flushValues() {
+  int rleBufferSizeMax = maxRleBufferSize();
   std::shared_ptr<ResizableBuffer> buffer =
-      AllocateBuffer(this->pool_, rle_buffer_size_max + kRleLengthInBytes);
+      allocateBuffer(this->pool_, rleBufferSizeMax + kRleLengthInBytes);
   RleEncoder encoder(
       buffer->mutable_data() + kRleLengthInBytes,
-      rle_buffer_size_max,
+      rleBufferSizeMax,
       /*bit_width*/ kBitWidth);
 
-  for (bool value : buffered_append_values_) {
+  for (bool value : bufferedAppendValues_) {
     encoder.Put(value ? 1 : 0);
   }
   encoder.Flush();
   ::arrow::util::SafeStore(
       buffer->mutable_data(), ::arrow::bit_util::ToLittleEndian(encoder.len()));
   PARQUET_THROW_NOT_OK(buffer->Resize(kRleLengthInBytes + encoder.len()));
-  buffered_append_values_.clear();
+  bufferedAppendValues_.clear();
   return buffer;
 }
 
-// ----------------------------------------------------------------------
-// RLE_BOOLEAN_DECODER
+// ----------------------------------------------------------------------.
+// RLE_BOOLEAN_DECODER.
 
 class RleBooleanDecoder : public DecoderImpl, virtual public BooleanDecoder {
  public:
   explicit RleBooleanDecoder(const ColumnDescriptor* descr)
-      : DecoderImpl(descr, Encoding::RLE) {}
+      : DecoderImpl(descr, Encoding::kRle) {}
 
-  void SetData(int num_values, const uint8_t* data, int len) override {
-    num_values_ = num_values;
-    uint32_t num_bytes = 0;
+  void setData(int numValues, const uint8_t* data, int len) override {
+    numValues_ = numValues;
+    uint32_t numBytes = 0;
 
     if (len < 4) {
       throw ParquetException(
           "Received invalid length : " + std::to_string(len) +
           " (corrupt data page?)");
     }
-    // Load the first 4 bytes in little-endian, which indicates the length
-    num_bytes = ::arrow::bit_util::FromLittleEndian(SafeLoadAs<uint32_t>(data));
-    if (num_bytes > static_cast<uint32_t>(len - 4)) {
+    // Load the first 4 bytes in little-endian, which indicates the length.
+    numBytes = ::arrow::bit_util::FromLittleEndian(SafeLoadAs<uint32_t>(data));
+    if (numBytes > static_cast<uint32_t>(len - 4)) {
       throw ParquetException(
-          "Received invalid number of bytes : " + std::to_string(num_bytes) +
+          "Received invalid number of bytes : " + std::to_string(numBytes) +
           " (corrupt data page?)");
     }
 
-    auto decoder_data = data + 4;
+    auto decoderData = data + 4;
     if (decoder_ == nullptr) {
-      decoder_ = std::make_shared<RleDecoder>(
-          decoder_data,
-          num_bytes,
-          /*bit_width=*/1);
+      decoder_ = std::make_shared<RleDecoder>(decoderData, numBytes, 1);
     } else {
-      decoder_->Reset(decoder_data, num_bytes, /*bitWidth=*/1);
+      decoder_->Reset(decoderData, numBytes, 1);
     }
   }
 
-  int Decode(bool* buffer, int max_values) override {
-    max_values = std::min(max_values, num_values_);
+  int decode(bool* buffer, int maxValues) override {
+    maxValues = std::min(maxValues, numValues_);
 
-    if (decoder_->GetBatch(buffer, max_values) != max_values) {
-      ParquetException::EofException();
+    if (decoder_->GetBatch(buffer, maxValues) != maxValues) {
+      ParquetException::eofException();
     }
-    num_values_ -= max_values;
-    return max_values;
+    numValues_ -= maxValues;
+    return maxValues;
   }
 
-  int Decode(uint8_t* buffer, int max_values) override {
+  int decode(uint8_t* buffer, int maxValues) override {
     ParquetException::NYI("Decode(uint8_t*, int) for RleBooleanDecoder");
   }
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<BooleanType>::Accumulator* out) override {
-    if (null_count != 0) {
+    if (nullCount != 0) {
       // TODO(ARROW-34660): implement DecodeArrow with null slots.
       ParquetException::NYI("RleBoolean DecodeArrow with null slots");
     }
     constexpr int kBatchSize = 1024;
     std::array<bool, kBatchSize> values;
-    int sum_decode_count = 0;
+    int sumDecodeCount = 0;
     do {
-      int current_batch = std::min(kBatchSize, num_values);
-      int decoded_count = decoder_->GetBatch(values.data(), current_batch);
-      if (decoded_count == 0) {
+      int currentBatch = std::min(kBatchSize, numValues);
+      int decodedCount = decoder_->GetBatch(values.data(), currentBatch);
+      if (decodedCount == 0) {
         break;
       }
-      sum_decode_count += decoded_count;
-      PARQUET_THROW_NOT_OK(out->Reserve(sum_decode_count));
-      for (int i = 0; i < decoded_count; ++i) {
+      sumDecodeCount += decodedCount;
+      PARQUET_THROW_NOT_OK(out->Reserve(sumDecodeCount));
+      for (int i = 0; i < decodedCount; ++i) {
         PARQUET_THROW_NOT_OK(out->Append(values[i]));
       }
-      num_values -= decoded_count;
-    } while (num_values > 0);
-    return sum_decode_count;
+      numValues -= decodedCount;
+    } while (numValues > 0);
+    return sumDecodeCount;
   }
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      typename EncodingTraits<BooleanType>::DictAccumulator* builder) override {
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      typename EncodingTraits<BooleanType>::DictAccumulator* Builder) override {
     ParquetException::NYI("DecodeArrow for RleBooleanDecoder");
   }
 
@@ -3471,8 +3424,8 @@ class RleBooleanDecoder : public DecoderImpl, virtual public BooleanDecoder {
   std::shared_ptr<RleDecoder> decoder_;
 };
 
-// ----------------------------------------------------------------------
-// DELTA_BYTE_ARRAY
+// ----------------------------------------------------------------------.
+// DELTA_BYTE_ARRAY.
 
 class DeltaByteArrayDecoder : public DecoderImpl,
                               virtual public TypedDecoder<ByteArrayType> {
@@ -3480,224 +3433,224 @@ class DeltaByteArrayDecoder : public DecoderImpl,
   explicit DeltaByteArrayDecoder(
       const ColumnDescriptor* descr,
       MemoryPool* pool = ::arrow::default_memory_pool())
-      : DecoderImpl(descr, Encoding::DELTA_BYTE_ARRAY),
-        prefix_len_decoder_(nullptr, pool),
-        suffix_decoder_(nullptr, pool),
-        last_value_in_previous_page_(""),
-        buffered_prefix_length_(AllocateBuffer(pool, 0)),
-        buffered_data_(AllocateBuffer(pool, 0)) {}
-
-  void SetData(int num_values, const uint8_t* data, int len) override {
-    num_values_ = num_values;
+      : DecoderImpl(descr, Encoding::kDeltaByteArray),
+        prefixLenDecoder_(nullptr, pool),
+        suffixDecoder_(nullptr, pool),
+        lastValueInPreviousPage_(""),
+        bufferedPrefixLength_(allocateBuffer(pool, 0)),
+        bufferedData_(allocateBuffer(pool, 0)) {}
+
+  void setData(int numValues, const uint8_t* data, int len) override {
+    numValues_ = numValues;
     decoder_ = std::make_shared<BitReader>(data, len);
-    prefix_len_decoder_.SetDecoder(num_values, decoder_);
+    prefixLenDecoder_.setDecoder(numValues, decoder_);
 
-    // get the number of encoded prefix lengths
-    int num_prefix = prefix_len_decoder_.ValidValuesCount();
-    // call prefix_len_decoder_.Decode to decode all the prefix lengths.
-    // all the prefix lengths are buffered in buffered_prefix_length_.
+    // Get the number of encoded prefix lengths.
+    int numPrefix = prefixLenDecoder_.validValuesCount();
+    // Call prefix_len_decoder_.Decode to decode all the prefix lengths.
+    // All the prefix lengths are buffered in buffered_prefix_length_.
     PARQUET_THROW_NOT_OK(
-        buffered_prefix_length_->Resize(num_prefix * sizeof(int32_t)));
-    VELOX_DEBUG_ONLY int ret = prefix_len_decoder_.Decode(
-        reinterpret_cast<int32_t*>(buffered_prefix_length_->mutable_data()),
-        num_prefix);
-    VELOX_DCHECK_EQ(ret, num_prefix);
-    prefix_len_offset_ = 0;
-    num_valid_values_ = num_prefix;
-
-    int bytes_left = decoder_->bytesLeft();
+        bufferedPrefixLength_->Resize(numPrefix * sizeof(int32_t)));
+    VELOX_DEBUG_ONLY int ret = prefixLenDecoder_.decode(
+        reinterpret_cast<int32_t*>(bufferedPrefixLength_->mutable_data()),
+        numPrefix);
+    VELOX_DCHECK_EQ(ret, numPrefix);
+    prefixLenOffset_ = 0;
+    numValidValues_ = numPrefix;
+
+    int bytesLeft = decoder_->bytesLeft();
     // If len < bytes_left, prefix_len_decoder.Decode will throw exception.
-    VELOX_DCHECK_GE(len, bytes_left);
-    int suffix_begins = len - bytes_left;
-    // at this time, the decoder_ will be at the start of the encoded suffix
-    // data.
-    suffix_decoder_.SetData(num_values, data + suffix_begins, bytes_left);
-
-    // TODO: read corrupted files written with bug(PARQUET-246). last_value_
-    // should be set to last_value_in_previous_page_ when decoding a new
+    VELOX_DCHECK_GE(len, bytesLeft);
+    int suffixBegins = len - bytesLeft;
+    // At this time, the decoder_ will be at the start of the encoded suffix.
+    // Data.
+    suffixDecoder_.setData(numValues, data + suffixBegins, bytesLeft);
+
+    // TODO: read corrupted files written with bug(PARQUET-246). last_value_.
+    // Should be set to last_value_in_previous_page_ when decoding a new.
     // page(except the first page)
-    last_value_ = "";
+    lastValue_ = "";
   }
 
-  int Decode(ByteArray* buffer, int max_values) override {
-    return GetInternal(buffer, max_values);
+  int decode(ByteArray* buffer, int maxValues) override {
+    return getInternal(buffer, maxValues);
   }
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<ByteArrayType>::Accumulator* out) override {
     int result = 0;
-    PARQUET_THROW_NOT_OK(DecodeArrowDense(
-        num_values, null_count, valid_bits, valid_bits_offset, out, &result));
+    PARQUET_THROW_NOT_OK(decodeArrowDense(
+        numValues, nullCount, validBits, validBitsOffset, out, &result));
     return result;
   }
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      typename EncodingTraits<ByteArrayType>::DictAccumulator* builder)
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      typename EncodingTraits<ByteArrayType>::DictAccumulator* Builder)
       override {
     ParquetException::NYI(
         "DecodeArrow of DictAccumulator for DeltaByteArrayDecoder");
   }
 
  private:
-  int GetInternal(ByteArray* buffer, int max_values) {
-    // Decode up to `max_values` strings into an internal buffer
-    // and reference them into `buffer`.
-    max_values = std::min(max_values, num_valid_values_);
-    if (max_values == 0) {
-      return max_values;
-    }
-
-    int suffix_read = suffix_decoder_.Decode(buffer, max_values);
-    if (ARROW_PREDICT_FALSE(suffix_read != max_values)) {
-      ParquetException::EofException(
-          "Read " + std::to_string(suffix_read) + ", expecting " +
-          std::to_string(max_values) + " from suffix decoder");
-    }
-
-    int64_t data_size = 0;
-    const int32_t* prefix_len_ptr =
-        reinterpret_cast<const int32_t*>(buffered_prefix_length_->data()) +
-        prefix_len_offset_;
-    for (int i = 0; i < max_values; ++i) {
-      if (ARROW_PREDICT_FALSE(prefix_len_ptr[i] < 0)) {
+  int getInternal(ByteArray* buffer, int maxValues) {
+    // Decode up to `max_values` strings into an internal buffer.
+    // And reference them into `buffer`.
+    maxValues = std::min(maxValues, numValidValues_);
+    if (maxValues == 0) {
+      return maxValues;
+    }
+
+    int suffixRead = suffixDecoder_.decode(buffer, maxValues);
+    if (ARROW_PREDICT_FALSE(suffixRead != maxValues)) {
+      ParquetException::eofException(
+          "Read " + std::to_string(suffixRead) + ", expecting " +
+          std::to_string(maxValues) + " from suffix decoder");
+    }
+
+    int64_t dataSize = 0;
+    const int32_t* prefixLenPtr =
+        reinterpret_cast<const int32_t*>(bufferedPrefixLength_->data()) +
+        prefixLenOffset_;
+    for (int i = 0; i < maxValues; ++i) {
+      if (ARROW_PREDICT_FALSE(prefixLenPtr[i] < 0)) {
         throw ParquetException("negative prefix length in DELTA_BYTE_ARRAY");
       }
       if (ARROW_PREDICT_FALSE(
-              AddWithOverflow(data_size, prefix_len_ptr[i], &data_size) ||
-              AddWithOverflow(data_size, buffer[i].len, &data_size))) {
+              AddWithOverflow(dataSize, prefixLenPtr[i], &dataSize) ||
+              AddWithOverflow(dataSize, buffer[i].len, &dataSize))) {
         throw ParquetException("excess expansion in DELTA_BYTE_ARRAY");
       }
     }
-    PARQUET_THROW_NOT_OK(buffered_data_->Resize(data_size));
+    PARQUET_THROW_NOT_OK(bufferedData_->Resize(dataSize));
 
-    string_view prefix{last_value_};
-    uint8_t* data_ptr = buffered_data_->mutable_data();
-    for (int i = 0; i < max_values; ++i) {
+    string_view prefix{lastValue_};
+    uint8_t* dataPtr = bufferedData_->mutable_data();
+    for (int i = 0; i < maxValues; ++i) {
       if (ARROW_PREDICT_FALSE(
-              static_cast<size_t>(prefix_len_ptr[i]) > prefix.length())) {
+              static_cast<size_t>(prefixLenPtr[i]) > prefix.length())) {
         throw ParquetException("prefix length too large in DELTA_BYTE_ARRAY");
       }
-      memcpy(data_ptr, prefix.data(), prefix_len_ptr[i]);
-      // buffer[i] currently points to the string suffix
-      memcpy(data_ptr + prefix_len_ptr[i], buffer[i].ptr, buffer[i].len);
-      buffer[i].ptr = data_ptr;
-      buffer[i].len += prefix_len_ptr[i];
-      data_ptr += buffer[i].len;
+      memcpy(dataPtr, prefix.data(), prefixLenPtr[i]);
+      // Buffer[i] currently points to the string suffix.
+      memcpy(dataPtr + prefixLenPtr[i], buffer[i].ptr, buffer[i].len);
+      buffer[i].ptr = dataPtr;
+      buffer[i].len += prefixLenPtr[i];
+      dataPtr += buffer[i].len;
       prefix = string_view{
           reinterpret_cast<const char*>(buffer[i].ptr), buffer[i].len};
     }
-    prefix_len_offset_ += max_values;
-    this->num_values_ -= max_values;
-    num_valid_values_ -= max_values;
-    last_value_ = std::string{prefix};
+    prefixLenOffset_ += maxValues;
+    this->numValues_ -= maxValues;
+    numValidValues_ -= maxValues;
+    lastValue_ = std::string{prefix};
 
-    if (num_valid_values_ == 0) {
-      last_value_in_previous_page_ = last_value_;
+    if (numValidValues_ == 0) {
+      lastValueInPreviousPage_ = lastValue_;
     }
-    return max_values;
+    return maxValues;
   }
 
-  Status DecodeArrowDense(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
+  Status decodeArrowDense(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
       typename EncodingTraits<ByteArrayType>::Accumulator* out,
-      int* out_num_values) {
+      int* outNumValues) {
     ArrowBinaryHelper helper(out);
 
-    std::vector<ByteArray> values(num_values);
-    const int num_valid_values =
-        GetInternal(values.data(), num_values - null_count);
-    VELOX_DCHECK_EQ(num_values - null_count, num_valid_values);
+    std::vector<ByteArray> values(numValues);
+    const int numValidValues =
+        getInternal(values.data(), numValues - nullCount);
+    VELOX_DCHECK_EQ(numValues - nullCount, numValidValues);
 
-    auto values_ptr = reinterpret_cast<const ByteArray*>(values.data());
-    int value_idx = 0;
+    auto valuesPtr = reinterpret_cast<const ByteArray*>(values.data());
+    int valueIdx = 0;
 
     RETURN_NOT_OK(VisitNullBitmapInline(
-        valid_bits,
-        valid_bits_offset,
-        num_values,
-        null_count,
+        validBits,
+        validBitsOffset,
+        numValues,
+        nullCount,
         [&]() {
-          const auto& val = values_ptr[value_idx];
-          if (ARROW_PREDICT_FALSE(!helper.CanFit(val.len))) {
-            RETURN_NOT_OK(helper.PushChunk());
+          const auto& val = valuesPtr[valueIdx];
+          if (ARROW_PREDICT_FALSE(!helper.canFit(val.len))) {
+            RETURN_NOT_OK(helper.pushChunk());
           }
-          RETURN_NOT_OK(helper.Append(val.ptr, static_cast<int32_t>(val.len)));
-          ++value_idx;
+          RETURN_NOT_OK(helper.append(val.ptr, static_cast<int32_t>(val.len)));
+          ++valueIdx;
           return Status::OK();
         },
         [&]() {
-          RETURN_NOT_OK(helper.AppendNull());
-          --null_count;
+          RETURN_NOT_OK(helper.appendNull());
+          --nullCount;
           return Status::OK();
         }));
 
-    VELOX_DCHECK_EQ(null_count, 0);
-    *out_num_values = num_valid_values;
+    VELOX_DCHECK_EQ(nullCount, 0);
+    *outNumValues = numValidValues;
     return Status::OK();
   }
 
   std::shared_ptr<BitReader> decoder_;
-  DeltaBitPackDecoder<Int32Type> prefix_len_decoder_;
-  DeltaLengthByteArrayDecoder suffix_decoder_;
-  std::string last_value_;
-  // string buffer for last value in previous page
-  std::string last_value_in_previous_page_;
-  int num_valid_values_;
-  uint32_t prefix_len_offset_;
-  std::shared_ptr<ResizableBuffer> buffered_prefix_length_;
-  std::shared_ptr<ResizableBuffer> buffered_data_;
+  DeltaBitPackDecoder<Int32Type> prefixLenDecoder_;
+  DeltaLengthByteArrayDecoder suffixDecoder_;
+  std::string lastValue_;
+  // String buffer for last value in previous page.
+  std::string lastValueInPreviousPage_;
+  int numValidValues_;
+  uint32_t prefixLenOffset_;
+  std::shared_ptr<ResizableBuffer> bufferedPrefixLength_;
+  std::shared_ptr<ResizableBuffer> bufferedData_;
 };
 
-// ----------------------------------------------------------------------
-// BYTE_STREAM_SPLIT
+// ----------------------------------------------------------------------.
+// BYTE_STREAM_SPLIT.
 
 template <typename DType>
 class ByteStreamSplitDecoder : public DecoderImpl,
                                virtual public TypedDecoder<DType> {
  public:
-  using T = typename DType::c_type;
+  using T = typename DType::CType;
   explicit ByteStreamSplitDecoder(const ColumnDescriptor* descr);
 
-  int Decode(T* buffer, int max_values) override;
+  int decode(T* buffer, int maxValues) override;
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      typename EncodingTraits<DType>::Accumulator* builder) override;
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      typename EncodingTraits<DType>::Accumulator* Builder) override;
 
-  int DecodeArrow(
-      int num_values,
-      int null_count,
-      const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      typename EncodingTraits<DType>::DictAccumulator* builder) override;
+  int decodeArrow(
+      int numValues,
+      int nullCount,
+      const uint8_t* validBits,
+      int64_t validBitsOffset,
+      typename EncodingTraits<DType>::DictAccumulator* Builder) override;
 
-  void SetData(int num_values, const uint8_t* data, int len) override;
+  void setData(int numValues, const uint8_t* data, int len) override;
 
-  T* EnsureDecodeBuffer(int64_t min_values) {
-    const int64_t size = sizeof(T) * min_values;
-    if (!decode_buffer_ || decode_buffer_->size() < size) {
-      PARQUET_ASSIGN_OR_THROW(decode_buffer_, ::arrow::AllocateBuffer(size));
+  T* ensureDecodeBuffer(int64_t minValues) {
+    const int64_t size = sizeof(T) * minValues;
+    if (!decodeBuffer_ || decodeBuffer_->size() < size) {
+      decodeBuffer_ = allocateBuffer(this->memoryPool(), size);
     }
-    return reinterpret_cast<T*>(decode_buffer_->mutable_data());
+    return reinterpret_cast<T*>(decodeBuffer_->mutable_data());
   }
 
  private:
-  int num_values_in_buffer_{0};
-  std::shared_ptr<Buffer> decode_buffer_;
+  int numValuesInBuffer_{0};
+  std::shared_ptr<Buffer> decodeBuffer_;
 
   static constexpr size_t kNumStreams = sizeof(T);
 };
@@ -3705,14 +3658,14 @@ class ByteStreamSplitDecoder : public DecoderImpl,
 template <typename DType>
 ByteStreamSplitDecoder<DType>::ByteStreamSplitDecoder(
     const ColumnDescriptor* descr)
-    : DecoderImpl(descr, Encoding::BYTE_STREAM_SPLIT) {}
+    : DecoderImpl(descr, Encoding::kByteStreamSplit) {}
 
 template <typename DType>
-void ByteStreamSplitDecoder<DType>::SetData(
-    int num_values,
+void ByteStreamSplitDecoder<DType>::setData(
+    int numValues,
     const uint8_t* data,
     int len) {
-  if (num_values * static_cast<int64_t>(sizeof(T)) < len) {
+  if (numValues * static_cast<int64_t>(sizeof(T)) < len) {
     throw ParquetException(
         "Data size too large for number of values (padding in byte stream split data "
         "page?)");
@@ -3720,184 +3673,183 @@ void ByteStreamSplitDecoder<DType>::SetData(
   if (len % sizeof(T) != 0) {
     throw ParquetException(
         "ByteStreamSplit data size " + std::to_string(len) +
-        " not aligned with type " + TypeToString(DType::type_num));
+        " not aligned with type " + typeToString(DType::typeNum));
   }
-  num_values = len / sizeof(T);
-  DecoderImpl::SetData(num_values, data, len);
-  num_values_in_buffer_ = num_values_;
+  numValues = len / sizeof(T);
+  DecoderImpl::setData(numValues, data, len);
+  numValuesInBuffer_ = numValues_;
 }
 
 template <typename DType>
-int ByteStreamSplitDecoder<DType>::Decode(T* buffer, int max_values) {
-  const int values_to_decode = std::min(num_values_, max_values);
-  const int num_decoded_previously = num_values_in_buffer_ - num_values_;
-  const uint8_t* data = data_ + num_decoded_previously;
+int ByteStreamSplitDecoder<DType>::decode(T* buffer, int maxValues) {
+  const int valuesToDecode = std::min(numValues_, maxValues);
+  const int numDecodedPreviously = numValuesInBuffer_ - numValues_;
+  const uint8_t* data = data_ + numDecodedPreviously;
 
-  ByteStreamSplitDecode<T>(
-      data, values_to_decode, num_values_in_buffer_, buffer);
-  num_values_ -= values_to_decode;
-  len_ -= sizeof(T) * values_to_decode;
-  return values_to_decode;
+  byteStreamSplitDecode<T>(data, valuesToDecode, numValuesInBuffer_, buffer);
+  numValues_ -= valuesToDecode;
+  len_ -= sizeof(T) * valuesToDecode;
+  return valuesToDecode;
 }
 
 template <typename DType>
-int ByteStreamSplitDecoder<DType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<DType>::Accumulator* builder) {
-  constexpr int value_size = static_cast<int>(kNumStreams);
-  int values_decoded = num_values - null_count;
-  if (ARROW_PREDICT_FALSE(len_ < value_size * values_decoded)) {
-    ParquetException::EofException();
-  }
-
-  PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
-
-  const int num_decoded_previously = num_values_in_buffer_ - num_values_;
-  const uint8_t* data = data_ + num_decoded_previously;
+int ByteStreamSplitDecoder<DType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<DType>::Accumulator* Builder) {
+  constexpr int valueSize = static_cast<int>(kNumStreams);
+  int valuesDecoded = numValues - nullCount;
+  if (ARROW_PREDICT_FALSE(len_ < valueSize * valuesDecoded)) {
+    ParquetException::eofException();
+  }
+
+  PARQUET_THROW_NOT_OK(Builder->Reserve(numValues));
+
+  const int numDecodedPreviously = numValuesInBuffer_ - numValues_;
+  const uint8_t* data = data_ + numDecodedPreviously;
   int offset = 0;
 
 #if defined(ARROW_HAVE_SIMD_SPLIT)
-  // Use fast decoding into intermediate buffer.  This will also decode
-  // some null values, but it's fast enough that we don't care.
-  T* decode_out = EnsureDecodeBuffer(values_decoded);
-  ::arrow::util::internal::ByteStreamSplitDecode<T>(
-      data, values_decoded, num_values_in_buffer_, decode_out);
-
-  // XXX If null_count is 0, we could even append in bulk or decode directly
-  // into builder
+  // Use fast decoding into intermediate buffer.  This will also decode.
+  // Some null values, but it's fast enough that we don't care.
+  T* decodeOut = ensureDecodeBuffer(valuesDecoded);
+  ::arrow::util::internal::byte_stream_split_decode<T>(
+      data, valuesDecoded, numValuesInBuffer_, decodeOut);
+
+  // XXX If null_count is 0, we could even append in bulk or decode directly.
+  // Into builder.
   VisitNullBitmapInline(
-      valid_bits,
-      valid_bits_offset,
-      num_values,
-      null_count,
+      validBits,
+      validBitsOffset,
+      numValues,
+      nullCount,
       [&]() {
-        builder->UnsafeAppend(decode_out[offset]);
+        Builder->UnsafeAppend(decodeOut[offset]);
         ++offset;
       },
-      [&]() { builder->UnsafeAppendNull(); });
+      [&]() { Builder->UnsafeAppendNull(); });
 
 #else
   VisitNullBitmapInline(
-      valid_bits,
-      valid_bits_offset,
-      num_values,
-      null_count,
+      validBits,
+      validBitsOffset,
+      numValues,
+      nullCount,
       [&]() {
-        uint8_t gathered_byte_data[kNumStreams];
+        uint8_t gatheredByteData[kNumStreams];
         for (size_t b = 0; b < kNumStreams; ++b) {
-          const size_t byte_index = b * num_values_in_buffer_ + offset;
-          gathered_byte_data[b] = data[byte_index];
+          const size_t byteIndex = b * numValuesInBuffer_ + offset;
+          gatheredByteData[b] = data[byteIndex];
         }
-        builder->UnsafeAppend(SafeLoadAs<T>(&gathered_byte_data[0]));
+        Builder->UnsafeAppend(SafeLoadAs<T>(&gatheredByteData[0]));
         ++offset;
       },
-      [&]() { builder->UnsafeAppendNull(); });
+      [&]() { Builder->UnsafeAppendNull(); });
 #endif
 
-  num_values_ -= values_decoded;
-  len_ -= sizeof(T) * values_decoded;
-  return values_decoded;
+  numValues_ -= valuesDecoded;
+  len_ -= sizeof(T) * valuesDecoded;
+  return valuesDecoded;
 }
 
 template <typename DType>
-int ByteStreamSplitDecoder<DType>::DecodeArrow(
-    int num_values,
-    int null_count,
-    const uint8_t* valid_bits,
-    int64_t valid_bits_offset,
-    typename EncodingTraits<DType>::DictAccumulator* builder) {
+int ByteStreamSplitDecoder<DType>::decodeArrow(
+    int numValues,
+    int nullCount,
+    const uint8_t* validBits,
+    int64_t validBitsOffset,
+    typename EncodingTraits<DType>::DictAccumulator* Builder) {
   ParquetException::NYI("DecodeArrow for ByteStreamSplitDecoder");
 }
 
 } // namespace
 
-// ----------------------------------------------------------------------
-// Encoder and decoder factory functions
+// ----------------------------------------------------------------------.
+// Encoder and decoder factory functions.
 
-std::unique_ptr<Encoder> MakeEncoder(
-    Type::type type_num,
+std::unique_ptr<Encoder> makeEncoder(
+    Type::type typeNum,
     Encoding::type encoding,
-    bool use_dictionary,
+    bool useDictionary,
     const ColumnDescriptor* descr,
     MemoryPool* pool) {
-  if (use_dictionary) {
-    switch (type_num) {
-      case Type::INT32:
+  if (useDictionary) {
+    switch (typeNum) {
+      case Type::kInt32:
         return std::make_unique<DictEncoderImpl<Int32Type>>(descr, pool);
-      case Type::INT64:
+      case Type::kInt64:
         return std::make_unique<DictEncoderImpl<Int64Type>>(descr, pool);
-      case Type::INT96:
+      case Type::kInt96:
         return std::make_unique<DictEncoderImpl<Int96Type>>(descr, pool);
-      case Type::FLOAT:
+      case Type::kFloat:
         return std::make_unique<DictEncoderImpl<FloatType>>(descr, pool);
-      case Type::DOUBLE:
+      case Type::kDouble:
         return std::make_unique<DictEncoderImpl<DoubleType>>(descr, pool);
-      case Type::BYTE_ARRAY:
+      case Type::kByteArray:
         return std::make_unique<DictEncoderImpl<ByteArrayType>>(descr, pool);
-      case Type::FIXED_LEN_BYTE_ARRAY:
+      case Type::kFixedLenByteArray:
         return std::make_unique<DictEncoderImpl<FLBAType>>(descr, pool);
       default:
         VELOX_DCHECK(false, "Encoder not implemented");
         break;
     }
-  } else if (encoding == Encoding::PLAIN) {
-    switch (type_num) {
-      case Type::BOOLEAN:
+  } else if (encoding == Encoding::kPlain) {
+    switch (typeNum) {
+      case Type::kBoolean:
         return std::make_unique<PlainEncoder<BooleanType>>(descr, pool);
-      case Type::INT32:
+      case Type::kInt32:
         return std::make_unique<PlainEncoder<Int32Type>>(descr, pool);
-      case Type::INT64:
+      case Type::kInt64:
         return std::make_unique<PlainEncoder<Int64Type>>(descr, pool);
-      case Type::INT96:
+      case Type::kInt96:
         return std::make_unique<PlainEncoder<Int96Type>>(descr, pool);
-      case Type::FLOAT:
+      case Type::kFloat:
         return std::make_unique<PlainEncoder<FloatType>>(descr, pool);
-      case Type::DOUBLE:
+      case Type::kDouble:
         return std::make_unique<PlainEncoder<DoubleType>>(descr, pool);
-      case Type::BYTE_ARRAY:
+      case Type::kByteArray:
         return std::make_unique<PlainEncoder<ByteArrayType>>(descr, pool);
-      case Type::FIXED_LEN_BYTE_ARRAY:
+      case Type::kFixedLenByteArray:
         return std::make_unique<PlainEncoder<FLBAType>>(descr, pool);
       default:
         VELOX_DCHECK(false, "Encoder not implemented");
         break;
     }
-  } else if (encoding == Encoding::BYTE_STREAM_SPLIT) {
-    switch (type_num) {
-      case Type::FLOAT:
+  } else if (encoding == Encoding::kByteStreamSplit) {
+    switch (typeNum) {
+      case Type::kFloat:
         return std::make_unique<ByteStreamSplitEncoder<FloatType>>(descr, pool);
-      case Type::DOUBLE:
+      case Type::kDouble:
         return std::make_unique<ByteStreamSplitEncoder<DoubleType>>(
             descr, pool);
       default:
         throw ParquetException(
             "BYTE_STREAM_SPLIT only supports FLOAT and DOUBLE");
     }
-  } else if (encoding == Encoding::DELTA_BINARY_PACKED) {
-    switch (type_num) {
-      case Type::INT32:
+  } else if (encoding == Encoding::kDeltaBinaryPacked) {
+    switch (typeNum) {
+      case Type::kInt32:
         return std::make_unique<DeltaBitPackEncoder<Int32Type>>(descr, pool);
-      case Type::INT64:
+      case Type::kInt64:
         return std::make_unique<DeltaBitPackEncoder<Int64Type>>(descr, pool);
       default:
         throw ParquetException(
             "DELTA_BINARY_PACKED encoder only supports INT32 and INT64");
     }
-  } else if (encoding == Encoding::DELTA_LENGTH_BYTE_ARRAY) {
-    switch (type_num) {
-      case Type::BYTE_ARRAY:
+  } else if (encoding == Encoding::kDeltaLengthByteArray) {
+    switch (typeNum) {
+      case Type::kByteArray:
         return std::make_unique<DeltaLengthByteArrayEncoder<ByteArrayType>>(
             descr, pool);
       default:
         throw ParquetException(
             "DELTA_LENGTH_BYTE_ARRAY only supports BYTE_ARRAY");
     }
-  } else if (encoding == Encoding::RLE) {
-    switch (type_num) {
-      case Type::BOOLEAN:
+  } else if (encoding == Encoding::kRle) {
+    switch (typeNum) {
+      case Type::kBoolean:
         return std::make_unique<RleBooleanEncoder>(descr, pool);
       default:
         throw ParquetException("RLE only supports BOOLEAN");
@@ -3909,64 +3861,64 @@ std::unique_ptr<Encoder> MakeEncoder(
   return nullptr;
 }
 
-std::unique_ptr<Decoder> MakeDecoder(
-    Type::type type_num,
+std::unique_ptr<Decoder> makeDecoder(
+    Type::type typeNum,
     Encoding::type encoding,
     const ColumnDescriptor* descr,
     ::arrow::MemoryPool* pool) {
-  if (encoding == Encoding::PLAIN) {
-    switch (type_num) {
-      case Type::BOOLEAN:
+  if (encoding == Encoding::kPlain) {
+    switch (typeNum) {
+      case Type::kBoolean:
         return std::make_unique<PlainBooleanDecoder>(descr);
-      case Type::INT32:
+      case Type::kInt32:
         return std::make_unique<PlainDecoder<Int32Type>>(descr);
-      case Type::INT64:
+      case Type::kInt64:
         return std::make_unique<PlainDecoder<Int64Type>>(descr);
-      case Type::INT96:
+      case Type::kInt96:
         return std::make_unique<PlainDecoder<Int96Type>>(descr);
-      case Type::FLOAT:
+      case Type::kFloat:
         return std::make_unique<PlainDecoder<FloatType>>(descr);
-      case Type::DOUBLE:
+      case Type::kDouble:
         return std::make_unique<PlainDecoder<DoubleType>>(descr);
-      case Type::BYTE_ARRAY:
+      case Type::kByteArray:
         return std::make_unique<PlainByteArrayDecoder>(descr);
-      case Type::FIXED_LEN_BYTE_ARRAY:
+      case Type::kFixedLenByteArray:
         return std::make_unique<PlainFLBADecoder>(descr);
       default:
         break;
     }
-  } else if (encoding == Encoding::BYTE_STREAM_SPLIT) {
-    switch (type_num) {
-      case Type::FLOAT:
+  } else if (encoding == Encoding::kByteStreamSplit) {
+    switch (typeNum) {
+      case Type::kFloat:
         return std::make_unique<ByteStreamSplitDecoder<FloatType>>(descr);
-      case Type::DOUBLE:
+      case Type::kDouble:
         return std::make_unique<ByteStreamSplitDecoder<DoubleType>>(descr);
       default:
         throw ParquetException(
             "BYTE_STREAM_SPLIT only supports FLOAT and DOUBLE");
     }
-  } else if (encoding == Encoding::DELTA_BINARY_PACKED) {
-    switch (type_num) {
-      case Type::INT32:
+  } else if (encoding == Encoding::kDeltaBinaryPacked) {
+    switch (typeNum) {
+      case Type::kInt32:
         return std::make_unique<DeltaBitPackDecoder<Int32Type>>(descr, pool);
-      case Type::INT64:
+      case Type::kInt64:
         return std::make_unique<DeltaBitPackDecoder<Int64Type>>(descr, pool);
       default:
         throw ParquetException(
             "DELTA_BINARY_PACKED decoder only supports INT32 and INT64");
     }
-  } else if (encoding == Encoding::DELTA_BYTE_ARRAY) {
-    if (type_num == Type::BYTE_ARRAY) {
+  } else if (encoding == Encoding::kDeltaByteArray) {
+    if (typeNum == Type::kByteArray) {
       return std::make_unique<DeltaByteArrayDecoder>(descr, pool);
     }
     throw ParquetException("DELTA_BYTE_ARRAY only supports BYTE_ARRAY");
-  } else if (encoding == Encoding::DELTA_LENGTH_BYTE_ARRAY) {
-    if (type_num == Type::BYTE_ARRAY) {
+  } else if (encoding == Encoding::kDeltaLengthByteArray) {
+    if (typeNum == Type::kByteArray) {
       return std::make_unique<DeltaLengthByteArrayDecoder>(descr, pool);
     }
     throw ParquetException("DELTA_LENGTH_BYTE_ARRAY only supports BYTE_ARRAY");
-  } else if (encoding == Encoding::RLE) {
-    if (type_num == Type::BOOLEAN) {
+  } else if (encoding == Encoding::kRle) {
+    if (typeNum == Type::kBoolean) {
       return std::make_unique<RleBooleanDecoder>(descr);
     }
     throw ParquetException("RLE encoding only supports BOOLEAN");
@@ -3978,27 +3930,27 @@ std::unique_ptr<Decoder> MakeDecoder(
 }
 
 namespace detail {
-std::unique_ptr<Decoder> MakeDictDecoder(
-    Type::type type_num,
+std::unique_ptr<Decoder> makeDictDecoder(
+    Type::type typeNum,
     const ColumnDescriptor* descr,
     MemoryPool* pool) {
-  switch (type_num) {
-    case Type::BOOLEAN:
+  switch (typeNum) {
+    case Type::kBoolean:
       ParquetException::NYI(
           "Dictionary encoding not implemented for boolean type");
-    case Type::INT32:
+    case Type::kInt32:
       return std::make_unique<DictDecoderImpl<Int32Type>>(descr, pool);
-    case Type::INT64:
+    case Type::kInt64:
       return std::make_unique<DictDecoderImpl<Int64Type>>(descr, pool);
-    case Type::INT96:
+    case Type::kInt96:
       return std::make_unique<DictDecoderImpl<Int96Type>>(descr, pool);
-    case Type::FLOAT:
+    case Type::kFloat:
       return std::make_unique<DictDecoderImpl<FloatType>>(descr, pool);
-    case Type::DOUBLE:
+    case Type::kDouble:
       return std::make_unique<DictDecoderImpl<DoubleType>>(descr, pool);
-    case Type::BYTE_ARRAY:
+    case Type::kByteArray:
       return std::make_unique<DictByteArrayDecoderImpl>(descr, pool);
-    case Type::FIXED_LEN_BYTE_ARRAY:
+    case Type::kFixedLenByteArray:
       return std::make_unique<DictDecoderImpl<FLBAType>>(descr, pool);
     default:
       break;
diff --git a/velox/dwio/parquet/writer/arrow/tests/FileDeserializeTest.cpp b/velox/dwio/parquet/writer/arrow/tests/FileDeserializeTest.cpp
index 9c144739158..eb6279f55ce 100644
--- a/velox/dwio/parquet/writer/arrow/tests/FileDeserializeTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/FileDeserializeTest.cpp
@@ -19,20 +19,22 @@
 #include <gmock/gmock.h>
 
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/io/IoStatistics.h"
+#include "velox/common/testutil/TempFilePath.h"
 #include "velox/dwio/parquet/reader/ParquetReader.h"
 #include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/FileWriter.h"
 #include "velox/dwio/parquet/writer/arrow/ThriftInternal.h"
 #include "velox/dwio/parquet/writer/arrow/tests/TestUtil.h"
-#include "velox/exec/tests/utils/TempFilePath.h"
 
 #include "arrow/testing/gtest_util.h"
 #include "arrow/util/crc32.h"
 
 namespace facebook::velox::parquet::arrow {
+using namespace facebook::velox::common::testutil;
 namespace {
 void writeToFile(
-    std::shared_ptr<exec::test::TempFilePath> filePath,
+    std::shared_ptr<TempFilePath> filePath,
     std::shared_ptr<arrow::Buffer> buffer) {
   auto localWriteFile =
       std::make_unique<LocalWriteFile>(filePath->getPath(), false, false);
@@ -45,20 +47,20 @@ void writeToFile(
 
 using ::arrow::io::BufferReader;
 
-// Adds page statistics occupying a certain amount of bytes (for testing very
+// Adds page statistics occupying a certain amount of bytes (for testing very.
 // large page headers)
 template <typename H>
 static inline void
-AddDummyStats(int stat_size, H& header, bool fill_all_stats = false) {
-  std::vector<uint8_t> stat_bytes(stat_size);
-  // Some non-zero value
-  std::fill(stat_bytes.begin(), stat_bytes.end(), 1);
+addDummyStats(int statSize, H& header, bool fillAllStats = false) {
+  std::vector<uint8_t> statBytes(statSize);
+  // Some non-zero value.
+  std::fill(statBytes.begin(), statBytes.end(), 1);
   header.statistics.__set_max(
-      std::string(reinterpret_cast<const char*>(stat_bytes.data()), stat_size));
+      std::string(reinterpret_cast<const char*>(statBytes.data()), statSize));
 
-  if (fill_all_stats) {
-    header.statistics.__set_min(std::string(
-        reinterpret_cast<const char*>(stat_bytes.data()), stat_size));
+  if (fillAllStats) {
+    header.statistics.__set_min(
+        std::string(reinterpret_cast<const char*>(statBytes.data()), statSize));
     header.statistics.__set_null_count(42);
     header.statistics.__set_distinct_count(1);
   }
@@ -67,7 +69,7 @@ AddDummyStats(int stat_size, H& header, bool fill_all_stats = false) {
 }
 
 template <typename H>
-static inline void CheckStatistics(
+static inline void checkStatistics(
     const H& expected,
     const EncodedStatistics& actual) {
   if (expected.statistics.__isset.max) {
@@ -77,434 +79,417 @@ static inline void CheckStatistics(
     ASSERT_EQ(expected.statistics.min, actual.min());
   }
   if (expected.statistics.__isset.null_count) {
-    ASSERT_EQ(expected.statistics.null_count, actual.null_count);
+    ASSERT_EQ(expected.statistics.null_count, actual.nullCount);
   }
   if (expected.statistics.__isset.distinct_count) {
-    ASSERT_EQ(expected.statistics.distinct_count, actual.distinct_count);
+    ASSERT_EQ(expected.statistics.distinct_count, actual.distinctCount);
   }
 }
 
-static std::vector<Compression::type> GetSupportedCodecTypes() {
-  std::vector<Compression::type> codec_types;
+static std::vector<Compression::type> getSupportedCodecTypes() {
+  std::vector<Compression::type> codecTypes;
 
-  codec_types.push_back(Compression::SNAPPY);
+  codecTypes.push_back(Compression::SNAPPY);
 
 #ifdef ARROW_WITH_BROTLI
-  codec_types.push_back(Compression::BROTLI);
+  codecTypes.push_back(Compression::BROTLI);
 #endif
 
-  codec_types.push_back(Compression::GZIP);
+  codecTypes.push_back(Compression::GZIP);
 
-  codec_types.push_back(Compression::LZ4);
-  codec_types.push_back(Compression::LZ4_HADOOP);
+  codecTypes.push_back(Compression::LZ4);
+  codecTypes.push_back(Compression::LZ4_HADOOP);
 
-  codec_types.push_back(Compression::ZSTD);
-  return codec_types;
+  codecTypes.push_back(Compression::ZSTD);
+  return codecTypes;
 }
 
 class TestPageSerde : public ::testing::Test {
  public:
   void SetUp() {
-    data_page_header_.encoding =
+    dataPageHeader_.encoding =
         facebook::velox::parquet::thrift::Encoding::PLAIN;
-    data_page_header_.definition_level_encoding =
+    dataPageHeader_.definition_level_encoding =
         facebook::velox::parquet::thrift::Encoding::RLE;
-    data_page_header_.repetition_level_encoding =
+    dataPageHeader_.repetition_level_encoding =
         facebook::velox::parquet::thrift::Encoding::RLE;
 
-    ResetStream();
+    resetStream();
   }
 
-  void InitSerializedPageReader(
-      int64_t num_rows,
-      Compression::type codec = Compression::UNCOMPRESSED,
+  void initSerializedPageReader(
+      int64_t numRows,
+      Compression::type Codec = Compression::UNCOMPRESSED,
       const ReaderProperties& properties = ReaderProperties()) {
-    EndStream();
+    endStream();
 
-    auto stream = std::make_shared<::arrow::io::BufferReader>(out_buffer_);
-    page_reader_ = PageReader::Open(stream, num_rows, codec, properties);
+    auto stream = std::make_shared<::arrow::io::BufferReader>(outBuffer_);
+    pageReader_ = PageReader::open(stream, numRows, Codec, properties);
   }
 
-  void WriteDataPageHeader(
-      int max_serialized_len = 1024,
-      int32_t uncompressed_size = 0,
-      int32_t compressed_size = 0,
+  void writeDataPageHeader(
+      int maxSerializedLen = 1024,
+      int32_t uncompressedSize = 0,
+      int32_t compressedSize = 0,
       std::optional<int32_t> checksum = std::nullopt) {
-    // Simplifying writing serialized data page headers which may or may not
-    // have meaningful data associated with them
-
-    // Serialize the Page header
-    page_header_.__set_data_page_header(data_page_header_);
-    page_header_.uncompressed_page_size = uncompressed_size;
-    page_header_.compressed_page_size = compressed_size;
-    page_header_.type = facebook::velox::parquet::thrift::PageType::DATA_PAGE;
+    // Simplifying writing serialized data page headers which may or may not.
+    // Have meaningful data associated with them.
+
+    // Serialize the Page header.
+    pageHeader_.__set_data_page_header(dataPageHeader_);
+    pageHeader_.uncompressed_page_size = uncompressedSize;
+    pageHeader_.compressed_page_size = compressedSize;
+    pageHeader_.type = facebook::velox::parquet::thrift::PageType::DATA_PAGE;
     if (checksum.has_value()) {
-      page_header_.__set_crc(checksum.value());
+      pageHeader_.__set_crc(checksum.value());
     }
 
     ThriftSerializer serializer;
-    ASSERT_NO_THROW(serializer.Serialize(&page_header_, out_stream_.get()));
+    ASSERT_NO_THROW(serializer.serialize(&pageHeader_, outStream_.get()));
   }
 
-  void WriteDataPageHeaderV2(
-      int max_serialized_len = 1024,
-      int32_t uncompressed_size = 0,
-      int32_t compressed_size = 0,
+  void writeDataPageHeaderV2(
+      int maxSerializedLen = 1024,
+      int32_t uncompressedSize = 0,
+      int32_t compressedSize = 0,
       std::optional<int32_t> checksum = std::nullopt) {
-    // Simplifying writing serialized data page V2 headers which may or may not
-    // have meaningful data associated with them
-
-    // Serialize the Page header
-    page_header_.__set_data_page_header_v2(data_page_header_v2_);
-    page_header_.uncompressed_page_size = uncompressed_size;
-    page_header_.compressed_page_size = compressed_size;
-    page_header_.type =
-        facebook::velox::parquet::thrift::PageType::DATA_PAGE_V2;
+    // Simplifying writing serialized data page V2 headers which may or may not.
+    // Have meaningful data associated with them.
+
+    // Serialize the Page header.
+    pageHeader_.__set_data_page_header_v2(dataPageHeaderV2_);
+    pageHeader_.uncompressed_page_size = uncompressedSize;
+    pageHeader_.compressed_page_size = compressedSize;
+    pageHeader_.type = facebook::velox::parquet::thrift::PageType::DATA_PAGE_V2;
     if (checksum.has_value()) {
-      page_header_.__set_crc(checksum.value());
+      pageHeader_.__set_crc(checksum.value());
     }
 
     ThriftSerializer serializer;
-    ASSERT_NO_THROW(serializer.Serialize(&page_header_, out_stream_.get()));
+    ASSERT_NO_THROW(serializer.serialize(&pageHeader_, outStream_.get()));
   }
 
-  void WriteDictionaryPageHeader(
-      int32_t uncompressed_size = 0,
-      int32_t compressed_size = 0,
+  void writeDictionaryPageHeader(
+      int32_t uncompressedSize = 0,
+      int32_t compressedSize = 0,
       std::optional<int32_t> checksum = std::nullopt) {
-    page_header_.__set_dictionary_page_header(dictionary_page_header_);
-    page_header_.uncompressed_page_size = uncompressed_size;
-    page_header_.compressed_page_size = compressed_size;
-    page_header_.type =
+    pageHeader_.__set_dictionary_page_header(dictionaryPageHeader_);
+    pageHeader_.uncompressed_page_size = uncompressedSize;
+    pageHeader_.compressed_page_size = compressedSize;
+    pageHeader_.type =
         facebook::velox::parquet::thrift::PageType::DICTIONARY_PAGE;
     if (checksum.has_value()) {
-      page_header_.__set_crc(checksum.value());
+      pageHeader_.__set_crc(checksum.value());
     }
 
     ThriftSerializer serializer;
-    ASSERT_NO_THROW(serializer.Serialize(&page_header_, out_stream_.get()));
+    ASSERT_NO_THROW(serializer.serialize(&pageHeader_, outStream_.get()));
   }
 
-  void WriteIndexPageHeader(
-      int32_t uncompressed_size = 0,
-      int32_t compressed_size = 0) {
-    page_header_.__set_index_page_header(index_page_header_);
-    page_header_.uncompressed_page_size = uncompressed_size;
-    page_header_.compressed_page_size = compressed_size;
-    page_header_.type = facebook::velox::parquet::thrift::PageType::INDEX_PAGE;
+  void writeIndexPageHeader(
+      int32_t uncompressedSize = 0,
+      int32_t compressedSize = 0) {
+    pageHeader_.__set_index_page_header(indexPageHeader_);
+    pageHeader_.uncompressed_page_size = uncompressedSize;
+    pageHeader_.compressed_page_size = compressedSize;
+    pageHeader_.type = facebook::velox::parquet::thrift::PageType::INDEX_PAGE;
 
     ThriftSerializer serializer;
-    ASSERT_NO_THROW(serializer.Serialize(&page_header_, out_stream_.get()));
+    ASSERT_NO_THROW(serializer.serialize(&pageHeader_, outStream_.get()));
   }
 
-  void ResetStream() {
-    out_stream_ = CreateOutputStream();
+  void resetStream() {
+    outStream_ = createOutputStream();
   }
 
-  void EndStream() {
-    PARQUET_ASSIGN_OR_THROW(out_buffer_, out_stream_->Finish());
+  void endStream() {
+    PARQUET_ASSIGN_OR_THROW(outBuffer_, outStream_->Finish());
   }
 
-  void TestPageSerdeCrc(
-      bool write_checksum,
-      bool write_page_corrupt,
-      bool verification_checksum,
-      bool has_dictionary = false,
-      bool write_data_page_v2 = false);
+  void testPageSerdeCrc(
+      bool writeChecksum,
+      bool writePageCorrupt,
+      bool verificationChecksum,
+      bool hasDictionary = false,
+      bool writeDataPageV2 = false);
 
-  void TestPageCompressionRoundTrip(const std::vector<int>& page_sizes);
+  void testPageCompressionRoundTrip(const std::vector<int>& pageSizes);
 
  protected:
-  std::shared_ptr<::arrow::io::BufferOutputStream> out_stream_;
-  std::shared_ptr<Buffer> out_buffer_;
-
-  std::unique_ptr<PageReader> page_reader_;
-  facebook::velox::parquet::thrift::PageHeader page_header_;
-  facebook::velox::parquet::thrift::DataPageHeader data_page_header_;
-  facebook::velox::parquet::thrift::DataPageHeaderV2 data_page_header_v2_;
-  facebook::velox::parquet::thrift::IndexPageHeader index_page_header_;
-  facebook::velox::parquet::thrift::DictionaryPageHeader
-      dictionary_page_header_;
+  std::shared_ptr<::arrow::io::BufferOutputStream> outStream_;
+  std::shared_ptr<Buffer> outBuffer_;
+
+  std::unique_ptr<PageReader> pageReader_;
+  facebook::velox::parquet::thrift::PageHeader pageHeader_;
+  facebook::velox::parquet::thrift::DataPageHeader dataPageHeader_;
+  facebook::velox::parquet::thrift::DataPageHeaderV2 dataPageHeaderV2_;
+  facebook::velox::parquet::thrift::IndexPageHeader indexPageHeader_;
+  facebook::velox::parquet::thrift::DictionaryPageHeader dictionaryPageHeader_;
 };
 
-void TestPageSerde::TestPageSerdeCrc(
-    bool write_checksum,
-    bool write_page_corrupt,
-    bool verification_checksum,
-    bool has_dictionary,
-    bool write_data_page_v2) {
-  auto codec_types = GetSupportedCodecTypes();
-  codec_types.push_back(Compression::UNCOMPRESSED);
-  const int32_t num_rows = 32; // dummy value
-  if (write_data_page_v2) {
-    data_page_header_v2_.num_values = num_rows;
+void TestPageSerde::testPageSerdeCrc(
+    bool writeChecksum,
+    bool writePageCorrupt,
+    bool verificationChecksum,
+    bool hasDictionary,
+    bool writeDataPageV2) {
+  auto codecTypes = getSupportedCodecTypes();
+  codecTypes.push_back(Compression::UNCOMPRESSED);
+  const int32_t numRows = 32; // dummy value
+  if (writeDataPageV2) {
+    dataPageHeaderV2_.num_values = numRows;
   } else {
-    data_page_header_.num_values = num_rows;
+    dataPageHeader_.num_values = numRows;
   }
-  dictionary_page_header_.num_values = num_rows;
+  dictionaryPageHeader_.num_values = numRows;
 
-  const int num_pages = 10;
+  const int numPages = 10;
 
-  std::vector<std::vector<uint8_t>> faux_data;
-  faux_data.resize(num_pages);
-  for (int i = 0; i < num_pages; ++i) {
-    // The pages keep getting larger
-    int page_size = (i + 1) * 64;
-    test::random_bytes(page_size, 0, &faux_data[i]);
+  std::vector<std::vector<uint8_t>> fauxData;
+  fauxData.resize(numPages);
+  for (int i = 0; i < numPages; ++i) {
+    // The pages keep getting larger.
+    int pageSize = (i + 1) * 64;
+    test::randomBytes(pageSize, 0, &fauxData[i]);
   }
-  for (auto codec_type : codec_types) {
-    auto codec = GetCodec(codec_type);
+  for (auto codecType : codecTypes) {
+    auto Codec = getCodec(codecType);
 
     std::vector<uint8_t> buffer;
-    for (int i = 0; i < num_pages; ++i) {
-      const uint8_t* data = faux_data[i].data();
-      int data_size = static_cast<int>(faux_data[i].size());
-      int64_t actual_size;
-      if (codec == nullptr) {
-        buffer = faux_data[i];
-        actual_size = data_size;
+    for (int i = 0; i < numPages; ++i) {
+      const uint8_t* data = fauxData[i].data();
+      int dataSize = static_cast<int>(fauxData[i].size());
+      int64_t actualSize;
+      if (Codec == nullptr) {
+        buffer = fauxData[i];
+        actualSize = dataSize;
       } else {
-        int64_t max_compressed_size = codec->MaxCompressedLen(data_size, data);
-        buffer.resize(max_compressed_size);
+        int64_t maxCompressedSize = Codec->maxCompressedLen(dataSize, data);
+        buffer.resize(maxCompressedSize);
 
         ASSERT_OK_AND_ASSIGN(
-            actual_size,
-            codec->Compress(data_size, data, max_compressed_size, &buffer[0]));
+            actualSize,
+            Codec->compress(dataSize, data, maxCompressedSize, &buffer[0]));
       }
-      std::optional<uint32_t> checksum_opt;
-      if (write_checksum) {
+      std::optional<uint32_t> checksumOpt;
+      if (writeChecksum) {
         uint32_t checksum =
-            ::arrow::internal::crc32(/* prev */ 0, buffer.data(), actual_size);
-        if (write_page_corrupt) {
+            ::arrow::internal::crc32(/* prev */ 0, buffer.data(), actualSize);
+        if (writePageCorrupt) {
           checksum += 1; // write a bad checksum
         }
-        checksum_opt = checksum;
+        checksumOpt = checksum;
       }
-      if (has_dictionary && i == 0) {
-        ASSERT_NO_FATAL_FAILURE(WriteDictionaryPageHeader(
-            data_size, static_cast<int32_t>(actual_size), checksum_opt));
+      if (hasDictionary && i == 0) {
+        ASSERT_NO_FATAL_FAILURE(writeDictionaryPageHeader(
+            dataSize, static_cast<int32_t>(actualSize), checksumOpt));
       } else {
-        if (write_data_page_v2) {
-          ASSERT_NO_FATAL_FAILURE(WriteDataPageHeaderV2(
-              1024,
-              data_size,
-              static_cast<int32_t>(actual_size),
-              checksum_opt));
+        if (writeDataPageV2) {
+          ASSERT_NO_FATAL_FAILURE(writeDataPageHeaderV2(
+              1024, dataSize, static_cast<int32_t>(actualSize), checksumOpt));
         } else {
-          ASSERT_NO_FATAL_FAILURE(WriteDataPageHeader(
-              1024,
-              data_size,
-              static_cast<int32_t>(actual_size),
-              checksum_opt));
+          ASSERT_NO_FATAL_FAILURE(writeDataPageHeader(
+              1024, dataSize, static_cast<int32_t>(actualSize), checksumOpt));
         }
       }
-      ASSERT_OK(out_stream_->Write(buffer.data(), actual_size));
+      ASSERT_OK(outStream_->Write(buffer.data(), actualSize));
     }
-    ReaderProperties readerProperties;
-    readerProperties.set_page_checksum_verification(verification_checksum);
-    InitSerializedPageReader(
-        num_rows * num_pages, codec_type, readerProperties);
+    ReaderProperties ReaderProperties;
+    ReaderProperties.setPageChecksumVerification(verificationChecksum);
+    initSerializedPageReader(numRows * numPages, codecType, ReaderProperties);
 
-    for (int i = 0; i < num_pages; ++i) {
-      if (write_checksum && write_page_corrupt && verification_checksum) {
+    for (int i = 0; i < numPages; ++i) {
+      if (writeChecksum && writePageCorrupt && verificationChecksum) {
         EXPECT_THROW_THAT(
-            [&]() { page_reader_->NextPage(); },
+            [&]() { pageReader_->nextPage(); },
             ParquetException,
             ::testing::Property(
                 &ParquetException::what,
                 ::testing::HasSubstr("CRC checksum verification failed")));
       } else {
-        const auto page = page_reader_->NextPage();
-        const int data_size = static_cast<int>(faux_data[i].size());
-        if (has_dictionary && i == 0) {
-          ASSERT_EQ(PageType::DICTIONARY_PAGE, page->type());
-          const auto dict_page = static_cast<const DictionaryPage*>(page.get());
-          ASSERT_EQ(data_size, dict_page->size());
-          ASSERT_EQ(
-              0, memcmp(faux_data[i].data(), dict_page->data(), data_size));
-        } else if (write_data_page_v2) {
-          ASSERT_EQ(PageType::DATA_PAGE_V2, page->type());
-          const auto data_page = static_cast<const DataPageV2*>(page.get());
-          ASSERT_EQ(data_size, data_page->size());
-          ASSERT_EQ(
-              0, memcmp(faux_data[i].data(), data_page->data(), data_size));
+        const auto page = pageReader_->nextPage();
+        const int dataSize = static_cast<int>(fauxData[i].size());
+        if (hasDictionary && i == 0) {
+          ASSERT_EQ(PageType::kDictionaryPage, page->type());
+          const auto dictPage = static_cast<const DictionaryPage*>(page.get());
+          ASSERT_EQ(dataSize, dictPage->size());
+          ASSERT_EQ(0, memcmp(fauxData[i].data(), dictPage->data(), dataSize));
+        } else if (writeDataPageV2) {
+          ASSERT_EQ(PageType::kDataPageV2, page->type());
+          const auto dataPage = static_cast<const DataPageV2*>(page.get());
+          ASSERT_EQ(dataSize, dataPage->size());
+          ASSERT_EQ(0, memcmp(fauxData[i].data(), dataPage->data(), dataSize));
         } else {
-          ASSERT_EQ(PageType::DATA_PAGE, page->type());
-          const auto data_page = static_cast<const DataPageV1*>(page.get());
-          ASSERT_EQ(data_size, data_page->size());
-          ASSERT_EQ(
-              0, memcmp(faux_data[i].data(), data_page->data(), data_size));
+          ASSERT_EQ(PageType::kDataPage, page->type());
+          const auto dataPage = static_cast<const DataPageV1*>(page.get());
+          ASSERT_EQ(dataSize, dataPage->size());
+          ASSERT_EQ(0, memcmp(fauxData[i].data(), dataPage->data(), dataSize));
         }
       }
     }
 
-    ResetStream();
+    resetStream();
   }
 }
 
-void CheckDataPageHeader(
+void checkDataPageHeader(
     const facebook::velox::parquet::thrift::DataPageHeader& expected,
     const Page* page) {
-  ASSERT_EQ(PageType::DATA_PAGE, page->type());
+  ASSERT_EQ(PageType::kDataPage, page->type());
 
-  const DataPageV1* data_page = static_cast<const DataPageV1*>(page);
-  ASSERT_EQ(expected.num_values, data_page->num_values());
-  ASSERT_EQ(expected.encoding, data_page->encoding());
+  const DataPageV1* dataPage = static_cast<const DataPageV1*>(page);
+  ASSERT_EQ(expected.num_values, dataPage->numValues());
+  ASSERT_EQ(expected.encoding, dataPage->encoding());
   ASSERT_EQ(
-      expected.definition_level_encoding,
-      data_page->definition_level_encoding());
+      expected.definition_level_encoding, dataPage->definitionLevelEncoding());
   ASSERT_EQ(
-      expected.repetition_level_encoding,
-      data_page->repetition_level_encoding());
-  CheckStatistics(expected, data_page->statistics());
+      expected.repetition_level_encoding, dataPage->repetitionLevelEncoding());
+  checkStatistics(expected, dataPage->statistics());
 }
 
 // Overload for DataPageV2 tests.
-void CheckDataPageHeader(
+void checkDataPageHeader(
     const facebook::velox::parquet::thrift::DataPageHeaderV2& expected,
     const Page* page) {
-  ASSERT_EQ(PageType::DATA_PAGE_V2, page->type());
+  ASSERT_EQ(PageType::kDataPageV2, page->type());
 
-  const DataPageV2* data_page = static_cast<const DataPageV2*>(page);
-  ASSERT_EQ(expected.num_values, data_page->num_values());
-  ASSERT_EQ(expected.num_nulls, data_page->num_nulls());
-  ASSERT_EQ(expected.num_rows, data_page->num_rows());
-  ASSERT_EQ(expected.encoding, data_page->encoding());
+  const DataPageV2* dataPage = static_cast<const DataPageV2*>(page);
+  ASSERT_EQ(expected.num_values, dataPage->numValues());
+  ASSERT_EQ(expected.num_nulls, dataPage->numNulls());
+  ASSERT_EQ(expected.num_rows, dataPage->numRows());
+  ASSERT_EQ(expected.encoding, dataPage->encoding());
   ASSERT_EQ(
       expected.definition_levels_byte_length,
-      data_page->definition_levels_byte_length());
+      dataPage->definitionLevelsByteLength());
   ASSERT_EQ(
       expected.repetition_levels_byte_length,
-      data_page->repetition_levels_byte_length());
-  ASSERT_EQ(expected.is_compressed, data_page->is_compressed());
-  CheckStatistics(expected, data_page->statistics());
+      dataPage->repetitionLevelsByteLength());
+  ASSERT_EQ(expected.is_compressed, dataPage->isCompressed());
+  checkStatistics(expected, dataPage->statistics());
 }
 
 TEST_F(TestPageSerde, DataPageV1) {
-  int stats_size = 512;
-  const int32_t num_rows = 4444;
-  AddDummyStats(stats_size, data_page_header_, /* fill_all_stats = */ true);
-  data_page_header_.num_values = num_rows;
-
-  ASSERT_NO_FATAL_FAILURE(WriteDataPageHeader());
-  InitSerializedPageReader(num_rows);
-  std::shared_ptr<Page> current_page = page_reader_->NextPage();
+  int statsSize = 512;
+  const int32_t numRows = 4444;
+  addDummyStats(statsSize, dataPageHeader_, /*fill_all_stats=*/true);
+  dataPageHeader_.num_values = numRows;
+
+  ASSERT_NO_FATAL_FAILURE(writeDataPageHeader());
+  initSerializedPageReader(numRows);
+  std::shared_ptr<Page> currentPage = pageReader_->nextPage();
   ASSERT_NO_FATAL_FAILURE(
-      CheckDataPageHeader(data_page_header_, current_page.get()));
+      checkDataPageHeader(dataPageHeader_, currentPage.get()));
 }
 
-// Templated test class to test page filtering for both
-// facebook::velox::parquet::thrift::DataPageHeader and
-// facebook::velox::parquet::thrift::DataPageHeaderV2.
+// Templated test class to test page filtering for both.
+// Facebook::velox::parquet::thrift::DataPageHeader and.
+// Facebook::velox::parquet::thrift::DataPageHeaderV2.
 template <typename T>
 class PageFilterTest : public TestPageSerde {
  public:
   const int kNumPages = 10;
-  void WriteStream();
-  void WritePageWithoutStats();
-  void CheckNumRows(std::optional<int32_t> num_rows, const T& header);
+  void writeStream();
+  void writePageWithoutStats();
+  void checkNumRows(std::optional<int32_t> numRows, const T& header);
 
  protected:
-  std::vector<T> data_page_headers_;
-  int total_rows_ = 0;
+  std::vector<T> dataPageHeaders_;
+  int totalRows_ = 0;
 };
 
 template <>
 void PageFilterTest<
-    facebook::velox::parquet::thrift::DataPageHeader>::WriteStream() {
+    facebook::velox::parquet::thrift::DataPageHeader>::writeStream() {
   for (int i = 0; i < kNumPages; ++i) {
     // Vary the number of rows to produce different headers.
-    int32_t num_rows = i + 100;
-    total_rows_ += num_rows;
-    int data_size = i + 1024;
-    this->data_page_header_.__set_num_values(num_rows);
-    this->data_page_header_.statistics.__set_min_value("A" + std::to_string(i));
-    this->data_page_header_.statistics.__set_max_value("Z" + std::to_string(i));
-    this->data_page_header_.statistics.__set_null_count(0);
-    this->data_page_header_.statistics.__set_distinct_count(num_rows);
-    this->data_page_header_.__isset.statistics = true;
-    ASSERT_NO_FATAL_FAILURE(this->WriteDataPageHeader(
-        /*max_serialized_len=*/1024, data_size, data_size));
-    data_page_headers_.push_back(this->data_page_header_);
+    int32_t numRows = i + 100;
+    totalRows_ += numRows;
+    int dataSize = i + 1024;
+    this->dataPageHeader_.__set_num_values(numRows);
+    this->dataPageHeader_.statistics.__set_min_value("A" + std::to_string(i));
+    this->dataPageHeader_.statistics.__set_max_value("Z" + std::to_string(i));
+    this->dataPageHeader_.statistics.__set_null_count(0);
+    this->dataPageHeader_.statistics.__set_distinct_count(numRows);
+    this->dataPageHeader_.__isset.statistics = true;
+    ASSERT_NO_FATAL_FAILURE(
+        this->writeDataPageHeader(1024, dataSize, dataSize));
+    dataPageHeaders_.push_back(this->dataPageHeader_);
     // Also write data, to make sure we skip the data correctly.
-    std::vector<uint8_t> faux_data(data_size);
-    ASSERT_OK(this->out_stream_->Write(faux_data.data(), data_size));
+    std::vector<uint8_t> fauxData(dataSize);
+    ASSERT_OK(this->outStream_->Write(fauxData.data(), dataSize));
   }
-  this->EndStream();
+  this->endStream();
 }
 
 template <>
 void PageFilterTest<
-    facebook::velox::parquet::thrift::DataPageHeaderV2>::WriteStream() {
+    facebook::velox::parquet::thrift::DataPageHeaderV2>::writeStream() {
   for (int i = 0; i < kNumPages; ++i) {
     // Vary the number of rows to produce different headers.
-    int32_t num_rows = i + 100;
-    total_rows_ += num_rows;
-    int data_size = i + 1024;
-    this->data_page_header_v2_.__set_num_values(num_rows);
-    this->data_page_header_v2_.__set_num_rows(num_rows);
-    this->data_page_header_v2_.statistics.__set_min_value(
-        "A" + std::to_string(i));
-    this->data_page_header_v2_.statistics.__set_max_value(
-        "Z" + std::to_string(i));
-    this->data_page_header_v2_.statistics.__set_null_count(0);
-    this->data_page_header_v2_.statistics.__set_distinct_count(num_rows);
-    this->data_page_header_v2_.__isset.statistics = true;
-    ASSERT_NO_FATAL_FAILURE(this->WriteDataPageHeaderV2(
-        /*max_serialized_len=*/1024, data_size, data_size));
-    data_page_headers_.push_back(this->data_page_header_v2_);
+    int32_t numRows = i + 100;
+    totalRows_ += numRows;
+    int dataSize = i + 1024;
+    this->dataPageHeaderV2_.__set_num_values(numRows);
+    this->dataPageHeaderV2_.__set_num_rows(numRows);
+    this->dataPageHeaderV2_.statistics.__set_min_value("A" + std::to_string(i));
+    this->dataPageHeaderV2_.statistics.__set_max_value("Z" + std::to_string(i));
+    this->dataPageHeaderV2_.statistics.__set_null_count(0);
+    this->dataPageHeaderV2_.statistics.__set_distinct_count(numRows);
+    this->dataPageHeaderV2_.__isset.statistics = true;
+    ASSERT_NO_FATAL_FAILURE(
+        this->writeDataPageHeaderV2(1024, dataSize, dataSize));
+    dataPageHeaders_.push_back(this->dataPageHeaderV2_);
     // Also write data, to make sure we skip the data correctly.
-    std::vector<uint8_t> faux_data(data_size);
-    ASSERT_OK(this->out_stream_->Write(faux_data.data(), data_size));
+    std::vector<uint8_t> fauxData(dataSize);
+    ASSERT_OK(this->outStream_->Write(fauxData.data(), dataSize));
   }
-  this->EndStream();
+  this->endStream();
 }
 
 template <>
 void PageFilterTest<
-    facebook::velox::parquet::thrift::DataPageHeader>::WritePageWithoutStats() {
-  int32_t num_rows = 100;
-  total_rows_ += num_rows;
-  int data_size = 1024;
-  this->data_page_header_.__set_num_values(num_rows);
-  ASSERT_NO_FATAL_FAILURE(this->WriteDataPageHeader(
-      /*max_serialized_len=*/1024, data_size, data_size));
-  data_page_headers_.push_back(this->data_page_header_);
-  std::vector<uint8_t> faux_data(data_size);
-  ASSERT_OK(this->out_stream_->Write(faux_data.data(), data_size));
-  this->EndStream();
+    facebook::velox::parquet::thrift::DataPageHeader>::writePageWithoutStats() {
+  int32_t numRows = 100;
+  totalRows_ += numRows;
+  int dataSize = 1024;
+  this->dataPageHeader_.__set_num_values(numRows);
+  ASSERT_NO_FATAL_FAILURE(this->writeDataPageHeader(1024, dataSize, dataSize));
+  dataPageHeaders_.push_back(this->dataPageHeader_);
+  std::vector<uint8_t> fauxData(dataSize);
+  ASSERT_OK(this->outStream_->Write(fauxData.data(), dataSize));
+  this->endStream();
 }
 
 template <>
 void PageFilterTest<facebook::velox::parquet::thrift::DataPageHeaderV2>::
-    WritePageWithoutStats() {
-  int32_t num_rows = 100;
-  total_rows_ += num_rows;
-  int data_size = 1024;
-  this->data_page_header_v2_.__set_num_values(num_rows);
-  this->data_page_header_v2_.__set_num_rows(num_rows);
-  ASSERT_NO_FATAL_FAILURE(this->WriteDataPageHeaderV2(
-      /*max_serialized_len=*/1024, data_size, data_size));
-  data_page_headers_.push_back(this->data_page_header_v2_);
-  std::vector<uint8_t> faux_data(data_size);
-  ASSERT_OK(this->out_stream_->Write(faux_data.data(), data_size));
-  this->EndStream();
+    writePageWithoutStats() {
+  int32_t numRows = 100;
+  totalRows_ += numRows;
+  int dataSize = 1024;
+  this->dataPageHeaderV2_.__set_num_values(numRows);
+  this->dataPageHeaderV2_.__set_num_rows(numRows);
+  ASSERT_NO_FATAL_FAILURE(
+      this->writeDataPageHeaderV2(1024, dataSize, dataSize));
+  dataPageHeaders_.push_back(this->dataPageHeaderV2_);
+  std::vector<uint8_t> fauxData(dataSize);
+  ASSERT_OK(this->outStream_->Write(fauxData.data(), dataSize));
+  this->endStream();
 }
 
 template <>
 void PageFilterTest<facebook::velox::parquet::thrift::DataPageHeader>::
-    CheckNumRows(
-        std::optional<int32_t> num_rows,
+    checkNumRows(
+        std::optional<int32_t> numRows,
         const facebook::velox::parquet::thrift::DataPageHeader& header) {
-  ASSERT_EQ(num_rows, std::nullopt);
+  ASSERT_EQ(numRows, std::nullopt);
 }
 
 template <>
 void PageFilterTest<facebook::velox::parquet::thrift::DataPageHeaderV2>::
-    CheckNumRows(
-        std::optional<int32_t> num_rows,
+    checkNumRows(
+        std::optional<int32_t> numRows,
         const facebook::velox::parquet::thrift::DataPageHeaderV2& header) {
-  ASSERT_EQ(*num_rows, header.num_rows);
+  ASSERT_EQ(*numRows, header.num_rows);
 }
 
 using DataPageHeaderTypes = ::testing::Types<
@@ -512,415 +497,400 @@ using DataPageHeaderTypes = ::testing::Types<
     facebook::velox::parquet::thrift::DataPageHeaderV2>;
 TYPED_TEST_SUITE(PageFilterTest, DataPageHeaderTypes);
 
-// Test that the returned encoded_statistics is nullptr when there are no
-// statistics in the page header.
+// Test that the returned encoded_statistics is nullptr when there are no.
+// Statistics in the page header.
 TYPED_TEST(PageFilterTest, TestPageWithoutStatistics) {
-  this->WritePageWithoutStats();
+  this->writePageWithoutStats();
 
-  auto stream = std::make_shared<::arrow::io::BufferReader>(this->out_buffer_);
-  this->page_reader_ =
-      PageReader::Open(stream, this->total_rows_, Compression::UNCOMPRESSED);
+  auto stream = std::make_shared<::arrow::io::BufferReader>(this->outBuffer_);
+  this->pageReader_ =
+      PageReader::open(stream, this->totalRows_, Compression::UNCOMPRESSED);
 
-  int num_pages = 0;
-  bool is_stats_null = false;
-  auto read_all_pages = [&](const DataPageStats& stats) -> bool {
-    is_stats_null = stats.encoded_statistics == nullptr;
-    ++num_pages;
+  int numPages = 0;
+  bool isStatsNull = false;
+  auto readAllPages = [&](const DataPageStats& stats) -> bool {
+    isStatsNull = stats.encodedStatistics == nullptr;
+    ++numPages;
     return false;
   };
 
-  this->page_reader_->set_data_page_filter(read_all_pages);
-  std::shared_ptr<Page> current_page = this->page_reader_->NextPage();
-  ASSERT_EQ(num_pages, 1);
-  ASSERT_EQ(is_stats_null, true);
-  ASSERT_EQ(this->page_reader_->NextPage(), nullptr);
+  this->pageReader_->setDataPageFilter(readAllPages);
+  std::shared_ptr<Page> currentPage = this->pageReader_->nextPage();
+  ASSERT_EQ(numPages, 1);
+  ASSERT_EQ(isStatsNull, true);
+  ASSERT_EQ(this->pageReader_->nextPage(), nullptr);
 }
 
-// Creates a number of pages and skips some of them with the page filter
-// callback.
+// Creates a number of pages and skips some of them with the page filter.
+// Callback.
 TYPED_TEST(PageFilterTest, TestPageFilterCallback) {
-  this->WriteStream();
+  this->writeStream();
 
   { // Read all pages.
-    // Also check that the encoded statistics passed to the callback function
-    // are right.
-    auto stream =
-        std::make_shared<::arrow::io::BufferReader>(this->out_buffer_);
-    this->page_reader_ =
-        PageReader::Open(stream, this->total_rows_, Compression::UNCOMPRESSED);
-
-    std::vector<EncodedStatistics> read_stats;
-    std::vector<int64_t> read_num_values;
-    std::vector<std::optional<int32_t>> read_num_rows;
-    auto read_all_pages = [&](const DataPageStats& stats) -> bool {
-      VELOX_DCHECK_NOT_NULL(stats.encoded_statistics);
-      read_stats.push_back(*stats.encoded_statistics);
-      read_num_values.push_back(stats.num_values);
-      read_num_rows.push_back(stats.num_rows);
+    // Also check that the encoded statistics passed to the callback function.
+    // Are right.
+    auto stream = std::make_shared<::arrow::io::BufferReader>(this->outBuffer_);
+    this->pageReader_ =
+        PageReader::open(stream, this->totalRows_, Compression::UNCOMPRESSED);
+
+    std::vector<EncodedStatistics> readStats;
+    std::vector<int64_t> readNumValues;
+    std::vector<std::optional<int32_t>> readNumRows;
+    auto readAllPages = [&](const DataPageStats& stats) -> bool {
+      VELOX_DCHECK_NOT_NULL(stats.encodedStatistics);
+      readStats.push_back(*stats.encodedStatistics);
+      readNumValues.push_back(stats.numValues);
+      readNumRows.push_back(stats.numRows);
       return false;
     };
 
-    this->page_reader_->set_data_page_filter(read_all_pages);
+    this->pageReader_->setDataPageFilter(readAllPages);
     for (int i = 0; i < this->kNumPages; ++i) {
-      std::shared_ptr<Page> current_page = this->page_reader_->NextPage();
-      ASSERT_NE(current_page, nullptr);
+      std::shared_ptr<Page> currentPage = this->pageReader_->nextPage();
+      ASSERT_NE(currentPage, nullptr);
       ASSERT_NO_FATAL_FAILURE(
-          CheckDataPageHeader(this->data_page_headers_[i], current_page.get()));
-      auto data_page = static_cast<const DataPage*>(current_page.get());
-      const EncodedStatistics encoded_statistics = data_page->statistics();
-      ASSERT_EQ(read_stats[i].max(), encoded_statistics.max());
-      ASSERT_EQ(read_stats[i].min(), encoded_statistics.min());
-      ASSERT_EQ(read_stats[i].null_count, encoded_statistics.null_count);
-      ASSERT_EQ(
-          read_stats[i].distinct_count, encoded_statistics.distinct_count);
-      ASSERT_EQ(read_num_values[i], this->data_page_headers_[i].num_values);
-      this->CheckNumRows(read_num_rows[i], this->data_page_headers_[i]);
+          checkDataPageHeader(this->dataPageHeaders_[i], currentPage.get()));
+      auto dataPage = static_cast<const DataPage*>(currentPage.get());
+      const EncodedStatistics EncodedStatistics = dataPage->statistics();
+      ASSERT_EQ(readStats[i].max(), EncodedStatistics.max());
+      ASSERT_EQ(readStats[i].min(), EncodedStatistics.min());
+      ASSERT_EQ(readStats[i].nullCount, EncodedStatistics.nullCount);
+      ASSERT_EQ(readStats[i].distinctCount, EncodedStatistics.distinctCount);
+      ASSERT_EQ(readNumValues[i], this->dataPageHeaders_[i].num_values);
+      this->checkNumRows(readNumRows[i], this->dataPageHeaders_[i]);
     }
-    ASSERT_EQ(this->page_reader_->NextPage(), nullptr);
+    ASSERT_EQ(this->pageReader_->nextPage(), nullptr);
   }
 
   { // Skip all pages.
-    auto stream =
-        std::make_shared<::arrow::io::BufferReader>(this->out_buffer_);
-    this->page_reader_ =
-        PageReader::Open(stream, this->total_rows_, Compression::UNCOMPRESSED);
+    auto stream = std::make_shared<::arrow::io::BufferReader>(this->outBuffer_);
+    this->pageReader_ =
+        PageReader::open(stream, this->totalRows_, Compression::UNCOMPRESSED);
 
-    auto skip_all_pages = [](const DataPageStats& stats) -> bool {
-      return true;
-    };
+    auto skipAllPages = [](const DataPageStats& stats) -> bool { return true; };
 
-    this->page_reader_->set_data_page_filter(skip_all_pages);
-    std::shared_ptr<Page> current_page = this->page_reader_->NextPage();
-    ASSERT_EQ(this->page_reader_->NextPage(), nullptr);
+    this->pageReader_->setDataPageFilter(skipAllPages);
+    std::shared_ptr<Page> currentPage = this->pageReader_->nextPage();
+    ASSERT_EQ(this->pageReader_->nextPage(), nullptr);
   }
 
   { // Skip every other page.
-    auto stream =
-        std::make_shared<::arrow::io::BufferReader>(this->out_buffer_);
-    this->page_reader_ =
-        PageReader::Open(stream, this->total_rows_, Compression::UNCOMPRESSED);
+    auto stream = std::make_shared<::arrow::io::BufferReader>(this->outBuffer_);
+    this->pageReader_ =
+        PageReader::open(stream, this->totalRows_, Compression::UNCOMPRESSED);
 
     // Skip pages with even number of values.
-    auto skip_even_pages = [](const DataPageStats& stats) -> bool {
-      if (stats.num_values % 2 == 0)
+    auto skipEvenPages = [](const DataPageStats& stats) -> bool {
+      if (stats.numValues % 2 == 0)
         return true;
       return false;
     };
 
-    this->page_reader_->set_data_page_filter(skip_even_pages);
+    this->pageReader_->setDataPageFilter(skipEvenPages);
 
     for (int i = 0; i < this->kNumPages; ++i) {
       // Only pages with odd number of values are read.
       if (i % 2 != 0) {
-        std::shared_ptr<Page> current_page = this->page_reader_->NextPage();
-        ASSERT_NE(current_page, nullptr);
-        ASSERT_NO_FATAL_FAILURE(CheckDataPageHeader(
-            this->data_page_headers_[i], current_page.get()));
+        std::shared_ptr<Page> currentPage = this->pageReader_->nextPage();
+        ASSERT_NE(currentPage, nullptr);
+        ASSERT_NO_FATAL_FAILURE(
+            checkDataPageHeader(this->dataPageHeaders_[i], currentPage.get()));
       }
     }
     // We should have exhausted reading the pages by reading the odd pages only.
-    ASSERT_EQ(this->page_reader_->NextPage(), nullptr);
+    ASSERT_EQ(this->pageReader_->nextPage(), nullptr);
   }
 }
 
-// Set the page filter more than once. The new filter should be effective
-// on the next NextPage() call.
+// Set the page filter more than once. The new filter should be effective.
+// On the next NextPage() call.
 TYPED_TEST(PageFilterTest, TestChangingPageFilter) {
-  this->WriteStream();
+  this->writeStream();
 
-  auto stream = std::make_shared<::arrow::io::BufferReader>(this->out_buffer_);
-  this->page_reader_ =
-      PageReader::Open(stream, this->total_rows_, Compression::UNCOMPRESSED);
+  auto stream = std::make_shared<::arrow::io::BufferReader>(this->outBuffer_);
+  this->pageReader_ =
+      PageReader::open(stream, this->totalRows_, Compression::UNCOMPRESSED);
 
   // This callback will always return false.
-  auto read_all_pages = [](const DataPageStats& stats) -> bool {
-    return false;
-  };
-  this->page_reader_->set_data_page_filter(read_all_pages);
-  std::shared_ptr<Page> current_page = this->page_reader_->NextPage();
-  ASSERT_NE(current_page, nullptr);
+  auto readAllPages = [](const DataPageStats& stats) -> bool { return false; };
+  this->pageReader_->setDataPageFilter(readAllPages);
+  std::shared_ptr<Page> currentPage = this->pageReader_->nextPage();
+  ASSERT_NE(currentPage, nullptr);
   ASSERT_NO_FATAL_FAILURE(
-      CheckDataPageHeader(this->data_page_headers_[0], current_page.get()));
+      checkDataPageHeader(this->dataPageHeaders_[0], currentPage.get()));
 
   // This callback will skip all pages.
-  auto skip_all_pages = [](const DataPageStats& stats) -> bool { return true; };
-  this->page_reader_->set_data_page_filter(skip_all_pages);
-  ASSERT_EQ(this->page_reader_->NextPage(), nullptr);
+  auto skipAllPages = [](const DataPageStats& stats) -> bool { return true; };
+  this->pageReader_->setDataPageFilter(skipAllPages);
+  ASSERT_EQ(this->pageReader_->nextPage(), nullptr);
 }
 
 // Test that we do not skip dictionary pages.
 TEST_F(TestPageSerde, DoesNotFilterDictionaryPages) {
-  int data_size = 1024;
-  std::vector<uint8_t> faux_data(data_size);
+  int dataSize = 1024;
+  std::vector<uint8_t> fauxData(dataSize);
 
-  ASSERT_NO_FATAL_FAILURE(
-      WriteDataPageHeader(/*max_serialized_len=*/1024, data_size, data_size));
-  ASSERT_OK(out_stream_->Write(faux_data.data(), data_size));
+  ASSERT_NO_FATAL_FAILURE(writeDataPageHeader(1024, dataSize, dataSize));
+  ASSERT_OK(outStream_->Write(fauxData.data(), dataSize));
 
-  ASSERT_NO_FATAL_FAILURE(WriteDictionaryPageHeader(data_size, data_size));
-  ASSERT_OK(out_stream_->Write(faux_data.data(), data_size));
+  ASSERT_NO_FATAL_FAILURE(writeDictionaryPageHeader(dataSize, dataSize));
+  ASSERT_OK(outStream_->Write(fauxData.data(), dataSize));
 
-  ASSERT_NO_FATAL_FAILURE(
-      WriteDataPageHeader(/*max_serialized_len=*/1024, data_size, data_size));
-  ASSERT_OK(out_stream_->Write(faux_data.data(), data_size));
-  EndStream();
+  ASSERT_NO_FATAL_FAILURE(writeDataPageHeader(1024, dataSize, dataSize));
+  ASSERT_OK(outStream_->Write(fauxData.data(), dataSize));
+  endStream();
 
   // Try to read it back while asking for all data pages to be skipped.
-  auto stream = std::make_shared<::arrow::io::BufferReader>(out_buffer_);
-  page_reader_ =
-      PageReader::Open(stream, /*num_rows=*/100, Compression::UNCOMPRESSED);
+  auto stream = std::make_shared<::arrow::io::BufferReader>(outBuffer_);
+  pageReader_ = PageReader::open(stream, 100, Compression::UNCOMPRESSED);
 
-  auto skip_all_pages = [](const DataPageStats& stats) -> bool { return true; };
+  auto skipAllPages = [](const DataPageStats& stats) -> bool { return true; };
 
-  page_reader_->set_data_page_filter(skip_all_pages);
+  pageReader_->setDataPageFilter(skipAllPages);
   // The first data page is skipped, so we are now at the dictionary page.
-  std::shared_ptr<Page> current_page = page_reader_->NextPage();
-  ASSERT_NE(current_page, nullptr);
-  ASSERT_EQ(current_page->type(), PageType::DICTIONARY_PAGE);
+  std::shared_ptr<Page> currentPage = pageReader_->nextPage();
+  ASSERT_NE(currentPage, nullptr);
+  ASSERT_EQ(currentPage->type(), PageType::kDictionaryPage);
   // The data page after dictionary page is skipped.
-  ASSERT_EQ(page_reader_->NextPage(), nullptr);
+  ASSERT_EQ(pageReader_->nextPage(), nullptr);
 }
 
 // Tests that we successfully skip non-data pages.
 TEST_F(TestPageSerde, SkipsNonDataPages) {
-  int data_size = 1024;
-  std::vector<uint8_t> faux_data(data_size);
-  ASSERT_NO_FATAL_FAILURE(WriteIndexPageHeader(data_size, data_size));
-  ASSERT_OK(out_stream_->Write(faux_data.data(), data_size));
+  int dataSize = 1024;
+  std::vector<uint8_t> fauxData(dataSize);
+  ASSERT_NO_FATAL_FAILURE(writeIndexPageHeader(dataSize, dataSize));
+  ASSERT_OK(outStream_->Write(fauxData.data(), dataSize));
 
-  ASSERT_NO_FATAL_FAILURE(
-      WriteDataPageHeader(/*max_serialized_len=*/1024, data_size, data_size));
-  ASSERT_OK(out_stream_->Write(faux_data.data(), data_size));
+  ASSERT_NO_FATAL_FAILURE(writeDataPageHeader(1024, dataSize, dataSize));
+  ASSERT_OK(outStream_->Write(fauxData.data(), dataSize));
 
-  ASSERT_NO_FATAL_FAILURE(WriteIndexPageHeader(data_size, data_size));
-  ASSERT_OK(out_stream_->Write(faux_data.data(), data_size));
-  ASSERT_NO_FATAL_FAILURE(WriteIndexPageHeader(data_size, data_size));
-  ASSERT_OK(out_stream_->Write(faux_data.data(), data_size));
+  ASSERT_NO_FATAL_FAILURE(writeIndexPageHeader(dataSize, dataSize));
+  ASSERT_OK(outStream_->Write(fauxData.data(), dataSize));
+  ASSERT_NO_FATAL_FAILURE(writeIndexPageHeader(dataSize, dataSize));
+  ASSERT_OK(outStream_->Write(fauxData.data(), dataSize));
 
-  ASSERT_NO_FATAL_FAILURE(
-      WriteDataPageHeader(/*max_serialized_len=*/1024, data_size, data_size));
-  ASSERT_OK(out_stream_->Write(faux_data.data(), data_size));
-  ASSERT_NO_FATAL_FAILURE(WriteIndexPageHeader(data_size, data_size));
-  ASSERT_OK(out_stream_->Write(faux_data.data(), data_size));
-  EndStream();
+  ASSERT_NO_FATAL_FAILURE(writeDataPageHeader(1024, dataSize, dataSize));
+  ASSERT_OK(outStream_->Write(fauxData.data(), dataSize));
+  ASSERT_NO_FATAL_FAILURE(writeIndexPageHeader(dataSize, dataSize));
+  ASSERT_OK(outStream_->Write(fauxData.data(), dataSize));
+  endStream();
 
-  auto stream = std::make_shared<::arrow::io::BufferReader>(out_buffer_);
-  page_reader_ =
-      PageReader::Open(stream, /*num_rows=*/100, Compression::UNCOMPRESSED);
+  auto stream = std::make_shared<::arrow::io::BufferReader>(outBuffer_);
+  pageReader_ = PageReader::open(stream, 100, Compression::UNCOMPRESSED);
 
   // Only the two data pages are returned.
-  std::shared_ptr<Page> current_page = page_reader_->NextPage();
-  ASSERT_EQ(current_page->type(), PageType::DATA_PAGE);
-  current_page = page_reader_->NextPage();
-  ASSERT_EQ(current_page->type(), PageType::DATA_PAGE);
-  ASSERT_EQ(page_reader_->NextPage(), nullptr);
+  std::shared_ptr<Page> currentPage = pageReader_->nextPage();
+  ASSERT_EQ(currentPage->type(), PageType::kDataPage);
+  currentPage = pageReader_->nextPage();
+  ASSERT_EQ(currentPage->type(), PageType::kDataPage);
+  ASSERT_EQ(pageReader_->nextPage(), nullptr);
 }
 
 TEST_F(TestPageSerde, DataPageV2) {
-  int stats_size = 512;
-  const int32_t num_rows = 4444;
-  AddDummyStats(stats_size, data_page_header_v2_, /* fill_all_stats = */ true);
-  data_page_header_v2_.num_values = num_rows;
-
-  ASSERT_NO_FATAL_FAILURE(WriteDataPageHeaderV2());
-  InitSerializedPageReader(num_rows);
-  std::shared_ptr<Page> current_page = page_reader_->NextPage();
+  int statsSize = 512;
+  const int32_t numRows = 4444;
+  addDummyStats(statsSize, dataPageHeaderV2_, /*fill_all_stats=*/true);
+  dataPageHeaderV2_.num_values = numRows;
+
+  ASSERT_NO_FATAL_FAILURE(writeDataPageHeaderV2());
+  initSerializedPageReader(numRows);
+  std::shared_ptr<Page> currentPage = pageReader_->nextPage();
   ASSERT_NO_FATAL_FAILURE(
-      CheckDataPageHeader(data_page_header_v2_, current_page.get()));
+      checkDataPageHeader(dataPageHeaderV2_, currentPage.get()));
 }
 
 TEST_F(TestPageSerde, TestLargePageHeaders) {
-  int stats_size = 256 * 1024; // 256 KB
-  AddDummyStats(stats_size, data_page_header_);
+  int statsSize = 256 * 1024; // 256 KB
+  addDummyStats(statsSize, dataPageHeader_);
 
-  // Any number to verify metadata roundtrip
-  const int32_t num_rows = 4141;
-  data_page_header_.num_values = num_rows;
+  // Any number to verify metadata roundtrip.
+  const int32_t numRows = 4141;
+  dataPageHeader_.num_values = numRows;
 
-  int max_header_size = 512 * 1024; // 512 KB
-  ASSERT_NO_FATAL_FAILURE(WriteDataPageHeader(max_header_size));
+  int maxHeaderSize = 512 * 1024; // 512 KB
+  ASSERT_NO_FATAL_FAILURE(writeDataPageHeader(maxHeaderSize));
 
-  ASSERT_OK_AND_ASSIGN(int64_t position, out_stream_->Tell());
-  ASSERT_GE(max_header_size, position);
+  ASSERT_OK_AND_ASSIGN(int64_t position, outStream_->Tell());
+  ASSERT_GE(maxHeaderSize, position);
 
-  // check header size is between 256 KB to 16 MB
-  ASSERT_LE(stats_size, position);
+  // Check header size is between 256 KB to 16 MB.
+  ASSERT_LE(statsSize, position);
   ASSERT_GE(kDefaultMaxPageHeaderSize, position);
 
-  InitSerializedPageReader(num_rows);
-  std::shared_ptr<Page> current_page = page_reader_->NextPage();
+  initSerializedPageReader(numRows);
+  std::shared_ptr<Page> currentPage = pageReader_->nextPage();
   ASSERT_NO_FATAL_FAILURE(
-      CheckDataPageHeader(data_page_header_, current_page.get()));
+      checkDataPageHeader(dataPageHeader_, currentPage.get()));
 }
 
 TEST_F(TestPageSerde, TestFailLargePageHeaders) {
-  const int32_t num_rows = 1337; // dummy value
+  const int32_t numRows = 1337; // dummy value
 
-  int stats_size = 256 * 1024; // 256 KB
-  AddDummyStats(stats_size, data_page_header_);
+  int statsSize = 256 * 1024; // 256 KB
+  addDummyStats(statsSize, dataPageHeader_);
 
-  // Serialize the Page header
-  int max_header_size = 512 * 1024; // 512 KB
-  ASSERT_NO_FATAL_FAILURE(WriteDataPageHeader(max_header_size));
-  ASSERT_OK_AND_ASSIGN(int64_t position, out_stream_->Tell());
-  ASSERT_GE(max_header_size, position);
+  // Serialize the Page header.
+  int maxHeaderSize = 512 * 1024; // 512 KB
+  ASSERT_NO_FATAL_FAILURE(writeDataPageHeader(maxHeaderSize));
+  ASSERT_OK_AND_ASSIGN(int64_t position, outStream_->Tell());
+  ASSERT_GE(maxHeaderSize, position);
 
-  int smaller_max_size = 128 * 1024;
-  ASSERT_LE(smaller_max_size, position);
-  InitSerializedPageReader(num_rows);
+  int smallerMaxSize = 128 * 1024;
+  ASSERT_LE(smallerMaxSize, position);
+  initSerializedPageReader(numRows);
 
-  // Set the max page header size to 128 KB, which is less than the current
-  // header size
-  page_reader_->set_max_page_header_size(smaller_max_size);
-  ASSERT_THROW(page_reader_->NextPage(), ParquetException);
+  // Set the max page header size to 128 KB, which is less than the current.
+  // Header size.
+  pageReader_->setMaxPageHeaderSize(smallerMaxSize);
+  ASSERT_THROW(pageReader_->nextPage(), ParquetException);
 }
 
-void TestPageSerde::TestPageCompressionRoundTrip(
-    const std::vector<int>& page_sizes) {
-  auto codec_types = GetSupportedCodecTypes();
+void TestPageSerde::testPageCompressionRoundTrip(
+    const std::vector<int>& pageSizes) {
+  auto codecTypes = getSupportedCodecTypes();
 
-  const int32_t num_rows = 32; // dummy value
-  data_page_header_.num_values = num_rows;
+  const int32_t numRows = 32; // dummy value
+  dataPageHeader_.num_values = numRows;
 
-  std::vector<std::vector<uint8_t>> faux_data;
-  int num_pages = static_cast<int>(page_sizes.size());
-  faux_data.resize(num_pages);
-  for (int i = 0; i < num_pages; ++i) {
-    test::random_bytes(page_sizes[i], 0, &faux_data[i]);
+  std::vector<std::vector<uint8_t>> fauxData;
+  int numPages = static_cast<int>(pageSizes.size());
+  fauxData.resize(numPages);
+  for (int i = 0; i < numPages; ++i) {
+    test::randomBytes(pageSizes[i], 0, &fauxData[i]);
   }
-  for (auto codec_type : codec_types) {
-    auto codec = GetCodec(codec_type);
+  for (auto codecType : codecTypes) {
+    auto Codec = getCodec(codecType);
 
     std::vector<uint8_t> buffer;
-    for (int i = 0; i < num_pages; ++i) {
-      const uint8_t* data = faux_data[i].data();
-      int data_size = static_cast<int>(faux_data[i].size());
+    for (int i = 0; i < numPages; ++i) {
+      const uint8_t* data = fauxData[i].data();
+      int dataSize = static_cast<int>(fauxData[i].size());
 
-      int64_t max_compressed_size = codec->MaxCompressedLen(data_size, data);
-      buffer.resize(max_compressed_size);
+      int64_t maxCompressedSize = Codec->maxCompressedLen(dataSize, data);
+      buffer.resize(maxCompressedSize);
 
-      int64_t actual_size;
+      int64_t actualSize;
       ASSERT_OK_AND_ASSIGN(
-          actual_size,
-          codec->Compress(data_size, data, max_compressed_size, &buffer[0]));
+          actualSize,
+          Codec->compress(dataSize, data, maxCompressedSize, &buffer[0]));
 
-      ASSERT_NO_FATAL_FAILURE(WriteDataPageHeader(
-          1024, data_size, static_cast<int32_t>(actual_size)));
-      ASSERT_OK(out_stream_->Write(buffer.data(), actual_size));
+      ASSERT_NO_FATAL_FAILURE(writeDataPageHeader(
+          1024, dataSize, static_cast<int32_t>(actualSize)));
+      ASSERT_OK(outStream_->Write(buffer.data(), actualSize));
     }
 
-    InitSerializedPageReader(num_rows * num_pages, codec_type);
+    initSerializedPageReader(numRows * numPages, codecType);
 
     std::shared_ptr<Page> page;
-    const DataPageV1* data_page;
-    for (int i = 0; i < num_pages; ++i) {
-      int data_size = static_cast<int>(faux_data[i].size());
-      page = page_reader_->NextPage();
-      data_page = static_cast<const DataPageV1*>(page.get());
-      ASSERT_EQ(data_size, data_page->size());
-      ASSERT_EQ(0, memcmp(faux_data[i].data(), data_page->data(), data_size));
+    const DataPageV1* dataPage;
+    for (int i = 0; i < numPages; ++i) {
+      int dataSize = static_cast<int>(fauxData[i].size());
+      page = pageReader_->nextPage();
+      dataPage = static_cast<const DataPageV1*>(page.get());
+      ASSERT_EQ(dataSize, dataPage->size());
+      ASSERT_EQ(0, memcmp(fauxData[i].data(), dataPage->data(), dataSize));
     }
 
-    ResetStream();
+    resetStream();
   }
 }
 
 TEST_F(TestPageSerde, Compression) {
-  std::vector<int> page_sizes;
-  page_sizes.reserve(10);
+  std::vector<int> pageSizes;
+  pageSizes.reserve(10);
   for (int i = 0; i < 10; ++i) {
-    // The pages keep getting larger
-    page_sizes.push_back((i + 1) * 64);
+    // The pages keep getting larger.
+    pageSizes.push_back((i + 1) * 64);
   }
-  this->TestPageCompressionRoundTrip(page_sizes);
+  this->testPageCompressionRoundTrip(pageSizes);
 }
 
 TEST_F(TestPageSerde, PageSizeResetWhenRead) {
-  // GH-35423: Parquet SerializedPageReader need to
-  // reset the size after getting a smaller page.
-  std::vector<int> page_sizes;
-  page_sizes.reserve(10);
+  // GH-35423: Parquet SerializedPageReader need to.
+  // Reset the size after getting a smaller page.
+  std::vector<int> pageSizes;
+  pageSizes.reserve(10);
   for (int i = 0; i < 10; ++i) {
-    // The pages keep getting smaller
-    page_sizes.push_back((10 - i) * 64);
+    // The pages keep getting smaller.
+    pageSizes.push_back((10 - i) * 64);
   }
-  this->TestPageCompressionRoundTrip(page_sizes);
+  this->testPageCompressionRoundTrip(pageSizes);
 }
 
 TEST_F(TestPageSerde, LZONotSupported) {
-  // Must await PARQUET-530
-  int data_size = 1024;
-  std::vector<uint8_t> faux_data(data_size);
-  ASSERT_NO_FATAL_FAILURE(WriteDataPageHeader(1024, data_size, data_size));
-  ASSERT_OK(out_stream_->Write(faux_data.data(), data_size));
+  // Must await PARQUET-530.
+  int dataSize = 1024;
+  std::vector<uint8_t> fauxData(dataSize);
+  ASSERT_NO_FATAL_FAILURE(writeDataPageHeader(1024, dataSize, dataSize));
+  ASSERT_OK(outStream_->Write(fauxData.data(), dataSize));
   ASSERT_THROW(
-      InitSerializedPageReader(data_size, Compression::LZO), ParquetException);
+      initSerializedPageReader(dataSize, Compression::LZO), ParquetException);
 }
 
 TEST_F(TestPageSerde, NoCrc) {
-  int stats_size = 512;
-  const int32_t num_rows = 4444;
-  AddDummyStats(stats_size, data_page_header_, /*fill_all_stats=*/true);
-  data_page_header_.num_values = num_rows;
-
-  ASSERT_NO_FATAL_FAILURE(WriteDataPageHeader());
-  ReaderProperties readerProperties;
-  readerProperties.set_page_checksum_verification(true);
-  InitSerializedPageReader(
-      num_rows, Compression::UNCOMPRESSED, readerProperties);
-  std::shared_ptr<Page> current_page = page_reader_->NextPage();
+  int statsSize = 512;
+  const int32_t numRows = 4444;
+  addDummyStats(statsSize, dataPageHeader_, true);
+  dataPageHeader_.num_values = numRows;
+
+  ASSERT_NO_FATAL_FAILURE(writeDataPageHeader());
+  ReaderProperties ReaderProperties;
+  ReaderProperties.setPageChecksumVerification(true);
+  initSerializedPageReader(
+      numRows, Compression::UNCOMPRESSED, ReaderProperties);
+  std::shared_ptr<Page> currentPage = pageReader_->nextPage();
   ASSERT_NO_FATAL_FAILURE(
-      CheckDataPageHeader(data_page_header_, current_page.get()));
+      checkDataPageHeader(dataPageHeader_, currentPage.get()));
 }
 
 TEST_F(TestPageSerde, NoCrcDict) {
-  const int32_t num_rows = 4444;
-  dictionary_page_header_.num_values = num_rows;
+  const int32_t numRows = 4444;
+  dictionaryPageHeader_.num_values = numRows;
 
-  ASSERT_NO_FATAL_FAILURE(WriteDictionaryPageHeader());
-  ReaderProperties readerProperties;
-  readerProperties.set_page_checksum_verification(true);
-  InitSerializedPageReader(
-      num_rows, Compression::UNCOMPRESSED, readerProperties);
-  std::shared_ptr<Page> current_page = page_reader_->NextPage();
+  ASSERT_NO_FATAL_FAILURE(writeDictionaryPageHeader());
+  ReaderProperties ReaderProperties;
+  ReaderProperties.setPageChecksumVerification(true);
+  initSerializedPageReader(
+      numRows, Compression::UNCOMPRESSED, ReaderProperties);
+  std::shared_ptr<Page> currentPage = pageReader_->nextPage();
 
-  ASSERT_EQ(PageType::DICTIONARY_PAGE, current_page->type());
+  ASSERT_EQ(PageType::kDictionaryPage, currentPage->type());
 
-  const auto* dict_page =
-      static_cast<const DictionaryPage*>(current_page.get());
-  EXPECT_EQ(num_rows, dict_page->num_values());
+  const auto* dictPage = static_cast<const DictionaryPage*>(currentPage.get());
+  EXPECT_EQ(numRows, dictPage->numValues());
 }
 
 TEST_F(TestPageSerde, CrcCheckSuccessful) {
-  this->TestPageSerdeCrc(
+  this->testPageSerdeCrc(
       /* write_checksum */ true,
       /* write_page_corrupt */ false,
       /* verification_checksum */ true);
 }
 
 TEST_F(TestPageSerde, CrcCheckFail) {
-  this->TestPageSerdeCrc(
+  this->testPageSerdeCrc(
       /* write_checksum */ true,
       /* write_page_corrupt */ true,
       /* verification_checksum */ true);
 }
 
 TEST_F(TestPageSerde, CrcCorruptNotChecked) {
-  this->TestPageSerdeCrc(
+  this->testPageSerdeCrc(
       /* write_checksum */ true,
       /* write_page_corrupt */ true,
       /* verification_checksum */ false);
 }
 
 TEST_F(TestPageSerde, CrcCheckNonExistent) {
-  this->TestPageSerdeCrc(
+  this->testPageSerdeCrc(
       /* write_checksum */ false,
       /* write_page_corrupt */ false,
       /* verification_checksum */ true);
 }
 
 TEST_F(TestPageSerde, DictCrcCheckSuccessful) {
-  this->TestPageSerdeCrc(
+  this->testPageSerdeCrc(
       /* write_checksum */ true,
       /* write_page_corrupt */ false,
       /* verification_checksum */ true,
@@ -928,7 +898,7 @@ TEST_F(TestPageSerde, DictCrcCheckSuccessful) {
 }
 
 TEST_F(TestPageSerde, DictCrcCheckFail) {
-  this->TestPageSerdeCrc(
+  this->testPageSerdeCrc(
       /* write_checksum */ true,
       /* write_page_corrupt */ true,
       /* verification_checksum */ true,
@@ -936,7 +906,7 @@ TEST_F(TestPageSerde, DictCrcCheckFail) {
 }
 
 TEST_F(TestPageSerde, DictCrcCorruptNotChecked) {
-  this->TestPageSerdeCrc(
+  this->testPageSerdeCrc(
       /* write_checksum */ true,
       /* write_page_corrupt */ true,
       /* verification_checksum */ false,
@@ -944,7 +914,7 @@ TEST_F(TestPageSerde, DictCrcCorruptNotChecked) {
 }
 
 TEST_F(TestPageSerde, DictCrcCheckNonExistent) {
-  this->TestPageSerdeCrc(
+  this->testPageSerdeCrc(
       /* write_checksum */ false,
       /* write_page_corrupt */ false,
       /* verification_checksum */ true,
@@ -952,7 +922,7 @@ TEST_F(TestPageSerde, DictCrcCheckNonExistent) {
 }
 
 TEST_F(TestPageSerde, DataPageV2CrcCheckSuccessful) {
-  this->TestPageSerdeCrc(
+  this->testPageSerdeCrc(
       /* write_checksum */ true,
       /* write_page_corrupt */ false,
       /* verification_checksum */ true,
@@ -961,7 +931,7 @@ TEST_F(TestPageSerde, DataPageV2CrcCheckSuccessful) {
 }
 
 TEST_F(TestPageSerde, DataPageV2CrcCheckFail) {
-  this->TestPageSerdeCrc(
+  this->testPageSerdeCrc(
       /* write_checksum */ true,
       /* write_page_corrupt */ true,
       /* verification_checksum */ true,
@@ -970,7 +940,7 @@ TEST_F(TestPageSerde, DataPageV2CrcCheckFail) {
 }
 
 TEST_F(TestPageSerde, DataPageV2CrcCorruptNotChecked) {
-  this->TestPageSerdeCrc(
+  this->testPageSerdeCrc(
       /* write_checksum */ true,
       /* write_page_corrupt */ true,
       /* verification_checksum */ false,
@@ -979,7 +949,7 @@ TEST_F(TestPageSerde, DataPageV2CrcCorruptNotChecked) {
 }
 
 TEST_F(TestPageSerde, DataPageV2CrcCheckNonExistent) {
-  this->TestPageSerdeCrc(
+  this->testPageSerdeCrc(
       /* write_checksum */ false,
       /* write_page_corrupt */ false,
       /* verification_checksum */ true,
@@ -987,22 +957,26 @@ TEST_F(TestPageSerde, DataPageV2CrcCheckNonExistent) {
       /* write_data_page_v2 */ true);
 }
 
-// ----------------------------------------------------------------------
-// File structure tests
+// ----------------------------------------------------------------------.
+// File structure tests.
 
 class TestParquetFileReader : public ::testing::Test {
  public:
-  void AssertInvalidFileThrows(const std::shared_ptr<Buffer>& buffer) {
+  void assertInvalidFileThrows(const std::shared_ptr<Buffer>& buffer) {
     auto reader = std::make_shared<BufferReader>(buffer);
-    // Write the buffer to a temp file path
-    auto filePath = exec::test::TempFilePath::create();
+    // Write the buffer to a temp file path.
+    auto filePath = common::testutil::TempFilePath::create();
     writeToFile(filePath, buffer);
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
     std::shared_ptr<facebook::velox::memory::MemoryPool> rootPool =
         memory::memoryManager()->addRootPool("MetadataTest");
     std::shared_ptr<facebook::velox::memory::MemoryPool> leafPool =
         rootPool->addLeafChild("MetadataTest");
-    dwio::common::ReaderOptions readerOptions{leafPool.get()};
+    auto dataIoStats = std::make_shared<velox::io::IoStatistics>();
+    auto metadataIoStats = std::make_shared<velox::io::IoStatistics>();
+    dwio::common::ReaderOptions readerOptions(leafPool.get());
+    readerOptions.setDataIoStats(dataIoStats);
+    readerOptions.setMetadataIoStats(metadataIoStats);
     auto input = std::make_unique<dwio::common::BufferedInput>(
         std::make_shared<LocalReadFile>(filePath->getPath()),
         readerOptions.memoryPool());
@@ -1014,26 +988,26 @@ class TestParquetFileReader : public ::testing::Test {
 };
 
 TEST_F(TestParquetFileReader, InvalidHeader) {
-  const char* bad_header = "PAR2";
+  const char* badHeader = "PAR2";
 
-  auto buffer = Buffer::Wrap(bad_header, strlen(bad_header));
-  ASSERT_NO_FATAL_FAILURE(AssertInvalidFileThrows(buffer));
+  auto buffer = Buffer::Wrap(badHeader, strlen(badHeader));
+  ASSERT_NO_FATAL_FAILURE(assertInvalidFileThrows(buffer));
 }
 
 TEST_F(TestParquetFileReader, InvalidFooter) {
-  // File is smaller than FOOTER_SIZE
-  const char* bad_file = "PAR1PAR";
-  auto buffer = Buffer::Wrap(bad_file, strlen(bad_file));
-  ASSERT_NO_FATAL_FAILURE(AssertInvalidFileThrows(buffer));
-
-  // Magic number incorrect
-  const char* bad_file2 = "PAR1PAR2";
-  buffer = Buffer::Wrap(bad_file2, strlen(bad_file2));
-  ASSERT_NO_FATAL_FAILURE(AssertInvalidFileThrows(buffer));
+  // File is smaller than FOOTER_SIZE.
+  const char* badFile = "PAR1PAR";
+  auto buffer = Buffer::Wrap(badFile, strlen(badFile));
+  ASSERT_NO_FATAL_FAILURE(assertInvalidFileThrows(buffer));
+
+  // Magic number incorrect.
+  const char* badFile2 = "PAR1PAR2";
+  buffer = Buffer::Wrap(badFile2, strlen(badFile2));
+  ASSERT_NO_FATAL_FAILURE(assertInvalidFileThrows(buffer));
 }
 
 TEST_F(TestParquetFileReader, IncompleteMetadata) {
-  auto stream = CreateOutputStream();
+  auto stream = createOutputStream();
 
   const char* magic = "PAR1";
 
@@ -1041,24 +1015,28 @@ TEST_F(TestParquetFileReader, IncompleteMetadata) {
       stream->Write(reinterpret_cast<const uint8_t*>(magic), strlen(magic)));
   std::vector<uint8_t> bytes(10);
   ASSERT_OK(stream->Write(bytes.data(), bytes.size()));
-  uint32_t metadata_len = 24;
+  uint32_t metadataLen = 24;
   ASSERT_OK(stream->Write(
-      reinterpret_cast<const uint8_t*>(&metadata_len), sizeof(uint32_t)));
+      reinterpret_cast<const uint8_t*>(&metadataLen), sizeof(uint32_t)));
   ASSERT_OK(
       stream->Write(reinterpret_cast<const uint8_t*>(magic), strlen(magic)));
 
   ASSERT_OK_AND_ASSIGN(auto buffer, stream->Finish());
 
   auto reader = std::make_shared<BufferReader>(buffer);
-  // Write the buffer to a temp file path
-  auto filePath = exec::test::TempFilePath::create();
+  // Write the buffer to a temp file path.
+  auto filePath = TempFilePath::create();
   writeToFile(filePath, buffer);
   memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   std::shared_ptr<facebook::velox::memory::MemoryPool> rootPool =
       memory::memoryManager()->addRootPool("MetadataTest");
   std::shared_ptr<facebook::velox::memory::MemoryPool> leafPool =
       rootPool->addLeafChild("MetadataTest");
-  dwio::common::ReaderOptions readerOptions{leafPool.get()};
+  auto dataIoStats = std::make_shared<velox::io::IoStatistics>();
+  auto metadataIoStats = std::make_shared<velox::io::IoStatistics>();
+  dwio::common::ReaderOptions readerOptions(leafPool.get());
+  readerOptions.setDataIoStats(dataIoStats);
+  readerOptions.setMetadataIoStats(metadataIoStats);
   auto input = std::make_unique<dwio::common::BufferedInput>(
       std::make_shared<LocalReadFile>(filePath->getPath()),
       readerOptions.memoryPool());
diff --git a/velox/dwio/parquet/writer/arrow/tests/FileReader.cpp b/velox/dwio/parquet/writer/arrow/tests/FileReader.cpp
index b1a8f3148bf..b80f25f1c96 100644
--- a/velox/dwio/parquet/writer/arrow/tests/FileReader.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/FileReader.cpp
@@ -55,64 +55,63 @@ using arrow::internal::AddWithOverflow;
 
 namespace facebook::velox::parquet::arrow {
 
-// PARQUET-978: Minimize footer reads by reading 64 KB from the end of the file
+// PARQUET-978: Minimize footer reads by reading 64 KB from the end of the file.
 static constexpr int64_t kDefaultFooterReadSize = 64 * 1024;
 static constexpr uint32_t kFooterSize = 8;
 
-// For PARQUET-816
+// For PARQUET-816.
 static constexpr int64_t kMaxDictHeaderSize = 100;
 
-// ----------------------------------------------------------------------
-// RowGroupReader public API
+// ----------------------------------------------------------------------.
+// RowGroupReader public API.
 
 RowGroupReader::RowGroupReader(std::unique_ptr<Contents> contents)
     : contents_(std::move(contents)) {}
 
-std::shared_ptr<ColumnReader> RowGroupReader::Column(int i) {
-  if (i >= metadata()->num_columns()) {
+std::shared_ptr<ColumnReader> RowGroupReader::column(int i) {
+  if (i >= metadata()->numColumns()) {
     std::stringstream ss;
     ss << "Trying to read column index " << i
-       << " but row group metadata has only " << metadata()->num_columns()
+       << " but row group metadata has only " << metadata()->numColumns()
        << " columns";
     throw ParquetException(ss.str());
   }
-  const ColumnDescriptor* descr = metadata()->schema()->Column(i);
+  const ColumnDescriptor* descr = metadata()->schema()->column(i);
 
-  std::unique_ptr<PageReader> page_reader = contents_->GetColumnPageReader(i);
-  return ColumnReader::Make(
+  std::unique_ptr<PageReader> PageReader = contents_->getColumnPageReader(i);
+  return ColumnReader::make(
       descr,
-      std::move(page_reader),
-      const_cast<ReaderProperties*>(contents_->properties())->memory_pool());
+      std::move(PageReader),
+      const_cast<ReaderProperties*>(contents_->properties())->memoryPool());
 }
 
-std::shared_ptr<ColumnReader> RowGroupReader::ColumnWithExposeEncoding(
+std::shared_ptr<ColumnReader> RowGroupReader::columnWithExposeEncoding(
     int i,
-    ExposedEncoding encoding_to_expose) {
-  std::shared_ptr<ColumnReader> reader = Column(i);
+    ExposedEncoding encodingToExpose) {
+  std::shared_ptr<ColumnReader> reader = column(i);
 
-  if (encoding_to_expose == ExposedEncoding::DICTIONARY) {
+  if (encodingToExpose == ExposedEncoding::kDictionary) {
     // Check the encoding_stats to see if all data pages are dictionary encoded.
-    std::unique_ptr<ColumnChunkMetaData> col = metadata()->ColumnChunk(i);
-    const std::vector<PageEncodingStats>& encoding_stats =
-        col->encoding_stats();
-    if (encoding_stats.empty()) {
-      // Some parquet files may have empty encoding_stats. In this case we are
-      // not sure whether all data pages are dictionary encoded. So we do not
-      // enable exposing dictionary.
+    std::unique_ptr<ColumnChunkMetaData> col = metadata()->columnChunk(i);
+    const std::vector<PageEncodingStats>& encodingStats = col->encodingStats();
+    if (encodingStats.empty()) {
+      // Some parquet files may have empty encoding_stats. In this case we are.
+      // Not sure whether all data pages are dictionary encoded. So we do not.
+      // Enable exposing dictionary.
       return reader;
     }
     // The 1st page should be the dictionary page.
-    if (encoding_stats[0].page_type != PageType::DICTIONARY_PAGE ||
-        (encoding_stats[0].encoding != Encoding::PLAIN &&
-         encoding_stats[0].encoding != Encoding::PLAIN_DICTIONARY)) {
+    if (encodingStats[0].pageType != PageType::kDictionaryPage ||
+        (encodingStats[0].encoding != Encoding::kPlain &&
+         encodingStats[0].encoding != Encoding::kPlainDictionary)) {
       return reader;
     }
     // The following pages should be dictionary encoded data pages.
-    for (size_t idx = 1; idx < encoding_stats.size(); ++idx) {
-      if ((encoding_stats[idx].encoding != Encoding::RLE_DICTIONARY &&
-           encoding_stats[idx].encoding != Encoding::PLAIN_DICTIONARY) ||
-          (encoding_stats[idx].page_type != PageType::DATA_PAGE &&
-           encoding_stats[idx].page_type != PageType::DATA_PAGE_V2)) {
+    for (size_t idx = 1; idx < encodingStats.size(); ++idx) {
+      if ((encodingStats[idx].encoding != Encoding::kRleDictionary &&
+           encodingStats[idx].encoding != Encoding::kPlainDictionary) ||
+          (encodingStats[idx].pageType != PageType::kDataPage &&
+           encodingStats[idx].pageType != PageType::kDataPageV2)) {
         return reader;
       }
     }
@@ -122,138 +121,135 @@ std::shared_ptr<ColumnReader> RowGroupReader::ColumnWithExposeEncoding(
   }
 
   // Set exposed encoding.
-  reader->SetExposedEncoding(encoding_to_expose);
+  reader->setExposedEncoding(encodingToExpose);
   return reader;
 }
 
-std::unique_ptr<PageReader> RowGroupReader::GetColumnPageReader(int i) {
-  if (i >= metadata()->num_columns()) {
+std::unique_ptr<PageReader> RowGroupReader::getColumnPageReader(int i) {
+  if (i >= metadata()->numColumns()) {
     std::stringstream ss;
     ss << "Trying to read column index " << i
-       << " but row group metadata has only " << metadata()->num_columns()
+       << " but row group metadata has only " << metadata()->numColumns()
        << " columns";
     throw ParquetException(ss.str());
   }
-  return contents_->GetColumnPageReader(i);
+  return contents_->getColumnPageReader(i);
 }
 
-// Returns the rowgroup metadata
+// Returns the rowgroup metadata.
 const RowGroupMetaData* RowGroupReader::metadata() const {
   return contents_->metadata();
 }
 
-/// Compute the section of the file that should be read for the given
-/// row group and column chunk.
-::arrow::io::ReadRange ComputeColumnChunkRange(
-    FileMetaData* file_metadata,
-    int64_t source_size,
-    int row_group_index,
-    int column_index) {
-  auto row_group_metadata = file_metadata->RowGroup(row_group_index);
-  auto column_metadata = row_group_metadata->ColumnChunk(column_index);
-
-  int64_t col_start = column_metadata->data_page_offset();
-  if (column_metadata->has_dictionary_page() &&
-      column_metadata->dictionary_page_offset() > 0 &&
-      col_start > column_metadata->dictionary_page_offset()) {
-    col_start = column_metadata->dictionary_page_offset();
+/// Compute the section of the file that should be read for the given.
+/// Row group and column chunk.
+::arrow::io::ReadRange computeColumnChunkRange(
+    FileMetaData* fileMetadata,
+    int64_t sourceSize,
+    int rowGroupIndex,
+    int columnIndex) {
+  auto rowGroupMetadata = fileMetadata->rowGroup(rowGroupIndex);
+  auto columnMetadata = rowGroupMetadata->columnChunk(columnIndex);
+
+  int64_t colStart = columnMetadata->dataPageOffset();
+  if (columnMetadata->hasDictionaryPage() &&
+      columnMetadata->dictionaryPageOffset() > 0 &&
+      colStart > columnMetadata->dictionaryPageOffset()) {
+    colStart = columnMetadata->dictionaryPageOffset();
   }
 
-  int64_t col_length = column_metadata->total_compressed_size();
-  int64_t col_end;
-  if (col_start < 0 || col_length < 0) {
+  int64_t colLength = columnMetadata->totalCompressedSize();
+  int64_t colEnd;
+  if (colStart < 0 || colLength < 0) {
     throw ParquetException("Invalid column metadata (corrupt file?)");
   }
 
-  if (AddWithOverflow(col_start, col_length, &col_end) ||
-      col_end > source_size) {
+  if (AddWithOverflow(colStart, colLength, &colEnd) || colEnd > sourceSize) {
     throw ParquetException("Invalid column metadata (corrupt file?)");
   }
 
-  // PARQUET-816 workaround for old files created by older parquet-mr
-  const ApplicationVersion& version = file_metadata->writer_version();
-  if (version.VersionLt(ApplicationVersion::PARQUET_816_FIXED_VERSION())) {
-    // The Parquet MR writer had a bug in 1.2.8 and below where it didn't
-    // include the dictionary page header size in total_compressed_size and
-    // total_uncompressed_size (see IMPALA-694). We add padding to compensate.
-    int64_t bytes_remaining = source_size - col_end;
-    int64_t padding = std::min<int64_t>(kMaxDictHeaderSize, bytes_remaining);
-    col_length += padding;
+  // PARQUET-816 workaround for old files created by older parquet-mr.
+  const ApplicationVersion& version = fileMetadata->writerVersion();
+  if (version.versionLt(ApplicationVersion::PARQUET_816_FIXED_VERSION())) {
+    // The Parquet MR writer had a bug in 1.2.8 and below where it didn't.
+    // Include the dictionary page header size in total_compressed_size and.
+    // Total_uncompressed_size (see IMPALA-694). We add padding to compensate.
+    int64_t bytesRemaining = sourceSize - colEnd;
+    int64_t padding = std::min<int64_t>(kMaxDictHeaderSize, bytesRemaining);
+    colLength += padding;
   }
 
-  return {col_start, col_length};
+  return {colStart, colLength};
 }
 
-// RowGroupReader::Contents implementation for the Parquet file specification
+// RowGroupReader::Contents implementation for the Parquet file specification.
 class SerializedRowGroup : public RowGroupReader::Contents {
  public:
   SerializedRowGroup(
       std::shared_ptr<ArrowInputFile> source,
-      std::shared_ptr<::arrow::io::internal::ReadRangeCache> cached_source,
-      int64_t source_size,
-      FileMetaData* file_metadata,
-      int row_group_number,
+      std::shared_ptr<::arrow::io::internal::ReadRangeCache> cachedSource,
+      int64_t sourceSize,
+      FileMetaData* fileMetadata,
+      int rowGroupNumber,
       const ReaderProperties& props,
-      std::shared_ptr<Buffer> prebuffered_column_chunks_bitmap,
-      std::shared_ptr<InternalFileDecryptor> file_decryptor = nullptr)
+      std::shared_ptr<Buffer> prebufferedColumnChunksBitmap,
+      std::shared_ptr<InternalFileDecryptor> fileDecryptor = nullptr)
       : source_(std::move(source)),
-        cached_source_(std::move(cached_source)),
-        source_size_(source_size),
-        file_metadata_(file_metadata),
+        cachedSource_(std::move(cachedSource)),
+        sourceSize_(sourceSize),
+        fileMetadata_(fileMetadata),
         properties_(props),
-        row_group_ordinal_(row_group_number),
-        prebuffered_column_chunks_bitmap_(
-            std::move(prebuffered_column_chunks_bitmap)),
-        file_decryptor_(file_decryptor) {
-    row_group_metadata_ = file_metadata->RowGroup(row_group_number);
+        rowGroupOrdinal_(rowGroupNumber),
+        prebufferedColumnChunksBitmap_(
+            std::move(prebufferedColumnChunksBitmap)),
+        fileDecryptor_(fileDecryptor) {
+    rowGroupMetadata_ = fileMetadata->rowGroup(rowGroupNumber);
   }
 
   const RowGroupMetaData* metadata() const override {
-    return row_group_metadata_.get();
+    return rowGroupMetadata_.get();
   }
 
   const ReaderProperties* properties() const override {
     return &properties_;
   }
 
-  std::unique_ptr<PageReader> GetColumnPageReader(int i) override {
-    // Read column chunk from the file
-    auto col = row_group_metadata_->ColumnChunk(i);
+  std::unique_ptr<PageReader> getColumnPageReader(int i) override {
+    // Read column chunk from the file.
+    auto col = rowGroupMetadata_->columnChunk(i);
 
-    ::arrow::io::ReadRange col_range = ComputeColumnChunkRange(
-        file_metadata_, source_size_, row_group_ordinal_, i);
+    ::arrow::io::ReadRange colRange = computeColumnChunkRange(
+        fileMetadata_, sourceSize_, rowGroupOrdinal_, i);
     std::shared_ptr<ArrowInputStream> stream;
-    if (cached_source_ && prebuffered_column_chunks_bitmap_ != nullptr &&
-        ::arrow::bit_util::GetBit(
-            prebuffered_column_chunks_bitmap_->data(), i)) {
-      // PARQUET-1698: if read coalescing is enabled, read from pre-buffered
-      // segments.
-      PARQUET_ASSIGN_OR_THROW(auto buffer, cached_source_->Read(col_range));
+    if (cachedSource_ && prebufferedColumnChunksBitmap_ != nullptr &&
+        ::arrow::bit_util::GetBit(prebufferedColumnChunksBitmap_->data(), i)) {
+      // PARQUET-1698: if read coalescing is enabled, read from pre-buffered.
+      // Segments.
+      PARQUET_ASSIGN_OR_THROW(auto buffer, cachedSource_->Read(colRange));
       stream = std::make_shared<::arrow::io::BufferReader>(buffer);
     } else {
-      stream =
-          properties_.GetStream(source_, col_range.offset, col_range.length);
+      stream = properties_.getStream(source_, colRange.offset, colRange.length);
     }
 
-    std::unique_ptr<ColumnCryptoMetaData> crypto_metadata =
-        col->crypto_metadata();
+    std::unique_ptr<ColumnCryptoMetaData> cryptoMetadata =
+        col->cryptoMetadata();
 
-    // Prior to Arrow 3.0.0, is_compressed was always set to false in column
-    // headers, even if compression was used. See ARROW-17100.
-    bool always_compressed = file_metadata_->writer_version().VersionLt(
+    // Prior to Arrow 3.0.0, is_compressed was always set to false in column.
+    // Headers, even if compression was used. See ARROW-17100.
+    bool alwaysCompressed = fileMetadata_->writerVersion().versionLt(
         ApplicationVersion::PARQUET_CPP_10353_FIXED_VERSION());
 
     // Column is encrypted only if crypto_metadata exists.
-    if (!crypto_metadata) {
-      return PageReader::Open(
+    if (!cryptoMetadata) {
+      return PageReader::open(
           stream,
-          col->num_values(),
+          col->numValues(),
           col->compression(),
           properties_,
-          always_compressed);
+          alwaysCompressed);
     }
 
-    if (file_decryptor_ == nullptr) {
+    if (fileDecryptor_ == nullptr) {
       throw ParquetException(
           "RowGroup is noted as encrypted but no file decryptor");
     }
@@ -264,420 +260,415 @@ class SerializedRowGroup : public RowGroupReader::Contents {
           "Encrypted files cannot contain more than 32767 row groups");
     }
 
-    // The column is encrypted
-    std::shared_ptr<Decryptor> meta_decryptor;
-    std::shared_ptr<Decryptor> data_decryptor;
-    // The column is encrypted with footer key
-    if (crypto_metadata->encrypted_with_footer_key()) {
-      meta_decryptor = file_decryptor_->GetFooterDecryptorForColumnMeta();
-      data_decryptor = file_decryptor_->GetFooterDecryptorForColumnData();
+    // The column is encrypted.
+    std::shared_ptr<Decryptor> metaDecryptor;
+    std::shared_ptr<Decryptor> dataDecryptor;
+    // The column is encrypted with footer key.
+    if (cryptoMetadata->encryptedWithFooterKey()) {
+      metaDecryptor = fileDecryptor_->getFooterDecryptorForColumnMeta();
+      dataDecryptor = fileDecryptor_->getFooterDecryptorForColumnData();
       CryptoContext ctx(
-          col->has_dictionary_page(),
-          row_group_ordinal_,
+          col->hasDictionaryPage(),
+          rowGroupOrdinal_,
           static_cast<int16_t>(i),
-          meta_decryptor,
-          data_decryptor);
-      return PageReader::Open(
+          metaDecryptor,
+          dataDecryptor);
+      return PageReader::open(
           stream,
-          col->num_values(),
+          col->numValues(),
           col->compression(),
           properties_,
-          always_compressed,
+          alwaysCompressed,
           &ctx);
     }
 
-    // The column is encrypted with its own key
-    std::string column_key_metadata = crypto_metadata->key_metadata();
-    const std::string column_path =
-        crypto_metadata->path_in_schema()->ToDotString();
+    // The column is encrypted with its own key.
+    std::string columnKeyMetadata = cryptoMetadata->keyMetadata();
+    const std::string ColumnPath =
+        cryptoMetadata->pathInSchema()->toDotString();
 
-    meta_decryptor = file_decryptor_->GetColumnMetaDecryptor(
-        column_path, column_key_metadata);
-    data_decryptor = file_decryptor_->GetColumnDataDecryptor(
-        column_path, column_key_metadata);
+    metaDecryptor =
+        fileDecryptor_->getColumnMetaDecryptor(ColumnPath, columnKeyMetadata);
+    dataDecryptor =
+        fileDecryptor_->getColumnDataDecryptor(ColumnPath, columnKeyMetadata);
 
     CryptoContext ctx(
-        col->has_dictionary_page(),
-        row_group_ordinal_,
+        col->hasDictionaryPage(),
+        rowGroupOrdinal_,
         static_cast<int16_t>(i),
-        meta_decryptor,
-        data_decryptor);
-    return PageReader::Open(
+        metaDecryptor,
+        dataDecryptor);
+    return PageReader::open(
         stream,
-        col->num_values(),
+        col->numValues(),
         col->compression(),
         properties_,
-        always_compressed,
+        alwaysCompressed,
         &ctx);
   }
 
  private:
   std::shared_ptr<ArrowInputFile> source_;
   // Will be nullptr if PreBuffer() is not called.
-  std::shared_ptr<::arrow::io::internal::ReadRangeCache> cached_source_;
-  int64_t source_size_;
-  FileMetaData* file_metadata_;
-  std::unique_ptr<RowGroupMetaData> row_group_metadata_;
+  std::shared_ptr<::arrow::io::internal::ReadRangeCache> cachedSource_;
+  int64_t sourceSize_;
+  FileMetaData* fileMetadata_;
+  std::unique_ptr<RowGroupMetaData> rowGroupMetadata_;
   ReaderProperties properties_;
-  int row_group_ordinal_;
-  const std::shared_ptr<Buffer> prebuffered_column_chunks_bitmap_;
-  std::shared_ptr<InternalFileDecryptor> file_decryptor_;
+  int rowGroupOrdinal_;
+  const std::shared_ptr<Buffer> prebufferedColumnChunksBitmap_;
+  std::shared_ptr<InternalFileDecryptor> fileDecryptor_;
 };
 
-// ----------------------------------------------------------------------
-// SerializedFile: An implementation of ParquetFileReader::Contents that deals
-// with the Parquet file structure, Thrift deserialization, and other internal
-// matters
+// ----------------------------------------------------------------------.
+// SerializedFile: An implementation of ParquetFileReader::Contents that deals.
+// With the Parquet file structure, Thrift deserialization, and other internal.
+// Matters.
 
-// This class takes ownership of the provided data source
+// This class takes ownership of the provided data source.
 class SerializedFile : public ParquetFileReader::Contents {
  public:
   SerializedFile(
       std::shared_ptr<ArrowInputFile> source,
-      const ReaderProperties& props = default_reader_properties())
+      const ReaderProperties& props = defaultReaderProperties())
       : source_(std::move(source)), properties_(props) {
-    PARQUET_ASSIGN_OR_THROW(source_size_, source_->GetSize());
+    PARQUET_ASSIGN_OR_THROW(sourceSize_, source_->GetSize());
   }
 
   ~SerializedFile() override {
     try {
-      Close();
+      close();
     } catch (...) {
     }
   }
 
-  void Close() override {
-    if (file_decryptor_)
-      file_decryptor_->WipeOutDecryptionKeys();
+  void close() override {
+    if (fileDecryptor_)
+      fileDecryptor_->wipeOutDecryptionKeys();
   }
 
-  std::shared_ptr<RowGroupReader> GetRowGroup(int i) override {
-    std::shared_ptr<Buffer> prebuffered_column_chunks_bitmap;
+  std::shared_ptr<RowGroupReader> getRowGroup(int i) override {
+    std::shared_ptr<Buffer> prebufferedColumnChunksBitmap;
     // Avoid updating the bitmap as this function can be called concurrently.
     // The bitmap can only be updated within Prebuffer().
-    auto prebuffered_column_chunks_iter = prebuffered_column_chunks_.find(i);
-    if (prebuffered_column_chunks_iter != prebuffered_column_chunks_.end()) {
-      prebuffered_column_chunks_bitmap = prebuffered_column_chunks_iter->second;
+    auto prebufferedColumnChunksIter = prebufferedColumnChunks_.find(i);
+    if (prebufferedColumnChunksIter != prebufferedColumnChunks_.end()) {
+      prebufferedColumnChunksBitmap = prebufferedColumnChunksIter->second;
     }
 
     std::unique_ptr<SerializedRowGroup> contents =
         std::make_unique<SerializedRowGroup>(
             source_,
-            cached_source_,
-            source_size_,
-            file_metadata_.get(),
+            cachedSource_,
+            sourceSize_,
+            fileMetadata_.get(),
             i,
             properties_,
-            std::move(prebuffered_column_chunks_bitmap),
-            file_decryptor_);
+            std::move(prebufferedColumnChunksBitmap),
+            fileDecryptor_);
     return std::make_shared<RowGroupReader>(std::move(contents));
   }
 
   std::shared_ptr<FileMetaData> metadata() const override {
-    return file_metadata_;
+    return fileMetadata_;
   }
 
-  std::shared_ptr<PageIndexReader> GetPageIndexReader() override {
-    if (!file_metadata_) {
+  std::shared_ptr<PageIndexReader> getPageIndexReader() override {
+    if (!fileMetadata_) {
       // Usually this won't happen if user calls one of the static Open()
-      // functions to create a ParquetFileReader instance. But if user calls the
-      // constructor directly and calls GetPageIndexReader() before Open() then
-      // this could happen.
+      // Functions to create a ParquetFileReader instance. But if user calls
+      // the. Constructor directly and calls GetPageIndexReader() before Open()
+      // then. This could happen.
       throw ParquetException(
           "Cannot call GetPageIndexReader() due to missing file metadata. Did you "
           "forget to call ParquetFileReader::Open() first?");
     }
-    if (!page_index_reader_) {
-      page_index_reader_ = PageIndexReader::Make(
-          source_.get(), file_metadata_, properties_, file_decryptor_);
+    if (!pageIndexReader_) {
+      pageIndexReader_ = PageIndexReader::make(
+          source_.get(), fileMetadata_, properties_, fileDecryptor_);
     }
-    return page_index_reader_;
+    return pageIndexReader_;
   }
 
-  BloomFilterReader& GetBloomFilterReader() override {
-    if (!file_metadata_) {
+  BloomFilterReader& getBloomFilterReader() override {
+    if (!fileMetadata_) {
       // Usually this won't happen if user calls one of the static Open()
-      // functions to create a ParquetFileReader instance. But if user calls the
-      // constructor directly and calls GetBloomFilterReader() before Open()
-      // then this could happen.
+      // Functions to create a ParquetFileReader instance. But if user calls
+      // the. constructor directly and calls GetBloomFilterReader() before
+      // Open() Then this could happen.
       throw ParquetException(
           "Cannot call GetBloomFilterReader() due to missing file metadata. Did you "
           "forget to call ParquetFileReader::Open() first?");
     }
-    if (!bloom_filter_reader_) {
-      bloom_filter_reader_ = BloomFilterReader::Make(
-          source_, file_metadata_, properties_, file_decryptor_);
-      if (bloom_filter_reader_ == nullptr) {
+    if (!bloomFilterReader_) {
+      bloomFilterReader_ = BloomFilterReader::make(
+          source_, fileMetadata_, properties_, fileDecryptor_);
+      if (bloomFilterReader_ == nullptr) {
         throw ParquetException("Cannot create BloomFilterReader");
       }
     }
-    return *bloom_filter_reader_;
+    return *bloomFilterReader_;
   }
 
-  void set_metadata(std::shared_ptr<FileMetaData> metadata) {
-    file_metadata_ = std::move(metadata);
+  void setMetadata(std::shared_ptr<FileMetaData> metadata) {
+    fileMetadata_ = std::move(metadata);
   }
 
-  void PreBuffer(
-      const std::vector<int>& row_groups,
-      const std::vector<int>& column_indices,
+  void preBuffer(
+      const std::vector<int>& rowGroups,
+      const std::vector<int>& columnIndices,
       const ::arrow::io::IOContext& ctx,
       const ::arrow::io::CacheOptions& options) {
-    cached_source_ = std::make_shared<::arrow::io::internal::ReadRangeCache>(
+    cachedSource_ = std::make_shared<::arrow::io::internal::ReadRangeCache>(
         source_, ctx, options);
     std::vector<::arrow::io::ReadRange> ranges;
-    prebuffered_column_chunks_.clear();
-    for (int row : row_groups) {
-      std::shared_ptr<Buffer>& col_bitmap = prebuffered_column_chunks_[row];
-      int num_cols = file_metadata_->num_columns();
+    prebufferedColumnChunks_.clear();
+    for (int row : rowGroups) {
+      std::shared_ptr<Buffer>& colBitmap = prebufferedColumnChunks_[row];
+      int numCols = fileMetadata_->numColumns();
       PARQUET_THROW_NOT_OK(
-          AllocateEmptyBitmap(num_cols, properties_.memory_pool())
-              .Value(&col_bitmap));
-      for (int col : column_indices) {
-        ::arrow::bit_util::SetBit(col_bitmap->mutable_data(), col);
-        ranges.push_back(ComputeColumnChunkRange(
-            file_metadata_.get(), source_size_, row, col));
+          ::arrow::AllocateEmptyBitmap(numCols, properties_.memoryPool())
+              .Value(&colBitmap));
+      for (int col : columnIndices) {
+        ::arrow::bit_util::SetBit(colBitmap->mutable_data(), col);
+        ranges.push_back(computeColumnChunkRange(
+            fileMetadata_.get(), sourceSize_, row, col));
       }
     }
-    PARQUET_THROW_NOT_OK(cached_source_->Cache(ranges));
+    PARQUET_THROW_NOT_OK(cachedSource_->Cache(ranges));
   }
 
-  ::arrow::Future<> WhenBuffered(
-      const std::vector<int>& row_groups,
-      const std::vector<int>& column_indices) const {
-    if (!cached_source_) {
+  ::arrow::Future<> whenBuffered(
+      const std::vector<int>& rowGroups,
+      const std::vector<int>& columnIndices) const {
+    if (!cachedSource_) {
       return ::arrow::Status::Invalid(
           "Must call PreBuffer before WhenBuffered");
     }
     std::vector<::arrow::io::ReadRange> ranges;
-    for (int row : row_groups) {
-      for (int col : column_indices) {
-        ranges.push_back(ComputeColumnChunkRange(
-            file_metadata_.get(), source_size_, row, col));
+    for (int row : rowGroups) {
+      for (int col : columnIndices) {
+        ranges.push_back(computeColumnChunkRange(
+            fileMetadata_.get(), sourceSize_, row, col));
       }
     }
-    return cached_source_->WaitFor(ranges);
+    return cachedSource_->WaitFor(ranges);
   }
 
-  // Metadata/footer parsing. Divided up to separate sync/async paths, and to
-  // use exceptions for error handling (with the async path converting to
+  // Metadata/footer parsing. Divided up to separate sync/async paths, and to.
+  // Use exceptions for error handling (with the async path converting to.
   // Future/Status).
 
-  void ParseMetaData() {
-    int64_t footer_read_size = GetFooterReadSize();
+  void parseMetaData() {
+    int64_t footerReadSize = getFooterReadSize();
     PARQUET_ASSIGN_OR_THROW(
-        auto footer_buffer,
-        source_->ReadAt(source_size_ - footer_read_size, footer_read_size));
-    uint32_t metadata_len = ParseFooterLength(footer_buffer, footer_read_size);
-    int64_t metadata_start = source_size_ - kFooterSize - metadata_len;
-
-    std::shared_ptr<::arrow::Buffer> metadata_buffer;
-    if (footer_read_size >= (metadata_len + kFooterSize)) {
-      metadata_buffer = SliceBuffer(
-          footer_buffer,
-          footer_read_size - metadata_len - kFooterSize,
-          metadata_len);
+        auto footerBuffer,
+        source_->ReadAt(sourceSize_ - footerReadSize, footerReadSize));
+    uint32_t metadataLen = parseFooterLength(footerBuffer, footerReadSize);
+    int64_t metadataStart = sourceSize_ - kFooterSize - metadataLen;
+
+    std::shared_ptr<::arrow::Buffer> metadataBuffer;
+    if (footerReadSize >= (metadataLen + kFooterSize)) {
+      metadataBuffer = ::arrow::SliceBuffer(
+          footerBuffer,
+          footerReadSize - metadataLen - kFooterSize,
+          metadataLen);
     } else {
       PARQUET_ASSIGN_OR_THROW(
-          metadata_buffer, source_->ReadAt(metadata_start, metadata_len));
+          metadataBuffer, source_->ReadAt(metadataStart, metadataLen));
     }
 
-    // Parse the footer depending on encryption type
-    const bool is_encrypted_footer =
-        memcmp(
-            footer_buffer->data() + footer_read_size - 4, kParquetEMagic, 4) ==
+    // Parse the footer depending on encryption type.
+    const bool isEncryptedFooter =
+        memcmp(footerBuffer->data() + footerReadSize - 4, kParquetEMagic, 4) ==
         0;
-    if (is_encrypted_footer) {
+    if (isEncryptedFooter) {
       // Encrypted file with Encrypted footer.
-      const std::pair<int64_t, uint32_t> read_size =
-          ParseMetaDataOfEncryptedFileWithEncryptedFooter(
-              metadata_buffer, metadata_len);
-      // Read the actual footer
-      metadata_start = read_size.first;
-      metadata_len = read_size.second;
+      const std::pair<int64_t, uint32_t> readSize =
+          parseMetaDataOfEncryptedFileWithEncryptedFooter(
+              metadataBuffer, metadataLen);
+      // Read the actual footer.
+      metadataStart = readSize.first;
+      metadataLen = readSize.second;
       PARQUET_ASSIGN_OR_THROW(
-          metadata_buffer, source_->ReadAt(metadata_start, metadata_len));
-      // Fall through
+          metadataBuffer, source_->ReadAt(metadataStart, metadataLen));
+      // Fall through.
     }
 
-    const uint32_t read_metadata_len =
-        ParseUnencryptedFileMetadata(metadata_buffer, metadata_len);
-    auto file_decryption_properties =
-        properties_.file_decryption_properties().get();
-    if (is_encrypted_footer) {
+    const uint32_t readMetadataLen =
+        parseUnencryptedFileMetadata(metadataBuffer, metadataLen);
+    auto fileDecryptionProperties =
+        properties_.fileDecryptionProperties().get();
+    if (isEncryptedFooter) {
       // Nothing else to do here.
       return;
-    } else if (!file_metadata_
-                    ->is_encryption_algorithm_set()) { // Non encrypted file.
-      if (file_decryption_properties != nullptr) {
-        if (!file_decryption_properties->plaintext_files_allowed()) {
+    } else if (!fileMetadata_
+                    ->isEncryptionAlgorithmSet()) { // Non encrypted file.
+      if (fileDecryptionProperties != nullptr) {
+        if (!fileDecryptionProperties->plaintextFilesAllowed()) {
           throw ParquetException(
               "Applying decryption properties on plaintext file");
         }
       }
     } else {
       // Encrypted file with plaintext footer mode.
-      ParseMetaDataOfEncryptedFileWithPlaintextFooter(
-          file_decryption_properties,
-          metadata_buffer,
-          metadata_len,
-          read_metadata_len);
+      parseMetaDataOfEncryptedFileWithPlaintextFooter(
+          fileDecryptionProperties,
+          metadataBuffer,
+          metadataLen,
+          readMetadataLen);
     }
   }
 
   // Validate the source size and get the initial read size.
-  int64_t GetFooterReadSize() {
-    if (source_size_ == 0) {
+  int64_t getFooterReadSize() {
+    if (sourceSize_ == 0) {
       throw ParquetInvalidOrCorruptedFileException(
           "Parquet file size is 0 bytes");
-    } else if (source_size_ < kFooterSize) {
+    } else if (sourceSize_ < kFooterSize) {
       throw ParquetInvalidOrCorruptedFileException(
           "Parquet file size is ",
-          source_size_,
+          sourceSize_,
           " bytes, smaller than the minimum file footer (",
           kFooterSize,
           " bytes)");
     }
-    return std::min(source_size_, kDefaultFooterReadSize);
+    return std::min(sourceSize_, kDefaultFooterReadSize);
   }
 
   // Validate the magic bytes and get the length of the full footer.
-  uint32_t ParseFooterLength(
-      const std::shared_ptr<::arrow::Buffer>& footer_buffer,
-      const int64_t footer_read_size) {
-    // Check if all bytes are read. Check if last 4 bytes read have the magic
-    // bits
-    if (footer_buffer->size() != footer_read_size ||
-        (memcmp(
-             footer_buffer->data() + footer_read_size - 4, kParquetMagic, 4) !=
+  uint32_t parseFooterLength(
+      const std::shared_ptr<::arrow::Buffer>& footerBuffer,
+      const int64_t footerReadSize) {
+    // Check if all bytes are read. Check if last 4 bytes read have the magic.
+    // Bits.
+    if (footerBuffer->size() != footerReadSize ||
+        (memcmp(footerBuffer->data() + footerReadSize - 4, kParquetMagic, 4) !=
              0 &&
-         memcmp(
-             footer_buffer->data() + footer_read_size - 4, kParquetEMagic, 4) !=
+         memcmp(footerBuffer->data() + footerReadSize - 4, kParquetEMagic, 4) !=
              0)) {
       throw ParquetInvalidOrCorruptedFileException(
           "Parquet magic bytes not found in footer. Either the file is corrupted or this "
           "is not a parquet file.");
     }
     // Both encrypted/unencrypted footers have the same footer length check.
-    uint32_t metadata_len = ::arrow::util::SafeLoadAs<uint32_t>(
-        reinterpret_cast<const uint8_t*>(footer_buffer->data()) +
-        footer_read_size - kFooterSize);
-    if (metadata_len > source_size_ - kFooterSize) {
+    uint32_t metadataLen = ::arrow::util::SafeLoadAs<uint32_t>(
+        reinterpret_cast<const uint8_t*>(footerBuffer->data()) +
+        footerReadSize - kFooterSize);
+    if (metadataLen > sourceSize_ - kFooterSize) {
       throw ParquetInvalidOrCorruptedFileException(
           "Parquet file size is ",
-          source_size_,
+          sourceSize_,
           " bytes, smaller than the size reported by footer's (",
-          metadata_len,
+          metadataLen,
           "bytes)");
     }
-    return metadata_len;
+    return metadataLen;
   }
 
   // Does not throw.
-  ::arrow::Future<> ParseMetaDataAsync() {
-    int64_t footer_read_size;
+  ::arrow::Future<> parseMetaDataAsync() {
+    int64_t footerReadSize;
     BEGIN_PARQUET_CATCH_EXCEPTIONS
-    footer_read_size = GetFooterReadSize();
+    footerReadSize = getFooterReadSize();
     END_PARQUET_CATCH_EXCEPTIONS
-    // Assumes this is kept alive externally
-    return source_->ReadAsync(source_size_ - footer_read_size, footer_read_size)
+    // Assumes this is kept alive externally.
+    return source_->ReadAsync(sourceSize_ - footerReadSize, footerReadSize)
         .Then(
-            [this, footer_read_size](
-                const std::shared_ptr<::arrow::Buffer>& footer_buffer)
+            [this, footerReadSize](
+                const std::shared_ptr<::arrow::Buffer>& footerBuffer)
                 -> ::arrow::Future<> {
-              uint32_t metadata_len;
+              uint32_t metadataLen;
               BEGIN_PARQUET_CATCH_EXCEPTIONS
-              metadata_len = ParseFooterLength(footer_buffer, footer_read_size);
+              metadataLen = parseFooterLength(footerBuffer, footerReadSize);
               END_PARQUET_CATCH_EXCEPTIONS
-              int64_t metadata_start =
-                  source_size_ - kFooterSize - metadata_len;
-
-              std::shared_ptr<::arrow::Buffer> metadata_buffer;
-              if (footer_read_size >= (metadata_len + kFooterSize)) {
-                metadata_buffer = SliceBuffer(
-                    footer_buffer,
-                    footer_read_size - metadata_len - kFooterSize,
-                    metadata_len);
-                return ParseMaybeEncryptedMetaDataAsync(
-                    footer_buffer,
-                    std::move(metadata_buffer),
-                    footer_read_size,
-                    metadata_len);
+              int64_t metadataStart = sourceSize_ - kFooterSize - metadataLen;
+
+              std::shared_ptr<::arrow::Buffer> metadataBuffer;
+              if (footerReadSize >= (metadataLen + kFooterSize)) {
+                metadataBuffer = ::arrow::SliceBuffer(
+                    footerBuffer,
+                    footerReadSize - metadataLen - kFooterSize,
+                    metadataLen);
+                return parseMaybeEncryptedMetaDataAsync(
+                    footerBuffer,
+                    std::move(metadataBuffer),
+                    footerReadSize,
+                    metadataLen);
               }
-              return source_->ReadAsync(metadata_start, metadata_len)
-                  .Then([this, footer_buffer, footer_read_size, metadata_len](
+              return source_->ReadAsync(metadataStart, metadataLen)
+                  .Then([this, footerBuffer, footerReadSize, metadataLen](
                             const std::shared_ptr<::arrow::Buffer>&
-                                metadata_buffer) {
-                    return ParseMaybeEncryptedMetaDataAsync(
-                        footer_buffer,
-                        metadata_buffer,
-                        footer_read_size,
-                        metadata_len);
+                                metadataBuffer) {
+                    return parseMaybeEncryptedMetaDataAsync(
+                        footerBuffer,
+                        metadataBuffer,
+                        footerReadSize,
+                        metadataLen);
                   });
             });
   }
 
-  // Continuation
-  ::arrow::Future<> ParseMaybeEncryptedMetaDataAsync(
-      std::shared_ptr<::arrow::Buffer> footer_buffer,
-      std::shared_ptr<::arrow::Buffer> metadata_buffer,
-      int64_t footer_read_size,
-      uint32_t metadata_len) {
-    // Parse the footer depending on encryption type
-    const bool is_encrypted_footer =
-        memcmp(
-            footer_buffer->data() + footer_read_size - 4, kParquetEMagic, 4) ==
+  // Continuation.
+  ::arrow::Future<> parseMaybeEncryptedMetaDataAsync(
+      std::shared_ptr<::arrow::Buffer> footerBuffer,
+      std::shared_ptr<::arrow::Buffer> metadataBuffer,
+      int64_t footerReadSize,
+      uint32_t metadataLen) {
+    // Parse the footer depending on encryption type.
+    const bool isEncryptedFooter =
+        memcmp(footerBuffer->data() + footerReadSize - 4, kParquetEMagic, 4) ==
         0;
-    if (is_encrypted_footer) {
+    if (isEncryptedFooter) {
       // Encrypted file with Encrypted footer.
-      std::pair<int64_t, uint32_t> read_size;
+      std::pair<int64_t, uint32_t> readSize;
       BEGIN_PARQUET_CATCH_EXCEPTIONS
-      read_size = ParseMetaDataOfEncryptedFileWithEncryptedFooter(
-          metadata_buffer, metadata_len);
+      readSize = parseMetaDataOfEncryptedFileWithEncryptedFooter(
+          metadataBuffer, metadataLen);
       END_PARQUET_CATCH_EXCEPTIONS
-      // Read the actual footer
-      int64_t metadata_start = read_size.first;
-      metadata_len = read_size.second;
-      return source_->ReadAsync(metadata_start, metadata_len)
-          .Then([this, metadata_len, is_encrypted_footer](
-                    const std::shared_ptr<::arrow::Buffer>& metadata_buffer) {
-            // Continue and read the file footer
-            return ParseMetaDataFinal(
-                metadata_buffer, metadata_len, is_encrypted_footer);
+      // Read the actual footer.
+      int64_t metadataStart = readSize.first;
+      metadataLen = readSize.second;
+      return source_->ReadAsync(metadataStart, metadataLen)
+          .Then([this, metadataLen, isEncryptedFooter](
+                    const std::shared_ptr<::arrow::Buffer>& metadataBuffer) {
+            // Continue and read the file footer.
+            return parseMetaDataFinal(
+                metadataBuffer, metadataLen, isEncryptedFooter);
           });
     }
-    return ParseMetaDataFinal(
-        std::move(metadata_buffer), metadata_len, is_encrypted_footer);
+    return parseMetaDataFinal(
+        std::move(metadataBuffer), metadataLen, isEncryptedFooter);
   }
 
-  // Continuation
-  ::arrow::Status ParseMetaDataFinal(
-      std::shared_ptr<::arrow::Buffer> metadata_buffer,
-      uint32_t metadata_len,
-      const bool is_encrypted_footer) {
+  // Continuation.
+  ::arrow::Status parseMetaDataFinal(
+      std::shared_ptr<::arrow::Buffer> metadataBuffer,
+      uint32_t metadataLen,
+      const bool isEncryptedFooter) {
     BEGIN_PARQUET_CATCH_EXCEPTIONS
-    const uint32_t read_metadata_len =
-        ParseUnencryptedFileMetadata(metadata_buffer, metadata_len);
-    auto file_decryption_properties =
-        properties_.file_decryption_properties().get();
-    if (is_encrypted_footer) {
+    const uint32_t readMetadataLen =
+        parseUnencryptedFileMetadata(metadataBuffer, metadataLen);
+    auto fileDecryptionProperties =
+        properties_.fileDecryptionProperties().get();
+    if (isEncryptedFooter) {
       // Nothing else to do here.
       return ::arrow::Status::OK();
-    } else if (!file_metadata_
-                    ->is_encryption_algorithm_set()) { // Non encrypted file.
-      if (file_decryption_properties != nullptr) {
-        if (!file_decryption_properties->plaintext_files_allowed()) {
+    } else if (!fileMetadata_
+                    ->isEncryptionAlgorithmSet()) { // Non encrypted file.
+      if (fileDecryptionProperties != nullptr) {
+        if (!fileDecryptionProperties->plaintextFilesAllowed()) {
           throw ParquetException(
               "Applying decryption properties on plaintext file");
         }
       }
     } else {
       // Encrypted file with plaintext footer mode.
-      ParseMetaDataOfEncryptedFileWithPlaintextFooter(
-          file_decryption_properties,
-          metadata_buffer,
-          metadata_len,
-          read_metadata_len);
+      parseMetaDataOfEncryptedFileWithPlaintextFooter(
+          fileDecryptionProperties,
+          metadataBuffer,
+          metadataLen,
+          readMetadataLen);
     }
     END_PARQUET_CATCH_EXCEPTIONS
     return ::arrow::Status::OK();
@@ -685,130 +676,126 @@ class SerializedFile : public ParquetFileReader::Contents {
 
  private:
   std::shared_ptr<ArrowInputFile> source_;
-  std::shared_ptr<::arrow::io::internal::ReadRangeCache> cached_source_;
-  int64_t source_size_;
-  std::shared_ptr<FileMetaData> file_metadata_;
+  std::shared_ptr<::arrow::io::internal::ReadRangeCache> cachedSource_;
+  int64_t sourceSize_;
+  std::shared_ptr<FileMetaData> fileMetadata_;
   ReaderProperties properties_;
-  std::shared_ptr<PageIndexReader> page_index_reader_;
-  std::unique_ptr<BloomFilterReader> bloom_filter_reader_;
-  // Maps row group ordinal and prebuffer status of its column chunks in the
-  // form of a bitmap buffer.
-  std::unordered_map<int, std::shared_ptr<Buffer>> prebuffered_column_chunks_;
-  std::shared_ptr<InternalFileDecryptor> file_decryptor_;
-
-  // \return The true length of the metadata in bytes
-  uint32_t ParseUnencryptedFileMetadata(
-      const std::shared_ptr<Buffer>& footer_buffer,
-      const uint32_t metadata_len);
-
-  std::string HandleAadPrefix(
-      FileDecryptionProperties* file_decryption_properties,
+  std::shared_ptr<PageIndexReader> pageIndexReader_;
+  std::unique_ptr<BloomFilterReader> bloomFilterReader_;
+  // Maps row group ordinal and prebuffer status of its column chunks in the.
+  // Form of a bitmap buffer.
+  std::unordered_map<int, std::shared_ptr<Buffer>> prebufferedColumnChunks_;
+  std::shared_ptr<InternalFileDecryptor> fileDecryptor_;
+
+  // \return The true length of the metadata in bytes.
+  uint32_t parseUnencryptedFileMetadata(
+      const std::shared_ptr<Buffer>& footerBuffer,
+      const uint32_t metadataLen);
+
+  std::string handleAadPrefix(
+      FileDecryptionProperties* fileDecryptionProperties,
       EncryptionAlgorithm& algo);
 
-  void ParseMetaDataOfEncryptedFileWithPlaintextFooter(
-      FileDecryptionProperties* file_decryption_properties,
-      const std::shared_ptr<Buffer>& metadata_buffer,
-      uint32_t metadata_len,
-      uint32_t read_metadata_len);
+  void parseMetaDataOfEncryptedFileWithPlaintextFooter(
+      FileDecryptionProperties* fileDecryptionProperties,
+      const std::shared_ptr<Buffer>& metadataBuffer,
+      uint32_t metadataLen,
+      uint32_t readMetadataLen);
 
-  // \return The position and size of the actual footer
-  std::pair<int64_t, uint32_t> ParseMetaDataOfEncryptedFileWithEncryptedFooter(
-      const std::shared_ptr<Buffer>& crypto_metadata_buffer,
-      uint32_t footer_len);
+  // \return The position and size of the actual footer.
+  std::pair<int64_t, uint32_t> parseMetaDataOfEncryptedFileWithEncryptedFooter(
+      const std::shared_ptr<Buffer>& cryptoMetadataBuffer,
+      uint32_t footerLen);
 };
 
-uint32_t SerializedFile::ParseUnencryptedFileMetadata(
-    const std::shared_ptr<Buffer>& metadata_buffer,
-    const uint32_t metadata_len) {
-  if (metadata_buffer->size() != metadata_len) {
+uint32_t SerializedFile::parseUnencryptedFileMetadata(
+    const std::shared_ptr<Buffer>& metadataBuffer,
+    const uint32_t metadataLen) {
+  if (metadataBuffer->size() != metadataLen) {
     throw ParquetException(
         "Failed reading metadata buffer (requested " +
-        std::to_string(metadata_len) + " bytes but got " +
-        std::to_string(metadata_buffer->size()) + " bytes)");
+        std::to_string(metadataLen) + " bytes but got " +
+        std::to_string(metadataBuffer->size()) + " bytes)");
   }
-  uint32_t read_metadata_len = metadata_len;
-  // The encrypted read path falls through to here, so pass in the decryptor
-  file_metadata_ = FileMetaData::Make(
-      metadata_buffer->data(),
-      &read_metadata_len,
-      properties_,
-      file_decryptor_);
-  return read_metadata_len;
+  uint32_t readMetadataLen = metadataLen;
+  // The encrypted read path falls through to here, so pass in the decryptor.
+  fileMetadata_ = FileMetaData::make(
+      metadataBuffer->data(), &readMetadataLen, properties_, fileDecryptor_);
+  return readMetadataLen;
 }
 
 std::pair<int64_t, uint32_t>
-SerializedFile::ParseMetaDataOfEncryptedFileWithEncryptedFooter(
-    const std::shared_ptr<::arrow::Buffer>& crypto_metadata_buffer,
-    // both metadata & crypto metadata length
-    const uint32_t footer_len) {
-  // encryption with encrypted footer
-  // Check if the footer_buffer contains the entire metadata
-  if (crypto_metadata_buffer->size() != footer_len) {
+SerializedFile::parseMetaDataOfEncryptedFileWithEncryptedFooter(
+    const std::shared_ptr<::arrow::Buffer>& cryptoMetadataBuffer,
+    // Both metadata & crypto metadata length.
+    const uint32_t footerLen) {
+  // Encryption with encrypted footer.
+  // Check if the footer_buffer contains the entire metadata.
+  if (cryptoMetadataBuffer->size() != footerLen) {
     throw ParquetException(
         "Failed reading encrypted metadata buffer (requested " +
-        std::to_string(footer_len) + " bytes but got " +
-        std::to_string(crypto_metadata_buffer->size()) + " bytes)");
+        std::to_string(footerLen) + " bytes but got " +
+        std::to_string(cryptoMetadataBuffer->size()) + " bytes)");
   }
-  auto file_decryption_properties =
-      properties_.file_decryption_properties().get();
-  if (file_decryption_properties == nullptr) {
+  auto fileDecryptionProperties = properties_.fileDecryptionProperties().get();
+  if (fileDecryptionProperties == nullptr) {
     throw ParquetException(
         "Could not read encrypted metadata, no decryption found in reader's properties");
   }
-  uint32_t crypto_metadata_len = footer_len;
-  std::shared_ptr<FileCryptoMetaData> file_crypto_metadata =
-      FileCryptoMetaData::Make(
-          crypto_metadata_buffer->data(), &crypto_metadata_len);
-  // Handle AAD prefix
-  EncryptionAlgorithm algo = file_crypto_metadata->encryption_algorithm();
-  std::string file_aad = HandleAadPrefix(file_decryption_properties, algo);
-  file_decryptor_ = std::make_shared<InternalFileDecryptor>(
-      file_decryption_properties,
-      file_aad,
+  uint32_t cryptoMetadataLen = footerLen;
+  std::shared_ptr<FileCryptoMetaData> fileCryptoMetadata =
+      FileCryptoMetaData::make(
+          cryptoMetadataBuffer->data(), &cryptoMetadataLen);
+  // Handle AAD prefix.
+  EncryptionAlgorithm algo = fileCryptoMetadata->encryptionAlgorithm();
+  std::string fileAad = handleAadPrefix(fileDecryptionProperties, algo);
+  fileDecryptor_ = std::make_shared<InternalFileDecryptor>(
+      fileDecryptionProperties,
+      fileAad,
       algo.algorithm,
-      file_crypto_metadata->key_metadata(),
-      properties_.memory_pool());
+      fileCryptoMetadata->keyMetadata(),
+      properties_.memoryPool());
 
-  int64_t metadata_offset =
-      source_size_ - kFooterSize - footer_len + crypto_metadata_len;
-  uint32_t metadata_len = footer_len - crypto_metadata_len;
-  return std::make_pair(metadata_offset, metadata_len);
+  int64_t metadataOffset =
+      sourceSize_ - kFooterSize - footerLen + cryptoMetadataLen;
+  uint32_t metadataLen = footerLen - cryptoMetadataLen;
+  return std::make_pair(metadataOffset, metadataLen);
 }
 
-void SerializedFile::ParseMetaDataOfEncryptedFileWithPlaintextFooter(
-    FileDecryptionProperties* file_decryption_properties,
-    const std::shared_ptr<Buffer>& metadata_buffer,
-    uint32_t metadata_len,
-    uint32_t read_metadata_len) {
-  // Providing decryption properties in plaintext footer mode is not mandatory,
-  // for example when reading by legacy reader.
-  if (file_decryption_properties != nullptr) {
-    EncryptionAlgorithm algo = file_metadata_->encryption_algorithm();
-    // Handle AAD prefix
-    std::string file_aad = HandleAadPrefix(file_decryption_properties, algo);
-    file_decryptor_ = std::make_shared<InternalFileDecryptor>(
-        file_decryption_properties,
-        file_aad,
+void SerializedFile::parseMetaDataOfEncryptedFileWithPlaintextFooter(
+    FileDecryptionProperties* fileDecryptionProperties,
+    const std::shared_ptr<Buffer>& metadataBuffer,
+    uint32_t metadataLen,
+    uint32_t readMetadataLen) {
+  // Providing decryption properties in plaintext footer mode is not mandatory,.
+  // For example when reading by legacy reader.
+  if (fileDecryptionProperties != nullptr) {
+    EncryptionAlgorithm algo = fileMetadata_->encryptionAlgorithm();
+    // Handle AAD prefix.
+    std::string fileAad = handleAadPrefix(fileDecryptionProperties, algo);
+    fileDecryptor_ = std::make_shared<InternalFileDecryptor>(
+        fileDecryptionProperties,
+        fileAad,
         algo.algorithm,
-        file_metadata_->footer_signing_key_metadata(),
-        properties_.memory_pool());
-    // set the InternalFileDecryptor in the metadata as well, as it's used
-    // for signature verification and for ColumnChunkMetaData creation.
-    file_metadata_->set_file_decryptor(file_decryptor_);
-
-    if (file_decryption_properties->check_plaintext_footer_integrity()) {
-      if (metadata_len - read_metadata_len !=
+        fileMetadata_->footerSigningKeyMetadata(),
+        properties_.memoryPool());
+    // Set the InternalFileDecryptor in the metadata as well, as it's used.
+    // For signature verification and for ColumnChunkMetaData creation.
+    fileMetadata_->setFileDecryptor(fileDecryptor_);
+
+    if (fileDecryptionProperties->checkPlaintextFooterIntegrity()) {
+      if (metadataLen - readMetadataLen !=
           (encryption::kGcmTagLength + encryption::kNonceLength)) {
         throw ParquetInvalidOrCorruptedFileException(
             "Failed reading metadata for encryption signature (requested ",
             encryption::kGcmTagLength + encryption::kNonceLength,
             " bytes but have ",
-            metadata_len - read_metadata_len,
+            metadataLen - readMetadataLen,
             " bytes)");
       }
 
-      if (!file_metadata_->VerifySignature(
-              metadata_buffer->data() + read_metadata_len)) {
+      if (!fileMetadata_->verifySignature(
+              metadataBuffer->data() + readMetadataLen)) {
         throw ParquetInvalidOrCorruptedFileException(
             "Parquet crypto signature verification failed");
       }
@@ -816,88 +803,87 @@ void SerializedFile::ParseMetaDataOfEncryptedFileWithPlaintextFooter(
   }
 }
 
-std::string SerializedFile::HandleAadPrefix(
-    FileDecryptionProperties* file_decryption_properties,
+std::string SerializedFile::handleAadPrefix(
+    FileDecryptionProperties* fileDecryptionProperties,
     EncryptionAlgorithm& algo) {
-  std::string aad_prefix_in_properties =
-      file_decryption_properties->aad_prefix();
-  std::string aad_prefix = aad_prefix_in_properties;
-  bool file_has_aad_prefix = algo.aad.aad_prefix.empty() ? false : true;
-  std::string aad_prefix_in_file = algo.aad.aad_prefix;
+  std::string aadPrefixInProperties = fileDecryptionProperties->aadPrefix();
+  std::string aadPrefix = aadPrefixInProperties;
+  bool fileHasAadPrefix = algo.aad.aadPrefix.empty() ? false : true;
+  std::string aadPrefixInFile = algo.aad.aadPrefix;
 
-  if (algo.aad.supply_aad_prefix && aad_prefix_in_properties.empty()) {
+  if (algo.aad.supplyAadPrefix && aadPrefixInProperties.empty()) {
     throw ParquetException(
         "AAD prefix used for file encryption, "
         "but not stored in file and not supplied "
         "in decryption properties");
   }
 
-  if (file_has_aad_prefix) {
-    if (!aad_prefix_in_properties.empty()) {
-      if (aad_prefix_in_properties.compare(aad_prefix_in_file) != 0) {
+  if (fileHasAadPrefix) {
+    if (!aadPrefixInProperties.empty()) {
+      if (aadPrefixInProperties.compare(aadPrefixInFile) != 0) {
         throw ParquetException(
             "AAD Prefix in file and in properties "
             "is not the same");
       }
     }
-    aad_prefix = aad_prefix_in_file;
-    std::shared_ptr<AADPrefixVerifier> aad_prefix_verifier =
-        file_decryption_properties->aad_prefix_verifier();
-    if (aad_prefix_verifier != nullptr)
-      aad_prefix_verifier->Verify(aad_prefix);
+    aadPrefix = aadPrefixInFile;
+    std::shared_ptr<AADPrefixVerifier> aadPrefixVerifier =
+        fileDecryptionProperties->aadPrefixVerifier();
+    if (aadPrefixVerifier != nullptr)
+      aadPrefixVerifier->verify(aadPrefix);
   } else {
-    if (!algo.aad.supply_aad_prefix && !aad_prefix_in_properties.empty()) {
+    if (!algo.aad.supplyAadPrefix && !aadPrefixInProperties.empty()) {
       throw ParquetException(
           "AAD Prefix set in decryption properties, but was not used "
           "for file encryption");
     }
-    std::shared_ptr<AADPrefixVerifier> aad_prefix_verifier =
-        file_decryption_properties->aad_prefix_verifier();
-    if (aad_prefix_verifier != nullptr) {
+    std::shared_ptr<AADPrefixVerifier> aadPrefixVerifier =
+        fileDecryptionProperties->aadPrefixVerifier();
+    if (aadPrefixVerifier != nullptr) {
       throw ParquetException(
           "AAD Prefix Verifier is set, but AAD Prefix not found in file");
     }
   }
-  return aad_prefix + algo.aad.aad_file_unique;
+  return aadPrefix + algo.aad.aadFileUnique;
 }
 
-// ----------------------------------------------------------------------
-// ParquetFileReader public API
+// ----------------------------------------------------------------------.
+// ParquetFileReader public API.
 
 ParquetFileReader::ParquetFileReader() {}
 
 ParquetFileReader::~ParquetFileReader() {
   try {
-    Close();
+    close();
   } catch (...) {
   }
 }
 
-// Open the file. If no metadata is passed, it is parsed from the footer of
-// the file
-std::unique_ptr<ParquetFileReader::Contents> ParquetFileReader::Contents::Open(
+// Open the file. If no metadata is passed, it is parsed from the footer of.
+// The file.
+std::unique_ptr<ParquetFileReader::Contents> ParquetFileReader::Contents::open(
     std::shared_ptr<ArrowInputFile> source,
     const ReaderProperties& props,
     std::shared_ptr<FileMetaData> metadata) {
   std::unique_ptr<ParquetFileReader::Contents> result(
       new SerializedFile(std::move(source), props));
 
-  // Access private methods here, but otherwise unavailable
+  // Access private methods here, but otherwise unavailable.
   SerializedFile* file = static_cast<SerializedFile*>(result.get());
 
   if (metadata == nullptr) {
-    // Validates magic bytes, parses metadata, and initializes the
-    // SchemaDescriptor
-    file->ParseMetaData();
+    // Validates magic bytes, parses metadata, and initializes the.
+    // SchemaDescriptor.
+    file->parseMetaData();
   } else {
-    file->set_metadata(std::move(metadata));
+    file->setMetadata(std::move(metadata));
   }
 
   return result;
 }
 
 ::arrow::Future<std::unique_ptr<ParquetFileReader::Contents>>
-ParquetFileReader::Contents::OpenAsync(
+ParquetFileReader::Contents::openAsync(
     std::shared_ptr<ArrowInputFile> source,
     const ReaderProperties& props,
     std::shared_ptr<FileMetaData> metadata) {
@@ -906,7 +892,7 @@ ParquetFileReader::Contents::OpenAsync(
       new SerializedFile(std::move(source), props));
   SerializedFile* file = static_cast<SerializedFile*>(result.get());
   if (metadata == nullptr) {
-    // TODO(ARROW-12259): workaround since we have Future<(move-only type)>
+    // TODO(ARROW-12259): workaround since we have Future<(move-only type)>.
     struct {
       ::arrow::Result<std::unique_ptr<ParquetFileReader::Contents>>
       operator()() {
@@ -916,80 +902,80 @@ ParquetFileReader::Contents::OpenAsync(
       std::unique_ptr<ParquetFileReader::Contents> result;
     } Continuation;
     Continuation.result = std::move(result);
-    return file->ParseMetaDataAsync().Then(std::move(Continuation));
+    return file->parseMetaDataAsync().Then(std::move(Continuation));
   } else {
-    file->set_metadata(std::move(metadata));
+    file->setMetadata(std::move(metadata));
     return ::arrow::Future<std::unique_ptr<ParquetFileReader::Contents>>::
         MakeFinished(std::move(result));
   }
   END_PARQUET_CATCH_EXCEPTIONS
 }
 
-std::unique_ptr<ParquetFileReader> ParquetFileReader::Open(
+std::unique_ptr<ParquetFileReader> ParquetFileReader::open(
     std::shared_ptr<::arrow::io::RandomAccessFile> source,
     const ReaderProperties& props,
     std::shared_ptr<FileMetaData> metadata) {
   auto contents =
-      SerializedFile::Open(std::move(source), props, std::move(metadata));
+      SerializedFile::open(std::move(source), props, std::move(metadata));
   std::unique_ptr<ParquetFileReader> result =
       std::make_unique<ParquetFileReader>();
-  result->Open(std::move(contents));
+  result->open(std::move(contents));
   return result;
 }
 
-std::unique_ptr<ParquetFileReader> ParquetFileReader::OpenFile(
+std::unique_ptr<ParquetFileReader> ParquetFileReader::openFile(
     const std::string& path,
-    bool memory_map,
+    bool memoryMap,
     const ReaderProperties& props,
     std::shared_ptr<FileMetaData> metadata) {
   std::shared_ptr<::arrow::io::RandomAccessFile> source;
-  if (memory_map) {
+  if (memoryMap) {
     PARQUET_ASSIGN_OR_THROW(
         source,
         ::arrow::io::MemoryMappedFile::Open(path, ::arrow::io::FileMode::READ));
   } else {
     PARQUET_ASSIGN_OR_THROW(
-        source, ::arrow::io::ReadableFile::Open(path, props.memory_pool()));
+        source, ::arrow::io::ReadableFile::Open(path, props.memoryPool()));
   }
 
-  return Open(std::move(source), props, std::move(metadata));
+  return open(std::move(source), props, std::move(metadata));
 }
 
 ::arrow::Future<std::unique_ptr<ParquetFileReader>>
-ParquetFileReader::OpenAsync(
+ParquetFileReader::openAsync(
     std::shared_ptr<::arrow::io::RandomAccessFile> source,
     const ReaderProperties& props,
     std::shared_ptr<FileMetaData> metadata) {
   BEGIN_PARQUET_CATCH_EXCEPTIONS
   auto fut =
-      SerializedFile::OpenAsync(std::move(source), props, std::move(metadata));
-  // TODO(ARROW-12259): workaround since we have Future<(move-only type)>
+      SerializedFile::openAsync(std::move(source), props, std::move(metadata));
+  // TODO(ARROW-12259): workaround since we have Future<(move-only type)>.
   auto completed = ::arrow::Future<std::unique_ptr<ParquetFileReader>>::Make();
   fut.AddCallback(
       [fut, completed](
           const ::arrow::Result<std::unique_ptr<ParquetFileReader::Contents>>&
-              contents) mutable {
-        if (!contents.ok()) {
-          completed.MarkFinished(contents.status());
+              Contents) mutable {
+        if (!Contents.ok()) {
+          completed.MarkFinished(Contents.status());
           return;
         }
         std::unique_ptr<ParquetFileReader> result =
             std::make_unique<ParquetFileReader>();
-        result->Open(fut.MoveResult().MoveValueUnsafe());
+        result->open(fut.MoveResult().MoveValueUnsafe());
         completed.MarkFinished(std::move(result));
       });
   return completed;
   END_PARQUET_CATCH_EXCEPTIONS
 }
 
-void ParquetFileReader::Open(
+void ParquetFileReader::open(
     std::unique_ptr<ParquetFileReader::Contents> contents) {
   contents_ = std::move(contents);
 }
 
-void ParquetFileReader::Close() {
+void ParquetFileReader::close() {
   if (contents_) {
-    contents_->Close();
+    contents_->close();
   }
 }
 
@@ -997,120 +983,120 @@ std::shared_ptr<FileMetaData> ParquetFileReader::metadata() const {
   return contents_->metadata();
 }
 
-std::shared_ptr<PageIndexReader> ParquetFileReader::GetPageIndexReader() {
-  return contents_->GetPageIndexReader();
+std::shared_ptr<PageIndexReader> ParquetFileReader::getPageIndexReader() {
+  return contents_->getPageIndexReader();
 }
 
-BloomFilterReader& ParquetFileReader::GetBloomFilterReader() {
-  return contents_->GetBloomFilterReader();
+BloomFilterReader& ParquetFileReader::getBloomFilterReader() {
+  return contents_->getBloomFilterReader();
 }
 
-std::shared_ptr<RowGroupReader> ParquetFileReader::RowGroup(int i) {
-  if (i >= metadata()->num_row_groups()) {
+std::shared_ptr<RowGroupReader> ParquetFileReader::rowGroup(int i) {
+  if (i >= metadata()->numRowGroups()) {
     std::stringstream ss;
     ss << "Trying to read row group " << i << " but file only has "
-       << metadata()->num_row_groups() << " row groups";
+       << metadata()->numRowGroups() << " row groups";
     throw ParquetException(ss.str());
   }
-  return contents_->GetRowGroup(i);
+  return contents_->getRowGroup(i);
 }
 
-void ParquetFileReader::PreBuffer(
-    const std::vector<int>& row_groups,
-    const std::vector<int>& column_indices,
+void ParquetFileReader::preBuffer(
+    const std::vector<int>& rowGroups,
+    const std::vector<int>& columnIndices,
     const ::arrow::io::IOContext& ctx,
     const ::arrow::io::CacheOptions& options) {
-  // Access private methods here
+  // Access private methods here.
   SerializedFile* file =
       ::arrow::internal::checked_cast<SerializedFile*>(contents_.get());
-  file->PreBuffer(row_groups, column_indices, ctx, options);
+  file->preBuffer(rowGroups, columnIndices, ctx, options);
 }
 
-::arrow::Future<> ParquetFileReader::WhenBuffered(
-    const std::vector<int>& row_groups,
-    const std::vector<int>& column_indices) const {
-  // Access private methods here
+::arrow::Future<> ParquetFileReader::whenBuffered(
+    const std::vector<int>& rowGroups,
+    const std::vector<int>& columnIndices) const {
+  // Access private methods here.
   SerializedFile* file =
       ::arrow::internal::checked_cast<SerializedFile*>(contents_.get());
-  return file->WhenBuffered(row_groups, column_indices);
+  return file->whenBuffered(rowGroups, columnIndices);
 }
 
-// ----------------------------------------------------------------------
-// File metadata helpers
+// ----------------------------------------------------------------------.
+// File metadata helpers.
 
-std::shared_ptr<FileMetaData> ReadMetaData(
+std::shared_ptr<FileMetaData> readMetaData(
     const std::shared_ptr<::arrow::io::RandomAccessFile>& source) {
-  return ParquetFileReader::Open(source)->metadata();
+  return ParquetFileReader::open(source)->metadata();
 }
 
-// ----------------------------------------------------------------------
-// File scanner for performance testing
+// ----------------------------------------------------------------------.
+// File Scanner for performance testing.
 
-int64_t ScanFileContents(
+int64_t scanFileContents(
     std::vector<int> columns,
-    const int32_t column_batch_size,
+    const int32_t columnBatchSize,
     ParquetFileReader* reader) {
-  std::vector<int16_t> rep_levels(column_batch_size);
-  std::vector<int16_t> def_levels(column_batch_size);
+  std::vector<int16_t> repLevels(columnBatchSize);
+  std::vector<int16_t> defLevels(columnBatchSize);
 
-  int num_columns = static_cast<int>(columns.size());
+  int numColumns = static_cast<int>(columns.size());
 
-  // columns are not specified explicitly. Add all columns
+  // Columns are not specified explicitly. Add all columns.
   if (columns.size() == 0) {
-    num_columns = reader->metadata()->num_columns();
-    columns.resize(num_columns);
-    for (int i = 0; i < num_columns; i++) {
+    numColumns = reader->metadata()->numColumns();
+    columns.resize(numColumns);
+    for (int i = 0; i < numColumns; i++) {
       columns[i] = i;
     }
   }
-  if (num_columns == 0) {
-    // If we still have no columns(none in file), return early. The remainder of
-    // function expects there to be at least one column.
+  if (numColumns == 0) {
+    // If we still have no columns(none in file), return early. The remainder
+    // of. Function expects there to be at least one column.
     return 0;
   }
 
-  std::vector<int64_t> total_rows(num_columns, 0);
+  std::vector<int64_t> totalRows(numColumns, 0);
 
-  for (int r = 0; r < reader->metadata()->num_row_groups(); ++r) {
-    auto group_reader = reader->RowGroup(r);
+  for (int r = 0; r < reader->metadata()->numRowGroups(); ++r) {
+    auto groupReader = reader->rowGroup(r);
     int col = 0;
     for (auto i : columns) {
-      std::shared_ptr<ColumnReader> col_reader = group_reader->Column(i);
-      size_t value_byte_size =
-          GetTypeByteSize(col_reader->descr()->physical_type());
-      std::vector<uint8_t> values(column_batch_size * value_byte_size);
-
-      int64_t values_read = 0;
-      while (col_reader->HasNext()) {
-        int64_t levels_read = ScanAllValues(
-            column_batch_size,
-            def_levels.data(),
-            rep_levels.data(),
+      std::shared_ptr<ColumnReader> colReader = groupReader->column(i);
+      size_t valueByteSize =
+          getTypeByteSize(colReader->descr()->physicalType());
+      std::vector<uint8_t> values(columnBatchSize * valueByteSize);
+
+      int64_t valuesRead = 0;
+      while (colReader->hasNext()) {
+        int64_t levelsRead = scanAllValues(
+            columnBatchSize,
+            defLevels.data(),
+            repLevels.data(),
             values.data(),
-            &values_read,
-            col_reader.get());
-        if (col_reader->descr()->max_repetition_level() > 0) {
-          for (int64_t i = 0; i < levels_read; i++) {
-            if (rep_levels[i] == 0) {
-              total_rows[col]++;
+            &valuesRead,
+            colReader.get());
+        if (colReader->descr()->maxRepetitionLevel() > 0) {
+          for (int64_t i = 0; i < levelsRead; i++) {
+            if (repLevels[i] == 0) {
+              totalRows[col]++;
             }
           }
         } else {
-          total_rows[col] += levels_read;
+          totalRows[col] += levelsRead;
         }
       }
       col++;
     }
   }
 
-  for (int i = 1; i < num_columns; ++i) {
-    if (total_rows[0] != total_rows[i]) {
+  for (int i = 1; i < numColumns; ++i) {
+    if (totalRows[0] != totalRows[i]) {
       throw ParquetException(
           "Parquet error: Total rows among columns do not match");
     }
   }
 
-  return total_rows[0];
+  return totalRows[0];
 }
 
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/tests/FileReader.h b/velox/dwio/parquet/writer/arrow/tests/FileReader.h
index 046655e28b5..cf6e058e50a 100644
--- a/velox/dwio/parquet/writer/arrow/tests/FileReader.h
+++ b/velox/dwio/parquet/writer/arrow/tests/FileReader.h
@@ -40,178 +40,178 @@ class RowGroupMetaData;
 
 class PARQUET_EXPORT RowGroupReader {
  public:
-  // Forward declare a virtual class 'Contents' to aid dependency injection and
-  // more easily create test fixtures An implementation of the Contents class is
-  // defined in the .cc file
+  // Forward declare a virtual class 'Contents' to aid dependency injection and.
+  // More easily create test fixtures An implementation of the Contents class
+  // is. Defined in the .cc file.
   struct Contents {
     virtual ~Contents() {}
-    virtual std::unique_ptr<PageReader> GetColumnPageReader(int i) = 0;
+    virtual std::unique_ptr<PageReader> getColumnPageReader(int i) = 0;
     virtual const RowGroupMetaData* metadata() const = 0;
     virtual const ReaderProperties* properties() const = 0;
   };
 
   explicit RowGroupReader(std::unique_ptr<Contents> contents);
 
-  // Returns the rowgroup metadata
+  // Returns the rowgroup metadata.
   const RowGroupMetaData* metadata() const;
 
-  // Construct a ColumnReader for the indicated row group-relative
-  // column. Ownership is shared with the RowGroupReader.
-  std::shared_ptr<ColumnReader> Column(int i);
+  // Construct a ColumnReader for the indicated row group-relative.
+  // Column. Ownership is shared with the RowGroupReader.
+  std::shared_ptr<ColumnReader> column(int i);
 
   // Construct a ColumnReader, trying to enable exposed encoding.
   //
-  // For dictionary encoding, currently we only support column chunks that are
-  // fully dictionary encoded, i.e., all data pages in the column chunk are
-  // dictionary encoded. If a column chunk uses dictionary encoding but then
-  // falls back to plain encoding, the encoding will not be exposed.
+  // For dictionary encoding, currently we only support column chunks that are.
+  // Fully dictionary encoded, i.e., all data pages in the column chunk are.
+  // Dictionary encoded. If a column chunk uses dictionary encoding but then.
+  // Falls back to plain encoding, the encoding will not be exposed.
   //
-  // The returned column reader provides an API GetExposedEncoding() for the
-  // users to check the exposed encoding and determine how to read the batches.
+  // The returned column reader provides an API GetExposedEncoding() for the.
+  // Users to check the exposed encoding and determine how to read the batches.
   //
-  // \note API EXPERIMENTAL
-  std::shared_ptr<ColumnReader> ColumnWithExposeEncoding(
+  // \note API EXPERIMENTAL.
+  std::shared_ptr<ColumnReader> columnWithExposeEncoding(
       int i,
-      ExposedEncoding encoding_to_expose);
+      ExposedEncoding encodingToExpose);
 
-  std::unique_ptr<PageReader> GetColumnPageReader(int i);
+  std::unique_ptr<PageReader> getColumnPageReader(int i);
 
  private:
-  // Holds a pointer to an instance of Contents implementation
+  // Holds a pointer to an instance of Contents implementation.
   std::unique_ptr<Contents> contents_;
 };
 
 class PARQUET_EXPORT ParquetFileReader {
  public:
-  // Declare a virtual class 'Contents' to aid dependency injection and more
-  // easily create test fixtures
-  // An implementation of the Contents class is defined in the .cc file
+  // Declare a virtual class 'Contents' to aid dependency injection and more.
+  // Easily create test fixtures.
+  // An implementation of the Contents class is defined in the .cc file.
   struct PARQUET_EXPORT Contents {
-    static std::unique_ptr<Contents> Open(
+    static std::unique_ptr<Contents> open(
         std::shared_ptr<::arrow::io::RandomAccessFile> source,
-        const ReaderProperties& props = default_reader_properties(),
+        const ReaderProperties& props = defaultReaderProperties(),
         std::shared_ptr<FileMetaData> metadata = NULLPTR);
 
-    static ::arrow::Future<std::unique_ptr<Contents>> OpenAsync(
+    static ::arrow::Future<std::unique_ptr<Contents>> openAsync(
         std::shared_ptr<::arrow::io::RandomAccessFile> source,
-        const ReaderProperties& props = default_reader_properties(),
+        const ReaderProperties& props = defaultReaderProperties(),
         std::shared_ptr<FileMetaData> metadata = NULLPTR);
 
     virtual ~Contents() = default;
-    // Perform any cleanup associated with the file contents
-    virtual void Close() = 0;
-    virtual std::shared_ptr<RowGroupReader> GetRowGroup(int i) = 0;
+    // Perform any cleanup associated with the file contents.
+    virtual void close() = 0;
+    virtual std::shared_ptr<RowGroupReader> getRowGroup(int i) = 0;
     virtual std::shared_ptr<FileMetaData> metadata() const = 0;
-    virtual std::shared_ptr<PageIndexReader> GetPageIndexReader() = 0;
-    virtual BloomFilterReader& GetBloomFilterReader() = 0;
+    virtual std::shared_ptr<PageIndexReader> getPageIndexReader() = 0;
+    virtual BloomFilterReader& getBloomFilterReader() = 0;
   };
 
   ParquetFileReader();
   ~ParquetFileReader();
 
-  // Create a file reader instance from an Arrow file object. Thread-safety is
-  // the responsibility of the file implementation
-  static std::unique_ptr<ParquetFileReader> Open(
+  // Create a file reader instance from an Arrow file object. Thread-safety is.
+  // The responsibility of the file implementation.
+  static std::unique_ptr<ParquetFileReader> open(
       std::shared_ptr<::arrow::io::RandomAccessFile> source,
-      const ReaderProperties& props = default_reader_properties(),
+      const ReaderProperties& props = defaultReaderProperties(),
       std::shared_ptr<FileMetaData> metadata = NULLPTR);
 
-  // API Convenience to open a serialized Parquet file on disk, using Arrow IO
-  // interfaces.
-  static std::unique_ptr<ParquetFileReader> OpenFile(
+  // API Convenience to open a serialized Parquet file on disk, using Arrow IO.
+  // Interfaces.
+  static std::unique_ptr<ParquetFileReader> openFile(
       const std::string& path,
-      bool memory_map = false,
-      const ReaderProperties& props = default_reader_properties(),
+      bool memoryMap = false,
+      const ReaderProperties& props = defaultReaderProperties(),
       std::shared_ptr<FileMetaData> metadata = NULLPTR);
 
   // Asynchronously open a file reader from an Arrow file object.
   // Does not throw - all errors are reported through the Future.
-  static ::arrow::Future<std::unique_ptr<ParquetFileReader>> OpenAsync(
+  static ::arrow::Future<std::unique_ptr<ParquetFileReader>> openAsync(
       std::shared_ptr<::arrow::io::RandomAccessFile> source,
-      const ReaderProperties& props = default_reader_properties(),
+      const ReaderProperties& props = defaultReaderProperties(),
       std::shared_ptr<FileMetaData> metadata = NULLPTR);
 
-  void Open(std::unique_ptr<Contents> contents);
-  void Close();
+  void open(std::unique_ptr<Contents> contents);
+  void close();
 
-  // The RowGroupReader is owned by the FileReader
-  std::shared_ptr<RowGroupReader> RowGroup(int i);
+  // The RowGroupReader is owned by the FileReader.
+  std::shared_ptr<RowGroupReader> rowGroup(int i);
 
-  // Returns the file metadata. Only one instance is ever created
+  // Returns the file metadata. Only one instance is ever created.
   std::shared_ptr<FileMetaData> metadata() const;
 
   /// Returns the PageIndexReader. Only one instance is ever created.
   ///
   /// If the file does not have the page index, nullptr may be returned.
-  /// Because it pays to check existence of page index in the file, it
-  /// is possible to return a non null value even if page index does
-  /// not exist. It is the caller's responsibility to check the return
-  /// value and follow-up calls to PageIndexReader.
+  /// Because it pays to check existence of page index in the file, it.
+  /// Is possible to return a non null value even if page index does.
+  /// Not exist. It is the caller's responsibility to check the return.
+  /// Value and follow-up calls to PageIndexReader.
   ///
-  /// WARNING: The returned PageIndexReader must not outlive the
+  /// WARNING: The returned PageIndexReader must not outlive the.
   /// ParquetFileReader. Initialize GetPageIndexReader() is not thread-safety.
-  std::shared_ptr<PageIndexReader> GetPageIndexReader();
+  std::shared_ptr<PageIndexReader> getPageIndexReader();
 
   /// Returns the BloomFilterReader. Only one instance is ever created.
   ///
-  /// WARNING: The returned BloomFilterReader must not outlive the
+  /// WARNING: The returned BloomFilterReader must not outlive the.
   /// ParquetFileReader. Initialize GetBloomFilterReader() is not thread-safety.
-  BloomFilterReader& GetBloomFilterReader();
+  BloomFilterReader& getBloomFilterReader();
 
   /// Pre-buffer the specified column indices in all row groups.
   ///
-  /// Readers can optionally call this to cache the necessary slices
-  /// of the file in-memory before deserialization. Arrow readers can
-  /// automatically do this via an option. This is intended to
-  /// increase performance when reading from high-latency filesystems
-  /// (e.g. Amazon S3).
+  /// Readers can optionally call this to cache the necessary slices.
+  /// Of the file in-memory before deserialization. Arrow readers can.
+  /// Automatically do this via an option. This is intended to.
+  /// Increase performance when reading from high-latency filesystems.
+  /// (E.g. Amazon S3).
   ///
-  /// After calling this, creating readers for row groups/column
-  /// indices that were not buffered may fail. Creating multiple
-  /// readers for the a subset of the buffered regions is
-  /// acceptable. This may be called again to buffer a different set
-  /// of row groups/columns.
+  /// After calling this, creating readers for row groups/column.
+  /// Indices that were not buffered may fail. Creating multiple.
+  /// Readers for the a subset of the buffered regions is.
+  /// Acceptable. This may be called again to buffer a different set.
+  /// Of row groups/columns.
   ///
-  /// If memory usage is a concern, note that data will remain
-  /// buffered in memory until either \a PreBuffer() is called again,
-  /// or the reader itself is destructed. Reading - and buffering -
-  /// only one row group at a time may be useful.
+  /// If memory usage is a concern, note that data will remain.
+  /// Buffered in memory until either \a PreBuffer() is called again,.
+  /// Or the reader itself is destructed. Reading - and buffering -.
+  /// Only one row group at a time may be useful.
   ///
   /// This method may throw.
-  void PreBuffer(
-      const std::vector<int>& row_groups,
-      const std::vector<int>& column_indices,
+  void preBuffer(
+      const std::vector<int>& rowGroups,
+      const std::vector<int>& columnIndices,
       const ::arrow::io::IOContext& ctx,
       const ::arrow::io::CacheOptions& options);
 
   /// Wait for the specified row groups and column indices to be pre-buffered.
   ///
-  /// After the returned Future completes, reading the specified row
-  /// groups/columns will not block.
+  /// After the returned Future completes, reading the specified row.
+  /// Groups/columns will not block.
   ///
   /// PreBuffer must be called first. This method does not throw.
-  ::arrow::Future<> WhenBuffered(
-      const std::vector<int>& row_groups,
-      const std::vector<int>& column_indices) const;
+  ::arrow::Future<> whenBuffered(
+      const std::vector<int>& rowGroups,
+      const std::vector<int>& columnIndices) const;
 
  private:
-  // Holds a pointer to an instance of Contents implementation
+  // Holds a pointer to an instance of Contents implementation.
   std::unique_ptr<Contents> contents_;
 };
 
-// Read only Parquet file metadata
+// Read only Parquet file metadata.
 std::shared_ptr<FileMetaData> PARQUET_EXPORT
-ReadMetaData(const std::shared_ptr<::arrow::io::RandomAccessFile>& source);
+readMetaData(const std::shared_ptr<::arrow::io::RandomAccessFile>& source);
 
-/// \brief Scan all values in file. Useful for performance testing
-/// \param[in] columns the column numbers to scan. If empty scans all
-/// \param[in] column_batch_size number of values to read at a time when
-/// scanning column \param[in] reader a ParquetFileReader instance \return
-/// number of semantic rows in file
+/// \brief Scan all values in file. Useful for performance testing.
+/// \param[in] columns the column numbers to scan. If empty scans all.
+/// \param[in] column_batch_size number of values to read at a time when.
+/// Scanning column \param[in] reader a ParquetFileReader instance \return.
+/// Number of semantic rows in file.
 PARQUET_EXPORT
-int64_t ScanFileContents(
+int64_t scanFileContents(
     std::vector<int> columns,
-    const int32_t column_batch_size,
+    const int32_t columnBatchSize,
     ParquetFileReader* reader);
 
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/tests/FileSerializeTest.cpp b/velox/dwio/parquet/writer/arrow/tests/FileSerializeTest.cpp
index 1a939b49a9a..98527fe63ed 100644
--- a/velox/dwio/parquet/writer/arrow/tests/FileSerializeTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/FileSerializeTest.cpp
@@ -42,291 +42,288 @@ template <typename TestType>
 class TestSerialize : public PrimitiveTypedTest<TestType> {
  public:
   void SetUp() {
-    num_columns_ = 4;
-    num_rowgroups_ = 4;
-    rows_per_rowgroup_ = 50;
-    rows_per_batch_ = 10;
-    this->SetUpSchema(Repetition::OPTIONAL, num_columns_);
+    numColumns_ = 4;
+    numRowgroups_ = 4;
+    rowsPerRowgroup_ = 50;
+    rowsPerBatch_ = 10;
+    this->setUpSchema(Repetition::kOptional, numColumns_);
   }
 
  protected:
-  int num_columns_;
-  int num_rowgroups_;
-  int rows_per_rowgroup_;
-  int rows_per_batch_;
+  int numColumns_;
+  int numRowgroups_;
+  int rowsPerRowgroup_;
+  int rowsPerBatch_;
 
-  void FileSerializeTest(Compression::type codec_type) {
-    FileSerializeTest(codec_type, codec_type);
+  void fileSerializeTest(Compression::type codecType) {
+    fileSerializeTest(codecType, codecType);
   }
 
-  void FileSerializeTest(
-      Compression::type codec_type,
-      Compression::type expected_codec_type) {
-    auto sink = CreateOutputStream();
+  void fileSerializeTest(
+      Compression::type codecType,
+      Compression::type expectedCodecType) {
+    auto sink = createOutputStream();
     auto gnode = std::static_pointer_cast<GroupNode>(this->node_);
 
-    WriterProperties::Builder prop_builder;
+    WriterProperties::Builder propBuilder;
 
-    for (int i = 0; i < num_columns_; ++i) {
-      prop_builder.compression(this->schema_.Column(i)->name(), codec_type);
+    for (int i = 0; i < numColumns_; ++i) {
+      propBuilder.compression(this->schema_.column(i)->name(), codecType);
     }
-    std::shared_ptr<WriterProperties> writer_properties = prop_builder.build();
-
-    auto file_writer = ParquetFileWriter::Open(sink, gnode, writer_properties);
-    this->GenerateData(rows_per_rowgroup_);
-    for (int rg = 0; rg < num_rowgroups_ / 2; ++rg) {
-      RowGroupWriter* row_group_writer;
-      row_group_writer = file_writer->AppendRowGroup();
-      for (int col = 0; col < num_columns_; ++col) {
-        auto column_writer = static_cast<TypedColumnWriter<TestType>*>(
-            row_group_writer->NextColumn());
-        column_writer->WriteBatch(
-            rows_per_rowgroup_,
-            this->def_levels_.data(),
+    std::shared_ptr<WriterProperties> WriterProperties = propBuilder.build();
+
+    auto fileWriter = ParquetFileWriter::open(sink, gnode, WriterProperties);
+    this->generateData(rowsPerRowgroup_);
+    for (int rg = 0; rg < numRowgroups_ / 2; ++rg) {
+      RowGroupWriter* rowGroupWriter;
+      rowGroupWriter = fileWriter->appendRowGroup();
+      for (int col = 0; col < numColumns_; ++col) {
+        auto columnWriter = static_cast<TypedColumnWriter<TestType>*>(
+            rowGroupWriter->nextColumn());
+        columnWriter->writeBatch(
+            rowsPerRowgroup_,
+            this->defLevels_.data(),
             nullptr,
-            this->values_ptr_);
-        column_writer->Close();
-        // Ensure column() API which is specific to BufferedRowGroup cannot be
-        // called
-        ASSERT_THROW(row_group_writer->column(col), ParquetException);
+            this->valuesPtr_);
+        columnWriter->close();
+        // Ensure column() API which is specific to BufferedRowGroup cannot be.
+        // Called.
+        ASSERT_THROW(rowGroupWriter->column(col), ParquetException);
       }
-      EXPECT_EQ(0, row_group_writer->total_compressed_bytes());
-      EXPECT_NE(0, row_group_writer->total_bytes_written());
-      EXPECT_NE(0, row_group_writer->total_compressed_bytes_written());
-      row_group_writer->Close();
-      EXPECT_EQ(0, row_group_writer->total_compressed_bytes());
-      EXPECT_NE(0, row_group_writer->total_bytes_written());
-      EXPECT_NE(0, row_group_writer->total_compressed_bytes_written());
+      EXPECT_EQ(0, rowGroupWriter->totalCompressedBytes());
+      EXPECT_NE(0, rowGroupWriter->totalBytesWritten());
+      EXPECT_NE(0, rowGroupWriter->totalCompressedBytesWritten());
+      rowGroupWriter->close();
+      EXPECT_EQ(0, rowGroupWriter->totalCompressedBytes());
+      EXPECT_NE(0, rowGroupWriter->totalBytesWritten());
+      EXPECT_NE(0, rowGroupWriter->totalCompressedBytesWritten());
     }
-    // Write half BufferedRowGroups
-    for (int rg = 0; rg < num_rowgroups_ / 2; ++rg) {
-      RowGroupWriter* row_group_writer;
-      row_group_writer = file_writer->AppendBufferedRowGroup();
-      for (int batch = 0; batch < (rows_per_rowgroup_ / rows_per_batch_);
-           ++batch) {
-        for (int col = 0; col < num_columns_; ++col) {
-          auto column_writer = static_cast<TypedColumnWriter<TestType>*>(
-              row_group_writer->column(col));
-          column_writer->WriteBatch(
-              rows_per_batch_,
-              this->def_levels_.data() + (batch * rows_per_batch_),
+    // Write half BufferedRowGroups.
+    for (int rg = 0; rg < numRowgroups_ / 2; ++rg) {
+      RowGroupWriter* rowGroupWriter;
+      rowGroupWriter = fileWriter->appendBufferedRowGroup();
+      for (int batch = 0; batch < (rowsPerRowgroup_ / rowsPerBatch_); ++batch) {
+        for (int col = 0; col < numColumns_; ++col) {
+          auto columnWriter = static_cast<TypedColumnWriter<TestType>*>(
+              rowGroupWriter->column(col));
+          columnWriter->writeBatch(
+              rowsPerBatch_,
+              this->defLevels_.data() + (batch * rowsPerBatch_),
               nullptr,
-              this->values_ptr_ + (batch * rows_per_batch_));
-          // Ensure NextColumn() API which is specific to RowGroup cannot be
-          // called
-          ASSERT_THROW(row_group_writer->NextColumn(), ParquetException);
+              this->valuesPtr_ + (batch * rowsPerBatch_));
+          // Ensure NextColumn() API which is specific to RowGroup cannot be.
+          // Called.
+          ASSERT_THROW(rowGroupWriter->nextColumn(), ParquetException);
         }
       }
-      // total_compressed_bytes() may equal to 0 if no dictionary enabled and no
-      // buffered values.
-      EXPECT_EQ(0, row_group_writer->total_bytes_written());
-      EXPECT_EQ(0, row_group_writer->total_compressed_bytes_written());
-      for (int col = 0; col < num_columns_; ++col) {
-        auto column_writer = static_cast<TypedColumnWriter<TestType>*>(
-            row_group_writer->column(col));
-        column_writer->Close();
+      // Total_compressed_bytes() may equal to 0 if no dictionary enabled and
+      // no. Buffered values.
+      EXPECT_EQ(0, rowGroupWriter->totalBytesWritten());
+      EXPECT_EQ(0, rowGroupWriter->totalCompressedBytesWritten());
+      for (int col = 0; col < numColumns_; ++col) {
+        auto columnWriter = static_cast<TypedColumnWriter<TestType>*>(
+            rowGroupWriter->column(col));
+        columnWriter->close();
       }
-      row_group_writer->Close();
-      EXPECT_EQ(0, row_group_writer->total_compressed_bytes());
-      EXPECT_NE(0, row_group_writer->total_bytes_written());
-      EXPECT_NE(0, row_group_writer->total_compressed_bytes_written());
+      rowGroupWriter->close();
+      EXPECT_EQ(0, rowGroupWriter->totalCompressedBytes());
+      EXPECT_NE(0, rowGroupWriter->totalBytesWritten());
+      EXPECT_NE(0, rowGroupWriter->totalCompressedBytesWritten());
     }
-    file_writer->Close();
+    fileWriter->close();
 
     PARQUET_ASSIGN_OR_THROW(auto buffer, sink->Finish());
 
-    int num_rows_ = num_rowgroups_ * rows_per_rowgroup_;
+    int numRows_ = numRowgroups_ * rowsPerRowgroup_;
 
     auto source = std::make_shared<::arrow::io::BufferReader>(buffer);
-    auto file_reader = ParquetFileReader::Open(source);
-    ASSERT_EQ(num_columns_, file_reader->metadata()->num_columns());
-    ASSERT_EQ(num_rowgroups_, file_reader->metadata()->num_row_groups());
-    ASSERT_EQ(num_rows_, file_reader->metadata()->num_rows());
-
-    for (int rg = 0; rg < num_rowgroups_; ++rg) {
-      auto rg_reader = file_reader->RowGroup(rg);
-      auto rg_metadata = rg_reader->metadata();
-      ASSERT_EQ(num_columns_, rg_metadata->num_columns());
-      ASSERT_EQ(rows_per_rowgroup_, rg_metadata->num_rows());
+    auto fileReader = ParquetFileReader::open(source);
+    ASSERT_EQ(numColumns_, fileReader->metadata()->numColumns());
+    ASSERT_EQ(numRowgroups_, fileReader->metadata()->numRowGroups());
+    ASSERT_EQ(numRows_, fileReader->metadata()->numRows());
+
+    for (int rg = 0; rg < numRowgroups_; ++rg) {
+      auto rgReader = fileReader->rowGroup(rg);
+      auto rgMetadata = rgReader->metadata();
+      ASSERT_EQ(numColumns_, rgMetadata->numColumns());
+      ASSERT_EQ(rowsPerRowgroup_, rgMetadata->numRows());
       // Check that the specified compression was actually used.
-      ASSERT_EQ(
-          expected_codec_type, rg_metadata->ColumnChunk(0)->compression());
-
-      const int64_t total_byte_size = rg_metadata->total_byte_size();
-      const int64_t total_compressed_size =
-          rg_metadata->total_compressed_size();
-      if (expected_codec_type == Compression::UNCOMPRESSED) {
-        ASSERT_EQ(total_byte_size, total_compressed_size);
+      ASSERT_EQ(expectedCodecType, rgMetadata->columnChunk(0)->compression());
+
+      const int64_t totalByteSize = rgMetadata->totalByteSize();
+      const int64_t totalCompressedSize = rgMetadata->totalCompressedSize();
+      if (expectedCodecType == Compression::UNCOMPRESSED) {
+        ASSERT_EQ(totalByteSize, totalCompressedSize);
       } else {
-        ASSERT_NE(total_byte_size, total_compressed_size);
+        ASSERT_NE(totalByteSize, totalCompressedSize);
       }
 
-      int64_t total_column_byte_size = 0;
-      int64_t total_column_compressed_size = 0;
-
-      for (int i = 0; i < num_columns_; ++i) {
-        int64_t values_read;
-        ASSERT_FALSE(rg_metadata->ColumnChunk(i)->has_index_page());
-        total_column_byte_size +=
-            rg_metadata->ColumnChunk(i)->total_uncompressed_size();
-        total_column_compressed_size +=
-            rg_metadata->ColumnChunk(i)->total_compressed_size();
-
-        std::vector<int16_t> def_levels_out(rows_per_rowgroup_);
-        std::vector<int16_t> rep_levels_out(rows_per_rowgroup_);
-        auto col_reader = std::static_pointer_cast<TypedColumnReader<TestType>>(
-            rg_reader->Column(i));
-        this->SetupValuesOut(rows_per_rowgroup_);
-        col_reader->ReadBatch(
-            rows_per_rowgroup_,
-            def_levels_out.data(),
-            rep_levels_out.data(),
-            this->values_out_ptr_,
-            &values_read);
-        this->SyncValuesOut();
-        ASSERT_EQ(rows_per_rowgroup_, values_read);
-        ASSERT_EQ(this->values_, this->values_out_);
-        ASSERT_EQ(this->def_levels_, def_levels_out);
+      int64_t totalColumnByteSize = 0;
+      int64_t totalColumnCompressedSize = 0;
+
+      for (int i = 0; i < numColumns_; ++i) {
+        int64_t valuesRead;
+        ASSERT_FALSE(rgMetadata->columnChunk(i)->hasIndexPage());
+        totalColumnByteSize +=
+            rgMetadata->columnChunk(i)->totalUncompressedSize();
+        totalColumnCompressedSize +=
+            rgMetadata->columnChunk(i)->totalCompressedSize();
+
+        std::vector<int16_t> defLevelsOut(rowsPerRowgroup_);
+        std::vector<int16_t> repLevelsOut(rowsPerRowgroup_);
+        auto colReader = std::static_pointer_cast<TypedColumnReader<TestType>>(
+            rgReader->column(i));
+        this->setupValuesOut(rowsPerRowgroup_);
+        colReader->readBatch(
+            rowsPerRowgroup_,
+            defLevelsOut.data(),
+            repLevelsOut.data(),
+            this->valuesOutPtr_,
+            &valuesRead);
+        this->syncValuesOut();
+        ASSERT_EQ(rowsPerRowgroup_, valuesRead);
+        ASSERT_EQ(this->values_, this->valuesOut_);
+        ASSERT_EQ(this->defLevels_, defLevelsOut);
       }
 
-      ASSERT_EQ(total_byte_size, total_column_byte_size);
-      ASSERT_EQ(total_compressed_size, total_column_compressed_size);
+      ASSERT_EQ(totalByteSize, totalColumnByteSize);
+      ASSERT_EQ(totalCompressedSize, totalColumnCompressedSize);
     }
   }
 
-  void UnequalNumRows(
-      int64_t max_rows,
-      const std::vector<int64_t> rows_per_column) {
-    auto sink = CreateOutputStream();
+  void unequalNumRows(
+      int64_t maxRows,
+      const std::vector<int64_t> rowsPerColumn) {
+    auto sink = createOutputStream();
     auto gnode = std::static_pointer_cast<GroupNode>(this->node_);
 
     std::shared_ptr<WriterProperties> props =
         WriterProperties::Builder().build();
 
-    auto file_writer = ParquetFileWriter::Open(sink, gnode, props);
+    auto fileWriter = ParquetFileWriter::open(sink, gnode, props);
 
-    RowGroupWriter* row_group_writer;
-    row_group_writer = file_writer->AppendRowGroup();
+    RowGroupWriter* rowGroupWriter;
+    rowGroupWriter = fileWriter->appendRowGroup();
 
-    this->GenerateData(max_rows);
-    for (int col = 0; col < num_columns_; ++col) {
-      auto column_writer = static_cast<TypedColumnWriter<TestType>*>(
-          row_group_writer->NextColumn());
-      column_writer->WriteBatch(
-          rows_per_column[col],
-          this->def_levels_.data(),
+    this->generateData(maxRows);
+    for (int col = 0; col < numColumns_; ++col) {
+      auto columnWriter = static_cast<TypedColumnWriter<TestType>*>(
+          rowGroupWriter->nextColumn());
+      columnWriter->writeBatch(
+          rowsPerColumn[col],
+          this->defLevels_.data(),
           nullptr,
-          this->values_ptr_);
-      column_writer->Close();
+          this->valuesPtr_);
+      columnWriter->close();
     }
-    row_group_writer->Close();
-    file_writer->Close();
+    rowGroupWriter->close();
+    fileWriter->close();
   }
 
-  void UnequalNumRowsBuffered(
-      int64_t max_rows,
-      const std::vector<int64_t> rows_per_column) {
-    auto sink = CreateOutputStream();
+  void unequalNumRowsBuffered(
+      int64_t maxRows,
+      const std::vector<int64_t> rowsPerColumn) {
+    auto sink = createOutputStream();
     auto gnode = std::static_pointer_cast<GroupNode>(this->node_);
 
     std::shared_ptr<WriterProperties> props =
         WriterProperties::Builder().build();
 
-    auto file_writer = ParquetFileWriter::Open(sink, gnode, props);
+    auto fileWriter = ParquetFileWriter::open(sink, gnode, props);
 
-    RowGroupWriter* row_group_writer;
-    row_group_writer = file_writer->AppendBufferedRowGroup();
+    RowGroupWriter* rowGroupWriter;
+    rowGroupWriter = fileWriter->appendBufferedRowGroup();
 
-    this->GenerateData(max_rows);
-    for (int col = 0; col < num_columns_; ++col) {
-      auto column_writer = static_cast<TypedColumnWriter<TestType>*>(
-          row_group_writer->column(col));
-      column_writer->WriteBatch(
-          rows_per_column[col],
-          this->def_levels_.data(),
+    this->generateData(maxRows);
+    for (int col = 0; col < numColumns_; ++col) {
+      auto columnWriter = static_cast<TypedColumnWriter<TestType>*>(
+          rowGroupWriter->column(col));
+      columnWriter->writeBatch(
+          rowsPerColumn[col],
+          this->defLevels_.data(),
           nullptr,
-          this->values_ptr_);
-      column_writer->Close();
+          this->valuesPtr_);
+      columnWriter->close();
     }
-    row_group_writer->Close();
-    file_writer->Close();
+    rowGroupWriter->close();
+    fileWriter->close();
   }
 
-  void RepeatedUnequalRows() {
-    // Optional and repeated, so definition and repetition levels
-    this->SetUpSchema(Repetition::REPEATED);
+  void repeatedUnequalRows() {
+    // Optional and repeated, so definition and repetition levels.
+    this->setUpSchema(Repetition::kRepeated);
 
     const int kNumRows = 100;
-    this->GenerateData(kNumRows);
+    this->generateData(kNumRows);
 
-    auto sink = CreateOutputStream();
+    auto sink = createOutputStream();
     auto gnode = std::static_pointer_cast<GroupNode>(this->node_);
     std::shared_ptr<WriterProperties> props =
         WriterProperties::Builder().build();
-    auto file_writer = ParquetFileWriter::Open(sink, gnode, props);
+    auto fileWriter = ParquetFileWriter::open(sink, gnode, props);
 
-    RowGroupWriter* row_group_writer;
-    row_group_writer = file_writer->AppendRowGroup();
+    RowGroupWriter* rowGroupWriter;
+    rowGroupWriter = fileWriter->appendRowGroup();
 
-    this->GenerateData(kNumRows);
+    this->generateData(kNumRows);
 
-    std::vector<int16_t> definition_levels(kNumRows, 1);
-    std::vector<int16_t> repetition_levels(kNumRows, 0);
+    std::vector<int16_t> definitionLevels(kNumRows, 1);
+    std::vector<int16_t> repetitionLevels(kNumRows, 0);
 
     {
-      auto column_writer = static_cast<TypedColumnWriter<TestType>*>(
-          row_group_writer->NextColumn());
-      column_writer->WriteBatch(
+      auto columnWriter = static_cast<TypedColumnWriter<TestType>*>(
+          rowGroupWriter->nextColumn());
+      columnWriter->writeBatch(
           kNumRows,
-          definition_levels.data(),
-          repetition_levels.data(),
-          this->values_ptr_);
-      column_writer->Close();
+          definitionLevels.data(),
+          repetitionLevels.data(),
+          this->valuesPtr_);
+      columnWriter->close();
     }
 
-    definition_levels[1] = 0;
-    repetition_levels[3] = 1;
+    definitionLevels[1] = 0;
+    repetitionLevels[3] = 1;
 
     {
-      auto column_writer = static_cast<TypedColumnWriter<TestType>*>(
-          row_group_writer->NextColumn());
-      column_writer->WriteBatch(
+      auto columnWriter = static_cast<TypedColumnWriter<TestType>*>(
+          rowGroupWriter->nextColumn());
+      columnWriter->writeBatch(
           kNumRows,
-          definition_levels.data(),
-          repetition_levels.data(),
-          this->values_ptr_);
-      column_writer->Close();
+          definitionLevels.data(),
+          repetitionLevels.data(),
+          this->valuesPtr_);
+      columnWriter->close();
     }
   }
 
-  void ZeroRowsRowGroup() {
-    auto sink = CreateOutputStream();
+  void zeroRowsRowGroup() {
+    auto sink = createOutputStream();
     auto gnode = std::static_pointer_cast<GroupNode>(this->node_);
 
     std::shared_ptr<WriterProperties> props =
         WriterProperties::Builder().build();
 
-    auto file_writer = ParquetFileWriter::Open(sink, gnode, props);
+    auto fileWriter = ParquetFileWriter::open(sink, gnode, props);
 
-    RowGroupWriter* row_group_writer;
+    RowGroupWriter* rowGroupWriter;
 
-    row_group_writer = file_writer->AppendRowGroup();
-    for (int col = 0; col < num_columns_; ++col) {
-      auto column_writer = static_cast<TypedColumnWriter<TestType>*>(
-          row_group_writer->NextColumn());
-      column_writer->Close();
+    rowGroupWriter = fileWriter->appendRowGroup();
+    for (int col = 0; col < numColumns_; ++col) {
+      auto columnWriter = static_cast<TypedColumnWriter<TestType>*>(
+          rowGroupWriter->nextColumn());
+      columnWriter->close();
     }
-    row_group_writer->Close();
+    rowGroupWriter->close();
 
-    row_group_writer = file_writer->AppendBufferedRowGroup();
-    for (int col = 0; col < num_columns_; ++col) {
-      auto column_writer = static_cast<TypedColumnWriter<TestType>*>(
-          row_group_writer->column(col));
-      column_writer->Close();
+    rowGroupWriter = fileWriter->appendBufferedRowGroup();
+    for (int col = 0; col < numColumns_; ++col) {
+      auto columnWriter = static_cast<TypedColumnWriter<TestType>*>(
+          rowGroupWriter->column(col));
+      columnWriter->close();
     }
-    row_group_writer->Close();
+    rowGroupWriter->close();
 
-    file_writer->Close();
+    fileWriter->close();
   }
 };
 
@@ -344,177 +341,176 @@ typedef ::testing::Types<
 TYPED_TEST_SUITE(TestSerialize, TestTypes);
 
 TYPED_TEST(TestSerialize, SmallFileUncompressed) {
-  ASSERT_NO_FATAL_FAILURE(this->FileSerializeTest(Compression::UNCOMPRESSED));
+  ASSERT_NO_FATAL_FAILURE(this->fileSerializeTest(Compression::UNCOMPRESSED));
 }
 
 TYPED_TEST(TestSerialize, TooFewRows) {
-  std::vector<int64_t> num_rows = {100, 100, 100, 99};
-  ASSERT_THROW(this->UnequalNumRows(100, num_rows), ParquetException);
-  ASSERT_THROW(this->UnequalNumRowsBuffered(100, num_rows), ParquetException);
+  std::vector<int64_t> numRows = {100, 100, 100, 99};
+  ASSERT_THROW(this->unequalNumRows(100, numRows), ParquetException);
+  ASSERT_THROW(this->unequalNumRowsBuffered(100, numRows), ParquetException);
 }
 
 TYPED_TEST(TestSerialize, TooManyRows) {
-  std::vector<int64_t> num_rows = {100, 100, 100, 101};
-  ASSERT_THROW(this->UnequalNumRows(101, num_rows), ParquetException);
-  ASSERT_THROW(this->UnequalNumRowsBuffered(101, num_rows), ParquetException);
+  std::vector<int64_t> numRows = {100, 100, 100, 101};
+  ASSERT_THROW(this->unequalNumRows(101, numRows), ParquetException);
+  ASSERT_THROW(this->unequalNumRowsBuffered(101, numRows), ParquetException);
 }
 
 TYPED_TEST(TestSerialize, ZeroRows) {
-  ASSERT_NO_THROW(this->ZeroRowsRowGroup());
+  ASSERT_NO_THROW(this->zeroRowsRowGroup());
 }
 
 TYPED_TEST(TestSerialize, RepeatedTooFewRows) {
-  ASSERT_THROW(this->RepeatedUnequalRows(), ParquetException);
+  ASSERT_THROW(this->repeatedUnequalRows(), ParquetException);
 }
 
 TYPED_TEST(TestSerialize, SmallFileSnappy) {
-  ASSERT_NO_FATAL_FAILURE(this->FileSerializeTest(Compression::SNAPPY));
+  ASSERT_NO_FATAL_FAILURE(this->fileSerializeTest(Compression::SNAPPY));
 }
 
 #ifdef ARROW_WITH_BROTLI
 TYPED_TEST(TestSerialize, SmallFileBrotli) {
-  ASSERT_NO_FATAL_FAILURE(this->FileSerializeTest(Compression::BROTLI));
+  ASSERT_NO_FATAL_FAILURE(this->fileSerializeTest(Compression::BROTLI));
 }
 #endif
 
 TYPED_TEST(TestSerialize, SmallFileGzip) {
-  ASSERT_NO_FATAL_FAILURE(this->FileSerializeTest(Compression::GZIP));
+  ASSERT_NO_FATAL_FAILURE(this->fileSerializeTest(Compression::GZIP));
 }
 
 TYPED_TEST(TestSerialize, SmallFileLz4) {
-  ASSERT_NO_FATAL_FAILURE(this->FileSerializeTest(Compression::LZ4));
+  ASSERT_NO_FATAL_FAILURE(this->fileSerializeTest(Compression::LZ4));
 }
 
 TYPED_TEST(TestSerialize, SmallFileLz4Hadoop) {
-  ASSERT_NO_FATAL_FAILURE(this->FileSerializeTest(Compression::LZ4_HADOOP));
+  ASSERT_NO_FATAL_FAILURE(this->fileSerializeTest(Compression::LZ4_HADOOP));
 }
 
 TYPED_TEST(TestSerialize, SmallFileZstd) {
-  ASSERT_NO_FATAL_FAILURE(this->FileSerializeTest(Compression::ZSTD));
+  ASSERT_NO_FATAL_FAILURE(this->fileSerializeTest(Compression::ZSTD));
 }
 
 TEST(TestBufferedRowGroupWriter, DisabledDictionary) {
   // PARQUET-1706:
-  // Wrong dictionary_page_offset when writing only data pages via
-  // BufferedPageWriter
-  auto sink = CreateOutputStream();
-  auto writer_props = WriterProperties::Builder().disable_dictionary()->build();
+  // Wrong dictionary_page_offset when writing only data pages via.
+  // BufferedPageWriter.
+  auto sink = createOutputStream();
+  auto writerProps = WriterProperties::Builder().disableDictionary()->build();
   schema::NodeVector fields;
   fields.push_back(
-      PrimitiveNode::Make("col", Repetition::REQUIRED, Type::INT32));
+      PrimitiveNode::make("col", Repetition::kRequired, Type::kInt32));
   auto schema = std::static_pointer_cast<GroupNode>(
-      GroupNode::Make("schema", Repetition::REQUIRED, fields));
-  auto file_writer = ParquetFileWriter::Open(sink, schema, writer_props);
-  auto rg_writer = file_writer->AppendBufferedRowGroup();
-  auto col_writer = static_cast<Int32Writer*>(rg_writer->column(0));
+      GroupNode::make("schema", Repetition::kRequired, fields));
+  auto fileWriter = ParquetFileWriter::open(sink, schema, writerProps);
+  auto rgWriter = fileWriter->appendBufferedRowGroup();
+  auto colWriter = static_cast<Int32Writer*>(rgWriter->column(0));
   int value = 0;
-  col_writer->WriteBatch(1, nullptr, nullptr, &value);
-  rg_writer->Close();
-  file_writer->Close();
+  colWriter->writeBatch(1, nullptr, nullptr, &value);
+  rgWriter->close();
+  fileWriter->close();
   PARQUET_ASSIGN_OR_THROW(auto buffer, sink->Finish());
 
   auto source = std::make_shared<::arrow::io::BufferReader>(buffer);
-  auto file_reader = ParquetFileReader::Open(source);
-  ASSERT_EQ(1, file_reader->metadata()->num_row_groups());
-  auto rg_reader = file_reader->RowGroup(0);
-  ASSERT_EQ(1, rg_reader->metadata()->num_columns());
-  ASSERT_EQ(1, rg_reader->metadata()->num_rows());
-  ASSERT_FALSE(rg_reader->metadata()->ColumnChunk(0)->has_dictionary_page());
+  auto fileReader = ParquetFileReader::open(source);
+  ASSERT_EQ(1, fileReader->metadata()->numRowGroups());
+  auto rgReader = fileReader->rowGroup(0);
+  ASSERT_EQ(1, rgReader->metadata()->numColumns());
+  ASSERT_EQ(1, rgReader->metadata()->numRows());
+  ASSERT_FALSE(rgReader->metadata()->columnChunk(0)->hasDictionaryPage());
 }
 
 TEST(TestBufferedRowGroupWriter, MultiPageDisabledDictionary) {
   constexpr int kValueCount = 10000;
   constexpr int kPageSize = 16384;
-  auto sink = CreateOutputStream();
-  auto writer_props = WriterProperties::Builder()
-                          .disable_dictionary()
-                          ->data_pagesize(kPageSize)
-                          ->build();
+  auto sink = createOutputStream();
+  auto writerProps = WriterProperties::Builder()
+                         .disableDictionary()
+                         ->dataPagesize(kPageSize)
+                         ->build();
   schema::NodeVector fields;
   fields.push_back(
-      PrimitiveNode::Make("col", Repetition::REQUIRED, Type::INT32));
+      PrimitiveNode::make("col", Repetition::kRequired, Type::kInt32));
   auto schema = std::static_pointer_cast<GroupNode>(
-      GroupNode::Make("schema", Repetition::REQUIRED, fields));
-  auto file_writer = ParquetFileWriter::Open(sink, schema, writer_props);
-  auto rg_writer = file_writer->AppendBufferedRowGroup();
-  auto col_writer = static_cast<Int32Writer*>(rg_writer->column(0));
-  std::vector<int32_t> values_in;
+      GroupNode::make("schema", Repetition::kRequired, fields));
+  auto fileWriter = ParquetFileWriter::open(sink, schema, writerProps);
+  auto rgWriter = fileWriter->appendBufferedRowGroup();
+  auto colWriter = static_cast<Int32Writer*>(rgWriter->column(0));
+  std::vector<int32_t> valuesIn;
   for (int i = 0; i < kValueCount; ++i) {
-    values_in.push_back((i % 100) + 1);
+    valuesIn.push_back((i % 100) + 1);
   }
-  col_writer->WriteBatch(kValueCount, nullptr, nullptr, values_in.data());
-  rg_writer->Close();
-  file_writer->Close();
+  colWriter->writeBatch(kValueCount, nullptr, nullptr, valuesIn.data());
+  rgWriter->close();
+  fileWriter->close();
   PARQUET_ASSIGN_OR_THROW(auto buffer, sink->Finish());
 
   auto source = std::make_shared<::arrow::io::BufferReader>(buffer);
-  auto file_reader = ParquetFileReader::Open(source);
-  auto file_metadata = file_reader->metadata();
-  ASSERT_EQ(1, file_reader->metadata()->num_row_groups());
-  std::vector<int32_t> values_out(kValueCount);
-  for (int r = 0; r < file_metadata->num_row_groups(); ++r) {
-    auto rg_reader = file_reader->RowGroup(r);
-    ASSERT_EQ(1, rg_reader->metadata()->num_columns());
-    ASSERT_EQ(kValueCount, rg_reader->metadata()->num_rows());
-    int64_t total_values_read = 0;
-    std::shared_ptr<ColumnReader> col_reader;
-    ASSERT_NO_THROW(col_reader = rg_reader->Column(0));
-    Int32Reader* int32_reader = static_cast<Int32Reader*>(col_reader.get());
+  auto fileReader = ParquetFileReader::open(source);
+  auto fileMetadata = fileReader->metadata();
+  ASSERT_EQ(1, fileReader->metadata()->numRowGroups());
+  std::vector<int32_t> valuesOut(kValueCount);
+  for (int r = 0; r < fileMetadata->numRowGroups(); ++r) {
+    auto rgReader = fileReader->rowGroup(r);
+    ASSERT_EQ(1, rgReader->metadata()->numColumns());
+    ASSERT_EQ(kValueCount, rgReader->metadata()->numRows());
+    int64_t totalValuesRead = 0;
+    std::shared_ptr<ColumnReader> colReader;
+    ASSERT_NO_THROW(colReader = rgReader->column(0));
+    Int32Reader* int32Reader = static_cast<Int32Reader*>(colReader.get());
     int64_t vn = kValueCount;
-    int32_t* vx = values_out.data();
-    while (int32_reader->HasNext()) {
-      int64_t values_read;
-      int32_reader->ReadBatch(vn, nullptr, nullptr, vx, &values_read);
-      vn -= values_read;
-      vx += values_read;
-      total_values_read += values_read;
+    int32_t* vx = valuesOut.data();
+    while (int32Reader->hasNext()) {
+      int64_t valuesRead;
+      int32Reader->readBatch(vn, nullptr, nullptr, vx, &valuesRead);
+      vn -= valuesRead;
+      vx += valuesRead;
+      totalValuesRead += valuesRead;
     }
-    ASSERT_EQ(kValueCount, total_values_read);
-    ASSERT_EQ(values_in, values_out);
+    ASSERT_EQ(kValueCount, totalValuesRead);
+    ASSERT_EQ(valuesIn, valuesOut);
   }
 }
 
 TEST(ParquetRoundtrip, AllNulls) {
-  auto primitive_node =
-      PrimitiveNode::Make("nulls", Repetition::OPTIONAL, nullptr, Type::INT32);
-  schema::NodeVector columns({primitive_node});
+  auto primitiveNode = PrimitiveNode::make(
+      "nulls", Repetition::kOptional, nullptr, Type::kInt32);
+  schema::NodeVector columns({primitiveNode});
 
-  auto root_node =
-      GroupNode::Make("root", Repetition::REQUIRED, columns, nullptr);
+  auto rootNode =
+      GroupNode::make("root", Repetition::kRequired, columns, nullptr);
 
-  auto sink = CreateOutputStream();
+  auto sink = createOutputStream();
 
-  auto file_writer = ParquetFileWriter::Open(
-      sink, std::static_pointer_cast<GroupNode>(root_node));
-  auto row_group_writer = file_writer->AppendRowGroup();
-  auto column_writer =
-      static_cast<Int32Writer*>(row_group_writer->NextColumn());
+  auto fileWriter = ParquetFileWriter::open(
+      sink, std::static_pointer_cast<GroupNode>(rootNode));
+  auto rowGroupWriter = fileWriter->appendRowGroup();
+  auto columnWriter = static_cast<Int32Writer*>(rowGroupWriter->nextColumn());
 
   int32_t values[3];
-  int16_t def_levels[] = {0, 0, 0};
+  int16_t defLevels[] = {0, 0, 0};
 
-  column_writer->WriteBatch(3, def_levels, nullptr, values);
+  columnWriter->writeBatch(3, defLevels, nullptr, values);
 
-  column_writer->Close();
-  row_group_writer->Close();
-  file_writer->Close();
+  columnWriter->close();
+  rowGroupWriter->close();
+  fileWriter->close();
 
-  ReaderProperties props = default_reader_properties();
-  props.enable_buffered_stream();
+  ReaderProperties props = defaultReaderProperties();
+  props.enableBufferedStream();
   PARQUET_ASSIGN_OR_THROW(auto buffer, sink->Finish());
 
   auto source = std::make_shared<::arrow::io::BufferReader>(buffer);
-  auto file_reader = ParquetFileReader::Open(source, props);
-  auto row_group_reader = file_reader->RowGroup(0);
-  auto column_reader =
-      std::static_pointer_cast<Int32Reader>(row_group_reader->Column(0));
-
-  int64_t values_read;
-  def_levels[0] = -1;
-  def_levels[1] = -1;
-  def_levels[2] = -1;
-  column_reader->ReadBatch(3, def_levels, nullptr, values, &values_read);
-  EXPECT_THAT(def_levels, ElementsAre(0, 0, 0));
+  auto fileReader = ParquetFileReader::open(source, props);
+  auto RowGroupReader = fileReader->rowGroup(0);
+  auto ColumnReader =
+      std::static_pointer_cast<Int32Reader>(RowGroupReader->column(0));
+
+  int64_t valuesRead;
+  defLevels[0] = -1;
+  defLevels[1] = -1;
+  defLevels[2] = -1;
+  ColumnReader->readBatch(3, defLevels, nullptr, values, &valuesRead);
+  EXPECT_THAT(defLevels, ElementsAre(0, 0, 0));
 }
 
 } // namespace test
diff --git a/velox/dwio/parquet/writer/arrow/tests/Hasher.h b/velox/dwio/parquet/writer/arrow/tests/Hasher.h
index 3ffd42ed240..81f12b1f8f5 100644
--- a/velox/dwio/parquet/writer/arrow/tests/Hasher.h
+++ b/velox/dwio/parquet/writer/arrow/tests/Hasher.h
@@ -23,121 +23,121 @@
 
 namespace facebook::velox::parquet::arrow {
 
-// Abstract class for hash
+// Abstract class for hash.
 class Hasher {
  public:
   /// Compute hash for 32 bits value by using its plain encoding result.
   ///
   /// @param value the value to hash.
   /// @return hash result.
-  virtual uint64_t Hash(int32_t value) const = 0;
+  virtual uint64_t hash(int32_t value) const = 0;
 
   /// Compute hash for 64 bits value by using its plain encoding result.
   ///
   /// @param value the value to hash.
   /// @return hash result.
-  virtual uint64_t Hash(int64_t value) const = 0;
+  virtual uint64_t hash(int64_t value) const = 0;
 
   /// Compute hash for float value by using its plain encoding result.
   ///
   /// @param value the value to hash.
   /// @return hash result.
-  virtual uint64_t Hash(float value) const = 0;
+  virtual uint64_t hash(float value) const = 0;
 
   /// Compute hash for double value by using its plain encoding result.
   ///
   /// @param value the value to hash.
   /// @return hash result.
-  virtual uint64_t Hash(double value) const = 0;
+  virtual uint64_t hash(double value) const = 0;
 
   /// Compute hash for Int96 value by using its plain encoding result.
   ///
   /// @param value the value to hash.
   /// @return hash result.
-  virtual uint64_t Hash(const Int96* value) const = 0;
+  virtual uint64_t hash(const Int96* value) const = 0;
 
   /// Compute hash for ByteArray value by using its plain encoding result.
   ///
   /// @param value the value to hash.
   /// @return hash result.
-  virtual uint64_t Hash(const ByteArray* value) const = 0;
+  virtual uint64_t hash(const ByteArray* value) const = 0;
 
-  /// Compute hash for fixed byte array value by using its plain encoding
-  /// result.
+  /// Compute hash for fixed byte array value by using its plain encoding.
+  /// Result.
   ///
   /// @param value the value address.
   /// @param len the value length.
-  virtual uint64_t Hash(const FLBA* value, uint32_t len) const = 0;
+  virtual uint64_t hash(const FLBA* value, uint32_t len) const = 0;
 
-  /// Batch compute hashes for 32 bits values by using its plain encoding
-  /// result.
+  /// Batch compute hashes for 32 bits values by using its plain encoding.
+  /// Result.
   ///
   /// @param values a pointer to the values to hash.
   /// @param num_values the number of values to hash.
-  /// @param hashes a pointer to the output hash values, its length should be
-  /// equal to num_values.
-  virtual void Hashes(const int32_t* values, int num_values, uint64_t* hashes)
+  /// @param hashes a pointer to the output hash values, its length should be.
+  /// Equal to num_values.
+  virtual void hashes(const int32_t* values, int numValues, uint64_t* hashes)
       const = 0;
 
-  /// Batch compute hashes for 64 bits values by using its plain encoding
-  /// result.
+  /// Batch compute hashes for 64 bits values by using its plain encoding.
+  /// Result.
   ///
   /// @param values a pointer to the values to hash.
   /// @param num_values the number of values to hash.
-  /// @param hashes a pointer to the output hash values, its length should be
-  /// equal to num_values.
-  virtual void Hashes(const int64_t* values, int num_values, uint64_t* hashes)
+  /// @param hashes a pointer to the output hash values, its length should be.
+  /// Equal to num_values.
+  virtual void hashes(const int64_t* values, int numValues, uint64_t* hashes)
       const = 0;
 
   /// Batch compute hashes for float values by using its plain encoding result.
   ///
   /// @param values a pointer to the values to hash.
   /// @param num_values the number of values to hash.
-  /// @param hashes a pointer to the output hash values, its length should be
-  /// equal to num_values.
-  virtual void Hashes(const float* values, int num_values, uint64_t* hashes)
+  /// @param hashes a pointer to the output hash values, its length should be.
+  /// Equal to num_values.
+  virtual void hashes(const float* values, int numValues, uint64_t* hashes)
       const = 0;
 
   /// Batch compute hashes for double values by using its plain encoding result.
   ///
   /// @param values a pointer to the values to hash.
   /// @param num_values the number of values to hash.
-  /// @param hashes a pointer to the output hash values, its length should be
-  /// equal to num_values.
-  virtual void Hashes(const double* values, int num_values, uint64_t* hashes)
+  /// @param hashes a pointer to the output hash values, its length should be.
+  /// Equal to num_values.
+  virtual void hashes(const double* values, int numValues, uint64_t* hashes)
       const = 0;
 
   /// Batch compute hashes for Int96 values by using its plain encoding result.
   ///
   /// @param values a pointer to the values to hash.
   /// @param num_values the number of values to hash.
-  /// @param hashes a pointer to the output hash values, its length should be
-  /// equal to num_values.
-  virtual void Hashes(const Int96* values, int num_values, uint64_t* hashes)
+  /// @param hashes a pointer to the output hash values, its length should be.
+  /// Equal to num_values.
+  virtual void hashes(const Int96* values, int numValues, uint64_t* hashes)
       const = 0;
 
-  /// Batch compute hashes for ByteArray values by using its plain encoding
-  /// result.
+  /// Batch compute hashes for ByteArray values by using its plain encoding.
+  /// Result.
   ///
   /// @param values a pointer to the values to hash.
   /// @param num_values the number of values to hash.
-  /// @param hashes a pointer to the output hash values, its length should be
-  /// equal to num_values.
-  virtual void Hashes(const ByteArray* values, int num_values, uint64_t* hashes)
+  /// @param hashes a pointer to the output hash values, its length should be.
+  /// Equal to num_values.
+  virtual void hashes(const ByteArray* values, int numValues, uint64_t* hashes)
       const = 0;
 
-  /// Batch compute hashes for fixed byte array values by using its plain
-  /// encoding result.
+  /// Batch compute hashes for fixed byte array values by using its plain.
+  /// Encoding result.
   ///
   /// @param values the value address.
   /// @param type_len the value length.
   /// @param num_values the number of values to hash.
-  /// @param hashes a pointer to the output hash values, its length should be
-  /// equal to num_values.
-  virtual void Hashes(
+  /// @param hashes a pointer to the output hash values, its length should be.
+  /// Equal to num_values.
+  virtual void hashes(
       const FLBA* values,
-      uint32_t type_len,
-      int num_values,
+      uint32_t typeLen,
+      int numValues,
       uint64_t* hashes) const = 0;
 
   virtual ~Hasher() = default;
diff --git a/velox/dwio/parquet/writer/arrow/tests/MetadataTest.cpp b/velox/dwio/parquet/writer/arrow/tests/MetadataTest.cpp
index a0d0d2e5cb5..2efb7aa02f8 100644
--- a/velox/dwio/parquet/writer/arrow/tests/MetadataTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/MetadataTest.cpp
@@ -21,16 +21,20 @@
 #include <gtest/gtest.h>
 
 #include "arrow/util/key_value_metadata.h"
+#include "velox/common/io/IoStatistics.h"
+#include "velox/common/testutil/TempFilePath.h"
 #include "velox/dwio/parquet/reader/ParquetReader.h"
 #include "velox/dwio/parquet/writer/arrow/FileWriter.h"
 #include "velox/dwio/parquet/writer/arrow/tests/TestUtil.h"
-#include "velox/exec/tests/utils/TempFilePath.h"
 
 namespace facebook::velox::parquet::arrow {
 namespace metadata {
+
+using namespace facebook::velox::common::testutil;
+
 namespace {
 void writeToFile(
-    std::shared_ptr<exec::test::TempFilePath> filePath,
+    std::shared_ptr<TempFilePath> filePath,
     std::shared_ptr<arrow::Buffer> buffer) {
   auto localWriteFile =
       std::make_unique<LocalWriteFile>(filePath->getPath(), false, false);
@@ -41,29 +45,29 @@ void writeToFile(
 }
 } // namespace
 
-// Helper function for generating table metadata
-std::unique_ptr<FileMetaData> GenerateTableMetaData(
+// Helper function for generating table metadata.
+std::unique_ptr<FileMetaData> generateTableMetaData(
     const SchemaDescriptor& schema,
     const std::shared_ptr<WriterProperties>& props,
     const int64_t& nrows,
-    EncodedStatistics stats_int,
-    EncodedStatistics stats_float) {
-  auto f_builder = FileMetaDataBuilder::Make(&schema, props);
-  auto rg1_builder = f_builder->AppendRowGroup();
-  // Write the metadata
-  // rowgroup1 metadata
-  auto col1_builder = rg1_builder->NextColumnChunk();
-  auto col2_builder = rg1_builder->NextColumnChunk();
-  // column metadata
-  std::map<Encoding::type, int32_t> dict_encoding_stats(
-      {{Encoding::RLE_DICTIONARY, 1}});
-  std::map<Encoding::type, int32_t> data_encoding_stats(
-      {{Encoding::PLAIN, 1}, {Encoding::RLE, 1}});
-  stats_int.set_is_signed(true);
-  col1_builder->SetStatistics(stats_int);
-  stats_float.set_is_signed(true);
-  col2_builder->SetStatistics(stats_float);
-  col1_builder->Finish(
+    EncodedStatistics statsInt,
+    EncodedStatistics statsFloat) {
+  auto fBuilder = FileMetaDataBuilder::make(&schema, props);
+  auto rg1Builder = fBuilder->appendRowGroup();
+  // Write the metadata.
+  // Rowgroup1 metadata.
+  auto col1Builder = rg1Builder->nextColumnChunk();
+  auto col2Builder = rg1Builder->nextColumnChunk();
+  // Column metadata.
+  std::map<Encoding::type, int32_t> dictEncodingStats(
+      {{Encoding::kRleDictionary, 1}});
+  std::map<Encoding::type, int32_t> dataEncodingStats(
+      {{Encoding::kPlain, 1}, {Encoding::kRle, 1}});
+  statsInt.setIsSigned(true);
+  col1Builder->setStatistics(statsInt);
+  statsFloat.setIsSigned(true);
+  col2Builder->setStatistics(statsFloat);
+  col1Builder->finish(
       nrows / 2,
       4,
       0,
@@ -72,9 +76,9 @@ std::unique_ptr<FileMetaData> GenerateTableMetaData(
       600,
       true,
       false,
-      dict_encoding_stats,
-      data_encoding_stats);
-  col2_builder->Finish(
+      dictEncodingStats,
+      dataEncodingStats);
+  col2Builder->finish(
       nrows / 2,
       24,
       0,
@@ -83,31 +87,31 @@ std::unique_ptr<FileMetaData> GenerateTableMetaData(
       600,
       true,
       false,
-      dict_encoding_stats,
-      data_encoding_stats);
-
-  rg1_builder->set_num_rows(nrows / 2);
-  rg1_builder->Finish(1024);
-
-  // rowgroup2 metadata
-  auto rg2_builder = f_builder->AppendRowGroup();
-  col1_builder = rg2_builder->NextColumnChunk();
-  col2_builder = rg2_builder->NextColumnChunk();
-  // column metadata
-  col1_builder->SetStatistics(stats_int);
-  col2_builder->SetStatistics(stats_float);
-  col1_builder->Finish(
+      dictEncodingStats,
+      dataEncodingStats);
+
+  rg1Builder->setNumRows(nrows / 2);
+  rg1Builder->finish(1024);
+
+  // Rowgroup2 metadata.
+  auto rg2Builder = fBuilder->appendRowGroup();
+  col1Builder = rg2Builder->nextColumnChunk();
+  col2Builder = rg2Builder->nextColumnChunk();
+  // Column metadata.
+  col1Builder->setStatistics(statsInt);
+  col2Builder->setStatistics(statsFloat);
+  col1Builder->finish(
       nrows / 2,
-      /*dictionary_page_offset=*/0,
+      0,
       0,
       10,
       512,
       600,
-      /*has_dictionary=*/false,
       false,
-      dict_encoding_stats,
-      data_encoding_stats);
-  col2_builder->Finish(
+      false,
+      dictEncodingStats,
+      dataEncodingStats);
+  col2Builder->finish(
       nrows / 2,
       16,
       0,
@@ -116,17 +120,17 @@ std::unique_ptr<FileMetaData> GenerateTableMetaData(
       600,
       true,
       false,
-      dict_encoding_stats,
-      data_encoding_stats);
+      dictEncodingStats,
+      dataEncodingStats);
 
-  rg2_builder->set_num_rows(nrows / 2);
-  rg2_builder->Finish(1024);
+  rg2Builder->setNumRows(nrows / 2);
+  rg2Builder->finish(1024);
 
-  // Return the metadata accessor
-  return f_builder->Finish();
+  // Return the metadata accessor.
+  return fBuilder->finish();
 }
 
-void AssertEncodings(
+void assertEncodings(
     const ColumnChunkMetaData& data,
     const std::set<Encoding::type>& expected) {
   std::set<Encoding::type> encodings(
@@ -139,210 +143,210 @@ TEST(Metadata, TestBuildAccess) {
   schema::NodePtr root;
   SchemaDescriptor schema;
 
-  WriterProperties::Builder prop_builder;
+  WriterProperties::Builder propBuilder;
 
   std::shared_ptr<WriterProperties> props =
-      prop_builder.version(ParquetVersion::PARQUET_2_6)->build();
+      propBuilder.version(ParquetVersion::PARQUET_2_6)->build();
 
-  fields.push_back(schema::Int32("int_col", Repetition::REQUIRED));
-  fields.push_back(schema::Float("float_col", Repetition::REQUIRED));
-  root = schema::GroupNode::Make("schema", Repetition::REPEATED, fields);
-  schema.Init(root);
+  fields.push_back(schema::int32("int_col", Repetition::kRequired));
+  fields.push_back(schema::floatType("float_col", Repetition::kRequired));
+  root = schema::GroupNode::make("schema", Repetition::kRepeated, fields);
+  schema.init(root);
 
   int64_t nrows = 1000;
-  int32_t int_min = 100, int_max = 200;
-  EncodedStatistics stats_int;
-  stats_int.set_null_count(0)
-      .set_distinct_count(nrows)
-      .set_min(std::string(reinterpret_cast<const char*>(&int_min), 4))
-      .set_max(std::string(reinterpret_cast<const char*>(&int_max), 4));
-  EncodedStatistics stats_float;
-  float float_min = 100.100f, float_max = 200.200f;
-  stats_float.set_null_count(0)
-      .set_distinct_count(nrows)
-      .set_min(std::string(reinterpret_cast<const char*>(&float_min), 4))
-      .set_max(std::string(reinterpret_cast<const char*>(&float_max), 4));
-
-  // Generate the metadata
-  auto f_accessor =
-      GenerateTableMetaData(schema, props, nrows, stats_int, stats_float);
-
-  std::string f_accessor_serialized_metadata = f_accessor->SerializeToString();
-  uint32_t expected_len =
-      static_cast<uint32_t>(f_accessor_serialized_metadata.length());
-
-  // decoded_len is an in-out parameter
-  uint32_t decoded_len = expected_len;
-  auto f_accessor_copy =
-      FileMetaData::Make(f_accessor_serialized_metadata.data(), &decoded_len);
-
-  // Check that all of the serialized data is consumed
-  ASSERT_EQ(expected_len, decoded_len);
+  int32_t intMin = 100, intMax = 200;
+  EncodedStatistics statsInt;
+  statsInt.setNullCount(0)
+      .setDistinctCount(nrows)
+      .setMin(std::string(reinterpret_cast<const char*>(&intMin), 4))
+      .setMax(std::string(reinterpret_cast<const char*>(&intMax), 4));
+  EncodedStatistics statsFloat;
+  float floatMin = 100.100f, floatMax = 200.200f;
+  statsFloat.setNullCount(0)
+      .setDistinctCount(nrows)
+      .setMin(std::string(reinterpret_cast<const char*>(&floatMin), 4))
+      .setMax(std::string(reinterpret_cast<const char*>(&floatMax), 4));
+
+  // Generate the metadata.
+  auto fAccessor =
+      generateTableMetaData(schema, props, nrows, statsInt, statsFloat);
+
+  std::string fAccessorSerializedMetadata = fAccessor->serializeToString();
+  uint32_t expectedLen =
+      static_cast<uint32_t>(fAccessorSerializedMetadata.length());
+
+  // Decoded_len is an in-out parameter.
+  uint32_t decodedLen = expectedLen;
+  auto fAccessorCopy =
+      FileMetaData::make(fAccessorSerializedMetadata.data(), &decodedLen);
+
+  // Check that all of the serialized data is consumed.
+  ASSERT_EQ(expectedLen, decodedLen);
 
   // Run this block twice, one for f_accessor, one for f_accessor_copy.
   // To make sure SerializedMetadata was deserialized correctly.
-  std::vector<FileMetaData*> f_accessors = {
-      f_accessor.get(), f_accessor_copy.get()};
-  for (int loop_index = 0; loop_index < 2; loop_index++) {
-    // file metadata
-    ASSERT_EQ(nrows, f_accessors[loop_index]->num_rows());
-    ASSERT_LE(0, static_cast<int>(f_accessors[loop_index]->size()));
-    ASSERT_EQ(2, f_accessors[loop_index]->num_row_groups());
-    ASSERT_EQ(ParquetVersion::PARQUET_2_6, f_accessors[loop_index]->version());
+  std::vector<FileMetaData*> fAccessors = {
+      fAccessor.get(), fAccessorCopy.get()};
+  for (int loopIndex = 0; loopIndex < 2; loopIndex++) {
+    // File metadata.
+    ASSERT_EQ(nrows, fAccessors[loopIndex]->numRows());
+    ASSERT_LE(0, static_cast<int>(fAccessors[loopIndex]->size()));
+    ASSERT_EQ(2, fAccessors[loopIndex]->numRowGroups());
+    ASSERT_EQ(ParquetVersion::PARQUET_2_6, fAccessors[loopIndex]->version());
     ASSERT_TRUE(
-        f_accessors[loop_index]->created_by().find(DEFAULT_CREATED_BY) !=
+        fAccessors[loopIndex]->createdBy().find(DEFAULT_CREATED_BY) !=
         std::string::npos);
-    ASSERT_EQ(3, f_accessors[loop_index]->num_schema_elements());
-
-    // row group1 metadata
-    auto rg1_accessor = f_accessors[loop_index]->RowGroup(0);
-    ASSERT_EQ(2, rg1_accessor->num_columns());
-    ASSERT_EQ(nrows / 2, rg1_accessor->num_rows());
-    ASSERT_EQ(1024, rg1_accessor->total_byte_size());
-    ASSERT_EQ(1024, rg1_accessor->total_compressed_size());
+    ASSERT_EQ(3, fAccessors[loopIndex]->numSchemaElements());
+
+    // Row group1 metadata.
+    auto rg1Accessor = fAccessors[loopIndex]->rowGroup(0);
+    ASSERT_EQ(2, rg1Accessor->numColumns());
+    ASSERT_EQ(nrows / 2, rg1Accessor->numRows());
+    ASSERT_EQ(1024, rg1Accessor->totalByteSize());
+    ASSERT_EQ(1024, rg1Accessor->totalCompressedSize());
     EXPECT_EQ(
-        rg1_accessor->file_offset(),
-        rg1_accessor->ColumnChunk(0)->dictionary_page_offset());
-
-    auto rg1_column1 = rg1_accessor->ColumnChunk(0);
-    auto rg1_column2 = rg1_accessor->ColumnChunk(1);
-    ASSERT_EQ(true, rg1_column1->is_stats_set());
-    ASSERT_EQ(true, rg1_column2->is_stats_set());
-    ASSERT_EQ(stats_float.min(), rg1_column2->statistics()->EncodeMin());
-    ASSERT_EQ(stats_float.max(), rg1_column2->statistics()->EncodeMax());
-    ASSERT_EQ(stats_int.min(), rg1_column1->statistics()->EncodeMin());
-    ASSERT_EQ(stats_int.max(), rg1_column1->statistics()->EncodeMax());
-    ASSERT_EQ(0, rg1_column1->statistics()->null_count());
-    ASSERT_EQ(0, rg1_column2->statistics()->null_count());
-    ASSERT_EQ(nrows, rg1_column1->statistics()->distinct_count());
-    ASSERT_EQ(nrows, rg1_column2->statistics()->distinct_count());
-    ASSERT_EQ(DEFAULT_COMPRESSION_TYPE, rg1_column1->compression());
-    ASSERT_EQ(DEFAULT_COMPRESSION_TYPE, rg1_column2->compression());
-    ASSERT_EQ(nrows / 2, rg1_column1->num_values());
-    ASSERT_EQ(nrows / 2, rg1_column2->num_values());
+        rg1Accessor->fileOffset(),
+        rg1Accessor->columnChunk(0)->dictionaryPageOffset());
+
+    auto rg1Column1 = rg1Accessor->columnChunk(0);
+    auto rg1Column2 = rg1Accessor->columnChunk(1);
+    ASSERT_EQ(true, rg1Column1->isStatsSet());
+    ASSERT_EQ(true, rg1Column2->isStatsSet());
+    ASSERT_EQ(statsFloat.min(), rg1Column2->statistics()->encodeMin());
+    ASSERT_EQ(statsFloat.max(), rg1Column2->statistics()->encodeMax());
+    ASSERT_EQ(statsInt.min(), rg1Column1->statistics()->encodeMin());
+    ASSERT_EQ(statsInt.max(), rg1Column1->statistics()->encodeMax());
+    ASSERT_EQ(0, rg1Column1->statistics()->nullCount());
+    ASSERT_EQ(0, rg1Column2->statistics()->nullCount());
+    ASSERT_EQ(nrows, rg1Column1->statistics()->distinctCount());
+    ASSERT_EQ(nrows, rg1Column2->statistics()->distinctCount());
+    ASSERT_EQ(DEFAULT_COMPRESSION_TYPE, rg1Column1->compression());
+    ASSERT_EQ(DEFAULT_COMPRESSION_TYPE, rg1Column2->compression());
+    ASSERT_EQ(nrows / 2, rg1Column1->numValues());
+    ASSERT_EQ(nrows / 2, rg1Column2->numValues());
     {
       std::set<Encoding::type> encodings{
-          Encoding::RLE, Encoding::RLE_DICTIONARY, Encoding::PLAIN};
-      AssertEncodings(*rg1_column1, encodings);
+          Encoding::kRle, Encoding::kRleDictionary, Encoding::kPlain};
+      assertEncodings(*rg1Column1, encodings);
     }
     {
       std::set<Encoding::type> encodings{
-          Encoding::RLE, Encoding::RLE_DICTIONARY, Encoding::PLAIN};
-      AssertEncodings(*rg1_column2, encodings);
+          Encoding::kRle, Encoding::kRleDictionary, Encoding::kPlain};
+      assertEncodings(*rg1Column2, encodings);
     }
-    ASSERT_EQ(512, rg1_column1->total_compressed_size());
-    ASSERT_EQ(512, rg1_column2->total_compressed_size());
-    ASSERT_EQ(600, rg1_column1->total_uncompressed_size());
-    ASSERT_EQ(600, rg1_column2->total_uncompressed_size());
-    ASSERT_EQ(4, rg1_column1->dictionary_page_offset());
-    ASSERT_EQ(24, rg1_column2->dictionary_page_offset());
-    ASSERT_EQ(10, rg1_column1->data_page_offset());
-    ASSERT_EQ(30, rg1_column2->data_page_offset());
-    ASSERT_EQ(3, rg1_column1->encoding_stats().size());
-    ASSERT_EQ(3, rg1_column2->encoding_stats().size());
-
-    auto rg2_accessor = f_accessors[loop_index]->RowGroup(1);
-    ASSERT_EQ(2, rg2_accessor->num_columns());
-    ASSERT_EQ(nrows / 2, rg2_accessor->num_rows());
-    ASSERT_EQ(1024, rg2_accessor->total_byte_size());
-    ASSERT_EQ(1024, rg2_accessor->total_compressed_size());
+    ASSERT_EQ(512, rg1Column1->totalCompressedSize());
+    ASSERT_EQ(512, rg1Column2->totalCompressedSize());
+    ASSERT_EQ(600, rg1Column1->totalUncompressedSize());
+    ASSERT_EQ(600, rg1Column2->totalUncompressedSize());
+    ASSERT_EQ(4, rg1Column1->dictionaryPageOffset());
+    ASSERT_EQ(24, rg1Column2->dictionaryPageOffset());
+    ASSERT_EQ(10, rg1Column1->dataPageOffset());
+    ASSERT_EQ(30, rg1Column2->dataPageOffset());
+    ASSERT_EQ(3, rg1Column1->encodingStats().size());
+    ASSERT_EQ(3, rg1Column2->encodingStats().size());
+
+    auto rg2Accessor = fAccessors[loopIndex]->rowGroup(1);
+    ASSERT_EQ(2, rg2Accessor->numColumns());
+    ASSERT_EQ(nrows / 2, rg2Accessor->numRows());
+    ASSERT_EQ(1024, rg2Accessor->totalByteSize());
+    ASSERT_EQ(1024, rg2Accessor->totalCompressedSize());
     EXPECT_EQ(
-        rg2_accessor->file_offset(),
-        rg2_accessor->ColumnChunk(0)->data_page_offset());
-
-    auto rg2_column1 = rg2_accessor->ColumnChunk(0);
-    auto rg2_column2 = rg2_accessor->ColumnChunk(1);
-    ASSERT_EQ(true, rg2_column1->is_stats_set());
-    ASSERT_EQ(true, rg2_column2->is_stats_set());
-    ASSERT_EQ(stats_float.min(), rg2_column2->statistics()->EncodeMin());
-    ASSERT_EQ(stats_float.max(), rg2_column2->statistics()->EncodeMax());
-    ASSERT_EQ(stats_int.min(), rg1_column1->statistics()->EncodeMin());
-    ASSERT_EQ(stats_int.max(), rg1_column1->statistics()->EncodeMax());
-    ASSERT_EQ(0, rg2_column1->statistics()->null_count());
-    ASSERT_EQ(0, rg2_column2->statistics()->null_count());
-    ASSERT_EQ(nrows, rg2_column1->statistics()->distinct_count());
-    ASSERT_EQ(nrows, rg2_column2->statistics()->distinct_count());
-    ASSERT_EQ(nrows / 2, rg2_column1->num_values());
-    ASSERT_EQ(nrows / 2, rg2_column2->num_values());
-    ASSERT_EQ(DEFAULT_COMPRESSION_TYPE, rg2_column1->compression());
-    ASSERT_EQ(DEFAULT_COMPRESSION_TYPE, rg2_column2->compression());
+        rg2Accessor->fileOffset(),
+        rg2Accessor->columnChunk(0)->dataPageOffset());
+
+    auto rg2Column1 = rg2Accessor->columnChunk(0);
+    auto rg2Column2 = rg2Accessor->columnChunk(1);
+    ASSERT_EQ(true, rg2Column1->isStatsSet());
+    ASSERT_EQ(true, rg2Column2->isStatsSet());
+    ASSERT_EQ(statsFloat.min(), rg2Column2->statistics()->encodeMin());
+    ASSERT_EQ(statsFloat.max(), rg2Column2->statistics()->encodeMax());
+    ASSERT_EQ(statsInt.min(), rg1Column1->statistics()->encodeMin());
+    ASSERT_EQ(statsInt.max(), rg1Column1->statistics()->encodeMax());
+    ASSERT_EQ(0, rg2Column1->statistics()->nullCount());
+    ASSERT_EQ(0, rg2Column2->statistics()->nullCount());
+    ASSERT_EQ(nrows, rg2Column1->statistics()->distinctCount());
+    ASSERT_EQ(nrows, rg2Column2->statistics()->distinctCount());
+    ASSERT_EQ(nrows / 2, rg2Column1->numValues());
+    ASSERT_EQ(nrows / 2, rg2Column2->numValues());
+    ASSERT_EQ(DEFAULT_COMPRESSION_TYPE, rg2Column1->compression());
+    ASSERT_EQ(DEFAULT_COMPRESSION_TYPE, rg2Column2->compression());
     {
-      std::set<Encoding::type> encodings{Encoding::RLE, Encoding::PLAIN};
-      AssertEncodings(*rg2_column1, encodings);
+      std::set<Encoding::type> encodings{Encoding::kRle, Encoding::kPlain};
+      assertEncodings(*rg2Column1, encodings);
     }
     {
       std::set<Encoding::type> encodings{
-          Encoding::RLE, Encoding::RLE_DICTIONARY, Encoding::PLAIN};
-      AssertEncodings(*rg2_column2, encodings);
+          Encoding::kRle, Encoding::kRleDictionary, Encoding::kPlain};
+      assertEncodings(*rg2Column2, encodings);
     }
-    ASSERT_EQ(512, rg2_column1->total_compressed_size());
-    ASSERT_EQ(512, rg2_column2->total_compressed_size());
-    ASSERT_EQ(600, rg2_column1->total_uncompressed_size());
-    ASSERT_EQ(600, rg2_column2->total_uncompressed_size());
-    EXPECT_FALSE(rg2_column1->has_dictionary_page());
-    ASSERT_EQ(0, rg2_column1->dictionary_page_offset());
-    ASSERT_EQ(16, rg2_column2->dictionary_page_offset());
-    ASSERT_EQ(10, rg2_column1->data_page_offset());
-    ASSERT_EQ(26, rg2_column2->data_page_offset());
-    ASSERT_EQ(2, rg2_column1->encoding_stats().size());
-    ASSERT_EQ(3, rg2_column2->encoding_stats().size());
-
-    // Test FileMetaData::set_file_path
-    ASSERT_TRUE(rg2_column1->file_path().empty());
-    f_accessors[loop_index]->set_file_path("/foo/bar/bar.parquet");
-    ASSERT_EQ("/foo/bar/bar.parquet", rg2_column1->file_path());
+    ASSERT_EQ(512, rg2Column1->totalCompressedSize());
+    ASSERT_EQ(512, rg2Column2->totalCompressedSize());
+    ASSERT_EQ(600, rg2Column1->totalUncompressedSize());
+    ASSERT_EQ(600, rg2Column2->totalUncompressedSize());
+    EXPECT_FALSE(rg2Column1->hasDictionaryPage());
+    ASSERT_EQ(0, rg2Column1->dictionaryPageOffset());
+    ASSERT_EQ(16, rg2Column2->dictionaryPageOffset());
+    ASSERT_EQ(10, rg2Column1->dataPageOffset());
+    ASSERT_EQ(26, rg2Column2->dataPageOffset());
+    ASSERT_EQ(2, rg2Column1->encodingStats().size());
+    ASSERT_EQ(3, rg2Column2->encodingStats().size());
+
+    // Test FileMetaData::set_file_path.
+    ASSERT_TRUE(rg2Column1->filePath().empty());
+    fAccessors[loopIndex]->setFilePath("/foo/bar/bar.parquet");
+    ASSERT_EQ("/foo/bar/bar.parquet", rg2Column1->filePath());
   }
 
-  // Test AppendRowGroups
-  auto f_accessor_2 =
-      GenerateTableMetaData(schema, props, nrows, stats_int, stats_float);
-  f_accessor->AppendRowGroups(*f_accessor_2);
-  ASSERT_EQ(4, f_accessor->num_row_groups());
-  ASSERT_EQ(nrows * 2, f_accessor->num_rows());
-  ASSERT_LE(0, static_cast<int>(f_accessor->size()));
-  ASSERT_EQ(ParquetVersion::PARQUET_2_6, f_accessor->version());
+  // Test AppendRowGroups.
+  auto fAccessor2 =
+      generateTableMetaData(schema, props, nrows, statsInt, statsFloat);
+  fAccessor->appendRowGroups(*fAccessor2);
+  ASSERT_EQ(4, fAccessor->numRowGroups());
+  ASSERT_EQ(nrows * 2, fAccessor->numRows());
+  ASSERT_LE(0, static_cast<int>(fAccessor->size()));
+  ASSERT_EQ(ParquetVersion::PARQUET_2_6, fAccessor->version());
   ASSERT_TRUE(
-      f_accessor->created_by().find(DEFAULT_CREATED_BY) != std::string::npos);
-  ASSERT_EQ(3, f_accessor->num_schema_elements());
+      fAccessor->createdBy().find(DEFAULT_CREATED_BY) != std::string::npos);
+  ASSERT_EQ(3, fAccessor->numSchemaElements());
 
   // Test AppendRowGroups from self (ARROW-13654)
-  f_accessor->AppendRowGroups(*f_accessor);
-  ASSERT_EQ(8, f_accessor->num_row_groups());
-  ASSERT_EQ(nrows * 4, f_accessor->num_rows());
-  ASSERT_EQ(3, f_accessor->num_schema_elements());
-
-  // Test Subset
-  auto f_accessor_1 = f_accessor->Subset({2, 3});
-  ASSERT_TRUE(f_accessor_1->Equals(*f_accessor_2));
-
-  f_accessor_1 = f_accessor_2->Subset({0});
-  f_accessor_1->AppendRowGroups(*f_accessor->Subset({0}));
-  ASSERT_TRUE(f_accessor_1->Equals(*f_accessor->Subset({2, 0})));
+  fAccessor->appendRowGroups(*fAccessor);
+  ASSERT_EQ(8, fAccessor->numRowGroups());
+  ASSERT_EQ(nrows * 4, fAccessor->numRows());
+  ASSERT_EQ(3, fAccessor->numSchemaElements());
+
+  // Test Subset.
+  auto fAccessor1 = fAccessor->subset({2, 3});
+  ASSERT_TRUE(fAccessor1->equals(*fAccessor2));
+
+  fAccessor1 = fAccessor2->subset({0});
+  fAccessor1->appendRowGroups(*fAccessor->subset({0}));
+  ASSERT_TRUE(fAccessor1->equals(*fAccessor->subset({2, 0})));
 }
 
 TEST(Metadata, TestV1Version) {
-  // PARQUET-839
+  // PARQUET-839.
   schema::NodeVector fields;
   schema::NodePtr root;
   SchemaDescriptor schema;
 
-  WriterProperties::Builder prop_builder;
+  WriterProperties::Builder propBuilder;
 
   std::shared_ptr<WriterProperties> props =
-      prop_builder.version(ParquetVersion::PARQUET_1_0)->build();
+      propBuilder.version(ParquetVersion::PARQUET_1_0)->build();
 
-  fields.push_back(schema::Int32("int_col", Repetition::REQUIRED));
-  fields.push_back(schema::Float("float_col", Repetition::REQUIRED));
-  root = schema::GroupNode::Make("schema", Repetition::REPEATED, fields);
-  schema.Init(root);
+  fields.push_back(schema::int32("int_col", Repetition::kRequired));
+  fields.push_back(schema::floatType("float_col", Repetition::kRequired));
+  root = schema::GroupNode::make("schema", Repetition::kRepeated, fields);
+  schema.init(root);
 
-  auto f_builder = FileMetaDataBuilder::Make(&schema, props);
+  auto fBuilder = FileMetaDataBuilder::make(&schema, props);
 
-  // Read the metadata
-  auto f_accessor = f_builder->Finish();
+  // Read the metadata.
+  auto fAccessor = fBuilder->finish();
 
-  // file metadata
-  ASSERT_EQ(ParquetVersion::PARQUET_1_0, f_accessor->version());
+  // File metadata.
+  ASSERT_EQ(ParquetVersion::PARQUET_1_0, fAccessor->version());
 }
 
 TEST(Metadata, TestKeyValueMetadata) {
@@ -350,69 +354,72 @@ TEST(Metadata, TestKeyValueMetadata) {
   schema::NodePtr root;
   SchemaDescriptor schema;
 
-  WriterProperties::Builder prop_builder;
+  WriterProperties::Builder propBuilder;
 
   std::shared_ptr<WriterProperties> props =
-      prop_builder.version(ParquetVersion::PARQUET_1_0)->build();
+      propBuilder.version(ParquetVersion::PARQUET_1_0)->build();
 
-  fields.push_back(schema::Int32("int_col", Repetition::REQUIRED));
-  fields.push_back(schema::Float("float_col", Repetition::REQUIRED));
-  root = schema::GroupNode::Make("schema", Repetition::REPEATED, fields);
-  schema.Init(root);
+  fields.push_back(schema::int32("int_col", Repetition::kRequired));
+  fields.push_back(schema::floatType("float_col", Repetition::kRequired));
+  root = schema::GroupNode::make("schema", Repetition::kRepeated, fields);
+  schema.init(root);
 
   auto kvmeta = std::make_shared<KeyValueMetadata>();
   kvmeta->Append("test_key", "test_value");
 
-  auto f_builder = FileMetaDataBuilder::Make(&schema, props);
+  auto fBuilder = FileMetaDataBuilder::make(&schema, props);
 
-  // Read the metadata
-  auto f_accessor = f_builder->Finish(kvmeta);
+  // Read the metadata.
+  auto fAccessor = fBuilder->finish(kvmeta);
 
-  // Key value metadata
-  ASSERT_TRUE(f_accessor->key_value_metadata());
-  EXPECT_TRUE(f_accessor->key_value_metadata()->Equals(*kvmeta));
+  // Key value metadata.
+  ASSERT_TRUE(fAccessor->keyValueMetadata());
+  EXPECT_TRUE(fAccessor->keyValueMetadata()->Equals(*kvmeta));
 }
 
 TEST(Metadata, TestAddKeyValueMetadata) {
   schema::NodeVector fields;
-  fields.push_back(schema::Int32("int_col", Repetition::REQUIRED));
+  fields.push_back(schema::int32("int_col", Repetition::kRequired));
   auto schema = std::static_pointer_cast<schema::GroupNode>(
-      schema::GroupNode::Make("schema", Repetition::REQUIRED, fields));
+      schema::GroupNode::make("schema", Repetition::kRequired, fields));
 
-  auto kv_meta = std::make_shared<KeyValueMetadata>();
-  kv_meta->Append("test_key_1", "test_value_1");
-  kv_meta->Append("test_key_2", "test_value_2_");
+  auto kvMeta = std::make_shared<KeyValueMetadata>();
+  kvMeta->Append("test_key_1", "test_value_1");
+  kvMeta->Append("test_key_2", "test_value_2_");
 
-  auto sink = CreateOutputStream();
-  auto writer_props = WriterProperties::Builder().disable_dictionary()->build();
-  auto file_writer =
-      ParquetFileWriter::Open(sink, schema, writer_props, kv_meta);
+  auto sink = createOutputStream();
+  auto writerProps = WriterProperties::Builder().disableDictionary()->build();
+  auto fileWriter = ParquetFileWriter::open(sink, schema, writerProps, kvMeta);
 
   // Key value metadata that will be added to the file.
-  auto kv_meta_added = std::make_shared<KeyValueMetadata>();
-  kv_meta_added->Append("test_key_2", "test_value_2");
-  kv_meta_added->Append("test_key_3", "test_value_3");
+  auto kvMetaAdded = std::make_shared<KeyValueMetadata>();
+  kvMetaAdded->Append("test_key_2", "test_value_2");
+  kvMetaAdded->Append("test_key_3", "test_value_3");
 
-  file_writer->AddKeyValueMetadata(kv_meta_added);
-  file_writer->Close();
+  fileWriter->addKeyValueMetadata(kvMetaAdded);
+  fileWriter->close();
 
   // Throw if appending key value metadata to closed file.
-  auto kv_meta_ignored = std::make_shared<KeyValueMetadata>();
-  kv_meta_ignored->Append("test_key_4", "test_value_4");
+  auto kvMetaIgnored = std::make_shared<KeyValueMetadata>();
+  kvMetaIgnored->Append("test_key_4", "test_value_4");
   EXPECT_THROW(
-      file_writer->AddKeyValueMetadata(kv_meta_ignored), ParquetException);
+      fileWriter->addKeyValueMetadata(kvMetaIgnored), ParquetException);
 
   PARQUET_ASSIGN_OR_THROW(auto buffer, sink->Finish());
 
-  // Write the buffer to a temp file path
-  auto filePath = exec::test::TempFilePath::create();
+  // Write the buffer to a temp file path.
+  auto filePath = TempFilePath::create();
   writeToFile(filePath, buffer);
   memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   std::shared_ptr<facebook::velox::memory::MemoryPool> rootPool =
       memory::memoryManager()->addRootPool("MetadataTest");
   std::shared_ptr<facebook::velox::memory::MemoryPool> leafPool =
       rootPool->addLeafChild("MetadataTest");
-  dwio::common::ReaderOptions readerOptions{leafPool.get()};
+  auto dataIoStats = std::make_shared<velox::io::IoStatistics>();
+  auto metadataIoStats = std::make_shared<velox::io::IoStatistics>();
+  dwio::common::ReaderOptions readerOptions(leafPool.get());
+  readerOptions.setDataIoStats(dataIoStats);
+  readerOptions.setMetadataIoStats(metadataIoStats);
   auto input = std::make_unique<dwio::common::BufferedInput>(
       std::make_shared<LocalReadFile>(filePath->getPath()),
       readerOptions.memoryPool());
@@ -470,7 +477,7 @@ TEST(Metadata, TestReadPageIndex) {
     auto col_chunk_metadata = row_group_metadata->ColumnChunk(i);
     auto ci_location = col_chunk_metadata->GetColumnIndexLocation();
     if (i == 10) {
-      // column_id 10 does not have column index
+      // Column_id 10 does not have column index.
       ASSERT_FALSE(ci_location.has_value());
     } else {
       ASSERT_TRUE(ci_location.has_value());
@@ -490,48 +497,52 @@ TEST(Metadata, TestReadPageIndex) {
 
 TEST(Metadata, TestSortingColumns) {
   schema::NodeVector fields;
-  fields.push_back(schema::Int32("sort_col", Repetition::REQUIRED));
-  fields.push_back(schema::Int32("int_col", Repetition::REQUIRED));
+  fields.push_back(schema::int32("sort_col", Repetition::kRequired));
+  fields.push_back(schema::int32("int_col", Repetition::kRequired));
 
   auto schema = std::static_pointer_cast<schema::GroupNode>(
-      schema::GroupNode::Make("schema", Repetition::REQUIRED, fields));
+      schema::GroupNode::make("schema", Repetition::kRequired, fields));
 
   std::vector<SortingColumn> sortingColumns;
   {
     SortingColumn sortingColumn;
-    sortingColumn.column_idx = 0;
+    sortingColumn.columnIdx = 0;
     sortingColumn.descending = false;
-    sortingColumn.nulls_first = false;
+    sortingColumn.nullsFirst = false;
     sortingColumns.push_back(sortingColumn);
   }
 
   auto createdBy = CREATED_BY_VERSION + std::string(" version 1.0");
-  auto sink = CreateOutputStream();
+  auto sink = createOutputStream();
   auto writerProps = WriterProperties::Builder()
-                         .disable_dictionary()
-                         ->set_sorting_columns(sortingColumns)
-                         ->created_by(createdBy)
+                         .disableDictionary()
+                         ->setSortingColumns(sortingColumns)
+                         ->createdBy(createdBy)
                          ->build();
 
-  EXPECT_EQ(sortingColumns, writerProps->sorting_columns());
+  EXPECT_EQ(sortingColumns, writerProps->sortingColumns());
 
-  auto fileWriter = ParquetFileWriter::Open(sink, schema, writerProps);
+  auto fileWriter = ParquetFileWriter::open(sink, schema, writerProps);
 
-  auto rowGroupWriter = fileWriter->AppendBufferedRowGroup();
-  rowGroupWriter->Close();
-  fileWriter->Close();
+  auto rowGroupWriter = fileWriter->appendBufferedRowGroup();
+  rowGroupWriter->close();
+  fileWriter->close();
 
   PARQUET_ASSIGN_OR_THROW(auto buffer, sink->Finish());
 
-  // Write the buffer to a temp file path
-  auto filePath = exec::test::TempFilePath::create();
+  // Write the buffer to a temp file path.
+  auto filePath = TempFilePath::create();
   writeToFile(filePath, buffer);
   memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   std::shared_ptr<facebook::velox::memory::MemoryPool> rootPool =
       memory::memoryManager()->addRootPool("MetadataTest");
   std::shared_ptr<facebook::velox::memory::MemoryPool> leafPool =
       rootPool->addLeafChild("MetadataTest");
-  dwio::common::ReaderOptions readerOptions{leafPool.get()};
+  auto dataIoStats = std::make_shared<velox::io::IoStatistics>();
+  auto metadataIoStats = std::make_shared<velox::io::IoStatistics>();
+  dwio::common::ReaderOptions readerOptions(leafPool.get());
+  readerOptions.setDataIoStats(dataIoStats);
+  readerOptions.setMetadataIoStats(metadataIoStats);
   auto input = std::make_unique<dwio::common::BufferedInput>(
       std::make_shared<LocalReadFile>(filePath->getPath()),
       readerOptions.memoryPool());
@@ -539,9 +550,9 @@ TEST(Metadata, TestSortingColumns) {
       std::make_unique<ParquetReader>(std::move(input), readerOptions);
   ASSERT_EQ(1, reader->fileMetaData().numRowGroups());
   auto rowGroup = reader->fileMetaData().rowGroup(0);
-  EXPECT_EQ(sortingColumns[0].column_idx, rowGroup.sortingColumnIdx(0));
+  EXPECT_EQ(sortingColumns[0].columnIdx, rowGroup.sortingColumnIdx(0));
   EXPECT_EQ(sortingColumns[0].descending, rowGroup.sortingColumnDescending(0));
-  EXPECT_EQ(sortingColumns[0].nulls_first, rowGroup.sortingColumnNullsFirst(0));
+  EXPECT_EQ(sortingColumns[0].nullsFirst, rowGroup.sortingColumnNullsFirst(0));
   ASSERT_EQ(createdBy, reader->fileMetaData().createdBy());
 }
 
@@ -570,53 +581,53 @@ TEST(ApplicationVersion, Basics) {
   ASSERT_EQ(5, version4.version.minor);
   ASSERT_EQ(0, version4.version.patch);
   ASSERT_EQ("ab", version4.version.unknown);
-  ASSERT_EQ("cdh5.5.0", version4.version.pre_release);
-  ASSERT_EQ("cd", version4.version.build_info);
+  ASSERT_EQ("cdh5.5.0", version4.version.preRelease);
+  ASSERT_EQ("cd", version4.version.buildInfo);
 
   ASSERT_EQ("parquet-mr", version5.application_);
   ASSERT_EQ(0, version5.version.major);
   ASSERT_EQ(0, version5.version.minor);
   ASSERT_EQ(0, version5.version.patch);
 
-  ASSERT_EQ(true, version.VersionLt(version1));
+  ASSERT_EQ(true, version.versionLt(version1));
 
   EncodedStatistics stats;
   ASSERT_FALSE(
-      version1.HasCorrectStatistics(Type::INT96, stats, SortOrder::UNKNOWN));
+      version1.hasCorrectStatistics(Type::kInt96, stats, SortOrder::kUnknown));
   ASSERT_TRUE(
-      version.HasCorrectStatistics(Type::INT32, stats, SortOrder::SIGNED));
-  ASSERT_FALSE(
-      version.HasCorrectStatistics(Type::BYTE_ARRAY, stats, SortOrder::SIGNED));
-  ASSERT_TRUE(version1.HasCorrectStatistics(
-      Type::BYTE_ARRAY, stats, SortOrder::SIGNED));
-  ASSERT_FALSE(version1.HasCorrectStatistics(
-      Type::BYTE_ARRAY, stats, SortOrder::UNSIGNED));
-  ASSERT_TRUE(version3.HasCorrectStatistics(
-      Type::FIXED_LEN_BYTE_ARRAY, stats, SortOrder::SIGNED));
-
-  // Check that the old stats are correct if min and max are the same
-  // regardless of sort order
-  EncodedStatistics stats_str;
-  stats_str.set_min("a").set_max("b");
-  ASSERT_FALSE(version1.HasCorrectStatistics(
-      Type::BYTE_ARRAY, stats_str, SortOrder::UNSIGNED));
-  stats_str.set_max("a");
-  ASSERT_TRUE(version1.HasCorrectStatistics(
-      Type::BYTE_ARRAY, stats_str, SortOrder::UNSIGNED));
-
-  // Check that the same holds true for ints
-  int32_t int_min = 100, int_max = 200;
-  EncodedStatistics stats_int;
-  stats_int.set_min(std::string(reinterpret_cast<const char*>(&int_min), 4))
-      .set_max(std::string(reinterpret_cast<const char*>(&int_max), 4));
-  ASSERT_FALSE(version1.HasCorrectStatistics(
-      Type::BYTE_ARRAY, stats_int, SortOrder::UNSIGNED));
-  stats_int.set_max(std::string(reinterpret_cast<const char*>(&int_min), 4));
-  ASSERT_TRUE(version1.HasCorrectStatistics(
-      Type::BYTE_ARRAY, stats_int, SortOrder::UNSIGNED));
+      version.hasCorrectStatistics(Type::kInt32, stats, SortOrder::kSigned));
+  ASSERT_FALSE(version.hasCorrectStatistics(
+      Type::kByteArray, stats, SortOrder::kSigned));
+  ASSERT_TRUE(version1.hasCorrectStatistics(
+      Type::kByteArray, stats, SortOrder::kSigned));
+  ASSERT_FALSE(version1.hasCorrectStatistics(
+      Type::kByteArray, stats, SortOrder::kUnsigned));
+  ASSERT_TRUE(version3.hasCorrectStatistics(
+      Type::kFixedLenByteArray, stats, SortOrder::kSigned));
+
+  // Check that the old stats are correct if min and max are the same.
+  // Regardless of sort order.
+  EncodedStatistics statsStr;
+  statsStr.setMin("a").setMax("b");
+  ASSERT_FALSE(version1.hasCorrectStatistics(
+      Type::kByteArray, statsStr, SortOrder::kUnsigned));
+  statsStr.setMax("a");
+  ASSERT_TRUE(version1.hasCorrectStatistics(
+      Type::kByteArray, statsStr, SortOrder::kUnsigned));
+
+  // Check that the same holds true for ints.
+  int32_t intMin = 100, intMax = 200;
+  EncodedStatistics statsInt;
+  statsInt.setMin(std::string(reinterpret_cast<const char*>(&intMin), 4))
+      .setMax(std::string(reinterpret_cast<const char*>(&intMax), 4));
+  ASSERT_FALSE(version1.hasCorrectStatistics(
+      Type::kByteArray, statsInt, SortOrder::kUnsigned));
+  statsInt.setMax(std::string(reinterpret_cast<const char*>(&intMin), 4));
+  ASSERT_TRUE(version1.hasCorrectStatistics(
+      Type::kByteArray, statsInt, SortOrder::kUnsigned));
 }
 
-TEST(ApplicationVersion, Empty) {
+TEST(ApplicationVersion, empty) {
   ApplicationVersion version("");
 
   ASSERT_EQ("", version.application_);
@@ -625,8 +636,8 @@ TEST(ApplicationVersion, Empty) {
   ASSERT_EQ(0, version.version.minor);
   ASSERT_EQ(0, version.version.patch);
   ASSERT_EQ("", version.version.unknown);
-  ASSERT_EQ("", version.version.pre_release);
-  ASSERT_EQ("", version.version.build_info);
+  ASSERT_EQ("", version.version.preRelease);
+  ASSERT_EQ("", version.version.buildInfo);
 }
 
 TEST(ApplicationVersion, NoVersion) {
@@ -638,8 +649,8 @@ TEST(ApplicationVersion, NoVersion) {
   ASSERT_EQ(0, version.version.minor);
   ASSERT_EQ(0, version.version.patch);
   ASSERT_EQ("", version.version.unknown);
-  ASSERT_EQ("", version.version.pre_release);
-  ASSERT_EQ("", version.version.build_info);
+  ASSERT_EQ("", version.version.preRelease);
+  ASSERT_EQ("", version.version.buildInfo);
 }
 
 TEST(ApplicationVersion, VersionEmpty) {
@@ -651,8 +662,8 @@ TEST(ApplicationVersion, VersionEmpty) {
   ASSERT_EQ(0, version.version.minor);
   ASSERT_EQ(0, version.version.patch);
   ASSERT_EQ("", version.version.unknown);
-  ASSERT_EQ("", version.version.pre_release);
-  ASSERT_EQ("", version.version.build_info);
+  ASSERT_EQ("", version.version.preRelease);
+  ASSERT_EQ("", version.version.buildInfo);
 }
 
 TEST(ApplicationVersion, VersionNoMajor) {
@@ -664,8 +675,8 @@ TEST(ApplicationVersion, VersionNoMajor) {
   ASSERT_EQ(0, version.version.minor);
   ASSERT_EQ(0, version.version.patch);
   ASSERT_EQ("", version.version.unknown);
-  ASSERT_EQ("", version.version.pre_release);
-  ASSERT_EQ("", version.version.build_info);
+  ASSERT_EQ("", version.version.preRelease);
+  ASSERT_EQ("", version.version.buildInfo);
 }
 
 TEST(ApplicationVersion, VersionInvalidMajor) {
@@ -677,8 +688,8 @@ TEST(ApplicationVersion, VersionInvalidMajor) {
   ASSERT_EQ(0, version.version.minor);
   ASSERT_EQ(0, version.version.patch);
   ASSERT_EQ("", version.version.unknown);
-  ASSERT_EQ("", version.version.pre_release);
-  ASSERT_EQ("", version.version.build_info);
+  ASSERT_EQ("", version.version.preRelease);
+  ASSERT_EQ("", version.version.buildInfo);
 }
 
 TEST(ApplicationVersion, VersionMajorOnly) {
@@ -690,8 +701,8 @@ TEST(ApplicationVersion, VersionMajorOnly) {
   ASSERT_EQ(0, version.version.minor);
   ASSERT_EQ(0, version.version.patch);
   ASSERT_EQ("", version.version.unknown);
-  ASSERT_EQ("", version.version.pre_release);
-  ASSERT_EQ("", version.version.build_info);
+  ASSERT_EQ("", version.version.preRelease);
+  ASSERT_EQ("", version.version.buildInfo);
 }
 
 TEST(ApplicationVersion, VersionNoMinor) {
@@ -703,8 +714,8 @@ TEST(ApplicationVersion, VersionNoMinor) {
   ASSERT_EQ(0, version.version.minor);
   ASSERT_EQ(0, version.version.patch);
   ASSERT_EQ("", version.version.unknown);
-  ASSERT_EQ("", version.version.pre_release);
-  ASSERT_EQ("", version.version.build_info);
+  ASSERT_EQ("", version.version.preRelease);
+  ASSERT_EQ("", version.version.buildInfo);
 }
 
 TEST(ApplicationVersion, VersionMajorMinorOnly) {
@@ -716,8 +727,8 @@ TEST(ApplicationVersion, VersionMajorMinorOnly) {
   ASSERT_EQ(7, version.version.minor);
   ASSERT_EQ(0, version.version.patch);
   ASSERT_EQ("", version.version.unknown);
-  ASSERT_EQ("", version.version.pre_release);
-  ASSERT_EQ("", version.version.build_info);
+  ASSERT_EQ("", version.version.preRelease);
+  ASSERT_EQ("", version.version.buildInfo);
 }
 
 TEST(ApplicationVersion, VersionInvalidMinor) {
@@ -729,8 +740,8 @@ TEST(ApplicationVersion, VersionInvalidMinor) {
   ASSERT_EQ(0, version.version.minor);
   ASSERT_EQ(0, version.version.patch);
   ASSERT_EQ("", version.version.unknown);
-  ASSERT_EQ("", version.version.pre_release);
-  ASSERT_EQ("", version.version.build_info);
+  ASSERT_EQ("", version.version.preRelease);
+  ASSERT_EQ("", version.version.buildInfo);
 }
 
 TEST(ApplicationVersion, VersionNoPatch) {
@@ -742,8 +753,8 @@ TEST(ApplicationVersion, VersionNoPatch) {
   ASSERT_EQ(7, version.version.minor);
   ASSERT_EQ(0, version.version.patch);
   ASSERT_EQ("", version.version.unknown);
-  ASSERT_EQ("", version.version.pre_release);
-  ASSERT_EQ("", version.version.build_info);
+  ASSERT_EQ("", version.version.preRelease);
+  ASSERT_EQ("", version.version.buildInfo);
 }
 
 TEST(ApplicationVersion, VersionInvalidPatch) {
@@ -755,8 +766,8 @@ TEST(ApplicationVersion, VersionInvalidPatch) {
   ASSERT_EQ(7, version.version.minor);
   ASSERT_EQ(0, version.version.patch);
   ASSERT_EQ("", version.version.unknown);
-  ASSERT_EQ("", version.version.pre_release);
-  ASSERT_EQ("", version.version.build_info);
+  ASSERT_EQ("", version.version.preRelease);
+  ASSERT_EQ("", version.version.buildInfo);
 }
 
 TEST(ApplicationVersion, VersionNoUnknown) {
@@ -768,8 +779,8 @@ TEST(ApplicationVersion, VersionNoUnknown) {
   ASSERT_EQ(7, version.version.minor);
   ASSERT_EQ(9, version.version.patch);
   ASSERT_EQ("", version.version.unknown);
-  ASSERT_EQ("cdh5.5.0", version.version.pre_release);
-  ASSERT_EQ("cd", version.version.build_info);
+  ASSERT_EQ("cdh5.5.0", version.version.preRelease);
+  ASSERT_EQ("cd", version.version.buildInfo);
 }
 
 TEST(ApplicationVersion, VersionNoPreRelease) {
@@ -781,8 +792,8 @@ TEST(ApplicationVersion, VersionNoPreRelease) {
   ASSERT_EQ(7, version.version.minor);
   ASSERT_EQ(9, version.version.patch);
   ASSERT_EQ("ab", version.version.unknown);
-  ASSERT_EQ("", version.version.pre_release);
-  ASSERT_EQ("cd", version.version.build_info);
+  ASSERT_EQ("", version.version.preRelease);
+  ASSERT_EQ("cd", version.version.buildInfo);
 }
 
 TEST(ApplicationVersion, VersionNoUnknownNoPreRelease) {
@@ -794,8 +805,8 @@ TEST(ApplicationVersion, VersionNoUnknownNoPreRelease) {
   ASSERT_EQ(7, version.version.minor);
   ASSERT_EQ(9, version.version.patch);
   ASSERT_EQ("", version.version.unknown);
-  ASSERT_EQ("", version.version.pre_release);
-  ASSERT_EQ("cd", version.version.build_info);
+  ASSERT_EQ("", version.version.preRelease);
+  ASSERT_EQ("cd", version.version.buildInfo);
 }
 
 TEST(ApplicationVersion, VersionNoUnknownBuildInfoPreRelease) {
@@ -807,8 +818,8 @@ TEST(ApplicationVersion, VersionNoUnknownBuildInfoPreRelease) {
   ASSERT_EQ(7, version.version.minor);
   ASSERT_EQ(9, version.version.patch);
   ASSERT_EQ("", version.version.unknown);
-  ASSERT_EQ("", version.version.pre_release);
-  ASSERT_EQ("cd-cdh5.5.0", version.version.build_info);
+  ASSERT_EQ("", version.version.preRelease);
+  ASSERT_EQ("cd-cdh5.5.0", version.version.buildInfo);
 }
 
 TEST(ApplicationVersion, FullWithSpaces) {
@@ -821,8 +832,8 @@ TEST(ApplicationVersion, FullWithSpaces) {
   ASSERT_EQ(5, version.version.minor);
   ASSERT_EQ(3, version.version.patch);
   ASSERT_EQ("ab", version.version.unknown);
-  ASSERT_EQ("cdh5.5.0", version.version.pre_release);
-  ASSERT_EQ("cd", version.version.build_info);
+  ASSERT_EQ("cdh5.5.0", version.version.preRelease);
+  ASSERT_EQ("cd", version.version.buildInfo);
 }
 
 } // namespace metadata
diff --git a/velox/dwio/parquet/writer/arrow/tests/PageIndexTest.cpp b/velox/dwio/parquet/writer/arrow/tests/PageIndexTest.cpp
index fd175e2a821..1d4797bb4dd 100644
--- a/velox/dwio/parquet/writer/arrow/tests/PageIndexTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/PageIndexTest.cpp
@@ -26,117 +26,115 @@
 namespace facebook::velox::parquet::arrow {
 
 struct PageIndexRanges {
-  int64_t column_index_offset;
-  int64_t column_index_length;
-  int64_t offset_index_offset;
-  int64_t offset_index_length;
+  int64_t columnIndexOffset;
+  int64_t columnIndexLength;
+  int64_t offsetIndexOffset;
+  int64_t offsetIndexLength;
 };
 
 using RowGroupRanges = std::vector<PageIndexRanges>;
 
-/// Creates an FileMetaData object w/ single row group based on data in
-/// 'row_group_ranges'. It sets the offsets and sizes of the column index and
-/// offset index members of the row group. It doesn't set the member if the
-/// input value is -1.
-std::shared_ptr<FileMetaData> ConstructFakeMetaData(
-    const RowGroupRanges& row_group_ranges) {
-  facebook::velox::parquet::thrift::RowGroup row_group;
-  for (auto& page_index_ranges : row_group_ranges) {
-    facebook::velox::parquet::thrift::ColumnChunk col_chunk;
-    if (page_index_ranges.column_index_offset != -1) {
-      col_chunk.__set_column_index_offset(
-          page_index_ranges.column_index_offset);
+/// Creates an FileMetaData object w/ single row group based on data in.
+/// 'Row_group_ranges'. It sets the offsets and sizes of the column index and.
+/// Offset index members of the row group. It doesn't set the member if the.
+/// Input value is -1.
+std::shared_ptr<FileMetaData> constructFakeMetaData(
+    const RowGroupRanges& rowGroupRanges) {
+  facebook::velox::parquet::thrift::RowGroup rowGroup;
+  for (auto& pageIndexRanges : rowGroupRanges) {
+    facebook::velox::parquet::thrift::ColumnChunk colChunk;
+    if (pageIndexRanges.columnIndexOffset != -1) {
+      colChunk.__set_column_index_offset(pageIndexRanges.columnIndexOffset);
     }
-    if (page_index_ranges.column_index_length != -1) {
-      col_chunk.__set_column_index_length(
-          static_cast<int32_t>(page_index_ranges.column_index_length));
+    if (pageIndexRanges.columnIndexLength != -1) {
+      colChunk.__set_column_index_length(
+          static_cast<int32_t>(pageIndexRanges.columnIndexLength));
     }
-    if (page_index_ranges.offset_index_offset != -1) {
-      col_chunk.__set_offset_index_offset(
-          page_index_ranges.offset_index_offset);
+    if (pageIndexRanges.offsetIndexOffset != -1) {
+      colChunk.__set_offset_index_offset(pageIndexRanges.offsetIndexOffset);
     }
-    if (page_index_ranges.offset_index_length != -1) {
-      col_chunk.__set_offset_index_length(
-          static_cast<int32_t>(page_index_ranges.offset_index_length));
+    if (pageIndexRanges.offsetIndexLength != -1) {
+      colChunk.__set_offset_index_length(
+          static_cast<int32_t>(pageIndexRanges.offsetIndexLength));
     }
-    row_group.columns.push_back(col_chunk);
+    rowGroup.columns.push_back(colChunk);
   }
 
   facebook::velox::parquet::thrift::FileMetaData metadata;
-  metadata.row_groups.push_back(row_group);
+  metadata.row_groups.push_back(rowGroup);
 
   metadata.schema.emplace_back();
   schema::NodeVector fields;
-  for (size_t i = 0; i < row_group_ranges.size(); ++i) {
-    fields.push_back(schema::Int64(std::to_string(i)));
+  for (size_t i = 0; i < rowGroupRanges.size(); ++i) {
+    fields.push_back(schema::int64(std::to_string(i)));
     metadata.schema.emplace_back();
-    fields.back()->ToParquet(&metadata.schema.back());
+    fields.back()->toParquet(&metadata.schema.back());
   }
-  schema::GroupNode::Make("schema", Repetition::REPEATED, fields)
-      ->ToParquet(&metadata.schema.front());
+  schema::GroupNode::make("schema", Repetition::kRepeated, fields)
+      ->toParquet(&metadata.schema.front());
 
-  auto sink = CreateOutputStream();
-  ThriftSerializer{}.Serialize(&metadata, sink.get());
+  auto sink = createOutputStream();
+  ThriftSerializer{}.serialize(&metadata, sink.get());
   auto buffer = sink->Finish().MoveValueUnsafe();
   uint32_t len = static_cast<uint32_t>(buffer->size());
-  return FileMetaData::Make(buffer->data(), &len);
+  return FileMetaData::make(buffer->data(), &len);
 }
 
-/// Validates that 'DeterminePageIndexRangesInRowGroup()' selects the expected
-/// file offsets and sizes or returns false when the row group doesn't have a
-/// page index.
-void ValidatePageIndexRange(
-    const RowGroupRanges& row_group_ranges,
-    const std::vector<int32_t>& column_indices,
-    bool expected_has_column_index,
-    bool expected_has_offset_index,
-    int expected_ci_start,
-    int expected_ci_size,
-    int expected_oi_start,
-    int expected_oi_size) {
-  auto file_metadata = ConstructFakeMetaData(row_group_ranges);
-  auto read_range = PageIndexReader::DeterminePageIndexRangesInRowGroup(
-      *file_metadata->RowGroup(0), column_indices);
-  ASSERT_EQ(expected_has_column_index, read_range.column_index.has_value());
-  ASSERT_EQ(expected_has_offset_index, read_range.offset_index.has_value());
-  if (expected_has_column_index) {
-    EXPECT_EQ(expected_ci_start, read_range.column_index->offset);
-    EXPECT_EQ(expected_ci_size, read_range.column_index->length);
+/// Validates that 'DeterminePageIndexRangesInRowGroup()' selects the expected.
+/// File offsets and sizes or returns false when the row group doesn't have a.
+/// Page index.
+void validatePageIndexRange(
+    const RowGroupRanges& rowGroupRanges,
+    const std::vector<int32_t>& columnIndices,
+    bool expectedHasColumnIndex,
+    bool expectedHasOffsetIndex,
+    int expectedCiStart,
+    int expectedCiSize,
+    int expectedOiStart,
+    int expectedOiSize) {
+  auto fileMetadata = constructFakeMetaData(rowGroupRanges);
+  auto readRange = PageIndexReader::determinePageIndexRangesInRowGroup(
+      *fileMetadata->rowGroup(0), columnIndices);
+  ASSERT_EQ(expectedHasColumnIndex, readRange.columnIndex.has_value());
+  ASSERT_EQ(expectedHasOffsetIndex, readRange.offsetIndex.has_value());
+  if (expectedHasColumnIndex) {
+    EXPECT_EQ(expectedCiStart, readRange.columnIndex->offset);
+    EXPECT_EQ(expectedCiSize, readRange.columnIndex->length);
   }
-  if (expected_has_offset_index) {
-    EXPECT_EQ(expected_oi_start, read_range.offset_index->offset);
-    EXPECT_EQ(expected_oi_size, read_range.offset_index->length);
+  if (expectedHasOffsetIndex) {
+    EXPECT_EQ(expectedOiStart, readRange.offsetIndex->offset);
+    EXPECT_EQ(expectedOiSize, readRange.offsetIndex->length);
   }
 }
 
-/// This test constructs a couple of artificial row groups with page index
-/// offsets in them. Then it validates if
-/// PageIndexReader::DeterminePageIndexRangesInRowGroup() properly computes the
-/// file range that contains the whole page index.
-TEST(PageIndex, DeterminePageIndexRangesInRowGroup) {
-  // No Column chunks
-  ValidatePageIndexRange({}, {}, false, false, -1, -1, -1, -1);
+/// This test constructs a couple of artificial row groups with page index.
+/// Offsets in them. Then it validates if.
+/// PageIndexReader::DeterminePageIndexRangesInRowGroup() properly computes the.
+/// File range that contains the whole page index.
+TEST(PageIndex, determinePageIndexRangesInRowGroup) {
+  // No Column chunks.
+  validatePageIndexRange({}, {}, false, false, -1, -1, -1, -1);
   // No page index at all.
-  ValidatePageIndexRange({{-1, -1, -1, -1}}, {}, false, false, -1, -1, -1, -1);
+  validatePageIndexRange({{-1, -1, -1, -1}}, {}, false, false, -1, -1, -1, -1);
   // Page index for single column chunk.
-  ValidatePageIndexRange({{10, 5, 15, 5}}, {}, true, true, 10, 5, 15, 5);
+  validatePageIndexRange({{10, 5, 15, 5}}, {}, true, true, 10, 5, 15, 5);
   // Page index for two column chunks.
-  ValidatePageIndexRange(
+  validatePageIndexRange(
       {{10, 5, 30, 25}, {15, 15, 50, 20}}, {}, true, true, 10, 20, 30, 40);
   // Page index for second column chunk.
-  ValidatePageIndexRange(
+  validatePageIndexRange(
       {{-1, -1, -1, -1}, {20, 10, 30, 25}}, {}, true, true, 20, 10, 30, 25);
   // Page index for first column chunk.
-  ValidatePageIndexRange(
+  validatePageIndexRange(
       {{10, 5, 15, 5}, {-1, -1, -1, -1}}, {}, true, true, 10, 5, 15, 5);
   // Missing offset index for first column chunk. Gap in column index.
-  ValidatePageIndexRange(
+  validatePageIndexRange(
       {{10, 5, -1, -1}, {20, 10, 30, 25}}, {}, true, true, 10, 20, 30, 25);
   // Missing offset index for second column chunk.
-  ValidatePageIndexRange(
+  validatePageIndexRange(
       {{10, 5, 25, 5}, {20, 10, -1, -1}}, {}, true, true, 10, 20, 25, 5);
   // Four column chunks.
-  ValidatePageIndexRange(
+  validatePageIndexRange(
       {{100, 10, 220, 30},
        {110, 25, 250, 10},
        {140, 30, 260, 40},
@@ -150,23 +148,23 @@ TEST(PageIndex, DeterminePageIndexRangesInRowGroup) {
       180);
 }
 
-/// This test constructs a couple of artificial row groups with page index
-/// offsets in them. Then it validates if
-/// PageIndexReader::DeterminePageIndexRangesInRowGroup() properly computes the
-/// file range that contains the page index of selected columns.
+/// This test constructs a couple of artificial row groups with page index.
+/// Offsets in them. Then it validates if.
+/// PageIndexReader::DeterminePageIndexRangesInRowGroup() properly computes the.
+/// File range that contains the page index of selected columns.
 TEST(PageIndex, DeterminePageIndexRangesInRowGroupWithPartialColumnsSelected) {
   // No page index at all.
-  ValidatePageIndexRange({{-1, -1, -1, -1}}, {0}, false, false, -1, -1, -1, -1);
+  validatePageIndexRange({{-1, -1, -1, -1}}, {0}, false, false, -1, -1, -1, -1);
   // Page index for single column chunk.
-  ValidatePageIndexRange({{10, 5, 15, 5}}, {0}, true, true, 10, 5, 15, 5);
+  validatePageIndexRange({{10, 5, 15, 5}}, {0}, true, true, 10, 5, 15, 5);
   // Page index for the 1st column chunk.
-  ValidatePageIndexRange(
+  validatePageIndexRange(
       {{10, 5, 30, 25}, {15, 15, 50, 20}}, {0}, true, true, 10, 5, 30, 25);
   // Page index for the 2nd column chunk.
-  ValidatePageIndexRange(
+  validatePageIndexRange(
       {{10, 5, 30, 25}, {15, 15, 50, 20}}, {1}, true, true, 15, 15, 50, 20);
   // Only 2nd column is selected among four column chunks.
-  ValidatePageIndexRange(
+  validatePageIndexRange(
       {{100, 10, 220, 30},
        {110, 25, 250, 10},
        {140, 30, 260, 40},
@@ -179,7 +177,7 @@ TEST(PageIndex, DeterminePageIndexRangesInRowGroupWithPartialColumnsSelected) {
       250,
       10);
   // Only 2nd and 3rd columns are selected among four column chunks.
-  ValidatePageIndexRange(
+  validatePageIndexRange(
       {{100, 10, 220, 30},
        {110, 25, 250, 10},
        {140, 30, 260, 40},
@@ -192,7 +190,7 @@ TEST(PageIndex, DeterminePageIndexRangesInRowGroupWithPartialColumnsSelected) {
       250,
       50);
   // Only 2nd and 4th columns are selected among four column chunks.
-  ValidatePageIndexRange(
+  validatePageIndexRange(
       {{100, 10, 220, 30},
        {110, 25, 250, 10},
        {140, 30, 260, 40},
@@ -205,7 +203,7 @@ TEST(PageIndex, DeterminePageIndexRangesInRowGroupWithPartialColumnsSelected) {
       250,
       150);
   // Only 1st, 2nd and 4th columns are selected among four column chunks.
-  ValidatePageIndexRange(
+  validatePageIndexRange(
       {{100, 10, 220, 30},
        {110, 25, 250, 10},
        {140, 30, 260, 40},
@@ -217,9 +215,9 @@ TEST(PageIndex, DeterminePageIndexRangesInRowGroupWithPartialColumnsSelected) {
       110,
       220,
       180);
-  // 3rd column is selected but not present in the row group.
+  // 3Rd column is selected but not present in the row group.
   EXPECT_THROW(
-      ValidatePageIndexRange(
+      validatePageIndexRange(
           {{10, 5, 30, 25}, {15, 15, 50, 20}},
           {2},
           false,
@@ -231,101 +229,101 @@ TEST(PageIndex, DeterminePageIndexRangesInRowGroupWithPartialColumnsSelected) {
       ParquetException);
 }
 
-/// This test constructs a couple of artificial row groups with page index
-/// offsets in them. Then it validates if
-/// PageIndexReader::DeterminePageIndexRangesInRowGroup() properly detects if
-/// column index or offset index is missing.
+/// This test constructs a couple of artificial row groups with page index.
+/// Offsets in them. Then it validates if.
+/// PageIndexReader::DeterminePageIndexRangesInRowGroup() properly detects if.
+/// Column index or offset index is missing.
 TEST(PageIndex, DeterminePageIndexRangesInRowGroupWithMissingPageIndex) {
   // No column index at all.
-  ValidatePageIndexRange({{-1, -1, 15, 5}}, {}, false, true, -1, -1, 15, 5);
+  validatePageIndexRange({{-1, -1, 15, 5}}, {}, false, true, -1, -1, 15, 5);
   // No offset index at all.
-  ValidatePageIndexRange({{10, 5, -1, -1}}, {}, true, false, 10, 5, -1, -1);
+  validatePageIndexRange({{10, 5, -1, -1}}, {}, true, false, 10, 5, -1, -1);
   // No column index at all among two column chunks.
-  ValidatePageIndexRange(
+  validatePageIndexRange(
       {{-1, -1, 30, 25}, {-1, -1, 50, 20}}, {}, false, true, -1, -1, 30, 40);
   // No offset index at all among two column chunks.
-  ValidatePageIndexRange(
+  validatePageIndexRange(
       {{10, 5, -1, -1}, {15, 15, -1, -1}}, {}, true, false, 10, 20, -1, -1);
 }
 
 TEST(PageIndex, WriteOffsetIndex) {
   /// Create offset index via the OffsetIndexBuilder interface.
-  auto builder = OffsetIndexBuilder::Make();
-  const size_t num_pages = 5;
+  auto Builder = OffsetIndexBuilder::make();
+  const size_t numPages = 5;
   const std::vector<int64_t> offsets = {100, 200, 300, 400, 500};
-  const std::vector<int32_t> page_sizes = {1024, 2048, 3072, 4096, 8192};
-  const std::vector<int64_t> first_row_indices = {
-      0, 10000, 20000, 30000, 40000};
-  for (size_t i = 0; i < num_pages; ++i) {
-    builder->AddPage(offsets[i], page_sizes[i], first_row_indices[i]);
+  const std::vector<int32_t> pageSizes = {1024, 2048, 3072, 4096, 8192};
+  const std::vector<int64_t> firstRowIndices = {0, 10000, 20000, 30000, 40000};
+  for (size_t i = 0; i < numPages; ++i) {
+    Builder->addPage(offsets[i], pageSizes[i], firstRowIndices[i]);
   }
-  const int64_t final_position = 4096;
-  builder->Finish(final_position);
-
-  std::vector<std::unique_ptr<OffsetIndex>> offset_indexes;
-  /// 1st element is the offset index just built.
-  offset_indexes.emplace_back(builder->Build());
-  /// 2nd element is the offset index restored by serialize-then-deserialize
-  /// round trip.
-  auto sink = CreateOutputStream();
-  builder->WriteTo(sink.get());
+  const int64_t finalPosition = 4096;
+  Builder->finish(finalPosition);
+
+  std::vector<std::unique_ptr<OffsetIndex>> offsetIndexes;
+  /// 1St element is the offset index just built.
+  offsetIndexes.emplace_back(Builder->build());
+  /// 2Nd element is the offset index restored by serialize-then-deserialize.
+  /// Round trip.
+  auto sink = createOutputStream();
+  Builder->writeTo(sink.get());
   PARQUET_ASSIGN_OR_THROW(auto buffer, sink->Finish());
-  offset_indexes.emplace_back(OffsetIndex::Make(
-      buffer->data(),
-      static_cast<uint32_t>(buffer->size()),
-      default_reader_properties()));
+  offsetIndexes.emplace_back(
+      OffsetIndex::make(
+          buffer->data(),
+          static_cast<uint32_t>(buffer->size()),
+          defaultReaderProperties()));
 
   /// Verify the data of the offset index.
-  for (const auto& offset_index : offset_indexes) {
-    ASSERT_EQ(num_pages, offset_index->page_locations().size());
-    for (size_t i = 0; i < num_pages; ++i) {
-      const auto& page_location = offset_index->page_locations().at(i);
-      ASSERT_EQ(offsets[i] + final_position, page_location.offset);
-      ASSERT_EQ(page_sizes[i], page_location.compressed_page_size);
-      ASSERT_EQ(first_row_indices[i], page_location.first_row_index);
+  for (const auto& offsetIndex : offsetIndexes) {
+    ASSERT_EQ(numPages, offsetIndex->pageLocations().size());
+    for (size_t i = 0; i < numPages; ++i) {
+      const auto& pageLocation = offsetIndex->pageLocations().at(i);
+      ASSERT_EQ(offsets[i] + finalPosition, pageLocation.offset);
+      ASSERT_EQ(pageSizes[i], pageLocation.compressedPageSize);
+      ASSERT_EQ(firstRowIndices[i], pageLocation.firstRowIndex);
     }
   }
 }
 
-void TestWriteTypedColumnIndex(
-    schema::NodePtr node,
-    const std::vector<EncodedStatistics>& page_stats,
-    BoundaryOrder::type boundary_order,
-    bool has_null_counts) {
-  auto descr =
-      std::make_unique<ColumnDescriptor>(node, /*max_definition_level=*/1, 0);
-
-  auto builder = ColumnIndexBuilder::Make(descr.get());
-  for (const auto& stats : page_stats) {
-    builder->AddPage(stats);
+void testWriteTypedColumnIndex(
+    schema::NodePtr Node,
+    const std::vector<EncodedStatistics>& pageStats,
+    BoundaryOrder::type boundaryOrder,
+    bool hasNullCounts) {
+  auto descr = std::make_unique<ColumnDescriptor>(Node, 1, 0);
+
+  auto Builder = ColumnIndexBuilder::make(descr.get());
+  for (const auto& stats : pageStats) {
+    Builder->addPage(stats);
   }
-  ASSERT_NO_THROW(builder->Finish());
-
-  std::vector<std::unique_ptr<ColumnIndex>> column_indexes;
-  /// 1st element is the column index just built.
-  column_indexes.emplace_back(builder->Build());
-  /// 2nd element is the column index restored by serialize-then-deserialize
-  /// round trip.
-  auto sink = CreateOutputStream();
-  builder->WriteTo(sink.get());
+  ASSERT_NO_THROW(Builder->finish());
+
+  std::vector<std::unique_ptr<ColumnIndex>> columnIndexes;
+  /// 1St element is the column index just built.
+  columnIndexes.emplace_back(Builder->build());
+  /// 2Nd element is the column index restored by serialize-then-deserialize.
+  /// Round trip.
+  auto sink = createOutputStream();
+  Builder->writeTo(sink.get());
   PARQUET_ASSIGN_OR_THROW(auto buffer, sink->Finish());
-  column_indexes.emplace_back(ColumnIndex::Make(
-      *descr,
-      buffer->data(),
-      static_cast<uint32_t>(buffer->size()),
-      default_reader_properties()));
+  columnIndexes.emplace_back(
+      ColumnIndex::make(
+          *descr,
+          buffer->data(),
+          static_cast<uint32_t>(buffer->size()),
+          defaultReaderProperties()));
 
   /// Verify the data of the column index.
-  for (const auto& column_index : column_indexes) {
-    ASSERT_EQ(boundary_order, column_index->boundary_order());
-    ASSERT_EQ(has_null_counts, column_index->has_null_counts());
-    const size_t num_pages = column_index->null_pages().size();
-    for (size_t i = 0; i < num_pages; ++i) {
-      ASSERT_EQ(page_stats[i].all_null_value, column_index->null_pages()[i]);
-      ASSERT_EQ(page_stats[i].min(), column_index->encoded_min_values()[i]);
-      ASSERT_EQ(page_stats[i].max(), column_index->encoded_max_values()[i]);
-      if (has_null_counts) {
-        ASSERT_EQ(page_stats[i].null_count, column_index->null_counts()[i]);
+  for (const auto& columnIndex : columnIndexes) {
+    ASSERT_EQ(boundaryOrder, columnIndex->boundaryOrder());
+    ASSERT_EQ(hasNullCounts, columnIndex->hasNullCounts());
+    const size_t numPages = columnIndex->nullPages().size();
+    for (size_t i = 0; i < numPages; ++i) {
+      ASSERT_EQ(pageStats[i].allNullValue, columnIndex->nullPages()[i]);
+      ASSERT_EQ(pageStats[i].min(), columnIndex->encodedMinValues()[i]);
+      ASSERT_EQ(pageStats[i].max(), columnIndex->encodedMaxValues()[i]);
+      if (hasNullCounts) {
+        ASSERT_EQ(pageStats[i].nullCount, columnIndex->nullCounts()[i]);
       }
     }
   }
@@ -337,16 +335,13 @@ TEST(PageIndex, WriteInt32ColumnIndex) {
   };
 
   // Integer values in the ascending order.
-  std::vector<EncodedStatistics> page_stats(3);
-  page_stats.at(0).set_null_count(1).set_min(encode(1)).set_max(encode(2));
-  page_stats.at(1).set_null_count(2).set_min(encode(2)).set_max(encode(3));
-  page_stats.at(2).set_null_count(3).set_min(encode(3)).set_max(encode(4));
-
-  TestWriteTypedColumnIndex(
-      schema::Int32("c1"),
-      page_stats,
-      BoundaryOrder::Ascending,
-      /*has_null_counts=*/true);
+  std::vector<EncodedStatistics> pageStats(3);
+  pageStats.at(0).setNullCount(1).setMin(encode(1)).setMax(encode(2));
+  pageStats.at(1).setNullCount(2).setMin(encode(2)).setMax(encode(3));
+  pageStats.at(2).setNullCount(3).setMin(encode(3)).setMax(encode(4));
+
+  testWriteTypedColumnIndex(
+      schema::int32("c1"), pageStats, BoundaryOrder::kAscending, true);
 }
 
 TEST(PageIndex, WriteInt64ColumnIndex) {
@@ -355,16 +350,13 @@ TEST(PageIndex, WriteInt64ColumnIndex) {
   };
 
   // Integer values in the descending order.
-  std::vector<EncodedStatistics> page_stats(3);
-  page_stats.at(0).set_null_count(4).set_min(encode(-1)).set_max(encode(-2));
-  page_stats.at(1).set_null_count(0).set_min(encode(-2)).set_max(encode(-3));
-  page_stats.at(2).set_null_count(4).set_min(encode(-3)).set_max(encode(-4));
-
-  TestWriteTypedColumnIndex(
-      schema::Int64("c1"),
-      page_stats,
-      BoundaryOrder::Descending,
-      /*has_null_counts=*/true);
+  std::vector<EncodedStatistics> pageStats(3);
+  pageStats.at(0).setNullCount(4).setMin(encode(-1)).setMax(encode(-2));
+  pageStats.at(1).setNullCount(0).setMin(encode(-2)).setMax(encode(-3));
+  pageStats.at(2).setNullCount(4).setMin(encode(-3)).setMax(encode(-4));
+
+  testWriteTypedColumnIndex(
+      schema::int64("c1"), pageStats, BoundaryOrder::kDescending, true);
 }
 
 TEST(PageIndex, WriteFloatColumnIndex) {
@@ -373,25 +365,13 @@ TEST(PageIndex, WriteFloatColumnIndex) {
   };
 
   // Float values with no specific order.
-  std::vector<EncodedStatistics> page_stats(3);
-  page_stats.at(0)
-      .set_null_count(0)
-      .set_min(encode(2.2F))
-      .set_max(encode(4.4F));
-  page_stats.at(1)
-      .set_null_count(0)
-      .set_min(encode(1.1F))
-      .set_max(encode(5.5F));
-  page_stats.at(2)
-      .set_null_count(0)
-      .set_min(encode(3.3F))
-      .set_max(encode(6.6F));
-
-  TestWriteTypedColumnIndex(
-      schema::Float("c1"),
-      page_stats,
-      BoundaryOrder::Unordered,
-      /*has_null_counts=*/true);
+  std::vector<EncodedStatistics> pageStats(3);
+  pageStats.at(0).setNullCount(0).setMin(encode(2.2F)).setMax(encode(4.4F));
+  pageStats.at(1).setNullCount(0).setMin(encode(1.1F)).setMax(encode(5.5F));
+  pageStats.at(2).setNullCount(0).setMin(encode(3.3F)).setMax(encode(6.6F));
+
+  testWriteTypedColumnIndex(
+      schema::floatType("c1"), pageStats, BoundaryOrder::kUnordered, true);
 }
 
 TEST(PageIndex, WriteDoubleColumnIndex) {
@@ -400,66 +380,54 @@ TEST(PageIndex, WriteDoubleColumnIndex) {
   };
 
   // Double values with no specific order and without null count.
-  std::vector<EncodedStatistics> page_stats(3);
-  page_stats.at(0).set_min(encode(1.2)).set_max(encode(4.4));
-  page_stats.at(1).set_min(encode(2.2)).set_max(encode(5.5));
-  page_stats.at(2).set_min(encode(3.3)).set_max(encode(-6.6));
-
-  TestWriteTypedColumnIndex(
-      schema::Double("c1"),
-      page_stats,
-      BoundaryOrder::Unordered,
-      /*has_null_counts=*/false);
+  std::vector<EncodedStatistics> pageStats(3);
+  pageStats.at(0).setMin(encode(1.2)).setMax(encode(4.4));
+  pageStats.at(1).setMin(encode(2.2)).setMax(encode(5.5));
+  pageStats.at(2).setMin(encode(3.3)).setMax(encode(-6.6));
+
+  testWriteTypedColumnIndex(
+      schema::doubleType("c1"), pageStats, BoundaryOrder::kUnordered, false);
 }
 
 TEST(PageIndex, WriteByteArrayColumnIndex) {
   // Byte array values with identical min/max.
-  std::vector<EncodedStatistics> page_stats(3);
-  page_stats.at(0).set_min("bar").set_max("foo");
-  page_stats.at(1).set_min("bar").set_max("foo");
-  page_stats.at(2).set_min("bar").set_max("foo");
-
-  TestWriteTypedColumnIndex(
-      schema::ByteArray("c1"),
-      page_stats,
-      BoundaryOrder::Ascending,
-      /*has_null_counts=*/false);
+  std::vector<EncodedStatistics> pageStats(3);
+  pageStats.at(0).setMin("bar").setMax("foo");
+  pageStats.at(1).setMin("bar").setMax("foo");
+  pageStats.at(2).setMin("bar").setMax("foo");
+
+  testWriteTypedColumnIndex(
+      schema::byteArray("c1"), pageStats, BoundaryOrder::kAscending, false);
 }
 
 TEST(PageIndex, WriteFLBAColumnIndex) {
-  // FLBA values in the ascending order with some null pages
-  std::vector<EncodedStatistics> page_stats(5);
-  page_stats.at(0).set_min("abc").set_max("ABC");
-  page_stats.at(1).all_null_value = true;
-  page_stats.at(2).set_min("foo").set_max("FOO");
-  page_stats.at(3).all_null_value = true;
-  page_stats.at(4).set_min("xyz").set_max("XYZ");
-
-  auto node = schema::PrimitiveNode::Make(
+  // FLBA values in the ascending order with some null pages.
+  std::vector<EncodedStatistics> pageStats(5);
+  pageStats.at(0).setMin("abc").setMax("ABC");
+  pageStats.at(1).allNullValue = true;
+  pageStats.at(2).setMin("foo").setMax("FOO");
+  pageStats.at(3).allNullValue = true;
+  pageStats.at(4).setMin("xyz").setMax("XYZ");
+
+  auto Node = schema::PrimitiveNode::make(
       "c1",
-      Repetition::OPTIONAL,
-      Type::FIXED_LEN_BYTE_ARRAY,
-      ConvertedType::NONE,
-      /*length=*/3);
-  TestWriteTypedColumnIndex(
-      std::move(node),
-      page_stats,
-      BoundaryOrder::Ascending,
-      /*has_null_counts=*/false);
+      Repetition::kOptional,
+      Type::kFixedLenByteArray,
+      ConvertedType::kNone,
+      3);
+  testWriteTypedColumnIndex(
+      std::move(Node), pageStats, BoundaryOrder::kAscending, false);
 }
 
 TEST(PageIndex, WriteColumnIndexWithAllNullPages) {
   // All values are null.
-  std::vector<EncodedStatistics> page_stats(3);
-  page_stats.at(0).set_null_count(100).all_null_value = true;
-  page_stats.at(1).set_null_count(100).all_null_value = true;
-  page_stats.at(2).set_null_count(100).all_null_value = true;
-
-  TestWriteTypedColumnIndex(
-      schema::Int32("c1"),
-      page_stats,
-      BoundaryOrder::Unordered,
-      /*has_null_counts=*/true);
+  std::vector<EncodedStatistics> pageStats(3);
+  pageStats.at(0).setNullCount(100).allNullValue = true;
+  pageStats.at(1).setNullCount(100).allNullValue = true;
+  pageStats.at(2).setNullCount(100).allNullValue = true;
+
+  testWriteTypedColumnIndex(
+      schema::int32("c1"), pageStats, BoundaryOrder::kUnordered, true);
 }
 
 TEST(PageIndex, WriteColumnIndexWithInvalidNullCounts) {
@@ -467,17 +435,14 @@ TEST(PageIndex, WriteColumnIndexWithInvalidNullCounts) {
     return std::string(reinterpret_cast<const char*>(&value), sizeof(int32_t));
   };
 
-  // Some pages do not provide null_count
-  std::vector<EncodedStatistics> page_stats(3);
-  page_stats.at(0).set_min(encode(1)).set_max(encode(2)).set_null_count(0);
-  page_stats.at(1).set_min(encode(1)).set_max(encode(3));
-  page_stats.at(2).set_min(encode(2)).set_max(encode(3)).set_null_count(0);
-
-  TestWriteTypedColumnIndex(
-      schema::Int32("c1"),
-      page_stats,
-      BoundaryOrder::Ascending,
-      /*has_null_counts=*/false);
+  // Some pages do not provide null_count.
+  std::vector<EncodedStatistics> pageStats(3);
+  pageStats.at(0).setMin(encode(1)).setMax(encode(2)).setNullCount(0);
+  pageStats.at(1).setMin(encode(1)).setMax(encode(3));
+  pageStats.at(2).setMin(encode(2)).setMax(encode(3)).setNullCount(0);
+
+  testWriteTypedColumnIndex(
+      schema::int32("c1"), pageStats, BoundaryOrder::kAscending, false);
 }
 
 TEST(PageIndex, WriteColumnIndexWithCorruptedStats) {
@@ -485,153 +450,150 @@ TEST(PageIndex, WriteColumnIndexWithCorruptedStats) {
     return std::string(reinterpret_cast<const char*>(&value), sizeof(int32_t));
   };
 
-  // 2nd page does not set anything
-  std::vector<EncodedStatistics> page_stats(3);
-  page_stats.at(0).set_min(encode(1)).set_max(encode(2));
-  page_stats.at(2).set_min(encode(3)).set_max(encode(4));
+  // 2Nd page does not set anything.
+  std::vector<EncodedStatistics> pageStats(3);
+  pageStats.at(0).setMin(encode(1)).setMax(encode(2));
+  pageStats.at(2).setMin(encode(3)).setMax(encode(4));
 
-  ColumnDescriptor descr(schema::Int32("c1"), /*max_definition_level=*/1, 0);
-  auto builder = ColumnIndexBuilder::Make(&descr);
-  for (const auto& stats : page_stats) {
-    builder->AddPage(stats);
+  ColumnDescriptor descr(schema::int32("c1"), 1, 0);
+  auto Builder = ColumnIndexBuilder::make(&descr);
+  for (const auto& stats : pageStats) {
+    Builder->addPage(stats);
   }
-  ASSERT_NO_THROW(builder->Finish());
-  ASSERT_EQ(nullptr, builder->Build());
+  ASSERT_NO_THROW(Builder->finish());
+  ASSERT_EQ(nullptr, Builder->build());
 
-  auto sink = CreateOutputStream();
-  builder->WriteTo(sink.get());
+  auto sink = createOutputStream();
+  Builder->writeTo(sink.get());
   PARQUET_ASSIGN_OR_THROW(auto buffer, sink->Finish());
   EXPECT_EQ(0, buffer->size());
 }
 
 TEST(PageIndex, TestPageIndexBuilderWithZeroRowGroup) {
-  schema::NodeVector fields = {schema::Int32("c1"), schema::ByteArray("c2")};
+  schema::NodeVector fields = {schema::int32("c1"), schema::byteArray("c2")};
   schema::NodePtr root =
-      schema::GroupNode::Make("schema", Repetition::REPEATED, fields);
+      schema::GroupNode::make("schema", Repetition::kRepeated, fields);
   SchemaDescriptor schema;
-  schema.Init(root);
+  schema.init(root);
 
-  auto builder = PageIndexBuilder::Make(&schema);
+  auto Builder = PageIndexBuilder::make(&schema);
 
   // AppendRowGroup() is not called and expect throw.
-  ASSERT_THROW(builder->GetColumnIndexBuilder(0), ParquetException);
-  ASSERT_THROW(builder->GetOffsetIndexBuilder(0), ParquetException);
+  ASSERT_THROW(Builder->getColumnIndexBuilder(0), ParquetException);
+  ASSERT_THROW(Builder->getOffsetIndexBuilder(0), ParquetException);
 
   // Finish the builder without calling AppendRowGroup().
-  ASSERT_NO_THROW(builder->Finish());
+  ASSERT_NO_THROW(Builder->finish());
 
   // Verify WriteTo does not write anything.
-  auto sink = CreateOutputStream();
+  auto sink = createOutputStream();
   PageIndexLocation location;
-  builder->WriteTo(sink.get(), &location);
+  Builder->writeTo(sink.get(), &location);
   PARQUET_ASSIGN_OR_THROW(auto buffer, sink->Finish());
   ASSERT_EQ(0, buffer->size());
-  ASSERT_TRUE(location.column_index_location.empty());
-  ASSERT_TRUE(location.offset_index_location.empty());
+  ASSERT_TRUE(location.columnIndexLocation.empty());
+  ASSERT_TRUE(location.offsetIndexLocation.empty());
 }
 
 class PageIndexBuilderTest : public ::testing::Test {
  public:
-  void WritePageIndexes(
-      int num_row_groups,
-      int num_columns,
-      const std::vector<std::vector<EncodedStatistics>>& page_stats,
-      const std::vector<std::vector<PageLocation>>& page_locations,
-      int final_position) {
-    auto builder = PageIndexBuilder::Make(&schema_);
-    for (int row_group = 0; row_group < num_row_groups; ++row_group) {
-      ASSERT_NO_THROW(builder->AppendRowGroup());
-
-      for (int column = 0; column < num_columns; ++column) {
-        if (static_cast<size_t>(column) < page_stats[row_group].size()) {
-          auto column_index_builder = builder->GetColumnIndexBuilder(column);
+  void writePageIndexes(
+      int numRowGroups,
+      int numColumns,
+      const std::vector<std::vector<EncodedStatistics>>& pageStats,
+      const std::vector<std::vector<PageLocation>>& pageLocations,
+      int finalPosition) {
+    auto Builder = PageIndexBuilder::make(&schema_);
+    for (int rowGroup = 0; rowGroup < numRowGroups; ++rowGroup) {
+      ASSERT_NO_THROW(Builder->appendRowGroup());
+
+      for (int column = 0; column < numColumns; ++column) {
+        if (static_cast<size_t>(column) < pageStats[rowGroup].size()) {
+          auto ColumnIndexBuilder = Builder->getColumnIndexBuilder(column);
           ASSERT_NO_THROW(
-              column_index_builder->AddPage(page_stats[row_group][column]));
-          ASSERT_NO_THROW(column_index_builder->Finish());
+              ColumnIndexBuilder->addPage(pageStats[rowGroup][column]));
+          ASSERT_NO_THROW(ColumnIndexBuilder->finish());
         }
 
-        if (static_cast<size_t>(column) < page_locations[row_group].size()) {
-          auto offset_index_builder = builder->GetOffsetIndexBuilder(column);
+        if (static_cast<size_t>(column) < pageLocations[rowGroup].size()) {
+          auto OffsetIndexBuilder = Builder->getOffsetIndexBuilder(column);
           ASSERT_NO_THROW(
-              offset_index_builder->AddPage(page_locations[row_group][column]));
-          ASSERT_NO_THROW(offset_index_builder->Finish(final_position));
+              OffsetIndexBuilder->addPage(pageLocations[rowGroup][column]));
+          ASSERT_NO_THROW(OffsetIndexBuilder->finish(finalPosition));
         }
       }
     }
-    ASSERT_NO_THROW(builder->Finish());
+    ASSERT_NO_THROW(Builder->finish());
 
-    auto sink = CreateOutputStream();
-    builder->WriteTo(sink.get(), &page_index_location_);
+    auto sink = createOutputStream();
+    Builder->writeTo(sink.get(), &pageIndexLocation_);
     PARQUET_ASSIGN_OR_THROW(buffer_, sink->Finish());
 
     ASSERT_EQ(
-        static_cast<size_t>(num_row_groups),
-        page_index_location_.column_index_location.size());
+        static_cast<size_t>(numRowGroups),
+        pageIndexLocation_.columnIndexLocation.size());
     ASSERT_EQ(
-        static_cast<size_t>(num_row_groups),
-        page_index_location_.offset_index_location.size());
-    for (int row_group = 0; row_group < num_row_groups; ++row_group) {
+        static_cast<size_t>(numRowGroups),
+        pageIndexLocation_.offsetIndexLocation.size());
+    for (int rowGroup = 0; rowGroup < numRowGroups; ++rowGroup) {
       ASSERT_EQ(
-          static_cast<size_t>(num_columns),
-          page_index_location_.column_index_location[row_group].size());
+          static_cast<size_t>(numColumns),
+          pageIndexLocation_.columnIndexLocation[rowGroup].size());
       ASSERT_EQ(
-          static_cast<size_t>(num_columns),
-          page_index_location_.offset_index_location[row_group].size());
+          static_cast<size_t>(numColumns),
+          pageIndexLocation_.offsetIndexLocation[rowGroup].size());
     }
   }
 
   void
-  CheckColumnIndex(int row_group, int column, const EncodedStatistics& stats) {
-    auto column_index = ReadColumnIndex(row_group, column);
-    ASSERT_NE(nullptr, column_index);
-    ASSERT_EQ(size_t{1}, column_index->null_pages().size());
-    ASSERT_EQ(stats.all_null_value, column_index->null_pages()[0]);
-    ASSERT_EQ(stats.min(), column_index->encoded_min_values()[0]);
-    ASSERT_EQ(stats.max(), column_index->encoded_max_values()[0]);
-    ASSERT_EQ(stats.has_null_count, column_index->has_null_counts());
-    if (stats.has_null_count) {
-      ASSERT_EQ(stats.null_count, column_index->null_counts()[0]);
+  checkColumnIndex(int rowGroup, int column, const EncodedStatistics& stats) {
+    auto columnIndex = readColumnIndex(rowGroup, column);
+    ASSERT_NE(nullptr, columnIndex);
+    ASSERT_EQ(size_t{1}, columnIndex->nullPages().size());
+    ASSERT_EQ(stats.allNullValue, columnIndex->nullPages()[0]);
+    ASSERT_EQ(stats.min(), columnIndex->encodedMinValues()[0]);
+    ASSERT_EQ(stats.max(), columnIndex->encodedMaxValues()[0]);
+    ASSERT_EQ(stats.hasNullCount, columnIndex->hasNullCounts());
+    if (stats.hasNullCount) {
+      ASSERT_EQ(stats.nullCount, columnIndex->nullCounts()[0]);
     }
   }
 
-  void CheckOffsetIndex(
-      int row_group,
+  void checkOffsetIndex(
+      int rowGroup,
       int column,
-      const PageLocation& expected_location,
-      int64_t final_location) {
-    auto offset_index = ReadOffsetIndex(row_group, column);
-    ASSERT_NE(nullptr, offset_index);
-    ASSERT_EQ(size_t{1}, offset_index->page_locations().size());
-    const auto& location = offset_index->page_locations()[0];
-    ASSERT_EQ(expected_location.offset + final_location, location.offset);
-    ASSERT_EQ(
-        expected_location.compressed_page_size, location.compressed_page_size);
-    ASSERT_EQ(expected_location.first_row_index, location.first_row_index);
+      const PageLocation& expectedLocation,
+      int64_t finalLocation) {
+    auto offsetIndex = readOffsetIndex(rowGroup, column);
+    ASSERT_NE(nullptr, offsetIndex);
+    ASSERT_EQ(size_t{1}, offsetIndex->pageLocations().size());
+    const auto& location = offsetIndex->pageLocations()[0];
+    ASSERT_EQ(expectedLocation.offset + finalLocation, location.offset);
+    ASSERT_EQ(expectedLocation.compressedPageSize, location.compressedPageSize);
+    ASSERT_EQ(expectedLocation.firstRowIndex, location.firstRowIndex);
   }
 
  protected:
-  std::unique_ptr<ColumnIndex> ReadColumnIndex(int row_group, int column) {
-    auto location =
-        page_index_location_.column_index_location[row_group][column];
+  std::unique_ptr<ColumnIndex> readColumnIndex(int rowGroup, int column) {
+    auto location = pageIndexLocation_.columnIndexLocation[rowGroup][column];
     if (!location.has_value()) {
       return nullptr;
     }
-    auto properties = default_reader_properties();
-    return ColumnIndex::Make(
-        *schema_.Column(column),
+    auto properties = defaultReaderProperties();
+    return ColumnIndex::make(
+        *schema_.column(column),
         buffer_->data() + location->offset,
         static_cast<uint32_t>(location->length),
         properties);
   }
 
-  std::unique_ptr<OffsetIndex> ReadOffsetIndex(int row_group, int column) {
-    auto location =
-        page_index_location_.offset_index_location[row_group][column];
+  std::unique_ptr<OffsetIndex> readOffsetIndex(int rowGroup, int column) {
+    auto location = pageIndexLocation_.offsetIndexLocation[rowGroup][column];
     if (!location.has_value()) {
       return nullptr;
     }
-    auto properties = default_reader_properties();
-    return OffsetIndex::Make(
+    auto properties = defaultReaderProperties();
+    return OffsetIndex::make(
         buffer_->data() + location->offset,
         static_cast<uint32_t>(location->length),
         properties);
@@ -639,118 +601,96 @@ class PageIndexBuilderTest : public ::testing::Test {
 
   SchemaDescriptor schema_;
   std::shared_ptr<Buffer> buffer_;
-  PageIndexLocation page_index_location_;
+  PageIndexLocation pageIndexLocation_;
 };
 
 TEST_F(PageIndexBuilderTest, SingleRowGroup) {
-  schema::NodePtr root = schema::GroupNode::Make(
+  schema::NodePtr root = schema::GroupNode::make(
       "schema",
-      Repetition::REPEATED,
-      {schema::ByteArray("c1"),
-       schema::ByteArray("c2"),
-       schema::ByteArray("c3")});
-  schema_.Init(root);
+      Repetition::kRepeated,
+      {schema::byteArray("c1"),
+       schema::byteArray("c2"),
+       schema::byteArray("c3")});
+  schema_.init(root);
 
   // Prepare page stats and page locations for single row group.
-  // Note that the 3rd column does not have any stats and its page index is
-  // disabled.
-  const int num_row_groups = 1;
-  const int num_columns = 3;
-  const std::vector<std::vector<EncodedStatistics>> page_stats = {
+  // Note that the 3rd column does not have any stats and its page index is.
+  // Disabled.
+  const int numRowGroups = 1;
+  const int numColumns = 3;
+  const std::vector<std::vector<EncodedStatistics>> pageStats = {
       /*row_group_id=0*/
-      {/*column_id=0*/ EncodedStatistics()
-           .set_null_count(0)
-           .set_min("a")
-           .set_max("b"),
+      {/*column_id=0*/ EncodedStatistics().setNullCount(0).setMin("a").setMax(
+           "b"),
        /*column_id=1*/
-       EncodedStatistics().set_null_count(0).set_min("A").set_max("B")}};
-  const std::vector<std::vector<PageLocation>> page_locations = {
+       EncodedStatistics().setNullCount(0).setMin("A").setMax("B")}};
+  const std::vector<std::vector<PageLocation>> pageLocations = {
       /*row_group_id=0*/
-      {/*column_id=0*/ {
-           /*offset=*/128,
-           /*compressed_page_size=*/512,
-           /*first_row_index=*/0},
+      {/*column_id=0*/ {128, 512, 0},
        /*column_id=1*/
-       {/*offset=*/1024,
-        /*compressed_page_size=*/512,
-        /*first_row_index=*/0}}};
-  const int64_t final_position = 200;
+       {1024, 512, 0}}};
+  const int64_t finalPosition = 200;
 
-  WritePageIndexes(
-      num_row_groups, num_columns, page_stats, page_locations, final_position);
+  writePageIndexes(
+      numRowGroups, numColumns, pageStats, pageLocations, finalPosition);
 
   // Verify that first two columns have good page indexes.
   for (int column = 0; column < 2; ++column) {
-    CheckColumnIndex(/*row_group=*/0, column, page_stats[0][column]);
-    CheckOffsetIndex(
-        /*row_group=*/0, column, page_locations[0][column], final_position);
+    checkColumnIndex(0, column, pageStats[0][column]);
+    checkOffsetIndex(0, column, pageLocations[0][column], finalPosition);
   }
 
   // Verify the 3rd column does not have page indexes.
-  ASSERT_EQ(nullptr, ReadColumnIndex(/*row_group=*/0, /*column=*/2));
-  ASSERT_EQ(nullptr, ReadOffsetIndex(/*row_group=*/0, /*column=*/2));
+  ASSERT_EQ(nullptr, readColumnIndex(0, 2));
+  ASSERT_EQ(nullptr, readOffsetIndex(0, 2));
 }
 
 TEST_F(PageIndexBuilderTest, TwoRowGroups) {
-  schema::NodePtr root = schema::GroupNode::Make(
+  schema::NodePtr root = schema::GroupNode::make(
       "schema",
-      Repetition::REPEATED,
-      {schema::ByteArray("c1"), schema::ByteArray("c2")});
-  schema_.Init(root);
+      Repetition::kRepeated,
+      {schema::byteArray("c1"), schema::byteArray("c2")});
+  schema_.init(root);
 
   // Prepare page stats and page locations for two row groups.
   // Note that the 2nd column in the 2nd row group has corrupted stats.
-  const int num_row_groups = 2;
-  const int num_columns = 2;
-  const std::vector<std::vector<EncodedStatistics>> page_stats = {
+  const int numRowGroups = 2;
+  const int numColumns = 2;
+  const std::vector<std::vector<EncodedStatistics>> pageStats = {
       /*row_group_id=0*/
-      {/*column_id=0*/ EncodedStatistics().set_min("a").set_max("b"),
+      {/*column_id=0*/ EncodedStatistics().setMin("a").setMax("b"),
        /*column_id=1*/
-       EncodedStatistics().set_null_count(0).set_min("A").set_max("B")},
+       EncodedStatistics().setNullCount(0).setMin("A").setMax("B")},
       /*row_group_id=1*/
       {/*column_id=0*/ EncodedStatistics() /* corrupted stats */,
        /*column_id=1*/
-       EncodedStatistics().set_null_count(0).set_min("bar").set_max("foo")}};
-  const std::vector<std::vector<PageLocation>> page_locations = {
+       EncodedStatistics().setNullCount(0).setMin("bar").setMax("foo")}};
+  const std::vector<std::vector<PageLocation>> pageLocations = {
       /*row_group_id=0*/
-      {/*column_id=0*/ {
-           /*offset=*/128,
-           /*compressed_page_size=*/512,
-           /*first_row_index=*/0},
+      {/*column_id=0*/ {128, 512, 0},
        /*column_id=1*/
-       {/*offset=*/1024,
-        /*compressed_page_size=*/512,
-        /*first_row_index=*/0}},
+       {1024, 512, 0}},
       /*row_group_id=0*/
-      {/*column_id=0*/ {
-           /*offset=*/128,
-           /*compressed_page_size=*/512,
-           /*first_row_index=*/0},
+      {/*column_id=0*/ {128, 512, 0},
        /*column_id=1*/
-       {/*offset=*/1024,
-        /*compressed_page_size=*/512,
-        /*first_row_index=*/0}}};
-  const int64_t final_position = 200;
+       {1024, 512, 0}}};
+  const int64_t finalPosition = 200;
 
-  WritePageIndexes(
-      num_row_groups, num_columns, page_stats, page_locations, final_position);
+  writePageIndexes(
+      numRowGroups, numColumns, pageStats, pageLocations, finalPosition);
 
-  // Verify that all columns have good column indexes except the 2nd column in
-  // the 2nd row group.
-  CheckColumnIndex(/*row_group=*/0, /*column=*/0, page_stats[0][0]);
-  CheckColumnIndex(/*row_group=*/0, /*column=*/1, page_stats[0][1]);
-  CheckColumnIndex(/*row_group=*/1, /*column=*/1, page_stats[1][1]);
-  ASSERT_EQ(nullptr, ReadColumnIndex(/*row_group=*/1, /*column=*/0));
+  // Verify that all columns have good column indexes except the 2nd column in.
+  // The 2nd row group.
+  checkColumnIndex(0, 0, pageStats[0][0]);
+  checkColumnIndex(0, 1, pageStats[0][1]);
+  checkColumnIndex(1, 1, pageStats[1][1]);
+  ASSERT_EQ(nullptr, readColumnIndex(1, 0));
 
   // Verify that two columns have good offset indexes.
-  CheckOffsetIndex(
-      /*row_group=*/0, /*column=*/0, page_locations[0][0], final_position);
-  CheckOffsetIndex(
-      /*row_group=*/0, /*column=*/1, page_locations[0][1], final_position);
-  CheckOffsetIndex(
-      /*row_group=*/1, /*column=*/0, page_locations[1][0], final_position);
-  CheckOffsetIndex(
-      /*row_group=*/1, /*column=*/1, page_locations[1][1], final_position);
+  checkOffsetIndex(0, 0, pageLocations[0][0], finalPosition);
+  checkOffsetIndex(0, 1, pageLocations[0][1], finalPosition);
+  checkOffsetIndex(1, 0, pageLocations[1][0], finalPosition);
+  checkOffsetIndex(1, 1, pageLocations[1][1], finalPosition);
 }
 
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/tests/PropertiesTest.cpp b/velox/dwio/parquet/writer/arrow/tests/PropertiesTest.cpp
index 0b3f29737e6..27f9589b793 100644
--- a/velox/dwio/parquet/writer/arrow/tests/PropertiesTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/PropertiesTest.cpp
@@ -34,63 +34,63 @@ namespace test {
 TEST(TestReaderProperties, Basics) {
   ReaderProperties props;
 
-  ASSERT_EQ(props.buffer_size(), kDefaultBufferSize);
-  ASSERT_FALSE(props.is_buffered_stream_enabled());
-  ASSERT_FALSE(props.page_checksum_verification());
+  ASSERT_EQ(props.bufferSize(), kDefaultBufferSize);
+  ASSERT_FALSE(props.isBufferedStreamEnabled());
+  ASSERT_FALSE(props.pageChecksumVerification());
 }
 
 TEST(TestWriterProperties, Basics) {
   std::shared_ptr<WriterProperties> props = WriterProperties::Builder().build();
 
-  ASSERT_EQ(kDefaultDataPageSize, props->data_pagesize());
+  ASSERT_EQ(kDefaultDataPageSize, props->dataPagesize());
   ASSERT_EQ(
-      DEFAULT_DICTIONARY_PAGE_SIZE_LIMIT, props->dictionary_pagesize_limit());
+      DEFAULT_DICTIONARY_PAGE_SIZE_LIMIT, props->dictionaryPagesizeLimit());
   ASSERT_EQ(ParquetVersion::PARQUET_2_6, props->version());
-  ASSERT_EQ(ParquetDataPageVersion::V1, props->data_page_version());
-  ASSERT_FALSE(props->page_checksum_enabled());
+  ASSERT_EQ(ParquetDataPageVersion::V1, props->dataPageVersion());
+  ASSERT_FALSE(props->pageChecksumEnabled());
 }
 
 TEST(TestWriterProperties, AdvancedHandling) {
-  WriterProperties::Builder builder;
-  builder.compression("gzip", Compression::GZIP);
-  builder.compression("zstd", Compression::ZSTD);
-  builder.compression(Compression::SNAPPY);
-  builder.encoding(Encoding::DELTA_BINARY_PACKED);
-  builder.encoding("delta-length", Encoding::DELTA_LENGTH_BYTE_ARRAY);
-  builder.data_page_version(ParquetDataPageVersion::V2);
-  std::shared_ptr<WriterProperties> props = builder.build();
+  WriterProperties::Builder Builder;
+  Builder.compression("gzip", Compression::GZIP);
+  Builder.compression("zstd", Compression::ZSTD);
+  Builder.compression(Compression::SNAPPY);
+  Builder.encoding(Encoding::kDeltaBinaryPacked);
+  Builder.encoding("delta-length", Encoding::kDeltaLengthByteArray);
+  Builder.dataPageVersion(ParquetDataPageVersion::V2);
+  std::shared_ptr<WriterProperties> props = Builder.build();
 
   ASSERT_EQ(
-      Compression::GZIP, props->compression(ColumnPath::FromDotString("gzip")));
+      Compression::GZIP, props->compression(ColumnPath::fromDotString("gzip")));
   ASSERT_EQ(
-      Compression::ZSTD, props->compression(ColumnPath::FromDotString("zstd")));
+      Compression::ZSTD, props->compression(ColumnPath::fromDotString("zstd")));
   ASSERT_EQ(
       Compression::SNAPPY,
-      props->compression(ColumnPath::FromDotString("delta-length")));
+      props->compression(ColumnPath::fromDotString("delta-length")));
   ASSERT_EQ(
-      Encoding::DELTA_BINARY_PACKED,
-      props->encoding(ColumnPath::FromDotString("gzip")));
+      Encoding::kDeltaBinaryPacked,
+      props->encoding(ColumnPath::fromDotString("gzip")));
   ASSERT_EQ(
-      Encoding::DELTA_LENGTH_BYTE_ARRAY,
-      props->encoding(ColumnPath::FromDotString("delta-length")));
-  ASSERT_EQ(ParquetDataPageVersion::V2, props->data_page_version());
+      Encoding::kDeltaLengthByteArray,
+      props->encoding(ColumnPath::fromDotString("delta-length")));
+  ASSERT_EQ(ParquetDataPageVersion::V2, props->dataPageVersion());
 }
 
 TEST(TestReaderProperties, GetStreamInsufficientData) {
-  // ARROW-6058
+  // ARROW-6058.
   std::string data = "shorter than expected";
   auto buf = std::make_shared<Buffer>(data);
   auto reader = std::make_shared<::arrow::io::BufferReader>(buf);
 
   ReaderProperties props;
   try {
-    ARROW_UNUSED(props.GetStream(reader, 12, 15));
+    ARROW_UNUSED(props.getStream(reader, 12, 15));
     FAIL() << "No exception raised";
   } catch (const ParquetException& e) {
-    std::string ex_what =
+    std::string exWhat =
         ("Tried reading 15 bytes starting at position 12"
          " from file but only got 9");
-    ASSERT_EQ(ex_what, e.what());
+    ASSERT_EQ(exWhat, e.what());
   }
 }
 
diff --git a/velox/dwio/parquet/writer/arrow/tests/SchemaTest.cpp b/velox/dwio/parquet/writer/arrow/tests/SchemaTest.cpp
index f312ec7e7b4..fb22fc3d681 100644
--- a/velox/dwio/parquet/writer/arrow/tests/SchemaTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/SchemaTest.cpp
@@ -42,507 +42,513 @@ using facebook::velox::parquet::thrift::SchemaElement;
 
 namespace schema {
 
-static inline SchemaElement NewPrimitive(
+static inline SchemaElement newPrimitive(
     const std::string& name,
     FieldRepetitionType::type repetition,
     Type::type type,
-    int field_id = -1) {
+    int fieldId = -1) {
   SchemaElement result;
   result.__set_name(name);
   result.__set_repetition_type(repetition);
   result.__set_type(
       static_cast<facebook::velox::parquet::thrift::Type::type>(type));
-  if (field_id >= 0) {
-    result.__set_field_id(field_id);
+  if (fieldId >= 0) {
+    result.__set_field_id(fieldId);
   }
   return result;
 }
 
-static inline SchemaElement NewGroup(
+static inline SchemaElement newGroup(
     const std::string& name,
     FieldRepetitionType::type repetition,
-    int num_children,
-    int field_id = -1) {
+    int numChildren,
+    int fieldId = -1) {
   SchemaElement result;
   result.__set_name(name);
   result.__set_repetition_type(repetition);
-  result.__set_num_children(num_children);
+  result.__set_num_children(numChildren);
 
-  if (field_id >= 0) {
-    result.__set_field_id(field_id);
+  if (fieldId >= 0) {
+    result.__set_field_id(fieldId);
   }
 
   return result;
 }
 
 template <typename NodeType>
-static void CheckNodeRoundtrip(const Node& node) {
+static void checkNodeRoundtrip(const Node& node) {
   facebook::velox::parquet::thrift::SchemaElement serialized;
-  node.ToParquet(&serialized);
-  std::unique_ptr<Node> recovered = NodeType::FromParquet(&serialized);
-  ASSERT_TRUE(node.Equals(recovered.get()))
+  node.toParquet(&serialized);
+  std::unique_ptr<Node> recovered = NodeType::fromParquet(&serialized);
+  ASSERT_TRUE(node.equals(recovered.get()))
       << "Recovered node not equivalent to original node constructed "
-      << "with logical type " << node.logical_type()->ToString() << " got "
-      << recovered->logical_type()->ToString();
+      << "with logical type " << node.logicalType()->toString() << " got "
+      << recovered->logicalType()->toString();
 }
 
-static void ConfirmPrimitiveNodeRoundtrip(
-    const std::shared_ptr<const LogicalType>& logical_type,
-    Type::type physical_type,
-    int physical_length,
-    int field_id = -1) {
-  auto node = PrimitiveNode::Make(
+static void confirmPrimitiveNodeRoundtrip(
+    const std::shared_ptr<const LogicalType>& logicalType,
+    Type::type physicalType,
+    int physicalLength,
+    int fieldId = -1) {
+  auto Node = PrimitiveNode::make(
       "something",
-      Repetition::REQUIRED,
-      logical_type,
-      physical_type,
-      physical_length,
-      field_id);
-  CheckNodeRoundtrip<PrimitiveNode>(*node);
+      Repetition::kRequired,
+      logicalType,
+      physicalType,
+      physicalLength,
+      fieldId);
+  checkNodeRoundtrip<PrimitiveNode>(*Node);
 }
 
-static void ConfirmGroupNodeRoundtrip(
+static void confirmGroupNodeRoundtrip(
     std::string name,
-    const std::shared_ptr<const LogicalType>& logical_type,
-    int field_id = -1) {
-  auto node =
-      GroupNode::Make(name, Repetition::REQUIRED, {}, logical_type, field_id);
-  CheckNodeRoundtrip<GroupNode>(*node);
+    const std::shared_ptr<const LogicalType>& logicalType,
+    int fieldId = -1) {
+  auto Node =
+      GroupNode::make(name, Repetition::kRequired, {}, logicalType, fieldId);
+  checkNodeRoundtrip<GroupNode>(*Node);
 }
 
-// ----------------------------------------------------------------------
-// ColumnPath
+// ----------------------------------------------------------------------.
+// ColumnPath.
 
 TEST(TestColumnPath, TestAttrs) {
   ColumnPath path(std::vector<std::string>({"toplevel", "leaf"}));
 
-  ASSERT_EQ(path.ToDotString(), "toplevel.leaf");
+  ASSERT_EQ(path.toDotString(), "toplevel.leaf");
 
-  std::shared_ptr<ColumnPath> path_ptr =
-      ColumnPath::FromDotString("toplevel.leaf");
-  ASSERT_EQ(path_ptr->ToDotString(), "toplevel.leaf");
+  std::shared_ptr<ColumnPath> pathPtr =
+      ColumnPath::fromDotString("toplevel.leaf");
+  ASSERT_EQ(pathPtr->toDotString(), "toplevel.leaf");
 
-  std::shared_ptr<ColumnPath> extended = path_ptr->extend("anotherlevel");
-  ASSERT_EQ(extended->ToDotString(), "toplevel.leaf.anotherlevel");
+  std::shared_ptr<ColumnPath> extended = pathPtr->extend("anotherlevel");
+  ASSERT_EQ(extended->toDotString(), "toplevel.leaf.anotherlevel");
 }
 
-// ----------------------------------------------------------------------
-// Primitive node
+// ----------------------------------------------------------------------.
+// Primitive node.
 
 class TestPrimitiveNode : public ::testing::Test {
  public:
   void SetUp() {
     name_ = "name";
-    field_id_ = 5;
+    fieldId_ = 5;
   }
 
-  void Convert(const facebook::velox::parquet::thrift::SchemaElement* element) {
-    node_ = PrimitiveNode::FromParquet(element);
-    ASSERT_TRUE(node_->is_primitive());
-    prim_node_ = static_cast<const PrimitiveNode*>(node_.get());
+  void convert(const facebook::velox::parquet::thrift::SchemaElement* element) {
+    node_ = PrimitiveNode::fromParquet(element);
+    ASSERT_TRUE(node_->isPrimitive());
+    primNode_ = static_cast<const PrimitiveNode*>(node_.get());
   }
 
  protected:
   std::string name_;
-  const PrimitiveNode* prim_node_;
+  const PrimitiveNode* primNode_;
 
-  int field_id_;
+  int fieldId_;
   std::unique_ptr<Node> node_;
 };
 
 TEST_F(TestPrimitiveNode, Attrs) {
-  PrimitiveNode node1("foo", Repetition::REPEATED, Type::INT32);
+  PrimitiveNode node1("foo", Repetition::kRepeated, Type::kInt32);
 
   PrimitiveNode node2(
-      "bar", Repetition::OPTIONAL, Type::BYTE_ARRAY, ConvertedType::UTF8);
+      "bar", Repetition::kOptional, Type::kByteArray, ConvertedType::kUtf8);
 
   ASSERT_EQ("foo", node1.name());
 
-  ASSERT_TRUE(node1.is_primitive());
-  ASSERT_FALSE(node1.is_group());
+  ASSERT_TRUE(node1.isPrimitive());
+  ASSERT_FALSE(node1.isGroup());
 
-  ASSERT_EQ(Repetition::REPEATED, node1.repetition());
-  ASSERT_EQ(Repetition::OPTIONAL, node2.repetition());
+  ASSERT_EQ(Repetition::kRepeated, node1.repetition());
+  ASSERT_EQ(Repetition::kOptional, node2.repetition());
 
-  ASSERT_EQ(Node::PRIMITIVE, node1.node_type());
+  ASSERT_EQ(Node::kPrimitive, node1.nodeType());
 
-  ASSERT_EQ(Type::INT32, node1.physical_type());
-  ASSERT_EQ(Type::BYTE_ARRAY, node2.physical_type());
+  ASSERT_EQ(Type::kInt32, node1.physicalType());
+  ASSERT_EQ(Type::kByteArray, node2.physicalType());
 
-  // logical types
-  ASSERT_EQ(ConvertedType::NONE, node1.converted_type());
-  ASSERT_EQ(ConvertedType::UTF8, node2.converted_type());
+  // Logical types.
+  ASSERT_EQ(ConvertedType::kNone, node1.convertedType());
+  ASSERT_EQ(ConvertedType::kUtf8, node2.convertedType());
 
-  // repetition
-  PrimitiveNode node3("foo", Repetition::REPEATED, Type::INT32);
-  PrimitiveNode node4("foo", Repetition::REQUIRED, Type::INT32);
-  PrimitiveNode node5("foo", Repetition::OPTIONAL, Type::INT32);
+  // Repetition.
+  PrimitiveNode node3("foo", Repetition::kRepeated, Type::kInt32);
+  PrimitiveNode node4("foo", Repetition::kRequired, Type::kInt32);
+  PrimitiveNode node5("foo", Repetition::kOptional, Type::kInt32);
 
-  ASSERT_TRUE(node3.is_repeated());
-  ASSERT_FALSE(node3.is_optional());
+  ASSERT_TRUE(node3.isRepeated());
+  ASSERT_FALSE(node3.isOptional());
 
-  ASSERT_TRUE(node4.is_required());
+  ASSERT_TRUE(node4.isRequired());
 
-  ASSERT_TRUE(node5.is_optional());
-  ASSERT_FALSE(node5.is_required());
+  ASSERT_TRUE(node5.isOptional());
+  ASSERT_FALSE(node5.isRequired());
 }
 
-TEST_F(TestPrimitiveNode, FromParquet) {
-  SchemaElement elt = NewPrimitive(
-      name_, FieldRepetitionType::OPTIONAL, Type::INT32, field_id_);
-  ASSERT_NO_FATAL_FAILURE(Convert(&elt));
-  ASSERT_EQ(name_, prim_node_->name());
-  ASSERT_EQ(field_id_, prim_node_->field_id());
-  ASSERT_EQ(Repetition::OPTIONAL, prim_node_->repetition());
-  ASSERT_EQ(Type::INT32, prim_node_->physical_type());
-  ASSERT_EQ(ConvertedType::NONE, prim_node_->converted_type());
-
-  // Test a logical type
-  elt = NewPrimitive(
-      name_, FieldRepetitionType::REQUIRED, Type::BYTE_ARRAY, field_id_);
+TEST_F(TestPrimitiveNode, fromParquet) {
+  SchemaElement elt = newPrimitive(
+      name_, FieldRepetitionType::OPTIONAL, Type::kInt32, fieldId_);
+  ASSERT_NO_FATAL_FAILURE(convert(&elt));
+  ASSERT_EQ(name_, primNode_->name());
+  ASSERT_EQ(fieldId_, primNode_->fieldId());
+  ASSERT_EQ(Repetition::kOptional, primNode_->repetition());
+  ASSERT_EQ(Type::kInt32, primNode_->physicalType());
+  ASSERT_EQ(ConvertedType::kNone, primNode_->convertedType());
+
+  // Test a logical type.
+  elt = newPrimitive(
+      name_, FieldRepetitionType::REQUIRED, Type::kByteArray, fieldId_);
   elt.__set_converted_type(
       facebook::velox::parquet::thrift::ConvertedType::UTF8);
 
-  ASSERT_NO_FATAL_FAILURE(Convert(&elt));
-  ASSERT_EQ(Repetition::REQUIRED, prim_node_->repetition());
-  ASSERT_EQ(Type::BYTE_ARRAY, prim_node_->physical_type());
-  ASSERT_EQ(ConvertedType::UTF8, prim_node_->converted_type());
-
-  // FIXED_LEN_BYTE_ARRAY
-  elt = NewPrimitive(
-      name_,
-      FieldRepetitionType::OPTIONAL,
-      Type::FIXED_LEN_BYTE_ARRAY,
-      field_id_);
+  ASSERT_NO_FATAL_FAILURE(convert(&elt));
+  ASSERT_EQ(Repetition::kRequired, primNode_->repetition());
+  ASSERT_EQ(Type::kByteArray, primNode_->physicalType());
+  ASSERT_EQ(ConvertedType::kUtf8, primNode_->convertedType());
+
+  // FIXED_LEN_BYTE_ARRAY.
+  elt = newPrimitive(
+      name_, FieldRepetitionType::OPTIONAL, Type::kFixedLenByteArray, fieldId_);
   elt.__set_type_length(16);
 
-  ASSERT_NO_FATAL_FAILURE(Convert(&elt));
-  ASSERT_EQ(name_, prim_node_->name());
-  ASSERT_EQ(field_id_, prim_node_->field_id());
-  ASSERT_EQ(Repetition::OPTIONAL, prim_node_->repetition());
-  ASSERT_EQ(Type::FIXED_LEN_BYTE_ARRAY, prim_node_->physical_type());
-  ASSERT_EQ(16, prim_node_->type_length());
-
-  // facebook::velox::parquet::thrift::ConvertedType::Decimal
-  elt = NewPrimitive(
-      name_,
-      FieldRepetitionType::OPTIONAL,
-      Type::FIXED_LEN_BYTE_ARRAY,
-      field_id_);
+  ASSERT_NO_FATAL_FAILURE(convert(&elt));
+  ASSERT_EQ(name_, primNode_->name());
+  ASSERT_EQ(fieldId_, primNode_->fieldId());
+  ASSERT_EQ(Repetition::kOptional, primNode_->repetition());
+  ASSERT_EQ(Type::kFixedLenByteArray, primNode_->physicalType());
+  ASSERT_EQ(16, primNode_->typeLength());
+
+  // Facebook::velox::parquet::thrift::ConvertedType::Decimal.
+  elt = newPrimitive(
+      name_, FieldRepetitionType::OPTIONAL, Type::kFixedLenByteArray, fieldId_);
   elt.__set_converted_type(
       facebook::velox::parquet::thrift::ConvertedType::DECIMAL);
   elt.__set_type_length(6);
   elt.__set_scale(2);
   elt.__set_precision(12);
 
-  ASSERT_NO_FATAL_FAILURE(Convert(&elt));
-  ASSERT_EQ(Type::FIXED_LEN_BYTE_ARRAY, prim_node_->physical_type());
-  ASSERT_EQ(ConvertedType::DECIMAL, prim_node_->converted_type());
-  ASSERT_EQ(6, prim_node_->type_length());
-  ASSERT_EQ(2, prim_node_->decimal_metadata().scale);
-  ASSERT_EQ(12, prim_node_->decimal_metadata().precision);
+  ASSERT_NO_FATAL_FAILURE(convert(&elt));
+  ASSERT_EQ(Type::kFixedLenByteArray, primNode_->physicalType());
+  ASSERT_EQ(ConvertedType::kDecimal, primNode_->convertedType());
+  ASSERT_EQ(6, primNode_->typeLength());
+  ASSERT_EQ(2, primNode_->decimalMetadata().scale);
+  ASSERT_EQ(12, primNode_->decimalMetadata().precision);
 }
 
-TEST_F(TestPrimitiveNode, Equals) {
-  PrimitiveNode node1("foo", Repetition::REQUIRED, Type::INT32);
-  PrimitiveNode node2("foo", Repetition::REQUIRED, Type::INT64);
-  PrimitiveNode node3("bar", Repetition::REQUIRED, Type::INT32);
-  PrimitiveNode node4("foo", Repetition::OPTIONAL, Type::INT32);
-  PrimitiveNode node5("foo", Repetition::REQUIRED, Type::INT32);
+TEST_F(TestPrimitiveNode, equals) {
+  PrimitiveNode node1("foo", Repetition::kRequired, Type::kInt32);
+  PrimitiveNode node2("foo", Repetition::kRequired, Type::kInt64);
+  PrimitiveNode node3("bar", Repetition::kRequired, Type::kInt32);
+  PrimitiveNode node4("foo", Repetition::kOptional, Type::kInt32);
+  PrimitiveNode node5("foo", Repetition::kRequired, Type::kInt32);
 
-  ASSERT_TRUE(node1.Equals(&node1));
-  ASSERT_FALSE(node1.Equals(&node2));
-  ASSERT_FALSE(node1.Equals(&node3));
-  ASSERT_FALSE(node1.Equals(&node4));
-  ASSERT_TRUE(node1.Equals(&node5));
+  ASSERT_TRUE(node1.equals(&node1));
+  ASSERT_FALSE(node1.equals(&node2));
+  ASSERT_FALSE(node1.equals(&node3));
+  ASSERT_FALSE(node1.equals(&node4));
+  ASSERT_TRUE(node1.equals(&node5));
 
   PrimitiveNode flba1(
       "foo",
-      Repetition::REQUIRED,
-      Type::FIXED_LEN_BYTE_ARRAY,
-      ConvertedType::DECIMAL,
+      Repetition::kRequired,
+      Type::kFixedLenByteArray,
+      ConvertedType::kDecimal,
       12,
       4,
       2);
 
   PrimitiveNode flba2(
       "foo",
-      Repetition::REQUIRED,
-      Type::FIXED_LEN_BYTE_ARRAY,
-      ConvertedType::DECIMAL,
+      Repetition::kRequired,
+      Type::kFixedLenByteArray,
+      ConvertedType::kDecimal,
       1,
       4,
       2);
-  flba2.SetTypeLength(12);
+  flba2.setTypeLength(12);
 
   PrimitiveNode flba3(
       "foo",
-      Repetition::REQUIRED,
-      Type::FIXED_LEN_BYTE_ARRAY,
-      ConvertedType::DECIMAL,
+      Repetition::kRequired,
+      Type::kFixedLenByteArray,
+      ConvertedType::kDecimal,
       1,
       4,
       2);
-  flba3.SetTypeLength(16);
+  flba3.setTypeLength(16);
 
   PrimitiveNode flba4(
       "foo",
-      Repetition::REQUIRED,
-      Type::FIXED_LEN_BYTE_ARRAY,
-      ConvertedType::DECIMAL,
+      Repetition::kRequired,
+      Type::kFixedLenByteArray,
+      ConvertedType::kDecimal,
       12,
       4,
       0);
 
   PrimitiveNode flba5(
       "foo",
-      Repetition::REQUIRED,
-      Type::FIXED_LEN_BYTE_ARRAY,
-      ConvertedType::NONE,
+      Repetition::kRequired,
+      Type::kFixedLenByteArray,
+      ConvertedType::kNone,
       12,
       4,
       0);
 
-  ASSERT_TRUE(flba1.Equals(&flba2));
-  ASSERT_FALSE(flba1.Equals(&flba3));
-  ASSERT_FALSE(flba1.Equals(&flba4));
-  ASSERT_FALSE(flba1.Equals(&flba5));
+  ASSERT_TRUE(flba1.equals(&flba2));
+  ASSERT_FALSE(flba1.equals(&flba3));
+  ASSERT_FALSE(flba1.equals(&flba4));
+  ASSERT_FALSE(flba1.equals(&flba5));
 }
 
 TEST_F(TestPrimitiveNode, PhysicalLogicalMapping) {
-  ASSERT_NO_THROW(PrimitiveNode::Make(
-      "foo", Repetition::REQUIRED, Type::INT32, ConvertedType::INT_32));
-  ASSERT_NO_THROW(PrimitiveNode::Make(
-      "foo", Repetition::REQUIRED, Type::BYTE_ARRAY, ConvertedType::JSON));
+  ASSERT_NO_THROW(
+      PrimitiveNode::make(
+          "foo", Repetition::kRequired, Type::kInt32, ConvertedType::kInt32));
+  ASSERT_NO_THROW(
+      PrimitiveNode::make(
+          "foo",
+          Repetition::kRequired,
+          Type::kByteArray,
+          ConvertedType::kJson));
   ASSERT_THROW(
-      PrimitiveNode::Make(
-          "foo", Repetition::REQUIRED, Type::INT32, ConvertedType::JSON),
+      PrimitiveNode::make(
+          "foo", Repetition::kRequired, Type::kInt32, ConvertedType::kJson),
       ParquetException);
-  ASSERT_NO_THROW(PrimitiveNode::Make(
-      "foo",
-      Repetition::REQUIRED,
-      Type::INT64,
-      ConvertedType::TIMESTAMP_MILLIS));
+  ASSERT_NO_THROW(
+      PrimitiveNode::make(
+          "foo",
+          Repetition::kRequired,
+          Type::kInt64,
+          ConvertedType::kTimestampMillis));
   ASSERT_THROW(
-      PrimitiveNode::Make(
-          "foo", Repetition::REQUIRED, Type::INT32, ConvertedType::INT_64),
+      PrimitiveNode::make(
+          "foo", Repetition::kRequired, Type::kInt32, ConvertedType::kInt64),
       ParquetException);
   ASSERT_THROW(
-      PrimitiveNode::Make(
-          "foo", Repetition::REQUIRED, Type::BYTE_ARRAY, ConvertedType::INT_8),
+      PrimitiveNode::make(
+          "foo", Repetition::kRequired, Type::kByteArray, ConvertedType::kInt8),
       ParquetException);
   ASSERT_THROW(
-      PrimitiveNode::Make(
+      PrimitiveNode::make(
           "foo",
-          Repetition::REQUIRED,
-          Type::BYTE_ARRAY,
-          ConvertedType::INTERVAL),
+          Repetition::kRequired,
+          Type::kByteArray,
+          ConvertedType::kInterval),
       ParquetException);
   ASSERT_THROW(
-      PrimitiveNode::Make(
+      PrimitiveNode::make(
           "foo",
-          Repetition::REQUIRED,
-          Type::FIXED_LEN_BYTE_ARRAY,
-          ConvertedType::ENUM),
+          Repetition::kRequired,
+          Type::kFixedLenByteArray,
+          ConvertedType::kEnum),
       ParquetException);
-  ASSERT_NO_THROW(PrimitiveNode::Make(
-      "foo", Repetition::REQUIRED, Type::BYTE_ARRAY, ConvertedType::ENUM));
+  ASSERT_NO_THROW(
+      PrimitiveNode::make(
+          "foo",
+          Repetition::kRequired,
+          Type::kByteArray,
+          ConvertedType::kEnum));
   ASSERT_THROW(
-      PrimitiveNode::Make(
+      PrimitiveNode::make(
           "foo",
-          Repetition::REQUIRED,
-          Type::FIXED_LEN_BYTE_ARRAY,
-          ConvertedType::DECIMAL,
+          Repetition::kRequired,
+          Type::kFixedLenByteArray,
+          ConvertedType::kDecimal,
           0,
           2,
           4),
       ParquetException);
   ASSERT_THROW(
-      PrimitiveNode::Make(
+      PrimitiveNode::make(
           "foo",
-          Repetition::REQUIRED,
-          Type::FLOAT,
-          ConvertedType::DECIMAL,
+          Repetition::kRequired,
+          Type::kFloat,
+          ConvertedType::kDecimal,
           0,
           2,
           4),
       ParquetException);
   ASSERT_THROW(
-      PrimitiveNode::Make(
+      PrimitiveNode::make(
           "foo",
-          Repetition::REQUIRED,
-          Type::FIXED_LEN_BYTE_ARRAY,
-          ConvertedType::DECIMAL,
+          Repetition::kRequired,
+          Type::kFixedLenByteArray,
+          ConvertedType::kDecimal,
           0,
           4,
           0),
       ParquetException);
   ASSERT_THROW(
-      PrimitiveNode::Make(
+      PrimitiveNode::make(
           "foo",
-          Repetition::REQUIRED,
-          Type::FIXED_LEN_BYTE_ARRAY,
-          ConvertedType::DECIMAL,
+          Repetition::kRequired,
+          Type::kFixedLenByteArray,
+          ConvertedType::kDecimal,
           10,
           0,
           4),
       ParquetException);
   ASSERT_THROW(
-      PrimitiveNode::Make(
+      PrimitiveNode::make(
           "foo",
-          Repetition::REQUIRED,
-          Type::FIXED_LEN_BYTE_ARRAY,
-          ConvertedType::DECIMAL,
+          Repetition::kRequired,
+          Type::kFixedLenByteArray,
+          ConvertedType::kDecimal,
           10,
           4,
           -1),
       ParquetException);
   ASSERT_THROW(
-      PrimitiveNode::Make(
+      PrimitiveNode::make(
           "foo",
-          Repetition::REQUIRED,
-          Type::FIXED_LEN_BYTE_ARRAY,
-          ConvertedType::DECIMAL,
+          Repetition::kRequired,
+          Type::kFixedLenByteArray,
+          ConvertedType::kDecimal,
           10,
           2,
           4),
       ParquetException);
-  ASSERT_NO_THROW(PrimitiveNode::Make(
-      "foo",
-      Repetition::REQUIRED,
-      Type::FIXED_LEN_BYTE_ARRAY,
-      ConvertedType::DECIMAL,
-      10,
-      6,
-      4));
-  ASSERT_NO_THROW(PrimitiveNode::Make(
-      "foo",
-      Repetition::REQUIRED,
-      Type::FIXED_LEN_BYTE_ARRAY,
-      ConvertedType::INTERVAL,
-      12));
+  ASSERT_NO_THROW(
+      PrimitiveNode::make(
+          "foo",
+          Repetition::kRequired,
+          Type::kFixedLenByteArray,
+          ConvertedType::kDecimal,
+          10,
+          6,
+          4));
+  ASSERT_NO_THROW(
+      PrimitiveNode::make(
+          "foo",
+          Repetition::kRequired,
+          Type::kFixedLenByteArray,
+          ConvertedType::kInterval,
+          12));
   ASSERT_THROW(
-      PrimitiveNode::Make(
+      PrimitiveNode::make(
           "foo",
-          Repetition::REQUIRED,
-          Type::FIXED_LEN_BYTE_ARRAY,
-          ConvertedType::INTERVAL,
+          Repetition::kRequired,
+          Type::kFixedLenByteArray,
+          ConvertedType::kInterval,
           10),
       ParquetException);
 }
 
-// ----------------------------------------------------------------------
-// Group node
+// ----------------------------------------------------------------------.
+// Group node.
 
 class TestGroupNode : public ::testing::Test {
  public:
-  NodeVector Fields1() {
+  NodeVector fields1() {
     NodeVector fields;
 
-    fields.push_back(Int32("one", Repetition::REQUIRED));
-    fields.push_back(Int64("two"));
-    fields.push_back(Double("three"));
+    fields.push_back(int32("one", Repetition::kRequired));
+    fields.push_back(int64("two"));
+    fields.push_back(doubleType("three"));
 
     return fields;
   }
 
-  NodeVector Fields2() {
-    // Fields with a duplicate name
+  NodeVector fields2() {
+    // Fields with a duplicate name.
     NodeVector fields;
 
-    fields.push_back(Int32("duplicate", Repetition::REQUIRED));
-    fields.push_back(Int64("unique"));
-    fields.push_back(Double("duplicate"));
+    fields.push_back(int32("duplicate", Repetition::kRequired));
+    fields.push_back(int64("unique"));
+    fields.push_back(doubleType("duplicate"));
 
     return fields;
   }
 };
 
 TEST_F(TestGroupNode, Attrs) {
-  NodeVector fields = Fields1();
+  NodeVector fields = fields1();
 
-  GroupNode node1("foo", Repetition::REPEATED, fields);
-  GroupNode node2("bar", Repetition::OPTIONAL, fields, ConvertedType::LIST);
+  GroupNode node1("foo", Repetition::kRepeated, fields);
+  GroupNode node2("bar", Repetition::kOptional, fields, ConvertedType::kList);
 
   ASSERT_EQ("foo", node1.name());
 
-  ASSERT_TRUE(node1.is_group());
-  ASSERT_FALSE(node1.is_primitive());
+  ASSERT_TRUE(node1.isGroup());
+  ASSERT_FALSE(node1.isPrimitive());
 
-  ASSERT_EQ(fields.size(), node1.field_count());
+  ASSERT_EQ(fields.size(), node1.fieldCount());
 
-  ASSERT_TRUE(node1.is_repeated());
-  ASSERT_TRUE(node2.is_optional());
+  ASSERT_TRUE(node1.isRepeated());
+  ASSERT_TRUE(node2.isOptional());
 
-  ASSERT_EQ(Repetition::REPEATED, node1.repetition());
-  ASSERT_EQ(Repetition::OPTIONAL, node2.repetition());
+  ASSERT_EQ(Repetition::kRepeated, node1.repetition());
+  ASSERT_EQ(Repetition::kOptional, node2.repetition());
 
-  ASSERT_EQ(Node::GROUP, node1.node_type());
+  ASSERT_EQ(Node::kGroup, node1.nodeType());
 
-  // logical types
-  ASSERT_EQ(ConvertedType::NONE, node1.converted_type());
-  ASSERT_EQ(ConvertedType::LIST, node2.converted_type());
+  // Logical types.
+  ASSERT_EQ(ConvertedType::kNone, node1.convertedType());
+  ASSERT_EQ(ConvertedType::kList, node2.convertedType());
 }
 
-TEST_F(TestGroupNode, Equals) {
-  NodeVector f1 = Fields1();
-  NodeVector f2 = Fields1();
+TEST_F(TestGroupNode, equals) {
+  NodeVector f1 = fields1();
+  NodeVector f2 = fields1();
 
-  GroupNode group1("group", Repetition::REPEATED, f1);
-  GroupNode group2("group", Repetition::REPEATED, f2);
-  GroupNode group3("group2", Repetition::REPEATED, f2);
+  GroupNode group1("group", Repetition::kRepeated, f1);
+  GroupNode group2("group", Repetition::kRepeated, f2);
+  GroupNode group3("group2", Repetition::kRepeated, f2);
 
-  // This is copied in the GroupNode ctor, so this is okay
-  f2.push_back(Float("four", Repetition::OPTIONAL));
-  GroupNode group4("group", Repetition::REPEATED, f2);
-  GroupNode group5("group", Repetition::REPEATED, Fields1());
+  // This is copied in the GroupNode ctor, so this is okay.
+  f2.push_back(floatType("four", Repetition::kOptional));
+  GroupNode group4("group", Repetition::kRepeated, f2);
+  GroupNode group5("group", Repetition::kRepeated, fields1());
 
-  ASSERT_TRUE(group1.Equals(&group1));
-  ASSERT_TRUE(group1.Equals(&group2));
-  ASSERT_FALSE(group1.Equals(&group3));
+  ASSERT_TRUE(group1.equals(&group1));
+  ASSERT_TRUE(group1.equals(&group2));
+  ASSERT_FALSE(group1.equals(&group3));
 
-  ASSERT_FALSE(group1.Equals(&group4));
-  ASSERT_FALSE(group5.Equals(&group4));
+  ASSERT_FALSE(group1.equals(&group4));
+  ASSERT_FALSE(group5.equals(&group4));
 }
 
-TEST_F(TestGroupNode, FieldIndex) {
-  NodeVector fields = Fields1();
-  GroupNode group("group", Repetition::REQUIRED, fields);
+TEST_F(TestGroupNode, fieldIndex) {
+  NodeVector fields = fields1();
+  GroupNode group("group", Repetition::kRequired, fields);
   for (size_t i = 0; i < fields.size(); i++) {
     auto field = group.field(static_cast<int>(i));
-    ASSERT_EQ(i, group.FieldIndex(*field));
+    ASSERT_EQ(i, group.fieldIndex(*field));
   }
 
-  // Test a non field node
-  auto non_field_alien = Int32("alien", Repetition::REQUIRED); // other name
-  auto non_field_familiar = Int32("one", Repetition::REPEATED); // other node
-  ASSERT_LT(group.FieldIndex(*non_field_alien), 0);
-  ASSERT_LT(group.FieldIndex(*non_field_familiar), 0);
+  // Test a non field node.
+  auto nonFieldAlien = int32("alien", Repetition::kRequired); // other name
+  auto nonFieldFamiliar = int32("one", Repetition::kRepeated); // other node
+  ASSERT_LT(group.fieldIndex(*nonFieldAlien), 0);
+  ASSERT_LT(group.fieldIndex(*nonFieldFamiliar), 0);
 }
 
 TEST_F(TestGroupNode, FieldIndexDuplicateName) {
-  NodeVector fields = Fields2();
-  GroupNode group("group", Repetition::REQUIRED, fields);
+  NodeVector fields = fields2();
+  GroupNode group("group", Repetition::kRequired, fields);
   for (size_t i = 0; i < fields.size(); i++) {
     auto field = group.field(static_cast<int>(i));
-    ASSERT_EQ(i, group.FieldIndex(*field));
+    ASSERT_EQ(i, group.fieldIndex(*field));
   }
 }
 
-// ----------------------------------------------------------------------
-// Test convert group
+// ----------------------------------------------------------------------.
+// Test convert group.
 
 class TestSchemaConverter : public ::testing::Test {
  public:
-  void setUp() {
+  void SetUp() {
     name_ = "parquet_schema";
   }
 
-  void Convert(
+  void convert(
       const facebook::velox::parquet::thrift::SchemaElement* elements,
       int length) {
-    node_ = Unflatten(elements, length);
-    ASSERT_TRUE(node_->is_group());
+    node_ = unflatten(elements, length);
+    ASSERT_TRUE(node_->isGroup());
     group_ = static_cast<const GroupNode*>(node_.get());
   }
 
@@ -552,16 +558,16 @@ class TestSchemaConverter : public ::testing::Test {
   std::unique_ptr<Node> node_;
 };
 
-bool check_for_parent_consistency(const GroupNode* node) {
-  // Each node should have the group as parent
-  for (int i = 0; i < node->field_count(); i++) {
-    const NodePtr& field = node->field(i);
-    if (field->parent() != node) {
+bool checkForParentConsistency(const GroupNode* Node) {
+  // Each node should have the group as parent.
+  for (int i = 0; i < Node->fieldCount(); i++) {
+    const NodePtr& field = Node->field(i);
+    if (field->parent() != Node) {
       return false;
     }
-    if (field->is_group()) {
+    if (field->isGroup()) {
       const GroupNode* group = static_cast<GroupNode*>(field.get());
-      if (!check_for_parent_consistency(group)) {
+      if (!checkForParentConsistency(group)) {
         return false;
       }
     }
@@ -572,106 +578,99 @@ bool check_for_parent_consistency(const GroupNode* node) {
 TEST_F(TestSchemaConverter, NestedExample) {
   SchemaElement elt;
   std::vector<SchemaElement> elements;
-  elements.push_back(NewGroup(
-      name_,
-      FieldRepetitionType::REPEATED,
-      /*num_children=*/2,
-      /*field_id=*/0));
+  elements.push_back(newGroup(name_, FieldRepetitionType::REPEATED, 2, 0));
 
-  // A primitive one
+  // A primitive one.
   elements.push_back(
-      NewPrimitive("a", FieldRepetitionType::REQUIRED, Type::INT32, 1));
+      newPrimitive("a", FieldRepetitionType::REQUIRED, Type::kInt32, 1));
 
-  // A group
-  elements.push_back(NewGroup("bag", FieldRepetitionType::OPTIONAL, 1, 2));
+  // A group.
+  elements.push_back(newGroup("bag", FieldRepetitionType::OPTIONAL, 1, 2));
 
-  // 3-level list encoding, by hand
-  elt = NewGroup("b", FieldRepetitionType::REPEATED, 1, 3);
+  // 3-Level list encoding, by hand.
+  elt = newGroup("b", FieldRepetitionType::REPEATED, 1, 3);
   elt.__set_converted_type(
       facebook::velox::parquet::thrift::ConvertedType::LIST);
   elements.push_back(elt);
   elements.push_back(
-      NewPrimitive("item", FieldRepetitionType::OPTIONAL, Type::INT64, 4));
+      newPrimitive("item", FieldRepetitionType::OPTIONAL, Type::kInt64, 4));
 
   ASSERT_NO_FATAL_FAILURE(
-      Convert(&elements[0], static_cast<int>(elements.size())));
+      convert(&elements[0], static_cast<int>(elements.size())));
 
-  // Construct the expected schema
+  // Construct the expected schema.
   NodeVector fields;
-  fields.push_back(Int32("a", Repetition::REQUIRED, 1));
-
-  // 3-level list encoding
-  NodePtr item = Int64("item", Repetition::OPTIONAL, 4);
-  NodePtr list(GroupNode::Make(
-      "b", Repetition::REPEATED, {item}, ConvertedType::LIST, 3));
-  NodePtr bag(GroupNode::Make(
-      "bag", Repetition::OPTIONAL, {list}, /*logical_type=*/nullptr, 2));
+  fields.push_back(int32("a", Repetition::kRequired, 1));
+
+  // 3-Level list encoding.
+  NodePtr item = int64("item", Repetition::kOptional, 4);
+  NodePtr List(
+      GroupNode::make(
+          "b", Repetition::kRepeated, {item}, ConvertedType::kList, 3));
+  NodePtr bag(
+      GroupNode::make("bag", Repetition::kOptional, {List}, nullptr, 2));
   fields.push_back(bag);
 
-  NodePtr schema = GroupNode::Make(
-      name_,
-      Repetition::REPEATED,
-      fields,
-      /*logical_type=*/nullptr,
-      0);
+  NodePtr schema =
+      GroupNode::make(name_, Repetition::kRepeated, fields, nullptr, 0);
 
-  ASSERT_TRUE(schema->Equals(group_));
+  ASSERT_TRUE(schema->equals(group_));
 
-  // Check that the parent relationship in each node is consistent
+  // Check that the parent relationship in each node is consistent.
   ASSERT_EQ(group_->parent(), nullptr);
-  ASSERT_TRUE(check_for_parent_consistency(group_));
+  ASSERT_TRUE(checkForParentConsistency(group_));
 }
 
 TEST_F(TestSchemaConverter, ZeroColumns) {
-  // ARROW-3843
+  // ARROW-3843.
   SchemaElement elements[1];
-  elements[0] = NewGroup("schema", FieldRepetitionType::REPEATED, 0, 0);
-  ASSERT_NO_THROW(Convert(elements, 1));
+  elements[0] = newGroup("schema", FieldRepetitionType::REPEATED, 0, 0);
+  ASSERT_NO_THROW(convert(elements, 1));
 }
 
 TEST_F(TestSchemaConverter, InvalidRoot) {
-  // According to the Parquet specification, the first element in the
+  // According to the Parquet specification, the first element in the.
   // list<SchemaElement> is a group whose children (and their descendants)
-  // contain all of the rest of the flattened schema elements. If the first
-  // element is not a group, it is a malformed Parquet file.
+  // Contain all of the rest of the flattened schema elements. If the first.
+  // Element is not a group, it is a malformed Parquet file.
 
   SchemaElement elements[2];
-  elements[0] = NewPrimitive(
-      "not-a-group", FieldRepetitionType::REQUIRED, Type::INT32, 0);
-  ASSERT_THROW(Convert(elements, 2), ParquetException);
-
-  // While the Parquet spec indicates that the root group should have REPEATED
-  // repetition type, some implementations may return REQUIRED or OPTIONAL
-  // groups as the first element. These tests check that this is okay as a
-  // practicality matter.
-  elements[0] = NewGroup("not-repeated", FieldRepetitionType::REQUIRED, 1, 0);
+  elements[0] = newPrimitive(
+      "not-a-group", FieldRepetitionType::REQUIRED, Type::kInt32, 0);
+  ASSERT_THROW(convert(elements, 2), ParquetException);
+
+  // While the Parquet spec indicates that the root group should have REPEATED.
+  // Repetition type, some implementations may return REQUIRED or OPTIONAL.
+  // Groups as the first element. These tests check that this is okay as a.
+  // Practicality matter.
+  elements[0] = newGroup("not-repeated", FieldRepetitionType::REQUIRED, 1, 0);
   elements[1] =
-      NewPrimitive("a", FieldRepetitionType::REQUIRED, Type::INT32, 1);
-  ASSERT_NO_FATAL_FAILURE(Convert(elements, 2));
+      newPrimitive("a", FieldRepetitionType::REQUIRED, Type::kInt32, 1);
+  ASSERT_NO_FATAL_FAILURE(convert(elements, 2));
 
-  elements[0] = NewGroup("not-repeated", FieldRepetitionType::OPTIONAL, 1, 0);
-  ASSERT_NO_FATAL_FAILURE(Convert(elements, 2));
+  elements[0] = newGroup("not-repeated", FieldRepetitionType::OPTIONAL, 1, 0);
+  ASSERT_NO_FATAL_FAILURE(convert(elements, 2));
 }
 
 TEST_F(TestSchemaConverter, NotEnoughChildren) {
-  // Throw a ParquetException, but don't core dump or anything
+  // Throw a ParquetException, but don't core dump or anything.
   SchemaElement elt;
   std::vector<SchemaElement> elements;
-  elements.push_back(NewGroup(name_, FieldRepetitionType::REPEATED, 2, 0));
-  ASSERT_THROW(Convert(&elements[0], 1), ParquetException);
+  elements.push_back(newGroup(name_, FieldRepetitionType::REPEATED, 2, 0));
+  ASSERT_THROW(convert(&elements[0], 1), ParquetException);
 }
 
-// ----------------------------------------------------------------------
-// Schema tree flatten / unflatten
+// ----------------------------------------------------------------------.
+// Schema tree flatten / unflatten.
 
 class TestSchemaFlatten : public ::testing::Test {
  public:
-  void setUp() {
+  void SetUp() {
     name_ = "parquet_schema";
   }
 
-  void Flatten(const GroupNode* schema) {
-    ToParquet(schema, &elements_);
+  void flatten(const GroupNode* schema) {
+    toParquet(schema, &elements_);
   }
 
  protected:
@@ -680,42 +679,42 @@ class TestSchemaFlatten : public ::testing::Test {
 };
 
 TEST_F(TestSchemaFlatten, DecimalMetadata) {
-  // Checks that DecimalMetadata is only set for DecimalTypes
-  NodePtr node = PrimitiveNode::Make(
+  // Checks that DecimalMetadata is only set for DecimalTypes.
+  NodePtr Node = PrimitiveNode::make(
       "decimal",
-      Repetition::REQUIRED,
-      Type::INT64,
-      ConvertedType::DECIMAL,
+      Repetition::kRequired,
+      Type::kInt64,
+      ConvertedType::kDecimal,
       -1,
       8,
       4);
-  NodePtr group = GroupNode::Make(
-      "group", Repetition::REPEATED, {node}, ConvertedType::LIST);
-  Flatten(reinterpret_cast<GroupNode*>(group.get()));
+  NodePtr group = GroupNode::make(
+      "group", Repetition::kRepeated, {Node}, ConvertedType::kList);
+  flatten(reinterpret_cast<GroupNode*>(group.get()));
   ASSERT_EQ("decimal", elements_[1].name);
   ASSERT_TRUE(elements_[1].__isset.precision);
   ASSERT_TRUE(elements_[1].__isset.scale);
 
   elements_.clear();
-  // ... including those created with new logical types
-  node = PrimitiveNode::Make(
+  // ... Including those created with new logical types.
+  Node = PrimitiveNode::make(
       "decimal",
-      Repetition::REQUIRED,
-      DecimalLogicalType::Make(10, 5),
-      Type::INT64,
+      Repetition::kRequired,
+      DecimalLogicalType::make(10, 5),
+      Type::kInt64,
       -1);
-  group = GroupNode::Make(
-      "group", Repetition::REPEATED, {node}, ListLogicalType::Make());
-  Flatten(reinterpret_cast<GroupNode*>(group.get()));
+  group = GroupNode::make(
+      "group", Repetition::kRepeated, {Node}, ListLogicalType::make());
+  flatten(reinterpret_cast<GroupNode*>(group.get()));
   ASSERT_EQ("decimal", elements_[1].name);
   ASSERT_TRUE(elements_[1].__isset.precision);
   ASSERT_TRUE(elements_[1].__isset.scale);
 
   elements_.clear();
-  // Not for integers with no logical type
-  group = GroupNode::Make(
-      "group", Repetition::REPEATED, {Int64("int64")}, ConvertedType::LIST);
-  Flatten(reinterpret_cast<GroupNode*>(group.get()));
+  // Not for integers with no logical type.
+  group = GroupNode::make(
+      "group", Repetition::kRepeated, {int64("int64")}, ConvertedType::kList);
+  flatten(reinterpret_cast<GroupNode*>(group.get()));
   ASSERT_EQ("int64", elements_[1].name);
   ASSERT_FALSE(elements_[0].__isset.precision);
   ASSERT_FALSE(elements_[0].__isset.scale);
@@ -724,17 +723,17 @@ TEST_F(TestSchemaFlatten, DecimalMetadata) {
 TEST_F(TestSchemaFlatten, NestedExample) {
   SchemaElement elt;
   std::vector<SchemaElement> elements;
-  elements.push_back(NewGroup(name_, FieldRepetitionType::REPEATED, 2, 0));
+  elements.push_back(newGroup(name_, FieldRepetitionType::REPEATED, 2, 0));
 
-  // A primitive one
+  // A primitive one.
   elements.push_back(
-      NewPrimitive("a", FieldRepetitionType::REQUIRED, Type::INT32, 1));
+      newPrimitive("a", FieldRepetitionType::REQUIRED, Type::kInt32, 1));
 
-  // A group
-  elements.push_back(NewGroup("bag", FieldRepetitionType::OPTIONAL, 1, 2));
+  // A group.
+  elements.push_back(newGroup("bag", FieldRepetitionType::OPTIONAL, 1, 2));
 
-  // 3-level list encoding, by hand
-  elt = NewGroup("b", FieldRepetitionType::REPEATED, 1, 3);
+  // 3-Level list encoding, by hand.
+  elt = newGroup("b", FieldRepetitionType::REPEATED, 1, 3);
   elt.__set_converted_type(
       facebook::velox::parquet::thrift::ConvertedType::LIST);
   facebook::velox::parquet::thrift::ListType ls;
@@ -743,32 +742,25 @@ TEST_F(TestSchemaFlatten, NestedExample) {
   elt.__set_logicalType(lt);
   elements.push_back(elt);
   elements.push_back(
-      NewPrimitive("item", FieldRepetitionType::OPTIONAL, Type::INT64, 4));
+      newPrimitive("item", FieldRepetitionType::OPTIONAL, Type::kInt64, 4));
 
-  // Construct the schema
+  // Construct the schema.
   NodeVector fields;
-  fields.push_back(Int32("a", Repetition::REQUIRED, 1));
-
-  // 3-level list encoding
-  NodePtr item = Int64("item", Repetition::OPTIONAL, 4);
-  NodePtr list(GroupNode::Make(
-      "b", Repetition::REPEATED, {item}, ConvertedType::LIST, 3));
-  NodePtr bag(GroupNode::Make(
-      "bag",
-      Repetition::OPTIONAL,
-      {list},
-      /*logical_type=*/nullptr,
-      2));
+  fields.push_back(int32("a", Repetition::kRequired, 1));
+
+  // 3-Level list encoding.
+  NodePtr item = int64("item", Repetition::kOptional, 4);
+  NodePtr List(
+      GroupNode::make(
+          "b", Repetition::kRepeated, {item}, ConvertedType::kList, 3));
+  NodePtr bag(
+      GroupNode::make("bag", Repetition::kOptional, {List}, nullptr, 2));
   fields.push_back(bag);
 
-  NodePtr schema = GroupNode::Make(
-      name_,
-      Repetition::REPEATED,
-      fields,
-      /*logical_type=*/nullptr,
-      0);
+  NodePtr schema =
+      GroupNode::make(name_, Repetition::kRepeated, fields, nullptr, 0);
 
-  Flatten(static_cast<GroupNode*>(schema.get()));
+  flatten(static_cast<GroupNode*>(schema.get()));
   ASSERT_EQ(elements_.size(), elements.size());
   for (size_t i = 0; i < elements_.size(); i++) {
     ASSERT_EQ(elements_[i], elements[i]);
@@ -776,18 +768,18 @@ TEST_F(TestSchemaFlatten, NestedExample) {
 }
 
 TEST(TestColumnDescriptor, TestAttrs) {
-  NodePtr node = PrimitiveNode::Make(
-      "name", Repetition::OPTIONAL, Type::BYTE_ARRAY, ConvertedType::UTF8);
-  ColumnDescriptor descr(node, 4, 1);
+  NodePtr Node = PrimitiveNode::make(
+      "name", Repetition::kOptional, Type::kByteArray, ConvertedType::kUtf8);
+  ColumnDescriptor descr(Node, 4, 1);
 
   ASSERT_EQ("name", descr.name());
-  ASSERT_EQ(4, descr.max_definition_level());
-  ASSERT_EQ(1, descr.max_repetition_level());
+  ASSERT_EQ(4, descr.maxDefinitionLevel());
+  ASSERT_EQ(1, descr.maxRepetitionLevel());
 
-  ASSERT_EQ(Type::BYTE_ARRAY, descr.physical_type());
+  ASSERT_EQ(Type::kByteArray, descr.physicalType());
 
-  ASSERT_EQ(-1, descr.type_length());
-  const char* expected_descr = R"(column descriptor = {
+  ASSERT_EQ(-1, descr.typeLength());
+  const char* expectedDescr = R"(column descriptor = {
   name: name,
   path: ,
   physical_type: BYTE_ARRAY,
@@ -796,23 +788,23 @@ TEST(TestColumnDescriptor, TestAttrs) {
   max_definition_level: 4,
   max_repetition_level: 1,
 })";
-  ASSERT_EQ(expected_descr, descr.ToString());
+  ASSERT_EQ(expectedDescr, descr.toString());
 
-  // Test FIXED_LEN_BYTE_ARRAY
-  node = PrimitiveNode::Make(
+  // Test FIXED_LEN_BYTE_ARRAY.
+  Node = PrimitiveNode::make(
       "name",
-      Repetition::OPTIONAL,
-      Type::FIXED_LEN_BYTE_ARRAY,
-      ConvertedType::DECIMAL,
+      Repetition::kOptional,
+      Type::kFixedLenByteArray,
+      ConvertedType::kDecimal,
       12,
       10,
       4);
-  ColumnDescriptor descr2(node, 4, 1);
+  ColumnDescriptor descr2(Node, 4, 1);
 
-  ASSERT_EQ(Type::FIXED_LEN_BYTE_ARRAY, descr2.physical_type());
-  ASSERT_EQ(12, descr2.type_length());
+  ASSERT_EQ(Type::kFixedLenByteArray, descr2.physicalType());
+  ASSERT_EQ(12, descr2.typeLength());
 
-  expected_descr = R"(column descriptor = {
+  expectedDescr = R"(column descriptor = {
   name: name,
   path: ,
   physical_type: FIXED_LEN_BYTE_ARRAY,
@@ -824,248 +816,259 @@ TEST(TestColumnDescriptor, TestAttrs) {
   precision: 10,
   scale: 4,
 })";
-  ASSERT_EQ(expected_descr, descr2.ToString());
+  ASSERT_EQ(expectedDescr, descr2.toString());
 }
 
 class TestSchemaDescriptor : public ::testing::Test {
  public:
-  void setUp() {}
+  void SetUp() {}
 
  protected:
   SchemaDescriptor descr_;
 };
 
 TEST_F(TestSchemaDescriptor, InitNonGroup) {
-  NodePtr node =
-      PrimitiveNode::Make("field", Repetition::OPTIONAL, Type::INT32);
+  NodePtr Node =
+      PrimitiveNode::make("field", Repetition::kOptional, Type::kInt32);
 
-  ASSERT_THROW(descr_.Init(node), ParquetException);
+  ASSERT_THROW(descr_.init(Node), ParquetException);
 }
 
-TEST_F(TestSchemaDescriptor, Equals) {
+TEST_F(TestSchemaDescriptor, equals) {
   NodePtr schema;
 
-  NodePtr inta = Int32("a", Repetition::REQUIRED);
-  NodePtr intb = Int64("b", Repetition::OPTIONAL);
-  NodePtr intb2 = Int64("b2", Repetition::OPTIONAL);
-  NodePtr intc = ByteArray("c", Repetition::REPEATED);
+  NodePtr inta = int32("a", Repetition::kRequired);
+  NodePtr intb = int64("b", Repetition::kOptional);
+  NodePtr intb2 = int64("b2", Repetition::kOptional);
+  NodePtr intc = byteArray("c", Repetition::kRepeated);
 
-  NodePtr item1 = Int64("item1", Repetition::REQUIRED);
-  NodePtr item2 = Boolean("item2", Repetition::OPTIONAL);
-  NodePtr item3 = Int32("item3", Repetition::REPEATED);
-  NodePtr list(GroupNode::Make(
-      "records",
-      Repetition::REPEATED,
-      {item1, item2, item3},
-      ConvertedType::LIST));
+  NodePtr item1 = int64("item1", Repetition::kRequired);
+  NodePtr item2 = boolean("item2", Repetition::kOptional);
+  NodePtr item3 = int32("item3", Repetition::kRepeated);
+  NodePtr List(
+      GroupNode::make(
+          "records",
+          Repetition::kRepeated,
+          {item1, item2, item3},
+          ConvertedType::kList));
 
-  NodePtr bag(GroupNode::Make("bag", Repetition::OPTIONAL, {list}));
-  NodePtr bag2(GroupNode::Make("bag", Repetition::REQUIRED, {list}));
+  NodePtr bag(GroupNode::make("bag", Repetition::kOptional, {List}));
+  NodePtr bag2(GroupNode::make("bag", Repetition::kRequired, {List}));
 
   SchemaDescriptor descr1;
-  descr1.Init(
-      GroupNode::Make("schema", Repetition::REPEATED, {inta, intb, intc, bag}));
+  descr1.init(
+      GroupNode::make(
+          "schema", Repetition::kRepeated, {inta, intb, intc, bag}));
 
-  ASSERT_TRUE(descr1.Equals(descr1));
+  ASSERT_TRUE(descr1.equals(descr1));
 
   SchemaDescriptor descr2;
-  descr2.Init(GroupNode::Make(
-      "schema", Repetition::REPEATED, {inta, intb, intc, bag2}));
-  ASSERT_FALSE(descr1.Equals(descr2));
+  descr2.init(
+      GroupNode::make(
+          "schema", Repetition::kRepeated, {inta, intb, intc, bag2}));
+  ASSERT_FALSE(descr1.equals(descr2));
 
   SchemaDescriptor descr3;
-  descr3.Init(GroupNode::Make(
-      "schema", Repetition::REPEATED, {inta, intb2, intc, bag}));
-  ASSERT_FALSE(descr1.Equals(descr3));
+  descr3.init(
+      GroupNode::make(
+          "schema", Repetition::kRepeated, {inta, intb2, intc, bag}));
+  ASSERT_FALSE(descr1.equals(descr3));
 
-  // Robust to name of parent node
+  // Robust to name of parent node.
   SchemaDescriptor descr4;
-  descr4.Init(
-      GroupNode::Make("SCHEMA", Repetition::REPEATED, {inta, intb, intc, bag}));
-  ASSERT_TRUE(descr1.Equals(descr4));
+  descr4.init(
+      GroupNode::make(
+          "SCHEMA", Repetition::kRepeated, {inta, intb, intc, bag}));
+  ASSERT_TRUE(descr1.equals(descr4));
 
   SchemaDescriptor descr5;
-  descr5.Init(GroupNode::Make(
-      "schema", Repetition::REPEATED, {inta, intb, intc, bag, intb2}));
-  ASSERT_FALSE(descr1.Equals(descr5));
+  descr5.init(
+      GroupNode::make(
+          "schema", Repetition::kRepeated, {inta, intb, intc, bag, intb2}));
+  ASSERT_FALSE(descr1.equals(descr5));
 
-  // Different max repetition / definition levels
+  // Different max repetition / definition levels.
   ColumnDescriptor col1(inta, 5, 1);
   ColumnDescriptor col2(inta, 6, 1);
   ColumnDescriptor col3(inta, 5, 2);
 
-  ASSERT_TRUE(col1.Equals(col1));
-  ASSERT_FALSE(col1.Equals(col2));
-  ASSERT_FALSE(col1.Equals(col3));
+  ASSERT_TRUE(col1.equals(col1));
+  ASSERT_FALSE(col1.equals(col2));
+  ASSERT_FALSE(col1.equals(col3));
 }
 
-TEST_F(TestSchemaDescriptor, BuildTree) {
+TEST_F(TestSchemaDescriptor, buildTree) {
   NodeVector fields;
   NodePtr schema;
 
-  NodePtr inta = Int32("a", Repetition::REQUIRED);
+  NodePtr inta = int32("a", Repetition::kRequired);
   fields.push_back(inta);
-  fields.push_back(Int64("b", Repetition::OPTIONAL));
-  fields.push_back(ByteArray("c", Repetition::REPEATED));
-
-  // 3-level list encoding
-  NodePtr item1 = Int64("item1", Repetition::REQUIRED);
-  NodePtr item2 = Boolean("item2", Repetition::OPTIONAL);
-  NodePtr item3 = Int32("item3", Repetition::REPEATED);
-  NodePtr list(GroupNode::Make(
-      "records",
-      Repetition::REPEATED,
-      {item1, item2, item3},
-      ConvertedType::LIST));
-  NodePtr bag(GroupNode::Make("bag", Repetition::OPTIONAL, {list}));
+  fields.push_back(int64("b", Repetition::kOptional));
+  fields.push_back(byteArray("c", Repetition::kRepeated));
+
+  // 3-Level list encoding.
+  NodePtr item1 = int64("item1", Repetition::kRequired);
+  NodePtr item2 = boolean("item2", Repetition::kOptional);
+  NodePtr item3 = int32("item3", Repetition::kRepeated);
+  NodePtr List(
+      GroupNode::make(
+          "records",
+          Repetition::kRepeated,
+          {item1, item2, item3},
+          ConvertedType::kList));
+  NodePtr bag(GroupNode::make("bag", Repetition::kOptional, {List}));
   fields.push_back(bag);
 
-  schema = GroupNode::Make("schema", Repetition::REPEATED, fields);
+  schema = GroupNode::make("schema", Repetition::kRepeated, fields);
 
-  descr_.Init(schema);
+  descr_.init(schema);
 
   int nleaves = 6;
 
-  // 6 leaves
-  ASSERT_EQ(nleaves, descr_.num_columns());
-
-  //                             mdef mrep
-  // required int32 a            0    0
-  // optional int64 b            1    0
-  // repeated byte_array c       1    1
-  // optional group bag          1    0
-  //   repeated group records    2    1
-  //     required int64 item1    2    1
-  //     optional boolean item2  3    1
-  //     repeated int32 item3    3    2
-  int16_t ex_max_def_levels[6] = {0, 1, 1, 2, 3, 3};
-  int16_t ex_max_rep_levels[6] = {0, 0, 1, 1, 1, 2};
+  // 6 Leaves.
+  ASSERT_EQ(nleaves, descr_.numColumns());
+
+  //                             Mdef mrep.
+  // Required int32 a            0    0.
+  // Optional int64 b            1    0.
+  // Repeated byte_array c       1    1.
+  // Optional group bag          1    0.
+  //   Repeated group records    2    1.
+  //     Required int64 item1    2    1.
+  //     Optional boolean item2  3    1.
+  //     Repeated int32 item3    3    2.
+  int16_t exMaxDefLevels[6] = {0, 1, 1, 2, 3, 3};
+  int16_t exMaxRepLevels[6] = {0, 0, 1, 1, 1, 2};
 
   for (int i = 0; i < nleaves; ++i) {
-    const ColumnDescriptor* col = descr_.Column(i);
-    EXPECT_EQ(ex_max_def_levels[i], col->max_definition_level()) << i;
-    EXPECT_EQ(ex_max_rep_levels[i], col->max_repetition_level()) << i;
+    const ColumnDescriptor* col = descr_.column(i);
+    EXPECT_EQ(exMaxDefLevels[i], col->maxDefinitionLevel()) << i;
+    EXPECT_EQ(exMaxRepLevels[i], col->maxRepetitionLevel()) << i;
   }
 
-  ASSERT_EQ(descr_.Column(0)->path()->ToDotString(), "a");
-  ASSERT_EQ(descr_.Column(1)->path()->ToDotString(), "b");
-  ASSERT_EQ(descr_.Column(2)->path()->ToDotString(), "c");
-  ASSERT_EQ(descr_.Column(3)->path()->ToDotString(), "bag.records.item1");
-  ASSERT_EQ(descr_.Column(4)->path()->ToDotString(), "bag.records.item2");
-  ASSERT_EQ(descr_.Column(5)->path()->ToDotString(), "bag.records.item3");
+  ASSERT_EQ(descr_.column(0)->path()->toDotString(), "a");
+  ASSERT_EQ(descr_.column(1)->path()->toDotString(), "b");
+  ASSERT_EQ(descr_.column(2)->path()->toDotString(), "c");
+  ASSERT_EQ(descr_.column(3)->path()->toDotString(), "bag.records.item1");
+  ASSERT_EQ(descr_.column(4)->path()->toDotString(), "bag.records.item2");
+  ASSERT_EQ(descr_.column(5)->path()->toDotString(), "bag.records.item3");
 
   for (int i = 0; i < nleaves; ++i) {
-    auto col = descr_.Column(i);
-    ASSERT_EQ(i, descr_.ColumnIndex(*col->schema_node()));
+    auto col = descr_.column(i);
+    ASSERT_EQ(i, descr_.columnIndex(*col->schemaNode()));
   }
 
-  // Test non-column nodes find
-  NodePtr non_column_alien = Int32("alien", Repetition::REQUIRED); // other path
-  NodePtr non_column_familiar = Int32("a", Repetition::REPEATED); // other node
-  ASSERT_LT(descr_.ColumnIndex(*non_column_alien), 0);
-  ASSERT_LT(descr_.ColumnIndex(*non_column_familiar), 0);
+  // Test non-column nodes find.
+  NodePtr nonColumnAlien = int32("alien", Repetition::kRequired); // other path
+  NodePtr nonColumnFamiliar = int32("a", Repetition::kRepeated); // other node
+  ASSERT_LT(descr_.columnIndex(*nonColumnAlien), 0);
+  ASSERT_LT(descr_.columnIndex(*nonColumnFamiliar), 0);
 
-  ASSERT_EQ(inta.get(), descr_.GetColumnRoot(0));
-  ASSERT_EQ(bag.get(), descr_.GetColumnRoot(3));
-  ASSERT_EQ(bag.get(), descr_.GetColumnRoot(4));
-  ASSERT_EQ(bag.get(), descr_.GetColumnRoot(5));
+  ASSERT_EQ(inta.get(), descr_.getColumnRoot(0));
+  ASSERT_EQ(bag.get(), descr_.getColumnRoot(3));
+  ASSERT_EQ(bag.get(), descr_.getColumnRoot(4));
+  ASSERT_EQ(bag.get(), descr_.getColumnRoot(5));
 
-  ASSERT_EQ(schema.get(), descr_.group_node());
+  ASSERT_EQ(schema.get(), descr_.groupNode());
 
-  // Init clears the leaves
-  descr_.Init(schema);
-  ASSERT_EQ(nleaves, descr_.num_columns());
+  // Init clears the leaves.
+  descr_.init(schema);
+  ASSERT_EQ(nleaves, descr_.numColumns());
 }
 
-TEST_F(TestSchemaDescriptor, HasRepeatedFields) {
+TEST_F(TestSchemaDescriptor, hasRepeatedFields) {
   NodeVector fields;
   NodePtr schema;
 
-  NodePtr inta = Int32("a", Repetition::REQUIRED);
+  NodePtr inta = int32("a", Repetition::kRequired);
   fields.push_back(inta);
-  fields.push_back(Int64("b", Repetition::OPTIONAL));
-  fields.push_back(ByteArray("c", Repetition::REPEATED));
-
-  schema = GroupNode::Make("schema", Repetition::REPEATED, fields);
-  descr_.Init(schema);
-  ASSERT_EQ(true, descr_.HasRepeatedFields());
-
-  // 3-level list encoding
-  NodePtr item1 = Int64("item1", Repetition::REQUIRED);
-  NodePtr item2 = Boolean("item2", Repetition::OPTIONAL);
-  NodePtr item3 = Int32("item3", Repetition::REPEATED);
-  NodePtr list(GroupNode::Make(
-      "records",
-      Repetition::REPEATED,
-      {item1, item2, item3},
-      ConvertedType::LIST));
-  NodePtr bag(GroupNode::Make("bag", Repetition::OPTIONAL, {list}));
+  fields.push_back(int64("b", Repetition::kOptional));
+  fields.push_back(byteArray("c", Repetition::kRepeated));
+
+  schema = GroupNode::make("schema", Repetition::kRepeated, fields);
+  descr_.init(schema);
+  ASSERT_EQ(true, descr_.hasRepeatedFields());
+
+  // 3-Level list encoding.
+  NodePtr item1 = int64("item1", Repetition::kRequired);
+  NodePtr item2 = boolean("item2", Repetition::kOptional);
+  NodePtr item3 = int32("item3", Repetition::kRepeated);
+  NodePtr List(
+      GroupNode::make(
+          "records",
+          Repetition::kRepeated,
+          {item1, item2, item3},
+          ConvertedType::kList));
+  NodePtr bag(GroupNode::make("bag", Repetition::kOptional, {List}));
   fields.push_back(bag);
 
-  schema = GroupNode::Make("schema", Repetition::REPEATED, fields);
-  descr_.Init(schema);
-  ASSERT_EQ(true, descr_.HasRepeatedFields());
-
-  // 3-level list encoding
-  NodePtr item_key = Int64("key", Repetition::REQUIRED);
-  NodePtr item_value = Boolean("value", Repetition::OPTIONAL);
-  NodePtr map(GroupNode::Make(
-      "map", Repetition::REPEATED, {item_key, item_value}, ConvertedType::MAP));
-  NodePtr my_map(GroupNode::Make("my_map", Repetition::OPTIONAL, {map}));
-  fields.push_back(my_map);
-
-  schema = GroupNode::Make("schema", Repetition::REPEATED, fields);
-  descr_.Init(schema);
-  ASSERT_EQ(true, descr_.HasRepeatedFields());
-  ASSERT_EQ(true, descr_.HasRepeatedFields());
+  schema = GroupNode::make("schema", Repetition::kRepeated, fields);
+  descr_.init(schema);
+  ASSERT_EQ(true, descr_.hasRepeatedFields());
+
+  // 3-Level list encoding.
+  NodePtr itemKey = int64("key", Repetition::kRequired);
+  NodePtr itemValue = boolean("value", Repetition::kOptional);
+  NodePtr Map(
+      GroupNode::make(
+          "map",
+          Repetition::kRepeated,
+          {itemKey, itemValue},
+          ConvertedType::kMap));
+  NodePtr myMap(GroupNode::make("my_map", Repetition::kOptional, {Map}));
+  fields.push_back(myMap);
+
+  schema = GroupNode::make("schema", Repetition::kRepeated, fields);
+  descr_.init(schema);
+  ASSERT_EQ(true, descr_.hasRepeatedFields());
+  ASSERT_EQ(true, descr_.hasRepeatedFields());
 }
 
-static std::string Print(const NodePtr& node) {
+static std::string print(const NodePtr& Node) {
   std::stringstream ss;
-  PrintSchema(node.get(), ss);
+  printSchema(Node.get(), ss);
   return ss.str();
 }
 
 TEST(TestSchemaPrinter, Examples) {
-  // Test schema 1
+  // Test schema 1.
   NodeVector fields;
-  fields.push_back(Int32("a", Repetition::REQUIRED, 1));
-
-  // 3-level list encoding
-  NodePtr item1 = Int64("item1", Repetition::OPTIONAL, 4);
-  NodePtr item2 = Boolean("item2", Repetition::REQUIRED, 5);
-  NodePtr list(GroupNode::Make(
-      "b", Repetition::REPEATED, {item1, item2}, ConvertedType::LIST, 3));
-  NodePtr bag(GroupNode::Make(
-      "bag", Repetition::OPTIONAL, {list}, /*logical_type=*/nullptr, 2));
+  fields.push_back(int32("a", Repetition::kRequired, 1));
+
+  // 3-Level list encoding.
+  NodePtr item1 = int64("item1", Repetition::kOptional, 4);
+  NodePtr item2 = boolean("item2", Repetition::kRequired, 5);
+  NodePtr List(
+      GroupNode::make(
+          "b", Repetition::kRepeated, {item1, item2}, ConvertedType::kList, 3));
+  NodePtr bag(
+      GroupNode::make("bag", Repetition::kOptional, {List}, nullptr, 2));
   fields.push_back(bag);
 
-  fields.push_back(PrimitiveNode::Make(
-      "c",
-      Repetition::REQUIRED,
-      Type::INT32,
-      ConvertedType::DECIMAL,
-      -1,
-      3,
-      2,
-      6));
-
-  fields.push_back(PrimitiveNode::Make(
-      "d",
-      Repetition::REQUIRED,
-      DecimalLogicalType::Make(10, 5),
-      Type::INT64,
-      /*length=*/-1,
-      7));
-
-  NodePtr schema = GroupNode::Make(
-      "schema",
-      Repetition::REPEATED,
-      fields,
-      /*logical_type=*/nullptr,
-      0);
+  fields.push_back(
+      PrimitiveNode::make(
+          "c",
+          Repetition::kRequired,
+          Type::kInt32,
+          ConvertedType::kDecimal,
+          -1,
+          3,
+          2,
+          6));
+
+  fields.push_back(
+      PrimitiveNode::make(
+          "d",
+          Repetition::kRequired,
+          DecimalLogicalType::make(10, 5),
+          Type::kInt64,
+          -1,
+          7));
 
-  std::string result = Print(schema);
+  NodePtr schema =
+      GroupNode::make("schema", Repetition::kRepeated, fields, nullptr, 0);
+
+  std::string result = print(schema);
 
   std::string expected = R"(repeated group field_id=0 schema {
   required int32 field_id=1 a;
@@ -1082,349 +1085,330 @@ TEST(TestSchemaPrinter, Examples) {
   ASSERT_EQ(expected, result);
 }
 
-static void ConfirmFactoryEquivalence(
-    ConvertedType::type converted_type,
-    const std::shared_ptr<const LogicalType>& from_make,
+static void confirmFactoryEquivalence(
+    ConvertedType::type convertedType,
+    const std::shared_ptr<const LogicalType>& fromMake,
     std::function<bool(const std::shared_ptr<const LogicalType>&)>
-        check_is_type) {
-  std::shared_ptr<const LogicalType> from_converted_type =
-      LogicalType::FromConvertedType(converted_type);
-  ASSERT_EQ(from_converted_type->type(), from_make->type())
-      << from_make->ToString()
+        checkIsType) {
+  std::shared_ptr<const LogicalType> fromConvertedType =
+      LogicalType::fromConvertedType(convertedType);
+  ASSERT_EQ(fromConvertedType->type(), fromMake->type())
+      << fromMake->toString()
       << " logical types unexpectedly do not match on type";
-  ASSERT_TRUE(from_converted_type->Equals(*from_make))
-      << from_make->ToString() << " logical types unexpectedly not equivalent";
-  ASSERT_TRUE(check_is_type(from_converted_type))
-      << from_converted_type->ToString()
+  ASSERT_TRUE(fromConvertedType->equals(*fromMake))
+      << fromMake->toString() << " logical types unexpectedly not equivalent";
+  ASSERT_TRUE(checkIsType(fromConvertedType))
+      << fromConvertedType->toString()
       << " logical type (from converted type) does not have expected type property";
-  ASSERT_TRUE(check_is_type(from_make))
-      << from_make->ToString()
+  ASSERT_TRUE(checkIsType(fromMake))
+      << fromMake->toString()
       << " logical type (from Make()) does not have expected type property";
   return;
 }
 
 TEST(TestLogicalTypeConstruction, FactoryEquivalence) {
-  // For each legacy converted type, ensure that the equivalent logical type
+  // For each legacy converted type, ensure that the equivalent logical type.
   // object can be obtained from either the base class's FromConvertedType()
-  // factory method or the logical type type class's Make() method (accessed via
-  // convenience methods on the base class) and that these logical type objects
-  // are equivalent
+  // Factory method or the logical type type class's Make() method (accessed
+  // via. Convenience methods on the base class) and that these logical type
+  // objects. Are equivalent.
 
   struct ConfirmFactoryEquivalenceArguments {
-    ConvertedType::type converted_type;
-    std::shared_ptr<const LogicalType> logical_type;
-    std::function<bool(const std::shared_ptr<const LogicalType>&)>
-        check_is_type;
+    ConvertedType::type convertedType;
+    std::shared_ptr<const LogicalType> logicalType;
+    std::function<bool(const std::shared_ptr<const LogicalType>&)> checkIsType;
   };
 
-  auto check_is_string =
-      [](const std::shared_ptr<const LogicalType>& logical_type) {
-        return logical_type->is_string();
-      };
-  auto check_is_map =
-      [](const std::shared_ptr<const LogicalType>& logical_type) {
-        return logical_type->is_map();
-      };
-  auto check_is_list =
-      [](const std::shared_ptr<const LogicalType>& logical_type) {
-        return logical_type->is_list();
-      };
-  auto check_is_enum =
-      [](const std::shared_ptr<const LogicalType>& logical_type) {
-        return logical_type->is_enum();
-      };
-  auto check_is_date =
-      [](const std::shared_ptr<const LogicalType>& logical_type) {
-        return logical_type->is_date();
-      };
-  auto check_is_time =
-      [](const std::shared_ptr<const LogicalType>& logical_type) {
-        return logical_type->is_time();
-      };
-  auto check_is_timestamp =
-      [](const std::shared_ptr<const LogicalType>& logical_type) {
-        return logical_type->is_timestamp();
-      };
-  auto check_is_int =
-      [](const std::shared_ptr<const LogicalType>& logical_type) {
-        return logical_type->is_int();
-      };
-  auto check_is_JSON =
-      [](const std::shared_ptr<const LogicalType>& logical_type) {
-        return logical_type->is_JSON();
-      };
-  auto check_is_BSON =
-      [](const std::shared_ptr<const LogicalType>& logical_type) {
-        return logical_type->is_BSON();
+  auto checkIsString =
+      [](const std::shared_ptr<const LogicalType>& logicalType) {
+        return logicalType->isString();
       };
-  auto check_is_interval =
-      [](const std::shared_ptr<const LogicalType>& logical_type) {
-        return logical_type->is_interval();
+  auto checkIsMap = [](const std::shared_ptr<const LogicalType>& logicalType) {
+    return logicalType->isMap();
+  };
+  auto checkIsList = [](const std::shared_ptr<const LogicalType>& logicalType) {
+    return logicalType->isList();
+  };
+  auto checkIsenum = [](const std::shared_ptr<const LogicalType>& logicalType) {
+    return logicalType->isEnum();
+  };
+  auto checkIsDate = [](const std::shared_ptr<const LogicalType>& logicalType) {
+    return logicalType->isDate();
+  };
+  auto checkIsTime = [](const std::shared_ptr<const LogicalType>& logicalType) {
+    return logicalType->isTime();
+  };
+  auto checkIsTimestamp =
+      [](const std::shared_ptr<const LogicalType>& logicalType) {
+        return logicalType->isTimestamp();
       };
-  auto check_is_none =
-      [](const std::shared_ptr<const LogicalType>& logical_type) {
-        return logical_type->is_none();
+  auto checkIsInt = [](const std::shared_ptr<const LogicalType>& logicalType) {
+    return logicalType->isInt();
+  };
+  auto checkIsJson = [](const std::shared_ptr<const LogicalType>& logicalType) {
+    return logicalType->isJson();
+  };
+  auto checkIsBson = [](const std::shared_ptr<const LogicalType>& logicalType) {
+    return logicalType->isBson();
+  };
+  auto checkIsInterval =
+      [](const std::shared_ptr<const LogicalType>& logicalType) {
+        return logicalType->isInterval();
       };
+  auto checkIsNone = [](const std::shared_ptr<const LogicalType>& logicalType) {
+    return logicalType->isNone();
+  };
 
   std::vector<ConfirmFactoryEquivalenceArguments> cases = {
-      {ConvertedType::UTF8, LogicalType::String(), check_is_string},
-      {ConvertedType::MAP, LogicalType::Map(), check_is_map},
-      {ConvertedType::MAP_KEY_VALUE, LogicalType::Map(), check_is_map},
-      {ConvertedType::LIST, LogicalType::List(), check_is_list},
-      {ConvertedType::ENUM, LogicalType::Enum(), check_is_enum},
-      {ConvertedType::DATE, LogicalType::Date(), check_is_date},
-      {ConvertedType::TIME_MILLIS,
-       LogicalType::Time(true, LogicalType::TimeUnit::MILLIS),
-       check_is_time},
-      {ConvertedType::TIME_MICROS,
-       LogicalType::Time(true, LogicalType::TimeUnit::MICROS),
-       check_is_time},
-      {ConvertedType::TIMESTAMP_MILLIS,
-       LogicalType::Timestamp(true, LogicalType::TimeUnit::MILLIS),
-       check_is_timestamp},
-      {ConvertedType::TIMESTAMP_MICROS,
-       LogicalType::Timestamp(true, LogicalType::TimeUnit::MICROS),
-       check_is_timestamp},
-      {ConvertedType::UINT_8, LogicalType::Int(8, false), check_is_int},
-      {ConvertedType::UINT_16, LogicalType::Int(16, false), check_is_int},
-      {ConvertedType::UINT_32, LogicalType::Int(32, false), check_is_int},
-      {ConvertedType::UINT_64, LogicalType::Int(64, false), check_is_int},
-      {ConvertedType::INT_8, LogicalType::Int(8, true), check_is_int},
-      {ConvertedType::INT_16, LogicalType::Int(16, true), check_is_int},
-      {ConvertedType::INT_32, LogicalType::Int(32, true), check_is_int},
-      {ConvertedType::INT_64, LogicalType::Int(64, true), check_is_int},
-      {ConvertedType::JSON, LogicalType::JSON(), check_is_JSON},
-      {ConvertedType::BSON, LogicalType::BSON(), check_is_BSON},
-      {ConvertedType::INTERVAL, LogicalType::Interval(), check_is_interval},
-      {ConvertedType::NONE, LogicalType::None(), check_is_none}};
+      {ConvertedType::kUtf8, LogicalType::string(), checkIsString},
+      {ConvertedType::kMap, LogicalType::map(), checkIsMap},
+      {ConvertedType::kMapKeyValue, LogicalType::map(), checkIsMap},
+      {ConvertedType::kList, LogicalType::list(), checkIsList},
+      {ConvertedType::kEnum, LogicalType::enumType(), checkIsenum},
+      {ConvertedType::kDate, LogicalType::date(), checkIsDate},
+      {ConvertedType::kTimeMillis,
+       LogicalType::time(true, LogicalType::TimeUnit::kMillis),
+       checkIsTime},
+      {ConvertedType::kTimeMicros,
+       LogicalType::time(true, LogicalType::TimeUnit::kMicros),
+       checkIsTime},
+      {ConvertedType::kTimestampMillis,
+       LogicalType::timestamp(true, LogicalType::TimeUnit::kMillis),
+       checkIsTimestamp},
+      {ConvertedType::kTimestampMicros,
+       LogicalType::timestamp(true, LogicalType::TimeUnit::kMicros),
+       checkIsTimestamp},
+      {ConvertedType::kUint8, LogicalType::intType(8, false), checkIsInt},
+      {ConvertedType::kUint16, LogicalType::intType(16, false), checkIsInt},
+      {ConvertedType::kUint32, LogicalType::intType(32, false), checkIsInt},
+      {ConvertedType::kUint64, LogicalType::intType(64, false), checkIsInt},
+      {ConvertedType::kInt8, LogicalType::intType(8, true), checkIsInt},
+      {ConvertedType::kInt16, LogicalType::intType(16, true), checkIsInt},
+      {ConvertedType::kInt32, LogicalType::intType(32, true), checkIsInt},
+      {ConvertedType::kInt64, LogicalType::intType(64, true), checkIsInt},
+      {ConvertedType::kJson, LogicalType::json(), checkIsJson},
+      {ConvertedType::kBson, LogicalType::bson(), checkIsBson},
+      {ConvertedType::kInterval, LogicalType::interval(), checkIsInterval},
+      {ConvertedType::kNone, LogicalType::none(), checkIsNone}};
 
   for (const ConfirmFactoryEquivalenceArguments& c : cases) {
-    ConfirmFactoryEquivalence(
-        c.converted_type, c.logical_type, c.check_is_type);
+    confirmFactoryEquivalence(c.convertedType, c.logicalType, c.checkIsType);
   }
 
-  // ConvertedType::DECIMAL, LogicalType::Decimal, is_decimal
-  schema::DecimalMetadata converted_decimal_metadata;
-  converted_decimal_metadata.isset = true;
-  converted_decimal_metadata.precision = 10;
-  converted_decimal_metadata.scale = 4;
-  std::shared_ptr<const LogicalType> from_converted_type =
-      LogicalType::FromConvertedType(
-          ConvertedType::DECIMAL, converted_decimal_metadata);
-  std::shared_ptr<const LogicalType> from_make = LogicalType::Decimal(10, 4);
-  ASSERT_EQ(from_converted_type->type(), from_make->type());
-  ASSERT_TRUE(from_converted_type->Equals(*from_make));
-  ASSERT_TRUE(from_converted_type->is_decimal());
-  ASSERT_TRUE(from_make->is_decimal());
-  ASSERT_TRUE(LogicalType::Decimal(16)->Equals(*LogicalType::Decimal(16, 0)));
+  // ConvertedType::kDecimal, LogicalType::decimal, is_decimal.
+  schema::DecimalMetadata convertedDecimalMetadata;
+  convertedDecimalMetadata.isset = true;
+  convertedDecimalMetadata.precision = 10;
+  convertedDecimalMetadata.scale = 4;
+  std::shared_ptr<const LogicalType> fromConvertedType =
+      LogicalType::fromConvertedType(
+          ConvertedType::kDecimal, convertedDecimalMetadata);
+  std::shared_ptr<const LogicalType> fromMake = LogicalType::decimal(10, 4);
+  ASSERT_EQ(fromConvertedType->type(), fromMake->type());
+  ASSERT_TRUE(fromConvertedType->equals(*fromMake));
+  ASSERT_TRUE(fromConvertedType->isDecimal());
+  ASSERT_TRUE(fromMake->isDecimal());
+  ASSERT_TRUE(LogicalType::decimal(16)->equals(*LogicalType::decimal(16, 0)));
 }
 
-static void ConfirmConvertedTypeCompatibility(
+static void confirmConvertedTypeCompatibility(
     const std::shared_ptr<const LogicalType>& original,
-    ConvertedType::type expected_converted_type) {
-  ASSERT_TRUE(original->is_valid())
-      << original->ToString() << " logical type unexpectedly is not valid";
-  schema::DecimalMetadata converted_decimal_metadata;
-  ConvertedType::type converted_type =
-      original->ToConvertedType(&converted_decimal_metadata);
-  ASSERT_EQ(converted_type, expected_converted_type)
-      << original->ToString()
+    ConvertedType::type expectedConvertedType) {
+  ASSERT_TRUE(original->isValid())
+      << original->toString() << " logical type unexpectedly is not valid";
+  schema::DecimalMetadata convertedDecimalMetadata;
+  ConvertedType::type convertedType =
+      original->toConvertedType(&convertedDecimalMetadata);
+  ASSERT_EQ(convertedType, expectedConvertedType)
+      << original->toString()
       << " logical type unexpectedly returns incorrect converted type";
-  ASSERT_FALSE(converted_decimal_metadata.isset)
-      << original->ToString()
+  ASSERT_FALSE(convertedDecimalMetadata.isset)
+      << original->toString()
       << " logical type unexpectedly returns converted decimal metadata that is set";
-  ASSERT_TRUE(
-      original->is_compatible(converted_type, converted_decimal_metadata))
-      << original->ToString()
+  ASSERT_TRUE(original->isCompatible(convertedType, convertedDecimalMetadata))
+      << original->toString()
       << " logical type unexpectedly is incompatible with converted type and decimal "
          "metadata it returned";
-  ASSERT_FALSE(original->is_compatible(converted_type, {true, 1, 1}))
-      << original->ToString()
+  ASSERT_FALSE(original->isCompatible(convertedType, {true, 1, 1}))
+      << original->toString()
       << " logical type unexpectedly is compatible with converted decimal metadata that "
          "is "
          "set";
-  ASSERT_TRUE(original->is_compatible(converted_type))
-      << original->ToString()
+  ASSERT_TRUE(original->isCompatible(convertedType))
+      << original->toString()
       << " logical type unexpectedly is incompatible with converted type it returned";
   std::shared_ptr<const LogicalType> reconstructed =
-      LogicalType::FromConvertedType(
-          converted_type, converted_decimal_metadata);
-  ASSERT_TRUE(reconstructed->is_valid())
-      << "Reconstructed " << reconstructed->ToString()
+      LogicalType::fromConvertedType(convertedType, convertedDecimalMetadata);
+  ASSERT_TRUE(reconstructed->isValid())
+      << "Reconstructed " << reconstructed->toString()
       << " logical type unexpectedly is not valid";
-  ASSERT_TRUE(reconstructed->Equals(*original))
-      << "Reconstructed logical type (" << reconstructed->ToString()
+  ASSERT_TRUE(reconstructed->equals(*original))
+      << "Reconstructed logical type (" << reconstructed->toString()
       << ") unexpectedly not equivalent to original logical type ("
-      << original->ToString() << ")";
+      << original->toString() << ")";
   return;
 }
 
 TEST(TestLogicalTypeConstruction, ConvertedTypeCompatibility) {
-  // For each legacy converted type, ensure that the equivalent logical type
-  // emits correct, compatible converted type information and that the emitted
-  // information can be used to reconstruct another equivalent logical type.
+  // For each legacy converted type, ensure that the equivalent logical type.
+  // Emits correct, compatible converted type information and that the emitted.
+  // Information can be used to reconstruct another equivalent logical type.
 
   struct ExpectedConvertedType {
-    std::shared_ptr<const LogicalType> logical_type;
-    ConvertedType::type converted_type;
+    std::shared_ptr<const LogicalType> logicalType;
+    ConvertedType::type convertedType;
   };
 
   std::vector<ExpectedConvertedType> cases = {
-      {LogicalType::String(), ConvertedType::UTF8},
-      {LogicalType::Map(), ConvertedType::MAP},
-      {LogicalType::List(), ConvertedType::LIST},
-      {LogicalType::Enum(), ConvertedType::ENUM},
-      {LogicalType::Date(), ConvertedType::DATE},
-      {LogicalType::Time(true, LogicalType::TimeUnit::MILLIS),
-       ConvertedType::TIME_MILLIS},
-      {LogicalType::Time(true, LogicalType::TimeUnit::MICROS),
-       ConvertedType::TIME_MICROS},
-      {LogicalType::Timestamp(true, LogicalType::TimeUnit::MILLIS),
-       ConvertedType::TIMESTAMP_MILLIS},
-      {LogicalType::Timestamp(true, LogicalType::TimeUnit::MICROS),
-       ConvertedType::TIMESTAMP_MICROS},
-      {LogicalType::Int(8, false), ConvertedType::UINT_8},
-      {LogicalType::Int(16, false), ConvertedType::UINT_16},
-      {LogicalType::Int(32, false), ConvertedType::UINT_32},
-      {LogicalType::Int(64, false), ConvertedType::UINT_64},
-      {LogicalType::Int(8, true), ConvertedType::INT_8},
-      {LogicalType::Int(16, true), ConvertedType::INT_16},
-      {LogicalType::Int(32, true), ConvertedType::INT_32},
-      {LogicalType::Int(64, true), ConvertedType::INT_64},
-      {LogicalType::JSON(), ConvertedType::JSON},
-      {LogicalType::BSON(), ConvertedType::BSON},
-      {LogicalType::Interval(), ConvertedType::INTERVAL},
-      {LogicalType::None(), ConvertedType::NONE}};
+      {LogicalType::string(), ConvertedType::kUtf8},
+      {LogicalType::map(), ConvertedType::kMap},
+      {LogicalType::list(), ConvertedType::kList},
+      {LogicalType::enumType(), ConvertedType::kEnum},
+      {LogicalType::date(), ConvertedType::kDate},
+      {LogicalType::time(true, LogicalType::TimeUnit::kMillis),
+       ConvertedType::kTimeMillis},
+      {LogicalType::time(true, LogicalType::TimeUnit::kMicros),
+       ConvertedType::kTimeMicros},
+      {LogicalType::timestamp(true, LogicalType::TimeUnit::kMillis),
+       ConvertedType::kTimestampMillis},
+      {LogicalType::timestamp(true, LogicalType::TimeUnit::kMicros),
+       ConvertedType::kTimestampMicros},
+      {LogicalType::intType(8, false), ConvertedType::kUint8},
+      {LogicalType::intType(16, false), ConvertedType::kUint16},
+      {LogicalType::intType(32, false), ConvertedType::kUint32},
+      {LogicalType::intType(64, false), ConvertedType::kUint64},
+      {LogicalType::intType(8, true), ConvertedType::kInt8},
+      {LogicalType::intType(16, true), ConvertedType::kInt16},
+      {LogicalType::intType(32, true), ConvertedType::kInt32},
+      {LogicalType::intType(64, true), ConvertedType::kInt64},
+      {LogicalType::json(), ConvertedType::kJson},
+      {LogicalType::bson(), ConvertedType::kBson},
+      {LogicalType::interval(), ConvertedType::kInterval},
+      {LogicalType::none(), ConvertedType::kNone}};
 
   for (const ExpectedConvertedType& c : cases) {
-    ConfirmConvertedTypeCompatibility(c.logical_type, c.converted_type);
+    confirmConvertedTypeCompatibility(c.logicalType, c.convertedType);
   }
 
   // Special cases ...
 
   std::shared_ptr<const LogicalType> original;
-  ConvertedType::type converted_type;
-  schema::DecimalMetadata converted_decimal_metadata;
+  ConvertedType::type convertedType;
+  schema::DecimalMetadata convertedDecimalMetadata;
   std::shared_ptr<const LogicalType> reconstructed;
 
-  // DECIMAL
+  // DECIMAL.
   std::memset(
-      &converted_decimal_metadata, 0x00, sizeof(converted_decimal_metadata));
-  original = LogicalType::Decimal(6, 2);
-  ASSERT_TRUE(original->is_valid());
-  converted_type = original->ToConvertedType(&converted_decimal_metadata);
-  ASSERT_EQ(converted_type, ConvertedType::DECIMAL);
-  ASSERT_TRUE(converted_decimal_metadata.isset);
-  ASSERT_EQ(converted_decimal_metadata.precision, 6);
-  ASSERT_EQ(converted_decimal_metadata.scale, 2);
-  ASSERT_TRUE(
-      original->is_compatible(converted_type, converted_decimal_metadata));
-  reconstructed = LogicalType::FromConvertedType(
-      converted_type, converted_decimal_metadata);
-  ASSERT_TRUE(reconstructed->is_valid());
-  ASSERT_TRUE(reconstructed->Equals(*original));
-
-  // Undefined
-  original = UndefinedLogicalType::Make();
-  ASSERT_TRUE(original->is_invalid());
-  ASSERT_FALSE(original->is_valid());
-  converted_type = original->ToConvertedType(&converted_decimal_metadata);
-  ASSERT_EQ(converted_type, ConvertedType::UNDEFINED);
-  ASSERT_FALSE(converted_decimal_metadata.isset);
-  ASSERT_TRUE(
-      original->is_compatible(converted_type, converted_decimal_metadata));
-  ASSERT_TRUE(original->is_compatible(converted_type));
-  reconstructed = LogicalType::FromConvertedType(
-      converted_type, converted_decimal_metadata);
-  ASSERT_TRUE(reconstructed->is_invalid());
-  ASSERT_TRUE(reconstructed->Equals(*original));
+      &convertedDecimalMetadata, 0x00, sizeof(convertedDecimalMetadata));
+  original = LogicalType::decimal(6, 2);
+  ASSERT_TRUE(original->isValid());
+  convertedType = original->toConvertedType(&convertedDecimalMetadata);
+  ASSERT_EQ(convertedType, ConvertedType::kDecimal);
+  ASSERT_TRUE(convertedDecimalMetadata.isset);
+  ASSERT_EQ(convertedDecimalMetadata.precision, 6);
+  ASSERT_EQ(convertedDecimalMetadata.scale, 2);
+  ASSERT_TRUE(original->isCompatible(convertedType, convertedDecimalMetadata));
+  reconstructed =
+      LogicalType::fromConvertedType(convertedType, convertedDecimalMetadata);
+  ASSERT_TRUE(reconstructed->isValid());
+  ASSERT_TRUE(reconstructed->equals(*original));
+
+  // Undefined.
+  original = UndefinedLogicalType::make();
+  ASSERT_TRUE(original->isInvalid());
+  ASSERT_FALSE(original->isValid());
+  convertedType = original->toConvertedType(&convertedDecimalMetadata);
+  ASSERT_EQ(convertedType, ConvertedType::kUndefined);
+  ASSERT_FALSE(convertedDecimalMetadata.isset);
+  ASSERT_TRUE(original->isCompatible(convertedType, convertedDecimalMetadata));
+  ASSERT_TRUE(original->isCompatible(convertedType));
+  reconstructed =
+      LogicalType::fromConvertedType(convertedType, convertedDecimalMetadata);
+  ASSERT_TRUE(reconstructed->isInvalid());
+  ASSERT_TRUE(reconstructed->equals(*original));
 }
 
-static void ConfirmNewTypeIncompatibility(
-    const std::shared_ptr<const LogicalType>& logical_type,
+static void confirmNewTypeIncompatibility(
+    const std::shared_ptr<const LogicalType>& logicalType,
     std::function<bool(const std::shared_ptr<const LogicalType>&)>
-        check_is_type) {
-  ASSERT_TRUE(logical_type->is_valid())
-      << logical_type->ToString() << " logical type unexpectedly is not valid";
-  ASSERT_TRUE(check_is_type(logical_type))
-      << logical_type->ToString()
+        checkIsType) {
+  ASSERT_TRUE(logicalType->isValid())
+      << logicalType->toString() << " logical type unexpectedly is not valid";
+  ASSERT_TRUE(checkIsType(logicalType))
+      << logicalType->toString()
       << " logical type is not expected logical type";
-  schema::DecimalMetadata converted_decimal_metadata;
-  ConvertedType::type converted_type =
-      logical_type->ToConvertedType(&converted_decimal_metadata);
-  ASSERT_EQ(converted_type, ConvertedType::NONE)
-      << logical_type->ToString()
+  schema::DecimalMetadata convertedDecimalMetadata;
+  ConvertedType::type convertedType =
+      logicalType->toConvertedType(&convertedDecimalMetadata);
+  ASSERT_EQ(convertedType, ConvertedType::kNone)
+      << logicalType->toString()
       << " logical type converted type unexpectedly is not NONE";
-  ASSERT_FALSE(converted_decimal_metadata.isset)
-      << logical_type->ToString()
+  ASSERT_FALSE(convertedDecimalMetadata.isset)
+      << logicalType->toString()
       << " logical type converted decimal metadata unexpectedly is set";
   return;
 }
 
 TEST(TestLogicalTypeConstruction, NewTypeIncompatibility) {
-  // For each new logical type, ensure that the type
-  // correctly reports that it has no legacy equivalent
+  // For each new logical type, ensure that the type.
+  // Correctly reports that it has no legacy equivalent.
 
   struct ConfirmNewTypeIncompatibilityArguments {
-    std::shared_ptr<const LogicalType> logical_type;
-    std::function<bool(const std::shared_ptr<const LogicalType>&)>
-        check_is_type;
+    std::shared_ptr<const LogicalType> logicalType;
+    std::function<bool(const std::shared_ptr<const LogicalType>&)> checkIsType;
   };
 
-  auto check_is_UUID =
-      [](const std::shared_ptr<const LogicalType>& logical_type) {
-        return logical_type->is_UUID();
-      };
-  auto check_is_null =
-      [](const std::shared_ptr<const LogicalType>& logical_type) {
-        return logical_type->is_null();
-      };
-  auto check_is_time =
-      [](const std::shared_ptr<const LogicalType>& logical_type) {
-        return logical_type->is_time();
-      };
-  auto check_is_timestamp =
-      [](const std::shared_ptr<const LogicalType>& logical_type) {
-        return logical_type->is_timestamp();
+  auto checkIsUuid = [](const std::shared_ptr<const LogicalType>& logicalType) {
+    return logicalType->isUuid();
+  };
+  auto checkIsNull = [](const std::shared_ptr<const LogicalType>& logicalType) {
+    return logicalType->isNull();
+  };
+  auto checkIsTime = [](const std::shared_ptr<const LogicalType>& logicalType) {
+    return logicalType->isTime();
+  };
+  auto checkIsTimestamp =
+      [](const std::shared_ptr<const LogicalType>& logicalType) {
+        return logicalType->isTimestamp();
       };
 
   std::vector<ConfirmNewTypeIncompatibilityArguments> cases = {
-      {LogicalType::UUID(), check_is_UUID},
-      {LogicalType::Null(), check_is_null},
-      {LogicalType::Time(false, LogicalType::TimeUnit::MILLIS), check_is_time},
-      {LogicalType::Time(false, LogicalType::TimeUnit::MICROS), check_is_time},
-      {LogicalType::Time(false, LogicalType::TimeUnit::NANOS), check_is_time},
-      {LogicalType::Time(true, LogicalType::TimeUnit::NANOS), check_is_time},
-      {LogicalType::Timestamp(false, LogicalType::TimeUnit::NANOS),
-       check_is_timestamp},
-      {LogicalType::Timestamp(true, LogicalType::TimeUnit::NANOS),
-       check_is_timestamp},
+      {LogicalType::uuid(), checkIsUuid},
+      {LogicalType::nullType(), checkIsNull},
+      {LogicalType::time(false, LogicalType::TimeUnit::kMillis), checkIsTime},
+      {LogicalType::time(false, LogicalType::TimeUnit::kMicros), checkIsTime},
+      {LogicalType::time(false, LogicalType::TimeUnit::kNanos), checkIsTime},
+      {LogicalType::time(true, LogicalType::TimeUnit::kNanos), checkIsTime},
+      {LogicalType::timestamp(false, LogicalType::TimeUnit::kNanos),
+       checkIsTimestamp},
+      {LogicalType::timestamp(true, LogicalType::TimeUnit::kNanos),
+       checkIsTimestamp},
   };
 
   for (const ConfirmNewTypeIncompatibilityArguments& c : cases) {
-    ConfirmNewTypeIncompatibility(c.logical_type, c.check_is_type);
+    confirmNewTypeIncompatibility(c.logicalType, c.checkIsType);
   }
 }
 
 TEST(TestLogicalTypeConstruction, FactoryExceptions) {
-  // Ensure that logical type construction catches invalid arguments
+  // Ensure that logical type construction catches invalid arguments.
 
   std::vector<std::function<void()>> cases = {
       []() {
-        TimeLogicalType::Make(true, LogicalType::TimeUnit::UNKNOWN);
+        TimeLogicalType::make(true, LogicalType::TimeUnit::kUnknown);
       }, // Invalid TimeUnit
       []() {
-        TimestampLogicalType::Make(true, LogicalType::TimeUnit::UNKNOWN);
+        TimestampLogicalType::make(true, LogicalType::TimeUnit::kUnknown);
       }, // Invalid TimeUnit
-      []() { IntLogicalType::Make(-1, false); }, // Invalid bit width
-      []() { IntLogicalType::Make(0, false); }, // Invalid bit width
-      []() { IntLogicalType::Make(1, false); }, // Invalid bit width
-      []() { IntLogicalType::Make(65, false); }, // Invalid bit width
-      []() { DecimalLogicalType::Make(-1); }, // Invalid precision
-      []() { DecimalLogicalType::Make(0); }, // Invalid precision
-      []() { DecimalLogicalType::Make(0, 0); }, // Invalid precision
-      []() { DecimalLogicalType::Make(10, -1); }, // Invalid scale
-      []() { DecimalLogicalType::Make(10, 11); } // Invalid scale
+      []() { IntLogicalType::make(-1, false); }, // Invalid bit width
+      []() { IntLogicalType::make(0, false); }, // Invalid bit width
+      []() { IntLogicalType::make(1, false); }, // Invalid bit width
+      []() { IntLogicalType::make(65, false); }, // Invalid bit width
+      []() { DecimalLogicalType::make(-1); }, // Invalid precision
+      []() { DecimalLogicalType::make(0); }, // Invalid precision
+      []() { DecimalLogicalType::make(0, 0); }, // Invalid precision
+      []() { DecimalLogicalType::make(10, -1); }, // Invalid scale
+      []() { DecimalLogicalType::make(10, 11); } // Invalid scale
   };
 
   for (auto f : cases) {
@@ -1432,247 +1416,248 @@ TEST(TestLogicalTypeConstruction, FactoryExceptions) {
   }
 }
 
-static void ConfirmLogicalTypeProperties(
-    const std::shared_ptr<const LogicalType>& logical_type,
+static void confirmLogicalTypeProperties(
+    const std::shared_ptr<const LogicalType>& logicalType,
     bool nested,
     bool serialized,
     bool valid) {
-  ASSERT_TRUE(logical_type->is_nested() == nested)
-      << logical_type->ToString()
+  ASSERT_TRUE(logicalType->isNested() == nested)
+      << logicalType->toString()
       << " logical type has incorrect nested() property";
-  ASSERT_TRUE(logical_type->is_serialized() == serialized)
-      << logical_type->ToString()
+  ASSERT_TRUE(logicalType->isSerialized() == serialized)
+      << logicalType->toString()
       << " logical type has incorrect serialized() property";
-  ASSERT_TRUE(logical_type->is_valid() == valid)
-      << logical_type->ToString()
+  ASSERT_TRUE(logicalType->isValid() == valid)
+      << logicalType->toString()
       << " logical type has incorrect valid() property";
-  ASSERT_TRUE(logical_type->is_nonnested() != nested)
-      << logical_type->ToString()
+  ASSERT_TRUE(logicalType->isNonnested() != nested)
+      << logicalType->toString()
       << " logical type has incorrect nonnested() property";
-  ASSERT_TRUE(logical_type->is_invalid() != valid)
-      << logical_type->ToString()
+  ASSERT_TRUE(logicalType->isInvalid() != valid)
+      << logicalType->toString()
       << " logical type has incorrect invalid() property";
   return;
 }
 
 TEST(TestLogicalTypeOperation, LogicalTypeProperties) {
-  // For each logical type, ensure that the correct general properties are
-  // reported
+  // For each logical type, ensure that the correct general properties are.
+  // Reported.
 
   struct ExpectedProperties {
-    std::shared_ptr<const LogicalType> logical_type;
+    std::shared_ptr<const LogicalType> logicalType;
     bool nested;
     bool serialized;
     bool valid;
   };
 
   std::vector<ExpectedProperties> cases = {
-      {StringLogicalType::Make(), false, true, true},
-      {MapLogicalType::Make(), true, true, true},
-      {ListLogicalType::Make(), true, true, true},
-      {EnumLogicalType::Make(), false, true, true},
-      {DecimalLogicalType::Make(16, 6), false, true, true},
-      {DateLogicalType::Make(), false, true, true},
-      {TimeLogicalType::Make(true, LogicalType::TimeUnit::MICROS),
+      {StringLogicalType::make(), false, true, true},
+      {MapLogicalType::make(), true, true, true},
+      {ListLogicalType::make(), true, true, true},
+      {EnumLogicalType::make(), false, true, true},
+      {DecimalLogicalType::make(16, 6), false, true, true},
+      {DateLogicalType::make(), false, true, true},
+      {TimeLogicalType::make(true, LogicalType::TimeUnit::kMicros),
        false,
        true,
        true},
-      {TimestampLogicalType::Make(true, LogicalType::TimeUnit::MICROS),
+      {TimestampLogicalType::make(true, LogicalType::TimeUnit::kMicros),
        false,
        true,
        true},
-      {IntervalLogicalType::Make(), false, true, true},
-      {IntLogicalType::Make(8, false), false, true, true},
-      {IntLogicalType::Make(64, true), false, true, true},
-      {NullLogicalType::Make(), false, true, true},
-      {JSONLogicalType::Make(), false, true, true},
-      {BSONLogicalType::Make(), false, true, true},
-      {UUIDLogicalType::Make(), false, true, true},
-      {NoLogicalType::Make(), false, false, true},
+      {IntervalLogicalType::make(), false, true, true},
+      {IntLogicalType::make(8, false), false, true, true},
+      {IntLogicalType::make(64, true), false, true, true},
+      {NullLogicalType::make(), false, true, true},
+      {JsonLogicalType::make(), false, true, true},
+      {BsonLogicalType::make(), false, true, true},
+      {UuidLogicalType::make(), false, true, true},
+      {NoLogicalType::make(), false, false, true},
   };
 
   for (const ExpectedProperties& c : cases) {
-    ConfirmLogicalTypeProperties(
-        c.logical_type, c.nested, c.serialized, c.valid);
+    confirmLogicalTypeProperties(
+        c.logicalType, c.nested, c.serialized, c.valid);
   }
 }
 
 static constexpr int PHYSICAL_TYPE_COUNT = 8;
 
-static Type::type physical_type[PHYSICAL_TYPE_COUNT] = {
-    Type::BOOLEAN,
-    Type::INT32,
-    Type::INT64,
-    Type::INT96,
-    Type::FLOAT,
-    Type::DOUBLE,
-    Type::BYTE_ARRAY,
-    Type::FIXED_LEN_BYTE_ARRAY};
-
-static void ConfirmSinglePrimitiveTypeApplicability(
-    const std::shared_ptr<const LogicalType>& logical_type,
-    Type::type applicable_type) {
+static Type::type physicalType[PHYSICAL_TYPE_COUNT] = {
+    Type::kBoolean,
+    Type::kInt32,
+    Type::kInt64,
+    Type::kInt96,
+    Type::kFloat,
+    Type::kDouble,
+    Type::kByteArray,
+    Type::kFixedLenByteArray};
+
+static void confirmSinglePrimitiveTypeApplicability(
+    const std::shared_ptr<const LogicalType>& logicalType,
+    Type::type applicableType) {
   for (int i = 0; i < PHYSICAL_TYPE_COUNT; ++i) {
-    if (physical_type[i] == applicable_type) {
-      ASSERT_TRUE(logical_type->is_applicable(physical_type[i]))
-          << logical_type->ToString()
+    if (physicalType[i] == applicableType) {
+      ASSERT_TRUE(logicalType->isApplicable(physicalType[i]))
+          << logicalType->toString()
           << " logical type unexpectedly inapplicable to physical type "
-          << TypeToString(physical_type[i]);
+          << typeToString(physicalType[i]);
     } else {
-      ASSERT_FALSE(logical_type->is_applicable(physical_type[i]))
-          << logical_type->ToString()
+      ASSERT_FALSE(logicalType->isApplicable(physicalType[i]))
+          << logicalType->toString()
           << " logical type unexpectedly applicable to physical type "
-          << TypeToString(physical_type[i]);
+          << typeToString(physicalType[i]);
     }
   }
   return;
 }
 
-static void ConfirmAnyPrimitiveTypeApplicability(
-    const std::shared_ptr<const LogicalType>& logical_type) {
+static void confirmAnyPrimitiveTypeApplicability(
+    const std::shared_ptr<const LogicalType>& logicalType) {
   for (int i = 0; i < PHYSICAL_TYPE_COUNT; ++i) {
-    ASSERT_TRUE(logical_type->is_applicable(physical_type[i]))
-        << logical_type->ToString()
+    ASSERT_TRUE(logicalType->isApplicable(physicalType[i]))
+        << logicalType->toString()
         << " logical type unexpectedly inapplicable to physical type "
-        << TypeToString(physical_type[i]);
+        << typeToString(physicalType[i]);
   }
   return;
 }
 
-static void ConfirmNoPrimitiveTypeApplicability(
-    const std::shared_ptr<const LogicalType>& logical_type) {
+static void confirmNoPrimitiveTypeApplicability(
+    const std::shared_ptr<const LogicalType>& logicalType) {
   for (int i = 0; i < PHYSICAL_TYPE_COUNT; ++i) {
-    ASSERT_FALSE(logical_type->is_applicable(physical_type[i]))
-        << logical_type->ToString()
+    ASSERT_FALSE(logicalType->isApplicable(physicalType[i]))
+        << logicalType->toString()
         << " logical type unexpectedly applicable to physical type "
-        << TypeToString(physical_type[i]);
+        << typeToString(physicalType[i]);
   }
   return;
 }
 
 TEST(TestLogicalTypeOperation, LogicalTypeApplicability) {
-  // Check that each logical type correctly reports which
-  // underlying primitive type(s) it can be applied to
+  // Check that each logical type correctly reports which.
+  // Underlying primitive type(s) it can be applied to.
 
   struct ExpectedApplicability {
-    std::shared_ptr<const LogicalType> logical_type;
-    Type::type applicable_type;
+    std::shared_ptr<const LogicalType> logicalType;
+    Type::type applicableType;
   };
 
-  std::vector<ExpectedApplicability> single_type_cases = {
-      {LogicalType::String(), Type::BYTE_ARRAY},
-      {LogicalType::Enum(), Type::BYTE_ARRAY},
-      {LogicalType::Date(), Type::INT32},
-      {LogicalType::Time(true, LogicalType::TimeUnit::MILLIS), Type::INT32},
-      {LogicalType::Time(true, LogicalType::TimeUnit::MICROS), Type::INT64},
-      {LogicalType::Time(true, LogicalType::TimeUnit::NANOS), Type::INT64},
-      {LogicalType::Timestamp(true, LogicalType::TimeUnit::MILLIS),
-       Type::INT64},
-      {LogicalType::Timestamp(true, LogicalType::TimeUnit::MICROS),
-       Type::INT64},
-      {LogicalType::Timestamp(true, LogicalType::TimeUnit::NANOS), Type::INT64},
-      {LogicalType::Int(8, false), Type::INT32},
-      {LogicalType::Int(16, false), Type::INT32},
-      {LogicalType::Int(32, false), Type::INT32},
-      {LogicalType::Int(64, false), Type::INT64},
-      {LogicalType::Int(8, true), Type::INT32},
-      {LogicalType::Int(16, true), Type::INT32},
-      {LogicalType::Int(32, true), Type::INT32},
-      {LogicalType::Int(64, true), Type::INT64},
-      {LogicalType::JSON(), Type::BYTE_ARRAY},
-      {LogicalType::BSON(), Type::BYTE_ARRAY}};
-
-  for (const ExpectedApplicability& c : single_type_cases) {
-    ConfirmSinglePrimitiveTypeApplicability(c.logical_type, c.applicable_type);
+  std::vector<ExpectedApplicability> singleTypeCases = {
+      {LogicalType::string(), Type::kByteArray},
+      {LogicalType::enumType(), Type::kByteArray},
+      {LogicalType::date(), Type::kInt32},
+      {LogicalType::time(true, LogicalType::TimeUnit::kMillis), Type::kInt32},
+      {LogicalType::time(true, LogicalType::TimeUnit::kMicros), Type::kInt64},
+      {LogicalType::time(true, LogicalType::TimeUnit::kNanos), Type::kInt64},
+      {LogicalType::timestamp(true, LogicalType::TimeUnit::kMillis),
+       Type::kInt64},
+      {LogicalType::timestamp(true, LogicalType::TimeUnit::kMicros),
+       Type::kInt64},
+      {LogicalType::timestamp(true, LogicalType::TimeUnit::kNanos),
+       Type::kInt64},
+      {LogicalType::intType(8, false), Type::kInt32},
+      {LogicalType::intType(16, false), Type::kInt32},
+      {LogicalType::intType(32, false), Type::kInt32},
+      {LogicalType::intType(64, false), Type::kInt64},
+      {LogicalType::intType(8, true), Type::kInt32},
+      {LogicalType::intType(16, true), Type::kInt32},
+      {LogicalType::intType(32, true), Type::kInt32},
+      {LogicalType::intType(64, true), Type::kInt64},
+      {LogicalType::json(), Type::kByteArray},
+      {LogicalType::bson(), Type::kByteArray}};
+
+  for (const ExpectedApplicability& c : singleTypeCases) {
+    confirmSinglePrimitiveTypeApplicability(c.logicalType, c.applicableType);
   }
 
-  std::vector<std::shared_ptr<const LogicalType>> no_type_cases = {
-      LogicalType::Map(), LogicalType::List()};
+  std::vector<std::shared_ptr<const LogicalType>> noTypeCases = {
+      LogicalType::map(), LogicalType::list()};
 
-  for (auto c : no_type_cases) {
-    ConfirmNoPrimitiveTypeApplicability(c);
+  for (auto c : noTypeCases) {
+    confirmNoPrimitiveTypeApplicability(c);
   }
 
-  std::vector<std::shared_ptr<const LogicalType>> any_type_cases = {
-      LogicalType::Null(), LogicalType::None(), UndefinedLogicalType::Make()};
+  std::vector<std::shared_ptr<const LogicalType>> anyTypeCases = {
+      LogicalType::nullType(),
+      LogicalType::none(),
+      UndefinedLogicalType::make()};
 
-  for (auto c : any_type_cases) {
-    ConfirmAnyPrimitiveTypeApplicability(c);
+  for (auto c : anyTypeCases) {
+    confirmAnyPrimitiveTypeApplicability(c);
   }
 
   // Fixed binary, exact length cases ...
 
   struct InapplicableType {
-    Type::type physical_type;
-    int physical_length;
+    Type::type physicalType;
+    int physicalLength;
   };
 
-  std::vector<InapplicableType> inapplicable_types = {
-      {Type::FIXED_LEN_BYTE_ARRAY, 8},
-      {Type::FIXED_LEN_BYTE_ARRAY, 20},
-      {Type::BOOLEAN, -1},
-      {Type::INT32, -1},
-      {Type::INT64, -1},
-      {Type::INT96, -1},
-      {Type::FLOAT, -1},
-      {Type::DOUBLE, -1},
-      {Type::BYTE_ARRAY, -1}};
-
-  std::shared_ptr<const LogicalType> logical_type;
-
-  logical_type = LogicalType::Interval();
-  ASSERT_TRUE(logical_type->is_applicable(Type::FIXED_LEN_BYTE_ARRAY, 12));
-  for (const InapplicableType& t : inapplicable_types) {
-    ASSERT_FALSE(
-        logical_type->is_applicable(t.physical_type, t.physical_length));
+  std::vector<InapplicableType> inapplicableTypes = {
+      {Type::kFixedLenByteArray, 8},
+      {Type::kFixedLenByteArray, 20},
+      {Type::kBoolean, -1},
+      {Type::kInt32, -1},
+      {Type::kInt64, -1},
+      {Type::kInt96, -1},
+      {Type::kFloat, -1},
+      {Type::kDouble, -1},
+      {Type::kByteArray, -1}};
+
+  std::shared_ptr<const LogicalType> logicalType;
+
+  logicalType = LogicalType::interval();
+  ASSERT_TRUE(logicalType->isApplicable(Type::kFixedLenByteArray, 12));
+  for (const InapplicableType& t : inapplicableTypes) {
+    ASSERT_FALSE(logicalType->isApplicable(t.physicalType, t.physicalLength));
   }
 
-  logical_type = LogicalType::UUID();
-  ASSERT_TRUE(logical_type->is_applicable(Type::FIXED_LEN_BYTE_ARRAY, 16));
-  for (const InapplicableType& t : inapplicable_types) {
-    ASSERT_FALSE(
-        logical_type->is_applicable(t.physical_type, t.physical_length));
+  logicalType = LogicalType::uuid();
+  ASSERT_TRUE(logicalType->isApplicable(Type::kFixedLenByteArray, 16));
+  for (const InapplicableType& t : inapplicableTypes) {
+    ASSERT_FALSE(logicalType->isApplicable(t.physicalType, t.physicalLength));
   }
 }
 
 TEST(TestLogicalTypeOperation, DecimalLogicalTypeApplicability) {
-  // Check that the decimal logical type correctly reports which
-  // underlying primitive type(s) it can be applied to
+  // Check that the decimal logical type correctly reports which.
+  // Underlying primitive type(s) it can be applied to.
 
-  std::shared_ptr<const LogicalType> logical_type;
+  std::shared_ptr<const LogicalType> logicalType;
 
   for (int32_t precision = 1; precision <= 9; ++precision) {
-    logical_type = DecimalLogicalType::Make(precision, 0);
-    ASSERT_TRUE(logical_type->is_applicable(Type::INT32))
-        << logical_type->ToString()
+    logicalType = DecimalLogicalType::make(precision, 0);
+    ASSERT_TRUE(logicalType->isApplicable(Type::kInt32))
+        << logicalType->toString()
         << " unexpectedly inapplicable to physical type INT32";
   }
-  logical_type = DecimalLogicalType::Make(10, 0);
-  ASSERT_FALSE(logical_type->is_applicable(Type::INT32))
-      << logical_type->ToString()
+  logicalType = DecimalLogicalType::make(10, 0);
+  ASSERT_FALSE(logicalType->isApplicable(Type::kInt32))
+      << logicalType->toString()
       << " unexpectedly applicable to physical type INT32";
 
   for (int32_t precision = 1; precision <= 18; ++precision) {
-    logical_type = DecimalLogicalType::Make(precision, 0);
-    ASSERT_TRUE(logical_type->is_applicable(Type::INT64))
-        << logical_type->ToString()
+    logicalType = DecimalLogicalType::make(precision, 0);
+    ASSERT_TRUE(logicalType->isApplicable(Type::kInt64))
+        << logicalType->toString()
         << " unexpectedly inapplicable to physical type INT64";
   }
-  logical_type = DecimalLogicalType::Make(19, 0);
-  ASSERT_FALSE(logical_type->is_applicable(Type::INT64))
-      << logical_type->ToString()
+  logicalType = DecimalLogicalType::make(19, 0);
+  ASSERT_FALSE(logicalType->isApplicable(Type::kInt64))
+      << logicalType->toString()
       << " unexpectedly applicable to physical type INT64";
 
   for (int32_t precision = 1; precision <= 36; ++precision) {
-    logical_type = DecimalLogicalType::Make(precision, 0);
-    ASSERT_TRUE(logical_type->is_applicable(Type::BYTE_ARRAY))
-        << logical_type->ToString()
+    logicalType = DecimalLogicalType::make(precision, 0);
+    ASSERT_TRUE(logicalType->isApplicable(Type::kByteArray))
+        << logicalType->toString()
         << " unexpectedly inapplicable to physical type BYTE_ARRAY";
   }
 
   struct PrecisionLimits {
-    int32_t physical_length;
-    int32_t precision_limit;
+    int32_t physicalLength;
+    int32_t precisionLimit;
   };
 
   std::vector<PrecisionLimits> cases = {
@@ -1688,607 +1673,645 @@ TEST(TestLogicalTypeOperation, DecimalLogicalTypeApplicability) {
 
   for (const PrecisionLimits& c : cases) {
     int32_t precision;
-    for (precision = 1; precision <= c.precision_limit; ++precision) {
-      logical_type = DecimalLogicalType::Make(precision, 0);
-      ASSERT_TRUE(logical_type->is_applicable(
-          Type::FIXED_LEN_BYTE_ARRAY, c.physical_length))
-          << logical_type->ToString()
+    for (precision = 1; precision <= c.precisionLimit; ++precision) {
+      logicalType = DecimalLogicalType::make(precision, 0);
+      ASSERT_TRUE(
+          logicalType->isApplicable(Type::kFixedLenByteArray, c.physicalLength))
+          << logicalType->toString()
           << " unexpectedly inapplicable to physical type FIXED_LEN_BYTE_ARRAY with "
              "length "
-          << c.physical_length;
+          << c.physicalLength;
     }
-    logical_type = DecimalLogicalType::Make(precision, 0);
-    ASSERT_FALSE(logical_type->is_applicable(
-        Type::FIXED_LEN_BYTE_ARRAY, c.physical_length))
-        << logical_type->ToString()
+    logicalType = DecimalLogicalType::make(precision, 0);
+    ASSERT_FALSE(
+        logicalType->isApplicable(Type::kFixedLenByteArray, c.physicalLength))
+        << logicalType->toString()
         << " unexpectedly applicable to physical type FIXED_LEN_BYTE_ARRAY with length "
-        << c.physical_length;
+        << c.physicalLength;
   }
 
-  ASSERT_FALSE((DecimalLogicalType::Make(16, 6))->is_applicable(Type::BOOLEAN));
-  ASSERT_FALSE((DecimalLogicalType::Make(16, 6))->is_applicable(Type::FLOAT));
-  ASSERT_FALSE((DecimalLogicalType::Make(16, 6))->is_applicable(Type::DOUBLE));
+  ASSERT_FALSE((DecimalLogicalType::make(16, 6))->isApplicable(Type::kBoolean));
+  ASSERT_FALSE((DecimalLogicalType::make(16, 6))->isApplicable(Type::kFloat));
+  ASSERT_FALSE((DecimalLogicalType::make(16, 6))->isApplicable(Type::kDouble));
 }
 
 TEST(TestLogicalTypeOperation, LogicalTypeRepresentation) {
-  // Ensure that each logical type prints a correct string and
-  // JSON representation
+  // Ensure that each logical type prints a correct string and.
+  // JSON representation.
 
   struct ExpectedRepresentation {
-    std::shared_ptr<const LogicalType> logical_type;
-    const char* string_representation;
-    const char* JSON_representation;
+    std::shared_ptr<const LogicalType> logicalType;
+    const char* stringRepresentation;
+    const char* jsonRepresentation;
   };
 
   std::vector<ExpectedRepresentation> cases = {
-      {UndefinedLogicalType::Make(), "Undefined", R"({"Type": "Undefined"})"},
-      {LogicalType::String(), "String", R"({"Type": "String"})"},
-      {LogicalType::Map(), "Map", R"({"Type": "Map"})"},
-      {LogicalType::List(), "List", R"({"Type": "List"})"},
-      {LogicalType::Enum(), "Enum", R"({"Type": "Enum"})"},
-      {LogicalType::Decimal(10, 4),
+      {UndefinedLogicalType::make(), "Undefined", R"({"Type": "Undefined"})"},
+      {LogicalType::string(), "String", R"({"Type": "String"})"},
+      {LogicalType::map(), "Map", R"({"Type": "Map"})"},
+      {LogicalType::list(), "List", R"({"Type": "List"})"},
+      {LogicalType::enumType(), "Enum", R"({"Type": "Enum"})"},
+      {LogicalType::decimal(10, 4),
        "Decimal(precision=10, scale=4)",
        R"({"Type": "Decimal", "precision": 10, "scale": 4})"},
-      {LogicalType::Decimal(10),
+      {LogicalType::decimal(10),
        "Decimal(precision=10, scale=0)",
        R"({"Type": "Decimal", "precision": 10, "scale": 0})"},
-      {LogicalType::Date(), "Date", R"({"Type": "Date"})"},
-      {LogicalType::Time(true, LogicalType::TimeUnit::MILLIS),
+      {LogicalType::date(), "Date", R"({"Type": "Date"})"},
+      {LogicalType::time(true, LogicalType::TimeUnit::kMillis),
        "Time(isAdjustedToUTC=true, timeUnit=milliseconds)",
        R"({"Type": "Time", "isAdjustedToUTC": true, "timeUnit": "milliseconds"})"},
-      {LogicalType::Time(true, LogicalType::TimeUnit::MICROS),
+      {LogicalType::time(true, LogicalType::TimeUnit::kMicros),
        "Time(isAdjustedToUTC=true, timeUnit=microseconds)",
        R"({"Type": "Time", "isAdjustedToUTC": true, "timeUnit": "microseconds"})"},
-      {LogicalType::Time(true, LogicalType::TimeUnit::NANOS),
+      {LogicalType::time(true, LogicalType::TimeUnit::kNanos),
        "Time(isAdjustedToUTC=true, timeUnit=nanoseconds)",
        R"({"Type": "Time", "isAdjustedToUTC": true, "timeUnit": "nanoseconds"})"},
-      {LogicalType::Time(false, LogicalType::TimeUnit::MILLIS),
+      {LogicalType::time(false, LogicalType::TimeUnit::kMillis),
        "Time(isAdjustedToUTC=false, timeUnit=milliseconds)",
        R"({"Type": "Time", "isAdjustedToUTC": false, "timeUnit": "milliseconds"})"},
-      {LogicalType::Time(false, LogicalType::TimeUnit::MICROS),
+      {LogicalType::time(false, LogicalType::TimeUnit::kMicros),
        "Time(isAdjustedToUTC=false, timeUnit=microseconds)",
        R"({"Type": "Time", "isAdjustedToUTC": false, "timeUnit": "microseconds"})"},
-      {LogicalType::Time(false, LogicalType::TimeUnit::NANOS),
+      {LogicalType::time(false, LogicalType::TimeUnit::kNanos),
        "Time(isAdjustedToUTC=false, timeUnit=nanoseconds)",
        R"({"Type": "Time", "isAdjustedToUTC": false, "timeUnit": "nanoseconds"})"},
-      {LogicalType::Timestamp(true, LogicalType::TimeUnit::MILLIS),
+      {LogicalType::timestamp(true, LogicalType::TimeUnit::kMillis),
        "Timestamp(isAdjustedToUTC=true, timeUnit=milliseconds, "
        "is_from_converted_type=false, force_set_converted_type=false)",
        R"({"Type": "Timestamp", "isAdjustedToUTC": true, "timeUnit": "milliseconds", )"
-       R"("is_from_converted_type": false, "force_set_converted_type": false})"},
-      {LogicalType::Timestamp(true, LogicalType::TimeUnit::MICROS),
+       R"("isFromConvertedType": false, "forceSetConvertedType": false})"},
+      {LogicalType::timestamp(true, LogicalType::TimeUnit::kMicros),
        "Timestamp(isAdjustedToUTC=true, timeUnit=microseconds, "
        "is_from_converted_type=false, force_set_converted_type=false)",
        R"({"Type": "Timestamp", "isAdjustedToUTC": true, "timeUnit": "microseconds", )"
-       R"("is_from_converted_type": false, "force_set_converted_type": false})"},
-      {LogicalType::Timestamp(true, LogicalType::TimeUnit::NANOS),
+       R"("isFromConvertedType": false, "forceSetConvertedType": false})"},
+      {LogicalType::timestamp(true, LogicalType::TimeUnit::kNanos),
        "Timestamp(isAdjustedToUTC=true, timeUnit=nanoseconds, "
        "is_from_converted_type=false, force_set_converted_type=false)",
        R"({"Type": "Timestamp", "isAdjustedToUTC": true, "timeUnit": "nanoseconds", )"
-       R"("is_from_converted_type": false, "force_set_converted_type": false})"},
-      {LogicalType::Timestamp(false, LogicalType::TimeUnit::MILLIS, true, true),
+       R"("isFromConvertedType": false, "forceSetConvertedType": false})"},
+      {LogicalType::timestamp(
+           false, LogicalType::TimeUnit::kMillis, true, true),
        "Timestamp(isAdjustedToUTC=false, timeUnit=milliseconds, "
        "is_from_converted_type=true, force_set_converted_type=true)",
        R"({"Type": "Timestamp", "isAdjustedToUTC": false, "timeUnit": "milliseconds", )"
-       R"("is_from_converted_type": true, "force_set_converted_type": true})"},
-      {LogicalType::Timestamp(false, LogicalType::TimeUnit::MICROS),
+       R"("isFromConvertedType": true, "forceSetConvertedType": true})"},
+      {LogicalType::timestamp(false, LogicalType::TimeUnit::kMicros),
        "Timestamp(isAdjustedToUTC=false, timeUnit=microseconds, "
        "is_from_converted_type=false, force_set_converted_type=false)",
        R"({"Type": "Timestamp", "isAdjustedToUTC": false, "timeUnit": "microseconds", )"
-       R"("is_from_converted_type": false, "force_set_converted_type": false})"},
-      {LogicalType::Timestamp(false, LogicalType::TimeUnit::NANOS),
+       R"("isFromConvertedType": false, "forceSetConvertedType": false})"},
+      {LogicalType::timestamp(false, LogicalType::TimeUnit::kNanos),
        "Timestamp(isAdjustedToUTC=false, timeUnit=nanoseconds, "
        "is_from_converted_type=false, force_set_converted_type=false)",
        R"({"Type": "Timestamp", "isAdjustedToUTC": false, "timeUnit": "nanoseconds", )"
-       R"("is_from_converted_type": false, "force_set_converted_type": false})"},
-      {LogicalType::Interval(), "Interval", R"({"Type": "Interval"})"},
-      {LogicalType::Int(8, false),
+       R"("isFromConvertedType": false, "forceSetConvertedType": false})"},
+      {LogicalType::interval(), "Interval", R"({"Type": "Interval"})"},
+      {LogicalType::intType(8, false),
        "Int(bitWidth=8, isSigned=false)",
-       R"({"Type": "Int", "bitWidth": 8, "isSigned": false})"},
-      {LogicalType::Int(16, false),
+       R"({"Type": "int", "bitWidth": 8, "isSigned": false})"},
+      {LogicalType::intType(16, false),
        "Int(bitWidth=16, isSigned=false)",
-       R"({"Type": "Int", "bitWidth": 16, "isSigned": false})"},
-      {LogicalType::Int(32, false),
+       R"({"Type": "int", "bitWidth": 16, "isSigned": false})"},
+      {LogicalType::intType(32, false),
        "Int(bitWidth=32, isSigned=false)",
-       R"({"Type": "Int", "bitWidth": 32, "isSigned": false})"},
-      {LogicalType::Int(64, false),
+       R"({"Type": "int", "bitWidth": 32, "isSigned": false})"},
+      {LogicalType::intType(64, false),
        "Int(bitWidth=64, isSigned=false)",
-       R"({"Type": "Int", "bitWidth": 64, "isSigned": false})"},
-      {LogicalType::Int(8, true),
+       R"({"Type": "int", "bitWidth": 64, "isSigned": false})"},
+      {LogicalType::intType(8, true),
        "Int(bitWidth=8, isSigned=true)",
-       R"({"Type": "Int", "bitWidth": 8, "isSigned": true})"},
-      {LogicalType::Int(16, true),
+       R"({"Type": "int", "bitWidth": 8, "isSigned": true})"},
+      {LogicalType::intType(16, true),
        "Int(bitWidth=16, isSigned=true)",
-       R"({"Type": "Int", "bitWidth": 16, "isSigned": true})"},
-      {LogicalType::Int(32, true),
+       R"({"Type": "int", "bitWidth": 16, "isSigned": true})"},
+      {LogicalType::intType(32, true),
        "Int(bitWidth=32, isSigned=true)",
-       R"({"Type": "Int", "bitWidth": 32, "isSigned": true})"},
-      {LogicalType::Int(64, true),
+       R"({"Type": "int", "bitWidth": 32, "isSigned": true})"},
+      {LogicalType::intType(64, true),
        "Int(bitWidth=64, isSigned=true)",
-       R"({"Type": "Int", "bitWidth": 64, "isSigned": true})"},
-      {LogicalType::Null(), "Null", R"({"Type": "Null"})"},
-      {LogicalType::JSON(), "JSON", R"({"Type": "JSON"})"},
-      {LogicalType::BSON(), "BSON", R"({"Type": "BSON"})"},
-      {LogicalType::UUID(), "UUID", R"({"Type": "UUID"})"},
-      {LogicalType::None(), "None", R"({"Type": "None"})"},
+       R"({"Type": "int", "bitWidth": 64, "isSigned": true})"},
+      {LogicalType::nullType(), "Null", R"({"Type": "Null"})"},
+      {LogicalType::json(), "JSON", R"({"Type": "JSON"})"},
+      {LogicalType::bson(), "BSON", R"({"Type": "BSON"})"},
+      {LogicalType::uuid(), "UUID", R"({"Type": "UUID"})"},
+      {LogicalType::none(), "None", R"({"Type": "None"})"},
   };
 
   for (const ExpectedRepresentation& c : cases) {
-    ASSERT_STREQ(c.logical_type->ToString().c_str(), c.string_representation);
-    ASSERT_STREQ(c.logical_type->ToJSON().c_str(), c.JSON_representation);
+    ASSERT_STREQ(c.logicalType->toString().c_str(), c.stringRepresentation);
+    ASSERT_STREQ(c.logicalType->toJson().c_str(), c.jsonRepresentation);
   }
 }
 
 TEST(TestLogicalTypeOperation, LogicalTypeSortOrder) {
-  // Ensure that each logical type reports the correct sort order
+  // Ensure that each logical type reports the correct sort order.
 
   struct ExpectedSortOrder {
-    std::shared_ptr<const LogicalType> logical_type;
-    SortOrder::type sort_order;
+    std::shared_ptr<const LogicalType> logicalType;
+    SortOrder::type sortOrder;
   };
 
   std::vector<ExpectedSortOrder> cases = {
-      {LogicalType::String(), SortOrder::UNSIGNED},
-      {LogicalType::Map(), SortOrder::UNKNOWN},
-      {LogicalType::List(), SortOrder::UNKNOWN},
-      {LogicalType::Enum(), SortOrder::UNSIGNED},
-      {LogicalType::Decimal(8, 2), SortOrder::SIGNED},
-      {LogicalType::Date(), SortOrder::SIGNED},
-      {LogicalType::Time(true, LogicalType::TimeUnit::MILLIS),
-       SortOrder::SIGNED},
-      {LogicalType::Time(true, LogicalType::TimeUnit::MICROS),
-       SortOrder::SIGNED},
-      {LogicalType::Time(true, LogicalType::TimeUnit::NANOS),
-       SortOrder::SIGNED},
-      {LogicalType::Time(false, LogicalType::TimeUnit::MILLIS),
-       SortOrder::SIGNED},
-      {LogicalType::Time(false, LogicalType::TimeUnit::MICROS),
-       SortOrder::SIGNED},
-      {LogicalType::Time(false, LogicalType::TimeUnit::NANOS),
-       SortOrder::SIGNED},
-      {LogicalType::Timestamp(true, LogicalType::TimeUnit::MILLIS),
-       SortOrder::SIGNED},
-      {LogicalType::Timestamp(true, LogicalType::TimeUnit::MICROS),
-       SortOrder::SIGNED},
-      {LogicalType::Timestamp(true, LogicalType::TimeUnit::NANOS),
-       SortOrder::SIGNED},
-      {LogicalType::Timestamp(false, LogicalType::TimeUnit::MILLIS),
-       SortOrder::SIGNED},
-      {LogicalType::Timestamp(false, LogicalType::TimeUnit::MICROS),
-       SortOrder::SIGNED},
-      {LogicalType::Timestamp(false, LogicalType::TimeUnit::NANOS),
-       SortOrder::SIGNED},
-      {LogicalType::Interval(), SortOrder::UNKNOWN},
-      {LogicalType::Int(8, false), SortOrder::UNSIGNED},
-      {LogicalType::Int(16, false), SortOrder::UNSIGNED},
-      {LogicalType::Int(32, false), SortOrder::UNSIGNED},
-      {LogicalType::Int(64, false), SortOrder::UNSIGNED},
-      {LogicalType::Int(8, true), SortOrder::SIGNED},
-      {LogicalType::Int(16, true), SortOrder::SIGNED},
-      {LogicalType::Int(32, true), SortOrder::SIGNED},
-      {LogicalType::Int(64, true), SortOrder::SIGNED},
-      {LogicalType::Null(), SortOrder::UNKNOWN},
-      {LogicalType::JSON(), SortOrder::UNSIGNED},
-      {LogicalType::BSON(), SortOrder::UNSIGNED},
-      {LogicalType::UUID(), SortOrder::UNSIGNED},
-      {LogicalType::None(), SortOrder::UNKNOWN}};
+      {LogicalType::string(), SortOrder::kUnsigned},
+      {LogicalType::map(), SortOrder::kUnknown},
+      {LogicalType::list(), SortOrder::kUnknown},
+      {LogicalType::enumType(), SortOrder::kUnsigned},
+      {LogicalType::decimal(8, 2), SortOrder::kSigned},
+      {LogicalType::date(), SortOrder::kSigned},
+      {LogicalType::time(true, LogicalType::TimeUnit::kMillis),
+       SortOrder::kSigned},
+      {LogicalType::time(true, LogicalType::TimeUnit::kMicros),
+       SortOrder::kSigned},
+      {LogicalType::time(true, LogicalType::TimeUnit::kNanos),
+       SortOrder::kSigned},
+      {LogicalType::time(false, LogicalType::TimeUnit::kMillis),
+       SortOrder::kSigned},
+      {LogicalType::time(false, LogicalType::TimeUnit::kMicros),
+       SortOrder::kSigned},
+      {LogicalType::time(false, LogicalType::TimeUnit::kNanos),
+       SortOrder::kSigned},
+      {LogicalType::timestamp(true, LogicalType::TimeUnit::kMillis),
+       SortOrder::kSigned},
+      {LogicalType::timestamp(true, LogicalType::TimeUnit::kMicros),
+       SortOrder::kSigned},
+      {LogicalType::timestamp(true, LogicalType::TimeUnit::kNanos),
+       SortOrder::kSigned},
+      {LogicalType::timestamp(false, LogicalType::TimeUnit::kMillis),
+       SortOrder::kSigned},
+      {LogicalType::timestamp(false, LogicalType::TimeUnit::kMicros),
+       SortOrder::kSigned},
+      {LogicalType::timestamp(false, LogicalType::TimeUnit::kNanos),
+       SortOrder::kSigned},
+      {LogicalType::interval(), SortOrder::kUnknown},
+      {LogicalType::intType(8, false), SortOrder::kUnsigned},
+      {LogicalType::intType(16, false), SortOrder::kUnsigned},
+      {LogicalType::intType(32, false), SortOrder::kUnsigned},
+      {LogicalType::intType(64, false), SortOrder::kUnsigned},
+      {LogicalType::intType(8, true), SortOrder::kSigned},
+      {LogicalType::intType(16, true), SortOrder::kSigned},
+      {LogicalType::intType(32, true), SortOrder::kSigned},
+      {LogicalType::intType(64, true), SortOrder::kSigned},
+      {LogicalType::nullType(), SortOrder::kUnknown},
+      {LogicalType::json(), SortOrder::kUnsigned},
+      {LogicalType::bson(), SortOrder::kUnsigned},
+      {LogicalType::uuid(), SortOrder::kUnsigned},
+      {LogicalType::none(), SortOrder::kUnknown}};
 
   for (const ExpectedSortOrder& c : cases) {
-    ASSERT_EQ(c.logical_type->sort_order(), c.sort_order)
-        << c.logical_type->ToString()
+    ASSERT_EQ(c.logicalType->sortOrder(), c.sortOrder)
+        << c.logicalType->toString()
         << " logical type has incorrect sort order";
   }
 }
 
-static void ConfirmPrimitiveNodeFactoryEquivalence(
-    const std::shared_ptr<const LogicalType>& logical_type,
-    ConvertedType::type converted_type,
-    Type::type physical_type,
-    int physical_length,
+static void confirmPrimitiveNodeFactoryEquivalence(
+    const std::shared_ptr<const LogicalType>& logicalType,
+    ConvertedType::type convertedType,
+    Type::type physicalType,
+    int physicalLength,
     int precision,
     int scale) {
   std::string name = "something";
-  Repetition::type repetition = Repetition::REQUIRED;
-  NodePtr from_converted_type = PrimitiveNode::Make(
+  Repetition::type repetition = Repetition::kRequired;
+  NodePtr fromConvertedType = PrimitiveNode::make(
       name,
       repetition,
-      physical_type,
-      converted_type,
-      physical_length,
+      physicalType,
+      convertedType,
+      physicalLength,
       precision,
       scale);
-  NodePtr from_logical_type = PrimitiveNode::Make(
-      name, repetition, logical_type, physical_type, physical_length);
-  ASSERT_TRUE(from_converted_type->Equals(from_logical_type.get()))
+  NodePtr fromLogicalType = PrimitiveNode::make(
+      name, repetition, logicalType, physicalType, physicalLength);
+  ASSERT_TRUE(fromConvertedType->equals(fromLogicalType.get()))
       << "Primitive node constructed with converted type "
-      << ConvertedTypeToString(converted_type)
+      << convertedTypeToString(convertedType)
       << " unexpectedly not equivalent to primitive node constructed with logical "
          "type "
-      << logical_type->ToString();
+      << logicalType->toString();
   return;
 }
 
-static void ConfirmGroupNodeFactoryEquivalence(
+static void confirmGroupNodeFactoryEquivalence(
     std::string name,
-    const std::shared_ptr<const LogicalType>& logical_type,
-    ConvertedType::type converted_type) {
-  Repetition::type repetition = Repetition::OPTIONAL;
-  NodePtr from_converted_type =
-      GroupNode::Make(name, repetition, {}, converted_type);
-  NodePtr from_logical_type =
-      GroupNode::Make(name, repetition, {}, logical_type);
-  ASSERT_TRUE(from_converted_type->Equals(from_logical_type.get()))
+    const std::shared_ptr<const LogicalType>& logicalType,
+    ConvertedType::type convertedType) {
+  Repetition::type repetition = Repetition::kOptional;
+  NodePtr fromConvertedType =
+      GroupNode::make(name, repetition, {}, convertedType);
+  NodePtr fromLogicalType = GroupNode::make(name, repetition, {}, logicalType);
+  ASSERT_TRUE(fromConvertedType->equals(fromLogicalType.get()))
       << "Group node constructed with converted type "
-      << ConvertedTypeToString(converted_type)
+      << convertedTypeToString(convertedType)
       << " unexpectedly not equivalent to group node constructed with logical type "
-      << logical_type->ToString();
+      << logicalType->toString();
   return;
 }
 
 TEST(TestSchemaNodeCreation, FactoryEquivalence) {
-  // Ensure that the Node factory methods produce equivalent results regardless
-  // of whether they are given a converted type or a logical type.
+  // Ensure that the Node factory methods produce equivalent results regardless.
+  // Of whether they are given a converted type or a logical type.
 
   // Primitive nodes ...
 
   struct PrimitiveNodeFactoryArguments {
-    std::shared_ptr<const LogicalType> logical_type;
-    ConvertedType::type converted_type;
-    Type::type physical_type;
-    int physical_length;
+    std::shared_ptr<const LogicalType> logicalType;
+    ConvertedType::type convertedType;
+    Type::type physicalType;
+    int physicalLength;
     int precision;
     int scale;
   };
 
   std::vector<PrimitiveNodeFactoryArguments> cases = {
-      {LogicalType::String(),
-       ConvertedType::UTF8,
-       Type::BYTE_ARRAY,
+      {LogicalType::string(),
+       ConvertedType::kUtf8,
+       Type::kByteArray,
        -1,
        -1,
        -1},
-      {LogicalType::Enum(), ConvertedType::ENUM, Type::BYTE_ARRAY, -1, -1, -1},
-      {LogicalType::Decimal(16, 6),
-       ConvertedType::DECIMAL,
-       Type::INT64,
+      {LogicalType::enumType(),
+       ConvertedType::kEnum,
+       Type::kByteArray,
+       -1,
+       -1,
+       -1},
+      {LogicalType::decimal(16, 6),
+       ConvertedType::kDecimal,
+       Type::kInt64,
        -1,
        16,
        6},
-      {LogicalType::Date(), ConvertedType::DATE, Type::INT32, -1, -1, -1},
-      {LogicalType::Time(true, LogicalType::TimeUnit::MILLIS),
-       ConvertedType::TIME_MILLIS,
-       Type::INT32,
+      {LogicalType::date(), ConvertedType::kDate, Type::kInt32, -1, -1, -1},
+      {LogicalType::time(true, LogicalType::TimeUnit::kMillis),
+       ConvertedType::kTimeMillis,
+       Type::kInt32,
        -1,
        -1,
        -1},
-      {LogicalType::Time(true, LogicalType::TimeUnit::MICROS),
-       ConvertedType::TIME_MICROS,
-       Type::INT64,
+      {LogicalType::time(true, LogicalType::TimeUnit::kMicros),
+       ConvertedType::kTimeMicros,
+       Type::kInt64,
        -1,
        -1,
        -1},
-      {LogicalType::Timestamp(true, LogicalType::TimeUnit::MILLIS),
-       ConvertedType::TIMESTAMP_MILLIS,
-       Type::INT64,
+      {LogicalType::timestamp(true, LogicalType::TimeUnit::kMillis),
+       ConvertedType::kTimestampMillis,
+       Type::kInt64,
        -1,
        -1,
        -1},
-      {LogicalType::Timestamp(true, LogicalType::TimeUnit::MICROS),
-       ConvertedType::TIMESTAMP_MICROS,
-       Type::INT64,
+      {LogicalType::timestamp(true, LogicalType::TimeUnit::kMicros),
+       ConvertedType::kTimestampMicros,
+       Type::kInt64,
        -1,
        -1,
        -1},
-      {LogicalType::Interval(),
-       ConvertedType::INTERVAL,
-       Type::FIXED_LEN_BYTE_ARRAY,
+      {LogicalType::interval(),
+       ConvertedType::kInterval,
+       Type::kFixedLenByteArray,
        12,
        -1,
        -1},
-      {LogicalType::Int(8, false),
-       ConvertedType::UINT_8,
-       Type::INT32,
+      {LogicalType::intType(8, false),
+       ConvertedType::kUint8,
+       Type::kInt32,
        -1,
        -1,
        -1},
-      {LogicalType::Int(8, true),
-       ConvertedType::INT_8,
-       Type::INT32,
+      {LogicalType::intType(8, true),
+       ConvertedType::kInt8,
+       Type::kInt32,
        -1,
        -1,
        -1},
-      {LogicalType::Int(16, false),
-       ConvertedType::UINT_16,
-       Type::INT32,
+      {LogicalType::intType(16, false),
+       ConvertedType::kUint16,
+       Type::kInt32,
        -1,
        -1,
        -1},
-      {LogicalType::Int(16, true),
-       ConvertedType::INT_16,
-       Type::INT32,
+      {LogicalType::intType(16, true),
+       ConvertedType::kInt16,
+       Type::kInt32,
        -1,
        -1,
        -1},
-      {LogicalType::Int(32, false),
-       ConvertedType::UINT_32,
-       Type::INT32,
+      {LogicalType::intType(32, false),
+       ConvertedType::kUint32,
+       Type::kInt32,
        -1,
        -1,
        -1},
-      {LogicalType::Int(32, true),
-       ConvertedType::INT_32,
-       Type::INT32,
+      {LogicalType::intType(32, true),
+       ConvertedType::kInt32,
+       Type::kInt32,
        -1,
        -1,
        -1},
-      {LogicalType::Int(64, false),
-       ConvertedType::UINT_64,
-       Type::INT64,
+      {LogicalType::intType(64, false),
+       ConvertedType::kUint64,
+       Type::kInt64,
        -1,
        -1,
        -1},
-      {LogicalType::Int(64, true),
-       ConvertedType::INT_64,
-       Type::INT64,
+      {LogicalType::intType(64, true),
+       ConvertedType::kInt64,
+       Type::kInt64,
        -1,
        -1,
        -1},
-      {LogicalType::JSON(), ConvertedType::JSON, Type::BYTE_ARRAY, -1, -1, -1},
-      {LogicalType::BSON(), ConvertedType::BSON, Type::BYTE_ARRAY, -1, -1, -1},
-      {LogicalType::None(), ConvertedType::NONE, Type::INT64, -1, -1, -1}};
+      {LogicalType::json(), ConvertedType::kJson, Type::kByteArray, -1, -1, -1},
+      {LogicalType::bson(), ConvertedType::kBson, Type::kByteArray, -1, -1, -1},
+      {LogicalType::none(), ConvertedType::kNone, Type::kInt64, -1, -1, -1}};
 
   for (const PrimitiveNodeFactoryArguments& c : cases) {
-    ConfirmPrimitiveNodeFactoryEquivalence(
-        c.logical_type,
-        c.converted_type,
-        c.physical_type,
-        c.physical_length,
+    confirmPrimitiveNodeFactoryEquivalence(
+        c.logicalType,
+        c.convertedType,
+        c.physicalType,
+        c.physicalLength,
         c.precision,
         c.scale);
   }
 
   // Group nodes ...
-  ConfirmGroupNodeFactoryEquivalence(
-      "map", LogicalType::Map(), ConvertedType::MAP);
-  ConfirmGroupNodeFactoryEquivalence(
-      "list", LogicalType::List(), ConvertedType::LIST);
+  confirmGroupNodeFactoryEquivalence(
+      "map", LogicalType::map(), ConvertedType::kMap);
+  confirmGroupNodeFactoryEquivalence(
+      "list", LogicalType::list(), ConvertedType::kList);
 }
 
 TEST(TestSchemaNodeCreation, FactoryExceptions) {
-  // Ensure that the Node factory method that accepts a logical type refuses to
-  // create an object if compatibility conditions are not met
+  // Ensure that the Node factory method that accepts a logical type refuses to.
+  // Create an object if compatibility conditions are not met.
 
   // Nested logical type on non-group node ...
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "map", Repetition::REQUIRED, MapLogicalType::Make(), Type::INT64));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::make(
+          "map", Repetition::kRequired, MapLogicalType::make(), Type::kInt64));
   // Incompatible primitive type ...
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "string",
-      Repetition::REQUIRED,
-      StringLogicalType::Make(),
-      Type::BOOLEAN));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::make(
+          "string",
+          Repetition::kRequired,
+          StringLogicalType::make(),
+          Type::kBoolean));
   // Incompatible primitive length ...
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "interval",
-      Repetition::REQUIRED,
-      IntervalLogicalType::Make(),
-      Type::FIXED_LEN_BYTE_ARRAY,
-      11));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::make(
+          "interval",
+          Repetition::kRequired,
+          IntervalLogicalType::make(),
+          Type::kFixedLenByteArray,
+          11));
   // Scale is greater than precision.
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "decimal",
-      Repetition::REQUIRED,
-      DecimalLogicalType::Make(10, 11),
-      Type::INT64));
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "decimal",
-      Repetition::REQUIRED,
-      DecimalLogicalType::Make(17, 18),
-      Type::INT64));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::make(
+          "decimal",
+          Repetition::kRequired,
+          DecimalLogicalType::make(10, 11),
+          Type::kInt64));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::make(
+          "decimal",
+          Repetition::kRequired,
+          DecimalLogicalType::make(17, 18),
+          Type::kInt64));
   // Primitive too small for given precision ...
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "decimal",
-      Repetition::REQUIRED,
-      DecimalLogicalType::Make(16, 6),
-      Type::INT32));
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "decimal",
-      Repetition::REQUIRED,
-      DecimalLogicalType::Make(10, 9),
-      Type::INT32));
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "decimal",
-      Repetition::REQUIRED,
-      DecimalLogicalType::Make(19, 17),
-      Type::INT64));
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "decimal",
-      Repetition::REQUIRED,
-      DecimalLogicalType::Make(308, 6),
-      Type::FIXED_LEN_BYTE_ARRAY,
-      128));
-  // Length is too long
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "decimal",
-      Repetition::REQUIRED,
-      DecimalLogicalType::Make(10, 6),
-      Type::FIXED_LEN_BYTE_ARRAY,
-      891723283));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::make(
+          "decimal",
+          Repetition::kRequired,
+          DecimalLogicalType::make(16, 6),
+          Type::kInt32));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::make(
+          "decimal",
+          Repetition::kRequired,
+          DecimalLogicalType::make(10, 9),
+          Type::kInt32));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::make(
+          "decimal",
+          Repetition::kRequired,
+          DecimalLogicalType::make(19, 17),
+          Type::kInt64));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::make(
+          "decimal",
+          Repetition::kRequired,
+          DecimalLogicalType::make(308, 6),
+          Type::kFixedLenByteArray,
+          128));
+  // Length is too long.
+  ASSERT_ANY_THROW(
+      PrimitiveNode::make(
+          "decimal",
+          Repetition::kRequired,
+          DecimalLogicalType::make(10, 6),
+          Type::kFixedLenByteArray,
+          891723283));
 
   // Incompatible primitive length ...
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "uuid",
-      Repetition::REQUIRED,
-      UUIDLogicalType::Make(),
-      Type::FIXED_LEN_BYTE_ARRAY,
-      64));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::make(
+          "uuid",
+          Repetition::kRequired,
+          UuidLogicalType::make(),
+          Type::kFixedLenByteArray,
+          64));
   // Non-positive length argument for fixed length binary ...
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "negative_length",
-      Repetition::REQUIRED,
-      NoLogicalType::Make(),
-      Type::FIXED_LEN_BYTE_ARRAY,
-      -16));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::make(
+          "negative_length",
+          Repetition::kRequired,
+          NoLogicalType::make(),
+          Type::kFixedLenByteArray,
+          -16));
   // Non-positive length argument for fixed length binary ...
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "zero_length",
-      Repetition::REQUIRED,
-      NoLogicalType::Make(),
-      Type::FIXED_LEN_BYTE_ARRAY,
-      0));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::make(
+          "zero_length",
+          Repetition::kRequired,
+          NoLogicalType::make(),
+          Type::kFixedLenByteArray,
+          0));
   // Non-nested logical type on group node ...
-  ASSERT_ANY_THROW(GroupNode::Make(
-      "list", Repetition::REPEATED, {}, JSONLogicalType::Make()));
+  ASSERT_ANY_THROW(
+      GroupNode::make(
+          "list", Repetition::kRepeated, {}, JsonLogicalType::make()));
 
-  // nullptr logical type arguments convert to NoLogicalType/ConvertedType::NONE
+  // Nullptr logical type arguments convert to
+  // NoLogicalType/ConvertedType::kNone.
   std::shared_ptr<const LogicalType> empty;
-  NodePtr node;
+  NodePtr Node;
   ASSERT_NO_THROW(
-      node = PrimitiveNode::Make(
-          "value", Repetition::REQUIRED, empty, Type::DOUBLE));
-  ASSERT_TRUE(node->logical_type()->is_none());
-  ASSERT_EQ(node->converted_type(), ConvertedType::NONE);
+      Node = PrimitiveNode::make(
+          "value", Repetition::kRequired, empty, Type::kDouble));
+  ASSERT_TRUE(Node->logicalType()->isNone());
+  ASSERT_EQ(Node->convertedType(), ConvertedType::kNone);
   ASSERT_NO_THROW(
-      node = GroupNode::Make("items", Repetition::REPEATED, {}, empty));
-  ASSERT_TRUE(node->logical_type()->is_none());
-  ASSERT_EQ(node->converted_type(), ConvertedType::NONE);
+      Node = GroupNode::make("items", Repetition::kRepeated, {}, empty));
+  ASSERT_TRUE(Node->logicalType()->isNone());
+  ASSERT_EQ(Node->convertedType(), ConvertedType::kNone);
 
   // Invalid ConvertedType in deserialized element ...
-  node = PrimitiveNode::Make(
+  Node = PrimitiveNode::make(
       "string",
-      Repetition::REQUIRED,
-      StringLogicalType::Make(),
-      Type::BYTE_ARRAY);
-  ASSERT_EQ(node->logical_type()->type(), LogicalType::Type::STRING);
-  ASSERT_TRUE(node->logical_type()->is_valid());
-  ASSERT_TRUE(node->logical_type()->is_serialized());
-  facebook::velox::parquet::thrift::SchemaElement string_intermediary;
-  node->ToParquet(&string_intermediary);
-  // ... corrupt the Thrift intermediary ....
-  string_intermediary.logicalType.__isset.STRING = false;
-  ASSERT_ANY_THROW(node = PrimitiveNode::FromParquet(&string_intermediary));
+      Repetition::kRequired,
+      StringLogicalType::make(),
+      Type::kByteArray);
+  ASSERT_EQ(Node->logicalType()->type(), LogicalType::Type::kString);
+  ASSERT_TRUE(Node->logicalType()->isValid());
+  ASSERT_TRUE(Node->logicalType()->isSerialized());
+  facebook::velox::parquet::thrift::SchemaElement stringIntermediary;
+  Node->toParquet(&stringIntermediary);
+  // ... Corrupt the Thrift intermediary ....
+  stringIntermediary.logicalType.__isset.STRING = false;
+  ASSERT_ANY_THROW(Node = PrimitiveNode::fromParquet(&stringIntermediary));
 
   // Invalid TimeUnit in deserialized TimeLogicalType ...
-  node = PrimitiveNode::Make(
+  Node = PrimitiveNode::make(
       "time",
-      Repetition::REQUIRED,
-      TimeLogicalType::Make(true, LogicalType::TimeUnit::NANOS),
-      Type::INT64);
-  facebook::velox::parquet::thrift::SchemaElement time_intermediary;
-  node->ToParquet(&time_intermediary);
-  // ... corrupt the Thrift intermediary ....
-  time_intermediary.logicalType.TIME.unit.__isset.NANOS = false;
-  ASSERT_ANY_THROW(PrimitiveNode::FromParquet(&time_intermediary));
+      Repetition::kRequired,
+      TimeLogicalType::make(true, LogicalType::TimeUnit::kNanos),
+      Type::kInt64);
+  facebook::velox::parquet::thrift::SchemaElement timeIntermediary;
+  Node->toParquet(&timeIntermediary);
+  // ... Corrupt the Thrift intermediary ....
+  timeIntermediary.logicalType.TIME.unit.__isset.NANOS = false;
+  ASSERT_ANY_THROW(PrimitiveNode::fromParquet(&timeIntermediary));
 
   // Invalid TimeUnit in deserialized TimestampLogicalType ...
-  node = PrimitiveNode::Make(
+  Node = PrimitiveNode::make(
       "timestamp",
-      Repetition::REQUIRED,
-      TimestampLogicalType::Make(true, LogicalType::TimeUnit::NANOS),
-      Type::INT64);
-  facebook::velox::parquet::thrift::SchemaElement timestamp_intermediary;
-  node->ToParquet(&timestamp_intermediary);
-  // ... corrupt the Thrift intermediary ....
-  timestamp_intermediary.logicalType.TIMESTAMP.unit.__isset.NANOS = false;
-  ASSERT_ANY_THROW(PrimitiveNode::FromParquet(&timestamp_intermediary));
+      Repetition::kRequired,
+      TimestampLogicalType::make(true, LogicalType::TimeUnit::kNanos),
+      Type::kInt64);
+  facebook::velox::parquet::thrift::SchemaElement timestampIntermediary;
+  Node->toParquet(&timestampIntermediary);
+  // ... Corrupt the Thrift intermediary ....
+  timestampIntermediary.logicalType.TIMESTAMP.unit.__isset.NANOS = false;
+  ASSERT_ANY_THROW(PrimitiveNode::fromParquet(&timestampIntermediary));
 }
 
 struct SchemaElementConstructionArguments {
+  SchemaElementConstructionArguments(
+      std::string name,
+      std::shared_ptr<const LogicalType> logicalType,
+      Type::type physicalType,
+      int physicalLength,
+      bool expectConvertedType,
+      ConvertedType::type convertedType,
+      bool expectLogicaltype,
+      std::function<bool()> checkLogicaltype)
+      : name(std::move(name)),
+        logicalType(std::move(logicalType)),
+        physicalType(physicalType),
+        physicalLength(physicalLength),
+        expectConvertedType(expectConvertedType),
+        convertedType(convertedType),
+        expectLogicaltype(expectLogicaltype),
+        checkLogicaltype(std::move(checkLogicaltype)) {}
+
   std::string name;
-  std::shared_ptr<const LogicalType> logical_type;
-  Type::type physical_type;
-  int physical_length;
-  bool expect_converted_type;
-  ConvertedType::type converted_type;
-  bool expect_logicalType;
-  std::function<bool()> check_logicalType;
+  std::shared_ptr<const LogicalType> logicalType;
+  Type::type physicalType;
+  int physicalLength;
+  bool expectConvertedType;
+  ConvertedType::type convertedType;
+  bool expectLogicaltype;
+  std::function<bool()> checkLogicaltype;
 };
 
 struct LegacySchemaElementConstructionArguments {
   std::string name;
-  Type::type physical_type;
-  int physical_length;
-  bool expect_converted_type;
-  ConvertedType::type converted_type;
-  bool expect_logicalType;
-  std::function<bool()> check_logicalType;
+  Type::type physicalType;
+  int physicalLength;
+  bool expectConvertedType;
+  ConvertedType::type convertedType;
+  bool expectLogicaltype;
+  std::function<bool()> checkLogicaltype;
 };
 
 class TestSchemaElementConstruction : public ::testing::Test {
  public:
-  TestSchemaElementConstruction* Reconstruct(
+  TestSchemaElementConstruction* reconstruct(
       const SchemaElementConstructionArguments& c) {
     // Make node, create serializable Thrift object from it ...
-    node_ = PrimitiveNode::Make(
+    node_ = PrimitiveNode::make(
         c.name,
-        Repetition::REQUIRED,
-        c.logical_type,
-        c.physical_type,
-        c.physical_length);
+        Repetition::kRequired,
+        c.logicalType,
+        c.physicalType,
+        c.physicalLength);
     element_.reset(new facebook::velox::parquet::thrift::SchemaElement);
-    node_->ToParquet(element_.get());
+    node_->toParquet(element_.get());
 
-    // ... then set aside some values for later inspection.
+    // ... Then set aside some values for later inspection.
     name_ = c.name;
-    expect_converted_type_ = c.expect_converted_type;
-    converted_type_ = c.converted_type;
-    expect_logicalType_ = c.expect_logicalType;
-    check_logicalType_ = c.check_logicalType;
+    expectConvertedType_ = c.expectConvertedType;
+    convertedType_ = c.convertedType;
+    expectLogicaltype_ = c.expectLogicaltype;
+    checkLogicaltype_ = c.checkLogicaltype;
     return this;
   }
 
-  TestSchemaElementConstruction* LegacyReconstruct(
+  TestSchemaElementConstruction* legacyReconstruct(
       const LegacySchemaElementConstructionArguments& c) {
     // Make node, create serializable Thrift object from it ...
-    node_ = PrimitiveNode::Make(
+    node_ = PrimitiveNode::make(
         c.name,
-        Repetition::REQUIRED,
-        c.physical_type,
-        c.converted_type,
-        c.physical_length);
+        Repetition::kRequired,
+        c.physicalType,
+        c.convertedType,
+        c.physicalLength);
     element_.reset(new facebook::velox::parquet::thrift::SchemaElement);
-    node_->ToParquet(element_.get());
+    node_->toParquet(element_.get());
 
-    // ... then set aside some values for later inspection.
+    // ... Then set aside some values for later inspection.
     name_ = c.name;
-    expect_converted_type_ = c.expect_converted_type;
-    converted_type_ = c.converted_type;
-    expect_logicalType_ = c.expect_logicalType;
-    check_logicalType_ = c.check_logicalType;
+    expectConvertedType_ = c.expectConvertedType;
+    convertedType_ = c.convertedType;
+    expectLogicaltype_ = c.expectLogicaltype;
+    checkLogicaltype_ = c.checkLogicaltype;
     return this;
   }
 
-  void Inspect() {
+  void inspect() {
     ASSERT_EQ(element_->name, name_);
-    if (expect_converted_type_) {
+    if (expectConvertedType_) {
       ASSERT_TRUE(element_->__isset.converted_type)
-          << node_->logical_type()->ToString()
+          << node_->logicalType()->toString()
           << " logical type unexpectedly failed to generate a converted type in the "
              "Thrift "
              "intermediate object";
-      ASSERT_EQ(element_->converted_type, ToThrift(converted_type_))
-          << node_->logical_type()->ToString()
+      ASSERT_EQ(element_->converted_type, toThrift(convertedType_))
+          << node_->logicalType()->toString()
           << " logical type unexpectedly failed to generate correct converted type in "
              "the "
              "Thrift intermediate object";
     } else {
       ASSERT_FALSE(element_->__isset.converted_type)
-          << node_->logical_type()->ToString()
+          << node_->logicalType()->toString()
           << " logical type unexpectedly generated a converted type in the Thrift "
              "intermediate object";
     }
-    if (expect_logicalType_) {
+    if (expectLogicaltype_) {
       ASSERT_TRUE(element_->__isset.logicalType)
-          << node_->logical_type()->ToString()
+          << node_->logicalType()->toString()
           << " logical type unexpectedly failed to genverate a logicalType in the Thrift "
              "intermediate object";
-      ASSERT_TRUE(check_logicalType_())
-          << node_->logical_type()->ToString()
+      ASSERT_TRUE(checkLogicaltype_())
+          << node_->logicalType()->toString()
           << " logical type generated incorrect logicalType "
              "settings in the Thrift intermediate object";
     } else {
       ASSERT_FALSE(element_->__isset.logicalType)
-          << node_->logical_type()->ToString()
+          << node_->logicalType()->toString()
           << " logical type unexpectedly generated a logicalType in the Thrift "
              "intermediate object";
     }
@@ -2299,13 +2322,13 @@ class TestSchemaElementConstruction : public ::testing::Test {
   NodePtr node_;
   std::unique_ptr<facebook::velox::parquet::thrift::SchemaElement> element_;
   std::string name_;
-  bool expect_converted_type_;
+  bool expectConvertedType_;
   ConvertedType::type
-      converted_type_; // expected converted type in Thrift object
-  bool expect_logicalType_;
+      convertedType_; // expected converted type in Thrift object
+  bool expectLogicaltype_;
   std::function<bool()>
-      check_logicalType_; // specialized (by logical type)
-                          // logicalType check for Thrift object
+      checkLogicaltype_; // specialized (by logical type)
+                         // LogicalType check for Thrift object.
 };
 
 /*
@@ -2316,125 +2339,125 @@ class TestSchemaElementConstruction : public ::testing::Test {
  */
 
 TEST_F(TestSchemaElementConstruction, SimpleCases) {
-  auto check_nothing = []() {
+  auto checkNothing = []() {
     return true;
   }; // used for logical types that don't expect a logicalType to be set
 
   std::vector<SchemaElementConstructionArguments> cases = {
       {"string",
-       LogicalType::String(),
-       Type::BYTE_ARRAY,
+       LogicalType::string(),
+       Type::kByteArray,
        -1,
        true,
-       ConvertedType::UTF8,
+       ConvertedType::kUtf8,
        true,
        [this]() { return element_->logicalType.__isset.STRING; }},
       {"enum",
-       LogicalType::Enum(),
-       Type::BYTE_ARRAY,
+       LogicalType::enumType(),
+       Type::kByteArray,
        -1,
        true,
-       ConvertedType::ENUM,
+       ConvertedType::kEnum,
        true,
        [this]() { return element_->logicalType.__isset.ENUM; }},
       {"date",
-       LogicalType::Date(),
-       Type::INT32,
+       LogicalType::date(),
+       Type::kInt32,
        -1,
        true,
-       ConvertedType::DATE,
+       ConvertedType::kDate,
        true,
        [this]() { return element_->logicalType.__isset.DATE; }},
       {"interval",
-       LogicalType::Interval(),
-       Type::FIXED_LEN_BYTE_ARRAY,
+       LogicalType::interval(),
+       Type::kFixedLenByteArray,
        12,
        true,
-       ConvertedType::INTERVAL,
+       ConvertedType::kInterval,
        false,
-       check_nothing},
+       checkNothing},
       {"null",
-       LogicalType::Null(),
-       Type::DOUBLE,
+       LogicalType::nullType(),
+       Type::kDouble,
        -1,
        false,
-       ConvertedType::NA,
+       ConvertedType::kNa,
        true,
        [this]() { return element_->logicalType.__isset.UNKNOWN; }},
       {"json",
-       LogicalType::JSON(),
-       Type::BYTE_ARRAY,
+       LogicalType::json(),
+       Type::kByteArray,
        -1,
        true,
-       ConvertedType::JSON,
+       ConvertedType::kJson,
        true,
        [this]() { return element_->logicalType.__isset.JSON; }},
       {"bson",
-       LogicalType::BSON(),
-       Type::BYTE_ARRAY,
+       LogicalType::bson(),
+       Type::kByteArray,
        -1,
        true,
-       ConvertedType::BSON,
+       ConvertedType::kBson,
        true,
        [this]() { return element_->logicalType.__isset.BSON; }},
       {"uuid",
-       LogicalType::UUID(),
-       Type::FIXED_LEN_BYTE_ARRAY,
+       LogicalType::uuid(),
+       Type::kFixedLenByteArray,
        16,
        false,
-       ConvertedType::NA,
+       ConvertedType::kNa,
        true,
        [this]() { return element_->logicalType.__isset.UUID; }},
       {"none",
-       LogicalType::None(),
-       Type::INT64,
+       LogicalType::none(),
+       Type::kInt64,
        -1,
        false,
-       ConvertedType::NA,
+       ConvertedType::kNa,
        false,
-       check_nothing}};
+       checkNothing}};
 
   for (const SchemaElementConstructionArguments& c : cases) {
-    this->Reconstruct(c)->Inspect();
+    this->reconstruct(c)->inspect();
   }
 
-  std::vector<LegacySchemaElementConstructionArguments> legacy_cases = {
+  std::vector<LegacySchemaElementConstructionArguments> legacyCases = {
       {"timestamp_ms",
-       Type::INT64,
+       Type::kInt64,
        -1,
        true,
-       ConvertedType::TIMESTAMP_MILLIS,
+       ConvertedType::kTimestampMillis,
        false,
-       check_nothing},
+       checkNothing},
       {"timestamp_us",
-       Type::INT64,
+       Type::kInt64,
        -1,
        true,
-       ConvertedType::TIMESTAMP_MICROS,
+       ConvertedType::kTimestampMicros,
        false,
-       check_nothing},
+       checkNothing},
   };
 
-  for (const LegacySchemaElementConstructionArguments& c : legacy_cases) {
-    this->LegacyReconstruct(c)->Inspect();
+  for (const LegacySchemaElementConstructionArguments& c : legacyCases) {
+    this->legacyReconstruct(c)->inspect();
   }
 }
 
 class TestDecimalSchemaElementConstruction
     : public TestSchemaElementConstruction {
  public:
-  TestDecimalSchemaElementConstruction* Reconstruct(
+  TestDecimalSchemaElementConstruction* reconstruct(
       const SchemaElementConstructionArguments& c) {
-    TestSchemaElementConstruction::Reconstruct(c);
-    const auto& decimal_logical_type =
-        checked_cast<const DecimalLogicalType&>(*c.logical_type);
-    precision_ = decimal_logical_type.precision();
-    scale_ = decimal_logical_type.scale();
+    TestSchemaElementConstruction::reconstruct(c);
+    const auto& decimalLogicalType =
+        checked_cast<const DecimalLogicalType&>(*c.logicalType);
+    precision_ = decimalLogicalType.precision();
+    scale_ = decimalLogicalType.scale();
     return this;
   }
 
-  void Inspect() {
-    TestSchemaElementConstruction::Inspect();
+  void inspect() {
+    TestSchemaElementConstruction::inspect();
     ASSERT_EQ(element_->precision, precision_);
     ASSERT_EQ(element_->scale, scale_);
     ASSERT_EQ(element_->logicalType.DECIMAL.precision, precision_);
@@ -2448,87 +2471,87 @@ class TestDecimalSchemaElementConstruction
 };
 
 TEST_F(TestDecimalSchemaElementConstruction, DecimalCases) {
-  auto check_DECIMAL = [this]() {
+  auto checkDecimal = [this]() {
     return element_->logicalType.__isset.DECIMAL;
   };
 
   std::vector<SchemaElementConstructionArguments> cases = {
       {"decimal",
-       LogicalType::Decimal(16, 6),
-       Type::INT64,
+       LogicalType::decimal(16, 6),
+       Type::kInt64,
        -1,
        true,
-       ConvertedType::DECIMAL,
+       ConvertedType::kDecimal,
        true,
-       check_DECIMAL},
+       checkDecimal},
       {"decimal",
-       LogicalType::Decimal(1, 0),
-       Type::INT32,
+       LogicalType::decimal(1, 0),
+       Type::kInt32,
        -1,
        true,
-       ConvertedType::DECIMAL,
+       ConvertedType::kDecimal,
        true,
-       check_DECIMAL},
+       checkDecimal},
       {"decimal",
-       LogicalType::Decimal(10),
-       Type::INT64,
+       LogicalType::decimal(10),
+       Type::kInt64,
        -1,
        true,
-       ConvertedType::DECIMAL,
+       ConvertedType::kDecimal,
        true,
-       check_DECIMAL},
+       checkDecimal},
       {"decimal",
-       LogicalType::Decimal(11, 11),
-       Type::INT64,
+       LogicalType::decimal(11, 11),
+       Type::kInt64,
        -1,
        true,
-       ConvertedType::DECIMAL,
+       ConvertedType::kDecimal,
        true,
-       check_DECIMAL},
+       checkDecimal},
       {"decimal",
-       LogicalType::Decimal(9, 9),
-       Type::INT32,
+       LogicalType::decimal(9, 9),
+       Type::kInt32,
        -1,
        true,
-       ConvertedType::DECIMAL,
+       ConvertedType::kDecimal,
        true,
-       check_DECIMAL},
+       checkDecimal},
       {"decimal",
-       LogicalType::Decimal(18, 18),
-       Type::INT64,
+       LogicalType::decimal(18, 18),
+       Type::kInt64,
        -1,
        true,
-       ConvertedType::DECIMAL,
+       ConvertedType::kDecimal,
        true,
-       check_DECIMAL},
+       checkDecimal},
       {"decimal",
-       LogicalType::Decimal(307, 7),
-       Type::FIXED_LEN_BYTE_ARRAY,
+       LogicalType::decimal(307, 7),
+       Type::kFixedLenByteArray,
        128,
        true,
-       ConvertedType::DECIMAL,
+       ConvertedType::kDecimal,
        true,
-       check_DECIMAL},
+       checkDecimal},
       {"decimal",
-       LogicalType::Decimal(310, 32),
-       Type::FIXED_LEN_BYTE_ARRAY,
+       LogicalType::decimal(310, 32),
+       Type::kFixedLenByteArray,
        129,
        true,
-       ConvertedType::DECIMAL,
+       ConvertedType::kDecimal,
        true,
-       check_DECIMAL},
+       checkDecimal},
       {"decimal",
-       LogicalType::Decimal(2147483645, 2147483645),
-       Type::FIXED_LEN_BYTE_ARRAY,
+       LogicalType::decimal(2147483645, 2147483645),
+       Type::kFixedLenByteArray,
        891723282,
        true,
-       ConvertedType::DECIMAL,
+       ConvertedType::kDecimal,
        true,
-       check_DECIMAL},
+       checkDecimal},
   };
 
   for (const SchemaElementConstructionArguments& c : cases) {
-    this->Reconstruct(c)->Inspect();
+    this->reconstruct(c)->inspect();
   }
 }
 
@@ -2536,42 +2559,42 @@ class TestTemporalSchemaElementConstruction
     : public TestSchemaElementConstruction {
  public:
   template <typename T>
-  TestTemporalSchemaElementConstruction* Reconstruct(
+  TestTemporalSchemaElementConstruction* reconstruct(
       const SchemaElementConstructionArguments& c) {
-    TestSchemaElementConstruction::Reconstruct(c);
-    const auto& t = checked_cast<const T&>(*c.logical_type);
-    adjusted_ = t.is_adjusted_to_utc();
-    unit_ = t.time_unit();
+    TestSchemaElementConstruction::reconstruct(c);
+    const auto& t = checked_cast<const T&>(*c.logicalType);
+    adjusted_ = t.isAdjustedToUtc();
+    unit_ = t.timeUnit();
     return this;
   }
 
   template <typename T>
-  void Inspect() {
+  void inspect() {
     FAIL() << "Invalid typename specified in test suite";
     return;
   }
 
  protected:
   bool adjusted_;
-  LogicalType::TimeUnit::unit unit_;
+  LogicalType::TimeUnit::Unit unit_;
 };
 
 template <>
-void TestTemporalSchemaElementConstruction::Inspect<
+void TestTemporalSchemaElementConstruction::inspect<
     facebook::velox::parquet::thrift::TimeType>() {
-  TestSchemaElementConstruction::Inspect();
+  TestSchemaElementConstruction::inspect();
   ASSERT_EQ(element_->logicalType.TIME.isAdjustedToUTC, adjusted_);
   switch (unit_) {
-    case LogicalType::TimeUnit::MILLIS:
+    case LogicalType::TimeUnit::kMillis:
       ASSERT_TRUE(element_->logicalType.TIME.unit.__isset.MILLIS);
       break;
-    case LogicalType::TimeUnit::MICROS:
+    case LogicalType::TimeUnit::kMicros:
       ASSERT_TRUE(element_->logicalType.TIME.unit.__isset.MICROS);
       break;
-    case LogicalType::TimeUnit::NANOS:
+    case LogicalType::TimeUnit::kNanos:
       ASSERT_TRUE(element_->logicalType.TIME.unit.__isset.NANOS);
       break;
-    case LogicalType::TimeUnit::UNKNOWN:
+    case LogicalType::TimeUnit::kUnknown:
     default:
       FAIL() << "Invalid time unit in test case";
   }
@@ -2579,21 +2602,21 @@ void TestTemporalSchemaElementConstruction::Inspect<
 }
 
 template <>
-void TestTemporalSchemaElementConstruction::Inspect<
+void TestTemporalSchemaElementConstruction::inspect<
     facebook::velox::parquet::thrift::TimestampType>() {
-  TestSchemaElementConstruction::Inspect();
+  TestSchemaElementConstruction::inspect();
   ASSERT_EQ(element_->logicalType.TIMESTAMP.isAdjustedToUTC, adjusted_);
   switch (unit_) {
-    case LogicalType::TimeUnit::MILLIS:
+    case LogicalType::TimeUnit::kMillis:
       ASSERT_TRUE(element_->logicalType.TIMESTAMP.unit.__isset.MILLIS);
       break;
-    case LogicalType::TimeUnit::MICROS:
+    case LogicalType::TimeUnit::kMicros:
       ASSERT_TRUE(element_->logicalType.TIMESTAMP.unit.__isset.MICROS);
       break;
-    case LogicalType::TimeUnit::NANOS:
+    case LogicalType::TimeUnit::kNanos:
       ASSERT_TRUE(element_->logicalType.TIMESTAMP.unit.__isset.NANOS);
       break;
-    case LogicalType::TimeUnit::UNKNOWN:
+    case LogicalType::TimeUnit::kUnknown:
     default:
       FAIL() << "Invalid time unit in test case";
   }
@@ -2601,164 +2624,158 @@ void TestTemporalSchemaElementConstruction::Inspect<
 }
 
 TEST_F(TestTemporalSchemaElementConstruction, TemporalCases) {
-  auto check_TIME = [this]() { return element_->logicalType.__isset.TIME; };
+  auto checkTime = [this]() { return element_->logicalType.__isset.TIME; };
 
-  std::vector<SchemaElementConstructionArguments> time_cases = {
+  std::vector<SchemaElementConstructionArguments> timeCases = {
       {"time_T_ms",
-       LogicalType::Time(true, LogicalType::TimeUnit::MILLIS),
-       Type::INT32,
+       LogicalType::time(true, LogicalType::TimeUnit::kMillis),
+       Type::kInt32,
        -1,
        true,
-       ConvertedType::TIME_MILLIS,
+       ConvertedType::kTimeMillis,
        true,
-       check_TIME},
+       checkTime},
       {"time_F_ms",
-       LogicalType::Time(false, LogicalType::TimeUnit::MILLIS),
-       Type::INT32,
+       LogicalType::time(false, LogicalType::TimeUnit::kMillis),
+       Type::kInt32,
        -1,
        false,
-       ConvertedType::NA,
+       ConvertedType::kNa,
        true,
-       check_TIME},
+       checkTime},
       {"time_T_us",
-       LogicalType::Time(true, LogicalType::TimeUnit::MICROS),
-       Type::INT64,
+       LogicalType::time(true, LogicalType::TimeUnit::kMicros),
+       Type::kInt64,
        -1,
        true,
-       ConvertedType::TIME_MICROS,
+       ConvertedType::kTimeMicros,
        true,
-       check_TIME},
+       checkTime},
       {"time_F_us",
-       LogicalType::Time(false, LogicalType::TimeUnit::MICROS),
-       Type::INT64,
+       LogicalType::time(false, LogicalType::TimeUnit::kMicros),
+       Type::kInt64,
        -1,
        false,
-       ConvertedType::NA,
+       ConvertedType::kNa,
        true,
-       check_TIME},
+       checkTime},
       {"time_T_ns",
-       LogicalType::Time(true, LogicalType::TimeUnit::NANOS),
-       Type::INT64,
+       LogicalType::time(true, LogicalType::TimeUnit::kNanos),
+       Type::kInt64,
        -1,
        false,
-       ConvertedType::NA,
+       ConvertedType::kNa,
        true,
-       check_TIME},
+       checkTime},
       {"time_F_ns",
-       LogicalType::Time(false, LogicalType::TimeUnit::NANOS),
-       Type::INT64,
+       LogicalType::time(false, LogicalType::TimeUnit::kNanos),
+       Type::kInt64,
        -1,
        false,
-       ConvertedType::NA,
+       ConvertedType::kNa,
        true,
-       check_TIME},
+       checkTime},
   };
 
-  for (const SchemaElementConstructionArguments& c : time_cases) {
-    this->Reconstruct<TimeLogicalType>(c)
-        ->Inspect<facebook::velox::parquet::thrift::TimeType>();
+  for (const SchemaElementConstructionArguments& c : timeCases) {
+    this->reconstruct<TimeLogicalType>(c)
+        ->inspect<facebook::velox::parquet::thrift::TimeType>();
   }
 
-  auto check_TIMESTAMP = [this]() {
+  auto checkTimestamp = [this]() {
     return element_->logicalType.__isset.TIMESTAMP;
   };
 
-  std::vector<SchemaElementConstructionArguments> timestamp_cases = {
+  std::vector<SchemaElementConstructionArguments> timestampCases = {
       {"timestamp_T_ms",
-       LogicalType::Timestamp(true, LogicalType::TimeUnit::MILLIS),
-       Type::INT64,
+       LogicalType::timestamp(true, LogicalType::TimeUnit::kMillis),
+       Type::kInt64,
        -1,
        true,
-       ConvertedType::TIMESTAMP_MILLIS,
+       ConvertedType::kTimestampMillis,
        true,
-       check_TIMESTAMP},
+       checkTimestamp},
       {"timestamp_F_ms",
-       LogicalType::Timestamp(false, LogicalType::TimeUnit::MILLIS),
-       Type::INT64,
+       LogicalType::timestamp(false, LogicalType::TimeUnit::kMillis),
+       Type::kInt64,
        -1,
        false,
-       ConvertedType::NA,
+       ConvertedType::kNa,
        true,
-       check_TIMESTAMP},
+       checkTimestamp},
       {"timestamp_F_ms_force",
-       LogicalType::Timestamp(
-           false,
-           LogicalType::TimeUnit::MILLIS,
-           /*is_from_converted_type=*/false,
-           /*force_set_converted_type=*/true),
-       Type::INT64,
+       LogicalType::timestamp(
+           false, LogicalType::TimeUnit::kMillis, false, true),
+       Type::kInt64,
        -1,
        true,
-       ConvertedType::TIMESTAMP_MILLIS,
+       ConvertedType::kTimestampMillis,
        true,
-       check_TIMESTAMP},
+       checkTimestamp},
       {"timestamp_T_us",
-       LogicalType::Timestamp(true, LogicalType::TimeUnit::MICROS),
-       Type::INT64,
+       LogicalType::timestamp(true, LogicalType::TimeUnit::kMicros),
+       Type::kInt64,
        -1,
        true,
-       ConvertedType::TIMESTAMP_MICROS,
+       ConvertedType::kTimestampMicros,
        true,
-       check_TIMESTAMP},
+       checkTimestamp},
       {"timestamp_F_us",
-       LogicalType::Timestamp(false, LogicalType::TimeUnit::MICROS),
-       Type::INT64,
+       LogicalType::timestamp(false, LogicalType::TimeUnit::kMicros),
+       Type::kInt64,
        -1,
        false,
-       ConvertedType::NA,
+       ConvertedType::kNa,
        true,
-       check_TIMESTAMP},
+       checkTimestamp},
       {"timestamp_F_us_force",
-       LogicalType::Timestamp(
-           false,
-           LogicalType::TimeUnit::MILLIS,
-           /*is_from_converted_type=*/false,
-           /*force_set_converted_type=*/true),
-       Type::INT64,
+       LogicalType::timestamp(
+           false, LogicalType::TimeUnit::kMillis, false, true),
+       Type::kInt64,
        -1,
        true,
-       ConvertedType::TIMESTAMP_MILLIS,
+       ConvertedType::kTimestampMillis,
        true,
-       check_TIMESTAMP},
+       checkTimestamp},
       {"timestamp_T_ns",
-       LogicalType::Timestamp(true, LogicalType::TimeUnit::NANOS),
-       Type::INT64,
+       LogicalType::timestamp(true, LogicalType::TimeUnit::kNanos),
+       Type::kInt64,
        -1,
        false,
-       ConvertedType::NA,
+       ConvertedType::kNa,
        true,
-       check_TIMESTAMP},
+       checkTimestamp},
       {"timestamp_F_ns",
-       LogicalType::Timestamp(false, LogicalType::TimeUnit::NANOS),
-       Type::INT64,
+       LogicalType::timestamp(false, LogicalType::TimeUnit::kNanos),
+       Type::kInt64,
        -1,
        false,
-       ConvertedType::NA,
+       ConvertedType::kNa,
        true,
-       check_TIMESTAMP},
+       checkTimestamp},
   };
 
-  for (const SchemaElementConstructionArguments& c : timestamp_cases) {
-    this->Reconstruct<TimestampLogicalType>(c)
-        ->Inspect<facebook::velox::parquet::thrift::TimestampType>();
+  for (const SchemaElementConstructionArguments& c : timestampCases) {
+    this->reconstruct<TimestampLogicalType>(c)
+        ->inspect<facebook::velox::parquet::thrift::TimestampType>();
   }
 }
 
 class TestIntegerSchemaElementConstruction
     : public TestSchemaElementConstruction {
  public:
-  TestIntegerSchemaElementConstruction* Reconstruct(
+  TestIntegerSchemaElementConstruction* reconstruct(
       const SchemaElementConstructionArguments& c) {
-    TestSchemaElementConstruction::Reconstruct(c);
-    const auto& int_logical_type =
-        checked_cast<const IntLogicalType&>(*c.logical_type);
-    width_ = int_logical_type.bit_width();
-    signed_ = int_logical_type.is_signed();
+    TestSchemaElementConstruction::reconstruct(c);
+    const auto& intLogicalType =
+        checked_cast<const IntLogicalType&>(*c.logicalType);
+    width_ = intLogicalType.bitWidth();
+    signed_ = intLogicalType.isSigned();
     return this;
   }
 
-  void Inspect() {
-    TestSchemaElementConstruction::Inspect();
+  void inspect() {
+    TestSchemaElementConstruction::inspect();
     ASSERT_EQ(element_->logicalType.INTEGER.bitWidth, width_);
     ASSERT_EQ(element_->logicalType.INTEGER.isSigned, signed_);
     return;
@@ -2770,221 +2787,229 @@ class TestIntegerSchemaElementConstruction
 };
 
 TEST_F(TestIntegerSchemaElementConstruction, IntegerCases) {
-  auto check_INTEGER = [this]() {
+  auto checkInteger = [this]() {
     return element_->logicalType.__isset.INTEGER;
   };
 
   std::vector<SchemaElementConstructionArguments> cases = {
       {"uint8",
-       LogicalType::Int(8, false),
-       Type::INT32,
+       LogicalType::intType(8, false),
+       Type::kInt32,
        -1,
        true,
-       ConvertedType::UINT_8,
+       ConvertedType::kUint8,
        true,
-       check_INTEGER},
+       checkInteger},
       {"uint16",
-       LogicalType::Int(16, false),
-       Type::INT32,
+       LogicalType::intType(16, false),
+       Type::kInt32,
        -1,
        true,
-       ConvertedType::UINT_16,
+       ConvertedType::kUint16,
        true,
-       check_INTEGER},
+       checkInteger},
       {"uint32",
-       LogicalType::Int(32, false),
-       Type::INT32,
+       LogicalType::intType(32, false),
+       Type::kInt32,
        -1,
        true,
-       ConvertedType::UINT_32,
+       ConvertedType::kUint32,
        true,
-       check_INTEGER},
+       checkInteger},
       {"uint64",
-       LogicalType::Int(64, false),
-       Type::INT64,
+       LogicalType::intType(64, false),
+       Type::kInt64,
        -1,
        true,
-       ConvertedType::UINT_64,
+       ConvertedType::kUint64,
        true,
-       check_INTEGER},
+       checkInteger},
       {"int8",
-       LogicalType::Int(8, true),
-       Type::INT32,
+       LogicalType::intType(8, true),
+       Type::kInt32,
        -1,
        true,
-       ConvertedType::INT_8,
+       ConvertedType::kInt8,
        true,
-       check_INTEGER},
+       checkInteger},
       {"int16",
-       LogicalType::Int(16, true),
-       Type::INT32,
+       LogicalType::intType(16, true),
+       Type::kInt32,
        -1,
        true,
-       ConvertedType::INT_16,
+       ConvertedType::kInt16,
        true,
-       check_INTEGER},
+       checkInteger},
       {"int32",
-       LogicalType::Int(32, true),
-       Type::INT32,
+       LogicalType::intType(32, true),
+       Type::kInt32,
        -1,
        true,
-       ConvertedType::INT_32,
+       ConvertedType::kInt32,
        true,
-       check_INTEGER},
+       checkInteger},
       {"int64",
-       LogicalType::Int(64, true),
-       Type::INT64,
+       LogicalType::intType(64, true),
+       Type::kInt64,
        -1,
        true,
-       ConvertedType::INT_64,
+       ConvertedType::kInt64,
        true,
-       check_INTEGER},
+       checkInteger},
   };
 
   for (const SchemaElementConstructionArguments& c : cases) {
-    this->Reconstruct(c)->Inspect();
+    this->reconstruct(c)->inspect();
   }
 }
 
 TEST(TestLogicalTypeSerialization, SchemaElementNestedCases) {
-  // Confirm that the intermediate Thrift objects created during node
-  // serialization contain correct ConvertedType and ConvertedType information
+  // Confirm that the intermediate Thrift objects created during node.
+  // Serialization contain correct ConvertedType and ConvertedType information.
 
-  NodePtr string_node = PrimitiveNode::Make(
+  NodePtr stringNode = PrimitiveNode::make(
       "string",
-      Repetition::REQUIRED,
-      StringLogicalType::Make(),
-      Type::BYTE_ARRAY);
-  NodePtr date_node = PrimitiveNode::Make(
-      "date", Repetition::REQUIRED, DateLogicalType::Make(), Type::INT32);
-  NodePtr json_node = PrimitiveNode::Make(
-      "json", Repetition::REQUIRED, JSONLogicalType::Make(), Type::BYTE_ARRAY);
-  NodePtr uuid_node = PrimitiveNode::Make(
+      Repetition::kRequired,
+      StringLogicalType::make(),
+      Type::kByteArray);
+  NodePtr dateNode = PrimitiveNode::make(
+      "date", Repetition::kRequired, DateLogicalType::make(), Type::kInt32);
+  NodePtr jsonNode = PrimitiveNode::make(
+      "json", Repetition::kRequired, JsonLogicalType::make(), Type::kByteArray);
+  NodePtr uuidNode = PrimitiveNode::make(
       "uuid",
-      Repetition::REQUIRED,
-      UUIDLogicalType::Make(),
-      Type::FIXED_LEN_BYTE_ARRAY,
+      Repetition::kRequired,
+      UuidLogicalType::make(),
+      Type::kFixedLenByteArray,
       16);
-  NodePtr timestamp_node = PrimitiveNode::Make(
+  NodePtr timestampNode = PrimitiveNode::make(
       "timestamp",
-      Repetition::REQUIRED,
-      TimestampLogicalType::Make(false, LogicalType::TimeUnit::NANOS),
-      Type::INT64);
-  NodePtr int_node = PrimitiveNode::Make(
+      Repetition::kRequired,
+      TimestampLogicalType::make(false, LogicalType::TimeUnit::kNanos),
+      Type::kInt64);
+  NodePtr intNode = PrimitiveNode::make(
       "int",
-      Repetition::REQUIRED,
-      IntLogicalType::Make(64, false),
-      Type::INT64);
-  NodePtr decimal_node = PrimitiveNode::Make(
+      Repetition::kRequired,
+      IntLogicalType::make(64, false),
+      Type::kInt64);
+  NodePtr decimalNode = PrimitiveNode::make(
       "decimal",
-      Repetition::REQUIRED,
-      DecimalLogicalType::Make(16, 6),
-      Type::INT64);
+      Repetition::kRequired,
+      DecimalLogicalType::make(16, 6),
+      Type::kInt64);
 
-  NodePtr list_node = GroupNode::Make(
+  NodePtr listNode = GroupNode::make(
       "list",
-      Repetition::REPEATED,
-      {string_node,
-       date_node,
-       json_node,
-       uuid_node,
-       timestamp_node,
-       int_node,
-       decimal_node},
-      ListLogicalType::Make());
-  std::vector<facebook::velox::parquet::thrift::SchemaElement> list_elements;
-  ToParquet(reinterpret_cast<GroupNode*>(list_node.get()), &list_elements);
-  ASSERT_EQ(list_elements[0].name, "list");
-  ASSERT_TRUE(list_elements[0].__isset.converted_type);
-  ASSERT_TRUE(list_elements[0].__isset.logicalType);
-  ASSERT_EQ(list_elements[0].converted_type, ToThrift(ConvertedType::LIST));
-  ASSERT_TRUE(list_elements[0].logicalType.__isset.LIST);
-  ASSERT_TRUE(list_elements[1].logicalType.__isset.STRING);
-  ASSERT_TRUE(list_elements[2].logicalType.__isset.DATE);
-  ASSERT_TRUE(list_elements[3].logicalType.__isset.JSON);
-  ASSERT_TRUE(list_elements[4].logicalType.__isset.UUID);
-  ASSERT_TRUE(list_elements[5].logicalType.__isset.TIMESTAMP);
-  ASSERT_TRUE(list_elements[6].logicalType.__isset.INTEGER);
-  ASSERT_TRUE(list_elements[7].logicalType.__isset.DECIMAL);
-
-  NodePtr map_node =
-      GroupNode::Make("map", Repetition::REQUIRED, {}, MapLogicalType::Make());
-  std::vector<facebook::velox::parquet::thrift::SchemaElement> map_elements;
-  ToParquet(reinterpret_cast<GroupNode*>(map_node.get()), &map_elements);
-  ASSERT_EQ(map_elements[0].name, "map");
-  ASSERT_TRUE(map_elements[0].__isset.converted_type);
-  ASSERT_TRUE(map_elements[0].__isset.logicalType);
-  ASSERT_EQ(map_elements[0].converted_type, ToThrift(ConvertedType::MAP));
-  ASSERT_TRUE(map_elements[0].logicalType.__isset.MAP);
+      Repetition::kRepeated,
+      {stringNode,
+       dateNode,
+       jsonNode,
+       uuidNode,
+       timestampNode,
+       intNode,
+       decimalNode},
+      ListLogicalType::make());
+  std::vector<facebook::velox::parquet::thrift::SchemaElement> listElements;
+  toParquet(reinterpret_cast<GroupNode*>(listNode.get()), &listElements);
+  ASSERT_EQ(listElements[0].name, "list");
+  ASSERT_TRUE(listElements[0].__isset.converted_type);
+  ASSERT_TRUE(listElements[0].__isset.logicalType);
+  ASSERT_EQ(listElements[0].converted_type, toThrift(ConvertedType::kList));
+  ASSERT_TRUE(listElements[0].logicalType.__isset.LIST);
+  ASSERT_TRUE(listElements[1].logicalType.__isset.STRING);
+  ASSERT_TRUE(listElements[2].logicalType.__isset.DATE);
+  ASSERT_TRUE(listElements[3].logicalType.__isset.JSON);
+  ASSERT_TRUE(listElements[4].logicalType.__isset.UUID);
+  ASSERT_TRUE(listElements[5].logicalType.__isset.TIMESTAMP);
+  ASSERT_TRUE(listElements[6].logicalType.__isset.INTEGER);
+  ASSERT_TRUE(listElements[7].logicalType.__isset.DECIMAL);
+
+  NodePtr mapNode =
+      GroupNode::make("map", Repetition::kRequired, {}, MapLogicalType::make());
+  std::vector<facebook::velox::parquet::thrift::SchemaElement> mapElements;
+  toParquet(reinterpret_cast<GroupNode*>(mapNode.get()), &mapElements);
+  ASSERT_EQ(mapElements[0].name, "map");
+  ASSERT_TRUE(mapElements[0].__isset.converted_type);
+  ASSERT_TRUE(mapElements[0].__isset.logicalType);
+  ASSERT_EQ(mapElements[0].converted_type, toThrift(ConvertedType::kMap));
+  ASSERT_TRUE(mapElements[0].logicalType.__isset.MAP);
 }
 
 TEST(TestLogicalTypeSerialization, Roundtrips) {
-  // Confirm that Thrift serialization-deserialization of nodes with logical
-  // types produces equivalent reconstituted nodes
+  // Confirm that Thrift serialization-deserialization of nodes with logical.
+  // Types produces equivalent reconstituted nodes.
 
   // Primitive nodes ...
   struct AnnotatedPrimitiveNodeFactoryArguments {
-    std::shared_ptr<const LogicalType> logical_type;
-    Type::type physical_type;
-    int physical_length;
+    std::shared_ptr<const LogicalType> logicalType;
+    Type::type physicalType;
+    int physicalLength;
   };
 
   std::vector<AnnotatedPrimitiveNodeFactoryArguments> cases = {
-      {LogicalType::String(), Type::BYTE_ARRAY, -1},
-      {LogicalType::Enum(), Type::BYTE_ARRAY, -1},
-      {LogicalType::Decimal(16, 6), Type::INT64, -1},
-      {LogicalType::Date(), Type::INT32, -1},
-      {LogicalType::Time(true, LogicalType::TimeUnit::MILLIS), Type::INT32, -1},
-      {LogicalType::Time(true, LogicalType::TimeUnit::MICROS), Type::INT64, -1},
-      {LogicalType::Time(true, LogicalType::TimeUnit::NANOS), Type::INT64, -1},
-      {LogicalType::Time(false, LogicalType::TimeUnit::MILLIS),
-       Type::INT32,
+      {LogicalType::string(), Type::kByteArray, -1},
+      {LogicalType::enumType(), Type::kByteArray, -1},
+      {LogicalType::decimal(16, 6), Type::kInt64, -1},
+      {LogicalType::date(), Type::kInt32, -1},
+      {LogicalType::time(true, LogicalType::TimeUnit::kMillis),
+       Type::kInt32,
+       -1},
+      {LogicalType::time(true, LogicalType::TimeUnit::kMicros),
+       Type::kInt64,
+       -1},
+      {LogicalType::time(true, LogicalType::TimeUnit::kNanos),
+       Type::kInt64,
+       -1},
+      {LogicalType::time(false, LogicalType::TimeUnit::kMillis),
+       Type::kInt32,
+       -1},
+      {LogicalType::time(false, LogicalType::TimeUnit::kMicros),
+       Type::kInt64,
        -1},
-      {LogicalType::Time(false, LogicalType::TimeUnit::MICROS),
-       Type::INT64,
+      {LogicalType::time(false, LogicalType::TimeUnit::kNanos),
+       Type::kInt64,
        -1},
-      {LogicalType::Time(false, LogicalType::TimeUnit::NANOS), Type::INT64, -1},
-      {LogicalType::Timestamp(true, LogicalType::TimeUnit::MILLIS),
-       Type::INT64,
+      {LogicalType::timestamp(true, LogicalType::TimeUnit::kMillis),
+       Type::kInt64,
        -1},
-      {LogicalType::Timestamp(true, LogicalType::TimeUnit::MICROS),
-       Type::INT64,
+      {LogicalType::timestamp(true, LogicalType::TimeUnit::kMicros),
+       Type::kInt64,
        -1},
-      {LogicalType::Timestamp(true, LogicalType::TimeUnit::NANOS),
-       Type::INT64,
+      {LogicalType::timestamp(true, LogicalType::TimeUnit::kNanos),
+       Type::kInt64,
        -1},
-      {LogicalType::Timestamp(false, LogicalType::TimeUnit::MILLIS),
-       Type::INT64,
+      {LogicalType::timestamp(false, LogicalType::TimeUnit::kMillis),
+       Type::kInt64,
        -1},
-      {LogicalType::Timestamp(false, LogicalType::TimeUnit::MICROS),
-       Type::INT64,
+      {LogicalType::timestamp(false, LogicalType::TimeUnit::kMicros),
+       Type::kInt64,
        -1},
-      {LogicalType::Timestamp(false, LogicalType::TimeUnit::NANOS),
-       Type::INT64,
+      {LogicalType::timestamp(false, LogicalType::TimeUnit::kNanos),
+       Type::kInt64,
        -1},
-      {LogicalType::Interval(), Type::FIXED_LEN_BYTE_ARRAY, 12},
-      {LogicalType::Int(8, false), Type::INT32, -1},
-      {LogicalType::Int(16, false), Type::INT32, -1},
-      {LogicalType::Int(32, false), Type::INT32, -1},
-      {LogicalType::Int(64, false), Type::INT64, -1},
-      {LogicalType::Int(8, true), Type::INT32, -1},
-      {LogicalType::Int(16, true), Type::INT32, -1},
-      {LogicalType::Int(32, true), Type::INT32, -1},
-      {LogicalType::Int(64, true), Type::INT64, -1},
-      {LogicalType::Null(), Type::BOOLEAN, -1},
-      {LogicalType::JSON(), Type::BYTE_ARRAY, -1},
-      {LogicalType::BSON(), Type::BYTE_ARRAY, -1},
-      {LogicalType::UUID(), Type::FIXED_LEN_BYTE_ARRAY, 16},
-      {LogicalType::None(), Type::BOOLEAN, -1}};
+      {LogicalType::interval(), Type::kFixedLenByteArray, 12},
+      {LogicalType::intType(8, false), Type::kInt32, -1},
+      {LogicalType::intType(16, false), Type::kInt32, -1},
+      {LogicalType::intType(32, false), Type::kInt32, -1},
+      {LogicalType::intType(64, false), Type::kInt64, -1},
+      {LogicalType::intType(8, true), Type::kInt32, -1},
+      {LogicalType::intType(16, true), Type::kInt32, -1},
+      {LogicalType::intType(32, true), Type::kInt32, -1},
+      {LogicalType::intType(64, true), Type::kInt64, -1},
+      {LogicalType::nullType(), Type::kBoolean, -1},
+      {LogicalType::json(), Type::kByteArray, -1},
+      {LogicalType::bson(), Type::kByteArray, -1},
+      {LogicalType::uuid(), Type::kFixedLenByteArray, 16},
+      {LogicalType::none(), Type::kBoolean, -1}};
 
   for (const AnnotatedPrimitiveNodeFactoryArguments& c : cases) {
-    ConfirmPrimitiveNodeRoundtrip(
-        c.logical_type, c.physical_type, c.physical_length);
+    confirmPrimitiveNodeRoundtrip(
+        c.logicalType, c.physicalType, c.physicalLength);
   }
 
   // Group nodes ...
-  ConfirmGroupNodeRoundtrip("map", LogicalType::Map());
-  ConfirmGroupNodeRoundtrip("list", LogicalType::List());
+  confirmGroupNodeRoundtrip("map", LogicalType::map());
+  confirmGroupNodeRoundtrip("list", LogicalType::list());
 }
 
 } // namespace schema
diff --git a/velox/dwio/parquet/writer/arrow/tests/StatisticsTest.cpp b/velox/dwio/parquet/writer/arrow/tests/StatisticsTest.cpp
index 85603e04b15..008d95d3df9 100644
--- a/velox/dwio/parquet/writer/arrow/tests/StatisticsTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/StatisticsTest.cpp
@@ -20,10 +20,12 @@
 
 #include "arrow/testing/builder.h"
 
+#include "velox/common/io/IoStatistics.h"
+#include "velox/common/testutil/TempFilePath.h"
 #include "velox/dwio/parquet/reader/ParquetReader.h"
 #include "velox/dwio/parquet/writer/arrow/FileWriter.h"
+#include "velox/dwio/parquet/writer/arrow/StringTruncation.h"
 #include "velox/dwio/parquet/writer/arrow/tests/TestUtil.h"
-#include "velox/exec/tests/utils/TempFilePath.h"
 
 using arrow::default_memory_pool;
 using arrow::MemoryPool;
@@ -32,6 +34,7 @@ using arrow::util::SafeCopy;
 namespace bit_util = arrow::bit_util;
 
 namespace facebook::velox::parquet::arrow {
+using namespace facebook::velox::common::testutil;
 
 using schema::GroupNode;
 using schema::NodePtr;
@@ -40,8 +43,8 @@ using schema::PrimitiveNode;
 namespace test {
 namespace {
 void writeToFile(
-    std::shared_ptr<exec::test::TempFilePath> filePath,
-    std::shared_ptr<arrow::Buffer> buffer) {
+    std::shared_ptr<TempFilePath> filePath,
+    std::shared_ptr<::arrow::Buffer> buffer) {
   auto localWriteFile =
       std::make_unique<LocalWriteFile>(filePath->getPath(), false, false);
   auto bufferReader = std::make_shared<::arrow::io::BufferReader>(buffer);
@@ -51,15 +54,15 @@ void writeToFile(
 }
 } // namespace
 
-// ----------------------------------------------------------------------
-// Test comparators
+// ----------------------------------------------------------------------.
+// Test Comparators.
 
-static ByteArray ByteArrayFromString(const std::string& s) {
+static ByteArray byteArrayFromString(const std::string& s) {
   auto ptr = reinterpret_cast<const uint8_t*>(s.data());
   return ByteArray(static_cast<uint32_t>(s.size()), ptr);
 }
 
-static FLBA FLBAFromString(const std::string& s) {
+static FLBA fLBAFromString(const std::string& s) {
   auto ptr = reinterpret_cast<const uint8_t*>(s.data());
   return FLBA(ptr);
 }
@@ -69,12 +72,12 @@ TEST(Comparison, SignedByteArray) {
   // decimals are encoded as byte arrays they use twos complement big-endian
   // encoded values. Comparisons of byte arrays of unequal types need to handle
   // sign extension.
-  auto comparator =
-      MakeComparator<ByteArrayType>(Type::BYTE_ARRAY, SortOrder::SIGNED);
+  auto Comparator =
+      makeComparator<ByteArrayType>(Type::kByteArray, SortOrder::kSigned);
   struct Case {
     std::vector<uint8_t> bytes;
     int order;
-    ByteArray ToByteArray() const {
+    ByteArray toByteArray() const {
       return ByteArray(static_cast<int>(bytes.size()), bytes.data());
     }
   };
@@ -99,23 +102,23 @@ TEST(Comparison, SignedByteArray) {
 
   for (size_t x = 0; x < cases.size(); x++) {
     const auto& case1 = cases[x];
-    // Empty array is always the smallest values
-    EXPECT_TRUE(comparator->Compare(ByteArray(), case1.ToByteArray())) << x;
-    EXPECT_FALSE(comparator->Compare(case1.ToByteArray(), ByteArray())) << x;
+    // Empty array is always the smallest values.
+    EXPECT_TRUE(Comparator->compare(ByteArray(), case1.toByteArray())) << x;
+    EXPECT_FALSE(Comparator->compare(case1.toByteArray(), ByteArray())) << x;
     // Equals is always false.
-    EXPECT_FALSE(comparator->Compare(case1.ToByteArray(), case1.ToByteArray()))
+    EXPECT_FALSE(Comparator->compare(case1.toByteArray(), case1.toByteArray()))
         << x;
 
     for (size_t y = 0; y < cases.size(); y++) {
       const auto& case2 = cases[y];
       if (case1.order < case2.order) {
         EXPECT_TRUE(
-            comparator->Compare(case1.ToByteArray(), case2.ToByteArray()))
+            Comparator->compare(case1.toByteArray(), case2.toByteArray()))
             << x << " (order: " << case1.order << ") " << y
             << " (order: " << case2.order << ")";
       } else {
         EXPECT_FALSE(
-            comparator->Compare(case1.ToByteArray(), case2.ToByteArray()))
+            Comparator->compare(case1.toByteArray(), case2.toByteArray()))
             << x << " (order: " << case1.order << ") " << y
             << " (order: " << case2.order << ")";
       }
@@ -124,36 +127,36 @@ TEST(Comparison, SignedByteArray) {
 }
 
 TEST(Comparison, UnsignedByteArray) {
-  // Check if UTF-8 is compared using unsigned correctly
-  auto comparator =
-      MakeComparator<ByteArrayType>(Type::BYTE_ARRAY, SortOrder::UNSIGNED);
+  // Check if UTF-8 is compared using unsigned correctly.
+  auto Comparator =
+      makeComparator<ByteArrayType>(Type::kByteArray, SortOrder::kUnsigned);
 
   std::string s1 = "arrange";
   std::string s2 = "arrangement";
-  ByteArray s1ba = ByteArrayFromString(s1);
-  ByteArray s2ba = ByteArrayFromString(s2);
-  ASSERT_TRUE(comparator->Compare(s1ba, s2ba));
+  ByteArray s1ba = byteArrayFromString(s1);
+  ByteArray s2ba = byteArrayFromString(s2);
+  ASSERT_TRUE(Comparator->compare(s1ba, s2ba));
 
-  // Multi-byte UTF-8 characters
+  // Multi-byte UTF-8 characters.
   s1 = "braten";
   s2 = "bügeln";
-  s1ba = ByteArrayFromString(s1);
-  s2ba = ByteArrayFromString(s2);
-  ASSERT_TRUE(comparator->Compare(s1ba, s2ba));
+  s1ba = byteArrayFromString(s1);
+  s2ba = byteArrayFromString(s2);
+  ASSERT_TRUE(Comparator->compare(s1ba, s2ba));
 
   s1 = "ünk123456"; // ü = 252
   s2 = "ănk123456"; // ă = 259
-  s1ba = ByteArrayFromString(s1);
-  s2ba = ByteArrayFromString(s2);
-  ASSERT_TRUE(comparator->Compare(s1ba, s2ba));
+  s1ba = byteArrayFromString(s1);
+  s2ba = byteArrayFromString(s2);
+  ASSERT_TRUE(Comparator->compare(s1ba, s2ba));
 }
 
 TEST(Comparison, SignedFLBA) {
   int size = 4;
-  auto comparator = MakeComparator<FLBAType>(
-      Type::FIXED_LEN_BYTE_ARRAY, SortOrder::SIGNED, size);
+  auto Comparator = makeComparator<FLBAType>(
+      Type::kFixedLenByteArray, SortOrder::kSigned, size);
 
-  std::vector<uint8_t> byte_values[] = {
+  std::vector<uint8_t> byteValues[] = {
       {0x80, 0, 0, 0},
       {0xFF, 0xFF, 0x01, 0},
       {0xFF, 0xFF, 0x80, 0},
@@ -162,21 +165,18 @@ TEST(Comparison, SignedFLBA) {
       {0, 0, 0x01, 0x01},
       {0, 0x01, 0x01, 0},
       {0x01, 0x01, 0, 0}};
-  std::vector<FLBA> values_to_compare;
-  for (auto& bytes : byte_values) {
-    values_to_compare.emplace_back(FLBA(bytes.data()));
+  std::vector<FLBA> valuesToCompare;
+  for (auto& bytes : byteValues) {
+    valuesToCompare.emplace_back(FLBA(bytes.data()));
   }
 
-  for (size_t x = 0; x < values_to_compare.size(); x++) {
-    EXPECT_FALSE(
-        comparator->Compare(values_to_compare[x], values_to_compare[x]))
+  for (size_t x = 0; x < valuesToCompare.size(); x++) {
+    EXPECT_FALSE(Comparator->compare(valuesToCompare[x], valuesToCompare[x]))
         << x;
-    for (size_t y = x + 1; y < values_to_compare.size(); y++) {
-      EXPECT_TRUE(
-          comparator->Compare(values_to_compare[x], values_to_compare[y]))
+    for (size_t y = x + 1; y < valuesToCompare.size(); y++) {
+      EXPECT_TRUE(Comparator->compare(valuesToCompare[x], valuesToCompare[y]))
           << x << " " << y;
-      EXPECT_FALSE(
-          comparator->Compare(values_to_compare[y], values_to_compare[x]))
+      EXPECT_FALSE(Comparator->compare(valuesToCompare[y], valuesToCompare[x]))
           << y << " " << x;
     }
   }
@@ -184,20 +184,20 @@ TEST(Comparison, SignedFLBA) {
 
 TEST(Comparison, UnsignedFLBA) {
   int size = 10;
-  auto comparator = MakeComparator<FLBAType>(
-      Type::FIXED_LEN_BYTE_ARRAY, SortOrder::UNSIGNED, size);
+  auto Comparator = makeComparator<FLBAType>(
+      Type::kFixedLenByteArray, SortOrder::kUnsigned, size);
 
   std::string s1 = "Anti123456";
   std::string s2 = "Bunkd123456";
-  FLBA s1flba = FLBAFromString(s1);
-  FLBA s2flba = FLBAFromString(s2);
-  ASSERT_TRUE(comparator->Compare(s1flba, s2flba));
+  FLBA s1flba = fLBAFromString(s1);
+  FLBA s2flba = fLBAFromString(s2);
+  ASSERT_TRUE(Comparator->compare(s1flba, s2flba));
 
   s1 = "Bunk123456";
   s2 = "Bünk123456";
-  s1flba = FLBAFromString(s1);
-  s2flba = FLBAFromString(s2);
-  ASSERT_TRUE(comparator->Compare(s1flba, s2flba));
+  s1flba = fLBAFromString(s1);
+  s2flba = fLBAFromString(s2);
+  ASSERT_TRUE(Comparator->compare(s1flba, s2flba));
 }
 
 TEST(Comparison, SignedInt96) {
@@ -205,11 +205,11 @@ TEST(Comparison, SignedInt96) {
   Int96 aa{{1, 41, 14}}, bb{{1, 41, 14}};
   Int96 aaa{{1, 41, static_cast<uint32_t>(-14)}}, bbb{{1, 41, 42}};
 
-  auto comparator = MakeComparator<Int96Type>(Type::INT96, SortOrder::SIGNED);
+  auto Comparator = makeComparator<Int96Type>(Type::kInt96, SortOrder::kSigned);
 
-  ASSERT_TRUE(comparator->Compare(a, b));
-  ASSERT_TRUE(!comparator->Compare(aa, bb) && !comparator->Compare(bb, aa));
-  ASSERT_TRUE(comparator->Compare(aaa, bbb));
+  ASSERT_TRUE(Comparator->compare(a, b));
+  ASSERT_TRUE(!Comparator->compare(aa, bb) && !Comparator->compare(bb, aa));
+  ASSERT_TRUE(Comparator->compare(aaa, bbb));
 }
 
 TEST(Comparison, UnsignedInt96) {
@@ -217,35 +217,36 @@ TEST(Comparison, UnsignedInt96) {
   Int96 aa{{1, 41, 14}}, bb{{1, 41, static_cast<uint32_t>(-14)}};
   Int96 aaa, bbb;
 
-  auto comparator = MakeComparator<Int96Type>(Type::INT96, SortOrder::UNSIGNED);
+  auto Comparator =
+      makeComparator<Int96Type>(Type::kInt96, SortOrder::kUnsigned);
 
-  ASSERT_TRUE(comparator->Compare(a, b));
-  ASSERT_TRUE(comparator->Compare(aa, bb));
+  ASSERT_TRUE(Comparator->compare(a, b));
+  ASSERT_TRUE(Comparator->compare(aa, bb));
 
-  // INT96 Timestamp
+  // INT96 Timestamp.
   aaa.value[2] = 2451545; // 2000-01-01
   bbb.value[2] = 2451546; // 2000-01-02
-  // 12 hours + 34 minutes + 56 seconds.
-  Int96SetNanoSeconds(aaa, 45296000000000);
-  // 12 hours + 34 minutes + 50 seconds.
-  Int96SetNanoSeconds(bbb, 45290000000000);
-  ASSERT_TRUE(comparator->Compare(aaa, bbb));
+  // 12 Hours + 34 minutes + 56 seconds.
+  int96SetNanoSeconds(aaa, 45296000000000);
+  // 12 Hours + 34 minutes + 50 seconds.
+  int96SetNanoSeconds(bbb, 45290000000000);
+  ASSERT_TRUE(Comparator->compare(aaa, bbb));
 
   aaa.value[2] = 2451545; // 2000-01-01
   bbb.value[2] = 2451545; // 2000-01-01
-  // 11 hours + 34 minutes + 56 seconds.
-  Int96SetNanoSeconds(aaa, 41696000000000);
-  // 12 hours + 34 minutes + 50 seconds.
-  Int96SetNanoSeconds(bbb, 45290000000000);
-  ASSERT_TRUE(comparator->Compare(aaa, bbb));
+  // 11 Hours + 34 minutes + 56 seconds.
+  int96SetNanoSeconds(aaa, 41696000000000);
+  // 12 Hours + 34 minutes + 50 seconds.
+  int96SetNanoSeconds(bbb, 45290000000000);
+  ASSERT_TRUE(Comparator->compare(aaa, bbb));
 
   aaa.value[2] = 2451545; // 2000-01-01
   bbb.value[2] = 2451545; // 2000-01-01
-  // 12 hours + 34 minutes + 55 seconds.
-  Int96SetNanoSeconds(aaa, 45295000000000);
-  // 12 hours + 34 minutes + 56 seconds.
-  Int96SetNanoSeconds(bbb, 45296000000000);
-  ASSERT_TRUE(comparator->Compare(aaa, bbb));
+  // 12 Hours + 34 minutes + 55 seconds.
+  int96SetNanoSeconds(aaa, 45295000000000);
+  // 12 Hours + 34 minutes + 56 seconds.
+  int96SetNanoSeconds(bbb, 45296000000000);
+  ASSERT_TRUE(Comparator->compare(aaa, bbb));
 }
 
 TEST(Comparison, SignedInt64) {
@@ -253,15 +254,15 @@ TEST(Comparison, SignedInt64) {
   int64_t aa = 1, bb = 1;
   int64_t aaa = -1, bbb = 1;
 
-  NodePtr node =
-      PrimitiveNode::Make("SignedInt64", Repetition::REQUIRED, Type::INT64);
-  ColumnDescriptor descr(node, 0, 0);
+  NodePtr Node =
+      PrimitiveNode::make("SignedInt64", Repetition::kRequired, Type::kInt64);
+  ColumnDescriptor descr(Node, 0, 0);
 
-  auto comparator = MakeComparator<Int64Type>(&descr);
+  auto Comparator = makeComparator<Int64Type>(&descr);
 
-  ASSERT_TRUE(comparator->Compare(a, b));
-  ASSERT_TRUE(!comparator->Compare(aa, bb) && !comparator->Compare(bb, aa));
-  ASSERT_TRUE(comparator->Compare(aaa, bbb));
+  ASSERT_TRUE(Comparator->compare(a, b));
+  ASSERT_TRUE(!Comparator->compare(aa, bb) && !Comparator->compare(bb, aa));
+  ASSERT_TRUE(Comparator->compare(aaa, bbb));
 }
 
 TEST(Comparison, UnsignedInt64) {
@@ -269,19 +270,19 @@ TEST(Comparison, UnsignedInt64) {
   uint64_t aa = 1, bb = 1;
   uint64_t aaa = 1, bbb = -1;
 
-  NodePtr node = PrimitiveNode::Make(
+  NodePtr Node = PrimitiveNode::make(
       "UnsignedInt64",
-      Repetition::REQUIRED,
-      Type::INT64,
-      ConvertedType::UINT_64);
-  ColumnDescriptor descr(node, 0, 0);
+      Repetition::kRequired,
+      Type::kInt64,
+      ConvertedType::kUint64);
+  ColumnDescriptor descr(Node, 0, 0);
 
-  ASSERT_EQ(SortOrder::UNSIGNED, descr.sort_order());
-  auto comparator = MakeComparator<Int64Type>(&descr);
+  ASSERT_EQ(SortOrder::kUnsigned, descr.sortOrder());
+  auto Comparator = makeComparator<Int64Type>(&descr);
 
-  ASSERT_TRUE(comparator->Compare(a, b));
-  ASSERT_TRUE(!comparator->Compare(aa, bb) && !comparator->Compare(bb, aa));
-  ASSERT_TRUE(comparator->Compare(aaa, bbb));
+  ASSERT_TRUE(Comparator->compare(a, b));
+  ASSERT_TRUE(!Comparator->compare(aa, bb) && !Comparator->compare(bb, aa));
+  ASSERT_TRUE(Comparator->compare(aaa, bbb));
 }
 
 TEST(Comparison, UnsignedInt32) {
@@ -289,174 +290,174 @@ TEST(Comparison, UnsignedInt32) {
   uint32_t aa = 1, bb = 1;
   uint32_t aaa = 1, bbb = -1;
 
-  NodePtr node = PrimitiveNode::Make(
+  NodePtr Node = PrimitiveNode::make(
       "UnsignedInt32",
-      Repetition::REQUIRED,
-      Type::INT32,
-      ConvertedType::UINT_32);
-  ColumnDescriptor descr(node, 0, 0);
+      Repetition::kRequired,
+      Type::kInt32,
+      ConvertedType::kUint32);
+  ColumnDescriptor descr(Node, 0, 0);
 
-  ASSERT_EQ(SortOrder::UNSIGNED, descr.sort_order());
-  auto comparator = MakeComparator<Int32Type>(&descr);
+  ASSERT_EQ(SortOrder::kUnsigned, descr.sortOrder());
+  auto Comparator = makeComparator<Int32Type>(&descr);
 
-  ASSERT_TRUE(comparator->Compare(a, b));
-  ASSERT_TRUE(!comparator->Compare(aa, bb) && !comparator->Compare(bb, aa));
-  ASSERT_TRUE(comparator->Compare(aaa, bbb));
+  ASSERT_TRUE(Comparator->compare(a, b));
+  ASSERT_TRUE(!Comparator->compare(aa, bb) && !Comparator->compare(bb, aa));
+  ASSERT_TRUE(Comparator->compare(aaa, bbb));
 }
 
 TEST(Comparison, UnknownSortOrder) {
-  NodePtr node = PrimitiveNode::Make(
+  NodePtr Node = PrimitiveNode::make(
       "Unknown",
-      Repetition::REQUIRED,
-      Type::FIXED_LEN_BYTE_ARRAY,
-      ConvertedType::INTERVAL,
+      Repetition::kRequired,
+      Type::kFixedLenByteArray,
+      ConvertedType::kInterval,
       12);
-  ColumnDescriptor descr(node, 0, 0);
+  ColumnDescriptor descr(Node, 0, 0);
 
-  ASSERT_THROW(Comparator::Make(&descr), ParquetException);
+  ASSERT_THROW(Comparator::make(&descr), ParquetException);
 }
 
-// ----------------------------------------------------------------------
+// ----------------------------------------------------------------------.
 
 template <typename TestType>
 class TestStatistics : public PrimitiveTypedTest<TestType> {
  public:
-  using c_type = typename TestType::c_type;
+  using CType = typename TestType::CType;
 
-  std::vector<c_type> GetDeepCopy(
-      const std::vector<c_type>&); // allocates new memory for FLBA/ByteArray
+  std::vector<CType> getDeepCopy(
+      const std::vector<CType>&); // allocates new memory for FLBA/ByteArray
 
-  c_type* GetValuesPointer(std::vector<c_type>&);
-  void DeepFree(std::vector<c_type>&);
+  CType* getValuesPointer(std::vector<CType>&);
+  void deepFree(std::vector<CType>&);
 
-  void TestMinMaxEncode() {
-    this->GenerateData(1000);
+  void testMinMaxEncode() {
+    this->generateData(1000);
 
-    auto statistics1 = MakeStatistics<TestType>(this->schema_.Column(0));
-    statistics1->Update(this->values_ptr_, this->values_.size(), 0);
-    std::string encoded_min = statistics1->EncodeMin();
-    std::string encoded_max = statistics1->EncodeMax();
+    auto statistics1 = makeStatistics<TestType>(this->schema_.column(0));
+    statistics1->update(this->valuesPtr_, this->values_.size(), 0);
+    std::string encodedMin = statistics1->encodeMin();
+    std::string encodedMax = statistics1->encodeMax();
 
-    auto statistics2 = MakeStatistics<TestType>(
-        this->schema_.Column(0),
-        encoded_min,
-        encoded_max,
+    auto statistics2 = makeStatistics<TestType>(
+        this->schema_.column(0),
+        encodedMin,
+        encodedMax,
         this->values_.size(),
-        0,
-        0,
-        true,
-        true,
-        true);
-
-    auto statistics3 = MakeStatistics<TestType>(this->schema_.Column(0));
-    std::vector<uint8_t> valid_bits(
+        0, // nullCount.
+        0, // distinctCount.
+        true, // hasMinMax.
+        true, // hasNullCount.
+        true, // hasDistinctCount.
+        false, // hasNaNCount.
+        0); // nanCount.
+
+    auto statistics3 = makeStatistics<TestType>(this->schema_.column(0));
+    std::vector<uint8_t> validBits(
         ::arrow::bit_util::BytesForBits(
             static_cast<uint32_t>(this->values_.size())) +
             1,
         255);
-    statistics3->UpdateSpaced(
-        this->values_ptr_,
-        valid_bits.data(),
+    statistics3->updateSpaced(
+        this->valuesPtr_,
+        validBits.data(),
         0,
         this->values_.size(),
         this->values_.size(),
         0);
-    std::string encoded_min_spaced = statistics3->EncodeMin();
-    std::string encoded_max_spaced = statistics3->EncodeMax();
+    std::string encodedMinSpaced = statistics3->encodeMin();
+    std::string encodedMaxSpaced = statistics3->encodeMax();
 
-    ASSERT_EQ(encoded_min, statistics2->EncodeMin());
-    ASSERT_EQ(encoded_max, statistics2->EncodeMax());
+    ASSERT_EQ(encodedMin, statistics2->encodeMin());
+    ASSERT_EQ(encodedMax, statistics2->encodeMax());
     ASSERT_EQ(statistics1->min(), statistics2->min());
     ASSERT_EQ(statistics1->max(), statistics2->max());
-    ASSERT_EQ(encoded_min_spaced, statistics2->EncodeMin());
-    ASSERT_EQ(encoded_max_spaced, statistics2->EncodeMax());
+    ASSERT_EQ(encodedMinSpaced, statistics2->encodeMin());
+    ASSERT_EQ(encodedMaxSpaced, statistics2->encodeMax());
     ASSERT_EQ(statistics3->min(), statistics2->min());
     ASSERT_EQ(statistics3->max(), statistics2->max());
   }
 
-  void TestReset() {
-    this->GenerateData(1000);
-
-    auto statistics = MakeStatistics<TestType>(this->schema_.Column(0));
-    statistics->Update(this->values_ptr_, this->values_.size(), 0);
-    ASSERT_EQ(this->values_.size(), statistics->num_values());
-
-    statistics->Reset();
-    ASSERT_TRUE(statistics->HasNullCount());
-    ASSERT_FALSE(statistics->HasMinMax());
-    ASSERT_FALSE(statistics->HasDistinctCount());
-    ASSERT_EQ(0, statistics->null_count());
-    ASSERT_EQ(0, statistics->num_values());
-    ASSERT_EQ(0, statistics->distinct_count());
-    ASSERT_EQ("", statistics->EncodeMin());
-    ASSERT_EQ("", statistics->EncodeMax());
+  void testReset() {
+    this->generateData(1000);
+
+    auto Statistics = makeStatistics<TestType>(this->schema_.column(0));
+    Statistics->update(this->valuesPtr_, this->values_.size(), 0);
+    ASSERT_EQ(this->values_.size(), Statistics->numValues());
+
+    Statistics->reset();
+    ASSERT_TRUE(Statistics->hasNullCount());
+    ASSERT_FALSE(Statistics->hasMinMax());
+    ASSERT_FALSE(Statistics->hasDistinctCount());
+    ASSERT_EQ(0, Statistics->nullCount());
+    ASSERT_EQ(0, Statistics->numValues());
+    ASSERT_EQ(0, Statistics->distinctCount());
+    ASSERT_EQ("", Statistics->encodeMin());
+    ASSERT_EQ("", Statistics->encodeMax());
   }
 
-  void TestMerge() {
-    int num_null[2];
-    random_numbers(2, 42, 0, 100, num_null);
+  void testMerge() {
+    int numNull[2];
+    randomNumbers(2, 42, 0, 100, numNull);
 
-    auto statistics1 = MakeStatistics<TestType>(this->schema_.Column(0));
-    this->GenerateData(1000);
-    statistics1->Update(
-        this->values_ptr_, this->values_.size() - num_null[0], num_null[0]);
+    auto statistics1 = makeStatistics<TestType>(this->schema_.column(0));
+    this->generateData(1000);
+    statistics1->update(
+        this->valuesPtr_, this->values_.size() - numNull[0], numNull[0]);
 
-    auto statistics2 = MakeStatistics<TestType>(this->schema_.Column(0));
-    this->GenerateData(1000);
-    statistics2->Update(
-        this->values_ptr_, this->values_.size() - num_null[1], num_null[1]);
+    auto statistics2 = makeStatistics<TestType>(this->schema_.column(0));
+    this->generateData(1000);
+    statistics2->update(
+        this->valuesPtr_, this->values_.size() - numNull[1], numNull[1]);
 
-    auto total = MakeStatistics<TestType>(this->schema_.Column(0));
-    total->Merge(*statistics1);
-    total->Merge(*statistics2);
+    auto total = makeStatistics<TestType>(this->schema_.column(0));
+    total->merge(*statistics1);
+    total->merge(*statistics2);
 
-    ASSERT_EQ(num_null[0] + num_null[1], total->null_count());
+    ASSERT_EQ(numNull[0] + numNull[1], total->nullCount());
     ASSERT_EQ(
-        this->values_.size() * 2 - num_null[0] - num_null[1],
-        total->num_values());
+        this->values_.size() * 2 - numNull[0] - numNull[1], total->numValues());
     ASSERT_EQ(total->min(), std::min(statistics1->min(), statistics2->min()));
     ASSERT_EQ(total->max(), std::max(statistics1->max(), statistics2->max()));
   }
 
-  void TestEquals() {
-    const auto n_values = 1;
-    auto statistics_have_minmax1 =
-        MakeStatistics<TestType>(this->schema_.Column(0));
+  void testEquals() {
+    const auto nValues = 1;
+    auto statisticsHaveMinmax1 =
+        makeStatistics<TestType>(this->schema_.column(0));
     const auto seed1 = 1;
-    this->GenerateData(n_values, seed1);
-    statistics_have_minmax1->Update(this->values_ptr_, this->values_.size(), 0);
-    auto statistics_have_minmax2 =
-        MakeStatistics<TestType>(this->schema_.Column(0));
+    this->generateData(nValues, seed1);
+    statisticsHaveMinmax1->update(this->valuesPtr_, this->values_.size(), 0);
+    auto statisticsHaveMinmax2 =
+        makeStatistics<TestType>(this->schema_.column(0));
     const auto seed2 = 9999;
-    this->GenerateData(n_values, seed2);
-    statistics_have_minmax2->Update(this->values_ptr_, this->values_.size(), 0);
-    auto statistics_no_minmax =
-        MakeStatistics<TestType>(this->schema_.Column(0));
-
-    ASSERT_EQ(true, statistics_have_minmax1->Equals(*statistics_have_minmax1));
-    ASSERT_EQ(true, statistics_no_minmax->Equals(*statistics_no_minmax));
-    ASSERT_EQ(false, statistics_have_minmax1->Equals(*statistics_have_minmax2));
-    ASSERT_EQ(false, statistics_have_minmax1->Equals(*statistics_no_minmax));
+    this->generateData(nValues, seed2);
+    statisticsHaveMinmax2->update(this->valuesPtr_, this->values_.size(), 0);
+    auto statisticsNoMinmax = makeStatistics<TestType>(this->schema_.column(0));
+
+    ASSERT_EQ(true, statisticsHaveMinmax1->equals(*statisticsHaveMinmax1));
+    ASSERT_EQ(true, statisticsNoMinmax->equals(*statisticsNoMinmax));
+    ASSERT_EQ(false, statisticsHaveMinmax1->equals(*statisticsHaveMinmax2));
+    ASSERT_EQ(false, statisticsHaveMinmax1->equals(*statisticsNoMinmax));
   }
 
-  void TestFullRoundtrip(int64_t numValues, int64_t nullCount) {
-    this->GenerateData(numValues);
+  void testFullRoundtrip(int64_t numValues, int64_t nullCount) {
+    this->generateData(numValues);
 
-    // compute statistics for the whole batch
-    auto expectedStats = MakeStatistics<TestType>(this->schema_.Column(0));
-    expectedStats->Update(this->values_ptr_, numValues - nullCount, nullCount);
+    // Compute statistics for the whole batch.
+    auto expectedStats = makeStatistics<TestType>(this->schema_.column(0));
+    expectedStats->update(this->valuesPtr_, numValues - nullCount, nullCount);
 
-    auto sink = CreateOutputStream();
+    auto sink = createOutputStream();
     auto gnode = std::static_pointer_cast<GroupNode>(this->node_);
-    std::shared_ptr<WriterProperties> writerProperties =
-        WriterProperties::Builder().enable_statistics("column")->build();
-    auto fileWriter = ParquetFileWriter::Open(sink, gnode, writerProperties);
-    auto rowGroupWriter = fileWriter->AppendRowGroup();
+    std::shared_ptr<WriterProperties> WriterProperties =
+        WriterProperties::Builder().enableStatistics("column")->build();
+    auto fileWriter = ParquetFileWriter::open(sink, gnode, WriterProperties);
+    auto rowGroupWriter = fileWriter->appendRowGroup();
     auto columnWriter =
-        static_cast<TypedColumnWriter<TestType>*>(rowGroupWriter->NextColumn());
+        static_cast<TypedColumnWriter<TestType>*>(rowGroupWriter->nextColumn());
 
-    // simulate the case when data comes from multiple buffers,
-    // in which case special care is necessary for FLBA/ByteArray types
+    // Simulate the case when data comes from multiple buffers,
+    // in which case special care is necessary for FLBA/ByteArray types.
     for (int i = 0; i < 2; i++) {
       int64_t batchNumValues = i ? numValues - numValues / 2 : numValues / 2;
       int64_t batchNullCount = i ? nullCount : 0;
@@ -464,29 +465,33 @@ class TestStatistics : public PrimitiveTypedTest<TestType> {
       std::vector<int16_t> definitionLevels(batchNullCount, 0);
       definitionLevels.insert(
           definitionLevels.end(), batchNumValues - batchNullCount, 1);
-      auto beg = this->values_.begin() + i * numValues / 2;
+      auto beg = this->values_.cbegin() + i * numValues / 2;
       auto end = beg + batchNumValues;
-      std::vector<c_type> batch = GetDeepCopy(std::vector<c_type>(beg, end));
-      c_type* batchValuesPtr = GetValuesPointer(batch);
-      columnWriter->WriteBatch(
+      std::vector<CType> batch = getDeepCopy(std::vector<CType>(beg, end));
+      CType* batchValuesPtr = getValuesPointer(batch);
+      columnWriter->writeBatch(
           batchNumValues, definitionLevels.data(), nullptr, batchValuesPtr);
-      DeepFree(batch);
+      deepFree(batch);
     }
-    columnWriter->Close();
-    rowGroupWriter->Close();
-    fileWriter->Close();
+    columnWriter->close();
+    rowGroupWriter->close();
+    fileWriter->close();
 
     ASSERT_OK_AND_ASSIGN(auto buffer, sink->Finish());
 
-    // Write the buffer to a temp file
-    auto filePath = exec::test::TempFilePath::create();
+    // Write the buffer to a temp file.
+    auto filePath = TempFilePath::create();
     writeToFile(filePath, buffer);
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
     std::shared_ptr<facebook::velox::memory::MemoryPool> rootPool =
         memory::memoryManager()->addRootPool("StatisticsTest");
     std::shared_ptr<facebook::velox::memory::MemoryPool> leafPool =
         rootPool->addLeafChild("StatisticsTest");
-    dwio::common::ReaderOptions readerOptions{leafPool.get()};
+    auto dataIoStats = std::make_shared<velox::io::IoStatistics>();
+    auto metadataIoStats = std::make_shared<velox::io::IoStatistics>();
+    dwio::common::ReaderOptions readerOptions(leafPool.get());
+    readerOptions.setDataIoStats(dataIoStats);
+    readerOptions.setMetadataIoStats(metadataIoStats);
     auto input = std::make_unique<dwio::common::BufferedInput>(
         std::make_shared<LocalReadFile>(filePath->getPath()),
         readerOptions.memoryPool());
@@ -495,12 +500,12 @@ class TestStatistics : public PrimitiveTypedTest<TestType> {
     auto rowGroup = reader->fileMetaData().rowGroup(0);
     auto columnChunk = rowGroup.columnChunk(0);
     EXPECT_EQ(nullCount, columnChunk.getColumnMetadataStatsNullCount());
-    EXPECT_TRUE(expectedStats->HasMinMax());
+    EXPECT_TRUE(expectedStats->hasMinMax());
     EXPECT_EQ(
-        expectedStats->EncodeMin(),
+        expectedStats->encodeMin(),
         columnChunk.getColumnMetadataStatsMinValue());
     EXPECT_EQ(
-        expectedStats->EncodeMax(),
+        expectedStats->encodeMax(),
         columnChunk.getColumnMetadataStatsMaxValue());
     auto columnStats =
         columnChunk.getColumnStatistics(INTEGER(), rowGroup.numRows());
@@ -509,29 +514,29 @@ class TestStatistics : public PrimitiveTypedTest<TestType> {
 };
 
 template <typename TestType>
-typename TestType::c_type* TestStatistics<TestType>::GetValuesPointer(
-    std::vector<typename TestType::c_type>& values) {
+typename TestType::CType* TestStatistics<TestType>::getValuesPointer(
+    std::vector<typename TestType::CType>& values) {
   return values.data();
 }
 
 template <>
-bool* TestStatistics<BooleanType>::GetValuesPointer(std::vector<bool>& values) {
-  static std::vector<uint8_t> bool_buffer;
-  bool_buffer.clear();
-  bool_buffer.resize(values.size());
-  std::copy(values.begin(), values.end(), bool_buffer.begin());
-  return reinterpret_cast<bool*>(bool_buffer.data());
+bool* TestStatistics<BooleanType>::getValuesPointer(std::vector<bool>& values) {
+  static std::vector<uint8_t> boolBuffer;
+  boolBuffer.clear();
+  boolBuffer.resize(values.size());
+  std::copy(values.begin(), values.end(), boolBuffer.begin());
+  return reinterpret_cast<bool*>(boolBuffer.data());
 }
 
 template <typename TestType>
-typename std::vector<typename TestType::c_type>
-TestStatistics<TestType>::GetDeepCopy(
-    const std::vector<typename TestType::c_type>& values) {
+typename std::vector<typename TestType::CType>
+TestStatistics<TestType>::getDeepCopy(
+    const std::vector<typename TestType::CType>& values) {
   return values;
 }
 
 template <>
-std::vector<FLBA> TestStatistics<FLBAType>::GetDeepCopy(
+std::vector<FLBA> TestStatistics<FLBAType>::getDeepCopy(
     const std::vector<FLBA>& values) {
   std::vector<FLBA> copy;
   MemoryPool* pool = ::arrow::default_memory_pool();
@@ -545,7 +550,7 @@ std::vector<FLBA> TestStatistics<FLBAType>::GetDeepCopy(
 }
 
 template <>
-std::vector<ByteArray> TestStatistics<ByteArrayType>::GetDeepCopy(
+std::vector<ByteArray> TestStatistics<ByteArrayType>::getDeepCopy(
     const std::vector<ByteArray>& values) {
   std::vector<ByteArray> copy;
   MemoryPool* pool = default_memory_pool();
@@ -559,11 +564,11 @@ std::vector<ByteArray> TestStatistics<ByteArrayType>::GetDeepCopy(
 }
 
 template <typename TestType>
-void TestStatistics<TestType>::DeepFree(
-    std::vector<typename TestType::c_type>& values) {}
+void TestStatistics<TestType>::deepFree(
+    std::vector<typename TestType::CType>& values) {}
 
 template <>
-void TestStatistics<FLBAType>::DeepFree(std::vector<FLBA>& values) {
+void TestStatistics<FLBAType>::deepFree(std::vector<FLBA>& values) {
   MemoryPool* pool = default_memory_pool();
   for (FLBA& flba : values) {
     auto ptr = const_cast<uint8_t*>(flba.ptr);
@@ -573,7 +578,7 @@ void TestStatistics<FLBAType>::DeepFree(std::vector<FLBA>& values) {
 }
 
 template <>
-void TestStatistics<ByteArrayType>::DeepFree(std::vector<ByteArray>& values) {
+void TestStatistics<ByteArrayType>::deepFree(std::vector<ByteArray>& values) {
   MemoryPool* pool = default_memory_pool();
   for (ByteArray& ba : values) {
     auto ptr = const_cast<uint8_t*>(ba.ptr);
@@ -583,39 +588,41 @@ void TestStatistics<ByteArrayType>::DeepFree(std::vector<ByteArray>& values) {
 }
 
 template <>
-void TestStatistics<ByteArrayType>::TestMinMaxEncode() {
-  this->GenerateData(1000);
-  // Test that we encode min max strings correctly
-  auto statistics1 = MakeStatistics<ByteArrayType>(this->schema_.Column(0));
-  statistics1->Update(this->values_ptr_, this->values_.size(), 0);
-  std::string encoded_min = statistics1->EncodeMin();
-  std::string encoded_max = statistics1->EncodeMax();
-
-  // encoded is same as unencoded
+void TestStatistics<ByteArrayType>::testMinMaxEncode() {
+  this->generateData(1000);
+  // Test that we encode min max strings correctly.
+  auto statistics1 = makeStatistics<ByteArrayType>(this->schema_.column(0));
+  statistics1->update(this->valuesPtr_, this->values_.size(), 0);
+  std::string encodedMin = statistics1->encodeMin();
+  std::string encodedMax = statistics1->encodeMax();
+
+  // Encoded is same as unencoded.
   ASSERT_EQ(
-      encoded_min,
+      encodedMin,
       std::string(
           reinterpret_cast<const char*>(statistics1->min().ptr),
           statistics1->min().len));
   ASSERT_EQ(
-      encoded_max,
+      encodedMax,
       std::string(
           reinterpret_cast<const char*>(statistics1->max().ptr),
           statistics1->max().len));
 
-  auto statistics2 = MakeStatistics<ByteArrayType>(
-      this->schema_.Column(0),
-      encoded_min,
-      encoded_max,
+  auto statistics2 = makeStatistics<ByteArrayType>(
+      this->schema_.column(0),
+      encodedMin,
+      encodedMax,
       this->values_.size(),
-      0,
-      0,
-      true,
-      true,
-      true);
-
-  ASSERT_EQ(encoded_min, statistics2->EncodeMin());
-  ASSERT_EQ(encoded_max, statistics2->EncodeMax());
+      0, // nullCount
+      0, // distinctCount
+      true, // hasMinMax
+      true, // hasNullCount
+      true, // hasDistinctCount
+      false, // hasNaNCount
+      0); // nanCount
+
+  ASSERT_EQ(encodedMin, statistics2->encodeMin());
+  ASSERT_EQ(encodedMax, statistics2->encodeMax());
   ASSERT_EQ(statistics1->min(), statistics2->min());
   ASSERT_EQ(statistics1->max(), statistics2->max());
 }
@@ -632,25 +639,25 @@ using Types = ::testing::Types<
 TYPED_TEST_SUITE(TestStatistics, Types);
 
 TYPED_TEST(TestStatistics, MinMaxEncode) {
-  this->SetUpSchema(Repetition::REQUIRED);
-  ASSERT_NO_FATAL_FAILURE(this->TestMinMaxEncode());
+  this->setUpSchema(Repetition::kRequired);
+  ASSERT_NO_FATAL_FAILURE(this->testMinMaxEncode());
 }
 
-TYPED_TEST(TestStatistics, Reset) {
-  this->SetUpSchema(Repetition::OPTIONAL);
-  ASSERT_NO_FATAL_FAILURE(this->TestReset());
+TYPED_TEST(TestStatistics, reset) {
+  this->setUpSchema(Repetition::kOptional);
+  ASSERT_NO_FATAL_FAILURE(this->testReset());
 }
 
-TYPED_TEST(TestStatistics, Equals) {
-  this->SetUpSchema(Repetition::OPTIONAL);
-  ASSERT_NO_FATAL_FAILURE(this->TestEquals());
+TYPED_TEST(TestStatistics, equals) {
+  this->setUpSchema(Repetition::kOptional);
+  ASSERT_NO_FATAL_FAILURE(this->testEquals());
 }
 
 TYPED_TEST(TestStatistics, FullRoundtrip) {
-  this->SetUpSchema(Repetition::OPTIONAL);
-  ASSERT_NO_FATAL_FAILURE(this->TestFullRoundtrip(100, 31));
-  ASSERT_NO_FATAL_FAILURE(this->TestFullRoundtrip(1000, 415));
-  ASSERT_NO_FATAL_FAILURE(this->TestFullRoundtrip(10000, 926));
+  this->setUpSchema(Repetition::kOptional);
+  ASSERT_NO_FATAL_FAILURE(this->testFullRoundtrip(100, 31));
+  ASSERT_NO_FATAL_FAILURE(this->testFullRoundtrip(1000, 415));
+  ASSERT_NO_FATAL_FAILURE(this->testFullRoundtrip(10000, 926));
 }
 
 template <typename TestType>
@@ -661,113 +668,103 @@ using NumericTypes =
 
 TYPED_TEST_SUITE(TestNumericStatistics, NumericTypes);
 
-TYPED_TEST(TestNumericStatistics, Merge) {
-  this->SetUpSchema(Repetition::OPTIONAL);
-  ASSERT_NO_FATAL_FAILURE(this->TestMerge());
+TYPED_TEST(TestNumericStatistics, merge) {
+  this->setUpSchema(Repetition::kOptional);
+  ASSERT_NO_FATAL_FAILURE(this->testMerge());
 }
 
-TYPED_TEST(TestNumericStatistics, Equals) {
-  this->SetUpSchema(Repetition::OPTIONAL);
-  ASSERT_NO_FATAL_FAILURE(this->TestEquals());
+TYPED_TEST(TestNumericStatistics, equals) {
+  this->setUpSchema(Repetition::kOptional);
+  ASSERT_NO_FATAL_FAILURE(this->testEquals());
 }
 
 template <typename TestType>
 class TestStatisticsHasFlag : public TestStatistics<TestType> {
  public:
   void SetUp() override {
-    TestStatistics<TestType>::SetUp();
-    this->SetUpSchema(Repetition::OPTIONAL);
+    this->setUpSchema(Repetition::kOptional);
   }
 
-  std::shared_ptr<TypedStatistics<TestType>> MergedStatistics(
+  std::shared_ptr<TypedStatistics<TestType>> mergedStatistics(
       const TypedStatistics<TestType>& stats1,
       const TypedStatistics<TestType>& stats2) {
-    auto chunk_statistics = MakeStatistics<TestType>(this->schema_.Column(0));
-    chunk_statistics->Merge(stats1);
-    chunk_statistics->Merge(stats2);
-    return chunk_statistics;
+    auto chunkStatistics = makeStatistics<TestType>(this->schema_.column(0));
+    chunkStatistics->merge(stats1);
+    chunkStatistics->merge(stats2);
+    return chunkStatistics;
   }
 
-  void VerifyMergedStatistics(
+  void verifyMergedStatistics(
       const TypedStatistics<TestType>& stats1,
       const TypedStatistics<TestType>& stats2,
-      const std::function<void(TypedStatistics<TestType>*)>& test_fn) {
-    ASSERT_NO_FATAL_FAILURE(test_fn(MergedStatistics(stats1, stats2).get()));
-    ASSERT_NO_FATAL_FAILURE(test_fn(MergedStatistics(stats2, stats1).get()));
+      const std::function<void(TypedStatistics<TestType>*)>& testFn) {
+    ASSERT_NO_FATAL_FAILURE(testFn(mergedStatistics(stats1, stats2).get()));
+    ASSERT_NO_FATAL_FAILURE(testFn(mergedStatistics(stats2, stats1).get()));
   }
 
   // Distinct count should set to false when Merge is called.
-  void TestMergeDistinctCount() {
+  void testMergeDistinctCount() {
     // Create a statistics object with distinct count.
     std::shared_ptr<TypedStatistics<TestType>> statistics1;
     {
-      EncodedStatistics encoded_statistics1;
-      statistics1 =
-          std::dynamic_pointer_cast<TypedStatistics<TestType>>(Statistics::Make(
-              this->schema_.Column(0),
-              &encoded_statistics1,
-              /*num_values=*/1000));
-      EXPECT_FALSE(statistics1->HasDistinctCount());
+      EncodedStatistics encodedStatistics1;
+      statistics1 = std::dynamic_pointer_cast<TypedStatistics<TestType>>(
+          Statistics::make(this->schema_.column(0), &encodedStatistics1, 1000));
+      EXPECT_FALSE(statistics1->hasDistinctCount());
     }
 
     // Create a statistics object with distinct count.
     std::shared_ptr<TypedStatistics<TestType>> statistics2;
     {
-      EncodedStatistics encoded_statistics2;
-      encoded_statistics2.has_distinct_count = true;
-      encoded_statistics2.distinct_count = 500;
-      statistics2 =
-          std::dynamic_pointer_cast<TypedStatistics<TestType>>(Statistics::Make(
-              this->schema_.Column(0),
-              &encoded_statistics2,
-              /*num_values=*/1000));
-      EXPECT_TRUE(statistics2->HasDistinctCount());
+      EncodedStatistics encodedStatistics2;
+      encodedStatistics2.hasDistinctCount = true;
+      encodedStatistics2.distinctCount = 500;
+      statistics2 = std::dynamic_pointer_cast<TypedStatistics<TestType>>(
+          Statistics::make(this->schema_.column(0), &encodedStatistics2, 1000));
+      EXPECT_TRUE(statistics2->hasDistinctCount());
     }
 
-    VerifyMergedStatistics(
+    verifyMergedStatistics(
         *statistics1,
         *statistics2,
-        [](TypedStatistics<TestType>* merged_statistics) {
-          EXPECT_FALSE(merged_statistics->HasDistinctCount());
-          EXPECT_FALSE(merged_statistics->Encode().has_distinct_count);
+        [](TypedStatistics<TestType>* mergedStatistics) {
+          EXPECT_FALSE(mergedStatistics->hasDistinctCount());
+          EXPECT_FALSE(mergedStatistics->encode().hasDistinctCount);
         });
   }
 
   // If all values in a page are null or nan, its stats should not set min-max.
   // Merging its stats with another page having good min-max stats should not
   // drop the valid min-max from the latter page.
-  void TestMergeMinMax() {
-    this->GenerateData(1000);
+  void testMergeMinMax() {
+    this->generateData(1000);
     // Create a statistics object without min-max.
     std::shared_ptr<TypedStatistics<TestType>> statistics1;
     {
-      statistics1 = MakeStatistics<TestType>(this->schema_.Column(0));
-      statistics1->Update(
-          this->values_ptr_,
-          /*num_values=*/0,
-          /*null_count=*/this->values_.size());
-      auto encoded_stats1 = statistics1->Encode();
-      EXPECT_FALSE(statistics1->HasMinMax());
-      EXPECT_FALSE(encoded_stats1.has_min);
-      EXPECT_FALSE(encoded_stats1.has_max);
+      statistics1 = makeStatistics<TestType>(this->schema_.column(0));
+      statistics1->update(this->valuesPtr_, 0, this->values_.size());
+      auto encodedStats1 = statistics1->encode();
+      EXPECT_FALSE(statistics1->hasMinMax());
+      EXPECT_FALSE(encodedStats1.hasMin);
+      EXPECT_FALSE(encodedStats1.hasMax);
     }
     // Create a statistics object with min-max.
     std::shared_ptr<TypedStatistics<TestType>> statistics2;
     {
-      statistics2 = MakeStatistics<TestType>(this->schema_.Column(0));
-      statistics2->Update(this->values_ptr_, this->values_.size(), 0);
-      auto encoded_stats2 = statistics2->Encode();
-      EXPECT_TRUE(statistics2->HasMinMax());
-      EXPECT_TRUE(encoded_stats2.has_min);
-      EXPECT_TRUE(encoded_stats2.has_max);
+      statistics2 = makeStatistics<TestType>(this->schema_.column(0));
+      statistics2->update(this->valuesPtr_, this->values_.size(), 0);
+      auto encodedStats2 = statistics2->encode();
+      EXPECT_TRUE(statistics2->hasMinMax());
+      EXPECT_TRUE(encodedStats2.hasMin);
+      EXPECT_TRUE(encodedStats2.hasMax);
     }
-    VerifyMergedStatistics(
+    verifyMergedStatistics(
         *statistics1,
         *statistics2,
-        [](TypedStatistics<TestType>* merged_statistics) {
-          EXPECT_TRUE(merged_statistics->HasMinMax());
-          EXPECT_TRUE(merged_statistics->Encode().has_min);
-          EXPECT_TRUE(merged_statistics->Encode().has_max);
+        [](TypedStatistics<TestType>* mergedStatistics) {
+          EXPECT_TRUE(mergedStatistics->hasMinMax());
+          EXPECT_TRUE(mergedStatistics->encode().hasMin);
+          EXPECT_TRUE(mergedStatistics->encode().hasMax);
         });
   }
 
@@ -775,254 +772,275 @@ class TestStatisticsHasFlag : public TestStatistics<TestType> {
   // However, if statistics is created from thrift message, it might not
   // have null_count. Merging statistics from such page will result in an
   // invalid null_count as well.
-  void TestMergeNullCount() {
-    this->GenerateData(/*num_values=*/1000);
+  void testMergeNullCount() {
+    this->generateData(1000);
 
-    // Page should have null-count even if no nulls
+    // Page should have null-count even if no nulls.
     std::shared_ptr<TypedStatistics<TestType>> statistics1;
     {
-      statistics1 = MakeStatistics<TestType>(this->schema_.Column(0));
-      statistics1->Update(
-          this->values_ptr_,
-          /*num_values=*/this->values_.size(),
-          /*null_count=*/0);
-      auto encoded_stats1 = statistics1->Encode();
-      EXPECT_TRUE(statistics1->HasNullCount());
-      EXPECT_EQ(0, statistics1->null_count());
-      EXPECT_TRUE(statistics1->Encode().has_null_count);
+      statistics1 = makeStatistics<TestType>(this->schema_.column(0));
+      statistics1->update(this->valuesPtr_, this->values_.size(), 0);
+      auto encodedStats1 = statistics1->encode();
+      EXPECT_TRUE(statistics1->hasNullCount());
+      EXPECT_EQ(0, statistics1->nullCount());
+      EXPECT_TRUE(statistics1->encode().hasNullCount);
     }
-    // Merge with null-count should also have null count
-    VerifyMergedStatistics(
+    // Merge with null-count should also have null count.
+    verifyMergedStatistics(
         *statistics1,
         *statistics1,
-        [](TypedStatistics<TestType>* merged_statistics) {
-          EXPECT_TRUE(merged_statistics->HasNullCount());
-          EXPECT_EQ(0, merged_statistics->null_count());
-          auto encoded = merged_statistics->Encode();
-          EXPECT_TRUE(encoded.has_null_count);
-          EXPECT_EQ(0, encoded.null_count);
+        [](TypedStatistics<TestType>* mergedStatistics) {
+          EXPECT_TRUE(mergedStatistics->hasNullCount());
+          EXPECT_EQ(0, mergedStatistics->nullCount());
+          auto encoded = mergedStatistics->encode();
+          EXPECT_TRUE(encoded.hasNullCount);
+          EXPECT_EQ(0, encoded.nullCount);
         });
 
     // When loaded from thrift, might not have null count.
     std::shared_ptr<TypedStatistics<TestType>> statistics2;
     {
-      EncodedStatistics encoded_statistics2;
-      encoded_statistics2.has_null_count = false;
-      statistics2 =
-          std::dynamic_pointer_cast<TypedStatistics<TestType>>(Statistics::Make(
-              this->schema_.Column(0),
-              &encoded_statistics2,
-              /*num_values=*/1000));
-      EXPECT_FALSE(statistics2->Encode().has_null_count);
-      EXPECT_FALSE(statistics2->HasNullCount());
+      EncodedStatistics encodedStatistics2;
+      encodedStatistics2.hasNullCount = false;
+      statistics2 = std::dynamic_pointer_cast<TypedStatistics<TestType>>(
+          Statistics::make(this->schema_.column(0), &encodedStatistics2, 1000));
+      EXPECT_FALSE(statistics2->encode().hasNullCount);
+      EXPECT_FALSE(statistics2->hasNullCount());
     }
 
-    // Merge without null-count should not have null count
-    VerifyMergedStatistics(
+    // Merge without null-count should not have null count.
+    verifyMergedStatistics(
         *statistics1,
         *statistics2,
-        [](TypedStatistics<TestType>* merged_statistics) {
-          EXPECT_FALSE(merged_statistics->HasNullCount());
-          EXPECT_FALSE(merged_statistics->Encode().has_null_count);
+        [](TypedStatistics<TestType>* mergedStatistics) {
+          EXPECT_FALSE(mergedStatistics->hasNullCount());
+          EXPECT_FALSE(mergedStatistics->encode().hasNullCount);
         });
   }
 
-  // statistics.all_null_value is used to build the page index.
+  // Statistics.all_null_value is used to build the page index.
   // If statistics doesn't have null count, all_null_value should be false.
-  void TestMissingNullCount() {
-    EncodedStatistics encoded_statistics;
-    encoded_statistics.has_null_count = false;
-    auto statistics = Statistics::Make(
-        this->schema_.Column(0),
-        &encoded_statistics,
-        /*num_values=*/1000);
-    auto typed_stats =
-        std::dynamic_pointer_cast<TypedStatistics<TestType>>(statistics);
-    EXPECT_FALSE(typed_stats->HasNullCount());
-    auto encoded = typed_stats->Encode();
-    EXPECT_FALSE(encoded.all_null_value);
-    EXPECT_FALSE(encoded.has_null_count);
-    EXPECT_FALSE(encoded.has_distinct_count);
-    EXPECT_FALSE(encoded.has_min);
-    EXPECT_FALSE(encoded.has_max);
+  void testMissingNullCount() {
+    EncodedStatistics EncodedStatistics;
+    EncodedStatistics.hasNullCount = false;
+    auto Statistics =
+        Statistics::make(this->schema_.column(0), &EncodedStatistics, 1000);
+    auto typedStats =
+        std::dynamic_pointer_cast<TypedStatistics<TestType>>(Statistics);
+    EXPECT_FALSE(typedStats->hasNullCount());
+    auto encoded = typedStats->encode();
+    EXPECT_FALSE(encoded.allNullValue);
+    EXPECT_FALSE(encoded.hasNullCount);
+    EXPECT_FALSE(encoded.hasDistinctCount);
+    EXPECT_FALSE(encoded.hasMin);
+    EXPECT_FALSE(encoded.hasMax);
   }
 };
 
 TYPED_TEST_SUITE(TestStatisticsHasFlag, Types);
 
 TYPED_TEST(TestStatisticsHasFlag, MergeDistinctCount) {
-  ASSERT_NO_FATAL_FAILURE(this->TestMergeDistinctCount());
+  ASSERT_NO_FATAL_FAILURE(this->testMergeDistinctCount());
 }
 
 TYPED_TEST(TestStatisticsHasFlag, MergeNullCount) {
-  ASSERT_NO_FATAL_FAILURE(this->TestMergeNullCount());
+  ASSERT_NO_FATAL_FAILURE(this->testMergeNullCount());
 }
 
 TYPED_TEST(TestStatisticsHasFlag, MergeMinMax) {
-  ASSERT_NO_FATAL_FAILURE(this->TestMergeMinMax());
+  ASSERT_NO_FATAL_FAILURE(this->testMergeMinMax());
 }
 
 TYPED_TEST(TestStatisticsHasFlag, MissingNullCount) {
-  ASSERT_NO_FATAL_FAILURE(this->TestMissingNullCount());
+  ASSERT_NO_FATAL_FAILURE(this->testMissingNullCount());
 }
 
-// Helper for basic statistics tests below
-void AssertStatsSet(
+// Helper for basic statistics tests below.
+void assertStatsSet(
     const ApplicationVersion& version,
     std::shared_ptr<WriterProperties> props,
     const ColumnDescriptor* column,
-    bool expected_is_set) {
-  auto metadata_builder = ColumnChunkMetaDataBuilder::Make(props, column);
-  auto column_chunk = ColumnChunkMetaData::Make(
-      metadata_builder->contents(),
-      column,
-      default_reader_properties(),
-      &version);
+    bool expectedIsSet) {
+  auto metadataBuilder = ColumnChunkMetaDataBuilder::make(props, column);
+  auto columnChunk = ColumnChunkMetaData::make(
+      metadataBuilder->Contents(), column, defaultReaderProperties(), &version);
   EncodedStatistics stats;
-  stats.set_is_signed(false);
-  metadata_builder->SetStatistics(stats);
-  ASSERT_EQ(column_chunk->is_stats_set(), expected_is_set);
+  stats.setIsSigned(false);
+  metadataBuilder->setStatistics(stats);
+  ASSERT_EQ(columnChunk->isStatsSet(), expectedIsSet);
 }
 
-// Statistics are restricted for few types in older parquet version
+// Statistics are restricted for few types in older parquet version.
 TEST(CorruptStatistics, Basics) {
-  std::string created_by = "parquet-mr version 1.8.0";
-  ApplicationVersion version(created_by);
+  std::string createdBy = "parquet-mr version 1.8.0";
+  ApplicationVersion version(createdBy);
   SchemaDescriptor schema;
-  schema::NodePtr node;
+  schema::NodePtr Node;
   std::vector<schema::NodePtr> fields;
-  // Test Physical Types
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col1", Repetition::OPTIONAL, Type::INT32, ConvertedType::NONE));
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col2", Repetition::OPTIONAL, Type::BYTE_ARRAY, ConvertedType::NONE));
-  // Test Logical Types
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col3", Repetition::OPTIONAL, Type::INT32, ConvertedType::DATE));
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col4", Repetition::OPTIONAL, Type::INT32, ConvertedType::UINT_32));
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col5",
-      Repetition::OPTIONAL,
-      Type::FIXED_LEN_BYTE_ARRAY,
-      ConvertedType::INTERVAL,
-      12));
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col6", Repetition::OPTIONAL, Type::BYTE_ARRAY, ConvertedType::UTF8));
-  node = schema::GroupNode::Make("schema", Repetition::REQUIRED, fields);
-  schema.Init(node);
-
-  WriterProperties::Builder builder;
-  builder.created_by(created_by);
-  std::shared_ptr<WriterProperties> props = builder.build();
-
-  AssertStatsSet(version, props, schema.Column(0), true);
-  AssertStatsSet(version, props, schema.Column(1), false);
-  AssertStatsSet(version, props, schema.Column(2), true);
-  AssertStatsSet(version, props, schema.Column(3), false);
-  AssertStatsSet(version, props, schema.Column(4), false);
-  AssertStatsSet(version, props, schema.Column(5), false);
-}
-
-// Statistics for all types have no restrictions in newer parquet version
+  // Test Physical Types.
+  fields.push_back(
+      schema::PrimitiveNode::make(
+          "col1", Repetition::kOptional, Type::kInt32, ConvertedType::kNone));
+  fields.push_back(
+      schema::PrimitiveNode::make(
+          "col2",
+          Repetition::kOptional,
+          Type::kByteArray,
+          ConvertedType::kNone));
+  // Test Logical Types.
+  fields.push_back(
+      schema::PrimitiveNode::make(
+          "col3", Repetition::kOptional, Type::kInt32, ConvertedType::kDate));
+  fields.push_back(
+      schema::PrimitiveNode::make(
+          "col4", Repetition::kOptional, Type::kInt32, ConvertedType::kUint32));
+  fields.push_back(
+      schema::PrimitiveNode::make(
+          "col5",
+          Repetition::kOptional,
+          Type::kFixedLenByteArray,
+          ConvertedType::kInterval,
+          12));
+  fields.push_back(
+      schema::PrimitiveNode::make(
+          "col6",
+          Repetition::kOptional,
+          Type::kByteArray,
+          ConvertedType::kUtf8));
+  Node = schema::GroupNode::make("schema", Repetition::kRequired, fields);
+  schema.init(Node);
+
+  WriterProperties::Builder Builder;
+  Builder.createdBy(createdBy);
+  std::shared_ptr<WriterProperties> props = Builder.build();
+
+  assertStatsSet(version, props, schema.column(0), true);
+  assertStatsSet(version, props, schema.column(1), false);
+  assertStatsSet(version, props, schema.column(2), true);
+  assertStatsSet(version, props, schema.column(3), false);
+  assertStatsSet(version, props, schema.column(4), false);
+  assertStatsSet(version, props, schema.column(5), false);
+}
+
+// Statistics for all types have no restrictions in newer parquet version.
 TEST(CorrectStatistics, Basics) {
-  std::string created_by = "parquet-cpp version 1.3.0";
-  ApplicationVersion version(created_by);
+  std::string createdBy = "parquet-cpp version 1.3.0";
+  ApplicationVersion version(createdBy);
   SchemaDescriptor schema;
-  schema::NodePtr node;
+  schema::NodePtr Node;
   std::vector<schema::NodePtr> fields;
-  // Test Physical Types
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col1", Repetition::OPTIONAL, Type::INT32, ConvertedType::NONE));
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col2", Repetition::OPTIONAL, Type::BYTE_ARRAY, ConvertedType::NONE));
-  // Test Logical Types
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col3", Repetition::OPTIONAL, Type::INT32, ConvertedType::DATE));
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col4", Repetition::OPTIONAL, Type::INT32, ConvertedType::UINT_32));
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col5",
-      Repetition::OPTIONAL,
-      Type::FIXED_LEN_BYTE_ARRAY,
-      ConvertedType::INTERVAL,
-      12));
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col6", Repetition::OPTIONAL, Type::BYTE_ARRAY, ConvertedType::UTF8));
-  node = schema::GroupNode::Make("schema", Repetition::REQUIRED, fields);
-  schema.Init(node);
-
-  WriterProperties::Builder builder;
-  builder.created_by(created_by);
-  std::shared_ptr<WriterProperties> props = builder.build();
-
-  AssertStatsSet(version, props, schema.Column(0), true);
-  AssertStatsSet(version, props, schema.Column(1), true);
-  AssertStatsSet(version, props, schema.Column(2), true);
-  AssertStatsSet(version, props, schema.Column(3), true);
-  AssertStatsSet(version, props, schema.Column(4), false);
-  AssertStatsSet(version, props, schema.Column(5), true);
-}
-
-// Test SortOrder class
+  // Test Physical Types.
+  fields.push_back(
+      schema::PrimitiveNode::make(
+          "col1", Repetition::kOptional, Type::kInt32, ConvertedType::kNone));
+  fields.push_back(
+      schema::PrimitiveNode::make(
+          "col2",
+          Repetition::kOptional,
+          Type::kByteArray,
+          ConvertedType::kNone));
+  // Test Logical Types.
+  fields.push_back(
+      schema::PrimitiveNode::make(
+          "col3", Repetition::kOptional, Type::kInt32, ConvertedType::kDate));
+  fields.push_back(
+      schema::PrimitiveNode::make(
+          "col4", Repetition::kOptional, Type::kInt32, ConvertedType::kUint32));
+  fields.push_back(
+      schema::PrimitiveNode::make(
+          "col5",
+          Repetition::kOptional,
+          Type::kFixedLenByteArray,
+          ConvertedType::kInterval,
+          12));
+  fields.push_back(
+      schema::PrimitiveNode::make(
+          "col6",
+          Repetition::kOptional,
+          Type::kByteArray,
+          ConvertedType::kUtf8));
+  Node = schema::GroupNode::make("schema", Repetition::kRequired, fields);
+  schema.init(Node);
+
+  WriterProperties::Builder Builder;
+  Builder.createdBy(createdBy);
+  std::shared_ptr<WriterProperties> props = Builder.build();
+
+  assertStatsSet(version, props, schema.column(0), true);
+  assertStatsSet(version, props, schema.column(1), true);
+  assertStatsSet(version, props, schema.column(2), true);
+  assertStatsSet(version, props, schema.column(3), true);
+  assertStatsSet(version, props, schema.column(4), false);
+  assertStatsSet(version, props, schema.column(5), true);
+}
+
+// Test SortOrder class.
 static const int NUM_VALUES = 10;
 
 template <typename TestType>
 class TestStatisticsSortOrder : public ::testing::Test {
  public:
-  using c_type = typename TestType::c_type;
-
-  void AddNodes(std::string name) {
-    fields_.push_back(schema::PrimitiveNode::Make(
-        name, Repetition::REQUIRED, TestType::type_num, ConvertedType::NONE));
+  using CType = typename TestType::CType;
+
+  void addNodes(std::string name) {
+    fields_.push_back(
+        schema::PrimitiveNode::make(
+            name,
+            Repetition::kRequired,
+            TestType::typeNum,
+            ConvertedType::kNone));
   }
 
-  void SetUpSchema() {
+  void setUpSchema() {
     stats_.resize(fields_.size());
     values_.resize(NUM_VALUES);
     schema_ = std::static_pointer_cast<GroupNode>(
-        GroupNode::Make("Schema", Repetition::REQUIRED, fields_));
+        GroupNode::make("Schema", Repetition::kRequired, fields_));
 
-    parquet_sink_ = CreateOutputStream();
+    parquetSink_ = createOutputStream();
   }
 
-  void SetValues();
+  void setValues();
 
-  void WriteParquet() {
-    // Add writer properties
-    WriterProperties::Builder builder;
-    builder.compression(Compression::SNAPPY);
-    builder.created_by("parquet-cpp version 1.3.0");
-    std::shared_ptr<WriterProperties> props = builder.build();
+  void writeParquet() {
+    // Add writer properties.
+    WriterProperties::Builder Builder;
+    Builder.compression(Compression::SNAPPY);
+    Builder.createdBy("parquet-cpp version 1.3.0");
+    std::shared_ptr<WriterProperties> props = Builder.build();
 
-    // Create a ParquetFileWriter instance
-    auto file_writer = ParquetFileWriter::Open(parquet_sink_, schema_, props);
+    // Create a ParquetFileWriter instance.
+    auto fileWriter = ParquetFileWriter::open(parquetSink_, schema_, props);
 
     // Append a RowGroup with a specific number of rows.
-    auto rg_writer = file_writer->AppendRowGroup();
+    auto rgWriter = fileWriter->appendRowGroup();
 
-    this->SetValues();
+    this->setValues();
 
-    // Insert Values
+    // Insert Values.
     for (int i = 0; i < static_cast<int>(fields_.size()); i++) {
-      auto column_writer =
-          static_cast<TypedColumnWriter<TestType>*>(rg_writer->NextColumn());
-      column_writer->WriteBatch(NUM_VALUES, nullptr, nullptr, values_.data());
+      auto columnWriter =
+          static_cast<TypedColumnWriter<TestType>*>(rgWriter->nextColumn());
+      columnWriter->writeBatch(NUM_VALUES, nullptr, nullptr, values_.data());
     }
   }
 
-  void VerifyParquetStats() {
-    ASSERT_OK_AND_ASSIGN(auto pbuffer, parquet_sink_->Finish());
+  void verifyParquetStats() {
+    ASSERT_OK_AND_ASSIGN(auto pbuffer, parquetSink_->Finish());
 
-    // Write the pbuffer to a temp file
-    auto filePath = exec::test::TempFilePath::create();
+    // Write the pbuffer to a temp file.
+    auto filePath = TempFilePath::create();
     writeToFile(filePath, pbuffer);
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
     std::shared_ptr<facebook::velox::memory::MemoryPool> rootPool =
         memory::memoryManager()->addRootPool("StatisticsTest");
     std::shared_ptr<facebook::velox::memory::MemoryPool> leafPool =
         rootPool->addLeafChild("StatisticsTest");
-    dwio::common::ReaderOptions readerOptions{leafPool.get()};
+    auto dataIoStats = std::make_shared<velox::io::IoStatistics>();
+    auto metadataIoStats = std::make_shared<velox::io::IoStatistics>();
+    dwio::common::ReaderOptions readerOptions(leafPool.get());
+    readerOptions.setDataIoStats(dataIoStats);
+    readerOptions.setMetadataIoStats(metadataIoStats);
     auto input = std::make_unique<dwio::common::BufferedInput>(
         std::make_shared<LocalReadFile>(filePath->getPath()),
         readerOptions.memoryPool());
@@ -1038,126 +1056,143 @@ class TestStatisticsSortOrder : public ::testing::Test {
   }
 
  protected:
-  std::vector<c_type> values_;
-  std::vector<uint8_t> values_buf_;
+  std::vector<CType> values_;
+  std::vector<uint8_t> valuesBuf_;
   std::vector<schema::NodePtr> fields_;
   std::shared_ptr<schema::GroupNode> schema_;
-  std::shared_ptr<::arrow::io::BufferOutputStream> parquet_sink_;
+  std::shared_ptr<::arrow::io::BufferOutputStream> parquetSink_;
   std::vector<EncodedStatistics> stats_;
 };
 
 using CompareTestTypes = ::testing::
     Types<Int32Type, Int64Type, FloatType, DoubleType, ByteArrayType, FLBAType>;
 
-// TYPE::INT32
+// TYPE::INT32.
 template <>
-void TestStatisticsSortOrder<Int32Type>::AddNodes(std::string name) {
-  // UINT_32 logical type to set Unsigned Statistics
-  fields_.push_back(schema::PrimitiveNode::Make(
-      name, Repetition::REQUIRED, Type::INT32, ConvertedType::UINT_32));
-  // INT_32 logical type to set Signed Statistics
-  fields_.push_back(schema::PrimitiveNode::Make(
-      name, Repetition::REQUIRED, Type::INT32, ConvertedType::INT_32));
+void TestStatisticsSortOrder<Int32Type>::addNodes(std::string name) {
+  // UINT_32 logical type to set Unsigned Statistics.
+  fields_.push_back(
+      schema::PrimitiveNode::make(
+          name, Repetition::kRequired, Type::kInt32, ConvertedType::kUint32));
+  // INT_32 logical type to set Signed Statistics.
+  fields_.push_back(
+      schema::PrimitiveNode::make(
+          name, Repetition::kRequired, Type::kInt32, ConvertedType::kInt32));
 }
 
 template <>
-void TestStatisticsSortOrder<Int32Type>::SetValues() {
+void TestStatisticsSortOrder<Int32Type>::setValues() {
   for (int i = 0; i < NUM_VALUES; i++) {
     values_[i] = i - 5; // {-5, -4, -3, -2, -1, 0, 1, 2, 3, 4};
   }
 
-  // Write UINT32 min/max values
+  // Write UINT32 min/max values.
   stats_[0]
-      .set_min(std::string(
-          reinterpret_cast<const char*>(&values_[5]), sizeof(c_type)))
-      .set_max(std::string(
-          reinterpret_cast<const char*>(&values_[4]), sizeof(c_type)));
-
-  // Write INT32 min/max values
+      .setMin(
+          std::string(
+              reinterpret_cast<const char*>(&values_[5]), sizeof(CType)))
+      .setMax(
+          std::string(
+              reinterpret_cast<const char*>(&values_[4]), sizeof(CType)));
+
+  // Write INT32 min/max values.
   stats_[1]
-      .set_min(std::string(
-          reinterpret_cast<const char*>(&values_[0]), sizeof(c_type)))
-      .set_max(std::string(
-          reinterpret_cast<const char*>(&values_[9]), sizeof(c_type)));
+      .setMin(
+          std::string(
+              reinterpret_cast<const char*>(&values_[0]), sizeof(CType)))
+      .setMax(
+          std::string(
+              reinterpret_cast<const char*>(&values_[9]), sizeof(CType)));
 }
 
-// TYPE::INT64
+// TYPE::INT64.
 template <>
-void TestStatisticsSortOrder<Int64Type>::AddNodes(std::string name) {
-  // UINT_64 logical type to set Unsigned Statistics
-  fields_.push_back(schema::PrimitiveNode::Make(
-      name, Repetition::REQUIRED, Type::INT64, ConvertedType::UINT_64));
-  // INT_64 logical type to set Signed Statistics
-  fields_.push_back(schema::PrimitiveNode::Make(
-      name, Repetition::REQUIRED, Type::INT64, ConvertedType::INT_64));
+void TestStatisticsSortOrder<Int64Type>::addNodes(std::string name) {
+  // UINT_64 logical type to set Unsigned Statistics.
+  fields_.push_back(
+      schema::PrimitiveNode::make(
+          name, Repetition::kRequired, Type::kInt64, ConvertedType::kUint64));
+  // INT_64 logical type to set Signed Statistics.
+  fields_.push_back(
+      schema::PrimitiveNode::make(
+          name, Repetition::kRequired, Type::kInt64, ConvertedType::kInt64));
 }
 
 template <>
-void TestStatisticsSortOrder<Int64Type>::SetValues() {
+void TestStatisticsSortOrder<Int64Type>::setValues() {
   for (int i = 0; i < NUM_VALUES; i++) {
     values_[i] = i - 5; // {-5, -4, -3, -2, -1, 0, 1, 2, 3, 4};
   }
 
-  // Write UINT64 min/max values
+  // Write UINT64 min/max values.
   stats_[0]
-      .set_min(std::string(
-          reinterpret_cast<const char*>(&values_[5]), sizeof(c_type)))
-      .set_max(std::string(
-          reinterpret_cast<const char*>(&values_[4]), sizeof(c_type)));
-
-  // Write INT64 min/max values
+      .setMin(
+          std::string(
+              reinterpret_cast<const char*>(&values_[5]), sizeof(CType)))
+      .setMax(
+          std::string(
+              reinterpret_cast<const char*>(&values_[4]), sizeof(CType)));
+
+  // Write INT64 min/max values.
   stats_[1]
-      .set_min(std::string(
-          reinterpret_cast<const char*>(&values_[0]), sizeof(c_type)))
-      .set_max(std::string(
-          reinterpret_cast<const char*>(&values_[9]), sizeof(c_type)));
+      .setMin(
+          std::string(
+              reinterpret_cast<const char*>(&values_[0]), sizeof(CType)))
+      .setMax(
+          std::string(
+              reinterpret_cast<const char*>(&values_[9]), sizeof(CType)));
 }
 
-// TYPE::FLOAT
+// TYPE::FLOAT.
 template <>
-void TestStatisticsSortOrder<FloatType>::SetValues() {
+void TestStatisticsSortOrder<FloatType>::setValues() {
   for (int i = 0; i < NUM_VALUES; i++) {
     values_[i] = static_cast<float>(i) -
         5; // {-5.0, -4.0, -3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0, 4.0};
   }
 
-  // Write Float min/max values
+  // Write Float min/max values.
   stats_[0]
-      .set_min(std::string(
-          reinterpret_cast<const char*>(&values_[0]), sizeof(c_type)))
-      .set_max(std::string(
-          reinterpret_cast<const char*>(&values_[9]), sizeof(c_type)));
+      .setMin(
+          std::string(
+              reinterpret_cast<const char*>(&values_[0]), sizeof(CType)))
+      .setMax(
+          std::string(
+              reinterpret_cast<const char*>(&values_[9]), sizeof(CType)));
 }
 
-// TYPE::DOUBLE
+// TYPE::DOUBLE.
 template <>
-void TestStatisticsSortOrder<DoubleType>::SetValues() {
+void TestStatisticsSortOrder<DoubleType>::setValues() {
   for (int i = 0; i < NUM_VALUES; i++) {
     values_[i] = static_cast<float>(i) -
         5; // {-5.0, -4.0, -3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0, 4.0};
   }
 
-  // Write Double min/max values
+  // Write Double min/max values.
   stats_[0]
-      .set_min(std::string(
-          reinterpret_cast<const char*>(&values_[0]), sizeof(c_type)))
-      .set_max(std::string(
-          reinterpret_cast<const char*>(&values_[9]), sizeof(c_type)));
+      .setMin(
+          std::string(
+              reinterpret_cast<const char*>(&values_[0]), sizeof(CType)))
+      .setMax(
+          std::string(
+              reinterpret_cast<const char*>(&values_[9]), sizeof(CType)));
 }
 
-// TYPE::ByteArray
+// TYPE::ByteArray.
 template <>
-void TestStatisticsSortOrder<ByteArrayType>::AddNodes(std::string name) {
-  // UTF8 logical type to set Unsigned Statistics
-  fields_.push_back(schema::PrimitiveNode::Make(
-      name, Repetition::REQUIRED, Type::BYTE_ARRAY, ConvertedType::UTF8));
+void TestStatisticsSortOrder<ByteArrayType>::addNodes(std::string name) {
+  // UTF8 logical type to set Unsigned Statistics.
+  fields_.push_back(
+      schema::PrimitiveNode::make(
+          name, Repetition::kRequired, Type::kByteArray, ConvertedType::kUtf8));
 }
 
 template <>
-void TestStatisticsSortOrder<ByteArrayType>::SetValues() {
-  int max_byte_array_len = 10;
-  size_t nbytes = NUM_VALUES * max_byte_array_len;
-  values_buf_.resize(nbytes);
+void TestStatisticsSortOrder<ByteArrayType>::setValues() {
+  int maxByteArrayLen = 10;
+  size_t nbytes = NUM_VALUES * maxByteArrayLen;
+  valuesBuf_.resize(nbytes);
   std::vector<std::string> vals = {
       "c123",
       "b123",
@@ -1170,7 +1205,7 @@ void TestStatisticsSortOrder<ByteArrayType>::SetValues() {
       "i123",
       "ü123"};
 
-  uint8_t* base = &values_buf_.data()[0];
+  uint8_t* base = &valuesBuf_.data()[0];
   for (int i = 0; i < NUM_VALUES; i++) {
     memcpy(base, vals[i].c_str(), vals[i].length());
     values_[i].ptr = base;
@@ -1178,30 +1213,34 @@ void TestStatisticsSortOrder<ByteArrayType>::SetValues() {
     base += vals[i].length();
   }
 
-  // Write String min/max values
+  // Write String min/max values.
   stats_[0]
-      .set_min(std::string(
-          reinterpret_cast<const char*>(vals[2].c_str()), vals[2].length()))
-      .set_max(std::string(
-          reinterpret_cast<const char*>(vals[9].c_str()), vals[9].length()));
+      .setMin(
+          std::string(
+              reinterpret_cast<const char*>(vals[2].c_str()), vals[2].length()))
+      .setMax(
+          std::string(
+              reinterpret_cast<const char*>(vals[9].c_str()),
+              vals[9].length()));
 }
 
-// TYPE::FLBAArray
+// TYPE::FLBAArray.
 template <>
-void TestStatisticsSortOrder<FLBAType>::AddNodes(std::string name) {
-  // FLBA has only Unsigned Statistics
-  fields_.push_back(schema::PrimitiveNode::Make(
-      name,
-      Repetition::REQUIRED,
-      Type::FIXED_LEN_BYTE_ARRAY,
-      ConvertedType::NONE,
-      FLBA_LENGTH));
+void TestStatisticsSortOrder<FLBAType>::addNodes(std::string name) {
+  // FLBA has only Unsigned Statistics.
+  fields_.push_back(
+      schema::PrimitiveNode::make(
+          name,
+          Repetition::kRequired,
+          Type::kFixedLenByteArray,
+          ConvertedType::kNone,
+          FLBA_LENGTH));
 }
 
 template <>
-void TestStatisticsSortOrder<FLBAType>::SetValues() {
+void TestStatisticsSortOrder<FLBAType>::setValues() {
   size_t nbytes = NUM_VALUES * FLBA_LENGTH;
-  values_buf_.resize(nbytes);
+  valuesBuf_.resize(nbytes);
   char vals[NUM_VALUES][FLBA_LENGTH] = {
       "b12345",
       "a12345",
@@ -1214,88 +1253,93 @@ void TestStatisticsSortOrder<FLBAType>::SetValues() {
       "z12345",
       "a12345"};
 
-  uint8_t* base = &values_buf_.data()[0];
+  uint8_t* base = &valuesBuf_.data()[0];
   for (int i = 0; i < NUM_VALUES; i++) {
     memcpy(base, &vals[i][0], FLBA_LENGTH);
     values_[i].ptr = base;
     base += FLBA_LENGTH;
   }
 
-  // Write FLBA min,max values
+  // Write FLBA min,max values.
   stats_[0]
-      .set_min(
+      .setMin(
           std::string(reinterpret_cast<const char*>(&vals[1][0]), FLBA_LENGTH))
-      .set_max(
+      .setMax(
           std::string(reinterpret_cast<const char*>(&vals[8][0]), FLBA_LENGTH));
 }
 
 TYPED_TEST_SUITE(TestStatisticsSortOrder, CompareTestTypes);
 
 TYPED_TEST(TestStatisticsSortOrder, MinMax) {
-  this->AddNodes("Column ");
-  this->SetUpSchema();
-  this->WriteParquet();
-  ASSERT_NO_FATAL_FAILURE(this->VerifyParquetStats());
+  this->addNodes("Column ");
+  this->setUpSchema();
+  this->writeParquet();
+  ASSERT_NO_FATAL_FAILURE(this->verifyParquetStats());
 }
 
 template <typename ArrowType>
-void TestByteArrayStatisticsFromArrow() {
+void testByteArrayStatisticsFromArrow() {
   using TypeTraits = ::arrow::TypeTraits<ArrowType>;
   using ArrayType = typename TypeTraits::ArrayType;
 
-  auto values = ArrayFromJSON(
+  auto values = ::arrow::ArrayFromJSON(
       TypeTraits::type_singleton(),
       "[\"c123\", \"b123\", \"a123\", null, "
       "null, \"f123\", \"g123\", \"h123\", \"i123\", \"ü123\"]");
 
-  const auto& typed_values = static_cast<const ArrayType&>(*values);
+  const auto& typedValues = static_cast<const ArrayType&>(*values);
 
-  NodePtr node = PrimitiveNode::Make(
-      "field", Repetition::REQUIRED, Type::BYTE_ARRAY, ConvertedType::UTF8);
-  ColumnDescriptor descr(node, 0, 0);
-  auto stats = MakeStatistics<ByteArrayType>(&descr);
-  ASSERT_NO_FATAL_FAILURE(stats->Update(*values));
+  NodePtr Node = PrimitiveNode::make(
+      "field", Repetition::kRequired, Type::kByteArray, ConvertedType::kUtf8);
+  ColumnDescriptor descr(Node, 0, 0);
+  auto stats = makeStatistics<ByteArrayType>(&descr);
+  ASSERT_NO_FATAL_FAILURE(stats->update(*values));
 
-  ASSERT_EQ(ByteArray(typed_values.GetView(2)), stats->min());
-  ASSERT_EQ(ByteArray(typed_values.GetView(9)), stats->max());
-  ASSERT_EQ(2, stats->null_count());
+  ASSERT_EQ(ByteArray(typedValues.GetView(2)), stats->min());
+  ASSERT_EQ(ByteArray(typedValues.GetView(9)), stats->max());
+  ASSERT_EQ(2, stats->nullCount());
 }
 
-TEST(TestByteArrayStatisticsFromArrow, StringType) {
-  // Part of ARROW-3246. Replicating TestStatisticsSortOrder test but via Arrow
-  TestByteArrayStatisticsFromArrow<::arrow::StringType>();
+TEST(testByteArrayStatisticsFromArrow, StringType) {
+  // Part of ARROW-3246. Replicating TestStatisticsSortOrder test but via Arrow.
+  testByteArrayStatisticsFromArrow<::arrow::StringType>();
 }
 
-TEST(TestByteArrayStatisticsFromArrow, LargeStringType) {
-  TestByteArrayStatisticsFromArrow<::arrow::LargeStringType>();
+TEST(testByteArrayStatisticsFromArrow, LargeStringType) {
+  testByteArrayStatisticsFromArrow<::arrow::LargeStringType>();
 }
 
-// Ensure Decimal sort order is handled properly
+// Ensure Decimal sort order is handled properly.
 using TestStatisticsSortOrderFLBA = TestStatisticsSortOrder<FLBAType>;
 
 TEST_F(TestStatisticsSortOrderFLBA, decimalSortOrder) {
-  this->fields_.push_back(schema::PrimitiveNode::Make(
-      "Column 0",
-      Repetition::REQUIRED,
-      Type::FIXED_LEN_BYTE_ARRAY,
-      ConvertedType::DECIMAL,
-      FLBA_LENGTH,
-      12,
-      2));
-  this->SetUpSchema();
-  this->WriteParquet();
-
-  ASSERT_OK_AND_ASSIGN(auto pbuffer, parquet_sink_->Finish());
-
-  // Write the pbuffer to a temp file
-  auto filePath = exec::test::TempFilePath::create();
+  this->fields_.push_back(
+      schema::PrimitiveNode::make(
+          "Column 0",
+          Repetition::kRequired,
+          Type::kFixedLenByteArray,
+          ConvertedType::kDecimal,
+          FLBA_LENGTH,
+          12,
+          2));
+  this->setUpSchema();
+  this->writeParquet();
+
+  ASSERT_OK_AND_ASSIGN(auto pbuffer, parquetSink_->Finish());
+
+  // Write the pbuffer to a temp file.
+  auto filePath = TempFilePath::create();
   writeToFile(filePath, pbuffer);
   memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   std::shared_ptr<facebook::velox::memory::MemoryPool> rootPool =
       memory::memoryManager()->addRootPool("StatisticsTest");
   std::shared_ptr<facebook::velox::memory::MemoryPool> leafPool =
       rootPool->addLeafChild("StatisticsTest");
-  dwio::common::ReaderOptions readerOptions{leafPool.get()};
+  auto dataIoStats = std::make_shared<velox::io::IoStatistics>();
+  auto metadataIoStats = std::make_shared<velox::io::IoStatistics>();
+  dwio::common::ReaderOptions readerOptions(leafPool.get());
+  readerOptions.setDataIoStats(dataIoStats);
+  readerOptions.setMetadataIoStats(metadataIoStats);
   auto input = std::make_unique<dwio::common::BufferedInput>(
       std::make_shared<LocalReadFile>(filePath->getPath()),
       readerOptions.memoryPool());
@@ -1310,65 +1354,65 @@ template <
     typename Stats,
     typename Array,
     typename T = typename Array::value_type>
-void AssertMinMaxAre(
+void assertMinMaxAre(
     Stats stats,
     const Array& values,
-    T expected_min,
-    T expected_max) {
-  stats->Update(values.data(), values.size(), 0);
-  ASSERT_TRUE(stats->HasMinMax());
-  EXPECT_EQ(stats->min(), expected_min);
-  EXPECT_EQ(stats->max(), expected_max);
+    T expectedMin,
+    T expectedMax) {
+  stats->update(values.data(), values.size(), 0);
+  ASSERT_TRUE(stats->hasMinMax());
+  EXPECT_EQ(stats->min(), expectedMin);
+  EXPECT_EQ(stats->max(), expectedMax);
 }
 
 template <typename Stats, typename Array, typename T = typename Stats::T>
-void AssertMinMaxAre(
+void assertMinMaxAre(
     Stats stats,
     const Array& values,
-    const uint8_t* valid_bitmap,
-    T expected_min,
-    T expected_max) {
-  auto n_values = values.size();
-  auto null_count = ::arrow::internal::CountSetBits(valid_bitmap, n_values, 0);
-  auto non_null_count = n_values - null_count;
-  stats->UpdateSpaced(
+    const uint8_t* validBitmap,
+    T expectedMin,
+    T expectedMax) {
+  auto nValues = values.size();
+  auto nullCount = ::arrow::internal::CountSetBits(validBitmap, nValues, 0);
+  auto nonNullCount = nValues - nullCount;
+  stats->updateSpaced(
       values.data(),
-      valid_bitmap,
+      validBitmap,
       0,
-      non_null_count + null_count,
-      non_null_count,
-      null_count);
-  ASSERT_TRUE(stats->HasMinMax());
-  EXPECT_EQ(stats->min(), expected_min);
-  EXPECT_EQ(stats->max(), expected_max);
+      nonNullCount + nullCount,
+      nonNullCount,
+      nullCount);
+  ASSERT_TRUE(stats->hasMinMax());
+  EXPECT_EQ(stats->min(), expectedMin);
+  EXPECT_EQ(stats->max(), expectedMax);
 }
 
 template <typename Stats, typename Array>
-void AssertUnsetMinMax(Stats stats, const Array& values) {
-  stats->Update(values.data(), values.size(), 0);
-  ASSERT_FALSE(stats->HasMinMax());
+void assertUnsetMinMax(Stats stats, const Array& values) {
+  stats->update(values.data(), values.size(), 0);
+  ASSERT_FALSE(stats->hasMinMax());
 }
 
 template <typename Stats, typename Array>
-void AssertUnsetMinMax(
+void assertUnsetMinMax(
     Stats stats,
     const Array& values,
-    const uint8_t* valid_bitmap) {
-  auto n_values = values.size();
-  auto null_count = ::arrow::internal::CountSetBits(valid_bitmap, n_values, 0);
-  auto non_null_count = n_values - null_count;
-  stats->UpdateSpaced(
+    const uint8_t* validBitmap) {
+  auto nValues = values.size();
+  auto nullCount = ::arrow::internal::CountSetBits(validBitmap, nValues, 0);
+  auto nonNullCount = nValues - nullCount;
+  stats->updateSpaced(
       values.data(),
-      valid_bitmap,
+      validBitmap,
       0,
-      non_null_count + null_count,
-      non_null_count,
-      null_count);
-  ASSERT_FALSE(stats->HasMinMax());
+      nonNullCount + nullCount,
+      nonNullCount,
+      nullCount);
+  ASSERT_FALSE(stats->hasMinMax());
 }
 
-template <typename ParquetType, typename T = typename ParquetType::c_type>
-void CheckExtrema() {
+template <typename ParquetType, typename T = typename ParquetType::CType>
+void checkExtrema() {
   using UT = typename std::make_unsigned<T>::type;
 
   const T smin = std::numeric_limits<T>::min();
@@ -1380,18 +1424,18 @@ void CheckExtrema() {
   std::array<T, kNumValues> values{
       0, smin, smax, umin, umax, smin + 1, smax - 1, umax - 1};
 
-  NodePtr unsigned_node = PrimitiveNode::Make(
+  NodePtr unsignedNode = PrimitiveNode::make(
       "uint",
-      Repetition::OPTIONAL,
-      LogicalType::Int(sizeof(T) * CHAR_BIT, false /*signed*/),
-      ParquetType::type_num);
-  ColumnDescriptor unsigned_descr(unsigned_node, 1, 1);
-  NodePtr signed_node = PrimitiveNode::Make(
+      Repetition::kOptional,
+      LogicalType::intType(sizeof(T) * CHAR_BIT, false /*signed*/),
+      ParquetType::typeNum);
+  ColumnDescriptor unsignedDescr(unsignedNode, 1, 1);
+  NodePtr signedNode = PrimitiveNode::make(
       "int",
-      Repetition::OPTIONAL,
-      LogicalType::Int(sizeof(T) * CHAR_BIT, true /*signed*/),
-      ParquetType::type_num);
-  ColumnDescriptor signed_descr(signed_node, 1, 1);
+      Repetition::kOptional,
+      LogicalType::intType(sizeof(T) * CHAR_BIT, true /*signed*/),
+      ParquetType::typeNum);
+  ColumnDescriptor signedDescr(signedNode, 1, 1);
 
   {
     ARROW_SCOPED_TRACE(
@@ -1400,13 +1444,13 @@ void CheckExtrema() {
         ", umax = ",
         umax,
         ", node type = ",
-        unsigned_node->logical_type()->ToString(),
+        unsignedNode->logicalType()->toString(),
         ", physical type = ",
-        unsigned_descr.physical_type(),
+        unsignedDescr.physicalType(),
         ", sort order = ",
-        unsigned_descr.sort_order());
-    auto unsigned_stats = MakeStatistics<ParquetType>(&unsigned_descr);
-    AssertMinMaxAre(unsigned_stats, values, umin, umax);
+        unsignedDescr.sortOrder());
+    auto unsignedStats = makeStatistics<ParquetType>(&unsignedDescr);
+    assertMinMaxAre(unsignedStats, values, umin, umax);
   }
   {
     ARROW_SCOPED_TRACE(
@@ -1415,20 +1459,20 @@ void CheckExtrema() {
         ", smax = ",
         smax,
         ", node type = ",
-        signed_node->logical_type()->ToString(),
+        signedNode->logicalType()->toString(),
         ", physical type = ",
-        signed_descr.physical_type(),
+        signedDescr.physicalType(),
         ", sort order = ",
-        signed_descr.sort_order());
-    auto signed_stats = MakeStatistics<ParquetType>(&signed_descr);
-    AssertMinMaxAre(signed_stats, values, smin, smax);
+        signedDescr.sortOrder());
+    auto signedStats = makeStatistics<ParquetType>(&signedDescr);
+    assertMinMaxAre(signedStats, values, smin, smax);
   }
 
-  // With validity bitmap
-  std::vector<bool> is_valid = {
+  // With validity bitmap.
+  std::vector<bool> isValid = {
       true, false, false, false, false, true, true, true};
-  std::shared_ptr<Buffer> valid_bitmap;
-  ::arrow::BitmapFromVector(is_valid, &valid_bitmap);
+  std::shared_ptr<Buffer> validBitmap;
+  ::arrow::BitmapFromVector(isValid, &validBitmap);
   {
     ARROW_SCOPED_TRACE(
         "spaced unsigned statistics: umin = ",
@@ -1436,14 +1480,13 @@ void CheckExtrema() {
         ", umax = ",
         umax,
         ", node type = ",
-        unsigned_node->logical_type()->ToString(),
+        unsignedNode->logicalType()->toString(),
         ", physical type = ",
-        unsigned_descr.physical_type(),
+        unsignedDescr.physicalType(),
         ", sort order = ",
-        unsigned_descr.sort_order());
-    auto unsigned_stats = MakeStatistics<ParquetType>(&unsigned_descr);
-    AssertMinMaxAre(
-        unsigned_stats, values, valid_bitmap->data(), T{0}, umax - 1);
+        unsignedDescr.sortOrder());
+    auto unsignedStats = makeStatistics<ParquetType>(&unsignedDescr);
+    assertMinMaxAre(unsignedStats, values, validBitmap->data(), T{0}, umax - 1);
   }
   {
     ARROW_SCOPED_TRACE(
@@ -1452,99 +1495,102 @@ void CheckExtrema() {
         ", smax = ",
         smax,
         ", node type = ",
-        signed_node->logical_type()->ToString(),
+        signedNode->logicalType()->toString(),
         ", physical type = ",
-        signed_descr.physical_type(),
+        signedDescr.physicalType(),
         ", sort order = ",
-        signed_descr.sort_order());
-    auto signed_stats = MakeStatistics<ParquetType>(&signed_descr);
-    AssertMinMaxAre(
-        signed_stats, values, valid_bitmap->data(), smin + 1, smax - 1);
+        signedDescr.sortOrder());
+    auto signedStats = makeStatistics<ParquetType>(&signedDescr);
+    assertMinMaxAre(
+        signedStats, values, validBitmap->data(), smin + 1, smax - 1);
   }
 }
 
 TEST(TestStatistic, Int32Extrema) {
-  CheckExtrema<Int32Type>();
+  checkExtrema<Int32Type>();
 }
 TEST(TestStatistic, Int64Extrema) {
-  CheckExtrema<Int64Type>();
+  checkExtrema<Int64Type>();
 }
 
-// PARQUET-1225: Float NaN values may lead to incorrect min-max
+// PARQUET-1225: Float NaN values may lead to incorrect min-max.
 template <typename ParquetType>
-void CheckNaNs() {
-  using T = typename ParquetType::c_type;
+void checkNaNs() {
+  using T = typename ParquetType::CType;
 
   constexpr int kNumValues = 8;
-  NodePtr node =
-      PrimitiveNode::Make("f", Repetition::OPTIONAL, ParquetType::type_num);
-  ColumnDescriptor descr(node, 1, 1);
+  NodePtr Node =
+      PrimitiveNode::make("f", Repetition::kOptional, ParquetType::typeNum);
+  ColumnDescriptor descr(Node, 1, 1);
 
   constexpr T nan = std::numeric_limits<T>::quiet_NaN();
   constexpr T min = -4.0f;
   constexpr T max = 3.0f;
 
-  std::array<T, kNumValues> all_nans{nan, nan, nan, nan, nan, nan, nan, nan};
-  std::array<T, kNumValues> some_nans{
+  std::array<T, kNumValues> allNans{nan, nan, nan, nan, nan, nan, nan, nan};
+  std::array<T, kNumValues> someNans{
       nan, max, -3.0f, -1.0f, nan, 2.0f, min, nan};
-  uint8_t valid_bitmap = 0x7F; // 0b01111111
-  // NaNs excluded
-  uint8_t valid_bitmap_no_nans = 0x6E; // 0b01101110
-
-  // Test values
-  auto some_nan_stats = MakeStatistics<ParquetType>(&descr);
-  // Ingesting only nans should not yield valid min max
-  AssertUnsetMinMax(some_nan_stats, all_nans);
+  uint8_t validBitmap = 0x7F; // 0b01111111
+  // NaNs excluded.
+  uint8_t validBitmapNoNans = 0x6E; // 0b01101110
+
+  // Test values.
+  auto someNanStats = makeStatistics<ParquetType>(&descr);
+  // Ingesting only nans should not yield valid min max.
+  assertUnsetMinMax(someNanStats, allNans);
+  EXPECT_EQ(someNanStats->nanCount(), allNans.size());
   // Ingesting a mix of NaNs and non-NaNs should not yield valid min max.
-  AssertMinMaxAre(some_nan_stats, some_nans, min, max);
-  // Ingesting only nans after a valid min/max, should have not effect
-  AssertMinMaxAre(some_nan_stats, all_nans, min, max);
+  assertMinMaxAre(someNanStats, someNans, min, max);
+  // Ingesting only nans after a valid min/max, should have not effect.
+  assertMinMaxAre(someNanStats, allNans, min, max);
 
-  some_nan_stats = MakeStatistics<ParquetType>(&descr);
-  AssertUnsetMinMax(some_nan_stats, all_nans, &valid_bitmap);
+  someNanStats = makeStatistics<ParquetType>(&descr);
+  assertUnsetMinMax(someNanStats, allNans, &validBitmap);
   // NaNs should not pollute min max when excluded via null bitmap.
-  AssertMinMaxAre(some_nan_stats, some_nans, &valid_bitmap_no_nans, min, max);
+  assertMinMaxAre(someNanStats, someNans, &validBitmapNoNans, min, max);
   // Ingesting NaNs with a null bitmap should not change the result.
-  AssertMinMaxAre(some_nan_stats, some_nans, &valid_bitmap, min, max);
+  assertMinMaxAre(someNanStats, someNans, &validBitmap, min, max);
 
-  // An array that doesn't start with NaN
-  std::array<T, kNumValues> other_nans{
+  // An array that doesn't start with NaN.
+  std::array<T, kNumValues> otherNans{
       1.5f, max, -3.0f, -1.0f, nan, 2.0f, min, nan};
-  auto other_stats = MakeStatistics<ParquetType>(&descr);
-  AssertMinMaxAre(other_stats, other_nans, min, max);
+  auto otherStats = makeStatistics<ParquetType>(&descr);
+  assertMinMaxAre(otherStats, otherNans, min, max);
+  EXPECT_EQ(otherStats->nanCount(), 2);
 }
 
 TEST(TestStatistic, NaNFloatValues) {
-  CheckNaNs<FloatType>();
+  checkNaNs<FloatType>();
 }
 
 TEST(TestStatistic, NaNDoubleValues) {
-  CheckNaNs<DoubleType>();
+  checkNaNs<DoubleType>();
 }
 
-// ARROW-7376
+// ARROW-7376.
 TEST(TestStatisticsSortOrderFloatNaN, NaNAndNullsInfiniteLoop) {
   constexpr int kNumValues = 8;
-  NodePtr node =
-      PrimitiveNode::Make("nan_float", Repetition::OPTIONAL, Type::FLOAT);
-  ColumnDescriptor descr(node, 1, 1);
+  NodePtr Node =
+      PrimitiveNode::make("nan_float", Repetition::kOptional, Type::kFloat);
+  ColumnDescriptor descr(Node, 1, 1);
 
   constexpr float nan = std::numeric_limits<float>::quiet_NaN();
-  std::array<float, kNumValues> nans_but_last{
+  std::array<float, kNumValues> nansButLast{
       nan, nan, nan, nan, nan, nan, nan, 0.0f};
 
-  uint8_t all_but_last_valid = 0x7F; // 0b01111111
-  auto stats = MakeStatistics<FloatType>(&descr);
-  AssertUnsetMinMax(stats, nans_but_last, &all_but_last_valid);
+  uint8_t allButLastValid = 0x7F; // 0b01111111
+  auto stats = makeStatistics<FloatType>(&descr);
+  assertUnsetMinMax(stats, nansButLast, &allButLastValid);
+  EXPECT_EQ(stats->nanCount(), kNumValues - 1);
 }
 
 template <
     typename Stats,
     typename Array,
     typename T = typename Array::value_type>
-void AssertMinMaxZeroesSign(Stats stats, const Array& values) {
-  stats->Update(values.data(), values.size(), 0);
-  ASSERT_TRUE(stats->HasMinMax());
+void assertMinMaxZeroesSign(Stats stats, const Array& values) {
+  stats->update(values.data(), values.size(), 0);
+  ASSERT_TRUE(stats->hasMinMax());
 
   T zero{};
   ASSERT_EQ(stats->min(), zero);
@@ -1554,52 +1600,218 @@ void AssertMinMaxZeroesSign(Stats stats, const Array& values) {
   ASSERT_FALSE(std::signbit(stats->max()));
 }
 
-// ARROW-5562: Ensure that -0.0f and 0.0f values are properly handled like in
-// parquet-mr
+// ARROW-5562: Ensure that -0.0f and 0.0f values are properly handled like in.
+// Parquet-mr.
 template <typename ParquetType>
-void CheckNegativeZeroStats() {
-  using T = typename ParquetType::c_type;
+void checkNegativeZeroStats() {
+  using T = typename ParquetType::CType;
 
-  NodePtr node =
-      PrimitiveNode::Make("f", Repetition::OPTIONAL, ParquetType::type_num);
-  ColumnDescriptor descr(node, 1, 1);
+  NodePtr Node =
+      PrimitiveNode::make("f", Repetition::kOptional, ParquetType::typeNum);
+  ColumnDescriptor descr(Node, 1, 1);
   T zero{};
 
   {
     std::array<T, 2> values{-zero, zero};
-    auto stats = MakeStatistics<ParquetType>(&descr);
-    AssertMinMaxZeroesSign(stats, values);
+    auto stats = makeStatistics<ParquetType>(&descr);
+    assertMinMaxZeroesSign(stats, values);
   }
 
   {
     std::array<T, 2> values{zero, -zero};
-    auto stats = MakeStatistics<ParquetType>(&descr);
-    AssertMinMaxZeroesSign(stats, values);
+    auto stats = makeStatistics<ParquetType>(&descr);
+    assertMinMaxZeroesSign(stats, values);
   }
 
   {
     std::array<T, 2> values{-zero, -zero};
-    auto stats = MakeStatistics<ParquetType>(&descr);
-    AssertMinMaxZeroesSign(stats, values);
+    auto stats = makeStatistics<ParquetType>(&descr);
+    assertMinMaxZeroesSign(stats, values);
   }
 
   {
     std::array<T, 2> values{zero, zero};
-    auto stats = MakeStatistics<ParquetType>(&descr);
-    AssertMinMaxZeroesSign(stats, values);
+    auto stats = makeStatistics<ParquetType>(&descr);
+    assertMinMaxZeroesSign(stats, values);
   }
 }
 
 TEST(TestStatistics, FloatNegativeZero) {
-  CheckNegativeZeroStats<FloatType>();
+  checkNegativeZeroStats<FloatType>();
 }
 
 TEST(TestStatistics, DoubleNegativeZero) {
-  CheckNegativeZeroStats<DoubleType>();
+  checkNegativeZeroStats<DoubleType>();
+}
+
+// Test infinity handling in statistics.
+template <typename ParquetType>
+void checkInfinityStats() {
+  using T = typename ParquetType::CType;
+
+  constexpr int32_t kNumValues = 8;
+  NodePtr Node = PrimitiveNode::make(
+      "infinity_test", Repetition::kOptional, ParquetType::typeNum);
+  ColumnDescriptor descr(Node, 1, 1);
+
+  constexpr T posInf = std::numeric_limits<T>::infinity();
+  constexpr T negInf = -std::numeric_limits<T>::infinity();
+  constexpr T min = -1.0f;
+  constexpr T max = 1.0f;
+
+  {
+    std::array<T, kNumValues> allPosInf{
+        posInf, posInf, posInf, posInf, posInf, posInf, posInf, posInf};
+    auto stats = makeStatistics<ParquetType>(&descr);
+    assertMinMaxAre(stats, allPosInf, posInf, posInf);
+  }
+
+  {
+    std::array<T, kNumValues> allNegInf{
+        negInf, negInf, negInf, negInf, negInf, negInf, negInf, negInf};
+    auto stats = makeStatistics<ParquetType>(&descr);
+    assertMinMaxAre(stats, allNegInf, negInf, negInf);
+  }
+
+  {
+    std::array<T, kNumValues> mixedInf{
+        posInf, negInf, posInf, negInf, posInf, negInf, posInf, negInf};
+    auto stats = makeStatistics<ParquetType>(&descr);
+    assertMinMaxAre(stats, mixedInf, negInf, posInf);
+  }
+
+  {
+    std::array<T, kNumValues> mixedValues{
+        posInf, max, min, min, negInf, max, min, posInf};
+    auto stats = makeStatistics<ParquetType>(&descr);
+    assertMinMaxAre(stats, mixedValues, negInf, posInf);
+  }
+
+  {
+    constexpr T nan = std::numeric_limits<T>::quiet_NaN();
+    std::array<T, kNumValues> mixedWithNan{
+        posInf, nan, max, negInf, nan, min, posInf, nan};
+    auto stats = makeStatistics<ParquetType>(&descr);
+    assertMinMaxAre(stats, mixedWithNan, negInf, posInf);
+  }
+}
+
+TEST(TestStatistics, FloatInfinityValues) {
+  checkInfinityStats<FloatType>();
+}
+
+TEST(TestStatistics, DoubleInfinityValues) {
+  checkInfinityStats<DoubleType>();
+}
+
+// Test infinity values with validity bitmap.
+TEST(TestStatistics, InfinityWithNullBitmap) {
+  constexpr int kNumValues = 8;
+  NodePtr Node = PrimitiveNode::make(
+      "infinity_null_test", Repetition::kOptional, Type::kFloat);
+  ColumnDescriptor descr(Node, 1, 1);
+
+  constexpr float posInf = std::numeric_limits<float>::infinity();
+  constexpr float negInf = -std::numeric_limits<float>::infinity();
+
+  // Test with some infinity values marked as null.
+  std::array<float, kNumValues> valuesWithNulls{
+      posInf, negInf, 1.0f, 2.0f, posInf, -1.0f, 3.0f, negInf};
+
+  // Bitmap: exclude first posInf and last negInf (01111110 = 0x7E).
+  uint8_t validBitmap = 0x7E;
+
+  auto stats = makeStatistics<FloatType>(&descr);
+  assertMinMaxAre(stats, valuesWithNulls, &validBitmap, negInf, posInf);
+  valuesWithNulls = {posInf, 0.0f, 1.0f, 2.0f, -2.0f, -1.0f, 3.0f, negInf};
+
+  stats = makeStatistics<FloatType>(&descr);
+  assertMinMaxAre(stats, valuesWithNulls, &validBitmap, -2.0f, 3.0f);
+}
+
+// Test merging statistics with infinity values.
+TEST(TestStatistics, MergeInfinityStatistics) {
+  NodePtr Node = PrimitiveNode::make(
+      "merge_infinity", Repetition::kOptional, Type::kDouble);
+  ColumnDescriptor descr(Node, 1, 1);
+
+  constexpr double posInf = std::numeric_limits<double>::infinity();
+  constexpr double negInf = -std::numeric_limits<double>::infinity();
+
+  auto stats1 = makeStatistics<DoubleType>(&descr);
+  std::array<double, 3> normalValues{-1.0f, 0.0f, 1.0f};
+  assertMinMaxAre(stats1, normalValues, -1.0f, 1.0f);
+
+  auto stats2 = makeStatistics<DoubleType>(&descr);
+  std::array<double, 2> infinityValues{negInf, posInf};
+  assertMinMaxAre(stats2, infinityValues, negInf, posInf);
+
+  auto mergedStats = makeStatistics<DoubleType>(&descr);
+  mergedStats->merge(*stats1);
+  mergedStats->merge(*stats2);
+
+  // Result should have infinity bounds.
+  ASSERT_TRUE(mergedStats->hasMinMax());
+  ASSERT_EQ(negInf, mergedStats->min());
+  ASSERT_EQ(posInf, mergedStats->max());
+}
+
+TEST(TestStatistics, CleanInfinityStatistics) {
+  constexpr int kNumValues = 4;
+  NodePtr Node = PrimitiveNode::make(
+      "clean_stat_nullopt", Repetition::kOptional, Type::kFloat);
+  ColumnDescriptor descr(Node, 1, 1);
+
+  constexpr float nan = std::numeric_limits<float>::quiet_NaN();
+
+  {
+    std::array<float, kNumValues> allNans{nan, nan, nan, nan};
+    auto stats = makeStatistics<FloatType>(&descr);
+    assertUnsetMinMax(stats, allNans);
+  }
+
+  {
+    std::array<float, kNumValues> values{1.0f, 2.0f, 3.0f, 4.0f};
+    uint8_t allNullBitmap = 0x00;
+
+    auto stats = makeStatistics<FloatType>(&descr);
+    assertUnsetMinMax(stats, values, &allNullBitmap);
+  }
+
+  {
+    std::array<float, kNumValues> mixedNans{nan, 1.0f, nan, 2.0f};
+    uint8_t partialNullBitmap = 0x05;
+
+    auto stats = makeStatistics<FloatType>(&descr);
+    assertUnsetMinMax(stats, mixedNans, &partialNullBitmap);
+  }
+}
+
+TEST(TestStatistics, InfinityCleanStatisticValid) {
+  constexpr int kNumValues = 4;
+  NodePtr Node = PrimitiveNode::make(
+      "clean_stat_valid", Repetition::kOptional, Type::kDouble);
+  ColumnDescriptor descr(Node, 1, 1);
+
+  constexpr double posInf = std::numeric_limits<double>::infinity();
+  constexpr double negInf = -std::numeric_limits<double>::infinity();
+  constexpr double nan = std::numeric_limits<double>::quiet_NaN();
+
+  {
+    std::array<double, kNumValues> mixedValues{posInf, nan, negInf, nan};
+    auto stats = makeStatistics<DoubleType>(&descr);
+    assertMinMaxAre(stats, mixedValues, negInf, posInf);
+  }
+
+  {
+    std::array<double, 1> singleInf{negInf};
+    auto stats = makeStatistics<DoubleType>(&descr);
+    assertMinMaxAre(stats, singleInf, negInf, negInf);
+  }
 }
 
 // TODO: disabled as it requires Arrow parquet data dir.
-// Test statistics for binary column with UNSIGNED sort order
+// Test statistics for binary column with UNSIGNED sort order.
 /*
 TEST(TestStatisticsSortOrderMinMax, Unsigned) {
   std::string dir_string(test::get_data_dir());
@@ -1607,15 +1819,15 @@ TEST(TestStatisticsSortOrderMinMax, Unsigned) {
   ss << dir_string << "/binary.parquet";
   auto path = ss.str();
 
-  // The file is generated by parquet-mr 1.10.0, the first version that
-  // supports correct statistics for binary data (see PARQUET-1025). It
-  // contains a single column of binary type. Data is just single byte values
-  // from 0x00 to 0x0B.
+  // The file is generated by parquet-mr 1.10.0, the first version that.
+  // Supports correct statistics for binary data (see PARQUET-1025). It.
+  // Contains a single column of binary type. Data is just single byte values.
+  // From 0x00 to 0x0B.
   auto file_reader = ParquetFileReader::OpenFile(path);
   auto rg_reader = file_reader->RowGroup(0);
   auto metadata = rg_reader->metadata();
   auto column_schema = metadata->schema()->Column(0);
-  ASSERT_EQ(SortOrder::UNSIGNED, column_schema->sort_order());
+  ASSERT_EQ(SortOrder::kUnsigned, column_schema->sort_order());
 
   auto column_chunk = metadata->ColumnChunk(0);
   ASSERT_TRUE(column_chunk->is_stats_set());
@@ -1645,5 +1857,397 @@ TEST(TestEncodedStatistics, CopySafe) {
 }
 */
 
+namespace {
+
+constexpr int32_t kTruncLen = 16;
+
+template <typename ParquetType, typename T>
+std::shared_ptr<TypedStatistics<ParquetType>> makeStats(
+    const ColumnDescriptor* descr,
+    std::initializer_list<T> values) {
+  auto stats = makeStatistics<ParquetType>(descr);
+  std::vector<T> v(values);
+  stats->update(v.data(), v.size(), 0);
+  return stats;
+}
+
+std::shared_ptr<TypedStatistics<ByteArrayType>> makeStats(
+    const ColumnDescriptor* descr,
+    std::initializer_list<std::string> values) {
+  auto stats = makeStatistics<ByteArrayType>(descr);
+  std::vector<std::string> strings(values);
+  std::vector<ByteArray> byteArrays;
+  byteArrays.reserve(strings.size());
+  for (const auto& s : strings) {
+    byteArrays.push_back(byteArrayFromString(s));
+  }
+  stats->update(byteArrays.data(), byteArrays.size(), 0);
+  return stats;
+}
+
+} // namespace
+
+TEST(IcebergStatistics, decimalMinMaxValue) {
+  const NodePtr Node = PrimitiveNode::make(
+      "decimal_col",
+      Repetition::kRequired,
+      LogicalType::decimal(10, 2),
+      Type::kInt64);
+  ColumnDescriptor descr(Node, 0, 0);
+
+  auto stats =
+      makeStats<Int64Type, int64_t>(&descr, {12345, -67890, 100, 50000});
+
+  ASSERT_TRUE(stats->hasMinMax());
+  EXPECT_EQ(stats->min(), -67890);
+  EXPECT_EQ(stats->max(), 50000);
+
+  const auto lowerBound = stats->icebergLowerBoundInclusive(kTruncLen);
+  const auto upperBound = stats->icebergUpperBoundExclusive(kTruncLen);
+
+  ASSERT_TRUE(upperBound.has_value());
+
+  // Verify the encoding is big-endian.
+  int64_t decodedMin = ::arrow::bit_util::FromBigEndian(
+      *reinterpret_cast<const int64_t*>(lowerBound.data()));
+  int64_t decodedMax = ::arrow::bit_util::FromBigEndian(
+      *reinterpret_cast<const int64_t*>(upperBound->data()));
+
+  EXPECT_EQ(decodedMin, -67890);
+  EXPECT_EQ(decodedMax, 50000);
+}
+
+TEST(IcebergStatistics, nonDecimalBounds) {
+  const NodePtr Node =
+      PrimitiveNode::make("int_col", Repetition::kRequired, Type::kInt64);
+  ColumnDescriptor descr(Node, 0, 0);
+
+  auto stats = makeStats<Int64Type, int64_t>(&descr, {100, -200, 300, 50});
+
+  ASSERT_TRUE(stats->hasMinMax());
+
+  // For non-decimal INT64, IcebergLowerBound should equal EncodeMin (plain.
+  // Encoding).
+  EXPECT_EQ(stats->icebergLowerBoundInclusive(kTruncLen), stats->encodeMin());
+  const auto upperBound = stats->icebergUpperBoundExclusive(kTruncLen);
+  ASSERT_TRUE(upperBound.has_value());
+  EXPECT_EQ(*upperBound, stats->encodeMax());
+}
+
+TEST(IcebergStatistics, byteArrayBounds) {
+  NodePtr Node = PrimitiveNode::make(
+      "string_col",
+      Repetition::kRequired,
+      Type::kByteArray,
+      ConvertedType::kUtf8);
+  ColumnDescriptor descr(Node, 0, 0);
+
+  auto stats = makeStats(
+      &descr,
+      {"AAAAAAAAAAAAAAAAAAAAAAAAA", "ZZZZZZZZZZZZZZZZZZZZZZZZZ", "Hello"});
+
+  ASSERT_TRUE(stats->hasMinMax());
+
+  // IcebergLowerBound should be truncated to 16 characters.
+  const auto lowerBound = stats->icebergLowerBoundInclusive(kTruncLen);
+  EXPECT_EQ(lowerBound, "AAAAAAAAAAAAAAAA");
+
+  // IcebergUpperBound should be truncated and incremented.
+  const auto upperBound = stats->icebergUpperBoundExclusive(kTruncLen);
+  ASSERT_TRUE(upperBound.has_value());
+  // 'Z' (0x5A) incremented becomes '[' (0x5B).
+  EXPECT_EQ(*upperBound, "ZZZZZZZZZZZZZZZ[");
+}
+
+TEST(IcebergStatistics, byteArrayBoundsNoTruncation) {
+  NodePtr Node = PrimitiveNode::make(
+      "string_col",
+      Repetition::kRequired,
+      Type::kByteArray,
+      ConvertedType::kUtf8);
+  ColumnDescriptor descr(Node, 0, 0);
+
+  // Create strings shorter than 16 characters.
+  auto stats = makeStats(&descr, {"apple", "zebra", "banana"});
+
+  ASSERT_TRUE(stats->hasMinMax());
+
+  // For short strings, IcebergLowerBound/IcebergUpperBound should be the same.
+  // As EncodeMin/EncodeMax.
+  EXPECT_EQ(stats->icebergLowerBoundInclusive(kTruncLen), stats->encodeMin());
+  const auto upperBound = stats->icebergUpperBoundExclusive(kTruncLen);
+  ASSERT_TRUE(upperBound.has_value());
+  EXPECT_EQ(*upperBound, stats->encodeMax());
+}
+
+TEST(IcebergStatistics, byteArrayBoundsUnicode) {
+  NodePtr Node = PrimitiveNode::make(
+      "string_col",
+      Repetition::kRequired,
+      Type::kByteArray,
+      ConvertedType::kUtf8);
+  ColumnDescriptor descr(Node, 0, 0);
+
+  // Create Unicode strings longer than 16 characters to trigger truncation.
+  // Truncation is based on character count (16 chars), not byte count.
+  // "世" is U+4E16 (3 bytes in UTF-8: E4 B8 96)
+  // "界" is U+754C (3 bytes in UTF-8: E7 95 8C)
+  // "你" is U+4F60 (3 bytes in UTF-8: E4 BD A0)
+  // "好" is U+597D (3 bytes in UTF-8: E5 A5 BD)
+  auto stats = makeStats(
+      &descr,
+      {"AAAA世界世界世界世界世界世界世",
+       "ZZZZ你好你好你好你好你好你好你",
+       "Hello, 世界!"});
+
+  ASSERT_TRUE(stats->hasMinMax());
+
+  const auto lowerBound = stats->icebergLowerBoundInclusive(kTruncLen);
+  const auto upperBound = stats->icebergUpperBoundExclusive(kTruncLen);
+
+  ASSERT_TRUE(upperBound.has_value());
+
+  // Str1 has 18 characters (4 ASCII + 14 Chinese).
+  // Truncated to 16 chars: "AAAA" (4) + "世界世界世界世界世界世界 (12)".
+  const std::string expectedLower = "AAAA世界世界世界世界世界世界";
+  EXPECT_EQ(lowerBound, expectedLower);
+
+  // Str2 has 18 characters (4 ASCII + 14 Chinese).
+  // For upperBound, the last character is incremented after truncation.
+  // "好" (U+597D) incremented becomes U+597E "奾".
+  const std::string expectedUpper = "ZZZZ你好你好你好你好你好你奾";
+  EXPECT_EQ(*upperBound, expectedUpper);
+}
+
+// Verifies the lower and upper bounds for non-string ByteArray (BINARY /
+// VARBINARY) take a raw-byte prefix and a byte-level round-up rather than
+// going through the UTF-8 paths. Inputs include 0xff bytes that would not
+// form a valid UTF-8 sequence; the lower bound must be a byte-truncation
+// (string_view::substr), and the upper bound must use the binary round-up
+// (which propagates carry on 0xff and yields an exclusive upper bound).
+TEST(IcebergStatistics, byteArrayBoundsBinary) {
+  NodePtr Node = PrimitiveNode::make(
+      "binary_col",
+      Repetition::kRequired,
+      Type::kByteArray,
+      ConvertedType::kNone);
+  ColumnDescriptor descr(Node, 0, 0);
+
+  // Each value is 20 raw bytes, longer than kTruncLen (16). Bytes include
+  // 0xff and other non-ASCII values to ensure UTF-8 parsing would not be
+  // appropriate.
+  const std::string min(20, '\x10');
+  const std::string max = std::string(15, '\xff') + std::string(5, '\x10');
+  auto stats = makeStats(&descr, {min, max});
+
+  ASSERT_TRUE(stats->hasMinMax());
+
+  // Lower bound: raw-byte prefix of 'min' (16 bytes of 0x10).
+  const auto lowerBound = stats->icebergLowerBoundInclusive(kTruncLen);
+  EXPECT_EQ(lowerBound, std::string(16, '\x10'));
+
+  // Upper bound: max truncated to 16 bytes is 15 * 0xff + 1 * 0x10. The
+  // binary round-up walks from the end and increments the first non-0xff
+  // byte (0x10 -> 0x11), then truncates anything past it.
+  const auto upperBound = stats->icebergUpperBoundExclusive(kTruncLen);
+  ASSERT_TRUE(upperBound.has_value());
+  EXPECT_EQ(*upperBound, std::string(15, '\xff') + std::string(1, '\x11'));
+}
+
+TEST(IcebergStatistics, floatBounds) {
+  NodePtr Node =
+      PrimitiveNode::make("float_col", Repetition::kRequired, Type::kFloat);
+  ColumnDescriptor descr(Node, 0, 0);
+
+  auto stats = makeStats<FloatType, float>(&descr, {1.5f, -2.5f, 3.5f, 0.5f});
+
+  ASSERT_TRUE(stats->hasMinMax());
+  EXPECT_EQ(stats->icebergLowerBoundInclusive(kTruncLen), stats->encodeMin());
+  const auto upperBound = stats->icebergUpperBoundExclusive(kTruncLen);
+  ASSERT_TRUE(upperBound.has_value());
+  EXPECT_EQ(*upperBound, stats->encodeMax());
+}
+
+TEST(IcebergStatistics, doubleBounds) {
+  NodePtr Node =
+      PrimitiveNode::make("double_col", Repetition::kRequired, Type::kDouble);
+  ColumnDescriptor descr(Node, 0, 0);
+
+  auto stats = makeStats<DoubleType, double>(&descr, {1.5, -2.5, 3.5, 0.5});
+
+  ASSERT_TRUE(stats->hasMinMax());
+  EXPECT_EQ(stats->icebergLowerBoundInclusive(kTruncLen), stats->encodeMin());
+  const auto upperBound = stats->icebergUpperBoundExclusive(kTruncLen);
+  ASSERT_TRUE(upperBound.has_value());
+  EXPECT_EQ(*upperBound, stats->encodeMax());
+}
+
+TEST(IcebergStatistics, emptyStringBounds) {
+  NodePtr Node = PrimitiveNode::make(
+      "string_col",
+      Repetition::kRequired,
+      Type::kByteArray,
+      ConvertedType::kUtf8);
+  ColumnDescriptor descr(Node, 0, 0);
+
+  {
+    auto stats = makeStats(&descr, {"", "hello", ""});
+
+    ASSERT_TRUE(stats->hasMinMax());
+    EXPECT_EQ(stats->icebergLowerBoundInclusive(kTruncLen), "");
+
+    const auto upperBound = stats->icebergUpperBoundExclusive(kTruncLen);
+    ASSERT_TRUE(upperBound.has_value());
+    EXPECT_EQ(*upperBound, "hello");
+  }
+
+  {
+    auto stats = makeStats(&descr, {"", ""});
+
+    ASSERT_TRUE(stats->hasMinMax());
+    EXPECT_EQ(stats->min(), ByteArray(""));
+    EXPECT_EQ(stats->max(), ByteArray(""));
+
+    EXPECT_EQ(stats->icebergLowerBoundInclusive(kTruncLen), "");
+
+    const auto upperBound = stats->icebergUpperBoundExclusive(kTruncLen);
+    ASSERT_TRUE(upperBound.has_value());
+    EXPECT_EQ(*upperBound, "");
+  }
+}
+
+TEST(IcebergStatistics, unboundedUpperBound) {
+  NodePtr Node = PrimitiveNode::make(
+      "string_col",
+      Repetition::kRequired,
+      Type::kByteArray,
+      ConvertedType::kUtf8);
+  ColumnDescriptor descr(Node, 0, 0);
+
+  {
+    std::string allMaxAscii(20, '\x7F');
+    auto stats = makeStats(&descr, {"hello", allMaxAscii});
+
+    ASSERT_TRUE(stats->hasMinMax());
+
+    const auto lowerBound = stats->icebergLowerBoundInclusive(kTruncLen);
+    const auto upperBound = stats->icebergUpperBoundExclusive(kTruncLen);
+
+    EXPECT_EQ(lowerBound, stats->encodeMin());
+    EXPECT_FALSE(upperBound.has_value());
+  }
+
+  {
+    std::string allMaxUnicode;
+    allMaxUnicode.reserve(17 * 4);
+    for (int i = 0; i < 17; ++i) {
+      allMaxUnicode += "\U0010FFFF";
+    }
+    auto stats = makeStats(&descr, {"hello", allMaxUnicode});
+
+    ASSERT_TRUE(stats->hasMinMax());
+
+    const auto lowerBound = stats->icebergLowerBoundInclusive(kTruncLen);
+    const auto upperBound = stats->icebergUpperBoundExclusive(kTruncLen);
+    EXPECT_EQ(lowerBound, stats->encodeMin());
+    EXPECT_FALSE(upperBound.has_value());
+  }
+
+  {
+    std::string allMaxAscii(20, '\x7F');
+    auto stats = makeStats(&descr, {allMaxAscii, allMaxAscii});
+
+    ASSERT_TRUE(stats->hasMinMax());
+    EXPECT_EQ(stats->min(), ByteArray(allMaxAscii));
+    EXPECT_EQ(stats->max(), ByteArray(allMaxAscii));
+
+    const auto lowerBound = stats->icebergLowerBoundInclusive(kTruncLen);
+    const auto upperBound = stats->icebergUpperBoundExclusive(kTruncLen);
+    EXPECT_TRUE(stats->encodeMin().starts_with(lowerBound));
+    EXPECT_FALSE(upperBound.has_value());
+  }
+
+  {
+    std::string allMaxUnicode;
+    allMaxUnicode.reserve(17 * 4);
+    for (int i = 0; i < 17; ++i) {
+      allMaxUnicode += "\U0010FFFF";
+    }
+    auto stats = makeStats(&descr, {allMaxUnicode, allMaxUnicode});
+
+    ASSERT_TRUE(stats->hasMinMax());
+    EXPECT_EQ(stats->min(), ByteArray(allMaxUnicode));
+    EXPECT_EQ(stats->max(), ByteArray(allMaxUnicode));
+
+    const auto lowerBound = stats->icebergLowerBoundInclusive(kTruncLen);
+    const auto upperBound = stats->icebergUpperBoundExclusive(kTruncLen);
+    EXPECT_TRUE(stats->encodeMin().starts_with(lowerBound));
+    EXPECT_FALSE(upperBound.has_value());
+  }
+}
+
+TEST(StatisticsComparison, withInt64) {
+  NodePtr Node =
+      PrimitiveNode::make("int_col", Repetition::kRequired, Type::kInt64);
+  ColumnDescriptor descr(Node, 0, 0);
+
+  auto stats1 = makeStats<Int64Type, int64_t>(&descr, {10, 20, 30});
+  auto stats2 = makeStats<Int64Type, int64_t>(&descr, {5, 15, 25});
+  auto stats3 = makeStats<Int64Type, int64_t>(&descr, {10, 20, 30});
+
+  ASSERT_TRUE(stats1->hasMinMax());
+  ASSERT_TRUE(stats2->hasMinMax());
+  ASSERT_TRUE(stats3->hasMinMax());
+
+  EXPECT_TRUE(stats1->maxGreaterThan(*stats2));
+  EXPECT_FALSE(stats2->maxGreaterThan(*stats1));
+  EXPECT_TRUE(stats1->maxGreaterThan(*stats3));
+  EXPECT_TRUE(stats3->maxGreaterThan(*stats1));
+
+  EXPECT_FALSE(stats1->minLessThan(*stats2));
+  EXPECT_TRUE(stats2->minLessThan(*stats1));
+  EXPECT_FALSE(stats1->minLessThan(*stats3));
+  EXPECT_FALSE(stats3->minLessThan(*stats1));
+}
+
+TEST(StatisticsComparison, withDouble) {
+  NodePtr Node =
+      PrimitiveNode::make("double_col", Repetition::kRequired, Type::kDouble);
+  ColumnDescriptor descr(Node, 0, 0);
+
+  auto stats1 = makeStats<DoubleType, double>(&descr, {1.0, 2.0, 3.0});
+  auto stats2 = makeStats<DoubleType, double>(&descr, {0.5, 1.5, 2.5});
+
+  ASSERT_TRUE(stats1->hasMinMax());
+  ASSERT_TRUE(stats2->hasMinMax());
+
+  EXPECT_TRUE(stats1->maxGreaterThan(*stats2));
+  EXPECT_FALSE(stats2->maxGreaterThan(*stats1));
+
+  EXPECT_FALSE(stats1->minLessThan(*stats2));
+  EXPECT_TRUE(stats2->minLessThan(*stats1));
+}
+
+TEST(StatisticsComparison, withByteArray) {
+  NodePtr Node = PrimitiveNode::make(
+      "string_col",
+      Repetition::kRequired,
+      Type::kByteArray,
+      ConvertedType::kUtf8);
+  ColumnDescriptor descr(Node, 0, 0);
+
+  auto stats1 = makeStats(&descr, {"apple", "zebra"});
+  auto stats2 = makeStats(&descr, {"banana", "mangomango"});
+
+  ASSERT_TRUE(stats1->hasMinMax());
+  ASSERT_TRUE(stats2->hasMinMax());
+
+  EXPECT_TRUE(stats1->maxGreaterThan(*stats2));
+  EXPECT_FALSE(stats2->maxGreaterThan(*stats1));
+
+  EXPECT_TRUE(stats1->minLessThan(*stats2));
+  EXPECT_FALSE(stats2->minLessThan(*stats1));
+}
+
 } // namespace test
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/tests/StringTruncationTest.cpp b/velox/dwio/parquet/writer/arrow/tests/StringTruncationTest.cpp
new file mode 100644
index 00000000000..a0486b0c1d0
--- /dev/null
+++ b/velox/dwio/parquet/writer/arrow/tests/StringTruncationTest.cpp
@@ -0,0 +1,271 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "velox/dwio/parquet/writer/arrow/StringTruncation.h"
+
+namespace facebook::velox::parquet::arrow {
+
+// Tests for string utility functions used in statistics
+TEST(StringTruncation, truncateUtf8) {
+  auto testTruncate = [](const std::string& input,
+                         int32_t numCodePoints,
+                         const std::string& expected) {
+    EXPECT_EQ(truncateUtf8(input, numCodePoints), expected);
+  };
+
+  // ASCII string.
+  std::string ascii = "Hello, world!";
+  testTruncate(ascii, 0, "");
+  testTruncate(ascii, 1, "H");
+  testTruncate(ascii, 5, "Hello");
+  testTruncate(ascii, 13, ascii);
+  testTruncate(ascii, 20, ascii);
+
+  // String with multi-bytes characters.
+  std::string unicode = "Hello, 世界!";
+  testTruncate(unicode, 7, "Hello, ");
+  testTruncate(unicode, 8, "Hello, 世");
+  testTruncate(unicode, 9, "Hello, 世界");
+  testTruncate(unicode, 10, unicode);
+  testTruncate(unicode, 20, unicode);
+
+  // String with emoji (surrogate pairs).
+  std::string emoji = "Hello 🌍!";
+  testTruncate(emoji, 6, "Hello ");
+  testTruncate(emoji, 7, "Hello 🌍");
+  testTruncate(emoji, 8, emoji);
+  testTruncate(emoji, 10, emoji);
+
+  std::string empty = "";
+  testTruncate(empty, 0, "");
+  testTruncate(empty, 5, "");
+
+  std::string mixed = "café世界🌍";
+  testTruncate(mixed, 3, "caf");
+  testTruncate(mixed, 4, "café");
+  testTruncate(mixed, 5, "café世");
+  testTruncate(mixed, 6, "café世界");
+  testTruncate(mixed, 7, mixed);
+}
+
+TEST(StringTruncation, roundUpUtf8) {
+  auto testRoundUp = [](const std::string& input,
+                        int32_t numCodePoints,
+                        const std::optional<std::string>& expected) {
+    EXPECT_EQ(roundUpUtf8(input, numCodePoints), expected);
+  };
+
+  std::string ascii = "Hello, world!";
+  // Empty truncation returns nullopt.
+  testRoundUp(ascii, 0, std::nullopt);
+  // 'o' -> 'p'.
+  testRoundUp(ascii, 5, "Hellp");
+  testRoundUp(ascii, ascii.length(), ascii);
+
+  ascii = "Customer#000001500";
+  // '5' -> '6'.
+  testRoundUp(ascii, 16, "Customer#0000016");
+
+  std::string unicode = "Hello, 世界!";
+  testRoundUp(unicode, 8, "Hello, 丗");
+
+  // No truncation needed.
+  std::string shortString = "Hi";
+  testRoundUp(shortString, 2, shortString);
+  testRoundUp(shortString, 20, shortString);
+
+  // Last character is already at maximum value, returns nullopt.
+  std::string maxChar = "Hello\U0010FFFF";
+  testRoundUp(maxChar, 6, maxChar);
+
+  std::string empty = "";
+  testRoundUp(empty, 0, "");
+  testRoundUp(empty, 5, "");
+
+  std::string single = "a";
+  // No truncation needed.
+  testRoundUp(single, 1, "a");
+
+  std::string zChar = "zz";
+  // 'z' -> '{'.
+  testRoundUp(zChar, 1, "{");
+
+  std::string emojiTest = "🌍!!";
+  // U1F30D (🌍) -> U1F30E.
+  testRoundUp(emojiTest, 1, "\U0001F30E");
+
+  std::string multiByteTest = "café+";
+  // 'f' -> 'g'.
+  testRoundUp(multiByteTest, 3, "cag");
+  // 'é' -> 'ê'.
+  testRoundUp(multiByteTest, 4, "cafê");
+
+  // Test surrogate boundary: U+D7FF should increment to U+E000 (skipping
+  // surrogate range U+D800-U+DFFF).
+  // U+D7FF followed by "!!"
+  std::string surrogateTest = "\xED\x9F\xBF!!";
+  // U+E000
+  testRoundUp(surrogateTest, 1, "\xEE\x80\x80");
+
+  // Test all max code points - should return nullopt.
+  std::string allMax = "\U0010FFFF\U0010FFFF";
+  testRoundUp(allMax, 1, std::nullopt);
+}
+
+TEST(StringTruncation, roundUpBinary) {
+  auto testRoundUpBinary = [](const std::string& input,
+                              int32_t truncateLength,
+                              const std::optional<std::string>& expected) {
+    EXPECT_EQ(roundUpBinary(input, truncateLength), expected);
+  };
+
+  // Basic binary data with truncation.
+  std::string binary = "Hello, world!";
+  // Empty truncation returns nullopt.
+  testRoundUpBinary(binary, 0, std::nullopt);
+  // 'o' (0x6F) -> 'p' (0x70).
+  testRoundUpBinary(binary, 5, "Hellp");
+  // No truncation needed - returns input unchanged.
+  testRoundUpBinary(binary, binary.length(), binary);
+  testRoundUpBinary(binary, binary.length() + 10, binary);
+
+  // Test with numeric data.
+  std::string numeric = "Customer#000001500";
+  // '5' (0x35) -> '6' (0x36).
+  testRoundUpBinary(numeric, 16, "Customer#0000016");
+
+  // Test with binary data containing high bytes.
+  std::string highBytes = "data\xFE\xFD";
+  // No truncation needed - returns input unchanged.
+  testRoundUpBinary(highBytes, 6, highBytes);
+  // Truncate to 5 bytes "data\xFE", 0xFE -> 0xFF.
+  testRoundUpBinary(highBytes, 5, "data\xFF");
+
+  // Test with all 0xFF bytes - should return nullopt.
+  std::string allFF = "\xFF\xFF\xFF";
+  testRoundUpBinary(allFF, 1, std::nullopt);
+  testRoundUpBinary(allFF, 2, std::nullopt);
+  // No truncation needed - returns input unchanged.
+  testRoundUpBinary(allFF, 3, allFF);
+
+  // Test with trailing 0xFF bytes.
+  std::string trailingFF = "abc\xFF\xFF";
+  // No truncation needed - returns input unchanged.
+  testRoundUpBinary(trailingFF, 5, trailingFF);
+  // Truncate to 4 bytes "abc\xFF", 0xFF overflows, 'c' (0x63) -> 'd' (0x64).
+  testRoundUpBinary(trailingFF, 4, "abd");
+  // Truncate to 3 bytes "abc", 'c' (0x63) -> 'd' (0x64).
+  testRoundUpBinary(trailingFF, 3, "abd");
+
+  // Test empty string.
+  std::string empty = "";
+  testRoundUpBinary(empty, 0, std::nullopt);
+  testRoundUpBinary(empty, 5, "");
+
+  // Test single byte.
+  std::string single = "a";
+  // No truncation needed - returns input unchanged.
+  testRoundUpBinary(single, 1, "a");
+  testRoundUpBinary(single, 10, "a");
+
+  // Test incrementing single byte with truncation.
+  std::string singleZ = "zz";
+  // Truncate to 1 byte "z", 'z' (0x7A) -> '{' (0x7B).
+  testRoundUpBinary(singleZ, 1, "{");
+
+  // Test with null bytes.
+  std::string withNull = std::string("ab\0cd", 5);
+  // No truncation needed - returns input unchanged.
+  testRoundUpBinary(withNull, 5, withNull);
+  // Truncate to 4 bytes "ab\0c", 'c' (0x63) -> 'd' (0x64).
+  testRoundUpBinary(withNull, 4, std::string("ab\0d", 4));
+
+  // Test boundary case: 0xFE -> 0xFF.
+  std::string boundaryFE = "test\xFE";
+  // No truncation needed - returns input unchanged.
+  testRoundUpBinary(boundaryFE, 5, boundaryFE);
+  // Truncate to 5 bytes and increment would give same result.
+  std::string boundaryFE2 = std::string("test\xFE", 5) + "abc";
+  testRoundUpBinary(boundaryFE2, 5, "test\xFF");
+
+  // Test mixed case with overflow in middle.
+  std::string mixedOverflow = "a\xFF\xFFz";
+  // Truncate to 3 bytes "a\xFF\xFF", both 0xFF overflow, 'a' (0x61) -> 'b'
+  // (0x62).
+  testRoundUpBinary(mixedOverflow, 3, "b");
+
+  // Test truncation removes trailing bytes after increment.
+  std::string longString = "abcdefgh";
+  // Truncate to 3 bytes "abc", 'c' (0x63) -> 'd' (0x64), result is "abd".
+  testRoundUpBinary(longString, 3, "abd");
+  // Truncate to 5 bytes "abcde", 'e' (0x65) -> 'f' (0x66), result is "abcdf".
+  testRoundUpBinary(longString, 5, "abcdf");
+
+  // Test with UTF-8 multi-byte sequences (treated as raw bytes).
+  std::string utf8Bytes = "café";
+  // Truncate to 3 bytes "caf", 'f' (0x66) -> 'g' (0x67).
+  testRoundUpBinary(utf8Bytes, 3, "cag");
+  // No truncation needed - returns input unchanged.
+  testRoundUpBinary(utf8Bytes, 5, utf8Bytes);
+  // Truncate to 5 bytes and increment last byte.
+  std::string utf8Bytes2 = "café!";
+  // Truncate to 5 bytes "café" (caf + 0xC3 0xA9), 0xA9 -> 0xAA.
+  testRoundUpBinary(utf8Bytes2, 5, "caf\xC3\xAA");
+
+  // Test with INVALID UTF-8 sequences - this is the key use case for
+  // roundUpBinary. These sequences would cause roundUpUtf8 to fail, but
+  // roundUpBinary treats them as raw bytes.
+
+  // Invalid UTF-8: lone continuation byte 0x80.
+  std::string invalidUtf8_1 = std::string("test\x80", 5);
+  testRoundUpBinary(invalidUtf8_1, 5, invalidUtf8_1);
+  testRoundUpBinary(invalidUtf8_1, 4, "tesu");
+
+  // Invalid UTF-8: incomplete multi-byte sequence (0xC3 without continuation).
+  std::string invalidUtf8_2 = std::string("data\xC3", 5);
+  testRoundUpBinary(invalidUtf8_2, 5, invalidUtf8_2);
+  testRoundUpBinary(invalidUtf8_2, 4, "datb");
+
+  // Invalid UTF-8: overlong encoding (0xC0 0x80 for null byte).
+  std::string invalidUtf8_3 = std::string("ab\xC0\x80", 4);
+  testRoundUpBinary(invalidUtf8_3, 4, invalidUtf8_3);
+  testRoundUpBinary(invalidUtf8_3, 3, std::string("ab\xC1", 3));
+
+  // Invalid UTF-8: invalid start byte 0xFE.
+  std::string invalidUtf8_4 = std::string("xyz\xFE", 4);
+  testRoundUpBinary(invalidUtf8_4, 4, invalidUtf8_4);
+  testRoundUpBinary(invalidUtf8_4, 3, "xy{");
+
+  // Invalid UTF-8: truncated 3-byte sequence (0xE0 0x80 without third byte).
+  std::string invalidUtf8_5 = std::string("foo\xE0\x80", 5);
+  testRoundUpBinary(invalidUtf8_5, 5, invalidUtf8_5);
+  testRoundUpBinary(invalidUtf8_5, 4, std::string("foo\xE1", 4));
+
+  // Invalid UTF-8: sequence with 0xFF (which is never valid in UTF-8).
+  std::string invalidUtf8_6 = std::string("bar\xFF", 4);
+  testRoundUpBinary(invalidUtf8_6, 4, invalidUtf8_6);
+  // Truncate to 3 bytes "bar", 'r' (0x72) -> 's' (0x73).
+  testRoundUpBinary(invalidUtf8_6, 3, "bas");
+
+  // Test with all 0xFF in invalid UTF-8 context.
+  std::string invalidUtf8_7 = std::string("\xFF\xFF\xFF", 3);
+  testRoundUpBinary(invalidUtf8_7, 2, std::nullopt);
+  testRoundUpBinary(invalidUtf8_7, 3, invalidUtf8_7);
+}
+
+} // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/tests/TestUtil.cpp b/velox/dwio/parquet/writer/arrow/tests/TestUtil.cpp
index 47156197e1b..58b25d47cc3 100644
--- a/velox/dwio/parquet/writer/arrow/tests/TestUtil.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/TestUtil.cpp
@@ -36,7 +36,7 @@
 namespace facebook::velox::parquet::arrow {
 namespace test {
 
-const char* get_data_dir() {
+const char* getDataDir() {
   const auto result = std::getenv("PARQUET_TEST_DATA");
   if (!result || !result[0]) {
     throw ParquetTestException(
@@ -46,30 +46,30 @@ const char* get_data_dir() {
   return result;
 }
 
-std::string get_bad_data_dir() {
-  // PARQUET_TEST_DATA should point to
-  // ARROW_HOME/cpp/submodules/parquet-testing/data so need to reach one folder
-  // up to access the "bad_data" folder.
-  std::string data_dir(get_data_dir());
+std::string getBadDataDir() {
+  // PARQUET_TEST_DATA should point to.
+  // ARROW_HOME/cpp/submodules/parquet-testing/data so need to reach one folder.
+  // Up to access the "bad_data" folder.
+  std::string dataDir(getDataDir());
   std::stringstream ss;
-  ss << data_dir << "/../bad_data";
+  ss << dataDir << "/../bad_data";
   return ss.str();
 }
 
-std::string get_data_file(const std::string& filename, bool is_good) {
+std::string getDataFile(const std::string& filename, bool isGood) {
   std::stringstream ss;
 
-  if (is_good) {
-    ss << get_data_dir();
+  if (isGood) {
+    ss << getDataDir();
   } else {
-    ss << get_bad_data_dir();
+    ss << getBadDataDir();
   }
 
   ss << "/" << filename;
   return ss.str();
 }
 
-void random_bytes(int n, uint32_t seed, std::vector<uint8_t>* out) {
+void randomBytes(int n, uint32_t seed, std::vector<uint8_t>* out) {
   std::default_random_engine gen(seed);
   std::uniform_int_distribution<int> d(0, 255);
 
@@ -79,7 +79,7 @@ void random_bytes(int n, uint32_t seed, std::vector<uint8_t>* out) {
   }
 }
 
-void random_bools(int n, double p, uint32_t seed, bool* out) {
+void randomBools(int n, double p, uint32_t seed, bool* out) {
   std::default_random_engine gen(seed);
   std::bernoulli_distribution d(p);
   for (int i = 0; i < n; ++i) {
@@ -87,14 +87,14 @@ void random_bools(int n, double p, uint32_t seed, bool* out) {
   }
 }
 
-void random_Int96_numbers(
+void randomInt96Numbers(
     int n,
     uint32_t seed,
-    int32_t min_value,
-    int32_t max_value,
+    int32_t minValue,
+    int32_t maxValue,
     Int96* out) {
   std::default_random_engine gen(seed);
-  std::uniform_int_distribution<int32_t> d(min_value, max_value);
+  std::uniform_int_distribution<int32_t> d(minValue, maxValue);
   for (int i = 0; i < n; ++i) {
     out[i].value[0] = d(gen);
     out[i].value[1] = d(gen);
@@ -102,7 +102,7 @@ void random_Int96_numbers(
   }
 }
 
-void random_fixed_byte_array(
+void randomFixedByteArray(
     int n,
     uint32_t seed,
     uint8_t* buf,
@@ -119,15 +119,15 @@ void random_fixed_byte_array(
   }
 }
 
-void random_byte_array(
+void randomByteArray(
     int n,
     uint32_t seed,
     uint8_t* buf,
     ByteArray* out,
-    int min_size,
-    int max_size) {
+    int minSize,
+    int maxSize) {
   std::default_random_engine gen(seed);
-  std::uniform_int_distribution<int> d1(min_size, max_size);
+  std::uniform_int_distribution<int> d1(minSize, maxSize);
   std::uniform_int_distribution<int> d2(0, 255);
   for (int i = 0; i < n; ++i) {
     int len = d1(gen);
@@ -140,13 +140,13 @@ void random_byte_array(
   }
 }
 
-void random_byte_array(
+void randomByteArray(
     int n,
     uint32_t seed,
     uint8_t* buf,
     ByteArray* out,
-    int max_size) {
-  random_byte_array(n, seed, buf, out, 0, max_size);
+    int maxSize) {
+  randomByteArray(n, seed, buf, out, 0, maxSize);
 }
 
 } // namespace test
diff --git a/velox/dwio/parquet/writer/arrow/tests/TestUtil.h b/velox/dwio/parquet/writer/arrow/tests/TestUtil.h
index 79f3dc3992c..019f79541c4 100644
--- a/velox/dwio/parquet/writer/arrow/tests/TestUtil.h
+++ b/velox/dwio/parquet/writer/arrow/tests/TestUtil.h
@@ -38,14 +38,14 @@
 #include "velox/dwio/parquet/writer/arrow/tests/ColumnReader.h"
 
 // https://github.com/google/googletest/pull/2904 might not be available
-// in our version of gtest/gmock
-#define EXPECT_THROW_THAT(callable, ex_type, property)   \
-  EXPECT_THROW(                                          \
-      try { (callable)(); } catch (const ex_type& err) { \
-        EXPECT_THAT(err, (property));                    \
-        throw;                                           \
-      },                                                 \
-      ex_type)
+// In our version of gtest/gmock.
+#define EXPECT_THROW_THAT(callable, exType, property)   \
+  EXPECT_THROW(                                         \
+      try { (callable)(); } catch (const exType& err) { \
+        EXPECT_THAT(err, (property));                   \
+        throw;                                          \
+      },                                                \
+      exType)
 
 namespace facebook::velox::parquet::arrow {
 
@@ -72,13 +72,13 @@ class ParquetTestException : public ParquetException {
   using ParquetException::ParquetException;
 };
 
-const char* get_data_dir();
-std::string get_bad_data_dir();
+const char* getDataDir();
+std::string getBadDataDir();
 
-std::string get_data_file(const std::string& filename, bool is_good = true);
+std::string getDataFile(const std::string& filename, bool isGood = true);
 
 template <typename T>
-static inline void assert_vector_equal(
+static inline void assertVectorEqual(
     const std::vector<T>& left,
     const std::vector<T>& right) {
   ASSERT_EQ(left.size(), right.size());
@@ -89,7 +89,7 @@ static inline void assert_vector_equal(
 }
 
 template <typename T>
-static inline bool vector_equal(
+static inline bool vectorEqual(
     const std::vector<T>& left,
     const std::vector<T>& right) {
   if (left.size() != right.size()) {
@@ -120,96 +120,96 @@ static std::vector<T> slice(const std::vector<T>& values, int start, int end) {
   return out;
 }
 
-void random_bytes(int n, uint32_t seed, std::vector<uint8_t>* out);
-void random_bools(int n, double p, uint32_t seed, bool* out);
+void randomBytes(int n, uint32_t seed, std::vector<uint8_t>* out);
+void randomBools(int n, double p, uint32_t seed, bool* out);
 
 template <typename T>
 inline void
-random_numbers(int n, uint32_t seed, T min_value, T max_value, T* out) {
+randomNumbers(int n, uint32_t seed, T minValue, T maxValue, T* out) {
   std::default_random_engine gen(seed);
-  std::uniform_int_distribution<T> d(min_value, max_value);
+  std::uniform_int_distribution<T> d(minValue, maxValue);
   for (int i = 0; i < n; ++i) {
     out[i] = d(gen);
   }
 }
 
 template <>
-inline void random_numbers(
+inline void randomNumbers(
     int n,
     uint32_t seed,
-    float min_value,
-    float max_value,
+    float minValue,
+    float maxValue,
     float* out) {
   std::default_random_engine gen(seed);
-  std::uniform_real_distribution<float> d(min_value, max_value);
+  std::uniform_real_distribution<float> d(minValue, maxValue);
   for (int i = 0; i < n; ++i) {
     out[i] = d(gen);
   }
 }
 
 template <>
-inline void random_numbers(
+inline void randomNumbers(
     int n,
     uint32_t seed,
-    double min_value,
-    double max_value,
+    double minValue,
+    double maxValue,
     double* out) {
   std::default_random_engine gen(seed);
-  std::uniform_real_distribution<double> d(min_value, max_value);
+  std::uniform_real_distribution<double> d(minValue, maxValue);
   for (int i = 0; i < n; ++i) {
     out[i] = d(gen);
   }
 }
 
-void random_Int96_numbers(
+void randomInt96Numbers(
     int n,
     uint32_t seed,
-    int32_t min_value,
-    int32_t max_value,
+    int32_t minValue,
+    int32_t maxValue,
     Int96* out);
 
-void random_fixed_byte_array(
+void randomFixedByteArray(
     int n,
     uint32_t seed,
     uint8_t* buf,
     int len,
     FLBA* out);
 
-void random_byte_array(
+void randomByteArray(
     int n,
     uint32_t seed,
     uint8_t* buf,
     ByteArray* out,
-    int min_size,
-    int max_size);
+    int minSize,
+    int maxSize);
 
-void random_byte_array(
+void randomByteArray(
     int n,
     uint32_t seed,
     uint8_t* buf,
     ByteArray* out,
-    int max_size);
+    int maxSize);
 
 template <typename Type, typename Sequence>
-std::shared_ptr<Buffer> EncodeValues(
+std::shared_ptr<Buffer> encodeValues(
     Encoding::type encoding,
-    bool use_dictionary,
+    bool useDictionary,
     const Sequence& values,
     int length,
     const ColumnDescriptor* descr) {
-  auto encoder = MakeTypedEncoder<Type>(encoding, use_dictionary, descr);
-  encoder->Put(values, length);
-  return encoder->FlushValues();
+  auto encoder = makeTypedEncoder<Type>(encoding, useDictionary, descr);
+  encoder->put(values, length);
+  return encoder->flushValues();
 }
 
 template <typename T>
-static void InitValues(
-    int num_values,
+static void initValues(
+    int numValues,
     uint32_t seed,
     std::vector<T>& values,
     std::vector<uint8_t>& buffer) {
-  random_numbers(
-      num_values,
+  randomNumbers(
+      numValues,
       seed,
       std::numeric_limits<T>::min(),
       std::numeric_limits<T>::max(),
@@ -217,283 +217,283 @@ static void InitValues(
 }
 
 template <typename T>
-static void InitValues(
-    int num_values,
+static void initValues(
+    int numValues,
     std::vector<T>& values,
     std::vector<uint8_t>& buffer) {
-  InitValues(num_values, 0, values, buffer);
+  initValues(numValues, 0, values, buffer);
 }
 
 template <typename T>
-static void InitDictValues(
-    int num_values,
-    int num_dicts,
+static void initDictValues(
+    int numValues,
+    int numDicts,
     std::vector<T>& values,
     std::vector<uint8_t>& buffer) {
-  int repeat_factor = num_values / num_dicts;
-  InitValues<T>(num_dicts, values, buffer);
-  // add some repeated values
-  for (int j = 1; j < repeat_factor; ++j) {
-    for (int i = 0; i < num_dicts; ++i) {
-      std::memcpy(&values[num_dicts * j + i], &values[i], sizeof(T));
+  int repeatFactor = numValues / numDicts;
+  initValues<T>(numDicts, values, buffer);
+  // Add some repeated values.
+  for (int j = 1; j < repeatFactor; ++j) {
+    for (int i = 0; i < numDicts; ++i) {
+      std::memcpy(&values[numDicts * j + i], &values[i], sizeof(T));
     }
   }
-  // computed only dict_per_page * repeat_factor - 1 values < num_values
-  // compute remaining
-  for (int i = num_dicts * repeat_factor; i < num_values; ++i) {
-    std::memcpy(&values[i], &values[i - num_dicts * repeat_factor], sizeof(T));
+  // Computed only dict_per_page * repeat_factor - 1 values < num_values.
+  // Compute remaining.
+  for (int i = numDicts * repeatFactor; i < numValues; ++i) {
+    std::memcpy(&values[i], &values[i - numDicts * repeatFactor], sizeof(T));
   }
 }
 
 template <>
-inline void InitDictValues<bool>(
-    int num_values,
-    int num_dicts,
+inline void initDictValues<bool>(
+    int numValues,
+    int numDicts,
     std::vector<bool>& values,
     std::vector<uint8_t>& buffer) {
-  // No op for bool
+  // No op for bool.
 }
 
 class MockPageReader : public PageReader {
  public:
   explicit MockPageReader(const std::vector<std::shared_ptr<Page>>& pages)
-      : pages_(pages), page_index_(0) {}
+      : pages_(pages), pageIndex_(0) {}
 
-  std::shared_ptr<Page> NextPage() override {
-    if (page_index_ == static_cast<int>(pages_.size())) {
-      // EOS to consumer
+  std::shared_ptr<Page> nextPage() override {
+    if (pageIndex_ == static_cast<int>(pages_.size())) {
+      // EOS to consumer.
       return std::shared_ptr<Page>(nullptr);
     }
-    return pages_[page_index_++];
+    return pages_[pageIndex_++];
   }
 
-  // No-op
-  void set_max_page_header_size(uint32_t size) override {}
+  // No-op.
+  void setMaxPageHeaderSize(uint32_t size) override {}
 
  private:
   std::vector<std::shared_ptr<Page>> pages_;
-  int page_index_;
+  int pageIndex_;
 };
 
-// TODO(wesm): this is only used for testing for now. Refactor to form part of
-// primary file write path
+// TODO(wesm): this is only used for testing for now. Refactor to form part of.
+// Primary file write path.
 template <typename Type>
 class DataPageBuilder {
  public:
-  using c_type = typename Type::c_type;
+  using CType = typename Type::CType;
 
-  // This class writes data and metadata to the passed inputs
+  // This class writes data and metadata to the passed inputs.
   explicit DataPageBuilder(ArrowOutputStream* sink)
       : sink_(sink),
-        num_values_(0),
-        encoding_(Encoding::PLAIN),
-        definition_level_encoding_(Encoding::RLE),
-        repetition_level_encoding_(Encoding::RLE),
-        have_def_levels_(false),
-        have_rep_levels_(false),
-        have_values_(false) {}
-
-  void AppendDefLevels(
+        numValues_(0),
+        encoding_(Encoding::kPlain),
+        definitionLevelEncoding_(Encoding::kRle),
+        repetitionLevelEncoding_(Encoding::kRle),
+        haveDefLevels_(false),
+        haveRepLevels_(false),
+        haveValues_(false) {}
+
+  void appendDefLevels(
       const std::vector<int16_t>& levels,
-      int16_t max_level,
-      Encoding::type encoding = Encoding::RLE) {
-    AppendLevels(levels, max_level, encoding);
+      int16_t maxLevel,
+      Encoding::type encoding = Encoding::kRle) {
+    appendLevels(levels, maxLevel, encoding);
 
-    num_values_ = std::max(static_cast<int32_t>(levels.size()), num_values_);
-    definition_level_encoding_ = encoding;
-    have_def_levels_ = true;
+    numValues_ = std::max(static_cast<int32_t>(levels.size()), numValues_);
+    definitionLevelEncoding_ = encoding;
+    haveDefLevels_ = true;
   }
 
-  void AppendRepLevels(
+  void appendRepLevels(
       const std::vector<int16_t>& levels,
-      int16_t max_level,
-      Encoding::type encoding = Encoding::RLE) {
-    AppendLevels(levels, max_level, encoding);
+      int16_t maxLevel,
+      Encoding::type encoding = Encoding::kRle) {
+    appendLevels(levels, maxLevel, encoding);
 
-    num_values_ = std::max(static_cast<int32_t>(levels.size()), num_values_);
-    repetition_level_encoding_ = encoding;
-    have_rep_levels_ = true;
+    numValues_ = std::max(static_cast<int32_t>(levels.size()), numValues_);
+    repetitionLevelEncoding_ = encoding;
+    haveRepLevels_ = true;
   }
 
-  void AppendValues(
+  void appendValues(
       const ColumnDescriptor* d,
-      const std::vector<c_type>& values,
-      Encoding::type encoding = Encoding::PLAIN) {
-    std::shared_ptr<Buffer> values_sink = EncodeValues<Type>(
+      const std::vector<CType>& values,
+      Encoding::type encoding = Encoding::kPlain) {
+    std::shared_ptr<Buffer> valuesSink = encodeValues<Type>(
         encoding, false, values.data(), static_cast<int>(values.size()), d);
-    PARQUET_THROW_NOT_OK(
-        sink_->Write(values_sink->data(), values_sink->size()));
+    PARQUET_THROW_NOT_OK(sink_->Write(valuesSink->data(), valuesSink->size()));
 
-    num_values_ = std::max(static_cast<int32_t>(values.size()), num_values_);
+    numValues_ = std::max(static_cast<int32_t>(values.size()), numValues_);
     encoding_ = encoding;
-    have_values_ = true;
+    haveValues_ = true;
   }
 
-  int32_t num_values() const {
-    return num_values_;
+  int32_t numValues() const {
+    return numValues_;
   }
 
   Encoding::type encoding() const {
     return encoding_;
   }
 
-  Encoding::type rep_level_encoding() const {
-    return repetition_level_encoding_;
+  Encoding::type repLevelEncoding() const {
+    return repetitionLevelEncoding_;
   }
 
-  Encoding::type def_level_encoding() const {
-    return definition_level_encoding_;
+  Encoding::type defLevelEncoding() const {
+    return definitionLevelEncoding_;
   }
 
  private:
   ArrowOutputStream* sink_;
 
-  int32_t num_values_;
+  int32_t numValues_;
   Encoding::type encoding_;
-  Encoding::type definition_level_encoding_;
-  Encoding::type repetition_level_encoding_;
+  Encoding::type definitionLevelEncoding_;
+  Encoding::type repetitionLevelEncoding_;
 
-  bool have_def_levels_;
-  bool have_rep_levels_;
-  bool have_values_;
+  bool haveDefLevels_;
+  bool haveRepLevels_;
+  bool haveValues_;
 
-  // Used internally for both repetition and definition levels
-  void AppendLevels(
+  // Used internally for both repetition and definition levels.
+  void appendLevels(
       const std::vector<int16_t>& levels,
-      int16_t max_level,
+      int16_t maxLevel,
       Encoding::type encoding) {
-    if (encoding != Encoding::RLE) {
+    if (encoding != Encoding::kRle) {
       ParquetException::NYI("only rle encoding currently implemented");
     }
 
-    std::vector<uint8_t> encode_buffer(LevelEncoder::MaxBufferSize(
-        Encoding::RLE, max_level, static_cast<int>(levels.size())));
+    std::vector<uint8_t> encodeBuffer(
+        LevelEncoder::maxBufferSize(
+            Encoding::kRle, maxLevel, static_cast<int>(levels.size())));
 
-    // We encode into separate memory from the output stream because the
-    // RLE-encoded bytes have to be preceded in the stream by their absolute
-    // size.
+    // We encode into separate memory from the output stream because the.
+    // RLE-encoded bytes have to be preceded in the stream by their absolute.
+    // Size.
     LevelEncoder encoder;
-    encoder.Init(
+    encoder.init(
         encoding,
-        max_level,
+        maxLevel,
         static_cast<int>(levels.size()),
-        encode_buffer.data(),
-        static_cast<int>(encode_buffer.size()));
+        encodeBuffer.data(),
+        static_cast<int>(encodeBuffer.size()));
 
-    encoder.Encode(static_cast<int>(levels.size()), levels.data());
+    encoder.encode(static_cast<int>(levels.size()), levels.data());
 
-    int32_t rle_bytes = encoder.len();
+    int32_t rleBytes = encoder.len();
     PARQUET_THROW_NOT_OK(sink_->Write(
-        reinterpret_cast<const uint8_t*>(&rle_bytes), sizeof(int32_t)));
-    PARQUET_THROW_NOT_OK(sink_->Write(encode_buffer.data(), rle_bytes));
+        reinterpret_cast<const uint8_t*>(&rleBytes), sizeof(int32_t)));
+    PARQUET_THROW_NOT_OK(sink_->Write(encodeBuffer.data(), rleBytes));
   }
 };
 
 template <>
-inline void DataPageBuilder<BooleanType>::AppendValues(
+inline void DataPageBuilder<BooleanType>::appendValues(
     const ColumnDescriptor* d,
     const std::vector<bool>& values,
     Encoding::type encoding) {
-  if (encoding != Encoding::PLAIN) {
+  if (encoding != Encoding::kPlain) {
     ParquetException::NYI("only plain encoding currently implemented");
   }
 
-  auto encoder = MakeTypedEncoder<BooleanType>(Encoding::PLAIN, false, d);
+  auto encoder = makeTypedEncoder<BooleanType>(Encoding::kPlain, false, d);
   dynamic_cast<BooleanEncoder*>(encoder.get())
-      ->Put(values, static_cast<int>(values.size()));
-  std::shared_ptr<Buffer> buffer = encoder->FlushValues();
+      ->put(values, static_cast<int>(values.size()));
+  std::shared_ptr<Buffer> buffer = encoder->flushValues();
   PARQUET_THROW_NOT_OK(sink_->Write(buffer->data(), buffer->size()));
 
-  num_values_ = std::max(static_cast<int32_t>(values.size()), num_values_);
+  numValues_ = std::max(static_cast<int32_t>(values.size()), numValues_);
   encoding_ = encoding;
-  have_values_ = true;
+  haveValues_ = true;
 }
 
 template <typename Type>
-static std::shared_ptr<DataPageV1> MakeDataPage(
+static std::shared_ptr<DataPageV1> makeDataPage(
     const ColumnDescriptor* d,
-    const std::vector<typename Type::c_type>& values,
-    int num_vals,
+    const std::vector<typename Type::CType>& values,
+    int numVals,
     Encoding::type encoding,
     const uint8_t* indices,
-    int indices_size,
-    const std::vector<int16_t>& def_levels,
-    int16_t max_def_level,
-    const std::vector<int16_t>& rep_levels,
-    int16_t max_rep_level) {
-  int num_values = 0;
+    int indicesSize,
+    const std::vector<int16_t>& defLevels,
+    int16_t maxDefLevel,
+    const std::vector<int16_t>& repLevels,
+    int16_t maxRepLevel) {
+  int numValues = 0;
 
-  auto page_stream = CreateOutputStream();
-  test::DataPageBuilder<Type> page_builder(page_stream.get());
+  auto pageStream = createOutputStream();
+  test::DataPageBuilder<Type> pageBuilder(pageStream.get());
 
-  if (!rep_levels.empty()) {
-    page_builder.AppendRepLevels(rep_levels, max_rep_level);
+  if (!repLevels.empty()) {
+    pageBuilder.appendRepLevels(repLevels, maxRepLevel);
   }
-  if (!def_levels.empty()) {
-    page_builder.AppendDefLevels(def_levels, max_def_level);
+  if (!defLevels.empty()) {
+    pageBuilder.appendDefLevels(defLevels, maxDefLevel);
   }
 
-  if (encoding == Encoding::PLAIN) {
-    page_builder.AppendValues(d, values, encoding);
-    num_values = std::max(page_builder.num_values(), num_vals);
+  if (encoding == Encoding::kPlain) {
+    pageBuilder.appendValues(d, values, encoding);
+    numValues = std::max(pageBuilder.numValues(), numVals);
   } else { // DICTIONARY PAGES
-    PARQUET_THROW_NOT_OK(page_stream->Write(indices, indices_size));
-    num_values = std::max(page_builder.num_values(), num_vals);
+    PARQUET_THROW_NOT_OK(pageStream->Write(indices, indicesSize));
+    numValues = std::max(pageBuilder.numValues(), numVals);
   }
 
-  PARQUET_ASSIGN_OR_THROW(auto buffer, page_stream->Finish());
+  PARQUET_ASSIGN_OR_THROW(auto buffer, pageStream->Finish());
 
   return std::make_shared<DataPageV1>(
       buffer,
-      num_values,
+      numValues,
       encoding,
-      page_builder.def_level_encoding(),
-      page_builder.rep_level_encoding(),
+      pageBuilder.defLevelEncoding(),
+      pageBuilder.repLevelEncoding(),
       buffer->size());
 }
 
 template <typename TYPE>
 class DictionaryPageBuilder {
  public:
-  typedef typename TYPE::c_type TC;
-  static constexpr int TN = TYPE::type_num;
+  typedef typename TYPE::CType TC;
+  static constexpr int TN = TYPE::typeNum;
   using SpecializedEncoder = typename EncodingTraits<TYPE>::Encoder;
 
-  // This class writes data and metadata to the passed inputs
+  // This class writes data and metadata to the passed inputs.
   explicit DictionaryPageBuilder(const ColumnDescriptor* d)
-      : num_dict_values_(0), have_values_(false) {
-    auto encoder = MakeTypedEncoder<TYPE>(Encoding::PLAIN, true, d);
-    dict_traits_ = dynamic_cast<DictEncoder<TYPE>*>(encoder.get());
+      : numDictValues_(0), haveValues_(false) {
+    auto encoder = makeTypedEncoder<TYPE>(Encoding::kPlain, true, d);
+    dictTraits_ = dynamic_cast<DictEncoder<TYPE>*>(encoder.get());
     encoder_.reset(dynamic_cast<SpecializedEncoder*>(encoder.release()));
   }
 
   ~DictionaryPageBuilder() {}
 
-  std::shared_ptr<Buffer> AppendValues(const std::vector<TC>& values) {
-    int num_values = static_cast<int>(values.size());
-    // Dictionary encoding
-    encoder_->Put(values.data(), num_values);
-    num_dict_values_ = dict_traits_->num_entries();
-    have_values_ = true;
-    return encoder_->FlushValues();
+  std::shared_ptr<Buffer> appendValues(const std::vector<TC>& values) {
+    int numValues = static_cast<int>(values.size());
+    // Dictionary encoding.
+    encoder_->put(values.data(), numValues);
+    numDictValues_ = dictTraits_->numEntries();
+    haveValues_ = true;
+    return encoder_->flushValues();
   }
 
-  std::shared_ptr<Buffer> WriteDict() {
-    std::shared_ptr<Buffer> dict_buffer = AllocateBuffer(
-        ::arrow::default_memory_pool(), dict_traits_->dict_encoded_size());
-    dict_traits_->WriteDict(dict_buffer->mutable_data());
-    return dict_buffer;
+  std::shared_ptr<Buffer> writeDict() {
+    std::shared_ptr<Buffer> dictBuffer = allocateBuffer(
+        ::arrow::default_memory_pool(), dictTraits_->dictEncodedSize());
+    dictTraits_->writeDict(dictBuffer->mutable_data());
+    return dictBuffer;
   }
 
-  int32_t num_values() const {
-    return num_dict_values_;
+  int32_t numValues() const {
+    return numDictValues_;
   }
 
  private:
-  DictEncoder<TYPE>* dict_traits_;
+  DictEncoder<TYPE>* dictTraits_;
   std::unique_ptr<SpecializedEncoder> encoder_;
-  int32_t num_dict_values_;
-  bool have_values_;
+  int32_t numDictValues_;
+  bool haveValues_;
 };
 
 template <>
@@ -504,14 +504,14 @@ inline DictionaryPageBuilder<BooleanType>::DictionaryPageBuilder(
 }
 
 template <>
-inline std::shared_ptr<Buffer> DictionaryPageBuilder<BooleanType>::WriteDict() {
+inline std::shared_ptr<Buffer> DictionaryPageBuilder<BooleanType>::writeDict() {
   ParquetException::NYI(
       "only plain encoding currently implemented for boolean");
   return nullptr;
 }
 
 template <>
-inline std::shared_ptr<Buffer> DictionaryPageBuilder<BooleanType>::AppendValues(
+inline std::shared_ptr<Buffer> DictionaryPageBuilder<BooleanType>::appendValues(
     const std::vector<TC>& values) {
   ParquetException::NYI(
       "only plain encoding currently implemented for boolean");
@@ -519,213 +519,212 @@ inline std::shared_ptr<Buffer> DictionaryPageBuilder<BooleanType>::AppendValues(
 }
 
 template <typename Type>
-inline static std::shared_ptr<DictionaryPage> MakeDictPage(
+inline static std::shared_ptr<DictionaryPage> makeDictPage(
     const ColumnDescriptor* d,
-    const std::vector<typename Type::c_type>& values,
-    const std::vector<int>& values_per_page,
+    const std::vector<typename Type::CType>& values,
+    const std::vector<int>& valuesPerPage,
     Encoding::type encoding,
-    std::vector<std::shared_ptr<Buffer>>& rle_indices) {
-  test::DictionaryPageBuilder<Type> page_builder(d);
-  int num_pages = static_cast<int>(values_per_page.size());
-  int value_start = 0;
+    std::vector<std::shared_ptr<Buffer>>& rleIndices) {
+  test::DictionaryPageBuilder<Type> pageBuilder(d);
+  int numPages = static_cast<int>(valuesPerPage.size());
+  int valueStart = 0;
 
-  for (int i = 0; i < num_pages; i++) {
-    rle_indices.push_back(page_builder.AppendValues(
-        slice(values, value_start, value_start + values_per_page[i])));
-    value_start += values_per_page[i];
+  for (int i = 0; i < numPages; i++) {
+    rleIndices.push_back(pageBuilder.appendValues(
+        slice(values, valueStart, valueStart + valuesPerPage[i])));
+    valueStart += valuesPerPage[i];
   }
 
-  auto buffer = page_builder.WriteDict();
+  auto buffer = pageBuilder.writeDict();
 
   return std::make_shared<DictionaryPage>(
-      buffer, page_builder.num_values(), Encoding::PLAIN);
+      buffer, pageBuilder.numValues(), Encoding::kPlain);
 }
 
-// Given def/rep levels and values create multiple dict pages
+// Given def/rep levels and values create multiple dict pages.
 template <typename Type>
-inline static void PaginateDict(
+inline static void paginateDict(
     const ColumnDescriptor* d,
-    const std::vector<typename Type::c_type>& values,
-    const std::vector<int16_t>& def_levels,
-    int16_t max_def_level,
-    const std::vector<int16_t>& rep_levels,
-    int16_t max_rep_level,
-    int num_levels_per_page,
-    const std::vector<int>& values_per_page,
+    const std::vector<typename Type::CType>& values,
+    const std::vector<int16_t>& defLevels,
+    int16_t maxDefLevel,
+    const std::vector<int16_t>& repLevels,
+    int16_t maxRepLevel,
+    int numLevelsPerPage,
+    const std::vector<int>& valuesPerPage,
     std::vector<std::shared_ptr<Page>>& pages,
-    Encoding::type encoding = Encoding::RLE_DICTIONARY) {
-  int num_pages = static_cast<int>(values_per_page.size());
-  std::vector<std::shared_ptr<Buffer>> rle_indices;
-  std::shared_ptr<DictionaryPage> dict_page =
-      MakeDictPage<Type>(d, values, values_per_page, encoding, rle_indices);
-  pages.push_back(dict_page);
-  int def_level_start = 0;
-  int def_level_end = 0;
-  int rep_level_start = 0;
-  int rep_level_end = 0;
-  for (int i = 0; i < num_pages; i++) {
-    if (max_def_level > 0) {
-      def_level_start = i * num_levels_per_page;
-      def_level_end = (i + 1) * num_levels_per_page;
+    Encoding::type encoding = Encoding::kRleDictionary) {
+  int numPages = static_cast<int>(valuesPerPage.size());
+  std::vector<std::shared_ptr<Buffer>> rleIndices;
+  std::shared_ptr<DictionaryPage> dictPage =
+      makeDictPage<Type>(d, values, valuesPerPage, encoding, rleIndices);
+  pages.push_back(dictPage);
+  int defLevelStart = 0;
+  int defLevelEnd = 0;
+  int repLevelStart = 0;
+  int repLevelEnd = 0;
+  for (int i = 0; i < numPages; i++) {
+    if (maxDefLevel > 0) {
+      defLevelStart = i * numLevelsPerPage;
+      defLevelEnd = (i + 1) * numLevelsPerPage;
     }
-    if (max_rep_level > 0) {
-      rep_level_start = i * num_levels_per_page;
-      rep_level_end = (i + 1) * num_levels_per_page;
+    if (maxRepLevel > 0) {
+      repLevelStart = i * numLevelsPerPage;
+      repLevelEnd = (i + 1) * numLevelsPerPage;
     }
-    std::shared_ptr<DataPageV1> data_page = MakeDataPage<Int32Type>(
+    std::shared_ptr<DataPageV1> dataPage = makeDataPage<Int32Type>(
         d,
         {},
-        values_per_page[i],
+        valuesPerPage[i],
         encoding,
-        rle_indices[i]->data(),
-        static_cast<int>(rle_indices[i]->size()),
-        slice(def_levels, def_level_start, def_level_end),
-        max_def_level,
-        slice(rep_levels, rep_level_start, rep_level_end),
-        max_rep_level);
-    pages.push_back(data_page);
+        rleIndices[i]->data(),
+        static_cast<int>(rleIndices[i]->size()),
+        slice(defLevels, defLevelStart, defLevelEnd),
+        maxDefLevel,
+        slice(repLevels, repLevelStart, repLevelEnd),
+        maxRepLevel);
+    pages.push_back(dataPage);
   }
 }
 
-// Given def/rep levels and values create multiple plain pages
+// Given def/rep levels and values create multiple plain pages.
 template <typename Type>
-static inline void PaginatePlain(
+static inline void paginatePlain(
     const ColumnDescriptor* d,
-    const std::vector<typename Type::c_type>& values,
-    const std::vector<int16_t>& def_levels,
-    int16_t max_def_level,
-    const std::vector<int16_t>& rep_levels,
-    int16_t max_rep_level,
-    int num_levels_per_page,
-    const std::vector<int>& values_per_page,
+    const std::vector<typename Type::CType>& values,
+    const std::vector<int16_t>& defLevels,
+    int16_t maxDefLevel,
+    const std::vector<int16_t>& repLevels,
+    int16_t maxRepLevel,
+    int numLevelsPerPage,
+    const std::vector<int>& valuesPerPage,
     std::vector<std::shared_ptr<Page>>& pages,
-    Encoding::type encoding = Encoding::PLAIN) {
-  int num_pages = static_cast<int>(values_per_page.size());
-  int def_level_start = 0;
-  int def_level_end = 0;
-  int rep_level_start = 0;
-  int rep_level_end = 0;
-  int value_start = 0;
-  for (int i = 0; i < num_pages; i++) {
-    if (max_def_level > 0) {
-      def_level_start = i * num_levels_per_page;
-      def_level_end = (i + 1) * num_levels_per_page;
+    Encoding::type encoding = Encoding::kPlain) {
+  int numPages = static_cast<int>(valuesPerPage.size());
+  int defLevelStart = 0;
+  int defLevelEnd = 0;
+  int repLevelStart = 0;
+  int repLevelEnd = 0;
+  int valueStart = 0;
+  for (int i = 0; i < numPages; i++) {
+    if (maxDefLevel > 0) {
+      defLevelStart = i * numLevelsPerPage;
+      defLevelEnd = (i + 1) * numLevelsPerPage;
     }
-    if (max_rep_level > 0) {
-      rep_level_start = i * num_levels_per_page;
-      rep_level_end = (i + 1) * num_levels_per_page;
+    if (maxRepLevel > 0) {
+      repLevelStart = i * numLevelsPerPage;
+      repLevelEnd = (i + 1) * numLevelsPerPage;
     }
-    std::shared_ptr<DataPage> page = MakeDataPage<Type>(
+    std::shared_ptr<DataPage> page = makeDataPage<Type>(
         d,
-        slice(values, value_start, value_start + values_per_page[i]),
-        values_per_page[i],
+        slice(values, valueStart, valueStart + valuesPerPage[i]),
+        valuesPerPage[i],
         encoding,
         nullptr,
         0,
-        slice(def_levels, def_level_start, def_level_end),
-        max_def_level,
-        slice(rep_levels, rep_level_start, rep_level_end),
-        max_rep_level);
+        slice(defLevels, defLevelStart, defLevelEnd),
+        maxDefLevel,
+        slice(repLevels, repLevelStart, repLevelEnd),
+        maxRepLevel);
     pages.push_back(page);
-    value_start += values_per_page[i];
+    valueStart += valuesPerPage[i];
   }
 }
 
-// Generates pages from randomly generated data
+// Generates pages from randomly generated data.
 template <typename Type>
-static inline int MakePages(
+static inline int makePages(
     const ColumnDescriptor* d,
-    int num_pages,
-    int levels_per_page,
-    std::vector<int16_t>& def_levels,
-    std::vector<int16_t>& rep_levels,
-    std::vector<typename Type::c_type>& values,
+    int numPages,
+    int levelsPerPage,
+    std::vector<int16_t>& defLevels,
+    std::vector<int16_t>& repLevels,
+    std::vector<typename Type::CType>& values,
     std::vector<uint8_t>& buffer,
     std::vector<std::shared_ptr<Page>>& pages,
-    Encoding::type encoding = Encoding::PLAIN,
+    Encoding::type encoding = Encoding::kPlain,
     uint32_t seed = 0) {
-  int num_levels = levels_per_page * num_pages;
-  int num_values = 0;
+  int numLevels = levelsPerPage * numPages;
+  int numValues = 0;
   int16_t zero = 0;
-  int16_t max_def_level = d->max_definition_level();
-  int16_t max_rep_level = d->max_repetition_level();
-  std::vector<int> values_per_page(num_pages, levels_per_page);
-  // Create definition levels
-  if (max_def_level > 0 && num_levels != 0) {
-    def_levels.resize(num_levels);
-    random_numbers(num_levels, seed, zero, max_def_level, def_levels.data());
-    for (int p = 0; p < num_pages; p++) {
-      int num_values_per_page = 0;
-      for (int i = 0; i < levels_per_page; i++) {
-        if (def_levels[i + p * levels_per_page] == max_def_level) {
-          num_values_per_page++;
-          num_values++;
+  int16_t maxDefLevel = d->maxDefinitionLevel();
+  int16_t maxRepLevel = d->maxRepetitionLevel();
+  std::vector<int> valuesPerPage(numPages, levelsPerPage);
+  // Create definition levels.
+  if (maxDefLevel > 0 && numLevels != 0) {
+    defLevels.resize(numLevels);
+    randomNumbers(numLevels, seed, zero, maxDefLevel, defLevels.data());
+    for (int p = 0; p < numPages; p++) {
+      int numValuesPerPage = 0;
+      for (int i = 0; i < levelsPerPage; i++) {
+        if (defLevels[i + p * levelsPerPage] == maxDefLevel) {
+          numValuesPerPage++;
+          numValues++;
         }
       }
-      values_per_page[p] = num_values_per_page;
+      valuesPerPage[p] = numValuesPerPage;
     }
   } else {
-    num_values = num_levels;
+    numValues = numLevels;
   }
-  // Create repitition levels
-  if (max_rep_level > 0 && num_levels != 0) {
-    rep_levels.resize(num_levels);
+  // Create repitition levels.
+  if (maxRepLevel > 0 && numLevels != 0) {
+    repLevels.resize(numLevels);
     // Using a different seed so that def_levels and rep_levels are different.
-    random_numbers(
-        num_levels, seed + 789, zero, max_rep_level, rep_levels.data());
-    // The generated levels are random. Force the very first page to start with
-    // a new record.
-    rep_levels[0] = 0;
+    randomNumbers(numLevels, seed + 789, zero, maxRepLevel, repLevels.data());
+    // The generated levels are random. Force the very first page to start with.
+    // A new record.
+    repLevels[0] = 0;
     // For a null value, rep_levels and def_levels are both 0.
-    // If we have a repeated value right after this, it needs to start with
-    // rep_level = 0 to indicate a new record.
-    for (int i = 0; i < num_levels - 1; ++i) {
-      if (rep_levels[i] == 0 && def_levels[i] == 0) {
-        rep_levels[i + 1] = 0;
+    // If we have a repeated value right after this, it needs to start with.
+    // Rep_level = 0 to indicate a new record.
+    for (int i = 0; i < numLevels - 1; ++i) {
+      if (repLevels[i] == 0 && defLevels[i] == 0) {
+        repLevels[i + 1] = 0;
       }
     }
   }
-  // Create values
-  values.resize(num_values);
-  if (encoding == Encoding::PLAIN) {
-    InitValues<typename Type::c_type>(num_values, values, buffer);
-    PaginatePlain<Type>(
+  // Create values.
+  values.resize(numValues);
+  if (encoding == Encoding::kPlain) {
+    initValues<typename Type::CType>(numValues, values, buffer);
+    paginatePlain<Type>(
         d,
         values,
-        def_levels,
-        max_def_level,
-        rep_levels,
-        max_rep_level,
-        levels_per_page,
-        values_per_page,
+        defLevels,
+        maxDefLevel,
+        repLevels,
+        maxRepLevel,
+        levelsPerPage,
+        valuesPerPage,
         pages);
   } else if (
-      encoding == Encoding::RLE_DICTIONARY ||
-      encoding == Encoding::PLAIN_DICTIONARY) {
-    // Calls InitValues and repeats the data
-    InitDictValues<typename Type::c_type>(
-        num_values, levels_per_page, values, buffer);
-    PaginateDict<Type>(
+      encoding == Encoding::kRleDictionary ||
+      encoding == Encoding::kPlainDictionary) {
+    // Calls InitValues and repeats the data.
+    initDictValues<typename Type::CType>(
+        numValues, levelsPerPage, values, buffer);
+    paginateDict<Type>(
         d,
         values,
-        def_levels,
-        max_def_level,
-        rep_levels,
-        max_rep_level,
-        levels_per_page,
-        values_per_page,
+        defLevels,
+        maxDefLevel,
+        repLevels,
+        maxRepLevel,
+        levelsPerPage,
+        valuesPerPage,
         pages);
   }
 
-  return num_values;
+  return numValues;
 }
 
-// ----------------------------------------------------------------------
-// Test data generation
+// ----------------------------------------------------------------------.
+// Test data generation.
 
 template <>
-void inline InitValues<bool>(
-    int num_values,
+void inline initValues<bool>(
+    int numValues,
     uint32_t seed,
     std::vector<bool>& values,
     std::vector<uint8_t>& buffer) {
@@ -733,185 +732,183 @@ void inline InitValues<bool>(
   if (seed == 0) {
     seed = static_cast<uint32_t>(::arrow::random_seed());
   }
-  ::arrow::random_is_valid(num_values, 0.5, &values, static_cast<int>(seed));
+  ::arrow::random_is_valid(numValues, 0.5, &values, static_cast<int>(seed));
 }
 
 template <>
-inline void InitValues<ByteArray>(
-    int num_values,
+inline void initValues<ByteArray>(
+    int numValues,
     uint32_t seed,
     std::vector<ByteArray>& values,
     std::vector<uint8_t>& buffer) {
-  int max_byte_array_len = 12;
-  int num_bytes = static_cast<int>(max_byte_array_len + sizeof(uint32_t));
-  size_t nbytes = num_values * num_bytes;
+  int maxByteArrayLen = 12;
+  int numBytes = static_cast<int>(maxByteArrayLen + sizeof(uint32_t));
+  size_t nbytes = numValues * numBytes;
   buffer.resize(nbytes);
-  random_byte_array(
-      num_values, seed, buffer.data(), values.data(), max_byte_array_len);
+  randomByteArray(
+      numValues, seed, buffer.data(), values.data(), maxByteArrayLen);
 }
 
-inline void InitWideByteArrayValues(
-    int num_values,
+inline void initWideByteArrayValues(
+    int numValues,
     std::vector<ByteArray>& values,
     std::vector<uint8_t>& buffer,
-    int min_len,
-    int max_len) {
-  int num_bytes = static_cast<int>(max_len + sizeof(uint32_t));
-  size_t nbytes = num_values * num_bytes;
+    int minLen,
+    int maxLen) {
+  int numBytes = static_cast<int>(maxLen + sizeof(uint32_t));
+  size_t nbytes = numValues * numBytes;
   buffer.resize(nbytes);
-  random_byte_array(
-      num_values, 0, buffer.data(), values.data(), min_len, max_len);
+  randomByteArray(numValues, 0, buffer.data(), values.data(), minLen, maxLen);
 }
 
 template <>
-inline void InitValues<FLBA>(
-    int num_values,
+inline void initValues<FLBA>(
+    int numValues,
     uint32_t seed,
     std::vector<FLBA>& values,
     std::vector<uint8_t>& buffer) {
-  size_t nbytes = num_values * FLBA_LENGTH;
+  size_t nbytes = numValues * FLBA_LENGTH;
   buffer.resize(nbytes);
-  random_fixed_byte_array(
-      num_values, seed, buffer.data(), FLBA_LENGTH, values.data());
+  randomFixedByteArray(
+      numValues, seed, buffer.data(), FLBA_LENGTH, values.data());
 }
 
 template <>
-inline void InitValues<Int96>(
-    int num_values,
+inline void initValues<Int96>(
+    int numValues,
     uint32_t seed,
     std::vector<Int96>& values,
     std::vector<uint8_t>& buffer) {
-  random_Int96_numbers(
-      num_values,
+  randomInt96Numbers(
+      numValues,
       seed,
       std::numeric_limits<int32_t>::min(),
       std::numeric_limits<int32_t>::max(),
       values.data());
 }
 
-inline std::string TestColumnName(int i) {
-  std::stringstream col_name;
-  col_name << "column_" << i;
-  return col_name.str();
+inline std::string testColumnName(int i) {
+  std::stringstream colName;
+  colName << "column_" << i;
+  return colName.str();
 }
 
-// This class lives here because of its dependency on the InitValues
-// specializations.
+// This class lives here because of its dependency on the InitValues.
+// Specializations.
 template <typename TestType>
 class PrimitiveTypedTest : public ::testing::Test {
  public:
-  using c_type = typename TestType::c_type;
+  using CType = typename TestType::CType;
 
-  void SetUpSchema(Repetition::type repetition, int num_columns = 1) {
+  void setUpSchema(Repetition::type repetition, int numColumns = 1) {
     std::vector<schema::NodePtr> fields;
 
-    for (int i = 0; i < num_columns; ++i) {
-      std::string name = TestColumnName(i);
-      fields.push_back(schema::PrimitiveNode::Make(
-          name,
-          repetition,
-          TestType::type_num,
-          ConvertedType::NONE,
-          FLBA_LENGTH));
+    for (int i = 0; i < numColumns; ++i) {
+      std::string name = testColumnName(i);
+      fields.push_back(
+          schema::PrimitiveNode::make(
+              name,
+              repetition,
+              TestType::typeNum,
+              ConvertedType::kNone,
+              FLBA_LENGTH));
     }
-    node_ = schema::GroupNode::Make("schema", Repetition::REQUIRED, fields);
-    schema_.Init(node_);
+    node_ = schema::GroupNode::make("schema", Repetition::kRequired, fields);
+    schema_.init(node_);
   }
 
-  void GenerateData(int64_t num_values, uint32_t seed = 0);
-  void SetupValuesOut(int64_t num_values);
-  void SyncValuesOut();
+  void generateData(int64_t numValues, uint32_t seed = 0);
+  void setupValuesOut(int64_t numValues);
+  void syncValuesOut();
 
  protected:
   schema::NodePtr node_;
   SchemaDescriptor schema_;
 
-  // Input buffers
-  std::vector<c_type> values_;
+  // Input buffers.
+  std::vector<CType> values_;
 
-  std::vector<int16_t> def_levels_;
+  std::vector<int16_t> defLevels_;
 
   std::vector<uint8_t> buffer_;
   // Pointer to the values, needed as we cannot use std::vector<bool>::data()
-  c_type* values_ptr_;
-  std::vector<uint8_t> bool_buffer_;
+  CType* valuesPtr_;
+  std::vector<uint8_t> boolBuffer_;
 
-  // Output buffers
-  std::vector<c_type> values_out_;
-  std::vector<uint8_t> bool_buffer_out_;
-  c_type* values_out_ptr_;
+  // Output buffers.
+  std::vector<CType> valuesOut_;
+  std::vector<uint8_t> boolBufferOut_;
+  CType* valuesOutPtr_;
 };
 
 template <typename TestType>
-inline void PrimitiveTypedTest<TestType>::SyncValuesOut() {}
+inline void PrimitiveTypedTest<TestType>::syncValuesOut() {}
 
 template <>
-inline void PrimitiveTypedTest<BooleanType>::SyncValuesOut() {
-  std::vector<uint8_t>::const_iterator source_iterator =
-      bool_buffer_out_.begin();
-  std::vector<c_type>::iterator destination_iterator = values_out_.begin();
-  while (source_iterator != bool_buffer_out_.end()) {
-    *destination_iterator++ = *source_iterator++ != 0;
+inline void PrimitiveTypedTest<BooleanType>::syncValuesOut() {
+  std::vector<uint8_t>::const_iterator sourceIterator = boolBufferOut_.begin();
+  std::vector<CType>::iterator destinationIterator = valuesOut_.begin();
+  while (sourceIterator != boolBufferOut_.end()) {
+    *destinationIterator++ = *sourceIterator++ != 0;
   }
 }
 
 template <typename TestType>
-inline void PrimitiveTypedTest<TestType>::SetupValuesOut(int64_t num_values) {
-  values_out_.clear();
-  values_out_.resize(num_values);
-  values_out_ptr_ = values_out_.data();
+inline void PrimitiveTypedTest<TestType>::setupValuesOut(int64_t numValues) {
+  valuesOut_.clear();
+  valuesOut_.resize(numValues);
+  valuesOutPtr_ = valuesOut_.data();
 }
 
 template <>
-inline void PrimitiveTypedTest<BooleanType>::SetupValuesOut(
-    int64_t num_values) {
-  values_out_.clear();
-  values_out_.resize(num_values);
+inline void PrimitiveTypedTest<BooleanType>::setupValuesOut(int64_t numValues) {
+  valuesOut_.clear();
+  valuesOut_.resize(numValues);
 
-  bool_buffer_out_.clear();
-  bool_buffer_out_.resize(num_values);
-  // Write once to all values so we can copy it without getting Valgrind errors
-  // about uninitialised values.
-  std::fill(bool_buffer_out_.begin(), bool_buffer_out_.end(), true);
-  values_out_ptr_ = reinterpret_cast<bool*>(bool_buffer_out_.data());
+  boolBufferOut_.clear();
+  boolBufferOut_.resize(numValues);
+  // Write once to all values so we can copy it without getting Valgrind errors.
+  // About uninitialised values.
+  std::fill(boolBufferOut_.begin(), boolBufferOut_.end(), true);
+  valuesOutPtr_ = reinterpret_cast<bool*>(boolBufferOut_.data());
 }
 
 template <typename TestType>
-inline void PrimitiveTypedTest<TestType>::GenerateData(
-    int64_t num_values,
+inline void PrimitiveTypedTest<TestType>::generateData(
+    int64_t numValues,
     uint32_t seed) {
-  def_levels_.resize(num_values);
-  values_.resize(num_values);
+  defLevels_.resize(numValues);
+  values_.resize(numValues);
 
-  InitValues<c_type>(static_cast<int>(num_values), seed, values_, buffer_);
-  values_ptr_ = values_.data();
+  initValues<CType>(static_cast<int>(numValues), seed, values_, buffer_);
+  valuesPtr_ = values_.data();
 
-  std::fill(def_levels_.begin(), def_levels_.end(), 1);
+  std::fill(defLevels_.begin(), defLevels_.end(), 1);
 }
 
 template <>
-inline void PrimitiveTypedTest<BooleanType>::GenerateData(
-    int64_t num_values,
+inline void PrimitiveTypedTest<BooleanType>::generateData(
+    int64_t numValues,
     uint32_t seed) {
-  def_levels_.resize(num_values);
-  values_.resize(num_values);
+  defLevels_.resize(numValues);
+  values_.resize(numValues);
 
-  InitValues<c_type>(static_cast<int>(num_values), seed, values_, buffer_);
-  bool_buffer_.resize(num_values);
-  std::copy(values_.begin(), values_.end(), bool_buffer_.begin());
-  values_ptr_ = reinterpret_cast<bool*>(bool_buffer_.data());
+  initValues<CType>(static_cast<int>(numValues), seed, values_, buffer_);
+  boolBuffer_.resize(numValues);
+  std::copy(values_.begin(), values_.end(), boolBuffer_.begin());
+  valuesPtr_ = reinterpret_cast<bool*>(boolBuffer_.data());
 
-  std::fill(def_levels_.begin(), def_levels_.end(), 1);
+  std::fill(defLevels_.begin(), defLevels_.end(), 1);
 }
 
-// ----------------------------------------------------------------------
-// test data generation
+// ----------------------------------------------------------------------.
+// Test data generation.
 
 template <typename T>
-inline void GenerateData(int num_values, T* out, std::vector<uint8_t>* heap) {
-  // seed the prng so failure is deterministic
-  random_numbers(
-      num_values,
+inline void generateData(int numValues, T* out, std::vector<uint8_t>* heap) {
+  // Seed the prng so failure is deterministic.
+  randomNumbers(
+      numValues,
       0,
       std::numeric_limits<T>::min(),
       std::numeric_limits<T>::max(),
@@ -919,29 +916,29 @@ inline void GenerateData(int num_values, T* out, std::vector<uint8_t>* heap) {
 }
 
 template <typename T>
-inline void GenerateBoundData(
-    int num_values,
+inline void generateBoundData(
+    int numValues,
     T* out,
     T min,
     T max,
     std::vector<uint8_t>* heap) {
-  // seed the prng so failure is deterministic
-  random_numbers(num_values, 0, min, max, out);
+  // Seed the prng so failure is deterministic.
+  randomNumbers(numValues, 0, min, max, out);
 }
 
 template <>
 inline void
-GenerateData<bool>(int num_values, bool* out, std::vector<uint8_t>* heap) {
-  // seed the prng so failure is deterministic
-  random_bools(num_values, 0.5, 0, out);
+generateData<bool>(int numValues, bool* out, std::vector<uint8_t>* heap) {
+  // Seed the prng so failure is deterministic.
+  randomBools(numValues, 0.5, 0, out);
 }
 
 template <>
 inline void
-GenerateData<Int96>(int num_values, Int96* out, std::vector<uint8_t>* heap) {
-  // seed the prng so failure is deterministic
-  random_Int96_numbers(
-      num_values,
+generateData<Int96>(int numValues, Int96* out, std::vector<uint8_t>* heap) {
+  // Seed the prng so failure is deterministic.
+  randomInt96Numbers(
+      numValues,
       0,
       std::numeric_limits<int32_t>::min(),
       std::numeric_limits<int32_t>::max(),
@@ -949,25 +946,25 @@ GenerateData<Int96>(int num_values, Int96* out, std::vector<uint8_t>* heap) {
 }
 
 template <>
-inline void GenerateData<ByteArray>(
-    int num_values,
+inline void generateData<ByteArray>(
+    int numValues,
     ByteArray* out,
     std::vector<uint8_t>* heap) {
-  // seed the prng so failure is deterministic
-  int max_byte_array_len = 12;
-  heap->resize(num_values * max_byte_array_len);
-  random_byte_array(num_values, 0, heap->data(), out, 2, max_byte_array_len);
+  // Seed the prng so failure is deterministic.
+  int maxByteArrayLen = 12;
+  heap->resize(numValues * maxByteArrayLen);
+  randomByteArray(numValues, 0, heap->data(), out, 2, maxByteArrayLen);
 }
 
 static constexpr int kGenerateDataFLBALength = 8;
 
 template <>
 inline void
-GenerateData<FLBA>(int num_values, FLBA* out, std::vector<uint8_t>* heap) {
-  // seed the prng so failure is deterministic
-  heap->resize(num_values * kGenerateDataFLBALength);
-  random_fixed_byte_array(
-      num_values, 0, heap->data(), kGenerateDataFLBALength, out);
+generateData<FLBA>(int numValues, FLBA* out, std::vector<uint8_t>* heap) {
+  // Seed the prng so failure is deterministic.
+  heap->resize(numValues * kGenerateDataFLBALength);
+  randomFixedByteArray(
+      numValues, 0, heap->data(), kGenerateDataFLBALength, out);
 }
 
 } // namespace test
diff --git a/velox/dwio/parquet/writer/arrow/tests/TypesTest.cpp b/velox/dwio/parquet/writer/arrow/tests/TypesTest.cpp
index 495b02c1ee8..476cc7f9fea 100644
--- a/velox/dwio/parquet/writer/arrow/tests/TypesTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/TypesTest.cpp
@@ -26,54 +26,54 @@
 namespace facebook::velox::parquet::arrow {
 
 TEST(TestTypeToString, PhysicalTypes) {
-  ASSERT_STREQ("BOOLEAN", TypeToString(Type::BOOLEAN).c_str());
-  ASSERT_STREQ("INT32", TypeToString(Type::INT32).c_str());
-  ASSERT_STREQ("INT64", TypeToString(Type::INT64).c_str());
-  ASSERT_STREQ("INT96", TypeToString(Type::INT96).c_str());
-  ASSERT_STREQ("FLOAT", TypeToString(Type::FLOAT).c_str());
-  ASSERT_STREQ("DOUBLE", TypeToString(Type::DOUBLE).c_str());
-  ASSERT_STREQ("BYTE_ARRAY", TypeToString(Type::BYTE_ARRAY).c_str());
+  ASSERT_STREQ("BOOLEAN", typeToString(Type::kBoolean).c_str());
+  ASSERT_STREQ("INT32", typeToString(Type::kInt32).c_str());
+  ASSERT_STREQ("INT64", typeToString(Type::kInt64).c_str());
+  ASSERT_STREQ("INT96", typeToString(Type::kInt96).c_str());
+  ASSERT_STREQ("FLOAT", typeToString(Type::kFloat).c_str());
+  ASSERT_STREQ("DOUBLE", typeToString(Type::kDouble).c_str());
+  ASSERT_STREQ("BYTE_ARRAY", typeToString(Type::kByteArray).c_str());
   ASSERT_STREQ(
-      "FIXED_LEN_BYTE_ARRAY", TypeToString(Type::FIXED_LEN_BYTE_ARRAY).c_str());
+      "FIXED_LEN_BYTE_ARRAY", typeToString(Type::kFixedLenByteArray).c_str());
 }
 
 TEST(TestConvertedTypeToString, ConvertedTypes) {
-  ASSERT_STREQ("NONE", ConvertedTypeToString(ConvertedType::NONE).c_str());
-  ASSERT_STREQ("UTF8", ConvertedTypeToString(ConvertedType::UTF8).c_str());
-  ASSERT_STREQ("MAP", ConvertedTypeToString(ConvertedType::MAP).c_str());
+  ASSERT_STREQ("NONE", convertedTypeToString(ConvertedType::kNone).c_str());
+  ASSERT_STREQ("UTF8", convertedTypeToString(ConvertedType::kUtf8).c_str());
+  ASSERT_STREQ("MAP", convertedTypeToString(ConvertedType::kMap).c_str());
   ASSERT_STREQ(
       "MAP_KEY_VALUE",
-      ConvertedTypeToString(ConvertedType::MAP_KEY_VALUE).c_str());
-  ASSERT_STREQ("LIST", ConvertedTypeToString(ConvertedType::LIST).c_str());
-  ASSERT_STREQ("ENUM", ConvertedTypeToString(ConvertedType::ENUM).c_str());
+      convertedTypeToString(ConvertedType::kMapKeyValue).c_str());
+  ASSERT_STREQ("LIST", convertedTypeToString(ConvertedType::kList).c_str());
+  ASSERT_STREQ("ENUM", convertedTypeToString(ConvertedType::kEnum).c_str());
   ASSERT_STREQ(
-      "DECIMAL", ConvertedTypeToString(ConvertedType::DECIMAL).c_str());
-  ASSERT_STREQ("DATE", ConvertedTypeToString(ConvertedType::DATE).c_str());
+      "DECIMAL", convertedTypeToString(ConvertedType::kDecimal).c_str());
+  ASSERT_STREQ("DATE", convertedTypeToString(ConvertedType::kDate).c_str());
   ASSERT_STREQ(
-      "TIME_MILLIS", ConvertedTypeToString(ConvertedType::TIME_MILLIS).c_str());
+      "TIME_MILLIS", convertedTypeToString(ConvertedType::kTimeMillis).c_str());
   ASSERT_STREQ(
-      "TIME_MICROS", ConvertedTypeToString(ConvertedType::TIME_MICROS).c_str());
+      "TIME_MICROS", convertedTypeToString(ConvertedType::kTimeMicros).c_str());
   ASSERT_STREQ(
       "TIMESTAMP_MILLIS",
-      ConvertedTypeToString(ConvertedType::TIMESTAMP_MILLIS).c_str());
+      convertedTypeToString(ConvertedType::kTimestampMillis).c_str());
   ASSERT_STREQ(
       "TIMESTAMP_MICROS",
-      ConvertedTypeToString(ConvertedType::TIMESTAMP_MICROS).c_str());
-  ASSERT_STREQ("UINT_8", ConvertedTypeToString(ConvertedType::UINT_8).c_str());
+      convertedTypeToString(ConvertedType::kTimestampMicros).c_str());
+  ASSERT_STREQ("UINT_8", convertedTypeToString(ConvertedType::kUint8).c_str());
   ASSERT_STREQ(
-      "UINT_16", ConvertedTypeToString(ConvertedType::UINT_16).c_str());
+      "UINT_16", convertedTypeToString(ConvertedType::kUint16).c_str());
   ASSERT_STREQ(
-      "UINT_32", ConvertedTypeToString(ConvertedType::UINT_32).c_str());
+      "UINT_32", convertedTypeToString(ConvertedType::kUint32).c_str());
   ASSERT_STREQ(
-      "UINT_64", ConvertedTypeToString(ConvertedType::UINT_64).c_str());
-  ASSERT_STREQ("INT_8", ConvertedTypeToString(ConvertedType::INT_8).c_str());
-  ASSERT_STREQ("INT_16", ConvertedTypeToString(ConvertedType::INT_16).c_str());
-  ASSERT_STREQ("INT_32", ConvertedTypeToString(ConvertedType::INT_32).c_str());
-  ASSERT_STREQ("INT_64", ConvertedTypeToString(ConvertedType::INT_64).c_str());
-  ASSERT_STREQ("JSON", ConvertedTypeToString(ConvertedType::JSON).c_str());
-  ASSERT_STREQ("BSON", ConvertedTypeToString(ConvertedType::BSON).c_str());
+      "UINT_64", convertedTypeToString(ConvertedType::kUint64).c_str());
+  ASSERT_STREQ("INT_8", convertedTypeToString(ConvertedType::kInt8).c_str());
+  ASSERT_STREQ("INT_16", convertedTypeToString(ConvertedType::kInt16).c_str());
+  ASSERT_STREQ("INT_32", convertedTypeToString(ConvertedType::kInt32).c_str());
+  ASSERT_STREQ("INT_64", convertedTypeToString(ConvertedType::kInt64).c_str());
+  ASSERT_STREQ("JSON", convertedTypeToString(ConvertedType::kJson).c_str());
+  ASSERT_STREQ("BSON", convertedTypeToString(ConvertedType::kBson).c_str());
   ASSERT_STREQ(
-      "INTERVAL", ConvertedTypeToString(ConvertedType::INTERVAL).c_str());
+      "INTERVAL", convertedTypeToString(ConvertedType::kInterval).c_str());
 }
 
 #ifdef __GNUC__
@@ -87,86 +87,87 @@ TEST(TestConvertedTypeToString, ConvertedTypes) {
 TEST(TypePrinter, StatisticsTypes) {
   std::string smin;
   std::string smax;
-  int32_t int_min = 1024;
-  int32_t int_max = 2048;
-  smin = std::string(reinterpret_cast<char*>(&int_min), sizeof(int32_t));
-  smax = std::string(reinterpret_cast<char*>(&int_max), sizeof(int32_t));
-  ASSERT_STREQ("1024", FormatStatValue(Type::INT32, smin).c_str());
-  ASSERT_STREQ("2048", FormatStatValue(Type::INT32, smax).c_str());
-
-  int64_t int64_min = 10240000000000;
-  int64_t int64_max = 20480000000000;
-  smin = std::string(reinterpret_cast<char*>(&int64_min), sizeof(int64_t));
-  smax = std::string(reinterpret_cast<char*>(&int64_max), sizeof(int64_t));
-  ASSERT_STREQ("10240000000000", FormatStatValue(Type::INT64, smin).c_str());
-  ASSERT_STREQ("20480000000000", FormatStatValue(Type::INT64, smax).c_str());
-
-  float float_min = 1.024f;
-  float float_max = 2.048f;
-  smin = std::string(reinterpret_cast<char*>(&float_min), sizeof(float));
-  smax = std::string(reinterpret_cast<char*>(&float_max), sizeof(float));
-  ASSERT_STREQ("1.024", FormatStatValue(Type::FLOAT, smin).c_str());
-  ASSERT_STREQ("2.048", FormatStatValue(Type::FLOAT, smax).c_str());
-
-  double double_min = 1.0245;
-  double double_max = 2.0489;
-  smin = std::string(reinterpret_cast<char*>(&double_min), sizeof(double));
-  smax = std::string(reinterpret_cast<char*>(&double_max), sizeof(double));
-  ASSERT_STREQ("1.0245", FormatStatValue(Type::DOUBLE, smin).c_str());
-  ASSERT_STREQ("2.0489", FormatStatValue(Type::DOUBLE, smax).c_str());
+  int32_t intMin = 1024;
+  int32_t intMax = 2048;
+  smin = std::string(reinterpret_cast<char*>(&intMin), sizeof(int32_t));
+  smax = std::string(reinterpret_cast<char*>(&intMax), sizeof(int32_t));
+  ASSERT_STREQ("1024", formatStatValue(Type::kInt32, smin).c_str());
+  ASSERT_STREQ("2048", formatStatValue(Type::kInt32, smax).c_str());
+
+  int64_t int64Min = 10240000000000;
+  int64_t int64Max = 20480000000000;
+  smin = std::string(reinterpret_cast<char*>(&int64Min), sizeof(int64_t));
+  smax = std::string(reinterpret_cast<char*>(&int64Max), sizeof(int64_t));
+  ASSERT_STREQ("10240000000000", formatStatValue(Type::kInt64, smin).c_str());
+  ASSERT_STREQ("20480000000000", formatStatValue(Type::kInt64, smax).c_str());
+
+  float floatMin = 1.024f;
+  float floatMax = 2.048f;
+  smin = std::string(reinterpret_cast<char*>(&floatMin), sizeof(float));
+  smax = std::string(reinterpret_cast<char*>(&floatMax), sizeof(float));
+  ASSERT_STREQ("1.024", formatStatValue(Type::kFloat, smin).c_str());
+  ASSERT_STREQ("2.048", formatStatValue(Type::kFloat, smax).c_str());
+
+  double doubleMin = 1.0245;
+  double doubleMax = 2.0489;
+  smin = std::string(reinterpret_cast<char*>(&doubleMin), sizeof(double));
+  smax = std::string(reinterpret_cast<char*>(&doubleMax), sizeof(double));
+  ASSERT_STREQ("1.0245", formatStatValue(Type::kDouble, smin).c_str());
+  ASSERT_STREQ("2.0489", formatStatValue(Type::kDouble, smax).c_str());
 
 #if ARROW_LITTLE_ENDIAN
-  Int96 Int96_min = {{1024, 2048, 4096}};
-  Int96 Int96_max = {{2048, 4096, 8192}};
+  Int96 int96Min = {{1024, 2048, 4096}};
+  Int96 int96Max = {{2048, 4096, 8192}};
 #else
-  Int96 Int96_min = {{2048, 1024, 4096}};
-  Int96 Int96_max = {{4096, 2048, 8192}};
+  Int96 int96Min = {{2048, 1024, 4096}};
+  Int96 int96Max = {{4096, 2048, 8192}};
 #endif
-  smin = std::string(reinterpret_cast<char*>(&Int96_min), sizeof(Int96));
-  smax = std::string(reinterpret_cast<char*>(&Int96_max), sizeof(Int96));
-  ASSERT_STREQ("1024 2048 4096", FormatStatValue(Type::INT96, smin).c_str());
-  ASSERT_STREQ("2048 4096 8192", FormatStatValue(Type::INT96, smax).c_str());
+  smin = std::string(reinterpret_cast<char*>(&int96Min), sizeof(Int96));
+  smax = std::string(reinterpret_cast<char*>(&int96Max), sizeof(Int96));
+  ASSERT_STREQ("1024 2048 4096", formatStatValue(Type::kInt96, smin).c_str());
+  ASSERT_STREQ("2048 4096 8192", formatStatValue(Type::kInt96, smax).c_str());
 
   smin = std::string("abcdef");
   smax = std::string("ijklmnop");
-  ASSERT_STREQ("abcdef", FormatStatValue(Type::BYTE_ARRAY, smin).c_str());
-  ASSERT_STREQ("ijklmnop", FormatStatValue(Type::BYTE_ARRAY, smax).c_str());
+  ASSERT_STREQ("abcdef", formatStatValue(Type::kByteArray, smin).c_str());
+  ASSERT_STREQ("ijklmnop", formatStatValue(Type::kByteArray, smax).c_str());
 
-  // PARQUET-1357: FormatStatValue truncates binary statistics on zero character
+  // PARQUET-1357: FormatStatValue truncates binary statistics on zero
+  // character.
   smax.push_back('\0');
-  ASSERT_EQ(smax, FormatStatValue(Type::BYTE_ARRAY, smax));
+  ASSERT_EQ(smax, formatStatValue(Type::kByteArray, smax));
 
   smin = std::string("abcdefgh");
   smax = std::string("ijklmnop");
   ASSERT_STREQ(
-      "abcdefgh", FormatStatValue(Type::FIXED_LEN_BYTE_ARRAY, smin).c_str());
+      "abcdefgh", formatStatValue(Type::kFixedLenByteArray, smin).c_str());
   ASSERT_STREQ(
-      "ijklmnop", FormatStatValue(Type::FIXED_LEN_BYTE_ARRAY, smax).c_str());
+      "ijklmnop", formatStatValue(Type::kFixedLenByteArray, smax).c_str());
 }
 
 TEST(TestInt96Timestamp, Decoding) {
-  auto check = [](int32_t julian_day, uint64_t nanoseconds) {
+  auto check = [](int32_t julianDay, uint64_t nanoseconds) {
 #if ARROW_LITTLE_ENDIAN
     Int96 i96{
         static_cast<uint32_t>(nanoseconds),
         static_cast<uint32_t>(nanoseconds >> 32),
-        static_cast<uint32_t>(julian_day)};
+        static_cast<uint32_t>(julianDay)};
 #else
     Int96 i96{
         static_cast<uint32_t>(nanoseconds >> 32),
         static_cast<uint32_t>(nanoseconds),
-        static_cast<uint32_t>(julian_day)};
+        static_cast<uint32_t>(julianDay)};
 #endif
-    // Official formula according to
+    // Official formula according to.
     // https://github.com/apache/parquet-format/pull/49
     int64_t expected =
-        (julian_day - 2440588) * (86400LL * 1000 * 1000 * 1000) + nanoseconds;
-    int64_t actual = Int96GetNanoSeconds(i96);
+        (julianDay - 2440588) * (86400LL * 1000 * 1000 * 1000) + nanoseconds;
+    int64_t actual = int96GetNanoSeconds(i96);
     ASSERT_EQ(expected, actual);
   };
 
-  // [2333837, 2547339] is the range of Julian days that can be converted to
-  // 64-bit Unix timestamps.
+  // [2333837, 2547339] Is the range of Julian days that can be converted to.
+  // 64-Bit Unix timestamps.
   check(2333837, 0);
   check(2333855, 0);
   check(2547330, 0);
diff --git a/velox/dwio/parquet/writer/arrow/tests/XxHasher.cpp b/velox/dwio/parquet/writer/arrow/tests/XxHasher.cpp
index cecdfc9e7de..a7b47b27d76 100644
--- a/velox/dwio/parquet/writer/arrow/tests/XxHasher.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/XxHasher.cpp
@@ -18,88 +18,87 @@
 
 #include "velox/dwio/parquet/writer/arrow/tests/XxHasher.h"
 
-#define XXH_INLINE_ALL
-#include <xxhash.h>
+#include "velox/common/base/XxHashInline.h"
 
 namespace facebook::velox::parquet::arrow {
 
 namespace {
 template <typename T>
-uint64_t XxHashHelper(T value, uint32_t seed) {
+uint64_t xxHashHelper(T value, uint32_t seed) {
   return XXH64(reinterpret_cast<const void*>(&value), sizeof(T), seed);
 }
 
 template <typename T>
-void XxHashesHelper(
+void xxHashesHelper(
     const T* values,
     uint32_t seed,
-    int num_values,
+    int numValues,
     uint64_t* results) {
-  for (int i = 0; i < num_values; ++i) {
-    results[i] = XxHashHelper(values[i], seed);
+  for (int i = 0; i < numValues; ++i) {
+    results[i] = xxHashHelper(values[i], seed);
   }
 }
 
 } // namespace
 
-uint64_t XxHasher::Hash(int32_t value) const {
-  return XxHashHelper(value, kParquetBloomXxHashSeed);
+uint64_t XxHasher::hash(int32_t value) const {
+  return xxHashHelper(value, kParquetBloomXxHashSeed);
 }
 
-uint64_t XxHasher::Hash(int64_t value) const {
-  return XxHashHelper(value, kParquetBloomXxHashSeed);
+uint64_t XxHasher::hash(int64_t value) const {
+  return xxHashHelper(value, kParquetBloomXxHashSeed);
 }
 
-uint64_t XxHasher::Hash(float value) const {
-  return XxHashHelper(value, kParquetBloomXxHashSeed);
+uint64_t XxHasher::hash(float value) const {
+  return xxHashHelper(value, kParquetBloomXxHashSeed);
 }
 
-uint64_t XxHasher::Hash(double value) const {
-  return XxHashHelper(value, kParquetBloomXxHashSeed);
+uint64_t XxHasher::hash(double value) const {
+  return xxHashHelper(value, kParquetBloomXxHashSeed);
 }
 
-uint64_t XxHasher::Hash(const FLBA* value, uint32_t len) const {
+uint64_t XxHasher::hash(const FLBA* value, uint32_t len) const {
   return XXH64(
       reinterpret_cast<const void*>(value->ptr), len, kParquetBloomXxHashSeed);
 }
 
-uint64_t XxHasher::Hash(const Int96* value) const {
+uint64_t XxHasher::hash(const Int96* value) const {
   return XXH64(
       reinterpret_cast<const void*>(value->value),
       sizeof(value->value),
       kParquetBloomXxHashSeed);
 }
 
-uint64_t XxHasher::Hash(const ByteArray* value) const {
+uint64_t XxHasher::hash(const ByteArray* value) const {
   return XXH64(
       reinterpret_cast<const void*>(value->ptr),
       value->len,
       kParquetBloomXxHashSeed);
 }
 
-void XxHasher::Hashes(const int32_t* values, int num_values, uint64_t* hashes)
+void XxHasher::hashes(const int32_t* values, int numValues, uint64_t* hashes)
     const {
-  XxHashesHelper(values, kParquetBloomXxHashSeed, num_values, hashes);
+  xxHashesHelper(values, kParquetBloomXxHashSeed, numValues, hashes);
 }
 
-void XxHasher::Hashes(const int64_t* values, int num_values, uint64_t* hashes)
+void XxHasher::hashes(const int64_t* values, int numValues, uint64_t* hashes)
     const {
-  XxHashesHelper(values, kParquetBloomXxHashSeed, num_values, hashes);
+  xxHashesHelper(values, kParquetBloomXxHashSeed, numValues, hashes);
 }
 
-void XxHasher::Hashes(const float* values, int num_values, uint64_t* hashes)
+void XxHasher::hashes(const float* values, int numValues, uint64_t* hashes)
     const {
-  XxHashesHelper(values, kParquetBloomXxHashSeed, num_values, hashes);
+  xxHashesHelper(values, kParquetBloomXxHashSeed, numValues, hashes);
 }
 
-void XxHasher::Hashes(const double* values, int num_values, uint64_t* hashes)
+void XxHasher::hashes(const double* values, int numValues, uint64_t* hashes)
     const {
-  XxHashesHelper(values, kParquetBloomXxHashSeed, num_values, hashes);
+  xxHashesHelper(values, kParquetBloomXxHashSeed, numValues, hashes);
 }
 
-void XxHasher::Hashes(const Int96* values, int num_values, uint64_t* hashes)
+void XxHasher::hashes(const Int96* values, int numValues, uint64_t* hashes)
     const {
-  for (int i = 0; i < num_values; ++i) {
+  for (int i = 0; i < numValues; ++i) {
     hashes[i] = XXH64(
         reinterpret_cast<const void*>(values[i].value),
         sizeof(values[i].value),
@@ -107,9 +106,9 @@ void XxHasher::Hashes(const Int96* values, int num_values, uint64_t* hashes)
   }
 }
 
-void XxHasher::Hashes(const ByteArray* values, int num_values, uint64_t* hashes)
+void XxHasher::hashes(const ByteArray* values, int numValues, uint64_t* hashes)
     const {
-  for (int i = 0; i < num_values; ++i) {
+  for (int i = 0; i < numValues; ++i) {
     hashes[i] = XXH64(
         reinterpret_cast<const void*>(values[i].ptr),
         values[i].len,
@@ -117,15 +116,15 @@ void XxHasher::Hashes(const ByteArray* values, int num_values, uint64_t* hashes)
   }
 }
 
-void XxHasher::Hashes(
+void XxHasher::hashes(
     const FLBA* values,
-    uint32_t type_len,
-    int num_values,
+    uint32_t typeLen,
+    int numValues,
     uint64_t* hashes) const {
-  for (int i = 0; i < num_values; ++i) {
+  for (int i = 0; i < numValues; ++i) {
     hashes[i] = XXH64(
         reinterpret_cast<const void*>(values[i].ptr),
-        type_len,
+        typeLen,
         kParquetBloomXxHashSeed);
   }
 }
diff --git a/velox/dwio/parquet/writer/arrow/tests/XxHasher.h b/velox/dwio/parquet/writer/arrow/tests/XxHasher.h
index 48650dba114..7b51cffc6de 100644
--- a/velox/dwio/parquet/writer/arrow/tests/XxHasher.h
+++ b/velox/dwio/parquet/writer/arrow/tests/XxHasher.h
@@ -28,30 +28,30 @@ namespace facebook::velox::parquet::arrow {
 
 class PARQUET_EXPORT XxHasher : public Hasher {
  public:
-  uint64_t Hash(int32_t value) const override;
-  uint64_t Hash(int64_t value) const override;
-  uint64_t Hash(float value) const override;
-  uint64_t Hash(double value) const override;
-  uint64_t Hash(const Int96* value) const override;
-  uint64_t Hash(const ByteArray* value) const override;
-  uint64_t Hash(const FLBA* val, uint32_t len) const override;
-
-  void Hashes(const int32_t* values, int num_values, uint64_t* hashes)
+  uint64_t hash(int32_t value) const override;
+  uint64_t hash(int64_t value) const override;
+  uint64_t hash(float value) const override;
+  uint64_t hash(double value) const override;
+  uint64_t hash(const Int96* value) const override;
+  uint64_t hash(const ByteArray* value) const override;
+  uint64_t hash(const FLBA* val, uint32_t len) const override;
+
+  void hashes(const int32_t* values, int numValues, uint64_t* hashes)
       const override;
-  void Hashes(const int64_t* values, int num_values, uint64_t* hashes)
+  void hashes(const int64_t* values, int numValues, uint64_t* hashes)
       const override;
-  void Hashes(const float* values, int num_values, uint64_t* hashes)
+  void hashes(const float* values, int numValues, uint64_t* hashes)
       const override;
-  void Hashes(const double* values, int num_values, uint64_t* hashes)
+  void hashes(const double* values, int numValues, uint64_t* hashes)
       const override;
-  void Hashes(const Int96* values, int num_values, uint64_t* hashes)
+  void hashes(const Int96* values, int numValues, uint64_t* hashes)
       const override;
-  void Hashes(const ByteArray* values, int num_values, uint64_t* hashes)
+  void hashes(const ByteArray* values, int numValues, uint64_t* hashes)
       const override;
-  void Hashes(
+  void hashes(
       const FLBA* values,
-      uint32_t type_len,
-      int num_values,
+      uint32_t typeLen,
+      int numValues,
       uint64_t* hashes) const override;
 
   static constexpr int kParquetBloomXxHashSeed = 0;
diff --git a/velox/dwio/parquet/writer/arrow/util/ByteStreamSplitInternal.h b/velox/dwio/parquet/writer/arrow/util/ByteStreamSplitInternal.h
index 45e5b025ff1..aa2f83f6763 100644
--- a/velox/dwio/parquet/writer/arrow/util/ByteStreamSplitInternal.h
+++ b/velox/dwio/parquet/writer/arrow/util/ByteStreamSplitInternal.h
@@ -27,21 +27,21 @@
 #include <cstdint>
 
 #ifdef ARROW_HAVE_SSE4_2
-// Enable the SIMD for ByteStreamSplit Encoder/Decoder
+// Enable the SIMD for ByteStreamSplit Encoder/Decoder.
 #define ARROW_HAVE_SIMD_SPLIT
 #endif // ARROW_HAVE_SSE4_2
 
 namespace facebook::velox::parquet::arrow {
 
 //
-// SIMD implementations
+// SIMD implementations.
 //
 
 #if defined(ARROW_HAVE_SSE4_2)
 template <typename T>
-void ByteStreamSplitDecodeSse2(
+void byteStreamSplitDecodeSse2(
     const uint8_t* data,
-    int64_t num_values,
+    int64_t numValues,
     int64_t stride,
     T* out) {
   constexpr size_t kNumStreams = sizeof(T);
@@ -50,87 +50,88 @@ void ByteStreamSplitDecodeSse2(
   constexpr size_t kNumStreamsLog2 = (kNumStreams == 8U ? 3U : 2U);
   constexpr int64_t kBlockSize = sizeof(__m128i) * kNumStreams;
 
-  const int64_t size = num_values * sizeof(T);
-  const int64_t num_blocks = size / kBlockSize;
-  uint8_t* output_data = reinterpret_cast<uint8_t*>(out);
+  const int64_t size = numValues * sizeof(T);
+  const int64_t numBlocks = size / kBlockSize;
+  uint8_t* outputData = reinterpret_cast<uint8_t*>(out);
 
   // First handle suffix.
-  // This helps catch if the simd-based processing overflows into the suffix
-  // since almost surely a test would fail.
-  const int64_t num_processed_elements =
-      (num_blocks * kBlockSize) / kNumStreams;
-  for (int64_t i = num_processed_elements; i < num_values; ++i) {
-    uint8_t gathered_byte_data[kNumStreams];
+  // This helps catch if the simd-based processing overflows into the suffix.
+  // Since almost surely a test would fail.
+  const int64_t numProcessedElements = (numBlocks * kBlockSize) / kNumStreams;
+  for (int64_t i = numProcessedElements; i < numValues; ++i) {
+    uint8_t gatheredByteData[kNumStreams];
     for (size_t b = 0; b < kNumStreams; ++b) {
-      const size_t byte_index = b * stride + i;
-      gathered_byte_data[b] = data[byte_index];
+      const size_t byteIndex = b * stride + i;
+      gatheredByteData[b] = data[byteIndex];
     }
-    out[i] = arrow::util::SafeLoadAs<T>(&gathered_byte_data[0]);
+    out[i] = arrow::util::SafeLoadAs<T>(&gatheredByteData[0]);
   }
 
   // The blocks get processed hierarchically using the unpack intrinsics.
   // Example with four streams:
-  // Stage 1: AAAA BBBB CCCC DDDD
-  // Stage 2: ACAC ACAC BDBD BDBD
-  // Stage 3: ABCD ABCD ABCD ABCD
+  // Stage 1: AAAA BBBB CCCC DDDD.
+  // Stage 2: ACAC ACAC BDBD BDBD.
+  // Stage 3: ABCD ABCD ABCD ABCD.
   __m128i stage[kNumStreamsLog2 + 1U][kNumStreams];
   constexpr size_t kNumStreamsHalf = kNumStreams / 2U;
 
-  for (int64_t i = 0; i < num_blocks; ++i) {
+  for (int64_t i = 0; i < numBlocks; ++i) {
     for (size_t j = 0; j < kNumStreams; ++j) {
-      stage[0][j] = _mm_loadu_si128(reinterpret_cast<const __m128i*>(
-          &data[i * sizeof(__m128i) + j * stride]));
+      stage[0][j] = mmLoaduSi128(
+          reinterpret_cast<const __m128i*>(
+              &data[i * sizeof(__m128i) + j * stride]));
     }
     for (size_t step = 0; step < kNumStreamsLog2; ++step) {
       for (size_t j = 0; j < kNumStreamsHalf; ++j) {
         stage[step + 1U][j * 2] =
-            _mm_unpacklo_epi8(stage[step][j], stage[step][kNumStreamsHalf + j]);
+            mmUnpackloEpi8(stage[step][j], stage[step][kNumStreamsHalf + j]);
         stage[step + 1U][j * 2 + 1U] =
-            _mm_unpackhi_epi8(stage[step][j], stage[step][kNumStreamsHalf + j]);
+            mmUnpackhiEpi8(stage[step][j], stage[step][kNumStreamsHalf + j]);
       }
     }
     for (size_t j = 0; j < kNumStreams; ++j) {
-      _mm_storeu_si128(
+      mmStoreuSi128(
           reinterpret_cast<__m128i*>(
-              &output_data[(i * kNumStreams + j) * sizeof(__m128i)]),
+              &outputData[(i * kNumStreams + j) * sizeof(__m128i)]),
           stage[kNumStreamsLog2][j]);
     }
   }
 }
 
 template <typename T>
-void ByteStreamSplitEncodeSse2(
-    const uint8_t* raw_values,
-    const size_t num_values,
-    uint8_t* output_buffer_raw) {
+void byteStreamSplitEncodeSse2(
+    const uint8_t* rawValues,
+    const size_t numValues,
+    uint8_t* outputBufferRaw) {
   constexpr size_t kNumStreams = sizeof(T);
   static_assert(
       kNumStreams == 4U || kNumStreams == 8U, "Invalid number of streams.");
   constexpr size_t kBlockSize = sizeof(__m128i) * kNumStreams;
 
   __m128i stage[3][kNumStreams];
-  __m128i final_result[kNumStreams];
+  __m128i finalResult[kNumStreams];
 
-  const size_t size = num_values * sizeof(T);
-  const size_t num_blocks = size / kBlockSize;
-  const __m128i* raw_values_sse = reinterpret_cast<const __m128i*>(raw_values);
-  __m128i* output_buffer_streams[kNumStreams];
+  const size_t size = numValues * sizeof(T);
+  const size_t numBlocks = size / kBlockSize;
+  const __m128i* rawValuesSse = reinterpret_cast<const __m128i*>(rawValues);
+  __m128i* outputBufferStreams[kNumStreams];
   for (size_t i = 0; i < kNumStreams; ++i) {
-    output_buffer_streams[i] =
-        reinterpret_cast<__m128i*>(&output_buffer_raw[num_values * i]);
+    outputBufferStreams[i] =
+        reinterpret_cast<__m128i*>(&outputBufferRaw[numValues * i]);
   }
 
   // First handle suffix.
-  const size_t num_processed_elements = (num_blocks * kBlockSize) / sizeof(T);
-  for (size_t i = num_processed_elements; i < num_values; ++i) {
+  const size_t numProcessedElements = (numBlocks * kBlockSize) / sizeof(T);
+  for (size_t i = numProcessedElements; i < numValues; ++i) {
     for (size_t j = 0U; j < kNumStreams; ++j) {
-      const uint8_t byte_in_value = raw_values[i * kNumStreams + j];
-      output_buffer_raw[j * num_values + i] = byte_in_value;
+      const uint8_t byteInValue = rawValues[i * kNumStreams + j];
+      outputBufferRaw[j * numValues + i] = byteInValue;
     }
   }
-  // The current shuffling algorithm diverges for float and double types but the
-  // compiler should be able to remove the branch since only one path is taken
-  // for each template instantiation. Example run for floats: Step 0, copy:
+  // The current shuffling algorithm diverges for float and double types but
+  // the. Compiler should be able to remove the branch since only one path is
+  // taken. For each template instantiation. Example run for floats: Step 0,
+  // copy:
   //   0: ABCD ABCD ABCD ABCD 1: ABCD ABCD ABCD ABCD ...
   // Step 1: _mm_unpacklo_epi8 and mm_unpackhi_epi8:
   //   0: AABB CCDD AABB CCDD 1: AABB CCDD AABB CCDD ...
@@ -139,51 +140,49 @@ void ByteStreamSplitEncodeSse2(
   //   0: AAAA AAAA BBBB BBBB 1: CCCC CCCC DDDD DDDD ...
   // Step 4: __mm_unpacklo_epi64 and _mm_unpackhi_epi64:
   //   0: AAAA AAAA AAAA AAAA 1: BBBB BBBB BBBB BBBB ...
-  for (size_t block_index = 0; block_index < num_blocks; ++block_index) {
+  for (size_t blockIndex = 0; blockIndex < numBlocks; ++blockIndex) {
     // First copy the data to stage 0.
     for (size_t i = 0; i < kNumStreams; ++i) {
-      stage[0][i] =
-          _mm_loadu_si128(&raw_values_sse[block_index * kNumStreams + i]);
+      stage[0][i] = mmLoaduSi128(&rawValuesSse[blockIndex * kNumStreams + i]);
     }
 
     // The shuffling of bytes is performed through the unpack intrinsics.
     // In my measurements this gives better performance then an implementation
     // which uses the shuffle intrinsics.
-    for (size_t stage_lvl = 0; stage_lvl < 2U; ++stage_lvl) {
+    for (size_t stageLvl = 0; stageLvl < 2U; ++stageLvl) {
       for (size_t i = 0; i < kNumStreams / 2U; ++i) {
-        stage[stage_lvl + 1][i * 2] = _mm_unpacklo_epi8(
-            stage[stage_lvl][i * 2], stage[stage_lvl][i * 2 + 1]);
-        stage[stage_lvl + 1][i * 2 + 1] = _mm_unpackhi_epi8(
-            stage[stage_lvl][i * 2], stage[stage_lvl][i * 2 + 1]);
+        stage[stageLvl + 1][i * 2] =
+            mmUnpackloEpi8(stage[stageLvl][i * 2], stage[stageLvl][i * 2 + 1]);
+        stage[stageLvl + 1][i * 2 + 1] =
+            mmUnpackhiEpi8(stage[stageLvl][i * 2], stage[stageLvl][i * 2 + 1]);
       }
     }
     if constexpr (kNumStreams == 8U) {
       // This is the path for double.
       __m128i tmp[8];
       for (size_t i = 0; i < 4; ++i) {
-        tmp[i * 2] = _mm_unpacklo_epi32(stage[2][i], stage[2][i + 4]);
-        tmp[i * 2 + 1] = _mm_unpackhi_epi32(stage[2][i], stage[2][i + 4]);
+        tmp[i * 2] = mmUnpackloEpi32(stage[2][i], stage[2][i + 4]);
+        tmp[i * 2 + 1] = mmUnpackhiEpi32(stage[2][i], stage[2][i + 4]);
       }
 
       for (size_t i = 0; i < 4; ++i) {
-        final_result[i * 2] = _mm_unpacklo_epi32(tmp[i], tmp[i + 4]);
-        final_result[i * 2 + 1] = _mm_unpackhi_epi32(tmp[i], tmp[i + 4]);
+        finalResult[i * 2] = mmUnpackloEpi32(tmp[i], tmp[i + 4]);
+        finalResult[i * 2 + 1] = mmUnpackhiEpi32(tmp[i], tmp[i + 4]);
       }
     } else {
-      // this is the path for float.
+      // This is the path for float.
       __m128i tmp[4];
       for (size_t i = 0; i < 2; ++i) {
-        tmp[i * 2] = _mm_unpacklo_epi8(stage[2][i * 2], stage[2][i * 2 + 1]);
-        tmp[i * 2 + 1] =
-            _mm_unpackhi_epi8(stage[2][i * 2], stage[2][i * 2 + 1]);
+        tmp[i * 2] = mmUnpackloEpi8(stage[2][i * 2], stage[2][i * 2 + 1]);
+        tmp[i * 2 + 1] = mmUnpackhiEpi8(stage[2][i * 2], stage[2][i * 2 + 1]);
       }
       for (size_t i = 0; i < 2; ++i) {
-        final_result[i * 2] = _mm_unpacklo_epi64(tmp[i], tmp[i + 2]);
-        final_result[i * 2 + 1] = _mm_unpackhi_epi64(tmp[i], tmp[i + 2]);
+        finalResult[i * 2] = mmUnpackloEpi64(tmp[i], tmp[i + 2]);
+        finalResult[i * 2 + 1] = mmUnpackhiEpi64(tmp[i], tmp[i + 2]);
       }
     }
     for (size_t i = 0; i < kNumStreams; ++i) {
-      _mm_storeu_si128(&output_buffer_streams[i][block_index], final_result[i]);
+      mmStoreuSi128(&outputBufferStreams[i][blockIndex], finalResult[i]);
     }
   }
 }
@@ -191,9 +190,9 @@ void ByteStreamSplitEncodeSse2(
 
 #if defined(ARROW_HAVE_AVX2)
 template <typename T>
-void ByteStreamSplitDecodeAvx2(
+void byteStreamSplitDecodeAvx2(
     const uint8_t* data,
-    int64_t num_values,
+    int64_t numValues,
     int64_t stride,
     T* out) {
   constexpr size_t kNumStreams = sizeof(T);
@@ -202,119 +201,117 @@ void ByteStreamSplitDecodeAvx2(
   constexpr size_t kNumStreamsLog2 = (kNumStreams == 8U ? 3U : 2U);
   constexpr int64_t kBlockSize = sizeof(__m256i) * kNumStreams;
 
-  const int64_t size = num_values * sizeof(T);
+  const int64_t size = numValues * sizeof(T);
   if (size < kBlockSize) // Back to SSE for small size
-    return ByteStreamSplitDecodeSse2(data, num_values, stride, out);
-  const int64_t num_blocks = size / kBlockSize;
-  uint8_t* output_data = reinterpret_cast<uint8_t*>(out);
+    return byteStreamSplitDecodeSse2(data, numValues, stride, out);
+  const int64_t numBlocks = size / kBlockSize;
+  uint8_t* outputData = reinterpret_cast<uint8_t*>(out);
 
   // First handle suffix.
-  const int64_t num_processed_elements =
-      (num_blocks * kBlockSize) / kNumStreams;
-  for (int64_t i = num_processed_elements; i < num_values; ++i) {
-    uint8_t gathered_byte_data[kNumStreams];
+  const int64_t numProcessedElements = (numBlocks * kBlockSize) / kNumStreams;
+  for (int64_t i = numProcessedElements; i < numValues; ++i) {
+    uint8_t gatheredByteData[kNumStreams];
     for (size_t b = 0; b < kNumStreams; ++b) {
-      const size_t byte_index = b * stride + i;
-      gathered_byte_data[b] = data[byte_index];
+      const size_t byteIndex = b * stride + i;
+      gatheredByteData[b] = data[byteIndex];
     }
-    out[i] = arrow::util::SafeLoadAs<T>(&gathered_byte_data[0]);
+    out[i] = arrow::util::SafeLoadAs<T>(&gatheredByteData[0]);
   }
 
   // Processed hierarchically using unpack intrinsics, then permute intrinsics.
   __m256i stage[kNumStreamsLog2 + 1U][kNumStreams];
-  __m256i final_result[kNumStreams];
+  __m256i finalResult[kNumStreams];
   constexpr size_t kNumStreamsHalf = kNumStreams / 2U;
 
-  for (int64_t i = 0; i < num_blocks; ++i) {
+  for (int64_t i = 0; i < numBlocks; ++i) {
     for (size_t j = 0; j < kNumStreams; ++j) {
-      stage[0][j] = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(
-          &data[i * sizeof(__m256i) + j * stride]));
+      stage[0][j] = mm256LoaduSi256(
+          reinterpret_cast<const __m256i*>(
+              &data[i * sizeof(__m256i) + j * stride]));
     }
 
     for (size_t step = 0; step < kNumStreamsLog2; ++step) {
       for (size_t j = 0; j < kNumStreamsHalf; ++j) {
-        stage[step + 1U][j * 2] = _mm256_unpacklo_epi8(
-            stage[step][j], stage[step][kNumStreamsHalf + j]);
-        stage[step + 1U][j * 2 + 1U] = _mm256_unpackhi_epi8(
-            stage[step][j], stage[step][kNumStreamsHalf + j]);
+        stage[step + 1U][j * 2] =
+            mm256UnpackloEpi8(stage[step][j], stage[step][kNumStreamsHalf + j]);
+        stage[step + 1U][j * 2 + 1U] =
+            mm256UnpackhiEpi8(stage[step][j], stage[step][kNumStreamsHalf + j]);
       }
     }
 
     if constexpr (kNumStreams == 8U) {
-      // path for double, 128i index:
-      //   {0x00, 0x08}, {0x01, 0x09}, {0x02, 0x0A}, {0x03, 0x0B},
-      //   {0x04, 0x0C}, {0x05, 0x0D}, {0x06, 0x0E}, {0x07, 0x0F},
-      final_result[0] = _mm256_permute2x128_si256(
+      // Path for double, 128i index:
+      //   {0X00, 0x08}, {0x01, 0x09}, {0x02, 0x0A}, {0x03, 0x0B},
+      //   {0X04, 0x0C}, {0x05, 0x0D}, {0x06, 0x0E}, {0x07, 0x0F},
+      finalResult[0] = mm256Permute2x128Si256(
           stage[kNumStreamsLog2][0], stage[kNumStreamsLog2][1], 0b00100000);
-      final_result[1] = _mm256_permute2x128_si256(
+      finalResult[1] = mm256Permute2x128Si256(
           stage[kNumStreamsLog2][2], stage[kNumStreamsLog2][3], 0b00100000);
-      final_result[2] = _mm256_permute2x128_si256(
+      finalResult[2] = mm256Permute2x128Si256(
           stage[kNumStreamsLog2][4], stage[kNumStreamsLog2][5], 0b00100000);
-      final_result[3] = _mm256_permute2x128_si256(
+      finalResult[3] = mm256Permute2x128Si256(
           stage[kNumStreamsLog2][6], stage[kNumStreamsLog2][7], 0b00100000);
-      final_result[4] = _mm256_permute2x128_si256(
+      finalResult[4] = mm256Permute2x128Si256(
           stage[kNumStreamsLog2][0], stage[kNumStreamsLog2][1], 0b00110001);
-      final_result[5] = _mm256_permute2x128_si256(
+      finalResult[5] = mm256Permute2x128Si256(
           stage[kNumStreamsLog2][2], stage[kNumStreamsLog2][3], 0b00110001);
-      final_result[6] = _mm256_permute2x128_si256(
+      finalResult[6] = mm256Permute2x128Si256(
           stage[kNumStreamsLog2][4], stage[kNumStreamsLog2][5], 0b00110001);
-      final_result[7] = _mm256_permute2x128_si256(
+      finalResult[7] = mm256Permute2x128Si256(
           stage[kNumStreamsLog2][6], stage[kNumStreamsLog2][7], 0b00110001);
     } else {
-      // path for float, 128i index:
+      // Path for float, 128i index:
       //   {0x00, 0x04}, {0x01, 0x05}, {0x02, 0x06}, {0x03, 0x07}
-      final_result[0] = _mm256_permute2x128_si256(
+      finalResult[0] = mm256Permute2x128Si256(
           stage[kNumStreamsLog2][0], stage[kNumStreamsLog2][1], 0b00100000);
-      final_result[1] = _mm256_permute2x128_si256(
+      finalResult[1] = mm256Permute2x128Si256(
           stage[kNumStreamsLog2][2], stage[kNumStreamsLog2][3], 0b00100000);
-      final_result[2] = _mm256_permute2x128_si256(
+      finalResult[2] = mm256Permute2x128Si256(
           stage[kNumStreamsLog2][0], stage[kNumStreamsLog2][1], 0b00110001);
-      final_result[3] = _mm256_permute2x128_si256(
+      finalResult[3] = mm256Permute2x128Si256(
           stage[kNumStreamsLog2][2], stage[kNumStreamsLog2][3], 0b00110001);
     }
 
     for (size_t j = 0; j < kNumStreams; ++j) {
-      _mm256_storeu_si256(
+      mm256StoreuSi256(
           reinterpret_cast<__m256i*>(
-              &output_data[(i * kNumStreams + j) * sizeof(__m256i)]),
-          final_result[j]);
+              &outputData[(i * kNumStreams + j) * sizeof(__m256i)]),
+          finalResult[j]);
     }
   }
 }
 
 template <typename T>
-void ByteStreamSplitEncodeAvx2(
-    const uint8_t* raw_values,
-    const size_t num_values,
-    uint8_t* output_buffer_raw) {
+void byteStreamSplitEncodeAvx2(
+    const uint8_t* rawValues,
+    const size_t numValues,
+    uint8_t* outputBufferRaw) {
   constexpr size_t kNumStreams = sizeof(T);
   static_assert(
       kNumStreams == 4U || kNumStreams == 8U, "Invalid number of streams.");
   constexpr size_t kBlockSize = sizeof(__m256i) * kNumStreams;
 
   if constexpr (kNumStreams == 8U) // Back to SSE, currently no path for double.
-    return ByteStreamSplitEncodeSse2<T>(
-        raw_values, num_values, output_buffer_raw);
+    return byteStreamSplitEncodeSse2<T>(rawValues, numValues, outputBufferRaw);
 
-  const size_t size = num_values * sizeof(T);
+  const size_t size = numValues * sizeof(T);
   if (size < kBlockSize) // Back to SSE for small size
-    return ByteStreamSplitEncodeSse2<T>(
-        raw_values, num_values, output_buffer_raw);
-  const size_t num_blocks = size / kBlockSize;
-  const __m256i* raw_values_simd = reinterpret_cast<const __m256i*>(raw_values);
-  __m256i* output_buffer_streams[kNumStreams];
+    return byteStreamSplitEncodeSse2<T>(rawValues, numValues, outputBufferRaw);
+  const size_t numBlocks = size / kBlockSize;
+  const __m256i* rawValuesSimd = reinterpret_cast<const __m256i*>(rawValues);
+  __m256i* outputBufferStreams[kNumStreams];
 
   for (size_t i = 0; i < kNumStreams; ++i) {
-    output_buffer_streams[i] =
-        reinterpret_cast<__m256i*>(&output_buffer_raw[num_values * i]);
+    outputBufferStreams[i] =
+        reinterpret_cast<__m256i*>(&outputBufferRaw[numValues * i]);
   }
 
   // First handle suffix.
-  const size_t num_processed_elements = (num_blocks * kBlockSize) / sizeof(T);
-  for (size_t i = num_processed_elements; i < num_values; ++i) {
+  const size_t numProcessedElements = (numBlocks * kBlockSize) / sizeof(T);
+  for (size_t i = numProcessedElements; i < numValues; ++i) {
     for (size_t j = 0U; j < kNumStreams; ++j) {
-      const uint8_t byte_in_value = raw_values[i * kNumStreams + j];
-      output_buffer_raw[j * num_values + i] = byte_in_value;
+      const uint8_t byteInValue = rawValues[i * kNumStreams + j];
+      outputBufferRaw[j * numValues + i] = byteInValue;
     }
   }
 
@@ -325,42 +322,36 @@ void ByteStreamSplitEncodeAvx2(
   constexpr size_t kNumUnpack = 3U;
   __m256i stage[kNumUnpack + 1][kNumStreams];
   static const __m256i kPermuteMask =
-      _mm256_set_epi32(0x07, 0x03, 0x06, 0x02, 0x05, 0x01, 0x04, 0x00);
+      mm256SetEpi32(0x07, 0x03, 0x06, 0x02, 0x05, 0x01, 0x04, 0x00);
   __m256i permute[kNumStreams];
-  __m256i final_result[kNumStreams];
+  __m256i finalResult[kNumStreams];
 
-  for (size_t block_index = 0; block_index < num_blocks; ++block_index) {
+  for (size_t blockIndex = 0; blockIndex < numBlocks; ++blockIndex) {
     for (size_t i = 0; i < kNumStreams; ++i) {
       stage[0][i] =
-          _mm256_loadu_si256(&raw_values_simd[block_index * kNumStreams + i]);
+          mm256LoaduSi256(&rawValuesSimd[blockIndex * kNumStreams + i]);
     }
 
-    for (size_t stage_lvl = 0; stage_lvl < kNumUnpack; ++stage_lvl) {
+    for (size_t stageLvl = 0; stageLvl < kNumUnpack; ++stageLvl) {
       for (size_t i = 0; i < kNumStreams / 2U; ++i) {
-        stage[stage_lvl + 1][i * 2] = _mm256_unpacklo_epi8(
-            stage[stage_lvl][i * 2], stage[stage_lvl][i * 2 + 1]);
-        stage[stage_lvl + 1][i * 2 + 1] = _mm256_unpackhi_epi8(
-            stage[stage_lvl][i * 2], stage[stage_lvl][i * 2 + 1]);
+        stage[stageLvl + 1][i * 2] = mm256UnpackloEpi8(
+            stage[stageLvl][i * 2], stage[stageLvl][i * 2 + 1]);
+        stage[stageLvl + 1][i * 2 + 1] = mm256UnpackhiEpi8(
+            stage[stageLvl][i * 2], stage[stageLvl][i * 2 + 1]);
       }
     }
 
     for (size_t i = 0; i < kNumStreams; ++i) {
-      permute[i] =
-          _mm256_permutevar8x32_epi32(stage[kNumUnpack][i], kPermuteMask);
+      permute[i] = mm256Permutevar8x32Epi32(stage[kNumUnpack][i], kPermuteMask);
     }
 
-    final_result[0] =
-        _mm256_permute2x128_si256(permute[0], permute[2], 0b00100000);
-    final_result[1] =
-        _mm256_permute2x128_si256(permute[0], permute[2], 0b00110001);
-    final_result[2] =
-        _mm256_permute2x128_si256(permute[1], permute[3], 0b00100000);
-    final_result[3] =
-        _mm256_permute2x128_si256(permute[1], permute[3], 0b00110001);
+    finalResult[0] = mm256Permute2x128Si256(permute[0], permute[2], 0b00100000);
+    finalResult[1] = mm256Permute2x128Si256(permute[0], permute[2], 0b00110001);
+    finalResult[2] = mm256Permute2x128Si256(permute[1], permute[3], 0b00100000);
+    finalResult[3] = mm256Permute2x128Si256(permute[1], permute[3], 0b00110001);
 
     for (size_t i = 0; i < kNumStreams; ++i) {
-      _mm256_storeu_si256(
-          &output_buffer_streams[i][block_index], final_result[i]);
+      mm256StoreuSi256(&outputBufferStreams[i][blockIndex], finalResult[i]);
     }
   }
 }
@@ -368,9 +359,9 @@ void ByteStreamSplitEncodeAvx2(
 
 #if defined(ARROW_HAVE_AVX512)
 template <typename T>
-void ByteStreamSplitDecodeAvx512(
+void byteStreamSplitDecodeAvx512(
     const uint8_t* data,
-    int64_t num_values,
+    int64_t numValues,
     int64_t stride,
     T* out) {
   constexpr size_t kNumStreams = sizeof(T);
@@ -379,157 +370,144 @@ void ByteStreamSplitDecodeAvx512(
   constexpr size_t kNumStreamsLog2 = (kNumStreams == 8U ? 3U : 2U);
   constexpr int64_t kBlockSize = sizeof(__m512i) * kNumStreams;
 
-  const int64_t size = num_values * sizeof(T);
+  const int64_t size = numValues * sizeof(T);
   if (size < kBlockSize) // Back to AVX2 for small size
-    return ByteStreamSplitDecodeAvx2(data, num_values, stride, out);
-  const int64_t num_blocks = size / kBlockSize;
-  uint8_t* output_data = reinterpret_cast<uint8_t*>(out);
+    return byteStreamSplitDecodeAvx2(data, numValues, stride, out);
+  const int64_t numBlocks = size / kBlockSize;
+  uint8_t* outputData = reinterpret_cast<uint8_t*>(out);
 
   // First handle suffix.
-  const int64_t num_processed_elements =
-      (num_blocks * kBlockSize) / kNumStreams;
-  for (int64_t i = num_processed_elements; i < num_values; ++i) {
-    uint8_t gathered_byte_data[kNumStreams];
+  const int64_t numProcessedElements = (numBlocks * kBlockSize) / kNumStreams;
+  for (int64_t i = numProcessedElements; i < numValues; ++i) {
+    uint8_t gatheredByteData[kNumStreams];
     for (size_t b = 0; b < kNumStreams; ++b) {
-      const size_t byte_index = b * stride + i;
-      gathered_byte_data[b] = data[byte_index];
+      const size_t byteIndex = b * stride + i;
+      gatheredByteData[b] = data[byteIndex];
     }
-    out[i] = arrow::util::SafeLoadAs<T>(&gathered_byte_data[0]);
+    out[i] = arrow::util::SafeLoadAs<T>(&gatheredByteData[0]);
   }
 
   // Processed hierarchically using the unpack, then two shuffles.
   __m512i stage[kNumStreamsLog2 + 1U][kNumStreams];
   __m512i shuffle[kNumStreams];
-  __m512i final_result[kNumStreams];
+  __m512i finalResult[kNumStreams];
   constexpr size_t kNumStreamsHalf = kNumStreams / 2U;
 
-  for (int64_t i = 0; i < num_blocks; ++i) {
+  for (int64_t i = 0; i < numBlocks; ++i) {
     for (size_t j = 0; j < kNumStreams; ++j) {
-      stage[0][j] = _mm512_loadu_si512(reinterpret_cast<const __m512i*>(
-          &data[i * sizeof(__m512i) + j * stride]));
+      stage[0][j] = mm512LoaduSi512(
+          reinterpret_cast<const __m512i*>(
+              &data[i * sizeof(__m512i) + j * stride]));
     }
 
     for (size_t step = 0; step < kNumStreamsLog2; ++step) {
       for (size_t j = 0; j < kNumStreamsHalf; ++j) {
-        stage[step + 1U][j * 2] = _mm512_unpacklo_epi8(
-            stage[step][j], stage[step][kNumStreamsHalf + j]);
-        stage[step + 1U][j * 2 + 1U] = _mm512_unpackhi_epi8(
-            stage[step][j], stage[step][kNumStreamsHalf + j]);
+        stage[step + 1U][j * 2] =
+            mm512UnpackloEpi8(stage[step][j], stage[step][kNumStreamsHalf + j]);
+        stage[step + 1U][j * 2 + 1U] =
+            mm512UnpackhiEpi8(stage[step][j], stage[step][kNumStreamsHalf + j]);
       }
     }
 
     if constexpr (kNumStreams == 8U) {
-      // path for double, 128i index:
-      // {0x00, 0x04, 0x08, 0x0C}, {0x10, 0x14, 0x18, 0x1C},
-      // {0x01, 0x05, 0x09, 0x0D}, {0x11, 0x15, 0x19, 0x1D},
-      // {0x02, 0x06, 0x0A, 0x0E}, {0x12, 0x16, 0x1A, 0x1E},
-      // {0x03, 0x07, 0x0B, 0x0F}, {0x13, 0x17, 0x1B, 0x1F},
-      shuffle[0] = _mm512_shuffle_i32x4(
+      // Path for double, 128i index:
+      // {0X00, 0x04, 0x08, 0x0C}, {0x10, 0x14, 0x18, 0x1C},
+      // {0X01, 0x05, 0x09, 0x0D}, {0x11, 0x15, 0x19, 0x1D},
+      // {0X02, 0x06, 0x0A, 0x0E}, {0x12, 0x16, 0x1A, 0x1E},
+      // {0X03, 0x07, 0x0B, 0x0F}, {0x13, 0x17, 0x1B, 0x1F},
+      shuffle[0] = mm512ShuffleI32x4(
           stage[kNumStreamsLog2][0], stage[kNumStreamsLog2][1], 0b01000100);
-      shuffle[1] = _mm512_shuffle_i32x4(
+      shuffle[1] = mm512ShuffleI32x4(
           stage[kNumStreamsLog2][2], stage[kNumStreamsLog2][3], 0b01000100);
-      shuffle[2] = _mm512_shuffle_i32x4(
+      shuffle[2] = mm512ShuffleI32x4(
           stage[kNumStreamsLog2][4], stage[kNumStreamsLog2][5], 0b01000100);
-      shuffle[3] = _mm512_shuffle_i32x4(
+      shuffle[3] = mm512ShuffleI32x4(
           stage[kNumStreamsLog2][6], stage[kNumStreamsLog2][7], 0b01000100);
-      shuffle[4] = _mm512_shuffle_i32x4(
+      shuffle[4] = mm512ShuffleI32x4(
           stage[kNumStreamsLog2][0], stage[kNumStreamsLog2][1], 0b11101110);
-      shuffle[5] = _mm512_shuffle_i32x4(
+      shuffle[5] = mm512ShuffleI32x4(
           stage[kNumStreamsLog2][2], stage[kNumStreamsLog2][3], 0b11101110);
-      shuffle[6] = _mm512_shuffle_i32x4(
+      shuffle[6] = mm512ShuffleI32x4(
           stage[kNumStreamsLog2][4], stage[kNumStreamsLog2][5], 0b11101110);
-      shuffle[7] = _mm512_shuffle_i32x4(
+      shuffle[7] = mm512ShuffleI32x4(
           stage[kNumStreamsLog2][6], stage[kNumStreamsLog2][7], 0b11101110);
 
-      final_result[0] =
-          _mm512_shuffle_i32x4(shuffle[0], shuffle[1], 0b10001000);
-      final_result[1] =
-          _mm512_shuffle_i32x4(shuffle[2], shuffle[3], 0b10001000);
-      final_result[2] =
-          _mm512_shuffle_i32x4(shuffle[0], shuffle[1], 0b11011101);
-      final_result[3] =
-          _mm512_shuffle_i32x4(shuffle[2], shuffle[3], 0b11011101);
-      final_result[4] =
-          _mm512_shuffle_i32x4(shuffle[4], shuffle[5], 0b10001000);
-      final_result[5] =
-          _mm512_shuffle_i32x4(shuffle[6], shuffle[7], 0b10001000);
-      final_result[6] =
-          _mm512_shuffle_i32x4(shuffle[4], shuffle[5], 0b11011101);
-      final_result[7] =
-          _mm512_shuffle_i32x4(shuffle[6], shuffle[7], 0b11011101);
+      finalResult[0] = mm512ShuffleI32x4(shuffle[0], shuffle[1], 0b10001000);
+      finalResult[1] = mm512ShuffleI32x4(shuffle[2], shuffle[3], 0b10001000);
+      finalResult[2] = mm512ShuffleI32x4(shuffle[0], shuffle[1], 0b11011101);
+      finalResult[3] = mm512ShuffleI32x4(shuffle[2], shuffle[3], 0b11011101);
+      finalResult[4] = mm512ShuffleI32x4(shuffle[4], shuffle[5], 0b10001000);
+      finalResult[5] = mm512ShuffleI32x4(shuffle[6], shuffle[7], 0b10001000);
+      finalResult[6] = mm512ShuffleI32x4(shuffle[4], shuffle[5], 0b11011101);
+      finalResult[7] = mm512ShuffleI32x4(shuffle[6], shuffle[7], 0b11011101);
     } else {
-      // path for float, 128i index:
+      // Path for float, 128i index:
       // {0x00, 0x04, 0x08, 0x0C}, {0x01, 0x05, 0x09, 0x0D}
-      // {0x02, 0x06, 0x0A, 0x0E}, {0x03, 0x07, 0x0B, 0x0F},
-      shuffle[0] = _mm512_shuffle_i32x4(
+      // {0X02, 0x06, 0x0A, 0x0E}, {0x03, 0x07, 0x0B, 0x0F},
+      shuffle[0] = mm512ShuffleI32x4(
           stage[kNumStreamsLog2][0], stage[kNumStreamsLog2][1], 0b01000100);
-      shuffle[1] = _mm512_shuffle_i32x4(
+      shuffle[1] = mm512ShuffleI32x4(
           stage[kNumStreamsLog2][2], stage[kNumStreamsLog2][3], 0b01000100);
-      shuffle[2] = _mm512_shuffle_i32x4(
+      shuffle[2] = mm512ShuffleI32x4(
           stage[kNumStreamsLog2][0], stage[kNumStreamsLog2][1], 0b11101110);
-      shuffle[3] = _mm512_shuffle_i32x4(
+      shuffle[3] = mm512ShuffleI32x4(
           stage[kNumStreamsLog2][2], stage[kNumStreamsLog2][3], 0b11101110);
 
-      final_result[0] =
-          _mm512_shuffle_i32x4(shuffle[0], shuffle[1], 0b10001000);
-      final_result[1] =
-          _mm512_shuffle_i32x4(shuffle[0], shuffle[1], 0b11011101);
-      final_result[2] =
-          _mm512_shuffle_i32x4(shuffle[2], shuffle[3], 0b10001000);
-      final_result[3] =
-          _mm512_shuffle_i32x4(shuffle[2], shuffle[3], 0b11011101);
+      finalResult[0] = mm512ShuffleI32x4(shuffle[0], shuffle[1], 0b10001000);
+      finalResult[1] = mm512ShuffleI32x4(shuffle[0], shuffle[1], 0b11011101);
+      finalResult[2] = mm512ShuffleI32x4(shuffle[2], shuffle[3], 0b10001000);
+      finalResult[3] = mm512ShuffleI32x4(shuffle[2], shuffle[3], 0b11011101);
     }
 
     for (size_t j = 0; j < kNumStreams; ++j) {
-      _mm512_storeu_si512(
+      mm512StoreuSi512(
           reinterpret_cast<__m512i*>(
-              &output_data[(i * kNumStreams + j) * sizeof(__m512i)]),
-          final_result[j]);
+              &outputData[(i * kNumStreams + j) * sizeof(__m512i)]),
+          finalResult[j]);
     }
   }
 }
 
 template <typename T>
-void ByteStreamSplitEncodeAvx512(
-    const uint8_t* raw_values,
-    const size_t num_values,
-    uint8_t* output_buffer_raw) {
+void byteStreamSplitEncodeAvx512(
+    const uint8_t* rawValues,
+    const size_t numValues,
+    uint8_t* outputBufferRaw) {
   constexpr size_t kNumStreams = sizeof(T);
   static_assert(
       kNumStreams == 4U || kNumStreams == 8U, "Invalid number of streams.");
   constexpr size_t kBlockSize = sizeof(__m512i) * kNumStreams;
 
-  const size_t size = num_values * sizeof(T);
+  const size_t size = numValues * sizeof(T);
 
   if (size < kBlockSize) // Back to AVX2 for small size
-    return ByteStreamSplitEncodeAvx2<T>(
-        raw_values, num_values, output_buffer_raw);
+    return byteStreamSplitEncodeAvx2<T>(rawValues, numValues, outputBufferRaw);
 
-  const size_t num_blocks = size / kBlockSize;
-  const __m512i* raw_values_simd = reinterpret_cast<const __m512i*>(raw_values);
-  __m512i* output_buffer_streams[kNumStreams];
+  const size_t numBlocks = size / kBlockSize;
+  const __m512i* rawValuesSimd = reinterpret_cast<const __m512i*>(rawValues);
+  __m512i* outputBufferStreams[kNumStreams];
   for (size_t i = 0; i < kNumStreams; ++i) {
-    output_buffer_streams[i] =
-        reinterpret_cast<__m512i*>(&output_buffer_raw[num_values * i]);
+    outputBufferStreams[i] =
+        reinterpret_cast<__m512i*>(&outputBufferRaw[numValues * i]);
   }
 
   // First handle suffix.
-  const size_t num_processed_elements = (num_blocks * kBlockSize) / sizeof(T);
-  for (size_t i = num_processed_elements; i < num_values; ++i) {
+  const size_t numProcessedElements = (numBlocks * kBlockSize) / sizeof(T);
+  for (size_t i = numProcessedElements; i < numValues; ++i) {
     for (size_t j = 0U; j < kNumStreams; ++j) {
-      const uint8_t byte_in_value = raw_values[i * kNumStreams + j];
-      output_buffer_raw[j * num_values + i] = byte_in_value;
+      const uint8_t byteInValue = rawValues[i * kNumStreams + j];
+      outputBufferRaw[j * numValues + i] = byteInValue;
     }
   }
 
   constexpr size_t KNumUnpack = (kNumStreams == 8U) ? 2U : 3U;
-  __m512i final_result[kNumStreams];
+  __m512i finalResult[kNumStreams];
   __m512i unpack[KNumUnpack + 1][kNumStreams];
   __m512i permutex[kNumStreams];
-  __m512i permutex_mask;
+  __m512i permutexMask;
   if constexpr (kNumStreams == 8U) {
-    // use _mm512_set_epi32, no _mm512_set_epi16 for some old gcc version.
-    permutex_mask = _mm512_set_epi32(
+    // Use _mm512_set_epi32, no _mm512_set_epi16 for some old gcc version.
+    permutexMask = mm512SetEpi32(
         0x001F0017,
         0x000F0007,
         0x001E0016,
@@ -547,7 +525,7 @@ void ByteStreamSplitEncodeAvx512(
         0x00180010,
         0x00080000);
   } else {
-    permutex_mask = _mm512_set_epi32(
+    permutexMask = mm512SetEpi32(
         0x0F,
         0x0B,
         0x07,
@@ -566,60 +544,52 @@ void ByteStreamSplitEncodeAvx512(
         0x00);
   }
 
-  for (size_t block_index = 0; block_index < num_blocks; ++block_index) {
+  for (size_t blockIndex = 0; blockIndex < numBlocks; ++blockIndex) {
     for (size_t i = 0; i < kNumStreams; ++i) {
       unpack[0][i] =
-          _mm512_loadu_si512(&raw_values_simd[block_index * kNumStreams + i]);
+          mm512LoaduSi512(&rawValuesSimd[blockIndex * kNumStreams + i]);
     }
 
-    for (size_t unpack_lvl = 0; unpack_lvl < KNumUnpack; ++unpack_lvl) {
+    for (size_t unpackLvl = 0; unpackLvl < KNumUnpack; ++unpackLvl) {
       for (size_t i = 0; i < kNumStreams / 2U; ++i) {
-        unpack[unpack_lvl + 1][i * 2] = _mm512_unpacklo_epi8(
-            unpack[unpack_lvl][i * 2], unpack[unpack_lvl][i * 2 + 1]);
-        unpack[unpack_lvl + 1][i * 2 + 1] = _mm512_unpackhi_epi8(
-            unpack[unpack_lvl][i * 2], unpack[unpack_lvl][i * 2 + 1]);
+        unpack[unpackLvl + 1][i * 2] = mm512UnpackloEpi8(
+            unpack[unpackLvl][i * 2], unpack[unpackLvl][i * 2 + 1]);
+        unpack[unpackLvl + 1][i * 2 + 1] = mm512UnpackhiEpi8(
+            unpack[unpackLvl][i * 2], unpack[unpackLvl][i * 2 + 1]);
       }
     }
 
     if constexpr (kNumStreams == 8U) {
-      // path for double
-      // 1. unpack to epi16 block
-      // 2. permutexvar_epi16 to 128i block
-      // 3. shuffle 128i to final 512i target, index:
-      //   {0x00, 0x04, 0x08, 0x0C}, {0x10, 0x14, 0x18, 0x1C},
-      //   {0x01, 0x05, 0x09, 0x0D}, {0x11, 0x15, 0x19, 0x1D},
-      //   {0x02, 0x06, 0x0A, 0x0E}, {0x12, 0x16, 0x1A, 0x1E},
-      //   {0x03, 0x07, 0x0B, 0x0F}, {0x13, 0x17, 0x1B, 0x1F},
+      // Path for double.
+      // 1. Unpack to epi16 block.
+      // 2. Permutexvar_epi16 to 128i block.
+      // 3. Shuffle 128i to final 512i target, index:
+      //   {0X00, 0x04, 0x08, 0x0C}, {0x10, 0x14, 0x18, 0x1C},
+      //   {0X01, 0x05, 0x09, 0x0D}, {0x11, 0x15, 0x19, 0x1D},
+      //   {0X02, 0x06, 0x0A, 0x0E}, {0x12, 0x16, 0x1A, 0x1E},
+      //   {0X03, 0x07, 0x0B, 0x0F}, {0x13, 0x17, 0x1B, 0x1F},
       for (size_t i = 0; i < kNumStreams; ++i)
         permutex[i] =
-            _mm512_permutexvar_epi16(permutex_mask, unpack[KNumUnpack][i]);
+            mm512PermutexvarEpi16(permutexMask, unpack[KNumUnpack][i]);
 
       __m512i shuffle[kNumStreams];
-      shuffle[0] = _mm512_shuffle_i32x4(permutex[0], permutex[2], 0b01000100);
-      shuffle[1] = _mm512_shuffle_i32x4(permutex[4], permutex[6], 0b01000100);
-      shuffle[2] = _mm512_shuffle_i32x4(permutex[0], permutex[2], 0b11101110);
-      shuffle[3] = _mm512_shuffle_i32x4(permutex[4], permutex[6], 0b11101110);
-      shuffle[4] = _mm512_shuffle_i32x4(permutex[1], permutex[3], 0b01000100);
-      shuffle[5] = _mm512_shuffle_i32x4(permutex[5], permutex[7], 0b01000100);
-      shuffle[6] = _mm512_shuffle_i32x4(permutex[1], permutex[3], 0b11101110);
-      shuffle[7] = _mm512_shuffle_i32x4(permutex[5], permutex[7], 0b11101110);
-
-      final_result[0] =
-          _mm512_shuffle_i32x4(shuffle[0], shuffle[1], 0b10001000);
-      final_result[1] =
-          _mm512_shuffle_i32x4(shuffle[0], shuffle[1], 0b11011101);
-      final_result[2] =
-          _mm512_shuffle_i32x4(shuffle[2], shuffle[3], 0b10001000);
-      final_result[3] =
-          _mm512_shuffle_i32x4(shuffle[2], shuffle[3], 0b11011101);
-      final_result[4] =
-          _mm512_shuffle_i32x4(shuffle[4], shuffle[5], 0b10001000);
-      final_result[5] =
-          _mm512_shuffle_i32x4(shuffle[4], shuffle[5], 0b11011101);
-      final_result[6] =
-          _mm512_shuffle_i32x4(shuffle[6], shuffle[7], 0b10001000);
-      final_result[7] =
-          _mm512_shuffle_i32x4(shuffle[6], shuffle[7], 0b11011101);
+      shuffle[0] = mm512ShuffleI32x4(permutex[0], permutex[2], 0b01000100);
+      shuffle[1] = mm512ShuffleI32x4(permutex[4], permutex[6], 0b01000100);
+      shuffle[2] = mm512ShuffleI32x4(permutex[0], permutex[2], 0b11101110);
+      shuffle[3] = mm512ShuffleI32x4(permutex[4], permutex[6], 0b11101110);
+      shuffle[4] = mm512ShuffleI32x4(permutex[1], permutex[3], 0b01000100);
+      shuffle[5] = mm512ShuffleI32x4(permutex[5], permutex[7], 0b01000100);
+      shuffle[6] = mm512ShuffleI32x4(permutex[1], permutex[3], 0b11101110);
+      shuffle[7] = mm512ShuffleI32x4(permutex[5], permutex[7], 0b11101110);
+
+      finalResult[0] = mm512ShuffleI32x4(shuffle[0], shuffle[1], 0b10001000);
+      finalResult[1] = mm512ShuffleI32x4(shuffle[0], shuffle[1], 0b11011101);
+      finalResult[2] = mm512ShuffleI32x4(shuffle[2], shuffle[3], 0b10001000);
+      finalResult[3] = mm512ShuffleI32x4(shuffle[2], shuffle[3], 0b11011101);
+      finalResult[4] = mm512ShuffleI32x4(shuffle[4], shuffle[5], 0b10001000);
+      finalResult[5] = mm512ShuffleI32x4(shuffle[4], shuffle[5], 0b11011101);
+      finalResult[6] = mm512ShuffleI32x4(shuffle[6], shuffle[7], 0b10001000);
+      finalResult[7] = mm512ShuffleI32x4(shuffle[6], shuffle[7], 0b11011101);
     } else {
       // Path for float.
       // 1. Processed hierarchically to 32i block using the unpack intrinsics.
@@ -627,21 +597,16 @@ void ByteStreamSplitEncodeAvx512(
       // 3. Pack final 256i block with _mm256_permute2x128_si256.
       for (size_t i = 0; i < kNumStreams; ++i)
         permutex[i] =
-            _mm512_permutexvar_epi32(permutex_mask, unpack[KNumUnpack][i]);
+            mm512PermutexvarEpi32(permutexMask, unpack[KNumUnpack][i]);
 
-      final_result[0] =
-          _mm512_shuffle_i32x4(permutex[0], permutex[2], 0b01000100);
-      final_result[1] =
-          _mm512_shuffle_i32x4(permutex[0], permutex[2], 0b11101110);
-      final_result[2] =
-          _mm512_shuffle_i32x4(permutex[1], permutex[3], 0b01000100);
-      final_result[3] =
-          _mm512_shuffle_i32x4(permutex[1], permutex[3], 0b11101110);
+      finalResult[0] = mm512ShuffleI32x4(permutex[0], permutex[2], 0b01000100);
+      finalResult[1] = mm512ShuffleI32x4(permutex[0], permutex[2], 0b11101110);
+      finalResult[2] = mm512ShuffleI32x4(permutex[1], permutex[3], 0b01000100);
+      finalResult[3] = mm512ShuffleI32x4(permutex[1], permutex[3], 0b11101110);
     }
 
     for (size_t i = 0; i < kNumStreams; ++i) {
-      _mm512_storeu_si512(
-          &output_buffer_streams[i][block_index], final_result[i]);
+      mm512StoreuSi512(&outputBufferStreams[i][blockIndex], finalResult[i]);
     }
   }
 }
@@ -649,36 +614,36 @@ void ByteStreamSplitEncodeAvx512(
 
 #if defined(ARROW_HAVE_SIMD_SPLIT)
 template <typename T>
-void inline ByteStreamSplitDecodeSimd(
+void inline byteStreamSplitDecodeSimd(
     const uint8_t* data,
-    int64_t num_values,
+    int64_t numValues,
     int64_t stride,
     T* out) {
 #if defined(ARROW_HAVE_AVX512)
-  return ByteStreamSplitDecodeAvx512(data, num_values, stride, out);
+  return byteStreamSplitDecodeAvx512(data, numValues, stride, out);
 #elif defined(ARROW_HAVE_AVX2)
-  return ByteStreamSplitDecodeAvx2(data, num_values, stride, out);
+  return byteStreamSplitDecodeAvx2(data, numValues, stride, out);
 #elif defined(ARROW_HAVE_SSE4_2)
-  return ByteStreamSplitDecodeSse2(data, num_values, stride, out);
+  return byteStreamSplitDecodeSse2(data, numValues, stride, out);
 #else
 #error "ByteStreamSplitDecodeSimd not implemented"
 #endif
 }
 
 template <typename T>
-void inline ByteStreamSplitEncodeSimd(
-    const uint8_t* raw_values,
-    const int64_t num_values,
-    uint8_t* output_buffer_raw) {
+void inline byteStreamSplitEncodeSimd(
+    const uint8_t* rawValues,
+    const int64_t numValues,
+    uint8_t* outputBufferRaw) {
 #if defined(ARROW_HAVE_AVX512)
-  return ByteStreamSplitEncodeAvx512<T>(
-      raw_values, static_cast<size_t>(num_values), output_buffer_raw);
+  return byteStreamSplitEncodeAvx512<T>(
+      rawValues, static_cast<size_t>(numValues), outputBufferRaw);
 #elif defined(ARROW_HAVE_AVX2)
-  return ByteStreamSplitEncodeAvx2<T>(
-      raw_values, static_cast<size_t>(num_values), output_buffer_raw);
+  return byteStreamSplitEncodeAvx2<T>(
+      rawValues, static_cast<size_t>(numValues), outputBufferRaw);
 #elif defined(ARROW_HAVE_SSE4_2)
-  return ByteStreamSplitEncodeSse2<T>(
-      raw_values, static_cast<size_t>(num_values), output_buffer_raw);
+  return byteStreamSplitEncodeSse2<T>(
+      rawValues, static_cast<size_t>(numValues), outputBufferRaw);
 #else
 #error "ByteStreamSplitEncodeSimd not implemented"
 #endif
@@ -686,21 +651,21 @@ void inline ByteStreamSplitEncodeSimd(
 #endif
 
 //
-// Scalar implementations
+// Scalar implementations.
 //
 
-inline void DoSplitStreams(
+inline void doSplitStreams(
     const uint8_t* src,
     int width,
     int64_t nvalues,
-    uint8_t** dest_streams) {
+    uint8_t** destStreams) {
   // Value empirically chosen to provide the best performance on the author's
-  // machine
+  // machine.
   constexpr int kBlockSize = 32;
 
   while (nvalues >= kBlockSize) {
     for (int stream = 0; stream < width; ++stream) {
-      uint8_t* dest = dest_streams[stream];
+      uint8_t* dest = destStreams[stream];
       for (int i = 0; i < kBlockSize; i += 8) {
         uint64_t a = src[stream + i * width];
         uint64_t b = src[stream + (i + 1) * width];
@@ -719,35 +684,35 @@ inline void DoSplitStreams(
 #endif
         ::arrow::util::SafeStore(&dest[i], r);
       }
-      dest_streams[stream] += kBlockSize;
+      destStreams[stream] += kBlockSize;
     }
     src += width * kBlockSize;
     nvalues -= kBlockSize;
   }
 
-  // Epilog
+  // Epilog.
   for (int stream = 0; stream < width; ++stream) {
-    uint8_t* dest = dest_streams[stream];
+    uint8_t* dest = destStreams[stream];
     for (int64_t i = 0; i < nvalues; ++i) {
       dest[i] = src[stream + i * width];
     }
   }
 }
 
-inline void DoMergeStreams(
-    const uint8_t** src_streams,
+inline void doMergeStreams(
+    const uint8_t** srcStreams,
     int width,
     int64_t nvalues,
     uint8_t* dest) {
   // Value empirically chosen to provide the best performance on the author's
-  // machine
+  // machine.
   constexpr int kBlockSize = 128;
 
   while (nvalues >= kBlockSize) {
     for (int stream = 0; stream < width; ++stream) {
-      // Take kBlockSize bytes from the given stream and spread them
-      // to their logical places in destination.
-      const uint8_t* src = src_streams[stream];
+      // Take kBlockSize bytes from the given stream and spread them.
+      // To their logical places in destination.
+      const uint8_t* src = srcStreams[stream];
       for (int i = 0; i < kBlockSize; i += 8) {
         uint64_t v = ::arrow::util::SafeLoadAs<uint64_t>(&src[i]);
 #if ARROW_LITTLE_ENDIAN
@@ -770,15 +735,15 @@ inline void DoMergeStreams(
         dest[stream + (i + 7) * width] = static_cast<uint8_t>(v);
 #endif
       }
-      src_streams[stream] += kBlockSize;
+      srcStreams[stream] += kBlockSize;
     }
     dest += width * kBlockSize;
     nvalues -= kBlockSize;
   }
 
-  // Epilog
+  // Epilog.
   for (int stream = 0; stream < width; ++stream) {
-    const uint8_t* src = src_streams[stream];
+    const uint8_t* src = srcStreams[stream];
     for (int64_t i = 0; i < nvalues; ++i) {
       dest[stream + i * width] = src[i];
     }
@@ -786,60 +751,58 @@ inline void DoMergeStreams(
 }
 
 template <typename T>
-void ByteStreamSplitEncodeScalar(
-    const uint8_t* raw_values,
-    const int64_t num_values,
-    uint8_t* output_buffer_raw) {
+void byteStreamSplitEncodeScalar(
+    const uint8_t* rawValues,
+    const int64_t numValues,
+    uint8_t* outputBufferRaw) {
   constexpr int kNumStreams = static_cast<int>(sizeof(T));
-  std::array<uint8_t*, kNumStreams> dest_streams;
+  std::array<uint8_t*, kNumStreams> destStreams;
   for (int stream = 0; stream < kNumStreams; ++stream) {
-    dest_streams[stream] = &output_buffer_raw[stream * num_values];
+    destStreams[stream] = &outputBufferRaw[stream * numValues];
   }
-  DoSplitStreams(raw_values, kNumStreams, num_values, dest_streams.data());
+  doSplitStreams(rawValues, kNumStreams, numValues, destStreams.data());
 }
 
 template <typename T>
-void ByteStreamSplitDecodeScalar(
+void byteStreamSplitDecodeScalar(
     const uint8_t* data,
-    int64_t num_values,
+    int64_t numValues,
     int64_t stride,
     T* out) {
   constexpr int kNumStreams = static_cast<int>(sizeof(T));
-  std::array<const uint8_t*, kNumStreams> src_streams;
+  std::array<const uint8_t*, kNumStreams> srcStreams;
   for (int stream = 0; stream < kNumStreams; ++stream) {
-    src_streams[stream] = &data[stream * stride];
+    srcStreams[stream] = &data[stream * stride];
   }
-  DoMergeStreams(
-      src_streams.data(),
+  doMergeStreams(
+      srcStreams.data(),
       kNumStreams,
-      num_values,
+      numValues,
       reinterpret_cast<uint8_t*>(out));
 }
 
 template <typename T>
-void inline ByteStreamSplitEncode(
-    const uint8_t* raw_values,
-    const int64_t num_values,
-    uint8_t* output_buffer_raw) {
+void inline byteStreamSplitEncode(
+    const uint8_t* rawValues,
+    const int64_t numValues,
+    uint8_t* outputBufferRaw) {
 #if defined(ARROW_HAVE_SIMD_SPLIT)
-  return ByteStreamSplitEncodeSimd<T>(
-      raw_values, num_values, output_buffer_raw);
+  return byteStreamSplitEncodeSimd<T>(rawValues, numValues, outputBufferRaw);
 #else
-  return ByteStreamSplitEncodeScalar<T>(
-      raw_values, num_values, output_buffer_raw);
+  return byteStreamSplitEncodeScalar<T>(rawValues, numValues, outputBufferRaw);
 #endif
 }
 
 template <typename T>
-void inline ByteStreamSplitDecode(
+void inline byteStreamSplitDecode(
     const uint8_t* data,
-    int64_t num_values,
+    int64_t numValues,
     int64_t stride,
     T* out) {
 #if defined(ARROW_HAVE_SIMD_SPLIT)
-  return ByteStreamSplitDecodeSimd(data, num_values, stride, out);
+  return byteStreamSplitDecodeSimd(data, numValues, stride, out);
 #else
-  return ByteStreamSplitDecodeScalar(data, num_values, stride, out);
+  return byteStreamSplitDecodeScalar(data, numValues, stride, out);
 #endif
 }
 
diff --git a/velox/dwio/parquet/writer/arrow/util/CMakeLists.txt b/velox/dwio/parquet/writer/arrow/util/CMakeLists.txt
index 2aff416fcdb..ce41ffe680b 100644
--- a/velox/dwio/parquet/writer/arrow/util/CMakeLists.txt
+++ b/velox/dwio/parquet/writer/arrow/util/CMakeLists.txt
@@ -21,6 +21,15 @@ velox_add_library(
   CompressionLZ4.cpp
   Hashing.cpp
   Crc32.cpp
+  HEADERS
+  ByteStreamSplitInternal.h
+  Compression.h
+  CompressionInternal.h
+  Crc32.h
+  Hashing.h
+  OverflowUtilInternal.h
+  VisitArrayInline.h
+  safe-math.h
 )
 
 velox_link_libraries(
diff --git a/velox/dwio/parquet/writer/arrow/util/Compression.cpp b/velox/dwio/parquet/writer/arrow/util/Compression.cpp
index f5f77313d10..a51c29b917a 100644
--- a/velox/dwio/parquet/writer/arrow/util/Compression.cpp
+++ b/velox/dwio/parquet/writer/arrow/util/Compression.cpp
@@ -24,15 +24,14 @@
 
 #include "arrow/result.h"
 #include "arrow/status.h"
-#include "arrow/util/logging.h"
 #include "velox/dwio/parquet/writer/arrow/util/CompressionInternal.h"
 
 namespace facebook::velox::parquet::arrow::util {
 
 namespace {
 
-Status CheckSupportsCompressionLevel(Compression::type type) {
-  if (!Codec::SupportsCompressionLevel(type)) {
+Status checkSupportsCompressionLevel(Compression::type type) {
+  if (!Codec::supportsCompressionLevel(type)) {
     return Status::Invalid(
         "The specified codec does not support the compression level parameter");
   }
@@ -41,20 +40,20 @@ Status CheckSupportsCompressionLevel(Compression::type type) {
 
 } // namespace
 
-int Codec::UseDefaultCompressionLevel() {
+int Codec::useDefaultCompressionLevel() {
   return kUseDefaultCompressionLevel;
 }
 
-Status Codec::Init() {
+Status Codec::init() {
   return Status::OK();
 }
 
-const std::string& Codec::GetCodecAsString(Compression::type t) {
+const std::string& Codec::getCodecAsString(Compression::type t) {
   static const std::string uncompressed = "uncompressed", snappy = "snappy",
                            gzip = "gzip", lzo = "lzo", brotli = "brotli",
-                           lz4_raw = "lz4_raw", lz4 = "lz4",
-                           lz4_hadoop = "lz4_hadoop", zstd = "zstd",
-                           bz2 = "bz2", unknown = "unknown";
+                           lz4Raw = "lz4_raw", lz4 = "lz4",
+                           lz4Hadoop = "lz4_hadoop", zstd = "zstd", bz2 = "bz2",
+                           unknown = "unknown";
 
   switch (t) {
     case Compression::UNCOMPRESSED:
@@ -68,11 +67,11 @@ const std::string& Codec::GetCodecAsString(Compression::type t) {
     case Compression::BROTLI:
       return brotli;
     case Compression::LZ4:
-      return lz4_raw;
+      return lz4Raw;
     case Compression::LZ4_FRAME:
       return lz4;
     case Compression::LZ4_HADOOP:
-      return lz4_hadoop;
+      return lz4Hadoop;
     case Compression::ZSTD:
       return zstd;
     case Compression::BZ2:
@@ -82,7 +81,7 @@ const std::string& Codec::GetCodecAsString(Compression::type t) {
   }
 }
 
-Result<Compression::type> Codec::GetCompressionType(const std::string& name) {
+Result<Compression::type> Codec::getCompressionType(const std::string& name) {
   if (name == "uncompressed") {
     return Compression::UNCOMPRESSED;
   } else if (name == "gzip") {
@@ -108,7 +107,7 @@ Result<Compression::type> Codec::GetCompressionType(const std::string& name) {
   }
 }
 
-bool Codec::SupportsCompressionLevel(Compression::type codec) {
+bool Codec::supportsCompressionLevel(Compression::type codec) {
   switch (codec) {
     case Compression::GZIP:
     case Compression::BROTLI:
@@ -122,88 +121,88 @@ bool Codec::SupportsCompressionLevel(Compression::type codec) {
   }
 }
 
-Result<int> Codec::MaximumCompressionLevel(Compression::type codec_type) {
-  RETURN_NOT_OK(CheckSupportsCompressionLevel(codec_type));
-  ARROW_ASSIGN_OR_RAISE(auto codec, Codec::Create(codec_type));
-  return codec->maximum_compression_level();
+Result<int> Codec::maximumCompressionLevel(Compression::type codecType) {
+  RETURN_NOT_OK(checkSupportsCompressionLevel(codecType));
+  ARROW_ASSIGN_OR_RAISE(auto codec, Codec::create(codecType));
+  return codec->maximumCompressionLevel();
 }
 
-Result<int> Codec::MinimumCompressionLevel(Compression::type codec_type) {
-  RETURN_NOT_OK(CheckSupportsCompressionLevel(codec_type));
-  ARROW_ASSIGN_OR_RAISE(auto codec, Codec::Create(codec_type));
-  return codec->minimum_compression_level();
+Result<int> Codec::minimumCompressionLevel(Compression::type codecType) {
+  RETURN_NOT_OK(checkSupportsCompressionLevel(codecType));
+  ARROW_ASSIGN_OR_RAISE(auto codec, Codec::create(codecType));
+  return codec->minimumCompressionLevel();
 }
 
-Result<int> Codec::DefaultCompressionLevel(Compression::type codec_type) {
-  RETURN_NOT_OK(CheckSupportsCompressionLevel(codec_type));
-  ARROW_ASSIGN_OR_RAISE(auto codec, Codec::Create(codec_type));
-  return codec->default_compression_level();
+Result<int> Codec::defaultCompressionLevel(Compression::type codecType) {
+  RETURN_NOT_OK(checkSupportsCompressionLevel(codecType));
+  ARROW_ASSIGN_OR_RAISE(auto codec, Codec::create(codecType));
+  return codec->defaultCompressionLevel();
 }
 
-Result<std::unique_ptr<Codec>> Codec::Create(
-    Compression::type codec_type,
-    const CodecOptions& codec_options) {
-  if (!IsAvailable(codec_type)) {
-    if (codec_type == Compression::LZO) {
+Result<std::unique_ptr<Codec>> Codec::create(
+    Compression::type codecType,
+    const CodecOptions& codecOptions) {
+  if (!isAvailable(codecType)) {
+    if (codecType == Compression::LZO) {
       return Status::NotImplemented("LZO codec not implemented");
     }
 
-    auto name = GetCodecAsString(codec_type);
+    auto name = getCodecAsString(codecType);
     if (name == "unknown") {
       return Status::Invalid("Unrecognized codec");
     }
 
     return Status::NotImplemented(
-        "Support for codec '", GetCodecAsString(codec_type), "' not built");
+        "Support for codec '", getCodecAsString(codecType), "' not built");
   }
 
-  auto compression_level = codec_options.compression_level;
-  if (compression_level != kUseDefaultCompressionLevel &&
-      !SupportsCompressionLevel(codec_type)) {
+  auto compressionLevel = codecOptions.compressionLevel;
+  if (compressionLevel != kUseDefaultCompressionLevel &&
+      !supportsCompressionLevel(codecType)) {
     return Status::Invalid(
         "Codec '",
-        GetCodecAsString(codec_type),
+        getCodecAsString(codecType),
         "' doesn't support setting a compression level.");
   }
 
   std::unique_ptr<Codec> codec;
-  switch (codec_type) {
+  switch (codecType) {
     case Compression::UNCOMPRESSED:
       return nullptr;
     case Compression::SNAPPY:
-      codec = internal::MakeSnappyCodec();
+      codec = internal::makeSnappyCodec();
       break;
     case Compression::GZIP: {
-      auto opt = dynamic_cast<const GZipCodecOptions*>(&codec_options);
-      codec = internal::MakeGZipCodec(
-          compression_level,
-          opt ? opt->gzip_format : GZipFormat::GZIP,
-          opt ? opt->window_bits : std::nullopt);
+      auto opt = dynamic_cast<const GZipCodecOptions*>(&codecOptions);
+      codec = internal::makeGZipCodec(
+          compressionLevel,
+          opt ? opt->gzipFormat : GZipFormat::GZIP,
+          opt ? opt->windowBits : std::nullopt);
       break;
     }
     case Compression::BROTLI: {
 #ifdef ARROW_WITH_BROTLI
-      auto opt = dynamic_cast<const BrotliCodecOptions*>(&codec_options);
-      codec = internal::MakeBrotliCodec(
-          compression_level, opt ? opt->window_bits : std::nullopt);
+      auto opt = dynamic_cast<const BrotliCodecOptions*>(&codecOptions);
+      codec = internal::makeBrotliCodec(
+          compressionLevel, opt ? opt->windowBits : std::nullopt);
 #endif
       break;
     }
     case Compression::LZ4:
-      codec = internal::MakeLz4RawCodec(compression_level);
+      codec = internal::makeLz4RawCodec(compressionLevel);
       break;
     case Compression::LZ4_FRAME:
-      codec = internal::MakeLz4FrameCodec(compression_level);
+      codec = internal::makeLz4FrameCodec(compressionLevel);
       break;
     case Compression::LZ4_HADOOP:
-      codec = internal::MakeLz4HadoopRawCodec();
+      codec = internal::makeLz4HadoopRawCodec();
       break;
     case Compression::ZSTD:
-      codec = internal::MakeZSTDCodec(compression_level);
+      codec = internal::makeZSTDCodec(compressionLevel);
       break;
     case Compression::BZ2:
 #ifdef ARROW_WITH_BZ2
-      codec = internal::MakeBZ2Codec(compression_level);
+      codec = internal::makeBZ2Codec(compressionLevel);
 #endif
       break;
     default:
@@ -214,19 +213,19 @@ Result<std::unique_ptr<Codec>> Codec::Create(
     return Status::NotImplemented("LZO codec not implemented");
   }
 
-  RETURN_NOT_OK(codec->Init());
+  RETURN_NOT_OK(codec->init());
   return std::move(codec);
 }
 
-// use compression level to create Codec
-Result<std::unique_ptr<Codec>> Codec::Create(
-    Compression::type codec_type,
-    int compression_level) {
-  return Codec::Create(codec_type, CodecOptions{compression_level});
+// Use compression level to create Codec.
+Result<std::unique_ptr<Codec>> Codec::create(
+    Compression::type codecType,
+    int compressionLevel) {
+  return Codec::create(codecType, CodecOptions{compressionLevel});
 }
 
-bool Codec::IsAvailable(Compression::type codec_type) {
-  switch (codec_type) {
+bool Codec::isAvailable(Compression::type codecType) {
+  switch (codecType) {
     case Compression::UNCOMPRESSED:
     case Compression::SNAPPY:
     case Compression::GZIP:
diff --git a/velox/dwio/parquet/writer/arrow/util/Compression.h b/velox/dwio/parquet/writer/arrow/util/Compression.h
index 7432008fd20..be92fddeebc 100644
--- a/velox/dwio/parquet/writer/arrow/util/Compression.h
+++ b/velox/dwio/parquet/writer/arrow/util/Compression.h
@@ -31,7 +31,7 @@
 namespace facebook::velox::parquet::arrow {
 
 struct Compression {
-  /// \brief Compression algorithm
+  /// \brief Compression algorithm.
   enum type {
     UNCOMPRESSED,
     SNAPPY,
@@ -53,54 +53,53 @@ using namespace ::arrow;
 
 constexpr int kUseDefaultCompressionLevel = std::numeric_limits<int>::min();
 
-/// \brief Streaming compressor interface
+/// \brief Streaming compressor interface.
 ///
 class ARROW_EXPORT Compressor {
  public:
   virtual ~Compressor() = default;
 
   struct CompressResult {
-    int64_t bytes_read;
-    int64_t bytes_written;
+    int64_t bytesRead;
+    int64_t bytesWritten;
   };
   struct FlushResult {
-    int64_t bytes_written;
-    bool should_retry;
+    int64_t bytesWritten;
+    bool shouldRetry;
   };
   struct EndResult {
-    int64_t bytes_written;
-    bool should_retry;
+    int64_t bytesWritten;
+    bool shouldRetry;
   };
 
   /// \brief Compress some input.
   ///
   /// If bytes_read is 0 on return, then a larger output buffer should be
   /// supplied.
-  virtual Result<CompressResult> Compress(
-      int64_t input_len,
+  virtual Result<CompressResult> compress(
+      int64_t inputLen,
       const uint8_t* input,
-      int64_t output_len,
+      int64_t outputLen,
       uint8_t* output) = 0;
 
   /// \brief Flush part of the compressed output.
   ///
-  /// If should_retry is true on return, Flush() should be called again
-  /// with a larger buffer.
-  virtual Result<FlushResult> Flush(int64_t output_len, uint8_t* output) = 0;
+  /// If should_retry is true on return, Flush() should be called again with a
+  /// larger buffer.
+  virtual Result<FlushResult> flush(int64_t outputLen, uint8_t* output) = 0;
 
   /// \brief End compressing, doing whatever is necessary to end the stream.
   ///
-  /// If should_retry is true on return, End() should be called again
-  /// with a larger buffer.  Otherwise, the Compressor should not be used
-  /// anymore.
+  /// If should_retry is true on return, End() should be called again with a
+  /// larger buffer. Otherwise, the Compressor should not be used anymore.
   ///
   /// End() implies Flush().
-  virtual Result<EndResult> End(int64_t output_len, uint8_t* output) = 0;
+  virtual Result<EndResult> end(int64_t outputLen, uint8_t* output) = 0;
 
   // XXX add methods for buffer size heuristics?
 };
 
-/// \brief Streaming decompressor interface
+/// \brief Streaming decompressor interface.
 ///
 class ARROW_EXPORT Decompressor {
  public:
@@ -108,49 +107,48 @@ class ARROW_EXPORT Decompressor {
 
   struct DecompressResult {
     // XXX is need_more_output necessary? (Brotli?)
-    int64_t bytes_read;
-    int64_t bytes_written;
-    bool need_more_output;
+    int64_t bytesRead;
+    int64_t bytesWritten;
+    bool needMoreOutput;
   };
 
   /// \brief Decompress some input.
   ///
-  /// If need_more_output is true on return, a larger output buffer needs
-  /// to be supplied.
-  virtual Result<DecompressResult> Decompress(
-      int64_t input_len,
+  /// If need_more_output is true on return, a larger output buffer needs to be
+  /// supplied.
+  virtual Result<DecompressResult> decompress(
+      int64_t inputLen,
       const uint8_t* input,
-      int64_t output_len,
+      int64_t outputLen,
       uint8_t* output) = 0;
 
   /// \brief Return whether the compressed stream is finished.
   ///
-  /// This is a heuristic.  If true is returned, then it is guaranteed
-  /// that the stream is finished.  If false is returned, however, it may
-  /// simply be that the underlying library isn't able to provide the
-  /// information.
-  virtual bool IsFinished() = 0;
+  /// This is a heuristic. If true is returned, then it is guaranteed that the
+  /// stream is finished. If false is returned, however, it may simply be that
+  /// the underlying library isn't able to provide the information.
+  virtual bool isFinished() = 0;
 
   /// \brief Reinitialize decompressor, making it ready for a new compressed
   /// stream.
-  virtual Status Reset() = 0;
+  virtual Status reset() = 0;
 
   // XXX add methods for buffer size heuristics?
 };
 
-/// \brief Compression codec options
+/// \brief Compression codec options.
 class ARROW_EXPORT CodecOptions {
  public:
-  explicit CodecOptions(int compression_level = kUseDefaultCompressionLevel)
-      : compression_level(compression_level) {}
+  explicit CodecOptions(int compressionLevel = kUseDefaultCompressionLevel)
+      : compressionLevel(compressionLevel) {}
 
   virtual ~CodecOptions() = default;
 
-  int compression_level;
+  int compressionLevel;
 };
 
-// ----------------------------------------------------------------------
-// GZip codec options implementation
+// ----------------------------------------------------------------------.
+// GZip codec options implementation.
 
 enum class GZipFormat {
   ZLIB,
@@ -160,123 +158,124 @@ enum class GZipFormat {
 
 class ARROW_EXPORT GZipCodecOptions : public CodecOptions {
  public:
-  GZipFormat gzip_format = GZipFormat::GZIP;
-  std::optional<int> window_bits;
+  GZipFormat gzipFormat = GZipFormat::GZIP;
+  std::optional<int> windowBits;
 };
 
-// ----------------------------------------------------------------------
-// brotli codec options implementation
+// ----------------------------------------------------------------------.
+// Brotli codec options implementation.
 
 class ARROW_EXPORT BrotliCodecOptions : public CodecOptions {
  public:
-  std::optional<int> window_bits;
+  std::optional<int> windowBits;
 };
 
-/// \brief Compression codec
+/// \brief Compression codec.
 class ARROW_EXPORT Codec {
  public:
   virtual ~Codec() = default;
 
   /// \brief Return special value to indicate that a codec implementation
-  /// should use its default compression level
-  static int UseDefaultCompressionLevel();
+  /// should use its default compression level.
+  static int useDefaultCompressionLevel();
 
-  /// \brief Return a string name for compression type
-  static const std::string& GetCodecAsString(Compression::type t);
+  /// \brief Return a string name for compression type.
+  static const std::string& getCodecAsString(Compression::type t);
 
-  /// \brief Return compression type for name (all lower case)
-  static Result<Compression::type> GetCompressionType(const std::string& name);
+  /// \brief Return compression type for name (all lower case).
+  static Result<Compression::type> getCompressionType(const std::string& name);
 
-  /// \brief Create a codec for the given compression algorithm with
-  /// CodecOptions
-  static Result<std::unique_ptr<Codec>> Create(
+  /// \brief Create a codec for the given compression algorithm with codec
+  /// options.
+  static Result<std::unique_ptr<Codec>> create(
       Compression::type codec,
-      const CodecOptions& codec_options = CodecOptions{});
+      const CodecOptions& codecOptions = CodecOptions{});
 
-  /// \brief Create a codec for the given compression algorithm
-  static Result<std::unique_ptr<Codec>> Create(
+  /// \brief Create a codec for the given compression algorithm.
+  static Result<std::unique_ptr<Codec>> create(
       Compression::type codec,
-      int compression_level);
+      int compressionLevel);
 
-  /// \brief Return true if support for indicated codec has been enabled
-  static bool IsAvailable(Compression::type codec);
+  /// \brief Return true if support for indicated codec has been enabled.
+  static bool isAvailable(Compression::type codec);
 
-  /// \brief Return true if indicated codec supports setting a compression level
-  static bool SupportsCompressionLevel(Compression::type codec);
+  /// \brief Return true if indicated codec supports setting a compression
+  /// level.
+  static bool supportsCompressionLevel(Compression::type codec);
 
-  /// \brief Return the smallest supported compression level for the codec
-  /// Note: This function creates a temporary Codec instance
-  static Result<int> MinimumCompressionLevel(Compression::type codec);
+  /// \brief Return the smallest supported compression level for the codec.
+  /// Note: This function creates a temporary Codec instance.
+  static Result<int> minimumCompressionLevel(Compression::type codec);
 
-  /// \brief Return the largest supported compression level for the codec
-  /// Note: This function creates a temporary Codec instance
-  static Result<int> MaximumCompressionLevel(Compression::type codec);
+  /// \brief Return the largest supported compression level for the codec.
+  /// Note: This function creates a temporary Codec instance.
+  static Result<int> maximumCompressionLevel(Compression::type codec);
 
-  /// \brief Return the default compression level
-  /// Note: This function creates a temporary Codec instance
-  static Result<int> DefaultCompressionLevel(Compression::type codec);
+  /// \brief Return the default compression level.
+  /// Note: This function creates a temporary Codec instance.
+  static Result<int> defaultCompressionLevel(Compression::type codec);
 
-  /// \brief Return the smallest supported compression level
-  virtual int minimum_compression_level() const = 0;
+  /// \brief Return the smallest supported compression level.
+  virtual int minimumCompressionLevel() const = 0;
 
-  /// \brief Return the largest supported compression level
-  virtual int maximum_compression_level() const = 0;
+  /// \brief Return the largest supported compression level.
+  virtual int maximumCompressionLevel() const = 0;
 
-  /// \brief Return the default compression level
-  virtual int default_compression_level() const = 0;
+  /// \brief Return the default compression level.
+  virtual int defaultCompressionLevel() const = 0;
 
-  /// \brief One-shot decompression function
+  /// \brief One-shot decompression function.
   ///
-  /// output_buffer_len must be correct and therefore be obtained in advance.
+  /// Output_buffer_len must be correct and therefore be obtained in advance.
   /// The actual decompressed length is returned.
   ///
   /// \note One-shot decompression is not always compatible with streaming
   /// compression.  Depending on the codec (e.g. LZ4), different formats may
   /// be used.
-  virtual Result<int64_t> Decompress(
-      int64_t input_len,
+  virtual Result<int64_t> decompress(
+      int64_t inputLen,
       const uint8_t* input,
-      int64_t output_buffer_len,
-      uint8_t* output_buffer) = 0;
+      int64_t outputBufferLen,
+      uint8_t* outputBuffer) = 0;
 
-  /// \brief One-shot compression function
+  /// \brief One-shot compression function.
   ///
-  /// output_buffer_len must first have been computed using MaxCompressedLen().
+  /// Output_buffer_len must first have been computed using MaxCompressedLen().
   /// The actual compressed length is returned.
   ///
   /// \note One-shot compression is not always compatible with streaming
-  /// decompression.  Depending on the codec (e.g. LZ4), different formats may
-  /// be used.
-  virtual Result<int64_t> Compress(
-      int64_t input_len,
+  /// decompression. Depending on the codec (e.g. LZ4), different formats may be
+  /// used.
+  virtual Result<int64_t> compress(
+      int64_t inputLen,
       const uint8_t* input,
-      int64_t output_buffer_len,
-      uint8_t* output_buffer) = 0;
+      int64_t outputBufferLen,
+      uint8_t* outputBuffer) = 0;
 
-  virtual int64_t MaxCompressedLen(int64_t input_len, const uint8_t* input) = 0;
+  virtual int64_t maxCompressedLen(int64_t inputLen, const uint8_t* input) = 0;
 
-  /// \brief Create a streaming compressor instance
-  virtual Result<std::shared_ptr<Compressor>> MakeCompressor() = 0;
+  /// \brief Create a streaming compressor instance.
+  virtual Result<std::shared_ptr<Compressor>> makeCompressor() = 0;
 
-  /// \brief Create a streaming compressor instance
-  virtual Result<std::shared_ptr<Decompressor>> MakeDecompressor() = 0;
+  /// \brief Create a streaming compressor instance.
+  virtual Result<std::shared_ptr<Decompressor>> makeDecompressor() = 0;
 
-  /// \brief This Codec's compression type
-  virtual Compression::type compression_type() const = 0;
+  /// \brief This Codec's compression type.
+  virtual Compression::type compressionType() const = 0;
 
-  /// \brief The name of this Codec's compression type
+  /// \brief The name of this Codec's compression type.
   const std::string& name() const {
-    return GetCodecAsString(compression_type());
+    return getCodecAsString(compressionType());
   }
 
-  /// \brief This Codec's compression level, if applicable
-  virtual int compression_level() const {
-    return UseDefaultCompressionLevel();
+  /// \brief This Codec's compression level, if applicable.
+  virtual int compressionLevel() const {
+    return useDefaultCompressionLevel();
   }
 
  private:
   /// \brief Initializes the codec's resources.
-  virtual Status Init();
+  virtual Status init();
 };
 
 } // namespace facebook::velox::parquet::arrow::util
diff --git a/velox/dwio/parquet/writer/arrow/util/CompressionInternal.h b/velox/dwio/parquet/writer/arrow/util/CompressionInternal.h
index 53ddd6e20d0..d43ad595642 100644
--- a/velox/dwio/parquet/writer/arrow/util/CompressionInternal.h
+++ b/velox/dwio/parquet/writer/arrow/util/CompressionInternal.h
@@ -24,8 +24,8 @@
 
 namespace facebook::velox::parquet::arrow::util {
 
-// ----------------------------------------------------------------------
-// Internal Codec factories
+// ----------------------------------------------------------------------.
+// Internal Codec factories.
 
 namespace internal {
 
@@ -34,49 +34,49 @@ namespace internal {
 constexpr int kBrotliDefaultCompressionLevel = 8;
 
 // Brotli codec.
-std::unique_ptr<Codec> MakeBrotliCodec(
-    int compression_level = kBrotliDefaultCompressionLevel,
-    std::optional<int> window_bits = std::nullopt);
+std::unique_ptr<Codec> makeBrotliCodec(
+    int compressionLevel = kBrotliDefaultCompressionLevel,
+    std::optional<int> windowBits = std::nullopt);
 
 // BZ2 codec.
 constexpr int kBZ2DefaultCompressionLevel = 9;
 
-std::unique_ptr<Codec> MakeBZ2Codec(
-    int compression_level = kBZ2DefaultCompressionLevel);
+std::unique_ptr<Codec> makeBZ2Codec(
+    int compressionLevel = kBZ2DefaultCompressionLevel);
 
-// GZip
+// GZip.
 constexpr int kGZipDefaultCompressionLevel = 9;
 
-std::unique_ptr<Codec> MakeGZipCodec(
-    int compression_level = kGZipDefaultCompressionLevel,
+std::unique_ptr<Codec> makeGZipCodec(
+    int compressionLevel = kGZipDefaultCompressionLevel,
     GZipFormat format = GZipFormat::GZIP,
-    std::optional<int> window_bits = std::nullopt);
+    std::optional<int> windowBits = std::nullopt);
 
-// Snappy
-std::unique_ptr<Codec> MakeSnappyCodec();
+// Snappy.
+std::unique_ptr<Codec> makeSnappyCodec();
 
-// Lz4 Codecs
+// Lz4 Codecs.
 constexpr int kLz4DefaultCompressionLevel = 1;
 
 // Lz4 frame format codec.
 
-std::unique_ptr<Codec> MakeLz4FrameCodec(
-    int compression_level = kLz4DefaultCompressionLevel);
+std::unique_ptr<Codec> makeLz4FrameCodec(
+    int compressionLevel = kLz4DefaultCompressionLevel);
 
 // Lz4 "raw" format codec.
-std::unique_ptr<Codec> MakeLz4RawCodec(
-    int compression_level = kLz4DefaultCompressionLevel);
+std::unique_ptr<Codec> makeLz4RawCodec(
+    int compressionLevel = kLz4DefaultCompressionLevel);
 
 // Lz4 "Hadoop" format codec (== Lz4 raw codec prefixed with lengths header)
-std::unique_ptr<Codec> MakeLz4HadoopRawCodec();
+std::unique_ptr<Codec> makeLz4HadoopRawCodec();
 
 // ZSTD codec.
 
-// XXX level = 1 probably doesn't compress very much
+// XXX level = 1 probably doesn't compress very much.
 constexpr int kZSTDDefaultCompressionLevel = 1;
 
-std::unique_ptr<Codec> MakeZSTDCodec(
-    int compression_level = kZSTDDefaultCompressionLevel);
+std::unique_ptr<Codec> makeZSTDCodec(
+    int compressionLevel = kZSTDDefaultCompressionLevel);
 
 } // namespace internal
 } // namespace facebook::velox::parquet::arrow::util
diff --git a/velox/dwio/parquet/writer/arrow/util/CompressionLZ4.cpp b/velox/dwio/parquet/writer/arrow/util/CompressionLZ4.cpp
index 399fe58b1b0..0b0aeb09d36 100644
--- a/velox/dwio/parquet/writer/arrow/util/CompressionLZ4.cpp
+++ b/velox/dwio/parquet/writer/arrow/util/CompressionLZ4.cpp
@@ -39,25 +39,25 @@ namespace {
 
 constexpr int kLz4MinCompressionLevel = 1;
 
-static Status LZ4Error(LZ4F_errorCode_t ret, const char* prefix_msg) {
-  return Status::IOError(prefix_msg, LZ4F_getErrorName(ret));
+static Status lZ4Error(LZ4F_errorCode_t ret, const char* prefixMsg) {
+  return Status::IOError(prefixMsg, LZ4F_getErrorName(ret));
 }
 
-static LZ4F_preferences_t DefaultPreferences() {
+static LZ4F_preferences_t defaultPreferences() {
   LZ4F_preferences_t prefs;
   memset(&prefs, 0, sizeof(prefs));
   return prefs;
 }
 
-static LZ4F_preferences_t PreferencesWithCompressionLevel(
-    int compression_level) {
-  LZ4F_preferences_t prefs = DefaultPreferences();
-  prefs.compressionLevel = compression_level;
+static LZ4F_preferences_t preferencesWithCompressionLevel(
+    int compressionLevel) {
+  LZ4F_preferences_t prefs = defaultPreferences();
+  prefs.compressionLevel = compressionLevel;
   return prefs;
 }
 
-// ----------------------------------------------------------------------
-// Lz4 frame decompressor implementation
+// ----------------------------------------------------------------------.
+// Lz4 frame Decompressor implementation.
 
 class LZ4Decompressor : public Decompressor {
  public:
@@ -69,21 +69,21 @@ class LZ4Decompressor : public Decompressor {
     }
   }
 
-  Status Init() {
+  Status init() {
     LZ4F_errorCode_t ret;
     finished_ = false;
 
     ret = LZ4F_createDecompressionContext(&ctx_, LZ4F_VERSION);
     if (LZ4F_isError(ret)) {
-      return LZ4Error(ret, "LZ4 init failed: ");
+      return lZ4Error(ret, "LZ4 init failed: ");
     } else {
       return Status::OK();
     }
   }
 
-  Status Reset() override {
+  Status reset() override {
 #if defined(LZ4_VERSION_NUMBER) && LZ4_VERSION_NUMBER >= 10800
-    // LZ4F_resetDecompressionContext appeared in 1.8.0
+    // LZ4F_resetDecompressionContext appeared in 1.8.0.
     VELOX_DCHECK_NOT_NULL(ctx_);
     LZ4F_resetDecompressionContext(ctx_);
     finished_ = false;
@@ -92,34 +92,34 @@ class LZ4Decompressor : public Decompressor {
     if (ctx_ != nullptr) {
       ARROW_UNUSED(LZ4F_freeDecompressionContext(ctx_));
     }
-    return Init();
+    return init();
 #endif
   }
 
-  Result<DecompressResult> Decompress(
-      int64_t input_len,
+  Result<DecompressResult> decompress(
+      int64_t inputLen,
       const uint8_t* input,
-      int64_t output_len,
+      int64_t outputLen,
       uint8_t* output) override {
     auto src = input;
     auto dst = output;
-    auto src_size = static_cast<size_t>(input_len);
-    auto dst_capacity = static_cast<size_t>(output_len);
+    auto srcSize = static_cast<size_t>(inputLen);
+    auto dstCapacity = static_cast<size_t>(outputLen);
     size_t ret;
 
     ret = LZ4F_decompress(
-        ctx_, dst, &dst_capacity, src, &src_size, nullptr /* options */);
+        ctx_, dst, &dstCapacity, src, &srcSize, nullptr /* options */);
     if (LZ4F_isError(ret)) {
-      return LZ4Error(ret, "LZ4 decompress failed: ");
+      return lZ4Error(ret, "LZ4 decompress failed: ");
     }
     finished_ = (ret == 0);
     return DecompressResult{
-        static_cast<int64_t>(src_size),
-        static_cast<int64_t>(dst_capacity),
-        (src_size == 0 && dst_capacity == 0)};
+        static_cast<int64_t>(srcSize),
+        static_cast<int64_t>(dstCapacity),
+        (srcSize == 0 && dstCapacity == 0)};
   }
 
-  bool IsFinished() override {
+  bool isFinished() override {
     return finished_;
   }
 
@@ -128,13 +128,13 @@ class LZ4Decompressor : public Decompressor {
   bool finished_;
 };
 
-// ----------------------------------------------------------------------
-// Lz4 frame compressor implementation
+// ----------------------------------------------------------------------.
+// Lz4 frame compressor implementation.
 
 class LZ4Compressor : public Compressor {
  public:
-  explicit LZ4Compressor(int compression_level)
-      : compression_level_(compression_level) {}
+  explicit LZ4Compressor(int compressionLevel)
+      : compressionLevel_(compressionLevel) {}
 
   ~LZ4Compressor() override {
     if (ctx_ != nullptr) {
@@ -142,482 +142,480 @@ class LZ4Compressor : public Compressor {
     }
   }
 
-  Status Init() {
+  Status init() {
     LZ4F_errorCode_t ret;
-    prefs_ = PreferencesWithCompressionLevel(compression_level_);
-    first_time_ = true;
+    prefs_ = preferencesWithCompressionLevel(compressionLevel_);
+    firstTime_ = true;
 
     ret = LZ4F_createCompressionContext(&ctx_, LZ4F_VERSION);
     if (LZ4F_isError(ret)) {
-      return LZ4Error(ret, "LZ4 init failed: ");
+      return lZ4Error(ret, "LZ4 init failed: ");
     } else {
       return Status::OK();
     }
   }
 
-#define BEGIN_COMPRESS(dst, dst_capacity, output_too_small)     \
-  if (first_time_) {                                            \
-    if (dst_capacity < LZ4F_HEADER_SIZE_MAX) {                  \
-      /* Output too small to write LZ4F header */               \
-      return (output_too_small);                                \
-    }                                                           \
-    ret = LZ4F_compressBegin(ctx_, dst, dst_capacity, &prefs_); \
-    if (LZ4F_isError(ret)) {                                    \
-      return LZ4Error(ret, "LZ4 compress begin failed: ");      \
-    }                                                           \
-    first_time_ = false;                                        \
-    dst += ret;                                                 \
-    dst_capacity -= ret;                                        \
-    bytes_written += static_cast<int64_t>(ret);                 \
-  }
-
-  Result<CompressResult> Compress(
-      int64_t input_len,
+#define BEGIN_COMPRESS(dst, dstCapacity, outputTooSmall)       \
+  if (firstTime_) {                                            \
+    if (dstCapacity < LZ4F_HEADER_SIZE_MAX) {                  \
+      /* Output too small to write LZ4F header */              \
+      return (outputTooSmall);                                 \
+    }                                                          \
+    ret = LZ4F_compressBegin(ctx_, dst, dstCapacity, &prefs_); \
+    if (LZ4F_isError(ret)) {                                   \
+      return lZ4Error(ret, "LZ4 compress begin failed: ");     \
+    }                                                          \
+    firstTime_ = false;                                        \
+    dst += ret;                                                \
+    dstCapacity -= ret;                                        \
+    bytesWritten += static_cast<int64_t>(ret);                 \
+  }
+
+  Result<CompressResult> compress(
+      int64_t inputLen,
       const uint8_t* input,
-      int64_t output_len,
+      int64_t outputLen,
       uint8_t* output) override {
     auto src = input;
     auto dst = output;
-    auto src_size = static_cast<size_t>(input_len);
-    auto dst_capacity = static_cast<size_t>(output_len);
+    auto srcSize = static_cast<size_t>(inputLen);
+    auto dstCapacity = static_cast<size_t>(outputLen);
     size_t ret;
-    int64_t bytes_written = 0;
+    int64_t bytesWritten = 0;
 
-    BEGIN_COMPRESS(dst, dst_capacity, (CompressResult{0, 0}));
+    BEGIN_COMPRESS(dst, dstCapacity, (CompressResult{0, 0}));
 
-    if (dst_capacity < LZ4F_compressBound(src_size, &prefs_)) {
-      // Output too small to compress into
-      return CompressResult{0, bytes_written};
+    if (dstCapacity < LZ4F_compressBound(srcSize, &prefs_)) {
+      // Output too small to compress into.
+      return CompressResult{0, bytesWritten};
     }
     ret = LZ4F_compressUpdate(
-        ctx_, dst, dst_capacity, src, src_size, nullptr /* options */);
+        ctx_, dst, dstCapacity, src, srcSize, nullptr /* options */);
     if (LZ4F_isError(ret)) {
-      return LZ4Error(ret, "LZ4 compress update failed: ");
+      return lZ4Error(ret, "LZ4 compress update failed: ");
     }
-    bytes_written += static_cast<int64_t>(ret);
-    VELOX_DCHECK_LE(bytes_written, output_len);
-    return CompressResult{input_len, bytes_written};
+    bytesWritten += static_cast<int64_t>(ret);
+    VELOX_DCHECK_LE(bytesWritten, outputLen);
+    return CompressResult{inputLen, bytesWritten};
   }
 
-  Result<FlushResult> Flush(int64_t output_len, uint8_t* output) override {
+  Result<FlushResult> flush(int64_t outputLen, uint8_t* output) override {
     auto dst = output;
-    auto dst_capacity = static_cast<size_t>(output_len);
+    auto dstCapacity = static_cast<size_t>(outputLen);
     size_t ret;
-    int64_t bytes_written = 0;
+    int64_t bytesWritten = 0;
 
-    BEGIN_COMPRESS(dst, dst_capacity, (FlushResult{0, true}));
+    BEGIN_COMPRESS(dst, dstCapacity, (FlushResult{0, true}));
 
-    if (dst_capacity < LZ4F_compressBound(0, &prefs_)) {
-      // Output too small to flush into
-      return FlushResult{bytes_written, true};
+    if (dstCapacity < LZ4F_compressBound(0, &prefs_)) {
+      // Output too small to flush into.
+      return FlushResult{bytesWritten, true};
     }
 
-    ret = LZ4F_flush(ctx_, dst, dst_capacity, nullptr /* options */);
+    ret = LZ4F_flush(ctx_, dst, dstCapacity, nullptr /* options */);
     if (LZ4F_isError(ret)) {
-      return LZ4Error(ret, "LZ4 flush failed: ");
+      return lZ4Error(ret, "LZ4 flush failed: ");
     }
-    bytes_written += static_cast<int64_t>(ret);
-    VELOX_DCHECK_LE(bytes_written, output_len);
-    return FlushResult{bytes_written, false};
+    bytesWritten += static_cast<int64_t>(ret);
+    VELOX_DCHECK_LE(bytesWritten, outputLen);
+    return FlushResult{bytesWritten, false};
   }
 
-  Result<EndResult> End(int64_t output_len, uint8_t* output) override {
+  Result<EndResult> end(int64_t outputLen, uint8_t* output) override {
     auto dst = output;
-    auto dst_capacity = static_cast<size_t>(output_len);
+    auto dstCapacity = static_cast<size_t>(outputLen);
     size_t ret;
-    int64_t bytes_written = 0;
+    int64_t bytesWritten = 0;
 
-    BEGIN_COMPRESS(dst, dst_capacity, (EndResult{0, true}));
+    BEGIN_COMPRESS(dst, dstCapacity, (EndResult{0, true}));
 
-    if (dst_capacity < LZ4F_compressBound(0, &prefs_)) {
-      // Output too small to end frame into
-      return EndResult{bytes_written, true};
+    if (dstCapacity < LZ4F_compressBound(0, &prefs_)) {
+      // Output too small to end frame into.
+      return EndResult{bytesWritten, true};
     }
 
-    ret = LZ4F_compressEnd(ctx_, dst, dst_capacity, nullptr /* options */);
+    ret = LZ4F_compressEnd(ctx_, dst, dstCapacity, nullptr /* options */);
     if (LZ4F_isError(ret)) {
-      return LZ4Error(ret, "LZ4 end failed: ");
+      return lZ4Error(ret, "LZ4 end failed: ");
     }
-    bytes_written += static_cast<int64_t>(ret);
-    VELOX_DCHECK_LE(bytes_written, output_len);
-    return EndResult{bytes_written, false};
+    bytesWritten += static_cast<int64_t>(ret);
+    VELOX_DCHECK_LE(bytesWritten, outputLen);
+    return EndResult{bytesWritten, false};
   }
 
 #undef BEGIN_COMPRESS
 
  protected:
-  int compression_level_;
+  int compressionLevel_;
   LZ4F_compressionContext_t ctx_ = nullptr;
   LZ4F_preferences_t prefs_;
-  bool first_time_;
+  bool firstTime_;
 };
 
-// ----------------------------------------------------------------------
-// Lz4 frame codec implementation
+// ----------------------------------------------------------------------.
+// Lz4 frame codec implementation.
 
 class Lz4FrameCodec : public Codec {
  public:
-  explicit Lz4FrameCodec(int compression_level)
-      : compression_level_(
-            compression_level == kUseDefaultCompressionLevel
+  explicit Lz4FrameCodec(int compressionLevel)
+      : compressionLevel_(
+            compressionLevel == kUseDefaultCompressionLevel
                 ? kLz4DefaultCompressionLevel
-                : compression_level),
-        prefs_(PreferencesWithCompressionLevel(compression_level_)) {}
+                : compressionLevel),
+        prefs_(preferencesWithCompressionLevel(compressionLevel_)) {}
 
-  int64_t MaxCompressedLen(
-      int64_t input_len,
+  int64_t maxCompressedLen(
+      int64_t inputLen,
       const uint8_t* ARROW_ARG_UNUSED(input)) override {
     return static_cast<int64_t>(
-        LZ4F_compressFrameBound(static_cast<size_t>(input_len), &prefs_));
+        LZ4F_compressFrameBound(static_cast<size_t>(inputLen), &prefs_));
   }
 
-  Result<int64_t> Compress(
-      int64_t input_len,
+  Result<int64_t> compress(
+      int64_t inputLen,
       const uint8_t* input,
-      int64_t output_buffer_len,
-      uint8_t* output_buffer) override {
-    auto output_len = LZ4F_compressFrame(
-        output_buffer,
-        static_cast<size_t>(output_buffer_len),
+      int64_t outputBufferLen,
+      uint8_t* outputBuffer) override {
+    auto outputLen = LZ4F_compressFrame(
+        outputBuffer,
+        static_cast<size_t>(outputBufferLen),
         input,
-        static_cast<size_t>(input_len),
+        static_cast<size_t>(inputLen),
         &prefs_);
-    if (LZ4F_isError(output_len)) {
-      return LZ4Error(output_len, "Lz4 compression failure: ");
+    if (LZ4F_isError(outputLen)) {
+      return lZ4Error(outputLen, "Lz4 compression failure: ");
     }
-    return static_cast<int64_t>(output_len);
+    return static_cast<int64_t>(outputLen);
   }
 
-  Result<int64_t> Decompress(
-      int64_t input_len,
+  Result<int64_t> decompress(
+      int64_t inputLen,
       const uint8_t* input,
-      int64_t output_buffer_len,
-      uint8_t* output_buffer) override {
-    ARROW_ASSIGN_OR_RAISE(auto decomp, MakeDecompressor());
+      int64_t outputBufferLen,
+      uint8_t* outputBuffer) override {
+    ARROW_ASSIGN_OR_RAISE(auto decomp, makeDecompressor());
 
-    int64_t total_bytes_written = 0;
-    while (!decomp->IsFinished() && input_len != 0) {
+    int64_t totalBytesWritten = 0;
+    while (!decomp->isFinished() && inputLen != 0) {
       ARROW_ASSIGN_OR_RAISE(
           auto res,
-          decomp->Decompress(
-              input_len, input, output_buffer_len, output_buffer));
-      input += res.bytes_read;
-      input_len -= res.bytes_read;
-      output_buffer += res.bytes_written;
-      output_buffer_len -= res.bytes_written;
-      total_bytes_written += res.bytes_written;
-      if (res.need_more_output) {
+          decomp->decompress(inputLen, input, outputBufferLen, outputBuffer));
+      input += res.bytesRead;
+      inputLen -= res.bytesRead;
+      outputBuffer += res.bytesWritten;
+      outputBufferLen -= res.bytesWritten;
+      totalBytesWritten += res.bytesWritten;
+      if (res.needMoreOutput) {
         return Status::IOError("Lz4 decompression buffer too small");
       }
     }
-    if (!decomp->IsFinished()) {
+    if (!decomp->isFinished()) {
       return Status::IOError(
           "Lz4 compressed input contains less than one frame");
     }
-    if (input_len != 0) {
+    if (inputLen != 0) {
       return Status::IOError(
           "Lz4 compressed input contains more than one frame");
     }
-    return total_bytes_written;
+    return totalBytesWritten;
   }
 
-  Result<std::shared_ptr<Compressor>> MakeCompressor() override {
-    auto ptr = std::make_shared<LZ4Compressor>(compression_level_);
-    RETURN_NOT_OK(ptr->Init());
+  Result<std::shared_ptr<Compressor>> makeCompressor() override {
+    auto ptr = std::make_shared<LZ4Compressor>(compressionLevel_);
+    RETURN_NOT_OK(ptr->init());
     return ptr;
   }
 
-  Result<std::shared_ptr<Decompressor>> MakeDecompressor() override {
+  Result<std::shared_ptr<Decompressor>> makeDecompressor() override {
     auto ptr = std::make_shared<LZ4Decompressor>();
-    RETURN_NOT_OK(ptr->Init());
+    RETURN_NOT_OK(ptr->init());
     return ptr;
   }
 
-  Compression::type compression_type() const override {
+  Compression::type compressionType() const override {
     return Compression::LZ4_FRAME;
   }
-  int minimum_compression_level() const override {
+  int minimumCompressionLevel() const override {
     return kLz4MinCompressionLevel;
   }
 #if (defined(LZ4_VERSION_NUMBER) && LZ4_VERSION_NUMBER < 10800)
-  int maximum_compression_level() const override {
+  int maximumCompressionLevel() const override {
     return 12;
   }
 #else
-  int maximum_compression_level() const override {
+  int maximumCompressionLevel() const override {
     return LZ4F_compressionLevel_max();
   }
 #endif
-  int default_compression_level() const override {
+  int defaultCompressionLevel() const override {
     return kLz4DefaultCompressionLevel;
   }
 
-  int compression_level() const override {
-    return compression_level_;
+  int compressionLevel() const override {
+    return compressionLevel_;
   }
 
  protected:
-  const int compression_level_;
+  const int compressionLevel_;
   const LZ4F_preferences_t prefs_;
 };
 
-// ----------------------------------------------------------------------
-// Lz4 "raw" codec implementation
+// ----------------------------------------------------------------------.
+// Lz4 "raw" codec implementation.
 
 class Lz4Codec : public Codec {
  public:
-  explicit Lz4Codec(int compression_level)
-      : compression_level_(
-            compression_level == kUseDefaultCompressionLevel
+  explicit Lz4Codec(int compressionLevel)
+      : compressionLevel_(
+            compressionLevel == kUseDefaultCompressionLevel
                 ? kLz4DefaultCompressionLevel
-                : compression_level) {}
+                : compressionLevel) {}
 
-  Result<int64_t> Decompress(
-      int64_t input_len,
+  Result<int64_t> decompress(
+      int64_t inputLen,
       const uint8_t* input,
-      int64_t output_buffer_len,
-      uint8_t* output_buffer) override {
-    int64_t decompressed_size = LZ4_decompress_safe(
+      int64_t outputBufferLen,
+      uint8_t* outputBuffer) override {
+    int64_t decompressedSize = LZ4_decompress_safe(
         reinterpret_cast<const char*>(input),
-        reinterpret_cast<char*>(output_buffer),
-        static_cast<int>(input_len),
-        static_cast<int>(output_buffer_len));
-    if (decompressed_size < 0) {
+        reinterpret_cast<char*>(outputBuffer),
+        static_cast<int>(inputLen),
+        static_cast<int>(outputBufferLen));
+    if (decompressedSize < 0) {
       return Status::IOError("Corrupt Lz4 compressed data.");
     }
-    return decompressed_size;
+    return decompressedSize;
   }
 
-  int64_t MaxCompressedLen(
-      int64_t input_len,
+  int64_t maxCompressedLen(
+      int64_t inputLen,
       const uint8_t* ARROW_ARG_UNUSED(input)) override {
-    return LZ4_compressBound(static_cast<int>(input_len));
+    return LZ4_compressBound(static_cast<int>(inputLen));
   }
 
-  Result<int64_t> Compress(
-      int64_t input_len,
+  Result<int64_t> compress(
+      int64_t inputLen,
       const uint8_t* input,
-      int64_t output_buffer_len,
-      uint8_t* output_buffer) override {
-    int64_t output_len;
+      int64_t outputBufferLen,
+      uint8_t* outputBuffer) override {
+    int64_t outputLen;
 #ifdef LZ4HC_CLEVEL_MIN
-    constexpr int min_hc_clevel = LZ4HC_CLEVEL_MIN;
+    constexpr int minHcClevel = LZ4HC_CLEVEL_MIN;
 #else // For older versions of the lz4 library
-    constexpr int min_hc_clevel = 3;
+    constexpr int minHcClevel = 3;
 #endif
-    if (compression_level_ < min_hc_clevel) {
-      output_len = LZ4_compress_default(
+    if (compressionLevel_ < minHcClevel) {
+      outputLen = LZ4_compress_default(
           reinterpret_cast<const char*>(input),
-          reinterpret_cast<char*>(output_buffer),
-          static_cast<int>(input_len),
-          static_cast<int>(output_buffer_len));
+          reinterpret_cast<char*>(outputBuffer),
+          static_cast<int>(inputLen),
+          static_cast<int>(outputBufferLen));
     } else {
-      output_len = LZ4_compress_HC(
+      outputLen = LZ4_compress_HC(
           reinterpret_cast<const char*>(input),
-          reinterpret_cast<char*>(output_buffer),
-          static_cast<int>(input_len),
-          static_cast<int>(output_buffer_len),
-          compression_level_);
+          reinterpret_cast<char*>(outputBuffer),
+          static_cast<int>(inputLen),
+          static_cast<int>(outputBufferLen),
+          compressionLevel_);
     }
-    if (output_len == 0) {
+    if (outputLen == 0) {
       return Status::IOError("Lz4 compression failure.");
     }
-    return output_len;
+    return outputLen;
   }
 
-  Result<std::shared_ptr<Compressor>> MakeCompressor() override {
+  Result<std::shared_ptr<Compressor>> makeCompressor() override {
     return Status::NotImplemented(
         "Streaming compression unsupported with LZ4 raw format. "
         "Try using LZ4 frame format instead.");
   }
 
-  Result<std::shared_ptr<Decompressor>> MakeDecompressor() override {
+  Result<std::shared_ptr<Decompressor>> makeDecompressor() override {
     return Status::NotImplemented(
         "Streaming decompression unsupported with LZ4 raw format. "
         "Try using LZ4 frame format instead.");
   }
 
-  Compression::type compression_type() const override {
+  Compression::type compressionType() const override {
     return Compression::LZ4;
   }
-  int minimum_compression_level() const override {
+  int minimumCompressionLevel() const override {
     return kLz4MinCompressionLevel;
   }
 #if (defined(LZ4_VERSION_NUMBER) && LZ4_VERSION_NUMBER < 10800)
-  int maximum_compression_level() const override {
+  int maximumCompressionLevel() const override {
     return 12;
   }
 #else
-  int maximum_compression_level() const override {
+  int maximumCompressionLevel() const override {
     return LZ4F_compressionLevel_max();
   }
 #endif
-  int default_compression_level() const override {
+  int defaultCompressionLevel() const override {
     return kLz4DefaultCompressionLevel;
   }
 
  protected:
-  int compression_level_;
+  int compressionLevel_;
 };
 
-// ----------------------------------------------------------------------
-// Lz4 Hadoop "raw" codec implementation
+// ----------------------------------------------------------------------.
+// Lz4 Hadoop "raw" codec implementation.
 
 class Lz4HadoopCodec : public Lz4Codec {
  public:
   Lz4HadoopCodec() : Lz4Codec(kUseDefaultCompressionLevel) {}
 
-  Result<int64_t> Decompress(
-      int64_t input_len,
+  Result<int64_t> decompress(
+      int64_t inputLen,
       const uint8_t* input,
-      int64_t output_buffer_len,
-      uint8_t* output_buffer) override {
-    const int64_t decompressed_size =
-        TryDecompressHadoop(input_len, input, output_buffer_len, output_buffer);
-    if (decompressed_size != kNotHadoop) {
-      return decompressed_size;
+      int64_t outputBufferLen,
+      uint8_t* outputBuffer) override {
+    const int64_t decompressedSize =
+        tryDecompressHadoop(inputLen, input, outputBufferLen, outputBuffer);
+    if (decompressedSize != kNotHadoop) {
+      return decompressedSize;
     }
-    // Fall back on raw LZ4 codec (for files produces by earlier versions of
+    // Fall back on raw LZ4 codec (for files produces by earlier versions of.
     // Parquet C++)
-    return Lz4Codec::Decompress(
-        input_len, input, output_buffer_len, output_buffer);
+    return Lz4Codec::decompress(inputLen, input, outputBufferLen, outputBuffer);
   }
 
-  int64_t MaxCompressedLen(
-      int64_t input_len,
+  int64_t maxCompressedLen(
+      int64_t inputLen,
       const uint8_t* ARROW_ARG_UNUSED(input)) override {
-    return kPrefixLength + Lz4Codec::MaxCompressedLen(input_len, nullptr);
+    return kPrefixLength + Lz4Codec::maxCompressedLen(inputLen, nullptr);
   }
 
-  Result<int64_t> Compress(
-      int64_t input_len,
+  Result<int64_t> compress(
+      int64_t inputLen,
       const uint8_t* input,
-      int64_t output_buffer_len,
-      uint8_t* output_buffer) override {
-    if (output_buffer_len < kPrefixLength) {
+      int64_t outputBufferLen,
+      uint8_t* outputBuffer) override {
+    if (outputBufferLen < kPrefixLength) {
       return Status::Invalid(
           "Output buffer too small for Lz4HadoopCodec compression");
     }
 
     ARROW_ASSIGN_OR_RAISE(
-        int64_t output_len,
-        Lz4Codec::Compress(
-            input_len,
+        int64_t outputLen,
+        Lz4Codec::compress(
+            inputLen,
             input,
-            output_buffer_len - kPrefixLength,
-            output_buffer + kPrefixLength));
+            outputBufferLen - kPrefixLength,
+            outputBuffer + kPrefixLength));
 
-    // Prepend decompressed size in bytes and compressed size in bytes
-    // to be compatible with Hadoop Lz4Codec
-    const uint32_t decompressed_size =
-        bit_util::ToBigEndian(static_cast<uint32_t>(input_len));
-    const uint32_t compressed_size =
-        bit_util::ToBigEndian(static_cast<uint32_t>(output_len));
-    ::arrow::util::SafeStore(output_buffer, decompressed_size);
-    ::arrow::util::SafeStore(output_buffer + sizeof(uint32_t), compressed_size);
+    // Prepend decompressed size in bytes and compressed size in bytes.
+    // To be compatible with Hadoop Lz4Codec.
+    const uint32_t decompressedSize =
+        bit_util::ToBigEndian(static_cast<uint32_t>(inputLen));
+    const uint32_t compressedSize =
+        bit_util::ToBigEndian(static_cast<uint32_t>(outputLen));
+    ::arrow::util::SafeStore(outputBuffer, decompressedSize);
+    ::arrow::util::SafeStore(outputBuffer + sizeof(uint32_t), compressedSize);
 
-    return kPrefixLength + output_len;
+    return kPrefixLength + outputLen;
   }
 
-  Result<std::shared_ptr<Compressor>> MakeCompressor() override {
+  Result<std::shared_ptr<Compressor>> makeCompressor() override {
     return Status::NotImplemented(
         "Streaming compression unsupported with LZ4 Hadoop raw format. "
         "Try using LZ4 frame format instead.");
   }
 
-  Result<std::shared_ptr<Decompressor>> MakeDecompressor() override {
+  Result<std::shared_ptr<Decompressor>> makeDecompressor() override {
     return Status::NotImplemented(
         "Streaming decompression unsupported with LZ4 Hadoop raw format. "
         "Try using LZ4 frame format instead.");
   }
 
-  Compression::type compression_type() const override {
+  Compression::type compressionType() const override {
     return Compression::LZ4_HADOOP;
   }
 
  protected:
-  // Offset starting at which page data can be read/written
+  // Offset starting at which page data can be read/written.
   static const int64_t kPrefixLength = sizeof(uint32_t) * 2;
 
   static const int64_t kNotHadoop = -1;
 
-  int64_t TryDecompressHadoop(
-      int64_t input_len,
+  int64_t tryDecompressHadoop(
+      int64_t inputLen,
       const uint8_t* input,
-      int64_t output_buffer_len,
-      uint8_t* output_buffer) {
+      int64_t outputBufferLen,
+      uint8_t* outputBuffer) {
     // Parquet files written with the Hadoop Lz4Codec use their own framing.
-    // The input buffer can contain an arbitrary number of "frames", each
-    // with the following structure:
-    // - bytes 0..3: big-endian uint32_t representing the frame decompressed
-    // size
-    // - bytes 4..7: big-endian uint32_t representing the frame compressed size
-    // - bytes 8...: frame compressed data
+    // The input buffer can contain an arbitrary number of "frames", each.
+    // With the following structure:
+    // - Bytes 0..3: big-endian uint32_t representing the frame decompressed
+    // size.
+    // - Bytes 4..7: big-endian uint32_t representing the frame compressed size.
+    // - Bytes 8...: frame compressed data.
     //
     // The Hadoop Lz4Codec source code can be found here:
     // https://github.com/apache/hadoop/blob/trunk/hadoop-mapreduce-project/hadoop-mapreduce-client/hadoop-mapreduce-client-nativetask/src/main/native/src/codec/Lz4Codec.cc
-    int64_t total_decompressed_size = 0;
+    int64_t totalDecompressedSize = 0;
 
-    while (input_len >= kPrefixLength) {
-      const uint32_t expected_decompressed_size =
+    while (inputLen >= kPrefixLength) {
+      const uint32_t expectedDecompressedSize =
           bit_util::FromBigEndian(::arrow::util::SafeLoadAs<uint32_t>(input));
-      const uint32_t expected_compressed_size = bit_util::FromBigEndian(
+      const uint32_t expectedCompressedSize = bit_util::FromBigEndian(
           ::arrow::util::SafeLoadAs<uint32_t>(input + sizeof(uint32_t)));
       input += kPrefixLength;
-      input_len -= kPrefixLength;
+      inputLen -= kPrefixLength;
 
-      if (input_len < expected_compressed_size) {
-        // Not enough bytes for Hadoop "frame"
+      if (inputLen < expectedCompressedSize) {
+        // Not enough bytes for Hadoop "frame".
         return kNotHadoop;
       }
-      if (output_buffer_len < expected_decompressed_size) {
-        // Not enough bytes to hold advertised output => probably not Hadoop
+      if (outputBufferLen < expectedDecompressedSize) {
+        // Not enough bytes to hold advertised output => probably not Hadoop.
         return kNotHadoop;
       }
-      // Try decompressing and compare with expected decompressed length
-      auto maybe_decompressed_size = Lz4Codec::Decompress(
-          expected_compressed_size, input, output_buffer_len, output_buffer);
-      if (!maybe_decompressed_size.ok() ||
-          *maybe_decompressed_size != expected_decompressed_size) {
+      // Try decompressing and compare with expected decompressed length.
+      auto maybeDecompressedSize = Lz4Codec::decompress(
+          expectedCompressedSize, input, outputBufferLen, outputBuffer);
+      if (!maybeDecompressedSize.ok() ||
+          *maybeDecompressedSize != expectedDecompressedSize) {
         return kNotHadoop;
       }
-      input += expected_compressed_size;
-      input_len -= expected_compressed_size;
-      output_buffer += expected_decompressed_size;
-      output_buffer_len -= expected_decompressed_size;
-      total_decompressed_size += expected_decompressed_size;
+      input += expectedCompressedSize;
+      inputLen -= expectedCompressedSize;
+      outputBuffer += expectedDecompressedSize;
+      outputBufferLen -= expectedDecompressedSize;
+      totalDecompressedSize += expectedDecompressedSize;
     }
 
-    if (input_len == 0) {
-      return total_decompressed_size;
+    if (inputLen == 0) {
+      return totalDecompressedSize;
     } else {
       return kNotHadoop;
     }
   }
 
-  int minimum_compression_level() const override {
+  int minimumCompressionLevel() const override {
     return kUseDefaultCompressionLevel;
   }
-  int maximum_compression_level() const override {
+  int maximumCompressionLevel() const override {
     return kUseDefaultCompressionLevel;
   }
-  int default_compression_level() const override {
+  int defaultCompressionLevel() const override {
     return kUseDefaultCompressionLevel;
   }
 };
 
 } // namespace
 
-std::unique_ptr<Codec> MakeLz4FrameCodec(int compression_level) {
-  return std::make_unique<Lz4FrameCodec>(compression_level);
+std::unique_ptr<Codec> makeLz4FrameCodec(int compressionLevel) {
+  return std::make_unique<Lz4FrameCodec>(compressionLevel);
 }
 
-std::unique_ptr<Codec> MakeLz4HadoopRawCodec() {
+std::unique_ptr<Codec> makeLz4HadoopRawCodec() {
   return std::make_unique<Lz4HadoopCodec>();
 }
 
-std::unique_ptr<Codec> MakeLz4RawCodec(int compression_level) {
-  return std::make_unique<Lz4Codec>(compression_level);
+std::unique_ptr<Codec> makeLz4RawCodec(int compressionLevel) {
+  return std::make_unique<Lz4Codec>(compressionLevel);
 }
 
 } // namespace facebook::velox::parquet::arrow::util::internal
diff --git a/velox/dwio/parquet/writer/arrow/util/CompressionSnappy.cpp b/velox/dwio/parquet/writer/arrow/util/CompressionSnappy.cpp
index a79a4c95ccd..eaa186cd23c 100644
--- a/velox/dwio/parquet/writer/arrow/util/CompressionSnappy.cpp
+++ b/velox/dwio/parquet/writer/arrow/util/CompressionSnappy.cpp
@@ -37,88 +37,88 @@ namespace {
 
 using ::arrow::Result;
 
-// ----------------------------------------------------------------------
-// Snappy implementation
+// ----------------------------------------------------------------------.
+// Snappy implementation.
 
 class SnappyCodec : public Codec {
  public:
-  Result<int64_t> Decompress(
-      int64_t input_len,
+  Result<int64_t> decompress(
+      int64_t inputLen,
       const uint8_t* input,
-      int64_t output_buffer_len,
-      uint8_t* output_buffer) override {
-    size_t decompressed_size;
+      int64_t outputBufferLen,
+      uint8_t* outputBuffer) override {
+    size_t decompressedSize;
     if (!snappy::GetUncompressedLength(
             reinterpret_cast<const char*>(input),
-            static_cast<size_t>(input_len),
-            &decompressed_size)) {
+            static_cast<size_t>(inputLen),
+            &decompressedSize)) {
       return Status::IOError("Corrupt snappy compressed data.");
     }
-    if (output_buffer_len < static_cast<int64_t>(decompressed_size)) {
+    if (outputBufferLen < static_cast<int64_t>(decompressedSize)) {
       return Status::Invalid(
           "Output buffer size (",
-          output_buffer_len,
+          outputBufferLen,
           ") must be ",
-          decompressed_size,
+          decompressedSize,
           " or larger.");
     }
     if (!snappy::RawUncompress(
             reinterpret_cast<const char*>(input),
-            static_cast<size_t>(input_len),
-            reinterpret_cast<char*>(output_buffer))) {
+            static_cast<size_t>(inputLen),
+            reinterpret_cast<char*>(outputBuffer))) {
       return Status::IOError("Corrupt snappy compressed data.");
     }
-    return static_cast<int64_t>(decompressed_size);
+    return static_cast<int64_t>(decompressedSize);
   }
 
-  int64_t MaxCompressedLen(
-      int64_t input_len,
+  int64_t maxCompressedLen(
+      int64_t inputLen,
       const uint8_t* ARROW_ARG_UNUSED(input)) override {
-    VELOX_DCHECK_GE(input_len, 0);
-    return snappy::MaxCompressedLength(static_cast<size_t>(input_len));
+    VELOX_DCHECK_GE(inputLen, 0);
+    return snappy::MaxCompressedLength(static_cast<size_t>(inputLen));
   }
 
-  Result<int64_t> Compress(
-      int64_t input_len,
+  Result<int64_t> compress(
+      int64_t inputLen,
       const uint8_t* input,
-      int64_t ARROW_ARG_UNUSED(output_buffer_len),
-      uint8_t* output_buffer) override {
-    size_t output_size;
+      int64_t ARROW_ARG_UNUSED(outputBufferLen),
+      uint8_t* outputBuffer) override {
+    size_t outputSize;
     snappy::RawCompress(
         reinterpret_cast<const char*>(input),
-        static_cast<size_t>(input_len),
-        reinterpret_cast<char*>(output_buffer),
-        &output_size);
-    return static_cast<int64_t>(output_size);
+        static_cast<size_t>(inputLen),
+        reinterpret_cast<char*>(outputBuffer),
+        &outputSize);
+    return static_cast<int64_t>(outputSize);
   }
 
-  Result<std::shared_ptr<Compressor>> MakeCompressor() override {
+  Result<std::shared_ptr<Compressor>> makeCompressor() override {
     return Status::NotImplemented(
         "Streaming compression unsupported with Snappy");
   }
 
-  Result<std::shared_ptr<Decompressor>> MakeDecompressor() override {
+  Result<std::shared_ptr<Decompressor>> makeDecompressor() override {
     return Status::NotImplemented(
         "Streaming decompression unsupported with Snappy");
   }
 
-  Compression::type compression_type() const override {
+  Compression::type compressionType() const override {
     return Compression::SNAPPY;
   }
-  int minimum_compression_level() const override {
+  int minimumCompressionLevel() const override {
     return kUseDefaultCompressionLevel;
   }
-  int maximum_compression_level() const override {
+  int maximumCompressionLevel() const override {
     return kUseDefaultCompressionLevel;
   }
-  int default_compression_level() const override {
+  int defaultCompressionLevel() const override {
     return kUseDefaultCompressionLevel;
   }
 };
 
 } // namespace
 
-std::unique_ptr<Codec> MakeSnappyCodec() {
+std::unique_ptr<Codec> makeSnappyCodec() {
   return std::make_unique<SnappyCodec>();
 }
 
diff --git a/velox/dwio/parquet/writer/arrow/util/CompressionZlib.cpp b/velox/dwio/parquet/writer/arrow/util/CompressionZlib.cpp
index 23ab7f25e34..0e5347138e1 100644
--- a/velox/dwio/parquet/writer/arrow/util/CompressionZlib.cpp
+++ b/velox/dwio/parquet/writer/arrow/util/CompressionZlib.cpp
@@ -34,19 +34,19 @@
 namespace facebook::velox::parquet::arrow::util::internal {
 namespace {
 
-// ----------------------------------------------------------------------
-// gzip implementation
+// ----------------------------------------------------------------------.
+// Gzip implementation.
 
-// These are magic numbers from zlib.h.  Not clear why they are not defined
-// there.
+// These are magic numbers from zlib.h.  Not clear why they are not defined.
+// There.
 
-// Maximum window size
+// Maximum window size.
 constexpr int kGZipMaxWindowBits = 15;
 
-// Minimum window size
+// Minimum window size.
 constexpr int kGZipMinWindowBits = 9;
 
-// Default window size
+// Default window size.
 constexpr int kGZipDefaultWindowBits = 15;
 
 // Output Gzip.
@@ -58,41 +58,41 @@ constexpr int DETECT_CODEC = 32;
 constexpr int kGZipMinCompressionLevel = 1;
 constexpr int kGZipMaxCompressionLevel = 9;
 
-int CompressionWindowBitsForFormat(GZipFormat format, int window_bits) {
+int compressionWindowBitsForFormat(GZipFormat format, int windowBits) {
   switch (format) {
     case GZipFormat::DEFLATE:
-      window_bits = -window_bits;
+      windowBits = -windowBits;
       break;
     case GZipFormat::GZIP:
-      window_bits += GZIP_CODEC;
+      windowBits += GZIP_CODEC;
       break;
     case GZipFormat::ZLIB:
       break;
   }
-  return window_bits;
+  return windowBits;
 }
 
-int DecompressionWindowBitsForFormat(GZipFormat format, int window_bits) {
+int decompressionWindowBitsForFormat(GZipFormat format, int windowBits) {
   if (format == GZipFormat::DEFLATE) {
-    return -window_bits;
+    return -windowBits;
   } else {
     /* If not deflate, autodetect format from header */
-    return window_bits | DETECT_CODEC;
+    return windowBits | DETECT_CODEC;
   }
 }
 
-Status ZlibErrorPrefix(const char* prefix_msg, const char* msg) {
-  return Status::IOError(prefix_msg, (msg) ? msg : "(unknown error)");
+Status zlibErrorPrefix(const char* prefixMsg, const char* msg) {
+  return Status::IOError(prefixMsg, (msg) ? msg : "(unknown error)");
 }
 
-// ----------------------------------------------------------------------
-// gzip decompressor implementation
+// ----------------------------------------------------------------------.
+// Gzip Decompressor implementation.
 
 class GZipDecompressor : public Decompressor {
  public:
-  explicit GZipDecompressor(GZipFormat format, int window_bits)
+  explicit GZipDecompressor(GZipFormat format, int windowBits)
       : format_(format),
-        window_bits_(window_bits),
+        windowBits_(windowBits),
         initialized_(false),
         finished_(false) {}
 
@@ -102,88 +102,88 @@ class GZipDecompressor : public Decompressor {
     }
   }
 
-  Status Init() {
+  Status init() {
     VELOX_DCHECK(!initialized_);
     memset(&stream_, 0, sizeof(stream_));
     finished_ = false;
 
     int ret;
-    int window_bits = DecompressionWindowBitsForFormat(format_, window_bits_);
-    if ((ret = inflateInit2(&stream_, window_bits)) != Z_OK) {
-      return ZlibError("zlib inflateInit failed: ");
+    int windowBits = decompressionWindowBitsForFormat(format_, windowBits_);
+    if ((ret = inflateInit2(&stream_, windowBits)) != Z_OK) {
+      return zlibError("zlib inflateInit failed: ");
     } else {
       initialized_ = true;
       return Status::OK();
     }
   }
 
-  Status Reset() override {
+  Status reset() override {
     VELOX_DCHECK(initialized_);
     finished_ = false;
     int ret;
     if ((ret = inflateReset(&stream_)) != Z_OK) {
-      return ZlibError("zlib inflateReset failed: ");
+      return zlibError("zlib inflateReset failed: ");
     } else {
       return Status::OK();
     }
   }
 
-  Result<DecompressResult> Decompress(
-      int64_t input_len,
+  Result<DecompressResult> decompress(
+      int64_t inputLen,
       const uint8_t* input,
-      int64_t output_len,
+      int64_t outputLen,
       uint8_t* output) override {
-    static constexpr auto input_limit =
+    static constexpr auto inputLimit =
         static_cast<int64_t>(std::numeric_limits<uInt>::max());
     stream_.next_in = const_cast<Bytef*>(reinterpret_cast<const Bytef*>(input));
-    stream_.avail_in = static_cast<uInt>(std::min(input_len, input_limit));
+    stream_.avail_in = static_cast<uInt>(std::min(inputLen, inputLimit));
     stream_.next_out = reinterpret_cast<Bytef*>(output);
-    stream_.avail_out = static_cast<uInt>(std::min(output_len, input_limit));
+    stream_.avail_out = static_cast<uInt>(std::min(outputLen, inputLimit));
     int ret;
 
     ret = inflate(&stream_, Z_SYNC_FLUSH);
     if (ret == Z_DATA_ERROR || ret == Z_STREAM_ERROR || ret == Z_MEM_ERROR) {
-      return ZlibError("zlib inflate failed: ");
+      return zlibError("zlib inflate failed: ");
     }
     if (ret == Z_NEED_DICT) {
-      return ZlibError("zlib inflate failed (need preset dictionary): ");
+      return zlibError("zlib inflate failed (need preset dictionary): ");
     }
     finished_ = (ret == Z_STREAM_END);
     if (ret == Z_BUF_ERROR) {
-      // No progress was possible
+      // No progress was possible.
       return DecompressResult{0, 0, true};
     } else {
       VELOX_DCHECK(ret == Z_OK || ret == Z_STREAM_END);
-      // Some progress has been made
+      // Some progress has been made.
       return DecompressResult{
-          input_len - stream_.avail_in, output_len - stream_.avail_out, false};
+          inputLen - stream_.avail_in, outputLen - stream_.avail_out, false};
     }
     return Status::OK();
   }
 
-  bool IsFinished() override {
+  bool isFinished() override {
     return finished_;
   }
 
  protected:
-  Status ZlibError(const char* prefix_msg) {
-    return ZlibErrorPrefix(prefix_msg, stream_.msg);
+  Status zlibError(const char* prefixMsg) {
+    return zlibErrorPrefix(prefixMsg, stream_.msg);
   }
 
   z_stream stream_;
   GZipFormat format_;
-  int window_bits_;
+  int windowBits_;
   bool initialized_;
   bool finished_;
 };
 
-// ----------------------------------------------------------------------
-// gzip compressor implementation
+// ----------------------------------------------------------------------.
+// Gzip Compressor implementation.
 
 class GZipCompressor : public Compressor {
  public:
-  explicit GZipCompressor(int compression_level)
-      : initialized_(false), compression_level_(compression_level) {}
+  explicit GZipCompressor(int compressionLevel)
+      : initialized_(false), compressionLevel_(compressionLevel) {}
 
   ~GZipCompressor() override {
     if (initialized_) {
@@ -191,378 +191,377 @@ class GZipCompressor : public Compressor {
     }
   }
 
-  Status Init(GZipFormat format, int input_window_bits) {
+  Status init(GZipFormat format, int inputWindowBits) {
     VELOX_DCHECK(!initialized_);
     memset(&stream_, 0, sizeof(stream_));
 
     int ret;
-    // Initialize to run specified format
-    int window_bits = CompressionWindowBitsForFormat(format, input_window_bits);
+    // Initialize to run specified format.
+    int windowBits = compressionWindowBitsForFormat(format, inputWindowBits);
     if ((ret = deflateInit2(
              &stream_,
              Z_DEFAULT_COMPRESSION,
              Z_DEFLATED,
-             window_bits,
-             compression_level_,
+             windowBits,
+             compressionLevel_,
              Z_DEFAULT_STRATEGY)) != Z_OK) {
-      return ZlibError("zlib deflateInit failed: ");
+      return zlibError("zlib deflateInit failed: ");
     } else {
       initialized_ = true;
       return Status::OK();
     }
   }
 
-  Result<CompressResult> Compress(
-      int64_t input_len,
+  Result<CompressResult> compress(
+      int64_t inputLen,
       const uint8_t* input,
-      int64_t output_len,
+      int64_t outputLen,
       uint8_t* output) override {
     VELOX_DCHECK(initialized_, "Called on non-initialized stream");
 
-    static constexpr auto input_limit =
+    static constexpr auto inputLimit =
         static_cast<int64_t>(std::numeric_limits<uInt>::max());
 
     stream_.next_in = const_cast<Bytef*>(reinterpret_cast<const Bytef*>(input));
-    stream_.avail_in = static_cast<uInt>(std::min(input_len, input_limit));
+    stream_.avail_in = static_cast<uInt>(std::min(inputLen, inputLimit));
     stream_.next_out = reinterpret_cast<Bytef*>(output);
-    stream_.avail_out = static_cast<uInt>(std::min(output_len, input_limit));
+    stream_.avail_out = static_cast<uInt>(std::min(outputLen, inputLimit));
 
     int64_t ret = 0;
     ret = deflate(&stream_, Z_NO_FLUSH);
     if (ret == Z_STREAM_ERROR) {
-      return ZlibError("zlib compress failed: ");
+      return zlibError("zlib compress failed: ");
     }
     if (ret == Z_OK) {
-      // Some progress has been made
+      // Some progress has been made.
       return CompressResult{
-          input_len - stream_.avail_in, output_len - stream_.avail_out};
+          inputLen - stream_.avail_in, outputLen - stream_.avail_out};
     } else {
-      // No progress was possible
+      // No progress was possible.
       VELOX_DCHECK_EQ(ret, Z_BUF_ERROR);
       return CompressResult{0, 0};
     }
   }
 
-  Result<FlushResult> Flush(int64_t output_len, uint8_t* output) override {
+  Result<FlushResult> flush(int64_t outputLen, uint8_t* output) override {
     VELOX_DCHECK(initialized_, "Called on non-initialized stream");
 
-    static constexpr auto input_limit =
+    static constexpr auto inputLimit =
         static_cast<int64_t>(std::numeric_limits<uInt>::max());
 
     stream_.avail_in = 0;
     stream_.next_out = reinterpret_cast<Bytef*>(output);
-    stream_.avail_out = static_cast<uInt>(std::min(output_len, input_limit));
+    stream_.avail_out = static_cast<uInt>(std::min(outputLen, inputLimit));
 
     int64_t ret = 0;
     ret = deflate(&stream_, Z_SYNC_FLUSH);
     if (ret == Z_STREAM_ERROR) {
-      return ZlibError("zlib flush failed: ");
+      return zlibError("zlib flush failed: ");
     }
-    int64_t bytes_written;
+    int64_t bytesWritten;
     if (ret == Z_OK) {
-      bytes_written = output_len - stream_.avail_out;
+      bytesWritten = outputLen - stream_.avail_out;
     } else {
       VELOX_DCHECK_EQ(ret, Z_BUF_ERROR);
-      bytes_written = 0;
+      bytesWritten = 0;
     }
-    // "If deflate returns with avail_out == 0, this function must be called
-    //  again with the same value of the flush parameter and more output space
-    //  (updated avail_out), until the flush is complete (deflate returns
-    //  with non-zero avail_out)."
-    // "Note that Z_BUF_ERROR is not fatal, and deflate() can be called again
-    //  with more input and more output space to continue compressing."
-    return FlushResult{bytes_written, stream_.avail_out == 0};
+    // "If deflate returns with avail_out == 0, this function must be called.
+    //  Again with the same value of the flush parameter and more output space.
+    //  (Updated avail_out), until the flush is complete (deflate returns.
+    //  With non-zero avail_out).".
+    // "Note that Z_BUF_ERROR is not fatal, and deflate() can be called again.
+    //  With more input and more output space to continue compressing.".
+    return FlushResult{bytesWritten, stream_.avail_out == 0};
   }
 
-  Result<EndResult> End(int64_t output_len, uint8_t* output) override {
+  Result<EndResult> end(int64_t outputLen, uint8_t* output) override {
     VELOX_DCHECK(initialized_, "Called on non-initialized stream");
 
-    static constexpr auto input_limit =
+    static constexpr auto inputLimit =
         static_cast<int64_t>(std::numeric_limits<uInt>::max());
 
     stream_.avail_in = 0;
     stream_.next_out = reinterpret_cast<Bytef*>(output);
-    stream_.avail_out = static_cast<uInt>(std::min(output_len, input_limit));
+    stream_.avail_out = static_cast<uInt>(std::min(outputLen, inputLimit));
 
     int64_t ret = 0;
     ret = deflate(&stream_, Z_FINISH);
     if (ret == Z_STREAM_ERROR) {
-      return ZlibError("zlib flush failed: ");
+      return zlibError("zlib flush failed: ");
     }
-    int64_t bytes_written = output_len - stream_.avail_out;
+    int64_t bytesWritten = outputLen - stream_.avail_out;
     if (ret == Z_STREAM_END) {
-      // Flush complete, we can now end the stream
+      // Flush complete, we can now end the stream.
       initialized_ = false;
       ret = deflateEnd(&stream_);
       if (ret == Z_OK) {
-        return EndResult{bytes_written, false};
+        return EndResult{bytesWritten, false};
       } else {
-        return ZlibError("zlib end failed: ");
+        return zlibError("zlib end failed: ");
       }
     } else {
-      // Not everything could be flushed,
-      return EndResult{bytes_written, true};
+      // Not everything could be flushed,.
+      return EndResult{bytesWritten, true};
     }
   }
 
  protected:
-  Status ZlibError(const char* prefix_msg) {
-    return ZlibErrorPrefix(prefix_msg, stream_.msg);
+  Status zlibError(const char* prefixMsg) {
+    return zlibErrorPrefix(prefixMsg, stream_.msg);
   }
 
   z_stream stream_;
   bool initialized_;
-  int compression_level_;
+  int compressionLevel_;
 };
 
-// ----------------------------------------------------------------------
-// gzip codec implementation
+// ----------------------------------------------------------------------.
+// Gzip codec implementation.
 
 class GZipCodec : public Codec {
  public:
-  explicit GZipCodec(int compression_level, GZipFormat format, int window_bits)
+  explicit GZipCodec(int compressionLevel, GZipFormat format, int windowBits)
       : format_(format),
-        window_bits_(window_bits),
-        compressor_initialized_(false),
-        decompressor_initialized_(false) {
-    compression_level_ = compression_level == kUseDefaultCompressionLevel
+        windowBits_(windowBits),
+        compressorInitialized_(false),
+        decompressorInitialized_(false) {
+    compressionLevel_ = compressionLevel == kUseDefaultCompressionLevel
         ? kGZipDefaultCompressionLevel
-        : compression_level;
+        : compressionLevel;
   }
 
   ~GZipCodec() override {
-    EndCompressor();
-    EndDecompressor();
+    endCompressor();
+    endDecompressor();
   }
 
-  Result<std::shared_ptr<Compressor>> MakeCompressor() override {
-    auto ptr = std::make_shared<GZipCompressor>(compression_level_);
-    RETURN_NOT_OK(ptr->Init(format_, window_bits_));
+  Result<std::shared_ptr<Compressor>> makeCompressor() override {
+    auto ptr = std::make_shared<GZipCompressor>(compressionLevel_);
+    RETURN_NOT_OK(ptr->init(format_, windowBits_));
     return ptr;
   }
 
-  Result<std::shared_ptr<Decompressor>> MakeDecompressor() override {
-    auto ptr = std::make_shared<GZipDecompressor>(format_, window_bits_);
-    RETURN_NOT_OK(ptr->Init());
+  Result<std::shared_ptr<Decompressor>> makeDecompressor() override {
+    auto ptr = std::make_shared<GZipDecompressor>(format_, windowBits_);
+    RETURN_NOT_OK(ptr->init());
     return ptr;
   }
 
-  Status InitCompressor() {
-    EndDecompressor();
+  Status initCompressor() {
+    endDecompressor();
     memset(&stream_, 0, sizeof(stream_));
 
     int ret;
-    // Initialize to run specified format
-    int window_bits = CompressionWindowBitsForFormat(format_, window_bits_);
+    // Initialize to run specified format.
+    int windowBits = compressionWindowBitsForFormat(format_, windowBits_);
     if ((ret = deflateInit2(
              &stream_,
              Z_DEFAULT_COMPRESSION,
              Z_DEFLATED,
-             window_bits,
-             compression_level_,
+             windowBits,
+             compressionLevel_,
              Z_DEFAULT_STRATEGY)) != Z_OK) {
-      return ZlibErrorPrefix("zlib deflateInit failed: ", stream_.msg);
+      return zlibErrorPrefix("zlib deflateInit failed: ", stream_.msg);
     }
-    compressor_initialized_ = true;
+    compressorInitialized_ = true;
     return Status::OK();
   }
 
-  void EndCompressor() {
-    if (compressor_initialized_) {
+  void endCompressor() {
+    if (compressorInitialized_) {
       static_cast<void>(deflateEnd(&stream_));
     }
-    compressor_initialized_ = false;
+    compressorInitialized_ = false;
   }
 
-  Status InitDecompressor() {
-    EndCompressor();
+  Status initDecompressor() {
+    endCompressor();
     memset(&stream_, 0, sizeof(stream_));
     int ret;
 
-    // Initialize to run either deflate or zlib/gzip format
-    int window_bits = DecompressionWindowBitsForFormat(format_, window_bits_);
-    if ((ret = inflateInit2(&stream_, window_bits)) != Z_OK) {
-      return ZlibErrorPrefix("zlib inflateInit failed: ", stream_.msg);
+    // Initialize to run either deflate or zlib/gzip format.
+    int windowBits = decompressionWindowBitsForFormat(format_, windowBits_);
+    if ((ret = inflateInit2(&stream_, windowBits)) != Z_OK) {
+      return zlibErrorPrefix("zlib inflateInit failed: ", stream_.msg);
     }
-    decompressor_initialized_ = true;
+    decompressorInitialized_ = true;
     return Status::OK();
   }
 
-  void EndDecompressor() {
-    if (decompressor_initialized_) {
+  void endDecompressor() {
+    if (decompressorInitialized_) {
       static_cast<void>(inflateEnd(&stream_));
     }
-    decompressor_initialized_ = false;
+    decompressorInitialized_ = false;
   }
 
-  Result<int64_t> Decompress(
-      int64_t input_length,
+  Result<int64_t> decompress(
+      int64_t inputLength,
       const uint8_t* input,
-      int64_t output_buffer_length,
+      int64_t outputBufferLength,
       uint8_t* output) override {
-    if (!decompressor_initialized_) {
-      RETURN_NOT_OK(InitDecompressor());
+    if (!decompressorInitialized_) {
+      RETURN_NOT_OK(initDecompressor());
     }
-    if (output_buffer_length == 0) {
-      // The zlib library does not allow *output to be NULL, even when
-      // output_buffer_length is 0 (inflate() will return Z_STREAM_ERROR). We
-      // don't consider this an error, so bail early if no output is expected.
-      // Note that we don't signal an error if the input actually contains
-      // compressed data.
+    if (outputBufferLength == 0) {
+      // The zlib library does not allow *output to be NULL, even when.
+      // Output_buffer_length is 0 (inflate() will return Z_STREAM_ERROR). We.
+      // Don't consider this an error, so bail early if no output is expected.
+      // Note that we don't signal an error if the input actually contains.
+      // Compressed data.
       return 0;
     }
 
-    // Reset the stream for this block
+    // Reset the stream for this block.
     if (inflateReset(&stream_) != Z_OK) {
-      return ZlibErrorPrefix("zlib inflateReset failed: ", stream_.msg);
+      return zlibErrorPrefix("zlib inflateReset failed: ", stream_.msg);
     }
 
     int ret = 0;
-    // gzip can run in streaming mode or non-streaming mode.  We only
-    // support the non-streaming use case where we present it the entire
-    // compressed input and a buffer big enough to contain the entire
-    // compressed output.  In the case where we don't know the output,
-    // we just make a bigger buffer and try the non-streaming mode
-    // from the beginning again.
+    // Gzip can run in streaming mode or non-streaming mode.  We only.
+    // Support the non-streaming use case where we present it the entire.
+    // Compressed input and a buffer big enough to contain the entire.
+    // Compressed output.  In the case where we don't know the output,.
+    // We just make a bigger buffer and try the non-streaming mode.
+    // From the beginning again.
     while (ret != Z_STREAM_END) {
       stream_.next_in =
           const_cast<Bytef*>(reinterpret_cast<const Bytef*>(input));
-      stream_.avail_in = static_cast<uInt>(input_length);
+      stream_.avail_in = static_cast<uInt>(inputLength);
       stream_.next_out = reinterpret_cast<Bytef*>(output);
-      stream_.avail_out = static_cast<uInt>(output_buffer_length);
+      stream_.avail_out = static_cast<uInt>(outputBufferLength);
 
-      // We know the output size.  In this case, we can use Z_FINISH
-      // which is more efficient.
+      // We know the output size.  In this case, we can use Z_FINISH.
+      // Which is more efficient.
       ret = inflate(&stream_, Z_FINISH);
       if (ret == Z_STREAM_END || ret != Z_OK) {
         break;
       }
 
-      // Failure, buffer was too small
+      // Failure, buffer was too small.
       return Status::IOError(
           "Too small a buffer passed to GZipCodec. InputLength=",
-          input_length,
+          inputLength,
           " OutputLength=",
-          output_buffer_length);
+          outputBufferLength);
     }
 
-    // Failure for some other reason
+    // Failure for some other reason.
     if (ret != Z_STREAM_END) {
-      return ZlibErrorPrefix("GZipCodec failed: ", stream_.msg);
+      return zlibErrorPrefix("GZipCodec failed: ", stream_.msg);
     }
 
     return stream_.total_out;
   }
 
-  int64_t MaxCompressedLen(
-      int64_t input_length,
+  int64_t maxCompressedLen(
+      int64_t inputLength,
       const uint8_t* ARROW_ARG_UNUSED(input)) override {
-    // Must be in compression mode
-    if (!compressor_initialized_) {
-      Status s = InitCompressor();
+    // Must be in compression mode.
+    if (!compressorInitialized_) {
+      Status s = initCompressor();
       VELOX_DCHECK(s.ok(), s.ToString());
     }
-    int64_t max_len = deflateBound(&stream_, static_cast<uLong>(input_length));
-    // ARROW-3514: return a more pessimistic estimate to account for bugs
-    // in old zlib versions.
-    return max_len + 12;
+    int64_t maxLen = deflateBound(&stream_, static_cast<uLong>(inputLength));
+    // ARROW-3514: return a more pessimistic estimate to account for bugs.
+    // In old zlib versions.
+    return maxLen + 12;
   }
 
-  Result<int64_t> Compress(
-      int64_t input_length,
+  Result<int64_t> compress(
+      int64_t inputLength,
       const uint8_t* input,
-      int64_t output_buffer_len,
+      int64_t outputBufferLen,
       uint8_t* output) override {
-    if (!compressor_initialized_) {
-      RETURN_NOT_OK(InitCompressor());
+    if (!compressorInitialized_) {
+      RETURN_NOT_OK(initCompressor());
     }
     stream_.next_in = const_cast<Bytef*>(reinterpret_cast<const Bytef*>(input));
-    stream_.avail_in = static_cast<uInt>(input_length);
+    stream_.avail_in = static_cast<uInt>(inputLength);
     stream_.next_out = reinterpret_cast<Bytef*>(output);
-    stream_.avail_out = static_cast<uInt>(output_buffer_len);
+    stream_.avail_out = static_cast<uInt>(outputBufferLen);
 
     int64_t ret = 0;
     if ((ret = deflate(&stream_, Z_FINISH)) != Z_STREAM_END) {
       if (ret == Z_OK) {
-        // Will return Z_OK (and stream.msg NOT set) if stream.avail_out is too
-        // small
+        // Will return Z_OK (and stream.msg NOT set) if stream.avail_out is too.
+        // Small.
         return Status::IOError("zlib deflate failed, output buffer too small");
       }
 
-      return ZlibErrorPrefix("zlib deflate failed: ", stream_.msg);
+      return zlibErrorPrefix("zlib deflate failed: ", stream_.msg);
     }
 
     if (deflateReset(&stream_) != Z_OK) {
-      return ZlibErrorPrefix("zlib deflateReset failed: ", stream_.msg);
+      return zlibErrorPrefix("zlib deflateReset failed: ", stream_.msg);
     }
 
-    // Actual output length
-    return output_buffer_len - stream_.avail_out;
+    // Actual output length.
+    return outputBufferLen - stream_.avail_out;
   }
 
-  Status Init() override {
-    if (window_bits_ < kGZipMinWindowBits ||
-        window_bits_ > kGZipMaxWindowBits) {
+  Status init() override {
+    if (windowBits_ < kGZipMinWindowBits || windowBits_ > kGZipMaxWindowBits) {
       return Status::Invalid(
           "GZip window_bits should be between ",
           kGZipMinWindowBits,
           " and ",
           kGZipMaxWindowBits);
     }
-    const Status init_compressor_status = InitCompressor();
-    if (!init_compressor_status.ok()) {
-      return init_compressor_status;
+    const Status initCompressorStatus = initCompressor();
+    if (!initCompressorStatus.ok()) {
+      return initCompressorStatus;
     }
-    return InitDecompressor();
+    return initDecompressor();
   }
 
-  Compression::type compression_type() const override {
+  Compression::type compressionType() const override {
     return Compression::GZIP;
   }
 
-  int compression_level() const override {
-    return compression_level_;
+  int compressionLevel() const override {
+    return compressionLevel_;
   }
-  int minimum_compression_level() const override {
+  int minimumCompressionLevel() const override {
     return kGZipMinCompressionLevel;
   }
-  int maximum_compression_level() const override {
+  int maximumCompressionLevel() const override {
     return kGZipMaxCompressionLevel;
   }
-  int default_compression_level() const override {
+  int defaultCompressionLevel() const override {
     return kGZipDefaultCompressionLevel;
   }
 
  private:
-  // zlib is stateful and the z_stream state variable must be initialized
-  // before
+  // Zlib is stateful and the z_stream state variable must be initialized.
+  // Before.
   z_stream stream_;
 
-  // Realistically, this will always be GZIP, but we leave the option open to
-  // configure
+  // Realistically, this will always be GZIP, but we leave the option open to.
+  // Configure.
   GZipFormat format_;
 
-  // These variables are mutually exclusive. When the codec is in "compressor"
-  // state, compressor_initialized_ is true while decompressor_initialized_ is
-  // false. When it's decompressing, the opposite is true.
+  // These variables are mutually exclusive. When the codec is in "Compressor".
+  // State, compressor_initialized_ is true while decompressor_initialized_ is.
+  // False. When it's decompressing, the opposite is true.
   //
-  // Indeed, this is slightly hacky, but the alternative is having separate
-  // Compressor and Decompressor classes. If this ever becomes an issue, we can
-  // perform the refactoring then
-  int window_bits_;
-  bool compressor_initialized_;
-  bool decompressor_initialized_;
-  int compression_level_;
+  // Indeed, this is slightly hacky, but the alternative is having separate.
+  // Compressor and Decompressor classes. If this ever becomes an issue, we can.
+  // Perform the refactoring then.
+  int windowBits_;
+  bool compressorInitialized_;
+  bool decompressorInitialized_;
+  int compressionLevel_;
 };
 
 } // namespace
 
-std::unique_ptr<Codec> MakeGZipCodec(
-    int compression_level,
+std::unique_ptr<Codec> makeGZipCodec(
+    int compressionLevel,
     GZipFormat format,
-    std::optional<int> window_bits) {
+    std::optional<int> windowBits) {
   return std::make_unique<GZipCodec>(
-      compression_level, format, window_bits.value_or(kGZipDefaultWindowBits));
+      compressionLevel, format, windowBits.value_or(kGZipDefaultWindowBits));
 }
 
 } // namespace facebook::velox::parquet::arrow::util::internal
diff --git a/velox/dwio/parquet/writer/arrow/util/CompressionZstd.cpp b/velox/dwio/parquet/writer/arrow/util/CompressionZstd.cpp
index 22408c77210..71fc0f7bad8 100644
--- a/velox/dwio/parquet/writer/arrow/util/CompressionZstd.cpp
+++ b/velox/dwio/parquet/writer/arrow/util/CompressionZstd.cpp
@@ -35,12 +35,12 @@ using std::size_t;
 namespace facebook::velox::parquet::arrow::util::internal {
 namespace {
 
-Status ZSTDError(size_t ret, const char* prefix_msg) {
-  return Status::IOError(prefix_msg, ZSTD_getErrorName(ret));
+Status zSTDError(size_t ret, const char* prefixMsg) {
+  return Status::IOError(prefixMsg, ZSTD_getErrorName(ret));
 }
 
-// ----------------------------------------------------------------------
-// ZSTD decompressor implementation
+// ----------------------------------------------------------------------.
+// ZSTD decompressor implementation.
 
 class ZSTDDecompressor : public Decompressor {
  public:
@@ -50,48 +50,48 @@ class ZSTDDecompressor : public Decompressor {
     ZSTD_freeDStream(stream_);
   }
 
-  Status Init() {
+  Status init() {
     finished_ = false;
     size_t ret = ZSTD_initDStream(stream_);
     if (ZSTD_isError(ret)) {
-      return ZSTDError(ret, "ZSTD init failed: ");
+      return zSTDError(ret, "ZSTD init failed: ");
     } else {
       return Status::OK();
     }
   }
 
-  Result<DecompressResult> Decompress(
-      int64_t input_len,
+  Result<DecompressResult> decompress(
+      int64_t inputLen,
       const uint8_t* input,
-      int64_t output_len,
+      int64_t outputLen,
       uint8_t* output) override {
-    ZSTD_inBuffer in_buf;
-    ZSTD_outBuffer out_buf;
+    ZSTD_inBuffer inBuf;
+    ZSTD_outBuffer outBuf;
 
-    in_buf.src = input;
-    in_buf.size = static_cast<size_t>(input_len);
-    in_buf.pos = 0;
-    out_buf.dst = output;
-    out_buf.size = static_cast<size_t>(output_len);
-    out_buf.pos = 0;
+    inBuf.src = input;
+    inBuf.size = static_cast<size_t>(inputLen);
+    inBuf.pos = 0;
+    outBuf.dst = output;
+    outBuf.size = static_cast<size_t>(outputLen);
+    outBuf.pos = 0;
 
     size_t ret;
-    ret = ZSTD_decompressStream(stream_, &out_buf, &in_buf);
+    ret = ZSTD_decompressStream(stream_, &outBuf, &inBuf);
     if (ZSTD_isError(ret)) {
-      return ZSTDError(ret, "ZSTD decompress failed: ");
+      return zSTDError(ret, "ZSTD decompress failed: ");
     }
     finished_ = (ret == 0);
     return DecompressResult{
-        static_cast<int64_t>(in_buf.pos),
-        static_cast<int64_t>(out_buf.pos),
-        in_buf.pos == 0 && out_buf.pos == 0};
+        static_cast<int64_t>(inBuf.pos),
+        static_cast<int64_t>(outBuf.pos),
+        inBuf.pos == 0 && outBuf.pos == 0};
   }
 
-  Status Reset() override {
-    return Init();
+  Status reset() override {
+    return init();
   }
 
-  bool IsFinished() override {
+  bool isFinished() override {
     return finished_;
   }
 
@@ -100,186 +100,186 @@ class ZSTDDecompressor : public Decompressor {
   bool finished_;
 };
 
-// ----------------------------------------------------------------------
-// ZSTD compressor implementation
+// ----------------------------------------------------------------------.
+// ZSTD compressor implementation.
 
 class ZSTDCompressor : public Compressor {
  public:
-  explicit ZSTDCompressor(int compression_level)
-      : stream_(ZSTD_createCStream()), compression_level_(compression_level) {}
+  explicit ZSTDCompressor(int compressionLevel)
+      : stream_(ZSTD_createCStream()), compressionLevel_(compressionLevel) {}
 
   ~ZSTDCompressor() override {
     ZSTD_freeCStream(stream_);
   }
 
-  Status Init() {
-    size_t ret = ZSTD_initCStream(stream_, compression_level_);
+  Status init() {
+    size_t ret = ZSTD_initCStream(stream_, compressionLevel_);
     if (ZSTD_isError(ret)) {
-      return ZSTDError(ret, "ZSTD init failed: ");
+      return zSTDError(ret, "ZSTD init failed: ");
     } else {
       return Status::OK();
     }
   }
 
-  Result<CompressResult> Compress(
-      int64_t input_len,
+  Result<CompressResult> compress(
+      int64_t inputLen,
       const uint8_t* input,
-      int64_t output_len,
+      int64_t outputLen,
       uint8_t* output) override {
-    ZSTD_inBuffer in_buf;
-    ZSTD_outBuffer out_buf;
+    ZSTD_inBuffer inBuf;
+    ZSTD_outBuffer outBuf;
 
-    in_buf.src = input;
-    in_buf.size = static_cast<size_t>(input_len);
-    in_buf.pos = 0;
-    out_buf.dst = output;
-    out_buf.size = static_cast<size_t>(output_len);
-    out_buf.pos = 0;
+    inBuf.src = input;
+    inBuf.size = static_cast<size_t>(inputLen);
+    inBuf.pos = 0;
+    outBuf.dst = output;
+    outBuf.size = static_cast<size_t>(outputLen);
+    outBuf.pos = 0;
 
     size_t ret;
-    ret = ZSTD_compressStream(stream_, &out_buf, &in_buf);
+    ret = ZSTD_compressStream(stream_, &outBuf, &inBuf);
     if (ZSTD_isError(ret)) {
-      return ZSTDError(ret, "ZSTD compress failed: ");
+      return zSTDError(ret, "ZSTD compress failed: ");
     }
     return CompressResult{
-        static_cast<int64_t>(in_buf.pos), static_cast<int64_t>(out_buf.pos)};
+        static_cast<int64_t>(inBuf.pos), static_cast<int64_t>(outBuf.pos)};
   }
 
-  Result<FlushResult> Flush(int64_t output_len, uint8_t* output) override {
-    ZSTD_outBuffer out_buf;
+  Result<FlushResult> flush(int64_t outputLen, uint8_t* output) override {
+    ZSTD_outBuffer outBuf;
 
-    out_buf.dst = output;
-    out_buf.size = static_cast<size_t>(output_len);
-    out_buf.pos = 0;
+    outBuf.dst = output;
+    outBuf.size = static_cast<size_t>(outputLen);
+    outBuf.pos = 0;
 
     size_t ret;
-    ret = ZSTD_flushStream(stream_, &out_buf);
+    ret = ZSTD_flushStream(stream_, &outBuf);
     if (ZSTD_isError(ret)) {
-      return ZSTDError(ret, "ZSTD flush failed: ");
+      return zSTDError(ret, "ZSTD flush failed: ");
     }
-    return FlushResult{static_cast<int64_t>(out_buf.pos), ret > 0};
+    return FlushResult{static_cast<int64_t>(outBuf.pos), ret > 0};
   }
 
-  Result<EndResult> End(int64_t output_len, uint8_t* output) override {
-    ZSTD_outBuffer out_buf;
+  Result<EndResult> end(int64_t outputLen, uint8_t* output) override {
+    ZSTD_outBuffer outBuf;
 
-    out_buf.dst = output;
-    out_buf.size = static_cast<size_t>(output_len);
-    out_buf.pos = 0;
+    outBuf.dst = output;
+    outBuf.size = static_cast<size_t>(outputLen);
+    outBuf.pos = 0;
 
     size_t ret;
-    ret = ZSTD_endStream(stream_, &out_buf);
+    ret = ZSTD_endStream(stream_, &outBuf);
     if (ZSTD_isError(ret)) {
-      return ZSTDError(ret, "ZSTD end failed: ");
+      return zSTDError(ret, "ZSTD end failed: ");
     }
-    return EndResult{static_cast<int64_t>(out_buf.pos), ret > 0};
+    return EndResult{static_cast<int64_t>(outBuf.pos), ret > 0};
   }
 
  protected:
   ZSTD_CStream* stream_;
 
  private:
-  int compression_level_;
+  int compressionLevel_;
 };
 
-// ----------------------------------------------------------------------
-// ZSTD codec implementation
+// ----------------------------------------------------------------------.
+// ZSTD codec implementation.
 
 class ZSTDCodec : public Codec {
  public:
-  explicit ZSTDCodec(int compression_level)
-      : compression_level_(
-            compression_level == kUseDefaultCompressionLevel
+  explicit ZSTDCodec(int compressionLevel)
+      : compressionLevel_(
+            compressionLevel == kUseDefaultCompressionLevel
                 ? kZSTDDefaultCompressionLevel
-                : compression_level) {}
+                : compressionLevel) {}
 
-  Result<int64_t> Decompress(
-      int64_t input_len,
+  Result<int64_t> decompress(
+      int64_t inputLen,
       const uint8_t* input,
-      int64_t output_buffer_len,
-      uint8_t* output_buffer) override {
-    if (output_buffer == nullptr) {
-      // We may pass a NULL 0-byte output buffer but some zstd versions demand
-      // a valid pointer: https://github.com/facebook/zstd/issues/1385
-      static uint8_t empty_buffer;
-      VELOX_DCHECK_EQ(output_buffer_len, 0);
-      output_buffer = &empty_buffer;
+      int64_t outputBufferLen,
+      uint8_t* outputBuffer) override {
+    if (outputBuffer == nullptr) {
+      // We may pass a NULL 0-byte output buffer but some zstd versions demand a
+      // valid pointer: https://github.com/facebook/zstd/issues/1385.
+      static uint8_t emptyBuffer;
+      VELOX_DCHECK_EQ(outputBufferLen, 0);
+      outputBuffer = &emptyBuffer;
     }
 
     size_t ret = ZSTD_decompress(
-        output_buffer,
-        static_cast<size_t>(output_buffer_len),
+        outputBuffer,
+        static_cast<size_t>(outputBufferLen),
         input,
-        static_cast<size_t>(input_len));
+        static_cast<size_t>(inputLen));
     if (ZSTD_isError(ret)) {
-      return ZSTDError(ret, "ZSTD decompression failed: ");
+      return zSTDError(ret, "ZSTD decompression failed: ");
     }
-    if (static_cast<int64_t>(ret) != output_buffer_len) {
+    if (static_cast<int64_t>(ret) != outputBufferLen) {
       return Status::IOError("Corrupt ZSTD compressed data.");
     }
     return static_cast<int64_t>(ret);
   }
 
-  int64_t MaxCompressedLen(
-      int64_t input_len,
+  int64_t maxCompressedLen(
+      int64_t inputLen,
       const uint8_t* ARROW_ARG_UNUSED(input)) override {
-    VELOX_DCHECK_GE(input_len, 0);
-    return ZSTD_compressBound(static_cast<size_t>(input_len));
+    VELOX_DCHECK_GE(inputLen, 0);
+    return ZSTD_compressBound(static_cast<size_t>(inputLen));
   }
 
-  Result<int64_t> Compress(
-      int64_t input_len,
+  Result<int64_t> compress(
+      int64_t inputLen,
       const uint8_t* input,
-      int64_t output_buffer_len,
-      uint8_t* output_buffer) override {
+      int64_t outputBufferLen,
+      uint8_t* outputBuffer) override {
     size_t ret = ZSTD_compress(
-        output_buffer,
-        static_cast<size_t>(output_buffer_len),
+        outputBuffer,
+        static_cast<size_t>(outputBufferLen),
         input,
-        static_cast<size_t>(input_len),
-        compression_level_);
+        static_cast<size_t>(inputLen),
+        compressionLevel_);
     if (ZSTD_isError(ret)) {
-      return ZSTDError(ret, "ZSTD compression failed: ");
+      return zSTDError(ret, "ZSTD compression failed: ");
     }
     return static_cast<int64_t>(ret);
   }
 
-  Result<std::shared_ptr<Compressor>> MakeCompressor() override {
-    auto ptr = std::make_shared<ZSTDCompressor>(compression_level_);
-    RETURN_NOT_OK(ptr->Init());
+  Result<std::shared_ptr<Compressor>> makeCompressor() override {
+    auto ptr = std::make_shared<ZSTDCompressor>(compressionLevel_);
+    RETURN_NOT_OK(ptr->init());
     return ptr;
   }
 
-  Result<std::shared_ptr<Decompressor>> MakeDecompressor() override {
+  Result<std::shared_ptr<Decompressor>> makeDecompressor() override {
     auto ptr = std::make_shared<ZSTDDecompressor>();
-    RETURN_NOT_OK(ptr->Init());
+    RETURN_NOT_OK(ptr->init());
     return ptr;
   }
 
-  Compression::type compression_type() const override {
+  Compression::type compressionType() const override {
     return Compression::ZSTD;
   }
-  int minimum_compression_level() const override {
+  int minimumCompressionLevel() const override {
     return ZSTD_minCLevel();
   }
-  int maximum_compression_level() const override {
+  int maximumCompressionLevel() const override {
     return ZSTD_maxCLevel();
   }
-  int default_compression_level() const override {
+  int defaultCompressionLevel() const override {
     return kZSTDDefaultCompressionLevel;
   }
 
-  int compression_level() const override {
-    return compression_level_;
+  int compressionLevel() const override {
+    return compressionLevel_;
   }
 
  private:
-  const int compression_level_;
+  const int compressionLevel_;
 };
 
 } // namespace
 
-std::unique_ptr<Codec> MakeZSTDCodec(int compression_level) {
-  return std::make_unique<ZSTDCodec>(compression_level);
+std::unique_ptr<Codec> makeZSTDCodec(int compressionLevel) {
+  return std::make_unique<ZSTDCodec>(compressionLevel);
 }
-} // namespace facebook::velox::parquet::arrow::util::internal.
+} // namespace facebook::velox::parquet::arrow::util::internal
diff --git a/velox/dwio/parquet/writer/arrow/util/Crc32.cpp b/velox/dwio/parquet/writer/arrow/util/Crc32.cpp
index 9b00633f32f..1e37d763aa1 100644
--- a/velox/dwio/parquet/writer/arrow/util/Crc32.cpp
+++ b/velox/dwio/parquet/writer/arrow/util/Crc32.cpp
@@ -97,7 +97,7 @@ namespace facebook::velox::parquet::arrow::internal {
 
 #define ALIGNOF_UINT32_T alignof(uint32_t)
 
-static const uint32_t crc32_lookup[16][256] = {
+static const uint32_t crc32Lookup[16][256] = {
     /* same algorithm as crc32_bitwise
 
        for (int i = 0; i <= 0xFF; i++)
@@ -861,7 +861,7 @@ static const uint32_t crc32_lookup[16][256] = {
 uint32_t crc32(uint32_t prev, const void* data, size_t length) {
   uint32_t crc = ~prev;
   unsigned unaligned;
-  const uint8_t* current_char;
+  const uint8_t* currentChar;
   const uint32_t* current;
 
   unaligned =
@@ -870,20 +870,20 @@ uint32_t crc32(uint32_t prev, const void* data, size_t length) {
     unaligned = 0;
 
   /* process a byte at a time until we hit an alignment boundary (max 3) */
-  current_char = reinterpret_cast<const uint8_t*>(data);
+  currentChar = reinterpret_cast<const uint8_t*>(data);
   for (; unaligned && length; unaligned--, length--)
-    crc = (crc >> 8) ^ crc32_lookup[0][(crc & 0xFF) ^ *current_char++];
+    crc = (crc >> 8) ^ crc32Lookup[0][(crc & 0xFF) ^ *currentChar++];
 
-  current = reinterpret_cast<const uint32_t*>(current_char);
+  current = reinterpret_cast<const uint32_t*>(currentChar);
 
   /* process 64 bytes at once (Slicing-by-16) */
 
   /* enabling optimization (at least -O2) automatically unrolls the inner
    * for-loop */
   const size_t unroll = 4;
-  const size_t bytes_at_once = 16 * unroll;
+  const size_t bytesAtOnce = 16 * unroll;
 
-  while (length >= bytes_at_once) {
+  while (length >= bytesAtOnce) {
     size_t unrolling;
     for (unrolling = 0; unrolling < unroll; unrolling++) {
 #if ARROW_LITTLE_ENDIAN
@@ -891,39 +891,39 @@ uint32_t crc32(uint32_t prev, const void* data, size_t length) {
       uint32_t two = *current++;
       uint32_t three = *current++;
       uint32_t four = *current++;
-      crc = crc32_lookup[0][(four >> 24) & 0xFF] ^
-          crc32_lookup[1][(four >> 16) & 0xFF] ^
-          crc32_lookup[2][(four >> 8) & 0xFF] ^ crc32_lookup[3][four & 0xFF] ^
-          crc32_lookup[4][(three >> 24) & 0xFF] ^
-          crc32_lookup[5][(three >> 16) & 0xFF] ^
-          crc32_lookup[6][(three >> 8) & 0xFF] ^ crc32_lookup[7][three & 0xFF] ^
-          crc32_lookup[8][(two >> 24) & 0xFF] ^
-          crc32_lookup[9][(two >> 16) & 0xFF] ^
-          crc32_lookup[10][(two >> 8) & 0xFF] ^ crc32_lookup[11][two & 0xFF] ^
-          crc32_lookup[12][(one >> 24) & 0xFF] ^
-          crc32_lookup[13][(one >> 16) & 0xFF] ^
-          crc32_lookup[14][(one >> 8) & 0xFF] ^ crc32_lookup[15][one & 0xFF];
+      crc = crc32Lookup[0][(four >> 24) & 0xFF] ^
+          crc32Lookup[1][(four >> 16) & 0xFF] ^
+          crc32Lookup[2][(four >> 8) & 0xFF] ^ crc32Lookup[3][four & 0xFF] ^
+          crc32Lookup[4][(three >> 24) & 0xFF] ^
+          crc32Lookup[5][(three >> 16) & 0xFF] ^
+          crc32Lookup[6][(three >> 8) & 0xFF] ^ crc32Lookup[7][three & 0xFF] ^
+          crc32Lookup[8][(two >> 24) & 0xFF] ^
+          crc32Lookup[9][(two >> 16) & 0xFF] ^
+          crc32Lookup[10][(two >> 8) & 0xFF] ^ crc32Lookup[11][two & 0xFF] ^
+          crc32Lookup[12][(one >> 24) & 0xFF] ^
+          crc32Lookup[13][(one >> 16) & 0xFF] ^
+          crc32Lookup[14][(one >> 8) & 0xFF] ^ crc32Lookup[15][one & 0xFF];
 #else
       uint32_t one = *current++ ^ ::arrow::bit_util::ByteSwap(crc);
       uint32_t two = *current++;
       uint32_t three = *current++;
       uint32_t four = *current++;
-      crc = crc32_lookup[0][four & 0xFF] ^ crc32_lookup[1][(four >> 8) & 0xFF] ^
-          crc32_lookup[2][(four >> 16) & 0xFF] ^
-          crc32_lookup[3][(four >> 24) & 0xFF] ^ crc32_lookup[4][three & 0xFF] ^
-          crc32_lookup[5][(three >> 8) & 0xFF] ^
-          crc32_lookup[6][(three >> 16) & 0xFF] ^
-          crc32_lookup[7][(three >> 24) & 0xFF] ^ crc32_lookup[8][two & 0xFF] ^
-          crc32_lookup[9][(two >> 8) & 0xFF] ^
-          crc32_lookup[10][(two >> 16) & 0xFF] ^
-          crc32_lookup[11][(two >> 24) & 0xFF] ^ crc32_lookup[12][one & 0xFF] ^
-          crc32_lookup[13][(one >> 8) & 0xFF] ^
-          crc32_lookup[14][(one >> 16) & 0xFF] ^
-          crc32_lookup[15][(one >> 24) & 0xFF];
+      crc = crc32Lookup[0][four & 0xFF] ^ crc32Lookup[1][(four >> 8) & 0xFF] ^
+          crc32Lookup[2][(four >> 16) & 0xFF] ^
+          crc32Lookup[3][(four >> 24) & 0xFF] ^ crc32Lookup[4][three & 0xFF] ^
+          crc32Lookup[5][(three >> 8) & 0xFF] ^
+          crc32Lookup[6][(three >> 16) & 0xFF] ^
+          crc32Lookup[7][(three >> 24) & 0xFF] ^ crc32Lookup[8][two & 0xFF] ^
+          crc32Lookup[9][(two >> 8) & 0xFF] ^
+          crc32Lookup[10][(two >> 16) & 0xFF] ^
+          crc32Lookup[11][(two >> 24) & 0xFF] ^ crc32Lookup[12][one & 0xFF] ^
+          crc32Lookup[13][(one >> 8) & 0xFF] ^
+          crc32Lookup[14][(one >> 16) & 0xFF] ^
+          crc32Lookup[15][(one >> 24) & 0xFF];
 #endif
     }
 
-    length -= bytes_at_once;
+    length -= bytesAtOnce;
   }
 
   /* process eight bytes at once (Slicing-by-8) */
@@ -932,21 +932,19 @@ uint32_t crc32(uint32_t prev, const void* data, size_t length) {
 #if ARROW_LITTLE_ENDIAN
     uint32_t one = *current++ ^ crc;
     uint32_t two = *current++;
-    crc = crc32_lookup[0][(two >> 24) & 0xFF] ^
-        crc32_lookup[1][(two >> 16) & 0xFF] ^
-        crc32_lookup[2][(two >> 8) & 0xFF] ^ crc32_lookup[3][two & 0xFF] ^
-        crc32_lookup[4][(one >> 24) & 0xFF] ^
-        crc32_lookup[5][(one >> 16) & 0xFF] ^
-        crc32_lookup[6][(one >> 8) & 0xFF] ^ crc32_lookup[7][one & 0xFF];
+    crc = crc32Lookup[0][(two >> 24) & 0xFF] ^
+        crc32Lookup[1][(two >> 16) & 0xFF] ^ crc32Lookup[2][(two >> 8) & 0xFF] ^
+        crc32Lookup[3][two & 0xFF] ^ crc32Lookup[4][(one >> 24) & 0xFF] ^
+        crc32Lookup[5][(one >> 16) & 0xFF] ^ crc32Lookup[6][(one >> 8) & 0xFF] ^
+        crc32Lookup[7][one & 0xFF];
 #else
     uint32_t one = *current++ ^ ::arrow::bit_util::ByteSwap(crc);
     uint32_t two = *current++;
-    crc = crc32_lookup[0][two & 0xFF] ^ crc32_lookup[1][(two >> 8) & 0xFF] ^
-        crc32_lookup[2][(two >> 16) & 0xFF] ^
-        crc32_lookup[3][(two >> 24) & 0xFF] ^ crc32_lookup[4][one & 0xFF] ^
-        crc32_lookup[5][(one >> 8) & 0xFF] ^
-        crc32_lookup[6][(one >> 16) & 0xFF] ^
-        crc32_lookup[7][(one >> 24) & 0xFF];
+    crc = crc32Lookup[0][two & 0xFF] ^ crc32Lookup[1][(two >> 8) & 0xFF] ^
+        crc32Lookup[2][(two >> 16) & 0xFF] ^
+        crc32Lookup[3][(two >> 24) & 0xFF] ^ crc32Lookup[4][one & 0xFF] ^
+        crc32Lookup[5][(one >> 8) & 0xFF] ^ crc32Lookup[6][(one >> 16) & 0xFF] ^
+        crc32Lookup[7][(one >> 24) & 0xFF];
 #endif
 
     length -= 8;
@@ -955,14 +953,13 @@ uint32_t crc32(uint32_t prev, const void* data, size_t length) {
   if (length >= 4) {
 #if ARROW_LITTLE_ENDIAN
     uint32_t one = *current++ ^ crc;
-    crc = crc32_lookup[0][(one >> 24) & 0xFF] ^
-        crc32_lookup[1][(one >> 16) & 0xFF] ^
-        crc32_lookup[2][(one >> 8) & 0xFF] ^ crc32_lookup[3][one & 0xFF];
+    crc = crc32Lookup[0][(one >> 24) & 0xFF] ^
+        crc32Lookup[1][(one >> 16) & 0xFF] ^ crc32Lookup[2][(one >> 8) & 0xFF] ^
+        crc32Lookup[3][one & 0xFF];
 #else
     uint32_t one = *current++ ^ ::arrow::bit_util::ByteSwap(crc);
-    crc = crc32_lookup[0][one & 0xFF] ^ crc32_lookup[1][(one >> 8) & 0xFF] ^
-        crc32_lookup[2][(one >> 16) & 0xFF] ^
-        crc32_lookup[3][(one >> 24) & 0xFF];
+    crc = crc32Lookup[0][one & 0xFF] ^ crc32Lookup[1][(one >> 8) & 0xFF] ^
+        crc32Lookup[2][(one >> 16) & 0xFF] ^ crc32Lookup[3][(one >> 24) & 0xFF];
 #endif
 
     length -= 4;
@@ -970,10 +967,10 @@ uint32_t crc32(uint32_t prev, const void* data, size_t length) {
 
   /* Finish with any remaining bytes one by one */
 
-  current_char = reinterpret_cast<const uint8_t*>(current);
+  currentChar = reinterpret_cast<const uint8_t*>(current);
   /* remaining 1 to 3 bytes (standard algorithm) */
   while (length-- != 0)
-    crc = (crc >> 8) ^ crc32_lookup[0][(crc & 0xFF) ^ *current_char++];
+    crc = (crc >> 8) ^ crc32Lookup[0][(crc & 0xFF) ^ *currentChar++];
 
   return ~crc;
 }
diff --git a/velox/dwio/parquet/writer/arrow/util/Crc32.h b/velox/dwio/parquet/writer/arrow/util/Crc32.h
index afb2045f979..6fd2f9fe2c5 100644
--- a/velox/dwio/parquet/writer/arrow/util/Crc32.h
+++ b/velox/dwio/parquet/writer/arrow/util/Crc32.h
@@ -23,7 +23,7 @@
 
 namespace facebook::velox::parquet::arrow::internal {
 
-/// \brief Compute the CRC32 checksum of the given data
+/// \brief Compute the CRC32 checksum of the given data.
 ///
 /// This function computes CRC32 with the polynomial 0x04C11DB7,
 /// as used in zlib and others (note this is different from CRC32C).
diff --git a/velox/dwio/parquet/writer/arrow/util/Hashing.cpp b/velox/dwio/parquet/writer/arrow/util/Hashing.cpp
index eabab4b54c4..76c1508ad6d 100644
--- a/velox/dwio/parquet/writer/arrow/util/Hashing.cpp
+++ b/velox/dwio/parquet/writer/arrow/util/Hashing.cpp
@@ -24,32 +24,32 @@
 namespace facebook::velox::parquet::arrow::internal {
 namespace {
 
-/// \brief A hash function for bitmaps that can handle offsets and lengths in
-/// terms of number of bits. The hash only depends on the bits actually hashed.
+/// \brief A hash function for bitmaps that can handle offsets and lengths in.
+/// Terms of number of bits. The hash only depends on the bits actually hashed.
 ///
-/// This implementation is based on 64-bit versions of MurmurHash2 by Austin
+/// This implementation is based on 64-bit versions of MurmurHash2 by Austin.
 /// Appleby.
 ///
-/// It's the caller's responsibility to ensure that bits_offset + num_bits are
-/// readable from the bitmap.
+/// It's the caller's responsibility to ensure that bits_offset + num_bits are.
+/// Readable from the bitmap.
 ///
 /// \param key The pointer to the bitmap.
-/// \param seed The seed for the hash function (useful when chaining hash
-/// functions). \param bits_offset The offset in bits relative to the start of
-/// the bitmap. \param num_bits The number of bits after the offset to be
-/// hashed.
-uint64_t MurmurHashBitmap64(
+/// \param seed The seed for the hash function (useful when chaining hash.
+/// Functions). \param bits_offset The offset in bits relative to the start of.
+/// The bitmap. \param num_bits The number of bits after the offset to be.
+/// Hashed.
+uint64_t murmurHashBitmap64(
     const uint8_t* key,
     uint64_t seed,
-    uint64_t bits_offset,
-    uint64_t num_bits) {
+    uint64_t bitsOffset,
+    uint64_t numBits) {
   const uint64_t m = 0xc6a4a7935bd1e995LLU;
   const int r = 47;
 
-  uint64_t h = seed ^ (num_bits * m);
+  uint64_t h = seed ^ (numBits * m);
 
   ::arrow::internal::BitmapWordReader<uint64_t> reader(
-      key, bits_offset, num_bits);
+      key, bitsOffset, numBits);
   auto nwords = reader.words();
   while (nwords--) {
     auto k = reader.NextWord();
@@ -60,12 +60,12 @@ uint64_t MurmurHashBitmap64(
     h ^= k;
     h *= m;
   }
-  int valid_bits;
+  int validBits;
   auto nbytes = reader.trailing_bytes();
   if (nbytes) {
     uint64_t k = 0;
     do {
-      auto byte = reader.NextTrailingByte(valid_bits);
+      auto byte = reader.NextTrailingByte(validBits);
       k = (k << 8) | static_cast<uint64_t>(byte);
     } while (--nbytes);
     h ^= k;
@@ -80,14 +80,14 @@ uint64_t MurmurHashBitmap64(
 
 } // namespace
 
-hash_t ComputeBitmapHash(
+hash_t computeBitmapHash(
     const uint8_t* bitmap,
     hash_t seed,
-    int64_t bits_offset,
-    int64_t num_bits) {
-  VELOX_DCHECK_GE(bits_offset, 0);
-  VELOX_DCHECK_GE(num_bits, 0);
-  return MurmurHashBitmap64(bitmap, seed, bits_offset, num_bits);
+    int64_t bitsOffset,
+    int64_t numBits) {
+  VELOX_DCHECK_GE(bitsOffset, 0);
+  VELOX_DCHECK_GE(numBits, 0);
+  return murmurHashBitmap64(bitmap, seed, bitsOffset, numBits);
 }
 
 } // namespace facebook::velox::parquet::arrow::internal
diff --git a/velox/dwio/parquet/writer/arrow/util/Hashing.h b/velox/dwio/parquet/writer/arrow/util/Hashing.h
index cadca7c6890..b183df953cf 100644
--- a/velox/dwio/parquet/writer/arrow/util/Hashing.h
+++ b/velox/dwio/parquet/writer/arrow/util/Hashing.h
@@ -16,7 +16,7 @@
 
 // Adapted from Apache Arrow.
 
-// Private header, not to be exported
+// Private header, not to be exported.
 
 #pragma once
 
@@ -46,9 +46,7 @@
 
 #include "velox/common/base/Exceptions.h"
 
-#define XXH_INLINE_ALL
-
-#include <xxhash.h>
+#include "velox/common/base/XxHashInline.h"
 
 namespace facebook::velox::parquet::arrow::internal {
 
@@ -62,12 +60,12 @@ typedef uint64_t hash_t;
 
 // Notes about the choice of a hash function.
 // - XXH3 is extremely fast on most data sizes, from small to huge;
-//   faster even than HW CRC-based hashing schemes
-// - our custom hash function for tiny values (< 16 bytes) is still
-//   significantly faster (~30%), at least on this machine and compiler
+//   Faster even than HW CRC-based hashing schemes.
+// - Our custom hash function for tiny values (< 16 bytes) is still.
+//   Significantly faster (~30%), at least on this machine and compiler.
 
 template <uint64_t AlgNum>
-inline hash_t ComputeStringHash(const void* data, int64_t length);
+inline hash_t computeStringHash(const void* data, int64_t length);
 
 /// \brief A hash function for bitmaps that can handle offsets and lengths in
 /// terms of number of bits. The hash only depends on the bits actually hashed.
@@ -75,35 +73,35 @@ inline hash_t ComputeStringHash(const void* data, int64_t length);
 /// It's the caller's responsibility to ensure that bits_offset + num_bits are
 /// readable from the bitmap.
 ///
-/// \pre bits_offset >= 0
-/// \pre num_bits >= 0
+/// \pre bits_offset >= 0.
+/// \pre num_bits >= 0.
 /// \pre (bits_offset + num_bits + 7) / 8 <= readable length in bytes from
-/// bitmap
+/// bitmap.
 ///
 /// \param bitmap The pointer to the bitmap.
-/// \param seed The seed for the hash function (useful when chaining hash
-/// functions). \param bits_offset The offset in bits relative to the start of
-/// the bitmap. \param num_bits The number of bits after the offset to be
-/// hashed.
-ARROW_EXPORT hash_t ComputeBitmapHash(
+/// \param seed The seed for the hash function (useful when chaining hash.
+/// Functions). \param bits_offset The offset in bits relative to the start of.
+/// The bitmap. \param num_bits The number of bits after the offset to be.
+/// Hashed.
+ARROW_EXPORT hash_t computeBitmapHash(
     const uint8_t* bitmap,
     hash_t seed,
-    int64_t bits_offset,
-    int64_t num_bits);
+    int64_t bitsOffset,
+    int64_t numBits);
 
 template <typename Scalar, uint64_t AlgNum>
 struct ScalarHelperBase {
-  static bool CompareScalars(Scalar u, Scalar v) {
+  static bool compareScalars(Scalar u, Scalar v) {
     return u == v;
   }
 
-  static hash_t ComputeHash(const Scalar& value) {
-    // Generic hash computation for scalars.  Simply apply the string hash
-    // to the bit representation of the value.
+  static hash_t computeHash(const Scalar& value) {
+    // Generic hash computation for scalars.  Simply apply the string hash.
+    // To the bit representation of the value.
 
     // XXX in the case of FP values, we'd like equal values to have the same
     // hash, even if they have different bit representations...
-    return ComputeStringHash<AlgNum>(&value, sizeof(value));
+    return computeStringHash<AlgNum>(&value, sizeof(value));
   }
 };
 
@@ -116,20 +114,20 @@ struct ScalarHelper<
     AlgNum,
     enable_if_t<std::is_integral<Scalar>::value>>
     : public ScalarHelperBase<Scalar, AlgNum> {
-  // ScalarHelper specialization for integers
+  // ScalarHelper specialization for integers.
 
-  static hash_t ComputeHash(const Scalar& value) {
+  static hash_t computeHash(const Scalar& value) {
     // Faster hash computation for integers.
 
-    // Two of xxhash's prime multipliers (which are chosen for their
+    // Two of xxhash's prime multipliers (which are chosen for their.
     // bit dispersion properties)
     static constexpr uint64_t multipliers[] = {
         11400714785074694791ULL, 14029467366897019727ULL};
 
-    // Multiplying by the prime number mixes the low bits into the high bits,
-    // then byte-swapping (which is a single CPU instruction) allows the
-    // combined high and low bits to participate in the initial hash table
-    // index.
+    // Multiplying by the prime number mixes the low bits into the high bits,.
+    // Then byte-swapping (which is a single CPU instruction) allows the.
+    // Combined high and low bits to participate in the initial hash table.
+    // Index.
     auto h = static_cast<hash_t>(value);
     return ::arrow::bit_util::ByteSwap(multipliers[AlgNum] * h);
   }
@@ -141,10 +139,10 @@ struct ScalarHelper<
     AlgNum,
     enable_if_t<std::is_same<std::string_view, Scalar>::value>>
     : public ScalarHelperBase<Scalar, AlgNum> {
-  // ScalarHelper specialization for std::string_view
+  // ScalarHelper specialization for std::string_view.
 
-  static hash_t ComputeHash(std::string_view value) {
-    return ComputeStringHash<AlgNum>(
+  static hash_t computeHash(std::string_view value) {
+    return computeStringHash<AlgNum>(
         value.data(), static_cast<int64_t>(value.size()));
   }
 };
@@ -155,9 +153,9 @@ struct ScalarHelper<
     AlgNum,
     enable_if_t<std::is_floating_point<Scalar>::value>>
     : public ScalarHelperBase<Scalar, AlgNum> {
-  // ScalarHelper specialization for reals
+  // ScalarHelper specialization for reals.
 
-  static bool CompareScalars(Scalar u, Scalar v) {
+  static bool compareScalars(Scalar u, Scalar v) {
     if (std::isnan(u)) {
       // XXX should we do a bit-precise comparison?
       return std::isnan(v);
@@ -167,10 +165,10 @@ struct ScalarHelper<
 };
 
 template <uint64_t AlgNum = 0>
-hash_t ComputeStringHash(const void* data, int64_t length) {
+hash_t computeStringHash(const void* data, int64_t length) {
   if (ARROW_PREDICT_TRUE(length <= 16)) {
-    // Specialize for small hash strings, as they are quite common as
-    // hash table keys.  Even XXH3 isn't quite as fast.
+    // Specialize for small hash strings, as they are quite common as.
+    // Hash table keys.  Even XXH3 isn't quite as fast.
     auto p = reinterpret_cast<const uint8_t*>(data);
     auto n = static_cast<uint32_t>(length);
     if (n <= 8) {
@@ -179,28 +177,28 @@ hash_t ComputeStringHash(const void* data, int64_t length) {
           return 1U;
         }
         uint32_t x = (n << 24) ^ (p[0] << 16) ^ (p[n / 2] << 8) ^ p[n - 1];
-        return ScalarHelper<uint32_t, AlgNum>::ComputeHash(x);
+        return ScalarHelper<uint32_t, AlgNum>::computeHash(x);
       }
-      // 4 <= length <= 8
-      // We can read the string as two overlapping 32-bit ints, apply
-      // different hash functions to each of them in parallel, then XOR
-      // the results
+      // 4 <= Length <= 8.
+      // We can read the string as two overlapping 32-bit ints, apply.
+      // Different hash functions to each of them in parallel, then XOR.
+      // The results.
       uint32_t x, y;
       hash_t hx, hy;
       x = ::arrow::util::SafeLoadAs<uint32_t>(p + n - 4);
       y = ::arrow::util::SafeLoadAs<uint32_t>(p);
-      hx = ScalarHelper<uint32_t, AlgNum>::ComputeHash(x);
-      hy = ScalarHelper<uint32_t, AlgNum ^ 1>::ComputeHash(y);
+      hx = ScalarHelper<uint32_t, AlgNum>::computeHash(x);
+      hy = ScalarHelper<uint32_t, AlgNum ^ 1>::computeHash(y);
       return n ^ hx ^ hy;
     }
-    // 8 <= length <= 16
-    // Apply the same principle as above
+    // 8 <= Length <= 16.
+    // Apply the same principle as above.
     uint64_t x, y;
     hash_t hx, hy;
     x = ::arrow::util::SafeLoadAs<uint64_t>(p + n - 8);
     y = ::arrow::util::SafeLoadAs<uint64_t>(p);
-    hx = ScalarHelper<uint64_t, AlgNum>::ComputeHash(x);
-    hy = ScalarHelper<uint64_t, AlgNum ^ 1>::ComputeHash(y);
+    hx = ScalarHelper<uint64_t, AlgNum>::computeHash(x);
+    hy = ScalarHelper<uint64_t, AlgNum ^ 1>::computeHash(y);
     return n ^ hx ^ hy;
   }
 
@@ -208,9 +206,9 @@ hash_t ComputeStringHash(const void* data, int64_t length) {
 #error XXH3_SECRET_SIZE_MIN changed, please fix kXxh3Secrets
 #endif
 
-  // XXH3_64bits_withSeed generates a secret based on the seed, which is too
-  // slow. Instead, we use hard-coded random secrets.  To maximize cache
-  // efficiency, they reuse the same memory area.
+  // XXH3_64bits_withSeed generates a secret based on the seed, which is too.
+  // Slow. Instead, we use hard-coded random secrets.  To maximize cache.
+  // Efficiency, they reuse the same memory area.
   static constexpr unsigned char kXxh3Secrets[XXH3_SECRET_SIZE_MIN + 1] = {
       0xe7, 0x8b, 0x13, 0xf9, 0xfc, 0xb5, 0x8e, 0xef, 0x81, 0x48, 0x2c, 0xbf,
       0xf9, 0x9f, 0xc1, 0x1e, 0x43, 0x6d, 0xbf, 0xa6, 0x6d, 0xb5, 0x72, 0xbc,
@@ -233,7 +231,7 @@ hash_t ComputeStringHash(const void* data, int64_t length) {
 
 // XXX add a HashEq<ArrowType> struct with both hash and compare functions?
 
-// ----------------------------------------------------------------------
+// ----------------------------------------------------------------------.
 // An open-addressing insert-only hash table (no deletes)
 
 template <typename Payload>
@@ -246,51 +244,51 @@ class HashTable {
     hash_t h;
     Payload payload;
 
-    // An entry is valid if the hash is different from the sentinel value
+    // An entry is valid if the hash is different from the sentinel value.
     operator bool() const {
       return h != kSentinel;
     }
   };
 
-  HashTable(MemoryPool* pool, uint64_t capacity) : entries_builder_(pool) {
+  HashTable(MemoryPool* pool, uint64_t capacity) : entriesBuilder_(pool) {
     VELOX_DCHECK_NOT_NULL(pool);
-    // Minimum of 32 elements
+    // Minimum of 32 elements.
     capacity = std::max<uint64_t>(capacity, 32UL);
     capacity_ = ::arrow::bit_util::NextPower2(capacity);
-    capacity_mask_ = capacity_ - 1;
+    capacityMask_ = capacity_ - 1;
     size_ = 0;
 
-    auto status = UpsizeBuffer(capacity_);
+    auto status = upsizeBuffer(capacity_);
     VELOX_DCHECK(status.ok(), status.ToString());
   }
 
-  // Lookup with non-linear probing
-  // cmp_func should have signature bool(const Payload*).
+  // Lookup with non-linear probing.
+  // Cmp_func should have signature bool(const Payload*).
   // Return a (Entry*, found) pair.
   template <typename CmpFunc>
-  std::pair<Entry*, bool> Lookup(hash_t h, CmpFunc&& cmp_func) {
-    auto p = Lookup<DoCompare, CmpFunc>(
-        h, entries_, capacity_mask_, std::forward<CmpFunc>(cmp_func));
+  std::pair<Entry*, bool> lookup(hash_t h, CmpFunc&& cmpFunc) {
+    auto p = lookup<DoCompare, CmpFunc>(
+        h, entries_, capacityMask_, std::forward<CmpFunc>(cmpFunc));
     return {&entries_[p.first], p.second};
   }
 
   template <typename CmpFunc>
-  std::pair<const Entry*, bool> Lookup(hash_t h, CmpFunc&& cmp_func) const {
-    auto p = Lookup<DoCompare, CmpFunc>(
-        h, entries_, capacity_mask_, std::forward<CmpFunc>(cmp_func));
+  std::pair<const Entry*, bool> lookup(hash_t h, CmpFunc&& cmpFunc) const {
+    auto p = lookup<DoCompare, CmpFunc>(
+        h, entries_, capacityMask_, std::forward<CmpFunc>(cmpFunc));
     return {&entries_[p.first], p.second};
   }
 
-  Status Insert(Entry* entry, hash_t h, const Payload& payload) {
-    // Ensure entry is empty before inserting
+  Status insert(Entry* entry, hash_t h, const Payload& payload) {
+    // Ensure entry is empty before inserting.
     assert(!*entry);
-    entry->h = FixHash(h);
+    entry->h = fixHash(h);
     entry->payload = payload;
     ++size_;
 
-    if (ARROW_PREDICT_FALSE(NeedUpsizing())) {
-      // Resize less frequently since it is expensive
-      return Upsize(capacity_ * kLoadFactor * 2);
+    if (ARROW_PREDICT_FALSE(needUpsizing())) {
+      // Resize less frequently since it is expensive.
+      return upsize(capacity_ * kLoadFactor * 2);
     }
     return Status::OK();
   }
@@ -299,129 +297,129 @@ class HashTable {
     return size_;
   }
 
-  // Visit all non-empty entries in the table
+  // Visit all non-empty entries in the table.
   // The visit_func should have signature void(const Entry*)
   template <typename VisitFunc>
-  void VisitEntries(VisitFunc&& visit_func) const {
+  void visitEntries(VisitFunc&& visitFunc) const {
     for (uint64_t i = 0; i < capacity_; i++) {
       const auto& entry = entries_[i];
       if (entry) {
-        visit_func(&entry);
+        visitFunc(&entry);
       }
     }
   }
 
  protected:
-  // NoCompare is for when the value is known not to exist in the table
+  // NoCompare is for when the value is known not to exist in the table.
   enum CompareKind { DoCompare, NoCompare };
 
-  // The workhorse lookup function
+  // The workhorse lookup function.
   template <CompareKind CKind, typename CmpFunc>
-  std::pair<uint64_t, bool> Lookup(
+  std::pair<uint64_t, bool> lookup(
       hash_t h,
       const Entry* entries,
-      uint64_t size_mask,
-      CmpFunc&& cmp_func) const {
-    static constexpr uint8_t perturb_shift = 5;
+      uint64_t sizeMask,
+      CmpFunc&& cmpFunc) const {
+    static constexpr uint8_t perturbShift = 5;
 
     uint64_t index, perturb;
     const Entry* entry;
 
-    h = FixHash(h);
-    index = h & size_mask;
-    perturb = (h >> perturb_shift) + 1U;
+    h = fixHash(h);
+    index = h & sizeMask;
+    perturb = (h >> perturbShift) + 1U;
 
     while (true) {
       entry = &entries[index];
-      if (CompareEntry<CKind, CmpFunc>(
-              h, entry, std::forward<CmpFunc>(cmp_func))) {
-        // Found
+      if (compareEntry<CKind, CmpFunc>(
+              h, entry, std::forward<CmpFunc>(cmpFunc))) {
+        // Found.
         return {index, true};
       }
       if (entry->h == kSentinel) {
-        // Empty slot
+        // Empty slot.
         return {index, false};
       }
 
       // Perturbation logic inspired from CPython's set / dict object.
-      // The goal is that all 64 bits of the unmasked hash value eventually
-      // participate in the probing sequence, to minimize clustering.
-      index = (index + perturb) & size_mask;
-      perturb = (perturb >> perturb_shift) + 1U;
+      // The goal is that all 64 bits of the unmasked hash value eventually.
+      // Participate in the probing sequence, to minimize clustering.
+      index = (index + perturb) & sizeMask;
+      perturb = (perturb >> perturbShift) + 1U;
     }
   }
 
   template <CompareKind CKind, typename CmpFunc>
-  bool CompareEntry(hash_t h, const Entry* entry, CmpFunc&& cmp_func) const {
+  bool compareEntry(hash_t h, const Entry* entry, CmpFunc&& cmpFunc) const {
     if (CKind == NoCompare) {
       return false;
     } else {
-      return entry->h == h && cmp_func(&entry->payload);
+      return entry->h == h && cmpFunc(&entry->payload);
     }
   }
 
-  bool NeedUpsizing() const {
-    // Keep the load factor <= 1/2
+  bool needUpsizing() const {
+    // Keep the load factor <= 1/2.
     return size_ * kLoadFactor >= capacity_;
   }
 
-  Status UpsizeBuffer(uint64_t capacity) {
-    RETURN_NOT_OK(entries_builder_.Resize(capacity));
-    entries_ = entries_builder_.mutable_data();
+  Status upsizeBuffer(uint64_t capacity) {
+    RETURN_NOT_OK(entriesBuilder_.Resize(capacity));
+    entries_ = entriesBuilder_.mutable_data();
     memset(static_cast<void*>(entries_), 0, capacity * sizeof(Entry));
 
     return Status::OK();
   }
 
-  Status Upsize(uint64_t new_capacity) {
-    assert(new_capacity > capacity_);
-    uint64_t new_mask = new_capacity - 1;
-    assert((new_capacity & new_mask) == 0); // it's a power of two
+  Status upsize(uint64_t newCapacity) {
+    assert(newCapacity > capacity_);
+    uint64_t newMask = newCapacity - 1;
+    assert((newCapacity & newMask) == 0); // it's a power of two
 
-    // Stash old entries and seal builder, effectively resetting the Buffer
-    const Entry* old_entries = entries_;
+    // Stash old entries and seal builder, effectively resetting the Buffer.
+    const Entry* oldEntries = entries_;
     ARROW_ASSIGN_OR_RAISE(
-        auto previous, entries_builder_.FinishWithLength(capacity_));
-    // Allocate new buffer
-    RETURN_NOT_OK(UpsizeBuffer(new_capacity));
+        auto previous, entriesBuilder_.FinishWithLength(capacity_));
+    // Allocate new buffer.
+    RETURN_NOT_OK(upsizeBuffer(newCapacity));
 
     for (uint64_t i = 0; i < capacity_; i++) {
-      const auto& entry = old_entries[i];
+      const auto& entry = oldEntries[i];
       if (entry) {
-        // Dummy compare function will not be called
-        auto p = Lookup<NoCompare>(
-            entry.h, entries_, new_mask, [](const Payload*) { return false; });
-        // Lookup<NoCompare> (and CompareEntry<NoCompare>) ensure that an
-        // empty slots is always returned
+        // Dummy compare function will not be called.
+        auto p = lookup<NoCompare>(
+            entry.h, entries_, newMask, [](const Payload*) { return false; });
+        // Lookup<NoCompare> (and CompareEntry<NoCompare>) ensure that an.
+        // Empty slots is always returned.
         assert(!p.second);
         entries_[p.first] = entry;
       }
     }
-    capacity_ = new_capacity;
-    capacity_mask_ = new_mask;
+    capacity_ = newCapacity;
+    capacityMask_ = newMask;
 
     return Status::OK();
   }
 
-  hash_t FixHash(hash_t h) const {
+  hash_t fixHash(hash_t h) const {
     return (h == kSentinel) ? 42U : h;
   }
 
   // The number of slots available in the hash table array.
   uint64_t capacity_;
-  uint64_t capacity_mask_;
+  uint64_t capacityMask_;
   // The number of used slots in the hash table array.
   uint64_t size_;
 
   Entry* entries_;
-  ::arrow::TypedBufferBuilder<Entry> entries_builder_;
+  ::arrow::TypedBufferBuilder<Entry> entriesBuilder_;
 };
 
 // XXX typedef memo_index_t int32_t ?
 
 constexpr int32_t kKeyNotFound = -1;
 
-// ----------------------------------------------------------------------
+// ----------------------------------------------------------------------.
 // A base class for memoization table.
 
 class MemoTable {
@@ -431,11 +429,11 @@ class MemoTable {
   virtual int32_t size() const = 0;
 };
 
-// ----------------------------------------------------------------------
+// ----------------------------------------------------------------------.
 // A memoization table for memory-cheap scalar values.
 
-// The memoization table remembers and allows to look up the insertion
-// index for each key.
+// The memoization table remembers and allows to look up the insertion.
+// Index for each key.
 
 template <
     typename Scalar,
@@ -443,131 +441,130 @@ template <
 class ScalarMemoTable : public MemoTable {
  public:
   explicit ScalarMemoTable(MemoryPool* pool, int64_t entries = 0)
-      : hash_table_(pool, static_cast<uint64_t>(entries)) {}
+      : hashTable_(pool, static_cast<uint64_t>(entries)) {}
 
-  int32_t Get(const Scalar& value) const {
-    auto cmp_func = [value](const Payload* payload) -> bool {
-      return ScalarHelper<Scalar, 0>::CompareScalars(payload->value, value);
+  int32_t get(const Scalar& value) const {
+    auto cmpFunc = [value](const Payload* payload) -> bool {
+      return ScalarHelper<Scalar, 0>::compareScalars(payload->value, value);
     };
-    hash_t h = ComputeHash(value);
-    auto p = hash_table_.Lookup(h, cmp_func);
+    hash_t h = computeHash(value);
+    auto p = hashTable_.lookup(h, cmpFunc);
     if (p.second) {
-      return p.first->payload.memo_index;
+      return p.first->payload.memoIndex;
     } else {
       return kKeyNotFound;
     }
   }
 
   template <typename Func1, typename Func2>
-  Status GetOrInsert(
+  Status getOrInsert(
       const Scalar& value,
-      Func1&& on_found,
-      Func2&& on_not_found,
-      int32_t* out_memo_index) {
-    auto cmp_func = [value](const Payload* payload) -> bool {
-      return ScalarHelper<Scalar, 0>::CompareScalars(value, payload->value);
+      Func1&& onFound,
+      Func2&& onNotFound,
+      int32_t* outMemoIndex) {
+    auto cmpFunc = [value](const Payload* payload) -> bool {
+      return ScalarHelper<Scalar, 0>::compareScalars(value, payload->value);
     };
-    hash_t h = ComputeHash(value);
-    auto p = hash_table_.Lookup(h, cmp_func);
-    int32_t memo_index;
+    hash_t h = computeHash(value);
+    auto p = hashTable_.lookup(h, cmpFunc);
+    int32_t memoIndex;
     if (p.second) {
-      memo_index = p.first->payload.memo_index;
-      on_found(memo_index);
+      memoIndex = p.first->payload.memoIndex;
+      onFound(memoIndex);
     } else {
-      memo_index = size();
-      RETURN_NOT_OK(hash_table_.Insert(p.first, h, {value, memo_index}));
-      on_not_found(memo_index);
+      memoIndex = size();
+      RETURN_NOT_OK(hashTable_.insert(p.first, h, {value, memoIndex}));
+      onNotFound(memoIndex);
     }
-    *out_memo_index = memo_index;
+    *outMemoIndex = memoIndex;
     return Status::OK();
   }
 
-  Status GetOrInsert(const Scalar& value, int32_t* out_memo_index) {
-    return GetOrInsert(
-        value, [](int32_t i) {}, [](int32_t i) {}, out_memo_index);
+  Status getOrInsert(const Scalar& value, int32_t* outMemoIndex) {
+    return getOrInsert(value, [](int32_t i) {}, [](int32_t i) {}, outMemoIndex);
   }
 
-  int32_t GetNull() const {
-    return null_index_;
+  int32_t getNull() const {
+    return nullIndex_;
   }
 
   template <typename Func1, typename Func2>
-  int32_t GetOrInsertNull(Func1&& on_found, Func2&& on_not_found) {
-    int32_t memo_index = GetNull();
-    if (memo_index != kKeyNotFound) {
-      on_found(memo_index);
+  int32_t getOrInsertNull(Func1&& onFound, Func2&& onNotFound) {
+    int32_t memoIndex = getNull();
+    if (memoIndex != kKeyNotFound) {
+      onFound(memoIndex);
     } else {
-      null_index_ = memo_index = size();
-      on_not_found(memo_index);
+      nullIndex_ = memoIndex = size();
+      onNotFound(memoIndex);
     }
-    return memo_index;
+    return memoIndex;
   }
 
-  int32_t GetOrInsertNull() {
-    return GetOrInsertNull([](int32_t i) {}, [](int32_t i) {});
+  int32_t getOrInsertNull() {
+    return getOrInsertNull([](int32_t i) {}, [](int32_t i) {});
   }
 
   // The number of entries in the memo table +1 if null was added.
   // (which is also 1 + the largest memo index)
   int32_t size() const override {
-    return static_cast<int32_t>(hash_table_.size()) +
-        (GetNull() != kKeyNotFound);
+    return static_cast<int32_t>(hashTable_.size()) +
+        (getNull() != kKeyNotFound);
   }
 
-  // Copy values starting from index `start` into `out_data`
-  void CopyValues(int32_t start, Scalar* out_data) const {
-    hash_table_.VisitEntries([=](const HashTableEntry* entry) {
-      int32_t index = entry->payload.memo_index - start;
+  // Copy values starting from index `start` into `out_data`.
+  void copyValues(int32_t start, Scalar* outData) const {
+    hashTable_.visitEntries([=](const HashTableEntry* entry) {
+      int32_t index = entry->payload.memoIndex - start;
       if (index >= 0) {
-        out_data[index] = entry->payload.value;
+        outData[index] = entry->payload.value;
       }
     });
-    // Zero-initialize the null entry
-    if (null_index_ != kKeyNotFound) {
-      int32_t index = null_index_ - start;
+    // Zero-initialize the null entry.
+    if (nullIndex_ != kKeyNotFound) {
+      int32_t index = nullIndex_ - start;
       if (index >= 0) {
-        out_data[index] = Scalar{};
+        outData[index] = Scalar{};
       }
     }
   }
 
-  void CopyValues(Scalar* out_data) const {
-    CopyValues(0, out_data);
+  void copyValues(Scalar* outData) const {
+    copyValues(0, outData);
   }
 
  protected:
   struct Payload {
     Scalar value;
-    int32_t memo_index;
+    int32_t memoIndex;
   };
 
   using HashTableType = HashTableTemplateType<Payload>;
   using HashTableEntry = typename HashTableType::Entry;
-  HashTableType hash_table_;
-  int32_t null_index_ = kKeyNotFound;
+  HashTableType hashTable_;
+  int32_t nullIndex_ = kKeyNotFound;
 
-  hash_t ComputeHash(const Scalar& value) const {
-    return ScalarHelper<Scalar, 0>::ComputeHash(value);
+  hash_t computeHash(const Scalar& value) const {
+    return ScalarHelper<Scalar, 0>::computeHash(value);
   }
 
  public:
-  // defined here so that `HashTableType` is visible
+  // Defined here so that `HashTableType` is visible.
   // Merge entries from `other_table` into `this->hash_table_`.
-  Status MergeTable(const ScalarMemoTable& other_table) {
-    const HashTableType& other_hashtable = other_table.hash_table_;
+  Status mergeTable(const ScalarMemoTable& otherTable) {
+    const HashTableType& otherHashtable = otherTable.hashTable_;
 
-    other_hashtable.VisitEntries([this](const HashTableEntry* other_entry) {
+    otherHashtable.visitEntries([this](const HashTableEntry* otherEntry) {
       int32_t unused;
-      auto status = this->GetOrInsert(other_entry->payload.value, &unused);
+      auto status = this->getOrInsert(otherEntry->payload.value, &unused);
       VELOX_DCHECK(status.ok(), status.ToString());
     });
-    // TODO: ARROW-17074 - implement proper error handling
+    // TODO: ARROW-17074 - implement proper error handling.
     return Status::OK();
   }
 };
 
-// ----------------------------------------------------------------------
-// A memoization table for small scalar values, using direct indexing
+// ----------------------------------------------------------------------.
+// A memoization table for small scalar values, using direct indexing.
 
 template <typename Scalar, typename Enable = void>
 struct SmallScalarTraits {};
@@ -576,7 +573,7 @@ template <>
 struct SmallScalarTraits<bool> {
   static constexpr int32_t cardinality = 2;
 
-  static uint32_t AsIndex(bool value) {
+  static uint32_t asIndex(bool value) {
     return value ? 1 : 0;
   }
 };
@@ -588,7 +585,7 @@ struct SmallScalarTraits<Scalar, enable_if_t<std::is_integral<Scalar>::value>> {
   static constexpr int32_t cardinality =
       1U + std::numeric_limits<Unsigned>::max();
 
-  static uint32_t AsIndex(Scalar value) {
+  static uint32_t asIndex(Scalar value) {
     return static_cast<Unsigned>(value);
   }
 };
@@ -599,94 +596,93 @@ template <
 class SmallScalarMemoTable : public MemoTable {
  public:
   explicit SmallScalarMemoTable(MemoryPool* pool, int64_t entries = 0) {
-    std::fill(value_to_index_, value_to_index_ + cardinality + 1, kKeyNotFound);
-    index_to_value_.reserve(cardinality);
+    std::fill(valueToIndex_, valueToIndex_ + cardinality + 1, kKeyNotFound);
+    indexToValue_.reserve(cardinality);
   }
 
-  int32_t Get(const Scalar value) const {
-    auto value_index = AsIndex(value);
-    return value_to_index_[value_index];
+  int32_t get(const Scalar value) const {
+    auto valueIndex = asIndex(value);
+    return valueToIndex_[valueIndex];
   }
 
   template <typename Func1, typename Func2>
-  Status GetOrInsert(
+  Status getOrInsert(
       const Scalar value,
-      Func1&& on_found,
-      Func2&& on_not_found,
-      int32_t* out_memo_index) {
-    auto value_index = AsIndex(value);
-    auto memo_index = value_to_index_[value_index];
-    if (memo_index == kKeyNotFound) {
-      memo_index = static_cast<int32_t>(index_to_value_.size());
-      index_to_value_.push_back(value);
-      value_to_index_[value_index] = memo_index;
-      VELOX_DCHECK_LT(memo_index, cardinality + 1);
-      on_not_found(memo_index);
+      Func1&& onFound,
+      Func2&& onNotFound,
+      int32_t* outMemoIndex) {
+    auto valueIndex = asIndex(value);
+    auto memoIndex = valueToIndex_[valueIndex];
+    if (memoIndex == kKeyNotFound) {
+      memoIndex = static_cast<int32_t>(indexToValue_.size());
+      indexToValue_.push_back(value);
+      valueToIndex_[valueIndex] = memoIndex;
+      VELOX_DCHECK_LT(memoIndex, cardinality + 1);
+      onNotFound(memoIndex);
     } else {
-      on_found(memo_index);
+      onFound(memoIndex);
     }
-    *out_memo_index = memo_index;
+    *outMemoIndex = memoIndex;
     return Status::OK();
   }
 
-  Status GetOrInsert(const Scalar value, int32_t* out_memo_index) {
-    return GetOrInsert(
-        value, [](int32_t i) {}, [](int32_t i) {}, out_memo_index);
+  Status getOrInsert(const Scalar value, int32_t* outMemoIndex) {
+    return getOrInsert(value, [](int32_t i) {}, [](int32_t i) {}, outMemoIndex);
   }
 
-  int32_t GetNull() const {
-    return value_to_index_[cardinality];
+  int32_t getNull() const {
+    return valueToIndex_[cardinality];
   }
 
   template <typename Func1, typename Func2>
-  int32_t GetOrInsertNull(Func1&& on_found, Func2&& on_not_found) {
-    auto memo_index = GetNull();
-    if (memo_index == kKeyNotFound) {
-      memo_index = value_to_index_[cardinality] = size();
-      index_to_value_.push_back(0);
-      on_not_found(memo_index);
+  int32_t getOrInsertNull(Func1&& onFound, Func2&& onNotFound) {
+    auto memoIndex = getNull();
+    if (memoIndex == kKeyNotFound) {
+      memoIndex = valueToIndex_[cardinality] = size();
+      indexToValue_.push_back(0);
+      onNotFound(memoIndex);
     } else {
-      on_found(memo_index);
+      onFound(memoIndex);
     }
-    return memo_index;
+    return memoIndex;
   }
 
-  int32_t GetOrInsertNull() {
-    return GetOrInsertNull([](int32_t i) {}, [](int32_t i) {});
+  int32_t getOrInsertNull() {
+    return getOrInsertNull([](int32_t i) {}, [](int32_t i) {});
   }
 
-  // The number of entries in the memo table
+  // The number of entries in the memo table.
   // (which is also 1 + the largest memo index)
   int32_t size() const override {
-    return static_cast<int32_t>(index_to_value_.size());
+    return static_cast<int32_t>(indexToValue_.size());
   }
 
   // Merge entries from `other_table` into `this`.
-  Status MergeTable(const SmallScalarMemoTable& other_table) {
-    for (const Scalar& other_val : other_table.index_to_value_) {
+  Status mergeTable(const SmallScalarMemoTable& otherTable) {
+    for (const Scalar& otherVal : otherTable.indexToValue_) {
       int32_t unused;
-      RETURN_NOT_OK(this->GetOrInsert(other_val, &unused));
+      RETURN_NOT_OK(this->getOrInsert(otherVal, &unused));
     }
     return Status::OK();
   }
 
-  // Copy values starting from index `start` into `out_data`
-  void CopyValues(int32_t start, Scalar* out_data) const {
+  // Copy values starting from index `start` into `out_data`.
+  void copyValues(int32_t start, Scalar* outData) const {
     VELOX_DCHECK_GE(start, 0);
-    VELOX_DCHECK_LE(static_cast<size_t>(start), index_to_value_.size());
+    VELOX_DCHECK_LE(static_cast<size_t>(start), indexToValue_.size());
     int64_t offset = start * static_cast<int32_t>(sizeof(Scalar));
     memcpy(
-        out_data,
-        index_to_value_.data() + offset,
+        outData,
+        indexToValue_.data() + offset,
         (size() - start) * sizeof(Scalar));
   }
 
-  void CopyValues(Scalar* out_data) const {
-    CopyValues(0, out_data);
+  void copyValues(Scalar* outData) const {
+    copyValues(0, outData);
   }
 
   const std::vector<Scalar>& values() const {
-    return index_to_value_;
+    return indexToValue_;
   }
 
  protected:
@@ -695,287 +691,285 @@ class SmallScalarMemoTable : public MemoTable {
       cardinality <= 256,
       "cardinality too large for direct-addressed table");
 
-  uint32_t AsIndex(Scalar value) const {
-    return SmallScalarTraits<Scalar>::AsIndex(value);
+  uint32_t asIndex(Scalar value) const {
+    return SmallScalarTraits<Scalar>::asIndex(value);
   }
 
   // The last index is reserved for the null element.
-  int32_t value_to_index_[cardinality + 1];
-  std::vector<Scalar> index_to_value_;
+  int32_t valueToIndex_[cardinality + 1];
+  std::vector<Scalar> indexToValue_;
 };
 
-// ----------------------------------------------------------------------
+// ----------------------------------------------------------------------.
 // A memoization table for variable-sized binary data.
 
 template <typename BinaryBuilderT>
 class BinaryMemoTable : public MemoTable {
  public:
-  using builder_offset_type = typename BinaryBuilderT::offset_type;
+  using BuilderOffsetType = typename BinaryBuilderT::offset_type;
   explicit BinaryMemoTable(
       MemoryPool* pool,
       int64_t entries = 0,
-      int64_t values_size = -1)
-      : hash_table_(pool, static_cast<uint64_t>(entries)),
-        binary_builder_(pool) {
-    const int64_t data_size = (values_size < 0) ? entries * 4 : values_size;
-    auto status = binary_builder_.Resize(entries);
+      int64_t valuesSize = -1)
+      : hashTable_(pool, static_cast<uint64_t>(entries)), binaryBuilder_(pool) {
+    const int64_t dataSize = (valuesSize < 0) ? entries * 4 : valuesSize;
+    auto status = binaryBuilder_.Reserve(entries);
     VELOX_DCHECK(status.ok(), status.ToString());
-    status = binary_builder_.ReserveData(data_size);
+    status = binaryBuilder_.ReserveData(dataSize);
     VELOX_DCHECK(status.ok(), status.ToString());
   }
 
-  int32_t Get(const void* data, builder_offset_type length) const {
-    hash_t h = ComputeStringHash<0>(data, length);
-    auto p = Lookup(h, data, length);
+  int32_t get(const void* data, BuilderOffsetType length) const {
+    hash_t h = computeStringHash<0>(data, length);
+    auto p = lookup(h, data, length);
     if (p.second) {
-      return p.first->payload.memo_index;
+      return p.first->payload.memoIndex;
     } else {
       return kKeyNotFound;
     }
   }
 
-  int32_t Get(std::string_view value) const {
-    return Get(value.data(), static_cast<builder_offset_type>(value.length()));
+  int32_t get(std::string_view value) const {
+    return get(value.data(), static_cast<BuilderOffsetType>(value.length()));
   }
 
   template <typename Func1, typename Func2>
-  Status GetOrInsert(
+  Status getOrInsert(
       const void* data,
-      builder_offset_type length,
-      Func1&& on_found,
-      Func2&& on_not_found,
-      int32_t* out_memo_index) {
-    hash_t h = ComputeStringHash<0>(data, length);
-    auto p = Lookup(h, data, length);
-    int32_t memo_index;
+      BuilderOffsetType length,
+      Func1&& onFound,
+      Func2&& onNotFound,
+      int32_t* outMemoIndex) {
+    hash_t h = computeStringHash<0>(data, length);
+    auto p = lookup(h, data, length);
+    int32_t memoIndex;
     if (p.second) {
-      memo_index = p.first->payload.memo_index;
-      on_found(memo_index);
+      memoIndex = p.first->payload.memoIndex;
+      onFound(memoIndex);
     } else {
-      memo_index = size();
-      // Insert string value
+      memoIndex = size();
+      // Insert string value.
       RETURN_NOT_OK(
-          binary_builder_.Append(static_cast<const char*>(data), length));
-      // Insert hash entry
-      RETURN_NOT_OK(hash_table_.Insert(
-          const_cast<HashTableEntry*>(p.first), h, {memo_index}));
+          binaryBuilder_.Append(static_cast<const char*>(data), length));
+      // Insert hash entry.
+      RETURN_NOT_OK(hashTable_.insert(
+          const_cast<HashTableEntry*>(p.first), h, {memoIndex}));
 
-      on_not_found(memo_index);
+      onNotFound(memoIndex);
     }
-    *out_memo_index = memo_index;
+    *outMemoIndex = memoIndex;
     return Status::OK();
   }
 
   template <typename Func1, typename Func2>
-  Status GetOrInsert(
+  Status getOrInsert(
       std::string_view value,
-      Func1&& on_found,
-      Func2&& on_not_found,
-      int32_t* out_memo_index) {
-    return GetOrInsert(
+      Func1&& onFound,
+      Func2&& onNotFound,
+      int32_t* outMemoIndex) {
+    return getOrInsert(
         value.data(),
-        static_cast<builder_offset_type>(value.length()),
-        std::forward<Func1>(on_found),
-        std::forward<Func2>(on_not_found),
-        out_memo_index);
+        static_cast<BuilderOffsetType>(value.length()),
+        std::forward<Func1>(onFound),
+        std::forward<Func2>(onNotFound),
+        outMemoIndex);
   }
 
-  Status GetOrInsert(
+  Status getOrInsert(
       const void* data,
-      builder_offset_type length,
-      int32_t* out_memo_index) {
-    return GetOrInsert(
-        data, length, [](int32_t i) {}, [](int32_t i) {}, out_memo_index);
+      BuilderOffsetType length,
+      int32_t* outMemoIndex) {
+    return getOrInsert(
+        data, length, [](int32_t i) {}, [](int32_t i) {}, outMemoIndex);
   }
 
-  Status GetOrInsert(std::string_view value, int32_t* out_memo_index) {
-    return GetOrInsert(
+  Status getOrInsert(std::string_view value, int32_t* outMemoIndex) {
+    return getOrInsert(
         value.data(),
-        static_cast<builder_offset_type>(value.length()),
-        out_memo_index);
+        static_cast<BuilderOffsetType>(value.length()),
+        outMemoIndex);
   }
 
-  int32_t GetNull() const {
-    return null_index_;
+  int32_t getNull() const {
+    return nullIndex_;
   }
 
   template <typename Func1, typename Func2>
-  int32_t GetOrInsertNull(Func1&& on_found, Func2&& on_not_found) {
-    int32_t memo_index = GetNull();
-    if (memo_index == kKeyNotFound) {
-      memo_index = null_index_ = size();
-      auto status = binary_builder_.AppendNull();
+  int32_t getOrInsertNull(Func1&& onFound, Func2&& onNotFound) {
+    int32_t memoIndex = getNull();
+    if (memoIndex == kKeyNotFound) {
+      memoIndex = nullIndex_ = size();
+      auto status = binaryBuilder_.AppendNull();
       VELOX_DCHECK(status.ok(), status.ToString());
-      on_not_found(memo_index);
+      onNotFound(memoIndex);
     } else {
-      on_found(memo_index);
+      onFound(memoIndex);
     }
-    return memo_index;
+    return memoIndex;
   }
 
-  int32_t GetOrInsertNull() {
-    return GetOrInsertNull([](int32_t i) {}, [](int32_t i) {});
+  int32_t getOrInsertNull() {
+    return getOrInsertNull([](int32_t i) {}, [](int32_t i) {});
   }
 
-  // The number of entries in the memo table
+  // The number of entries in the memo table.
   // (which is also 1 + the largest memo index)
   int32_t size() const override {
     return static_cast<int32_t>(
-        hash_table_.size() + (GetNull() != kKeyNotFound));
+        hashTable_.size() + (getNull() != kKeyNotFound));
   }
 
-  int64_t values_size() const {
-    return binary_builder_.value_data_length();
+  int64_t valuesSize() const {
+    return binaryBuilder_.value_data_length();
   }
 
-  // Copy (n + 1) offsets starting from index `start` into `out_data`
+  // Copy (n + 1) offsets starting from index `start` into `out_data`.
   template <class Offset>
-  void CopyOffsets(int32_t start, Offset* out_data) const {
+  void copyOffsets(int32_t start, Offset* outData) const {
     VELOX_DCHECK_LE(start, size());
 
-    const builder_offset_type* offsets = binary_builder_.offsets_data();
-    const builder_offset_type delta =
-        start < binary_builder_.length() ? offsets[start] : 0;
+    const BuilderOffsetType* offsets = binaryBuilder_.offsets_data();
+    const BuilderOffsetType delta =
+        start < binaryBuilder_.length() ? offsets[start] : 0;
     for (int32_t i = start; i < size(); ++i) {
-      const builder_offset_type adjusted_offset = offsets[i] - delta;
-      Offset cast_offset = static_cast<Offset>(adjusted_offset);
+      const BuilderOffsetType adjustedOffset = offsets[i] - delta;
+      Offset castOffset = static_cast<Offset>(adjustedOffset);
       assert(
-          static_cast<builder_offset_type>(cast_offset) ==
-          adjusted_offset); // avoid truncation
-      *out_data++ = cast_offset;
+          static_cast<BuilderOffsetType>(castOffset) ==
+          adjustedOffset); // avoid truncation
+      *outData++ = castOffset;
     }
 
     // Copy last value since BinaryBuilder only materializes it on in Finish()
-    *out_data =
-        static_cast<Offset>(binary_builder_.value_data_length() - delta);
+    *outData = static_cast<Offset>(binaryBuilder_.value_data_length() - delta);
   }
 
   template <class Offset>
-  void CopyOffsets(Offset* out_data) const {
-    CopyOffsets(0, out_data);
+  void copyOffsets(Offset* outData) const {
+    copyOffsets(0, outData);
   }
 
-  // Copy values starting from index `start` into `out_data`
-  void CopyValues(int32_t start, uint8_t* out_data) const {
-    CopyValues(start, -1, out_data);
+  // Copy values starting from index `start` into `out_data`.
+  void copyValues(int32_t start, uint8_t* outData) const {
+    copyValues(start, -1, outData);
   }
 
-  // Same as above, but check output size in debug mode
-  void CopyValues(int32_t start, int64_t out_size, uint8_t* out_data) const {
+  // Same as above, but check output size in debug mode.
+  void copyValues(int32_t start, int64_t outSize, uint8_t* outData) const {
     VELOX_DCHECK_LE(start, size());
 
     // The absolute byte offset of `start` value in the binary buffer.
-    const builder_offset_type offset = binary_builder_.offset(start);
+    const BuilderOffsetType offset = binaryBuilder_.offsets_data()[start];
     const auto length =
-        binary_builder_.value_data_length() - static_cast<size_t>(offset);
+        binaryBuilder_.value_data_length() - static_cast<size_t>(offset);
 
-    if (out_size != -1) {
-      assert(static_cast<int64_t>(length) <= out_size);
+    if (outSize != -1) {
+      assert(static_cast<int64_t>(length) <= outSize);
     }
 
-    auto view = binary_builder_.GetView(start);
-    memcpy(out_data, view.data(), length);
+    auto view = binaryBuilder_.GetView(start);
+    memcpy(outData, view.data(), length);
   }
 
-  void CopyValues(uint8_t* out_data) const {
-    CopyValues(0, -1, out_data);
+  void copyValues(uint8_t* outData) const {
+    copyValues(0, -1, outData);
   }
 
-  void CopyValues(int64_t out_size, uint8_t* out_data) const {
-    CopyValues(0, out_size, out_data);
+  void copyValues(int64_t outSize, uint8_t* outData) const {
+    copyValues(0, outSize, outData);
   }
 
-  void CopyFixedWidthValues(
+  void copyFixedWidthValues(
       int32_t start,
-      int32_t width_size,
-      int64_t out_size,
-      uint8_t* out_data) const {
-    // This method exists to cope with the fact that the BinaryMemoTable does
-    // not know the fixed width when inserting the null value. The data
-    // buffer hold a zero length string for the null value (if found).
+      int32_t widthSize,
+      int64_t outSize,
+      uint8_t* outData) const {
+    // This method exists to cope with the fact that the BinaryMemoTable does.
+    // Not know the fixed width when inserting the null value. The data.
+    // Buffer hold a zero length string for the null value (if found).
     //
-    // Thus, the method will properly inject an empty value of the proper width
-    // in the output buffer.
+    // Thus, the method will properly inject an empty value of the proper width.
+    // In the output buffer.
     //
     if (start >= size()) {
       return;
     }
 
-    int32_t null_index = GetNull();
-    if (null_index < start) {
+    int32_t nullIndex = getNull();
+    if (nullIndex < start) {
       // Nothing to skip, proceed as usual.
-      CopyValues(start, out_size, out_data);
+      copyValues(start, outSize, outData);
       return;
     }
 
-    builder_offset_type left_offset = binary_builder_.offset(start);
+    BuilderOffsetType leftOffset = binaryBuilder_.offsets_data()[start];
 
-    // Ensure that the data length is exactly missing width_size bytes to fit
-    // in the expected output (n_values * width_size).
+    // Ensure that the data length is exactly missing width_size bytes to fit.
+    // In the expected output (n_values * width_size).
 #ifndef NDEBUG
-    int64_t data_length = values_size() - static_cast<size_t>(left_offset);
-    assert(data_length + width_size == out_size);
-    ARROW_UNUSED(data_length);
+    int64_t dataLength = valuesSize() - static_cast<size_t>(leftOffset);
+    assert(dataLength + widthSize == outSize);
+    ARROW_UNUSED(dataLength);
 #endif
 
-    auto in_data = binary_builder_.value_data() + left_offset;
-    // The null use 0-length in the data, slice the data in 2 and skip by
-    // width_size in out_data. [part_1][width_size][part_2]
-    auto null_data_offset = binary_builder_.offset(null_index);
-    auto left_size = null_data_offset - left_offset;
-    if (left_size > 0) {
-      memcpy(out_data, in_data + left_offset, left_size);
+    auto inData = binaryBuilder_.value_data() + leftOffset;
+    // The null use 0-length in the data, slice the data in 2 and skip by.
+    // Width_size in out_data. [part_1][width_size][part_2].
+    auto nullDataOffset = binaryBuilder_.offsets_data()[nullIndex];
+    auto leftSize = nullDataOffset - leftOffset;
+    if (leftSize > 0) {
+      memcpy(outData, inData + leftOffset, leftSize);
     }
-    // Zero-initialize the null entry
-    memset(out_data + left_size, 0, width_size);
-
-    auto right_size = values_size() - static_cast<size_t>(null_data_offset);
-    if (right_size > 0) {
-      // skip the null fixed size value.
-      auto out_offset = left_size + width_size;
-      assert(out_data + out_offset + right_size == out_data + out_size);
-      memcpy(out_data + out_offset, in_data + null_data_offset, right_size);
+    // Zero-initialize the null entry.
+    memset(outData + leftSize, 0, widthSize);
+
+    auto rightSize = valuesSize() - static_cast<size_t>(nullDataOffset);
+    if (rightSize > 0) {
+      // Skip the null fixed size value.
+      auto outOffset = leftSize + widthSize;
+      assert(outData + outOffset + rightSize == outData + outSize);
+      memcpy(outData + outOffset, inData + nullDataOffset, rightSize);
     }
   }
 
   // Visit the stored values in insertion order.
-  // The visitor function should have the signature `void(std::string_view)`
-  // or `void(const std::string_view&)`.
+  // The visitor function should have the signature `void(std::string_view)`.
+  // Or `void(const std::string_view&)`.
   template <typename VisitFunc>
-  void VisitValues(int32_t start, VisitFunc&& visit) const {
+  void visitValues(int32_t start, VisitFunc&& visit) const {
     for (int32_t i = start; i < size(); ++i) {
-      auto sv = binary_builder_.GetView(i);
+      auto sv = binaryBuilder_.GetView(i);
       visit(std::string_view(sv.data(), sv.size()));
     }
   }
 
  protected:
   struct Payload {
-    int32_t memo_index;
+    int32_t memoIndex;
   };
 
   using HashTableType = HashTable<Payload>;
   using HashTableEntry = typename HashTable<Payload>::Entry;
-  HashTableType hash_table_;
-  BinaryBuilderT binary_builder_;
+  HashTableType hashTable_;
+  BinaryBuilderT binaryBuilder_;
 
-  int32_t null_index_ = kKeyNotFound;
+  int32_t nullIndex_ = kKeyNotFound;
 
   std::pair<const HashTableEntry*, bool>
-  Lookup(hash_t h, const void* data, builder_offset_type length) const {
-    auto cmp_func = [&](const Payload* payload) {
-      auto lhs = binary_builder_.GetView(payload->memo_index);
+  lookup(hash_t h, const void* data, BuilderOffsetType length) const {
+    auto cmpFunc = [&](const Payload* payload) {
+      auto lhs = binaryBuilder_.GetView(payload->memoIndex);
       auto rhs = std::string_view(static_cast<const char*>(data), length);
       return lhs == rhs;
     };
-    return hash_table_.Lookup(h, cmp_func);
+    return hashTable_.lookup(h, cmpFunc);
   }
 
  public:
-  Status MergeTable(const BinaryMemoTable& other_table) {
-    other_table.VisitValues(0, [this](std::string_view other_value) {
+  Status mergeTable(const BinaryMemoTable& otherTable) {
+    otherTable.visitValues(0, [this](std::string_view otherValue) {
       int32_t unused;
-      auto status = this->GetOrInsert(other_value, &unused);
+      auto status = this->getOrInsert(otherValue, &unused);
       VELOX_DCHECK(status.ok(), status.ToString());
     });
     return Status::OK();
@@ -992,8 +986,8 @@ struct HashTraits<::arrow::BooleanType> {
 
 template <typename T>
 struct HashTraits<T, ::arrow::enable_if_8bit_int<T>> {
-  using c_type = typename T::c_type;
-  using MemoTableType = SmallScalarMemoTable<typename T::c_type>;
+  using CType = typename T::CType;
+  using MemoTableType = SmallScalarMemoTable<typename T::CType>;
 };
 
 template <typename T>
@@ -1001,8 +995,8 @@ struct HashTraits<
     T,
     enable_if_t<
         ::arrow::has_c_type<T>::value && !::arrow::is_8bit_int<T>::value>> {
-  using c_type = typename T::c_type;
-  using MemoTableType = ScalarMemoTable<c_type, HashTable>;
+  using CType = typename T::CType;
+  using MemoTableType = ScalarMemoTable<CType, HashTable>;
 };
 
 template <typename T>
@@ -1027,35 +1021,35 @@ struct HashTraits<
 };
 
 template <typename MemoTableType>
-static inline Status ComputeNullBitmap(
+static inline Status computeNullBitmap(
     MemoryPool* pool,
-    const MemoTableType& memo_table,
-    int64_t start_offset,
-    int64_t* null_count,
-    std::shared_ptr<::arrow::Buffer>* null_bitmap) {
-  int64_t dict_length = static_cast<int64_t>(memo_table.size()) - start_offset;
-  int64_t null_index = memo_table.GetNull();
-
-  *null_count = 0;
-  *null_bitmap = nullptr;
-
-  if (null_index != kKeyNotFound && null_index >= start_offset) {
-    null_index -= start_offset;
-    *null_count = 1;
+    const MemoTableType& memoTable,
+    int64_t startOffset,
+    int64_t* nullCount,
+    std::shared_ptr<::arrow::Buffer>* nullBitmap) {
+  int64_t dictLength = static_cast<int64_t>(memoTable.size()) - startOffset;
+  int64_t nullIndex = memoTable.getNull();
+
+  *nullCount = 0;
+  *nullBitmap = nullptr;
+
+  if (nullIndex != kKeyNotFound && nullIndex >= startOffset) {
+    nullIndex -= startOffset;
+    *nullCount = 1;
     ARROW_ASSIGN_OR_RAISE(
-        *null_bitmap,
-        ::arrow::internal::BitmapAllButOne(pool, dict_length, null_index));
+        *nullBitmap,
+        ::arrow::internal::BitmapAllButOne(pool, dictLength, nullIndex));
   }
 
   return Status::OK();
 }
 
 struct StringViewHash {
-  // std::hash compatible hasher for use with std::unordered_*
-  // (the std::hash specialization provided by nonstd constructs std::string
+  // Std::hash compatible hasher for use with std::unordered_*.
+  // (The std::hash specialization provided by nonstd constructs std::string.
   // temporaries then invokes std::hash<std::string> against those)
   hash_t operator()(std::string_view value) const {
-    return ComputeStringHash<0>(
+    return computeStringHash<0>(
         value.data(), static_cast<int64_t>(value.size()));
   }
 };
diff --git a/velox/dwio/parquet/writer/arrow/util/OverflowUtilInternal.h b/velox/dwio/parquet/writer/arrow/util/OverflowUtilInternal.h
index 97efda714a8..c0c7d434c07 100644
--- a/velox/dwio/parquet/writer/arrow/util/OverflowUtilInternal.h
+++ b/velox/dwio/parquet/writer/arrow/util/OverflowUtilInternal.h
@@ -26,60 +26,60 @@
 #include "arrow/util/macros.h"
 #include "arrow/util/visibility.h"
 
-// "safe-math.h" includes <intsafe.h> from the Windows headers.
+// "Safe-math.h" includes <intsafe.h> from the Windows headers
 #include "arrow/util/windows_compatibility.h"
-// #include "arrow/vendored/portable-snippets/safe-math.h"
+// #include "arrow/vendored/portable-snippets/safe-math.h".
 #include "velox/dwio/parquet/writer/arrow/util/safe-math.h"
 // clang-format off (avoid include reordering)
 #include "arrow/util/windows_fixup.h"
-// clang-format on
+// clang-format on.
 
 namespace arrow {
 namespace internal {
 
-// Define functions AddWithOverflow, SubtractWithOverflow, MultiplyWithOverflow
+// Define functions AddWithOverflow, SubtractWithOverflow, MultiplyWithOverflow.
 // with the signature `bool(T u, T v, T* out)` where T is an integer type.
-// On overflow, these functions return true.  Otherwise, false is returned
+// on overflow, these functions return true.  Otherwise, false is returned.
 // and `out` is updated with the result of the operation.
 
-#define OP_WITH_OVERFLOW(_func_name, _psnip_op, _type, _psnip_type)           \
-  [[nodiscard]] static inline bool _func_name(_type u, _type v, _type* out) { \
-    return !psnip_safe_##_psnip_type##_##_psnip_op(out, u, v);                \
+#define OP_WITH_OVERFLOW(funcName, psnipOp, Type, PsnipType)             \
+  [[nodiscard]] static inline bool funcName(Type u, Type v, Type* out) { \
+    return !psnipSafe_##PsnipType##_##psnipOp(out, u, v);                \
   }
 
-#define OPS_WITH_OVERFLOW(_func_name, _psnip_op)            \
-  OP_WITH_OVERFLOW(_func_name, _psnip_op, int8_t, int8)     \
-  OP_WITH_OVERFLOW(_func_name, _psnip_op, int16_t, int16)   \
-  OP_WITH_OVERFLOW(_func_name, _psnip_op, int32_t, int32)   \
-  OP_WITH_OVERFLOW(_func_name, _psnip_op, int64_t, int64)   \
-  OP_WITH_OVERFLOW(_func_name, _psnip_op, uint8_t, uint8)   \
-  OP_WITH_OVERFLOW(_func_name, _psnip_op, uint16_t, uint16) \
-  OP_WITH_OVERFLOW(_func_name, _psnip_op, uint32_t, uint32) \
-  OP_WITH_OVERFLOW(_func_name, _psnip_op, uint64_t, uint64)
-
-OPS_WITH_OVERFLOW(AddWithOverflow, add)
+#define OPS_WITH_OVERFLOW(funcName, psnipOp)            \
+  OP_WITH_OVERFLOW(funcName, psnipOp, int8_t, int8)     \
+  OP_WITH_OVERFLOW(funcName, psnipOp, int16_t, int16)   \
+  OP_WITH_OVERFLOW(funcName, psnipOp, int32_t, int32)   \
+  OP_WITH_OVERFLOW(funcName, psnipOp, int64_t, int64)   \
+  OP_WITH_OVERFLOW(funcName, psnipOp, uint8_t, uint8)   \
+  OP_WITH_OVERFLOW(funcName, psnipOp, uint16_t, uint16) \
+  OP_WITH_OVERFLOW(funcName, psnipOp, uint32_t, uint32) \
+  OP_WITH_OVERFLOW(funcName, psnipOp, uint64_t, uint64)
+
+OPS_WITH_OVERFLOW(addWithOverflow, add)
 OPS_WITH_OVERFLOW(SubtractWithOverflow, sub)
-OPS_WITH_OVERFLOW(MultiplyWithOverflow, mul)
+OPS_WITH_OVERFLOW(multiplyWithOverflow, mul)
 OPS_WITH_OVERFLOW(DivideWithOverflow, div)
 
 #undef OP_WITH_OVERFLOW
 #undef OPS_WITH_OVERFLOW
 
-// Define function NegateWithOverflow with the signature `bool(T u, T* out)`
+// Define function NegateWithOverflow with the signature `bool(T u, T* out)`.
 // where T is a signed integer type.  On overflow, these functions return true.
-// Otherwise, false is returned and `out` is updated with the result of the
+// otherwise, false is returned and `out` is updated with the result of the.
 // operation.
 
-#define UNARY_OP_WITH_OVERFLOW(_func_name, _psnip_op, _type, _psnip_type) \
-  [[nodiscard]] static inline bool _func_name(_type u, _type* out) {      \
-    return !psnip_safe_##_psnip_type##_##_psnip_op(out, u);               \
+#define UNARY_OP_WITH_OVERFLOW(funcName, psnipOp, Type, PsnipType) \
+  [[nodiscard]] static inline bool funcName(Type u, Type* out) {   \
+    return !psnipSafe_##PsnipType##_##psnipOp(out, u);             \
   }
 
-#define SIGNED_UNARY_OPS_WITH_OVERFLOW(_func_name, _psnip_op)   \
-  UNARY_OP_WITH_OVERFLOW(_func_name, _psnip_op, int8_t, int8)   \
-  UNARY_OP_WITH_OVERFLOW(_func_name, _psnip_op, int16_t, int16) \
-  UNARY_OP_WITH_OVERFLOW(_func_name, _psnip_op, int32_t, int32) \
-  UNARY_OP_WITH_OVERFLOW(_func_name, _psnip_op, int64_t, int64)
+#define SIGNED_UNARY_OPS_WITH_OVERFLOW(funcName, psnipOp)   \
+  UNARY_OP_WITH_OVERFLOW(funcName, psnipOp, int8_t, int8)   \
+  UNARY_OP_WITH_OVERFLOW(funcName, psnipOp, int16_t, int16) \
+  UNARY_OP_WITH_OVERFLOW(funcName, psnipOp, int32_t, int32) \
+  UNARY_OP_WITH_OVERFLOW(funcName, psnipOp, int64_t, int64)
 
 SIGNED_UNARY_OPS_WITH_OVERFLOW(NegateWithOverflow, neg)
 
@@ -88,7 +88,7 @@ SIGNED_UNARY_OPS_WITH_OVERFLOW(NegateWithOverflow, neg)
 
 /// Signed addition with well-defined behaviour on overflow (as unsigned)
 template <typename SignedInt>
-SignedInt SafeSignedAdd(SignedInt u, SignedInt v) {
+SignedInt safeSignedAdd(SignedInt u, SignedInt v) {
   using UnsignedInt = typename std::make_unsigned<SignedInt>::type;
   return static_cast<SignedInt>(
       static_cast<UnsignedInt>(u) + static_cast<UnsignedInt>(v));
@@ -96,7 +96,7 @@ SignedInt SafeSignedAdd(SignedInt u, SignedInt v) {
 
 /// Signed subtraction with well-defined behaviour on overflow (as unsigned)
 template <typename SignedInt>
-SignedInt SafeSignedSubtract(SignedInt u, SignedInt v) {
+SignedInt safeSignedSubtract(SignedInt u, SignedInt v) {
   using UnsignedInt = typename std::make_unsigned<SignedInt>::type;
   return static_cast<SignedInt>(
       static_cast<UnsignedInt>(u) - static_cast<UnsignedInt>(v));
@@ -104,15 +104,15 @@ SignedInt SafeSignedSubtract(SignedInt u, SignedInt v) {
 
 /// Signed negation with well-defined behaviour on overflow (as unsigned)
 template <typename SignedInt>
-SignedInt SafeSignedNegate(SignedInt u) {
+SignedInt safeSignedNegate(SignedInt u) {
   using UnsignedInt = typename std::make_unsigned<SignedInt>::type;
   return static_cast<SignedInt>(~static_cast<UnsignedInt>(u) + 1);
 }
 
-/// Signed left shift with well-defined behaviour on negative numbers or
-/// overflow
+/// Signed left shift with well-defined behaviour on negative numbers or.
+/// overflow.
 template <typename SignedInt, typename Shift>
-SignedInt SafeLeftShift(SignedInt u, Shift shift) {
+SignedInt safeLeftShift(SignedInt u, Shift shift) {
   using UnsignedInt = typename std::make_unsigned<SignedInt>::type;
   return static_cast<SignedInt>(static_cast<UnsignedInt>(u) << shift);
 }
diff --git a/velox/dwio/parquet/writer/arrow/util/VisitArrayInline.h b/velox/dwio/parquet/writer/arrow/util/VisitArrayInline.h
index 886f4b0451e..cd4f1be452b 100644
--- a/velox/dwio/parquet/writer/arrow/util/VisitArrayInline.h
+++ b/velox/dwio/parquet/writer/arrow/util/VisitArrayInline.h
@@ -24,24 +24,23 @@
 
 namespace facebook::velox::parquet::arrow::util {
 
-#define ARRAY_VISIT_INLINE(TYPE_CLASS)                                         \
-  case ::arrow::TYPE_CLASS##Type::type_id:                                     \
-    return visitor->Visit(                                                     \
-        ::arrow::internal::checked_cast<                                       \
-            const typename TypeTraits<::arrow::TYPE_CLASS##Type>::ArrayType&>( \
-            array),                                                            \
+#define ARRAY_VISIT_INLINE(TYPE_CLASS)                                      \
+  case ::arrow::TYPE_CLASS##Type::type_id:                                  \
+    return visitor->visit(                                                  \
+        ::arrow::internal::checked_cast<const typename ::arrow::TypeTraits< \
+            ::arrow::TYPE_CLASS##Type>::ArrayType&>(array),                 \
         std::forward<ARGS>(args)...);
 
-/// \brief Apply the visitors Visit() method specialized to the array type
+/// \brief Apply the visitors Visit() method specialized to the array type.
 ///
 /// \tparam VISITOR Visitor type that implements Visit() for all array types.
-/// \tparam ARGS Additional arguments, if any, will be passed to the Visit
-/// function after the `arr` argument \return Status
+/// \tparam ARGS Additional arguments, if any, will be passed to the Visit.
+/// Function after the `arr` argument \return Status.
 ///
 /// A visitor is a type that implements specialized logic for each Arrow type.
 /// Example usage:
 ///
-/// ```
+/// ```.
 /// class ExampleVisitor {
 ///   arrow::Status Visit(arrow::NumericArray<Int32Type> arr) { ... }
 ///   arrow::Status Visit(arrow::NumericArray<Int64Type> arr) { ... }
@@ -49,10 +48,10 @@ namespace facebook::velox::parquet::arrow::util {
 /// }
 /// ExampleVisitor visitor;
 /// VisitArrayInline(some_array, &visitor);
-/// ```
+/// ```.
 template <typename VISITOR, typename... ARGS>
 inline Status
-VisitArrayInline(const Array& array, VISITOR* visitor, ARGS&&... args) {
+visitArrayInline(const Array& array, VISITOR* visitor, ARGS&&... args) {
   switch (array.type_id()) {
     ARROW_GENERATE_FOR_ALL_TYPES(ARRAY_VISIT_INLINE);
     default:
diff --git a/velox/dwio/parquet/writer/arrow/util/safe-math.h b/velox/dwio/parquet/writer/arrow/util/safe-math.h
index 661b62887bc..2164e60355e 100644
--- a/velox/dwio/parquet/writer/arrow/util/safe-math.h
+++ b/velox/dwio/parquet/writer/arrow/util/safe-math.h
@@ -75,39 +75,39 @@
   PSNIP_SAFE__COMPILER_ATTRIBUTES static PSNIP_SAFE__INLINE
 #endif
 
-// !defined(__cplusplus) added for Solaris support
+// !Defined(__cplusplus) added for Solaris support.
 #if !defined(__cplusplus) && defined(__STDC_VERSION__) && \
     __STDC_VERSION__ >= 199901L
-#define psnip_safe_bool _Bool
+#define psnipSafeBool bool
 #else
-#define psnip_safe_bool int
+#define psnipSafeBool int
 #endif
 
 #if !defined(PSNIP_SAFE_NO_FIXED)
 /* For maximum portability include the exact-int module from
    portable snippets. */
-#if !defined(psnip_int64_t) || !defined(psnip_uint64_t) || \
-    !defined(psnip_int32_t) || !defined(psnip_uint32_t) || \
-    !defined(psnip_int16_t) || !defined(psnip_uint16_t) || \
+#if !defined(Psnip_int64_t) || !defined(Psnip_uint64_t) || \
+    !defined(Psnip_int32_t) || !defined(Psnip_uint32_t) || \
+    !defined(Psnip_int16_t) || !defined(Psnip_uint16_t) || \
     !defined(psnip_int8_t) || !defined(psnip_uint8_t)
 #include <stdint.h>
-#if !defined(psnip_int64_t)
-#define psnip_int64_t int64_t
+#if !defined(Psnip_int64_t)
+#define Psnip_int64_t int64_t
 #endif
-#if !defined(psnip_uint64_t)
-#define psnip_uint64_t uint64_t
+#if !defined(Psnip_uint64_t)
+#define Psnip_uint64_t uint64_t
 #endif
-#if !defined(psnip_int32_t)
-#define psnip_int32_t int32_t
+#if !defined(Psnip_int32_t)
+#define Psnip_int32_t int32_t
 #endif
-#if !defined(psnip_uint32_t)
-#define psnip_uint32_t uint32_t
+#if !defined(Psnip_uint32_t)
+#define Psnip_uint32_t uint32_t
 #endif
-#if !defined(psnip_int16_t)
-#define psnip_int16_t int16_t
+#if !defined(Psnip_int16_t)
+#define Psnip_int16_t int16_t
 #endif
-#if !defined(psnip_uint16_t)
-#define psnip_uint16_t uint16_t
+#if !defined(Psnip_uint16_t)
+#define Psnip_uint16_t uint16_t
 #endif
 #if !defined(psnip_int8_t)
 #define psnip_int8_t int8_t
@@ -154,16 +154,16 @@
 
 #if !defined(PSNIP_SAFE_NO_PROMOTIONS)
 
-#define PSNIP_SAFE_DEFINE_LARGER_BINARY_OP(T, name, op_name, op)             \
-  PSNIP_SAFE__FUNCTION psnip_safe_##name##_larger                            \
-      psnip_safe_larger_##name##_##op_name(T a, T b) {                       \
-    return ((psnip_safe_##name##_larger)a)op((psnip_safe_##name##_larger)b); \
+#define PSNIP_SAFE_DEFINE_LARGER_BINARY_OP(T, name, opName, op)        \
+  PSNIP_SAFE__FUNCTION psnipSafe##name##Larger                         \
+  psnipSafeLarger_##name##_##opName(T a, T b) {                        \
+    return ((psnipSafe##name##Larger)a)op((psnipSafe##name##Larger)b); \
   }
 
-#define PSNIP_SAFE_DEFINE_LARGER_UNARY_OP(T, name, op_name, op) \
-  PSNIP_SAFE__FUNCTION psnip_safe_##name##_larger               \
-      psnip_safe_larger_##name##_##op_name(T value) {           \
-    return (op((psnip_safe_##name##_larger)value));             \
+#define PSNIP_SAFE_DEFINE_LARGER_UNARY_OP(T, name, opName, op) \
+  PSNIP_SAFE__FUNCTION psnipSafe##name##Larger                 \
+  psnipSafeLarger_##name##_##opName(T value) {                 \
+    return (op((psnipSafe##name##Larger)value));               \
   }
 
 #define PSNIP_SAFE_DEFINE_LARGER_SIGNED_OPS(T, name)  \
@@ -188,235 +188,235 @@
     ((__GNUC__ >= 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && \
     defined(__SIZEOF_INT128__) && !defined(__ibmxl__)
 #define PSNIP_SAFE_HAVE_128
-typedef __int128 psnip_safe_int128_t;
-typedef unsigned __int128 psnip_safe_uint128_t;
+typedef __int128 Psnip_safe_int128_t;
+typedef unsigned __int128 Psnip_safe_uint128_t;
 #endif /* defined(__GNUC__) */
 
 #if !defined(PSNIP_SAFE_NO_FIXED)
 #define PSNIP_SAFE_HAVE_INT8_LARGER
 #define PSNIP_SAFE_HAVE_UINT8_LARGER
-typedef psnip_int16_t psnip_safe_int8_larger;
-typedef psnip_uint16_t psnip_safe_uint8_larger;
+typedef Psnip_int16_t psnipSafeint8Larger;
+typedef Psnip_uint16_t psnipSafeuint8Larger;
 
 #define PSNIP_SAFE_HAVE_INT16_LARGER
-typedef psnip_int32_t psnip_safe_int16_larger;
-typedef psnip_uint32_t psnip_safe_uint16_larger;
+typedef Psnip_int32_t psnipSafeint16Larger;
+typedef Psnip_uint32_t psnipSafeuint16Larger;
 
 #define PSNIP_SAFE_HAVE_INT32_LARGER
-typedef psnip_int64_t psnip_safe_int32_larger;
-typedef psnip_uint64_t psnip_safe_uint32_larger;
+typedef Psnip_int64_t psnipSafeint32Larger;
+typedef Psnip_uint64_t psnipSafeuint32Larger;
 
 #if defined(PSNIP_SAFE_HAVE_128)
 #define PSNIP_SAFE_HAVE_INT64_LARGER
-typedef psnip_safe_int128_t psnip_safe_int64_larger;
-typedef psnip_safe_uint128_t psnip_safe_uint64_larger;
+typedef Psnip_safe_int128_t psnipSafeint64Larger;
+typedef Psnip_safe_uint128_t psnipSafeuint64Larger;
 #endif /* defined(PSNIP_SAFE_HAVE_128) */
 #endif /* !defined(PSNIP_SAFE_NO_FIXED) */
 
 #define PSNIP_SAFE_HAVE_LARGER_SCHAR
 #if PSNIP_SAFE_IS_LARGER(SCHAR_MAX, SHRT_MAX)
-typedef short psnip_safe_schar_larger;
+typedef short psnipSafescharLarger;
 #elif PSNIP_SAFE_IS_LARGER(SCHAR_MAX, INT_MAX)
-typedef int psnip_safe_schar_larger;
+typedef int psnipSafescharLarger;
 #elif PSNIP_SAFE_IS_LARGER(SCHAR_MAX, LONG_MAX)
-typedef long psnip_safe_schar_larger;
+typedef long psnipSafescharLarger;
 #elif PSNIP_SAFE_IS_LARGER(SCHAR_MAX, LLONG_MAX)
-typedef long long psnip_safe_schar_larger;
+typedef long long psnipSafescharLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(SCHAR_MAX, 0x7fff)
-typedef psnip_int16_t psnip_safe_schar_larger;
+typedef Psnip_int16_t psnipSafescharLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && \
     PSNIP_SAFE_IS_LARGER(SCHAR_MAX, 0x7fffffffLL)
-typedef psnip_int32_t psnip_safe_schar_larger;
+typedef Psnip_int32_t psnipSafescharLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && \
     PSNIP_SAFE_IS_LARGER(SCHAR_MAX, 0x7fffffffffffffffLL)
-typedef psnip_int64_t psnip_safe_schar_larger;
+typedef Psnip_int64_t psnipSafescharLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && defined(PSNIP_SAFE_HAVE_128) && \
     (SCHAR_MAX <= 0x7fffffffffffffffLL)
-typedef psnip_safe_int128_t psnip_safe_schar_larger;
+typedef Psnip_safe_int128_t psnipSafescharLarger;
 #else
 #undef PSNIP_SAFE_HAVE_LARGER_SCHAR
 #endif
 
 #define PSNIP_SAFE_HAVE_LARGER_UCHAR
 #if PSNIP_SAFE_IS_LARGER(UCHAR_MAX, USHRT_MAX)
-typedef unsigned short psnip_safe_uchar_larger;
+typedef unsigned short psnipSafeucharLarger;
 #elif PSNIP_SAFE_IS_LARGER(UCHAR_MAX, UINT_MAX)
-typedef unsigned int psnip_safe_uchar_larger;
+typedef unsigned int psnipSafeucharLarger;
 #elif PSNIP_SAFE_IS_LARGER(UCHAR_MAX, ULONG_MAX)
-typedef unsigned long psnip_safe_uchar_larger;
+typedef unsigned long psnipSafeucharLarger;
 #elif PSNIP_SAFE_IS_LARGER(UCHAR_MAX, ULLONG_MAX)
-typedef unsigned long long psnip_safe_uchar_larger;
+typedef unsigned long long psnipSafeucharLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(UCHAR_MAX, 0xffffU)
-typedef psnip_uint16_t psnip_safe_uchar_larger;
+typedef Psnip_uint16_t psnipSafeucharLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && \
     PSNIP_SAFE_IS_LARGER(UCHAR_MAX, 0xffffffffUL)
-typedef psnip_uint32_t psnip_safe_uchar_larger;
+typedef Psnip_uint32_t psnipSafeucharLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && \
     PSNIP_SAFE_IS_LARGER(UCHAR_MAX, 0xffffffffffffffffULL)
-typedef psnip_uint64_t psnip_safe_uchar_larger;
+typedef Psnip_uint64_t psnipSafeucharLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && defined(PSNIP_SAFE_HAVE_128) && \
     (UCHAR_MAX <= 0xffffffffffffffffULL)
-typedef psnip_safe_uint128_t psnip_safe_uchar_larger;
+typedef Psnip_safe_uint128_t psnipSafeucharLarger;
 #else
 #undef PSNIP_SAFE_HAVE_LARGER_UCHAR
 #endif
 
 #if CHAR_MIN == 0 && defined(PSNIP_SAFE_HAVE_LARGER_UCHAR)
 #define PSNIP_SAFE_HAVE_LARGER_CHAR
-typedef psnip_safe_uchar_larger psnip_safe_char_larger;
+typedef psnipSafeucharLarger psnipSafecharLarger;
 #elif CHAR_MIN < 0 && defined(PSNIP_SAFE_HAVE_LARGER_SCHAR)
 #define PSNIP_SAFE_HAVE_LARGER_CHAR
-typedef psnip_safe_schar_larger psnip_safe_char_larger;
+typedef psnipSafescharLarger psnipSafecharLarger;
 #endif
 
 #define PSNIP_SAFE_HAVE_LARGER_SHRT
 #if PSNIP_SAFE_IS_LARGER(SHRT_MAX, INT_MAX)
-typedef int psnip_safe_short_larger;
+typedef int psnipSafeshortLarger;
 #elif PSNIP_SAFE_IS_LARGER(SHRT_MAX, LONG_MAX)
-typedef long psnip_safe_short_larger;
+typedef long psnipSafeshortLarger;
 #elif PSNIP_SAFE_IS_LARGER(SHRT_MAX, LLONG_MAX)
-typedef long long psnip_safe_short_larger;
+typedef long long psnipSafeshortLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(SHRT_MAX, 0x7fff)
-typedef psnip_int16_t psnip_safe_short_larger;
+typedef Psnip_int16_t psnipSafeshortLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && \
     PSNIP_SAFE_IS_LARGER(SHRT_MAX, 0x7fffffffLL)
-typedef psnip_int32_t psnip_safe_short_larger;
+typedef Psnip_int32_t psnipSafeshortLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && \
     PSNIP_SAFE_IS_LARGER(SHRT_MAX, 0x7fffffffffffffffLL)
-typedef psnip_int64_t psnip_safe_short_larger;
+typedef Psnip_int64_t psnipSafeshortLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && defined(PSNIP_SAFE_HAVE_128) && \
     (SHRT_MAX <= 0x7fffffffffffffffLL)
-typedef psnip_safe_int128_t psnip_safe_short_larger;
+typedef Psnip_safe_int128_t psnipSafeshortLarger;
 #else
 #undef PSNIP_SAFE_HAVE_LARGER_SHRT
 #endif
 
 #define PSNIP_SAFE_HAVE_LARGER_USHRT
 #if PSNIP_SAFE_IS_LARGER(USHRT_MAX, UINT_MAX)
-typedef unsigned int psnip_safe_ushort_larger;
+typedef unsigned int psnipSafeushortLarger;
 #elif PSNIP_SAFE_IS_LARGER(USHRT_MAX, ULONG_MAX)
-typedef unsigned long psnip_safe_ushort_larger;
+typedef unsigned long psnipSafeushortLarger;
 #elif PSNIP_SAFE_IS_LARGER(USHRT_MAX, ULLONG_MAX)
-typedef unsigned long long psnip_safe_ushort_larger;
+typedef unsigned long long psnipSafeushortLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(USHRT_MAX, 0xffff)
-typedef psnip_uint16_t psnip_safe_ushort_larger;
+typedef Psnip_uint16_t psnipSafeushortLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && \
     PSNIP_SAFE_IS_LARGER(USHRT_MAX, 0xffffffffUL)
-typedef psnip_uint32_t psnip_safe_ushort_larger;
+typedef Psnip_uint32_t psnipSafeushortLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && \
     PSNIP_SAFE_IS_LARGER(USHRT_MAX, 0xffffffffffffffffULL)
-typedef psnip_uint64_t psnip_safe_ushort_larger;
+typedef Psnip_uint64_t psnipSafeushortLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && defined(PSNIP_SAFE_HAVE_128) && \
     (USHRT_MAX <= 0xffffffffffffffffULL)
-typedef psnip_safe_uint128_t psnip_safe_ushort_larger;
+typedef Psnip_safe_uint128_t psnipSafeushortLarger;
 #else
 #undef PSNIP_SAFE_HAVE_LARGER_USHRT
 #endif
 
 #define PSNIP_SAFE_HAVE_LARGER_INT
 #if PSNIP_SAFE_IS_LARGER(INT_MAX, LONG_MAX)
-typedef long psnip_safe_int_larger;
+typedef long psnipSafeintLarger;
 #elif PSNIP_SAFE_IS_LARGER(INT_MAX, LLONG_MAX)
-typedef long long psnip_safe_int_larger;
+typedef long long psnipSafeintLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(INT_MAX, 0x7fff)
-typedef psnip_int16_t psnip_safe_int_larger;
+typedef Psnip_int16_t psnipSafeintLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && \
     PSNIP_SAFE_IS_LARGER(INT_MAX, 0x7fffffffLL)
-typedef psnip_int32_t psnip_safe_int_larger;
+typedef Psnip_int32_t psnipSafeintLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && \
     PSNIP_SAFE_IS_LARGER(INT_MAX, 0x7fffffffffffffffLL)
-typedef psnip_int64_t psnip_safe_int_larger;
+typedef Psnip_int64_t psnipSafeintLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && defined(PSNIP_SAFE_HAVE_128) && \
     (INT_MAX <= 0x7fffffffffffffffLL)
-typedef psnip_safe_int128_t psnip_safe_int_larger;
+typedef Psnip_safe_int128_t psnipSafeintLarger;
 #else
 #undef PSNIP_SAFE_HAVE_LARGER_INT
 #endif
 
 #define PSNIP_SAFE_HAVE_LARGER_UINT
 #if PSNIP_SAFE_IS_LARGER(UINT_MAX, ULONG_MAX)
-typedef unsigned long psnip_safe_uint_larger;
+typedef unsigned long psnipSafeuintLarger;
 #elif PSNIP_SAFE_IS_LARGER(UINT_MAX, ULLONG_MAX)
-typedef unsigned long long psnip_safe_uint_larger;
+typedef unsigned long long psnipSafeuintLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(UINT_MAX, 0xffff)
-typedef psnip_uint16_t psnip_safe_uint_larger;
+typedef Psnip_uint16_t psnipSafeuintLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && \
     PSNIP_SAFE_IS_LARGER(UINT_MAX, 0xffffffffUL)
-typedef psnip_uint32_t psnip_safe_uint_larger;
+typedef Psnip_uint32_t psnipSafeuintLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && \
     PSNIP_SAFE_IS_LARGER(UINT_MAX, 0xffffffffffffffffULL)
-typedef psnip_uint64_t psnip_safe_uint_larger;
+typedef Psnip_uint64_t psnipSafeuintLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && defined(PSNIP_SAFE_HAVE_128) && \
     (UINT_MAX <= 0xffffffffffffffffULL)
-typedef psnip_safe_uint128_t psnip_safe_uint_larger;
+typedef Psnip_safe_uint128_t psnipSafeuintLarger;
 #else
 #undef PSNIP_SAFE_HAVE_LARGER_UINT
 #endif
 
 #define PSNIP_SAFE_HAVE_LARGER_LONG
 #if PSNIP_SAFE_IS_LARGER(LONG_MAX, LLONG_MAX)
-typedef long long psnip_safe_long_larger;
+typedef long long psnipSafelongLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(LONG_MAX, 0x7fff)
-typedef psnip_int16_t psnip_safe_long_larger;
+typedef Psnip_int16_t psnipSafelongLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && \
     PSNIP_SAFE_IS_LARGER(LONG_MAX, 0x7fffffffLL)
-typedef psnip_int32_t psnip_safe_long_larger;
+typedef Psnip_int32_t psnipSafelongLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && \
     PSNIP_SAFE_IS_LARGER(LONG_MAX, 0x7fffffffffffffffLL)
-typedef psnip_int64_t psnip_safe_long_larger;
+typedef Psnip_int64_t psnipSafelongLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && defined(PSNIP_SAFE_HAVE_128) && \
     (LONG_MAX <= 0x7fffffffffffffffLL)
-typedef psnip_safe_int128_t psnip_safe_long_larger;
+typedef Psnip_safe_int128_t psnipSafelongLarger;
 #else
 #undef PSNIP_SAFE_HAVE_LARGER_LONG
 #endif
 
 #define PSNIP_SAFE_HAVE_LARGER_ULONG
 #if PSNIP_SAFE_IS_LARGER(ULONG_MAX, ULLONG_MAX)
-typedef unsigned long long psnip_safe_ulong_larger;
+typedef unsigned long long psnipSafeulongLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(ULONG_MAX, 0xffff)
-typedef psnip_uint16_t psnip_safe_ulong_larger;
+typedef Psnip_uint16_t psnipSafeulongLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && \
     PSNIP_SAFE_IS_LARGER(ULONG_MAX, 0xffffffffUL)
-typedef psnip_uint32_t psnip_safe_ulong_larger;
+typedef Psnip_uint32_t psnipSafeulongLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && \
     PSNIP_SAFE_IS_LARGER(ULONG_MAX, 0xffffffffffffffffULL)
-typedef psnip_uint64_t psnip_safe_ulong_larger;
+typedef Psnip_uint64_t psnipSafeulongLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && defined(PSNIP_SAFE_HAVE_128) && \
     (ULONG_MAX <= 0xffffffffffffffffULL)
-typedef psnip_safe_uint128_t psnip_safe_ulong_larger;
+typedef Psnip_safe_uint128_t psnipSafeulongLarger;
 #else
 #undef PSNIP_SAFE_HAVE_LARGER_ULONG
 #endif
 
 #define PSNIP_SAFE_HAVE_LARGER_LLONG
 #if !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(LLONG_MAX, 0x7fff)
-typedef psnip_int16_t psnip_safe_llong_larger;
+typedef Psnip_int16_t psnipSafellongLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && \
     PSNIP_SAFE_IS_LARGER(LLONG_MAX, 0x7fffffffLL)
-typedef psnip_int32_t psnip_safe_llong_larger;
+typedef Psnip_int32_t psnipSafellongLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && \
     PSNIP_SAFE_IS_LARGER(LLONG_MAX, 0x7fffffffffffffffLL)
-typedef psnip_int64_t psnip_safe_llong_larger;
+typedef Psnip_int64_t psnipSafellongLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && defined(PSNIP_SAFE_HAVE_128) && \
     (LLONG_MAX <= 0x7fffffffffffffffLL)
-typedef psnip_safe_int128_t psnip_safe_llong_larger;
+typedef Psnip_safe_int128_t psnipSafellongLarger;
 #else
 #undef PSNIP_SAFE_HAVE_LARGER_LLONG
 #endif
 
 #define PSNIP_SAFE_HAVE_LARGER_ULLONG
 #if !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(ULLONG_MAX, 0xffff)
-typedef psnip_uint16_t psnip_safe_ullong_larger;
+typedef Psnip_uint16_t psnipSafeullongLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && \
     PSNIP_SAFE_IS_LARGER(ULLONG_MAX, 0xffffffffUL)
-typedef psnip_uint32_t psnip_safe_ullong_larger;
+typedef Psnip_uint32_t psnipSafeullongLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && \
     PSNIP_SAFE_IS_LARGER(ULLONG_MAX, 0xffffffffffffffffULL)
-typedef psnip_uint64_t psnip_safe_ullong_larger;
+typedef Psnip_uint64_t psnipSafeullongLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && defined(PSNIP_SAFE_HAVE_128) && \
     (ULLONG_MAX <= 0xffffffffffffffffULL)
-typedef psnip_safe_uint128_t psnip_safe_ullong_larger;
+typedef Psnip_safe_uint128_t psnipSafeullongLarger;
 #else
 #undef PSNIP_SAFE_HAVE_LARGER_ULLONG
 #endif
@@ -424,25 +424,25 @@ typedef psnip_safe_uint128_t psnip_safe_ullong_larger;
 #if defined(PSNIP_SAFE_SIZE_MAX)
 #define PSNIP_SAFE_HAVE_LARGER_SIZE
 #if PSNIP_SAFE_IS_LARGER(PSNIP_SAFE_SIZE_MAX, USHRT_MAX)
-typedef unsigned short psnip_safe_size_larger;
+typedef unsigned short psnipSafesizeLarger;
 #elif PSNIP_SAFE_IS_LARGER(PSNIP_SAFE_SIZE_MAX, UINT_MAX)
-typedef unsigned int psnip_safe_size_larger;
+typedef unsigned int psnipSafesizeLarger;
 #elif PSNIP_SAFE_IS_LARGER(PSNIP_SAFE_SIZE_MAX, ULONG_MAX)
-typedef unsigned long psnip_safe_size_larger;
+typedef unsigned long psnipSafesizeLarger;
 #elif PSNIP_SAFE_IS_LARGER(PSNIP_SAFE_SIZE_MAX, ULLONG_MAX)
-typedef unsigned long long psnip_safe_size_larger;
+typedef unsigned long long psnipSafesizeLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && \
     PSNIP_SAFE_IS_LARGER(PSNIP_SAFE_SIZE_MAX, 0xffff)
-typedef psnip_uint16_t psnip_safe_size_larger;
+typedef Psnip_uint16_t psnipSafesizeLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && \
     PSNIP_SAFE_IS_LARGER(PSNIP_SAFE_SIZE_MAX, 0xffffffffUL)
-typedef psnip_uint32_t psnip_safe_size_larger;
+typedef Psnip_uint32_t psnipSafesizeLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && \
     PSNIP_SAFE_IS_LARGER(PSNIP_SAFE_SIZE_MAX, 0xffffffffffffffffULL)
-typedef psnip_uint64_t psnip_safe_size_larger;
+typedef Psnip_uint64_t psnipSafesizeLarger;
 #elif !defined(PSNIP_SAFE_NO_FIXED) && defined(PSNIP_SAFE_HAVE_128) && \
     (PSNIP_SAFE_SIZE_MAX <= 0xffffffffffffffffULL)
-typedef psnip_safe_uint128_t psnip_safe_size_larger;
+typedef Psnip_safe_uint128_t psnipSafesizeLarger;
 #else
 #undef PSNIP_SAFE_HAVE_LARGER_SIZE
 #endif
@@ -503,180 +503,177 @@ PSNIP_SAFE_DEFINE_LARGER_UNSIGNED_OPS(size_t, size)
 #if !defined(PSNIP_SAFE_NO_FIXED)
 PSNIP_SAFE_DEFINE_LARGER_SIGNED_OPS(psnip_int8_t, int8)
 PSNIP_SAFE_DEFINE_LARGER_UNSIGNED_OPS(psnip_uint8_t, uint8)
-PSNIP_SAFE_DEFINE_LARGER_SIGNED_OPS(psnip_int16_t, int16)
-PSNIP_SAFE_DEFINE_LARGER_UNSIGNED_OPS(psnip_uint16_t, uint16)
-PSNIP_SAFE_DEFINE_LARGER_SIGNED_OPS(psnip_int32_t, int32)
-PSNIP_SAFE_DEFINE_LARGER_UNSIGNED_OPS(psnip_uint32_t, uint32)
+PSNIP_SAFE_DEFINE_LARGER_SIGNED_OPS(Psnip_int16_t, int16)
+PSNIP_SAFE_DEFINE_LARGER_UNSIGNED_OPS(Psnip_uint16_t, uint16)
+PSNIP_SAFE_DEFINE_LARGER_SIGNED_OPS(Psnip_int32_t, int32)
+PSNIP_SAFE_DEFINE_LARGER_UNSIGNED_OPS(Psnip_uint32_t, uint32)
 #if defined(PSNIP_SAFE_HAVE_128)
-PSNIP_SAFE_DEFINE_LARGER_SIGNED_OPS(psnip_int64_t, int64)
-PSNIP_SAFE_DEFINE_LARGER_UNSIGNED_OPS(psnip_uint64_t, uint64)
+PSNIP_SAFE_DEFINE_LARGER_SIGNED_OPS(Psnip_int64_t, int64)
+PSNIP_SAFE_DEFINE_LARGER_UNSIGNED_OPS(Psnip_uint64_t, uint64)
 #endif
 #endif
 
 #endif /* !defined(PSNIP_SAFE_NO_PROMOTIONS) */
 
-#define PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(T, name, op_name)         \
-  PSNIP_SAFE__FUNCTION psnip_safe_bool psnip_safe_##name##_##op_name( \
-      T* res, T a, T b) {                                             \
-    return !__builtin_##op_name##_overflow(a, b, res);                \
+#define PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(T, name, opName)      \
+  PSNIP_SAFE__FUNCTION psnipSafeBool psnipSafe_##name##_##opName( \
+      T* res, T a, T b) {                                         \
+    return !__builtin_##opName##_overflow(a, b, res);             \
   }
 
-#define PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(                  \
-    T, name, op_name, min, max)                                       \
-  PSNIP_SAFE__FUNCTION psnip_safe_bool psnip_safe_##name##_##op_name( \
-      T* res, T a, T b) {                                             \
-    const psnip_safe_##name##_larger r =                              \
-        psnip_safe_larger_##name##_##op_name(a, b);                   \
-    *res = (T)r;                                                      \
-    return (r >= min) && (r <= max);                                  \
+#define PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(T, name, opName, min, max) \
+  PSNIP_SAFE__FUNCTION psnipSafeBool psnipSafe_##name##_##opName(              \
+      T* res, T a, T b) {                                                      \
+    const psnipSafe_##name##Larger r =                                         \
+        psnipSafeLarger_##name##_##opName(a, b);                               \
+    *res = (T)r;                                                               \
+    return (r >= min) && (r <= max);                                           \
   }
 
-#define PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(T, name, op_name, max) \
-  PSNIP_SAFE__FUNCTION psnip_safe_bool psnip_safe_##name##_##op_name(        \
-      T* res, T a, T b) {                                                    \
-    const psnip_safe_##name##_larger r =                                     \
-        psnip_safe_larger_##name##_##op_name(a, b);                          \
-    *res = (T)r;                                                             \
-    return (r <= max);                                                       \
+#define PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(T, name, opName, max) \
+  PSNIP_SAFE__FUNCTION psnipSafeBool psnipSafe_##name##_##opName(           \
+      T* res, T a, T b) {                                                   \
+    const psnipSafe_##name##Larger r =                                      \
+        psnipSafeLarger_##name##_##opName(a, b);                            \
+    *res = (T)r;                                                            \
+    return (r <= max);                                                      \
   }
 
 #define PSNIP_SAFE_DEFINE_SIGNED_ADD(T, name, min, max)                  \
-  PSNIP_SAFE__FUNCTION psnip_safe_bool psnip_safe_##name##_add(          \
+  PSNIP_SAFE__FUNCTION psnipSafeBool psnipSafe_##name##_add(             \
       T* res, T a, T b) {                                                \
-    psnip_safe_bool r =                                                  \
+    psnipSafeBool r =                                                    \
         !(((b > 0) && (a > (max - b))) || ((b < 0) && (a < (min - b)))); \
     if (PSNIP_SAFE_LIKELY(r))                                            \
       *res = a + b;                                                      \
     return r;                                                            \
   }
 
-#define PSNIP_SAFE_DEFINE_UNSIGNED_ADD(T, name, max)            \
-  PSNIP_SAFE__FUNCTION psnip_safe_bool psnip_safe_##name##_add( \
-      T* res, T a, T b) {                                       \
-    *res = (T)(a + b);                                          \
-    return !PSNIP_SAFE_UNLIKELY((b > 0) && (a > (max - b)));    \
+#define PSNIP_SAFE_DEFINE_UNSIGNED_ADD(T, name, max)         \
+  PSNIP_SAFE__FUNCTION psnipSafeBool psnipSafe_##name##_add( \
+      T* res, T a, T b) {                                    \
+    *res = (T)(a + b);                                       \
+    return !PSNIP_SAFE_UNLIKELY((b > 0) && (a > (max - b))); \
   }
 
-#define PSNIP_SAFE_DEFINE_SIGNED_SUB(T, name, min, max)          \
-  PSNIP_SAFE__FUNCTION psnip_safe_bool psnip_safe_##name##_sub(  \
-      T* res, T a, T b) {                                        \
-    psnip_safe_bool r =                                          \
-        !((b > 0 && a < (min + b)) || (b < 0 && a > (max + b))); \
-    if (PSNIP_SAFE_LIKELY(r))                                    \
-      *res = a - b;                                              \
-    return r;                                                    \
+#define PSNIP_SAFE_DEFINE_SIGNED_SUB(T, name, min, max)                        \
+  PSNIP_SAFE__FUNCTION psnipSafeBool psnipSafe_##name##_sub(                   \
+      T* res, T a, T b) {                                                      \
+    psnipSafeBool r = !((b > 0 && a < (min + b)) || (b < 0 && a > (max + b))); \
+    if (PSNIP_SAFE_LIKELY(r))                                                  \
+      *res = a - b;                                                            \
+    return r;                                                                  \
   }
 
-#define PSNIP_SAFE_DEFINE_UNSIGNED_SUB(T, name, max)            \
-  PSNIP_SAFE__FUNCTION psnip_safe_bool psnip_safe_##name##_sub( \
-      T* res, T a, T b) {                                       \
-    *res = a - b;                                               \
-    return !PSNIP_SAFE_UNLIKELY(b > a);                         \
+#define PSNIP_SAFE_DEFINE_UNSIGNED_SUB(T, name, max)         \
+  PSNIP_SAFE__FUNCTION psnipSafeBool psnipSafe_##name##_sub( \
+      T* res, T a, T b) {                                    \
+    *res = a - b;                                            \
+    return !PSNIP_SAFE_UNLIKELY(b > a);                      \
   }
 
-#define PSNIP_SAFE_DEFINE_SIGNED_MUL(T, name, min, max)         \
-  PSNIP_SAFE__FUNCTION psnip_safe_bool psnip_safe_##name##_mul( \
-      T* res, T a, T b) {                                       \
-    psnip_safe_bool r = 1;                                      \
-    if (a > 0) {                                                \
-      if (b > 0) {                                              \
-        if (a > (max / b)) {                                    \
-          r = 0;                                                \
-        }                                                       \
-      } else {                                                  \
-        if (b < (min / a)) {                                    \
-          r = 0;                                                \
-        }                                                       \
-      }                                                         \
-    } else {                                                    \
-      if (b > 0) {                                              \
-        if (a < (min / b)) {                                    \
-          r = 0;                                                \
-        }                                                       \
-      } else {                                                  \
-        if ((a != 0) && (b < (max / a))) {                      \
-          r = 0;                                                \
-        }                                                       \
-      }                                                         \
-    }                                                           \
-    if (PSNIP_SAFE_LIKELY(r))                                   \
-      *res = a * b;                                             \
-    return r;                                                   \
+#define PSNIP_SAFE_DEFINE_SIGNED_MUL(T, name, min, max)      \
+  PSNIP_SAFE__FUNCTION psnipSafeBool psnipSafe_##name##_mul( \
+      T* res, T a, T b) {                                    \
+    psnipSafeBool r = 1;                                     \
+    if (a > 0) {                                             \
+      if (b > 0) {                                           \
+        if (a > (max / b)) {                                 \
+          r = 0;                                             \
+        }                                                    \
+      } else {                                               \
+        if (b < (min / a)) {                                 \
+          r = 0;                                             \
+        }                                                    \
+      }                                                      \
+    } else {                                                 \
+      if (b > 0) {                                           \
+        if (a < (min / b)) {                                 \
+          r = 0;                                             \
+        }                                                    \
+      } else {                                               \
+        if ((a != 0) && (b < (max / a))) {                   \
+          r = 0;                                             \
+        }                                                    \
+      }                                                      \
+    }                                                        \
+    if (PSNIP_SAFE_LIKELY(r))                                \
+      *res = a * b;                                          \
+    return r;                                                \
   }
 
 #define PSNIP_SAFE_DEFINE_UNSIGNED_MUL(T, name, max)                    \
-  PSNIP_SAFE__FUNCTION psnip_safe_bool psnip_safe_##name##_mul(         \
+  PSNIP_SAFE__FUNCTION psnipSafeBool psnipSafe_##name##_mul(            \
       T* res, T a, T b) {                                               \
     *res = (T)(a * b);                                                  \
     return !PSNIP_SAFE_UNLIKELY((a > 0) && (b > 0) && (a > (max / b))); \
   }
 
-#define PSNIP_SAFE_DEFINE_SIGNED_DIV(T, name, min, max)         \
-  PSNIP_SAFE__FUNCTION psnip_safe_bool psnip_safe_##name##_div( \
-      T* res, T a, T b) {                                       \
-    if (PSNIP_SAFE_UNLIKELY(b == 0)) {                          \
-      *res = 0;                                                 \
-      return 0;                                                 \
-    } else if (PSNIP_SAFE_UNLIKELY(a == min && b == -1)) {      \
-      *res = min;                                               \
-      return 0;                                                 \
-    } else {                                                    \
-      *res = (T)(a / b);                                        \
-      return 1;                                                 \
-    }                                                           \
+#define PSNIP_SAFE_DEFINE_SIGNED_DIV(T, name, min, max)      \
+  PSNIP_SAFE__FUNCTION psnipSafeBool psnipSafe_##name##_div( \
+      T* res, T a, T b) {                                    \
+    if (PSNIP_SAFE_UNLIKELY(b == 0)) {                       \
+      *res = 0;                                              \
+      return 0;                                              \
+    } else if (PSNIP_SAFE_UNLIKELY(a == min && b == -1)) {   \
+      *res = min;                                            \
+      return 0;                                              \
+    } else {                                                 \
+      *res = (T)(a / b);                                     \
+      return 1;                                              \
+    }                                                        \
   }
 
-#define PSNIP_SAFE_DEFINE_UNSIGNED_DIV(T, name, max)            \
-  PSNIP_SAFE__FUNCTION psnip_safe_bool psnip_safe_##name##_div( \
-      T* res, T a, T b) {                                       \
-    if (PSNIP_SAFE_UNLIKELY(b == 0)) {                          \
-      *res = 0;                                                 \
-      return 0;                                                 \
-    } else {                                                    \
-      *res = a / b;                                             \
-      return 1;                                                 \
-    }                                                           \
+#define PSNIP_SAFE_DEFINE_UNSIGNED_DIV(T, name, max)         \
+  PSNIP_SAFE__FUNCTION psnipSafeBool psnipSafe_##name##_div( \
+      T* res, T a, T b) {                                    \
+    if (PSNIP_SAFE_UNLIKELY(b == 0)) {                       \
+      *res = 0;                                              \
+      return 0;                                              \
+    } else {                                                 \
+      *res = a / b;                                          \
+      return 1;                                              \
+    }                                                        \
   }
 
-#define PSNIP_SAFE_DEFINE_SIGNED_MOD(T, name, min, max)         \
-  PSNIP_SAFE__FUNCTION psnip_safe_bool psnip_safe_##name##_mod( \
-      T* res, T a, T b) {                                       \
-    if (PSNIP_SAFE_UNLIKELY(b == 0)) {                          \
-      *res = 0;                                                 \
-      return 0;                                                 \
-    } else if (PSNIP_SAFE_UNLIKELY(a == min && b == -1)) {      \
-      *res = min;                                               \
-      return 0;                                                 \
-    } else {                                                    \
-      *res = (T)(a % b);                                        \
-      return 1;                                                 \
-    }                                                           \
+#define PSNIP_SAFE_DEFINE_SIGNED_MOD(T, name, min, max)      \
+  PSNIP_SAFE__FUNCTION psnipSafeBool psnipSafe_##name##_mod( \
+      T* res, T a, T b) {                                    \
+    if (PSNIP_SAFE_UNLIKELY(b == 0)) {                       \
+      *res = 0;                                              \
+      return 0;                                              \
+    } else if (PSNIP_SAFE_UNLIKELY(a == min && b == -1)) {   \
+      *res = min;                                            \
+      return 0;                                              \
+    } else {                                                 \
+      *res = (T)(a % b);                                     \
+      return 1;                                              \
+    }                                                        \
   }
 
-#define PSNIP_SAFE_DEFINE_UNSIGNED_MOD(T, name, max)            \
-  PSNIP_SAFE__FUNCTION psnip_safe_bool psnip_safe_##name##_mod( \
-      T* res, T a, T b) {                                       \
-    if (PSNIP_SAFE_UNLIKELY(b == 0)) {                          \
-      *res = 0;                                                 \
-      return 0;                                                 \
-    } else {                                                    \
-      *res = a % b;                                             \
-      return 1;                                                 \
-    }                                                           \
+#define PSNIP_SAFE_DEFINE_UNSIGNED_MOD(T, name, max)         \
+  PSNIP_SAFE__FUNCTION psnipSafeBool psnipSafe_##name##_mod( \
+      T* res, T a, T b) {                                    \
+    if (PSNIP_SAFE_UNLIKELY(b == 0)) {                       \
+      *res = 0;                                              \
+      return 0;                                              \
+    } else {                                                 \
+      *res = a % b;                                          \
+      return 1;                                              \
+    }                                                        \
   }
 
-#define PSNIP_SAFE_DEFINE_SIGNED_NEG(T, name, min, max)         \
-  PSNIP_SAFE__FUNCTION psnip_safe_bool psnip_safe_##name##_neg( \
-      T* res, T value) {                                        \
-    psnip_safe_bool r = value != min;                           \
-    *res = PSNIP_SAFE_LIKELY(r) ? -value : max;                 \
-    return r;                                                   \
+#define PSNIP_SAFE_DEFINE_SIGNED_NEG(T, name, min, max)                        \
+  PSNIP_SAFE__FUNCTION psnipSafeBool psnipSafe_##name##_neg(T* res, T value) { \
+    psnipSafeBool r = value != min;                                            \
+    *res = PSNIP_SAFE_LIKELY(r) ? -value : max;                                \
+    return r;                                                                  \
   }
 
-#define PSNIP_SAFE_DEFINE_INTSAFE(T, name, op, isf)              \
-  PSNIP_SAFE__FUNCTION psnip_safe_bool psnip_safe_##name##_##op( \
-      T* res, T a, T b) {                                        \
-    return isf(a, b, res) == S_OK;                               \
+#define PSNIP_SAFE_DEFINE_INTSAFE(T, name, op, isf)           \
+  PSNIP_SAFE__FUNCTION psnipSafeBool psnipSafe_##name##_##op( \
+      T* res, T a, T b) {                                     \
+    return isf(a, b, res) == S_OK;                            \
   }
 
 #if CHAR_MIN == 0
@@ -1071,260 +1068,260 @@ PSNIP_SAFE_DEFINE_UNSIGNED_DIV(psnip_uint8_t, uint8, 0xff)
 PSNIP_SAFE_DEFINE_UNSIGNED_MOD(psnip_uint8_t, uint8, 0xff)
 
 #if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)
-PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_int16_t, int16, add)
-PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_int16_t, int16, sub)
-PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_int16_t, int16, mul)
+PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(Psnip_int16_t, int16, add)
+PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(Psnip_int16_t, int16, sub)
+PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(Psnip_int16_t, int16, mul)
 #elif defined(PSNIP_SAFE_HAVE_LARGER_INT16)
 PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(
-    psnip_int16_t,
+    Psnip_int16_t,
     int16,
     add,
     (-32767 - 1),
     0x7fff)
 PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(
-    psnip_int16_t,
+    Psnip_int16_t,
     int16,
     sub,
     (-32767 - 1),
     0x7fff)
 PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(
-    psnip_int16_t,
+    Psnip_int16_t,
     int16,
     mul,
     (-32767 - 1),
     0x7fff)
 #else
-PSNIP_SAFE_DEFINE_SIGNED_ADD(psnip_int16_t, int16, (-32767 - 1), 0x7fff)
-PSNIP_SAFE_DEFINE_SIGNED_SUB(psnip_int16_t, int16, (-32767 - 1), 0x7fff)
-PSNIP_SAFE_DEFINE_SIGNED_MUL(psnip_int16_t, int16, (-32767 - 1), 0x7fff)
+PSNIP_SAFE_DEFINE_SIGNED_ADD(Psnip_int16_t, int16, (-32767 - 1), 0x7fff)
+PSNIP_SAFE_DEFINE_SIGNED_SUB(Psnip_int16_t, int16, (-32767 - 1), 0x7fff)
+PSNIP_SAFE_DEFINE_SIGNED_MUL(Psnip_int16_t, int16, (-32767 - 1), 0x7fff)
 #endif
-PSNIP_SAFE_DEFINE_SIGNED_DIV(psnip_int16_t, int16, (-32767 - 1), 0x7fff)
-PSNIP_SAFE_DEFINE_SIGNED_MOD(psnip_int16_t, int16, (-32767 - 1), 0x7fff)
-PSNIP_SAFE_DEFINE_SIGNED_NEG(psnip_int16_t, int16, (-32767 - 1), 0x7fff)
+PSNIP_SAFE_DEFINE_SIGNED_DIV(Psnip_int16_t, int16, (-32767 - 1), 0x7fff)
+PSNIP_SAFE_DEFINE_SIGNED_MOD(Psnip_int16_t, int16, (-32767 - 1), 0x7fff)
+PSNIP_SAFE_DEFINE_SIGNED_NEG(Psnip_int16_t, int16, (-32767 - 1), 0x7fff)
 
 #if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)
-PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_uint16_t, uint16, add)
-PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_uint16_t, uint16, sub)
-PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_uint16_t, uint16, mul)
+PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(Psnip_uint16_t, uint16, add)
+PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(Psnip_uint16_t, uint16, sub)
+PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(Psnip_uint16_t, uint16, mul)
 #elif defined(PSNIP_SAFE_HAVE_INTSAFE_H) && defined(_WIN32)
-PSNIP_SAFE_DEFINE_INTSAFE(psnip_uint16_t, uint16, add, UShortAdd)
-PSNIP_SAFE_DEFINE_INTSAFE(psnip_uint16_t, uint16, sub, UShortSub)
-PSNIP_SAFE_DEFINE_INTSAFE(psnip_uint16_t, uint16, mul, UShortMult)
+PSNIP_SAFE_DEFINE_INTSAFE(Psnip_uint16_t, uint16, add, UShortAdd)
+PSNIP_SAFE_DEFINE_INTSAFE(Psnip_uint16_t, uint16, sub, UShortSub)
+PSNIP_SAFE_DEFINE_INTSAFE(Psnip_uint16_t, uint16, mul, UShortMult)
 #elif defined(PSNIP_SAFE_HAVE_LARGER_UINT16)
 PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(
-    psnip_uint16_t,
+    Psnip_uint16_t,
     uint16,
     add,
     0xffff)
 PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(
-    psnip_uint16_t,
+    Psnip_uint16_t,
     uint16,
     sub,
     0xffff)
 PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(
-    psnip_uint16_t,
+    Psnip_uint16_t,
     uint16,
     mul,
     0xffff)
 #else
-PSNIP_SAFE_DEFINE_UNSIGNED_ADD(psnip_uint16_t, uint16, 0xffff)
-PSNIP_SAFE_DEFINE_UNSIGNED_SUB(psnip_uint16_t, uint16, 0xffff)
-PSNIP_SAFE_DEFINE_UNSIGNED_MUL(psnip_uint16_t, uint16, 0xffff)
+PSNIP_SAFE_DEFINE_UNSIGNED_ADD(Psnip_uint16_t, uint16, 0xffff)
+PSNIP_SAFE_DEFINE_UNSIGNED_SUB(Psnip_uint16_t, uint16, 0xffff)
+PSNIP_SAFE_DEFINE_UNSIGNED_MUL(Psnip_uint16_t, uint16, 0xffff)
 #endif
-PSNIP_SAFE_DEFINE_UNSIGNED_DIV(psnip_uint16_t, uint16, 0xffff)
-PSNIP_SAFE_DEFINE_UNSIGNED_MOD(psnip_uint16_t, uint16, 0xffff)
+PSNIP_SAFE_DEFINE_UNSIGNED_DIV(Psnip_uint16_t, uint16, 0xffff)
+PSNIP_SAFE_DEFINE_UNSIGNED_MOD(Psnip_uint16_t, uint16, 0xffff)
 
 #if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)
-PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_int32_t, int32, add)
-PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_int32_t, int32, sub)
-PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_int32_t, int32, mul)
+PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(Psnip_int32_t, int32, add)
+PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(Psnip_int32_t, int32, sub)
+PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(Psnip_int32_t, int32, mul)
 #elif defined(PSNIP_SAFE_HAVE_LARGER_INT32)
 PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(
-    psnip_int32_t,
+    Psnip_int32_t,
     int32,
     add,
     (-0x7fffffffLL - 1),
     0x7fffffffLL)
 PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(
-    psnip_int32_t,
+    Psnip_int32_t,
     int32,
     sub,
     (-0x7fffffffLL - 1),
     0x7fffffffLL)
 PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(
-    psnip_int32_t,
+    Psnip_int32_t,
     int32,
     mul,
     (-0x7fffffffLL - 1),
     0x7fffffffLL)
 #else
 PSNIP_SAFE_DEFINE_SIGNED_ADD(
-    psnip_int32_t,
+    Psnip_int32_t,
     int32,
     (-0x7fffffffLL - 1),
     0x7fffffffLL)
 PSNIP_SAFE_DEFINE_SIGNED_SUB(
-    psnip_int32_t,
+    Psnip_int32_t,
     int32,
     (-0x7fffffffLL - 1),
     0x7fffffffLL)
 PSNIP_SAFE_DEFINE_SIGNED_MUL(
-    psnip_int32_t,
+    Psnip_int32_t,
     int32,
     (-0x7fffffffLL - 1),
     0x7fffffffLL)
 #endif
 PSNIP_SAFE_DEFINE_SIGNED_DIV(
-    psnip_int32_t,
+    Psnip_int32_t,
     int32,
     (-0x7fffffffLL - 1),
     0x7fffffffLL)
 PSNIP_SAFE_DEFINE_SIGNED_MOD(
-    psnip_int32_t,
+    Psnip_int32_t,
     int32,
     (-0x7fffffffLL - 1),
     0x7fffffffLL)
 PSNIP_SAFE_DEFINE_SIGNED_NEG(
-    psnip_int32_t,
+    Psnip_int32_t,
     int32,
     (-0x7fffffffLL - 1),
     0x7fffffffLL)
 
 #if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)
-PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_uint32_t, uint32, add)
-PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_uint32_t, uint32, sub)
-PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_uint32_t, uint32, mul)
+PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(Psnip_uint32_t, uint32, add)
+PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(Psnip_uint32_t, uint32, sub)
+PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(Psnip_uint32_t, uint32, mul)
 #elif defined(PSNIP_SAFE_HAVE_INTSAFE_H) && defined(_WIN32)
-PSNIP_SAFE_DEFINE_INTSAFE(psnip_uint32_t, uint32, add, UIntAdd)
-PSNIP_SAFE_DEFINE_INTSAFE(psnip_uint32_t, uint32, sub, UIntSub)
-PSNIP_SAFE_DEFINE_INTSAFE(psnip_uint32_t, uint32, mul, UIntMult)
+PSNIP_SAFE_DEFINE_INTSAFE(Psnip_uint32_t, uint32, add, UIntAdd)
+PSNIP_SAFE_DEFINE_INTSAFE(Psnip_uint32_t, uint32, sub, UIntSub)
+PSNIP_SAFE_DEFINE_INTSAFE(Psnip_uint32_t, uint32, mul, UIntMult)
 #elif defined(PSNIP_SAFE_HAVE_LARGER_UINT32)
 PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(
-    psnip_uint32_t,
+    Psnip_uint32_t,
     uint32,
     add,
     0xffffffffUL)
 PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(
-    psnip_uint32_t,
+    Psnip_uint32_t,
     uint32,
     sub,
     0xffffffffUL)
 PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(
-    psnip_uint32_t,
+    Psnip_uint32_t,
     uint32,
     mul,
     0xffffffffUL)
 #else
-PSNIP_SAFE_DEFINE_UNSIGNED_ADD(psnip_uint32_t, uint32, 0xffffffffUL)
-PSNIP_SAFE_DEFINE_UNSIGNED_SUB(psnip_uint32_t, uint32, 0xffffffffUL)
-PSNIP_SAFE_DEFINE_UNSIGNED_MUL(psnip_uint32_t, uint32, 0xffffffffUL)
+PSNIP_SAFE_DEFINE_UNSIGNED_ADD(Psnip_uint32_t, uint32, 0xffffffffUL)
+PSNIP_SAFE_DEFINE_UNSIGNED_SUB(Psnip_uint32_t, uint32, 0xffffffffUL)
+PSNIP_SAFE_DEFINE_UNSIGNED_MUL(Psnip_uint32_t, uint32, 0xffffffffUL)
 #endif
-PSNIP_SAFE_DEFINE_UNSIGNED_DIV(psnip_uint32_t, uint32, 0xffffffffUL)
-PSNIP_SAFE_DEFINE_UNSIGNED_MOD(psnip_uint32_t, uint32, 0xffffffffUL)
+PSNIP_SAFE_DEFINE_UNSIGNED_DIV(Psnip_uint32_t, uint32, 0xffffffffUL)
+PSNIP_SAFE_DEFINE_UNSIGNED_MOD(Psnip_uint32_t, uint32, 0xffffffffUL)
 
 #if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)
-PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_int64_t, int64, add)
-PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_int64_t, int64, sub)
-PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_int64_t, int64, mul)
+PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(Psnip_int64_t, int64, add)
+PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(Psnip_int64_t, int64, sub)
+PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(Psnip_int64_t, int64, mul)
 #elif defined(PSNIP_SAFE_HAVE_LARGER_INT64)
 PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(
-    psnip_int64_t,
+    Psnip_int64_t,
     int64,
     add,
     (-0x7fffffffffffffffLL - 1),
     0x7fffffffffffffffLL)
 PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(
-    psnip_int64_t,
+    Psnip_int64_t,
     int64,
     sub,
     (-0x7fffffffffffffffLL - 1),
     0x7fffffffffffffffLL)
 PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(
-    psnip_int64_t,
+    Psnip_int64_t,
     int64,
     mul,
     (-0x7fffffffffffffffLL - 1),
     0x7fffffffffffffffLL)
 #else
 PSNIP_SAFE_DEFINE_SIGNED_ADD(
-    psnip_int64_t,
+    Psnip_int64_t,
     int64,
     (-0x7fffffffffffffffLL - 1),
     0x7fffffffffffffffLL)
 PSNIP_SAFE_DEFINE_SIGNED_SUB(
-    psnip_int64_t,
+    Psnip_int64_t,
     int64,
     (-0x7fffffffffffffffLL - 1),
     0x7fffffffffffffffLL)
 PSNIP_SAFE_DEFINE_SIGNED_MUL(
-    psnip_int64_t,
+    Psnip_int64_t,
     int64,
     (-0x7fffffffffffffffLL - 1),
     0x7fffffffffffffffLL)
 #endif
 PSNIP_SAFE_DEFINE_SIGNED_DIV(
-    psnip_int64_t,
+    Psnip_int64_t,
     int64,
     (-0x7fffffffffffffffLL - 1),
     0x7fffffffffffffffLL)
 PSNIP_SAFE_DEFINE_SIGNED_MOD(
-    psnip_int64_t,
+    Psnip_int64_t,
     int64,
     (-0x7fffffffffffffffLL - 1),
     0x7fffffffffffffffLL)
 PSNIP_SAFE_DEFINE_SIGNED_NEG(
-    psnip_int64_t,
+    Psnip_int64_t,
     int64,
     (-0x7fffffffffffffffLL - 1),
     0x7fffffffffffffffLL)
 
 #if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)
-PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_uint64_t, uint64, add)
-PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_uint64_t, uint64, sub)
-PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_uint64_t, uint64, mul)
+PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(Psnip_uint64_t, uint64, add)
+PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(Psnip_uint64_t, uint64, sub)
+PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(Psnip_uint64_t, uint64, mul)
 #elif defined(PSNIP_SAFE_HAVE_INTSAFE_H) && defined(_WIN32)
-PSNIP_SAFE_DEFINE_INTSAFE(psnip_uint64_t, uint64, add, ULongLongAdd)
-PSNIP_SAFE_DEFINE_INTSAFE(psnip_uint64_t, uint64, sub, ULongLongSub)
-PSNIP_SAFE_DEFINE_INTSAFE(psnip_uint64_t, uint64, mul, ULongLongMult)
+PSNIP_SAFE_DEFINE_INTSAFE(Psnip_uint64_t, uint64, add, ULongLongAdd)
+PSNIP_SAFE_DEFINE_INTSAFE(Psnip_uint64_t, uint64, sub, ULongLongSub)
+PSNIP_SAFE_DEFINE_INTSAFE(Psnip_uint64_t, uint64, mul, ULongLongMult)
 #elif defined(PSNIP_SAFE_HAVE_LARGER_UINT64)
 PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(
-    psnip_uint64_t,
+    Psnip_uint64_t,
     uint64,
     add,
     0xffffffffffffffffULL)
 PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(
-    psnip_uint64_t,
+    Psnip_uint64_t,
     uint64,
     sub,
     0xffffffffffffffffULL)
 PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(
-    psnip_uint64_t,
+    Psnip_uint64_t,
     uint64,
     mul,
     0xffffffffffffffffULL)
 #else
-PSNIP_SAFE_DEFINE_UNSIGNED_ADD(psnip_uint64_t, uint64, 0xffffffffffffffffULL)
-PSNIP_SAFE_DEFINE_UNSIGNED_SUB(psnip_uint64_t, uint64, 0xffffffffffffffffULL)
-PSNIP_SAFE_DEFINE_UNSIGNED_MUL(psnip_uint64_t, uint64, 0xffffffffffffffffULL)
+PSNIP_SAFE_DEFINE_UNSIGNED_ADD(Psnip_uint64_t, uint64, 0xffffffffffffffffULL)
+PSNIP_SAFE_DEFINE_UNSIGNED_SUB(Psnip_uint64_t, uint64, 0xffffffffffffffffULL)
+PSNIP_SAFE_DEFINE_UNSIGNED_MUL(Psnip_uint64_t, uint64, 0xffffffffffffffffULL)
 #endif
-PSNIP_SAFE_DEFINE_UNSIGNED_DIV(psnip_uint64_t, uint64, 0xffffffffffffffffULL)
-PSNIP_SAFE_DEFINE_UNSIGNED_MOD(psnip_uint64_t, uint64, 0xffffffffffffffffULL)
+PSNIP_SAFE_DEFINE_UNSIGNED_DIV(Psnip_uint64_t, uint64, 0xffffffffffffffffULL)
+PSNIP_SAFE_DEFINE_UNSIGNED_MOD(Psnip_uint64_t, uint64, 0xffffffffffffffffULL)
 
 #endif /* !defined(PSNIP_SAFE_NO_FIXED) */
 
 #define PSNIP_SAFE_C11_GENERIC_SELECTION(res, op) \
-  _Generic(                                       \
+  generic(                                        \
       (*res),                                     \
-      char: psnip_safe_char_##op,                 \
-      unsigned char: psnip_safe_uchar_##op,       \
-      short: psnip_safe_short_##op,               \
-      unsigned short: psnip_safe_ushort_##op,     \
-      int: psnip_safe_int_##op,                   \
-      unsigned int: psnip_safe_uint_##op,         \
-      long: psnip_safe_long_##op,                 \
-      unsigned long: psnip_safe_ulong_##op,       \
-      long long: psnip_safe_llong_##op,           \
-      unsigned long long: psnip_safe_ullong_##op)
+      char : psnipSafeChar_##op,                  \
+      unsigned char : psnipSafeUchar_##op,        \
+      short : psnipSafeShort_##op,                \
+      unsigned short : psnipSafeUshort_##op,      \
+      int : psnipSafeInt_##op,                    \
+      unsigned int : psnipSafeUint_##op,          \
+      long : psnipSafeLong_##op,                  \
+      unsigned long : psnipSafeUlong_##op,        \
+      long long : psnipSafeLlong_##op,            \
+      unsigned long long : psnipSafeUllong_##op)
 
 #define PSNIP_SAFE_C11_GENERIC_BINARY_OP(op, res, a, b) \
   PSNIP_SAFE_C11_GENERIC_SELECTION(res, op)(res, a, b)
@@ -1332,12 +1329,12 @@ PSNIP_SAFE_DEFINE_UNSIGNED_MOD(psnip_uint64_t, uint64, 0xffffffffffffffffULL)
   PSNIP_SAFE_C11_GENERIC_SELECTION(res, op)(res, v)
 
 #if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)
-#define psnip_safe_add(res, a, b) (!__builtin_add_overflow(a, b, res))
-#define psnip_safe_sub(res, a, b) (!__builtin_sub_overflow(a, b, res))
-#define psnip_safe_mul(res, a, b) (!__builtin_mul_overflow(a, b, res))
-#define psnip_safe_div(res, a, b) (!__builtin_div_overflow(a, b, res))
-#define psnip_safe_mod(res, a, b) (!__builtin_mod_overflow(a, b, res))
-#define psnip_safe_neg(res, v) PSNIP_SAFE_C11_GENERIC_UNARY_OP(neg, res, v)
+#define psnipSafeAdd(res, a, b) (!__builtin_add_overflow(a, b, res))
+#define psnipSafeSub(res, a, b) (!__builtin_sub_overflow(a, b, res))
+#define psnipSafeMul(res, a, b) (!__builtin_mul_overflow(a, b, res))
+#define psnipSafeDiv(res, a, b) (!__builtin_div_overflow(a, b, res))
+#define psnipSafeMod(res, a, b) (!__builtin_mod_overflow(a, b, res))
+#define psnipSafeNeg(res, v) PSNIP_SAFE_C11_GENERIC_UNARY_OP(neg, res, v)
 
 #elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
 /* The are no fixed-length or size selections because they cause an
@@ -1345,42 +1342,37 @@ PSNIP_SAFE_DEFINE_UNSIGNED_MOD(psnip_uint64_t, uint64, 0xffffffffffffffffULL)
  * this doesn't cause problems on exotic platforms, but if it does
  * please let me know and I'll try to figure something out. */
 
-#define psnip_safe_add(res, a, b) \
-  PSNIP_SAFE_C11_GENERIC_BINARY_OP(add, res, a, b)
-#define psnip_safe_sub(res, a, b) \
-  PSNIP_SAFE_C11_GENERIC_BINARY_OP(sub, res, a, b)
-#define psnip_safe_mul(res, a, b) \
-  PSNIP_SAFE_C11_GENERIC_BINARY_OP(mul, res, a, b)
-#define psnip_safe_div(res, a, b) \
-  PSNIP_SAFE_C11_GENERIC_BINARY_OP(div, res, a, b)
-#define psnip_safe_mod(res, a, b) \
-  PSNIP_SAFE_C11_GENERIC_BINARY_OP(mod, res, a, b)
-#define psnip_safe_neg(res, v) PSNIP_SAFE_C11_GENERIC_UNARY_OP(neg, res, v)
+#define psnipSafeAdd(res, a, b) PSNIP_SAFE_C11_GENERIC_BINARY_OP(add, res, a, b)
+#define psnipSafeSub(res, a, b) PSNIP_SAFE_C11_GENERIC_BINARY_OP(sub, res, a, b)
+#define psnipSafeMul(res, a, b) PSNIP_SAFE_C11_GENERIC_BINARY_OP(mul, res, a, b)
+#define psnipSafeDiv(res, a, b) PSNIP_SAFE_C11_GENERIC_BINARY_OP(div, res, a, b)
+#define psnipSafeMod(res, a, b) PSNIP_SAFE_C11_GENERIC_BINARY_OP(mod, res, a, b)
+#define psnipSafeNeg(res, v) PSNIP_SAFE_C11_GENERIC_UNARY_OP(neg, res, v)
 #endif
 
 #if !defined(PSNIP_SAFE_HAVE_BUILTINS) &&  \
     (defined(PSNIP_SAFE_EMULATE_NATIVE) || \
      defined(PSNIP_BUILTIN_EMULATE_NATIVE))
-#define __builtin_sadd_overflow(a, b, res) (!psnip_safe_int_add(res, a, b))
-#define __builtin_saddl_overflow(a, b, res) (!psnip_safe_long_add(res, a, b))
-#define __builtin_saddll_overflow(a, b, res) (!psnip_safe_llong_add(res, a, b))
-#define __builtin_uadd_overflow(a, b, res) (!psnip_safe_uint_add(res, a, b))
-#define __builtin_uaddl_overflow(a, b, res) (!psnip_safe_ulong_add(res, a, b))
-#define __builtin_uaddll_overflow(a, b, res) (!psnip_safe_ullong_add(res, a, b))
-
-#define __builtin_ssub_overflow(a, b, res) (!psnip_safe_int_sub(res, a, b))
-#define __builtin_ssubl_overflow(a, b, res) (!psnip_safe_long_sub(res, a, b))
-#define __builtin_ssubll_overflow(a, b, res) (!psnip_safe_llong_sub(res, a, b))
-#define __builtin_usub_overflow(a, b, res) (!psnip_safe_uint_sub(res, a, b))
-#define __builtin_usubl_overflow(a, b, res) (!psnip_safe_ulong_sub(res, a, b))
-#define __builtin_usubll_overflow(a, b, res) (!psnip_safe_ullong_sub(res, a, b))
-
-#define __builtin_smul_overflow(a, b, res) (!psnip_safe_int_mul(res, a, b))
-#define __builtin_smull_overflow(a, b, res) (!psnip_safe_long_mul(res, a, b))
-#define __builtin_smulll_overflow(a, b, res) (!psnip_safe_llong_mul(res, a, b))
-#define __builtin_umul_overflow(a, b, res) (!psnip_safe_uint_mul(res, a, b))
-#define __builtin_umull_overflow(a, b, res) (!psnip_safe_ulong_mul(res, a, b))
-#define __builtin_umulll_overflow(a, b, res) (!psnip_safe_ullong_mul(res, a, b))
+#define __builtin_sadd_overflow(a, b, res) (!psnipSafeIntAdd(res, a, b))
+#define __builtin_saddl_overflow(a, b, res) (!psnipSafeLongAdd(res, a, b))
+#define __builtin_saddll_overflow(a, b, res) (!psnipSafeLlongAdd(res, a, b))
+#define __builtin_uadd_overflow(a, b, res) (!psnipSafeUintAdd(res, a, b))
+#define __builtin_uaddl_overflow(a, b, res) (!psnipSafeUlongAdd(res, a, b))
+#define __builtin_uaddll_overflow(a, b, res) (!psnipSafeUllongAdd(res, a, b))
+
+#define __builtin_ssub_overflow(a, b, res) (!psnipSafeIntSub(res, a, b))
+#define __builtin_ssubl_overflow(a, b, res) (!psnipSafeLongSub(res, a, b))
+#define __builtin_ssubll_overflow(a, b, res) (!psnipSafeLlongSub(res, a, b))
+#define __builtin_usub_overflow(a, b, res) (!psnipSafeUintSub(res, a, b))
+#define __builtin_usubl_overflow(a, b, res) (!psnipSafeUlongSub(res, a, b))
+#define __builtin_usubll_overflow(a, b, res) (!psnipSafeUllongSub(res, a, b))
+
+#define __builtin_smul_overflow(a, b, res) (!psnipSafeIntMul(res, a, b))
+#define __builtin_smull_overflow(a, b, res) (!psnipSafeLongMul(res, a, b))
+#define __builtin_smulll_overflow(a, b, res) (!psnipSafeLlongMul(res, a, b))
+#define __builtin_umul_overflow(a, b, res) (!psnipSafeUintMul(res, a, b))
+#define __builtin_umull_overflow(a, b, res) (!psnipSafeUlongMul(res, a, b))
+#define __builtin_umulll_overflow(a, b, res) (!psnipSafeUllongMul(res, a, b))
 #endif
 
 #endif /* !defined(PSNIP_SAFE_H) */
diff --git a/velox/dwio/text/CMakeLists.txt b/velox/dwio/text/CMakeLists.txt
index d11825c4e30..040e3ca05d0 100644
--- a/velox/dwio/text/CMakeLists.txt
+++ b/velox/dwio/text/CMakeLists.txt
@@ -18,7 +18,13 @@ endif()
 
 add_subdirectory(writer)
 
-velox_add_library(velox_dwio_text_writer_register RegisterTextWriter.cpp)
+velox_add_library(
+  velox_dwio_text_writer_register
+  RegisterTextWriter.cpp
+  HEADERS
+  RegisterTextReader.h
+  RegisterTextWriter.h
+)
 
 velox_link_libraries(velox_dwio_text_writer_register velox_dwio_text_writer)
 
diff --git a/velox/dwio/text/reader/CMakeLists.txt b/velox/dwio/text/reader/CMakeLists.txt
index d65f1ffbc22..7910a383b7e 100644
--- a/velox/dwio/text/reader/CMakeLists.txt
+++ b/velox/dwio/text/reader/CMakeLists.txt
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_dwio_text_reader TextReader.cpp)
+velox_add_library(velox_dwio_text_reader TextReader.cpp HEADERS TextReader.h)
 
 velox_link_libraries(
   velox_dwio_text_reader
diff --git a/velox/dwio/text/reader/TextReader.cpp b/velox/dwio/text/reader/TextReader.cpp
index a157144ea46..d093e377eef 100644
--- a/velox/dwio/text/reader/TextReader.cpp
+++ b/velox/dwio/text/reader/TextReader.cpp
@@ -15,13 +15,16 @@
  */
 
 #include "velox/dwio/text/reader/TextReader.h"
+
+#include <boost/algorithm/string/predicate.hpp>
+#include <string>
+
 #include "velox/common/encode/Base64.h"
 #include "velox/dwio/common/exception/Exceptions.h"
 #include "velox/type/fbhive/HiveTypeParser.h"
 
-#include <string>
-
 namespace facebook::velox::text {
+namespace {
 
 using common::CompressionKind;
 
@@ -29,16 +32,18 @@ using dwio::common::EOFError;
 using dwio::common::RowReader;
 using dwio::common::verify;
 
-using folly::AsciiCaseInsensitive;
-using folly::StringPiece;
-
-constexpr const char* kTextfileCompressionExtensionGzip = ".gz";
-constexpr const char* kTextfileCompressionExtensionDeflate = ".deflate";
-constexpr const char* kTextfileCompressionExtensionZst = ".zst";
+static constexpr std::string_view kTextfileCompressionExtensionGzip{".gz"};
+static constexpr std::string_view kTextfileCompressionExtensionDeflate{
+    ".deflate"};
+static constexpr std::string_view kTextfileCompressionExtensionZst{".zst"};
+static constexpr std::string_view kTextfileCompressionExtensionLz4{".lz4"};
+static constexpr std::string_view kTextfileCompressionExtensionLzo{".lzo"};
+static constexpr std::string_view kTextfileCompressionExtensionSnappy{
+    ".snappy"};
 
 static std::string emptyString = std::string();
 
-namespace {
+constexpr const int32_t kDecompressionBufferFactor = 3;
 
 void resizeVector(
     BaseVector* FOLLY_NULLABLE data,
@@ -91,24 +96,24 @@ void resizeVector(
   }
 }
 
-bool endsWith(const std::string& str, const std::string& suffix) {
-  return str.size() >= suffix.size() &&
-      str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
-}
-
 void setCompressionSettings(
     const std::string& filename,
     CompressionKind& kind,
     dwio::common::compression::CompressionOptions& compressionOptions) {
-  if (endsWith(filename, kTextfileCompressionExtensionGzip)) {
+  if (filename.ends_with(kTextfileCompressionExtensionLz4) ||
+      filename.ends_with(kTextfileCompressionExtensionLzo) ||
+      filename.ends_with(kTextfileCompressionExtensionSnappy)) {
+    VELOX_FAIL("Unsupported compression extension for file: {}", filename);
+  }
+  if (filename.ends_with(kTextfileCompressionExtensionGzip)) {
     kind = CompressionKind::CompressionKind_GZIP;
     compressionOptions.format.zlib.windowBits =
         15; // 2^15-byte deflate window size
-  } else if (endsWith(filename, kTextfileCompressionExtensionDeflate)) {
+  } else if (filename.ends_with(kTextfileCompressionExtensionDeflate)) {
     kind = CompressionKind::CompressionKind_ZLIB;
     compressionOptions.format.zlib.windowBits =
         -15; // raw deflate, 2^15-byte window size
-  } else if (endsWith(filename, kTextfileCompressionExtensionZst)) {
+  } else if (filename.ends_with(kTextfileCompressionExtensionZst)) {
     kind = CompressionKind::CompressionKind_ZSTD;
   } else {
     kind = CompressionKind::CompressionKind_NONE;
@@ -156,20 +161,17 @@ TextRowReader::TextRowReader(
           std::make_shared<dwio::common::DataBuffer<char>>(contents_->pool)} {
   // Seek to first line at or after the specified region.
   if (contents_->compression == CompressionKind::CompressionKind_NONE) {
-    /**
-     * TODO: Inconsistent row skipping behavior (kept for Presto compatibility)
-     *
-     * Issue: When reading from byte offset > 0, we skip rows inclusively at the
-     * start position, but when reading from byte 0, no rows are skipped. This
-     * creates inconsistent behavior where a row at the boundary may be skipped
-     * when it should be included.
-     *
-     * Example: If pos_ = 10 is the first byte of row 2, that entire row gets
-     * skipped, even though it should be read.
-     *
-     * Proposed fix: streamPosition_ = (pos_ == 0) ? 0 : --pos_;
-     * This would skip rows exclusively of pos_, ensuring consistent behavior.
-     */
+    // TODO: Inconsistent row skipping behavior (kept for Presto compatibility)
+    // Issue: When reading from byte offset > 0, we skip rows inclusively at the
+    // start position, but when reading from byte 0, no rows are skipped. This
+    // creates inconsistent behavior where a row at the boundary may be skipped
+    // when it should be included.
+    //
+    // Example: If pos_ = 10 is the first byte of row 2, that entire row gets
+    // skipped, even though it should be read.
+    //
+    // Proposed fix: streamPosition_ = (pos_ == 0) ? 0 : --pos_;
+    // This would skip rows exclusively of pos_, ensuring consistent behavior.
     const auto streamPosition_ = pos_;
 
     contents_->inputStream = contents_->input->read(
@@ -191,34 +193,15 @@ TextRowReader::TextRowReader(
     }
     limit_ = std::numeric_limits<uint64_t>::max();
 
-    /**
-     * The output buffer for decompression is allocated based on the
-     * uncompressed length of the stream.
-     *
-     * For decompressors other than ZlibDecompressor, the uncompressed length is
-     * obtained via getDecompressedLength, and blockSize serves only as a
-     * fallbak when getDecompressedLength fails to return a valid length.
-     *
-     * ZlibDecompressor does not implement getDecompressedLength because the
-     * DEFLATE algorithm used by zlib does not inherently includes the
-     * uncompressed length in the compressed stream. As a result, blockSize is
-     * used to set z_stream.avail_out during decompression to ensure enough
-     * buffer allocated for the output. Since zlib requires avail_out to be a
-     * uInt (unsigned int), blockSize is set to std::numeric_limits<unsigned
-     * int>::max() for full compatibility.
-     */
-    const auto blockSize =
-        (contents_->compression == CompressionKind::CompressionKind_ZLIB ||
-         contents_->compression == CompressionKind::CompressionKind_GZIP)
-        ? std::numeric_limits<unsigned int>::max()
-        : std::numeric_limits<uint64_t>::max();
-
     contents_->inputStream = contents_->input->loadCompleteFile();
     auto name = contents_->inputStream->getName();
     contents_->decompressedInputStream = createDecompressor(
         contents_->compression,
         std::move(contents_->inputStream),
-        blockSize,
+        // An estimated value used as the output buffer size for the zlib
+        // decompressor, and as the fallback value of the decompressed length
+        // for other decompressors.
+        kDecompressionBufferFactor * contents_->fileLength,
         contents_->pool,
         contents_->compressionOptions,
         fmt::format("Text Reader: Stream {}", name),
@@ -274,34 +257,27 @@ uint64_t TextRowReader::next(
       DelimType delim = DelimTypeNone;
       const auto& ct = t->childAt(i);
       const auto& rct = reqT->childAt(i);
-      auto childVector = rowVecPtr->childAt(i).get();
+      BaseVector* childVector = nullptr;
 
       if (isSelectedField(ct)) {
+        childVector = rowVecPtr->childAt(i).get();
         ++colIndex;
       } else if (colIndex < reqChildCount && !projectSelectedType) {
-        // not selected and not projecting: set to null
-        if (childVector != nullptr) {
-          rowVecPtr->setNull(i, true);
-          childVector = nullptr;
-        }
+        // Not selected and not projecting: discard the child by setting it to
+        // nullptr. The projectColumns() function will later filter out unneeded
+        // columns based on the ScanSpec.
+        rowVecPtr->childAt(i) = nullptr;
         ++colIndex;
       } else {
-        // not selected and projecting: just discard the field
-        childVector = nullptr;
+        // Not selected and projecting: discard the child. Same reasoning as
+        // above.
+        rowVecPtr->childAt(i) = nullptr;
       }
 
       resizeVector(childVector, rowsRead);
       readElement(ct->type(), rct->type(), childVector, rowsRead, delim);
     }
 
-    // set null property
-    for (uint64_t i = colIndex; i < reqChildCount; i++) {
-      auto childVector = rowVecPtr->childAt(i).get();
-
-      if (childVector != nullptr) {
-        rowVecPtr->setNull(static_cast<vector_size_t>(i), true);
-      }
-    }
     (void)skipLine();
     ++currentRow_;
     ++rowsRead;
@@ -504,11 +480,9 @@ TextRowReader::getString(TextRowReader& th, bool& isNull, DelimType& delim) {
   bool wasEscaped = false;
   th.ownedString_.clear();
 
-  /**
-  Processing has to be done character by characater instad of chunk by chunk.
-  This is to avoid edge case handling if escape character(s) are cut off at
-  the end of the chunk.
-  */
+  // Processing has to be done character by characater instad of chunk by chunk.
+  // This is to avoid edge case handling if escape character(s) are cut off at
+  // the end of the chunk.
   while (true) {
     auto v = th.getByteOptimized(delim);
     if (!th.isNone(delim)) {
@@ -559,16 +533,22 @@ TextRowReader::getString(TextRowReader& th, bool& isNull, DelimType& delim) {
   return th.ownedString_;
 }
 
-uint8_t TextRowReader::getByte(DelimType& delim) {
-  setNone(delim);
-  auto v = getByteUnchecked(delim);
-  if (isNone(delim)) {
-    if (v == '\r') {
-      v = getByteUnchecked<true>(delim); // always returns '\n' in this case
-    }
-    delim = getDelimType(v);
+template <class T>
+void TextRowReader::setValueFromString(
+    const std::string& str,
+    BaseVector* data,
+    vector_size_t insertionRow,
+    std::function<std::optional<T>(const std::string&)> convert) {
+  if ((atEOF_ && atSOL_) || data == nullptr) {
+    return;
+  }
+  auto flatVector = data->asChecked<FlatVector<T>>();
+  auto result = str.empty() ? std::nullopt : convert(str);
+  if (result) {
+    flatVector->set(insertionRow, *result);
+  } else {
+    flatVector->setNull(insertionRow, true);
   }
-  return v;
 }
 
 uint8_t TextRowReader::getByteOptimized(DelimType& delim) {
@@ -612,48 +592,6 @@ DelimType TextRowReader::getDelimType(uint8_t v) {
   return delim;
 }
 
-template <bool skipLF>
-char TextRowReader::getByteUnchecked(DelimType& delim) {
-  if (atEOL_) {
-    if (!skipLF) {
-      delim = DelimTypeEOR; // top level EOR
-    }
-    return '\n';
-  }
-
-  try {
-    char v;
-    if (!unreadData_.empty()) {
-      v = unreadData_[0];
-      unreadData_.erase(0, 1);
-    } else {
-      contents_->inputStream->readFully(&v, 1);
-    }
-    pos_++;
-
-    // only when previous char == '\r'
-    if (skipLF) {
-      if (v != '\n') {
-        pos_--;
-        return '\n';
-      }
-    } else {
-      atSOL_ = false;
-    }
-    return v;
-  } catch (EOFError&) {
-  } catch (std::runtime_error& e) {
-    if (std::string(e.what()).find("Short read of") != 0 && !skipLF) {
-      throw;
-    }
-  }
-  if (!skipLF) {
-    setEOF();
-    delim = DelimTypeEOR;
-  }
-  return '\n';
-}
-
 template <bool skipLF>
 char TextRowReader::getByteUncheckedOptimized(DelimType& delim) {
   if (atEOL_) {
@@ -854,8 +792,8 @@ T TextRowReader::getInteger(TextRowReader& th, bool& isNull, DelimType& delim) {
 
 namespace {
 
-static const StringView trueStringView = StringView{"TRUE"};
-static const StringView falseStringView = StringView{"FALSE"};
+static constexpr std::string_view kTrueStringView{"TRUE"};
+static constexpr std::string_view kFalseStringView{"FALSE"};
 
 } // namespace
 
@@ -870,21 +808,21 @@ bool TextRowReader::getBoolean(
   if (isNull) {
     return false;
   }
-  if (str.compare(trueStringView) == 0) {
+  if (str.compare(kTrueStringView) == 0) {
     return true;
   }
-  if (str.compare(falseStringView) == 0) {
+  if (str.compare(kFalseStringView) == 0) {
     return false;
   }
 
   switch (str.size()) {
     case 4:
-      if (StringPiece(str).equals("TRUE", AsciiCaseInsensitive())) {
+      if (boost::algorithm::iequals(str, kTrueStringView)) {
         return true;
       }
       break;
     case 5:
-      if (StringPiece(str).equals("FALSE", AsciiCaseInsensitive())) {
+      if (boost::algorithm::iequals(str, kFalseStringView)) {
         return false;
       }
       break;
@@ -898,11 +836,11 @@ bool TextRowReader::getBoolean(
 
 namespace {
 
-static const StringView NaNStringView = StringView{"NaN"};
-static const StringView InfinityStringView = StringView{"Infinity"};
-static const StringView ShortInfinityStringView = StringView{"Inf"};
-static const StringView NegInfinityStringView = StringView{"-Infinity"};
-static const StringView ShortNegInfinityStringView = StringView{"-Inf"};
+static constexpr std::string_view kNaNStringView{"NaN"};
+static constexpr std::string_view kInfinityStringView{"Infinity"};
+static constexpr std::string_view kShortInfinityStringView{"Inf"};
+static constexpr std::string_view kNegInfinityStringView{"-Infinity"};
+static constexpr std::string_view kShortNegInfinityStringView{"-Inf"};
 
 bool unacceptableFloatingPoint(std::string& s) {
   for (int i = 0; i < s.size(); ++i) {
@@ -912,18 +850,14 @@ bool unacceptableFloatingPoint(std::string& s) {
     }
   }
 
-  bool isNaN =
-      StringPiece(s).equals(StringPiece(NaNStringView), AsciiCaseInsensitive());
+  bool isNaN = boost::algorithm::iequals(s, kNaNStringView);
 
-  bool isInf = StringPiece(s).equals(
-      StringPiece(InfinityStringView), AsciiCaseInsensitive());
-  bool isShortInf = StringPiece(s).equals(
-      StringPiece(ShortInfinityStringView), AsciiCaseInsensitive());
+  bool isInf = boost::algorithm::iequals(s, kInfinityStringView);
+  bool isShortInf = boost::algorithm::iequals(s, kShortInfinityStringView);
 
-  bool isNegInf = StringPiece(s).equals(
-      StringPiece(NegInfinityStringView), AsciiCaseInsensitive());
-  bool isShortNegInf = StringPiece(s).equals(
-      StringPiece(ShortNegInfinityStringView), AsciiCaseInsensitive());
+  bool isNegInf = boost::algorithm::iequals(s, kNegInfinityStringView);
+  bool isShortNegInf =
+      boost::algorithm::iequals(s, kShortNegInfinityStringView);
 
   return (!isNaN && !isInf && !isShortInf && !isNegInf && !isShortNegInf);
 }
@@ -1052,8 +986,19 @@ void TextRowReader::readElement(
               getInteger<int32_t>, data, insertionRow, delim);
           break;
         case TypeKind::INTEGER:
-          putValue<int32_t, int32_t>(
-              getInteger<int32_t>, data, insertionRow, delim);
+          if (reqT->isDate()) {
+            const std::string& str = getString(*this, isNull, delim);
+            setValueFromString<int32_t>(
+                str,
+                data,
+                insertionRow,
+                [](const std::string& s) -> std::optional<int32_t> {
+                  return DATE()->toDays(s);
+                });
+          } else {
+            putValue<int32_t, int32_t>(
+                getInteger<int32_t>, data, insertionRow, delim);
+          }
           break;
         default:
           VELOX_FAIL(
@@ -1065,10 +1010,61 @@ void TextRowReader::readElement(
       break;
 
     case TypeKind::BIGINT:
-      putValue<int64_t, int64_t>(
-          getInteger<int64_t>, data, insertionRow, delim);
+      if (reqT->isShortDecimal()) {
+        const std::string& str = getString(*this, isNull, delim);
+        auto decimalParams = getDecimalPrecisionScale(*reqT);
+        const auto precision = decimalParams.first;
+        const auto scale = decimalParams.second;
+        setValueFromString<int64_t>(
+            str,
+            data,
+            insertionRow,
+            [precision, scale](const std::string& s) -> std::optional<int64_t> {
+              int64_t v = 0;
+              const auto status = DecimalUtil::castFromString(
+                  StringView(s.data(), static_cast<int32_t>(s.size())),
+                  precision,
+                  scale,
+                  v);
+              return status.ok() ? std::optional<int64_t>(v) : std::nullopt;
+            });
+      } else {
+        putValue<int64_t, int64_t>(
+            getInteger<int64_t>, data, insertionRow, delim);
+      }
       break;
 
+    case TypeKind::HUGEINT: {
+      const std::string& str = getString(*this, isNull, delim);
+      if (reqT->isLongDecimal()) {
+        auto decimalParams = getDecimalPrecisionScale(*reqT);
+        const auto precision = decimalParams.first;
+        const auto scale = decimalParams.second;
+        setValueFromString<int128_t>(
+            str,
+            data,
+            insertionRow,
+            [precision,
+             scale](const std::string& s) -> std::optional<int128_t> {
+              int128_t v = 0;
+              const auto status = DecimalUtil::castFromString(
+                  StringView(s.data(), static_cast<int32_t>(s.size())),
+                  precision,
+                  scale,
+                  v);
+              return status.ok() ? std::optional<int128_t>(v) : std::nullopt;
+            });
+      } else {
+        setValueFromString<int128_t>(
+            str,
+            data,
+            insertionRow,
+            [](const std::string& s) -> std::optional<int128_t> {
+              return HugeInt::parse(s);
+            });
+      }
+      break;
+    }
     case TypeKind::SMALLINT:
       switch (reqT->kind()) {
         case TypeKind::BIGINT:
@@ -1639,17 +1635,4 @@ uint64_t TextReader::getFileLength() const {
   return contents_->fileLength;
 }
 
-uint64_t TextReader::getMemoryUse() {
-  uint64_t memory = std::min(
-      uint64_t(contents_->fileLength),
-      contents_->input->getInputStream()->getNaturalReadSize());
-
-  // Decompressor needs a buffer.
-  if (contents_->compression != CompressionKind::CompressionKind_NONE) {
-    memory *= 3;
-  }
-
-  return memory;
-}
-
 } // namespace facebook::velox::text
diff --git a/velox/dwio/text/reader/TextReader.h b/velox/dwio/text/reader/TextReader.h
index e1563508705..435de81c35a 100644
--- a/velox/dwio/text/reader/TextReader.h
+++ b/velox/dwio/text/reader/TextReader.h
@@ -85,8 +85,6 @@ class TextReader : public dwio::common::Reader {
 
   uint64_t getFileLength() const;
 
-  uint64_t getMemoryUse();
-
  private:
   ReaderOptions options_;
   mutable std::shared_ptr<const TypeWithId> typeWithId_;
@@ -206,6 +204,13 @@ class TextRowReader : public dwio::common::RowReader {
       vector_size_t insertionRow,
       DelimType& delim);
 
+  template <class T>
+  void setValueFromString(
+      const std::string& str,
+      BaseVector* FOLLY_NULLABLE data,
+      vector_size_t insertionRow,
+      std::function<std::optional<T>(const std::string&)> convert);
+
   const std::shared_ptr<FileContents> contents_;
   const std::shared_ptr<const TypeWithId> schemaWithId_;
   const std::shared_ptr<velox::common::ScanSpec>& scanSpec_;
diff --git a/velox/dwio/text/tests/CMakeLists.txt b/velox/dwio/text/tests/CMakeLists.txt
index 032c209e75a..b1975b85607 100644
--- a/velox/dwio/text/tests/CMakeLists.txt
+++ b/velox/dwio/text/tests/CMakeLists.txt
@@ -17,7 +17,7 @@ set(
   velox_dwio_common_test_utils
   velox_vector_test_lib
   velox_exec_test_lib
-  velox_temp_path
+  velox_test_util
   GTest::gtest
   GTest::gtest_main
   GTest::gmock
diff --git a/velox/dwio/text/tests/reader/TextReaderTest.cpp b/velox/dwio/text/tests/reader/TextReaderTest.cpp
index b1b3bbda23e..b6c559087b4 100644
--- a/velox/dwio/text/tests/reader/TextReaderTest.cpp
+++ b/velox/dwio/text/tests/reader/TextReaderTest.cpp
@@ -14,6 +14,10 @@
  * limitations under the License.
  */
 
+#include "velox/common/file/File.h"
+#include "velox/common/io/IoStatistics.h"
+#include "velox/common/testutil/TempFilePath.h"
+#include "velox/connectors/hive/ExtractionUtils.h"
 #include "velox/dwio/common/tests/utils/DataFiles.h"
 #include "velox/dwio/text/RegisterTextReader.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
@@ -23,11 +27,16 @@ extern long timezone;
 
 using namespace facebook::velox;
 using namespace facebook::velox::test;
+using facebook::velox::common::testutil::TempFilePath;
 
 namespace facebook::velox::text {
 
 namespace {
 
+int32_t parseDate(const std::string& text) {
+  return DATE()->toDays(text);
+}
+
 class TextReaderTest : public testing::Test,
                        public velox::test::VectorTestBase {
  protected:
@@ -53,6 +62,11 @@ class TextReaderTest : public testing::Test,
     options.setScanSpec(spec);
   }
 
+  std::shared_ptr<velox::io::IoStatistics> dataIoStats_ =
+      std::make_shared<velox::io::IoStatistics>();
+  std::shared_ptr<velox::io::IoStatistics> metadataIoStats_ =
+      std::make_shared<velox::io::IoStatistics>();
+
  private:
   std::shared_ptr<LocalReadFile> readFile_;
 };
@@ -122,7 +136,9 @@ TEST_F(TextReaderTest, basic) {
       "examples/simple_types_compressed_file.gz");
   auto readFile = std::make_shared<LocalReadFile>(path);
 
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(type);
 
   auto input =
@@ -232,7 +248,9 @@ TEST_F(TextReaderTest, headerAndCustomNullString) {
       "velox/dwio/text/tests/reader/", "examples/simple_types_with_header");
   auto readFile = std::make_shared<LocalReadFile>(path);
 
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(type);
   auto rowReaderOptions = dwio::common::RowReaderOptions();
   setScanSpec(*type, rowReaderOptions);
@@ -406,7 +424,9 @@ TEST_F(TextReaderTest, complexTypesWithCustomDelimiters) {
   auto readFile = std::make_shared<LocalReadFile>(path);
 
   auto serDeOptions = dwio::common::SerDeOptions('\t', '|', '#', '\\', true);
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(type);
   readerOptions.setSerDeOptions(serDeOptions);
 
@@ -471,7 +491,9 @@ TEST_F(TextReaderTest, projectComplexTypesWithCustomDelimiters) {
   auto readFile = std::make_shared<LocalReadFile>(path);
 
   auto serDeOptions = dwio::common::SerDeOptions('\t', '|', '#', '\\', true);
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(type);
   readerOptions.setSerDeOptions(serDeOptions);
 
@@ -487,8 +509,9 @@ TEST_F(TextReaderTest, projectComplexTypesWithCustomDelimiters) {
 
   dwio::common::RowReaderOptions rowOptions;
   rowOptions.setScanSpec(spec);
-  rowOptions.select(std::make_shared<dwio::common::ColumnSelector>(
-      type, std::vector<std::string>({"col_string", "col_map"})));
+  rowOptions.select(
+      std::make_shared<dwio::common::ColumnSelector>(
+          type, std::vector<std::string>({"col_string", "col_map"})));
   auto rowReader = reader->createRowReader(rowOptions);
 
   VectorPtr result;
@@ -573,7 +596,9 @@ TEST_F(TextReaderTest, projectPrimitiveTypes) {
   auto path = velox::test::getDataFilePath(
       "velox/dwio/text/tests/reader/", "examples/simple_types");
   auto readFile = std::make_shared<LocalReadFile>(path);
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(type);
   auto input =
       std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
@@ -587,8 +612,10 @@ TEST_F(TextReaderTest, projectPrimitiveTypes) {
 
   dwio::common::RowReaderOptions rowOptions;
   rowOptions.setScanSpec(spec);
-  rowOptions.select(std::make_shared<dwio::common::ColumnSelector>(
-      type, std::vector<std::string>({"col_tiny", "col_int", "col_double"})));
+  rowOptions.select(
+      std::make_shared<dwio::common::ColumnSelector>(
+          type,
+          std::vector<std::string>({"col_tiny", "col_int", "col_double"})));
   auto rowReader = reader->createRowReader(rowOptions);
 
   VectorPtr result;
@@ -639,7 +666,9 @@ TEST_F(TextReaderTest, projectColumns) {
       "velox/dwio/text/tests/reader/",
       "examples/simple_types_compressed_file.gz");
   auto readFile = std::make_shared<LocalReadFile>(path);
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(type);
   auto input =
       std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
@@ -650,8 +679,9 @@ TEST_F(TextReaderTest, projectColumns) {
   spec->addField("col_float", 1);
   dwio::common::RowReaderOptions rowOptions;
   rowOptions.setScanSpec(spec);
-  rowOptions.select(std::make_shared<dwio::common::ColumnSelector>(
-      type, std::vector<std::string>({"col_float"})));
+  rowOptions.select(
+      std::make_shared<dwio::common::ColumnSelector>(
+          type, std::vector<std::string>({"col_float"})));
   auto rowReader = reader->createRowReader(rowOptions);
   VectorPtr result;
   ASSERT_EQ(rowReader->next(10, result), 10);
@@ -693,7 +723,9 @@ TEST_F(TextReaderTest, projectNone) {
       "velox/dwio/text/tests/reader/", "examples/simple_types");
   auto readFile = std::make_shared<LocalReadFile>(path);
 
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(type);
 
   dwio::common::RowReaderOptions rowReaderOptions;
@@ -728,7 +760,9 @@ TEST_F(TextReaderTest, compressedProjectNone) {
       "examples/simple_types_compressed_file.gz");
   auto readFile = std::make_shared<LocalReadFile>(path);
 
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(type);
 
   dwio::common::RowReaderOptions rowReaderOptions;
@@ -759,7 +793,9 @@ TEST_F(TextReaderTest, compressedFilter) {
       "velox/dwio/text/tests/reader/",
       "examples/simple_types_compressed_file.gz");
   auto readFile = std::make_shared<LocalReadFile>(path);
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(type);
   auto input =
       std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
@@ -769,8 +805,9 @@ TEST_F(TextReaderTest, compressedFilter) {
       BaseVector::createConstant(VARCHAR(), "2023-07-18", 1, pool()));
   spec->addField("col_int", 1);
   spec->getOrCreateChild(common::Subfield("col_string"))
-      ->setFilter(std::make_unique<common::BytesValues>(
-          std::vector<std::string>({"BAR"}), false));
+      ->setFilter(
+          std::make_unique<common::BytesValues>(
+              std::vector<std::string>({"BAR"}), false));
   dwio::common::RowReaderOptions rowOptions;
   rowOptions.setScanSpec(spec);
   rowOptions.select(
@@ -802,7 +839,9 @@ TEST_F(TextReaderTest, filter) {
       "velox/dwio/text/tests/reader/", "examples/more_simple_types");
   auto readFile = std::make_shared<LocalReadFile>(path);
 
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(type);
 
   auto input =
@@ -814,8 +853,9 @@ TEST_F(TextReaderTest, filter) {
       BaseVector::createConstant(VARCHAR(), "2023-07-18", 1, pool()));
   spec->addField("col_big_int", 1);
   spec->getOrCreateChild(common::Subfield("col_string"))
-      ->setFilter(std::make_unique<common::BytesValues>(
-          std::vector<std::string>({"BAR", "BAZ"}), false));
+      ->setFilter(
+          std::make_unique<common::BytesValues>(
+              std::vector<std::string>({"BAR", "BAZ"}), false));
 
   dwio::common::RowReaderOptions rowOptions;
   rowOptions.setScanSpec(spec);
@@ -859,7 +899,9 @@ TEST_F(TextReaderTest, shrinkBatch) {
   auto path = velox::test::getDataFilePath(
       "velox/dwio/text/tests/reader/", "examples/simple_types");
   auto readFile = std::make_shared<LocalReadFile>(path);
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(type);
   auto input =
       std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
@@ -892,7 +934,9 @@ TEST_F(TextReaderTest, compressedShrinkBatch) {
       "velox/dwio/text/tests/reader/",
       "examples/simple_types_compressed_file.gz");
   auto readFile = std::make_shared<LocalReadFile>(path);
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(type);
   auto input =
       std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
@@ -922,7 +966,9 @@ TEST_F(TextReaderTest, emptyFile) {
   auto path = velox::test::getDataFilePath(
       "velox/dwio/text/tests/reader/", "examples/empty.gz");
   auto readFile = std::make_shared<LocalReadFile>(path);
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(type);
   auto rowReaderOptions = dwio::common::RowReaderOptions();
   setScanSpec(*type, rowReaderOptions);
@@ -969,7 +1015,9 @@ TEST_F(TextReaderTest, readRanges) {
       "examples/simple_types_10_bytes_per_row");
   auto readFile = std::make_shared<LocalReadFile>(path);
 
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(type);
 
   auto input =
@@ -1066,7 +1114,9 @@ TEST_F(TextReaderTest, readFloatAsInt) {
       "velox/dwio/text/tests/reader/", "examples/simple_types");
   auto readFile = std::make_shared<LocalReadFile>(path);
 
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(type);
 
   auto input =
@@ -1165,7 +1215,9 @@ TEST_F(TextReaderTest, simpleTypes) {
       "velox/dwio/text/tests/reader/", "examples/more_simple_types");
   auto readFile = std::make_shared<LocalReadFile>(path);
 
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(type);
 
   auto input =
@@ -1225,7 +1277,9 @@ TEST_F(TextReaderTest, primitiveLimitsStressTest) {
       "velox/dwio/text/tests/reader/", "examples/primitive_limits");
   auto readFile = std::make_shared<LocalReadFile>(path);
 
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   auto serDeOptions = dwio::common::SerDeOptions('\t', '=', '|', '\\', true);
   readerOptions.setFileSchema(type);
   readerOptions.setSerDeOptions(serDeOptions);
@@ -1383,7 +1437,9 @@ TEST_F(TextReaderTest, DISABLED_nestedComplexTypesWithCustomDelimiters) {
   auto serDeOptions = dwio::common::SerDeOptions('\t', '=', '|', '\\', true);
   serDeOptions.separators[3] = ',';
   serDeOptions.separators[4] = ':';
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(type);
   readerOptions.setSerDeOptions(serDeOptions);
 
@@ -1454,7 +1510,9 @@ TEST_F(TextReaderTest, nestedArraysWithCustomDelimiters) {
   // - Pipe ('|') for outer array element separation (depth 1)
   // - Comma (',') for inner array element separation (depth 2)
   auto serDeOptions = dwio::common::SerDeOptions('\t', '|', ',', '\\', true);
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(type);
   readerOptions.setSerDeOptions(serDeOptions);
 
@@ -1545,7 +1603,9 @@ TEST_F(TextReaderTest, tripleNestedArraysWithCustomDelimiters) {
   // - Hash ('#') for innermost array element separation (depth 3)
   auto serDeOptions = dwio::common::SerDeOptions('\t', '|', ',', '\\', true);
   serDeOptions.separators[3] = '#';
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(type);
   readerOptions.setSerDeOptions(serDeOptions);
 
@@ -1579,7 +1639,9 @@ TEST_F(TextReaderTest, varbinarySuccessfulDecoding) {
 
   auto readFile = std::make_shared<LocalReadFile>(path);
 
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(type);
 
   auto input =
@@ -1614,7 +1676,9 @@ TEST_F(TextReaderTest, varbinaryUnsuccessfulDecoding) {
 
   auto readFile = std::make_shared<LocalReadFile>(path);
 
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(type);
 
   auto input =
@@ -1639,6 +1703,97 @@ TEST_F(TextReaderTest, varbinaryUnsuccessfulDecoding) {
   EXPECT_EQ(binaryVector->valueAt(1), StringView("Another@Invalid#String"));
 }
 
+TEST_F(TextReaderTest, logicalTypes) {
+  auto expected = makeRowVector(
+      {makeNullableFlatVector<int64_t>(
+           {0,
+            123,
+            -1234567,
+            999999999999999,
+            std::nullopt,
+            4242,
+            -1,
+            std::nullopt,
+            314159265358979,
+            77777,
+            100000000000000,
+            -5432199,
+            std::nullopt,
+            1234,
+            -999999999999999,
+            999999999999999},
+           DECIMAL(15, 2)),
+       makeNullableFlatVector<int128_t>(
+           {0,
+            HugeInt::parse("999999999999999999999"),
+            HugeInt::parse("123456789012345678901234567890"),
+            HugeInt::parse("-99999999999999999999999999"),
+            HugeInt::parse("88888888888888888888"),
+            std::nullopt,
+            1,
+            std::nullopt,
+            HugeInt::parse("27182818284590452353612"),
+            HugeInt::parse("-123456789012345678999"),
+            HugeInt::parse("12345678901234567890123456789012345678"),
+            987654321012,
+            std::nullopt,
+            5678,
+            -123,
+            HugeInt::parse("99999999999999999999999999999999")},
+           DECIMAL(38, 2)),
+       makeNullableFlatVector<int32_t>(
+           {
+               parseDate("1970-01-01"),
+               parseDate("2024-02-29"),
+               parseDate("1900-01-01"),
+               parseDate("2099-12-31"),
+               parseDate("2001-09-11"),
+               parseDate("2025-09-10"),
+               std::nullopt,
+               std::nullopt,
+               parseDate("1999-12-31"),
+               parseDate("2012-12-21"),
+               parseDate("2200-01-01"),
+               parseDate("1988-08-08"),
+               parseDate("1969-07-20"),
+               parseDate("2000-01-01"),
+               parseDate("1800-06-15"),
+               parseDate("2500-12-31"),
+           },
+           DATE())});
+
+  auto type =
+      ROW({{"c0", DECIMAL(15, 2)}, {"c1", DECIMAL(38, 2)}, {"c2", DATE()}});
+
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/", "examples/logical_types.gz");
+
+  auto readFile = std::make_shared<LocalReadFile>(path);
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  readerOptions.setFileSchema(type);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+  dwio::common::RowReaderOptions rowReaderOptions;
+  setScanSpec(*type, rowReaderOptions);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+  EXPECT_EQ(*reader->rowType(), *type);
+
+  VectorPtr result;
+  ASSERT_EQ(rowReader->next(10, result), 10);
+  for (int i = 0; i < 10; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 6);
+  for (int i = 0; i < 6; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 10 + i));
+  }
+}
+
 TEST_F(TextReaderTest, nestedRows) {
   auto nestedRowChildren = std::vector<VectorPtr>{
       makeFlatVector<int32_t>({42, 100, -5, 0, 999}),
@@ -1674,7 +1829,9 @@ TEST_F(TextReaderTest, nestedRows) {
   auto readFile = std::make_shared<LocalReadFile>(path);
   auto serDeOptions = dwio::common::SerDeOptions('&', ',', '#', '\\', true);
 
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(type);
   readerOptions.setSerDeOptions(serDeOptions);
 
@@ -1753,7 +1910,9 @@ TEST_P(TextReaderDecompressionTest, tests) {
       velox::test::getDataFilePath("velox/dwio/text/tests/reader/", filepath);
   auto readFile = std::make_shared<LocalReadFile>(path);
 
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(type);
 
   auto input =
@@ -1811,6 +1970,316 @@ INSTANTIATE_TEST_SUITE_P(
     testing::ValuesIn(params),
     [](const auto& paramInfo) { return paramInfo.param.compression; });
 
+TEST_F(TextReaderTest, unsupportedCompressedKind) {
+  auto type = ROW(
+      {{"col_string", VARCHAR()},
+       {"col_int", INTEGER()},
+       {"col_float", DOUBLE()},
+       {"col_bool", BOOLEAN()}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+  const std::string kBaseDir = "velox/dwio/text/tests/reader/";
+  std::vector paths = {
+      getDataFilePath(kBaseDir, "examples/simple_types_compressed_file.lz4"),
+      getDataFilePath(kBaseDir, "examples/simple_types_compressed_file.lzo"),
+      getDataFilePath(
+          kBaseDir, "examples/simple_types_compressed_file.snappy")};
+  for (const auto& path : paths) {
+    auto readFile = std::make_shared<LocalReadFile>(path);
+    dwio::common::ReaderOptions readerOptions(pool());
+    readerOptions.setDataIoStats(dataIoStats_);
+    readerOptions.setMetadataIoStats(metadataIoStats_);
+    readerOptions.setFileSchema(type);
+    auto input =
+        std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+    EXPECT_THROW(
+        factory->createReader(std::move(input), readerOptions),
+        VeloxRuntimeError);
+  }
+}
+
+TEST_F(TextReaderTest, extractionMapKeys) {
+  // Read a text file with a MAP column and apply a MapKeys extraction transform
+  // via ScanSpec.  The text reader uses RowReader::projectColumns() as
+  // fallback, which should apply the transform.
+  const auto type = ROW(
+      {{"col_string", VARCHAR()},
+       {"col_bigint_arr", ARRAY(BIGINT())},
+       {"col_double_arr", ARRAY(DOUBLE())},
+       {"col_map", MAP(BIGINT(), BOOLEAN())}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/", "examples/custom_delimiters_file");
+  auto readFile = std::make_shared<LocalReadFile>(path);
+
+  auto serDeOptions = dwio::common::SerDeOptions('\t', '|', '#', '\\', true);
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  readerOptions.setFileSchema(type);
+  readerOptions.setSerDeOptions(serDeOptions);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+
+  // Build a ScanSpec that projects only col_map with a MapKeys extraction
+  // transform.
+  auto spec = std::make_shared<common::ScanSpec>("root");
+  auto* mapSpec = spec->addField("col_map", 0);
+  mapSpec->addAllChildFields(*MAP(BIGINT(), BOOLEAN()));
+
+  using connector::hive::applyExtractionChain;
+  using connector::hive::ExtractionPathElement;
+  using connector::hive::ExtractionPathElementPtr;
+  using connector::hive::ExtractionStep;
+  auto chain = std::vector<ExtractionPathElementPtr>{
+      ExtractionPathElement::simple(ExtractionStep::kMapKeys)};
+  mapSpec->setExtractionType(common::ScanSpec::ExtractionType::kKeys);
+  mapSpec->setTransform(
+      [chain](const VectorPtr& input, memory::MemoryPool* pool) -> VectorPtr {
+        return applyExtractionChain(input, chain, pool);
+      },
+      ARRAY(BIGINT()));
+
+  auto rowReaderOptions = dwio::common::RowReaderOptions();
+  rowReaderOptions.setScanSpec(spec);
+  rowReaderOptions.range(0, 544);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  VectorPtr result;
+  auto numRows = rowReader->next(100, result);
+  ASSERT_GT(numRows, 0);
+  auto* row = result->as<RowVector>();
+  ASSERT_EQ(row->childrenSize(), 1);
+
+  // Verify the transform was applied: the result should be ARRAY(BIGINT)
+  // (keys), not MAP.
+  auto* keysArray = row->childAt(0)->as<ArrayVector>();
+  ASSERT_NE(keysArray, nullptr);
+  ASSERT_EQ(keysArray->size(), numRows);
+
+  // Each map in the test file has some keys.  Verify array sizes are
+  // non-negative.
+  for (int i = 0; i < numRows; ++i) {
+    ASSERT_GE(keysArray->sizeAt(i), 0);
+  }
+}
+
+TEST_F(TextReaderTest, extractionMapValues) {
+  // Read a text file with a MAP column and apply a MapValues extraction
+  // transform via ScanSpec.
+  const auto type = ROW(
+      {{"col_string", VARCHAR()},
+       {"col_bigint_arr", ARRAY(BIGINT())},
+       {"col_double_arr", ARRAY(DOUBLE())},
+       {"col_map", MAP(BIGINT(), BOOLEAN())}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/", "examples/custom_delimiters_file");
+  auto readFile = std::make_shared<LocalReadFile>(path);
+
+  auto serDeOptions = dwio::common::SerDeOptions('\t', '|', '#', '\\', true);
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  readerOptions.setFileSchema(type);
+  readerOptions.setSerDeOptions(serDeOptions);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+
+  // Build a ScanSpec that projects only col_map with a MapValues extraction
+  // transform.
+  auto spec = std::make_shared<common::ScanSpec>("root");
+  auto* mapSpec = spec->addField("col_map", 0);
+  mapSpec->addAllChildFields(*MAP(BIGINT(), BOOLEAN()));
+
+  using connector::hive::applyExtractionChain;
+  using connector::hive::ExtractionPathElement;
+  using connector::hive::ExtractionPathElementPtr;
+  using connector::hive::ExtractionStep;
+  auto chain = std::vector<ExtractionPathElementPtr>{
+      ExtractionPathElement::simple(ExtractionStep::kMapValues)};
+  mapSpec->setExtractionType(common::ScanSpec::ExtractionType::kValues);
+  mapSpec->setTransform(
+      [chain](const VectorPtr& input, memory::MemoryPool* pool) -> VectorPtr {
+        return applyExtractionChain(input, chain, pool);
+      },
+      ARRAY(BOOLEAN()));
+
+  auto rowReaderOptions = dwio::common::RowReaderOptions();
+  rowReaderOptions.setScanSpec(spec);
+  rowReaderOptions.range(0, 544);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  VectorPtr result;
+  auto numRows = rowReader->next(100, result);
+  ASSERT_GT(numRows, 0);
+  auto* row = result->as<RowVector>();
+  ASSERT_EQ(row->childrenSize(), 1);
+
+  // Verify the transform was applied: the result should be ARRAY(BOOLEAN)
+  // (values), not MAP.
+  auto* valuesArray = row->childAt(0)->as<ArrayVector>();
+  ASSERT_NE(valuesArray, nullptr);
+  ASSERT_EQ(valuesArray->size(), numRows);
+
+  // Verify array sizes are non-negative.
+  for (int i = 0; i < numRows; ++i) {
+    ASSERT_GE(valuesArray->sizeAt(i), 0);
+  }
+}
+
+TEST_F(TextReaderTest, extractionMapKeyFilter) {
+  // Write a text file with a MAP(VARCHAR, BIGINT) column and apply a
+  // MapKeyFilter extraction transform via ScanSpec.
+  auto textFile = TempFilePath::create();
+  {
+    auto writeFile =
+        std::make_unique<LocalWriteFile>(textFile->getPath(), true, false);
+    // Row format: map entries separated by \x02, key-value by \x03.
+    // Row 0: {"a":1, "b":2, "c":3}
+    // Row 1: {"a":10, "d":40}
+    writeFile->append(
+        "a\x03"
+        "1\x02"
+        "b\x03"
+        "2\x02"
+        "c\x03"
+        "3\n"
+        "a\x03"
+        "10\x02"
+        "d\x03"
+        "40\n");
+    writeFile->close();
+  }
+
+  const auto type = ROW({{"col_map", MAP(VARCHAR(), BIGINT())}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+
+  auto readFile = std::make_shared<LocalReadFile>(textFile->getPath());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  readerOptions.setFileSchema(type);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+
+  // Build a ScanSpec with MapKeyFilter extraction for keys {"a", "b"}.
+  auto spec = std::make_shared<common::ScanSpec>("root");
+  auto* mapSpec = spec->addField("col_map", 0);
+  mapSpec->addAllChildFields(*MAP(VARCHAR(), BIGINT()));
+
+  using connector::hive::applyExtractionChain;
+  using connector::hive::ExtractionPathElement;
+  using connector::hive::ExtractionPathElementPtr;
+  using connector::hive::ExtractionStep;
+  auto chain = std::vector<ExtractionPathElementPtr>{
+      ExtractionPathElement::mapKeyFilter(std::vector<std::string>{"a", "b"})};
+  mapSpec->setTransform(
+      [chain](const VectorPtr& input, memory::MemoryPool* pool) -> VectorPtr {
+        return applyExtractionChain(input, chain, pool);
+      },
+      MAP(VARCHAR(), BIGINT()));
+
+  auto serDeOptions = dwio::common::SerDeOptions('\x01', '\x02', '\x03');
+  readerOptions.setSerDeOptions(serDeOptions);
+  input = std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  reader = factory->createReader(std::move(input), readerOptions);
+
+  auto rowReaderOptions = dwio::common::RowReaderOptions();
+  rowReaderOptions.setScanSpec(spec);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  VectorPtr result;
+  auto numRows = rowReader->next(100, result);
+  ASSERT_EQ(numRows, 2);
+  auto* row = result->as<RowVector>();
+  ASSERT_EQ(row->childrenSize(), 1);
+
+  // Verify the MapKeyFilter was applied: only keys "a" and "b" remain.
+  auto* filteredMap = row->childAt(0)->as<MapVector>();
+  ASSERT_NE(filteredMap, nullptr);
+  // Row 0: {"a":1, "b":2} kept, "c" filtered out.
+  ASSERT_EQ(filteredMap->sizeAt(0), 2);
+  // Row 1: {"a":10} kept, "d" filtered out.
+  ASSERT_EQ(filteredMap->sizeAt(1), 1);
+}
+
+TEST_F(TextReaderTest, extractionTransformOnMapColumn) {
+  // Read a text file with a MAP column and apply a Size extraction transform
+  // via ScanSpec.  The text reader uses RowReader::projectColumns() as
+  // fallback, which should apply the transform.
+  const auto type = ROW(
+      {{"col_string", VARCHAR()},
+       {"col_bigint_arr", ARRAY(BIGINT())},
+       {"col_double_arr", ARRAY(DOUBLE())},
+       {"col_map", MAP(BIGINT(), BOOLEAN())}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/", "examples/custom_delimiters_file");
+  auto readFile = std::make_shared<LocalReadFile>(path);
+
+  auto serDeOptions = dwio::common::SerDeOptions('\t', '|', '#', '\\', true);
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
+  readerOptions.setFileSchema(type);
+  readerOptions.setSerDeOptions(serDeOptions);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+
+  // Build a ScanSpec that projects only col_map with a Size extraction
+  // transform.
+  auto spec = std::make_shared<common::ScanSpec>("root");
+  auto* mapSpec = spec->addField("col_map", 0);
+  mapSpec->addAllChildFields(*MAP(BIGINT(), BOOLEAN()));
+
+  using connector::hive::applyExtractionChain;
+  using connector::hive::ExtractionPathElement;
+  using connector::hive::ExtractionPathElementPtr;
+  using connector::hive::ExtractionStep;
+  auto chain = std::vector<ExtractionPathElementPtr>{
+      ExtractionPathElement::simple(ExtractionStep::kSize)};
+  mapSpec->setExtractionType(common::ScanSpec::ExtractionType::kSize);
+  mapSpec->setTransform(
+      [chain](const VectorPtr& input, memory::MemoryPool* pool) -> VectorPtr {
+        return applyExtractionChain(input, chain, pool);
+      },
+      BIGINT());
+
+  auto rowReaderOptions = dwio::common::RowReaderOptions();
+  rowReaderOptions.setScanSpec(spec);
+  rowReaderOptions.range(0, 544);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  VectorPtr result;
+  auto numRows = rowReader->next(100, result);
+  ASSERT_GT(numRows, 0);
+  auto* row = result->as<RowVector>();
+  ASSERT_EQ(row->childrenSize(), 1);
+
+  // Verify the transform was applied: the result should be BIGINT (sizes),
+  // not MAP.
+  auto* sizes = row->childAt(0)->as<FlatVector<int64_t>>();
+  ASSERT_NE(sizes, nullptr);
+  ASSERT_EQ(sizes->size(), numRows);
+
+  // Each map entry in the test file has some keys.  Just verify sizes are
+  // non-negative.
+  for (int i = 0; i < numRows; ++i) {
+    ASSERT_GE(sizes->valueAt(i), 0);
+  }
+}
+
 } // namespace
 
 } // namespace facebook::velox::text
diff --git a/velox/dwio/text/tests/reader/examples/logical_types.gz b/velox/dwio/text/tests/reader/examples/logical_types.gz
new file mode 100644
index 00000000000..3a20dc8ceee
Binary files /dev/null and b/velox/dwio/text/tests/reader/examples/logical_types.gz differ
diff --git a/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.lz4 b/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.lz4
new file mode 100644
index 00000000000..fa1adc4234d
Binary files /dev/null and b/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.lz4 differ
diff --git a/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.lzo b/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.lzo
new file mode 100644
index 00000000000..951ed722424
Binary files /dev/null and b/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.lzo differ
diff --git a/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.snappy b/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.snappy
new file mode 100644
index 00000000000..3343cdfc53e
Binary files /dev/null and b/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.snappy differ
diff --git a/velox/dwio/text/tests/writer/BufferedWriterSinkTest.cpp b/velox/dwio/text/tests/writer/BufferedWriterSinkTest.cpp
index a7372b7b6a7..c19d5f3961c 100644
--- a/velox/dwio/text/tests/writer/BufferedWriterSinkTest.cpp
+++ b/velox/dwio/text/tests/writer/BufferedWriterSinkTest.cpp
@@ -16,11 +16,12 @@
 
 #include <gtest/gtest.h>
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/dwio/text/tests/writer/FileReaderUtil.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
 namespace facebook::velox::text {
+using namespace facebook::velox::common::testutil;
 
 class BufferedWriterSinkTest : public testing::Test,
                                public velox::test::VectorTestBase {
@@ -30,7 +31,7 @@ class BufferedWriterSinkTest : public testing::Test,
     dwio::common::LocalFileSink::registerFactory();
     rootPool_ = memory::memoryManager()->addRootPool("BufferedWriterSinkTest");
     leafPool_ = rootPool_->addLeafChild("BufferedWriterSinkTest");
-    tempPath_ = exec::test::TempDirectoryPath::create();
+    tempPath_ = TempDirectoryPath::create();
   }
 
  protected:
@@ -40,7 +41,7 @@ class BufferedWriterSinkTest : public testing::Test,
 
   std::shared_ptr<memory::MemoryPool> rootPool_;
   std::shared_ptr<memory::MemoryPool> leafPool_;
-  std::shared_ptr<exec::test::TempDirectoryPath> tempPath_;
+  std::shared_ptr<TempDirectoryPath> tempPath_;
 };
 
 TEST_F(BufferedWriterSinkTest, write) {
@@ -80,4 +81,103 @@ TEST_F(BufferedWriterSinkTest, abort) {
   uint64_t result = readFile(tempPath_->getPath(), filename);
   EXPECT_EQ(result, 10);
 }
+
+TEST_F(BufferedWriterSinkTest, oversizedWriteBypassesBuffer) {
+  // Regression test: a write whose payload exceeds the flush buffer size must
+  // drain anything buffered (preserving order) and forward the oversized
+  // payload directly to the underlying sink, instead of asserting.
+  constexpr uint64_t kFlushBufferSize = 16;
+  const std::string oversized(64, 'x');
+
+  const auto tempPath = tempPath_->getPath();
+  const auto filename = "test_buffered_oversized.txt";
+
+  auto filePath = fs::path(fmt::format("{}/{}", tempPath, filename));
+  auto sink = std::make_unique<dwio::common::LocalFileSink>(
+      filePath, dwio::common::FileSink::Options{.pool = leafPool_.get()});
+
+  auto bufferedWriterSink = std::make_unique<BufferedWriterSink>(
+      std::move(sink),
+      rootPool_->addLeafChild("bufferedWriterSinkTest"),
+      kFlushBufferSize);
+
+  // Small write that fits in the buffer, then an oversized write that must
+  // first drain the small one and then write directly to the sink.
+  const std::string prefix = "head:";
+  bufferedWriterSink->write(prefix.data(), prefix.size());
+  bufferedWriterSink->write(oversized.data(), oversized.size());
+  // Another small write after the bypass to confirm buffering still works.
+  const std::string suffix = ":tail";
+  bufferedWriterSink->write(suffix.data(), suffix.size());
+  bufferedWriterSink->close();
+
+  const auto fs = filesystems::getFileSystem(tempPath, nullptr);
+  const auto& file = fs->openFileForRead(filePath.string());
+  const auto fileSize = file->size();
+  std::string contents(fileSize, '\0');
+  file->pread(0, fileSize, contents.data());
+
+  EXPECT_EQ(contents, prefix + oversized + suffix);
+}
+
+namespace {
+// Reads the file at 'path/name' into a string.
+std::string readFileBytes(const std::string& path, const std::string& name) {
+  const auto fs = filesystems::getFileSystem(path, nullptr);
+  const auto filePath = fs::path(fmt::format("{}/{}", path, name));
+  const auto& file = fs->openFileForRead(filePath.string());
+  const auto fileSize = file->size();
+  std::string out(fileSize, '\0');
+  if (fileSize > 0) {
+    file->pread(0, fileSize, out.data());
+  }
+  return out;
+}
+} // namespace
+
+TEST_F(BufferedWriterSinkTest, writeEqualToFlushBufferUsesBufferedPath) {
+  // Boundary: a write of exactly flushBufferSize_ bytes is *not* oversized
+  // (the bypass condition is strict `size > flushBufferSize_`); it must go
+  // through the buffered path and land on disk intact after close().
+  constexpr uint64_t kFlushBufferSize = 16;
+  const std::string exact(kFlushBufferSize, 'a');
+
+  const auto tempPath = tempPath_->getPath();
+  const auto filename = "test_buffered_equal.txt";
+  auto filePath = fs::path(fmt::format("{}/{}", tempPath, filename));
+  auto sink = std::make_unique<dwio::common::LocalFileSink>(
+      filePath, dwio::common::FileSink::Options{.pool = leafPool_.get()});
+  auto bufferedWriterSink = std::make_unique<BufferedWriterSink>(
+      std::move(sink),
+      rootPool_->addLeafChild("bufferedWriterSinkTest"),
+      kFlushBufferSize);
+
+  bufferedWriterSink->write(exact.data(), exact.size());
+  bufferedWriterSink->close();
+
+  EXPECT_EQ(readFileBytes(tempPath, filename), exact);
+}
+
+TEST_F(BufferedWriterSinkTest, writeOneByteOverFlushBufferTriggersBypass) {
+  // Boundary: a write of flushBufferSize_ + 1 bytes is the smallest oversized
+  // write and must hit the bypass path. The buffer is empty so the flush() is
+  // a no-op; verify the payload still lands on disk in full.
+  constexpr uint64_t kFlushBufferSize = 16;
+  const std::string oneOver(kFlushBufferSize + 1, 'b');
+
+  const auto tempPath = tempPath_->getPath();
+  const auto filename = "test_buffered_one_over.txt";
+  auto filePath = fs::path(fmt::format("{}/{}", tempPath, filename));
+  auto sink = std::make_unique<dwio::common::LocalFileSink>(
+      filePath, dwio::common::FileSink::Options{.pool = leafPool_.get()});
+  auto bufferedWriterSink = std::make_unique<BufferedWriterSink>(
+      std::move(sink),
+      rootPool_->addLeafChild("bufferedWriterSinkTest"),
+      kFlushBufferSize);
+
+  bufferedWriterSink->write(oneOver.data(), oneOver.size());
+  bufferedWriterSink->close();
+
+  EXPECT_EQ(readFileBytes(tempPath, filename), oneOver);
+}
 } // namespace facebook::velox::text
diff --git a/velox/dwio/text/tests/writer/CMakeLists.txt b/velox/dwio/text/tests/writer/CMakeLists.txt
index f53ecec5bc3..eea5ac780da 100644
--- a/velox/dwio/text/tests/writer/CMakeLists.txt
+++ b/velox/dwio/text/tests/writer/CMakeLists.txt
@@ -18,6 +18,7 @@ add_executable(
   BufferedWriterSinkTest.cpp
   FileReaderUtil.cpp
 )
+velox_add_test_headers(velox_text_writer_test FileReaderUtil.h)
 
 add_test(
   NAME velox_text_writer_test
@@ -33,7 +34,6 @@ target_link_libraries(
   velox_dwio_text_reader_register
   velox_dwio_text_writer_register
   velox_link_libs
-  Boost::regex
   Folly::folly
   ${TEST_LINK_LIBS}
   GTest::gtest
diff --git a/velox/dwio/text/tests/writer/TextWriterTest.cpp b/velox/dwio/text/tests/writer/TextWriterTest.cpp
index d007c932362..c488ece97f6 100644
--- a/velox/dwio/text/tests/writer/TextWriterTest.cpp
+++ b/velox/dwio/text/tests/writer/TextWriterTest.cpp
@@ -17,10 +17,11 @@
 #include "velox/dwio/text/writer/TextWriter.h"
 #include "velox/buffer/Buffer.h"
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/io/IoStatistics.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/dwio/text/RegisterTextReader.h"
 #include "velox/dwio/text/RegisterTextWriter.h"
 #include "velox/dwio/text/tests/writer/FileReaderUtil.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
 #include <gtest/gtest.h>
@@ -28,6 +29,8 @@
 /// TODO: Add fuzzer test.
 
 namespace facebook::velox::text {
+using namespace facebook::velox::common::testutil;
+
 class TextWriterTest : public testing::Test,
                        public velox::test::VectorTestBase {
  public:
@@ -37,7 +40,7 @@ class TextWriterTest : public testing::Test,
     registerTextReaderFactory();
     rootPool_ = memory::memoryManager()->addRootPool("TextWriterTests");
     leafPool_ = rootPool_->addLeafChild("TextWriterTests");
-    tempPath_ = exec::test::TempDirectoryPath::create();
+    tempPath_ = TempDirectoryPath::create();
   }
 
   void TearDown() override {
@@ -62,9 +65,13 @@ class TextWriterTest : public testing::Test,
 
   constexpr static float kInf = std::numeric_limits<float>::infinity();
   constexpr static double kNaN = std::numeric_limits<double>::quiet_NaN();
+  std::shared_ptr<velox::io::IoStatistics> dataIoStats_ =
+      std::make_shared<velox::io::IoStatistics>();
+  std::shared_ptr<velox::io::IoStatistics> metadataIoStats_ =
+      std::make_shared<velox::io::IoStatistics>();
   std::shared_ptr<memory::MemoryPool> rootPool_;
   std::shared_ptr<memory::MemoryPool> leafPool_;
-  std::shared_ptr<exec::test::TempDirectoryPath> tempPath_;
+  std::shared_ptr<TempDirectoryPath> tempPath_;
 };
 
 TEST_F(TextWriterTest, write) {
@@ -225,7 +232,9 @@ TEST_F(TextWriterTest, verifyWriteWithTextReader) {
   auto readerFactory =
       dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
   auto readFile = std::make_shared<LocalReadFile>(filePath.string());
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(schema);
   auto input =
       std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
@@ -493,7 +502,9 @@ TEST_F(TextWriterTest, verifyMapAndArrayComplexTypesWithTextReader) {
   auto readerFactory =
       dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
   auto readFile = std::make_shared<LocalReadFile>(filePath.string());
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(schema);
   readerOptions.setSerDeOptions(serDeOptions);
   auto input =
@@ -684,7 +695,9 @@ TEST_F(TextWriterTest, verifyArrayTypesWithTextReader) {
   auto readerFactory =
       dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
   auto readFile = std::make_shared<LocalReadFile>(filePath.string());
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(schema);
   readerOptions.setSerDeOptions(serDeOptions);
 
@@ -922,7 +935,9 @@ TEST_F(TextWriterTest, verifyMapTypesWithTextReader) {
   auto readerFactory =
       dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
   auto readFile = std::make_shared<LocalReadFile>(filePath.string());
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(schema);
   readerOptions.setSerDeOptions(serDeOptions);
 
@@ -1077,7 +1092,9 @@ TEST_F(TextWriterTest, verifyNestedRowTypesWithTextReader) {
   auto readerFactory =
       dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
   auto readFile = std::make_shared<LocalReadFile>(filePath.string());
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(schema);
   readerOptions.setSerDeOptions(serDeOptions);
 
@@ -1465,7 +1482,9 @@ TEST_F(
   auto readerFactory =
       dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
   auto readFile = std::make_shared<LocalReadFile>(filePath.string());
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(schema);
   readerOptions.setSerDeOptions(serDeOptions);
 
@@ -1594,7 +1613,9 @@ TEST_F(TextWriterTest, verifySimpleEscapeCharTestWithTextReader) {
   auto readerFactory =
       dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
   auto readFile = std::make_shared<LocalReadFile>(filePath.string());
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(schema);
   readerOptions.setSerDeOptions(serDeOptions);
 
@@ -1726,7 +1747,9 @@ TEST_F(TextWriterTest, verifyCustomEscapeCharTestWithTextReader) {
   auto readerFactory =
       dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
   auto readFile = std::make_shared<LocalReadFile>(filePath.string());
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(schema);
   readerOptions.setSerDeOptions(serDeOptions);
 
@@ -1848,7 +1871,9 @@ TEST_F(TextWriterTest, verifyHeaderTestWithTextReader) {
   auto readerFactory =
       dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
   auto readFile = std::make_shared<LocalReadFile>(filePath.string());
-  auto readerOptions = dwio::common::ReaderOptions(pool());
+  dwio::common::ReaderOptions readerOptions(pool());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileSchema(schema);
   readerOptions.setSerDeOptions(serDeOptions);
 
diff --git a/velox/dwio/text/writer/BufferedWriterSink.cpp b/velox/dwio/text/writer/BufferedWriterSink.cpp
index e5de4a20401..3f62721b7ef 100644
--- a/velox/dwio/text/writer/BufferedWriterSink.cpp
+++ b/velox/dwio/text/writer/BufferedWriterSink.cpp
@@ -41,15 +41,20 @@ void BufferedWriterSink::write(char value) {
 }
 
 void BufferedWriterSink::write(const char* data, uint64_t size) {
-  // TODO Add logic for when size is larger than flushCount_
-  VELOX_CHECK_GE(
-      flushBufferSize_,
-      size,
-      "write data size exceeds flush buffer size limit");
-
   if (buf_->size() + size > flushBufferSize_) {
     flush();
   }
+
+  if (size > flushBufferSize_) {
+    // Oversized payload: grow the (now-empty) buffer to fit, fill it, then
+    // flush directly to the sink. flush() resets the buffer back to
+    // flushBufferSize_ on the way out via reserveBuffer().
+    buf_->reserve(size);
+    buf_->append(0, data, size);
+    flush();
+    return;
+  }
+
   buf_->append(buf_->size(), data, size);
 }
 
diff --git a/velox/dwio/text/writer/CMakeLists.txt b/velox/dwio/text/writer/CMakeLists.txt
index cc2657f5b0b..eba803d2958 100644
--- a/velox/dwio/text/writer/CMakeLists.txt
+++ b/velox/dwio/text/writer/CMakeLists.txt
@@ -12,6 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_dwio_text_writer TextWriter.cpp BufferedWriterSink.cpp)
+velox_add_library(
+  velox_dwio_text_writer
+  TextWriter.cpp
+  BufferedWriterSink.cpp
+  HEADERS
+  BufferedWriterSink.h
+  TextWriter.h
+)
 
 velox_link_libraries(velox_dwio_text_writer velox_dwio_common fmt::fmt)
diff --git a/velox/dwio/text/writer/TextWriter.cpp b/velox/dwio/text/writer/TextWriter.cpp
index f221257f1dc..be837b12522 100644
--- a/velox/dwio/text/writer/TextWriter.cpp
+++ b/velox/dwio/text/writer/TextWriter.cpp
@@ -70,13 +70,15 @@ TextWriter::TextWriter(
     const std::shared_ptr<text::WriterOptions>& options,
     const SerDeOptions& serDeOptions)
     : schema_(std::move(schema)),
-      bufferedWriterSink_(std::make_unique<BufferedWriterSink>(
-          std::move(sink),
-          options->memoryPool->addLeafChild(fmt::format(
-              "{}.text_writer_node.{}",
-              options->memoryPool->name(),
-              folly::to<std::string>(folly::Random::rand64()))),
-          options->defaultFlushCount)),
+      bufferedWriterSink_(
+          std::make_unique<BufferedWriterSink>(
+              std::move(sink),
+              options->memoryPool->addLeafChild(
+                  fmt::format(
+                      "{}.text_writer_node.{}",
+                      options->memoryPool->name(),
+                      folly::to<std::string>(folly::Random::rand64()))),
+              options->defaultFlushCount)),
       headerLineCount_(options->headerLineCount),
       serDeOptions_(serDeOptions) {
   VELOX_CHECK_LE(headerLineCount_, 1, "Header line count must be <= 1");
@@ -173,8 +175,9 @@ void TextWriter::flush() {
   bufferedWriterSink_->flush();
 }
 
-void TextWriter::close() {
+std::unique_ptr<dwio::common::FileMetadata> TextWriter::close() {
   bufferedWriterSink_->close();
+  return std::make_unique<TextFileMetadata>();
 }
 
 void TextWriter::abort() {
@@ -348,7 +351,7 @@ void TextWriter::writeCellValue(
       [[fallthrough]];
     default:
       VELOX_NYI(
-          "Text writer does not support type {}", mapTypeKindToName(type));
+          "Text writer does not support type {}", TypeKindName::toName(type));
   }
 
   VELOX_CHECK(
diff --git a/velox/dwio/text/writer/TextWriter.h b/velox/dwio/text/writer/TextWriter.h
index 2ec11b82685..045f7b7f5cb 100644
--- a/velox/dwio/text/writer/TextWriter.h
+++ b/velox/dwio/text/writer/TextWriter.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include "velox/dwio/common/FileMetadata.h"
 #include "velox/dwio/common/FileSink.h"
 #include "velox/dwio/common/Options.h"
 #include "velox/dwio/common/Writer.h"
@@ -26,6 +27,9 @@ namespace facebook::velox::text {
 
 using dwio::common::SerDeOptions;
 
+/// Text-specific file metadata wrapper. Currently a placeholder.
+class TextFileMetadata : public dwio::common::FileMetadata {};
+
 struct WriterOptions : public dwio::common::WriterOptions {
   int64_t defaultFlushCount = 10 << 10;
   uint8_t headerLineCount =
@@ -58,7 +62,7 @@ class TextWriter : public dwio::common::Writer {
     return true;
   }
 
-  void close() override;
+  std::unique_ptr<dwio::common::FileMetadata> close() override;
 
   void abort() override;
 
diff --git a/velox/examples/OperatorExtensibility.cpp b/velox/examples/OperatorExtensibility.cpp
index 6f48b4e9bbd..a6e4aaec682 100644
--- a/velox/examples/OperatorExtensibility.cpp
+++ b/velox/examples/OperatorExtensibility.cpp
@@ -124,8 +124,9 @@ class DuplicateRowOperator : public exec::Operator {
     outputChildren.reserve(input->childrenSize());
 
     for (const auto& child : input->children()) {
-      outputChildren.push_back(BaseVector::wrapInDictionary(
-          BufferPtr(), indices, outputSize, child));
+      outputChildren.push_back(
+          BaseVector::wrapInDictionary(
+              BufferPtr(), indices, outputSize, child));
     }
     return std::make_shared<RowVector>(
         pool(),
diff --git a/velox/examples/ScanAndSort.cpp b/velox/examples/ScanAndSort.cpp
index aee9144b172..4cc8cc97d2c 100644
--- a/velox/examples/ScanAndSort.cpp
+++ b/velox/examples/ScanAndSort.cpp
@@ -17,22 +17,24 @@
 #include "velox/common/base/Fs.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/memory/Memory.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
 #include "velox/dwio/common/FileSink.h"
 #include "velox/dwio/dwrf/RegisterDwrfReader.h"
 #include "velox/dwio/dwrf/RegisterDwrfWriter.h"
 #include "velox/exec/Task.h"
-#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/type/Type.h"
 #include "velox/vector/BaseVector.h"
 
 #include <folly/init/Init.h>
+#include <folly/system/HardwareConcurrency.h>
 #include <algorithm>
 
 using namespace facebook::velox;
+using namespace facebook::velox::common::testutil;
 
 // This file contains a step-by-step minimal example of a workflow that:
 //
@@ -91,7 +93,8 @@ int main(int argc, char** argv) {
       kHiveConnectorId,
       std::make_shared<config::ConfigBase>(
           std::unordered_map<std::string, std::string>()));
-  connector::registerConnector(hiveConnector);
+  connector::ConnectorRegistry::global().insert(
+      hiveConnector->connectorId(), hiveConnector);
 
   // To be able to read local files, we need to register the local file
   // filesystem. We also need to register the dwrf reader factory as well as a
@@ -104,7 +107,7 @@ int main(int argc, char** argv) {
   // Create a temporary dir to store the local file created. Note that this
   // directory is automatically removed when the `tempDir` object runs out of
   // scope.
-  auto tempDir = exec::test::TempDirectoryPath::create();
+  auto tempDir = TempDirectoryPath::create();
   auto absTempDirPath = tempDir->getPath();
 
   // Once we finalize setting up the Hive connector, let's define our query
@@ -125,7 +128,7 @@ int main(int argc, char** argv) {
 
   std::shared_ptr<folly::Executor> executor(
       std::make_shared<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency()));
+          folly::available_concurrency()));
 
   // Task is the top-level execution concept. A task needs a taskId (as a
   // string), the plan fragment to execute, a destination (only used for
@@ -135,7 +138,8 @@ int main(int argc, char** argv) {
       writerPlanFragment,
       /*destination=*/0,
       core::QueryCtx::create(executor.get()),
-      exec::Task::ExecutionMode::kSerial);
+      exec::Task::ExecutionMode::kSerial,
+      exec::Consumer{});
 
   // next() starts execution using the client thread. The loop pumps output
   // vectors out of the task (there are none in this query fragment).
@@ -165,7 +169,8 @@ int main(int argc, char** argv) {
       readPlanFragment,
       /*destination=*/0,
       core::QueryCtx::create(executor.get()),
-      exec::Task::ExecutionMode::kSerial);
+      exec::Task::ExecutionMode::kSerial,
+      exec::Consumer{});
 
   // Now that we have the query fragment and Task structure set up, we will
   // add data to it via `splits`.
diff --git a/velox/examples/ScanOrc.cpp b/velox/examples/ScanOrc.cpp
index 1f75f698324..0dbb79697a5 100644
--- a/velox/examples/ScanOrc.cpp
+++ b/velox/examples/ScanOrc.cpp
@@ -18,14 +18,16 @@
 #include <algorithm>
 
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/io/IoStatistics.h"
 #include "velox/common/memory/Memory.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/dwio/common/Reader.h"
 #include "velox/dwio/common/ReaderFactory.h"
 #include "velox/dwio/dwrf/RegisterDwrfReader.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/vector/BaseVector.h"
 
 using namespace facebook::velox;
+using namespace facebook::velox::common::testutil;
 using namespace facebook::velox::dwio::common;
 using namespace facebook::velox::dwrf;
 
@@ -48,7 +50,11 @@ int main(int argc, char** argv) {
   auto pool = facebook::velox::memory::memoryManager()->addLeafPool();
 
   std::string filePath{argv[1]};
-  dwio::common::ReaderOptions readerOpts{pool.get()};
+  auto dataIoStats = std::make_shared<io::IoStatistics>();
+  auto metadataIoStats = std::make_shared<io::IoStatistics>();
+  dwio::common::ReaderOptions readerOpts(pool.get());
+  readerOpts.setDataIoStats(dataIoStats);
+  readerOpts.setMetadataIoStats(metadataIoStats);
   // To make DwrfReader reads ORC file, setFileFormat to FileFormat::ORC
   readerOpts.setFileFormat(FileFormat::ORC);
   auto reader = dwio::common::getReaderFactory(FileFormat::ORC)
diff --git a/velox/examples/SimpleFunctions.cpp b/velox/examples/SimpleFunctions.cpp
index 4c12cb4bf51..e34b0598a22 100644
--- a/velox/examples/SimpleFunctions.cpp
+++ b/velox/examples/SimpleFunctions.cpp
@@ -341,7 +341,7 @@ struct MyRegexpMatchFunction {
     // quite expensive to compile it on a per-row basis. In this example we
     // support both modes (const and non-const).
     if (pattern != nullptr) {
-      re_.emplace(*pattern);
+      re_.emplace(std::string_view(*pattern));
     }
 
     // Optionally, one could also inspect the session configs in `QueryConfig`.
@@ -359,7 +359,8 @@ struct MyRegexpMatchFunction {
     // > `my_regexp_match(col1, col2)`
     result = re_.has_value()
         ? RE2::PartialMatch(toStringPiece(input), *re_)
-        : RE2::PartialMatch(toStringPiece(input), ::re2::RE2(pattern));
+        : RE2::PartialMatch(
+              toStringPiece(input), ::re2::RE2(std::string_view(pattern)));
     return true;
   }
 
diff --git a/velox/exec/AdaptivePrefetch.h b/velox/exec/AdaptivePrefetch.h
new file mode 100644
index 00000000000..afc44128116
--- /dev/null
+++ b/velox/exec/AdaptivePrefetch.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <algorithm>
+#include <chrono>
+
+namespace facebook::velox::exec {
+
+/// Adaptive prefetch look-ahead for loops with random memory accesses where
+/// the working set exceeds CPU cache. Measures per-iteration latency during
+/// initial iterations, then returns a fixed look-ahead for the remainder.
+class AdaptivePrefetch {
+ public:
+  explicit AdaptivePrefetch(int32_t numIterations)
+      : numIterations_(numIterations),
+        start_(std::chrono::steady_clock::now()) {}
+
+  /// Returns look-ahead distance, or 0 when too close to the end.
+  int32_t lookAhead() {
+    if (iteration_ == kMeasurementIterations) {
+      computeLookAhead();
+    }
+    ++iteration_;
+    if (iteration_ + lookAhead_ > numIterations_) {
+      return 0;
+    }
+    return lookAhead_;
+  }
+
+ private:
+  static constexpr int32_t kMeasurementIterations = 16;
+  static constexpr int32_t kMinLookAhead = 4;
+  static constexpr int32_t kMaxLookAhead = 32;
+  static constexpr int64_t kAssumedDramLatencyNs = 100;
+  static constexpr int64_t kCoefficient = 4;
+
+  void computeLookAhead() {
+    auto elapsedNs = std::chrono::duration_cast<std::chrono::nanoseconds>(
+                         std::chrono::steady_clock::now() - start_)
+                         .count();
+    lookAhead_ = std::clamp(
+        static_cast<int32_t>(
+            kCoefficient * kAssumedDramLatencyNs * kMeasurementIterations /
+            elapsedNs),
+        kMinLookAhead,
+        kMaxLookAhead);
+  }
+
+  int32_t numIterations_;
+  int32_t iteration_{0};
+  int32_t lookAhead_{kMinLookAhead};
+  std::chrono::steady_clock::time_point start_;
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/Aggregate.cpp b/velox/exec/Aggregate.cpp
index dd07b7e4436..c48cfe47a91 100644
--- a/velox/exec/Aggregate.cpp
+++ b/velox/exec/Aggregate.cpp
@@ -20,7 +20,6 @@
 #include "velox/exec/AggregateCompanionAdapter.h"
 #include "velox/exec/AggregateCompanionSignatures.h"
 #include "velox/exec/AggregateWindow.h"
-#include "velox/expression/SignatureBinder.h"
 
 namespace facebook::velox::exec {
 
@@ -139,6 +138,7 @@ std::vector<AggregateRegistrationResult> registerAggregateFunction(
     bool registerCompanionFunctions,
     bool overwrite) {
   auto size = names.size();
+  VELOX_CHECK_NE(size, 0, "Aggregate function registered without a name.");
   std::vector<AggregateRegistrationResult> registrationResults{size};
   for (int i = 0; i < size; ++i) {
     registrationResults[i] = registerAggregateFunction(
@@ -295,24 +295,6 @@ std::unique_ptr<Aggregate> Aggregate::create(
     const std::vector<TypePtr>& argTypes,
     const TypePtr& resultType,
     const core::QueryConfig& config) {
-  // TODO(timaou, kletkavrubashku): Reneable the validation once "regr_slope"
-  // signature is fixed
-  //
-  // Validate the result type. if (isPartialOutput(step)) {
-  //   auto intermediateType = Aggregate::intermediateType(name, argTypes);
-  //   VELOX_CHECK(
-  //       resultType->equivalent(*intermediateType),
-  //       "Intermediate type mismatch. Expected: {}, actual: {}",
-  //       intermediateType->toString(),
-  //       resultType->toString());
-  // } else {
-  //   auto finalType = Aggregate::finalType(name, argTypes);
-  //   VELOX_CHECK(
-  //       resultType->equivalent(*finalType),
-  //       "Final type mismatch. Expected: {}, actual: {}",
-  //       finalType->toString(),
-  //       resultType->toString());
-  // }
   // Lookup the function in the new registry first.
   if (auto func = getAggregateFunctionEntry(name)) {
     return func->factory(step, argTypes, resultType, config);
diff --git a/velox/exec/Aggregate.h b/velox/exec/Aggregate.h
index 69e7e16bd43..d38f91bc3af 100644
--- a/velox/exec/Aggregate.h
+++ b/velox/exec/Aggregate.h
@@ -93,6 +93,17 @@ class Aggregate {
     setAllocatorInternal(allocator);
   }
 
+  /// Called after construction to pass constant input values to the aggregate.
+  /// Non-constant inputs have null entries in 'constantInputs'. This is called
+  /// before any data is processed, allowing the aggregate to read constant
+  /// arguments (e.g., flags, configuration values) at initialization time
+  /// rather than extracting them from 'args' at runtime.
+  ///
+  /// Default implementation is a no-op. Override in subclasses that need
+  /// access to constant arguments.
+  virtual void setConstantInputs(
+      const std::vector<VectorPtr>& /*constantInputs*/) {}
+
   /// Called for functions that take one or more lambda expression as input.
   /// These expressions must appear after all non-lambda inputs.
   /// These expressions cannot use captures.
@@ -302,9 +313,22 @@ class Aggregate {
 
     for (auto* group : groups) {
       group[initializedByte_] &= ~initializedMask_;
+      clearNull(group);
     }
   }
 
+  /// Returns true if this aggregate function supports lightweight memory
+  /// compaction via compact().
+  virtual bool supportsCompact() const {
+    return false;
+  }
+
+  /// Invoked by GroupingSet::compact() to perform lightweight memory compaction
+  /// on the given 'groups', freeing unused memory without spilling to disk.
+  virtual uint64_t compact(folly::Range<char**> /*groups*/) {
+    return 0;
+  }
+
   // Clears state between reuses, e.g. this is called before reusing
   // the aggregation operator's state after flushing a partial
   // aggregation.
@@ -505,6 +529,10 @@ using AggregateFunctionFactory = std::function<std::unique_ptr<Aggregate>(
     const core::QueryConfig& config)>;
 
 struct AggregateFunctionMetadata {
+  /// True if results of the aggregation ignore duplicate values.
+  /// For example, min and max ignore duplicates while sum does not.
+  bool ignoreDuplicates{false};
+
   /// True if results of the aggregation depend on the order of inputs. For
   /// example, array_agg is order sensitive while count is not.
   bool orderSensitive{true};
diff --git a/velox/exec/AggregateCompanionAdapter.cpp b/velox/exec/AggregateCompanionAdapter.cpp
index ea3c64c5c9e..9aab4fbac9b 100644
--- a/velox/exec/AggregateCompanionAdapter.cpp
+++ b/velox/exec/AggregateCompanionAdapter.cpp
@@ -340,25 +340,35 @@ bool registerMergeExtractFunctionInternal(
              mergeExtractFunctionName,
              std::move(mergeExtractSignatures),
              [name, mergeExtractFunctionName](
-                 core::AggregationNode::Step /*step*/,
+                 core::AggregationNode::Step step,
                  const std::vector<TypePtr>& argTypes,
                  const TypePtr& resultType,
                  const core::QueryConfig& config)
                  -> std::unique_ptr<Aggregate> {
-               const auto& [originalResultType, _] =
-                   resolveAggregateFunction(mergeExtractFunctionName, argTypes);
-               if (!originalResultType) {
-                 // TODO: limitation -- result type must be resolvable given
-                 // intermediate type of the original UDAF.
-                 VELOX_UNREACHABLE(
-                     "Signatures whose result types are not resolvable given intermediate types should have been excluded.");
+               TypePtr functionResultType;
+               if (step == core::AggregationNode::Step::kFinal ||
+                   step == core::AggregationNode::Step::kSingle) {
+                 functionResultType = resultType;
+               } else {
+                 // When step is kPartial or kIntermediate, 'resultType' is
+                 // the intermediate type and the original result type needs to
+                 // be resolved for the aggregate function creation.
+                 const auto& originalResultType =
+                     resolveResultType(mergeExtractFunctionName, argTypes);
+                 if (!originalResultType) {
+                   // Result type must be resolvable given intermediate type of
+                   // the original UDAF.
+                   VELOX_FAIL(
+                       "Signatures' result types must be resolvable given intermediate types.");
+                 }
+                 functionResultType = originalResultType;
                }
 
                if (auto func = getAggregateFunctionEntry(name)) {
                  auto fn = func->factory(
                      core::AggregationNode::Step::kFinal,
                      argTypes,
-                     originalResultType,
+                     functionResultType,
                      config);
                  VELOX_CHECK_NOT_NULL(fn);
                  return std::make_unique<
diff --git a/velox/exec/AggregateCompanionAdapter.h b/velox/exec/AggregateCompanionAdapter.h
index 8a6af66ff51..fc0a5909f8a 100644
--- a/velox/exec/AggregateCompanionAdapter.h
+++ b/velox/exec/AggregateCompanionAdapter.h
@@ -169,21 +169,35 @@ struct AggregateCompanionAdapter {
   };
 };
 
+/// In Velox, "Step" is a property of the aggregate operator, whereas in
+/// Spark, it is tied to individual aggregate functions. Spark executes
+/// aggregates using a mix of partial, intermediate, and final aggregate
+/// functions. To bridge the two systems, the planner translates Spark's
+/// aggregate modes into corresponding Velox companion functions and assigns
+/// the "single" step to Velox’s AggregationNode. These companion functions
+/// are intended for internal use within the aggregate operator and are not
+/// designed to be used as standalone functions, and their result types
+/// may not always be inferable from intermediate types. More details can be
+/// found in
+/// https://github.com/facebookincubator/velox/pull/11999#issuecomment-3274577979
+/// and https://github.com/facebookincubator/velox/issues/12830.
 class CompanionFunctionsRegistrar {
  public:
-  // Register the partial companion function for an aggregation function of
-  // `name` and `signatures`. When there is already a function of the same name,
-  // if `overwrite` is true, the registration is replaced. Otherwise, return
-  // false without overwriting the registry.
+  /// Register the partial companion function for an aggregate function of
+  /// `name` and `signatures`. When there is already a function of the same
+  /// name, if `overwrite` is true, the registration is replaced. Otherwise,
+  /// return false without overwriting the registry. This function supports
+  /// generating Spark compatible companion functions.
   static bool registerPartialFunction(
       const std::string& name,
       const std::vector<AggregateFunctionSignaturePtr>& signatures,
       const AggregateFunctionMetadata& metadata,
       bool overwrite = false);
 
-  // When there is already a function of the same name as the merge companion
-  // function, if `overwrite` is true, the registration is replaced. Otherwise,
-  // return false without overwriting the registry.
+  /// When there is already a function of the same name as the merge companion
+  /// function, if `overwrite` is true, the registration is replaced. Otherwise,
+  /// return false without overwriting the registry. This function supports
+  /// generating Spark compatible companion functions.
   static bool registerMergeFunction(
       const std::string& name,
       const std::vector<AggregateFunctionSignaturePtr>& signatures,
@@ -204,14 +218,16 @@ class CompanionFunctionsRegistrar {
       const std::vector<AggregateFunctionSignaturePtr>& signatures,
       bool overwrite = false);
 
-  // Similar to registerExtractFunction(), the result type of the original
-  // aggregation function is required to be resolvable given its intermediate
-  // type. If there are multiple signatures of the original aggregation function
-  // with the same intermediate type, register merge-extract functions with
+  /// If there are multiple signatures of the original aggregate function
+  /// with the same intermediate type, register merge-extract functions with
   // suffix of their result types in the function names for each of them. When
-  // there is already a function of the same name as the merge-extract companion
-  // function, if `overwrite` is true, the registration is replaced. Otherwise,
-  // return false without overwriting the registry.
+  /// there is already a function of the same name as the merge-extract
+  /// companion function, if `overwrite` is true, the registration is replaced.
+  /// Otherwise, return false without overwriting the registry. This function
+  /// supports generating Spark compatible companion functions only when the
+  /// return types are explicitly specified (typically in "single" or "final"
+  /// steps). It will throw an exception if return types are not provided and
+  /// cannot be resolved from the intermediate types.
   static bool registerMergeExtractFunction(
       const std::string& name,
       const std::vector<AggregateFunctionSignaturePtr>& signatures,
diff --git a/velox/exec/AggregateCompanionSignatures.cpp b/velox/exec/AggregateCompanionSignatures.cpp
index 2fa7e8d11dc..c6da4488dc6 100644
--- a/velox/exec/AggregateCompanionSignatures.cpp
+++ b/velox/exec/AggregateCompanionSignatures.cpp
@@ -102,20 +102,18 @@ CompanionSignatures::partialFunctionSignatures(
     const std::vector<AggregateFunctionSignaturePtr>& signatures) {
   std::vector<AggregateFunctionSignaturePtr> partialSignatures;
   for (const auto& signature : signatures) {
-    if (!isResultTypeResolvableGivenIntermediateType(signature)) {
-      continue;
-    }
     std::vector<TypeSignature> usedTypes = signature->argumentTypes();
     usedTypes.push_back(signature->intermediateType());
     auto variables = usedTypeVariables(usedTypes, signature->variables());
 
-    partialSignatures.push_back(std::make_shared<AggregateFunctionSignature>(
-        /*variables*/ variables,
-        /*returnType*/ signature->intermediateType(),
-        /*intermediateType*/ signature->intermediateType(),
-        /*argumentTypes*/ signature->argumentTypes(),
-        /*constantArguments*/ signature->constantArguments(),
-        /*variableArity*/ signature->variableArity()));
+    partialSignatures.push_back(
+        std::make_shared<AggregateFunctionSignature>(
+            /*variables*/ variables,
+            /*returnType*/ signature->intermediateType(),
+            /*intermediateType*/ signature->intermediateType(),
+            /*argumentTypes*/ signature->argumentTypes(),
+            /*constantArguments*/ signature->constantArguments(),
+            /*variableArity*/ signature->variableArity()));
   }
   return partialSignatures;
 }
@@ -126,10 +124,6 @@ std::string CompanionSignatures::partialFunctionName(const std::string& name) {
 
 AggregateFunctionSignaturePtr CompanionSignatures::mergeFunctionSignature(
     const AggregateFunctionSignaturePtr& signature) {
-  if (!isResultTypeResolvableGivenIntermediateType(signature)) {
-    return nullptr;
-  }
-
   std::vector<TypeSignature> usedTypes = {signature->intermediateType()};
   auto variables = usedTypeVariables(usedTypes, signature->variables());
   return std::make_shared<AggregateFunctionSignature>(
@@ -172,10 +166,6 @@ bool CompanionSignatures::hasSameIntermediateTypesAcrossSignatures(
 AggregateFunctionSignaturePtr
 CompanionSignatures::mergeExtractFunctionSignature(
     const AggregateFunctionSignaturePtr& signature) {
-  if (!isResultTypeResolvableGivenIntermediateType(signature)) {
-    return nullptr;
-  }
-
   std::vector<TypeSignature> usedTypes = {
       signature->intermediateType(), signature->returnType()};
   auto variables = usedTypeVariables(usedTypes, signature->variables());
diff --git a/velox/exec/AggregateCompanionSignatures.h b/velox/exec/AggregateCompanionSignatures.h
index ea7d4b2d6ce..c0557adc091 100644
--- a/velox/exec/AggregateCompanionSignatures.h
+++ b/velox/exec/AggregateCompanionSignatures.h
@@ -106,8 +106,9 @@ class CompanionSignatures {
           normalizeType(signature->intermediateType(), signature->variables());
       auto normalizedReturnType =
           normalizeType(signature->returnType(), signature->variables());
-      if (distinctIntermediateAndResultTypes.count(std::make_pair(
-              normalizedIntermediateType, normalizedReturnType))) {
+      if (distinctIntermediateAndResultTypes.count(
+              std::make_pair(
+                  normalizedIntermediateType, normalizedReturnType))) {
         continue;
       }
 
diff --git a/velox/exec/AggregateFunctionRegistry.cpp b/velox/exec/AggregateFunctionRegistry.cpp
index 87373f37aa8..259888032cf 100644
--- a/velox/exec/AggregateFunctionRegistry.cpp
+++ b/velox/exec/AggregateFunctionRegistry.cpp
@@ -21,25 +21,75 @@
 
 namespace facebook::velox::exec {
 
-std::pair<TypePtr, TypePtr> resolveAggregateFunction(
+namespace {
+std::string makeSignatureNotSupportedError(
+    const std::string& name,
+    const std::vector<TypePtr>& argTypes,
+    const std::vector<std::shared_ptr<AggregateFunctionSignature>>&
+        signatures) {
+  std::stringstream error;
+  error << "Aggregate function signature is not supported: "
+        << toString(name, argTypes)
+        << ". Supported signatures: " << toString(signatures) << ".";
+  return error.str();
+}
+} // namespace
+
+TypePtr resolveResultType(
     const std::string& name,
     const std::vector<TypePtr>& argTypes) {
   if (auto signatures = getAggregateFunctionSignatures(name)) {
     for (const auto& signature : signatures.value()) {
-      SignatureBinder binder(*signature, argTypes);
+      SignatureBinder binder(*signature, argTypes, TypeCoercer::defaults());
       if (binder.tryBind()) {
-        return std::make_pair(
-            binder.tryResolveReturnType(),
-            binder.tryResolveType(signature->intermediateType()));
+        return binder.tryResolveReturnType();
       }
     }
 
-    std::stringstream error;
-    error << "Aggregate function signature is not supported: "
-          << toString(name, argTypes)
-          << ". Supported signatures: " << toString(signatures.value()) << ".";
-    VELOX_USER_FAIL(error.str());
+    VELOX_USER_FAIL(
+        makeSignatureNotSupportedError(name, argTypes, signatures.value()));
+  }
+
+  VELOX_USER_FAIL("Aggregate function not registered: {}", name);
+}
+
+TypePtr resolveResultTypeWithCoercions(
+    const std::string& name,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer) {
+  coercions.clear();
+
+  if (auto signatures = getAggregateFunctionSignatures(name)) {
+    std::vector<FunctionSignaturePtr> baseSignatures(
+        signatures.value().begin(), signatures.value().end());
+    if (auto type = tryResolveReturnTypeWithCoercions(
+            baseSignatures, argTypes, coercions, coercer)) {
+      return type;
+    }
+
+    VELOX_USER_FAIL(
+        makeSignatureNotSupportedError(name, argTypes, signatures.value()));
+  }
+
+  VELOX_USER_FAIL("Aggregate function not registered: {}", name);
+}
+
+TypePtr resolveIntermediateType(
+    const std::string& name,
+    const std::vector<TypePtr>& argTypes) {
+  if (auto signatures = getAggregateFunctionSignatures(name)) {
+    for (const auto& signature : signatures.value()) {
+      SignatureBinder binder(*signature, argTypes, TypeCoercer::defaults());
+      if (binder.tryBind()) {
+        return binder.tryResolveType(signature->intermediateType());
+      }
+    }
 
+    VELOX_USER_FAIL(
+        "Aggregate function signature is not supported: {}. Supported signatures: {}.",
+        toString(name, argTypes),
+        toString(signatures.value()));
   } else {
     VELOX_USER_FAIL("Aggregate function not registered: {}", name);
   }
diff --git a/velox/exec/AggregateFunctionRegistry.h b/velox/exec/AggregateFunctionRegistry.h
index 2ee6045907d..53eb8b87b32 100644
--- a/velox/exec/AggregateFunctionRegistry.h
+++ b/velox/exec/AggregateFunctionRegistry.h
@@ -19,15 +19,43 @@
 #include <vector>
 
 #include "velox/type/Type.h"
+#include "velox/type/TypeCoercer.h"
 
 namespace facebook::velox::exec {
 
-/// Given a name of aggregate function and argument types, returns a pair of the
-/// return type and intermediate type if the function exists. Throws if function
-/// doesn't exist or doesn't support specified argument types.
+/// Given a name of aggregate function and argument types, returns the result
+/// type if the function exists. Throws if function doesn't exist or doesn't
+/// support specified argument types. Since aggregate functions can be
+/// integrated into internal steps of an aggregate operator — rather than
+/// always being used as standalone functions at the SQL level — their result
+/// types may not always be inferable from the intermediate types. As a
+/// result, an exception might be thrown during the type resolution process. In
+/// such cases, the caller should explicitly specify the result type. More
+/// details can be found in
+/// https://github.com/facebookincubator/velox/pull/11999#issuecomment-3274577979
+/// and https://github.com/facebookincubator/velox/issues/12830.
+TypePtr resolveResultType(
+    const std::string& name,
+    const std::vector<TypePtr>& argTypes);
+
+/// Like 'resolveResultType', but with support for applying type conversions if
+/// a function signature doesn't match 'argTypes' exactly.
 ///
-/// @return a pair of {finalType, intermediateType}
-std::pair<TypePtr, TypePtr> resolveAggregateFunction(
+/// @param coercions A list of optional type coercions that were applied to
+/// resolve a function successfully. Contains one entry per argument. The entry
+/// is null if no coercion is required for that argument. The entry is not null
+/// if coercion is necessary.
+/// @param coercer Coercion rule set to use when resolving type coercions.
+TypePtr resolveResultTypeWithCoercions(
+    const std::string& name,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer);
+
+/// Given a name of aggregate function and argument types, returns the
+/// intermediate type if the function exists. Throws if function doesn't exist
+/// or doesn't support specified argument types.
+TypePtr resolveIntermediateType(
     const std::string& name,
     const std::vector<TypePtr>& argTypes);
 
diff --git a/velox/exec/AggregateInfo.cpp b/velox/exec/AggregateInfo.cpp
index a3f28c0684d..044a510e848 100644
--- a/velox/exec/AggregateInfo.cpp
+++ b/velox/exec/AggregateInfo.cpp
@@ -81,11 +81,10 @@ std::vector<AggregateInfo> toAggregateInfo(
             arg->toString());
       }
     }
+    const auto& name = aggregate.call->name();
 
-    info.distinct = aggregate.distinct;
-    info.intermediateType = resolveAggregateFunction(
-                                aggregate.call->name(), aggregate.rawInputTypes)
-                                .second;
+    info.intermediateType =
+        resolveIntermediateType(name, aggregate.rawInputTypes);
 
     // Setup aggregation mask: convert the Variable Reference name to the
     // channel (projection) index, if there is a mask.
@@ -98,13 +97,19 @@ std::vector<AggregateInfo> toAggregateInfo(
     auto index = numKeys + i;
     const auto& aggResultType = outputType->childAt(index);
     info.function = Aggregate::create(
-        aggregate.call->name(),
+        name,
         isPartialOutput(step) ? core::AggregationNode::Step::kPartial
                               : core::AggregationNode::Step::kSingle,
         aggregate.rawInputTypes,
         aggResultType,
         operatorCtx.driverCtx()->queryConfig());
 
+    // Pass constant inputs to the aggregate so it can read constant arguments
+    // (e.g., flags) at initialization time.
+    if (!constants.empty()) {
+      info.function->setConstantInputs(constants);
+    }
+
     auto lambdas = extractLambdaInputs(aggregate);
     if (!lambdas.empty()) {
       if (expressionEvaluator == nullptr) {
@@ -114,10 +119,13 @@ std::vector<AggregateInfo> toAggregateInfo(
       info.function->setLambdaExpressions(lambdas, expressionEvaluator);
     }
 
-    // Ignore sorting properties if aggregate function is not sensitive to the
-    // order of inputs.
-    auto* entry = getAggregateFunctionEntry(aggregate.call->name());
+    // 1. Ignore duplicates property
+    //    if aggregate function is not sensitive to duplicates.
+    // 2. Ignore sorting properties
+    //    if aggregate function is not sensitive to the order of inputs.
+    auto* entry = getAggregateFunctionEntry(name);
     const auto& metadata = entry->metadata;
+    info.distinct = !metadata.ignoreDuplicates && aggregate.distinct;
     if (metadata.orderSensitive) {
       // Sorting keys and orders.
       const auto numSortingKeys = aggregate.sortingKeys.size();
diff --git a/velox/exec/AggregateWindow.cpp b/velox/exec/AggregateWindow.cpp
index 2bdad5342c6..6c90a4fd1d5 100644
--- a/velox/exec/AggregateWindow.cpp
+++ b/velox/exec/AggregateWindow.cpp
@@ -150,7 +150,7 @@ class AggregateWindowFunction : public exec::WindowFunction {
         // This is the start of a new incremental aggregation. So the
         // aggregate_ function object should be initialized.
         auto singleGroup = std::vector<vector_size_t>{0};
-        aggregate_->clear();
+        aggregate_->destroy(folly::Range<char**>(&rawSingleGroupRow_, 1));
         aggregate_->initializeNewGroups(&rawSingleGroupRow_, singleGroup);
         aggregateInitialized_ = true;
       }
@@ -257,6 +257,11 @@ class AggregateWindowFunction : public exec::WindowFunction {
   void fillArgVectors(vector_size_t firstRow, vector_size_t lastRow) {
     vector_size_t numFrameRows = lastRow + 1 - firstRow;
     for (int i = 0; i < argIndices_.size(); i++) {
+      // Without the following call to `prepareForReuse`, if the type of
+      // `argVectors_[i]` is VARCHAR, then the string buffers will accumulate
+      // across calculations. As a result, memory consumption will increase over
+      // time. So we call `prepareForReuse` to clear string buffers timely.
+      argVectors_[i]->prepareForReuse();
       argVectors_[i]->resize(numFrameRows);
       // Only non-constant field argument vectors need to be populated. The
       // constant vectors are correctly set during aggregate initialization
@@ -331,7 +336,7 @@ class AggregateWindowFunction : public exec::WindowFunction {
       // TODO : Try to re-use previous computations by advancing and retracting
       // the aggregation based on the frame changes with each row. This would
       // require adding new APIs to the Aggregate framework.
-      aggregate_->clear();
+      aggregate_->destroy(folly::Range<char**>(&rawSingleGroupRow_, 1));
       aggregate_->initializeNewGroups(&rawSingleGroupRow_, kSingleGroup);
       aggregateInitialized_ = true;
 
diff --git a/velox/exec/ArrowStream.cpp b/velox/exec/ArrowStream.cpp
index e368844e41f..a456852c7d9 100644
--- a/velox/exec/ArrowStream.cpp
+++ b/velox/exec/ArrowStream.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 #include "velox/exec/ArrowStream.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/vector/arrow/Bridge.h"
 
 namespace facebook::velox::exec {
@@ -27,7 +28,7 @@ ArrowStream::ArrowStream(
           arrowStreamNode->outputType(),
           operatorId,
           arrowStreamNode->id(),
-          "ArrowStream") {
+          OperatorType::kArrowStream) {
   arrowStream_ = arrowStreamNode->arrowStream();
 }
 
diff --git a/velox/exec/AssignUniqueId.cpp b/velox/exec/AssignUniqueId.cpp
index e08898decfd..5428d326069 100644
--- a/velox/exec/AssignUniqueId.cpp
+++ b/velox/exec/AssignUniqueId.cpp
@@ -18,6 +18,8 @@
 #include <algorithm>
 #include <utility>
 
+#include "velox/exec/OperatorType.h"
+
 namespace facebook::velox::exec {
 
 AssignUniqueId::AssignUniqueId(
@@ -31,7 +33,7 @@ AssignUniqueId::AssignUniqueId(
           planNode->outputType(),
           operatorId,
           planNode->id(),
-          "AssignUniqueId"),
+          OperatorType::kAssignUniqueId),
       rowIdPool_(std::move(rowIdPool)) {
   VELOX_USER_CHECK_LT(
       uniqueTaskId,
diff --git a/velox/exec/BarrierSplit.h b/velox/exec/BarrierSplit.h
new file mode 100644
index 00000000000..3249b2eeaa2
--- /dev/null
+++ b/velox/exec/BarrierSplit.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cstdint>
+
+namespace facebook::velox::exec {
+
+/// A special split used by task barrier processing to signal output drain
+/// processing. When task barrier processing is triggered, one barrier split is
+/// added to each leaf source node. Once a source node receives the barrier
+/// split, it will produce output and propagate the barrier down to the root
+/// node of a pipeline (typically exchange or partitioned output).
+struct BarrierSplit {
+  /// The number of drivers in the source pipeline that share this barrier
+  /// split. It is used to deduplicate barrier processing at the root node of
+  /// the pipeline which blocks the barrier processing until all the pipelines
+  /// drivers have reached it.
+  uint32_t numDrivers;
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/BlockingReason.cpp b/velox/exec/BlockingReason.cpp
index ffe07aa41d8..325249defff 100644
--- a/velox/exec/BlockingReason.cpp
+++ b/velox/exec/BlockingReason.cpp
@@ -16,6 +16,8 @@
 
 #include "velox/exec/BlockingReason.h"
 
+#include "velox/common/EnumDefine.h"
+
 namespace facebook::velox::exec {
 
 namespace {
@@ -35,6 +37,8 @@ const auto& blockingReasonNames() {
       {BlockingReason::kWaitForArbitration, "kWaitForArbitration"},
       {BlockingReason::kWaitForScanScaleUp, "kWaitForScanScaleUp"},
       {BlockingReason::kWaitForIndexLookup, "kWaitForIndexLookup"},
+      {BlockingReason::kWaitForIndexSplits, "kWaitForIndexSplits"},
+      {BlockingReason::kWaitForRPC, "kWaitForRPC"},
   };
   return kNames;
 }
diff --git a/velox/exec/BlockingReason.h b/velox/exec/BlockingReason.h
index f89e808b099..6ecc81cd465 100644
--- a/velox/exec/BlockingReason.h
+++ b/velox/exec/BlockingReason.h
@@ -16,7 +16,8 @@
 
 #pragma once
 
-#include "velox/common/Enums.h"
+#include <fmt/format.h>
+#include "velox/common/EnumDeclare.h"
 
 namespace facebook::velox::exec {
 
@@ -55,6 +56,12 @@ enum class BlockingReason {
   /// Used by IndexLookupJoin operator, indicating that it was blocked by the
   /// async index lookup.
   kWaitForIndexLookup,
+  /// Used by IndexLookupJoin follower operators waiting for the leader to
+  /// finish collecting index splits via the IndexLookupJoinBridge.
+  kWaitForIndexSplits,
+  /// Used by RPC operators, indicating that the operator is blocked waiting
+  /// for an async RPC response (e.g., LLM inference, embedding lookups).
+  kWaitForRPC,
 };
 
 VELOX_DECLARE_ENUM_NAME(BlockingReason);
diff --git a/velox/exec/CMakeLists.txt b/velox/exec/CMakeLists.txt
index ba8457f888e..cbea17dc9b3 100644
--- a/velox/exec/CMakeLists.txt
+++ b/velox/exec/CMakeLists.txt
@@ -19,14 +19,14 @@ velox_add_library(
   AggregateCompanionSignatures.cpp
   AggregateFunctionRegistry.cpp
   AggregateInfo.cpp
-  AggregationMasks.cpp
   AggregateWindow.cpp
+  AggregationMasks.cpp
   ArrowStream.cpp
   AssignUniqueId.cpp
   BlockingReason.cpp
   CallbackSink.cpp
-  ContainerRowSerde.cpp
   ColumnStatsCollector.cpp
+  ContainerRowSerde.cpp
   DistinctAggregations.cpp
   Driver.cpp
   EnforceSingleRow.cpp
@@ -34,6 +34,7 @@ velox_add_library(
   ExchangeClient.cpp
   ExchangeQueue.cpp
   ExchangeSource.cpp
+  SerializedPage.cpp
   Expand.cpp
   FilterProject.cpp
   GroupId.cpp
@@ -44,57 +45,66 @@ velox_add_library(
   HashPartitionFunction.cpp
   HashProbe.cpp
   HashTable.cpp
+  HashTableCache.cpp
   IndexLookupJoin.cpp
+  IndexLookupJoinBridge.cpp
   JoinBridge.cpp
   Limit.cpp
   LocalPartition.cpp
   LocalPlanner.cpp
   MarkDistinct.cpp
+  MarkSorted.cpp
+  EnforceDistinct.cpp
   MemoryReclaimer.cpp
   Merge.cpp
   MergeJoin.cpp
   MergeSource.cpp
+  MixedUnion.cpp
   NestedLoopJoinBuild.cpp
   NestedLoopJoinProbe.cpp
+  SpatialIndex.cpp
   SpatialJoinBuild.cpp
   SpatialJoinProbe.cpp
   Operator.cpp
+  OperatorTraceCtx.cpp
+  OperatorTraceReader.cpp
+  OperatorTraceScan.cpp
+  OperatorTraceWriter.cpp
   OperatorUtils.cpp
   OrderBy.cpp
   OutputBuffer.cpp
   OutputBufferManager.cpp
-  OperatorTraceReader.cpp
-  OperatorTraceScan.cpp
-  OperatorTraceWriter.cpp
   ParallelProject.cpp
-  TaskStructs.cpp
-  TaskTraceReader.cpp
-  TaskTraceWriter.cpp
-  Trace.cpp
-  TraceUtil.cpp
-  PartitionedOutput.cpp
   PartitionFunction.cpp
   PartitionStreamingWindowBuild.cpp
+  PartitionedOutput.cpp
   PlanNodeStats.cpp
   PrefixSort.cpp
   ProbeOperatorState.cpp
-  RowsStreamingWindowBuild.cpp
+  SubPartitionedSortWindowBuild.cpp
   RowContainer.cpp
   RowNumber.cpp
-  ScaledScanController.cpp
+  RowsStreamingWindowBuild.cpp
   ScaleWriterLocalPartition.cpp
+  ScaledScanController.cpp
   SortBuffer.cpp
-  SortedAggregations.cpp
   SortWindowBuild.cpp
+  SortedAggregations.cpp
+  SpatialJoinBuild.cpp
+  SpatialJoinProbe.cpp
   Spill.cpp
   SpillFile.cpp
   Spiller.cpp
   StreamingAggregation.cpp
+  StreamingEnforceDistinct.cpp
   Strings.cpp
   TableScan.cpp
   TableWriteMerge.cpp
   TableWriter.cpp
   Task.cpp
+  TaskStructs.cpp
+  TaskTraceReader.cpp
+  TaskTraceWriter.cpp
   TopN.cpp
   TopNRowNumber.cpp
   Unnest.cpp
@@ -104,36 +114,153 @@ velox_add_library(
   WindowBuild.cpp
   WindowFunction.cpp
   WindowPartition.cpp
+  HEADERS
+  AddressableNonNullValueList.h
+  Aggregate.h
+  AdaptivePrefetch.h
+  AggregateCompanionAdapter.h
+  AggregateCompanionSignatures.h
+  AggregateFunctionRegistry.h
+  AggregateInfo.h
+  AggregateWindow.h
+  AggregationMasks.h
+  ArrowStream.h
+  AssignUniqueId.h
+  BarrierSplit.h
+  BlockingReason.h
+  CallbackSink.h
+  ColumnStatsCollector.h
+  ContainerRowSerde.h
+  DistinctAggregations.h
+  Driver.h
+  DriverStats.h
+  EnforceDistinct.h
+  EnforceSingleRow.h
+  Exchange.h
+  ExchangeClient.h
+  ExchangeQueue.h
+  ExchangeSource.h
+  Expand.h
+  FilterProject.h
+  GroupId.h
+  GroupingSet.h
+  HashAggregation.h
+  HashBitRange.h
+  HashBuild.h
+  HashJoinBridge.h
+  HashPartitionFunction.h
+  HashProbe.h
+  HashTable.h
+  HashTableCache.h
+  HilbertIndex.h
+  IndexLookupJoin.h
+  IndexLookupJoinBridge.h
+  JoinBridge.h
+  Limit.h
+  LocalPartition.h
+  LocalPlanner.h
+  MarkDistinct.h
+  MarkSorted.h
+  MemoryReclaimer.h
+  Merge.h
+  MergeJoin.h
+  MergeSource.h
+  MixedUnion.h
+  NestedLoopJoinBuild.h
+  NestedLoopJoinProbe.h
+  OneWayStatusFlag.h
+  Operator.h
+  OperatorStats.h
+  OperatorTraceCtx.h
+  OperatorTraceReader.h
+  OperatorTraceScan.h
+  OperatorTraceWriter.h
+  OperatorType.h
+  OperatorUtils.h
+  OrderBy.h
+  OutputBuffer.h
+  OutputBufferManager.h
+  ParallelProject.h
+  PartitionFunction.h
+  PartitionStreamingWindowBuild.h
+  PartitionedOutput.h
+  PlanNodeStats.h
+  PrefixSort.h
+  ProbeOperatorState.h
+  RoundRobinPartitionFunction.h
+  RowContainer.h
+  RowNumber.h
+  RowsStreamingWindowBuild.h
+  ScaleWriterLocalPartition.h
+  ScaledScanController.h
+  SerializedPage.h
+  SetAccumulator.h
+  SimpleAggregateAdapter.h
+  SortBuffer.h
+  SortWindowBuild.h
+  SortedAggregations.h
+  SpatialIndex.h
+  SpatialJoinBuild.h
+  SpatialJoinProbe.h
+  Spill.h
+  SpillFile.h
+  Spiller.h
+  Split.h
+  StreamingAggregation.h
+  StreamingEnforceDistinct.h
+  Strings.h
+  SubPartitionedSortWindowBuild.h
+  TableScan.h
+  TableWriteMerge.h
+  TableWriter.h
+  Task.h
+  TaskStats.h
+  TaskStructs.h
+  TaskTraceReader.h
+  TaskTraceWriter.h
+  TopN.h
+  TopNRowNumber.h
+  TraceUtil.h
+  Unnest.h
+  UnorderedStreamReader.h
+  Values.h
+  VectorHasher-inl.h
+  VectorHasher.h
+  Window.h
+  WindowBuild.h
+  WindowFunction.h
+  WindowPartition.h
 )
 
+velox_add_library(velox_exec_spill_stats SpillStats.cpp HEADERS SpillStats.h)
+velox_link_libraries(velox_exec_spill_stats velox_common_base velox_file Folly::folly)
+
 velox_link_libraries(
   velox_exec
-  velox_file
+  velox_arrow_bridge
+  velox_common_base
+  velox_common_compression
   velox_core
-  velox_vector
   velox_connector
+  velox_connector_registry
+  velox_exec_spill_stats
   velox_expression
+  velox_file
+  velox_presto_serializer
+  velox_trace
   velox_time
-  velox_common_base
   velox_test_util
-  velox_arrow_bridge
-  velox_common_compression
+  velox_vector
 )
 
-velox_add_library(velox_cursor Cursor.cpp)
-velox_link_libraries(
-  velox_cursor
-  velox_core
-  velox_exception
-  velox_expression
-  velox_dwio_common
-  velox_dwio_dwrf_reader
-  velox_dwio_dwrf_writer
-  velox_type_fbhive
-  velox_presto_serializer
-  velox_functions_prestosql
-  velox_aggregates
-)
+if(VELOX_ENABLE_GEO)
+  velox_compile_definitions(velox_exec PRIVATE VELOX_ENABLE_GEO)
+  velox_link_libraries(velox_exec velox_common_geospatial_serde)
+endif()
+
+velox_add_library(velox_cursor Cursor.cpp HEADERS Cursor.h)
+
+velox_link_libraries(velox_cursor velox_core velox_exception velox_expression)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(fuzzer)
@@ -147,3 +274,9 @@ if(${VELOX_ENABLE_BENCHMARKS})
 endif()
 
 add_subdirectory(prefixsort)
+add_subdirectory(rpc)
+add_subdirectory(trace)
+
+velox_add_library(velox_aggregate_util INTERFACE HEADERS AggregateUtil.h)
+
+velox_add_library(velox_operator_type INTERFACE HEADERS OperatorType.h)
diff --git a/velox/exec/CallbackSink.h b/velox/exec/CallbackSink.h
index dc8afd64763..199bbd9d8aa 100644
--- a/velox/exec/CallbackSink.h
+++ b/velox/exec/CallbackSink.h
@@ -16,6 +16,7 @@
 #pragma once
 
 #include "velox/exec/Operator.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/OperatorUtils.h"
 
 namespace facebook::velox::exec {
@@ -26,8 +27,14 @@ class CallbackSink : public Operator {
       int32_t operatorId,
       DriverCtx* driverCtx,
       Consumer consumeCb,
-      std::function<BlockingReason(ContinueFuture*)> startedCb = nullptr)
-      : Operator(driverCtx, nullptr, operatorId, "N/A", "CallbackSink"),
+      std::function<BlockingReason(ContinueFuture*)> startedCb = nullptr,
+      const std::string& planNodeId = "N/A")
+      : Operator(
+            driverCtx,
+            nullptr,
+            operatorId,
+            planNodeId,
+            OperatorType::kCallbackSink),
         startedCb_{std::move(startedCb)},
         consumeCb_{std::move(consumeCb)} {}
 
diff --git a/velox/exec/ColumnStatsCollector.cpp b/velox/exec/ColumnStatsCollector.cpp
index 1fcfab46cfe..1ec85678924 100644
--- a/velox/exec/ColumnStatsCollector.cpp
+++ b/velox/exec/ColumnStatsCollector.cpp
@@ -54,30 +54,9 @@ void ColumnStatsCollector::initialize() {
   VELOX_CHECK_NOT_NULL(groupingSet_);
 }
 
-// static
-RowTypePtr ColumnStatsCollector::outputType(
-    const core::ColumnStatsSpec& statsSpec) {
-  // Create output type based on the column stats collection specs.
-  std::vector<std::string> names;
-  std::vector<TypePtr> types;
-  const auto numAggregates = statsSpec.aggregates.size();
-  const auto outputTypeSize = statsSpec.groupingKeys.size() + numAggregates;
-  names.reserve(outputTypeSize);
-  types.reserve(outputTypeSize);
-  for (const auto& key : statsSpec.groupingKeys) {
-    names.push_back(key->name());
-    types.push_back(key->type());
-  }
-  for (auto i = 0; i < numAggregates; ++i) {
-    names.push_back(statsSpec.aggregateNames[i]);
-    types.push_back(statsSpec.aggregates[i].call->type());
-  }
-  return ROW(std::move(names), std::move(types));
-}
-
 void ColumnStatsCollector::setOutputType() {
   VELOX_CHECK_NULL(outputType_);
-  outputType_ = outputType(statsSpec_);
+  outputType_ = statsSpec_.outputType();
 }
 
 std::pair<std::vector<column_index_t>, std::vector<column_index_t>>
@@ -120,9 +99,8 @@ std::vector<AggregateInfo> ColumnStatsCollector::createAggregates(
       }
     }
     VELOX_CHECK(!aggregate.distinct);
-    info.intermediateType = resolveAggregateFunction(
-                                aggregate.call->name(), aggregate.rawInputTypes)
-                                .second;
+    info.intermediateType = resolveIntermediateType(
+        aggregate.call->name(), aggregate.rawInputTypes);
     // Column stats collection doesn't support aggregation mask.
     VELOX_CHECK_NULL(aggregate.mask);
     info.mask = std::nullopt;
@@ -181,7 +159,6 @@ void ColumnStatsCollector::addInput(RowVectorPtr input) {
     return;
   }
 
-  // Add input to the grouping set
   groupingSet_->addInput(input, /*mayPushdown=*/false);
 }
 
diff --git a/velox/exec/ColumnStatsCollector.h b/velox/exec/ColumnStatsCollector.h
index 26af22142e3..5c76f9af391 100644
--- a/velox/exec/ColumnStatsCollector.h
+++ b/velox/exec/ColumnStatsCollector.h
@@ -51,11 +51,6 @@ class ColumnStatsCollector {
       memory::MemoryPool* pool,
       tsan_atomic<bool>* nonReclaimableSection);
 
-  /// Returns the output row type that will be produced by this collector.
-  /// The output type is determined by the grouping keys and aggregate functions
-  /// specified in the ColumnStatsSpec.
-  static RowTypePtr outputType(const core::ColumnStatsSpec& statsSpec);
-
   /// Initializes the stats collector. Must be called exactly once before
   /// adding any input data. Sets up internal aggregation structures based
   /// on the provided ColumnStatsSpec.
diff --git a/velox/exec/ContainerRowSerde.cpp b/velox/exec/ContainerRowSerde.cpp
index 89f2de3f3a3..b571a0a7b95 100644
--- a/velox/exec/ContainerRowSerde.cpp
+++ b/velox/exec/ContainerRowSerde.cpp
@@ -388,11 +388,8 @@ std::optional<int32_t> compareSwitch(
 template <
     bool typeProvidesCustomComparison,
     TypeKind Kind,
-    std::enable_if_t<
-        Kind != TypeKind::VARCHAR && Kind != TypeKind::VARBINARY &&
-            Kind != TypeKind::ARRAY && Kind != TypeKind::MAP &&
-            Kind != TypeKind::ROW,
-        int32_t> = 0>
+    std::enable_if_t<!is_string_kind(Kind) && !is_nested_kind(Kind), int32_t> =
+        0>
 std::optional<int32_t> compare(
     ByteInputStream& left,
     const BaseVector& right,
@@ -693,11 +690,8 @@ std::optional<int32_t> compareSwitch(
 template <
     bool typeProvidesCustomComparison,
     TypeKind Kind,
-    std::enable_if_t<
-        Kind != TypeKind::VARCHAR && Kind != TypeKind::VARBINARY &&
-            Kind != TypeKind::ARRAY && Kind != TypeKind::MAP &&
-            Kind != TypeKind::ROW,
-        int32_t> = 0>
+    std::enable_if_t<!is_string_kind(Kind) && !is_nested_kind(Kind), int32_t> =
+        0>
 std::optional<int32_t> compare(
     ByteInputStream& left,
     ByteInputStream& right,
@@ -898,11 +892,8 @@ uint64_t hashSwitch(ByteInputStream& stream, const Type* type);
 template <
     bool typeProvidesCustomComparison,
     TypeKind Kind,
-    std::enable_if_t<
-        Kind != TypeKind::VARBINARY && Kind != TypeKind::VARCHAR &&
-            Kind != TypeKind::ARRAY && Kind != TypeKind::MAP &&
-            Kind != TypeKind::ROW,
-        int32_t> = 0>
+    std::enable_if_t<!is_string_kind(Kind) && !is_nested_kind(Kind), int32_t> =
+        0>
 uint64_t hashOne(ByteInputStream& stream, const Type* type) {
   using T = typename TypeTraits<Kind>::NativeType;
 
diff --git a/velox/exec/Cursor.cpp b/velox/exec/Cursor.cpp
index bdbbc0fe50c..1d807609e18 100644
--- a/velox/exec/Cursor.cpp
+++ b/velox/exec/Cursor.cpp
@@ -13,38 +13,89 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #include "velox/exec/Cursor.h"
-#include "velox/common/file/FileSystems.h"
 
+#include <folly/system/HardwareConcurrency.h>
 #include <filesystem>
+#include <optional>
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/common/future/VeloxPromise.h"
+#include "velox/exec/BlockingReason.h"
+#include "velox/vector/EncodedVectorCopy.h"
 
 namespace facebook::velox::exec {
+namespace {
 
-bool waitForTaskDriversToFinish(exec::Task* task, uint64_t maxWaitMicros) {
-  VELOX_USER_CHECK(!task->isRunning());
-  uint64_t waitMicros = 0;
-  while ((task->numFinishedDrivers() != task->numTotalDrivers()) &&
-         (waitMicros < maxWaitMicros)) {
-    const uint64_t kWaitMicros = 1000;
-    std::this_thread::sleep_for(std::chrono::microseconds(kWaitMicros));
-    waitMicros += kWaitMicros;
+class TaskQueue {
+ public:
+  struct TaskQueueEntry {
+    RowVectorPtr vector;
+    uint64_t bytes;
+  };
+
+  explicit TaskQueue(
+      uint64_t maxBytes,
+      const std::shared_ptr<memory::MemoryPool>& outputPool)
+      : pool_(
+            outputPool != nullptr ? outputPool
+                                  : memory::memoryManager()->addLeafPool()),
+        maxBytes_(maxBytes) {}
+
+  void setNumProducers(int32_t n) {
+    numProducers_ = n;
   }
 
-  if (task->numFinishedDrivers() != task->numTotalDrivers()) {
-    LOG(ERROR) << "Timed out waiting for all drivers of task " << task->taskId()
-               << " to finish. Finished drivers: " << task->numFinishedDrivers()
-               << ". Total drivers: " << task->numTotalDrivers();
+  // Adds a batch of rows to the queue and returns kNotBlocked if the
+  // producer may continue. Returns kWaitForConsumer if the queue is
+  // full after the addition and sets '*future' to a future that is
+  // realized when the producer may continue.
+  exec::BlockingReason
+  enqueue(RowVectorPtr vector, bool drained, velox::ContinueFuture* future);
+
+  // Returns nullptr when all producers are at end. Otherwise blocks.
+  RowVectorPtr dequeue();
+
+  void close();
+
+  bool hasNext();
+
+  velox::memory::MemoryPool* pool() const {
+    return pool_.get();
   }
 
-  return task->numFinishedDrivers() == task->numTotalDrivers();
-}
+  std::optional<int32_t> numProducers_;
+  std::atomic_int32_t numDrainedProducers_{0};
+
+ private:
+  // Owns the vectors in 'queue_', hence must be declared first.
+  std::shared_ptr<velox::memory::MemoryPool> pool_;
+  std::deque<TaskQueueEntry> queue_;
+  int32_t producersFinished_ = 0;
+  uint64_t totalBytes_ = 0;
+  // Blocks the producer if 'totalBytes' exceeds 'maxBytes' after
+  // adding the result.
+  uint64_t maxBytes_;
+  std::mutex mutex_;
+  std::vector<ContinuePromise> producerUnblockPromises_;
+  bool consumerBlocked_ = false;
+  ContinuePromise consumerPromise_{ContinuePromise::makeEmpty()};
+  ContinueFuture consumerFuture_;
+  bool closed_ = false;
+};
 
 exec::BlockingReason TaskQueue::enqueue(
     RowVectorPtr vector,
+    bool drained,
     velox::ContinueFuture* future) {
   if (!vector) {
     std::lock_guard<std::mutex> l(mutex_);
-    ++producersFinished_;
+    if (drained) {
+      ++numDrainedProducers_;
+    } else {
+      ++producersFinished_;
+    }
     if (consumerBlocked_) {
       consumerBlocked_ = false;
       consumerPromise_.setValue();
@@ -67,7 +118,8 @@ exec::BlockingReason TaskQueue::enqueue(
     consumerPromise_.setValue();
   }
   if (totalBytes_ > maxBytes_) {
-    auto [unblockPromise, unblockFuture] = makeVeloxContinuePromiseContract();
+    auto [unblockPromise, unblockFuture] =
+        makeVeloxContinuePromiseContract("TaskQueue::enqueue");
     producerUnblockPromises_.emplace_back(std::move(unblockPromise));
     *future = std::move(unblockFuture);
     return exec::BlockingReason::kWaitForConsumer;
@@ -96,10 +148,13 @@ RowVectorPtr TaskQueue::dequeue() {
       } else if (
           numProducers_.has_value() && producersFinished_ == numProducers_) {
         return nullptr;
+      } else if (numDrainedProducers_ == numProducers_) {
+        return nullptr;
       }
+
       if (!vector) {
         consumerBlocked_ = true;
-        consumerPromise_ = ContinuePromise();
+        consumerPromise_ = ContinuePromise("TaskQueue::dequeue");
         consumerFuture_ = consumerPromise_.getFuture();
       }
     }
@@ -161,8 +216,15 @@ class TaskCursorBase : public TaskCursor {
           fmt::format("TaskCursorQuery_{}", cursorQueryId++));
     }
 
-    if (!params.queryConfigs.empty()) {
-      auto configCopy = params.queryConfigs;
+    // If query configs needs to be overwritten in queryCtx.
+    if (!params.queryConfigs.empty() || !params.breakpoints.empty()) {
+      auto configCopy = !params.queryConfigs.empty()
+          ? params.queryConfigs
+          : queryCtx_->queryConfig().rawConfigsCopy();
+
+      if (!params.breakpoints.empty()) {
+        configCopy.insert({core::QueryConfig::kQueryTraceEnabled, "true"});
+      }
       queryCtx_->testingOverrideConfigUnsafe(std::move(configCopy));
     }
 
@@ -174,22 +236,25 @@ class TaskCursorBase : public TaskCursor {
 
     if (!params.spillDirectory.empty()) {
       taskSpillDirectory_ = params.spillDirectory + "/" + taskId_;
-      auto fileSystem =
-          velox::filesystems::getFileSystem(taskSpillDirectory_, nullptr);
-      VELOX_CHECK_NOT_NULL(fileSystem, "File System is null!");
-      try {
-        fileSystem->mkdir(taskSpillDirectory_);
-      } catch (...) {
-        LOG(ERROR) << "Faield to create task spill directory "
-                   << taskSpillDirectory_ << " base director "
-                   << params.spillDirectory << " exists["
-                   << std::filesystem::exists(taskSpillDirectory_) << "]";
-
-        std::rethrow_exception(std::current_exception());
-      }
+      taskSpillDirectoryCb_ = params.spillDirectoryCallback;
+      if (taskSpillDirectoryCb_ == nullptr) {
+        auto fileSystem =
+            velox::filesystems::getFileSystem(taskSpillDirectory_, nullptr);
+        VELOX_CHECK_NOT_NULL(fileSystem, "File System is null!");
+        try {
+          fileSystem->mkdir(taskSpillDirectory_);
+        } catch (...) {
+          LOG(ERROR) << "Faield to create task spill directory "
+                     << taskSpillDirectory_ << " base director "
+                     << params.spillDirectory << " exists["
+                     << std::filesystem::exists(taskSpillDirectory_) << "]";
+
+          std::rethrow_exception(std::current_exception());
+        }
 
-      LOG(INFO) << "Task spill directory[" << taskSpillDirectory_
-                << "] created";
+        LOG(INFO) << "Task spill directory[" << taskSpillDirectory_
+                  << "] created";
+      }
     }
   }
 
@@ -198,6 +263,7 @@ class TaskCursorBase : public TaskCursor {
   std::shared_ptr<core::QueryCtx> queryCtx_;
   core::PlanFragment planFragment_;
   std::string taskSpillDirectory_;
+  std::function<std::string()> taskSpillDirectoryCb_;
 
  private:
   std::shared_ptr<folly::Executor> executor_;
@@ -209,7 +275,7 @@ class MultiThreadedTaskCursor : public TaskCursorBase {
       : TaskCursorBase(
             params,
             std::make_shared<folly::CPUThreadPoolExecutor>(
-                std::thread::hardware_concurrency())),
+                folly::available_concurrency())),
         maxDrivers_{params.maxDrivers},
         numConcurrentSplitGroups_{params.numConcurrentSplitGroups},
         numSplitGroups_{params.numSplitGroups} {
@@ -222,7 +288,14 @@ class MultiThreadedTaskCursor : public TaskCursorBase {
         std::make_shared<TaskQueue>(params.bufferedBytes, params.outputPool);
 
     // Captured as a shared_ptr by the consumer callback of task_.
-    auto queue = queue_;
+    auto queueHolder = std::weak_ptr(queue_);
+    std::optional<common::SpillDiskOptions> spillDiskOpts;
+    if (!taskSpillDirectory_.empty()) {
+      spillDiskOpts = common::SpillDiskOptions{
+          .spillDirPath = taskSpillDirectory_,
+          .spillDirCreated = taskSpillDirectoryCb_ == nullptr,
+          .spillDirCreateCb = taskSpillDirectoryCb_};
+    }
     task_ = Task::create(
         taskId_,
         std::move(planFragment_),
@@ -230,35 +303,39 @@ class MultiThreadedTaskCursor : public TaskCursorBase {
         std::move(queryCtx_),
         Task::ExecutionMode::kParallel,
         // consumer
-        [queue, copyResult = params.copyResult](
+        [queueHolder, copyResult = params.copyResult, taskId = taskId_](
             const RowVectorPtr& vector,
             bool drained,
             velox::ContinueFuture* future) {
-          VELOX_CHECK(
-              !drained, "Unexpected drain in multithreaded task cursor");
-          if (!vector || !copyResult) {
-            return queue->enqueue(vector, future);
+          auto queue = queueHolder.lock();
+          if (queue == nullptr) {
+            LOG(ERROR) << "TaskQueue has been destroyed, taskId: " << taskId;
+            return exec::BlockingReason::kNotBlocked;
           }
-          // Make sure to load lazy vector if not loaded already.
-          for (auto& child : vector->children()) {
-            child->loadedVector();
+
+          if (!vector || !copyResult) {
+            return queue->enqueue(vector, drained, future);
           }
-          auto copy = BaseVector::create<RowVector>(
-              vector->type(), vector->size(), queue->pool());
-          copy->copy(vector.get(), 0, 0, vector->size());
-          return queue->enqueue(std::move(copy), future);
+          VectorPtr copy = encodedVectorCopy(
+              {.pool = queue->pool(), .reuseSource = false}, vector);
+          return queue->enqueue(
+              std::static_pointer_cast<RowVector>(std::move(copy)),
+              drained,
+              future);
         },
         0,
-        [queue](std::exception_ptr) {
+        std::move(spillDiskOpts),
+        [queueHolder, taskId = taskId_](std::exception_ptr) {
           // onError close the queue to unblock producers and consumers.
           // moveNext will handle rethrowing the error once it's
           // unblocked.
+          auto queue = queueHolder.lock();
+          if (queue == nullptr) {
+            LOG(ERROR) << "TaskQueue has been destroyed, taskId: " << taskId;
+            return;
+          }
           queue->close();
         });
-
-    if (!taskSpillDirectory_.empty()) {
-      task_->setSpillDirectory(taskSpillDirectory_);
-    }
   }
 
   ~MultiThreadedTaskCursor() override {
@@ -300,11 +377,22 @@ class MultiThreadedTaskCursor : public TaskCursorBase {
 
     checkTaskError();
     if (!current_) {
+      if (queue_->numDrainedProducers_ > 0) {
+        VELOX_CHECK(queue_->numProducers_.has_value());
+        VELOX_CHECK_EQ(
+            queue_->numDrainedProducers_.load(), queue_->numProducers_.value());
+        queue_->numDrainedProducers_ = 0;
+        return false;
+      }
       atEnd_ = true;
     }
     return current_ != nullptr;
   }
 
+  bool moveStep(const core::PlanNodeId& /*planId*/ = "") override {
+    return moveNext();
+  }
+
   void setNoMoreSplits() override {
     VELOX_CHECK(!noMoreSplits_);
     noMoreSplits_ = true;
@@ -314,14 +402,14 @@ class MultiThreadedTaskCursor : public TaskCursorBase {
     return noMoreSplits_;
   }
 
-  bool hasNext() override {
-    return queue_->hasNext();
-  }
-
   RowVectorPtr& current() override {
     return current_;
   }
 
+  core::PlanNodeId at() const override {
+    return ""; // always at task output.
+  }
+
   void setError(std::exception_ptr error) override {
     error_ = error;
     if (task_) {
@@ -371,17 +459,22 @@ class SingleThreadedTaskCursor : public TaskCursorBase {
     VELOX_CHECK(
         !queryCtx_->isExecutorSupplied(),
         "Executor should not be set in serial task cursor");
-
+    std::optional<common::SpillDiskOptions> spillDiskOpts;
+    if (!taskSpillDirectory_.empty()) {
+      spillDiskOpts = common::SpillDiskOptions{
+          .spillDirPath = taskSpillDirectory_,
+          .spillDirCreated = true,
+          .spillDirCreateCb = taskSpillDirectoryCb_};
+    }
     task_ = Task::create(
         taskId_,
         std::move(planFragment_),
         params.destination,
         std::move(queryCtx_),
-        Task::ExecutionMode::kSerial);
-
-    if (!taskSpillDirectory_.empty()) {
-      task_->setSpillDirectory(taskSpillDirectory_);
-    }
+        Task::ExecutionMode::kSerial,
+        std::function<BlockingReason(RowVectorPtr, bool, ContinueFuture*)>{},
+        0,
+        std::move(spillDiskOpts));
 
     VELOX_CHECK(
         task_->supportSerialExecutionMode(),
@@ -389,7 +482,7 @@ class SingleThreadedTaskCursor : public TaskCursorBase {
   }
 
   ~SingleThreadedTaskCursor() override {
-    if (task_ && !SingleThreadedTaskCursor::hasNext()) {
+    if (task_) {
       task_->requestCancel().wait();
     }
   }
@@ -408,26 +501,15 @@ class SingleThreadedTaskCursor : public TaskCursorBase {
   }
 
   bool moveNext() override {
-    if (!hasNext()) {
-      return false;
-    }
-    current_ = next_;
-    next_ = nullptr;
-    return true;
-  };
-
-  bool hasNext() override {
-    if (next_) {
-      return true;
-    }
     if (!task_->isRunning()) {
       return false;
     }
+
     while (true) {
       ContinueFuture future = ContinueFuture::makeEmpty();
       RowVectorPtr next = task_->next(&future);
       if (next != nullptr) {
-        next_ = next;
+        current_ = next;
         return true;
       }
       // When next is returned from task as a null pointer.
@@ -439,12 +521,21 @@ class SingleThreadedTaskCursor : public TaskCursorBase {
       VELOX_CHECK_NULL(next);
       future.wait();
     }
-  };
+    return false;
+  }
+
+  bool moveStep(const core::PlanNodeId& /*planId*/ = "") override {
+    return moveNext();
+  }
 
   RowVectorPtr& current() override {
     return current_;
   }
 
+  core::PlanNodeId at() const override {
+    return ""; // always at task output.
+  }
+
   void setError(std::exception_ptr error) override {
     error_ = error;
     if (task_) {
@@ -460,16 +551,434 @@ class SingleThreadedTaskCursor : public TaskCursorBase {
   std::shared_ptr<exec::Task> task_;
   bool noMoreSplits_{false};
   RowVectorPtr current_;
-  RowVectorPtr next_;
   std::exception_ptr error_;
 };
 
-std::unique_ptr<TaskCursor> TaskCursor::create(const CursorParameters& params) {
-  if (params.serialExecution) {
-    return std::make_unique<SingleThreadedTaskCursor>(params);
+/// Common base class for debugging cursors that support breakpoints.
+///
+/// Provides shared infrastructure for pausing execution at traced operators
+/// and inspecting intermediate results. Subclasses implement the execution
+/// model (serial vs parallel) via the `advance()` and `start()` methods.
+class TaskDebuggerCursorBase : public TaskCursorBase {
+ protected:
+  // Internal state for coordinating between the tracer and cursor.
+  //
+  // This struct manages the synchronization between the trace writer
+  // (which produces intermediate results) and the cursor (which consumes
+  // them).
+  struct TraceDriverState {
+    // Promise used to signal the tracer to continue after a partial result
+    // has been consumed.
+    ContinuePromise tracePromise{ContinuePromise::makeEmpty()};
+
+    // The most recent intermediate result from a traced operator.
+    RowVectorPtr traceData;
+
+    // The plan id where this state came from.
+    core::PlanNodeId planId;
+  };
+
+  struct TraceState {
+    std::deque<TraceDriverState> queue;
+    std::mutex mutex;
+
+    // Consumer blocking fields used by the parallel cursor to coordinate
+    // between the consumer callback and the advance() loop. In serial mode,
+    // consumerBlocked is never set to true, so the wakeup code is a no-op.
+    bool consumerBlocked = false;
+    ContinuePromise consumerPromise{ContinuePromise::makeEmpty()};
+    ContinueFuture consumerFuture;
+  };
+
+  // Custom trace context implementation for the debugger.
+  //
+  // This trace context pauses execution at traced operators by blocking
+  // the trace writer until the cursor consumes the intermediate result.
+  class TaskDebuggerTraceCtx : public trace::TraceCtx {
+   public:
+    // Constructs a trace context for the specified plan nodes.
+    //
+    // @param breakpoints Map of plan node IDs to optional callbacks.
+    // @param traceState Reference to the shared trace state for coordination.
+    TaskDebuggerTraceCtx(
+        const CursorParameters::TBreakpointMap& breakpoints,
+        TraceState& traceState)
+        : TraceCtx(false), breakpoints_(breakpoints), traceState_(traceState) {}
+
+    // Determines whether a given operator should be traced.
+    //
+    // @param op The operator to check.
+    // @return true if the operator's plan node ID is in the traced set.
+    bool shouldTrace(const Operator& op) const override {
+      return breakpoints_.contains(op.planNodeId());
+    }
+
+    // Creates an input trace writer for the given operator.
+    //
+    // @param op The operator to create a tracer for.
+    // @return A unique pointer to the trace input writer.
+    std::unique_ptr<trace::TraceInputWriter> createInputTracer(
+        Operator& op) const override {
+      auto it = breakpoints_.find(op.planNodeId());
+      return std::make_unique<TaskDebuggerTraceInputWriter>(
+          op.planNodeId(),
+          it != breakpoints_.end() ? it->second : nullptr,
+          traceState_);
+    }
+
+   private:
+    // Trace writer that captures input vectors and pauses execution.
+    //
+    // When an input vector is written, this writer stores it in the shared
+    // trace state and blocks until the cursor signals to continue.
+    class TaskDebuggerTraceInputWriter : public trace::TraceInputWriter {
+     public:
+      TaskDebuggerTraceInputWriter(
+          const core::PlanNodeId& planId,
+          CursorParameters::BreakpointCallback callback,
+          TraceState& traceState)
+          : planId_(planId),
+            callback_(std::move(callback)),
+            traceState_(traceState) {}
+
+      // Writes an input vector and potentially pauses execution.
+      //
+      // Invokes the callback if set. If the callback returns false, the writer
+      // does not block and execution continues. If the callback returns true
+      // (or is null), stores the vector in the trace state and creates a future
+      // that blocks until the cursor consumes the result and signals
+      // continuation.
+      //
+      // @param vector The input vector to trace.
+      // @param future Output parameter set to a future that blocks until
+      //        the cursor is ready to continue.
+      // @return true if the writer is blocked waiting for the future, false
+      //         if execution should continue without blocking.
+      bool write(const RowVectorPtr& vector, ContinueFuture* future) override {
+        // Invoke the callback if set. If it returns false, don't block.
+        if (callback_ && !callback_(vector)) {
+          return false;
+        }
+
+        std::lock_guard<std::mutex> l(traceState_.mutex);
+        traceState_.queue.push_back(
+            TraceDriverState{
+                .tracePromise = ContinuePromise("TaskQueue::dequeue"),
+                .traceData = vector,
+                .planId = planId_,
+            });
+        *future = traceState_.queue.back().tracePromise.getFuture();
+
+        // If the consumer is blocked waiting for output, unblock it.
+        if (traceState_.consumerBlocked) {
+          traceState_.consumerBlocked = false;
+          traceState_.consumerPromise.setValue();
+        }
+        return true;
+      }
+
+      // Called when tracing is complete for this operator.
+      void finish() override {}
+
+     private:
+      const core::PlanNodeId planId_;
+      const CursorParameters::BreakpointCallback callback_;
+      TraceState& traceState_;
+    };
+
+    CursorParameters::TBreakpointMap breakpoints_;
+    TraceState& traceState_;
+  };
+
+  using TaskCursorBase::TaskCursorBase;
+
+  /// Ensures the task completes before cleanup.
+  ~TaskDebuggerCursorBase() override {
+    if (task_) {
+      task_->requestCancel().wait();
+    }
+  }
+
+ public:
+  bool moveNext() override {
+    return advance(false);
+  }
+
+  bool moveStep(const core::PlanNodeId& planId = "") override {
+    return advance(true, planId);
+  }
+
+  RowVectorPtr& current() override {
+    return current_;
+  }
+
+  core::PlanNodeId at() const override {
+    if (pendingTraceDriverState_) {
+      return pendingTraceDriverState_->planId;
+    }
+    return "";
   }
-  return std::make_unique<MultiThreadedTaskCursor>(params);
-}
+
+  void setNoMoreSplits() override {
+    VELOX_CHECK(!noMoreSplits_);
+    noMoreSplits_ = true;
+  }
+
+  bool noMoreSplits() const override {
+    return noMoreSplits_;
+  }
+
+  void setError(std::exception_ptr error) override {
+    error_ = error;
+    if (task_) {
+      task_->setError(error);
+    }
+  }
+
+  const std::shared_ptr<Task>& task() override {
+    return task_;
+  }
+
+ protected:
+  // Advance to the next vector to produce, storing it in `current_`. If
+  // `isStep` is true, move to the next trace point or task output. If false,
+  // moves to the next task output.
+  //
+  // If `isStep` is true and `planId` is non-empty, only stops at trace points
+  // matching the given plan node ID; other trace points are skipped.
+  //
+  // Returns false when the task is done producing output.
+  virtual bool advance(bool isStep, const core::PlanNodeId& planId = "") = 0;
+
+  // Unblocks the trace writer (driver) from the previously consumed trace
+  // state.
+  void unblockPendingState() {
+    if (pendingTraceDriverState_) {
+      pendingTraceDriverState_->tracePromise.setValue();
+      pendingTraceDriverState_.reset();
+    }
+  }
+
+  std::shared_ptr<exec::Task> task_;
+  bool noMoreSplits_{false};
+  RowVectorPtr current_;
+  std::exception_ptr error_;
+
+  // Holds the trace state that was returned to the user via moveStep(),
+  // so its promise can be fulfilled on the next advance() call.
+  std::optional<TraceDriverState> pendingTraceDriverState_;
+};
+
+/// A debugging cursor for interactive serial task execution.
+///
+/// @note This class assumes serial (single-threaded) execution mode.
+class TaskDebuggerSerialCursor : public TaskDebuggerCursorBase {
+ public:
+  explicit TaskDebuggerSerialCursor(const CursorParameters& params)
+      : TaskDebuggerCursorBase(params, nullptr) {
+    // Installs the required trace provider.
+    queryCtx_->setTraceCtxProvider(
+        [&](core::QueryCtx&, const core::PlanFragment&) {
+          return std::make_unique<TaskDebuggerTraceCtx>(
+              params.breakpoints, traceState_);
+        });
+
+    task_ = Task::create(
+        taskId_,
+        std::move(planFragment_),
+        params.destination,
+        std::move(queryCtx_),
+        Task::ExecutionMode::kSerial);
+  }
+
+  // no-op
+  void start() override {}
+
+ private:
+  bool advance(bool isStep, const core::PlanNodeId& planId = "") override {
+    if (error_) {
+      std::rethrow_exception(error_);
+    }
+
+    unblockPendingState();
+
+    while (true) {
+      ContinueFuture future = ContinueFuture::makeEmpty();
+
+      if (auto vector = task_->next(&future)) {
+        current_ = vector;
+        return true;
+      }
+
+      // Check if any trace states have been queued by writers.
+      {
+        std::lock_guard<std::mutex> l(traceState_.mutex);
+        if (!traceState_.queue.empty()) {
+          auto state = std::move(traceState_.queue.front());
+          traceState_.queue.pop_front();
+
+          if (isStep && (planId.empty() || state.planId == planId)) {
+            current_ = state.traceData;
+            pendingTraceDriverState_ = std::move(state);
+            return true;
+          }
+
+          // Signal the task driver to unblock.
+          state.tracePromise.setValue();
+        }
+      }
+
+      // Wait until the task future is unblocked.
+      if (future.valid()) {
+        future.wait();
+      } else {
+        // When no vector was produced and the future is not valid, it's the
+        // task signal that it has finished producing output.
+        VELOX_CHECK(!task_->isRunning() || !noMoreSplits_);
+        break;
+      }
+    }
+    return false;
+  }
+
+  TraceState traceState_;
+};
+
+/// A debugging cursor for interactive parallel task execution.
+///
+/// Uses a consumer callback to receive output from parallel drivers.
+class TaskDebuggerParallelCursor : public TaskDebuggerCursorBase {
+ public:
+  explicit TaskDebuggerParallelCursor(const CursorParameters& params)
+      : TaskDebuggerCursorBase(
+            params,
+            std::make_shared<folly::CPUThreadPoolExecutor>(
+                folly::available_concurrency())),
+        maxDrivers_(params.maxDrivers),
+        numConcurrentSplitGroups_(params.numConcurrentSplitGroups) {
+    // Installs the required trace provider.
+    queryCtx_->setTraceCtxProvider(
+        [&](core::QueryCtx&, const core::PlanFragment&) {
+          return std::make_unique<TaskDebuggerTraceCtx>(
+              params.breakpoints, traceState_);
+        });
+
+    task_ = Task::create(
+        taskId_,
+        std::move(planFragment_),
+        params.destination,
+        std::move(queryCtx_),
+        Task::ExecutionMode::kParallel,
+        // consumer
+        [&](const RowVectorPtr& vector,
+            bool drained,
+            velox::ContinueFuture* future) {
+          VELOX_CHECK(
+              !drained, "Unexpected drain in multithreaded task cursor");
+
+          if (!vector) {
+            // End-of-stream from a driver. Track completion and wake the
+            // consumer if it's blocked waiting for data.
+            std::lock_guard<std::mutex> l(traceState_.mutex);
+            ++traceState_.numFinishedProducers;
+            if (traceState_.consumerBlocked) {
+              traceState_.consumerBlocked = false;
+              traceState_.consumerPromise.setValue();
+            }
+            return exec::BlockingReason::kNotBlocked;
+          }
+
+          std::lock_guard<std::mutex> l(traceState_.mutex);
+          traceState_.queue.push_back(
+              TraceDriverState{
+                  .tracePromise = ContinuePromise("TaskQueue::dequeue"),
+                  .traceData = vector,
+                  .planId = "",
+              });
+          *future = traceState_.queue.back().tracePromise.getFuture();
+
+          if (traceState_.consumerBlocked) {
+            traceState_.consumerBlocked = false;
+            traceState_.consumerPromise.setValue();
+          }
+          return exec::BlockingReason::kWaitForConsumer;
+        });
+  }
+
+  void start() override {
+    if (!started_) {
+      started_ = true;
+      try {
+        task_->start(maxDrivers_, numConcurrentSplitGroups_);
+        numProducers_ = task_->numOutputDrivers();
+      } catch (const VeloxException& e) {
+        // Could not find output pipeline, due to Task terminated before
+        // start. Do not override the error.
+        if (e.message().find("Output pipeline not found for task") ==
+            std::string::npos) {
+          throw;
+        }
+      }
+    }
+  }
+
+ private:
+  bool advance(bool isStep, const core::PlanNodeId& planId = "") override {
+    start();
+    if (error_) {
+      std::rethrow_exception(error_);
+    }
+
+    unblockPendingState();
+
+    while (true) {
+      // Check if any trace states have been queued by writers.
+      {
+        std::lock_guard<std::mutex> l(traceState_.mutex);
+        if (!traceState_.queue.empty()) {
+          auto state = std::move(traceState_.queue.front());
+          traceState_.queue.pop_front();
+
+          const bool matchesPlanId = planId.empty() || state.planId == planId;
+          if ((isStep && matchesPlanId) || state.planId.empty()) {
+            current_ = state.traceData;
+            pendingTraceDriverState_ = std::move(state);
+            return true;
+          }
+
+          // moveNext() skips breakpoint trace data, or the planId filter
+          // didn't match; unblock the trace writer (driver).
+          state.tracePromise.setValue();
+        }
+
+        // Queue is empty. If all producers have finished, we're done.
+        if (traceState_.numFinishedProducers >= numProducers_) {
+          break;
+        }
+
+        traceState_.consumerBlocked = true;
+        traceState_.consumerPromise = ContinuePromise("TaskQueue::dequeue");
+        traceState_.consumerFuture = traceState_.consumerPromise.getFuture();
+      }
+      traceState_.consumerFuture.wait();
+    }
+    return false;
+  }
+
+  struct ParallelTraceState : TraceState {
+    // Number of output drivers that have finished (sent a null vector).
+    int numFinishedProducers{0};
+  };
+
+  ParallelTraceState traceState_;
+
+  bool started_{false};
+  int32_t maxDrivers_;
+  int32_t numConcurrentSplitGroups_;
+  int numProducers_{0};
+};
+
+} // namespace
 
 bool RowCursor::next() {
   if (++currentRow_ < numRows_) {
@@ -498,8 +1007,38 @@ bool RowCursor::next() {
   return true;
 }
 
-bool RowCursor::hasNext() {
-  return currentRow_ < numRows_ || cursor_->hasNext();
+std::unique_ptr<TaskCursor> TaskCursor::create(const CursorParameters& params) {
+  if (!params.breakpoints.empty()) {
+    if (params.serialExecution) {
+      return std::make_unique<TaskDebuggerSerialCursor>(params);
+    } else {
+      return std::make_unique<TaskDebuggerParallelCursor>(params);
+    }
+  }
+
+  if (params.serialExecution) {
+    return std::make_unique<SingleThreadedTaskCursor>(params);
+  }
+  return std::make_unique<MultiThreadedTaskCursor>(params);
+}
+
+bool waitForTaskDriversToFinish(exec::Task* task, uint64_t maxWaitMicros) {
+  VELOX_USER_CHECK(!task->isRunning());
+  uint64_t waitMicros = 0;
+  while ((task->numFinishedDrivers() != task->numTotalDrivers()) &&
+         (waitMicros < maxWaitMicros)) {
+    const uint64_t kWaitMicros = 1000;
+    std::this_thread::sleep_for(std::chrono::microseconds(kWaitMicros));
+    waitMicros += kWaitMicros;
+  }
+
+  if (task->numFinishedDrivers() != task->numTotalDrivers()) {
+    LOG(ERROR) << "Timed out waiting for all drivers of task " << task->taskId()
+               << " to finish. Finished drivers: " << task->numFinishedDrivers()
+               << ". Total drivers: " << task->numTotalDrivers();
+  }
+
+  return task->numFinishedDrivers() == task->numTotalDrivers();
 }
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/Cursor.h b/velox/exec/Cursor.h
index 57d1ec8380a..7f859e98c61 100644
--- a/velox/exec/Cursor.h
+++ b/velox/exec/Cursor.h
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #pragma once
 
 #include "velox/core/PlanNode.h"
@@ -21,19 +22,13 @@
 
 namespace facebook::velox::exec {
 
-/// Wait up to maxWaitMicros for all the task drivers to finish. The function
-/// returns true if all the drivers have finished, otherwise false.
-///
-/// NOTE: user must call this on a finished or failed task.
-bool waitForTaskDriversToFinish(
-    exec::Task* task,
-    uint64_t maxWaitMicros = 1'000'000);
-
 /// Parameters for initializing a TaskCursor or RowCursor.
 struct CursorParameters {
   /// Root node of the plan tree
   std::shared_ptr<const core::PlanNode> planNode;
 
+  /// Partition number if task is expected to receive data from a remote data
+  /// shuffle. Used to initialize ExchangeClient.
   int32_t destination{0};
 
   /// Maximum number of drivers per pipeline.
@@ -69,7 +64,13 @@ struct CursorParameters {
 
   /// Spilling directory, if not empty, then the task's spilling directory
   /// would be built from it.
-  std::string spillDirectory;
+  std::string spillDirectory = "";
+
+  /// Callback function to dynamically create or determine the spill directory
+  /// path at runtime. If provided, this callback is invoked when spilling is
+  /// needed and must return a valid directory path. This allows for dynamic
+  /// spill directory creation or path resolution based on runtime conditions.
+  std::function<std::string()> spillDirectoryCallback = nullptr;
 
   bool copyResult = true;
 
@@ -81,65 +82,58 @@ struct CursorParameters {
 
   /// If both 'queryConfigs' and 'queryCtx' are specified, the configurations
   /// in 'queryCtx' will be overridden by 'queryConfig'.
-  std::unordered_map<std::string, std::string> queryConfigs;
-};
+  std::unordered_map<std::string, std::string> queryConfigs = {};
 
-class TaskQueue {
- public:
-  struct TaskQueueEntry {
-    RowVectorPtr vector;
-    uint64_t bytes;
-  };
-
-  explicit TaskQueue(
-      uint64_t maxBytes,
-      const std::shared_ptr<memory::MemoryPool>& outputPool)
-      : pool_(
-            outputPool != nullptr ? outputPool
-                                  : memory::memoryManager()->addLeafPool()),
-        maxBytes_(maxBytes) {}
-
-  void setNumProducers(int32_t n) {
-    numProducers_ = n;
-  }
-
-  // Adds a batch of rows to the queue and returns kNotBlocked if the
-  // producer may continue. Returns kWaitForConsumer if the queue is
-  // full after the addition and sets '*future' to a future that is
-  // realized when the producer may continue.
-  exec::BlockingReason enqueue(
-      RowVectorPtr vector,
-      velox::ContinueFuture* future);
-
-  // Returns nullptr when all producers are at end. Otherwise blocks.
-  RowVectorPtr dequeue();
-
-  void close();
+  // Debugging related structures:
 
-  bool hasNext();
-
-  velox::memory::MemoryPool* pool() const {
-    return pool_.get();
-  }
-
- private:
-  // Owns the vectors in 'queue_', hence must be declared first.
-  std::shared_ptr<velox::memory::MemoryPool> pool_;
-  std::deque<TaskQueueEntry> queue_;
-  std::optional<int32_t> numProducers_;
-  int32_t producersFinished_ = 0;
-  uint64_t totalBytes_ = 0;
-  // Blocks the producer if 'totalBytes' exceeds 'maxBytes' after
-  // adding the result.
-  uint64_t maxBytes_;
-  std::mutex mutex_;
-  std::vector<ContinuePromise> producerUnblockPromises_;
-  bool consumerBlocked_ = false;
-  ContinuePromise consumerPromise_;
-  ContinueFuture consumerFuture_;
-  bool closed_ = false;
+  /// Callback type for breakpoints.
+  ///
+  /// Called with the current vector when the breakpoint is hit. The return
+  /// value semantics is "should block?"; returns true if the driver should stop
+  /// and produce the vector, false to continue without stopping.
+  ///
+  /// If callback is not specified (nullptr), assume the partial vector should
+  /// always be produced, which is the same as callback returning true (always
+  /// stop).
+  using BreakpointCallback = std::function<bool(const RowVectorPtr&)>;
+
+  /// Map type for breakpoints: plan node ID to optional callback.
+  using TBreakpointMap =
+      std::unordered_map<core::PlanNodeId, BreakpointCallback>;
+
+  /// Breakpoints enable step-by-step execution of a query plan, allowing users
+  /// to inspect intermediate results at operator boundaries containing
+  /// breakpoints. This is useful for debugging query execution and
+  /// understanding data flow through operators.
+  ///
+  /// Maps plan node IDs to optional callbacks. When a breakpoint is hit, the
+  /// callback (if non-null) is invoked with the current vector before the
+  /// cursor pauses.
+  TBreakpointMap breakpoints = {};
 };
 
+/// Abstract interface for iterating over query results. TaskCursor manages
+/// task execution and provides batch-level access to output vectors.
+///
+/// Example usage:
+/// @code
+///
+///   auto cursor = TaskCursor:create({
+///     .planNode = node,
+///   );
+///
+///   // Run through every output.
+///   while (cursor->moveNext()) {
+///     auto vector = cursor->current();
+///   }
+/// @endcode
+///
+/// If "breakpoints" are set in the CursorParameters input, then
+/// `cursor->moveStep()` will move the cursor to the next breakpoint, which is
+/// either the input of an operator with a breakpoint installed, or the next
+/// task output.
+///
+/// `cursor->moveNext()` will always move the cursor to the next task output.
 class TaskCursor {
  public:
   virtual ~TaskCursor() = default;
@@ -149,14 +143,32 @@ class TaskCursor {
   /// Starts the task if not started yet.
   virtual void start() = 0;
 
-  /// Fetches another batch from the task queue.
-  /// Starts the task if not started yet.
+  /// Fetches another batch from the task queue. Starts the task if not started
+  /// yet.
+  ///
+  /// @return Returns false is the task is done producing output.
   virtual bool moveNext() = 0;
 
-  virtual bool hasNext() = 0;
+  /// Steps through execution, returning either the input to the next operator
+  /// with a breakpoint installed, or the next task output. If no breakpoints
+  /// are set, then moveStep() == moveNext().
+  ///
+  /// If @planId is non-empty, only stops at a breakpoint whose plan node ID
+  /// matches @planId; breakpoints for other plan nodes are skipped
+  /// (unblocked) automatically. When empty (the default), stops at the next
+  /// breakpoint regardless of plan node ID.
+  ///
+  /// @return Returns false is the task is done producing output.
+  virtual bool moveStep(const core::PlanNodeId& planId = "") = 0;
 
+  /// Returns the vector the cursor is currently on.
   virtual RowVectorPtr& current() = 0;
 
+  /// If breakpoints are set, returns the plan node that generated the trace. If
+  /// the cursor is at the task output or if there are no breakpoints,
+  /// returns empty string.
+  virtual core::PlanNodeId at() const = 0;
+
   virtual void setError(std::exception_ptr error) = 0;
 
   virtual bool noMoreSplits() const = 0;
@@ -166,6 +178,8 @@ class TaskCursor {
   virtual const std::shared_ptr<Task>& task() = 0;
 };
 
+/// Row-level cursor that wraps a TaskCursor and provides access to individual
+/// rows and column values within the result set.
 class RowCursor {
  public:
   explicit RowCursor(CursorParameters& params) {
@@ -185,8 +199,6 @@ class RowCursor {
 
   bool next();
 
-  bool hasNext();
-
   std::shared_ptr<Task> task() const {
     return cursor_->task();
   }
@@ -204,4 +216,12 @@ class RowCursor {
   vector_size_t numRows_ = 0;
 };
 
+/// Wait up to maxWaitMicros for all the task drivers to finish. The function
+/// returns true if all the drivers have finished, otherwise false.
+///
+/// NOTE: user must call this on a finished or failed task.
+bool waitForTaskDriversToFinish(
+    exec::Task* task,
+    uint64_t maxWaitMicros = 1'000'000);
+
 } // namespace facebook::velox::exec
diff --git a/velox/exec/DistinctAggregations.cpp b/velox/exec/DistinctAggregations.cpp
index e51413d4843..81936cd7a3f 100644
--- a/velox/exec/DistinctAggregations.cpp
+++ b/velox/exec/DistinctAggregations.cpp
@@ -20,6 +20,152 @@ namespace facebook::velox::exec {
 
 namespace {
 
+// Handles distinct aggregations where all inputs are constants.
+// The distinct set of a constant tuple is always either empty or a single
+// element, so it only needs a boolean flag per group indicating whether any
+// row was seen.
+class ConstantDistinctAggregations : public DistinctAggregations {
+ public:
+  ConstantDistinctAggregations(
+      std::vector<AggregateInfo*> aggregates,
+      memory::MemoryPool* pool)
+      : pool_{pool}, aggregates_{std::move(aggregates)} {
+    for (const auto& aggregate : aggregates_) {
+      for (size_t i = 0; i < aggregate->inputs.size(); ++i) {
+        VELOX_DCHECK_NOT_NULL(aggregate->constantInputs[i]);
+      }
+    }
+  }
+
+  Accumulator accumulator() const override {
+    return {/*isFixedSize=*/true,
+            sizeof(bool),
+            /*usesExternalMemory=*/false,
+            /*alignment=*/1,
+            BOOLEAN(),
+            /*spillExtractFunction=*/
+            [this](folly::Range<char**> groups, VectorPtr& result) {
+              extractForSpill(groups, result);
+            },
+            /*destroyFunction=*/nullptr};
+  }
+
+  void addInput(
+      char** groups,
+      const RowVectorPtr& /*input*/,
+      const SelectivityVector& rows) override {
+    rows.applyToSelected([&](vector_size_t i) { value(groups[i]) = true; });
+  }
+
+  void addSingleGroupInput(
+      char* group,
+      const RowVectorPtr& /*input*/,
+      const SelectivityVector& /*rows*/) override {
+    value(group) = true;
+  }
+
+  void extractValues(folly::Range<char**> groups, const RowVectorPtr& result)
+      override {
+    raw_vector<int32_t> indices(pool_);
+    for (const auto& aggregate : aggregates_) {
+      // All inputs are constant, so the aggregate result is identical for every
+      // group that saw rows. Compute it once and broadcast.
+      // Check whether any group is non-empty.
+      bool hasNonEmpty = false;
+      for (vector_size_t i = 0; i < groups.size(); ++i) {
+        if (value(groups[i])) {
+          hasNonEmpty = true;
+          break;
+        }
+      }
+
+      if (groups.size() < 2 || !hasNonEmpty) {
+        // With 0 or 1 groups no broadcasting is needed.  If all groups
+        // are empty, there is no need to add input, so just extract directly.
+        if (hasNonEmpty) {
+          VELOX_CHECK_EQ(groups.size(), 1);
+          const SelectivityVector rows(1);
+          aggregate->function->addSingleGroupRawInput(
+              groups[0], rows, aggregate->constantInputs, false);
+        }
+        aggregate->function->extractValues(
+            groups.data(), groups.size(), &result->childAt(aggregate->output));
+      } else {
+        // Use groups[0] as the non-empty representative and groups[1] as the
+        // empty representative. Extract from these two into a 2-row vector,
+        // then wrap the output in a dictionary that maps each group to the
+        // appropriate row.
+        const SelectivityVector rows(1);
+        aggregate->function->addSingleGroupRawInput(
+            groups[0], rows, aggregate->constantInputs, false);
+
+        std::array<char*, 2> representatives = {groups[0], groups[1]};
+        auto extracted =
+            BaseVector::create(aggregate->function->resultType(), 2, pool_);
+        aggregate->function->extractValues(
+            representatives.data(), 2, &extracted);
+
+        auto dictIndices = allocateIndices(groups.size(), pool_);
+        auto* rawIndices = dictIndices->asMutable<vector_size_t>();
+        for (vector_size_t i = 0; i < groups.size(); ++i) {
+          // Index 0 = non-empty value, index 1 = empty/default value.
+          rawIndices[i] = value(groups[i]) ? 0 : 1;
+        }
+        result->childAt(aggregate->output) = BaseVector::wrapInDictionary(
+            nullptr,
+            std::move(dictIndices),
+            groups.size(),
+            std::move(extracted));
+      }
+
+      aggregate->function->destroy(groups);
+      aggregate->function->initializeNewGroups(
+          groups.data(),
+          folly::Range<const int32_t*>(
+              iota(groups.size(), indices), groups.size()));
+    }
+  }
+
+  void addSingleGroupSpillInput(
+      char* group,
+      const VectorPtr& input,
+      vector_size_t index) override {
+    if (input->as<FlatVector<bool>>()->valueAt(index)) {
+      value(group) = true;
+    }
+  }
+
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    for (auto index : indices) {
+      groups[index][nullByte_] |= nullMask_;
+      value(groups[index]) = false;
+    }
+
+    for (const auto& aggregate : aggregates_) {
+      aggregate->function->initializeNewGroups(groups, indices);
+    }
+  }
+
+ private:
+  bool& value(char* group) const {
+    return *reinterpret_cast<bool*>(group + offset_);
+  }
+
+  void extractForSpill(folly::Range<char**> groups, VectorPtr& result) const {
+    auto* flatResult = result->asFlatVector<bool>();
+    flatResult->resize(groups.size());
+    for (auto i = 0; i < groups.size(); ++i) {
+      flatResult->set(i, value(groups[i]));
+    }
+  }
+
+  memory::MemoryPool* const pool_;
+  const std::vector<AggregateInfo*> aggregates_;
+};
+
 template <
     typename T,
     typename AccumulatorType = aggregate::prestosql::SetAccumulator<T>>
@@ -28,35 +174,37 @@ class TypedDistinctAggregations : public DistinctAggregations {
   TypedDistinctAggregations(
       std::vector<AggregateInfo*> aggregates,
       const RowTypePtr& inputType,
+      std::vector<column_index_t> nonConstantInputs,
       memory::MemoryPool* pool)
       : pool_{pool},
         aggregates_{std::move(aggregates)},
-        inputs_{aggregates_[0]->inputs},
-        inputType_(TypedDistinctAggregations::makeInputTypeForAccumulator(
-            inputType,
-            inputs_)) {}
+        nonConstantInputs_{std::move(nonConstantInputs)},
+        inputType_(makeInputTypeForAccumulator(inputType, nonConstantInputs_)),
+        spillType_(ARRAY(inputType_)),
+        singleNonConstantInput_(nonConstantInputs_.size() == 1) {}
 
   /// Returns metadata about the accumulator used to store unique inputs.
   Accumulator accumulator() const override {
-    return {
-        false, // isFixedSize
-        sizeof(AccumulatorType),
-        false, // usesExternalMemory
-        1, // alignment
-        nullptr,
-        [](folly::Range<char**> /*groups*/, VectorPtr& /*result*/) {
-          VELOX_UNREACHABLE();
-        },
-        [this](folly::Range<char**> groups) {
-          for (auto* group : groups) {
-            if (!isInitialized(group)) {
-              continue;
-            }
-            auto* accumulator =
-                reinterpret_cast<AccumulatorType*>(group + offset_);
-            accumulator->free(*allocator_);
-          }
-        }};
+    return {/*isFixedSize=*/false,
+            sizeof(AccumulatorType),
+            /*usesExternalMemory=*/false,
+            /*alignment=*/1,
+            spillType_,
+            /*spillExtractFunction=*/
+            [this](folly::Range<char**> groups, VectorPtr& result) {
+              extractForSpill(groups, result);
+            },
+            /*destroyFunction=*/
+            [this](folly::Range<char**> groups) {
+              for (auto* group : groups) {
+                if (!isInitialized(group)) {
+                  continue;
+                }
+                auto* accumulator =
+                    reinterpret_cast<AccumulatorType*>(group + offset_);
+                accumulator->free(*allocator_);
+              }
+            }};
   }
 
   void addInput(
@@ -99,12 +247,18 @@ class TypedDistinctAggregations : public DistinctAggregations {
       const auto& aggregate = *aggregates_[i];
 
       // For each group, add distinct inputs to aggregate.
+      VectorPtr data;
       for (auto* group : groups) {
         auto* accumulator = reinterpret_cast<AccumulatorType*>(group + offset_);
 
         // TODO Process group rows in batches to avoid creating very large input
         // vectors.
-        auto data = BaseVector::create(inputType_, accumulator->size(), pool_);
+        if (!data) {
+          data = BaseVector::create(inputType_, accumulator->size(), pool_);
+        } else {
+          BaseVector::prepareForReuse(data, accumulator->size());
+        }
+
         if constexpr (std::is_same_v<T, ComplexType>) {
           accumulator->extractValues(*data, 0);
         } else {
@@ -114,7 +268,7 @@ class TypedDistinctAggregations : public DistinctAggregations {
         if (data->size() > 0) {
           rows.resize(data->size());
           std::vector<VectorPtr> inputForAggregation =
-              makeInputForAggregation(data);
+              makeInputForAggregation(data, aggregate);
           aggregate.function->addSingleGroupRawInput(
               group, rows, inputForAggregation, false);
         }
@@ -137,13 +291,25 @@ class TypedDistinctAggregations : public DistinctAggregations {
     }
   }
 
+  void addSingleGroupSpillInput(
+      char* group,
+      const VectorPtr& input,
+      vector_size_t index) override {
+    auto* elementArray = input->asChecked<ArrayVector>();
+    decodedInput_.decode(*elementArray->elements());
+
+    auto* accumulator = reinterpret_cast<AccumulatorType*>(group + offset_);
+    RowSizeTracker<char, uint32_t> tracker(group[rowSizeOffset_], *allocator_);
+    accumulator->addValues(*elementArray, index, decodedInput_, allocator_);
+  }
+
  protected:
   void initializeNewGroupsInternal(
       char** groups,
       folly::Range<const vector_size_t*> indices) override {
-    for (auto i : indices) {
-      groups[i][nullByte_] |= nullMask_;
-      new (groups[i] + offset_) AccumulatorType(inputType_, allocator_);
+    for (auto index : indices) {
+      groups[index][nullByte_] |= nullMask_;
+      new (groups[index] + offset_) AccumulatorType(inputType_, allocator_);
     }
 
     for (auto i = 0; i < aggregates_.size(); ++i) {
@@ -153,10 +319,6 @@ class TypedDistinctAggregations : public DistinctAggregations {
   }
 
  private:
-  bool isSingleInputAggregate() const {
-    return aggregates_[0]->inputs.size() == 1;
-  }
-
   void decodeInput(const RowVectorPtr& input, const SelectivityVector& rows) {
     inputForAccumulator_ = makeInputForAccumulator(input);
     decodedInput_.decode(*inputForAccumulator_, rows);
@@ -164,45 +326,108 @@ class TypedDistinctAggregations : public DistinctAggregations {
 
   static TypePtr makeInputTypeForAccumulator(
       const RowTypePtr& rowType,
-      const std::vector<column_index_t>& inputs) {
-    if (inputs.size() == 1) {
-      return rowType->childAt(inputs[0]);
+      const std::vector<column_index_t>& inputChannels) {
+    const auto numInputChannels = inputChannels.size();
+    if (numInputChannels == 1) {
+      return rowType->childAt(inputChannels[0]);
     }
 
     // Otherwise, synthesize a ROW(distinct_channels[0..N])
     std::vector<TypePtr> types;
+    types.reserve(numInputChannels);
     std::vector<std::string> names;
-    for (column_index_t channelIndex : inputs) {
-      names.emplace_back(rowType->nameOf(channelIndex));
-      types.emplace_back(rowType->childAt(channelIndex));
+    names.reserve(numInputChannels);
+    for (column_index_t inputChannel : inputChannels) {
+      names.emplace_back(rowType->nameOf(inputChannel));
+      types.emplace_back(rowType->childAt(inputChannel));
     }
     return ROW(std::move(names), std::move(types));
   }
 
   VectorPtr makeInputForAccumulator(const RowVectorPtr& input) const {
-    if (isSingleInputAggregate()) {
-      return input->childAt(inputs_[0]);
+    if (singleNonConstantInput_) {
+      return input->childAt(nonConstantInputs_[0]);
     }
 
-    std::vector<VectorPtr> newChildren(inputs_.size());
-    for (int i = 0; i < inputs_.size(); ++i) {
-      newChildren[i] = input->childAt(inputs_[i]);
+    std::vector<VectorPtr> newChildren(nonConstantInputs_.size());
+    for (size_t i = 0; i < nonConstantInputs_.size(); ++i) {
+      newChildren[i] = input->childAt(nonConstantInputs_[i]);
     }
     return std::make_shared<RowVector>(
         pool_, inputType_, nullptr, input->size(), newChildren);
   }
 
-  std::vector<VectorPtr> makeInputForAggregation(const VectorPtr& input) const {
-    if (isSingleInputAggregate()) {
-      return {std::move(input)};
+  /// Build the full input vector list for the aggregate function from the
+  /// extracted distinct values, splicing constant inputs back in at the
+  /// correct positions.
+  std::vector<VectorPtr> makeInputForAggregation(
+      VectorPtr& data,
+      const AggregateInfo& aggregate) const {
+    const auto& inputs = aggregate.inputs;
+    const auto& constants = aggregate.constantInputs;
+    std::vector<VectorPtr> result(inputs.size());
+
+    std::vector<VectorPtr> distinctColumns;
+    if (singleNonConstantInput_) {
+      distinctColumns.push_back(data);
+    } else {
+      distinctColumns = data->template asUnchecked<RowVector>()->children();
+    }
+
+    size_t nonConstantIndex = 0;
+    for (size_t i = 0; i < inputs.size(); ++i) {
+      if (inputs[i] == kConstantChannel) {
+        result[i] = constants[i];
+      } else {
+        result[i] = distinctColumns[nonConstantIndex++];
+      }
+    }
+    VELOX_DCHECK_EQ(nonConstantIndex, distinctColumns.size());
+    return result;
+  }
+
+  void extractForSpill(folly::Range<char**> groups, VectorPtr& result) const {
+    auto* arrayVector = result->asChecked<ArrayVector>();
+    arrayVector->resize(groups.size());
+
+    auto* rawOffsets = arrayVector->offsets()->asMutable<vector_size_t>();
+    auto* rawSizes = arrayVector->sizes()->asMutable<vector_size_t>();
+
+    vector_size_t offset = 0;
+    for (auto i = 0; i < groups.size(); ++i) {
+      auto* accumulator =
+          reinterpret_cast<AccumulatorType*>(groups[i] + offset_);
+
+      const auto numDistinct = accumulator->size();
+      VELOX_DCHECK_GT(numDistinct, 0);
+
+      rawSizes[i] = numDistinct;
+      rawOffsets[i] = offset;
+
+      offset += numDistinct;
+    }
+
+    auto& elementsVector = arrayVector->elements();
+    elementsVector->resize(offset);
+
+    offset = 0;
+    for (const auto group : groups) {
+      auto* accumulator = reinterpret_cast<AccumulatorType*>(group + offset_);
+      if constexpr (std::is_same_v<T, ComplexType>) {
+        offset += accumulator->extractValues(*elementsVector, offset);
+      } else {
+        offset += accumulator->extractValues(
+            *(elementsVector->template as<FlatVector<T>>()), offset);
+      }
     }
-    return input->template asUnchecked<RowVector>()->children();
   }
 
   memory::MemoryPool* const pool_;
   const std::vector<AggregateInfo*> aggregates_;
-  const std::vector<column_index_t> inputs_;
+  const std::vector<column_index_t> nonConstantInputs_;
   const TypePtr inputType_;
+  const TypePtr spillType_;
+  const bool singleNonConstantInput_;
 
   DecodedVector decodedInput_;
   VectorPtr inputForAccumulator_;
@@ -211,13 +436,14 @@ class TypedDistinctAggregations : public DistinctAggregations {
 template <TypeKind Kind>
 std::unique_ptr<DistinctAggregations>
 createDistinctAggregationsWithCustomCompare(
-    std::vector<AggregateInfo*> aggregates,
+    const std::vector<AggregateInfo*>& aggregates,
     const RowTypePtr& inputType,
+    std::vector<column_index_t> nonConstantInputs,
     memory::MemoryPool* pool) {
   return std::make_unique<TypedDistinctAggregations<
       typename TypeTraits<Kind>::NativeType,
       aggregate::prestosql::CustomComparisonSetAccumulator<Kind>>>(
-      aggregates, inputType, pool);
+      aggregates, inputType, std::move(nonConstantInputs), pool);
 }
 } // namespace
 
@@ -229,13 +455,27 @@ std::unique_ptr<DistinctAggregations> DistinctAggregations::create(
   VELOX_CHECK_EQ(aggregates.size(), 1);
   VELOX_CHECK(!aggregates[0]->inputs.empty());
 
-  const bool isSingleInput = aggregates[0]->inputs.size() == 1;
-  if (!isSingleInput) {
+  // Collect non-constant input channels to determine the type for the
+  // set accumulator. Constant inputs are not deduplicated — they are
+  // spliced back during extraction.
+  std::vector<column_index_t> nonConstantInputs;
+  for (auto i = 0; i < aggregates[0]->inputs.size(); ++i) {
+    if (aggregates[0]->inputs[i] != kConstantChannel) {
+      nonConstantInputs.push_back(aggregates[0]->inputs[i]);
+    }
+  }
+
+  if (nonConstantInputs.empty()) {
+    return std::make_unique<ConstantDistinctAggregations>(
+        std::move(aggregates), pool);
+  }
+
+  if (nonConstantInputs.size() > 1) {
     return std::make_unique<TypedDistinctAggregations<ComplexType>>(
-        aggregates, inputType, pool);
+        std::move(aggregates), inputType, std::move(nonConstantInputs), pool);
   }
 
-  const auto type = inputType->childAt(aggregates[0]->inputs[0]);
+  const auto type = inputType->childAt(nonConstantInputs[0]);
 
   if (type->providesCustomComparison()) {
     return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
@@ -243,50 +483,51 @@ std::unique_ptr<DistinctAggregations> DistinctAggregations::create(
         type->kind(),
         aggregates,
         inputType,
+        std::move(nonConstantInputs),
         pool);
   }
 
   switch (type->kind()) {
     case TypeKind::BOOLEAN:
       return std::make_unique<TypedDistinctAggregations<bool>>(
-          aggregates, inputType, pool);
+          aggregates, inputType, std::move(nonConstantInputs), pool);
     case TypeKind::TINYINT:
       return std::make_unique<TypedDistinctAggregations<int8_t>>(
-          aggregates, inputType, pool);
+          aggregates, inputType, std::move(nonConstantInputs), pool);
     case TypeKind::SMALLINT:
       return std::make_unique<TypedDistinctAggregations<int16_t>>(
-          aggregates, inputType, pool);
+          aggregates, inputType, std::move(nonConstantInputs), pool);
     case TypeKind::INTEGER:
       return std::make_unique<TypedDistinctAggregations<int32_t>>(
-          aggregates, inputType, pool);
+          aggregates, inputType, std::move(nonConstantInputs), pool);
     case TypeKind::BIGINT:
       return std::make_unique<TypedDistinctAggregations<int64_t>>(
-          aggregates, inputType, pool);
+          aggregates, inputType, std::move(nonConstantInputs), pool);
     case TypeKind::HUGEINT:
       return std::make_unique<TypedDistinctAggregations<int128_t>>(
-          aggregates, inputType, pool);
+          aggregates, inputType, std::move(nonConstantInputs), pool);
     case TypeKind::REAL:
       return std::make_unique<TypedDistinctAggregations<float>>(
-          aggregates, inputType, pool);
+          aggregates, inputType, std::move(nonConstantInputs), pool);
     case TypeKind::DOUBLE:
       return std::make_unique<TypedDistinctAggregations<double>>(
-          aggregates, inputType, pool);
+          aggregates, inputType, std::move(nonConstantInputs), pool);
     case TypeKind::TIMESTAMP:
       return std::make_unique<TypedDistinctAggregations<Timestamp>>(
-          aggregates, inputType, pool);
+          aggregates, inputType, std::move(nonConstantInputs), pool);
     case TypeKind::VARBINARY:
       [[fallthrough]];
     case TypeKind::VARCHAR:
       return std::make_unique<TypedDistinctAggregations<StringView>>(
-          aggregates, inputType, pool);
+          aggregates, inputType, std::move(nonConstantInputs), pool);
     case TypeKind::ARRAY:
     case TypeKind::MAP:
     case TypeKind::ROW:
       return std::make_unique<TypedDistinctAggregations<ComplexType>>(
-          aggregates, inputType, pool);
+          aggregates, inputType, std::move(nonConstantInputs), pool);
     case TypeKind::UNKNOWN:
       return std::make_unique<TypedDistinctAggregations<UnknownValue>>(
-          aggregates, inputType, pool);
+          aggregates, inputType, std::move(nonConstantInputs), pool);
     default:
       VELOX_UNREACHABLE("Unexpected type {}", type->toString());
   }
diff --git a/velox/exec/DistinctAggregations.h b/velox/exec/DistinctAggregations.h
index fdd13a89fd0..0991b1a5e6f 100644
--- a/velox/exec/DistinctAggregations.h
+++ b/velox/exec/DistinctAggregations.h
@@ -91,6 +91,15 @@ class DistinctAggregations {
       folly::Range<char**> groups,
       const RowVectorPtr& result) = 0;
 
+  /// Update the single accumulator using previously spilled data.
+  /// @param group Pointer to the start of the group row.
+  /// @param input Restored spill data to be added to the accumulator.
+  /// @param index The index indicating which row in `input` is being added.
+  virtual void addSingleGroupSpillInput(
+      char* group,
+      const VectorPtr& input,
+      vector_size_t index) = 0;
+
  protected:
   // Initializes null flags and accumulators for newly encountered groups.  This
   // function should be called only once for each group.
diff --git a/velox/exec/Driver.cpp b/velox/exec/Driver.cpp
index 202553ef41b..1514f9a8516 100644
--- a/velox/exec/Driver.cpp
+++ b/velox/exec/Driver.cpp
@@ -16,15 +16,30 @@
 
 #include "velox/exec/Driver.h"
 
+#include <atomic>
+
 #include "velox/common/process/TraceContext.h"
+#include "velox/exec/Operator.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/Task.h"
 #include "velox/vector/LazyVector.h"
 
 using facebook::velox::common::testutil::TestValue;
 
 namespace facebook::velox::exec {
+
+Driver::~Driver() = default;
+
 namespace {
 
+/// Returns current time in microseconds using high_resolution_clock.
+/// Used for driver-level lifecycle timing to match BlockingState::sinceUs_.
+inline uint64_t currentTimeMicrosHires() {
+  return std::chrono::duration_cast<std::chrono::microseconds>(
+             std::chrono::high_resolution_clock::now().time_since_epoch())
+      .count();
+}
+
 // Checks if output channel is produced using identity projection and returns
 // input channel if so.
 std::optional<column_index_t> getIdentityProjection(
@@ -44,7 +59,7 @@ void recordSilentThrows(Operator& op) {
   auto numThrow = threadNumVeloxThrow();
   if (numThrow > 0) {
     op.stats().wlock()->addRuntimeStat(
-        "numSilentThrow", RuntimeCounter(numThrow));
+        std::string(DriverStats::kNumSilentThrow), RuntimeCounter(numThrow));
   }
 }
 
@@ -96,8 +111,8 @@ const core::QueryConfig& DriverCtx::queryConfig() const {
   return task->queryCtx()->queryConfig();
 }
 
-const std::optional<TraceConfig>& DriverCtx::traceConfig() const {
-  return task->traceConfig();
+const trace::TraceCtx* DriverCtx::traceCtx() const {
+  return task->traceCtx();
 }
 
 velox::memory::MemoryPool* DriverCtx::addOperatorPool(
@@ -107,8 +122,25 @@ velox::memory::MemoryPool* DriverCtx::addOperatorPool(
       planNodeId, splitGroupId, pipelineId, driverId, operatorType);
 }
 
+namespace {
+bool isHashJoinSpillOperator(std::string_view operatorType) {
+  return operatorType == OperatorType::kHashBuild ||
+      operatorType == OperatorType::kHashProbe;
+}
+
+bool isAggregationSpillOperator(std::string_view operatorType) {
+  return operatorType == OperatorType::kAggregation ||
+      operatorType == OperatorType::kPartialAggregation;
+}
+
+bool isRowNumberSpillOperator(std::string_view operatorType) {
+  return operatorType == OperatorType::kRowNumber;
+}
+} // namespace
+
 std::optional<common::SpillConfig> DriverCtx::makeSpillConfig(
-    int32_t operatorId) const {
+    int32_t operatorId,
+    std::string_view operatorType) const {
   const auto& queryConfig = task->queryCtx()->queryConfig();
   if (!queryConfig.spillEnabled()) {
     return std::nullopt;
@@ -126,6 +158,26 @@ std::optional<common::SpillConfig> DriverCtx::makeSpillConfig(
       [this](uint64_t bytes) {
         task->queryCtx()->updateSpilledBytesAndCheckLimit(bytes);
       };
+
+  std::string fileCreateConfig = queryConfig.spillFileCreateConfig();
+  if (isHashJoinSpillOperator(operatorType)) {
+    const auto& hashJoinConfig = queryConfig.hashJoinSpillFileCreateConfig();
+    if (!hashJoinConfig.empty()) {
+      fileCreateConfig = hashJoinConfig;
+    }
+  } else if (isAggregationSpillOperator(operatorType)) {
+    const auto& aggregationConfig =
+        queryConfig.aggregationSpillFileCreateConfig();
+    if (!aggregationConfig.empty()) {
+      fileCreateConfig = aggregationConfig;
+    }
+  } else if (isRowNumberSpillOperator(operatorType)) {
+    const auto& rowNumberConfig = queryConfig.rowNumberSpillFileCreateConfig();
+    if (!rowNumberConfig.empty()) {
+      fileCreateConfig = rowNumberConfig;
+    }
+  }
+
   return common::SpillConfig(
       std::move(getSpillDirPathCb),
       std::move(updateAndCheckSpillLimitCb),
@@ -142,10 +194,12 @@ std::optional<common::SpillConfig> DriverCtx::makeSpillConfig(
       queryConfig.maxSpillRunRows(),
       queryConfig.writerFlushThresholdBytes(),
       queryConfig.spillCompressionKind(),
+      queryConfig.spillNumMaxMergeFiles(),
       queryConfig.spillPrefixSortEnabled()
           ? std::optional<common::PrefixSortConfig>(prefixSortConfig())
           : std::nullopt,
-      queryConfig.spillFileCreateConfig());
+      fileCreateConfig,
+      queryConfig.windowSpillMinReadBatchRows());
 }
 
 std::atomic_uint64_t BlockingState::numBlockedDrivers_{0};
@@ -159,11 +213,13 @@ BlockingState::BlockingState(
       future_(std::move(future)),
       operator_(op),
       reason_(reason),
-      sinceUs_(std::chrono::duration_cast<std::chrono::microseconds>(
-                   std::chrono::high_resolution_clock::now().time_since_epoch())
-                   .count()) {
+      sinceUs_(
+          std::chrono::duration_cast<std::chrono::microseconds>(
+              std::chrono::high_resolution_clock::now().time_since_epoch())
+              .count()) {
   // Set before leaving the thread.
   driver_->state().hasBlockingFuture = true;
+  driver_->state().blockingStartUs = sinceUs_;
   numBlockedDrivers_++;
 }
 
@@ -180,6 +236,10 @@ void BlockingState::setResume(std::shared_ptr<BlockingState> state) {
         std::lock_guard<std::timed_mutex> l(task->mutex());
         if (!driver->state().isTerminated) {
           state->operator_->recordBlockingTime(state->sinceUs_, state->reason_);
+          // Accumulate driver-level blocked time using high_resolution_clock,
+          // matching sinceUs_ and all other driver lifecycle timing.
+          driver->addDriverBlockedTime(
+              (currentTimeMicrosHires() - state->sinceUs_) * 1'000);
         }
         VELOX_CHECK(!driver->state().suspended());
         VELOX_CHECK(driver->state().hasBlockingFuture);
@@ -278,6 +338,7 @@ RowVectorPtr Driver::next(
   ScopedDriverThreadContext scopedDriverThreadContext(self->driverCtx());
   std::shared_ptr<BlockingState> blockingState;
   RowVectorPtr result;
+
   const auto stop = runInternal(self, blockingState, result);
 
   if (blockingState != nullptr) {
@@ -309,7 +370,7 @@ void Driver::enqueueInternal() {
   VELOX_CHECK(!state_.isEnqueued);
   state_.isEnqueued = true;
   // When enqueuing, starting timing the queue time.
-  queueTimeStartUs_ = getCurrentTimeMicro();
+  queueTimeStartUs_ = currentTimeMicrosHires();
 }
 
 // Call an Operator method. record silenced throws, but not a query
@@ -337,13 +398,13 @@ void Driver::enqueueInternal() {
   }
 
 void OpCallStatus::start(int32_t operatorId, const char* operatorMethod) {
-  timeStartMs = getCurrentTimeMs();
-  opId = operatorId;
-  method = operatorMethod;
+  timeStartMs_ = getCurrentTimeMs();
+  opId_ = operatorId;
+  method_ = operatorMethod;
 }
 
 void OpCallStatus::stop() {
-  timeStartMs = 0;
+  timeStartMs_ = 0;
 }
 
 size_t OpCallStatusRaw::callDuration() const {
@@ -365,10 +426,14 @@ CpuWallTiming Driver::processLazyIoStats(
   if (&op == operators_[0].get()) {
     return timing;
   }
+  static const std::string kCpuNanosKey(LazyVector::kCpuNanos);
+  static const std::string kWallNanosKey(LazyVector::kWallNanos);
+  static const std::string kInputBytesKey(LazyVector::kInputBytes);
+
   auto lockStats = op.stats().wlock();
 
   // Checks and tries to update cpu time from lazy loads.
-  auto it = lockStats->runtimeStats.find(LazyVector::kCpuNanos);
+  auto it = lockStats->runtimeStats.find(kCpuNanosKey);
   if (it == lockStats->runtimeStats.end()) {
     // Return early if no lazy activity.  Lazy CPU and wall times are recorded
     // together, checking one is enough.
@@ -386,7 +451,7 @@ CpuWallTiming Driver::processLazyIoStats(
 
   // Checks and tries to update wall time from lazy loads.
   int64_t wallDelta = 0;
-  it = lockStats->runtimeStats.find(LazyVector::kWallNanos);
+  it = lockStats->runtimeStats.find(kWallNanosKey);
   if (it != lockStats->runtimeStats.end()) {
     const int64_t wall = it->second.sum;
     wallDelta = std::max<int64_t>(0, wall - lockStats->lastLazyWallNanos);
@@ -397,7 +462,7 @@ CpuWallTiming Driver::processLazyIoStats(
 
   // Checks and tries to update input bytes from lazy loads.
   int64_t inputBytesDelta = 0;
-  it = lockStats->runtimeStats.find(LazyVector::kInputBytes);
+  it = lockStats->runtimeStats.find(kInputBytesKey);
   if (it != lockStats->runtimeStats.end()) {
     const int64_t inputBytes = it->second.sum;
     inputBytesDelta = inputBytes - lockStats->lastLazyInputBytes;
@@ -410,11 +475,12 @@ CpuWallTiming Driver::processLazyIoStats(
   cpuDelta = std::min<int64_t>(cpuDelta, timing.cpuNanos);
   wallDelta = std::min<int64_t>(wallDelta, timing.wallNanos);
   lockStats = operators_[0]->stats().wlock();
-  lockStats->getOutputTiming.add(CpuWallTiming{
-      1,
-      static_cast<uint64_t>(wallDelta),
-      static_cast<uint64_t>(cpuDelta),
-  });
+  lockStats->getOutputTiming.add(
+      CpuWallTiming{
+          1,
+          static_cast<uint64_t>(wallDelta),
+          static_cast<uint64_t>(cpuDelta),
+      });
   lockStats->inputBytes += inputBytesDelta;
   lockStats->outputBytes += inputBytesDelta;
   return CpuWallTiming{
@@ -454,8 +520,24 @@ StopReason Driver::runInternal(
     std::shared_ptr<Driver>& self,
     std::shared_ptr<BlockingState>& blockingState,
     RowVectorPtr& result) {
-  const auto now = getCurrentTimeMicro();
+  // All driver timing uses high_resolution_clock consistently
+  // (matching BlockingState::sinceUs_ used for blocked time).
+  const auto now = currentTimeMicrosHires();
   const auto queuedTimeUs = now - queueTimeStartUs_;
+
+  totalDriverQueuedNanos_ += queuedTimeUs * 1'000;
+  onThreadStartUs_ = now;
+  // For the normal close path, closeOperators() finalizes and clears
+  // onThreadStartUs_ before reporting. This guard handles early returns
+  // (e.g. Task::enter() failure) and non-close exit paths.
+  auto onThreadTimeGuard = folly::makeGuard([this]() {
+    if (onThreadStartUs_ > 0) {
+      totalDriverOnThreadNanos_ +=
+          (currentTimeMicrosHires() - onThreadStartUs_) * 1'000;
+      onThreadStartUs_ = 0;
+    }
+  });
+
   // Update the next operator's queueTime.
   StopReason stop =
       closed_ ? StopReason::kTerminate : task()->enter(state_, now);
@@ -474,7 +556,7 @@ StopReason Driver::runInternal(
   // been deleted.
   if (curOperatorId_ < operators_.size()) {
     operators_[curOperatorId_]->addRuntimeStat(
-        "queuedWallNanos",
+        std::string(DriverStats::kQueuedWallNanos),
         RuntimeCounter(queuedTimeUs * 1'000, RuntimeCounter::Unit::kNanos));
     RECORD_HISTOGRAM_METRIC_VALUE(
         kMetricDriverQueueTimeMs, queuedTimeUs / 1'000);
@@ -492,14 +574,27 @@ StopReason Driver::runInternal(
   try {
     // Invoked to initialize the operators once before driver starts execution.
     initializeOperators();
+    int32_t startingOperator = getStartingOperator();
 
     TestValue::adjust("facebook::velox::exec::Driver::runInternal", this);
 
-    const int32_t numOperators = operators_.size();
+    // If the driver is coming back from a trace interruption, feed the
+    // intermediate result into the next operator, then resume execution at the
+    // exact operator where the trace was interrupted.
+    if (traceInput_ != nullptr) {
+      Operator* tracedOp = operators_[startingOperator].get();
+      CALL_OPERATOR(
+          addInput(tracedOp, traceInput_),
+          tracedOp,
+          startingOperator,
+          kOpMethodAddInput);
+      traceInput_ = nullptr;
+    }
+
     ContinueFuture future = ContinueFuture::makeEmpty();
 
     for (;;) {
-      for (int32_t i = numOperators - 1; i >= 0; --i) {
+      for (int32_t i = startingOperator; i >= 0; --i) {
         stop = task()->shouldStop();
         if (stop != StopReason::kNone) {
           guard.notThrown();
@@ -544,7 +639,7 @@ StopReason Driver::runInternal(
           return blockDriver(self, i, std::move(future), blockingState, guard);
         }
 
-        if (i < numOperators - 1) {
+        if (i < operators_.size() - 1) {
           Operator* nextOp = operators_[i + 1].get();
 
           withDeltaCpuWallTimer(nextOp, &OperatorStats::isBlockedTiming, [&]() {
@@ -565,9 +660,11 @@ StopReason Driver::runInternal(
               nextOp,
               curOperatorId_ + 1,
               kOpMethodNeedsInput);
+
           if (needsInput) {
             uint64_t resultBytes = 0;
             RowVectorPtr intermediateResult;
+
             withDeltaCpuWallTimer(op, &OperatorStats::getOutputTiming, [&]() {
               TestValue::adjust(
                   "facebook::velox::exec::Driver::runInternal::getOutput", op);
@@ -587,6 +684,16 @@ StopReason Driver::runInternal(
               }
             });
             if (intermediateResult) {
+              const bool block =
+                  nextOp->traceInput(intermediateResult, &future);
+
+              if (block) {
+                blockingReason_ = BlockingReason::kWaitForConsumer;
+                traceInput_ = intermediateResult;
+                return blockDriver(
+                    self, i + 1, std::move(future), blockingState, guard);
+              }
+
               withDeltaCpuWallTimer(
                   nextOp, &OperatorStats::addInputTiming, [&]() {
                     {
@@ -594,7 +701,7 @@ StopReason Driver::runInternal(
                       lockedStats->addInputVector(
                           resultBytes, intermediateResult->size());
                     }
-                    nextOp->traceInput(intermediateResult);
+
                     TestValue::adjust(
                         "facebook::velox::exec::Driver::runInternal::addInput",
                         nextOp);
@@ -702,7 +809,7 @@ StopReason Driver::runInternal(
     }
   } catch (velox::VeloxException&) {
     task()->setError(std::current_exception());
-    // The CancelPoolGuard will close 'self' and remove from Task.
+    // The CancelGuard will close 'self' and remove from Task.
     return StopReason::kAlreadyTerminated;
   } catch (std::exception&) {
     task()->setError(std::current_exception());
@@ -794,10 +901,40 @@ void Driver::closeOperators() {
     op->close();
   }
 
+  // Report driver-level lifecycle timing to the Task accumulator.
+  // Use partitionId (0..numDrivers-1) so same-index drivers across split
+  // groups in grouped execution are summed together.
+  // Finalize on-thread time here (the onThreadTimeGuard in runInternal
+  // hasn't fired yet since CancelGuard destructs before it).
+  if (onThreadStartUs_ > 0) {
+    totalDriverOnThreadNanos_ +=
+        (currentTimeMicrosHires() - onThreadStartUs_) * 1'000;
+    onThreadStartUs_ = 0; // Prevent double-counting in the guard.
+  }
+  task()->addDriverLifecycleStats(
+      static_cast<uint32_t>(ctx_->pipelineId),
+      ctx_->partitionId,
+      totalDriverQueuedNanos_,
+      totalDriverOnThreadNanos_,
+      totalDriverBlockedNanos_);
+
   // Add operator stats to the task.
   for (auto& op : operators_) {
     auto stats = op->stats(true);
     stats.numDrivers = 1;
+
+    // Calculate this driver's CPU time for this specific operator and add it as
+    // a runtime stat. This will be aggregated across all drivers, with the max
+    // field containing the CPU time from the longest running driver.
+    uint64_t operatorCpuNanos = stats.addInputTiming.cpuNanos +
+        stats.getOutputTiming.cpuNanos + stats.finishTiming.cpuNanos +
+        stats.isBlockedTiming.cpuNanos;
+
+    if (operatorCpuNanos > 0) {
+      stats.runtimeStats[std::string(OperatorStats::kDriverCpuTime)] =
+          RuntimeMetric(operatorCpuNanos, RuntimeCounter::Unit::kNanos);
+    }
+
     task()->addOperatorStats(stats);
   }
 }
@@ -805,22 +942,40 @@ void Driver::closeOperators() {
 void Driver::updateStats() {
   DriverStats stats;
   if (state_.totalPauseTimeMs > 0) {
-    stats.runtimeStats[DriverStats::kTotalPauseTime] = RuntimeMetric(
-        1'000'000 * state_.totalPauseTimeMs, RuntimeCounter::Unit::kNanos);
+    stats.runtimeStats[std::string(DriverStats::kTotalPauseTime)] =
+        RuntimeMetric(
+            1'000'000 * state_.totalPauseTimeMs, RuntimeCounter::Unit::kNanos);
   }
   if (state_.totalOffThreadTimeMs > 0) {
-    stats.runtimeStats[DriverStats::kTotalOffThreadTime] = RuntimeMetric(
-        1'000'000 * state_.totalOffThreadTimeMs, RuntimeCounter::Unit::kNanos);
+    stats.runtimeStats[std::string(DriverStats::kTotalOffThreadTime)] =
+        RuntimeMetric(
+            1'000'000 * state_.totalOffThreadTimeMs,
+            RuntimeCounter::Unit::kNanos);
   }
+
   task()->addDriverStats(ctx_->pipelineId, std::move(stats));
 }
 
+void Driver::updateOperatorBlockingStats() {
+  // Record blocked time if the driver was blocked when terminated.
+  // This ensures we don't lose blocked time metrics when a query is aborted.
+  if (state_.hasBlockingFuture) {
+    // Accumulate driver-level blocked time unconditionally.
+    totalDriverBlockedNanos_ +=
+        (currentTimeMicrosHires() - state_.blockingStartUs) * 1'000;
+    // Record per-operator blocked time if operator is available.
+    if (blockedOperatorId_ < operators_.size()) {
+      operators_[blockedOperatorId_]->recordBlockingTime(
+          state_.blockingStartUs, blockingReason_);
+    }
+  }
+}
+
 void Driver::startBarrier() {
   VELOX_CHECK(ctx_->task->underBarrier());
   VELOX_CHECK(
-      !barrier_.has_value(),
-      "The driver has already started barrier processing");
-  barrier_ = BarrierState{};
+      !hasBarrier(), "The driver has already started barrier processing");
+  barrier_.start();
 }
 
 void Driver::drainOutput() {
@@ -828,38 +983,38 @@ void Driver::drainOutput() {
       hasBarrier(), "Can't drain a driver not under barrier processing");
   VELOX_CHECK(!isDraining(), "The driver is already draining");
   // Starts to drain from the source operator.
-  barrier_->drainingOpId = 0;
+  barrier_.drainingOpId = 0;
   drainNextOperator();
 }
 
 bool Driver::isDraining() const {
-  return hasBarrier() && barrier_->drainingOpId.has_value();
+  return hasBarrier() && barrier_.drainingOpId.has_value();
 }
 
 bool Driver::isDraining(int32_t operatorId) const {
-  return isDraining() && operatorId == barrier_->drainingOpId;
+  return isDraining() && operatorId == barrier_.drainingOpId;
 }
 
 bool Driver::hasDrained(int32_t operatorId) const {
-  return isDraining() && operatorId < barrier_->drainingOpId;
+  return isDraining() && operatorId < barrier_.drainingOpId;
 }
 
 void Driver::finishDrain(int32_t operatorId) {
   VELOX_CHECK(isDraining());
-  VELOX_CHECK_EQ(barrier_->drainingOpId.value(), operatorId);
-  barrier_->drainingOpId = barrier_->drainingOpId.value() + 1;
+  VELOX_CHECK_EQ(barrier_.drainingOpId.value(), operatorId);
+  barrier_.drainingOpId = barrier_.drainingOpId.value() + 1;
   drainNextOperator();
 }
 
 void Driver::drainNextOperator() {
   VELOX_CHECK(isDraining());
-  for (; barrier_->drainingOpId < operators_.size();
-       barrier_->drainingOpId = barrier_->drainingOpId.value() + 1) {
-    if (operators_[barrier_->drainingOpId.value()]->startDrain()) {
+  for (; barrier_.drainingOpId < operators_.size();
+       barrier_.drainingOpId = barrier_.drainingOpId.value() + 1) {
+    if (operators_[barrier_.drainingOpId.value()]->startDrain()) {
       break;
     }
   }
-  if (barrier_->drainingOpId == operators_.size()) {
+  if (barrier_.drainingOpId == operators_.size()) {
     finishBarrier();
   }
 }
@@ -870,21 +1025,37 @@ void Driver::dropInput(int32_t operatorId) {
     return;
   }
   VELOX_CHECK_LT(operatorId, operators_.size());
-  if (!barrier_->dropInputOpId.has_value()) {
-    barrier_->dropInputOpId = operatorId;
-  } else {
-    barrier_->dropInputOpId = std::max(*barrier_->dropInputOpId, operatorId);
-  }
+  // dropInput() is only called from operators within this driver's pipeline
+  // during barrier processing. Since a driver runs on a single thread at a
+  // time, we don't need compare-and-swap here. We simply keep the maximum
+  // operator id - all operators upstream (with smaller ids) will drop their
+  // output.
+  barrier_.dropInputOpId = std::max(
+      barrier_.dropInputOpId.load(std::memory_order_relaxed), operatorId);
 }
 
 bool Driver::shouldDropOutput(int32_t operatorId) const {
-  return hasBarrier() && barrier_->dropInputOpId.has_value() &&
-      operatorId < *barrier_->dropInputOpId;
+  const int32_t dropOpId =
+      barrier_.dropInputOpId.load(std::memory_order_acquire);
+  return hasBarrier() && dropOpId != BarrierState::kNoDropInput &&
+      operatorId < dropOpId;
+}
+
+void Driver::BarrierState::start() {
+  VELOX_CHECK(!active.load(std::memory_order_acquire));
+  active.store(true, std::memory_order_release);
+}
+
+void Driver::BarrierState::reset() {
+  VELOX_CHECK(active.load(std::memory_order_acquire));
+  active.store(false, std::memory_order_release);
+  drainingOpId = std::nullopt;
+  dropInputOpId.store(kNoDropInput, std::memory_order_relaxed);
 }
 
 void Driver::finishBarrier() {
   VELOX_CHECK(isDraining());
-  VELOX_CHECK_EQ(barrier_->drainingOpId.value(), operators_.size());
+  VELOX_CHECK_EQ(barrier_.drainingOpId.value(), operators_.size());
   barrier_.reset();
   ctx_->task->finishDriverBarrier();
 }
@@ -906,6 +1077,7 @@ void Driver::close() {
 void Driver::closeByTask() {
   VELOX_CHECK(isOnThread());
   VELOX_CHECK(isTerminated());
+  updateOperatorBlockingStats();
   closeOperators();
   updateStats();
   closed_ = true;
@@ -1035,11 +1207,13 @@ int Driver::pushdownFilters(
       operators_[j]->addDynamicFilterLocked(filterSource->planNodeId(), *lk);
     }
     operators_[j]->addRuntimeStat(
-        "dynamicFiltersAccepted", RuntimeCounter(numFiltersAccepted[j]));
+        std::string(DriverStats::kDynamicFiltersAccepted),
+        RuntimeCounter(numFiltersAccepted[j]));
   }
   if (numFiltersProduced > 0) {
     filterSource->addRuntimeStat(
-        "dynamicFiltersProduced", RuntimeCounter(numFiltersProduced));
+        std::string(DriverStats::kDynamicFiltersProduced),
+        RuntimeCounter(numFiltersProduced));
   }
   return numFiltersProduced;
 }
@@ -1102,9 +1276,13 @@ std::string Driver::toString() const {
   }
 
   out << "{Operators: ";
-  for (auto& op : operators_) {
-    out << op->toString() << ", ";
-  }
+  std::vector<std::string> opStrs;
+  opStrs.reserve(operators_.size());
+  std::ranges::transform(
+      operators_, std::back_inserter(opStrs), [](const auto& op) {
+        return op->toString();
+      });
+  out << folly::join(", ", opStrs);
   out << "}";
   const auto ocs = opCallStatus();
   if (!ocs.empty()) {
@@ -1220,6 +1398,14 @@ StopReason Driver::blockDriver(
   return StopReason::kBlock;
 }
 
+int32_t Driver::getStartingOperator() const {
+  if (traceInput_ != nullptr) {
+    return blockedOperatorId_;
+  }
+  // By default, start at the last (the consumer).
+  return operators_.size() - 1;
+}
+
 std::string Driver::label() const {
   return fmt::format("<Driver {}:{}>", task()->taskId(), ctx_->driverId);
 }
diff --git a/velox/exec/Driver.h b/velox/exec/Driver.h
index cdcccbf64aa..2407e7240cc 100644
--- a/velox/exec/Driver.h
+++ b/velox/exec/Driver.h
@@ -16,18 +16,21 @@
 
 #pragma once
 
+#include <atomic>
 #include <memory>
+#include <string_view>
 
 #include <folly/executors/CPUThreadPoolExecutor.h>
 #include <folly/futures/Future.h>
 #include <folly/portability/SysSyscall.h>
 
 #include "velox/common/base/Counters.h"
+#include "velox/common/base/Portability.h"
 #include "velox/common/base/StatsReporter.h"
-#include "velox/common/base/TraceConfig.h"
 #include "velox/common/time/CpuWallTimer.h"
 #include "velox/core/PlanFragment.h"
 #include "velox/exec/BlockingReason.h"
+#include "velox/exec/trace/TraceCtx.h"
 
 namespace facebook::velox::exec {
 
@@ -86,7 +89,7 @@ std::ostream& operator<<(std::ostream& out, const StopReason& reason);
 ///  Terminated - 'isTerminated' is set. The Driver cannot run after this and
 /// the state is final.
 ///
-/// CancelPool  allows terminating or pausing a set of Drivers. The Task API
+/// Task allows terminating or pausing a set of Drivers. The Task API
 /// allows starting or resuming Drivers. When terminate is requested the request
 /// is successful when all Drivers are off thread, blocked or suspended. When
 /// pause is requested, we have success when all Drivers are either enqueued,
@@ -102,7 +105,10 @@ struct ThreadState {
   std::atomic<bool> isTerminated{false};
   /// True if there is a future outstanding that will schedule this on an
   /// executor thread when some promise is realized.
-  bool hasBlockingFuture{false};
+  tsan_atomic<bool> hasBlockingFuture{false};
+  /// Timestamp in microseconds when the driver became blocked. Used to record
+  /// blocked time when the driver is terminated while still blocked.
+  tsan_atomic<uint64_t> blockingStartUs{0};
   /// The number of suspension requests on a on-thread driver. If > 0, this
   /// driver thread is in a (recursive) section waiting for RPC or memory
   /// strategy decision. The thread is not supposed to access its memory, which
@@ -167,7 +173,8 @@ struct ThreadState {
     obj["tid"] = tid.load();
     obj["isTerminated"] = isTerminated.load();
     obj["isEnqueued"] = isEnqueued.load();
-    obj["hasBlockingFuture"] = hasBlockingFuture;
+    obj["hasBlockingFuture"] = tsanAtomicValue(hasBlockingFuture);
+    obj["blockingStartUs"] = tsanAtomicValue(blockingStartUs);
     obj["isSuspended"] = suspended();
     obj["startExecTime"] = startExecTimeMs;
     return obj;
@@ -224,9 +231,11 @@ constexpr uint32_t kUngroupedGroupId{std::numeric_limits<uint32_t>::max()};
 struct DriverCtx {
   const int driverId;
   const int pipelineId;
+
   /// Id of the split group this driver should process in case of grouped
   /// execution, kUngroupedGroupId otherwise.
   const uint32_t splitGroupId;
+
   /// Id of the partition to use by this driver. For local exchange, for
   /// instance.
   const uint32_t partitionId;
@@ -234,6 +243,7 @@ struct DriverCtx {
   std::shared_ptr<Task> task;
   Driver* driver{nullptr};
   facebook::velox::process::ThreadDebugInfo threadDebugInfo;
+
   /// Tracks the traced operator ids. It is also used to avoid tracing the
   /// auxiliary operator such as the aggregation operator used by the table
   /// writer to generate the columns stats.
@@ -248,14 +258,17 @@ struct DriverCtx {
 
   const core::QueryConfig& queryConfig() const;
 
-  const std::optional<TraceConfig>& traceConfig() const;
+  const trace::TraceCtx* traceCtx() const;
 
   velox::memory::MemoryPool* addOperatorPool(
       const core::PlanNodeId& planNodeId,
       const std::string& operatorType);
 
-  /// Builds the spill config for the operator with specified 'operatorId'.
-  std::optional<common::SpillConfig> makeSpillConfig(int32_t operatorId) const;
+  /// Builds the spill config for the operator with specified 'operatorId' and
+  /// 'operatorType'.
+  std::optional<common::SpillConfig> makeSpillConfig(
+      int32_t operatorId,
+      std::string_view operatorType) const;
 
   common::PrefixSortConfig prefixSortConfig() const {
     return common::PrefixSortConfig{
@@ -273,13 +286,13 @@ constexpr const char* kOpMethodAddInput = "addInput";
 constexpr const char* kOpMethodNoMoreInput = "noMoreInput";
 constexpr const char* kOpMethodIsFinished = "isFinished";
 
-/// Same as the structure below, but does not have atomic members.
-/// Used to return the status from the struct with atomics.
+/// Non-atomic snapshot of OpCallStatus, used to return a consistent status from
+/// OpCallStatus which uses atomic members internally.
 struct OpCallStatusRaw {
   /// Time (ms) when the operator call started.
   size_t timeStartMs{0};
-  /// Id of the operator, method of which is currently running. It is index into
-  /// the vector of Driver's operators.
+  /// Id of the operator, method of which is currently running. It is the index
+  /// into the vector of Driver's operators.
   int32_t opId{0};
   /// Method of the operator, which is currently running.
   const char* method{kOpMethodNone};
@@ -293,14 +306,15 @@ struct OpCallStatusRaw {
 };
 
 /// Structure holds the information about the current operator call the driver
-/// is in. Can be used to detect deadlocks and otherwise blocked calls.
-/// If timeStartMs is zero, then we aren't in an operator call.
-struct OpCallStatus {
+/// is in. Can be used to detect deadlocks and otherwise blocked calls. If
+/// 'timeStartMs_' is zero, then we aren't in an operator call.
+class OpCallStatus {
+ public:
   OpCallStatus() {}
 
   /// The status accessor.
   OpCallStatusRaw operator()() const {
-    return OpCallStatusRaw{timeStartMs, opId, method};
+    return OpCallStatusRaw{timeStartMs_, opId_, method_};
   }
 
   void start(int32_t operatorId, const char* operatorMethod);
@@ -308,12 +322,12 @@ struct OpCallStatus {
 
  private:
   /// Time (ms) when the operator call started.
-  std::atomic_size_t timeStartMs{0};
-  /// Id of the operator, method of which is currently running. It is index into
-  /// the vector of Driver's operators.
-  std::atomic_int32_t opId{0};
+  std::atomic_size_t timeStartMs_{0};
+  /// Id of the operator, method of which is currently running. It is the index
+  /// into the vector of Driver's operators.
+  std::atomic_int32_t opId_{0};
   /// Method of the operator, which is currently running.
-  std::atomic<const char*> method{kOpMethodNone};
+  std::atomic<const char*> method_{kOpMethodNone};
 };
 
 struct PushdownFilters {
@@ -338,6 +352,14 @@ using PipelinePushdownFilters =
 
 class Driver : public std::enable_shared_from_this<Driver> {
  public:
+  ~Driver();
+
+  // Disable copy and move
+  Driver(const Driver&) = delete;
+  Driver& operator=(const Driver&) = delete;
+  Driver(Driver&&) = delete;
+  Driver& operator=(Driver&&) = delete;
+
   static void enqueue(std::shared_ptr<Driver> instance);
 
   /// Run the pipeline until it produces a batch of data or gets blocked.
@@ -394,6 +416,12 @@ class Driver : public std::enable_shared_from_this<Driver> {
   /// memory arbitration finishes.
   bool checkUnderArbitration(ContinueFuture* future);
 
+  /// Accumulates blocked time for driver-level lifecycle tracking.
+  /// Called from BlockingState::setResume() when the blocking future resolves.
+  void addDriverBlockedTime(uint64_t nanos) {
+    totalDriverBlockedNanos_ += nanos;
+  }
+
   void initializeOperatorStats(std::vector<OperatorStats>& stats);
 
   /// Close operators and add operator stats to the task.
@@ -481,7 +509,7 @@ class Driver : public std::enable_shared_from_this<Driver> {
 
   /// Returns true if the driver is under barrier processing.
   bool hasBarrier() const {
-    return barrier_.has_value();
+    return barrier_.active.load(std::memory_order_acquire);
   }
 
   /// Invoked to start draining the output of this driver pipeline from the
@@ -579,15 +607,33 @@ class Driver : public std::enable_shared_from_this<Driver> {
 
   void updateStats();
 
+  /// Records operator blocked time ins case the driver was off the thrread and
+  /// blocked when terminated.
+  void updateOperatorBlockingStats();
+
   // Defines the driver barrier processing state.
   struct BarrierState {
+    // True if the driver is under barrier processing. This is set by
+    // startBarrier() and read by hasBarrier() from different threads.
+    std::atomic_bool active{false};
     // If set, the driver has started output draining. It points to the operator
     // that is currently draining output.
     std::optional<int32_t> drainingOpId{std::nullopt};
-    // If set, the specified operator doesn't need any more input to finish the
-    // draining operation. All the upstream operators within the same driver
-    // should drop their output or output processing.
-    std::optional<int32_t> dropInputOpId{std::nullopt};
+    // The operator id that doesn't need any more input to finish the draining
+    // operation. All the upstream operators within the same driver should drop
+    // their output or output processing. -1 means not set. This is accessed
+    // from different driver threads so it needs to be atomic.
+    static constexpr int32_t kNoDropInput = -1;
+    std::atomic_int32_t dropInputOpId{kNoDropInput};
+
+    BarrierState() = default;
+
+    /// Starts the barrier processing. Must be called when the barrier is not
+    /// active.
+    void start();
+
+    /// Resets the barrier state. Must be called when the barrier is active.
+    void reset();
   };
 
   // Invoked to start draining on the next operator. If there is no "next"
@@ -627,6 +673,15 @@ class Driver : public std::enable_shared_from_this<Driver> {
       std::shared_ptr<BlockingState>& blockingState,
       CancelGuard& guard);
 
+  // Returns the operator to start from. The Driver always start the driver
+  // pipeline from the consumer (leaf), then walk backwards to the root based on
+  // whether they are ready to consume data, and the previous is ready to
+  // produce data.
+  //
+  // The only exception is when resuming from a trace, in which case the Driver
+  // must resume at the operator where it was blocked.
+  int32_t getStartingOperator() const;
+
   std::unique_ptr<DriverCtx> ctx_;
 
   // If set, the operator output batch size stats will be collected during
@@ -640,8 +695,8 @@ class Driver : public std::enable_shared_from_this<Driver> {
 
   std::atomic_bool closed_{false};
 
-  // If set, the driver is under a barrier processing.
-  std::optional<BarrierState> barrier_;
+  // The driver barrier processing state.
+  BarrierState barrier_;
 
   OpCallStatus opCallStatus_;
 
@@ -650,16 +705,44 @@ class Driver : public std::enable_shared_from_this<Driver> {
 
   // Timer used to track down the time we are sitting in the driver queue.
   size_t queueTimeStartUs_{0};
+
+  // Driver-level lifecycle timing: independently tracks the three states
+  // a driver can be in (queued, on-thread, blocked) to enable gap analysis.
+  // Reported as RuntimeStats on the source operator at close time.
+  // All three use high_resolution_clock for consistency, matching
+  // BlockingState::sinceUs_ and enabling accurate gap analysis
+  // (queued + on-thread + blocked ≈ elapsed time).
+  // Atomic because closeByTask() may read these from a different thread
+  // than the one running the onThreadTimeGuard scope guard.
+  std::atomic<uint64_t> totalDriverQueuedNanos_{0};
+  std::atomic<uint64_t> totalDriverOnThreadNanos_{0};
+  std::atomic<uint64_t> totalDriverBlockedNanos_{0};
+  // Timestamp (micros, high_resolution_clock) when the current on-thread
+  // period started. Set at the beginning of runInternal, used by
+  // closeOperators to snapshot on-thread time before the scope guard fires.
+  // Atomic because closeByTask() may access it from a different thread
+  // than the one running the onThreadTimeGuard scope guard in runInternal.
+  std::atomic<uint64_t> onThreadStartUs_{0};
+
   // Id (index in the vector) of the current operator to run (or the 1st one if
   // we haven't started yet). Used to determine which operator's queueTime we
   // should update.
   size_t curOperatorId_{0};
 
-  std::vector<std::unique_ptr<Operator>> operators_;
+  std::vector<std::unique_ptr<Operator>> operators_; // NOLINT
 
-  BlockingReason blockingReason_{BlockingReason::kNotBlocked};
+  tsan_atomic<BlockingReason> blockingReason_{BlockingReason::kNotBlocked};
+
+  // Stores the operator where the driver was last blocked. Note that the driver
+  // always resumes at the leaf (consumer) to prioritize getting data out of the
+  // task. The only exception is when resuming from a trace.
   size_t blockedOperatorId_{0};
 
+  // If this driver is being traced, store a pointer to the current data. Once
+  // the trace client unblocks the driver, we will feed this vector to the next
+  // operator in the pipeline.
+  RowVectorPtr traceInput_;
+
   bool trackOperatorCpuUsage_;
 
   // Indicates that a DriverAdapter can rearrange Operators. Set to false at end
@@ -822,6 +905,10 @@ struct DriverFactory {
   /// based on this pipeline.
   std::vector<core::PlanNodeId> needsSpatialJoinBridges() const;
 
+  /// Returns plan node IDs for which IndexLookupJoin Bridges must be created
+  /// based on this pipeline.
+  std::vector<core::PlanNodeId> needsIndexLookupJoinBridges() const;
+
   static std::vector<DriverAdapter> adapters;
 };
 
diff --git a/velox/exec/DriverStats.h b/velox/exec/DriverStats.h
index 3b047f4c9e0..d99e3afd464 100644
--- a/velox/exec/DriverStats.h
+++ b/velox/exec/DriverStats.h
@@ -16,16 +16,29 @@
 
 #pragma once
 
+#include <string_view>
 #include <unordered_map>
 #include "velox/common/base/RuntimeMetrics.h"
 
 namespace facebook::velox::exec {
 
 struct DriverStats {
-  static constexpr const char* kTotalPauseTime = "totalDriverPauseWallNanos";
-  static constexpr const char* kTotalOffThreadTime =
+  static constexpr std::string_view kTotalPauseTime =
+      "totalDriverPauseWallNanos";
+  static constexpr std::string_view kTotalOffThreadTime =
       "totalDriverOffThreadWallNanos";
 
+  /// Number of silent Velox throws during operator execution.
+  static constexpr std::string_view kNumSilentThrow = "numSilentThrow";
+  /// Time an operator spent queued before execution.
+  static constexpr std::string_view kQueuedWallNanos = "queuedWallNanos";
+  /// Number of dynamic filters accepted by an operator.
+  static constexpr std::string_view kDynamicFiltersAccepted =
+      "dynamicFiltersAccepted";
+  /// Number of dynamic filters produced by an operator.
+  static constexpr std::string_view kDynamicFiltersProduced =
+      "dynamicFiltersProduced";
+
   std::unordered_map<std::string, RuntimeMetric> runtimeStats;
 };
 
diff --git a/velox/exec/EnforceDistinct.cpp b/velox/exec/EnforceDistinct.cpp
new file mode 100644
index 00000000000..8007edd7b94
--- /dev/null
+++ b/velox/exec/EnforceDistinct.cpp
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/EnforceDistinct.h"
+
+#include "velox/exec/OperatorType.h"
+
+namespace facebook::velox::exec {
+
+EnforceDistinct::EnforceDistinct(
+    int32_t operatorId,
+    DriverCtx* driverCtx,
+    const std::shared_ptr<const core::EnforceDistinctNode>& planNode)
+    : Operator(
+          driverCtx,
+          planNode->outputType(),
+          operatorId,
+          planNode->id(),
+          OperatorType::kEnforceDistinct),
+      errorMessage_{planNode->errorMessage()} {
+  const auto& inputType = planNode->sources()[0]->outputType();
+
+  for (auto i = 0; i < inputType->size(); ++i) {
+    identityProjections_.emplace_back(i, i);
+  }
+
+  groupingSet_ = GroupingSet::createForDistinct(
+      inputType,
+      createVectorHashers(inputType, planNode->distinctKeys()),
+      toChannels(
+          inputType,
+          std::vector<core::TypedExprPtr>{
+              planNode->preGroupedKeys().begin(),
+              planNode->preGroupedKeys().end()}),
+      operatorCtx_.get(),
+      &nonReclaimableSection_);
+}
+
+void EnforceDistinct::addInput(RowVectorPtr input) {
+  groupingSet_->addInput(input, /*mayPushdown=*/false);
+
+  const auto& newGroups = groupingSet_->hashLookup().newGroups;
+  if (newGroups.size() != input->size()) {
+    VELOX_USER_FAIL("{}", errorMessage_);
+  }
+
+  input_ = std::move(input);
+}
+
+RowVectorPtr EnforceDistinct::getOutput() {
+  if (isFinished() || !input_) {
+    return nullptr;
+  }
+
+  auto output = fillOutput(input_->size(), nullptr);
+
+  input_ = nullptr;
+
+  return output;
+}
+
+bool EnforceDistinct::isFinished() {
+  return noMoreInput_ && !input_;
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/EnforceDistinct.h b/velox/exec/EnforceDistinct.h
new file mode 100644
index 00000000000..a09d14f25b2
--- /dev/null
+++ b/velox/exec/EnforceDistinct.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/exec/GroupingSet.h"
+#include "velox/exec/Operator.h"
+
+namespace facebook::velox::exec {
+
+/// Enforces uniqueness of rows based on specified key columns. Passes through
+/// all input rows unchanged. Throws an exception if any duplicate key values
+/// are detected.
+class EnforceDistinct : public Operator {
+ public:
+  EnforceDistinct(
+      int32_t operatorId,
+      DriverCtx* driverCtx,
+      const std::shared_ptr<const core::EnforceDistinctNode>& planNode);
+
+  bool preservesOrder() const override {
+    return true;
+  }
+
+  bool needsInput() const override {
+    return !noMoreInput_ && !input_;
+  }
+
+  void addInput(RowVectorPtr input) override;
+
+  RowVectorPtr getOutput() override;
+
+  BlockingReason isBlocked(ContinueFuture* /*future*/) override {
+    return BlockingReason::kNotBlocked;
+  }
+
+  bool isFinished() override;
+
+ private:
+  const std::string errorMessage_;
+  std::unique_ptr<GroupingSet> groupingSet_;
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/EnforceSingleRow.cpp b/velox/exec/EnforceSingleRow.cpp
index 85d629431fc..c7f71b08edb 100644
--- a/velox/exec/EnforceSingleRow.cpp
+++ b/velox/exec/EnforceSingleRow.cpp
@@ -15,6 +15,8 @@
  */
 #include "velox/exec/EnforceSingleRow.h"
 
+#include "velox/exec/OperatorType.h"
+
 namespace facebook::velox::exec {
 
 EnforceSingleRow::EnforceSingleRow(
@@ -26,7 +28,7 @@ EnforceSingleRow::EnforceSingleRow(
           planNode->outputType(),
           operatorId,
           planNode->id(),
-          "EnforceSingleRow") {
+          OperatorType::kEnforceSingleRow) {
   isIdentityProjection_ = true;
 }
 
diff --git a/velox/exec/Exchange.cpp b/velox/exec/Exchange.cpp
index 4afdb425e7a..2d67c88d54b 100644
--- a/velox/exec/Exchange.cpp
+++ b/velox/exec/Exchange.cpp
@@ -14,8 +14,9 @@
  * limitations under the License.
  */
 #include "velox/exec/Exchange.h"
-
+#include "velox/common/Casts.h"
 #include "velox/common/serialization/Serializable.h"
+#include "velox/exec/OperatorUtils.h"
 #include "velox/exec/Task.h"
 #include "velox/serializers/CompactRowSerializer.h"
 
@@ -42,16 +43,18 @@ void RemoteConnectorSplit::registerSerDe() {
 }
 
 namespace {
-std::unique_ptr<VectorSerde::Options> getVectorSerdeOptions(
-    const core::QueryConfig& queryConfig,
-    VectorSerde::Kind kind) {
-  std::unique_ptr<VectorSerde::Options> options =
-      kind == VectorSerde::Kind::kPresto
-      ? std::make_unique<serializer::presto::PrestoVectorSerde::PrestoOptions>()
-      : std::make_unique<VectorSerde::Options>();
-  options->compressionKind =
-      common::stringToCompressionKind(queryConfig.shuffleCompressionKind());
-  return options;
+std::unique_ptr<folly::IOBuf> mergePages(
+    std::vector<std::unique_ptr<SerializedPageBase>>& pages) {
+  VELOX_CHECK(!pages.empty());
+  std::unique_ptr<folly::IOBuf> mergedBufs;
+  for (const auto& page : pages) {
+    if (mergedBufs == nullptr) {
+      mergedBufs = page->getIOBuf();
+    } else {
+      mergedBufs->appendToChain(page->getIOBuf());
+    }
+  }
+  return mergedBufs;
 }
 } // namespace
 
@@ -60,7 +63,7 @@ Exchange::Exchange(
     DriverCtx* driverCtx,
     const std::shared_ptr<const core::ExchangeNode>& exchangeNode,
     std::shared_ptr<ExchangeClient> exchangeClient,
-    const std::string& operatorType)
+    std::string_view operatorType)
     : SourceOperator(
           driverCtx,
           exchangeNode->outputType(),
@@ -71,8 +74,14 @@ Exchange::Exchange(
           driverCtx->queryConfig().preferredOutputBatchBytes()},
       serdeKind_{exchangeNode->serdeKind()},
       serdeOptions_{getVectorSerdeOptions(
-          operatorCtx_->driverCtx()->queryConfig(),
-          serdeKind_)},
+          common::stringToCompressionKind(operatorCtx_->driverCtx()
+                                              ->queryConfig()
+                                              .shuffleCompressionKind()),
+          serdeKind_,
+          std::nullopt,
+          operatorCtx_->driverCtx()
+              ->queryConfig()
+              .minShuffleCompressionPageSizeBytes())},
       processSplits_{operatorCtx_->driverCtx()->driverId == 0},
       driverId_{driverCtx->driverId},
       exchangeClient_{std::move(exchangeClient)} {}
@@ -85,42 +94,48 @@ void Exchange::addRemoteTaskIds(std::vector<std::string>& remoteTaskIds) {
   stats_.wlock()->numSplits += remoteTaskIds.size();
 }
 
-bool Exchange::getSplits(ContinueFuture* future) {
+void Exchange::getSplits(ContinueFuture* future) {
   if (!processSplits_) {
-    return false;
+    return;
   }
   if (noMoreSplits_) {
-    return false;
+    return;
   }
   std::vector<std::string> remoteTaskIds;
   for (;;) {
     exec::Split split;
-    auto reason = operatorCtx_->task()->getSplitOrFuture(
-        operatorCtx_->driverCtx()->splitGroupId, planNodeId(), split, *future);
-    if (reason == BlockingReason::kNotBlocked) {
-      if (split.hasConnectorSplit()) {
-        auto remoteSplit = std::dynamic_pointer_cast<RemoteConnectorSplit>(
-            split.connectorSplit);
-        VELOX_CHECK_NOT_NULL(remoteSplit, "Wrong type of split");
-        if (FOLLY_UNLIKELY(splitTracer_ != nullptr)) {
-          splitTracer_->write(split);
-        }
-        remoteTaskIds.push_back(remoteSplit->taskId);
-      } else {
-        addRemoteTaskIds(remoteTaskIds);
-        exchangeClient_->noMoreRemoteTasks();
-        noMoreSplits_ = true;
-        if (atEnd_) {
-          operatorCtx_->task()->multipleSplitsFinished(
-              false, stats_.rlock()->numSplits, 0);
-          recordExchangeClientStats();
-        }
-        return false;
-      }
-    } else {
+    const auto reason = operatorCtx_->task()->getSplitOrFuture(
+        operatorCtx_->driverCtx()->driverId,
+        operatorCtx_->driverCtx()->splitGroupId,
+        planNodeId(),
+        /*maxPreloadSplits=*/0,
+        /*preload=*/nullptr,
+        split,
+        *future);
+    if (reason != BlockingReason::kNotBlocked) {
       addRemoteTaskIds(remoteTaskIds);
-      return true;
+      return;
+    }
+
+    if (split.hasConnectorSplit()) {
+      auto remoteSplit =
+          checkedPointerCast<RemoteConnectorSplit>(split.connectorSplit);
+      if (FOLLY_UNLIKELY(splitTracer_ != nullptr)) {
+        splitTracer_->write(split);
+      }
+      remoteTaskIds.push_back(remoteSplit->taskId);
+      continue;
+    }
+
+    addRemoteTaskIds(remoteTaskIds);
+    exchangeClient_->noMoreRemoteTasks();
+    noMoreSplits_ = true;
+    if (atEnd_) {
+      operatorCtx_->task()->multipleSplitsFinished(
+          false, stats_.rlock()->numSplits, 0);
+      recordExchangeClientStats();
     }
+    return;
   }
 }
 
@@ -130,7 +145,6 @@ BlockingReason Exchange::isBlocked(ContinueFuture* future) {
   }
 
   // Start fetching data right away. Do not wait for all splits to be available.
-
   if (!splitFuture_.valid()) {
     getSplits(&splitFuture_);
   }
@@ -159,6 +173,7 @@ BlockingReason Exchange::isBlocked(ContinueFuture* future) {
   }
 
   // Block until data becomes available.
+  VELOX_CHECK(dataFuture.valid());
   *future = std::move(dataFuture);
   return BlockingReason::kWaitForProducer;
 }
@@ -167,102 +182,142 @@ bool Exchange::isFinished() {
   return atEnd_ && currentPages_.empty();
 }
 
-namespace {
-std::unique_ptr<folly::IOBuf> mergePages(
-    std::vector<std::unique_ptr<SerializedPage>>& pages) {
-  VELOX_CHECK(!pages.empty());
-  std::unique_ptr<folly::IOBuf> mergedBufs;
-  for (const auto& page : pages) {
-    if (mergedBufs == nullptr) {
-      mergedBufs = page->getIOBuf();
-    } else {
-      mergedBufs->appendToChain(page->getIOBuf());
-    }
-  }
-  return mergedBufs;
-}
-} // namespace
-
 RowVectorPtr Exchange::getOutput() {
   auto* serde = getSerde();
   if (serde->supportsAppendInDeserialize()) {
-    uint64_t rawInputBytes{0};
-    if (currentPages_.empty()) {
-      return nullptr;
-    }
-    vector_size_t resultOffset = 0;
-    for (const auto& page : currentPages_) {
+    return getOutputFromColumnarPages(serde);
+  }
+  return getOutputFromRowPages(serde);
+}
+
+RowVectorPtr Exchange::getOutputFromColumnarPages(VectorSerde* serde) {
+  if (currentPages_.empty()) {
+    return nullptr;
+  }
+
+  // Calculate target row count based on estimated row size, similar to
+  // getOutputFromRowPages.
+  // Start conservatively, then use estimates.
+  const auto numRows = estimatedRowSize_.has_value()
+      ? std::max(
+            (preferredOutputBatchBytes_ / estimatedRowSize_.value()),
+            kInitialOutputRows)
+      : kInitialOutputRows;
+
+  // Process pages one-by-one from currentPages_ pointed by columnarPageIdx_.
+  // Within each page, deserialize vectors incrementally until we hit the target
+  // batch size.
+  uint64_t rawInputBytes = 0;
+  vector_size_t resultOffset{0};
+
+  // Should be either starting fresh or continuing from a previous partial page
+  VELOX_CHECK(
+      inputStream_ == nullptr || columnarPageIdx_ < currentPages_.size());
+
+  // Iterate through pages
+  while (columnarPageIdx_ < currentPages_.size()) {
+    auto& page = currentPages_[columnarPageIdx_];
+
+    if (!inputStream_) {
+      // NOTE: 'rawInputBytes' only counts bytes from pages processed from the
+      // beginning in this call. If processing resumes from the middle of a
+      // page, that page's bytes are not counted. This ensures each page is
+      // counted only once in 'rawInputBytes' across multiple calls.
       rawInputBytes += page->size();
+      inputStream_ = page->prepareStreamForDeserialize();
+    }
 
-      auto inputStream = page->prepareStreamForDeserialize();
-      while (!inputStream->atEnd()) {
-        serde->deserialize(
-            inputStream.get(),
-            pool(),
-            outputType_,
-            &result_,
-            resultOffset,
-            serdeOptions_.get());
-        resultOffset = result_->size();
-      }
+    // Inner loop: deserialize vectors from current page until batch is full
+    // or page is exhausted.
+    while (!inputStream_->atEnd() && resultOffset < numRows) {
+      serde->deserialize(
+          inputStream_.get(),
+          pool(),
+          outputType_,
+          &result_,
+          resultOffset,
+          serdeOptions_.get());
+
+      resultOffset = result_->size();
+    }
+
+    if (inputStream_->atEnd()) {
+      // Page is fully consumed, free memory immediately, and move to the next.
+      inputStream_ = nullptr;
+      page.reset();
+      ++columnarPageIdx_;
+    }
+
+    // Stop if accumulated enough rows for this batch.
+    if (resultOffset >= numRows) {
+      break;
     }
-    currentPages_.clear();
-    recordInputStats(rawInputBytes);
-    return result_;
-  }
-  if (serde->kind() == VectorSerde::Kind::kCompactRow) {
-    return getOutputFromCompactRows(serde);
   }
-  if (serde->kind() == VectorSerde::Kind::kUnsafeRow) {
-    return getOutputFromUnsafeRows(serde);
+
+  const auto numOutputRows = result_->size();
+  VELOX_CHECK_GT(numOutputRows, 0);
+
+  estimatedRowSize_ = std::max(
+      result_->estimateFlatSize() / numOutputRows,
+      estimatedRowSize_.value_or(1L));
+
+  // If processed all pages, clear the vector and reset state.
+  if (columnarPageIdx_ >= currentPages_.size()) {
+    VELOX_CHECK_NULL(inputStream_);
+    currentPages_.clear();
+    columnarPageIdx_ = 0;
   }
-  VELOX_UNREACHABLE(
-      "Unsupported serde kind: {}", VectorSerde::kindName(serde->kind()));
+
+  recordInputStats(rawInputBytes);
+  return result_;
 }
 
-RowVectorPtr Exchange::getOutputFromCompactRows(VectorSerde* serde) {
+RowVectorPtr Exchange::getOutputFromRowPages(VectorSerde* serde) {
   uint64_t rawInputBytes{0};
   if (currentPages_.empty()) {
-    VELOX_CHECK_NULL(compactRowInputStream_);
-    VELOX_CHECK_NULL(compactRowIterator_);
+    VELOX_CHECK_NULL(inputStream_);
+    VELOX_CHECK_NULL(rowIterator_);
     return nullptr;
   }
 
-  if (compactRowInputStream_ == nullptr) {
+  if (inputStream_ == nullptr) {
     std::unique_ptr<folly::IOBuf> mergedBufs = mergePages(currentPages_);
     rawInputBytes += mergedBufs->computeChainDataLength();
-    compactRowPages_ = std::make_unique<SerializedPage>(std::move(mergedBufs));
-    compactRowInputStream_ = compactRowPages_->prepareStreamForDeserialize();
+    mergedRowPage_ =
+        std::make_unique<PrestoSerializedPage>(std::move(mergedBufs));
+    inputStream_ = mergedRowPage_->prepareStreamForDeserialize();
   }
 
-  auto numRows = kInitialOutputCompactRows;
-  if (estimatedCompactRowSize_.has_value()) {
+  auto numRows = kInitialOutputRows;
+  if (estimatedRowSize_.has_value()) {
     numRows = std::max(
-        (preferredOutputBatchBytes_ / estimatedCompactRowSize_.value()),
-        kInitialOutputCompactRows);
+        (preferredOutputBatchBytes_ / estimatedRowSize_.value()),
+        kInitialOutputRows);
   }
 
+  // Check if the serde supports batched deserialization
   serde->deserialize(
-      compactRowInputStream_.get(),
-      compactRowIterator_,
+      inputStream_.get(),
+      rowIterator_,
       numRows,
       outputType_,
       &result_,
       pool(),
       serdeOptions_.get());
+
   const auto numOutputRows = result_->size();
   VELOX_CHECK_GT(numOutputRows, 0);
 
-  estimatedCompactRowSize_ = std::max(
+  estimatedRowSize_ = std::max(
       result_->estimateFlatSize() / numOutputRows,
-      estimatedCompactRowSize_.value_or(1L));
+      estimatedRowSize_.value_or(1L));
 
-  if (compactRowInputStream_->atEnd() && compactRowIterator_ == nullptr) {
+  if (inputStream_->atEnd() && rowIterator_ == nullptr) {
     // only clear the input stream if we have reached the end of the row
     // iterator because row iterator may depend on input stream if serialized
     // rows are not compressed.
-    compactRowInputStream_ = nullptr;
-    compactRowPages_ = nullptr;
+    inputStream_ = nullptr;
+    mergedRowPage_ = nullptr;
     currentPages_.clear();
   }
 
@@ -270,22 +325,6 @@ RowVectorPtr Exchange::getOutputFromCompactRows(VectorSerde* serde) {
   return result_;
 }
 
-RowVectorPtr Exchange::getOutputFromUnsafeRows(VectorSerde* serde) {
-  uint64_t rawInputBytes{0};
-  if (currentPages_.empty()) {
-    return nullptr;
-  }
-  std::unique_ptr<folly::IOBuf> mergedBufs = mergePages(currentPages_);
-  rawInputBytes += mergedBufs->computeChainDataLength();
-  auto mergedPages = std::make_unique<SerializedPage>(std::move(mergedBufs));
-  auto source = mergedPages->prepareStreamForDeserialize();
-  serde->deserialize(
-      source.get(), pool(), outputType_, &result_, serdeOptions_.get());
-  currentPages_.clear();
-  recordInputStats(rawInputBytes);
-  return result_;
-}
-
 void Exchange::recordInputStats(uint64_t rawInputBytes) {
   auto lockedStats = stats_.wlock();
   lockedStats->rawInputBytes += rawInputBytes;
@@ -297,16 +336,27 @@ void Exchange::close() {
   SourceOperator::close();
   currentPages_.clear();
   result_ = nullptr;
+
+  // Clean up stateful deserialization state
+  inputStream_ = nullptr;
+  mergedRowPage_ = nullptr;
+  rowIterator_ = nullptr;
+  columnarPageIdx_ = 0;
+
   if (exchangeClient_) {
-    recordExchangeClientStats();
+    // Close the client before recording stats so that stats are captured
+    // from the final state. ExchangeClient::close() caches final stats
+    // before clearing sources.
     exchangeClient_->close();
+    recordExchangeClientStats();
   }
   exchangeClient_ = nullptr;
   {
     auto lockedStats = stats_.wlock();
     lockedStats->addRuntimeStat(
         Operator::kShuffleSerdeKind,
-        RuntimeCounter(static_cast<int64_t>(serdeKind_)));
+        RuntimeCounter(
+            static_cast<int64_t>(VectorSerde::kindByName(serdeKind_))));
     lockedStats->addRuntimeStat(
         Operator::kShuffleCompressionKind,
         RuntimeCounter(static_cast<int64_t>(serdeOptions_->compressionKind)));
@@ -325,14 +375,13 @@ void Exchange::recordExchangeClientStats() {
     lockedStats->runtimeStats.insert({name, value});
   }
 
-  auto backgroundCpuTimeMs =
-      exchangeClientStats.find(ExchangeClient::kBackgroundCpuTimeMs);
-  if (backgroundCpuTimeMs != exchangeClientStats.end()) {
+  const auto iter =
+      exchangeClientStats.find(std::string(Operator::kBackgroundCpuTimeNanos));
+  if (iter != exchangeClientStats.end()) {
     const CpuWallTiming backgroundTiming{
-        static_cast<uint64_t>(backgroundCpuTimeMs->second.count),
+        static_cast<uint64_t>(iter->second.count),
         0,
-        static_cast<uint64_t>(backgroundCpuTimeMs->second.sum) *
-            Timestamp::kNanosecondsInMillisecond};
+        static_cast<uint64_t>(iter->second.sum)};
     lockedStats->backgroundTiming.clear();
     lockedStats->backgroundTiming.add(backgroundTiming);
   }
diff --git a/velox/exec/Exchange.h b/velox/exec/Exchange.h
index 2e235b698e9..05e984fc595 100644
--- a/velox/exec/Exchange.h
+++ b/velox/exec/Exchange.h
@@ -19,6 +19,7 @@
 
 #include "velox/exec/ExchangeClient.h"
 #include "velox/exec/Operator.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/OutputBufferManager.h"
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/serializers/RowSerializer.h"
@@ -50,7 +51,7 @@ class Exchange : public SourceOperator {
       DriverCtx* driverCtx,
       const std::shared_ptr<const core::ExchangeNode>& exchangeNode,
       std::shared_ptr<ExchangeClient> exchangeClient,
-      const std::string& operatorType = "Exchange");
+      std::string_view operatorType = OperatorType::kExchange);
 
   ~Exchange() override {
     close();
@@ -67,12 +68,11 @@ class Exchange : public SourceOperator {
  protected:
   virtual VectorSerde* getSerde();
 
- private:
-  // When 'estimatedCompactRowSize_' is unset, meaning we haven't materialized
+  // When 'estimatedRowSize_' is unset, meaning we haven't materialized
   // and returned any output from this exchange operator, we return this
   // conservative number of output rows, to make sure memory does not grow too
   // much.
-  static constexpr uint64_t kInitialOutputCompactRows = 64;
+  static constexpr uint64_t kInitialOutputRows = 64;
 
   // Invoked to create exchange client for remote tasks. The function shuffles
   // the source task ids first to randomize the source tasks we fetch data from.
@@ -82,11 +82,8 @@ class Exchange : public SourceOperator {
 
   // Fetches splits from the task until there are no more splits or task returns
   // a future that will be complete when more splits arrive. Adds splits to
-  // exchangeClient_. Returns true if received a future from the task and sets
-  // the 'future' parameter. Returns false if fetched all splits or if this
-  // operator is not the first operator in the pipeline and therefore is not
-  // responsible for fetching splits and adding them to the exchangeClient_.
-  bool getSplits(ContinueFuture* future);
+  // exchangeClient_.
+  void getSplits(ContinueFuture* future);
 
   // Fetches runtime stats from ExchangeClient and replaces these in this
   // operator's stats.
@@ -94,13 +91,13 @@ class Exchange : public SourceOperator {
 
   void recordInputStats(uint64_t rawInputBytes);
 
-  RowVectorPtr getOutputFromCompactRows(VectorSerde* serde);
+  RowVectorPtr getOutputFromColumnarPages(VectorSerde* serde);
 
-  RowVectorPtr getOutputFromUnsafeRows(VectorSerde* serde);
+  RowVectorPtr getOutputFromRowPages(VectorSerde* serde);
 
   const uint64_t preferredOutputBatchBytes_;
 
-  const VectorSerde::Kind serdeKind_;
+  const std::string serdeKind_;
 
   const std::unique_ptr<VectorSerde::Options> serdeOptions_;
 
@@ -121,19 +118,25 @@ class Exchange : public SourceOperator {
   // Reusable result vector.
   RowVectorPtr result_;
 
-  std::vector<std::unique_ptr<SerializedPage>> currentPages_;
+  std::vector<std::unique_ptr<SerializedPageBase>> currentPages_;
   bool atEnd_{false};
   std::default_random_engine rng_{std::random_device{}()};
 
-  // Memory holders needed by compact row serde to perform cursor like reads
-  // across 'getOutputFromCompactRows' calls.
-  std::unique_ptr<SerializedPage> compactRowPages_;
-  std::unique_ptr<ByteInputStream> compactRowInputStream_;
-  std::unique_ptr<RowIterator> compactRowIterator_;
+  // Memory holders for deserialization across 'getOutput' calls.
+  // The merged pages for row serialization.
+  std::unique_ptr<SerializedPageBase> mergedRowPage_;
+  std::unique_ptr<RowIterator> rowIterator_;
+
+  // State for columnar page deserialization.
+  // Index of the current page in 'currentPages_' being processed.
+  size_t columnarPageIdx_{0};
+
+  // Stream for deserialization used by both row and columnar.
+  std::unique_ptr<ByteInputStream> inputStream_;
 
   // The estimated bytes per row of the output of this exchange operator
   // computed from the last processed output.
-  std::optional<uint64_t> estimatedCompactRowSize_;
+  std::optional<uint64_t> estimatedRowSize_;
 };
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/ExchangeClient.cpp b/velox/exec/ExchangeClient.cpp
index 0a8b92b2f01..0b1ae2ef098 100644
--- a/velox/exec/ExchangeClient.cpp
+++ b/velox/exec/ExchangeClient.cpp
@@ -53,7 +53,16 @@ void ExchangeClient::addRemoteTaskId(const std::string& remoteTaskId) {
       sources_.push_back(source);
       queue_->addSourceLocked();
       emptySources_.push(source);
-      requestSpecs = pickSourcesToRequestLocked();
+      // When lazyFetching_ is true, I/O will be triggered lazily when next() is
+      // called from Exchange::isBlocked(). This allows waiter tasks using
+      // cached hash tables to skip I/O entirely when the table is already
+      // cached - the HashBuild operator will finish before
+      // Exchange::isBlocked() is ever called, so no unnecessary data fetching
+      // occurs.
+      if (!lazyFetching_) {
+        // Start fetching data immediately.
+        requestSpecs = pickSourcesToRequestLocked();
+      }
     }
   }
 
@@ -78,6 +87,11 @@ void ExchangeClient::close() {
     if (closed_) {
       return;
     }
+
+    // Capture stats BEFORE clearing sources_.
+    // This allows stats() to return meaningful data even after close().
+    stats_ = collectStatsLocked();
+
     closed_ = true;
     sources = std::move(sources_);
     producingSources = std::move(producingSources_);
@@ -91,41 +105,52 @@ void ExchangeClient::close() {
   queue_->close();
 }
 
-folly::F14FastMap<std::string, RuntimeMetric> ExchangeClient::stats() const {
-  folly::F14FastMap<std::string, RuntimeMetric> stats;
+folly::F14FastMap<std::string, RuntimeMetric> ExchangeClient::stats() {
   std::lock_guard<std::mutex> l(queue_->mutex());
+  if (stats_.empty()) {
+    stats_ = collectStatsLocked();
+  }
+  return stats_;
+}
+
+folly::F14FastMap<std::string, RuntimeMetric>
+ExchangeClient::collectStatsLocked() const {
+  folly::F14FastMap<std::string, RuntimeMetric> stats;
 
   for (const auto& source : sources_) {
     if (source->supportsMetrics()) {
       for (const auto& [name, value] : source->metrics()) {
-        if (UNLIKELY(stats.count(name) == 0)) {
-          stats.insert(std::pair(name, RuntimeMetric(value.unit)));
-        }
-        stats[name].merge(value);
+        auto [iter, inserted] = stats.try_emplace(name, value.unit);
+        iter->second.merge(value);
       }
     } else {
       for (const auto& [name, value] : source->stats()) {
-        stats[name].addValue(value);
+        auto [iter, inserted] = stats.try_emplace(name);
+        iter->second.addValue(value);
       }
     }
   }
 
-  stats["peakBytes"] =
-      RuntimeMetric(queue_->peakBytes(), RuntimeCounter::Unit::kBytes);
-  stats["numReceivedPages"] = RuntimeMetric(queue_->receivedPages());
-  stats["averageReceivedPageBytes"] = RuntimeMetric(
-      queue_->averageReceivedPageBytes(), RuntimeCounter::Unit::kBytes);
+  stats.insert_or_assign(
+      "peakBytes",
+      RuntimeMetric(queue_->peakBytes(), RuntimeCounter::Unit::kBytes));
+  stats.insert_or_assign(
+      "numReceivedPages", RuntimeMetric(queue_->receivedPages()));
+  stats.insert_or_assign(
+      "averageReceivedPageBytes",
+      RuntimeMetric(
+          queue_->averageReceivedPageBytes(), RuntimeCounter::Unit::kBytes));
 
   return stats;
 }
 
-std::vector<std::unique_ptr<SerializedPage>> ExchangeClient::next(
+std::vector<std::unique_ptr<SerializedPageBase>> ExchangeClient::next(
     int consumerId,
     uint32_t maxBytes,
     bool* atEnd,
     ContinueFuture* future) {
   std::vector<RequestSpec> requestSpecs;
-  std::vector<std::unique_ptr<SerializedPage>> pages;
+  std::vector<std::unique_ptr<SerializedPageBase>> pages;
   ContinuePromise stalePromise = ContinuePromise::makeEmpty();
   {
     std::lock_guard<std::mutex> l(queue_->mutex());
@@ -161,7 +186,7 @@ void ExchangeClient::request(std::vector<RequestSpec>&& requestSpecs) {
   for (auto& spec : requestSpecs) {
     auto future = folly::SemiFuture<ExchangeSource::Response>::makeEmpty();
     if (spec.maxBytes == 0) {
-      future = spec.source->requestDataSizes(kRequestDataSizesMaxWaitSec_);
+      future = spec.source->requestDataSizes(requestDataSizesMaxWaitSec_);
     } else {
       future = spec.source->request(spec.maxBytes, kRequestDataMaxWait);
     }
@@ -185,7 +210,7 @@ void ExchangeClient::request(std::vector<RequestSpec>&& requestSpecs) {
                 RECORD_METRIC_VALUE(kMetricExchangeDataCount);
               }
 
-              bool pauseCurrentSource = false;
+              bool pauseCurrentSource{false};
               std::vector<RequestSpec> requestSpecs;
               std::shared_ptr<ExchangeSource> currentSource = spec.source;
               {
@@ -232,6 +257,9 @@ ExchangeClient::pickSourcesToRequestLocked() {
   if (closed_) {
     return {};
   }
+  if (skipRequestDataSizeWithSingleSource()) {
+    return pickupSingleSourceToRequestLocked();
+  }
   std::vector<RequestSpec> requestSpecs;
   while (!emptySources_.empty()) {
     auto& source = emptySources_.front();
@@ -267,10 +295,10 @@ ExchangeClient::pickSourcesToRequestLocked() {
     // 1. We have full capacity but still cannot initiate one single data
     //    transfer. Let the transfer happen in this case to avoid getting stuck.
     //
-    // 2. We have some data in the queue that is not big enough for
-    //    consumers and it is big enough to not allow ExchangeClient to
-    //    initiate request for more data. Let transfer happen in this case
-    //    to avoid this deadlock situation.
+    // 2. We have some data in the queue that is not big enough for consumers,
+    //    and it is big enough to not allow ExchangeClient to initiate request
+    //    for more data. Let transfer happen in this case to avoid this deadlock
+    //    situation.
     auto& source = producingSources_.front().source;
     auto requestBytes = producingSources_.front().remainingBytes.at(0);
     LOG(INFO) << "Requesting large single page " << requestBytes
@@ -283,6 +311,43 @@ ExchangeClient::pickSourcesToRequestLocked() {
   return requestSpecs;
 }
 
+std::vector<ExchangeClient::RequestSpec>
+ExchangeClient::pickupSingleSourceToRequestLocked() {
+  VELOX_CHECK_EQ(sources_.size(), 1);
+  VELOX_CHECK(!closed_);
+  if (emptySources_.empty() && producingSources_.empty()) {
+    return {};
+  }
+
+  VELOX_CHECK_EQ(totalPendingBytes_, 0);
+  VELOX_CHECK_LE(!!emptySources_.empty() + !!producingSources_.empty(), 1);
+  const auto requestBytes = maxQueuedBytes_ - queue_->totalBytes();
+
+  if (requestBytes <= 0) {
+    return {};
+  }
+  std::vector<RequestSpec> requestSpecs;
+  SCOPE_EXIT {
+    totalPendingBytes_ += requestBytes;
+  };
+  if (!emptySources_.empty()) {
+    VELOX_CHECK_EQ(emptySources_.size(), 1);
+    auto& source = emptySources_.front();
+    VELOX_CHECK(source->shouldRequestLocked());
+    requestSpecs.push_back({std::move(source), requestBytes});
+    emptySources_.pop();
+    return requestSpecs;
+  }
+
+  VELOX_CHECK_EQ(producingSources_.size(), 1);
+  auto& source = producingSources_.front().source;
+  VELOX_CHECK(source->shouldRequestLocked());
+  VELOX_CHECK(!producingSources_.front().remainingBytes.empty());
+  requestSpecs.push_back({std::move(source), requestBytes});
+  producingSources_.pop();
+  return requestSpecs;
+}
+
 ExchangeClient::~ExchangeClient() {
   close();
 }
diff --git a/velox/exec/ExchangeClient.h b/velox/exec/ExchangeClient.h
index b99fc49e885..cb279d74184 100644
--- a/velox/exec/ExchangeClient.h
+++ b/velox/exec/ExchangeClient.h
@@ -26,7 +26,6 @@ class ExchangeClient : public std::enable_shared_from_this<ExchangeClient> {
  public:
   static constexpr int32_t kDefaultMaxQueuedBytes = 32 << 20; // 32 MB.
   static constexpr std::chrono::milliseconds kRequestDataMaxWait{100};
-  static inline const std::string kBackgroundCpuTimeMs = "backgroundCpuTimeMs";
 
   ExchangeClient(
       std::string taskId,
@@ -36,23 +35,29 @@ class ExchangeClient : public std::enable_shared_from_this<ExchangeClient> {
       uint64_t minOutputBatchBytes,
       memory::MemoryPool* pool,
       folly::Executor* executor,
-      int32_t requestDataSizesMaxWaitSec = 10)
+      int32_t requestDataSizesMaxWaitSec = 10,
+      bool skipRequestDataSizeWithSingleSource = false,
+      bool lazyFetching = false)
       : taskId_{std::move(taskId)},
         destination_(destination),
         maxQueuedBytes_{maxQueuedBytes},
-        kRequestDataSizesMaxWaitSec_{requestDataSizesMaxWaitSec},
+        requestDataSizesMaxWaitSec_{requestDataSizesMaxWaitSec},
         pool_(pool),
         executor_(executor),
-        queue_(std::make_shared<ExchangeQueue>(
-            numberOfConsumers,
-            minOutputBatchBytes)),
+        queue_(
+            std::make_shared<ExchangeQueue>(
+                numberOfConsumers,
+                minOutputBatchBytes)),
         // See comment in 'pickSourcesToRequestLocked' for why this is needed
         // for 'minOutputBatchBytes_'. Note: ExchangeQueue does not need max(1,
         // minOutputBatchBytes) because for 'MergeExchangeSource', we want
         // ExchangeQueue 'minOutputBatchBytes' to be be 0 so that it always
         // unblocks. In short, 0 has a special meaning for ExchangeQueue
         minOutputBatchBytes_(
-            std::max(static_cast<uint64_t>(1), minOutputBatchBytes)) {
+            std::max(static_cast<uint64_t>(1), minOutputBatchBytes)),
+        skipRequestDataSizeWithSingleSource_(
+            skipRequestDataSizeWithSingleSource),
+        lazyFetching_(lazyFetching) {
     VELOX_CHECK_NOT_NULL(pool_);
     VELOX_CHECK_NOT_NULL(executor_);
     // NOTE: the executor is used to run async response callback from the
@@ -87,8 +92,8 @@ class ExchangeClient : public std::enable_shared_from_this<ExchangeClient> {
 
   // Returns runtime statistics aggregated across all of the exchange sources.
   // ExchangeClient is expected to report background CPU time by including a
-  // runtime metric named ExchangeClient::kBackgroundCpuTimeMs.
-  folly::F14FastMap<std::string, RuntimeMetric> stats() const;
+  // runtime metric named Operator::kBackgroundCpuTimeNanos.
+  folly::F14FastMap<std::string, RuntimeMetric> stats();
 
   const std::shared_ptr<ExchangeQueue>& queue() const {
     return queue_;
@@ -102,7 +107,7 @@ class ExchangeClient : public std::enable_shared_from_this<ExchangeClient> {
   ///
   /// The data may be compressed, in which case 'maxBytes' applies to compressed
   /// size.
-  std::vector<std::unique_ptr<SerializedPage>>
+  std::vector<std::unique_ptr<SerializedPageBase>>
   next(int consumerId, uint32_t maxBytes, bool* atEnd, ContinueFuture* future);
 
   std::string toString() const;
@@ -110,7 +115,7 @@ class ExchangeClient : public std::enable_shared_from_this<ExchangeClient> {
   folly::dynamic toJson() const;
 
   std::chrono::seconds requestDataSizesMaxWaitSec() const {
-    return kRequestDataSizesMaxWaitSec_;
+    return requestDataSizesMaxWaitSec_;
   }
 
   const std::unordered_set<std::string>& getRemoteTaskIdList() const {
@@ -131,15 +136,42 @@ class ExchangeClient : public std::enable_shared_from_this<ExchangeClient> {
     std::vector<int64_t> remainingBytes;
   };
 
+  // Selects exchange sources to request data from based on available queue
+  // capacity. Handles multiple sources by first requesting data sizes from all
+  // empty sources, then requesting actual data from producing sources based on
+  // their remaining bytes and available capacity. May initiate out-of-band
+  // transfers for large pages that exceed capacity to avoid deadlock
+  // situations. For single source case, delegates to
+  // pickupSingleSourceToRequestLocked which sets max request bytes based on
+  // available queue space instead of reported remaining bytes from exchange
+  // sources.
   std::vector<RequestSpec> pickSourcesToRequestLocked();
 
+  // Specialized single-source request picker for single-source exchange
+  // clients. Sets the max request bytes based on available space in the queue
+  // rather than the reported remaining bytes from exchange sources. The reason
+  // is that single source has no other alternative so just fetch as much as
+  // possible from that source. Returns a request spec for the single source
+  // when there is available capacity in the queue and no pending requests. If
+  // capacity is unavailable or requests are already pending, returns empty
+  // vector.
+  std::vector<RequestSpec> pickupSingleSourceToRequestLocked();
   void request(std::vector<RequestSpec>&& requestSpecs);
 
+  /// Returns true if skip request data size optimization is enabled for single
+  /// source exchanges.
+  bool skipRequestDataSizeWithSingleSource() const {
+    return skipRequestDataSizeWithSingleSource_ && queue_->hasNoMoreSources() &&
+        sources_.size() == 1;
+  }
+
+  folly::F14FastMap<std::string, RuntimeMetric> collectStatsLocked() const;
+
   // Handy for ad-hoc logging.
   const std::string taskId_;
   const int destination_;
   const int64_t maxQueuedBytes_;
-  const std::chrono::seconds kRequestDataSizesMaxWaitSec_;
+  const std::chrono::seconds requestDataSizesMaxWaitSec_;
 
   memory::MemoryPool* const pool_;
   folly::Executor* const executor_;
@@ -149,10 +181,21 @@ class ExchangeClient : public std::enable_shared_from_this<ExchangeClient> {
   std::vector<std::shared_ptr<ExchangeSource>> sources_;
   bool closed_{false};
 
+  folly::F14FastMap<std::string, RuntimeMetric> stats_;
+
   // The minimum byte size the consumer is expected to consume from
   // the exchange queue.
   const uint64_t minOutputBatchBytes_;
 
+  // Enable single source exchange optimization query config flag
+  // when there is only one exchange source.
+  const bool skipRequestDataSizeWithSingleSource_;
+
+  // If true, defer fetching until next() is called.
+  // If false (default), start fetching data immediately when remote tasks are
+  // added.
+  const bool lazyFetching_;
+
   // Total number of bytes in flight.
   int64_t totalPendingBytes_{0};
 
diff --git a/velox/exec/ExchangeQueue.cpp b/velox/exec/ExchangeQueue.cpp
index 7d1c24369b9..9a9114ae2c4 100644
--- a/velox/exec/ExchangeQueue.cpp
+++ b/velox/exec/ExchangeQueue.cpp
@@ -22,40 +22,12 @@ using facebook::velox::common::testutil::TestValue;
 
 namespace facebook::velox::exec {
 
-SerializedPage::SerializedPage(
-    std::unique_ptr<folly::IOBuf> iobuf,
-    std::function<void(folly::IOBuf&)> onDestructionCb,
-    std::optional<int64_t> numRows)
-    : iobuf_(std::move(iobuf)),
-      iobufBytes_(chainBytes(*iobuf_.get())),
-      numRows_(numRows),
-      onDestructionCb_(onDestructionCb) {
-  VELOX_CHECK_NOT_NULL(iobuf_);
-  for (auto& buf : *iobuf_) {
-    int32_t bufSize = buf.size();
-    ranges_.push_back(ByteRange{
-        const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(buf.data())),
-        bufSize,
-        0});
-  }
-}
-
-SerializedPage::~SerializedPage() {
-  if (onDestructionCb_) {
-    onDestructionCb_(*iobuf_.get());
-  }
-}
-
-std::unique_ptr<ByteInputStream> SerializedPage::prepareStreamForDeserialize() {
-  return std::make_unique<BufferInputStream>(std::move(ranges_));
-}
-
 void ExchangeQueue::noMoreSources() {
   std::vector<ContinuePromise> promises;
   {
     std::lock_guard<std::mutex> l(mutex_);
     noMoreSources_ = true;
-    promises = checkCompleteLocked();
+    promises = checkNoMoreInput();
   }
   clearPromises(promises);
 }
@@ -70,20 +42,21 @@ void ExchangeQueue::close() {
 }
 
 int64_t ExchangeQueue::minOutputBatchBytesLocked() const {
-  // always allow to unblock when at end
-  if (atEnd_) {
+  // Allow to unblock if no more input.
+  if (noMoreInput_) {
     return 0;
   }
-  // At most 1% of received bytes so far to minimize latency for small exchanges
+  // At most 1% of received bytes so far to minimize latency for small
+  // exchanges.
   return std::min<int64_t>(minOutputBatchBytes_, receivedBytes_ / 100);
 }
 
 void ExchangeQueue::enqueueLocked(
-    std::unique_ptr<SerializedPage>&& page,
+    std::unique_ptr<SerializedPageBase>&& page,
     std::vector<ContinuePromise>& promises) {
   if (page == nullptr) {
     ++numCompleted_;
-    auto completedPromises = checkCompleteLocked();
+    auto completedPromises = checkNoMoreInput();
     promises.reserve(promises.size() + completedPromises.size());
     for (auto& promise : completedPromises) {
       promises.push_back(std::move(promise));
@@ -128,12 +101,12 @@ void ExchangeQueue::addPromiseLocked(
     *stalePromise = std::move(it->second);
     it->second = std::move(promise);
   } else {
-    promises_[consumerId] = std::move(promise);
+    promises_.emplace(consumerId, std::move(promise));
   }
   VELOX_CHECK_LE(promises_.size(), numberOfConsumers_);
 }
 
-std::vector<std::unique_ptr<SerializedPage>> ExchangeQueue::dequeueLocked(
+std::vector<std::unique_ptr<SerializedPageBase>> ExchangeQueue::dequeueLocked(
     int consumerId,
     uint32_t maxBytes,
     bool* atEnd,
@@ -156,11 +129,11 @@ std::vector<std::unique_ptr<SerializedPage>> ExchangeQueue::dequeueLocked(
     return {};
   }
 
-  std::vector<std::unique_ptr<SerializedPage>> pages;
+  std::vector<std::unique_ptr<SerializedPageBase>> pages;
   uint32_t pageBytes = 0;
   for (;;) {
     if (queue_.empty()) {
-      if (atEnd_) {
+      if (noMoreInput_) {
         *atEnd = true;
       } else if (pages.empty()) {
         addPromiseLocked(consumerId, future, stalePromise);
@@ -189,9 +162,9 @@ void ExchangeQueue::setError(const std::string& error) {
       return;
     }
     error_ = error;
-    atEnd_ = true;
-    // NOTE: clear the serialized page queue as we won't consume from an
-    // errored queue.
+    noMoreInput_ = true;
+    // NOTE: clear the serialized page queue as we won't consume from an errored
+    // queue.
     queue_.clear();
     promises = clearAllPromisesLocked();
   }
diff --git a/velox/exec/ExchangeQueue.h b/velox/exec/ExchangeQueue.h
index 4f77360fdbc..91a633d5366 100644
--- a/velox/exec/ExchangeQueue.h
+++ b/velox/exec/ExchangeQueue.h
@@ -15,66 +15,11 @@
  */
 #pragma once
 
-#include "velox/common/memory/ByteStream.h"
+#include "velox/exec/SerializedPage.h"
 
-namespace facebook::velox::exec {
-
-/// Corresponds to Presto SerializedPage, i.e. a container for serialize vectors
-/// in Presto wire format.
-class SerializedPage {
- public:
-  /// Construct from IOBuf chain.
-  explicit SerializedPage(
-      std::unique_ptr<folly::IOBuf> iobuf,
-      std::function<void(folly::IOBuf&)> onDestructionCb = nullptr,
-      std::optional<int64_t> numRows = std::nullopt);
-
-  ~SerializedPage();
+#include <mutex>
 
-  /// Returns the size of the serialized data in bytes.
-  uint64_t size() const {
-    return iobufBytes_;
-  }
-
-  std::optional<int64_t> numRows() const {
-    return numRows_;
-  }
-
-  /// Makes 'input' ready for deserializing 'this' with
-  /// VectorStreamGroup::read().
-  std::unique_ptr<ByteInputStream> prepareStreamForDeserialize();
-
-  std::unique_ptr<folly::IOBuf> getIOBuf() const {
-    return iobuf_->clone();
-  }
-
- private:
-  static int64_t chainBytes(folly::IOBuf& iobuf) {
-    int64_t size = 0;
-    for (auto& range : iobuf) {
-      size += range.size();
-    }
-    return size;
-  }
-
-  // Buffers containing the serialized data. The memory is owned by 'iobuf_'.
-  std::vector<ByteRange> ranges_;
-
-  // IOBuf holding the data in 'ranges_.
-  std::unique_ptr<folly::IOBuf> iobuf_;
-
-  // Number of payload bytes in 'iobuf_'.
-  const int64_t iobufBytes_;
-
-  // Number of payload rows, if provided.
-  const std::optional<int64_t> numRows_;
-
-  // Callback that will be called on destruction of the SerializedPage,
-  // primarily used to free externally allocated memory backing folly::IOBuf
-  // from caller. Caller is responsible to pass in proper cleanup logic to
-  // prevent any memory leak.
-  std::function<void(folly::IOBuf&)> onDestructionCb_;
-};
+namespace facebook::velox::exec {
 
 /// Queue of results retrieved from source. Owned by shared_ptr by
 /// Exchange and client threads and registered callbacks waiting
@@ -108,7 +53,7 @@ class ExchangeQueue {
   /// returned in 'promises'. When 'page' is nullptr and the queue is not
   /// completed serving data, no 'promises' will be added and returned.
   void enqueueLocked(
-      std::unique_ptr<SerializedPage>&& page,
+      std::unique_ptr<SerializedPageBase>&& page,
       std::vector<ContinuePromise>& promises);
 
   /// If data is permanently not available, e.g. the source cannot be
@@ -127,7 +72,7 @@ class ExchangeQueue {
   ///
   /// The data may be compressed, in which case 'maxBytes' applies to compressed
   /// size.
-  std::vector<std::unique_ptr<SerializedPage>> dequeueLocked(
+  std::vector<std::unique_ptr<SerializedPageBase>> dequeueLocked(
       int consumerId,
       uint32_t maxBytes,
       bool* atEnd,
@@ -162,6 +107,10 @@ class ExchangeQueue {
 
   void noMoreSources();
 
+  bool hasNoMoreSources() const {
+    return noMoreSources_;
+  }
+
   void close();
 
  private:
@@ -170,9 +119,9 @@ class ExchangeQueue {
     return clearAllPromisesLocked();
   }
 
-  std::vector<ContinuePromise> checkCompleteLocked() {
+  std::vector<ContinuePromise> checkNoMoreInput() {
     if (noMoreSources_ && numCompleted_ == numSources_) {
-      atEnd_ = true;
+      noMoreInput_ = true;
       return clearAllPromisesLocked();
     }
     return {};
@@ -193,7 +142,9 @@ class ExchangeQueue {
   }
 
   std::vector<ContinuePromise> clearAllPromisesLocked() {
-    std::vector<ContinuePromise> promises(promises_.size());
+    std::vector<ContinuePromise> promises;
+    promises.reserve(promises_.size());
+
     auto it = promises_.begin();
     while (it != promises_.end()) {
       promises.push_back(std::move(it->second));
@@ -216,11 +167,14 @@ class ExchangeQueue {
 
   int numCompleted_{0};
   int numSources_{0};
-  bool noMoreSources_{false};
-  bool atEnd_{false};
+  tsan_atomic<bool> noMoreSources_{false};
+  // True if no more pages will be enqueued. This can be due to all sources
+  // completing normally or an error. Note that the queue itself may still
+  // contain data to be consumed.
+  bool noMoreInput_{false};
 
   std::mutex mutex_;
-  std::deque<std::unique_ptr<SerializedPage>> queue_;
+  std::deque<std::unique_ptr<SerializedPageBase>> queue_;
   // The map from consumer id to the waiting promise
   folly::F14FastMap<int, ContinuePromise> promises_;
 
diff --git a/velox/exec/ExchangeSource.h b/velox/exec/ExchangeSource.h
index 2b0f74fa205..79ec65781b8 100644
--- a/velox/exec/ExchangeSource.h
+++ b/velox/exec/ExchangeSource.h
@@ -106,7 +106,7 @@ class ExchangeSource : public std::enable_shared_from_this<ExchangeSource> {
 
   // Returns runtime statistics. ExchangeSource is expected to report
   // background CPU time by including a runtime metric named
-  // ExchangeClient::kBackgroundCpuTimeMs.
+  // Operator::kBackgroundCpuTimeNanos.
   virtual folly::F14FastMap<std::string, int64_t> stats() const {
     VELOX_UNREACHABLE();
   }
diff --git a/velox/exec/Expand.cpp b/velox/exec/Expand.cpp
index 5d866b888c1..39a35053c0e 100644
--- a/velox/exec/Expand.cpp
+++ b/velox/exec/Expand.cpp
@@ -15,6 +15,8 @@
  */
 #include "velox/exec/Expand.h"
 
+#include "velox/exec/OperatorType.h"
+
 namespace facebook::velox::exec {
 
 Expand::Expand(
@@ -26,11 +28,12 @@ Expand::Expand(
           expandNode->outputType(),
           operatorId,
           expandNode->id(),
-          "Expand") {
+          OperatorType::kExpand) {
   const auto& inputType = expandNode->inputType();
   const auto numRows = expandNode->projections().size();
   fieldProjections_.reserve(numRows);
   constantProjections_.reserve(numRows);
+  constantOutputs_.reserve(numRows);
   const auto numColumns = expandNode->names().size();
   for (const auto& rowProjections : expandNode->projections()) {
     std::vector<column_index_t> rowProjection;
@@ -58,6 +61,26 @@ Expand::Expand(
   }
 }
 
+void Expand::initialize() {
+  Operator::initialize();
+  if (constantProjections_.empty()) {
+    return;
+  }
+  const auto numColumns = constantProjections_[0].size();
+  for (const auto& projections : constantProjections_) {
+    std::vector<VectorPtr> constantOutput;
+    constantOutput.reserve(numColumns);
+    for (const auto& constant : projections) {
+      if (constant) {
+        constantOutput.push_back(constant->toConstantVector(pool()));
+      } else {
+        constantOutput.push_back(nullptr);
+      }
+    }
+    constantOutputs_.emplace_back(std::move(constantOutput));
+  }
+}
+
 bool Expand::needsInput() const {
   return !noMoreInput_ && input_ == nullptr;
 }
@@ -81,21 +104,13 @@ RowVectorPtr Expand::getOutput() {
   std::vector<VectorPtr> outputColumns(outputType_->size());
 
   const auto& rowProjection = fieldProjections_[rowIndex_];
-  const auto& constantProjection = constantProjections_[rowIndex_];
+  const auto& constantProjection = constantOutputs_[rowIndex_];
   const auto numColumns = rowProjection.size();
 
   for (auto i = 0; i < numColumns; ++i) {
     if (rowProjection[i] == kConstantChannel) {
-      const auto& constantExpr = constantProjection[i];
-      if (constantExpr->value().isNull()) {
-        // Add null column.
-        outputColumns[i] = BaseVector::createNullConstant(
-            outputType_->childAt(i), numInput, pool());
-      } else {
-        // Add constant column.
-        outputColumns[i] = BaseVector::createConstant(
-            constantExpr->type(), constantExpr->value(), numInput, pool());
-      }
+      outputColumns[i] =
+          BaseVector::wrapInConstant(numInput, 0, constantProjection[i]);
     } else {
       outputColumns[i] = input_->childAt(rowProjection[i]);
     }
diff --git a/velox/exec/Expand.h b/velox/exec/Expand.h
index 97c737c1d1f..adf87a71526 100644
--- a/velox/exec/Expand.h
+++ b/velox/exec/Expand.h
@@ -42,11 +42,15 @@ class Expand : public Operator {
   }
 
  private:
+  void initialize() override;
+
   std::vector<std::vector<column_index_t>> fieldProjections_;
 
   std::vector<std::vector<std::shared_ptr<const core::ConstantTypedExpr>>>
       constantProjections_;
 
+  std::vector<std::vector<VectorPtr>> constantOutputs_;
+
   // Used to indicate the index of fieldProjections_.
   int32_t rowIndex_{0};
 };
diff --git a/velox/exec/FilterProject.cpp b/velox/exec/FilterProject.cpp
index b8189539d8f..a583b34db2e 100644
--- a/velox/exec/FilterProject.cpp
+++ b/velox/exec/FilterProject.cpp
@@ -15,6 +15,8 @@
  */
 #include "velox/exec/FilterProject.h"
 #include "velox/core/Expressions.h"
+#include "velox/exec/Driver.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/expression/Expr.h"
 #include "velox/expression/FieldReference.h"
 
@@ -72,6 +74,65 @@ std::vector<OperatorStats> splitStats(
   return {std::move(projectStats), std::move(filterStats)};
 }
 
+// Unwraps dictionary/constant/sequence encodings to get to the underlying
+// Lazy vector if it exists. Otherwise, returns nullptr.
+const BaseVector* unwrapToLazy(const VectorPtr& vector) {
+  switch (vector->encoding()) {
+    case VectorEncoding::Simple::CONSTANT:
+    case VectorEncoding::Simple::DICTIONARY:
+    case VectorEncoding::Simple::SEQUENCE: {
+      return vector->valueVector() ? unwrapToLazy(vector->valueVector())
+                                   : nullptr;
+    }
+    case VectorEncoding::Simple::LAZY:
+      return vector.get();
+    default:
+      return nullptr;
+  }
+}
+
+// Returns a unique identity pointer for Lazy vectors. For other vectors,
+// returns nullptr.
+const void* lazyIdentityPtr(const VectorPtr& vec) {
+  if (!vec) {
+    return nullptr;
+  }
+  const BaseVector* lazyVec = unwrapToLazy(vec);
+  if (!lazyVec) {
+    return nullptr;
+  }
+  return static_cast<const void*>(lazyVec);
+}
+
+// Load the reused lazy vectors in the output. A lazy vector cannot be reused
+// across different output fields because its contents may be loaded via a
+// hook during pushdown. Accessing a loaded vector in this case can lead to
+// incorrect results or even a crash.
+void loadReusedLazyVectors(const RowVectorPtr& output) {
+  if (!output || !output->containsLazyNotLoaded()) {
+    return;
+  }
+
+  const auto& vectors = output->children();
+
+  // Build a map of lazy identity pointers to their occurrence count.
+  std::unordered_map<const void*, size_t> lazyIdentityCounts;
+  for (const auto& vector : vectors) {
+    const void* id = lazyIdentityPtr(vector);
+    if (id) {
+      lazyIdentityCounts[id]++;
+    }
+  }
+
+  // Load only the vectors whose lazy identity appears more than once.
+  for (auto& vector : vectors) {
+    const void* id = lazyIdentityPtr(vector);
+    if (id && lazyIdentityCounts[id] > 1) {
+      vector->loadedVector();
+    }
+  }
+}
+
 } // namespace
 
 FilterProject::FilterProject(
@@ -84,7 +145,7 @@ FilterProject::FilterProject(
           project ? project->outputType() : filter->outputType(),
           operatorId,
           project ? project->id() : filter->id(),
-          "FilterProject"),
+          OperatorType::kFilterProject),
       hasFilter_(filter != nullptr),
       lazyDereference_(
           dynamic_cast<const core::LazyDereferenceNode*>(project.get()) !=
@@ -148,6 +209,11 @@ void FilterProject::initialize() {
   }
   filter_.reset();
   project_.reset();
+
+  if (const auto* traceCtx = operatorCtx_->driverCtx()->traceCtx();
+      traceCtx && traceCtx->shouldTrace(*this)) {
+    exprs_->maybeSetupTracers(*this, *traceCtx);
+  }
 }
 
 void FilterProject::addInput(RowVectorPtr input) {
@@ -185,7 +251,9 @@ RowVectorPtr FilterProject::getOutput() {
   if (!hasFilter_) {
     VELOX_CHECK(!isIdentityProjection_);
     auto results = project(*rows, evalCtx);
-    return fillOutput(size, nullptr, results);
+    auto output = fillOutput(size, nullptr, results);
+    loadReusedLazyVectors(output);
+    return output;
   }
 
   // evaluate filter
@@ -205,10 +273,12 @@ RowVectorPtr FilterProject::getOutput() {
     results = project(*rows, evalCtx);
   }
 
-  return fillOutput(
+  auto output = fillOutput(
       numOut,
       allRowsSelected ? nullptr : filterEvalCtx_.selectedIndices,
       results);
+  loadReusedLazyVectors(output);
+  return output;
 }
 
 std::vector<VectorPtr> FilterProject::project(
diff --git a/velox/exec/FilterProject.h b/velox/exec/FilterProject.h
index 79aafcc4a8d..85947b21d97 100644
--- a/velox/exec/FilterProject.h
+++ b/velox/exec/FilterProject.h
@@ -59,6 +59,7 @@ class FilterProject : public Operator {
   void close() override {
     Operator::close();
     if (exprs_ != nullptr) {
+      exprs_->finishTracers();
       exprs_->clear();
     } else {
       VELOX_CHECK(!initialized_);
@@ -82,6 +83,12 @@ class FilterProject : public Operator {
   /// tracking is enabled via query config.
   OperatorStats stats(bool clear) override;
 
+  /// Returns the filterNode, call this function before initialize the operator,
+  /// this field is reset in function initialize.
+  const std::shared_ptr<const core::FilterNode>& filterNode() const {
+    return filter_;
+  }
+
  private:
   // Evaluate filter on all rows. Return number of rows that passed the filter.
   // Populate filterEvalCtx_.selectedBits and selectedIndices with the indices
diff --git a/velox/exec/GroupId.cpp b/velox/exec/GroupId.cpp
index f64c4e51fc3..cf51b4ed2ba 100644
--- a/velox/exec/GroupId.cpp
+++ b/velox/exec/GroupId.cpp
@@ -15,6 +15,8 @@
  */
 #include "velox/exec/GroupId.h"
 
+#include "velox/exec/OperatorType.h"
+
 namespace facebook::velox::exec {
 
 GroupId::GroupId(
@@ -26,7 +28,7 @@ GroupId::GroupId(
           groupIdNode->outputType(),
           operatorId,
           groupIdNode->id(),
-          "GroupId") {
+          OperatorType::kGroupId) {
   const auto& inputType = groupIdNode->sources()[0]->outputType();
 
   std::unordered_map<column_index_t, column_index_t>
diff --git a/velox/exec/GroupingSet.cpp b/velox/exec/GroupingSet.cpp
index 63bbf4b5c3c..ab885023b27 100644
--- a/velox/exec/GroupingSet.cpp
+++ b/velox/exec/GroupingSet.cpp
@@ -15,6 +15,7 @@
  */
 #include "velox/exec/GroupingSet.h"
 #include "velox/common/testutil/TestValue.h"
+#include "velox/exec/OperatorUtils.h"
 #include "velox/exec/Task.h"
 
 using facebook::velox::common::testutil::TestValue;
@@ -55,26 +56,26 @@ GroupingSet::GroupingSet(
     tsan_atomic<bool>* nonReclaimableSection,
     const core::QueryConfig* queryConfig,
     memory::MemoryPool* pool,
-    folly::Synchronized<common::SpillStats>* spillStats)
+    exec::SpillStats* spillStats)
     : preGroupedKeyChannels_(std::move(preGroupedKeys)),
-      groupingKeyOutputProjections_(std::move(groupingKeyOutputProjections)),
-      hashers_(std::move(hashers)),
-      isGlobal_(hashers_.empty()),
+      isGlobal_(hashers.empty()),
       isPartial_(isPartial),
       isRawInput_(isRawInput),
+      ignoreNullKeys_(ignoreNullKeys),
+      isAdaptive_(queryConfig->hashAdaptivityEnabled()),
+      globalGroupingSets_(globalGroupingSets),
+      nonReclaimableSection_(nonReclaimableSection),
+      spillConfig_(spillConfig),
       queryConfig_(queryConfig),
       pool_(pool),
+      spillStats_(spillStats),
+      groupingKeyOutputProjections_(std::move(groupingKeyOutputProjections)),
+      hashers_(std::move(hashers)),
       aggregates_(std::move(aggregates)),
       masks_(extractMaskChannels(aggregates_)),
-      ignoreNullKeys_(ignoreNullKeys),
-      globalGroupingSets_(globalGroupingSets),
       groupIdChannel_(groupIdChannel),
-      spillConfig_(spillConfig),
-      nonReclaimableSection_(nonReclaimableSection),
       stringAllocator_(pool_),
-      rows_(pool_),
-      isAdaptive_(queryConfig_->hashAdaptivityEnabled()),
-      spillStats_(spillStats) {
+      rows_(pool_) {
   VELOX_CHECK_NOT_NULL(nonReclaimableSection_);
   VELOX_CHECK(pool_->trackUsage());
 
@@ -122,6 +123,10 @@ GroupingSet::GroupingSet(
     } else {
       distinctAggregations_.push_back(nullptr);
     }
+
+    if (aggregate.function->supportsCompact()) {
+      hasCompactableAggregates_ = true;
+    }
   }
 }
 
@@ -131,15 +136,16 @@ GroupingSet::~GroupingSet() {
   }
 }
 
-std::unique_ptr<GroupingSet> GroupingSet::createForMarkDistinct(
+std::unique_ptr<GroupingSet> GroupingSet::createForDistinct(
     const RowTypePtr& inputType,
     std::vector<std::unique_ptr<VectorHasher>>&& hashers,
+    std::vector<column_index_t>&& preGroupedKeys,
     OperatorCtx* operatorCtx,
     tsan_atomic<bool>* nonReclaimableSection) {
   return std::make_unique<GroupingSet>(
       inputType,
       std::move(hashers),
-      /*preGroupedKeys=*/std::vector<column_index_t>{},
+      std::move(preGroupedKeys),
       /*groupingKeyOutputProjections=*/std::vector<column_index_t>{},
       /*aggregates=*/std::vector<AggregateInfo>{},
       /*ignoreNullKeys=*/false,
@@ -172,6 +178,7 @@ bool equalKeys(
 } // namespace
 
 void GroupingSet::addInput(const RowVectorPtr& input, bool mayPushdown) {
+  drainedNewGroups_ = {};
   if (isGlobal_) {
     addGlobalAggregationInput(input, mayPushdown);
     return;
@@ -205,6 +212,7 @@ void GroupingSet::addInput(const RowVectorPtr& input, bool mayPushdown) {
 }
 
 void GroupingSet::noMoreInput() {
+  drainedNewGroups_ = {};
   noMoreInput_ = true;
 
   if (remainingInput_) {
@@ -230,6 +238,38 @@ bool GroupingSet::hasSpilled() const {
   return outputSpiller_ != nullptr;
 }
 
+uint64_t GroupingSet::compact() {
+  VELOX_CHECK(hasCompactableAggregates_);
+
+  uint64_t freedBytes = 0;
+
+  if (isGlobal_) {
+    if (globalAggregationInitialized_) {
+      VELOX_CHECK_NOT_NULL(lookup_);
+      VELOX_CHECK_EQ(lookup_->hits.size(), 1);
+      char* group = lookup_->hits[0];
+      for (auto& aggregate : aggregates_) {
+        freedBytes += aggregate.function->compact(folly::Range(&group, 1));
+      }
+    }
+  } else if (table_ != nullptr) {
+    auto* rows = table_->rows();
+    if (rows != nullptr && rows->numRows() > 0) {
+      RowContainerIterator iter;
+      std::vector<char*> groups(1'000);
+      while (const auto numRows = rows->listRows(
+                 &iter, static_cast<int32_t>(groups.size()), groups.data())) {
+        for (auto& aggregate : aggregates_) {
+          freedBytes +=
+              aggregate.function->compact(folly::Range(groups.data(), numRows));
+        }
+      }
+    }
+  }
+
+  return freedBytes;
+}
+
 bool GroupingSet::hasOutput() {
   return noMoreInput_ || remainingInput_;
 }
@@ -238,7 +278,7 @@ void GroupingSet::addInputForActiveRows(
     const RowVectorPtr& input,
     bool mayPushdown) {
   VELOX_CHECK(!isGlobal_);
-  if (!table_) {
+  if (table_ == nullptr) {
     createHashTable();
   }
   ensureInputFits(input);
@@ -320,6 +360,23 @@ void GroupingSet::addRemainingInput() {
   activeRows_.updateBounds();
 
   addInputForActiveRows(remainingInput_, remainingMayPushdown_);
+
+  if (isDistinct() && !preGroupedKeyChannels_.empty()) {
+    // Pre-grouped distinct aggregation does not currently spill
+    // (AggregationNode::canSpill returns false when preGroupedKeys is
+    // non-empty; see velox#3264). The captured row pointers below
+    // reference table_->rows() and would dangle after table_->clear() in
+    // any spill path. If spill becomes enabled here, restore a
+    // materialize-before-clear path or otherwise preserve these rows.
+    VELOX_CHECK(!hasSpilled());
+    const auto& newGroups = lookup_->newGroups;
+    drainedNewGroups_.clear();
+    drainedNewGroups_.reserve(newGroups.size());
+    for (auto idx : newGroups) {
+      drainedNewGroups_.push_back(lookup_->hits[idx]);
+    }
+  }
+
   remainingInput_.reset();
 }
 
@@ -605,7 +662,7 @@ bool GroupingSet::getGlobalAggregationOutput(
 
   initializeGlobalAggregation();
 
-  auto groups = lookup_->hits.data();
+  auto* groups = lookup_->hits.data();
   for (int32_t i = 0; i < aggregates_.size(); ++i) {
     if (!aggregates_[i].sortingKeys.empty()) {
       continue;
@@ -815,6 +872,30 @@ void GroupingSet::extractGroups(
   }
 }
 
+bool GroupingSet::hasDrainedNewGroups() const {
+  return !drainedNewGroups_.empty();
+}
+
+vector_size_t GroupingSet::drainedNewGroupsCount() const {
+  return static_cast<vector_size_t>(drainedNewGroups_.size());
+}
+
+void GroupingSet::extractDrainedNewGroups(const RowVectorPtr& result) {
+  VELOX_CHECK(isDistinct());
+  VELOX_DCHECK(!drainedNewGroups_.empty());
+  result->resize(drainedNewGroups_.size());
+  auto* rowContainer = table_->rows();
+  for (vector_size_t i = 0; i < result->childrenSize(); ++i) {
+    auto& keyVector = result->childAt(i);
+    rowContainer->extractColumn(
+        drainedNewGroups_.data(),
+        drainedNewGroups_.size(),
+        groupingKeyOutputProjections_[i],
+        keyVector);
+  }
+  drainedNewGroups_.clear();
+}
+
 void GroupingSet::resetTable(bool freeTable) {
   if (table_ != nullptr) {
     table_->clear(freeTable);
@@ -932,8 +1013,11 @@ void GroupingSet::ensureInputFits(const RowVectorPtr& input) {
   }
   LOG(WARNING) << "Failed to reserve " << succinctBytes(targetIncrementBytes)
                << " for memory pool " << pool_->name()
-               << ", usage: " << succinctBytes(pool_->usedBytes())
-               << ", reservation: " << succinctBytes(pool_->reservedBytes());
+               << ", root pool: " << pool_->root()->name()
+               << ", used: " << succinctBytes(pool_->usedBytes())
+               << ", reservation: " << succinctBytes(pool_->reservedBytes())
+               << ", root pool reservation: "
+               << succinctBytes(pool_->root()->reservedBytes());
 }
 
 void GroupingSet::ensureOutputFits() {
@@ -972,8 +1056,11 @@ void GroupingSet::ensureOutputFits() {
   LOG(WARNING) << "Failed to reserve "
                << succinctBytes(outputBufferSizeToReserve)
                << " for memory pool " << pool_->name()
-               << ", usage: " << succinctBytes(pool_->usedBytes())
-               << ", reservation: " << succinctBytes(pool_->reservedBytes());
+               << ", root pool: " << pool_->root()->name()
+               << ", used: " << succinctBytes(pool_->usedBytes())
+               << ", reservation: " << succinctBytes(pool_->reservedBytes())
+               << ", root pool reservation: "
+               << succinctBytes(pool_->root()->reservedBytes());
 }
 
 RowTypePtr GroupingSet::makeSpillType() const {
@@ -985,6 +1072,7 @@ RowTypePtr GroupingSet::makeSpillType() const {
   }
 
   std::vector<std::string> names;
+  names.reserve(types.size());
   for (auto i = 0; i < types.size(); ++i) {
     names.push_back(fmt::format("s{}", i));
   }
@@ -992,7 +1080,7 @@ RowTypePtr GroupingSet::makeSpillType() const {
   return ROW(std::move(names), std::move(types));
 }
 
-std::optional<common::SpillStats> GroupingSet::spilledStats() const {
+std::optional<exec::SpillStats> GroupingSet::spilledStats() const {
   if (!hasSpilled()) {
     return std::nullopt;
   }
@@ -1100,6 +1188,8 @@ bool GroupingSet::getOutputWithSpill(
           false,
           false,
           false,
+          false, // hasCountFlag
+          false,
           false,
           pool_);
 
@@ -1136,8 +1226,7 @@ bool GroupingSet::prepareNextSpillPartitionOutput() {
   auto it = spillPartitionSet_.begin();
   VELOX_CHECK_NE(outputSpillPartition_, it->first.partitionNumber());
   outputSpillPartition_ = it->first.partitionNumber();
-  merge_ = it->second->createOrderedReader(
-      spillConfig_->readBufferSize, pool_, spillStats_);
+  merge_ = it->second->createOrderedReader(*spillConfig_, pool_, spillStats_);
   spillPartitionSet_.erase(it);
   return true;
 }
@@ -1246,6 +1335,9 @@ void GroupingSet::prepareSpillResultWithoutAggregates(
     spillResultWithoutAggregates_->childAt(groupingKeyOutputProjections_[i]) =
         std::move(result->childAt(i));
   }
+
+  spillSources_.resize(maxOutputRows);
+  spillSourceRows_.resize(maxOutputRows);
 }
 
 void GroupingSet::projectResult(const RowVectorPtr& result) {
@@ -1266,6 +1358,7 @@ bool GroupingSet::mergeNextWithoutAggregates(
   VELOX_CHECK_EQ(
       numDistinctSpillFilesPerPartition_.size(),
       1 << spillConfig_->numPartitionBits);
+  VELOX_CHECK(pool_ == result->pool());
 
   // We are looping over sorted rows produced by tree-of-losers. We logically
   // split the stream into runs of duplicate rows. As we process each run we
@@ -1280,12 +1373,15 @@ bool GroupingSet::mergeNextWithoutAggregates(
   // less than 'numDistinctSpillFilesPerPartition_'.
   bool newDistinct{true};
   int32_t numOutputRows{0};
+  int32_t outputSize{0};
+  bool endOfBatch = false;
   prepareSpillResultWithoutAggregates(maxOutputRows, result);
 
-  while (numOutputRows < maxOutputRows) {
+  while (numOutputRows + outputSize < maxOutputRows) {
     const auto next = merge_->nextWithEquals();
     auto* stream = next.first;
     if (stream == nullptr) {
+      VELOX_CHECK_EQ(outputSize, 0);
       if (numOutputRows > 0) {
         break;
       }
@@ -1300,17 +1396,40 @@ bool GroupingSet::mergeNextWithoutAggregates(
         numDistinctSpillFilesPerPartition_[outputSpillPartition_]) {
       newDistinct = false;
     }
-    if (next.second) {
-      stream->pop();
-      continue;
-    }
-    if (newDistinct) {
+    auto index = stream->currentIndex(&endOfBatch);
+    if (!next.second && newDistinct) {
       // Yield result for new distinct.
-      spillResultWithoutAggregates_->copy(
-          &stream->current(), numOutputRows++, stream->currentIndex(), 1);
+      spillSources_[outputSize] = &stream->current();
+      spillSourceRows_[outputSize] = index;
+      ++outputSize;
+    }
+
+    if (FOLLY_UNLIKELY(endOfBatch)) {
+      // The stream is at end of input batch. Need to copy out the rows before
+      // fetching next batch in 'pop'.
+      gatherCopy(
+          spillResultWithoutAggregates_.get(),
+          numOutputRows,
+          outputSize,
+          spillSources_,
+          spillSourceRows_);
+      numOutputRows += outputSize;
+      outputSize = 0;
     }
     stream->pop();
-    newDistinct = true;
+    // Reset newDistinct flag for new row.
+    if (!next.second) {
+      newDistinct = true;
+    }
+  }
+  if (FOLLY_LIKELY(outputSize != 0)) {
+    gatherCopy(
+        spillResultWithoutAggregates_.get(),
+        numOutputRows,
+        outputSize,
+        spillSources_,
+        spillSourceRows_);
+    numOutputRows += outputSize;
   }
   spillResultWithoutAggregates_->resize(numOutputRows);
   projectResult(result);
@@ -1322,12 +1441,17 @@ void GroupingSet::initializeRow(SpillMergeStream& stream, char* row) {
     mergeRows_->store(stream.decoded(i), stream.currentIndex(), mergeState_, i);
   }
   vector_size_t zero = 0;
-  for (auto& aggregate : aggregates_) {
-    if (!aggregate.sortingKeys.empty()) {
+  for (auto i = 0; i < aggregates_.size(); ++i) {
+    if (!aggregates_[i].sortingKeys.empty()) {
       continue;
     }
-    aggregate.function->initializeNewGroups(
-        &row, folly::Range<const vector_size_t*>(&zero, 1));
+    if (!aggregates_[i].distinct) {
+      aggregates_[i].function->initializeNewGroups(
+          &row, folly::Range<const vector_size_t*>(&zero, 1));
+    } else {
+      distinctAggregations_[i]->initializeNewGroups(
+          &row, folly::Range<const vector_size_t*>(&zero, 1));
+    }
   }
 
   if (sortedAggregations_ != nullptr) {
@@ -1380,11 +1504,22 @@ void GroupingSet::updateRow(SpillMergeStream& input, char* row) {
   }
   mergeSelection_.setValid(input.currentIndex(), false);
 
+  auto sortOrDistinctAggIndex = aggregates_.size() + keyChannels_.size();
   if (sortedAggregations_ != nullptr) {
-    const auto& vector =
-        input.current().childAt(aggregates_.size() + keyChannels_.size());
+    const auto& vector = input.current().childAt(sortOrDistinctAggIndex);
     sortedAggregations_->addSingleGroupSpillInput(
         row, vector, input.currentIndex());
+    ++sortOrDistinctAggIndex;
+  }
+
+  for (const auto& distinctAgg : distinctAggregations_) {
+    if (distinctAgg != nullptr) {
+      distinctAgg->addSingleGroupSpillInput(
+          row,
+          input.current().childAt(sortOrDistinctAggIndex),
+          input.currentIndex());
+      ++sortOrDistinctAggIndex;
+    }
   }
 }
 
@@ -1406,6 +1541,8 @@ void GroupingSet::abandonPartialAggregation() {
       false,
       false,
       false,
+      false, // hasCountFlag
+      false,
       false,
       pool_);
   initializeAggregates(aggregates_, *intermediateRows_, true);
@@ -1502,8 +1639,9 @@ void GroupingSet::toIntermediate(
         &aggregateVector);
   }
   if (intermediateRows_) {
-    intermediateRows_->eraseRows(folly::Range<char**>(
-        intermediateGroups_.data(), intermediateGroups_.size()));
+    intermediateRows_->eraseRows(
+        folly::Range<char**>(
+            intermediateGroups_.data(), intermediateGroups_.size()));
   }
 
   // It's unnecessary to call function->clear() to reset the internal states of
@@ -1526,7 +1664,7 @@ AggregationInputSpiller::AggregationInputSpiller(
     const HashBitRange& hashBitRange,
     const std::vector<SpillSortKey>& sortingKeys,
     const common::SpillConfig* spillConfig,
-    folly::Synchronized<common::SpillStats>* spillStats)
+    exec::SpillStats* spillStats)
     : SpillerBase(
           container,
           std::move(rowType),
@@ -1542,7 +1680,7 @@ AggregationOutputSpiller::AggregationOutputSpiller(
     RowContainer* container,
     RowTypePtr rowType,
     const common::SpillConfig* spillConfig,
-    folly::Synchronized<common::SpillStats>* spillStats)
+    exec::SpillStats* spillStats)
     : SpillerBase(
           container,
           std::move(rowType),
diff --git a/velox/exec/GroupingSet.h b/velox/exec/GroupingSet.h
index 43ce19eed1c..3d70a841aa1 100644
--- a/velox/exec/GroupingSet.h
+++ b/velox/exec/GroupingSet.h
@@ -15,13 +15,14 @@
  */
 #pragma once
 
+#include "velox/common/base/TreeOfLosers.h"
+#include "velox/common/file/FileSystems.h"
 #include "velox/exec/AggregateInfo.h"
 #include "velox/exec/AggregationMasks.h"
 #include "velox/exec/DistinctAggregations.h"
 #include "velox/exec/HashTable.h"
 #include "velox/exec/SortedAggregations.h"
 #include "velox/exec/Spiller.h"
-#include "velox/exec/TreeOfLosers.h"
 #include "velox/exec/VectorHasher.h"
 
 namespace facebook::velox::exec {
@@ -45,14 +46,18 @@ class GroupingSet {
       tsan_atomic<bool>* nonReclaimableSection,
       const core::QueryConfig* queryConfig,
       memory::MemoryPool* pool,
-      folly::Synchronized<common::SpillStats>* spillStats);
+      exec::SpillStats* spillStats);
 
   ~GroupingSet();
 
-  /// Used by MarkDistinct operator to identify rows with unique values.
-  static std::unique_ptr<GroupingSet> createForMarkDistinct(
+  /// Used by MarkDistinct and EnforceDistinct operators to identify rows with
+  /// unique values for a set of keys.
+  /// @param preGroupedKeys Subset of grouping keys that input is already
+  /// clustered on.
+  static std::unique_ptr<GroupingSet> createForDistinct(
       const RowTypePtr& inputType,
       std::vector<std::unique_ptr<VectorHasher>>&& hashers,
+      std::vector<column_index_t>&& preGroupedKeys,
       OperatorCtx* operatorCtx,
       tsan_atomic<bool>* nonReclaimableSection);
 
@@ -109,6 +114,18 @@ class GroupingSet {
 
   const HashLookup& hashLookup() const;
 
+  /// Returns true if there are pending new-group rows from the most recent
+  /// tail auto-drain that have not yet been consumed.
+  bool hasDrainedNewGroups() const;
+
+  /// Returns the number of pending drained new-group rows.
+  vector_size_t drainedNewGroupsCount() const;
+
+  /// Extracts the pending drained new-group rows into 'result' by reading
+  /// directly from row-container pointers. Clears the pending state after
+  /// extraction.
+  void extractDrainedNewGroups(const RowVectorPtr& result);
+
   /// Spills all the rows in container.
   void spill();
 
@@ -118,11 +135,22 @@ class GroupingSet {
   void spill(const RowContainerIterator& rowIterator);
 
   /// Returns the spiller stats including total bytes and rows spilled so far.
-  std::optional<common::SpillStats> spilledStats() const;
+  std::optional<exec::SpillStats> spilledStats() const;
 
   /// Returns true if spilling has triggered on this grouping set.
   bool hasSpilled() const;
 
+  /// Performs lightweight memory compaction across all aggregates before
+  /// spilling. Iterates over all groups and calls Aggregate::compact() on each
+  /// aggregate function. Returns the total number of bytes freed.
+  uint64_t compact();
+
+  /// Returns true if any aggregate function supports lightweight memory
+  /// compaction.
+  bool hasCompactableAggregates() const {
+    return hasCompactableAggregates_;
+  }
+
   /// Returns the hashtable stats.
   HashTableStats hashTableStats() const {
     return table_ ? table_->stats() : HashTableStats{};
@@ -133,6 +161,12 @@ class GroupingSet {
     return table_ ? table_->rows()->numRows() : 0;
   }
 
+  /// Returns the underlying hash table, or nullptr if it has not been created
+  /// yet.
+  BaseHashTable* table() const {
+    return table_.get();
+  }
+
   /// Frees hash tables and other state when giving up partial aggregation as
   /// non-productive. Must be called before toIntermediate() is used.
   void abandonPartialAggregation();
@@ -289,43 +323,45 @@ class GroupingSet {
   // 'toIntermediate'.
   std::vector<Accumulator> accumulators(bool excludeToIntermediate);
 
-  std::vector<column_index_t> keyChannels_;
-
   // A subset of grouping keys on which the input is clustered.
   const std::vector<column_index_t> preGroupedKeyChannels_;
 
-  // Provides the column projections for extracting the grouping keys from
-  // 'table_' for output. The vector index is the output channel and the value
-  // is the corresponding column index stored in 'table_'.
-  std::vector<column_index_t> groupingKeyOutputProjections_;
-
-  std::vector<std::unique_ptr<VectorHasher>> hashers_;
   const bool isGlobal_;
   const bool isPartial_;
   const bool isRawInput_;
+  const bool ignoreNullKeys_;
+  const bool isAdaptive_;
+  // List of global grouping set numbers, if being used with a GROUPING SET.
+  const std::vector<vector_size_t> globalGroupingSets_;
+  // Indicates if this grouping set and the associated hash aggregation operator
+  // is under non-reclaimable execution section or not.
+  tsan_atomic<bool>* const nonReclaimableSection_;
+
+  const common::SpillConfig* const spillConfig_;
   const core::QueryConfig* const queryConfig_;
   memory::MemoryPool* const pool_;
+  exec::SpillStats* const spillStats_;
+
+  std::vector<column_index_t> keyChannels_;
+  // Provides the column projections for extracting the grouping keys from
+  // 'table_' for output. The vector index is the output channel and the value
+  // is the corresponding column index stored in 'table_'.
+  std::vector<column_index_t> groupingKeyOutputProjections_;
+  std::vector<std::unique_ptr<VectorHasher>> hashers_;
 
   std::vector<AggregateInfo> aggregates_;
   AggregationMasks masks_;
   std::unique_ptr<SortedAggregations> sortedAggregations_;
   std::vector<std::unique_ptr<DistinctAggregations>> distinctAggregations_;
 
-  const bool ignoreNullKeys_;
+  // Boolean indicating whether any aggregate supports compact().
+  bool hasCompactableAggregates_{false};
 
   uint64_t numInputRows_ = 0;
 
-  // List of global grouping set numbers, if being used with a GROUPING SET.
-  const std::vector<vector_size_t> globalGroupingSets_;
   // Column for groupId for a GROUPING SET.
   std::optional<column_index_t> groupIdChannel_;
 
-  const common::SpillConfig* const spillConfig_;
-
-  // Indicates if this grouping set and the associated hash aggregation operator
-  // is under non-reclaimable execution section or not.
-  tsan_atomic<bool>* const nonReclaimableSection_;
-
   // Boolean indicating whether accumulators for a global aggregation (i.e.
   // aggregation with no grouping keys) have been initialized.
   bool globalAggregationInitialized_{false};
@@ -342,7 +378,6 @@ class GroupingSet {
   // aggregation
   HashStringAllocator stringAllocator_;
   memory::AllocationPool rows_;
-  const bool isAdaptive_;
 
   bool noMoreInput_{false};
 
@@ -354,12 +389,23 @@ class GroupingSet {
   // First row in remainingInput_ that needs to be processed.
   vector_size_t firstRemainingRow_;
 
+  // Populated by addRemainingInput(); reset at top of addInput()/noMoreInput().
+  // Pointers reference table_->rows() and remain valid only while no spill
+  // path runs. Pre-grouped distinct aggregation does not currently spill, so
+  // the row container is not cleared between capture and consumption.
+  std::vector<char*> drainedNewGroups_;
+
   // In case of distinct aggregation without aggregates and the grouping key
   // reordered, the spilled data is first loaded into
   // 'spillResultWithoutAggregates_' and then reordered back and load to
   // result.
   RowVectorPtr spillResultWithoutAggregates_{nullptr};
 
+  // Records the source rows to copy to 'output_' in order.
+  std::vector<const RowVector*> spillSources_;
+
+  std::vector<vector_size_t> spillSourceRows_;
+
   // The value of mayPushdown flag specified in addInput() for the
   // 'remainingInput_'.
   bool remainingMayPushdown_;
@@ -408,8 +454,6 @@ class GroupingSet {
   // Temporary for case where an aggregate in toIntermediate() outputs post-init
   // state of aggregate for all rows.
   std::vector<char*> firstGroup_;
-
-  folly::Synchronized<common::SpillStats>* const spillStats_;
 };
 
 class AggregationInputSpiller : public SpillerBase {
@@ -422,7 +466,7 @@ class AggregationInputSpiller : public SpillerBase {
       const HashBitRange& hashBitRange,
       const std::vector<SpillSortKey>& sortingKeys,
       const common::SpillConfig* spillConfig,
-      folly::Synchronized<common::SpillStats>* spillStats);
+      exec::SpillStats* spillStats);
 
   void spill();
 
@@ -444,7 +488,7 @@ class AggregationOutputSpiller : public SpillerBase {
       RowContainer* container,
       RowTypePtr rowType,
       const common::SpillConfig* spillConfig,
-      folly::Synchronized<common::SpillStats>* spillStats);
+      exec::SpillStats* spillStats);
 
   void spill(const RowContainerIterator& startRowIter);
 
diff --git a/velox/exec/HashAggregation.cpp b/velox/exec/HashAggregation.cpp
index bcc3b4b97cb..ad81999bf5e 100644
--- a/velox/exec/HashAggregation.cpp
+++ b/velox/exec/HashAggregation.cpp
@@ -16,10 +16,14 @@
 #include "velox/exec/HashAggregation.h"
 
 #include <optional>
+#include "velox/common/testutil/TestValue.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/PrefixSort.h"
 #include "velox/exec/Task.h"
 #include "velox/expression/Expr.h"
 
+using facebook::velox::common::testutil::TestValue;
+
 namespace facebook::velox::exec {
 
 HashAggregation::HashAggregation(
@@ -32,15 +36,22 @@ HashAggregation::HashAggregation(
           operatorId,
           aggregationNode->id(),
           aggregationNode->step() == core::AggregationNode::Step::kPartial
-              ? "PartialAggregation"
-              : "Aggregation",
+              ? OperatorType::kPartialAggregation
+              : OperatorType::kAggregation,
           aggregationNode->canSpill(driverCtx->queryConfig())
-              ? driverCtx->makeSpillConfig(operatorId)
+              ? driverCtx->makeSpillConfig(
+                    operatorId,
+                    aggregationNode->step() ==
+                            core::AggregationNode::Step::kPartial
+                        ? OperatorType::kPartialAggregation
+                        : OperatorType::kAggregation)
               : std::nullopt),
       aggregationNode_(aggregationNode),
       isPartialOutput_(isPartialOutput(aggregationNode->step())),
       isGlobal_(aggregationNode->groupingKeys().empty()),
       isDistinct_(!isGlobal_ && aggregationNode->aggregates().empty()),
+      memoryCompactionEnabled_(
+          driverCtx->queryConfig().aggregationMemoryCompactionReclaimEnabled()),
       maxExtendedPartialAggregationMemoryUsage_(
           driverCtx->queryConfig().maxExtendedPartialAggregationMemoryUsage()),
       abandonPartialAggregationMinRows_(
@@ -116,6 +127,8 @@ void HashAggregation::initialize() {
       operatorCtx_->pool(),
       spillStats_.get());
 
+  hasCompactableAggregates_ = groupingSet_->hasCompactableAggregates();
+
   aggregationNode_.reset();
 }
 
@@ -220,8 +233,6 @@ void HashAggregation::updateRuntimeStats() {
   const auto& hashers = groupingSet_->hashLookup().hashers;
   uint64_t asRange{0};
   uint64_t asDistinct{0};
-  const auto hashTableStats = groupingSet_->hashTableStats();
-
   auto lockedStats = stats_.wlock();
   auto& runtimeStats = lockedStats->runtimeStats;
 
@@ -235,14 +246,9 @@ void HashAggregation::updateRuntimeStats() {
     }
   }
 
-  runtimeStats[BaseHashTable::kCapacity] =
-      RuntimeMetric(hashTableStats.capacity);
-  runtimeStats[BaseHashTable::kNumRehashes] =
-      RuntimeMetric(hashTableStats.numRehashes);
-  runtimeStats[BaseHashTable::kNumDistinct] =
-      RuntimeMetric(hashTableStats.numDistinct);
-  runtimeStats[BaseHashTable::kNumTombstones] =
-      RuntimeMetric(hashTableStats.numTombstones);
+  if (auto* table = groupingSet_->table()) {
+    table->addRuntimeStats(runtimeStats);
+  }
 }
 
 void HashAggregation::prepareOutput(vector_size_t size) {
@@ -266,10 +272,13 @@ void HashAggregation::resetPartialOutputIfNeed() {
   {
     auto lockedStats = stats_.wlock();
     lockedStats->addRuntimeStat(
-        "flushRowCount", RuntimeCounter(numOutputRows_));
-    lockedStats->addRuntimeStat("flushTimes", RuntimeCounter(1));
+        std::string(HashAggregation::kFlushRowCount),
+        RuntimeCounter(numOutputRows_));
+    lockedStats->addRuntimeStat(
+        std::string(HashAggregation::kFlushTimes), RuntimeCounter(1));
     lockedStats->addRuntimeStat(
-        "partialAggregationPct", RuntimeCounter(aggregationPct));
+        std::string(HashAggregation::kPartialAggregationPct),
+        RuntimeCounter(saturateCast(aggregationPct)));
   }
   groupingSet_->resetTable(/*freeTable=*/false);
   partialFull_ = false;
@@ -293,7 +302,6 @@ void HashAggregation::maybeIncreasePartialAggregationMemoryUsage(
            maxExtendedPartialAggregationMemoryUsage_)) {
     groupingSet_->abandonPartialAggregation();
     pool()->release();
-    addRuntimeStat("abandonedPartialAggregation", RuntimeCounter(1));
     abandonedPartialAggregation_ = true;
     return;
   }
@@ -332,6 +340,9 @@ RowVectorPtr HashAggregation::getOutput() {
     }
     prepareOutput(input_->size());
     groupingSet_->toIntermediate(input_, output_);
+    addRuntimeStat(
+        std::string(HashAggregation::kAbandonedPartialAggregationRows),
+        RuntimeCounter(input_->size()));
     numOutputRows_ += input_->size();
     input_ = nullptr;
     return output_;
@@ -343,7 +354,7 @@ RowVectorPtr HashAggregation::getOutput() {
   // - distinct aggregation has new keys;
   // - running in partial streaming mode and have some output ready.
   if (!noMoreInput_ && !partialFull_ && !newDistincts_ &&
-      !groupingSet_->hasOutput()) {
+      !groupingSet_->hasDrainedNewGroups() && !groupingSet_->hasOutput()) {
     input_ = nullptr;
     return nullptr;
   }
@@ -379,6 +390,15 @@ RowVectorPtr HashAggregation::getDistinctOutput() {
   VELOX_CHECK(isDistinct_);
   VELOX_CHECK(!finished_);
 
+  if (groupingSet_->hasDrainedNewGroups()) {
+    auto size = groupingSet_->drainedNewGroupsCount();
+    prepareOutput(size);
+    groupingSet_->extractDrainedNewGroups(output_);
+    numOutputRows_ += size;
+    resetPartialOutputIfNeed();
+    return output_;
+  }
+
   if (newDistincts_) {
     VELOX_CHECK_NOT_NULL(input_);
 
@@ -458,13 +478,37 @@ void HashAggregation::reclaim(
 
   updateEstimatedOutputRowSize();
 
+  // Try lightweight compaction first before spilling.
+  if (memoryCompactionEnabled_) {
+    uint64_t compactedBytes{0};
+    if (hasCompactableAggregates_) {
+      compactedBytes = groupingSet_->compact();
+    }
+    TestValue::adjust(
+        "facebook::velox::exec::HashAggregation::reclaim::compact",
+        &compactedBytes);
+    if (compactedBytes > 0) {
+      stats.reclaimedBytes += compactedBytes;
+      pool()->release();
+      if (compactedBytes >= targetBytes) {
+        return;
+      }
+    }
+  }
+
+  if (!canSpill()) {
+    return;
+  }
+
   if (noMoreInput_) {
     if (groupingSet_->hasSpilled()) {
       LOG(WARNING)
           << "Can't reclaim from aggregation operator which has spilled and is under output processing, pool "
-          << pool()->name()
-          << ", memory usage: " << succinctBytes(pool()->usedBytes())
-          << ", reservation: " << succinctBytes(pool()->reservedBytes());
+          << pool()->name() << ", root pool: " << pool()->root()->name()
+          << ", used: " << succinctBytes(pool()->usedBytes())
+          << ", reservation: " << succinctBytes(pool()->reservedBytes())
+          << ", root pool reservation: "
+          << succinctBytes(pool()->root()->reservedBytes());
       return;
     }
     if (isDistinct_) {
diff --git a/velox/exec/HashAggregation.h b/velox/exec/HashAggregation.h
index 5cd44f77cb4..800c90d8539 100644
--- a/velox/exec/HashAggregation.h
+++ b/velox/exec/HashAggregation.h
@@ -15,6 +15,8 @@
  */
 #pragma once
 
+#include <string_view>
+
 #include "velox/exec/GroupingSet.h"
 #include "velox/exec/Operator.h"
 
@@ -22,6 +24,18 @@ namespace facebook::velox::exec {
 
 class HashAggregation : public Operator {
  public:
+  /// Runtime stat keys for hash aggregation.
+  /// Number of rows flushed in partial aggregation output.
+  static constexpr std::string_view kFlushRowCount = "flushRowCount";
+  /// Number of partial aggregation flush operations.
+  static constexpr std::string_view kFlushTimes = "flushTimes";
+  /// Ratio of output to input rows in partial aggregation as a percentage.
+  static constexpr std::string_view kPartialAggregationPct =
+      "partialAggregationPct";
+  /// Number of rows emitted after partial aggregation was abandoned.
+  static constexpr std::string_view kAbandonedPartialAggregationRows =
+      "abandonedPartialAggregationRows";
+
   HashAggregation(
       int32_t operatorId,
       DriverCtx* driverCtx,
@@ -45,6 +59,13 @@ class HashAggregation : public Operator {
 
   bool isFinished() override;
 
+  /// HashAggregation can reclaim memory via lightweight compaction even when
+  /// spilling is not enabled.
+  bool canReclaim() const override {
+    return (memoryCompactionEnabled_ && hasCompactableAggregates_) ||
+        canSpill();
+  }
+
   void reclaim(uint64_t targetBytes, memory::MemoryReclaimer::Stats& stats)
       override;
 
@@ -89,6 +110,7 @@ class HashAggregation : public Operator {
   const bool isPartialOutput_;
   const bool isGlobal_;
   const bool isDistinct_;
+  const bool memoryCompactionEnabled_;
   const int64_t maxExtendedPartialAggregationMemoryUsage_;
   // Minimum number of rows to see before deciding to give up on partial
   // aggregation.
@@ -100,6 +122,11 @@ class HashAggregation : public Operator {
   int64_t maxPartialAggregationMemoryUsage_;
   std::unique_ptr<GroupingSet> groupingSet_;
 
+  // Cached from groupingSet_->hasCompactableAggregates() during initialize().
+  // Stored separately to allow safe access from the arbitration thread without
+  // dereferencing groupingSet_.
+  bool hasCompactableAggregates_{false};
+
   // Size of a single output row estimated using
   // 'groupingSet_->estimateRowSize()'. If spilling, this value is set to max
   // 'groupingSet_->estimateRowSize()' across all accumulated data set.
diff --git a/velox/exec/HashBuild.cpp b/velox/exec/HashBuild.cpp
index 3dde65a5750..7760a1f5d83 100644
--- a/velox/exec/HashBuild.cpp
+++ b/velox/exec/HashBuild.cpp
@@ -18,6 +18,8 @@
 #include "velox/common/base/Counters.h"
 #include "velox/common/base/StatsReporter.h"
 #include "velox/common/testutil/TestValue.h"
+#include "velox/exec/HashTableCache.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/Task.h"
 #include "velox/exec/VectorHasher.h"
@@ -55,14 +57,22 @@ HashBuild::HashBuild(
           nullptr,
           operatorId,
           joinNode->id(),
-          "HashBuild",
+          OperatorType::kHashBuild,
           joinNode->canSpill(driverCtx->queryConfig())
-              ? driverCtx->makeSpillConfig(operatorId)
+              ? driverCtx->makeSpillConfig(operatorId, OperatorType::kHashBuild)
               : std::nullopt),
       joinNode_(std::move(joinNode)),
       joinType_{joinNode_->joinType()},
       nullAware_{joinNode_->isNullAware()},
+      nullAsValue_{joinNode_->isNullAsValue()},
       needProbedFlagSpill_{needRightSideJoin(joinType_)},
+      dropDuplicates_(joinNode_->canDropDuplicates()),
+      vectorHasherMaxNumDistinct_(
+          driverCtx->queryConfig().joinBuildVectorHasherMaxNumDistinct()),
+      abandonHashBuildDedupMinRows_(
+          driverCtx->queryConfig().abandonHashBuildDedupMinRows()),
+      abandonHashBuildDedupMinPct_(
+          driverCtx->queryConfig().abandonHashBuildDedupMinPct()),
       joinBridge_(operatorCtx_->task()->getHashJoinBridgeLocked(
           operatorCtx_->driverCtx()->splitGroupId,
           planNodeId())),
@@ -86,36 +96,136 @@ HashBuild::HashBuild(
 
   // Identify the non-key build side columns and make a decoder for each.
   const int32_t numDependents = inputType->size() - numKeys;
-  if (numDependents > 0) {
-    // Number of join keys (numKeys) may be less then number of input columns
-    // (inputType->size()). In this case numDependents is negative and cannot be
-    // used to call 'reserve'. This happens when we join different probe side
-    // keys with the same build side key: SELECT * FROM t LEFT JOIN u ON t.k1 =
-    // u.k AND t.k2 = u.k.
-    dependentChannels_.reserve(numDependents);
-    decoders_.reserve(numDependents);
-  }
-  for (auto i = 0; i < inputType->size(); ++i) {
-    if (keyChannelMap_.find(i) == keyChannelMap_.end()) {
-      dependentChannels_.emplace_back(i);
-      decoders_.emplace_back(std::make_unique<DecodedVector>());
+  if (!dropDuplicates_) {
+    if (numDependents > 0) {
+      // Number of join keys (numKeys) may be less then number of input columns
+      // (inputType->size()). In this case numDependents is negative and cannot
+      // be used to call 'reserve'. This happens when we join different probe
+      // side keys with the same build side key: SELECT * FROM t LEFT JOIN u ON
+      // t.k1 = u.k AND t.k2 = u.k.
+      dependentChannels_.reserve(numDependents);
+      decoders_.reserve(numDependents);
+    }
+
+    for (auto i = 0; i < inputType->size(); ++i) {
+      if (keyChannelMap_.find(i) == keyChannelMap_.end()) {
+        dependentChannels_.emplace_back(i);
+        decoders_.emplace_back(std::make_unique<DecodedVector>());
+      }
     }
   }
 
   tableType_ = hashJoinTableType(joinNode_);
-  setupTable();
-  setupSpiller();
+
   stateCleared_ = false;
 }
 
 void HashBuild::initialize() {
   Operator::initialize();
 
+  if (setupCachedHashTable()) {
+    return;
+  }
+
+  // Set up table and spiller now that cache state is initialized.
+  // This ensures tableMemoryPool() returns the cache's tablePool when enabled.
+  setupTable();
+  setupSpiller();
+
   if (isAntiJoin(joinType_) && joinNode_->filter()) {
     setupFilterForAntiJoins(keyChannelMap_);
   }
 }
 
+bool HashBuild::setupCachedHashTable() {
+  if (!joinNode_->useHashTableCache()) {
+    return false;
+  }
+
+  const auto& queryId = operatorCtx_->task()->queryCtx()->queryId();
+  cacheKey_ = fmt::format("{}:{}", queryId, planNodeId());
+
+  // Get or create the cache entry (which includes the pool).
+  // If another task is already building, future_ will be set.
+  auto* cache = HashTableCache::instance();
+  auto* queryCtx = operatorCtx_->task()->queryCtx().get();
+  cacheEntry_ = cache->get(cacheKey_, taskId(), queryCtx, &future_);
+  VELOX_CHECK_NOT_NULL(cacheEntry_);
+  VELOX_CHECK_NOT_NULL(cacheEntry_->tablePool);
+
+  // Check if table is already built.
+  if (cacheEntry_->buildComplete) {
+    noMoreInput();
+    return true;
+  }
+
+  // Check if we're a waiter task (future was set by get).
+  if (future_.valid()) {
+    setState(State::kWaitForBuild);
+    return true;
+  }
+
+  // This is the builder task - proceed with building.
+  return false;
+}
+
+bool HashBuild::getHashTableFromCache() {
+  if (!useHashTableCache()) {
+    return false;
+  }
+
+  if (!cacheEntry_->buildComplete) {
+    // Cache miss - we need to build the table.
+    stats_.wlock()->addRuntimeStat(
+        std::string(BaseHashTable::kHashTableCacheMiss), RuntimeCounter(1));
+    return false;
+  }
+
+  // Table already built by a previous task! Use it directly.
+  // Notify the bridge with the cached table.
+  // We pass a shared_ptr copy (not std::move) since the cache retains
+  // ownership.
+  joinBridge_->setHashTable(
+      cacheEntry_->table, {}, cacheEntry_->hasNullKeys, nullptr);
+  // Record cache hit metric.
+  stats_.wlock()->addRuntimeStat(
+      std::string(BaseHashTable::kHashTableCacheHit), RuntimeCounter(1));
+  return true;
+}
+
+void HashBuild::maybeSetHashTableInCache(
+    const std::shared_ptr<BaseHashTable>& table) {
+  if (!useHashTableCache()) {
+    return;
+  }
+  auto* cache = HashTableCache::instance();
+  cache->put(cacheKey(), table, joinHasNullKeys_);
+}
+
+bool HashBuild::receivedCachedHashTable() {
+  if (!useHashTableCache() || future_.valid()) {
+    return false;
+  }
+  // Builder task drivers coordinate via allPeersFinished and should fall
+  // through to the kWaitForProbe path in isBlocked(). Only waiter task
+  // drivers (different taskId than the builder) should enter here.
+  VELOX_CHECK_NOT_NULL(cacheEntry_);
+  if (hashTableCacheBuilderTask()) {
+    return false;
+  }
+  // We were waiting on cached table from another task.
+  // Ensure that table is ready.
+  VELOX_CHECK(
+      cacheEntry_->buildComplete,
+      "Hash table cache build failed for key '{}'. "
+      "The builder task may have encountered an error (e.g., OOM).",
+      cacheKey_);
+  // Proceed through normal noMoreInput flow which will use the cache.
+  setRunning();
+  noMoreInput();
+  return true;
+}
+
 void HashBuild::setupTable() {
   VELOX_CHECK_NULL(table_);
 
@@ -133,6 +243,7 @@ void HashBuild::setupTable() {
   for (int i = numKeys; i < tableType_->size(); ++i) {
     dependentTypes.emplace_back(tableType_->childAt(i));
   }
+  auto& queryConfig = operatorCtx_->driverCtx()->queryConfig();
   if (joinNode_->isRightJoin() || joinNode_->isFullJoin() ||
       joinNode_->isRightSemiProjectJoin()) {
     // Do not ignore null keys.
@@ -141,44 +252,47 @@ void HashBuild::setupTable() {
         dependentTypes,
         true, // allowDuplicates
         true, // hasProbedFlag
-        operatorCtx_->driverCtx()
-            ->queryConfig()
-            .minTableRowsForParallelJoinBuild(),
-        pool());
+        false, // hasCountFlag
+        queryConfig.minTableRowsForParallelJoinBuild(),
+        tableMemoryPool());
   } else {
-    // (Left) semi and anti join with no extra filter only needs to know whether
-    // there is a match. Hence, no need to store entries with duplicate keys.
-    const bool dropDuplicates = !joinNode_->filter() &&
-        (joinNode_->isLeftSemiFilterJoin() ||
-         joinNode_->isLeftSemiProjectJoin() || isAntiJoin(joinType_));
     // Right semi join needs to tag build rows that were probed.
     const bool needProbedFlag = joinNode_->isRightSemiFilterJoin();
-    if (isLeftNullAwareJoinWithFilter(joinNode_)) {
+    const bool hasCountFlag = joinNode_->isCountingJoin();
+    if (nullAsValue_ || isLeftNullAwareJoinWithFilter(joinNode_)) {
       // We need to check null key rows in build side in case of null-aware anti
       // or left semi project join with filter set.
       table_ = HashTable<false>::createForJoin(
           std::move(keyHashers),
           dependentTypes,
-          !dropDuplicates, // allowDuplicates
+          !dropDuplicates_, // allowDuplicates
           needProbedFlag, // hasProbedFlag
-          operatorCtx_->driverCtx()
-              ->queryConfig()
-              .minTableRowsForParallelJoinBuild(),
-          pool());
+          hasCountFlag,
+          queryConfig.minTableRowsForParallelJoinBuild(),
+          tableMemoryPool());
     } else {
       // Ignore null keys
       table_ = HashTable<true>::createForJoin(
           std::move(keyHashers),
           dependentTypes,
-          !dropDuplicates, // allowDuplicates
+          !dropDuplicates_, // allowDuplicates
           needProbedFlag, // hasProbedFlag
-          operatorCtx_->driverCtx()
-              ->queryConfig()
-              .minTableRowsForParallelJoinBuild(),
-          pool());
+          hasCountFlag,
+          queryConfig.minTableRowsForParallelJoinBuild(),
+          tableMemoryPool(),
+          queryConfig.hashProbeBloomFilterPushdownMaxSize());
     }
   }
   analyzeKeys_ = table_->hashMode() != BaseHashTable::HashMode::kHash;
+  if (abandonHashBuildDedupMinPct_ == 0 && !joinNode_->isCountingJoin()) {
+    // Building a HashTable without duplicates is disabled if
+    // abandonBuildNoDupHashMinPct_ is 0. Counting joins always require dedup.
+    abandonHashBuildDedup_ = true;
+    table_->setAllowDuplicates(true);
+    return;
+  }
+  // Only create HashLookup when dedup is enabled.
+  lookup_ = std::make_unique<HashLookup>(table_->hashers(), pool());
 }
 
 void HashBuild::setupSpiller(SpillPartition* spillPartition) {
@@ -214,12 +328,19 @@ void HashBuild::setupSpiller(SpillPartition* spillPartition) {
         numPartitionBits;
     // Disable spilling if exceeding the max spill level and the query might run
     // out of memory if the restored partition still can't fit in memory.
-    if (config->exceedSpillLevelLimit(startPartitionBit)) {
+    if (FOLLY_UNLIKELY(config->exceedSpillLevelLimit(startPartitionBit))) {
       RECORD_METRIC_VALUE(kMetricMaxSpillLevelExceededCount);
       LOG(WARNING) << "Exceeded spill level limit: " << config->maxSpillLevel
                    << ", and disable spilling for memory pool: "
-                   << pool()->name();
-      ++spillStats_->wlock()->spillMaxLevelExceededCount;
+                   << pool()->name()
+                   << ", root pool: " << pool()->root()->name()
+                   << ", used: " << succinctBytes(pool()->usedBytes())
+                   << ", reservation: "
+                   << succinctBytes(pool()->reservedBytes())
+                   << ", root pool reservation: "
+                   << succinctBytes(pool()->root()->reservedBytes());
+      spillStats_->spillMaxLevelExceededCount.fetch_add(
+          1, std::memory_order_relaxed);
       exceededMaxSpillLevelLimit_ = true;
       return;
     }
@@ -309,6 +430,11 @@ void HashBuild::removeInputRowsForAntiJoinFilter() {
 
 void HashBuild::addInput(RowVectorPtr input) {
   checkRunning();
+
+  VELOX_CHECK(
+      !useHashTableCache() ||
+      (cacheEntry_->builderTaskId == taskId() && !cacheEntry_->buildComplete));
+
   ensureInputFits(input);
 
   TestValue::adjust("facebook::velox::exec::HashBuild::addInput", this);
@@ -336,7 +462,7 @@ void HashBuild::addInput(RowVectorPtr input) {
   }
 
   if (!isRightJoin(joinType_) && !isFullJoin(joinType_) &&
-      !isRightSemiProjectJoin(joinType_) &&
+      !isRightSemiProjectJoin(joinType_) && !nullAsValue_ &&
       !isLeftNullAwareJoinWithFilter(joinNode_)) {
     deselectRowsWithNulls(hashers, activeRows_);
     if (nullAware_ && !joinHasNullKeys_ &&
@@ -377,6 +503,41 @@ void HashBuild::addInput(RowVectorPtr input) {
     return;
   }
 
+  if (dropDuplicates_ && !abandonHashBuildDedup_) {
+    // Counting joins must not abandon dedup — accurate counts are required.
+    const bool abandonEarly = !joinNode_->isCountingJoin() &&
+        abandonHashBuildDedupEarly(table_->numDistinct());
+    if (!abandonEarly) {
+      numHashInputRows_ += activeRows_.countSelected();
+      table_->prepareForGroupProbe(
+          *lookup_,
+          input,
+          activeRows_,
+          BaseHashTable::kNoSpillInputStartPartitionBit);
+      if (lookup_->rows.empty()) {
+        return;
+      }
+      table_->groupProbe(
+          *lookup_, BaseHashTable::kNoSpillInputStartPartitionBit);
+
+      // For counting joins, increment the count for duplicate rows.
+      // New rows are initialized with count = 1 by initializeRow.
+      // Increment count for all rows, then decrement for new rows to
+      // correct the over-counting.
+      if (joinNode_->isCountingJoin()) {
+        auto* rows = table_->rows();
+        for (auto row : lookup_->rows) {
+          rows->incrementCount(lookup_->hits[row]);
+        }
+        for (auto newRow : lookup_->newGroups) {
+          rows->decrementCount(lookup_->hits[newRow]);
+        }
+      }
+      return;
+    }
+    abandonHashBuildDedup();
+  }
+
   if (analyzeKeys_ && hashes_.size() < activeRows_.end()) {
     hashes_.resize(activeRows_.end());
   }
@@ -506,8 +667,11 @@ void HashBuild::ensureInputFits(RowVectorPtr& input) {
   }
   LOG(WARNING) << "Failed to reserve " << succinctBytes(targetIncrementBytes)
                << " for memory pool " << pool()->name()
-               << ", usage: " << succinctBytes(pool()->usedBytes())
-               << ", reservation: " << succinctBytes(pool()->reservedBytes());
+               << ", root pool: " << pool()->root()->name()
+               << ", used: " << succinctBytes(pool()->usedBytes())
+               << ", reservation: " << succinctBytes(pool()->reservedBytes())
+               << ", root pool reservation: "
+               << succinctBytes(pool()->root()->reservedBytes());
 }
 
 void HashBuild::spillInput(const RowVectorPtr& input) {
@@ -627,6 +791,7 @@ void HashBuild::noMoreInput() {
   if (noMoreInput_) {
     return;
   }
+
   Operator::noMoreInput();
 
   noMoreInputInternal();
@@ -656,7 +821,19 @@ bool HashBuild::finishHashBuild() {
   // build pipeline.
   if (!operatorCtx_->task()->allPeersFinished(
           planNodeId(), operatorCtx_->driver(), &future_, promises, peers)) {
-    setState(State::kWaitForBuild);
+    if (useHashTableCache() && !hashTableCacheBuilderTask()) {
+      // Waiter task non-last driver: no partial table was built (we used the
+      // cached table). Nothing to contribute — finish immediately. Clear the
+      // future since allPeersFinished() set it but we don't need to wait.
+      VELOX_CHECK_NULL(
+          table_, "Waiter task should not have built a partial hash table");
+      future_ = folly::SemiFuture<folly::Unit>::makeEmpty();
+      setState(State::kFinish);
+    } else {
+      // Builder task non-last driver: the last driver needs our partial
+      // table. Wait in kWaitForBuild until it has moved our table out.
+      setState(State::kWaitForBuild);
+    }
     return false;
   }
 
@@ -671,6 +848,10 @@ bool HashBuild::finishHashBuild() {
     }
   };
 
+  if (getHashTableFromCache()) {
+    return true;
+  }
+
   if (joinHasNullKeys_ && isAntiJoin(joinType_) && nullAware_ &&
       !joinNode_->filter()) {
     joinBridge_->setAntiJoinHasNullKeys();
@@ -746,8 +927,6 @@ bool HashBuild::finishHashBuild() {
     pool()->release();
   };
 
-  // TODO: Re-enable parallel join build with spilling triggered after
-  //  https://github.com/facebookincubator/velox/issues/3567 is fixed.
   CpuWallTiming timing;
   {
     CpuWallTimer cpuWallTimer{timing};
@@ -755,11 +934,13 @@ bool HashBuild::finishHashBuild() {
         std::move(otherTables),
         isInputFromSpill() ? spillConfig()->startPartitionBit
                            : BaseHashTable::kNoSpillInputStartPartitionBit,
+        vectorHasherMaxNumDistinct_,
+        dropDuplicates_,
         allowParallelJoinBuild ? operatorCtx_->task()->queryCtx()->executor()
                                : nullptr);
   }
   stats_.wlock()->addRuntimeStat(
-      BaseHashTable::kBuildWallNanos,
+      std::string(BaseHashTable::kBuildWallNanos),
       RuntimeCounter(timing.wallNanos, RuntimeCounter::Unit::kNanos));
 
   addRuntimeStats();
@@ -784,11 +965,16 @@ bool HashBuild::finishHashBuild() {
               spillStats);
         };
   }
+
+  // For hash table caching: the last driver caches the merged table.
+  std::shared_ptr<BaseHashTable> table = std::move(table_);
+  maybeSetHashTableInCache(table);
   joinBridge_->setHashTable(
-      std::move(table_),
+      table,
       std::move(spillPartitions),
       joinHasNullKeys_,
       std::move(tableSpillFunc));
+
   if (canSpill()) {
     stateCleared_ = true;
   }
@@ -833,14 +1019,15 @@ void HashBuild::ensureTableFits(uint64_t numRows) {
 
   LOG(WARNING) << "Failed to reserve " << succinctBytes(memoryBytesToReserve)
                << " for join table build from last hash build operator "
-               << pool()->name()
-               << ", usage: " << succinctBytes(pool()->usedBytes())
-               << ", reservation: " << succinctBytes(pool()->reservedBytes());
+               << pool()->name() << ", root pool: " << pool()->root()->name()
+               << ", used: " << succinctBytes(pool()->usedBytes())
+               << ", reservation: " << succinctBytes(pool()->reservedBytes())
+               << ", root pool reservation: "
+               << succinctBytes(pool()->root()->reservedBytes());
 }
 
 void HashBuild::postHashBuildProcess() {
   checkRunning();
-
   if (!canSpill()) {
     setState(State::kFinish);
     return;
@@ -879,6 +1066,7 @@ void HashBuild::setupSpillInput(HashJoinBridge::SpillInput spillInput) {
   setupTable();
   setupSpiller(spillInput.spillPartition.get());
   stateCleared_ = false;
+  numHashInputRows_ = 0;
 
   // Start to process spill input.
   processSpillInput();
@@ -904,7 +1092,6 @@ void HashBuild::processSpillInput() {
 void HashBuild::addRuntimeStats() {
   // Report range sizes and number of distinct values for the join keys.
   const auto& hashers = table_->hashers();
-  const auto hashTableStats = table_->stats();
   uint64_t asRange{0};
   uint64_t asDistinct{0};
   auto lockedStats = stats_.wlock();
@@ -912,23 +1099,54 @@ void HashBuild::addRuntimeStats() {
   for (const auto& timing : table_->parallelJoinBuildStats().partitionTimings) {
     lockedStats->getOutputTiming.add(timing);
     lockedStats->addRuntimeStat(
-        BaseHashTable::kParallelJoinPartitionWallNanos,
+        std::string(BaseHashTable::kParallelJoinPartitionWallNanos),
         RuntimeCounter(timing.wallNanos, RuntimeCounter::Unit::kNanos));
     lockedStats->addRuntimeStat(
-        BaseHashTable::kParallelJoinPartitionCpuNanos,
+        std::string(BaseHashTable::kParallelJoinPartitionCpuNanos),
         RuntimeCounter(timing.cpuNanos, RuntimeCounter::Unit::kNanos));
   }
 
   for (const auto& timing : table_->parallelJoinBuildStats().buildTimings) {
     lockedStats->getOutputTiming.add(timing);
     lockedStats->addRuntimeStat(
-        BaseHashTable::kParallelJoinBuildWallNanos,
+        std::string(BaseHashTable::kParallelJoinBuildWallNanos),
         RuntimeCounter(timing.wallNanos, RuntimeCounter::Unit::kNanos));
     lockedStats->addRuntimeStat(
-        BaseHashTable::kParallelJoinBuildCpuNanos,
+        std::string(BaseHashTable::kParallelJoinBuildCpuNanos),
         RuntimeCounter(timing.cpuNanos, RuntimeCounter::Unit::kNanos));
   }
 
+  for (const auto& timing :
+       table_->parallelJoinBuildStats().bloomFilterPartitionTimings) {
+    lockedStats->getOutputTiming.add(timing);
+    if (timing.wallNanos > 0) {
+      lockedStats->addRuntimeStat(
+          std::string(
+              BaseHashTable::kParallelJoinBloomFilterPartitionWallNanos),
+          RuntimeCounter(timing.wallNanos, RuntimeCounter::Unit::kNanos));
+    }
+    if (timing.cpuNanos > 0) {
+      lockedStats->addRuntimeStat(
+          std::string(BaseHashTable::kParallelJoinBloomFilterPartitionCpuNanos),
+          RuntimeCounter(timing.cpuNanos, RuntimeCounter::Unit::kNanos));
+    }
+  }
+
+  for (const auto& timing :
+       table_->parallelJoinBuildStats().bloomFilterBuildTimings) {
+    lockedStats->getOutputTiming.add(timing);
+    if (timing.wallNanos > 0) {
+      lockedStats->addRuntimeStat(
+          std::string(BaseHashTable::kParallelJoinBloomFilterBuildWallNanos),
+          RuntimeCounter(timing.wallNanos, RuntimeCounter::Unit::kNanos));
+    }
+    if (timing.cpuNanos > 0) {
+      lockedStats->addRuntimeStat(
+          std::string(BaseHashTable::kParallelJoinBloomFilterBuildCpuNanos),
+          RuntimeCounter(timing.cpuNanos, RuntimeCounter::Unit::kNanos));
+    }
+  }
+
   for (auto i = 0; i < hashers.size(); i++) {
     hashers[i]->cardinality(0, asRange, asDistinct);
     if (asRange != VectorHasher::kRangeTooLarge) {
@@ -941,24 +1159,21 @@ void HashBuild::addRuntimeStats() {
     }
   }
 
-  lockedStats->runtimeStats[BaseHashTable::kCapacity] =
-      RuntimeMetric(hashTableStats.capacity);
-  lockedStats->runtimeStats[BaseHashTable::kNumRehashes] =
-      RuntimeMetric(hashTableStats.numRehashes);
-  lockedStats->runtimeStats[BaseHashTable::kNumDistinct] =
-      RuntimeMetric(hashTableStats.numDistinct);
-  if (hashTableStats.numTombstones != 0) {
-    lockedStats->runtimeStats[BaseHashTable::kNumTombstones] =
-        RuntimeMetric(hashTableStats.numTombstones);
-  }
+  table_->addRuntimeStats(lockedStats->runtimeStats);
 
   // Add max spilling level stats if spilling has been triggered.
   if (spiller_ != nullptr && spiller_->spillTriggered()) {
     lockedStats->addRuntimeStat(
-        "maxSpillLevel",
+        std::string(HashBuild::kMaxSpillLevel),
         RuntimeCounter(
             spillConfig()->spillLevel(spiller_->hashBits().begin())));
   }
+
+  lockedStats->addRuntimeStat(
+      std::string(BaseHashTable::kVectorHasherMergeCpuNanos),
+      RuntimeCounter(
+          table_->vectorHasherMergeTiming().cpuNanos,
+          RuntimeCounter::Unit::kNanos));
 }
 
 BlockingReason HashBuild::isBlocked(ContinueFuture* future) {
@@ -976,6 +1191,11 @@ BlockingReason HashBuild::isBlocked(ContinueFuture* future) {
     case State::kFinish:
       break;
     case State::kWaitForBuild:
+      if (receivedCachedHashTable()) {
+        break;
+      }
+      // We were waiting for peer drivers to finish - fall through to
+      // kWaitForProbe which has the same logic.
       [[fallthrough]];
     case State::kWaitForProbe:
       if (!future_.valid()) {
@@ -1059,6 +1279,14 @@ bool HashBuild::canSpill() const {
   if (!Operator::canSpill()) {
     return false;
   }
+  // For Cached hash table, we don't support spill either by the
+  // task thats building or by the task that is re-using it
+  if (useHashTableCache()) {
+    return false;
+  }
+  if (joinNode_->isCountingJoin()) {
+    return false;
+  }
   if (operatorCtx_->task()->hasMixedExecutionGroupJoin(joinNode_.get())) {
     return operatorCtx_->driverCtx()
                ->queryConfig()
@@ -1091,8 +1319,12 @@ void HashBuild::reclaim(
     LOG(WARNING)
         << "Can't reclaim from hash build operator, exceeded maximum spill "
            "level of "
-        << config->maxSpillLevel << ", " << pool()->name() << ", usage "
-        << succinctBytes(pool()->usedBytes());
+        << config->maxSpillLevel << ", " << pool()->name()
+        << ", root pool: " << pool()->root()->name()
+        << ", used: " << succinctBytes(pool()->usedBytes())
+        << ", reservation: " << succinctBytes(pool()->reservedBytes())
+        << ", root pool reservation: "
+        << succinctBytes(pool()->root()->reservedBytes());
     return;
   }
 
@@ -1105,11 +1337,16 @@ void HashBuild::reclaim(
     LOG(WARNING) << "Can't reclaim from hash build operator, state_["
                  << stateName(state_) << "], nonReclaimableSection_["
                  << nonReclaimableSection_ << "], spiller_["
-                 << (stateCleared_ ? "cleared"
-                                   : (spiller_->finalized() ? "finalized"
-                                                            : "non-finalized"))
+                 << (stateCleared_               ? "cleared"
+                         : spiller_ == nullptr   ? "null"
+                         : spiller_->finalized() ? "finalized"
+                                                 : "non-finalized")
                  << "] " << pool()->name()
-                 << ", usage: " << succinctBytes(pool()->usedBytes());
+                 << ", root pool: " << pool()->root()->name()
+                 << ", used: " << succinctBytes(pool()->usedBytes())
+                 << ", reservation: " << succinctBytes(pool()->reservedBytes())
+                 << ", root pool reservation: "
+                 << succinctBytes(pool()->root()->reservedBytes());
     return;
   }
 
@@ -1128,9 +1365,18 @@ void HashBuild::reclaim(
       ++stats.numNonReclaimableAttempts;
       LOG(WARNING) << "Can't reclaim from hash build operator, state_["
                    << stateName(buildOp->state_) << "], nonReclaimableSection_["
-                   << buildOp->nonReclaimableSection_ << "], "
-                   << buildOp->pool()->name() << ", usage: "
-                   << succinctBytes(buildOp->pool()->usedBytes());
+                   << buildOp->nonReclaimableSection_ << "], spiller_["
+                   << (buildOp->stateCleared_               ? "cleared"
+                           : buildOp->spiller_ == nullptr   ? "null"
+                           : buildOp->spiller_->finalized() ? "finalized"
+                                                            : "non-finalized")
+                   << "], " << buildOp->pool()->name()
+                   << ", root pool: " << buildOp->pool()->root()->name()
+                   << ", used: " << succinctBytes(buildOp->pool()->usedBytes())
+                   << ", reservation: "
+                   << succinctBytes(buildOp->pool()->reservedBytes())
+                   << ", root pool reservation: "
+                   << succinctBytes(buildOp->pool()->root()->reservedBytes());
       return;
     }
   }
@@ -1150,6 +1396,19 @@ void HashBuild::reclaim(
   }
 }
 
+memory::MemoryPool* HashBuild::tableMemoryPool() const {
+  if (useHashTableCache()) {
+    // Cached hash tables use a leaf pool under the query pool (from cache
+    // entry). This allows the table to outlive the task while still supporting
+    // allocations.
+    VELOX_CHECK_NOT_NULL(cacheEntry_);
+    VELOX_CHECK_NOT_NULL(cacheEntry_->tablePool);
+    return cacheEntry_->tablePool.get();
+  }
+  // Regular joins use operator pool
+  return pool();
+}
+
 bool HashBuild::nonReclaimableState() const {
   // Apart from being in the nonReclaimable section, it's also not reclaimable
   // if:
@@ -1167,6 +1426,11 @@ bool HashBuild::nonReclaimableState() const {
 void HashBuild::close() {
   Operator::close();
 
+  if (useHashTableCache() && cacheEntry_ != nullptr &&
+      !cacheEntry_->buildComplete && hashTableCacheBuilderTask()) {
+    HashTableCache::instance()->drop(cacheKey_);
+  }
+
   {
     // Free up major memory usage. Gate access to them as they can be accessed
     // by the last build thread that finishes building the hash table.
@@ -1185,7 +1449,7 @@ HashBuildSpiller::HashBuildSpiller(
     RowTypePtr rowType,
     HashBitRange bits,
     const common::SpillConfig* spillConfig,
-    folly::Synchronized<common::SpillStats>* spillStats)
+    exec::SpillStats* spillStats)
     : SpillerBase(
           container,
           std::move(rowType),
@@ -1240,4 +1504,22 @@ void HashBuildSpiller::extractSpill(
         rows.data(), rows.size(), false, false, result->childAt(types.size()));
   }
 }
+
+bool HashBuild::abandonHashBuildDedupEarly(int64_t numDistinct) const {
+  VELOX_CHECK(dropDuplicates_);
+  return numHashInputRows_ > abandonHashBuildDedupMinRows_ &&
+      100 * numDistinct / numHashInputRows_ >= abandonHashBuildDedupMinPct_;
+}
+
+void HashBuild::abandonHashBuildDedup() {
+  // The hash table is no longer directly constructed in addInput. The data
+  // that was previously inserted into the hash table is already in the
+  // RowContainer.
+  addRuntimeStat(
+      std::string(HashBuild::kAbandonBuildNoDupHash), RuntimeCounter(1));
+  abandonHashBuildDedup_ = true;
+  table_->setAllowDuplicates(true);
+  lookup_.reset();
+}
+
 } // namespace facebook::velox::exec
diff --git a/velox/exec/HashBuild.h b/velox/exec/HashBuild.h
index 9485662bd0a..96beccf9850 100644
--- a/velox/exec/HashBuild.h
+++ b/velox/exec/HashBuild.h
@@ -15,8 +15,11 @@
  */
 #pragma once
 
+#include <string_view>
+
 #include "velox/exec/HashJoinBridge.h"
 #include "velox/exec/HashTable.h"
+#include "velox/exec/HashTableCache.h"
 #include "velox/exec/Operator.h"
 #include "velox/exec/Spill.h"
 #include "velox/exec/Spiller.h"
@@ -54,6 +57,13 @@ class HashBuild final : public Operator {
   };
   static std::string stateName(State state);
 
+  /// Runtime stat keys for hash build.
+  /// Maximum spill level reached during hash join build.
+  static constexpr std::string_view kMaxSpillLevel = "maxSpillLevel";
+  /// Whether dedup hash build was abandoned.
+  static constexpr std::string_view kAbandonBuildNoDupHash =
+      "abandonBuildNoDupHash";
+
   HashBuild(
       int32_t operatorId,
       DriverCtx* driverCtx,
@@ -104,9 +114,35 @@ class HashBuild final : public Operator {
   bool isRunning() const;
   void checkRunning() const;
 
+  // Returns true if this task is the builder task for the hash table cache
+  // entry (i.e. the task that builds the table, as opposed to a waiter task
+  // that reuses a cached table built by another task).
+  bool hashTableCacheBuilderTask() const {
+    return cacheEntry_->builderTaskId == taskId();
+  }
+
   // Invoked to set up hash table to build.
   void setupTable();
 
+  // Sets up hash table caching if enabled. Returns true if the cached table
+  // is already available or if this operator should wait for another task
+  // to build it, in which case further initialization should be skipped.
+  // Returns false if this operator should proceed with building the table.
+  bool setupCachedHashTable();
+
+  // Checks if a cached hash table is available and uses it if so.
+  // Returns true if the cached table was used (build can be skipped).
+  // Returns false if we need to build the table (cache miss).
+  bool getHashTableFromCache();
+
+  // Called when waiting for a cached hash table from another task.
+  // Returns true if the cached table was received and noMoreInput was called.
+  bool receivedCachedHashTable();
+
+  // Stores the built hash table in the cache for reuse by other tasks.
+  // No-op if hash table caching is not enabled.
+  void maybeSetHashTableInCache(const std::shared_ptr<BaseHashTable>& table);
+
   // Invoked when operator has finished processing the build input and wait for
   // all the other drivers to finish the processing. The last driver that
   // reaches to the hash build barrier, is responsible to build the hash table
@@ -204,12 +240,43 @@ class HashBuild final : public Operator {
   // not.
   bool nonReclaimableState() const;
 
+  // True if we have enough rows and not enough duplicate join keys, i.e. more
+  // than 'abandonHashBuildDedupMinRows_' rows and more than
+  // 'abandonHashBuildDedupMinPct_' % of rows are unique.
+  bool abandonHashBuildDedupEarly(int64_t numDistinct) const;
+
+  // Invoked to abandon build deduped hash table.
+  void abandonHashBuildDedup();
+
+  // Returns true if this operator is using a cached hash table.
+  // When enabled, the hash table is built once and cached for reuse
+  // by other tasks within the same query and stage.
+  bool useHashTableCache() const {
+    return !cacheKey_.empty();
+  }
+
+  // Returns the hash table cache key for this operator.
+  // Only valid if useHashTableCache() returns true.
+  const std::string& cacheKey() const {
+    VELOX_CHECK(
+        useHashTableCache(),
+        "cacheKey() called when table caching is not enabled");
+    return cacheKey_;
+  }
+
+  // Determines the memory pool to use for the hash table.
+  // For cached hash tables, uses query-level pool so the table can
+  // outlive the task. For regular joins, uses operator pool.
+  memory::MemoryPool* tableMemoryPool() const;
+
   const std::shared_ptr<const core::HashJoinNode> joinNode_;
 
   const core::JoinType joinType_;
 
   const bool nullAware_;
 
+  const bool nullAsValue_;
+
   // Sets to true for join type which needs right side join processing. The hash
   // table spiller then needs to record the probed flag, and the spilled input
   // reader also needs to restore the recorded probed flag. This is used to
@@ -217,12 +284,37 @@ class HashBuild final : public Operator {
   // not.
   const bool needProbedFlagSpill_;
 
+  // Indicates whether drop duplicate rows. Rows containing duplicate keys
+  // can be removed for left semi and anti join.
+  const bool dropDuplicates_;
+
+  // Maximum number of distinct values to keep when merging vector hashers
+  const size_t vectorHasherMaxNumDistinct_;
+
+  // Minimum number of rows to see before deciding to give up build no
+  // duplicates hash table.
+  const int32_t abandonHashBuildDedupMinRows_;
+
+  // Min unique rows pct for give up build deduped hash table. If more
+  // than this many rows are unique, build hash table in addInput phase is not
+  // worthwhile.
+  const int32_t abandonHashBuildDedupMinPct_;
+
   std::shared_ptr<HashJoinBridge> joinBridge_;
 
   tsan_atomic<bool> exceededMaxSpillLevelLimit_{false};
 
   State state_{State::kRunning};
 
+  // For hash table caching: the cache key passed in at construction.
+  // If set, this operator coordinates via HashTableCache.
+  // Key format: "queryId:planNodeId"
+  std::string cacheKey_;
+
+  // For hash table caching: cached entry containing the shared table and pool.
+  // Retrieved from HashTableCache.
+  std::shared_ptr<HashTableCacheEntry> cacheEntry_;
+
   // The row type used for hash table build and disk spilling.
   RowTypePtr tableType_;
 
@@ -242,6 +334,9 @@ class HashBuild final : public Operator {
   // Container for the rows being accumulated.
   std::unique_ptr<BaseHashTable> table_;
 
+  // Used for building hash table while adding input rows.
+  std::unique_ptr<HashLookup> lookup_;
+
   // Key channels in 'input_'
   std::vector<column_index_t> keyChannels_;
 
@@ -269,6 +364,10 @@ class HashBuild final : public Operator {
   // at least one entry with null join keys.
   bool joinHasNullKeys_{false};
 
+  // Whether to abandon building a HashTable without duplicates in HashBuild
+  // addInput phase for left semi/anti join.
+  bool abandonHashBuildDedup_{false};
+
   // The type used to spill hash table which might attach a boolean column to
   // record the probed flag if 'needProbedFlagSpill_' is true.
   RowTypePtr spillType_;
@@ -310,6 +409,10 @@ class HashBuild final : public Operator {
 
   // Maps key channel in 'input_' to channel in key.
   folly::F14FastMap<column_index_t, column_index_t> keyChannelMap_;
+
+  // Count the number of hash table input rows for building deduped
+  // hash table. It will not be updated after abandonBuildNoDupHash_ is true.
+  int64_t numHashInputRows_ = 0;
 };
 
 inline std::ostream& operator<<(std::ostream& os, HashBuild::State state) {
@@ -328,7 +431,7 @@ class HashBuildSpiller : public SpillerBase {
       RowTypePtr rowType,
       HashBitRange bits,
       const common::SpillConfig* spillConfig,
-      folly::Synchronized<common::SpillStats>* spillStats);
+      exec::SpillStats* spillStats);
 
   /// Invoked to spill all the rows stored in the row container of the hash
   /// build.
diff --git a/velox/exec/HashJoinBridge.cpp b/velox/exec/HashJoinBridge.cpp
index c9dc19948a0..4e9e25eab26 100644
--- a/velox/exec/HashJoinBridge.cpp
+++ b/velox/exec/HashJoinBridge.cpp
@@ -42,13 +42,18 @@ RowTypePtr hashJoinTableType(
     types.emplace_back(inputType->childAt(channel));
   }
 
+  if (joinNode->canDropDuplicates()) {
+    // For left semi and anti join with no extra filter, hash table does not
+    // store dependent columns.
+    return ROW(std::move(names), std::move(types));
+  }
+
   for (auto i = 0; i < inputType->size(); ++i) {
     if (keyChannelSet.find(i) == keyChannelSet.end()) {
       names.emplace_back(inputType->nameOf(i));
       types.emplace_back(inputType->childAt(i));
     }
   }
-
   return ROW(std::move(names), std::move(types));
 }
 
@@ -98,7 +103,7 @@ std::unique_ptr<HashBuildSpiller> createSpiller(
     const RowTypePtr& tableType,
     const HashBitRange& hashBitRange,
     const common::SpillConfig* spillConfig,
-    folly::Synchronized<common::SpillStats>* stats) {
+    exec::SpillStats* stats) {
   return std::make_unique<HashBuildSpiller>(
       joinType,
       parentId,
@@ -166,7 +171,7 @@ SpillPartitionSet spillHashJoinTable(
     const HashBitRange& hashBitRange,
     const std::shared_ptr<const core::HashJoinNode>& joinNode,
     const common::SpillConfig* spillConfig,
-    folly::Synchronized<common::SpillStats>* stats) {
+    exec::SpillStats* spillStats) {
   VELOX_CHECK_NOT_NULL(table);
   VELOX_CHECK_NOT_NULL(spillConfig);
   if (table->numDistinct() == 0) {
@@ -189,7 +194,7 @@ SpillPartitionSet spillHashJoinTable(
         tableType,
         hashBitRange,
         spillConfig,
-        stats));
+        spillStats));
     spillers.push_back(spillersHolder.back().get());
   }
   if (spillersHolder.empty()) {
@@ -211,7 +216,7 @@ SpillPartitionSet spillHashJoinTable(
 }
 
 void HashJoinBridge::setHashTable(
-    std::unique_ptr<BaseHashTable> table,
+    std::shared_ptr<BaseHashTable> table,
     SpillPartitionSet spillPartitionSet,
     bool hasNullKeys,
     HashJoinTableSpillFunc&& tableSpillFunc) {
@@ -452,11 +457,11 @@ uint64_t HashJoinMemoryReclaimer::reclaim(
 }
 
 bool isHashBuildMemoryPool(const memory::MemoryPool& pool) {
-  return folly::StringPiece(pool.name()).endsWith("HashBuild");
+  return pool.name().ends_with("HashBuild");
 }
 
 bool isHashProbeMemoryPool(const memory::MemoryPool& pool) {
-  return folly::StringPiece(pool.name()).endsWith("HashProbe");
+  return pool.name().ends_with("HashProbe");
 }
 
 bool needRightSideJoin(core::JoinType joinType) {
diff --git a/velox/exec/HashJoinBridge.h b/velox/exec/HashJoinBridge.h
index 879eab6801f..bd175f99c22 100644
--- a/velox/exec/HashJoinBridge.h
+++ b/velox/exec/HashJoinBridge.h
@@ -53,8 +53,9 @@ class HashJoinBridge : public JoinBridge {
   /// Invoked by the build operator to set the built hash table.
   /// 'spillPartitionSet' contains the spilled partitions while building
   /// 'table' which only applies if the disk spilling is enabled.
+  /// Accepts both unique_ptr (regular joins) and shared_ptr (broadcast joins).
   void setHashTable(
-      std::unique_ptr<BaseHashTable> table,
+      std::shared_ptr<BaseHashTable> table,
       SpillPartitionSet spillPartitionSet,
       bool hasNullKeys,
       HashJoinTableSpillFunc&& tableSpillFunc);
@@ -143,6 +144,17 @@ class HashJoinBridge : public JoinBridge {
 
   bool testingHasMoreSpilledPartitions();
 
+  /// Return the next unclaimed row container id in the current hash table for
+  /// HashProbe drivers to output build-side rows.
+  int getAndIncrementUnclaimedRowContainerId() {
+    return unclaimedRowContainerId_.fetch_add(1);
+  }
+
+  /// Reset the next unclaimed row container id to 0.
+  void resetUnclaimedRowContainerId() {
+    unclaimedRowContainerId_.store(0);
+  }
+
  private:
   void appendSpilledHashTablePartitionsLocked(
       SpillPartitionSet&& spillPartitionSet);
@@ -183,6 +195,13 @@ class HashJoinBridge : public JoinBridge {
   // processing.
   bool probeStarted_;
 
+  // Keep track of the next row container id in a hash table that has not been
+  // processed by any hash probe driver. This is used when hash probe drivers
+  // output build-side rows. When drivers are allowed to output build-side rows
+  // in parallel, drivers call getAndIncrementClaimedRowContainerId() to ensure
+  // the row containers they process do not overlap with each other.
+  std::atomic_int unclaimedRowContainerId_{0};
+
   friend test::HashJoinBridgeTestHelper;
 };
 
@@ -253,7 +272,7 @@ SpillPartitionSet spillHashJoinTable(
     const HashBitRange& hashBitRange,
     const std::shared_ptr<const core::HashJoinNode>& joinNode,
     const common::SpillConfig* spillConfig,
-    folly::Synchronized<common::SpillStats>* stats);
+    exec::SpillStats* spillStats);
 
 /// Returns the type used to spill a given hash table type. The function
 /// might attach a boolean column at the end of 'tableType' if 'joinType' needs
diff --git a/velox/exec/HashPartitionFunction.cpp b/velox/exec/HashPartitionFunction.cpp
index 896facc4efa..60323b9703b 100644
--- a/velox/exec/HashPartitionFunction.cpp
+++ b/velox/exec/HashPartitionFunction.cpp
@@ -16,8 +16,7 @@
 #include <velox/exec/HashPartitionFunction.h>
 #include <velox/exec/VectorHasher.h>
 
-#define XXH_INLINE_ALL
-#include <xxhash.h> // @manual=third-party//xxHash:xxhash
+#include "velox/common/base/XxHashInline.h"
 
 namespace facebook::velox::exec {
 namespace {
diff --git a/velox/exec/HashProbe.cpp b/velox/exec/HashProbe.cpp
index 7bbfe47656a..3ce4f60018d 100644
--- a/velox/exec/HashProbe.cpp
+++ b/velox/exec/HashProbe.cpp
@@ -15,9 +15,11 @@
  */
 
 #include "velox/exec/HashProbe.h"
+#include <folly/ScopeGuard.h>
 #include "velox/common/base/Counters.h"
 #include "velox/common/base/StatsReporter.h"
 #include "velox/common/testutil/TestValue.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/Task.h"
 #include "velox/expression/FieldReference.h"
@@ -118,15 +120,19 @@ HashProbe::HashProbe(
           joinNode->outputType(),
           operatorId,
           joinNode->id(),
-          "HashProbe",
+          OperatorType::kHashProbe,
           joinNode->canSpill(driverCtx->queryConfig())
-              ? driverCtx->makeSpillConfig(operatorId)
+              ? driverCtx->makeSpillConfig(operatorId, OperatorType::kHashProbe)
               : std::nullopt),
       outputBatchSize_{outputBatchRows()},
       joinNode_(std::move(joinNode)),
       joinType_{joinNode_->joinType()},
       nullAware_{joinNode_->isNullAware()},
+      nullAsValue_{joinNode_->isNullAsValue()},
       probeType_(joinNode_->sources()[0]->outputType()),
+      canOutputBuildRowsInParallel_(
+          driverCtx->queryConfig().parallelOutputJoinBuildRowsEnabled() &&
+          !canSpill()),
       joinBridge_(operatorCtx_->task()->getHashJoinBridgeLocked(
           operatorCtx_->driverCtx()->splitGroupId,
           planNodeId())),
@@ -376,6 +382,10 @@ void HashProbe::initializeResultIter() {
 
 void HashProbe::pushdownDynamicFilters() {
   auto* driver = operatorCtx_->driverCtx()->driver;
+  const bool hashProbeStringDynamicFilterPushdownEnabled =
+      operatorCtx_->driverCtx()
+          ->queryConfig()
+          .hashProbeStringDynamicFilterPushdownEnabled();
   auto numFilters = driver->pushdownFilters(
       this,
       keyChannels_,
@@ -384,10 +394,27 @@ void HashProbe::pushdownDynamicFilters() {
         if (dynamicFiltersProducedOnChannels_.contains(sourceChannel)) {
           return true;
         }
-        filter = table_->hashers()[sourceChannel]->getFilter(false);
+        auto& hasher = *table_->hashers()[sourceChannel];
+        if (hasher.typeKind() == TypeKind::VARCHAR ||
+            hasher.typeKind() == TypeKind::VARBINARY) {
+          if (!hashProbeStringDynamicFilterPushdownEnabled) {
+            return false;
+          }
+        }
+        filter = hasher.getFilter(false);
         if (!filter) {
-          return false;
+          filter = hasher.getBloomFilter();
+          if (!filter) {
+            return false;
+          }
+          auto* bloomFilter =
+              checkedPointerCast<const common::BigintValuesUsingBloomFilter>(
+                  filter.get());
+          addRuntimeStat(
+              std::string(HashProbe::kBloomFilterSize),
+              RuntimeCounter(bloomFilter->blocksByteSize()));
         }
+        dynamicFiltersProducedOnChannels_.insert(sourceChannel);
         for (auto* peer : findPeerOperators()) {
           peer->dynamicFiltersProducedOnChannels_.insert(sourceChannel);
         }
@@ -399,7 +426,7 @@ void HashProbe::pushdownDynamicFilters() {
   //  * build side has no dependent columns.
   if (keyChannels_.size() == 1 && !table_->hasDuplicateKeys() &&
       tableOutputProjections_.empty() && !filter_ && numFilters > 0 &&
-      !isRightJoin(joinType_)) {
+      !table_->hashers()[0]->getBloomFilter() && !isRightJoin(joinType_)) {
     canReplaceWithDynamicFilter_ = true;
   }
 }
@@ -456,10 +483,14 @@ void HashProbe::asyncWaitForHashTable() {
     }
   } else if (
       (isInnerJoin(joinType_) || isLeftSemiFilterJoin(joinType_) ||
+       isCountingLeftSemiFilterJoin(joinType_) ||
        isRightSemiFilterJoin(joinType_) ||
        (isRightSemiProjectJoin(joinType_) && !nullAware_) ||
        isRightJoin(joinType_)) &&
       table_->hashMode() != BaseHashTable::HashMode::kHash && !isSpillInput() &&
+      operatorCtx_->driverCtx()
+          ->queryConfig()
+          .hashProbeDynamicFilterPushdownEnabled() &&
       !hasMoreSpillData()) {
     // Find out whether there are any upstream operators that can accept dynamic
     // filters on all or a subset of the join keys. Create dynamic filters to
@@ -493,7 +524,6 @@ void HashProbe::prepareForSpillRestore() {
   restoringPartitionId_.reset();
   spillInputPartitionIds_.clear();
   spillOutputReader_.reset();
-  lastProbeIterator_.reset();
 
   VELOX_CHECK(promises_.empty() || lastProber_);
   if (!lastProber_) {
@@ -634,7 +664,6 @@ BlockingReason HashProbe::isBlocked(ContinueFuture* future) {
       }
       break;
     case ProbeOperatorState::kWaitForPeers:
-      VELOX_CHECK(canSpill());
       if (!future_.valid()) {
         setRunning();
       }
@@ -662,7 +691,9 @@ void HashProbe::decodeAndDetectNonNullKeys() {
     hashers_[i]->decode(*key, nonNullInputRows_);
   }
 
-  deselectRowsWithNulls(hashers_, nonNullInputRows_);
+  if (!nullAsValue_) {
+    deselectRowsWithNulls(hashers_, nonNullInputRows_);
+  }
   if (isRightSemiProjectJoin(joinType_) &&
       nonNullInputRows_.countSelected() < input_->size()) {
     probeSideHasNullKeys_ = true;
@@ -839,6 +870,7 @@ void HashProbe::fillLeftSemiProjectMatchColumn(vector_size_t size) {
 }
 
 void HashProbe::fillOutput(vector_size_t size) {
+  TestValue::adjust("facebook::velox::exec::HashProbe::fillOutput", this);
   prepareOutput(size);
 
   for (auto [in, out] : projectedInputColumns_) {
@@ -863,28 +895,49 @@ void HashProbe::fillOutput(vector_size_t size) {
 }
 
 RowVectorPtr HashProbe::getBuildSideOutput() {
-  auto* outputTableRows =
+  if (buildSideOutputRowContainerId_ == -1) {
+    buildSideOutputRowContainerId_ =
+        joinBridge_->getAndIncrementUnclaimedRowContainerId();
+    lastProbeIterator_.reset();
+  }
+  if (buildSideOutputRowContainerId_ >= table_->numRowContainers()) {
+    return nullptr;
+  }
+
+  char** outputTableRows =
       initBuffer<char*>(outputTableRows_, outputTableRowsCapacity_, pool());
-  int32_t numOut;
-  if (isRightSemiFilterJoin(joinType_)) {
-    numOut = table_->listProbedRows(
-        &lastProbeIterator_,
-        outputTableRowsCapacity_,
-        RowContainer::kUnlimited,
-        outputTableRows);
-  } else if (isRightSemiProjectJoin(joinType_)) {
-    numOut = table_->listAllRows(
-        &lastProbeIterator_,
-        outputTableRowsCapacity_,
-        RowContainer::kUnlimited,
-        outputTableRows);
-  } else {
-    // Must be a right join or full join.
-    numOut = table_->listNotProbedRows(
-        &lastProbeIterator_,
-        outputTableRowsCapacity_,
-        RowContainer::kUnlimited,
-        outputTableRows);
+  int32_t numOut{0};
+  while (numOut == 0 &&
+         buildSideOutputRowContainerId_ < table_->numRowContainers()) {
+    if (isRightSemiFilterJoin(joinType_)) {
+      numOut = table_->listProbedRows(
+          lastProbeIterator_,
+          buildSideOutputRowContainerId_,
+          outputTableRowsCapacity_,
+          RowContainer::kUnlimited,
+          outputTableRows);
+    } else if (isRightSemiProjectJoin(joinType_)) {
+      numOut = table_->listAllRows(
+          lastProbeIterator_,
+          buildSideOutputRowContainerId_,
+          outputTableRowsCapacity_,
+          RowContainer::kUnlimited,
+          outputTableRows);
+
+    } else {
+      // Must be a right join or full join.
+      numOut = table_->listNotProbedRows(
+          lastProbeIterator_,
+          buildSideOutputRowContainerId_,
+          outputTableRowsCapacity_,
+          RowContainer::kUnlimited,
+          outputTableRows);
+    }
+    if (numOut == 0) {
+      buildSideOutputRowContainerId_ =
+          joinBridge_->getAndIncrementUnclaimedRowContainerId();
+      lastProbeIterator_.reset();
+    }
   }
   if (numOut == 0) {
     return nullptr;
@@ -908,9 +961,9 @@ RowVectorPtr HashProbe::getBuildSideOutput() {
 
   if (isRightSemiProjectJoin(joinType_)) {
     // Populate 'match' column.
-    if (noInput_) {
+    if (noInput_ && nullAware_) {
       // Probe side is empty. All rows should return 'match = false', even ones
-      // with a null join key.
+      // with a null join key. (This applies to null-aware joins only.)
       matchColumn() = createConstantFalse(numOut, pool());
     } else {
       table_->rows()->extractProbedFlags(
@@ -940,14 +993,20 @@ bool HashProbe::needLastProbe() const {
 
 bool HashProbe::skipProbeOnEmptyBuild() const {
   return isInnerJoin(joinType_) || isLeftSemiFilterJoin(joinType_) ||
-      isRightJoin(joinType_) || isRightSemiFilterJoin(joinType_) ||
-      isRightSemiProjectJoin(joinType_);
+      isCountingLeftSemiFilterJoin(joinType_) || isRightJoin(joinType_) ||
+      isRightSemiFilterJoin(joinType_) || isRightSemiProjectJoin(joinType_);
 }
 
 bool HashProbe::canSpill() const {
   if (!Operator::canSpill()) {
     return false;
   }
+  // Hash table caching is incompatible with spilling. When the table is
+  // cached and shared across tasks, clearing it after probe would corrupt
+  // the cache for subsequent tasks.
+  if (joinNode_->useHashTableCache()) {
+    return false;
+  }
   if (operatorCtx_->task()->hasMixedExecutionGroupJoin(joinNode_.get())) {
     return operatorCtx_->driverCtx()
                ->queryConfig()
@@ -978,16 +1037,11 @@ void HashProbe::checkStateTransition(ProbeOperatorState state) {
   VELOX_CHECK_NE(state_, state);
   switch (state) {
     case ProbeOperatorState::kRunning:
-      if (!canSpill()) {
-        VELOX_CHECK_EQ(state_, ProbeOperatorState::kWaitForBuild);
-      } else {
-        VELOX_CHECK(
-            state_ == ProbeOperatorState::kWaitForBuild ||
-            state_ == ProbeOperatorState::kWaitForPeers);
-      }
+      VELOX_CHECK(
+          state_ == ProbeOperatorState::kWaitForBuild ||
+          state_ == ProbeOperatorState::kWaitForPeers);
       break;
     case ProbeOperatorState::kWaitForPeers:
-      VELOX_CHECK(canSpill());
       [[fallthrough]];
     case ProbeOperatorState::kWaitForBuild:
       [[fallthrough]];
@@ -1028,12 +1082,12 @@ RowVectorPtr HashProbe::getOutputInternal(bool toSpillOutput) {
 
   clearProjectedOutput();
 
-  if (!input_) {
+  if (input_ == nullptr) {
     if (hasMoreInput()) {
       return nullptr;
     }
 
-    if (needLastProbe() && lastProber_) {
+    if (needLastProbe() && (canOutputBuildRowsInParallel_ || lastProber_)) {
       auto output = getBuildSideOutput();
       if (output != nullptr) {
         return output;
@@ -1085,7 +1139,9 @@ RowVectorPtr HashProbe::getOutputInternal(bool toSpillOutput) {
   const auto inputSize = input_->size();
 
   if (replacedWithDynamicFilter_) {
-    addRuntimeStat("replacedWithDynamicFilterRows", RuntimeCounter(inputSize));
+    addRuntimeStat(
+        std::string(HashProbe::kReplacedWithDynamicFilterRows),
+        RuntimeCounter(inputSize));
     auto output = Operator::fillOutput(inputSize, nullptr);
     input_ = nullptr;
     return output;
@@ -1093,7 +1149,7 @@ RowVectorPtr HashProbe::getOutputInternal(bool toSpillOutput) {
 
   const bool isLeftSemiOrAntiJoinNoFilter = !filter_ &&
       (isLeftSemiFilterJoin(joinType_) || isLeftSemiProjectJoin(joinType_) ||
-       isAntiJoin(joinType_));
+       isAntiJoin(joinType_) || isCountingJoin(joinType_));
 
   const bool emptyBuildSide = (table_->numDistinct() == 0);
 
@@ -1155,6 +1211,31 @@ RowVectorPtr HashProbe::getOutputInternal(bool toSpillOutput) {
           }
         }
       }
+    } else if (isCountingAntiJoin(joinType_)) {
+      // Counting anti-join: emit row if no match or count has reached zero.
+      // Decrement count on match.
+      auto* rows = table_->rows();
+      for (auto i = 0; i < inputSize; ++i) {
+        auto* hit = lookup_->hits[i];
+        if (!activeRows_.isValid(i) || !hit || rows->count(hit) == 0) {
+          mapping[numOut] = i;
+          ++numOut;
+        } else {
+          rows->decrementCount(hit);
+        }
+      }
+    } else if (isCountingLeftSemiFilterJoin(joinType_)) {
+      // Counting semi-join: emit row if match and count > 0.
+      // Decrement count on match.
+      auto* rows = table_->rows();
+      for (auto i = 0; i < inputSize; ++i) {
+        auto* hit = lookup_->hits[i];
+        if (activeRows_.isValid(i) && hit && rows->count(hit) > 0) {
+          rows->decrementCount(hit);
+          mapping[numOut] = i;
+          ++numOut;
+        }
+      }
     } else {
       numOut = table_->listJoinResults(
           *resultIter_,
@@ -1173,9 +1254,30 @@ RowVectorPtr HashProbe::getOutputInternal(bool toSpillOutput) {
     }
     VELOX_CHECK_LE(numOut, outputBatchSize);
 
+    // Pre-load lazy input vectors within a reclaimable section so that the
+    // subsequent non-reclaimable evalFilter/fillOutput does not trigger OOM.
+    // If memory reclaim spills the hash table during lazy loading,
+    // ensureLazyInputLoaded() spills the current input and sets input_ to
+    // nullptr. We must bail out because resultIter_ now references freed
+    // hash table rows.
+    if (!toSpillOutput) {
+      ensureLazyInputLoaded();
+      if (input_ == nullptr) {
+        return nullptr;
+      }
+      VELOX_CHECK_NOT_NULL(table_);
+    }
+
     numOut = evalFilter(numOut);
 
     if (numOut == 0) {
+      // The hash probe might get stuck in the output loop if the filter is
+      // highly selective. This does not apply if the call is made during
+      // spilling, because we cannot break out and resume when the operator is
+      // undergoing spilling.
+      if (!toSpillOutput && shouldYield()) {
+        return nullptr;
+      }
       continue;
     }
 
@@ -1251,7 +1353,7 @@ RowVectorPtr HashProbe::createFilterInput(vector_size_t size) {
 }
 
 void HashProbe::prepareFilterRowsForNullAwareJoin(
-    RowVectorPtr& filterInput,
+    const RowVector* filterInput,
     vector_size_t numRows,
     bool filterPropagateNulls) {
   VELOX_CHECK_LE(numRows, kBatchSize);
@@ -1260,6 +1362,18 @@ void HashProbe::prepareFilterRowsForNullAwareJoin(
         BaseVector::create<RowVector>(filterInputType_, kBatchSize, pool());
   }
 
+  // When no rows are selected, filterInput must be nullptr since
+  // createFilterInput() cannot be called when outputRowMapping_ has been
+  // overwritten. When rows are selected, filterInput must be valid.
+  if (FOLLY_UNLIKELY(!filterInputRows_.hasSelections())) {
+    VELOX_CHECK_NULL(filterInput);
+    if (filterPropagateNulls) {
+      nullFilterInputRows_.resizeFill(numRows, false);
+    }
+    return;
+  }
+
+  VELOX_CHECK_NOT_NULL(filterInput);
   if (filterPropagateNulls) {
     nullFilterInputRows_.resizeFill(numRows, false);
     auto* rawNullRows = nullFilterInputRows_.asMutableRange().bits();
@@ -1331,7 +1445,7 @@ const uint64_t* getFlatFilterResult(VectorPtr& result) {
 } // namespace
 
 void HashProbe::applyFilterOnTableRowsForNullAwareJoin(
-    const SelectivityVector& rows,
+    SelectivityVector& rows,
     SelectivityVector& filterPassedRows,
     std::function<int32_t(char**, int32_t)> iterator) {
   if (!rows.hasSelections()) {
@@ -1339,47 +1453,53 @@ void HashProbe::applyFilterOnTableRowsForNullAwareJoin(
   }
   VELOX_CHECK(table_->rows(), "Should not move rows in hash joins");
   char* data[kBatchSize];
-  while (auto numRows = iterator(data, kBatchSize)) {
-    filterTableInput_->resize(numRows);
-    filterTableInputRows_.resizeFill(numRows, true);
+
+  while (auto numBuildRows = iterator(data, kBatchSize)) {
+    // Extract build-side columns once per build batch.
+    filterTableInput_->resize(numBuildRows);
+    filterTableInputRows_.resizeFill(numBuildRows, true);
     for (auto& projection : filterTableProjections_) {
       table_->extractColumn(
-          folly::Range<char* const*>(data, numRows),
+          folly::Range<char* const*>(data, numBuildRows),
           projection.inputChannel,
           filterTableInput_->childAt(projection.outputChannel));
     }
+
+    // Skip probe rows that already passed the filter on a previous build batch.
+    rows.deselect(filterPassedRows);
     rows.applyToSelected([&](vector_size_t row) {
       for (auto& projection : filterInputProjections_) {
         filterTableInput_->childAt(projection.outputChannel) =
             BaseVector::wrapInConstant(
-                numRows, row, input_->childAt(projection.inputChannel));
+                numBuildRows, row, input_->childAt(projection.inputChannel));
       }
       EvalCtx evalCtx(
           operatorCtx_->execCtx(), filter_.get(), filterTableInput_.get());
       filter_->eval(filterTableInputRows_, evalCtx, filterTableResult_);
+
+      bool passed = false;
       if (auto* values = getFlatFilterResult(filterTableResult_[0])) {
-        if (!bits::testSetBits(
-                values, 0, numRows, [](vector_size_t) { return false; })) {
-          filterPassedRows.setValid(row, true);
-        }
+        passed = !bits::testSetBits(
+            values, 0, numBuildRows, [](vector_size_t) { return false; });
       } else {
         decodedFilterTableResult_.decode(
             *filterTableResult_[0], filterTableInputRows_);
         if (decodedFilterTableResult_.isConstantMapping()) {
-          if (!decodedFilterTableResult_.isNullAt(0) &&
-              decodedFilterTableResult_.valueAt<bool>(0)) {
-            filterPassedRows.setValid(row, true);
-          }
+          passed = !decodedFilterTableResult_.isNullAt(0) &&
+              decodedFilterTableResult_.valueAt<bool>(0);
         } else {
-          for (vector_size_t i = 0; i < numRows; ++i) {
+          for (vector_size_t i = 0; i < numBuildRows; ++i) {
             if (!decodedFilterTableResult_.isNullAt(i) &&
                 decodedFilterTableResult_.valueAt<bool>(i)) {
-              filterPassedRows.setValid(row, true);
+              passed = true;
               break;
             }
           }
         }
       }
+      if (passed) {
+        filterPassedRows.setValid(row, true);
+      }
     });
   }
 }
@@ -1423,7 +1543,7 @@ SelectivityVector HashProbe::evalFilterForNullAwareJoin(
   if (buildSideHasNullKeys_) {
     prepareNullKeyProbeHashers();
     BaseHashTable::NullKeyRowsIterator iter;
-    nullKeyProbeRows.deselect(filterPassedRows);
+    nullKeyProbeRows.updateBounds();
     applyFilterOnTableRowsForNullAwareJoin(
         nullKeyProbeRows, filterPassedRows, [&](char** data, int32_t maxRows) {
           return table_->listNullKeyRows(
@@ -1431,7 +1551,7 @@ SelectivityVector HashProbe::evalFilterForNullAwareJoin(
         });
   }
   BaseHashTable::RowsIterator iter;
-  crossJoinProbeRows.deselect(filterPassedRows);
+  crossJoinProbeRows.updateBounds();
   applyFilterOnTableRowsForNullAwareJoin(
       crossJoinProbeRows, filterPassedRows, [&](char** data, int32_t maxRows) {
         return table_->listAllRows(
@@ -1484,17 +1604,26 @@ int32_t HashProbe::evalFilter(int32_t numRows) {
     filterInputRows_.updateBounds();
   }
 
-  RowVectorPtr filterInput = createFilterInput(numRows);
-
-  if (nullAware_) {
-    prepareFilterRowsForNullAwareJoin(
-        filterInput, numRows, filterPropagateNulls);
-  }
+  // Skip filter evaluation when no rows are selected. filterPassed()
+  // short-circuits on filterInputRows_, so the result is never read.
+  // We cannot call createFilterInput() here because it wraps probe columns
+  // in a dictionary over outputRowMapping_, which listJoinResults() may have
+  // already overwritten in the previous iteration — the dictionary would fail
+  // validation in debug builds.
+  if (FOLLY_LIKELY(filterInputRows_.hasSelections())) {
+    RowVectorPtr filterInput = createFilterInput(numRows);
+    if (nullAware_) {
+      prepareFilterRowsForNullAwareJoin(
+          filterInput.get(), numRows, filterPropagateNulls);
+    }
 
-  EvalCtx evalCtx(operatorCtx_->execCtx(), filter_.get(), filterInput.get());
-  filter_->eval(0, 1, true, filterInputRows_, evalCtx, filterResult_);
+    EvalCtx evalCtx(operatorCtx_->execCtx(), filter_.get(), filterInput.get());
+    filter_->eval(0, 1, true, filterInputRows_, evalCtx, filterResult_);
 
-  decodedFilterResult_.decode(*filterResult_[0], filterInputRows_);
+    decodedFilterResult_.decode(*filterResult_[0], filterInputRows_);
+  } else if (nullAware_) {
+    prepareFilterRowsForNullAwareJoin(nullptr, numRows, filterPropagateNulls);
+  }
 
   int32_t numPassed = 0;
   if (isLeftJoin(joinType_) || isFullJoin(joinType_)) {
@@ -1655,7 +1784,7 @@ void HashProbe::ensureLoadedIfNotAtEnd(column_index_t channel) {
 void HashProbe::ensureLoaded(column_index_t channel) {
   if (!filter_ &&
       (isLeftSemiFilterJoin(joinType_) || isLeftSemiProjectJoin(joinType_) ||
-       isAntiJoin(joinType_))) {
+       isAntiJoin(joinType_) || isCountingJoin(joinType_))) {
     return;
   }
 
@@ -1700,21 +1829,34 @@ void HashProbe::noMoreInputInternal() {
         spillInputPartitionIds_.size(),
         inputSpiller_->state().spilledPartitionIdSet().size());
     inputSpiller_->finishSpill(inputSpillPartitionSet_);
-    VELOX_CHECK_EQ(spillStats_->rlock()->spillSortTimeNanos, 0);
+    VELOX_CHECK_EQ(
+        spillStats_->spillSortTimeNanos.load(std::memory_order_relaxed), 0);
   }
 
-  const bool hasSpillEnabled = canSpill();
   std::vector<ContinuePromise> promises;
   std::vector<std::shared_ptr<Driver>> peers;
-  // The last operator to finish processing inputs is responsible for
-  // producing build-side rows based on the join.
+
+  // Reset flags about outputting build-side rows in parallel.
+  buildSideOutputRowContainerId_ = -1;
+
+  // NOTE: if 'canSpill()' is false and 'outputBuildRowsInParallel' is
+  // false too, then a hash probe operator doesn't need to wait for all the
+  // other peers to finish probe processing. If 'canSpill()' is true, it
+  // needs to wait and might expect spill gets triggered by the other probe
+  // operators, or there is previously spilled table partition(s) that needs to
+  // restore. If 'outputBuildRowsInParallel', it needs to wait to all drivers
+  // start outputting build-side rows in parallel only after all drivers finish
+  // probe processing.
+  const bool outputBuildRowsInParallel =
+      canOutputBuildRowsInParallel_ && needLastProbe();
+  const bool shouldBlock = canSpill() || outputBuildRowsInParallel;
   if (!operatorCtx_->task()->allPeersFinished(
           planNodeId(),
           operatorCtx_->driver(),
-          hasSpillEnabled ? &future_ : nullptr,
-          hasSpillEnabled ? promises_ : promises,
+          shouldBlock ? &future_ : nullptr,
+          shouldBlock ? promises_ : promises,
           peers)) {
-    if (hasSpillEnabled) {
+    if (shouldBlock) {
       VELOX_CHECK(future_.valid());
       setState(ProbeOperatorState::kWaitForPeers);
       VELOX_DCHECK(promises_.empty());
@@ -1725,13 +1867,14 @@ void HashProbe::noMoreInputInternal() {
   }
 
   VELOX_CHECK(promises.empty());
-  // NOTE: if 'hasSpillEnabled' is false, then a hash probe operator doesn't
-  // need to wait for all the other peers to finish probe processing.
-  // Otherwise, it needs to wait and might expect spill gets triggered by the
-  // other probe operators, or there is previously spilled table partition(s)
-  // that needs to restore.
-  VELOX_CHECK(hasSpillEnabled || peers.empty());
   lastProber_ = true;
+  joinBridge_->resetUnclaimedRowContainerId();
+  // If 'outputBuildRowsInParallel' is true, wake up all peers to start
+  // outputting build-side rows in parallel. Otherwise, only let the last prober
+  // proceed.
+  if (outputBuildRowsInParallel) {
+    wakeupPeerOperators();
+  }
 }
 
 bool HashProbe::isFinished() {
@@ -1775,8 +1918,9 @@ void HashProbe::ensureOutputFits() {
   }
 
   // We only need to reserve memory for output if need.
-  if (input_ == nullptr &&
-      (hasMoreInput() || !(needLastProbe() && lastProber_))) {
+  bool outputBuildSideRows =
+      needLastProbe() && (canOutputBuildRowsInParallel_ || lastProber_);
+  if (input_ == nullptr && (hasMoreInput() || !outputBuildSideRows)) {
     return;
   }
 
@@ -1785,9 +1929,11 @@ void HashProbe::ensureOutputFits() {
     memory::testingRunArbitration(pool());
   }
 
-  const uint64_t bytesToReserve =
-      operatorCtx_->driverCtx()->queryConfig().preferredOutputBatchBytes() *
-      1.2;
+  const uint64_t bytesToReserve = static_cast<uint64_t>(
+      static_cast<double>(operatorCtx_->driverCtx()
+                              ->queryConfig()
+                              .preferredOutputBatchBytes()) *
+      1.2);
   if (pool()->availableReservation() >= bytesToReserve) {
     return;
   }
@@ -1799,8 +1945,102 @@ void HashProbe::ensureOutputFits() {
   }
   LOG(WARNING) << "Failed to reserve " << succinctBytes(bytesToReserve)
                << " for memory pool " << pool()->name()
-               << ", usage: " << succinctBytes(pool()->usedBytes())
-               << ", reservation: " << succinctBytes(pool()->reservedBytes());
+               << ", root pool: " << pool()->root()->name()
+               << ", used: " << succinctBytes(pool()->usedBytes())
+               << ", reservation: " << succinctBytes(pool()->reservedBytes())
+               << ", root pool reservation: "
+               << succinctBytes(pool()->root()->reservedBytes());
+}
+
+bool HashProbe::needLazyLoadProbeInput() const {
+  if (!canReclaim() || input_ == nullptr || replacedWithDynamicFilter_) {
+    return false;
+  }
+
+  // For left semi filter/project and anti joins without a filter,
+  // ensureLoaded() is a no-op — lazy vectors are passed through zero-copy
+  // via wrapChild() in fillOutput() and never loaded during probe.
+  // Preloading is unnecessary because no loading happens.
+  if (!filter_ &&
+      (isLeftSemiFilterJoin(joinType_) || isLeftSemiProjectJoin(joinType_) ||
+       isAntiJoin(joinType_))) {
+    return false;
+  }
+  return true;
+}
+
+void HashProbe::ensureLazyInputLoaded() {
+  if (!needLazyLoadProbeInput()) {
+    return;
+  }
+
+  VELOX_CHECK_NOT_NULL(input_);
+
+  // When atEnd (single output batch), fillOutput() skips loading via
+  // ensureLoadedIfNotAtEnd() and wraps lazy vectors zero-copy.
+  // However, createFilterInput() unconditionally loads filter+projected
+  // columns, so those still need preloading when a filter is present.
+  const bool atEnd{resultIter_->atEnd()};
+  if (atEnd && !filter_) {
+    return;
+  }
+
+  std::vector<column_index_t> lazyChannels;
+  if (!atEnd) {
+    for (const auto& [in, _] : projectedInputColumns_) {
+      if (isLazyNotLoaded(*input_->childAt(in))) {
+        lazyChannels.push_back(in);
+      }
+    }
+  }
+  if (filter_) {
+    for (const auto& projection : filterInputProjections_) {
+      if (atEnd &&
+          projectedInputColumns_.find(projection.inputChannel) ==
+              projectedInputColumns_.end()) {
+        continue;
+      }
+      if (isLazyNotLoaded(*input_->childAt(projection.inputChannel))) {
+        lazyChannels.push_back(projection.inputChannel);
+      }
+    }
+  }
+  if (lazyChannels.empty()) {
+    return;
+  }
+
+  const bool tableWasNonEmpty{table_->numDistinct() > 0};
+  {
+    loadingLazyInput_ = true;
+    SCOPE_EXIT {
+      loadingLazyInput_ = false;
+    };
+    Operator::ReclaimableSectionGuard guard(this);
+    if (testingTriggerSpill(pool()->name())) {
+      memory::testingRunArbitration(pool());
+    }
+    for (const auto channel : lazyChannels) {
+      ensureLoaded(channel);
+    }
+  }
+
+  // If the hash table was spilled during lazy loading (it was non-empty
+  // before but is now empty), spill the current input so it can be re-probed
+  // during the restore pass. After spilling, resultIter_ references freed
+  // hash table rows, so we must abandon the current iteration by setting
+  // input_ to nullptr.
+  VELOX_CHECK_NOT_NULL(input_);
+  if (tableWasNonEmpty && table_->numDistinct() == 0) {
+    VELOX_CHECK_NOT_NULL(inputSpiller_);
+    spillInput(input_);
+    if (input_ != nullptr) {
+      // Non-spilled rows remain. For join types that skip probe on empty
+      // build side (inner, right, semi filter), dropping them is correct.
+      // For left/anti/full joins this would be data loss — fail loudly.
+      VELOX_CHECK(skipProbeOnEmptyBuild());
+    }
+    input_ = nullptr;
+  }
 }
 
 bool HashProbe::canReclaim() const {
@@ -1826,8 +2066,12 @@ void HashProbe::reclaim(
     LOG(WARNING)
         << "Can't reclaim from hash probe operator, exceeded maximum spill "
            "level of "
-        << config->maxSpillLevel << ", " << pool()->name() << ", usage "
-        << succinctBytes(pool()->usedBytes());
+        << config->maxSpillLevel << ", " << pool()->name()
+        << ", root pool: " << pool()->root()->name()
+        << ", used: " << succinctBytes(pool()->usedBytes())
+        << ", reservation: " << succinctBytes(pool()->reservedBytes())
+        << ", root pool reservation: "
+        << succinctBytes(pool()->root()->reservedBytes());
     return;
   }
 
@@ -1844,9 +2088,13 @@ void HashProbe::reclaim(
                  << (table_ == nullptr ? "nullptr"
                                        : std::to_string(table_->numDistinct()))
                  << "], " << pool()->name()
-                 << ", usage: " << succinctBytes(pool()->usedBytes())
+                 << ", root pool: " << pool()->root()->name()
+                 << ", used: " << succinctBytes(pool()->usedBytes())
+                 << ", reservation: " << succinctBytes(pool()->reservedBytes())
                  << ", node pool reservation: "
-                 << succinctBytes(pool()->parent()->reservedBytes());
+                 << succinctBytes(pool()->parent()->reservedBytes())
+                 << ", root pool reservation: "
+                 << succinctBytes(pool()->root()->reservedBytes());
     return;
   }
 
@@ -1874,9 +2122,14 @@ void HashProbe::reclaim(
                            ? "nullptr"
                            : std::to_string(probeOp->table_->numDistinct()))
                    << "], " << peerPool->name()
-                   << ", usage: " << succinctBytes(peerPool->usedBytes())
+                   << ", root pool: " << peerPool->root()->name()
+                   << ", used: " << succinctBytes(peerPool->usedBytes())
+                   << ", reservation: "
+                   << succinctBytes(peerPool->reservedBytes())
                    << ", node pool reservation: "
-                   << succinctBytes(peerPool->parent()->reservedBytes());
+                   << succinctBytes(peerPool->parent()->reservedBytes())
+                   << ", root pool reservation: "
+                   << succinctBytes(peerPool->root()->reservedBytes());
       return;
     }
     hasMoreProbeInput |= !probeOp->noMoreSpillInput_;
@@ -1932,6 +2185,13 @@ void HashProbe::spillOutput(const std::vector<HashProbe*>& operators) {
   auto* spillExecutor = spillConfig()->executor;
   for (auto* op : operators) {
     HashProbe* probeOp = static_cast<HashProbe*>(op);
+    // Skip operators that are in the middle of loading lazy input vectors.
+    // Their reclaim path re-enters getOutputInternal()->fillOutput(), or
+    // evalFilter()->createFilterInput() which loads the same lazy vectors,
+    // deadlocking on the column reader's folly::basic_once_flag.
+    if (probeOp->loadingLazyInput_) {
+      continue;
+    }
     spillTasks.push_back(
         memory::createAsyncMemoryReclaimTask<SpillResult>([probeOp]() {
           try {
@@ -2048,7 +2308,8 @@ void HashProbe::checkMaxSpillLevel(
           << "Exceeded spill level limit: " << config->maxSpillLevel
           << ", and disable spilling for memory pool: " << pool()->name();
       exceededMaxSpillLevelLimit_ = true;
-      ++spillStats_->wlock()->spillMaxLevelExceededCount;
+      spillStats_->spillMaxLevelExceededCount.fetch_add(
+          1, std::memory_order_relaxed);
       return;
     }
   }
diff --git a/velox/exec/HashProbe.h b/velox/exec/HashProbe.h
index e04521d5431..aacf12aa321 100644
--- a/velox/exec/HashProbe.h
+++ b/velox/exec/HashProbe.h
@@ -15,6 +15,8 @@
  */
 #pragma once
 
+#include <string_view>
+
 #include "velox/exec/HashBuild.h"
 #include "velox/exec/HashTable.h"
 #include "velox/exec/Operator.h"
@@ -26,6 +28,13 @@ namespace facebook::velox::exec {
 // Probes a hash table made by HashBuild.
 class HashProbe : public Operator {
  public:
+  /// Runtime stat keys for hash probe.
+  /// Size of the bloom filter in bytes.
+  static constexpr std::string_view kBloomFilterSize = "bloomFilterSize";
+  /// Number of rows bypassed via dynamic filter replacement.
+  static constexpr std::string_view kReplacedWithDynamicFilterRows =
+      "replacedWithDynamicFilterRows";
+
   HashProbe(
       int32_t operatorId,
       DriverCtx* driverCtx,
@@ -110,7 +119,8 @@ class HashProbe : public Operator {
   // output.
   static bool joinIncludesMissesFromLeft(core::JoinType joinType) {
     return isLeftJoin(joinType) || isFullJoin(joinType) ||
-        isAntiJoin(joinType) || isLeftSemiProjectJoin(joinType);
+        isAntiJoin(joinType) || isCountingAntiJoin(joinType) ||
+        isLeftSemiProjectJoin(joinType);
   }
 
   void setState(ProbeOperatorState state);
@@ -190,7 +200,7 @@ class HashProbe : public Operator {
   // 'filterPropagateNulls' is true, the probe input row which has null in any
   // probe filter column can't pass the filter.
   void prepareFilterRowsForNullAwareJoin(
-      RowVectorPtr& filterInput,
+      const RowVector* filterInput,
       vector_size_t numRows,
       bool filterPropagateNulls);
 
@@ -210,7 +220,7 @@ class HashProbe : public Operator {
   // that pass the filter in 'filterPassedRows'. Used in null-aware join
   // processing.
   void applyFilterOnTableRowsForNullAwareJoin(
-      const SelectivityVector& rows,
+      SelectivityVector& rows,
       SelectivityVector& filterPassedRows,
       std::function<int32_t(char**, int32_t)> iterator);
 
@@ -269,6 +279,17 @@ class HashProbe : public Operator {
   // operator is set to reclaimable at this stage.
   void ensureOutputFits();
 
+  // Returns true if the current input batch requires lazy preloading before
+  // the non-reclaimable probe output loop. Checks canReclaim(), input state,
+  // and join type to determine if preloading is needed.
+  bool needLazyLoadProbeInput() const;
+
+  // Pre-loads lazy input vectors in a reclaimable section so that the
+  // subsequent non-reclaimable evalFilter/fillOutput does not trigger OOM.
+  // Called after listJoinResults() so that atEnd() is known and preloading
+  // can be skipped for columns that fillOutput/createFilterInput won't load.
+  void ensureLazyInputLoaded();
+
   // Setups spilled output reader if 'spillOutputPartitionSet_' is not empty.
   void maybeSetupSpillOutputReader();
 
@@ -376,8 +397,18 @@ class HashProbe : public Operator {
 
   const bool nullAware_;
 
+  const bool nullAsValue_;
+
   const RowTypePtr probeType_;
 
+  // Flag to indicate whether this hash probe operator can output build-side
+  // rows in parallel with the peer operators for the current hash table.
+  // Outputting build-side rows in parallel is currently not allowed in either
+  // of the following cases:
+  // 1. QueryConfig::kParallelOutputJoinBuildRowsEnabled is false.
+  // 2. Spill is enabled.
+  const bool canOutputBuildRowsInParallel_;
+
   std::shared_ptr<HashJoinBridge> joinBridge_;
 
   ProbeOperatorState state_{ProbeOperatorState::kWaitForBuild};
@@ -630,7 +661,7 @@ class HashProbe : public Operator {
     std::optional<bool> currentRowPassed;
   };
 
-  BaseHashTable::RowsIterator lastProbeIterator_;
+  RowContainerIterator lastProbeIterator_;
 
   // For left and anti join with filter, tracks the probe side rows which had
   // matches on the build side but didn't pass the filter.
@@ -666,6 +697,11 @@ class HashProbe : public Operator {
   // input.
   SelectivityVector passingInputRows_;
 
+  // Set while loading lazy input vectors inside a ReclaimableSectionGuard.
+  // Tells reclaim() to skip spillOutput() for this operator to avoid
+  // re-entering the column reader (which would deadlock on call_once).
+  tsan_atomic<bool> loadingLazyInput_{false};
+
   // Indicates if this hash probe has exceeded max spill limit which is not
   // allowed to spill. This is reset when hash probe operator starts to probe
   // the next previously spilled hash table partition.
@@ -728,6 +764,10 @@ class HashProbe : public Operator {
 
   // Input vector used for listing rows with null keys.
   VectorPtr nullKeyProbeInput_;
+
+  // The index of the row container in the current hash table that this hash
+  // probe oprator is processing to output build-side rows.
+  int buildSideOutputRowContainerId_{-1};
 };
 
 inline std::ostream& operator<<(std::ostream& os, ProbeOperatorState state) {
diff --git a/velox/exec/HashTable.cpp b/velox/exec/HashTable.cpp
index 4c4a8c46382..4c811c47e95 100644
--- a/velox/exec/HashTable.cpp
+++ b/velox/exec/HashTable.cpp
@@ -22,12 +22,13 @@
 #include "velox/common/process/ProcessBase.h"
 #include "velox/common/process/TraceContext.h"
 #include "velox/common/testutil/TestValue.h"
+#include "velox/exec/AdaptivePrefetch.h"
 #include "velox/exec/OperatorUtils.h"
-#include "velox/vector/VectorTypeUtils.h"
 
 using facebook::velox::common::testutil::TestValue;
 
 namespace facebook::velox::exec {
+
 // static
 std::string BaseHashTable::modeString(HashMode mode) {
   switch (mode) {
@@ -51,17 +52,22 @@ HashTable<ignoreNullKeys>::HashTable(
     bool allowDuplicates,
     bool isJoinBuild,
     bool hasProbedFlag,
+    bool hasCountFlag,
     uint32_t minTableSizeForParallelJoinBuild,
-    memory::MemoryPool* pool)
+    memory::MemoryPool* pool,
+    uint64_t bloomFilterMaxSize)
     : BaseHashTable(std::move(hashers)),
       pool_(pool),
       minTableSizeForParallelJoinBuild_(minTableSizeForParallelJoinBuild),
+      bloomFilterMaxSize_(bloomFilterMaxSize),
       isJoinBuild_(isJoinBuild),
+      allowDuplicates_(allowDuplicates),
       buildPartitionBounds_(raw_vector<PartitionBoundIndexType>(pool)) {
+  VELOX_CHECK(bloomFilterMaxSize_ == 0 || (isJoinBuild && ignoreNullKeys));
   std::vector<TypePtr> keys;
   for (auto& hasher : hashers_) {
     keys.push_back(hasher->type());
-    if (!VectorHasher::typeKindSupportsValueIds(hasher->typeKind())) {
+    if (!hasher->typeSupportsValueIds()) {
       hashMode_ = HashMode::kHash;
     }
   }
@@ -74,7 +80,9 @@ HashTable<ignoreNullKeys>::HashTable(
       allowDuplicates,
       isJoinBuild,
       hasProbedFlag,
+      hasCountFlag,
       hashMode_ != HashMode::kHash,
+      /*useListRowIndex=*/false,
       pool);
   nextOffset_ = rows_->nextOffset();
 }
@@ -234,8 +242,7 @@ class ProbeState {
     int64_t numProbedBuckets = 0;
     while (numProbedBuckets < table.numBuckets()) {
       if (!hits_) {
-        const uint16_t empty = simd::toBitMask(tagsInTable_ == kEmptyGroup);
-        if (empty) {
+        if (simd::any(tagsInTable_ == kEmptyGroup)) {
           return nullptr;
         }
       } else {
@@ -275,8 +282,7 @@ class ProbeState {
   template <typename Table>
   void eraseHit(Table& table, int64_t& numTombstones) {
     const auto kEmptyGroup = BaseHashTable::TagVector::broadcast(kEmptyTag);
-    const bool hasEmptyGroup =
-        simd::toBitMask(tagsInTable_ == kEmptyGroup) != 0;
+    const bool hasEmptyGroup = simd::any(tagsInTable_ == kEmptyGroup);
 
     table.bucketAt(bucketOffset_)
         ->setTag(indexInTags_, hasEmptyGroup ? 0 : kTombstoneTag);
@@ -332,6 +338,8 @@ char* HashTable<ignoreNullKeys>::insertEntry(
     HashLookup& lookup,
     uint64_t index,
     vector_size_t row) {
+  TestValue::adjust(
+      "facebook::velox::exec::HashTable::insertEntry", rows_->pool());
   char* group = rows_->newRow();
   lookup.hits[row] = group; // NOLINT
   storeKeys(lookup, row);
@@ -358,8 +366,13 @@ bool HashTable<ignoreNullKeys>::compareKeys(
   int32_t i = 0;
   do {
     auto& hasher = lookup.hashers[i];
-    if (!rows_->equals<!ignoreNullKeys>(
-            group, rows_->columnAt(i), hasher->decodedVector(), row)) {
+    if (rows_->compare<!ignoreNullKeys>(
+            group,
+            rows_->columnAt(i),
+            hasher->decodedVector(),
+            row,
+            CompareFlags::equality(
+                CompareFlags::NullHandlingMode::kNullAsValue)) != 0) {
       return false;
     }
   } while (++i < numKeys);
@@ -417,9 +430,12 @@ FOLLY_ALWAYS_INLINE void HashTable<ignoreNullKeys>::fullProbe(
 }
 
 namespace {
+
 // Group prefetch size for join build & probe.
 constexpr int32_t kPrefetchSize = 64;
 
+constexpr int32_t kHashBatchSize = 1024;
+
 // Normalized keys have non0-random bits. Bits need to be propagated
 // up to make a tag byte and down so that non-lowest bits of
 // normalized key affect the hash table index.
@@ -798,7 +814,14 @@ bool HashTable<ignoreNullKeys>::hashRows(
     return true;
   }
   if (!initNormalizedKeys && hashMode_ == HashMode::kNormalizedKey) {
-    for (auto i = 0; i < rows.size(); ++i) {
+    // Prefetch row pointers ahead to hide DRAM latency when reading
+    // normalizedKey from random RowContainer arena addresses.
+    const auto numRows = static_cast<int32_t>(rows.size());
+    AdaptivePrefetch prefetch(numRows);
+    for (int32_t i = 0; i < numRows; ++i) {
+      if (auto ahead = prefetch.lookAhead()) {
+        __builtin_prefetch(rows[i + ahead] - sizeof(normalized_key_t));
+      }
       hashes[i] =
           mixNormalizedKey(RowContainer::normalizedKey(rows[i]), sizeBits_);
     }
@@ -834,12 +857,87 @@ bool HashTable<ignoreNullKeys>::hashRows(
 }
 
 namespace {
+
+template <typename T>
+void partitionBloomFilterRowsImpl(
+    int32_t offset,
+    const common::BigintValuesUsingBloomFilter& filter,
+    const RowContainer& rowContainer,
+    uint8_t partitionMask,
+    RowPartitions& rowPartitions) {
+  char* rows[kHashBatchSize];
+  uint8_t partitions[kHashBatchSize];
+  RowContainerIterator iter;
+  while (auto numRows = rowContainer.listRows(
+             &iter, kHashBatchSize, RowContainer::kUnlimited, rows)) {
+    for (int i = 0; i < numRows; ++i) {
+      auto value = folly::loadUnaligned<T>(rows[i] + offset);
+      partitions[i] = filter.blockIndex(value) & partitionMask;
+    }
+    rowPartitions.appendPartitions(
+        folly::Range<const uint8_t*>(partitions, numRows));
+  }
+}
+
+void partitionBloomFilterRows(
+    const VectorHasher& hasher,
+    int32_t offset,
+    const common::BigintValuesUsingBloomFilter& filter,
+    const RowContainer& rowContainer,
+    uint8_t numPartitions,
+    RowPartitions& rowPartitions) {
+  VELOX_DCHECK(hasher.supportsBloomFilter());
+  VELOX_DCHECK(bits::isPowerOfTwo(numPartitions));
+  switch (hasher.typeKind()) {
+    case TypeKind::INTEGER:
+      partitionBloomFilterRowsImpl<int32_t>(
+          offset, filter, rowContainer, numPartitions - 1, rowPartitions);
+      break;
+    case TypeKind::BIGINT:
+      partitionBloomFilterRowsImpl<int64_t>(
+          offset, filter, rowContainer, numPartitions - 1, rowPartitions);
+      break;
+    default:
+      VELOX_UNREACHABLE();
+  }
+}
+
+template <typename T>
+void buildBloomFilterImpl(
+    int32_t offset,
+    char** rows,
+    int numRows,
+    common::BigintValuesUsingBloomFilter& filter) {
+  for (int i = 0; i < numRows; ++i) {
+    filter.insert(folly::loadUnaligned<T>(rows[i] + offset));
+  }
+}
+
+void buildBloomFilter(
+    const VectorHasher& hasher,
+    int32_t offset,
+    char** rows,
+    int numRows,
+    common::BigintValuesUsingBloomFilter& filter) {
+  VELOX_DCHECK(hasher.supportsBloomFilter());
+  switch (hasher.typeKind()) {
+    case TypeKind::INTEGER:
+      buildBloomFilterImpl<int32_t>(offset, rows, numRows, filter);
+      break;
+    case TypeKind::BIGINT:
+      buildBloomFilterImpl<int64_t>(offset, rows, numRows, filter);
+      break;
+    default:
+      VELOX_UNREACHABLE();
+  }
+}
+
 template <typename Source>
 void syncWorkItems(
     std::vector<std::shared_ptr<Source>>& items,
-    std::exception_ptr& error,
     std::vector<CpuWallTiming>& timings,
-    bool log = false) {
+    bool throwError) {
+  std::exception_ptr error;
   // All items must be synced also in case of error because the items
   // hold references to the table and rows which could be destructed
   // if unwinding the stack did not pause to sync.
@@ -850,15 +948,42 @@ void syncWorkItems(
         timings.push_back(item->prepareTiming());
       }
     } catch (const std::exception& e) {
-      if (log) {
+      if (!throwError) {
         LOG(ERROR) << "Error in async hash build: " << e.what();
+      } else {
+        error = std::current_exception();
       }
-      error = std::current_exception();
     }
   }
+  if (error) {
+    std::rethrow_exception(error);
+  }
 }
+
 } // namespace
 
+template <>
+bool HashTable<true>::bloomFilterSupported() const {
+  if (!(bloomFilterMaxSize_ > 0 &&
+        common::BigintValuesUsingBloomFilter::numBlocks(numDistinct_) *
+                sizeof(SplitBlockBloomFilter::Block) <=
+            bloomFilterMaxSize_)) {
+    return false;
+  }
+  for (auto& hasher : hashers_) {
+    if (hasher->supportsBloomFilter()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+template <>
+bool HashTable<false>::bloomFilterSupported() const {
+  VELOX_CHECK_EQ(bloomFilterMaxSize_, 0);
+  return false;
+}
+
 template <bool ignoreNullKeys>
 bool HashTable<ignoreNullKeys>::canApplyParallelJoinBuild() const {
   if (!isJoinBuild_ || buildExecutor_ == nullptr) {
@@ -908,23 +1033,50 @@ void HashTable<ignoreNullKeys>::parallelJoinBuild() {
   buildPartitionBounds_.back() = sizeMask_ + 1;
   std::vector<std::shared_ptr<AsyncSource<bool>>> partitionSteps;
   std::vector<std::shared_ptr<AsyncSource<bool>>> buildSteps;
+  std::vector<std::shared_ptr<AsyncSource<bool>>> bloomFilterPartitionSteps;
+  std::vector<std::shared_ptr<AsyncSource<bool>>> bloomFilterBuildSteps;
   // rowPartitions are used in the async threads, so declare them before the
   // sync guard.
   std::vector<std::unique_ptr<RowPartitions>> rowPartitions;
   auto sync = folly::makeGuard([&]() {
     // This is executed on returning path, possibly in unwinding, so must not
     // throw.
-    std::exception_ptr error;
     syncWorkItems(
-        partitionSteps, error, parallelJoinBuildStats_.partitionTimings, true);
+        partitionSteps, parallelJoinBuildStats_.partitionTimings, false);
+    syncWorkItems(buildSteps, parallelJoinBuildStats_.buildTimings, false);
     syncWorkItems(
-        buildSteps, error, parallelJoinBuildStats_.buildTimings, true);
+        bloomFilterPartitionSteps,
+        parallelJoinBuildStats_.bloomFilterPartitionTimings,
+        false);
+    syncWorkItems(
+        bloomFilterBuildSteps,
+        parallelJoinBuildStats_.bloomFilterBuildTimings,
+        false);
     // Release the partition bounds to reduce memory usage.
     buildPartitionBounds_ = raw_vector<PartitionBoundIndexType>(pool_);
   });
 
-  const auto getTable = [this](size_t i) INLINE_LAMBDA {
-    return i == 0 ? this : otherTables_[i - 1].get();
+  // Passing driver context directly to avoid cross thread access to thread
+  // local driver thread context.
+  const DriverCtx* driverCtx{nullptr};
+  if (const auto* driverThreadCtx = driverThreadContext()) {
+    driverCtx = driverThreadCtx->driverCtx();
+  }
+
+  const auto runStep = [&](auto& steps, auto&& work, bool runInCurrentThread) {
+    auto step = std::make_shared<AsyncSource<bool>>([work = std::move(work)] {
+      work();
+      return std::make_unique<bool>(true);
+    });
+    steps.push_back(step);
+    if (runInCurrentThread) {
+      step->prepare();
+    } else {
+      buildExecutor_->add([driverCtx, step]() {
+        ScopedDriverThreadContext scopedDriverThreadContext(driverCtx);
+        step->prepare();
+      });
+    }
   };
 
   // This step can involve large memory allocations, so there is a chance of
@@ -932,69 +1084,120 @@ void HashTable<ignoreNullKeys>::parallelJoinBuild() {
   // concurrency issues.
   rowPartitions.reserve(numPartitions);
   for (auto i = 0; i < numPartitions; ++i) {
-    auto* table = getTable(i);
-    rowPartitions.push_back(table->rows()->createRowPartitions(*rows_->pool()));
-  }
-
-  // Passing driver context directly to avoid cross thread access to thread
-  // local driver thread context.
-  const DriverCtx* driverCtx{nullptr};
-  if (const auto* driverThreadCtx = driverThreadContext()) {
-    driverCtx = driverThreadCtx->driverCtx();
+    rowPartitions.push_back(
+        tableAt(i)->rows()->createRowPartitions(*rows_->pool()));
   }
 
   // The parallel table partitioning step.
   for (auto i = 0; i < numPartitions; ++i) {
-    auto* table = getTable(i);
-    partitionSteps.push_back(std::make_shared<AsyncSource<bool>>(
-        [this, table, rawRowPartitions = rowPartitions[i].get()]() {
+    auto* table = tableAt(i);
+    bool last = i == numPartitions - 1;
+    runStep(
+        partitionSteps,
+        [this, table, rawRowPartitions = rowPartitions[i].get()] {
           partitionRows(*table, *rawRowPartitions);
-          return std::make_unique<bool>(true);
-        }));
-    VELOX_CHECK(!partitionSteps.empty());
-    buildExecutor_->add([driverCtx, step = partitionSteps.back()]() {
-      ScopedDriverThreadContext scopedDriverThreadContext(driverCtx);
-      step->prepare();
-    });
-  }
-
-  std::exception_ptr error;
-  syncWorkItems(
-      partitionSteps, error, parallelJoinBuildStats_.partitionTimings);
-  if (error != nullptr) {
-    std::rethrow_exception(error);
+        },
+        // run last partition on current thread to avoid wasting current thread
+        // on just waiting
+        last);
   }
+  syncWorkItems(partitionSteps, parallelJoinBuildStats_.partitionTimings, true);
 
-  // The parallel table building step.
+  // The parallel table building step. Each partition collects overflow rows
+  // (rows whose target bucket falls outside its [start, end) range) along
+  // with their hashes, so the final serial re-insertion phase below does
+  // not need to recompute them.
   std::vector<std::vector<char*>> overflowPerPartition(numPartitions);
+  std::vector<std::vector<uint64_t>> overflowHashesPerPartition(numPartitions);
   for (auto i = 0; i < numPartitions; ++i) {
-    buildSteps.push_back(std::make_shared<AsyncSource<bool>>(
-        [this, i, &overflowPerPartition, &rowPartitions]() {
-          buildJoinPartition(i, rowPartitions, overflowPerPartition[i]);
-          return std::make_unique<bool>(true);
-        }));
-    VELOX_CHECK(!buildSteps.empty());
-    buildExecutor_->add([driverCtx, step = buildSteps.back()]() {
-      ScopedDriverThreadContext scopedDriverThreadContext(driverCtx);
-      step->prepare();
-    });
-  }
-  syncWorkItems(buildSteps, error, parallelJoinBuildStats_.buildTimings);
-
-  if (error != nullptr) {
-    std::rethrow_exception(error);
+    bool last = i == numPartitions - 1;
+    runStep(
+        buildSteps,
+        [this,
+         i,
+         &overflowPerPartition,
+         &overflowHashesPerPartition,
+         &rowPartitions] {
+          buildJoinPartition(
+              i,
+              rowPartitions,
+              overflowPerPartition[i],
+              overflowHashesPerPartition[i]);
+        },
+        // run last partition on current thread to avoid wasting current thread
+        // on just waiting
+        last);
+  }
+  syncWorkItems(buildSteps, parallelJoinBuildStats_.buildTimings, true);
+
+  if (bloomFilterSupported()) {
+    const auto numBloomFilterPartitions = bits::isPowerOfTwo(numPartitions)
+        ? numPartitions
+        : bits::nextPowerOfTwo(numPartitions) / 2;
+    VELOX_CHECK_GT(numBloomFilterPartitions, 0);
+    for (int i = 0; i < hashers_.size(); ++i) {
+      if (!hashers_[i]->supportsBloomFilter()) {
+        continue;
+      }
+      auto filter = std::make_shared<common::BigintValuesUsingBloomFilter>(
+          numDistinct_, false);
+      hashers_[i]->setBloomFilter(filter);
+      for (auto j = 0; j < numPartitions; ++j) {
+        bool last = j == numPartitions - 1;
+        auto* rows = tableAt(j)->rows();
+        rowPartitions[j]->reset();
+        runStep(
+            bloomFilterPartitionSteps,
+            [hasher = hashers_[i].get(),
+             offset = rows->columnAt(i).offset(),
+             filter,
+             rows,
+             numBloomFilterPartitions,
+             rowPartitions = rowPartitions[j].get()] {
+              partitionBloomFilterRows(
+                  *hasher,
+                  offset,
+                  *filter,
+                  *rows,
+                  numBloomFilterPartitions,
+                  *rowPartitions);
+            },
+            // run last partition on current thread to avoid wasting current
+            // thread on just waiting
+            last);
+      }
+      syncWorkItems(
+          bloomFilterPartitionSteps,
+          parallelJoinBuildStats_.bloomFilterPartitionTimings,
+          true);
+      for (auto j = 0; j < numBloomFilterPartitions; ++j) {
+        bool last = j == numBloomFilterPartitions - 1;
+        runStep(
+            bloomFilterBuildSteps,
+            [this, i, j, &rowPartitions] {
+              buildBloomFilterPartition(i, j, rowPartitions);
+            },
+            // run last partition on current thread to avoid wasting current
+            // thread on just waiting
+            last);
+      }
+      syncWorkItems(
+          bloomFilterBuildSteps,
+          parallelJoinBuildStats_.bloomFilterBuildTimings,
+          true);
+    }
   }
 
-  raw_vector<uint64_t> hashes(pool_);
+  // Serially re-insert overflow rows that didn't fit in any partition's
+  // bucket range. Hashes were captured during the parallel build phase, so
+  // we reuse them instead of re-hashing.
   for (auto i = 0; i < numPartitions; ++i) {
     auto& overflows = overflowPerPartition[i];
-    hashes.resize(overflows.size());
-    hashRows(
-        folly::Range<char**>(overflows.data(), overflows.size()),
-        false,
-        hashes);
-    auto table = i == 0 ? this : otherTables_[i - 1].get();
-    insertForJoin(overflows.data(), hashes.data(), overflows.size(), nullptr);
+    auto& overflowHashes = overflowHashesPerPartition[i];
+    VELOX_CHECK_EQ(overflows.size(), overflowHashes.size());
+    insertForJoin(
+        overflows.data(), overflowHashes.data(), overflows.size(), nullptr);
+    auto* table = tableAt(i);
     VELOX_CHECK_EQ(table->rows()->numRows(), table->numParallelBuildRows_);
   }
 }
@@ -1025,14 +1228,14 @@ template <bool ignoreNullKeys>
 void HashTable<ignoreNullKeys>::partitionRows(
     HashTable<ignoreNullKeys>& subtable,
     RowPartitions& rowPartitions) {
-  constexpr int32_t kBatch = 1024;
-  raw_vector<char*> rows(kBatch, pool_);
-  raw_vector<uint64_t> hashes(kBatch, pool_);
-  raw_vector<uint8_t> partitions(kBatch, pool_);
+  raw_vector<char*> rows(kHashBatchSize, pool_);
+  raw_vector<uint64_t> hashes(kHashBatchSize, pool_);
+  raw_vector<uint8_t> partitions(kHashBatchSize, pool_);
   RowContainerIterator iter;
   while (auto numRows = subtable.rows_->listRows(
-             &iter, kBatch, RowContainer::kUnlimited, rows.data())) {
-    hashRows(folly::Range<char**>(rows.data(), numRows), true, hashes);
+             &iter, kHashBatchSize, RowContainer::kUnlimited, rows.data())) {
+    VELOX_CHECK(
+        hashRows(folly::Range<char**>(rows.data(), numRows), true, hashes));
     VELOX_DCHECK_EQ(
         0,
         buildPartitionBounds_.capacity() %
@@ -1052,27 +1255,57 @@ template <bool ignoreNullKeys>
 void HashTable<ignoreNullKeys>::buildJoinPartition(
     uint8_t partition,
     const std::vector<std::unique_ptr<RowPartitions>>& rowPartitions,
-    std::vector<char*>& overflow) {
-  constexpr int32_t kBatch = 1024;
-  raw_vector<char*> rows(kBatch, pool_);
-  raw_vector<uint64_t> hashes(kBatch, pool_);
+    std::vector<char*>& overflow,
+    std::vector<uint64_t>& overflowHashes) {
+  raw_vector<char*> rows(kHashBatchSize, pool_);
+  raw_vector<uint64_t> hashes(kHashBatchSize, pool_);
   const int32_t numPartitions = 1 + otherTables_.size();
   TableInsertPartitionInfo partitionInfo{
       buildPartitionBounds_[partition],
       buildPartitionBounds_[partition + 1],
-      overflow};
+      overflow,
+      overflowHashes};
   for (auto i = 0; i < numPartitions; ++i) {
-    auto* table = i == 0 ? this : otherTables_[i - 1].get();
+    auto* table = tableAt(i);
     RowContainerIterator iter;
-    while (const auto numRows = table->rows_->listPartitionRows(
-               iter, partition, kBatch, *rowPartitions[i], rows.data())) {
-      hashRows(folly::Range(rows.data(), numRows), false, hashes);
+    while (
+        const auto numRows = table->rows_->listPartitionRows(
+            iter, partition, kHashBatchSize, *rowPartitions[i], rows.data())) {
+      VELOX_CHECK(hashRows(folly::Range(rows.data(), numRows), false, hashes));
       insertForJoin(rows.data(), hashes.data(), numRows, &partitionInfo);
       table->numParallelBuildRows_ += numRows;
     }
   }
 }
 
+template <>
+void HashTable<true>::buildBloomFilterPartition(
+    column_index_t columnIndex,
+    uint8_t partition,
+    const std::vector<std::unique_ptr<RowPartitions>>& rowPartitions) {
+  char* rows[kHashBatchSize];
+  for (auto i = 0; i < 1 + otherTables_.size(); ++i) {
+    auto* table = tableAt(i);
+    auto rowColumn = table->rows_->columnAt(columnIndex);
+    auto* filter = checkedPointerCast<common::BigintValuesUsingBloomFilter>(
+        hashers_[columnIndex]->getBloomFilter().get());
+    RowContainerIterator iter;
+    while (auto numRows = table->rows_->listPartitionRows(
+               iter, partition, kHashBatchSize, *rowPartitions[i], rows)) {
+      buildBloomFilter(
+          *hashers_[columnIndex], rowColumn.offset(), rows, numRows, *filter);
+    }
+  }
+}
+
+template <>
+void HashTable<false>::buildBloomFilterPartition(
+    column_index_t /*columnIndex*/,
+    uint8_t /*partition*/,
+    const std::vector<std::unique_ptr<RowPartitions>>& /*rowPartitions*/) {
+  VELOX_UNREACHABLE();
+}
+
 template <bool ignoreNullKeys>
 bool HashTable<ignoreNullKeys>::insertBatch(
     char** groups,
@@ -1093,7 +1326,7 @@ bool HashTable<ignoreNullKeys>::insertBatch(
 template <bool ignoreNullKeys>
 void HashTable<ignoreNullKeys>::insertForGroupBy(
     char** groups,
-    uint64_t* hashes,
+    const uint64_t* hashes,
     int32_t numGroups) {
   if (hashMode_ == HashMode::kArray) {
     for (auto i = 0; i < numGroups; ++i) {
@@ -1119,9 +1352,24 @@ void HashTable<ignoreNullKeys>::insertForGroupBy(
       bool inserted{false};
       for (int64_t numProbedBuckets = 0; numProbedBuckets < numBuckets();
            ++numProbedBuckets) {
+        // We are populating a newly allocated table during rehash(), so
+        // here each tag is either empty (zero) or in-use (high bit set)
+        // and never a tombstone (0x7f, high bit unset). Therefore, the two
+        // approaches below are equivalent:
+        // - On x86 with SSE2, we benefit from a single instruction that builds
+        //   a bit mask by combining top bits of the tags in a vector, so we
+        //   pass the raw tags to simd::toBitMask().
+        // - On all architectures, the universally robust way is to call
+        //   simd::toBitMask() with an intermediate xsimd::batch_bool
+        //   generated from a comparison between the tags and an empty batch.
         MaskType free =
             ~simd::toBitMask(
-                BaseHashTable::TagVector::batch_bool_type(tagsInTable)) &
+#if XSIMD_WITH_SSE2
+                BaseHashTable::TagVector::batch_bool_type(tagsInTable)
+#else
+                tagsInTable != TagVector::broadcast(ProbeState::kEmptyTag)
+#endif
+                    ) &
             ProbeState::kFullMask;
         if (free) {
           auto freeOffset = bits::getAndClearLastSetBit(free);
@@ -1151,7 +1399,9 @@ bool HashTable<ignoreNullKeys>::arrayPushRow(char* row, int32_t index) {
       hasDuplicates_.set();
     }
   } else if (existing) {
-    // Semijoin or a known unique build side ignores a repeat of a key.
+    if (rows_->countOffset() > 0) {
+      rows_->addCount(existing, rows_->count(row));
+    }
     return false;
   }
   table_[index] = row;
@@ -1179,7 +1429,7 @@ FOLLY_ALWAYS_INLINE void HashTable<ignoreNullKeys>::buildFullProbe(
       -static_cast<int32_t>(sizeof(normalized_key_t));
   auto insertFn = [&](int32_t /*row*/, PartitionBoundIndexType index) {
     if (partitionInfo != nullptr && !partitionInfo->inRange(index)) {
-      partitionInfo->addOverflow(inserted);
+      partitionInfo->addOverflow(inserted, hash);
       return nullptr;
     }
     storeRowPointer(index, hash, inserted);
@@ -1194,6 +1444,8 @@ FOLLY_ALWAYS_INLINE void HashTable<ignoreNullKeys>::buildFullProbe(
               RowContainer::normalizedKey(inserted)) {
             if (nextOffset_ > 0) {
               pushNext(group, inserted);
+            } else if (rows_->countOffset() > 0) {
+              rows_->addCount(group, rows_->count(inserted));
             }
             return true;
           }
@@ -1211,6 +1463,8 @@ FOLLY_ALWAYS_INLINE void HashTable<ignoreNullKeys>::buildFullProbe(
           if (compareKeys(group, inserted)) {
             if (nextOffset_ > 0) {
               pushNext(group, inserted);
+            } else if (rows_->countOffset() > 0) {
+              rows_->addCount(group, rows_->count(inserted));
             }
             return true;
           }
@@ -1227,7 +1481,7 @@ template <bool ignoreNullKeys>
 template <bool isNormailizedKeyMode>
 FOLLY_ALWAYS_INLINE void HashTable<ignoreNullKeys>::insertForJoinWithPrefetch(
     char** groups,
-    uint64_t* hashes,
+    const uint64_t* hashes,
     int32_t numGroups,
     TableInsertPartitionInfo* partitionInfo) {
   auto i = 0;
@@ -1263,7 +1517,7 @@ FOLLY_ALWAYS_INLINE void HashTable<ignoreNullKeys>::insertForJoinWithPrefetch(
 template <bool ignoreNullKeys>
 void HashTable<ignoreNullKeys>::insertForJoin(
     char** groups,
-    uint64_t* hashes,
+    const uint64_t* hashes,
     int32_t numGroups,
     TableInsertPartitionInfo* partitionInfo) {
   // The insertable rows are in the table, all get put in the hash table or
@@ -1288,7 +1542,6 @@ void HashTable<ignoreNullKeys>::rehash(
     bool initNormalizedKeys,
     int8_t spillInputStartPartitionBit) {
   ++numRehashes_;
-  constexpr int32_t kHashBatchSize = 1024;
   if (canApplyParallelJoinBuild()) {
     parallelJoinBuild();
     return;
@@ -1296,22 +1549,48 @@ void HashTable<ignoreNullKeys>::rehash(
   raw_vector<uint64_t> hashes(pool_);
   hashes.resize(kHashBatchSize);
   char* groups[kHashBatchSize];
+  const bool shouldBuildBloomFilter = bloomFilterSupported();
+  std::vector<common::BigintValuesUsingBloomFilter*> bloomFilters;
+  if (shouldBuildBloomFilter) {
+    bloomFilters.resize(hashers_.size());
+    for (int i = 0; i < hashers_.size(); ++i) {
+      if (!hashers_[i]->supportsBloomFilter()) {
+        continue;
+      }
+      auto filter = std::make_shared<common::BigintValuesUsingBloomFilter>(
+          numDistinct_, false);
+      bloomFilters[i] = filter.get();
+      hashers_[i]->setBloomFilter(filter);
+    }
+  }
   // A join build can have multiple payload tables. Loop over 'this'
   // and the possible other tables and put all the data in the table
   // of 'this'.
   for (int32_t i = 0; i <= otherTables_.size(); ++i) {
     RowContainerIterator iterator;
     int32_t numGroups;
+    auto* table = tableAt(i);
     do {
-      numGroups = (i == 0 ? this : otherTables_[i - 1].get())
-                      ->rows()
-                      ->listRows(&iterator, kHashBatchSize, groups);
+      numGroups = table->rows()->listRows(&iterator, kHashBatchSize, groups);
       if (!insertBatch(
               groups, numGroups, hashes, initNormalizedKeys || i != 0)) {
         VELOX_CHECK_NE(hashMode_, HashMode::kHash);
         setHashMode(HashMode::kHash, 0, spillInputStartPartitionBit);
         return;
       }
+      if (shouldBuildBloomFilter) {
+        for (int j = 0; j < hashers_.size(); ++j) {
+          if (!hashers_[j]->supportsBloomFilter()) {
+            continue;
+          }
+          buildBloomFilter(
+              *hashers_[j],
+              table->rows()->columnAt(j).offset(),
+              groups,
+              numGroups,
+              *bloomFilters[j]);
+        }
+      }
     } while (numGroups > 0);
   }
 }
@@ -1350,7 +1629,6 @@ void HashTable<ignoreNullKeys>::setHashMode(
 
 template <bool ignoreNullKeys>
 bool HashTable<ignoreNullKeys>::analyze() {
-  constexpr int32_t kHashBatchSize = 1024;
   // @lint-ignore CLANGTIDY
   char* groups[kHashBatchSize];
   RowContainerIterator iterator;
@@ -1487,7 +1765,9 @@ void HashTable<ignoreNullKeys>::decideHashMode(
     return;
   }
   disableRangeArrayHash_ |= disableRangeArrayHash;
-  if (numDistinct_ && !isJoinBuild_) {
+  if (numDistinct_ && (!isJoinBuild_ || joinBuildNoDuplicates())) {
+    // If the join type is left semi and anti, allowDuplicates_ will be false,
+    // and join build is building hash table while adding input rows.
     if (!analyze()) {
       setHashMode(HashMode::kHash, numNew, spillInputStartPartitionBit);
       return;
@@ -1709,12 +1989,26 @@ template <bool ignoreNullKeys>
 void HashTable<ignoreNullKeys>::prepareJoinTable(
     std::vector<std::unique_ptr<BaseHashTable>> tables,
     int8_t spillInputStartPartitionBit,
+    size_t vectorHasherMaxNumDistinct,
+    bool dropDuplicates,
     folly::Executor* executor) {
   buildExecutor_ = executor;
+  if (dropDuplicates) {
+    if (table_ != nullptr) {
+      // Reset table_ and capacity_ to trigger rehash.
+      rows_->pool()->freeContiguous(tableAllocation_);
+      table_ = nullptr;
+      capacity_ = 0;
+    }
+    // Call analyze to insert all unique values in row container to the
+    // table hashers' uniqueValues_;
+    analyze();
+  }
   otherTables_.reserve(tables.size());
   for (auto& table : tables) {
-    otherTables_.emplace_back(std::unique_ptr<HashTable<ignoreNullKeys>>(
-        dynamic_cast<HashTable<ignoreNullKeys>*>(table.release())));
+    otherTables_.emplace_back(
+        std::unique_ptr<HashTable<ignoreNullKeys>>(
+            dynamic_cast<HashTable<ignoreNullKeys>*>(table.release())));
   }
 
   // If there are multiple tables, we need to merge the 'columnHasNulls' flags
@@ -1732,6 +2026,7 @@ void HashTable<ignoreNullKeys>::prepareJoinTable(
 
   bool useValueIds = mayUseValueIds(*this);
   if (useValueIds) {
+    CpuWallTimer timer(vectorHasherMergeTiming_);
     for (auto& other : otherTables_) {
       if (!mayUseValueIds(*other)) {
         useValueIds = false;
@@ -1740,8 +2035,13 @@ void HashTable<ignoreNullKeys>::prepareJoinTable(
     }
     if (useValueIds) {
       for (auto& other : otherTables_) {
+        if (dropDuplicates) {
+          // Before merging with the current hashers, all values in the row
+          // containers of other table need to be inserted into uniqueValues_.
+          other->analyze();
+        }
         for (auto i = 0; i < hashers_.size(); ++i) {
-          hashers_[i]->merge(*other->hashers_[i]);
+          hashers_[i]->merge(*other->hashers_[i], vectorHasherMaxNumDistinct);
           if (!hashers_[i]->mayUseValueIds()) {
             useValueIds = false;
             break;
@@ -1967,6 +2267,55 @@ int32_t HashTable<ignoreNullKeys>::listAllRows(
   return listRows<RowContainer::ProbeType::kAll>(iter, maxRows, maxBytes, rows);
 }
 
+template <bool ignoreNullKeys>
+template <RowContainer::ProbeType probeType>
+int32_t HashTable<ignoreNullKeys>::listRows(
+    RowContainerIterator& rowContainerIt,
+    int rowContainerId,
+    int32_t maxRows,
+    uint64_t maxBytes,
+    char** rows) {
+  const auto& rowContainer = rowContainerId == 0
+      ? rows_.get()
+      : otherTables_[rowContainerId - 1]->rows();
+  const auto numRows = rowContainer->template listRows<probeType>(
+      &rowContainerIt, maxRows, maxBytes, rows);
+  return numRows;
+}
+
+template <bool ignoreNullKeys>
+int32_t HashTable<ignoreNullKeys>::listNotProbedRows(
+    RowContainerIterator& rowContainerIt,
+    int rowContainerId,
+    int32_t maxRows,
+    uint64_t maxBytes,
+    char** rows) {
+  return listRows<RowContainer::ProbeType::kNotProbed>(
+      rowContainerIt, rowContainerId, maxRows, maxBytes, rows);
+}
+
+template <bool ignoreNullKeys>
+int32_t HashTable<ignoreNullKeys>::listProbedRows(
+    RowContainerIterator& rowContainerIt,
+    int rowContainerId,
+    int32_t maxRows,
+    uint64_t maxBytes,
+    char** rows) {
+  return listRows<RowContainer::ProbeType::kProbed>(
+      rowContainerIt, rowContainerId, maxRows, maxBytes, rows);
+}
+
+template <bool ignoreNullKeys>
+int32_t HashTable<ignoreNullKeys>::listAllRows(
+    RowContainerIterator& rowContainerIt,
+    int rowContainerId,
+    int32_t maxRows,
+    uint64_t maxBytes,
+    char** rows) {
+  return listRows<RowContainer::ProbeType::kAll>(
+      rowContainerIt, rowContainerId, maxRows, maxBytes, rows);
+}
+
 template <>
 int32_t HashTable<false>::listNullKeyRows(
     NullKeyRowsIterator* iter,
diff --git a/velox/exec/HashTable.h b/velox/exec/HashTable.h
index c19d74727a1..b8d3a33ee46 100644
--- a/velox/exec/HashTable.h
+++ b/velox/exec/HashTable.h
@@ -16,9 +16,8 @@
 #pragma once
 
 #include "velox/common/base/Portability.h"
-#include "velox/common/memory/MemoryAllocator.h"
+#include "velox/common/base/RuntimeMetrics.h"
 #include "velox/exec/OneWayStatusFlag.h"
-#include "velox/exec/Operator.h"
 #include "velox/exec/RowContainer.h"
 #include "velox/exec/VectorHasher.h"
 
@@ -30,15 +29,22 @@ struct TableInsertPartitionInfo {
   /// ['start', 'end') specifies the insert range of this table partition.
   PartitionBoundIndexType start;
   PartitionBoundIndexType end;
-  /// Used to contains the overflowed rows which can't be inserted into the
-  /// given table partition range.
+  /// Holds overflowed rows that can't be inserted into the given table
+  /// partition range. Re-inserted serially after all partitions finish.
   std::vector<char*>& overflows;
+  /// Hashes of the rows in 'overflows', stored 1:1. Carried through so
+  /// the serial re-insertion phase does not need to re-hash overflow rows.
+  std::vector<uint64_t>& overflowHashes;
 
   TableInsertPartitionInfo(
       PartitionBoundIndexType _start,
       PartitionBoundIndexType _end,
-      std::vector<char*>& _overflows)
-      : start(_start), end(_end), overflows(_overflows) {
+      std::vector<char*>& _overflows,
+      std::vector<uint64_t>& _overflowHashes)
+      : start(_start),
+        end(_end),
+        overflows(_overflows),
+        overflowHashes(_overflowHashes) {
     VELOX_CHECK_GE(start, 0);
     VELOX_CHECK_LT(start, end);
   }
@@ -48,9 +54,10 @@ struct TableInsertPartitionInfo {
     return index >= start && index < end;
   }
 
-  /// Adds 'row' falls outside of this partititon range into 'overflows'.
-  void addOverflow(char* row) {
+  /// Records 'row' (with its already-computed 'hash') as an overflow.
+  void addOverflow(char* row, uint64_t hash) {
     overflows.push_back(row);
+    overflowHashes.push_back(hash);
   }
 };
 
@@ -115,6 +122,8 @@ struct HashTableStats {
 struct ParallelJoinBuildStats {
   std::vector<CpuWallTiming> partitionTimings;
   std::vector<CpuWallTiming> buildTimings;
+  std::vector<CpuWallTiming> bloomFilterPartitionTimings;
+  std::vector<CpuWallTiming> bloomFilterBuildTimings;
 };
 
 class BaseHashTable {
@@ -140,21 +149,38 @@ class BaseHashTable {
 
   /// The name of the runtime stats collected and reported by operators that use
   /// the HashTable (HashBuild, HashAggregation).
-  static inline const std::string kCapacity{"hashtable.capacity"};
-  static inline const std::string kNumRehashes{"hashtable.numRehashes"};
-  static inline const std::string kNumDistinct{"hashtable.numDistinct"};
-  static inline const std::string kNumTombstones{"hashtable.numTombstones"};
+  static constexpr std::string_view kCapacity{"hashtable.capacity"};
+  static constexpr std::string_view kNumRehashes{"hashtable.numRehashes"};
+  static constexpr std::string_view kNumDistinct{"hashtable.numDistinct"};
+  static constexpr std::string_view kNumTombstones{"hashtable.numTombstones"};
+  static constexpr std::string_view kHashMode{"hashtable.hashMode"};
 
   /// The same as above but only reported by the HashBuild operator.
-  static inline const std::string kBuildWallNanos{"hashtable.buildWallNanos"};
-  static inline const std::string kParallelJoinPartitionWallNanos{
+  static constexpr std::string_view kBuildWallNanos{"hashtable.buildWallNanos"};
+  static constexpr std::string_view kParallelJoinPartitionWallNanos{
       "hashtable.parallelJoinPartitionWallNanos"};
-  static inline const std::string kParallelJoinPartitionCpuNanos{
+  static constexpr std::string_view kParallelJoinPartitionCpuNanos{
       "hashtable.parallelJoinPartitionCpuNanos"};
-  static inline const std::string kParallelJoinBuildWallNanos{
+  static constexpr std::string_view kParallelJoinBuildWallNanos{
       "hashtable.parallelJoinBuildWallNanos"};
-  static inline const std::string kParallelJoinBuildCpuNanos{
+  static constexpr std::string_view kParallelJoinBuildCpuNanos{
       "hashtable.parallelJoinBuildCpuNanos"};
+  static constexpr std::string_view kParallelJoinBloomFilterPartitionWallNanos{
+      "hashtable.parallelJoinBloomFilterPartitionWallNanos"};
+  static constexpr std::string_view kParallelJoinBloomFilterPartitionCpuNanos{
+      "hashtable.parallelJoinBloomFilterPartitionCpuNanos"};
+  static constexpr std::string_view kParallelJoinBloomFilterBuildWallNanos{
+      "hashtable.parallelJoinBloomFilterBuildWallNanos"};
+  static constexpr std::string_view kParallelJoinBloomFilterBuildCpuNanos{
+      "hashtable.parallelJoinBloomFilterBuildCpuNanos"};
+  static constexpr std::string_view kVectorHasherMergeCpuNanos{
+      "hashtable.vectorHasherMergeCpuNanos"};
+  static constexpr std::string_view kHashTableCacheHit{"hashtable.cacheHit"};
+  static constexpr std::string_view kHashTableCacheMiss{"hashtable.cacheMiss"};
+
+  /// Populates 'runtimeStats' with hash table stats.
+  virtual void addRuntimeStats(
+      std::unordered_map<std::string, RuntimeMetric>& runtimeStats) const = 0;
 
   /// Returns the string of the given 'mode'.
   static std::string modeString(HashMode mode);
@@ -285,6 +311,15 @@ class BaseHashTable {
       uint64_t maxBytes,
       char** rows) = 0;
 
+  /// Same as above, but only return rows from the row container of
+  /// 'rowContainerId'.
+  virtual int32_t listNotProbedRows(
+      RowContainerIterator& rowContainerIt,
+      int rowContainerId,
+      int32_t maxRows,
+      uint64_t maxBytes,
+      char** rows) = 0;
+
   /// Returns rows with 'probed' flag set. Used by the right semi join.
   virtual int32_t listProbedRows(
       RowsIterator* iter,
@@ -292,6 +327,15 @@ class BaseHashTable {
       uint64_t maxBytes,
       char** rows) = 0;
 
+  /// Same as above, but only return rows from the row container of
+  /// 'rowContainerId'.
+  virtual int32_t listProbedRows(
+      RowContainerIterator& rowContainerIt,
+      int rowContainerId,
+      int32_t maxRows,
+      uint64_t maxBytes,
+      char** rows) = 0;
+
   /// Returns all rows. Used by the right semi join project.
   virtual int32_t listAllRows(
       RowsIterator* iter,
@@ -299,6 +343,15 @@ class BaseHashTable {
       uint64_t maxBytes,
       char** rows) = 0;
 
+  /// Same as above, but only return rows from the row container of
+  /// 'rowContainerId'.
+  virtual int32_t listAllRows(
+      RowContainerIterator& rowContainerIt,
+      int rowContainerId,
+      int32_t maxRows,
+      uint64_t maxBytes,
+      char** rows) = 0;
+
   /// Returns all rows with null keys.  Used by null-aware joins (e.g. anti or
   /// left semi project).
   virtual int32_t listNullKeyRows(
@@ -310,8 +363,22 @@ class BaseHashTable {
   virtual void prepareJoinTable(
       std::vector<std::unique_ptr<BaseHashTable>> tables,
       int8_t spillInputStartPartitionBit,
+      size_t vectorHasherMaxNumDistinct,
+      bool dropDuplicates = false,
       folly::Executor* executor = nullptr) = 0;
 
+  /// The hash table used for join build in left semi and anti join may not
+  /// retain duplicate join keys when allowDuplicates_ is false. This is
+  /// achieved by constructing the hash table in the addInput phase to eliminate
+  /// duplicate join keys. When the percentage of duplicate data is small, it
+  /// will adaptively adjust to not build the hash table in the addInput phase.
+  /// Instead, it operates like other join types by reading all the data before
+  /// building the hash table. This function is used to change the behavior of
+  /// building hash table, if allowDuplicates is true, the join hash table will
+  /// not be built during the addInput phase, and the input data will also not
+  /// be deduplicated, but it will not impact the containing row container.
+  virtual void setAllowDuplicates(bool allowDuplicates) = 0;
+
   /// Returns the memory footprint in bytes for any data structures
   /// owned by 'this'.
   virtual int64_t allocatedBytes() const = 0;
@@ -328,6 +395,9 @@ class BaseHashTable {
   /// side. This is used for sizing the internal hash table.
   virtual uint64_t numDistinct() const = 0;
 
+  /// Returns the number of row containers in this hash table.
+  virtual int32_t numRowContainers() const = 0;
+
   /// Return a number of current stats that can help with debugging and
   /// profiling.
   virtual HashTableStats stats() const = 0;
@@ -414,8 +484,7 @@ class BaseHashTable {
   __attribute__((__no_sanitize__("thread")))
 #endif
 #endif
-  static TagVector
-  loadTags(uint8_t* tags, int64_t tagIndex) {
+  static TagVector loadTags(uint8_t* tags, int64_t tagIndex) {
     // Cannot use xsimd::batch::unaligned here because we need to skip TSAN.
     auto src = tags + tagIndex;
 #if XSIMD_WITH_SSE2
@@ -429,6 +498,10 @@ class BaseHashTable {
     return parallelJoinBuildStats_;
   }
 
+  const CpuWallTiming& vectorHasherMergeTiming() const {
+    return vectorHasherMergeTiming_;
+  }
+
   /// Copies the values at 'columnIndex' into 'result' for the 'rows.size' rows
   /// pointed to by 'rows'. If an entry in 'rows' is null, sets corresponding
   /// row in 'result' to null.
@@ -452,6 +525,7 @@ class BaseHashTable {
   std::unique_ptr<RowContainer> rows_;
 
   ParallelJoinBuildStats parallelJoinBuildStats_;
+  CpuWallTiming vectorHasherMergeTiming_;
 };
 
 FOLLY_ALWAYS_INLINE std::ostream& operator<<(
@@ -484,8 +558,10 @@ class HashTable : public BaseHashTable {
       bool allowDuplicates,
       bool isJoinBuild,
       bool hasProbedFlag,
+      bool hasCountFlag,
       uint32_t minTableSizeForParallelJoinBuild,
-      memory::MemoryPool* pool);
+      memory::MemoryPool* pool,
+      uint64_t bloomFilterMaxSize = 0);
 
   ~HashTable() override = default;
 
@@ -500,6 +576,7 @@ class HashTable : public BaseHashTable {
         false, // allowDuplicates
         false, // isJoinBuild
         false, // hasProbedFlag
+        false, // hasCountFlag
         0, // minTableSizeForParallelJoinBuild
         pool);
   }
@@ -509,8 +586,10 @@ class HashTable : public BaseHashTable {
       const std::vector<TypePtr>& dependentTypes,
       bool allowDuplicates,
       bool hasProbedFlag,
+      bool hasCountFlag,
       uint32_t minTableSizeForParallelJoinBuild,
-      memory::MemoryPool* pool) {
+      memory::MemoryPool* pool,
+      uint64_t bloomFilterMaxSize = 0) {
     return std::make_unique<HashTable>(
         std::move(hashers),
         std::vector<Accumulator>{},
@@ -518,8 +597,10 @@ class HashTable : public BaseHashTable {
         allowDuplicates,
         true, // isJoinBuild
         hasProbedFlag,
+        hasCountFlag,
         minTableSizeForParallelJoinBuild,
-        pool);
+        pool,
+        bloomFilterMaxSize);
   }
 
   void groupProbe(HashLookup& lookup, int8_t spillInputStartPartitionBit)
@@ -552,6 +633,27 @@ class HashTable : public BaseHashTable {
       uint64_t maxBytes,
       char** rows) override;
 
+  int32_t listNotProbedRows(
+      RowContainerIterator& rowContainerIt,
+      int rowContainerId,
+      int32_t maxRows,
+      uint64_t maxBytes,
+      char** rows) override;
+
+  int32_t listProbedRows(
+      RowContainerIterator& rowContainerIt,
+      int rowContainerId,
+      int32_t maxRows,
+      uint64_t maxBytes,
+      char** rows) override;
+
+  int32_t listAllRows(
+      RowContainerIterator& rowContainerIt,
+      int rowContainerId,
+      int32_t maxRows,
+      uint64_t maxBytes,
+      char** rows) override;
+
   int32_t listNullKeyRows(
       NullKeyRowsIterator* iter,
       int32_t maxRows,
@@ -578,6 +680,10 @@ class HashTable : public BaseHashTable {
     return numDistinct_;
   }
 
+  int32_t numRowContainers() const override {
+    return otherTables_.size() + 1;
+  }
+
   HashTableStats stats() const override {
     return HashTableStats{
         capacity_, numRehashes_, numDistinct_, numTombstones_};
@@ -587,10 +693,27 @@ class HashTable : public BaseHashTable {
     return hasDuplicates_.check();
   }
 
+  void setAllowDuplicates(const bool allowDuplicates) override {
+    allowDuplicates_ = allowDuplicates;
+  }
+
   HashMode hashMode() const override {
     return hashMode_;
   }
 
+  void addRuntimeStats(
+      std::unordered_map<std::string, RuntimeMetric>& runtimeStats)
+      const override {
+    runtimeStats[std::string(kCapacity)] = RuntimeMetric(capacity_);
+    runtimeStats[std::string(kHashMode)] =
+        RuntimeMetric(static_cast<int64_t>(hashMode_));
+    runtimeStats[std::string(kNumRehashes)] = RuntimeMetric(numRehashes_);
+    runtimeStats[std::string(kNumDistinct)] = RuntimeMetric(numDistinct_);
+    if (numTombstones_ != 0) {
+      runtimeStats[std::string(kNumTombstones)] = RuntimeMetric(numTombstones_);
+    }
+  }
+
   void decideHashMode(
       int32_t numNew,
       int8_t spillInputStartPartitionBit,
@@ -611,6 +734,8 @@ class HashTable : public BaseHashTable {
   void prepareJoinTable(
       std::vector<std::unique_ptr<BaseHashTable>> tables,
       int8_t spillInputStartPartitionBit,
+      size_t vectorHasherMaxNumDistinct,
+      bool dropDuplicates = false,
       folly::Executor* executor = nullptr) override;
 
   void prepareForJoinProbe(
@@ -766,6 +891,14 @@ class HashTable : public BaseHashTable {
   int32_t
   listRows(RowsIterator* iter, int32_t maxRows, uint64_t maxBytes, char** rows);
 
+  template <RowContainer::ProbeType probeType>
+  int32_t listRows(
+      RowContainerIterator& rowContainerIt,
+      int rowContainerId,
+      int32_t maxRows,
+      uint64_t maxBytes,
+      char** rows);
+
   char*& nextRow(char* row) {
     return *reinterpret_cast<char**>(row + nextOffset_);
   }
@@ -846,7 +979,7 @@ class HashTable : public BaseHashTable {
   // to the end of 'overflows' in 'partitionInfo'.
   void insertForJoin(
       char** groups,
-      uint64_t* hashes,
+      const uint64_t* hashes,
       int32_t numGroups,
       TableInsertPartitionInfo* partitionInfo);
 
@@ -854,7 +987,8 @@ class HashTable : public BaseHashTable {
   // contents in a RowContainer owned by 'this'. 'hashes' are the hash
   // numbers or array indices (if kArray mode) for each
   // group. 'groups' is expected to have no duplicate keys.
-  void insertForGroupBy(char** groups, uint64_t* hashes, int32_t numGroups);
+  void
+  insertForGroupBy(char** groups, const uint64_t* hashes, int32_t numGroups);
 
   // Checks if we can apply parallel table build optimization for hash join.
   // The function returns true if all of the following conditions:
@@ -876,12 +1010,14 @@ class HashTable : public BaseHashTable {
   void parallelJoinBuild();
 
   // Inserts the rows in 'partition' from this and 'otherTables' into 'this'.
-  // The rows that would have gone past the end of the partition are returned in
-  // 'overflow'.
+  // The rows that would have gone past the end of the partition are returned
+  // in 'overflow', along with their already-computed hashes in
+  // 'overflowHashes' so the caller can re-insert without re-hashing.
   void buildJoinPartition(
       uint8_t partition,
       const std::vector<std::unique_ptr<RowPartitions>>& rowPartitions,
-      std::vector<char*>& overflow);
+      std::vector<char*>& overflow,
+      std::vector<uint64_t>& overflowHashes);
 
   // Assigns a partition to each row of 'subtable' in RowPartitions of
   // subtable's RowContainer. If 'hashMode_' is kNormalizedKeys, records the
@@ -890,6 +1026,20 @@ class HashTable : public BaseHashTable {
       HashTable<ignoreNullKeys>& subtable,
       RowPartitions& rowPartitions);
 
+  // Whether we should build Bloom filters.  If Bloom filter pushdown is
+  // enabled, and the size fits, this returns true if any of the key columns
+  // support it.  The actual build should build a Bloom filter for each key
+  // column that supports it, and skip the ones that do not.
+  bool bloomFilterSupported() const;
+
+  // Populate the Bloom filter for the key column with `columnIndex` and rows
+  // with certain `partition`.  The partitions information is stored in
+  // `rowPartitions`.
+  void buildBloomFilterPartition(
+      column_index_t columnIndex,
+      uint8_t partition,
+      const std::vector<std::unique_ptr<RowPartitions>>& rowPartitions);
+
   // Calculates hashes for 'rows' and returns them in 'hashes'. If
   // 'initNormalizedKeys' is true, the normalized keys are stored below each row
   // in the container. If 'initNormalizedKeys' is false and the table is in
@@ -950,7 +1100,7 @@ class HashTable : public BaseHashTable {
   template <bool isNormailizedKeyMode>
   void insertForJoinWithPrefetch(
       char** groups,
-      uint64_t* hashes,
+      const uint64_t* hashes,
       int32_t numGroups,
       TableInsertPartitionInfo* partitionInfo);
 
@@ -967,7 +1117,13 @@ class HashTable : public BaseHashTable {
   // or distinct mode VectorHashers in a group by hash table. 0 for
   // join build sides.
   int32_t reservePct() const {
-    return isJoinBuild_ ? 0 : 50;
+    return (isJoinBuild_ && allowDuplicates_) ? 0 : 50;
+  }
+
+  // Used to indicate whether it is a HashTable that does not contain duplicate
+  // join keys.
+  bool joinBuildNoDuplicates() const {
+    return isJoinBuild_ && !allowDuplicates_;
   }
 
   // Returns the byte offset of the bucket for 'hash' starting from 'table_'.
@@ -1023,6 +1179,11 @@ class HashTable : public BaseHashTable {
     }
   }
 
+  // Returns the i-th sub-table participating in parallel join build.
+  inline HashTable<ignoreNullKeys>* tableAt(size_t idx) {
+    return idx == 0 ? this : otherTables_[idx - 1].get();
+  }
+
   // We don't want any overlap in the bit ranges used by bucket index and those
   // used by spill partitioning; otherwise because we receive data from only one
   // partition, the overlapped bits would be the same and only a fraction of the
@@ -1035,8 +1196,11 @@ class HashTable : public BaseHashTable {
   // The min table size in row to trigger parallel join table build.
   const uint32_t minTableSizeForParallelJoinBuild_;
 
+  const uint64_t bloomFilterMaxSize_;
+
   int8_t sizeBits_;
   bool isJoinBuild_ = false;
+  bool allowDuplicates_ = true;
 
   // Set at join build time if the table has duplicates, meaning that
   // the join can be cardinality increasing. Atomic for tsan because
diff --git a/velox/exec/HashTableCache.cpp b/velox/exec/HashTableCache.cpp
new file mode 100644
index 00000000000..dcecce4cc7e
--- /dev/null
+++ b/velox/exec/HashTableCache.cpp
@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/HashTableCache.h"
+
+#include <fmt/format.h>
+
+#include "velox/core/QueryCtx.h"
+#include "velox/exec/MemoryReclaimer.h"
+
+namespace facebook::velox::exec {
+
+HashTableCache* HashTableCache::instance() {
+  static HashTableCache instance;
+  return &instance;
+}
+
+std::shared_ptr<HashTableCacheEntry> HashTableCache::get(
+    const std::string& key,
+    const std::string& taskId,
+    core::QueryCtx* queryCtx,
+    ContinueFuture* future) {
+  VELOX_CHECK_NOT_NULL(future, "future parameter must not be null");
+  VELOX_CHECK_NOT_NULL(queryCtx, "queryCtx parameter must not be null");
+
+  std::lock_guard<std::mutex> guard(lock_);
+
+  auto it = tables_.find(key);
+  if (it == tables_.end()) {
+    // No entry exists - create a placeholder for this task to build the table.
+    auto* queryPool = queryCtx->pool();
+    auto entry = std::make_shared<HashTableCacheEntry>(
+        key,
+        taskId,
+        // Add memory reclaimer that is not reclaimable.
+        queryPool->addLeafChild(
+            fmt::format("cached_table_{}", key),
+            /* threadsafe */ true,
+            exec::MemoryReclaimer::create()));
+    tables_.insert({key, entry});
+
+    // Register callback to clean up this cache entry when QueryCtx is
+    // destroyed. This ensures tablePool memory is freed before the query
+    // pool is destroyed.
+    queryCtx->addReleaseCallback(
+        [cacheKey = key]() { HashTableCache::instance()->drop(cacheKey); });
+
+    // Return entry with pool, table will be filled later.
+    return entry;
+  }
+
+  auto& entry = it->second;
+
+  // Check if build is complete
+  if (entry->buildComplete) {
+    return entry;
+  }
+
+  // If this is the builder task, don't wait - all drivers of the builder task
+  // should proceed to build (they coordinate via JoinBridge, not here).
+  if (entry->builderTaskId == taskId) {
+    return entry;
+  }
+
+  auto [promise, _future] =
+      makeVeloxContinuePromiseContract(fmt::format("HashTableCache::{}", key));
+  entry->buildPromises.push_back(std::move(promise));
+  *future = std::move(_future);
+
+  return entry;
+}
+
+void HashTableCache::put(
+    const std::string& key,
+    std::shared_ptr<BaseHashTable> table,
+    bool hasNullKeys) {
+  std::vector<ContinuePromise> promises;
+
+  {
+    std::lock_guard<std::mutex> guard(lock_);
+
+    auto it = tables_.find(key);
+    VELOX_CHECK(
+        it != tables_.end(),
+        "Cache entry for key '{}' must be created by get() before put()",
+        key);
+
+    auto& entry = it->second;
+    VELOX_CHECK(!entry->buildComplete);
+    VELOX_CHECK_NULL(entry->table);
+    // Update the entry with the built table
+    entry->table = std::move(table);
+    entry->hasNullKeys = hasNullKeys;
+    entry->buildComplete = true;
+
+    // Collect promises to notify waiters
+    promises = std::move(entry->buildPromises);
+  }
+
+  // Notify all waiting tasks outside the lock
+  for (auto& promise : promises) {
+    promise.setValue();
+  }
+}
+
+void HashTableCache::drop(const std::string& key) {
+  std::shared_ptr<HashTableCacheEntry> entry;
+  std::vector<ContinuePromise> promises;
+  {
+    std::lock_guard<std::mutex> guard(lock_);
+    auto it = tables_.find(key);
+    if (it != tables_.end()) {
+      entry = std::move(it->second);
+      tables_.erase(it);
+    }
+  }
+
+  // Clear the table outside the lock to free memory before the entry
+  // is destroyed. This ensures the tablePool's memory is released
+  // before any parent pools are destroyed.
+  if (entry) {
+    promises = std::move(entry->buildPromises);
+    entry->table.reset();
+  }
+
+  // Fulfill any pending build promises so waiting tasks are unblocked
+  // rather than hanging forever (e.g., after builder OOM).
+  for (auto& promise : promises) {
+    promise.setValue();
+  }
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/HashTableCache.h b/velox/exec/HashTableCache.h
new file mode 100644
index 00000000000..e1d9717e89e
--- /dev/null
+++ b/velox/exec/HashTableCache.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+
+#include "velox/exec/HashTable.h"
+
+namespace facebook::velox::core {
+class QueryCtx;
+}
+
+namespace facebook::velox::exec {
+
+/// Cached hash table entry with build coordination metadata.
+struct HashTableCacheEntry {
+  HashTableCacheEntry(
+      std::string _cacheKey,
+      std::string _builderTaskId,
+      std::shared_ptr<memory::MemoryPool> _tablePool)
+      : cacheKey(std::move(_cacheKey)),
+        builderTaskId(std::move(_builderTaskId)),
+        tablePool(std::move(_tablePool)) {}
+
+  const std::string cacheKey;
+  const std::string builderTaskId;
+  const std::shared_ptr<memory::MemoryPool> tablePool;
+  std::shared_ptr<BaseHashTable> table;
+  bool hasNullKeys{false};
+  tsan_atomic<bool> buildComplete{false};
+  std::vector<ContinuePromise> buildPromises;
+};
+
+/// Global cache for hash tables shared across tasks within the same query.
+/// First task builds the table, subsequent tasks wait and reuse it.
+class HashTableCache {
+ public:
+  static HashTableCache* instance();
+
+  /// Gets or creates a cache entry. First caller becomes the builder.
+  /// Subsequent callers from different tasks get a future to wait on.
+  /// When a new entry is created, a release callback is registered on queryCtx
+  /// to clean up the entry when the query completes.
+  /// @param future Must be non-null; set if caller needs to wait.
+  std::shared_ptr<HashTableCacheEntry> get(
+      const std::string& key,
+      const std::string& taskId,
+      core::QueryCtx* queryCtx,
+      ContinueFuture* future);
+
+  /// Stores a built hash table and notifies waiting tasks.
+  void put(
+      const std::string& key,
+      std::shared_ptr<BaseHashTable> table,
+      bool hasNullKeys);
+
+  /// Removes a cache entry.
+  void drop(const std::string& key);
+
+ private:
+  HashTableCache() = default;
+
+  std::mutex lock_;
+  std::unordered_map<std::string, std::shared_ptr<HashTableCacheEntry>> tables_;
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/HilbertIndex.h b/velox/exec/HilbertIndex.h
new file mode 100644
index 00000000000..9d8fd096f95
--- /dev/null
+++ b/velox/exec/HilbertIndex.h
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Based off of https://threadlocalmutex.com/?p=126
+
+#pragma once
+
+#include <cstdint>
+#include <limits>
+
+#include "velox/common/base/Exceptions.h"
+
+namespace facebook::velox::exec {
+
+class HilbertIndex {
+ public:
+  /// Construct a Hilber index. If a min value is greater than the max value,
+  /// this will panic.
+  HilbertIndex(float minX, float minY, float maxX, float maxY)
+      : minX_(minX), minY_(minY), maxX_(maxX), maxY_(maxY) {
+    VELOX_CHECK(minX_ <= maxX_);
+    VELOX_CHECK(minY_ <= maxY_);
+
+    float deltaX = maxX_ - minX_;
+    // Subnormals cause numerical instability.
+    // NOLINTNEXTLINE(facebook-hte-FloatingPointMin)
+    if (deltaX < std::numeric_limits<float>::min()) {
+      xScale_ = 0;
+    } else {
+      xScale_ = kHilbertMax / deltaX;
+    }
+
+    float deltaY = maxY_ - minY_;
+    // Subnormals cause numerical instability.
+    // NOLINTNEXTLINE(facebook-hte-FloatingPointMin)
+    if (deltaY < std::numeric_limits<float>::min()) {
+      yScale_ = 0;
+    } else {
+      yScale_ = kHilbertMax / deltaY;
+    }
+  }
+
+  uint32_t inline indexOf(float x, float y) const {
+    if (!(x >= minX_ && x <= maxX_ && y >= minY_ && y <= maxY_)) {
+      // Put things outside the bounds at the end of the Hilbert curve.
+      // Negation handles NaNs
+      return std::numeric_limits<uint32_t>::max();
+    }
+
+    float maxFloat = static_cast<float>(std::numeric_limits<uint32_t>::max());
+
+    uint32_t xInt = static_cast<uint32_t>(
+        std::clamp(xScale_ * (x - minX_), 0.0f, maxFloat));
+    uint32_t yInt = static_cast<uint32_t>(
+        std::clamp(yScale_ * (y - minY_), 0.0f, maxFloat));
+    return discreteIndexOf(xInt, yInt);
+  }
+
+ private:
+  static inline uint32_t interleave(uint32_t x) {
+    x = (x | (x << 8)) & 0x00FF00FF;
+    x = (x | (x << 4)) & 0x0F0F0F0F;
+    x = (x | (x << 2)) & 0x33333333;
+    x = (x | (x << 1)) & 0x55555555;
+    return x;
+  }
+
+  static inline uint32_t discreteIndexOf(uint32_t x, uint32_t y) {
+    uint32_t A, B, C, D;
+
+    // Initial prefix scan round, prime with x and y
+    {
+      uint32_t a = x ^ y;
+      uint32_t b = 0xFFFF ^ a;
+      uint32_t c = 0xFFFF ^ (x | y);
+      uint32_t d = x & (y ^ 0xFFFF);
+
+      A = a | (b >> 1);
+      B = (a >> 1) ^ a;
+
+      C = ((c >> 1) ^ (b & (d >> 1))) ^ c;
+      D = ((a & (c >> 1)) ^ (d >> 1)) ^ d;
+    }
+
+    {
+      uint32_t a = A;
+      uint32_t b = B;
+      uint32_t c = C;
+      uint32_t d = D;
+
+      A = ((a & (a >> 2)) ^ (b & (b >> 2)));
+      B = ((a & (b >> 2)) ^ (b & ((a ^ b) >> 2)));
+
+      C ^= ((a & (c >> 2)) ^ (b & (d >> 2)));
+      D ^= ((b & (c >> 2)) ^ ((a ^ b) & (d >> 2)));
+    }
+
+    {
+      uint32_t a = A;
+      uint32_t b = B;
+      uint32_t c = C;
+      uint32_t d = D;
+
+      A = ((a & (a >> 4)) ^ (b & (b >> 4)));
+      B = ((a & (b >> 4)) ^ (b & ((a ^ b) >> 4)));
+
+      C ^= ((a & (c >> 4)) ^ (b & (d >> 4)));
+      D ^= ((b & (c >> 4)) ^ ((a ^ b) & (d >> 4)));
+    }
+
+    // Final round and projection
+    {
+      uint32_t a = A;
+      uint32_t b = B;
+      uint32_t c = C;
+      uint32_t d = D;
+
+      C ^= ((a & (c >> 8)) ^ (b & (d >> 8)));
+      D ^= ((b & (c >> 8)) ^ ((a ^ b) & (d >> 8)));
+    }
+
+    // Undo transformation prefix scan
+    uint32_t a = C ^ (C >> 1);
+    uint32_t b = D ^ (D >> 1);
+
+    // Recover index bits
+    uint32_t i0 = x ^ y;
+    uint32_t i1 = b | (0xFFFF ^ (i0 | a));
+
+    return (interleave(i1) << 1) | interleave(i0);
+  }
+
+  static const int8_t kHilbertBits = 16;
+  static constexpr float kHilbertMax = (1 << kHilbertBits) - 1;
+
+  const float minX_;
+  const float minY_;
+  const float maxX_;
+  const float maxY_;
+  float xScale_;
+  float yScale_;
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/IndexLookupJoin.cpp b/velox/exec/IndexLookupJoin.cpp
index f0e437ec713..982f86fefbb 100644
--- a/velox/exec/IndexLookupJoin.cpp
+++ b/velox/exec/IndexLookupJoin.cpp
@@ -16,14 +16,52 @@
 #include "velox/exec/IndexLookupJoin.h"
 
 #include "velox/buffer/Buffer.h"
+#include "velox/common/base/RuntimeMetrics.h"
+#include "velox/common/testutil/TestValue.h"
 #include "velox/connectors/Connector.h"
+#include "velox/connectors/ConnectorRegistry.h"
+#include "velox/core/QueryConfig.h"
+#include "velox/exec/OperatorTraceWriter.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/Task.h"
+#include "velox/exec/trace/TraceUtil.h"
 #include "velox/expression/Expr.h"
 #include "velox/expression/FieldReference.h"
+#include "velox/vector/LazyVector.h"
+
+using facebook::velox::common::testutil::TestValue;
 
 namespace facebook::velox::exec {
+using IndexSource = connector::IndexSource;
+
+void IndexLookupJoin::IndexStatWriter::addRuntimeStat(
+    std::string_view name,
+    const RuntimeCounter& value) {
+  auto lockedStats = runtimeStats_.wlock();
+  auto it = lockedStats->find(std::string(name));
+  if (it != lockedStats->end()) {
+    it->second.addValue(value.value);
+  } else {
+    RuntimeMetric metric(value.unit);
+    metric.addValue(value.value);
+    lockedStats->emplace(std::string(name), std::move(metric));
+  }
+}
+
+void IndexLookupJoin::IndexStatWriter::setRuntimeStat(
+    const std::string& name,
+    const RuntimeMetric& metric) {
+  runtimeStats_.wlock()->insert_or_assign(name, metric);
+}
+
+std::unordered_map<std::string, RuntimeMetric>
+IndexLookupJoin::IndexStatWriter::runtimeStats() const {
+  return *runtimeStats_.rlock();
+}
+
 namespace {
+
 void duplicateJoinKeyCheck(
     const std::vector<core::FieldAccessTypedExprPtr>& keys) {
   folly::F14FastSet<std::string> lookupKeyNames;
@@ -60,6 +98,36 @@ void addLookupInputColumn(
   lookupInputNameSet.insert(columnName);
 }
 
+// Normalizes all join conditions into a unified representation by converting
+// equi-join keys (leftKeys/rightKeys) to EqualIndexLookupCondition objects.
+// Each leftKey/rightKey pair is converted to an EqualIndexLookupCondition
+// where:
+// - key: the index column expression (from rightKeys)
+// - value: the probe column expression (from leftKeys)
+// The resulting vector contains the converted equi-join conditions followed by
+// the original joinConditions.
+std::vector<core::IndexLookupConditionPtr> getJoinConditions(
+    const std::vector<core::FieldAccessTypedExprPtr>& leftKeys,
+    const std::vector<core::FieldAccessTypedExprPtr>& rightKeys,
+    const std::vector<core::IndexLookupConditionPtr>& joinConditions) {
+  VELOX_CHECK_EQ(leftKeys.size(), rightKeys.size());
+
+  std::vector<core::IndexLookupConditionPtr> normalizedConditions;
+  normalizedConditions.reserve(leftKeys.size() + joinConditions.size());
+
+  for (size_t i = 0; i < leftKeys.size(); ++i) {
+    normalizedConditions.push_back(
+        std::make_shared<core::EqualIndexLookupCondition>(
+            rightKeys[i], leftKeys[i]));
+  }
+
+  for (const auto& condition : joinConditions) {
+    normalizedConditions.push_back(condition);
+  }
+
+  return normalizedConditions;
+}
+
 // Validates one of between bound, and update the lookup input channels and type
 // to include the corresponding probe input column if the bound is not constant.
 bool addBetweenConditionBound(
@@ -86,8 +154,9 @@ bool addBetweenConditionBound(
         lookupInputChannels,
         lookupInputNameSet);
   } else {
-    VELOX_USER_CHECK(core::TypedExprs::asConstant(typeExpr)->type()->equivalent(
-        *indexKeyType));
+    VELOX_USER_CHECK(
+        core::TypedExprs::asConstant(typeExpr)->type()->equivalent(
+            *indexKeyType));
   }
   return isConstant;
 }
@@ -127,8 +196,102 @@ void addBetweenCondition(
       "At least one of the between condition bounds needs to be not constant: {}",
       betweenCondition->toString());
 }
+
+// Create a row vector wrapper without allocating any buffer.
+// We expect the child vectors to be directly set from probe inputs and join
+// outputs.
+inline RowVectorPtr createRowVector(
+    velox::memory::MemoryPool* pool,
+    const RowTypePtr& type,
+    vector_size_t numRows) {
+  std::vector<VectorPtr> children(type->size(), nullptr);
+  return std::make_shared<RowVector>(
+      pool, type, nullptr, numRows, std::move(children));
+}
+
+// Extracts a runtime stat from the map, removes it, and returns its sum value.
+// Returns 0 if the stat is not found.
+int64_t extractStatSum(
+    std::unordered_map<std::string, RuntimeMetric>& stats,
+    const std::string& name) {
+  auto it = stats.find(name);
+  if (it == stats.end()) {
+    return 0;
+  }
+  const auto value = it->second.sum;
+  stats.erase(it);
+  return value;
+}
+
 } // namespace
 
+// static
+std::vector<OperatorStats> IndexLookupJoin::splitStats(
+    const OperatorStats& combinedStats,
+    const core::PlanNodeId& indexSourceNodeId,
+    const IndexStatWriter& indexSourceStatWriter) {
+  // Create stats for the IndexSource node from the accumulated index source
+  // runtime stats.
+  OperatorStats indexSourceStats;
+  indexSourceStats.operatorId = combinedStats.operatorId;
+  indexSourceStats.pipelineId = combinedStats.pipelineId;
+  indexSourceStats.planNodeId = indexSourceNodeId;
+  indexSourceStats.operatorType = "IndexSource";
+  indexSourceStats.numDrivers = combinedStats.numDrivers;
+
+  // Populate IndexSource runtime stats from the writer's accumulated map.
+  indexSourceStats.runtimeStats = indexSourceStatWriter.runtimeStats();
+
+  // Extract standard operator stats from runtime stats into OperatorStats
+  // fields so they show up in PlanNodeStats (inputRows, outputRows, etc.).
+  indexSourceStats.outputPositions =
+      extractStatSum(indexSourceStats.runtimeStats, "outputPositions");
+  indexSourceStats.outputBytes =
+      extractStatSum(indexSourceStats.runtimeStats, "outputBytes");
+  indexSourceStats.outputVectors =
+      extractStatSum(indexSourceStats.runtimeStats, "outputVectors");
+  indexSourceStats.inputPositions =
+      extractStatSum(indexSourceStats.runtimeStats, "inputPositions");
+  indexSourceStats.inputBytes =
+      extractStatSum(indexSourceStats.runtimeStats, "inputBytes");
+
+  // Populate IndexSource addInputTiming from lookup timing stats recorded by
+  // recordConnectorStats into the writer.
+  const auto lookupCount =
+      extractStatSum(indexSourceStats.runtimeStats, "lookupCount");
+  const auto lookupWallNanos =
+      extractStatSum(indexSourceStats.runtimeStats, "lookupWallNanos");
+  const auto lookupCpuNanos =
+      extractStatSum(indexSourceStats.runtimeStats, "lookupCpuNanos");
+  if (lookupCount > 0) {
+    indexSourceStats.addInputTiming = CpuWallTiming{
+        static_cast<uint64_t>(lookupCount),
+        static_cast<uint64_t>(lookupWallNanos),
+        static_cast<uint64_t>(lookupCpuNanos)};
+  }
+
+  // Create stats for the IndexLookupJoin node.
+  auto joinStats = combinedStats;
+
+  // Remove residual probe-side lazy loading stats from join stats. These
+  // accumulate in every non-scan operator's runtimeStats and are normally
+  // harmless, but splitStats copies combinedStats to create the join node
+  // entry, so we must erase them to avoid exposing them on the join node.
+  joinStats.runtimeStats.erase(std::string(LazyVector::kInputBytes));
+  joinStats.runtimeStats.erase(std::string(LazyVector::kCpuNanos));
+  joinStats.runtimeStats.erase(std::string(LazyVector::kWallNanos));
+
+  // Remove index source stats from join stats. recordConnectorStats copies
+  // these into the operator's runtimeStats (prefixed with "indexSource.") so
+  // they flow through the task-level stats path, but they belong to the
+  // IndexSource node, not the join node.
+  for (const auto& [name, _] : indexSourceStatWriter.runtimeStats()) {
+    joinStats.runtimeStats.erase(fmt::format("indexSource.{}", name));
+  }
+
+  return {std::move(joinStats), std::move(indexSourceStats)};
+}
+
 IndexLookupJoin::IndexLookupJoin(
     int32_t operatorId,
     DriverCtx* driverCtx,
@@ -138,7 +301,8 @@ IndexLookupJoin::IndexLookupJoin(
           joinNode->outputType(),
           operatorId,
           joinNode->id(),
-          "IndexLookupJoin"),
+          OperatorType::kIndexLookupJoin),
+      splitOutput_{driverCtx->queryConfig().indexLookupJoinSplitOutput()},
       // TODO: support to update output batch size with output size stats during
       // the lookup processing.
       outputBatchSize_{
@@ -146,12 +310,15 @@ IndexLookupJoin::IndexLookupJoin(
               ? outputBatchRows()
               : std::numeric_limits<vector_size_t>::max()},
       joinType_{joinNode->joinType()},
-      includeMatchColumn_(joinNode->includeMatchColumn()),
-      numKeys_{joinNode->leftKeys().size()},
+      hasMarker_(joinNode->hasMarker()),
       probeType_{joinNode->sources()[0]->outputType()},
       lookupType_{joinNode->lookupSource()->outputType()},
+      indexSourceNodeId_(joinNode->lookupSource()->id()),
       lookupTableHandle_{joinNode->lookupSource()->tableHandle()},
-      lookupConditions_{joinNode->joinConditions()},
+      joinConditions_{getJoinConditions(
+          joinNode->leftKeys(),
+          joinNode->rightKeys(),
+          joinNode->joinConditions())},
       lookupColumnHandles_(joinNode->lookupSource()->assignments()),
       connectorQueryCtx_{operatorCtx_->createConnectorQueryCtx(
           lookupTableHandle_->connectorId(),
@@ -163,12 +330,29 @@ IndexLookupJoin::IndexLookupJoin(
               operatorType(),
               lookupTableHandle_->connectorId()),
           spillConfig_.has_value() ? &(spillConfig_.value()) : nullptr)},
-      connector_(connector::getConnector(lookupTableHandle_->connectorId())),
+      connector_(
+          connector::ConnectorRegistry::tryGet(
+              *driverCtx->task->queryCtx(),
+              lookupTableHandle_->connectorId())),
       maxNumInputBatches_(
           1 + driverCtx->queryConfig().indexLookupJoinMaxPrefetchBatches()),
-      joinNode_{joinNode} {
+      isIndexSplitCollector_{driverCtx->partitionId == 0},
+      joinNode_{joinNode},
+      indexStatWriter_(std::make_shared<IndexStatWriter>()) {
   duplicateJoinKeyCheck(joinNode_->leftKeys());
   duplicateJoinKeyCheck(joinNode_->rightKeys());
+
+  // Set up the stat splitter to report separate OperatorStats for
+  // IndexLookupJoin and IndexSource nodes. Must be done in the constructor
+  // (not initialize()) because operator stats are copied to task stats before
+  // initialize() is called.
+  stats_.withWLock([&](auto& stats) {
+    stats.setStatSplitter([indexSourceId = indexSourceNodeId_,
+                           indexSourceStatWriter =
+                               indexStatWriter_](const auto& combinedStats) {
+      return splitStats(combinedStats, indexSourceId, *indexSourceStatWriter);
+    });
+  });
 }
 
 void IndexLookupJoin::initialize() {
@@ -184,15 +368,56 @@ void IndexLookupJoin::initialize() {
   initLookupInput();
   initLookupOutput();
   initOutputProjections();
+  initFilter();
 
   indexSource_ = connector_->createIndexSource(
       lookupInputType_,
-      numKeys_,
-      lookupConditions_,
+      joinConditions_,
       lookupOutputType_,
       lookupTableHandle_,
       lookupColumnHandles_,
       connectorQueryCtx_.get());
+
+  if (lookupTableHandle_->needsIndexSplit()) {
+    auto* driverCtx = operatorCtx_->driverCtx();
+    joinBridge_ = driverCtx->task->getIndexLookupJoinBridge(
+        driverCtx->splitGroupId, planNodeId());
+    VELOX_CHECK_NOT_NULL(joinBridge_);
+  }
+
+  createIndexSplitTracer();
+}
+
+void IndexLookupJoin::createIndexSplitTracer() {
+  if (inputTracer_ == nullptr) {
+    return;
+  }
+  const auto& queryConfig = operatorCtx_->driverCtx()->queryConfig();
+  const auto taskTraceDir = exec::trace::getTaskTraceDirectory(
+      queryConfig.queryTraceDir(),
+      operatorCtx_->driverCtx()->task->queryCtx()->queryId(),
+      operatorCtx_->taskId());
+  const auto opTraceDir = exec::trace::getOpTraceDirectory(
+      taskTraceDir,
+      planNodeId(),
+      operatorCtx_->driverCtx()->pipelineId,
+      operatorCtx_->driverCtx()->driverId);
+  indexSplitTracer_ =
+      std::make_unique<trace::OperatorTraceSplitWriter>(this, opTraceDir);
+}
+
+void IndexLookupJoin::traceIndexSplit(const exec::Split& split) {
+  if (FOLLY_UNLIKELY(indexSplitTracer_ != nullptr)) {
+    auto connectorSplit = split.connectorSplit;
+    indexSplitTracer_->write(exec::Split(std::move(connectorSplit)));
+  }
+}
+
+void IndexLookupJoin::closeIndexSplitTracer() {
+  // NOTE: skip calling finish() because the input tracer (via Operator::close)
+  // already wrote the summary file. Both tracers share the same summary path
+  // and finish() would fail with O_EXCL.
+  indexSplitTracer_.reset();
 }
 
 void IndexLookupJoin::ensureInputLoaded(const InputBatchState& batch) {
@@ -215,14 +440,13 @@ void IndexLookupJoin::initLookupInput() {
   VELOX_CHECK(lookupInputChannels_.empty());
 
   std::vector<std::string> lookupInputNames;
-  lookupInputNames.reserve(numKeys_ + lookupConditions_.size());
+  lookupInputNames.reserve(joinConditions_.size());
   std::vector<TypePtr> lookupInputTypes;
-  lookupInputTypes.reserve(numKeys_ + lookupConditions_.size());
-  lookupInputChannels_.reserve(numKeys_ + lookupConditions_.size());
+  lookupInputTypes.reserve(joinConditions_.size());
+  lookupInputChannels_.reserve(joinConditions_.size());
 
   SCOPE_EXIT {
-    VELOX_CHECK_GE(
-        lookupInputNames.size(), numKeys_ + lookupConditions_.size());
+    VELOX_CHECK_GE(lookupInputNames.size(), joinConditions_.size());
     VELOX_CHECK_EQ(lookupInputNames.size(), lookupInputChannels_.size());
     lookupInputType_ =
         ROW(std::move(lookupInputNames), std::move(lookupInputTypes));
@@ -231,25 +455,6 @@ void IndexLookupJoin::initLookupInput() {
 
   folly::F14FastSet<std::string> lookupInputColumnSet;
   folly::F14FastSet<std::string> lookupIndexColumnSet;
-  // List probe columns used in join-equi caluse first.
-  for (auto keyIdx = 0; keyIdx < numKeys_; ++keyIdx) {
-    const auto probeKeyName = joinNode_->leftKeys()[keyIdx]->name();
-    const auto indexKeyName = joinNode_->rightKeys()[keyIdx]->name();
-    VELOX_USER_CHECK_EQ(lookupIndexColumnSet.count(indexKeyName), 0);
-    lookupIndexColumnSet.insert(indexKeyName);
-    const auto probeKeyChannel = probeType_->getChildIdx(probeKeyName);
-    const auto probeKeyType = probeType_->childAt(probeKeyChannel);
-    VELOX_USER_CHECK(
-        lookupType_->findChild(indexKeyName)->equivalent(*probeKeyType));
-    addLookupInputColumn(
-        indexKeyName,
-        probeKeyType,
-        probeKeyChannel,
-        lookupInputNames,
-        lookupInputTypes,
-        lookupInputChannels_,
-        lookupInputColumnSet);
-  }
 
   SCOPE_EXIT {
     VELOX_CHECK(lookupKeyOrConditionHashers_.empty());
@@ -257,19 +462,42 @@ void IndexLookupJoin::initLookupInput() {
     lookupKeyOrConditionHashers_ =
         createVectorHashers(probeType_, lookupInputChannels_);
   };
-  if (lookupConditions_.empty()) {
-    return;
-  }
 
-  for (const auto& lookupCondition : lookupConditions_) {
-    const auto indexKeyName = getColumnName(lookupCondition->key);
+  for (const auto& condition : joinConditions_) {
+    const auto indexKeyName = getColumnName(condition->key);
     VELOX_USER_CHECK_EQ(lookupIndexColumnSet.count(indexKeyName), 0);
     lookupIndexColumnSet.insert(indexKeyName);
     const auto indexKeyType = lookupType_->findChild(indexKeyName);
 
+    if (const auto equalCondition =
+            std::dynamic_pointer_cast<const core::EqualIndexLookupCondition>(
+                condition)) {
+      VELOX_CHECK(
+          !equalCondition->isFilter(),
+          "Constant equal condition in join not supported");
+      // Process as a join condition - value references a probe column.
+      const auto probeKeyName = getColumnName(equalCondition->value);
+      const auto probeKeyChannel = probeType_->getChildIdx(probeKeyName);
+      const auto probeKeyType = probeType_->childAt(probeKeyChannel);
+      VELOX_USER_CHECK(
+          indexKeyType->equivalent(*probeKeyType),
+          "Index key type {} must be equivalent to probe key type {}",
+          indexKeyType->toString(),
+          probeKeyType->toString());
+      addLookupInputColumn(
+          probeKeyName,
+          probeKeyType,
+          probeKeyChannel,
+          lookupInputNames,
+          lookupInputTypes,
+          lookupInputChannels_,
+          lookupInputColumnSet);
+      continue;
+    }
+
     if (const auto inCondition =
             std::dynamic_pointer_cast<const core::InIndexLookupCondition>(
-                lookupCondition)) {
+                condition)) {
       const auto conditionInputName = getColumnName(inCondition->list);
       const auto conditionInputChannel =
           probeType_->getChildIdx(conditionInputName);
@@ -286,11 +514,12 @@ void IndexLookupJoin::initLookupInput() {
           lookupInputTypes,
           lookupInputChannels_,
           lookupInputColumnSet);
+      continue;
     }
 
     if (const auto betweenCondition =
             std::dynamic_pointer_cast<core::BetweenIndexLookupCondition>(
-                lookupCondition)) {
+                condition)) {
       addBetweenCondition(
           betweenCondition,
           probeType_,
@@ -299,21 +528,10 @@ void IndexLookupJoin::initLookupInput() {
           lookupInputTypes,
           lookupInputChannels_,
           lookupInputColumnSet);
+      continue;
     }
 
-    if (const auto equalCondition =
-            std::dynamic_pointer_cast<core::EqualIndexLookupCondition>(
-                lookupCondition)) {
-      // Process an equal join condition by validating that the value is
-      // constant. Equal conditions only support constant values for filtering.
-      VELOX_USER_CHECK(
-          core::TypedExprs::isConstant(equalCondition->value),
-          "Equal condition value must be constant: {}",
-          equalCondition->toString());
-      VELOX_USER_CHECK(core::TypedExprs::asConstant(equalCondition->value)
-                           ->type()
-                           ->equivalent(*indexKeyType));
-    }
+    VELOX_UNSUPPORTED("Unsupported join condition type");
   }
 }
 
@@ -371,15 +589,129 @@ void IndexLookupJoin::initOutputProjections() {
     }
     lookupOutputProjections_.emplace_back(i, outputChannelOpt.value());
   }
-  if (includeMatchColumn_) {
+  if (hasMarker_) {
     matchOutputChannel_ = outputType_->size() - 1;
   }
+
   VELOX_USER_CHECK_EQ(
       probeOutputProjections_.size() + lookupOutputProjections_.size() +
           !!matchOutputChannel_.has_value(),
       outputType_->size());
 }
 
+void IndexLookupJoin::initFilter() {
+  VELOX_CHECK_NULL(filter_);
+
+  if (joinNode_->filter() == nullptr) {
+    return;
+  }
+
+  std::vector<core::TypedExprPtr> filters = {joinNode_->filter()};
+  filter_ =
+      std::make_unique<ExprSet>(std::move(filters), operatorCtx_->execCtx());
+
+  std::vector<std::string> names;
+  std::vector<TypePtr> types;
+  const auto numFields = filter_->expr(0)->distinctFields().size();
+  names.reserve(numFields);
+  types.reserve(numFields);
+
+  column_index_t filterChannel{0};
+  const auto addChannel = [&](column_index_t channel,
+                              const RowTypePtr& inputType,
+                              std::vector<IdentityProjection>& projections) {
+    names.emplace_back(inputType->nameOf(channel));
+    types.emplace_back(inputType->childAt(channel));
+    projections.emplace_back(channel, filterChannel++);
+  };
+
+  for (const auto& field : filter_->expr(0)->distinctFields()) {
+    const auto& name = field->field();
+    auto channel = probeType_->getChildIdxIfExists(name);
+    if (channel.has_value()) {
+      addChannel(channel.value(), probeType_, filterProbeInputProjections_);
+      continue;
+    }
+    channel = lookupOutputType_->getChildIdxIfExists(name);
+    if (channel.has_value()) {
+      addChannel(
+          channel.value(), lookupOutputType_, filterLookupInputProjections_);
+      continue;
+    }
+    VELOX_FAIL(
+        "Index lookup join filter field not found in either left or right input: {}",
+        field->toString());
+  }
+
+  filterInputType_ = ROW(std::move(names), std::move(types));
+}
+
+bool IndexLookupJoin::collectIndexSplits(ContinueFuture* future) {
+  VELOX_CHECK(needsIndexSplits());
+
+  TestValue::adjust(
+      "facebook::velox::exec::IndexLookupJoin::collectIndexSplits", this);
+
+  auto* driverCtx = operatorCtx_->driverCtx();
+  while (true) {
+    exec::Split split;
+    const auto reason = driverCtx->task->getSplitOrFuture(
+        driverCtx->driverId,
+        driverCtx->splitGroupId,
+        indexSourceNodeId_,
+        /*maxPreloadSplits=*/0,
+        /*preload=*/nullptr,
+        split,
+        indexSplitFuture_);
+    if (reason != BlockingReason::kNotBlocked) {
+      *future = std::move(indexSplitFuture_);
+      return false;
+    }
+
+    if (!split.hasConnectorSplit()) {
+      noMoreIndexSplits_ = true;
+      VELOX_CHECK(!hasNoIndexSplits_);
+      VELOX_CHECK_NOT_NULL(joinBridge_);
+      joinBridge_->setIndexSplits(indexSplits_);
+      {
+        auto lockedStats = stats_.wlock();
+        lockedStats->addRuntimeStat(
+            kNumIndexSplits,
+            RuntimeCounter(
+                static_cast<int64_t>(indexSplits_.size()),
+                RuntimeCounter::Unit::kNone));
+      }
+      if (indexSplits_.empty()) {
+        hasNoIndexSplits_ = true;
+      } else {
+        indexSource_->addSplits(std::move(indexSplits_));
+      }
+      return true;
+    }
+
+    traceIndexSplit(split);
+    indexSplits_.push_back(std::move(split.connectorSplit));
+  }
+}
+
+bool IndexLookupJoin::waitForIndexSplits(ContinueFuture* future) {
+  VELOX_CHECK(needsIndexSplits());
+  VELOX_CHECK(!isIndexSplitCollector_);
+  VELOX_CHECK(indexSplits_.empty());
+
+  auto splits = joinBridge_->splitsOrFuture(future);
+  if (future->valid()) {
+    return false;
+  }
+  noMoreIndexSplits_ = true;
+  if (splits.empty()) {
+    hasNoIndexSplits_ = true;
+  } else {
+    indexSource_->addSplits(std::move(splits));
+  }
+  return true;
+}
+
 bool IndexLookupJoin::startDrain() {
   return numInputBatches() != 0;
 }
@@ -388,6 +720,13 @@ bool IndexLookupJoin::needsInput() const {
   if (noMoreInput_ || isDraining()) {
     return false;
   }
+  // Don't accept input until we have collected all splits for index source.
+  if (needsIndexSplits()) {
+    return false;
+  }
+  if (shouldSkipInput()) {
+    return false;
+  }
   if (numInputBatches() >= maxNumInputBatches_) {
     return false;
   }
@@ -402,6 +741,21 @@ bool IndexLookupJoin::needsInput() const {
 }
 
 BlockingReason IndexLookupJoin::isBlocked(ContinueFuture* future) {
+  // Handle split collection for index sources that require splits.
+  if (needsIndexSplits()) {
+    if (isIndexSplitCollector_) {
+      if (!collectIndexSplits(future)) {
+        VELOX_CHECK(future->valid());
+        return BlockingReason::kWaitForSplit;
+      }
+    } else {
+      if (!waitForIndexSplits(future)) {
+        VELOX_CHECK(future->valid());
+        return BlockingReason::kWaitForIndexSplits;
+      }
+    }
+  }
+
   auto& batch = currentInputBatch();
   if (!batch.lookupFuture.valid()) {
     endLookupBlockWait();
@@ -438,16 +792,33 @@ void IndexLookupJoin::endLookupBlockWait() {
 
 void IndexLookupJoin::addInput(RowVectorPtr input) {
   VELOX_CHECK_GT(input->size(), 0);
+  VELOX_CHECK(!shouldSkipInput());
   auto& batch = nextInputBatch();
   VELOX_CHECK_LE(numInputBatches(), maxNumInputBatches_);
   batch.input = std::move(input);
+  // Probe-side lazy loading happens here — stats go to kInputBytes (standard
+  // names) and are transferred to the scan by Driver::processLazyIoStats().
   ensureInputLoaded(batch);
   decodeAndDetectNonNullKeys(batch);
   prepareLookup(batch);
-  startLookup(batch);
+  recordIndexSourceInputStats(batch);
+  // startLookup may trigger index-side lazy loading via mergeLookupResults()
+  // when sync lookups return multiple partial results. Redirect those stats to
+  // index-specific names.
+  {
+    RuntimeStatWriterScopeGuard guard(indexStatWriter_.get());
+    startLookup(batch);
+  }
 }
 
 RowVectorPtr IndexLookupJoin::getOutput() {
+  // Redirect lazy loading stats during getOutput() to index-specific names.
+  // This separates index-side lazy loading (loading lookup result vectors) from
+  // probe-side lazy loading (loading scan input vectors in addInput()), so that
+  // Driver::processLazyIoStats() correctly attributes only probe-side stats to
+  // the scan operator.
+  RuntimeStatWriterScopeGuard guard(indexStatWriter_.get());
+
   SCOPE_EXIT {
     if (numInputBatches() == 0 && isDraining()) {
       finishDrain();
@@ -478,14 +849,8 @@ void IndexLookupJoin::prepareLookup(InputBatchState& batch) {
   const size_t numLookupRows = batch.lookupInputHasNullKeys
       ? batch.nonNullInputRows.countSelected()
       : batch.input->size();
-  if (batch.lookupInput == nullptr) {
-    batch.lookupInput =
-        BaseVector::create<RowVector>(lookupInputType_, numLookupRows, pool());
-  } else {
-    VectorPtr lookupInputVector = std::move(batch.lookupInput);
-    BaseVector::prepareForReuse(lookupInputVector, numLookupRows);
-    batch.lookupInput = std::static_pointer_cast<RowVector>(lookupInputVector);
-  }
+  batch.lookupInput = createRowVector(
+      pool(), lookupInputType_, static_cast<vector_size_t>(numLookupRows));
 
   if (!batch.lookupInputHasNullKeys) {
     for (auto i = 0; i < lookupInputType_->size(); ++i) {
@@ -525,6 +890,110 @@ void IndexLookupJoin::prepareLookup(InputBatchState& batch) {
   }
 }
 
+void IndexLookupJoin::mergeLookupResults(InputBatchState& batch) {
+  VELOX_CHECK(!batch.partialOutputs.empty());
+  VELOX_CHECK_NULL(batch.lookupResult);
+
+  if (batch.partialOutputs.size() == 1) {
+    batch.lookupResult = std::move(batch.partialOutputs[0]);
+    SCOPE_EXIT {
+      VELOX_CHECK_NOT_NULL(batch.lookupResult);
+      batch.partialOutputs.clear();
+    };
+    return;
+  }
+
+  // Calculate total size.
+  vector_size_t totalSize = 0;
+  for (const auto& result : batch.partialOutputs) {
+    totalSize += static_cast<vector_size_t>(result->size());
+  }
+
+  // Merge inputHits buffers.
+  auto mergedInputHits = allocateIndices(totalSize, pool());
+  auto* rawMergedInputHits = mergedInputHits->asMutable<vector_size_t>();
+  vector_size_t offset = 0;
+  for (const auto& result : batch.partialOutputs) {
+    std::memcpy(
+        rawMergedInputHits + offset,
+        result->inputHits->as<const vector_size_t>(),
+        result->size() * sizeof(vector_size_t));
+    offset += static_cast<vector_size_t>(result->size());
+  }
+
+  // Merge output RowVectors.
+  // NOTE: Uncommon path for connectors that do not respect output batch size
+  // properly
+  auto mergedOutput = BaseVector::create<RowVector>(
+      batch.partialOutputs[0]->output->type(), totalSize, pool());
+  vector_size_t outputOffset = 0;
+  for (const auto& result : batch.partialOutputs) {
+    mergedOutput->copy(result->output.get(), outputOffset, 0, result->size());
+    outputOffset += static_cast<vector_size_t>(result->size());
+  }
+
+  batch.lookupResult = std::make_unique<connector::IndexSource::Result>(
+      std::move(mergedInputHits), std::move(mergedOutput));
+  batch.partialOutputs.clear();
+}
+
+bool IndexLookupJoin::getLookupResults(InputBatchState& batch) {
+  VELOX_CHECK_NOT_NULL(batch.lookupInput);
+  VELOX_CHECK_NOT_NULL(batch.lookupResultIter);
+  VELOX_CHECK(!batch.lookupFuture.valid());
+
+  // Result is ready.
+  if (batch.lookupResult != nullptr) {
+    return true;
+  }
+
+  // Fetch the first result if not already fetched.
+  if (batch.lookupResult == nullptr && batch.partialOutputs.empty()) {
+    auto lookupResultOr =
+        batch.lookupResultIter->next(outputBatchSize_, batch.lookupFuture);
+    if (!lookupResultOr.has_value()) {
+      VELOX_CHECK(batch.lookupFuture.valid());
+      return false;
+    }
+    VELOX_CHECK(!batch.lookupFuture.valid());
+
+    // Either splitOutput_ is true, or no more results, or first result is null.
+    if (splitOutput_ || !batch.lookupResultIter->hasNext()) {
+      batch.lookupResult = std::move(lookupResultOr).value();
+      return true;
+    }
+
+    // Otherwise start accumulating results.
+    batch.partialOutputs.push_back(std::move(lookupResultOr).value());
+  }
+
+  // Continue accumulating remaining results when splitOutput_ is false.
+  // This handles both initial accumulation and resuming after async
+  // interruption.
+  VELOX_CHECK(!splitOutput_);
+  VELOX_CHECK(!batch.partialOutputs.empty());
+  VELOX_CHECK_NULL(batch.lookupResult);
+
+  while (batch.lookupResultIter->hasNext()) {
+    auto nextResultOr =
+        batch.lookupResultIter->next(outputBatchSize_, batch.lookupFuture);
+    if (!nextResultOr.has_value()) {
+      // Need to wait for async operation.
+      VELOX_CHECK(batch.lookupFuture.valid());
+      return false;
+    }
+    VELOX_CHECK(!batch.lookupFuture.valid());
+    auto nextResult = std::move(nextResultOr).value();
+    if (nextResult != nullptr) {
+      batch.partialOutputs.push_back(std::move(nextResult));
+    }
+  }
+
+  // All results accumulated, merge them.
+  mergeLookupResults(batch);
+  return true;
+}
+
 void IndexLookupJoin::decodeAndDetectNonNullKeys(InputBatchState& batch) {
   const auto numRows = batch.input->size();
   batch.nonNullInputRows.resize(numRows);
@@ -555,60 +1024,55 @@ void IndexLookupJoin::startLookup(InputBatchState& batch) {
   VELOX_CHECK_NULL(batch.lookupResult);
   VELOX_CHECK(!batch.lookupFuture.valid());
 
-  if (batch.lookupInput->size() == 0) {
-    // No need to start lookup for empty lookup input.
+  if (shouldSkipLookup(batch)) {
     return;
   }
 
-  batch.lookupResultIter = indexSource_->lookup(
-      connector::IndexSource::LookupRequest{batch.lookupInput});
-  auto lookupResultOr =
-      batch.lookupResultIter->next(outputBatchSize_, batch.lookupFuture);
-  if (!lookupResultOr.has_value()) {
-    VELOX_CHECK(batch.lookupFuture.valid());
-    return;
-  }
-  VELOX_CHECK(!batch.lookupFuture.valid());
-  batch.lookupResult = std::move(lookupResultOr).value();
+  // Create the lookup result iterator.
+  batch.lookupResultIter =
+      indexSource_->lookup(connector::IndexSource::Request{batch.lookupInput});
+
+  getLookupResults(batch);
 }
 
 RowVectorPtr IndexLookupJoin::getOutputFromLookupResult(
     InputBatchState& batch) {
   VELOX_CHECK(!batch.empty());
+  VELOX_CHECK(!shouldSkipInput());
   VELOX_CHECK(!batch.lookupFuture.valid() || batch.lookupFuture.isReady());
   batch.lookupFuture = ContinueFuture::makeEmpty();
 
-  if (batch.lookupInput->size() == 0) {
-    if (hasRemainingOutputForLeftJoin(batch)) {
-      return produceRemainingOutputForLeftJoin(batch);
-    }
-    finishInput(batch);
+  if (shouldSkipLookup(batch)) {
+    return produceRemainingOutput(batch);
+  }
+
+  if (!getLookupResults(batch)) {
+    // Async operation pending, need to wait.
+    VELOX_CHECK(batch.lookupFuture.valid());
     return nullptr;
   }
 
-  VELOX_CHECK_NOT_NULL(batch.lookupResultIter);
+  VELOX_CHECK(!batch.lookupFuture.valid());
+  VELOX_CHECK(batch.partialOutputs.empty());
 
   if (batch.lookupResult == nullptr) {
-    auto resultOptional =
-        batch.lookupResultIter->next(outputBatchSize_, batch.lookupFuture);
-    if (!resultOptional.has_value()) {
-      VELOX_CHECK(batch.lookupFuture.valid());
-      return nullptr;
-    }
-    VELOX_CHECK(!batch.lookupFuture.valid());
-
-    batch.lookupResult = std::move(resultOptional).value();
-    if (batch.lookupResult == nullptr) {
-      if (hasRemainingOutputForLeftJoin(batch)) {
-        return produceRemainingOutputForLeftJoin(batch);
-      }
-      finishInput(batch);
-      return nullptr;
+    if (hasRemainingOutputForLeftJoin(batch)) {
+      return produceRemainingOutputForLeftJoin(batch);
     }
+    finishInput(batch);
+    return nullptr;
   }
+
   prepareLookupResult(batch);
   VELOX_CHECK_NOT_NULL(batch.lookupResult);
 
+  if (!applyFilterOnLookupResult(batch)) {
+    VELOX_CHECK_NULL(batch.lookupResult);
+    // All rows in lookup result are filtered out, and fetch next lookup result
+    // batch.
+    return nullptr;
+  }
+
   SCOPE_EXIT {
     maybeFinishLookupResult(batch);
   };
@@ -618,8 +1082,52 @@ RowVectorPtr IndexLookupJoin::getOutputFromLookupResult(
   return produceOutputForLeftJoin(batch);
 }
 
+RowVectorPtr IndexLookupJoin::produceRemainingOutput(InputBatchState& batch) {
+  if (hasRemainingOutputForLeftJoin(batch)) {
+    return produceRemainingOutputForLeftJoin(batch);
+  }
+  finishInput(batch);
+  return nullptr;
+}
+
+void IndexLookupJoin::recordIndexSourceInputStats(
+    const InputBatchState& batch) {
+  if (batch.lookupInput == nullptr || batch.lookupInput->size() == 0) {
+    return;
+  }
+  indexStatWriter_->addRuntimeStat(
+      "inputPositions",
+      RuntimeCounter(
+          static_cast<int64_t>(batch.lookupInput->size()),
+          RuntimeCounter::Unit::kNone));
+  indexStatWriter_->addRuntimeStat(
+      "inputBytes",
+      RuntimeCounter(
+          static_cast<int64_t>(batch.lookupInput->estimateFlatSize()),
+          RuntimeCounter::Unit::kBytes));
+}
+
+void IndexLookupJoin::recordIndexSourceOutputStats(
+    const InputBatchState& batch) {
+  indexStatWriter_->addRuntimeStat(
+      "outputPositions",
+      RuntimeCounter(
+          static_cast<int64_t>(batch.lookupResult->size()),
+          RuntimeCounter::Unit::kNone));
+  indexStatWriter_->addRuntimeStat(
+      "outputBytes",
+      RuntimeCounter(
+          static_cast<int64_t>(batch.lookupResult->output->estimateFlatSize()),
+          RuntimeCounter::Unit::kBytes));
+  indexStatWriter_->addRuntimeStat(
+      "outputVectors", RuntimeCounter(1, RuntimeCounter::Unit::kNone));
+}
+
 void IndexLookupJoin::prepareLookupResult(InputBatchState& batch) {
   VELOX_CHECK_NOT_NULL(batch.lookupResult);
+
+  recordIndexSourceOutputStats(batch);
+
   if (rawLookupInputHitIndices_ != nullptr) {
     return;
   }
@@ -630,28 +1138,8 @@ void IndexLookupJoin::prepareLookupResult(InputBatchState& batch) {
     return;
   }
   VELOX_CHECK_NOT_NULL(batch.nonNullInputMappings);
-  vector_size_t* rawLookupInputHitIndices{nullptr};
-  if (batch.lookupResult->inputHits->isMutable()) {
-    rawLookupInputHitIndices =
-        batch.lookupResult->inputHits->asMutable<vector_size_t>();
-  } else {
-    const auto indicesByteSize =
-        batch.lookupResult->size() * sizeof(vector_size_t);
-    if ((batch.resultInputHitIndices == nullptr) ||
-        !batch.resultInputHitIndices->unique() ||
-        (batch.resultInputHitIndices->capacity() < indicesByteSize)) {
-      batch.resultInputHitIndices = allocateIndices(indicesByteSize, pool());
-    } else {
-      batch.resultInputHitIndices->setSize(indicesByteSize);
-    }
-    rawLookupInputHitIndices =
-        batch.resultInputHitIndices->asMutable<vector_size_t>();
-    std::memcpy(
-        rawLookupInputHitIndices,
-        batch.lookupResult->inputHits->as<const vector_size_t>(),
-        indicesByteSize);
-    batch.lookupResult->inputHits = batch.resultInputHitIndices;
-  }
+  vector_size_t* rawLookupInputHitIndices =
+      batch.ensureInputHitsWritable(pool());
   for (auto i = 0; i < batch.lookupResult->size(); ++i) {
     rawLookupInputHitIndices[i] =
         batch.rawNonNullInputMappings[rawLookupInputHitIndices[i]];
@@ -665,15 +1153,44 @@ void IndexLookupJoin::prepareLookupResult(InputBatchState& batch) {
   rawLookupInputHitIndices_ = rawLookupInputHitIndices;
 }
 
+vector_size_t* IndexLookupJoin::InputBatchState::ensureInputHitsWritable(
+    memory::MemoryPool* pool) {
+  VELOX_CHECK_NOT_NULL(lookupResult);
+  if (lookupResult->inputHits->isMutable()) {
+    return lookupResult->inputHits->asMutable<vector_size_t>();
+  }
+
+  const auto indicesByteSize = lookupResult->size() * sizeof(vector_size_t);
+  if ((resultInputHitIndices == nullptr) ||
+      !resultInputHitIndices->isMutable() ||
+      (resultInputHitIndices->capacity() < indicesByteSize)) {
+    resultInputHitIndices = allocateIndices(indicesByteSize, pool);
+  } else {
+    resultInputHitIndices->setSize(indicesByteSize);
+  }
+  auto* rawLookupInputHitIndices =
+      resultInputHitIndices->asMutable<vector_size_t>();
+  std::memcpy(
+      rawLookupInputHitIndices,
+      lookupResult->inputHits->as<const vector_size_t>(),
+      indicesByteSize);
+  lookupResult->inputHits = resultInputHitIndices;
+  return rawLookupInputHitIndices;
+}
+
 void IndexLookupJoin::maybeFinishLookupResult(InputBatchState& batch) {
   VELOX_CHECK_NOT_NULL(batch.lookupResult);
   if (nextOutputResultRow_ == batch.lookupResult->size()) {
-    batch.lookupResult = nullptr;
-    nextOutputResultRow_ = 0;
-    rawLookupInputHitIndices_ = nullptr;
+    finishLookupResult(batch);
   }
 }
 
+void IndexLookupJoin::finishLookupResult(InputBatchState& batch) {
+  batch.lookupResult = nullptr;
+  nextOutputResultRow_ = 0;
+  rawLookupInputHitIndices_ = nullptr;
+}
+
 bool IndexLookupJoin::hasRemainingOutputForLeftJoin(
     const InputBatchState& batch) const {
   if (joinType_ != core::JoinType::kLeft) {
@@ -687,8 +1204,8 @@ bool IndexLookupJoin::hasRemainingOutputForLeftJoin(
 
 void IndexLookupJoin::finishInput(InputBatchState& batch) {
   VELOX_CHECK_NOT_NULL(batch.input);
-  VELOX_CHECK_EQ(
-      batch.lookupInput->size() == 0, batch.lookupResultIter == nullptr);
+  VELOX_CHECK(!shouldSkipInput());
+  VELOX_CHECK_EQ(shouldSkipLookup(batch), batch.lookupResultIter == nullptr);
   VELOX_CHECK(!batch.lookupFuture.valid());
 
   batch.input = nullptr;
@@ -706,19 +1223,14 @@ void IndexLookupJoin::finishInput(InputBatchState& batch) {
       VELOX_CHECK(!nextBatch.lookupFuture.valid());
     } else {
       VELOX_CHECK_EQ(
-          nextBatch.lookupInput->size() != 0, nextBatch.lookupFuture.valid());
+          !shouldSkipLookup(nextBatch), nextBatch.lookupFuture.valid());
     }
   }
 }
 
-void IndexLookupJoin::prepareOutput(vector_size_t numOutputRows) {
-  if (output_ == nullptr) {
-    output_ = BaseVector::create<RowVector>(outputType_, numOutputRows, pool());
-  } else {
-    VectorPtr output = std::move(output_);
-    BaseVector::prepareForReuse(output, numOutputRows);
-    output_ = std::static_pointer_cast<RowVector>(output);
-  }
+RowVectorPtr IndexLookupJoin::prepareOutput(vector_size_t numOutputRows) {
+  std::vector<VectorPtr> children(outputType_->size(), nullptr);
+  return createRowVector(pool(), outputType_, numOutputRows);
 }
 
 RowVectorPtr IndexLookupJoin::produceOutputForInnerJoin(
@@ -729,22 +1241,22 @@ RowVectorPtr IndexLookupJoin::produceOutputForInnerJoin(
 
   const size_t numOutputRows = std::min<size_t>(
       batch.lookupResult->size() - nextOutputResultRow_, outputBatchSize_);
-  prepareOutput(numOutputRows);
+  auto output = prepareOutput(numOutputRows);
   if (numOutputRows == batch.lookupResult->size()) {
     for (const auto& projection : probeOutputProjections_) {
-      output_->childAt(projection.outputChannel) = BaseVector::wrapInDictionary(
+      output->childAt(projection.outputChannel) = BaseVector::wrapInDictionary(
           nullptr,
           batch.lookupResult->inputHits,
           numOutputRows,
           batch.input->childAt(projection.inputChannel));
     }
     for (const auto& projection : lookupOutputProjections_) {
-      output_->childAt(projection.outputChannel) =
+      output->childAt(projection.outputChannel) =
           batch.lookupResult->output->childAt(projection.inputChannel);
     }
   } else {
     for (const auto& projection : probeOutputProjections_) {
-      output_->childAt(projection.outputChannel) = BaseVector::wrapInDictionary(
+      output->childAt(projection.outputChannel) = BaseVector::wrapInDictionary(
           nullptr,
           Buffer::slice<vector_size_t>(
               batch.lookupResult->inputHits,
@@ -755,14 +1267,14 @@ RowVectorPtr IndexLookupJoin::produceOutputForInnerJoin(
           batch.input->childAt(projection.inputChannel));
     }
     for (const auto& projection : lookupOutputProjections_) {
-      output_->childAt(projection.outputChannel) =
+      output->childAt(projection.outputChannel) =
           batch.lookupResult->output->childAt(projection.inputChannel)
               ->slice(nextOutputResultRow_, numOutputRows);
     }
   }
   nextOutputResultRow_ += numOutputRows;
   VELOX_CHECK_LE(nextOutputResultRow_, batch.lookupResult->size());
-  return output_;
+  return output;
 }
 
 void IndexLookupJoin::fillOutputMatchRows(
@@ -775,7 +1287,7 @@ void IndexLookupJoin::fillOutputMatchRows(
       offset,
       offset + size,
       match ? bits::kNotNull : bits::kNull);
-  if (!includeMatchColumn_) {
+  if (!hasMarker_) {
     return;
   }
   VELOX_CHECK_NOT_NULL(rawMatchValues_);
@@ -803,26 +1315,38 @@ RowVectorPtr IndexLookupJoin::produceOutputForLeftJoin(
   VELOX_CHECK_NOT_NULL(rawLookupOutputNulls_);
   size_t numOutputRows{0};
   size_t totalMissedInputRows{0};
+
+  // Outputs up to 'numMisses' missed (unmatched) input rows into the current
+  // output batch, capped by the remaining output capacity. Updates
+  // numOutputRows, lastProcessedInputRow, and totalMissedInputRows.
+  const auto outputMissedRows = [&](vector_size_t numMisses) INLINE_LAMBDA {
+    const auto numToOutput =
+        std::min<vector_size_t>(numMisses, maxOutputRows - numOutputRows);
+    if (totalMissedInputRows == 0) {
+      ensureMatchColumn(maxOutputRows);
+      fillOutputMatchRows(0, maxOutputRows, true);
+    }
+    fillOutputMatchRows(numOutputRows, numToOutput, false);
+    for (vector_size_t i = 0; i < numToOutput; ++i) {
+      rawProbeOutputRowIndices_[numOutputRows++] = ++lastProcessedInputRow;
+    }
+    totalMissedInputRows += numToOutput;
+  };
+
   for (; numOutputRows < maxOutputRows &&
        nextOutputResultRow_ < batch.lookupResult->size();) {
     VELOX_CHECK_GE(
-        rawLookupInputHitIndices_[nextOutputResultRow_], lastProcessedInputRow);
+        rawLookupInputHitIndices_[nextOutputResultRow_],
+        lastProcessedInputRow,
+        "nextOutputResultRow_ {}, batch.lookupResult->size() {}",
+        nextOutputResultRow_,
+        batch.lookupResult->size());
     const vector_size_t numMissedInputRows =
         rawLookupInputHitIndices_[nextOutputResultRow_] -
         lastProcessedInputRow - 1;
     VELOX_CHECK_GE(numMissedInputRows, -1);
     if (numMissedInputRows > 0) {
-      if (totalMissedInputRows == 0) {
-        ensureMatchColumn(maxOutputRows);
-        fillOutputMatchRows(0, maxOutputRows, true);
-      }
-      const auto numOutputMissedInputRows = std::min<vector_size_t>(
-          numMissedInputRows, maxOutputRows - numOutputRows);
-      fillOutputMatchRows(numOutputRows, numOutputMissedInputRows, false);
-      for (auto i = 0; i < numOutputMissedInputRows; ++i) {
-        rawProbeOutputRowIndices_[numOutputRows++] = ++lastProcessedInputRow;
-      }
-      totalMissedInputRows += numOutputMissedInputRows;
+      outputMissedRows(numMissedInputRows);
       continue;
     }
 
@@ -833,6 +1357,17 @@ RowVectorPtr IndexLookupJoin::produceOutputForLeftJoin(
     ++nextOutputResultRow_;
     ++numOutputRows;
   }
+
+  // If splitOutput_ is false, include any trailing missed input rows.
+  if (!splitOutput_ && nextOutputResultRow_ == batch.lookupResult->size() &&
+      numOutputRows < maxOutputRows) {
+    const vector_size_t numRemainingInputRows =
+        batch.input->size() - lastProcessedInputRow - 1;
+    if (numRemainingInputRows > 0) {
+      outputMissedRows(numRemainingInputRows);
+    }
+  }
+
   VELOX_CHECK(
       numOutputRows == maxOutputRows ||
       nextOutputResultRow_ == batch.lookupResult->size());
@@ -850,24 +1385,24 @@ RowVectorPtr IndexLookupJoin::produceOutputForLeftJoin(
     return nullptr;
   }
 
-  prepareOutput(numOutputRows);
+  auto output = prepareOutput(numOutputRows);
   const auto numInputRows = lastProcessedInputRow - startProcessInputRow + 1;
   if (numInputRows == numOutputRows) {
     if (startProcessInputRow == 0 && numInputRows == batch.input->size()) {
       for (const auto& projection : probeOutputProjections_) {
-        output_->childAt(projection.outputChannel) =
+        output->childAt(projection.outputChannel) =
             batch.input->childAt(projection.inputChannel);
       }
     } else {
       for (const auto& projection : probeOutputProjections_) {
-        output_->childAt(projection.outputChannel) =
+        output->childAt(projection.outputChannel) =
             batch.input->childAt(projection.inputChannel)
                 ->slice(startProcessInputRow, numInputRows);
       }
     }
   } else {
     for (const auto& projection : probeOutputProjections_) {
-      output_->childAt(projection.outputChannel) = BaseVector::wrapInDictionary(
+      output->childAt(projection.outputChannel) = BaseVector::wrapInDictionary(
           nullptr,
           probeOutputRowMapping_,
           numOutputRows,
@@ -877,39 +1412,39 @@ RowVectorPtr IndexLookupJoin::produceOutputForLeftJoin(
 
   if (totalMissedInputRows > 0) {
     for (const auto& projection : lookupOutputProjections_) {
-      output_->childAt(projection.outputChannel) = BaseVector::wrapInDictionary(
+      output->childAt(projection.outputChannel) = BaseVector::wrapInDictionary(
           lookupOutputNulls_,
           lookupOutputRowMapping_,
           numOutputRows,
           batch.lookupResult->output->childAt(projection.inputChannel));
     }
-    if (includeMatchColumn_) {
-      output_->childAt(matchOutputChannel_.value()) = matchColumn_;
+    if (hasMarker_) {
+      output->childAt(matchOutputChannel_.value()) = matchColumn_;
     }
   } else {
     if (startOutputRow == 0 &&
         numOutputRows == batch.lookupResult->output->size()) {
       for (const auto& projection : lookupOutputProjections_) {
-        output_->childAt(projection.outputChannel) =
+        output->childAt(projection.outputChannel) =
             batch.lookupResult->output->childAt(projection.inputChannel);
       }
     } else {
       for (const auto& projection : lookupOutputProjections_) {
-        output_->childAt(projection.outputChannel) =
+        output->childAt(projection.outputChannel) =
             batch.lookupResult->output->childAt(projection.inputChannel)
                 ->slice(startOutputRow, numOutputRows);
       }
     }
-    if (includeMatchColumn_) {
-      output_->childAt(matchOutputChannel_.value()) =
+    if (hasMarker_) {
+      output->childAt(matchOutputChannel_.value()) =
           BaseVector::createConstant(BOOLEAN(), true, numOutputRows, pool());
     }
   }
-  return output_;
+  return output;
 }
 
 void IndexLookupJoin::ensureMatchColumn(vector_size_t maxOutputRows) {
-  if (!includeMatchColumn_) {
+  if (!hasMarker_) {
     return;
   }
   if (matchColumn_) {
@@ -925,7 +1460,7 @@ void IndexLookupJoin::ensureMatchColumn(vector_size_t maxOutputRows) {
 }
 
 void IndexLookupJoin::setMatchColumnSize(vector_size_t numOutputRows) {
-  if (!includeMatchColumn_) {
+  if (!hasMarker_) {
     return;
   }
   VELOX_CHECK_NOT_NULL(matchColumn_);
@@ -945,31 +1480,29 @@ RowVectorPtr IndexLookupJoin::produceRemainingOutputForLeftJoin(
       outputBatchSize_, batch.input->size() - startProcessInputRow);
   VELOX_CHECK_GT(numOutputRows, 0);
   VELOX_CHECK_LE(numOutputRows, batch.input->size());
-  prepareOutput(numOutputRows);
+  auto output = prepareOutput(numOutputRows);
   if (numOutputRows != batch.input->size()) {
     for (const auto& projection : probeOutputProjections_) {
-      output_->childAt(projection.outputChannel) =
+      output->childAt(projection.outputChannel) =
           batch.input->childAt(projection.inputChannel)
               ->slice(startProcessInputRow, numOutputRows);
     }
   } else {
     for (const auto& projection : probeOutputProjections_) {
-      output_->childAt(projection.outputChannel) =
+      output->childAt(projection.outputChannel) =
           batch.input->childAt(projection.inputChannel);
     }
   }
   for (const auto& projection : lookupOutputProjections_) {
-    output_->childAt(projection.outputChannel) = BaseVector::createNullConstant(
-        output_->type()->childAt(projection.outputChannel),
-        numOutputRows,
-        pool());
+    output->childAt(projection.outputChannel) = BaseVector::createNullConstant(
+        outputType_->childAt(projection.outputChannel), numOutputRows, pool());
   }
-  if (includeMatchColumn_) {
-    output_->childAt(matchOutputChannel_.value()) =
+  if (hasMarker_) {
+    output->childAt(matchOutputChannel_.value()) =
         BaseVector::createConstant(BOOLEAN(), false, numOutputRows, pool());
   }
   lastProcessedInputRow_ = lastProcessedInputRow + numOutputRows;
-  return output_;
+  return output;
 }
 
 void IndexLookupJoin::prepareOutputRowMappings(size_t outputBatchSize) {
@@ -1015,6 +1548,106 @@ void IndexLookupJoin::close() {
   lookupOutputNulls_ = nullptr;
 
   Operator::close();
+
+  closeIndexSplitTracer();
+}
+
+bool IndexLookupJoin::applyFilterOnLookupResult(InputBatchState& batch) {
+  VELOX_CHECK_NOT_NULL(batch.lookupResult);
+  if (!filter_) {
+    return true;
+  }
+  if (batch.lookupResult->size() == 0) {
+    return true;
+  }
+
+  const auto numResultRows = batch.lookupResult->size();
+
+  // Prepare filter input vector
+  filterRows_.resize(numResultRows);
+  filterRows_.setAll();
+  filterInput_ = createRowVector(
+      pool(), filterInputType_, static_cast<vector_size_t>(numResultRows));
+
+  // Populate filter input from probe input.
+  for (const auto& projection : filterProbeInputProjections_) {
+    // Get the probe input column and dictionary-wrap it with hit indices
+    filterInput_->childAt(projection.outputChannel) =
+        BaseVector::wrapInDictionary(
+            nullptr,
+            batch.lookupResult->inputHits,
+            numResultRows,
+            batch.input->childAt(projection.inputChannel));
+  }
+
+  // Populate filter input from lookup result.
+  for (const auto& projection : filterLookupInputProjections_) {
+    filterInput_->childAt(projection.outputChannel) =
+        batch.lookupResult->output->childAt(projection.inputChannel);
+  }
+
+  // Evaluate filter
+  filterResult_.resize(1);
+  EvalCtx evalCtx(operatorCtx_->execCtx(), filter_.get(), filterInput_.get());
+  filter_->eval(filterRows_, evalCtx, filterResult_);
+  decodedFilterResult_.decode(*filterResult_[0], filterRows_);
+
+  const auto indicesByteSize = numResultRows * sizeof(vector_size_t);
+  if (!filteredIndices_ || !filteredIndices_->isMutable() ||
+      filteredIndices_->capacity() < indicesByteSize) {
+    filteredIndices_ = allocateIndices(numResultRows, pool());
+  } else {
+    filteredIndices_->setSize(indicesByteSize);
+  }
+  auto* rawFilteredIndices = filteredIndices_->asMutable<vector_size_t>();
+
+  vector_size_t numPassed{0};
+  for (auto i = 0; i < numResultRows; ++i) {
+    if (!decodedFilterResult_.isNullAt(i) &&
+        decodedFilterResult_.valueAt<bool>(i)) {
+      rawFilteredIndices[numPassed++] = i;
+    }
+  }
+
+  if (numPassed == 0) {
+    finishLookupResult(batch);
+    return false;
+  }
+
+  if (numPassed == numResultRows) {
+    return true;
+  }
+
+  // Some rows passed - create filtered lookup result.
+  filteredIndices_->setSize(numPassed * sizeof(vector_size_t));
+
+  // Update the inputHits buffer.
+  auto* rawLookupInputHitIndices = batch.ensureInputHitsWritable(pool());
+  for (auto i = 0; i < numPassed; ++i) {
+    rawLookupInputHitIndices[i] =
+        rawLookupInputHitIndices_[rawFilteredIndices[i]];
+#ifdef NDEBUG
+    if (i > 0) {
+      VELOX_DCHECK_LE(
+          rawLookupInputHitIndices[i - 1], rawLookupInputHitIndices[i]);
+    }
+#endif
+  }
+  batch.lookupResult->inputHits->setSize(numPassed * sizeof(vector_size_t));
+  rawLookupInputHitIndices_ = rawLookupInputHitIndices;
+
+  // Create the filtered result vector.
+  auto filteredOutput = BaseVector::create<RowVector>(
+      batch.lookupResult->output->type(), numPassed, pool());
+  for (auto i = 0; i < batch.lookupResult->output->childrenSize(); ++i) {
+    filteredOutput->childAt(i) = BaseVector::wrapInDictionary(
+        nullptr,
+        filteredIndices_,
+        numPassed,
+        batch.lookupResult->output->childAt(i));
+  }
+  batch.lookupResult->output = std::move(filteredOutput);
+  return true;
 }
 
 void IndexLookupJoin::recordConnectorStats() {
@@ -1023,23 +1656,46 @@ void IndexLookupJoin::recordConnectorStats() {
     // in that case.
     return;
   }
-  auto lockedStats = stats_.wlock();
   auto connectorStats = indexSource_->runtimeStats();
   for (auto& [name, value] : connectorStats) {
-    lockedStats->runtimeStats.erase(name);
-    lockedStats->runtimeStats.emplace(name, std::move(value));
-  }
-  if (connectorStats.count(kConnectorLookupWallTime) != 0) {
-    const CpuWallTiming backgroundTiming{
-        static_cast<uint64_t>(connectorStats[kConnectorLookupWallTime].count),
-        static_cast<uint64_t>(connectorStats[kConnectorLookupWallTime].sum),
-        // NOTE: this might not be accurate as it doesn't include the time
-        // spent inside the index storage client.
-        static_cast<uint64_t>(connectorStats[kConnectorResultPrepareTime].sum) +
-            connectorStats[kClientRequestProcessTime].sum +
-            connectorStats[kClientResultProcessTime].sum};
-    lockedStats->backgroundTiming.clear();
-    lockedStats->backgroundTiming.add(backgroundTiming);
+    indexStatWriter_->setRuntimeStat(name, value);
+  }
+
+  // Record lookup timing into the index stat writer. splitStats extracts these
+  // to populate the IndexSource node's addInputTiming.
+  if (connectorStats.count(std::string(kConnectorLookupWallTime)) != 0) {
+    const auto& lookupWallTime =
+        connectorStats[std::string(kConnectorLookupWallTime)];
+    indexStatWriter_->addRuntimeStat(
+        "lookupCount",
+        RuntimeCounter(
+            static_cast<int64_t>(lookupWallTime.count),
+            RuntimeCounter::Unit::kNone));
+    indexStatWriter_->addRuntimeStat(
+        "lookupWallNanos",
+        RuntimeCounter(
+            static_cast<int64_t>(lookupWallTime.sum),
+            RuntimeCounter::Unit::kNanos));
+    // NOTE: lookupCpuNanos may undercount CPU consumed on prefetch worker
+    // threads or async I/O completion handlers, since CpuWallTimer measures
+    // CPU on the calling thread only.
+    indexStatWriter_->addRuntimeStat(
+        "lookupCpuNanos",
+        RuntimeCounter(
+            static_cast<int64_t>(
+                connectorStats[std::string(kConnectorResultPrepareTime)].sum +
+                connectorStats[std::string(kClientRequestProcessTime)].sum +
+                connectorStats[std::string(kClientResultProcessTime)].sum),
+            RuntimeCounter::Unit::kNanos));
+  }
+  // Copy index source stats into the operator's own runtimeStats so they are
+  // visible through the task-level runtime stats path.
+  const auto indexSourceStats = indexStatWriter_->runtimeStats();
+  {
+    auto lockedStats = stats_.wlock();
+    for (const auto& [name, value] : indexSourceStats) {
+      lockedStats->runtimeStats[fmt::format("indexSource.{}", name)] = value;
+    }
   }
 }
 } // namespace facebook::velox::exec
diff --git a/velox/exec/IndexLookupJoin.h b/velox/exec/IndexLookupJoin.h
index 159324b7bb7..369a6fb7207 100644
--- a/velox/exec/IndexLookupJoin.h
+++ b/velox/exec/IndexLookupJoin.h
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 #pragma once
+
+#include "velox/exec/IndexLookupJoinBridge.h"
 #include "velox/exec/Operator.h"
 #include "velox/exec/VectorHasher.h"
 
@@ -39,7 +41,7 @@ class IndexLookupJoin : public Operator {
   RowVectorPtr getOutput() override;
 
   bool isFinished() override {
-    return noMoreInput_ && (numInputBatches() == 0);
+    return (noMoreInput_ || shouldSkipInput()) && (numInputBatches() == 0);
   }
 
   void close() override;
@@ -47,41 +49,73 @@ class IndexLookupJoin : public Operator {
   /// Defines lookup runtime stats.
   /// The end-to-end walltime in nanoseconds that the index connector do the
   /// lookup.
-  static inline const std::string kConnectorLookupWallTime{
+  static constexpr std::string_view kConnectorLookupWallTime{
       "connectorLookupWallNanos"};
   /// The cpu time in nanoseconds that the index connector process response from
   /// storage client for followup processing by index join operator.
-  static inline const std::string kConnectorResultPrepareTime{
+  static constexpr std::string_view kConnectorResultPrepareTime{
       "connectorResultPrepareCpuNanos"};
   /// The cpu time in nanoseconds that the storage client process request for
   /// remote storage lookup such as encoding the lookup input data into remotr
   /// storage request.
-  static inline const std::string kClientRequestProcessTime{
+  static constexpr std::string_view kClientRequestProcessTime{
       "clientRequestProcessCpuNanos"};
   /// The walltime in nanoseconds that the storage client wait for the lookup
   /// from remote storage.
-  static inline const std::string kClientLookupWaitWallTime{
+  static constexpr std::string_view kClientLookupWaitWallTime{
       "clientlookupWaitWallNanos"};
   /// The number of split requests sent to remote storage for a client lookup
   /// request.
-  static inline const std::string kClientNumStorageRequests{
+  static constexpr std::string_view kClientNumStorageRequests{
       "clientNumStorageRequests"};
   /// The cpu time in nanoseconds that the storage client process response from
   /// remote storage lookup such as decoding the response data into velox
   /// vectors.
-  static inline const std::string kClientResultProcessTime{
+  static constexpr std::string_view kClientResultProcessTime{
       "clientResultProcessCpuNanos"};
   /// The byte size of the raw result received from the remote storage lookup.
-  static inline const std::string kClientLookupResultRawSize{
+  static constexpr std::string_view kClientLookupResultRawSize{
       "clientLookupResultRawSize"};
   /// The byte size of the result data in velox vectors that are decoded from
   /// the raw data received from the remote storage lookup.
-  static inline const std::string kClientLookupResultSize{
+  static constexpr std::string_view kClientLookupResultSize{
       "clientLookupResultSize"};
+  /// The number of lookup results received from remote storage with error.
+  static constexpr std::string_view kClientNumErrorResults{
+      "clientNumErrorResults"};
+  /// The number of index splits provided for index lookup.
+  static constexpr std::string_view kNumIndexSplits{"numIndexSplits"};
 
  private:
-  using LookupResultIter = connector::IndexSource::LookupResultIterator;
-  using LookupResult = connector::IndexSource::LookupResult;
+  // Intercepts runtime stats emitted during index-side operations (getOutput /
+  // startLookup) and accumulates them into a local map, separating them from
+  // probe-side stats so Driver::processLazyIoStats() correctly attributes
+  // only probe-side stats to the scan operator. Held via shared_ptr so the
+  // stat splitter lambda can outlive the operator and read the final stats.
+  class IndexStatWriter : public BaseRuntimeStatWriter {
+   public:
+    void addRuntimeStat(std::string_view name, const RuntimeCounter& value)
+        override;
+
+    // Sets a runtime metric in the index source stats map. Thread-safe.
+    void setRuntimeStat(const std::string& name, const RuntimeMetric& metric);
+
+    // Returns a snapshot of the accumulated index source runtime stats.
+    std::unordered_map<std::string, RuntimeMetric> runtimeStats() const;
+
+   private:
+    folly::Synchronized<std::unordered_map<std::string, RuntimeMetric>>
+        runtimeStats_;
+  };
+
+  // Produces separate OperatorStats for IndexLookupJoin and IndexSource nodes.
+  static std::vector<OperatorStats> splitStats(
+      const OperatorStats& combinedStats,
+      const core::PlanNodeId& indexSourceNodeId,
+      const IndexStatWriter& indexSourceStatWriter);
+
+  using ResultIterator = connector::IndexSource::ResultIterator;
+  using Result = connector::IndexSource::Result;
 
   // Contains the state of an input batch processing.
   struct InputBatchState {
@@ -100,14 +134,14 @@ class IndexLookupJoin : public Operator {
     // The reusable vector projected from 'input' as index lookup input.
     RowVectorPtr lookupInput;
     // Used to fetch lookup results for an input batch.
-    std::shared_ptr<LookupResultIter> lookupResultIter;
+    std::shared_ptr<ResultIterator> lookupResultIter;
     // Used for synchronization with the async fetch result from index source
     // through 'lookupResultIter'.
     ContinueFuture lookupFuture;
     // Used to store the lookup result fetched from 'lookupResultIter' for
     // output processing. We might split the output result into multiple output
     // batches based on the operator's output batch size limit.
-    std::unique_ptr<LookupResult> lookupResult;
+    std::unique_ptr<Result> lookupResult;
     // Specifies the indices of input row in 'input' that have matches in
     // 'output' from 'lookupResult'. This is only used in case
     // 'lookupInputHasNullKeys' is true in which 'inputHits' in 'lookupResult'
@@ -117,6 +151,10 @@ class IndexLookupJoin : public Operator {
     // row in 'input' through the mapping specified by 'nonNullInputMappings'.
     // The redirect input hit indices are stored in 'resultInputHitIndices'.
     BufferPtr resultInputHitIndices;
+    // When splitOutput_ is false, this tracks partially accumulated results
+    // that are waiting for async operations to complete before continuing
+    // accumulation.
+    std::vector<std::unique_ptr<Result>> partialOutputs;
 
     InputBatchState() : lookupFuture(ContinueFuture::makeEmpty()) {}
 
@@ -125,12 +163,20 @@ class IndexLookupJoin : public Operator {
       lookupResultIter = nullptr;
       lookupFuture = ContinueFuture::makeEmpty();
       lookupResult = nullptr;
+      partialOutputs.clear();
     }
 
     // Indicates if this input batch is empty.
     bool empty() const {
       return input == nullptr;
     }
+
+    // Ensures that the lookup result's inputHits buffer is writable and returns
+    // a mutable pointer. If the buffer is already mutable, returns it directly.
+    // Otherwise, creates a new writable buffer by copying the existing data and
+    // returns a pointer to the new buffer. This is needed when filters or null
+    // key handling requires modifying the input hit indices.
+    vector_size_t* ensureInputHitsWritable(memory::MemoryPool* pool);
   };
 
   void initInputBatches();
@@ -138,17 +184,51 @@ class IndexLookupJoin : public Operator {
   void initLookupInput();
   void initLookupOutput();
   void initOutputProjections();
+  void initFilter();
+
+  // Collects splits for the index source until no more splits signal is
+  // received. Returns true if all splits have been collected and the index
+  // source is ready. Returns false if we are still waiting for splits.
+  // Only called by the split collector operator (partitionId == 0).
+  bool collectIndexSplits(ContinueFuture* future);
+
+  // Waits for the split collector to share index splits via the bridge.
+  // Returns true if splits are available and have been added to the index
+  // source. Returns false if we are still waiting for splits.
+  bool waitForIndexSplits(ContinueFuture* future);
+
+  // Applies the join filter directly on the lookup result, updating the
+  // lookup result to only include rows that pass the filter. Returns true if
+  // some rows passed the filter, otherwise false.
+  bool applyFilterOnLookupResult(InputBatchState& batch);
+
   void ensureInputLoaded(const InputBatchState& batch);
   // Prepare index source lookup for a given 'input_'.
   void prepareLookup(InputBatchState& batch);
   void startLookup(InputBatchState& batch);
 
+  // Helper function to merge batch.partialOutputs into a single
+  // batch.lookupResult. This is used when splitOutput_ is false to ensure all
+  // results from an iterator are combined into one output batch.
+  void mergeLookupResults(InputBatchState& batch);
+  // Helper function to get all lookup results. Fetches the first result if not
+  // already fetched, and when splitOutput_ is false, accumulates all remaining
+  // results into a single batch. Handles both initial lookup and resuming
+  // accumulation after async interruption. Returns true if results are ready,
+  // false if an async operation is pending.
+  bool getLookupResults(InputBatchState& batch);
+
   void startLookupBlockWait();
   void endLookupBlockWait();
 
   RowVectorPtr getOutputFromLookupResult(InputBatchState& batch);
   RowVectorPtr produceOutputForInnerJoin(const InputBatchState& batch);
   RowVectorPtr produceOutputForLeftJoin(const InputBatchState& batch);
+  // Handles production of remaining output after lookup result processing is
+  // complete. For left joins, this ensures unmatched rows from the probe side
+  // are included in the output with null values for lookup columns. For inner
+  // joins, this simply finishes the input batch.
+  RowVectorPtr produceRemainingOutput(InputBatchState& batch);
   // Produces output for the remaining input rows that has no matches from the
   // lookup at the end of current input batch processing.
   RowVectorPtr produceRemainingOutputForLeftJoin(const InputBatchState& batch);
@@ -160,8 +240,10 @@ class IndexLookupJoin : public Operator {
   bool hasRemainingOutputForLeftJoin(const InputBatchState& batch) const;
 
   // Checks if we have finished processing the current 'lookupResult_'. If so,
-  // we reset 'lookupResult_' and corresponding processing state.
+  // call 'finishLookupResult' to reset 'lookupResult_' and corresponding
+  // processing state.
   void maybeFinishLookupResult(InputBatchState& batch);
+  void finishLookupResult(InputBatchState& batch);
 
   // Invoked after finished processing the current 'input_' batch. The function
   // resets the input batch and the lookup result states.
@@ -172,8 +254,9 @@ class IndexLookupJoin : public Operator {
   // for output rows without lookup matches.
   void prepareOutputRowMappings(size_t outputBatchSize);
 
-  // Prepare 'output_' for the next output batch with size of 'numOutputRows'.
-  void prepareOutput(vector_size_t numOutputRows);
+  // Creates a new output RowVector with 'numOutputRows' rows and nullptr
+  // children. Callers populate the children before returning it.
+  RowVectorPtr prepareOutput(vector_size_t numOutputRows);
 
   // Invoked to ensure the match column is created to store the output match
   // result for the left join.
@@ -196,6 +279,12 @@ class IndexLookupJoin : public Operator {
   // input rows.
   void prepareLookupResult(InputBatchState& batch);
 
+  // Records index source input stats from the lookup keys.
+  void recordIndexSourceInputStats(const InputBatchState& batch);
+
+  // Records index source output stats from the lookup result.
+  void recordIndexSourceOutputStats(const InputBatchState& batch);
+
   // Invoked at operator close to record the lookup stats.
   void recordConnectorStats();
 
@@ -205,6 +294,25 @@ class IndexLookupJoin : public Operator {
     return maxNumInputBatches_ > 1;
   }
 
+  // Returns true if the index source needs splits and we haven't received the
+  // no-more-splits signal yet.
+  bool needsIndexSplits() const {
+    return lookupTableHandle_->needsIndexSplit() && !noMoreIndexSplits_;
+  }
+
+  // Returns true if input processing can be skipped entirely. This is the case
+  // for INNER JOIN when there are no index splits — every probe row will be
+  // discarded since there can be no matches.
+  bool shouldSkipInput() const {
+    return hasNoIndexSplits_ && joinType_ == core::JoinType::kInner;
+  }
+
+  // Returns true if lookup should be skipped for the given batch, either
+  // because the index source has no splits or because all probe keys are null.
+  bool shouldSkipLookup(const InputBatchState& batch) const {
+    return hasNoIndexSplits_ || batch.lookupInput->size() == 0;
+  }
+
   // Returns the number of input batches to process.
   size_t numInputBatches() const {
     VELOX_CHECK_LE(startBatchIndex_, endBatchIndex_);
@@ -228,21 +336,29 @@ class IndexLookupJoin : public Operator {
     return inputBatches_[startBatchIndex_ % maxNumInputBatches_];
   }
 
+  // If true, allows one input row to produce multiple output rows.
+  // If false, enforces one-to-one mapping.
+  const bool splitOutput_;
   // Maximum number of rows in the output batch.
   const vector_size_t outputBatchSize_;
   // Type of join.
   const core::JoinType joinType_;
-  const bool includeMatchColumn_;
-  const size_t numKeys_;
+  const bool hasMarker_;
   const RowTypePtr probeType_;
   const RowTypePtr lookupType_;
+  // The plan node id of the lookup source (index source).
+  const core::PlanNodeId indexSourceNodeId_;
   const connector::ConnectorTableHandlePtr lookupTableHandle_;
-  const std::vector<core::IndexLookupConditionPtr> lookupConditions_;
+  const std::vector<core::IndexLookupConditionPtr> joinConditions_;
   const connector::ColumnHandleMap lookupColumnHandles_;
   const std::shared_ptr<connector::ConnectorQueryCtx> connectorQueryCtx_;
   const std::shared_ptr<connector::Connector> connector_;
   const size_t maxNumInputBatches_;
 
+  // True if this operator (partitionId == 0) is responsible for collecting
+  // index splits from the task and sharing them via the bridge.
+  const bool isIndexSplitCollector_;
+
   // The lookup join plan node used to initialize this operator and reset after
   // that.
   std::shared_ptr<const core::IndexLookupJoinNode> joinNode_;
@@ -300,13 +416,64 @@ class IndexLookupJoin : public Operator {
   BufferPtr lookupOutputNulls_;
   uint64_t* rawLookupOutputNulls_{nullptr};
 
-  // The reusable output vector for the join output.
-  RowVectorPtr output_;
+  // Join filter.
+  std::unique_ptr<ExprSet> filter_;
+
+  // Join filter input type.
+  RowTypePtr filterInputType_;
+
+  // Maps probe-side input channels to channels in 'filterInputType_'.
+  std::vector<IdentityProjection> filterProbeInputProjections_;
+  // Maps lookup-side input channels to channels in 'filterInputType_',
+  std::vector<IdentityProjection> filterLookupInputProjections_;
+
+  // Reusable memory for filter evaluations.
+  RowVectorPtr filterInput_;
+  SelectivityVector filterRows_;
+  std::vector<VectorPtr> filterResult_;
+  DecodedVector decodedFilterResult_;
+  BufferPtr filteredIndices_;
+
   FlatVectorPtr<bool> matchColumn_{nullptr};
   uint64_t* rawMatchValues_{nullptr};
 
   // The start time of the current lookup driver block wait, and reset after the
   // driver wait completes.
   std::optional<size_t> blockWaitStartNs_;
+
+  // The bridge for sharing index splits across operators in the same pipeline.
+  // Null if the index source does not need splits.
+  std::shared_ptr<IndexLookupJoinBridge> joinBridge_;
+
+  // Split collection state for index sources that require splits.
+  // True if we have received the no-more-splits signal for the index source.
+  bool noMoreIndexSplits_{false};
+  // True if the index source received zero splits (e.g., partition pruning
+  // eliminated all index partitions). When set, lookups are skipped entirely.
+  bool hasNoIndexSplits_{false};
+  // The future to wait for the next index split.
+  ContinueFuture indexSplitFuture_;
+  // The collected splits for the index source. It is passed to index source
+  // after the no-more-splits signal is received (i.e., 'noMoreIndexSplits_' is
+  // true).
+  std::vector<std::shared_ptr<connector::ConnectorSplit>> indexSplits_;
+
+  // Traces the index splits received by this operator for replay. Set when
+  // tracing is enabled for this operator.
+  std::unique_ptr<trace::TraceSplitWriter> indexSplitTracer_;
+
+  // Creates the index split tracer if input tracing is enabled.
+  void createIndexSplitTracer();
+
+  // Traces the given index split for replay.
+  void traceIndexSplit(const exec::Split& split);
+
+  // Closes and resets the index split tracer.
+  void closeIndexSplitTracer();
+
+  // Intercepts and accumulates index source runtime stats. Held via
+  // shared_ptr so the stat splitter lambda can read the final stats after the
+  // operator is destroyed.
+  std::shared_ptr<IndexStatWriter> indexStatWriter_;
 };
 } // namespace facebook::velox::exec
diff --git a/velox/exec/IndexLookupJoinBridge.cpp b/velox/exec/IndexLookupJoinBridge.cpp
new file mode 100644
index 00000000000..a00a7159e8a
--- /dev/null
+++ b/velox/exec/IndexLookupJoinBridge.cpp
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/exec/IndexLookupJoinBridge.h"
+
+namespace facebook::velox::exec {
+
+void IndexLookupJoinBridge::setIndexSplits(
+    std::vector<std::shared_ptr<connector::ConnectorSplit>> splits) {
+  std::vector<ContinuePromise> promises;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    VELOX_CHECK(started_, "Bridge must be started before setting index splits");
+    VELOX_CHECK(
+        !cancelled_, "Setting index splits after the bridge is cancelled");
+    VELOX_CHECK(!splitsSet_, "setIndexSplits must be called only once");
+    splitsSet_ = true;
+    indexSplits_ = std::move(splits);
+    promises = std::move(promises_);
+  }
+  notify(std::move(promises));
+}
+
+std::vector<std::shared_ptr<connector::ConnectorSplit>>
+IndexLookupJoinBridge::splitsOrFuture(ContinueFuture* future) {
+  std::lock_guard<std::mutex> l(mutex_);
+  VELOX_CHECK(
+      !cancelled_, "Getting index splits after the bridge is cancelled");
+  if (splitsSet_) {
+    return indexSplits_;
+  }
+  promises_.emplace_back("IndexLookupJoinBridge::splitsOrFuture");
+  *future = promises_.back().getSemiFuture();
+  return {};
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/IndexLookupJoinBridge.h b/velox/exec/IndexLookupJoinBridge.h
new file mode 100644
index 00000000000..b085c477918
--- /dev/null
+++ b/velox/exec/IndexLookupJoinBridge.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/connectors/Connector.h"
+#include "velox/exec/JoinBridge.h"
+
+namespace facebook::velox::exec {
+
+/// Coordinates sharing of index splits among multiple IndexLookupJoin operators
+/// in the same pipeline. The leader operator (driverId 0) collects all splits
+/// from the task and publishes them via setIndexSplits(). Follower operators
+/// wait for splits via splitsOrFuture().
+class IndexLookupJoinBridge : public JoinBridge {
+ public:
+  /// Called by the leader operator after collecting all index splits. Stores
+  /// the splits and notifies all waiting followers. Must be called only once.
+  /// May be called with an empty vector (e.g., when partition pruning
+  /// eliminates all index partitions for a split group).
+  void setIndexSplits(
+      std::vector<std::shared_ptr<connector::ConnectorSplit>> splits);
+
+  /// Returns the index splits if the leader has called setIndexSplits(),
+  /// otherwise sets 'future' and returns an empty vector. The caller should
+  /// check future->valid() to distinguish "not ready" (future set) from
+  /// "ready with 0 splits" (future not set, empty vector).
+  std::vector<std::shared_ptr<connector::ConnectorSplit>> splitsOrFuture(
+      ContinueFuture* future);
+
+ private:
+  bool splitsSet_{false};
+  std::vector<std::shared_ptr<connector::ConnectorSplit>> indexSplits_;
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/Limit.cpp b/velox/exec/Limit.cpp
index 0ed5bbf7386..39bcf5ffdb8 100644
--- a/velox/exec/Limit.cpp
+++ b/velox/exec/Limit.cpp
@@ -15,6 +15,8 @@
  */
 #include "velox/exec/Limit.h"
 
+#include "velox/exec/OperatorType.h"
+
 namespace facebook::velox::exec {
 Limit::Limit(
     int32_t operatorId,
@@ -25,7 +27,7 @@ Limit::Limit(
           limitNode->outputType(),
           operatorId,
           limitNode->id(),
-          "Limit"),
+          OperatorType::kLimit),
       remainingOffset_{limitNode->offset()},
       remainingLimit_{limitNode->count()} {
   isIdentityProjection_ = true;
diff --git a/velox/exec/LocalPartition.cpp b/velox/exec/LocalPartition.cpp
index 1fbce8b8960..eb6eb81add3 100644
--- a/velox/exec/LocalPartition.cpp
+++ b/velox/exec/LocalPartition.cpp
@@ -15,6 +15,8 @@
  */
 
 #include "velox/exec/LocalPartition.h"
+#include "velox/common/Casts.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/Task.h"
 #include "velox/vector/EncodedVectorCopy.h"
 
@@ -263,7 +265,7 @@ LocalExchange::LocalExchange(
           std::move(outputType),
           operatorId,
           planNodeId,
-          "LocalExchange"),
+          OperatorType::kLocalExchange),
       partition_{partition},
       queue_{operatorCtx_->task()->getLocalExchangeQueue(
           ctx->splitGroupId,
@@ -332,7 +334,7 @@ LocalPartition::LocalPartition(
           planNode->outputType(),
           operatorId,
           planNode->id(),
-          "LocalPartition"),
+          OperatorType::kLocalPartition),
       queues_{
           ctx->task->getLocalExchangeQueues(ctx->splitGroupId, planNode->id())},
       numPartitions_{queues_.size()},
@@ -420,6 +422,7 @@ RowVectorPtr LocalPartition::wrapChildren(
 void LocalPartition::copy(
     const RowVectorPtr& input,
     const folly::Range<const BaseVector::CopyRange*>& ranges,
+    const size_t partition,
     VectorPtr& target) {
   if (ranges.empty()) {
     return;
@@ -432,57 +435,153 @@ void LocalPartition::copy(
   }
 
   if (!target) {
-    target = BaseVector::create<RowVector>(outputType_, 0, pool());
+    target = getOrCreateVector(partition);
   }
   target->resize(target->size() + ranges.size());
   target->copyRanges(input.get(), ranges);
 }
 
-RowVectorPtr LocalPartition::processPartition(
+VectorPtr LocalPartition::getOrCreateVector(const size_t partition) {
+  auto reusable = queues_[partition]->getVector();
+  if (reusable) {
+    VELOX_CHECK_EQ(reusable->type(), outputType_);
+    reusable->unsafeResize(0);
+    for (auto i = 0; i < reusable->childrenSize(); ++i) {
+      reusable->childAt(i) = nullptr;
+    }
+    return reusable;
+  } else {
+    return BaseVector::create<RowVector>(outputType_, 0, pool());
+  }
+}
+
+void LocalPartition::populatePartitionBuffer(
     const RowVectorPtr& input,
-    vector_size_t size,
-    int partition,
-    const BufferPtr& indices,
-    const vector_size_t* rawIndices) {
+    const vector_size_t numPartitionRows,
+    const size_t partition,
+    const vector_size_t* rawIndices,
+    uint64_t& totalPartitionBufferSizeExcludingString,
+    uint64_t& totalPartitionStringBufferSize) {
+  VELOX_CHECK_GT(singlePartitionBufferSize_, 0);
+  copyRanges_.resize(numPartitionRows);
+
+  auto& partitionBuffer = partitionBuffers_[partition];
+  auto targetIndex = 0;
+  if (partitionBuffer) {
+    targetIndex = partitionBuffer->size();
+  }
+  for (int i = 0; i < numPartitionRows; i++) {
+    copyRanges_[i] = {rawIndices[i], targetIndex, 1};
+    targetIndex++;
+  }
+
+  copy(input, copyRanges_, partition, partitionBuffer);
+
+  if (partitionBuffer) {
+    uint64_t stringBufferSize{0};
+    auto totalSize = partitionBuffer->retainedSize(stringBufferSize);
+    totalPartitionBufferSizeExcludingString += totalSize - stringBufferSize;
+    totalPartitionStringBufferSize += stringBufferSize;
+  }
+}
+
+RowVectorPtr LocalPartition::createPartition(
+    const RowVectorPtr& input,
+    const vector_size_t numPartitionRows,
+    const size_t partition,
+    const BufferPtr& indices) {
   RowVectorPtr partitionData{nullptr};
   if (singlePartitionBufferSize_ > 0) {
-    if (partitionBuffers_.empty()) {
-      partitionBuffers_.resize(numPartitions_);
-    }
-    if (copyRanges_.size() < size) {
-      copyRanges_.resize(size);
-    }
-
     auto& partitionBuffer = partitionBuffers_[partition];
-    auto targetIndex = 0;
     if (partitionBuffer) {
-      targetIndex = partitionBuffer->size();
-    }
-    for (int i = 0; i < size; i++) {
-      copyRanges_[i] = {rawIndices[i], targetIndex, 1};
-      targetIndex++;
+      partitionData =
+          checkedPointerCast<RowVector, BaseVector>(partitionBuffer);
+      partitionBuffers_[partition] = nullptr;
     }
+  } else if (numPartitionRows > 0) {
+    partitionData = wrapChildren(
+        input, numPartitionRows, indices, queues_[partition]->getVector());
+  }
+  return partitionData;
+}
 
-    copy(
-        input,
-        folly::Range{copyRanges_.data(), static_cast<size_t>(size)},
-        partitionBuffer);
-
-    if (partitionBuffer &&
-        partitionBuffer->retainedSize() >= singlePartitionBufferSize_) {
-      partitionData = std::dynamic_pointer_cast<RowVector>(partitionBuffer);
-      VELOX_CHECK(partitionData);
-      partitionBuffers_[partition] = nullptr;
+void LocalPartition::populateAndEnqueuePartitions(
+    RowVectorPtr input,
+    const std::vector<vector_size_t>& numRowsPerPartition,
+    const std::vector<BufferPtr>& indexBuffers,
+    const std::vector<vector_size_t*>& rawIndicesBuffers) {
+  uint64_t totalPartitionBufferSizeExcludingString = 0;
+  uint64_t totalPartitionStringBufferSize = 0;
+  uint16_t nonEmptyPartitionCount = 0;
+
+  // Populate partition buffers if in buffer mode.
+  if (singlePartitionBufferSize_ > 0) {
+    if (partitionBuffers_.empty()) {
+      partitionBuffers_.resize(numPartitions_);
+    }
+    for (auto partition = 0; partition < numPartitions_; partition++) {
+      populatePartitionBuffer(
+          input,
+          numRowsPerPartition[partition],
+          partition,
+          rawIndicesBuffers[partition],
+          totalPartitionBufferSizeExcludingString,
+          totalPartitionStringBufferSize);
+      if (partitionBuffers_[partition]) {
+        nonEmptyPartitionCount++;
+      }
     }
   } else {
-    partitionData =
-        wrapChildren(input, size, indices, queues_[partition]->getVector());
+    nonEmptyPartitionCount = numPartitions_ -
+        std::count(numRowsPerPartition.begin(), numRowsPerPartition.end(), 0);
+  }
+  VELOX_CHECK_GT(
+      nonEmptyPartitionCount,
+      0,
+      "Input rows should be assigned to at least one partition");
+
+  // Calculate the partition buffer size across all partitions with amortized
+  // string buffer sizes.
+  auto balancedTotalPartitionBufferSize =
+      totalPartitionBufferSizeExcludingString +
+      (totalPartitionStringBufferSize / nonEmptyPartitionCount);
+  auto inputRetainedSize = input->retainedSize();
+
+  // Enqueue all partitions if one of the following conditions is met:
+  // 1. This operator is not in buffer mode.
+  // 2. This operator is in buffer mode and the total buffer size across all
+  // partitions exceeds 'singlePartitionBufferSize_ * numPartitions_'.
+  if (singlePartitionBufferSize_ == 0 ||
+      balancedTotalPartitionBufferSize >=
+          singlePartitionBufferSize_ * numPartitions_) {
+    auto perPartitionAmortizedSize =
+        (singlePartitionBufferSize_ > 0 ? balancedTotalPartitionBufferSize
+                                        : inputRetainedSize) /
+        nonEmptyPartitionCount;
+    for (auto partition = 0; partition < numPartitions_; partition++) {
+      auto partitionSize = numRowsPerPartition[partition];
+      auto partitionData = createPartition(
+          input, partitionSize, partition, indexBuffers[partition]);
+      if (!partitionData) {
+        continue;
+      }
+
+      ContinueFuture future;
+      auto reason = queues_[partition]->enqueue(
+          std::move(partitionData), perPartitionAmortizedSize, &future);
+      if (reason != BlockingReason::kNotBlocked) {
+        blockingReasons_.push_back(reason);
+        futures_.push_back(std::move(future));
+      }
+    }
   }
-  return partitionData;
 }
 
 void LocalPartition::addInput(RowVectorPtr input) {
   prepareForInput(input);
+  if (input->size() == 0) {
+    return;
+  }
 
   const auto singlePartition = numPartitions_ == 1
       ? 0
@@ -512,31 +611,7 @@ void LocalPartition::addInput(RowVectorPtr input) {
     ++maxIndex[partition];
   }
 
-  const int64_t totalSize = input->retainedSize();
-  for (auto partition = 0; partition < numPartitions_; partition++) {
-    auto partitionSize = maxIndex[partition];
-    if (partitionSize == 0) {
-      // Do not enqueue empty partitions.
-      continue;
-    }
-
-    auto partitionData = processPartition(
-        input,
-        partitionSize,
-        partition,
-        indexBuffers_[partition],
-        rawIndices_[partition]);
-
-    if (partitionData) {
-      ContinueFuture future;
-      auto reason = queues_[partition]->enqueue(
-          partitionData, totalSize * partitionSize / numInput, &future);
-      if (reason != BlockingReason::kNotBlocked) {
-        blockingReasons_.push_back(reason);
-        futures_.push_back(std::move(future));
-      }
-    }
-  }
+  populateAndEnqueuePartitions(input, maxIndex, indexBuffers_, rawIndices_);
 }
 
 void LocalPartition::prepareForInput(RowVectorPtr& input) {
@@ -566,19 +641,36 @@ BlockingReason LocalPartition::isBlocked(ContinueFuture* future) {
 void LocalPartition::noMoreInput() {
   Operator::noMoreInput();
   if (!partitionBuffers_.empty()) {
+    uint64_t totalPartitionBufferSizeExcludingString = 0;
+    uint64_t totalPartitionStringBufferSize = 0;
+    uint16_t nonEmptyPartitionCount = 0;
     for (auto partition = 0; partition < numPartitions_; partition++) {
-      if (partitionBuffers_[partition] &&
-          partitionBuffers_[partition]->size() > 0) {
-        auto partitionData =
-            std::dynamic_pointer_cast<RowVector>(partitionBuffers_[partition]);
-        VELOX_CHECK(partitionData);
-        ContinueFuture future;
-        queues_[partition]->enqueue(
-            partitionData,
-            partitionBuffers_[partition]->retainedSize(),
-            &future);
+      if (partitionBuffers_[partition]) {
+        uint64_t stringBufferSize{0};
+        auto totalSize =
+            partitionBuffers_[partition]->retainedSize(stringBufferSize);
+        totalPartitionBufferSizeExcludingString += totalSize - stringBufferSize;
+        totalPartitionStringBufferSize += stringBufferSize;
+        nonEmptyPartitionCount++;
+      }
+    }
+    if (nonEmptyPartitionCount > 0) {
+      auto balancedPartitionBufferSize =
+          totalPartitionBufferSizeExcludingString +
+          (totalPartitionStringBufferSize / nonEmptyPartitionCount);
+      for (auto partition = 0; partition < numPartitions_; partition++) {
+        if (partitionBuffers_[partition]) {
+          auto partitionData = checkedPointerCast<RowVector, BaseVector>(
+              partitionBuffers_[partition]);
+          ContinueFuture future;
+
+          queues_[partition]->enqueue(
+              partitionData,
+              balancedPartitionBufferSize / nonEmptyPartitionCount,
+              &future);
+        }
+        partitionBuffers_[partition] = nullptr;
       }
-      partitionBuffers_[partition] = nullptr;
     }
     partitionBuffers_.resize(0);
     copyRanges_.resize(0);
diff --git a/velox/exec/LocalPartition.h b/velox/exec/LocalPartition.h
index bdf7ab42df5..f2b1da8de50 100644
--- a/velox/exec/LocalPartition.h
+++ b/velox/exec/LocalPartition.h
@@ -240,12 +240,21 @@ class LocalPartition : public Operator {
 
   void allocateIndexBuffers(const std::vector<vector_size_t>& sizes);
 
-  RowVectorPtr processPartition(
-      const RowVectorPtr& input,
-      vector_size_t size,
-      int partition,
-      const BufferPtr& indices,
-      const vector_size_t* rawIndices);
+  /// Create partitions from 'input' according to 'numRowsPerPartition' and
+  /// 'indexBuffers', and enqueue the partitions to LocalExchangeQueues. The
+  /// behavior of partition vector creation varies depending on
+  /// 'singlePartitionBufferSize_'. If 'singlePartitionBufferSize_' is non-zero,
+  /// append rows from 'input' to 'partitionBuffers_' for every partition. When
+  /// the total size of all partition buffer vectors exceeds
+  /// 'singlePartitionBufferSize_ * numPartitions_', flush all partitionBuffers_
+  /// vectors to LocalExchangeQueues. If 'singlePartitionBufferSize_' is zero,
+  /// create partition vectors by wrapping 'input' with indexBuffers and flush
+  /// them to LocalExchangeQueues immediately.
+  void populateAndEnqueuePartitions(
+      RowVectorPtr input,
+      const std::vector<vector_size_t>& numRowsPerPartition,
+      const std::vector<BufferPtr>& indexBuffers,
+      const std::vector<vector_size_t*>& rawIndicesBuffers);
 
   const std::vector<std::shared_ptr<LocalExchangeQueue>> queues_;
   const size_t numPartitions_;
@@ -261,6 +270,11 @@ class LocalPartition : public Operator {
   std::vector<vector_size_t*> rawIndices_;
 
  private:
+  // Try getting a reusable vector for 'partition' from the corresponding
+  // local-exchange vector pool of this partition. If none is available, create
+  // a new vector.
+  VectorPtr getOrCreateVector(const size_t partition);
+
   RowVectorPtr wrapChildren(
       const RowVectorPtr& input,
       vector_size_t size,
@@ -270,8 +284,30 @@ class LocalPartition : public Operator {
   void copy(
       const RowVectorPtr& input,
       const folly::Range<const BaseVector::CopyRange*>& ranges,
+      const size_t partition,
       VectorPtr& target);
 
+  /// Add rows from 'input' to 'partitionBuffers_' that every row belongs to.
+  /// Also set 'totalPartitionBufferSizeExcludingString' to be the total size of
+  /// all partition buffer vectors excluding string buffers inside them, and set
+  /// 'totalPartitionStringBufferSize' to be the total size of all string
+  /// buffers in all partition buffer vectors.
+  void populatePartitionBuffer(
+      const RowVectorPtr& input,
+      const vector_size_t numPartitionRows,
+      const size_t partition,
+      const vector_size_t* rawIndices,
+      uint64_t& totalPartitionBufferSizeExcludingString,
+      uint64_t& totalPartitionStringBufferSize);
+
+  /// Return the partition vector to be added to LocalExchangeQueue. This method
+  /// returns nullptr if no row belongs to 'partition'
+  RowVectorPtr createPartition(
+      const RowVectorPtr& input,
+      const vector_size_t numPartitionRows,
+      const size_t partition,
+      const BufferPtr& indices);
+
   const uint64_t singlePartitionBufferSize_;
   std::vector<BaseVector::CopyRange> copyRanges_;
   std::vector<VectorPtr> partitionBuffers_;
diff --git a/velox/exec/LocalPlanner.cpp b/velox/exec/LocalPlanner.cpp
index b78ca6ec8b9..39f009fe39a 100644
--- a/velox/exec/LocalPlanner.cpp
+++ b/velox/exec/LocalPlanner.cpp
@@ -18,6 +18,7 @@
 #include "velox/exec/ArrowStream.h"
 #include "velox/exec/AssignUniqueId.h"
 #include "velox/exec/CallbackSink.h"
+#include "velox/exec/EnforceDistinct.h"
 #include "velox/exec/EnforceSingleRow.h"
 #include "velox/exec/Exchange.h"
 #include "velox/exec/Expand.h"
@@ -29,8 +30,10 @@
 #include "velox/exec/IndexLookupJoin.h"
 #include "velox/exec/Limit.h"
 #include "velox/exec/MarkDistinct.h"
+#include "velox/exec/MarkSorted.h"
 #include "velox/exec/Merge.h"
 #include "velox/exec/MergeJoin.h"
+#include "velox/exec/MixedUnion.h"
 #include "velox/exec/NestedLoopJoinBuild.h"
 #include "velox/exec/NestedLoopJoinProbe.h"
 #include "velox/exec/OperatorTraceScan.h"
@@ -43,6 +46,7 @@
 #include "velox/exec/SpatialJoinBuild.h"
 #include "velox/exec/SpatialJoinProbe.h"
 #include "velox/exec/StreamingAggregation.h"
+#include "velox/exec/StreamingEnforceDistinct.h"
 #include "velox/exec/TableScan.h"
 #include "velox/exec/TableWriteMerge.h"
 #include "velox/exec/TableWriter.h"
@@ -84,6 +88,11 @@ bool mustStartNewPipeline(
     return true;
   }
 
+  if (std::dynamic_pointer_cast<const core::MixedUnionNode>(planNode)) {
+    // MixedUnion's sources run on their own pipelines.
+    return true;
+  }
+
   if (std::dynamic_pointer_cast<const core::LocalPartitionNode>(planNode)) {
     return true;
   }
@@ -142,6 +151,27 @@ OperatorSupplier makeOperatorSupplier(
     };
   }
 
+  if (auto mixedUnion =
+          std::dynamic_pointer_cast<const core::MixedUnionNode>(planNode)) {
+    return [mixedUnion](int32_t operatorId, DriverCtx* ctx) {
+      auto mergeSource = ctx->task->addLocalMergeSource(
+          ctx->splitGroupId,
+          mixedUnion->id(),
+          mixedUnion->outputType(),
+          static_cast<int>(ctx->queryConfig().localMergeSourceQueueSize()));
+      auto consumerCb =
+          [mergeSource](
+              RowVectorPtr input, bool drained, ContinueFuture* future) {
+            return mergeSource->enqueue(std::move(input), future, drained);
+          };
+      auto startCb = [mergeSource](ContinueFuture* future) {
+        return mergeSource->started(future);
+      };
+      return std::make_unique<CallbackSink>(
+          operatorId, ctx, std::move(consumerCb), std::move(startCb));
+    };
+  }
+
   if (auto localPartitionNode =
           std::dynamic_pointer_cast<const core::LocalPartitionNode>(planNode)) {
     if (localPartitionNode->scaleWriter()) {
@@ -203,7 +233,15 @@ OperatorSupplier makeOperatorSupplier(
               return source->enqueue(std::move(input), future);
             }
           };
-      return std::make_unique<CallbackSink>(operatorId, ctx, consumer);
+      // NOTE: Pass planNodeId to associate CallbackSink with the MergeJoin
+      // node for proper operator identification and input collection.
+      // Operator::maybeSetTracer() uses this to enable tracing.
+      return std::make_unique<CallbackSink>(
+          operatorId,
+          ctx,
+          consumer,
+          nullptr,
+          ctx->queryConfig().queryTraceEnabled() ? planNodeId : "N/A");
     };
   }
 
@@ -261,74 +299,24 @@ uint32_t maxDrivers(
     return count;
   }
   for (auto& node : driverFactory.planNodes) {
-    if (auto topN = std::dynamic_pointer_cast<const core::TopNNode>(node)) {
-      if (!topN->isPartial()) {
-        // final topN must run single-threaded
-        return 1;
-      }
-    } else if (
-        auto values = std::dynamic_pointer_cast<const core::ValuesNode>(node)) {
-      // values node must run single-threaded, unless in test context
-      if (!values->testingIsParallelizable()) {
-        return 1;
-      }
-    } else if (std::dynamic_pointer_cast<const core::ArrowStreamNode>(node)) {
-      // ArrowStream node must run single-threaded.
+    if (node->requiresSingleThread()) {
       return 1;
-    } else if (
-        auto limit = std::dynamic_pointer_cast<const core::LimitNode>(node)) {
-      // final limit must run single-threaded
-      if (!limit->isPartial()) {
-        return 1;
-      }
-    } else if (
-        auto orderBy =
-            std::dynamic_pointer_cast<const core::OrderByNode>(node)) {
-      // final orderby must run single-threaded
-      if (!orderBy->isPartial()) {
-        return 1;
-      }
-    } else if (
-        auto localExchange =
+    }
+
+    if (auto localExchange =
             std::dynamic_pointer_cast<const core::LocalPartitionNode>(node)) {
-      // Local gather must run single-threaded.
-      switch (localExchange->type()) {
-        case core::LocalPartitionNode::Type::kGather:
-          return 1;
-        case core::LocalPartitionNode::Type::kRepartition:
-          count = std::min(queryConfig.maxLocalExchangePartitionCount(), count);
-          break;
-        default:
-          VELOX_UNREACHABLE("Unexpected local exchange type");
-      }
-    } else if (std::dynamic_pointer_cast<const core::LocalMergeNode>(node)) {
-      // Local merge must run single-threaded.
-      return 1;
-    } else if (std::dynamic_pointer_cast<const core::MergeExchangeNode>(node)) {
-      // Merge exchange must run single-threaded.
-      return 1;
-    } else if (std::dynamic_pointer_cast<const core::MergeJoinNode>(node)) {
-      // Merge join must run single-threaded.
-      return 1;
-    } else if (
-        auto join = std::dynamic_pointer_cast<const core::HashJoinNode>(node)) {
-      // Right semi project doesn't support multi-threaded execution.
-      if (join->isRightSemiProjectJoin()) {
-        return 1;
+      // Repartition limits parallelism to the partition count.
+      if (localExchange->type() ==
+          core::LocalPartitionNode::Type::kRepartition) {
+        count = std::min(queryConfig.maxLocalExchangePartitionCount(), count);
       }
     } else if (
         auto tableWrite =
             std::dynamic_pointer_cast<const core::TableWriteNode>(node)) {
-      const auto& connectorInsertHandle =
-          tableWrite->insertTableHandle()->connectorInsertTableHandle();
-      if (!connectorInsertHandle->supportsMultiThreading()) {
-        return 1;
+      if (tableWrite->hasPartitioningScheme()) {
+        return queryConfig.taskPartitionedWriterCount();
       } else {
-        if (tableWrite->hasPartitioningScheme()) {
-          return queryConfig.taskPartitionedWriterCount();
-        } else {
-          return queryConfig.taskWriterCount();
-        }
+        return queryConfig.taskWriterCount();
       }
     } else {
       auto result = Operator::maxDrivers(node);
@@ -490,7 +478,7 @@ std::shared_ptr<Driver> DriverFactory::createDriver(
   std::vector<std::unique_ptr<Operator>> operators;
   operators.reserve(planNodes.size());
 
-  for (int32_t i = 0; i < planNodes.size(); i++) {
+  for (int32_t i = 0; i < planNodes.size(); ++i) {
     // Id of the Operator being made. This is not the same as 'i'
     // because some PlanNodes may get fused.
     auto id = operators.size();
@@ -501,8 +489,9 @@ std::shared_ptr<Driver> DriverFactory::createDriver(
         auto next = planNodes[i + 1];
         if (auto projectNode =
                 std::dynamic_pointer_cast<const core::ProjectNode>(next)) {
-          operators.push_back(std::make_unique<FilterProject>(
-              id, ctx.get(), filterNode, projectNode));
+          operators.push_back(
+              std::make_unique<FilterProject>(
+                  id, ctx.get(), filterNode, projectNode));
           i++;
           continue;
         }
@@ -543,8 +532,9 @@ std::shared_ptr<Driver> DriverFactory::createDriver(
         auto tableWriteMergeNode =
             std::dynamic_pointer_cast<const core::TableWriteMergeNode>(
                 planNode)) {
-      operators.push_back(std::make_unique<TableWriteMerge>(
-          id, ctx.get(), tableWriteMergeNode));
+      operators.push_back(
+          std::make_unique<TableWriteMerge>(
+              id, ctx.get(), tableWriteMergeNode));
     } else if (
         auto mergeExchangeNode =
             std::dynamic_pointer_cast<const core::MergeExchangeNode>(
@@ -556,14 +546,16 @@ std::shared_ptr<Driver> DriverFactory::createDriver(
             std::dynamic_pointer_cast<const core::ExchangeNode>(planNode)) {
       // NOTE: the exchange client can only be used by one operator in a driver.
       VELOX_CHECK_NOT_NULL(exchangeClient);
-      operators.push_back(std::make_unique<Exchange>(
-          id, ctx.get(), exchangeNode, std::move(exchangeClient)));
+      operators.push_back(
+          std::make_unique<Exchange>(
+              id, ctx.get(), exchangeNode, std::move(exchangeClient)));
     } else if (
         auto partitionedOutputNode =
             std::dynamic_pointer_cast<const core::PartitionedOutputNode>(
                 planNode)) {
-      operators.push_back(std::make_unique<PartitionedOutput>(
-          id, ctx.get(), partitionedOutputNode, eagerFlush(*planNode)));
+      operators.push_back(
+          std::make_unique<PartitionedOutput>(
+              id, ctx.get(), partitionedOutputNode, eagerFlush(*planNode)));
     } else if (
         auto joinNode =
             std::dynamic_pointer_cast<const core::HashJoinNode>(planNode)) {
@@ -589,8 +581,9 @@ std::shared_ptr<Driver> DriverFactory::createDriver(
         auto aggregationNode =
             std::dynamic_pointer_cast<const core::AggregationNode>(planNode)) {
       if (aggregationNode->isPreGrouped()) {
-        operators.push_back(std::make_unique<StreamingAggregation>(
-            id, ctx.get(), aggregationNode));
+        operators.push_back(
+            std::make_unique<StreamingAggregation>(
+                id, ctx.get(), aggregationNode));
       } else {
         operators.push_back(
             std::make_unique<HashAggregation>(id, ctx.get(), aggregationNode));
@@ -637,12 +630,36 @@ std::shared_ptr<Driver> DriverFactory::createDriver(
             std::dynamic_pointer_cast<const core::MarkDistinctNode>(planNode)) {
       operators.push_back(
           std::make_unique<MarkDistinct>(id, ctx.get(), markDistinctNode));
+    } else if (
+        auto enforceDistinctNode =
+            std::dynamic_pointer_cast<const core::EnforceDistinctNode>(
+                planNode)) {
+      if (enforceDistinctNode->isPreGrouped()) {
+        operators.push_back(
+            std::make_unique<StreamingEnforceDistinct>(
+                id, ctx.get(), enforceDistinctNode));
+      } else {
+        operators.push_back(
+            std::make_unique<EnforceDistinct>(
+                id, ctx.get(), enforceDistinctNode));
+      }
+    } else if (
+        auto markSortedNode =
+            std::dynamic_pointer_cast<const core::MarkSortedNode>(planNode)) {
+      operators.push_back(
+          std::make_unique<MarkSorted>(id, ctx.get(), markSortedNode));
     } else if (
         auto localMerge =
             std::dynamic_pointer_cast<const core::LocalMergeNode>(planNode)) {
       auto localMergeOp =
           std::make_unique<LocalMerge>(id, ctx.get(), localMerge);
       operators.push_back(std::move(localMergeOp));
+    } else if (
+        auto mixedUnion =
+            std::dynamic_pointer_cast<const core::MixedUnionNode>(planNode)) {
+      auto mixedUnionOp =
+          std::make_unique<MixedUnion>(id, ctx.get(), mixedUnion);
+      operators.push_back(std::move(mixedUnionOp));
     } else if (
         auto mergeJoin =
             std::dynamic_pointer_cast<const core::MergeJoinNode>(planNode)) {
@@ -653,12 +670,13 @@ std::shared_ptr<Driver> DriverFactory::createDriver(
         auto localPartitionNode =
             std::dynamic_pointer_cast<const core::LocalPartitionNode>(
                 planNode)) {
-      operators.push_back(std::make_unique<LocalExchange>(
-          id,
-          ctx.get(),
-          localPartitionNode->outputType(),
-          localPartitionNode->id(),
-          ctx->partitionId));
+      operators.push_back(
+          std::make_unique<LocalExchange>(
+              id,
+              ctx.get(),
+              localPartitionNode->outputType(),
+              localPartitionNode->id(),
+              ctx->partitionId));
     } else if (
         auto unnest =
             std::dynamic_pointer_cast<const core::UnnestNode>(planNode)) {
@@ -673,17 +691,19 @@ std::shared_ptr<Driver> DriverFactory::createDriver(
         auto assignUniqueIdNode =
             std::dynamic_pointer_cast<const core::AssignUniqueIdNode>(
                 planNode)) {
-      operators.push_back(std::make_unique<AssignUniqueId>(
-          id,
-          ctx.get(),
-          assignUniqueIdNode,
-          assignUniqueIdNode->taskUniqueId(),
-          assignUniqueIdNode->uniqueIdCounter()));
+      operators.push_back(
+          std::make_unique<AssignUniqueId>(
+              id,
+              ctx.get(),
+              assignUniqueIdNode,
+              assignUniqueIdNode->taskUniqueId(),
+              assignUniqueIdNode->uniqueIdCounter()));
     } else if (
         const auto traceScanNode =
             std::dynamic_pointer_cast<const core::TraceScanNode>(planNode)) {
-      operators.push_back(std::make_unique<trace::OperatorTraceScan>(
-          id, ctx.get(), traceScanNode));
+      operators.push_back(
+          std::make_unique<trace::OperatorTraceScan>(
+              id, ctx.get(), traceScanNode));
     } else {
       std::unique_ptr<Operator> extended;
       if (planNode->requiresExchangeClient()) {
@@ -731,7 +751,7 @@ std::vector<std::unique_ptr<Operator>> DriverFactory::replaceOperators(
   }
 
   driver.operators_.erase(
-      driver.operators_.begin() + begin, driver.operators_.begin() + end);
+      driver.operators_.cbegin() + begin, driver.operators_.cbegin() + end);
 
   // Insert the replacement at the place of the erase. Do manually because
   // insert() is not good with unique pointers.
@@ -812,6 +832,21 @@ std::vector<core::PlanNodeId> DriverFactory::needsSpatialJoinBridges() const {
   return planNodeIds;
 }
 
+std::vector<core::PlanNodeId> DriverFactory::needsIndexLookupJoinBridges()
+    const {
+  std::vector<core::PlanNodeId> planNodeIds;
+  for (const auto& planNode : planNodes) {
+    if (auto joinNode =
+            std::dynamic_pointer_cast<const core::IndexLookupJoinNode>(
+                planNode)) {
+      if (joinNode->needsIndexSplit()) {
+        planNodeIds.emplace_back(joinNode->id());
+      }
+    }
+  }
+  return planNodeIds;
+}
+
 // static
 void DriverFactory::registerAdapter(DriverAdapter adapter) {
   adapters.push_back(std::move(adapter));
diff --git a/velox/exec/MarkDistinct.cpp b/velox/exec/MarkDistinct.cpp
index 8b4d0c09e55..2b562c714af 100644
--- a/velox/exec/MarkDistinct.cpp
+++ b/velox/exec/MarkDistinct.cpp
@@ -15,7 +15,11 @@
  */
 
 #include "velox/exec/MarkDistinct.h"
-#include "velox/common/base/Range.h"
+
+#include "velox/common/memory/Memory.h"
+#include "velox/common/memory/MemoryArbitrator.h"
+#include "velox/exec/OperatorType.h"
+#include "velox/exec/OperatorUtils.h"
 #include "velox/vector/FlatVector.h"
 
 #include <algorithm>
@@ -32,39 +36,161 @@ MarkDistinct::MarkDistinct(
           planNode->outputType(),
           operatorId,
           planNode->id(),
-          "MarkDistinct") {
-  const auto& inputType = planNode->sources()[0]->outputType();
+          OperatorType::kMarkDistinct,
+          planNode->canSpill(driverCtx->queryConfig())
+              ? driverCtx->makeSpillConfig(operatorId, planNode->name())
+              : std::nullopt) {
+  inputType_ = planNode->sources()[0]->outputType();
 
   // Set all input columns as identity projection.
-  for (auto i = 0; i < inputType->size(); ++i) {
+  for (auto i = 0; i < inputType_->size(); ++i) {
     identityProjections_.emplace_back(i, i);
   }
 
-  // We will use result[0] for distinct mask output.
-  resultProjections_.emplace_back(0, inputType->size());
+  // Use result[0] for distinct mask output.
+  resultProjections_.emplace_back(0, inputType_->size());
+
+  for (const auto& key : planNode->distinctKeys()) {
+    distinctKeyChannels_.push_back(inputType_->getChildIdx(key->name()));
+  }
 
-  groupingSet_ = GroupingSet::createForMarkDistinct(
-      inputType,
-      createVectorHashers(inputType, planNode->distinctKeys()),
+  groupingSet_ = GroupingSet::createForDistinct(
+      inputType_,
+      createVectorHashers(inputType_, planNode->distinctKeys()),
+      /*preGroupedKeys=*/{},
       operatorCtx_.get(),
       &nonReclaimableSection_);
 
   results_.resize(1);
+
+  if (spillEnabled()) {
+    setSpillPartitionBits();
+  }
 }
 
 void MarkDistinct::addInput(RowVectorPtr input) {
-  groupingSet_->addInput(input, false /*mayPushdown*/);
+  ensureInputFits(input);
+
+  if (inputSpiller_ != nullptr) {
+    spillInput(input, pool());
+    return;
+  }
 
+  // Don't add to the hash table here. We defer it to getOutput() so that if
+  // spill() is called between addInput() and getOutput(), the hash table spill
+  // won't include this input's keys. This prevents those keys from being
+  // re-suppressed during restore.
   input_ = std::move(input);
 }
 
+void MarkDistinct::noMoreInput() {
+  Operator::noMoreInput();
+
+  if (inputSpiller_ != nullptr) {
+    finishSpillInputAndRestoreNext();
+  }
+}
+
+void MarkDistinct::finishSpillInputAndRestoreNext() {
+  VELOX_CHECK_NOT_NULL(inputSpiller_);
+  inputSpiller_->finishSpill(spillInputPartitionSet_);
+  inputSpiller_.reset();
+  removeEmptyPartitions(spillInputPartitionSet_);
+  restoreNextSpillPartition();
+}
+
+void MarkDistinct::restoreNextSpillPartition() {
+  if (spillInputPartitionSet_.empty()) {
+    return;
+  }
+
+  auto it = spillInputPartitionSet_.begin();
+  restoringPartitionId_ = it->first;
+
+  spillInputReader_ = it->second->createUnorderedReader(
+      spillConfig_->readBufferSize, pool(), spillStats_.get());
+
+  auto hashTableIt = spillHashTablePartitionSet_.find(it->first);
+  if (hashTableIt != spillHashTablePartitionSet_.end()) {
+    auto reader = hashTableIt->second->createUnorderedReader(
+        spillConfig_->readBufferSize, pool(), spillStats_.get());
+
+    setSpillPartitionBits(&(it->first));
+
+    auto* table = groupingSet_->table();
+    const auto& hashers = table->hashers();
+    auto lookup = std::make_unique<HashLookup>(hashers, pool());
+
+    std::vector<VectorPtr> columns(inputType_->size());
+    RowVectorPtr data;
+    while (reader->nextBatch(data)) {
+      for (auto i = 0; i < hashers.size(); ++i) {
+        columns[hashers[i]->channel()] = data->childAt(i);
+      }
+
+      auto input = std::make_shared<RowVector>(
+          pool(), inputType_, nullptr, data->size(), std::move(columns));
+
+      SelectivityVector rows(data->size());
+      table->prepareForGroupProbe(
+          *lookup, input, rows, spillConfig_->startPartitionBit);
+      table->groupProbe(*lookup, spillConfig_->startPartitionBit);
+
+      columns.assign(inputType_->size(), nullptr);
+    }
+  }
+
+  spillInputPartitionSet_.erase(it);
+
+  RowVectorPtr spilledInput;
+  spillInputReader_->nextBatch(spilledInput);
+  VELOX_CHECK_NOT_NULL(spilledInput);
+  addInput(std::move(spilledInput));
+}
+
+void MarkDistinct::recursiveSpillInput() {
+  RowVectorPtr spilledInput;
+  while (spillInputReader_->nextBatch(spilledInput)) {
+    spillInput(spilledInput, pool());
+
+    if (shouldYield()) {
+      yield_ = true;
+      return;
+    }
+  }
+
+  finishSpillInputAndRestoreNext();
+}
+
 RowVectorPtr MarkDistinct::getOutput() {
-  if (isFinished() || !input_) {
+  if (isFinished()) {
     return nullptr;
   }
 
-  auto outputSize = input_->size();
-  // Re-use memory for the ID vector if possible.
+  if (input_ == nullptr) {
+    if (spillInputReader_ == nullptr) {
+      return nullptr;
+    }
+
+    recursiveSpillInput();
+    if (yield_) {
+      yield_ = false;
+      return nullptr;
+    }
+
+    if (input_ == nullptr) {
+      return nullptr;
+    }
+  }
+
+  // Add the current input to the hash table now, just before producing output.
+  // This is deferred from addInput() so that if spill() is called between
+  // addInput() and getOutput(), the hash table doesn't contain this input's
+  // keys — ensuring they are correctly marked as new during restore.
+  groupingSet_->addInput(input_, /*mayPushdown=*/false);
+
+  const auto outputSize = input_->size();
+
   VectorPtr& result = results_[0];
   if (result && result.use_count() == 1) {
     BaseVector::prepareForReuse(result, outputSize);
@@ -72,26 +198,269 @@ RowVectorPtr MarkDistinct::getOutput() {
     result = BaseVector::create(BOOLEAN(), outputSize, operatorCtx_->pool());
   }
 
-  // newGroups contains the indices of distinct rows.
-  // For each index in newGroups, we mark the index'th bit true in the result
-  // vector.
-  auto resultBits =
+  auto* resultBits =
       results_[0]->as<FlatVector<bool>>()->mutableRawValues<uint64_t>();
-
   bits::fillBits(resultBits, 0, outputSize, false);
   for (const auto i : groupingSet_->hashLookup().newGroups) {
     bits::setBit(resultBits, i, true);
   }
-  auto output = fillOutput(outputSize, nullptr);
 
-  // Drop reference to input_ to make it singly-referenced at the producer and
-  // allow for memory reuse.
+  auto output = fillOutput(outputSize, nullptr);
   input_ = nullptr;
 
+  if (spillInputReader_ != nullptr) {
+    RowVectorPtr spilledInput;
+    if (spillInputReader_->nextBatch(spilledInput)) {
+      addInput(std::move(spilledInput));
+    } else {
+      spillInputReader_.reset();
+      restoringPartitionId_.reset();
+      groupingSet_->resetTable(true);
+      restoreNextSpillPartition();
+    }
+  }
+
   return output;
 }
 
 bool MarkDistinct::isFinished() {
-  return noMoreInput_ && !input_;
+  return noMoreInput_ && input_ == nullptr && spillInputReader_ == nullptr;
+}
+
+void MarkDistinct::ensureInputFits(const RowVectorPtr& input) {
+  if (!spillEnabled() || inputSpiller_ != nullptr) {
+    return;
+  }
+
+  const auto numDistinct = groupingSet_->numDistinct();
+  if (numDistinct == 0) {
+    return;
+  }
+
+  auto* table = groupingSet_->table();
+  auto* rows = table->rows();
+  const auto [freeRows, outOfLineFreeBytes] = rows->freeSpace();
+  const auto outOfLineBytes =
+      rows->stringAllocator().retainedSize() - outOfLineFreeBytes;
+  const auto outOfLineBytesPerRow = outOfLineBytes / numDistinct;
+
+  if (testingTriggerSpill(pool()->name())) {
+    Operator::ReclaimableSectionGuard guard(this);
+    memory::testingRunArbitration(pool());
+    return;
+  }
+
+  const auto currentUsage = pool()->usedBytes();
+  const auto minReservationBytes =
+      currentUsage * spillConfig_->minSpillableReservationPct / 100;
+  const auto availableReservationBytes = pool()->availableReservation();
+  const auto tableIncrementBytes =
+      static_cast<int64_t>(table->hashTableSizeIncrease(input->size()));
+  const auto incrementBytes =
+      static_cast<int64_t>(rows->sizeIncrement(
+          input->size(), outOfLineBytesPerRow * input->size())) +
+      tableIncrementBytes;
+
+  if (availableReservationBytes >= minReservationBytes) {
+    if ((tableIncrementBytes == 0) && (freeRows > input->size()) &&
+        (outOfLineBytes == 0 ||
+         outOfLineFreeBytes >= outOfLineBytesPerRow * input->size())) {
+      return;
+    }
+
+    if (availableReservationBytes > 2 * incrementBytes) {
+      return;
+    }
+  }
+
+  const auto targetIncrementBytes = std::max<int64_t>(
+      incrementBytes * 2,
+      currentUsage * spillConfig_->spillableReservationGrowthPct / 100);
+  {
+    Operator::ReclaimableSectionGuard guard(this);
+    if (pool()->maybeReserve(targetIncrementBytes)) {
+      if (inputSpiller_ != nullptr) {
+        pool()->release();
+      }
+      return;
+    }
+  }
+
+  LOG(WARNING) << "Failed to reserve " << succinctBytes(targetIncrementBytes)
+               << " for memory pool " << pool()->name()
+               << ", root pool: " << pool()->root()->name()
+               << ", used: " << succinctBytes(pool()->usedBytes())
+               << ", reservation: " << succinctBytes(pool()->reservedBytes())
+               << ", root pool reservation: "
+               << succinctBytes(pool()->root()->reservedBytes());
+}
+
+void MarkDistinct::reclaim(
+    uint64_t /* unused */,
+    memory::MemoryReclaimer::Stats& /* unused */) {
+  VELOX_CHECK(canReclaim());
+  VELOX_CHECK(!nonReclaimableSection_);
+
+  if (groupingSet_->numDistinct() == 0) {
+    return;
+  }
+
+  if (FOLLY_UNLIKELY(exceededMaxSpillLevelLimit_)) {
+    LOG(WARNING) << "Exceeded mark distinct spill level limit: "
+                 << spillConfig_->maxSpillLevel
+                 << ", and abandon spilling for memory pool: " << pool()->name()
+                 << ", root pool: " << pool()->root()->name()
+                 << ", used: " << succinctBytes(pool()->usedBytes())
+                 << ", reservation: " << succinctBytes(pool()->reservedBytes())
+                 << ", root pool reservation: "
+                 << succinctBytes(pool()->root()->reservedBytes());
+    spillStats_->spillMaxLevelExceededCount.fetch_add(
+        1, std::memory_order_relaxed);
+    return;
+  }
+
+  spill();
+}
+
+SpillPartitionIdSet MarkDistinct::spillHashTable() {
+  VELOX_CHECK_GT(groupingSet_->numDistinct(), 0);
+
+  auto* table = groupingSet_->table();
+  auto columnTypes = table->rows()->columnTypes();
+  auto tableType = ROW(std::move(columnTypes));
+
+  auto hashTableSpiller = std::make_unique<MarkDistinctHashTableSpiller>(
+      table->rows(),
+      restoringPartitionId_,
+      tableType,
+      spillPartitionBits_,
+      &spillConfig_.value(),
+      spillStats_.get());
+
+  hashTableSpiller->spill();
+  hashTableSpiller->finishSpill(spillHashTablePartitionSet_);
+
+  groupingSet_->resetTable(true);
+  pool()->release();
+  return hashTableSpiller->state().spilledPartitionIdSet();
+}
+
+void MarkDistinct::setupInputSpiller(
+    const SpillPartitionIdSet& spillPartitionIdSet) {
+  VELOX_CHECK(!spillPartitionIdSet.empty());
+
+  inputSpiller_ = std::make_unique<NoRowContainerSpiller>(
+      inputType_,
+      restoringPartitionId_,
+      spillPartitionBits_,
+      &spillConfig_.value(),
+      spillStats_.get());
+
+  spillHashFunction_ = std::make_unique<HashPartitionFunction>(
+      inputSpiller_->hashBits(), inputType_, distinctKeyChannels_);
+}
+
+void MarkDistinct::spill() {
+  VELOX_CHECK(spillEnabled());
+
+  spilled_ = true;
+
+  const auto spillPartitionIdSet = spillHashTable();
+  VELOX_CHECK_EQ(groupingSet_->numDistinct(), 0);
+
+  setupInputSpiller(spillPartitionIdSet);
+  if (input_ != nullptr) {
+    spillInput(input_, memory::spillMemoryPool());
+    input_ = nullptr;
+  }
+  results_.clear();
+  results_.resize(1);
+}
+
+void MarkDistinct::spillInput(
+    const RowVectorPtr& input,
+    memory::MemoryPool* pool) {
+  const auto numRows = input->size();
+
+  std::vector<uint32_t> partitionAssignments(numRows);
+  const auto singlePartition =
+      spillHashFunction_->partition(*input, partitionAssignments);
+
+  const auto numPartitions = spillHashFunction_->numPartitions();
+
+  std::vector<BufferPtr> partitionIndices(numPartitions);
+  std::vector<vector_size_t*> rawPartitionIndices(numPartitions);
+
+  for (auto i = 0; i < numPartitions; ++i) {
+    partitionIndices[i] = allocateIndices(numRows, pool);
+    rawPartitionIndices[i] = partitionIndices[i]->asMutable<vector_size_t>();
+  }
+
+  std::vector<vector_size_t> numSpillInputs(numPartitions, 0);
+
+  for (auto row = 0; row < numRows; ++row) {
+    const auto partition = singlePartition.has_value()
+        ? singlePartition.value()
+        : partitionAssignments[row];
+    rawPartitionIndices[partition][numSpillInputs[partition]++] = row;
+  }
+
+  // Ensure vector are lazy loaded before spilling.
+  for (auto i = 0; i < input->childrenSize(); ++i) {
+    input->childAt(i)->loadedVector();
+  }
+
+  for (auto partition = 0; partition < numSpillInputs.size(); ++partition) {
+    const auto numInputs = numSpillInputs[partition];
+    if (numInputs == 0) {
+      continue;
+    }
+
+    inputSpiller_->spill(
+        SpillPartitionId(partition),
+        wrap(numInputs, partitionIndices[partition], input));
+  }
+}
+
+void MarkDistinct::setSpillPartitionBits(
+    const SpillPartitionId* restoredPartitionId) {
+  const auto startPartitionBitOffset = restoredPartitionId == nullptr
+      ? spillConfig_->startPartitionBit
+      : partitionBitOffset(
+            *restoredPartitionId,
+            spillConfig_->startPartitionBit,
+            spillConfig_->numPartitionBits) +
+          spillConfig_->numPartitionBits;
+  if (spillConfig_->exceedSpillLevelLimit(startPartitionBitOffset)) {
+    exceededMaxSpillLevelLimit_ = true;
+    return;
+  }
+
+  exceededMaxSpillLevelLimit_ = false;
+  spillPartitionBits_ = HashBitRange(
+      startPartitionBitOffset,
+      startPartitionBitOffset + spillConfig_->numPartitionBits);
+}
+
+MarkDistinctHashTableSpiller::MarkDistinctHashTableSpiller(
+    RowContainer* container,
+    std::optional<SpillPartitionId> parentId,
+    RowTypePtr rowType,
+    HashBitRange bits,
+    const common::SpillConfig* spillConfig,
+    exec::SpillStats* spillStats)
+    : SpillerBase(
+          container,
+          std::move(rowType),
+          bits,
+          {},
+          spillConfig->maxFileSize,
+          spillConfig->maxSpillRunRows,
+          parentId,
+          spillConfig,
+          spillStats) {}
+
+void MarkDistinctHashTableSpiller::spill() {
+  SpillerBase::spill(nullptr);
 }
 } // namespace facebook::velox::exec
diff --git a/velox/exec/MarkDistinct.h b/velox/exec/MarkDistinct.h
index dabba1b179a..c8c582b5ea8 100644
--- a/velox/exec/MarkDistinct.h
+++ b/velox/exec/MarkDistinct.h
@@ -17,10 +17,21 @@
 #pragma once
 
 #include "velox/exec/GroupingSet.h"
+#include "velox/exec/HashPartitionFunction.h"
 #include "velox/exec/Operator.h"
+#include "velox/exec/Spiller.h"
 
 namespace facebook::velox::exec {
 
+/// Marks distinct rows based on a set of grouping keys. For each input row,
+/// produces a boolean output column indicating whether the row's key
+/// combination is seen for the first time.
+///
+/// Supports spilling by persisting the hash table state to disk (like
+/// RowNumber). When spill is triggered, the hash table contents and future
+/// input are partitioned and written to disk. During restore, each partition's
+/// hash table is rebuilt from the spilled data, preserving knowledge of which
+/// keys were already seen before spill.
 class MarkDistinct : public Operator {
  public:
   MarkDistinct(
@@ -29,6 +40,10 @@ class MarkDistinct : public Operator {
       const std::shared_ptr<const core::MarkDistinctNode>& planNode);
 
   bool preservesOrder() const override {
+    return false;
+  }
+
+  bool isFilter() const override {
     return true;
   }
 
@@ -38,6 +53,8 @@ class MarkDistinct : public Operator {
 
   void addInput(RowVectorPtr input) override;
 
+  void noMoreInput() override;
+
   RowVectorPtr getOutput() override;
 
   BlockingReason isBlocked(ContinueFuture* /*future*/) override {
@@ -46,8 +63,85 @@ class MarkDistinct : public Operator {
 
   bool isFinished() override;
 
+  void reclaim(uint64_t targetBytes, memory::MemoryReclaimer::Stats& stats)
+      override;
+
  private:
-  // TODO: Document spilling configuration in spilling.rst.
+  bool spillEnabled() const {
+    return spillConfig_.has_value();
+  }
+
+  void ensureInputFits(const RowVectorPtr& input);
+
+  void spill();
+
+  void spillInput(const RowVectorPtr& input, memory::MemoryPool* pool);
+
+  void setupInputSpiller(const SpillPartitionIdSet& spillPartitionIdSet);
+
+  void setSpillPartitionBits(
+      const SpillPartitionId* restoredPartitionId = nullptr);
+
+  SpillPartitionIdSet spillHashTable();
+
+  void restoreNextSpillPartition();
+
+  void finishSpillInputAndRestoreNext();
+
+  /// Drains remaining batches from the current spill partition reader and
+  /// spills them when a recursive spill was triggered during restore.
+  void recursiveSpillInput();
+
+  RowTypePtr inputType_;
+
   std::unique_ptr<GroupingSet> groupingSet_;
+
+  HashBitRange spillPartitionBits_;
+
+  std::unique_ptr<NoRowContainerSpiller> inputSpiller_;
+
+  std::unique_ptr<UnorderedStreamReader<BatchStream>> spillInputReader_;
+
+  std::optional<SpillPartitionId> restoringPartitionId_;
+
+  SpillPartitionSet spillInputPartitionSet_;
+
+  std::unique_ptr<HashPartitionFunction> spillHashFunction_;
+
+  SpillPartitionSet spillHashTablePartitionSet_;
+
+  bool exceededMaxSpillLevelLimit_{false};
+
+  bool spilled_{false};
+
+  bool yield_{false};
+
+  std::vector<column_index_t> distinctKeyChannels_;
+};
+
+/// Spills the hash table contents (distinct keys) from MarkDistinct's
+/// GroupingSet to disk, partitioned by key hash.
+class MarkDistinctHashTableSpiller : public SpillerBase {
+ public:
+  static constexpr std::string_view kType = "MarkDistinctHashTableSpiller";
+
+  MarkDistinctHashTableSpiller(
+      RowContainer* container,
+      std::optional<SpillPartitionId> parentId,
+      RowTypePtr rowType,
+      HashBitRange bits,
+      const common::SpillConfig* spillConfig,
+      exec::SpillStats* spillStats);
+
+  void spill();
+
+ private:
+  bool needSort() const override {
+    return false;
+  }
+
+  std::string type() const override {
+    return std::string(kType);
+  }
 };
 } // namespace facebook::velox::exec
diff --git a/velox/exec/MarkSorted.cpp b/velox/exec/MarkSorted.cpp
new file mode 100644
index 00000000000..120175323a6
--- /dev/null
+++ b/velox/exec/MarkSorted.cpp
@@ -0,0 +1,330 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/MarkSorted.h"
+#include "velox/common/base/BitUtil.h"
+#include "velox/common/base/CompareFlags.h"
+#include "velox/functions/lib/SIMDComparisonUtil.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::exec {
+
+namespace {
+bool isSimdEligibleType(TypeKind kind) {
+  return kind == TypeKind::TINYINT || kind == TypeKind::SMALLINT ||
+      kind == TypeKind::INTEGER || kind == TypeKind::BIGINT;
+}
+} // namespace
+
+MarkSorted::MarkSorted(
+    int32_t operatorId,
+    DriverCtx* driverCtx,
+    const std::shared_ptr<const core::MarkSortedNode>& planNode)
+    : Operator(
+          driverCtx,
+          planNode->outputType(),
+          operatorId,
+          planNode->id(),
+          "MarkSorted"),
+      markerName_(planNode->markerName()),
+      zeroCopyThreshold_(
+          driverCtx->queryConfig().markSortedZeroCopyThreshold()) {
+  const auto& inputType = planNode->sources()[0]->outputType();
+  const auto& sortingKeys = planNode->sortingKeys();
+  const auto& sortingOrders = planNode->sortingOrders();
+
+  // Set all input columns as identity projection.
+  for (auto i = 0; i < inputType->size(); ++i) {
+    identityProjections_.emplace_back(i, i);
+  }
+
+  // Map the marker result (results_[0]) to the last column position in output,
+  // immediately after all input columns.
+  resultProjections_.emplace_back(0, inputType->size());
+
+  // Extract channel indices for sorting keys.
+  sortingKeyChannels_.reserve(sortingKeys.size());
+  compareFlags_.reserve(sortingKeys.size());
+  sortingOrders_.reserve(sortingKeys.size());
+
+  for (auto i = 0; i < sortingKeys.size(); ++i) {
+    const auto& key = sortingKeys[i];
+    auto channel = inputType->getChildIdx(key->name());
+    sortingKeyChannels_.push_back(channel);
+
+    const auto& order = sortingOrders[i];
+    sortingOrders_.push_back(order);
+
+    // Build CompareFlags from SortOrder.
+    compareFlags_.push_back(
+        {order.isNullsFirst(),
+         order.isAscending(),
+         false, // equalsOnly
+         CompareFlags::NullHandlingMode::kNullAsValue});
+  }
+
+  // Precompute type for lastRow_ (contains only sorting key columns).
+  std::vector<std::string> keyNames;
+  std::vector<TypePtr> keyTypes;
+  keyNames.reserve(sortingKeys.size());
+  keyTypes.reserve(sortingKeys.size());
+  for (auto i = 0; i < sortingKeys.size(); ++i) {
+    auto channel = sortingKeyChannels_[i];
+    keyNames.push_back(inputType->nameOf(channel));
+    keyTypes.push_back(inputType->childAt(channel));
+  }
+  lastRowType_ = ROW(std::move(keyNames), std::move(keyTypes));
+
+  results_.resize(1);
+}
+
+void MarkSorted::addInput(RowVectorPtr input) {
+  input_ = std::move(input);
+}
+
+bool MarkSorted::isSortedRelativeTo(
+    const RowVectorPtr& currentData,
+    vector_size_t currentIndex,
+    const RowVectorPtr& prevData,
+    vector_size_t prevIndex) {
+  for (auto i = 0; i < sortingKeyChannels_.size(); ++i) {
+    auto channel = sortingKeyChannels_[i];
+    const auto& currentColumn = currentData->childAt(channel);
+    const auto& prevColumn = prevData->childAt(channel);
+
+    auto result = currentColumn->compare(
+        prevColumn.get(), currentIndex, prevIndex, compareFlags_[i]);
+
+    if (result.has_value()) {
+      if (result.value() < 0) {
+        return false;
+      } else if (result.value() > 0) {
+        return true;
+      }
+    }
+  }
+
+  // All keys are equal - this is still considered sorted.
+  return true;
+}
+
+bool MarkSorted::allKeysConstant() const {
+  for (auto channel : sortingKeyChannels_) {
+    auto& keyCol = input_->childAt(channel);
+    if (!keyCol->isConstantEncoding() || keyCol->isNullAt(0)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool MarkSorted::canApplySimdPath() const {
+  if (sortingKeyChannels_.size() != 1) {
+    return false;
+  }
+  auto& keyCol = input_->childAt(sortingKeyChannels_[0]);
+  if (!keyCol->isFlatEncoding() || keyCol->mayHaveNulls()) {
+    return false;
+  }
+  if (keyCol->type()->providesCustomComparison()) {
+    return false;
+  }
+  return isSimdEligibleType(keyCol->typeKind());
+}
+
+void MarkSorted::applySimdComparison(
+    uint64_t* resultBits,
+    vector_size_t numRows) {
+  auto channel = sortingKeyChannels_[0];
+  auto& keyCol = input_->childAt(channel);
+  bool ascending = sortingOrders_[0].isAscending();
+  const auto numCompares = numRows - 1;
+
+  // Reuse bit-packed result buffer for SIMD output.
+  const auto bufferBytes = bits::nbytes(numCompares);
+  if (!simdBuffer_ || simdBuffer_->size() < bufferBytes) {
+    simdBuffer_ = AlignedBuffer::allocate<uint8_t>(bufferBytes, pool());
+  }
+  auto simdResult = simdBuffer_->asMutable<uint8_t>();
+  memset(simdResult, 0, bufferBytes);
+
+  // Dispatch by type to call applySimdComparison with typed raw data.
+  // Consecutive-row trick: rawData+1 as lhs, rawData as rhs.
+  // For ascending: row[i+1] >= row[i] means sorted.
+  // For descending: row[i+1] <= row[i] means sorted.
+  auto dispatchSimd = [&](auto dummy) {
+    using T = decltype(dummy);
+    const T* rawData = keyCol->asFlatVector<T>()->rawValues();
+    if (ascending) {
+      functions::applySimdComparison<T, false, false, std::greater_equal<>>(
+          0, numCompares, rawData + 1, rawData, simdResult);
+    } else {
+      functions::applySimdComparison<T, false, false, std::less_equal<>>(
+          0, numCompares, rawData + 1, rawData, simdResult);
+    }
+  };
+
+  auto kind = keyCol->typeKind();
+  if (kind == TypeKind::TINYINT) {
+    dispatchSimd(int8_t{});
+  } else if (kind == TypeKind::SMALLINT) {
+    dispatchSimd(int16_t{});
+  } else if (kind == TypeKind::INTEGER) {
+    dispatchSimd(int32_t{});
+  } else {
+    VELOX_DCHECK_EQ(kind, TypeKind::BIGINT);
+    dispatchSimd(int64_t{});
+  }
+
+  // Copy SIMD results into resultBits with +1 offset.
+  // simdResult bit i = comparison result for (data[i+1] vs data[i]).
+  // Row 0 is handled by cross-batch logic, so we write starting at bit 1.
+  bits::copyBits(
+      reinterpret_cast<const uint64_t*>(simdResult),
+      0,
+      resultBits,
+      1,
+      numCompares);
+}
+
+RowVectorPtr MarkSorted::getOutput() {
+  if (isFinished() || !input_) {
+    return nullptr;
+  }
+
+  auto outputSize = input_->size();
+
+  // Handle empty batches.
+  if (outputSize == 0) {
+    input_ = nullptr;
+    return nullptr;
+  }
+
+  // Re-use memory for the marker vector if possible.
+  VectorPtr& result = results_[0];
+  if (result && result.use_count() == 1) {
+    BaseVector::prepareForReuse(result, outputSize);
+  } else {
+    result = BaseVector::create(BOOLEAN(), outputSize, operatorCtx_->pool());
+  }
+
+  auto resultBits =
+      results_[0]->as<FlatVector<bool>>()->mutableRawValues<uint64_t>();
+
+  // Initialize all bits to true (sorted), then clear for violations.
+  bits::fillBits(resultBits, 0, outputSize, true);
+
+  // Cross-batch comparison: compare first row of current batch with last row
+  // of previous batch.
+  if (prevInput_) {
+    // Zero-copy mode: prevInput_ has same schema as current input.
+    for (column_index_t k = 0; k < sortingKeyChannels_.size(); ++k) {
+      auto channel = sortingKeyChannels_[k];
+      auto cmp = prevInput_->childAt(channel)->compare(
+          input_->childAt(channel).get(),
+          prevInput_->size() - 1,
+          0,
+          compareFlags_[k]);
+      if (cmp.has_value() && cmp.value() != 0) {
+        if (cmp.value() > 0) {
+          // Previous > current in sort order means NOT sorted.
+          bits::clearBit(resultBits, 0);
+        }
+        break;
+      }
+    }
+    prevInput_.reset();
+  } else if (lastRow_) {
+    // Copy mode: lastRow_ has key columns at sequential indices.
+    for (column_index_t k = 0; k < sortingKeyChannels_.size(); ++k) {
+      auto channel = sortingKeyChannels_[k];
+      auto cmp = lastRow_->childAt(k)->compare(
+          input_->childAt(channel).get(), 0, 0, compareFlags_[k]);
+      if (cmp.has_value() && cmp.value() != 0) {
+        if (cmp.value() > 0) {
+          bits::clearBit(resultBits, 0);
+        }
+        break;
+      }
+    }
+  }
+
+  // Within-batch comparison.
+  if (allKeysConstant()) {
+    // ConstantVector fast path: all key columns are constant non-null,
+    // so all rows are trivially sorted. Bits are already true.
+  } else if (canApplySimdPath()) {
+    // SIMD fast path: single flat non-null primitive key.
+    applySimdComparison(resultBits, outputSize);
+  } else {
+    // Generic path: compare each row with its predecessor.
+    for (auto i = 1; i < outputSize; ++i) {
+      if (!isSortedRelativeTo(input_, i, input_, i - 1)) {
+        bits::setBit(resultBits, i, false);
+      }
+    }
+  }
+
+  // Store last row for next batch's cross-batch comparison.
+  if (input_->size() < zeroCopyThreshold_) {
+    prevInput_ = input_;
+    lastRow_.reset();
+  } else {
+    copyLastRowKeyColumns();
+    prevInput_.reset();
+  }
+
+  auto output = fillOutput(outputSize, nullptr);
+
+  // Drop reference to input_ to make it singly-referenced at the producer and
+  // allow for memory reuse.
+  input_ = nullptr;
+
+  return output;
+}
+
+void MarkSorted::copyLastRowKeyColumns() {
+  auto lastIndex = input_->size() - 1;
+  auto numKeys = sortingKeyChannels_.size();
+
+  std::vector<VectorPtr> keyChildren(numKeys);
+  for (auto i = 0; i < numKeys; ++i) {
+    auto channel = sortingKeyChannels_[i];
+    const auto& sourceColumn = input_->childAt(channel);
+    keyChildren[i] =
+        BaseVector::create(sourceColumn->type(), 1, operatorCtx_->pool());
+    keyChildren[i]->copy(sourceColumn.get(), 0, lastIndex, 1);
+  }
+
+  lastRow_ = std::make_shared<RowVector>(
+      operatorCtx_->pool(),
+      lastRowType_,
+      nullptr, // no nulls
+      1, // single row
+      std::move(keyChildren));
+}
+
+void MarkSorted::noMoreInput() {
+  Operator::noMoreInput();
+  lastRow_.reset();
+  prevInput_.reset();
+}
+
+bool MarkSorted::isFinished() {
+  return noMoreInput_ && !input_;
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/MarkSorted.h b/velox/exec/MarkSorted.h
new file mode 100644
index 00000000000..e546e3c00a8
--- /dev/null
+++ b/velox/exec/MarkSorted.h
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/exec/Operator.h"
+
+namespace facebook::velox::exec {
+
+/// Marks each row with a boolean indicating whether it maintains sort order
+/// relative to its predecessor. The first row is always marked true.
+/// Subsequent rows are marked true if they are sorted relative to the
+/// previous row based on the configured sorting keys and orders.
+class MarkSorted : public Operator {
+ public:
+  MarkSorted(
+      int32_t operatorId,
+      DriverCtx* driverCtx,
+      const std::shared_ptr<const core::MarkSortedNode>& planNode);
+
+  bool preservesOrder() const override {
+    return true;
+  }
+
+  bool isFilter() const override {
+    return true;
+  }
+
+  bool needsInput() const override {
+    return !noMoreInput_ && !input_;
+  }
+
+  void addInput(RowVectorPtr input) override;
+
+  RowVectorPtr getOutput() override;
+
+  BlockingReason isBlocked(ContinueFuture* /*future*/) override {
+    return BlockingReason::kNotBlocked;
+  }
+
+  bool isFinished() override;
+
+  void noMoreInput() override;
+
+ private:
+  /// Compare row at currentIndex in currentData with row at prevIndex in
+  /// prevData. Both vectors must share the same schema (uses
+  /// sortingKeyChannels_ to access columns).
+  bool isSortedRelativeTo(
+      const RowVectorPtr& currentData,
+      vector_size_t currentIndex,
+      const RowVectorPtr& prevData,
+      vector_size_t prevIndex);
+
+  /// Copy only sorting key columns of the last row from input_ into lastRow_.
+  /// Creates a single-row RowVector with key columns at sequential indices
+  /// (0, 1, 2, ...) to avoid holding a reference to the entire input batch.
+  void copyLastRowKeyColumns();
+
+  /// Returns true if all key columns in input_ use constant encoding with
+  /// non-null values. When true, within-batch comparison can be skipped
+  /// entirely since all rows have the same key values.
+  bool allKeysConstant() const;
+
+  /// Returns true if input has a single sorting key that is flat, non-null,
+  /// and a SIMD-eligible primitive type.
+  bool canApplySimdPath() const;
+
+  /// Apply SIMD comparison for a single primitive sorting key. Writes
+  /// bit-packed results into resultBits (clears bits for unsorted rows).
+  /// Row 0 is not modified (handled by cross-batch logic).
+  void applySimdComparison(uint64_t* resultBits, vector_size_t numRows);
+
+  const std::string markerName_;
+  std::vector<column_index_t> sortingKeyChannels_;
+  std::vector<CompareFlags> compareFlags_;
+  std::vector<core::SortOrder> sortingOrders_;
+
+  /// Key-only RowType for lastRow_ construction. Columns are at sequential
+  /// indices (0, 1, 2, ...) mapping to sortingKeyChannels_ in the input.
+  RowTypePtr lastRowType_;
+
+  /// Stores only sorting key column values of the last row from the previous
+  /// batch, for cross-batch comparison. Has a different schema than input_
+  /// (key columns only), so cross-batch comparison uses inline logic instead
+  /// of isSortedRelativeTo().
+  RowVectorPtr lastRow_;
+
+  /// Zero-copy: holds reference to the previous input batch for cross-batch
+  /// comparison when the batch is smaller than zeroCopyThreshold_. Mutually
+  /// exclusive with lastRow_ (one or neither is set, never both).
+  RowVectorPtr prevInput_;
+
+  /// Batch size threshold for zero-copy optimization. Batches smaller than
+  /// this hold a reference to the entire batch; larger batches deep-copy
+  /// key columns only.
+  const int32_t zeroCopyThreshold_;
+
+  /// Reusable buffer for SIMD comparison results. Allocated on first use
+  /// and grown as needed to avoid per-batch allocation overhead.
+  BufferPtr simdBuffer_;
+};
+} // namespace facebook::velox::exec
diff --git a/velox/exec/MemoryReclaimer.cpp b/velox/exec/MemoryReclaimer.cpp
index 4aee429883d..1837da7881b 100644
--- a/velox/exec/MemoryReclaimer.cpp
+++ b/velox/exec/MemoryReclaimer.cpp
@@ -108,9 +108,10 @@ uint64_t ParallelMemoryReclaimer::reclaim(
         if (!reclaimableBytesOpt.has_value()) {
           continue;
         }
-        candidates.push_back(Candidate{
-            std::move(child),
-            static_cast<int64_t>(reclaimableBytesOpt.value())});
+        candidates.push_back(
+            Candidate{
+                std::move(child),
+                static_cast<int64_t>(reclaimableBytesOpt.value())});
       }
     }
   }
@@ -134,21 +135,23 @@ uint64_t ParallelMemoryReclaimer::reclaim(
     if (candidate.reclaimableBytes == 0) {
       continue;
     }
-    reclaimTasks.push_back(memory::createAsyncMemoryReclaimTask<ReclaimResult>(
-        [&, reclaimPool = candidate.pool]() {
-          try {
-            Stats reclaimStats;
-            const auto bytes =
-                reclaimPool->reclaim(targetBytes, maxWaitMs, reclaimStats);
-            return std::make_unique<ReclaimResult>(
-                bytes, std::move(reclaimStats));
-          } catch (const std::exception& e) {
-            VELOX_MEM_LOG(ERROR) << "Reclaim from memory pool " << pool->name()
-                                 << " failed: " << e.what();
-            // The exception is captured and thrown by the caller.
-            return std::make_unique<ReclaimResult>(std::current_exception());
-          }
-        }));
+    reclaimTasks.push_back(
+        memory::createAsyncMemoryReclaimTask<ReclaimResult>(
+            [&, reclaimPool = candidate.pool]() {
+              try {
+                Stats reclaimStats;
+                const auto bytes =
+                    reclaimPool->reclaim(targetBytes, maxWaitMs, reclaimStats);
+                return std::make_unique<ReclaimResult>(
+                    bytes, std::move(reclaimStats));
+              } catch (const std::exception& e) {
+                VELOX_MEM_LOG(ERROR) << "Reclaim from memory pool "
+                                     << pool->name() << " failed: " << e.what();
+                // The exception is captured and thrown by the caller.
+                return std::make_unique<ReclaimResult>(
+                    std::current_exception());
+              }
+            }));
     if (reclaimTasks.size() > 1) {
       executor_->add([source = reclaimTasks.back()]() { source->prepare(); });
     }
diff --git a/velox/exec/Merge.cpp b/velox/exec/Merge.cpp
index 887fec7017e..aada7c0a413 100644
--- a/velox/exec/Merge.cpp
+++ b/velox/exec/Merge.cpp
@@ -15,26 +15,16 @@
  */
 
 #include "velox/exec/Merge.h"
+#include <folly/Traits.h>
+#include <exception>
 #include "velox/common/testutil/TestValue.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/Task.h"
 
 using facebook::velox::common::testutil::TestValue;
 
 namespace facebook::velox::exec {
-namespace {
-std::unique_ptr<VectorSerde::Options> getVectorSerdeOptions(
-    const core::QueryConfig& queryConfig,
-    VectorSerde::Kind kind) {
-  std::unique_ptr<VectorSerde::Options> options =
-      kind == VectorSerde::Kind::kPresto
-      ? std::make_unique<serializer::presto::PrestoVectorSerde::PrestoOptions>()
-      : std::make_unique<VectorSerde::Options>();
-  options->compressionKind =
-      common::stringToCompressionKind(queryConfig.shuffleCompressionKind());
-  return options;
-}
-} // namespace
 
 Merge::Merge(
     int32_t operatorId,
@@ -44,7 +34,7 @@ Merge::Merge(
         sortingKeys,
     const std::vector<core::SortOrder>& sortingOrders,
     const std::string& planNodeId,
-    const std::string& operatorType,
+    std::string_view operatorType,
     const std::optional<common::SpillConfig>& spillConfig)
     : SourceOperator(
           driverCtx,
@@ -170,8 +160,12 @@ void Merge::setupSpillMerger() {
     std::vector<std::unique_ptr<SpillReadFile>> spillReadFiles;
     spillReadFiles.reserve(spillFiles.size());
     for (const auto& spillFile : spillFiles) {
-      spillReadFiles.emplace_back(SpillReadFile::create(
-          spillFile, spillConfig_->readBufferSize, pool(), spillStats_.get()));
+      spillReadFiles.emplace_back(
+          SpillReadFile::create(
+              spillFile,
+              spillConfig_->readBufferSize,
+              pool(),
+              spillStats_.get()));
     }
     spillReadFilesGroups.push_back(std::move(spillReadFiles));
   }
@@ -206,8 +200,9 @@ void Merge::maybeStartNextMergeSourceGroup() {
   std::vector<std::unique_ptr<SourceStream>> cursors;
   cursors.reserve(sources.size());
   for (auto* source : sources) {
-    cursors.push_back(std::make_unique<SourceStream>(
-        source, sortingKeys_, maxOutputBatchRows_));
+    cursors.push_back(
+        std::make_unique<SourceStream>(
+            source, sortingKeys_, maxOutputBatchRows_));
   }
 
   // TODO: consider to provide a config other than the regular operator batch
@@ -342,8 +337,9 @@ SourceMerger::SourceMerger(
         }
         return streams;
       }()),
-      merger_(std::make_unique<TreeOfLosers<SourceStream>>(
-          std::move(sourceStreams))),
+      merger_(
+          std::make_unique<TreeOfLosers<SourceStream>>(
+              std::move(sourceStreams))),
       pool_(pool) {}
 
 void SourceMerger::isBlocked(
@@ -390,10 +386,7 @@ RowVectorPtr SourceMerger::getOutput(
   VELOX_CHECK_GT(outputBatchRows_, 0);
 
   if (!output_) {
-    output_ = BaseVector::create<RowVector>(type_, outputBatchRows_, pool_);
-    for (auto& child : output_->children()) {
-      child->resize(outputBatchRows_);
-    }
+    output_ = createOutputVector();
   }
 
   for (;;) {
@@ -439,6 +432,23 @@ RowVectorPtr SourceMerger::getOutput(
   }
 }
 
+RowVectorPtr SourceMerger::createOutputVector() {
+  // Attempt to generate output vector using stream data to preserve encodings.
+  // First, find the first stream with non-null data to determine column
+  // encodings.
+  const RowVector* source = nullptr;
+  for (const auto* stream : streams_) {
+    if (stream->hasData() && (source = stream->data())) {
+      return BaseVector::createEmptyLike<RowVector>(
+          source, outputBatchRows_, pool_);
+    }
+  }
+
+  // If a non-null stream cannot be found, default to generating row vector by
+  // type.
+  return BaseVector::create<RowVector>(type_, outputBatchRows_, pool_);
+}
+
 bool SourceStream::operator<(const MergeStream& other) const {
   const auto& otherCursor = static_cast<const SourceStream&>(other);
   for (auto i = 0; i < sortingKeys_.size(); ++i) {
@@ -496,7 +506,8 @@ void SourceStream::copyToOutput(RowVectorPtr& output) {
 
 bool SourceStream::fetchMoreData(std::vector<ContinueFuture>& futures) {
   ContinueFuture future;
-  auto reason = source_->next(data_, &future);
+  bool drained{false};
+  auto reason = source_->next(data_, &future, drained);
   if (reason != BlockingReason::kNotBlocked) {
     needData_ = true;
     futures.emplace_back(std::move(future));
@@ -528,7 +539,7 @@ SpillMerger::SpillMerger(
     uint64_t maxOutputBatchBytes,
     int mergeSourceQueueSize,
     const common::SpillConfig* spillConfig,
-    const std::shared_ptr<folly::Synchronized<common::SpillStats>>& spillStats,
+    const std::shared_ptr<exec::SpillStats>& spillStats,
     velox::memory::MemoryPool* pool)
     : executor_(spillConfig->executor),
       spillStats_(spillStats),
@@ -562,14 +573,21 @@ void SpillMerger::start() {
 
 RowVectorPtr SpillMerger::getOutput(
     std::vector<ContinueFuture>& sourceBlockingFutures,
-    bool& atEnd) const {
+    bool& atEnd) {
   TestValue::adjust(
       "facebook::velox::exec::SpillMerger::getOutput", &sourceBlockingFutures);
   sourceMerger_->isBlocked(sourceBlockingFutures);
   if (!sourceBlockingFutures.empty()) {
     return nullptr;
   }
-  return sourceMerger_->getOutput(sourceBlockingFutures, atEnd);
+  // SpillMerger::getOutput waits for all readers to finish, reaches EOF,
+  // and rethrows any captured error. Centralizing error propagation here
+  // helps prevent potential resource leaks.
+  auto output = sourceMerger_->getOutput(sourceBlockingFutures, atEnd);
+  if (atEnd) {
+    checkError();
+  }
+  return output;
 }
 
 std::vector<std::shared_ptr<MergeSource>> SpillMerger::createMergeSources(
@@ -609,68 +627,105 @@ std::unique_ptr<SourceMerger> SpillMerger::createSourceMerger(
   std::vector<std::unique_ptr<SourceStream>> streams;
   streams.reserve(sources.size());
   for (const auto& source : sources) {
-    streams.push_back(std::make_unique<SourceStream>(
-        source.get(), sortingKeys, maxOutputBatchRows));
+    streams.push_back(
+        std::make_unique<SourceStream>(
+            source.get(), sortingKeys, maxOutputBatchRows));
   }
   return std::make_unique<SourceMerger>(
       type, std::move(streams), maxOutputBatchRows, maxOutputBatchBytes, pool);
 }
 
-// static.
-void SpillMerger::asyncReadFromSpillFileStream(
+void SpillMerger::finishSource(size_t streamIdx) const {
+  ContinueFuture future{ContinueFuture::makeEmpty()};
+  sources_[streamIdx]->enqueue(nullptr, &future);
+  VELOX_CHECK(!future.valid());
+}
+
+void SpillMerger::readFromSpillFileStream(
     const std::weak_ptr<SpillMerger>& mergeHolder,
     size_t streamIdx) {
   TestValue::adjust(
-      "facebook::velox::exec::SpillMerger::asyncReadFromSpillFileStream",
-      static_cast<void*>(0));
+      "facebook::velox::exec::SpillMerger::readFromSpillFileStream", nullptr);
   const auto merger = mergeHolder.lock();
   if (merger == nullptr) {
     LOG(ERROR) << "SpillMerger is destroyed, abandon reading from batch stream";
     return;
   }
-  merger->readFromSpillFileStream(streamIdx);
-}
 
-void SpillMerger::readFromSpillFileStream(size_t streamIdx) {
-  RowVectorPtr vector;
-  ContinueFuture future{ContinueFuture::makeEmpty()};
-  if (!batchStreams_[streamIdx]->nextBatch(vector)) {
-    VELOX_CHECK_NULL(vector);
-    sources_[streamIdx]->enqueue(nullptr, &future);
-    VELOX_CHECK(!future.valid());
-    return;
-  }
-  const auto blockingReason =
-      sources_[streamIdx]->enqueue(std::move(vector), &future);
-  // TODO: add async error handling.
-  if (blockingReason == BlockingReason::kNotBlocked) {
-    VELOX_CHECK(!future.valid());
-    executor_->add(
-        [mergeHolder = std::weak_ptr(shared_from_this()), streamIdx]() {
-          asyncReadFromSpillFileStream(mergeHolder, streamIdx);
-        });
-  } else {
-    VELOX_CHECK(future.valid());
-    std::move(future)
-        .via(executor_)
-        .thenValue([mergeHolder = std::weak_ptr(shared_from_this()),
-                    streamIdx](folly::Unit) {
-          asyncReadFromSpillFileStream(mergeHolder, streamIdx);
-        })
-        .thenError(
-            folly::tag_t<std::exception>{},
-            [streamIdx](const std::exception& e) {
-              LOG(ERROR) << "Stop the " << streamIdx
-                         << "th batch stream producer on error: " << e.what();
-            });
+  try {
+    if (hasError()) {
+      finishSource(streamIdx);
+      return;
+    }
+
+    RowVectorPtr vector;
+    if (!batchStreams_[streamIdx]->nextBatch(vector)) {
+      VELOX_CHECK_NULL(vector);
+      finishSource(streamIdx);
+      return;
+    }
+
+    ContinueFuture future{ContinueFuture::makeEmpty()};
+    const auto blockingReason =
+        sources_[streamIdx]->enqueue(std::move(vector), &future);
+    if (blockingReason == BlockingReason::kNotBlocked) {
+      VELOX_CHECK(!future.valid());
+      readFromSpillFileStream(mergeHolder, streamIdx);
+    } else {
+      VELOX_CHECK(future.valid());
+      std::move(future)
+          .via(executor_)
+          .thenValue([this, mergeHolder, streamIdx](auto&&) {
+            readFromSpillFileStream(mergeHolder, streamIdx);
+          })
+          .thenError(
+              folly::tag_t<std::exception>{},
+              [this, mergeHolder, streamIdx](const std::exception& e) {
+                const auto merger = mergeHolder.lock();
+                if (merger != nullptr) {
+                  LOG(ERROR) << "Stop the " << streamIdx
+                             << " th source on error: " << e.what();
+                  setError(std::make_exception_ptr(e));
+                  finishSource(streamIdx);
+                }
+              });
+    }
+  } catch (const std::exception& e) {
+    LOG(ERROR) << "The " << streamIdx
+               << " spill stream failed with error: " << e.what();
+    setError(std::current_exception());
+    finishSource(streamIdx);
   }
 }
 
 void SpillMerger::scheduleAsyncSpillFileStreamReads() {
   VELOX_CHECK_EQ(batchStreams_.size(), sources_.size());
   for (auto i = 0; i < batchStreams_.size(); ++i) {
-    executor_->add(
-        [&, streamIdx = i]() { readFromSpillFileStream(streamIdx); });
+    executor_->add([&, streamIdx = i]() {
+      readFromSpillFileStream(std::weak_ptr(shared_from_this()), streamIdx);
+    });
+  }
+}
+
+void SpillMerger::setError(const std::exception_ptr& exception) {
+  std::lock_guard l(mutex_);
+  if (exception_ != nullptr) {
+    return;
+  }
+  exception_ = exception;
+}
+
+bool SpillMerger::hasError() const {
+  std::lock_guard l(mutex_);
+  return exception_ != nullptr;
+}
+
+void SpillMerger::checkError() {
+  if (hasError()) {
+    sourceMerger_.reset();
+    batchStreams_.clear();
+    sources_.clear();
+    std::rethrow_exception(exception_);
   }
 }
 
@@ -685,9 +740,11 @@ LocalMerge::LocalMerge(
           localMergeNode->sortingKeys(),
           localMergeNode->sortingOrders(),
           localMergeNode->id(),
-          "LocalMerge",
+          OperatorType::kLocalMerge,
           localMergeNode->canSpill(driverCtx->queryConfig())
-              ? driverCtx->makeSpillConfig(operatorId)
+              ? driverCtx->makeSpillConfig(
+                    operatorId,
+                    OperatorType::kLocalMerge)
               : std::nullopt) {
   VELOX_CHECK_EQ(
       operatorCtx_->driverCtx()->driverId,
@@ -722,11 +779,14 @@ MergeExchange::MergeExchange(
           mergeExchangeNode->sortingKeys(),
           mergeExchangeNode->sortingOrders(),
           mergeExchangeNode->id(),
-          "MergeExchange"),
+          OperatorType::kMergeExchange),
       serde_(getNamedVectorSerde(mergeExchangeNode->serdeKind())),
       serdeOptions_(getVectorSerdeOptions(
-          driverCtx->queryConfig(),
-          mergeExchangeNode->serdeKind())) {}
+          common::stringToCompressionKind(
+              driverCtx->queryConfig().shuffleCompressionKind()),
+          mergeExchangeNode->serdeKind(),
+          std::nullopt,
+          driverCtx->queryConfig().minShuffleCompressionPageSizeBytes())) {}
 
 BlockingReason MergeExchange::addMergeSources(ContinueFuture* future) {
   if (operatorCtx_->driverCtx()->driverId != 0) {
@@ -741,7 +801,14 @@ BlockingReason MergeExchange::addMergeSources(ContinueFuture* future) {
   for (;;) {
     exec::Split split;
     auto reason = operatorCtx_->task()->getSplitOrFuture(
-        operatorCtx_->driverCtx()->splitGroupId, planNodeId(), split, *future);
+
+        operatorCtx_->driverCtx()->driverId,
+        operatorCtx_->driverCtx()->splitGroupId,
+        planNodeId(),
+        /*maxPreloadSplits=*/0,
+        /*preload=*/nullptr,
+        split,
+        *future);
     if (reason != BlockingReason::kNotBlocked) {
       return reason;
     }
@@ -770,13 +837,14 @@ BlockingReason MergeExchange::addMergeSources(ContinueFuture* future) {
             operatorCtx_->planNodeId(),
             operatorCtx_->driverCtx()->pipelineId,
             remoteSourceIndex);
-        sources_.emplace_back(MergeSource::createMergeExchangeSource(
-            this,
-            remoteSourceTaskIds_[remoteSourceIndex],
-            operatorCtx_->task()->destination(),
-            maxQueuedBytesPerSource,
-            pool,
-            operatorCtx_->task()->queryCtx()->executor()));
+        sources_.emplace_back(
+            MergeSource::createMergeExchangeSource(
+                this,
+                remoteSourceTaskIds_[remoteSourceIndex],
+                operatorCtx_->task()->destination(),
+                maxQueuedBytesPerSource,
+                pool,
+                operatorCtx_->task()->queryCtx()->executor()));
       }
     }
     // TODO Delay this call until all input data has been processed.
@@ -795,7 +863,8 @@ void MergeExchange::close() {
     auto lockedStats = stats_.wlock();
     lockedStats->addRuntimeStat(
         Operator::kShuffleSerdeKind,
-        RuntimeCounter(static_cast<int64_t>(serde_->kind())));
+        RuntimeCounter(
+            static_cast<int64_t>(VectorSerde::kindByName(serde_->kind()))));
     lockedStats->addRuntimeStat(
         Operator::kShuffleCompressionKind,
         RuntimeCounter(static_cast<int64_t>(serdeOptions_->compressionKind)));
diff --git a/velox/exec/Merge.h b/velox/exec/Merge.h
index f41dfebd94f..799ba348fe0 100644
--- a/velox/exec/Merge.h
+++ b/velox/exec/Merge.h
@@ -15,11 +15,11 @@
  */
 #pragma once
 
+#include "velox/common/base/TreeOfLosers.h"
 #include "velox/exec/Exchange.h"
 #include "velox/exec/MergeSource.h"
 #include "velox/exec/Spill.h"
 #include "velox/exec/Spiller.h"
-#include "velox/exec/TreeOfLosers.h"
 
 namespace facebook::velox::exec {
 
@@ -40,7 +40,7 @@ class Merge : public SourceOperator {
           sortingKeys,
       const std::vector<core::SortOrder>& sortingOrders,
       const std::string& planNodeId,
-      const std::string& operatorType,
+      std::string_view operatorType,
       const std::optional<common::SpillConfig>& spillConfig = std::nullopt);
 
   void initialize() override;
@@ -61,12 +61,12 @@ class Merge : public SourceOperator {
   /// The running wall time of the merge operator reading from the streaming
   /// source. If spilling is enabled for local merge, this also includes the
   /// time that writes to the spilled source.
-  static inline const std::string kStreamingSourceReadWallNanos{
+  static constexpr std::string_view kStreamingSourceReadWallNanos{
       "streamingSourceReadWallNanos"};
   /// The running wall time of the merge operator reading from the spilled
   /// source to produce the final output. This only applies when spilling is
   /// enabled for local merge.
-  static inline const std::string kSpilledSourceReadWallNanos{
+  static constexpr std::string_view kSpilledSourceReadWallNanos{
       "spilledSourceReadWallNanos"};
 
  protected:
@@ -167,6 +167,10 @@ class SourceMerger {
  private:
   void setOutputBatchSize();
 
+  /// Creates the output vector. If a template is available from input data,
+  /// creates output children with matching encodings to support FlatMapVector.
+  RowVectorPtr createOutputVector();
+
   const RowTypePtr type_;
   const vector_size_t maxOutputBatchRows_;
   const uint64_t maxOutputBatchBytes_;
@@ -211,6 +215,12 @@ class SourceStream final : public MergeStream {
     return !atEnd_;
   }
 
+  /// Returns the current data batch from the source. Used for encoding
+  /// detection to create output vectors with matching encodings.
+  const RowVector* data() const {
+    return data_.get();
+  }
+
   // Returns the estimated row size based on the vector received from the
   // merge source.
   std::optional<int64_t> estimateRowSize() const {
@@ -292,8 +302,7 @@ class SpillMerger : public std::enable_shared_from_this<SpillMerger> {
       uint64_t maxOutputBatchBytes,
       int mergeSourceQueueSize,
       const common::SpillConfig* spillConfig,
-      const std::shared_ptr<folly::Synchronized<common::SpillStats>>&
-          spillStats,
+      const std::shared_ptr<exec::SpillStats>& spillStats,
       velox::memory::MemoryPool* pool);
 
   ~SpillMerger();
@@ -302,7 +311,7 @@ class SpillMerger : public std::enable_shared_from_this<SpillMerger> {
 
   RowVectorPtr getOutput(
       std::vector<ContinueFuture>& sourceBlockingFutures,
-      bool& atEnd) const;
+      bool& atEnd);
 
  private:
   static std::vector<std::shared_ptr<MergeSource>> createMergeSources(
@@ -321,21 +330,32 @@ class SpillMerger : public std::enable_shared_from_this<SpillMerger> {
       uint64_t maxOutputBatchBytes,
       velox::memory::MemoryPool* pool);
 
-  static void asyncReadFromSpillFileStream(
+  void finishSource(size_t streamIdx) const;
+
+  void readFromSpillFileStream(
       const std::weak_ptr<SpillMerger>& mergeHolder,
       size_t streamIdx);
 
-  void readFromSpillFileStream(size_t streamIdx);
-
   void scheduleAsyncSpillFileStreamReads();
 
+  // Sets 'exception_' when an async reader throws.
+  void setError(const std::exception_ptr& exception);
+
+  // Returns true if any async reader has thrown an exception.
+  bool hasError() const;
+
+  // If any async reader has thrown an exception, rethrows it.
+  void checkError();
+
   folly::Executor* const executor_;
-  const std::shared_ptr<folly::Synchronized<common::SpillStats>> spillStats_;
+  const std::shared_ptr<exec::SpillStats> spillStats_;
   const std::shared_ptr<memory::MemoryPool> pool_;
 
   std::vector<std::shared_ptr<MergeSource>> sources_;
   std::vector<std::unique_ptr<BatchStream>> batchStreams_;
   std::unique_ptr<SourceMerger> sourceMerger_;
+  mutable std::timed_mutex mutex_;
+  std::exception_ptr exception_ = nullptr;
 };
 
 // LocalMerge merges its source's output into a single stream of
diff --git a/velox/exec/MergeJoin.cpp b/velox/exec/MergeJoin.cpp
index b5cc721b04c..65d2d180718 100644
--- a/velox/exec/MergeJoin.cpp
+++ b/velox/exec/MergeJoin.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 #include "velox/exec/MergeJoin.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/Task.h"
 #include "velox/expression/FieldReference.h"
@@ -48,11 +49,20 @@ MergeJoin::MergeJoin(
           joinNode->outputType(),
           operatorId,
           joinNode->id(),
-          "MergeJoin"),
-      outputBatchSize_{outputBatchRows()},
+          OperatorType::kMergeJoin),
+      preferredOutputBatchBytes_{
+          driverCtx->queryConfig().preferredOutputBatchBytes()},
+      preferredOutputBatchRows_{
+          driverCtx->queryConfig().preferredOutputBatchRows()},
+      dynamicOutputBatchSizeEnabled_{
+          driverCtx->queryConfig().mergeJoinOutputBatchStartSize() != 0},
       joinType_{joinNode->joinType()},
       numKeys_{joinNode->leftKeys().size()},
       rightNodeId_{joinNode->sources()[1]->id()},
+      outputBatchSize_{
+          dynamicOutputBatchSizeEnabled_
+              ? driverCtx->queryConfig().mergeJoinOutputBatchStartSize()
+              : preferredOutputBatchRows_},
       joinNode_(joinNode) {
   VELOX_USER_CHECK(
       core::MergeJoinNode::isSupported(joinType_),
@@ -111,12 +121,12 @@ void MergeJoin::initialize() {
     if (joinNode_->isLeftJoin() || joinNode_->isAntiJoin() ||
         joinNode_->isRightJoin() || joinNode_->isFullJoin() ||
         isSemiFilterJoin(joinType_)) {
-      joinTracker_ = JoinTracker(outputBatchSize_, pool());
+      joinTracker_ = JoinTracker(preferredOutputBatchRows_, pool());
     }
   } else if (joinNode_->isAntiJoin()) {
     // Anti join needs to track the left side rows that have no match on the
     // right.
-    joinTracker_ = JoinTracker(outputBatchSize_, pool());
+    joinTracker_ = JoinTracker(preferredOutputBatchRows_, pool());
   }
 
   joinNode_.reset();
@@ -226,28 +236,37 @@ void MergeJoin::addInput(RowVectorPtr input) {
 
 // static
 int32_t MergeJoin::compare(
-    const std::vector<column_index_t>& keys,
-    const RowVectorPtr& batch,
-    vector_size_t index,
-    const std::vector<column_index_t>& otherKeys,
-    const RowVectorPtr& otherBatch,
-    vector_size_t otherIndex) {
-  for (auto i = 0; i < keys.size(); ++i) {
+    const std::vector<column_index_t>& leftKeys,
+    const RowVectorPtr& leftBatch,
+    vector_size_t leftIndex,
+    const std::vector<column_index_t>& rightKeys,
+    const RowVectorPtr& rightBatch,
+    vector_size_t rightIndex) {
+  for (auto i = 0; i < leftKeys.size(); ++i) {
     static const CompareFlags kCompareFlags = {
         .equalsOnly = true,
         .nullHandlingMode =
             CompareFlags::NullHandlingMode::kNullAsIndeterminate};
-    const auto compare = batch->childAt(keys[i])->compare(
-        otherBatch->childAt(otherKeys[i]).get(),
-        index,
-        otherIndex,
-        kCompareFlags);
+    const auto compare = leftBatch->childAt(leftKeys[i])
+                             ->compare(
+                                 rightBatch->childAt(rightKeys[i]).get(),
+                                 leftIndex,
+                                 rightIndex,
+                                 kCompareFlags);
 
-    // Comparing null with anything will return std::nullopt.
     if (!compare.has_value()) {
-      // The SQL semantics of Presto and Spark will always return false if
-      // comparing a NULL value with any other value.
-      return -1;
+      // Under CompareFlags::NullHandlingMode::kNullAsIndeterminate,
+      // std::nullopt is returned in three cases:
+      //   1) Both the left key and the right key are null.
+      //   2) The left key is null, and the right key is not null.
+      //   3) The left key is not null, and the right key is null.
+      //
+      // However, the comparison result semantics differ:
+      // - Cases (1) and (2): return -1, meaning input_ should catch up with
+      // rightInput_.
+      // - Case (3): return 1, indicating the left key is considered greater,
+      //   so rightInput_ should catch up with input_ in the subsequent steps.
+      return leftBatch->childAt(leftKeys[i])->isNullAt(leftIndex) ? -1 : 1;
     } else if (compare.value() != 0) {
       return compare.value();
     }
@@ -559,7 +578,7 @@ bool MergeJoin::prepareOutput(
       } else {
         inputs[i] = BaseVector::create(
             filterInputType_->childAt(i),
-            outputBatchSize_,
+            preferredOutputBatchRows_,
             operatorCtx_->pool());
       }
     }
@@ -568,7 +587,7 @@ bool MergeJoin::prepareOutput(
         operatorCtx_->pool(),
         filterInputType_,
         nullptr,
-        outputBatchSize_,
+        preferredOutputBatchRows_,
         std::move(inputs));
   }
   return false;
@@ -751,6 +770,9 @@ RowVectorPtr MergeJoin::getOutput() {
   for (;;) {
     auto output = doGetOutput();
     if (output != nullptr && output->size() > 0) {
+      // Update the batch size based on the output before filtering.
+      updateOutputBatchSize(output);
+
       if (filter_) {
         output = applyFilter(output);
         if (output != nullptr) {
@@ -996,19 +1018,23 @@ RowVectorPtr MergeJoin::doGetOutput() {
           leftEndRow < input_->size(),
           std::nullopt};
 
-      vector_size_t endRightRow = rightRowIndex_ + 1;
-      while (endRightRow < rightInput_->size() &&
-             compareRight(endRightRow) == 0) {
-        ++endRightRow;
+      vector_size_t rightEndRow = rightRowIndex_ + 1;
+      while (rightEndRow < rightInput_->size() &&
+             compareRight(rightEndRow) == 0) {
+        ++rightEndRow;
       }
 
       rightMatch_ = Match{
           {rightInput_},
           rightRowIndex_,
-          endRightRow,
-          endRightRow < rightInput_->size(),
+          rightEndRow,
+          rightEndRow < rightInput_->size(),
           std::nullopt};
 
+      // Track matched rows for this key match.
+      matchedLeftRows_ += leftEndRow - leftMatch_->startRowIndex;
+      matchedRightRows_ += rightEndRow - rightMatch_->startRowIndex;
+
       if (!leftMatch_->complete || !rightMatch_->complete) {
         if (!leftMatch_->complete) {
           // Need to continue looking for the end of match.
@@ -1024,10 +1050,10 @@ RowVectorPtr MergeJoin::doGetOutput() {
 
       leftRowIndex_ = leftEndRow;
       if (isFullJoin(joinType_) || isRightJoin(joinType_)) {
-        rightRowIndex_ = endRightRow;
+        rightRowIndex_ = rightEndRow;
       } else {
         rightRowIndex_ =
-            firstNonNull(rightInput_, rightKeyChannels_, endRightRow);
+            firstNonNull(rightInput_, rightKeyChannels_, rightEndRow);
       }
 
       if (rightBatchFinished()) {
@@ -1267,6 +1293,34 @@ void MergeJoin::clearRightInput() {
   rightInput_ = nullptr;
 }
 
+void MergeJoin::updateOutputBatchSize(const RowVectorPtr& output) {
+  if (!dynamicOutputBatchSizeEnabled_) {
+    return;
+  }
+
+  VELOX_CHECK_NOT_NULL(output);
+
+  const auto outputSize = output->size();
+  VELOX_CHECK_GT(outputSize, 0);
+
+  // Calculate average row size from the current output batch.
+  const auto avgRowSize = output->estimateFlatSize() / outputSize;
+
+  if (avgRowSize == 0) {
+    // Avoid division by zero; keep current batch size.
+    return;
+  }
+
+  outputBatchSize_ = std::min(
+      static_cast<uint64_t>(preferredOutputBatchBytes_ / avgRowSize),
+      static_cast<uint64_t>(preferredOutputBatchRows_));
+
+  // Ensure we have at least 1 row.
+  if (outputBatchSize_ == 0) {
+    outputBatchSize_ = 1;
+  }
+}
+
 RowVectorPtr MergeJoin::applyFilter(const RowVectorPtr& output) {
   const auto numRows = output->size();
 
@@ -1464,6 +1518,16 @@ bool MergeJoin::isFinished() {
 }
 
 void MergeJoin::close() {
+  // Report match ratio statistics.
+  {
+    auto lockedStats = stats_.wlock();
+    lockedStats->addRuntimeStat(
+        std::string(MergeJoin::kMatchedLeftRows),
+        RuntimeCounter(matchedLeftRows_));
+    lockedStats->addRuntimeStat(
+        std::string(MergeJoin::kMatchedRightRows),
+        RuntimeCounter(matchedRightRows_));
+  }
   if (rightSource_) {
     rightSource_->close();
   }
diff --git a/velox/exec/MergeJoin.h b/velox/exec/MergeJoin.h
index 414cb77bcaa..58b41a2e659 100644
--- a/velox/exec/MergeJoin.h
+++ b/velox/exec/MergeJoin.h
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 #pragma once
+#include <string_view>
+
 #include <folly/container/F14Map.h>
 
 #include "velox/exec/MergeSource.h"
@@ -44,6 +46,12 @@ namespace facebook::velox::exec {
 /// than one right vector, it gets copied and flattened.
 class MergeJoin : public Operator {
  public:
+  /// Runtime stat keys for merge join.
+  /// Number of left rows matched in merge join.
+  static constexpr std::string_view kMatchedLeftRows = "matchedLeftRows";
+  /// Number of right rows matched in merge join.
+  static constexpr std::string_view kMatchedRightRows = "matchedRightRows";
+
   MergeJoin(
       int32_t operatorId,
       DriverCtx* driverCtx,
@@ -346,6 +354,12 @@ class MergeJoin : public Operator {
     return std::move(output_);
   }
 
+  // Updates outputBatchSize_ dynamically based on the average row size of the
+  // current output batch. The new batch size is computed as:
+  // 1. preferredOutputBatchBytes / avgRowSize
+  // 2. min(result from step 1, preferredOutputBatchRows)
+  void updateOutputBatchSize(const RowVectorPtr& output);
+
   // Evaluates join filter on 'filterInput_' and returns 'output' that contains
   // a subset of rows on which the filter passed. Returns nullptr if no rows
   // passed the filter.
@@ -557,8 +571,15 @@ class MergeJoin : public Operator {
   // dictionaries wrapped around the right side input.
   bool isRightFlattened_{false};
 
-  // Maximum number of rows in the output batch.
-  const vector_size_t outputBatchSize_;
+  // Preferred output batch size in bytes from QueryConfig.
+  const uint64_t preferredOutputBatchBytes_;
+
+  // Preferred output batch size in rows from QueryConfig.
+  const vector_size_t preferredOutputBatchRows_;
+
+  // Whether dynamic output batch sizing is enabled. When disabled (default),
+  // outputBatchSize_ is fixed at preferredOutputBatchRows_.
+  const bool dynamicOutputBatchSizeEnabled_;
 
   // Type of join.
   const core::JoinType joinType_;
@@ -568,6 +589,11 @@ class MergeJoin : public Operator {
 
   const core::PlanNodeId rightNodeId_;
 
+  // Maximum number of rows in the output batch. This is dynamically adjusted
+  // based on the average row size of previous output batches when dynamic
+  // batching is enabled.
+  vector_size_t outputBatchSize_;
+
   // The cached merge join plan node used to initialize this operator after the
   // driver has started execution. It is reset after the initialization.
   std::shared_ptr<const core::MergeJoinNode> joinNode_;
@@ -632,5 +658,11 @@ class MergeJoin : public Operator {
 
   bool leftHasDrained_{false};
   bool rightHasDrained_{false};
+
+  // Stats for tracking matched rows from the left side
+  uint64_t matchedLeftRows_{0};
+
+  // Stats for tracking matched rows from the right side
+  uint64_t matchedRightRows_{0};
 };
 } // namespace facebook::velox::exec
diff --git a/velox/exec/MergeSource.cpp b/velox/exec/MergeSource.cpp
index 2c91c39002a..34ddf2e0cf2 100644
--- a/velox/exec/MergeSource.cpp
+++ b/velox/exec/MergeSource.cpp
@@ -80,14 +80,23 @@ class LocalMergeSource : public MergeSource {
     return queue_.withWLock([&](auto& queue) { return queue.started(future); });
   }
 
-  BlockingReason next(RowVectorPtr& data, ContinueFuture* future) override {
+  BlockingReason next(RowVectorPtr& data, ContinueFuture* future, bool& drained)
+      override {
+    drained = false;
     ScopedPromiseNotification notification(1);
-    return queue_.withWLock(
-        [&](auto& queue) { return queue.next(data, future, notification); });
+    return queue_.withWLock([&](auto& queue) {
+      return queue.next(data, future, drained, notification);
+    });
   }
 
-  BlockingReason enqueue(RowVectorPtr input, ContinueFuture* future) override {
+  BlockingReason
+  enqueue(RowVectorPtr input, ContinueFuture* future, bool drained) override {
     ScopedPromiseNotification notification(1);
+    if (drained) {
+      VELOX_CHECK_NULL(input);
+      queue_.withWLock([&](auto& queue) { queue.drain(notification); });
+      return BlockingReason::kNotBlocked;
+    }
     return queue_.withWLock([&](auto& queue) {
       return queue.enqueue(input, future, notification);
     });
@@ -118,6 +127,7 @@ class LocalMergeSource : public MergeSource {
     BlockingReason next(
         RowVectorPtr& data,
         ContinueFuture* future,
+        bool& drained,
         ScopedPromiseNotification& notification) {
       VELOX_CHECK(started_);
       data.reset();
@@ -126,6 +136,11 @@ class LocalMergeSource : public MergeSource {
         if (atEnd_) {
           return BlockingReason::kNotBlocked;
         }
+        if (drained_) {
+          drained = true;
+          drained_ = false;
+          return BlockingReason::kNotBlocked;
+        }
         consumerPromises_.emplace_back("LocalMergeSourceQueue::next");
         *future = consumerPromises_.back().getSemiFuture();
         return BlockingReason::kWaitForProducer;
@@ -140,6 +155,12 @@ class LocalMergeSource : public MergeSource {
       return BlockingReason::kNotBlocked;
     }
 
+    void drain(ScopedPromiseNotification& notification) {
+      VELOX_CHECK(!atEnd_);
+      drained_ = true;
+      notifyConsumers(notification);
+    }
+
     BlockingReason enqueue(
         RowVectorPtr input,
         ContinueFuture* future,
@@ -180,6 +201,7 @@ class LocalMergeSource : public MergeSource {
 
     bool started_{false};
     bool atEnd_{false};
+    bool drained_{false};
     boost::circular_buffer<RowVectorPtr> data_;
     std::vector<ContinuePromise> consumerPromises_;
     std::vector<ContinuePromise> producerPromises_;
@@ -198,15 +220,16 @@ class MergeExchangeSource : public MergeSource {
       memory::MemoryPool* pool,
       folly::Executor* executor)
       : mergeExchange_(mergeExchange),
-        client_(std::make_shared<ExchangeClient>(
-            mergeExchange->taskId(),
-            destination,
-            maxQueuedBytes,
-            1,
-            // Deliver right away to avoid blocking other sources
-            0,
-            pool,
-            executor)) {
+        client_(
+            std::make_shared<ExchangeClient>(
+                mergeExchange->taskId(),
+                destination,
+                maxQueuedBytes,
+                1,
+                // Deliver right away to avoid blocking other sources
+                0,
+                pool,
+                executor)) {
     client_->addRemoteTaskId(taskId);
     client_->noMoreRemoteTasks();
   }
@@ -221,7 +244,9 @@ class MergeExchangeSource : public MergeSource {
     VELOX_NYI();
   }
 
-  BlockingReason next(RowVectorPtr& data, ContinueFuture* future) override {
+  BlockingReason next(RowVectorPtr& data, ContinueFuture* future, bool& drained)
+      override {
+    drained = false;
     data.reset();
 
     if (atEnd_ && !currentPage_) {
@@ -277,16 +302,16 @@ class MergeExchangeSource : public MergeSource {
     }
   }
 
- private:
-  BlockingReason enqueue(RowVectorPtr input, ContinueFuture* future) override {
+  BlockingReason
+  enqueue(RowVectorPtr input, ContinueFuture* future, bool drained) override {
     VELOX_FAIL();
   }
 
+ private:
   MergeExchange* const mergeExchange_;
-
   std::shared_ptr<ExchangeClient> client_;
   std::unique_ptr<ByteInputStream> inputStream_;
-  std::unique_ptr<SerializedPage> currentPage_;
+  std::unique_ptr<SerializedPageBase> currentPage_;
   bool atEnd_ = false;
 };
 } // namespace
diff --git a/velox/exec/MergeSource.h b/velox/exec/MergeSource.h
index ed9f3d1f37f..86ce401d079 100644
--- a/velox/exec/MergeSource.h
+++ b/velox/exec/MergeSource.h
@@ -37,11 +37,14 @@ class MergeSource {
   /// from the consumer.
   virtual BlockingReason started(ContinueFuture* future) = 0;
 
-  virtual BlockingReason next(RowVectorPtr& data, ContinueFuture* future) = 0;
-
-  virtual BlockingReason enqueue(
-      RowVectorPtr input,
-      ContinueFuture* future) = 0;
+  virtual BlockingReason
+  next(RowVectorPtr& data, ContinueFuture* future, bool& drained) = 0;
+
+  /// Called by the producer to enqueue more data, signal end of data (nullptr
+  /// input), or signal drain (nullptr input with drained=true) under barrier
+  /// processing.
+  virtual BlockingReason
+  enqueue(RowVectorPtr input, ContinueFuture* future, bool drained = false) = 0;
 
   virtual void close() = 0;
 
diff --git a/velox/exec/MixedUnion.cpp b/velox/exec/MixedUnion.cpp
new file mode 100644
index 00000000000..93918bd361b
--- /dev/null
+++ b/velox/exec/MixedUnion.cpp
@@ -0,0 +1,304 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/MixedUnion.h"
+#include "velox/exec/OperatorType.h"
+#include "velox/exec/OperatorUtils.h"
+#include "velox/exec/Task.h"
+
+namespace facebook::velox::exec {
+
+MixedUnion::MixedUnion(
+    int32_t operatorId,
+    DriverCtx* driverCtx,
+    const std::shared_ptr<const core::MixedUnionNode>& unionNode)
+    : SourceOperator(
+          driverCtx,
+          unionNode->outputType(),
+          operatorId,
+          unionNode->id(),
+          OperatorType::kMixedUnion),
+      unionNode_(unionNode),
+      maxOutputBatchRows_(outputBatchRows()),
+      maxOutputBatchBytes_(
+          driverCtx->queryConfig().preferredOutputBatchBytes()) {}
+
+BlockingReason MixedUnion::addMergeSources(ContinueFuture* /* future */) {
+  if (sources_.empty()) {
+    // Get merge sources from the task
+    sources_ = operatorCtx_->task()->getLocalMergeSources(
+        operatorCtx_->driverCtx()->splitGroupId, planNodeId());
+
+    // Initialize tracking vectors
+    const auto numSources = sources_.size();
+    pendingData_.resize(numSources);
+    sourcesFinished_.resize(numSources, false);
+    sourcesDrained_.resize(numSources, false);
+  }
+  return BlockingReason::kNotBlocked;
+}
+
+void MixedUnion::startSources() {
+  if (sourcesStarted_) {
+    return;
+  }
+
+  // Start all sources
+  for (auto& source : sources_) {
+    source->start();
+  }
+  sourcesStarted_ = true;
+}
+
+BlockingReason MixedUnion::isBlocked(ContinueFuture* future) {
+  const auto reason = addMergeSources(future);
+  if (reason != BlockingReason::kNotBlocked) {
+    return reason;
+  }
+
+  if (sources_.empty()) {
+    finished_ = true;
+    return BlockingReason::kNotBlocked;
+  }
+
+  startSources();
+
+  // Pre-fetch data from each source into pendingData_. This is done in both
+  // normal and drain modes so that getOutputMixed() can uniformly drain
+  // pendingData_ without polling sources directly.
+  std::vector<ContinueFuture> blockingFutures;
+  for (size_t i = 0; i < sources_.size(); ++i) {
+    if (sourcesFinished_[i] || sourcesDrained_[i] || pendingData_[i]) {
+      continue;
+    }
+
+    ContinueFuture sourceFuture;
+    RowVectorPtr data;
+    bool drained{false};
+    const auto blockingReason = sources_[i]->next(data, &sourceFuture, drained);
+
+    if (blockingReason != BlockingReason::kNotBlocked) {
+      blockingFutures.push_back(std::move(sourceFuture));
+    } else if (data) {
+      pendingData_[i] = std::move(data);
+    } else if (drained) {
+      sourcesDrained_[i] = true;
+    } else {
+      sourcesFinished_[i] = true;
+    }
+  }
+
+  if (!blockingFutures.empty()) {
+    // Use collectAny to continue as soon as any source has data, allowing us to
+    // prefetch into pendingData_ incrementally. This differs from Merge which
+    // waits one source at a time since it needs sorted merging.
+    *future = folly::collectAny(std::move(blockingFutures)).unit();
+    return BlockingReason::kWaitForProducer;
+  }
+
+  return BlockingReason::kNotBlocked;
+}
+
+bool MixedUnion::isFinished() {
+  return finished_;
+}
+
+RowVectorPtr MixedUnion::getOutput() {
+  if (finished_) {
+    return nullptr;
+  }
+
+  return getOutputMixed();
+}
+
+bool MixedUnion::hasPendingDrainData() const {
+  // Check if there's any pending data to drain.
+  for (const auto& data : pendingData_) {
+    if (data != nullptr) {
+      return true;
+    }
+  }
+
+  // Check if any source still has data to drain.
+  // A source is considered drained if it's finished OR has signaled drained.
+  for (size_t i = 0; i < sources_.size(); ++i) {
+    if (!sourcesFinished_[i] && !sourcesDrained_[i]) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool MixedUnion::startDrain() {
+  VELOX_CHECK(isDraining());
+
+  // Note: We don't call source->drain() here because the producer's
+  // CallbackSink has already called it when it entered drain mode.
+  // We just need to check if there's pending data to drain and drain any
+  // remaining data from sources.
+
+  if (hasPendingDrainData()) {
+    return true;
+  }
+
+  // No data to drain. Reset state for next barrier cycle.
+  std::fill(sourcesDrained_.begin(), sourcesDrained_.end(), false);
+
+  return false;
+}
+
+void MixedUnion::maybeFinishDrain() {
+  if (!isDraining()) {
+    return;
+  }
+
+  if (hasPendingDrainData()) {
+    return;
+  }
+
+  finishDrain();
+}
+
+void MixedUnion::finishDrain() {
+  VELOX_CHECK(isDraining());
+
+  // Reset drain state for next barrier.
+  std::fill(sourcesDrained_.begin(), sourcesDrained_.end(), false);
+
+  Operator::finishDrain();
+}
+
+RowVectorPtr MixedUnion::getOutputMixed() {
+  // Drain pendingData_ populated by isBlocked() in both normal and drain modes.
+  std::vector<RowVectorPtr> validInputs;
+  for (size_t i = 0; i < pendingData_.size(); ++i) {
+    if (pendingData_[i]) {
+      validInputs.push_back(std::move(pendingData_[i]));
+      pendingData_[i] = nullptr;
+    }
+  }
+
+  if (!validInputs.empty()) {
+    auto result = combineResults(validInputs);
+    return result;
+  }
+
+  // No pending data. Check termination conditions.
+  if (isDraining()) {
+    maybeFinishDrain();
+    return nullptr;
+  }
+
+  bool allFinished = true;
+  bool allDrained = true;
+  for (size_t i = 0; i < sources_.size(); ++i) {
+    if (sourcesFinished_[i]) {
+      continue;
+    }
+    allFinished = false;
+    if (!sourcesDrained_[i]) {
+      allDrained = false;
+    }
+  }
+
+  if (allFinished) {
+    finished_ = true;
+    return nullptr;
+  }
+
+  if (allDrained && operatorCtx_->driver()->hasBarrier()) {
+    operatorCtx_->driver()->drainOutput();
+  }
+
+  return nullptr;
+}
+
+RowVectorPtr MixedUnion::combineResults(std::vector<RowVectorPtr>& results) {
+  if (results.empty()) {
+    return nullptr;
+  }
+
+  if (results.size() == 1) {
+    auto result = std::move(results[0]);
+    // Record output statistics
+    {
+      auto lockedStats = stats_.wlock();
+      lockedStats->addOutputVector(result->estimateFlatSize(), result->size());
+    }
+    return result;
+  }
+
+  // Calculate total number of rows
+  vector_size_t totalRows = 0;
+  for (const auto& result : results) {
+    totalRows += result->size();
+  }
+
+  if (totalRows == 0) {
+    return nullptr;
+  }
+
+  // Create combined output vector
+  auto combinedResult =
+      BaseVector::create<RowVector>(outputType_, totalRows, pool());
+
+  // Copy data from all input vectors
+  vector_size_t currentOffset = 0;
+  for (const auto& result : results) {
+    if (result->size() > 0) {
+      for (auto i = 0; i < outputType_->size(); ++i) {
+        // Copy column data
+        std::vector<BaseVector::CopyRange> ranges;
+        ranges.push_back({0, currentOffset, result->size()});
+
+        combinedResult->childAt(i)->copyRanges(
+            result->childAt(i).get(), ranges);
+      }
+      currentOffset += result->size();
+    }
+  }
+
+  // Record output statistics
+  {
+    auto lockedStats = stats_.wlock();
+    lockedStats->addOutputVector(
+        combinedResult->estimateFlatSize(), combinedResult->size());
+  }
+
+  return combinedResult;
+}
+
+bool MixedUnion::hasDataFromAllSources() const {
+  for (size_t i = 0; i < pendingData_.size(); ++i) {
+    // If source is not finished and has no data, we don't have all sources
+    if (!sourcesFinished_[i] && !pendingData_[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void MixedUnion::close() {
+  // Close all sources
+  for (auto& source : sources_) {
+    source->close();
+  }
+  pendingData_.clear();
+  Operator::close();
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/MixedUnion.h b/velox/exec/MixedUnion.h
new file mode 100644
index 00000000000..bba78d343a6
--- /dev/null
+++ b/velox/exec/MixedUnion.h
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/core/PlanNode.h"
+#include "velox/exec/MergeSource.h"
+#include "velox/exec/Operator.h"
+
+namespace facebook::velox::exec {
+
+/// Union operator that processes splits from all inputs simultaneously as a
+/// SourceOperator. Unlike traditional operators that receive input via
+/// addInput(), MixedUnion manages multiple MergeSource objects internally,
+/// pulling data from each source and combining results in a round-robin or
+/// interleaved fashion.
+class MixedUnion : public SourceOperator {
+ public:
+  MixedUnion(
+      int32_t operatorId,
+      DriverCtx* driverCtx,
+      const std::shared_ptr<const core::MixedUnionNode>& unionNode);
+
+  RowVectorPtr getOutput() override;
+
+  BlockingReason isBlocked(ContinueFuture* future) override;
+
+  bool isFinished() override;
+
+  void close() override;
+
+  /// Invoked by the driver to start draining output on this operator.
+  /// Returns true if this operator has buffered output to drain (pending data
+  /// in pendingData_ or sources that haven't signaled drained yet).
+  /// Returns false if there's no data to drain and the driver should proceed
+  /// to the next operator.
+  bool startDrain() override;
+
+  void finishDrain() override;
+
+ private:
+  /// Check if there's pending data to drain (either in pendingData_ or from
+  /// sources that haven't signaled drained yet). Used by both startDrain() and
+  /// maybeFinishDrain() to avoid duplicate code.
+  bool hasPendingDrainData() const;
+
+  /// Check if all sources have been drained and finish drain if so.
+  void maybeFinishDrain();
+
+  /// Get merge sources from the task
+  BlockingReason addMergeSources(ContinueFuture* future);
+
+  /// Start reading from sources
+  void startSources();
+
+  /// Process inputs in mixed mode (all at once)
+  RowVectorPtr getOutputMixed();
+
+  /// Combine multiple row vectors into a single output vector
+  RowVectorPtr combineResults(std::vector<RowVectorPtr>& results);
+
+  /// Check if we have data from all active sources for mixed mode
+  bool hasDataFromAllSources() const;
+
+  const std::shared_ptr<const core::MixedUnionNode> unionNode_;
+
+  /// MergeSource objects representing each input pipeline
+  std::vector<std::shared_ptr<MergeSource>> sources_;
+
+  /// Track which sources have been started
+  bool sourcesStarted_{false};
+
+  /// Store pending data from each source
+  std::vector<RowVectorPtr> pendingData_;
+
+  /// Track which sources have finished
+  std::vector<bool> sourcesFinished_;
+
+  /// True when all sources are exhausted
+  bool finished_{false};
+
+  /// Tracks which sources have been drained (during barrier processing).
+  std::vector<bool> sourcesDrained_;
+
+  /// Maximum output batch size
+  const vector_size_t maxOutputBatchRows_;
+  const uint64_t maxOutputBatchBytes_;
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/NestedLoopJoinBuild.cpp b/velox/exec/NestedLoopJoinBuild.cpp
index 5fbd2acc4d0..f38098fab86 100644
--- a/velox/exec/NestedLoopJoinBuild.cpp
+++ b/velox/exec/NestedLoopJoinBuild.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 #include "velox/exec/NestedLoopJoinBuild.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/Task.h"
 
 namespace facebook::velox::exec {
@@ -50,7 +51,7 @@ NestedLoopJoinBuild::NestedLoopJoinBuild(
           nullptr,
           operatorId,
           joinNode->id(),
-          "NestedLoopJoinBuild") {}
+          OperatorType::kNestedLoopJoinBuild) {}
 
 void NestedLoopJoinBuild::addInput(RowVectorPtr input) {
   if (input->size() > 0) {
diff --git a/velox/exec/NestedLoopJoinProbe.cpp b/velox/exec/NestedLoopJoinProbe.cpp
index 3c72407796c..868e8088920 100644
--- a/velox/exec/NestedLoopJoinProbe.cpp
+++ b/velox/exec/NestedLoopJoinProbe.cpp
@@ -15,6 +15,7 @@
  */
 #include "velox/exec/NestedLoopJoinProbe.h"
 #include "velox/exec/DriverStats.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/Task.h"
 #include "velox/expression/FieldReference.h"
@@ -56,7 +57,7 @@ NestedLoopJoinProbe::NestedLoopJoinProbe(
           joinNode->outputType(),
           operatorId,
           joinNode->id(),
-          "NestedLoopJoinProbe"),
+          OperatorType::kNestedLoopJoinProbe),
       joinType_(joinNode->joinType()),
       outputBatchSize_{outputBatchRows()},
       joinNode_(joinNode) {
diff --git a/velox/exec/OneWayStatusFlag.h b/velox/exec/OneWayStatusFlag.h
index 9986f5bafe7..4eea37c2471 100644
--- a/velox/exec/OneWayStatusFlag.h
+++ b/velox/exec/OneWayStatusFlag.h
@@ -16,53 +16,28 @@
 
 #pragma once
 
-#include <folly/synchronization/SanitizeThread.h>
 #include <atomic>
 
 namespace facebook::velox::exec {
 
-/// A simple one way status flag that uses a non atomic flag to avoid
-/// unnecessary atomic operations.
 class OneWayStatusFlag {
  public:
-  bool check() const {
-#if defined(__x86_64__)
-    folly::annotate_ignore_thread_sanitizer_guard g(__FILE__, __LINE__);
-    return fastStatus_ || atomicStatus_.load();
-#else
-    return atomicStatus_.load(std::memory_order_relaxed) ||
-        atomicStatus_.load();
-#endif
+  bool check() const noexcept {
+    return status_.load(std::memory_order_acquire);
   }
 
-  void set() {
-#if defined(__x86_64__)
-    folly::annotate_ignore_thread_sanitizer_guard g(__FILE__, __LINE__);
-    if (!fastStatus_) {
-      atomicStatus_.store(true);
-      fastStatus_ = true;
+  void set() noexcept {
+    if (!status_.load(std::memory_order_relaxed)) {
+      status_.store(true, std::memory_order_release);
     }
-#else
-    if (!atomicStatus_.load(std::memory_order_relaxed)) {
-      atomicStatus_.store(true);
-    }
-#endif
   }
 
-  /// Operator overload to convert OneWayStatusFlag to bool
-  operator bool() const {
+  explicit operator bool() const noexcept {
     return check();
   }
 
  private:
-#if defined(__x86_64__)
-  // This flag can only go from false to true, and is only checked at the end of
-  // a loop. Given that once a flag is true it can never go back to false, we
-  // are ok to use this in a non synchronized manner to avoid the overhead. As
-  // such we consciously exempt ourselves here from TSAN detection.
-  bool fastStatus_{false};
-#endif
-  std::atomic_bool atomicStatus_{false};
+  std::atomic_bool status_{false};
 };
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/Operator.cpp b/velox/exec/Operator.cpp
index b5dcdb849c7..972fa31fb9b 100644
--- a/velox/exec/Operator.cpp
+++ b/velox/exec/Operator.cpp
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #include "velox/exec/Operator.h"
 #include "velox/common/base/Counters.h"
 #include "velox/common/base/StatsReporter.h"
@@ -20,7 +21,7 @@
 #include "velox/common/testutil/TestValue.h"
 #include "velox/exec/Driver.h"
 #include "velox/exec/OperatorUtils.h"
-#include "velox/exec/TraceUtil.h"
+#include "velox/exec/Task.h"
 #include "velox/expression/Expr.h"
 
 using facebook::velox::common::testutil::TestValue;
@@ -31,12 +32,12 @@ OperatorCtx::OperatorCtx(
     DriverCtx* driverCtx,
     const core::PlanNodeId& planNodeId,
     int32_t operatorId,
-    const std::string& operatorType)
+    std::string_view operatorType)
     : driverCtx_(driverCtx),
       planNodeId_(planNodeId),
       operatorId_(operatorId),
       operatorType_(operatorType),
-      pool_(driverCtx_->addOperatorPool(planNodeId, operatorType)) {}
+      pool_(driverCtx_->addOperatorPool(planNodeId, operatorType_)) {}
 
 core::ExecCtx* OperatorCtx::execCtx() const {
   if (!execCtx_) {
@@ -72,6 +73,8 @@ OperatorCtx::createConnectorQueryCtx(
       task->queryCtx()->fsTokenProvider());
   connectorQueryCtx->setSelectiveNimbleReaderEnabled(
       driverCtx_->queryConfig().selectiveNimbleReaderEnabled());
+  connectorQueryCtx->setRowSizeTrackingMode(
+      driverCtx_->queryConfig().rowSizeTrackingMode());
   return connectorQueryCtx;
 }
 
@@ -80,23 +83,25 @@ Operator::Operator(
     RowTypePtr outputType,
     int32_t operatorId,
     std::string planNodeId,
-    std::string operatorType,
+    std::string_view operatorType,
     std::optional<common::SpillConfig> spillConfig)
-    : operatorCtx_(std::make_unique<OperatorCtx>(
-          driverCtx,
-          planNodeId,
-          operatorId,
-          operatorType)),
+    : operatorCtx_(
+          std::make_unique<OperatorCtx>(
+              driverCtx,
+              planNodeId,
+              operatorId,
+              operatorType)),
       outputType_(std::move(outputType)),
       spillConfig_(std::move(spillConfig)),
       dryRun_(
-          operatorCtx_->driverCtx()->traceConfig().has_value() &&
-          operatorCtx_->driverCtx()->traceConfig()->dryRun),
-      stats_(OperatorStats{
-          operatorId,
-          driverCtx->pipelineId,
-          std::move(planNodeId),
-          std::move(operatorType)}) {}
+          operatorCtx_->driverCtx()->traceCtx() &&
+          operatorCtx_->driverCtx()->traceCtx()->dryRun()),
+      stats_(
+          OperatorStats{
+              operatorId,
+              driverCtx->pipelineId,
+              std::move(planNodeId),
+              std::string(operatorType)}) {}
 
 void Operator::maybeSetReclaimer() {
   VELOX_CHECK_NULL(pool()->reclaimer());
@@ -109,53 +114,22 @@ void Operator::maybeSetReclaimer() {
 }
 
 void Operator::maybeSetTracer() {
-  const auto& traceConfig = operatorCtx_->driverCtx()->traceConfig();
-  if (!traceConfig.has_value()) {
-    return;
-  }
-
-  const auto nodeId = planNodeId();
-  if (traceConfig->queryNodeId.empty() || traceConfig->queryNodeId != nodeId) {
-    return;
-  }
+  const auto* traceCtx = operatorCtx_->driverCtx()->traceCtx();
 
-  auto& tracedOpMap = operatorCtx_->driverCtx()->tracedOperatorMap;
-  if (const auto iter = tracedOpMap.find(operatorId());
-      iter != tracedOpMap.end()) {
-    LOG(WARNING) << "Operator " << iter->first << " with type of "
-                 << operatorType() << ", plan node " << nodeId
-                 << " might be the auxiliary operator of " << iter->second
-                 << " which has the same operator id";
-    return;
-  }
-  tracedOpMap.emplace(operatorId(), operatorType());
-
-  if (!trace::canTrace(operatorType())) {
-    VELOX_UNSUPPORTED("{} does not support tracing", operatorType());
-  }
-
-  const auto pipelineId = operatorCtx_->driverCtx()->pipelineId;
-  const auto driverId = operatorCtx_->driverCtx()->driverId;
-  LOG(INFO) << "Trace input for operator type: " << operatorType()
-            << ", operator id: " << operatorId() << ", pipeline: " << pipelineId
-            << ", driver: " << driverId << ", task: " << taskId();
-  const auto opTraceDirPath = trace::getOpTraceDirectory(
-      traceConfig->queryTraceDir, planNodeId(), pipelineId, driverId);
-  trace::createTraceDirectory(
-      opTraceDirPath,
-      operatorCtx_->driverCtx()->queryConfig().opTraceDirectoryCreateConfig());
-
-  if (dynamic_cast<SourceOperator*>(this) != nullptr) {
-    setupSplitTracer(opTraceDirPath);
-  } else {
-    setupInputTracer(opTraceDirPath);
+  if (traceCtx && traceCtx->shouldTrace(*this)) {
+    if (dynamic_cast<SourceOperator*>(this) != nullptr) {
+      splitTracer_ = traceCtx->createSplitTracer(*this);
+    } else {
+      inputTracer_ = traceCtx->createInputTracer(*this);
+    }
   }
 }
 
-void Operator::traceInput(const RowVectorPtr& input) {
+bool Operator::traceInput(const RowVectorPtr& input, ContinueFuture* future) {
   if (FOLLY_UNLIKELY(inputTracer_ != nullptr)) {
-    inputTracer_->write(input);
+    return inputTracer_->write(input, future);
   }
+  return false;
 }
 
 void Operator::finishTrace() {
@@ -175,19 +149,6 @@ Operator::translators() {
   return translators;
 }
 
-void Operator::setupInputTracer(const std::string& opTraceDirPath) {
-  inputTracer_ = std::make_unique<trace::OperatorTraceInputWriter>(
-      this,
-      opTraceDirPath,
-      memory::traceMemoryPool(),
-      operatorCtx_->driverCtx()->traceConfig()->updateAndCheckTraceLimitCB);
-}
-
-void Operator::setupSplitTracer(const std::string& opTraceDirPath) {
-  splitTracer_ =
-      std::make_unique<trace::OperatorTraceSplitWriter>(this, opTraceDirPath);
-}
-
 // static
 std::unique_ptr<Operator> Operator::fromPlanNode(
     DriverCtx* ctx,
@@ -391,107 +352,121 @@ void Operator::recordBlockingTime(uint64_t start, BlockingReason reason) {
 }
 
 void Operator::recordSpillStats() {
-  const auto lockedSpillStats = spillStats_->wlock();
   auto lockedStats = stats_.wlock();
-  lockedStats->spilledInputBytes += lockedSpillStats->spilledInputBytes;
-  lockedStats->spilledBytes += lockedSpillStats->spilledBytes;
-  lockedStats->spilledRows += lockedSpillStats->spilledRows;
-  lockedStats->spilledPartitions += lockedSpillStats->spilledPartitions;
-  lockedStats->spilledFiles += lockedSpillStats->spilledFiles;
-  if (lockedSpillStats->spillFillTimeNanos != 0) {
+  lockedStats->spilledInputBytes +=
+      spillStats_->spilledInputBytes.load(std::memory_order_relaxed);
+  lockedStats->spilledBytes +=
+      spillStats_->spilledBytes.load(std::memory_order_relaxed);
+  lockedStats->spilledRows +=
+      spillStats_->spilledRows.load(std::memory_order_relaxed);
+  lockedStats->spilledPartitions +=
+      spillStats_->spilledPartitions.load(std::memory_order_relaxed);
+  lockedStats->spilledFiles +=
+      spillStats_->spilledFiles.load(std::memory_order_relaxed);
+
+  const auto fillTime =
+      spillStats_->spillFillTimeNanos.load(std::memory_order_relaxed);
+  if (fillTime != 0) {
     lockedStats->addRuntimeStat(
         kSpillFillTime,
-        RuntimeCounter{
-            static_cast<int64_t>(lockedSpillStats->spillFillTimeNanos),
-            RuntimeCounter::Unit::kNanos});
+        RuntimeCounter{saturateCast(fillTime), RuntimeCounter::Unit::kNanos});
   }
-  if (lockedSpillStats->spillSortTimeNanos != 0) {
+  const auto sortTime =
+      spillStats_->spillSortTimeNanos.load(std::memory_order_relaxed);
+  if (sortTime != 0) {
     lockedStats->addRuntimeStat(
         kSpillSortTime,
-        RuntimeCounter{
-            static_cast<int64_t>(lockedSpillStats->spillSortTimeNanos),
-            RuntimeCounter::Unit::kNanos});
+        RuntimeCounter{saturateCast(sortTime), RuntimeCounter::Unit::kNanos});
   }
-  if (lockedSpillStats->spillExtractVectorTimeNanos != 0) {
+  const auto extractTime =
+      spillStats_->spillExtractVectorTimeNanos.load(std::memory_order_relaxed);
+  if (extractTime != 0) {
     lockedStats->addRuntimeStat(
         kSpillExtractVectorTime,
         RuntimeCounter{
-            static_cast<int64_t>(lockedSpillStats->spillExtractVectorTimeNanos),
-            RuntimeCounter::Unit::kNanos});
+            saturateCast(extractTime), RuntimeCounter::Unit::kNanos});
   }
-  if (lockedSpillStats->spillSerializationTimeNanos != 0) {
+  const auto serializationTime =
+      spillStats_->spillSerializationTimeNanos.load(std::memory_order_relaxed);
+  if (serializationTime != 0) {
     lockedStats->addRuntimeStat(
         kSpillSerializationTime,
         RuntimeCounter{
-            static_cast<int64_t>(lockedSpillStats->spillSerializationTimeNanos),
-            RuntimeCounter::Unit::kNanos});
+            saturateCast(serializationTime), RuntimeCounter::Unit::kNanos});
   }
-  if (lockedSpillStats->spillFlushTimeNanos != 0) {
+  const auto flushTime =
+      spillStats_->spillFlushTimeNanos.load(std::memory_order_relaxed);
+  if (flushTime != 0) {
     lockedStats->addRuntimeStat(
         kSpillFlushTime,
-        RuntimeCounter{
-            static_cast<int64_t>(lockedSpillStats->spillFlushTimeNanos),
-            RuntimeCounter::Unit::kNanos});
+        RuntimeCounter{saturateCast(flushTime), RuntimeCounter::Unit::kNanos});
   }
-  if (lockedSpillStats->spillWrites != 0) {
+  const auto writes = spillStats_->spillWrites.load(std::memory_order_relaxed);
+  if (writes != 0) {
     lockedStats->addRuntimeStat(
-        kSpillWrites,
-        RuntimeCounter{static_cast<int64_t>(lockedSpillStats->spillWrites)});
+        kSpillWrites, RuntimeCounter{saturateCast(writes)});
   }
-  if (lockedSpillStats->spillWriteTimeNanos != 0) {
+  const auto writeTime =
+      spillStats_->spillWriteTimeNanos.load(std::memory_order_relaxed);
+  if (writeTime != 0) {
     lockedStats->addRuntimeStat(
         kSpillWriteTime,
-        RuntimeCounter{
-            static_cast<int64_t>(lockedSpillStats->spillWriteTimeNanos),
-            RuntimeCounter::Unit::kNanos});
+        RuntimeCounter{saturateCast(writeTime), RuntimeCounter::Unit::kNanos});
   }
-  if (lockedSpillStats->spillRuns != 0) {
-    lockedStats->addRuntimeStat(
-        kSpillRuns,
-        RuntimeCounter{static_cast<int64_t>(lockedSpillStats->spillRuns)});
-    common::updateGlobalSpillRunStats(lockedSpillStats->spillRuns);
+  const auto runs = spillStats_->spillRuns.load(std::memory_order_relaxed);
+  if (runs != 0) {
+    lockedStats->addRuntimeStat(kSpillRuns, RuntimeCounter{saturateCast(runs)});
+    updateGlobalSpillRunStats(runs);
   }
 
-  if (lockedSpillStats->spillMaxLevelExceededCount != 0) {
+  const auto maxLevelExceeded =
+      spillStats_->spillMaxLevelExceededCount.load(std::memory_order_relaxed);
+  if (maxLevelExceeded != 0) {
     lockedStats->addRuntimeStat(
-        kExceededMaxSpillLevel,
-        RuntimeCounter{static_cast<int64_t>(
-            lockedSpillStats->spillMaxLevelExceededCount)});
-    common::updateGlobalMaxSpillLevelExceededCount(
-        lockedSpillStats->spillMaxLevelExceededCount);
+        kExceededMaxSpillLevel, RuntimeCounter{saturateCast(maxLevelExceeded)});
+    updateGlobalMaxSpillLevelExceededCount(maxLevelExceeded);
   }
 
-  if (lockedSpillStats->spillReadBytes != 0) {
+  const auto readBytes =
+      spillStats_->spillReadBytes.load(std::memory_order_relaxed);
+  if (readBytes != 0) {
     lockedStats->addRuntimeStat(
         kSpillReadBytes,
-        RuntimeCounter{
-            static_cast<int64_t>(lockedSpillStats->spillReadBytes),
-            RuntimeCounter::Unit::kBytes});
+        RuntimeCounter{saturateCast(readBytes), RuntimeCounter::Unit::kBytes});
   }
 
-  if (lockedSpillStats->spillReads != 0) {
+  const auto reads = spillStats_->spillReads.load(std::memory_order_relaxed);
+  if (reads != 0) {
     lockedStats->addRuntimeStat(
-        kSpillReads,
-        RuntimeCounter{static_cast<int64_t>(lockedSpillStats->spillReads)});
+        kSpillReads, RuntimeCounter{saturateCast(reads)});
   }
 
-  if (lockedSpillStats->spillReadTimeNanos != 0) {
+  const auto readTime =
+      spillStats_->spillReadTimeNanos.load(std::memory_order_relaxed);
+  if (readTime != 0) {
     lockedStats->addRuntimeStat(
         kSpillReadTime,
-        RuntimeCounter{
-            static_cast<int64_t>(lockedSpillStats->spillReadTimeNanos),
-            RuntimeCounter::Unit::kNanos});
+        RuntimeCounter{saturateCast(readTime), RuntimeCounter::Unit::kNanos});
   }
 
-  if (lockedSpillStats->spillDeserializationTimeNanos != 0) {
+  const auto deserializationTime =
+      spillStats_->spillDeserializationTimeNanos.load(
+          std::memory_order_relaxed);
+  if (deserializationTime != 0) {
     lockedStats->addRuntimeStat(
         kSpillDeserializationTime,
         RuntimeCounter{
-            static_cast<int64_t>(
-                lockedSpillStats->spillDeserializationTimeNanos),
-            RuntimeCounter::Unit::kNanos});
+            saturateCast(deserializationTime), RuntimeCounter::Unit::kNanos});
   }
-  lockedSpillStats->reset();
+
+  // Collect filesystem I/O stats for spilling.
+  const auto ioStatsMap = spillStats_->ioStats.stats();
+  for (const auto& [statName, statValue] : ioStatsMap) {
+    lockedStats->addRuntimeStat(
+        statName, RuntimeCounter(statValue.sum, statValue.unit));
+  }
+
+  spillStats_->reset();
 }
 
 std::string Operator::toString() const {
@@ -553,7 +528,7 @@ std::vector<column_index_t> calculateOutputChannels(
 }
 
 void OperatorStats::addRuntimeStat(
-    const std::string& name,
+    std::string_view name,
     const RuntimeCounter& value) {
   addOperatorRuntimeStats(name, value, runtimeStats);
 }
@@ -772,9 +747,12 @@ uint64_t Operator::MemoryReclaimer::reclaim(
     ++stats.numNonReclaimableAttempts;
     RECORD_METRIC_VALUE(kMetricMemoryNonReclaimableCount);
     LOG(WARNING) << "Can't reclaim from memory pool " << pool->name()
-                 << " which is under non-reclaimable section, memory usage: "
-                 << succinctBytes(pool->usedBytes())
-                 << ", reservation: " << succinctBytes(pool->reservedBytes());
+                 << " which is under non-reclaimable section"
+                 << ", root pool: " << pool->root()->name()
+                 << ", used: " << succinctBytes(pool->usedBytes())
+                 << ", reservation: " << succinctBytes(pool->reservedBytes())
+                 << ", root pool reservation: "
+                 << succinctBytes(pool->root()->reservedBytes());
     return 0;
   }
 
diff --git a/velox/exec/Operator.h b/velox/exec/Operator.h
index a2459ba52d6..53e462da850 100644
--- a/velox/exec/Operator.h
+++ b/velox/exec/Operator.h
@@ -16,12 +16,14 @@
 #pragma once
 
 #include <folly/Synchronized.h>
+#include <string_view>
 #include "velox/core/PlanNode.h"
 #include "velox/core/QueryCtx.h"
 #include "velox/exec/Driver.h"
 #include "velox/exec/JoinBridge.h"
 #include "velox/exec/OperatorStats.h"
-#include "velox/exec/OperatorTraceWriter.h"
+#include "velox/exec/SpillStats.h"
+#include "velox/exec/trace/TraceWriter.h"
 
 namespace facebook::velox::exec {
 
@@ -43,7 +45,7 @@ class OperatorCtx {
       DriverCtx* driverCtx,
       const core::PlanNodeId& planNodeId,
       int32_t operatorId,
-      const std::string& operatorType = "");
+      std::string_view operatorType = "");
 
   const std::shared_ptr<Task>& task() const {
     return driverCtx_->task;
@@ -152,40 +154,45 @@ class Operator : public BaseRuntimeStatWriter {
     }
   };
 
+  /// The name for background cpu time metric if operator has background cpu
+  /// usages outside its driver thread.
+  static constexpr std::string_view kBackgroundCpuTimeNanos =
+      "backgroundCpuTimeNanos";
+
   /// The name of the runtime spill stats collected and reported by operators
   /// that support spilling.
 
   /// This indicates the spill not supported for a spillable operator when the
   /// spill config is enabled. This is due to the spill limitation in certain
   /// plan node config such as unpartition window operator.
-  static inline const std::string kSpillNotSupported{"spillNotSupported"};
+  static constexpr std::string_view kSpillNotSupported{"spillNotSupported"};
   /// The spill write stats.
-  static inline const std::string kSpillFillTime{"spillFillWallNanos"};
-  static inline const std::string kSpillSortTime{"spillSortWallNanos"};
-  static inline const std::string kSpillExtractVectorTime{
+  static constexpr std::string_view kSpillFillTime{"spillFillWallNanos"};
+  static constexpr std::string_view kSpillSortTime{"spillSortWallNanos"};
+  static constexpr std::string_view kSpillExtractVectorTime{
       "spillExtractVectorWallNanos"};
-  static inline const std::string kSpillSerializationTime{
+  static constexpr std::string_view kSpillSerializationTime{
       "spillSerializationWallNanos"};
-  static inline const std::string kSpillFlushTime{"spillFlushWallNanos"};
-  static inline const std::string kSpillWrites{"spillWrites"};
-  static inline const std::string kSpillWriteTime{"spillWriteWallNanos"};
-  static inline const std::string kSpillRuns{"spillRuns"};
-  static inline const std::string kExceededMaxSpillLevel{
+  static constexpr std::string_view kSpillFlushTime{"spillFlushWallNanos"};
+  static constexpr std::string_view kSpillWrites{"spillWrites"};
+  static constexpr std::string_view kSpillWriteTime{"spillWriteWallNanos"};
+  static constexpr std::string_view kSpillRuns{"spillRuns"};
+  static constexpr std::string_view kExceededMaxSpillLevel{
       "exceededMaxSpillLevel"};
   /// The spill read stats.
-  static inline const std::string kSpillReadBytes{"spillReadBytes"};
-  static inline const std::string kSpillReads{"spillReads"};
-  static inline const std::string kSpillReadTime{"spillReadWallNanos"};
-  static inline const std::string kSpillDeserializationTime{
+  static constexpr std::string_view kSpillReadBytes{"spillReadBytes"};
+  static constexpr std::string_view kSpillReads{"spillReads"};
+  static constexpr std::string_view kSpillReadTime{"spillReadWallNanos"};
+  static constexpr std::string_view kSpillDeserializationTime{
       "spillDeserializationWallNanos"};
 
   /// The vector serde kind used by an operator for shuffle. The recorded
   /// runtime stats value is the corresponding enum value.
-  static inline const std::string kShuffleSerdeKind{"shuffleSerdeKind"};
+  static constexpr std::string_view kShuffleSerdeKind{"shuffleSerdeKind"};
 
   /// The compression kind used by an operator for shuffle. The recorded
   /// runtime stats value is the corresponding enum value.
-  static inline const std::string kShuffleCompressionKind{
+  static constexpr std::string_view kShuffleCompressionKind{
       "shuffleCompressionKind"};
 
   /// 'operatorId' is the initial index of the 'this' in the Driver's list of
@@ -203,7 +210,7 @@ class Operator : public BaseRuntimeStatWriter {
       RowTypePtr outputType,
       int32_t operatorId,
       std::string planNodeId,
-      std::string operatorType,
+      std::string_view operatorType,
       std::optional<common::SpillConfig> spillConfig = std::nullopt);
 
   virtual ~Operator() = default;
@@ -212,7 +219,7 @@ class Operator : public BaseRuntimeStatWriter {
   /// allocation from memory pool that can't be done under operator constructor.
   ///
   /// NOTE: the default implementation set 'initialized_' to true to ensure we
-  /// never call this more than once. The overload initialize() implementation
+  /// never call this more than once. The overriding initialize() implementation
   /// must call this base implementation first.
   virtual void initialize();
 
@@ -290,7 +297,7 @@ class Operator : public BaseRuntimeStatWriter {
   }
 
   /// Traces input batch of the operator.
-  virtual void traceInput(const RowVectorPtr&);
+  virtual bool traceInput(const RowVectorPtr& input, ContinueFuture* future);
 
   /// Finishes tracing of the operator.
   virtual void finishTrace();
@@ -341,7 +348,7 @@ class Operator : public BaseRuntimeStatWriter {
 
   /// Add a single runtime stat to the operator stats under the write lock.
   /// This member overrides BaseRuntimeStatWriter's member.
-  void addRuntimeStat(const std::string& name, const RuntimeCounter& value)
+  void addRuntimeStat(std::string_view name, const RuntimeCounter& value)
       override {
     stats_.wlock()->addRuntimeStat(name, value);
   }
@@ -516,6 +523,12 @@ class Operator : public BaseRuntimeStatWriter {
     return input_ != nullptr;
   }
 
+  /// Returns the spill config for this operator. This method is only used for
+  /// test.
+  const common::SpillConfig* testingSpillConfig() const {
+    return spillConfig();
+  }
+
  protected:
   static std::vector<std::unique_ptr<PlanNodeTranslator>>& translators();
   friend class NonReclaimableSection;
@@ -628,14 +641,14 @@ class Operator : public BaseRuntimeStatWriter {
   bool initialized_{false};
 
   folly::Synchronized<OperatorStats> stats_;
-  std::shared_ptr<folly::Synchronized<common::SpillStats>> spillStats_ =
-      std::make_shared<folly::Synchronized<common::SpillStats>>();
+  std::shared_ptr<exec::SpillStats> spillStats_ =
+      std::make_shared<exec::SpillStats>();
 
   /// NOTE: only one of the two could be set for an operator for tracing .
   /// 'splitTracer_' is only set for table scan to record the processed split
   /// for now.
-  std::unique_ptr<trace::OperatorTraceInputWriter> inputTracer_{nullptr};
-  std::unique_ptr<trace::OperatorTraceSplitWriter> splitTracer_{nullptr};
+  std::unique_ptr<trace::TraceInputWriter> inputTracer_{nullptr};
+  std::unique_ptr<trace::TraceSplitWriter> splitTracer_{nullptr};
 
   /// Indicates if an operator is under a non-reclaimable execution section.
   /// This prevents the memory arbitrator from reclaiming memory from this
@@ -666,12 +679,6 @@ class Operator : public BaseRuntimeStatWriter {
   bool shouldYield() const {
     return operatorCtx_->driverCtx()->driver->shouldYield();
   }
-
- private:
-  // Setup 'inputTracer_' to record the processed input vectors.
-  void setupInputTracer(const std::string& traceDir);
-  // Setup 'splitTracer_' for table scan to record the processed split.
-  void setupSplitTracer(const std::string& traceDir);
 };
 
 /// Given a row type returns indices for the specified subset of columns.
@@ -698,7 +705,7 @@ class SourceOperator : public Operator {
       RowTypePtr outputType,
       int32_t operatorId,
       const std::string& planNodeId,
-      const std::string& operatorType,
+      std::string_view operatorType,
       const std::optional<common::SpillConfig>& spillConfig = std::nullopt)
       : Operator(
             driverCtx,
diff --git a/velox/exec/OperatorStats.h b/velox/exec/OperatorStats.h
index 4715ccb06d5..19ca8e93318 100644
--- a/velox/exec/OperatorStats.h
+++ b/velox/exec/OperatorStats.h
@@ -15,6 +15,8 @@
  */
 #pragma once
 
+#include <string_view>
+
 #include "velox/common/base/RuntimeMetrics.h"
 #include "velox/common/memory/MemoryPool.h"
 #include "velox/common/time/CpuWallTimer.h"
@@ -89,6 +91,21 @@ struct DynamicFilterStats {
 };
 
 struct OperatorStats {
+  /// Runtime stat name for per-driver CPU time (actual work time, not including
+  /// blocked time) for this operator. The max field will contain the CPU time
+  /// from the longest running single driver.
+  static constexpr const char* kDriverCpuTime = "driverCpuTimeNanos";
+
+  /// Running time metrics from CpuWallTiming structures, aggregated per thread.
+  static constexpr std::string_view kRunningAddInputWallNanos =
+      "runningAddInputWallNanos";
+  static constexpr std::string_view kRunningGetOutputWallNanos =
+      "runningGetOutputWallNanos";
+  static constexpr std::string_view kRunningFinishWallNanos =
+      "runningFinishWallNanos";
+  static constexpr std::string_view kRunningIsBlockedWallNanos =
+      "runningIsBlockedWallNanos";
+
   /// Initial ordinal position in the operator's pipeline.
   int32_t operatorId = 0;
   int32_t pipelineId = 0;
@@ -219,7 +236,7 @@ struct OperatorStats {
     outputVectors += 1;
   }
 
-  void addRuntimeStat(const std::string& name, const RuntimeCounter& value);
+  void addRuntimeStat(std::string_view name, const RuntimeCounter& value);
   void add(const OperatorStats& other);
   void clear();
 };
diff --git a/velox/exec/OperatorTraceCtx.cpp b/velox/exec/OperatorTraceCtx.cpp
new file mode 100644
index 00000000000..cb1c1d27056
--- /dev/null
+++ b/velox/exec/OperatorTraceCtx.cpp
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/OperatorTraceCtx.h"
+
+#include <re2/re2.h>
+#include "velox/common/base/Exceptions.h"
+#include "velox/exec/Operator.h"
+#include "velox/exec/OperatorTraceWriter.h"
+#include "velox/exec/TaskTraceWriter.h"
+#include "velox/exec/trace/TraceUtil.h"
+
+namespace facebook::velox::exec::trace {
+namespace {
+
+std::string setupTraceDirectory(
+    const Operator& op,
+    const std::string& queryTraceDir) {
+  const auto* operatorCtx = op.operatorCtx();
+  const auto pipelineId = operatorCtx->driverCtx()->pipelineId;
+  const auto driverId = operatorCtx->driverCtx()->driverId;
+
+  LOG(INFO) << "Trace input for operator type: " << op.operatorType()
+            << ", operator id: " << op.operatorId()
+            << ", pipeline: " << pipelineId << ", driver: " << driverId
+            << ", task: " << op.taskId();
+
+  const auto opTraceDirPath =
+      getOpTraceDirectory(queryTraceDir, op.planNodeId(), pipelineId, driverId);
+
+  createTraceDirectory(
+      opTraceDirPath,
+      operatorCtx->driverCtx()->queryConfig().opTraceDirectoryCreateConfig());
+  return opTraceDirPath;
+}
+
+} // namespace
+
+OperatorTraceCtx::OperatorTraceCtx(
+    std::string queryNodeId,
+    std::string queryTraceDir,
+    UpdateAndCheckTraceLimitCB updateAndCheckTraceLimitCB,
+    std::string taskRegExp,
+    bool dryRun)
+    : TraceCtx(dryRun),
+      queryNodeId_(std::move(queryNodeId)),
+      queryTraceDir_(std::move(queryTraceDir)),
+      taskRegExp_(std::move(taskRegExp)),
+      updateAndCheckTraceLimitCB_(std::move(updateAndCheckTraceLimitCB)) {
+  VELOX_CHECK(!queryNodeId_.empty(), "The query trace node cannot be empty");
+}
+
+// static
+std::unique_ptr<OperatorTraceCtx> OperatorTraceCtx::maybeCreate(
+    core::QueryCtx& queryCtx,
+    const core::PlanFragment& planFragment,
+    const std::string& taskId) {
+  const auto& queryConfig = queryCtx.queryConfig();
+
+  VELOX_USER_CHECK(
+      !queryConfig.queryTraceDir().empty(),
+      "Query trace enabled but the trace dir is not set");
+
+  VELOX_USER_CHECK(
+      !queryConfig.queryTraceTaskRegExp().empty(),
+      "Query trace enabled but the trace task regexp is not set");
+
+  if (!RE2::FullMatch(taskId, queryConfig.queryTraceTaskRegExp())) {
+    return nullptr;
+  }
+
+  const auto traceNodeId = queryConfig.queryTraceNodeId();
+  VELOX_USER_CHECK(!traceNodeId.empty(), "Query trace node ID are not set");
+
+  const auto traceDir = getTaskTraceDirectory(
+      queryConfig.queryTraceDir(), queryCtx.queryId(), taskId);
+
+  VELOX_USER_CHECK_NOT_NULL(
+      core::PlanNode::findFirstNode(
+          planFragment.planNode.get(),
+          [traceNodeId](const core::PlanNode* node) -> bool {
+            return node->id() == traceNodeId;
+          }),
+      "Trace plan node ID = '{}' not found from task '{}'",
+      traceNodeId,
+      taskId);
+
+  LOG(INFO) << "Trace input for plan nodes '" << traceNodeId << "' from task '"
+            << taskId << "'";
+
+  UpdateAndCheckTraceLimitCB updateAndCheckTraceLimitCB = [&](uint64_t bytes) {
+    queryCtx.updateTracedBytesAndCheckLimit(bytes);
+  };
+
+  return std::make_unique<OperatorTraceCtx>(
+      traceNodeId,
+      traceDir,
+      std::move(updateAndCheckTraceLimitCB),
+      queryConfig.queryTraceTaskRegExp(),
+      queryConfig.queryTraceDryRun());
+}
+
+bool OperatorTraceCtx::shouldTrace(const Operator& op) const {
+  const auto& nodeId = op.planNodeId();
+
+  if (queryNodeId_.empty() || queryNodeId_ != nodeId) {
+    return false;
+  }
+
+  auto& tracedOpMap = op.operatorCtx()->driverCtx()->tracedOperatorMap;
+  if (const auto iter = tracedOpMap.find(op.operatorId());
+      iter != tracedOpMap.end()) {
+    LOG(WARNING) << "Operator " << iter->first << " with type of "
+                 << op.operatorType() << ", plan node " << nodeId
+                 << " might be the auxiliary operator of " << iter->second
+                 << " which has the same operator id";
+    return false;
+  }
+  tracedOpMap.emplace(op.operatorId(), op.operatorType());
+
+  if (!canTrace(op.operatorType())) {
+    VELOX_UNSUPPORTED("{} does not support tracing", op.operatorType());
+  }
+  return true;
+}
+
+std::unique_ptr<TraceInputWriter> OperatorTraceCtx::createInputTracer(
+    Operator& op) const {
+  return std::make_unique<OperatorTraceInputWriter>(
+      &op,
+      setupTraceDirectory(op, queryTraceDir_),
+      memory::traceMemoryPool(),
+      updateAndCheckTraceLimitCB_);
+}
+
+std::unique_ptr<TraceSplitWriter> OperatorTraceCtx::createSplitTracer(
+    Operator& op) const {
+  return std::make_unique<OperatorTraceSplitWriter>(
+      &op, setupTraceDirectory(op, queryTraceDir_));
+}
+
+std::unique_ptr<TraceMetadataWriter> OperatorTraceCtx::createMetadataTracer()
+    const {
+  createTraceDirectory(queryTraceDir_);
+  return std::make_unique<TaskTraceMetadataWriter>(
+      queryTraceDir_, queryNodeId_, memory::traceMemoryPool());
+}
+
+} // namespace facebook::velox::exec::trace
diff --git a/velox/common/base/TraceConfig.h b/velox/exec/OperatorTraceCtx.h
similarity index 53%
rename from velox/common/base/TraceConfig.h
rename to velox/exec/OperatorTraceCtx.h
index 0eb84070f22..26da31a2353 100644
--- a/velox/common/base/TraceConfig.h
+++ b/velox/exec/OperatorTraceCtx.h
@@ -16,45 +16,55 @@
 
 #pragma once
 
-#include <cstdint>
-#include <functional>
-#include <string>
-#include <unordered_set>
-
-namespace facebook::velox {
-
-#define VELOX_TRACE_LIMIT_EXCEEDED(errorMessage)                    \
-  _VELOX_THROW(                                                     \
-      ::facebook::velox::VeloxRuntimeError,                         \
-      ::facebook::velox::error_source::kErrorSourceRuntime.c_str(), \
-      ::facebook::velox::error_code::kTraceLimitExceeded.c_str(),   \
-      /* isRetriable */ true,                                       \
-      "{}",                                                         \
-      errorMessage);
+#include "velox/core/PlanFragment.h"
+#include "velox/core/QueryCtx.h"
+#include "velox/exec/trace/TraceCtx.h"
+
+namespace facebook::velox::exec::trace {
+
+class TraceInputWriter;
+class TraceSplitWriter;
 
 /// The callback used to update and aggregate the trace bytes of a query. If the
 /// query trace limit is set, the callback return true if the aggregate traced
 /// bytes exceed the set limit otherwise return false.
 using UpdateAndCheckTraceLimitCB = std::function<void(uint64_t)>;
 
-struct TraceConfig {
-  /// Target query trace node id.
-  std::string queryNodeId;
-  /// Base dir of query trace.
-  std::string queryTraceDir;
-  UpdateAndCheckTraceLimitCB updateAndCheckTraceLimitCB;
-  /// The trace task regexp.
-  std::string taskRegExp;
-  /// If true, we only collect operator input trace without the actual
-  /// execution. This is used by crash debugging so that we can collect the
-  /// input that triggers the crash.
-  bool dryRun{false};
-
-  TraceConfig(
+class OperatorTraceCtx : public TraceCtx {
+ public:
+  OperatorTraceCtx(
       std::string queryNodeId,
       std::string queryTraceDir,
       UpdateAndCheckTraceLimitCB updateAndCheckTraceLimitCB,
       std::string taskRegExp,
       bool dryRun);
+
+  static std::unique_ptr<OperatorTraceCtx> maybeCreate(
+      core::QueryCtx& queryCtx,
+      const core::PlanFragment& planFragment,
+      const std::string& taskId);
+
+  bool shouldTrace(const Operator& op) const override;
+
+  std::unique_ptr<TraceInputWriter> createInputTracer(
+      Operator& op) const override;
+
+  std::unique_ptr<TraceSplitWriter> createSplitTracer(
+      Operator& op) const override;
+
+  std::unique_ptr<TraceMetadataWriter> createMetadataTracer() const override;
+
+ private:
+  /// Target query trace node id.
+  const std::string queryNodeId_;
+
+  /// Base dir of query trace.
+  const std::string queryTraceDir_;
+
+  /// The trace task regexp.
+  const std::string taskRegExp_;
+
+  UpdateAndCheckTraceLimitCB updateAndCheckTraceLimitCB_;
 };
-} // namespace facebook::velox
+
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/OperatorTraceReader.cpp b/velox/exec/OperatorTraceReader.cpp
index 2e92b6c4071..52edeffe323 100644
--- a/velox/exec/OperatorTraceReader.cpp
+++ b/velox/exec/OperatorTraceReader.cpp
@@ -19,9 +19,10 @@
 #include <folly/hash/Checksum.h>
 #include "velox/common/file/FileInputStream.h"
 #include "velox/exec/OperatorTraceReader.h"
-#include "velox/exec/TraceUtil.h"
+#include "velox/exec/trace/TraceUtil.h"
 
 namespace facebook::velox::exec::trace {
+
 OperatorTraceInputReader::OperatorTraceInputReader(
     std::string traceDir,
     RowTypePtr dataType,
@@ -30,7 +31,7 @@ OperatorTraceInputReader::OperatorTraceInputReader(
       fs_(filesystems::getFileSystem(traceDir_, nullptr)),
       dataType_(std::move(dataType)),
       pool_(pool),
-      serde_(getNamedVectorSerde(VectorSerde::Kind::kPresto)),
+      serde_(getNamedVectorSerde("Presto")),
       inputStream_(getInputStream()) {
   VELOX_CHECK_NOT_NULL(dataType_);
 }
@@ -155,4 +156,5 @@ std::vector<std::string> OperatorTraceSplitReader::deserialize(
   }
   return splits;
 }
+
 } // namespace facebook::velox::exec::trace
diff --git a/velox/exec/OperatorTraceReader.h b/velox/exec/OperatorTraceReader.h
index 6a8e7c65650..95355d09be6 100644
--- a/velox/exec/OperatorTraceReader.h
+++ b/velox/exec/OperatorTraceReader.h
@@ -19,10 +19,11 @@
 #include "velox/common/file/FileInputStream.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/exec/Split.h"
-#include "velox/exec/Trace.h"
+#include "velox/exec/trace/Trace.h"
 #include "velox/serializers/PrestoSerializer.h"
 
 namespace facebook::velox::exec::trace {
+
 /// Used to read an operator trace input.
 class OperatorTraceInputReader {
  public:
@@ -95,4 +96,5 @@ class OperatorTraceSplitReader {
   const std::shared_ptr<filesystems::FileSystem> fs_;
   memory::MemoryPool* const pool_;
 };
+
 } // namespace facebook::velox::exec::trace
diff --git a/velox/exec/OperatorTraceScan.cpp b/velox/exec/OperatorTraceScan.cpp
index 965715dcc5f..e16c79ef746 100644
--- a/velox/exec/OperatorTraceScan.cpp
+++ b/velox/exec/OperatorTraceScan.cpp
@@ -15,8 +15,8 @@
  */
 
 #include "velox/exec/OperatorTraceScan.h"
-
-#include "velox/exec/TraceUtil.h"
+#include "velox/exec/OperatorType.h"
+#include "velox/exec/trace/TraceUtil.h"
 
 namespace facebook::velox::exec::trace {
 
@@ -29,7 +29,7 @@ OperatorTraceScan::OperatorTraceScan(
           traceScanNode->outputType(),
           operatorId,
           traceScanNode->id(),
-          "OperatorTraceScan") {
+          OperatorType::kOperatorTraceScan) {
   traceReader_ = std::make_unique<OperatorTraceInputReader>(
       getOpTraceDirectory(
           traceScanNode->traceDir(),
diff --git a/velox/exec/OperatorTraceScan.h b/velox/exec/OperatorTraceScan.h
index 1542e43f2c4..a18a31345dc 100644
--- a/velox/exec/OperatorTraceScan.h
+++ b/velox/exec/OperatorTraceScan.h
@@ -21,6 +21,7 @@
 #include "velox/exec/OperatorTraceReader.h"
 
 namespace facebook::velox::exec::trace {
+
 /// This is a scan operator for query replay. It uses traced data from a
 /// specific directory path, which is
 /// $traceRoot/$taskId/$nodeId/$pipelineId/$driverId.
diff --git a/velox/exec/OperatorTraceWriter.cpp b/velox/exec/OperatorTraceWriter.cpp
index 36719246f29..17dc05af0ad 100644
--- a/velox/exec/OperatorTraceWriter.cpp
+++ b/velox/exec/OperatorTraceWriter.cpp
@@ -23,15 +23,17 @@
 #include "velox/common/file/File.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/exec/Operator.h"
-#include "velox/exec/Trace.h"
-#include "velox/exec/TraceUtil.h"
+#include "velox/exec/OperatorType.h"
+#include "velox/exec/trace/Trace.h"
+#include "velox/exec/trace/TraceUtil.h"
 
 namespace facebook::velox::exec::trace {
 namespace {
+
 void recordOperatorSummary(Operator* op, folly::dynamic& obj) {
   obj[OperatorTraceTraits::kOpTypeKey] = op->operatorType();
   const auto stats = op->stats(/*clear=*/false);
-  if (op->operatorType() == "TableScan") {
+  if (op->operatorType() == OperatorType::kTableScan) {
     obj[OperatorTraceTraits::kNumSplitsKey] = stats.numSplits;
   }
   obj[OperatorTraceTraits::kPeakMemoryKey] =
@@ -41,6 +43,7 @@ void recordOperatorSummary(Operator* op, folly::dynamic& obj) {
   obj[OperatorTraceTraits::kRawInputRowsKey] = stats.rawInputPositions;
   obj[OperatorTraceTraits::kRawInputBytesKey] = stats.rawInputBytes;
 }
+
 } // namespace
 
 OperatorTraceInputWriter::OperatorTraceInputWriter(
@@ -52,15 +55,17 @@ OperatorTraceInputWriter::OperatorTraceInputWriter(
       traceDir_(std::move(traceDir)),
       fs_(filesystems::getFileSystem(traceDir_, nullptr)),
       pool_(pool),
-      serde_(getNamedVectorSerde(VectorSerde::Kind::kPresto)),
+      serde_(getNamedVectorSerde("Presto")),
       updateAndCheckTraceLimitCB_(std::move(updateAndCheckTraceLimitCB)) {
   traceFile_ = fs_->openFileForWrite(getOpTraceInputFilePath(traceDir_));
   VELOX_CHECK_NOT_NULL(traceFile_);
 }
 
-void OperatorTraceInputWriter::write(const RowVectorPtr& rows) {
+bool OperatorTraceInputWriter::write(
+    const RowVectorPtr& rows,
+    ContinueFuture*) {
   if (FOLLY_UNLIKELY(finished_)) {
-    return;
+    return false;
   }
 
   if (batch_ == nullptr) {
@@ -80,6 +85,7 @@ void OperatorTraceInputWriter::write(const RowVectorPtr& rows) {
   auto iobuf = out.getIOBuf();
   updateAndCheckTraceLimitCB_(iobuf->computeChainDataLength());
   traceFile_->append(std::move(iobuf));
+  return false;
 }
 
 void OperatorTraceInputWriter::finish() {
@@ -146,9 +152,9 @@ std::unique_ptr<folly::IOBuf> OperatorTraceSplitWriter::serialize(
   auto ioBuf =
       folly::IOBuf::create(sizeof(length) + split.size() + sizeof(crc32));
   folly::io::Appender appender(ioBuf.get(), 0);
-  appender.writeLE(length);
+  appender.writeLE<uint32_t>(length);
   appender.push(reinterpret_cast<const uint8_t*>(split.data()), length);
-  appender.writeLE(crc32);
+  appender.writeLE<uint32_t>(crc32);
   return ioBuf;
 }
 
diff --git a/velox/exec/OperatorTraceWriter.h b/velox/exec/OperatorTraceWriter.h
index 189577dee1f..49b8a94a999 100644
--- a/velox/exec/OperatorTraceWriter.h
+++ b/velox/exec/OperatorTraceWriter.h
@@ -16,10 +16,12 @@
 
 #pragma once
 
-#include "velox/common/base/TraceConfig.h"
 #include "velox/common/file/File.h"
 #include "velox/common/file/FileSystems.h"
+#include "velox/exec/OperatorTraceCtx.h"
 #include "velox/exec/Split.h"
+#include "velox/exec/trace/TraceCtx.h"
+#include "velox/exec/trace/TraceWriter.h"
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/vector/VectorStream.h"
 
@@ -32,7 +34,7 @@ namespace facebook::velox::exec::trace {
 /// Used to serialize and write the input vectors from a particular operator
 /// into a data file. Additionally, it creates a corresponding summary file that
 /// contains information such as peak memory, input rows, operator type, etc.
-class OperatorTraceInputWriter {
+class OperatorTraceInputWriter : public TraceInputWriter {
  public:
   /// 'traceOp' is the operator to trace. 'traceDir' specifies the trace
   /// directory for the operator.
@@ -43,10 +45,10 @@ class OperatorTraceInputWriter {
       UpdateAndCheckTraceLimitCB updateAndCheckTraceLimitCB);
 
   /// Serializes rows and writes out each batch.
-  void write(const RowVectorPtr& rows);
+  bool write(const RowVectorPtr& rows, ContinueFuture* future) override;
 
   /// Closes the data file and writes out the data summary.
-  void finish();
+  void finish() override;
 
  private:
   // Flushes the trace data summaries to the disk.
@@ -77,16 +79,16 @@ class OperatorTraceInputWriter {
 /// Currently, it only works with 'HiveConnectorSplit'. In the future, it will
 /// be extended to handle more types of splits, such as
 /// 'IcebergHiveConnectorSplit'.
-class OperatorTraceSplitWriter {
+class OperatorTraceSplitWriter : public TraceSplitWriter {
  public:
   explicit OperatorTraceSplitWriter(Operator* traceOp, std::string traceDir);
 
   /// Serializes and writes out each split. Each serialized split is immediately
   /// flushed to ensure that we can still replay a traced operator even if a
   /// crash occurs during execution.
-  void write(const exec::Split& split) const;
+  void write(const exec::Split& split) const override;
 
-  void finish();
+  void finish() override;
 
  private:
   static std::unique_ptr<folly::IOBuf> serialize(const std::string& split);
diff --git a/velox/exec/OperatorType.h b/velox/exec/OperatorType.h
new file mode 100644
index 00000000000..40a11cdac8a
--- /dev/null
+++ b/velox/exec/OperatorType.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string_view>
+
+namespace facebook::velox::exec {
+
+/// Centralized constants for operator type strings used in operator
+/// constructors and comparison sites throughout the execution engine.
+struct OperatorType {
+  static constexpr std::string_view kAggregation = "Aggregation";
+  static constexpr std::string_view kArrowStream = "ArrowStream";
+  static constexpr std::string_view kAssignUniqueId = "AssignUniqueId";
+  static constexpr std::string_view kBlockedOperator = "BlockedOperator";
+  static constexpr std::string_view kCallbackSink = "CallbackSink";
+  static constexpr std::string_view kEnforceDistinct = "EnforceDistinct";
+  static constexpr std::string_view kEnforceSingleRow = "EnforceSingleRow";
+  static constexpr std::string_view kExchange = "Exchange";
+  static constexpr std::string_view kExpand = "Expand";
+  static constexpr std::string_view kFilterProject = "FilterProject";
+  static constexpr std::string_view kGroupId = "GroupId";
+  static constexpr std::string_view kHashBuild = "HashBuild";
+  static constexpr std::string_view kHashProbe = "HashProbe";
+  static constexpr std::string_view kIndexLookupJoin = "IndexLookupJoin";
+  static constexpr std::string_view kLimit = "Limit";
+  static constexpr std::string_view kLocalExchange = "LocalExchange";
+  static constexpr std::string_view kLocalMerge = "LocalMerge";
+  static constexpr std::string_view kLocalPartition = "LocalPartition";
+  static constexpr std::string_view kMarkDistinct = "MarkDistinct";
+  static constexpr std::string_view kMergeExchange = "MergeExchange";
+  static constexpr std::string_view kMergeJoin = "MergeJoin";
+  static constexpr std::string_view kMixedUnion = "MixedUnion";
+  static constexpr std::string_view kNestedLoopJoinBuild =
+      "NestedLoopJoinBuild";
+  static constexpr std::string_view kNestedLoopJoinProbe =
+      "NestedLoopJoinProbe";
+  static constexpr std::string_view kOperatorTraceScan = "OperatorTraceScan";
+  static constexpr std::string_view kOrderBy = "OrderBy";
+  static constexpr std::string_view kParallelProject = "ParallelProject";
+  static constexpr std::string_view kPartialAggregation = "PartialAggregation";
+  static constexpr std::string_view kPartitionedOutput = "PartitionedOutput";
+  static constexpr std::string_view kRowNumber = "RowNumber";
+  static constexpr std::string_view kSpatialJoinBuild = "SpatialJoinBuild";
+  static constexpr std::string_view kSpatialJoinProbe = "SpatialJoinProbe";
+  static constexpr std::string_view kStreamingEnforceDistinct =
+      "StreamingEnforceDistinct";
+  static constexpr std::string_view kTableScan = "TableScan";
+  static constexpr std::string_view kTableWrite = "TableWrite";
+  static constexpr std::string_view kTableWriteMerge = "TableWriteMerge";
+  static constexpr std::string_view kTopN = "TopN";
+  static constexpr std::string_view kTopNRowNumber = "TopNRowNumber";
+  static constexpr std::string_view kUnnest = "Unnest";
+  static constexpr std::string_view kValues = "Values";
+  static constexpr std::string_view kWindow = "Window";
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/OperatorUtils.cpp b/velox/exec/OperatorUtils.cpp
index eb7258202a9..184d8edd764 100644
--- a/velox/exec/OperatorUtils.cpp
+++ b/velox/exec/OperatorUtils.cpp
@@ -14,8 +14,10 @@
  * limitations under the License.
  */
 #include "velox/exec/OperatorUtils.h"
+#include "velox/exec/PartitionedOutput.h"
 #include "velox/exec/VectorHasher.h"
 #include "velox/expression/EvalCtx.h"
+#include "velox/serializers/PrestoSerializer.h"
 #include "velox/vector/ConstantVector.h"
 #include "velox/vector/FlatVector.h"
 #include "velox/vector/LazyVector.h"
@@ -101,7 +103,11 @@ void gatherCopy(
     const std::vector<const RowVector*>& sources,
     const std::vector<vector_size_t>& sourceIndices,
     column_index_t sourceChannel) {
-  if (target->isScalar()) {
+  const bool flattenSources =
+      std::all_of(sources.begin(), sources.end(), [](const auto& source) {
+        return source->isFlatEncoding();
+      });
+  if (target->isScalar() && flattenSources) {
     VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
         scalarGatherCopy,
         target->type()->kind(),
@@ -124,7 +130,14 @@ bool shouldAggregateRuntimeMetric(const std::string& name) {
       "dataSourceAddSplitWallNanos",
       "dataSourceLazyWallNanos",
       "queuedWallNanos",
-      "flushTimes"};
+      "flushTimes",
+      "driverCpuTimeNanos",
+      "ioWaitWallNanos",
+      "storageReadWallNanos",
+      "ssdCacheReadWallNanos",
+      "cacheWaitWallNanos",
+      "coalescedSsdLoadWallNanos",
+      "coalescedStorageLoadWallNanos"};
   if (metricNames.contains(name)) {
     return true;
   }
@@ -457,21 +470,21 @@ std::string makeOperatorSpillPath(
 }
 
 void setOperatorRuntimeStats(
-    const std::string& name,
+    std::string_view name,
     const RuntimeCounter& value,
     std::unordered_map<std::string, RuntimeMetric>& stats) {
-  stats[name] = RuntimeMetric(value.unit);
-  stats[name].addValue(value.value);
+  auto [it, _] =
+      stats.insert_or_assign(std::string(name), RuntimeMetric(value.unit));
+  it->second.addValue(value.value);
 }
 
 void addOperatorRuntimeStats(
-    const std::string& name,
+    std::string_view name,
     const RuntimeCounter& value,
     std::unordered_map<std::string, RuntimeMetric>& stats) {
-  auto statIt = stats.find(name);
-  if (UNLIKELY(statIt == stats.end())) {
-    statIt = stats.insert(std::pair(name, RuntimeMetric(value.unit))).first;
-  } else {
+  auto [statIt, inserted] =
+      stats.emplace(std::string(name), RuntimeMetric(value.unit));
+  if (!inserted) {
     VELOX_CHECK_EQ(statIt->second.unit, value.unit);
   }
   statIt->second.addValue(value.value);
@@ -569,4 +582,21 @@ std::unique_ptr<Operator> BlockedOperatorFactory::toOperator(
   }
   return nullptr;
 }
+
+std::unique_ptr<VectorSerde::Options> getVectorSerdeOptions(
+    common::CompressionKind compressionKind,
+    const std::string& kind,
+    std::optional<float> minCompressionRatio,
+    int32_t minCompressionPageSizeBytes) {
+  std::unique_ptr<VectorSerde::Options> options = kind == "Presto"
+      ? std::make_unique<serializer::presto::PrestoVectorSerde::PrestoOptions>()
+      : std::make_unique<VectorSerde::Options>();
+  options->compressionKind = compressionKind;
+  if (minCompressionRatio.has_value()) {
+    options->minCompressionRatio = minCompressionRatio.value();
+  }
+  options->minCompressionPageSizeBytes = minCompressionPageSizeBytes;
+  return options;
+}
+
 } // namespace facebook::velox::exec
diff --git a/velox/exec/OperatorUtils.h b/velox/exec/OperatorUtils.h
index ac2698e437d..f80d48bc227 100644
--- a/velox/exec/OperatorUtils.h
+++ b/velox/exec/OperatorUtils.h
@@ -15,8 +15,12 @@
  */
 #pragma once
 
+#include <optional>
+#include "velox/core/QueryConfig.h"
 #include "velox/exec/Operator.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/Spiller.h"
+#include "velox/vector/VectorStream.h"
 
 namespace facebook::velox::exec {
 
@@ -147,13 +151,13 @@ std::string makeOperatorSpillPath(
 
 /// Set a named runtime metric in operator 'stats'.
 void setOperatorRuntimeStats(
-    const std::string& name,
+    std::string_view name,
     const RuntimeCounter& value,
     std::unordered_map<std::string, RuntimeMetric>& stats);
 
 /// Add a named runtime metric to operator 'stats'.
 void addOperatorRuntimeStats(
-    const std::string& name,
+    std::string_view name,
     const RuntimeCounter& value,
     std::unordered_map<std::string, RuntimeMetric>& stats);
 
@@ -229,7 +233,12 @@ class BlockedOperator : public Operator {
       int32_t id,
       core::PlanNodePtr node,
       BlockedOperatorCb&& blockedCb)
-      : Operator(ctx, node->outputType(), id, node->id(), "BlockedOperator"),
+      : Operator(
+            ctx,
+            node->outputType(),
+            id,
+            node->id(),
+            OperatorType::kBlockedOperator),
         blockedCb_(std::move(blockedCb)) {}
 
   BlockingReason isBlocked(ContinueFuture* future) override {
@@ -307,4 +316,13 @@ class BlockedOperatorFactory : public Operator::PlanNodeTranslator {
  private:
   BlockedOperatorCb blockedCb_{nullptr};
 };
+
+/// Creates VectorSerde::Options for the given VectorSerde kind with compression
+/// settings. Optionally configures minimum compression ratio.
+std::unique_ptr<VectorSerde::Options> getVectorSerdeOptions(
+    common::CompressionKind compressionKind,
+    const std::string& kind,
+    std::optional<float> minCompressionRatio = std::nullopt,
+    int32_t minCompressionPageSizeBytes = 0);
+
 } // namespace facebook::velox::exec
diff --git a/velox/exec/OrderBy.cpp b/velox/exec/OrderBy.cpp
index dc6b5d54809..85957281898 100644
--- a/velox/exec/OrderBy.cpp
+++ b/velox/exec/OrderBy.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 #include "velox/exec/OrderBy.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/Task.h"
 #include "velox/vector/FlatVector.h"
@@ -39,9 +40,9 @@ OrderBy::OrderBy(
           orderByNode->outputType(),
           operatorId,
           orderByNode->id(),
-          "OrderBy",
+          OperatorType::kOrderBy,
           orderByNode->canSpill(driverCtx->queryConfig())
-              ? driverCtx->makeSpillConfig(operatorId)
+              ? driverCtx->makeSpillConfig(operatorId, OperatorType::kOrderBy)
               : std::nullopt) {
   maxOutputRows_ = outputBatchRows(std::nullopt);
   VELOX_CHECK(pool()->trackUsage());
diff --git a/velox/exec/OutputBuffer.cpp b/velox/exec/OutputBuffer.cpp
index b2396d745ce..e3045d1f64e 100644
--- a/velox/exec/OutputBuffer.cpp
+++ b/velox/exec/OutputBuffer.cpp
@@ -30,10 +30,10 @@ void ArbitraryBuffer::noMoreData() {
   pages_.push_back(nullptr);
 }
 
-void ArbitraryBuffer::enqueue(std::unique_ptr<SerializedPage> page) {
+void ArbitraryBuffer::enqueue(std::unique_ptr<SerializedPageBase> page) {
   VELOX_CHECK_NOT_NULL(page, "Unexpected null page");
   VELOX_CHECK(!hasNoMoreData(), "Arbitrary buffer has set no more data marker");
-  pages_.push_back(std::shared_ptr<SerializedPage>(page.release()));
+  pages_.push_back(std::shared_ptr<SerializedPageBase>(page.release()));
 }
 
 void ArbitraryBuffer::getAvailablePageSizes(std::vector<int64_t>& out) const {
@@ -45,7 +45,7 @@ void ArbitraryBuffer::getAvailablePageSizes(std::vector<int64_t>& out) const {
   }
 }
 
-std::vector<std::shared_ptr<SerializedPage>> ArbitraryBuffer::getPages(
+std::vector<std::shared_ptr<SerializedPageBase>> ArbitraryBuffer::getPages(
     uint64_t maxBytes) {
   if (maxBytes == 0 && !pages_.empty() && pages_.front() == nullptr) {
     // Always give out an end marker when this buffer is finished and fully
@@ -57,7 +57,7 @@ std::vector<std::shared_ptr<SerializedPage>> ArbitraryBuffer::getPages(
     VELOX_CHECK_EQ(pages_.size(), 1);
     return {nullptr};
   }
-  std::vector<std::shared_ptr<SerializedPage>> pages;
+  std::vector<std::shared_ptr<SerializedPageBase>> pages;
   uint64_t bytesRemoved{0};
   while (bytesRemoved < maxBytes && !pages_.empty()) {
     if (pages_.front() == nullptr) {
@@ -81,7 +81,7 @@ std::string ArbitraryBuffer::toString() const {
       hasNoMoreData());
 }
 
-void DestinationBuffer::Stats::recordEnqueue(const SerializedPage& data) {
+void DestinationBuffer::Stats::recordEnqueue(const SerializedPageBase& data) {
   const auto numRows = data.numRows();
   VELOX_CHECK(numRows.has_value(), "SerializedPage's numRows must be valid");
   bytesBuffered += data.size();
@@ -89,7 +89,8 @@ void DestinationBuffer::Stats::recordEnqueue(const SerializedPage& data) {
   ++pagesBuffered;
 }
 
-void DestinationBuffer::Stats::recordAcknowledge(const SerializedPage& data) {
+void DestinationBuffer::Stats::recordAcknowledge(
+    const SerializedPageBase& data) {
   const auto numRows = data.numRows();
   VELOX_CHECK(numRows.has_value(), "SerializedPage's numRows must be valid");
   const int64_t size = data.size();
@@ -104,7 +105,7 @@ void DestinationBuffer::Stats::recordAcknowledge(const SerializedPage& data) {
   ++pagesSent;
 }
 
-void DestinationBuffer::Stats::recordDelete(const SerializedPage& data) {
+void DestinationBuffer::Stats::recordDelete(const SerializedPageBase& data) {
   recordAcknowledge(data);
 }
 
@@ -185,7 +186,7 @@ DestinationBuffer::Data DestinationBuffer::getData(
   return {std::move(data), std::move(remainingBytes), true};
 }
 
-void DestinationBuffer::enqueue(std::shared_ptr<SerializedPage> data) {
+void DestinationBuffer::enqueue(std::shared_ptr<SerializedPageBase> data) {
   // Drop duplicate end markers.
   if (data == nullptr && !data_.empty() && data_.back() == nullptr) {
     return;
@@ -245,7 +246,7 @@ void DestinationBuffer::loadData(ArbitraryBuffer* buffer, uint64_t maxBytes) {
   }
 }
 
-std::vector<std::shared_ptr<SerializedPage>> DestinationBuffer::acknowledge(
+std::vector<std::shared_ptr<SerializedPageBase>> DestinationBuffer::acknowledge(
     int64_t sequence,
     bool fromGetData) {
   const int64_t numDeleted = sequence - sequence_;
@@ -268,7 +269,7 @@ std::vector<std::shared_ptr<SerializedPage>> DestinationBuffer::acknowledge(
 
   VELOX_CHECK_LE(
       numDeleted, data_.size(), "Ack received for a not yet produced item");
-  std::vector<std::shared_ptr<SerializedPage>> freed;
+  std::vector<std::shared_ptr<SerializedPageBase>> freed;
   for (auto i = 0; i < numDeleted; ++i) {
     if (data_[i] == nullptr) {
       VELOX_CHECK_EQ(i, data_.size() - 1, "null marker found in the middle");
@@ -277,14 +278,14 @@ std::vector<std::shared_ptr<SerializedPage>> DestinationBuffer::acknowledge(
     stats_.recordAcknowledge(*data_[i]);
     freed.push_back(std::move(data_[i]));
   }
-  data_.erase(data_.begin(), data_.begin() + numDeleted);
+  data_.erase(data_.cbegin(), data_.cbegin() + numDeleted);
   sequence_ += numDeleted;
   return freed;
 }
 
-std::vector<std::shared_ptr<SerializedPage>>
+std::vector<std::shared_ptr<SerializedPageBase>>
 DestinationBuffer::deleteResults() {
-  std::vector<std::shared_ptr<SerializedPage>> freed;
+  std::vector<std::shared_ptr<SerializedPageBase>> freed;
   for (auto i = 0; i < data_.size(); ++i) {
     if (data_[i] == nullptr) {
       VELOX_CHECK_EQ(i, data_.size() - 1, "null marker found in the middle");
@@ -314,7 +315,7 @@ namespace {
 // that we do the expensive free outside and only then continue the
 // producers which will allocate more memory.
 void releaseAfterAcknowledge(
-    std::vector<std::shared_ptr<SerializedPage>>& freed,
+    std::vector<std::shared_ptr<SerializedPageBase>>& freed,
     std::vector<ContinuePromise>& promises) {
   freed.clear();
   for (auto& promise : promises) {
@@ -445,7 +446,7 @@ void OutputBuffer::updateTotalBufferedBytesMsLocked() {
 
 bool OutputBuffer::enqueue(
     int destination,
-    std::unique_ptr<SerializedPage> data,
+    std::unique_ptr<SerializedPageBase> data,
     ContinueFuture* future) {
   VELOX_CHECK_NOT_NULL(data);
   VELOX_CHECK(
@@ -492,13 +493,13 @@ bool OutputBuffer::enqueue(
 }
 
 void OutputBuffer::enqueueBroadcastOutputLocked(
-    std::unique_ptr<SerializedPage> data,
+    std::unique_ptr<SerializedPageBase> data,
     std::vector<DataAvailable>& dataAvailableCbs) {
   VELOX_DCHECK(isBroadcast());
   VELOX_CHECK_NULL(arbitraryBuffer_);
   VELOX_DCHECK(dataAvailableCbs.empty());
 
-  std::shared_ptr<SerializedPage> sharedData(data.release());
+  std::shared_ptr<SerializedPageBase> sharedData(data.release());
   for (auto& buffer : buffers_) {
     if (buffer != nullptr) {
       buffer->enqueue(sharedData);
@@ -514,7 +515,7 @@ void OutputBuffer::enqueueBroadcastOutputLocked(
 }
 
 void OutputBuffer::enqueueArbitraryOutputLocked(
-    std::unique_ptr<SerializedPage> data,
+    std::unique_ptr<SerializedPageBase> data,
     std::vector<DataAvailable>& dataAvailableCbs) {
   VELOX_DCHECK(isArbitrary());
   VELOX_DCHECK_NOT_NULL(arbitraryBuffer_);
@@ -541,7 +542,7 @@ void OutputBuffer::enqueueArbitraryOutputLocked(
 
 void OutputBuffer::enqueuePartitionedOutputLocked(
     int destination,
-    std::unique_ptr<SerializedPage> data,
+    std::unique_ptr<SerializedPageBase> data,
     std::vector<DataAvailable>& dataAvailableCbs) {
   VELOX_DCHECK(isPartitioned());
   VELOX_CHECK_NULL(arbitraryBuffer_);
@@ -631,7 +632,7 @@ bool OutputBuffer::isFinishedLocked() {
 }
 
 void OutputBuffer::acknowledge(int destination, int64_t sequence) {
-  std::vector<std::shared_ptr<SerializedPage>> freed;
+  std::vector<std::shared_ptr<SerializedPageBase>> freed;
   std::vector<ContinuePromise> promises;
   {
     std::lock_guard<std::mutex> l(mutex_);
@@ -649,7 +650,7 @@ void OutputBuffer::acknowledge(int destination, int64_t sequence) {
 }
 
 void OutputBuffer::updateAfterAcknowledgeLocked(
-    const std::vector<std::shared_ptr<SerializedPage>>& freed,
+    const std::vector<std::shared_ptr<SerializedPageBase>>& freed,
     std::vector<ContinuePromise>& promises) {
   uint64_t freedBytes{0};
   int freedPages{0};
@@ -673,7 +674,7 @@ void OutputBuffer::updateAfterAcknowledgeLocked(
 }
 
 bool OutputBuffer::deleteResults(int destination) {
-  std::vector<std::shared_ptr<SerializedPage>> freed;
+  std::vector<std::shared_ptr<SerializedPageBase>> freed;
   std::vector<ContinuePromise> promises;
   bool isFinished;
   DataAvailable dataAvailable;
@@ -717,7 +718,7 @@ void OutputBuffer::getData(
     DataAvailableCallback notify,
     DataConsumerActiveCheckCallback activeCheck) {
   DestinationBuffer::Data data;
-  std::vector<std::shared_ptr<SerializedPage>> freed;
+  std::vector<std::shared_ptr<SerializedPageBase>> freed;
   std::vector<ContinuePromise> promises;
   {
     std::lock_guard<std::mutex> l(mutex_);
diff --git a/velox/exec/OutputBuffer.h b/velox/exec/OutputBuffer.h
index 640c1bfcd8e..a21d9928e5a 100644
--- a/velox/exec/OutputBuffer.h
+++ b/velox/exec/OutputBuffer.h
@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include "velox/common/base/Portability.h"
 #include "velox/core/PlanNode.h"
 #include "velox/exec/ExchangeQueue.h"
 
@@ -75,11 +76,11 @@ class ArbitraryBuffer {
   /// appends a null page at the end of 'pages_' as end marker.
   void noMoreData();
 
-  void enqueue(std::unique_ptr<SerializedPage> page);
+  void enqueue(std::unique_ptr<SerializedPageBase> page);
 
   /// Returns a number of pages with total bytes no less than 'maxBytes' if
   /// there are sufficient buffered pages.
-  std::vector<std::shared_ptr<SerializedPage>> getPages(uint64_t maxBytes);
+  std::vector<std::shared_ptr<SerializedPageBase>> getPages(uint64_t maxBytes);
 
   /// Append the available page sizes to `out'.
   void getAvailablePageSizes(std::vector<int64_t>& out) const;
@@ -87,7 +88,7 @@ class ArbitraryBuffer {
   std::string toString() const;
 
  private:
-  std::deque<std::shared_ptr<SerializedPage>> pages_;
+  std::deque<std::shared_ptr<SerializedPageBase>> pages_;
 };
 
 class DestinationBuffer {
@@ -98,11 +99,11 @@ class DestinationBuffer {
   /// 2. Sent: the data is removed from the buffer after it is acked or
   ///          deleted.
   struct Stats {
-    void recordEnqueue(const SerializedPage& data);
+    void recordEnqueue(const SerializedPageBase& data);
 
-    void recordAcknowledge(const SerializedPage& data);
+    void recordAcknowledge(const SerializedPageBase& data);
 
-    void recordDelete(const SerializedPage& data);
+    void recordDelete(const SerializedPageBase& data);
 
     bool finished{false};
 
@@ -117,7 +118,7 @@ class DestinationBuffer {
     int64_t pagesSent{0};
   };
 
-  void enqueue(std::shared_ptr<SerializedPage> data);
+  void enqueue(std::shared_ptr<SerializedPageBase> data);
 
   /// Invoked to load data with up to 'notifyMaxBytes_' bytes from arbitrary
   /// 'buffer' if there is pending fetch from this destination in which case
@@ -165,12 +166,12 @@ class DestinationBuffer {
   /// do not give a warning for the case where no data is removed, otherwise we
   /// expect that data does get freed. We cannot assert that data gets deleted
   /// because acknowledge messages can arrive out of order.
-  std::vector<std::shared_ptr<SerializedPage>> acknowledge(
+  std::vector<std::shared_ptr<SerializedPageBase>> acknowledge(
       int64_t sequence,
       bool fromGetData);
 
   /// Removes all remaining data from the queue and returns the removed data.
-  std::vector<std::shared_ptr<SerializedPage>> deleteResults();
+  std::vector<std::shared_ptr<SerializedPageBase>> deleteResults();
 
   /// Returns and clears the notify callback, if any, along with arguments for
   /// the callback.
@@ -187,7 +188,7 @@ class DestinationBuffer {
  private:
   void clearNotify();
 
-  std::vector<std::shared_ptr<SerializedPage>> data_;
+  std::vector<std::shared_ptr<SerializedPageBase>> data_;
   // The sequence number of the first in 'data_'.
   int64_t sequence_ = 0;
   DataAvailableCallback notify_{nullptr};
@@ -280,7 +281,7 @@ class OutputBuffer {
 
   bool enqueue(
       int destination,
-      std::unique_ptr<SerializedPage> data,
+      std::unique_ptr<SerializedPageBase> data,
       ContinueFuture* future);
 
   void noMoreData();
@@ -345,7 +346,7 @@ class OutputBuffer {
   // Updates buffered size and returns possibly continuable producer promises
   // in 'promises'.
   void updateAfterAcknowledgeLocked(
-      const std::vector<std::shared_ptr<SerializedPage>>& freed,
+      const std::vector<std::shared_ptr<SerializedPageBase>>& freed,
       std::vector<ContinuePromise>& promises);
 
   /// Given an updated total number of broadcast buffers, add any missing ones
@@ -353,16 +354,16 @@ class OutputBuffer {
   void addOutputBuffersLocked(int numBuffers);
 
   void enqueueBroadcastOutputLocked(
-      std::unique_ptr<SerializedPage> data,
+      std::unique_ptr<SerializedPageBase> data,
       std::vector<DataAvailable>& dataAvailableCbs);
 
   void enqueueArbitraryOutputLocked(
-      std::unique_ptr<SerializedPage> data,
+      std::unique_ptr<SerializedPageBase> data,
       std::vector<DataAvailable>& dataAvailableCbs);
 
   void enqueuePartitionedOutputLocked(
       int destination,
-      std::unique_ptr<SerializedPage> data,
+      std::unique_ptr<SerializedPageBase> data,
       std::vector<DataAvailable>& dataAvailableCbs);
 
   std::string toStringLocked() const;
@@ -401,11 +402,11 @@ class OutputBuffer {
   // While noMoreBuffers_ is false, stores the enqueued data to
   // broadcast to destinations that have not yet been initialized. Cleared
   // after receiving no-more-broadcast-buffers signal.
-  std::vector<std::shared_ptr<SerializedPage>> dataToBroadcast_;
+  std::vector<std::shared_ptr<SerializedPageBase>> dataToBroadcast_;
 
   std::mutex mutex_;
   // Actual data size in 'buffers_'.
-  int64_t bufferedBytes_{0};
+  tsan_atomic<int64_t> bufferedBytes_{0};
   // The number of buffered pages which corresponds to 'bufferedBytes_'.
   int64_t bufferedPages_{0};
   // The total number of output bytes, rows and pages.
@@ -425,7 +426,7 @@ class OutputBuffer {
   uint32_t numFinished_{0};
   // When this reaches buffers_.size(), 'this' can be freed.
   int numFinalAcknowledges_ = 0;
-  bool atEnd_ = false;
+  tsan_atomic<bool> atEnd_{false};
 
   // Time since last change in bufferedBytes_. Used to compute total time data
   // is buffered. Ignored if bufferedBytes_ is zero.
diff --git a/velox/exec/OutputBufferManager.cpp b/velox/exec/OutputBufferManager.cpp
index 4773911a530..f8183218fb4 100644
--- a/velox/exec/OutputBufferManager.cpp
+++ b/velox/exec/OutputBufferManager.cpp
@@ -57,7 +57,7 @@ uint64_t OutputBufferManager::numBuffers() const {
 bool OutputBufferManager::enqueue(
     const std::string& taskId,
     int destination,
-    std::unique_ptr<SerializedPage> data,
+    std::unique_ptr<SerializedPageBase> data,
     ContinueFuture* future) {
   return getBuffer(taskId)->enqueue(destination, std::move(data), future);
 }
diff --git a/velox/exec/OutputBufferManager.h b/velox/exec/OutputBufferManager.h
index 8affa6f9051..ef9487ee87b 100644
--- a/velox/exec/OutputBufferManager.h
+++ b/velox/exec/OutputBufferManager.h
@@ -53,7 +53,7 @@ class OutputBufferManager {
   bool enqueue(
       const std::string& taskId,
       int destination,
-      std::unique_ptr<SerializedPage> data,
+      std::unique_ptr<SerializedPageBase> data,
       ContinueFuture* future);
 
   void noMoreData(const std::string& taskId);
diff --git a/velox/exec/ParallelProject.cpp b/velox/exec/ParallelProject.cpp
index 8d3cf41e986..e772838e2bf 100644
--- a/velox/exec/ParallelProject.cpp
+++ b/velox/exec/ParallelProject.cpp
@@ -17,6 +17,7 @@
 #include "velox/exec/ParallelProject.h"
 #include "velox/common/base/AsyncSource.h"
 #include "velox/exec/Operator.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/Task.h"
 
 namespace facebook::velox::exec {
@@ -30,7 +31,7 @@ ParallelProject::ParallelProject(
           node->outputType(),
           operatorId,
           node->id(),
-          "ParallelProject"),
+          OperatorType::kParallelProject),
       node_(node) {}
 
 namespace {
@@ -139,8 +140,9 @@ RowVectorPtr ParallelProject::getOutput() {
   std::vector<VectorPtr> results(outputType_->size());
 
   for (auto i = 0; i < work_.size(); ++i) {
-    pending.push_back(std::make_shared<AsyncSource<WorkResult>>(
-        [i, &results, this]() { return doWork(i, results); }));
+    pending.push_back(
+        std::make_shared<AsyncSource<WorkResult>>(
+            [i, &results, this]() { return doWork(i, results); }));
     auto item = pending.back();
     operatorCtx_->task()->queryCtx()->executor()->add(
         [item]() { item->prepare(); });
diff --git a/velox/exec/PartitionStreamingWindowBuild.cpp b/velox/exec/PartitionStreamingWindowBuild.cpp
index 331d3e6f6e1..a3ce88cbe7b 100644
--- a/velox/exec/PartitionStreamingWindowBuild.cpp
+++ b/velox/exec/PartitionStreamingWindowBuild.cpp
@@ -78,7 +78,7 @@ PartitionStreamingWindowBuild::nextPartition() {
     data_->eraseRows(
         folly::Range<char**>(sortedRows_.data(), numPreviousPartitionRows));
     sortedRows_.erase(
-        sortedRows_.begin(), sortedRows_.begin() + numPreviousPartitionRows);
+        sortedRows_.cbegin(), sortedRows_.cbegin() + numPreviousPartitionRows);
     sortedRows_.shrink_to_fit();
     for (int i = currentPartition_; i < partitionStartRows_.size(); ++i) {
       partitionStartRows_[i] =
diff --git a/velox/exec/PartitionStreamingWindowBuild.h b/velox/exec/PartitionStreamingWindowBuild.h
index bb5cb352d24..2c9cc1e14c9 100644
--- a/velox/exec/PartitionStreamingWindowBuild.h
+++ b/velox/exec/PartitionStreamingWindowBuild.h
@@ -38,7 +38,7 @@ class PartitionStreamingWindowBuild : public WindowBuild {
     VELOX_UNREACHABLE();
   }
 
-  std::optional<common::SpillStats> spilledStats() const override {
+  std::optional<exec::SpillStats> spilledStats() const override {
     return std::nullopt;
   }
 
diff --git a/velox/exec/PartitionedOutput.cpp b/velox/exec/PartitionedOutput.cpp
index 974cfbb3ec8..ea221045b87 100644
--- a/velox/exec/PartitionedOutput.cpp
+++ b/velox/exec/PartitionedOutput.cpp
@@ -15,24 +15,12 @@
  */
 
 #include "velox/exec/PartitionedOutput.h"
+#include "velox/exec/OperatorType.h"
+#include "velox/exec/OperatorUtils.h"
 #include "velox/exec/OutputBufferManager.h"
 #include "velox/exec/Task.h"
 
 namespace facebook::velox::exec {
-namespace {
-std::unique_ptr<VectorSerde::Options> getVectorSerdeOptions(
-    const core::QueryConfig& queryConfig,
-    VectorSerde::Kind kind) {
-  std::unique_ptr<VectorSerde::Options> options =
-      kind == VectorSerde::Kind::kPresto
-      ? std::make_unique<serializer::presto::PrestoVectorSerde::PrestoOptions>()
-      : std::make_unique<VectorSerde::Options>();
-  options->compressionKind =
-      common::stringToCompressionKind(queryConfig.shuffleCompressionKind());
-  options->minCompressionRatio = PartitionedOutput::minCompressionRatio();
-  return options;
-}
-} // namespace
 
 namespace detail {
 Destination::Destination(
@@ -88,21 +76,17 @@ BlockingReason Destination::advance(
   }
 
   // Serialize
-  if (current_ == nullptr) {
-    current_ = std::make_unique<VectorStreamGroup>(pool_, serde_);
-    const auto rowType = asRowType(output->type());
-    current_->createStreamTree(rowType, rowsInCurrent_, serdeOptions_);
-  }
+  createVectorStreamGroup(output);
 
   const auto rows = folly::Range(&rows_[firstRow], rowIdx_ - firstRow);
-  if (serde_->kind() == VectorSerde::Kind::kCompactRow) {
+  if (serde_->kind() == "CompactRow") {
     VELOX_CHECK_NOT_NULL(outputCompactRow);
     current_->append(*outputCompactRow, rows, sizes);
-  } else if (serde_->kind() == VectorSerde::Kind::kUnsafeRow) {
+  } else if (serde_->kind() == "UnsafeRow") {
     VELOX_CHECK_NOT_NULL(outputUnsafeRow);
     current_->append(*outputUnsafeRow, rows, sizes);
   } else {
-    VELOX_CHECK_EQ(serde_->kind(), VectorSerde::Kind::kPresto);
+    VELOX_CHECK_EQ(serde_->kind(), "Presto");
     current_->append(output, rows, scratch);
   }
 
@@ -116,6 +100,26 @@ BlockingReason Destination::advance(
   return BlockingReason::kNotBlocked;
 }
 
+void Destination::createVectorStreamGroup(const RowVectorPtr& output) {
+  if (current_ == nullptr || needsStreamTreeRecreation_) {
+    if (current_ == nullptr) {
+      current_ = std::make_unique<VectorStreamGroup>(pool_, serde_);
+    }
+    const auto rowType = asRowType(output->type());
+    current_->createStreamTree(rowType, rowsInCurrent_, serdeOptions_);
+    needsStreamTreeRecreation_ = false;
+  }
+}
+
+void Destination::clearVectorStreamGroup() {
+  current_->clear();
+  // Signal that createStreamTree() must be called before the next append
+  // to properly reinitialize the serializer with a fresh stream tree.
+  // This fixes a crash where the serializer was in an invalid state after
+  // clear() due to stale references to freed StreamArena memory.
+  needsStreamTreeRecreation_ = true;
+}
+
 BlockingReason Destination::flush(
     OutputBufferManager& bufferManager,
     const std::function<void()>& bufferReleaseFn,
@@ -134,7 +138,20 @@ BlockingReason Destination::flush(
   const int64_t flushedRows = rowsInCurrent_;
 
   current_->flush(&stream);
-  current_->clear();
+
+  // Accumulate stats from the current serializer BEFORE clear() to preserve
+  // compression metrics across flushes.
+  const auto currentStats = current_->runtimeStats();
+  for (const auto& [name, counter] : currentStats) {
+    auto it = accumulatedStats_.find(name);
+    if (it != accumulatedStats_.end()) {
+      it->second.value += counter.value;
+    } else {
+      accumulatedStats_.emplace(name, counter);
+    }
+  }
+
+  clearVectorStreamGroup();
 
   const int64_t flushedBytes = stream.tellp();
 
@@ -145,7 +162,7 @@ BlockingReason Destination::flush(
   bool blocked = bufferManager.enqueue(
       taskId_,
       destination_,
-      std::make_unique<SerializedPage>(
+      std::make_unique<PrestoSerializedPage>(
           stream.getIOBuf(bufferReleaseFn), nullptr, flushedRows),
       future);
 
@@ -157,11 +174,18 @@ BlockingReason Destination::flush(
 
 void Destination::updateStats(Operator* op) {
   VELOX_CHECK(finished_);
+  auto lockedStats = op->stats().wlock();
+
+  // First add accumulated stats from previous serialization cycles.
+  for (const auto& [name, counter] : accumulatedStats_) {
+    lockedStats->addRuntimeStat(name, counter);
+  }
+
+  // Then add stats from the current serializer (if any).
   if (current_) {
     const auto serializerStats = current_->runtimeStats();
-    auto lockedStats = op->stats().wlock();
-    for (auto& pair : serializerStats) {
-      lockedStats->addRuntimeStat(pair.first, pair.second);
+    for (const auto& [name, counter] : serializerStats) {
+      lockedStats->addRuntimeStat(name, counter);
     }
   }
 }
@@ -178,7 +202,7 @@ PartitionedOutput::PartitionedOutput(
           planNode->outputType(),
           operatorId,
           planNode->id(),
-          "PartitionedOutput"),
+          OperatorType::kPartitionedOutput),
       keyChannels_(toChannels(planNode->inputType(), planNode->keys())),
       numDestinations_(planNode->numPartitions()),
       replicateNullsAndAny_(planNode->isReplicateNullsAndAny()),
@@ -200,11 +224,19 @@ PartitionedOutput::PartitionedOutput(
       maxBufferedBytes_(ctx->task->queryCtx()
                             ->queryConfig()
                             .maxPartitionedOutputBufferSize()),
-      eagerFlush_(eagerFlush),
+      eagerFlush_(
+          eagerFlush ||
+          ctx->task->queryCtx()->queryConfig().partitionedOutputEagerFlush()),
       serde_(getNamedVectorSerde(planNode->serdeKind())),
       serdeOptions_(getVectorSerdeOptions(
-          operatorCtx_->driverCtx()->queryConfig(),
-          planNode->serdeKind())) {
+          common::stringToCompressionKind(operatorCtx_->driverCtx()
+                                              ->queryConfig()
+                                              .shuffleCompressionKind()),
+          planNode->serdeKind(),
+          PartitionedOutput::minCompressionRatio(),
+          operatorCtx_->driverCtx()
+              ->queryConfig()
+              .minShuffleCompressionPageSizeBytes())) {
   if (!planNode->isPartitioned()) {
     VELOX_USER_CHECK_EQ(numDestinations_, 1);
   }
@@ -245,9 +277,9 @@ void PartitionedOutput::initializeInput(RowVectorPtr input) {
     output_->childAt(i)->loadedVector();
   }
 
-  if (serde_->kind() == VectorSerde::Kind::kCompactRow) {
+  if (serde_->kind() == "CompactRow") {
     outputCompactRow_ = std::make_unique<row::CompactRow>(output_);
-  } else if (serde_->kind() == VectorSerde::Kind::kUnsafeRow) {
+  } else if (serde_->kind() == "UnsafeRow") {
     outputUnsafeRow_ = std::make_unique<row::UnsafeRowFast>(output_);
   }
 }
@@ -256,17 +288,18 @@ void PartitionedOutput::initializeDestinations() {
   if (destinations_.empty()) {
     auto taskId = operatorCtx_->taskId();
     for (int i = 0; i < numDestinations_; ++i) {
-      destinations_.push_back(std::make_unique<detail::Destination>(
-          taskId,
-          i,
-          serde_,
-          serdeOptions_.get(),
-          pool(),
-          eagerFlush_,
-          [&](uint64_t bytes, uint64_t rows) {
-            auto lockedStats = stats_.wlock();
-            lockedStats->addOutputVector(bytes, rows);
-          }));
+      destinations_.push_back(
+          std::make_unique<detail::Destination>(
+              taskId,
+              i,
+              serde_,
+              serdeOptions_.get(),
+              pool(),
+              eagerFlush_,
+              [&](uint64_t bytes, uint64_t rows) {
+                auto lockedStats = stats_.wlock();
+                lockedStats->addOutputVector(bytes, rows);
+              }));
     }
   }
 }
@@ -289,16 +322,16 @@ void PartitionedOutput::estimateRowSizes() {
   raw_vector<vector_size_t> storage(pool());
   const auto numbers = iota(numInput, storage);
   const auto rows = folly::Range(numbers, numInput);
-  if (serde_->kind() == VectorSerde::Kind::kCompactRow) {
+  if (serde_->kind() == "CompactRow") {
     VELOX_CHECK_NOT_NULL(outputCompactRow_);
     serde_->estimateSerializedSize(
         outputCompactRow_.get(), rows, sizePointers_.data());
-  } else if (serde_->kind() == VectorSerde::Kind::kUnsafeRow) {
+  } else if (serde_->kind() == "UnsafeRow") {
     VELOX_CHECK_NOT_NULL(outputUnsafeRow_);
     serde_->estimateSerializedSize(
         outputUnsafeRow_.get(), rows, sizePointers_.data());
   } else {
-    VELOX_CHECK_EQ(serde_->kind(), VectorSerde::Kind::kPresto);
+    VELOX_CHECK_EQ(serde_->kind(), "Presto");
     serde_->estimateSerializedSize(
         output_.get(), rows, sizePointers_.data(), scratch_);
   }
@@ -481,7 +514,8 @@ void PartitionedOutput::close() {
     auto lockedStats = stats_.wlock();
     lockedStats->addRuntimeStat(
         Operator::kShuffleSerdeKind,
-        RuntimeCounter(static_cast<int64_t>(serde_->kind())));
+        RuntimeCounter(
+            static_cast<int64_t>(VectorSerde::kindByName(serde_->kind()))));
     lockedStats->addRuntimeStat(
         Operator::kShuffleCompressionKind,
         RuntimeCounter(static_cast<int64_t>(serdeOptions_->compressionKind)));
diff --git a/velox/exec/PartitionedOutput.h b/velox/exec/PartitionedOutput.h
index 5a1c44cf0b1..dd8c68e8b9e 100644
--- a/velox/exec/PartitionedOutput.h
+++ b/velox/exec/PartitionedOutput.h
@@ -102,6 +102,15 @@ class Destination {
     targetNumRows_ = (10'000 * targetSizePct_) / 100;
   }
 
+  // Creates VectorStreamGroup if needed. May recreate the stream tree
+  // after flush() to reinitialize the serializer.
+  void createVectorStreamGroup(const RowVectorPtr& output);
+
+  // Clears the VectorStreamGroup and marks it for recreation.
+  // This ensures the serializer is properly reinitialized before the next
+  // append to avoid crashes from stale references to freed StreamArena memory.
+  void clearVectorStreamGroup();
+
   const std::string taskId_;
   const int destination_;
   VectorSerde* const serde_;
@@ -122,6 +131,16 @@ class Destination {
   // The current stream where the input is serialized to. This is cleared on
   // every flush() call.
   std::unique_ptr<VectorStreamGroup> current_;
+
+  // Whether the stream tree needs to be recreated. Set after flush() to ensure
+  // proper initialization of the serializer before the next append.
+  bool needsStreamTreeRecreation_{false};
+
+  // Accumulated runtime stats from previous serialization cycles. Stats are
+  // collected before recreating the stream tree to avoid losing compression
+  // metrics from earlier flushes.
+  std::unordered_map<std::string, RuntimeCounter> accumulatedStats_;
+
   bool finished_{false};
 
   // Flush accumulated data to buffer manager after reaching this
diff --git a/velox/exec/PlanNodeStats.cpp b/velox/exec/PlanNodeStats.cpp
index ed3414fed7d..76c47b3db39 100644
--- a/velox/exec/PlanNodeStats.cpp
+++ b/velox/exec/PlanNodeStats.cpp
@@ -59,6 +59,14 @@ PlanNodeStats& PlanNodeStats::operator+=(const PlanNodeStats& another) {
     }
   }
 
+  for (const auto& [name, exprStats] : another.expressionStats) {
+    auto const [it, inserted] =
+        this->expressionStats.try_emplace(name, exprStats);
+    if (!inserted) {
+      it->second.add(exprStats);
+    }
+  }
+
   // Populating number of drivers for plan nodes with multiple operators is not
   // useful. Each operator could have been executed in different pipelines with
   // different number of drivers.
diff --git a/velox/exec/PrefixSort.cpp b/velox/exec/PrefixSort.cpp
index 45bafec927e..6578429a02e 100644
--- a/velox/exec/PrefixSort.cpp
+++ b/velox/exec/PrefixSort.cpp
@@ -101,7 +101,7 @@ FOLLY_ALWAYS_INLINE void extractRowColumnToPrefix(
     default:
       VELOX_UNSUPPORTED(
           "prefix-sort does not support type kind: {}",
-          mapTypeKindToName(typeKind));
+          TypeKindName::toName(typeKind));
   }
 }
 
@@ -310,7 +310,7 @@ void PrefixSort::extractRowAndEncodePrefixKeys(char* row, char* prefixBuffer) {
 }
 
 // static.
-uint32_t PrefixSort::maxRequiredBytes(
+uint64_t PrefixSort::maxRequiredBytes(
     const RowContainer* rowContainer,
     const std::vector<CompareFlags>& compareFlags,
     const velox::common::PrefixSortConfig& config,
@@ -345,14 +345,15 @@ void PrefixSort::stdSort(
       });
 }
 
-uint32_t PrefixSort::maxRequiredBytes() const {
+uint64_t PrefixSort::maxRequiredBytes() const {
   const auto numRows = rowContainer_->numRows();
   const auto numPages =
       memory::AllocationTraits::numPages(numRows * sortLayout_.entrySize);
   // Prefix data size + swap buffer size.
   return memory::AllocationTraits::pageBytes(numPages) +
-      pool_->preferredSize(checkedPlus<size_t>(
-          sortLayout_.entrySize, AlignedBuffer::kPaddedSize)) +
+      pool_->preferredSize(
+          checkedPlus<size_t>(
+              sortLayout_.entrySize, AlignedBuffer::kPaddedSize)) +
       2 * pool_->alignment();
 }
 
diff --git a/velox/exec/PrefixSort.h b/velox/exec/PrefixSort.h
index 3d1fa46c2a5..e36c3588413 100644
--- a/velox/exec/PrefixSort.h
+++ b/velox/exec/PrefixSort.h
@@ -153,7 +153,7 @@ class PrefixSort {
   /// The std::sort won't require bytes while prefix sort may require buffers
   /// such as prefix data. The logic is similar to the above function
   /// PrefixSort::sort but returns the maximum buffer the sort may need.
-  static uint32_t maxRequiredBytes(
+  static uint64_t maxRequiredBytes(
       const RowContainer* rowContainer,
       const std::vector<CompareFlags>& compareFlags,
       const velox::common::PrefixSortConfig& config,
@@ -161,7 +161,7 @@ class PrefixSort {
 
   /// The runtime stats name collected for prefix sort.
   /// The number of prefix sort keys.
-  static inline const std::string kNumPrefixSortKeys{"numPrefixSortKeys"};
+  static constexpr std::string_view kNumPrefixSortKeys{"numPrefixSortKeys"};
 
  private:
   /// Fallback to stdSort when prefix sort conditions such as config and memory
@@ -205,7 +205,7 @@ class PrefixSort {
 
   // Estimates the memory required for prefix sort such as prefix buffer and
   // swap buffer.
-  uint32_t maxRequiredBytes() const;
+  uint64_t maxRequiredBytes() const;
 
   void sortInternal(std::vector<char*, memory::StlAllocator<char*>>& rows);
 
diff --git a/velox/exec/RowContainer.cpp b/velox/exec/RowContainer.cpp
index cbf28e6c67a..5a3e8e291e0 100644
--- a/velox/exec/RowContainer.cpp
+++ b/velox/exec/RowContainer.cpp
@@ -42,8 +42,7 @@ static int32_t typeKindSize(TypeKind kind) {
 __attribute__((__no_sanitize__("thread")))
 #endif
 #endif
-inline void
-setBit(char* bits, uint32_t idx) {
+inline void setBit(char* bits, uint32_t idx) {
   auto bitsAs8Bit = reinterpret_cast<uint8_t*>(bits);
   bitsAs8Bit[idx / 8] |= (1 << (idx % 8));
 }
@@ -136,15 +135,19 @@ RowContainer::RowContainer(
     bool hasNext,
     bool isJoinBuild,
     bool hasProbedFlag,
+    bool hasCountFlag,
     bool hasNormalizedKeys,
+    bool useListRowIndex,
     memory::MemoryPool* pool)
     : keyTypes_(keyTypes),
       nullableKeys_(nullableKeys),
       isJoinBuild_(isJoinBuild),
       hasNormalizedKeys_(hasNormalizedKeys),
+      useListRowIndex_(useListRowIndex),
       stringAllocator_(std::make_unique<HashStringAllocator>(pool)),
       accumulators_(accumulators),
-      rows_(pool) {
+      rows_(pool),
+      rowPointers_(StlAllocator<char*>(stringAllocator_.get())) {
   // Compute the layout of the payload row.  The row has keys, null flags,
   // accumulators, dependent fields. All fields are fixed width. If variable
   // width data is referenced, this is done with StringView(for VARCHAR) and
@@ -245,6 +248,10 @@ RowContainer::RowContainer(
     nextOffset_ = offset;
     offset += sizeof(void*);
   }
+  if (hasCountFlag) {
+    countOffset_ = offset;
+    offset += sizeof(int32_t);
+  }
   fixedRowSize_ = bits::roundUp(offset, alignment_);
   originalNormalizedKeySize_ = hasNormalizedKeys_
       ? bits::roundUp(sizeof(normalized_key_t), alignment_)
@@ -280,6 +287,10 @@ char* RowContainer::newRow() {
     if (normalizedKeySize_) {
       ++numRowsWithNormalizedKey_;
     }
+
+    if (useListRowIndex_) {
+      rowPointers_.push_back(row);
+    }
   }
   return initializeRow(row, false /* reuse */);
 }
@@ -314,6 +325,9 @@ char* RowContainer::initializeRow(char* row, bool reuse) {
     variableRowSize(row) = 0;
   }
   bits::clearBit(row, freeFlagOffset_);
+  if (countOffset_) {
+    countRef(row) = 1;
+  }
   return row;
 }
 
@@ -587,7 +601,7 @@ int32_t RowContainer::variableSizeAt(const char* row, column_index_t column)
   }
 
   const auto typeKind = typeKinds_[column];
-  if (typeKind == TypeKind::VARCHAR || typeKind == TypeKind::VARBINARY) {
+  if (is_string_kind(typeKind)) {
     return reinterpret_cast<const StringView*>(row + rowColumn.offset())
         ->size();
   } else {
@@ -613,7 +627,7 @@ int32_t RowContainer::extractVariableSizeAt(
   }
 
   const auto typeKind = typeKinds_[column];
-  if (typeKind == TypeKind::VARCHAR || typeKind == TypeKind::VARBINARY) {
+  if (is_string_kind(typeKind)) {
     const auto value = valueAt<StringView>(row, rowColumn.offset());
     const auto size = value.size();
     ::memcpy(output, &size, 4);
@@ -651,7 +665,7 @@ int32_t RowContainer::storeVariableSizeAt(
   // First 4 bytes is the size of the data.
   const auto size = *reinterpret_cast<const int32_t*>(data);
 
-  if (typeKind == TypeKind::VARCHAR || typeKind == TypeKind::VARBINARY) {
+  if (is_string_kind(typeKind)) {
     if (size > 0) {
       stringAllocator_->copyMultipart(
           StringView(data + 4, size), row, rowColumn.offset());
@@ -889,13 +903,11 @@ void RowContainer::hashTyped(
                       : BaseVector::kNullHash;
     } else {
       uint64_t hash;
-      if constexpr (Kind == TypeKind::VARCHAR || Kind == TypeKind::VARBINARY) {
+      if constexpr (is_string_kind(Kind)) {
         hash =
             folly::hasher<StringView>()(HashStringAllocator::contiguousString(
                 valueAt<StringView>(row, offset), storage));
-      } else if constexpr (
-          Kind == TypeKind::ROW || Kind == TypeKind::ARRAY ||
-          Kind == TypeKind::MAP) {
+      } else if constexpr (is_nested_kind(Kind)) {
         auto in = prepareRead(row, offset);
         hash = ContainerRowSerde::hash(in, type);
       } else if constexpr (typeProvidesCustomComparison) {
@@ -965,6 +977,8 @@ void RowContainer::clear() {
   hasDuplicateRows_ = false;
 
   rows_.clear();
+  rowPointers_.clear();
+  rowPointers_.shrink_to_fit();
   stringAllocator_->clear();
   numRows_ = 0;
   numRowsWithNormalizedKey_ = 0;
@@ -1026,7 +1040,8 @@ std::optional<int64_t> RowContainer::estimateRowSize() const {
   }
   int64_t freeBytes = rows_.freeBytes() + fixedRowSize_ * numFreeRows_;
   int64_t usedSize = rows_.allocatedBytes() - freeBytes +
-      stringAllocator_->retainedSize() - stringAllocator_->freeSpace();
+      stringAllocator_->retainedSize() - stringAllocator_->freeSpace() -
+      rowPointers_.capacity() * sizeof(char*);
   int64_t rowSize = usedSize / numRows_;
   VELOX_CHECK_GT(
       rowSize, 0, "Estimated row size of the RowContainer must be positive.");
diff --git a/velox/exec/RowContainer.h b/velox/exec/RowContainer.h
index 03166af6482..acdfb3ee608 100644
--- a/velox/exec/RowContainer.h
+++ b/velox/exec/RowContainer.h
@@ -83,6 +83,8 @@ struct RowContainerIterator {
   char* rowBegin{nullptr};
   /// First byte after the end of the range containing 'currentRow'.
   char* endOfRun{nullptr};
+  /// Cursor of the list row operation.
+  int32_t listRowCursor{0};
 
   /// Returns the current row, skipping a possible normalized key below the
   /// first byte of row.
@@ -118,6 +120,10 @@ class RowPartitions {
     return size_;
   }
 
+  void reset() {
+    size_ = 0;
+  }
+
  private:
   const int32_t capacity_;
 
@@ -273,6 +279,21 @@ class RowContainer {
       const std::vector<TypePtr>& keyTypes,
       const std::vector<TypePtr>& dependentTypes,
       memory::MemoryPool* pool)
+      : RowContainer(
+            keyTypes,
+            dependentTypes,
+            /*useListRowIndex=*/false,
+            pool) {}
+
+  /// If 'useListRowIndex' is true, the container maintains an internal array of
+  /// row pointers so that listRowsFast() can return rows without scanning
+  /// underlying allocations or checking free/probe flags. It is intended to be
+  /// used in SortBuffer and SortInputSpiller to improve performance.
+  RowContainer(
+      const std::vector<TypePtr>& keyTypes,
+      const std::vector<TypePtr>& dependentTypes,
+      bool useListRowIndex,
+      memory::MemoryPool* pool)
       : RowContainer(
             keyTypes,
             true, // nullableKeys
@@ -281,7 +302,9 @@ class RowContainer {
             false, // hasNext
             false, // isJoinBuild
             false, // hasProbedFlag
+            false, // hasCountFlag
             false, // hasNormalizedKey
+            useListRowIndex,
             pool) {}
 
   ~RowContainer();
@@ -312,7 +335,9 @@ class RowContainer {
       bool hasNext,
       bool isJoinBuild,
       bool hasProbedFlag,
+      bool hasCountFlag,
       bool hasNormalizedKey,
+      bool useListRowIndex,
       memory::MemoryPool* pool);
 
   /// Allocates a new row and initializes possible aggregates to null.
@@ -573,8 +598,7 @@ class RowContainer {
   __attribute__((__no_sanitize__("thread")))
 #endif
 #endif
-  int32_t
-  listRows(
+  int32_t listRows(
       RowContainerIterator* iter,
       int32_t maxRows,
       uint64_t maxBytes,
@@ -638,6 +662,20 @@ class RowContainer {
     return count;
   }
 
+  /// Fast path for `listRows` that returns `rowPointers_` directly. Used by
+  /// `SortBuffer` and `SortInputSpiller`, so it skips checking the free and
+  /// probe flags.
+  int32_t listRowsFast(RowContainerIterator* iter, int32_t maxRows, char** rows)
+      const {
+    int32_t count = 0;
+    while (count < maxRows && iter->listRowCursor < rowPointers_.size()) {
+      char* row = rowPointers_[iter->listRowCursor];
+      rows[count++] = row;
+      ++iter->listRowCursor;
+    }
+    return count;
+  }
+
   /// Extracts up to 'maxRows' rows starting at the position of 'iter'. A
   /// default constructed or reset iter starts at the beginning. Returns the
   /// number of rows written to 'rows'. Returns 0 when at end. Stops after the
@@ -652,6 +690,9 @@ class RowContainer {
 
   int32_t listRows(RowContainerIterator* iter, int32_t maxRows, char** rows)
       const {
+    if (useListRowIndex_) {
+      return listRowsFast(iter, maxRows, rows);
+    }
     return listRows<ProbeType::kAll>(iter, maxRows, kUnlimited, rows);
   }
 
@@ -668,21 +709,13 @@ class RowContainer {
   __attribute__((__no_sanitize__("thread")))
 #endif
 #endif
-  void
-  setProbedFlag(char** rows, int32_t numRows);
-
-  /// Returns true if 'row' at 'column' equals the value at 'index' in
-  /// 'decoded'. 'mayHaveNulls' specifies if nulls need to be checked. This is a
-  /// fast path for compare().
-  template <bool mayHaveNulls>
-  bool equals(
-      const char* row,
-      RowColumn column,
-      const DecodedVector& decoded,
-      vector_size_t index) const;
+  void setProbedFlag(char** rows, int32_t numRows);
 
   /// Compares the value at 'column' in 'row' with the value at 'index' in
   /// 'decoded'. Returns 0 for equal, < 0 for 'row' < 'decoded', > 0 otherwise.
+  /// 'mayHaveNulls' specifies if nulls need to be checked. This is a fast path
+  /// for compare().
+  template <bool mayHaveNulls = true>
   int32_t compare(
       const char* row,
       RowColumn column,
@@ -735,6 +768,38 @@ class RowContainer {
     return probedFlagOffset_;
   }
 
+  /// Byte offset of the per-row count for counting joins. 0 if not applicable.
+  int32_t countOffset() const {
+    return countOffset_;
+  }
+
+  /// Returns the count stored at the given row. Used for counting joins.
+  int32_t count(const char* row) const {
+    VELOX_DCHECK_NE(countOffset_, 0);
+    return countRef(const_cast<char*>(row));
+  }
+
+  /// Increments the count at the given row. Used during hash table build for
+  /// counting joins.
+  void incrementCount(char* row) const {
+    VELOX_DCHECK_NE(countOffset_, 0);
+    ++countRef(row);
+  }
+
+  /// Decrements the count at the given row. Used during hash table probe for
+  /// counting joins.
+  void decrementCount(char* row) const {
+    VELOX_DCHECK_NE(countOffset_, 0);
+    --countRef(row);
+  }
+
+  /// Adds 'n' to the count at the given row. Used during hash table merge
+  /// to combine counts from multiple build-side tables.
+  void addCount(char* row, int32_t n) const {
+    VELOX_DCHECK_NE(countOffset_, 0);
+    countRef(row) += n;
+  }
+
   /// Returns the offset of a uint32_t row size or 0 if the row has no variable
   /// width fields or accumulators.
   int32_t rowSizeOffset() const {
@@ -800,6 +865,10 @@ class RowContainer {
     return 0;
   }
 
+  const std::vector<char*, StlAllocator<char*>>& testingRowPointers() const {
+    return rowPointers_;
+  }
+
   memory::MemoryPool* pool() const {
     return stringAllocator_->pool();
   }
@@ -1167,56 +1236,29 @@ class RowContainer {
       bool mix,
       uint64_t* result) const;
 
-  template <bool typeProvidesCustomComparison, TypeKind Kind>
-  inline bool equalsWithNulls(
-      const char* row,
-      int32_t offset,
-      int32_t nullByte,
-      uint8_t nullMask,
-      const DecodedVector& decoded,
-      vector_size_t index) const {
-    bool rowIsNull = isNullAt(row, nullByte, nullMask);
-    bool indexIsNull = decoded.isNullAt(index);
-    if (rowIsNull || indexIsNull) {
-      return rowIsNull == indexIsNull;
-    }
-
-    return equalsNoNulls<typeProvidesCustomComparison, Kind>(
-        row, offset, decoded, index);
-  }
-
-  template <bool typeProvidesCustomComparison, TypeKind Kind>
-  inline bool equalsNoNulls(
+  template <bool mayHaveNulls, TypeKind Kind>
+  inline int compare(
       const char* row,
-      int32_t offset,
+      RowColumn column,
       const DecodedVector& decoded,
-      vector_size_t index) const {
-    using T = typename KindToFlatVector<Kind>::HashRowType;
-
-    if constexpr (
-        Kind == TypeKind::ROW || Kind == TypeKind::ARRAY ||
-        Kind == TypeKind::MAP) {
-      return compareComplexType(row, offset, decoded, index) == 0;
-    } else if constexpr (
-        Kind == TypeKind::VARCHAR || Kind == TypeKind::VARBINARY) {
-      return compareStringAsc(
-                 valueAt<StringView>(row, offset), decoded, index) == 0;
-    } else if constexpr (typeProvidesCustomComparison) {
-      return SimpleVector<T>::template comparePrimitiveAscWithCustomComparison<
-                 Kind>(
-                 decoded.base()->type().get(),
-                 decoded.valueAt<T>(index),
-                 valueAt<T>(row, offset)) == 0;
+      vector_size_t index,
+      CompareFlags flags) const {
+    if (decoded.base()->typeUsesCustomComparison()) {
+      return compare<true, Kind, mayHaveNulls>(
+          row, column, decoded, index, flags);
     } else {
-      return SimpleVector<T>::comparePrimitiveAsc(
-                 decoded.valueAt<T>(index), valueAt<T>(row, offset)) == 0;
+      return compare<false, Kind, mayHaveNulls>(
+          row, column, decoded, index, flags);
     }
   }
 
   template <
       bool typeProvidesCustomComparison,
       TypeKind Kind,
-      std::enable_if_t<Kind != TypeKind::OPAQUE, int32_t> = 0>
+      bool mayHaveNulls,
+      std::enable_if_t<
+          Kind != TypeKind::OPAQUE && Kind != TypeKind::UNKNOWN,
+          int32_t> = 0>
   inline int compare(
       const char* row,
       RowColumn column,
@@ -1224,20 +1266,23 @@ class RowContainer {
       vector_size_t index,
       CompareFlags flags) const {
     using T = typename KindToFlatVector<Kind>::HashRowType;
-    bool rowIsNull = isNullAt(row, column.nullByte(), column.nullMask());
-    bool indexIsNull = decoded.isNullAt(index);
-    if (rowIsNull) {
-      return indexIsNull ? 0 : flags.nullsFirst ? -1 : 1;
-    }
-    if (indexIsNull) {
-      return flags.nullsFirst ? 1 : -1;
+
+    if constexpr (mayHaveNulls) {
+      bool rowIsNull = isNullAt(row, column.nullByte(), column.nullMask());
+      bool indexIsNull = decoded.isNullAt(index);
+      if (rowIsNull) {
+        return indexIsNull ? 0 : flags.nullsFirst ? -1 : 1;
+      }
+      if (indexIsNull) {
+        return flags.nullsFirst ? 1 : -1;
+      }
     }
+
     if constexpr (
         Kind == TypeKind::ROW || Kind == TypeKind::ARRAY ||
         Kind == TypeKind::MAP) {
       return compareComplexType(row, column.offset(), decoded, index, flags);
-    } else if constexpr (
-        Kind == TypeKind::VARCHAR || Kind == TypeKind::VARBINARY) {
+    } else if constexpr (is_string_kind(Kind)) {
       auto result = compareStringAsc(
           valueAt<StringView>(row, column.offset()), decoded, index);
       return flags.ascending ? result : result * -1;
@@ -1261,6 +1306,22 @@ class RowContainer {
   template <
       bool typeProvidesCustomComparison,
       TypeKind Kind,
+      bool mayHaveNulls,
+      std::enable_if_t<Kind == TypeKind::UNKNOWN, int32_t> = 0>
+  inline int compare(
+      const char* row,
+      RowColumn column,
+      const DecodedVector& /*decoded*/,
+      vector_size_t /*index*/,
+      CompareFlags flags) const {
+    const bool rowIsNull = isNullAt(row, column.nullByte(), column.nullMask());
+    return rowIsNull ? 0 : flags.nullsFirst ? 1 : -1;
+  }
+
+  template <
+      bool typeProvidesCustomComparison,
+      TypeKind Kind,
+      bool mayHaveNulls,
       std::enable_if_t<Kind == TypeKind::OPAQUE, int32_t> = 0>
   inline int compare(
       const char* /*row*/,
@@ -1301,8 +1362,7 @@ class RowContainer {
         Kind == TypeKind::MAP) {
       return compareComplexType(
           left, right, type, leftOffset, rightOffset, flags);
-    } else if constexpr (
-        Kind == TypeKind::VARCHAR || Kind == TypeKind::VARBINARY) {
+    } else if constexpr (is_string_kind(Kind)) {
       auto leftValue = valueAt<StringView>(left, leftOffset);
       auto rightValue = valueAt<StringView>(right, rightOffset);
       auto result = compareStringAsc(leftValue, rightValue);
@@ -1482,12 +1542,17 @@ class RowContainer {
     }
   }
 
+  int32_t& countRef(char* row) const {
+    return *reinterpret_cast<int32_t*>(row + countOffset_);
+  }
+
   const std::vector<TypePtr> keyTypes_;
   const bool nullableKeys_;
   const bool isJoinBuild_;
   // True if normalized keys are enabled in initial state.
   const bool hasNormalizedKeys_;
-
+  // True if use 'listRowsFast'.
+  const bool useListRowIndex_;
   const std::unique_ptr<HashStringAllocator> stringAllocator_;
 
   // Indicates if we can add new row to this row container. It is set to false
@@ -1521,6 +1586,9 @@ class RowContainer {
   // not applicable.
   int32_t probedFlagOffset_ = 0;
 
+  // Byte offset of the per-row count for counting joins. 0 if not applicable.
+  int32_t countOffset_ = 0;
+
   // Bit position of free bit.
   int32_t freeFlagOffset_ = 0;
   int32_t rowSizeOffset_ = 0;
@@ -1543,6 +1611,7 @@ class RowContainer {
   uint64_t numFreeRows_ = 0;
 
   memory::AllocationPool rows_;
+  std::vector<char*, StlAllocator<char*>> rowPointers_;
 
   int alignment_ = 1;
 
@@ -1730,60 +1799,21 @@ inline void RowContainer::extractNulls(
 }
 
 template <bool mayHaveNulls>
-inline bool RowContainer::equals(
-    const char* row,
-    RowColumn column,
-    const DecodedVector& decoded,
-    vector_size_t index) const {
-  auto typeKind = decoded.base()->typeKind();
-  if (typeKind == TypeKind::UNKNOWN) {
-    return isNullAt(row, column.nullByte(), column.nullMask());
-  }
-
-  if constexpr (!mayHaveNulls) {
-    return VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH(
-        equalsNoNulls, false, typeKind, row, column.offset(), decoded, index);
-  } else {
-    return VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH(
-        equalsWithNulls,
-        false,
-        typeKind,
-        row,
-        column.offset(),
-        column.nullByte(),
-        column.nullMask(),
-        decoded,
-        index);
-  }
-}
-
 inline int RowContainer::compare(
     const char* row,
     RowColumn column,
     const DecodedVector& decoded,
     vector_size_t index,
     CompareFlags flags) const {
-  if (decoded.base()->typeUsesCustomComparison()) {
-    return VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH_ALL(
-        compare,
-        true,
-        decoded.base()->typeKind(),
-        row,
-        column,
-        decoded,
-        index,
-        flags);
-  } else {
-    return VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH_ALL(
-        compare,
-        false,
-        decoded.base()->typeKind(),
-        row,
-        column,
-        decoded,
-        index,
-        flags);
-  }
+  return VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH_ALL(
+      compare,
+      mayHaveNulls,
+      decoded.base()->typeKind(),
+      row,
+      column,
+      decoded,
+      index,
+      flags);
 }
 
 inline int RowContainer::compare(
diff --git a/velox/exec/RowNumber.cpp b/velox/exec/RowNumber.cpp
index e57424da59d..cd2cd4ce36a 100644
--- a/velox/exec/RowNumber.cpp
+++ b/velox/exec/RowNumber.cpp
@@ -15,6 +15,7 @@
  */
 #include "velox/exec/RowNumber.h"
 #include "velox/common/memory/MemoryArbitrator.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/OperatorUtils.h"
 
 namespace facebook::velox::exec {
@@ -28,9 +29,9 @@ RowNumber::RowNumber(
           rowNumberNode->outputType(),
           operatorId,
           rowNumberNode->id(),
-          "RowNumber",
+          OperatorType::kRowNumber,
           rowNumberNode->canSpill(driverCtx->queryConfig())
-              ? driverCtx->makeSpillConfig(operatorId)
+              ? driverCtx->makeSpillConfig(operatorId, OperatorType::kRowNumber)
               : std::nullopt),
       limit_{rowNumberNode->limit()},
       generateRowNumber_{rowNumberNode->generateRowNumber()} {
@@ -46,6 +47,7 @@ RowNumber::RowNumber(
         false, // allowDuplicates
         false, // isJoinBuild
         false, // hasProbedFlag
+        false, // hasCountFlag
         0, // minTableSizeForParallelJoinBuild
         pool());
     lookup_ = std::make_unique<HashLookup>(table_->hashers(), pool());
@@ -239,8 +241,11 @@ void RowNumber::ensureInputFits(const RowVectorPtr& input) {
 
   LOG(WARNING) << "Failed to reserve " << succinctBytes(targetIncrementBytes)
                << " for memory pool " << pool()->name()
-               << ", usage: " << succinctBytes(pool()->usedBytes())
-               << ", reservation: " << succinctBytes(pool()->reservedBytes());
+               << ", root pool: " << pool()->root()->name()
+               << ", used: " << succinctBytes(pool()->usedBytes())
+               << ", reservation: " << succinctBytes(pool()->reservedBytes())
+               << ", root pool reservation: "
+               << succinctBytes(pool()->root()->reservedBytes());
 }
 
 FlatVector<int64_t>& RowNumber::getOrCreateRowNumberVector(vector_size_t size) {
@@ -383,12 +388,17 @@ void RowNumber::reclaim(
     return;
   }
 
-  if (exceededMaxSpillLevelLimit_) {
+  if (FOLLY_UNLIKELY(exceededMaxSpillLevelLimit_)) {
     LOG(WARNING) << "Exceeded row spill level limit: "
                  << spillConfig_->maxSpillLevel
-                 << ", and abandon spilling for memory pool: "
-                 << pool()->name();
-    ++spillStats_->wlock()->spillMaxLevelExceededCount;
+                 << ", and abandon spilling for memory pool: " << pool()->name()
+                 << ", root pool: " << pool()->root()->name()
+                 << ", used: " << succinctBytes(pool()->usedBytes())
+                 << ", reservation: " << succinctBytes(pool()->reservedBytes())
+                 << ", root pool reservation: "
+                 << succinctBytes(pool()->root()->reservedBytes());
+    spillStats_->spillMaxLevelExceededCount.fetch_add(
+        1, std::memory_order_relaxed);
     return;
   }
 
@@ -544,7 +554,7 @@ RowNumberHashTableSpiller::RowNumberHashTableSpiller(
     RowTypePtr rowType,
     HashBitRange bits,
     const common::SpillConfig* spillConfig,
-    folly::Synchronized<common::SpillStats>* spillStats)
+    exec::SpillStats* spillStats)
     : SpillerBase(
           container,
           std::move(rowType),
diff --git a/velox/exec/RowNumber.h b/velox/exec/RowNumber.h
index 255827ece03..b34fc9d9c20 100644
--- a/velox/exec/RowNumber.h
+++ b/velox/exec/RowNumber.h
@@ -161,7 +161,7 @@ class RowNumberHashTableSpiller : public SpillerBase {
       RowTypePtr rowType,
       HashBitRange bits,
       const common::SpillConfig* spillConfig,
-      folly::Synchronized<common::SpillStats>* spillStats);
+      exec::SpillStats* spillStats);
 
   void spill();
 
diff --git a/velox/exec/RowsStreamingWindowBuild.cpp b/velox/exec/RowsStreamingWindowBuild.cpp
index a3dedd8a60c..7f03a465b6c 100644
--- a/velox/exec/RowsStreamingWindowBuild.cpp
+++ b/velox/exec/RowsStreamingWindowBuild.cpp
@@ -50,8 +50,9 @@ bool RowsStreamingWindowBuild::needsInput() {
 
 void RowsStreamingWindowBuild::ensureInputPartition() {
   if (windowPartitions_.empty() || windowPartitions_.back()->complete()) {
-    windowPartitions_.emplace_back(std::make_shared<WindowPartition>(
-        data_.get(), inversedInputChannels_, sortKeyInfo_));
+    windowPartitions_.emplace_back(
+        std::make_shared<WindowPartition>(
+            data_.get(), inversedInputChannels_, sortKeyInfo_));
   }
 }
 
diff --git a/velox/exec/RowsStreamingWindowBuild.h b/velox/exec/RowsStreamingWindowBuild.h
index 065ff4c7c44..421236889e3 100644
--- a/velox/exec/RowsStreamingWindowBuild.h
+++ b/velox/exec/RowsStreamingWindowBuild.h
@@ -41,7 +41,7 @@ class RowsStreamingWindowBuild : public WindowBuild {
     VELOX_UNREACHABLE();
   }
 
-  std::optional<common::SpillStats> spilledStats() const override {
+  std::optional<exec::SpillStats> spilledStats() const override {
     return std::nullopt;
   }
 
diff --git a/velox/exec/ScaleWriterLocalPartition.cpp b/velox/exec/ScaleWriterLocalPartition.cpp
index 3b9bcf4cee3..7530ff403a0 100644
--- a/velox/exec/ScaleWriterLocalPartition.cpp
+++ b/velox/exec/ScaleWriterLocalPartition.cpp
@@ -174,28 +174,11 @@ void ScaleWriterPartitioningLocalPartition::addInput(RowVectorPtr input) {
                                              row;
     }
 
-    for (auto i = 0; i < numPartitions_; ++i) {
-      const auto writerRowCount = writerAssignmentCounts_[i];
-      if (writerRowCount == 0) {
-        continue;
-      }
-
-      auto writerInput = processPartition(
-          input,
-          writerRowCount,
-          i,
-          std::move(writerAssignmmentIndicesBuffers_[i]),
-          rawWriterAssignmmentIndicesBuffers_[i]);
-      if (writerInput != nullptr) {
-        ContinueFuture future;
-        auto reason = queues_[i]->enqueue(
-            writerInput, totalInputBytes * writerRowCount / numInput, &future);
-        if (reason != BlockingReason::kNotBlocked) {
-          blockingReasons_.push_back(reason);
-          futures_.push_back(std::move(future));
-        }
-      }
-    }
+    populateAndEnqueuePartitions(
+        input,
+        writerAssignmentCounts_,
+        writerAssignmmentIndicesBuffers_,
+        rawWriterAssignmmentIndicesBuffers_);
   }
 
   // Only update the scaling state if the memory used is below the
diff --git a/velox/exec/ScaleWriterLocalPartition.h b/velox/exec/ScaleWriterLocalPartition.h
index 3fba1e781d2..3bfd2c5467b 100644
--- a/velox/exec/ScaleWriterLocalPartition.h
+++ b/velox/exec/ScaleWriterLocalPartition.h
@@ -44,9 +44,9 @@ class ScaleWriterPartitioningLocalPartition : public LocalPartition {
 
   /// The name of the runtime stats of writer scaling.
   /// The number of times that we triggers the rebalance of table partitions.
-  static inline const std::string kRebalanceTriggers{"rebalanceTriggers"};
+  static constexpr std::string_view kRebalanceTriggers{"rebalanceTriggers"};
   /// The number of times that we scale a partition processing.
-  static inline const std::string kScaledPartitions{"scaledPartitions"};
+  static constexpr std::string_view kScaledPartitions{"scaledPartitions"};
 
  private:
   void prepareForWriterAssignments(vector_size_t numInput);
@@ -98,7 +98,7 @@ class ScaleWriterLocalPartition : public LocalPartition {
 
   /// The name of the runtime stats of writer scaling.
   /// The number of scaled writers.
-  static inline const std::string kScaledWriters{"scaledWriters"};
+  static constexpr std::string_view kScaledWriters{"scaledWriters"};
 
  private:
   // Gets the writer id to process the next input in a round-robin manner.
diff --git a/velox/exec/SerializedPage.cpp b/velox/exec/SerializedPage.cpp
new file mode 100644
index 00000000000..62ab77218c9
--- /dev/null
+++ b/velox/exec/SerializedPage.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/exec/SerializedPage.h"
+
+#include <utility>
+
+namespace facebook::velox::exec {
+
+PrestoSerializedPage::PrestoSerializedPage(
+    std::unique_ptr<folly::IOBuf> iobuf,
+    std::function<void(folly::IOBuf&)> onDestructionCb,
+    std::optional<int64_t> numRows)
+    : iobuf_(std::move(iobuf)),
+      iobufBytes_(chainBytes(*iobuf_.get())),
+      numRows_(numRows),
+      onDestructionCb_(std::move(onDestructionCb)) {
+  VELOX_CHECK_NOT_NULL(iobuf_);
+  for (auto& buf : *iobuf_) {
+    int32_t bufSize = buf.size();
+    ranges_.push_back(
+        ByteRange{
+            const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(buf.data())),
+            bufSize,
+            0});
+  }
+}
+
+PrestoSerializedPage::~PrestoSerializedPage() {
+  if (onDestructionCb_) {
+    onDestructionCb_(*iobuf_.get());
+  }
+}
+
+std::unique_ptr<ByteInputStream>
+PrestoSerializedPage::prepareStreamForDeserialize() {
+  return std::make_unique<BufferInputStream>(std::move(ranges_));
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/SerializedPage.h b/velox/exec/SerializedPage.h
new file mode 100644
index 00000000000..3f93de8012a
--- /dev/null
+++ b/velox/exec/SerializedPage.h
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/common/memory/ByteStream.h"
+
+namespace facebook::velox::exec {
+
+/// Interface for serialized pages.
+class SerializedPageBase {
+ public:
+  virtual ~SerializedPageBase() = default;
+
+  /// Returns the size of the serialized data in bytes.
+  virtual uint64_t size() const = 0;
+
+  /// Returns the number of rows if available.
+  virtual std::optional<int64_t> numRows() const = 0;
+
+  /// Makes 'input' ready for deserializing 'this' with
+  /// VectorStreamGroup::read().
+  virtual std::unique_ptr<ByteInputStream> prepareStreamForDeserialize() = 0;
+
+  /// Returns a clone of the IOBuf.
+  virtual std::unique_ptr<folly::IOBuf> getIOBuf() const = 0;
+};
+
+/// Corresponds to Presto SerializedPage, i.e. a container for serialized
+/// vectors in Presto wire format.
+class PrestoSerializedPage : public SerializedPageBase {
+ public:
+  /// Construct from IOBuf chain.
+  explicit PrestoSerializedPage(
+      std::unique_ptr<folly::IOBuf> iobuf,
+      std::function<void(folly::IOBuf&)> onDestructionCb = nullptr,
+      std::optional<int64_t> numRows = std::nullopt);
+
+  ~PrestoSerializedPage() override;
+
+  uint64_t size() const override {
+    return iobufBytes_;
+  }
+
+  std::optional<int64_t> numRows() const override {
+    return numRows_;
+  }
+
+  std::unique_ptr<ByteInputStream> prepareStreamForDeserialize() override;
+
+  std::unique_ptr<folly::IOBuf> getIOBuf() const override {
+    return iobuf_->clone();
+  }
+
+ private:
+  static int64_t chainBytes(folly::IOBuf& iobuf) {
+    int64_t size = 0;
+    for (auto& range : iobuf) {
+      size += range.size();
+    }
+    return size;
+  }
+
+  // Buffers containing the serialized data. The memory is owned by 'iobuf_'.
+  std::vector<ByteRange> ranges_;
+
+  // IOBuf holding the data in 'ranges_.
+  std::unique_ptr<folly::IOBuf> iobuf_;
+
+  // Number of payload bytes in 'iobuf_'.
+  const int64_t iobufBytes_;
+
+  // Number of payload rows, if provided.
+  const std::optional<int64_t> numRows_;
+
+  // Callback that will be called on destruction of the PrestoSerializedPage,
+  // primarily used to free externally allocated memory backing folly::IOBuf
+  // from caller. Caller is responsible to pass in proper cleanup logic to
+  // prevent any memory leak.
+  std::function<void(folly::IOBuf&)> onDestructionCb_;
+};
+
+// TODO: Remove after fully migration to new SerializedPageBase and
+// PrestoSerializedPage API.
+using SerializedPage = PrestoSerializedPage;
+} // namespace facebook::velox::exec
diff --git a/velox/exec/SimpleAggregateAdapter.h b/velox/exec/SimpleAggregateAdapter.h
index 7ff74ae43b6..24a35955e5e 100644
--- a/velox/exec/SimpleAggregateAdapter.h
+++ b/velox/exec/SimpleAggregateAdapter.h
@@ -18,9 +18,43 @@
 #include "velox/exec/Aggregate.h"
 #include "velox/expression/VectorReaders.h"
 #include "velox/expression/VectorWriters.h"
+#include "velox/type/SimpleFunctionApi.h"
 
 namespace facebook::velox::exec {
 
+// AggregateInputType is similar to Row but allows Variadic as the last element.
+// Unlike Row, this type is not meant to be serialized or used as a data type
+// in Velox vectors - it's only used for type deduction in
+// SimpleAggregateAdapter.
+template <typename... T>
+struct AggregateInputType {
+  template <size_t idx>
+  using type_at = typename std::tuple_element<idx, std::tuple<T...>>::type;
+
+  static const size_t size_ = sizeof...(T);
+
+  // Verify that Variadic, if present, is only at the last position.
+  static_assert(
+      []() constexpr {
+        if constexpr (sizeof...(T) <= 1) {
+          return true;
+        } else {
+          // Check that no element except possibly the last is Variadic
+          constexpr bool checks[] = {!isVariadicType<T>::value...};
+          for (size_t i = 0; i < sizeof...(T) - 1; ++i) {
+            if (!checks[i]) {
+              return false;
+            }
+          }
+          return true;
+        }
+      }(),
+      "Variadic can only appear at the end of aggregation input type");
+
+ private:
+  AggregateInputType() {}
+};
+
 // The writer type of T used in simple UDAF interface. An instance of
 // out_type allows writing one row into the output vector.
 template <typename T>
@@ -44,9 +78,15 @@ class SimpleAggregateAdapter : public Aggregate {
   explicit SimpleAggregateAdapter(
       core::AggregationNode::Step step,
       const std::vector<TypePtr>& argTypes,
-      TypePtr resultType)
+      TypePtr resultType,
+      const core::QueryConfig* config = nullptr)
       : Aggregate(std::move(resultType)), fn_{std::make_unique<FUNC>()} {
-    if constexpr (support_initialize_) {
+    if constexpr (support_initialize_with_config_) {
+      VELOX_CHECK_NOT_NULL(
+          config,
+          "QueryConfig is required to initialize this aggregate function.");
+      fn_->initialize(step, argTypes, resultType_, *config);
+    } else if constexpr (support_initialize_) {
       fn_->initialize(step, argTypes, resultType_);
     }
   }
@@ -159,6 +199,20 @@ class SimpleAggregateAdapter : public Aggregate {
   struct support_initialize<T, std::void_t<decltype(&T::initialize)>>
       : std::true_type {};
 
+  // Whether the function defines an initialize() method that accepts a
+  // QueryConfig parameter. If so, the config is forwarded during construction.
+  template <typename T, typename = void>
+  struct support_initialize_with_config : std::false_type {};
+
+  template <typename T>
+  struct support_initialize_with_config<
+      T,
+      std::void_t<decltype(std::declval<T&>().initialize(
+          std::declval<core::AggregationNode::Step>(),
+          std::declval<const std::vector<TypePtr>&>(),
+          std::declval<const TypePtr&>(),
+          std::declval<const core::QueryConfig&>()))>> : std::true_type {};
+
   // Whether the accumulator requires aligned access. If it is defined,
   // SimpleAggregateAdapter::accumulatorAlignmentSize() returns
   // alignof(typename FUNC::AccumulatorType).
@@ -188,6 +242,9 @@ class SimpleAggregateAdapter : public Aggregate {
 
   static constexpr bool support_initialize_ = support_initialize<FUNC>::value;
 
+  static constexpr bool support_initialize_with_config_ =
+      support_initialize_with_config<FUNC>::value;
+
   static constexpr bool accumulator_is_aligned_ =
       accumulator_is_aligned<typename FUNC::AccumulatorType>::value;
 
@@ -226,8 +283,7 @@ class SimpleAggregateAdapter : public Aggregate {
       inputDecoded_[i].decode(*args[i], rows);
     }
 
-    addRawInputImpl(
-        groups, rows, std::make_index_sequence<FUNC::InputType::size_>{});
+    addRawInputImpl(groups, rows);
   }
 
   // Similar to addRawInput, but add inputs to one single accumulator.
@@ -244,8 +300,7 @@ class SimpleAggregateAdapter : public Aggregate {
       inputDecoded_[i].decode(*args[i], rows);
     }
 
-    addSingleGroupRawInputImpl(
-        group, rows, std::make_index_sequence<FUNC::InputType::size_>{});
+    addSingleGroupRawInputImpl(group, rows);
   }
 
   bool supportsToIntermediate() const override {
@@ -262,11 +317,7 @@ class SimpleAggregateAdapter : public Aggregate {
         inputDecoded[i].decode(*args[i], rows);
       }
 
-      toIntermediateImpl(
-          inputDecoded,
-          rows,
-          result,
-          std::make_index_sequence<FUNC::InputType::size_>{});
+      toIntermediateImpl(inputDecoded, rows, result);
     } else {
       VELOX_UNREACHABLE(
           "toIntermediate should only be called when support_to_intermediate_ is true.");
@@ -385,18 +436,97 @@ class SimpleAggregateAdapter : public Aggregate {
   }
 
  private:
-  template <std::size_t... Is>
-  void addRawInputImpl(
+  // Check if InputType has a variadic argument (must be at the last position).
+  static constexpr bool hasVariadicInput() {
+    if constexpr (FUNC::InputType::size_ == 0) {
+      return false;
+    } else {
+      return isVariadicType<typename FUNC::InputType::template type_at<
+          FUNC::InputType::size_ - 1>>::value;
+    }
+  }
+
+  static constexpr bool has_variadic_input_ = hasVariadicInput();
+
+  // The position in InputType where the variadic argument starts.
+  static constexpr int32_t variadicStartPosition_ =
+      has_variadic_input_ ? FUNC::InputType::size_ - 1 : FUNC::InputType::size_;
+
+  // Check if an input at POSITION is non-null for the given row. For
+  // non-variadic inputs this checks isSet(). For variadic inputs this checks
+  // hasTopLevelNull(), which inspects each variadic element's top-level
+  // nullity. This matches the expression layer's per-input null deselection
+  // for simple scalar functions.
+  template <size_t POSITION, typename TReader>
+  static bool isInputNonNull(const TReader& reader, vector_size_t row) {
+    if constexpr (POSITION >= variadicStartPosition_) {
+      return !reader.hasTopLevelNull(row);
+    } else {
+      return reader.isSet(row);
+    }
+  }
+
+  // Generic recursive unpacking function that creates VectorReaders for each
+  // input type and invokes the callback with all accumulated readers.
+  template <std::size_t POSITION, typename Callback, typename... TReader>
+  void unpackInputs(
+      const std::vector<DecodedVector>& inputDecoded,
+      const Callback& callback,
+      TReader&... readers) const {
+    if constexpr (POSITION == FUNC::InputType::size_) {
+      callback(readers...);
+    } else if constexpr (isVariadicType<
+                             typename FUNC::InputType::template type_at<
+                                 POSITION>>::value) {
+      static_assert(
+          POSITION == FUNC::InputType::size_ - 1,
+          "Variadic must be the last argument");
+      using VariadicT = typename FUNC::InputType::template type_at<POSITION>;
+      VectorReader<VariadicT> variadicReader(
+          inputDecoded, variadicStartPosition_);
+      callback(readers..., variadicReader);
+    } else {
+      VectorReader<typename FUNC::InputType::template type_at<POSITION>> reader(
+          &inputDecoded[POSITION]);
+      unpackInputs<POSITION + 1>(inputDecoded, callback, readers..., reader);
+    }
+  }
+
+  void addRawInputImpl(char** groups, const SelectivityVector& rows) {
+    unpackInputs<0>(inputDecoded_, [&](auto&... readers) {
+      addRawInputWithReaders(groups, rows, readers...);
+    });
+  }
+
+  template <typename... TReader>
+  void addRawInputWithReaders(
+      char** groups,
+      const SelectivityVector& rows,
+      TReader&... readers) {
+    addRawInputWithReadersImpl(
+        groups,
+        rows,
+        std::make_index_sequence<sizeof...(TReader)>{},
+        readers...);
+  }
+
+  // Process rows with the accumulated readers. Use Is to access the original
+  // input types to create OptionalAccessor.
+  template <std::size_t... Is, typename... TReader>
+  void addRawInputWithReadersImpl(
       char** groups,
       const SelectivityVector& rows,
-      std::index_sequence<Is...>) {
-    std::tuple<VectorReader<typename FUNC::InputType::template type_at<Is>>...>
-        readers{&inputDecoded_[Is]...};
+      std::index_sequence<Is...>,
+      TReader&... readers) {
+    static_assert(
+        sizeof...(Is) == FUNC::InputType::size_,
+        "Reader count must match InputType size");
 
     if constexpr (aggregate_default_null_behavior_) {
-      rows.applyToSelected([&](auto row) {
-        // If any input is null, we ignore the whole row.
-        if (!(std::get<Is>(readers).isSet(row) && ...)) {
+      rows.applyToSelected([&](vector_size_t row) {
+        // If any input is null, we ignore the whole row. For variadic
+        // arguments, this includes nulls within the variadic elements.
+        if (!(isInputNonNull<Is>(readers, row) && ...)) {
           return;
         }
         std::optional<RowSizeTracker<char, uint32_t>> tracker;
@@ -404,11 +534,11 @@ class SimpleAggregateAdapter : public Aggregate {
           tracker.emplace(groups[row][rowSizeOffset_], *allocator_);
         }
         auto group = value<typename FUNC::AccumulatorType>(groups[row]);
-        group->addInput(allocator_, std::get<Is>(readers)[row]...);
+        group->addInput(allocator_, readers[row]...);
         clearNull(groups[row]);
       });
     } else {
-      rows.applyToSelected([&](auto row) {
+      rows.applyToSelected([&](vector_size_t row) {
         std::optional<RowSizeTracker<char, uint32_t>> tracker;
         if constexpr (!accumulator_is_fixed_size_) {
           tracker.emplace(groups[row][rowSizeOffset_], *allocator_);
@@ -417,7 +547,7 @@ class SimpleAggregateAdapter : public Aggregate {
         bool nonNull = group->addInput(
             allocator_,
             OptionalAccessor<typename FUNC::InputType::template type_at<Is>>{
-                &std::get<Is>(readers), (int64_t)row}...);
+                &readers, (int64_t)row}...);
         if (nonNull) {
           clearNull(groups[row]);
         }
@@ -425,30 +555,54 @@ class SimpleAggregateAdapter : public Aggregate {
     }
   }
 
-  template <std::size_t... Is>
-  void addSingleGroupRawInputImpl(
+  void addSingleGroupRawInputImpl(char* group, const SelectivityVector& rows) {
+    unpackInputs<0>(inputDecoded_, [&](auto&... readers) {
+      addSingleGroupRawInputWithReaders(group, rows, readers...);
+    });
+  }
+
+  template <typename... TReader>
+  void addSingleGroupRawInputWithReaders(
+      char* group,
+      const SelectivityVector& rows,
+      TReader&... readers) {
+    addSingleGroupRawInputWithReadersImpl(
+        group,
+        rows,
+        std::make_index_sequence<sizeof...(TReader)>{},
+        readers...);
+  }
+
+  // Process rows for a single group with the accumulated readers. Use Is to
+  // access the original input types to create OptionalAccessor.
+  template <std::size_t... Is, typename... TReader>
+  void addSingleGroupRawInputWithReadersImpl(
       char* group,
       const SelectivityVector& rows,
-      std::index_sequence<Is...>) {
-    std::tuple<VectorReader<typename FUNC::InputType::template type_at<Is>>...>
-        readers{&inputDecoded_[Is]...};
+      std::index_sequence<Is...>,
+      TReader&... readers) {
+    static_assert(
+        sizeof...(Is) == FUNC::InputType::size_,
+        "Reader count must match InputType size");
+
     auto accumulator = value<typename FUNC::AccumulatorType>(group);
 
     if constexpr (aggregate_default_null_behavior_) {
-      rows.applyToSelected([&](auto row) {
-        // If any input is null, we ignore the whole row.
-        if (!(std::get<Is>(readers).isSet(row) && ...)) {
+      rows.applyToSelected([&](vector_size_t row) {
+        // If any input is null, we ignore the whole row. For variadic
+        // arguments, this includes nulls within the variadic elements.
+        if (!(isInputNonNull<Is>(readers, row) && ...)) {
           return;
         }
         std::optional<RowSizeTracker<char, uint32_t>> tracker;
         if constexpr (!accumulator_is_fixed_size_) {
           tracker.emplace(group[rowSizeOffset_], *allocator_);
         }
-        accumulator->addInput(allocator_, std::get<Is>(readers)[row]...);
+        accumulator->addInput(allocator_, readers[row]...);
         clearNull(group);
       });
     } else {
-      rows.applyToSelected([&](auto row) {
+      rows.applyToSelected([&](vector_size_t row) {
         std::optional<RowSizeTracker<char, uint32_t>> tracker;
         if constexpr (!accumulator_is_fixed_size_) {
           tracker.emplace(group[rowSizeOffset_], *allocator_);
@@ -456,7 +610,7 @@ class SimpleAggregateAdapter : public Aggregate {
         bool nonNull = accumulator->addInput(
             allocator_,
             OptionalAccessor<typename FUNC::InputType::template type_at<Is>>{
-                &std::get<Is>(readers), (int64_t)row}...);
+                &readers, (int64_t)row}...);
         if (nonNull) {
           clearNull(group);
         }
@@ -464,15 +618,10 @@ class SimpleAggregateAdapter : public Aggregate {
     }
   }
 
-  template <std::size_t... Is>
   void toIntermediateImpl(
       const std::vector<DecodedVector>& inputDecoded,
       const SelectivityVector& rows,
-      VectorPtr& result,
-      std::index_sequence<Is...>) const {
-    std::tuple<VectorReader<typename FUNC::InputType::template type_at<Is>>...>
-        readers{&inputDecoded[Is]...};
-
+      VectorPtr& result) const {
     VELOX_CHECK(result);
     result->ensureWritable(rows);
     auto* rawNulls = result->mutableRawNulls();
@@ -485,29 +634,56 @@ class SimpleAggregateAdapter : public Aggregate {
     exec::VectorWriter<typename FUNC::IntermediateType> writer;
     writer.init(*flatResult);
 
+    unpackInputs<0>(inputDecoded, [&](auto&... readers) {
+      toIntermediateWithReaders(rows, writer, readers...);
+    });
+    writer.finish();
+  }
+
+  template <typename... TReader>
+  void toIntermediateWithReaders(
+      const SelectivityVector& rows,
+      exec::VectorWriter<typename FUNC::IntermediateType>& writer,
+      TReader&... readers) const {
+    toIntermediateWithReadersImpl(
+        rows,
+        writer,
+        std::make_index_sequence<sizeof...(TReader)>{},
+        readers...);
+  }
+
+  // Process rows for toIntermediate with the accumulated readers.
+  template <std::size_t... Is, typename... TReader>
+  void toIntermediateWithReadersImpl(
+      const SelectivityVector& rows,
+      exec::VectorWriter<typename FUNC::IntermediateType>& writer,
+      std::index_sequence<Is...>,
+      TReader&... readers) const {
+    static_assert(
+        sizeof...(Is) == FUNC::InputType::size_,
+        "Reader count must match InputType size");
+
     if constexpr (aggregate_default_null_behavior_) {
-      rows.applyToSelected([&](auto row) {
+      rows.applyToSelected([&](vector_size_t row) {
         writer.setOffset(row);
-        // If any input is null, we ignore the whole row.
-        if (!(std::get<Is>(readers).isSet(row) && ...)) {
+        // If any input is null, we ignore the whole row. For variadic
+        // arguments, this includes nulls within the variadic elements.
+        if (!(isInputNonNull<Is>(readers, row) && ...)) {
           writer.commitNull();
           return;
         }
-        bool nonNull = FUNC::toIntermediate(
-            writer.current(), std::get<Is>(readers)[row]...);
+        bool nonNull = FUNC::toIntermediate(writer.current(), readers[row]...);
         writer.commit(nonNull);
       });
-      writer.finish();
     } else {
-      rows.applyToSelected([&](auto row) {
+      rows.applyToSelected([&](vector_size_t row) {
         writer.setOffset(row);
         bool nonNull = FUNC::toIntermediate(
             writer.current(),
             OptionalAccessor<typename FUNC::InputType::template type_at<Is>>{
-                &std::get<Is>(readers), (int64_t)row}...);
+                &readers, (int64_t)row}...);
         writer.commit(nonNull);
       });
-      writer.finish();
     }
   }
 
@@ -519,7 +695,7 @@ class SimpleAggregateAdapter : public Aggregate {
     VectorReader<typename FUNC::IntermediateType> reader(&intermediateDecoded_);
 
     if constexpr (aggregate_default_null_behavior_) {
-      rows.applyToSelected([&](auto row) {
+      rows.applyToSelected([&](vector_size_t row) {
         if (!reader.isSet(row)) {
           return;
         }
@@ -532,7 +708,7 @@ class SimpleAggregateAdapter : public Aggregate {
         clearNull(groups[row]);
       });
     } else {
-      rows.applyToSelected([&](auto row) {
+      rows.applyToSelected([&](vector_size_t row) {
         std::optional<RowSizeTracker<char, uint32_t>> tracker;
         if constexpr (!accumulator_is_fixed_size_) {
           tracker.emplace(groups[row][rowSizeOffset_], *allocator_);
@@ -558,7 +734,7 @@ class SimpleAggregateAdapter : public Aggregate {
     auto accumulator = value<typename FUNC::AccumulatorType>(group);
 
     if constexpr (aggregate_default_null_behavior_) {
-      rows.applyToSelected([&](auto row) {
+      rows.applyToSelected([&](vector_size_t row) {
         if (!reader.isSet(row)) {
           return;
         }
@@ -570,7 +746,7 @@ class SimpleAggregateAdapter : public Aggregate {
         clearNull(group);
       });
     } else {
-      rows.applyToSelected([&](auto row) {
+      rows.applyToSelected([&](vector_size_t row) {
         std::optional<RowSizeTracker<char, uint32_t>> tracker;
         if constexpr (!accumulator_is_fixed_size_) {
           tracker.emplace(group[rowSizeOffset_], *allocator_);
diff --git a/velox/exec/SortBuffer.cpp b/velox/exec/SortBuffer.cpp
index d64f858d95f..fda9c19a5c9 100644
--- a/velox/exec/SortBuffer.cpp
+++ b/velox/exec/SortBuffer.cpp
@@ -28,7 +28,7 @@ SortBuffer::SortBuffer(
     tsan_atomic<bool>* nonReclaimableSection,
     common::PrefixSortConfig prefixSortConfig,
     const common::SpillConfig* spillConfig,
-    folly::Synchronized<velox::common::SpillStats>* spillStats)
+    exec::SpillStats* spillStats)
     : input_(input),
       sortCompareFlags_(sortCompareFlags),
       pool_(pool),
@@ -37,7 +37,7 @@ SortBuffer::SortBuffer(
       spillConfig_(spillConfig),
       spillStats_(spillStats),
       sortedRows_(0, memory::StlAllocator<char*>(*pool)) {
-  VELOX_CHECK_GE(input_->size(), sortCompareFlags_.size());
+  VELOX_CHECK_GE(input_->children().size(), sortCompareFlags_.size());
   VELOX_CHECK_GT(sortCompareFlags_.size(), 0);
   VELOX_CHECK_EQ(sortColumnIndices.size(), sortCompareFlags_.size());
   VELOX_CHECK_NOT_NULL(nonReclaimableSection_);
@@ -74,7 +74,7 @@ SortBuffer::SortBuffer(
   }
 
   data_ = std::make_unique<RowContainer>(
-      sortedColumnTypes, nonSortedColumnTypes, pool_);
+      sortedColumnTypes, nonSortedColumnTypes, /*useListRowIndex=*/true, pool_);
   spillerStoreType_ =
       ROW(std::move(sortedSpillColumnNames), std::move(sortedSpillColumnTypes));
 }
@@ -90,12 +90,12 @@ void SortBuffer::addInput(const VectorPtr& input) {
   VELOX_CHECK(!noMoreInput_);
   ensureInputFits(input);
 
-  SelectivityVector allRows(input->size());
+  const SelectivityVector allRows(input->size());
   std::vector<char*> rows(input->size());
   for (int row = 0; row < input->size(); ++row) {
     rows[row] = data_->newRow();
   }
-  auto* inputRow = input->as<RowVector>();
+  const auto* inputRow = input->as<RowVector>();
   for (const auto& columnProjection : columnMap_) {
     DecodedVector decoded(
         *inputRow->childAt(columnProjection.outputChannel), allRows);
@@ -128,6 +128,7 @@ void SortBuffer::noMoreInput() {
     updateEstimatedOutputRowSize();
     // Sort the pointers to the rows in RowContainer (data_) instead of sorting
     // the rows.
+    // TODO: Reuse 'RowContainer::rowPointers_'.
     sortedRows_.resize(numInputRows_);
     RowContainerIterator iter;
     data_->listRows(&iter, numInputRows_, sortedRows_.data());
@@ -168,7 +169,7 @@ RowVectorPtr SortBuffer::getOutput(vector_size_t maxOutputRows) {
   } else {
     getOutputWithoutSpill();
   }
-  return output_;
+  return std::move(output_);
 }
 
 bool SortBuffer::hasSpilled() const {
@@ -257,8 +258,11 @@ void SortBuffer::ensureInputFits(const VectorPtr& input) {
   }
   LOG(WARNING) << "Failed to reserve " << succinctBytes(targetIncrementBytes)
                << " for memory pool " << pool()->name()
-               << ", usage: " << succinctBytes(pool()->usedBytes())
-               << ", reservation: " << succinctBytes(pool()->reservedBytes());
+               << ", root pool: " << pool()->root()->name()
+               << ", used: " << succinctBytes(pool()->usedBytes())
+               << ", reservation: " << succinctBytes(pool()->reservedBytes())
+               << ", root pool reservation: "
+               << succinctBytes(pool()->root()->reservedBytes());
 }
 
 void SortBuffer::ensureOutputFits(vector_size_t batchSize) {
@@ -289,8 +293,11 @@ void SortBuffer::ensureOutputFits(vector_size_t batchSize) {
   LOG(WARNING) << "Failed to reserve "
                << succinctBytes(outputBufferSizeToReserve)
                << " for memory pool " << pool_->name()
-               << ", usage: " << succinctBytes(pool_->usedBytes())
-               << ", reservation: " << succinctBytes(pool_->reservedBytes());
+               << ", root pool: " << pool_->root()->name()
+               << ", used: " << succinctBytes(pool_->usedBytes())
+               << ", reservation: " << succinctBytes(pool_->reservedBytes())
+               << ", root pool reservation: "
+               << succinctBytes(pool_->root()->reservedBytes());
 }
 
 void SortBuffer::ensureSortFits() {
@@ -310,7 +317,7 @@ void SortBuffer::ensureSortFits() {
   }
 
   // The memory for std::vector sorted rows and prefix sort required buffer.
-  uint64_t sortBufferToReserve =
+  const auto sortBufferToReserve =
       numInputRows_ * sizeof(char*) +
       PrefixSort::maxRequiredBytes(
           data_.get(), sortCompareFlags_, prefixSortConfig_, pool_);
@@ -389,10 +396,6 @@ void SortBuffer::prepareOutput(vector_size_t batchSize) {
         BaseVector::create(input_, batchSize, pool_));
   }
 
-  for (auto& child : output_->children()) {
-    child->resize(batchSize);
-  }
-
   if (hasSpilled()) {
     spillSources_.resize(batchSize);
     spillSourceRows_.resize(batchSize);
@@ -488,7 +491,7 @@ void SortBuffer::prepareOutputWithSpill() {
 
   VELOX_CHECK_EQ(spillPartitionSet_.size(), 1);
   spillMerger_ = spillPartitionSet_.begin()->second->createOrderedReader(
-      spillConfig_->readBufferSize, pool(), spillStats_);
+      *spillConfig_, pool(), spillStats_);
   spillPartitionSet_.clear();
 }
 } // namespace facebook::velox::exec
diff --git a/velox/exec/SortBuffer.h b/velox/exec/SortBuffer.h
index 9804e2f8589..99ddc866cf0 100644
--- a/velox/exec/SortBuffer.h
+++ b/velox/exec/SortBuffer.h
@@ -40,7 +40,7 @@ class SortBuffer {
       tsan_atomic<bool>* nonReclaimableSection,
       common::PrefixSortConfig prefixSortConfig,
       const common::SpillConfig* spillConfig = nullptr,
-      folly::Synchronized<velox::common::SpillStats>* spillStats = nullptr);
+      exec::SpillStats* spillStats = nullptr);
 
   ~SortBuffer();
 
@@ -125,7 +125,7 @@ class SortBuffer {
 
   const common::SpillConfig* const spillConfig_;
 
-  folly::Synchronized<common::SpillStats>* const spillStats_;
+  exec::SpillStats* const spillStats_;
 
   // The column projection map between 'input_' and 'spillerStoreType_' as sort
   // buffer stores the sort columns first in 'data_'.
diff --git a/velox/exec/SortWindowBuild.cpp b/velox/exec/SortWindowBuild.cpp
index f25175cc2cf..89eeeb08160 100644
--- a/velox/exec/SortWindowBuild.cpp
+++ b/velox/exec/SortWindowBuild.cpp
@@ -16,6 +16,7 @@
 
 #include "velox/exec/SortWindowBuild.h"
 #include "velox/exec/MemoryReclaimer.h"
+#include "velox/exec/Window.h"
 
 namespace facebook::velox::exec {
 
@@ -45,16 +46,19 @@ SortWindowBuild::SortWindowBuild(
     common::PrefixSortConfig&& prefixSortConfig,
     const common::SpillConfig* spillConfig,
     tsan_atomic<bool>* nonReclaimableSection,
-    folly::Synchronized<common::SpillStats>* spillStats)
+    folly::Synchronized<OperatorStats>* opStats,
+    exec::SpillStats* spillStats)
     : WindowBuild(node, pool, spillConfig, nonReclaimableSection),
       numPartitionKeys_{node->partitionKeys().size()},
       compareFlags_{makeCompareFlags(numPartitionKeys_, node->sortingOrders())},
       pool_(pool),
       prefixSortConfig_(prefixSortConfig),
+      opStats_(opStats),
       spillStats_(spillStats),
       sortedRows_(0, memory::StlAllocator<char*>(*pool)),
       partitionStartRows_(0, memory::StlAllocator<char*>(*pool)) {
   VELOX_CHECK_NOT_NULL(pool_);
+  VELOX_CHECK_NOT_NULL(opStats_);
   allKeyInfo_.reserve(partitionKeyInfo_.size() + sortKeyInfo_.size());
   allKeyInfo_.insert(
       allKeyInfo_.cend(), partitionKeyInfo_.begin(), partitionKeyInfo_.end());
@@ -72,13 +76,20 @@ void SortWindowBuild::addInput(RowVectorPtr input) {
 
   // Add all the rows into the RowContainer.
   for (auto row = 0; row < input->size(); ++row) {
-    char* newRow = data_->newRow();
+    addDecodedInputRow(decodedInputVectors_, row);
+  }
+}
 
-    for (auto col = 0; col < input->childrenSize(); ++col) {
-      data_->store(decodedInputVectors_[col], row, newRow, col);
-    }
+void SortWindowBuild::addDecodedInputRow(
+    std::vector<DecodedVector>& decodedInputVectors,
+    vector_size_t row) {
+  char* newRow = data_->newRow();
+
+  for (auto col = 0; col < inputChannels_.size(); ++col) {
+    data_->store(decodedInputVectors[col], row, newRow, col);
   }
-  numRows_ += input->size();
+
+  numRows_++;
 }
 
 void SortWindowBuild::ensureInputFits(const RowVectorPtr& input) {
@@ -135,9 +146,12 @@ void SortWindowBuild::ensureInputFits(const RowVectorPtr& input) {
 
   LOG(WARNING) << "Failed to reserve " << succinctBytes(targetIncrementBytes)
                << " for memory pool " << data_->pool()->name()
-               << ", usage: " << succinctBytes(data_->pool()->usedBytes())
+               << ", root pool: " << data_->pool()->root()->name()
+               << ", used: " << succinctBytes(data_->pool()->usedBytes())
                << ", reservation: "
-               << succinctBytes(data_->pool()->reservedBytes());
+               << succinctBytes(data_->pool()->reservedBytes())
+               << ", root pool reservation: "
+               << succinctBytes(data_->pool()->root()->reservedBytes());
 }
 
 void SortWindowBuild::ensureSortFits() {
@@ -194,7 +208,7 @@ void SortWindowBuild::spill() {
   data_->pool()->release();
 }
 
-std::optional<common::SpillStats> SortWindowBuild::spilledStats() const {
+std::optional<exec::SpillStats> SortWindowBuild::spilledStats() const {
   if (spiller_ == nullptr) {
     return std::nullopt;
   }
@@ -280,7 +294,7 @@ void SortWindowBuild::noMoreInput() {
     spiller_->finishSpill(spillPartitionSet);
     VELOX_CHECK_EQ(spillPartitionSet.size(), 1);
     merge_ = spillPartitionSet.begin()->second->createOrderedReader(
-        spillConfig_->readBufferSize, pool_, spillStats_);
+        *spillConfig_, pool_, spillStats_);
   } else {
     // At this point we have seen all the input rows. The operator is
     // being prepared to output rows now.
@@ -294,14 +308,31 @@ void SortWindowBuild::noMoreInput() {
   pool_->release();
 }
 
-void SortWindowBuild::loadNextPartitionFromSpill() {
+void SortWindowBuild::loadNextPartitionBatchFromSpill() {
+  // Check if current partition batch still has available partitions. If so,
+  // return directly.
+  if (currentPartition_ < static_cast<int>(partitionStartRows_.size() - 2)) {
+    return;
+  }
+
+  const int minReadBatchRows = spillConfig_->windowMinReadBatchRows;
   sortedRows_.clear();
-  sortedRows_.shrink_to_fit();
+  sortedRows_.reserve(minReadBatchRows);
   data_->clear();
+  partitionStartRows_.clear();
+  partitionStartRows_.reserve(minReadBatchRows);
+  partitionStartRows_.push_back(0);
+  currentPartition_ = -1;
+  numSpillReadBatches_++;
 
+  // Load at least #minReadBatchRows rows and a complete partition. The rows
+  // might contain multiple partitions. Record the partition boundaries as
+  // inMemory case. In this way, the logic of getting window partitions would be
+  // identical between inMemory and spill.
   for (;;) {
     auto next = merge_->next();
     if (next == nullptr) {
+      partitionStartRows_.push_back(sortedRows_.size());
       break;
     }
 
@@ -324,7 +355,10 @@ void SortWindowBuild::loadNextPartitionFromSpill() {
     }
 
     if (newPartition) {
-      break;
+      partitionStartRows_.push_back(sortedRows_.size());
+      if (sortedRows_.size() >= minReadBatchRows) {
+        break;
+      }
     }
 
     auto* newRow = data_->newRow();
@@ -334,16 +368,20 @@ void SortWindowBuild::loadNextPartitionFromSpill() {
     sortedRows_.push_back(newRow);
     next->pop();
   }
-}
 
-std::shared_ptr<WindowPartition> SortWindowBuild::nextPartition() {
-  if (merge_ != nullptr) {
-    VELOX_CHECK(!sortedRows_.empty(), "No window partitions available");
-    auto partition = folly::Range(sortedRows_.data(), sortedRows_.size());
-    return std::make_shared<WindowPartition>(
-        data_.get(), partition, inversedInputChannels_, sortKeyInfo_);
+  // No more partition batches. All data is consumed.
+  if (sortedRows_.empty()) {
+    partitionStartRows_.clear();
+    numSpillReadBatches_--;
+
+    auto lockedOpStats = opStats_->wlock();
+    lockedOpStats
+        ->runtimeStats[std::string(Window::kWindowSpillReadNumBatches)] =
+        RuntimeMetric(numSpillReadBatches_);
   }
+}
 
+std::shared_ptr<WindowPartition> SortWindowBuild::nextPartition() {
   VELOX_CHECK(!partitionStartRows_.empty(), "No window partitions available");
 
   currentPartition_++;
@@ -364,8 +402,7 @@ std::shared_ptr<WindowPartition> SortWindowBuild::nextPartition() {
 
 bool SortWindowBuild::hasNextPartition() {
   if (merge_ != nullptr) {
-    loadNextPartitionFromSpill();
-    return !sortedRows_.empty();
+    loadNextPartitionBatchFromSpill();
   }
 
   return partitionStartRows_.size() > 0 &&
diff --git a/velox/exec/SortWindowBuild.h b/velox/exec/SortWindowBuild.h
index 72875094007..47e51ad7979 100644
--- a/velox/exec/SortWindowBuild.h
+++ b/velox/exec/SortWindowBuild.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include "velox/common/file/FileSystems.h"
 #include "velox/exec/PrefixSort.h"
 #include "velox/exec/Spiller.h"
 #include "velox/exec/WindowBuild.h"
@@ -32,7 +33,8 @@ class SortWindowBuild : public WindowBuild {
       common::PrefixSortConfig&& prefixSortConfig,
       const common::SpillConfig* spillConfig,
       tsan_atomic<bool>* nonReclaimableSection,
-      folly::Synchronized<common::SpillStats>* spillStats);
+      folly::Synchronized<OperatorStats>* opStats,
+      exec::SpillStats* spillStats);
 
   ~SortWindowBuild() override {
     pool_->release();
@@ -45,9 +47,13 @@ class SortWindowBuild : public WindowBuild {
 
   void addInput(RowVectorPtr input) override;
 
+  void addDecodedInputRow(
+      std::vector<DecodedVector>& decodedInputVectors,
+      vector_size_t row);
+
   void spill() override;
 
-  std::optional<common::SpillStats> spilledStats() const override;
+  std::optional<exec::SpillStats> spilledStats() const override;
 
   void noMoreInput() override;
 
@@ -55,9 +61,9 @@ class SortWindowBuild : public WindowBuild {
 
   std::shared_ptr<WindowPartition> nextPartition() override;
 
- private:
   void ensureInputFits(const RowVectorPtr& input);
 
+ private:
   void ensureSortFits();
 
   void setupSpiller();
@@ -75,8 +81,10 @@ class SortWindowBuild : public WindowBuild {
   // Find the next partition start row from start.
   vector_size_t findNextPartitionStartRow(vector_size_t start);
 
-  // Reads next partition from spilled data into 'data_' and 'sortedRows_'.
-  void loadNextPartitionFromSpill();
+  // Load the next partition batch if needed. If current partition batch is not
+  // entirely consumed, return directly. Otherwise, read next partition batch
+  // from spilled data into 'data_' and set pointers in 'sortedRows_'.
+  void loadNextPartitionBatchFromSpill();
 
   const size_t numPartitionKeys_;
 
@@ -92,7 +100,9 @@ class SortWindowBuild : public WindowBuild {
   // Config for Prefix-sort.
   const common::PrefixSortConfig prefixSortConfig_;
 
-  folly::Synchronized<common::SpillStats>* const spillStats_;
+  folly::Synchronized<OperatorStats>* const opStats_;
+
+  exec::SpillStats* const spillStats_;
 
   // allKeyInfo_ is a combination of (partitionKeyInfo_ and sortKeyInfo_).
   // It is used to perform a full sorting of the input rows to be able to
@@ -121,5 +131,8 @@ class SortWindowBuild : public WindowBuild {
 
   // Used to sort-merge spilled data.
   std::unique_ptr<TreeOfLosers<SpillMergeStream>> merge_;
+
+  // Number of batches of whole partitions read from spilled data.
+  uint64_t numSpillReadBatches_ = 0;
 };
 } // namespace facebook::velox::exec
diff --git a/velox/exec/SpatialIndex.cpp b/velox/exec/SpatialIndex.cpp
new file mode 100644
index 00000000000..41adcff2ff2
--- /dev/null
+++ b/velox/exec/SpatialIndex.cpp
@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <algorithm>
+#include <vector>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/exec/HilbertIndex.h"
+#include "velox/exec/SpatialIndex.h"
+
+namespace facebook::velox::exec {
+
+std::vector<size_t> RTreeLevel::query(
+    const Envelope& queryEnv,
+    const std::vector<size_t>& branchIndices) const {
+  std::vector<size_t> result;
+
+  for (size_t branchIdx : branchIndices) {
+    size_t startIdx = branchIdx * branchSize_;
+    size_t endIdx = std::min(startIdx + branchSize_, minXs_.size());
+    for (size_t idx = startIdx; idx < endIdx; ++idx) {
+      bool intersects = (queryEnv.maxX >= minXs_[idx]) &&
+          (queryEnv.maxY >= minYs_[idx]) && (queryEnv.minX <= maxXs_[idx]) &&
+          (queryEnv.minY <= maxYs_[idx]);
+      if (intersects) {
+        result.push_back(idx);
+      }
+    }
+  }
+
+  return result;
+}
+
+namespace {
+std::pair<RTreeLevel, std::vector<Envelope>> buildLevel(
+    uint32_t branchSize,
+    const std::vector<Envelope>& envelopes) {
+  std::vector<float> minXs;
+  minXs.reserve(envelopes.size());
+  std::vector<float> minYs;
+  minYs.reserve(envelopes.size());
+  std::vector<float> maxXs;
+  maxXs.reserve(envelopes.size());
+  std::vector<float> maxYs;
+  maxYs.reserve(envelopes.size());
+
+  std::vector<Envelope> parentEnvelopes;
+  parentEnvelopes.reserve((envelopes.size() + branchSize - 1) / branchSize);
+  Envelope currentBounds = Envelope::empty();
+
+  uint32_t idx = 0;
+  for (const auto& env : envelopes) {
+    ++idx;
+    currentBounds.maxX = std::max(currentBounds.maxX, env.maxX);
+    currentBounds.maxY = std::max(currentBounds.maxY, env.maxY);
+    currentBounds.minX = std::min(currentBounds.minX, env.minX);
+    currentBounds.minY = std::min(currentBounds.minY, env.minY);
+    if (idx % branchSize == 0) {
+      parentEnvelopes.push_back(currentBounds);
+      currentBounds = Envelope::empty();
+    }
+
+    minXs.push_back(env.minX);
+    minYs.push_back(env.minY);
+    maxXs.push_back(env.maxX);
+    maxYs.push_back(env.maxY);
+  }
+
+  if (!currentBounds.isEmpty()) {
+    parentEnvelopes.push_back(currentBounds);
+  }
+
+  return {
+      RTreeLevel(
+          branchSize,
+          std::move(minXs),
+          std::move(minYs),
+          std::move(maxXs),
+          std::move(maxYs)),
+      std::move(parentEnvelopes)};
+}
+} // namespace
+
+SpatialIndex::SpatialIndex(
+    Envelope bounds,
+    std::vector<Envelope> envelopes,
+    uint32_t branchSize)
+    : branchSize_(branchSize), bounds_(std::move(bounds)) {
+  VELOX_CHECK_GT(branchSize_, 1);
+
+  if (!bounds_.isEmpty()) {
+    HilbertIndex hilbert(
+        bounds_.minX, bounds_.minY, bounds_.maxX, bounds_.maxY);
+
+    std::sort(
+        envelopes.begin(), envelopes.end(), [&](const auto& a, const auto& b) {
+          return hilbert.indexOf(a.minX, a.minY) <
+              hilbert.indexOf(b.minX, b.minY);
+        });
+  }
+
+  rowIndices_.reserve(envelopes.size());
+  for (const auto& env : envelopes) {
+    VELOX_CHECK(env.minX >= bounds_.minX);
+    VELOX_CHECK(env.minY >= bounds_.minY);
+    VELOX_CHECK(env.maxX <= bounds_.maxX);
+    VELOX_CHECK(env.maxY <= bounds_.maxY);
+    rowIndices_.push_back(env.rowIndex);
+  }
+
+  if (envelopes.size() > 0) {
+    size_t numLevels =
+        std::ceil(std::log(envelopes.size()) / std::log(branchSize_));
+    levels_.reserve(numLevels);
+  }
+
+  while (envelopes.size() > branchSize_) {
+    auto [level, parentEnvelopes] = buildLevel(branchSize_, envelopes);
+    levels_.push_back(std::move(level));
+    envelopes = std::move(parentEnvelopes);
+  }
+
+  if (envelopes.size() > 1 || levels_.empty()) {
+    levels_.push_back(buildLevel(branchSize_, envelopes).first);
+  }
+
+  VELOX_CHECK_GT(branchSize_ + 1, levels_.back().size());
+}
+
+std::vector<vector_size_t> SpatialIndex::query(const Envelope& queryEnv) const {
+  std::vector<vector_size_t> result;
+  if (!Envelope::intersects(queryEnv, bounds_)) {
+    return result;
+  }
+
+  size_t thisLevel = levels_.size() - 1;
+  VELOX_CHECK_GT(levels_[thisLevel].size(), 0);
+  VELOX_CHECK_GT(branchSize_ + 1, levels_[thisLevel].size());
+
+  // The top level should have only one branch.
+  std::vector<size_t> childIndices = {0};
+  for (; thisLevel > 0; --thisLevel) {
+    // Avoiding thisLevel = 0 due to int underflow
+    childIndices = levels_[thisLevel].query(queryEnv, childIndices);
+    // If we have no matches, return.
+    if (childIndices.empty()) {
+      return result;
+    }
+  }
+
+  // We're at level 0 now.  The indices index into rowIndices.
+  VELOX_DCHECK_EQ(thisLevel, 0);
+  childIndices = levels_[thisLevel].query(queryEnv, childIndices);
+  result.reserve(childIndices.size());
+  for (auto idx : childIndices) {
+    result.push_back(rowIndices_[idx]);
+  }
+
+  return result;
+}
+
+Envelope SpatialIndex::bounds() const {
+  return bounds_;
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/SpatialIndex.h b/velox/exec/SpatialIndex.h
new file mode 100644
index 00000000000..d6b2ad6d83b
--- /dev/null
+++ b/velox/exec/SpatialIndex.h
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <vector>
+#include "velox/vector/TypeAliases.h"
+
+namespace facebook::velox::exec {
+
+/// A minimal envelope for a geometry.
+/// It also includes an index for the geometry for later reference.  This can
+/// be -1 if the geometry is not indexed.
+///
+/// Envelopes use float32s instead of float64s so that SIMD loops can be
+/// twice as fast.  Our geometries use float64 coordinates, so we have to
+/// downcast them for the envelope.  The loss of precision is theoretically fine
+/// because the envelope checks are already approximate: either they don't
+/// intersect or they might intersect.  Thus, expanding the envelopes slightly
+/// does not affect correctness (but it might affect efficiency slightly).
+///
+/// We want to show that if two envelopes expressed with float64 precision would
+/// intersect, the envelopes with float32 precision would also intersect.
+///
+/// Define
+/// ```
+/// nextUp(f) = std::nextafter(f, std::numeric_limits<float>::infinity())
+/// nextDown(f) = std::nextafter(f, -std::numeric_limits<float>::infinity())
+/// ```
+/// which move a float up or down one ulp (unit in the last place).
+///
+/// Since the conditions are all of the form `maxX >= minX` for float64s maxX
+/// and minX, we need to show that this implies `nextUp((float) maxX) >=
+/// nextDown((float) minX)`.
+///
+/// Assume you have a double `d` and two adjacent floats `f0` and `f1`, such
+/// that `d` is "between" `f0` and `f1`:
+///
+/// 1. `(double) f0 <= d <= (double) f1`
+/// 2. `nextup(f0) == f1 && f0 = nextdown(f0)`
+///
+/// This implies `nextdown((float) d) <= f0 && nextup((float) d) >= f1`.
+///
+/// Let double `minX` have two adjacent floats `f0`, `f1` as above, and `maxX`
+/// have two adjacent floats `g0`, `g1`.  Then
+/// ```
+/// (double) nextDown((float) minX)
+///   <= (double) f0
+///   <= minX
+///   <= maxX
+///   <= (double) g1
+///   <= (double) nextUp((float) maxX)
+/// ```
+///
+/// And this implies `nextDown((float) minX) <= nextUp((float) maxX)` as
+/// desired. The same argument applies to all for members, so if we construct
+/// the float32 precision envelope by applying nextDown to the minX/Ys and
+/// nextUp to maxX/Ys, the float32 envelope intersects in all cases that the
+/// float64 envelope would (but not necessarily the converse).
+struct Envelope {
+  float minX{std::numeric_limits<float>::infinity()};
+  float minY{std::numeric_limits<float>::infinity()};
+  float maxX{-std::numeric_limits<float>::infinity()};
+  float maxY{-std::numeric_limits<float>::infinity()};
+  vector_size_t rowIndex = -1;
+
+  /// Returns true if the intersection of two envelopes is not empty.
+  static inline bool intersects(const Envelope& left, const Envelope& right) {
+    return (left.maxX >= right.minX) && (left.minX <= right.maxX) &&
+        (left.maxY >= right.minY) && (left.minY <= right.maxY);
+  }
+
+  /// Returns true if the envelope contains at least one point.
+  /// An envelope of a point is not empty.
+  inline bool isEmpty() const {
+    // This negation handles NaNs correctly.
+    return !((minX <= maxX) && (minY <= maxY));
+  }
+
+  /// Expands this Envelope to also contain the other.
+  inline void merge(const Envelope& other) {
+    minX = std::min(minX, other.minX);
+    minY = std::min(minY, other.minY);
+    maxX = std::max(maxX, other.maxX);
+    maxY = std::max(maxY, other.maxY);
+  }
+
+  /// Construct an empty envelope.
+  static constexpr inline Envelope empty() {
+    return Envelope{
+        .minX = std::numeric_limits<float>::infinity(),
+        .minY = std::numeric_limits<float>::infinity(),
+        .maxX = -std::numeric_limits<float>::infinity(),
+        .maxY = -std::numeric_limits<float>::infinity()};
+  }
+
+  static constexpr inline Envelope from(
+      double minX,
+      double minY,
+      double maxX,
+      double maxY,
+      vector_size_t rowIndex = -1) {
+    return Envelope{
+        .minX = std::nextafterf(
+            static_cast<float>(minX), -std::numeric_limits<float>::infinity()),
+        .minY = std::nextafterf(
+            static_cast<float>(minY), -std::numeric_limits<float>::infinity()),
+        .maxX = std::nextafterf(
+            static_cast<float>(maxX), std::numeric_limits<float>::infinity()),
+        .maxY = std::nextafterf(
+            static_cast<float>(maxY), std::numeric_limits<float>::infinity()),
+        .rowIndex = rowIndex};
+  }
+
+  static inline Envelope of(const std::vector<Envelope>& envelopes) {
+    Envelope result = Envelope::empty();
+    for (const auto& envelope : envelopes) {
+      result.merge(envelope);
+    }
+    return result;
+  }
+};
+
+/// A single level of an R-tree.  It is a set of envelopes that can be linearly
+/// scanned for envelope intersection.
+class RTreeLevel {
+ public:
+  RTreeLevel(const RTreeLevel&) = delete;
+  RTreeLevel& operator=(const RTreeLevel&) = delete;
+
+  RTreeLevel() = default;
+  RTreeLevel(RTreeLevel&&) = default;
+  RTreeLevel& operator=(RTreeLevel&&) = default;
+  ~RTreeLevel() = default;
+
+  explicit RTreeLevel(
+      size_t branchSize,
+      std::vector<float> minXs,
+      std::vector<float> minYs,
+      std::vector<float> maxXs,
+      std::vector<float> maxYs)
+      : branchSize_{branchSize},
+        minXs_(std::move(minXs)),
+        minYs_(std::move(minYs)),
+        maxXs_(std::move(maxXs)),
+        maxYs_(std::move(maxYs)) {}
+
+  /// Returns the internal indices of all envelopes that probeEnv intersects.
+  /// Order of the returned indices is an implementation detail and cannot be
+  /// relied upon.
+  /// This does not do a short-circuit bounds check: the caller should do that
+  /// first.
+  std::vector<size_t> query(
+      const Envelope& queryEnv,
+      const std::vector<size_t>& branchIndices) const;
+
+  size_t size() const {
+    return minXs_.size();
+  }
+
+ private:
+  size_t branchSize_{};
+  Envelope bounds_;
+  std::vector<float> minXs_{};
+  std::vector<float> minYs_{};
+  std::vector<float> maxXs_{};
+  std::vector<float> maxYs_{};
+};
+
+/// A spatial index for a set of geometries. The index only cares about the
+/// envelopes of the geometries, and an index into the geometries (not stored in
+/// SpatialIndex).
+///
+/// The contract is that SpatialIndex::probe returns the indices of all
+/// envelopes that probeEnv intersects. The form of the index is an
+/// implementation detail. The order of the returned indicies is an
+/// implementation detail.
+class SpatialIndex {
+ public:
+  SpatialIndex(const SpatialIndex&) = delete;
+  SpatialIndex& operator=(const SpatialIndex&) = delete;
+
+  SpatialIndex() = default;
+  SpatialIndex(SpatialIndex&&) = default;
+  SpatialIndex& operator=(SpatialIndex&&) = default;
+  ~SpatialIndex() = default;
+
+  static const uint32_t kDefaultRTreeBranchSize = 32;
+
+  /// Constructs a spatial index from envelopes contained with `bounds`.
+  /// `bounds` must contain all envelopes in `envelopes`, otherwise the
+  /// an assertio will fail.  Envelopes should not contain NaN coordinates.
+  explicit SpatialIndex(
+      Envelope bounds,
+      std::vector<Envelope> envelopes,
+      uint32_t branchSize = kDefaultRTreeBranchSize);
+
+  /// Returns the row indices of all envelopes that probeEnv intersects.
+  /// Order of the returned indices is an implementation detail and cannot be
+  /// relied upon.
+  std::vector<vector_size_t> query(const Envelope& queryEnv) const;
+
+  /// Returns the envelope of the all envelopes in the index.
+  /// The returned envelope will have index = -1.
+  Envelope bounds() const;
+
+ private:
+  uint32_t branchSize_ = kDefaultRTreeBranchSize;
+
+  Envelope bounds_ = Envelope::empty();
+  std::vector<RTreeLevel> levels_{};
+  std::vector<vector_size_t> rowIndices_{};
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/SpatialJoinBuild.cpp b/velox/exec/SpatialJoinBuild.cpp
index 240e3ba6854..238c9ba7b5b 100644
--- a/velox/exec/SpatialJoinBuild.cpp
+++ b/velox/exec/SpatialJoinBuild.cpp
@@ -13,30 +13,39 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #include "velox/exec/SpatialJoinBuild.h"
+#include <limits>
+#include "velox/common/geospatial/GeometryConstants.h"
+#ifdef VELOX_ENABLE_GEO
+#include "velox/common/geospatial/GeometrySerde.h"
+#endif
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/Task.h"
 
 namespace facebook::velox::exec {
 
-void SpatialJoinBridge::setData(std::vector<RowVectorPtr> buildVectors) {
+using velox::common::geospatial::GeometrySerializationType;
+
+void SpatialJoinBridge::setData(SpatialBuildResult buildResult) {
   std::vector<ContinuePromise> promises;
   {
     std::lock_guard<std::mutex> l(mutex_);
-    VELOX_CHECK(!buildVectors_.has_value(), "setData must be called only once");
-    buildVectors_ = std::move(buildVectors);
+    VELOX_CHECK(!buildResult_.has_value(), "setData must be called only once");
+    buildResult_ = std::move(buildResult);
     promises = std::move(promises_);
   }
   notify(std::move(promises));
 }
 
-std::optional<std::vector<RowVectorPtr>> SpatialJoinBridge::dataOrFuture(
+std::optional<SpatialBuildResult> SpatialJoinBridge::dataOrFuture(
     ContinueFuture* future) {
   std::lock_guard<std::mutex> l(mutex_);
   VELOX_CHECK(!cancelled_, "Getting data after the build side is aborted");
-  if (buildVectors_.has_value()) {
-    return buildVectors_;
+  if (buildResult_.has_value()) {
+    return buildResult_.value();
   }
-  promises_.emplace_back("SpatialJoinBridge::tableOrFuture");
+  promises_.emplace_back("SpatialJoinBridge::dataOrFuture");
   *future = promises_.back().getSemiFuture();
   return std::nullopt;
 }
@@ -50,7 +59,20 @@ SpatialJoinBuild::SpatialJoinBuild(
           nullptr,
           operatorId,
           joinNode->id(),
-          "SpatialJoinBuild") {}
+          OperatorType::kSpatialJoinBuild) {
+  const auto& buildType = joinNode->rightNode()->outputType();
+  buildGeometryChannel_ =
+      buildType->getChildIdx(joinNode->buildGeometry()->name());
+  VELOX_CHECK_EQ(
+      buildType->childAt(buildGeometryChannel_),
+      joinNode->buildGeometry()->type());
+  if (joinNode->radius().has_value()) {
+    auto radiusVar = joinNode->radius().value();
+    uint32_t radiusChannel = buildType->getChildIdx(radiusVar->name());
+    VELOX_CHECK_EQ(buildType->childAt(radiusChannel), radiusVar->type());
+    radiusChannel_ = radiusChannel;
+  }
+}
 
 void SpatialJoinBuild::addInput(RowVectorPtr input) {
   if (input->size() > 0) {
@@ -106,6 +128,88 @@ std::vector<RowVectorPtr> SpatialJoinBuild::mergeDataVectors() const {
   return merged;
 }
 
+Envelope SpatialJoinBuild::readEnvelope(
+    const StringView& geometryBytes,
+    double radius) {
+#ifdef VELOX_ENABLE_GEO
+  radius = std::max(radius, 0.0);
+  auto geosEnvelope =
+      common::geospatial::GeometryDeserializer::deserializeEnvelope(
+          geometryBytes);
+  if (geosEnvelope->isNull()) {
+    return Envelope::empty();
+  } else {
+    return Envelope::from(
+        geosEnvelope->getMinX() - radius,
+        geosEnvelope->getMinY() - radius,
+        geosEnvelope->getMaxX() + radius,
+        geosEnvelope->getMaxY() + radius);
+  }
+#else
+  // When VELOX_ENABLE_GEO is not set, return an envelope of infinite area
+  // to ensure all geometries are considered for spatial join
+  return Envelope::from(
+      -std::numeric_limits<double>::infinity(),
+      -std::numeric_limits<double>::infinity(),
+      std::numeric_limits<double>::infinity(),
+      std::numeric_limits<double>::infinity());
+#endif
+}
+
+SpatialIndex SpatialJoinBuild::buildSpatialIndex(
+    const std::vector<RowVectorPtr>& data,
+    column_index_t geometryIdx,
+    std::optional<column_index_t> radiusIdx) {
+  size_t numRows = 0;
+  for (auto& vector : data) {
+    numRows += vector->size();
+  }
+  std::vector<Envelope> envelopes;
+  // TODO: Chunk the data to avoid allocating a large vector.
+  envelopes.reserve(numRows);
+
+  DecodedVector radiusCol;
+  DecodedVector geometryCol;
+  vector_size_t offset = 0;
+  Envelope bounds = Envelope::empty();
+
+  for (auto& vector : data) {
+    const auto& rawGeometryCol =
+        vector->childAt(geometryIdx)->asChecked<SimpleVector<StringView>>();
+    geometryCol.decode(*rawGeometryCol);
+
+    auto constantZero = velox::BaseVector::createConstant(
+        velox::DOUBLE(), 0.0, vector->size(), pool());
+    if (radiusIdx.has_value()) {
+      const auto& rawRadiusCol =
+          vector->childAt(radiusIdx.value())->asChecked<SimpleVector<double>>();
+      radiusCol.decode(*rawRadiusCol);
+    } else {
+      radiusCol.decode(*constantZero);
+    }
+
+    // TODO: Make a selectivity vector based on nulls and use for DecodedVector.
+    for (vector_size_t i = 0; i < vector->size(); ++i) {
+      if (geometryCol.isNullAt(i) || radiusCol.isNullAt(i)) {
+        // If geometry or radius is null, it will not match the predicate and so
+        // we should skip the envelope.
+        continue;
+      }
+      double radius = radiusCol.valueAt<double>(i);
+      const StringView geometryBytes = geometryCol.valueAt<StringView>(i);
+      Envelope envelope = SpatialJoinBuild::readEnvelope(geometryBytes, radius);
+      if (FOLLY_UNLIKELY(envelope.isEmpty())) {
+        continue;
+      }
+      envelope.rowIndex = offset + geometryCol.index(i);
+      bounds.merge(envelope);
+      envelopes.push_back(std::move(envelope));
+    }
+    offset += vector->size();
+  }
+  return SpatialIndex(std::move(bounds), std::move(envelopes));
+}
+
 void SpatialJoinBuild::noMoreInput() {
   Operator::noMoreInput();
   std::vector<ContinuePromise> promises;
@@ -142,10 +246,17 @@ void SpatialJoinBuild::noMoreInput() {
   }
 
   dataVectors_ = mergeDataVectors();
+  SpatialIndex spatialIndex =
+      buildSpatialIndex(dataVectors_, buildGeometryChannel_, radiusChannel_);
+  SpatialBuildResult buildResult;
+  buildResult.spatialIndex =
+      std::make_shared<SpatialIndex>(std::move(spatialIndex));
+  buildResult.buildVectors = std::move(dataVectors_);
+
   operatorCtx_->task()
       ->getSpatialJoinBridge(
           operatorCtx_->driverCtx()->splitGroupId, planNodeId())
-      ->setData(std::move(dataVectors_));
+      ->setData(std::move(buildResult));
 }
 
 bool SpatialJoinBuild::isFinished() {
diff --git a/velox/exec/SpatialJoinBuild.h b/velox/exec/SpatialJoinBuild.h
index bea8fdd354b..daceada9f29 100644
--- a/velox/exec/SpatialJoinBuild.h
+++ b/velox/exec/SpatialJoinBuild.h
@@ -18,17 +18,23 @@
 #include "velox/core/PlanNode.h"
 #include "velox/exec/JoinBridge.h"
 #include "velox/exec/Operator.h"
+#include "velox/exec/SpatialIndex.h"
 
 namespace facebook::velox::exec {
 
+struct SpatialBuildResult {
+  std::vector<RowVectorPtr> buildVectors;
+  std::shared_ptr<SpatialIndex> spatialIndex;
+};
+
 class SpatialJoinBridge : public JoinBridge {
  public:
-  void setData(std::vector<RowVectorPtr> buildVectors);
+  void setData(SpatialBuildResult buildResult);
 
-  std::optional<std::vector<RowVectorPtr>> dataOrFuture(ContinueFuture* future);
+  std::optional<SpatialBuildResult> dataOrFuture(ContinueFuture* future);
 
  private:
-  std::optional<std::vector<RowVectorPtr>> buildVectors_;
+  std::optional<SpatialBuildResult> buildResult_;
 };
 
 class SpatialJoinBuild : public Operator {
@@ -59,11 +65,25 @@ class SpatialJoinBuild : public Operator {
     Operator::close();
   }
 
-  std::vector<RowVectorPtr> mergeDataVectors() const;
+  static Envelope readEnvelope(
+      const StringView& serializedGeometry,
+      double radius);
 
  private:
+  std::vector<RowVectorPtr> mergeDataVectors() const;
+
+  SpatialIndex buildSpatialIndex(
+      const std::vector<RowVectorPtr>& data,
+      column_index_t geometryIdx,
+      std::optional<column_index_t> radiusIdx);
+
   std::vector<RowVectorPtr> dataVectors_;
 
+  // Channel of geometry variable used to build spatial index
+  column_index_t buildGeometryChannel_;
+  // Channel (if set) of radius variable used to build spatial index
+  std::optional<column_index_t> radiusChannel_{};
+
   // Future for synchronizing with other Drivers of the same pipeline. All build
   // Drivers must be completed before making data available for the probe side.
   ContinueFuture future_{ContinueFuture::makeEmpty()};
diff --git a/velox/exec/SpatialJoinProbe.cpp b/velox/exec/SpatialJoinProbe.cpp
index bc49d24cba4..7fbdc6f519d 100644
--- a/velox/exec/SpatialJoinProbe.cpp
+++ b/velox/exec/SpatialJoinProbe.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 #include "velox/exec/SpatialJoinProbe.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/SpatialJoinBuild.h"
 #include "velox/exec/Task.h"
@@ -42,6 +43,107 @@ std::vector<IdentityProjection> extractProjections(
 
 } // namespace
 
+//////////////////
+// OUTPUT BUILDER
+
+void SpatialJoinOutputBuilder::initializeOutput(
+    const RowVectorPtr& input,
+    memory::MemoryPool* pool) {
+  if (output_ == nullptr) {
+    output_ =
+        BaseVector::create<RowVector>(outputType_, outputBatchSize_, pool);
+  } else {
+    VectorPtr outputVector = std::move(output_);
+    BaseVector::prepareForReuse(outputVector, outputBatchSize_);
+    output_ = std::static_pointer_cast<RowVector>(outputVector);
+  }
+  probeOutputIndices_ = allocateIndices(outputBatchSize_, pool);
+  rawProbeOutputIndices_ = probeOutputIndices_->asMutable<vector_size_t>();
+
+  // Add probe side projections as dictionary vectors
+  for (const auto& projection : probeProjections_) {
+    output_->childAt(projection.outputChannel) = wrapChild(
+        outputBatchSize_,
+        probeOutputIndices_,
+        input->childAt(projection.inputChannel));
+  }
+
+  // Add build side projections as uninitialized vectors
+  for (const auto& projection : buildProjections_) {
+    auto child = output_->childAt(projection.outputChannel);
+    if (child == nullptr) {
+      child = BaseVector::create(
+          outputType_->childAt(projection.outputChannel),
+          outputBatchSize_,
+          operatorCtx_.pool());
+    }
+  }
+}
+
+void SpatialJoinOutputBuilder::addOutputRow(
+    vector_size_t probeRow,
+    vector_size_t buildRow) {
+  VELOX_CHECK_NOT_NULL(probeOutputIndices_);
+  // Probe side is always a dictionary; just populate the index.
+  rawProbeOutputIndices_[outputRow_] = probeRow;
+
+  // For the build side, we accumulate the ranges to copy, then copy all of
+  // them at once. Consecutive records are copied in one memcpy.
+  if (!buildCopyRanges_.empty() &&
+      (buildCopyRanges_.back().sourceIndex + buildCopyRanges_.back().count) ==
+          buildRow) {
+    ++buildCopyRanges_.back().count;
+  } else {
+    buildCopyRanges_.push_back({buildRow, outputRow_, 1});
+  }
+  ++outputRow_;
+}
+
+void SpatialJoinOutputBuilder::copyBuildValues(
+    const RowVectorPtr& buildVector) {
+  if (buildCopyRanges_.empty()) {
+    return;
+  }
+
+  VELOX_CHECK_NOT_NULL(output_);
+
+  for (const auto& projection : buildProjections_) {
+    const auto& buildChild = buildVector->childAt(projection.inputChannel);
+    const auto& outputChild = output_->childAt(projection.outputChannel);
+    outputChild->copyRanges(buildChild.get(), buildCopyRanges_);
+  }
+  buildCopyRanges_.clear();
+}
+
+void SpatialJoinOutputBuilder::addProbeMismatchRow(vector_size_t probeRow) {
+  VELOX_CHECK_NOT_NULL(output_);
+
+  // Probe side is always a dictionary; just populate the index.
+  rawProbeOutputIndices_[outputRow_] = probeRow;
+
+  // Null out build projections.
+  for (const auto& projection : buildProjections_) {
+    const auto& outputChild = output_->childAt(projection.outputChannel);
+    outputChild->setNull(outputRow_, true);
+  }
+  ++outputRow_;
+}
+
+RowVectorPtr SpatialJoinOutputBuilder::takeOutput() {
+  VELOX_CHECK(buildCopyRanges_.empty());
+  if (outputRow_ == 0 || !output_) {
+    return nullptr;
+  }
+  RowVectorPtr output = std::move(output_);
+  output->resize(outputRow_);
+  output_ = nullptr;
+  outputRow_ = 0;
+  return output;
+}
+
+////////////////////
+// SpatialJoinProbe
+
 SpatialJoinProbe::SpatialJoinProbe(
     int32_t operatorId,
     DriverCtx* driverCtx,
@@ -51,25 +153,42 @@ SpatialJoinProbe::SpatialJoinProbe(
           joinNode->outputType(),
           operatorId,
           joinNode->id(),
-          "SpatialJoinProbe"),
+          OperatorType::kSpatialJoinProbe),
       joinType_(joinNode->joinType()),
       outputBatchSize_{outputBatchRows()},
-      joinNode_(joinNode) {
-  auto probeType = joinNode_->sources()[0]->outputType();
-  auto buildType = joinNode_->sources()[1]->outputType();
+      joinNode_(joinNode),
+      buildProjections_(extractProjections(
+          joinNode_->rightNode()->outputType(),
+          outputType_)),
+      outputBuilder_{
+          outputBatchSize_,
+          outputType_,
+          extractProjections(
+              joinNode_->leftNode()->outputType(),
+              outputType_), // these are the identity Projections
+          buildProjections_,
+          *operatorCtx_} {
+  auto probeType = joinNode_->leftNode()->outputType();
   identityProjections_ = extractProjections(probeType, outputType_);
-  buildProjections_ = extractProjections(buildType, outputType_);
+  probeGeometryChannel_ =
+      probeType->getChildIdx(joinNode_->probeGeometry()->name());
+  VELOX_CHECK_EQ(
+      probeType->childAt(probeGeometryChannel_),
+      joinNode_->probeGeometry()->type());
 }
 
+/////////
+// SETUP
+
 void SpatialJoinProbe::initialize() {
   Operator::initialize();
 
-  VELOX_CHECK(joinNode_ != nullptr);
+  VELOX_CHECK_NOT_NULL(joinNode_);
   if (joinNode_->joinCondition() != nullptr) {
     initializeFilter(
         joinNode_->joinCondition(),
-        joinNode_->sources()[0]->outputType(),
-        joinNode_->sources()[1]->outputType());
+        joinNode_->leftNode()->outputType(),
+        joinNode_->rightNode()->outputType());
   }
 
   joinNode_.reset();
@@ -151,32 +270,15 @@ void SpatialJoinProbe::close() {
     joinCondition_->clear();
   }
   buildVectors_.reset();
+  spatialIndex_.reset();
   Operator::close();
 }
 
-void SpatialJoinProbe::addInput(RowVectorPtr input) {
-  VELOX_CHECK_NULL(input_);
-
-  // In getOutput(), we are going to wrap input in dictionaries a few rows at a
-  // time. Since lazy vectors cannot be wrapped in different dictionaries, we
-  // are going to load them here.
-  for (auto& child : input->children()) {
-    child->loadedVector();
-  }
-  input_ = std::move(input);
-  if (input_->size() > 0) {
-    probeSideEmpty_ = false;
-  }
-  VELOX_CHECK_EQ(buildIndex_, 0);
-}
-
 void SpatialJoinProbe::noMoreInput() {
   Operator::noMoreInput();
-  if (state_ != ProbeOperatorState::kRunning || input_ != nullptr) {
-    return;
+  if (state_ == ProbeOperatorState::kRunning && input_ == nullptr) {
+    setState(ProbeOperatorState::kFinish);
   }
-  setState(ProbeOperatorState::kFinish);
-  return;
 }
 
 bool SpatialJoinProbe::getBuildData(ContinueFuture* future) {
@@ -191,15 +293,56 @@ bool SpatialJoinProbe::getBuildData(ContinueFuture* future) {
     return false;
   }
 
-  buildVectors_ = std::move(buildData);
+  buildVectors_ = buildData.value().buildVectors;
+  spatialIndex_ = buildData.value().spatialIndex;
   return true;
 }
 
+void SpatialJoinProbe::checkStateTransition(ProbeOperatorState state) {
+  VELOX_CHECK_NE(state_, state);
+  switch (state) {
+    case ProbeOperatorState::kRunning:
+      VELOX_CHECK_EQ(state_, ProbeOperatorState::kWaitForBuild);
+      break;
+    case ProbeOperatorState::kWaitForBuild:
+      [[fallthrough]];
+    case ProbeOperatorState::kFinish:
+      VELOX_CHECK_EQ(state_, ProbeOperatorState::kRunning);
+      break;
+    default:
+      VELOX_UNREACHABLE(probeOperatorStateName(state_));
+      break;
+  }
+}
+
+////////////////
+// INPUT/OUTPUT
+
+void SpatialJoinProbe::addInput(RowVectorPtr input) {
+  VELOX_CHECK_NULL(input_);
+  VELOX_CHECK_EQ(probeRow_, 0);
+  VELOX_CHECK(!probeHasMatch_);
+  VELOX_CHECK_EQ(buildVectorIndex_, 0);
+  VELOX_CHECK_EQ(candidateIndex_, 0);
+
+  // In getOutput(), we are going to wrap input in dictionaries a few rows at a
+  // time. Since lazy vectors cannot be wrapped in different dictionaries, we
+  // are going to load them here.
+  for (auto& child : input->children()) {
+    child->loadedVector();
+  }
+  input_ = std::move(input);
+  decodedGeometryCol_.decode(*input_->childAt(probeGeometryChannel_)
+                                  ->asChecked<SimpleVector<StringView>>());
+  ++probeCount_;
+}
+
 RowVectorPtr SpatialJoinProbe::getOutput() {
   if (state_ == ProbeOperatorState::kFinish ||
       state_ == ProbeOperatorState::kWaitForPeers) {
     return nullptr;
   }
+
   RowVectorPtr output{nullptr};
   while (output == nullptr) {
     // Need more input.
@@ -207,155 +350,156 @@ RowVectorPtr SpatialJoinProbe::getOutput() {
       break;
     }
 
+    // If the task owning this operator isn't running, there is no point
+    // to continue executing this procedure, which may be long in degenerate
+    // cases. Exit the working loop and let the Driver handle exiting
+    // gracefully in its own loop.
+    if (!operatorCtx_->task()->isRunning()) {
+      break;
+    }
+
+    if (shouldYield()) {
+      break;
+    }
+
     // Generate actual join output by processing probe and build matches, and
     // probe mismaches (for left joins).
     output = generateOutput();
   }
+
+  if (output != nullptr) {
+    ++outputCount_;
+  }
   return output;
 }
 
 RowVectorPtr SpatialJoinProbe::generateOutput() {
-  // If addToOutput() returns false, output_ is filled. Need to produce it.
-  if (!addToOutput()) {
-    VELOX_CHECK_GT(output_->size(), 0);
-    return std::move(output_);
+  VELOX_CHECK_NOT_NULL(input_);
+  VELOX_CHECK_GT(input_->size(), probeRow_);
+  outputBuilder_.initializeOutput(input_, pool());
+
+  while (!isOutputDone()) {
+    // Fill output_ with the results from one row.  This may produce too
+    // much output and only partially complete.  If so, the next time we
+    // call this we'll get the next chunk.
+    //
+    // addProbeRowOutput is responsible for advancing probeRow_.
+    addProbeRowOutput();
   }
 
-  // Try to advance the probe cursor; call finish if no more probe input.
-  if (advanceProbe()) {
+  // If we've exhausted the input, release it.
+  if (probeRow_ >= input_->size()) {
     finishProbeInput();
-    if (numOutputRows_ == 0) {
-      // output_ can only be re-used across probe rows within the same input_.
-      // Here we have to abandon the emtpy non-null output_ before we advance to
-      // the next probe input.
-      output_ = nullptr;
-    }
   }
 
-  if (!readyToProduceOutput()) {
-    return nullptr;
-  }
-
-  output_->resize(numOutputRows_);
-  return std::move(output_);
+  return outputBuilder_.takeOutput();
 }
 
-bool SpatialJoinProbe::readyToProduceOutput() {
-  if (!output_ || numOutputRows_ == 0) {
-    return false;
-  }
+// Return true if adding output stops early because output is full.
+void SpatialJoinProbe::addProbeRowOutput() {
+  VELOX_CHECK(buildVectors_.has_value());
+  VELOX_CHECK(!outputBuilder_.isOutputFull());
 
-  // If the input_ has no remaining rows or the output_ is fully filled,
-  // it's right time for output.
-  return !input_ || numOutputRows_ >= outputBatchSize_;
-}
-
-bool SpatialJoinProbe::advanceProbe() {
-  if (hasProbedAllBuildData()) {
-    probeRow_ += 1;
-    probeRowHasMatch_ = false;
-    buildIndex_ = 0;
-
-    // If we finished processing the probe side.
-    if (probeRow_ >= input_->size()) {
-      return true;
-    }
+  // Find the candidates for each probe row from the spatial index.  Only do
+  // this at the start for each row.
+  if (buildVectorIndex_ == 0 && candidateIndex_ == 0) {
+    candidateBuildRows_ = querySpatialIndex();
   }
-  return false;
-}
 
-bool SpatialJoinProbe::addToOutput() {
-  VELOX_CHECK_NOT_NULL(input_);
-  prepareOutput();
-
-  while (!hasProbedAllBuildData()) {
-    const auto& currentBuild = buildVectors_.value()[buildIndex_];
-
-    // Empty build vector; move to the next.
-    if (currentBuild->size() == 0) {
-      ++buildIndex_;
-      buildRow_ = 0;
-      continue;
-    }
-
-    // Only re-calculate the filter if we have a new build vector.
-    if (buildRow_ == 0) {
-      evaluateSpatialJoinFilter(currentBuild);
+  while (!isProbeRowDone()) {
+    addBuildVectorOutput(buildVectors_.value()[buildVectorIndex_]);
+    if (outputBuilder_.isOutputFull()) {
+      // If full, don't advance buildVectorIndex_ because we may not have
+      // exhausted the current vector.  Return instead of breaking so that we
+      // can add a mismatch row later if necessary.
+      return;
     }
+    advanceBuildVector();
+  }
 
-    // Iterate over the filter results. For each match, add an output record.
-    for (vector_size_t i = buildRow_; i < decodedFilterResult_.size(); ++i) {
-      if (!isSpatialJoinConditionMatch(i)) {
-        continue;
-      }
+  // Now that we have finished the probe row, check if we need to add a probe
+  // mismatch record.
+  if (!probeHasMatch_ && needsProbeMismatch(joinType_)) {
+    outputBuilder_.addProbeMismatchRow(probeRow_);
+  }
+  // Advance here instead of the loop in generateOutput so that early return on
+  // full doesn't advance the probe.
+  advanceProbeRow();
+}
 
-      addOutputRow(i);
-      ++numOutputRows_;
-      probeRowHasMatch_ = true;
+void SpatialJoinProbe::addBuildVectorOutput(const RowVectorPtr& buildVector) {
+  if (FOLLY_UNLIKELY(needsFilterEvaluated_)) {
+    // Evaluate join filter for the whole vector just once.
+    evaluateJoinFilter(buildVector);
+    needsFilterEvaluated_ = false;
+  }
 
-      // If the buffer is full, save state and produce it as output.
-      if (numOutputRows_ == outputBatchSize_) {
-        buildRow_ = i + 1;
-        copyBuildValues(currentBuild);
-        return false;
-      }
+  // Start where we left off: after the last buildRow_ that was processed.
+  while (!isBuildVectorDone(buildVector)) {
+    vector_size_t buildRow = relativeBuildRow(candidateIndex_);
+    if (isJoinConditionMatch(candidateIndex_)) {
+      outputBuilder_.addOutputRow(probeRow_, buildRow);
+      probeHasMatch_ = true;
     }
 
-    // Before moving to the next build vector, copy the needed ranges.
-    copyBuildValues(currentBuild);
-    ++buildIndex_;
-    buildRow_ = 0;
+    // Advance candidateIndex_ even if full, since we're finished with this row.
+    ++candidateIndex_;
   }
 
-  // Check if the current probed row needs to be added as a mismatch (for left
-  // and full outer joins).
-  checkProbeMismatchRow();
-
-  // Signals that all input has been generated for the probeRow and build
-  // vectors; safe to move to the next probe record.
-  return true;
+  // Since we are copying from the current buildVector, we must copy here.
+  outputBuilder_.copyBuildValues(buildVector);
 }
 
-void SpatialJoinProbe::prepareOutput() {
-  if (output_ != nullptr) {
-    return;
+std::vector<int32_t> SpatialJoinProbe::querySpatialIndex() {
+  VELOX_CHECK(spatialIndex_.has_value());
+  VELOX_CHECK_NOT_NULL(spatialIndex_.value());
+
+  if (decodedGeometryCol_.isNullAt(probeRow_)) {
+    return std::vector<int32_t>{};
   }
 
-  std::vector<VectorPtr> localColumns(outputType_->size());
+  // Always apply radius to build side, not probe side.
+  Envelope envelope = SpatialJoinBuild::readEnvelope(
+      decodedGeometryCol_.valueAt<StringView>(probeRow_), 0 /* radius */);
+  std::vector<int32_t> candidates = spatialIndex_.value()->query(envelope);
+  std::sort(candidates.begin(), candidates.end());
 
-  probeOutputIndices_ = allocateIndices(outputBatchSize_, pool());
-  rawProbeOutputIndices_ = probeOutputIndices_->asMutable<vector_size_t>();
+  return candidates;
+}
 
-  for (const auto& projection : identityProjections_) {
-    localColumns[projection.outputChannel] = BaseVector::wrapInDictionary(
-        {},
-        probeOutputIndices_,
-        outputBatchSize_,
-        input_->childAt(projection.inputChannel));
+BufferPtr SpatialJoinProbe::makeBuildVectorIndices(vector_size_t vectorSize) {
+  // Find the slice of candidates that are in this build vector.
+  vector_size_t endIndex = candidateIndex_;
+  for (; endIndex < candidateBuildRows_.size(); ++endIndex) {
+    if (relativeBuildRow(endIndex) >= vectorSize) {
+      break;
+    }
   }
 
-  // For other join types, add build side projections
-  for (const auto& projection : buildProjections_) {
-    localColumns[projection.outputChannel] = BaseVector::create(
-        outputType_->childAt(projection.outputChannel),
-        outputBatchSize_,
-        operatorCtx_->pool());
+  // Make an index vector to fit the candidates.  Populate each entry with its
+  // relative build row.
+  vector_size_t indexCount =
+      static_cast<vector_size_t>(endIndex - candidateIndex_);
+  auto rowIndices = allocateIndices(indexCount, operatorCtx_->pool());
+  auto rawIndices = rowIndices->asMutable<vector_size_t>();
+  for (vector_size_t idx = 0; idx < indexCount; ++idx) {
+    rawIndices[idx] = relativeBuildRow(idx + candidateIndex_);
   }
 
-  numOutputRows_ = 0;
-  output_ = std::make_shared<RowVector>(
-      pool(), outputType_, nullptr, outputBatchSize_, std::move(localColumns));
+  return rowIndices;
 }
 
-void SpatialJoinProbe::evaluateSpatialJoinFilter(
-    const RowVectorPtr& buildVector) {
-  // First step to process is to get a batch so we can evaluate the join
-  // filter.
-  auto filterInput = getNextCrossProductBatch(
+void SpatialJoinProbe::evaluateJoinFilter(const RowVectorPtr& buildVector) {
+  // Get the indices of the rows in the build vector that are candidates.
+  auto candidateRowsBuffer = makeBuildVectorIndices(buildVector->size());
+
+  // Now get the input for the spatial join filter, one row per candidate.
+  auto filterInput = getNextJoinBatch(
       buildVector,
       filterInputType_,
       filterProbeProjections_,
-      filterBuildProjections_);
+      filterBuildProjections_,
+      candidateRowsBuffer);
 
   if (filterInputRows_.size() != filterInput->size()) {
     filterInputRows_.resizeFill(filterInput->size(), true);
@@ -371,28 +515,28 @@ void SpatialJoinProbe::evaluateSpatialJoinFilter(
   decodedFilterResult_.decode(*filterOutput_, filterInputRows_);
 }
 
-RowVectorPtr SpatialJoinProbe::getNextCrossProductBatch(
+RowVectorPtr SpatialJoinProbe::getNextJoinBatch(
     const RowVectorPtr& buildVector,
     const RowTypePtr& outputType,
     const std::vector<IdentityProjection>& probeProjections,
-    const std::vector<IdentityProjection>& buildProjections) {
+    const std::vector<IdentityProjection>& buildProjections,
+    BufferPtr candidateRows) const {
   VELOX_CHECK_GT(buildVector->size(), 0);
+  // candidateRows is a buffer of vector_size_t indices into buildVector
+  const vector_size_t numOutputRows =
+      candidateRows->size() / sizeof(vector_size_t);
+  if (numOutputRows == 0) {
+    return RowVector::createEmpty(outputType, pool());
+  }
 
-  return genCrossProductMultipleBuildVectors(
-      buildVector, outputType, probeProjections, buildProjections);
-}
-
-RowVectorPtr SpatialJoinProbe::genCrossProductMultipleBuildVectors(
-    const RowVectorPtr& buildVector,
-    const RowTypePtr& outputType,
-    const std::vector<IdentityProjection>& probeProjections,
-    const std::vector<IdentityProjection>& buildProjections) {
   std::vector<VectorPtr> projectedChildren(outputType->size());
-  const vector_size_t numOutputRows = buildVector->size();
-
   // Project columns from the build side.
   projectChildren(
-      projectedChildren, buildVector, buildProjections, numOutputRows, nullptr);
+      projectedChildren,
+      buildVector,
+      buildProjections,
+      numOutputRows,
+      candidateRows);
 
   // Wrap projections from the probe side as constants.
   for (const auto [inputChannel, outputChannel] : probeProjections) {
@@ -404,68 +548,14 @@ RowVectorPtr SpatialJoinProbe::genCrossProductMultipleBuildVectors(
       pool(), outputType, nullptr, numOutputRows, std::move(projectedChildren));
 }
 
-void SpatialJoinProbe::addOutputRow(vector_size_t buildRow) {
-  // Probe side is always a dictionary; just populate the index.
-  rawProbeOutputIndices_[numOutputRows_] = probeRow_;
-
-  // For the build side, we accumulate the ranges to copy, then copy all of them
-  // at once. If records are consecutive and can have a single copy range run.
-  if (!buildCopyRanges_.empty() &&
-      (buildCopyRanges_.back().sourceIndex + buildCopyRanges_.back().count) ==
-          buildRow) {
-    ++buildCopyRanges_.back().count;
-  } else {
-    buildCopyRanges_.push_back({buildRow, numOutputRows_, 1});
-  }
-}
-
-void SpatialJoinProbe::copyBuildValues(const RowVectorPtr& buildVector) {
-  if (buildCopyRanges_.empty() || isLeftSemiProjectJoin(joinType_)) {
-    return;
-  }
-
-  for (const auto& projection : buildProjections_) {
-    const auto& buildChild = buildVector->childAt(projection.inputChannel);
-    const auto& outputChild = output_->childAt(projection.outputChannel);
-    outputChild->copyRanges(buildChild.get(), buildCopyRanges_);
-  }
-  buildCopyRanges_.clear();
-}
-
-void SpatialJoinProbe::checkProbeMismatchRow() {
-  // If we are processing the last batch of the build side, check if we need
-  // to add a probe mismatch record.
-  if (needsProbeMismatch(joinType_) && hasProbedAllBuildData() &&
-      !probeRowHasMatch_) {
-    prepareOutput();
-    addProbeMismatchRow();
-    ++numOutputRows_;
-  }
-}
-
-void SpatialJoinProbe::addProbeMismatchRow() {
-  // Probe side is always a dictionary; just populate the index.
-  rawProbeOutputIndices_[numOutputRows_] = probeRow_;
-
-  // Null out build projections.
-  for (const auto& projection : buildProjections_) {
-    const auto& outputChild = output_->childAt(projection.outputChannel);
-    outputChild->setNull(numOutputRows_, true);
-  }
-}
-
 void SpatialJoinProbe::finishProbeInput() {
   VELOX_CHECK_NOT_NULL(input_);
   input_.reset();
-  buildIndex_ = 0;
   probeRow_ = 0;
 
-  if (!noMoreInput_) {
-    return;
+  if (noMoreInput_) {
+    setState(ProbeOperatorState::kFinish);
   }
-
-  setState(ProbeOperatorState::kFinish);
-  return;
 }
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/SpatialJoinProbe.h b/velox/exec/SpatialJoinProbe.h
index 54b2cbe701d..e9fc2eea13a 100644
--- a/velox/exec/SpatialJoinProbe.h
+++ b/velox/exec/SpatialJoinProbe.h
@@ -18,16 +18,71 @@
 #include "velox/core/PlanNode.h"
 #include "velox/exec/Operator.h"
 #include "velox/exec/ProbeOperatorState.h"
+#include "velox/exec/SpatialIndex.h"
 
 namespace facebook::velox::exec {
 
+class SpatialJoinOutputBuilder {
+ public:
+  SpatialJoinOutputBuilder(
+      vector_size_t outputBatchSize,
+      RowTypePtr outputType,
+      std::vector<IdentityProjection> probeProjections,
+      std::vector<IdentityProjection> buildProjections,
+      const OperatorCtx& operatorCtx)
+      : outputBatchSize_{outputBatchSize},
+        outputType_{std::move(outputType)},
+        probeProjections_{std::move(probeProjections)},
+        buildProjections_{std::move(buildProjections)},
+        operatorCtx_{operatorCtx} {
+    VELOX_CHECK_GT(outputBatchSize_, 0);
+  }
+
+  void initializeOutput(const RowVectorPtr& input, memory::MemoryPool* pool);
+
+  bool isOutputFull() const {
+    return outputRow_ >= outputBatchSize_;
+  }
+
+  void addOutputRow(vector_size_t probeRow, vector_size_t buildRow);
+
+  /// Checks if it is required to add a probe mismatch row, and does it if
+  /// needed. The caller needs to ensure there is available space in `output_`
+  /// for the new record, which has nulled out build projections.
+  void addProbeMismatchRow(vector_size_t probeRow);
+
+  void copyBuildValues(const RowVectorPtr& buildVector);
+
+  RowVectorPtr takeOutput();
+
+ private:
+  // Initialization parameters
+  const vector_size_t outputBatchSize_;
+  const RowTypePtr outputType_;
+  const std::vector<IdentityProjection> probeProjections_;
+  const std::vector<IdentityProjection> buildProjections_;
+  const OperatorCtx& operatorCtx_;
+
+  // Output state
+  RowVectorPtr output_;
+  vector_size_t outputRow_{0};
+  // Dictionary indices for probe columns for output vector.
+  BufferPtr probeOutputIndices_;
+  // Mutable pointer to probeOutputIndices_
+  vector_size_t* rawProbeOutputIndices_{};
+
+  // Stores the ranges of build values to be copied to the output vector (we
+  // batch them and copy once, instead of copying them row-by-row).
+  std::vector<BaseVector::CopyRange> buildCopyRanges_{};
+};
+
 /// Implements a Spatial Join between records from the probe (input_)
-/// and build (SpatialJoinBridge) sides. It supports inner, left, right and
-/// full outer joins.
+/// and build (SpatialJoinBridge) sides. It supports inner and left joins.
 ///
 /// This class is designed to evaluate spatial join conditions (e.g.
-/// ST_INTERSECTS, ST_CONTAINS, ST_WITHIN) between geometric data types. It can
-/// also implement spatial cross-join semantics if joinCondition is nullptr.
+/// ST_INTERSECTS, ST_CONTAINS, ST_WITHIN) between geometric data types. It
+/// can also implement spatial cross-join semantics if joinCondition is
+/// nullptr.
 ///
 /// The output follows the order of the probe side rows (for inner and left
 /// joins). All build vectors are materialized upfront (check buildVectors_),
@@ -39,11 +94,14 @@ namespace facebook::velox::exec {
 /// 1. Materialize a cross-product batch across probe and build.
 /// 2. Evaluate the spatial join condition.
 /// 3. Add spatial matches to the output.
-/// 4. Once all build vectors are processed for a particular probe row, check if
+/// 4. Once all build vectors are processed for a particular probe row, check
+/// if
 ///    a probe mismatch is needed (only for left and full outer joins).
-/// 5. Once all probe and build inputs are processed, check if build mismatches
+/// 5. Once all probe and build inputs are processed, check if build
+/// mismatches
 ///    are needed (only for right and full outer joins).
-/// 6. If so, signal other peer operators; only a single operator instance will
+/// 6. If so, signal other peer operators; only a single operator instance
+/// will
 ///    collect all build matches at the end, and emit any records that haven't
 ///    been matched by any of the peers.
 ///
@@ -79,6 +137,13 @@ class SpatialJoinProbe : public Operator {
   void close() override;
 
  private:
+  void checkStateTransition(ProbeOperatorState state);
+
+  void setState(ProbeOperatorState state) {
+    checkStateTransition(state);
+    state_ = state;
+  }
+
   // Initialize spatial filter for evaluating spatial join conditions.
   void initializeFilter(
       const core::TypedExprPtr& filter,
@@ -91,94 +156,14 @@ class SpatialJoinProbe : public Operator {
   // `buildVectors_` before it can produce output.
   bool getBuildData(ContinueFuture* future);
 
-  // Generates output from spatial join matches between probe and build sides,
-  // as well as probe mismatches (for left and full outer joins). As much as
-  // possible, generates outputs `outputBatchSize_` records at a time, but
-  // batches may be smaller in some cases - outputs follow the probe side buffer
-  // boundaries.
+  // Produce as much output as possible for the current input.
   RowVectorPtr generateOutput();
 
-  // For non cross-join mode, the `output_` can be reused across multiple probe
-  // rows. If the input_ has remaining rows and the output_ is not fully filled,
-  // it returns false here.
-  bool readyToProduceOutput();
-
-  // Fill in joined output to `output_` by matching the current probeRow_ and
-  // successive build vectors (using getNextCrossProductBatch()). Stops when
-  // either all build vectors were matched for the current probeRow (returns
-  // true), or if the output is full (returns false). If it returns false, a
-  // valid vector with more than zero records will be available at `output_`;
-  // if it returns true, either nullptr or zero records may be placed at
-  // `output_`. Also if it returns true, it's the caller's responsibility to
-  // decide when to set `output_` size.
-  //
-  // Also updates `buildMatched_` if the build records that received a match, so
-  // that they can be used to implement right and full outer join semantic once
-  // all probe data has been processed.
-  bool addToOutput();
-
-  // Advances 'probeRow_' and resets required state information. Returns true
-  // if there is no more probe data to be processed in the current `input_`
-  // (and hence a new probe input is required). False otherwise.
-  bool advanceProbe();
-
-  // Ensures a new batch of records is available at `output_` and ready to
-  // receive rows. Batches have space for `outputBatchSize_`.
-  void prepareOutput();
-
-  // Evaluates the spatial joinCondition for a given build vector. This method
-  // sets `filterOutput_` and `decodedFilterResult_`, which will be ready to be
-  // used by `isSpatialJoinConditionMatch(buildRow)` below.
-  void evaluateSpatialJoinFilter(const RowVectorPtr& buildVector);
-
-  // Checks if the spatial join condition matched for a particular row.
-  bool isSpatialJoinConditionMatch(vector_size_t i) const {
-    return (
-        !decodedFilterResult_.isNullAt(i) &&
-        decodedFilterResult_.valueAt<bool>(i));
+  // Returns true if the input is exhausted or the output is full.
+  bool isOutputDone() const {
+    return probeRow_ >= input_->size() || outputBuilder_.isOutputFull();
   }
 
-  // Generates the next batch of a cross product between probe and build. It
-  // should be used as the entry point, and will internally delegate to one of
-  // the three functions below.
-  //
-  // Output projections can be specified so that this function can be used to
-  // generate both filter input and actual output (in case there is no join
-  // filter - cross join).
-  RowVectorPtr getNextCrossProductBatch(
-      const RowVectorPtr& buildVector,
-      const RowTypePtr& outputType,
-      const std::vector<IdentityProjection>& probeProjections,
-      const std::vector<IdentityProjection>& buildProjections);
-
-  // As a fallback, process the current probe row to as much build data as
-  // possible (probe row as constant, and flat copied data for build records).
-  RowVectorPtr genCrossProductMultipleBuildVectors(
-      const RowVectorPtr& buildVector,
-      const RowTypePtr& outputType,
-      const std::vector<IdentityProjection>& probeProjections,
-      const std::vector<IdentityProjection>& buildProjections);
-
-  // Add a single record to `output_` based on buildRow from buildVector, and
-  // the current probeRow and probe vector (input_). Probe side projections are
-  // zero-copy (dictionary indices), and build side projections are marked to be
-  // copied using `buildCopyRanges_`; they will be copied later on by
-  // `copyBuildValues()`.
-  void addOutputRow(vector_size_t buildRow);
-
-  // Copies the ranges from buildVector specified by `buildCopyRanges_` to
-  // `output_`, one projected column at a time. Clears buildCopyRanges_.
-  void copyBuildValues(const RowVectorPtr& buildVector);
-
-  // Checks if it is required to add a probe mismatch row, and does it if
-  // needed. The caller needs to ensure there is available space in `output_`
-  // for the new record, which has nulled out build projections.
-  void checkProbeMismatchRow();
-
-  // Add a probe mismatch (only for left/full outer joins). The record is based
-  // on the current probeRow and vector (input_) and build projections are null.
-  void addProbeMismatchRow();
-
   // Called when we are done processing the current probe batch, to signal we
   // are ready for the next one.
   //
@@ -186,118 +171,226 @@ class SpatialJoinProbe : public Operator {
   // change the operator state to signal peers.
   void finishProbeInput();
 
-  // Whether we have processed all build data for the current probe row (based
-  // on buildIndex_'s value).
-  bool hasProbedAllBuildData() const {
-    return (buildIndex_ >= buildVectors_.value().size());
-  }
+  // Add the output for a single probe row.  This will return early if the
+  // output vector is full.
+  void addProbeRowOutput();
 
-  // If build has a single vector, we can wrap probe and build batches into
-  // dictionaries and produce as many combinations of probe and build rows,
-  // until `numOutputRows_` is filled.
-  bool isSingleBuildVector() const {
-    return buildVectors_->size() == 1;
+  // Returns true if all output for the current probe row has been produced.
+  bool isProbeRowDone() const {
+    return candidateIndex_ >= candidateBuildRows_.size() ||
+        buildVectorIndex_ >= buildVectors_.value().size();
   }
 
-  // If there are no incoming records in the build side.
-  bool isBuildSideEmpty() const {
-    return buildVectors_->empty();
+  // Increment probeRow_ and reset associated fields
+  void advanceProbeRow() {
+    ++probeRow_;
+    probeHasMatch_ = false;
+    buildVectorIndex_ = 0;
+    candidateIndex_ = 0;
+    candidateOffsetForCurrentBuildVector_ = 0;
+    buildRowOffset_ = 0;
+    needsFilterEvaluated_ = true;
   }
 
-  // If build has a single row, we can simply add it as a constant to probe
-  // batches.
-  bool isSingleBuildRow() const {
-    return isSingleBuildVector() && buildVectors_->front()->size() == 1;
+  // Add the output for a single build vector for a single probe row.  This will
+  // return early if the output vector is full.
+  void addBuildVectorOutput(const RowVectorPtr& buildVector);
+
+  // Returns true if all the rows for the current build vector have been
+  // processed, or the output is full.
+  bool isBuildVectorDone(const RowVectorPtr& buildVector) const {
+    // Note that candidateBuildRows_ entries are row numbers across
+    // all build vectors.
+    return candidateIndex_ >= candidateBuildRows_.size() ||
+        relativeBuildRow(candidateIndex_) >= buildVector->size() ||
+        outputBuilder_.isOutputFull();
   }
 
-  // TODO: Add state transition check.
-  void setState(ProbeOperatorState state) {
-    state_ = state;
+  // Increment buildVectorIndex_ and reset associated fields
+  void advanceBuildVector() {
+    VELOX_CHECK(buildVectors_.has_value());
+
+    buildRowOffset_ += buildVectors_.value()[buildVectorIndex_]->size();
+    ++buildVectorIndex_;
+    needsFilterEvaluated_ = true;
+    candidateOffsetForCurrentBuildVector_ = candidateIndex_;
   }
 
-  const core::JoinType joinType_;
+  // Calculate candidate build rows from spatialIndex_ for the current probe
+  // row. This should be done each time the probe is advanced.
+  std::vector<int32_t> querySpatialIndex();
 
-  // Output buffer members.
+  // Evaluates the spatial joinCondition for a given build vector. This method
+  // sets `filterOutput_` and `decodedFilterResult_`, which will be ready to
+  // be used by `isSpatialJoinConditionMatch()` below.
+  // This only evaluates rows that are in the candidateBuildRows_, restricted to
+  // those in the current build vector. Thus we must index into this with
+  // candidateIndex_.
+  void evaluateJoinFilter(const RowVectorPtr& buildVector);
 
-  // Maximum number of rows in the output batch.
-  const vector_size_t outputBatchSize_;
+  // Checks if the spatial join condition matched for a particular row.
+  bool isJoinConditionMatch(vector_size_t candidateIndex) const {
+    vector_size_t relativeIndex =
+        candidateIndex - candidateOffsetForCurrentBuildVector_;
+    VELOX_CHECK_GT(decodedFilterResult_.size(), relativeIndex);
+    return (
+        !decodedFilterResult_.isNullAt(relativeIndex) &&
+        decodedFilterResult_.valueAt<bool>(relativeIndex));
+  }
 
-  // The current output batch being populated.
-  RowVectorPtr output_;
+  // Generates the next batch of a cross product between probe and build using
+  // the supplied projections. It uses the current probe row as constant, and
+  // flat copied data for build records.
+  RowVectorPtr getNextJoinBatch(
+      const RowVectorPtr& buildVector,
+      const RowTypePtr& outputType,
+      const std::vector<IdentityProjection>& probeProjections,
+      const std::vector<IdentityProjection>& buildProjections,
+      BufferPtr candidateRows) const;
+
+  // Given a candidate index, return the row index into the current build
+  // vector.  For example, if we have candidates [2, 50, 81] and have processed
+  // two build vectors with size 30 and 40, then `relativeBuildRow(2) == 11`
+  // (81 - (30 + 40)).
+  vector_size_t relativeBuildRow(vector_size_t candidateRow) const {
+    return candidateBuildRows_[candidateRow] - buildRowOffset_;
+  }
 
-  // Number of output rows in the current output batch.
-  vector_size_t numOutputRows_{0};
+  // Make the indices of build vector candidates suitable for creating a
+  // DictionaryVector.
+  BufferPtr makeBuildVectorIndices(vector_size_t vectorSize);
 
-  // Dictionary indices for probe columns used to generate cross-product.
-  BufferPtr probeIndices_;
+  /////////
+  // SETUP
+  // Variables set during operator setup that are used during execution.
+  // These should not be modified after the operator is initialized.
 
-  // Dictionary indices for probe columns for output vector.
-  BufferPtr probeOutputIndices_;
-  vector_size_t* rawProbeOutputIndices_{};
+  const core::JoinType joinType_;
 
-  // Dictionary indices for build columns.
-  BufferPtr buildIndices_;
+  // Maximum number of rows in the output batch.
+  const vector_size_t outputBatchSize_;
 
-  // Spatial join condition expression.
+  // Join metadata and state.
+  std::shared_ptr<const core::SpatialJoinNode> joinNode_;
 
+  // Spatial join condition expression.
   // Must not be null
   std::unique_ptr<ExprSet> joinCondition_;
 
   // Input type for the spatial join condition expression.
   RowTypePtr filterInputType_;
 
-  // Spatial join condition evaluation state that need to persisted across the
-  // generation of successive output buffers.
-  SelectivityVector filterInputRows_;
-  VectorPtr filterOutput_;
-  DecodedVector decodedFilterResult_;
+  // List of output projections from the build side. Note that the list of
+  // projections from the probe side is available at `identityProjections_`.
+  std::vector<IdentityProjection> buildProjections_;
 
-  // Join metadata and state.
-  std::shared_ptr<const core::SpatialJoinNode> joinNode_;
+  // Projections needed as input to the filter to evaluation spatial join
+  // filter conditions. Note that if this is a cross-join, filter projections
+  // are the same as output projections.
+  std::vector<IdentityProjection> filterProbeProjections_;
+  std::vector<IdentityProjection> filterBuildProjections_;
 
-  ProbeOperatorState state_{ProbeOperatorState::kWaitForBuild};
-  ContinueFuture future_{ContinueFuture::makeEmpty()};
+  // Stores the build spatial index for the join
+  std::optional<std::shared_ptr<SpatialIndex>> spatialIndex_;
+  // Stores the data for build vectors (right side of the join).
+  std::optional<std::vector<RowVectorPtr>> buildVectors_;
 
-  // Probe side state.
+  // Channel of geometry variable used to probe spatial index
+  column_index_t probeGeometryChannel_;
 
-  // Probe row being currently processed (related to `input_`).
-  vector_size_t probeRow_{0};
+  //////////////////
+  // OPERATOR STATE
+  // Variables used to track the general operator state during exection.
+  // These will change throughout setup and execution.
 
-  // Whether the current probeRow_ has produces a match. Used for left and full
-  // outer joins.
-  bool probeRowHasMatch_{false};
+  ProbeOperatorState state_{ProbeOperatorState::kWaitForBuild};
+  ContinueFuture future_{ContinueFuture::makeEmpty()};
 
-  // Indicate if the probe side has empty input or not. For the last probe,
-  // this indicates if all the probe sides are empty or not. This flag is used
-  // for mismatched output producing.
-  bool probeSideEmpty_{true};
+  // The information needed to produce an output RowVectorPtr. It is stored
+  // for all execution, but is reset on each output batch.
+  SpatialJoinOutputBuilder outputBuilder_;
 
-  // Build side state.
+  // Count of output batches produced (1-indexed). Primarily for debugging.
+  size_t outputCount_{0};
 
-  // Stores the data for build vectors (right side of the join).
-  std::optional<std::vector<RowVectorPtr>> buildVectors_;
+  // This is always set to all true, but we need it for eval/etc. Reuse between
+  // evaluations.
+  SelectivityVector filterInputRows_;
+  // The output result of the join condition evaluation on the **current**
+  // build vector. We must index into this with
+  // `candidateIndex_ - candidateOffsetForCurrentBuildVector_`.
+  VectorPtr filterOutput_;
+  // Decoded filterOutput: remove recursive dictionary/etc encodings.
+  // Like filterOutput_, this is only for the current build vector and we
+  // must index into this with
+  // `candidateIndex_ - candidateOffsetForCurrentBuildVector_`.
+  DecodedVector decodedFilterResult_;
 
-  // Index into `buildVectors_` for the build vector being currently processed.
-  size_t buildIndex_{0};
+  // Decoded geometry vector.  Must be reset whenever input_ is changed (it
+  // maintains a pointer to input_).
+  DecodedVector decodedGeometryCol_{};
 
-  // Row being currently processed from `buildVectors_[buildIndex_]`.
-  vector_size_t buildRow_{0};
+  ///////////////
+  // PROBE STATE
+  // Variables used to track the probe-side state state during exection.
+  // These will change throughout setup and execution.
 
-  // Stores the ranges of build values to be copied to the output vector (we
-  // batch them and copy once, instead of copying them row-by-row).
-  std::vector<BaseVector::CopyRange> buildCopyRanges_;
+  // Count of probe batches added (1-indexed). Primarily for debugging.
+  size_t probeCount_{0};
 
-  // List of output projections from the build side. Note that the list of
-  // projections from the probe side is available at `identityProjections_`.
-  std::vector<IdentityProjection> buildProjections_;
+  // Probe row being currently processed (related to `input_`).
+  vector_size_t probeRow_{0};
 
-  // Projections needed as input to the filter to evaluation spatial join filter
-  // conditions. Note that if this is a cross-join, filter projections are the
-  // same as output projections.
-  std::vector<IdentityProjection> filterProbeProjections_;
-  std::vector<IdentityProjection> filterBuildProjections_;
+  // Whether the current probeRow_ has found a match.  Needed for left join.
+  bool probeHasMatch_{false};
 
-  BufferPtr buildOutMapping_;
+  ///////////////
+  // BUILD STATE
+  // Variables used to track the build-side state state during exection.
+  // These will change throughout setup and execution.
+  //
+  // The build rows are stored in a vector of RowVectorPtrs.  These are
+  // conceptually indexed by an absolute build row, which indexes into a
+  // flattened vector of rows.  buildVectorIndex_ is the index to the current
+  // RowVectorPtr in buildVectors_, buildRowOffset_ is the sum of the sizes
+  // of the previous build vectors and should be subtracted from buildRow
+  // to index into the current build vector.
+  //
+  // We primarily use candidateBuildRows_, which is a vector of (absolute)
+  // build rows.  candidateIndex_ indexes the entry in candidateBuildRows_,
+  // so candidateBuildrows_[candidiateIndex_] is the absolute build row
+  // of the current candidate.
+
+  // Whether we need to evaluate the join filter on this build vector.  It
+  // should be done once per build vector/probe row pair.
+  bool needsFilterEvaluated_{true};
+
+  // Index into `buildVectors_` for the build vector being currently
+  // processed.
+  size_t buildVectorIndex_{0};
+
+  // Keep track of how many build rows we've traversed in previous build
+  // RowVectors. Subtract this from the current element in candidateBuildRows_
+  // to index into the current build RowVector.
+  vector_size_t buildRowOffset_{0};
+
+  // Build rows returned from the spatial index.
+  // The value is the row number over all build vectors, so if the have two
+  // build vectors of size 100 and 200, candidate row 50 is the 50th entry of
+  // the first vector, and 101 is the 2nd entry of the second vector.
+  std::vector<vector_size_t> candidateBuildRows_{};
+
+  // Index of candidate currently being processed from
+  // `buildVectors_[buildIndex_]`.
+  vector_size_t candidateIndex_{0};
+
+  // How many candidates were in previous build vectors.
+  // This is important because for each build vector, we calculate a
+  // decodedFilterResult_ with only the rows from from the candidates in
+  // that build vector.  candidateIndex_ indexes over _all_ candidates, so
+  // we must substract candidateOffsetForCurrentBuildVector_ to index into the
+  // candidates for this build vector.
+  vector_size_t candidateOffsetForCurrentBuildVector_{0};
 };
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/Spill.cpp b/velox/exec/Spill.cpp
index 376d06502a3..193d86265c6 100644
--- a/velox/exec/Spill.cpp
+++ b/velox/exec/Spill.cpp
@@ -15,14 +15,82 @@
  */
 
 #include "velox/exec/Spill.h"
+#include "velox/common/Casts.h"
 #include "velox/common/base/RuntimeMetrics.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/testutil/TestValue.h"
+#include "velox/exec/OperatorUtils.h"
 #include "velox/serializers/PrestoSerializer.h"
 
 using facebook::velox::common::testutil::TestValue;
 
 namespace facebook::velox::exec {
+
+namespace {
+/// gatherMerge merges & sorts with the mergeTree and gatherCopy the
+/// results into target. 'target' is the result RowVector, and the copying
+/// starts from row 0 up to row target.size(). 'mergeTree' is the data source.
+/// 'totalNumRows' is the actual num of rows that is copied to target.
+/// 'bufferSources' and 'bufferSourceIndices' are buffering vectors that could
+/// be reused across calls.
+void gatherMerge(
+    RowVectorPtr& target,
+    TreeOfLosers<SpillMergeStream>& mergeTree,
+    int32_t& totalNumRows,
+    std::vector<const RowVector*>& bufferSources,
+    std::vector<vector_size_t>& bufferSourceIndices) {
+  VELOX_CHECK_GE(bufferSources.size(), target->size());
+  VELOX_CHECK_GE(bufferSourceIndices.size(), target->size());
+  totalNumRows = 0;
+  int32_t numBatchRows = 0;
+  bool endOfBatch = false;
+  for (auto currentStream = mergeTree.next();
+       currentStream != nullptr && totalNumRows + numBatchRows < target->size();
+       currentStream = mergeTree.next()) {
+    bufferSources[numBatchRows] = &currentStream->current();
+    bufferSourceIndices[numBatchRows] =
+        currentStream->currentIndex(&endOfBatch);
+    ++numBatchRows;
+    if (FOLLY_UNLIKELY(endOfBatch)) {
+      // The stream is at end of input batch. Need to copy out the rows before
+      // fetching next batch in 'pop'.
+      gatherCopy(
+          target.get(),
+          totalNumRows,
+          numBatchRows,
+          bufferSources,
+          bufferSourceIndices);
+      totalNumRows += numBatchRows;
+      numBatchRows = 0;
+    }
+    // Advance the stream.
+    currentStream->pop();
+  }
+  VELOX_CHECK_LE(totalNumRows + numBatchRows, target->size());
+
+  if (FOLLY_LIKELY(numBatchRows != 0)) {
+    gatherCopy(
+        target.get(),
+        totalNumRows,
+        numBatchRows,
+        bufferSources,
+        bufferSourceIndices);
+    totalNumRows += numBatchRows;
+    numBatchRows = 0;
+  }
+}
+} // namespace
+
+void testingGatherMerge(
+    RowVectorPtr& target,
+    TreeOfLosers<SpillMergeStream>& mergeTree,
+    int32_t& totalNumRows,
+    std::vector<const RowVector*>& bufferSources,
+    std::vector<vector_size_t>& bufferSourceIndices) {
+  gatherMerge(
+      target, mergeTree, totalNumRows, bufferSources, bufferSourceIndices);
+}
+
 void SpillMergeStream::pop() {
   VELOX_CHECK(!closed_);
   if (++index_ >= size_) {
@@ -70,7 +138,7 @@ SpillState::SpillState(
     common::CompressionKind compressionKind,
     const std::optional<common::PrefixSortConfig>& prefixSortConfig,
     memory::MemoryPool* pool,
-    folly::Synchronized<common::SpillStats>* stats,
+    exec::SpillStats* stats,
     const std::string& fileCreateConfig)
     : getSpillDirPathCb_(getSpillDirPathCb),
       updateAndCheckSpillLimitCb_(updateAndCheckSpillLimitCb),
@@ -110,8 +178,8 @@ std::vector<SpillSortKey> SpillState::makeSortingKeys(
 void SpillState::setPartitionSpilled(const SpillPartitionId& id) {
   VELOX_DCHECK(!spilledPartitionIdSet_.contains(id));
   spilledPartitionIdSet_.emplace(id);
-  ++stats_->wlock()->spilledPartitions;
-  common::incrementGlobalSpilledPartitionStats();
+  stats_->spilledPartitions.fetch_add(1, std::memory_order_relaxed);
+  incrementGlobalSpilledPartitionStats();
 }
 
 /*static*/
@@ -119,17 +187,17 @@ void SpillState::validateSpillBytesSize(uint64_t bytes) {
   static constexpr uint64_t kMaxSpillBytesPerWrite =
       std::numeric_limits<int32_t>::max();
   if (bytes >= kMaxSpillBytesPerWrite) {
-    VELOX_GENERIC_SPILL_FAILURE(fmt::format(
-        "Spill bytes will overflow. Bytes {}, kMaxSpillBytesPerWrite: {}",
-        bytes,
-        kMaxSpillBytesPerWrite));
+    VELOX_GENERIC_SPILL_FAILURE(
+        fmt::format(
+            "Spill bytes will overflow. Bytes {}, kMaxSpillBytesPerWrite: {}",
+            bytes,
+            kMaxSpillBytesPerWrite));
   }
 }
 
 void SpillState::updateSpilledInputBytes(uint64_t bytes) {
-  auto statsLocked = stats_->wlock();
-  statsLocked->spilledInputBytes += bytes;
-  common::updateGlobalSpillMemoryBytes(bytes);
+  stats_->spilledInputBytes.fetch_add(bytes, std::memory_order_relaxed);
+  updateGlobalSpillMemoryBytes(bytes);
 }
 
 uint64_t SpillState::appendToPartition(
@@ -278,13 +346,14 @@ std::unique_ptr<UnorderedStreamReader<BatchStream>>
 SpillPartition::createUnorderedReader(
     uint64_t bufferSize,
     memory::MemoryPool* pool,
-    folly::Synchronized<common::SpillStats>* spillStats) {
+    exec::SpillStats* spillStats) {
   VELOX_CHECK_NOT_NULL(pool);
   std::vector<std::unique_ptr<BatchStream>> streams;
   streams.reserve(files_.size());
   for (auto& fileInfo : files_) {
-    streams.push_back(FileSpillBatchStream::create(
-        SpillReadFile::create(fileInfo, bufferSize, pool, spillStats)));
+    streams.push_back(
+        FileSpillBatchStream::create(
+            SpillReadFile::create(fileInfo, bufferSize, pool, spillStats)));
   }
   files_.clear();
   return std::make_unique<UnorderedStreamReader<BatchStream>>(
@@ -292,15 +361,16 @@ SpillPartition::createUnorderedReader(
 }
 
 std::unique_ptr<TreeOfLosers<SpillMergeStream>>
-SpillPartition::createOrderedReader(
+SpillPartition::createOrderedReaderInternal(
     uint64_t bufferSize,
     memory::MemoryPool* pool,
-    folly::Synchronized<common::SpillStats>* spillStats) {
+    exec::SpillStats* spillStats) {
   std::vector<std::unique_ptr<SpillMergeStream>> streams;
   streams.reserve(files_.size());
   for (auto& fileInfo : files_) {
-    streams.push_back(FileSpillMergeStream::create(
-        SpillReadFile::create(fileInfo, bufferSize, pool, spillStats)));
+    streams.push_back(
+        FileSpillMergeStream::create(
+            SpillReadFile::create(fileInfo, bufferSize, pool, spillStats)));
   }
   files_.clear();
   // Check if the partition is empty or not.
@@ -310,6 +380,174 @@ SpillPartition::createOrderedReader(
   return std::make_unique<TreeOfLosers<SpillMergeStream>>(std::move(streams));
 }
 
+namespace {
+size_t estimateOutputBatchRows(
+    const std::vector<std::unique_ptr<SpillMergeStream>>& streams,
+    vector_size_t maxRows,
+    size_t maxBytes) {
+  size_t numEstimations{0};
+  int64_t totalEstimatedBytes{0};
+  for (const auto& stream : streams) {
+    const auto streamEstimateRowSize = stream->estimateRowSize();
+    if (streamEstimateRowSize.has_value()) {
+      ++numEstimations;
+      totalEstimatedBytes += streamEstimateRowSize.value();
+    }
+  }
+
+  if (numEstimations == 0) {
+    return maxRows;
+  }
+
+  const auto estimateRowSize =
+      std::max<vector_size_t>(1, totalEstimatedBytes / numEstimations);
+  return std::min<vector_size_t>(
+      std::max<vector_size_t>(1, maxBytes / estimateRowSize), maxRows);
+}
+
+// This contains batching parameters and various kinds of batching buffers that
+// are reused across multiple merging rounds.
+struct SpillFileMergeParams {
+  static constexpr size_t kDefaultMaxBatchRows = 1'000;
+  static constexpr size_t kDefaultMaxBatchBytes = 64 * 1024;
+
+  SpillFileMergeParams(
+      const TypePtr& type,
+      memory::MemoryPool* pool,
+      const vector_size_t _maxBatchRows = kDefaultMaxBatchRows,
+      const size_t _maxBatchBytes = kDefaultMaxBatchBytes)
+      : maxBatchRows(_maxBatchRows), maxBatchBytes(_maxBatchBytes) {
+    rowVector = std::static_pointer_cast<RowVector>(
+        BaseVector::create(type, maxBatchRows, pool));
+    spillSources.resize(maxBatchRows);
+    spillSourceRows.resize(maxBatchRows);
+  }
+
+  const vector_size_t maxBatchRows;
+  const size_t maxBatchBytes;
+  RowVectorPtr rowVector;
+  std::vector<const RowVector*> spillSources;
+  std::vector<vector_size_t> spillSourceRows;
+};
+
+SpillFileInfo mergeSpillFiles(
+    const std::vector<SpillFileInfo>& files,
+    const std::string& pathPrefix,
+    const common::UpdateAndCheckSpillLimitCB& updateAndCheckSpillLimitCb,
+    const std::string& fileCreateConfig,
+    uint64_t readBufferSize,
+    uint64_t writeBufferSize,
+    SpillFileMergeParams& mergeParams,
+    memory::MemoryPool* pool,
+    exec::SpillStats* spillStats) {
+  VELOX_CHECK_GT(files.size(), 0);
+  std::vector<std::unique_ptr<SpillMergeStream>> streams;
+  streams.reserve(files.size());
+  for (const auto& fileInfo : files) {
+    streams.push_back(
+        FileSpillMergeStream::create(
+            SpillReadFile::create(fileInfo, readBufferSize, pool, spillStats)));
+  }
+  const auto batchRows = estimateOutputBatchRows(
+      streams, mergeParams.maxBatchRows, mergeParams.maxBatchBytes);
+
+  auto mergeTree =
+      std::make_unique<TreeOfLosers<SpillMergeStream>>(std::move(streams));
+  const auto type = files[0].type;
+
+  auto writer = std::make_unique<SpillWriter>(
+      type,
+      files[0].sortingKeys,
+      files[0].compressionKind,
+      pathPrefix,
+      std::numeric_limits<uint64_t>::max(),
+      writeBufferSize,
+      fileCreateConfig,
+      updateAndCheckSpillLimitCb,
+      pool,
+      spillStats);
+
+  while (mergeTree->next()) {
+    VectorPtr tmpRowVector = std::move(mergeParams.rowVector);
+    BaseVector::prepareForReuse(tmpRowVector, batchRows);
+    mergeParams.rowVector = checkedPointerCast<RowVector>(tmpRowVector);
+    mergeParams.rowVector->resize(batchRows);
+    int32_t outputRow = 0;
+    gatherMerge(
+        mergeParams.rowVector,
+        *mergeTree,
+        outputRow,
+        mergeParams.spillSources,
+        mergeParams.spillSourceRows);
+
+    IndexRange range{0, outputRow};
+    writer->write(mergeParams.rowVector, folly::Range<IndexRange*>(&range, 1));
+  }
+  auto resultFiles = writer->finish();
+  VELOX_CHECK_EQ(resultFiles.size(), 1);
+  return std::move(resultFiles[0]);
+}
+
+struct SpillFileCompare {
+  bool operator()(const SpillFileInfo& lhs, const SpillFileInfo& rhs) const {
+    return lhs.size > rhs.size;
+  }
+};
+using SpillFileHeap = std::
+    priority_queue<SpillFileInfo, std::vector<SpillFileInfo>, SpillFileCompare>;
+} // namespace
+
+std::unique_ptr<TreeOfLosers<SpillMergeStream>>
+SpillPartition::createOrderedReader(
+    const common::SpillConfig& spillConfig,
+    memory::MemoryPool* pool,
+    exec::SpillStats* spillStats) {
+  const auto numMaxMergeFiles = spillConfig.numMaxMergeFiles;
+  VELOX_CHECK_NE(numMaxMergeFiles, 1);
+  if (numMaxMergeFiles == 0 || files_.size() <= numMaxMergeFiles) {
+    return createOrderedReaderInternal(
+        spillConfig.readBufferSize, pool, spillStats);
+  }
+
+  SpillFileHeap orderedFiles(files_.begin(), files_.end());
+  SpillFiles files;
+  files.reserve(numMaxMergeFiles);
+  const auto mergeFilePathPrefix = files_[0].path;
+  SpillFileMergeParams mergeParams(files_[0].type, pool);
+
+  // Recursively merge the files.
+  for (uint32_t round = 0; orderedFiles.size() > numMaxMergeFiles; ++round) {
+    const uint64_t numMergeFiles = std::min(
+        static_cast<uint64_t>(numMaxMergeFiles),
+        static_cast<uint64_t>(orderedFiles.size() + 1 - numMaxMergeFiles));
+    // Choose the top 'numMergeFiles' smallest files for merging to minimize IO.
+    for (uint32_t i = 0; i < numMergeFiles; i++) {
+      files.push_back(orderedFiles.top());
+      orderedFiles.pop();
+    }
+    auto mergedFile = mergeSpillFiles(
+        files,
+        fmt::format("{}-merge-round-{}", mergeFilePathPrefix, round),
+        spillConfig.updateAndCheckSpillLimitCb,
+        spillConfig.fileCreateConfig,
+        spillConfig.readBufferSize,
+        spillConfig.writeBufferSize,
+        mergeParams,
+        pool,
+        spillStats);
+    orderedFiles.push(mergedFile);
+    files.clear();
+  }
+
+  files_.clear();
+  while (!orderedFiles.empty()) {
+    files_.push_back(orderedFiles.top());
+    orderedFiles.pop();
+  }
+  return createOrderedReaderInternal(
+      spillConfig.readBufferSize, pool, spillStats);
+}
+
 IterableSpillPartitionSet::IterableSpillPartitionSet() {
   spillPartitionIter_ = spillPartitions_.begin();
 }
@@ -436,6 +674,8 @@ std::unique_ptr<BatchStream> ConcatFilesSpillBatchStream::create(
 }
 
 bool ConcatFilesSpillBatchStream::nextBatch(RowVectorPtr& batch) {
+  TestValue::adjust(
+      "facebook::velox::exec::ConcatFilesSpillBatchStream::nextBatch", nullptr);
   VELOX_CHECK_NULL(batch);
   VELOX_CHECK(!atEnd_);
   for (; fileIndex_ < spillFiles_.size(); ++fileIndex_) {
@@ -454,10 +694,11 @@ bool ConcatFilesSpillBatchStream::nextBatch(RowVectorPtr& batch) {
 SpillPartitionId::SpillPartitionId(uint32_t partitionNumber)
     : encodedId_(partitionNumber) {
   if (FOLLY_UNLIKELY(partitionNumber >= (1 << kMaxPartitionBits))) {
-    VELOX_FAIL(fmt::format(
-        "Partition number {} exceeds max partition number {}",
-        partitionNumber,
-        1 << kMaxPartitionBits));
+    VELOX_FAIL(
+        fmt::format(
+            "Partition number {} exceeds max partition number {}",
+            partitionNumber,
+            1 << kMaxPartitionBits));
   }
 }
 
@@ -466,10 +707,11 @@ SpillPartitionId::SpillPartitionId(
     uint32_t partitionNumber) {
   const auto childSpillLevel = parent.spillLevel() + 1;
   if (FOLLY_UNLIKELY(childSpillLevel > kMaxSpillLevel)) {
-    VELOX_FAIL(fmt::format(
-        "Spill level {} exceeds max spill level {}",
-        childSpillLevel,
-        kMaxSpillLevel));
+    VELOX_FAIL(
+        fmt::format(
+            "Spill level {} exceeds max spill level {}",
+            childSpillLevel,
+            kMaxSpillLevel));
   }
   encodedId_ = parent.encodedId_;
   encodedId_ = encodedId_ & ~kSpillLevelBitMask;
diff --git a/velox/exec/Spill.h b/velox/exec/Spill.h
index 18fd2cbfcb1..c523c6ed96b 100644
--- a/velox/exec/Spill.h
+++ b/velox/exec/Spill.h
@@ -20,12 +20,12 @@
 
 #include <re2/re2.h>
 #include "velox/common/base/SpillConfig.h"
-#include "velox/common/base/SpillStats.h"
+#include "velox/common/base/TreeOfLosers.h"
 #include "velox/common/compression/Compression.h"
 #include "velox/common/file/File.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/exec/SpillFile.h"
-#include "velox/exec/TreeOfLosers.h"
+#include "velox/exec/SpillStats.h"
 #include "velox/exec/UnorderedStreamReader.h"
 #include "velox/exec/VectorHasher.h"
 #include "velox/vector/ComplexVector.h"
@@ -33,6 +33,23 @@
 #include "velox/vector/VectorStream.h"
 
 namespace facebook::velox::exec {
+
+class SpillMergeStream;
+
+/// Testing gatherMerge without exposing the interface in the header. Used in
+/// test only. gatherMerge merges & sorts with the mergeTree and gatherCopy the
+/// results into target. 'target' is the result RowVector, and the copying
+/// starts from row 0 up to row target.size(). 'mergeTree' is the data source.
+/// 'totalNumRows' is the actual num of rows that is copied to target.
+/// 'bufferSources' and 'bufferSourceIndices' are buffering vectors that could
+/// be reused across calls.
+void testingGatherMerge(
+    RowVectorPtr& target,
+    TreeOfLosers<SpillMergeStream>& mergeTree,
+    int32_t& totalNumRows,
+    std::vector<const RowVector*>& bufferSources,
+    std::vector<vector_size_t>& bufferSourceIndices);
+
 class VectorHasher;
 
 /// A source of sorted spilled RowVectors coming either from a file or memory.
@@ -80,6 +97,15 @@ class SpillMergeStream : public MergeStream {
     return decoded_[index];
   }
 
+  /// Returns the estimated row size based on the vector received from the
+  /// merge source.
+  std::optional<int64_t> estimateRowSize() const {
+    if (rowVector_ == nullptr || rowVector_->size() == 0) {
+      return std::nullopt;
+    }
+    return rowVector_->estimateFlatSize() / rowVector_->size();
+  }
+
  protected:
   virtual const std::vector<SpillSortKey>& sortingKeys() const = 0;
 
@@ -477,22 +503,33 @@ class SpillPartition {
   std::unique_ptr<UnorderedStreamReader<BatchStream>> createUnorderedReader(
       uint64_t bufferSize,
       memory::MemoryPool* pool,
-      folly::Synchronized<common::SpillStats>* spillStats);
+      exec::SpillStats* spillStats);
+
+  /// Create an ordered stream reader from this spill partition. If the
+  /// partition has more than spillConfig.numMaxMergeFiles files, the files will
+  /// be pre-merged recursively to make sure the final ordered reader reads no
+  /// more than numMaxMergeFiles files. This behavior is to avoid OOM problem
+  /// when opening and reading too many files at the same time. If
+  /// numMaxMergeFiles < 2, the merge way is unlimited.
+  std::unique_ptr<TreeOfLosers<SpillMergeStream>> createOrderedReader(
+      const common::SpillConfig& spillConfig,
+      memory::MemoryPool* pool,
+      exec::SpillStats* spillStats);
 
+  std::string toString() const;
+
+ private:
   /// Invoked to create an ordered stream reader from this spill partition.
   /// The created reader will take the ownership of the spill files.
   /// 'bufferSize' specifies the read size from the storage. If the file
   /// system supports async read mode, then reader allocates two buffers with
   /// one buffer prefetch ahead. 'spillStats' is provided to collect the spill
   /// stats when reading data from spilled files.
-  std::unique_ptr<TreeOfLosers<SpillMergeStream>> createOrderedReader(
+  std::unique_ptr<TreeOfLosers<SpillMergeStream>> createOrderedReaderInternal(
       uint64_t bufferSize,
       memory::MemoryPool* pool,
-      folly::Synchronized<common::SpillStats>* spillStats);
+      exec::SpillStats* spillStats);
 
-  std::string toString() const;
-
- private:
   SpillPartitionId id_;
   SpillFiles files_;
   // Counts the total file size in bytes from this spilled partition.
@@ -549,7 +586,7 @@ class SpillState {
   /// 'numSortKeys' is the number of leading columns on which the data is
   /// sorted, 0 if only hash partitioning is used. 'targetFileSize' is the
   /// target size of a single file.  'pool' owns the memory for state and
-  /// results.
+  /// results. 'ioStats' is used to collect filesystem I/O stats.
   SpillState(
       const common::GetSpillDirectoryPathCB& getSpillDirectoryPath,
       const common::UpdateAndCheckSpillLimitCB& updateAndCheckSpillLimitCb,
@@ -560,7 +597,7 @@ class SpillState {
       common::CompressionKind compressionKind,
       const std::optional<common::PrefixSortConfig>& prefixSortConfig,
       memory::MemoryPool* pool,
-      folly::Synchronized<common::SpillStats>* stats,
+      exec::SpillStats* stats,
       const std::string& fileCreateConfig = {});
 
   static std::vector<SpillSortKey> makeSortingKeys(
@@ -665,7 +702,7 @@ class SpillState {
   const std::optional<common::PrefixSortConfig> prefixSortConfig_;
   const std::string fileCreateConfig_;
   memory::MemoryPool* const pool_;
-  folly::Synchronized<common::SpillStats>* const stats_;
+  exec::SpillStats* const stats_;
 
   // A set of spilled partition ids.
   SpillPartitionIdSet spilledPartitionIdSet_;
diff --git a/velox/exec/SpillFile.cpp b/velox/exec/SpillFile.cpp
index a5ad7d53d7e..cb4647c8ca8 100644
--- a/velox/exec/SpillFile.cpp
+++ b/velox/exec/SpillFile.cpp
@@ -16,8 +16,7 @@
 
 #include "velox/exec/SpillFile.h"
 #include "velox/common/base/RuntimeMetrics.h"
-#include "velox/common/file/FileSystems.h"
-#include "velox/vector/VectorStream.h"
+#include "velox/serializers/SerializedPageFile.h"
 
 namespace facebook::velox::exec {
 namespace {
@@ -29,49 +28,6 @@ namespace {
 static const bool kDefaultUseLosslessTimestamp = true;
 } // namespace
 
-std::unique_ptr<SpillWriteFile> SpillWriteFile::create(
-    uint32_t id,
-    const std::string& pathPrefix,
-    const std::string& fileCreateConfig) {
-  return std::unique_ptr<SpillWriteFile>(
-      new SpillWriteFile(id, pathPrefix, fileCreateConfig));
-}
-
-SpillWriteFile::SpillWriteFile(
-    uint32_t id,
-    const std::string& pathPrefix,
-    const std::string& fileCreateConfig)
-    : id_(id), path_(fmt::format("{}-{}", pathPrefix, ordinalCounter_++)) {
-  auto fs = filesystems::getFileSystem(path_, nullptr);
-  file_ = fs->openFileForWrite(
-      path_,
-      filesystems::FileOptions{
-          {{filesystems::FileOptions::kFileCreateConfig.toString(),
-            fileCreateConfig}},
-          nullptr,
-          std::nullopt});
-}
-
-void SpillWriteFile::finish() {
-  VELOX_CHECK_NOT_NULL(file_);
-  size_ = file_->size();
-  file_->close();
-  file_ = nullptr;
-}
-
-uint64_t SpillWriteFile::size() const {
-  if (file_ != nullptr) {
-    return file_->size();
-  }
-  return size_;
-}
-
-uint64_t SpillWriteFile::write(std::unique_ptr<folly::IOBuf> iobuf) {
-  auto writtenBytes = iobuf->computeChainDataLength();
-  file_->append(std::move(iobuf));
-  return writtenBytes;
-}
-
 SpillWriter::SpillWriter(
     const RowTypePtr& type,
     const std::vector<SpillSortKey>& sortingKeys,
@@ -80,160 +36,82 @@ SpillWriter::SpillWriter(
     uint64_t targetFileSize,
     uint64_t writeBufferSize,
     const std::string& fileCreateConfig,
-    common::UpdateAndCheckSpillLimitCB& updateAndCheckSpillLimitCb,
+    const common::UpdateAndCheckSpillLimitCB& updateAndCheckSpillLimitCb,
     memory::MemoryPool* pool,
-    folly::Synchronized<common::SpillStats>* stats)
-    : type_(type),
+    exec::SpillStats* stats)
+    : serializer::SerializedPageFileWriter(
+          pathPrefix,
+          targetFileSize,
+          writeBufferSize,
+          fileCreateConfig,
+          std::make_unique<
+              serializer::presto::PrestoVectorSerde::PrestoOptions>(
+              kDefaultUseLosslessTimestamp,
+              compressionKind,
+              0.8,
+              /*_nullsFirst=*/true),
+          getNamedVectorSerde("Presto"),
+          pool,
+          &stats->ioStats),
+      type_(type),
       sortingKeys_(sortingKeys),
-      compressionKind_(compressionKind),
-      pathPrefix_(pathPrefix),
-      targetFileSize_(targetFileSize),
-      writeBufferSize_(writeBufferSize),
-      fileCreateConfig_(fileCreateConfig),
-      updateAndCheckSpillLimitCb_(updateAndCheckSpillLimitCb),
-      pool_(pool),
-      serde_(getNamedVectorSerde(VectorSerde::Kind::kPresto)),
-      stats_(stats) {}
-
-SpillWriteFile* SpillWriter::ensureFile() {
-  if ((currentFile_ != nullptr) && (currentFile_->size() > targetFileSize_)) {
-    closeFile();
-  }
-  if (currentFile_ == nullptr) {
-    currentFile_ = SpillWriteFile::create(
-        nextFileId_++,
-        fmt::format("{}-{}", pathPrefix_, finishedFiles_.size()),
-        fileCreateConfig_);
-  }
-  return currentFile_.get();
-}
-
-void SpillWriter::closeFile() {
-  if (currentFile_ == nullptr) {
-    return;
-  }
-  currentFile_->finish();
-  updateSpilledFileStats(currentFile_->size());
-  finishedFiles_.push_back(SpillFileInfo{
-      .id = currentFile_->id(),
-      .type = type_,
-      .path = currentFile_->path(),
-      .size = currentFile_->size(),
-      .sortingKeys = sortingKeys_,
-      .compressionKind = compressionKind_});
-  currentFile_.reset();
-}
-
-size_t SpillWriter::numFinishedFiles() const {
-  return finishedFiles_.size();
-}
-
-uint64_t SpillWriter::flush() {
-  if (batch_ == nullptr) {
-    return 0;
-  }
-
-  auto* file = ensureFile();
-  VELOX_CHECK_NOT_NULL(file);
-
-  IOBufOutputStream out(
-      *pool_, nullptr, std::max<int64_t>(64 * 1024, batch_->size()));
-  uint64_t flushTimeNs{0};
-  {
-    NanosecondTimer timer(&flushTimeNs);
-    batch_->flush(&out);
-  }
-  batch_.reset();
-
-  uint64_t writeTimeNs{0};
-  uint64_t writtenBytes{0};
-  auto iobuf = out.getIOBuf();
-  {
-    NanosecondTimer timer(&writeTimeNs);
-    writtenBytes = file->write(std::move(iobuf));
-  }
-  updateWriteStats(writtenBytes, flushTimeNs, writeTimeNs);
-  updateAndCheckSpillLimitCb_(writtenBytes);
-  return writtenBytes;
-}
-
-uint64_t SpillWriter::write(
-    const RowVectorPtr& rows,
-    const folly::Range<IndexRange*>& indices) {
-  checkNotFinished();
-
-  uint64_t timeNs{0};
-  {
-    NanosecondTimer timer(&timeNs);
-    if (batch_ == nullptr) {
-      serializer::presto::PrestoVectorSerde::PrestoOptions options = {
-          kDefaultUseLosslessTimestamp,
-          compressionKind_,
-          0.8,
-          /*_nullsFirst=*/true};
-      batch_ = std::make_unique<VectorStreamGroup>(pool_, serde_);
-      batch_->createStreamTree(
-          std::static_pointer_cast<const RowType>(rows->type()),
-          1'000,
-          &options);
-    }
-    batch_->append(rows, indices);
-  }
-  updateAppendStats(rows->size(), timeNs);
-  if (batch_->size() < writeBufferSize_) {
-    return 0;
-  }
-  return flush();
-}
+      stats_(stats),
+      updateAndCheckLimitCb_(updateAndCheckSpillLimitCb) {}
 
 void SpillWriter::updateAppendStats(
     uint64_t numRows,
     uint64_t serializationTimeNs) {
-  auto statsLocked = stats_->wlock();
-  statsLocked->spilledRows += numRows;
-  statsLocked->spillSerializationTimeNanos += serializationTimeNs;
-  common::updateGlobalSpillAppendStats(numRows, serializationTimeNs);
+  stats_->spilledRows.fetch_add(numRows, std::memory_order_relaxed);
+  stats_->spillSerializationTimeNanos.fetch_add(
+      serializationTimeNs, std::memory_order_relaxed);
+  updateGlobalSpillAppendStats(numRows, serializationTimeNs);
 }
 
 void SpillWriter::updateWriteStats(
     uint64_t spilledBytes,
     uint64_t flushTimeNs,
     uint64_t fileWriteTimeNs) {
-  auto statsLocked = stats_->wlock();
-  statsLocked->spilledBytes += spilledBytes;
-  statsLocked->spillFlushTimeNanos += flushTimeNs;
-  statsLocked->spillWriteTimeNanos += fileWriteTimeNs;
-  ++statsLocked->spillWrites;
-  common::updateGlobalSpillWriteStats(
-      spilledBytes, flushTimeNs, fileWriteTimeNs);
-}
-
-void SpillWriter::updateSpilledFileStats(uint64_t fileSize) {
-  ++stats_->wlock()->spilledFiles;
+  stats_->spillWrites.fetch_add(1, std::memory_order_relaxed);
+  stats_->spilledBytes.fetch_add(spilledBytes, std::memory_order_relaxed);
+  stats_->spillFlushTimeNanos.fetch_add(flushTimeNs, std::memory_order_relaxed);
+  stats_->spillWriteTimeNanos.fetch_add(
+      fileWriteTimeNs, std::memory_order_relaxed);
+  updateGlobalSpillWriteStats(spilledBytes, flushTimeNs, fileWriteTimeNs);
+  updateAndCheckLimitCb_(spilledBytes);
+}
+
+void SpillWriter::updateFileStats(
+    const serializer::SerializedPageFile::FileInfo& file) {
+  stats_->spilledFiles.fetch_add(1, std::memory_order_relaxed);
   addThreadLocalRuntimeStat(
-      "spillFileSize", RuntimeCounter(fileSize, RuntimeCounter::Unit::kBytes));
-  common::incrementGlobalSpilledFiles();
-}
-
-void SpillWriter::finishFile() {
-  checkNotFinished();
-  flush();
-  closeFile();
-  VELOX_CHECK_NULL(currentFile_);
+      "spillFileSize", RuntimeCounter(file.size, RuntimeCounter::Unit::kBytes));
+  incrementGlobalSpilledFiles();
 }
 
 SpillFiles SpillWriter::finish() {
-  checkNotFinished();
-  auto finishGuard = folly::makeGuard([this]() { finished_ = true; });
-
-  finishFile();
-  return std::move(finishedFiles_);
+  const auto serializedPageFiles =
+      serializer::SerializedPageFileWriter::finish();
+  SpillFiles spillFiles;
+  spillFiles.reserve(serializedPageFiles.size());
+  for (const auto& fileInfo : serializedPageFiles) {
+    spillFiles.push_back(
+        SpillFileInfo{
+            .id = fileInfo.id,
+            .type = type_,
+            .path = fileInfo.path,
+            .size = fileInfo.size,
+            .sortingKeys = sortingKeys_,
+            .compressionKind = serdeOptions_->compressionKind});
+  }
+  return spillFiles;
 }
 
 std::vector<std::string> SpillWriter::testingSpilledFilePaths() const {
   checkNotFinished();
 
   std::vector<std::string> spilledFilePaths;
+  spilledFilePaths.reserve(
+      finishedFiles_.size() + (currentFile_ != nullptr ? 1 : 0));
   for (auto& file : finishedFiles_) {
     spilledFilePaths.push_back(file.path);
   }
@@ -260,7 +138,7 @@ std::unique_ptr<SpillReadFile> SpillReadFile::create(
     const SpillFileInfo& fileInfo,
     uint64_t bufferSize,
     memory::MemoryPool* pool,
-    folly::Synchronized<common::SpillStats>* stats) {
+    exec::SpillStats* stats) {
   return std::unique_ptr<SpillReadFile>(new SpillReadFile(
       fileInfo.id,
       fileInfo.path,
@@ -282,52 +160,42 @@ SpillReadFile::SpillReadFile(
     const std::vector<SpillSortKey>& sortingKeys,
     common::CompressionKind compressionKind,
     memory::MemoryPool* pool,
-    folly::Synchronized<common::SpillStats>* stats)
-    : id_(id),
+    exec::SpillStats* stats)
+    : serializer::SerializedPageFileReader(
+          path,
+          bufferSize,
+          type,
+          getNamedVectorSerde("Presto"),
+          std::make_unique<
+              serializer::presto::PrestoVectorSerde::PrestoOptions>(
+              kDefaultUseLosslessTimestamp,
+              compressionKind,
+              0.8,
+              /*_nullsFirst=*/true),
+          pool,
+          &stats->ioStats),
+      id_(id),
       path_(path),
       size_(size),
-      type_(type),
       sortingKeys_(sortingKeys),
-      compressionKind_(compressionKind),
-      readOptions_{
-          kDefaultUseLosslessTimestamp,
-          compressionKind_,
-          0.8,
-          /*_nullsFirst=*/true},
-      pool_(pool),
-      serde_(getNamedVectorSerde(VectorSerde::Kind::kPresto)),
-      stats_(stats) {
-  auto fs = filesystems::getFileSystem(path_, nullptr);
-  auto file = fs->openFileForRead(path_);
-  input_ = std::make_unique<common::FileInputStream>(
-      std::move(file), bufferSize, pool_);
-}
-
-bool SpillReadFile::nextBatch(RowVectorPtr& rowVector) {
-  if (input_->atEnd()) {
-    recordSpillStats();
-    return false;
-  }
-
-  uint64_t timeNs{0};
-  {
-    NanosecondTimer timer{&timeNs};
-    VectorStreamGroup::read(
-        input_.get(), pool_, type_, serde_, &rowVector, &readOptions_);
-  }
-  stats_->wlock()->spillDeserializationTimeNanos += timeNs;
-  common::updateGlobalSpillDeserializationTimeNs(timeNs);
-  return true;
-}
+      stats_(stats) {}
 
-void SpillReadFile::recordSpillStats() {
+void SpillReadFile::updateFinalStats() {
   VELOX_CHECK(input_->atEnd());
   const auto readStats = input_->stats();
-  common::updateGlobalSpillReadStats(
+  updateGlobalSpillReadStats(
       readStats.numReads, readStats.readBytes, readStats.readTimeNs);
-  auto lockedSpillStats = stats_->wlock();
-  lockedSpillStats->spillReads += readStats.numReads;
-  lockedSpillStats->spillReadTimeNanos += readStats.readTimeNs;
-  lockedSpillStats->spillReadBytes += readStats.readBytes;
-}
+  stats_->spillReads.fetch_add(readStats.numReads, std::memory_order_relaxed);
+  stats_->spillReadBytes.fetch_add(
+      readStats.readBytes, std::memory_order_relaxed);
+  stats_->spillReadTimeNanos.fetch_add(
+      readStats.readTimeNs, std::memory_order_relaxed);
+};
+
+void SpillReadFile::updateSerializationTimeStats(uint64_t timeNs) {
+  stats_->spillDeserializationTimeNanos.fetch_add(
+      timeNs, std::memory_order_relaxed);
+  updateGlobalSpillDeserializationTimeNs(timeNs);
+};
+
 } // namespace facebook::velox::exec
diff --git a/velox/exec/SpillFile.h b/velox/exec/SpillFile.h
index 55547eec0a5..fdedf817d7b 100644
--- a/velox/exec/SpillFile.h
+++ b/velox/exec/SpillFile.h
@@ -17,14 +17,16 @@
 #pragma once
 
 #include <folly/container/F14Set.h>
+#include <optional>
 
 #include "velox/common/base/SpillConfig.h"
-#include "velox/common/base/SpillStats.h"
+#include "velox/common/base/TreeOfLosers.h"
 #include "velox/common/compression/Compression.h"
 #include "velox/common/file/File.h"
 #include "velox/common/file/FileInputStream.h"
-#include "velox/exec/TreeOfLosers.h"
+#include "velox/exec/SpillStats.h"
 #include "velox/serializers/PrestoSerializer.h"
+#include "velox/serializers/SerializedPageFile.h"
 #include "velox/vector/ComplexVector.h"
 #include "velox/vector/DecodedVector.h"
 #include "velox/vector/VectorStream.h"
@@ -32,53 +34,6 @@
 namespace facebook::velox::exec {
 using SpillSortKey = std::pair<column_index_t, CompareFlags>;
 
-/// Represents a spill file for writing the serialized spilled data into a disk
-/// file.
-class SpillWriteFile {
- public:
-  static std::unique_ptr<SpillWriteFile> create(
-      uint32_t id,
-      const std::string& pathPrefix,
-      const std::string& fileCreateConfig);
-
-  uint32_t id() const {
-    return id_;
-  }
-
-  /// Returns the file size in bytes.
-  uint64_t size() const;
-
-  const std::string& path() const {
-    return path_;
-  }
-
-  uint64_t write(std::unique_ptr<folly::IOBuf> iobuf);
-
-  WriteFile* file() {
-    return file_.get();
-  }
-
-  /// Finishes writing and flushes any unwritten data.
-  void finish();
-
- private:
-  static inline std::atomic<int32_t> ordinalCounter_{0};
-
-  SpillWriteFile(
-      uint32_t id,
-      const std::string& pathPrefix,
-      const std::string& fileCreateConfig);
-
-  // The spill file id which is monotonically increasing and unique for each
-  // associated spill partition.
-  const uint32_t id_;
-  const std::string path_;
-
-  std::unique_ptr<WriteFile> file_;
-  // Byte size of the backing file. Set when finishing writing.
-  uint64_t size_{0};
-};
-
 /// Records info of a finished spill file which is used for read.
 struct SpillFileInfo {
   uint32_t id;
@@ -95,7 +50,7 @@ using SpillFiles = std::vector<SpillFileInfo>;
 /// Used to write the spilled data to a sequence of files for one partition. If
 /// data is sorted, each file is sorted. The globally sorted order is produced
 /// by merging the constituent files.
-class SpillWriter {
+class SpillWriter : public serializer::SerializedPageFileWriter {
  public:
   /// 'type' is a RowType describing the content. 'numSortKeys' is the number
   /// of leading columns on which the data is sorted. 'path' is a file path
@@ -116,29 +71,13 @@ class SpillWriter {
       uint64_t targetFileSize,
       uint64_t writeBufferSize,
       const std::string& fileCreateConfig,
-      common::UpdateAndCheckSpillLimitCB& updateAndCheckSpillLimitCb,
+      const common::UpdateAndCheckSpillLimitCB& updateAndCheckSpillLimitCb,
       memory::MemoryPool* pool,
-      folly::Synchronized<common::SpillStats>* stats);
-
-  /// Adds 'rows' for the positions in 'indices' into 'this'. The indices
-  /// must produce a view where the rows are sorted if sorting is desired.
-  /// Consecutive calls must have sorted data so that the first row of the
-  /// next call is not less than the last row of the previous call.
-  /// Returns the size to write.
-  uint64_t write(
-      const RowVectorPtr& rows,
-      const folly::Range<IndexRange*>& indices);
-
-  /// Closes the current output file if any. Subsequent calls to write will
-  /// start a new one.
-  void finishFile();
-
-  /// Returns the number of current finished files.
-  size_t numFinishedFiles() const;
+      exec::SpillStats* stats);
 
   /// Finishes this file writer and returns the written spill files info.
   ///
-  /// NOTE: we don't allow write to a spill writer after t
+  /// NOTE: we don't allow write to a spill writer after finish
   SpillFiles finish();
 
   std::vector<std::string> testingSpilledFilePaths() const;
@@ -146,55 +85,29 @@ class SpillWriter {
   std::vector<uint32_t> testingSpilledFileIds() const;
 
  private:
-  FOLLY_ALWAYS_INLINE void checkNotFinished() const {
-    VELOX_CHECK(!finished_, "SpillWriter has finished");
-  }
-
-  // Returns an open spill file for write. If there is no open spill file, then
-  // the function creates a new one. If the current open spill file exceeds the
-  // target file size limit, then it first closes the current one and then
-  // creates a new one. 'currentFile_' points to the current open spill file.
-  SpillWriteFile* ensureFile();
-
-  // Closes the current open spill file pointed by 'currentFile_'.
-  void closeFile();
-
-  // Writes data from 'batch_' to the current output file. Returns the actual
-  // written size.
-  uint64_t flush();
-
   // Invoked to increment the number of spilled files and the file size.
-  void updateSpilledFileStats(uint64_t fileSize);
+  void updateFileStats(
+      const serializer::SerializedPageFile::FileInfo& fileInfo) override;
 
   // Invoked to update the number of spilled rows.
-  void updateAppendStats(uint64_t numRows, uint64_t serializationTimeUs);
+  void updateAppendStats(uint64_t numRows, uint64_t serializationTimeUs)
+      override;
 
   // Invoked to update the disk write stats.
   void updateWriteStats(
       uint64_t spilledBytes,
       uint64_t flushTimeUs,
-      uint64_t writeTimeUs);
+      uint64_t writeTimeUs) override;
 
   const RowTypePtr type_;
+
   const std::vector<SpillSortKey> sortingKeys_;
-  const common::CompressionKind compressionKind_;
-  const std::string pathPrefix_;
-  const uint64_t targetFileSize_;
-  const uint64_t writeBufferSize_;
-  const std::string fileCreateConfig_;
 
-  // Updates the aggregated spill bytes of this query, and throws if exceeds
-  // the max spill bytes limit.
-  const common::UpdateAndCheckSpillLimitCB updateAndCheckSpillLimitCb_;
-  memory::MemoryPool* const pool_;
-  VectorSerde* const serde_;
-  folly::Synchronized<common::SpillStats>* const stats_;
+  exec::SpillStats* const stats_;
 
-  bool finished_{false};
-  uint32_t nextFileId_{0};
-  std::unique_ptr<VectorStreamGroup> batch_;
-  std::unique_ptr<SpillWriteFile> currentFile_;
-  SpillFiles finishedFiles_;
+  // Updates the aggregated bytes of this query, and throws if exceeds
+  // the max bytes limit.
+  const common::UpdateAndCheckSpillLimitCB updateAndCheckLimitCb_;
 };
 
 /// Represents a spill file for read which turns the serialized spilled data
@@ -204,13 +117,13 @@ class SpillWriter {
 /// needs to remove the unused spill files at some point later. For example, a
 /// query Task deletes all the generated spill files in one operation using
 /// rmdir() call.
-class SpillReadFile {
+class SpillReadFile : public serializer::SerializedPageFileReader {
  public:
   static std::unique_ptr<SpillReadFile> create(
       const SpillFileInfo& fileInfo,
       uint64_t bufferSize,
       memory::MemoryPool* pool,
-      folly::Synchronized<common::SpillStats>* stats);
+      exec::SpillStats* stats);
 
   uint32_t id() const {
     return id_;
@@ -220,8 +133,6 @@ class SpillReadFile {
     return sortingKeys_;
   }
 
-  bool nextBatch(RowVectorPtr& rowVector);
-
   /// Returns the file size in bytes.
   uint64_t size() const {
     return size_;
@@ -241,26 +152,25 @@ class SpillReadFile {
       const std::vector<SpillSortKey>& sortingKeys,
       common::CompressionKind compressionKind,
       memory::MemoryPool* pool,
-      folly::Synchronized<common::SpillStats>* stats);
+      exec::SpillStats* stats);
+
+  // Records spill read stats at the end of read input.
+  void updateFinalStats() override;
 
-  // Invoked to record spill read stats at the end of read input.
-  void recordSpillStats();
+  void updateSerializationTimeStats(uint64_t timeNs) override;
 
   // The spill file id which is monotonically increasing and unique for each
   // associated spill partition.
   const uint32_t id_;
+
   const std::string path_;
+
   // The file size in bytes.
   const uint64_t size_;
-  // The data type of spilled data.
-  const RowTypePtr type_;
+
   const std::vector<SpillSortKey> sortingKeys_;
-  const common::CompressionKind compressionKind_;
-  const serializer::presto::PrestoVectorSerde::PrestoOptions readOptions_;
-  memory::MemoryPool* const pool_;
-  VectorSerde* const serde_;
-  folly::Synchronized<common::SpillStats>* const stats_;
 
-  std::unique_ptr<common::FileInputStream> input_;
+  exec::SpillStats* const stats_;
 };
+
 } // namespace facebook::velox::exec
diff --git a/velox/exec/SpillStats.cpp b/velox/exec/SpillStats.cpp
new file mode 100644
index 00000000000..8b3aef5c0f6
--- /dev/null
+++ b/velox/exec/SpillStats.cpp
@@ -0,0 +1,509 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/SpillStats.h"
+#include <folly/system/HardwareConcurrency.h>
+#include <sstream>
+#include "velox/common/base/Counters.h"
+#include "velox/common/base/StatsReporter.h"
+#include "velox/common/base/SuccinctPrinter.h"
+
+namespace facebook::velox::exec {
+namespace {
+std::vector<SpillStats>& allSpillStats() {
+  static std::vector<SpillStats> spillStatsList(folly::available_concurrency());
+  return spillStatsList;
+}
+
+SpillStats& localSpillStats() {
+  const auto idx = std::hash<std::thread::id>{}(std::this_thread::get_id());
+  auto& spillStatsVector = allSpillStats();
+  return spillStatsVector[idx % spillStatsVector.size()];
+}
+} // namespace
+
+SpillStats::SpillStats(
+    uint64_t _spillRuns,
+    uint64_t _spilledInputBytes,
+    uint64_t _spilledBytes,
+    uint64_t _spilledRows,
+    uint32_t _spilledPartitions,
+    uint64_t _spilledFiles,
+    uint64_t _spillFillTimeNanos,
+    uint64_t _spillSortTimeNanos,
+    uint64_t _spillExtractVectorTimeNanos,
+    uint64_t _spillSerializationTimeNanos,
+    uint64_t _spillWrites,
+    uint64_t _spillFlushTimeNanos,
+    uint64_t _spillWriteTimeNanos,
+    uint64_t _spillMaxLevelExceededCount,
+    uint64_t _spillReadBytes,
+    uint64_t _spillReads,
+    uint64_t _spillReadTimeNanos,
+    uint64_t _spillDeserializationTimeNanos) {
+  spillRuns.store(_spillRuns, std::memory_order_relaxed);
+  spilledInputBytes.store(_spilledInputBytes, std::memory_order_relaxed);
+  spilledBytes.store(_spilledBytes, std::memory_order_relaxed);
+  spilledRows.store(_spilledRows, std::memory_order_relaxed);
+  spilledPartitions.store(_spilledPartitions, std::memory_order_relaxed);
+  spilledFiles.store(_spilledFiles, std::memory_order_relaxed);
+  spillFillTimeNanos.store(_spillFillTimeNanos, std::memory_order_relaxed);
+  spillSortTimeNanos.store(_spillSortTimeNanos, std::memory_order_relaxed);
+  spillExtractVectorTimeNanos.store(
+      _spillExtractVectorTimeNanos, std::memory_order_relaxed);
+  spillSerializationTimeNanos.store(
+      _spillSerializationTimeNanos, std::memory_order_relaxed);
+  spillWrites.store(_spillWrites, std::memory_order_relaxed);
+  spillFlushTimeNanos.store(_spillFlushTimeNanos, std::memory_order_relaxed);
+  spillWriteTimeNanos.store(_spillWriteTimeNanos, std::memory_order_relaxed);
+  spillMaxLevelExceededCount.store(
+      _spillMaxLevelExceededCount, std::memory_order_relaxed);
+  spillReadBytes.store(_spillReadBytes, std::memory_order_relaxed);
+  spillReads.store(_spillReads, std::memory_order_relaxed);
+  spillReadTimeNanos.store(_spillReadTimeNanos, std::memory_order_relaxed);
+  spillDeserializationTimeNanos.store(
+      _spillDeserializationTimeNanos, std::memory_order_relaxed);
+}
+
+SpillStats::SpillStats(const SpillStats& other) {
+  copyFrom(other);
+}
+
+SpillStats& SpillStats::operator=(const SpillStats& other) {
+  if (this != &other) {
+    copyFrom(other);
+  }
+  return *this;
+}
+
+SpillStats& SpillStats::operator+=(const SpillStats& other) {
+  spillRuns.fetch_add(
+      other.spillRuns.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spilledInputBytes.fetch_add(
+      other.spilledInputBytes.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spilledBytes.fetch_add(
+      other.spilledBytes.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spilledRows.fetch_add(
+      other.spilledRows.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spilledPartitions.fetch_add(
+      other.spilledPartitions.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spilledFiles.fetch_add(
+      other.spilledFiles.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillFillTimeNanos.fetch_add(
+      other.spillFillTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillSortTimeNanos.fetch_add(
+      other.spillSortTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillExtractVectorTimeNanos.fetch_add(
+      other.spillExtractVectorTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillSerializationTimeNanos.fetch_add(
+      other.spillSerializationTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillWrites.fetch_add(
+      other.spillWrites.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillFlushTimeNanos.fetch_add(
+      other.spillFlushTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillWriteTimeNanos.fetch_add(
+      other.spillWriteTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillMaxLevelExceededCount.fetch_add(
+      other.spillMaxLevelExceededCount.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillReadBytes.fetch_add(
+      other.spillReadBytes.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillReads.fetch_add(
+      other.spillReads.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillReadTimeNanos.fetch_add(
+      other.spillReadTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillDeserializationTimeNanos.fetch_add(
+      other.spillDeserializationTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  ioStats.merge(other.ioStats);
+  return *this;
+}
+
+bool SpillStats::empty() const {
+  return spilledBytes.load(std::memory_order_relaxed) == 0;
+}
+
+void SpillStats::copyFrom(const SpillStats& other) {
+  spillRuns.store(
+      other.spillRuns.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spilledInputBytes.store(
+      other.spilledInputBytes.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spilledBytes.store(
+      other.spilledBytes.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spilledRows.store(
+      other.spilledRows.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spilledPartitions.store(
+      other.spilledPartitions.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spilledFiles.store(
+      other.spilledFiles.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillFillTimeNanos.store(
+      other.spillFillTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillSortTimeNanos.store(
+      other.spillSortTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillExtractVectorTimeNanos.store(
+      other.spillExtractVectorTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillSerializationTimeNanos.store(
+      other.spillSerializationTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillWrites.store(
+      other.spillWrites.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillFlushTimeNanos.store(
+      other.spillFlushTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillWriteTimeNanos.store(
+      other.spillWriteTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillMaxLevelExceededCount.store(
+      other.spillMaxLevelExceededCount.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillReadBytes.store(
+      other.spillReadBytes.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillReads.store(
+      other.spillReads.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillReadTimeNanos.store(
+      other.spillReadTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  spillDeserializationTimeNanos.store(
+      other.spillDeserializationTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  ioStats.merge(other.ioStats);
+}
+
+SpillStats SpillStats::operator-(const SpillStats& other) const {
+  SpillStats result;
+  result.spillRuns.store(
+      spillRuns.load(std::memory_order_relaxed) -
+          other.spillRuns.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  result.spilledInputBytes.store(
+      spilledInputBytes.load(std::memory_order_relaxed) -
+          other.spilledInputBytes.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  result.spilledBytes.store(
+      spilledBytes.load(std::memory_order_relaxed) -
+          other.spilledBytes.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  result.spilledRows.store(
+      spilledRows.load(std::memory_order_relaxed) -
+          other.spilledRows.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  result.spilledPartitions.store(
+      spilledPartitions.load(std::memory_order_relaxed) -
+          other.spilledPartitions.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  result.spilledFiles.store(
+      spilledFiles.load(std::memory_order_relaxed) -
+          other.spilledFiles.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  result.spillFillTimeNanos.store(
+      spillFillTimeNanos.load(std::memory_order_relaxed) -
+          other.spillFillTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  result.spillSortTimeNanos.store(
+      spillSortTimeNanos.load(std::memory_order_relaxed) -
+          other.spillSortTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  result.spillExtractVectorTimeNanos.store(
+      spillExtractVectorTimeNanos.load(std::memory_order_relaxed) -
+          other.spillExtractVectorTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  result.spillSerializationTimeNanos.store(
+      spillSerializationTimeNanos.load(std::memory_order_relaxed) -
+          other.spillSerializationTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  result.spillWrites.store(
+      spillWrites.load(std::memory_order_relaxed) -
+          other.spillWrites.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  result.spillFlushTimeNanos.store(
+      spillFlushTimeNanos.load(std::memory_order_relaxed) -
+          other.spillFlushTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  result.spillWriteTimeNanos.store(
+      spillWriteTimeNanos.load(std::memory_order_relaxed) -
+          other.spillWriteTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  result.spillMaxLevelExceededCount.store(
+      spillMaxLevelExceededCount.load(std::memory_order_relaxed) -
+          other.spillMaxLevelExceededCount.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  result.spillReadBytes.store(
+      spillReadBytes.load(std::memory_order_relaxed) -
+          other.spillReadBytes.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  result.spillReads.store(
+      spillReads.load(std::memory_order_relaxed) -
+          other.spillReads.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  result.spillReadTimeNanos.store(
+      spillReadTimeNanos.load(std::memory_order_relaxed) -
+          other.spillReadTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  result.spillDeserializationTimeNanos.store(
+      spillDeserializationTimeNanos.load(std::memory_order_relaxed) -
+          other.spillDeserializationTimeNanos.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+  return result;
+}
+
+bool SpillStats::operator==(const SpillStats& other) const {
+  return spillRuns.load(std::memory_order_relaxed) ==
+      other.spillRuns.load(std::memory_order_relaxed) &&
+      spilledInputBytes.load(std::memory_order_relaxed) ==
+      other.spilledInputBytes.load(std::memory_order_relaxed) &&
+      spilledBytes.load(std::memory_order_relaxed) ==
+      other.spilledBytes.load(std::memory_order_relaxed) &&
+      spilledRows.load(std::memory_order_relaxed) ==
+      other.spilledRows.load(std::memory_order_relaxed) &&
+      spilledPartitions.load(std::memory_order_relaxed) ==
+      other.spilledPartitions.load(std::memory_order_relaxed) &&
+      spilledFiles.load(std::memory_order_relaxed) ==
+      other.spilledFiles.load(std::memory_order_relaxed) &&
+      spillFillTimeNanos.load(std::memory_order_relaxed) ==
+      other.spillFillTimeNanos.load(std::memory_order_relaxed) &&
+      spillSortTimeNanos.load(std::memory_order_relaxed) ==
+      other.spillSortTimeNanos.load(std::memory_order_relaxed) &&
+      spillExtractVectorTimeNanos.load(std::memory_order_relaxed) ==
+      other.spillExtractVectorTimeNanos.load(std::memory_order_relaxed) &&
+      spillSerializationTimeNanos.load(std::memory_order_relaxed) ==
+      other.spillSerializationTimeNanos.load(std::memory_order_relaxed) &&
+      spillWrites.load(std::memory_order_relaxed) ==
+      other.spillWrites.load(std::memory_order_relaxed) &&
+      spillFlushTimeNanos.load(std::memory_order_relaxed) ==
+      other.spillFlushTimeNanos.load(std::memory_order_relaxed) &&
+      spillWriteTimeNanos.load(std::memory_order_relaxed) ==
+      other.spillWriteTimeNanos.load(std::memory_order_relaxed) &&
+      spillMaxLevelExceededCount.load(std::memory_order_relaxed) ==
+      other.spillMaxLevelExceededCount.load(std::memory_order_relaxed) &&
+      spillReadBytes.load(std::memory_order_relaxed) ==
+      other.spillReadBytes.load(std::memory_order_relaxed) &&
+      spillReads.load(std::memory_order_relaxed) ==
+      other.spillReads.load(std::memory_order_relaxed) &&
+      spillReadTimeNanos.load(std::memory_order_relaxed) ==
+      other.spillReadTimeNanos.load(std::memory_order_relaxed) &&
+      spillDeserializationTimeNanos.load(std::memory_order_relaxed) ==
+      other.spillDeserializationTimeNanos.load(std::memory_order_relaxed);
+}
+
+void SpillStats::reset() {
+  spillRuns.store(0, std::memory_order_relaxed);
+  spilledInputBytes.store(0, std::memory_order_relaxed);
+  spilledBytes.store(0, std::memory_order_relaxed);
+  spilledRows.store(0, std::memory_order_relaxed);
+  spilledPartitions.store(0, std::memory_order_relaxed);
+  spilledFiles.store(0, std::memory_order_relaxed);
+  spillFillTimeNanos.store(0, std::memory_order_relaxed);
+  spillSortTimeNanos.store(0, std::memory_order_relaxed);
+  spillExtractVectorTimeNanos.store(0, std::memory_order_relaxed);
+  spillSerializationTimeNanos.store(0, std::memory_order_relaxed);
+  spillWrites.store(0, std::memory_order_relaxed);
+  spillFlushTimeNanos.store(0, std::memory_order_relaxed);
+  spillWriteTimeNanos.store(0, std::memory_order_relaxed);
+  spillMaxLevelExceededCount.store(0, std::memory_order_relaxed);
+  spillReadBytes.store(0, std::memory_order_relaxed);
+  spillReads.store(0, std::memory_order_relaxed);
+  spillReadTimeNanos.store(0, std::memory_order_relaxed);
+  spillDeserializationTimeNanos.store(0, std::memory_order_relaxed);
+  ioStats = IoStats();
+}
+
+std::string SpillStats::toString() const {
+  std::stringstream ss;
+  ss << "spillRuns[" << spillRuns.load(std::memory_order_relaxed) << "] "
+     << "spilledInputBytes["
+     << succinctBytes(spilledInputBytes.load(std::memory_order_relaxed)) << "] "
+     << "spilledBytes["
+     << succinctBytes(spilledBytes.load(std::memory_order_relaxed)) << "] "
+     << "spilledRows[" << spilledRows.load(std::memory_order_relaxed) << "] "
+     << "spilledPartitions["
+     << spilledPartitions.load(std::memory_order_relaxed) << "] "
+     << "spilledFiles[" << spilledFiles.load(std::memory_order_relaxed) << "] "
+     << "spillFillTimeNanos["
+     << succinctNanos(spillFillTimeNanos.load(std::memory_order_relaxed))
+     << "] "
+     << "spillSortTimeNanos["
+     << succinctNanos(spillSortTimeNanos.load(std::memory_order_relaxed))
+     << "] "
+     << "spillExtractVectorTime["
+     << succinctNanos(
+            spillExtractVectorTimeNanos.load(std::memory_order_relaxed))
+     << "] "
+     << "spillSerializationTimeNanos["
+     << succinctNanos(
+            spillSerializationTimeNanos.load(std::memory_order_relaxed))
+     << "] "
+     << "spillWrites[" << spillWrites.load(std::memory_order_relaxed) << "] "
+     << "spillFlushTimeNanos["
+     << succinctNanos(spillFlushTimeNanos.load(std::memory_order_relaxed))
+     << "] "
+     << "spillWriteTimeNanos["
+     << succinctNanos(spillWriteTimeNanos.load(std::memory_order_relaxed))
+     << "] "
+     << "maxSpillExceededLimitCount["
+     << spillMaxLevelExceededCount.load(std::memory_order_relaxed) << "] "
+     << "spillReadBytes["
+     << succinctBytes(spillReadBytes.load(std::memory_order_relaxed)) << "] "
+     << "spillReads[" << spillReads.load(std::memory_order_relaxed) << "] "
+     << "spillReadTimeNanos["
+     << succinctNanos(spillReadTimeNanos.load(std::memory_order_relaxed))
+     << "] "
+     << "spillReadDeserializationTimeNanos["
+     << succinctNanos(
+            spillDeserializationTimeNanos.load(std::memory_order_relaxed))
+     << "]";
+
+  const auto ioStatsMap = ioStats.stats();
+  if (!ioStatsMap.empty()) {
+    ss << " ioStats[";
+    bool first = true;
+    for (const auto& [name, metric] : ioStatsMap) {
+      if (!first) {
+        ss << ", ";
+      }
+      first = false;
+      ss << name << ":{sum:" << metric.sum << ", count:" << metric.count
+         << ", min:" << metric.min << ", max:" << metric.max << "}";
+    }
+    ss << "]";
+  }
+  return ss.str();
+}
+
+void updateGlobalSpillRunStats(uint64_t numRuns) {
+  localSpillStats().spillRuns.fetch_add(numRuns, std::memory_order_relaxed);
+}
+
+void updateGlobalSpillAppendStats(
+    uint64_t numRows,
+    uint64_t serializationTimeNs) {
+  RECORD_METRIC_VALUE(kMetricSpilledRowsCount, numRows);
+  RECORD_HISTOGRAM_METRIC_VALUE(
+      kMetricSpillSerializationTimeMs, serializationTimeNs / 1'000'000);
+  auto& stats = localSpillStats();
+  stats.spilledRows.fetch_add(numRows, std::memory_order_relaxed);
+  stats.spillSerializationTimeNanos.fetch_add(
+      serializationTimeNs, std::memory_order_relaxed);
+}
+
+void incrementGlobalSpilledPartitionStats() {
+  localSpillStats().spilledPartitions.fetch_add(1, std::memory_order_relaxed);
+}
+
+void updateGlobalSpillFillTime(uint64_t timeNs) {
+  RECORD_HISTOGRAM_METRIC_VALUE(kMetricSpillFillTimeMs, timeNs / 1'000'000);
+  localSpillStats().spillFillTimeNanos.fetch_add(
+      timeNs, std::memory_order_relaxed);
+}
+
+void updateGlobalSpillSortTime(uint64_t timeNs) {
+  RECORD_HISTOGRAM_METRIC_VALUE(kMetricSpillSortTimeMs, timeNs / 1'000'000);
+  localSpillStats().spillSortTimeNanos.fetch_add(
+      timeNs, std::memory_order_relaxed);
+}
+
+void updateGlobalSpillExtractVectorTime(uint64_t timeNs) {
+  RECORD_HISTOGRAM_METRIC_VALUE(
+      kMetricSpillExtractVectorTimeMs, timeNs / 1'000'000);
+  localSpillStats().spillExtractVectorTimeNanos.fetch_add(
+      timeNs, std::memory_order_relaxed);
+}
+
+void updateGlobalSpillWriteStats(
+    uint64_t spilledBytes,
+    uint64_t flushTimeNs,
+    uint64_t writeTimeNs) {
+  RECORD_METRIC_VALUE(kMetricSpillWritesCount);
+  RECORD_METRIC_VALUE(kMetricSpilledBytes, spilledBytes);
+  RECORD_HISTOGRAM_METRIC_VALUE(
+      kMetricSpillFlushTimeMs, flushTimeNs / 1'000'000);
+  RECORD_HISTOGRAM_METRIC_VALUE(
+      kMetricSpillWriteTimeMs, writeTimeNs / 1'000'000);
+  auto& stats = localSpillStats();
+  stats.spillWrites.fetch_add(1, std::memory_order_relaxed);
+  stats.spilledBytes.fetch_add(spilledBytes, std::memory_order_relaxed);
+  stats.spillFlushTimeNanos.fetch_add(flushTimeNs, std::memory_order_relaxed);
+  stats.spillWriteTimeNanos.fetch_add(writeTimeNs, std::memory_order_relaxed);
+}
+
+void updateGlobalSpillReadStats(
+    uint64_t spillReads,
+    uint64_t spillReadBytes,
+    uint64_t spillReadTimeNs) {
+  auto& stats = localSpillStats();
+  stats.spillReads.fetch_add(spillReads, std::memory_order_relaxed);
+  stats.spillReadBytes.fetch_add(spillReadBytes, std::memory_order_relaxed);
+  stats.spillReadTimeNanos.fetch_add(
+      spillReadTimeNs, std::memory_order_relaxed);
+}
+
+void updateGlobalSpillMemoryBytes(uint64_t spilledInputBytes) {
+  RECORD_METRIC_VALUE(kMetricSpilledInputBytes, spilledInputBytes);
+  localSpillStats().spilledInputBytes.fetch_add(
+      spilledInputBytes, std::memory_order_relaxed);
+}
+
+void incrementGlobalSpilledFiles() {
+  RECORD_METRIC_VALUE(kMetricSpilledFilesCount);
+  localSpillStats().spilledFiles.fetch_add(1, std::memory_order_relaxed);
+}
+
+void updateGlobalMaxSpillLevelExceededCount(
+    uint64_t maxSpillLevelExceededCount) {
+  localSpillStats().spillMaxLevelExceededCount.fetch_add(
+      maxSpillLevelExceededCount, std::memory_order_relaxed);
+}
+
+void updateGlobalSpillDeserializationTimeNs(uint64_t timeNs) {
+  localSpillStats().spillDeserializationTimeNanos.fetch_add(
+      timeNs, std::memory_order_relaxed);
+}
+
+SpillStats globalSpillStats() {
+  SpillStats gSpillStats;
+  for (auto& stats : allSpillStats()) {
+    gSpillStats += stats;
+  }
+  return gSpillStats;
+}
+} // namespace facebook::velox::exec
diff --git a/velox/common/base/SpillStats.h b/velox/exec/SpillStats.h
similarity index 76%
rename from velox/common/base/SpillStats.h
rename to velox/exec/SpillStats.h
index 36e3c7b33e7..7f4c09e2652 100644
--- a/velox/common/base/SpillStats.h
+++ b/velox/exec/SpillStats.h
@@ -15,60 +15,62 @@
  */
 #pragma once
 
-#include <compare>
+#include <atomic>
 #include <cstdint>
-#include <cstring>
 
-#include <folly/executors/CPUThreadPoolExecutor.h>
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/file/File.h"
 
-#include "velox/common/compression/Compression.h"
+namespace facebook::velox::exec {
 
-namespace facebook::velox::common {
-/// Provides the fine-grained spill execution stats.
+/// Thread-safe spill statistics with atomic members.
 struct SpillStats {
   /// The number of times that spilling runs on an operator.
-  uint64_t spillRuns{0};
-  /// The number of bytes in memory to spill
-  uint64_t spilledInputBytes{0};
+  std::atomic_uint64_t spillRuns{0};
+  /// The number of bytes in memory to spill.
+  std::atomic_uint64_t spilledInputBytes{0};
   /// The number of bytes spilled to disks.
-  ///
   /// NOTE: if compression is enabled, this counts the compressed bytes.
-  uint64_t spilledBytes{0};
+  std::atomic_uint64_t spilledBytes{0};
   /// The number of spilled rows.
-  uint64_t spilledRows{0};
+  std::atomic_uint64_t spilledRows{0};
   /// NOTE: when we sum up the stats from a group of spill operators, it is
   /// the total number of spilled partitions X number of operators.
-  uint32_t spilledPartitions{0};
+  std::atomic_uint32_t spilledPartitions{0};
   /// The number of spilled files.
-  uint64_t spilledFiles{0};
+  std::atomic_uint64_t spilledFiles{0};
   /// The time spent on filling rows for spilling.
-  uint64_t spillFillTimeNanos{0};
+  std::atomic_uint64_t spillFillTimeNanos{0};
   /// The time spent on sorting rows for spilling.
-  uint64_t spillSortTimeNanos{0};
+  std::atomic_uint64_t spillSortTimeNanos{0};
   /// The time spent on extracting vector from RowContainer for spilling.
-  uint64_t spillExtractVectorTimeNanos{0};
+  std::atomic_uint64_t spillExtractVectorTimeNanos{0};
   /// The time spent on serializing rows for spilling.
-  uint64_t spillSerializationTimeNanos{0};
+  std::atomic_uint64_t spillSerializationTimeNanos{0};
   /// The number of spill writer flushes, equivalent to number of write calls to
   /// underlying filesystem.
-  uint64_t spillWrites{0};
+  std::atomic_uint64_t spillWrites{0};
   /// The time spent on copy out serialized rows for disk write. If compression
   /// is enabled, this includes the compression time.
-  uint64_t spillFlushTimeNanos{0};
+  std::atomic_uint64_t spillFlushTimeNanos{0};
   /// The time spent on writing spilled rows to disk.
-  uint64_t spillWriteTimeNanos{0};
+  std::atomic_uint64_t spillWriteTimeNanos{0};
   /// The number of times that an hash build operator exceeds the max spill
   /// limit.
-  uint64_t spillMaxLevelExceededCount{0};
+  std::atomic_uint64_t spillMaxLevelExceededCount{0};
   /// The number of bytes read from spilled files.
-  uint64_t spillReadBytes{0};
+  std::atomic_uint64_t spillReadBytes{0};
   /// The number of spill reader reads, equivalent to the number of read calls
   /// to the underlying filesystem.
-  uint64_t spillReads{0};
+  std::atomic_uint64_t spillReads{0};
   /// The time spent on read data from spilled files.
-  uint64_t spillReadTimeNanos{0};
+  std::atomic_uint64_t spillReadTimeNanos{0};
   /// The time spent on deserializing rows read from spilled files.
-  uint64_t spillDeserializationTimeNanos{0};
+  std::atomic_uint64_t spillDeserializationTimeNanos{0};
+  /// Filesystem I/O stats for spill operations.
+  IoStats ioStats;
+
+  SpillStats() = default;
 
   SpillStats(
       uint64_t _spillRuns,
@@ -90,24 +92,29 @@ struct SpillStats {
       uint64_t _spillReadTimeNanos,
       uint64_t _spillDeserializationTimeNanos);
 
-  SpillStats() = default;
+  SpillStats(const SpillStats& other);
 
-  bool empty() const {
-    return spilledBytes == 0;
-  }
+  SpillStats& operator=(const SpillStats& other);
 
   SpillStats& operator+=(const SpillStats& other);
+
   SpillStats operator-(const SpillStats& other) const;
-  bool operator==(const SpillStats& other) const = default;
+
+  bool operator==(const SpillStats& other) const;
+
+  bool empty() const;
 
   void reset();
 
   std::string toString() const;
+
+ private:
+  void copyFrom(const SpillStats& other);
 };
 
 FOLLY_ALWAYS_INLINE std::ostream& operator<<(
     std::ostream& o,
-    const common::SpillStats& stats) {
+    const SpillStats& stats) {
   return o << stats.toString();
 }
 
@@ -163,12 +170,12 @@ void updateGlobalSpillDeserializationTimeNs(uint64_t timeNs);
 
 /// Gets the cumulative global spill stats.
 SpillStats globalSpillStats();
-} // namespace facebook::velox::common
+} // namespace facebook::velox::exec
 
 template <>
-struct fmt::formatter<facebook::velox::common::SpillStats>
+struct fmt::formatter<facebook::velox::exec::SpillStats>
     : fmt::formatter<std::string> {
-  auto format(const facebook::velox::common::SpillStats& s, format_context& ctx)
+  auto format(const facebook::velox::exec::SpillStats& s, format_context& ctx)
       const {
     return formatter<std::string>::format(s.toString(), ctx);
   }
diff --git a/velox/exec/Spiller.cpp b/velox/exec/Spiller.cpp
index 35352aed980..65de8a906ce 100644
--- a/velox/exec/Spiller.cpp
+++ b/velox/exec/Spiller.cpp
@@ -37,7 +37,7 @@ SpillerBase::SpillerBase(
     uint64_t maxSpillRunRows,
     std::optional<SpillPartitionId> parentId,
     const common::SpillConfig* spillConfig,
-    folly::Synchronized<common::SpillStats>* spillStats)
+    exec::SpillStats* spillStats)
     : container_(container),
       executor_(spillConfig->executor),
       bits_(bits),
@@ -101,8 +101,9 @@ bool SpillerBase::fillSpillRuns(RowContainerIterator* iterator) {
 
     uint64_t totalRows{0};
     for (;;) {
-      const auto numRows = container_->listRows(
-          iterator, rows.size(), RowContainer::kUnlimited, rows.data());
+      // TODO: Reuse 'RowContainer::rowPointers_'.
+      const auto numRows =
+          container_->listRows(iterator, rows.size(), rows.data());
       if (numRows == 0) {
         lastRun = true;
         break;
@@ -143,7 +144,7 @@ bool SpillerBase::fillSpillRuns(RowContainerIterator* iterator) {
 }
 
 void SpillerBase::runSpill(bool lastRun) {
-  ++spillStats_->wlock()->spillRuns;
+  spillStats_->spillRuns.fetch_add(1, std::memory_order_relaxed);
 
   std::vector<std::shared_ptr<AsyncSource<SpillStatus>>> writes;
   for (const auto& [id, spillRun] : spillRuns_) {
@@ -154,8 +155,9 @@ void SpillerBase::runSpill(bool lastRun) {
     if (spillRun.rows.empty()) {
       continue;
     }
-    writes.push_back(memory::createAsyncMemoryReclaimTask<SpillStatus>(
-        [partitionId = id, this]() { return writeSpill(partitionId); }));
+    writes.push_back(
+        memory::createAsyncMemoryReclaimTask<SpillStatus>(
+            [partitionId = id, this]() { return writeSpill(partitionId); }));
     if ((writes.size() > 1) && executor_ != nullptr) {
       executor_->add([source = writes.back()]() { source->prepare(); });
     }
@@ -307,13 +309,14 @@ void SpillerBase::extractSpill(
 }
 
 void SpillerBase::updateSpillExtractVectorTime(uint64_t timeNs) {
-  spillStats_->wlock()->spillExtractVectorTimeNanos += timeNs;
-  common::updateGlobalSpillExtractVectorTime(timeNs);
+  spillStats_->spillExtractVectorTimeNanos.fetch_add(
+      timeNs, std::memory_order_relaxed);
+  updateGlobalSpillExtractVectorTime(timeNs);
 }
 
 void SpillerBase::updateSpillSortTime(uint64_t timeNs) {
-  spillStats_->wlock()->spillSortTimeNanos += timeNs;
-  common::updateGlobalSpillSortTime(timeNs);
+  spillStats_->spillSortTimeNanos.fetch_add(timeNs, std::memory_order_relaxed);
+  updateGlobalSpillSortTime(timeNs);
 }
 
 void SpillerBase::checkEmptySpillRuns() const {
@@ -326,8 +329,8 @@ void SpillerBase::checkEmptySpillRuns() const {
 }
 
 void SpillerBase::updateSpillFillTime(uint64_t timeNs) {
-  spillStats_->wlock()->spillFillTimeNanos += timeNs;
-  common::updateGlobalSpillFillTime(timeNs);
+  spillStats_->spillFillTimeNanos.fetch_add(timeNs, std::memory_order_relaxed);
+  updateGlobalSpillFillTime(timeNs);
 }
 
 void SpillerBase::finishSpill(SpillPartitionSet& partitionSet) {
@@ -352,8 +355,8 @@ void SpillerBase::finishSpill(SpillPartitionSet& partitionSet) {
   }
 }
 
-common::SpillStats SpillerBase::stats() const {
-  return spillStats_->copy();
+exec::SpillStats SpillerBase::stats() const {
+  return *spillStats_;
 }
 
 std::string SpillerBase::toString() const {
@@ -387,7 +390,7 @@ NoRowContainerSpiller::NoRowContainerSpiller(
     std::optional<SpillPartitionId> parentId,
     HashBitRange bits,
     const common::SpillConfig* spillConfig,
-    folly::Synchronized<common::SpillStats>* spillStats)
+    exec::SpillStats* spillStats)
     : NoRowContainerSpiller(
           std::move(rowType),
           parentId,
@@ -402,7 +405,7 @@ NoRowContainerSpiller::NoRowContainerSpiller(
     HashBitRange bits,
     const std::vector<SpillSortKey>& sortingKeys,
     const common::SpillConfig* spillConfig,
-    folly::Synchronized<common::SpillStats>* spillStats)
+    exec::SpillStats* spillStats)
     : SpillerBase(
           nullptr,
           std::move(rowType),
@@ -435,7 +438,7 @@ SortOutputSpiller::SortOutputSpiller(
     RowContainer* container,
     RowTypePtr rowType,
     const common::SpillConfig* spillConfig,
-    folly::Synchronized<common::SpillStats>* spillStats)
+    exec::SpillStats* spillStats)
     : SpillerBase(
           container,
           std::move(rowType),
diff --git a/velox/exec/Spiller.h b/velox/exec/Spiller.h
index 9151a7eaf53..f651338fcea 100644
--- a/velox/exec/Spiller.h
+++ b/velox/exec/Spiller.h
@@ -17,6 +17,7 @@
 
 #include "velox/common/base/SpillConfig.h"
 #include "velox/common/compression/Compression.h"
+#include "velox/common/file/FileSystems.h"
 #include "velox/exec/HashBitRange.h"
 #include "velox/exec/RowContainer.h"
 
@@ -46,7 +47,7 @@ class SpillerBase {
     return finalized_;
   }
 
-  common::SpillStats stats() const;
+  exec::SpillStats stats() const;
 
   std::string toString() const;
 
@@ -60,7 +61,7 @@ class SpillerBase {
       uint64_t maxSpillRunRows,
       std::optional<SpillPartitionId> parentId,
       const common::SpillConfig* spillConfig,
-      folly::Synchronized<common::SpillStats>* spillStats);
+      exec::SpillStats* spillStats);
 
   // Invoked to spill. If 'startRowIter' is not null, then we only spill rows
   // from row container starting at the offset pointed by 'startRowIter'.
@@ -148,7 +149,7 @@ class SpillerBase {
 
   const std::optional<SpillPartitionId> parentId_;
 
-  folly::Synchronized<common::SpillStats>* const spillStats_;
+  exec::SpillStats* const spillStats_;
 
   const std::vector<CompareFlags> compareFlags_;
 
@@ -207,7 +208,7 @@ class NoRowContainerSpiller : public SpillerBase {
       std::optional<SpillPartitionId> parentId,
       HashBitRange bits,
       const common::SpillConfig* spillConfig,
-      folly::Synchronized<common::SpillStats>* spillStats);
+      exec::SpillStats* spillStats);
 
   void spill(
       const SpillPartitionId& partitionId,
@@ -226,7 +227,7 @@ class NoRowContainerSpiller : public SpillerBase {
       HashBitRange bits,
       const std::vector<SpillSortKey>& sortingKeys,
       const common::SpillConfig* spillConfig,
-      folly::Synchronized<common::SpillStats>* spillStats);
+      exec::SpillStats* spillStats);
 
  private:
   std::string type() const override {
@@ -246,7 +247,7 @@ class MergeSpiller final : public NoRowContainerSpiller {
       HashBitRange bits,
       const std::vector<SpillSortKey>& sortingKeys,
       const common::SpillConfig* spillConfig,
-      folly::Synchronized<common::SpillStats>* spillStats)
+      exec::SpillStats* spillStats)
       : NoRowContainerSpiller(
             std::move(rowType),
             parentId,
@@ -265,7 +266,7 @@ class SortInputSpiller : public SpillerBase {
       RowTypePtr rowType,
       const std::vector<SpillSortKey>& sortingKeys,
       const common::SpillConfig* spillConfig,
-      folly::Synchronized<common::SpillStats>* spillStats)
+      exec::SpillStats* spillStats)
       : SpillerBase(
             container,
             std::move(rowType),
@@ -297,7 +298,7 @@ class SortOutputSpiller : public SpillerBase {
       RowContainer* container,
       RowTypePtr rowType,
       const common::SpillConfig* spillConfig,
-      folly::Synchronized<common::SpillStats>* spillStats);
+      exec::SpillStats* spillStats);
 
   void spill(SpillRows& rows);
 
diff --git a/velox/exec/Split.h b/velox/exec/Split.h
index 1ccdcaeba16..58913feb951 100644
--- a/velox/exec/Split.h
+++ b/velox/exec/Split.h
@@ -15,7 +15,11 @@
  */
 #pragma once
 
+#include <cstdint>
+#include <optional>
+
 #include "velox/connectors/Connector.h"
+#include "velox/exec/BarrierSplit.h"
 
 namespace facebook::velox::exec {
 
@@ -23,10 +27,8 @@ struct Split {
   std::shared_ptr<velox::connector::ConnectorSplit> connectorSplit{nullptr};
   int32_t groupId{-1}; // Bucketed group id (-1 means 'none').
 
-  /// Indicates if this is a barrier split. A barrier split is used by task
-  /// barrier processing which adds one barrier split to each leaf source node
-  /// to signal the output drain processing.
-  bool barrier{false};
+  /// Indicates if this is a barrier split.
+  std::optional<BarrierSplit> barrier;
 
   Split() = default;
 
@@ -36,9 +38,10 @@ struct Split {
       : connectorSplit(std::move(connectorSplit)), groupId(groupId) {}
 
   /// Called by the task barrier to create a special barrier split.
-  static Split createBarrier() {
-    static Split barrierSplit;
-    barrierSplit.barrier = true;
+  static Split createBarrier(uint32_t numDrivers = 1) {
+    Split barrierSplit;
+    barrierSplit.barrier = BarrierSplit{numDrivers};
+    VELOX_CHECK_NULL(barrierSplit.connectorSplit);
     return barrierSplit;
   }
 
@@ -48,7 +51,7 @@ struct Split {
   Split& operator=(const Split& other) = default;
 
   bool isBarrier() const {
-    return barrier;
+    return barrier.has_value();
   }
 
   inline bool hasConnectorSplit() const {
diff --git a/velox/exec/StreamingAggregation.cpp b/velox/exec/StreamingAggregation.cpp
index 873e2e853ce..ef21af360f6 100644
--- a/velox/exec/StreamingAggregation.cpp
+++ b/velox/exec/StreamingAggregation.cpp
@@ -15,6 +15,11 @@
  */
 
 #include "velox/exec/StreamingAggregation.h"
+#include "velox/common/testutil/TestValue.h"
+
+using facebook::velox::common::testutil::TestValue;
+
+#include "velox/exec/OperatorType.h"
 
 namespace facebook::velox::exec {
 
@@ -28,8 +33,8 @@ StreamingAggregation::StreamingAggregation(
           operatorId,
           aggregationNode->id(),
           aggregationNode->step() == core::AggregationNode::Step::kPartial
-              ? "PartialAggregation"
-              : "Aggregation"),
+              ? OperatorType::kPartialAggregation
+              : OperatorType::kAggregation),
       maxOutputBatchSize_{outputBatchRows()},
       minOutputBatchSize_{
           operatorCtx_->driverCtx()
@@ -41,8 +46,11 @@ StreamingAggregation::StreamingAggregation(
                         ->queryConfig()
                         .streamingAggregationMinOutputBatchRows())
               : maxOutputBatchSize_},
+      maxOutputBatchBytes_{
+          operatorCtx_->driverCtx()->queryConfig().preferredOutputBatchBytes()},
       aggregationNode_{aggregationNode},
-      step_{aggregationNode->step()} {
+      step_{aggregationNode->step()},
+      noGroupsSpanBatches_{aggregationNode_->noGroupsSpanBatches()} {
   if (aggregationNode_->ignoreNullKeys()) {
     VELOX_UNSUPPORTED(
         "Streaming aggregation doesn't support ignoring null keys yet");
@@ -180,6 +188,14 @@ RowVectorPtr StreamingAggregation::createOutput(size_t numGroups) {
     } else {
       function->extractValues(groups_.data(), numGroups, &result);
     }
+
+    // Clear any state the aggregations may be holding onto and return them
+    // to a valid initial state.
+    function->destroy(folly::Range<char**>(groups_.data(), numGroups));
+    std::vector<vector_size_t> newGroups;
+    newGroups.resize(numGroups);
+    std::iota(newGroups.begin(), newGroups.end(), 0);
+    function->initializeNewGroups(groups_.data(), newGroups);
   }
 
   if (sortedAggregations_) {
@@ -194,6 +210,9 @@ RowVectorPtr StreamingAggregation::createOutput(size_t numGroups) {
     }
   }
 
+  TestValue::adjust(
+      "facebook::velox::exec::StreamingAggregation::createOutput", this);
+
   std::rotate(groups_.begin(), groups_.begin() + numGroups, groups_.end());
   numGroups_ -= numGroups;
 
@@ -356,23 +375,42 @@ RowVectorPtr StreamingAggregation::getOutput() {
   initializeNewGroups(numPrevGroups);
   evaluateAggregates();
 
+  const auto estimatedRowBytes = rows_->estimateRowSize();
+  const auto estimatedBatchBytes =
+      estimatedRowBytes.value_or(0) * rows_->numRows();
+
   RowVectorPtr output;
 
-  if ((numPrevGroups != 0) && (numGroups_ > minOutputBatchSize_)) {
+  // we do not respect minOutputBatchRows or outputDueToBatchBytes
+  // when noGroupsSpanBatches is set
+  const bool outputDueToBatchSize = numGroups_ > minOutputBatchSize_;
+  const bool outputDueToBatchBytes =
+      numGroups_ > 1 && estimatedBatchBytes > maxOutputBatchBytes_;
+  if (noGroupsSpanBatches_ ||
+      (numPrevGroups > 0 && (outputDueToBatchSize || outputDueToBatchBytes))) {
     size_t numOutputGroups{0};
-    // NOTE: we only want to apply the single group output optimization if
-    // 'minOutputBatchSize_' is set to one for eagerly streaming output
-    // producing.
-    if (!prevGroupAssigned || numPrevGroups == 1 || minOutputBatchSize_ != 1) {
-      numOutputGroups = std::min(numGroups_ - 1, numPrevGroups);
+    if (noGroupsSpanBatches_) {
+      numOutputGroups = numGroups_;
     } else {
-      numOutputGroups = std::min(numGroups_ - 1, numPrevGroups - 1);
-      outputFirstGroup_ = (numGroups_ - numOutputGroups) > 1;
+      // NOTE: we only want to apply the single group output optimization if
+      // 'minOutputBatchSize_' is set to one for eagerly streaming output
+      // producing.
+      if (!prevGroupAssigned || numPrevGroups == 1 ||
+          minOutputBatchSize_ != 1) {
+        numOutputGroups = std::min(numGroups_ - 1, numPrevGroups);
+      } else {
+        numOutputGroups = std::min(numGroups_ - 1, numPrevGroups - 1);
+        outputFirstGroup_ = (numGroups_ - numOutputGroups) > 1;
+      }
     }
     VELOX_CHECK_GT(numOutputGroups, 0);
     output = createOutput(numOutputGroups);
   }
   prevInput_ = input_;
+  if (numGroups_ == 0) {
+    VELOX_CHECK(noGroupsSpanBatches_);
+    prevInput_ = nullptr;
+  }
   input_ = nullptr;
   return output;
 }
@@ -404,6 +442,8 @@ std::unique_ptr<RowContainer> StreamingAggregation::makeRowContainer(
       false,
       false,
       false,
+      false, // hasCountFlag
+      false,
       false,
       pool());
 }
diff --git a/velox/exec/StreamingAggregation.h b/velox/exec/StreamingAggregation.h
index d01e8e36274..5fcf5d4b729 100644
--- a/velox/exec/StreamingAggregation.h
+++ b/velox/exec/StreamingAggregation.h
@@ -96,11 +96,20 @@ class StreamingAggregation : public Operator {
   // Maximum number of rows in the output batch.
   const vector_size_t minOutputBatchSize_;
 
+  // If the size of the data in the RowContainer exceeds this value, we will
+  // output a batch regardless of the number of rows.
+  const uint64_t maxOutputBatchBytes_;
+
   // Used at initialize() and gets reset() afterward.
   std::shared_ptr<const core::AggregationNode> aggregationNode_;
 
   const core::AggregationNode::Step step_;
 
+  // When true, indicates that no sort group spans across input batches. Each
+  // input batch contains complete data for its groups. This allows the
+  // streaming aggregation operator to produce all group results for each input.
+  const bool noGroupsSpanBatches_;
+
   std::vector<column_index_t> groupingKeys_;
   std::vector<AggregateInfo> aggregates_;
   std::unique_ptr<SortedAggregations> sortedAggregations_;
diff --git a/velox/exec/StreamingEnforceDistinct.cpp b/velox/exec/StreamingEnforceDistinct.cpp
new file mode 100644
index 00000000000..e19c6bbe01d
--- /dev/null
+++ b/velox/exec/StreamingEnforceDistinct.cpp
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/StreamingEnforceDistinct.h"
+
+#include "velox/exec/OperatorType.h"
+
+namespace facebook::velox::exec {
+
+namespace {
+// Compares two rows in the same or different vectors and returns true if they
+// match in all key columns.
+bool equalKeys(
+    const std::vector<column_index_t>& keyChannels,
+    const RowVectorPtr& batch,
+    vector_size_t index,
+    const RowVectorPtr& otherBatch,
+    vector_size_t otherIndex) {
+  for (auto channel : keyChannels) {
+    if (!batch->childAt(channel)->equalValueAt(
+            otherBatch->childAt(channel).get(), index, otherIndex)) {
+      return false;
+    }
+  }
+  return true;
+}
+} // namespace
+
+StreamingEnforceDistinct::StreamingEnforceDistinct(
+    int32_t operatorId,
+    DriverCtx* driverCtx,
+    const std::shared_ptr<const core::EnforceDistinctNode>& planNode)
+    : Operator(
+          driverCtx,
+          planNode->outputType(),
+          operatorId,
+          planNode->id(),
+          OperatorType::kStreamingEnforceDistinct),
+      inputType_{planNode->sources()[0]->outputType()},
+      keyChannels_{toChannels(
+          inputType_,
+          std::vector<core::TypedExprPtr>{
+              planNode->distinctKeys().begin(),
+              planNode->distinctKeys().end()})},
+      errorMessage_{planNode->errorMessage()} {
+  for (auto i = 0; i < inputType_->size(); ++i) {
+    identityProjections_.emplace_back(i, i);
+  }
+}
+
+void StreamingEnforceDistinct::addInput(RowVectorPtr input) {
+  if (input->size() == 0) {
+    return;
+  }
+
+  // Check first row against previous batch's last row.
+  if (prevKeyValues_ != nullptr &&
+      equalKeys(keyChannels_, input, 0, prevKeyValues_, 0)) {
+    VELOX_USER_FAIL("{}", errorMessage_);
+  }
+
+  // Check consecutive rows within this batch.
+  for (vector_size_t i = 1; i < input->size(); ++i) {
+    if (equalKeys(keyChannels_, input, i, input, i - 1)) {
+      VELOX_USER_FAIL("{}", errorMessage_);
+    }
+  }
+
+  // Save key values from the last row for comparison with next batch.
+
+  if (prevKeyValues_ == nullptr) {
+    std::vector<VectorPtr> keyVectors(inputType_->size());
+    for (auto channel : keyChannels_) {
+      keyVectors[channel] =
+          BaseVector::create(inputType_->childAt(channel), 1, pool());
+    }
+    prevKeyValues_ = std::make_shared<RowVector>(
+        pool(), inputType_, nullptr, 1, std::move(keyVectors));
+  }
+
+  const auto lastRow = input->size() - 1;
+  for (auto channel : keyChannels_) {
+    prevKeyValues_->childAt(channel)->copy(
+        input->childAt(channel).get(), 0, lastRow, 1);
+  }
+
+  input_ = std::move(input);
+}
+
+RowVectorPtr StreamingEnforceDistinct::getOutput() {
+  if (isFinished() || !input_) {
+    return nullptr;
+  }
+
+  auto output = fillOutput(input_->size(), nullptr);
+  input_ = nullptr;
+  return output;
+}
+
+bool StreamingEnforceDistinct::isFinished() {
+  return noMoreInput_ && !input_;
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/StreamingEnforceDistinct.h b/velox/exec/StreamingEnforceDistinct.h
new file mode 100644
index 00000000000..5f22c098712
--- /dev/null
+++ b/velox/exec/StreamingEnforceDistinct.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/exec/Operator.h"
+
+namespace facebook::velox::exec {
+
+/// Streaming implementation of EnforceDistinct for pre-grouped input.
+/// Compares each row with the previous row to detect duplicates.
+/// Memory usage is O(1) - only stores the previous row's key values.
+///
+/// Use this operator when input is clustered on distinct keys, i.e., rows with
+/// the same key values are guaranteed to be adjacent.
+class StreamingEnforceDistinct : public Operator {
+ public:
+  StreamingEnforceDistinct(
+      int32_t operatorId,
+      DriverCtx* driverCtx,
+      const std::shared_ptr<const core::EnforceDistinctNode>& planNode);
+
+  bool preservesOrder() const override {
+    return true;
+  }
+
+  bool needsInput() const override {
+    return !noMoreInput_ && !input_;
+  }
+
+  void addInput(RowVectorPtr input) override;
+
+  RowVectorPtr getOutput() override;
+
+  BlockingReason isBlocked(ContinueFuture* /*future*/) override {
+    return BlockingReason::kNotBlocked;
+  }
+
+  bool isFinished() override;
+
+ private:
+  const RowTypePtr inputType_;
+  const std::vector<column_index_t> keyChannels_;
+  const std::string errorMessage_;
+
+  // Key values from the last row of the previous batch for cross-batch
+  // comparison. Lazily initialized on first input batch.
+  RowVectorPtr prevKeyValues_;
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/SubPartitionedSortWindowBuild.cpp b/velox/exec/SubPartitionedSortWindowBuild.cpp
new file mode 100644
index 00000000000..2f2a247a8d4
--- /dev/null
+++ b/velox/exec/SubPartitionedSortWindowBuild.cpp
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/SubPartitionedSortWindowBuild.h"
+#include "velox/exec/MemoryReclaimer.h"
+
+namespace facebook::velox::exec {
+
+SubPartitionedSortWindowBuild::SubPartitionedSortWindowBuild(
+    const std::shared_ptr<const core::WindowNode>& node,
+    int32_t numSubPartitions,
+    velox::memory::MemoryPool* pool,
+    common::PrefixSortConfig&& prefixSortConfig,
+    const common::SpillConfig* spillConfig,
+    tsan_atomic<bool>* nonReclaimableSection,
+    folly::Synchronized<OperatorStats>* opStats,
+    exec::SpillStats* spillStats)
+    : WindowBuild(node, pool, spillConfig, nonReclaimableSection),
+      numSubPartitions_(numSubPartitions),
+      numPartitionKeys_{node->partitionKeys().size()},
+      pool_(pool),
+      spillStats_(spillStats) {
+  VELOX_CHECK_NOT_NULL(pool_);
+  data_.reset();
+
+  std::vector<column_index_t> keyChannels(numPartitionKeys_);
+  for (int i = 0; i < numPartitionKeys_; i++) {
+    keyChannels[i] = inputChannels_[i];
+  }
+  subPartitioningFunction_ = std::make_unique<HashPartitionFunction>(
+      false, numSubPartitions_, node->inputType(), keyChannels);
+  subWindowBuilds_.resize(numSubPartitions_);
+  for (int i = 0; i < numSubPartitions_; i++) {
+    subWindowBuilds_[i] = std::make_unique<SortWindowBuild>(
+        node,
+        pool,
+        common::PrefixSortConfig(prefixSortConfig),
+        spillConfig,
+        nonReclaimableSection,
+        opStats,
+        spillStats);
+  }
+}
+
+void SubPartitionedSortWindowBuild::addInput(RowVectorPtr input) {
+  VELOX_CHECK_LT(currentSubPartition_, 0);
+
+  subPartitionIdsBuffer_.resize(input->size());
+  subPartitioningFunction_->partition(*input, subPartitionIdsBuffer_);
+
+  for (auto i = 0; i < inputChannels_.size(); ++i) {
+    decodedInputVectors_[i].decode(*input->childAt(inputChannels_[i]));
+  }
+
+  ensureInputFits(input);
+
+  for (auto row = 0; row < input->size(); ++row) {
+    auto& windowBuild = subWindowBuilds_[subPartitionIdsBuffer_[row]];
+    windowBuild->addDecodedInputRow(decodedInputVectors_, row);
+  }
+
+  numRows_ += input->size();
+}
+
+bool SubPartitionedSortWindowBuild::switchToNextSubPartition() {
+  if (currentSubPartition_ >= numSubPartitions_) {
+    return false;
+  }
+
+  if (currentSubPartition_ >= 0) {
+    subWindowBuilds_[currentSubPartition_].reset();
+  }
+  currentSubPartition_++;
+  if (currentSubPartition_ >= numSubPartitions_) {
+    return false;
+  }
+
+  VELOX_CHECK_NOT_NULL(subWindowBuilds_[currentSubPartition_]);
+  // WindowBuild starts processing the partitions when 'noMoreInput' is called,
+  // which allocates additional memory. We want to defer the memory allocation
+  // as late as possible to reduce memory usage, so we don't call 'noMoreInput'
+  // until the sub partition's data is to be consumed.
+  subWindowBuilds_[currentSubPartition_]->noMoreInput();
+  return true;
+}
+
+void SubPartitionedSortWindowBuild::ensureInputFits(const RowVectorPtr& input) {
+  if (spillConfig_ == nullptr) {
+    // Spilling is disabled.
+    return;
+  }
+
+  if (numRows_ == 0) {
+    // Nothing to spill.
+    return;
+  }
+
+  // Test-only spill path.
+  if (testingTriggerSpill(pool_->name())) {
+    spill();
+    return;
+  }
+
+  VELOX_CHECK_LT(currentSubPartition_, 0);
+  for (auto& windowBuild : subWindowBuilds_) {
+    windowBuild->ensureInputFits(input);
+  }
+}
+
+void SubPartitionedSortWindowBuild::spill() {
+  VELOX_CHECK_LT(currentSubPartition_, 0);
+  for (auto& windowBuild : subWindowBuilds_) {
+    windowBuild->spill();
+  }
+  spilled_ = true;
+}
+
+std::optional<exec::SpillStats> SubPartitionedSortWindowBuild::spilledStats()
+    const {
+  if (!spilled_) {
+    return std::nullopt;
+  }
+  return {*spillStats_};
+}
+
+void SubPartitionedSortWindowBuild::noMoreInput() {
+  if (numRows_ == 0) {
+    return;
+  }
+
+  if (spilled_) {
+    // Spill remaining data to avoid running out of memory while sort-merging
+    // spilled data.
+    spill();
+  }
+
+  switchToNextSubPartition();
+
+  VELOX_CHECK_EQ(currentSubPartition_, 0);
+}
+
+std::shared_ptr<WindowPartition>
+SubPartitionedSortWindowBuild::nextPartition() {
+  VELOX_CHECK_GE(currentSubPartition_, 0);
+  VELOX_CHECK_LT(currentSubPartition_, numSubPartitions_);
+  VELOX_CHECK_NOT_NULL(subWindowBuilds_[currentSubPartition_]);
+  return subWindowBuilds_[currentSubPartition_]->nextPartition();
+}
+
+std::optional<int64_t> SubPartitionedSortWindowBuild::estimateRowSize() {
+  auto subPartition = std::max(currentSubPartition_, 0);
+  if (subPartition >= numSubPartitions_) {
+    return std::nullopt;
+  }
+
+  if (subWindowBuilds_[subPartition]) {
+    return subWindowBuilds_[subPartition]->estimateRowSize();
+  }
+
+  return std::nullopt;
+}
+
+bool SubPartitionedSortWindowBuild::hasNextPartition() {
+  // Check if the build hasn't begun or has finished.
+  if (currentSubPartition_ < 0 || currentSubPartition_ >= numSubPartitions_) {
+    return false;
+  }
+
+  VELOX_CHECK_NOT_NULL(subWindowBuilds_[currentSubPartition_]);
+  if (subWindowBuilds_[currentSubPartition_]->hasNextPartition()) {
+    return true;
+  }
+
+  if (switchToNextSubPartition()) {
+    return hasNextPartition();
+  }
+  return false;
+}
+} // namespace facebook::velox::exec
diff --git a/velox/exec/SubPartitionedSortWindowBuild.h b/velox/exec/SubPartitionedSortWindowBuild.h
new file mode 100644
index 00000000000..8735f438d30
--- /dev/null
+++ b/velox/exec/SubPartitionedSortWindowBuild.h
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/exec/HashPartitionFunction.h"
+#include "velox/exec/PrefixSort.h"
+#include "velox/exec/SortWindowBuild.h"
+#include "velox/exec/Spiller.h"
+
+namespace facebook::velox::exec {
+// Divides the input data into several sub partitions by partition keys, then
+// sequentially sorts input data of each sub partition by {partition keys, sort
+// keys} to identify window partitions with SortWindowBuild. As each sub
+// partition has a smaller working set, the memory used by sorting is reduced.
+// Besides, once a sub partition is completely consumed, its memory could be
+// released immediately.
+class SubPartitionedSortWindowBuild : public WindowBuild {
+ public:
+  SubPartitionedSortWindowBuild(
+      const std::shared_ptr<const core::WindowNode>& node,
+      int32_t numSubPartitions,
+      velox::memory::MemoryPool* pool,
+      common::PrefixSortConfig&& prefixSortConfig,
+      const common::SpillConfig* spillConfig,
+      tsan_atomic<bool>* nonReclaimableSection,
+      folly::Synchronized<OperatorStats>* opStats,
+      exec::SpillStats* spillStats);
+
+  ~SubPartitionedSortWindowBuild() override {
+    pool_->release();
+  }
+
+  bool needsInput() override {
+    // No sub partitions are available yet, so can consume input rows.
+    return currentSubPartition_ < 0;
+  }
+
+  void addInput(RowVectorPtr input) override;
+
+  void spill() override;
+
+  std::optional<exec::SpillStats> spilledStats() const override;
+
+  void noMoreInput() override;
+
+  bool hasNextPartition() override;
+
+  std::shared_ptr<WindowPartition> nextPartition() override;
+
+  std::optional<int64_t> estimateRowSize() override;
+
+ private:
+  // The current sub partition's WindowBuild has finished producing all the
+  // data. Release all the memory of current sub partition's WindowBuild, and
+  // then switch to next sub partition's WindowBuild as the new current one.
+  bool switchToNextSubPartition();
+
+  void ensureInputFits(const RowVectorPtr& input);
+
+  const int32_t numSubPartitions_;
+
+  const size_t numPartitionKeys_;
+
+  memory::MemoryPool* const pool_;
+
+  exec::SpillStats* const spillStats_;
+
+  // Divide input rows to the corresponding sub partitions.
+  std::unique_ptr<HashPartitionFunction> subPartitioningFunction_;
+
+  // WindowBuilds for each sub partition.
+  std::vector<std::unique_ptr<SortWindowBuild>> subWindowBuilds_;
+
+  bool spilled_{false};
+
+  // Buffers the subPartitionIds for each row. Reused across addInput calls.
+  std::vector<uint32_t> subPartitionIdsBuffer_;
+
+  int32_t currentSubPartition_ = -1;
+};
+} // namespace facebook::velox::exec
diff --git a/velox/exec/TableScan.cpp b/velox/exec/TableScan.cpp
index 9157e876d5f..de261dda455 100644
--- a/velox/exec/TableScan.cpp
+++ b/velox/exec/TableScan.cpp
@@ -16,6 +16,8 @@
 #include "velox/exec/TableScan.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/common/time/Timer.h"
+#include "velox/connectors/ConnectorRegistry.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/Task.h"
 
 using facebook::velox::common::testutil::TestValue;
@@ -76,7 +78,7 @@ TableScan::TableScan(
           tableScanNode->outputType(),
           operatorId,
           tableScanNode->id(),
-          "TableScan"),
+          OperatorType::kTableScan),
       tableHandle_(tableScanNode->tableHandle()),
       columnHandles_(tableScanNode->assignments()),
       driverCtx_(driverCtx),
@@ -89,9 +91,14 @@ TableScan::TableScan(
           driverCtx_->driverId,
           operatorType(),
           tableHandle_->connectorId())),
-      connector_(connector::getConnector(tableHandle_->connectorId())),
+      connector_(
+          connector::ConnectorRegistry::tryGet(
+              *driverCtx->task->queryCtx(),
+              tableHandle_->connectorId())),
       getOutputTimeLimitMs_(
           driverCtx_->queryConfig().tableScanGetOutputTimeLimitMs()),
+      outputBatchRowsOverride_(
+          driverCtx_->queryConfig().tableScanOutputBatchRowsOverride()),
       scaledController_(driverCtx_->task->getScaledScanControllerLocked(
           driverCtx_->splitGroupId,
           planNodeId())) {
@@ -171,6 +178,7 @@ RowVectorPtr TableScan::getOutput() {
          },
          &debugString_});
 
+    checkPreload();
     if (needNewSplit_) {
       const auto hasNewSplit = getSplit();
       if (!hasNewSplit) {
@@ -180,21 +188,15 @@ RowVectorPtr TableScan::getOutput() {
         }
         continue;
       }
-      const auto estimatedRowSize = dataSource_->estimatedRowSize();
-      readBatchSize_ =
-          estimatedRowSize == connector::DataSource::kUnknownRowSize
-          ? outputBatchRows()
-          : outputBatchRows(estimatedRowSize);
     }
     VELOX_CHECK(!needNewSplit_);
     VELOX_CHECK(!hasDrained());
 
-    int32_t readBatchSize = readBatchSize_;
-    if (maxFilteringRatio_ > 0) {
-      readBatchSize = std::min(
-          maxReadBatchSize_,
-          static_cast<int32_t>(readBatchSize / maxFilteringRatio_));
-    }
+    const auto estimatedRowSize = dataSource_->estimatedRowSize();
+    const int32_t readBatchSize = calculateBatchSize(estimatedRowSize);
+
+    const auto prevCompletedRows = dataSource_->getCompletedRows();
+
     uint64_t ioTimeUs{0};
     std::optional<RowVectorPtr> dataOptional;
     {
@@ -203,11 +205,10 @@ RowVectorPtr TableScan::getOutput() {
       dataOptional = dataSource_->next(readBatchSize, blockingFuture_);
     }
 
-    checkPreload();
     {
       auto lockedStats = stats_.wlock();
       lockedStats->addRuntimeStat(
-          "dataSourceReadWallNanos",
+          std::string(TableScan::kDataSourceReadWallNanos),
           RuntimeCounter(ioTimeUs * 1'000, RuntimeCounter::Unit::kNanos));
 
       if (!dataOptional.has_value()) {
@@ -225,7 +226,19 @@ RowVectorPtr TableScan::getOutput() {
       if (data != nullptr && !shouldDropOutput()) {
         constexpr int kMaxSelectiveBatchSizeMultiplier = 4;
         if (data->size() > 0) {
-          lockedStats->addInputVector(data->estimateFlatSize(), data->size());
+          uint64_t flatSize = 0;
+          if (driverCtx_->driver->enableOperatorBatchSizeStats()) {
+            flatSize = data->estimateFlatSize();
+          }
+          lockedStats->addInputVector(flatSize, data->size());
+          const auto completedRowsDelta =
+              dataSource_->getCompletedRows() - prevCompletedRows;
+          if (completedRowsDelta > 0) {
+            core::ScanBatchEvent event;
+            event.numRows = completedRowsDelta;
+            event.wallTimeMicros = ioTimeUs;
+            dataSource_->fireScanBatchCallback(event);
+          }
           maxFilteringRatio_ = std::max(
               {maxFilteringRatio_,
                1.0 * data->size() / readBatchSize,
@@ -234,8 +247,9 @@ RowVectorPtr TableScan::getOutput() {
             RECORD_METRIC_VALUE(
                 velox::kMetricTableScanBatchProcessTimeMs, ioTimeUs / 1'000);
           }
-          RECORD_METRIC_VALUE(
-              velox::kMetricTableScanBatchBytes, data->estimateFlatSize());
+          if (driverCtx_->driver->enableOperatorBatchSizeStats()) {
+            RECORD_METRIC_VALUE(velox::kMetricTableScanBatchBytes, flatSize);
+          }
           return data;
         } else {
           maxFilteringRatio_ = std::max(
@@ -250,12 +264,14 @@ RowVectorPtr TableScan::getOutput() {
       auto lockedStats = stats_.wlock();
       if (numPreloadedSplits_ > 0) {
         lockedStats->addRuntimeStat(
-            "preloadedSplits", RuntimeCounter(numPreloadedSplits_));
+            std::string(TableScan::kPreloadedSplits),
+            RuntimeCounter(numPreloadedSplits_));
         numPreloadedSplits_ = 0;
       }
       if (numReadyPreloadedSplits_ > 0) {
         lockedStats->addRuntimeStat(
-            "readyPreloadedSplits", RuntimeCounter(numReadyPreloadedSplits_));
+            std::string(TableScan::kReadyPreloadedSplits),
+            RuntimeCounter(numReadyPreloadedSplits_));
         numReadyPreloadedSplits_ = 0;
       }
       currNumRawInputRows = lockedStats->rawInputPositions;
@@ -285,12 +301,13 @@ bool TableScan::getSplit() {
 
   exec::Split split;
   blockingReason_ = driverCtx_->task->getSplitOrFuture(
+      driverCtx_->driverId,
       driverCtx_->splitGroupId,
       planNodeId(),
-      split,
-      blockingFuture_,
       maxPreloadedSplits_,
-      splitPreloader_);
+      splitPreloader_,
+      split,
+      blockingFuture_);
   if (blockingReason_ != BlockingReason::kNotBlocked) {
     return false;
   }
@@ -303,15 +320,15 @@ bool TableScan::getSplit() {
   if (!split.hasConnectorSplit()) {
     noMoreSplits_ = true;
     if (dataSource_) {
-      const auto connectorStats = dataSource_->runtimeStats();
+      const auto connectorStats = dataSource_->getRuntimeStats();
       auto lockedStats = stats_.wlock();
-      for (const auto& [name, counter] : connectorStats) {
+      for (const auto& [name, metric] : connectorStats) {
         if (FOLLY_UNLIKELY(lockedStats->runtimeStats.count(name) == 0)) {
-          lockedStats->runtimeStats.emplace(name, RuntimeMetric(counter.unit));
+          lockedStats->runtimeStats.emplace(name, RuntimeMetric(metric.unit));
         } else {
-          VELOX_CHECK_EQ(lockedStats->runtimeStats.at(name).unit, counter.unit);
+          VELOX_CHECK_EQ(lockedStats->runtimeStats.at(name).unit, metric.unit);
         }
-        lockedStats->runtimeStats.at(name).addValue(counter.value);
+        lockedStats->runtimeStats.at(name).merge(metric);
       }
     }
     return false;
@@ -322,7 +339,8 @@ bool TableScan::getSplit() {
   }
 
   stats_.wlock()->addRuntimeStat(
-      "connectorSplitSize", RuntimeCounter(split.connectorSplit->size()));
+      std::string(TableScan::kConnectorSplitSize),
+      RuntimeCounter(static_cast<int64_t>(split.connectorSplit->size())));
   const auto& connectorSplit = split.connectorSplit;
   currentSplitWeight_ = connectorSplit->splitWeight;
   needNewSplit_ = false;
@@ -346,6 +364,10 @@ bool TableScan::getSplit() {
         tableHandle_,
         columnHandles_,
         connectorQueryCtx_.get());
+    if (const auto& callback =
+            operatorCtx_->driverCtx()->task->queryCtx()->scanBatchCallback()) {
+      dataSource_->setScanBatchCallback(callback);
+    }
   }
 
   debugString_ = fmt::format(
@@ -368,18 +390,18 @@ bool TableScan::getSplit() {
     auto preparedDataSource = connectorSplit->dataSource->move();
     auto endTimeNs = getCurrentTimeNano();
     stats_.wlock()->addRuntimeStat(
-        "waitForPreloadSplitNanos",
+        std::string(TableScan::kWaitForPreloadSplitNanos),
         RuntimeCounter(endTimeNs - startTimeNs, RuntimeCounter::Unit::kNanos));
-    stats_.wlock()->addRuntimeStat(
-        "preloadSplitPrepareTimeNanos",
-        RuntimeCounter(
-            connectorSplit->dataSource->prepareTiming().wallNanos,
-            RuntimeCounter::Unit::kNanos));
-    if (!preparedDataSource) {
+    if (preparedDataSource == nullptr) {
       // There must be a cancellation.
       VELOX_CHECK(operatorCtx_->task()->isCancelled());
       return false;
     }
+    stats_.wlock()->addRuntimeStat(
+        std::string(TableScan::kPreloadSplitPrepareTimeNanos),
+        RuntimeCounter(
+            connectorSplit->dataSource->prepareTiming().wallNanos,
+            RuntimeCounter::Unit::kNanos));
     dataSource_->setFromDataSource(std::move(preparedDataSource));
   } else {
     uint64_t addSplitTimeUs{0};
@@ -389,7 +411,7 @@ bool TableScan::getSplit() {
       dataSource_->addSplit(connectorSplit);
     }
     stats_.wlock()->addRuntimeStat(
-        "dataSourceAddSplitWallNanos",
+        std::string(TableScan::kDataSourceAddSplitWallNanos),
         RuntimeCounter(addSplitTimeUs * 1'000, RuntimeCounter::Unit::kNanos));
   }
   ++stats_.wlock()->numSplits;
@@ -471,21 +493,18 @@ void TableScan::checkPreload() {
       !connector_->supportsSplitPreload()) {
     return;
   }
-  if (dataSource_->allPrefetchIssued()) {
-    maxPreloadedSplits_ = driverCtx_->task->numDrivers(driverCtx_->driver) *
-        maxSplitPreloadPerDriver_;
-    if (!splitPreloader_) {
-      splitPreloader_ =
-          [ioExecutor,
-           this](const std::shared_ptr<connector::ConnectorSplit>& split) {
-            preload(split);
-
-            ioExecutor->add([connectorSplit = split]() mutable {
-              connectorSplit->dataSource->prepare();
-              connectorSplit.reset();
-            });
-          };
-    }
+  maxPreloadedSplits_ = driverCtx_->task->numDrivers(driverCtx_->driver) *
+      maxSplitPreloadPerDriver_;
+  if (!splitPreloader_) {
+    splitPreloader_ =
+        [ioExecutor,
+         this](const std::shared_ptr<connector::ConnectorSplit>& split) {
+          preload(split);
+          ioExecutor->add([connectorSplit = split]() mutable {
+            connectorSplit->dataSource->prepare();
+            connectorSplit.reset();
+          });
+        };
   }
 }
 
@@ -504,6 +523,35 @@ void TableScan::addDynamicFilterLocked(
   stats_.wlock()->dynamicFilterStats.producerNodeIds.emplace(producer);
 }
 
+int32_t TableScan::calculateBatchSize(int64_t currentEstimatedRowSize) {
+  if (outputBatchRowsOverride_ > 0) {
+    return outputBatchRowsOverride_;
+  }
+  int64_t estimatedRowSize = connector::DataSource::kUnknownRowSize;
+  if (currentEstimatedRowSize != connector::DataSource::kUnknownRowSize) {
+    // Use current file estimate.
+    fileEstimatedRowSize_ = currentEstimatedRowSize;
+    estimatedRowSize = currentEstimatedRowSize;
+  } else if (fileEstimatedRowSize_ != connector::DataSource::kUnknownRowSize) {
+    // Fallback to previous file estimate.
+    estimatedRowSize = fileEstimatedRowSize_;
+  }
+  // Otherwise, no estimate available: use preferredOutputBatchRows()
+  // (readBatchSize_ default).
+
+  if (estimatedRowSize != connector::DataSource::kUnknownRowSize) {
+    readBatchSize_ = outputBatchRows(estimatedRowSize);
+  }
+
+  int32_t batchSize = readBatchSize_;
+  if (maxFilteringRatio_ > 0) {
+    batchSize = std::min(
+        maxReadBatchSize_,
+        static_cast<int32_t>(batchSize / maxFilteringRatio_));
+  }
+  return batchSize;
+}
+
 void TableScan::close() {
   Operator::close();
 
@@ -524,7 +572,7 @@ void TableScan::close() {
   const auto scaledStats = scaledController_->stats();
   auto lockedStats = stats_.wlock();
   lockedStats->addRuntimeStat(
-      TableScan::kNumRunningScaleThreads,
+      std::string(TableScan::kNumRunningScaleThreads),
       RuntimeCounter(scaledStats.numRunningDrivers));
 }
 } // namespace facebook::velox::exec
diff --git a/velox/exec/TableScan.h b/velox/exec/TableScan.h
index 69bff9ddc45..e3573211404 100644
--- a/velox/exec/TableScan.h
+++ b/velox/exec/TableScan.h
@@ -15,6 +15,8 @@
  */
 #pragma once
 
+#include <string_view>
+
 #include "velox/core/PlanNode.h"
 #include "velox/exec/Operator.h"
 #include "velox/exec/ScaledScanController.h"
@@ -61,13 +63,44 @@ class TableScan : public SourceOperator {
   ///
   /// NOTE: we only report the number of running scan drivers at the point that
   /// all the splits have been dispatched.
-  static inline const std::string kNumRunningScaleThreads{
-      "numRunningScaleThreads"};
+  static constexpr std::string_view kNumRunningScaleThreads =
+      "numRunningScaleThreads";
+
+  /// Time spent reading from the data source.
+  static constexpr std::string_view kDataSourceReadWallNanos =
+      "dataSourceReadWallNanos";
+
+  /// Number of splits that started background preload.
+  static constexpr std::string_view kPreloadedSplits = "preloadedSplits";
+
+  /// Number of preloaded splits that finished before being read.
+  static constexpr std::string_view kReadyPreloadedSplits =
+      "readyPreloadedSplits";
+
+  /// Size of the connector split.
+  static constexpr std::string_view kConnectorSplitSize = "connectorSplitSize";
+
+  /// Time waiting for a preloaded split to become available.
+  static constexpr std::string_view kWaitForPreloadSplitNanos =
+      "waitForPreloadSplitNanos";
+
+  /// Time for preload split preparation.
+  static constexpr std::string_view kPreloadSplitPrepareTimeNanos =
+      "preloadSplitPrepareTimeNanos";
+
+  /// Time spent adding a split to the data source.
+  static constexpr std::string_view kDataSourceAddSplitWallNanos =
+      "dataSourceAddSplitWallNanos";
 
   std::shared_ptr<ScaledScanController> testingScaledController() const {
     return scaledController_;
   }
 
+  /// Returns the current read batch size. Used for testing.
+  vector_size_t testingReadBatchSize() const {
+    return readBatchSize_;
+  }
+
  private:
   // Checks if this table scan operator needs to yield before processing the
   // next split.
@@ -99,6 +132,10 @@ class TableScan : public SourceOperator {
   // processing or not.
   void tryScaleUp();
 
+  // Calculates the batch size to read based on available row size information.
+  // Returns the number of rows to read in the next batch.
+  int32_t calculateBatchSize(int64_t currentEstimatedRowSize);
+
   const connector::ConnectorTableHandlePtr tableHandle_;
   const connector::ColumnHandleMap columnHandles_;
   DriverCtx* const driverCtx_;
@@ -110,6 +147,8 @@ class TableScan : public SourceOperator {
   // limit'.
   const size_t getOutputTimeLimitMs_{0};
 
+  const uint32_t outputBatchRowsOverride_;
+
   // If set, used for scan scale processing. It is shared by all the scan
   // operators instantiated from the same table scan node.
   const std::shared_ptr<ScaledScanController> scaledController_;
@@ -141,6 +180,10 @@ class TableScan : public SourceOperator {
 
   double maxFilteringRatio_{0};
 
+  // Row size estimate from the file reader. It is set to the last known
+  // estimated row size from the current split reader or the previous ones.
+  int64_t fileEstimatedRowSize_{connector::DataSource::kUnknownRowSize};
+
   // String shown in ExceptionContext inside DataSource and LazyVector loading.
   std::string debugString_;
 
diff --git a/velox/exec/TableWriteMerge.cpp b/velox/exec/TableWriteMerge.cpp
index 8a9b6c2b8ff..f8e96378a20 100644
--- a/velox/exec/TableWriteMerge.cpp
+++ b/velox/exec/TableWriteMerge.cpp
@@ -16,35 +16,10 @@
 
 #include "velox/exec/TableWriteMerge.h"
 
-#include "HashAggregation.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/TableWriter.h"
-#include "velox/exec/Task.h"
 
 namespace facebook::velox::exec {
-namespace {
-bool isSameCommitContext(
-    const folly::dynamic& first,
-    const folly::dynamic& second) {
-  return std::tie(
-             first[TableWriteTraits::kTaskIdContextKey],
-             first[TableWriteTraits::kCommitStrategyContextKey]) ==
-      std::tie(
-             second[TableWriteTraits::kTaskIdContextKey],
-             second[TableWriteTraits::kCommitStrategyContextKey]);
-}
-
-bool containsNonNullRows(const VectorPtr& vector) {
-  if (!vector->mayHaveNulls()) {
-    return true;
-  }
-  for (int i = 0; i < vector->size(); ++i) {
-    if (!vector->isNullAt(i)) {
-      return true;
-    }
-  }
-  return false;
-}
-} // namespace
 
 TableWriteMerge::TableWriteMerge(
     int32_t operatorId,
@@ -55,7 +30,7 @@ TableWriteMerge::TableWriteMerge(
           tableWriteMergeNode->outputType(),
           operatorId,
           tableWriteMergeNode->id(),
-          "TableWriteMerge") {
+          OperatorType::kTableWriteMerge) {
   if (tableWriteMergeNode->outputType()->size() == 1) {
     VELOX_USER_CHECK(!tableWriteMergeNode->hasColumnStatsSpec());
   } else {
@@ -79,35 +54,98 @@ void TableWriteMerge::initialize() {
   }
 }
 
+namespace {
+// Creates a RowVector containing only the rows at the given indices from
+// 'input'. Each child vector is wrapped in a dictionary to avoid copying.
+RowVectorPtr
+selectRows(const RowVectorPtr& input, BufferPtr indices, vector_size_t size) {
+  std::vector<VectorPtr> children(input->childrenSize());
+  for (auto i = 0; i < input->childrenSize(); ++i) {
+    children[i] =
+        BaseVector::wrapInDictionary(nullptr, indices, size, input->childAt(i));
+  }
+  return std::make_shared<RowVector>(
+      input->pool(), input->type(), nullptr, size, std::move(children));
+}
+} // namespace
+
 void TableWriteMerge::addInput(RowVectorPtr input) {
   VELOX_CHECK(!noMoreInput_);
   VELOX_CHECK_GT(input->size(), 0);
 
-  if (isStatistics(input)) {
-    VELOX_CHECK_NOT_NULL(statsCollector_);
-    statsCollector_->addInput(input);
-    return;
+  // Possibly mixed batch: split into stats and data using dictionary wrapping.
+  auto statsIndices = allocateIndices(input->size(), pool());
+  auto dataIndices = allocateIndices(input->size(), pool());
+  auto* rawStatsIndices = statsIndices->asMutable<vector_size_t>();
+  auto* rawDataIndices = dataIndices->asMutable<vector_size_t>();
+  vector_size_t numStats{0};
+  vector_size_t numData{0};
+  for (vector_size_t i = 0; i < input->size(); ++i) {
+    if (TableWriteTraits::isStatisticsRow(input, i)) {
+      rawStatsIndices[numStats++] = i;
+    } else {
+      rawDataIndices[numData++] = i;
+    }
   }
 
-  // Increments row count.
+  if (numStats > 0) {
+    if (numData == 0) {
+      addStatisticsInput(input);
+    } else {
+      addStatisticsInput(selectRows(input, statsIndices, numStats));
+    }
+  }
+
+  if (numData > 0) {
+    if (numStats == 0) {
+      addDataInput(input);
+    } else {
+      addDataInput(selectRows(input, dataIndices, numData));
+    }
+  }
+}
+
+void TableWriteMerge::addStatisticsInput(const RowVectorPtr& input) {
+  VELOX_CHECK_NOT_NULL(statsCollector_);
+  statsCollector_->addInput(input);
+}
+
+void TableWriteMerge::addDataInput(const RowVectorPtr& input) {
   numRows_ += TableWriteTraits::getRowCount(input);
 
-  // Makes sure the lifespan is the same.
+  // Validate commit strategy consistency. TaskId may differ in cross-worker
+  // merge (coordinator merging output from multiple workers).
   auto commitContext = TableWriteTraits::getTableCommitContext(input);
   if (lastCommitContext_ != nullptr) {
-    VELOX_CHECK(
-        isSameCommitContext(lastCommitContext_, commitContext),
-        "incompatible table commit context: {} is not compatible with {}",
-        lastCommitContext_.asString(),
-        commitContext.asString());
+    VELOX_CHECK_EQ(
+        lastCommitContext_[TableWriteTraits::kCommitStrategyContextKey]
+            .asString(),
+        commitContext[TableWriteTraits::kCommitStrategyContextKey].asString(),
+        "Mismatched commit strategy in commit context");
   }
   lastCommitContext_ = commitContext;
 
-  // Adds fragments to the buffer. Fragments will be emitted as soon as possible
-  // to avoid using extra memory.
+  // Buffer non-null fragments for early emission to free memory. The input
+  // may contain a mix of fragment rows (non-null) and summary rows (null
+  // fragment) when the TableWriter produces them in a single multi-row
+  // output.
   auto fragmentVector = input->childAt(TableWriteTraits::kFragmentChannel);
-  if (containsNonNullRows(fragmentVector)) {
+  if (!fragmentVector->mayHaveNulls()) {
     fragmentVectors_.push(fragmentVector);
+  } else {
+    auto indices = allocateIndices(fragmentVector->size(), pool());
+    auto* rawIndices = indices->asMutable<vector_size_t>();
+    vector_size_t numNonNull{0};
+    for (vector_size_t i = 0; i < fragmentVector->size(); ++i) {
+      if (!fragmentVector->isNullAt(i)) {
+        rawIndices[numNonNull++] = i;
+      }
+    }
+    if (numNonNull > 0) {
+      fragmentVectors_.push(
+          BaseVector::wrapInDictionary(
+              nullptr, indices, numNonNull, fragmentVector));
+    }
   }
 }
 
@@ -213,8 +251,4 @@ RowVectorPtr TableWriteMerge::createLastOutput() {
   return output;
 }
 
-bool TableWriteMerge::isStatistics(RowVectorPtr input) {
-  return input->childAt(TableWriteTraits::kRowCountChannel)->isNullAt(0) &&
-      input->childAt(TableWriteTraits::kFragmentChannel)->isNullAt(0);
-}
 } // namespace facebook::velox::exec
diff --git a/velox/exec/TableWriteMerge.h b/velox/exec/TableWriteMerge.h
index c5a0ade2ccd..8dd1ea99b3c 100644
--- a/velox/exec/TableWriteMerge.h
+++ b/velox/exec/TableWriteMerge.h
@@ -55,6 +55,12 @@ class TableWriteMerge : public Operator {
   void close() override;
 
  private:
+  // Processes a batch of statistics rows.
+  void addStatisticsInput(const RowVectorPtr& input);
+
+  // Processes a batch of data rows (row counts, fragments, commit context).
+  void addDataInput(const RowVectorPtr& input);
+
   // Creates non-last output with fragments and last commit context only.
   RowVectorPtr createFragmentsOutput();
 
@@ -65,9 +71,6 @@ class TableWriteMerge : public Operator {
   // Creates the last output and fragment columns must be null.
   RowVectorPtr createLastOutput();
 
-  // Check if the input is statistics input.
-  bool isStatistics(RowVectorPtr input);
-
   std::unique_ptr<ColumnStatsCollector> statsCollector_;
   bool finished_{false};
   // The sum of written rows.
diff --git a/velox/exec/TableWriter.cpp b/velox/exec/TableWriter.cpp
index 776a6e4d653..fa1ba1f6e1a 100644
--- a/velox/exec/TableWriter.cpp
+++ b/velox/exec/TableWriter.cpp
@@ -15,6 +15,8 @@
  */
 
 #include "velox/exec/TableWriter.h"
+#include "velox/connectors/ConnectorRegistry.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/Task.h"
 
 namespace facebook::velox::exec {
@@ -28,9 +30,11 @@ TableWriter::TableWriter(
           tableWriteNode->outputType(),
           operatorId,
           tableWriteNode->id(),
-          "TableWrite",
+          OperatorType::kTableWrite,
           tableWriteNode->canSpill(driverCtx->queryConfig())
-              ? driverCtx->makeSpillConfig(operatorId)
+              ? driverCtx->makeSpillConfig(
+                    operatorId,
+                    OperatorType::kTableWrite)
               : std::nullopt),
       driverCtx_(driverCtx),
       connectorPool_(driverCtx_->task->addConnectorPoolLocked(
@@ -42,7 +46,7 @@ TableWriter::TableWriter(
       insertTableHandle_(
           tableWriteNode->insertTableHandle()->connectorInsertTableHandle()),
       commitStrategy_(tableWriteNode->commitStrategy()),
-      createTimeUs_(getCurrentTimeNano()) {
+      createTimeNs_(getCurrentTimeNano()) {
   setConnectorMemoryReclaimer();
   if (tableWriteNode->outputType()->size() == 1) {
     VELOX_USER_CHECK(!tableWriteNode->columnStatsSpec().has_value());
@@ -60,7 +64,8 @@ TableWriter::TableWriter(
         &nonReclaimableSection_);
   }
   const auto& connectorId = tableWriteNode->insertTableHandle()->connectorId();
-  connector_ = connector::getConnector(connectorId);
+  connector_ = connector::ConnectorRegistry::tryGet(
+      *driverCtx->task->queryCtx(), connectorId);
   connectorQueryCtx_ = operatorCtx_->createConnectorQueryCtx(
       connectorId,
       planNodeId(),
@@ -258,8 +263,9 @@ RowVectorPtr TableWriter::getOutput() {
   if (statsCollector_ != nullptr) {
     for (int i = TableWriteTraits::kStatsChannel; i < outputType_->size();
          ++i) {
-      columns.push_back(BaseVector::createNullConstant(
-          outputType_->childAt(i), writtenRowsVector->size(), pool()));
+      columns.push_back(
+          BaseVector::createNullConstant(
+              outputType_->childAt(i), writtenRowsVector->size(), pool()));
     }
   }
 
@@ -280,7 +286,7 @@ std::string TableWriter::createTableCommitContext(bool lastOutput) {
 
 void TableWriter::updateStats(const connector::DataSink::Stats& stats) {
   const auto currentTimeNs = getCurrentTimeNano();
-  VELOX_CHECK_GE(currentTimeNs, createTimeUs_);
+  VELOX_CHECK_GE(currentTimeNs, createTimeNs_);
   {
     auto lockedStats = stats_.wlock();
     lockedStats->physicalWrittenBytes = stats.numWrittenBytes;
@@ -314,10 +320,10 @@ void TableWriter::updateStats(const connector::DataSink::Stats& stats) {
     lockedStats->addRuntimeStat(
         kRunningWallNanos,
         RuntimeCounter(
-            currentTimeNs - createTimeUs_, RuntimeCounter::Unit::kNanos));
+            currentTimeNs - createTimeNs_, RuntimeCounter::Unit::kNanos));
   }
   if (!stats.spillStats.empty()) {
-    *spillStats_->wlock() += stats.spillStats;
+    *spillStats_ += stats.spillStats;
   }
 }
 
@@ -336,8 +342,9 @@ void TableWriter::close() {
 void TableWriter::setConnectorMemoryReclaimer() {
   VELOX_CHECK_NOT_NULL(connectorPool_);
   if (connectorPool_->parent()->reclaimer() != nullptr) {
-    connectorPool_->setReclaimer(TableWriter::ConnectorReclaimer::create(
-        spillConfig_, operatorCtx_->driverCtx(), this));
+    connectorPool_->setReclaimer(
+        TableWriter::ConnectorReclaimer::create(
+            spillConfig_, operatorCtx_->driverCtx(), this));
   }
 }
 
@@ -387,8 +394,11 @@ uint64_t TableWriter::ConnectorReclaimer::reclaim(
     // TODO: reduce the log frequency if it is too verbose.
     ++stats.numNonReclaimableAttempts;
     LOG(WARNING) << "Can't reclaim from a closed writer connector pool: "
-                 << pool->name()
-                 << ", memory usage: " << succinctBytes(pool->reservedBytes());
+                 << pool->name() << ", root pool: " << pool->root()->name()
+                 << ", used: " << succinctBytes(pool->usedBytes())
+                 << ", reservation: " << succinctBytes(pool->reservedBytes())
+                 << ", root pool reservation: "
+                 << succinctBytes(pool->root()->reservedBytes());
     return 0;
   }
 
@@ -397,115 +407,15 @@ uint64_t TableWriter::ConnectorReclaimer::reclaim(
     ++stats.numNonReclaimableAttempts;
     LOG(WARNING)
         << "Can't reclaim from a writer connector pool which hasn't initialized yet: "
-        << pool->name()
-        << ", memory usage: " << succinctBytes(pool->reservedBytes());
+        << pool->name() << ", root pool: " << pool->root()->name()
+        << ", used: " << succinctBytes(pool->usedBytes())
+        << ", reservation: " << succinctBytes(pool->reservedBytes())
+        << ", root pool reservation: "
+        << succinctBytes(pool->root()->reservedBytes());
     return 0;
   }
   RuntimeStatWriterScopeGuard opStatsGuard(op_);
   return ParallelMemoryReclaimer::reclaim(pool, targetBytes, maxWaitMs, stats);
 }
 
-// static
-RowVectorPtr TableWriteTraits::createAggregationStatsOutput(
-    RowTypePtr outputType,
-    RowVectorPtr aggregationOutput,
-    StringView tableCommitContext,
-    velox::memory::MemoryPool* pool) {
-  // TODO: record aggregation stats output time.
-  if (aggregationOutput == nullptr) {
-    return nullptr;
-  }
-  VELOX_CHECK_GT(aggregationOutput->childrenSize(), 0);
-  const vector_size_t numOutputRows = aggregationOutput->childAt(0)->size();
-  std::vector<VectorPtr> columns;
-  for (int channel = 0; channel < outputType->size(); channel++) {
-    if (channel < TableWriteTraits::kContextChannel) {
-      // 1. Set null rows column.
-      // 2. Set null fragments column.
-      columns.push_back(BaseVector::createNullConstant(
-          outputType->childAt(channel), numOutputRows, pool));
-      continue;
-    }
-    if (channel == TableWriteTraits::kContextChannel) {
-      // 3. Set commitcontext column.
-      columns.push_back(std::make_shared<ConstantVector<StringView>>(
-          pool,
-          numOutputRows,
-          false /*isNull*/,
-          VARBINARY(),
-          std::move(tableCommitContext)));
-      continue;
-    }
-    // 4. Set statistics columns.
-    columns.push_back(
-        aggregationOutput->childAt(channel - TableWriteTraits::kStatsChannel));
-  }
-  return std::make_shared<RowVector>(
-      pool, outputType, nullptr, numOutputRows, columns);
-}
-
-std::string TableWriteTraits::rowCountColumnName() {
-  static const std::string kRowCountName = "rows";
-  return kRowCountName;
-}
-
-std::string TableWriteTraits::fragmentColumnName() {
-  static const std::string kFragmentName = "fragments";
-  return kFragmentName;
-}
-
-std::string TableWriteTraits::contextColumnName() {
-  static const std::string kContextName = "commitcontext";
-  return kContextName;
-}
-
-const TypePtr& TableWriteTraits::rowCountColumnType() {
-  static const TypePtr kRowCountType = BIGINT();
-  return kRowCountType;
-}
-
-const TypePtr& TableWriteTraits::fragmentColumnType() {
-  static const TypePtr kFragmentType = VARBINARY();
-  return kFragmentType;
-}
-
-const TypePtr& TableWriteTraits::contextColumnType() {
-  static const TypePtr kContextType = VARBINARY();
-  return kContextType;
-}
-
-// static.
-RowTypePtr TableWriteTraits::outputType(
-    const std::optional<core::ColumnStatsSpec>& columnStatsSpec) {
-  static const auto kOutputTypeWithoutStats =
-      ROW({rowCountColumnName(), fragmentColumnName(), contextColumnName()},
-          {rowCountColumnType(), fragmentColumnType(), contextColumnType()});
-  if (!columnStatsSpec.has_value()) {
-    return kOutputTypeWithoutStats;
-  }
-  return kOutputTypeWithoutStats->unionWith(
-      ColumnStatsCollector::outputType(columnStatsSpec.value()));
-}
-
-folly::dynamic TableWriteTraits::getTableCommitContext(
-    const RowVectorPtr& input) {
-  VELOX_CHECK_GT(input->size(), 0);
-  auto* contextVector =
-      input->childAt(kContextChannel)->as<SimpleVector<StringView>>();
-  return folly::parseJson(contextVector->valueAt(input->size() - 1));
-}
-
-int64_t TableWriteTraits::getRowCount(const RowVectorPtr& output) {
-  VELOX_CHECK_GT(output->size(), 0);
-  auto rowCountVector =
-      output->childAt(kRowCountChannel)->asFlatVector<int64_t>();
-  VELOX_CHECK_NOT_NULL(rowCountVector);
-  int64_t rowCount{0};
-  for (int i = 0; i < output->size(); ++i) {
-    if (!rowCountVector->isNullAt(i)) {
-      rowCount += rowCountVector->valueAt(i);
-    }
-  }
-  return rowCount;
-}
 } // namespace facebook::velox::exec
diff --git a/velox/exec/TableWriter.h b/velox/exec/TableWriter.h
index f25ceeb28af..577dc394154 100644
--- a/velox/exec/TableWriter.h
+++ b/velox/exec/TableWriter.h
@@ -17,86 +17,13 @@
 #pragma once
 
 #include "velox/core/PlanNode.h"
+#include "velox/core/TableWriteTraits.h"
 #include "velox/exec/ColumnStatsCollector.h"
 #include "velox/exec/MemoryReclaimer.h"
 #include "velox/exec/Operator.h"
 
 namespace facebook::velox::exec {
 
-/// Defines table writer output related config properties that are shared
-/// between TableWriter and TableWriteMerger.
-///
-/// TODO: the table write output processing is Prestissimo specific. Consider
-/// move these part logic to Prestissimo and pass to Velox through a customized
-/// output processing callback.
-class TableWriteTraits {
- public:
-  /// Defines the column names/types in table write output.
-  static std::string rowCountColumnName();
-  static std::string fragmentColumnName();
-  static std::string contextColumnName();
-
-  static const TypePtr& rowCountColumnType();
-  static const TypePtr& fragmentColumnType();
-  static const TypePtr& contextColumnType();
-
-  /// Defines the column channels in table write output.
-  /// Both the statistics and the row_count + fragments are transferred over the
-  /// same communication link between the TableWriter and TableFinish. Thus the
-  /// multiplexing is needed.
-  ///
-  ///  The transferred page layout looks like:
-  /// [row_count_channel], [fragment_channel], [context_channel],
-  /// [statistic_channel_1] ... [statistic_channel_N]]
-  ///
-  /// [row_count_channel] - contains number of rows processed by a TableWriter
-  /// [fragment_channel] - contains data provided by the DataSink#finish
-  /// [statistic_channel_1] ...[statistic_channel_N] -
-  /// contain aggregated statistics computed by the statistics aggregation
-  /// within the TableWriter
-  ///
-  /// For convenience, we never set both: [row_count_channel] +
-  /// [fragment_channel] and the [statistic_channel_1] ...
-  /// [statistic_channel_N].
-  ///
-  /// If this is a row that holds statistics - the [row_count_channel] +
-  /// [fragment_channel] will be NULL.
-  ///
-  /// If this is a row that holds the row count
-  /// or the fragment - all the statistics channels will be set to NULL.
-  static constexpr int32_t kRowCountChannel = 0;
-  static constexpr int32_t kFragmentChannel = 1;
-  static constexpr int32_t kContextChannel = 2;
-  static constexpr int32_t kStatsChannel = 3;
-
-  /// Defines the names of metadata in commit context in table writer output.
-  static constexpr std::string_view kLifeSpanContextKey = "lifespan";
-  static constexpr std::string_view kTaskIdContextKey = "taskId";
-  static constexpr std::string_view kCommitStrategyContextKey =
-      "pageSinkCommitStrategy";
-  static constexpr std::string_view klastPageContextKey = "lastPage";
-
-  static RowTypePtr outputType(
-      const std::optional<core::ColumnStatsSpec>& columnStatsSpec);
-
-  /// Returns the parsed commit context from table writer 'output'.
-  static folly::dynamic getTableCommitContext(const RowVectorPtr& output);
-
-  /// Returns the sum of row counts from table writer 'output'.
-  static int64_t getRowCount(const RowVectorPtr& output);
-
-  /// Creates the statistics output.
-  /// Statistics page layout (aggregate by partition):
-  /// row     fragments     context     [partition]   stats1     stats2 ...
-  /// null       null          X          [X]            X          X
-  /// null       null          X          [X]            X          X
-  static RowVectorPtr createAggregationStatsOutput(
-      RowTypePtr outputType,
-      RowVectorPtr aggregationOutput,
-      StringView tableCommitContext,
-      velox::memory::MemoryPool* pool);
-};
-
 class TableWriter : public Operator {
  public:
   TableWriter(
@@ -150,15 +77,15 @@ class TableWriter : public Operator {
 
   /// The name of runtime stats specific to table writer.
   /// The running wall time of a writer operator from creation to close.
-  static inline const std::string kRunningWallNanos{"runningWallNanos"};
+  static constexpr std::string_view kRunningWallNanos{"runningWallNanos"};
   /// The number of files written by this writer operator.
-  static inline const std::string kNumWrittenFiles{"numWrittenFiles"};
+  static constexpr std::string_view kNumWrittenFiles{"numWrittenFiles"};
   /// The file write IO walltime.
-  static inline const std::string kWriteIOTime{"writeIOWallNanos"};
+  static constexpr std::string_view kWriteIOTime{"writeIOWallNanos"};
   /// The walltime spend on file write data recoding.
-  static inline const std::string kWriteRecodeTime{"writeRecodeWallNanos"};
+  static constexpr std::string_view kWriteRecodeTime{"writeRecodeWallNanos"};
   /// The walltime spent on file write data compression.
-  static inline const std::string kWriteCompressionTime{
+  static constexpr std::string_view kWriteCompressionTime{
       "writeCompressionWallNanos"};
 
  private:
@@ -233,9 +160,9 @@ class TableWriter : public Operator {
   const connector::ConnectorInsertTableHandlePtr insertTableHandle_;
   const connector::CommitStrategy commitStrategy_;
   // Records the writer operator creation time in ns. This is used to record
-  // the running wall time of a writer operator. This can helps to detect the
+  // the running wall time of a writer operator. This can help to detect the
   // slow scaled writer scheduling in Prestissimo.
-  const uint64_t createTimeUs_{0};
+  const uint64_t createTimeNs_{0};
 
   std::unique_ptr<ColumnStatsCollector> statsCollector_;
   std::shared_ptr<connector::Connector> connector_;
@@ -260,4 +187,10 @@ class TableWriter : public Operator {
   bool closed_{false};
   vector_size_t numWrittenRows_{0};
 };
+
+// TODO: TableWriteTraits got moved to velox/core as it pertains to plan
+// metadata, not execution. Maintaining the alias here in order not to break
+// backward compatibility.
+using core::TableWriteTraits;
+
 } // namespace facebook::velox::exec
diff --git a/velox/exec/Task.cpp b/velox/exec/Task.cpp
index eab1bf7d59c..9b1c2f7e385 100644
--- a/velox/exec/Task.cpp
+++ b/velox/exec/Task.cpp
@@ -14,6 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #include <boost/lexical_cast.hpp>
 #include <boost/uuid/uuid_generators.hpp>
 #include <boost/uuid/uuid_io.hpp>
@@ -26,22 +27,22 @@
 #include "velox/common/time/Timer.h"
 #include "velox/exec/Exchange.h"
 #include "velox/exec/HashJoinBridge.h"
+#include "velox/exec/IndexLookupJoinBridge.h"
 #include "velox/exec/LocalPlanner.h"
 #include "velox/exec/MemoryReclaimer.h"
 #include "velox/exec/NestedLoopJoinBuild.h"
+#include "velox/exec/OperatorTraceCtx.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/OutputBufferManager.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/SpatialJoinBuild.h"
 #include "velox/exec/TableScan.h"
 #include "velox/exec/Task.h"
-#include "velox/exec/TaskTraceWriter.h"
-#include "velox/exec/TraceUtil.h"
 
 using facebook::velox::common::testutil::TestValue;
 
 namespace facebook::velox::exec {
-
 namespace {
 
 // RAII helper class to satisfy given promises and notify listeners of an event
@@ -116,15 +117,49 @@ std::string errorMessageImpl(const std::exception_ptr& exception) {
   return message;
 }
 
+// Returns the number of source nodes to process for a given plan node.
+// For most nodes, this is the number of sources. For index lookup join,
+// only the first source (probe side) is processed as a source node.
+inline size_t numSourceNodes(const core::PlanNode* planNode) {
+  if (!isIndexLookupJoin(planNode)) {
+    return planNode->sources().size();
+  }
+  const auto* indexNode =
+      checkedPointerCast<const core::IndexLookupJoinNode>(planNode);
+  VELOX_CHECK_EQ(indexNode->sources().size(), 2);
+  return !indexNode->needsIndexSplit() ? 1 : indexNode->sources().size();
+}
+
+// Collects IDs of IndexLookupJoinNode's lookup source (index) TableScanNodes.
+// These nodes are NOT separate pipeline leaves in Velox's LocalPlanner
+// (it only plans the probe source) and must be excluded from
+// groupedExecutionLeafNodeIds validation.
+void collectIndexSourceIds(
+    const core::PlanNodePtr& node,
+    std::unordered_set<core::PlanNodeId>& indexSourceIds) {
+  if (auto indexJoin =
+          std::dynamic_pointer_cast<const core::IndexLookupJoinNode>(node)) {
+    indexSourceIds.insert(indexJoin->lookupSource()->id());
+    // Only recurse into the probe side (sources()[0]), not the lookup source.
+    collectIndexSourceIds(indexJoin->sources()[0], indexSourceIds);
+    return;
+  }
+  for (const auto& source : node->sources()) {
+    collectIndexSourceIds(source, indexSourceIds);
+  }
+}
+
 // Add 'running time' metrics from CpuWallTiming structures to have them
 // available aggregated per thread.
 void addRunningTimeOperatorMetrics(exec::OperatorStats& op) {
-  op.runtimeStats["runningAddInputWallNanos"] =
+  op.runtimeStats[std::string(OperatorStats::kRunningAddInputWallNanos)] =
       RuntimeMetric(op.addInputTiming.wallNanos, RuntimeCounter::Unit::kNanos);
-  op.runtimeStats["runningGetOutputWallNanos"] =
+  op.runtimeStats[std::string(OperatorStats::kRunningGetOutputWallNanos)] =
       RuntimeMetric(op.getOutputTiming.wallNanos, RuntimeCounter::Unit::kNanos);
-  op.runtimeStats["runningFinishWallNanos"] =
+  op.runtimeStats[std::string(OperatorStats::kRunningFinishWallNanos)] =
       RuntimeMetric(op.finishTiming.wallNanos, RuntimeCounter::Unit::kNanos);
+  op.runtimeStats[std::string(OperatorStats::kRunningIsBlockedWallNanos)] =
+      RuntimeMetric(op.isBlockedTiming.wallNanos, RuntimeCounter::Unit::kNanos);
 }
 
 void buildSplitStates(
@@ -150,7 +185,7 @@ void buildSplitStates(
   }
 
   const auto& sources = planNode->sources();
-  const auto numSources = isIndexLookupJoin(planNode) ? 1 : sources.size();
+  const auto numSources = numSourceNodes(planNode);
   for (auto i = 0; i < numSources; ++i) {
     buildSplitStates(sources[i].get(), allIds, splitStateMap);
   }
@@ -173,26 +208,33 @@ std::string makeUuid() {
 
 // Returns true if an operator is a hash join operator given 'operatorType'.
 bool isHashJoinOperator(const std::string& operatorType) {
-  return (operatorType == "HashBuild") || (operatorType == "HashProbe");
+  return (operatorType == OperatorType::kHashBuild) ||
+      (operatorType == OperatorType::kHashProbe);
 }
 
 class QueueSplitsStore : public SplitsStore {
  public:
   using SplitsStore::SplitsStore;
 
-  void requestBarrier(std::vector<ContinuePromise>& promises) override {
-    addSplit(Split::createBarrier(), promises);
+  void requestBarrier(
+      uint32_t numDrivers,
+      std::vector<ContinuePromise>& promises) override {
+    addSplit(Split::createBarrier(numDrivers), promises);
   }
 
   bool nextSplit(
-      Split& split,
-      ContinueFuture& future,
+      std::optional<uint32_t> driverId,
       int maxPreloadSplits,
-      const ConnectorSplitPreloadFunc& preload) override {
+      const ConnectorSplitPreloadFunc& preload,
+      Split& split,
+      ContinueFuture& future) override {
     if (!splits_.empty()) {
       split = getSplit(maxPreloadSplits, preload);
       return true;
     }
+    if (tryGetBarrier(driverId, split)) {
+      return true;
+    }
     if (noMoreSplits_) {
       return true;
     }
@@ -300,7 +342,7 @@ bool registerSplitListenerFactory(
 bool unregisterSplitListenerFactory(
     const std::shared_ptr<SplitListenerFactory>& factory) {
   return splitListenerFactories().withWLock([&](auto& factories) {
-    for (auto it = factories.begin(); it != factories.end(); ++it) {
+    for (auto it = factories.cbegin(); it != factories.cend(); ++it) {
       if ((*it) == factory) {
         factories.erase(it);
         return true;
@@ -320,8 +362,8 @@ std::shared_ptr<Task> Task::create(
     ExecutionMode mode,
     Consumer consumer,
     int32_t memoryArbitrationPriority,
+    std::optional<common::SpillDiskOptions> spillDiskOpts,
     std::function<void(std::exception_ptr)> onError) {
-  VELOX_CHECK_NOT_NULL(planFragment.planNode);
   return Task::create(
       taskId,
       std::move(planFragment),
@@ -331,6 +373,7 @@ std::shared_ptr<Task> Task::create(
       (consumer ? [c = std::move(consumer)]() { return c; }
                 : ConsumerSupplier{}),
       memoryArbitrationPriority,
+      std::move(spillDiskOpts),
       std::move(onError));
 }
 
@@ -343,6 +386,7 @@ std::shared_ptr<Task> Task::create(
     ExecutionMode mode,
     ConsumerSupplier consumerSupplier,
     int32_t memoryArbitrationPriority,
+    std::optional<common::SpillDiskOptions> spillDiskOpts,
     std::function<void(std::exception_ptr)> onError) {
   VELOX_CHECK_NOT_NULL(planFragment.planNode);
   auto task = std::shared_ptr<Task>(new Task(
@@ -354,7 +398,7 @@ std::shared_ptr<Task> Task::create(
       std::move(consumerSupplier),
       memoryArbitrationPriority,
       std::move(onError)));
-  task->initTaskPool();
+  task->init(std::move(spillDiskOpts));
   task->addToTaskList();
   return task;
 }
@@ -377,7 +421,7 @@ Task::Task(
       planFragment_(std::move(planFragment)),
       firstNodeNotSupportingBarrier_(
           planFragment_.firstNodeNotSupportingBarrier()),
-      traceConfig_(maybeMakeTraceConfig()),
+      traceCtx_(maybeMakeTraceCtx()),
       consumerSupplier_(std::move(consumerSupplier)),
       onError_(std::move(onError)),
       splitsStates_(buildSplitStates(planFragment_.planNode)),
@@ -457,11 +501,6 @@ Task::~Task() {
 }
 
 void Task::ensureBarrierSupport() const {
-  VELOX_CHECK_EQ(
-      mode_,
-      Task::ExecutionMode::kSerial,
-      "Task doesn't support barriered execution.");
-
   VELOX_CHECK_NULL(
       firstNodeNotSupportingBarrier_,
       "Task doesn't support barriered execution. Name of the first node that "
@@ -469,6 +508,76 @@ void Task::ensureBarrierSupport() const {
       firstNodeNotSupportingBarrier_->name());
 }
 
+void Task::init(std::optional<common::SpillDiskOptions>&& spillDiskOpts) {
+  VELOX_CHECK(driverFactories_.empty());
+  initTaskPool();
+
+  setSpillDiskConfig(std::move(spillDiskOpts));
+
+  if (mode_ != Task::ExecutionMode::kSerial) {
+    return;
+  }
+
+  // Create drivers.
+  VELOX_CHECK_NULL(
+      consumerSupplier_,
+      "Serial execution mode doesn't support delivering results to a "
+      "callback");
+
+  taskStats_.executionStartTimeMs = getCurrentTimeMs();
+  LocalPlanner::plan(
+      planFragment_, nullptr, &driverFactories_, queryCtx_->queryConfig(), 1);
+  exchangeClients_.resize(driverFactories_.size());
+
+  // In Task::next() we always assume ungrouped execution.
+  for (const auto& factory : driverFactories_) {
+    VELOX_CHECK(factory->supportsSerialExecution());
+    numDriversUngrouped_ += factory->numDrivers;
+    numTotalDrivers_ += factory->numTotalDrivers;
+    taskStats_.pipelineStats.emplace_back(
+        factory->inputDriver, factory->outputDriver);
+    VELOX_CHECK_EQ(factory->numDrivers, 1);
+    numDriversPerLeafNode_[factory->leafNodeId()] = factory->numDrivers;
+  }
+
+  initDriverLifecycleStatsLocked();
+
+  // Create drivers.
+  createSplitGroupStateLocked(kUngroupedGroupId);
+  std::vector<std::shared_ptr<Driver>> drivers =
+      createDriversLocked(kUngroupedGroupId);
+  if (pool_->reservedBytes() != 0) {
+    VELOX_FAIL(
+        "Unexpected memory pool allocations during task[{}] driver initialization: {}",
+        taskId_,
+        pool_->treeMemoryUsage());
+  }
+
+  drivers_ = std::move(drivers);
+  driverBlockingStates_.reserve(drivers_.size());
+  for (auto i = 0; i < drivers_.size(); ++i) {
+    driverBlockingStates_.emplace_back(
+        std::make_unique<DriverBlockingState>(drivers_[i].get()));
+  }
+}
+
+void Task::setSpillDiskConfig(
+    std::optional<common::SpillDiskOptions>&& spillDiskOpts) {
+  if (!spillDiskOpts.has_value()) {
+    return;
+  }
+  VELOX_CHECK(
+      !spillDiskOpts->spillDirPath.empty(), "Spill directory can't be empty");
+  VELOX_CHECK(
+      spillDiskOpts->spillDirCreated || spillDiskOpts->spillDirCreateCb);
+  VELOX_CHECK_NULL(spillDirectoryCallback_);
+  VELOX_CHECK(!spillDirectoryCreated_);
+  VELOX_CHECK(spillDirectory_.empty());
+  spillDirectory_ = std::move(spillDiskOpts->spillDirPath);
+  spillDirectoryCreated_ = spillDiskOpts->spillDirCreated;
+  spillDirectoryCallback_ = std::move(spillDiskOpts->spillDirCreateCb);
+}
+
 Task::TaskList& Task::taskList() {
   static TaskList taskList;
   return taskList;
@@ -547,7 +656,7 @@ bool Task::allNodesReceivedNoMoreSplitsMessageLocked() const {
 const std::string& Task::getOrCreateSpillDirectory() {
   VELOX_CHECK(
       !spillDirectory_.empty() || spillDirectoryCallback_,
-      "Spill directory or spill directory callback must be set ");
+      "Spill directory or spill directory callback must be set");
   if (spillDirectoryCreated_) {
     return spillDirectory_;
   }
@@ -681,8 +790,9 @@ velox::memory::MemoryPool* Task::addOperatorPool(
   } else {
     nodePool = getOrAddNodePool(planNodeId);
   }
-  childPools_.push_back(nodePool->addLeafChild(fmt::format(
-      "op.{}.{}.{}.{}", planNodeId, pipelineId, driverId, operatorType)));
+  childPools_.push_back(nodePool->addLeafChild(
+      fmt::format(
+          "op.{}.{}.{}.{}", planNodeId, pipelineId, driverId, operatorType)));
   return childPools_.back().get();
 }
 
@@ -693,13 +803,14 @@ velox::memory::MemoryPool* Task::addConnectorPoolLocked(
     const std::string& operatorType,
     const std::string& connectorId) {
   auto* nodePool = getOrAddNodePool(planNodeId);
-  childPools_.push_back(nodePool->addAggregateChild(fmt::format(
-      "op.{}.{}.{}.{}.{}",
-      planNodeId,
-      pipelineId,
-      driverId,
-      operatorType,
-      connectorId)));
+  childPools_.push_back(nodePool->addAggregateChild(
+      fmt::format(
+          "op.{}.{}.{}.{}.{}",
+          planNodeId,
+          pipelineId,
+          driverId,
+          operatorType,
+          connectorId)));
   return childPools_.back().get();
 }
 
@@ -769,48 +880,8 @@ RowVectorPtr Task::next(ContinueFuture* future) {
     }
   }
 
-  // On first call, create the drivers.
-  if (driverFactories_.empty()) {
-    VELOX_CHECK_NULL(
-        consumerSupplier_,
-        "Serial execution mode doesn't support delivering results to a "
-        "callback");
-
-    taskStats_.executionStartTimeMs = getCurrentTimeMs();
-    LocalPlanner::plan(
-        planFragment_, nullptr, &driverFactories_, queryCtx_->queryConfig(), 1);
-    exchangeClients_.resize(driverFactories_.size());
-
-    // In Task::next() we always assume ungrouped execution.
-    for (const auto& factory : driverFactories_) {
-      VELOX_CHECK(factory->supportsSerialExecution());
-      numDriversUngrouped_ += factory->numDrivers;
-      numTotalDrivers_ += factory->numTotalDrivers;
-      taskStats_.pipelineStats.emplace_back(
-          factory->inputDriver, factory->outputDriver);
-    }
-
-    // Create drivers.
-    createSplitGroupStateLocked(kUngroupedGroupId);
-    std::vector<std::shared_ptr<Driver>> drivers =
-        createDriversLocked(kUngroupedGroupId);
-    if (pool_->reservedBytes() != 0) {
-      VELOX_FAIL(
-          "Unexpected memory pool allocations during task[{}] driver initialization: {}",
-          taskId_,
-          pool_->treeMemoryUsage());
-    }
-
-    drivers_ = std::move(drivers);
-    driverBlockingStates_.reserve(drivers_.size());
-    for (auto i = 0; i < drivers_.size(); ++i) {
-      driverBlockingStates_.emplace_back(
-          std::make_unique<DriverBlockingState>(drivers_[i].get()));
-    }
-    if (underBarrier()) {
-      startDriverBarriersLocked();
-    }
-  }
+  VELOX_CHECK_EQ(
+      state_, TaskState::kRunning, "Task has already finished processing.");
 
   // Run drivers one at a time. If a driver blocks, continue running the other
   // drivers. Running other drivers is expected to unblock some or all blocked
@@ -986,10 +1057,13 @@ void Task::createDriverFactoriesLocked(uint32_t maxDrivers) {
       numDriversUngrouped_ += factory->numDrivers;
     }
     numTotalDrivers_ += factory->numTotalDrivers;
+    numDriversPerLeafNode_[factory->leafNodeId()] = factory->numDrivers;
     taskStats_.pipelineStats.emplace_back(
         factory->inputDriver, factory->outputDriver);
   }
 
+  initDriverLifecycleStatsLocked();
+
   validateGroupedExecutionLeafNodes();
 }
 
@@ -1211,9 +1285,20 @@ void Task::validateGroupedExecutionLeafNodes() {
         !planFragment_.groupedExecutionLeafNodeIds.empty(),
         "groupedExecutionLeafNodeIds must not be empty in "
         "grouped execution mode");
+
+    // Collect IndexLookupJoin lookup source node IDs. These are in
+    // groupedExecutionLeafNodeIds (for coordinator-side grouped split
+    // scheduling) but are NOT separate pipeline leaves in Velox —
+    // IndexLookupJoin manages the index source internally.
+    std::unordered_set<core::PlanNodeId> indexSourceIds;
+    collectIndexSourceIds(planFragment_.planNode, indexSourceIds);
+
     // Check that each node designated as the grouped execution leaf node
     // existing in a pipeline that will run grouped execution.
     for (const auto& leafNodeId : planFragment_.groupedExecutionLeafNodeIds) {
+      if (indexSourceIds.count(leafNodeId)) {
+        continue;
+      }
       bool found{false};
       for (auto& factory : driverFactories_) {
         if (leafNodeId == factory->leafNodeId()) {
@@ -1263,6 +1348,8 @@ void Task::createSplitGroupStateLocked(uint32_t splitGroupId) {
         splitGroupId, factory->needsNestedLoopJoinBridges());
     addSpatialJoinBridgesLocked(
         splitGroupId, factory->needsSpatialJoinBridges());
+    addIndexLookupJoinBridgesLocked(
+        splitGroupId, factory->needsIndexLookupJoinBridges());
     addCustomJoinBridgesLocked(splitGroupId, factory->planNodes);
 
     core::PlanNodeId tableScanNodeId;
@@ -1600,18 +1687,12 @@ void Task::addSplitToStoreLocked(
     uint32_t groupId,
     const exec::Split& split,
     std::vector<ContinuePromise>& promises) {
-  auto& splitsStore = splitsState.groupSplitsStores[groupId];
-  if (!splitsStore) {
-    setSplitsStore(
-        splitsStore,
-        std::make_unique<QueueSplitsStore>(!splitsState.sourceIsTableScan));
-  }
+  auto* splitsStore = getOrCreateSplitsStoreLocked(splitsState, groupId);
   if (split.isBarrier()) {
-    splitsStore->requestBarrier(promises);
+    splitsStore->requestBarrier(split.barrier->numDrivers, promises);
     return;
   }
-  auto* queueSplitsStore =
-      checked_pointer_cast<QueueSplitsStore>(splitsStore.get());
+  auto* queueSplitsStore = checkedPointerCast<QueueSplitsStore>(splitsStore);
   queueSplitsStore->addSplit(split, promises);
 }
 
@@ -1625,7 +1706,7 @@ void Task::noMoreSplitsForGroup(
 
     auto& splitsState = getPlanNodeSplitsStateLocked(planNodeId);
     noMoreSplitsForStore(
-        splitsState.groupSplitsStores[splitGroupId].get(), promises);
+        getOrCreateSplitsStoreLocked(splitsState, splitGroupId), promises);
 
     // There were no splits in this group, hence, no active drivers. Mark the
     // group complete.
@@ -1722,6 +1803,18 @@ void Task::setSplitsStore(
   splitsStore->setPreloadingSplits(preloadingSplits_);
 }
 
+SplitsStore* Task::getOrCreateSplitsStoreLocked(
+    SplitsState& splitsState,
+    uint32_t splitGroupId) {
+  auto& splitsStore = splitsState.groupSplitsStores[splitGroupId];
+  if (!splitsStore) {
+    setSplitsStore(
+        splitsStore,
+        std::make_unique<QueueSplitsStore>(!splitsState.sourceIsTableScan));
+  }
+  return splitsStore.get();
+}
+
 ContinueFuture Task::requestBarrier() {
   ensureBarrierSupport();
   return startBarrier("Task::requestBarrier");
@@ -1764,7 +1857,8 @@ ContinueFuture Task::startBarrier(std::string_view comment) {
 
   promises.reserve(leafPlanNodeIds.size());
   for (const auto& leafPlanNode : leafPlanNodeIds) {
-    auto barrierSplit = Split::createBarrier();
+    const auto barrierSplit =
+        Split::createBarrier(numDriversPerLeafNode_.at(leafPlanNode));
     auto& splitState = getPlanNodeSplitsStateLocked(leafPlanNode);
     addSplitLocked(splitState, barrierSplit, promises);
   }
@@ -1862,8 +1956,8 @@ void Task::dropInputLocked(
     VELOX_CHECK(!drivers.empty());
     const auto dropNodeId = *dropNodeIds.begin();
     bool foundDriver{false};
-    auto it = drivers.begin();
-    while (it != drivers.end()) {
+    auto it = drivers.cbegin();
+    while (it != drivers.cend()) {
       Driver* driver = *it;
       VELOX_CHECK_NOT_NULL(driver);
       if (auto* dropOp = driver->findOperator(dropNodeId)) {
@@ -1925,21 +2019,18 @@ bool Task::isAllSplitsFinishedLocked() {
 }
 
 BlockingReason Task::getSplitOrFuture(
+    uint32_t driverId,
     uint32_t splitGroupId,
     const core::PlanNodeId& planNodeId,
-    exec::Split& split,
-    ContinueFuture& future,
     int32_t maxPreloadSplits,
-    const ConnectorSplitPreloadFunc& preload) {
+    const ConnectorSplitPreloadFunc& preload,
+    exec::Split& split,
+    ContinueFuture& future) {
   std::lock_guard<std::timed_mutex> l(mutex_);
   auto& splitsState = getPlanNodeSplitsStateLocked(planNodeId);
-  auto& splitsStore = splitsState.groupSplitsStores[splitGroupId];
-  if (!splitsStore) {
-    setSplitsStore(
-        splitsStore,
-        std::make_unique<QueueSplitsStore>(!splitsState.sourceIsTableScan));
-  }
-  return splitsStore->nextSplit(split, future, maxPreloadSplits, preload)
+  auto* splitsStore = getOrCreateSplitsStoreLocked(splitsState, splitGroupId);
+  return splitsStore->nextSplit(
+             driverId, maxPreloadSplits, preload, split, future)
       ? BlockingReason::kNotBlocked
       : BlockingReason::kWaitForSplit;
 }
@@ -2301,6 +2392,26 @@ void Task::addSpatialJoinBridgesLocked(
   }
 }
 
+void Task::addIndexLookupJoinBridgesLocked(
+    uint32_t splitGroupId,
+    const std::vector<core::PlanNodeId>& planNodeIds) {
+  auto& splitGroupState = splitGroupStates_[splitGroupId];
+  for (const auto& planNodeId : planNodeIds) {
+    auto const inserted =
+        splitGroupState.bridges
+            .emplace(planNodeId, std::make_shared<IndexLookupJoinBridge>())
+            .second;
+    VELOX_CHECK(
+        inserted, "Join bridge for node {} is already present", planNodeId);
+  }
+}
+
+std::shared_ptr<IndexLookupJoinBridge> Task::getIndexLookupJoinBridge(
+    uint32_t splitGroupId,
+    const core::PlanNodeId& planNodeId) {
+  return getJoinBridgeInternal<IndexLookupJoinBridge>(splitGroupId, planNodeId);
+}
+
 std::shared_ptr<HashJoinBridge> Task::getHashJoinBridge(
     uint32_t splitGroupId,
     const core::PlanNodeId& planNodeId) {
@@ -2339,7 +2450,7 @@ template <class TBridgeType, typename MemberType>
 std::shared_ptr<TBridgeType> Task::getJoinBridgeInternalLocked(
     uint32_t splitGroupId,
     const core::PlanNodeId& planNodeId,
-    MemberType SplitGroupState::*bridges_member) {
+    MemberType SplitGroupState::* bridges_member) {
   const auto& splitGroupState = splitGroupStates_[splitGroupId];
 
   auto it = (splitGroupState.*bridges_member).find(planNodeId);
@@ -2409,22 +2520,27 @@ ContinueFuture Task::terminate(TaskState terminalState) {
         "Termination time has already been set, this should only happen once.");
     taskStats_.terminationTimeMs = getCurrentTimeMs();
     if (state_ == TaskState::kCanceled || state_ == TaskState::kAborted) {
-      try {
-        VELOX_FAIL(
-            state_ == TaskState::kCanceled ? "Cancelled"
-                                           : "Aborted for external error");
-      } catch (const std::exception&) {
-        exception_ = std::current_exception();
-      }
+      // Construct the exception directly instead of going through VELOX_FAIL to
+      // avoid error log when cancellation is expected.
+      exception_ = std::make_exception_ptr(VeloxRuntimeError(
+          __FILE__,
+          __LINE__,
+          __FUNCTION__,
+          /*expression=*/"",
+          state_ == TaskState::kCanceled ? "Cancelled"
+                                         : "Aborted for external error",
+          error_source::kErrorSourceRuntime,
+          error_code::kInvalidState,
+          /*isRetriable=*/false));
     }
     if (state_ != TaskState::kFinished) {
       VELOX_CHECK(!cancellationSource_.isCancellationRequested());
       cancellationSource_.requestCancellation();
     }
 
-    LOG(INFO) << "Terminating task " << taskId() << " with state "
-              << taskStateString(state_) << " after running for "
-              << succinctMillis(timeSinceStartMsLocked());
+    VLOG(1) << "Terminating task " << taskId() << " with state "
+            << taskStateString(state_) << " after running for "
+            << succinctMillis(timeSinceStartMsLocked());
 
     taskCompletionNotifier.activate(
         std::move(taskCompletionPromises_), [&]() { onTaskCompletion(); });
@@ -2452,6 +2568,9 @@ ContinueFuture Task::terminate(TaskState terminalState) {
     exchangeClients.swap(exchangeClients_);
 
     barrierPromises.swap(barrierFinishPromises_);
+    // Clear the barrier flag to ensure underBarrier() returns false after task
+    // termination.
+    barrierRequested_ = false;
   }
 
   taskCompletionNotifier.notify();
@@ -2514,8 +2633,13 @@ ContinueFuture Task::terminate(TaskState terminalState) {
           }
           while (!store->allSplitsConsumed()) {
             auto future = ContinueFuture::makeEmpty();
-            VELOX_CHECK(
-                store->nextSplit(splits.emplace_back(), future, 0, nullptr));
+            const auto hasNextSplit = store->nextSplit(
+                /*driverId=*/std::nullopt,
+                /*maxPreloadSplits=*/0,
+                /*preload=*/nullptr,
+                splits.emplace_back(),
+                future);
+            VELOX_CHECK(hasNextSplit);
           }
         }
         if (!splits.empty()) {
@@ -2616,6 +2740,37 @@ void Task::addDriverStats(int pipelineId, DriverStats stats) {
   taskStats_.pipelineStats[pipelineId].driverStats.push_back(std::move(stats));
 }
 
+void Task::initDriverLifecycleStatsLocked() {
+  pipelineLifecycleStats_.resize(driverFactories_.size());
+  for (size_t i = 0; i < driverFactories_.size(); ++i) {
+    auto& pls = pipelineLifecycleStats_[i];
+    const auto& leafNode = driverFactories_[i]->planNodes.front();
+    pls.sourceOperatorType = leafNode->name();
+    pls.sourcePlanNodeId = leafNode->id();
+    pls.driverTimes.resize(driverFactories_[i]->numDrivers);
+  }
+}
+
+void Task::addDriverLifecycleStats(
+    uint32_t pipelineId,
+    uint32_t driverIndex,
+    uint64_t queuedNanos,
+    uint64_t onThreadNanos,
+    uint64_t blockedNanos) {
+  std::lock_guard<std::timed_mutex> l(mutex_);
+  if (pipelineId >= pipelineLifecycleStats_.size()) {
+    return;
+  }
+  auto& pls = pipelineLifecycleStats_[pipelineId];
+  if (pls.driverTimes.empty()) {
+    return;
+  }
+  const auto idx = driverIndex % pls.driverTimes.size();
+  pls.driverTimes[idx].queuedNanos += queuedNanos;
+  pls.driverTimes[idx].onThreadNanos += onThreadNanos;
+  pls.driverTimes[idx].blockedNanos += blockedNanos;
+}
+
 TaskStats Task::taskStats() const {
   std::lock_guard<std::timed_mutex> l(mutex_);
 
@@ -2671,6 +2826,41 @@ TaskStats Task::taskStats() const {
     taskStats.longestRunningOpCallMs = 0;
   }
 
+  // Emit per-pipeline driver lifecycle timing. Merged into the first
+  // existing DriverStats entry for each pipeline to avoid inflating the
+  // driverStats vector. Each logical driver index contributes one sample,
+  // giving proper sum/count/min/max aggregation.
+  for (size_t i = 0; i < pipelineLifecycleStats_.size(); ++i) {
+    const auto& pls = pipelineLifecycleStats_[i];
+    if (pls.driverTimes.empty()) {
+      continue;
+    }
+    auto& pipeDriverStats = taskStats.pipelineStats[i].driverStats;
+    if (pipeDriverStats.empty()) {
+      pipeDriverStats.emplace_back();
+    }
+    auto& targetStats = pipeDriverStats[0].runtimeStats;
+    const auto prefix = fmt::format(
+        "P{}-{}.{}", i, pls.sourceOperatorType, pls.sourcePlanNodeId);
+    const auto queuedKey = fmt::format("{}.driverQueuedWallNanos", prefix);
+    const auto onThreadKey = fmt::format("{}.driverOnThreadWallNanos", prefix);
+    const auto blockedKey = fmt::format("{}.driverBlockedWallNanos", prefix);
+    for (const auto& timing : pls.driverTimes) {
+      auto addOrMerge = [&targetStats](const std::string& key, uint64_t nanos) {
+        const auto value = saturateCast(nanos);
+        auto it = targetStats.find(key);
+        if (it != targetStats.end()) {
+          it->second.merge(RuntimeMetric(value, RuntimeCounter::Unit::kNanos));
+        } else {
+          targetStats[key] = RuntimeMetric(value, RuntimeCounter::Unit::kNanos);
+        }
+      };
+      addOrMerge(queuedKey, timing.queuedNanos);
+      addOrMerge(onThreadKey, timing.onThreadNanos);
+      addOrMerge(blockedKey, timing.blockedNanos);
+    }
+  }
+
   auto bufferManager = bufferManager_.lock();
   taskStats.outputBufferUtilization = bufferManager->getUtilization(taskId_);
   taskStats.outputBufferOverutilized = bufferManager->isOverutilized(taskId_);
@@ -2770,19 +2960,29 @@ void Task::onTaskCompletion() {
     }
 
     for (auto& listener : listeners) {
-      listener->onTaskCompletion(
-          uuid_,
-          taskId_,
-          state,
-          exception,
-          stats,
-          planFragment_,
-          exchangeClientByPlanNode_);
+      try {
+        listener->onTaskCompletion(
+            uuid_,
+            taskId_,
+            state,
+            exception,
+            stats,
+            planFragment_,
+            exchangeClientByPlanNode_);
+      } catch (const std::exception& e) {
+        LOG(ERROR) << "TaskCompletionListener threw for task " << taskId_
+                   << ": " << e.what();
+      }
     }
   });
 
   for (auto& listener : splitListeners_) {
-    listener->onTaskCompletion();
+    try {
+      listener->onTaskCompletion();
+    } catch (const std::exception& e) {
+      LOG(ERROR) << "SplitCompletionListener threw for task " << taskId_ << ": "
+                 << e.what();
+    }
   }
 }
 
@@ -3006,8 +3206,9 @@ void Task::createLocalExchangeQueuesLocked(
       queryCtx_->queryConfig().maxLocalExchangeBufferSize());
   exchange.queues.reserve(numPartitions);
   for (auto i = 0; i < numPartitions; ++i) {
-    exchange.queues.emplace_back(std::make_shared<LocalExchangeQueue>(
-        exchange.memoryManager, exchange.vectorPool, i));
+    exchange.queues.emplace_back(
+        std::make_shared<LocalExchangeQueue>(
+            exchange.memoryManager, exchange.vectorPool, i));
   }
 
   const auto partitionNode =
@@ -3138,7 +3339,7 @@ std::string Task::errorMessage() const {
 }
 
 StopReason Task::enter(ThreadState& state, uint64_t nowMicros) {
-  TestValue::adjust("facebook::velox::exec::Task::enter", &state);
+  TestValue::adjust("facebook::velox::exec::Task::enter", this);
   std::lock_guard<std::timed_mutex> l(mutex_);
   VELOX_CHECK(state.isEnqueued);
   state.isEnqueued = false;
@@ -3396,7 +3597,9 @@ void Task::createExchangeClientLocked(
       queryCtx()->queryConfig().minExchangeOutputBatchBytes(),
       addExchangeClientPool(planNodeId, pipelineId),
       queryCtx()->executor(),
-      queryCtx()->queryConfig().requestDataSizesMaxWaitSec());
+      queryCtx()->queryConfig().requestDataSizesMaxWaitSec(),
+      queryCtx()->queryConfig().singleSourceExchangeOptimizationEnabled(),
+      queryCtx()->queryConfig().exchangeLazyFetchingEnabled());
   exchangeClientByPlanNode_.emplace(planNodeId, exchangeClients_[pipelineId]);
 }
 
@@ -3415,66 +3618,27 @@ std::shared_ptr<ExchangeClient> Task::getExchangeClientLocked(
   return exchangeClients_[pipelineId];
 }
 
-std::optional<TraceConfig> Task::maybeMakeTraceConfig() const {
-  const auto& queryConfig = queryCtx_->queryConfig();
-  if (!queryConfig.queryTraceEnabled()) {
-    return std::nullopt;
+std::unique_ptr<trace::TraceCtx> Task::maybeMakeTraceCtx() const {
+  if (!queryCtx_->queryConfig().queryTraceEnabled()) {
+    return nullptr;
   }
 
-  VELOX_USER_CHECK(
-      !queryConfig.queryTraceDir().empty(),
-      "Query trace enabled but the trace dir is not set");
-
-  VELOX_USER_CHECK(
-      !queryConfig.queryTraceTaskRegExp().empty(),
-      "Query trace enabled but the trace task regexp is not set");
-
-  if (!RE2::FullMatch(taskId_, queryConfig.queryTraceTaskRegExp())) {
-    return std::nullopt;
+  if (queryCtx_->traceCtxProvider()) {
+    return queryCtx_->traceCtxProvider()(*queryCtx_, planFragment());
   }
-
-  const auto traceNodeId = queryConfig.queryTraceNodeId();
-  VELOX_USER_CHECK(!traceNodeId.empty(), "Query trace node ID are not set");
-
-  const auto traceDir = trace::getTaskTraceDirectory(
-      queryConfig.queryTraceDir(), queryCtx_->queryId(), taskId_);
-
-  VELOX_USER_CHECK_NOT_NULL(
-      core::PlanNode::findFirstNode(
-          planFragment_.planNode.get(),
-          [traceNodeId](const core::PlanNode* node) -> bool {
-            return node->id() == traceNodeId;
-          }),
-      "Trace plan node ID = {} not found from task {}",
-      traceNodeId,
-      taskId_);
-
-  LOG(INFO) << "Trace input for plan nodes " << traceNodeId << " from task "
-            << taskId_;
-
-  UpdateAndCheckTraceLimitCB updateAndCheckTraceLimitCB =
-      [this](uint64_t bytes) {
-        queryCtx_->updateTracedBytesAndCheckLimit(bytes);
-      };
-  return TraceConfig(
-      traceNodeId,
-      traceDir,
-      std::move(updateAndCheckTraceLimitCB),
-      queryConfig.queryTraceTaskRegExp(),
-      queryConfig.queryTraceDryRun());
+  // Fallback to default trace.
+  return trace::OperatorTraceCtx::maybeCreate(
+      *queryCtx_, planFragment(), taskId());
 }
 
 void Task::maybeInitTrace() {
-  if (!traceConfig_) {
+  if (!traceCtx_) {
     return;
   }
 
-  trace::createTraceDirectory(traceConfig_->queryTraceDir);
-  const auto metadataWriter = std::make_unique<trace::TaskTraceMetadataWriter>(
-      traceConfig_->queryTraceDir, memory::traceMemoryPool());
-  auto traceNode =
-      trace::getTraceNode(planFragment_.planNode, traceConfig_->queryNodeId);
-  metadataWriter->write(queryCtx_, traceNode);
+  if (auto metadataWriter = traceCtx_->createMetadataTracer()) {
+    metadataWriter->write(*queryCtx_, *planFragment_.planNode);
+  }
 }
 
 void Task::testingVisitDrivers(const std::function<void(Driver*)>& callback) {
@@ -3685,8 +3849,8 @@ bool Task::DriverBlockingState::blocked(ContinueFuture* future) {
     VELOX_CHECK(promises_.empty());
     return false;
   }
-  auto [blockPromise, blockFuture] =
-      makeVeloxContinuePromiseContract(fmt::format(
+  auto [blockPromise, blockFuture] = makeVeloxContinuePromiseContract(
+      fmt::format(
           "DriverBlockingState {} from task {}",
           driver_->driverCtx()->driverId,
           driver_->task()->taskId()));
diff --git a/velox/exec/Task.h b/velox/exec/Task.h
index 01b906df087..2b483b806a9 100644
--- a/velox/exec/Task.h
+++ b/velox/exec/Task.h
@@ -15,8 +15,9 @@
  */
 #pragma once
 
+#include <folly/container/IntrusiveList.h>
+
 #include "velox/common/base/SkewedPartitionBalancer.h"
-#include "velox/common/base/TraceConfig.h"
 #include "velox/core/PlanFragment.h"
 #include "velox/core/QueryCtx.h"
 #include "velox/exec/Driver.h"
@@ -26,6 +27,7 @@
 #include "velox/exec/ScaledScanController.h"
 #include "velox/exec/TaskStats.h"
 #include "velox/exec/TaskStructs.h"
+#include "velox/exec/trace/TraceCtx.h"
 #include "velox/vector/ComplexVector.h"
 
 namespace facebook::velox::exec {
@@ -33,6 +35,7 @@ namespace facebook::velox::exec {
 class OutputBufferManager;
 
 class HashJoinBridge;
+class IndexLookupJoinBridge;
 class NestedLoopJoinBridge;
 class SpatialJoinBridge;
 class SplitListener;
@@ -66,11 +69,16 @@ class Task : public std::enable_shared_from_this<Task> {
   /// @param consumer Optional factory function to get callbacks to pass the
   /// results of the execution. In a parallel execution mode, results from each
   /// thread are passed on to a separate consumer.
+  /// @param memoryArbitrationPriority Priority used by the memory arbitrator
+  /// to determine which task should have its memory reclaimed first when the
+  /// system is under memory pressure. Higher values indicate higher priority
+  /// (lower likelihood of being reclaimed). Default is 0.
+  /// @param spillDiskOpts Optional configuration for spill disk storage. When
+  /// provided, allows operators to spill intermediate data to disk during
+  /// execution when memory pressure is high. Includes spill directory path
+  /// and callback options. Default is std::nullopt (no spilling).
   /// @param onError Optional callback to receive an exception if task
   /// execution fails.
-  /// @param memoryArbitrationPriority Optional priority on task that, in a
-  /// multi task system, is used for memory arbitration to decide the order of
-  /// reclaiming.
   static std::shared_ptr<Task> create(
       const std::string& taskId,
       core::PlanFragment planFragment,
@@ -79,6 +87,7 @@ class Task : public std::enable_shared_from_this<Task> {
       ExecutionMode mode,
       Consumer consumer = nullptr,
       int32_t memoryArbitrationPriority = 0,
+      std::optional<common::SpillDiskOptions> spillDiskOpts = std::nullopt,
       std::function<void(std::exception_ptr)> onError = nullptr);
 
   static std::shared_ptr<Task> create(
@@ -89,6 +98,7 @@ class Task : public std::enable_shared_from_this<Task> {
       ExecutionMode mode,
       ConsumerSupplier consumerSupplier,
       int32_t memoryArbitrationPriority = 0,
+      std::optional<common::SpillDiskOptions> spillDiskOpts = std::nullopt,
       std::function<void(std::exception_ptr)> onError = nullptr);
 
   /// Convenience function for shortening a Presto taskId. To be used
@@ -97,22 +107,6 @@ class Task : public std::enable_shared_from_this<Task> {
 
   ~Task();
 
-  /// Specify directory to which data will be spilled if spilling is enabled and
-  /// required. Set 'alreadyCreated' to true if the directory has already been
-  /// created by the caller.
-  void setSpillDirectory(
-      const std::string& spillDirectory,
-      bool alreadyCreated = true) {
-    spillDirectory_ = spillDirectory;
-    spillDirectoryCreated_ = alreadyCreated;
-  }
-
-  void setCreateSpillDirectoryCb(
-      std::function<std::string()> spillDirectoryCallback) {
-    VELOX_CHECK_NULL(spillDirectoryCallback_);
-    spillDirectoryCallback_ = std::move(spillDirectoryCallback);
-  }
-
   /// Returns human-friendly representation of the plan augmented with runtime
   /// statistics. The implementation invokes exec::printPlanWithStats().
   ///
@@ -160,8 +154,8 @@ class Task : public std::enable_shared_from_this<Task> {
   }
 
   /// Returns query trace config if specified.
-  const std::optional<TraceConfig>& traceConfig() const {
-    return traceConfig_;
+  const trace::TraceCtx* traceCtx() const {
+    return traceCtx_.get();
   }
 
   /// Returns ConsumerSupplier passed in the constructor.
@@ -446,12 +440,13 @@ class Task : public std::enable_shared_from_this<Task> {
   /// so many of splits at the head of the queue are preloading. If
   /// they are not, calls preload on them to start preload.
   BlockingReason getSplitOrFuture(
+      uint32_t driverId,
       uint32_t splitGroupId,
       const core::PlanNodeId& planNodeId,
+      int32_t maxPreloadSplits,
+      const ConnectorSplitPreloadFunc& preload,
       exec::Split& split,
-      ContinueFuture& future,
-      int32_t maxPreloadSplits = 0,
-      const ConnectorSplitPreloadFunc& preload = nullptr);
+      ContinueFuture& future);
 
   /// Returns the scaled scan controller for a given table scan node if the
   /// query has configured.
@@ -520,7 +515,7 @@ class Task : public std::enable_shared_from_this<Task> {
   void setError(const std::string& message);
 
   /// Returns all the peer operators of the 'caller' operator from a given
-  /// 'pipelindId' in this task.
+  /// 'pipelineId' in this task.
   std::vector<Operator*> findPeerOperators(int pipelineId, Operator* caller);
 
   /// Synchronizes completion of an Operator across Drivers of 'this'.
@@ -566,6 +561,11 @@ class Task : public std::enable_shared_from_this<Task> {
       uint32_t splitGroupId,
       const std::vector<core::PlanNodeId>& planNodeIds);
 
+  /// Adds IndexLookupJoinBridge's for all the specified plan node IDs.
+  void addIndexLookupJoinBridgesLocked(
+      uint32_t splitGroupId,
+      const std::vector<core::PlanNodeId>& planNodeIds);
+
   /// Adds custom join bridges for all the specified plan nodes.
   void addCustomJoinBridgesLocked(
       uint32_t splitGroupId,
@@ -593,6 +593,11 @@ class Task : public std::enable_shared_from_this<Task> {
       uint32_t splitGroupId,
       const core::PlanNodeId& planNodeId);
 
+  /// Returns an IndexLookupJoinBridge for 'planNodeId'.
+  std::shared_ptr<IndexLookupJoinBridge> getIndexLookupJoinBridge(
+      uint32_t splitGroupId,
+      const core::PlanNodeId& planNodeId);
+
   /// Returns a custom join bridge for 'planNodeId'.
   std::shared_ptr<JoinBridge> getCustomJoinBridge(
       uint32_t splitGroupId,
@@ -610,6 +615,16 @@ class Task : public std::enable_shared_from_this<Task> {
   /// Adds per driver statistics.  Called from Drivers upon their closure.
   void addDriverStats(int pipelineId, DriverStats stats);
 
+  /// Accumulates driver lifecycle timing (queued, on-thread, blocked) for gap
+  /// analysis. Same-index drivers across split groups are summed together.
+  /// Called from Driver::closeOperators() upon driver closure.
+  void addDriverLifecycleStats(
+      uint32_t pipelineId,
+      uint32_t driverIndex,
+      uint64_t queuedNanos,
+      uint64_t onThreadNanos,
+      uint64_t blockedNanos);
+
   /// Returns kNone if no pause or terminate is requested. The thread count is
   /// incremented if kNone is returned. If something else is returned the
   /// calling thread should unwind and return itself to its pool. If 'this' goes
@@ -626,7 +641,7 @@ class Task : public std::enable_shared_from_this<Task> {
   StopReason enterForTerminateLocked(ThreadState& state);
 
   /// Marks that the Driver is not on thread. If no more Drivers in the
-  /// CancelPool are on thread, this realizes threadFinishFutures_. These allow
+  /// Task are on thread, this realizes threadFinishFutures_.
   /// syncing with pause or termination. The Driver may go off thread because of
   /// hasBlockingFuture or pause requested or terminate requested. The
   /// return value indicates the reason. If kTerminate is returned, the
@@ -821,6 +836,13 @@ class Task : public std::enable_shared_from_this<Task> {
       int32_t memoryArbitrationPriority = 0,
       std::function<void(std::exception_ptr)> onError = nullptr);
 
+  // Invoked to do post-create initialization.
+  void init(std::optional<common::SpillDiskOptions>&& spillDiskOpts);
+
+  // Invoked to initialize the spill storage config for this task.
+  void setSpillDiskConfig(
+      std::optional<common::SpillDiskOptions>&& spillDiskOpts);
+
   // Invoked to add this to the system-wide running task list on task creation.
   void addToTaskList();
 
@@ -859,7 +881,7 @@ class Task : public std::enable_shared_from_this<Task> {
   // message.
   bool allNodesReceivedNoMoreSplitsMessageLocked() const;
 
-  // Recursive helper for 'allSpilitsConsumed()' method.
+  // Recursive helper for 'allSplitsConsumed()' method.
   bool allSplitsConsumedHelper(const core::PlanNode* planNode) const;
 
   // Remove the spill directory, if the Task was creating it for potential
@@ -944,7 +966,7 @@ class Task : public std::enable_shared_from_this<Task> {
       VELOX_CHECK_NOT_NULL(task);
     }
 
-    // Gets the shared pointer to the driver to ensure its liveness during the
+    // Gets the shared pointer to the task to ensure its liveness during the
     // memory reclaim operation.
     //
     // NOTE: a task's memory pool might outlive the task itself.
@@ -976,7 +998,7 @@ class Task : public std::enable_shared_from_this<Task> {
   std::shared_ptr<TBridgeType> getJoinBridgeInternalLocked(
       uint32_t splitGroupId,
       const core::PlanNodeId& planNodeId,
-      MemberType SplitGroupState::*bridges_member);
+      MemberType SplitGroupState::* bridges_member);
 
   std::shared_ptr<JoinBridge> getCustomJoinBridgeInternal(
       uint32_t splitGroupId,
@@ -1038,6 +1060,12 @@ class Task : public std::enable_shared_from_this<Task> {
       std::unique_ptr<SplitsStore>& splitsStore,
       std::unique_ptr<SplitsStore> newSplitsStore);
 
+  // Returns the splits store for the given group, creating one if it doesn't
+  // exist.
+  SplitsStore* getOrCreateSplitsStoreLocked(
+      SplitsState& splitsState,
+      uint32_t splitGroupId);
+
   // Invoked when all the driver threads are off thread. The function returns
   // 'threadFinishPromises_' to fulfill.
   std::vector<ContinuePromise> allThreadsFinishedLocked();
@@ -1118,7 +1146,7 @@ class Task : public std::enable_shared_from_this<Task> {
       int32_t pipelineId) const;
 
   // Builds the query trace config.
-  std::optional<TraceConfig> maybeMakeTraceConfig() const;
+  std::unique_ptr<trace::TraceCtx> maybeMakeTraceCtx() const;
 
   // Create a 'QueryMetadtaWriter' to trace the query metadata if the query
   // trace enabled.
@@ -1165,7 +1193,7 @@ class Task : public std::enable_shared_from_this<Task> {
   // and all its plan nodes support barrier processing.
   const core::PlanNode* firstNodeNotSupportingBarrier_{};
 
-  const std::optional<TraceConfig> traceConfig_;
+  const std::unique_ptr<trace::TraceCtx> traceCtx_;
 
   inline static std::atomic_uint64_t numCreatedTasks_;
 
@@ -1176,7 +1204,7 @@ class Task : public std::enable_shared_from_this<Task> {
   // to pool_ must be defined after pool_, childPools_.
   std::shared_ptr<memory::MemoryPool> pool_;
 
-  // Keep driver and operator memory pools alive for the duration of the task
+  // Keep plan node and operator memory pools alive for the duration of the task
   // to allow for sharing vectors across drivers without copy.
   std::vector<std::shared_ptr<memory::MemoryPool>> childPools_;
 
@@ -1215,11 +1243,12 @@ class Task : public std::enable_shared_from_this<Task> {
   ConsumerSupplier consumerSupplier_;
 
   // The function that is executed when the task encounters its first error,
-  // that is, serError() is called for the first time.
+  // that is, setError() is called for the first time.
   std::function<void(std::exception_ptr)> onError_;
 
   std::vector<std::unique_ptr<DriverFactory>> driverFactories_;
   std::vector<std::shared_ptr<Driver>> drivers_;
+  std::unordered_map<core::PlanNodeId, uint32_t> numDriversPerLeafNode_;
 
   // Tracks the blocking state for each driver under serialized execution mode.
   class DriverBlockingState {
@@ -1349,6 +1378,27 @@ class Task : public std::enable_shared_from_this<Task> {
 
   TaskStats taskStats_;
 
+  // Per-pipeline driver lifecycle timing accumulator. For each pipeline, holds
+  // a vector of per-driver timing indexed by driver index within the pipeline.
+  // In grouped execution, same-index drivers across groups accumulate into the
+  // same entry, giving the total time for a logical driver across all groups.
+  // Reported as RuntimeMetrics at task close via taskStats().
+  struct DriverLifecycleTiming {
+    uint64_t queuedNanos{0};
+    uint64_t onThreadNanos{0};
+    uint64_t blockedNanos{0};
+  };
+
+  struct PipelineLifecycleStats {
+    std::string sourceOperatorType;
+    core::PlanNodeId sourcePlanNodeId;
+    std::vector<DriverLifecycleTiming> driverTimes;
+  };
+  std::vector<PipelineLifecycleStats> pipelineLifecycleStats_;
+
+  /// Initializes pipelineLifecycleStats_ from driverFactories_.
+  void initDriverLifecycleStatsLocked();
+
   // Stores inter-operator state (exchange, bridges) per split group. During
   // ungrouped execution we use the [0] entry in this vector.
   std::unordered_map<uint32_t, SplitGroupState> splitGroupStates_;
@@ -1377,7 +1427,7 @@ class Task : public std::enable_shared_from_this<Task> {
   // The promises for the futures returned to callers of requestBarrier().
   std::vector<ContinuePromise> barrierFinishPromises_;
 
-  std::atomic<int32_t> toYield_ = 0;
+  std::atomic_int32_t toYield_ = 0;
   int32_t numThreads_ = 0;
   // Microsecond real time when 'this' last went from no threads to
   // one thread running. Used to decide if continuous run should be
diff --git a/velox/exec/TaskStructs.cpp b/velox/exec/TaskStructs.cpp
index 21786166125..2d5cbc27d42 100644
--- a/velox/exec/TaskStructs.cpp
+++ b/velox/exec/TaskStructs.cpp
@@ -23,12 +23,23 @@ void SplitsStore::addSplit(
     std::vector<ContinuePromise>& promises) {
   VELOX_CHECK(!noMoreSplits_);
   VELOX_CHECK(!(remoteSplit_ && split.isBarrier()));
-  splits_.push_back(std::move(split));
-  if (promises_.empty()) {
-    return;
+  VELOX_CHECK(barrierSplits_.empty());
+  if (split.isBarrier()) {
+    for (auto i = 0; i < split.barrier->numDrivers; ++i) {
+      barrierSplits_[i] = Split::createBarrier();
+    }
+    VELOX_CHECK_LE(promises_.size(), split.barrier->numDrivers);
+    // A barrier is assigned to every driver; wake up all currently blocked
+    // drivers to process it.
+    std::move(promises_.begin(), promises_.end(), std::back_inserter(promises));
+    promises_.clear();
+  } else {
+    splits_.push_back(std::move(split));
+    if (!promises_.empty()) {
+      promises.push_back(std::move(promises_.back()));
+      promises_.pop_back();
+    }
   }
-  promises.push_back(std::move(promises_.back()));
-  promises_.pop_back();
 }
 
 ContinueFuture SplitsStore::makeFuture() {
@@ -85,4 +96,21 @@ Split SplitsStore::getSplit(
   return split;
 }
 
+bool SplitsStore::tryGetBarrier(
+    std::optional<uint32_t> driverId,
+    Split& split) {
+  if (!driverId.has_value()) {
+    barrierSplits_.clear();
+    return false;
+  }
+  // Delivers a barrier exactly once for each driver from the same plan node.
+  auto it = barrierSplits_.find(*driverId);
+  if (it == barrierSplits_.end()) {
+    return false;
+  }
+  split = it->second;
+  barrierSplits_.erase(it);
+  return true;
+}
+
 } // namespace facebook::velox::exec
diff --git a/velox/exec/TaskStructs.h b/velox/exec/TaskStructs.h
index ba99890d3a0..59c8f0912b6 100644
--- a/velox/exec/TaskStructs.h
+++ b/velox/exec/TaskStructs.h
@@ -88,15 +88,29 @@ class SplitsStore {
   ///
   /// `promises` should be set by caller (potentially outside a lock), to notify
   /// any waiters on the splits.
-  virtual void requestBarrier(std::vector<ContinuePromise>& promises) = 0;
+  virtual void requestBarrier(
+      uint32_t numDrivers,
+      std::vector<ContinuePromise>& promises) = 0;
 
-  /// Return true when split is set or there is no more splits; false when
+  /// Returns the next split to process.
+  ///
+  /// @param driverId The driver id requesting the split. If set, a barrier
+  /// split will be delivered exactly once for each driver. If not set, all
+  /// barrier splits are cleared and no barrier split is returned. This is
+  /// used when cleaning up remaining remote splits during task termination.
+  /// @param maxPreloadSplits Maximum number of splits to preload.
+  /// @param preload Function to preload connector splits.
+  /// @param split Output parameter for the next split.
+  /// @param future Output parameter for the future to wait on if no split is
+  /// available.
+  /// @return true if a split is set or there are no more splits; false if the
   /// caller should retry when the future is fulfilled.
   virtual bool nextSplit(
-      Split& split,
-      ContinueFuture& future,
+      std::optional<uint32_t> driverId,
       int maxPreloadSplits,
-      const ConnectorSplitPreloadFunc& preload) = 0;
+      const ConnectorSplitPreloadFunc& preload,
+      Split& split,
+      ContinueFuture& future) = 0;
 
   /// Return whether all splits has been consumed and there will be no more
   /// splits.
@@ -139,6 +153,8 @@ class SplitsStore {
 
   ContinueFuture makeFuture();
 
+  bool tryGetBarrier(std::optional<uint32_t> driverId, Split& split);
+
   const bool remoteSplit_;
   TaskStats* taskStats_{};
   folly::F14FastSet<std::shared_ptr<connector::ConnectorSplit>>*
@@ -146,6 +162,8 @@ class SplitsStore {
 
   // Arrived (added), but not distributed yet, splits.
   std::deque<Split> splits_;
+  // The map from driver id to barrier splits.
+  std::unordered_map<uint32_t, Split> barrierSplits_;
 
   // Signal, that no more splits will arrive.
   bool noMoreSplits_{false};
diff --git a/velox/exec/TaskTraceReader.cpp b/velox/exec/TaskTraceReader.cpp
index 59647bd5305..9cf56807a9f 100644
--- a/velox/exec/TaskTraceReader.cpp
+++ b/velox/exec/TaskTraceReader.cpp
@@ -18,8 +18,8 @@
 
 #include "velox/common/file/FileSystems.h"
 #include "velox/core/PlanNode.h"
-#include "velox/exec/Trace.h"
-#include "velox/exec/TraceUtil.h"
+#include "velox/exec/trace/Trace.h"
+#include "velox/exec/trace/TraceUtil.h"
 
 namespace facebook::velox::exec::trace {
 
@@ -31,9 +31,10 @@ TaskTraceMetadataReader::TaskTraceMetadataReader(
       traceFilePath_(getTaskTraceMetaFilePath(traceDir_)),
       pool_(pool),
       metadataObj_(getTaskMetadata(traceFilePath_, fs_)),
-      tracePlanNode_(ISerializable::deserialize<core::PlanNode>(
-          metadataObj_[TraceTraits::kPlanNodeKey],
-          pool_)) {}
+      tracePlanNode_(
+          ISerializable::deserialize<core::PlanNode>(
+              metadataObj_[TraceTraits::kPlanNodeKey],
+              pool_)) {}
 
 std::unordered_map<std::string, std::string>
 TaskTraceMetadataReader::queryConfigs() const {
@@ -66,17 +67,24 @@ core::PlanNodePtr TaskTraceMetadataReader::queryPlan() const {
 }
 
 std::string TaskTraceMetadataReader::nodeName(const std::string& nodeId) const {
-  const auto* traceNode = core::PlanNode::findFirstNode(
-      tracePlanNode_.get(),
-      [&nodeId](const core::PlanNode* node) { return node->id() == nodeId; });
+  LOG(ERROR) << "node id " << nodeId << " trace plan node "
+             << tracePlanNode_->toString(true, true);
+  const auto* traceNode =
+      core::PlanNode::findNodeById(tracePlanNode_.get(), nodeId);
+  VELOX_CHECK_NOT_NULL(
+      traceNode, "trace node id {} not found in the trace plan", nodeId);
   return std::string(traceNode->name());
 }
 
 std::optional<std::string> TaskTraceMetadataReader::connectorId(
     const std::string& nodeId) const {
-  const auto* traceNode = core::PlanNode::findFirstNode(
-      tracePlanNode_.get(),
-      [&nodeId](const core::PlanNode* node) { return node->id() == nodeId; });
+  const auto* traceNode =
+      core::PlanNode::findNodeById(tracePlanNode_.get(), nodeId);
+  VELOX_CHECK_NOT_NULL(
+      traceNode,
+      "trace node id {} not found in the trace plan: {}",
+      nodeId,
+      tracePlanNode_->toString(true, true));
 
   if (const auto* indexLookupJoinNode =
           dynamic_cast<const core::IndexLookupJoinNode*>(traceNode)) {
@@ -84,14 +92,16 @@ std::optional<std::string> TaskTraceMetadataReader::connectorId(
         indexLookupJoinNode->lookupSource()->tableHandle()->connectorId();
     VELOX_CHECK(!indexLookupConnectorId.empty());
     return indexLookupConnectorId;
-  } else if (
-      const auto* tableScanNode =
+  }
+
+  if (const auto* tableScanNode =
           dynamic_cast<const core::TableScanNode*>(traceNode)) {
     VELOX_CHECK_NOT_NULL(tableScanNode);
     const auto connectorId = tableScanNode->tableHandle()->connectorId();
     VELOX_CHECK(!connectorId.empty());
     return connectorId;
   }
+
   return std::nullopt;
 }
 } // namespace facebook::velox::exec::trace
diff --git a/velox/exec/TaskTraceWriter.cpp b/velox/exec/TaskTraceWriter.cpp
index 46d28b66a41..218832c4e1e 100644
--- a/velox/exec/TaskTraceWriter.cpp
+++ b/velox/exec/TaskTraceWriter.cpp
@@ -18,15 +18,17 @@
 #include "velox/common/file/File.h"
 #include "velox/core/PlanNode.h"
 #include "velox/core/QueryCtx.h"
-#include "velox/exec/Trace.h"
-#include "velox/exec/TraceUtil.h"
+#include "velox/exec/trace/Trace.h"
+#include "velox/exec/trace/TraceUtil.h"
 
 namespace facebook::velox::exec::trace {
 
 TaskTraceMetadataWriter::TaskTraceMetadataWriter(
     std::string traceDir,
+    std::string traceNodeId,
     memory::MemoryPool* /* pool */)
     : traceDir_(std::move(traceDir)),
+      traceNodeId_(std::move(traceNodeId)),
       fs_(filesystems::getFileSystem(traceDir_, nullptr)),
       traceFilePath_(getTaskTraceMetaFilePath(traceDir_)) {
   VELOX_CHECK_NOT_NULL(fs_);
@@ -34,19 +36,22 @@ TaskTraceMetadataWriter::TaskTraceMetadataWriter(
 }
 
 void TaskTraceMetadataWriter::write(
-    const std::shared_ptr<core::QueryCtx>& queryCtx,
-    const core::PlanNodePtr& planNode) {
+    const core::QueryCtx& queryCtx,
+    const core::PlanNode& planNode) {
   VELOX_CHECK(!finished_, "Query metadata can only be written once");
   finished_ = true;
+
+  auto traceNode = trace::getTraceNode(planNode, traceNodeId_);
+
   folly::dynamic queryConfigObj = folly::dynamic::object;
-  const auto configValues = queryCtx->queryConfig().rawConfigsCopy();
+  const auto configValues = queryCtx.queryConfig().rawConfigsCopy();
   for (const auto& [key, value] : configValues) {
     queryConfigObj[key] = value;
   }
 
   folly::dynamic connectorPropertiesObj = folly::dynamic::object;
   for (const auto& [connectorId, configs] :
-       queryCtx->connectorSessionProperties()) {
+       queryCtx.connectorSessionProperties()) {
     folly::dynamic obj = folly::dynamic::object;
     for (const auto& [key, value] : configs->rawConfigsCopy()) {
       obj[key] = value;
@@ -57,7 +62,7 @@ void TaskTraceMetadataWriter::write(
   folly::dynamic metaObj = folly::dynamic::object;
   metaObj[TraceTraits::kQueryConfigKey] = queryConfigObj;
   metaObj[TraceTraits::kConnectorPropertiesKey] = connectorPropertiesObj;
-  metaObj[TraceTraits::kPlanNodeKey] = planNode->serialize();
+  metaObj[TraceTraits::kPlanNodeKey] = traceNode->serialize();
 
   const auto metaStr = folly::toJson(metaObj);
   const auto file = fs_->openFileForWrite(traceFilePath_);
diff --git a/velox/exec/TaskTraceWriter.h b/velox/exec/TaskTraceWriter.h
index a61cfb719eb..b10d6952058 100644
--- a/velox/exec/TaskTraceWriter.h
+++ b/velox/exec/TaskTraceWriter.h
@@ -19,18 +19,23 @@
 #include "velox/common/file/FileSystems.h"
 #include "velox/core/PlanNode.h"
 #include "velox/core/QueryCtx.h"
+#include "velox/exec/trace/TraceWriter.h"
 
 namespace facebook::velox::exec::trace {
-class TaskTraceMetadataWriter {
+
+class TaskTraceMetadataWriter : public TraceMetadataWriter {
  public:
-  TaskTraceMetadataWriter(std::string traceDir, memory::MemoryPool* pool);
+  TaskTraceMetadataWriter(
+      std::string traceDir,
+      std::string traceNodeId,
+      memory::MemoryPool* pool);
 
-  void write(
-      const std::shared_ptr<core::QueryCtx>& queryCtx,
-      const core::PlanNodePtr& planNode);
+  void write(const core::QueryCtx& queryCtx, const core::PlanNode& planNode)
+      override;
 
  private:
   const std::string traceDir_;
+  const std::string traceNodeId_;
   const std::shared_ptr<filesystems::FileSystem> fs_;
   const std::string traceFilePath_;
   bool finished_{false};
diff --git a/velox/exec/TopN.cpp b/velox/exec/TopN.cpp
index 1c7af492477..961661d6801 100644
--- a/velox/exec/TopN.cpp
+++ b/velox/exec/TopN.cpp
@@ -16,6 +16,7 @@
 #include <folly/container/F14Map.h>
 
 #include "velox/exec/ContainerRowSerde.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/TopN.h"
 #include "velox/vector/FlatVector.h"
 
@@ -29,7 +30,7 @@ TopN::TopN(
           topNNode->outputType(),
           operatorId,
           topNNode->id(),
-          "TopN"),
+          OperatorType::kTopN),
       count_(topNNode->count()),
       data_(std::make_unique<RowContainer>(outputType_->children(), pool())),
       comparator_(
diff --git a/velox/exec/TopNRowNumber.cpp b/velox/exec/TopNRowNumber.cpp
index 5bd614ffa1e..b26b8519fb0 100644
--- a/velox/exec/TopNRowNumber.cpp
+++ b/velox/exec/TopNRowNumber.cpp
@@ -15,10 +15,34 @@
  */
 #include "velox/exec/TopNRowNumber.h"
 
+#include "velox/exec/OperatorType.h"
+
 namespace facebook::velox::exec {
 
 namespace {
 
+#define RANK_FUNCTION_DISPATCH(TEMPLATE_FUNC, functionKind, ...)             \
+  [&]() {                                                                    \
+    switch (functionKind) {                                                  \
+      case core::TopNRowNumberNode::RankFunction::kRowNumber: {              \
+        return TEMPLATE_FUNC<                                                \
+            core::TopNRowNumberNode::RankFunction::kRowNumber>(__VA_ARGS__); \
+      }                                                                      \
+      case core::TopNRowNumberNode::RankFunction::kRank: {                   \
+        return TEMPLATE_FUNC<core::TopNRowNumberNode::RankFunction::kRank>(  \
+            __VA_ARGS__);                                                    \
+      }                                                                      \
+      case core::TopNRowNumberNode::RankFunction::kDenseRank: {              \
+        return TEMPLATE_FUNC<                                                \
+            core::TopNRowNumberNode::RankFunction::kDenseRank>(__VA_ARGS__); \
+      }                                                                      \
+      default:                                                               \
+        VELOX_FAIL(                                                          \
+            "not a rank function kind: {}",                                  \
+            core::TopNRowNumberNode::rankFunctionName(functionKind));        \
+    }                                                                        \
+  }()
+
 std::vector<column_index_t> reorderInputChannels(
     const RowTypePtr& inputType,
     const std::vector<core::FieldAccessTypedExprPtr>& partitionKeys,
@@ -109,13 +133,17 @@ TopNRowNumber::TopNRowNumber(
           node->outputType(),
           operatorId,
           node->id(),
-          "TopNRowNumber",
+          OperatorType::kTopNRowNumber,
           node->canSpill(driverCtx->queryConfig())
-              ? driverCtx->makeSpillConfig(operatorId)
+              ? driverCtx->makeSpillConfig(
+                    operatorId,
+                    OperatorType::kTopNRowNumber)
               : std::nullopt),
+      rankFunction_(node->rankFunction()),
       limit_{node->limit()},
       generateRowNumber_{node->generateRowNumber()},
       numPartitionKeys_{node->partitionKeys().size()},
+      numSortingKeys_{node->sortingKeys().size()},
       inputChannels_{reorderInputChannels(
           node->inputType(),
           node->partitionKeys(),
@@ -127,22 +155,20 @@ TopNRowNumber::TopNRowNumber(
           driverCtx->queryConfig().abandonPartialTopNRowNumberMinRows()),
       abandonPartialMinPct_(
           driverCtx->queryConfig().abandonPartialTopNRowNumberMinPct()),
-      data_(std::make_unique<RowContainer>(
-          slice(inputType_->children(), 0, spillCompareFlags_.size()),
-          slice(
-              inputType_->children(),
-              spillCompareFlags_.size(),
-              inputType_->size()),
-          pool())),
+      data_(
+          std::make_unique<RowContainer>(
+              slice(inputType_->children(), 0, spillCompareFlags_.size()),
+              slice(
+                  inputType_->children(),
+                  spillCompareFlags_.size(),
+                  inputType_->size()),
+              pool())),
       comparator_(
           inputType_,
           node->sortingKeys(),
           node->sortingOrders(),
           data_.get()),
       decodedVectors_(inputType_->size()) {
-  VELOX_CHECK_EQ(
-      node->rankFunction(), core::TopNRowNumberNode::RankFunction::kRowNumber);
-
   const auto& keys = node->partitionKeys();
   const auto numKeys = keys.size();
 
@@ -163,6 +189,7 @@ TopNRowNumber::TopNRowNumber(
         false, // allowDuplicates
         false, // isJoinBuild
         false, // hasProbedFlag
+        false, // hasCountFlag
         0, // minTableSizeForParallelJoinBuild
         pool());
     partitionOffset_ = table_->rows()->columnAt(numKeys).offset();
@@ -203,7 +230,17 @@ void TopNRowNumber::addInput(RowVectorPtr input) {
     SelectivityVector rows(numInput);
     table_->prepareForGroupProbe(
         *lookup_, input, rows, BaseHashTable::kNoSpillInputStartPartitionBit);
-    table_->groupProbe(*lookup_, BaseHashTable::kNoSpillInputStartPartitionBit);
+    try {
+      table_->groupProbe(
+          *lookup_, BaseHashTable::kNoSpillInputStartPartitionBit);
+    } catch (...) {
+      // If groupProbe throws (e.g., due to OOM), we need to clean up the new
+      // groups that were inserted but not yet initialized by
+      // initializeNewPartitions(). Otherwise, close() will crash when trying to
+      // destroy uninitialized TopRows structures.
+      cleanupNewPartitions();
+      throw;
+    }
 
     // Initialize new partitions.
     initializeNewPartitions();
@@ -211,18 +248,23 @@ void TopNRowNumber::addInput(RowVectorPtr input) {
     // Process input rows. For each row, lookup the partition. If the highest
     // (top) rank in that partition is less than limit, add the new row.
     // Otherwise, check if row should replace an existing row or be discarded.
-    processInputRowLoop(numInput);
+    RANK_FUNCTION_DISPATCH(processInputRowLoop, rankFunction_, numInput);
 
+    // It is determined that the TopNRowNumber (as a partial) is not rejecting
+    // enough input rows to make the duplicate detection worthwhile. Hence,
+    // abandon the processing at this partial TopN and let the final TopN do
+    // the processing.
     if (abandonPartialEarly()) {
       abandonedPartial_ = true;
-      addRuntimeStat("abandonedPartial", RuntimeCounter(1));
+      addRuntimeStat(
+          std::string(TopNRowNumber::kAbandonedPartial), RuntimeCounter(1));
 
       updateEstimatedOutputRowSize();
       outputBatchSize_ = outputBatchRows(estimatedOutputRowSize_);
       outputRows_.resize(outputBatchSize_);
     }
   } else {
-    processInputRowLoop(numInput);
+    RANK_FUNCTION_DISPATCH(processInputRowLoop, rankFunction_, numInput);
   }
 }
 
@@ -247,7 +289,60 @@ void TopNRowNumber::initializeNewPartitions() {
   }
 }
 
-char* TopNRowNumber::processRowWithinLimit(
+void TopNRowNumber::cleanupNewPartitions() {
+  std::vector<char*> newRows(lookup_->newGroups.size());
+  for (auto i = 0; i < lookup_->newGroups.size(); ++i) {
+    newRows[i] = lookup_->hits[lookup_->newGroups[i]];
+  }
+  table_->erase(folly::Range(newRows.data(), newRows.size()));
+  lookup_->newGroups.clear();
+}
+
+template <>
+char* TopNRowNumber::processRowWithinLimit<
+    core::TopNRowNumberNode::RankFunction::kRank>(
+    vector_size_t index,
+    TopRows& partition) {
+  // The topRanks queue is not filled yet.
+  auto& topRows = partition.rows;
+  if (topRows.empty()) {
+    partition.topRank = 1;
+  } else {
+    // Rank assigns all peer rows the same rank, but the rank increments by
+    // the number of peers when moving between peers. So when adding a new
+    // row:
+    // If row == top rank then top rank is unchanged.
+    // If row < top rank then top rank += 1.
+    // If row > top, then rank += number of peers of top rank.
+    auto* topRow = topRows.top();
+    auto result = comparator_.compare(decodedVectors_, index, topRow);
+    if (result < 0) {
+      partition.topRank += 1;
+    } else if (result > 0) {
+      partition.topRank += partition.numTopRankRows();
+    }
+  }
+  return data_->newRow();
+}
+
+template <>
+char* TopNRowNumber::processRowWithinLimit<
+    core::TopNRowNumberNode::RankFunction::kDenseRank>(
+    vector_size_t index,
+    TopRows& partition) {
+  // The topRanks queue is not filled yet.
+  // dense_rank will add this row to its partition. But the top rank is
+  // incremented only if the new row is not a peer of any other existing
+  // row in the partition queue.
+  if (!partition.isDuplicate(decodedVectors_, index)) {
+    partition.topRank++;
+  }
+  return data_->newRow();
+}
+
+template <>
+char* TopNRowNumber::processRowWithinLimit<
+    core::TopNRowNumberNode::RankFunction::kRowNumber>(
     vector_size_t /*index*/,
     TopRows& partition) {
   // row_number accumulates the new row in the partition, and the top rank is
@@ -256,7 +351,62 @@ char* TopNRowNumber::processRowWithinLimit(
   return data_->newRow();
 }
 
-char* TopNRowNumber::processRowExceedingLimit(
+template <>
+char* TopNRowNumber::processRowExceedingLimit<
+    core::TopNRowNumberNode::RankFunction::kRank>(
+    vector_size_t index,
+    TopRows& partition) {
+  auto& topRows = partition.rows;
+  // The new row < top rank
+  // For rank, the new row gets assigned its rank as per its position in the
+  // queue. But the ranks of all subsequent rows increment by 1.
+  // So we can remove the rows at the top rank as its rank > limit now.
+  char* topRow = partition.removeTopRankRows();
+  char* newRow = data_->initializeRow(topRow, /*reuse=*/true);
+  if (topRows.empty()) {
+    partition.topRank = 1;
+  } else {
+    // The new top rank value depends on the number of peers of the top ranking
+    // row. If the current row also has the same value as the new top ranking
+    // row then it has to be counted as a peer as well.
+    auto numNewTopRankRows = partition.numTopRankRows();
+    topRow = topRows.top();
+    if (comparator_.compare(decodedVectors_, index, topRow) == 0) {
+      partition.topRank = topRows.size() - numNewTopRankRows + 1;
+    } else {
+      partition.topRank = topRows.size() - numNewTopRankRows + 2;
+    }
+  }
+  return newRow;
+}
+
+template <>
+char* TopNRowNumber::processRowExceedingLimit<
+    core::TopNRowNumberNode::RankFunction::kDenseRank>(
+    vector_size_t index,
+    TopRows& partition) {
+  char* newRow = nullptr;
+  // The new row < top rank
+  // For dense_rank:
+  // i) If the row is a peer of an existing row in the queue, then it
+  // has the same rank as it. The ranks of other rows are unchanged. So its
+  // only added to the queue.
+  // ii) If the row is a distinct new value in the queue, then it is assigned
+  // a rank as per its position, and the ranks of all subsequent rows += 1.
+  // So the current top rank rows can be removed from the queue as their new
+  // rank > limit.
+  if (partition.isDuplicate(decodedVectors_, index)) {
+    newRow = data_->newRow();
+  } else {
+    char* topRow = partition.removeTopRankRows();
+    newRow = data_->initializeRow(topRow, /*reuse=*/true);
+  }
+  return newRow;
+}
+
+template <>
+char* TopNRowNumber::processRowExceedingLimit<
+    core::TopNRowNumberNode::RankFunction::kRowNumber>(
     vector_size_t /*index*/,
     TopRows& partition) {
   // The new row has rank < highest (aka top) rank at 'limit' function value.
@@ -269,13 +419,16 @@ char* TopNRowNumber::processRowExceedingLimit(
   return data_->initializeRow(topRow, true /* reuse */);
 }
 
+template <core::TopNRowNumberNode::RankFunction TRank>
 void TopNRowNumber::processInputRow(vector_size_t index, TopRows& partition) {
   auto& topRows = partition.rows;
 
   char* newRow = nullptr;
   if (partition.topRank < limit_) {
-    newRow = processRowWithinLimit(index, partition);
+    newRow = processRowWithinLimit<TRank>(index, partition);
   } else {
+    // The partition has now accumulated >= limit rows. So the new rows can be
+    // rejected or replace existing rows based on the order_by values.
     char* topRow = topRows.top();
 
     const auto result = comparator_.compare(decodedVectors_, index, topRow);
@@ -284,14 +437,18 @@ void TopNRowNumber::processInputRow(vector_size_t index, TopRows& partition) {
       return;
     }
 
-    if (result == 0) {
-      // The new row has the same value as the top rank row. row_number rejects
-      // such rows.
-      return;
+    // This row has the same value as the top rank row. row_number rejects
+    // such rows, but are added to the queue for rank and dense_rank. The top
+    // rank remains unchanged.
+    else if (result == 0) {
+      if (rankFunction_ == core::TopNRowNumberNode::RankFunction::kRowNumber) {
+        return;
+      }
+      newRow = data_->newRow();
     }
 
-    if (result < 0) {
-      newRow = processRowExceedingLimit(index, partition);
+    else if (result < 0) {
+      newRow = processRowExceedingLimit<TRank>(index, partition);
     }
   }
 
@@ -302,14 +459,15 @@ void TopNRowNumber::processInputRow(vector_size_t index, TopRows& partition) {
   topRows.push(newRow);
 }
 
+template <core::TopNRowNumberNode::RankFunction TRank>
 void TopNRowNumber::processInputRowLoop(vector_size_t numInput) {
   if (table_) {
     for (auto i = 0; i < numInput; ++i) {
-      processInputRow(i, partitionAt(lookup_->hits[i]));
+      processInputRow<TRank>(i, partitionAt(lookup_->hits[i]));
     }
   } else {
     for (auto i = 0; i < numInput; ++i) {
-      processInputRow(i, *singlePartition_);
+      processInputRow<TRank>(i, *singlePartition_);
     }
   }
 }
@@ -330,7 +488,7 @@ void TopNRowNumber::noMoreInput() {
     spiller_->finishSpill(spillPartitionSet);
     VELOX_CHECK_EQ(spillPartitionSet.size(), 1);
     merge_ = spillPartitionSet.begin()->second->createOrderedReader(
-        spillConfig_->readBufferSize, pool(), spillStats_.get());
+        *spillConfig_, pool(), spillStats_.get());
   } else {
     outputRows_.resize(outputBatchSize_);
   }
@@ -355,10 +513,46 @@ void TopNRowNumber::updateEstimatedOutputRowSize() {
   }
 }
 
+// This function handles a special case when determining the starting
+// rank value for the 'rank' function.
+// If there are many peer rows for the highest rank, then topRank could
+// oscillate between the two cases of topRank < limit and topRank > limit
+// as rows are added
+// E.g. If the input rows are 0, 0, 0, 5, 0, 0, 6 and we want rank <= 5, then
+// at 0, 0, 0, 5 :
+// topRows.pq - 0, 0, 0, 5 topRank -> 4
+// 0 is added.
+// topRows.pq - 0, 0, 0, 0, 5 topRank -> 5
+// topRank = limit now.
+// So when the next 0 is added, the last 5 is popped from TopRows and 0 is added
+// topRows.pq - 0, 0, 0, 0, 0, topRank -> 1
+// This makes topRank < 5 and so when 6 comes by, 6 is pushed
+// topRows.pq - 0, 0, 0, 0, 0, 6 topRank -> 6
+// So when doing getOutput, we need to adjust this case.
+// Since topRank > limit, then the highest rank is popped and the
+// topRank is adjusted as length(pq) - number_of_duplicates_of_new_top_row + 1.
+vector_size_t TopNRowNumber::fixTopRank(TopRows& partition) {
+  if (rankFunction_ == core::TopNRowNumberNode::RankFunction::kRank) {
+    if (partition.topRank > limit_) {
+      partition.removeTopRankRows();
+      auto numNewTopRankRows = partition.numTopRankRows();
+      partition.topRank = partition.rows.size() - numNewTopRankRows + 1;
+    }
+  }
+
+  return partition.topRank;
+}
+
 TopNRowNumber::TopRows* TopNRowNumber::nextPartition() {
+  auto setNextRankAndPeer = [&](TopRows& partition) {
+    nextRank_ = fixTopRank(partition);
+    numPeers_ = 1;
+  };
+
   if (!table_) {
     if (!outputPartitionNumber_) {
       outputPartitionNumber_ = 0;
+      setNextRankAndPeer(*singlePartition_);
       return singlePartition_.get();
     }
     return nullptr;
@@ -374,7 +568,6 @@ TopNRowNumber::TopRows* TopNRowNumber::nextPartition() {
       // No more partitions.
       return nullptr;
     }
-
     outputPartitionNumber_ = 0;
   } else {
     ++outputPartitionNumber_.value();
@@ -384,24 +577,56 @@ TopNRowNumber::TopRows* TopNRowNumber::nextPartition() {
     }
   }
 
-  return &partitionAt(partitions_[outputPartitionNumber_.value()]);
+  auto partition = &partitionAt(partitions_[outputPartitionNumber_.value()]);
+  setNextRankAndPeer(*partition);
+  return partition;
 }
 
+template <core::TopNRowNumberNode::RankFunction TRank>
+void TopNRowNumber::computeNextRankInMemory(
+    TopRows& partition,
+    vector_size_t outputIndex) {
+  if constexpr (TRank == core::TopNRowNumberNode::RankFunction::kRowNumber) {
+    nextRank_ -= 1;
+    return;
+  }
+
+  // This is the logic for rank() and dense_rank().
+  // If the next row is a peer of the current one, then the rank remains the
+  // same.
+  if (comparator_.compare(outputRows_[outputIndex], partition.rows.top()) ==
+      0) {
+    return;
+  }
+
+  // The new row is not a peer of the current one. So dense_rank drops the
+  // rank by 1, but rank drops by the number of peers of the new top
+  // row (new rank) in TopRows queue.
+  if constexpr (TRank == core::TopNRowNumberNode::RankFunction::kDenseRank) {
+    nextRank_ -= 1;
+  } else {
+    nextRank_ -= partition.numTopRankRows();
+  }
+}
+
+template <core::TopNRowNumberNode::RankFunction TRank>
 void TopNRowNumber::appendPartitionRows(
     TopRows& partition,
     vector_size_t numRows,
     vector_size_t outputOffset,
-    FlatVector<int64_t>* rowNumbers) {
+    FlatVector<int64_t>* rankValues) {
   // The partition.rows priority queue pops rows in order of reverse
-  // row numbers.
-  auto rowNumber = partition.rows.size();
+  // ranks. Output rows based on nextRank_ and update it with each row.
   for (auto i = 0; i < numRows; ++i) {
-    const auto index = outputOffset + i;
-    if (rowNumbers) {
-      rowNumbers->set(index, rowNumber--);
+    auto index = outputOffset + i;
+    if (rankValues) {
+      rankValues->set(index, nextRank_);
     }
     outputRows_[index] = partition.rows.top();
     partition.rows.pop();
+    if (!partition.rows.empty()) {
+      computeNextRankInMemory<TRank>(partition, index);
+    }
   }
 }
 
@@ -417,7 +642,7 @@ RowVectorPtr TopNRowNumber::getOutput() {
       return output;
     }
 
-    // We may have input accumulated in 'data_'.
+    // There could be older rows accumulated in 'data_'.
     if (data_->numRows() > 0) {
       return getOutputFromMemory();
     }
@@ -426,6 +651,7 @@ RowVectorPtr TopNRowNumber::getOutput() {
       finished_ = true;
     }
 
+    // There is no data to return at this moment.
     return nullptr;
   }
 
@@ -433,9 +659,11 @@ RowVectorPtr TopNRowNumber::getOutput() {
     return nullptr;
   }
 
+  // All the input data is received, so the operator can start producing
+  // output.
   RowVectorPtr output;
   if (merge_ != nullptr) {
-    output = getOutputFromSpill();
+    output = RANK_FUNCTION_DISPATCH(getOutputFromSpill, rankFunction_);
   } else {
     output = getOutputFromMemory();
   }
@@ -472,20 +700,27 @@ RowVectorPtr TopNRowNumber::getOutputFromMemory() {
 
     const auto numOutputRowsLeft = outputBatchSize_ - offset;
     if (outputPartition_->rows.size() > numOutputRowsLeft) {
-      // Only a partial partition can be output in this getOutput() call.
       // Output as many rows as possible.
-      // NOTE: the partial output partition erases the yielded output rows
-      // and next getOutput() call starts with the remaining rows.
-      appendPartitionRows(
-          *outputPartition_, numOutputRowsLeft, offset, rowNumbers);
+      RANK_FUNCTION_DISPATCH(
+          appendPartitionRows,
+          rankFunction_,
+          *outputPartition_,
+          numOutputRowsLeft,
+          offset,
+          rowNumbers);
       offset += numOutputRowsLeft;
       break;
     }
 
     // Add all partition rows.
-    auto numPartitionRows = outputPartition_->rows.size();
-    appendPartitionRows(
-        *outputPartition_, numPartitionRows, offset, rowNumbers);
+    const auto numPartitionRows = outputPartition_->rows.size();
+    RANK_FUNCTION_DISPATCH(
+        appendPartitionRows,
+        rankFunction_,
+        *outputPartition_,
+        numPartitionRows,
+        offset,
+        rowNumbers);
     offset += numPartitionRows;
     outputPartition_ = nullptr;
   }
@@ -512,13 +747,15 @@ RowVectorPtr TopNRowNumber::getOutputFromMemory() {
   return output;
 }
 
-bool TopNRowNumber::isNewPartition(
+bool TopNRowNumber::compareSpillRowColumns(
     const RowVectorPtr& output,
     vector_size_t index,
-    SpillMergeStream* next) {
+    const SpillMergeStream* next,
+    vector_size_t startColumn,
+    vector_size_t endColumn) {
   VELOX_CHECK_GT(index, 0);
 
-  for (auto i = 0; i < numPartitionKeys_; ++i) {
+  for (auto i = startColumn; i < endColumn; ++i) {
     if (!output->childAt(inputChannels_[i])
              ->equalValueAt(
                  next->current().childAt(i).get(),
@@ -530,22 +767,79 @@ bool TopNRowNumber::isNewPartition(
   return false;
 }
 
-void TopNRowNumber::setupNextOutput(
+// Compares the partition keys for new partitions.
+bool TopNRowNumber::isNewPartition(
     const RowVectorPtr& output,
-    int32_t rowNumber) {
-  auto* lookAhead = merge_->next();
-  if (lookAhead == nullptr) {
-    nextRowNumber_ = 0;
+    vector_size_t index,
+    const SpillMergeStream* next) {
+  return compareSpillRowColumns(output, index, next, 0, numPartitionKeys_);
+}
+
+// Compares the sorting keys for determining peers.
+bool TopNRowNumber::isNewRank(
+    const RowVectorPtr& output,
+    vector_size_t index,
+    const SpillMergeStream* next) {
+  return compareSpillRowColumns(
+      output,
+      index,
+      next,
+      numPartitionKeys_,
+      numPartitionKeys_ + numSortingKeys_);
+}
+
+template <core::TopNRowNumberNode::RankFunction TRank>
+void TopNRowNumber::computeNextRankInSpill(
+    const RowVectorPtr& output,
+    vector_size_t index,
+    const SpillMergeStream* next) {
+  if (isNewPartition(output, index, next)) {
+    nextRank_ = 1;
+    numPeers_ = 1;
+    return;
+  }
+
+  if constexpr (TRank == core::TopNRowNumberNode::RankFunction::kRowNumber) {
+    nextRank_ += 1;
     return;
   }
 
-  if (isNewPartition(output, output->size(), lookAhead)) {
-    nextRowNumber_ = 0;
+  // The function is either rank or dense_rank.
+  // This row belongs to the same partition as the previous row. However,
+  // it should be determined if it is a peer row as well. If its a peer,
+  // then increase numPeers_ but the rank remains unchanged.
+  if (!isNewRank(output, index, next)) {
+    numPeers_ += 1;
     return;
   }
 
-  nextRowNumber_ = rowNumber;
-  if (nextRowNumber_ < limit_) {
+  // The row is not a peer, so increment the rank and peers accordingly.
+  if constexpr (TRank == core::TopNRowNumberNode::RankFunction::kDenseRank) {
+    nextRank_ += 1;
+    numPeers_ = 1;
+    return;
+  }
+
+  // Rank function increments by number of peers.
+  nextRank_ += numPeers_;
+  numPeers_ = 1;
+}
+
+template <core::TopNRowNumberNode::RankFunction TRank>
+void TopNRowNumber::setupNextOutput(const RowVectorPtr& output) {
+  auto resetNextRankAndPeer = [this]() {
+    nextRank_ = 1;
+    numPeers_ = 1;
+  };
+
+  auto* lookAhead = merge_->next();
+  if (lookAhead == nullptr) {
+    resetNextRankAndPeer();
+    return;
+  }
+
+  computeNextRankInSpill<TRank>(output, output->size(), lookAhead);
+  if (nextRank_ <= limit_) {
     return;
   }
 
@@ -553,16 +847,17 @@ void TopNRowNumber::setupNextOutput(
   lookAhead->pop();
   while (auto* next = merge_->next()) {
     if (isNewPartition(output, output->size(), next)) {
-      nextRowNumber_ = 0;
+      resetNextRankAndPeer();
       return;
     }
     next->pop();
   }
 
   // This partition is the last partition.
-  nextRowNumber_ = 0;
+  resetNextRankAndPeer();
 }
 
+template <core::TopNRowNumberNode::RankFunction TRank>
 RowVectorPtr TopNRowNumber::getOutputFromSpill() {
   VELOX_CHECK_NOT_NULL(merge_);
 
@@ -570,37 +865,32 @@ RowVectorPtr TopNRowNumber::getOutputFromSpill() {
   // All rows from the same partition will appear together.
   // We'll identify partition boundaries by comparing partition keys of the
   // current row with the previous row. When new partition starts, we'll reset
-  // row number to zero. Once row number reaches the 'limit_', we'll start
+  // nextRank_ and numPeers_. Once rank reaches the 'limit_', we'll start
   // dropping rows until the next partition starts.
   // We'll emit output every time we accumulate 'outputBatchSize_' rows.
-
   auto output =
       BaseVector::create<RowVector>(outputType_, outputBatchSize_, pool());
-  FlatVector<int64_t>* rowNumbers = nullptr;
+  FlatVector<int64_t>* rankValues = nullptr;
   if (generateRowNumber_) {
-    rowNumbers = output->children().back()->as<FlatVector<int64_t>>();
+    rankValues = output->children().back()->as<FlatVector<int64_t>>();
   }
 
   // Index of the next row to append to output.
   vector_size_t index = 0;
-
-  // Row number of the next row in the current partition.
-  vector_size_t rowNumber = nextRowNumber_;
-  VELOX_CHECK_LT(rowNumber, limit_);
+  VELOX_CHECK_LE(nextRank_, limit_);
   for (;;) {
     auto next = merge_->next();
     if (next == nullptr) {
       break;
     }
 
-    // Check if this row comes from a new partition.
-    if (index > 0 && isNewPartition(output, index, next)) {
-      rowNumber = 0;
+    if (index > 0) {
+      computeNextRankInSpill<TRank>(output, index, next);
     }
 
     // Copy this row to the output buffer if this partition has
     // < limit_ rows output.
-    if (rowNumber < limit_) {
+    if (nextRank_ <= limit_) {
       for (auto i = 0; i < inputChannels_.size(); ++i) {
         output->childAt(inputChannels_[i])
             ->copy(
@@ -609,12 +899,11 @@ RowVectorPtr TopNRowNumber::getOutputFromSpill() {
                 next->currentIndex(),
                 1);
       }
-      if (rowNumbers) {
-        // Row numbers start with 1.
-        rowNumbers->set(index, rowNumber + 1);
+
+      if (rankValues) {
+        rankValues->set(index, nextRank_);
       }
       ++index;
-      ++rowNumber;
     }
 
     // Pop this row from the spill.
@@ -625,8 +914,8 @@ RowVectorPtr TopNRowNumber::getOutputFromSpill() {
       // Prepare the next batch :
       // i) If 'limit_' is reached for this partition, then skip the rows
       // until the next partition.
-      // ii) If the next row is from a new partition, then reset rowNumber_.
-      setupNextOutput(output, rowNumber);
+      // ii) If the next row is from a new partition, then reset nextRank_.
+      setupNextOutput<TRank>(output);
       return output;
     }
   }
@@ -692,8 +981,11 @@ void TopNRowNumber::reclaim(
     // TODO Add support for spilling after noMoreInput().
     LOG(WARNING)
         << "Can't reclaim from topNRowNumber operator which has started producing output: "
-        << pool()->name() << ", usage: " << succinctBytes(pool()->usedBytes())
-        << ", reservation: " << succinctBytes(pool()->reservedBytes());
+        << pool()->name() << ", root pool: " << pool()->root()->name()
+        << ", used: " << succinctBytes(pool()->usedBytes())
+        << ", reservation: " << succinctBytes(pool()->reservedBytes())
+        << ", root pool reservation: "
+        << succinctBytes(pool()->root()->reservedBytes());
     return;
   }
 
@@ -741,14 +1033,15 @@ void TopNRowNumber::ensureInputFits(const RowVectorPtr& input) {
     if ((tableIncrementBytes == 0) && (freeRows > input->size()) &&
         (outOfLineBytes == 0 ||
          outOfLineFreeBytes >= outOfLineBytesPerRow * input->size())) {
-      // Enough free rows for input rows and enough variable length free space.
+      // Enough free rows for input rows and enough variable length free
+      // space.
       return;
     }
   }
 
-  // Check if we can increase reservation. The increment is the largest of twice
-  // the maximum increment from this input and 'spillableReservationGrowthPct_'
-  // of the current memory usage.
+  // Check if we can increase reservation. The increment is the largest of
+  // twice the maximum increment from this input and
+  // 'spillableReservationGrowthPct_' of the current memory usage.
   const auto targetIncrementBytes = std::max<int64_t>(
       incrementBytes * 2,
       currentUsage * spillConfig_->spillableReservationGrowthPct / 100);
@@ -761,8 +1054,11 @@ void TopNRowNumber::ensureInputFits(const RowVectorPtr& input) {
 
   LOG(WARNING) << "Failed to reserve " << succinctBytes(targetIncrementBytes)
                << " for memory pool " << pool()->name()
-               << ", usage: " << succinctBytes(pool()->usedBytes())
-               << ", reservation: " << succinctBytes(pool()->reservedBytes());
+               << ", root pool: " << pool()->root()->name()
+               << ", used: " << succinctBytes(pool()->usedBytes())
+               << ", reservation: " << succinctBytes(pool()->reservedBytes())
+               << ", root pool reservation: "
+               << succinctBytes(pool()->root()->reservedBytes());
 }
 
 void TopNRowNumber::spill() {
@@ -789,4 +1085,80 @@ void TopNRowNumber::setupSpiller() {
       &spillConfig_.value(),
       spillStats_.get());
 }
+
+// Using the underlying vector of the priority queue for the algorithms to
+// check duplicates and count the number of top rank rows. This makes the
+// algorithms O(n). There could be other approaches to make the
+// algorithms O(1), but would trade memory efficiency.
+namespace {
+template <class T, class S, class C>
+S& PriorityQueueVector(std::priority_queue<T, S, C>& q) {
+  struct PrivateQueue : private std::priority_queue<T, S, C> {
+    static S& Container(std::priority_queue<T, S, C>& q) {
+      return q.*&PrivateQueue::c;
+    }
+  };
+  return PrivateQueue::Container(q);
+}
+} // namespace
+
+char* TopNRowNumber::TopRows::removeTopRankRows() {
+  VELOX_CHECK(!rows.empty());
+
+  char* topRow = rows.top();
+  rows.pop();
+
+  while (!rows.empty()) {
+    char* newTopRow = rows.top();
+    if (rowComparator.compare(topRow, newTopRow) != 0) {
+      return topRow;
+    }
+    rows.pop();
+  }
+  return topRow;
+}
+
+vector_size_t TopNRowNumber::TopRows::numTopRankRows() {
+  VELOX_CHECK(!rows.empty());
+
+  tempTopRankRows.clear();
+  SCOPE_EXIT {
+    tempTopRankRows.clear();
+  };
+  auto popAndSaveTopRow = [&]() {
+    tempTopRankRows.push_back(rows.top());
+    rows.pop();
+  };
+
+  char* topRow = rows.top();
+  popAndSaveTopRow();
+  while (!rows.empty()) {
+    if (rowComparator.compare(topRow, rows.top()) == 0) {
+      popAndSaveTopRow();
+    } else {
+      break;
+    }
+  }
+
+  vector_size_t numTopRows = tempTopRankRows.size();
+  // Re-insert all rows with the top rank row.
+  for (char* row : tempTopRankRows) {
+    rows.push(row);
+  }
+  return numTopRows;
+}
+
+bool TopNRowNumber::TopRows::isDuplicate(
+    const std::vector<DecodedVector>& decodedVectors,
+    vector_size_t index) {
+  const std::vector<char*, StlAllocator<char*>> partitionRowsVector =
+      PriorityQueueVector(rows);
+  for (const char* row : partitionRowsVector) {
+    if (rowComparator.compare(decodedVectors, index, row) == 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
 } // namespace facebook::velox::exec
diff --git a/velox/exec/TopNRowNumber.h b/velox/exec/TopNRowNumber.h
index dc21f0f93c4..12daa35cce3 100644
--- a/velox/exec/TopNRowNumber.h
+++ b/velox/exec/TopNRowNumber.h
@@ -15,6 +15,8 @@
  */
 #pragma once
 
+#include <string_view>
+
 #include "velox/exec/HashTable.h"
 #include "velox/exec/Operator.h"
 #include "velox/exec/Spiller.h"
@@ -22,22 +24,63 @@
 namespace facebook::velox::exec {
 class TopNRowNumberSpiller;
 
-/// Partitions the input using specified partitioning keys, sorts rows within
-/// partitions using specified sorting keys, assigns row numbers and returns up
-/// to specified number of rows per partition.
+/// TopNRowNumber is an optimized version of a Window operator with a
+/// single row_number or rank or dense_rank window function followed by a
+/// rank <= N filter. N must be >= 0. If the TopNRowNumber has no partition
+/// keys, then all the rows belong to a single partition. However, the
+/// TopNRowNumber should have at least one sorting key specified.
+///
+/// TopNRowNumber is more efficient than a general Window operator as it does
+/// not store all rows of a partition. Instead, it only keeps the top N
+/// rows of the partition at any point.
+///
+/// The operator partitions the input using specified partitioning keys,
+/// and maintains a TopRows structure per partition in a HashTable. The TopRows
+/// maintains a priority queue of row pointers. The priority queue is
+/// kept ordered by sorting keys of the TopNRowNumber. The TopRows only retains
+/// rows whose ranks satisfy the filter condition (so rank <= N). N is also
+/// called the limit of the operator. To aid this filtering, the TopRows tracks
+/// the greatest rank seen for each partition.
+///
+/// The operator processes all input rows before beginning to output rows.
 ///
-/// It is allowed to not specify partitioning keys. In this case the whole input
-/// is treated as a single partition.
+/// For each input row, it retrieves the TopRows corresponding to the partition
+/// keys. The TopRows is first filled until it has N rows. Thereafter, new rows
+/// are compared with the top row in the TopRows priority queue.
+/// If the new rows order by values are less than (for ASC) or greater than
+/// (for DESC) so row rank <= topRank, then the row is added to TopRows.
+/// For each outcome, the greatest rank of the TopRows is updated as per the
+/// ranking function logic.
+/// For each function type, the rank maintenance logic is in:
+/// - processRowWithinLimit() function when the TopRows is filling the first
+///   N rows.
+/// - processRowExceedingLimit() function when the TopRows already has N rows.
 ///
-/// At least one sorting key must be specified.
+/// After processing all the input rows, the operator proceeds to output the
+/// rows. The rows might all be in memory or spilled to disk if memory
+/// reclamation was triggered during processing.
 ///
-/// The limit (maximum number of rows to return per partition) must be greater
-/// than zero.
+/// If the rows are in memory, then the operator iterates over each partition
+/// in the HashTable, and starts outputting rows from the partition. The
+/// TopRows structure maintains the rows in descending order of their ranks
+/// (greatest rank at the top of the priority queue). So when outputting,
+/// the operator first fixes the top rank of the partition using fixTopRank()
+/// and then computes the ranks of each row using computeNextRankInMemory().
+/// The logic of the next rank differs based on the ranking function.
 ///
-/// This is an optimized version of a Window operator with a single row_number
-/// window function followed by a row_number <= N filter.
+/// If the rows are in the spill, then the spiller iterates over each spilled
+/// partition in order of the ranks. For each row from the spill, the next
+/// rank is computed using computeNextRankInSpill() function. The logic of
+/// the next rank differs based on the ranking function.
+/// Note : The spill could have > limit rows for a partition as each spill
+/// resets the TopRows for the partition. So stop outputting rows after
+/// reaching the limit for each partition.
+
 class TopNRowNumber : public Operator {
  public:
+  /// Runtime stat key indicating partial TopN was abandoned.
+  static constexpr std::string_view kAbandonedPartial = "abandonedPartial";
+
   TopNRowNumber(
       int32_t operatorId,
       DriverCtx* driverCtx,
@@ -71,7 +114,23 @@ class TopNRowNumber : public Operator {
       override;
 
  private:
-  // A priority queue to keep track of top 'limit' rows for a given partition.
+  // This structure holds the top rows for a partition. It uses a priority
+  // queue to maintain the top rows in order of their ranks. Note the rank
+  // logic depends on the respective function (row_number, rank or dense_rank).
+  // However, a common requirement across all three is to maintain the rows in
+  // order of their sort keys so that the greatest rank row is always at the top
+  // of the queue. This ordering is done using the RowComparator passed to the
+  // TopRows.
+  //
+  // The number of rows in TopRows are limited to 'limit' specified for the
+  // operator. The greatest rank of the rows in TopRows is maintained in the
+  // 'topRank' variable.
+  //
+  // The TopRows structure is first filled in order to collect 'limit'
+  // rows. Thereafter, new rows are compared with the top row and either kept
+  // or discarded and the new top rank is updated. The rank computation differs
+  // based on the ranking function. This structure has methods for abstractions
+  // used for the top rank maintenance algorithms.
   struct TopRows {
     struct Compare {
       RowComparator& comparator;
@@ -84,17 +143,43 @@ class TopNRowNumber : public Operator {
     std::priority_queue<char*, std::vector<char*, StlAllocator<char*>>, Compare>
         rows;
 
-    // This is the highest rank (this code will be enhanced for rank, dense_rank
-    // soon) seen so far in the input rows. It is compared
-    // with the limit for the operator.
+    // Temporary storage for rows with the highest rank in the partition.
+    std::vector<char*, StlAllocator<char*>> tempTopRankRows;
+
+    RowComparator& rowComparator;
+
+    // This is the greatest rank seen so far in the input rows. Note: rank is
+    // the result of the respective function computation (row_number, rank or
+    // dense_rank). It is compared with the expected limit for the operator.
     int64_t topRank = 0;
 
+    // Number of rows with the highest rank in the partition.
+    vector_size_t numTopRankRows();
+
+    // Remove all rows with the highest rank in the partition.
+    // Returns a pointer to the last removed row.
+    char* removeTopRankRows();
+
+    // Returns true if the row at position index in decodedVectors
+    // has the same order by keys as another row in the TopRows
+    // priority_vector.
+    bool isDuplicate(
+        const std::vector<DecodedVector>& decodedVectors,
+        vector_size_t index);
+
     TopRows(HashStringAllocator* allocator, RowComparator& comparator)
-        : rows{{comparator}, StlAllocator<char*>(allocator)} {}
+        : rows{{comparator}, StlAllocator<char*>(allocator)},
+          tempTopRankRows(StlAllocator<char*>(allocator)),
+          rowComparator(comparator) {}
   };
 
   void initializeNewPartitions();
 
+  // Cleans up any newly inserted but uninitialized partitions from the hash
+  // table. This is called when groupProbe throws (e.g., due to OOM) to ensure
+  // close() doesn't crash trying to destroy uninitialized TopRows structures.
+  void cleanupNewPartitions();
+
   TopRows& partitionAt(char* group) {
     return *reinterpret_cast<TopRows*>(group + partitionOffset_);
   }
@@ -104,26 +189,42 @@ class TopNRowNumber : public Operator {
 
   // Handles input row when the partition has not yet accumulated 'limit' rows.
   // Returns a pointer to the row to add to the partition accumulator.
+  template <core::TopNRowNumberNode::RankFunction TRank>
   char* processRowWithinLimit(vector_size_t index, TopRows& partition);
 
   // Handles input row when the partition has already accumulated 'limit' rows.
   // Returns a pointer to the row to add to the partition accumulator.
+  template <core::TopNRowNumberNode::RankFunction TRank>
   char* processRowExceedingLimit(vector_size_t index, TopRows& partition);
 
-  // Loop to add each row to a partition or discard the row.
+  // Loop to process the numInput input rows received by the operator.
+  template <core::TopNRowNumberNode::RankFunction TRank>
   void processInputRowLoop(vector_size_t numInput);
 
   // Adds input row to a partition or discards the row.
+  template <core::TopNRowNumberNode::RankFunction TRank>
   void processInputRow(vector_size_t index, TopRows& partition);
 
   // Returns next partition to add to output or nullptr if there are no
   // partitions left.
   TopRows* nextPartition();
 
-  // Appends numRows of the output partition the output. Note: The rows are
-  // popped in reverse order of the row_number.
+  // If there are many rows with the highest rank, then the topRank
+  // of the partition can oscillate between a very small value and a
+  // value > limit. Fix the partition for this condition before starting to
+  // output the partition.
+  vector_size_t fixTopRank(TopRows& partition);
+
+  // Computes the rank for the next row to be output
+  // (all output rows in memory).
+  template <core::TopNRowNumberNode::RankFunction TRank>
+  void computeNextRankInMemory(TopRows& partition, vector_size_t rowIndex);
+
+  // Appends numRows of the current partition to the output. Note: The rows are
+  // popped in reverse order of the rank.
   // NOTE: This function erases the yielded output rows from the partition
   // and the next call starts with the remaining rows.
+  template <core::TopNRowNumberNode::RankFunction TRank>
   void appendPartitionRows(
       TopRows& partition,
       vector_size_t numRows,
@@ -141,6 +242,7 @@ class TopNRowNumber : public Operator {
 
   void setupSpiller();
 
+  template <core::TopNRowNumberNode::RankFunction TRank>
   RowVectorPtr getOutputFromSpill();
 
   RowVectorPtr getOutputFromMemory();
@@ -150,17 +252,42 @@ class TopNRowNumber : public Operator {
   bool isNewPartition(
       const RowVectorPtr& output,
       vector_size_t index,
-      SpillMergeStream* next);
+      const SpillMergeStream* next);
 
-  // Sets nextRowNumber_ to rowNumber. Checks if next row in 'merge_' belongs to
-  // a different partition than last row in 'output' and if so updates
-  // nextRowNumber_ to 0. Also, checks current partition reached the limit on
-  // number of rows and if so advances 'merge_' to the first row on the next
-  // partition and sets nextRowNumber_ to 0.
+  // Returns true if 'next' row is a new rank (rows differ on order by keys)
+  // of the previous row in the partition (at output[index] of the
+  // output block).
+  bool isNewRank(
+      const RowVectorPtr& output,
+      vector_size_t index,
+      const SpillMergeStream* next);
+
+  // Utility method to compare values from startColumn to endColumn for
+  // 'next' row from SpillMergeStream with current row of output (at index).
+  bool compareSpillRowColumns(
+      const RowVectorPtr& output,
+      vector_size_t index,
+      const SpillMergeStream* next,
+      vector_size_t startColumn,
+      vector_size_t endColumn);
+
+  // Computes next rank value for spill output.
+  template <core::TopNRowNumberNode::RankFunction TRank>
+  inline void computeNextRankInSpill(
+      const RowVectorPtr& output,
+      vector_size_t index,
+      const SpillMergeStream* next);
+
+  // Checks if next row in 'merge_' belongs to a different partition than last
+  // row in 'output' and if so updates nextRank_ and numPeers_ to 1.
+  // Also, checks current partition reached the limit on rank and
+  // if so advances 'merge_' to the first row on the next
+  // partition and sets nextRank_ and numPeers_ to 0.
   //
   // @post 'merge_->next()' is either at end or points to a row that should be
-  // included in the next output batch using 'nextRowNumber_'.
-  void setupNextOutput(const RowVectorPtr& output, int32_t rowNumber);
+  // included in the next output batch using 'nextRank_'.
+  template <core::TopNRowNumberNode::RankFunction TRank>
+  void setupNextOutput(const RowVectorPtr& output);
 
   // Called in noMoreInput() and spill().
   void updateEstimatedOutputRowSize();
@@ -169,11 +296,15 @@ class TopNRowNumber : public Operator {
   // cardinality sufficiently. Returns false if spilling was triggered earlier.
   bool abandonPartialEarly() const;
 
+  // Rank function semantics of operator.
+  const core::TopNRowNumberNode::RankFunction rankFunction_;
+
   const int32_t limit_;
 
   const bool generateRowNumber_;
 
   const size_t numPartitionKeys_;
+  const size_t numSortingKeys_;
 
   // Input columns in the order of: partition keys, sorting keys, the rest.
   const std::vector<column_index_t> inputChannels_;
@@ -260,7 +391,11 @@ class TopNRowNumber : public Operator {
   // Used to sort-merge spilled data.
   std::unique_ptr<TreeOfLosers<SpillMergeStream>> merge_;
 
-  // Row number for the first row in the next output batch from the spiller.
-  int32_t nextRowNumber_{0};
+  // Row number/rank or dense_rank for the first row in the next output batch
+  // from the spiller.
+  vector_size_t nextRank_{1};
+  // Number of peers of first row in the previous output batch. This is used
+  // in rank calculation.
+  vector_size_t numPeers_{1};
 };
 } // namespace facebook::velox::exec
diff --git a/velox/exec/TraceUtil.h b/velox/exec/TraceUtil.h
index b9814e0e90d..a3483320e87 100644
--- a/velox/exec/TraceUtil.h
+++ b/velox/exec/TraceUtil.h
@@ -16,138 +16,5 @@
 
 #pragma once
 
-#include <string>
-#include <vector>
-#include "velox/common/file/FileSystems.h"
-#include "velox/core/PlanNode.h"
-#include "velox/exec/Task.h"
-#include "velox/type/Type.h"
-
-#include <folly/dynamic.h>
-
-namespace facebook::velox::exec::trace {
-
-/// Creates a directory to store the query trace metdata and data.
-void createTraceDirectory(
-    const std::string& traceDir,
-    const std::string& directoryConfig = "");
-
-/// Returns the trace directory for a given query.
-std::string getQueryTraceDirectory(
-    const std::string& traceDir,
-    const std::string& queryId);
-
-/// Returns the trace directory for a given query task.
-std::string getTaskTraceDirectory(
-    const std::string& traceDir,
-    const Task& task);
-
-std::string getTaskTraceDirectory(
-    const std::string& traceDir,
-    const std::string& queryId,
-    const std::string& taskId);
-
-/// Returns the file path for a given task's metadata trace file.
-std::string getTaskTraceMetaFilePath(const std::string& taskTraceDir);
-
-/// Returns the trace directory for a given traced plan node.
-std::string getNodeTraceDirectory(
-    const std::string& taskTraceDir,
-    const std::string& nodeId);
-
-/// Returns the trace directory for a given traced pipeline.
-std::string getPipelineTraceDirectory(
-    const std::string& nodeTraceDir,
-    uint32_t pipelineId);
-
-/// Returns the trace directory for a given traced operator.
-std::string getOpTraceDirectory(
-    const std::string& taskTraceDir,
-    const std::string& nodeId,
-    uint32_t pipelineId,
-    uint32_t driverId);
-
-std::string getOpTraceDirectory(
-    const std::string& nodeTraceDir,
-    uint32_t pipelineId,
-    uint32_t driverId);
-
-/// Returns the file path for a given operator's traced input file.
-std::string getOpTraceInputFilePath(const std::string& opTraceDir);
-
-/// Returns the file path for a given operator's traced split file.
-std::string getOpTraceSplitFilePath(const std::string& opTraceDir);
-
-/// Returns the file path for a given operator's traced input file.
-std::string getOpTraceSummaryFilePath(const std::string& opTraceDir);
-
-/// Extracts the input data type for the trace scan operator. The function first
-/// uses the traced node id to find traced operator's plan node from the traced
-/// plan fragment. Then it uses the specified source node index to find the
-/// output data type from its source node plans as the input data type of the
-/// traced plan node.
-///
-/// For hash join plan node, there are two source nodes, the  output data type
-/// of the first node is the input data type of the 'HashProbe' operator, and
-/// the output data type of the second one is the input data type of the
-/// 'HashBuild' operator.
-///
-/// @param tracedPlan The root node of the trace plan fragment.
-/// @param tracedNodeId The node id of the trace node.
-/// @param sourceIndex The source index of the specific traced operator.
-RowTypePtr getDataType(
-    const core::PlanNodePtr& tracedPlan,
-    const std::string& tracedNodeId,
-    size_t sourceIndex = 0);
-
-/// Extracts pipeline IDs in ascending order by listing the trace directory,
-/// then decoding the names of the subdirectories to obtain the pipeline IDs,
-/// and finally sorting them. 'nodeTraceDir' corresponds to the trace directory
-/// of the plan node.
-std::vector<uint32_t> listPipelineIds(
-    const std::string& nodeTraceDir,
-    const std::shared_ptr<filesystems::FileSystem>& fs);
-
-/// Extracts driver IDs in ascending order by listing the trace directory for a
-/// given pipeline then decoding the names of the subdirectories to obtain the
-/// driver IDs, and finally sorting them. 'nodeTraceDir' corresponds to the
-/// trace directory of the plan node.
-std::vector<uint32_t> listDriverIds(
-    const std::string& nodeTraceDir,
-    uint32_t pipelineId,
-    const std::shared_ptr<filesystems::FileSystem>& fs);
-
-/// Extracts the driver IDs from the comma-separated list of driver IDs string.
-std::vector<uint32_t> extractDriverIds(const std::string& driverIds);
-
-/// Extracts task ids of the query tracing by listing the query trace directory.
-/// 'traceDir' is the root trace directory. 'queryId' is the query id.
-std::vector<std::string> getTaskIds(
-    const std::string& traceDir,
-    const std::string& queryId,
-    const std::shared_ptr<filesystems::FileSystem>& fs);
-
-/// Gets the metadata from a given task metadata file which includes query plan,
-/// configs and connector properties.
-folly::dynamic getTaskMetadata(
-    const std::string& taskMetaFilePath,
-    const std::shared_ptr<filesystems::FileSystem>& fs);
-
-/// Checks whether the operator can be traced.
-bool canTrace(const std::string& operatorType);
-
-/// Gets the specified the trace node from 'plan'. In the returned trace node,
-/// we replace its source nodes with DummySourceNode for replay.
-core::PlanNodePtr getTraceNode(
-    const core::PlanNodePtr& plan,
-    core::PlanNodeId nodeId);
-
-using TraceNodeFactory = std::function<
-    core::PlanNodePtr(const core::PlanNode*, const core::PlanNodeId&)>;
-
-void registerTraceNodeFactory(
-    const std::string& operatorType,
-    TraceNodeFactory&& factory);
-
-void registerDummySourceSerDe();
-} // namespace facebook::velox::exec::trace
+// To maintain backward compatibility.
+#include "velox/exec/trace/TraceUtil.h"
diff --git a/velox/exec/Unnest.cpp b/velox/exec/Unnest.cpp
index 99aa13fdd3b..7d464112cea 100644
--- a/velox/exec/Unnest.cpp
+++ b/velox/exec/Unnest.cpp
@@ -16,6 +16,7 @@
 
 #include "velox/exec/Unnest.h"
 #include "velox/common/base/Nulls.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/vector/FlatVector.h"
 
 namespace facebook::velox::exec {
@@ -40,11 +41,16 @@ Unnest::Unnest(
           unnestNode->outputType(),
           operatorId,
           unnestNode->id(),
-          "Unnest"),
+          OperatorType::kUnnest),
       withOrdinality_(unnestNode->hasOrdinality()),
-      withEmptyUnnestValue_(unnestNode->hasEmptyUnnestValue()),
+      withMarker_(unnestNode->hasMarker()),
       maxOutputSize_(
-          driverCtx->queryConfig().unnestSplitOutput()
+          // If splitOutput is set to true in the UnnestNode or it's not set at
+          // all and it's enabled in the QueryConfig.
+          ((unnestNode->splitOutput().has_value() &&
+            unnestNode->splitOutput().value()) ||
+           (!unnestNode->splitOutput().has_value() &&
+            driverCtx->queryConfig().unnestSplitOutput()))
               ? outputBatchRows()
               : std::numeric_limits<vector_size_t>::max()) {
   const auto& inputType = unnestNode->sources()[0]->outputType();
@@ -60,11 +66,11 @@ Unnest::Unnest(
   unnestDecoded_.resize(unnestVariables.size());
 
   column_index_t checkOutputChannel = outputType_->size() - 1;
-  if (withEmptyUnnestValue_) {
+  if (withMarker_) {
     VELOX_CHECK_EQ(
         outputType_->childAt(checkOutputChannel),
         BOOLEAN(),
-        "Empty unnest value column should be BOOLEAN type.");
+        "Marker column should be BOOLEAN type.");
     --checkOutputChannel;
   }
   if (withOrdinality_) {
@@ -194,7 +200,7 @@ Unnest::RowRange Unnest::extractRowRange(vector_size_t inputSize) const {
     if (rawMaxSizes_[inputRow] == 0) {
       VELOX_CHECK_EQ(remainingInnerRows, 0);
       hasEmptyUnnestValue = true;
-      if (withEmptyUnnestValue_) {
+      if (withMarker_) {
         remainingInnerRows = 1;
       }
     }
@@ -237,12 +243,11 @@ void Unnest::generateRepeatedColumns(
   vector_size_t* rawRepeatedIndices =
       repeatedIndices->asMutable<vector_size_t>();
 
-  const bool generateEmptyUnnestValue =
-      withEmptyUnnestValue_ && range.hasEmptyUnnestValue;
+  const bool generateMarker = withMarker_ && range.hasEmptyUnnestValue;
   vector_size_t index{0};
   VELOX_CHECK_GT(range.numInputRows, 0);
   // Record the row number to process.
-  if (generateEmptyUnnestValue) {
+  if (generateMarker) {
     range.forEachRow(
         [&](vector_size_t row, vector_size_t /*start*/, vector_size_t size) {
           if (FOLLY_UNLIKELY(size == 0)) {
@@ -302,7 +307,7 @@ const Unnest::UnnestChannelEncoding Unnest::generateEncodingForChannel(
   range.forEachRow(
       [&](vector_size_t row, vector_size_t start, vector_size_t size) {
         const auto end = start + size;
-        if (size == 0 && withEmptyUnnestValue_) {
+        if (size == 0 && withMarker_) {
           identityMapping = false;
           bits::setNull(rawNulls, index++, true);
         } else if (!currentDecoded.isNullAt(row)) {
@@ -343,9 +348,8 @@ VectorPtr Unnest::generateOrdinalityVector(const RowRange& range) {
   // Set the ordinality at each result row to be the index of the element in
   // the original array (or map) plus one.
   auto* rawOrdinality = ordinalityVector->mutableRawValues();
-  const bool hasEmptyUnnestValue =
-      withEmptyUnnestValue_ && range.hasEmptyUnnestValue;
-  if (!hasEmptyUnnestValue) {
+  const bool hasMarker = withMarker_ && range.hasEmptyUnnestValue;
+  if (!hasMarker) {
     range.forEachRow(
         [&](vector_size_t /*row*/, vector_size_t start, vector_size_t size) {
           std::iota(rawOrdinality, rawOrdinality + size, start + 1);
@@ -374,28 +378,28 @@ VectorPtr Unnest::generateOrdinalityVector(const RowRange& range) {
   return ordinalityVector;
 }
 
-VectorPtr Unnest::generateEmptyUnnestValueVector(const RowRange& range) {
-  VELOX_CHECK(withEmptyUnnestValue_);
+VectorPtr Unnest::generateMarkerVector(const RowRange& range) {
+  VELOX_CHECK(withMarker_);
   VELOX_DCHECK_GT(range.numInputRows, 0);
 
   if (!range.hasEmptyUnnestValue) {
     return BaseVector::createConstant(
-        BOOLEAN(), false, range.numInnerRows, pool());
+        BOOLEAN(), true, range.numInnerRows, pool());
   }
 
-  // Create a vector with all elements set to false initially assuming most
+  // Create a vector with all elements set to true initially assuming most
   // output rows have non-empty unnest values.
-  auto emptyBuffer =
-      velox::AlignedBuffer::allocate<bool>(range.numInnerRows, pool(), false);
-  auto emptyVector = std::make_shared<velox::FlatVector<bool>>(
+  auto markerBuffer =
+      velox::AlignedBuffer::allocate<bool>(range.numInnerRows, pool(), true);
+  auto markerVector = std::make_shared<velox::FlatVector<bool>>(
       pool(),
       /*type=*/BOOLEAN(),
       /*nulls=*/nullptr,
       range.numInnerRows,
-      /*values=*/std::move(emptyBuffer),
+      /*values=*/std::move(markerBuffer),
       /*stringBuffers=*/std::vector<velox::BufferPtr>{});
-  // Set each output row has empty unnest values.
-  auto* const rawEmpty = emptyVector->mutableRawValues<uint64_t>();
+  // Set each output row with empty unnest values to false.
+  auto* const rawMarker = markerVector->mutableRawValues<uint64_t>();
   size_t index{0};
   range.forEachRow(
       [&](vector_size_t /*row*/, vector_size_t start, vector_size_t size) {
@@ -403,12 +407,12 @@ VectorPtr Unnest::generateEmptyUnnestValueVector(const RowRange& range) {
           index += size;
         } else {
           VELOX_DCHECK_EQ(size, 0);
-          bits::setBit(rawEmpty, index++, true);
+          bits::setBit(rawMarker, index++, false);
         }
       },
       rawMaxSizes_,
       firstInnerRowStart_);
-  return emptyVector;
+  return markerVector;
 }
 
 RowVectorPtr Unnest::generateOutput(const RowRange& range) {
@@ -443,8 +447,8 @@ RowVectorPtr Unnest::generateOutput(const RowRange& range) {
   if (withOrdinality_) {
     outputs[outputColumnIndex++] = generateOrdinalityVector(range);
   }
-  if (withEmptyUnnestValue_) {
-    outputs[outputColumnIndex++] = generateEmptyUnnestValueVector(range);
+  if (withMarker_) {
+    outputs[outputColumnIndex++] = generateMarkerVector(range);
   }
 
   return std::make_shared<RowVector>(
diff --git a/velox/exec/Unnest.h b/velox/exec/Unnest.h
index 58812e86ddd..e1fb967525c 100644
--- a/velox/exec/Unnest.h
+++ b/velox/exec/Unnest.h
@@ -134,15 +134,15 @@ class Unnest : public Operator {
   // Invoked by generateOutput for the ordinality column.
   VectorPtr generateOrdinalityVector(const RowRange& rowRange);
 
-  // Invoked by generateOutput for the empty unnest value column.
-  VectorPtr generateEmptyUnnestValueVector(const RowRange& rowRange);
+  // Invoked by generateOutput for the marker column.
+  VectorPtr generateMarkerVector(const RowRange& rowRange);
 
   // Invoked when finish one input batch processing to reset the internal
   // execution state for the next batch.
   void finishInput();
 
   const bool withOrdinality_;
-  const bool withEmptyUnnestValue_;
+  const bool withMarker_;
   // The maximum number of output batch rows.
   const vector_size_t maxOutputSize_;
 
diff --git a/velox/exec/Values.cpp b/velox/exec/Values.cpp
index 2660732979a..cc9503594e8 100644
--- a/velox/exec/Values.cpp
+++ b/velox/exec/Values.cpp
@@ -15,6 +15,7 @@
  */
 #include "velox/exec/Values.h"
 #include "velox/common/testutil/TestValue.h"
+#include "velox/exec/OperatorType.h"
 using facebook::velox::common::testutil::TestValue;
 
 namespace facebook::velox::exec {
@@ -28,7 +29,7 @@ Values::Values(
           values->outputType(),
           operatorId,
           values->id(),
-          "Values"),
+          OperatorType::kValues),
       valueNodes_(std::move(values)),
       roundsLeft_(valueNodes_->repeatTimes()) {}
 
@@ -45,8 +46,9 @@ void Values::initialize() {
         // If this is parallelizable, copy the values to prevent Vectors from
         // being shared across threads.  Note that the contract in ValuesNode is
         // that this should only be enabled for testing.
-        values_.emplace_back(std::static_pointer_cast<RowVector>(
-            vector->testingCopyPreserveEncodings()));
+        values_.emplace_back(
+            std::static_pointer_cast<RowVector>(
+                vector->testingCopyPreserveEncodings()));
       } else {
         values_.emplace_back(vector);
       }
diff --git a/velox/exec/VectorHasher-inl.h b/velox/exec/VectorHasher-inl.h
index 63f842c774b..6964d3a3c08 100644
--- a/velox/exec/VectorHasher-inl.h
+++ b/velox/exec/VectorHasher-inl.h
@@ -28,14 +28,14 @@ bool VectorHasher::tryMapToRangeSimd(
   constexpr int kWidth = xsimd::batch<T>::size;
   for (; row + kWidth <= rows.end(); row += kWidth) {
     auto data = xsimd::load_unaligned(values + row);
-    int32_t gtMax = simd::toBitMask(data > allHigh);
-    int32_t ltMin = simd::toBitMask(data < allLow);
+    bool gtMax = simd::any(data > allHigh);
+    bool ltMin = simd::any(data < allLow);
     // value - (low - 1) doesn't work when low is the lowest possible (e.g.
     // std::numeric_limits<int64_t>::min())
     if constexpr (sizeof(T) == sizeof(uint64_t)) {
       (data - allLow + allOne).store_unaligned(result + row);
     }
-    if ((gtMax | ltMin) != 0) {
+    if (gtMax || ltMin) {
       inRange = false;
       break;
     }
diff --git a/velox/exec/VectorHasher.cpp b/velox/exec/VectorHasher.cpp
index e502575aae7..70d8295b70c 100644
--- a/velox/exec/VectorHasher.cpp
+++ b/velox/exec/VectorHasher.cpp
@@ -23,35 +23,35 @@
 
 namespace facebook::velox::exec {
 
-#define VALUE_ID_TYPE_DISPATCH(TEMPLATE_FUNC, typeKind, ...)             \
-  [&]() {                                                                \
-    switch (typeKind) {                                                  \
-      case TypeKind::BOOLEAN: {                                          \
-        return TEMPLATE_FUNC<TypeKind::BOOLEAN>(__VA_ARGS__);            \
-      }                                                                  \
-      case TypeKind::TINYINT: {                                          \
-        return TEMPLATE_FUNC<TypeKind::TINYINT>(__VA_ARGS__);            \
-      }                                                                  \
-      case TypeKind::SMALLINT: {                                         \
-        return TEMPLATE_FUNC<TypeKind::SMALLINT>(__VA_ARGS__);           \
-      }                                                                  \
-      case TypeKind::INTEGER: {                                          \
-        return TEMPLATE_FUNC<TypeKind::INTEGER>(__VA_ARGS__);            \
-      }                                                                  \
-      case TypeKind::BIGINT: {                                           \
-        return TEMPLATE_FUNC<TypeKind::BIGINT>(__VA_ARGS__);             \
-      }                                                                  \
-      case TypeKind::VARCHAR:                                            \
-      case TypeKind::VARBINARY: {                                        \
-        return TEMPLATE_FUNC<TypeKind::VARCHAR>(__VA_ARGS__);            \
-      }                                                                  \
-      case TypeKind::TIMESTAMP: {                                        \
-        return TEMPLATE_FUNC<TypeKind::TIMESTAMP>(__VA_ARGS__);          \
-      }                                                                  \
-      default:                                                           \
-        VELOX_UNREACHABLE(                                               \
-            "Unsupported value ID type: ", mapTypeKindToName(typeKind)); \
-    }                                                                    \
+#define VALUE_ID_TYPE_DISPATCH(TEMPLATE_FUNC, typeKind, ...)                \
+  [&]() {                                                                   \
+    switch (typeKind) {                                                     \
+      case TypeKind::BOOLEAN: {                                             \
+        return TEMPLATE_FUNC<TypeKind::BOOLEAN>(__VA_ARGS__);               \
+      }                                                                     \
+      case TypeKind::TINYINT: {                                             \
+        return TEMPLATE_FUNC<TypeKind::TINYINT>(__VA_ARGS__);               \
+      }                                                                     \
+      case TypeKind::SMALLINT: {                                            \
+        return TEMPLATE_FUNC<TypeKind::SMALLINT>(__VA_ARGS__);              \
+      }                                                                     \
+      case TypeKind::INTEGER: {                                             \
+        return TEMPLATE_FUNC<TypeKind::INTEGER>(__VA_ARGS__);               \
+      }                                                                     \
+      case TypeKind::BIGINT: {                                              \
+        return TEMPLATE_FUNC<TypeKind::BIGINT>(__VA_ARGS__);                \
+      }                                                                     \
+      case TypeKind::VARCHAR:                                               \
+      case TypeKind::VARBINARY: {                                           \
+        return TEMPLATE_FUNC<TypeKind::VARCHAR>(__VA_ARGS__);               \
+      }                                                                     \
+      case TypeKind::TIMESTAMP: {                                           \
+        return TEMPLATE_FUNC<TypeKind::TIMESTAMP>(__VA_ARGS__);             \
+      }                                                                     \
+      default:                                                              \
+        VELOX_UNREACHABLE(                                                  \
+            "Unsupported value ID type: ", TypeKindName::toName(typeKind)); \
+    }                                                                       \
   }()
 
 namespace {
@@ -351,6 +351,8 @@ bool VectorHasher::makeValueIdsDecoded<bool, false>(
 bool VectorHasher::computeValueIds(
     const SelectivityVector& rows,
     raw_vector<uint64_t>& result) {
+  checkTypeSupportsValueIds();
+
   return VALUE_ID_TYPE_DISPATCH(makeValueIds, typeKind_, rows, result.data());
 }
 
@@ -361,6 +363,8 @@ bool VectorHasher::computeValueIdsForRows(
     int32_t nullByte,
     uint8_t nullMask,
     raw_vector<uint64_t>& result) {
+  checkTypeSupportsValueIds();
+
   return VALUE_ID_TYPE_DISPATCH(
       makeValueIdsForRows,
       typeKind_,
@@ -422,32 +426,24 @@ void VectorHasher::lookupValueIdsTyped(
         result[row] = multiplier_ == 1 ? id : result[row] + multiplier_ * id;
       });
     }
-  } else if (decoded.isIdentityMapping()) {
+    return;
+  }
+
+  if (decoded.isIdentityMapping() && !decoded.mayHaveNulls()) {
     if (Kind == TypeKind::BIGINT && isRange_) {
       lookupIdsRangeSimd<int64_t>(decoded, rows, result);
-    } else if (Kind == TypeKind::INTEGER && isRange_) {
+      rows.updateBounds();
+      return;
+    }
+    if (Kind == TypeKind::INTEGER && isRange_) {
       lookupIdsRangeSimd<int32_t>(decoded, rows, result);
-    } else {
-      rows.applyToSelected([&](vector_size_t row) INLINE_LAMBDA {
-        if (decoded.isNullAt(row)) {
-          if (multiplier_ == 1) {
-            result[row] = 0;
-          }
-          return;
-        }
-        T value = decoded.valueAt<T>(row);
-        uint64_t id = lookupValueId(value);
-        if (id == kUnmappable) {
-          rows.setValid(row, false);
-          return;
-        }
-        result[row] = multiplier_ == 1 ? id : result[row] + multiplier_ * id;
-      });
+      rows.updateBounds();
+      return;
     }
-    rows.updateBounds();
-  } else {
-    hashes.resize(decoded.base()->size());
-    std::fill(hashes.begin(), hashes.end(), 0);
+  }
+
+  if (decoded.isIdentityMapping() ||
+      rows.countSelected() <= decoded.base()->size()) {
     rows.applyToSelected([&](vector_size_t row) INLINE_LAMBDA {
       if (decoded.isNullAt(row)) {
         if (multiplier_ == 1) {
@@ -455,21 +451,41 @@ void VectorHasher::lookupValueIdsTyped(
         }
         return;
       }
-      auto baseIndex = decoded.index(row);
-      uint64_t id = hashes[baseIndex];
-      if (id == 0) {
-        T value = decoded.valueAt<T>(row);
-        id = lookupValueId(value);
-        if (id == kUnmappable) {
-          rows.setValid(row, false);
-          return;
-        }
-        hashes[baseIndex] = id;
+      T value = decoded.valueAt<T>(row);
+      uint64_t id = lookupValueId(value);
+      if (id == kUnmappable) {
+        rows.setValid(row, false);
+        return;
       }
       result[row] = multiplier_ == 1 ? id : result[row] + multiplier_ * id;
     });
     rows.updateBounds();
+    return;
   }
+
+  hashes.resize(decoded.base()->size());
+  std::fill(hashes.begin(), hashes.end(), 0);
+  rows.applyToSelected([&](vector_size_t row) INLINE_LAMBDA {
+    if (decoded.isNullAt(row)) {
+      if (multiplier_ == 1) {
+        result[row] = 0;
+      }
+      return;
+    }
+    auto baseIndex = decoded.index(row);
+    uint64_t id = hashes[baseIndex];
+    if (id == 0) {
+      T value = decoded.valueAt<T>(row);
+      id = lookupValueId(value);
+      if (id == kUnmappable) {
+        rows.setValid(row, false);
+        return;
+      }
+      hashes[baseIndex] = id;
+    }
+    result[row] = multiplier_ == 1 ? id : result[row] + multiplier_ * id;
+  });
+  rows.updateBounds();
 }
 
 template <typename T>
@@ -533,6 +549,8 @@ void VectorHasher::lookupValueIds(
     SelectivityVector& rows,
     ScratchMemory& scratchMemory,
     raw_vector<uint64_t>& result) const {
+  checkTypeSupportsValueIds();
+
   scratchMemory.decoded.decode(values, rows);
   VALUE_ID_TYPE_DISPATCH(
       lookupValueIdsTyped,
@@ -552,7 +570,7 @@ void VectorHasher::hash(
       result[row] = mix ? bits::hashMix(result[row], kNullHash) : kNullHash;
     });
   } else {
-    if (type_->providesCustomComparison()) {
+    if (typeProvidesCustomComparison_) {
       VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH(
           hashValues, true, typeKind_, rows, mix, result.data());
     } else {
@@ -581,7 +599,7 @@ void VectorHasher::precompute(const BaseVector& value) {
   const SelectivityVector rows(1, true);
   decoded_.decode(value, rows);
 
-  if (type_->providesCustomComparison()) {
+  if (typeProvidesCustomComparison_) {
     precomputedHash_ = VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH(
         hashOne, true, typeKind_, decoded_, 0);
   } else {
@@ -596,6 +614,8 @@ void VectorHasher::analyze(
     int32_t offset,
     int32_t nullByte,
     uint8_t nullMask) {
+  checkTypeSupportsValueIds();
+
   VALUE_ID_TYPE_DISPATCH(
       analyzeTyped, typeKind_, groups, numGroups, offset, nullByte, nullMask);
 }
@@ -668,6 +688,10 @@ void VectorHasher::setRangeOverflow() {
 
 std::unique_ptr<common::Filter> VectorHasher::getFilter(
     bool nullAllowed) const {
+  if (typeProvidesCustomComparison_) {
+    return nullptr;
+  }
+
   switch (typeKind_) {
     case TypeKind::TINYINT:
       [[fallthrough]];
@@ -686,8 +710,19 @@ std::unique_ptr<common::Filter> VectorHasher::getFilter(
         return common::createBigintValues(values, nullAllowed);
       }
       [[fallthrough]];
+    case TypeKind::VARCHAR:
+      [[fallthrough]];
+    case TypeKind::VARBINARY:
+      if (!distinctOverflow_) {
+        std::vector<std::string> values;
+        values.reserve(uniqueValues_.size());
+        for (const auto& value : uniqueValues_) {
+          values.emplace_back(value.asString());
+        }
+        return std::make_unique<common::BytesValues>(values, nullAllowed);
+      }
+      [[fallthrough]];
     default:
-      // TODO Add support for strings.
       return nullptr;
   }
 }
@@ -767,6 +802,12 @@ void VectorHasher::cardinality(
     int32_t reservePct,
     uint64_t& asRange,
     uint64_t& asDistincts) {
+  if (!typeSupportsValueIds()) {
+    asRange = kRangeTooLarge;
+    asDistincts = kRangeTooLarge;
+    return;
+  }
+
   if (typeKind_ == TypeKind::BOOLEAN) {
     hasRange_ = true;
     asRange = 3;
@@ -808,6 +849,8 @@ uint64_t VectorHasher::enableValueIds(uint64_t multiplier, int32_t reservePct) {
       typeKind_,
       TypeKind::BOOLEAN,
       "A boolean VectorHasher should  always be by range");
+  checkTypeSupportsValueIds();
+
   multiplier_ = multiplier;
   rangeSize_ = addIdReserve(uniqueValues_.size(), reservePct) + 1;
   isRange_ = false;
@@ -821,6 +864,8 @@ uint64_t VectorHasher::enableValueIds(uint64_t multiplier, int32_t reservePct) {
 uint64_t VectorHasher::enableValueRange(
     uint64_t multiplier,
     int32_t reservePct) {
+  checkTypeSupportsValueIds();
+
   multiplier_ = multiplier;
   VELOX_CHECK_LE(0, reservePct);
   VELOX_CHECK(hasRange_);
@@ -849,7 +894,7 @@ void VectorHasher::copyStatsFrom(const VectorHasher& other) {
   uniqueValues_ = other.uniqueValues_;
 }
 
-void VectorHasher::merge(const VectorHasher& other) {
+void VectorHasher::merge(const VectorHasher& other, size_t maxNumDistinct) {
   if (typeKind_ == TypeKind::BOOLEAN) {
     return;
   }
@@ -867,18 +912,25 @@ void VectorHasher::merge(const VectorHasher& other) {
   } else {
     setRangeOverflow();
   }
-  if (!distinctOverflow_ && !other.distinctOverflow_) {
-    // Unique values can be merged without dispatch on type. All the
-    // merged hashers must stay live for string type columns.
-    for (UniqueValue value : other.uniqueValues_) {
-      // Assign a new id at end of range for the case 'value' is not
-      // in 'uniqueValues_'. We do not set overflow here because the
-      // memory is already allocated and there is a known cap on size.
-      value.setId(uniqueValues_.size() + 1);
-      uniqueValues_.insert(value);
-    }
-  } else {
+  if (distinctOverflow_) {
+    return;
+  }
+  if (other.distinctOverflow_) {
     setDistinctOverflow();
+    return;
+  }
+  // Unique values can be merged without dispatch on type. All the
+  // merged hashers must stay live for string type columns.
+  for (UniqueValue value : other.uniqueValues_) {
+    // Assign a new id at end of range for the case 'value' is not
+    // in 'uniqueValues_'. We do not set overflow here because the
+    // memory is already allocated and there is a known cap on size.
+    value.setId(uniqueValues_.size() + 1);
+    if (uniqueValues_.insert(value).second &&
+        uniqueValues_.size() > maxNumDistinct) {
+      setDistinctOverflow();
+      break;
+    }
   }
 }
 
diff --git a/velox/exec/VectorHasher.h b/velox/exec/VectorHasher.h
index ebd3534c116..f580fc6f865 100644
--- a/velox/exec/VectorHasher.h
+++ b/velox/exec/VectorHasher.h
@@ -61,6 +61,15 @@ class UniqueValue {
     return data_;
   }
 
+  std::string asString() const {
+    if (size_ <= sizeof(int64_t)) {
+      // String is stored inline in data_.
+      return std::string{reinterpret_cast<const char*>(&data_), size_};
+    }
+    // String is stored as a pointer in data_.
+    return std::string{reinterpret_cast<const char*>(data_), size_};
+  }
+
   void setData(int64_t data) {
     data_ = data;
   }
@@ -131,8 +140,15 @@ class VectorHasher {
   static constexpr int32_t kNoLimit = -1;
 
   VectorHasher(TypePtr type, column_index_t channel)
-      : channel_(channel), type_(std::move(type)), typeKind_(type_->kind()) {
-    if (typeKind_ == TypeKind::BOOLEAN) {
+      : channel_(channel),
+        type_(std::move(type)),
+        typeKind_(type_->kind()),
+        typeProvidesCustomComparison_(type_->providesCustomComparison()) {
+    if (!typeSupportsValueIds()) {
+      // Ensure any range or unique value based hashing is disabled.
+      setRangeOverflow();
+      setDistinctOverflow();
+    } else if (typeKind_ == TypeKind::BOOLEAN) {
       // We do not need samples to know the cardinality or limits of a bool
       // vector.
       hasRange_ = true;
@@ -235,15 +251,39 @@ class VectorHasher {
       ScratchMemory& scratchMemory,
       raw_vector<uint64_t>& result) const;
 
-  // Returns true if either range or distinct values have not overflowed.
+  // Returns true if either range or distinct values have not overflowed and the
+  // type doesn't support custom comparison.
   bool mayUseValueIds() const {
-    return hasRange_ || !distinctOverflow_;
+    return typeSupportsValueIds() && (hasRange_ || !distinctOverflow_);
   }
 
   // Returns an instance of the filter corresponding to a set of unique values.
   // Returns null if distinctOverflow_ is true.
   std::unique_ptr<common::Filter> getFilter(bool nullAllowed) const;
 
+  bool supportsBloomFilter() const {
+    if (typeProvidesCustomComparison_) {
+      return false;
+    }
+    switch (typeKind_) {
+      // Smaller integers would never overflow 100'000 distinct values.
+      case TypeKind::INTEGER:
+      case TypeKind::BIGINT:
+        return distinctOverflow_;
+      default:
+        return false;
+    }
+  }
+
+  void setBloomFilter(common::FilterPtr filter) {
+    VELOX_DCHECK(supportsBloomFilter());
+    bloomFilter_ = std::move(filter);
+  }
+
+  const common::FilterPtr& getBloomFilter() const {
+    return bloomFilter_;
+  }
+
   void resetStats() {
     uniqueValues_.clear();
     uniqueValuesStorage_.clear();
@@ -284,8 +324,12 @@ class VectorHasher {
     return isRange_;
   }
 
-  static bool typeKindSupportsValueIds(TypeKind kind) {
-    switch (kind) {
+  bool typeSupportsValueIds() const {
+    if (typeProvidesCustomComparison_) {
+      return false;
+    }
+
+    switch (typeKind_) {
       case TypeKind::BOOLEAN:
       case TypeKind::TINYINT:
       case TypeKind::SMALLINT:
@@ -302,7 +346,7 @@ class VectorHasher {
 
   // Merges the value ids information of 'other' into 'this'. Ranges
   // and distinct values are unioned.
-  void merge(const VectorHasher& other);
+  void merge(const VectorHasher& other, size_t maxNumDistinct);
 
   // true if no values have been added.
   bool empty() const {
@@ -535,6 +579,13 @@ class VectorHasher {
 
   void setRangeOverflow();
 
+  inline void checkTypeSupportsValueIds() const {
+    VELOX_DCHECK(
+        typeSupportsValueIds(),
+        "Value IDs cannot be used, the type {} is not supported.",
+        type_->toString());
+  }
+
   static inline bool
   isNullAt(const char* group, int32_t nullByte, uint8_t nullMask) {
     return (group[nullByte] & nullMask) != 0;
@@ -551,6 +602,7 @@ class VectorHasher {
   const column_index_t channel_;
   const TypePtr type_;
   const TypeKind typeKind_;
+  const bool typeProvidesCustomComparison_;
 
   DecodedVector decoded_;
   raw_vector<uint64_t> cachedHashes_;
@@ -587,6 +639,8 @@ class VectorHasher {
   // Memory for unique string values.
   std::vector<std::string> uniqueValuesStorage_;
   uint64_t distinctStringsBytes_ = 0;
+
+  common::FilterPtr bloomFilter_;
 };
 
 template <>
@@ -601,14 +655,6 @@ bool VectorHasher::makeValueIdsForRows<TypeKind::VARCHAR>(
 template <>
 void VectorHasher::analyzeValue(StringView value);
 
-template <>
-inline bool VectorHasher::tryMapToRange(
-    const StringView* /*values*/,
-    const SelectivityVector& /*rows*/,
-    uint64_t* /*result*/) {
-  return false;
-}
-
 template <>
 inline uint64_t VectorHasher::valueId(StringView value) {
   auto size = value.size();
@@ -703,10 +749,12 @@ inline bool VectorHasher::tryMapToRange(
 }
 
 template <>
-bool VectorHasher::tryMapToRange(
+inline bool VectorHasher::tryMapToRange(
     const StringView* /*values*/,
     const SelectivityVector& /*rows*/,
-    uint64_t* /*result*/);
+    uint64_t* /*result*/) {
+  return false;
+}
 
 template <>
 bool VectorHasher::makeValueIdsFlatNoNulls<bool>(
diff --git a/velox/exec/Window.cpp b/velox/exec/Window.cpp
index 321a469ddae..f9107522f0a 100644
--- a/velox/exec/Window.cpp
+++ b/velox/exec/Window.cpp
@@ -14,14 +14,27 @@
  * limitations under the License.
  */
 #include "velox/exec/Window.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/PartitionStreamingWindowBuild.h"
 #include "velox/exec/RowsStreamingWindowBuild.h"
 #include "velox/exec/SortWindowBuild.h"
+#include "velox/exec/SubPartitionedSortWindowBuild.h"
 #include "velox/exec/Task.h"
 
 namespace facebook::velox::exec {
 
+namespace {
+common::PrefixSortConfig makePrefixSortConfig(
+    const core::QueryConfig& queryConfig) {
+  return common::PrefixSortConfig{
+      queryConfig.prefixSortNormalizedKeyMaxBytes(),
+      queryConfig.prefixSortMinRows(),
+      queryConfig.prefixSortMaxStringPrefixLength()};
+}
+
+} // namespace
+
 Window::Window(
     int32_t operatorId,
     DriverCtx* driverCtx,
@@ -31,9 +44,9 @@ Window::Window(
           windowNode->outputType(),
           operatorId,
           windowNode->id(),
-          "Window",
+          OperatorType::kWindow,
           windowNode->canSpill(driverCtx->queryConfig())
-              ? driverCtx->makeSpillConfig(operatorId)
+              ? driverCtx->makeSpillConfig(operatorId, OperatorType::kWindow)
               : std::nullopt),
       numInputColumns_(windowNode->inputType()->size()),
       windowNode_(windowNode),
@@ -44,7 +57,8 @@ Window::Window(
   if (spillConfig == nullptr &&
       operatorCtx_->driverCtx()->queryConfig().windowSpillEnabled()) {
     auto lockedStats = stats_.wlock();
-    lockedStats->runtimeStats.emplace(kSpillNotSupported, RuntimeMetric(1));
+    lockedStats->runtimeStats.emplace(
+        std::string(kSpillNotSupported), RuntimeMetric(1));
   }
   if (windowNode->inputsSorted()) {
     if (supportRowsStreaming()) {
@@ -55,16 +69,28 @@ Window::Window(
           windowNode, pool(), spillConfig, &nonReclaimableSection_);
     }
   } else {
-    windowBuild_ = std::make_unique<SortWindowBuild>(
-        windowNode,
-        pool(),
-        common::PrefixSortConfig{
-            driverCtx->queryConfig().prefixSortNormalizedKeyMaxBytes(),
-            driverCtx->queryConfig().prefixSortMinRows(),
-            driverCtx->queryConfig().prefixSortMaxStringPrefixLength()},
-        spillConfig,
-        &nonReclaimableSection_,
-        spillStats_.get());
+    if (auto numSubPartitions =
+            operatorCtx_->driverCtx()->queryConfig().windowNumSubPartitions();
+        numSubPartitions > 1) {
+      windowBuild_ = std::make_unique<SubPartitionedSortWindowBuild>(
+          windowNode,
+          numSubPartitions,
+          pool(),
+          makePrefixSortConfig(driverCtx->queryConfig()),
+          spillConfig,
+          &nonReclaimableSection_,
+          &stats_,
+          spillStats_.get());
+    } else {
+      windowBuild_ = std::make_unique<SortWindowBuild>(
+          windowNode,
+          pool(),
+          makePrefixSortConfig(driverCtx->queryConfig()),
+          spillConfig,
+          &nonReclaimableSection_,
+          &stats_,
+          spillStats_.get());
+    }
   }
 }
 
@@ -159,10 +185,11 @@ Window::WindowFrame Window::createWindowFrame(
       return std::make_optional(
           FrameChannelArg{kConstantChannel, nullptr, value});
     } else {
-      return std::make_optional(FrameChannelArg{
-          frameChannel,
-          BaseVector::create(frame->type(), 0, pool()),
-          std::nullopt});
+      return std::make_optional(
+          FrameChannelArg{
+              frameChannel,
+              BaseVector::create(frame->type(), 0, pool()),
+              std::nullopt});
     }
   };
 
@@ -196,14 +223,15 @@ void Window::createWindowFunctions() {
       }
     }
 
-    windowFunctions_.push_back(WindowFunction::create(
-        windowNodeFunction.functionCall->name(),
-        functionArgs,
-        windowNodeFunction.functionCall->type(),
-        windowNodeFunction.ignoreNulls,
-        operatorCtx_->pool(),
-        &stringAllocator_,
-        operatorCtx_->driverCtx()->queryConfig()));
+    windowFunctions_.push_back(
+        WindowFunction::create(
+            windowNodeFunction.functionCall->name(),
+            functionArgs,
+            windowNodeFunction.functionCall->type(),
+            windowNodeFunction.ignoreNulls,
+            operatorCtx_->pool(),
+            &stringAllocator_,
+            operatorCtx_->driverCtx()->queryConfig()));
 
     windowFrames_.push_back(
         createWindowFrame(windowNode_, windowNodeFunction.frame, inputType));
@@ -251,8 +279,11 @@ void Window::reclaim(
     // TODO Add support for spilling after noMoreInput().
     LOG(WARNING)
         << "Can't reclaim from window operator which has started producing output: "
-        << pool()->name() << ", usage: " << succinctBytes(pool()->usedBytes())
-        << ", reservation: " << succinctBytes(pool()->reservedBytes());
+        << pool()->name() << ", root pool: " << pool()->root()->name()
+        << ", used: " << succinctBytes(pool()->usedBytes())
+        << ", reservation: " << succinctBytes(pool()->reservedBytes())
+        << ", root pool reservation: "
+        << succinctBytes(pool()->root()->reservedBytes());
     return;
   }
 
diff --git a/velox/exec/Window.h b/velox/exec/Window.h
index 8cbd3b1ee85..2ddca5065bf 100644
--- a/velox/exec/Window.h
+++ b/velox/exec/Window.h
@@ -67,6 +67,11 @@ class Window : public Operator {
   void reclaim(uint64_t targetBytes, memory::MemoryReclaimer::Stats& stats)
       override;
 
+  /// Runtime statistics holding total number of batches read from spilled data.
+  /// 0 if no spilling occurred.
+  static constexpr std::string_view kWindowSpillReadNumBatches{
+      "windowSpillReadNumBatches"};
+
  private:
   // Used for k preceding/following frames. Index is the column index if k is a
   // column. value is used to read column values from the column index when k
diff --git a/velox/exec/WindowBuild.h b/velox/exec/WindowBuild.h
index c67e090a02a..730e15ebb28 100644
--- a/velox/exec/WindowBuild.h
+++ b/velox/exec/WindowBuild.h
@@ -48,7 +48,7 @@ class WindowBuild {
   virtual void spill() = 0;
 
   /// Returns the spiller stats including total bytes and rows spilled so far.
-  virtual std::optional<common::SpillStats> spilledStats() const = 0;
+  virtual std::optional<exec::SpillStats> spilledStats() const = 0;
 
   /// The Window operator invokes this function to indicate that no more input
   /// rows will be passed from the Window operator to the WindowBuild. When
@@ -70,14 +70,16 @@ class WindowBuild {
 
   /// Returns the average size of input rows in bytes stored in the data
   /// container of the WindowBuild.
-  std::optional<int64_t> estimateRowSize() {
+  virtual std::optional<int64_t> estimateRowSize() {
     return data_->estimateRowSize();
   }
 
   /// Releases the memory held by the window build. This is called by the
   /// window operator when all rows have been processed.
   void release() {
-    data_->clear();
+    if (data_) {
+      data_->clear();
+    }
   }
 
   void setNumRowsPerOutput(vector_size_t numRowsPerOutput) {
diff --git a/velox/exec/WindowFunction.cpp b/velox/exec/WindowFunction.cpp
index 30c3d4840b7..1825efd2ecd 100644
--- a/velox/exec/WindowFunction.cpp
+++ b/velox/exec/WindowFunction.cpp
@@ -68,6 +68,52 @@ std::optional<std::vector<FunctionSignaturePtr>> getWindowFunctionSignatures(
   return std::nullopt;
 }
 
+TypePtr resolveWindowResultType(
+    const std::string& name,
+    const std::vector<TypePtr>& argTypes) {
+  auto sanitizedName = sanitizeName(name);
+
+  if (auto signatures = getWindowFunctionSignatures(sanitizedName)) {
+    for (const auto& signature : signatures.value()) {
+      SignatureBinder binder(*signature, argTypes, TypeCoercer::defaults());
+      if (binder.tryBind()) {
+        return binder.tryResolveReturnType();
+      }
+    }
+
+    VELOX_USER_FAIL(
+        "Window function signature is not supported: {}. Supported signatures: {}.",
+        toString(sanitizedName, argTypes),
+        toString(signatures.value()));
+  }
+
+  VELOX_USER_FAIL("Window function not registered: {}", name);
+}
+
+TypePtr resolveWindowResultTypeWithCoercions(
+    const std::string& name,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer) {
+  coercions.clear();
+
+  auto sanitizedName = sanitizeName(name);
+
+  if (auto signatures = getWindowFunctionSignatures(sanitizedName)) {
+    if (auto type = tryResolveReturnTypeWithCoercions(
+            signatures.value(), argTypes, coercions, coercer)) {
+      return type;
+    }
+
+    VELOX_USER_FAIL(
+        "Window function signature is not supported: {}. Supported signatures: {}.",
+        toString(sanitizedName, argTypes),
+        toString(signatures.value()));
+  }
+
+  VELOX_USER_FAIL("Window function not registered: {}", name);
+}
+
 std::unique_ptr<WindowFunction> WindowFunction::create(
     const std::string& name,
     const std::vector<WindowFunctionArg>& args,
@@ -86,7 +132,7 @@ std::unique_ptr<WindowFunction> WindowFunction::create(
 
     const auto& signatures = func.value()->signatures;
     for (auto& signature : signatures) {
-      SignatureBinder binder(*signature, argTypes);
+      SignatureBinder binder(*signature, argTypes, TypeCoercer::defaults());
       if (binder.tryBind()) {
         auto type = binder.tryResolveType(signature->returnType());
         VELOX_USER_CHECK(
diff --git a/velox/exec/WindowFunction.h b/velox/exec/WindowFunction.h
index e9bea92ee2c..dd0febc41fc 100644
--- a/velox/exec/WindowFunction.h
+++ b/velox/exec/WindowFunction.h
@@ -18,6 +18,7 @@
 #include "velox/core/QueryConfig.h"
 #include "velox/exec/WindowPartition.h"
 #include "velox/expression/FunctionSignature.h"
+#include "velox/type/TypeCoercer.h"
 #include "velox/vector/BaseVector.h"
 
 namespace facebook::velox::exec {
@@ -179,6 +180,25 @@ bool registerWindowFunction(
 std::optional<std::vector<FunctionSignaturePtr>> getWindowFunctionSignatures(
     const std::string& name);
 
+/// Resolves the return type of a window function.
+/// Throws if no matching signature is found.
+TypePtr resolveWindowResultType(
+    const std::string& name,
+    const std::vector<TypePtr>& argTypes);
+
+/// Like 'resolveWindowResultType', but with support for applying type
+/// coercions if a function signature doesn't match 'argTypes' exactly.
+///
+/// @param coercions A list of optional type coercions applied to resolve the
+/// function. Contains one entry per argument. The entry is null if no coercion
+/// is required for that argument.
+/// @param coercer Coercion rule set to use when resolving type coercions.
+TypePtr resolveWindowResultTypeWithCoercions(
+    const std::string& name,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer);
+
 struct WindowFunctionEntry {
   std::vector<FunctionSignaturePtr> signatures;
   WindowFunctionFactory factory;
diff --git a/velox/exec/WindowPartition.cpp b/velox/exec/WindowPartition.cpp
index 90b209732f8..954437d0ed6 100644
--- a/velox/exec/WindowPartition.cpp
+++ b/velox/exec/WindowPartition.cpp
@@ -74,7 +74,7 @@ void WindowPartition::removeProcessedRows(vector_size_t numRows) {
     previousRow_ = rows_[numRows - 1];
   }
 
-  rows_.erase(rows_.begin(), rows_.begin() + numRows);
+  rows_.erase(rows_.cbegin(), rows_.cbegin() + numRows);
   partition_ = folly::Range(rows_.data(), rows_.size());
   startRow_ += numRows;
 }
diff --git a/velox/exec/benchmarks/AtomicsBench.cpp b/velox/exec/benchmarks/AtomicsBench.cpp
index 74343e9303f..c86991ef6fc 100644
--- a/velox/exec/benchmarks/AtomicsBench.cpp
+++ b/velox/exec/benchmarks/AtomicsBench.cpp
@@ -16,16 +16,39 @@
 
 #include <folly/Benchmark.h>
 #include <folly/init/Init.h>
-#include <gtest/gtest.h>
 #include <atomic>
 #include <thread>
 #include <vector>
+#include "velox/common/base/Portability.h"
 #include "velox/exec/OneWayStatusFlag.h"
 
-using namespace ::testing;
-using namespace facebook::velox;
-static const size_t kNumThreads = 88;
-static const size_t kNumIterations = 10000;
+namespace {
+
+using facebook::velox::exec::OneWayStatusFlag;
+constexpr size_t kNumThreads = 88;
+constexpr size_t kNumIterations = 10000;
+
+#if defined(__x86_64__) && !defined(TSAN_BUILD)
+
+class OneWayStatusFlagUnsafe {
+ public:
+  bool check() const {
+    return fastStatus_ || atomicStatus_.load();
+  }
+
+  void set() {
+    if (!fastStatus_) {
+      atomicStatus_.store(true);
+      fastStatus_ = true;
+    }
+  }
+
+ private:
+  bool fastStatus_{false};
+  std::atomic_bool atomicStatus_{false};
+};
+
+#endif
 
 void runParallelUpdates(
     std::function<void(size_t iter)> callback,
@@ -46,12 +69,28 @@ void runParallelUpdates(
   }
 }
 
-BENCHMARK(std_atomic_bool_write) {
-  std::atomic<bool> flag{false};
+BENCHMARK(std_atomic_bool_write_seq_cst) {
+  std::atomic_bool flag{false};
   runParallelUpdates(
       [&](size_t iters) {
         for (size_t i = 0; i < iters; ++i) {
           flag.store(true);
+          bool dummy{};
+          folly::doNotOptimizeAway(dummy);
+        }
+      },
+      kNumThreads, // Threads
+      kNumIterations); // Iterations per thread
+}
+
+BENCHMARK(std_atomic_bool_write_release) {
+  std::atomic_bool flag{false};
+  runParallelUpdates(
+      [&](size_t iters) {
+        for (size_t i = 0; i < iters; ++i) {
+          flag.store(true, std::memory_order_release);
+          bool dummy{};
+          folly::doNotOptimizeAway(dummy);
         }
       },
       kNumThreads, // Threads
@@ -59,76 +98,82 @@ BENCHMARK(std_atomic_bool_write) {
 }
 
 BENCHMARK(std_atomic_bool_write_relaxed) {
-  std::atomic<bool> flag{false};
+  std::atomic_bool flag{false};
   runParallelUpdates(
       [&](size_t iters) {
         for (size_t i = 0; i < iters; ++i) {
           flag.store(true, std::memory_order_relaxed);
+          bool dummy{};
+          folly::doNotOptimizeAway(dummy);
         }
       },
       kNumThreads, // Threads
       kNumIterations); // Iterations per thread
 }
 
-BENCHMARK(std_atomic_bool_read_write_relaxed) {
-  std::atomic<bool> flag{false};
+BENCHMARK(one_way_flag_write) {
+  OneWayStatusFlag flag;
   runParallelUpdates(
       [&](size_t iters) {
         for (size_t i = 0; i < iters; ++i) {
-          if (!flag.load(std::memory_order_relaxed)) {
-            flag.store(true, std::memory_order_acq_rel);
-          }
+          flag.set();
+          bool dummy{};
+          folly::doNotOptimizeAway(dummy);
         }
       },
       kNumThreads, // Threads
       kNumIterations); // Iterations per thread
 }
 
-BENCHMARK(one_way_flag_write) {
-  exec::OneWayStatusFlag flag;
+#if defined(__x86_64__) && !defined(TSAN_BUILD)
+
+BENCHMARK(one_way_flag_unsafe_write) {
+  OneWayStatusFlagUnsafe flag;
   runParallelUpdates(
       [&](size_t iters) {
         for (size_t i = 0; i < iters; ++i) {
           flag.set();
+          bool dummy{};
+          folly::doNotOptimizeAway(dummy);
         }
       },
       kNumThreads, // Threads
       kNumIterations); // Iterations per thread
 }
 
+#endif
+
 // Read Benchmarks
-BENCHMARK(std_atomic_bool_read) {
-  std::atomic<bool> flag{false};
+BENCHMARK(std_atomic_bool_read_seq_cst) {
+  std::atomic_bool flag{false};
   runParallelUpdates(
       [&](size_t iters) {
         for (size_t i = 0; i < iters; ++i) {
-          folly::doNotOptimizeAway(flag.load());
+          folly::doNotOptimizeAway(flag.load(std::memory_order_seq_cst));
         }
       },
       kNumThreads, // Threads
       kNumIterations); // Iterations per thread
 }
 
-BENCHMARK(std_atomic_bool_relaxed_read) {
-  std::atomic<bool> flag{false};
+BENCHMARK(std_atomic_bool_read_acquire) {
+  std::atomic_bool flag{false};
   runParallelUpdates(
       [&](size_t iters) {
         for (size_t i = 0; i < iters; ++i) {
-          folly::doNotOptimizeAway(flag.load(std::memory_order_relaxed));
+          folly::doNotOptimizeAway(flag.load(std::memory_order_acquire));
         }
       },
       kNumThreads, // Threads
       kNumIterations); // Iterations per thread
 }
 
-BENCHMARK(std_atomic_bool_read_relaxed_acquire) {
-  std::atomic<bool> flag{false};
+BENCHMARK(std_atomic_bool_read_relaxed) {
+  std::atomic_bool flag{false};
   runParallelUpdates(
       [&](size_t iters) {
         for (size_t i = 0; i < iters; ++i) {
-          folly::doNotOptimizeAway(
-              flag.load(std::memory_order_relaxed) ||
-              flag.load(std::memory_order_acquire));
+          folly::doNotOptimizeAway(flag.load(std::memory_order_relaxed));
         }
       },
       kNumThreads, // Threads
@@ -136,7 +181,21 @@ BENCHMARK(std_atomic_bool_read_relaxed_acquire) {
 }
 
 BENCHMARK(one_way_flag_read) {
-  exec::OneWayStatusFlag flag;
+  OneWayStatusFlag flag;
+  runParallelUpdates(
+      [&](size_t iters) {
+        for (size_t i = 0; i < iters; ++i) {
+          folly::doNotOptimizeAway(flag.check());
+        }
+      },
+      kNumThreads, // Threads
+      kNumIterations); // Iterations per thread
+}
+
+#if defined(__x86_64__) && !defined(TSAN_BUILD)
+
+BENCHMARK(one_way_flag_unsafe_read) {
+  OneWayStatusFlagUnsafe flag;
   runParallelUpdates(
       [&](size_t iters) {
         for (size_t i = 0; i < iters; ++i) {
@@ -147,6 +206,10 @@ BENCHMARK(one_way_flag_read) {
       kNumIterations); // Iterations per thread
 }
 
+#endif
+
+} // namespace
+
 int main(int argc, char** argv) {
   folly::Init init(&argc, &argv);
   folly::runBenchmarks();
diff --git a/velox/exec/benchmarks/CMakeLists.txt b/velox/exec/benchmarks/CMakeLists.txt
index 5dfe0ff853e..1ccecdf49d5 100644
--- a/velox/exec/benchmarks/CMakeLists.txt
+++ b/velox/exec/benchmarks/CMakeLists.txt
@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
 add_executable(velox_exec_vector_hasher_benchmark VectorHasherBenchmark.cpp)
 
 target_link_libraries(
@@ -51,6 +52,10 @@ target_link_libraries(
   GTest::gtest_main
 )
 
+add_executable(velox_hash_rows_benchmark HashRowsBenchmark.cpp)
+
+target_link_libraries(velox_hash_rows_benchmark Folly::folly Folly::follybenchmark)
+
 add_executable(velox_hash_benchmark HashTableBenchmark.cpp)
 
 target_link_libraries(
@@ -72,6 +77,17 @@ target_link_libraries(
   Folly::follybenchmark
 )
 
+add_executable(velox_hash_join_build_benchmark HashJoinBuildBenchmark.cpp)
+
+target_link_libraries(
+  velox_hash_join_build_benchmark
+  velox_exec
+  velox_exec_test_lib
+  velox_vector_fuzzer
+  velox_vector_test_lib
+  Folly::follybenchmark
+)
+
 add_executable(velox_hash_join_prepare_join_table_benchmark HashJoinPrepareJoinTableBenchmark.cpp)
 
 target_link_libraries(
@@ -98,6 +114,7 @@ if(${VELOX_ENABLE_PARQUET})
 endif()
 
 add_library(velox_orderby_benchmark_util OrderByBenchmarkUtil.cpp)
+velox_add_test_headers(velox_orderby_benchmark_util OrderByBenchmarkUtil.h)
 
 target_link_libraries(velox_orderby_benchmark_util velox_vector_fuzzer velox_vector_test_lib)
 
@@ -136,6 +153,30 @@ target_link_libraries(
   Folly::follybenchmark
 )
 
+add_executable(velox_window_sub_partitioned_sort_benchmark WindowSubPartitionedSortBenchmark.cpp)
+
+target_link_libraries(
+  velox_window_sub_partitioned_sort_benchmark
+  velox_aggregates
+  velox_exec
+  velox_exec_test_lib
+  velox_hive_connector
+  velox_vector_fuzzer
+  velox_vector_test_lib
+  velox_window
+  Folly::follybenchmark
+)
+
+add_executable(velox_mark_sorted_benchmark MarkSortedBenchmark.cpp)
+
+target_link_libraries(
+  velox_mark_sorted_benchmark
+  velox_exec
+  velox_exec_test_lib
+  velox_vector_test_lib
+  Folly::follybenchmark
+)
+
 add_executable(velox_streaming_aggregation_benchmark StreamingAggregationBenchmark.cpp)
 
 target_link_libraries(
@@ -158,3 +199,25 @@ target_link_libraries(
   velox_vector_fuzzer
   Folly::follybenchmark
 )
+
+add_executable(velox_atomics_benchmark AtomicsBench.cpp)
+
+target_link_libraries(velox_atomics_benchmark Folly::follybenchmark)
+
+if(VELOX_ENABLE_GEO)
+  add_executable(velox_spatial_join_benchmark SpatialJoinBenchmark.cpp)
+
+  target_compile_definitions(velox_spatial_join_benchmark PRIVATE VELOX_ENABLE_GEO)
+
+  target_link_libraries(
+    velox_spatial_join_benchmark
+    velox_memory
+    velox_exec
+    velox_exec_test_lib
+    velox_parse_parser
+    velox_presto_types
+    velox_vector_test_lib
+    velox_functions_prestosql
+    Folly::follybenchmark
+  )
+endif()
diff --git a/velox/exec/benchmarks/DuplicateProjectBenchmark.cpp b/velox/exec/benchmarks/DuplicateProjectBenchmark.cpp
index 4c08384d3c8..a2251b26d7c 100644
--- a/velox/exec/benchmarks/DuplicateProjectBenchmark.cpp
+++ b/velox/exec/benchmarks/DuplicateProjectBenchmark.cpp
@@ -32,6 +32,7 @@ using namespace facebook::velox::test;
 using namespace facebook::velox::exec::test;
 
 namespace {
+using namespace facebook::velox::common::testutil;
 
 static constexpr int32_t kNumVectors = 50;
 static constexpr int32_t kRowsPerVector = 10'000;
diff --git a/velox/exec/benchmarks/ExchangeBenchmark.cpp b/velox/exec/benchmarks/ExchangeBenchmark.cpp
index 17dbd6ee02e..45689ccbf64 100644
--- a/velox/exec/benchmarks/ExchangeBenchmark.cpp
+++ b/velox/exec/benchmarks/ExchangeBenchmark.cpp
@@ -162,7 +162,7 @@ class ExchangeBenchmark : public VectorTestBase {
       std::vector<std::string> finalAggTaskIds;
       core::PlanNodePtr finalAggPlan =
           exec::test::PlanBuilder()
-              .exchange(leafPlan->outputType(), VectorSerde::Kind::kPresto)
+              .exchange(leafPlan->outputType(), "Presto")
               .capturePlanNodeId(exchangeId)
               .singleAggregation({}, {"count(1)"})
               .partitionedOutput({}, 1)
@@ -184,11 +184,10 @@ class ExchangeBenchmark : public VectorTestBase {
       })});
 
       // plan: Agg/kSingle(1) <-- Exchange (0)
-      plan =
-          exec::test::PlanBuilder()
-              .exchange(finalAggPlan->outputType(), VectorSerde::Kind::kPresto)
-              .singleAggregation({}, {"sum(a0)"})
-              .planNode();
+      plan = exec::test::PlanBuilder()
+                 .exchange(finalAggPlan->outputType(), "Presto")
+                 .singleAggregation({}, {"sum(a0)"})
+                 .planNode();
     };
 
     exec::test::AssertQueryBuilder(plan)
@@ -600,7 +599,7 @@ int main(int argc, char** argv) {
   functions::prestosql::registerAllScalarFunctions();
   aggregate::prestosql::registerAllAggregateFunctions();
   parse::registerTypeResolver();
-  if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kPresto)) {
+  if (!isRegisteredNamedVectorSerde("Presto")) {
     serializer::presto::PrestoVectorSerde::registerNamedVectorSerde();
   }
   exec::ExchangeSource::registerFactory(exec::test::createLocalExchangeSource);
diff --git a/velox/exec/benchmarks/FilterProjectBenchmark.cpp b/velox/exec/benchmarks/FilterProjectBenchmark.cpp
index e34be8a68e8..4c0c26ac03e 100644
--- a/velox/exec/benchmarks/FilterProjectBenchmark.cpp
+++ b/velox/exec/benchmarks/FilterProjectBenchmark.cpp
@@ -94,10 +94,11 @@ class FilterProjectBenchmark : public VectorTestBase {
     auto& type = data[0]->type()->as<TypeKind::ROW>();
     builder.values(data);
     for (auto level = 0; level < numStages; ++level) {
-      builder.filter(fmt::format(
-          "c0 >= {}",
-          static_cast<int32_t>(
-              1000000 - pow(passPct / 100.0, 1 + level) * 1000000)));
+      builder.filter(
+          fmt::format(
+              "c0 >= {}",
+              static_cast<int32_t>(
+                  1000000 - pow(passPct / 100.0, 1 + level) * 1000000)));
       std::vector<std::string> projections = {"c0"};
       int32_t nthBigint = 0;
       int32_t nthVarchar = 0;
diff --git a/velox/exec/benchmarks/HashJoinBuildBenchmark.cpp b/velox/exec/benchmarks/HashJoinBuildBenchmark.cpp
new file mode 100644
index 00000000000..783b48a4362
--- /dev/null
+++ b/velox/exec/benchmarks/HashJoinBuildBenchmark.cpp
@@ -0,0 +1,399 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Benchmark.h>
+#include <folly/executors/CPUThreadPoolExecutor.h>
+#include <folly/init/Init.h>
+#include <iostream>
+#include <utility>
+
+#include "velox/exec/HashBuild.h"
+#include "velox/exec/HashTable.h"
+#include "velox/exec/OperatorType.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/VectorTestUtil.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::test;
+
+namespace {
+struct BenchmarkParams {
+  BenchmarkParams() = default;
+
+  // Benchmark params, we need to provide:
+  //  -the expect hash mode,
+  //  -the build row schema,
+  //  -the duplicate factor,
+  //  -number of building rows,
+  //  -number of probing rows,
+  //  -the abandon percentage,
+  //  -the number of build vector batches.
+  BenchmarkParams(
+      BaseHashTable::HashMode mode,
+      const TypePtr& buildType,
+      double dupFactor,
+      int64_t buildSize,
+      int64_t probeSize,
+      int32_t abandonPct,
+      int32_t numBuildBatches)
+      : mode{mode},
+        buildType{buildType},
+        hashTableSize{static_cast<long>(std::floor(buildSize / dupFactor))},
+        buildSize{buildSize},
+        probeSize{probeSize},
+        numBuildBatches{numBuildBatches},
+        dupFactor{dupFactor},
+        abandonPct{abandonPct} {
+    VELOX_CHECK_LE(hashTableSize, buildSize);
+    VELOX_CHECK_GE(numBuildBatches, 1);
+
+    if (hashTableSize > BaseHashTable::kArrayHashMaxSize &&
+        mode == BaseHashTable::HashMode::kArray) {
+      VELOX_FAIL("Bad hash mode.");
+    }
+
+    numFields = buildType->size();
+    if (mode == BaseHashTable::HashMode::kNormalizedKey) {
+      extraValue = BaseHashTable::kArrayHashMaxSize + 100;
+    } else if (mode == BaseHashTable::HashMode::kHash) {
+      extraValue = std::numeric_limits<int64_t>::max() - 1;
+    } else {
+      extraValue = 0;
+    }
+
+    title = fmt::format(
+        "dupFactor:{:<2},abandonPct:{},{}",
+        dupFactor,
+        abandonPct,
+        BaseHashTable::modeString(mode));
+  }
+
+  // Expected mode.
+  BaseHashTable::HashMode mode;
+
+  // Type of build & probe row.
+  TypePtr buildType;
+
+  // Distinct rows in the table.
+  int64_t hashTableSize;
+
+  // Number of build rows.
+  int64_t buildSize;
+
+  // Number of probe rows.
+  int64_t probeSize;
+
+  // Number of build RowContainers.
+  int32_t numBuildBatches;
+
+  // Title for reporting.
+  std::string title;
+
+  // The duplicate factor, 2 means every row will repeat 2 times.
+  double dupFactor;
+
+  // This parameter controls the hashing mode. It is incorporated into the keys
+  // on the build side. If the expected mode is an array, its value is 0. If
+  // the expected mode is a normalized key, its value is 'kArrayHashMaxSize' +
+  // 100 to make the key range > 'kArrayHashMaxSize'. If the expected mode is a
+  // hash, its value is the maximum value of int64_t minus 1 to make the key
+  // range  == 'kRangeTooLarge'.
+  int64_t extraValue;
+
+  // Number of fields.
+  int32_t numFields;
+
+  int32_t abandonPct;
+
+  std::string toString() const {
+    return fmt::format(
+        "DupFactor:{:<2}, AbandonPct:{}, HashMode:{:<14}",
+        dupFactor,
+        abandonPct,
+        BaseHashTable::modeString(mode));
+  }
+};
+
+struct BenchmarkResult {
+  BenchmarkParams params;
+
+  uint64_t totalClock{0};
+
+  uint64_t hashBuildPeakMemoryBytes{0};
+
+  bool isBuildNoDupHashTableAbandon{false};
+
+  // The mode of the table.
+  BaseHashTable::HashMode hashMode;
+
+  std::string toString() const {
+    return fmt::format(
+        "{}, isAbandon:{:<5}, totalClock:{}ms, peakMemoryBytes:{}",
+        params.toString(),
+        isBuildNoDupHashTableAbandon,
+        totalClock / 1000'000,
+        succinctBytes(hashBuildPeakMemoryBytes));
+  }
+};
+
+class HashJoinBuildBenchmark : public VectorTestBase {
+ public:
+  HashJoinBuildBenchmark() : randomEngine_((std::random_device{}())) {}
+
+  BenchmarkResult run(BenchmarkParams params) {
+    params_ = std::move(params);
+    BenchmarkResult result;
+    result.params = params_;
+    result.hashMode = params_.mode;
+
+    std::vector<RowVectorPtr> buildVectors;
+    makeBuildBatches(buildVectors);
+
+    int64_t sequence = 0;
+    int64_t batchSize = params_.probeSize / 4;
+    std::vector<RowVectorPtr> probeVectors;
+    for (auto i = 0; i < 4; ++i) {
+      auto batch = makeProbeVector(batchSize, params_.hashTableSize, sequence);
+      probeVectors.emplace_back(batch);
+    }
+
+    uint64_t totalClocks{0};
+    {
+      ClockTimer timer(totalClocks);
+      auto plan = makeHashJoinPlan(buildVectors, probeVectors);
+      CursorParameters cursorParams;
+      cursorParams.planNode = std::move(plan);
+      cursorParams.queryCtx = core::QueryCtx::create(
+          executor_.get(),
+          core::QueryConfig{{}},
+          {},
+          cache::AsyncDataCache::getInstance(),
+          rootPool_);
+      cursorParams.queryCtx->testingOverrideConfigUnsafe({
+          {core::QueryConfig::kAbandonDedupHashMapMinPct,
+           std::to_string(params_.abandonPct)},
+          {core::QueryConfig::kAbandonDedupHashMapMinRows, "1000000"},
+      });
+
+      cursorParams.maxDrivers = 1;
+      auto cursor = TaskCursor::create(cursorParams);
+      auto* task = cursor->task().get();
+      while (cursor->moveNext()) {
+      }
+      waitForTaskCompletion(task);
+      result.isBuildNoDupHashTableAbandon = isBuildNoDupHashTableAbandon(task);
+    }
+    result.totalClock = totalClocks;
+
+    result.hashBuildPeakMemoryBytes = getHashBuildPeakMemory(rootPool_.get());
+    return result;
+  }
+
+ private:
+  std::shared_ptr<const core::PlanNode> makeHashJoinPlan(
+      const std::vector<RowVectorPtr>& buildVectors,
+      const std::vector<RowVectorPtr>& probeVectors) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    return exec::test::PlanBuilder(planNodeIdGenerator, pool_.get())
+        .values(probeVectors)
+        .project({"c0 AS t0", "c1 as t1", "c2 as t2"})
+        .hashJoin(
+            {"t0"},
+            {"u0"},
+            exec::test::PlanBuilder(planNodeIdGenerator)
+                .values(buildVectors)
+                .project({"c0 AS u0"})
+                .planNode(),
+            "",
+            {"t0", "t1", "match"},
+            core::JoinType::kLeftSemiProject)
+        .planNode();
+  }
+
+  // Create the row vector for the build side, where the first column is used
+  // as the join key, and the remaining columns are dependent fields.
+  // If expect mode is array, the key is within the range [0, hashTableSize];
+  // If expect mode is normalized key, the key is within the range
+  // [0, hashTableSize] + extraValue(kArrayHashMaxSize + 100);
+  // If expect mode is hash, the key is within the range [0, hashTableSize] +
+  // extraValue(max_int64 -1);
+  RowVectorPtr makeBuildRows(
+      std::vector<int64_t>& data,
+      int64_t start,
+      int64_t end,
+      bool addExtraValue) {
+    auto subData =
+        std::vector<int64_t>(data.begin() + start, data.begin() + end);
+    if (addExtraValue) {
+      subData[0] = params_.extraValue;
+    }
+
+    std::vector<VectorPtr> children;
+    children.push_back(makeFlatVector<int64_t>(subData));
+    return makeRowVector(children);
+  }
+
+  // Generate the build side data batches.
+  void makeBuildBatches(std::vector<RowVectorPtr>& batches) {
+    int64_t buildKey = 0;
+    std::vector<int64_t> data;
+    for (auto i = 0; i < params_.buildSize; ++i) {
+      data.emplace_back((buildKey++) % params_.hashTableSize);
+    }
+    std::shuffle(data.begin(), data.end(), randomEngine_);
+
+    auto size = params_.buildSize / params_.numBuildBatches;
+    for (auto i = 0; i < params_.numBuildBatches; ++i) {
+      batches.push_back(makeBuildRows(
+          data,
+          i * size,
+          (i + 1) * size + 1,
+          i == params_.numBuildBatches - 1));
+    }
+  }
+
+  // Create the row vector for the probe side, where the first column is used
+  // as the join key, and the remaining columns are dependent fields.
+  // Probe key is within the range [0, hashTableSize].
+  RowVectorPtr
+  makeProbeVector(int64_t size, int64_t hashTableSize, int64_t& sequence) {
+    std::vector<VectorPtr> children;
+    for (int32_t i = 0; i < params_.numFields; ++i) {
+      children.push_back(
+          makeFlatVector<int64_t>(
+              size,
+              [&](vector_size_t row) {
+                return (sequence + row) % hashTableSize;
+              },
+              nullptr));
+    }
+    sequence += size;
+
+    for (int32_t i = 0; i < 2; ++i) {
+      children.push_back(
+          makeFlatVector<int64_t>(
+              size, [&](vector_size_t row) { return row + size; }, nullptr));
+    }
+    return makeRowVector(children);
+  }
+
+  static int64_t getHashBuildPeakMemory(memory::MemoryPool* rootPool) {
+    int64_t hashBuildPeakBytes = 0;
+    std::vector<memory::MemoryPool*> pools;
+    pools.push_back(rootPool);
+    while (!pools.empty()) {
+      std::vector<memory::MemoryPool*> childPools;
+      for (auto pool : pools) {
+        pool->visitChildren([&](memory::MemoryPool* childPool) -> bool {
+          if (childPool->name().find("HashBuild") != std::string::npos) {
+            hashBuildPeakBytes += childPool->peakBytes();
+          }
+          childPools.push_back(childPool);
+          return true;
+        });
+      }
+      pools.swap(childPools);
+    }
+    if (hashBuildPeakBytes == 0) {
+      VELOX_FAIL("Failed to get HashBuild peak memory");
+    }
+    return hashBuildPeakBytes;
+  }
+
+  static bool isBuildNoDupHashTableAbandon(exec::Task* task) {
+    for (auto& pipelineStat : task->taskStats().pipelineStats) {
+      for (auto& operatorStat : pipelineStat.operatorStats) {
+        if (operatorStat.operatorType == OperatorType::kHashBuild) {
+          return operatorStat
+                     .runtimeStats[std::string(
+                         HashBuild::kAbandonBuildNoDupHash)]
+                     .count != 0;
+        }
+      }
+    }
+    return false;
+  }
+
+  std::default_random_engine randomEngine_;
+  BenchmarkParams params_;
+};
+
+} // namespace
+
+int main(int argc, char** argv) {
+  folly::Init init{&argc, &argv};
+  memory::MemoryManager::Options options;
+  options.useMmapAllocator = true;
+  options.allocatorCapacity = 10UL << 30;
+  options.useMmapArena = true;
+  options.mmapArenaCapacityRatio = 1;
+  memory::MemoryManager::initialize(options);
+
+  auto bm = std::make_unique<HashJoinBuildBenchmark>();
+  std::vector<BenchmarkResult> results;
+
+  auto buildRowSize = (2L << 20) - 3;
+  auto probeRowSize = 100000000L;
+
+  TypePtr twoKeyType{ROW({"k1"}, {BIGINT()})};
+
+  const std::vector<BaseHashTable::HashMode> hashModes = {
+      BaseHashTable::HashMode::kArray,
+      BaseHashTable::HashMode::kNormalizedKey,
+      BaseHashTable::HashMode::kHash,
+  };
+  const std::vector<double> dupFactorVector = {
+      2,
+      8,
+      32,
+  };
+  const std::vector<int32_t> abandonPcts = {
+      90,
+      80,
+      70,
+      50,
+      0,
+  };
+
+  std::vector<BenchmarkParams> params;
+  for (auto mode : hashModes) {
+    for (auto dupFactor : dupFactorVector) {
+      for (auto pct : abandonPcts) {
+        params.push_back(BenchmarkParams(
+            mode, twoKeyType, dupFactor, buildRowSize, probeRowSize, pct, 512));
+      }
+    }
+  }
+
+  for (auto& param : params) {
+    BenchmarkResult result;
+    folly::addBenchmark(__FILE__, param.title, [param, &results, &bm]() {
+      results.emplace_back(bm->run(param));
+      return 1;
+    });
+  }
+
+  folly::runBenchmarks();
+
+  for (auto& result : results) {
+    std::cout << result.toString() << std::endl;
+  }
+  return 0;
+}
diff --git a/velox/exec/benchmarks/HashJoinListResultBenchmark.cpp b/velox/exec/benchmarks/HashJoinListResultBenchmark.cpp
index f9b6f13f179..cb0c7788c0f 100644
--- a/velox/exec/benchmarks/HashJoinListResultBenchmark.cpp
+++ b/velox/exec/benchmarks/HashJoinListResultBenchmark.cpp
@@ -280,10 +280,11 @@ class HashTableListJoinResultBenchmark : public VectorTestBase {
     std::vector<VectorPtr> children;
     children.push_back(makeFlatVector<int64_t>(data));
     for (int32_t i = 0; i < params_.numDependentFields; ++i) {
-      children.push_back(makeFlatVector<int64_t>(
-          data.size(),
-          [&](vector_size_t row) { return row + maxKey; },
-          nullptr));
+      children.push_back(
+          makeFlatVector<int64_t>(
+              data.size(),
+              [&](vector_size_t row) { return row + maxKey; },
+              nullptr));
     }
     return makeRowVector(children);
   }
@@ -311,14 +312,16 @@ class HashTableListJoinResultBenchmark : public VectorTestBase {
   RowVectorPtr
   makeProbeVector(int32_t size, int64_t hashTableSize, int64_t& sequence) {
     std::vector<VectorPtr> children;
-    children.push_back(makeFlatVector<int64_t>(
-        size,
-        [&](vector_size_t row) { return (sequence + row) % hashTableSize; },
-        nullptr));
+    children.push_back(
+        makeFlatVector<int64_t>(
+            size,
+            [&](vector_size_t row) { return (sequence + row) % hashTableSize; },
+            nullptr));
     sequence += size;
     for (int32_t i = 0; i < params_.numDependentFields; ++i) {
-      children.push_back(makeFlatVector<int64_t>(
-          size, [&](vector_size_t row) { return row + size; }, nullptr));
+      children.push_back(
+          makeFlatVector<int64_t>(
+              size, [&](vector_size_t row) { return row + size; }, nullptr));
     }
     return makeRowVector(children);
   }
@@ -375,6 +378,7 @@ class HashTableListJoinResultBenchmark : public VectorTestBase {
           dependentTypes,
           true,
           false,
+          false, // hasCountFlag
           1'000,
           tablePools[i].get());
 
@@ -391,6 +395,8 @@ class HashTableListJoinResultBenchmark : public VectorTestBase {
       topTable_->prepareJoinTable(
           std::move(otherTables),
           BaseHashTable::kNoSpillInputStartPartitionBit,
+          1'000'000,
+          false,
           executor_.get());
     }
     buildTime_ = buildClocks;
diff --git a/velox/exec/benchmarks/HashJoinPrepareJoinTableBenchmark.cpp b/velox/exec/benchmarks/HashJoinPrepareJoinTableBenchmark.cpp
index 6d5988577ad..ac9ffddd4da 100644
--- a/velox/exec/benchmarks/HashJoinPrepareJoinTableBenchmark.cpp
+++ b/velox/exec/benchmarks/HashJoinPrepareJoinTableBenchmark.cpp
@@ -129,6 +129,8 @@ class HashJoinPrepareJoinTableBenchmark : public VectorTestBase {
     topTable_->prepareJoinTable(
         std::move(otherTables_),
         BaseHashTable::kNoSpillInputStartPartitionBit,
+        1'000'000,
+        false,
         executor_.get());
     VELOX_CHECK_EQ(topTable_->hashMode(), params_.mode);
   }
@@ -219,6 +221,7 @@ class HashJoinPrepareJoinTableBenchmark : public VectorTestBase {
           dependentTypes,
           true,
           false,
+          false, // hasCountFlag
           1'000,
           pool_.get());
 
diff --git a/velox/exec/benchmarks/HashRowsBenchmark.cpp b/velox/exec/benchmarks/HashRowsBenchmark.cpp
new file mode 100644
index 00000000000..289731003f1
--- /dev/null
+++ b/velox/exec/benchmarks/HashRowsBenchmark.cpp
@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Benchmark.h>
+#include <folly/hash/Hash.h>
+#include <folly/init/Init.h>
+
+#include <random>
+#include <vector>
+
+#include "velox/exec/AdaptivePrefetch.h"
+
+namespace {
+
+using namespace facebook::velox::exec;
+using NormalizedKeyT = uint64_t;
+
+struct FakeRowContainer {
+  explicit FakeRowContainer(int64_t numRows) {
+    constexpr int32_t kRowSize = 32;
+    constexpr int32_t kKeySize = sizeof(NormalizedKeyT);
+    data_.resize(static_cast<size_t>(numRows) * kRowSize);
+    rows_.resize(static_cast<size_t>(numRows));
+
+    std::mt19937_64 rng(42);
+    for (int64_t i = 0; i < numRows; ++i) {
+      char* base = data_.data() + i * kRowSize;
+      auto* key = reinterpret_cast<NormalizedKeyT*>(base);
+      *key = rng();
+      rows_[i] = base + kKeySize;
+    }
+    std::shuffle(rows_.begin(), rows_.end(), std::mt19937(123));
+  }
+
+  char** rows() {
+    return rows_.data();
+  }
+  int64_t numRows() const {
+    return static_cast<int64_t>(rows_.size());
+  }
+
+ private:
+  std::vector<char> data_;
+  std::vector<char*> rows_;
+};
+
+inline NormalizedKeyT& normalizedKey(char* row) {
+  return reinterpret_cast<NormalizedKeyT*>(row)[-1];
+}
+
+constexpr int32_t kBatchSize = 1024;
+
+std::unique_ptr<FakeRowContainer> g4K;
+std::unique_ptr<FakeRowContainer> g40K;
+std::unique_ptr<FakeRowContainer> g400K;
+std::unique_ptr<FakeRowContainer> g4M;
+
+void hashRowsNoPrefetch(FakeRowContainer& container, int32_t iters) {
+  std::vector<uint64_t> hashes(kBatchSize);
+  auto** allRows = container.rows();
+  const int64_t numRows = container.numRows();
+
+  for (int32_t iter = 0; iter < iters; ++iter) {
+    for (int64_t start = 0; start + kBatchSize <= numRows;
+         start += kBatchSize) {
+      char** rows = allRows + start;
+      for (int32_t i = 0; i < kBatchSize; ++i) {
+        hashes[i] = folly::hasher<uint64_t>()(normalizedKey(rows[i]));
+      }
+    }
+  }
+  folly::doNotOptimizeAway(hashes.data());
+}
+
+void hashRowsWithPrefetch(FakeRowContainer& container, int32_t iters) {
+  std::vector<uint64_t> hashes(kBatchSize);
+  auto** allRows = container.rows();
+  const int64_t numRows = container.numRows();
+
+  for (int32_t iter = 0; iter < iters; ++iter) {
+    for (int64_t start = 0; start + kBatchSize <= numRows;
+         start += kBatchSize) {
+      char** rows = allRows + start;
+      AdaptivePrefetch prefetch(kBatchSize);
+      for (int32_t i = 0; i < kBatchSize; ++i) {
+        if (auto ahead = prefetch.lookAhead()) {
+          __builtin_prefetch(rows[i + ahead] - sizeof(NormalizedKeyT));
+        }
+        hashes[i] = folly::hasher<uint64_t>()(normalizedKey(rows[i]));
+      }
+    }
+  }
+  folly::doNotOptimizeAway(hashes.data());
+}
+
+BENCHMARK(noPrefetch_4K) {
+  hashRowsNoPrefetch(*g4K, 5);
+}
+BENCHMARK_RELATIVE(withPrefetch_4K) {
+  hashRowsWithPrefetch(*g4K, 5);
+}
+
+BENCHMARK_DRAW_LINE();
+
+BENCHMARK(noPrefetch_40K) {
+  hashRowsNoPrefetch(*g40K, 5);
+}
+BENCHMARK_RELATIVE(withPrefetch_40K) {
+  hashRowsWithPrefetch(*g40K, 5);
+}
+
+BENCHMARK_DRAW_LINE();
+
+BENCHMARK(noPrefetch_400K) {
+  hashRowsNoPrefetch(*g400K, 5);
+}
+BENCHMARK_RELATIVE(withPrefetch_400K) {
+  hashRowsWithPrefetch(*g400K, 5);
+}
+
+BENCHMARK_DRAW_LINE();
+
+BENCHMARK(noPrefetch_4M) {
+  hashRowsNoPrefetch(*g4M, 5);
+}
+BENCHMARK_RELATIVE(withPrefetch_4M) {
+  hashRowsWithPrefetch(*g4M, 5);
+}
+
+} // namespace
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+  g4K = std::make_unique<FakeRowContainer>(4'000);
+  g40K = std::make_unique<FakeRowContainer>(40'000);
+  g400K = std::make_unique<FakeRowContainer>(400'000);
+  g4M = std::make_unique<FakeRowContainer>(4'000'000);
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/exec/benchmarks/HashTableBenchmark.cpp b/velox/exec/benchmarks/HashTableBenchmark.cpp
index 7bc4ec69a4d..4d6c9b918c7 100644
--- a/velox/exec/benchmarks/HashTableBenchmark.cpp
+++ b/velox/exec/benchmarks/HashTableBenchmark.cpp
@@ -173,14 +173,16 @@ class HashTableBenchmark : public VectorTestBase {
       std::vector<RowVectorPtr> batches;
       std::vector<std::unique_ptr<VectorHasher>> keyHashers;
       for (auto channel = 0; channel < params_.numKeys; ++channel) {
-        keyHashers.emplace_back(std::make_unique<VectorHasher>(
-            params_.buildType->childAt(channel), channel));
+        keyHashers.emplace_back(
+            std::make_unique<VectorHasher>(
+                params_.buildType->childAt(channel), channel));
       }
       auto table = HashTable<true>::createForJoin(
           std::move(keyHashers),
           dependentTypes,
           true,
           false,
+          false, // hasCountFlag
           1'000,
           pool_.get());
 
@@ -198,6 +200,8 @@ class HashTableBenchmark : public VectorTestBase {
     topTable_->prepareJoinTable(
         std::move(otherTables),
         BaseHashTable::kNoSpillInputStartPartitionBit,
+        1'000'000,
+        false,
         executor_.get());
     LOG(INFO) << "Made table " << topTable_->toString();
 
@@ -409,8 +413,9 @@ class HashTableBenchmark : public VectorTestBase {
       TypePtr buildType,
       std::vector<RowVectorPtr>& batches) {
     for (auto i = 0; i < numBatches; ++i) {
-      batches.push_back(std::static_pointer_cast<RowVector>(
-          makeVector(buildType, batchSize, sequence)));
+      batches.push_back(
+          std::static_pointer_cast<RowVector>(
+              makeVector(buildType, batchSize, sequence)));
       sequence += batchSize;
     }
   }
diff --git a/velox/exec/benchmarks/MarkSortedBenchmark.cpp b/velox/exec/benchmarks/MarkSortedBenchmark.cpp
new file mode 100644
index 00000000000..87f84eee3f3
--- /dev/null
+++ b/velox/exec/benchmarks/MarkSortedBenchmark.cpp
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/vector/tests/utils/VectorMaker.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec::test;
+
+namespace {
+
+constexpr vector_size_t kBatchSize = 10'000;
+constexpr int kIterations = 100;
+
+class BenchmarkHelper {
+ public:
+  memory::MemoryPool* pool() {
+    return pool_.get();
+  }
+
+  test::VectorMaker& vectorMaker() {
+    return vectorMaker_;
+  }
+
+  void runMarkSorted(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<std::string>& sortingKeys,
+      const std::vector<core::SortOrder>& sortingOrders) {
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .markSorted("is_sorted", sortingKeys, sortingOrders)
+                    .planNode();
+    auto result = AssertQueryBuilder(plan).copyResults(pool());
+    folly::doNotOptimizeAway(result);
+  }
+
+ private:
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
+  test::VectorMaker vectorMaker_{pool_.get()};
+};
+
+// --- Sorted INTEGER (SIMD path) ---
+BENCHMARK(sortedInteger) {
+  folly::BenchmarkSuspender suspender;
+  BenchmarkHelper helper;
+  auto data = helper.vectorMaker().rowVector({
+      helper.vectorMaker().flatVector<int32_t>(
+          kBatchSize, [](vector_size_t i) { return i; }),
+  });
+  suspender.dismiss();
+
+  for (int i = 0; i < kIterations; ++i) {
+    helper.runMarkSorted({data}, {"c0"}, {core::kAscNullsLast});
+  }
+}
+
+// --- Sorted BIGINT (SIMD path) ---
+BENCHMARK_RELATIVE(sortedBigint) {
+  folly::BenchmarkSuspender suspender;
+  BenchmarkHelper helper;
+  auto data = helper.vectorMaker().rowVector({
+      helper.vectorMaker().flatVector<int64_t>(
+          kBatchSize, [](vector_size_t i) { return static_cast<int64_t>(i); }),
+  });
+  suspender.dismiss();
+
+  for (int i = 0; i < kIterations; ++i) {
+    helper.runMarkSorted({data}, {"c0"}, {core::kAscNullsLast});
+  }
+}
+
+// --- Sorted VARCHAR (generic path, no SIMD) ---
+// U8 fix: strings stored in vector with lifetime spanning the benchmark.
+BENCHMARK_RELATIVE(sortedVarchar) {
+  folly::BenchmarkSuspender suspender;
+  BenchmarkHelper helper;
+  std::vector<std::string> storage(kBatchSize);
+  for (vector_size_t i = 0; i < kBatchSize; ++i) {
+    storage[i] = fmt::format("str_{:08d}", i);
+  }
+  auto data = helper.vectorMaker().rowVector({
+      helper.vectorMaker().flatVector<StringView>(
+          kBatchSize,
+          [&storage](vector_size_t i) { return StringView(storage[i]); }),
+  });
+  suspender.dismiss();
+
+  for (int i = 0; i < kIterations; ++i) {
+    helper.runMarkSorted({data}, {"c0"}, {core::kAscNullsLast});
+  }
+}
+
+// --- Unsorted INTEGER (SIMD path, many false bits) ---
+BENCHMARK(unsortedInteger) {
+  folly::BenchmarkSuspender suspender;
+  BenchmarkHelper helper;
+  auto data = helper.vectorMaker().rowVector({
+      helper.vectorMaker().flatVector<int32_t>(
+          kBatchSize,
+          [](vector_size_t i) {
+            // Alternating pattern creates many unsorted pairs.
+            return (i % 2 == 0) ? i : kBatchSize - i;
+          }),
+  });
+  suspender.dismiss();
+
+  for (int i = 0; i < kIterations; ++i) {
+    helper.runMarkSorted({data}, {"c0"}, {core::kAscNullsLast});
+  }
+}
+
+// --- ConstantVector (O(1) fast path) ---
+BENCHMARK_RELATIVE(constantVector) {
+  folly::BenchmarkSuspender suspender;
+  BenchmarkHelper helper;
+  auto data = helper.vectorMaker().rowVector({
+      BaseVector::createConstant(INTEGER(), 42, kBatchSize, helper.pool()),
+  });
+  suspender.dismiss();
+
+  for (int i = 0; i < kIterations; ++i) {
+    helper.runMarkSorted({data}, {"c0"}, {core::kAscNullsLast});
+  }
+}
+
+// --- Cross-batch comparison (measures overhead) ---
+BENCHMARK(crossBatch) {
+  folly::BenchmarkSuspender suspender;
+  BenchmarkHelper helper;
+  constexpr vector_size_t kSmallBatch = 100;
+  constexpr int kNumBatches = 100;
+  std::vector<RowVectorPtr> batches;
+  batches.reserve(kNumBatches);
+  for (int b = 0; b < kNumBatches; ++b) {
+    batches.push_back(helper.vectorMaker().rowVector({
+        helper.vectorMaker().flatVector<int32_t>(
+            kSmallBatch, [b](vector_size_t i) { return b * kSmallBatch + i; }),
+    }));
+  }
+  suspender.dismiss();
+
+  for (int i = 0; i < kIterations; ++i) {
+    helper.runMarkSorted(batches, {"c0"}, {core::kAscNullsLast});
+  }
+}
+
+} // namespace
+
+int main(int argc, char** argv) {
+  folly::Init init{&argc, &argv};
+  memory::MemoryManager::initialize(memory::MemoryManager::Options{});
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/exec/benchmarks/MergeBenchmark.cpp b/velox/exec/benchmarks/MergeBenchmark.cpp
index f5fbaee0ff6..118007abe0d 100644
--- a/velox/exec/benchmarks/MergeBenchmark.cpp
+++ b/velox/exec/benchmarks/MergeBenchmark.cpp
@@ -19,7 +19,7 @@
 
 #include <gflags/gflags.h>
 
-#include "velox/exec/TreeOfLosers.h"
+#include "velox/common/base/TreeOfLosers.h"
 #include "velox/exec/tests/utils/MergeTestBase.h"
 
 using namespace facebook::velox;
diff --git a/velox/exec/benchmarks/OrderByBenchmark.cpp b/velox/exec/benchmarks/OrderByBenchmark.cpp
index 326bbf0e53d..be01eed258f 100644
--- a/velox/exec/benchmarks/OrderByBenchmark.cpp
+++ b/velox/exec/benchmarks/OrderByBenchmark.cpp
@@ -56,7 +56,7 @@ class OrderByBenchmark {
             const auto start = getCurrentTimeMicro();
             for (auto i = 0; i < iterations; ++i) {
               std::shared_ptr<Task> task;
-              test::AssertQueryBuilder(plan).runWithoutResults(task);
+              test::AssertQueryBuilder(plan).countResults(task);
               auto taskStats = exec::toPlanStats(task->taskStats());
               auto& stats = taskStats.at(orderByNodeId);
               inputNs += stats.addInputTiming.wallNanos;
@@ -79,8 +79,9 @@ class OrderByBenchmark {
       core::PlanNodeId& orderByNodeId) {
     folly::BenchmarkSuspender suspender;
     std::vector<RowVectorPtr> vectors;
-    vectors.emplace_back(OrderByBenchmarkUtil::fuzzRows(
-        test.rowType, test.numRows, pool_.get()));
+    vectors.emplace_back(
+        OrderByBenchmarkUtil::fuzzRows(
+            test.rowType, test.numRows, pool_.get()));
 
     std::vector<std::string> keys;
     keys.reserve(test.numKeys);
diff --git a/velox/exec/benchmarks/OrderByBenchmarkUtil.h b/velox/exec/benchmarks/OrderByBenchmarkUtil.h
index 3605edc936f..8b3855daabc 100644
--- a/velox/exec/benchmarks/OrderByBenchmarkUtil.h
+++ b/velox/exec/benchmarks/OrderByBenchmarkUtil.h
@@ -23,12 +23,13 @@ class OrderByBenchmarkUtil {
  public:
   /// Add the benchmarks with the parameter.
   /// @param benchmarkFunc benchmark generator.
-  static void addBenchmarks(const std::function<void(
-                                const std::string& benchmarkName,
-                                vector_size_t numRows,
-                                const RowTypePtr& rowType,
-                                int iterations,
-                                int numKeys)>& benchmarkFunc);
+  static void addBenchmarks(
+      const std::function<void(
+          const std::string& benchmarkName,
+          vector_size_t numRows,
+          const RowTypePtr& rowType,
+          int iterations,
+          int numKeys)>& benchmarkFunc);
 
   /// Generate RowVector by VectorFuzzer according to rowType. Use
   /// FLAGS_data_null_ratio to specify the columns null ratio
diff --git a/velox/exec/benchmarks/RowContainerSortBenchmark.cpp b/velox/exec/benchmarks/RowContainerSortBenchmark.cpp
index c1f5555d37f..3dcffe398ff 100644
--- a/velox/exec/benchmarks/RowContainerSortBenchmark.cpp
+++ b/velox/exec/benchmarks/RowContainerSortBenchmark.cpp
@@ -17,6 +17,7 @@
 #include <folly/Benchmark.h>
 #include <folly/init/Init.h>
 
+#include "velox/common/io/IoStatistics.h"
 #include "velox/dwio/common/tests/utils/DataFiles.h"
 #include "velox/dwio/parquet/reader/ParquetReader.h"
 #include "velox/exec/RowContainer.h"
@@ -64,7 +65,11 @@ std::vector<std::optional<StringView>> getDataFromFile() {
   const std::string sample(getExampleFilePath("str_sort.parquet"));
   auto rowType = ROW({"query_sig", "result_sig"}, {VARCHAR(), VARCHAR()});
   auto pool = memory::memoryManager()->addLeafPool();
-  facebook::velox::dwio::common::ReaderOptions readerOptions{pool.get()};
+  auto dataIoStats = std::make_shared<velox::io::IoStatistics>();
+  auto metadataIoStats = std::make_shared<velox::io::IoStatistics>();
+  facebook::velox::dwio::common::ReaderOptions readerOptions(pool.get());
+  readerOptions.setDataIoStats(dataIoStats);
+  readerOptions.setMetadataIoStats(metadataIoStats);
   facebook::velox::parquet::ParquetReader reader =
       createReader(sample, readerOptions);
   auto rowReaderOpts = getReaderOpts(rowType);
diff --git a/velox/exec/benchmarks/SpatialJoinBenchmark.cpp b/velox/exec/benchmarks/SpatialJoinBenchmark.cpp
new file mode 100644
index 00000000000..066cceb6379
--- /dev/null
+++ b/velox/exec/benchmarks/SpatialJoinBenchmark.cpp
@@ -0,0 +1,360 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include "velox/common/memory/Memory.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/parse/TypeResolver.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+/// Benchmark for SpatialJoin operator, which implements a nested-loop join
+/// with spatial predicates (e.g., ST_INTERSECTS, ST_CONTAINS, ST_WITHIN).
+///
+/// This benchmark measures the performance of spatial joins under different
+/// conditions:
+/// - Different build and probe side sizes (cross join cardinality)
+/// - Different spatial predicates
+/// - Different data distributions (dense vs sparse geometries)
+/// - Inner vs Left join types
+///
+/// The benchmark creates synthetic geometric data and measures the throughput
+/// of spatial join operations. The focus is on understanding how the nested
+/// loop pattern performs with varying data sizes and selectivity.
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+namespace {
+
+/// Spatial distribution patterns for geometry generation.
+enum class Distribution {
+  kUniform, // Geometries uniformly distributed in space
+  kClustered // Geometries clustered in specific regions
+};
+
+// Constants for geometry generation.
+constexpr int32_t kNullPatternModulo = 13;
+constexpr int32_t kRandomCoordinateMax = 10000;
+constexpr double kCoordinateScaleDivisor = 10.0;
+constexpr int32_t kNumClusters = 5;
+constexpr double kClusterSpacing = 200.0;
+constexpr double kClusterCenterOffset = 100.0;
+constexpr int32_t kClusterSpreadRange = 100;
+constexpr int32_t kClusterSpreadHalf = 50;
+constexpr double kPolygonSize = 10.0;
+
+// Constants for benchmark configuration.
+constexpr int32_t kDefaultBatchSize = 10000;
+constexpr int32_t kSmallBenchmarkSize = 1000;
+constexpr int32_t kMediumProbeBenchmarkSize = 50000;
+constexpr int32_t kMediumBuildBenchmarkSize = 5000;
+constexpr int32_t kLargeProbeBenchmarkSize = 200000;
+constexpr int32_t kLargeBuildBenchmarkSize = 50000;
+
+/// Parameters for a spatial join benchmark test case.
+struct SpatialJoinBenchmarkParams {
+  /// Number of rows on the probe (left) side.
+  int32_t probeSize;
+
+  /// Number of rows on the build (right) side.
+  int32_t buildSize;
+
+  /// Spatial predicate to use (e.g., "ST_Intersects", "ST_Contains").
+  std::string predicate;
+
+  /// Join type (kInner or kLeft).
+  core::JoinType joinType;
+
+  /// Spatial distribution pattern for geometry generation.
+  Distribution distribution;
+
+  /// Description for benchmark naming.
+  std::string toString() const {
+    std::string joinTypeStr =
+        (joinType == core::JoinType::kInner) ? "Inner" : "Left";
+    std::string distributionStr =
+        (distribution == Distribution::kUniform) ? "uniform" : "clustered";
+    return fmt::format(
+        "{}x{}_{}_{}_{}",
+        probeSize,
+        buildSize,
+        predicate,
+        joinTypeStr,
+        distributionStr);
+  }
+};
+
+class SpatialJoinBenchmark : public facebook::velox::test::VectorTestBase {
+ public:
+  SpatialJoinBenchmark() : rng_((std::random_device{}())) {}
+
+  /// Creates a vector of POINT geometries with specified distribution.
+  VectorPtr
+  makePointVector(int32_t size, Distribution distribution, bool nulls = false) {
+    return makeFlatVector<std::string>(
+        size,
+        [&](vector_size_t row) {
+          if (nulls && (row % kNullPatternModulo == 0)) {
+            return std::string("");
+          }
+          double x, y;
+          if (distribution == Distribution::kUniform) {
+            x = (folly::Random::rand32(rng_) % kRandomCoordinateMax) /
+                kCoordinateScaleDivisor;
+            y = (folly::Random::rand32(rng_) % kRandomCoordinateMax) /
+                kCoordinateScaleDivisor;
+          } else {
+            int cluster = row % kNumClusters;
+            double centerX = (cluster * kClusterSpacing) + kClusterCenterOffset;
+            double centerY = (cluster * kClusterSpacing) + kClusterCenterOffset;
+            x = centerX +
+                ((folly::Random::rand32(rng_) % kClusterSpreadRange) -
+                 kClusterSpreadHalf);
+            y = centerY +
+                ((folly::Random::rand32(rng_) % kClusterSpreadRange) -
+                 kClusterSpreadHalf);
+          }
+          return fmt::format("POINT ({} {})", x, y);
+        },
+        [&](vector_size_t row) {
+          return nulls && (row % kNullPatternModulo == 0);
+        });
+  }
+
+  /// Creates a vector of POLYGON geometries with specified distribution.
+  VectorPtr makePolygonVector(
+      int32_t size,
+      Distribution distribution,
+      bool nulls = false) {
+    return makeFlatVector<std::string>(
+        size,
+        [&](vector_size_t row) {
+          if (nulls && (row % kNullPatternModulo == 0)) {
+            return std::string("");
+          }
+          double centerX, centerY;
+          if (distribution == Distribution::kUniform) {
+            centerX = (folly::Random::rand32(rng_) % kRandomCoordinateMax) /
+                kCoordinateScaleDivisor;
+            centerY = (folly::Random::rand32(rng_) % kRandomCoordinateMax) /
+                kCoordinateScaleDivisor;
+          } else {
+            int cluster = row % kNumClusters;
+            centerX = (cluster * kClusterSpacing) + kClusterCenterOffset;
+            centerY = (cluster * kClusterSpacing) + kClusterCenterOffset;
+          }
+          return fmt::format(
+              "POLYGON (({} {}, {} {}, {} {}, {} {}, {} {}))",
+              centerX - kPolygonSize,
+              centerY - kPolygonSize,
+              centerX + kPolygonSize,
+              centerY - kPolygonSize,
+              centerX + kPolygonSize,
+              centerY + kPolygonSize,
+              centerX - kPolygonSize,
+              centerY + kPolygonSize,
+              centerX - kPolygonSize,
+              centerY - kPolygonSize);
+        },
+        [&](vector_size_t row) {
+          return nulls && (row % kNullPatternModulo == 0);
+        });
+  }
+
+  RowVectorPtr createProjectionVector(
+      const std::string& prefix,
+      RowVectorPtr input) {
+    const auto plan = PlanBuilder(std::make_shared<core::PlanNodeIdGenerator>())
+                          .values({input})
+                          .project(
+                              {fmt::format("{}_id", prefix),
+                               fmt::format(
+                                   "ST_GeometryFromText({}_geom) AS {}_geom",
+                                   prefix,
+                                   prefix)})
+                          .planNode();
+    return AssertQueryBuilder(plan).copyResults(pool_.get());
+  }
+
+  /// Creates test data for the specified parameters.
+  std::pair<std::vector<RowVectorPtr>, std::vector<RowVectorPtr>> makeTestData(
+      const SpatialJoinBenchmarkParams& params) {
+    // Create probe side data (points)
+    std::vector<RowVectorPtr> probeVectors;
+    const int32_t batchSize = std::min(params.probeSize, kDefaultBatchSize);
+    const int32_t numBatches = (params.probeSize + batchSize - 1) / batchSize;
+
+    for (int32_t i = 0; i < numBatches; ++i) {
+      int32_t currentBatchSize =
+          std::min(batchSize, params.probeSize - (i * batchSize));
+      auto geomVector =
+          makePointVector(currentBatchSize, params.distribution, false);
+      auto idVector = makeFlatVector<int64_t>(
+          currentBatchSize,
+          [i, batchSize](vector_size_t row) { return (i * batchSize) + row; });
+      probeVectors.push_back(createProjectionVector(
+          "probe",
+          makeRowVector({"probe_id", "probe_geom"}, {idVector, geomVector})));
+    }
+
+    // Create build side data (polygons)
+    std::vector<RowVectorPtr> buildVectors;
+    const int32_t buildBatchSize =
+        std::min(params.buildSize, kDefaultBatchSize);
+    const int32_t numBuildBatches =
+        (params.buildSize + buildBatchSize - 1) / buildBatchSize;
+
+    for (int32_t i = 0; i < numBuildBatches; ++i) {
+      int32_t currentBatchSize =
+          std::min(buildBatchSize, params.buildSize - (i * buildBatchSize));
+      auto geomVector =
+          makePolygonVector(currentBatchSize, params.distribution, false);
+      auto idVector = makeFlatVector<int64_t>(
+          currentBatchSize, [i, buildBatchSize](vector_size_t row) {
+            return (i * buildBatchSize) + row;
+          });
+      buildVectors.push_back(createProjectionVector(
+          "build",
+          makeRowVector({"build_id", "build_geom"}, {idVector, geomVector})));
+    }
+
+    return {probeVectors, buildVectors};
+  }
+
+  /// Creates a spatial join plan with the specified parameters.
+  std::shared_ptr<const core::PlanNode> makeSpatialJoinPlan(
+      std::vector<RowVectorPtr>&& probeVectors,
+      std::vector<RowVectorPtr>&& buildVectors,
+      const SpatialJoinBenchmarkParams& params) {
+    const auto planNodeIdGenerator =
+        std::make_shared<core::PlanNodeIdGenerator>();
+    return PlanBuilder(planNodeIdGenerator)
+        .values(probeVectors)
+        .spatialJoin(
+            PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode(),
+            fmt::format("{}(probe_geom, build_geom)", params.predicate),
+            "probe_geom",
+            "build_geom",
+            std::nullopt,
+            {"probe_id", "probe_geom", "build_id", "build_geom"},
+            params.joinType)
+        .planNode();
+  }
+
+  /// Runs a single benchmark iteration.
+  uint64_t run(
+      std::shared_ptr<const core::PlanNode> plan,
+      const SpatialJoinBenchmarkParams& params) {
+    auto result = AssertQueryBuilder(plan).copyResults(pool_.get());
+    return result->size();
+  }
+
+  /// Adds a benchmark for the given parameters.
+  void addBenchmark(const SpatialJoinBenchmarkParams& params) {
+    auto name = params.toString();
+    folly::addBenchmark(__FILE__, name, [this, params]() {
+      std::shared_ptr<const core::PlanNode> plan;
+      BENCHMARK_SUSPEND {
+        auto [probeVectors, buildVectors] = makeTestData(params);
+        plan = makeSpatialJoinPlan(
+            std::move(probeVectors), std::move(buildVectors), params);
+      }
+
+      run(plan, params);
+      return 1;
+    });
+  }
+
+ private:
+  std::default_random_engine rng_;
+};
+
+} // namespace
+
+int main(int argc, char** argv) {
+  folly::Init init{&argc, &argv};
+  memory::initializeMemoryManager(memory::MemoryManager::Options{});
+  parse::registerTypeResolver();
+  functions::prestosql::registerAllScalarFunctions();
+
+  SpatialJoinBenchmark bm;
+
+  // Small scale benchmarks (1K x 1K)
+  bm.addBenchmark(
+      {kSmallBenchmarkSize,
+       kSmallBenchmarkSize,
+       "ST_Intersects",
+       core::JoinType::kInner,
+       Distribution::kUniform});
+  bm.addBenchmark(
+      {kSmallBenchmarkSize,
+       kSmallBenchmarkSize,
+       "ST_Intersects",
+       core::JoinType::kInner,
+       Distribution::kClustered});
+
+  // Medium scale benchmarks (50K x 5K)
+  bm.addBenchmark(
+      {kMediumProbeBenchmarkSize,
+       kMediumBuildBenchmarkSize,
+       "ST_Intersects",
+       core::JoinType::kInner,
+       Distribution::kUniform});
+  bm.addBenchmark(
+      {kMediumProbeBenchmarkSize,
+       kMediumBuildBenchmarkSize,
+       "ST_Intersects",
+       core::JoinType::kInner,
+       Distribution::kClustered});
+
+  // Left join benchmarks (50K x 5K)
+  bm.addBenchmark(
+      {kMediumProbeBenchmarkSize / 2,
+       kMediumBuildBenchmarkSize,
+       "ST_Intersects",
+       core::JoinType::kLeft,
+       Distribution::kUniform});
+  bm.addBenchmark(
+      {kMediumProbeBenchmarkSize / 2,
+       kMediumBuildBenchmarkSize,
+       "ST_Intersects",
+       core::JoinType::kLeft,
+       Distribution::kClustered});
+
+  // Contains predicate benchmarks (50K x 5K)
+  bm.addBenchmark(
+      {kMediumProbeBenchmarkSize / 2,
+       kMediumBuildBenchmarkSize,
+       "ST_Contains",
+       core::JoinType::kInner,
+       Distribution::kUniform});
+
+  // Large scale benchmark (200K x 50K)
+  bm.addBenchmark(
+      {kLargeProbeBenchmarkSize,
+       kLargeBuildBenchmarkSize,
+       "ST_Intersects",
+       core::JoinType::kInner,
+       Distribution::kUniform});
+
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/exec/benchmarks/StreamingAggregationBenchmark.cpp b/velox/exec/benchmarks/StreamingAggregationBenchmark.cpp
index dc1f16ae6a1..9393d7cef7d 100644
--- a/velox/exec/benchmarks/StreamingAggregationBenchmark.cpp
+++ b/velox/exec/benchmarks/StreamingAggregationBenchmark.cpp
@@ -84,10 +84,9 @@ class StreamingAggregationBenchmark : public VectorTestBase {
         std::to_string(params.numGroups));
 
     folly::addBenchmark(__FILE__, name, [plan = &test->plan]() {
-      std::shared_ptr<Task> task;
       exec::test::AssertQueryBuilder(*plan)
           .serialExecution(true)
-          .runWithoutResults(task);
+          .countResults();
       return 1;
     });
 
diff --git a/velox/exec/benchmarks/WindowPrefixSortBenchmark.cpp b/velox/exec/benchmarks/WindowPrefixSortBenchmark.cpp
index 27025f72351..bb012adc453 100644
--- a/velox/exec/benchmarks/WindowPrefixSortBenchmark.cpp
+++ b/velox/exec/benchmarks/WindowPrefixSortBenchmark.cpp
@@ -21,6 +21,7 @@
 
 #include "velox/common/memory/SharedArbitrator.h"
 #include "velox/exec/Cursor.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
@@ -38,6 +39,7 @@ static constexpr int32_t kNumVectors = 50;
 static constexpr int32_t kRowsPerVector = 1'0000;
 
 namespace {
+using namespace facebook::velox::common::testutil;
 
 class WindowPrefixSortBenchmark : public HiveConnectorTestBase {
  public:
@@ -72,8 +74,9 @@ class WindowPrefixSortBenchmark : public HiveConnectorTestBase {
 
       // Generate key with a small number of unique values from a small range
       // (0-16).
-      children.emplace_back(makeFlatVector<int32_t>(
-          kRowsPerVector, [](auto row) { return row % 17; }));
+      children.emplace_back(
+          makeFlatVector<int32_t>(
+              kRowsPerVector, [](auto row) { return row % 17; }));
 
       // Generate key with a small number of unique values from a large range
       // (300 total values).
@@ -94,8 +97,9 @@ class WindowPrefixSortBenchmark : public HiveConnectorTestBase {
 
       // Generate a column with increasing values to get a deterministic sort
       // order.
-      children.emplace_back(makeFlatVector<int32_t>(
-          kRowsPerVector, [](auto row) { return row; }));
+      children.emplace_back(
+          makeFlatVector<int32_t>(
+              kRowsPerVector, [](auto row) { return row; }));
 
       // Generate random values without nulls.
       children.emplace_back(fuzzer.fuzzFlat(INTEGER()));
@@ -168,11 +172,11 @@ class WindowPrefixSortBenchmark : public HiveConnectorTestBase {
     auto stats = task->taskStats();
     for (auto& pipeline : stats.pipelineStats) {
       for (auto& op : pipeline.operatorStats) {
-        if (op.operatorType == "Window") {
+        if (op.operatorType == OperatorType::kWindow) {
           windowNanos_.add(op.addInputTiming);
           windowNanos_.add(op.getOutputTiming);
         }
-        if (op.operatorType == "Values") {
+        if (op.operatorType == OperatorType::kValues) {
           // This is the timing for Window::noMoreInput() where the window
           // sorting happens. So including in the cpu timing.
           windowNanos_.add(op.finishTiming);
@@ -192,7 +196,8 @@ class WindowPrefixSortBenchmark : public HiveConnectorTestBase {
           std::move(plan),
           0,
           core::QueryCtx::create(executor_.get()),
-          Task::ExecutionMode::kSerial);
+          Task::ExecutionMode::kSerial,
+          exec::Consumer{});
     } else {
       const std::unordered_map<std::string, std::string> queryConfigMap(
           {{core::QueryConfig::kPrefixSortNormalizedKeyMaxBytes, "0"}});
@@ -202,7 +207,8 @@ class WindowPrefixSortBenchmark : public HiveConnectorTestBase {
           0,
           core::QueryCtx::create(
               executor_.get(), core::QueryConfig(queryConfigMap)),
-          Task::ExecutionMode::kSerial);
+          Task::ExecutionMode::kSerial,
+          exec::Consumer{});
     }
   }
 
diff --git a/velox/exec/benchmarks/WindowSubPartitionedSortBenchmark.cpp b/velox/exec/benchmarks/WindowSubPartitionedSortBenchmark.cpp
new file mode 100644
index 00000000000..0b64ab91bed
--- /dev/null
+++ b/velox/exec/benchmarks/WindowSubPartitionedSortBenchmark.cpp
@@ -0,0 +1,410 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <fmt/format.h>
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+#include <string>
+
+#include "velox/common/memory/SharedArbitrator.h"
+#include "velox/exec/Cursor.h"
+#include "velox/exec/OperatorType.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
+#include "velox/functions/prestosql/window/WindowFunctionsRegistration.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+DEFINE_int64(fuzzer_seed, 99887766, "Seed for random input dataset generator");
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+static constexpr int32_t kNumVectors = 200;
+static constexpr int32_t kRowsPerVector = 10'000;
+
+namespace {
+using namespace facebook::velox::common::testutil;
+
+class BenchmarkRecorder {
+ public:
+  BenchmarkRecorder() = default;
+
+  void record(std::string name, uint64_t numBytes) {
+    // Only record the first apperance.
+    if (numBytesRecords_.count(name) == 0) {
+      numBytesRecords_[name] = {1, numBytes};
+      names_.push_back(name);
+    } else {
+      auto& record = numBytesRecords_[name];
+      record.numAppearance++;
+      record.totalCount += numBytes;
+    }
+  }
+
+  std::string report() {
+    std::string result = "name, memory(MB)\n";
+    for (auto& name : names_) {
+      auto& record = numBytesRecords_[name];
+      result += fmt::format(
+          "{}, {}MB\n",
+          name,
+          record.totalCount / 1024 / 1024 / record.numAppearance);
+    }
+    return result;
+  }
+
+ private:
+  struct Counter {
+    int32_t numAppearance{0};
+    uint64_t totalCount{0};
+  };
+  std::vector<std::string> names_;
+  std::unordered_map<std::string, Counter> numBytesRecords_;
+};
+
+class WindowSubPartitionedSortBenchmark : public HiveConnectorTestBase {
+ public:
+  WindowSubPartitionedSortBenchmark(
+      int32_t numVectors,
+      int32_t rowsPerVector,
+      std::shared_ptr<BenchmarkRecorder> recorder)
+      : numVectors_(numVectors),
+        rowsPerVector_(rowsPerVector),
+        recorder_(recorder) {
+    memory::SharedArbitrator::registerFactory();
+    HiveConnectorTestBase::SetUp();
+    aggregate::prestosql::registerAllAggregateFunctions();
+    window::prestosql::registerAllWindowFunctions();
+
+    inputType_ = ROW({
+        {"k_array", INTEGER()},
+        {"k_norm", INTEGER()},
+        {"k_hash", INTEGER()},
+        {"k_sort", INTEGER()},
+        {"i32", INTEGER()},
+        {"i64", BIGINT()},
+        {"f32", REAL()},
+        {"f64", DOUBLE()},
+        {"i32_halfnull", INTEGER()},
+        {"i64_halfnull", BIGINT()},
+        {"f32_halfnull", REAL()},
+        {"f64_halfnull", DOUBLE()},
+    });
+
+    VectorFuzzer::Options opts;
+    opts.vectorSize = rowsPerVector_;
+    opts.nullRatio = 0;
+    VectorFuzzer fuzzer(opts, pool_.get(), FLAGS_fuzzer_seed);
+    std::vector<RowVectorPtr> inputVectors;
+    for (auto i = 0; i < numVectors_; ++i) {
+      std::vector<VectorPtr> children;
+
+      // Generate key with a small number of unique values from a small range
+      // (0-16).
+      children.emplace_back(
+          makeFlatVector<int32_t>(
+              rowsPerVector_, [](auto row) { return row % 17; }));
+
+      // Generate key with a small number of unique values from a large range
+      // (300 total values).
+      children.emplace_back(
+          makeFlatVector<int32_t>(rowsPerVector_, [](auto row) {
+            if (row % 3 == 0) {
+              return std::numeric_limits<int32_t>::max() - row % 100;
+            } else if (row % 3 == 1) {
+              return row % 100;
+            } else {
+              return std::numeric_limits<int32_t>::min() + row % 100;
+            }
+          }));
+
+      // Generate key with many unique values from a large range (500K total
+      // values).
+      children.emplace_back(fuzzer.fuzzFlat(INTEGER()));
+
+      // Generate a column with increasing values to get a deterministic sort
+      // order.
+      children.emplace_back(
+          makeFlatVector<int32_t>(
+              rowsPerVector_, [](auto row) { return row; }));
+
+      // Generate random values without nulls.
+      children.emplace_back(fuzzer.fuzzFlat(INTEGER()));
+      children.emplace_back(fuzzer.fuzzFlat(BIGINT()));
+      children.emplace_back(fuzzer.fuzzFlat(REAL()));
+      children.emplace_back(fuzzer.fuzzFlat(DOUBLE()));
+
+      // Generate random values with nulls.
+      opts.nullRatio = 0.05; // 5%
+      fuzzer.setOptions(opts);
+
+      children.emplace_back(fuzzer.fuzzFlat(INTEGER()));
+      children.emplace_back(fuzzer.fuzzFlat(BIGINT()));
+      children.emplace_back(fuzzer.fuzzFlat(REAL()));
+      children.emplace_back(fuzzer.fuzzFlat(DOUBLE()));
+
+      inputVectors.emplace_back(makeRowVector(inputType_->names(), children));
+    }
+
+    sourceFilePath_ = TempFilePath::create();
+    writeToFile(sourceFilePath_->getPath(), inputVectors);
+  }
+
+  ~WindowSubPartitionedSortBenchmark() override {
+    HiveConnectorTestBase::TearDown();
+  }
+
+  CpuWallTiming windowNanos() {
+    return windowNanos_;
+  }
+
+  void TestBody() override {}
+
+  void run(
+      const std::string& recordName,
+      const std::string& key,
+      const std::string& aggregate,
+      int32_t numSubPartitions) {
+    folly::BenchmarkSuspender suspender1;
+
+    windowNanos_.clear();
+    windowMems_.clear();
+
+    std::string functionSql = fmt::format(
+        "{} over (partition by {} order by k_sort)", aggregate, key);
+
+    core::PlanNodeId tableScanPlanId;
+    core::PlanFragment plan = PlanBuilder()
+                                  .tableScan(inputType_)
+                                  .capturePlanNodeId(tableScanPlanId)
+                                  .window({functionSql})
+                                  .planFragment();
+
+    vector_size_t numResultRows = 0;
+    auto task = makeTask(plan, numSubPartitions);
+    task->addSplit(
+        tableScanPlanId,
+        exec::Split(makeHiveConnectorSplit(sourceFilePath_->getPath())));
+    task->noMoreSplits(tableScanPlanId);
+    suspender1.dismiss();
+
+    while (auto result = task->next()) {
+      numResultRows += result->size();
+    }
+
+    folly::BenchmarkSuspender suspender2;
+    auto stats = task->taskStats();
+    for (auto& pipeline : stats.pipelineStats) {
+      for (auto& op : pipeline.operatorStats) {
+        if (op.operatorType == OperatorType::kWindow) {
+          windowNanos_.add(op.addInputTiming);
+          windowNanos_.add(op.getOutputTiming);
+          windowMems_.add(op.memoryStats);
+        }
+        if (op.operatorType == OperatorType::kValues) {
+          // This is the timing for Window::noMoreInput() where the window
+          // sorting happens. So including in the cpu timing.
+          windowNanos_.add(op.finishTiming);
+        }
+      }
+    }
+    recorder_->record(recordName, windowMems_.peakTotalMemoryReservation);
+    suspender2.dismiss();
+    folly::doNotOptimizeAway(numResultRows);
+  }
+
+  std::shared_ptr<exec::Task> makeTask(
+      core::PlanFragment plan,
+      int32_t numSubPartitions) {
+    bool subPartitionedSort = numSubPartitions > 1;
+    if (subPartitionedSort) {
+      const std::unordered_map<std::string, std::string> queryConfigMap(
+          {{core::QueryConfig::kWindowNumSubPartitions,
+            std::to_string(numSubPartitions)}});
+      return exec::Task::create(
+          "t",
+          std::move(plan),
+          0,
+          core::QueryCtx::create(
+              executor_.get(), core::QueryConfig(queryConfigMap)),
+          Task::ExecutionMode::kSerial);
+
+    } else {
+      return exec::Task::create(
+          "t",
+          std::move(plan),
+          0,
+          core::QueryCtx::create(executor_.get()),
+          Task::ExecutionMode::kSerial);
+    }
+  }
+
+  uint64_t getLatestMemoryUsage() {
+    return windowMems_.peakTotalMemoryReservation;
+  }
+
+ private:
+  const int32_t numVectors_;
+  const int32_t rowsPerVector_;
+  const std::shared_ptr<BenchmarkRecorder> recorder_;
+  RowTypePtr inputType_;
+  std::shared_ptr<TempFilePath> sourceFilePath_;
+
+  CpuWallTiming windowNanos_;
+  MemoryStats windowMems_;
+};
+
+std::unique_ptr<WindowSubPartitionedSortBenchmark> benchmark;
+auto recorder = std::make_shared<BenchmarkRecorder>();
+
+void doSortRun(
+    uint32_t,
+    const std::string& recordName,
+    int32_t numSubPartitions,
+    const std::string& key,
+    const std::string& aggregate) {
+  benchmark->run(recordName, key, aggregate, numSubPartitions);
+}
+
+#define BENCHMARK_AND_RECORD_HEAD(_num_, _name_, _key_, _agg_) \
+  BENCHMARK_NAMED_PARAM(                                       \
+      doSortRun,                                               \
+      num##_num_##_##_name_,                                   \
+      fmt::format("num{}_{}", #_num_, #_name_),                \
+      _num_,                                                   \
+      _key_,                                                   \
+      _agg_);
+
+#define BENCHMARK_AND_RECORD_TAIL(_num_, _name_, _key_, _agg_) \
+  BENCHMARK_RELATIVE_NAMED_PARAM(                              \
+      doSortRun,                                               \
+      num##_num_##_##_name_,                                   \
+      fmt::format("num{}_{}", #_num_, #_name_),                \
+      _num_,                                                   \
+      _key_,                                                   \
+      _agg_);
+
+#define BATCHED_BENCHMARKS(_name_, _key_, _agg_)         \
+  BENCHMARK_AND_RECORD_HEAD(1, _name_, _key_, _agg_);    \
+  BENCHMARK_AND_RECORD_TAIL(2, _name_, _key_, _agg_);    \
+  BENCHMARK_AND_RECORD_TAIL(4, _name_, _key_, _agg_);    \
+  BENCHMARK_AND_RECORD_TAIL(8, _name_, _key_, _agg_);    \
+  BENCHMARK_AND_RECORD_TAIL(16, _name_, _key_, _agg_);   \
+  BENCHMARK_AND_RECORD_TAIL(32, _name_, _key_, _agg_);   \
+  BENCHMARK_AND_RECORD_TAIL(64, _name_, _key_, _agg_);   \
+  BENCHMARK_AND_RECORD_TAIL(128, _name_, _key_, _agg_);  \
+  BENCHMARK_AND_RECORD_TAIL(256, _name_, _key_, _agg_);  \
+  BENCHMARK_AND_RECORD_TAIL(512, _name_, _key_, _agg_);  \
+  BENCHMARK_AND_RECORD_TAIL(1024, _name_, _key_, _agg_); \
+  BENCHMARK_AND_RECORD_TAIL(2048, _name_, _key_, _agg_);
+
+#define AGG_BENCHMARKS(_name_, _key_)                                       \
+  BATCHED_BENCHMARKS(                                                       \
+      _name_##_INTEGER_##_key_, #_key_, fmt::format("{}(i32)", (#_name_))); \
+  BATCHED_BENCHMARKS(                                                       \
+      _name_##_REAL_##_key_, #_key_, fmt::format("{}(f32)", (#_name_)));    \
+  BATCHED_BENCHMARKS(                                                       \
+      _name_##_INTEGER_NULLS_##_key_,                                       \
+      #_key_,                                                               \
+      fmt::format("{}(i32_halfnull)", (#_name_)));                          \
+  BATCHED_BENCHMARKS(                                                       \
+      _name_##_REAL_NULLS_##_key_,                                          \
+      #_key_,                                                               \
+      fmt::format("{}(f32_halfnull)", (#_name_)));
+
+#define MULTI_KEY_AGG_BENCHMARKS(_name_, _key1_, _key2_) \
+  BATCHED_BENCHMARKS(                                    \
+      _name_##_BIGINT_##_key1_##_key2_,                  \
+      fmt::format("{},{}", (#_key1_), (#_key2_)),        \
+      fmt::format("{}(i64)", (#_name_)));                \
+  BATCHED_BENCHMARKS(                                    \
+      _name_##_BIGINT_NULLS_##_key1_##_key2_,            \
+      fmt::format("{},{}", (#_key1_), (#_key2_)),        \
+      fmt::format("{}(i64_halfnull)", (#_name_)));       \
+  BATCHED_BENCHMARKS(                                    \
+      _name_##_DOUBLE_##_key1_##_key2_,                  \
+      fmt::format("{},{}", (#_key1_), (#_key2_)),        \
+      fmt::format("{}(f64)", (#_name_)));                \
+  BATCHED_BENCHMARKS(                                    \
+      _name_##_DOUBLE_NULLS_##_key1_##_key2_,            \
+      fmt::format("{},{}", (#_key1_), (#_key2_)),        \
+      fmt::format("{}(f64_halfnull)", (#_name_)));
+
+// Count(1) aggregate.
+BATCHED_BENCHMARKS(count_k_array, "k_array", "count(1)");
+BATCHED_BENCHMARKS(count_k_norm, "k_norm", "count(1)");
+BATCHED_BENCHMARKS(count_k_hash, "k_hash", "count(1)");
+BATCHED_BENCHMARKS(count_k_array_k_hash, "k_array,i32", "count(1)");
+BENCHMARK_DRAW_LINE();
+
+// Count aggregate.
+AGG_BENCHMARKS(count, k_array)
+AGG_BENCHMARKS(count, k_norm)
+AGG_BENCHMARKS(count, k_hash)
+MULTI_KEY_AGG_BENCHMARKS(count, k_array, i32)
+MULTI_KEY_AGG_BENCHMARKS(count, k_array, i64)
+MULTI_KEY_AGG_BENCHMARKS(count, k_hash, f32)
+MULTI_KEY_AGG_BENCHMARKS(count, k_hash, f64)
+BENCHMARK_DRAW_LINE();
+
+// Avg aggregate.
+AGG_BENCHMARKS(avg, k_array)
+AGG_BENCHMARKS(avg, k_norm)
+AGG_BENCHMARKS(avg, k_hash)
+MULTI_KEY_AGG_BENCHMARKS(avg, k_array, i32)
+MULTI_KEY_AGG_BENCHMARKS(avg, k_array, i64)
+MULTI_KEY_AGG_BENCHMARKS(avg, k_hash, f32)
+MULTI_KEY_AGG_BENCHMARKS(avg, k_hash, f64)
+BENCHMARK_DRAW_LINE();
+
+// Min aggregate.
+AGG_BENCHMARKS(min, k_array)
+AGG_BENCHMARKS(min, k_norm)
+AGG_BENCHMARKS(min, k_hash)
+MULTI_KEY_AGG_BENCHMARKS(min, k_array, i32)
+MULTI_KEY_AGG_BENCHMARKS(min, k_array, i64)
+MULTI_KEY_AGG_BENCHMARKS(min, k_hash, f32)
+MULTI_KEY_AGG_BENCHMARKS(min, k_hash, f64)
+BENCHMARK_DRAW_LINE();
+
+// Max aggregate.
+AGG_BENCHMARKS(max, k_array)
+AGG_BENCHMARKS(max, k_norm)
+AGG_BENCHMARKS(max, k_hash)
+MULTI_KEY_AGG_BENCHMARKS(max, k_array, i32)
+MULTI_KEY_AGG_BENCHMARKS(max, k_array, i64)
+MULTI_KEY_AGG_BENCHMARKS(max, k_hash, f32)
+MULTI_KEY_AGG_BENCHMARKS(max, k_hash, f64)
+BENCHMARK_DRAW_LINE();
+
+} // namespace
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+  facebook::velox::memory::MemoryManager::initialize(
+      facebook::velox::memory::MemoryManager::Options{});
+
+  benchmark = std::make_unique<WindowSubPartitionedSortBenchmark>(
+      kNumVectors, kRowsPerVector, recorder);
+  folly::runBenchmarks();
+  benchmark.reset();
+
+  std::cout << std::endl << recorder->report();
+  return 0;
+}
diff --git a/velox/exec/fuzzer/AggregationFuzzer.cpp b/velox/exec/fuzzer/AggregationFuzzer.cpp
index 98854f82d26..844e25dca97 100644
--- a/velox/exec/fuzzer/AggregationFuzzer.cpp
+++ b/velox/exec/fuzzer/AggregationFuzzer.cpp
@@ -21,8 +21,8 @@
 #include "velox/connectors/hive/TableHandle.h"
 #include "velox/dwio/dwrf/reader/DwrfReader.h"
 
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 #include "velox/exec/PartitionFunction.h"
 #include "velox/exec/fuzzer/FuzzerUtil.h"
@@ -34,11 +34,18 @@ DEFINE_bool(
     true,
     "When true, generates plans with aggregations over sorted inputs");
 
+DEFINE_bool(
+    enable_streaming_aggregations,
+    true,
+    "When true, generates plans with streaming aggregations");
+
 using facebook::velox::fuzzer::CallableSignature;
 using facebook::velox::fuzzer::SignatureTemplate;
 
 namespace facebook::velox::exec::test {
 
+using namespace facebook::velox::common::testutil;
+
 class AggregationFuzzerBase;
 
 namespace {
@@ -490,21 +497,23 @@ void makeAlternativePlansWithValues(
     const std::vector<core::ExprPtr>& projections,
     std::vector<core::PlanNodePtr>& plans) {
   // Partial -> final aggregation plan.
-  plans.push_back(PlanBuilder()
-                      .values(inputVectors)
-                      .projectExpressions(projections)
-                      .partialAggregation(groupingKeys, aggregates, masks)
-                      .finalAggregation()
-                      .planNode());
+  plans.push_back(
+      PlanBuilder()
+          .values(inputVectors)
+          .projectExpressions(projections)
+          .partialAggregation(groupingKeys, aggregates, masks)
+          .finalAggregation()
+          .planNode());
 
   // Partial -> intermediate -> final aggregation plan.
-  plans.push_back(PlanBuilder()
-                      .values(inputVectors)
-                      .projectExpressions(projections)
-                      .partialAggregation(groupingKeys, aggregates, masks)
-                      .intermediateAggregation()
-                      .finalAggregation()
-                      .planNode());
+  plans.push_back(
+      PlanBuilder()
+          .values(inputVectors)
+          .projectExpressions(projections)
+          .partialAggregation(groupingKeys, aggregates, masks)
+          .intermediateAggregation()
+          .finalAggregation()
+          .planNode());
 
   // Partial -> local exchange -> final aggregation plan.
   auto numSources = std::min<size_t>(4, inputVectors.size());
@@ -550,23 +559,25 @@ void makeAlternativePlansWithTableScan(
 // the false negatives.
 #ifndef TSAN_BUILD
   // Partial -> final aggregation plan.
-  plans.push_back(PlanBuilder()
-                      .tableScan(inputRowType)
-                      .projectExpressions(projections)
-                      .partialAggregation(groupingKeys, aggregates, masks)
-                      .localPartition(groupingKeys)
-                      .finalAggregation()
-                      .planNode());
+  plans.push_back(
+      PlanBuilder()
+          .tableScan(inputRowType)
+          .projectExpressions(projections)
+          .partialAggregation(groupingKeys, aggregates, masks)
+          .localPartition(groupingKeys)
+          .finalAggregation()
+          .planNode());
 
   // Partial -> intermediate -> final aggregation plan.
-  plans.push_back(PlanBuilder()
-                      .tableScan(inputRowType)
-                      .projectExpressions(projections)
-                      .partialAggregation(groupingKeys, aggregates, masks)
-                      .localPartition(groupingKeys)
-                      .intermediateAggregation()
-                      .finalAggregation()
-                      .planNode());
+  plans.push_back(
+      PlanBuilder()
+          .tableScan(inputRowType)
+          .projectExpressions(projections)
+          .partialAggregation(groupingKeys, aggregates, masks)
+          .localPartition(groupingKeys)
+          .intermediateAggregation()
+          .finalAggregation()
+          .planNode());
 #endif
 }
 
@@ -578,17 +589,18 @@ void makeStreamingPlansWithValues(
     const std::vector<core::ExprPtr>& projections,
     std::vector<core::PlanNodePtr>& plans) {
   // Single aggregation.
-  plans.push_back(PlanBuilder()
-                      .values(inputVectors)
-                      .projectExpressions(projections)
-                      .orderBy(groupingKeys, false)
-                      .streamingAggregation(
-                          groupingKeys,
-                          aggregates,
-                          masks,
-                          core::AggregationNode::Step::kSingle,
-                          false)
-                      .planNode());
+  plans.push_back(
+      PlanBuilder()
+          .values(inputVectors)
+          .projectExpressions(projections)
+          .orderBy(groupingKeys, false)
+          .streamingAggregation(
+              groupingKeys,
+              aggregates,
+              masks,
+              core::AggregationNode::Step::kSingle,
+              false)
+          .planNode());
 
   // Partial -> final aggregation plan.
   plans.push_back(
@@ -643,17 +655,18 @@ void makeStreamingPlansWithTableScan(
     const std::vector<core::ExprPtr>& projections,
     std::vector<core::PlanNodePtr>& plans) {
   // Single aggregation.
-  plans.push_back(PlanBuilder()
-                      .tableScan(inputRowType)
-                      .projectExpressions(projections)
-                      .orderBy(groupingKeys, false)
-                      .streamingAggregation(
-                          groupingKeys,
-                          aggregates,
-                          masks,
-                          core::AggregationNode::Step::kSingle,
-                          false)
-                      .planNode());
+  plans.push_back(
+      PlanBuilder()
+          .tableScan(inputRowType)
+          .projectExpressions(projections)
+          .orderBy(groupingKeys, false)
+          .streamingAggregation(
+              groupingKeys,
+              aggregates,
+              masks,
+              core::AggregationNode::Step::kSingle,
+              false)
+          .planNode());
 
   // Partial -> final aggregation plan.
   plans.push_back(
@@ -724,7 +737,7 @@ bool AggregationFuzzer::verifyAggregation(
   std::vector<PlanWithSplits> plans;
   plans.push_back({firstPlan, {}});
 
-  auto directory = exec::test::TempDirectoryPath::create();
+  auto directory = TempDirectoryPath::create();
 
   // Alternate between using Values and TableScan node.
 
@@ -741,7 +754,7 @@ bool AggregationFuzzer::verifyAggregation(
         projections,
         tableScanPlans);
 
-    if (!groupingKeys.empty()) {
+    if (FLAGS_enable_streaming_aggregations && !groupingKeys.empty()) {
       // Use OrderBy + StreamingAggregation on original input.
       makeStreamingPlansWithTableScan(
           groupingKeys,
@@ -772,7 +785,7 @@ bool AggregationFuzzer::verifyAggregation(
     makeAlternativePlansWithValues(
         groupingKeys, aggregates, masks, flatInput, projections, valuesPlans);
 
-    if (!groupingKeys.empty()) {
+    if (FLAGS_enable_streaming_aggregations && !groupingKeys.empty()) {
       // Use OrderBy + StreamingAggregation on original input.
       makeStreamingPlansWithValues(
           groupingKeys, aggregates, masks, input, projections, valuesPlans);
@@ -839,7 +852,7 @@ bool AggregationFuzzer::verifySortedAggregation(
   std::vector<PlanWithSplits> plans;
   plans.push_back({firstPlan, {}});
 
-  if (!groupingKeys.empty()) {
+  if (FLAGS_enable_streaming_aggregations && !groupingKeys.empty()) {
     plans.push_back(
         {PlanBuilder()
              .values(input)
@@ -855,10 +868,10 @@ bool AggregationFuzzer::verifySortedAggregation(
          {}});
   }
 
-  std::shared_ptr<exec::test::TempDirectoryPath> directory;
+  std::shared_ptr<TempDirectoryPath> directory;
   const auto inputRowType = asRowType(input[0]->type());
   if (isTableScanSupported(inputRowType)) {
-    directory = exec::test::TempDirectoryPath::create();
+    directory = TempDirectoryPath::create();
     auto splits = makeSplits(input, directory->getPath(), writerPool_);
 
     plans.push_back(
@@ -869,7 +882,7 @@ bool AggregationFuzzer::verifySortedAggregation(
              .planNode(),
          splits});
 
-    if (!groupingKeys.empty()) {
+    if (FLAGS_enable_streaming_aggregations && !groupingKeys.empty()) {
       plans.push_back(
           {PlanBuilder()
                .tableScan(inputRowType)
@@ -1066,7 +1079,7 @@ bool AggregationFuzzer::compareEquivalentPlanResults(
               firstPlan, referenceQueryRunner_.get());
           stats_.updateReferenceQueryStats(referenceResult.second);
 
-          if (referenceResult.first) {
+          if (referenceResult.first && !referenceResult.first.value().empty()) {
             velox::fuzzer::ResultOrError expected;
             expected.result = fuzzer::mergeRowVectors(
                 referenceResult.first.value(), pool_.get());
@@ -1135,7 +1148,7 @@ bool AggregationFuzzer::verifyDistinctAggregation(
   std::vector<PlanWithSplits> plans;
   plans.push_back({firstPlan, {}});
 
-  if (!groupingKeys.empty()) {
+  if (FLAGS_enable_streaming_aggregations && !groupingKeys.empty()) {
     plans.push_back(
         {PlanBuilder()
              .values(input)
@@ -1153,10 +1166,10 @@ bool AggregationFuzzer::verifyDistinctAggregation(
 
   // Alternate between using Values and TableScan node.
 
-  std::shared_ptr<exec::test::TempDirectoryPath> directory;
+  std::shared_ptr<TempDirectoryPath> directory;
   const auto inputRowType = asRowType(input[0]->type());
   if (isTableScanSupported(inputRowType) && vectorFuzzer_.coinToss(0.5)) {
-    directory = exec::test::TempDirectoryPath::create();
+    directory = TempDirectoryPath::create();
     auto splits = makeSplits(input, directory->getPath(), writerPool_);
 
     plans.push_back(
@@ -1167,7 +1180,7 @@ bool AggregationFuzzer::verifyDistinctAggregation(
              .planNode(),
          splits});
 
-    if (!groupingKeys.empty()) {
+    if (FLAGS_enable_streaming_aggregations && !groupingKeys.empty()) {
       plans.push_back(
           {PlanBuilder()
                .tableScan(inputRowType)
diff --git a/velox/exec/fuzzer/AggregationFuzzerBase.cpp b/velox/exec/fuzzer/AggregationFuzzerBase.cpp
index 6dfbf494746..753bd019537 100644
--- a/velox/exec/fuzzer/AggregationFuzzerBase.cpp
+++ b/velox/exec/fuzzer/AggregationFuzzerBase.cpp
@@ -18,10 +18,10 @@
 #include <boost/random/uniform_int_distribution.hpp>
 #include "velox/common/base/Fs.h"
 #include "velox/common/base/VeloxException.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
 #include "velox/dwio/dwrf/writer/Writer.h"
 #include "velox/exec/Spill.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/expression/SignatureBinder.h"
 #include "velox/expression/fuzzer/ArgumentTypeFuzzer.h"
 #include "velox/vector/VectorSaver.h"
@@ -85,13 +85,15 @@ DEFINE_bool(
 
 namespace facebook::velox::exec::test {
 
+using namespace facebook::velox::common::testutil;
+
 int32_t AggregationFuzzerBase::randInt(int32_t min, int32_t max) {
   return boost::random::uniform_int_distribution<int32_t>(min, max)(rng_);
 }
 
 bool AggregationFuzzerBase::isSupportedType(const TypePtr& type) const {
   // Date / IntervalDayTime/ Unknown are not currently supported by DWRF.
-  if (type->isDate() || type->isIntervalDayTime() || type->isUnKnown()) {
+  if (type->isDate() || type->isIntervalDayTime() || type->isUnknown()) {
     return false;
   }
 
@@ -303,8 +305,9 @@ std::vector<RowVectorPtr> AggregationFuzzerBase::generateInputData(
       children.push_back(vectorFuzzer_.fuzz(inputType->childAt(j), size));
     }
 
-    input.push_back(std::make_shared<RowVector>(
-        pool_.get(), inputType, nullptr, size, std::move(children)));
+    input.push_back(
+        std::make_shared<RowVector>(
+            pool_.get(), inputType, nullptr, size, std::move(children)));
   }
 
   if (generator != nullptr) {
@@ -404,16 +407,18 @@ std::vector<RowVectorPtr> AggregationFuzzerBase::generateInputDataWithRowNumber(
         // values. This is done to introduce some repetition of key values for
         // windowing.
         auto baseVector = vectorFuzzer_.fuzz(types[i], numPartitions);
-        children.push_back(BaseVector::wrapInDictionary(
-            partitionNulls, partitionIndices, size, baseVector));
+        children.push_back(
+            BaseVector::wrapInDictionary(
+                partitionNulls, partitionIndices, size, baseVector));
       } else if (
           windowFrameBoundsSet.find(names[i]) != windowFrameBoundsSet.end()) {
         // Frame bound columns cannot have NULLs.
         children.push_back(vectorFuzzer_.fuzzNotNull(types[i], size));
       } else if (sortingKeySet.find(names[i]) != sortingKeySet.end()) {
         auto baseVector = vectorFuzzer_.fuzz(types[i], numPeerGroups);
-        children.push_back(BaseVector::wrapInDictionary(
-            sortingNulls, sortingIndices, size, baseVector));
+        children.push_back(
+            BaseVector::wrapInDictionary(
+                sortingNulls, sortingIndices, size, baseVector));
       } else {
         children.push_back(vectorFuzzer_.fuzz(types[i], size));
       }
@@ -495,7 +500,7 @@ velox::fuzzer::ResultOrError AggregationFuzzerBase::execute(
 
     int32_t spillPct{0};
     if (injectSpill) {
-      spillDirectory = exec::test::TempDirectoryPath::create();
+      spillDirectory = TempDirectoryPath::create();
       builder.spillDirectory(spillDirectory->getPath())
           .config(core::QueryConfig::kSpillEnabled, "true")
           .config(core::QueryConfig::kAggregationSpillEnabled, "true")
diff --git a/velox/exec/fuzzer/AggregationFuzzerBase.h b/velox/exec/fuzzer/AggregationFuzzerBase.h
index 246823fdd75..ce97472983c 100644
--- a/velox/exec/fuzzer/AggregationFuzzerBase.h
+++ b/velox/exec/fuzzer/AggregationFuzzerBase.h
@@ -81,7 +81,11 @@ class AggregationFuzzerBase {
                                       : getFuzzerOptions(timestampPrecision),
             pool_.get()} {
     filesystems::registerLocalFileSystem();
-    registerHiveConnector(hiveConfigs);
+    // Fuzzer test generates a lot of files and directories. Disable file
+    // handle cache to avoid EBADF errors.
+    auto configs = hiveConfigs;
+    configs[connector::hive::HiveConfig::kEnableFileHandleCache] = "false";
+    registerHiveConnector(configs);
     dwrf::registerDwrfReaderFactory();
     dwrf::registerDwrfWriterFactory();
 
@@ -121,6 +125,7 @@ class AggregationFuzzerBase {
     opts.stringVariableLength = true;
     opts.stringLength = 4'000;
     opts.nullRatio = FLAGS_null_ratio;
+    opts.useRandomNullPattern = true;
     opts.timestampPrecision = timestampPrecision;
     return opts;
   }
diff --git a/velox/exec/fuzzer/AggregationFuzzerRunner.h b/velox/exec/fuzzer/AggregationFuzzerRunner.h
index 6aa044d84ef..65f58aec142 100644
--- a/velox/exec/fuzzer/AggregationFuzzerRunner.h
+++ b/velox/exec/fuzzer/AggregationFuzzerRunner.h
@@ -107,13 +107,13 @@ class AggregationFuzzerRunner {
     facebook::velox::parse::registerTypeResolver();
     facebook::velox::serializer::presto::PrestoVectorSerde::
         registerVectorSerde();
-    if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kPresto)) {
+    if (!isRegisteredNamedVectorSerde("Presto")) {
       serializer::presto::PrestoVectorSerde::registerNamedVectorSerde();
     }
-    if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kCompactRow)) {
+    if (!isRegisteredNamedVectorSerde("CompactRow")) {
       serializer::CompactRowVectorSerde::registerNamedVectorSerde();
     }
-    if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kUnsafeRow)) {
+    if (!isRegisteredNamedVectorSerde("UnsafeRow")) {
       serializer::spark::UnsafeRowVectorSerde::registerNamedVectorSerde();
     }
     facebook::velox::filesystems::registerLocalFileSystem();
diff --git a/velox/exec/fuzzer/CMakeLists.txt b/velox/exec/fuzzer/CMakeLists.txt
index a826e6785ad..99e0e47e9f2 100644
--- a/velox/exec/fuzzer/CMakeLists.txt
+++ b/velox/exec/fuzzer/CMakeLists.txt
@@ -12,6 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# Generate Thrift library for LocalRunnerService early since velox_fuzzer_util
+# depends on it when VELOX_ENABLE_REMOTE_FUNCTIONS is enabled.
+if(VELOX_ENABLE_REMOTE_FUNCTIONS)
+  include(FBThriftCppLibrary)
+  add_fbthrift_cpp_library(
+    local_runner_service_thrift
+    if/LocalRunnerService.thrift
+    SERVICES
+    LocalRunnerService
+  )
+  target_compile_options(local_runner_service_thrift PRIVATE -Wno-error=deprecated-declarations)
+endif()
+
 add_library(
   velox_fuzzer_util
   ReferenceQueryRunner.cpp
@@ -26,6 +39,30 @@ add_library(
   FuzzerUtil.cpp
   PrestoSql.cpp
 )
+velox_add_test_headers(
+  velox_fuzzer_util
+  DuckQueryRunner.h
+  DuckQueryRunnerToSqlPlanNodeVisitor.h
+  FuzzerUtil.h
+  PrestoQueryRunner.h
+  PrestoQueryRunnerIntermediateTypeTransforms.h
+  PrestoQueryRunnerIntervalTransform.h
+  PrestoQueryRunnerJsonTransform.h
+  PrestoQueryRunnerTimestampWithTimeZoneTransform.h
+  PrestoQueryRunnerToSqlPlanNodeVisitor.h
+  PrestoSql.h
+  ReferenceQueryRunner.h
+  VeloxQueryRunner.h
+)
+
+# TODO Add VeloxQueryRunner to velox_fuzzer_util to support in
+# ExpressionFuzzerTest. More information can be found here:
+# https://github.com/facebookincubator/velox/issues/15414
+if(VELOX_ENABLE_REMOTE_FUNCTIONS)
+  target_sources(velox_fuzzer_util PRIVATE VeloxQueryRunner.cpp)
+  target_link_libraries(velox_fuzzer_util local_runner_service_thrift)
+  target_include_directories(velox_fuzzer_util PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
+endif()
 
 target_link_libraries(
   velox_fuzzer_util
@@ -35,8 +72,7 @@ target_link_libraries(
   velox_exec_test_lib
   velox_expression_functions
   velox_presto_types
-  cpr::cpr
-  Boost::regex
+  CURL::libcurl
   velox_presto_type_parser
   Folly::folly
   velox_hive_connector
@@ -46,11 +82,16 @@ target_link_libraries(
 )
 
 add_library(velox_aggregation_fuzzer_base AggregationFuzzerBase.cpp)
+velox_add_test_headers(
+  velox_aggregation_fuzzer_base
+  AggregationFuzzerBase.h
+  AggregationFuzzerOptions.h
+)
 
 target_link_libraries(
   velox_aggregation_fuzzer_base
   velox_exec_test_lib
-  velox_temp_path
+  velox_test_util
   velox_common_base
   velox_file
   velox_hive_connector
@@ -65,6 +106,7 @@ target_link_libraries(
 )
 
 add_library(velox_aggregation_fuzzer AggregationFuzzer.cpp)
+velox_add_test_headers(velox_aggregation_fuzzer AggregationFuzzer.h AggregationFuzzerRunner.h)
 
 target_link_libraries(
   velox_aggregation_fuzzer
@@ -77,6 +119,7 @@ target_link_libraries(
 )
 
 add_library(velox_window_fuzzer WindowFuzzer.cpp)
+velox_add_test_headers(velox_window_fuzzer WindowFuzzer.h WindowFuzzerRunner.h)
 
 target_link_libraries(
   velox_window_fuzzer
@@ -86,13 +129,14 @@ target_link_libraries(
   velox_exec_test_lib
   velox_expression_test_utility
   velox_aggregation_fuzzer_base
-  velox_temp_path
+  velox_test_util
 )
 
-add_library(velox_row_number_fuzzer_base_lib RowNumberFuzzerBase.cpp)
+add_library(velox_spill_fuzzer_base_lib SpillFuzzerBase.cpp)
+velox_add_test_headers(velox_spill_fuzzer_base_lib SpillFuzzerBase.h)
 
 target_link_libraries(
-  velox_row_number_fuzzer_base_lib
+  velox_spill_fuzzer_base_lib
   velox_dwio_dwrf_reader
   velox_fuzzer_util
   velox_vector_fuzzer
@@ -100,10 +144,11 @@ target_link_libraries(
 )
 
 add_library(velox_row_number_fuzzer_lib RowNumberFuzzer.cpp)
+velox_add_test_headers(velox_row_number_fuzzer_lib RowNumberFuzzer.h)
 
 target_link_libraries(
   velox_row_number_fuzzer_lib
-  velox_row_number_fuzzer_base_lib
+  velox_spill_fuzzer_base_lib
   velox_type
   velox_expression_test_utility
 )
@@ -114,10 +159,11 @@ add_executable(velox_row_number_fuzzer RowNumberFuzzerRunner.cpp)
 target_link_libraries(velox_row_number_fuzzer velox_row_number_fuzzer_lib)
 
 add_library(velox_topn_row_number_fuzzer_lib TopNRowNumberFuzzer.cpp)
+velox_add_test_headers(velox_topn_row_number_fuzzer_lib TopNRowNumberFuzzer.h)
 
 target_link_libraries(
   velox_topn_row_number_fuzzer_lib
-  velox_row_number_fuzzer_base_lib
+  velox_spill_fuzzer_base_lib
   velox_type
   velox_expression_test_utility
 )
@@ -125,10 +171,31 @@ target_link_libraries(
 # TopNRowNumber Fuzzer.
 add_executable(velox_topn_row_number_fuzzer TopNRowNumberFuzzerRunner.cpp)
 
-target_link_libraries(velox_topn_row_number_fuzzer velox_topn_row_number_fuzzer_lib)
+target_link_libraries(
+  velox_topn_row_number_fuzzer
+  velox_topn_row_number_fuzzer_lib
+  velox_functions_prestosql
+  velox_window
+)
+
+add_library(velox_mark_distinct_fuzzer_lib MarkDistinctFuzzer.cpp)
+velox_add_test_headers(velox_mark_distinct_fuzzer_lib MarkDistinctFuzzer.h)
+
+target_link_libraries(
+  velox_mark_distinct_fuzzer_lib
+  velox_spill_fuzzer_base_lib
+  velox_type
+  velox_expression_test_utility
+)
+
+# MarkDistinct Fuzzer.
+add_executable(velox_mark_distinct_fuzzer MarkDistinctFuzzerRunner.cpp)
+
+target_link_libraries(velox_mark_distinct_fuzzer velox_mark_distinct_fuzzer_lib velox_aggregates)
 
 # Join Fuzzer.
 add_executable(velox_join_fuzzer JoinFuzzerRunner.cpp JoinFuzzer.cpp JoinMaker.cpp)
+velox_add_test_headers(velox_join_fuzzer JoinFuzzer.h JoinMaker.h)
 
 target_link_libraries(
   velox_join_fuzzer
@@ -139,7 +206,22 @@ target_link_libraries(
   velox_expression_test_utility
 )
 
+# Spatial Join Fuzzer.
+add_executable(velox_spatial_join_fuzzer SpatialJoinFuzzerRunner.cpp SpatialJoinFuzzer.cpp)
+velox_add_test_headers(velox_spatial_join_fuzzer SpatialJoinFuzzer.h)
+
+target_link_libraries(
+  velox_spatial_join_fuzzer
+  velox_type
+  velox_vector_fuzzer
+  velox_fuzzer_util
+  velox_exec_test_lib
+  velox_expression_test_utility
+  velox_vector_test_lib
+)
+
 add_library(velox_writer_fuzzer WriterFuzzer.cpp)
+velox_add_test_headers(velox_writer_fuzzer WriterFuzzer.h WriterFuzzerRunner.h)
 
 target_link_libraries(
   velox_writer_fuzzer
@@ -148,7 +230,7 @@ target_link_libraries(
   velox_vector_fuzzer
   velox_exec_test_lib
   velox_expression_test_utility
-  velox_temp_path
+  velox_test_util
   velox_vector_test_lib
   velox_dwio_faulty_file_sink
   velox_file_test_utils
@@ -160,6 +242,7 @@ add_executable(
   MemoryArbitrationFuzzerRunner.cpp
   MemoryArbitrationFuzzer.cpp
 )
+velox_add_test_headers(velox_memory_arbitration_fuzzer MemoryArbitrationFuzzer.h)
 
 target_link_libraries(
   velox_memory_arbitration_fuzzer
@@ -167,6 +250,8 @@ target_link_libraries(
   velox_fuzzer_util
   velox_type
   velox_vector_fuzzer
+  velox_dwio_dwrf_reader
+  velox_dwio_dwrf_writer
   velox_exec_test_lib
   velox_expression_test_utility
   velox_functions_prestosql
@@ -174,6 +259,7 @@ target_link_libraries(
 )
 
 add_library(velox_cache_fuzzer_lib CacheFuzzer.cpp)
+velox_add_test_headers(velox_cache_fuzzer_lib CacheFuzzer.h)
 
 # Cache Fuzzer
 add_executable(velox_cache_fuzzer CacheFuzzerRunner.cpp)
@@ -183,7 +269,7 @@ target_link_libraries(velox_cache_fuzzer velox_cache_fuzzer_lib velox_fuzzer_uti
 target_link_libraries(
   velox_cache_fuzzer_lib
   velox_dwio_common
-  velox_temp_path
+  velox_test_util
   velox_vector_test_lib
 )
 
@@ -198,6 +284,53 @@ target_link_libraries(
   velox_vector_fuzzer
 )
 
+# LocalRunnerService Library (requires FBThrift support)
+if(VELOX_ENABLE_REMOTE_FUNCTIONS)
+  add_library(velox_local_runner_service_lib LocalRunnerService.cpp)
+  velox_add_test_headers(velox_local_runner_service_lib LocalRunnerService.h)
+
+  target_link_libraries(
+    velox_local_runner_service_lib
+    local_runner_service_thrift
+    velox_core
+    velox_exec
+    velox_exec_test_lib
+    velox_expression
+    velox_functions_prestosql
+    velox_common_base
+    velox_memory
+    Folly::folly
+    FBThrift::thriftcpp2
+    gflags
+    glog::glog
+  )
+
+  target_include_directories(velox_local_runner_service_lib PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
+
+  # LocalRunnerService Executable
+  add_executable(velox_local_runner_service_runner LocalRunnerServiceRunner.cpp)
+
+  target_link_libraries(
+    velox_local_runner_service_runner
+    velox_local_runner_service_lib
+    velox_functions_prestosql
+    gtest
+    gflags
+    Folly::folly
+  )
+endif()
+
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
 endif()
+
+velox_add_library(velox_expression_transformer INTERFACE HEADERS ExprTransformer.h)
+
+velox_add_library(
+  velox_fuzzer_generator_verifier
+  INTERFACE
+  HEADERS
+  InputGenerator.h
+  ResultVerifier.h
+  TransformResultVerifier.h
+)
diff --git a/velox/exec/fuzzer/CacheFuzzer.cpp b/velox/exec/fuzzer/CacheFuzzer.cpp
index 57d364f7450..b518396413d 100644
--- a/velox/exec/fuzzer/CacheFuzzer.cpp
+++ b/velox/exec/fuzzer/CacheFuzzer.cpp
@@ -23,10 +23,11 @@
 #include "velox/common/caching/SsdCache.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/file/tests/FaultyFileSystem.h"
+#include "velox/common/io/IoStatistics.h"
 #include "velox/common/memory/Memory.h"
 #include "velox/common/memory/MmapAllocator.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/dwio/common/CachedBufferedInput.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 DEFINE_int32(steps, 10, "Number of plans to generate and test.");
 
@@ -88,6 +89,7 @@ using namespace facebook::velox::dwio::common;
 using namespace facebook::velox::tests::utils;
 
 namespace facebook::velox::exec {
+using namespace facebook::velox::common::testutil;
 namespace {
 
 class CacheFuzzer {
@@ -157,11 +159,17 @@ class CacheFuzzer {
   // instead of random location for cache reuse.
   std::vector<std::vector<std::pair<int32_t, int32_t>>> fileFragments_;
   std::vector<std::unique_ptr<CachedBufferedInput>> inputs_;
-  std::shared_ptr<exec::test::TempDirectoryPath> sourceDataDir_;
-  std::shared_ptr<exec::test::TempDirectoryPath> cacheDataDir_;
+  std::shared_ptr<TempDirectoryPath> sourceDataDir_;
+  std::shared_ptr<TempDirectoryPath> cacheDataDir_;
   std::unique_ptr<memory::MemoryManager> memoryManager_;
   std::unique_ptr<folly::IOThreadPoolExecutor> executor_;
   std::shared_ptr<AsyncDataCache> cache_;
+
+  std::shared_ptr<io::IoStatistics> dataIoStats_{
+      std::make_shared<io::IoStatistics>()};
+  std::shared_ptr<io::IoStatistics> metadataIoStats_{
+      std::make_shared<io::IoStatistics>()};
+
   // Save the config for the last iteration so they can be potentially reused
   // after restart.
   int64_t lastMemoryCacheBytes_;
@@ -189,9 +197,8 @@ CacheFuzzer::CacheFuzzer(size_t initialSeed) {
 
 void CacheFuzzer::initSourceDataFiles() {
   // Skip errors on source data files.
-  sourceDataDir_ = exec::test::TempDirectoryPath::create();
-  cacheDataDir_ =
-      exec::test::TempDirectoryPath::create(FLAGS_enable_file_faulty_injection);
+  sourceDataDir_ = TempDirectoryPath::create();
+  cacheDataDir_ = TempDirectoryPath::create(FLAGS_enable_file_faulty_injection);
   fs_ = filesystems::getFileSystem(sourceDataDir_->getPath(), nullptr);
 
   // Create files with random sizes.
@@ -370,27 +377,30 @@ void CacheFuzzer::initializeCache(bool restartCache) {
 }
 
 void CacheFuzzer::initializeInputs() {
-  const auto readOptions = io::ReaderOptions(pool_.get());
+  io::ReaderOptions readOptions(pool_.get());
+  readOptions.setDataIoStats(dataIoStats_);
+  readOptions.setMetadataIoStats(metadataIoStats_);
   auto tracker = std::make_shared<ScanTracker>(
       "testTracker", nullptr, 256 << 10 /*256KB*/);
-  auto ioStats = std::make_shared<IoStatistics>();
-  auto fsStats = std::make_shared<filesystems::File::IoStats>();
+  auto ioStatistics = std::make_shared<IoStatistics>();
+  auto ioStats = std::make_shared<IoStats>();
   inputs_.reserve(FLAGS_num_source_files);
   for (auto i = 0; i < FLAGS_num_source_files; ++i) {
     // Initialize buffered input.
     auto readFile = fs_->openFileForRead(fileNames_[i]);
     auto const withExecutor = !folly::Random::oneIn(3, rng_);
-    inputs_.emplace_back(std::make_unique<CachedBufferedInput>(
-        std::move(readFile),
-        MetricsLog::voidLog(),
-        fileIds_[i], // NOLINT
-        cache_.get(),
-        tracker,
-        fileIds_[i], // NOLINT
-        ioStats,
-        fsStats,
-        withExecutor ? executor_.get() : nullptr,
-        readOptions));
+    inputs_.emplace_back(
+        std::make_unique<CachedBufferedInput>(
+            std::move(readFile),
+            MetricsLog::voidLog(),
+            fileIds_[i], // NOLINT
+            cache_.get(),
+            tracker,
+            fileIds_[i], // NOLINT
+            ioStatistics,
+            ioStats,
+            withExecutor ? executor_.get() : nullptr,
+            readOptions));
 
     // Divide file into fragments.
     std::vector<std::pair<int32_t, int32_t>> fragments;
diff --git a/velox/exec/fuzzer/DuckQueryRunnerToSqlPlanNodeVisitor.cpp b/velox/exec/fuzzer/DuckQueryRunnerToSqlPlanNodeVisitor.cpp
index 388e67ca36a..4ec4f00ca5c 100644
--- a/velox/exec/fuzzer/DuckQueryRunnerToSqlPlanNodeVisitor.cpp
+++ b/velox/exec/fuzzer/DuckQueryRunnerToSqlPlanNodeVisitor.cpp
@@ -277,7 +277,8 @@ void DuckQueryRunnerToSqlPlanNodeVisitor::visit(
     sql << inputType->nameOf(i);
   }
 
-  sql << ", row_number() OVER (";
+  sql << ", " << core::TopNRowNumberNode::rankFunctionName(node.rankFunction())
+      << "() OVER (";
 
   const auto& partitionKeys = node.partitionKeys();
   if (!partitionKeys.empty()) {
diff --git a/velox/exec/fuzzer/DuckQueryRunnerToSqlPlanNodeVisitor.h b/velox/exec/fuzzer/DuckQueryRunnerToSqlPlanNodeVisitor.h
index d7566ed833f..b7a655b7a88 100644
--- a/velox/exec/fuzzer/DuckQueryRunnerToSqlPlanNodeVisitor.h
+++ b/velox/exec/fuzzer/DuckQueryRunnerToSqlPlanNodeVisitor.h
@@ -92,6 +92,16 @@ class DuckQueryRunnerToSqlPlanNodeVisitor : public PrestoSqlPlanNodeVisitor {
     VELOX_NYI();
   }
 
+  void visit(const core::EnforceDistinctNode&, core::PlanNodeVisitorContext&)
+      const override {
+    VELOX_NYI();
+  }
+
+  void visit(const core::MarkSortedNode&, core::PlanNodeVisitorContext&)
+      const override {
+    VELOX_NYI();
+  }
+
   void visit(const core::MergeExchangeNode&, core::PlanNodeVisitorContext&)
       const override {
     VELOX_NYI();
@@ -177,6 +187,11 @@ class DuckQueryRunnerToSqlPlanNodeVisitor : public PrestoSqlPlanNodeVisitor {
     VELOX_NYI();
   }
 
+  void visit(const core::MixedUnionNode&, core::PlanNodeVisitorContext&)
+      const override {
+    VELOX_NYI();
+  }
+
  private:
   std::unordered_set<std::string> aggregateFunctionNames_;
 };
diff --git a/velox/exec/fuzzer/ExchangeFuzzer.cpp b/velox/exec/fuzzer/ExchangeFuzzer.cpp
index 4443b24fba2..9cd60c2a600 100644
--- a/velox/exec/fuzzer/ExchangeFuzzer.cpp
+++ b/velox/exec/fuzzer/ExchangeFuzzer.cpp
@@ -143,7 +143,7 @@ class ExchangeFuzzer : public VectorTestBase {
     }
     auto partialAggPlan =
         exec::test::PlanBuilder()
-            .exchange(leafPlan->outputType(), VectorSerde::Kind::kPresto)
+            .exchange(leafPlan->outputType(), "Presto")
             .partialAggregation({}, makeAggregates(rowType, 1))
             .partitionedOutput({}, 1)
             .planNode();
@@ -158,14 +158,13 @@ class ExchangeFuzzer : public VectorTestBase {
       addRemoteSplits(task, leafTaskIds);
     }
 
-    auto plan =
-        exec::test::PlanBuilder()
-            .exchange(partialAggPlan->outputType(), VectorSerde::Kind::kPresto)
-            .finalAggregation(
-                {},
-                makeAggregates(*partialAggPlan->outputType(), 0),
-                rawInputTypes)
-            .planNode();
+    auto plan = exec::test::PlanBuilder()
+                    .exchange(partialAggPlan->outputType(), "Presto")
+                    .finalAggregation(
+                        {},
+                        makeAggregates(*partialAggPlan->outputType(), 0),
+                        rawInputTypes)
+                    .planNode();
 
     try {
       // Create the Task to do the final aggregation using a TaskCursor so we
@@ -409,9 +408,11 @@ class ExchangeFuzzer : public VectorTestBase {
         LOG(INFO) << "Terminating with error";
         exit(1);
       }
-      LOG(INFO) << "Memory after run="
-                << succinctBytes(memory::AllocationTraits::pageBytes(
-                       memory::memoryManager()->allocator()->numAllocated()));
+      LOG(INFO)
+          << "Memory after run="
+          << succinctBytes(
+                 memory::AllocationTraits::pageBytes(
+                     memory::memoryManager()->allocator()->numAllocated()));
 
       if (FLAGS_duration_sec == 0 && FLAGS_steps &&
           counter + 1 >= FLAGS_steps) {
@@ -572,13 +573,13 @@ int main(int argc, char** argv) {
   aggregate::prestosql::registerAllAggregateFunctions();
   parse::registerTypeResolver();
   serializer::presto::PrestoVectorSerde::registerVectorSerde();
-  if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kPresto)) {
+  if (!isRegisteredNamedVectorSerde("Presto")) {
     serializer::presto::PrestoVectorSerde::registerNamedVectorSerde();
   }
-  if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kCompactRow)) {
+  if (!isRegisteredNamedVectorSerde("CompactRow")) {
     serializer::CompactRowVectorSerde::registerNamedVectorSerde();
   }
-  if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kUnsafeRow)) {
+  if (!isRegisteredNamedVectorSerde("UnsafeRow")) {
     serializer::spark::UnsafeRowVectorSerde::registerNamedVectorSerde();
   }
   exec::ExchangeSource::registerFactory(exec::test::createLocalExchangeSource);
diff --git a/velox/exec/fuzzer/FuzzerUtil.cpp b/velox/exec/fuzzer/FuzzerUtil.cpp
index 04fc59363a8..60df03452e3 100644
--- a/velox/exec/fuzzer/FuzzerUtil.cpp
+++ b/velox/exec/fuzzer/FuzzerUtil.cpp
@@ -17,6 +17,7 @@
 #include <re2/re2.h>
 #include <filesystem>
 #include "velox/common/memory/SharedArbitrator.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
 #include "velox/dwio/catalog/fbhive/FileUtils.h"
@@ -24,6 +25,7 @@
 #include "velox/exec/fuzzer/DuckQueryRunner.h"
 #include "velox/exec/fuzzer/PrestoQueryRunner.h"
 #include "velox/expression/SignatureBinder.h"
+#include "velox/functions/prestosql/types/IPAddressType.h"
 #include "velox/functions/prestosql/types/IPPrefixType.h"
 
 using namespace facebook::velox::dwio::catalog::fbhive;
@@ -247,6 +249,35 @@ bool containsUnsupportedTypes(const TypePtr& type) {
       containsType(type, INTERVAL_DAY_TIME());
 }
 
+bool containsIPAddress(const TypePtr& type) {
+  if (type->isArray()) {
+    const auto& elementType = type->asArray().elementType();
+    if (isIPAddressType(elementType)) {
+      return true;
+    }
+    return containsIPAddress(elementType);
+  }
+
+  if (type->isMap()) {
+    const auto& keyType = type->asMap().keyType();
+    const auto& valueType = type->asMap().valueType();
+    if (isIPAddressType(keyType) || isIPAddressType(valueType)) {
+      return true;
+    }
+    return containsIPAddress(keyType) || containsIPAddress(valueType);
+  }
+
+  if (type->isRow()) {
+    for (auto i = 0; i < type->size(); ++i) {
+      if (containsIPAddress(type->childAt(i))) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
 // Determine whether type is or contains typeName. typeName should be in lower
 // case.
 bool containTypeName(
@@ -323,8 +354,9 @@ TypePtr sanitizeTryResolveType(
     const exec::TypeSignature& typeSignature,
     const std::unordered_map<std::string, SignatureVariable>& variables,
     const std::unordered_map<std::string, TypePtr>& resolvedTypeVariables) {
-  return sanitize(SignatureBinder::tryResolveType(
-      typeSignature, variables, resolvedTypeVariables));
+  return sanitize(
+      SignatureBinder::tryResolveType(
+          typeSignature, variables, resolvedTypeVariables));
 }
 
 TypePtr sanitizeTryResolveType(
@@ -336,13 +368,14 @@ TypePtr sanitizeTryResolveType(
         longEnumParameterVariablesBindings,
     const std::unordered_map<std::string, VarcharEnumParameter>&
         varcharEnumParameterVariablesBindings) {
-  return sanitize(SignatureBinder::tryResolveType(
-      typeSignature,
-      variables,
-      typeVariablesBindings,
-      integerVariablesBindings,
-      longEnumParameterVariablesBindings,
-      varcharEnumParameterVariablesBindings));
+  return sanitize(
+      SignatureBinder::tryResolveType(
+          typeSignature,
+          variables,
+          typeVariablesBindings,
+          integerVariablesBindings,
+          longEnumParameterVariablesBindings,
+          varcharEnumParameterVariablesBindings));
 }
 
 void setupMemory(
@@ -359,11 +392,13 @@ void setupMemory(
   options.checkUsageLeak = true;
   options.arbitrationStateCheckCb = memoryArbitrationStateCheck;
   options.extraArbitratorConfigs = {
-      {std::string(velox::memory::SharedArbitrator::ExtraConfig::
-                       kGlobalArbitrationEnabled),
+      {std::string(
+           velox::memory::SharedArbitrator::ExtraConfig::
+               kGlobalArbitrationEnabled),
        enableGlobalArbitration ? "true" : "false"},
-      {std::string(velox::memory::SharedArbitrator::ExtraConfig::
-                       kMemoryPoolMinReclaimBytes),
+      {std::string(
+           velox::memory::SharedArbitrator::ExtraConfig::
+               kMemoryPoolMinReclaimBytes),
        "0B"}};
   facebook::velox::memory::MemoryManager::initialize(options);
 }
@@ -378,7 +413,8 @@ void registerHiveConnector(
   auto hiveConnector = factory.newConnector(
       kHiveConnectorId,
       std::make_shared<config::ConfigBase>(std::move(configs)));
-  connector::registerConnector(hiveConnector);
+  connector::ConnectorRegistry::global().insert(
+      hiveConnector->connectorId(), hiveConnector);
 }
 
 std::unique_ptr<ReferenceQueryRunner> setupReferenceQueryRunner(
diff --git a/velox/exec/fuzzer/FuzzerUtil.h b/velox/exec/fuzzer/FuzzerUtil.h
index 5ad39818ca5..da306395546 100644
--- a/velox/exec/fuzzer/FuzzerUtil.h
+++ b/velox/exec/fuzzer/FuzzerUtil.h
@@ -93,6 +93,17 @@ RowTypePtr concat(const RowTypePtr& a, const RowTypePtr& b);
 /// TODO Investigate mismatches reported when comparing Varbinary.
 bool containsUnsupportedTypes(const TypePtr& type);
 
+/// Checks if a type contains IPADDRESS in any container position (array
+/// element, map key, or map value) at any nesting level. Returns false for
+/// bare IPADDRESS or IPADDRESS directly in a ROW field.
+///
+/// Presto's Int128ArrayBlock doesn't implement compareTo(), which causes
+/// failures when IPADDRESS appears in containers that require element-level
+/// comparison (arrays, map keys, map values).
+///
+/// See: https://github.com/prestodb/presto/issues/26836
+bool containsIPAddress(const TypePtr& type);
+
 /// Determines whether the signature has an argument that contains typeName.
 /// typeName should be in lower case.
 bool usesInputTypeName(
diff --git a/velox/exec/fuzzer/JoinFuzzer.cpp b/velox/exec/fuzzer/JoinFuzzer.cpp
index 3edbc634cbe..33801b3d4a3 100644
--- a/velox/exec/fuzzer/JoinFuzzer.cpp
+++ b/velox/exec/fuzzer/JoinFuzzer.cpp
@@ -16,6 +16,8 @@
 #include "velox/exec/fuzzer/JoinFuzzer.h"
 #include <boost/random/uniform_int_distribution.hpp>
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/dwio/dwrf/RegisterDwrfReader.h"
 #include "velox/dwio/dwrf/RegisterDwrfWriter.h"
@@ -25,7 +27,6 @@
 #include "velox/exec/fuzzer/JoinMaker.h"
 #include "velox/exec/fuzzer/ReferenceQueryRunner.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
 DEFINE_int32(steps, 10, "Number of plans to generate and test.");
@@ -66,6 +67,7 @@ DEFINE_double(
     "The chance of testing plans with filters enabled.");
 
 namespace facebook::velox::exec {
+using namespace facebook::velox::common::testutil;
 
 namespace {
 
@@ -88,6 +90,7 @@ class JoinFuzzer {
     opts.stringVariableLength = true;
     opts.stringLength = 100;
     opts.nullRatio = FLAGS_null_ratio;
+    opts.useRandomNullPattern = true;
     opts.timestampPrecision =
         VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
     return opts;
@@ -210,7 +213,8 @@ JoinFuzzer::JoinFuzzer(
   auto hiveConnector = factory.newConnector(
       test::kHiveConnectorId,
       std::make_shared<config::ConfigBase>(std::move(hiveConfig)));
-  connector::registerConnector(hiveConnector);
+  connector::ConnectorRegistry::global().insert(
+      hiveConnector->connectorId(), hiveConnector);
   dwrf::registerDwrfReaderFactory();
   dwrf::registerDwrfWriterFactory();
 
@@ -389,10 +393,10 @@ RowVectorPtr JoinFuzzer::execute(
     builder.numConcurrentSplitGroups(randInt(1, plan.numGroups));
   }
 
-  std::shared_ptr<test::TempDirectoryPath> spillDirectory;
+  std::shared_ptr<TempDirectoryPath> spillDirectory;
   int32_t spillPct{0};
   if (injectSpill) {
-    spillDirectory = exec::test::TempDirectoryPath::create();
+    spillDirectory = TempDirectoryPath::create();
     builder.config(core::QueryConfig::kSpillEnabled, true)
         .config(core::QueryConfig::kJoinSpillEnabled, true)
         .config(core::QueryConfig::kMixedGroupedModeHashJoinSpillEnabled, true)
@@ -617,7 +621,7 @@ void JoinFuzzer::verify(core::JoinType joinType) {
     }
   }
 
-  const auto tableScanDir = exec::test::TempDirectoryPath::create();
+  const auto tableScanDir = TempDirectoryPath::create();
   auto localFs = filesystems::getFileSystem(tableScanDir->getPath(), nullptr);
   std::string probePath =
       fmt::format("{}/{}", tableScanDir->getPath(), "probe");
diff --git a/velox/exec/fuzzer/JoinFuzzerRunner.cpp b/velox/exec/fuzzer/JoinFuzzerRunner.cpp
index 7c350643793..b8eefa21b67 100644
--- a/velox/exec/fuzzer/JoinFuzzerRunner.cpp
+++ b/velox/exec/fuzzer/JoinFuzzerRunner.cpp
@@ -101,18 +101,15 @@ int main(int argc, char** argv) {
   facebook::velox::filesystems::registerLocalFileSystem();
   facebook::velox::functions::prestosql::registerAllScalarFunctions();
   facebook::velox::parse::registerTypeResolver();
-  if (!isRegisteredNamedVectorSerde(
-          facebook::velox::VectorSerde::Kind::kPresto)) {
+  if (!facebook::velox::isRegisteredNamedVectorSerde("Presto")) {
     facebook::velox::serializer::presto::PrestoVectorSerde::
         registerNamedVectorSerde();
   }
-  if (!isRegisteredNamedVectorSerde(
-          facebook::velox::VectorSerde::Kind::kCompactRow)) {
+  if (!facebook::velox::isRegisteredNamedVectorSerde("CompactRow")) {
     facebook::velox::serializer::CompactRowVectorSerde::
         registerNamedVectorSerde();
   }
-  if (!isRegisteredNamedVectorSerde(
-          facebook::velox::VectorSerde::Kind::kUnsafeRow)) {
+  if (!facebook::velox::isRegisteredNamedVectorSerde("UnsafeRow")) {
     facebook::velox::serializer::spark::UnsafeRowVectorSerde::
         registerNamedVectorSerde();
   }
diff --git a/velox/exec/fuzzer/JoinMaker.cpp b/velox/exec/fuzzer/JoinMaker.cpp
index 07e2b66d6b3..0addc7f94ba 100644
--- a/velox/exec/fuzzer/JoinMaker.cpp
+++ b/velox/exec/fuzzer/JoinMaker.cpp
@@ -62,10 +62,11 @@ std::vector<core::PlanNodePtr> makeSourcesForPartitionedJoinPlan(
 
   std::vector<core::PlanNodePtr> sourceNodes;
   for (const auto& sourceInput : sourceInputs) {
-    sourceNodes.push_back(test::PlanBuilder(planNodeIdGenerator)
-                              .values(sourceInput)
-                              .projectExpressions(joinSource->projections())
-                              .planNode());
+    sourceNodes.push_back(
+        test::PlanBuilder(planNodeIdGenerator)
+            .values(sourceInput)
+            .projectExpressions(joinSource->projections())
+            .planNode());
   }
 
   return sourceNodes;
@@ -610,7 +611,7 @@ core::JoinType flipJoinType(core::JoinType joinType) {
   auto flippedJoinType = tryFlipJoinType(joinType);
 
   if (!flippedJoinType.has_value()) {
-    VELOX_UNSUPPORTED(fmt::format("Unable to flip join type: {}", joinType));
+    VELOX_UNSUPPORTED("Unable to flip join type: {}", joinType);
   }
 
   return *flippedJoinType;
diff --git a/velox/exec/fuzzer/LocalRunnerService.cpp b/velox/exec/fuzzer/LocalRunnerService.cpp
new file mode 100644
index 00000000000..2475f6af40e
--- /dev/null
+++ b/velox/exec/fuzzer/LocalRunnerService.cpp
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/fuzzer/if/gen-cpp2/LocalRunnerService.h"
+#include <folly/executors/CPUThreadPoolExecutor.h>
+#include <folly/init/Init.h>
+#include <folly/json.h>
+#include <folly/portability/GFlags.h>
+#include <gflags/gflags.h>
+#include <glog/logging.h>
+#include <thrift/lib/cpp2/server/ThriftServer.h>
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/memory/ByteStream.h"
+#include "velox/exec/fuzzer/LocalRunnerService.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/serializers/PrestoSerializer.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::runner;
+
+namespace facebook::velox::runner {
+namespace {
+
+class StdoutCapture {
+ public:
+  StdoutCapture() {
+    oldCoutBuf_ = std::cout.rdbuf();
+    std::cout.rdbuf(buffer_.rdbuf());
+  }
+  ~StdoutCapture() {
+    std::cout.rdbuf(oldCoutBuf_);
+  }
+  std::string str() {
+    return buffer_.str();
+  }
+
+ private:
+  std::stringstream buffer_;
+  std::streambuf* oldCoutBuf_;
+};
+
+std::pair<RowVectorPtr, std::string> execute(
+    const std::string& serializedPlan,
+    const std::string& queryId,
+    std::shared_ptr<memory::MemoryPool> pool) {
+  StdoutCapture stdoutCapture;
+
+  core::PlanNodePtr plan;
+  try {
+    folly::dynamic planJson = folly::parseJson(serializedPlan);
+    VLOG(1) << "Deserializing plan:\n" << serializedPlan;
+    plan = core::PlanNode::deserialize<core::PlanNode>(planJson, pool.get());
+  } catch (const std::exception& e) {
+    throw std::runtime_error(
+        fmt::format("Failed to deserialize plan: {}", e.what()));
+  }
+  VLOG(1) << "Deserialized plan:\n" << plan->toString(true, true);
+
+  try {
+    exec::test::AssertQueryBuilder queryBuilder(plan);
+    queryBuilder.config("session_timezone", "America/Los_Angeles");
+
+    std::shared_ptr<exec::Task> task;
+    auto results = queryBuilder.copyResults(pool.get(), task);
+
+    return {results, stdoutCapture.str()};
+  } catch (const std::exception& e) {
+    throw std::runtime_error(
+        fmt::format("Error executing query: {}", e.what()));
+  }
+}
+
+} // namespace
+
+std::string serializeBatch(
+    const RowVectorPtr& rowVector,
+    memory::MemoryPool* pool) {
+  std::ostringstream out;
+
+  OStreamOutputStream outputStream(&out);
+
+  auto serde = std::make_unique<serializer::presto::PrestoVectorSerde>();
+  serializer::presto::PrestoVectorSerde::PrestoOptions options;
+
+  auto serializer = serde->createBatchSerializer(pool, &options);
+  serializer->serialize(rowVector, &outputStream);
+
+  return out.str();
+}
+
+std::vector<Batch> convertToBatches(
+    const std::vector<RowVectorPtr>& rowVectors,
+    memory::MemoryPool* pool) {
+  std::vector<Batch> results;
+
+  if (rowVectors.empty()) {
+    return results;
+  }
+
+  auto leafPool = pool->addLeafChild("batchSerialization");
+
+  for (const auto& rowVector : rowVectors) {
+    Batch result;
+    const auto& rowType = rowVector->type()->asRow();
+
+    for (auto i = 0; i < rowType.size(); ++i) {
+      result.columnNames()->push_back(rowType.nameOf(i));
+      result.columnTypes()->push_back(rowType.childAt(i)->toString());
+    }
+
+    std::string serializedData = serializeBatch(rowVector, leafPool.get());
+    result.serializedData() = std::move(serializedData);
+
+    results.push_back(std::move(result));
+  }
+
+  return results;
+}
+
+void LocalRunnerServiceHandler::execute(
+    ExecutePlanResponse& response,
+    std::unique_ptr<ExecutePlanRequest> request) {
+  VLOG(1) << "Received executePlan request";
+
+  auto rootPool = memory::memoryManager()->addRootPool();
+  auto pool = rootPool->addLeafChild("localRunnerHandler");
+
+  RowVectorPtr results;
+  std::string output;
+
+  try {
+    VLOG(1) << "Executing plan in service handler";
+    std::tie(results, output) =
+        ::execute(*request->serializedPlan(), *request->queryId(), pool);
+
+    VLOG(1) << fmt::format(
+        "Result:\nresult rowVector: {}\nstdout: {}",
+        results->toString(true),
+        output);
+  } catch (const std::exception& e) {
+    VLOG(1) << "Exception executing plan: " << e.what();
+    response.success() = false;
+    response.errorMessage() = e.what();
+    return;
+  }
+
+  VLOG(1) << "Converting results to Thrift response";
+  auto resultBatches = convertToBatches({results}, rootPool.get());
+  response.results() = std::move(resultBatches);
+  response.output() = output;
+  response.success() = true;
+  VLOG(1) << "Response sent";
+}
+
+} // namespace facebook::velox::runner
diff --git a/velox/exec/fuzzer/LocalRunnerService.h b/velox/exec/fuzzer/LocalRunnerService.h
new file mode 100644
index 00000000000..dbd5f5d8f17
--- /dev/null
+++ b/velox/exec/fuzzer/LocalRunnerService.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/// Thrift service implementation and library for executing Velox query plans
+/// remotely.
+///
+/// This file provides conversion utilities and a service handler for the
+/// LocalRunnerService. It enables remote execution of serialized Velox
+/// expression evaluation primarily used for fuzzing where query plans need to
+/// be executed on remote workers.
+
+#pragma once
+
+#include <folly/init/Init.h>
+#include <folly/json.h>
+#include <folly/portability/GFlags.h>
+#include <gflags/gflags.h>
+#include <glog/logging.h>
+#include <thrift/lib/cpp2/server/ThriftServer.h>
+
+#include "velox/exec/fuzzer/if/gen-cpp2/LocalRunnerService.h"
+#include "velox/vector/ComplexVector.h"
+
+namespace facebook::velox::runner {
+
+/// Converts a collection of Velox RowVectors into Thrift Batches using
+/// binary serialization.
+std::vector<Batch> convertToBatches(
+    const std::vector<RowVectorPtr>& rowVectors,
+    memory::MemoryPool* pool);
+
+/// Thrift service handler for executing Velox query plans.
+/// Executes a serialized Velox query plan. This method deserializes the plan
+/// from JSON, configures execution, runs the query plan to completion,
+/// converts results to Thrift Batches and captures any subsequent errors or
+/// output. The method returns a Thrift response containing the results.
+class LocalRunnerServiceHandler
+    : public apache::thrift::ServiceHandler<LocalRunnerService> {
+ public:
+  void execute(
+      ExecutePlanResponse& response,
+      std::unique_ptr<ExecutePlanRequest> request) override;
+};
+
+} // namespace facebook::velox::runner
diff --git a/velox/exec/fuzzer/LocalRunnerServiceRunner.cpp b/velox/exec/fuzzer/LocalRunnerServiceRunner.cpp
new file mode 100644
index 00000000000..7bb15f9d355
--- /dev/null
+++ b/velox/exec/fuzzer/LocalRunnerServiceRunner.cpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/init/Init.h>
+#include <gflags/gflags.h>
+#include <gtest/gtest.h>
+#include <thrift/lib/cpp2/server/ThriftServer.h>
+
+#include "velox/core/ITypedExpr.h"
+#include "velox/core/PlanNode.h"
+#include "velox/exec/fuzzer/LocalRunnerService.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/type/Type.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::runner;
+
+DEFINE_int32(
+    port,
+    9091,
+    "LocalRunnerService port number to be used in conjunction with ExpressionFuzzerTest flag local_runner_port.");
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+
+  folly::Init init(&argc, &argv);
+
+  memory::initializeMemoryManager(memory::MemoryManager::Options{});
+  Type::registerSerDe();
+  core::PlanNode::registerSerDe();
+  core::ITypedExpr::registerSerDe();
+  functions::prestosql::registerAllScalarFunctions();
+  functions::prestosql::registerInternalFunctions();
+
+  std::shared_ptr<apache::thrift::ThriftServer> thriftServer =
+      std::make_shared<apache::thrift::ThriftServer>();
+  thriftServer->setPort(FLAGS_port);
+  thriftServer->setInterface(std::make_shared<LocalRunnerServiceHandler>());
+  thriftServer->setNumIOWorkerThreads(1);
+  thriftServer->setNumCPUWorkerThreads(1);
+
+  VLOG(1) << "Starting LocalRunnerService";
+  thriftServer->serve();
+
+  return 0;
+}
diff --git a/velox/exec/fuzzer/MarkDistinctFuzzer.cpp b/velox/exec/fuzzer/MarkDistinctFuzzer.cpp
new file mode 100644
index 00000000000..af9ef508419
--- /dev/null
+++ b/velox/exec/fuzzer/MarkDistinctFuzzer.cpp
@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/fuzzer/MarkDistinctFuzzer.h"
+
+#include <utility>
+
+#include "velox/common/testutil/TempDirectoryPath.h"
+#include "velox/exec/fuzzer/FuzzerUtil.h"
+#include "velox/exec/fuzzer/SpillFuzzerBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+namespace facebook::velox::exec {
+using namespace facebook::velox::common::testutil;
+namespace {
+
+class MarkDistinctFuzzer : public SpillFuzzerBase {
+ public:
+  explicit MarkDistinctFuzzer(
+      size_t initialSeed,
+      std::unique_ptr<test::ReferenceQueryRunner>);
+
+ private:
+  void runSingleIteration() override;
+
+  std::pair<std::vector<std::string>, std::vector<TypePtr>>
+  generatePartitionKeys();
+
+  std::vector<RowVectorPtr> generateInput(
+      const std::vector<std::string>& keyNames,
+      const std::vector<TypePtr>& keyTypes);
+
+  // Makes the query plan: Values -> MarkDistinct -> Aggregation.
+  // MarkDistinct marks distinct rows for (groupKey, distinctKey) combinations,
+  // then aggregation uses the mask to compute count(distinct distinctKey).
+  static PlanWithSplits makeDefaultPlan(
+      const std::string& groupKey,
+      const std::string& distinctKey,
+      const std::vector<RowVectorPtr>& input);
+
+  static PlanWithSplits makePlanWithTableScan(
+      const RowTypePtr& type,
+      const std::string& groupKey,
+      const std::string& distinctKey,
+      const std::vector<Split>& splits);
+
+  void addPlansWithTableScan(
+      const std::string& tableDir,
+      const std::string& groupKey,
+      const std::string& distinctKey,
+      const std::vector<RowVectorPtr>& input,
+      std::vector<PlanWithSplits>& altPlans);
+};
+
+MarkDistinctFuzzer::MarkDistinctFuzzer(
+    size_t initialSeed,
+    std::unique_ptr<test::ReferenceQueryRunner> referenceQueryRunner)
+    : SpillFuzzerBase(initialSeed, std::move(referenceQueryRunner)) {
+  vectorFuzzer_.getMutableOptions().timestampPrecision =
+      fuzzer::FuzzerTimestampPrecision::kMilliSeconds;
+}
+
+std::pair<std::vector<std::string>, std::vector<TypePtr>>
+MarkDistinctFuzzer::generatePartitionKeys() {
+  // Generate 1-3 keys for grouping/distinct.
+  const auto numKeys = randInt(1, 3);
+  std::vector<std::string> names;
+  std::vector<TypePtr> types;
+  for (auto i = 0; i < numKeys; ++i) {
+    names.push_back(fmt::format("c{}", i));
+    types.push_back(vectorFuzzer_.randType(/*maxDepth=*/1));
+  }
+  return std::make_pair(names, types);
+}
+
+std::vector<RowVectorPtr> MarkDistinctFuzzer::generateInput(
+    const std::vector<std::string>& keyNames,
+    const std::vector<TypePtr>& keyTypes) {
+  std::vector<std::string> names = keyNames;
+  std::vector<TypePtr> types = keyTypes;
+
+  // Add up to 2 payload columns.
+  const auto numPayload = randInt(0, 2);
+  for (auto i = 0; i < numPayload; ++i) {
+    names.push_back(fmt::format("c{}", i + keyNames.size()));
+    types.push_back(vectorFuzzer_.randType(/*maxDepth=*/2));
+  }
+
+  const auto inputType = ROW(std::move(names), std::move(types));
+  std::vector<RowVectorPtr> input;
+  input.reserve(FLAGS_num_batches);
+  for (auto i = 0; i < FLAGS_num_batches; ++i) {
+    input.push_back(vectorFuzzer_.fuzzInputRow(inputType));
+  }
+
+  return input;
+}
+
+PlanWithSplits MarkDistinctFuzzer::makeDefaultPlan(
+    const std::string& groupKey,
+    const std::string& distinctKey,
+    const std::vector<RowVectorPtr>& input) {
+  // Build plan: Values -> MarkDistinct -> Aggregation
+  // This is equivalent to: SELECT groupKey, count(DISTINCT distinctKey)
+  //                         FROM input GROUP BY groupKey
+  auto plan = test::PlanBuilder()
+                  .values(input)
+                  .markDistinct("distinct_marker", {groupKey, distinctKey})
+                  .singleAggregation(
+                      {groupKey},
+                      {"count(\"" + distinctKey + "\")"},
+                      {"distinct_marker"})
+                  .planNode();
+  return PlanWithSplits{std::move(plan)};
+}
+
+PlanWithSplits MarkDistinctFuzzer::makePlanWithTableScan(
+    const RowTypePtr& type,
+    const std::string& groupKey,
+    const std::string& distinctKey,
+    const std::vector<Split>& splits) {
+  auto plan = test::PlanBuilder()
+                  .tableScan(type)
+                  .markDistinct("distinct_marker", {groupKey, distinctKey})
+                  .singleAggregation(
+                      {groupKey},
+                      {"count(\"" + distinctKey + "\")"},
+                      {"distinct_marker"})
+                  .planNode();
+  return PlanWithSplits{plan, splits};
+}
+
+void MarkDistinctFuzzer::addPlansWithTableScan(
+    const std::string& tableDir,
+    const std::string& groupKey,
+    const std::string& distinctKey,
+    const std::vector<RowVectorPtr>& input,
+    std::vector<PlanWithSplits>& altPlans) {
+  VELOX_CHECK(!tableDir.empty());
+
+  if (!isTableScanSupported(input[0]->type())) {
+    return;
+  }
+
+  const std::vector<Split> inputSplits = test::makeSplits(
+      input, fmt::format("{}/mark_distinct", tableDir), writerPool_);
+  altPlans.push_back(makePlanWithTableScan(
+      asRowType(input[0]->type()), groupKey, distinctKey, inputSplits));
+}
+
+void MarkDistinctFuzzer::runSingleIteration() {
+  const auto [keyNames, keyTypes] = generatePartitionKeys();
+
+  // We need at least 2 keys: one for GROUP BY and one for DISTINCT.
+  // If only 1 key was generated, add another one.
+  std::vector<std::string> allNames = keyNames;
+  std::vector<TypePtr> allTypes = keyTypes;
+  if (allNames.size() < 2) {
+    allNames.push_back(fmt::format("c{}", allNames.size()));
+    allTypes.push_back(vectorFuzzer_.randType(/*maxDepth=*/1));
+  }
+
+  const auto input = generateInput(allNames, allTypes);
+  test::logVectors(input);
+
+  // Use first key as group-by key, second as distinct key.
+  const auto& groupKey = allNames[0];
+  const auto& distinctKey = allNames[1];
+
+  auto defaultPlan = makeDefaultPlan(groupKey, distinctKey, input);
+  const auto expected = execute(defaultPlan, /*injectSpill=*/false, false);
+
+  // Validate against DuckDB using an equivalent plan without MarkDistinct.
+  // DuckDB cannot translate MarkDistinctNode to SQL, so we build a reference
+  // plan that uses count(DISTINCT ...) directly.
+  if (expected != nullptr) {
+    auto referencePlan =
+        test::PlanBuilder()
+            .values(input)
+            .singleAggregation(
+                {groupKey},
+                {fmt::format("count(DISTINCT \"{}\")", distinctKey)})
+            .planNode();
+    validateExpectedResults(referencePlan, input, expected);
+  }
+
+  std::vector<PlanWithSplits> altPlans;
+  altPlans.push_back(std::move(defaultPlan));
+
+  const auto tableScanDir = TempDirectoryPath::create();
+  addPlansWithTableScan(
+      tableScanDir->getPath(), groupKey, distinctKey, input, altPlans);
+
+  for (auto i = 0; i < altPlans.size(); ++i) {
+    testPlan(
+        altPlans[i],
+        i,
+        expected,
+        "core::QueryConfig::kMarkDistinctSpillEnabled");
+  }
+}
+
+} // namespace
+
+void markDistinctFuzzer(
+    size_t seed,
+    std::unique_ptr<test::ReferenceQueryRunner> referenceQueryRunner) {
+  MarkDistinctFuzzer(seed, std::move(referenceQueryRunner)).run();
+}
+} // namespace facebook::velox::exec
diff --git a/velox/experimental/wave/dwio/nimble/fuzzer/NimbleReaderFuzzer.h b/velox/exec/fuzzer/MarkDistinctFuzzer.h
similarity index 50%
rename from velox/experimental/wave/dwio/nimble/fuzzer/NimbleReaderFuzzer.h
rename to velox/exec/fuzzer/MarkDistinctFuzzer.h
index 26c3ede8213..bcd34e62a6b 100644
--- a/velox/experimental/wave/dwio/nimble/fuzzer/NimbleReaderFuzzer.h
+++ b/velox/exec/fuzzer/MarkDistinctFuzzer.h
@@ -13,30 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 #pragma once
 
 #include <cstddef>
 #include "velox/exec/fuzzer/ReferenceQueryRunner.h"
 
-namespace facebook::velox::wave {
-struct NimbleReaderFuzzerOptions {
-  size_t minNumStreams{1};
-  size_t maxNumStreams{10};
-  size_t minNumChunks{1};
-  size_t maxNumChunks{10};
-  size_t minChunkSize{1};
-  size_t minNumValues{10};
-  size_t maxNumValues{10000};
-  double hasNullProbability{0.5};
-  double hasFilterProbability{0.75};
-  double isFilterProbability{0.5};
-  double nullAllowedProbability{0};
-  double filterKeepValuesProbability{1.0};
-  std::vector<TypePtr> types{INTEGER(), BIGINT(), REAL(), DOUBLE()};
-};
-void nimbleReaderFuzzer(
+namespace facebook::velox::exec {
+void markDistinctFuzzer(
     size_t seed,
-    NimbleReaderFuzzerOptions options,
-    std::unique_ptr<exec::test::ReferenceQueryRunner> referenceQueryRunner);
-} // namespace facebook::velox::wave
+    std::unique_ptr<test::ReferenceQueryRunner> referenceQueryRunner);
+}
diff --git a/velox/exec/fuzzer/MarkDistinctFuzzerRunner.cpp b/velox/exec/fuzzer/MarkDistinctFuzzerRunner.cpp
new file mode 100644
index 00000000000..3e2bb69e5c5
--- /dev/null
+++ b/velox/exec/fuzzer/MarkDistinctFuzzerRunner.cpp
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/init/Init.h>
+#include <gflags/gflags.h>
+
+#include "velox/common/memory/SharedArbitrator.h"
+#include "velox/exec/fuzzer/FuzzerUtil.h"
+#include "velox/exec/fuzzer/MarkDistinctFuzzer.h"
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
+#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
+
+/// MarkDistinctFuzzerRunner leverages MarkDistinctFuzzer and VectorFuzzer to
+/// automatically generate and execute tests. It works as follows:
+///
+///  1. Plan Generation: Generate two equivalent query plans, one is
+///     mark-distinct + aggregation over ValuesNode and the other is over
+///     TableScanNode.
+///  2. Executes a variety of logically equivalent query plans and checks the
+///     results are the same.
+///  3. Rinse and repeat.
+///
+/// It is used as follows:
+///
+///  $ ./velox_mark_distinct_fuzzer --duration_sec 600
+///
+/// The flags that configure MarkDistinctFuzzer's behavior are:
+///
+///  --steps: how many iterations to run.
+///  --duration_sec: alternatively, for how many seconds it should run (takes
+///          precedence over --steps).
+///  --seed: pass a deterministic seed to reproduce the behavior (each iteration
+///          will print a seed as part of the logs).
+///  --v=1: verbose logging; print a lot more details about the execution.
+///  --batch_size: size of input vector batches generated.
+///  --num_batches: number of input vector batches to generate.
+///  --enable_spill: test plans with spilling enabled.
+///  --enable_oom_injection: randomly trigger OOM while executing query plans.
+/// e.g:
+///
+///  $ ./velox_mark_distinct_fuzzer \
+///         --seed 123 \
+///         --duration_sec 600 \
+///         --v=1
+
+DEFINE_int64(
+    seed,
+    0,
+    "Initial seed for random number generator used to reproduce previous "
+    "results (0 means start with random seed).");
+
+DEFINE_string(
+    presto_url,
+    "",
+    "Presto coordinator URI along with port. If set, we use Presto "
+    "source of truth. Otherwise, use DuckDB. Example: "
+    "--presto_url=http://127.0.0.1:8080");
+
+DEFINE_uint32(
+    req_timeout_ms,
+    1000,
+    "Timeout in milliseconds for HTTP requests made to reference DB, "
+    "such as Presto. Example: --req_timeout_ms=2000");
+
+DEFINE_int64(allocator_capacity, 8L << 30, "Allocator capacity in bytes.");
+
+DEFINE_int64(arbitrator_capacity, 6L << 30, "Arbitrator capacity in bytes.");
+
+using namespace facebook::velox;
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+  exec::test::setupMemory(FLAGS_allocator_capacity, FLAGS_arbitrator_capacity);
+  aggregate::prestosql::registerAllAggregateFunctions();
+  std::shared_ptr<memory::MemoryPool> rootPool{
+      memory::memoryManager()->addRootPool()};
+  auto referenceQueryRunner = exec::test::setupReferenceQueryRunner(
+      rootPool.get(),
+      FLAGS_presto_url,
+      "mark_distinct_fuzzer",
+      FLAGS_req_timeout_ms);
+  const size_t initialSeed = FLAGS_seed == 0 ? std::time(nullptr) : FLAGS_seed;
+  exec::markDistinctFuzzer(initialSeed, std::move(referenceQueryRunner));
+}
diff --git a/velox/exec/fuzzer/MemoryArbitrationFuzzer.cpp b/velox/exec/fuzzer/MemoryArbitrationFuzzer.cpp
index 1d855140727..b0c0078f88b 100644
--- a/velox/exec/fuzzer/MemoryArbitrationFuzzer.cpp
+++ b/velox/exec/fuzzer/MemoryArbitrationFuzzer.cpp
@@ -18,18 +18,20 @@
 #include <boost/random/uniform_int_distribution.hpp>
 
 #include <folly/concurrency/ConcurrentHashMap.h>
+#include <folly/system/HardwareConcurrency.h>
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/file/tests/FaultyFileSystem.h"
 #include "velox/common/fuzzer/Utils.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/hive/HiveConnector.h"
-#include "velox/dwio/dwrf/RegisterDwrfReader.h" // @manual
-#include "velox/dwio/dwrf/RegisterDwrfWriter.h" // @manual
+#include "velox/dwio/dwrf/RegisterDwrfReader.h"
+#include "velox/dwio/dwrf/RegisterDwrfWriter.h"
 #include "velox/exec/MemoryReclaimer.h"
 #include "velox/exec/fuzzer/FuzzerUtil.h"
 #include "velox/exec/tests/utils/ArbitratorTestUtil.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/serializers/CompactRowSerializer.h"
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/serializers/UnsafeRowSerializer.h"
@@ -99,9 +101,16 @@ DEFINE_int32(
     "After each specified number of milliseconds, abort a random task."
     "If given 0, no task will be aborted.");
 
+DEFINE_string(
+    plan_type,
+    "all",
+    "Type of plans to test. Options: all, hash_join, aggregate, "
+    "row_number, topn_row_number, order_by.");
+
 using namespace facebook::velox::tests::utils;
 
 namespace facebook::velox::exec {
+using namespace facebook::velox::common::testutil;
 namespace {
 
 using fuzzer::coinToss;
@@ -150,7 +159,7 @@ class MemoryArbitrationFuzzer {
     return boost::random::uniform_int_distribution<int32_t>(min, max)(rng_);
   }
 
-  std::shared_ptr<test::TempDirectoryPath> maybeGenerateFaultySpillDirectory();
+  std::shared_ptr<TempDirectoryPath> maybeGenerateFaultySpillDirectory();
 
   // Returns a list of randomly generated key types for join and aggregation.
   std::vector<TypePtr> generateKeyTypes(int32_t numKeys);
@@ -161,7 +170,8 @@ class MemoryArbitrationFuzzer {
   // Returns randomly generated input with up to 3 additional payload columns.
   std::vector<RowVectorPtr> generateInput(
       const std::vector<std::string>& keyNames,
-      const std::vector<TypePtr>& keyTypes);
+      const std::vector<TypePtr>& keyTypes,
+      int32_t minPayload = 0);
 
   // Reuses the 'generateInput' method to return randomly generated
   // probe input.
@@ -181,6 +191,12 @@ class MemoryArbitrationFuzzer {
       const std::vector<std::string>& keyNames,
       const std::vector<TypePtr>& keyTypes);
 
+  // Reuses the 'generateInput' method to return randomly generated
+  // topN row number input.
+  std::vector<RowVectorPtr> generateTopNRowNumberInput(
+      const std::vector<std::string>& keyNames,
+      const std::vector<TypePtr>& keyTypes);
+
   // Reuses the 'generateInput' method to return randomly generated
   // order by input.
   std::vector<RowVectorPtr> generateOrderByInput(
@@ -210,6 +226,8 @@ class MemoryArbitrationFuzzer {
 
   std::vector<PlanWithSplits> rowNumberPlans(const std::string& tableDir);
 
+  std::vector<PlanWithSplits> topNRowNumberPlans(const std::string& tableDir);
+
   std::vector<PlanWithSplits> orderByPlans(const std::string& tableDir);
 
   // Helper method that combines all above plan methods into one.
@@ -237,6 +255,7 @@ class MemoryArbitrationFuzzer {
       {core::QueryConfig::kSpillStartPartitionBit, "29"},
       {core::QueryConfig::kAggregationSpillEnabled, "true"},
       {core::QueryConfig::kRowNumberSpillEnabled, "true"},
+      {core::QueryConfig::kTopNRowNumberSpillEnabled, "true"},
       {core::QueryConfig::kOrderBySpillEnabled, "true"},
   };
 
@@ -256,7 +275,7 @@ class MemoryArbitrationFuzzer {
   VectorFuzzer vectorFuzzer_;
   std::shared_ptr<folly::Executor> executor_{
       std::make_shared<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency())};
+          folly::available_concurrency())};
   folly::Synchronized<Stats> stats_;
 };
 
@@ -266,13 +285,13 @@ MemoryArbitrationFuzzer::MemoryArbitrationFuzzer(size_t initialSeed)
   // paritition key, and presto doesn't supports nanosecond precision.
   vectorFuzzer_.getMutableOptions().timestampPrecision =
       fuzzer::FuzzerTimestampPrecision::kMilliSeconds;
-  if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kPresto)) {
+  if (!isRegisteredNamedVectorSerde("Presto")) {
     serializer::presto::PrestoVectorSerde::registerNamedVectorSerde();
   }
-  if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kCompactRow)) {
+  if (!isRegisteredNamedVectorSerde("CompactRow")) {
     serializer::CompactRowVectorSerde::registerNamedVectorSerde();
   }
-  if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kUnsafeRow)) {
+  if (!isRegisteredNamedVectorSerde("UnsafeRow")) {
     serializer::spark::UnsafeRowVectorSerde::registerNamedVectorSerde();
   }
   // Make sure not to run out of open file descriptors.
@@ -283,7 +302,8 @@ MemoryArbitrationFuzzer::MemoryArbitrationFuzzer(size_t initialSeed)
   const auto hiveConnector = hiveFactory.newConnector(
       test::kHiveConnectorId,
       std::make_shared<config::ConfigBase>(std::move(hiveConfig)));
-  connector::registerConnector(hiveConnector);
+  connector::ConnectorRegistry::global().insert(
+      hiveConnector->connectorId(), hiveConnector);
   dwrf::registerDwrfReaderFactory();
   dwrf::registerDwrfWriterFactory();
 
@@ -325,7 +345,8 @@ MemoryArbitrationFuzzer::generatePartitionKeys() {
 
 std::vector<RowVectorPtr> MemoryArbitrationFuzzer::generateInput(
     const std::vector<std::string>& keyNames,
-    const std::vector<TypePtr>& keyTypes) {
+    const std::vector<TypePtr>& keyTypes,
+    int32_t minPayload) {
   std::vector<std::string> names = keyNames;
   std::vector<TypePtr> types = keyTypes;
 
@@ -337,8 +358,7 @@ std::vector<RowVectorPtr> MemoryArbitrationFuzzer::generateInput(
     }
   }
 
-  // Add up to 3 payload columns.
-  const auto numPayload = randInt(0, 3);
+  const auto numPayload = randInt(minPayload, 3);
   for (auto i = 0; i < numPayload; ++i) {
     names.push_back(fmt::format("tp{}", i + keyNames.size()));
     types.push_back(vectorFuzzer_.randType(2 /*maxDepth*/));
@@ -433,6 +453,12 @@ std::vector<RowVectorPtr> MemoryArbitrationFuzzer::generateRowNumberInput(
   return generateInput(keyNames, keyTypes);
 }
 
+std::vector<RowVectorPtr> MemoryArbitrationFuzzer::generateTopNRowNumberInput(
+    const std::vector<std::string>& keyNames,
+    const std::vector<TypePtr>& keyTypes) {
+  return generateInput(keyNames, keyTypes, 1);
+}
+
 std::vector<RowVectorPtr> MemoryArbitrationFuzzer::generateOrderByInput(
     const std::vector<std::string>& keyNames,
     const std::vector<TypePtr>& keyTypes) {
@@ -503,9 +529,10 @@ MemoryArbitrationFuzzer::hashJoinPlans(
                  joinType,
                  false)
              .planNode();
-  plans.push_back(PlanWithSplits{
-      std::move(plan),
-      {{probeScanId, probeSplits}, {buildScanId, buildSplits}}});
+  plans.push_back(
+      PlanWithSplits{
+          std::move(plan),
+          {{probeScanId, probeSplits}, {buildScanId, buildSplits}}});
   return plans;
 }
 
@@ -680,6 +707,90 @@ MemoryArbitrationFuzzer::rowNumberPlans(const std::string& tableDir) {
   return plans;
 }
 
+std::vector<MemoryArbitrationFuzzer::PlanWithSplits>
+MemoryArbitrationFuzzer::topNRowNumberPlans(const std::string& tableDir) {
+  static const std::vector<std::string> kRankFunctions = {
+      "row_number", "rank", "dense_rank"};
+
+  const auto [keyNames, keyTypes] = generatePartitionKeys();
+  const auto input = generateTopNRowNumberInput(keyNames, keyTypes);
+
+  std::vector<PlanWithSplits> plans;
+
+  const auto inputType = asRowType(input[0]->type());
+  std::vector<std::string> sortingKeys;
+
+  std::unordered_set<std::string> partitionKeySet(
+      keyNames.begin(), keyNames.end());
+  for (const auto& name : inputType->names()) {
+    if (partitionKeySet.find(name) == partitionKeySet.end()) {
+      sortingKeys.push_back(name);
+    }
+  }
+
+  const auto numSortingKeys = randInt(1, sortingKeys.size());
+  sortingKeys.resize(numSortingKeys);
+
+  const auto rankFunction =
+      kRankFunctions[randInt(0, kRankFunctions.size() - 1)];
+  const auto limit = randInt(1, 100);
+  const bool generateRowNumber = vectorFuzzer_.coinToss(0.5);
+
+  std::vector<std::string> projectFields = keyNames;
+  if (generateRowNumber) {
+    projectFields.emplace_back("row_number");
+  }
+
+  // Values plan with Partiton Keys
+  auto plan = PlanWithSplits{
+      test::PlanBuilder()
+          .values(input)
+          .topNRank(
+              rankFunction, keyNames, sortingKeys, limit, generateRowNumber)
+          .project(projectFields)
+          .planNode(),
+      {}};
+  plans.push_back(std::move(plan));
+
+  if (!test::isTableScanSupported(input[0]->type())) {
+    return plans;
+  }
+
+  const std::vector<Split> splits = test::makeSplits(
+      input, fmt::format("{}/topn_row_number", tableDir), writerPool_);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId scanId;
+  // TableScan Plan with Parition Keys
+  plan = PlanWithSplits{
+      test::PlanBuilder(planNodeIdGenerator)
+          .tableScan(asRowType(input[0]->type()))
+          .capturePlanNodeId(scanId)
+          .topNRank(
+              rankFunction, keyNames, sortingKeys, limit, generateRowNumber)
+          .project(projectFields)
+          .planNode(),
+      {{scanId, splits}}};
+  plans.push_back(std::move(plan));
+
+  std::vector<std::string> globalProjectFields;
+  if (generateRowNumber) {
+    globalProjectFields.emplace_back("row_number");
+  }
+
+  // Global TopN
+  plan = PlanWithSplits{
+      test::PlanBuilder()
+          .values(input)
+          .topNRank(rankFunction, {}, sortingKeys, limit, generateRowNumber)
+          .project(globalProjectFields)
+          .planNode(),
+      {}};
+  plans.push_back(std::move(plan));
+
+  return plans;
+}
+
 std::vector<MemoryArbitrationFuzzer::PlanWithSplits>
 MemoryArbitrationFuzzer::orderByPlans(const std::string& tableDir) {
   const auto [keyNames, keyTypes] = generatePartitionKeys();
@@ -716,18 +827,40 @@ MemoryArbitrationFuzzer::orderByPlans(const std::string& tableDir) {
 std::vector<MemoryArbitrationFuzzer::PlanWithSplits>
 MemoryArbitrationFuzzer::allPlans(const std::string& tableDir) {
   std::vector<PlanWithSplits> plans;
-  for (const auto& plan : hashJoinPlans(tableDir)) {
-    plans.push_back(plan);
-  }
-  for (const auto& plan : aggregatePlans(tableDir)) {
-    plans.push_back(plan);
-  }
-  for (const auto& plan : rowNumberPlans(tableDir)) {
-    plans.push_back(plan);
-  }
-  for (const auto& plan : orderByPlans(tableDir)) {
-    plans.push_back(plan);
-  }
+  const std::string planType = FLAGS_plan_type;
+
+  auto appendPlansIf =
+      [&](const std::string& type,
+          std::function<std::vector<PlanWithSplits>(const std::string&)>
+              planGenerator) {
+        if (planType == "all" || planType == type) {
+          auto newPlans = planGenerator(tableDir);
+          plans.insert(
+              plans.end(),
+              std::make_move_iterator(newPlans.begin()),
+              std::make_move_iterator(newPlans.end()));
+        }
+      };
+  appendPlansIf("hash_join", [this](const std::string& dir) {
+    return hashJoinPlans(dir);
+  });
+  appendPlansIf("aggregate", [this](const std::string& dir) {
+    return aggregatePlans(dir);
+  });
+  appendPlansIf("row_number", [this](const std::string& dir) {
+    return rowNumberPlans(dir);
+  });
+  appendPlansIf("topn_row_number", [this](const std::string& dir) {
+    return topNRowNumberPlans(dir);
+  });
+  appendPlansIf(
+      "order_by", [this](const std::string& dir) { return orderByPlans(dir); });
+
+  VELOX_USER_CHECK(
+      !plans.empty(),
+      "No plans generated for plan_type: {}. Valid options are: all, hash_join, aggregate, row_number, topn_row_number, order_by",
+      planType);
+
   return plans;
 }
 
@@ -746,12 +879,12 @@ std::string MemoryArbitrationFuzzer::extractQueryIdFromSpillPath(
 // Stats that keeps track of per thread execution status in verify()
 folly::ConcurrentHashMap<std::string, folly::Unit> spillFsTaskSet;
 
-std::shared_ptr<test::TempDirectoryPath>
+std::shared_ptr<TempDirectoryPath>
 MemoryArbitrationFuzzer::maybeGenerateFaultySpillDirectory() {
   FuzzerGenerator fsRng(rng_());
   const auto injectFsFault = coinToss(fsRng, FLAGS_spill_faulty_fs_ratio);
   if (!injectFsFault) {
-    return exec::test::TempDirectoryPath::create(false);
+    return TempDirectoryPath::create(false);
   }
   using OpType = FaultFileOperation::Type;
   static const std::vector<std::unordered_set<OpType>> opTypes{
@@ -762,7 +895,7 @@ MemoryArbitrationFuzzer::maybeGenerateFaultySpillDirectory() {
       {OpType::kRead, OpType::kWrite},
       {OpType::kReadv, OpType::kWrite}};
 
-  const auto directory = exec::test::TempDirectoryPath::create(true);
+  const auto directory = TempDirectoryPath::create(true);
   auto faultyFileSystem = std::dynamic_pointer_cast<FaultyFileSystem>(
       filesystems::getFileSystem(directory->getPath(), nullptr));
   faultyFileSystem->setFileInjectionHook(
@@ -788,7 +921,7 @@ MemoryArbitrationFuzzer::maybeGenerateFaultySpillDirectory() {
 
 void MemoryArbitrationFuzzer::verify() {
   auto spillDirectory = maybeGenerateFaultySpillDirectory();
-  const auto tableScanDir = exec::test::TempDirectoryPath::create(false);
+  const auto tableScanDir = TempDirectoryPath::create(false);
 
   auto plans = allPlans(tableScanDir->getPath());
 
@@ -824,7 +957,10 @@ void MemoryArbitrationFuzzer::verify() {
 
           const auto plan = plans.at(getRandomIndex(rng, plans.size() - 1));
           test::AssertQueryBuilder builder(plan.plan);
-          builder.queryCtx(queryCtx);
+          // Use a long timeout (1 hour) to avoid false failures from CI thread
+          // starvation while still catching real deadlocks.
+          static constexpr uint64_t kOneHourUs{3'600'000'000ULL};
+          builder.queryCtx(queryCtx).maxWaitMicros(kOneHourUs);
           for (const auto& [planNodeId, nodeSplits] : plan.splits) {
             builder.splits(planNodeId, nodeSplits);
           }
@@ -856,21 +992,6 @@ void MemoryArbitrationFuzzer::verify() {
             const auto injectedTaskAbortRequest =
                 queryTaskAbortRequestMap.find(queryId)->second;
 
-            // Debug logging to understand the failure
-            if (!injectedSpillFsFault && !injectedTaskAbortRequest) {
-              LOG(ERROR) << "============== VELOX_CHECK failure debug info:";
-              LOG(ERROR) << "  queryId: " << queryId;
-              LOG(ERROR) << "  spillFsTaskSet size: " << spillFsTaskSet.size();
-              LOG(ERROR) << "  spillFsTaskSet contents:";
-              // Iterate through spillFsTaskSet to log contents
-              for (auto it = spillFsTaskSet.cbegin();
-                   it != spillFsTaskSet.cend();
-                   ++it) {
-                LOG(ERROR) << "    key: " << it->first;
-              }
-              LOG(ERROR) << "  error message: " << e.message();
-            }
-
             VELOX_CHECK(
                 injectedSpillFsFault || injectedTaskAbortRequest,
                 "injectedSpillFsFault: {}, injectedTaskAbortRequest: {}, error message: {}",
@@ -967,13 +1088,13 @@ void MemoryArbitrationFuzzer::go() {
   size_t iteration = 0;
 
   while (!isDone(iteration, startTime)) {
-    LOG(WARNING) << "==============================> Started iteration "
-                 << iteration << " (seed: " << currentSeed_ << ")";
+    LOG(INFO) << "==============================> Started iteration "
+              << iteration << " (seed: " << currentSeed_ << ")";
     verify();
+    stats_.rlock()->print();
 
     LOG(INFO) << "==============================> Done with iteration "
               << iteration;
-    stats_.rlock()->print();
 
     reSeed();
     ++iteration;
diff --git a/velox/exec/fuzzer/MemoryArbitrationFuzzerRunner.cpp b/velox/exec/fuzzer/MemoryArbitrationFuzzerRunner.cpp
index cfa1e928c1d..01f3fccc038 100644
--- a/velox/exec/fuzzer/MemoryArbitrationFuzzerRunner.cpp
+++ b/velox/exec/fuzzer/MemoryArbitrationFuzzerRunner.cpp
@@ -28,6 +28,7 @@
 #include "velox/exec/fuzzer/MemoryArbitrationFuzzer.h"
 #include "velox/exec/fuzzer/PrestoQueryRunner.h"
 #include "velox/exec/fuzzer/ReferenceQueryRunner.h"
+#include "velox/serializers/PrestoSerializer.h"
 
 DEFINE_int64(allocator_capacity, 32L << 30, "Allocator capacity in bytes.");
 
diff --git a/velox/exec/fuzzer/PrestoQueryRunner.cpp b/velox/exec/fuzzer/PrestoQueryRunner.cpp
index 27b524a3af5..da32ed01f0d 100644
--- a/velox/exec/fuzzer/PrestoQueryRunner.cpp
+++ b/velox/exec/fuzzer/PrestoQueryRunner.cpp
@@ -14,9 +14,10 @@
  * limitations under the License.
  */
 
-#include <cpr/cpr.h> // @manual
+#include <curl/curl.h>
 #include <folly/json.h>
 #include <iostream>
+#include <string>
 #include <utility>
 
 #include "velox/common/base/Fs.h"
@@ -38,9 +39,13 @@
 #include "velox/functions/prestosql/types/IPAddressType.h"
 #include "velox/functions/prestosql/types/IPPrefixType.h"
 #include "velox/functions/prestosql/types/JsonType.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+#include "velox/functions/prestosql/types/PrestoTypes.h"
 #include "velox/functions/prestosql/types/QDigestType.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
 #include "velox/functions/prestosql/types/SfmSketchType.h"
 #include "velox/functions/prestosql/types/TDigestType.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 #include "velox/functions/prestosql/types/UuidType.h"
 #include "velox/functions/prestosql/types/parser/TypeParser.h"
@@ -51,6 +56,13 @@ using namespace facebook::velox;
 namespace facebook::velox::exec::test {
 namespace {
 
+static size_t
+writeFunction(char* data, size_t size, size_t nmemb, void* userdata) {
+  std::string* response = static_cast<std::string*>(userdata);
+  response->append(data, size * nmemb);
+  return size * nmemb;
+}
+
 void writeToFile(
     const std::string& path,
     const std::vector<RowVectorPtr>& data,
@@ -132,8 +144,9 @@ class ServerResponse {
     std::vector<TypePtr> types;
     for (const auto& column : response_["columns"]) {
       names.push_back(column["name"].asString());
-      types.push_back(facebook::velox::functions::prestosql::parseType(
-          column["type"].asString()));
+      types.push_back(
+          facebook::velox::functions::prestosql::parseType(
+              column["type"].asString()));
     }
 
     auto rowType = ROW(std::move(names), std::move(types));
@@ -192,17 +205,24 @@ const std::vector<TypePtr>& PrestoQueryRunner::supportedScalarTypes() const {
       VARBINARY(),
       TIMESTAMP(),
       TIMESTAMP_WITH_TIME_ZONE(),
+      IPADDRESS(),
   };
   return kScalarTypes;
 }
 
 // static
 bool PrestoQueryRunner::isSupportedDwrfType(const TypePtr& type) {
-  if (type->isDate() || type->isIntervalDayTime() || type->isUnKnown() ||
+  if (type->isDate() || type->isIntervalDayTime() || type->isUnknown() ||
       isGeometryType(type)) {
     return false;
   }
 
+  // Block IPADDRESS in containers due to Presto's Int128ArrayBlock
+  // not supporting compareTo().
+  if (containsIPAddress(type)) {
+    return false;
+  }
+
   for (auto i = 0; i < type->size(); ++i) {
     if (!isSupportedDwrfType(type->childAt(i))) {
       return false;
@@ -243,8 +263,9 @@ PrestoQueryRunner::inputProjections(
         children[batchIndex].push_back(input[batchIndex]->childAt(childIndex));
       }
 
-      projections.push_back(std::make_shared<core::FieldAccessExpr>(
-          names[childIndex], names[childIndex]));
+      projections.push_back(
+          std::make_shared<core::FieldAccessExpr>(
+              names[childIndex], names[childIndex]));
     }
   }
 
@@ -258,12 +279,13 @@ PrestoQueryRunner::inputProjections(
   std::vector<RowVectorPtr> output;
   output.reserve(input.size());
   for (int batchIndex = 0; batchIndex < input.size(); batchIndex++) {
-    output.push_back(std::make_shared<RowVector>(
-        input[batchIndex]->pool(),
-        rowType,
-        input[batchIndex]->nulls(),
-        input[batchIndex]->size(),
-        std::move(children[batchIndex])));
+    output.push_back(
+        std::make_shared<RowVector>(
+            input[batchIndex]->pool(),
+            rowType,
+            input[batchIndex]->nulls(),
+            input[batchIndex]->size(),
+            std::move(children[batchIndex])));
   }
 
   return std::make_pair(output, projections);
@@ -306,30 +328,48 @@ bool PrestoQueryRunner::isConstantExprSupported(
     // same timezone as Velox. Interval type cannot be used as the type of
     // constant literals in Presto SQL.
     auto& type = expr->type();
-    return type->isPrimitiveType() && !type->isTimestamp() &&
+    return type->isPrimitiveType() && !type->isTimestamp() && !type->isTime() &&
         !isJsonType(type) && !type->isIntervalDayTime() &&
         !isIPAddressType(type) && !isIPPrefixType(type) && !isUuidType(type) &&
         !isTimestampWithTimeZoneType(type) && !isHyperLogLogType(type) &&
-        !isTDigestType(type) && !isQDigestType(type) && !isBingTileType(type) &&
-        !isSfmSketchType(type);
-    ;
+        !isKHyperLogLogType(type) && !isTDigestType(type) &&
+        !isQDigestType(type) && !isSetDigestType(type) &&
+        !isBingTileType(type) && !isSfmSketchType(type) &&
+        !isTimeWithTimeZone(type);
   }
   return true;
 }
 
 bool PrestoQueryRunner::isSupported(const exec::FunctionSignature& signature) {
-  // TODO: support queries with these types. Among the types below, hugeint is
-  // not a native type in Presto, so fuzzer should not use it as the type of
-  // cast-to or constant literals. Hyperloglog and TDigest can only be casted
-  // from varbinary and cannot be used as the type of constant literals.
-  // Interval year to month can only be casted from NULL and cannot be used as
-  // the type of constant literals. Json, Ipaddress, Ipprefix, and UUID require
-  // special handling, because Presto requires literals of these types to be
-  // valid, and doesn't allow creating HIVE columns of these types.
+  // TODO: support queries with these types.
+  // Types not supported by PrestoQueryRunner and their reasons:
+  //
+  // hugeint:
+  //   - Not a native type in Presto
+  //   - Fuzzer should not use it for cast-to or constant literals
+  //
+  // interval year to month:
+  //   - Can only be casted from NULL
+  //   - Cannot be used as constant literal types
+  //
+  // ipaddress, ipprefix, uuid:
+  //   - Require special handling in Presto
+  //   - Presto requires literals of these types to be valid
+  //   - Cannot create HIVE columns of these types
+  //
+  // geometry:
+  //   - Under development in Presto
+  //   - Cannot be used as constant literals
+  //   - Expected differences between Presto Java and Velox C++ implementations
+  //
+  // p4hyperloglog:
+  //   - Not a native type in Presto
+  //   - Cannot create HIVE columns of these types
   return !(
       usesTypeName(signature, "interval year to month") ||
       usesTypeName(signature, "hugeint") ||
-      usesInputTypeName(signature, "ipaddress") ||
+      usesTypeName(signature, "geometry") || usesTypeName(signature, "time") ||
+      usesTypeName(signature, "p4hyperloglog") ||
       usesInputTypeName(signature, "ipprefix") ||
       usesInputTypeName(signature, "uuid"));
 }
@@ -357,22 +397,24 @@ std::string PrestoQueryRunner::createTable(
   for (auto i = 0; i < inputType->size(); ++i) {
     appendComma(i, nullValues);
     nullValues << fmt::format(
-        "cast(null as {})", toTypeSql(inputType->childAt(i)));
+        "cast(null as {})", PrestoTypes::toSql(inputType->childAt(i)));
   }
 
   execute(fmt::format("DROP TABLE IF EXISTS {}", name));
 
-  execute(fmt::format(
-      "CREATE TABLE {}({}) WITH (format = 'DWRF') AS SELECT {}",
-      name,
-      folly::join(", ", inputType->names()),
-      nullValues.str()));
+  execute(
+      fmt::format(
+          "CREATE TABLE {}({}) WITH (format = 'DWRF') AS SELECT {}",
+          name,
+          folly::join(", ", inputType->names()),
+          nullValues.str()));
 
   // Query Presto to find out table's location on disk.
   auto results = execute(fmt::format("SELECT \"$path\" FROM {}", name));
-
   auto filePath = extractSingleValue<StringView>(results);
-  auto tableDirectoryPath = fs::path(filePath).parent_path();
+
+  // TODO: Remove explicit std::string_view cast.
+  auto tableDirectoryPath = fs::path(std::string_view(filePath)).parent_path();
 
   // Delete the all-null row.
   execute(fmt::format("DELETE FROM {}", name));
@@ -471,38 +513,82 @@ std::vector<RowVectorPtr> PrestoQueryRunner::execute(
 std::string PrestoQueryRunner::startQuery(
     const std::string& sql,
     const std::string& sessionProperty) {
-  auto uri = fmt::format("{}/v1/statement?binaryResults=true", coordinatorUri_);
-  cpr::Url url{uri};
-  cpr::Body body{sql};
-  cpr::Header header(
-      {{"X-Presto-User", user_},
-       {"X-Presto-Catalog", "hive"},
-       {"X-Presto-Schema", "tpch"},
-       {"Content-Type", "text/plain"},
-       {"X-Presto-Session", sessionProperty}});
-  cpr::Timeout timeout{timeout_};
-  cpr::Response response = cpr::Post(url, body, header, timeout);
+  CURL* curl = curl_easy_init();
+  VELOX_CHECK_NOT_NULL(curl, "Failed to initialize libcurl");
+
+  // Prepare curl headers
+  struct curl_slist* headers = nullptr;
+  headers = curl_slist_append(
+      headers, fmt::format("X-Presto-User: {}", user_).c_str());
+  headers = curl_slist_append(headers, "X-Presto-Catalog: hive");
+  headers = curl_slist_append(headers, "X-Presto-Schema: tpch");
+  headers = curl_slist_append(headers, "Content-Type: text/plain");
+  headers = curl_slist_append(
+      headers, fmt::format("X-Presto-Session: {}", sessionProperty).c_str());
+
+  std::string url =
+      fmt::format("{}/v1/statement?binaryResults=true", coordinatorUri_);
+  curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
+  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
+  curl_easy_setopt(curl, CURLOPT_POST, 1L);
+  curl_easy_setopt(curl, CURLOPT_POSTFIELDS, sql.c_str());
+  curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, sql.size());
+  curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, timeout_);
+  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeFunction);
+  curl_easy_setopt(curl, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_2);
+
+  std::string response;
+  curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
+
+  // Perform the request
+  CURLcode res = curl_easy_perform(curl);
+
+  // Clean up CURL resources before checking the result to avoid leaks on
+  // error.
+  curl_slist_free_all(headers);
+  curl_easy_cleanup(curl);
+
   VELOX_CHECK_EQ(
-      response.status_code,
-      200,
+      CURLE_OK,
+      res,
       "POST to {} failed: {}",
-      uri,
-      response.error.message);
-  return response.text;
+      coordinatorUri_,
+      curl_easy_strerror(res));
+
+  return response;
 }
 
 std::string PrestoQueryRunner::fetchNext(const std::string& nextUri) {
-  cpr::Url url(nextUri);
-  cpr::Header header({{"X-Presto-Client-Binary-Results", "true"}});
-  cpr::Timeout timeout{timeout_};
-  cpr::Response response = cpr::Get(url, header, timeout);
+  CURL* curl = curl_easy_init();
+  VELOX_CHECK_NOT_NULL(curl, "Failed to initialize libcurl");
+
+  // Set up the request URL
+  curl_easy_setopt(curl, CURLOPT_URL, nextUri.c_str());
+
+  // Set up headers
+  struct curl_slist* headers = nullptr;
+  headers = curl_slist_append(headers, "X-Presto-Client-Binary-Results: true");
+  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
+  curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, timeout_);
+  curl_easy_setopt(curl, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_2);
+
+  // Capture the response body
+  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeFunction);
+  std::string response;
+  curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
+
+  // Perform GET request
+  CURLcode res = curl_easy_perform(curl);
+
+  // Clean up CURL resources before checking the result to avoid leaks on
+  // error.
+  curl_slist_free_all(headers);
+  curl_easy_cleanup(curl);
+
   VELOX_CHECK_EQ(
-      response.status_code,
-      200,
-      "GET from {} failed: {}",
-      nextUri,
-      response.error.message);
-  return response.text;
+      CURLE_OK, res, "Get request failed: {}", curl_easy_strerror(res));
+
+  return response;
 }
 
 bool PrestoQueryRunner::supportsVeloxVectorResults() const {
@@ -510,3 +596,10 @@ bool PrestoQueryRunner::supportsVeloxVectorResults() const {
 }
 
 } // namespace facebook::velox::exec::test
+
+template <>
+struct fmt::formatter<CURLcode> : formatter<int> {
+  auto format(CURLcode s, format_context& ctx) const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
diff --git a/velox/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.cpp b/velox/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.cpp
index 059263c9941..3d61b4ba83f 100644
--- a/velox/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.cpp
+++ b/velox/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.cpp
@@ -21,10 +21,14 @@
 #include "velox/expression/Expr.h"
 #include "velox/functions/prestosql/types/BingTileType.h"
 #include "velox/functions/prestosql/types/HyperLogLogType.h"
+#include "velox/functions/prestosql/types/IPAddressType.h"
 #include "velox/functions/prestosql/types/JsonType.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
 #include "velox/functions/prestosql/types/QDigestType.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
 #include "velox/functions/prestosql/types/SfmSketchType.h"
 #include "velox/functions/prestosql/types/TDigestType.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 #include "velox/parse/Expressions.h"
 #include "velox/parse/TypeResolver.h"
@@ -50,6 +54,9 @@ intermediateTypeTransforms() {
           {HYPERLOGLOG(),
            std::make_shared<IntermediateTypeTransformUsingCast>(
                HYPERLOGLOG(), VARBINARY())},
+          {KHYPERLOGLOG(),
+           std::make_shared<IntermediateTypeTransformUsingCast>(
+               KHYPERLOGLOG(), VARBINARY())},
           {TDIGEST(DOUBLE()),
            std::make_shared<IntermediateTypeTransformUsingCast>(
                TDIGEST(DOUBLE()), VARBINARY())},
@@ -62,14 +69,26 @@ intermediateTypeTransforms() {
           {QDIGEST(REAL()),
            std::make_shared<IntermediateTypeTransformUsingCast>(
                QDIGEST(REAL()), VARBINARY())},
+          {SETDIGEST(),
+           std::make_shared<IntermediateTypeTransformUsingCast>(
+               SETDIGEST(), VARBINARY())},
           {SFMSKETCH(),
            std::make_shared<IntermediateTypeTransformUsingCast>(
                SFMSKETCH(), VARBINARY())},
           {JSON(), std::make_shared<JsonTransform>()},
+          {TIME(),
+           std::make_shared<IntermediateTypeTransformUsingCast>(
+               TIME(), VARCHAR())},
+          {TIME_WITH_TIME_ZONE(),
+           std::make_shared<IntermediateTypeTransformUsingCast>(
+               TIME_WITH_TIME_ZONE(), VARCHAR())},
           {BINGTILE(),
            std::make_shared<IntermediateTypeTransformUsingCast>(
                BINGTILE(), BIGINT())},
           {INTERVAL_DAY_TIME(), std::make_shared<IntervalDayTimeTransform>()},
+          {IPADDRESS(),
+           std::make_shared<IntermediateTypeTransformUsingCast>(
+               IPADDRESS(), VARCHAR())},
       };
   return intermediateTypeTransforms;
 }
@@ -237,10 +256,11 @@ core::ExprPtr getProjectionForRow(
           rowType.nameOf(i),
           transformDirection));
     } else {
-      children.push_back(std::make_shared<core::FieldAccessExpr>(
-          rowType.nameOf(i),
-          rowType.nameOf(i),
-          std::vector<core::ExprPtr>{inputExpr}));
+      children.push_back(
+          std::make_shared<core::FieldAccessExpr>(
+              rowType.nameOf(i),
+              rowType.nameOf(i),
+              std::vector<core::ExprPtr>{inputExpr}));
     }
   }
 
diff --git a/velox/exec/fuzzer/PrestoQueryRunnerToSqlPlanNodeVisitor.cpp b/velox/exec/fuzzer/PrestoQueryRunnerToSqlPlanNodeVisitor.cpp
index 4a828fd6813..04259b9c9c3 100644
--- a/velox/exec/fuzzer/PrestoQueryRunnerToSqlPlanNodeVisitor.cpp
+++ b/velox/exec/fuzzer/PrestoQueryRunnerToSqlPlanNodeVisitor.cpp
@@ -216,7 +216,7 @@ void PrestoQueryRunnerToSqlPlanNodeVisitor::visit(
   // )
   // AS SELECT * FROM t_<id>
   std::stringstream sql;
-  sql << "CREATE TABLE tmp_write";
+  sql << "CREATE TABLE " << ReferenceQueryRunner::getWriteTableName();
   std::vector<std::string> partitionKeys;
   for (auto i = 0; i < node.columnNames().size(); ++i) {
     if (insertTableHandle->inputColumns()[i]->isPartitionKey()) {
@@ -291,7 +291,8 @@ void PrestoQueryRunnerToSqlPlanNodeVisitor::visit(
     sql << inputType->nameOf(i);
   }
 
-  sql << ", row_number() OVER (";
+  sql << ", " << core::TopNRowNumberNode::rankFunctionName(node.rankFunction())
+      << "() OVER (";
 
   const auto& partitionKeys = node.partitionKeys();
   if (!partitionKeys.empty()) {
diff --git a/velox/exec/fuzzer/PrestoQueryRunnerToSqlPlanNodeVisitor.h b/velox/exec/fuzzer/PrestoQueryRunnerToSqlPlanNodeVisitor.h
index dd26b66611c..ac58b4e7995 100644
--- a/velox/exec/fuzzer/PrestoQueryRunnerToSqlPlanNodeVisitor.h
+++ b/velox/exec/fuzzer/PrestoQueryRunnerToSqlPlanNodeVisitor.h
@@ -95,6 +95,16 @@ class PrestoQueryRunnerToSqlPlanNodeVisitor : public PrestoSqlPlanNodeVisitor {
     VELOX_NYI();
   }
 
+  void visit(const core::EnforceDistinctNode&, core::PlanNodeVisitorContext&)
+      const override {
+    VELOX_NYI();
+  }
+
+  void visit(const core::MarkSortedNode&, core::PlanNodeVisitorContext&)
+      const override {
+    VELOX_NYI();
+  }
+
   void visit(const core::MergeExchangeNode&, core::PlanNodeVisitorContext&)
       const override {
     VELOX_NYI();
@@ -179,6 +189,11 @@ class PrestoQueryRunnerToSqlPlanNodeVisitor : public PrestoSqlPlanNodeVisitor {
   void visit(const core::WindowNode& node, core::PlanNodeVisitorContext& ctx)
       const override;
 
+  void visit(const core::MixedUnionNode&, core::PlanNodeVisitorContext&)
+      const override {
+    VELOX_NYI();
+  }
+
   /// Used to visit custom PlanNodes that extend the set provided by Velox.
   void visit(const core::PlanNode&, core::PlanNodeVisitorContext&)
       const override {
diff --git a/velox/exec/fuzzer/PrestoSql.cpp b/velox/exec/fuzzer/PrestoSql.cpp
index 6b034ef89d1..1effd97e49c 100644
--- a/velox/exec/fuzzer/PrestoSql.cpp
+++ b/velox/exec/fuzzer/PrestoSql.cpp
@@ -19,6 +19,7 @@
 #include "velox/exec/fuzzer/PrestoQueryRunner.h"
 #include "velox/exec/fuzzer/ReferenceQueryRunner.h"
 #include "velox/functions/prestosql/types/JsonType.h"
+#include "velox/functions/prestosql/types/PrestoTypes.h"
 #include "velox/vector/SimpleVector.h"
 
 namespace facebook::velox::exec::test {
@@ -71,36 +72,6 @@ void appendComma(int32_t i, std::stringstream& sql) {
   }
 }
 
-// Returns the SQL string of the given type.
-std::string toTypeSql(const TypePtr& type) {
-  switch (type->kind()) {
-    case TypeKind::ARRAY:
-      return fmt::format("ARRAY({})", toTypeSql(type->childAt(0)));
-    case TypeKind::MAP:
-      return fmt::format(
-          "MAP({}, {})",
-          toTypeSql(type->childAt(0)),
-          toTypeSql(type->childAt(1)));
-    case TypeKind::ROW: {
-      const auto& rowType = type->asRow();
-      std::stringstream sql;
-      sql << "ROW(";
-      for (auto i = 0; i < type->size(); ++i) {
-        appendComma(i, sql);
-        // TODO Field names may need to be quoted.
-        sql << rowType.nameOf(i) << " " << toTypeSql(type->childAt(i));
-      }
-      sql << ")";
-      return sql.str();
-    }
-    default:
-      if (type->isPrimitiveType()) {
-        return type->toString();
-      }
-      VELOX_UNSUPPORTED("Type is not supported: {}", type->toString());
-  }
-}
-
 std::string toLambdaSql(const core::LambdaTypedExprPtr& lambda) {
   std::stringstream sql;
   const auto& signature = lambda->signature();
@@ -346,7 +317,7 @@ std::string toCastSql(const core::CastTypedExpr& cast) {
     sql << "cast(";
   }
   toCallInputsSql(cast.inputs(), sql);
-  sql << " as " << toTypeSql(cast.type());
+  sql << " as " << facebook::velox::PrestoTypes::toSql(cast.type());
   sql << ")";
   return sql.str();
 }
@@ -355,7 +326,9 @@ std::string toConcatSql(const core::ConcatTypedExpr& concat) {
   std::stringstream input;
   toCallInputsSql(concat.inputs(), input);
   return fmt::format(
-      "cast(row({}) as {})", input.str(), toTypeSql(concat.type()));
+      "cast(row({}) as {})",
+      input.str(),
+      facebook::velox::PrestoTypes::toSql(concat.type()));
 }
 
 template <typename T>
@@ -381,7 +354,7 @@ std::string getConstantValue(const core::ConstantTypedExpr& expr) {
 
 std::string toConstantSql(const core::ConstantTypedExpr& constant) {
   const auto& type = constant.type();
-  const auto typeSql = toTypeSql(type);
+  const auto typeSql = facebook::velox::PrestoTypes::toSql(type);
 
   std::stringstream sql;
   if (constant.isNull()) {
diff --git a/velox/exec/fuzzer/PrestoSql.h b/velox/exec/fuzzer/PrestoSql.h
index 2acfaaa2df9..7fce82729c8 100644
--- a/velox/exec/fuzzer/PrestoSql.h
+++ b/velox/exec/fuzzer/PrestoSql.h
@@ -23,9 +23,6 @@ namespace facebook::velox::exec::test {
 /// than 0.
 void appendComma(int32_t i, std::stringstream& sql);
 
-/// Return the SQL string of type.
-std::string toTypeSql(const TypePtr& type);
-
 /// Converts input expressions into SQL string and appends to a given
 /// stringstream.
 void toCallInputsSql(
diff --git a/velox/exec/fuzzer/ReferenceQueryRunner.cpp b/velox/exec/fuzzer/ReferenceQueryRunner.cpp
index 8561db46ead..b6d212ec7d5 100644
--- a/velox/exec/fuzzer/ReferenceQueryRunner.cpp
+++ b/velox/exec/fuzzer/ReferenceQueryRunner.cpp
@@ -15,12 +15,36 @@
  */
 #include <unordered_map>
 
+#include <gflags/gflags.h>
+
 #include "velox/core/PlanNode.h"
 #include "velox/exec/fuzzer/PrestoSql.h"
 #include "velox/exec/fuzzer/ReferenceQueryRunner.h"
 
+DEFINE_string(
+    table_name_prefix,
+    "",
+    "Prefix for temporary table names created by fuzzer reference query "
+    "runners. Use to avoid collisions when running multiple fuzzer instances "
+    "against the same database server.");
+
 namespace facebook::velox::exec::test {
 
+std::string ReferenceQueryRunner::getTableName(
+    const core::ValuesNode& valuesNode) {
+  if (FLAGS_table_name_prefix.empty()) {
+    return fmt::format("t_{}", valuesNode.id());
+  }
+  return fmt::format("{}_t_{}", FLAGS_table_name_prefix, valuesNode.id());
+}
+
+std::string ReferenceQueryRunner::getWriteTableName() {
+  if (FLAGS_table_name_prefix.empty()) {
+    return "tmp_write";
+  }
+  return fmt::format("{}_tmp_write", FLAGS_table_name_prefix);
+}
+
 std::unordered_map<std::string, std::vector<velox::RowVectorPtr>>
 ReferenceQueryRunner::getAllTables(const core::PlanNodePtr& plan) {
   std::unordered_map<std::string, std::vector<velox::RowVectorPtr>> result;
diff --git a/velox/exec/fuzzer/ReferenceQueryRunner.h b/velox/exec/fuzzer/ReferenceQueryRunner.h
index 22e01c6e622..d277ea4347f 100644
--- a/velox/exec/fuzzer/ReferenceQueryRunner.h
+++ b/velox/exec/fuzzer/ReferenceQueryRunner.h
@@ -55,7 +55,8 @@ class ReferenceQueryRunner {
   enum class RunnerType {
     kPrestoQueryRunner,
     kDuckQueryRunner,
-    kSparkQueryRunner
+    kSparkQueryRunner,
+    kVeloxQueryRunner
   };
 
   // @param aggregatePool Used to allocate memory needed for vectors produced
@@ -161,10 +162,15 @@ class ReferenceQueryRunner {
     VELOX_UNSUPPORTED();
   }
 
-  /// Returns the name of the values node table in the form t_<id>.
-  static std::string getTableName(const core::ValuesNode& valuesNode) {
-    return fmt::format("t_{}", valuesNode.id());
-  }
+  /// Returns the name of the values node table in the form
+  /// [<prefix>_]t_<id>. When --table_name_prefix is set, the prefix is
+  /// prepended to avoid collisions between parallel fuzzer instances
+  /// sharing the same database server.
+  static std::string getTableName(const core::ValuesNode& valuesNode);
+
+  /// Returns the write destination table name, incorporating the
+  /// --table_name_prefix when set.
+  static std::string getWriteTableName();
 
  protected:
   memory::MemoryPool* aggregatePool() {
diff --git a/velox/exec/fuzzer/RowNumberFuzzer.cpp b/velox/exec/fuzzer/RowNumberFuzzer.cpp
index 7c8c911db75..7d43ec4fd38 100644
--- a/velox/exec/fuzzer/RowNumberFuzzer.cpp
+++ b/velox/exec/fuzzer/RowNumberFuzzer.cpp
@@ -18,15 +18,16 @@
 
 #include <utility>
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/exec/fuzzer/FuzzerUtil.h"
-#include "velox/exec/fuzzer/RowNumberFuzzerBase.h"
+#include "velox/exec/fuzzer/SpillFuzzerBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 namespace facebook::velox::exec {
+using namespace facebook::velox::common::testutil;
 namespace {
 
-class RowNumberFuzzer : public RowNumberFuzzerBase {
+class RowNumberFuzzer : public SpillFuzzerBase {
  public:
   explicit RowNumberFuzzer(
       size_t initialSeed,
@@ -68,7 +69,7 @@ class RowNumberFuzzer : public RowNumberFuzzerBase {
 RowNumberFuzzer::RowNumberFuzzer(
     size_t initialSeed,
     std::unique_ptr<test::ReferenceQueryRunner> referenceQueryRunner)
-    : RowNumberFuzzerBase(initialSeed, std::move(referenceQueryRunner)) {
+    : SpillFuzzerBase(initialSeed, std::move(referenceQueryRunner)) {
   // Set timestamp precision as milliseconds, as timestamp may be used as
   // paritition key, and presto doesn't supports nanosecond precision.
   vectorFuzzer_.getMutableOptions().timestampPrecision =
@@ -109,7 +110,7 @@ std::vector<RowVectorPtr> RowNumberFuzzer::generateInput(
   return input;
 }
 
-RowNumberFuzzerBase::PlanWithSplits RowNumberFuzzer::makeDefaultPlan(
+PlanWithSplits RowNumberFuzzer::makeDefaultPlan(
     const std::vector<std::string>& partitionKeys,
     const std::vector<RowVectorPtr>& input) {
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
@@ -123,7 +124,7 @@ RowNumberFuzzerBase::PlanWithSplits RowNumberFuzzer::makeDefaultPlan(
   return PlanWithSplits{std::move(plan)};
 }
 
-RowNumberFuzzerBase::PlanWithSplits RowNumberFuzzer::makePlanWithTableScan(
+PlanWithSplits RowNumberFuzzer::makePlanWithTableScan(
     const RowTypePtr& type,
     const std::vector<std::string>& partitionKeys,
     const std::vector<Split>& splits) {
@@ -164,8 +165,7 @@ void RowNumberFuzzer::runSingleIteration() {
   test::logVectors(input);
 
   auto defaultPlan = makeDefaultPlan(keyNames, input);
-  const auto expected =
-      execute(defaultPlan, pool_, /*injectSpill=*/false, false);
+  const auto expected = execute(defaultPlan, /*injectSpill=*/false, false);
 
   if (expected != nullptr) {
     validateExpectedResults(defaultPlan.plan, input, expected);
@@ -174,7 +174,7 @@ void RowNumberFuzzer::runSingleIteration() {
   std::vector<PlanWithSplits> altPlans;
   altPlans.push_back(std::move(defaultPlan));
 
-  const auto tableScanDir = exec::test::TempDirectoryPath::create();
+  const auto tableScanDir = TempDirectoryPath::create();
   addPlansWithTableScan(tableScanDir->getPath(), keyNames, input, altPlans);
 
   for (auto i = 0; i < altPlans.size(); ++i) {
diff --git a/velox/exec/fuzzer/SpatialJoinFuzzer.cpp b/velox/exec/fuzzer/SpatialJoinFuzzer.cpp
new file mode 100644
index 00000000000..546315defc3
--- /dev/null
+++ b/velox/exec/fuzzer/SpatialJoinFuzzer.cpp
@@ -0,0 +1,600 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/fuzzer/SpatialJoinFuzzer.h"
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/common/fuzzer/Utils.h"
+#include "velox/exec/fuzzer/FuzzerUtil.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+DEFINE_int32(steps, 10, "Number of plans to generate and test.");
+
+DEFINE_int32(
+    duration_sec,
+    0,
+    "For how long it should run (in seconds). If zero, "
+    "it executes exactly --steps iterations and exits.");
+
+DEFINE_int32(
+    batch_size,
+    100,
+    "The number of elements on each generated vector.");
+
+DEFINE_int32(num_batches, 10, "The number of generated vectors.");
+
+DEFINE_double(
+    null_ratio,
+    0.1,
+    "Chance of adding a null value in a vector "
+    "(expressed as double from 0 to 1).");
+
+namespace facebook::velox::exec {
+
+namespace {
+using namespace facebook::velox;
+
+/// Spatial distribution patterns for geometry generation.
+enum class GeometryDistribution {
+  kUniform, // Geometries uniformly distributed in space
+  kClustered, // Geometries clustered in specific regions
+  kSparse // Sparse geometries with low overlap probability
+};
+
+// Constants for geometry generation.
+constexpr int32_t kRandomCoordinateMax = 1000;
+constexpr int32_t kNumClusters = 5;
+constexpr double kClusterSpacing = 200.0;
+constexpr double kClusterCenterOffset = 100.0;
+constexpr int32_t kClusterSpreadRange = 100;
+constexpr int32_t kClusterSpreadHalf = kClusterSpreadRange / 2;
+constexpr double kPolygonSize = 10.0;
+constexpr double kSparseSpread = 2000.0;
+constexpr uint32_t kMaxRadius = 100;
+
+// Base class for geometry string generators.
+class GeometryInputGenerator : public AbstractInputGenerator {
+ public:
+  GeometryInputGenerator(
+      GeometryDistribution distribution,
+      size_t seed,
+      double nullRatio)
+      : AbstractInputGenerator(seed, VARCHAR(), nullptr, nullRatio),
+        distribution_(distribution) {}
+
+ protected:
+  std::pair<double, double> generateCoordinates() {
+    double x{0.0}, y{0.0};
+    switch (distribution_) {
+      case GeometryDistribution::kUniform: {
+        x = fuzzer::rand<int32_t>(
+            rng_, -kRandomCoordinateMax, kRandomCoordinateMax);
+        y = fuzzer::rand<int32_t>(
+            rng_, -kRandomCoordinateMax, kRandomCoordinateMax);
+        break;
+      }
+      case GeometryDistribution::kClustered: {
+        uint32_t cluster = fuzzer::rand<uint32_t>(rng_, 0, kNumClusters);
+        double centerX = (cluster * kClusterSpacing) + kClusterCenterOffset;
+        double centerY = (cluster * kClusterSpacing) + kClusterCenterOffset;
+        x = centerX +
+            ((fuzzer::rand<int32_t>(
+                 rng_, -kClusterSpreadRange, kClusterSpreadRange)) -
+             kClusterSpreadHalf);
+        y = centerY +
+            ((fuzzer::rand<int32_t>(
+                 rng_, -kClusterSpreadRange, kClusterSpreadRange)) -
+             kClusterSpreadHalf);
+        break;
+      }
+      case GeometryDistribution::kSparse: {
+        x = fuzzer::rand<int32_t>(rng_, -kSparseSpread, kSparseSpread);
+        y = fuzzer::rand<int32_t>(rng_, -kSparseSpread, kSparseSpread);
+        break;
+      }
+      default:
+        VELOX_UNREACHABLE();
+    }
+    return {x, y};
+  }
+
+  GeometryDistribution distribution_;
+};
+
+// Generates POINT geometry strings.
+class PointInputGenerator : public GeometryInputGenerator {
+ public:
+  PointInputGenerator(
+      GeometryDistribution distribution,
+      size_t seed,
+      double nullRatio)
+      : GeometryInputGenerator(distribution, seed, nullRatio) {}
+
+  variant generate() override {
+    if (fuzzer::coinToss(rng_, nullRatio_)) {
+      return variant::null(type_->kind());
+    }
+
+    auto [x, y] = generateCoordinates();
+    return fmt::format("POINT ({} {})", x, y);
+  }
+};
+
+// Generates POLYGON geometry strings.
+class PolygonInputGenerator : public GeometryInputGenerator {
+ public:
+  PolygonInputGenerator(
+      GeometryDistribution distribution,
+      size_t seed,
+      double nullRatio)
+      : GeometryInputGenerator(distribution, seed, nullRatio) {}
+
+  variant generate() override {
+    if (fuzzer::coinToss(rng_, nullRatio_)) {
+      return variant::null(type_->kind());
+    }
+    auto [centerX, centerY] = generateCoordinates();
+    return fmt::format(
+        "POLYGON (({} {}, {} {}, {} {}, {} {}, {} {}))",
+        centerX - kPolygonSize,
+        centerY - kPolygonSize,
+        centerX + kPolygonSize,
+        centerY - kPolygonSize,
+        centerX + kPolygonSize,
+        centerY + kPolygonSize,
+        centerX - kPolygonSize,
+        centerY + kPolygonSize,
+        centerX - kPolygonSize,
+        centerY - kPolygonSize);
+  }
+};
+
+// Generates LINESTRING geometry strings.
+class LineStringInputGenerator : public GeometryInputGenerator {
+ public:
+  LineStringInputGenerator(
+      GeometryDistribution distribution,
+      size_t seed,
+      double nullRatio)
+      : GeometryInputGenerator(distribution, seed, nullRatio) {}
+
+  variant generate() override {
+    if (fuzzer::coinToss(rng_, nullRatio_)) {
+      return variant::null(type_->kind());
+    }
+    auto [x1, y1] = generateCoordinates();
+    double x2 = x1 + kPolygonSize;
+    double y2 = y1 + kPolygonSize;
+    return fmt::format("LINESTRING ({} {}, {} {})", x1, y1, x2, y2);
+  }
+};
+
+class SpatialJoinFuzzer {
+ public:
+  explicit SpatialJoinFuzzer(size_t initialSeed);
+
+  void go();
+
+ private:
+  static VectorFuzzer::Options getFuzzerOptions() {
+    VectorFuzzer::Options opts;
+    opts.vectorSize = FLAGS_batch_size;
+    opts.stringVariableLength = true;
+    opts.stringLength = 100;
+    opts.nullRatio = FLAGS_null_ratio;
+    return opts;
+  }
+
+  void seed(size_t seed) {
+    currentSeed_ = seed;
+    vectorFuzzer_.reSeed(seed);
+    rng_.seed(currentSeed_);
+  }
+
+  void reSeed() {
+    seed(rng_());
+  }
+
+  // Randomly pick a join type supported by SpatialJoin.
+  core::JoinType pickJoinType();
+
+  // Randomly pick a spatial predicate function.
+  std::string pickSpatialPredicate();
+
+  // Randomly pick a geometry distribution pattern.
+  GeometryDistribution pickDistribution();
+
+  // Runs one test iteration from query plans generation, execution and result
+  // verification.
+  void verify(core::JoinType joinType);
+
+  // Creates a vector of POINT geometries with specified distribution.
+  VectorPtr makePointVector(int32_t size, GeometryDistribution distribution);
+
+  // Creates a vector of POLYGON geometries with specified distribution.
+  VectorPtr makePolygonVector(int32_t size, GeometryDistribution distribution);
+
+  // Creates a vector of LINESTRING geometries with specified distribution.
+  VectorPtr makeLineStringVector(
+      int32_t size,
+      GeometryDistribution distribution);
+
+  // Returns randomly generated probe input with geometry columns (as WKT
+  // strings).
+  std::vector<RowVectorPtr> generateProbeInput(
+      GeometryDistribution distribution);
+
+  // Same as generateProbeInput() but copies over 10% of the input to ensure
+  // some matches during joining. Also generates an empty input with a 10%
+  // chance.
+  std::vector<RowVectorPtr> generateBuildInput(
+      const std::vector<RowVectorPtr>& probeInput,
+      GeometryDistribution distribution);
+
+  // Executes a plan and returns the result.
+  RowVectorPtr execute(const core::PlanNodePtr& plan);
+
+  int32_t randInt(int32_t min, int32_t max) {
+    return boost::random::uniform_int_distribution<int32_t>(min, max)(rng_);
+  }
+
+  const std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
+  std::mt19937 rng_;
+  size_t currentSeed_{0};
+
+  VectorFuzzer vectorFuzzer_;
+
+  struct {
+    size_t numIterations{0};
+  } stats_;
+};
+
+SpatialJoinFuzzer::SpatialJoinFuzzer(size_t initialSeed)
+    : vectorFuzzer_{getFuzzerOptions(), pool_.get()} {
+  filesystems::registerLocalFileSystem();
+  seed(initialSeed);
+}
+
+template <typename T>
+bool isDone(size_t i, T startTime) {
+  if (FLAGS_duration_sec > 0) {
+    std::chrono::duration<double> elapsed =
+        std::chrono::system_clock::now() - startTime;
+    return elapsed.count() >= FLAGS_duration_sec;
+  }
+  return i >= FLAGS_steps;
+}
+
+core::JoinType SpatialJoinFuzzer::pickJoinType() {
+  // SpatialJoin only supports INNER and LEFT join types.
+  static std::vector<core::JoinType> kJoinTypes = {
+      core::JoinType::kInner, core::JoinType::kLeft};
+
+  const size_t idx = randInt(0, kJoinTypes.size() - 1);
+  return kJoinTypes[idx];
+}
+
+std::string SpatialJoinFuzzer::pickSpatialPredicate() {
+  // Common spatial predicates supported by spatial joins.
+  static std::vector<std::string> kPredicates = {
+      "ST_Intersects",
+      "ST_Contains",
+      "ST_Within",
+      "ST_Distance",
+      "ST_Overlaps",
+      "ST_Crosses",
+      "ST_Touches",
+      "ST_Equals"};
+
+  const size_t idx = randInt(0, kPredicates.size() - 1);
+  return kPredicates[idx];
+}
+
+GeometryDistribution SpatialJoinFuzzer::pickDistribution() {
+  static std::vector<GeometryDistribution> kDistributions = {
+      GeometryDistribution::kUniform,
+      GeometryDistribution::kClustered,
+      GeometryDistribution::kSparse};
+
+  const size_t idx = randInt(0, kDistributions.size() - 1);
+  return kDistributions[idx];
+}
+
+VectorPtr SpatialJoinFuzzer::makePointVector(
+    int32_t size,
+    GeometryDistribution distribution) {
+  auto generator = std::make_shared<PointInputGenerator>(
+      distribution, currentSeed_, getFuzzerOptions().nullRatio);
+  return vectorFuzzer_.fuzzFlat(VARCHAR(), size, generator);
+}
+
+VectorPtr SpatialJoinFuzzer::makePolygonVector(
+    int32_t size,
+    GeometryDistribution distribution) {
+  auto generator = std::make_shared<PolygonInputGenerator>(
+      distribution, currentSeed_, getFuzzerOptions().nullRatio);
+  return vectorFuzzer_.fuzzFlat(VARCHAR(), size, generator);
+}
+
+VectorPtr SpatialJoinFuzzer::makeLineStringVector(
+    int32_t size,
+    GeometryDistribution distribution) {
+  auto generator = std::make_shared<LineStringInputGenerator>(
+      distribution, currentSeed_, getFuzzerOptions().nullRatio);
+  return vectorFuzzer_.fuzzFlat(VARCHAR(), size, generator);
+}
+
+std::vector<RowVectorPtr> SpatialJoinFuzzer::generateProbeInput(
+    GeometryDistribution distribution) {
+  std::vector<RowVectorPtr> input;
+
+  const int32_t numRows = FLAGS_batch_size * FLAGS_num_batches;
+  const int32_t batchSize = FLAGS_batch_size;
+  const int32_t numBatches = FLAGS_num_batches;
+
+  // Randomly pick geometry type for probe side.
+  const int geometryType = randInt(0, 2);
+
+  for (int32_t i = 0; i < numBatches; ++i) {
+    int32_t currentBatchSize = std::min(batchSize, numRows - (i * batchSize));
+
+    VectorPtr geomVector;
+    if (geometryType == 0) {
+      geomVector = makePointVector(currentBatchSize, distribution);
+    } else if (geometryType == 1) {
+      geomVector = makePolygonVector(currentBatchSize, distribution);
+    } else {
+      geomVector = makeLineStringVector(currentBatchSize, distribution);
+    }
+
+    auto idVector = vectorFuzzer_.fuzzFlat(BIGINT(), currentBatchSize);
+    auto rowType = ROW(
+        {"probe_id", "probe_geom_wkt"}, {idVector->type(), geomVector->type()});
+    auto rowVector = std::make_shared<RowVector>(
+        pool_.get(),
+        rowType,
+        nullptr,
+        currentBatchSize,
+        std::vector{idVector, geomVector});
+    input.push_back(rowVector);
+  }
+
+  return input;
+}
+
+std::vector<RowVectorPtr> SpatialJoinFuzzer::generateBuildInput(
+    const std::vector<RowVectorPtr>& probeInput,
+    GeometryDistribution distribution) {
+  std::vector<RowVectorPtr> input;
+
+  // 1 in 10 times use empty build.
+  if (vectorFuzzer_.coinToss(0.1)) {
+    auto rowType = ROW({"build_id", "build_geom_wkt"}, {BIGINT(), VARCHAR()});
+    auto rowVector = std::make_shared<RowVector>(
+        pool_.get(),
+        rowType,
+        nullptr,
+        0,
+        std::vector{
+            vectorFuzzer_.fuzzFlat(BIGINT(), 0),
+            vectorFuzzer_.fuzzFlat(VARCHAR(), 0)});
+    return {rowVector};
+  }
+
+  // Randomly pick geometry type for build side.
+  const int geometryType = randInt(0, 2);
+
+  for (const auto& probe : probeInput) {
+    auto numRows = 1 + probe->size() / 8;
+
+    VectorPtr geomVector;
+    if (geometryType == 0) {
+      geomVector = makePointVector(numRows, distribution);
+    } else if (geometryType == 1) {
+      geomVector = makePolygonVector(numRows, distribution);
+    } else {
+      geomVector = makeLineStringVector(numRows, distribution);
+    }
+
+    auto idVector = vectorFuzzer_.fuzzFlat(BIGINT(), numRows);
+
+    // To ensure some matches, copy some geometries from probe side.
+    if (probe->size() > 0) {
+      std::vector<vector_size_t> rowNumbers(numRows);
+      SelectivityVector rows(numRows, false);
+      for (vector_size_t i = 0; i < numRows; ++i) {
+        if (vectorFuzzer_.coinToss(0.3)) {
+          rowNumbers[i] = randInt(0, probe->size() - 1);
+          rows.setValid(i, true);
+        }
+      }
+
+      // Copy geometry from probe to build.
+      auto probeGeom = probe->childAt(1);
+      geomVector->copy(probeGeom.get(), rows, rowNumbers.data());
+    }
+
+    auto rowType = ROW(
+        {"build_id", "build_geom_wkt"}, {idVector->type(), geomVector->type()});
+    auto rowVector = std::make_shared<RowVector>(
+        pool_.get(),
+        rowType,
+        nullptr,
+        numRows,
+        std::vector{idVector, geomVector});
+    input.push_back(rowVector);
+  }
+
+  return input;
+}
+
+RowVectorPtr SpatialJoinFuzzer::execute(const core::PlanNodePtr& plan) {
+  LOG(INFO) << "Executing query plan: " << std::endl
+            << plan->toString(true, true);
+
+  return test::AssertQueryBuilder(plan).copyResults(pool_.get());
+}
+
+void SpatialJoinFuzzer::verify(core::JoinType joinType) {
+  const auto distribution = pickDistribution();
+  const auto predicate = pickSpatialPredicate();
+
+  // Generate test data (WKT strings).
+  auto probeInput = generateProbeInput(distribution);
+  auto buildInput = generateBuildInput(probeInput, distribution);
+
+  if (VLOG_IS_ON(1)) {
+    VLOG(1) << "Probe input: " << probeInput[0]->toString();
+    for (const auto& v : probeInput) {
+      VLOG(1) << std::endl << v->toString(0, v->size());
+    }
+
+    VLOG(1) << "Build input: " << buildInput[0]->toString();
+    for (const auto& v : buildInput) {
+      VLOG(1) << std::endl << v->toString(0, v->size());
+    }
+  }
+
+  // Build spatial join plan with geometry conversion as part of the plan.
+  const auto planNodeIdGenerator =
+      std::make_shared<core::PlanNodeIdGenerator>();
+
+  std::string joinCondition;
+  std::optional<std::string> radiusColumn;
+  std::optional<std::string> radiusExpression;
+  if (predicate == "ST_Distance") {
+    // ST_Distance returns a value, use it with a threshold.
+    // For ST_Distance, we use a radius column instead of embedding the
+    // threshold in the join condition.
+    joinCondition =
+        fmt::format("{}(probe_geom, build_geom) < radius", predicate);
+    radiusColumn = "radius";
+    radiusExpression = fmt::format(
+        "CAST({} AS DOUBLE) AS radius",
+        static_cast<double>(randInt(0, kMaxRadius)));
+  } else {
+    // Other predicates return boolean.
+    joinCondition = fmt::format("{}(probe_geom, build_geom)", predicate);
+  }
+
+  // Create SpatialJoin plan with geometry conversion projections.
+  auto spatialJoinPlan =
+      test::PlanBuilder(planNodeIdGenerator)
+          .values(probeInput)
+          // Convert probe WKT strings to Geometry
+          .project(
+              {"probe_id",
+               "ST_GeometryFromText(probe_geom_wkt) AS probe_geom",
+               "probe_geom_wkt"})
+          .spatialJoin(
+              test::PlanBuilder(planNodeIdGenerator)
+                  .values(buildInput)
+                  // Convert build WKT strings to Geometry
+                  .project(
+                      radiusColumn.has_value()
+                          ? std::vector<
+                                std::
+                                    string>{"build_id", "ST_GeometryFromText(build_geom_wkt) AS build_geom", "build_geom_wkt", radiusExpression.value()}
+                          : std::vector<
+                                std::
+                                    string>{"build_id", "ST_GeometryFromText(build_geom_wkt) AS build_geom", "build_geom_wkt"})
+                  .planNode(),
+              joinCondition,
+              "probe_geom",
+              "build_geom",
+              radiusColumn,
+              {"probe_id", "probe_geom_wkt", "build_id", "build_geom_wkt"},
+              joinType)
+          .planNode();
+
+  // Create equivalent NestedLoopJoin plan for comparison.
+  auto nestedLoopJoinPlan =
+      test::PlanBuilder(planNodeIdGenerator)
+          .values(probeInput)
+          // Convert probe WKT strings to Geometry
+          .project(
+              {"probe_id",
+               "ST_GeometryFromText(probe_geom_wkt) AS probe_geom",
+               "probe_geom_wkt"})
+          .nestedLoopJoin(
+              test::PlanBuilder(planNodeIdGenerator)
+                  .values(buildInput)
+                  // Convert build WKT strings to Geometry
+                  .project(
+                      radiusColumn.has_value()
+                          ? std::vector<
+                                std::
+                                    string>{"build_id", "ST_GeometryFromText(build_geom_wkt) AS build_geom", "build_geom_wkt", radiusExpression.value()}
+                          : std::vector<
+                                std::
+                                    string>{"build_id", "ST_GeometryFromText(build_geom_wkt) AS build_geom", "build_geom_wkt"})
+                  .planNode(),
+              {joinCondition},
+              {"probe_id", "probe_geom_wkt", "build_id", "build_geom_wkt"},
+              joinType)
+          .planNode();
+
+  LOG(INFO) << "Executing SpatialJoin plan...";
+  const auto spatialJoinResult = execute(spatialJoinPlan);
+
+  LOG(INFO) << "Executing NestedLoopJoin plan...";
+  const auto nestedLoopJoinResult = execute(nestedLoopJoinPlan);
+
+  // Compare SpatialJoin vs NestedLoopJoin results.
+  auto result =
+      test::assertEqualResults({nestedLoopJoinResult}, {spatialJoinResult});
+  VELOX_CHECK(result, "SpatialJoin and NestedLoopJoin results don't match");
+
+  LOG(INFO) << "SpatialJoin matches NestedLoopJoin.";
+}
+
+void SpatialJoinFuzzer::go() {
+  VELOX_USER_CHECK(
+      FLAGS_steps > 0 || FLAGS_duration_sec > 0,
+      "Either --steps or --duration_sec needs to be greater than zero.");
+  VELOX_USER_CHECK_GE(FLAGS_batch_size, 10, "Batch size must be at least 10.");
+
+  const auto startTime = std::chrono::system_clock::now();
+
+  while (!isDone(stats_.numIterations, startTime)) {
+    LOG(WARNING) << "==============================> Started iteration "
+                 << stats_.numIterations << " (seed: " << currentSeed_ << ")";
+
+    // Pick join type.
+    const auto joinType = pickJoinType();
+
+    verify(joinType);
+
+    LOG(WARNING) << "==============================> Done with iteration "
+                 << stats_.numIterations;
+
+    reSeed();
+    ++stats_.numIterations;
+  }
+
+  LOG(INFO) << "Total iterations: " << stats_.numIterations;
+}
+
+} // namespace
+
+void spatialJoinFuzzer(size_t seed) {
+  SpatialJoinFuzzer(seed).go();
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/fuzzer/SpatialJoinFuzzer.h b/velox/exec/fuzzer/SpatialJoinFuzzer.h
new file mode 100644
index 00000000000..92bdd967213
--- /dev/null
+++ b/velox/exec/fuzzer/SpatialJoinFuzzer.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cstddef>
+namespace facebook::velox::exec {
+
+/// Runs the fuzzer for SpatialJoin operator. Generates random geometry data
+/// and spatial join plans with various predicates (ST_Intersects, ST_Contains,
+/// ST_Within, ST_Distance), comparing SpatialJoin results against
+/// NestedLoopJoin as the reference implementation.
+///
+/// The fuzzer tests:
+/// - Different spatial predicates
+/// - INNER and LEFT join types (the only types supported by SpatialJoin)
+/// - Different geometry types (POINT, POLYGON, LINESTRING)
+/// - Various data distributions (uniform, clustered, sparse)
+/// - Different sizes of probe and build sides
+/// - Plans with and without filters
+/// - Different output column projections
+void spatialJoinFuzzer(size_t seed);
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/fuzzer/SpatialJoinFuzzerRunner.cpp b/velox/exec/fuzzer/SpatialJoinFuzzerRunner.cpp
new file mode 100644
index 00000000000..162429d598d
--- /dev/null
+++ b/velox/exec/fuzzer/SpatialJoinFuzzerRunner.cpp
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/init/Init.h>
+#include <gflags/gflags.h>
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/common/memory/Memory.h"
+#include "velox/exec/fuzzer/SpatialJoinFuzzer.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/parse/TypeResolver.h"
+#include "velox/serializers/PrestoSerializer.h"
+
+DEFINE_int64(
+    seed,
+    0,
+    "Initial seed for random number generator used to reproduce previous "
+    "results (0 means start with random seed).");
+
+using namespace facebook::velox;
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+
+  // Initialize memory system.
+  memory::initializeMemoryManager(memory::MemoryManager::Options{});
+  auto pool = memory::memoryManager()->addLeafPool();
+
+  // Register file systems.
+  filesystems::registerLocalFileSystem();
+
+  // Register Presto functions.
+  functions::prestosql::registerAllScalarFunctions();
+
+  // Register type resolver.
+  parse::registerTypeResolver();
+
+  // Register serializers.
+  if (!isRegisteredNamedVectorSerde("Presto")) {
+    serializer::presto::PrestoVectorSerde::registerNamedVectorSerde();
+  }
+
+  // Determine the seed.
+  size_t seed = FLAGS_seed == 0 ? std::random_device{}() : FLAGS_seed;
+  LOG(INFO) << "Using seed: " << seed;
+
+  // Run the spatial join fuzzer.
+  exec::spatialJoinFuzzer(seed);
+
+  return 0;
+}
diff --git a/velox/exec/fuzzer/RowNumberFuzzerBase.cpp b/velox/exec/fuzzer/SpillFuzzerBase.cpp
similarity index 76%
rename from velox/exec/fuzzer/RowNumberFuzzerBase.cpp
rename to velox/exec/fuzzer/SpillFuzzerBase.cpp
index 1b634b0f23b..b239881e1b1 100644
--- a/velox/exec/fuzzer/RowNumberFuzzerBase.cpp
+++ b/velox/exec/fuzzer/SpillFuzzerBase.cpp
@@ -14,15 +14,16 @@
  * limitations under the License.
  */
 
-#include "velox/exec/fuzzer/RowNumberFuzzerBase.h"
+#include "velox/exec/fuzzer/SpillFuzzerBase.h"
 
 #include <utility>
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/dwio/dwrf/RegisterDwrfReader.h"
+#include "velox/dwio/dwrf/RegisterDwrfWriter.h"
 #include "velox/exec/Spill.h"
 #include "velox/exec/fuzzer/FuzzerUtil.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/serializers/CompactRowSerializer.h"
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/serializers/UnsafeRowSerializer.h"
@@ -66,7 +67,29 @@ DEFINE_bool(
 
 namespace facebook::velox::exec {
 
-RowNumberFuzzerBase::RowNumberFuzzerBase(
+using namespace facebook::velox::common::testutil;
+
+namespace {
+void compareResults(const RowVectorPtr& expected, const RowVectorPtr& actual) {
+  if (actual != nullptr && expected != nullptr) {
+    try {
+      VELOX_CHECK(
+          test::assertEqualResults({expected}, {actual}),
+          "Logically equivalent plans produced different results");
+    } catch (const VeloxException&) {
+      LOG(ERROR) << "Expected\n"
+                 << expected->toString(0, expected->size()) << "\nActual\n"
+                 << actual->toString(0, actual->size());
+      throw;
+    }
+  } else {
+    VELOX_CHECK(
+        FLAGS_enable_oom_injection, "Got unexpected nullptr for results");
+  }
+}
+} // namespace
+
+SpillFuzzerBase::SpillFuzzerBase(
     size_t initialSeed,
     std::unique_ptr<test::ReferenceQueryRunner> referenceQueryRunner)
     : vectorFuzzer_{getFuzzerOptions(), pool_.get()},
@@ -75,17 +98,21 @@ RowNumberFuzzerBase::RowNumberFuzzerBase(
   seed(initialSeed);
 }
 
-void RowNumberFuzzerBase::setupReadWrite() {
+void SpillFuzzerBase::setupReadWrite() {
   filesystems::registerLocalFileSystem();
   dwrf::registerDwrfReaderFactory();
+  dwrf::registerDwrfWriterFactory();
 
-  if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kPresto)) {
+  if (!isRegisteredNamedVectorSerde(
+          VectorSerde::kindName(VectorSerde::Kind::kPresto))) {
     serializer::presto::PrestoVectorSerde::registerNamedVectorSerde();
   }
-  if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kCompactRow)) {
+  if (!isRegisteredNamedVectorSerde(
+          VectorSerde::kindName(VectorSerde::Kind::kCompactRow))) {
     serializer::CompactRowVectorSerde::registerNamedVectorSerde();
   }
-  if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kUnsafeRow)) {
+  if (!isRegisteredNamedVectorSerde(
+          VectorSerde::kindName(VectorSerde::Kind::kUnsafeRow))) {
     serializer::spark::UnsafeRowVectorSerde::registerNamedVectorSerde();
   }
 
@@ -98,20 +125,19 @@ void RowNumberFuzzerBase::setupReadWrite() {
 // Sometimes we generate zero-column input of type ROW({}) or a column of type
 // UNKNOWN(). Such data cannot be written to a file and therefore cannot
 // be tested with TableScan.
-bool RowNumberFuzzerBase::isTableScanSupported(const TypePtr& type) {
-  if (type->kind() == TypeKind::ROW && type->size() == 0) {
-    return false;
-  }
-  if (type->kind() == TypeKind::UNKNOWN) {
-    return false;
-  }
-  if (type->kind() == TypeKind::HUGEINT) {
-    return false;
-  }
-  // Disable testing with TableScan when input contains TIMESTAMP type, due to
-  // the issue #8127.
-  if (type->kind() == TypeKind::TIMESTAMP) {
-    return false;
+bool SpillFuzzerBase::isTableScanSupported(const TypePtr& type) {
+  switch (type->kind()) {
+    case TypeKind::UNKNOWN:
+    case TypeKind::HUGEINT:
+    case TypeKind::TIMESTAMP:
+      return false;
+    case TypeKind::ROW:
+      if (type->size() == 0) {
+        return false;
+      }
+      break;
+    default:
+      break;
   }
 
   for (auto i = 0; i < type->size(); ++i) {
@@ -123,7 +149,7 @@ bool RowNumberFuzzerBase::isTableScanSupported(const TypePtr& type) {
   return true;
 }
 
-void RowNumberFuzzerBase::validateExpectedResults(
+void SpillFuzzerBase::validateExpectedResults(
     const core::PlanNodePtr& plan,
     const std::vector<RowVectorPtr>& input,
     const RowVectorPtr& result) {
@@ -149,7 +175,7 @@ bool isDone(size_t i, T startTime) {
   return i >= FLAGS_steps;
 }
 
-void RowNumberFuzzerBase::run() {
+void SpillFuzzerBase::run() {
   VELOX_USER_CHECK(
       FLAGS_steps > 0 || FLAGS_duration_sec > 0,
       "Either --steps or --duration_sec needs to be greater than zero.");
@@ -170,9 +196,8 @@ void RowNumberFuzzerBase::run() {
   }
 }
 
-RowVectorPtr RowNumberFuzzerBase::execute(
+RowVectorPtr SpillFuzzerBase::execute(
     const PlanWithSplits& plan,
-    const std::shared_ptr<memory::MemoryPool>& pool,
     bool injectSpill,
     bool injectOOM,
     const std::optional<std::string>& spillConfig,
@@ -191,8 +216,8 @@ RowVectorPtr RowNumberFuzzerBase::execute(
         "Spill config not set for execute with spilling");
     VELOX_CHECK_GE(
         maxSpillLevel, 0, "Max spill should be set for execute with spilling");
-    std::shared_ptr<test::TempDirectoryPath> spillDirectory;
-    spillDirectory = exec::test::TempDirectoryPath::create();
+    std::shared_ptr<TempDirectoryPath> spillDirectory;
+    spillDirectory = TempDirectoryPath::create();
     builder.config(core::QueryConfig::kSpillEnabled, true)
         .config(core::QueryConfig::kMaxSpillLevel, maxSpillLevel)
         .config(spillConfig.value(), true)
@@ -216,7 +241,7 @@ RowVectorPtr RowNumberFuzzerBase::execute(
   TestScopedSpillInjection scopedSpillInjection(spillPct);
   RowVectorPtr result;
   try {
-    result = builder.copyResults(pool.get());
+    result = builder.copyResults(pool_.get());
   } catch (VeloxRuntimeError& e) {
     if (injectOOM &&
         e.errorCode() == facebook::velox::error_code::kMemCapExceeded &&
@@ -236,50 +261,30 @@ RowVectorPtr RowNumberFuzzerBase::execute(
   return result;
 }
 
-void RowNumberFuzzerBase::testPlan(
+void SpillFuzzerBase::testPlan(
     const PlanWithSplits& plan,
     int32_t testNumber,
     const RowVectorPtr& expected,
     const std::optional<std::string>& spillConfig) {
   LOG(INFO) << "Testing plan #" << testNumber;
 
-  auto actual =
-      execute(plan, pool_, /*injectSpill=*/false, FLAGS_enable_oom_injection);
-  if (actual != nullptr && expected != nullptr) {
-    VELOX_CHECK(
-        test::assertEqualResults({expected}, {actual}),
-        "Logically equivalent plans produced different results");
-  } else {
-    VELOX_CHECK(
-        FLAGS_enable_oom_injection, "Got unexpected nullptr for results");
-  }
+  // Test without spilling first, then with spilling if enabled.
+  const bool testSpill = FLAGS_enable_spill;
+  for (int round = 0; round < (testSpill ? 2 : 1); ++round) {
+    const bool injectSpill = round == 1;
+    if (injectSpill) {
+      LOG(INFO) << "Testing plan #" << testNumber << " with spilling";
+    }
 
-  if (FLAGS_enable_spill) {
-    LOG(INFO) << "Testing plan #" << testNumber << " with spilling";
     const auto fuzzMaxSpillLevel =
         FLAGS_max_spill_level == -1 ? randInt(0, 3) : FLAGS_max_spill_level;
-    actual = execute(
+    auto actual = execute(
         plan,
-        pool_,
-        /*=injectSpill=*/true,
+        injectSpill,
         FLAGS_enable_oom_injection,
-        spillConfig,
-        fuzzMaxSpillLevel);
-    if (actual != nullptr && expected != nullptr) {
-      try {
-        VELOX_CHECK(
-            test::assertEqualResults({expected}, {actual}),
-            "Logically equivalent plans produced different results");
-      } catch (const VeloxException&) {
-        LOG(ERROR) << "Expected\n"
-                   << expected->toString(0, expected->size()) << "\nActual\n"
-                   << actual->toString(0, actual->size());
-        throw;
-      }
-    } else {
-      VELOX_CHECK(
-          FLAGS_enable_oom_injection, "Got unexpected nullptr for results");
-    }
+        injectSpill ? spillConfig : std::nullopt,
+        injectSpill ? fuzzMaxSpillLevel : -1);
+    compareResults(expected, actual);
   }
 }
 
diff --git a/velox/exec/fuzzer/RowNumberFuzzerBase.h b/velox/exec/fuzzer/SpillFuzzerBase.h
similarity index 83%
rename from velox/exec/fuzzer/RowNumberFuzzerBase.h
rename to velox/exec/fuzzer/SpillFuzzerBase.h
index 1aaf5f4f3b0..4f25116bef1 100644
--- a/velox/exec/fuzzer/RowNumberFuzzerBase.h
+++ b/velox/exec/fuzzer/SpillFuzzerBase.h
@@ -41,21 +41,31 @@ DECLARE_bool(enable_oom_injection);
 
 namespace facebook::velox::exec {
 
-class RowNumberFuzzerBase {
+struct PlanWithSplits {
+  core::PlanNodePtr plan;
+  std::vector<Split> splits;
+
+  explicit PlanWithSplits(
+      core::PlanNodePtr _plan,
+      const std::vector<Split>& _splits = {})
+      : plan(std::move(_plan)), splits(_splits) {}
+};
+
+class SpillFuzzerBase {
  public:
-  explicit RowNumberFuzzerBase(
+  explicit SpillFuzzerBase(
       size_t initialSeed,
       std::unique_ptr<test::ReferenceQueryRunner>);
 
   void run();
 
-  virtual ~RowNumberFuzzerBase() = default;
+  virtual ~SpillFuzzerBase() = default;
 
  protected:
   bool isTableScanSupported(const TypePtr& type);
 
-  // Runs one test iteration from query plans generations, executions and result
-  // verifications.
+  // Runs one test iteration from query plans generations, executions and
+  // result verifications.
   virtual void runSingleIteration() = 0;
 
   // Sets up the Dwrf reader/writer, serializers and Hive connector for the
@@ -91,27 +101,16 @@ class RowNumberFuzzerBase {
       const std::vector<RowVectorPtr>& input,
       const RowVectorPtr& result);
 
-  struct PlanWithSplits {
-    core::PlanNodePtr plan;
-    std::vector<Split> splits;
-
-    explicit PlanWithSplits(
-        core::PlanNodePtr _plan,
-        const std::vector<Split>& _splits = {})
-        : plan(std::move(_plan)), splits(_splits) {}
-  };
-
-  // Executes a plan with spilling and oom injection possibly.
+  // Executes a plan with optional spill and OOM injection.
   RowVectorPtr execute(
       const PlanWithSplits& plan,
-      const std::shared_ptr<memory::MemoryPool>& pool,
       bool injectSpill,
       bool injectOOM,
       const std::optional<std::string>& spillConfig = std::nullopt,
       int maxSpillLevel = -1);
 
-  // Tests a plan by executing it with and without spilling. OOM injection
-  // also might be done based on FLAG_enable_oom_injection.
+  // Tests a plan by executing it with and without spilling. OOM injection is
+  // controlled by FLAGS_enable_oom_injection.
   void testPlan(
       const PlanWithSplits& plan,
       int32_t testNumber,
@@ -123,15 +122,15 @@ class RowNumberFuzzerBase {
 
   std::shared_ptr<memory::MemoryPool> rootPool_{
       memory::memoryManager()->addRootPool(
-          "rowNumberFuzzer",
+          "spillFuzzer",
           memory::kMaxMemory,
           exec::MemoryReclaimer::create())};
   std::shared_ptr<memory::MemoryPool> pool_{rootPool_->addLeafChild(
-      "rowNumberFuzzerLeaf",
+      "spillFuzzerLeaf",
       true,
       exec::MemoryReclaimer::create())};
   std::shared_ptr<memory::MemoryPool> writerPool_{rootPool_->addAggregateChild(
-      "rowNumberFuzzerWriter",
+      "spillFuzzerWriter",
       exec::MemoryReclaimer::create())};
   VectorFuzzer vectorFuzzer_;
   std::unique_ptr<test::ReferenceQueryRunner> referenceQueryRunner_;
diff --git a/velox/exec/fuzzer/TopNRowNumberFuzzer.cpp b/velox/exec/fuzzer/TopNRowNumberFuzzer.cpp
index 7d658aa6888..ac66df864c1 100644
--- a/velox/exec/fuzzer/TopNRowNumberFuzzer.cpp
+++ b/velox/exec/fuzzer/TopNRowNumberFuzzer.cpp
@@ -16,18 +16,21 @@
 
 #include "velox/exec/fuzzer/TopNRowNumberFuzzer.h"
 
+#include <folly/String.h>
+#include <string_view>
 #include <utility>
 
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/exec/fuzzer/FuzzerUtil.h"
-#include "velox/exec/fuzzer/RowNumberFuzzerBase.h"
+#include "velox/exec/fuzzer/SpillFuzzerBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/vector/tests/utils/VectorMaker.h"
 
 namespace facebook::velox::exec {
+using namespace facebook::velox::common::testutil;
 namespace {
 
-class TopNRowNumberFuzzer : public RowNumberFuzzerBase {
+class TopNRowNumberFuzzer : public SpillFuzzerBase {
  public:
   explicit TopNRowNumberFuzzer(
       size_t initialSeed,
@@ -41,6 +44,8 @@ class TopNRowNumberFuzzer : public RowNumberFuzzerBase {
   std::pair<std::vector<std::string>, std::vector<TypePtr>> generateKeys(
       const std::string& prefix);
 
+  std::string generateRankFunction();
+
   std::vector<RowVectorPtr> generateInput(
       const std::vector<std::string>& keyNames,
       const std::vector<TypePtr>& keyTypes,
@@ -49,24 +54,36 @@ class TopNRowNumberFuzzer : public RowNumberFuzzerBase {
 
   // Makes the query plan with default settings in TopNRowNumberFuzzer.
   std::pair<PlanWithSplits, int32_t> makeDefaultPlan(
+      std::string_view rankFunction,
       const std::vector<std::string>& partitionKeys,
       const std::vector<std::string>& sortKeys,
       const std::vector<std::string>& allKeys,
       const std::vector<RowVectorPtr>& input);
 
   PlanWithSplits makePlanWithTableScan(
+      std::string_view rankFunction,
       const std::vector<std::string>& partitionKeys,
       const std::vector<std::string>& sortKeys,
       const std::vector<std::string>& allKeys,
       int limit,
       const std::vector<RowVectorPtr>& input,
       const std::string& tableDir);
+
+  // Makes an alternate plan using WindowNode with the same rank function,
+  // then filters rows where the rank value is within the limit.
+  PlanWithSplits makeWindowPlan(
+      std::string_view rankFunction,
+      const std::vector<std::string>& partitionKeys,
+      const std::vector<std::string>& sortKeys,
+      const std::vector<std::string>& allKeys,
+      int32_t limit,
+      const std::vector<RowVectorPtr>& input);
 };
 
 TopNRowNumberFuzzer::TopNRowNumberFuzzer(
     size_t initialSeed,
     std::unique_ptr<test::ReferenceQueryRunner> referenceQueryRunner)
-    : RowNumberFuzzerBase(initialSeed, std::move(referenceQueryRunner)) {}
+    : SpillFuzzerBase(initialSeed, std::move(referenceQueryRunner)) {}
 
 std::pair<std::vector<std::string>, std::vector<TypePtr>>
 TopNRowNumberFuzzer::generateKeys(const std::string& prefix) {
@@ -93,6 +110,19 @@ TopNRowNumberFuzzer::generateKeys(const std::string& prefix) {
   return std::make_pair(keys, types);
 }
 
+std::string TopNRowNumberFuzzer::generateRankFunction() {
+  int32_t rankFunction = randInt(0, 2);
+  switch (rankFunction) {
+    case 0:
+      return "row_number";
+    case 1:
+      return "rank";
+    case 2:
+      return "dense_rank";
+  }
+  return "row_number";
+}
+
 std::vector<RowVectorPtr> TopNRowNumberFuzzer::generateInput(
     const std::vector<std::string>& keyNames,
     const std::vector<TypePtr>& keyTypes,
@@ -153,12 +183,14 @@ std::vector<RowVectorPtr> TopNRowNumberFuzzer::generateInput(
         // values. This is done to introduce some repetition of key values for
         // windowing.
         auto baseVector = vectorFuzzer_.fuzz(keyTypes[i], numPartitions);
-        children.push_back(BaseVector::wrapInDictionary(
-            partitionNulls, partitionIndices, size, baseVector));
+        children.push_back(
+            BaseVector::wrapInDictionary(
+                partitionNulls, partitionIndices, size, baseVector));
       } else if (sortingKeySet.find(keyNames[i]) != sortingKeySet.end()) {
         auto baseVector = vectorFuzzer_.fuzz(keyTypes[i], numPeerGroups);
-        children.push_back(BaseVector::wrapInDictionary(
-            sortingNulls, sortingIndices, size, baseVector));
+        children.push_back(
+            BaseVector::wrapInDictionary(
+                sortingNulls, sortingIndices, size, baseVector));
       } else {
         children.push_back(vectorFuzzer_.fuzz(keyTypes[i], size));
       }
@@ -171,26 +203,26 @@ std::vector<RowVectorPtr> TopNRowNumberFuzzer::generateInput(
   return input;
 }
 
-std::pair<RowNumberFuzzerBase::PlanWithSplits, int32_t>
-TopNRowNumberFuzzer::makeDefaultPlan(
+std::pair<PlanWithSplits, int32_t> TopNRowNumberFuzzer::makeDefaultPlan(
+    std::string_view rankFunction,
     const std::vector<std::string>& partitionKeys,
     const std::vector<std::string>& sortKeys,
     const std::vector<std::string>& allKeys,
     const std::vector<RowVectorPtr>& input) {
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   std::vector<std::string> projectFields = allKeys;
   projectFields.emplace_back("row_number");
 
   int32_t limit = randInt(1, FLAGS_batch_size);
   auto plan = test::PlanBuilder()
                   .values(input)
-                  .topNRowNumber(partitionKeys, sortKeys, limit, true)
+                  .topNRank(rankFunction, partitionKeys, sortKeys, limit, true)
                   .project(projectFields)
                   .planNode();
   return std::make_pair(PlanWithSplits{std::move(plan)}, limit);
 }
 
-RowNumberFuzzerBase::PlanWithSplits TopNRowNumberFuzzer::makePlanWithTableScan(
+PlanWithSplits TopNRowNumberFuzzer::makePlanWithTableScan(
+    std::string_view rankFunction,
     const std::vector<std::string>& partitionKeys,
     const std::vector<std::string>& sortKeys,
     const std::vector<std::string>& allKeys,
@@ -205,7 +237,7 @@ RowNumberFuzzerBase::PlanWithSplits TopNRowNumberFuzzer::makePlanWithTableScan(
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   auto plan = test::PlanBuilder(planNodeIdGenerator)
                   .tableScan(asRowType(input[0]->type()))
-                  .topNRowNumber(partitionKeys, sortKeys, limit, true)
+                  .topNRank(rankFunction, partitionKeys, sortKeys, limit, true)
                   .project(projectFields)
                   .planNode();
 
@@ -214,6 +246,39 @@ RowNumberFuzzerBase::PlanWithSplits TopNRowNumberFuzzer::makePlanWithTableScan(
   return PlanWithSplits{plan, splits};
 }
 
+PlanWithSplits TopNRowNumberFuzzer::makeWindowPlan(
+    std::string_view rankFunction,
+    const std::vector<std::string>& partitionKeys,
+    const std::vector<std::string>& sortKeys,
+    const std::vector<std::string>& allKeys,
+    int32_t limit,
+    const std::vector<RowVectorPtr>& input) {
+  // Build the window OVER clause with optional PARTITION BY and ORDER BY.
+  std::string overClause;
+  if (!partitionKeys.empty()) {
+    overClause =
+        fmt::format("partition by {} ", folly::join(", ", partitionKeys));
+  }
+  overClause += fmt::format("order by {}", folly::join(", ", sortKeys));
+
+  // Alias the window output to "row_number" to match the default plan's output
+  // schema, regardless of which rank function (row_number, rank, dense_rank)
+  // is used.
+  auto windowExpr =
+      fmt::format("{}() over ({}) AS row_number", rankFunction, overClause);
+
+  std::vector<std::string> projectFields = allKeys;
+  projectFields.emplace_back("row_number");
+
+  auto plan = test::PlanBuilder()
+                  .values(input)
+                  .window({windowExpr})
+                  .filter(fmt::format("row_number <= {}", limit))
+                  .project(projectFields)
+                  .planNode();
+  return PlanWithSplits{std::move(plan)};
+}
+
 void TopNRowNumberFuzzer::runSingleIteration() {
   const auto [partitionKeys, partitionTypes] = generateKeys("p");
   const auto [sortKeys, sortTypes] = generateKeys("s");
@@ -236,11 +301,12 @@ void TopNRowNumberFuzzer::runSingleIteration() {
   const auto input = generateInput(allKeys, allTypes, partitionKeys, sortKeys);
   test::logVectors(input);
 
+  const auto rankFunction = generateRankFunction();
+
   auto [defaultPlan, limit] =
-      makeDefaultPlan(partitionKeys, allSortKeys, allKeys, input);
+      makeDefaultPlan(rankFunction, partitionKeys, allSortKeys, allKeys, input);
 
-  const auto expected =
-      execute(defaultPlan, pool_, /*injectSpill=*/false, false);
+  const auto expected = execute(defaultPlan, /*injectSpill=*/false, false);
   if (expected != nullptr) {
     validateExpectedResults(defaultPlan.plan, input, expected);
   }
@@ -248,9 +314,13 @@ void TopNRowNumberFuzzer::runSingleIteration() {
   std::vector<PlanWithSplits> altPlans;
   altPlans.push_back(std::move(defaultPlan));
 
-  const auto tableScanDir = exec::test::TempDirectoryPath::create();
+  altPlans.push_back(makeWindowPlan(
+      rankFunction, partitionKeys, allSortKeys, allKeys, limit, input));
+
+  const auto tableScanDir = TempDirectoryPath::create();
   if (isTableScanSupported(input[0]->type())) {
     altPlans.push_back(makePlanWithTableScan(
+        rankFunction,
         partitionKeys,
         allSortKeys,
         allKeys,
diff --git a/velox/exec/fuzzer/TopNRowNumberFuzzerRunner.cpp b/velox/exec/fuzzer/TopNRowNumberFuzzerRunner.cpp
index b93b49be367..7368ad94c95 100644
--- a/velox/exec/fuzzer/TopNRowNumberFuzzerRunner.cpp
+++ b/velox/exec/fuzzer/TopNRowNumberFuzzerRunner.cpp
@@ -22,6 +22,9 @@
 #include "velox/exec/fuzzer/FuzzerUtil.h"
 #include "velox/exec/fuzzer/ReferenceQueryRunner.h"
 #include "velox/exec/fuzzer/TopNRowNumberFuzzer.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/functions/prestosql/window/WindowFunctionsRegistration.h"
+#include "velox/parse/TypeResolver.h"
 
 /// TopNRowNumberFuzzerRunner leverages TopNRowNumberFuzzer and VectorFuzzer to
 /// automatically generate and execute tests. It works as follows:
@@ -85,6 +88,9 @@ int main(int argc, char** argv) {
   // singletons, installing proper signal handlers for better debugging
   // experience, and initialize glog and gflags.
   folly::Init init(&argc, &argv);
+  functions::prestosql::registerAllScalarFunctions();
+  parse::registerTypeResolver();
+  window::prestosql::registerAllWindowFunctions();
   exec::test::setupMemory(FLAGS_allocator_capacity, FLAGS_arbitrator_capacity);
   std::shared_ptr<memory::MemoryPool> rootPool{
       memory::memoryManager()->addRootPool()};
diff --git a/velox/exec/fuzzer/VeloxQueryRunner.cpp b/velox/exec/fuzzer/VeloxQueryRunner.cpp
new file mode 100644
index 00000000000..765dbc2beab
--- /dev/null
+++ b/velox/exec/fuzzer/VeloxQueryRunner.cpp
@@ -0,0 +1,244 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/fuzzer/VeloxQueryRunner.h"
+
+#include <fmt/format.h>
+#include <folly/Uri.h>
+#include <folly/json.h>
+#include <re2/re2.h>
+#include <thrift/lib/cpp2/async/RocketClientChannel.h>
+#include "velox/core/PlanNode.h"
+#include "velox/exec/fuzzer/if/gen-cpp2/LocalRunnerService.h"
+#include "velox/exec/tests/utils/QueryAssertions.h"
+#include "velox/functions/prestosql/types/BingTileType.h"
+#include "velox/functions/prestosql/types/GeometryType.h"
+#include "velox/functions/prestosql/types/IPAddressType.h"
+#include "velox/functions/prestosql/types/IPPrefixType.h"
+#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/functions/prestosql/types/UuidType.h"
+#include "velox/functions/prestosql/types/parser/TypeParser.h"
+#include "velox/serializers/PrestoSerializer.h"
+
+using namespace facebook::velox::runner;
+
+namespace facebook::velox::exec::test {
+
+namespace {
+
+RowTypePtr parseBatchRowType(Batch batch) {
+  std::vector<std::string> names;
+  std::vector<TypePtr> types;
+
+  for (const auto& name : *batch.columnNames()) {
+    names.push_back(name);
+  }
+
+  // Clean up type strings and format according to TypeParser::parseType
+  // expectation. Input types are serialized by type()->asRow() for Thrift
+  // struct by LocalRunnerService in the format of SOME_COMPLEX_TYPE<TYPE_1,
+  // TYPE_2, etc.> (note the '<' and '>'). And in the case of complex type ROW,
+  // types follow column name and a semicolon: as an example, ROW<f0:TYPE_1,
+  // f1:TYPE_2, etc.>. We need to change these particular character choices to
+  // paranthesis (in the case of the angled brackets) and spaces (in the case of
+  // the semicolon). As an example,
+  //  MAP<VARCHAR,TIMESTAMP> -> MAP(VARCHAR, TIMESTAMP)
+  //  ROW<f0:TYPE_1, f1:TYPE_2, etc.> -> ROW(f0 TYPE_1, f1 TYPE_2, etc.)
+  // as expected by TypeParser::parseType. Without this cleanup, parse will
+  // crash and fuzzer will fail.
+  for (const auto& typeString : *batch.columnTypes()) {
+    auto parsedTypeString = typeString;
+    std::replace(parsedTypeString.begin(), parsedTypeString.end(), '<', '(');
+    std::replace(parsedTypeString.begin(), parsedTypeString.end(), '>', ')');
+    std::replace(parsedTypeString.begin(), parsedTypeString.end(), ':', ' ');
+    types.push_back(functions::prestosql::parseType(parsedTypeString));
+  }
+
+  return ROW(std::move(names), std::move(types));
+}
+
+std::vector<RowVectorPtr> deserializeBatches(
+    const std::vector<Batch>& resultBatches,
+    memory::MemoryPool* pool) {
+  std::vector<RowVectorPtr> queryResults;
+
+  auto serde = std::make_unique<serializer::presto::PrestoVectorSerde>();
+  serializer::presto::PrestoVectorSerde::PrestoOptions options;
+
+  for (const auto& batch : resultBatches) {
+    VELOX_CHECK(
+        apache::thrift::is_non_optional_field_set_manually_or_by_serializer(
+            batch.serializedData()));
+    VELOX_CHECK(!batch.serializedData()->empty());
+
+    // Deserialize binary data.
+    const auto& serializedData = *batch.serializedData();
+    ByteRange byteRange{
+        reinterpret_cast<uint8_t*>(const_cast<char*>(serializedData.data())),
+        static_cast<int32_t>(serializedData.length()),
+        0};
+    auto byteStream = std::make_unique<BufferInputStream>(
+        std::vector<ByteRange>{{byteRange}});
+
+    RowVectorPtr rowVector;
+    serde->deserialize(
+        byteStream.get(),
+        pool,
+        parseBatchRowType(batch),
+        &rowVector,
+        0,
+        &options);
+
+    VELOX_CHECK_NOT_NULL(rowVector);
+    queryResults.push_back(rowVector);
+  }
+
+  return queryResults;
+}
+
+std::shared_ptr<apache::thrift::Client<LocalRunnerService>> createThriftClient(
+    const std::string& host,
+    int port,
+    std::chrono::milliseconds timeout,
+    folly::EventBase* evb) {
+  folly::SocketAddress addr(host, port);
+  auto socket = folly::AsyncSocket::newSocket(evb, addr, timeout.count());
+  auto channel =
+      apache::thrift::RocketClientChannel::newChannel(std::move(socket));
+  return std::make_shared<apache::thrift::Client<LocalRunnerService>>(
+      std::move(channel));
+}
+} // namespace
+
+VeloxQueryRunner::VeloxQueryRunner(
+    memory::MemoryPool* aggregatePool,
+    std::string serviceUri,
+    std::chrono::milliseconds timeout)
+    : ReferenceQueryRunner(aggregatePool),
+      serviceUri_(std::move(serviceUri)),
+      timeout_(timeout) {
+  pool_ = aggregatePool->addLeafChild("leaf");
+
+  folly::Uri uri(serviceUri_);
+  thriftHost_ = uri.host();
+  thriftPort_ = uri.port();
+}
+
+const std::vector<TypePtr>& VeloxQueryRunner::supportedScalarTypes() const {
+  static const std::vector<TypePtr> kScalarTypes{
+      BOOLEAN(),
+      TINYINT(),
+      SMALLINT(),
+      INTEGER(),
+      BIGINT(),
+      REAL(),
+      DOUBLE(),
+      VARCHAR(),
+      VARBINARY(),
+      TIMESTAMP(),
+      TIMESTAMP_WITH_TIME_ZONE(),
+      IPADDRESS(),
+      UUID(),
+      // https://github.com/facebookincubator/velox/issues/15379 (IPPREFIX)
+      // https://github.com/facebookincubator/velox/issues/15380 (Non-orderable
+      // custom types such as HYPERLOGLOG, JSON, BINGTILE, GEOMETRY, etc.)
+  };
+  return kScalarTypes;
+}
+
+const std::unordered_map<std::string, DataSpec>&
+VeloxQueryRunner::aggregationFunctionDataSpecs() const {
+  static const std::unordered_map<std::string, DataSpec>
+      kAggregationFunctionDataSpecs{};
+  return kAggregationFunctionDataSpecs;
+}
+
+std::optional<std::string> VeloxQueryRunner::toSql(
+    const core::PlanNodePtr& /*plan*/) {
+  // We don't need to convert to SQL for VeloxQueryRunner
+  // as we're sending the serialized plan directly
+  VELOX_FAIL("VeloxQueryRunner does not support SQL conversion");
+}
+
+bool VeloxQueryRunner::isConstantExprSupported(
+    const core::TypedExprPtr& /*expr*/) {
+  // Since we're using Velox directly, we support all constant expressions
+  return true;
+}
+
+bool VeloxQueryRunner::isSupported(
+    const exec::FunctionSignature& /*signature*/) {
+  // Since we're using Velox directly, we support all function signatures
+  return true;
+}
+
+std::vector<RowVectorPtr> VeloxQueryRunner::execute(
+    const std::string& /*sql*/) {
+  VELOX_FAIL("VeloxQueryRunner does not support SQL execution");
+}
+
+std::vector<RowVectorPtr> VeloxQueryRunner::execute(
+    const std::string& /*sql*/,
+    const std::string& /*sessionProperty*/) {
+  VELOX_FAIL("VeloxQueryRunner does not support SQL execution");
+}
+
+std::pair<
+    std::optional<std::multiset<std::vector<velox::variant>>>,
+    ReferenceQueryErrorCode>
+VeloxQueryRunner::execute(const core::PlanNodePtr& plan) {
+  auto serializedPlan = serializePlan(plan);
+  auto queryId = fmt::format("velox_local_query_runner_{}", rand());
+
+  auto client =
+      createThriftClient(thriftHost_, thriftPort_, timeout_, &eventBase_);
+
+  // Create the request
+  ExecutePlanRequest request;
+  request.serializedPlan() = serializedPlan;
+  request.queryId() = queryId;
+  request.numWorkers() = 4; // Default value
+  request.numDrivers() = 2; // Default value
+
+  // Send the request
+  ExecutePlanResponse response;
+  try {
+    client->sync_execute(response, request);
+  } catch (const std::exception& e) {
+    VELOX_FAIL("Thrift request failed: {}", e.what());
+  }
+
+  // Handle the response
+  if (*response.success()) {
+    LOG(INFO) << "Reference eval succeeded.";
+    return std::make_pair(
+        exec::test::materialize(
+            deserializeBatches(*response.results(), pool_.get())),
+        ReferenceQueryErrorCode::kSuccess);
+  } else {
+    LOG(INFO) << "Reference eval failed.";
+    return std::make_pair(
+        std::nullopt, ReferenceQueryErrorCode::kReferenceQueryFail);
+  }
+}
+
+std::string VeloxQueryRunner::serializePlan(const core::PlanNodePtr& plan) {
+  // Serialize the plan to JSON
+  folly::dynamic serializedPlan = plan->serialize();
+  return folly::toJson(serializedPlan);
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/VeloxQueryRunner.h b/velox/exec/fuzzer/VeloxQueryRunner.h
new file mode 100644
index 00000000000..67826c62bce
--- /dev/null
+++ b/velox/exec/fuzzer/VeloxQueryRunner.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <folly/io/async/EventBaseThread.h>
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
+#include "velox/vector/ComplexVector.h"
+
+namespace facebook::velox::exec::test {
+
+class VeloxQueryRunner : public ReferenceQueryRunner {
+ public:
+  /// @param serviceUri Thrift URI of the LocalRunnerService.
+  /// @param timeout Timeout in milliseconds of a request.
+  VeloxQueryRunner(
+      memory::MemoryPool* aggregatePool,
+      std::string serviceUri,
+      std::chrono::milliseconds timeout);
+
+  RunnerType runnerType() const override {
+    return RunnerType::kVeloxQueryRunner;
+  }
+
+  const std::vector<TypePtr>& supportedScalarTypes() const override;
+
+  const std::unordered_map<std::string, DataSpec>&
+  aggregationFunctionDataSpecs() const override;
+
+  std::optional<std::string> toSql(const core::PlanNodePtr& plan) override;
+
+  bool isConstantExprSupported(const core::TypedExprPtr& expr) override;
+
+  bool isSupported(const exec::FunctionSignature& signature) override;
+
+  std::pair<
+      std::optional<std::multiset<std::vector<velox::variant>>>,
+      ReferenceQueryErrorCode>
+  execute(const core::PlanNodePtr& plan) override;
+
+  bool supportsVeloxVectorResults() const override {
+    return true;
+  }
+
+  std::vector<RowVectorPtr> execute(const std::string& sql) override;
+
+  std::vector<RowVectorPtr> execute(
+      const std::string& sql,
+      const std::string& sessionProperty) override;
+
+ private:
+  // Serializes the plan node to JSON string
+  std::string serializePlan(const core::PlanNodePtr& plan);
+
+  std::string serviceUri_;
+  std::chrono::milliseconds timeout_;
+  folly::EventBase eventBase_;
+  std::shared_ptr<memory::MemoryPool> pool_;
+
+  // Thrift-specific members
+  std::string thriftHost_;
+  int thriftPort_{9091};
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/WindowFuzzer.cpp b/velox/exec/fuzzer/WindowFuzzer.cpp
index 81eddf15976..10160ad2029 100644
--- a/velox/exec/fuzzer/WindowFuzzer.cpp
+++ b/velox/exec/fuzzer/WindowFuzzer.cpp
@@ -17,8 +17,8 @@
 #include "velox/exec/fuzzer/WindowFuzzer.h"
 
 #include <boost/random/uniform_int_distribution.hpp>
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/expression/ScopedVarSetter.h"
 
 DEFINE_bool(
@@ -28,6 +28,8 @@ DEFINE_bool(
 
 namespace facebook::velox::exec::test {
 
+using namespace facebook::velox::common::testutil;
+
 namespace {
 
 bool supportIgnoreNulls(const std::string& name) {
@@ -81,12 +83,20 @@ std::string WindowFuzzer::generateKRowsFrameBound(
 
   constexpr int64_t kMax = std::numeric_limits<int64_t>::max();
   constexpr int64_t kMin = std::numeric_limits<int64_t>::min();
-  // For frames with kPreceding, kFollowing bounds, pick a valid k, in the
-  // range of 1 to 10, 70% of times. Test for random k values remaining times.
-  int64_t minKValue, maxKValue;
+  // For frames with kPreceding, kFollowing bounds:
+  // - 70%: pick a valid k in the range [1, 10].
+  // - 20%: pick a valid k in the full positive range [1, INT64_MAX].
+  // - 10%: pick from the full range [INT64_MIN, INT64_MAX] to exercise
+  //   invalid (negative/zero) offsets and verify both Velox and the reference
+  //   DB reject them consistently.
+  int64_t minKValue;
+  int64_t maxKValue;
   if (vectorFuzzer_.coinToss(0.7)) {
     minKValue = 1;
     maxKValue = 10;
+  } else if (vectorFuzzer_.coinToss(2.0 / 3.0)) {
+    minKValue = 1;
+    maxKValue = kMax;
   } else {
     minKValue = kMin;
     maxKValue = kMax;
@@ -609,8 +619,9 @@ void WindowFuzzer::testAlternativePlans(
     allKeys.emplace_back(key + " NULLS FIRST");
   }
   for (const auto& keyAndOrder : sortingKeysAndOrders) {
-    allKeys.emplace_back(fmt::format(
-        "{} {}", keyAndOrder.key_, keyAndOrder.sortOrder_.toString()));
+    allKeys.emplace_back(
+        fmt::format(
+            "{} {}", keyAndOrder.key_, keyAndOrder.sortOrder_.toString()));
   }
 
   // Streaming window from values.
@@ -627,7 +638,7 @@ void WindowFuzzer::testAlternativePlans(
   }
 
   // With TableScan.
-  auto directory = exec::test::TempDirectoryPath::create();
+  auto directory = TempDirectoryPath::create();
   const auto inputRowType = asRowType(input[0]->type());
   if (isTableScanSupported(inputRowType)) {
     auto splits = makeSplits(input, directory->getPath(), writerPool_);
diff --git a/velox/exec/fuzzer/WriterFuzzer.cpp b/velox/exec/fuzzer/WriterFuzzer.cpp
index 9c2132c7403..71894a2fe55 100644
--- a/velox/exec/fuzzer/WriterFuzzer.cpp
+++ b/velox/exec/fuzzer/WriterFuzzer.cpp
@@ -16,6 +16,7 @@
 #include "velox/exec/fuzzer/WriterFuzzer.h"
 
 #include <boost/random/uniform_int_distribution.hpp>
+#include <fmt/ranges.h>
 
 #include <re2/re2.h>
 #include <algorithm>
@@ -24,6 +25,7 @@
 #include "velox/common/encode/Base64.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/file/tests/FaultyFileSystem.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
 #include "velox/connectors/hive/TableHandle.h"
@@ -32,7 +34,6 @@
 #include "velox/exec/fuzzer/PrestoQueryRunner.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/expression/fuzzer/FuzzerToolkit.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/vector/VectorSaver.h"
@@ -58,6 +59,13 @@ DEFINE_int32(
 
 DEFINE_int32(num_batches, 10, "The number of generated vectors.");
 
+DEFINE_string(
+    max_target_file_size,
+    "",
+    "Maximum target file size for testing file rotation. "
+    "If empty, randomly selects from various sizes (10KB-5MB) to test edge cases. "
+    "Set to a specific value like '1MB' to use a fixed size.");
+
 DEFINE_double(
     null_ratio,
     0.1,
@@ -68,6 +76,7 @@ using namespace facebook::velox::connector::hive;
 using namespace facebook::velox::test;
 
 namespace facebook::velox::exec::test {
+using namespace facebook::velox::common::testutil;
 
 namespace {
 using facebook::velox::filesystems::FileSystem;
@@ -148,6 +157,17 @@ class WriterFuzzer {
       const std::vector<std::shared_ptr<const HiveSortingColumn>>& sortBy,
       const std::shared_ptr<TempDirectoryPath>& outputDirectoryPath);
 
+  // Verifies file rotation by writing with a small max target file size.
+  // This specifically tests the file split logic for non-bucketed,
+  // non-sorted tables.
+  void verifyFileRotation(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<std::string>& names,
+      const std::vector<TypePtr>& types,
+      int32_t partitionOffset,
+      const std::vector<std::string>& partitionKeys,
+      const std::shared_ptr<TempDirectoryPath>& outputDirectoryPath);
+
   // Generates table column handles based on table column properties
   connector::ColumnHandleMap getTableColumnHandles(
       const std::vector<std::string>& names,
@@ -159,7 +179,8 @@ class WriterFuzzer {
   RowVectorPtr execute(
       const core::PlanNodePtr& plan,
       const int32_t maxDrivers = 2,
-      const std::vector<exec::Split>& splits = {});
+      const std::vector<exec::Split>& splits = {},
+      const std::string& maxTargetFileSizeBytes = "0B");
 
   RowVectorPtr veloxToPrestoResult(const RowVectorPtr& result);
 
@@ -247,7 +268,7 @@ class WriterFuzzer {
   };
 
   // Supported partition key column types
-  // According to VectorHasher::typeKindSupportsValueIds and
+  // According to VectorHasher::typeSupportsValueIds and
   // https://github.com/prestodb/presto/blob/10143be627beb2c61aba5b3d36af473d2a8ef65e/presto-hive/src/main/java/com/facebook/presto/hive/HiveUtil.java#L593
   const std::vector<TypePtr> kPartitionKeyTypes_{
       BOOLEAN(),
@@ -264,6 +285,10 @@ class WriterFuzzer {
   const std::string injectedErrorMsg_{"Injected Faulty File Error"};
   std::atomic<uint64_t> injectedErrorCount_{0};
 
+  // Current max target file size for file rotation testing.
+  // Randomized per iteration to test various file split scenarios.
+  std::string currentMaxTargetFileSize_;
+
   FuzzerGenerator rng_;
   size_t currentSeed_{0};
   std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner_;
@@ -332,8 +357,20 @@ void WriterFuzzer::go() {
   }
 
   while (!isDone(iteration, startTime)) {
+    // Randomize max target file size for file rotation testing.
+    // Use small sizes to trigger file splits. Include very small sizes
+    // (10KB, 50KB) to force many splits and test edge cases.
+    const std::vector<std::string> fileSizes = {
+        "10KB", "50KB", "100KB", "500KB", "1MB", "2MB", "5MB"};
+    auto fileSizeIdx = boost::random::uniform_int_distribution<size_t>(
+        0, fileSizes.size() - 1)(rng_);
+    currentMaxTargetFileSize_ = FLAGS_max_target_file_size.empty()
+        ? fileSizes[fileSizeIdx]
+        : FLAGS_max_target_file_size;
+
     LOG(INFO) << "==============================> Started iteration "
-              << iteration << " (seed: " << currentSeed_ << ")";
+              << iteration << " (seed: " << currentSeed_
+              << ", maxTargetFileSize: " << currentMaxTargetFileSize_ << ")";
 
     std::vector<std::string> names;
     std::vector<TypePtr> types;
@@ -364,11 +401,12 @@ void WriterFuzzer::go() {
           sortColumnOffset -= offset;
           sortBy.reserve(sortColumns.size());
           for (const auto& sortByColumn : sortColumns) {
-            sortBy.push_back(std::make_shared<const HiveSortingColumn>(
-                sortByColumn,
-                kSortOrderTypes_.at(
-                    boost::random::uniform_int_distribution<uint32_t>(
-                        0, 1)(rng_))));
+            sortBy.push_back(
+                std::make_shared<const HiveSortingColumn>(
+                    sortByColumn,
+                    kSortOrderTypes_.at(
+                        boost::random::uniform_int_distribution<uint32_t>(
+                            0, 1)(rng_))));
           }
         }
       }
@@ -379,8 +417,8 @@ void WriterFuzzer::go() {
     }
     auto input = generateInputData(names, types, partitionOffset);
 
-    const auto outputDirPath = exec::test::TempDirectoryPath::create(
-        FLAGS_file_system_error_injection);
+    const auto outputDirPath =
+        TempDirectoryPath::create(FLAGS_file_system_error_injection);
 
     verifyWriter(
         input,
@@ -394,6 +432,20 @@ void WriterFuzzer::go() {
         sortBy,
         outputDirPath);
 
+    // Test file rotation for non-bucketed, non-sorted tables.
+    // File rotation only works when bucketCount == 0 and sortBy is empty.
+    if (bucketCount == 0 && sortBy.empty()) {
+      const auto fileRotationOutputDirPath =
+          TempDirectoryPath::create(FLAGS_file_system_error_injection);
+      verifyFileRotation(
+          input,
+          names,
+          types,
+          partitionOffset,
+          partitionKeys,
+          fileRotationOutputDirPath);
+    }
+
     LOG(INFO) << "==============================> Done with iteration "
               << iteration++;
     reSeed();
@@ -483,8 +535,9 @@ std::vector<RowVectorPtr> WriterFuzzer::generateInputData(
             partitionValues.at(j - partitionOffset), size));
       }
     }
-    input.push_back(std::make_shared<RowVector>(
-        pool_.get(), inputType, nullptr, size, std::move(children)));
+    input.push_back(
+        std::make_shared<RowVector>(
+            pool_.get(), inputType, nullptr, size, std::move(children)));
   }
 
   return input;
@@ -532,7 +585,8 @@ void WriterFuzzer::verifyWriter(
   }
 
   try {
-    referenceQueryRunner_->execute("DROP TABLE IF EXISTS tmp_write");
+    referenceQueryRunner_->execute(
+        "DROP TABLE IF EXISTS " + ReferenceQueryRunner::getWriteTableName());
   } catch (...) {
     LOG(WARNING) << "Drop table query failed in the reference DB";
     return;
@@ -578,7 +632,8 @@ void WriterFuzzer::verifyWriter(
   }
   try {
     auto referenceData = referenceQueryRunner_->execute(
-        "SELECT *" + bucketSql + " FROM tmp_write");
+        "SELECT *" + bucketSql + " FROM " +
+        ReferenceQueryRunner::getWriteTableName());
     VELOX_CHECK(
         assertEqualResults(referenceData, {actual}),
         "Velox and reference DB results don't match");
@@ -635,6 +690,134 @@ void WriterFuzzer::verifyWriter(
   LOG(INFO) << "Verified results against reference DB";
 }
 
+void WriterFuzzer::verifyFileRotation(
+    const std::vector<RowVectorPtr>& input,
+    const std::vector<std::string>& names,
+    const std::vector<TypePtr>& types,
+    const int32_t partitionOffset,
+    const std::vector<std::string>& partitionKeys,
+    const std::shared_ptr<TempDirectoryPath>& outputDirectoryPath) {
+  // Create a non-bucketed, non-sorted table write plan.
+  // File rotation only works for non-bucketed, non-sorted tables.
+  const auto plan = PlanBuilder()
+                        .values(input)
+                        .tableWrite(
+                            outputDirectoryPath->getPath(),
+                            partitionKeys,
+                            dwio::common::FileFormat::DWRF)
+                        .planNode();
+
+  const auto maxDrivers =
+      boost::random::uniform_int_distribution<int32_t>(1, 16)(rng_);
+  RowVectorPtr result;
+  const uint64_t prevInjectedErrorCount = injectedErrorCount_;
+  try {
+    result = veloxToPrestoResult(
+        execute(plan, maxDrivers, {}, currentMaxTargetFileSize_));
+  } catch (VeloxRuntimeError& error) {
+    if (injectedErrorCount_ == prevInjectedErrorCount) {
+      throw error;
+    }
+    VELOX_CHECK_GT(
+        injectedErrorCount_,
+        prevInjectedErrorCount,
+        "Unexpected writer fuzzer failure: {}",
+        error.message());
+    VELOX_CHECK_EQ(
+        error.message(), injectedErrorMsg_, "Unexpected writer fuzzer failure");
+    return;
+  }
+
+  const auto outputPath = outputDirectoryPath->getDelegatePath();
+
+  // 1. Count the number of files created to verify file rotation occurred.
+  const auto partitionNameAndFileCount =
+      getPartitionNameAndFilecount(outputPath);
+  int32_t totalFileCount = 0;
+  for (const auto& [partitionName, fileCount] : partitionNameAndFileCount) {
+    totalFileCount += fileCount;
+  }
+  LOG(INFO) << "File rotation: " << totalFileCount
+            << " files created with max target file size "
+            << currentMaxTargetFileSize_;
+
+  // 2. Verify the written data by reading it back.
+  auto splits = makeSplits(outputPath);
+  auto columnHandles =
+      getTableColumnHandles(names, types, partitionOffset, /*bucketCount=*/0);
+  const auto rowType = generateOutputType(names, types, /*bucketCount=*/0);
+
+  auto readPlan = PlanBuilder()
+                      .tableScan(rowType, {}, "", rowType, columnHandles)
+                      .planNode();
+  auto actual = execute(readPlan, maxDrivers, splits);
+
+  // 3. Compare row count with input.
+  int64_t expectedRowCount = 0;
+  for (const auto& batch : input) {
+    expectedRowCount += batch->size();
+  }
+  VELOX_CHECK_EQ(
+      actual->size(),
+      expectedRowCount,
+      "File rotation: Row count mismatch. Expected {}, got {}",
+      expectedRowCount,
+      actual->size());
+
+  // 4. Verify the actual data content matches the input.
+  std::vector<RowVectorPtr> expectedBatches;
+  expectedBatches.reserve(input.size());
+  for (const auto& batch : input) {
+    std::vector<VectorPtr> children;
+    children.reserve(batch->childrenSize());
+    for (int32_t i = 0; i < partitionOffset; ++i) {
+      children.push_back(batch->childAt(i));
+    }
+    for (int32_t i = partitionOffset; i < batch->childrenSize(); ++i) {
+      children.push_back(batch->childAt(i));
+    }
+    expectedBatches.push_back(
+        std::make_shared<RowVector>(
+            pool_.get(), rowType, nullptr, batch->size(), std::move(children)));
+  }
+
+  VELOX_CHECK(
+      assertEqualResults(expectedBatches, {actual}),
+      "File rotation: Data content mismatch between written and read-back data");
+
+  // 5. Compare with Presto as the source of truth.
+  try {
+    referenceQueryRunner_->execute(
+        "DROP TABLE IF EXISTS " + ReferenceQueryRunner::getWriteTableName());
+  } catch (...) {
+    LOG(WARNING) << "Drop table query failed in the reference DB";
+    return;
+  }
+
+  auto prestoResult = referenceQueryRunner_->execute(plan);
+  if (!prestoResult.first.has_value()) {
+    LOG(WARNING) << "Presto write query failed, skipping comparison";
+    return;
+  }
+
+  VELOX_CHECK(
+      assertEqualResults(*prestoResult.first, plan->outputType(), {result}),
+      "File rotation: Velox and Presto row counts don't match");
+
+  try {
+    auto prestoData = referenceQueryRunner_->execute(
+        "SELECT * FROM " + ReferenceQueryRunner::getWriteTableName());
+    VELOX_CHECK(
+        assertEqualResults(prestoData, {actual}),
+        "File rotation: Velox and Presto data don't match");
+  } catch (...) {
+    LOG(WARNING) << "Query failed in the reference DB";
+    return;
+  }
+
+  LOG(INFO) << "File rotation verification succeeded";
+}
+
 connector::ColumnHandleMap WriterFuzzer::getTableColumnHandles(
     const std::vector<std::string>& names,
     const std::vector<TypePtr>& types,
@@ -642,11 +825,11 @@ connector::ColumnHandleMap WriterFuzzer::getTableColumnHandles(
     const int32_t bucketCount) {
   connector::ColumnHandleMap columnHandle;
   for (int i = 0; i < names.size(); ++i) {
-    HiveColumnHandle::ColumnType columnType;
+    FileColumnHandle::ColumnType columnType;
     if (i < partitionOffset) {
-      columnType = HiveColumnHandle::ColumnType::kRegular;
+      columnType = FileColumnHandle::ColumnType::kRegular;
     } else {
-      columnType = HiveColumnHandle::ColumnType::kPartitionKey;
+      columnType = FileColumnHandle::ColumnType::kPartitionKey;
     }
     columnHandle.insert(
         {names.at(i),
@@ -659,7 +842,7 @@ connector::ColumnHandleMap WriterFuzzer::getTableColumnHandles(
         {"$bucket",
          std::make_shared<HiveColumnHandle>(
              "$bucket",
-             HiveColumnHandle::ColumnType::kSynthesized,
+             FileColumnHandle::ColumnType::kSynthesized,
              INTEGER(),
              INTEGER())});
   }
@@ -669,7 +852,8 @@ connector::ColumnHandleMap WriterFuzzer::getTableColumnHandles(
 RowVectorPtr WriterFuzzer::execute(
     const core::PlanNodePtr& plan,
     const int32_t maxDrivers,
-    const std::vector<exec::Split>& splits) {
+    const std::vector<exec::Split>& splits,
+    const std::string& maxTargetFileSizeBytes) {
   LOG(INFO) << "Executing query plan: " << std::endl
             << plan->toString(true, true);
   fuzzer::ResultOrError resultOrError;
@@ -682,6 +866,10 @@ RowVectorPtr WriterFuzzer::execute(
           kHiveConnectorId,
           connector::hive::HiveConfig::kMaxPartitionsPerWritersSession,
           "400")
+      .connectorSessionProperty(
+          kHiveConnectorId,
+          connector::hive::HiveConfig::kMaxTargetFileSizeSession,
+          maxTargetFileSizeBytes)
       .copyResults(pool_.get());
 }
 
@@ -702,10 +890,11 @@ RowVectorPtr WriterFuzzer::veloxToPrestoResult(const RowVectorPtr& result) {
 }
 
 std::string WriterFuzzer::getReferenceOutputDirectoryPath(int32_t layers) {
-  auto filePath =
-      referenceQueryRunner_->execute("SELECT \"$path\" FROM tmp_write");
+  auto filePath = referenceQueryRunner_->execute(
+      "SELECT \"$path\" FROM " + ReferenceQueryRunner::getWriteTableName());
+  auto stringView = extractSingleValue<StringView>(filePath);
   auto tableDirectoryPath =
-      fs::path(extractSingleValue<StringView>(filePath)).parent_path();
+      fs::path(std::string_view(stringView)).parent_path();
   while (layers-- > 0) {
     tableDirectoryPath = tableDirectoryPath.parent_path();
   }
@@ -853,8 +1042,8 @@ std::string WriterFuzzer::sortSql(
     }
     selectedColumns << sortBy.at(i)->sortColumn();
   }
-  return "SELECT " + selectedColumns.str() + " FROM tmp_write " +
-      whereSql.str();
+  return "SELECT " + selectedColumns.str() + " FROM " +
+      ReferenceQueryRunner::getWriteTableName() + " " + whereSql.str();
 }
 
 std::string WriterFuzzer::partitionToSql(
diff --git a/velox/exec/fuzzer/WriterFuzzerRunner.h b/velox/exec/fuzzer/WriterFuzzerRunner.h
index fbe76685c89..97b240732b3 100644
--- a/velox/exec/fuzzer/WriterFuzzerRunner.h
+++ b/velox/exec/fuzzer/WriterFuzzerRunner.h
@@ -24,6 +24,7 @@
 
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/file/tests/FaultyFileSystem.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/dwio/common/FileSink.h"
 #include "velox/dwio/common/tests/FaultyFileSink.h"
@@ -82,7 +83,8 @@ class WriterFuzzerRunner {
         kHiveConnectorId,
         std::make_shared<config::ConfigBase>(
             std::unordered_map<std::string, std::string>()));
-    connector::registerConnector(hiveConnector);
+    connector::ConnectorRegistry::global().insert(
+        hiveConnector->connectorId(), hiveConnector);
     dwrf::registerDwrfReaderFactory();
     dwrf::registerDwrfWriterFactory();
     dwio::common::registerFileSinks();
diff --git a/velox/exec/fuzzer/if/LocalRunnerService.thrift b/velox/exec/fuzzer/if/LocalRunnerService.thrift
new file mode 100644
index 00000000000..5e28b5f0151
--- /dev/null
+++ b/velox/exec/fuzzer/if/LocalRunnerService.thrift
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// This file defines a Thrift service for executing Velox query plans remotely.
+// Results are returned using Presto's binary serialization format for efficient
+// data transfer.
+
+namespace cpp2 facebook.velox.runner
+
+// Represents a batch of rows using Presto's binary serialization format.
+// The serialized data can be deserialized using PrestoVectorSerde to reconstruct
+// the original RowVector.
+struct Batch {
+  // Binary serialized RowVector data in Presto format
+  1: binary serializedData;
+  // Column names in the RowVector
+  2: list<string> columnNames;
+  // Column type strings in the RowVector
+  3: list<string> columnTypes;
+}
+
+// Request to execute a serialized Velox query plan.
+struct ExecutePlanRequest {
+  1: string serializedPlan;
+  2: string queryId;
+  3: i32 numWorkers = 4;
+  4: i32 numDrivers = 2;
+}
+
+// Response from executing a query plan.
+struct ExecutePlanResponse {
+  1: list<Batch> results;
+  2: string output;
+  3: bool success;
+  4: optional string errorMessage;
+}
+
+// Service for executing Velox query plans locally.
+// This service enables remote execution of serialized query plans with
+// configurable parallelism, returning results in a structured format.
+service LocalRunnerService {
+  // Inputs a Thrift request and executes a serialized Velox query plan and
+  // returns the results as a Thrift response.
+  ExecutePlanResponse execute(1: ExecutePlanRequest request);
+}
diff --git a/velox/exec/fuzzer/tests/CMakeLists.txt b/velox/exec/fuzzer/tests/CMakeLists.txt
index b7478d931a2..a77e6691a5c 100644
--- a/velox/exec/fuzzer/tests/CMakeLists.txt
+++ b/velox/exec/fuzzer/tests/CMakeLists.txt
@@ -16,3 +16,24 @@ add_executable(presto_sql_test PrestoSqlTest.cpp)
 add_test(presto_sql_test presto_sql_test)
 
 target_link_libraries(presto_sql_test velox_fuzzer_util velox_presto_types)
+
+# LocalRunnerService Test (requires FBThrift support)
+if(VELOX_ENABLE_REMOTE_FUNCTIONS)
+  add_executable(local_runner_service_test LocalRunnerServiceTest.cpp)
+  add_test(local_runner_service_test local_runner_service_test)
+
+  target_link_libraries(
+    local_runner_service_test
+    velox_local_runner_service_lib
+    local_runner_service_thrift
+    velox_core
+    velox_type
+    velox_functions_prestosql
+    velox_functions_test_lib
+    velox_vector_test_lib
+    velox_common_base
+    Folly::folly
+    gtest
+    gtest_main
+  )
+endif()
diff --git a/velox/exec/fuzzer/tests/LocalRunnerServiceTest.cpp b/velox/exec/fuzzer/tests/LocalRunnerServiceTest.cpp
new file mode 100644
index 00000000000..97ec6930877
--- /dev/null
+++ b/velox/exec/fuzzer/tests/LocalRunnerServiceTest.cpp
@@ -0,0 +1,256 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/init/Init.h>
+#include <folly/json.h>
+#include <gtest/gtest.h>
+
+#include "velox/core/PlanNode.h"
+#include "velox/exec/fuzzer/LocalRunnerService.h"
+#include "velox/exec/fuzzer/if/gen-cpp2/LocalRunnerService.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/type/Type.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::runner;
+using namespace facebook::velox::test;
+
+namespace facebook::velox::fuzzer::test {
+class LocalRunnerServiceTest : public functions::test::FunctionBaseTest {
+ protected:
+  void SetUp() override {
+    Type::registerSerDe();
+    core::PlanNode::registerSerDe();
+    core::ITypedExpr::registerSerDe();
+    functions::prestosql::registerAllScalarFunctions();
+    functions::prestosql::registerInternalFunctions();
+
+    createTestData();
+  }
+
+  void createTestData() {
+    // Create test vectors for different data types
+    auto rowType = ROW({
+        {"bool_col", BOOLEAN()},
+        {"int_col", INTEGER()},
+        {"bigint_col", BIGINT()},
+        {"double_col", DOUBLE()},
+        {"varchar_col", VARCHAR()},
+        {"timestamp_col", TIMESTAMP()},
+        {"array_col", ARRAY(ARRAY(INTEGER()))},
+    });
+
+    testRowVector_ = makeRowVector(
+        {"bool_col",
+         "int_col",
+         "bigint_col",
+         "double_col",
+         "varchar_col",
+         "timestamp_col",
+         "array_col"},
+        {
+            makeFlatVector<bool>(
+                10,
+                [](auto row) { return row % 2 == 0; },
+                [](auto row) { return row % 3 == 0; }),
+            makeFlatVector<int32_t>(
+                10,
+                [](auto row) { return row; },
+                [](auto row) { return row % 3 == 0; }),
+            makeFlatVector<int64_t>(
+                10,
+                [](auto row) { return row; },
+                [](auto row) { return row % 3 == 0; }),
+            makeFlatVector<double>(
+                10,
+                [](auto row) { return row * 1.1; },
+                [](auto row) { return row % 3 == 0; }),
+            makeFlatVector<std::string>(
+                10,
+                [](auto row) { return fmt::format("str_{}", row); },
+                [](auto row) { return row % 3 == 0; }),
+            makeFlatVector<facebook::velox::Timestamp>(
+                10,
+                [](auto row) { return facebook::velox::Timestamp(row, 0); },
+                [](auto row) { return row % 3 == 0; }),
+            makeNestedArrayVectorFromJson<int64_t>(
+                {"[[1, 2]]",
+                 "[[3]]",
+                 "[[4]]",
+                 "[[5, 6]]",
+                 "[[7]]",
+                 "[[8]]",
+                 "[[9]]",
+                 "[[10]]",
+                 "[[11]]",
+                 "[[12]]"}),
+        });
+
+    testRowVectorWrapped_ = makeRowVector(
+        {"bool_col",
+         "int_col",
+         "bigint_col",
+         "double_col",
+         "varchar_col",
+         "timestamp_col",
+         "array_col"},
+        {
+            makeFlatVector<bool>(
+                5,
+                [](auto row) { return row % 2 == 0; },
+                [](auto row) { return row % 3 == 0; }),
+            wrapInDictionary(
+                makeIndices(5, [](auto row) { return (row * 17 + 3) % 10; }),
+                5,
+                makeFlatVector<int32_t>(
+                    10,
+                    [](auto row) { return row; },
+                    [](auto row) { return row % 3 == 0; })),
+            BaseVector::wrapInConstant(
+                5,
+                0,
+                makeFlatVector<int64_t>(
+                    10,
+                    [](auto row) { return row; },
+                    [](auto row) { return row % 3 == 0; })),
+            makeFlatVector<double>(
+                5,
+                [](auto row) { return row * 1.1; },
+                [](auto row) { return row % 3 == 0; }),
+            makeFlatVector<std::string>(
+                5,
+                [](auto row) { return fmt::format("str_{}", row); },
+                [](auto row) { return row % 3 == 0; }),
+            makeFlatVector<facebook::velox::Timestamp>(
+                5,
+                [](auto row) { return facebook::velox::Timestamp(row, 0); },
+                [](auto row) { return row % 3 == 0; }),
+            makeNestedArrayVectorFromJson<int64_t>(
+                {"[[1, 2]]",
+                 "[[3]]",
+                 "[[4]]",
+                 "[[5, 6]]",
+                 "[[7]]",
+                 "[[8]]",
+                 "[[9]]",
+                 "[[10]]",
+                 "[[11]]",
+                 "[[12]]"}),
+        });
+  }
+
+  RowVectorPtr testRowVector_;
+  RowVectorPtr testRowVectorWrapped_;
+};
+
+TEST_F(LocalRunnerServiceTest, ConvertToBatchesRoundTrip) {
+  auto result = facebook::velox::runner::convertToBatches(
+      {testRowVector_}, rootPool_.get());
+
+  ASSERT_EQ(result.size(), 1);
+  ASSERT_EQ(result[0].columnNames()->size(), 7);
+  ASSERT_EQ(result[0].columnTypes()->size(), 7);
+
+  // Verify serializedData is present
+  ASSERT_GT(result[0].serializedData()->size(), 0);
+
+  // Deserialize and verify
+  auto leafPool = rootPool_->addLeafChild("deserialize");
+  auto serde = std::make_unique<
+      facebook::velox::serializer::presto::PrestoVectorSerde>();
+  facebook::velox::serializer::presto::PrestoVectorSerde::PrestoOptions options;
+
+  const auto& serializedData = *result[0].serializedData();
+  ByteRange byteRange{
+      reinterpret_cast<uint8_t*>(const_cast<char*>(serializedData.data())),
+      static_cast<int32_t>(serializedData.length()),
+      0};
+  auto byteStream = std::make_unique<facebook::velox::BufferInputStream>(
+      std::vector<ByteRange>{{byteRange}});
+
+  RowVectorPtr deserialized;
+  serde->deserialize(
+      byteStream.get(),
+      leafPool.get(),
+      asRowType(testRowVector_->type()),
+      &deserialized,
+      0,
+      &options);
+
+  ASSERT_NE(deserialized, nullptr);
+  ASSERT_EQ(deserialized->size(), testRowVector_->size());
+  ASSERT_EQ(deserialized->childrenSize(), testRowVector_->childrenSize());
+
+  assertEqualVectors(deserialized, testRowVector_);
+}
+
+TEST_F(LocalRunnerServiceTest, ServiceHandlerMockRequestIntegration) {
+  LocalRunnerServiceHandler handler;
+
+  auto request = std::make_unique<ExecutePlanRequest>();
+  // Serialized plan for the following:
+  // expressions: (p0:DOUBLE, plus(null,0.1646418017335236))
+  request->serializedPlan() =
+      R"({"names":["p0","p1"],"id":"project","name":"ProjectNode","sources":[{"name":"ProjectNode","id":"transform","projections":[{"name":"FieldAccessTypedExpr","type":{"name":"Type","type":"BIGINT"},"inputs":[{"name":"InputTypedExpr","type":{"type":"ROW","name":"Type","names":["row_number"],"cTypes":[{"name":"Type","type":"BIGINT"}]}}],"fieldName":"row_number"}],"names":["row_number"],"sources":[{"name":"ValuesNode","id":"efb6650a_8541_4214_82dd_9792a4965380","data":"AAAAAF4AAAB7ImNUeXBlcyI6W3sidHlwZSI6IkJJR0lOVCIsIm5hbWUiOiJUeXBlIn1dLCJuYW1lcyI6WyJyb3dfbnVtYmVyIl0sInR5cGUiOiJST1ciLCJuYW1lIjoiVHlwZSJ9AQAAAAABAAAAAQAAAAAfAAAAeyJ0eXBlIjoiQklHSU5UIiwibmFtZSI6IlR5cGUifQEAAAAAAQgAAAAAAAAAAAAAAA==","parallelizable":false,"repeatTimes":1}]}],"projections":[{"name":"CallTypedExpr","type":{"name":"Type","type":"DOUBLE"},"functionName":"plus","inputs":[{"name":"ConstantTypedExpr","type":{"name":"Type","type":"DOUBLE"},"valueVector":"AQAAAB8AAAB7InR5cGUiOiJET1VCTEUiLCJuYW1lIjoiVHlwZSJ9AQAAAAE="},{"name":"ConstantTypedExpr","type":{"name":"Type","type":"DOUBLE"},"valueVector":"AQAAAB8AAAB7InR5cGUiOiJET1VCTEUiLCJuYW1lIjoiVHlwZSJ9AQAAAAABAAAAifsSxT8="}]},{"name":"FieldAccessTypedExpr","type":{"name":"Type","type":"BIGINT"},"fieldName":"row_number"}]})";
+  request->queryId() = "query1";
+
+  ExecutePlanResponse response;
+  handler.execute(response, std::move(request));
+
+  EXPECT_TRUE(*response.success());
+  EXPECT_EQ(response.results()->size(), 1);
+
+  const auto& batch = (*response.results()).front();
+  EXPECT_EQ(batch.columnNames()->size(), 2);
+  EXPECT_EQ((*batch.columnNames())[0], "p0");
+  EXPECT_EQ(batch.columnTypes()->size(), 2);
+  EXPECT_EQ((*batch.columnTypes())[0], "DOUBLE");
+  EXPECT_GT(batch.serializedData()->size(), 0);
+}
+
+TEST_F(LocalRunnerServiceTest, ServiceHandlerMockRequestIntegrationFailure) {
+  LocalRunnerServiceHandler handler;
+
+  auto request = std::make_unique<ExecutePlanRequest>();
+  // Serialized plan for the following:
+  // expressions: (p0:TINYINT, divide(89,"c0")
+  // Will encounter divide by zero error.
+  request->serializedPlan() =
+      R"({"projections":[{"inputs":[{"valueVector":"AQAAACAAAAB7InR5cGUiOiJUSU5ZSU5UIiwibmFtZSI6IlR5cGUifQEAAAAAAVk=","type":{"type":"TINYINT","name":"Type"},"name":"ConstantTypedExpr"},{"fieldName":"c0","type":{"type":"TINYINT","name":"Type"},"name":"FieldAccessTypedExpr"}],"functionName":"divide","type":{"type":"TINYINT","name":"Type"},"name":"CallTypedExpr"},{"fieldName":"row_number","type":{"type":"BIGINT","name":"Type"},"name":"FieldAccessTypedExpr"}],"sources":[{"projections":[{"inputs":[{"type":{"cTypes":[{"type":"TINYINT","name":"Type"},{"type":"BIGINT","name":"Type"}],"names":["c0","row_number"],"type":"ROW","name":"Type"},"name":"InputTypedExpr"}],"fieldName":"c0","type":{"type":"TINYINT","name":"Type"},"name":"FieldAccessTypedExpr"},{"inputs":[{"type":{"cTypes":[{"type":"TINYINT","name":"Type"},{"type":"BIGINT","name":"Type"}],"names":["c0","row_number"],"type":"ROW","name":"Type"},"name":"InputTypedExpr"}],"fieldName":"row_number","type":{"type":"BIGINT","name":"Type"},"name":"FieldAccessTypedExpr"}],"sources":[{"parallelizable":false,"repeatTimes":1,"data":"AAAAAIQAAAB7ImNUeXBlcyI6W3sidHlwZSI6IlRJTllJTlQiLCJuYW1lIjoiVHlwZSJ9LHsidHlwZSI6IkJJR0lOVCIsIm5hbWUiOiJUeXBlIn1dLCJuYW1lcyI6WyJjMCIsInJvd19udW1iZXIiXSwidHlwZSI6IlJPVyIsIm5hbWUiOiJUeXBlIn0KAAAAAAIAAAABAgAAACAAAAB7InR5cGUiOiJUSU5ZSU5UIiwibmFtZSI6IlR5cGUifQoAAAAAKAAAAAMAAAACAAAABgAAAAAAAAABAAAACAAAAAUAAAAAAAAACAAAAAUAAAACAAAAIAAAAHsidHlwZSI6IlRJTllJTlQiLCJuYW1lIjoiVHlwZSJ9CgAAAAECAAAA9/8oAAAACQAAAAQAAAAJAAAAAAAAAAYAAAAHAAAABAAAAAYAAAAAAAAAAAAAAAIAAAAgAAAAeyJ0eXBlIjoiVElOWUlOVCIsIm5hbWUiOiJUeXBlIn0KAAAAAQIAAAD7oigAAAAJAAAAAQAAAAkAAAAHAAAAAAAAAAUAAAAEAAAAAwAAAAEAAAAAAAAAAAAAACAAAAB7InR5cGUiOiJUSU5ZSU5UIiwibmFtZSI6IlR5cGUifQoAAAAAAQoAAABTOkYvJBw5ZUAAAQAAAAAfAAAAeyJ0eXBlIjoiQklHSU5UIiwibmFtZSI6IlR5cGUifQoAAAAAAVAAAAAAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAQAAAAAAAAABQAAAAAAAAAGAAAAAAAAAAcAAAAAAAAACAAAAAAAAAAJAAAAAAAAAA==","id":"d69f11dc_1f0e_40ae_8c5d_2cde4b784a12","name":"ValuesNode"}],"names":["c0","row_number"],"id":"transform","name":"ProjectNode"}],"names":["p0","p1"],"id":"project","name":"ProjectNode"})";
+  request->queryId() = "query1";
+
+  ExecutePlanResponse response;
+  handler.execute(response, std::move(request));
+
+  ASSERT_TRUE(response.errorMessage().has_value());
+  auto errorMsg = response.errorMessage().value();
+  EXPECT_NE(errorMsg.find("Error Source: USER"), std::string::npos);
+  EXPECT_NE(errorMsg.find("Error Code: ARITHMETIC_ERROR"), std::string::npos);
+  EXPECT_NE(errorMsg.find("Reason: division by zero"), std::string::npos);
+
+  EXPECT_FALSE(*response.success());
+  EXPECT_EQ(response.results()->size(), 0);
+}
+
+} // namespace facebook::velox::fuzzer::test
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  folly::Init init(&argc, &argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/velox/exec/fuzzer/tests/PrestoSqlTest.cpp b/velox/exec/fuzzer/tests/PrestoSqlTest.cpp
index e1873d448e8..2ac4d863d8c 100644
--- a/velox/exec/fuzzer/tests/PrestoSqlTest.cpp
+++ b/velox/exec/fuzzer/tests/PrestoSqlTest.cpp
@@ -18,47 +18,10 @@
 
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/fuzzer/PrestoSql.h"
-#include "velox/functions/prestosql/types/JsonType.h"
-#include "velox/functions/prestosql/types/QDigestType.h"
-#include "velox/functions/prestosql/types/TDigestType.h"
-#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 
 namespace facebook::velox::exec::test {
 namespace {
 
-TEST(PrestoSqlTest, toTypeSql) {
-  EXPECT_EQ(toTypeSql(BOOLEAN()), "BOOLEAN");
-  EXPECT_EQ(toTypeSql(TINYINT()), "TINYINT");
-  EXPECT_EQ(toTypeSql(SMALLINT()), "SMALLINT");
-  EXPECT_EQ(toTypeSql(INTEGER()), "INTEGER");
-  EXPECT_EQ(toTypeSql(BIGINT()), "BIGINT");
-  EXPECT_EQ(toTypeSql(REAL()), "REAL");
-  EXPECT_EQ(toTypeSql(DOUBLE()), "DOUBLE");
-  EXPECT_EQ(toTypeSql(VARCHAR()), "VARCHAR");
-  EXPECT_EQ(toTypeSql(VARBINARY()), "VARBINARY");
-  EXPECT_EQ(toTypeSql(TDIGEST(DOUBLE())), "TDIGEST(DOUBLE)");
-  EXPECT_EQ(toTypeSql(TIMESTAMP()), "TIMESTAMP");
-  EXPECT_EQ(toTypeSql(QDIGEST(DOUBLE())), "QDIGEST(DOUBLE)");
-  EXPECT_EQ(toTypeSql(QDIGEST(BIGINT())), "QDIGEST(BIGINT)");
-  EXPECT_EQ(toTypeSql(QDIGEST(REAL())), "QDIGEST(REAL)");
-  EXPECT_EQ(toTypeSql(DATE()), "DATE");
-  EXPECT_EQ(toTypeSql(TIMESTAMP_WITH_TIME_ZONE()), "TIMESTAMP WITH TIME ZONE");
-  EXPECT_EQ(toTypeSql(ARRAY(BOOLEAN())), "ARRAY(BOOLEAN)");
-  EXPECT_EQ(toTypeSql(MAP(BOOLEAN(), INTEGER())), "MAP(BOOLEAN, INTEGER)");
-  EXPECT_EQ(
-      toTypeSql(ROW({{"a", BOOLEAN()}, {"b", INTEGER()}})),
-      "ROW(a BOOLEAN, b INTEGER)");
-  EXPECT_EQ(
-      toTypeSql(
-          ROW({{"a_", BOOLEAN()}, {"b$", INTEGER()}, {"c d", INTEGER()}})),
-      "ROW(a_ BOOLEAN, b$ INTEGER, c d INTEGER)");
-  EXPECT_EQ(toTypeSql(JSON()), "JSON");
-  EXPECT_EQ(toTypeSql(UNKNOWN()), "UNKNOWN");
-  VELOX_ASSERT_THROW(
-      toTypeSql(FUNCTION({INTEGER()}, INTEGER())),
-      "Type is not supported: FUNCTION");
-}
-
 void toUnaryOperator(
     const std::string& operatorName,
     const std::string& expectedSql) {
@@ -95,11 +58,12 @@ TEST(PrestoSqlTest, toCallSql) {
   toUnaryOperator("negate", "(- c0)");
   toUnaryOperator("not", "(not c0)");
   VELOX_ASSERT_THROW(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          INTEGER(),
-          "not",
-          std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0"),
-          std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c1"))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              INTEGER(),
+              "not",
+              std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0"),
+              std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c1"))),
       "Expected one argument to a unary operator");
 
   // Binary operators
@@ -116,113 +80,126 @@ TEST(PrestoSqlTest, toCallSql) {
   toBinaryOperator("gte", "(c0 >= c1)");
   toBinaryOperator("distinct_from", "(c0 is distinct from c1)");
   VELOX_ASSERT_THROW(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          INTEGER(),
-          "plus",
-          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"),
-          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1"),
-          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c3"))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              INTEGER(),
+              "plus",
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1"),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c3"))),
       "Expected two arguments to a binary operator");
 
   // Functions IS NULL and NOT NULL
   toIsNullOrIsNotNull("is_null", "(c0 is null)");
   toIsNullOrIsNotNull("not_null", "(c0 is not null)");
   VELOX_ASSERT_THROW(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          "is_null",
-          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"),
-          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1"))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "is_null",
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1"))),
       "Expected one argument to function 'is_null' or 'not_null'");
 
   // Function IN
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          "in",
-          std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"),
-          std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "b"))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "in",
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"),
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "b"))),
       "'a' in ('b')");
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          "in",
-          std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"),
-          std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "b"),
-          std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "c"),
-          std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "d"))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "in",
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"),
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "b"),
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "c"),
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "d"))),
       "'a' in ('b', 'c', 'd')");
   VELOX_ASSERT_THROW(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          "in",
-          std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "in",
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"))),
       "Expected at least two arguments to function 'in'");
 
   // Function LIKE
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          "like",
-          std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0"),
-          std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "like",
+              std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0"),
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"))),
       "(c0 like 'a')");
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          "like",
-          std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0"),
-          std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"),
-          std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "b"))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "like",
+              std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0"),
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"),
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "b"))),
       "(c0 like 'a' escape 'b')");
   VELOX_ASSERT_THROW(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          "like",
-          std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "like",
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"))),
       "Expected at least two arguments to function 'like'");
   VELOX_ASSERT_THROW(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          "like",
-          std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"),
-          std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "b"),
-          std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "c"),
-          std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "d"))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "like",
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"),
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "b"),
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "c"),
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "d"))),
       "Expected at most three arguments to function 'like'");
 
   // Functions OR and AND
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          "or",
-          std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), true),
-          std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), false))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "or",
+              std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), true),
+              std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), false))),
       "(BOOLEAN 'true' or BOOLEAN 'false')");
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          "and",
-          std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), true),
-          std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), false))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "and",
+              std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), true),
+              std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), false))),
       "(BOOLEAN 'true' and BOOLEAN 'false')");
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          "or",
-          std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), true),
-          std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), false),
-          std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), true),
-          std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), false))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "or",
+              std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), true),
+              std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), false),
+              std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), true),
+              std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), false))),
       "(BOOLEAN 'true' or BOOLEAN 'false' or BOOLEAN 'true' or BOOLEAN 'false')");
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          "and",
-          std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), true),
-          std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), false),
-          std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), true),
-          std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), false))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "and",
+              std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), true),
+              std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), false),
+              std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), true),
+              std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), false))),
       "(BOOLEAN 'true' and BOOLEAN 'false' and BOOLEAN 'true' and BOOLEAN 'false')");
   VELOX_ASSERT_THROW(
       toCallSql(std::make_shared<core::CallTypedExpr>(BOOLEAN(), "or")),
@@ -230,25 +207,28 @@ TEST(PrestoSqlTest, toCallSql) {
 
   // Functions ARRAY_CONSTRUCTOR and ROW_CONSTRUCTOR
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          ARRAY(INTEGER()),
-          "array_constructor",
-          std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"),
-          std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "b"),
-          std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "c"))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              ARRAY(INTEGER()),
+              "array_constructor",
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"),
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "b"),
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "c"))),
       "ARRAY['a', 'b', 'c']");
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          ARRAY(INTEGER()), "array_constructor")),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              ARRAY(INTEGER()), "array_constructor")),
       "ARRAY[]");
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          "row_constructor",
-          std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"),
-          std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "b"),
-          std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "c"),
-          std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "d"))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "row_constructor",
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"),
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "b"),
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "c"),
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "d"))),
       "row('a', 'b', 'c', 'd')");
   VELOX_ASSERT_THROW(
       toCallSql(
@@ -257,27 +237,29 @@ TEST(PrestoSqlTest, toCallSql) {
 
   // Function BETWEEN
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          "between",
-          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"),
-          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1"),
-          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c2"))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "between",
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1"),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c2"))),
       "(c0 between c1 and c2)");
   // Edge case check for ambiguous parantheses processing, query will fail
   // without the parantheses wrapping the left-hand side.
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          "lt",
+      toCallSql(
           std::make_shared<core::CallTypedExpr>(
               BOOLEAN(),
-              "between",
-              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"),
-              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"),
-              std::make_shared<core::ConstantTypedExpr>(
-                  INTEGER(), variant::null(TypeKind::INTEGER))),
-          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"))),
+              "lt",
+              std::make_shared<core::CallTypedExpr>(
+                  BOOLEAN(),
+                  "between",
+                  std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"),
+                  std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"),
+                  std::make_shared<core::ConstantTypedExpr>(
+                      INTEGER(), variant::null(TypeKind::INTEGER))),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"))),
       "((c0 between c0 and cast(null as INTEGER)) < c0)");
   VELOX_ASSERT_THROW(
       toCallSql(std::make_shared<core::CallTypedExpr>(BOOLEAN(), "between")),
@@ -285,66 +267,74 @@ TEST(PrestoSqlTest, toCallSql) {
 
   // Function SUBSCRIPT, builds '[]' SQL
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          INTEGER(),
-          "subscript",
-          std::make_shared<core::FieldAccessTypedExpr>(
-              ARRAY(INTEGER()), "array"),
-          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              INTEGER(),
+              "subscript",
+              std::make_shared<core::FieldAccessTypedExpr>(
+                  ARRAY(INTEGER()), "array"),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"))),
       "array[c0]");
   VELOX_ASSERT_THROW(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          INTEGER(),
-          "subscript",
-          std::make_shared<core::FieldAccessTypedExpr>(
-              ARRAY(INTEGER()), "array"),
-          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"),
-          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1"))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              INTEGER(),
+              "subscript",
+              std::make_shared<core::FieldAccessTypedExpr>(
+                  ARRAY(INTEGER()), "array"),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1"))),
       "Expected two arguments to function 'subscript'");
 
   // Function SWITCH, builds 'CASE WHEN ... THEN ... ELSE ... END' SQL
   // SWITCH cases with no ELSE.
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          INTEGER(),
-          "switch",
-          std::make_shared<core::FieldAccessTypedExpr>(BOOLEAN(), "c0"),
-          std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c1"))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              INTEGER(),
+              "switch",
+              std::make_shared<core::FieldAccessTypedExpr>(BOOLEAN(), "c0"),
+              std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c1"))),
       "case when c0 then c1 end");
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          INTEGER(),
-          "switch",
-          std::make_shared<core::FieldAccessTypedExpr>(BOOLEAN(), "c0"),
-          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1"),
-          std::make_shared<core::FieldAccessTypedExpr>(BOOLEAN(), "c2"),
-          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c3"))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              INTEGER(),
+              "switch",
+              std::make_shared<core::FieldAccessTypedExpr>(BOOLEAN(), "c0"),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1"),
+              std::make_shared<core::FieldAccessTypedExpr>(BOOLEAN(), "c2"),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c3"))),
       "case when c0 then c1 when c2 then c3 end");
   // SWITCH case with ELSE.
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          INTEGER(),
-          "switch",
-          std::make_shared<core::FieldAccessTypedExpr>(BOOLEAN(), "c0"),
-          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1"),
-          std::make_shared<core::FieldAccessTypedExpr>(BOOLEAN(), "c2"),
-          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c3"),
-          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c4"))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              INTEGER(),
+              "switch",
+              std::make_shared<core::FieldAccessTypedExpr>(BOOLEAN(), "c0"),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1"),
+              std::make_shared<core::FieldAccessTypedExpr>(BOOLEAN(), "c2"),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c3"),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c4"))),
       "case when c0 then c1 when c2 then c3 else c4 end");
   VELOX_ASSERT_THROW(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          INTEGER(),
-          "switch",
-          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              INTEGER(),
+              "switch",
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"))),
       "Expected at least two arguments to function 'switch'");
 
   // Generic functions
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          INTEGER(),
-          "array_top_n",
-          std::make_shared<core::FieldAccessTypedExpr>(ARRAY(INTEGER()), "c0"),
-          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1"))),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              INTEGER(),
+              "array_top_n",
+              std::make_shared<core::FieldAccessTypedExpr>(
+                  ARRAY(INTEGER()), "c0"),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1"))),
       "array_top_n(c0, c1)");
   EXPECT_EQ(
       toCallSql(std::make_shared<core::CallTypedExpr>(REAL(), "infinity")),
@@ -377,10 +367,10 @@ TEST(PrestoSqlTest, toCallInputsSql) {
 TEST(PrestoSqlTest, toConstantSql) {
   EXPECT_EQ(
       toConstantSql(core::ConstantTypedExpr(INTERVAL_YEAR_MONTH(), 123)),
-      "INTERVAL '123' YEAR TO MONTH");
+      "INTERVAL '10-3' YEAR TO MONTH");
   EXPECT_EQ(
       toConstantSql(core::ConstantTypedExpr(INTERVAL_DAY_TIME(), int64_t(123))),
-      "INTERVAL '123' DAY TO SECOND");
+      "INTERVAL '0 00:00:00.123' DAY TO SECOND");
 }
 
 } // namespace
diff --git a/velox/exec/prefixsort/CMakeLists.txt b/velox/exec/prefixsort/CMakeLists.txt
index aac7db501ec..9553d268332 100644
--- a/velox/exec/prefixsort/CMakeLists.txt
+++ b/velox/exec/prefixsort/CMakeLists.txt
@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+velox_add_library(velox_prefixsort INTERFACE HEADERS PrefixSortAlgorithm.h PrefixSortEncoder.h)
+
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
 elseif(${VELOX_BUILD_TEST_UTILS})
@@ -21,3 +23,5 @@ endif()
 if(${VELOX_ENABLE_BENCHMARKS})
   add_subdirectory(benchmarks)
 endif()
+
+velox_install_library_headers()
diff --git a/velox/exec/prefixsort/PrefixSortEncoder.h b/velox/exec/prefixsort/PrefixSortEncoder.h
index 945b1de5e16..87756792a72 100644
--- a/velox/exec/prefixsort/PrefixSortEncoder.h
+++ b/velox/exec/prefixsort/PrefixSortEncoder.h
@@ -28,7 +28,7 @@ namespace facebook::velox::exec::prefixsort {
 class PrefixSortEncoder {
  public:
   PrefixSortEncoder(bool ascending, bool nullsFirst)
-      : ascending_(ascending), nullsFirst_(nullsFirst){};
+      : ascending_(ascending), nullsFirst_(nullsFirst) {}
 
   /// Encode native primitive types(such as uint64_t, int64_t, uint32_t,
   /// int32_t, uint16_t, int16_t, float, double, Timestamp).
diff --git a/velox/exec/prefixsort/tests/PrefixEncoderTest.cpp b/velox/exec/prefixsort/tests/PrefixEncoderTest.cpp
index 398da750b04..ab88faa09cb 100644
--- a/velox/exec/prefixsort/tests/PrefixEncoderTest.cpp
+++ b/velox/exec/prefixsort/tests/PrefixEncoderTest.cpp
@@ -270,8 +270,7 @@ class PrefixEncoderTest : public testing::Test,
         const auto rightValue = rightVector->isNullAt(i)
             ? std::nullopt
             : std::optional<ValueDataType>(rightVector->valueAt(i));
-        if constexpr (
-            Kind == TypeKind::VARCHAR || Kind == TypeKind::VARBINARY) {
+        if constexpr (is_string_kind(Kind)) {
           encoder.encode(leftValue, leftEncoded, 17, true);
           encoder.encode(rightValue, rightEncoded, 17, true);
         } else {
diff --git a/velox/exec/prefixsort/tests/utils/CMakeLists.txt b/velox/exec/prefixsort/tests/utils/CMakeLists.txt
index c4691246a33..6b6c790cd83 100644
--- a/velox/exec/prefixsort/tests/utils/CMakeLists.txt
+++ b/velox/exec/prefixsort/tests/utils/CMakeLists.txt
@@ -13,5 +13,6 @@
 # limitations under the License.
 
 add_library(velox_exec_prefixsort_test_lib EncoderTestUtils.cpp)
+velox_add_test_headers(velox_exec_prefixsort_test_lib EncoderTestUtils.h)
 
 target_link_libraries(velox_exec_prefixsort_test_lib velox_vector_test_lib)
diff --git a/velox/exec/rpc/CMakeLists.txt b/velox/exec/rpc/CMakeLists.txt
new file mode 100644
index 00000000000..dafd5ad6fcd
--- /dev/null
+++ b/velox/exec/rpc/CMakeLists.txt
@@ -0,0 +1,68 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# RPCNode is part of velox_core (in core/PlanNode.h)
+
+velox_add_library(velox_rpc_state RPCState.cpp HEADERS RPCState.h)
+
+velox_link_libraries(
+  velox_rpc_state
+  velox_rpc_types
+  velox_common_base
+  velox_future
+  velox_vector
+  Folly::folly
+)
+
+velox_add_library(velox_rpc_rate_limiter RPCRateLimiter.cpp HEADERS RPCRateLimiter.h)
+
+velox_link_libraries(velox_rpc_rate_limiter velox_future)
+
+velox_add_library(velox_rpc_operator RPCOperator.cpp HEADERS RPCOperator.h)
+
+velox_link_libraries(
+  velox_rpc_operator
+  velox_rpc_state
+  velox_rpc_rate_limiter
+  velox_async_rpc_function
+  velox_async_rpc_function_registry
+  velox_exec
+  velox_expression
+  velox_vector
+  velox_buffer
+  velox_future
+  Folly::folly
+)
+
+velox_add_library(
+  velox_rpc_plan_node_translator
+  RPCPlanNodeTranslator.cpp
+  HEADERS
+  RPCPlanNodeTranslator.h
+)
+
+velox_link_libraries(velox_rpc_plan_node_translator velox_rpc_operator velox_exec)
+
+if(${VELOX_BUILD_TESTING})
+  velox_add_library(velox_demo_rpc_function tests/DemoRPCFunction.cpp)
+
+  velox_link_libraries(
+    velox_demo_rpc_function
+    velox_mock_rpc_client
+    velox_expression_functions
+    velox_async_rpc_function
+  )
+
+  add_subdirectory(tests)
+endif()
diff --git a/velox/exec/rpc/RPCOperator.cpp b/velox/exec/rpc/RPCOperator.cpp
new file mode 100644
index 00000000000..b4f903fa50c
--- /dev/null
+++ b/velox/exec/rpc/RPCOperator.cpp
@@ -0,0 +1,683 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/rpc/RPCOperator.h"
+
+#include "velox/common/time/CpuWallTimer.h"
+#include "velox/common/time/Timer.h"
+#include "velox/expression/rpc/AsyncRPCFunctionRegistry.h"
+
+#define RPC_OP_LOG(severity) LOG(severity) << "[RPC_OP] "
+#define RPC_OP_VLOG(level) VLOG(level) << "[RPC_OP] "
+
+namespace facebook::velox::exec::rpc {
+
+RPCOperator::RPCOperator(
+    int32_t operatorId,
+    exec::DriverCtx* driverCtx,
+    std::shared_ptr<const core::RPCNode> rpcNode)
+    : exec::Operator(
+          driverCtx,
+          rpcNode->outputType(),
+          operatorId,
+          rpcNode->id(),
+          "RPC"),
+      rpcNode_(std::move(rpcNode)),
+      state_(std::make_shared<RPCState>()),
+      dispatchBatchSize_(rpcNode_->dispatchBatchSize()) {
+  // Configure RPCState with streaming mode.
+  state_->setStreamingMode(rpcNode_->streamingMode());
+}
+
+void RPCOperator::initialize() {
+  Operator::initialize();
+
+  // Resolve the AsyncRPCFunction by name from the registry.
+  function_ = AsyncRPCFunctionRegistry::create(rpcNode_->functionName());
+  VELOX_CHECK(
+      function_,
+      "Unknown RPC function '{}'. Ensure it is registered via "
+      "AsyncRPCFunctionRegistry::registerFunction() before query execution.",
+      rpcNode_->functionName());
+
+  // Initialize the function with query config, argument types, and constants.
+  // The function creates/caches its own transport and clients internally.
+  function_->initialize(
+      operatorCtx_->driverCtx()->queryConfig(),
+      rpcNode_->argumentTypes(),
+      rpcNode_->constantInputs());
+
+  tierKey_ = function_->tierKey();
+
+  RPC_OP_VLOG(1) << "Created operator for function '"
+                 << rpcNode_->functionName() << "', planNodeId=" << planNodeId()
+                 << ", operatorId=" << operatorId() << ", streamingMode="
+                 << (rpcNode_->streamingMode() == RPCStreamingMode::kBatch
+                         ? "BATCH"
+                         : "PER_ROW");
+
+  // Precompute argument column indices for addInput().
+  const auto& argCols = rpcNode_->argumentColumns();
+  if (!argCols.empty()) {
+    auto sourceType = rpcNode_->source()->outputType();
+    argumentColumnIndices_.reserve(argCols.size());
+    for (const auto& colName : argCols) {
+      auto idx = sourceType->getChildIdx(colName);
+      argumentColumnIndices_.push_back(static_cast<column_index_t>(idx));
+    }
+    RPC_OP_VLOG(1) << "Initialized with " << argCols.size()
+                   << " argument columns";
+  } else {
+    RPC_OP_VLOG(1) << "Initialized with no argument columns "
+                   << "(fallback to all input columns)";
+  }
+
+  // Precompute output column projections to avoid string lookups in
+  // buildOutputVector().
+  initOutputProjections();
+}
+
+bool RPCOperator::needsInput() const {
+  if (noMoreInput_ || isDraining()) {
+    return false;
+  }
+
+  // Don't accept input if we have results ready to output.
+  if (!claimedRows_.empty() || claimedBatch_.has_value()) {
+    return false;
+  }
+
+  // Check per-state backpressure.
+  if (state_->isUnderBackpressure()) {
+    return false;
+  }
+
+  return true;
+}
+
+void RPCOperator::addInput(RowVectorPtr input) {
+  if (!input || input->size() == 0) {
+    RPC_OP_VLOG(2) << "addInput received empty input";
+    return;
+  }
+
+  RPC_OP_VLOG(1) << "addInput received " << input->size() << " rows with "
+                 << input->childrenSize() << " input columns";
+
+  SelectivityVector rows(input->size());
+
+  // Read pre-computed argument columns by precomputed index.
+  std::vector<VectorPtr> args;
+  if (!argumentColumnIndices_.empty()) {
+    args.reserve(argumentColumnIndices_.size());
+    for (auto idx : argumentColumnIndices_) {
+      args.push_back(input->childAt(idx));
+    }
+  } else {
+    // Fallback: use all input columns as arguments.
+    for (auto i = 0; i < input->childrenSize(); ++i) {
+      args.push_back(input->childAt(i));
+    }
+  }
+
+  // Flatten/load all columns upfront to avoid issues with lazy vectors.
+  std::vector<VectorPtr> flattenedColumns;
+  flattenedColumns.reserve(input->childrenSize());
+  for (int32_t j = 0; j < input->childrenSize(); ++j) {
+    auto column = BaseVector::loadedVectorShared(input->childAt(j));
+    BaseVector::flattenVector(column);
+    flattenedColumns.push_back(column);
+  }
+
+  auto streamingMode = state_->streamingMode();
+
+  if (streamingMode == RPCStreamingMode::kPerRow) {
+    // PER_ROW: function dispatches individual RPCs and returns futures.
+    auto futures = function_->dispatchPerRow(rows, args);
+
+    auto batchIndex = state_->storeInputBatch(
+        flattenedColumns, static_cast<int64_t>(futures.size()));
+    numRequestsDispatched_ += static_cast<int64_t>(futures.size());
+
+    for (auto& [originalRowIndex, future] : futures) {
+      auto rowId = globalRowIdCounter_++;
+      auto token = std::make_shared<RPCRateLimiter::Token>(
+          RPCRateLimiter::acquire(tierKey_));
+
+      auto wrapped =
+          std::move(future)
+              .within(kBatchRpcTimeout)
+              .deferValue([rowId, token](RPCResponse resp) {
+                resp.rowId = rowId;
+                return resp;
+              })
+              .deferError([token](folly::exception_wrapper ew) {
+                return folly::makeSemiFuture<RPCResponse>(std::move(ew));
+              });
+
+      state_->addPendingRow(
+          state_,
+          rowId,
+          RPCState::RowLocation{batchIndex, originalRowIndex},
+          std::move(wrapped));
+    }
+  } else {
+    // BATCH: function accumulates typed data internally.
+    auto rowIndices = function_->accumulateBatch(rows, args);
+
+    auto batchIndex = state_->storeInputBatch(
+        flattenedColumns, static_cast<int64_t>(rowIndices.size()));
+    numRequestsDispatched_ += static_cast<int64_t>(rowIndices.size());
+
+    for (auto originalRowIndex : rowIndices) {
+      auto rowId = globalRowIdCounter_++;
+      batchRowLocations_.push_back(
+          RPCState::RowLocation{batchIndex, originalRowIndex});
+      batchRowIds_.push_back(rowId);
+    }
+
+    if (dispatchBatchSize_ > 0 &&
+        function_->pendingBatchSize() >= dispatchBatchSize_) {
+      // Flush in chunks of dispatchBatchSize_ to avoid sending one
+      // giant batch_predict call that overwhelms the server.
+      while (function_->pendingBatchSize() >= dispatchBatchSize_ &&
+             !state_->isUnderBackpressure()) {
+        flushBatchRequests(dispatchBatchSize_);
+      }
+    }
+  }
+}
+
+void RPCOperator::flushBatchRequests(int32_t maxRows) {
+  if (function_->pendingBatchSize() == 0) {
+    VELOX_CHECK(
+        batchRowLocations_.empty(),
+        "Operator has {} accumulated batch rows but function reports "
+        "pendingBatchSize=0. Function must override pendingBatchSize() "
+        "when using BATCH mode.",
+        batchRowLocations_.size());
+    return;
+  }
+
+  // Determine how many rows to flush.
+  auto flushCount = maxRows > 0
+      ? std::min(static_cast<int32_t>(batchRowLocations_.size()), maxRows)
+      : static_cast<int32_t>(batchRowLocations_.size());
+
+  RPC_OP_LOG(INFO) << "Flushing batch with " << flushCount << " of "
+                   << function_->pendingBatchSize() << " accumulated rows";
+
+  // Split off the rows to flush.
+  std::vector<RPCState::RowLocation> rowLocations(
+      batchRowLocations_.begin(), batchRowLocations_.begin() + flushCount);
+  std::vector<int64_t> rowIds(
+      batchRowIds_.begin(), batchRowIds_.begin() + flushCount);
+  batchRowLocations_.erase(
+      batchRowLocations_.begin(), batchRowLocations_.begin() + flushCount);
+  batchRowIds_.erase(batchRowIds_.begin(), batchRowIds_.begin() + flushCount);
+
+  auto future = function_->flushBatch(maxRows);
+
+  // Count each flushBatch() as 1 pending unit in the rate limiter.
+  auto token = std::make_shared<RPCRateLimiter::Token>(
+      RPCRateLimiter::acquire(tierKey_));
+
+  // Stamp rowIds onto responses.
+  auto wrapped =
+      std::move(future)
+          .within(kBatchRpcTimeout)
+          .deferValue([rowIds = std::move(rowIds),
+                       token](std::vector<RPCResponse> resps) {
+            VELOX_CHECK_EQ(
+                resps.size(),
+                rowIds.size(),
+                "RPC batch response count ({}) does not match row count ({})",
+                resps.size(),
+                rowIds.size());
+            for (size_t i = 0; i < resps.size(); ++i) {
+              resps[i].rowId = rowIds[i];
+            }
+            return resps;
+          })
+          .deferError([token](folly::exception_wrapper ew) {
+            RPC_OP_LOG(ERROR) << "RPC batch failed: " << ew.what();
+            return folly::makeSemiFuture<std::vector<RPCResponse>>(
+                std::move(ew));
+          });
+
+  state_->addPendingBatch(state_, std::move(wrapped), std::move(rowLocations));
+}
+
+void RPCOperator::noMoreInput() {
+  exec::Operator::noMoreInput();
+
+  RPC_OP_VLOG(1) << "noMoreInput: totalRequestsDispatched="
+                 << numRequestsDispatched_;
+
+  if (state_->streamingMode() == RPCStreamingMode::kBatch) {
+    // Flush any remaining accumulated rows in chunks.
+    while (function_->pendingBatchSize() > 0) {
+      flushBatchRequests(dispatchBatchSize_ > 0 ? dispatchBatchSize_ : 0);
+    }
+  }
+
+  state_->setNoMoreInput();
+}
+
+RowVectorPtr RPCOperator::getOutput() {
+  auto streamingMode = state_->streamingMode();
+
+  if (streamingMode == RPCStreamingMode::kPerRow) {
+    if (claimedRows_.empty()) {
+      // If draining and nothing left to output, check finish.
+      if (isDraining() && state_->isFinished()) {
+        finished_ = true;
+        finishDrain();
+      }
+      return nullptr;
+    }
+
+    // Drain additional ready rows (non-blocking) for batched output.
+    // This amortizes RowVector allocation across multiple completed rows.
+    state_->drainReadyRows(claimedRows_, 1024);
+
+    auto numRows = static_cast<int64_t>(claimedRows_.size());
+    for (const auto& row : claimedRows_) {
+      if (row.response.hasError()) {
+        numErrors_++;
+      }
+    }
+    auto output = buildOutputFromReadyRows(claimedRows_);
+    numResponsesCollected_ += numRows;
+    claimedRows_.clear();
+    return output;
+  } else {
+    if (!claimedBatch_.has_value()) {
+      // If draining and nothing left to output, check finish.
+      if (isDraining() && state_->isFinished()) {
+        finished_ = true;
+        finishDrain();
+      }
+      return nullptr;
+    }
+
+    // Fail loudly on batch errors instead of silently dropping rows.
+    if (claimedBatch_->error.has_value()) {
+      auto error = claimedBatch_->error.value();
+      claimedBatch_.reset();
+      VELOX_FAIL("RPC batch failed: {}", error);
+    }
+
+    auto numRows = static_cast<int64_t>(claimedBatch_->responses.size());
+    for (const auto& response : claimedBatch_->responses) {
+      if (response.hasError()) {
+        numErrors_++;
+      }
+    }
+
+    // Delegate congestion evaluation to the function.
+    // The function knows its domain-specific error semantics.
+    auto signal = function_->evaluateCongestion(claimedBatch_->responses);
+    if (signal == AsyncRPCFunction::CongestionSignal::kError) {
+      state_->onBatchError();
+    } else if (signal == AsyncRPCFunction::CongestionSignal::kSuccess) {
+      state_->onBatchSuccess(function_->congestionRecoveryIncrement());
+    }
+
+    auto output = buildOutputFromReadyBatch(*claimedBatch_);
+    numResponsesCollected_ += numRows;
+    claimedBatch_.reset();
+    return output;
+  }
+}
+
+exec::BlockingReason RPCOperator::isBlocked(ContinueFuture* future) {
+  // End any previous block wait measurement.
+  if (blockWaitStartNs_.has_value()) {
+    auto elapsed = getCurrentTimeNano() - blockWaitStartNs_.value();
+    if (blockWaitIsBackpressure_) {
+      totalBackpressureWaitNanos_ += elapsed;
+    } else {
+      totalBlockWaitNanos_ += elapsed;
+    }
+    blockWaitStartNs_ = std::nullopt;
+  }
+
+  // Check per-tier backpressure first.
+  if (auto backpressureFuture = RPCRateLimiter::checkBackpressure(tierKey_)) {
+    RPC_OP_VLOG(1) << "Backpressure applied for tier '" << tierKey_
+                   << "', pending=" << RPCRateLimiter::pendingCount(tierKey_);
+    *future = std::move(*backpressureFuture);
+    blockWaitStartNs_ = getCurrentTimeNano();
+    blockWaitIsBackpressure_ = true;
+    return exec::BlockingReason::kWaitForRPC;
+  }
+
+  // If we already have output ready, don't block.
+  if (!claimedRows_.empty() || claimedBatch_.has_value()) {
+    return exec::BlockingReason::kNotBlocked;
+  }
+
+  // If finished, don't block.
+  if (finished_) {
+    return exec::BlockingReason::kNotBlocked;
+  }
+
+  auto streamingMode = state_->streamingMode();
+
+  if (streamingMode == RPCStreamingMode::kPerRow) {
+    if (!noMoreInput_ && !isDraining()) {
+      auto claimedRow = state_->tryClaimReady();
+      if (claimedRow) {
+        claimedRows_.push_back(std::move(*claimedRow));
+      }
+      return exec::BlockingReason::kNotBlocked;
+    }
+
+    std::optional<RPCState::ReadyRow> claimedRow;
+    ContinueFuture waitFuture{ContinueFuture::makeEmpty()};
+    auto result = state_->tryClaimOrWait(&waitFuture, &claimedRow);
+
+    switch (result) {
+      case RPCState::ClaimResult::kClaimed:
+        claimedRows_.push_back(std::move(*claimedRow));
+        return exec::BlockingReason::kNotBlocked;
+
+      case RPCState::ClaimResult::kFinished:
+        finished_ = true;
+        return exec::BlockingReason::kNotBlocked;
+
+      case RPCState::ClaimResult::kMustWait:
+        *future = std::move(waitFuture);
+        blockWaitStartNs_ = getCurrentTimeNano();
+        blockWaitIsBackpressure_ = false;
+        return exec::BlockingReason::kWaitForRPC;
+    }
+  } else {
+    // BATCH mode
+    if (!noMoreInput_ && !isDraining()) {
+      auto readyBatch = state_->tryPollReady();
+      if (readyBatch) {
+        if (readyBatch->error.has_value()) {
+          RPC_OP_LOG(WARNING)
+              << "Received batch with error: " << readyBatch->error.value();
+        }
+        claimedBatch_ = std::move(*readyBatch);
+      }
+      return exec::BlockingReason::kNotBlocked;
+    }
+
+    std::optional<RPCState::ReadyBatch> readyBatch;
+    ContinueFuture waitFuture{ContinueFuture::makeEmpty()};
+    auto result = state_->tryPollBatchOrWait(&waitFuture, &readyBatch);
+
+    switch (result) {
+      case RPCState::BatchPollResult::kGotBatch:
+        if (readyBatch->error.has_value()) {
+          RPC_OP_LOG(WARNING)
+              << "Received batch with error: " << readyBatch->error.value();
+        }
+        claimedBatch_ = std::move(*readyBatch);
+        return exec::BlockingReason::kNotBlocked;
+
+      case RPCState::BatchPollResult::kFinished:
+        finished_ = true;
+        return exec::BlockingReason::kNotBlocked;
+
+      case RPCState::BatchPollResult::kMustWait:
+        *future = std::move(waitFuture);
+        blockWaitStartNs_ = getCurrentTimeNano();
+        blockWaitIsBackpressure_ = false;
+        return exec::BlockingReason::kWaitForRPC;
+    }
+  }
+
+  VELOX_UNREACHABLE();
+}
+
+bool RPCOperator::isFinished() {
+  return finished_ && claimedRows_.empty() && !claimedBatch_.has_value();
+}
+
+bool RPCOperator::startDrain() {
+  VELOX_CHECK(isDraining());
+  VELOX_CHECK(!noMoreInput_);
+
+  // Flush any undispatched accumulated rows.
+  if (function_->pendingBatchSize() > 0) {
+    flushBatchRequests();
+  }
+
+  // Signal RPCState that no more rows will be dispatched so it can
+  // detect the finish condition once in-flight RPCs complete.
+  state_->setNoMoreInput();
+
+  // If we have claimed output or pending in-flight RPCs, there is
+  // buffered data to drain.
+  if (!claimedRows_.empty() || claimedBatch_.has_value()) {
+    return true;
+  }
+  if (state_ && !state_->isFinished()) {
+    return true;
+  }
+  return false;
+}
+
+void RPCOperator::close() {
+  recordRuntimeStats();
+
+  // Release resources explicitly. RPCState may be held alive by in-flight
+  // RPC callbacks (via shared_ptr capture), but we release our reference
+  // so that input batch memory can be freed as soon as possible.
+  state_.reset();
+  function_.reset();
+  claimedRows_.clear();
+  claimedBatch_.reset();
+  batchRowLocations_.clear();
+  batchRowIds_.clear();
+  reusableIndices_.reset();
+
+  Operator::close();
+}
+
+void RPCOperator::initOutputProjections() {
+  const auto& outputColumn = rpcNode_->outputColumn();
+  const auto& outputType = rpcNode_->outputType();
+  auto sourceType = rpcNode_->source()->outputType();
+
+  for (int32_t i = 0; i < static_cast<int32_t>(outputType->size()); ++i) {
+    const auto& colName = outputType->nameOf(i);
+    if (colName == outputColumn) {
+      rpcResultOutputChannel_ = static_cast<column_index_t>(i);
+    } else {
+      auto colIdx = sourceType->getChildIdxIfExists(colName);
+      if (colIdx.has_value()) {
+        passthroughProjections_.push_back(
+            OutputProjection{
+                .outputChannel = static_cast<column_index_t>(i),
+                .sourceChannel = static_cast<column_index_t>(colIdx.value())});
+      }
+    }
+  }
+
+  RPC_OP_VLOG(1) << "initOutputProjections: rpcResultChannel="
+                 << rpcResultOutputChannel_ << ", passthroughProjections="
+                 << passthroughProjections_.size();
+}
+
+void RPCOperator::recordRuntimeStats() {
+  auto lockedStats = stats_.wlock();
+  lockedStats->addRuntimeStat(
+      kRpcRequestsDispatched, RuntimeCounter(numRequestsDispatched_));
+  lockedStats->addRuntimeStat(
+      kRpcResponsesReceived, RuntimeCounter(numResponsesCollected_));
+  lockedStats->addRuntimeStat(kRpcErrorCount, RuntimeCounter(numErrors_));
+  if (totalBlockWaitNanos_ > 0) {
+    lockedStats->addRuntimeStat(
+        kRpcWaitWallNanos,
+        RuntimeCounter(
+            static_cast<int64_t>(totalBlockWaitNanos_),
+            RuntimeCounter::Unit::kNanos));
+  }
+  if (totalBackpressureWaitNanos_ > 0) {
+    lockedStats->addRuntimeStat(
+        kRpcBackpressureWaitNanos,
+        RuntimeCounter(
+            static_cast<int64_t>(totalBackpressureWaitNanos_),
+            RuntimeCounter::Unit::kNanos));
+  }
+
+  if (totalBlockWaitNanos_ > 0 || numResponsesCollected_ > 0) {
+    const CpuWallTiming backgroundTiming{
+        static_cast<uint64_t>(numResponsesCollected_), totalBlockWaitNanos_, 0};
+    lockedStats->backgroundTiming.clear();
+    lockedStats->backgroundTiming.add(backgroundTiming);
+  }
+}
+
+RowVectorPtr RPCOperator::buildOutputFromReadyRows(
+    std::vector<RPCState::ReadyRow>& readyRows) {
+  std::vector<RPCResponse> responses;
+  responses.reserve(readyRows.size());
+
+  std::vector<std::pair<int32_t, vector_size_t>> locations;
+  locations.reserve(readyRows.size());
+
+  for (auto& row : readyRows) {
+    responses.push_back(std::move(row.response));
+    locations.emplace_back(row.location.batchIndex, row.location.rowIndex);
+  }
+
+  return buildOutputVector(responses, locations);
+}
+
+RowVectorPtr RPCOperator::buildOutputFromReadyBatch(
+    RPCState::ReadyBatch& readyBatch) {
+  std::vector<std::pair<int32_t, vector_size_t>> locations;
+  locations.reserve(readyBatch.rowLocations.size());
+  for (const auto& loc : readyBatch.rowLocations) {
+    locations.emplace_back(loc.batchIndex, loc.rowIndex);
+  }
+
+  return buildOutputVector(readyBatch.responses, locations);
+}
+
+RowVectorPtr RPCOperator::buildOutputVector(
+    const std::vector<RPCResponse>& responses,
+    const std::vector<std::pair<int32_t, vector_size_t>>& locations) {
+  const auto numRows = static_cast<vector_size_t>(responses.size());
+  auto* pool = operatorCtx_->pool();
+
+  const auto& outputType = rpcNode_->outputType();
+
+  // Use AsyncRPCFunction to build RPC result column.
+  auto responseVector = function_->buildOutput(responses, pool);
+
+  // Check if all rows come from the same batch (common for BATCH mode).
+  bool singleBatch = true;
+  if (numRows > 0) {
+    int32_t firstBatch = locations[0].first;
+    for (vector_size_t i = 1; i < numRows; ++i) {
+      if (locations[i].first != firstBatch) {
+        singleBatch = false;
+        break;
+      }
+    }
+  }
+
+  std::vector<VectorPtr> outputChildren(outputType->size());
+
+  // Set RPC result column using precomputed index.
+  outputChildren[rpcResultOutputChannel_] = responseVector;
+
+  // Set passthrough columns using precomputed projections.
+  if (numRows == 0) {
+    for (const auto& proj : passthroughProjections_) {
+      outputChildren[proj.outputChannel] =
+          BaseVector::create(outputType->childAt(proj.outputChannel), 0, pool);
+    }
+  } else if (singleBatch) {
+    // All rows from same batch: use dictionary wrapping (zero-copy).
+    const auto indicesByteSize = numRows * sizeof(vector_size_t);
+    if (!reusableIndices_ || !reusableIndices_->unique() ||
+        reusableIndices_->capacity() < indicesByteSize) {
+      reusableIndices_ = allocateIndices(numRows, pool);
+    }
+    reusableIndices_->setSize(indicesByteSize);
+    auto rawIndices = reusableIndices_->asMutable<vector_size_t>();
+    for (vector_size_t rowIdx = 0; rowIdx < numRows; ++rowIdx) {
+      rawIndices[rowIdx] = locations[rowIdx].second;
+    }
+
+    const auto batchCols = state_->getInputBatchColumns(locations[0].first);
+    for (const auto& proj : passthroughProjections_) {
+      if (proj.sourceChannel < static_cast<column_index_t>(batchCols.size())) {
+        outputChildren[proj.outputChannel] = BaseVector::wrapInDictionary(
+            nullptr, reusableIndices_, numRows, batchCols[proj.sourceChannel]);
+      } else {
+        outputChildren[proj.outputChannel] = BaseVector::createNullConstant(
+            outputType->childAt(proj.outputChannel), numRows, pool);
+      }
+    }
+  } else {
+    // Rows from multiple batches: fetch columns once per batch.
+    std::unordered_map<int32_t, std::vector<VectorPtr>> batchColsCache;
+    for (const auto& proj : passthroughProjections_) {
+      auto combined = BaseVector::create(
+          outputType->childAt(proj.outputChannel), numRows, pool);
+      for (vector_size_t rowIdx = 0; rowIdx < numRows; ++rowIdx) {
+        const auto& [batchIdx, rowInBatch] = locations[rowIdx];
+        auto it = batchColsCache.find(batchIdx);
+        if (it == batchColsCache.end()) {
+          it = batchColsCache
+                   .emplace(batchIdx, state_->getInputBatchColumns(batchIdx))
+                   .first;
+        }
+        const auto& batchCols = it->second;
+        if (proj.sourceChannel <
+            static_cast<column_index_t>(batchCols.size())) {
+          combined->copy(
+              batchCols[proj.sourceChannel].get(), rowIdx, rowInBatch, 1);
+        } else {
+          combined->setNull(rowIdx, true);
+        }
+      }
+      outputChildren[proj.outputChannel] = combined;
+    }
+  }
+
+  // Fill any remaining nullptr entries with null constants.
+  for (int32_t i = 0; i < static_cast<int32_t>(outputChildren.size()); ++i) {
+    if (!outputChildren[i]) {
+      outputChildren[i] =
+          BaseVector::createNullConstant(outputType->childAt(i), numRows, pool);
+    }
+  }
+
+  // Release rows from their input batches.
+  std::unordered_map<int32_t, int64_t> batchReleaseCounts;
+  for (const auto& loc : locations) {
+    batchReleaseCounts[loc.first]++;
+  }
+  for (const auto& [batchIdx, count] : batchReleaseCounts) {
+    state_->releaseRows(batchIdx, count);
+  }
+
+  return std::make_shared<RowVector>(
+      pool, outputType, nullptr, numRows, std::move(outputChildren));
+}
+
+} // namespace facebook::velox::exec::rpc
diff --git a/velox/exec/rpc/RPCOperator.h b/velox/exec/rpc/RPCOperator.h
new file mode 100644
index 00000000000..aab13149bcf
--- /dev/null
+++ b/velox/exec/rpc/RPCOperator.h
@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <vector>
+
+#include "velox/buffer/Buffer.h"
+#include "velox/common/future/VeloxPromise.h"
+#include "velox/exec/Operator.h"
+#include "velox/exec/rpc/RPCRateLimiter.h"
+#include "velox/exec/rpc/RPCState.h"
+#include "velox/expression/rpc/AsyncRPCFunction.h"
+
+namespace facebook::velox::exec::rpc {
+
+/// Single-operator implementation for async RPC execution in Velox.
+///
+/// Handles both dispatch (send RPCs in addInput()) and join (receive results
+/// in isBlocked()/getOutput()) within the same operator.
+///
+/// Architecture:
+///   TableScan -> RPCOperator -> downstream
+///
+/// The operator lifecycle:
+/// 1. addInput(): Reads pre-computed argument columns, dispatches RPCs via
+///    the function's dispatchPerRow() or accumulateBatch()+flushBatch().
+/// 2. needsInput(): Returns false when under backpressure or when there are
+///    ready results to output (prioritizes outputting over accepting input).
+/// 3. isBlocked(): Checks RPCState for completed responses. Returns
+///    kWaitForRPC when no results are ready yet.
+/// 4. getOutput(): Builds output RowVector from completed RPC responses
+///    combined with preserved input (passthrough) columns.
+/// 5. noMoreInput(): In BATCH mode, flushes remaining accumulated rows.
+///    Signals RPCState that no more rows will be dispatched.
+///
+/// Supports two streaming modes:
+/// - PER_ROW: Rows emitted as individual RPCs complete (out-of-order).
+///   Lower tail latency for high-variance workloads (e.g., LLM inference).
+/// - BATCH: All rows in a batch complete before emitting. Lower overhead
+///   for uniform-latency workloads. Supports pipelined dispatch via
+///   dispatchBatchSize.
+///
+/// State is derived from data presence (no explicit state machine enum):
+/// - Has output: claimedRows_ non-empty or claimedBatch_ has value
+/// - Finished: noMoreInput_ && state_->isFinished() && no claimed data
+///
+/// Thread safety model:
+/// - addInput(), getOutput(), needsInput(), isBlocked() are called from
+///   a single driver thread (Velox guarantee). No synchronization needed
+///   for operator-local state (e.g., globalRowIdCounter_, claimedRows_).
+/// - Async RPC callbacks may run on any thread (transport executor pool).
+///   All cross-thread coordination goes through RPCState, which is fully
+///   mutex-protected (see RPCState.h for per-method annotations).
+/// - RPCRateLimiter tokens use RAII: destruction (including from cancelled
+///   futures) automatically decrements the pending count and notifies
+///   waiters.
+///
+class RPCOperator : public exec::Operator {
+ public:
+  RPCOperator(
+      int32_t operatorId,
+      exec::DriverCtx* driverCtx,
+      std::shared_ptr<const core::RPCNode> rpcNode);
+
+  void initialize() override;
+
+  void close() override;
+
+  bool needsInput() const override;
+
+  void addInput(RowVectorPtr input) override;
+
+  void noMoreInput() override;
+
+  RowVectorPtr getOutput() override;
+
+  exec::BlockingReason isBlocked(ContinueFuture* future) override;
+
+  bool isFinished() override;
+
+  bool startDrain() override;
+
+  /// Runtime stat names.
+  static inline const std::string kRpcRequestsDispatched{
+      "rpcRequestsDispatched"};
+  static inline const std::string kRpcResponsesReceived{"rpcResponsesReceived"};
+  static inline const std::string kRpcErrorCount{"rpcErrorCount"};
+  static inline const std::string kRpcWaitWallNanos{"rpcWaitWallNanos"};
+  static inline const std::string kRpcBackpressureWaitNanos{
+      "rpcBackpressureWaitNanos"};
+
+ private:
+  /// Flush accumulated batch rows via function_->flushBatch().
+  /// Called when threshold is reached or at noMoreInput/drain time.
+  /// @param maxRows Maximum rows to flush. 0 means flush all.
+  void flushBatchRequests(int32_t maxRows = 0);
+
+  /// Build output RowVector from ready rows (PER_ROW mode).
+  /// Supports multiple rows via batched drain for pipeline efficiency.
+  RowVectorPtr buildOutputFromReadyRows(
+      std::vector<RPCState::ReadyRow>& readyRows);
+
+  /// Build output RowVector from a ready batch (BATCH mode).
+  RowVectorPtr buildOutputFromReadyBatch(RPCState::ReadyBatch& readyBatch);
+
+  /// Common helper: build output vector from responses + input data lookup.
+  RowVectorPtr buildOutputVector(
+      const std::vector<RPCResponse>& responses,
+      const std::vector<std::pair<int32_t, vector_size_t>>& locations);
+
+  /// Precompute output column projections from source type to output type.
+  /// Called once in initialize() to avoid repeated string lookups in
+  /// buildOutputVector().
+  void initOutputProjections();
+
+  /// Record runtime stats into operator stats. Called from close().
+  void recordRuntimeStats();
+
+  std::shared_ptr<const core::RPCNode> rpcNode_;
+  std::shared_ptr<RPCState> state_;
+  std::shared_ptr<AsyncRPCFunction> function_;
+
+  // Tier key for per-tier rate limiting (from function_->tierKey()).
+  std::string tierKey_;
+
+  // Precomputed argument column indices for reading from input in addInput().
+  // Initialized in initialize() by looking up argumentColumns in source type.
+  std::vector<column_index_t> argumentColumnIndices_;
+
+  // Collected row locations for current batch (BATCH mode).
+  // Passed to addPendingBatch() when the batch is flushed.
+  std::vector<RPCState::RowLocation> batchRowLocations_;
+
+  // Collected row IDs for current batch (BATCH mode).
+  // Used to stamp rowIds onto responses at flush time.
+  std::vector<int64_t> batchRowIds_;
+
+  int64_t numRequestsDispatched_{0};
+  int64_t numResponsesCollected_{0};
+  int64_t numErrors_{0};
+
+  // Global row ID counter for unique IDs across all input batches.
+  int64_t globalRowIdCounter_{0};
+
+  // Dispatch batch size for pipelined BATCH mode.
+  // 0 = collect all rows, fire once in noMoreInput().
+  // > 0 = fire flushBatch() every N rows during addInput().
+  int32_t dispatchBatchSize_{0};
+
+  // Claimed rows/batch from isBlocked() for use in getOutput().
+  // State is derived from these: if non-empty, we have output ready.
+  std::vector<RPCState::ReadyRow> claimedRows_;
+  std::optional<RPCState::ReadyBatch> claimedBatch_;
+
+  // Whether we've detected the finish condition.
+  bool finished_{false};
+
+  // Timeout for batch RPC calls (30 minutes).
+  // This is a ceiling — the operator returns as soon as results are ready.
+  // Batch LLM inference can take many minutes due to MetaGen queuing
+  // and GPU scheduling, so the timeout needs generous headroom.
+  static constexpr auto kBatchRpcTimeout = std::chrono::milliseconds(3'600'000);
+
+  // Block wait time tracking for runtime stats.
+  std::optional<uint64_t> blockWaitStartNs_;
+  bool blockWaitIsBackpressure_{false};
+  uint64_t totalBlockWaitNanos_{0};
+  uint64_t totalBackpressureWaitNanos_{0};
+
+  // Reusable indices buffer for dictionary wrapping in single-batch output
+  // path.
+  BufferPtr reusableIndices_;
+
+  // Precomputed output column projections (initialized in initialize()).
+  // Maps output column index to source column index for passthrough columns.
+  // Avoids repeated string-based column lookups in buildOutputVector().
+  struct OutputProjection {
+    column_index_t outputChannel;
+    column_index_t sourceChannel;
+  };
+  std::vector<OutputProjection> passthroughProjections_;
+  column_index_t rpcResultOutputChannel_{0};
+};
+
+} // namespace facebook::velox::exec::rpc
diff --git a/velox/exec/rpc/RPCPlanNodeTranslator.cpp b/velox/exec/rpc/RPCPlanNodeTranslator.cpp
new file mode 100644
index 00000000000..7ce309ff7eb
--- /dev/null
+++ b/velox/exec/rpc/RPCPlanNodeTranslator.cpp
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/rpc/RPCPlanNodeTranslator.h"
+
+#include <algorithm>
+
+#include "velox/exec/rpc/RPCOperator.h"
+
+namespace facebook::velox::exec::rpc {
+
+std::unique_ptr<exec::Operator> RPCPlanNodeTranslator::toOperator(
+    exec::DriverCtx* ctx,
+    int32_t id,
+    const core::PlanNodePtr& node) {
+  if (auto rpcNode = std::dynamic_pointer_cast<const core::RPCNode>(node)) {
+    VLOG(1) << "[RPC_TRANSLATOR] Creating RPCOperator for node id="
+            << node->id();
+    return std::make_unique<RPCOperator>(id, ctx, rpcNode);
+  }
+  return nullptr;
+}
+
+std::optional<uint32_t> RPCPlanNodeTranslator::maxDrivers(
+    const core::PlanNodePtr& node) {
+  if (auto rpcNode = std::dynamic_pointer_cast<const core::RPCNode>(node)) {
+    if (rpcNode->streamingMode() == rpc::RPCStreamingMode::kBatch) {
+      // BATCH mode: Force single-driver execution. Multiple drivers would
+      // race for batch results, with only one getting data and others
+      // finishing empty.
+      return 1;
+    }
+
+    // When all arguments are constants and no real data columns flow from the
+    // source, the upstream is a synthetic single-row ValuesNode. The Java
+    // AddLocalExchanges optimizer inserts a ROUND_ROBIN LocalExchange that
+    // distributes this single row across N drivers, causing N-1 drivers to
+    // finish empty and the result to be lost. Force single-driver execution.
+    const auto& constantInputs = rpcNode->constantInputs();
+    const auto& argumentColumns = rpcNode->argumentColumns();
+    bool allConstant = !constantInputs.empty() &&
+        std::all_of(
+            constantInputs.begin(), constantInputs.end(), [](const auto& v) {
+              return v != nullptr;
+            });
+    if (allConstant) {
+      auto sourceType = rpcNode->source()->outputType();
+      if (sourceType->size() <= argumentColumns.size()) {
+        return 1;
+      }
+    }
+
+    // PER_ROW mode: Allow parallel execution. Each driver claims individual
+    // rows atomically via RPCState::tryClaimOrWait().
+    return std::nullopt;
+  }
+  return std::nullopt;
+}
+
+void registerRPCPlanNodeTranslator() {
+  exec::Operator::registerOperator(std::make_unique<RPCPlanNodeTranslator>());
+}
+
+} // namespace facebook::velox::exec::rpc
diff --git a/velox/exec/rpc/RPCPlanNodeTranslator.h b/velox/exec/rpc/RPCPlanNodeTranslator.h
new file mode 100644
index 00000000000..b69e3bc532f
--- /dev/null
+++ b/velox/exec/rpc/RPCPlanNodeTranslator.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/exec/Operator.h"
+
+namespace facebook::velox::exec::rpc {
+
+/// PlanNodeTranslator for RPCNode.
+///
+/// Creates RPCOperator from RPCNode plan nodes.
+///
+/// maxDrivers() returns 1 for BATCH mode to prevent multiple drivers from
+/// competing for batch results. PER_ROW mode allows parallel execution
+/// since each driver claims individual rows atomically.
+class RPCPlanNodeTranslator : public exec::Operator::PlanNodeTranslator {
+ public:
+  std::unique_ptr<exec::Operator> toOperator(
+      exec::DriverCtx* ctx,
+      int32_t id,
+      const core::PlanNodePtr& node) override;
+
+  /// Returns 1 for BATCH mode (single-driver), nullopt for PER_ROW mode.
+  std::optional<uint32_t> maxDrivers(const core::PlanNodePtr& node) override;
+};
+
+/// Register the RPCPlanNodeTranslator with Velox.
+void registerRPCPlanNodeTranslator();
+
+} // namespace facebook::velox::exec::rpc
diff --git a/velox/exec/rpc/RPCRateLimiter.cpp b/velox/exec/rpc/RPCRateLimiter.cpp
new file mode 100644
index 00000000000..f6da2aab80f
--- /dev/null
+++ b/velox/exec/rpc/RPCRateLimiter.cpp
@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/rpc/RPCRateLimiter.h"
+
+#define RPC_RATE_LIMITER_LOG(severity) LOG(severity) << "[RPC_RATE_LIMITER] "
+#define RPC_RATE_LIMITER_VLOG(level) VLOG(level) << "[RPC_RATE_LIMITER] "
+
+namespace facebook::velox::exec::rpc {
+
+// --- Token implementation ---
+
+RPCRateLimiter::Token::Token(const std::string& tierKey)
+    : tierKey_(tierKey), valid_(true) {}
+
+RPCRateLimiter::Token& RPCRateLimiter::Token::operator=(
+    Token&& other) noexcept {
+  if (this != &other) {
+    if (valid_) {
+      decrementPending(tierKey_);
+    }
+    tierKey_ = std::move(other.tierKey_);
+    valid_ = other.valid_;
+    other.valid_ = false;
+  }
+  return *this;
+}
+
+RPCRateLimiter::Token::~Token() {
+  if (valid_) {
+    decrementPending(tierKey_);
+  }
+}
+
+// --- Function-local statics ---
+
+std::mutex& RPCRateLimiter::mapMutex() {
+  static std::mutex mutex;
+  return mutex;
+}
+
+std::atomic<int64_t>& RPCRateLimiter::defaultMaxPendingRef() {
+  // Default: 20 concurrent RPCs per process per tier.
+  static std::atomic<int64_t> maxPending{20};
+  return maxPending;
+}
+
+std::unordered_map<std::string, std::unique_ptr<RPCRateLimiter::TierState>>&
+RPCRateLimiter::tiers() {
+  static std::unordered_map<std::string, std::unique_ptr<TierState>> tierMap;
+  return tierMap;
+}
+
+// --- TierState lookup ---
+
+RPCRateLimiter::TierState& RPCRateLimiter::getOrCreateTierState(
+    const std::string& tierKey) {
+  std::lock_guard<std::mutex> l(mapMutex());
+  auto& tierMap = tiers();
+  auto it = tierMap.find(tierKey);
+  if (it != tierMap.end()) {
+    return *it->second;
+  }
+  auto [newIt, _] = tierMap.emplace(tierKey, std::make_unique<TierState>());
+  return *newIt->second;
+}
+
+// --- Public API ---
+
+RPCRateLimiter::Token RPCRateLimiter::acquire(const std::string& tierKey) {
+  incrementPending(tierKey);
+  return Token(tierKey);
+}
+
+std::optional<ContinueFuture> RPCRateLimiter::checkBackpressure(
+    const std::string& tierKey) {
+  auto& state = getOrCreateTierState(tierKey);
+
+  std::lock_guard<std::mutex> l(state.mutex);
+
+  int64_t pending = state.pendingCount.load();
+  int64_t maxPending =
+      state.maxPending > 0 ? state.maxPending : defaultMaxPendingRef().load();
+
+  if (pending < maxPending) {
+    RPC_RATE_LIMITER_VLOG(2)
+        << "checkBackpressure[" << tierKey << "]: OK (pending=" << pending
+        << ", max=" << maxPending << ")";
+    return std::nullopt;
+  }
+
+  RPC_RATE_LIMITER_VLOG(1) << "checkBackpressure[" << tierKey
+                           << "]: BLOCKED (pending=" << pending
+                           << ", max=" << maxPending
+                           << "), creating wait promise #"
+                           << state.waiters.size();
+  state.waiters.emplace_back("RPCRateLimiter::checkBackpressure");
+  return state.waiters.back().getSemiFuture();
+}
+
+int64_t RPCRateLimiter::pendingCount(const std::string& tierKey) {
+  auto& state = getOrCreateTierState(tierKey);
+  return state.pendingCount.load();
+}
+
+void RPCRateLimiter::setMaxPending(const std::string& tierKey, int64_t limit) {
+  auto& state = getOrCreateTierState(tierKey);
+  std::lock_guard<std::mutex> l(state.mutex);
+  state.maxPending = limit;
+  RPC_RATE_LIMITER_VLOG(1) << "setMaxPending[" << tierKey << "]: set to "
+                           << limit;
+}
+
+void RPCRateLimiter::setDefaultMaxPending(int64_t limit) {
+  defaultMaxPendingRef().store(limit);
+  RPC_RATE_LIMITER_VLOG(1) << "setDefaultMaxPending: set to " << limit;
+}
+
+int64_t RPCRateLimiter::defaultMaxPending() {
+  return defaultMaxPendingRef().load();
+}
+
+void RPCRateLimiter::testingResetAllState() {
+  std::lock_guard<std::mutex> l(mapMutex());
+  defaultMaxPendingRef().store(20);
+  tiers().clear();
+}
+
+// --- Internal helpers ---
+
+void RPCRateLimiter::incrementPending(const std::string& tierKey) {
+  auto& state = getOrCreateTierState(tierKey);
+  int64_t newCount = ++state.pendingCount;
+  RPC_RATE_LIMITER_VLOG(2) << "incrementPending[" << tierKey
+                           << "]: pending=" << newCount;
+}
+
+void RPCRateLimiter::decrementPending(const std::string& tierKey) {
+  auto& state = getOrCreateTierState(tierKey);
+  int64_t newCount = --state.pendingCount;
+  RPC_RATE_LIMITER_VLOG(2) << "decrementPending[" << tierKey
+                           << "]: pending=" << newCount;
+
+  // CRITICAL: Hold the per-tier mutex when checking whether to notify waiters.
+  // This prevents a TOCTOU race where:
+  // 1. We read newCount < maxPending (should notify)
+  // 2. A new waiter is added in checkBackpressure() between read and notify
+  //
+  // By holding the lock during check-and-notify, any waiter added in
+  // checkBackpressure() will either:
+  // - Be in state.waiters before we check (and we'll notify it)
+  // - See the updated count and not need to wait at all
+  //
+  // We notify only one waiter per decrement (FIFO) to avoid thundering herd.
+  std::optional<ContinuePromise> waiterToNotify;
+  {
+    std::lock_guard<std::mutex> l(state.mutex);
+    int64_t maxPending =
+        state.maxPending > 0 ? state.maxPending : defaultMaxPendingRef().load();
+    if (newCount < maxPending && !state.waiters.empty()) {
+      RPC_RATE_LIMITER_VLOG(1)
+          << "decrementPending[" << tierKey << "]: notifying 1 of "
+          << state.waiters.size() << " waiters";
+      waiterToNotify = std::move(state.waiters.front());
+      state.waiters.pop_front();
+    }
+  }
+  if (waiterToNotify) {
+    waiterToNotify->setValue();
+  }
+}
+
+} // namespace facebook::velox::exec::rpc
diff --git a/velox/exec/rpc/RPCRateLimiter.h b/velox/exec/rpc/RPCRateLimiter.h
new file mode 100644
index 00000000000..a9f2e0a4d45
--- /dev/null
+++ b/velox/exec/rpc/RPCRateLimiter.h
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <atomic>
+#include <deque>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "velox/common/future/VeloxPromise.h"
+
+namespace facebook::velox::exec::rpc {
+
+/// Per-tier (per-process) rate limiter for RPC dispatch.
+///
+/// Each backend service tier (e.g., "service.backend.prod") gets its own
+/// independent concurrency limit and waiter queue. This allows different
+/// backends to have different concurrency budgets.
+///
+/// The rate limiter is per-process. Each Presto worker is a separate process
+/// with its own ServiceRouter connections. Cross-worker coordination is
+/// handled by the backend's own admission control.
+///
+/// The tier key comes from IRPCClient::tierKey(). Empty string means
+/// "no tier configured" and falls back to the global default limit.
+class RPCRateLimiter {
+ public:
+  /// RAII token representing one in-flight request slot.
+  /// Decrements the pending count on destruction, guaranteeing cleanup
+  /// even if the RPC future is abandoned (e.g., query cancellation).
+  class Token {
+   public:
+    Token() = default;
+
+    Token(Token&& other) noexcept
+        : tierKey_(std::move(other.tierKey_)), valid_(other.valid_) {
+      other.valid_ = false;
+    }
+
+    Token& operator=(Token&& other) noexcept;
+
+    ~Token();
+
+    // Non-copyable.
+    Token(const Token&) = delete;
+    Token& operator=(const Token&) = delete;
+
+   private:
+    friend class RPCRateLimiter;
+    explicit Token(const std::string& tierKey);
+
+    std::string tierKey_;
+    bool valid_{false};
+  };
+
+  /// Acquire a slot for the given tier. Increments pending count and
+  /// returns a Token that will decrement on destruction.
+  static Token acquire(const std::string& tierKey);
+
+  /// Check backpressure for a specific tier.
+  /// Returns a future to wait on if that tier's limit is reached.
+  /// @return Future to wait on if blocked, nullopt if can proceed.
+  static std::optional<ContinueFuture> checkBackpressure(
+      const std::string& tierKey);
+
+  /// Get current pending count for a specific tier.
+  static int64_t pendingCount(const std::string& tierKey);
+
+  /// Configure the max pending limit for a specific tier.
+  /// If not configured, falls back to the global default.
+  static void setMaxPending(const std::string& tierKey, int64_t limit);
+
+  /// Set the global default max pending (used when no per-tier config).
+  static void setDefaultMaxPending(int64_t limit);
+
+  /// Get the global default max pending.
+  static int64_t defaultMaxPending();
+
+  /// Reset all state. Intended ONLY for unit tests
+  /// to avoid test contamination across test cases.
+  /// WARNING: Do NOT call this in production code.
+  static void testingResetAllState();
+
+ private:
+  /// Per-tier state. Allocated via unique_ptr for pointer stability across
+  /// map inserts (std::unordered_map does not invalidate existing entries).
+  struct TierState {
+    std::mutex mutex;
+    std::atomic<int64_t> pendingCount{0};
+    int64_t maxPending{0}; // 0 = use global default
+    std::deque<ContinuePromise> waiters;
+  };
+
+  static void incrementPending(const std::string& tierKey);
+  static void decrementPending(const std::string& tierKey);
+
+  static TierState& getOrCreateTierState(const std::string& tierKey);
+
+  // Global mutex protects only the tier map for inserts/lookups.
+  static std::mutex& mapMutex();
+  static std::atomic<int64_t>& defaultMaxPendingRef();
+  static std::unordered_map<std::string, std::unique_ptr<TierState>>& tiers();
+};
+
+} // namespace facebook::velox::exec::rpc
diff --git a/velox/exec/rpc/RPCState.cpp b/velox/exec/rpc/RPCState.cpp
new file mode 100644
index 00000000000..4857d0d7258
--- /dev/null
+++ b/velox/exec/rpc/RPCState.cpp
@@ -0,0 +1,382 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/rpc/RPCState.h"
+
+#include <folly/executors/InlineExecutor.h>
+
+#include "velox/common/base/Exceptions.h"
+
+#define RPC_STATE_LOG(severity) LOG(severity) << "[RPC_STATE] "
+#define RPC_STATE_VLOG(level) VLOG(level) << "[RPC_STATE] "
+
+namespace facebook::velox::exec::rpc {
+
+// ===== Configuration =====
+// These setters are called during RPCOperator construction, before any
+// concurrent access. No lock needed — avoids lock-order-inversion with the
+// Task mutex (TSAN: M0→M1→M0 cycle).
+
+void RPCState::setStreamingMode(RPCStreamingMode mode) {
+  streamingMode_ = mode;
+}
+
+RPCStreamingMode RPCState::streamingMode() const {
+  return streamingMode_;
+}
+
+void RPCState::setMaxPendingRows(int64_t maxPendingRows) {
+  maxPendingRows_ = maxPendingRows;
+}
+
+void RPCState::setMaxPendingBatches(int64_t maxPendingBatches) {
+  maxPendingBatches_ = maxPendingBatches;
+  effectiveMaxPendingBatches_ = maxPendingBatches;
+}
+
+// ===== Input batch storage =====
+
+int32_t RPCState::storeInputBatch(
+    std::vector<VectorPtr> flatColumns,
+    int64_t rowCount) {
+  std::lock_guard<std::mutex> l(mutex_);
+  auto batchIndex = static_cast<int32_t>(inputBatches_.size());
+  inputBatches_.push_back(
+      InputBatchRef{
+          .flatColumns = std::move(flatColumns), .activeRowCount = rowCount});
+  RPC_STATE_VLOG(2) << "storeInputBatch: batchIndex=" << batchIndex
+                    << ", rowCount=" << rowCount;
+  return batchIndex;
+}
+
+std::vector<VectorPtr> RPCState::getInputBatchColumns(
+    int32_t batchIndex) const {
+  std::lock_guard<std::mutex> l(mutex_);
+  VELOX_CHECK_LT(
+      batchIndex,
+      static_cast<int32_t>(inputBatches_.size()),
+      "Invalid batchIndex {} for inputBatches_ of size {}",
+      batchIndex,
+      inputBatches_.size());
+  return inputBatches_[batchIndex].flatColumns;
+}
+
+void RPCState::releaseRows(int32_t batchIndex, int64_t count) {
+  std::lock_guard<std::mutex> l(mutex_);
+  VELOX_CHECK_LT(
+      batchIndex,
+      static_cast<int32_t>(inputBatches_.size()),
+      "Invalid batchIndex {} for inputBatches_ of size {}",
+      batchIndex,
+      inputBatches_.size());
+  auto& batch = inputBatches_[batchIndex];
+  VELOX_CHECK_GE(
+      batch.activeRowCount,
+      count,
+      "Cannot release {} rows from batch {} with only {} active rows",
+      count,
+      batchIndex,
+      batch.activeRowCount);
+  batch.activeRowCount -= count;
+  if (batch.activeRowCount == 0) {
+    // Release the column vectors to free memory.
+    batch.flatColumns.clear();
+    RPC_STATE_VLOG(2) << "releaseRows: batch " << batchIndex
+                      << " fully released";
+  }
+}
+
+// ===== PER_ROW mode API =====
+
+void RPCState::addPendingRow(
+    std::shared_ptr<RPCState> selfPtr,
+    int64_t rowId,
+    RowLocation location,
+    folly::SemiFuture<RPCResponse> future) {
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    numPendingRows_++;
+    RPC_STATE_VLOG(2) << "addPendingRow: rowId=" << rowId
+                      << ", pendingCount=" << numPendingRows_;
+  }
+
+  // Attach completion callbacks that delegate to completeRow().
+  // We capture selfPtr to keep this RPCState alive until the callback fires.
+  auto stateForError = selfPtr;
+  folly::futures::detachOn(
+      folly::getKeepAliveToken(folly::InlineExecutor::instance()),
+      std::move(future)
+          .deferValue([state = std::move(selfPtr), rowId, location](
+                          RPCResponse response) mutable {
+            state->completeRow(rowId, location, std::move(response));
+          })
+          .deferError([state = std::move(stateForError), rowId, location](
+                          const folly::exception_wrapper& ew) mutable {
+            RPC_STATE_LOG(ERROR)
+                << "RPC failed for rowId=" << rowId << ": " << ew.what();
+            RPCResponse errorResponse;
+            errorResponse.rowId = rowId;
+            errorResponse.error = ew.what().toStdString();
+            state->completeRow(rowId, location, std::move(errorResponse));
+          }));
+}
+
+void RPCState::completeRow(
+    int64_t rowId,
+    RowLocation location,
+    RPCResponse response) {
+  std::lock_guard<std::mutex> l(mutex_);
+  readyRows_.push_back(
+      ReadyRow{
+          .rowId = rowId,
+          .location = location,
+          .response = std::move(response)});
+  numPendingRows_--;
+
+  RPC_STATE_VLOG(2) << "Row completed: rowId=" << rowId
+                    << ", readyRows=" << readyRows_.size()
+                    << ", pendingCount=" << numPendingRows_;
+
+  notifyWaitersLocked();
+}
+
+RPCState::ClaimResult RPCState::tryClaimOrWait(
+    ContinueFuture* future,
+    std::optional<ReadyRow>* claimedRow) {
+  std::lock_guard<std::mutex> l(mutex_);
+
+  // Step 1: Try to claim a ready row.
+  if (!readyRows_.empty()) {
+    *claimedRow = std::move(readyRows_.front());
+    readyRows_.pop_front();
+    RPC_STATE_VLOG(1) << "tryClaimOrWait: claimed rowId="
+                      << (*claimedRow)->rowId
+                      << ", remaining ready=" << readyRows_.size();
+    return ClaimResult::kClaimed;
+  }
+
+  // Step 2: Check finish condition.
+  if (noMoreInput_ && numPendingRows_ == 0) {
+    RPC_STATE_VLOG(1) << "tryClaimOrWait: finish condition met";
+    return ClaimResult::kFinished;
+  }
+
+  // Step 3: Must wait — create a promise under the same lock to prevent
+  // TOCTOU races (no completion can slip between the check and wait).
+  RPC_STATE_VLOG(2) << "tryClaimOrWait: must wait (pending=" << numPendingRows_
+                    << ")";
+  promises_.emplace_back("RPCState::tryClaimOrWait");
+  *future = promises_.back().getSemiFuture();
+  return ClaimResult::kMustWait;
+}
+
+std::optional<RPCState::ReadyRow> RPCState::tryClaimReady() {
+  std::lock_guard<std::mutex> l(mutex_);
+  if (!readyRows_.empty()) {
+    auto row = std::move(readyRows_.front());
+    readyRows_.pop_front();
+    RPC_STATE_VLOG(1) << "tryClaimReady: claimed rowId=" << row.rowId
+                      << ", remaining ready=" << readyRows_.size();
+    return row;
+  }
+  return std::nullopt;
+}
+
+void RPCState::drainReadyRows(std::vector<ReadyRow>& out, int32_t maxRows) {
+  std::lock_guard<std::mutex> l(mutex_);
+  while (!readyRows_.empty() && static_cast<int32_t>(out.size()) < maxRows) {
+    out.push_back(std::move(readyRows_.front()));
+    readyRows_.pop_front();
+  }
+}
+
+int64_t RPCState::numPendingRows() {
+  std::lock_guard<std::mutex> l(mutex_);
+  return numPendingRows_;
+}
+
+// ===== BATCH mode API =====
+
+void RPCState::addPendingBatch(
+    std::shared_ptr<RPCState> selfPtr,
+    folly::SemiFuture<std::vector<RPCResponse>> future,
+    std::vector<RowLocation> rowLocations) {
+  std::lock_guard<std::mutex> l(mutex_);
+
+  int64_t batchId = nextBatchId_++;
+
+  // Attach a completion callback that notifies waiters when the batch
+  // completes. We use .via().thenValue() to run the callback eagerly.
+  auto callbackFuture =
+      std::move(future)
+          .via(folly::getKeepAliveToken(folly::InlineExecutor::instance()))
+          .thenValue([state = selfPtr](std::vector<RPCResponse> responses) {
+            RPC_STATE_VLOG(1)
+                << "Batch completed with " << responses.size() << " responses";
+            {
+              std::lock_guard<std::mutex> l(state->mutex_);
+              state->notifyWaitersLocked();
+            }
+            return responses;
+          })
+          .thenError([state = selfPtr](folly::exception_wrapper ew) {
+            RPC_STATE_LOG(ERROR) << "Batch failed: " << ew.what();
+            {
+              std::lock_guard<std::mutex> l(state->mutex_);
+              state->notifyWaitersLocked();
+            }
+            return folly::makeSemiFuture<std::vector<RPCResponse>>(
+                std::move(ew));
+          })
+          .semi();
+
+  pendingBatches_.push_back(
+      PendingBatch{
+          .batchId = batchId,
+          .future = std::move(callbackFuture),
+          .rowLocations = std::move(rowLocations)});
+
+  RPC_STATE_VLOG(1) << "addPendingBatch: batchId=" << batchId
+                    << ", totalPending=" << pendingBatches_.size();
+}
+
+RPCState::BatchPollResult RPCState::tryPollBatchOrWait(
+    ContinueFuture* future,
+    std::optional<ReadyBatch>* readyBatch) {
+  std::lock_guard<std::mutex> l(mutex_);
+
+  // Step 1: Check for a ready batch (out-of-order: first ready wins).
+  for (auto it = pendingBatches_.begin(); it != pendingBatches_.end(); ++it) {
+    if (it->future.isReady()) {
+      ReadyBatch result;
+      result.batchId = it->batchId;
+      result.rowLocations = std::move(it->rowLocations);
+
+      try {
+        result.responses = std::move(it->future).get();
+        RPC_STATE_VLOG(1) << "tryPollBatchOrWait: batchId=" << result.batchId
+                          << " ready with " << result.responses.size()
+                          << " responses";
+      } catch (const std::exception& e) {
+        result.error = e.what();
+        result.responses = {};
+        RPC_STATE_LOG(ERROR) << "tryPollBatchOrWait: batchId=" << result.batchId
+                             << " failed: " << e.what();
+      }
+
+      pendingBatches_.erase(it);
+      *readyBatch = std::move(result);
+      return BatchPollResult::kGotBatch;
+    }
+  }
+
+  // Step 2: Check finish condition.
+  if (noMoreInput_ && pendingBatches_.empty()) {
+    RPC_STATE_VLOG(1) << "tryPollBatchOrWait: finish condition met";
+    return BatchPollResult::kFinished;
+  }
+
+  // Step 3: Must wait.
+  RPC_STATE_VLOG(2) << "tryPollBatchOrWait: must wait";
+  promises_.emplace_back("RPCState::tryPollBatchOrWait");
+  *future = promises_.back().getSemiFuture();
+  return BatchPollResult::kMustWait;
+}
+
+std::optional<RPCState::ReadyBatch> RPCState::tryPollReady() {
+  std::lock_guard<std::mutex> l(mutex_);
+  for (auto it = pendingBatches_.begin(); it != pendingBatches_.end(); ++it) {
+    if (it->future.isReady()) {
+      ReadyBatch result;
+      result.batchId = it->batchId;
+      result.rowLocations = std::move(it->rowLocations);
+      try {
+        result.responses = std::move(it->future).get();
+        RPC_STATE_VLOG(1) << "tryPollReady: batchId=" << result.batchId
+                          << " ready with " << result.responses.size()
+                          << " responses";
+      } catch (const std::exception& e) {
+        result.error = e.what();
+        result.responses = {};
+        RPC_STATE_LOG(ERROR) << "tryPollReady: batchId=" << result.batchId
+                             << " failed: " << e.what();
+      }
+      pendingBatches_.erase(it);
+      return result;
+    }
+  }
+  return std::nullopt;
+}
+
+// ===== Common =====
+
+void RPCState::setNoMoreInput() {
+  std::lock_guard<std::mutex> l(mutex_);
+  noMoreInput_ = true;
+  RPC_STATE_VLOG(1) << "setNoMoreInput: pendingRows=" << numPendingRows_
+                    << ", pendingBatches=" << pendingBatches_.size()
+                    << ", readyRows=" << readyRows_.size();
+  notifyWaitersLocked();
+}
+
+bool RPCState::isFinished() {
+  std::lock_guard<std::mutex> l(mutex_);
+  return noMoreInput_ && numPendingRows_ == 0 && readyRows_.empty() &&
+      pendingBatches_.empty();
+}
+
+bool RPCState::isUnderBackpressure() {
+  std::lock_guard<std::mutex> l(mutex_);
+  if (streamingMode_ == RPCStreamingMode::kBatch) {
+    return static_cast<int64_t>(pendingBatches_.size()) >=
+        effectiveMaxPendingBatches_;
+  }
+  return numPendingRows_ >= maxPendingRows_;
+}
+
+void RPCState::onBatchSuccess(int64_t increment) {
+  std::lock_guard<std::mutex> l(mutex_);
+  if (effectiveMaxPendingBatches_ < maxPendingBatches_) {
+    effectiveMaxPendingBatches_ =
+        std::min(effectiveMaxPendingBatches_ + increment, maxPendingBatches_);
+    RPC_STATE_LOG(INFO) << "RPC congestion: batch success, window increased to "
+                        << effectiveMaxPendingBatches_ << "/"
+                        << maxPendingBatches_;
+  }
+}
+
+void RPCState::onBatchError() {
+  std::lock_guard<std::mutex> l(mutex_);
+  auto prev = effectiveMaxPendingBatches_;
+  effectiveMaxPendingBatches_ =
+      std::max<int64_t>(effectiveMaxPendingBatches_ / 2, 1);
+  if (effectiveMaxPendingBatches_ < prev) {
+    RPC_STATE_LOG(WARNING)
+        << "RPC congestion: batch error, window decreased from " << prev
+        << " to " << effectiveMaxPendingBatches_;
+  }
+}
+
+void RPCState::notifyWaitersLocked() {
+  // Fulfill all promises to wake up blocked drivers.
+  // Called while mutex_ is held.
+  for (auto& promise : promises_) {
+    promise.setValue();
+  }
+  promises_.clear();
+}
+
+} // namespace facebook::velox::exec::rpc
diff --git a/velox/exec/rpc/RPCState.h b/velox/exec/rpc/RPCState.h
new file mode 100644
index 00000000000..a4c018d369f
--- /dev/null
+++ b/velox/exec/rpc/RPCState.h
@@ -0,0 +1,277 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <deque>
+#include <mutex>
+#include <optional>
+#include <vector>
+
+#include <folly/futures/Future.h>
+
+#include "velox/common/future/VeloxPromise.h"
+#include "velox/common/rpc/RPCTypes.h"
+#include "velox/vector/BaseVector.h"
+
+namespace facebook::velox::exec::rpc {
+
+// Import RPC types from velox/common/rpc into this namespace.
+using velox::rpc::RPCResponse;
+using velox::rpc::RPCStreamingMode;
+
+/// A stored input batch with its rows referenced by index.
+/// Instead of slicing individual rows, we keep the entire batch and
+/// use row indices to look up passthrough columns at output time.
+struct InputBatchRef {
+  /// Flattened columns from the input batch (shared across all rows).
+  std::vector<VectorPtr> flatColumns;
+
+  /// Number of rows from this batch that are still in-flight or pending output.
+  /// When this reaches 0, the batch can be released.
+  int64_t activeRowCount{0};
+};
+
+/// Shared state between RPCOperator's driver thread and RPC completion
+/// callbacks.
+///
+/// A mutex-protected state object owned by RPCOperator. It coordinates
+/// async RPC dispatch (addPendingRow/addPendingBatch) with result
+/// consumption (tryClaimOrWait/tryPollBatchOrWait) across the driver
+/// thread and RPC client executor threads.
+///
+/// Thread safety: All public methods are thread-safe. The mutex_ protects
+/// all mutable state. Completion callbacks from the RPC client's executor
+/// threads call notifyWaitersLocked() to wake the driver thread.
+///
+/// Two streaming modes:
+/// - PER_ROW: Rows are emitted as they complete individually (out-of-order).
+///   Lower tail latency for high-variance workloads (e.g., LLM inference).
+/// - BATCH: All rows in a batch complete before emitting. Lower overhead
+///   for uniform-latency workloads.
+class RPCState {
+ public:
+  // ===== Data structures =====
+
+  /// Location of a row within an input batch.
+  struct RowLocation {
+    int32_t batchIndex{0};
+    vector_size_t rowIndex{0};
+  };
+
+  /// A completed row with its RPC response and location in the input batch.
+  struct ReadyRow {
+    int64_t rowId{0};
+    RowLocation location;
+    RPCResponse response;
+  };
+
+  /// A batch of rows waiting for RPC response.
+  struct PendingBatch {
+    int64_t batchId;
+    folly::SemiFuture<std::vector<RPCResponse>> future;
+    /// Row locations for mapping responses back to input batch positions.
+    /// Stored at batch level instead of per-row in a map, since callBatch()
+    /// returns responses in the same order as requests.
+    std::vector<RowLocation> rowLocations;
+  };
+
+  /// A batch with completed RPC responses.
+  struct ReadyBatch {
+    int64_t batchId{0};
+    std::vector<RPCResponse> responses;
+    std::optional<std::string> error;
+    /// Row locations carried from PendingBatch for response-to-input mapping.
+    std::vector<RowLocation> rowLocations;
+  };
+
+  RPCState() = default;
+
+  // ===== Configuration =====
+  // These must be called before any dispatch (single-threaded init phase).
+
+  /// Set the streaming mode. Must be called before any dispatch.
+  void setStreamingMode(RPCStreamingMode mode);
+
+  /// Get the current streaming mode.
+  RPCStreamingMode streamingMode() const;
+
+  /// Set the maximum number of pending rows before backpressure.
+  void setMaxPendingRows(int64_t maxPendingRows);
+
+  /// Set the maximum number of pending batches before backpressure (BATCH
+  /// mode).
+  void setMaxPendingBatches(int64_t maxPendingBatches);
+
+  // ===== Input batch storage =====
+  // Called from the driver thread (addInput/getOutput). Thread-safe.
+
+  /// Store an input batch and return its index. Thread-safe.
+  /// The batch is reference-counted; call releaseRows() when rows are output.
+  int32_t storeInputBatch(std::vector<VectorPtr> flatColumns, int64_t rowCount);
+
+  /// Get the flattened columns for a stored input batch. Thread-safe.
+  /// Returns by value to avoid returning a reference that outlives the lock.
+  std::vector<VectorPtr> getInputBatchColumns(int32_t batchIndex) const;
+
+  /// Release rows from an input batch. Thread-safe.
+  /// When all rows are released, the batch columns are freed.
+  void releaseRows(int32_t batchIndex, int64_t count);
+
+  // ===== PER_ROW mode API =====
+
+  /// Add a pending row with its RPC future and location in the input batch.
+  /// Thread-safe. Called from the driver thread in addInput().
+  ///
+  /// Attaches a completion callback to the future that moves the response
+  /// into readyRows_ and notifies waiting drivers. The callback runs on
+  /// the RPC client's executor thread, acquiring mutex_ internally.
+  ///
+  /// @param selfPtr Shared pointer to this RPCState, captured by the callback
+  ///        to prevent premature destruction.
+  /// @param rowId Globally unique row ID for correlation.
+  /// @param location Row's location in the stored input batch.
+  /// @param future The SemiFuture from client->call().
+  void addPendingRow(
+      std::shared_ptr<RPCState> selfPtr,
+      int64_t rowId,
+      RowLocation location,
+      folly::SemiFuture<RPCResponse> future);
+
+  /// Atomically try to claim a ready row, check finish, or wait. Thread-safe.
+  /// Called from the driver thread in isBlocked().
+  ///
+  /// All three checks happen under a single lock to prevent TOCTOU races.
+  ///
+  /// @param[out] future Set to a wait future if kMustWait.
+  /// @param[out] claimedRow Set to the claimed row if kClaimed.
+  /// @return kClaimed, kFinished, or kMustWait.
+  enum class ClaimResult { kClaimed, kFinished, kMustWait };
+  ClaimResult tryClaimOrWait(
+      ContinueFuture* future,
+      std::optional<ReadyRow>* claimedRow);
+
+  /// Non-blocking claim of a ready row. Thread-safe.
+  /// Returns nullopt if no ready rows.
+  /// Unlike tryClaimOrWait(), does NOT create a promise on miss.
+  /// Use this pre-noMoreInput to avoid accumulating orphaned promises.
+  std::optional<ReadyRow> tryClaimReady();
+
+  /// Drain all currently ready rows (non-blocking, up to maxRows). Thread-safe.
+  /// Used for batched PER_ROW output to amortize RowVector allocation.
+  void drainReadyRows(std::vector<ReadyRow>& out, int32_t maxRows);
+
+  /// Returns the number of pending (in-flight) rows. Thread-safe.
+  int64_t numPendingRows();
+
+  // ===== BATCH mode API =====
+
+  /// Add a pending batch future with row locations for response-to-input
+  /// mapping. Thread-safe. Called from the driver thread in
+  /// flushBatchRequests().
+  ///
+  /// Attaches a completion callback that notifies waiters on completion.
+  /// The callback runs on the RPC client's executor thread, acquiring
+  /// mutex_ internally.
+  ///
+  /// @param selfPtr Shared pointer to this RPCState (prevent destruction).
+  /// @param future The SemiFuture from client->callBatch().
+  /// @param rowLocations Locations mapping each request to its input batch
+  ///        position. Stored on the PendingBatch and carried through to
+  ///        ReadyBatch, eliminating per-row rowLocations_ map overhead.
+  void addPendingBatch(
+      std::shared_ptr<RPCState> selfPtr,
+      folly::SemiFuture<std::vector<RPCResponse>> future,
+      std::vector<RowLocation> rowLocations);
+
+  /// Atomically try to poll a ready batch, check finish, or wait. Thread-safe.
+  /// Called from the driver thread in isBlocked().
+  ///
+  /// @param[out] future Set to a wait future if kMustWait.
+  /// @param[out] readyBatch Set to the ready batch if kGotBatch.
+  /// @return kGotBatch, kFinished, or kMustWait.
+  enum class BatchPollResult { kGotBatch, kFinished, kMustWait };
+  BatchPollResult tryPollBatchOrWait(
+      ContinueFuture* future,
+      std::optional<ReadyBatch>* readyBatch);
+
+  /// Non-blocking poll of a ready batch. Thread-safe.
+  /// Returns nullopt if no batch ready.
+  /// Unlike tryPollBatchOrWait(), does NOT create a promise on miss.
+  /// Use this pre-noMoreInput to avoid accumulating orphaned promises.
+  std::optional<ReadyBatch> tryPollReady();
+
+  // ===== Common =====
+
+  /// Signal that no more rows will be dispatched. Thread-safe.
+  void setNoMoreInput();
+
+  /// Returns true when all work is complete. Thread-safe.
+  bool isFinished();
+
+  /// Returns true if backpressure should be applied. Thread-safe.
+  /// PER_ROW mode: pending rows >= maxPendingRows.
+  /// BATCH mode: pending batches >= effectiveMaxPendingBatches
+  /// (congestion-adjusted).
+  bool isUnderBackpressure();
+
+  /// Signal that a batch completed successfully (all responses non-empty).
+  /// Increases the effective concurrency window by increment (additive
+  /// increase). Thread-safe.
+  void onBatchSuccess(int64_t increment = 2);
+
+  /// Signal that a batch had errors (e.g., empty responses from overload).
+  /// Halves the effective concurrency window (multiplicative decrease).
+  /// Thread-safe.
+  void onBatchError();
+
+ private:
+  /// Move a completed row into readyRows_ and notify waiters.
+  /// Called from the RPC completion callback (runs on executor thread).
+  void completeRow(int64_t rowId, RowLocation location, RPCResponse response);
+
+  /// Fulfill all waiting promises and clear. Called under lock.
+  void notifyWaitersLocked();
+
+  mutable std::mutex mutex_;
+  std::vector<ContinuePromise> promises_;
+
+  // Input batch storage (shared across PER_ROW and BATCH modes)
+  std::vector<InputBatchRef> inputBatches_;
+
+  // PER_ROW state
+  std::deque<ReadyRow> readyRows_;
+  int64_t numPendingRows_{0};
+
+  // BATCH state
+  int64_t nextBatchId_{0};
+  std::deque<PendingBatch> pendingBatches_;
+
+  // Common
+  bool noMoreInput_{false};
+  RPCStreamingMode streamingMode_{RPCStreamingMode::kPerRow};
+  int64_t maxPendingRows_{100};
+  int64_t maxPendingBatches_{2};
+
+  // Congestion control for BATCH mode.
+  // effectiveMaxPendingBatches_ starts at maxPendingBatches_ and adjusts:
+  //   - On success: min(effective + 1, maxPendingBatches_)  (additive increase)
+  //   - On error:   max(effective / 2, 1)                   (multiplicative
+  //   decrease)
+  int64_t effectiveMaxPendingBatches_{2};
+};
+
+} // namespace facebook::velox::exec::rpc
diff --git a/velox/exec/rpc/tests/CMakeLists.txt b/velox/exec/rpc/tests/CMakeLists.txt
new file mode 100644
index 00000000000..8b2f61801d5
--- /dev/null
+++ b/velox/exec/rpc/tests/CMakeLists.txt
@@ -0,0 +1,95 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_executable(velox_mock_rpc_client_test MockRPCClientTest.cpp)
+
+target_link_libraries(
+  velox_mock_rpc_client_test
+  velox_mock_rpc_client
+  GTest::gtest
+  GTest::gtest_main
+  Folly::folly
+)
+
+add_test(NAME velox_mock_rpc_client_test COMMAND velox_mock_rpc_client_test)
+
+add_executable(velox_rpc_state_test RPCStateTest.cpp)
+
+target_link_libraries(
+  velox_rpc_state_test
+  velox_rpc_state
+  velox_rpc_types
+  GTest::gtest
+  GTest::gtest_main
+  Folly::folly
+)
+
+add_test(NAME velox_rpc_state_test COMMAND velox_rpc_state_test)
+
+add_executable(velox_rpc_node_test RPCNodeTest.cpp)
+
+target_link_libraries(
+  velox_rpc_node_test
+  velox_mock_rpc_client
+  velox_core
+  velox_memory
+  velox_vector
+  GTest::gtest
+  GTest::gtest_main
+  Folly::folly
+)
+
+add_test(NAME velox_rpc_node_test COMMAND velox_rpc_node_test)
+
+add_executable(velox_demo_rpc_function_test DemoRPCFunctionTest.cpp)
+velox_add_test_headers(velox_demo_rpc_function_test DemoRPCFunction.h)
+
+target_link_libraries(
+  velox_demo_rpc_function_test
+  velox_demo_rpc_function
+  velox_core
+  velox_memory
+  velox_vector
+  GTest::gtest
+  GTest::gtest_main
+  Folly::folly
+)
+
+add_test(NAME velox_demo_rpc_function_test COMMAND velox_demo_rpc_function_test)
+
+add_executable(velox_rpc_rate_limiter_test RPCRateLimiterTest.cpp)
+
+target_link_libraries(
+  velox_rpc_rate_limiter_test
+  velox_rpc_rate_limiter
+  GTest::gtest
+  GTest::gtest_main
+  Folly::folly
+)
+
+add_test(NAME velox_rpc_rate_limiter_test COMMAND velox_rpc_rate_limiter_test)
+
+add_executable(velox_rpc_operator_test RPCOperatorTest.cpp Main.cpp)
+
+target_link_libraries(
+  velox_rpc_operator_test
+  velox_demo_rpc_function
+  velox_rpc_plan_node_translator
+  velox_async_rpc_function_registry
+  velox_exec_test_lib
+  GTest::gtest
+  Folly::folly
+)
+
+add_test(NAME velox_rpc_operator_test COMMAND velox_rpc_operator_test)
diff --git a/velox/exec/rpc/tests/DemoRPCFunction.cpp b/velox/exec/rpc/tests/DemoRPCFunction.cpp
new file mode 100644
index 00000000000..150880cecda
--- /dev/null
+++ b/velox/exec/rpc/tests/DemoRPCFunction.cpp
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/rpc/tests/DemoRPCFunction.h"
+
+namespace facebook::velox::exec::rpc {
+
+void DemoAsyncRPCFunction::initialize(
+    const core::QueryConfig& /*queryConfig*/,
+    const std::vector<TypePtr>& /*inputTypes*/,
+    const std::vector<VectorPtr>& /*constantInputs*/) {
+  // Create and cache the mock client during initialization.
+  client_ = std::make_shared<MockRPCClient>(
+      std::chrono::milliseconds(1), // minimal latency
+      0.0); // no errors
+}
+
+std::vector<std::pair<vector_size_t, folly::SemiFuture<RPCResponse>>>
+DemoAsyncRPCFunction::dispatchPerRow(
+    const SelectivityVector& rows,
+    const std::vector<VectorPtr>& args) {
+  std::vector<std::pair<vector_size_t, folly::SemiFuture<RPCResponse>>> results;
+
+  if (args.empty()) {
+    return results;
+  }
+
+  auto* promptVector = args[0]->as<SimpleVector<StringView>>();
+  if (!promptVector) {
+    return results;
+  }
+
+  rows.applyToSelected([&](vector_size_t row) {
+    if (promptVector->isNullAt(row)) {
+      // Null input → immediate error response.
+      results.emplace_back(
+          row,
+          folly::makeSemiFuture<RPCResponse>(RPCResponse{
+              .rowId = 0,
+              .result = "",
+              .metadata = {},
+              .error = "null_input"}));
+      return;
+    }
+
+    // Build RPCRequest for MockRPCClient (test utility still uses payload).
+    RPCRequest request;
+    request.payload = promptVector->valueAt(row).str();
+
+    results.emplace_back(row, client_->call(request));
+  });
+
+  return results;
+}
+
+std::vector<std::shared_ptr<exec::FunctionSignature>>
+DemoAsyncRPCFunction::signatures() {
+  // 1-argument form: demo_rpc(prompt)
+  auto sig = exec::FunctionSignatureBuilder()
+                 .returnType("varchar")
+                 .argumentType("varchar") // prompt
+                 .build();
+
+  return {std::move(sig)};
+}
+
+} // namespace facebook::velox::exec::rpc
diff --git a/velox/exec/rpc/tests/DemoRPCFunction.h b/velox/exec/rpc/tests/DemoRPCFunction.h
new file mode 100644
index 00000000000..73126ed8f35
--- /dev/null
+++ b/velox/exec/rpc/tests/DemoRPCFunction.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <memory>
+
+#include "velox/common/rpc/clients/MockRPCClient.h"
+#include "velox/expression/FunctionSignature.h"
+#include "velox/expression/rpc/AsyncRPCFunction.h"
+
+namespace facebook::velox::exec::rpc {
+
+using velox::rpc::MockRPCClient;
+
+/// Demo AsyncRPCFunction that uses MockRPCClient for end-to-end testing.
+///
+/// Demonstrates the full AsyncRPCFunction lifecycle:
+///   1. initialize() — creates and caches the MockRPCClient
+///   2. dispatchPerRow() — dispatches per-row RPCs via MockRPCClient
+///   3. buildOutput() — uses base class default (error→null, result→varchar)
+///
+/// Returns "Response for: <prompt>" for each input row. No external
+/// dependencies — runs entirely in-process with simulated latency.
+///
+/// SQL usage:
+///   SELECT demo_rpc('hello world')
+///   -- Returns: "Response for: hello world"
+class DemoAsyncRPCFunction : public AsyncRPCFunction {
+ public:
+  /// Initialize the mock client. Called by RPCOperator during init.
+  void initialize(
+      const core::QueryConfig& queryConfig,
+      const std::vector<TypePtr>& inputTypes,
+      const std::vector<VectorPtr>& constantInputs) override;
+
+  std::string name() const override {
+    return "demo_rpc";
+  }
+
+  TypePtr resultType() const override {
+    return VARCHAR();
+  }
+
+  /// Dispatch individual RPCs for each active row via MockRPCClient.
+  /// Null-input rows get an immediate RPCResponse with error="null_input".
+  std::vector<std::pair<vector_size_t, folly::SemiFuture<RPCResponse>>>
+  dispatchPerRow(
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args) override;
+
+  /// SQL function signatures for registration.
+  static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures();
+
+ private:
+  std::shared_ptr<MockRPCClient> client_;
+};
+
+} // namespace facebook::velox::exec::rpc
diff --git a/velox/exec/rpc/tests/DemoRPCFunctionRegistration.cpp b/velox/exec/rpc/tests/DemoRPCFunctionRegistration.cpp
new file mode 100644
index 00000000000..e41ee48483d
--- /dev/null
+++ b/velox/exec/rpc/tests/DemoRPCFunctionRegistration.cpp
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/// Static registration of DemoAsyncRPCFunction with the
+/// AsyncRPCFunctionRegistry.
+
+#include "velox/exec/rpc/tests/DemoRPCFunction.h"
+#include "velox/expression/rpc/AsyncRPCFunctionRegistry.h"
+
+using namespace facebook::velox::exec::rpc;
+
+VELOX_REGISTER_RPC_FUNCTION(demo_rpc, DemoAsyncRPCFunction);
diff --git a/velox/exec/rpc/tests/DemoRPCFunctionTest.cpp b/velox/exec/rpc/tests/DemoRPCFunctionTest.cpp
new file mode 100644
index 00000000000..c2b24871a47
--- /dev/null
+++ b/velox/exec/rpc/tests/DemoRPCFunctionTest.cpp
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/// DemoRPCFunctionTest - End-to-end test for the reference AsyncRPCFunction
+/// implementation.
+///
+/// Exercises the full lifecycle: initialize -> dispatchPerRow -> buildOutput,
+/// verifying that DemoAsyncRPCFunction correctly follows the AsyncRPCFunction
+/// contract.
+
+#include "velox/exec/rpc/tests/DemoRPCFunction.h"
+
+#include <gtest/gtest.h>
+
+#include "velox/common/memory/Memory.h"
+#include "velox/core/QueryConfig.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::exec::rpc {
+namespace {
+
+class DemoRPCFunctionTest : public testing::Test {
+ protected:
+  static void SetUpTestSuite() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  void SetUp() override {
+    function_ = std::make_shared<DemoAsyncRPCFunction>();
+    pool_ = memory::memoryManager()->addLeafPool();
+
+    // Follow the lifecycle: initialize() before any dispatch.
+    function_->initialize(core::QueryConfig{{}}, {}, {});
+  }
+
+  std::shared_ptr<DemoAsyncRPCFunction> function_;
+  std::shared_ptr<memory::MemoryPool> pool_;
+};
+
+TEST_F(DemoRPCFunctionTest, endToEnd) {
+  // Build input vector.
+  std::vector<std::string> prompts = {"hello world", "test prompt"};
+  const auto numRows = static_cast<vector_size_t>(prompts.size());
+  auto input = BaseVector::create<FlatVector<StringView>>(
+      VARCHAR(), numRows, pool_.get());
+  for (vector_size_t i = 0; i < numRows; ++i) {
+    input->set(i, StringView(prompts[i]));
+  }
+
+  // Dispatch per-row and collect futures.
+  SelectivityVector rows(numRows);
+  auto futures = function_->dispatchPerRow(rows, {input});
+  ASSERT_EQ(futures.size(), 2);
+  EXPECT_EQ(futures[0].first, 0);
+  EXPECT_EQ(futures[1].first, 1);
+
+  // Resolve futures.
+  std::vector<RPCResponse> responses;
+  responses.reserve(futures.size());
+  for (auto& [rowIdx, future] : futures) {
+    responses.push_back(std::move(future).get());
+  }
+  ASSERT_EQ(responses.size(), 2);
+  for (const auto& resp : responses) {
+    EXPECT_FALSE(resp.hasError());
+  }
+
+  // Build output vector.
+  auto result = function_->buildOutput(responses, pool_.get());
+  ASSERT_EQ(result->size(), 2);
+  auto* flat = result->asFlatVector<StringView>();
+  EXPECT_FALSE(flat->isNullAt(0));
+  EXPECT_FALSE(flat->isNullAt(1));
+  // MockRPCClient returns "Response for: <payload>".
+  EXPECT_EQ(flat->valueAt(0).str(), "Response for: hello world");
+  EXPECT_EQ(flat->valueAt(1).str(), "Response for: test prompt");
+}
+
+TEST_F(DemoRPCFunctionTest, nullInput) {
+  // Build input with a null row.
+  auto input =
+      BaseVector::create<FlatVector<StringView>>(VARCHAR(), 2, pool_.get());
+  input->set(0, StringView("valid prompt"));
+  input->setNull(1, true);
+
+  SelectivityVector rows(2);
+  auto futures = function_->dispatchPerRow(rows, {input});
+
+  // Both rows produce futures (null row gets immediate error response).
+  ASSERT_EQ(futures.size(), 2);
+  EXPECT_EQ(futures[0].first, 0);
+  EXPECT_EQ(futures[1].first, 1);
+
+  // Non-null row should succeed.
+  auto resp0 = std::move(futures[0].second).get();
+  EXPECT_FALSE(resp0.hasError());
+
+  // Null row should get error="null_input".
+  auto resp1 = std::move(futures[1].second).get();
+  EXPECT_TRUE(resp1.hasError());
+  EXPECT_EQ(resp1.error.value(), "null_input");
+}
+
+TEST_F(DemoRPCFunctionTest, errorResponse) {
+  // Build output from a response with an error.
+  std::vector<RPCResponse> responses;
+  RPCResponse ok;
+  ok.rowId = 0;
+  ok.result = "good result";
+  responses.push_back(std::move(ok));
+
+  RPCResponse err;
+  err.rowId = 1;
+  err.error = "RPC failed";
+  responses.push_back(std::move(err));
+
+  auto result = function_->buildOutput(responses, pool_.get());
+  ASSERT_EQ(result->size(), 2);
+  auto* flat = result->asFlatVector<StringView>();
+  EXPECT_FALSE(flat->isNullAt(0));
+  EXPECT_EQ(flat->valueAt(0).str(), "good result");
+  EXPECT_TRUE(flat->isNullAt(1));
+}
+
+TEST_F(DemoRPCFunctionTest, signatures) {
+  auto sigs = DemoAsyncRPCFunction::signatures();
+  ASSERT_EQ(sigs.size(), 1);
+  // demo_rpc(varchar) -> varchar
+  EXPECT_EQ(sigs[0]->argumentTypes().size(), 1);
+}
+
+TEST_F(DemoRPCFunctionTest, metadata) {
+  EXPECT_EQ(function_->name(), "demo_rpc");
+  EXPECT_EQ(function_->resultType()->kind(), TypeKind::VARCHAR);
+  EXPECT_EQ(function_->tierKey(), "");
+}
+
+} // namespace
+} // namespace facebook::velox::exec::rpc
diff --git a/velox/exec/rpc/tests/Main.cpp b/velox/exec/rpc/tests/Main.cpp
new file mode 100644
index 00000000000..39c009ebdd7
--- /dev/null
+++ b/velox/exec/rpc/tests/Main.cpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/memory/Memory.h"
+#include "velox/common/process/ThreadDebugInfo.h"
+
+#include <folly/Unit.h>
+#include <folly/init/Init.h>
+#include <gtest/gtest.h>
+
+// This main is needed for some tests on linux.
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  // Signal handler required for ThreadDebugInfoTest
+  facebook::velox::process::addDefaultFatalSignalHandler();
+  folly::Init init(&argc, &argv, false);
+  facebook::velox::memory::MemoryManager::initialize({});
+  return RUN_ALL_TESTS();
+}
diff --git a/velox/exec/rpc/tests/MockRPCClientTest.cpp b/velox/exec/rpc/tests/MockRPCClientTest.cpp
new file mode 100644
index 00000000000..84f679562a6
--- /dev/null
+++ b/velox/exec/rpc/tests/MockRPCClientTest.cpp
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/// MockRPCClientTest - Tests the mock RPC backend.
+///
+/// TESTS:
+/// - basicCallAndError: Single call succeeds; error preserves rowId
+/// - batchCallAndError: Batch call returns correct count; errors preserve
+/// rowIds
+
+#include "velox/common/rpc/clients/MockRPCClient.h"
+
+#include <folly/futures/Future.h>
+#include <gtest/gtest.h>
+
+namespace facebook::velox::rpc {
+namespace {
+
+class MockRPCClientTest : public testing::Test {};
+
+TEST_F(MockRPCClientTest, basicCallAndError) {
+  // Success path
+  MockRPCClient client(std::chrono::milliseconds(1), 0.0);
+
+  RPCRequest request;
+  request.rowId = 42;
+  request.payload = "What is the capital of France?";
+  request.options[std::string(rpc::keys::kModel)] = "test-model";
+
+  auto response = client.call(request).get();
+
+  EXPECT_FALSE(response.hasError());
+  EXPECT_FALSE(response.result.empty());
+  EXPECT_EQ(response.rowId, 42);
+  EXPECT_EQ(client.callCount(), 1);
+
+  // Error path: rowId must be preserved
+  MockRPCClient errorClient(std::chrono::milliseconds(1), 1.0);
+
+  RPCRequest errorRequest;
+  errorRequest.rowId = 12345;
+  errorRequest.payload = "Test";
+
+  auto errorResponse = errorClient.call(errorRequest).get();
+
+  EXPECT_TRUE(errorResponse.hasError());
+  EXPECT_EQ(errorResponse.rowId, 12345);
+}
+
+TEST_F(MockRPCClientTest, batchCallAndError) {
+  // Success path
+  MockRPCClient client(std::chrono::milliseconds(1), 0.0);
+
+  std::vector<RPCRequest> requests;
+  for (int i = 0; i < 5; i++) {
+    RPCRequest req;
+    req.rowId = i;
+    req.payload = "Prompt " + std::to_string(i);
+    requests.push_back(std::move(req));
+  }
+
+  auto responses = client.callBatch(requests).get();
+
+  EXPECT_EQ(responses.size(), 5);
+  for (int i = 0; i < 5; i++) {
+    EXPECT_FALSE(responses[i].hasError());
+    EXPECT_EQ(responses[i].rowId, i);
+  }
+  EXPECT_EQ(client.callCount(), 5);
+
+  // Error path: rowIds must be preserved
+  MockRPCClient errorClient(std::chrono::milliseconds(1), 1.0);
+
+  std::vector<RPCRequest> errorRequests;
+  for (int i = 0; i < 5; i++) {
+    RPCRequest req;
+    req.rowId = 100 + i;
+    req.payload = "Test " + std::to_string(i);
+    errorRequests.push_back(std::move(req));
+  }
+
+  auto errorResponses = errorClient.callBatch(errorRequests).get();
+
+  EXPECT_EQ(errorResponses.size(), 5);
+  for (int i = 0; i < 5; i++) {
+    EXPECT_TRUE(errorResponses[i].hasError());
+    EXPECT_EQ(errorResponses[i].rowId, 100 + i);
+  }
+}
+
+} // namespace
+} // namespace facebook::velox::rpc
diff --git a/velox/exec/rpc/tests/RPCNodeTest.cpp b/velox/exec/rpc/tests/RPCNodeTest.cpp
new file mode 100644
index 00000000000..9a31deac9e4
--- /dev/null
+++ b/velox/exec/rpc/tests/RPCNodeTest.cpp
@@ -0,0 +1,243 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/// RPCNodeTest - Tests plan node creation and AsyncRPCFunction behavior.
+///
+/// TESTS:
+/// - rpcNodeCreation: RPCNode can be created with correct fields
+/// - rpcNodeWithBatchMode: Batch mode configuration works
+/// - functionDispatchPerRow: AsyncRPCFunction.dispatchPerRow() works
+/// - functionBuildOutput: AsyncRPCFunction.buildOutput() works
+/// - planNodeToString: toString() includes configuration info
+/// - planNodeSingleSource: Plan node has exactly one source
+
+#include "velox/core/PlanNode.h"
+
+#include <gtest/gtest.h>
+
+#include "velox/common/memory/Memory.h"
+#include "velox/common/rpc/clients/MockRPCClient.h"
+#include "velox/expression/rpc/AsyncRPCFunction.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::exec::rpc {
+
+using velox::rpc::MockRPCClient;
+
+namespace {
+
+/// Mock implementation of AsyncRPCFunction for testing.
+class MockAsyncRPCFunction : public AsyncRPCFunction {
+ public:
+  explicit MockAsyncRPCFunction(std::shared_ptr<MockRPCClient> client)
+      : client_(std::move(client)) {}
+
+  std::string name() const override {
+    return "mock_rpc_function";
+  }
+
+  TypePtr resultType() const override {
+    return VARCHAR();
+  }
+
+  std::vector<std::pair<vector_size_t, folly::SemiFuture<RPCResponse>>>
+  dispatchPerRow(
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args) override {
+    std::vector<std::pair<vector_size_t, folly::SemiFuture<RPCResponse>>>
+        results;
+
+    if (args.empty()) {
+      return results;
+    }
+
+    auto* promptVector = args[0]->as<SimpleVector<StringView>>();
+    if (!promptVector) {
+      return results;
+    }
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (promptVector->isNullAt(row)) {
+        results.emplace_back(
+            row,
+            folly::makeSemiFuture<RPCResponse>(RPCResponse{
+                .rowId = static_cast<int64_t>(row),
+                .result = "",
+                .metadata = {},
+                .error = "null_input"}));
+        return;
+      }
+      RPCRequest request;
+      request.payload = promptVector->valueAt(row).str();
+      results.emplace_back(row, client_->call(request));
+    });
+
+    return results;
+  }
+
+ private:
+  std::shared_ptr<MockRPCClient> client_;
+};
+
+class RPCNodeTest : public testing::Test {
+ protected:
+  static void SetUpTestSuite() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  void SetUp() override {
+    client_ =
+        std::make_shared<MockRPCClient>(std::chrono::milliseconds(10), 0.0);
+    function_ = std::make_shared<MockAsyncRPCFunction>(client_);
+    pool_ = memory::memoryManager()->addLeafPool();
+  }
+
+  std::shared_ptr<MockRPCClient> client_;
+  std::shared_ptr<MockAsyncRPCFunction> function_;
+  std::shared_ptr<memory::MemoryPool> pool_;
+};
+
+TEST_F(RPCNodeTest, rpcNodeCreation) {
+  auto rpcNode = std::make_shared<core::RPCNode>(
+      "rpc-1",
+      nullptr,
+      "mock_rpc_function",
+      VARCHAR(),
+      "response",
+      ROW({"response"}, {VARCHAR()}),
+      std::vector<std::string>{},
+      std::vector<TypePtr>{},
+      std::vector<VectorPtr>{});
+
+  EXPECT_EQ(rpcNode->id(), "rpc-1");
+  EXPECT_EQ(rpcNode->name(), "RPC");
+  EXPECT_EQ(rpcNode->functionName(), "mock_rpc_function");
+  EXPECT_EQ(rpcNode->outputColumn(), "response");
+  EXPECT_EQ(rpcNode->streamingMode(), rpc::RPCStreamingMode::kPerRow);
+  EXPECT_EQ(rpcNode->dispatchBatchSize(), 0);
+}
+
+TEST_F(RPCNodeTest, rpcNodeWithBatchMode) {
+  auto rpcNode = std::make_shared<core::RPCNode>(
+      "rpc-2",
+      nullptr,
+      "mock_rpc_function",
+      VARCHAR(),
+      "result",
+      ROW({"result"}, {VARCHAR()}),
+      std::vector<std::string>{},
+      std::vector<TypePtr>{},
+      std::vector<VectorPtr>{},
+      rpc::RPCStreamingMode::kBatch,
+      100);
+
+  EXPECT_EQ(rpcNode->streamingMode(), rpc::RPCStreamingMode::kBatch);
+  EXPECT_EQ(rpcNode->dispatchBatchSize(), 100);
+}
+
+TEST_F(RPCNodeTest, functionDispatchPerRow) {
+  std::vector<std::string> prompts = {
+      "What is 2+2?",
+      "What is the capital of France?",
+      "Explain quantum computing."};
+
+  const auto numPrompts = static_cast<vector_size_t>(prompts.size());
+  auto promptVector = BaseVector::create<FlatVector<StringView>>(
+      VARCHAR(), numPrompts, pool_.get());
+  for (vector_size_t i = 0; i < numPrompts; ++i) {
+    promptVector->set(i, StringView(prompts[i]));
+  }
+
+  std::vector<VectorPtr> args = {promptVector};
+  SelectivityVector rows(numPrompts);
+
+  auto futures = function_->dispatchPerRow(rows, args);
+
+  // Extract row indices and verify ordering.
+  std::vector<vector_size_t> rowIndices;
+  rowIndices.reserve(futures.size());
+  for (const auto& [idx, _] : futures) {
+    rowIndices.push_back(idx);
+  }
+  ASSERT_EQ(rowIndices.size(), 3);
+  EXPECT_EQ(rowIndices[0], 0);
+  EXPECT_EQ(rowIndices[1], 1);
+  EXPECT_EQ(rowIndices[2], 2);
+
+  // Resolve futures and verify responses.
+  for (auto& [rowIdx, future] : futures) {
+    auto response = std::move(future).get();
+    EXPECT_FALSE(response.hasError());
+    EXPECT_FALSE(response.result.empty());
+  }
+}
+
+TEST_F(RPCNodeTest, functionBuildOutput) {
+  std::vector<RPCResponse> responses;
+  for (int i = 0; i < 3; ++i) {
+    RPCResponse resp;
+    resp.rowId = i;
+    resp.result = "Response for prompt " + std::to_string(i);
+    responses.push_back(std::move(resp));
+  }
+
+  auto result = function_->buildOutput(responses, pool_.get());
+
+  EXPECT_EQ(result->size(), 3);
+  EXPECT_EQ(result->type()->kind(), TypeKind::VARCHAR);
+
+  auto* flatResult = result->asFlatVector<StringView>();
+  EXPECT_EQ(flatResult->valueAt(0).str(), "Response for prompt 0");
+  EXPECT_EQ(flatResult->valueAt(1).str(), "Response for prompt 1");
+  EXPECT_EQ(flatResult->valueAt(2).str(), "Response for prompt 2");
+}
+
+TEST_F(RPCNodeTest, planNodeToString) {
+  auto rpcNode = std::make_shared<core::RPCNode>(
+      "rpc-1",
+      nullptr,
+      "mock_rpc_function",
+      VARCHAR(),
+      "response",
+      ROW({"response"}, {VARCHAR()}),
+      std::vector<std::string>{},
+      std::vector<TypePtr>{},
+      std::vector<VectorPtr>{});
+
+  std::string str = rpcNode->toString(/*detailed=*/true);
+
+  EXPECT_TRUE(str.find("RPC") != std::string::npos);
+  EXPECT_TRUE(str.find("mock_rpc_function") != std::string::npos);
+}
+
+TEST_F(RPCNodeTest, planNodeSingleSource) {
+  auto rpcNode = std::make_shared<core::RPCNode>(
+      "rpc-1",
+      nullptr,
+      "mock_rpc_function",
+      VARCHAR(),
+      "response",
+      ROW({"response"}, {VARCHAR()}),
+      std::vector<std::string>{},
+      std::vector<TypePtr>{},
+      std::vector<VectorPtr>{});
+
+  ASSERT_EQ(rpcNode->sources().size(), 1);
+  EXPECT_EQ(rpcNode->source().get(), nullptr);
+}
+
+} // namespace
+} // namespace facebook::velox::exec::rpc
diff --git a/velox/exec/rpc/tests/RPCOperatorTest.cpp b/velox/exec/rpc/tests/RPCOperatorTest.cpp
new file mode 100644
index 00000000000..bf546608a32
--- /dev/null
+++ b/velox/exec/rpc/tests/RPCOperatorTest.cpp
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/// RPCOperatorTest - End-to-end task-level test for RPCOperator.
+///
+/// Runs a full Velox Task/Driver pipeline: Values → RPCNode → output.
+/// Verifies that RPCPlanNodeTranslator, RPCOperator, RPCState, and
+/// AsyncRPCFunction wire together correctly through the execution engine.
+
+#include <gtest/gtest.h>
+
+#include "velox/exec/rpc/RPCPlanNodeTranslator.h"
+#include "velox/exec/rpc/RPCRateLimiter.h"
+#include "velox/exec/rpc/tests/DemoRPCFunction.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/expression/rpc/AsyncRPCFunctionRegistry.h"
+
+namespace facebook::velox::exec::rpc {
+
+using namespace facebook::velox::exec::test;
+
+class RPCOperatorTest : public OperatorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    OperatorTestBase::SetUpTestCase();
+    registerRPCPlanNodeTranslator();
+    AsyncRPCFunctionRegistry::registerFunction(
+        "demo_rpc", []() { return std::make_shared<DemoAsyncRPCFunction>(); });
+  }
+
+  static void TearDownTestCase() {
+    OperatorTestBase::TearDownTestCase();
+    // Reset MemoryManager to shut down SharedArbitrator executor threads.
+    // Without this, TSAN reports a non-zero exit because the executor
+    // threads are still running at process exit.
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  void TearDown() override {
+    RPCRateLimiter::testingResetAllState();
+    OperatorTestBase::TearDown();
+  }
+
+  /// Build an RPCNode on top of a source plan node.
+  /// argumentColumnNames specifies which source columns are RPC arguments.
+  core::PlanNodePtr makeRPCNode(
+      const core::PlanNodePtr& source,
+      const std::vector<std::string>& argumentColumnNames) {
+    auto sourceType = source->outputType();
+
+    std::vector<std::string> argCols;
+    std::vector<TypePtr> argTypes;
+    std::vector<VectorPtr> constantInputs;
+    for (const auto& colName : argumentColumnNames) {
+      argCols.push_back(colName);
+      argTypes.push_back(sourceType->findChild(colName));
+      constantInputs.push_back(nullptr); // Variable, not constant.
+    }
+
+    // Output type = all source columns + RPC result column.
+    auto outputNames = sourceType->names();
+    auto outputTypes = sourceType->children();
+    outputNames.emplace_back("__rpc_result");
+    outputTypes.push_back(VARCHAR());
+    auto outputType = ROW(std::move(outputNames), std::move(outputTypes));
+
+    return std::make_shared<core::RPCNode>(
+        "rpc-0",
+        source,
+        "demo_rpc",
+        VARCHAR(),
+        "__rpc_result",
+        outputType,
+        argCols,
+        argTypes,
+        constantInputs);
+  }
+};
+
+/// Runs Values(3 rows) → RPCNode → verifies passthrough + RPC result.
+TEST_F(RPCOperatorTest, basicPerRow) {
+  auto input = makeRowVector(
+      {"prompt"},
+      {makeFlatVector<StringView>(
+          {"hello world", "test prompt", "third row"})});
+
+  auto plan = makeRPCNode(PlanBuilder().values({input}).planNode(), {"prompt"});
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+
+  ASSERT_EQ(result->size(), 3);
+  ASSERT_EQ(result->type()->size(), 2); // prompt + __rpc_result
+
+  // Rows may arrive out of order (async dispatch). Collect and sort to verify.
+  auto* prompts = result->childAt(0)->asFlatVector<StringView>();
+  auto* results = result->childAt(1)->asFlatVector<StringView>();
+
+  std::map<std::string, std::string> rows;
+  for (vector_size_t i = 0; i < result->size(); ++i) {
+    rows[prompts->valueAt(i).str()] = results->valueAt(i).str();
+  }
+
+  EXPECT_EQ(rows["hello world"], "Response for: hello world");
+  EXPECT_EQ(rows["test prompt"], "Response for: test prompt");
+  EXPECT_EQ(rows["third row"], "Response for: third row");
+}
+
+/// Null input rows should produce null in the RPC result column.
+TEST_F(RPCOperatorTest, nullInput) {
+  auto promptVector =
+      makeNullableFlatVector<StringView>({"valid prompt", std::nullopt});
+  auto input = makeRowVector({"prompt"}, {promptVector});
+
+  auto plan = makeRPCNode(PlanBuilder().values({input}).planNode(), {"prompt"});
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+
+  ASSERT_EQ(result->size(), 2);
+
+  auto* prompts = result->childAt(0)->asFlatVector<StringView>();
+  auto* results = result->childAt(1)->asFlatVector<StringView>();
+
+  // Find which row is the valid one vs the null one.
+  for (vector_size_t i = 0; i < result->size(); ++i) {
+    if (prompts->isNullAt(i)) {
+      // Null input row should produce null result.
+      EXPECT_TRUE(results->isNullAt(i));
+    } else {
+      EXPECT_EQ(prompts->valueAt(i).str(), "valid prompt");
+      EXPECT_FALSE(results->isNullAt(i));
+      EXPECT_EQ(results->valueAt(i).str(), "Response for: valid prompt");
+    }
+  }
+}
+
+/// Multiple source columns — verifies all passthrough columns are preserved.
+TEST_F(RPCOperatorTest, multipleColumns) {
+  auto input = makeRowVector(
+      {"id", "prompt", "extra"},
+      {makeFlatVector<int64_t>({100, 200}),
+       makeFlatVector<StringView>({"question one", "question two"}),
+       makeFlatVector<double>({1.5, 2.5})});
+
+  // Only "prompt" is an RPC argument; "id" and "extra" are passthrough.
+  auto plan = makeRPCNode(PlanBuilder().values({input}).planNode(), {"prompt"});
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+
+  ASSERT_EQ(result->size(), 2);
+  ASSERT_EQ(result->type()->size(), 4); // id, prompt, extra, __rpc_result
+
+  // Rows may arrive out of order. Index by prompt to verify.
+  auto* prompts = result->childAt(1)->asFlatVector<StringView>();
+  auto* ids = result->childAt(0)->asFlatVector<int64_t>();
+  auto* extras = result->childAt(2)->asFlatVector<double>();
+  auto* results = result->childAt(3)->asFlatVector<StringView>();
+
+  std::map<std::string, vector_size_t> rowIndex;
+  for (vector_size_t i = 0; i < result->size(); ++i) {
+    rowIndex[prompts->valueAt(i).str()] = i;
+  }
+
+  auto i1 = rowIndex["question one"];
+  EXPECT_EQ(ids->valueAt(i1), 100);
+  EXPECT_EQ(extras->valueAt(i1), 1.5);
+  EXPECT_EQ(results->valueAt(i1).str(), "Response for: question one");
+
+  auto i2 = rowIndex["question two"];
+  EXPECT_EQ(ids->valueAt(i2), 200);
+  EXPECT_EQ(extras->valueAt(i2), 2.5);
+  EXPECT_EQ(results->valueAt(i2).str(), "Response for: question two");
+}
+
+} // namespace facebook::velox::exec::rpc
diff --git a/velox/exec/rpc/tests/RPCRateLimiterTest.cpp b/velox/exec/rpc/tests/RPCRateLimiterTest.cpp
new file mode 100644
index 00000000000..127a0893159
--- /dev/null
+++ b/velox/exec/rpc/tests/RPCRateLimiterTest.cpp
@@ -0,0 +1,228 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/// RPCRateLimiterTest - Tests for the per-tier RPC rate limiter.
+///
+/// RPCRateLimiter provides per-tier concurrency limits with FIFO waiter
+/// notification and RAII token-based slot management.
+///
+/// Tests cover:
+/// - acquireAndRelease: Token acquire increments, destruction decrements.
+/// - backpressureWhenAtLimit: checkBackpressure returns future at limit.
+/// - backpressureReliefOnRelease: Waiter notified when token released.
+/// - fifoWaiterNotification: Multiple waiters notified in FIFO order.
+/// - perTierIsolation: Different tiers have independent limits.
+/// - perTierMaxPending: setMaxPending overrides global default.
+/// - defaultMaxPending: setDefaultMaxPending affects tiers without override.
+/// - tokenMoveSemantics: Move constructor/assignment transfer ownership.
+/// - testingResetAllState: Reset clears all tiers and restores defaults.
+
+#include "velox/exec/rpc/RPCRateLimiter.h"
+
+#include <gtest/gtest.h>
+
+#include <vector>
+
+namespace facebook::velox::exec::rpc {
+namespace {
+
+class RPCRateLimiterTest : public testing::Test {
+ protected:
+  void SetUp() override {
+    RPCRateLimiter::testingResetAllState();
+  }
+
+  void TearDown() override {
+    RPCRateLimiter::testingResetAllState();
+  }
+};
+
+TEST_F(RPCRateLimiterTest, acquireAndRelease) {
+  const std::string tier = "test.tier";
+  EXPECT_EQ(RPCRateLimiter::pendingCount(tier), 0);
+
+  {
+    auto token = RPCRateLimiter::acquire(tier);
+    EXPECT_EQ(RPCRateLimiter::pendingCount(tier), 1);
+  }
+  // Token destroyed — count should be back to 0.
+  EXPECT_EQ(RPCRateLimiter::pendingCount(tier), 0);
+}
+
+TEST_F(RPCRateLimiterTest, multipleAcquires) {
+  const std::string tier = "test.tier";
+
+  auto token1 = RPCRateLimiter::acquire(tier);
+  auto token2 = RPCRateLimiter::acquire(tier);
+  auto token3 = RPCRateLimiter::acquire(tier);
+  EXPECT_EQ(RPCRateLimiter::pendingCount(tier), 3);
+}
+
+TEST_F(RPCRateLimiterTest, backpressureWhenAtLimit) {
+  const std::string tier = "test.tier";
+  RPCRateLimiter::setMaxPending(tier, 2);
+
+  auto token1 = RPCRateLimiter::acquire(tier);
+  // 1 pending, limit 2 — no backpressure.
+  EXPECT_FALSE(RPCRateLimiter::checkBackpressure(tier).has_value());
+
+  auto token2 = RPCRateLimiter::acquire(tier);
+  // 2 pending, limit 2 — at limit, should get backpressure.
+  auto future = RPCRateLimiter::checkBackpressure(tier);
+  EXPECT_TRUE(future.has_value());
+}
+
+TEST_F(RPCRateLimiterTest, backpressureReliefOnRelease) {
+  const std::string tier = "test.tier";
+  RPCRateLimiter::setMaxPending(tier, 1);
+
+  auto token1 = RPCRateLimiter::acquire(tier);
+
+  // At limit — should block.
+  auto future = RPCRateLimiter::checkBackpressure(tier);
+  ASSERT_TRUE(future.has_value());
+  EXPECT_FALSE(future->isReady());
+
+  // Release the token — waiter should be notified.
+  token1 = RPCRateLimiter::Token();
+  EXPECT_TRUE(future->isReady());
+  EXPECT_EQ(RPCRateLimiter::pendingCount(tier), 0);
+}
+
+TEST_F(RPCRateLimiterTest, fifoWaiterNotification) {
+  const std::string tier = "test.tier";
+  RPCRateLimiter::setMaxPending(tier, 1);
+
+  auto token = RPCRateLimiter::acquire(tier);
+
+  // Two waiters enqueue while at limit.
+  auto future1 = RPCRateLimiter::checkBackpressure(tier);
+  auto future2 = RPCRateLimiter::checkBackpressure(tier);
+  ASSERT_TRUE(future1.has_value());
+  ASSERT_TRUE(future2.has_value());
+
+  // Release token — only first waiter should be notified (FIFO).
+  token = RPCRateLimiter::Token();
+  EXPECT_TRUE(future1->isReady());
+  EXPECT_FALSE(future2->isReady());
+
+  // Acquire and release again — second waiter should be notified.
+  {
+    auto token2 = RPCRateLimiter::acquire(tier);
+  }
+  EXPECT_TRUE(future2->isReady());
+}
+
+TEST_F(RPCRateLimiterTest, perTierIsolation) {
+  const std::string tier1 = "tier.one";
+  const std::string tier2 = "tier.two";
+  RPCRateLimiter::setMaxPending(tier1, 1);
+  RPCRateLimiter::setMaxPending(tier2, 1);
+
+  auto tokenA = RPCRateLimiter::acquire(tier1);
+  EXPECT_EQ(RPCRateLimiter::pendingCount(tier1), 1);
+  EXPECT_EQ(RPCRateLimiter::pendingCount(tier2), 0);
+
+  // tier1 at limit, tier2 not.
+  EXPECT_TRUE(RPCRateLimiter::checkBackpressure(tier1).has_value());
+  EXPECT_FALSE(RPCRateLimiter::checkBackpressure(tier2).has_value());
+}
+
+TEST_F(RPCRateLimiterTest, perTierMaxPending) {
+  const std::string tier = "test.tier";
+  RPCRateLimiter::setDefaultMaxPending(10);
+  RPCRateLimiter::setMaxPending(tier, 2);
+
+  auto token1 = RPCRateLimiter::acquire(tier);
+  auto token2 = RPCRateLimiter::acquire(tier);
+
+  // Per-tier limit of 2 applies, not global default of 10.
+  EXPECT_TRUE(RPCRateLimiter::checkBackpressure(tier).has_value());
+}
+
+TEST_F(RPCRateLimiterTest, defaultMaxPending) {
+  RPCRateLimiter::setDefaultMaxPending(2);
+  const std::string tier = "test.default.tier";
+
+  auto token1 = RPCRateLimiter::acquire(tier);
+  EXPECT_FALSE(RPCRateLimiter::checkBackpressure(tier).has_value());
+
+  auto token2 = RPCRateLimiter::acquire(tier);
+  // Global default of 2 reached.
+  EXPECT_TRUE(RPCRateLimiter::checkBackpressure(tier).has_value());
+}
+
+TEST_F(RPCRateLimiterTest, tokenMoveConstructor) {
+  const std::string tier = "test.tier";
+
+  auto token1 = RPCRateLimiter::acquire(tier);
+  EXPECT_EQ(RPCRateLimiter::pendingCount(tier), 1);
+
+  // Move construct — ownership transfers, count stays 1.
+  auto token2 = std::move(token1);
+  EXPECT_EQ(RPCRateLimiter::pendingCount(tier), 1);
+
+  // Destroy moved-from token — no effect.
+  // (token1 is already moved-from, but let it go out of scope naturally)
+}
+
+TEST_F(RPCRateLimiterTest, tokenMoveAssignment) {
+  const std::string tier1 = "tier.one";
+  const std::string tier2 = "tier.two";
+
+  auto token1 = RPCRateLimiter::acquire(tier1);
+  auto token2 = RPCRateLimiter::acquire(tier2);
+  EXPECT_EQ(RPCRateLimiter::pendingCount(tier1), 1);
+  EXPECT_EQ(RPCRateLimiter::pendingCount(tier2), 1);
+
+  // Move-assign token2 into token1 — old token1 (tier1) released.
+  token1 = std::move(token2);
+  EXPECT_EQ(RPCRateLimiter::pendingCount(tier1), 0);
+  EXPECT_EQ(RPCRateLimiter::pendingCount(tier2), 1);
+}
+
+TEST_F(RPCRateLimiterTest, testingResetAllState) {
+  const std::string tier = "test.tier";
+  RPCRateLimiter::setDefaultMaxPending(5);
+  RPCRateLimiter::setMaxPending(tier, 3);
+  auto token = RPCRateLimiter::acquire(tier);
+
+  // Move the token out so it doesn't decrement during reset.
+  // (In practice, testingResetAllState clears the tiers map,
+  // so the token's destructor will create a new empty tier state.)
+
+  RPCRateLimiter::testingResetAllState();
+
+  // Default restored to 20.
+  EXPECT_EQ(RPCRateLimiter::defaultMaxPending(), 20);
+  // Tier state cleared — pending count is 0 for a fresh tier.
+  EXPECT_EQ(RPCRateLimiter::pendingCount(tier), 0);
+}
+
+TEST_F(RPCRateLimiterTest, noBackpressureBelowLimit) {
+  const std::string tier = "test.tier";
+  RPCRateLimiter::setMaxPending(tier, 5);
+
+  std::vector<RPCRateLimiter::Token> tokens;
+  for (int i = 0; i < 4; ++i) {
+    tokens.push_back(RPCRateLimiter::acquire(tier));
+    EXPECT_FALSE(RPCRateLimiter::checkBackpressure(tier).has_value());
+  }
+  EXPECT_EQ(RPCRateLimiter::pendingCount(tier), 4);
+}
+
+} // namespace
+} // namespace facebook::velox::exec::rpc
diff --git a/velox/exec/rpc/tests/RPCStateTest.cpp b/velox/exec/rpc/tests/RPCStateTest.cpp
new file mode 100644
index 00000000000..4a7aa39c778
--- /dev/null
+++ b/velox/exec/rpc/tests/RPCStateTest.cpp
@@ -0,0 +1,490 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/// RPCStateTest - Tests for the RPCState shared state coordination.
+///
+/// RPCState coordinates between the operator's driver thread and async RPC
+/// completion callbacks using a mutex-protected state object.
+///
+/// Tests cover both PER_ROW and BATCH streaming modes:
+///
+/// PER_ROW tests:
+/// - basicAddAndClaim: Add pending row, fulfill, claim via tryClaimOrWait
+/// - claimOrWaitReturnsFinished: After noMoreInput + all claimed
+/// - claimOrWaitMustWait: When no rows ready, returns kMustWait with future
+/// - pendingRowCount: Tracks pending count correctly
+///
+/// BATCH tests:
+/// - basicAddAndPollBatch: Add pending batch, fulfill, poll
+/// - pollBatchOrWaitFinished: After noMoreInput + all polled
+/// - pollBatchOrWaitMustWait: When no batch ready, returns kMustWait
+/// - batchErrorHandling: Exception in batch future handled gracefully
+/// - batchRowLocationsCarriedThrough: Row locations carried from pending to
+///   ready batch
+///
+/// Common tests:
+/// - noMoreInputAndIsFinished: Lifecycle signals
+/// - inputBatchStorageAndRelease: Batch-reference input storage and release
+/// - backpressure: isUnderBackpressure when pending >= max
+/// - drainReadyRows: Batched drain of multiple ready rows
+
+#include "velox/exec/rpc/RPCState.h"
+
+#include <folly/futures/Promise.h>
+#include <gtest/gtest.h>
+
+#include <chrono>
+#include <functional>
+#include <set>
+#include <thread>
+
+namespace facebook::velox::exec::rpc {
+namespace {
+
+class RPCStateTest : public testing::Test {
+ protected:
+  void SetUp() override {
+    state_ = std::make_shared<RPCState>();
+  }
+
+  /// Polls a condition with short waits until it becomes true or timeout.
+  static void waitFor(
+      const std::function<bool()>& condition,
+      std::chrono::milliseconds timeout = std::chrono::milliseconds(5000)) {
+    auto deadline = std::chrono::steady_clock::now() + timeout;
+    while (!condition()) {
+      ASSERT_LT(std::chrono::steady_clock::now(), deadline)
+          << "Timed out waiting for condition";
+      /* sleep override */
+      std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    }
+  }
+
+  std::shared_ptr<RPCState> state_;
+};
+
+// ========== PER_ROW mode tests ==========
+
+TEST_F(RPCStateTest, basicAddAndClaim) {
+  state_->setStreamingMode(RPCStreamingMode::kPerRow);
+
+  auto [promise, future] = folly::makePromiseContract<RPCResponse>();
+
+  state_->addPendingRow(
+      state_, 42, RPCState::RowLocation{0, 0}, std::move(future));
+  EXPECT_EQ(state_->numPendingRows(), 1);
+
+  // Fulfill the promise
+  RPCResponse response;
+  response.rowId = 42;
+  response.result = "test result";
+  promise.setValue(std::move(response));
+
+  // Wait for async callback to move response into readyRows_
+  waitFor([&]() { return state_->numPendingRows() == 0; });
+
+  // Now claim
+  ContinueFuture waitFuture{ContinueFuture::makeEmpty()};
+  std::optional<RPCState::ReadyRow> claimedRow;
+  auto result = state_->tryClaimOrWait(&waitFuture, &claimedRow);
+
+  ASSERT_EQ(result, RPCState::ClaimResult::kClaimed);
+  ASSERT_TRUE(claimedRow.has_value());
+  EXPECT_EQ(claimedRow->rowId, 42);
+  EXPECT_EQ(claimedRow->response.result, "test result");
+}
+
+TEST_F(RPCStateTest, addAndClaimDirect) {
+  state_->setStreamingMode(RPCStreamingMode::kPerRow);
+
+  auto [promise, future] = folly::makePromiseContract<RPCResponse>();
+
+  state_->addPendingRow(
+      state_, 42, RPCState::RowLocation{0, 0}, std::move(future));
+
+  // Fulfill the promise
+  RPCResponse response;
+  response.rowId = 42;
+  response.result = "test result";
+  promise.setValue(std::move(response));
+
+  // Wait for async callback to move response into readyRows_
+  waitFor([&]() { return state_->numPendingRows() == 0; });
+
+  // Now claim
+  ContinueFuture waitFuture{ContinueFuture::makeEmpty()};
+  std::optional<RPCState::ReadyRow> claimedRow;
+  auto result = state_->tryClaimOrWait(&waitFuture, &claimedRow);
+
+  ASSERT_EQ(result, RPCState::ClaimResult::kClaimed);
+  ASSERT_TRUE(claimedRow.has_value());
+  EXPECT_EQ(claimedRow->rowId, 42);
+  EXPECT_EQ(claimedRow->response.result, "test result");
+  EXPECT_FALSE(claimedRow->response.hasError());
+}
+
+TEST_F(RPCStateTest, claimOrWaitReturnsFinished) {
+  state_->setStreamingMode(RPCStreamingMode::kPerRow);
+
+  // No rows, signal noMoreInput
+  state_->setNoMoreInput();
+
+  ContinueFuture waitFuture{ContinueFuture::makeEmpty()};
+  std::optional<RPCState::ReadyRow> claimedRow;
+  auto result = state_->tryClaimOrWait(&waitFuture, &claimedRow);
+
+  EXPECT_EQ(result, RPCState::ClaimResult::kFinished);
+}
+
+TEST_F(RPCStateTest, claimOrWaitMustWait) {
+  state_->setStreamingMode(RPCStreamingMode::kPerRow);
+
+  // Add a pending row that hasn't completed yet
+  auto [promise, future] = folly::makePromiseContract<RPCResponse>();
+  state_->addPendingRow(
+      state_, 1, RPCState::RowLocation{0, 0}, std::move(future));
+
+  // Try to claim — should return kMustWait because row isn't ready
+  ContinueFuture waitFuture{ContinueFuture::makeEmpty()};
+  std::optional<RPCState::ReadyRow> claimedRow;
+  auto result = state_->tryClaimOrWait(&waitFuture, &claimedRow);
+
+  EXPECT_EQ(result, RPCState::ClaimResult::kMustWait);
+  EXPECT_FALSE(claimedRow.has_value());
+
+  // Fulfill to clean up
+  RPCResponse response;
+  response.rowId = 1;
+  response.result = "done";
+  promise.setValue(std::move(response));
+}
+
+TEST_F(RPCStateTest, pendingRowCount) {
+  state_->setStreamingMode(RPCStreamingMode::kPerRow);
+
+  EXPECT_EQ(state_->numPendingRows(), 0);
+
+  auto [promise1, future1] = folly::makePromiseContract<RPCResponse>();
+  auto [promise2, future2] = folly::makePromiseContract<RPCResponse>();
+
+  state_->addPendingRow(
+      state_, 1, RPCState::RowLocation{0, 0}, std::move(future1));
+  EXPECT_EQ(state_->numPendingRows(), 1);
+
+  state_->addPendingRow(
+      state_, 2, RPCState::RowLocation{0, 1}, std::move(future2));
+  EXPECT_EQ(state_->numPendingRows(), 2);
+
+  // Fulfill first
+  RPCResponse r1;
+  r1.rowId = 1;
+  r1.result = "r1";
+  promise1.setValue(std::move(r1));
+
+  waitFor([&]() { return state_->numPendingRows() == 1; });
+  EXPECT_EQ(state_->numPendingRows(), 1);
+
+  // Fulfill second
+  RPCResponse r2;
+  r2.rowId = 2;
+  r2.result = "r2";
+  promise2.setValue(std::move(r2));
+
+  waitFor([&]() { return state_->numPendingRows() == 0; });
+  EXPECT_EQ(state_->numPendingRows(), 0);
+}
+
+// ========== BATCH mode tests ==========
+
+TEST_F(RPCStateTest, basicAddAndPollBatch) {
+  state_->setStreamingMode(RPCStreamingMode::kBatch);
+
+  auto [promise, future] =
+      folly::makePromiseContract<std::vector<RPCResponse>>();
+
+  state_->addPendingBatch(state_, std::move(future), {});
+
+  // Fulfill the promise
+  std::vector<RPCResponse> responses;
+  RPCResponse batchResponse;
+  batchResponse.rowId = 1;
+  batchResponse.result = "test";
+  responses.push_back(std::move(batchResponse));
+  promise.setValue(std::move(responses));
+
+  // Wait for async callback and poll
+  waitFor([&]() {
+    ContinueFuture waitFuture{ContinueFuture::makeEmpty()};
+    std::optional<RPCState::ReadyBatch> readyBatch;
+    auto result = state_->tryPollBatchOrWait(&waitFuture, &readyBatch);
+    if (result == RPCState::BatchPollResult::kGotBatch) {
+      // Verify row locations are empty (we passed empty).
+      EXPECT_TRUE(readyBatch->rowLocations.empty());
+      return true;
+    }
+    return false;
+  });
+}
+
+TEST_F(RPCStateTest, pollBatchOrWaitFinished) {
+  state_->setStreamingMode(RPCStreamingMode::kBatch);
+
+  // No batches, signal noMoreInput
+  state_->setNoMoreInput();
+
+  ContinueFuture waitFuture{ContinueFuture::makeEmpty()};
+  std::optional<RPCState::ReadyBatch> readyBatch;
+  auto result = state_->tryPollBatchOrWait(&waitFuture, &readyBatch);
+
+  EXPECT_EQ(result, RPCState::BatchPollResult::kFinished);
+}
+
+TEST_F(RPCStateTest, pollBatchOrWaitMustWait) {
+  state_->setStreamingMode(RPCStreamingMode::kBatch);
+
+  // Add a pending batch that hasn't completed yet
+  auto [promise, future] =
+      folly::makePromiseContract<std::vector<RPCResponse>>();
+  state_->addPendingBatch(state_, std::move(future), {});
+
+  // Try to poll — should return kMustWait
+  ContinueFuture waitFuture{ContinueFuture::makeEmpty()};
+  std::optional<RPCState::ReadyBatch> readyBatch;
+  auto result = state_->tryPollBatchOrWait(&waitFuture, &readyBatch);
+
+  EXPECT_EQ(result, RPCState::BatchPollResult::kMustWait);
+  EXPECT_FALSE(readyBatch.has_value());
+
+  // Fulfill to clean up
+  promise.setValue(std::vector<RPCResponse>{});
+}
+
+TEST_F(RPCStateTest, batchErrorHandling) {
+  state_->setStreamingMode(RPCStreamingMode::kBatch);
+
+  auto [promise, future] =
+      folly::makePromiseContract<std::vector<RPCResponse>>();
+
+  state_->addPendingBatch(state_, std::move(future), {});
+
+  // Set an exception
+  promise.setException(std::runtime_error("RPC batch failed"));
+
+  // Wait for async callback and poll
+  ContinueFuture waitFuture{ContinueFuture::makeEmpty()};
+  std::optional<RPCState::ReadyBatch> readyBatch;
+
+  waitFor([&]() {
+    auto result = state_->tryPollBatchOrWait(&waitFuture, &readyBatch);
+    return result == RPCState::BatchPollResult::kGotBatch;
+  });
+
+  ASSERT_TRUE(readyBatch.has_value());
+  ASSERT_TRUE(readyBatch->error.has_value());
+  EXPECT_TRUE(readyBatch->error->find("RPC batch failed") != std::string::npos);
+  EXPECT_TRUE(readyBatch->responses.empty());
+}
+
+// ========== Common tests ==========
+
+TEST_F(RPCStateTest, noMoreInputAndIsFinished) {
+  EXPECT_FALSE(state_->isFinished());
+
+  state_->setNoMoreInput();
+  EXPECT_TRUE(state_->isFinished());
+}
+
+TEST_F(RPCStateTest, isFinishedWithPendingRows) {
+  state_->setStreamingMode(RPCStreamingMode::kPerRow);
+
+  auto [promise, future] = folly::makePromiseContract<RPCResponse>();
+  state_->addPendingRow(
+      state_, 1, RPCState::RowLocation{0, 0}, std::move(future));
+
+  state_->setNoMoreInput();
+
+  // Not finished while rows are pending
+  EXPECT_FALSE(state_->isFinished());
+
+  // Fulfill and claim
+  RPCResponse response;
+  response.rowId = 1;
+  response.result = "done";
+  promise.setValue(std::move(response));
+
+  waitFor([&]() { return state_->numPendingRows() == 0; });
+
+  // Claim the ready row
+  ContinueFuture waitFuture{ContinueFuture::makeEmpty()};
+  std::optional<RPCState::ReadyRow> claimedRow;
+  state_->tryClaimOrWait(&waitFuture, &claimedRow);
+
+  // Now finished (noMoreInput + no pending + no ready)
+  EXPECT_TRUE(state_->isFinished());
+}
+
+TEST_F(RPCStateTest, inputBatchStorageAndRelease) {
+  // Store two input batches.
+  std::vector<VectorPtr> columns1; // Empty but valid for testing
+  std::vector<VectorPtr> columns2;
+
+  auto batchIdx1 = state_->storeInputBatch(std::move(columns1), 3);
+  auto batchIdx2 = state_->storeInputBatch(std::move(columns2), 2);
+
+  EXPECT_EQ(batchIdx1, 0);
+  EXPECT_EQ(batchIdx2, 1);
+
+  // Verify we can retrieve columns (empty in this test).
+  const auto& cols1 = state_->getInputBatchColumns(batchIdx1);
+  EXPECT_TRUE(cols1.empty());
+
+  const auto& cols2 = state_->getInputBatchColumns(batchIdx2);
+  EXPECT_TRUE(cols2.empty());
+
+  // Release rows incrementally.
+  state_->releaseRows(batchIdx1, 2);
+  // Batch 1 still has 1 active row, columns not released yet.
+  const auto& cols1After = state_->getInputBatchColumns(batchIdx1);
+  // Still accessible (columns empty in this test, but structure is still
+  // valid).
+  (void)cols1After;
+
+  // Release remaining row — batch should be fully released.
+  state_->releaseRows(batchIdx1, 1);
+
+  // Release all rows from batch 2 at once.
+  state_->releaseRows(batchIdx2, 2);
+}
+
+TEST_F(RPCStateTest, batchRowLocationsCarriedThrough) {
+  state_->setStreamingMode(RPCStreamingMode::kBatch);
+
+  auto [promise, future] =
+      folly::makePromiseContract<std::vector<RPCResponse>>();
+
+  // Pass row locations with the batch.
+  std::vector<RPCState::RowLocation> locations = {{0, 5}, {0, 10}, {1, 3}};
+  state_->addPendingBatch(state_, std::move(future), locations);
+
+  // Fulfill the promise.
+  std::vector<RPCResponse> responses;
+  for (int i = 0; i < 3; ++i) {
+    RPCResponse r;
+    r.rowId = i;
+    r.result = "result_" + std::to_string(i);
+    responses.push_back(std::move(r));
+  }
+  promise.setValue(std::move(responses));
+
+  // Poll and verify row locations are carried through.
+  waitFor([&]() {
+    ContinueFuture waitFuture{ContinueFuture::makeEmpty()};
+    std::optional<RPCState::ReadyBatch> readyBatch;
+    auto result = state_->tryPollBatchOrWait(&waitFuture, &readyBatch);
+    if (result == RPCState::BatchPollResult::kGotBatch) {
+      EXPECT_EQ(readyBatch->responses.size(), 3);
+      EXPECT_EQ(readyBatch->rowLocations.size(), 3);
+      EXPECT_EQ(readyBatch->rowLocations[0].batchIndex, 0);
+      EXPECT_EQ(readyBatch->rowLocations[0].rowIndex, 5);
+      EXPECT_EQ(readyBatch->rowLocations[1].batchIndex, 0);
+      EXPECT_EQ(readyBatch->rowLocations[1].rowIndex, 10);
+      EXPECT_EQ(readyBatch->rowLocations[2].batchIndex, 1);
+      EXPECT_EQ(readyBatch->rowLocations[2].rowIndex, 3);
+      return true;
+    }
+    return false;
+  });
+}
+
+TEST_F(RPCStateTest, drainReadyRows) {
+  state_->setStreamingMode(RPCStreamingMode::kPerRow);
+
+  // Add 3 pending rows and fulfill them all.
+  std::vector<folly::Promise<RPCResponse>> promises;
+  for (int i = 0; i < 3; ++i) {
+    auto [promise, future] = folly::makePromiseContract<RPCResponse>();
+    state_->addPendingRow(
+        state_,
+        i,
+        RPCState::RowLocation{0, static_cast<vector_size_t>(i)},
+        std::move(future));
+    promises.push_back(std::move(promise));
+  }
+
+  // Fulfill all 3.
+  for (int i = 0; i < 3; ++i) {
+    RPCResponse response;
+    response.rowId = i;
+    response.result = "result_" + std::to_string(i);
+    promises[i].setValue(std::move(response));
+  }
+
+  waitFor([&]() { return state_->numPendingRows() == 0; });
+
+  // Drain up to 10 rows (should get all 3).
+  std::vector<RPCState::ReadyRow> out;
+  state_->drainReadyRows(out, 10);
+
+  ASSERT_EQ(out.size(), 3);
+  // Verify all responses are present (order may vary due to async).
+  std::set<int64_t> rowIds;
+  for (const auto& row : out) {
+    rowIds.insert(row.rowId);
+  }
+  EXPECT_EQ(rowIds.count(0), 1);
+  EXPECT_EQ(rowIds.count(1), 1);
+  EXPECT_EQ(rowIds.count(2), 1);
+
+  // Drain again — should be empty.
+  std::vector<RPCState::ReadyRow> out2;
+  state_->drainReadyRows(out2, 10);
+  EXPECT_TRUE(out2.empty());
+}
+
+TEST_F(RPCStateTest, backpressure) {
+  state_->setStreamingMode(RPCStreamingMode::kPerRow);
+  state_->setMaxPendingRows(2);
+
+  EXPECT_FALSE(state_->isUnderBackpressure());
+
+  auto [promise1, future1] = folly::makePromiseContract<RPCResponse>();
+  state_->addPendingRow(
+      state_, 1, RPCState::RowLocation{0, 0}, std::move(future1));
+  EXPECT_FALSE(state_->isUnderBackpressure());
+
+  auto [promise2, future2] = folly::makePromiseContract<RPCResponse>();
+  state_->addPendingRow(
+      state_, 2, RPCState::RowLocation{0, 1}, std::move(future2));
+  EXPECT_TRUE(state_->isUnderBackpressure());
+
+  // Fulfill one to relieve backpressure
+  RPCResponse r1;
+  r1.rowId = 1;
+  r1.result = "r1";
+  promise1.setValue(std::move(r1));
+
+  waitFor([&]() { return !state_->isUnderBackpressure(); });
+  EXPECT_FALSE(state_->isUnderBackpressure());
+
+  // Clean up
+  RPCResponse r2;
+  r2.rowId = 2;
+  r2.result = "r2";
+  promise2.setValue(std::move(r2));
+}
+
+} // namespace
+} // namespace facebook::velox::exec::rpc
diff --git a/velox/exec/tests/AdaptivePrefetchTest.cpp b/velox/exec/tests/AdaptivePrefetchTest.cpp
new file mode 100644
index 00000000000..a48461a11c9
--- /dev/null
+++ b/velox/exec/tests/AdaptivePrefetchTest.cpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/AdaptivePrefetch.h"
+#include <gtest/gtest.h>
+#include <thread>
+
+namespace facebook::velox::exec {
+namespace {
+
+TEST(AdaptivePrefetchTest, returnsInitialLookAheadDuringMeasurement) {
+  AdaptivePrefetch prefetch(1000);
+  for (int i = 0; i < 16; ++i) {
+    EXPECT_EQ(prefetch.lookAhead(), 4);
+  }
+}
+
+TEST(AdaptivePrefetchTest, slowIterationsClampToMin) {
+  AdaptivePrefetch prefetch(1000);
+  for (int i = 0; i < 16; ++i) {
+    prefetch.lookAhead();
+    std::this_thread::sleep_for(std::chrono::microseconds(10));
+  }
+  EXPECT_EQ(prefetch.lookAhead(), 4);
+}
+
+TEST(AdaptivePrefetchTest, fastIterationsProduceHighLookAhead) {
+  AdaptivePrefetch prefetch(1000);
+  for (int i = 0; i < 16; ++i) {
+    prefetch.lookAhead();
+  }
+  EXPECT_GT(prefetch.lookAhead(), 4);
+}
+
+TEST(AdaptivePrefetchTest, returnsZeroNearEnd) {
+  AdaptivePrefetch prefetch(20);
+  int zeroCount = 0;
+  for (int i = 0; i < 20; ++i) {
+    if (prefetch.lookAhead() == 0) {
+      ++zeroCount;
+    }
+  }
+  EXPECT_GT(zeroCount, 0);
+}
+
+} // namespace
+} // namespace facebook::velox::exec
diff --git a/velox/exec/tests/AggregateCompanionAdapterTest.cpp b/velox/exec/tests/AggregateCompanionAdapterTest.cpp
index 61d27961ca8..e050dff7fdb 100644
--- a/velox/exec/tests/AggregateCompanionAdapterTest.cpp
+++ b/velox/exec/tests/AggregateCompanionAdapterTest.cpp
@@ -77,8 +77,8 @@ class AggregateCompanionRegistryTest : public testing::Test {
       const std::vector<TypePtr>& argTypes,
       const TypePtr& intermediateType,
       const TypePtr& resultType) {
-    const auto& [resolvedResult, resolveIntermediate] =
-        resolveAggregateFunction(name, argTypes);
+    const auto& resolvedResult = resolveResultType(name, argTypes);
+    const auto& resolveIntermediate = resolveIntermediateType(name, argTypes);
     checkEqual(resolvedResult, resultType);
     checkEqual(resolveIntermediate, intermediateType);
   }
@@ -414,22 +414,27 @@ TEST_F(
 TEST_F(
     AggregateCompanionRegistryTest,
     resultTypeNotResolvableFromIntermediateType) {
-  // We only register companion functions for original signatures whose result
-  // type can be resolved from its intermediate type.
+  // We only register partial, merge and merge_extract companion functions for
+  // original signatures whose result type cannot be resolved from its
+  // intermediate type.
   std::vector<std::shared_ptr<AggregateFunctionSignature>> signatures{
       AggregateFunctionSignatureBuilder()
-          .typeVariable("T")
-          .returnType("array(T)")
-          .intermediateType("varbinary")
-          .argumentType("T")
+          .integerVariable("a_precision")
+          .integerVariable("a_scale")
+          .integerVariable("i_precision", "min(38, a_precision + 10)")
+          .integerVariable("r_precision", "min(38, a_precision + 4)")
+          .integerVariable("r_scale", "min(38, a_scale + 4)")
+          .returnType("DECIMAL(r_precision, r_scale)")
+          .intermediateType("ROW(DECIMAL(i_precision, a_scale), bigint)")
+          .argumentType("DECIMAL(a_precision, a_scale)")
           .build()};
   registerDummyAggregateFunction("aggregateFunc6", signatures);
 
-  checkAggregateSignaturesCount("aggregateFunc6_partial", 0);
+  checkAggregateSignaturesCount("aggregateFunc6_partial", 1);
 
-  checkAggregateSignaturesCount("aggregateFunc6_merge", 0);
+  checkAggregateSignaturesCount("aggregateFunc6_merge", 1);
 
-  checkAggregateSignaturesCount("aggregateFunc6_merge_extract", 0);
+  checkAggregateSignaturesCount("aggregateFunc6_merge_extract", 1);
 
   checkScalarSignaturesCount("aggregateFunc6_extract", 0);
 }
diff --git a/velox/exec/tests/AggregateFunctionRegistryTest.cpp b/velox/exec/tests/AggregateFunctionRegistryTest.cpp
index a225e395729..8bd8dcf43a8 100644
--- a/velox/exec/tests/AggregateFunctionRegistryTest.cpp
+++ b/velox/exec/tests/AggregateFunctionRegistryTest.cpp
@@ -40,10 +40,44 @@ class AggregateFunctionRegistryTest : public testing::Test {
       const std::vector<TypePtr>& argTypes,
       const TypePtr& expectedFinalType,
       const TypePtr& expectedIntermediateType) {
-    auto [finalType, intermediateType] =
-        resolveAggregateFunction(name, argTypes);
-    EXPECT_EQ(*finalType, *expectedFinalType);
-    EXPECT_EQ(*intermediateType, *expectedIntermediateType);
+    {
+      auto finalType = resolveResultType(name, argTypes);
+      auto intermediateType = resolveIntermediateType(name, argTypes);
+      VELOX_EXPECT_EQ_TYPES(finalType, expectedFinalType);
+      VELOX_EXPECT_EQ_TYPES(intermediateType, expectedIntermediateType);
+    }
+
+    {
+      std::vector<TypePtr> coercions;
+      auto finalType = resolveResultTypeWithCoercions(
+          name, argTypes, coercions, TypeCoercer::defaults());
+      VELOX_EXPECT_EQ_TYPES(finalType, expectedFinalType);
+
+      EXPECT_EQ(coercions.size(), argTypes.size());
+      for (const auto& coercion : coercions) {
+        EXPECT_EQ(coercion, nullptr);
+      }
+    }
+  }
+
+  void testCoersions(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes,
+      const TypePtr& expectedFinalType,
+      const std::vector<TypePtr>& expectedCoercions) {
+    VELOX_ASSERT_THROW(
+        resolveResultType(name, argTypes),
+        "Aggregate function signature is not supported");
+
+    std::vector<TypePtr> coercions;
+    auto finalType = resolveResultTypeWithCoercions(
+        name, argTypes, coercions, TypeCoercer::defaults());
+    VELOX_EXPECT_EQ_TYPES(finalType, expectedFinalType);
+
+    EXPECT_EQ(coercions.size(), argTypes.size());
+    for (int i = 0; i < coercions.size(); ++i) {
+      VELOX_EXPECT_EQ_TYPES(coercions[i], expectedCoercions[i]);
+    }
   }
 
   void clearRegistry() {
@@ -67,26 +101,38 @@ TEST_F(AggregateFunctionRegistryTest, basic) {
 
 TEST_F(AggregateFunctionRegistryTest, wrongFunctionName) {
   VELOX_ASSERT_THROW(
-      resolveAggregateFunction("aggregate_func_nonexist", {BIGINT(), BIGINT()}),
+      resolveIntermediateType("aggregate_func_nonexist", {BIGINT(), BIGINT()}),
       "Aggregate function not registered: aggregate_func_nonexist");
   VELOX_ASSERT_THROW(
-      resolveAggregateFunction("aggregate_func_nonexist", {}),
+      resolveIntermediateType("aggregate_func_nonexist", {}),
       "Aggregate function not registered: aggregate_func_nonexist");
 }
 
 TEST_F(AggregateFunctionRegistryTest, wrongArgType) {
   VELOX_ASSERT_THROW(
-      resolveAggregateFunction("aggregate_func", {DOUBLE(), BIGINT()}),
+      resolveIntermediateType("aggregate_func", {DOUBLE(), BIGINT()}),
       "Aggregate function signature is not supported");
   VELOX_ASSERT_THROW(
-      resolveAggregateFunction("aggregate_func", {BIGINT()}),
+      resolveResultType("aggregate_func", {BIGINT()}),
       "Aggregate function signature is not supported");
   VELOX_ASSERT_THROW(
-      resolveAggregateFunction(
-          "aggregate_func", {BIGINT(), BIGINT(), BIGINT()}),
+      resolveResultType("aggregate_func", {BIGINT(), BIGINT(), BIGINT()}),
       "Aggregate function signature is not supported");
 }
 
+TEST_F(AggregateFunctionRegistryTest, coercions) {
+  // (bigint, double) -> bigint
+  // (T, T) -> T
+  testCoersions(
+      "aggregate_func", {DOUBLE(), BIGINT()}, DOUBLE(), {nullptr, DOUBLE()});
+
+  testCoersions(
+      "aggregate_func", {TINYINT(), BIGINT()}, BIGINT(), {BIGINT(), nullptr});
+
+  testCoersions(
+      "aggregate_func", {INTEGER(), DOUBLE()}, BIGINT(), {BIGINT(), nullptr});
+}
+
 TEST_F(AggregateFunctionRegistryTest, functionNameInMixedCase) {
   testResolve(
       "aggregatE_funC", {BIGINT(), DOUBLE()}, BIGINT(), ARRAY(BIGINT()));
diff --git a/velox/exec/tests/AggregateSpillBenchmarkBase.cpp b/velox/exec/tests/AggregateSpillBenchmarkBase.cpp
index b8f15c3c799..03b5f8fdcf6 100644
--- a/velox/exec/tests/AggregateSpillBenchmarkBase.cpp
+++ b/velox/exec/tests/AggregateSpillBenchmarkBase.cpp
@@ -36,10 +36,12 @@ std::unique_ptr<RowContainer> makeRowContainer(
       true, // nullableKeys
       std::vector<Accumulator>{},
       dependentTypes,
-      false, // hasNext
-      false, // isJoinBuild
-      false, // hasProbedFlag
-      false, // hasNormalizedKey
+      /*hasNext=*/false,
+      /*isJoinBuild=*/false,
+      /*hasProbedFlag=*/false,
+      /*hasCountFlag=*/false,
+      /*hasNormalizedKey=*/false,
+      /*useListRowIndex=*/false,
       pool.get());
 }
 
diff --git a/velox/exec/tests/AggregateSpillBenchmarkBase.h b/velox/exec/tests/AggregateSpillBenchmarkBase.h
index aafb67d009e..f25f35831bb 100644
--- a/velox/exec/tests/AggregateSpillBenchmarkBase.h
+++ b/velox/exec/tests/AggregateSpillBenchmarkBase.h
@@ -20,7 +20,7 @@ namespace facebook::velox::exec::test {
 class AggregateSpillBenchmarkBase : public SpillerBenchmarkBase {
  public:
   explicit AggregateSpillBenchmarkBase(std::string spillerType)
-      : spillerType_(spillerType){};
+      : spillerType_(spillerType) {};
 
   /// Sets up the test.
   void setUp() override;
diff --git a/velox/exec/tests/AggregationTest.cpp b/velox/exec/tests/AggregationTest.cpp
index 58b6d58b443..fc2ecd4942e 100644
--- a/velox/exec/tests/AggregationTest.cpp
+++ b/velox/exec/tests/AggregationTest.cpp
@@ -18,14 +18,16 @@
 #include <folly/Math.h>
 #include <re2/re2.h>
 
-#include "folly/experimental/EventCount.h"
+#include "folly/synchronization/EventCount.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/memory/SharedArbitrator.h"
 #include "velox/common/memory/tests/SharedArbitratorTestUtil.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/exec/Aggregate.h"
+#include "velox/exec/AggregateCompanionSignatures.h"
 #include "velox/exec/GroupingSet.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/PrefixSort.h"
@@ -36,7 +38,7 @@
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/exec/tests/utils/SumNonPODAggregate.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/type/tests/utils/CustomTypesForTesting.h"
 
 namespace facebook::velox::exec::test {
 
@@ -112,35 +114,43 @@ void checkSpillStats(PlanNodeStats& stats, bool expectedSpill) {
     ASSERT_GT(stats.spilledInputBytes, 0);
     ASSERT_GT(stats.spilledBytes, 0);
     ASSERT_GT(stats.spilledPartitions, 0);
-    ASSERT_GT(stats.customStats[Operator::kSpillRuns].sum, 0);
-    ASSERT_GT(stats.customStats[Operator::kSpillFillTime].sum, 0);
-    ASSERT_GT(stats.customStats[Operator::kSpillSortTime].sum, 0);
-    ASSERT_GT(stats.customStats[Operator::kSpillExtractVectorTime].sum, 0);
-    ASSERT_GT(stats.customStats[Operator::kSpillSerializationTime].sum, 0);
-    ASSERT_GT(stats.customStats[Operator::kSpillFlushTime].sum, 0);
-    ASSERT_GT(stats.customStats[Operator::kSpillWrites].sum, 0);
-    ASSERT_GT(stats.customStats[Operator::kSpillWriteTime].sum, 0);
+    ASSERT_GT(stats.customStats[std::string(Operator::kSpillRuns)].sum, 0);
+    ASSERT_GT(stats.customStats[std::string(Operator::kSpillFillTime)].sum, 0);
+    ASSERT_GT(stats.customStats[std::string(Operator::kSpillSortTime)].sum, 0);
+    ASSERT_GT(
+        stats.customStats[std::string(Operator::kSpillExtractVectorTime)].sum,
+        0);
+    ASSERT_GT(
+        stats.customStats[std::string(Operator::kSpillSerializationTime)].sum,
+        0);
+    ASSERT_GT(stats.customStats[std::string(Operator::kSpillFlushTime)].sum, 0);
+    ASSERT_GT(stats.customStats[std::string(Operator::kSpillWrites)].sum, 0);
+    ASSERT_GT(stats.customStats[std::string(Operator::kSpillWriteTime)].sum, 0);
   } else {
     ASSERT_EQ(stats.spilledRows, 0);
     ASSERT_EQ(stats.spilledInputBytes, 0);
     ASSERT_EQ(stats.spilledBytes, 0);
     ASSERT_EQ(stats.spilledPartitions, 0);
     ASSERT_EQ(stats.spilledFiles, 0);
-    ASSERT_EQ(stats.customStats[Operator::kSpillRuns].sum, 0);
-    ASSERT_EQ(stats.customStats[Operator::kSpillFillTime].sum, 0);
-    ASSERT_EQ(stats.customStats[Operator::kSpillSortTime].sum, 0);
-    ASSERT_EQ(stats.customStats[Operator::kSpillExtractVectorTime].sum, 0);
-    ASSERT_EQ(stats.customStats[Operator::kSpillSerializationTime].sum, 0);
-    ASSERT_EQ(stats.customStats[Operator::kSpillFlushTime].sum, 0);
-    ASSERT_EQ(stats.customStats[Operator::kSpillWrites].sum, 0);
-    ASSERT_EQ(stats.customStats[Operator::kSpillWriteTime].sum, 0);
+    ASSERT_EQ(stats.customStats[std::string(Operator::kSpillRuns)].sum, 0);
+    ASSERT_EQ(stats.customStats[std::string(Operator::kSpillFillTime)].sum, 0);
+    ASSERT_EQ(stats.customStats[std::string(Operator::kSpillSortTime)].sum, 0);
+    ASSERT_EQ(
+        stats.customStats[std::string(Operator::kSpillExtractVectorTime)].sum,
+        0);
+    ASSERT_EQ(
+        stats.customStats[std::string(Operator::kSpillSerializationTime)].sum,
+        0);
+    ASSERT_EQ(stats.customStats[std::string(Operator::kSpillFlushTime)].sum, 0);
+    ASSERT_EQ(stats.customStats[std::string(Operator::kSpillWrites)].sum, 0);
+    ASSERT_EQ(stats.customStats[std::string(Operator::kSpillWriteTime)].sum, 0);
   }
   ASSERT_EQ(
-      stats.customStats[Operator::kSpillSerializationTime].count,
-      stats.customStats[Operator::kSpillFlushTime].count);
+      stats.customStats[std::string(Operator::kSpillSerializationTime)].count,
+      stats.customStats[std::string(Operator::kSpillFlushTime)].count);
   ASSERT_EQ(
-      stats.customStats[Operator::kSpillWrites].count,
-      stats.customStats[Operator::kSpillWriteTime].count);
+      stats.customStats[std::string(Operator::kSpillWrites)].count,
+      stats.customStats[std::string(Operator::kSpillWriteTime)].count);
 }
 
 class AggregationTest : public OperatorTestBase {
@@ -332,10 +342,12 @@ class AggregationTest : public OperatorTestBase {
       std::vector<RowVectorPtr>& batches) {
     std::vector<VectorPtr> children;
     dictionary->setSize(count * sizeof(vector_size_t));
-    children.push_back(BaseVector::wrapInDictionary(
-        BufferPtr(nullptr), dictionary, count, rows->childAt(0)));
-    children.push_back(BaseVector::wrapInDictionary(
-        BufferPtr(nullptr), dictionary, count, rows->childAt(1)));
+    children.push_back(
+        BaseVector::wrapInDictionary(
+            BufferPtr(nullptr), dictionary, count, rows->childAt(0)));
+    children.push_back(
+        BaseVector::wrapInDictionary(
+            BufferPtr(nullptr), dictionary, count, rows->childAt(1)));
     children.push_back(children[1]);
     batches.push_back(vectorMaker_.rowVector(children));
     dictionary = AlignedBuffer::allocate<vector_size_t>(
@@ -379,7 +391,9 @@ class AggregationTest : public OperatorTestBase {
         false,
         false,
         true,
+        false, // hasCountFlag
         true,
+        false,
         pool_.get());
   }
 
@@ -478,7 +492,8 @@ TEST_F(AggregationTest, missingFunctionOrSignature) {
               std::vector<core::FieldAccessTypedExprPtr>{},
               std::vector<std::string>{"agg"},
               aggregates,
-              false,
+              /*ignoreNullKeys=*/false,
+              /*noGroupsSpanBatches=*/false,
               std::move(source));
         })
         .planNode();
@@ -539,7 +554,8 @@ TEST_F(AggregationTest, missingLambdaFunction) {
                         std::vector<core::FieldAccessTypedExprPtr>{},
                         std::vector<std::string>{"agg"},
                         aggregates,
-                        false,
+                        /*ignoreNullKeys=*/false,
+                        /*noGroupsSpanBatches=*/false,
                         std::move(source));
                   })
                   .planNode();
@@ -550,47 +566,6 @@ TEST_F(AggregationTest, missingLambdaFunction) {
       readCursor(params), "Aggregate function not registered: missing-lambda");
 }
 
-TEST_F(AggregationTest, DISABLED_resultTypeMismatch) {
-  using Step = core::AggregationNode::Step;
-
-  registerAggregateFunction(
-      "test_aggregate",
-      {AggregateFunctionSignatureBuilder()
-           .returnType("bigint")
-           .intermediateType("bigint")
-           .argumentType("bigint")
-           .build()},
-      [&](Step /*step*/,
-          const std::vector<TypePtr>& /*argTypes*/,
-          const TypePtr& /*resultType*/,
-          const core::QueryConfig& /*config*/)
-          -> std::unique_ptr<exec::Aggregate> { VELOX_UNREACHABLE(); },
-      false /*registerCompanionFunctions*/,
-      true /*overwrite*/);
-
-  for (auto step : {Step::kIntermediate, Step::kPartial}) {
-    VELOX_ASSERT_THROW(
-        Aggregate::create(
-            "test_aggregate",
-            step,
-            std::vector<TypePtr>{BIGINT()},
-            INTEGER(),
-            core::QueryConfig{{}}),
-        "Intermediate type mismatch");
-  }
-
-  for (auto step : {Step::kFinal, Step::kSingle}) {
-    VELOX_ASSERT_THROW(
-        Aggregate::create(
-            "test_aggregate",
-            step,
-            std::vector<TypePtr>{BIGINT()},
-            INTEGER(),
-            core::QueryConfig{{}}),
-        "Final type mismatch");
-  }
-}
-
 TEST_F(AggregationTest, global) {
   auto vectors = makeVectors(rowType_, 10, 100);
   createDuckDbTable(vectors);
@@ -670,8 +645,11 @@ TEST_F(AggregationTest, manyGlobalAggregations) {
   createDuckDbTable(vectors);
   aggregates.clear();
   for (int i = 0; i < rowType->size(); i++) {
-    aggregates.push_back(fmt::format(
-        "array_agg({} ORDER BY {})", rowType->nameOf(i), rowType->nameOf(i)));
+    aggregates.push_back(
+        fmt::format(
+            "array_agg({} ORDER BY {})",
+            rowType->nameOf(i),
+            rowType->nameOf(i)));
   }
 
   op = PlanBuilder()
@@ -876,8 +854,9 @@ TEST_F(AggregationTest, allKeyTypes) {
 
   std::vector<RowVectorPtr> batches;
   for (auto i = 0; i < 10; ++i) {
-    batches.push_back(std::static_pointer_cast<RowVector>(
-        BatchMaker::createBatch(rowType, 100, *pool_)));
+    batches.push_back(
+        std::static_pointer_cast<RowVector>(
+            BatchMaker::createBatch(rowType, 100, *pool_)));
   }
   createDuckDbTable(batches);
   auto op =
@@ -911,12 +890,13 @@ TEST_F(AggregationTest, partialAggregationMemoryLimit) {
   core::PlanNodeId aggNodeId;
   auto task = AssertQueryBuilder(duckDbQueryRunner_)
                   .config(QueryConfig::kMaxPartialAggregationMemory, 100)
-                  .plan(PlanBuilder()
-                            .values(vectors)
-                            .partialAggregation({"c0"}, {})
-                            .capturePlanNodeId(aggNodeId)
-                            .finalAggregation()
-                            .planNode())
+                  .plan(
+                      PlanBuilder()
+                          .values(vectors)
+                          .partialAggregation({"c0"}, {})
+                          .capturePlanNodeId(aggNodeId)
+                          .finalAggregation()
+                          .planNode())
                   .assertResults("SELECT distinct c0 FROM tmp");
   EXPECT_GT(
       toPlanStats(task->taskStats())
@@ -934,12 +914,13 @@ TEST_F(AggregationTest, partialAggregationMemoryLimit) {
   // Count aggregation.
   task = AssertQueryBuilder(duckDbQueryRunner_)
              .config(QueryConfig::kMaxPartialAggregationMemory, 1)
-             .plan(PlanBuilder()
-                       .values(vectors)
-                       .partialAggregation({"c0"}, {"count(1)"})
-                       .capturePlanNodeId(aggNodeId)
-                       .finalAggregation()
-                       .planNode())
+             .plan(
+                 PlanBuilder()
+                     .values(vectors)
+                     .partialAggregation({"c0"}, {"count(1)"})
+                     .capturePlanNodeId(aggNodeId)
+                     .finalAggregation()
+                     .planNode())
              .assertResults("SELECT c0, count(1) FROM tmp GROUP BY 1");
   EXPECT_GT(
       toPlanStats(task->taskStats())
@@ -957,12 +938,13 @@ TEST_F(AggregationTest, partialAggregationMemoryLimit) {
   // Global aggregation.
   task = AssertQueryBuilder(duckDbQueryRunner_)
              .config(QueryConfig::kMaxPartialAggregationMemory, 1)
-             .plan(PlanBuilder()
-                       .values(vectors)
-                       .partialAggregation({}, {"sum(c0)"})
-                       .capturePlanNodeId(aggNodeId)
-                       .finalAggregation()
-                       .planNode())
+             .plan(
+                 PlanBuilder()
+                     .values(vectors)
+                     .partialAggregation({}, {"sum(c0)"})
+                     .capturePlanNodeId(aggNodeId)
+                     .finalAggregation()
+                     .planNode())
              .assertResults("SELECT sum(c0) FROM tmp");
   EXPECT_EQ(
       0,
@@ -997,11 +979,12 @@ TEST_F(AggregationTest, partialDistinctWithAbandon) {
                   .config(QueryConfig::kAbandonPartialAggregationMinRows, 100)
                   .config(QueryConfig::kAbandonPartialAggregationMinPct, 50)
                   .maxDrivers(1)
-                  .plan(PlanBuilder()
-                            .values(vectors)
-                            .partialAggregation({"c0"}, {})
-                            .finalAggregation()
-                            .planNode())
+                  .plan(
+                      PlanBuilder()
+                          .values(vectors)
+                          .partialAggregation({"c0"}, {})
+                          .finalAggregation()
+                          .planNode())
                   .assertResults("SELECT distinct c0 FROM tmp");
 
   // with aggregation, just in case.
@@ -1009,11 +992,12 @@ TEST_F(AggregationTest, partialDistinctWithAbandon) {
              .config(QueryConfig::kAbandonPartialAggregationMinRows, 100)
              .config(QueryConfig::kAbandonPartialAggregationMinPct, 50)
              .maxDrivers(1)
-             .plan(PlanBuilder()
-                       .values(vectors)
-                       .partialAggregation({"c0"}, {"sum(c0)"})
-                       .finalAggregation()
-                       .planNode())
+             .plan(
+                 PlanBuilder()
+                     .values(vectors)
+                     .partialAggregation({"c0"}, {"sum(c0)"})
+                     .finalAggregation()
+                     .planNode())
              .assertResults("SELECT distinct c0, sum(c0) FROM tmp group by c0");
 }
 
@@ -1031,6 +1015,7 @@ TEST_F(AggregationTest, distinctWithGroupingKeysReordered) {
   options.vectorSize = vectorSize;
   options.stringVariableLength = false;
   options.stringLength = 128;
+  options.nullRatio = 0.1;
   VectorFuzzer fuzzer(options, pool());
   const int numVectors{5};
   std::vector<RowVectorPtr> vectors;
@@ -1042,22 +1027,22 @@ TEST_F(AggregationTest, distinctWithGroupingKeysReordered) {
 
   // Distinct aggregation with grouping key with larger prefix encoded size
   // first.
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
   TestScopedSpillInjection scopedSpillInjection(100);
-  auto task =
-      AssertQueryBuilder(duckDbQueryRunner_)
-          .config(QueryConfig::kAbandonPartialAggregationMinRows, 100)
-          .config(QueryConfig::kAbandonPartialAggregationMinPct, 50)
-          .spillDirectory(spillDirectory->getPath())
-          .config(QueryConfig::kSpillEnabled, true)
-          .config(QueryConfig::kAggregationSpillEnabled, true)
-          .config(QueryConfig::kSpillPrefixSortEnabled, true)
-          .maxDrivers(1)
-          .plan(PlanBuilder()
-                    .values(vectors)
-                    .singleAggregation({"c4", "c1", "c3", "c2", "c0"}, {})
-                    .planNode())
-          .assertResults("SELECT distinct c4, c1, c3, c2, c0 FROM tmp");
+  auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                  .config(QueryConfig::kAbandonPartialAggregationMinRows, 100)
+                  .config(QueryConfig::kAbandonPartialAggregationMinPct, 50)
+                  .spillDirectory(spillDirectory->getPath())
+                  .config(QueryConfig::kSpillEnabled, true)
+                  .config(QueryConfig::kAggregationSpillEnabled, true)
+                  .config(QueryConfig::kSpillPrefixSortEnabled, true)
+                  .maxDrivers(1)
+                  .plan(
+                      PlanBuilder()
+                          .values(vectors)
+                          .singleAggregation({"c4", "c1", "c3", "c2", "c0"}, {})
+                          .planNode())
+                  .assertResults("SELECT distinct c4, c1, c3, c2, c0 FROM tmp");
 }
 
 TEST_F(AggregationTest, largeValueRangeArray) {
@@ -1157,12 +1142,13 @@ TEST_F(AggregationTest, partialAggregationMemoryLimitIncrease) {
                     .config(
                         QueryConfig::kMaxExtendedPartialAggregationMemory,
                         std::to_string(testData.extendedPartialMemoryLimit))
-                    .plan(PlanBuilder()
-                              .values(vectors)
-                              .partialAggregation({"c0"}, {})
-                              .capturePlanNodeId(aggNodeId)
-                              .finalAggregation()
-                              .planNode())
+                    .plan(
+                        PlanBuilder()
+                            .values(vectors)
+                            .partialAggregation({"c0"}, {})
+                            .capturePlanNodeId(aggNodeId)
+                            .finalAggregation()
+                            .planNode())
                     .assertResults("SELECT distinct c0 FROM tmp");
     const auto runtimeStats =
         toPlanStats(task->taskStats()).at(aggNodeId).customStats;
@@ -1233,13 +1219,13 @@ TEST_F(AggregationTest, partialAggregationMaybeReservationReleaseCheck) {
 TEST_F(AggregationTest, spillAll) {
   auto inputs = makeVectors(rowType_, 100, 10);
 
-  const auto numDistincts =
-      AssertQueryBuilder(PlanBuilder()
-                             .values(inputs)
-                             .singleAggregation({"c0"}, {}, {})
-                             .planNode())
-          .copyResults(pool_.get())
-          ->size();
+  const auto numDistincts = AssertQueryBuilder(
+                                PlanBuilder()
+                                    .values(inputs)
+                                    .singleAggregation({"c0"}, {}, {})
+                                    .planNode())
+                                .copyResults(pool_.get())
+                                ->size();
 
   auto plan = PlanBuilder()
                   .values(inputs)
@@ -1249,7 +1235,7 @@ TEST_F(AggregationTest, spillAll) {
   auto results = AssertQueryBuilder(plan).copyResults(pool_.get());
 
   for (int numPartitionBits : {1, 2, 3}) {
-    auto tempDirectory = exec::test::TempDirectoryPath::create();
+    auto tempDirectory = TempDirectoryPath::create();
     auto queryCtx = core::QueryCtx::create(executor_.get());
     TestScopedSpillInjection scopedSpillInjection(100);
     auto task = AssertQueryBuilder(plan)
@@ -1263,7 +1249,11 @@ TEST_F(AggregationTest, spillAll) {
 
     auto stats = task->taskStats().pipelineStats;
     ASSERT_LT(
-        0, stats[0].operatorStats[1].runtimeStats[Operator::kSpillRuns].count);
+        0,
+        stats[0]
+            .operatorStats[1]
+            .runtimeStats[std::string(Operator::kSpillRuns)]
+            .count);
     // Check spilled bytes.
     ASSERT_LT(0, stats[0].operatorStats[1].spilledInputBytes);
     ASSERT_LT(0, stats[0].operatorStats[1].spilledBytes);
@@ -1739,7 +1729,7 @@ TEST_F(AggregationTest, outputBatchSizeCheckWithSpill) {
       inputs = largeVectors;
     }
     createDuckDbTable(inputs);
-    auto tempDirectory = exec::test::TempDirectoryPath::create();
+    auto tempDirectory = TempDirectoryPath::create();
     core::PlanNodeId aggrNodeId;
     TestScopedSpillInjection scopedSpillInjection(100);
     auto task =
@@ -1753,11 +1743,12 @@ TEST_F(AggregationTest, outputBatchSizeCheckWithSpill) {
             .config(
                 QueryConfig::kMaxOutputBatchRows,
                 std::to_string(testData.maxOutputRows))
-            .plan(PlanBuilder()
-                      .values(inputs)
-                      .singleAggregation({"c0"}, {"array_agg(c1)"})
-                      .capturePlanNodeId(aggrNodeId)
-                      .planNode())
+            .plan(
+                PlanBuilder()
+                    .values(inputs)
+                    .singleAggregation({"c0"}, {"array_agg(c1)"})
+                    .capturePlanNodeId(aggrNodeId)
+                    .planNode())
             .assertResults("SELECT c0, array_agg(c1) FROM tmp GROUP BY 1");
     ASSERT_GT(toPlanStats(task->taskStats()).at(aggrNodeId).spilledBytes, 0);
     ASSERT_EQ(
@@ -1803,7 +1794,7 @@ TEST_F(AggregationTest, outputBatchSizeCheckWithSpillForOrderedAggr) {
     SCOPED_TRACE(testData.debugString());
 
     createDuckDbTable(vectors);
-    auto tempDirectory = exec::test::TempDirectoryPath::create();
+    auto tempDirectory = TempDirectoryPath::create();
     core::PlanNodeId aggrNodeId;
     TestScopedSpillInjection scopedSpillInjection(100);
     auto task =
@@ -1817,11 +1808,12 @@ TEST_F(AggregationTest, outputBatchSizeCheckWithSpillForOrderedAggr) {
             .config(
                 QueryConfig::kMaxOutputBatchRows,
                 std::to_string(testData.maxOutputRows))
-            .plan(PlanBuilder()
-                      .values(vectors)
-                      .singleAggregation({"c0"}, {"array_agg(c1 order by c1)"})
-                      .capturePlanNodeId(aggrNodeId)
-                      .planNode())
+            .plan(
+                PlanBuilder()
+                    .values(vectors)
+                    .singleAggregation({"c0"}, {"array_agg(c1 order by c1)"})
+                    .capturePlanNodeId(aggrNodeId)
+                    .planNode())
             .assertResults(
                 "SELECT c0, array_agg(c1 order by c1) FROM tmp GROUP BY 1");
     ASSERT_GT(toPlanStats(task->taskStats()).at(aggrNodeId).spilledBytes, 0);
@@ -1847,7 +1839,7 @@ TEST_F(AggregationTest, spillDuringOutputProcessing) {
   createDuckDbTable({input});
 
   const int numOutputRows = 5;
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  auto tempDirectory = TempDirectoryPath::create();
   core::PlanNodeId aggrNodeId;
   TestScopedSpillInjection scopedSpillInjection(100);
   auto task =
@@ -1863,11 +1855,12 @@ TEST_F(AggregationTest, spillDuringOutputProcessing) {
           .config(
               QueryConfig::kMaxOutputBatchRows, std::to_string(numOutputRows))
           .config(QueryConfig::kSpillNumPartitionBits, "0")
-          .plan(PlanBuilder()
-                    .values({input})
-                    .singleAggregation({"c0", "c1"}, {"max(c2)", "min(c3)"})
-                    .capturePlanNodeId(aggrNodeId)
-                    .planNode())
+          .plan(
+              PlanBuilder()
+                  .values({input})
+                  .singleAggregation({"c0", "c1"}, {"max(c2)", "min(c3)"})
+                  .capturePlanNodeId(aggrNodeId)
+                  .planNode())
           .assertResults(
               "SELECT c0, c1, max(c2), min(c3) FROM tmp GROUP BY 1, 2");
 
@@ -1943,11 +1936,12 @@ TEST_F(AggregationTest, outputBatchSizeCheckWithoutSpill) {
             .config(
                 QueryConfig::kMaxOutputBatchRows,
                 std::to_string(testData.maxOutputRows))
-            .plan(PlanBuilder()
-                      .values(inputs)
-                      .singleAggregation({"c0"}, {"array_agg(c1)"})
-                      .capturePlanNodeId(aggrNodeId)
-                      .planNode())
+            .plan(
+                PlanBuilder()
+                    .values(inputs)
+                    .singleAggregation({"c0"}, {"array_agg(c1)"})
+                    .capturePlanNodeId(aggrNodeId)
+                    .planNode())
             .assertResults("SELECT c0, array_agg(c1) FROM tmp GROUP BY 1");
 
     ASSERT_EQ(
@@ -1973,8 +1967,9 @@ DEBUG_ONLY_TEST_F(AggregationTest, minSpillableMemoryReservation) {
   createDuckDbTable(batches);
 
   for (int32_t minSpillableReservationPct : {5, 50, 100}) {
-    SCOPED_TRACE(fmt::format(
-        "minSpillableReservationPct: {}", minSpillableReservationPct));
+    SCOPED_TRACE(
+        fmt::format(
+            "minSpillableReservationPct: {}", minSpillableReservationPct));
 
     SCOPED_TESTVALUE_SET(
         "facebook::velox::exec::GroupingSet::addInputForActiveRows",
@@ -1991,7 +1986,7 @@ DEBUG_ONLY_TEST_F(AggregationTest, minSpillableMemoryReservation) {
                   currentUsedBytes * minSpillableReservationPct / 100);
             })));
 
-    auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto spillDirectory = TempDirectoryPath::create();
     auto task =
         AssertQueryBuilder(duckDbQueryRunner_)
             .spillDirectory(spillDirectory->getPath())
@@ -2003,10 +1998,11 @@ DEBUG_ONLY_TEST_F(AggregationTest, minSpillableMemoryReservation) {
             .config(
                 QueryConfig::kSpillableReservationGrowthPct,
                 std::to_string(minSpillableReservationPct + 1))
-            .plan(PlanBuilder()
-                      .values(batches)
-                      .singleAggregation({"c0"}, {"array_agg(c2)", "max(c3)"})
-                      .planNode())
+            .plan(
+                PlanBuilder()
+                    .values(batches)
+                    .singleAggregation({"c0"}, {"array_agg(c2)", "max(c3)"})
+                    .planNode())
             .assertResults(
                 "SELECT c0, array_agg(c2), max(c3) FROM tmp GROUP BY 1");
     OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
@@ -2034,18 +2030,19 @@ TEST_F(AggregationTest, distinctWithSpilling) {
 
   for (const auto& testParam : testParams) {
     createDuckDbTable(testParam.inputs);
-    auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto spillDirectory = TempDirectoryPath::create();
     core::PlanNodeId aggrNodeId;
     TestScopedSpillInjection scopedSpillInjection(100);
     auto task = AssertQueryBuilder(duckDbQueryRunner_)
                     .spillDirectory(spillDirectory->getPath())
                     .config(QueryConfig::kSpillEnabled, true)
                     .config(QueryConfig::kAggregationSpillEnabled, true)
-                    .plan(PlanBuilder()
-                              .values(testParam.inputs)
-                              .singleAggregation({"c0"}, {}, {})
-                              .capturePlanNodeId(aggrNodeId)
-                              .planNode())
+                    .plan(
+                        PlanBuilder()
+                            .values(testParam.inputs)
+                            .singleAggregation({"c0"}, {}, {})
+                            .capturePlanNodeId(aggrNodeId)
+                            .planNode())
                     .assertResults("SELECT distinct c0 FROM tmp");
 
     // Verify that spilling is not triggered.
@@ -2060,35 +2057,125 @@ TEST_F(AggregationTest, distinctWithSpilling) {
   }
 }
 
-TEST_F(AggregationTest, spillingForAggrsWithDistinct) {
-  auto vectors = makeVectors(rowType_, 100, 10);
+class DistinctAggregationTest : public AggregationTest,
+                                public testing::WithParamInterface<double> {
+ protected:
+  std::vector<RowVectorPtr> makeVectors(
+      const RowTypePtr& rowType,
+      size_t size,
+      int numVectors,
+      column_index_t keyChannel) {
+    std::vector<RowVectorPtr> vectors;
+    vectors.reserve(numVectors);
+    VectorFuzzer aggVectorfuzzer(
+        {.vectorSize = size, .nullRatio = GetParam()}, pool());
+    // Key column is always non-null.
+    VectorFuzzer keyVectorFuzzer({.vectorSize = size, .nullRatio = 0}, pool());
+
+    for (int32_t i = 0; i < numVectors; ++i) {
+      std::vector<VectorPtr> children;
+      children.reserve(rowType->children().size());
+
+      for (auto idx = 0; idx < rowType->children().size(); idx++) {
+        auto& vectorFuzzer =
+            idx == keyChannel ? keyVectorFuzzer : aggVectorfuzzer;
+        children.push_back(vectorFuzzer.fuzzFlat(rowType->childAt(idx)));
+      }
+
+      vectors.push_back(
+          std::make_shared<RowVector>(
+              pool(), rowType, nullptr, size, children));
+    }
+    return vectors;
+  }
+};
+
+TEST_P(DistinctAggregationTest, spillingForAggrsWithDistinct) {
+  auto vectors = makeVectors(rowType_, 100, 10, 1);
   createDuckDbTable(vectors);
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
   core::PlanNodeId aggrNodeId;
-  TestScopedSpillInjection scopedSpillInjection(100);
-  auto task =
-      AssertQueryBuilder(duckDbQueryRunner_)
-          .spillDirectory(spillDirectory->getPath())
-          .config(QueryConfig::kSpillEnabled, true)
-          .config(QueryConfig::kAggregationSpillEnabled, true)
-          .plan(PlanBuilder()
-                    .values(vectors)
-                    .singleAggregation({"c1"}, {"count(DISTINCT c0)"}, {})
-                    .capturePlanNodeId(aggrNodeId)
-                    .planNode())
-          .assertResults("SELECT c1, count(DISTINCT c0) FROM tmp GROUP BY c1");
-  // Verify that spilling is not triggered.
-  const auto& queryConfig = task->queryCtx()->queryConfig();
-  ASSERT_TRUE(queryConfig.spillEnabled());
-  ASSERT_TRUE(queryConfig.aggregationSpillEnabled());
-  ASSERT_EQ(toPlanStats(task->taskStats()).at(aggrNodeId).spilledBytes, 0);
-  OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
+
+  auto testPlan = [&](const core::PlanNodePtr& plan, const std::string& sql) {
+    TestScopedSpillInjection scopedSpillInjection(100);
+    auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                    .spillDirectory(spillDirectory->getPath())
+                    .config(QueryConfig::kSpillEnabled, "true")
+                    .config(QueryConfig::kAggregationSpillEnabled, "true")
+                    .plan(plan)
+                    .assertResults(sql);
+
+    auto taskStats = exec::toPlanStats(task->taskStats());
+    auto& stats = taskStats.at(aggrNodeId);
+    checkSpillStats(stats, true);
+    OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
+  };
+
+  // Single aggregate with single input scenario.
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .singleAggregation({"c1"}, {"count(DISTINCT c0)"}, {})
+                  .capturePlanNodeId(aggrNodeId)
+                  .planNode();
+  testPlan(plan, "SELECT c1, count(DISTINCT c0) FROM tmp GROUP BY c1");
+
+  // Single aggregate with multiple input scenario.
+  plan = PlanBuilder()
+             .values(vectors)
+             .singleAggregation({"c1"}, {"covar_pop(DISTINCT c5, c5)"}, {})
+             .capturePlanNodeId(aggrNodeId)
+             .planNode();
+  testPlan(plan, "SELECT c1, covar_pop(DISTINCT c5, c5) FROM tmp GROUP BY c1");
+
+  // Mixed test including multiple types of distinct aggregate functions.
+  plan = PlanBuilder()
+             .values(vectors)
+             .singleAggregation(
+                 {"c1"},
+                 {"min(c0)",
+                  "count(c2)",
+                  "count(DISTINCT c0)",
+                  "covar_pop(DISTINCT c5, c5)",
+                  "array_agg(c0 ORDER BY c0)"},
+                 {})
+             .capturePlanNodeId(aggrNodeId)
+             .planNode();
+  testPlan(
+      plan,
+      "SELECT c1, min(c0), count(c2), count(DISTINCT c0), covar_pop(DISTINCT c5, c5), array_agg(c0 ORDER BY c0) FROM tmp GROUP BY c1");
+
+  // Single aggregate with mixed column and constant inputs.
+  // Tests that constant inputs are properly filtered from the accumulator
+  // during spilling and spliced back during extraction.
+  plan = PlanBuilder()
+             .values(vectors)
+             .singleAggregation({"c1"}, {"covar_pop(DISTINCT c5, 1.0)"}, {})
+             .capturePlanNodeId(aggrNodeId)
+             .planNode();
+  testPlan(plan, "SELECT c1, covar_pop(DISTINCT c5, 1.0) FROM tmp GROUP BY c1");
+
+  // All-constant distinct inputs.
+  plan = PlanBuilder()
+             .values(vectors)
+             .singleAggregation({"c1"}, {"sum(DISTINCT 3)"}, {})
+             .capturePlanNodeId(aggrNodeId)
+             .planNode();
+  testPlan(plan, "SELECT c1, sum(DISTINCT 3) FROM tmp GROUP BY c1");
 }
 
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    DistinctAggregationTest,
+    DistinctAggregationTest,
+    ::testing::Values(0, 0.5, 1),
+    [](const testing::TestParamInfo<double>& info) {
+      int ratio = static_cast<int>(info.param * 100);
+      return fmt::format("nullRatio_{}", ratio);
+    });
+
 TEST_F(AggregationTest, spillingForAggrsWithSorting) {
   auto vectors = makeVectors(rowType_, 100, 10);
   createDuckDbTable(vectors);
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
 
   core::PlanNodeId aggrNodeId;
 
@@ -2289,7 +2376,7 @@ TEST_F(AggregationTest, spillPrefixSortOptimization) {
        0}};
 
   for (const auto& testData : testSettings) {
-    auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto spillDirectory = TempDirectoryPath::create();
 
     core::PlanNodeId aggrNodeId;
 
@@ -2317,16 +2404,22 @@ TEST_F(AggregationTest, spillPrefixSortOptimization) {
       checkSpillStats(stats, true);
       if (testData.expectedNumPrefixSortKeys > 0) {
         ASSERT_GE(
-            stats.customStats.at(PrefixSort::kNumPrefixSortKeys).sum,
+            stats.customStats.at(std::string(PrefixSort::kNumPrefixSortKeys))
+                .sum,
             testData.expectedNumPrefixSortKeys);
         ASSERT_EQ(
-            stats.customStats.at(PrefixSort::kNumPrefixSortKeys).max,
+            stats.customStats.at(std::string(PrefixSort::kNumPrefixSortKeys))
+                .max,
             testData.expectedNumPrefixSortKeys);
         ASSERT_EQ(
-            stats.customStats.at(PrefixSort::kNumPrefixSortKeys).min,
+            stats.customStats.at(std::string(PrefixSort::kNumPrefixSortKeys))
+                .min,
             testData.expectedNumPrefixSortKeys);
       } else {
-        ASSERT_EQ(stats.customStats.count(PrefixSort::kNumPrefixSortKeys), 0);
+        ASSERT_EQ(
+            stats.customStats.count(
+                std::string(PrefixSort::kNumPrefixSortKeys)),
+            0);
       }
       OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
     };
@@ -2350,6 +2443,52 @@ TEST_F(AggregationTest, spillPrefixSortOptimization) {
   }
 }
 
+TEST_F(AggregationTest, distinctWithProperPrefixPreGroupedKeys) {
+  std::vector<RowVectorPtr> vectors;
+  vectors.push_back(makeRowVector({
+      makeFlatVector<int64_t>({0, 0, 1, 1, 2}),
+      makeFlatVector<int64_t>({0, 1, 10, 11, 20}),
+  }));
+  createDuckDbTable(vectors);
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .aggregation(
+                      {"c0", "c1"},
+                      {"c0"},
+                      {},
+                      {},
+                      core::AggregationNode::Step::kSingle,
+                      false)
+                  .planNode();
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .assertResults("SELECT DISTINCT c0, c1 FROM tmp");
+}
+
+TEST_F(AggregationTest, distinctWithPreGroupedKeysAcrossBatches) {
+  std::vector<RowVectorPtr> vectors;
+  vectors.push_back(makeRowVector({
+      makeFlatVector<int64_t>({0, 0, 1, 1}),
+      makeFlatVector<int64_t>({0, 1, 10, 11}),
+  }));
+  vectors.push_back(makeRowVector({
+      makeFlatVector<int64_t>({1, 1, 2, 2}),
+      makeFlatVector<int64_t>({12, 13, 20, 21}),
+  }));
+  createDuckDbTable(vectors);
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .aggregation(
+                      {"c0", "c1"},
+                      {"c0"},
+                      {},
+                      {},
+                      core::AggregationNode::Step::kSingle,
+                      false)
+                  .planNode();
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .assertResults("SELECT DISTINCT c0, c1 FROM tmp");
+}
+
 TEST_F(AggregationTest, preGroupedAggregationWithSpilling) {
   std::vector<RowVectorPtr> vectors;
   int64_t val = 0;
@@ -2362,7 +2501,7 @@ TEST_F(AggregationTest, preGroupedAggregationWithSpilling) {
          makeFlatVector<int64_t>(10, [](auto row) { return row; })}));
   }
   createDuckDbTable(vectors);
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
   core::PlanNodeId aggrNodeId;
   TestScopedSpillInjection scopedSpillInjection(100);
   auto task =
@@ -2370,17 +2509,18 @@ TEST_F(AggregationTest, preGroupedAggregationWithSpilling) {
           .spillDirectory(spillDirectory->getPath())
           .config(QueryConfig::kSpillEnabled, true)
           .config(QueryConfig::kAggregationSpillEnabled, true)
-          .plan(PlanBuilder()
-                    .values(vectors)
-                    .aggregation(
-                        {"c0", "c1"},
-                        {"c0"},
-                        {"sum(c2)"},
-                        {},
-                        core::AggregationNode::Step::kSingle,
-                        false)
-                    .capturePlanNodeId(aggrNodeId)
-                    .planNode())
+          .plan(
+              PlanBuilder()
+                  .values(vectors)
+                  .aggregation(
+                      {"c0", "c1"},
+                      {"c0"},
+                      {"sum(c2)"},
+                      {},
+                      core::AggregationNode::Step::kSingle,
+                      false)
+                  .capturePlanNodeId(aggrNodeId)
+                  .planNode())
           .assertResults("SELECT c0, c1, sum(c2) FROM tmp GROUP BY c0, c1");
   auto stats = task->taskStats().pipelineStats;
   // Verify that spilling is not triggered.
@@ -2463,10 +2603,11 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringInputProcessing) {
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
 
-    auto tempDirectory = exec::test::TempDirectoryPath::create();
+    auto tempDirectory = TempDirectoryPath::create();
     auto queryCtx = core::QueryCtx::create(executor_.get());
-    queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-        queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
+    queryCtx->testingOverrideMemoryPool(
+        memory::memoryManager()->addRootPool(
+            queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
     auto expectedResult =
         AssertQueryBuilder(
             PlanBuilder()
@@ -2613,15 +2754,17 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringReserve) {
     batches.push_back(fuzzer.fuzzRow(rowType));
   }
 
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  auto tempDirectory = TempDirectoryPath::create();
   auto queryCtx = core::QueryCtx::create(executor_.get());
-  queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-      queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
+  queryCtx->testingOverrideMemoryPool(
+      memory::memoryManager()->addRootPool(
+          queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
   auto expectedResult =
-      AssertQueryBuilder(PlanBuilder()
-                             .values(batches)
-                             .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                             .planNode())
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values(batches)
+              .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+              .planNode())
           .queryCtx(queryCtx)
           .copyResults(pool_.get());
 
@@ -2666,10 +2809,11 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringReserve) {
           })));
 
   std::thread taskThread([&]() {
-    AssertQueryBuilder(PlanBuilder()
-                           .values(batches)
-                           .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                           .planNode())
+    AssertQueryBuilder(
+        PlanBuilder()
+            .values(batches)
+            .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+            .planNode())
         .queryCtx(queryCtx)
         .spillDirectory(tempDirectory->getPath())
         .config(QueryConfig::kSpillEnabled, true)
@@ -2725,7 +2869,7 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringAllocation) {
   for (const auto enableSpilling : enableSpillings) {
     SCOPED_TRACE(fmt::format("enableSpilling {}", enableSpilling));
 
-    auto tempDirectory = exec::test::TempDirectoryPath::create();
+    auto tempDirectory = TempDirectoryPath::create();
     auto queryCtx = core::QueryCtx::create(executor_.get());
     queryCtx->testingOverrideMemoryPool(
         memory::memoryManager()->addRootPool(queryCtx->queryId(), kMaxBytes));
@@ -2851,10 +2995,11 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringOutputProcessing) {
   for (const auto enableSpilling : enableSpillings) {
     SCOPED_TRACE(fmt::format("enableSpilling {}", enableSpilling));
 
-    auto tempDirectory = exec::test::TempDirectoryPath::create();
+    auto tempDirectory = TempDirectoryPath::create();
     auto queryCtx = core::QueryCtx::create(executor_.get());
-    queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-        queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
+    queryCtx->testingOverrideMemoryPool(
+        memory::memoryManager()->addRootPool(
+            queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
     auto expectedResult =
         AssertQueryBuilder(
             PlanBuilder()
@@ -2996,7 +3141,7 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringNonReclaimableSection) {
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(fmt::format("testData {}", testData.debugString()));
 
-    auto tempDirectory = exec::test::TempDirectoryPath::create();
+    auto tempDirectory = TempDirectoryPath::create();
     auto queryCtx = core::QueryCtx::create(executor_.get());
     queryCtx->testingOverrideMemoryPool(
         memory::memoryManager()->addRootPool(queryCtx->queryId(), kMaxBytes));
@@ -3149,7 +3294,7 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimWithEmptyAggregationTable) {
   for (const auto enableSpilling : enableSpillings) {
     SCOPED_TRACE(fmt::format("enableSpilling {}", enableSpilling));
 
-    auto tempDirectory = exec::test::TempDirectoryPath::create();
+    auto tempDirectory = TempDirectoryPath::create();
     auto queryCtx = core::QueryCtx::create(executor_.get());
     queryCtx->testingOverrideMemoryPool(
         memory::memoryManager()->addRootPool(queryCtx->queryId(), kMaxBytes));
@@ -3460,6 +3605,99 @@ TEST_F(AggregationTest, distinctHang) {
       .assertResults("SELECT distinct c0, c1 FROM tmp");
 }
 
+TEST_F(AggregationTest, distinctWithConstantInput) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 1, 2, 2, 3}),
+      makeFlatVector<int64_t>({10, 20, 30, 40, 50}),
+      makeFlatVector<double>({0.1, 0.2, 0.3, 0.4, 0.5}),
+  });
+  createDuckDbTable({data});
+
+  auto plan =
+      PlanBuilder()
+          .values({data})
+          .singleAggregation(
+              {"c0"}, {"max_by(DISTINCT c1, 1)", "corr(DISTINCT 0.5, c2)"})
+          .planNode();
+
+  assertQuery(
+      plan,
+      "SELECT c0, max_by(DISTINCT c1, 1), corr(DISTINCT 0.5, c2) FROM tmp GROUP BY c0");
+
+  // All-constant distinct inputs.
+  plan = PlanBuilder()
+             .values({data})
+             .singleAggregation({"c0"}, {"sum(DISTINCT 3)"})
+             .planNode();
+
+  assertQuery(plan, "SELECT c0, sum(DISTINCT 3) FROM tmp GROUP BY c0");
+
+  // All-constant distinct inputs with a filter.
+  plan = PlanBuilder()
+             .values({data})
+             .project({"c0", "c1", "c2", "c1 > 1 as mask"})
+             .singleAggregation({"c0"}, {"sum(DISTINCT 3)"}, {"mask"})
+             .planNode();
+
+  assertQuery(
+      plan,
+      "SELECT c0, sum(DISTINCT 3) FILTER (WHERE c1 > 1) FROM tmp GROUP BY c0");
+
+  // All-constant distinct inputs together with column distinct inputs.
+  plan = PlanBuilder()
+             .values({data})
+             .singleAggregation({"c0"}, {"sum(DISTINCT 1)", "count(c1)"})
+             .planNode();
+
+  assertQuery(
+      plan, "SELECT c0, sum(DISTINCT 1), count(c1) FROM tmp GROUP BY c0");
+
+  // Global aggregation with constant distinct input.
+  plan = PlanBuilder()
+             .values({data})
+             .project({"c0", "c1", "c2", "c1 > 1 as mask"})
+             .singleAggregation(
+                 {},
+                 {"max_by(DISTINCT c1, 1)",
+                  "sum(DISTINCT 3)",
+                  "sum(DISTINCT 3)",
+                  "count(c1)"},
+                 {"", "", "mask", ""})
+             .planNode();
+
+  assertQuery(
+      plan,
+      "SELECT max_by(DISTINCT c1, 1), sum(DISTINCT 3), sum(DISTINCT 3) FILTER (WHERE c1 > 1), count(c1) FROM tmp");
+
+  // Mixed empty and non-empty groups.
+  plan = PlanBuilder()
+             .values({data})
+             .project({"c0", "c1 > 25 as mask"})
+             .singleAggregation({"c0"}, {"sum(DISTINCT 3)"}, {"mask"})
+             .planNode();
+  assertQuery(
+      plan,
+      "SELECT c0, sum(DISTINCT 3) FILTER (WHERE c1 > 25) FROM tmp GROUP BY c0");
+
+  // Group-by with all groups empty.
+  plan = PlanBuilder()
+             .values({data})
+             .project({"c0", "c1 > 100 as mask"})
+             .singleAggregation({"c0"}, {"sum(DISTINCT 3)"}, {"mask"})
+             .planNode();
+  assertQuery(
+      plan,
+      "SELECT c0, sum(DISTINCT 3) FILTER (WHERE c1 > 100) FROM tmp GROUP BY c0");
+
+  // Global with empty group.
+  plan = PlanBuilder()
+             .values({data})
+             .project({"c1 > 100 as mask"})
+             .singleAggregation({}, {"sum(DISTINCT 3)"}, {"mask"})
+             .planNode();
+  assertQuery(plan, "SELECT sum(DISTINCT 3) FILTER (WHERE c1 > 100) FROM tmp");
+}
+
 // Trigger memory pool allocation at HashAggregation::populateAggregateInputs by
 // aggregating null constant. Ensure the allocation happens outside of
 // HashAggregation's constructor.
@@ -3510,10 +3748,11 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimEmptyInput) {
         }
       }));
 
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  auto tempDirectory = TempDirectoryPath::create();
   auto queryCtx = core::QueryCtx::create(executor_.get());
-  queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-      queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
+  queryCtx->testingOverrideMemoryPool(
+      memory::memoryManager()->addRootPool(
+          queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
   core::PlanNodeId aggNodeId;
   auto task =
       AssertQueryBuilder(
@@ -3541,10 +3780,11 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimEmptyOutput) {
   auto batches = makeVectors(rowType, 100, 5);
 
   auto expectedResult =
-      AssertQueryBuilder(PlanBuilder()
-                             .values(batches)
-                             .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                             .planNode())
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values(batches)
+              .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+              .planNode())
           .copyResults(pool_.get());
 
   std::atomic_int numGetOutput{0};
@@ -3582,26 +3822,27 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimEmptyOutput) {
         }
       })));
 
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  auto tempDirectory = TempDirectoryPath::create();
   auto queryCtx = core::QueryCtx::create(executor_.get());
-  queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-      queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
+  queryCtx->testingOverrideMemoryPool(
+      memory::memoryManager()->addRootPool(
+          queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
   core::PlanNodeId aggNodeId;
-  auto task =
-      AssertQueryBuilder(PlanBuilder()
-                             .values(batches)
-                             .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                             .capturePlanNodeId(aggNodeId)
-                             .planNode())
-          .spillDirectory(tempDirectory->getPath())
-          .queryCtx(queryCtx)
-          .config(QueryConfig::kSpillEnabled, true)
-          .config(QueryConfig::kAggregationSpillEnabled, true)
-          // Set the output query configs to ensure fetch the result in one
-          // output batch.
-          .config(QueryConfig::kPreferredOutputBatchBytes, 1UL << 30)
-          .config(QueryConfig::kMaxOutputBatchRows, 1024)
-          .assertResults(expectedResult);
+  auto task = AssertQueryBuilder(
+                  PlanBuilder()
+                      .values(batches)
+                      .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                      .capturePlanNodeId(aggNodeId)
+                      .planNode())
+                  .spillDirectory(tempDirectory->getPath())
+                  .queryCtx(queryCtx)
+                  .config(QueryConfig::kSpillEnabled, true)
+                  .config(QueryConfig::kAggregationSpillEnabled, true)
+                  // Set the output query configs to ensure fetch the result in
+                  // one output batch.
+                  .config(QueryConfig::kPreferredOutputBatchBytes, 1UL << 30)
+                  .config(QueryConfig::kMaxOutputBatchRows, 1024)
+                  .assertResults(expectedResult);
   // Since the spilling is triggered after the aggregation operator has produced
   // all the output, we don't expect any spilled data.
   auto taskStats = exec::toPlanStats(task->taskStats());
@@ -3621,7 +3862,7 @@ TEST_F(AggregationTest, maxSpillBytes) {
                         .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
                         .capturePlanNodeId(aggregationNodeId)
                         .planNode();
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
 
   struct {
     int32_t maxSpilledBytes;
@@ -3678,7 +3919,7 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimFromAggregation) {
           testingRunArbitration(op->pool());
         })));
 
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto spillDirectory = TempDirectoryPath::create();
     core::PlanNodeId aggrNodeId;
     auto task =
         AssertQueryBuilder(duckDbQueryRunner_)
@@ -3688,11 +3929,12 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimFromAggregation) {
             .config(
                 core::QueryConfig::kMaxSpillRunRows,
                 std::to_string(maxSpillRunRows))
-            .plan(PlanBuilder()
-                      .values(vectors)
-                      .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                      .capturePlanNodeId(aggrNodeId)
-                      .planNode())
+            .plan(
+                PlanBuilder()
+                    .values(vectors)
+                    .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                    .capturePlanNodeId(aggrNodeId)
+                    .planNode())
             .assertResults(
                 "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
     auto taskStats = exec::toPlanStats(task->taskStats());
@@ -3702,7 +3944,8 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimFromAggregation) {
     // reporting in unit test.
     ASSERT_GE(
         planStats
-            .customStats[memory::SharedArbitrator::kMemoryArbitrationWallNanos]
+            .customStats[std::string(
+                memory::SharedArbitrator::kMemoryArbitrationWallNanos)]
             .sum,
         0);
     task.reset();
@@ -3732,7 +3975,7 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimFromDistinctAggregation) {
           testingRunArbitration(op->pool());
         })));
 
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto spillDirectory = TempDirectoryPath::create();
     core::PlanNodeId aggrNodeId;
     auto task = AssertQueryBuilder(duckDbQueryRunner_)
                     .spillDirectory(spillDirectory->getPath())
@@ -3741,11 +3984,12 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimFromDistinctAggregation) {
                     .config(
                         core::QueryConfig::kMaxSpillRunRows,
                         std::to_string(maxSpillRunRows))
-                    .plan(PlanBuilder()
-                              .values(vectors)
-                              .singleAggregation({"c0"}, {})
-                              .capturePlanNodeId(aggrNodeId)
-                              .planNode())
+                    .plan(
+                        PlanBuilder()
+                            .values(vectors)
+                            .singleAggregation({"c0"}, {})
+                            .capturePlanNodeId(aggrNodeId)
+                            .planNode())
                     .assertResults("SELECT distinct c0 FROM tmp");
     auto taskStats = exec::toPlanStats(task->taskStats());
     auto& planStats = taskStats.at(aggrNodeId);
@@ -3758,7 +4002,7 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimFromDistinctAggregation) {
 DEBUG_ONLY_TEST_F(AggregationTest, reclaimFromAggregationOnNoMoreInput) {
   std::vector<RowVectorPtr> vectors = createVectors(8, rowType_, fuzzerOpts_);
   createDuckDbTable(vectors);
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  const auto spillDirectory = TempDirectoryPath::create();
 
   std::atomic<bool> injectNoMoreInputOnce{true};
   SCOPED_TESTVALUE_SET(
@@ -3780,10 +4024,11 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimFromAggregationOnNoMoreInput) {
             .config(core::QueryConfig::kSpillEnabled, true)
             .config(core::QueryConfig::kAggregationSpillEnabled, true)
             .maxDrivers(1)
-            .plan(PlanBuilder()
-                      .values(vectors)
-                      .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                      .planNode())
+            .plan(
+                PlanBuilder()
+                    .values(vectors)
+                    .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                    .planNode())
             .assertResults(
                 "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
     auto stats = task->taskStats().pipelineStats;
@@ -3803,7 +4048,7 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimFromAggregationDuringOutput) {
   }
 
   createDuckDbTable(vectors);
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  const auto spillDirectory = TempDirectoryPath::create();
   std::atomic_int numInputs{0};
   SCOPED_TESTVALUE_SET(
       "facebook::velox::exec::Driver::runInternal::getOutput",
@@ -3825,10 +4070,11 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimFromAggregationDuringOutput) {
             .config(core::QueryConfig::kPreferredOutputBatchRows, numRows / 10)
             .maxDrivers(1)
             //.queryCtx(aggregationQueryCtx)
-            .plan(PlanBuilder()
-                      .values(vectors)
-                      .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                      .planNode())
+            .plan(
+                PlanBuilder()
+                    .values(vectors)
+                    .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                    .planNode())
             .assertResults(
                 "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
     auto stats = task->taskStats().pipelineStats;
@@ -3840,17 +4086,18 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimFromAggregationDuringOutput) {
 TEST_F(AggregationTest, reclaimFromCompletedAggregation) {
   std::vector<RowVectorPtr> vectors = createVectors(8, rowType_, fuzzerOpts_);
   createDuckDbTable(vectors);
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  const auto spillDirectory = TempDirectoryPath::create();
 
   folly::EventCount arbitrationWait;
   std::atomic_bool arbitrationWaitFlag{true};
   std::thread aggregationThread([&]() {
     auto task =
         AssertQueryBuilder(duckDbQueryRunner_)
-            .plan(PlanBuilder()
-                      .values(vectors)
-                      .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                      .planNode())
+            .plan(
+                PlanBuilder()
+                    .values(vectors)
+                    .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                    .planNode())
             .assertResults(
                 "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
     waitForTaskCompletion(task.get());
@@ -3864,6 +4111,108 @@ TEST_F(AggregationTest, reclaimFromCompletedAggregation) {
   waitForAllTasksToBeDeleted();
 }
 
+DEBUG_ONLY_TEST_F(AggregationTest, reclaimWithCompact) {
+  const int numInputs = 8;
+  std::vector<RowVectorPtr> vectors =
+      createVectors(numInputs, rowType_, fuzzerOpts_);
+  createDuckDbTable(vectors);
+
+  struct {
+    bool spillEnabled;
+    bool compactionEnabled;
+    uint64_t compactBytes;
+    bool expectedReclaimable;
+    bool expectSpill;
+
+    std::string debugString() const {
+      return fmt::format(
+          "spillEnabled {}, compactionEnabled {}, compactBytes {},"
+          " expectedReclaimable {}, expectSpill {}",
+          spillEnabled,
+          compactionEnabled,
+          compactBytes,
+          expectedReclaimable,
+          expectSpill);
+    }
+  } testSettings[] = {
+      // Spill enabled, compaction enabled, compaction frees enough bytes -> no
+      // spill.
+      {true, true, 1UL << 30, true, false},
+      // Spill enabled, compaction enabled, compaction frees 0 bytes -> spill.
+      {true, true, 0, true, true},
+      // Spill enabled, compaction disabled -> reclaimable via spill.
+      {true, false, 0, true, true},
+      // Spill disabled, compaction enabled -> non-reclaimable (no compactable
+      // aggregates with array_agg).
+      {false, true, 0, false, false},
+      // Spill disabled, compaction disabled -> non-reclaimable.
+      {false, false, 0, false, false},
+  };
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    std::atomic_int inputCount{0};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::HashAggregation::reclaim::compact",
+        std::function<void(uint64_t*)>(([&](uint64_t* compactedBytes) {
+          *compactedBytes = testData.compactBytes;
+        })));
+
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::addInput",
+        std::function<void(exec::Operator*)>(([&](exec::Operator* op) {
+          if (op->operatorCtx()->operatorType() != "Aggregation") {
+            return;
+          }
+          if (++inputCount != numInputs / 2) {
+            return;
+          }
+          ASSERT_EQ(op->canReclaim(), testData.expectedReclaimable);
+          if (testData.expectedReclaimable) {
+            testingRunArbitration(op->pool());
+          } else {
+            // When neither spill nor compaction can reclaim memory, calling
+            // reclaim() directly would fail the canReclaim() check. Under real
+            // memory pressure this operator would cause the query to OOM.
+            memory::MemoryReclaimer::Stats reclaimStats;
+            VELOX_ASSERT_THROW(op->reclaim(0, reclaimStats), "");
+          }
+        })));
+
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    core::PlanNodeId aggrNodeId;
+    AssertQueryBuilder queryBuilder(duckDbQueryRunner_);
+    queryBuilder.config(
+        core::QueryConfig::kAggregationMemoryCompactionReclaimEnabled,
+        testData.compactionEnabled);
+    if (testData.spillEnabled) {
+      queryBuilder.spillDirectory(spillDirectory->getPath())
+          .config(core::QueryConfig::kSpillEnabled, true)
+          .config(core::QueryConfig::kAggregationSpillEnabled, true);
+    }
+    auto task =
+        queryBuilder
+            .plan(
+                PlanBuilder()
+                    .values(vectors)
+                    .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                    .capturePlanNodeId(aggrNodeId)
+                    .planNode())
+            .assertResults(
+                "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
+    auto taskStats = exec::toPlanStats(task->taskStats());
+    auto& planStats = taskStats.at(aggrNodeId);
+    if (testData.expectSpill) {
+      ASSERT_GT(planStats.spilledBytes, 0);
+    } else {
+      ASSERT_EQ(planStats.spilledBytes, 0);
+    }
+    task.reset();
+    waitForAllTasksToBeDeleted();
+  }
+}
+
 TEST_F(AggregationTest, ignoreNullKeys) {
   // Some keys are null.
   auto data = makeRowVector({
@@ -4029,7 +4378,9 @@ TEST_F(AggregationTest, destroyAfterPartialInitialization) {
       false, // hasNext
       false, // isJoinBuild
       false, // hasProbedFlag
+      false, // hasCountFlag
       false, // hasNormalizedKeys
+      false, // useListRowIndex
       pool());
   const auto rowColumn = rows.columnAt(0);
   agg.setOffsets(
@@ -4138,4 +4489,100 @@ TEST_F(AggregationTest, nanKeys) {
       {makeRowVector({c0, c1}), c1},
       {makeRowVector({e0, e1}), e1});
 }
+
+TEST_F(AggregationTest, keysProvideCustomComparison) {
+  // Columns reused across test cases.
+  auto c0 = makeFlatVector<int64_t>(
+      {0, 1, 256, 257, 512, 513},
+      velox::test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON());
+  auto c1 = makeFlatVector<int32_t>({1, 2, 1, 2, 1, 2});
+  // Expected result columns reused across test cases. A deduplicated version of
+  // c0 and c1.
+  auto e0 = makeFlatVector<int64_t>(
+      {0, 1}, velox::test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON());
+  auto e1 = makeFlatVector<int32_t>({1, 2});
+
+  auto testDistinctAgg = [&](const std::vector<std::string>& aggKeys,
+                             const std::vector<VectorPtr>& inputCols,
+                             const std::vector<VectorPtr>& expectedCols) {
+    auto plan = PlanBuilder()
+                    .values({makeRowVector(inputCols)})
+                    .singleAggregation(aggKeys, {}, {})
+                    .planNode();
+    AssertQueryBuilder(plan).assertResults(makeRowVector(expectedCols));
+  };
+
+  // Test with a primitive type key.
+  testDistinctAgg({"c0"}, {c0}, {e0});
+  // Multiple key columns.
+  testDistinctAgg({"c0", "c1"}, {c0, c1}, {e0, e1});
+
+  // Test with a complex type key.
+  testDistinctAgg({"c0"}, {makeRowVector({c0, c1})}, {makeRowVector({e0, e1})});
+  // Multiple key columns.
+  testDistinctAgg(
+      {"c0", "c1"},
+      {makeRowVector({c0, c1}), c1},
+      {makeRowVector({e0, e1}), e1});
+}
+
+// Test that aggregation spill uses the aggregation_spill_file_create_config
+// when set, and other spillable operators use the default
+// spill_file_create_config.
+DEBUG_ONLY_TEST_F(AggregationTest, aggregationSpillFileCreateConfig) {
+  auto vectors = makeVectors(rowType_, 32, 100);
+  createDuckDbTable(vectors);
+
+  auto tempDirectory = TempDirectoryPath::create();
+
+  std::atomic_bool aggregationConfigVerified{false};
+  std::atomic_bool defaultConfigVerified{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::isBlocked",
+      std::function<void(exec::Operator*)>([&](exec::Operator* op) {
+        const auto* spillConfig = op->testingSpillConfig();
+        if (spillConfig == nullptr) {
+          return;
+        }
+        const auto& opType = op->operatorType();
+        if (opType == "Aggregation" || opType == "PartialAggregation") {
+          // Aggregation operators should use
+          // aggregation_spill_file_create_config.
+          ASSERT_EQ(spillConfig->fileCreateConfig, "test_aggregation_config")
+              << "Operator: " << opType;
+          aggregationConfigVerified = true;
+        } else {
+          // Other spillable operators (e.g., OrderBy) should use the default
+          // spill_file_create_config.
+          ASSERT_EQ(spillConfig->fileCreateConfig, "test_default_config")
+              << "Operator: " << opType;
+          defaultConfigVerified = true;
+        }
+      }));
+
+  // Build a plan with aggregation and orderBy. Aggregation operators should use
+  // aggregation_spill_file_create_config and orderBy should use the default
+  // spill_file_create_config.
+  TestScopedSpillInjection scopedSpillInjection(100);
+  AssertQueryBuilder(duckDbQueryRunner_)
+      .spillDirectory(tempDirectory->getPath())
+      .config(QueryConfig::kSpillEnabled, true)
+      .config(QueryConfig::kAggregationSpillEnabled, true)
+      .config(QueryConfig::kOrderBySpillEnabled, true)
+      .config(QueryConfig::kSpillFileCreateConfig, "test_default_config")
+      .config(
+          QueryConfig::kAggregationSpillFileCreateConfig,
+          "test_aggregation_config")
+      .plan(
+          PlanBuilder()
+              .values(vectors)
+              .singleAggregation({"c0", "c1"}, {"sum(c2)"})
+              .orderBy({"c0 ASC NULLS LAST"}, false)
+              .planNode())
+      .assertResults(
+          "SELECT c0, c1, sum(c2) FROM tmp GROUP BY c0, c1 ORDER BY c0 ASC NULLS LAST");
+
+  ASSERT_TRUE(aggregationConfigVerified.load());
+  ASSERT_TRUE(defaultConfigVerified.load());
+}
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/AssertQueryBuilderTest.cpp b/velox/exec/tests/AssertQueryBuilderTest.cpp
index 6ae70783f7a..e7155436c24 100644
--- a/velox/exec/tests/AssertQueryBuilderTest.cpp
+++ b/velox/exec/tests/AssertQueryBuilderTest.cpp
@@ -20,6 +20,7 @@
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
 namespace facebook::velox::exec::test {
+using namespace facebook::velox::common::testutil;
 
 class AssertQueryBuilderTest : public HiveConnectorTestBase {};
 
@@ -94,8 +95,11 @@ TEST_F(AssertQueryBuilderTest, hiveSplits) {
 
   // Single leaf node with two splits.
   auto makeSplits = [](const std::string& path, size_t numRepeats = 1) {
-    std::vector<std::shared_ptr<connector::ConnectorSplit>> splits(
-        numRepeats, makeHiveConnectorSplit(path));
+    std::vector<std::shared_ptr<connector::ConnectorSplit>> splits;
+    splits.reserve(numRepeats);
+    for (size_t i = 0; i < numRepeats; ++i) {
+      splits.emplace_back(makeHiveConnectorSplit(path));
+    }
     return splits;
   };
 
diff --git a/velox/exec/tests/AssignUniqueIdTest.cpp b/velox/exec/tests/AssignUniqueIdTest.cpp
index 6a34e3bc141..762dbdcbe14 100644
--- a/velox/exec/tests/AssignUniqueIdTest.cpp
+++ b/velox/exec/tests/AssignUniqueIdTest.cpp
@@ -21,7 +21,7 @@
 #include "velox/exec/tests/utils/QueryAssertions.h"
 
 namespace facebook::velox::exec {
-
+using namespace facebook::velox::common::testutil;
 using namespace facebook::velox::test;
 using namespace facebook::velox::exec::test;
 
@@ -200,22 +200,32 @@ TEST_F(AssignUniqueIdTest, barrier) {
                   .assignUniqueId("row_number")
                   .project({"c0", "c1", "row_number"})
                   .planNode();
+  struct {
+    bool hasBarrier;
+    bool serialExecution;
 
-  for (const auto barrierExecution : {false, true}) {
-    SCOPED_TRACE(fmt::format("barrierExecution {}", barrierExecution));
+    std::string toString() const {
+      return fmt::format(
+          "hasBarrier: {}, serialExecution: {}", hasBarrier, serialExecution);
+    }
+  } testSettings[] = {
+      {false, false}, {false, true}, {true, false}, {true, true}};
 
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.toString());
     std::shared_ptr<Task> task;
     auto result = AssertQueryBuilder(plan)
                       .splits(makeHiveConnectorSplits(tempFiles))
-                      .serialExecution(true)
-                      .barrierExecution(barrierExecution)
+                      .serialExecution(testData.serialExecution)
+                      .maxDrivers(testData.serialExecution ? 1 : 3)
+                      .barrierExecution(testData.hasBarrier)
                       .copyResults(pool(), task);
     auto results = split(result, numSplits);
 
     verifyUniqueId(vectors, results);
 
     const auto taskStats = task->taskStats();
-    ASSERT_EQ(taskStats.numBarriers, barrierExecution ? numSplits : 0);
+    ASSERT_EQ(taskStats.numBarriers, testData.hasBarrier ? numSplits : 0);
     ASSERT_EQ(taskStats.numFinishedSplits, numSplits);
   }
 }
diff --git a/velox/exec/tests/AsyncConnectorTest.cpp b/velox/exec/tests/AsyncConnectorTest.cpp
index 3904a610fd6..d2f5261c286 100644
--- a/velox/exec/tests/AsyncConnectorTest.cpp
+++ b/velox/exec/tests/AsyncConnectorTest.cpp
@@ -13,8 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <folly/experimental/FunctionScheduler.h>
+#include <folly/executors/FunctionScheduler.h>
 #include "velox/connectors/Connector.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
@@ -60,7 +61,8 @@ class TestSplit : public connector::ConnectorSplit {
       return ContinueFuture::makeEmpty();
     }
 
-    auto [promise, future] = makeVeloxContinuePromiseContract();
+    auto [promise, future] =
+        makeVeloxContinuePromiseContract("TestSplit::touch");
 
     promise_ = std::move(promise);
     scheduler_.addFunction(
@@ -126,7 +128,7 @@ class TestDataSource : public connector::DataSource {
     return 0;
   }
 
-  std::unordered_map<std::string, RuntimeCounter> runtimeStats() override {
+  std::unordered_map<std::string, RuntimeMetric> getRuntimeStats() override {
     return {};
   }
 
@@ -186,11 +188,12 @@ class AsyncConnectorTest : public OperatorTestBase {
             std::unordered_map<std::string, std::string>()),
         nullptr,
         nullptr);
-    connector::registerConnector(testConnector);
+    connector::ConnectorRegistry::global().insert(
+        testConnector->connectorId(), testConnector);
   }
 
   void TearDown() override {
-    connector::unregisterConnector(kTestConnectorId);
+    connector::ConnectorRegistry::global().erase(kTestConnectorId);
     OperatorTestBase::TearDown();
   }
 };
diff --git a/velox/exec/tests/CMakeLists.txt b/velox/exec/tests/CMakeLists.txt
index 010f343dea0..bda084e8ad9 100644
--- a/velox/exec/tests/CMakeLists.txt
+++ b/velox/exec/tests/CMakeLists.txt
@@ -19,6 +19,11 @@ add_executable(
   AggregateCompanionSignaturesTest.cpp
   DummyAggregateFunction.cpp
 )
+velox_add_test_headers(
+  aggregate_companion_functions_test
+  DummyAggregateFunction.h
+  PrestoQueryRunnerIntermediateTypeTransformTestBase.h
+)
 
 add_test(
   NAME aggregate_companion_functions_test
@@ -36,116 +41,123 @@ target_link_libraries(
   GTest::gtest_main
 )
 
-add_executable(
-  velox_exec_test
+# Sources are ordered via greedy bin-packing by measured EC2 execution time.
+# With VELOX_TESTS_PER_GROUP=10, CMake takes files positionally in batches of
+# 10 (files 1-10 = group0, 11-20 = group1, etc.).
+#
+# Measured per-file EC2 timings (sequential, 8-core, 30GB):
+#   IndexLookupJoinTest 783s, MultiFragmentTest 599s,
+#   HashJoinTestExtra ~585s, SpillerTest 584s, HashJoinTest ~575s,
+#   TableWriterTest 225s, TableScanTest 189s, IndexLookupJoinTestExtra 188s,
+#   MergeJoinTest 111s, AggregationTest 105s, OutputBufferManagerTest 98s,
+#   ScaleWriterLocalPartitionTest 96s, OrderByTest 71s, TopNRowNumberTest 64s,
+#   HashTableTest 60s, StreamingAggregationTest 58s, ExchangeClientTest 54s,
+#   RowNumberTest 42s.
+#
+# Max group ~784s (bounded by IndexLookupJoinTest.cpp).
+set(
+  VELOX_EXEC_TEST_SOURCES
+  # group0 (~784s): IndexLookupJoinTest 783 + 9 lightweight
+  IndexLookupJoinTest.cpp
+  ConcatFilesSpillMergeStreamTest.cpp
+  MixedUnionWithTableScanTest.cpp
+  MemoryReclaimerTest.cpp
+  EnforceDistinctTest.cpp
+  TraceUtilTest.cpp
+  HashPartitionFunctionTest.cpp
+  SpatialIndexTest.cpp
+  ValuesTest.cpp
+  ParallelProjectTest.cpp
+  # group1 (~599s): MultiFragmentTest 599 + 9 lightweight
+  MultiFragmentTest.cpp
+  EnforceSingleRowTest.cpp
+  FilterToExpressionTest.cpp
+  ScaledScanControllerTest.cpp
+  HilbertIndexTest.cpp
+  OperatorTraceTest.cpp
+  LimitTest.cpp
+  SplitListenerTest.cpp
   AddressableNonNullValueListTest.cpp
-  AggregationTest.cpp
-  AggregateFunctionRegistryTest.cpp
   ArrowStreamTest.cpp
-  AssignUniqueIdTest.cpp
-  AsyncConnectorTest.cpp
-  ConcatFilesSpillMergeStreamTest.cpp
-  ContainerRowSerdeTest.cpp
+  # group2 (~585s): HashJoinTestExtra ~585 + 9 lightweight
+  HashJoinTestExtra.cpp
+  AggregateFunctionRegistryTest.cpp
+  RoundRobinPartitionFunctionTest.cpp
   ColumnStatsCollectorTest.cpp
-  CustomJoinTest.cpp
-  EnforceSingleRowTest.cpp
-  ExchangeClientTest.cpp
+  MixedUnionTest.cpp
   ExpandTest.cpp
-  FilterProjectTest.cpp
-  FilterToExpressionTest.cpp
   FunctionResolutionTest.cpp
-  HashBitRangeTest.cpp
-  HashJoinBridgeTest.cpp
-  HashJoinTest.cpp
-  HashPartitionFunctionTest.cpp
-  HashTableTest.cpp
-  IndexLookupJoinTest.cpp
-  LimitTest.cpp
-  LocalPartitionTest.cpp
-  Main.cpp
-  MarkDistinctTest.cpp
-  MemoryReclaimerTest.cpp
-  MergeJoinTest.cpp
-  MergeTest.cpp
-  MergerTest.cpp
-  MultiFragmentTest.cpp
-  NestedLoopJoinTest.cpp
-  OrderByTest.cpp
-  OperatorTraceTest.cpp
-  OutputBufferManagerTest.cpp
-  ParallelProjectTest.cpp
+  SpillStatsTest.cpp
+  MarkSortedTest.cpp
   PartitionedOutputTest.cpp
-  PlanNodeSerdeTest.cpp
-  PlanNodeToStringTest.cpp
+  # group3 (~584s): SpillerTest 584 + 9 lightweight
+  SpillerTest.cpp
   PlanNodeToSummaryStringTest.cpp
+  CountingJoinTest.cpp
+  CustomJoinTest.cpp
+  TaskListenerTest.cpp
+  SplitTest.cpp
+  SqlTest.cpp
+  WindowFunctionRegistryTest.cpp
+  StreamingEnforceDistinctTest.cpp
+  HashBitRangeTest.cpp
+  # group4 (~575s): HashJoinTest ~575 + 9 lightweight
+  HashJoinTest.cpp
+  SpillTest.cpp
+  WindowTest.cpp
   PrefixSortTest.cpp
+  MergerTest.cpp
+  LocalPartitionTest.cpp
   PrintPlanWithStatsTest.cpp
   ProbeOperatorStateTest.cpp
-  TraceUtilTest.cpp
-  RoundRobinPartitionFunctionTest.cpp
-  RowContainerTest.cpp
-  RowNumberTest.cpp
-  ScaledScanControllerTest.cpp
-  ScaleWriterLocalPartitionTest.cpp
-  SortBufferTest.cpp
-  SpillerTest.cpp
-  SpillTest.cpp
-  SplitListenerTest.cpp
-  SplitTest.cpp
-  SqlTest.cpp
-  StreamingAggregationTest.cpp
-  TableScanTest.cpp
+  MarkDistinctTest.cpp
+  MergeTest.cpp
+  # group5 (~445s): TableWriterTest 225 + OutputBufMgr 98
+  # + TopNRowNumber 64 + StreamingAgg 58
   TableWriterTest.cpp
-  TaskListenerTest.cpp
-  ThreadDebugInfoTest.cpp
+  OutputBufferManagerTest.cpp
   TopNRowNumberTest.cpp
+  StreamingAggregationTest.cpp
+  ContainerRowSerdeTest.cpp
+  RowContainerTest.cpp
   TopNTest.cpp
+  WriterFuzzerUtilTest.cpp
+  PlanNodeStatsTest.cpp
+  ThreadDebugInfoTest.cpp
+  # group6 (~467s): TableScanTest 189 + AggregationTest 105
+  # + OrderBy 71 + HashTable 60 + RowNumber 42
+  TableScanTest.cpp
+  AggregationTest.cpp
+  OrderByTest.cpp
+  HashTableCacheTest.cpp
+  HashTableTest.cpp
+  RowNumberTest.cpp
   UnnestTest.cpp
-  UnorderedStreamReaderTest.cpp
-  ValuesTest.cpp
+  PlanNodeSerdeTest.cpp
+  HashJoinBridgeTest.cpp
+  SortBufferTest.cpp
   VectorHasherTest.cpp
-  WindowFunctionRegistryTest.cpp
-  WindowTest.cpp
-  WriterFuzzerUtilTest.cpp
-)
-
-if(VELOX_ENABLE_GEO)
-  target_sources(velox_exec_test PRIVATE SpatialJoinTest.cpp)
-endif()
-
-add_executable(
-  velox_exec_infra_test
-  AssertQueryBuilderTest.cpp
-  DriverTest.cpp
-  FunctionSignatureBuilderTest.cpp
-  GroupedExecutionTest.cpp
-  Main.cpp
-  OperatorUtilsTest.cpp
-  PlanBuilderTest.cpp
-  PrestoQueryRunnerTest.cpp
-  QueryAssertionsTest.cpp
-  TaskTest.cpp
-  TreeOfLosersTest.cpp
-)
-
-add_test(NAME velox_exec_test COMMAND velox_exec_test WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-
-# TODO: Revert back to 3000 once is fixed.
-# https://github.com/facebookincubator/velox/issues/13879
-set_tests_properties(velox_exec_test PROPERTIES TIMEOUT 6000)
-
-add_test(
-  NAME velox_exec_infra_test
-  COMMAND velox_exec_infra_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+  # group7 (~449s): IndexLookupJoinTestExtra 188
+  # + MergeJoin 111 + ScaleWriter 96 + Exchange 54
+  IndexLookupJoinTestExtra.cpp
+  MergeJoinTest.cpp
+  ScaleWriterLocalPartitionTest.cpp
+  ExchangeClientTest.cpp
+  NestedLoopJoinTest.cpp
+  UnorderedStreamReaderTest.cpp
+  PlanNodeToStringTest.cpp
+  AssignUniqueIdTest.cpp
+  FilterProjectTest.cpp
+  AsyncConnectorTest.cpp
 )
 
-target_link_libraries(
-  velox_exec_test
+set(
+  VELOX_EXEC_TEST_DEPS
   velox_aggregates
   velox_dwio_common
   velox_dwio_common_exception
   velox_dwio_common_test_utils
+  velox_dwio_orc_reader
   velox_dwio_parquet_reader
   velox_dwio_parquet_writer
   velox_exec
@@ -161,6 +173,7 @@ target_link_libraries(
   velox_test_util
   velox_type
   velox_type_test_lib
+  velox_trace
   velox_vector
   velox_vector_fuzzer
   velox_writer_fuzzer
@@ -170,7 +183,6 @@ target_link_libraries(
   Boost::date_time
   Boost::filesystem
   Boost::program_options
-  Boost::regex
   Boost::thread
   Boost::system
   GTest::gtest
@@ -182,6 +194,45 @@ target_link_libraries(
   fmt::fmt
 )
 
+velox_add_grouped_tests(
+  PREFIX velox_exec_test
+  SOURCES ${VELOX_EXEC_TEST_SOURCES}
+  DEPS ${VELOX_EXEC_TEST_DEPS}
+  EXTRA_SOURCES Main.cpp
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+if(VELOX_ENABLE_GEO)
+  add_executable(velox_exec_SpatialJoinTest SpatialJoinTest.cpp Main.cpp)
+  add_test(
+    NAME velox_exec_SpatialJoinTest
+    COMMAND velox_exec_SpatialJoinTest
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+  )
+  target_link_libraries(velox_exec_SpatialJoinTest ${VELOX_EXEC_TEST_DEPS})
+endif()
+
+add_executable(
+  velox_exec_infra_test
+  AssertQueryBuilderTest.cpp
+  DriverTest.cpp
+  FunctionSignatureBuilderTest.cpp
+  GroupedExecutionTest.cpp
+  Main.cpp
+  OperatorUtilsTest.cpp
+  PlanBuilderTest.cpp
+  PrestoQueryRunnerTest.cpp
+  QueryAssertionsTest.cpp
+  TaskTest.cpp
+  TreeOfLosersTest.cpp
+)
+
+add_test(
+  NAME velox_exec_infra_test
+  COMMAND velox_exec_infra_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
 target_link_libraries(
   velox_exec_infra_test
   velox_dwio_common
@@ -208,7 +259,6 @@ target_link_libraries(
   Boost::date_time
   Boost::filesystem
   Boost::program_options
-  Boost::regex
   Boost::thread
   Boost::system
   GTest::gtest
@@ -220,22 +270,23 @@ target_link_libraries(
   fmt::fmt
 )
 
-add_executable(
-  velox_exec_util_test
-  Main.cpp
+# Split velox_exec_util_test into individual test binaries for parallel execution.
+# Each test depends on the shared base class PrestoQueryRunnerIntermediateTypeTransformTestBase.cpp.
+set(
+  VELOX_EXEC_UTIL_TEST_SOURCES
   PrestoQueryRunnerHyperLogLogTransformTest.cpp
-  PrestoQueryRunnerIntermediateTypeTransformTestBase.cpp
   PrestoQueryRunnerTDigestTransformTest.cpp
   PrestoQueryRunnerQDigestTransformTest.cpp
+  PrestoQueryRunnerKHyperLogLogTransformTest.cpp
+  PrestoQueryRunnerSetDigestTransformTest.cpp
   PrestoQueryRunnerJsonTransformTest.cpp
   PrestoQueryRunnerIntervalTransformTest.cpp
+  PrestoQueryRunnerTimeTransformTest.cpp
   PrestoQueryRunnerTimestampWithTimeZoneTransformTest.cpp
 )
 
-add_test(velox_exec_util_test velox_exec_util_test)
-
-target_link_libraries(
-  velox_exec_util_test
+set(
+  VELOX_EXEC_UTIL_TEST_DEPS
   velox_fuzzer_util
   velox_exec_test_lib
   velox_functions_test_lib
@@ -245,6 +296,13 @@ target_link_libraries(
   GTest::gtest_main
 )
 
+velox_add_grouped_tests(
+  PREFIX velox_exec_util_test
+  SOURCES ${VELOX_EXEC_UTIL_TEST_SOURCES}
+  DEPS ${VELOX_EXEC_UTIL_TEST_DEPS}
+  EXTRA_SOURCES PrestoQueryRunnerIntermediateTypeTransformTestBase.cpp Main.cpp
+)
+
 add_executable(velox_in_10_min_demo VeloxIn10MinDemo.cpp)
 
 target_link_libraries(
@@ -264,6 +322,7 @@ add_executable(
   TableEvolutionFuzzerTest.cpp
   TableEvolutionFuzzer.cpp
 )
+velox_add_test_headers(velox_table_evolution_fuzzer_test TableEvolutionFuzzer.h)
 
 target_link_libraries(
   velox_table_evolution_fuzzer_test
@@ -273,7 +332,7 @@ target_link_libraries(
   velox_fuzzer_util
   velox_functions_prestosql
   velox_exec_test_lib
-  velox_temp_path
+  velox_test_util
   velox_vector_fuzzer
   GTest::gtest
   GTest::gtest_main
@@ -297,7 +356,14 @@ target_link_libraries(
   GTest::gtest_main
 )
 
-add_library(velox_simple_aggregate SimpleAverageAggregate.cpp SimpleArrayAggAggregate.cpp)
+add_library(
+  velox_simple_aggregate
+  SimpleAverageAggregate.cpp
+  SimpleArrayAggAggregate.cpp
+  SimpleVariadicArrayAggAggregate.cpp
+  SimpleVariadicSumAggregate.cpp
+)
+velox_add_test_headers(velox_simple_aggregate SimpleAggregateFunctionsRegistration.h)
 
 target_link_libraries(
   velox_simple_aggregate
@@ -325,6 +391,12 @@ if(VELOX_ENABLE_BENCHMARKS)
     JoinSpillInputBenchmarkBase.cpp
     SpillerBenchmarkBase.cpp
   )
+  velox_add_test_headers(
+    velox_spiller_join_benchmark_base
+    AggregateSpillBenchmarkBase.h
+    JoinSpillInputBenchmarkBase.h
+    SpillerBenchmarkBase.h
+  )
   target_link_libraries(
     velox_spiller_join_benchmark_base
     velox_exec
@@ -371,14 +443,6 @@ if(VELOX_ENABLE_BENCHMARKS)
   )
 endif()
 
-add_executable(cpr_http_client_test CprHttpClientTest.cpp)
-add_test(
-  NAME cpr_http_client_test
-  COMMAND cpr_http_client_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-)
-target_link_libraries(cpr_http_client_test cpr::cpr GTest::gtest GTest::gtest_main)
-
 add_executable(velox_driver_test OperatorReplacementTest.cpp Main.cpp)
 add_test(
   NAME velox_driver_test
@@ -387,3 +451,13 @@ add_test(
 )
 
 target_link_libraries(velox_driver_test velox_exec velox_exec_test_lib GTest::gtest)
+
+add_executable(velox_adaptive_prefetch_test AdaptivePrefetchTest.cpp)
+add_test(
+  NAME velox_adaptive_prefetch_test
+  COMMAND velox_adaptive_prefetch_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
+target_link_libraries(velox_adaptive_prefetch_test GTest::gtest GTest::gtest_main)
+
+velox_add_library(velox_aggregate_registry_util INTERFACE HEADERS AggregateRegistryTestUtil.h)
diff --git a/velox/exec/tests/ColumnStatsCollectorTest.cpp b/velox/exec/tests/ColumnStatsCollectorTest.cpp
index 250ae45e920..339fdf3df74 100644
--- a/velox/exec/tests/ColumnStatsCollectorTest.cpp
+++ b/velox/exec/tests/ColumnStatsCollectorTest.cpp
@@ -64,20 +64,20 @@ class ColumnStatsCollectorTest : public OperatorTestBase {
 
       core::AggregationNode::Aggregate agg;
       agg.call = std::dynamic_pointer_cast<const core::CallTypedExpr>(
-          core::Expressions::inferTypes(untypedExpr.expr, type, pool()));
+          core::Expressions::inferTypes(untypedExpr, type, pool()));
 
       for (const auto& input : agg.call->inputs()) {
         agg.rawInputTypes.push_back(input->type());
       }
 
-      VELOX_CHECK_NULL(untypedExpr.maskExpr);
-      VELOX_CHECK(!untypedExpr.distinct);
-      VELOX_CHECK(untypedExpr.orderBy.empty());
+      VELOX_CHECK_NULL(untypedExpr->filter());
+      VELOX_CHECK(!untypedExpr->isDistinct());
+      VELOX_CHECK(untypedExpr->orderBy().empty());
 
       aggs.emplace_back(agg);
 
-      if (untypedExpr.expr->alias().has_value()) {
-        names.push_back(untypedExpr.expr->alias().value());
+      if (untypedExpr->alias().has_value()) {
+        names.push_back(untypedExpr->alias().value());
       } else {
         names.push_back(fmt::format("a{}", i));
       }
diff --git a/velox/exec/tests/ConcatFilesSpillMergeStreamTest.cpp b/velox/exec/tests/ConcatFilesSpillMergeStreamTest.cpp
index fc8e81fde7f..25b1371618c 100644
--- a/velox/exec/tests/ConcatFilesSpillMergeStreamTest.cpp
+++ b/velox/exec/tests/ConcatFilesSpillMergeStreamTest.cpp
@@ -14,14 +14,14 @@
  * limitations under the License.
  */
 
+#include <folly/system/HardwareConcurrency.h>
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/exec/SortBuffer.h"
 #include "velox/exec/Spill.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/type/Type.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
-#include "velox/vector/tests/utils/VectorTestBase.h"
 
 #include <gtest/gtest.h>
 
@@ -31,6 +31,7 @@ using namespace facebook::velox;
 using namespace facebook::velox::memory;
 
 namespace facebook::velox::exec::test {
+using namespace facebook::velox::common::testutil;
 
 class ConcatFilesSpillMergeStreamTest : public OperatorTestBase {
  protected:
@@ -99,8 +100,12 @@ class ConcatFilesSpillMergeStreamTest : public OperatorTestBase {
       std::vector<std::unique_ptr<SpillReadFile>> spillReadFiles;
       spillReadFiles.reserve(spillFiles.size());
       for (const auto& spillFile : spillFiles) {
-        spillReadFiles.emplace_back(SpillReadFile::create(
-            spillFile, spillConfig_.readBufferSize, pool_.get(), &spillStats_));
+        spillReadFiles.emplace_back(
+            SpillReadFile::create(
+                spillFile,
+                spillConfig_.readBufferSize,
+                pool_.get(),
+                &spillStats_));
       }
       auto stream =
           ConcatFilesSpillMergeStream::create(i - 1, std::move(spillReadFiles));
@@ -196,7 +201,7 @@ class ConcatFilesSpillMergeStreamTest : public OperatorTestBase {
        {"c3", VARCHAR()}});
   const std::shared_ptr<folly::Executor> executor_{
       std::make_shared<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency())};
+          folly::available_concurrency())};
   const std::vector<column_index_t> sortColumnIndices_{0, 2};
   const std::vector<CompareFlags> sortCompareFlags_{
       CompareFlags{},
@@ -204,7 +209,7 @@ class ConcatFilesSpillMergeStreamTest : public OperatorTestBase {
   const std::vector<SpillSortKey> sortingKeys_ =
       SpillState::makeSortingKeys(sortColumnIndices_, sortCompareFlags_);
   const std::shared_ptr<TempDirectoryPath> spillDirectory_ =
-      exec::test::TempDirectoryPath::create();
+      TempDirectoryPath::create();
   const common::SpillConfig spillConfig_{
       [&]() -> const std::string& { return spillDirectory_->getPath(); },
       [&](uint64_t) {},
@@ -221,9 +226,10 @@ class ConcatFilesSpillMergeStreamTest : public OperatorTestBase {
       0,
       0,
       "none",
+      0,
       std::nullopt};
 
-  folly::Synchronized<common::SpillStats> spillStats_;
+  exec::SpillStats spillStats_;
   tsan_atomic<bool> nonReclaimableSection_{false};
 };
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/CountingJoinTest.cpp b/velox/exec/tests/CountingJoinTest.cpp
new file mode 100644
index 00000000000..da9db1630d4
--- /dev/null
+++ b/velox/exec/tests/CountingJoinTest.cpp
@@ -0,0 +1,418 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "velox/exec/HashTable.h"
+#include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+namespace facebook::velox::exec::test {
+namespace {
+
+class CountingJoinTest : public OperatorTestBase {
+ protected:
+  void assertCountingJoin(
+      const std::vector<int32_t>& probe,
+      const std::vector<int32_t>& build,
+      core::JoinType joinType,
+      const std::vector<int32_t>& expected) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(makeRowVector({makeFlatVector<int32_t>(probe)}))
+                    .hashJoin(
+                        {"c0"},
+                        {"u0"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(makeRowVector(
+                                {"u0"}, {makeFlatVector<int32_t>(build)}))
+                            .planNode(),
+                        "",
+                        {"c0"},
+                        joinType,
+                        /*nullAware=*/false,
+                        /*nullAsValue=*/true)
+                    .planNode();
+    AssertQueryBuilder(plan).assertResults(
+        makeRowVector({makeFlatVector<int32_t>(expected)}));
+  }
+};
+
+// {A, A, A, B, B} EXCEPT ALL {A, A, C} = {A, B, B}
+TEST_F(CountingJoinTest, countingAnti) {
+  assertCountingJoin(
+      {1, 1, 1, 2, 2}, {1, 1, 3}, core::JoinType::kCountingAnti, {1, 2, 2});
+}
+
+// {A, A, A, B, B} INTERSECT ALL {A, A, C} = {A, A}
+TEST_F(CountingJoinTest, countingSemi) {
+  assertCountingJoin(
+      {1, 1, 1, 2, 2},
+      {1, 1, 3},
+      core::JoinType::kCountingLeftSemiFilter,
+      {1, 1});
+}
+
+// Empty build side: returns all probe rows.
+TEST_F(CountingJoinTest, countingAntiEmptyBuild) {
+  assertCountingJoin({1, 2, 3}, {}, core::JoinType::kCountingAnti, {1, 2, 3});
+}
+
+// Empty build side: returns nothing.
+TEST_F(CountingJoinTest, countingSemiEmptyBuild) {
+  assertCountingJoin(
+      {1, 2, 3}, {}, core::JoinType::kCountingLeftSemiFilter, {});
+}
+
+// Empty probe side: returns nothing.
+TEST_F(CountingJoinTest, emptyProbe) {
+  assertCountingJoin({}, {1, 2, 3}, core::JoinType::kCountingAnti, {});
+  assertCountingJoin(
+      {}, {1, 2, 3}, core::JoinType::kCountingLeftSemiFilter, {});
+}
+
+// No duplicates on build side: degenerates to regular anti/semi.
+TEST_F(CountingJoinTest, noDuplicatesOnBuild) {
+  assertCountingJoin(
+      {1, 2, 3, 4, 5}, {2, 4}, core::JoinType::kCountingAnti, {1, 3, 5});
+  assertCountingJoin(
+      {1, 2, 3, 4, 5}, {2, 4}, core::JoinType::kCountingLeftSemiFilter, {2, 4});
+}
+
+// All duplicates on build side.
+TEST_F(CountingJoinTest, allDuplicatesOnBuild) {
+  // EXCEPT ALL: 5 - 3 = 2
+  assertCountingJoin(
+      {1, 1, 1, 1, 1}, {1, 1, 1}, core::JoinType::kCountingAnti, {1, 1});
+  // INTERSECT ALL: min(5, 3) = 3
+  assertCountingJoin(
+      {1, 1, 1, 1, 1},
+      {1, 1, 1},
+      core::JoinType::kCountingLeftSemiFilter,
+      {1, 1, 1});
+}
+
+// Multiple batches on probe side.
+TEST_F(CountingJoinTest, multipleProbeBatches) {
+  auto probeVectors = {
+      makeRowVector({makeFlatVector<int32_t>({1, 1, 2})}),
+      makeRowVector({makeFlatVector<int32_t>({1, 2, 3})}),
+      makeRowVector({makeFlatVector<int32_t>({2, 3, 3})}),
+  };
+  auto buildVector =
+      makeRowVector({"u0"}, {makeFlatVector<int32_t>({1, 2, 2, 3})});
+
+  auto test = [&](core::JoinType joinType,
+                  const std::vector<int32_t>& expected) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan =
+        PlanBuilder(planNodeIdGenerator)
+            .values(probeVectors)
+            .hashJoin(
+                {"c0"},
+                {"u0"},
+                PlanBuilder(planNodeIdGenerator).values(buildVector).planNode(),
+                "",
+                {"c0"},
+                joinType,
+                /*nullAware=*/false,
+                /*nullAsValue=*/true)
+            .planNode();
+    AssertQueryBuilder(plan).assertResults(
+        makeRowVector({makeFlatVector<int32_t>(expected)}));
+  };
+
+  // Probe: {1:3, 2:3, 3:3}, Build: {1:1, 2:2, 3:1}
+  // EXCEPT ALL: {1:2, 2:1, 3:2}
+  test(core::JoinType::kCountingAnti, {1, 1, 2, 3, 3});
+  // INTERSECT ALL: {1:1, 2:2, 3:1}
+  test(core::JoinType::kCountingLeftSemiFilter, {1, 2, 2, 3});
+}
+
+// Multiple columns as join keys.
+TEST_F(CountingJoinTest, multipleKeys) {
+  auto probeVector = makeRowVector(
+      {makeFlatVector<int32_t>({1, 1, 1, 2, 2}),
+       makeFlatVector<int32_t>({10, 10, 20, 10, 10})});
+  auto buildVector = makeRowVector(
+      {"u0", "u1"},
+      {makeFlatVector<int32_t>({1, 1, 2}),
+       makeFlatVector<int32_t>({10, 10, 10})});
+
+  // Probe: {(1,10):2, (1,20):1, (2,10):2}, Build: {(1,10):2, (2,10):1}
+  // EXCEPT ALL: {(1,20):1, (2,10):1}
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values(probeVector)
+          .hashJoin(
+              {"c0", "c1"},
+              {"u0", "u1"},
+              PlanBuilder(planNodeIdGenerator).values(buildVector).planNode(),
+              "",
+              {"c0", "c1"},
+              core::JoinType::kCountingAnti,
+              /*nullAware=*/false,
+              /*nullAsValue=*/true)
+          .planNode();
+
+  auto expected = makeRowVector({
+      makeFlatVector<int32_t>({1, 2}),
+      makeFlatVector<int32_t>({20, 10}),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+// Null join keys match each other with nullAsValue (IS NOT DISTINCT FROM
+// semantics), as required by SQL set operations (EXCEPT ALL, INTERSECT ALL).
+TEST_F(CountingJoinTest, nullKeys) {
+  // Probe: {1, null, 1, null, 2}, Build: {1, null, 3}
+  auto probeVector = makeRowVector(
+      {makeNullableFlatVector<int32_t>({1, std::nullopt, 1, std::nullopt, 2})});
+  auto buildVector = makeRowVector(
+      {"u0"}, {makeNullableFlatVector<int32_t>({1, std::nullopt, 3})});
+
+  auto test = [&](core::JoinType joinType,
+                  const std::vector<std::optional<int32_t>>& expected) {
+    SCOPED_TRACE(core::JoinTypeName::toName(joinType));
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values({probeVector})
+                    .hashJoin(
+                        {"c0"},
+                        {"u0"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values({buildVector})
+                            .planNode(),
+                        "",
+                        {"c0"},
+                        joinType,
+                        /*nullAware=*/false,
+                        /*nullAsValue=*/true)
+                    .planNode();
+    AssertQueryBuilder(plan).assertResults(
+        makeRowVector({makeNullableFlatVector<int32_t>(expected)}));
+  };
+
+  // EXCEPT ALL: null keys match. Probe has 2 nulls, build has 1 null, so 1
+  // null passes through. Key 1 appears twice on probe, once on build, so 1
+  // copy passes through. Key 2 has no build match.
+  test(core::JoinType::kCountingAnti, {1, std::nullopt, 2});
+
+  // INTERSECT ALL: null keys match. min(2, 1) = 1 null kept.
+  // Key 1: min(2, 1) = 1. Key 2: no match.
+  test(core::JoinType::kCountingLeftSemiFilter, {1, std::nullopt});
+}
+
+// Verifies that the build side deduplicates rows and stores only distinct keys.
+TEST_F(CountingJoinTest, buildSideDedup) {
+  // 10 distinct keys repeated 1'000 times each = 10'000 build rows.
+  auto buildVector = makeRowVector(
+      {"u0"}, {makeFlatVector<int32_t>(10, [](auto row) { return row; })});
+
+  // Probe has values 0..14. Build has values 0..9, each repeated 1'000 times.
+  // EXCEPT ALL: values 0..9 each appear once on probe but 1'000 times on build,
+  // so all are consumed. Values 10..14 have no match and are emitted.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(makeRowVector({makeFlatVector<int32_t>(
+                      15, [](auto row) { return row; })}))
+                  .hashJoin(
+                      {"c0"},
+                      {"u0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVector}, false, 1'000)
+                          .planNode(),
+                      "",
+                      {"c0"},
+                      core::JoinType::kCountingAnti,
+                      /*nullAware=*/false,
+                      /*nullAsValue=*/true)
+                  .planNode();
+
+  auto expected =
+      makeRowVector({makeFlatVector<int32_t>({10, 11, 12, 13, 14})});
+  auto task = AssertQueryBuilder(plan).assertResults(expected);
+
+  // Verify the build received 10'000 rows but the hash table has only 10
+  // distinct keys.
+  auto planStats = toPlanStats(task->taskStats());
+  const auto& joinStats = planStats.at(plan->id());
+  EXPECT_EQ(10'000, joinStats.operatorStats.at("HashBuild")->inputRows);
+  EXPECT_EQ(
+      10,
+      joinStats.customStats.at(std::string(BaseHashTable::kNumDistinct)).sum);
+}
+
+// Verifies that counts are correctly merged when multiple build drivers process
+// the same keys. Each driver builds its own hash table with per-key counts;
+// during the merge in prepareJoinTable, duplicate keys must have their counts
+// summed rather than silently dropped.
+//
+// Tests three key configurations to exercise all hash table modes:
+//  - Small INT32 keys {1, 2}: array mode (arrayPushRow path).
+//  - Two INT32 key columns with ~1500 distinct values each: normalized-key
+//    mode (buildFullProbe with normalizedKey comparison).
+//  - Complex-type (ARRAY(INT32)) keys: hash mode (buildFullProbe with
+//    compareKeys).
+TEST_F(CountingJoinTest, multipleBuildDrivers) {
+  constexpr int32_t kNumDrivers = 4;
+
+  auto test = [&](const RowVectorPtr& probeVector,
+                  const RowVectorPtr& buildVector,
+                  core::JoinType joinType,
+                  BaseHashTable::HashMode expectedHashMode,
+                  const std::vector<VectorPtr>& expectedChildren) {
+    auto expected =
+        makeRowVector(probeVector->rowType()->names(), expectedChildren);
+    auto probeKeys = probeVector->rowType()->names();
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values({probeVector})
+                    .hashJoin(
+                        probeKeys,
+                        buildVector->rowType()->names(),
+                        PlanBuilder(planNodeIdGenerator)
+                            .values({buildVector}, /*parallelizable=*/true)
+                            .planNode(),
+                        "",
+                        probeKeys,
+                        joinType,
+                        /*nullAware=*/false,
+                        /*nullAsValue=*/true)
+                    .planNode();
+    auto task = AssertQueryBuilder(plan)
+                    .maxDrivers(kNumDrivers)
+                    .assertResults(expected);
+
+    // Verify that all build drivers ran. Each driver processes 1 batch.
+    auto planStats = toPlanStats(task->taskStats());
+    const auto& joinStats = planStats.at(plan->id());
+
+    const auto& buildStats = *joinStats.operatorStats.at("HashBuild");
+    EXPECT_EQ(kNumDrivers, buildStats.numDrivers);
+    EXPECT_EQ(kNumDrivers, buildStats.inputVectors);
+    EXPECT_EQ(buildVector->size() * kNumDrivers, buildStats.inputRows);
+
+    // Probe side runs single-threaded (Values node is not parallelizable by
+    // default). It processes 1 batch.
+    const auto& probeStats = *joinStats.operatorStats.at("HashProbe");
+    EXPECT_EQ(1, probeStats.numDrivers);
+    EXPECT_EQ(1, probeStats.inputVectors);
+    EXPECT_EQ(probeVector->size(), probeStats.inputRows);
+
+    EXPECT_EQ(
+        static_cast<int64_t>(expectedHashMode),
+        buildStats.customStats.at(std::string(BaseHashTable::kHashMode)).sum);
+  };
+
+  // Small keys {1, 2}: triggers array-based hash mode.
+  // Build: {1, 1, 2}, each of 4 drivers => merged {1:8, 2:4}.
+  // Probe: {1:3, 2:5}.
+  {
+    SCOPED_TRACE("small keys (array mode)");
+    auto buildVector =
+        makeRowVector({"u0"}, {makeFlatVector<int32_t>({1, 1, 2})});
+    auto probeVector =
+        makeRowVector({makeFlatVector<int32_t>({1, 1, 1, 2, 2, 2, 2, 2})});
+
+    // EXCEPT ALL: {1: max(3-8,0)=0, 2: max(5-4,0)=1} => {2}.
+    test(
+        probeVector,
+        buildVector,
+        core::JoinType::kCountingAnti,
+        BaseHashTable::HashMode::kArray,
+        {makeFlatVector<int32_t>({2})});
+    // INTERSECT ALL: {1: min(3,8)=3, 2: min(5,4)=4}.
+    test(
+        probeVector,
+        buildVector,
+        core::JoinType::kCountingLeftSemiFilter,
+        BaseHashTable::HashMode::kArray,
+        {makeFlatVector<int32_t>({1, 1, 1, 2, 2, 2, 2})});
+  }
+
+  // Two INT32 key columns with ~1500 distinct values each. The combined
+  // cardinality (1500 * 1500 = 2.25M) exceeds kArrayHashMaxSize (2M),
+  // forcing normalized-key mode (buildFullProbe with normalizedKey comparison).
+  {
+    SCOPED_TRACE("multi-column keys (normalized-key mode)");
+    constexpr int32_t kNumKeys = 1'500;
+
+    // Build: 2-column keys (i, i) for i in 0..kNumKeys-1, plus duplicates of
+    // (0, 0) and (1, 1). Both columns are identical — we need 2 columns so
+    // the combined cardinality (1500 * 1500 = 2.25M) exceeds kArrayHashMaxSize
+    // (2M).
+    auto buildKeys = makeFlatVector<int32_t>(kNumKeys + 2, [](auto row) {
+      return row < kNumKeys ? row : row - kNumKeys;
+    });
+
+    // Probe: key (0,0) appears 10 times, key (1,1) appears 5 times.
+    auto probeKeys =
+        makeFlatVector<int32_t>({0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1});
+
+    // Each of 4 drivers: (0,0) count=2, (1,1) count=2, others count=1.
+    // After merge: (0,0) count=8, (1,1) count=8.
+    // EXCEPT ALL: (0,0): max(10-8,0)=2, (1,1): max(5-8,0)=0.
+    auto expectedAnti = makeFlatVector<int32_t>({0, 0});
+    test(
+        makeRowVector({probeKeys, probeKeys}),
+        makeRowVector({"u0", "u1"}, {buildKeys, buildKeys}),
+        core::JoinType::kCountingAnti,
+        BaseHashTable::HashMode::kNormalizedKey,
+        {expectedAnti, expectedAnti});
+    // INTERSECT ALL: (0,0): min(10,8)=8, (1,1): min(5,8)=5.
+    auto expectedSemi =
+        makeFlatVector<int32_t>({0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1});
+    test(
+        makeRowVector({probeKeys, probeKeys}),
+        makeRowVector({"u0", "u1"}, {buildKeys, buildKeys}),
+        core::JoinType::kCountingLeftSemiFilter,
+        BaseHashTable::HashMode::kNormalizedKey,
+        {expectedSemi, expectedSemi});
+  }
+
+  // ARRAY(INT32) type keys do not support value IDs in VectorHasher, forcing
+  // kHash mode (buildFullProbe with compareKeys).
+  {
+    SCOPED_TRACE("complex-type keys (hash mode)");
+    auto buildVector =
+        makeRowVector({"u0"}, {makeArrayVector<int32_t>({{1}, {1}, {2}})});
+    auto probeVector = makeRowVector(
+        {makeArrayVector<int32_t>({{1}, {1}, {1}, {2}, {2}, {2}, {2}, {2}})});
+
+    // EXCEPT ALL: {[1]: max(3-8,0)=0, [2]: max(5-4,0)=1} => {[2]}.
+    test(
+        probeVector,
+        buildVector,
+        core::JoinType::kCountingAnti,
+        BaseHashTable::HashMode::kHash,
+        {makeArrayVector<int32_t>({{2}})});
+    // INTERSECT ALL: {[1]: min(3,8)=3, [2]: min(5,4)=4}.
+    test(
+        probeVector,
+        buildVector,
+        core::JoinType::kCountingLeftSemiFilter,
+        BaseHashTable::HashMode::kHash,
+        {makeArrayVector<int32_t>({{1}, {1}, {1}, {2}, {2}, {2}, {2}})});
+  }
+}
+
+} // namespace
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/CprHttpClientTest.cpp b/velox/exec/tests/CprHttpClientTest.cpp
deleted file mode 100644
index 9a19ccaaed2..00000000000
--- a/velox/exec/tests/CprHttpClientTest.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/common/base/tests/GTestUtils.h"
-
-#include <cpr/cpr.h>
-#include <map>
-
-class CprHttpClientTest : public testing::Test {};
-
-// This test requires open access to internet and most places test runners might
-// be closed off from the general internet. And this test case is just an
-// illustration of how to use cpr, so disable it by default.
-TEST_F(CprHttpClientTest, DISABLED_basic) {
-  auto response = cpr::Get(
-      cpr::Url{"https://facebookincubator.github.io/velox/"},
-      cpr::Timeout{std::chrono::seconds{3}});
-  ASSERT_EQ(response.status_code, 200);
-  ASSERT_FALSE(response.text.empty());
-
-  response = cpr::Get(cpr::Url{"null"});
-  ASSERT_NE(response.status_code, 200);
-  ASSERT_TRUE(response.text.empty());
-
-  response = cpr::Post(
-      cpr::Url{"https://facebookincubator.github.io/velox/"},
-      cpr::Body{"select * from nation limit 1"},
-      cpr::Header({{"Content-Type", "text/plain"}}));
-  ASSERT_EQ(response.status_code, 405);
-  ASSERT_FALSE(response.text.empty());
-
-  response = cpr::Post(
-      cpr::Url{"null"},
-      cpr::Body{"select * from nation limit 1"},
-      cpr::Header({{"Content-Type", "text/plain"}}));
-  ASSERT_NE(response.status_code, 200);
-  ASSERT_TRUE(response.text.empty());
-}
diff --git a/velox/exec/tests/CustomTraceTest.cpp b/velox/exec/tests/CustomTraceTest.cpp
new file mode 100644
index 00000000000..267217b7372
--- /dev/null
+++ b/velox/exec/tests/CustomTraceTest.cpp
@@ -0,0 +1,1180 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <fmt/format.h>
+#include <gtest/gtest.h>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/trace/TraceCtx.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+namespace facebook::velox::exec::trace::test {
+namespace {
+
+using exec::test::AssertQueryBuilder;
+using exec::test::PlanBuilder;
+using velox::test::assertEqualVectors;
+
+using TCapturedVectors = std::unordered_map<core::PlanNodeId, VectorPtr>;
+
+// A custom test trace implementation that only captures pointers to internal
+// vectors. It only traces operators from `traceIds`, and assumes
+// single-threaded execution. Vectors are captured in TCapturedVectors.
+class TestTraceCtx : public TraceCtx {
+ public:
+  TestTraceCtx(
+      const std::vector<core::PlanNodeId>& tracedIds,
+      TCapturedVectors& tracedVectors)
+      : TraceCtx(false),
+        tracedIds_(tracedIds.begin(), tracedIds.end()),
+        tracedVectors_(tracedVectors) {}
+
+  bool shouldTrace(const Operator& op) const override {
+    return tracedIds_.contains(op.planNodeId());
+  }
+
+  class TestTraceInputWriter : public TraceInputWriter {
+   public:
+    TestTraceInputWriter(
+        const core::PlanNodeId& planId,
+        TCapturedVectors& tracedVectors)
+        : planId_(planId), tracedVectors_(tracedVectors) {}
+
+    bool write(const RowVectorPtr& vector, ContinueFuture*) override {
+      tracedVectors_[planId_] = vector;
+      return false;
+    }
+
+    void finish() override {}
+
+   private:
+    const core::PlanNodeId planId_;
+    TCapturedVectors& tracedVectors_;
+  };
+
+  std::unique_ptr<TraceInputWriter> createInputTracer(
+      Operator& op) const override {
+    return std::make_unique<TestTraceInputWriter>(
+        op.planNodeId(), tracedVectors_);
+  }
+
+ private:
+  std::unordered_set<core::PlanNodeId> tracedIds_;
+
+  TCapturedVectors& tracedVectors_;
+};
+
+// Captures expression output vectors keyed by function name.
+using TExprCapturedVectors = std::unordered_map<std::string, VectorPtr>;
+
+// A test trace implementation for expression-level tracing. Traces output
+// batches from named expression functions listed in tracedExprs.
+class ExprTestTraceCtx : public TraceCtx {
+ public:
+  ExprTestTraceCtx(
+      const std::vector<std::string>& tracedExprs,
+      TExprCapturedVectors& capturedVectors,
+      bool shouldTraceOp = true)
+      : TraceCtx(false),
+        shouldTraceOp_(shouldTraceOp),
+        tracedExprs_(tracedExprs.begin(), tracedExprs.end()),
+        capturedVectors_(capturedVectors) {}
+
+  bool shouldTrace(const Operator& /*op*/) const override {
+    return shouldTraceOp_;
+  }
+
+  bool shouldTraceExpr(std::string_view functionName) const override {
+    return tracedExprs_.contains(std::string(functionName));
+  }
+
+  std::unique_ptr<TraceExprWriter> createExprOutputTracer(
+      const Operator& /*op*/,
+      std::string_view functionName,
+      int instanceIndex) const override {
+    auto key = fmt::format("{}_{}", functionName, instanceIndex);
+    return std::make_unique<TestExprWriter>(std::move(key), capturedVectors_);
+  }
+
+ private:
+  class TestExprWriter : public TraceExprWriter {
+   public:
+    TestExprWriter(
+        std::string functionName,
+        TExprCapturedVectors& capturedVectors)
+        : functionName_(std::move(functionName)),
+          capturedVectors_(capturedVectors) {}
+
+    void write(const VectorPtr& vector) override {
+      capturedVectors_[functionName_] = vector;
+    }
+
+    void finish() override {}
+
+   private:
+    const std::string functionName_;
+    TExprCapturedVectors& capturedVectors_;
+  };
+
+  const bool shouldTraceOp_;
+  std::unordered_set<std::string> tracedExprs_;
+  TExprCapturedVectors& capturedVectors_;
+};
+
+class CustomTraceTest : public exec::test::HiveConnectorTestBase {};
+
+TEST_F(CustomTraceTest, customTrace) {
+  auto vector = makeRowVector(
+      {"a"}, {makeFlatVector<int64_t>(10, [](auto row) { return row; })});
+
+  core::PlanNodeId traceNodeId1;
+  core::PlanNodeId traceNodeId2;
+
+  // Trace the inputs from two operators.
+  auto plan = PlanBuilder()
+                  .values({vector})
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(traceNodeId1)
+                  .project({"a * 10 as a"})
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(traceNodeId2)
+                  .planNode();
+
+  TCapturedVectors tracedVectors;
+  auto queryCtx =
+      core::QueryCtx::Builder()
+          .executor(executor_.get())
+          .traceCtxProvider([&](core::QueryCtx&, const core::PlanFragment&) {
+            return std::make_unique<TestTraceCtx>(
+                std::vector<core::PlanNodeId>{traceNodeId1, traceNodeId2},
+                tracedVectors);
+          })
+          .build();
+
+  std::shared_ptr<Task> task;
+  AssertQueryBuilder(plan)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .queryCtx(queryCtx)
+      .countResults(task);
+
+  auto it1 = tracedVectors.find(traceNodeId1);
+  auto it2 = tracedVectors.find(traceNodeId2);
+
+  ASSERT_TRUE(it1 != tracedVectors.end());
+  ASSERT_TRUE(it2 != tracedVectors.end());
+
+  auto expected1 = makeRowVector(
+      {"a"}, {makeFlatVector<int64_t>(10, [](auto row) { return row; })});
+  auto expected2 = makeRowVector(
+      {"a"},
+      {makeFlatVector<int64_t>(10, [](auto row) { return row * 10 * 10; })});
+
+  assertEqualVectors(it1->second, expected1);
+  assertEqualVectors(it2->second, expected2);
+
+  // Vectors need to be destructed before the pool in the task dies.
+  tracedVectors.clear();
+}
+
+TEST_F(CustomTraceTest, exprOutputTrace) {
+  auto vector = makeRowVector(
+      {"a"}, {makeFlatVector<int64_t>(10, [](auto row) { return row; })});
+
+  auto plan =
+      PlanBuilder().values({vector}).project({"a * 10 as a"}).planNode();
+
+  TExprCapturedVectors capturedVectors;
+  auto queryCtx =
+      core::QueryCtx::Builder()
+          .executor(executor_.get())
+          .traceCtxProvider([&](core::QueryCtx&, const core::PlanFragment&) {
+            return std::make_unique<ExprTestTraceCtx>(
+                std::vector<std::string>{"multiply"}, capturedVectors);
+          })
+          .build();
+
+  std::shared_ptr<Task> task;
+  AssertQueryBuilder(plan)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .queryCtx(queryCtx)
+      .countResults(task);
+
+  auto iterator = capturedVectors.find("multiply_0");
+  ASSERT_TRUE(iterator != capturedVectors.end());
+
+  auto expected =
+      makeFlatVector<int64_t>(10, [](auto row) { return row * 10; });
+  assertEqualVectors(iterator->second, expected);
+
+  capturedVectors.clear();
+}
+
+TEST_F(CustomTraceTest, exprTraceOnlyMatchingFunctions) {
+  auto vector = makeRowVector(
+      {"a"}, {makeFlatVector<int64_t>(10, [](auto row) { return row; })});
+
+  // Two projections: multiply then plus. Only trace "plus".
+  auto plan = PlanBuilder()
+                  .values({vector})
+                  .project({"a * 10 as b", "a + 5 as c"})
+                  .planNode();
+
+  TExprCapturedVectors capturedVectors;
+  auto queryCtx =
+      core::QueryCtx::Builder()
+          .executor(executor_.get())
+          .traceCtxProvider([&](core::QueryCtx&, const core::PlanFragment&) {
+            return std::make_unique<ExprTestTraceCtx>(
+                std::vector<std::string>{"plus"}, capturedVectors);
+          })
+          .build();
+
+  std::shared_ptr<Task> task;
+  AssertQueryBuilder(plan)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .queryCtx(queryCtx)
+      .countResults(task);
+
+  // "plus" should be captured.
+  EXPECT_TRUE(capturedVectors.contains("plus_0"));
+
+  // "multiply" should not be captured.
+  EXPECT_FALSE(capturedVectors.contains("multiply_0"));
+
+  capturedVectors.clear();
+}
+
+TEST_F(CustomTraceTest, exprTraceMultipleInstances) {
+  auto vector = makeRowVector(
+      {"a", "b"},
+      {makeFlatVector<int64_t>(10, [](auto row) { return row; }),
+       makeFlatVector<int64_t>(10, [](auto row) { return row + 100; })});
+
+  auto plan = PlanBuilder()
+                  .values({vector})
+                  .project({"a * 10 as c", "b * 20 as d"})
+                  .planNode();
+
+  TExprCapturedVectors capturedVectors;
+  auto queryCtx =
+      core::QueryCtx::Builder()
+          .executor(executor_.get())
+          .traceCtxProvider([&](core::QueryCtx&, const core::PlanFragment&) {
+            return std::make_unique<ExprTestTraceCtx>(
+                std::vector<std::string>{"multiply"}, capturedVectors);
+          })
+          .build();
+
+  std::shared_ptr<Task> task;
+  AssertQueryBuilder(plan)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .queryCtx(queryCtx)
+      .countResults(task);
+
+  ASSERT_TRUE(capturedVectors.contains("multiply_0"));
+  ASSERT_TRUE(capturedVectors.contains("multiply_1"));
+
+  auto expected0 =
+      makeFlatVector<int64_t>(10, [](auto row) { return row * 10; });
+  auto expected1 =
+      makeFlatVector<int64_t>(10, [](auto row) { return (row + 100) * 20; });
+
+  assertEqualVectors(capturedVectors.at("multiply_0"), expected0);
+  assertEqualVectors(capturedVectors.at("multiply_1"), expected1);
+
+  capturedVectors.clear();
+}
+
+TEST_F(CustomTraceTest, exprTraceCseSharedNode) {
+  auto vector = makeRowVector(
+      {"a"}, {makeFlatVector<int64_t>(10, [](auto row) { return row; })});
+
+  // Both projections share the "a * 10" subexpression (CSE). The visited set
+  // should ensure the shared multiply node is only traced once.
+  auto plan = PlanBuilder()
+                  .values({vector})
+                  .project({"a * 10 + 1 as b", "a * 10 + 2 as c"})
+                  .planNode();
+
+  TExprCapturedVectors capturedVectors;
+  auto queryCtx =
+      core::QueryCtx::Builder()
+          .executor(executor_.get())
+          .traceCtxProvider([&](core::QueryCtx&, const core::PlanFragment&) {
+            return std::make_unique<ExprTestTraceCtx>(
+                std::vector<std::string>{"multiply"}, capturedVectors);
+          })
+          .build();
+
+  std::shared_ptr<Task> task;
+  AssertQueryBuilder(plan)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .queryCtx(queryCtx)
+      .countResults(task);
+
+  // The shared CSE node should produce exactly one multiply instance.
+  EXPECT_TRUE(capturedVectors.contains("multiply_0"));
+  EXPECT_FALSE(capturedVectors.contains("multiply_1"));
+
+  capturedVectors.clear();
+}
+
+TEST_F(CustomTraceTest, exprTraceNullResult) {
+  auto vector = makeRowVector(
+      {"a"},
+      {makeNullableFlatVector<int64_t>({1, std::nullopt, 3, std::nullopt, 5})});
+
+  // try(a / 0) produces all nulls without throwing.
+  auto plan =
+      PlanBuilder().values({vector}).project({"try(a / 0) as b"}).planNode();
+
+  TExprCapturedVectors capturedVectors;
+  auto queryCtx =
+      core::QueryCtx::Builder()
+          .executor(executor_.get())
+          .traceCtxProvider([&](core::QueryCtx&, const core::PlanFragment&) {
+            return std::make_unique<ExprTestTraceCtx>(
+                std::vector<std::string>{"divide"}, capturedVectors);
+          })
+          .build();
+
+  std::shared_ptr<Task> task;
+  AssertQueryBuilder(plan)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .queryCtx(queryCtx)
+      .countResults(task);
+
+  // divide is inside try() which catches the error and produces nulls.
+  // The tracer should still capture output (the null vector).
+  EXPECT_TRUE(capturedVectors.contains("divide_0"));
+
+  capturedVectors.clear();
+}
+
+TEST_F(CustomTraceTest, exprTraceOperatorScoping) {
+  auto vector = makeRowVector(
+      {"a"}, {makeFlatVector<int64_t>(10, [](auto row) { return row; })});
+
+  auto plan =
+      PlanBuilder().values({vector}).project({"a * 10 as b"}).planNode();
+
+  TExprCapturedVectors capturedVectors;
+  auto queryCtx =
+      core::QueryCtx::Builder()
+          .executor(executor_.get())
+          .traceCtxProvider([&](core::QueryCtx&, const core::PlanFragment&) {
+            return std::make_unique<ExprTestTraceCtx>(
+                std::vector<std::string>{"multiply"}, capturedVectors, false);
+          })
+          .build();
+
+  std::shared_ptr<Task> task;
+  AssertQueryBuilder(plan)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .queryCtx(queryCtx)
+      .countResults(task);
+
+  EXPECT_TRUE(capturedVectors.empty());
+}
+
+// A trace context that creates writers which throw from write() and finish().
+class ThrowingExprTraceCtx : public TraceCtx {
+ public:
+  explicit ThrowingExprTraceCtx(const std::vector<std::string>& tracedExprs)
+      : TraceCtx(false), tracedExprs_(tracedExprs.begin(), tracedExprs.end()) {}
+
+  bool shouldTrace(const Operator& /*op*/) const override {
+    return true;
+  }
+
+  bool shouldTraceExpr(std::string_view functionName) const override {
+    return tracedExprs_.contains(std::string(functionName));
+  }
+
+  std::unique_ptr<TraceExprWriter> createExprOutputTracer(
+      const Operator& /*op*/,
+      std::string_view /*functionName*/,
+      int /*instanceIndex*/) const override {
+    return std::make_unique<ThrowingExprWriter>();
+  }
+
+ private:
+  class ThrowingExprWriter : public TraceExprWriter {
+   public:
+    void write(const VectorPtr& /*result*/) override {
+      throw std::runtime_error("write failed");
+    }
+
+    void finish() override {
+      throw std::runtime_error("finish failed");
+    }
+  };
+
+  std::unordered_set<std::string> tracedExprs_;
+};
+
+TEST_F(CustomTraceTest, exprTraceThrowingWriter) {
+  auto vector = makeRowVector(
+      {"a"}, {makeFlatVector<int64_t>(10, [](auto row) { return row; })});
+
+  auto plan =
+      PlanBuilder().values({vector}).project({"a * 10 as a"}).planNode();
+
+  auto queryCtx =
+      core::QueryCtx::Builder()
+          .executor(executor_.get())
+          .traceCtxProvider([&](core::QueryCtx&, const core::PlanFragment&) {
+            return std::make_unique<ThrowingExprTraceCtx>(
+                std::vector<std::string>{"multiply"});
+          })
+          .build();
+
+  std::shared_ptr<Task> task;
+  ASSERT_NO_THROW(AssertQueryBuilder(plan)
+                      .config(core::QueryConfig::kQueryTraceEnabled, true)
+                      .queryCtx(queryCtx)
+                      .countResults(task));
+}
+
+// Helper to convert a vector of plan node IDs to a breakpoints map with null
+// callbacks.
+CursorParameters::TBreakpointMap toBreakpointsMap(
+    const std::vector<core::PlanNodeId>& ids) {
+  CursorParameters::TBreakpointMap result;
+  for (const auto& id : ids) {
+    result[id] = nullptr;
+  }
+  return result;
+}
+
+void assertCursorOutput(
+    const core::PlanNodePtr& plan,
+    const std::vector<core::PlanNodeId>& breakpoints,
+    const std::vector<RowVectorPtr>& expectation) {
+  auto cursor = TaskCursor::create({
+      .planNode = plan,
+      .serialExecution = true,
+      .breakpoints = toBreakpointsMap(breakpoints),
+  });
+  size_t i = 0;
+
+  while (cursor->moveStep()) {
+    if (i < expectation.size()) {
+      assertEqualVectors(cursor->current(), expectation[i++]);
+    } else {
+      ADD_FAILURE() << "Cursor output is longer than expectation: " << i;
+    }
+  }
+  EXPECT_EQ(i, expectation.size());
+}
+
+TEST_F(CustomTraceTest, taskDebuggerCursor) {
+  const size_t size = 10;
+  auto makeData = [&](std::function<int64_t(vector_size_t)> values) {
+    return makeRowVector(
+        {"a"}, {makeFlatVector<int64_t>(size, std::move(values))});
+  };
+
+  // Two input vectors.
+  auto input1 = makeData([](auto row) { return row; });
+  auto input2 = makeData([](auto row) { return row + 10; });
+
+  // Now, the expected input for a series of operators.
+  auto input1Project1 = makeData([](auto row) { return row; });
+  auto input1Project2 = makeData([](auto row) { return row * 10; });
+  auto input1Project3 = makeData([](auto row) { return row * 100; });
+  auto input1Project4 = makeData([](auto row) { return row * 1'000; });
+  auto output1 = makeData([](auto row) { return row * 10'000; });
+
+  auto input2Project1 = makeData([](auto row) { return (row + 10); });
+  auto input2Project2 = makeData([](auto row) { return (row + 10) * 10; });
+  auto input2Project3 = makeData([](auto row) { return (row + 10) * 100; });
+  auto input2Project4 = makeData([](auto row) { return (row + 10) * 1'000; });
+  auto output2 = makeData([](auto row) { return (row + 10) * 10'000; });
+
+  core::PlanNodeId project1, project2, project3, project4;
+  auto plan = PlanBuilder()
+                  .values({input1, input2})
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project1)
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project2)
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project3)
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project4)
+                  .planNode();
+
+  // Test a series of combinations.
+  assertCursorOutput(plan, {}, {output1, output2});
+  assertCursorOutput(
+      plan, {project1}, {input1Project1, output1, input2Project1, output2});
+  assertCursorOutput(
+      plan,
+      {project1, project2},
+      {
+          input1Project1,
+          input1Project2,
+          output1,
+          input2Project1,
+          input2Project2,
+          output2,
+      });
+  assertCursorOutput(
+      plan,
+      {project2, project4},
+      {
+          input1Project2,
+          input1Project4,
+          output1,
+          input2Project2,
+          input2Project4,
+          output2,
+      });
+  assertCursorOutput(
+      plan,
+      {project1, project2, project3, project4},
+      {
+          input1Project1,
+          input1Project2,
+          input1Project3,
+          input1Project4,
+          output1,
+          input2Project1,
+          input2Project2,
+          input2Project3,
+          input2Project4,
+          output2,
+      });
+}
+
+TEST_F(CustomTraceTest, cursorAt) {
+  const size_t size = 10;
+  auto input1 = makeRowVector(
+      {"a"}, {makeFlatVector<int64_t>(size, [](auto row) { return row; })});
+  auto input2 = makeRowVector(
+      {"a"},
+      {makeFlatVector<int64_t>(size, [](auto row) { return row + 10; })});
+
+  core::PlanNodeId project1, project2, project3, project4;
+  auto plan = PlanBuilder()
+                  .values({input1, input2})
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project1)
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project2)
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project3)
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project4)
+                  .planNode();
+
+  auto cursor = TaskCursor::create({
+      .planNode = plan,
+      .serialExecution = true,
+      .breakpoints = toBreakpointsMap({project1, project3}),
+  });
+
+  // Before any step, at() should return empty string.
+  EXPECT_EQ(cursor->at(), "");
+
+  // First step stops at project1 (first breakpoint).
+  EXPECT_TRUE(cursor->moveStep());
+  EXPECT_EQ(cursor->at(), project1);
+
+  // Second step stops at project3 (second breakpoint).
+  EXPECT_TRUE(cursor->moveStep());
+  EXPECT_EQ(cursor->at(), project3);
+
+  // Third step produces final output (no breakpoint, empty at()).
+  EXPECT_TRUE(cursor->moveStep());
+  EXPECT_EQ(cursor->at(), "");
+
+  // Fourth step stops at project1 for second input batch.
+  EXPECT_TRUE(cursor->moveStep());
+  EXPECT_EQ(cursor->at(), project1);
+
+  // Fifth step stops at project3 for second input batch.
+  EXPECT_TRUE(cursor->moveStep());
+  EXPECT_EQ(cursor->at(), project3);
+
+  // Sixth step produces final output for second batch.
+  EXPECT_TRUE(cursor->moveStep());
+  EXPECT_EQ(cursor->at(), "");
+
+  // No more data.
+  EXPECT_FALSE(cursor->moveStep());
+
+  // Test that moveNext() skips breakpoints and at() returns empty.
+  auto cursor2 = TaskCursor::create({
+      .planNode = plan,
+      .serialExecution = true,
+      .breakpoints = toBreakpointsMap({project1, project3}),
+  });
+
+  EXPECT_EQ(cursor2->at(), "");
+
+  // moveNext() should skip to final output.
+  EXPECT_TRUE(cursor2->moveNext());
+  EXPECT_EQ(cursor2->at(), "");
+
+  EXPECT_TRUE(cursor2->moveNext());
+  EXPECT_EQ(cursor2->at(), "");
+
+  EXPECT_FALSE(cursor2->moveNext());
+}
+
+TEST_F(CustomTraceTest, breakpointCallbackAlwaysStop) {
+  const size_t size = 10;
+  auto input = makeRowVector(
+      {"a"}, {makeFlatVector<int64_t>(size, [](auto row) { return row; })});
+
+  core::PlanNodeId project1;
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project1)
+                  .planNode();
+
+  // Callback that always returns true (always stop).
+  int callbackCount = 0;
+  CursorParameters::TBreakpointMap breakpoints;
+  breakpoints[project1] = [&](const RowVectorPtr& vector) {
+    ++callbackCount;
+    EXPECT_EQ(vector->size(), size);
+    return true;
+  };
+
+  auto cursor = TaskCursor::create({
+      .planNode = plan,
+      .serialExecution = true,
+      .breakpoints = std::move(breakpoints),
+  });
+
+  // First step should stop at breakpoint.
+  EXPECT_TRUE(cursor->moveStep());
+  EXPECT_EQ(cursor->at(), project1);
+  EXPECT_EQ(callbackCount, 1);
+
+  // Second step should produce final output.
+  EXPECT_TRUE(cursor->moveStep());
+  EXPECT_EQ(cursor->at(), "");
+
+  EXPECT_FALSE(cursor->moveStep());
+}
+
+TEST_F(CustomTraceTest, breakpointCallbackNeverStop) {
+  const size_t size = 10;
+  auto input = makeRowVector(
+      {"a"}, {makeFlatVector<int64_t>(size, [](auto row) { return row; })});
+
+  core::PlanNodeId project1;
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project1)
+                  .planNode();
+
+  // Callback that always returns false (never stop).
+  int callbackCount = 0;
+  CursorParameters::TBreakpointMap breakpoints;
+  breakpoints[project1] = [&](const RowVectorPtr& vector) {
+    ++callbackCount;
+    EXPECT_EQ(vector->size(), size);
+    return false;
+  };
+
+  auto cursor = TaskCursor::create({
+      .planNode = plan,
+      .serialExecution = true,
+      .breakpoints = std::move(breakpoints),
+  });
+
+  // Step should skip the breakpoint and go directly to final output.
+  EXPECT_TRUE(cursor->moveStep());
+  EXPECT_EQ(cursor->at(), "");
+  EXPECT_EQ(callbackCount, 1); // Callback was still invoked.
+
+  EXPECT_FALSE(cursor->moveStep());
+}
+
+TEST_F(CustomTraceTest, breakpointCallbackConditional) {
+  const size_t size = 10;
+  auto input1 = makeRowVector(
+      {"a"}, {makeFlatVector<int64_t>(size, [](auto row) { return row; })});
+  auto input2 = makeRowVector(
+      {"a"},
+      {makeFlatVector<int64_t>(size, [](auto row) { return row + 100; })});
+
+  core::PlanNodeId project1;
+  auto plan = PlanBuilder()
+                  .values({input1, input2})
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project1)
+                  .planNode();
+
+  // Callback that stops only when first element is >= 100.
+  int callbackCount = 0;
+  CursorParameters::TBreakpointMap breakpoints;
+  breakpoints[project1] = [&](const RowVectorPtr& vector) {
+    ++callbackCount;
+    auto values = vector->childAt(0)->asFlatVector<int64_t>();
+    return values->valueAt(0) >= 100;
+  };
+
+  auto cursor = TaskCursor::create({
+      .planNode = plan,
+      .serialExecution = true,
+      .breakpoints = std::move(breakpoints),
+  });
+
+  // First batch: callback returns false (first element is 0), skips breakpoint.
+  // Goes to final output for first batch.
+  EXPECT_TRUE(cursor->moveStep());
+  EXPECT_EQ(cursor->at(), "");
+  EXPECT_EQ(callbackCount, 1);
+
+  // Second batch: callback returns true (first element is 100), stops at
+  // breakpoint.
+  EXPECT_TRUE(cursor->moveStep());
+  EXPECT_EQ(cursor->at(), project1);
+  EXPECT_EQ(callbackCount, 2);
+
+  // Final output for second batch.
+  EXPECT_TRUE(cursor->moveStep());
+  EXPECT_EQ(cursor->at(), "");
+
+  EXPECT_FALSE(cursor->moveStep());
+}
+
+TEST_F(CustomTraceTest, breakpointMixedCallbacks) {
+  const size_t size = 10;
+  auto input = makeRowVector(
+      {"a"}, {makeFlatVector<int64_t>(size, [](auto row) { return row; })});
+
+  core::PlanNodeId project1, project2;
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project1)
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project2)
+                  .planNode();
+
+  // project1 has callback returning false (don't stop).
+  // project2 has null callback (always stop).
+  int callbackCount = 0;
+  CursorParameters::TBreakpointMap breakpoints;
+  breakpoints[project1] = [&](const RowVectorPtr&) {
+    ++callbackCount;
+    return false;
+  };
+  breakpoints[project2] = nullptr; // null callback = always stop.
+
+  auto cursor = TaskCursor::create({
+      .planNode = plan,
+      .serialExecution = true,
+      .breakpoints = std::move(breakpoints),
+  });
+
+  // project1 callback returns false, so it's skipped.
+  // project2 has null callback, so it stops.
+  EXPECT_TRUE(cursor->moveStep());
+  EXPECT_EQ(cursor->at(), project2);
+  EXPECT_EQ(callbackCount, 1);
+
+  // Final output.
+  EXPECT_TRUE(cursor->moveStep());
+  EXPECT_EQ(cursor->at(), "");
+
+  EXPECT_FALSE(cursor->moveStep());
+}
+
+// Tests stepping through multiple input batches with a breakpoint on a single
+// operator using parallel execution. With 4 drivers each processing 3 batches,
+// we expect 12 breakpoint hits and 12 final outputs, interleaved in
+// non-deterministic order across drivers.
+TEST_F(CustomTraceTest, parallelSingleBreakpoint) {
+  const size_t size = 10;
+  auto input1 = makeRowVector(
+      {"a"}, {makeFlatVector<int64_t>(size, [](auto row) { return row; })});
+  auto input2 = makeRowVector(
+      {"a"},
+      {makeFlatVector<int64_t>(size, [](auto row) { return row + 10; })});
+  auto input3 = makeRowVector(
+      {"a"},
+      {makeFlatVector<int64_t>(size, [](auto row) { return row + 20; })});
+
+  core::PlanNodeId project1;
+  auto plan = PlanBuilder()
+                  .values({input1, input2, input3}, /*parallelizable=*/true)
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project1)
+                  .planNode();
+
+  constexpr int kNumDrivers = 4;
+  constexpr int kNumBatches = 3;
+
+  auto cursor = TaskCursor::create({
+      .planNode = plan,
+      .maxDrivers = kNumDrivers,
+      .breakpoints = toBreakpointsMap({project1}),
+  });
+
+  int numBreakpointHits = 0;
+  int numFinalOutputs = 0;
+
+  while (cursor->moveStep()) {
+    if (cursor->at() == project1) {
+      ++numBreakpointHits;
+    } else {
+      EXPECT_EQ(cursor->at(), "");
+      ++numFinalOutputs;
+    }
+  }
+
+  // Each of the 4 drivers processes all 3 batches, producing one breakpoint
+  // hit and one final output per batch.
+  EXPECT_EQ(numBreakpointHits, kNumDrivers * kNumBatches);
+  EXPECT_EQ(numFinalOutputs, kNumDrivers * kNumBatches);
+}
+
+// Tests that moveNext() in parallel mode skips breakpoints and only produces
+// final task outputs.
+TEST_F(CustomTraceTest, parallelMoveNext) {
+  const size_t size = 10;
+  auto input1 = makeRowVector(
+      {"a"}, {makeFlatVector<int64_t>(size, [](auto row) { return row; })});
+  auto input2 = makeRowVector(
+      {"a"},
+      {makeFlatVector<int64_t>(size, [](auto row) { return row + 10; })});
+  auto input3 = makeRowVector(
+      {"a"},
+      {makeFlatVector<int64_t>(size, [](auto row) { return row + 20; })});
+
+  core::PlanNodeId project1;
+  auto plan = PlanBuilder()
+                  .values({input1, input2, input3}, /*parallelizable=*/true)
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project1)
+                  .planNode();
+
+  constexpr int kNumDrivers = 4;
+  constexpr int kNumBatches = 3;
+
+  auto cursor = TaskCursor::create({
+      .planNode = plan,
+      .maxDrivers = kNumDrivers,
+      .breakpoints = toBreakpointsMap({project1}),
+  });
+
+  int numOutputs = 0;
+
+  // moveNext() should skip all breakpoints and only return final outputs.
+  while (cursor->moveNext()) {
+    EXPECT_EQ(cursor->at(), "") << "moveNext() should skip breakpoints";
+    ++numOutputs;
+  }
+
+  // Each of the 4 drivers processes all 3 batches, producing only final
+  // outputs (no breakpoint hits).
+  EXPECT_EQ(numOutputs, kNumDrivers * kNumBatches);
+}
+
+// Tests stepping through multiple input batches with breakpoints on multiple
+// operators using parallel execution. With 4 drivers each processing 3 batches
+// through 2 breakpoints, we expect 12 hits per breakpoint and 12 final outputs,
+// interleaved in non-deterministic order across drivers.
+TEST_F(CustomTraceTest, parallelMultipleBreakpoints) {
+  const size_t size = 10;
+  auto makeData = [&](std::function<int64_t(vector_size_t)> values) {
+    return makeRowVector(
+        {"a"}, {makeFlatVector<int64_t>(size, std::move(values))});
+  };
+
+  auto input1 = makeData([](auto row) { return row; });
+  auto input2 = makeData([](auto row) { return row + 10; });
+  auto input3 = makeData([](auto row) { return row + 20; });
+
+  core::PlanNodeId project1, project2;
+  auto plan = PlanBuilder()
+                  .values({input1, input2, input3}, /*parallelizable=*/true)
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project1)
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project2)
+                  .planNode();
+
+  constexpr int kNumDrivers = 4;
+  constexpr int kNumBatches = 3;
+
+  auto cursor = TaskCursor::create({
+      .planNode = plan,
+      .maxDrivers = kNumDrivers,
+      .breakpoints = toBreakpointsMap({project1, project2}),
+  });
+
+  int numProject1Hits = 0;
+  int numProject2Hits = 0;
+  int numFinalOutputs = 0;
+
+  while (cursor->moveStep()) {
+    if (cursor->at() == project1) {
+      ++numProject1Hits;
+    } else if (cursor->at() == project2) {
+      ++numProject2Hits;
+    } else {
+      EXPECT_EQ(cursor->at(), "");
+      ++numFinalOutputs;
+    }
+  }
+
+  // Each of the 4 drivers processes all 3 batches, hitting both breakpoints
+  // and producing one final output per batch.
+  EXPECT_EQ(numProject1Hits, kNumDrivers * kNumBatches);
+  EXPECT_EQ(numProject2Hits, kNumDrivers * kNumBatches);
+  EXPECT_EQ(numFinalOutputs, kNumDrivers * kNumBatches);
+}
+
+// Tests the debugger cursor with a hash join plan, which creates multiple
+// pipelines (probe and build). Verifies that breakpoints on operators in
+// different pipelines are all correctly hit.
+TEST_F(CustomTraceTest, parallelHashJoinBreakpoints) {
+  auto probeData = makeRowVector(
+      {"t_key", "t_val"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+          makeFlatVector<int64_t>({10, 20, 30, 40, 50}),
+      });
+
+  auto buildData = makeRowVector(
+      {"u_key", "u_val"},
+      {
+          makeFlatVector<int64_t>({1, 3, 5, 7}),
+          makeFlatVector<int64_t>({100, 300, 500, 700}),
+      });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  core::PlanNodeId probeProjectId;
+  core::PlanNodeId buildProjectId;
+  core::PlanNodeId joinId;
+
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeData}, /*parallelizable=*/true)
+                  .project({"t_key", "t_val * 10 as t_val"})
+                  .capturePlanNodeId(probeProjectId)
+                  .hashJoin(
+                      {"t_key"},
+                      {"u_key"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildData}, /*parallelizable=*/true)
+                          .project({"u_key", "u_val * 10 as u_val"})
+                          .capturePlanNodeId(buildProjectId)
+                          .planNode(),
+                      "",
+                      {"t_key", "t_val", "u_val"})
+                  .capturePlanNodeId(joinId)
+                  .planNode();
+
+  constexpr int kNumDrivers = 4;
+
+  auto cursor = TaskCursor::create({
+      .planNode = plan,
+      .maxDrivers = kNumDrivers,
+      .breakpoints = toBreakpointsMap({probeProjectId, buildProjectId}),
+  });
+
+  int numProbeProjectHits = 0;
+  int numBuildProjectHits = 0;
+  int numFinalOutputs = 0;
+
+  while (cursor->moveStep()) {
+    if (cursor->at() == probeProjectId) {
+      ++numProbeProjectHits;
+    } else if (cursor->at() == buildProjectId) {
+      ++numBuildProjectHits;
+    } else {
+      EXPECT_EQ(cursor->at(), "");
+      ++numFinalOutputs;
+    }
+  }
+
+  // Each driver processes the single probe batch (1 breakpoint hit per driver).
+  EXPECT_EQ(numProbeProjectHits, kNumDrivers);
+
+  // The build pipeline runs with a single driver regardless of maxDrivers, so
+  // only 1 breakpoint hit for the build project.
+  EXPECT_GT(numBuildProjectHits, 0);
+
+  // The join should produce at least one final output (the 3 matching rows).
+  EXPECT_GT(numFinalOutputs, 0);
+}
+
+// Tests that moveStep(planId) only stops at breakpoints matching the specified
+// plan node ID, skipping breakpoints for other nodes.
+TEST_F(CustomTraceTest, moveStepWithPlanId) {
+  const size_t size = 10;
+  auto input1 = makeRowVector(
+      {"a"}, {makeFlatVector<int64_t>(size, [](auto row) { return row; })});
+  auto input2 = makeRowVector(
+      {"a"},
+      {makeFlatVector<int64_t>(size, [](auto row) { return row + 10; })});
+
+  core::PlanNodeId project1, project2, project3;
+  auto plan = PlanBuilder()
+                  .values({input1, input2})
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project1)
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project2)
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project3)
+                  .planNode();
+
+  // Set breakpoints on all three project nodes.
+  auto cursor = TaskCursor::create({
+      .planNode = plan,
+      .serialExecution = true,
+      .breakpoints = toBreakpointsMap({project1, project2, project3}),
+  });
+
+  // Step targeting project2 should skip project1 and stop at project2.
+  EXPECT_TRUE(cursor->moveStep(project2));
+  EXPECT_EQ(cursor->at(), project2);
+
+  // Step targeting project3 should skip project2 (for the remaining pipeline)
+  // and stop at project3.
+  EXPECT_TRUE(cursor->moveStep(project3));
+  EXPECT_EQ(cursor->at(), project3);
+
+  // Step with no filter stops at the next breakpoint (project1 for second
+  // batch).
+  EXPECT_TRUE(cursor->moveStep());
+  EXPECT_EQ(cursor->at(), "");
+
+  // First batch final output was produced above. Now step targeting project1
+  // for the second input batch.
+  EXPECT_TRUE(cursor->moveStep(project1));
+  EXPECT_EQ(cursor->at(), project1);
+
+  // Step targeting project3 should skip project2 and stop at project3.
+  EXPECT_TRUE(cursor->moveStep(project3));
+  EXPECT_EQ(cursor->at(), project3);
+
+  // Final output for second batch.
+  EXPECT_TRUE(cursor->moveStep());
+  EXPECT_EQ(cursor->at(), "");
+
+  // No more data.
+  EXPECT_FALSE(cursor->moveStep());
+}
+
+// Tests that moveStep(planId) only stops at breakpoints matching the specified
+// plan node ID when using moveStep with no filter (empty planId), the original
+// behavior is preserved (stop at any breakpoint).
+TEST_F(CustomTraceTest, moveStepWithPlanIdDefaultBehavior) {
+  const size_t size = 10;
+  auto input = makeRowVector(
+      {"a"}, {makeFlatVector<int64_t>(size, [](auto row) { return row; })});
+
+  core::PlanNodeId project1, project2;
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project1)
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project2)
+                  .planNode();
+
+  auto cursor = TaskCursor::create({
+      .planNode = plan,
+      .serialExecution = true,
+      .breakpoints = toBreakpointsMap({project1, project2}),
+  });
+
+  // Default moveStep() (empty planId) should stop at project1.
+  EXPECT_TRUE(cursor->moveStep());
+  EXPECT_EQ(cursor->at(), project1);
+
+  // Default moveStep() should stop at project2.
+  EXPECT_TRUE(cursor->moveStep());
+  EXPECT_EQ(cursor->at(), project2);
+
+  // Final output.
+  EXPECT_TRUE(cursor->moveStep());
+  EXPECT_EQ(cursor->at(), "");
+
+  EXPECT_FALSE(cursor->moveStep());
+}
+
+// Tests moveStep(planId) with parallel execution.
+TEST_F(CustomTraceTest, parallelMoveStepWithPlanId) {
+  constexpr int kNumDrivers = 4;
+  constexpr int kNumBatches = 3;
+
+  std::vector<RowVectorPtr> batches;
+  for (int i = 0; i < kNumBatches; ++i) {
+    batches.push_back(makeRowVector(
+        {"a"},
+        {
+            makeFlatVector<int64_t>(
+                10, [&](auto row) { return row + i * 100; }),
+        }));
+  }
+
+  core::PlanNodeId project1, project2;
+  auto plan = PlanBuilder()
+                  .values(batches, /*parallelizable=*/true)
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project1)
+                  .project({"a * 10 as a"})
+                  .capturePlanNodeId(project2)
+                  .planNode();
+
+  auto cursor = TaskCursor::create({
+      .planNode = plan,
+      .maxDrivers = kNumDrivers,
+      .breakpoints = toBreakpointsMap({project1, project2}),
+  });
+
+  int numProject2Hits = 0;
+  int numFinalOutputs = 0;
+
+  // Only step to project2 breakpoints, skipping project1.
+  while (cursor->moveStep(project2)) {
+    if (cursor->at() == project2) {
+      ++numProject2Hits;
+    } else {
+      EXPECT_EQ(cursor->at(), "");
+      ++numFinalOutputs;
+    }
+  }
+
+  // Each of the 4 drivers processes all 3 batches, hitting project2 once per
+  // batch.
+  EXPECT_EQ(numProject2Hits, kNumDrivers * kNumBatches);
+  EXPECT_EQ(numFinalOutputs, kNumDrivers * kNumBatches);
+}
+
+} // namespace
+} // namespace facebook::velox::exec::trace::test
diff --git a/velox/exec/tests/DriverTest.cpp b/velox/exec/tests/DriverTest.cpp
index 275ed3bd345..2d72b9f7d6e 100644
--- a/velox/exec/tests/DriverTest.cpp
+++ b/velox/exec/tests/DriverTest.cpp
@@ -17,7 +17,7 @@
 #include <folly/init/Init.h>
 #include <velox/exec/Driver.h>
 #include <memory>
-#include "folly/experimental/EventCount.h"
+#include "folly/synchronization/EventCount.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
@@ -124,8 +124,9 @@ class DriverTest : public OperatorTestBase {
       bool addTestingPauser = false) {
     std::vector<RowVectorPtr> batches;
     for (int32_t i = 0; i < numBatches; ++i) {
-      batches.push_back(std::dynamic_pointer_cast<RowVector>(
-          BatchMaker::createBatch(rowType, rowsInBatch, *pool_)));
+      batches.push_back(
+          std::dynamic_pointer_cast<RowVector>(
+              BatchMaker::createBatch(rowType, rowsInBatch, *pool_)));
     }
     if (filterFunc) {
       int32_t hits = 0;
@@ -188,10 +189,11 @@ class DriverTest : public OperatorTestBase {
     bool paused = false;
     for (;;) {
       if (operation == ResultOperation::kPause && paused) {
-        if (!cursor->hasNext()) {
-          paused = false;
-          Task::resume(cursor->task());
-        }
+        // Resume the task so that next() can retrieve more data.
+        // If there's already buffered data, next() returns it immediately;
+        // otherwise it will wait for the resumed task to produce output.
+        paused = false;
+        Task::resume(cursor->task());
       }
       if (!cursor->next()) {
         break;
@@ -468,10 +470,11 @@ TEST_F(DriverTest, error) {
   EXPECT_EQ(numRead, 0);
   EXPECT_TRUE(stateFutures_.at(0).isReady());
   // Realized immediately since task not running.
-  EXPECT_TRUE(tasks_[0]
-                  ->taskCompletionFuture()
-                  .within(std::chrono::microseconds(1'000'000))
-                  .isReady());
+  EXPECT_TRUE(
+      tasks_[0]
+          ->taskCompletionFuture()
+          .within(std::chrono::microseconds(1'000'000))
+          .isReady());
   EXPECT_EQ(tasks_[0]->state(), TaskState::kFailed);
 }
 
@@ -799,8 +802,9 @@ TEST_F(DriverTest, pauserNode) {
   // all its Tasks in the test instance to create inter-Task pauses.
   static DriverTest* testInstance;
   testInstance = this;
-  Operator::registerOperator(std::make_unique<PauserNodeFactory>(
-      kThreadsPerTask, sequence, testInstance));
+  Operator::registerOperator(
+      std::make_unique<PauserNodeFactory>(
+          kThreadsPerTask, sequence, testInstance));
 
   std::vector<CursorParameters> params(kNumTasks);
   int32_t hits{0};
@@ -1614,7 +1618,8 @@ DEBUG_ONLY_TEST_F(DriverTest, driverCpuTimeSlicingCheck) {
           0,
           core::QueryCtx::create(
               driverExecutor_.get(), core::QueryConfig{std::move(queryConfig)}),
-          testParam.executionMode);
+          testParam.executionMode,
+          exec::Consumer{});
       while (task->next() != nullptr) {
       }
     }
diff --git a/velox/exec/tests/EnforceDistinctTest.cpp b/velox/exec/tests/EnforceDistinctTest.cpp
new file mode 100644
index 00000000000..b947ec63892
--- /dev/null
+++ b/velox/exec/tests/EnforceDistinctTest.cpp
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+using namespace facebook::velox::exec::test;
+
+namespace facebook::velox::exec {
+namespace {
+
+class EnforceDistinctTest : public OperatorTestBase {
+ protected:
+  core::PlanNodePtr makePlan(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<std::string>& keys,
+      const std::string& errorMessage) {
+    return PlanBuilder()
+        .values(input)
+        .enforceDistinct(keys, errorMessage)
+        .planNode();
+  }
+
+  core::PlanNodePtr makePlan(
+      const RowVectorPtr& input,
+      const std::string& key,
+      const std::string& errorMessage) {
+    return makePlan(
+        std::vector<RowVectorPtr>{input},
+        std::vector<std::string>{key},
+        errorMessage);
+  }
+
+  void assertDistinct(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<std::string>& keys) {
+    auto plan = makePlan(input, keys, "Duplicate key found");
+    AssertQueryBuilder(plan).assertResults(input);
+  }
+};
+
+TEST_F(EnforceDistinctTest, uniqueRowsSingleKey) {
+  auto data = makeRowVector({
+      makeNullableFlatVector<int32_t>({1, 2, 3, std::nullopt, 5, 6, 7, 8, 9}),
+      makeFlatVector<std::string>(
+          {"a", "a", "b", "b", "a", "a", "b", "b", "a"}),
+  });
+
+  assertDistinct(split(data, 3), {"c0"});
+}
+
+TEST_F(EnforceDistinctTest, uniqueRowsMultipleKeys) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({1, 1, 2, 2, 3, 3, 4, 4, 5}),
+      makeFlatVector<std::string>(
+          {"x", "x", "y", "y", "x", "x", "y", "y", "x"}),
+      makeFlatVector<int64_t>({10, 20, 10, 20, 10, 20, 10, 20, 10}),
+  });
+
+  assertDistinct(split(data, 3), {"c0", "c2"});
+}
+
+TEST_F(EnforceDistinctTest, duplicateWithinBatch) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 3, 2, 5}),
+  });
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(makePlan(data, "c0", "Duplicate key found"))
+          .countResults(),
+      "Duplicate key found");
+}
+
+TEST_F(EnforceDistinctTest, duplicateAcrossBatches) {
+  auto batch1 = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 3}),
+  });
+
+  auto batch2 = makeRowVector({
+      makeFlatVector<int32_t>({4, 2, 6}),
+  });
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(
+          makePlan({batch1, batch2}, {"c0"}, "Duplicate key found"))
+          .countResults(),
+      "Duplicate key found");
+}
+
+TEST_F(EnforceDistinctTest, emptyInput) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({}),
+  });
+
+  assertDistinct({data}, {"c0"});
+}
+
+TEST_F(EnforceDistinctTest, singleRow) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({42}),
+  });
+
+  assertDistinct({data}, {"c0"});
+}
+
+TEST_F(EnforceDistinctTest, duplicateNulls) {
+  auto data = makeRowVector({
+      makeNullableFlatVector<int32_t>({1, std::nullopt, 3, std::nullopt, 5}),
+  });
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(makePlan(data, "c0", "Duplicate key found"))
+          .countResults(),
+      "Duplicate key found");
+}
+
+} // namespace
+} // namespace facebook::velox::exec
diff --git a/velox/exec/tests/ExchangeClientTest.cpp b/velox/exec/tests/ExchangeClientTest.cpp
index f8a6a374eba..27d8404afd0 100644
--- a/velox/exec/tests/ExchangeClientTest.cpp
+++ b/velox/exec/tests/ExchangeClientTest.cpp
@@ -36,20 +36,19 @@ namespace {
 
 static constexpr int32_t kDefaultMinExchangeOutputBatchBytes{2 << 20}; // 2 MB.
 
-class ExchangeClientTest
-    : public testing::Test,
-      public velox::test::VectorTestBase,
-      public testing::WithParamInterface<VectorSerde::Kind> {
+class ExchangeClientTest : public testing::Test,
+                           public velox::test::VectorTestBase,
+                           public testing::WithParamInterface<std::string> {
  protected:
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
-    if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kPresto)) {
+    if (!isRegisteredNamedVectorSerde("Presto")) {
       serializer::presto::PrestoVectorSerde::registerNamedVectorSerde();
     }
-    if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kCompactRow)) {
+    if (!isRegisteredNamedVectorSerde("CompactRow")) {
       serializer::CompactRowVectorSerde::registerNamedVectorSerde();
     }
-    if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kUnsafeRow)) {
+    if (!isRegisteredNamedVectorSerde("UnsafeRow")) {
       serializer::spark::UnsafeRowVectorSerde::registerNamedVectorSerde();
     }
   }
@@ -85,13 +84,15 @@ class ExchangeClientTest
         executor_.get(), core::QueryConfig{std::move(config)});
     queryCtx->testingOverrideMemoryPool(
         memory::memoryManager()->addRootPool(queryCtx->queryId()));
-    auto plan = test::PlanBuilder().values({}).planNode();
+    auto plan =
+        test::PlanBuilder().values(std::vector<RowVectorPtr>{}).planNode();
     return Task::create(
         taskId,
         core::PlanFragment{plan},
         0,
         std::move(queryCtx),
-        Task::ExecutionMode::kParallel);
+        Task::ExecutionMode::kParallel,
+        exec::Consumer{});
   }
 
   int32_t enqueue(
@@ -108,9 +109,9 @@ class ExchangeClientTest
     return pageSize;
   }
 
-  std::vector<std::unique_ptr<SerializedPage>>
+  std::vector<std::unique_ptr<SerializedPageBase>>
   fetchPages(int consumerId, ExchangeClient& client, int32_t numPages) {
-    std::vector<std::unique_ptr<SerializedPage>> allPages;
+    std::vector<std::unique_ptr<SerializedPageBase>> allPages;
     for (auto i = 0; i < numPages; ++i) {
       bool atEnd{false};
       ContinueFuture future;
@@ -138,7 +139,7 @@ class ExchangeClientTest
 
   static void enqueue(
       ExchangeQueue& queue,
-      std::unique_ptr<SerializedPage> page) {
+      std::unique_ptr<SerializedPageBase> page) {
     std::vector<ContinuePromise> promises;
     {
       std::lock_guard<std::mutex> l(queue.mutex());
@@ -149,17 +150,17 @@ class ExchangeClientTest
     }
   }
 
-  static std::unique_ptr<SerializedPage> makePage(uint64_t size) {
+  static std::unique_ptr<SerializedPageBase> makePage(uint64_t size) {
     auto ioBuf = folly::IOBuf::create(size);
     ioBuf->append(size);
-    return std::make_unique<SerializedPage>(std::move(ioBuf), nullptr, 1);
+    return std::make_unique<PrestoSerializedPage>(std::move(ioBuf), nullptr, 1);
   }
 
   folly::Executor* executor() const {
     return executor_.get();
   }
 
-  VectorSerde::Kind serdeKind_;
+  std::string serdeKind_;
   std::unique_ptr<folly::CPUThreadPoolExecutor> executor_;
   std::shared_ptr<OutputBufferManager> bufferManager_;
 };
@@ -588,7 +589,7 @@ TEST_P(ExchangeClientTest, acknowledge) {
   SCOPED_TESTVALUE_SET(
       "facebook::velox::exec::test::LocalExchangeSource::pause",
       std::function<void(void*)>(([&numberOfAcknowledgeRequests](void*) {
-        numberOfAcknowledgeRequests++;
+        ++numberOfAcknowledgeRequests;
       })));
 
   {
@@ -609,10 +610,11 @@ TEST_P(ExchangeClientTest, acknowledge) {
     client->addRemoteTaskId(sourceTaskId);
     client->noMoreRemoteTasks();
 
-    ASSERT_TRUE(std::move(future)
-                    .via(executor())
-                    .wait(std::chrono::seconds{10})
-                    .isReady());
+    ASSERT_TRUE(
+        std::move(future)
+            .via(executor())
+            .wait(std::chrono::seconds{10})
+            .isReady());
 
 #ifndef NDEBUG
     // The client knew there is more data available but could not fetch any more
@@ -663,7 +665,7 @@ TEST_P(ExchangeClientTest, acknowledge) {
     int attempts = 100;
     bool outputBuffersEmpty;
     while (attempts > 0) {
-      attempts--;
+      --attempts;
       outputBuffersEmpty = bufferManager_->getUtilization(sourceTaskId) == 0;
       if (outputBuffersEmpty) {
         break;
@@ -689,10 +691,11 @@ TEST_P(ExchangeClientTest, acknowledge) {
   pages = client->next(1, 1, &atEnd, &dequeueEndOfDataFuture);
   ASSERT_EQ(0, pages.size());
 
-  ASSERT_TRUE(std::move(dequeueEndOfDataFuture)
-                  .via(executor())
-                  .wait(std::chrono::seconds{10})
-                  .isReady());
+  ASSERT_TRUE(
+      std::move(dequeueEndOfDataFuture)
+          .via(executor())
+          .wait(std::chrono::seconds{10})
+          .isReady());
   pages = client->next(1, 1, &atEnd, &dequeueEndOfDataFuture);
   ASSERT_EQ(0, pages.size());
   ASSERT_TRUE(atEnd);
@@ -976,13 +979,197 @@ TEST_P(ExchangeClientTest, minOutputBatchBytesMultipleConsumers) {
   client->close();
 }
 
+TEST_P(ExchangeClientTest, skipRequestDataSizeWithSingleSource) {
+  // Test skipRequestDataSizeWithSingleSource flag behavior
+
+  struct {
+    bool skipEnabled;
+
+    std::string debugString() const {
+      return fmt::format("skipEnabled={}", skipEnabled);
+    }
+  } testSettings[] = {
+      // skip enabled
+      {true},
+      // skip disabled
+      {false}};
+
+  for (const auto& setting : testSettings) {
+    SCOPED_TRACE(setting.debugString());
+
+    auto client = std::make_shared<ExchangeClient>(
+        "test-" + setting.debugString(),
+        17,
+        1024,
+        1,
+        kDefaultMinExchangeOutputBatchBytes,
+        pool(),
+        executor(),
+        10,
+        setting.skipEnabled);
+
+    client->close();
+  }
+}
+
+TEST_P(ExchangeClientTest, skipRequestDataSizeNotTriggeredWithMultipleSources) {
+  // Test that optimization is NOT triggered with multiple sources
+
+  auto data = makeRowVector({makeFlatVector<int64_t>(100, folly::identity)});
+  auto page = test::toSerializedPage(data, serdeKind_, bufferManager_, pool());
+
+  // Client with optimization ENABLED but multiple sources
+  auto client = std::make_shared<ExchangeClient>(
+      "test-multi-source",
+      17,
+      page->size() * 10,
+      1,
+      kDefaultMinExchangeOutputBatchBytes,
+      pool(),
+      executor(),
+      10,
+      // enableSingleSourceOptimization = true (but won't trigger with
+      // multiple sources)
+      true);
+
+  // Setup: Create tasks with TWO sources
+  std::vector<std::shared_ptr<Task>> tasks;
+  for (int i = 0; i < 2; ++i) {
+    auto taskId = fmt::format("local://test-source-{}", i);
+    auto task = makeTask(taskId);
+    bufferManager_->initializeTask(
+        task, core::PartitionedOutputNode::Kind::kPartitioned, 100, 16);
+
+    // Enqueue data
+    for (int j = 0; j < 3; ++j) {
+      enqueue(taskId, 17, data);
+    }
+
+    tasks.push_back(task);
+    client->addRemoteTaskId(taskId);
+  }
+
+  client->noMoreRemoteTasks();
+
+  // Fetch pages - should work with regular path (not single source
+  // optimization)
+  // 3 pages from each of 2 sources
+  auto pages = fetchPages(1, *client, 6);
+  ASSERT_EQ(pages.size(), 6);
+
+  // Cleanup: Signal no more data first to allow faster task termination,
+  // then cancel and remove tasks.
+  for (auto& task : tasks) {
+    bufferManager_->noMoreData(task->taskId());
+  }
+  for (auto& task : tasks) {
+    task->requestCancel();
+    bufferManager_->removeTask(task->taskId());
+  }
+  tasks.clear();
+
+  client->close();
+}
+
+// Test that lazyFetching=true defers data fetching until next() is called.
+// When lazyFetching=false (default), fetching starts immediately when remote
+// tasks are added via pickSourcesToRequestLocked(). When lazyFetching=true,
+// pickSourcesToRequestLocked() is not called in addRemoteTaskId(), deferring
+// the fetch until next() is called. This is useful for cached hash table
+// scenarios where waiter tasks may not need the data if the table is already
+// cached.
+TEST_P(ExchangeClientTest, lazyFetching) {
+  auto data = makeRowVector({makeFlatVector<int32_t>({1, 2, 3, 4, 5})});
+
+  // Test with lazyFetching=false (default behavior).
+  // Verify that fetching starts and we can retrieve pages normally.
+  {
+    auto taskId = "local://eager-fetching-test";
+    auto task = makeTask(taskId);
+
+    bufferManager_->initializeTask(
+        task, core::PartitionedOutputNode::Kind::kPartitioned, 100, 16);
+
+    auto client = std::make_shared<ExchangeClient>(
+        "t",
+        17,
+        ExchangeClient::kDefaultMaxQueuedBytes,
+        1,
+        kDefaultMinExchangeOutputBatchBytes,
+        pool(),
+        executor(),
+        10, // requestDataSizesMaxWaitSec
+        false, // skipRequestDataSizeWithSingleSource
+        false); // lazyFetching=false (default)
+
+    client->addRemoteTaskId(taskId);
+    enqueue(taskId, 17, data);
+
+    auto pages = fetchPages(1, *client, 1);
+    ASSERT_EQ(1, pages.size());
+
+    task->requestCancel();
+    bufferManager_->removeTask(taskId);
+    task.reset();
+    client->close();
+  }
+
+  // Test with lazyFetching=true.
+  // Verify that we can still retrieve pages (fetch is triggered by next()).
+  {
+    auto taskId = "local://lazy-fetching-test";
+    auto task = makeTask(taskId);
+
+    bufferManager_->initializeTask(
+        task, core::PartitionedOutputNode::Kind::kPartitioned, 100, 16);
+
+    auto client = std::make_shared<ExchangeClient>(
+        "t",
+        17,
+        ExchangeClient::kDefaultMaxQueuedBytes,
+        1,
+        kDefaultMinExchangeOutputBatchBytes,
+        pool(),
+        executor(),
+        10, // requestDataSizesMaxWaitSec
+        false, // skipRequestDataSizeWithSingleSource
+        true); // lazyFetching=true
+
+    client->addRemoteTaskId(taskId);
+    enqueue(taskId, 17, data);
+
+    // Even with lazy fetching, we should be able to retrieve pages
+    // since next() triggers the fetch.
+    auto pages = fetchPages(1, *client, 1);
+    ASSERT_EQ(1, pages.size());
+
+    task->requestCancel();
+    bufferManager_->removeTask(taskId);
+    task.reset();
+    client->close();
+  }
+}
+
+// Test the new hasNoMoreSources() API
+TEST_P(ExchangeClientTest, hasNoMoreSourcesApi) {
+  auto queue = std::make_shared<ExchangeQueue>(1, 0);
+
+  // Initially, should return false
+  EXPECT_FALSE(queue->hasNoMoreSources());
+
+  // After calling noMoreSources(), should return true
+  queue->noMoreSources();
+
+  EXPECT_TRUE(queue->hasNoMoreSources());
+}
+
 VELOX_INSTANTIATE_TEST_SUITE_P(
     ExchangeClientTest,
     ExchangeClientTest,
-    testing::Values(
-        VectorSerde::Kind::kPresto,
-        VectorSerde::Kind::kCompactRow,
-        VectorSerde::Kind::kUnsafeRow));
+    testing::Values("Presto", "CompactRow", "UnsafeRow"),
+    [](const testing::TestParamInfo<std::string>& info) {
+      return fmt::format("{}", info.param);
+    });
 
 } // namespace
 } // namespace facebook::velox::exec
diff --git a/velox/exec/tests/ExpandTest.cpp b/velox/exec/tests/ExpandTest.cpp
index f541d20c04a..c9fec2a0d7f 100644
--- a/velox/exec/tests/ExpandTest.cpp
+++ b/velox/exec/tests/ExpandTest.cpp
@@ -21,7 +21,6 @@ using namespace facebook::velox;
 using namespace facebook::velox::exec::test;
 
 namespace facebook::velox::exec {
-
 namespace {
 class ExpandTest : public OperatorTestBase {
  public:
@@ -37,7 +36,31 @@ class ExpandTest : public OperatorTestBase {
         });
   }
 };
-} // anonymous namespace
+
+TEST_F(ExpandTest, complexConstant) {
+  auto data = makeRowVectorData(3);
+  auto children = data->children();
+  auto arrayVector =
+      makeArrayVector<int64_t>({{1, 2, 3}, {1, 2, 3}, {1, 2, 3}});
+  children.push_back(arrayVector);
+  children.push_back(makeAllNullArrayVector(3, BIGINT()));
+  children.push_back(makeNullConstant(TypeKind::BIGINT, 3));
+  auto expected = makeRowVector(children);
+
+  auto plan = PlanBuilder(pool())
+                  .values({data})
+                  .expand(
+                      {{"k1",
+                        "k2",
+                        "a",
+                        "b",
+                        "ARRAY[1, 2, 3] as c",
+                        "null::bigint[] as d",
+                        "null::bigint as e"}})
+                  .planNode();
+
+  assertQuery(plan, expected);
+}
 
 TEST_F(ExpandTest, groupingSets) {
   auto data = makeRowVectorData(1'000);
@@ -151,4 +174,5 @@ TEST_F(ExpandTest, invalidUseCases) {
       "projections must not be empty.");
 }
 
+} // namespace
 } // namespace facebook::velox::exec
diff --git a/velox/exec/tests/ExpressionBuilderTest.cpp b/velox/exec/tests/ExpressionBuilderTest.cpp
new file mode 100644
index 00000000000..18f0a3dc879
--- /dev/null
+++ b/velox/exec/tests/ExpressionBuilderTest.cpp
@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/tests/utils/ExpressionBuilder.h"
+
+#include <gtest/gtest.h>
+#include "velox/parse/ExpressionsParser.h"
+#include "velox/type/Variant.h"
+
+namespace facebook::velox::expr_builder::test {
+namespace {
+
+// Test convenience functions for downcasting.
+template <typename T>
+std::shared_ptr<const T> as(detail::ExprWrapper in) {
+  return std::dynamic_pointer_cast<const T>(in.expr());
+}
+
+template <typename T>
+bool is(detail::ExprWrapper in) {
+  return std::dynamic_pointer_cast<const T>(in.expr()) != nullptr;
+}
+
+// Parses a SQL expression using DuckDB.
+core::ExprPtr parseSql(const std::string& sql) {
+  return parse::DuckSqlExpressionsParser().parseExpr(sql);
+}
+
+TEST(ExpressionBuilderTest, columnReference) {
+  EXPECT_EQ(col("c0"), parseSql("c0"));
+  EXPECT_EQ(parseSql("c0"), col("c0"));
+  EXPECT_EQ("c0"_c, parseSql("c0"));
+
+  EXPECT_EQ(col("parent", "child"), parseSql("parent.child"));
+  EXPECT_EQ(col("parent").subfield("child"), parseSql("parent.child"));
+}
+
+TEST(ExpressionBuilderTest, literals) {
+  auto validate = [](detail::ExprWrapper expr,
+                     const TypePtr& expectedType,
+                     variant expectedValue) {
+    EXPECT_TRUE(is<core::ConstantExpr>(expr));
+    auto constant = as<core::ConstantExpr>(expr);
+    EXPECT_EQ(*constant->type(), *expectedType);
+    EXPECT_TRUE(constant->value().equalsWithEpsilon(expectedValue));
+  };
+
+  // Integer literal types.
+  validate(lit(123456L), BIGINT(), variant(123456L));
+  validate(lit(123), INTEGER(), variant(123));
+  validate(lit(int16_t(123)), SMALLINT(), variant(int16_t(123)));
+  validate(lit(int8_t(123)), TINYINT(), variant(int8_t(123)));
+
+  // Boolean.
+  validate(lit(true), BOOLEAN(), variant(true));
+  validate(lit(false), BOOLEAN(), variant(false));
+
+  // Floating point.
+  validate(lit(10.1f), REAL(), variant(10.1f));
+  validate(lit(10.1), DOUBLE(), variant(10.1));
+
+  // String.
+  validate(lit("str"), VARCHAR(), variant("str"));
+
+  // Null.
+  validate(lit(nullptr), UNKNOWN(), variant::null(TypeKind::UNKNOWN));
+}
+
+TEST(ExpressionBuilderTest, comparisons) {
+  // Make sure all combinations work, as long as at least one side is a
+  // ExprWrapper.
+  EXPECT_EQ(col("a") == lit(10L), parseSql("a = 10"));
+  EXPECT_EQ(lit(10L) == col("a"), parseSql("10 = a"));
+
+  EXPECT_EQ(col("a") == 10L, parseSql("a = 10"));
+  EXPECT_EQ(10L == col("a"), parseSql("10 = a"));
+
+  EXPECT_EQ(col("a") == col("b"), parseSql("a = b"));
+  EXPECT_EQ(col("a") == nullptr, parseSql("a = null"));
+
+  // Other comparisons.
+  EXPECT_EQ(col("a") != 1.1, parseSql("a != 1.1"));
+  EXPECT_EQ(col("a") != lit(1.1), parseSql("a != 1.1"));
+  EXPECT_EQ(col("a") > 42L, parseSql("a > 42"));
+  EXPECT_EQ(col("a") >= 42L, parseSql("a >= 42"));
+  EXPECT_EQ(col("a") < 42L, parseSql("a < 42"));
+  EXPECT_EQ(col("a") <= 42L, parseSql("a <= 42"));
+
+  EXPECT_EQ(!col("a"), parseSql("not a"));
+  EXPECT_EQ(isNull(col("a")), parseSql("a is null"));
+  EXPECT_EQ(col("a").isNull(), parseSql("a is null"));
+  EXPECT_EQ(!isNull(col("a")), parseSql("a is not null"));
+  EXPECT_EQ(!col("a").isNull(), parseSql("a is not null"));
+
+  EXPECT_EQ(isNull("a"), parseSql("\'a\' is null")); // this is "a" literal.
+}
+
+TEST(ExpressionBuilderTest, between) {
+  EXPECT_EQ(between(col("a"), 0L, 10L), parseSql("a between 0 and 10"));
+
+  EXPECT_EQ(col("a").between(0L, 10L), parseSql("a between 0 and 10"));
+}
+
+TEST(ExpressionBuilderTest, arithmetics) {
+  EXPECT_EQ(col("b") + 1L, parseSql("b + 1"));
+  EXPECT_EQ(1L + col("b"), parseSql("1 + b"));
+  EXPECT_EQ(lit("str") + col("b"), parseSql("'str' + b"));
+
+  EXPECT_EQ(col("b") - 1L, parseSql("b - 1"));
+  EXPECT_EQ(col("b") * 1L, parseSql("b * 1"));
+  EXPECT_EQ(col("b") / 1L, parseSql("b / 1"));
+  EXPECT_EQ(col("b") % 1L, parseSql("b % 1"));
+
+  EXPECT_EQ(col("b") + 1L / col("c") * 10L, parseSql("b + 1 / c * 10"));
+}
+
+TEST(ExpressionBuilderTest, conjuncts) {
+  EXPECT_EQ(col("b") && 1L, parseSql("b and 1"));
+  EXPECT_EQ(col("b") || 1L, parseSql("b or 1"));
+  EXPECT_EQ(col("b") || false, parseSql("b or false"));
+
+  EXPECT_EQ(col("a") && col("b") || col("c"), parseSql("a and b or c"));
+}
+
+TEST(ExpressionBuilderTest, functions) {
+  EXPECT_EQ(call("func"), parseSql("func()"));
+  EXPECT_EQ(
+      call("func", col("a"), 100L, col("c")), parseSql("func(a, 100, c)"));
+
+  // Nested functions.
+  auto expr = call("f1", call("f2", col("a") > call("f3", col("d"))));
+  EXPECT_EQ(expr, parseSql("f1(f2(a > f3(d)))"));
+
+  expr = 10L * col("c1") > call("func", 3.4, col("g") / col("h"), call("j"));
+  EXPECT_EQ(expr, parseSql("10 * c1 > func(3.4, g / h, j())"));
+}
+
+TEST(ExpressionBuilderTest, casts) {
+  // Casts.
+  EXPECT_EQ(lit("1").cast(TINYINT()).toString(), "cast(1 as TINYINT)");
+  EXPECT_EQ(
+      col("c0").cast(VARBINARY()).toString(), "cast(\"c0\" as VARBINARY)");
+
+  EXPECT_EQ(cast(1, TINYINT()).toString(), "cast(1 as TINYINT)");
+  EXPECT_EQ(
+      cast(col("c0"), VARBINARY()).toString(), "cast(\"c0\" as VARBINARY)");
+
+  // Try casts.
+  EXPECT_EQ(lit("1").tryCast(TINYINT()).toString(), "try_cast(1 as TINYINT)");
+  EXPECT_EQ(
+      col("c0").tryCast(VARBINARY()).toString(),
+      "try_cast(\"c0\" as VARBINARY)");
+
+  EXPECT_EQ(tryCast(1, TINYINT()).toString(), "try_cast(1 as TINYINT)");
+  EXPECT_EQ(
+      tryCast(col("c0"), VARBINARY()).toString(),
+      "try_cast(\"c0\" as VARBINARY)");
+}
+
+TEST(ExpressionBuilderTest, alias) {
+  EXPECT_EQ(lit("str").alias("col"), parseSql("'str' as col"));
+  EXPECT_EQ(col("c1").alias("col"), parseSql("c1 as col"));
+  EXPECT_EQ((col("c1") > 1.1).alias("col"), parseSql("c1 > 1.1 as col"));
+
+  EXPECT_EQ(
+      col("c1").between(1L, 10L).alias("my_col"),
+      parseSql("c1 between 1 and 10 as my_col"));
+
+  // As a free function.
+  EXPECT_EQ(alias(col("c1") == "bla", "col"), parseSql("c1 = 'bla' as col"));
+}
+
+TEST(ExpressionBuilderTest, lambdas) {
+  EXPECT_EQ(lambda("x", 1L), parseSql("x -> 1"));
+  EXPECT_EQ(lambda({"x"}, 1L), parseSql("x -> 1"));
+  EXPECT_EQ(lambda({"x"}, col("x") + 1L), parseSql("x -> x + 1"));
+  EXPECT_EQ(
+      lambda({"x", "y"}, col("x") * col("y")), parseSql("(x, y) -> x * y"));
+}
+
+} // namespace
+} // namespace facebook::velox::expr_builder::test
diff --git a/velox/exec/tests/FilterProjectTest.cpp b/velox/exec/tests/FilterProjectTest.cpp
index d9923793ce7..37e6c2d5cff 100644
--- a/velox/exec/tests/FilterProjectTest.cpp
+++ b/velox/exec/tests/FilterProjectTest.cpp
@@ -20,6 +20,7 @@
 #include "velox/exec/tests/utils/PlanBuilder.h"
 
 namespace facebook::velox::exec {
+using namespace facebook::velox::common::testutil;
 namespace {
 
 class FilterProjectTest : public test::HiveConnectorTestBase {
@@ -351,7 +352,7 @@ TEST_F(FilterProjectTest, statsSplitter) {
                   .planNode();
 
   std::shared_ptr<Task> task;
-  test::AssertQueryBuilder(plan).runWithoutResults(task);
+  test::AssertQueryBuilder(plan).countResults(task);
 
   auto planStats = toPlanStats(task->taskStats());
 
@@ -377,11 +378,11 @@ TEST_F(FilterProjectTest, statsSplitter) {
 
 TEST_F(FilterProjectTest, barrier) {
   std::vector<RowVectorPtr> vectors;
-  std::vector<std::shared_ptr<test::TempFilePath>> tempFiles;
+  std::vector<std::shared_ptr<TempFilePath>> tempFiles;
   const int numSplits{5};
   for (int32_t i = 0; i < numSplits; ++i) {
     vectors.push_back(makeTestVector());
-    tempFiles.push_back(test::TempFilePath::create());
+    tempFiles.push_back(TempFilePath::create());
   }
   writeToFiles(toFilePaths(tempFiles), vectors);
   createDuckDbTable(vectors);
@@ -394,16 +395,27 @@ TEST_F(FilterProjectTest, barrier) {
                   .capturePlanNodeId(projectPlanNodeId)
                   .planNode();
   struct {
+    bool serialExecution;
     bool barrierExecution;
     int numOutputRows;
 
     std::string toString() const {
       return fmt::format(
-          "barrierExecution {}, numOutputRows {}",
+          "serialExecution {}, barrierExecution {}, numOutputRows {}",
+          serialExecution,
           barrierExecution,
           numOutputRows);
     }
-  } testSettings[] = {{true, 23}, {false, 23}, {true, 200}, {false, 200}};
+  } testSettings[] = {
+      {true, true, 23},
+      {true, false, 23},
+      {false, true, 23},
+      {false, false, 23},
+      {true, true, 200},
+      {true, false, 200},
+      {false, true, 200},
+      {false, false, 200},
+  };
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.toString());
     auto task =
@@ -415,7 +427,8 @@ TEST_F(FilterProjectTest, barrier) {
                 core::QueryConfig::kPreferredOutputBatchRows,
                 std::to_string(testData.numOutputRows))
             .splits(makeHiveConnectorSplits(tempFiles))
-            .serialExecution(true)
+            .serialExecution(testData.serialExecution)
+            .maxDrivers(testData.serialExecution ? 1 : 3)
             .barrierExecution(testData.barrierExecution)
             .assertResults("SELECT c0, c1, c0 + c1 FROM tmp WHERE c1 % 10 > 0");
     const auto taskStats = task->taskStats();
@@ -441,7 +454,7 @@ TEST_F(FilterProjectTest, lazyDereference) {
       makeRowVector({expected[0], expected[1]}),
       makeRowVector({makeRowVector({expected[2]})}),
   });
-  auto file = test::TempFilePath::create();
+  auto file = TempFilePath::create();
   writeToFile(file->getPath(), vector);
   CursorParameters params;
   params.copyResult = false;
diff --git a/velox/exec/tests/FilterToExpressionTest.cpp b/velox/exec/tests/FilterToExpressionTest.cpp
index 0e66e865fe1..8f84e04fede 100644
--- a/velox/exec/tests/FilterToExpressionTest.cpp
+++ b/velox/exec/tests/FilterToExpressionTest.cpp
@@ -16,9 +16,6 @@
 #include "velox/exec/tests/utils/FilterToExpression.h"
 #include <gtest/gtest.h>
 #include "velox/core/Expressions.h"
-#include "velox/core/QueryCtx.h"
-#include "velox/expression/Expr.h"
-#include "velox/expression/ExprToSubfieldFilter.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
 namespace facebook::velox::core::test {
@@ -30,14 +27,6 @@ class FilterToExpressionTest : public testing::Test,
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   }
 
-  // Helper method to create a row type for testing
-  RowTypePtr createTestRowType() {
-    return ROW(
-        {"a", "b", "c", "d", "e", "f"},
-        {BIGINT(), DOUBLE(), VARCHAR(), BOOLEAN(), REAL(), TIMESTAMP()});
-  }
-
-  // Helper method to verify expression type and structure
   void verifyExpr(
       const TypedExprPtr& expr,
       const std::string& expectedType,
@@ -50,28 +39,15 @@ class FilterToExpressionTest : public testing::Test,
     ASSERT_EQ(callExpr->name(), expectedName);
   }
 
-  // Helper method for round trip testing
-  void testRoundTrip(
-      const std::string& fieldName,
-      std::unique_ptr<common::Filter> filter);
-
-  core::ExpressionEvaluator* evaluator() {
-    return &evaluator_;
+  TypedExprPtr toExpr(const common::Filter* filter, const TypePtr& type) {
+    common::Subfield subfield("a");
+    return filterToExpr(subfield, filter, ROW({"a"}, {type}), pool());
   }
-
- private:
-  std::shared_ptr<memory::MemoryPool> pool_ =
-      memory::memoryManager()->addLeafPool();
-  std::shared_ptr<core::QueryCtx> queryCtx_{core::QueryCtx::create()};
-  exec::SimpleExpressionEvaluator evaluator_{queryCtx_.get(), pool_.get()};
 };
 
-TEST_F(FilterToExpressionTest, AlwaysTrue) {
+TEST_F(FilterToExpressionTest, alwaysTrue) {
   auto filter = std::make_unique<common::AlwaysTrue>();
-  common::Subfield subfield("a");
-  auto rowType = createTestRowType();
-
-  auto expr = filterToExpr(subfield, filter.get(), rowType, pool());
+  auto expr = toExpr(filter.get(), BIGINT());
 
   ASSERT_TRUE(expr != nullptr);
   ASSERT_EQ(expr->type()->toString(), "BOOLEAN");
@@ -81,12 +57,9 @@ TEST_F(FilterToExpressionTest, AlwaysTrue) {
   ASSERT_TRUE(constantExpr->value().value<TypeKind::BOOLEAN>());
 }
 
-TEST_F(FilterToExpressionTest, AlwaysFalse) {
+TEST_F(FilterToExpressionTest, alwaysFalse) {
   auto filter = std::make_unique<common::AlwaysFalse>();
-  common::Subfield subfield("a");
-  auto rowType = createTestRowType();
-
-  auto expr = filterToExpr(subfield, filter.get(), rowType, pool());
+  auto expr = toExpr(filter.get(), BIGINT());
 
   ASSERT_TRUE(expr != nullptr);
   ASSERT_EQ(expr->type()->toString(), "BOOLEAN");
@@ -96,24 +69,18 @@ TEST_F(FilterToExpressionTest, AlwaysFalse) {
   ASSERT_FALSE(constantExpr->value().value<TypeKind::BOOLEAN>());
 }
 
-TEST_F(FilterToExpressionTest, IsNull) {
+TEST_F(FilterToExpressionTest, isNull) {
   auto filter = std::make_unique<common::IsNull>();
-  common::Subfield subfield("a");
-  auto rowType = createTestRowType();
-
-  auto expr = filterToExpr(subfield, filter.get(), rowType, pool());
+  auto expr = toExpr(filter.get(), BIGINT());
 
   verifyExpr(expr, "BOOLEAN", "is_null");
   auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
   ASSERT_EQ(callExpr->inputs().size(), 1);
 }
 
-TEST_F(FilterToExpressionTest, IsNotNull) {
+TEST_F(FilterToExpressionTest, isNotNull) {
   auto filter = std::make_unique<common::IsNotNull>();
-  common::Subfield subfield("a");
-  auto rowType = createTestRowType();
-
-  auto expr = filterToExpr(subfield, filter.get(), rowType, pool());
+  auto expr = toExpr(filter.get(), BIGINT());
 
   verifyExpr(expr, "BOOLEAN", "not");
   auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
@@ -126,12 +93,9 @@ TEST_F(FilterToExpressionTest, IsNotNull) {
   ASSERT_EQ(isNullExpr->name(), "is_null");
 }
 
-TEST_F(FilterToExpressionTest, BoolValue) {
+TEST_F(FilterToExpressionTest, boolValue) {
   auto filter = std::make_unique<common::BoolValue>(true, false);
-  common::Subfield subfield("d");
-  auto rowType = createTestRowType();
-
-  auto expr = filterToExpr(subfield, filter.get(), rowType, pool());
+  auto expr = toExpr(filter.get(), BOOLEAN());
 
   verifyExpr(expr, "BOOLEAN", "eq");
   auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
@@ -148,12 +112,9 @@ TEST_F(FilterToExpressionTest, BoolValue) {
   ASSERT_EQ(constantExpr->value().value<TypeKind::BOOLEAN>(), true);
 }
 
-TEST_F(FilterToExpressionTest, BigintRangeSingleValue) {
+TEST_F(FilterToExpressionTest, bigintRangeSingleValue) {
   auto filter = std::make_unique<common::BigintRange>(42, 42, false);
-  common::Subfield subfield("a");
-  auto rowType = createTestRowType();
-
-  auto expr = filterToExpr(subfield, filter.get(), rowType, pool());
+  auto expr = toExpr(filter.get(), BIGINT());
 
   verifyExpr(expr, "BOOLEAN", "eq");
   auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
@@ -165,12 +126,9 @@ TEST_F(FilterToExpressionTest, BigintRangeSingleValue) {
   ASSERT_EQ(constantExpr->value().value<TypeKind::BIGINT>(), 42);
 }
 
-TEST_F(FilterToExpressionTest, BigintRangeWithRange) {
+TEST_F(FilterToExpressionTest, bigintRangeWithRange) {
   auto filter = std::make_unique<common::BigintRange>(10, 20, false);
-  common::Subfield subfield("a");
-  auto rowType = createTestRowType();
-
-  auto expr = filterToExpr(subfield, filter.get(), rowType, pool());
+  auto expr = toExpr(filter.get(), BIGINT());
 
   verifyExpr(expr, "BOOLEAN", "and");
   auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
@@ -187,12 +145,9 @@ TEST_F(FilterToExpressionTest, BigintRangeWithRange) {
   ASSERT_EQ(lessOrEqual->name(), "lte");
 }
 
-TEST_F(FilterToExpressionTest, NegatedBigintRangeSingleValue) {
+TEST_F(FilterToExpressionTest, negatedBigintRangeSingleValue) {
   auto filter = std::make_unique<common::NegatedBigintRange>(42, 42, false);
-  common::Subfield subfield("a");
-  auto rowType = createTestRowType();
-
-  auto expr = filterToExpr(subfield, filter.get(), rowType, pool());
+  auto expr = toExpr(filter.get(), BIGINT());
 
   // The implementation now uses getNonNegated() which creates a NOT expression
   // even for single values, so we expect "not" instead of "neq"
@@ -234,13 +189,10 @@ TEST_F(FilterToExpressionTest, NegatedBigintRangeSingleValue) {
   }
 }
 
-TEST_F(FilterToExpressionTest, DoubleRange) {
+TEST_F(FilterToExpressionTest, doubleRange) {
   auto filter = std::make_unique<common::DoubleRange>(
       1.5, false, false, 3.5, false, false, false);
-  common::Subfield subfield("b");
-  auto rowType = createTestRowType();
-
-  auto expr = filterToExpr(subfield, filter.get(), rowType, pool());
+  auto expr = toExpr(filter.get(), DOUBLE());
 
   verifyExpr(expr, "BOOLEAN", "and");
   auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
@@ -257,13 +209,10 @@ TEST_F(FilterToExpressionTest, DoubleRange) {
   ASSERT_EQ(lessOrEqual->name(), "lte");
 }
 
-TEST_F(FilterToExpressionTest, FloatRange) {
+TEST_F(FilterToExpressionTest, floatRange) {
   auto filter = std::make_unique<common::FloatRange>(
       1.5f, false, true, 3.5f, false, true, false);
-  common::Subfield subfield("e");
-  auto rowType = createTestRowType();
-
-  auto expr = filterToExpr(subfield, filter.get(), rowType, pool());
+  auto expr = toExpr(filter.get(), REAL());
 
   verifyExpr(expr, "BOOLEAN", "and");
   auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
@@ -280,13 +229,10 @@ TEST_F(FilterToExpressionTest, FloatRange) {
   ASSERT_EQ(lessThan->name(), "lt");
 }
 
-TEST_F(FilterToExpressionTest, BytesRange) {
+TEST_F(FilterToExpressionTest, bytesRange) {
   auto filter = std::make_unique<common::BytesRange>(
       "apple", false, false, "orange", false, false, false);
-  common::Subfield subfield("c");
-  auto rowType = createTestRowType();
-
-  auto expr = filterToExpr(subfield, filter.get(), rowType, pool());
+  auto expr = toExpr(filter.get(), VARCHAR());
 
   verifyExpr(expr, "BOOLEAN", "and");
   auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
@@ -303,13 +249,10 @@ TEST_F(FilterToExpressionTest, BytesRange) {
   ASSERT_EQ(lessOrEqual->name(), "lte");
 }
 
-TEST_F(FilterToExpressionTest, BigintValuesUsingHashTable) {
+TEST_F(FilterToExpressionTest, bigintValuesUsingHashTable) {
   std::vector<int64_t> values = {10, 20, 30};
   auto filter = common::createBigintValues(values, false);
-  common::Subfield subfield("a");
-  auto rowType = createTestRowType();
-
-  auto expr = filterToExpr(subfield, filter.get(), rowType, pool());
+  auto expr = toExpr(filter.get(), BIGINT());
 
   // The implementation creates an optimized expression: (range check) AND (in
   // check)
@@ -337,13 +280,10 @@ TEST_F(FilterToExpressionTest, BigintValuesUsingHashTable) {
   ASSERT_EQ(arrayExpr->inputs().size(), 3);
 }
 
-TEST_F(FilterToExpressionTest, BytesValues) {
+TEST_F(FilterToExpressionTest, bytesValues) {
   std::vector<std::string> values = {"apple", "banana", "orange"};
   auto filter = std::make_unique<common::BytesValues>(values, false);
-  common::Subfield subfield("c");
-  auto rowType = createTestRowType();
-
-  auto expr = filterToExpr(subfield, filter.get(), rowType, pool());
+  auto expr = toExpr(filter.get(), VARCHAR());
 
   verifyExpr(expr, "BOOLEAN", "in");
   auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
@@ -356,13 +296,10 @@ TEST_F(FilterToExpressionTest, BytesValues) {
   ASSERT_EQ(arrayExpr->inputs().size(), 3);
 }
 
-TEST_F(FilterToExpressionTest, NegatedBytesValues) {
+TEST_F(FilterToExpressionTest, negatedBytesValues) {
   std::vector<std::string> values = {"apple", "banana", "orange"};
   auto filter = std::make_unique<common::NegatedBytesValues>(values, false);
-  common::Subfield subfield("c");
-  auto rowType = createTestRowType();
-
-  auto expr = filterToExpr(subfield, filter.get(), rowType, pool());
+  auto expr = toExpr(filter.get(), VARCHAR());
 
   verifyExpr(expr, "BOOLEAN", "not");
   auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
@@ -375,14 +312,11 @@ TEST_F(FilterToExpressionTest, NegatedBytesValues) {
   ASSERT_TRUE(containsExpr->name() == "in" || containsExpr->name() == "or");
 }
 
-TEST_F(FilterToExpressionTest, NegatedBigintValuesUsingHashTable) {
+TEST_F(FilterToExpressionTest, negatedBigintValuesUsingHashTable) {
   std::vector<int64_t> values = {10, 20, 30};
   auto filter = std::make_unique<common::NegatedBigintValuesUsingHashTable>(
       10, 30, values, false);
-  common::Subfield subfield("a");
-  auto rowType = createTestRowType();
-
-  auto expr = filterToExpr(subfield, filter.get(), rowType, pool());
+  auto expr = toExpr(filter.get(), BIGINT());
 
   // The implementation creates a NOT expression for the optimized IN check
   verifyExpr(expr, "BOOLEAN", "not");
@@ -409,15 +343,12 @@ TEST_F(FilterToExpressionTest, NegatedBigintValuesUsingHashTable) {
   ASSERT_EQ(isNullExpr->name(), "is_null");
 }
 
-TEST_F(FilterToExpressionTest, TimestampRange) {
+TEST_F(FilterToExpressionTest, timestampRange) {
   auto timestamp1 = Timestamp::fromMillis(1609459200000); // 2021-01-01
   auto timestamp2 = Timestamp::fromMillis(1640995200000); // 2022-01-01
   auto filter =
       std::make_unique<common::TimestampRange>(timestamp1, timestamp2, false);
-  common::Subfield subfield("f");
-  auto rowType = createTestRowType();
-
-  auto expr = filterToExpr(subfield, filter.get(), rowType, pool());
+  auto expr = toExpr(filter.get(), TIMESTAMP());
 
   verifyExpr(expr, "BOOLEAN", "and");
   auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
@@ -434,23 +365,20 @@ TEST_F(FilterToExpressionTest, TimestampRange) {
   ASSERT_EQ(lessOrEqual->name(), "lte");
 }
 
-TEST_F(FilterToExpressionTest, BigintMultiRange) {
+TEST_F(FilterToExpressionTest, bigintMultiRange) {
   std::vector<std::unique_ptr<common::BigintRange>> ranges;
   ranges.push_back(std::make_unique<common::BigintRange>(10, 20, false));
   ranges.push_back(std::make_unique<common::BigintRange>(30, 40, false));
   auto filter =
       std::make_unique<common::BigintMultiRange>(std::move(ranges), false);
-  common::Subfield subfield("a");
-  auto rowType = createTestRowType();
-
-  auto expr = filterToExpr(subfield, filter.get(), rowType, pool());
+  auto expr = toExpr(filter.get(), BIGINT());
 
   verifyExpr(expr, "BOOLEAN", "or");
   auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
   ASSERT_EQ(callExpr->inputs().size(), 2);
 }
 
-TEST_F(FilterToExpressionTest, MultiRange) {
+TEST_F(FilterToExpressionTest, multiRange) {
   // Create a MultiRange filter with compatible filters for BIGINT field
   std::vector<std::unique_ptr<common::Filter>> filters;
 
@@ -464,10 +392,7 @@ TEST_F(FilterToExpressionTest, MultiRange) {
   filters.push_back(std::make_unique<common::BigintRange>(30, 40, false));
 
   auto filter = std::make_unique<common::MultiRange>(std::move(filters), false);
-  common::Subfield subfield("a");
-  auto rowType = createTestRowType();
-
-  auto expr = filterToExpr(subfield, filter.get(), rowType, pool());
+  auto expr = toExpr(filter.get(), BIGINT());
 
   // Verify the top-level expression is an OR
   verifyExpr(expr, "BOOLEAN", "or");
@@ -497,132 +422,4 @@ TEST_F(FilterToExpressionTest, MultiRange) {
   ASSERT_EQ(thirdInput->inputs().size(), 2);
 }
 
-// Helper method for round trip testing
-void FilterToExpressionTest::testRoundTrip(
-    const std::string& fieldName,
-    std::unique_ptr<common::Filter> filter) {
-  // Step 1: Convert filter to expression
-  common::Subfield subfield(fieldName);
-  auto rowType = createTestRowType();
-  auto expr = filterToExpr(subfield, filter.get(), rowType, pool());
-  ASSERT_TRUE(expr != nullptr);
-
-  // Step 2: Convert expression back to filter
-  auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
-  if (!callExpr) {
-    // Some filters like AlwaysTrue/AlwaysFalse convert to ConstantTypedExpr
-    // which can't be converted back to a filter
-    return;
-  }
-
-  // Special handling for BoolValue filter
-  if (filter->kind() == common::FilterKind::kBoolValue) {
-    // For BoolValue, we need to extract the eq expression from the and
-    // expression
-    if (callExpr->name() == "and" && callExpr->inputs().size() == 2) {
-      auto eqExpr =
-          std::dynamic_pointer_cast<const CallTypedExpr>(callExpr->inputs()[0]);
-      if (eqExpr && eqExpr->name() == "eq") {
-        callExpr = eqExpr;
-      }
-    }
-  }
-
-  // Special handling for "in" with array_constructor
-  if (callExpr->name() == "in" && callExpr->inputs().size() == 2) {
-    auto arrayExpr =
-        std::dynamic_pointer_cast<const CallTypedExpr>(callExpr->inputs()[1]);
-    if (arrayExpr && arrayExpr->name() == "array_constructor") {
-      // Use toSubfieldFilter for array_constructor expressions
-      auto [roundTripSubfield, roundTripFilter] =
-          exec::toSubfieldFilter(expr, evaluator());
-
-      // Step 3: Verify the round-tripped filter and subfield
-      ASSERT_TRUE(roundTripFilter != nullptr);
-      ASSERT_EQ(roundTripSubfield.toString(), subfield.toString());
-
-      // Compare filter properties - this will vary based on filter type
-      // For this test we'll just verify the filter kind is the same
-      ASSERT_EQ(roundTripFilter->kind(), filter->kind());
-      return;
-    }
-  }
-
-  // Special handling for range filters (and expressions)
-  if (callExpr->name() == "and" && callExpr->inputs().size() == 2) {
-    auto firstInput =
-        std::dynamic_pointer_cast<const CallTypedExpr>(callExpr->inputs()[0]);
-    auto secondInput =
-        std::dynamic_pointer_cast<const CallTypedExpr>(callExpr->inputs()[1]);
-
-    if (firstInput && secondInput && firstInput->name() == "gte" &&
-        secondInput->name() == "lte") {
-      // Extract the field and bounds
-      auto field = firstInput->inputs()[0];
-      auto lowerBound = firstInput->inputs()[1];
-      auto upperBound = secondInput->inputs()[1];
-
-      // Create a between expression
-      auto betweenExpr = std::make_shared<CallTypedExpr>(
-          callExpr->type(), "between", field, lowerBound, upperBound);
-
-      common::Subfield roundTripSubfield;
-      auto roundTripFilter =
-          exec::ExprToSubfieldFilterParser::getInstance()
-              ->leafCallToSubfieldFilter(
-                  *betweenExpr, roundTripSubfield, evaluator(), false);
-
-      // Step 3: Verify the round-tripped filter and subfield
-      ASSERT_TRUE(roundTripFilter != nullptr);
-      ASSERT_EQ(roundTripSubfield.toString(), subfield.toString());
-
-      // Compare filter properties - this will vary based on filter type
-      // For this test we'll just verify the filter kind is the same
-      ASSERT_EQ(roundTripFilter->kind(), filter->kind());
-      return;
-    }
-  }
-
-  // For all other expressions, use leafCallToSubfieldFilter directly
-  common::Subfield roundTripSubfield;
-  auto roundTripFilter =
-      exec::ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *callExpr, roundTripSubfield, evaluator(), false);
-
-  // Step 3: Verify the round-tripped filter and subfield
-  ASSERT_TRUE(roundTripFilter != nullptr);
-  ASSERT_EQ(roundTripSubfield.toString(), subfield.toString());
-
-  // Compare filter properties - this will vary based on filter type
-  // For this test we'll just verify the filter kind is the same
-  ASSERT_EQ(roundTripFilter->kind(), filter->kind());
-}
-
-// Round trip tests for various filter types
-TEST_F(FilterToExpressionTest, RoundTripBigintRangeSingleValue) {
-  auto filter = std::make_unique<common::BigintRange>(42, 42, false);
-  testRoundTrip("a", std::move(filter));
-}
-
-TEST_F(FilterToExpressionTest, RoundTripBigintRangeWithRange) {
-  auto filter = std::make_unique<common::BigintRange>(10, 20, false);
-  testRoundTrip("a", std::move(filter));
-}
-
-TEST_F(FilterToExpressionTest, RoundTripIsNull) {
-  auto filter = std::make_unique<common::IsNull>();
-  testRoundTrip("a", std::move(filter));
-}
-
-TEST_F(FilterToExpressionTest, RoundTripBoolValue) {
-  auto filter = std::make_unique<common::BoolValue>(true, false);
-  testRoundTrip("d", std::move(filter));
-}
-
-TEST_F(FilterToExpressionTest, RoundTripBytesRange) {
-  auto filter = std::make_unique<common::BytesRange>(
-      "apple", false, false, "orange", false, false, false);
-  testRoundTrip("c", std::move(filter));
-}
-
 } // namespace facebook::velox::core::test
diff --git a/velox/exec/tests/FunctionSignatureBuilderTest.cpp b/velox/exec/tests/FunctionSignatureBuilderTest.cpp
index 6ac14b0592a..832f32c957a 100644
--- a/velox/exec/tests/FunctionSignatureBuilderTest.cpp
+++ b/velox/exec/tests/FunctionSignatureBuilderTest.cpp
@@ -45,11 +45,12 @@ TEST_F(FunctionSignatureBuilderTest, basicTypeTests) {
 
   // Integer variables do not have to be used in the inputs, but in that case
   // must appear in the return.
-  ASSERT_NO_THROW(FunctionSignatureBuilder()
-                      .integerVariable("a")
-                      .returnType("DECIMAL(a, a)")
-                      .argumentType("integer")
-                      .build(););
+  ASSERT_NO_THROW(
+      FunctionSignatureBuilder()
+          .integerVariable("a")
+          .returnType("DECIMAL(a, a)")
+          .argumentType("integer")
+          .build(););
 
   VELOX_ASSERT_THROW(
       FunctionSignatureBuilder()
@@ -124,7 +125,7 @@ TEST_F(FunctionSignatureBuilderTest, typeParamTests) {
           .returnType("integer")
           .argumentType("row(..., varchar)")
           .build(),
-      "Failed to parse type signature [row(..., varchar)]: syntax error, unexpected COMMA");
+      "Failed to parse type signature [row(..., varchar)]: syntax error, unexpected ELLIPSIS");
 
   // Type params cant have type params.
   VELOX_ASSERT_THROW(
@@ -155,6 +156,60 @@ TEST_F(FunctionSignatureBuilderTest, anyInReturn) {
       "Type 'Any' cannot appear in return type");
 }
 
+TEST_F(FunctionSignatureBuilderTest, homogeneousRowInReturn) {
+  VELOX_ASSERT_USER_THROW(
+      exec::FunctionSignatureBuilder()
+          .typeVariable("T")
+          .returnType("row(T, ...)")
+          .argumentType("T")
+          .build(),
+      "Homogeneous row cannot appear in return type");
+
+  VELOX_ASSERT_USER_THROW(
+      exec::FunctionSignatureBuilder()
+          .returnType("array(row(bigint, ...))")
+          .argumentType("bigint")
+          .build(),
+      "Homogeneous row cannot appear in return type");
+}
+
+TEST_F(FunctionSignatureBuilderTest, variableArity) {
+  // .variableArity() requires at least one argument.
+  VELOX_ASSERT_USER_THROW(
+      exec::FunctionSignatureBuilder()
+          .returnType("bigint")
+          .variableArity()
+          .build(),
+      "Variable arity requires at least one argument");
+
+  // .variableArity() can be used only once.
+  VELOX_ASSERT_USER_THROW(
+      exec::FunctionSignatureBuilder()
+          .returnType("bigint")
+          .variableArity("bigint")
+          .variableArity("integer")
+          .build(),
+      "Cannot add arguments after variable arity argument");
+
+  VELOX_ASSERT_USER_THROW(
+      exec::FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("bigint")
+          .variableArity()
+          .variableArity()
+          .build(),
+      "Only one variable arity argument is allowed");
+
+  // No arguments can be added after calling .variableArity().
+  VELOX_ASSERT_USER_THROW(
+      exec::FunctionSignatureBuilder()
+          .returnType("bigint")
+          .variableArity("bigint")
+          .argumentType("boolean")
+          .build(),
+      "Cannot add arguments after variable arity argument");
+}
+
 TEST_F(FunctionSignatureBuilderTest, scalarConstantFlags) {
   {
     auto signature = FunctionSignatureBuilder()
diff --git a/velox/exec/tests/GroupedExecutionTest.cpp b/velox/exec/tests/GroupedExecutionTest.cpp
index 07fc21ba3f7..477a41b020a 100644
--- a/velox/exec/tests/GroupedExecutionTest.cpp
+++ b/velox/exec/tests/GroupedExecutionTest.cpp
@@ -17,16 +17,18 @@
 
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/memory/MemoryArbitrator.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
+#include "velox/common/testutil/TempFilePath.h"
 #include "velox/exec/Cursor.h"
 #include "velox/exec/OutputBufferManager.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/type/Type.h"
 
 namespace facebook::velox::exec::test {
+using namespace facebook::velox::common::testutil;
 
 class GroupedExecutionTest : public virtual HiveConnectorTestBase {
  protected:
@@ -547,7 +549,7 @@ TEST_F(GroupedExecutionTest, hashJoinWithMixedGroupedExecutionWithSpill) {
     }
 
     TestScopedSpillInjection scopedSpillInjection(triggerSpill ? 100 : 0);
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto spillDirectory = TempDirectoryPath::create();
     AssertQueryBuilder queryBuilder(duckDbQueryRunner_);
     queryBuilder.plan(plan)
         .spillDirectory(spillDirectory->getPath())
@@ -675,16 +677,25 @@ DEBUG_ONLY_TEST_F(
           }
         }));
 
+    const auto spillDirectory = TempDirectoryPath::create();
+    std::optional<common::SpillDiskOptions> spillOpts;
+    if (testData.enableSpill) {
+      spillOpts = common::SpillDiskOptions{
+          .spillDirPath = spillDirectory->getPath(),
+          .spillDirCreated = true,
+          .spillDirCreateCb = nullptr};
+    }
+
     auto task = exec::Task::create(
         "0",
         std::move(planFragment),
         0,
         std::move(queryCtx),
-        Task::ExecutionMode::kParallel);
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
-    if (testData.enableSpill) {
-      task->setSpillDirectory(spillDirectory->getPath());
-    }
+        Task::ExecutionMode::kParallel,
+        /*consumer=*/Consumer{},
+        /*memoryArbitrationPriority=*/0,
+        spillOpts,
+        /*onError=*/nullptr);
 
     // 'numDriversPerGroup' drivers max to execute one group at a time.
     task->start(numDriversPerGroup, testData.groupConcurrency);
@@ -817,15 +828,21 @@ DEBUG_ONLY_TEST_F(
         memory::testingRunArbitration(op->pool());
       }));
 
+  const auto spillDirectory = TempDirectoryPath::create();
+  common::SpillDiskOptions spillOpts{
+      .spillDirPath = spillDirectory->getPath(),
+      .spillDirCreated = true,
+      .spillDirCreateCb = nullptr};
+
   auto task = exec::Task::create(
       "0",
       std::move(planFragment),
       0,
       std::move(queryCtx),
-      Task::ExecutionMode::kParallel);
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
-
-  task->setSpillDirectory(spillDirectory->getPath());
+      Task::ExecutionMode::kParallel,
+      Consumer{},
+      /*memoryArbitrationPriority=*/0,
+      spillOpts);
 
   // 'numDriversPerGroup' drivers max to execute one group at a time.
   task->start(numDriversPerGroup, 1);
@@ -848,8 +865,8 @@ DEBUG_ONLY_TEST_F(
   }
 
   // Total drivers should be numDriversPerGroup * (numGroups + 1), but since
-  // probe does not receive termination signal, it cannot signal the build side
-  // to finish. we expect only build's numDriversPerGroup finished.
+  // probe does not receive termination signal, it cannot signal the build
+  // side to finish. we expect only build's numDriversPerGroup finished.
   waitForFinishedDrivers(task, numDriversPerGroup);
 
   // 'Delete results' from output buffer triggers 'set all output consumed',
@@ -1025,8 +1042,8 @@ TEST_F(GroupedExecutionTest, groupedExecutionWithHashAndNestedLoopJoin) {
       const std::unordered_set<int32_t> expectedSplitGroupIds({1, 5, 8});
       int numSplitGroupJoinNodes{0};
       task->pool()->visitChildren([&](memory::MemoryPool* childPool) -> bool {
-        if (folly::StringPiece(childPool->name())
-                .startsWith(fmt::format("node.{}[", joinNodeId))) {
+        if (childPool->name().starts_with(
+                fmt::format("node.{}[", joinNodeId))) {
           ++numSplitGroupJoinNodes;
           std::vector<std::string> parts;
           folly::split(".", childPool->name(), parts);
diff --git a/velox/exec/tests/HashJoinBridgeTest.cpp b/velox/exec/tests/HashJoinBridgeTest.cpp
index 8b91ce52bf5..ccf3d411b89 100644
--- a/velox/exec/tests/HashJoinBridgeTest.cpp
+++ b/velox/exec/tests/HashJoinBridgeTest.cpp
@@ -16,15 +16,15 @@
 #include "velox/exec/HashJoinBridge.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/exec/HashTable.h"
 #include "velox/exec/Spill.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
-using facebook::velox::exec::test::TempDirectoryPath;
 
 namespace facebook::velox::exec::test {
+using namespace facebook::velox::common::testutil;
 
 class HashJoinBridgeTestHelper {
  public:
@@ -44,11 +44,17 @@ class HashJoinBridgeTestHelper {
   HashJoinBridge* const bridge_;
 };
 
+namespace {
 struct TestParam {
   int32_t numProbers{1};
   int32_t numBuilders{1};
 };
 
+inline void PrintTo(const TestParam& param, std::ostream* os) {
+  *os << fmt::format(
+      "probers:{}_builders:{}", param.numProbers, param.numBuilders);
+}
+
 class HashJoinBridgeTest : public testing::Test,
                            public testing::WithParamInterface<TestParam> {
  public:
@@ -70,7 +76,7 @@ class HashJoinBridgeTest : public testing::Test,
 
   void SetUp() override {
     rng_.seed(1245);
-    tempDir_ = exec::test::TempDirectoryPath::create();
+    tempDir_ = TempDirectoryPath::create();
   }
 
   void TearDown() override {}
@@ -96,7 +102,7 @@ class HashJoinBridgeTest : public testing::Test,
           std::make_unique<VectorHasher>(rowType_->childAt(channel), channel));
     }
     return HashTable<true>::createForJoin(
-        std::move(keyHashers), {}, true, false, 1'000, pool_.get());
+        std::move(keyHashers), {}, true, false, false, 1'000, pool_.get());
   }
 
   std::vector<ContinueFuture> createEmptyFutures(int32_t count) {
@@ -670,12 +676,16 @@ TEST_P(HashJoinBridgeTest, hashJoinTableType) {
     std::vector<core::FieldAccessTypedExprPtr> buildKeys;
     std::vector<core::FieldAccessTypedExprPtr> probeKeys;
     for (uint32_t i = 0; i < testData.buildKeyType->size(); i++) {
-      buildKeys.push_back(std::make_shared<core::FieldAccessTypedExpr>(
-          testData.buildKeyType->childAt(i), testData.buildKeyType->nameOf(i)));
+      buildKeys.push_back(
+          std::make_shared<core::FieldAccessTypedExpr>(
+              testData.buildKeyType->childAt(i),
+              testData.buildKeyType->nameOf(i)));
     }
     for (uint32_t i = 0; i < testData.probeKeyType->size(); i++) {
-      probeKeys.push_back(std::make_shared<core::FieldAccessTypedExpr>(
-          testData.probeKeyType->childAt(i), testData.probeKeyType->nameOf(i)));
+      probeKeys.push_back(
+          std::make_shared<core::FieldAccessTypedExpr>(
+              testData.probeKeyType->childAt(i),
+              testData.probeKeyType->nameOf(i)));
     }
     const auto joinNode = std::make_shared<core::HashJoinNode>(
         "join-bridge-test",
@@ -724,4 +734,5 @@ TEST(HashJoinBridgeTest, hashJoinTableSpillType) {
     ASSERT_EQ(spillType->names(), testData.expectedTableSpillType->names());
   }
 }
+} // namespace
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/HashJoinTest.cpp b/velox/exec/tests/HashJoinTest.cpp
index 510e063e919..1f10c643ce5 100644
--- a/velox/exec/tests/HashJoinTest.cpp
+++ b/velox/exec/tests/HashJoinTest.cpp
@@ -17,13 +17,16 @@
 #include <re2/re2.h>
 
 #include <fmt/format.h>
-#include "folly/experimental/EventCount.h"
+#include "folly/synchronization/EventCount.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/exec/Cursor.h"
 #include "velox/exec/HashBuild.h"
 #include "velox/exec/HashJoinBridge.h"
+#include "velox/exec/HashProbe.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/tests/utils/ArbitratorTestUtil.h"
@@ -31,8 +34,8 @@
 #include "velox/exec/tests/utils/HashJoinTestBase.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/exec/tests/utils/VectorTestUtil.h"
+#include "velox/type/tests/utils/CustomTypesForTesting.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
 using namespace facebook::velox;
@@ -44,27 +47,35 @@ using facebook::velox::test::BatchMaker;
 namespace facebook::velox::exec {
 namespace {
 
-class HashJoinTest : public HashJoinTestBase {
+class HashJoinTest : public HashJoinTestBase,
+                     public testing::WithParamInterface<TestParam> {
  public:
-  HashJoinTest() : HashJoinTestBase(TestParam(1)) {}
+  HashJoinTest() : HashJoinTestBase(GetParam()) {}
 
   explicit HashJoinTest(const TestParam& param) : HashJoinTestBase(param) {}
+
+  static std::vector<TestParam> getTestParams() {
+    return std::vector<TestParam>({TestParam{1, false}, TestParam{1, true}});
+  }
 };
 
-class MultiThreadedHashJoinTest
-    : public HashJoinTest,
-      public testing::WithParamInterface<TestParam> {
+class MultiThreadedHashJoinTest : public HashJoinTest {
  public:
   MultiThreadedHashJoinTest() : HashJoinTest(GetParam()) {}
 
   static std::vector<TestParam> getTestParams() {
-    return std::vector<TestParam>({TestParam{1}, TestParam{3}});
+    return std::vector<TestParam>(
+        {TestParam{1, false},
+         TestParam{1, true},
+         TestParam{3, false},
+         TestParam{3, true}});
   }
 };
 
 TEST_P(MultiThreadedHashJoinTest, bigintArray) {
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .keyTypes({BIGINT()})
       .probeVectors(1600, 5)
       .buildVectors(1500, 5)
@@ -76,6 +87,7 @@ TEST_P(MultiThreadedHashJoinTest, bigintArray) {
 TEST_P(MultiThreadedHashJoinTest, outOfJoinKeyColumnOrder) {
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeType(probeType_)
       .probeKeys({"t_k2"})
       .probeVectors(5, 10)
@@ -91,6 +103,7 @@ TEST_P(MultiThreadedHashJoinTest, outOfJoinKeyColumnOrder) {
 TEST_P(MultiThreadedHashJoinTest, joinWithCancellation) {
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .keyTypes({BIGINT()})
       .probeVectors(1600, 5)
       .buildVectors(1500, 5)
@@ -105,9 +118,10 @@ TEST_P(MultiThreadedHashJoinTest, joinWithCancellation) {
 }
 
 TEST_P(MultiThreadedHashJoinTest, testJoinWithSpillenabledCancellation) {
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .keyTypes({BIGINT()})
       .probeVectors(1600, 5)
       .buildVectors(1500, 5)
@@ -128,6 +142,7 @@ TEST_P(MultiThreadedHashJoinTest, emptyBuild) {
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .keyTypes({BIGINT()})
         .probeVectors(1600, 5)
         .buildVectors(0, 5)
@@ -159,6 +174,7 @@ TEST_P(MultiThreadedHashJoinTest, emptyBuild) {
 TEST_P(MultiThreadedHashJoinTest, emptyProbe) {
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .keyTypes({BIGINT()})
       .probeVectors(0, 5)
       .buildVectors(1500, 5)
@@ -195,6 +211,7 @@ TEST_P(MultiThreadedHashJoinTest, emptyProbe) {
 TEST_P(MultiThreadedHashJoinTest, normalizedKey) {
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .keyTypes({BIGINT(), VARCHAR()})
       .probeVectors(1600, 5)
       .buildVectors(1500, 5)
@@ -220,6 +237,7 @@ DEBUG_ONLY_TEST_P(MultiThreadedHashJoinTest, parallelJoinBuildCheck) {
       std::function<void(void*)>([&](void*) { isParallelBuild = true; }));
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .keyTypes({BIGINT(), VARCHAR()})
       .probeVectors(1600, 5)
       .buildVectors(1500, 5)
@@ -250,6 +268,7 @@ DEBUG_ONLY_TEST_P(
   VELOX_ASSERT_THROW(
       HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
           .numDrivers(numDrivers_)
+          .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
           .keyTypes({BIGINT(), VARCHAR()})
           .probeVectors(1600, 5)
           .buildVectors(1500, 5)
@@ -280,6 +299,7 @@ TEST_P(MultiThreadedHashJoinTest, allTypes) {
 TEST_P(MultiThreadedHashJoinTest, filter) {
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .keyTypes({BIGINT()})
       .probeVectors(1600, 5)
       .buildVectors(1500, 5)
@@ -289,8 +309,101 @@ TEST_P(MultiThreadedHashJoinTest, filter) {
       .run();
 }
 
+// Regression test for a JoinFuzzer-found bug where HashProbe::evalFilter
+// produces a DictionaryVector<bool> with indices pointing past the base
+// vector's size. The issue involves the filter "t_N = true" on a
+// dictionary-encoded probe boolean column combined with expression
+// memoization across multiple output batches from the same probe input.
+// In debug builds, this triggers a validation failure in
+// DictionaryVector::validate().
+//
+// This test exercises the same code path: hash join with boolean filter on
+// a probe column that is also a join key, using dictionary-encoded probe
+// input (matching the fuzzer's ENCODED input type) and small output batch
+// sizes to force multiple output batches from the same probe input.
+TEST_P(HashJoinTest, booleanJoinFilterDictionaryValidation) {
+  VectorFuzzer::Options opts;
+  opts.nullRatio = 0.1;
+
+  for (int seed = 0; seed < 20; ++seed) {
+    SCOPED_TRACE(fmt::format("seed: {}", seed));
+    opts.vectorSize = 10 + (seed % 20);
+    VectorFuzzer fuzzer(opts, pool_.get(), seed);
+
+    auto probeType = ROW({"t0", "t1"}, {INTEGER(), BOOLEAN()});
+    auto buildType = ROW({"u0", "u1"}, {INTEGER(), BOOLEAN()});
+
+    // Use fuzzRow which wraps columns in dictionary/constant encoding,
+    // matching the JoinFuzzer's ENCODED input type.
+    std::vector<RowVectorPtr> probeVectors = {fuzzer.fuzzRow(probeType)};
+    std::vector<RowVectorPtr> buildVectors = {fuzzer.fuzzRow(buildType)};
+
+    for (int batchSize : {3, 5}) {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .numDrivers(1)
+          .probeKeys({"t0", "t1"})
+          .probeVectors(std::vector<RowVectorPtr>(probeVectors))
+          .buildKeys({"u0", "u1"})
+          .buildVectors(std::vector<RowVectorPtr>(buildVectors))
+          .joinFilter("t1 = true")
+          .joinOutputLayout({"t0", "t1", "u0", "u1"})
+          .config(
+              core::QueryConfig::kPreferredOutputBatchRows,
+              std::to_string(batchSize))
+          .config(
+              core::QueryConfig::kMaxOutputBatchRows, std::to_string(batchSize))
+          .injectSpill(false)
+          .referenceQuery(
+              "SELECT t.t0, t.t1, u.u0, u.u1 FROM t, u "
+              "WHERE t.t0 = u.u0 AND t.t1 = u.u1 AND t.t1 = true")
+          .run();
+    }
+  }
+}
+
+// Same as above but with the boolean filter column as a non-key payload
+// column, exercising a slightly different code path where only integer
+// keys are used for join matching.
+TEST_P(HashJoinTest, booleanPayloadFilterDictionaryValidation) {
+  VectorFuzzer::Options opts;
+  opts.nullRatio = 0.1;
+
+  for (int seed = 0; seed < 20; ++seed) {
+    SCOPED_TRACE(fmt::format("seed: {}", seed));
+    opts.vectorSize = 10 + (seed % 20);
+    VectorFuzzer fuzzer(opts, pool_.get(), seed);
+
+    auto probeType = ROW({"t0", "t1"}, {INTEGER(), BOOLEAN()});
+    auto buildType = ROW({"u0", "u1"}, {INTEGER(), BOOLEAN()});
+
+    std::vector<RowVectorPtr> probeVectors = {fuzzer.fuzzRow(probeType)};
+    std::vector<RowVectorPtr> buildVectors = {fuzzer.fuzzRow(buildType)};
+
+    for (int batchSize : {3, 5}) {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .numDrivers(1)
+          .probeKeys({"t0"})
+          .probeVectors(std::vector<RowVectorPtr>(probeVectors))
+          .buildKeys({"u0"})
+          .buildVectors(std::vector<RowVectorPtr>(buildVectors))
+          .joinFilter("t1 = true")
+          .joinOutputLayout({"t0", "t1", "u0", "u1"})
+          .config(
+              core::QueryConfig::kPreferredOutputBatchRows,
+              std::to_string(batchSize))
+          .config(
+              core::QueryConfig::kMaxOutputBatchRows, std::to_string(batchSize))
+          .injectSpill(false)
+          .referenceQuery(
+              "SELECT t.t0, t.t1, u.u0, u.u1 FROM t, u "
+              "WHERE t.t0 = u.u0 AND t.t1 = true")
+          .run();
+    }
+  }
+}
+
 DEBUG_ONLY_TEST_P(MultiThreadedHashJoinTest, filterSpillOnFirstProbeInput) {
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
   std::atomic_bool injectProbeSpillOnce{true};
   SCOPED_TESTVALUE_SET(
       "facebook::velox::exec::Driver::runInternal::getOutput",
@@ -312,6 +425,7 @@ DEBUG_ONLY_TEST_P(MultiThreadedHashJoinTest, filterSpillOnFirstProbeInput) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .keyTypes({BIGINT()})
       .numDrivers(1)
       .probeVectors(1600, 5)
@@ -362,6 +476,7 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithNull) {
 
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeType(probeType_)
         .probeKeys({"t_k2"})
         .probeVectors(std::move(probeVectors))
@@ -380,6 +495,75 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithNull) {
   }
 }
 
+// Verifies that nullAsValue flag makes NULL keys match each other in anti and
+// left semi filter joins, as required by SQL set operations (EXCEPT,
+// INTERSECT).
+TEST_P(MultiThreadedHashJoinTest, nullAsValueAntiJoin) {
+  // Probe: (1, null), (2, 3). Build: (1, null), (2, 4).
+  // With nullAsValue, (1, null) matches on both keys and is anti-joined away.
+  // (2, 3) does not match (2, 4) because 3 != 4, so it passes through.
+  auto probeVector = makeRowVector(
+      {"c0", "c1"},
+      {makeNullableFlatVector<int32_t>({1, 2}),
+       makeNullableFlatVector<int32_t>({std::nullopt, 3})});
+  auto buildVector = makeRowVector(
+      {"u0", "u1"},
+      {makeNullableFlatVector<int32_t>({1, 2}),
+       makeNullableFlatVector<int32_t>({std::nullopt, 4})});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values({probeVector})
+          .hashJoin(
+              {"c0", "c1"},
+              {"u0", "u1"},
+              PlanBuilder(planNodeIdGenerator).values({buildVector}).planNode(),
+              "",
+              {"c0", "c1"},
+              core::JoinType::kAnti,
+              /*nullAware=*/false,
+              /*nullAsValue=*/true)
+          .planNode();
+  AssertQueryBuilder(plan).assertResults(makeRowVector(
+      {"c0", "c1"},
+      {makeNullableFlatVector<int32_t>({2}),
+       makeNullableFlatVector<int32_t>({3})}));
+}
+
+TEST_P(MultiThreadedHashJoinTest, nullAsValueSemiJoin) {
+  // Probe: (1, null), (2, 3). Build: (1, null), (2, 4).
+  // With nullAsValue, (1, null) matches and passes through semi join.
+  // (2, 3) does not match (2, 4), so it is filtered out.
+  auto probeVector = makeRowVector(
+      {"c0", "c1"},
+      {makeNullableFlatVector<int32_t>({1, 2}),
+       makeNullableFlatVector<int32_t>({std::nullopt, 3})});
+  auto buildVector = makeRowVector(
+      {"u0", "u1"},
+      {makeNullableFlatVector<int32_t>({1, 2}),
+       makeNullableFlatVector<int32_t>({std::nullopt, 4})});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values({probeVector})
+          .hashJoin(
+              {"c0", "c1"},
+              {"u0", "u1"},
+              PlanBuilder(planNodeIdGenerator).values({buildVector}).planNode(),
+              "",
+              {"c0", "c1"},
+              core::JoinType::kLeftSemiFilter,
+              /*nullAware=*/false,
+              /*nullAsValue=*/true)
+          .planNode();
+  AssertQueryBuilder(plan).assertResults(makeRowVector(
+      {"c0", "c1"},
+      {makeNullableFlatVector<int32_t>({1}),
+       makeNullableFlatVector<int32_t>({std::nullopt})}));
+}
+
 TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithLargeOutput) {
   // Build the identical left and right vectors to generate large join
   // outputs.
@@ -401,6 +585,7 @@ TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithLargeOutput) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeKeys({"t0"})
       .probeVectors(std::move(probeVectors))
       .buildKeys({"u0"})
@@ -452,6 +637,7 @@ TEST_P(MultiThreadedHashJoinTest, arrayBasedLookup) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeKeys({"c0"})
       .probeVectors(std::move(probeVectors))
       .buildKeys({"c0"})
@@ -518,6 +704,7 @@ TEST_P(MultiThreadedHashJoinTest, joinSidesDifferentSchema) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeKeys({"t_c0"})
       .probeVectors(std::move(probeVectors))
       .probeProjections({"c0 AS t_c0", "c1 AS t_c1", "c2 AS t_c2"})
@@ -557,6 +744,7 @@ TEST_P(MultiThreadedHashJoinTest, innerJoinWithEmptyBuild) {
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"c0"})
         .probeVectors(std::move(probeVectors))
         .buildKeys({"c0"})
@@ -591,6 +779,7 @@ TEST_P(MultiThreadedHashJoinTest, innerJoinWithEmptyBuild) {
 TEST_P(MultiThreadedHashJoinTest, leftSemiJoinFilter) {
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeType(probeType_)
       .probeVectors(174, 5)
       .probeKeys({"t_k1"})
@@ -627,6 +816,7 @@ TEST_P(MultiThreadedHashJoinTest, leftSemiJoinFilterWithEmptyBuild) {
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"c0"})
         .probeVectors(std::move(probeVectors))
         .buildKeys({"c0"})
@@ -668,6 +858,7 @@ TEST_P(MultiThreadedHashJoinTest, leftSemiJoinFilterWithExtraFilter) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"u0"})
@@ -684,6 +875,7 @@ TEST_P(MultiThreadedHashJoinTest, leftSemiJoinFilterWithExtraFilter) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"u0"})
@@ -700,6 +892,7 @@ TEST_P(MultiThreadedHashJoinTest, leftSemiJoinFilterWithExtraFilter) {
 TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilter) {
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeType(probeType_)
       .probeVectors(133, 3)
       .probeKeys({"t_k1"})
@@ -741,6 +934,7 @@ TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithEmptyBuild) {
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::move(probeVectors))
         .buildKeys({"u0"})
@@ -798,6 +992,7 @@ TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithAllMatches) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeKeys({"t0"})
       .probeVectors(std::move(probeVectors))
       .buildKeys({"u0"})
@@ -833,6 +1028,7 @@ TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithExtraFilter) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"u0"})
@@ -855,6 +1051,7 @@ TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithExtraFilter) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"u0"})
@@ -876,6 +1073,7 @@ TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithExtraFilter) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"u0"})
@@ -941,23 +1139,21 @@ TEST_P(MultiThreadedHashJoinTest, semiFilterOverLazyVectors) {
                       core::JoinType::kLeftSemiFilter)
                   .planNode();
 
-  SplitInput splitInput = {
-      {probeScanId,
-       {exec::Split(makeHiveConnectorSplit(probeFile->getPath()))}},
-      {buildScanId,
-       {exec::Split(makeHiveConnectorSplit(buildFile->getPath()))}},
+  SplitPath splitPaths = {
+      {probeScanId, {probeFile->getPath()}},
+      {buildScanId, {buildFile->getPath()}},
   };
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .planNode(plan)
-      .inputSplits(splitInput)
+      .inputSplits(splitPaths)
       .checkSpillStats(false)
       .referenceQuery("SELECT t0, t1 FROM t WHERE t0 IN (SELECT u0 FROM u)")
       .run();
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .planNode(flipJoinSides(plan))
-      .inputSplits(splitInput)
+      .inputSplits(splitPaths)
       .checkSpillStats(false)
       .referenceQuery("SELECT t0, t1 FROM t WHERE t0 IN (SELECT u0 FROM u)")
       .run();
@@ -981,7 +1177,7 @@ TEST_P(MultiThreadedHashJoinTest, semiFilterOverLazyVectors) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .planNode(plan)
-      .inputSplits(splitInput)
+      .inputSplits(splitPaths)
       .checkSpillStats(false)
       .referenceQuery(
           "SELECT t0, t1 FROM t WHERE t0 IN (SELECT u0 FROM u WHERE (t1 + u1) % 3 = 0)")
@@ -989,7 +1185,7 @@ TEST_P(MultiThreadedHashJoinTest, semiFilterOverLazyVectors) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .planNode(flipJoinSides(plan))
-      .inputSplits(splitInput)
+      .inputSplits(splitPaths)
       .checkSpillStats(false)
       .referenceQuery(
           "SELECT t0, t1 FROM t WHERE t0 IN (SELECT u0 FROM u WHERE (t1 + u1) % 3 = 0)")
@@ -1019,6 +1215,7 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoin) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"c0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"c0"})
@@ -1039,6 +1236,7 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoin) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"c0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"c0"})
@@ -1059,6 +1257,7 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoin) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"c0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"c0"})
@@ -1096,6 +1295,7 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilter) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeKeys({"t0"})
       .probeVectors(std::move(probeVectors))
       .buildKeys({"u0"})
@@ -1150,6 +1350,7 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilterAndEmptyBuild) {
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::vector<RowVectorPtr>(probeVectors))
         .buildKeys({"u0"})
@@ -1209,6 +1410,7 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilterAndNullKey) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"u0"})
@@ -1269,6 +1471,7 @@ TEST_P(
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"u0"})
@@ -1307,6 +1510,7 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilterOnNullableColumn) {
     });
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::move(probeVectors))
         .buildKeys({"u0"})
@@ -1357,6 +1561,7 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilterOnNullableColumn) {
     });
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::move(probeVectors))
         .buildKeys({"u0"})
@@ -1386,6771 +1591,223 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilterOnNullableColumn) {
   }
 }
 
-TEST_P(MultiThreadedHashJoinTest, antiJoin) {
-  auto probeVectors = makeBatches(64, [&](int32_t /*unused*/) {
+TEST_P(
+    MultiThreadedHashJoinTest,
+    nullAwareAntiJoinWithFilterBatchedEvaluation) {
+  // Use >1024 build rows to trigger multiple batches in
+  // applyFilterOnTableRowsForNullAwareJoin (kBatchSize is 1024), exercising the
+  // per-batch deselect of filterPassedRows from rows. Include null probe keys
+  // so that crossJoinProbeRows is non-empty and the cross-join path iterates
+  // all 2048 build rows across 2 batches.
+  auto probeVectors = makeBatches(1, [&](int32_t /*unused*/) {
     return makeRowVector(
         {"t0", "t1"},
         {
-            makeNullableFlatVector<int32_t>({std::nullopt, 1, 2}),
-            makeFlatVector<int32_t>({0, 1, 2}),
+            makeFlatVector<int32_t>(
+                256,
+                [](auto row) { return row % 50; },
+                [](auto row) { return row < 4; }),
+            makeFlatVector<int32_t>(256, [](auto row) { return row; }),
         });
   });
-  auto buildVectors = makeBatches(64, [&](int32_t /*unused*/) {
+  auto buildVectors = makeBatches(1, [&](int32_t /*unused*/) {
     return makeRowVector(
         {"u0", "u1"},
         {
-            makeNullableFlatVector<int32_t>({std::nullopt, 2, 3}),
-            makeFlatVector<int32_t>({0, 2, 3}),
+            makeFlatVector<int32_t>(2048, [](auto row) { return row % 25; }),
+            makeFlatVector<int32_t>(2048, [](auto row) { return row * 2; }),
         });
   });
+
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
       .probeKeys({"t0"})
-      .probeVectors(std::vector<RowVectorPtr>(probeVectors))
+      .probeVectors(std::move(probeVectors))
       .buildKeys({"u0"})
-      .buildVectors(std::vector<RowVectorPtr>(buildVectors))
+      .buildVectors(std::move(buildVectors))
       .joinType(core::JoinType::kAnti)
+      .nullAware(true)
+      .joinFilter("t1 <> u1")
       .joinOutputLayout({"t0", "t1"})
       .referenceQuery(
-          "SELECT t.* FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE u.u0 = t.t0)")
+          "SELECT t.* FROM t WHERE t0 NOT IN (SELECT u0 FROM u WHERE t1 <> u1)")
+      .checkSpillStats(false)
       .run();
-
-  std::vector<std::string> filters({
-      "u1 > t1",
-      "u1 * t1 > 0",
-      // This filter is true on rows without a match. It should not prevent
-      // the row from being returned.
-      "coalesce(u1, t1, 0::integer) is not null",
-      // This filter throws if evaluated on rows without a match. The join
-      // should not evaluate filter on those rows and therefore should not
-      // fail.
-      "t1 / coalesce(u1, 0::integer) is not null",
-      // This filter triggers memory pool allocation at
-      // HashBuild::setupFilterForAntiJoins, which should not be invoked in
-      // operator's constructor.
-      "contains(array[1, 2, NULL], 1)",
-  });
-  for (const std::string& filter : filters) {
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .numDrivers(numDrivers_)
-        .probeKeys({"t0"})
-        .probeVectors(std::vector<RowVectorPtr>(probeVectors))
-        .buildKeys({"u0"})
-        .buildVectors(std::vector<RowVectorPtr>(buildVectors))
-        .joinType(core::JoinType::kAnti)
-        .joinFilter(filter)
-        .joinOutputLayout({"t0", "t1"})
-        .referenceQuery(fmt::format(
-            "SELECT t.* FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE u.u0 = t.t0 AND {})",
-            filter))
-        .run();
-  }
-}
-
-TEST_P(MultiThreadedHashJoinTest, antiJoinWithFilterAndEmptyBuild) {
-  const std::vector<bool> finishOnEmptys = {false, true};
-  for (const auto finishOnEmpty : finishOnEmptys) {
-    SCOPED_TRACE(fmt::format("finishOnEmpty: {}", finishOnEmpty));
-
-    auto probeVectors = makeBatches(4, [&](int32_t /*unused*/) {
-      return makeRowVector(
-          {"t0", "t1"},
-          {
-              makeNullableFlatVector<int32_t>({std::nullopt, 1, 2}),
-              makeFlatVector<int32_t>({0, 1, 2}),
-          });
-    });
-    auto buildVectors = makeBatches(4, [&](int32_t /*unused*/) {
-      return makeRowVector(
-          {"u0", "u1"},
-          {
-              makeNullableFlatVector<int32_t>({3, 2, 3}),
-              makeFlatVector<int32_t>({0, 2, 3}),
-          });
-    });
-
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
-        .numDrivers(numDrivers_)
-        .probeKeys({"t0"})
-        .probeVectors(std::vector<RowVectorPtr>(probeVectors))
-        .buildKeys({"u0"})
-        .buildVectors(std::vector<RowVectorPtr>(buildVectors))
-        .buildFilter("u0 < 0")
-        .joinType(core::JoinType::kAnti)
-        .joinFilter("u1 > t1")
-        .joinOutputLayout({"t0", "t1"})
-        .referenceQuery(
-            "SELECT t.* FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE u0 < 0 AND u.u0 = t.t0)")
-        .checkSpillStats(false)
-        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-          const auto statsPair = taskSpilledStats(*task);
-          ASSERT_EQ(statsPair.first.spilledRows, 0);
-          ASSERT_EQ(statsPair.first.spilledBytes, 0);
-          ASSERT_EQ(statsPair.first.spilledPartitions, 0);
-          ASSERT_EQ(statsPair.first.spilledFiles, 0);
-          ASSERT_EQ(statsPair.second.spilledRows, 0);
-          ASSERT_EQ(statsPair.second.spilledBytes, 0);
-          ASSERT_EQ(statsPair.second.spilledPartitions, 0);
-          ASSERT_EQ(statsPair.second.spilledFiles, 0);
-          verifyTaskSpilledRuntimeStats(*task, false);
-          ASSERT_EQ(maxHashBuildSpillLevel(*task), -1);
-        })
-        .run();
-  }
 }
 
-TEST_P(MultiThreadedHashJoinTest, leftJoin) {
-  // Left side keys are [0, 1, 2,..20].
-  // Use 3-rd column as row number to allow for asserting the order of
-  // results.
-  std::vector<RowVectorPtr> probeVectors = mergeBatches(
-      makeBatches(
-          3,
-          [&](int32_t /*unused*/) {
-            return makeRowVector(
-                {"c0", "c1", "row_number"},
-                {
-                    makeFlatVector<int32_t>(
-                        77, [](auto row) { return row % 21; }, nullEvery(13)),
-                    makeFlatVector<int32_t>(77, [](auto row) { return row; }),
-                    makeFlatVector<int32_t>(77, [](auto row) { return row; }),
-                });
-          }),
-      makeBatches(
-          2,
-          [&](int32_t /*unused*/) {
-            return makeRowVector(
-                {"c0", "c1", "row_number"},
-                {
-                    makeFlatVector<int32_t>(
-                        97,
-                        [](auto row) { return (row + 3) % 21; },
-                        nullEvery(13)),
-                    makeFlatVector<int32_t>(97, [](auto row) { return row; }),
-                    makeFlatVector<int32_t>(
-                        97, [](auto row) { return 97 + row; }),
-                });
-          }),
-      true);
-
-  std::vector<RowVectorPtr> buildVectors =
-      makeBatches(3, [&](int32_t /*unused*/) {
-        return makeRowVector({
-            makeFlatVector<int32_t>(
-                73, [](auto row) { return row % 5; }, nullEvery(7)),
-            makeFlatVector<int32_t>(
-                73, [](auto row) { return -111 + row * 2; }, nullEvery(7)),
+TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilterEarlyTermination) {
+  auto probeVectors = makeBatches(1, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"t0", "t1"},
+        {
+            makeFlatVector<int32_t>(100, [](auto row) { return row % 10; }),
+            makeFlatVector<int32_t>(100, [](auto row) { return row; }),
         });
-      });
+  });
+  auto buildVectors = makeBatches(1, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"u0", "u1"},
+        {
+            makeFlatVector<int32_t>(500, [](auto row) { return row % 10; }),
+            makeFlatVector<int32_t>(500, [](auto row) { return row; }),
+        });
+  });
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
-      .probeKeys({"c0"})
+      .probeKeys({"t0"})
       .probeVectors(std::move(probeVectors))
-      .buildKeys({"u_c0"})
+      .buildKeys({"u0"})
       .buildVectors(std::move(buildVectors))
-      .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
-      .joinType(core::JoinType::kLeft)
-      .joinOutputLayout({"row_number", "c0", "c1", "u_c0"})
+      .joinType(core::JoinType::kAnti)
+      .nullAware(true)
+      .joinFilter("t1 < u1")
+      .joinOutputLayout({"t0", "t1"})
       .referenceQuery(
-          "SELECT t.row_number, t.c0, t.c1, u.c0 FROM t LEFT JOIN u ON t.c0 = u.c0")
-      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-        int nullJoinBuildKeyCount = 0;
-        int nullJoinProbeKeyCount = 0;
-
-        for (auto& pipeline : task->taskStats().pipelineStats) {
-          for (auto op : pipeline.operatorStats) {
-            if (op.operatorType == "HashBuild") {
-              nullJoinBuildKeyCount += op.numNullKeys;
-            }
-            if (op.operatorType == "HashProbe") {
-              nullJoinProbeKeyCount += op.numNullKeys;
-            }
-          }
-        }
-        ASSERT_EQ(nullJoinBuildKeyCount, 33 * GetParam().numDrivers);
-        ASSERT_EQ(nullJoinProbeKeyCount, 34 * GetParam().numDrivers);
-      })
+          "SELECT t.* FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE t0 = u0 AND t1 < u1)")
+      .checkSpillStats(false)
       .run();
 }
 
-TEST_P(MultiThreadedHashJoinTest, nullStatsWithEmptyBuild) {
-  std::vector<RowVectorPtr> probeVectors =
-      makeBatches(1, [&](int32_t /*unused*/) {
-        return makeRowVector(
-            {"c0", "c1", "row_number"},
-            {
-                makeFlatVector<int32_t>(
-                    77, [](auto row) { return row % 21; }, nullEvery(13)),
-                makeFlatVector<int32_t>(77, [](auto row) { return row; }),
-                makeFlatVector<int32_t>(77, [](auto row) { return row; }),
-            });
-      });
-
-  // All null keys on build side.
-  std::vector<RowVectorPtr> buildVectors =
-      makeBatches(1, [&](int32_t /*unused*/) {
-        return makeRowVector({
+TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilterMixedNulls) {
+  auto probeVectors = makeBatches(2, [&](int32_t batch) {
+    return makeRowVector(
+        {"t0", "t1"},
+        {
+            makeNullableFlatVector<int32_t>(
+                {std::nullopt,
+                 1,
+                 2,
+                 std::nullopt,
+                 4,
+                 5,
+                 6,
+                 std::nullopt,
+                 8,
+                 9}),
             makeFlatVector<int32_t>(
-                1, [](auto row) { return row % 5; }, nullEvery(1)),
+                10, [batch](auto row) { return batch * 10 + row; }),
+        });
+  });
+  auto buildVectors = makeBatches(2, [&](int32_t batch) {
+    return makeRowVector(
+        {"u0", "u1"},
+        {
+            makeNullableFlatVector<int32_t>(
+                {1,
+                 std::nullopt,
+                 3,
+                 4,
+                 std::nullopt,
+                 6,
+                 7,
+                 8,
+                 std::nullopt,
+                 10}),
             makeFlatVector<int32_t>(
-                1, [](auto row) { return -111 + row * 2; }, nullEvery(1)),
+                10, [batch](auto row) { return batch * 5 + row; }),
         });
-      });
+  });
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
-      .probeKeys({"c0"})
+      .probeKeys({"t0"})
       .probeVectors(std::move(probeVectors))
-      .buildKeys({"u_c0"})
+      .buildKeys({"u0"})
       .buildVectors(std::move(buildVectors))
-      .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
-      .joinType(core::JoinType::kLeft)
-      .joinOutputLayout({"row_number", "c0", "c1", "u_c0"})
+      .joinType(core::JoinType::kAnti)
+      .nullAware(true)
+      .joinFilter("t1 + u1 < 50")
+      .joinOutputLayout({"t0", "t1"})
       .referenceQuery(
-          "SELECT t.row_number, t.c0, t.c1, u.c0 FROM t LEFT JOIN u ON t.c0 = u.c0")
-      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-        int nullJoinBuildKeyCount = 0;
-        int nullJoinProbeKeyCount = 0;
-
-        for (auto& pipeline : task->taskStats().pipelineStats) {
-          for (auto op : pipeline.operatorStats) {
-            if (op.operatorType == "HashBuild") {
-              nullJoinBuildKeyCount += op.numNullKeys;
-            }
-            if (op.operatorType == "HashProbe") {
-              nullJoinProbeKeyCount += op.numNullKeys;
-            }
-          }
-        }
-        // Due to inaccurate stats tracking in case of empty build side,
-        // we will report 0 null keys on probe side.
-        ASSERT_EQ(nullJoinProbeKeyCount, 0);
-        ASSERT_EQ(nullJoinBuildKeyCount, 1 * GetParam().numDrivers);
-      })
+          "SELECT t.* FROM t WHERE t0 NOT IN (SELECT u0 FROM u WHERE t1 + u1 < 50)")
       .checkSpillStats(false)
       .run();
 }
 
-TEST_P(MultiThreadedHashJoinTest, leftJoinWithEmptyBuild) {
-  const std::vector<bool> finishOnEmptys = {false, true};
-  for (const auto finishOnEmpty : finishOnEmptys) {
-    SCOPED_TRACE(fmt::format("finishOnEmpty: {}", finishOnEmpty));
-
-    // Left side keys are [0, 1, 2,..10].
-    // Use 3-rd column as row number to allow for asserting the order of
-    // results.
-    std::vector<RowVectorPtr> probeVectors = mergeBatches(
-        makeBatches(
-            3,
-            [&](int32_t /*unused*/) {
-              return makeRowVector(
-                  {"c0", "c1", "row_number"},
-                  {
-                      makeFlatVector<int32_t>(
-                          77, [](auto row) { return row % 11; }, nullEvery(13)),
-                      makeFlatVector<int32_t>(77, [](auto row) { return row; }),
-                      makeFlatVector<int32_t>(77, [](auto row) { return row; }),
-                  });
-            }),
-        makeBatches(
-            2,
-            [&](int32_t /*unused*/) {
-              return makeRowVector(
-                  {"c0", "c1", "row_number"},
-                  {
-                      makeFlatVector<int32_t>(
-                          97,
-                          [](auto row) { return (row + 3) % 11; },
-                          nullEvery(13)),
-                      makeFlatVector<int32_t>(97, [](auto row) { return row; }),
-                      makeFlatVector<int32_t>(
-                          97, [](auto row) { return 97 + row; }),
-                  });
-            }),
-        true);
-
-    std::vector<RowVectorPtr> buildVectors =
-        makeBatches(3, [&](int32_t /*unused*/) {
-          return makeRowVector({
-              makeFlatVector<int32_t>(
-                  73, [](auto row) { return row % 5; }, nullEvery(7)),
-              makeFlatVector<int32_t>(
-                  73, [](auto row) { return -111 + row * 2; }, nullEvery(7)),
-          });
+TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilterAllNullProbeKeys) {
+  auto probeVectors = makeBatches(1, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"t0", "t1"},
+        {
+            makeNullConstant(TypeKind::INTEGER, 64),
+            makeFlatVector<int32_t>(64, [](auto row) { return row; }),
         });
-
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
-        .numDrivers(numDrivers_)
-        .probeKeys({"c0"})
-        .probeVectors(std::move(probeVectors))
-        .buildKeys({"u_c0"})
-        .buildVectors(std::move(buildVectors))
-        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
-        .buildFilter("c0 < 0")
-        .joinType(core::JoinType::kLeft)
-        .joinOutputLayout({"row_number", "c1"})
-        .referenceQuery(
-            "SELECT t.row_number, t.c1 FROM t LEFT JOIN (SELECT c0 FROM u WHERE c0 < 0) u ON t.c0 = u.c0")
-        .checkSpillStats(false)
-        .run();
-  }
-}
-
-TEST_P(MultiThreadedHashJoinTest, leftJoinWithNoJoin) {
-  // Left side keys are [0, 1, 2,..10].
-  // Use 3-rd column as row number to allow for asserting the order of
-  // results.
-  std::vector<RowVectorPtr> probeVectors = mergeBatches(
-      makeBatches(
-          3,
-          [&](int32_t /*unused*/) {
-            return makeRowVector(
-                {"c0", "c1", "row_number"},
-                {
-                    makeFlatVector<int32_t>(
-                        77, [](auto row) { return row % 11; }, nullEvery(13)),
-                    makeFlatVector<int32_t>(77, [](auto row) { return row; }),
-                    makeFlatVector<int32_t>(77, [](auto row) { return row; }),
-                });
-          }),
-      makeBatches(
-          2,
-          [&](int32_t /*unused*/) {
-            return makeRowVector(
-                {"c0", "c1", "row_number"},
-                {
-                    makeFlatVector<int32_t>(
-                        97,
-                        [](auto row) { return (row + 3) % 11; },
-                        nullEvery(13)),
-                    makeFlatVector<int32_t>(97, [](auto row) { return row; }),
-                    makeFlatVector<int32_t>(
-                        97, [](auto row) { return 97 + row; }),
-                });
-          }),
-      true);
-
-  std::vector<RowVectorPtr> buildVectors =
-      makeBatches(3, [&](int32_t /*unused*/) {
-        return makeRowVector({
-            makeFlatVector<int32_t>(
-                73, [](auto row) { return row % 5; }, nullEvery(7)),
-            makeFlatVector<int32_t>(
-                73, [](auto row) { return -111 + row * 2; }, nullEvery(7)),
+  });
+  auto buildVectors = makeBatches(1, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"u0", "u1"},
+        {
+            makeFlatVector<int32_t>(32, [](auto row) { return row; }),
+            makeFlatVector<int32_t>(32, [](auto row) { return row * 3; }),
         });
-      });
+  });
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
-      .probeKeys({"c0"})
+      .probeKeys({"t0"})
       .probeVectors(std::move(probeVectors))
-      .buildKeys({"u_c0"})
+      .buildKeys({"u0"})
       .buildVectors(std::move(buildVectors))
-      .buildProjections({"c0 - 123::INTEGER AS u_c0", "c1 AS u_c1"})
-      .joinType(core::JoinType::kLeft)
-      .joinOutputLayout({"row_number", "c0", "u_c1"})
+      .joinType(core::JoinType::kAnti)
+      .nullAware(true)
+      .joinFilter("t1 <> u1")
+      .joinOutputLayout({"t0", "t1"})
       .referenceQuery(
-          "SELECT t.row_number, t.c0, u.c1 FROM t LEFT JOIN (SELECT c0 - 123::INTEGER AS u_c0, c1 FROM u) u ON t.c0 = u.u_c0")
+          "SELECT t.* FROM t WHERE t0 NOT IN (SELECT u0 FROM u WHERE t1 <> u1)")
+      .checkSpillStats(false)
       .run();
 }
 
-TEST_P(MultiThreadedHashJoinTest, leftJoinWithAllMatch) {
-  // Left side keys are [0, 1, 2,..10].
-  // Use 3-rd column as row number to allow for asserting the order of
-  // results.
-  std::vector<RowVectorPtr> probeVectors = mergeBatches(
-      makeBatches(
-          3,
-          [&](int32_t /*unused*/) {
-            return makeRowVector(
-                {"c0", "c1", "row_number"},
-                {
-                    makeFlatVector<int32_t>(
-                        77, [](auto row) { return row % 11; }, nullEvery(13)),
-                    makeFlatVector<int32_t>(77, [](auto row) { return row; }),
-                    makeFlatVector<int32_t>(77, [](auto row) { return row; }),
-                });
-          }),
-      makeBatches(
-          2,
-          [&](int32_t /*unused*/) {
-            return makeRowVector(
-                {"c0", "c1", "row_number"},
-                {
-                    makeFlatVector<int32_t>(
-                        97,
-                        [](auto row) { return (row + 3) % 11; },
-                        nullEvery(13)),
-                    makeFlatVector<int32_t>(97, [](auto row) { return row; }),
-                    makeFlatVector<int32_t>(
-                        97, [](auto row) { return 97 + row; }),
-                });
-          }),
-      true);
-
-  std::vector<RowVectorPtr> buildVectors =
-      makeBatches(3, [&](int32_t /*unused*/) {
-        return makeRowVector({
-            makeFlatVector<int32_t>(
-                73, [](auto row) { return row % 5; }, nullEvery(7)),
-            makeFlatVector<int32_t>(
-                73, [](auto row) { return -111 + row * 2; }, nullEvery(7)),
+TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilterEmptyBatch) {
+  auto probeVectors = makeBatches(1, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"t0", "t1"},
+        {
+            makeFlatVector<int32_t>(32, [](auto row) { return row; }),
+            makeFlatVector<int32_t>(32, [](auto row) { return row; }),
         });
-      });
+  });
+  auto buildVectors = makeBatches(1, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"u0", "u1"},
+        {
+            makeFlatVector<int32_t>(32, [](auto row) { return row; }),
+            makeFlatVector<int32_t>(32, [](auto row) { return 1000 + row; }),
+        });
+  });
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
-      .probeKeys({"c0"})
+      .probeKeys({"t0"})
       .probeVectors(std::move(probeVectors))
-      .probeFilter("c0 < 5")
-      .buildKeys({"u_c0"})
+      .buildKeys({"u0"})
       .buildVectors(std::move(buildVectors))
-      .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
-      .joinType(core::JoinType::kLeft)
-      .joinOutputLayout({"row_number", "c0", "c1", "u_c1"})
+      .joinType(core::JoinType::kAnti)
+      .nullAware(true)
+      .joinFilter("t1 > u1")
+      .joinOutputLayout({"t0", "t1"})
       .referenceQuery(
-          "SELECT t.row_number, t.c0, t.c1, u.c1 FROM (SELECT * FROM t WHERE c0 < 5) t LEFT JOIN u ON t.c0 = u.c0")
+          "SELECT t.* FROM t WHERE t0 NOT IN (SELECT u0 FROM u WHERE t1 > u1)")
+      .checkSpillStats(false)
       .run();
 }
 
-TEST_P(MultiThreadedHashJoinTest, leftJoinWithFilter) {
-  // Left side keys are [0, 1, 2,..10].
-  // Use 3-rd column as row number to allow for asserting the order of
-  // results.
-  std::vector<RowVectorPtr> probeVectors = mergeBatches(
-      makeBatches(
-          3,
-          [&](int32_t /*unused*/) {
-            return makeRowVector(
-                {"c0", "c1", "row_number"},
-                {
-                    makeFlatVector<int32_t>(
-                        77, [](auto row) { return row % 11; }, nullEvery(13)),
-                    makeFlatVector<int32_t>(77, [](auto row) { return row; }),
-                    makeFlatVector<int32_t>(77, [](auto row) { return row; }),
-                });
-          }),
-      makeBatches(
-          2,
-          [&](int32_t /*unused*/) {
-            return makeRowVector(
-                {"c0", "c1", "row_number"},
-                {
-                    makeFlatVector<int32_t>(
-                        97,
-                        [](auto row) { return (row + 3) % 11; },
-                        nullEvery(13)),
-                    makeFlatVector<int32_t>(97, [](auto row) { return row; }),
-                    makeFlatVector<int32_t>(
-                        97, [](auto row) { return 97 + row; }),
-                });
-          }),
-      true);
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    MultiThreadedHashJoinTest,
+    MultiThreadedHashJoinTest,
+    testing::ValuesIn(MultiThreadedHashJoinTest::getTestParams()),
+    [](const testing::TestParamInfo<TestParam>& info) {
+      return TestParamToName(info.param);
+    });
 
-  std::vector<RowVectorPtr> buildVectors =
-      makeBatches(3, [&](int32_t /*unused*/) {
-        return makeRowVector({
-            makeFlatVector<int32_t>(
-                73, [](auto row) { return row % 5; }, nullEvery(7)),
-            makeFlatVector<int32_t>(
-                73, [](auto row) { return -111 + row * 2; }, nullEvery(7)),
-        });
-      });
-
-  // Additional filter.
-  {
-    auto testProbeVectors = probeVectors;
-    auto testBuildVectors = buildVectors;
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .numDrivers(numDrivers_)
-        .probeKeys({"c0"})
-        .probeVectors(std::move(testProbeVectors))
-        .buildKeys({"u_c0"})
-        .buildVectors(std::move(testBuildVectors))
-        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
-        .joinType(core::JoinType::kLeft)
-        .joinFilter("(c1 + u_c1) % 2 = 1")
-        .joinOutputLayout({"row_number", "c0", "c1", "u_c1"})
-        .referenceQuery(
-            "SELECT t.row_number, t.c0, t.c1, u.c1 FROM t LEFT JOIN u ON t.c0 = u.c0 AND (t.c1 + u.c1) % 2 = 1")
-        .run();
-  }
-
-  // No rows pass the additional filter.
-  {
-    auto testProbeVectors = probeVectors;
-    auto testBuildVectors = buildVectors;
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .numDrivers(numDrivers_)
-        .probeKeys({"c0"})
-        .probeVectors(std::move(testProbeVectors))
-        .buildKeys({"u_c0"})
-        .buildVectors(std::move(testBuildVectors))
-        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
-        .joinType(core::JoinType::kLeft)
-        .joinFilter("(c1 + u_c1) % 2  = 3")
-        .joinOutputLayout({"row_number", "c0", "c1", "u_c1"})
-        .referenceQuery(
-            "SELECT t.row_number, t.c0, t.c1, u.c1 FROM t LEFT JOIN u ON t.c0 = u.c0 AND (t.c1 + u.c1) % 2 = 3")
-        .run();
-  }
-}
-
-/// Tests left join with a filter that may evaluate to true, false or null.
-/// Makes sure that null filter results are handled correctly, e.g. as if the
-/// filter returned false.
-TEST_P(MultiThreadedHashJoinTest, leftJoinWithNullableFilter) {
-  std::vector<RowVectorPtr> probeVectors = mergeBatches(
-      makeBatches(
-          5,
-          [&](int32_t /*unused*/) {
-            return makeRowVector({
-                makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
-                makeNullableFlatVector<int32_t>(
-                    {10, std::nullopt, 30, std::nullopt, 50}),
-            });
-          }),
-      makeBatches(
-          5,
-          [&](int32_t /*unused*/) {
-            return makeRowVector({
-                makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
-                makeNullableFlatVector<int32_t>(
-                    {std::nullopt, 20, 30, std::nullopt, 50}),
-            });
-          }),
-      true);
-
-  std::vector<RowVectorPtr> buildVectors =
-      makeBatches(5, [&](int32_t /*unused*/) {
-        return makeRowVector(
-            {makeFlatVector<int32_t>(128, [](vector_size_t row) {
-              if (row < 3) {
-                return row;
-              }
-              return row + 10;
-            })});
-      });
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .numDrivers(numDrivers_)
-      .probeKeys({"c0"})
-      .probeVectors(std::move(probeVectors))
-      .buildKeys({"u_c0"})
-      .buildVectors(std::move(buildVectors))
-      .buildProjections({"c0 AS u_c0"})
-      .joinType(core::JoinType::kLeft)
-      .joinFilter("c1 + u_c0 > 0")
-      .joinOutputLayout({"c0", "c1", "u_c0"})
-      .referenceQuery(
-          "SELECT * FROM t LEFT JOIN u ON (t.c0 = u.c0 AND t.c1 + u.c0 > 0)")
-      .run();
-}
-
-TEST_P(MultiThreadedHashJoinTest, rightJoin) {
-  // Left side keys are [0, 1, 2,..20].
-  std::vector<RowVectorPtr> probeVectors = mergeBatches(
-      makeBatches(
-          3,
-          [&](int32_t /*unused*/) {
-            return makeRowVector({
-                makeFlatVector<int32_t>(
-                    137, [](auto row) { return row % 21; }, nullEvery(13)),
-                makeFlatVector<int32_t>(137, [](auto row) { return row; }),
-            });
-          }),
-      makeBatches(
-          3,
-          [&](int32_t /*unused*/) {
-            return makeRowVector({
-                makeFlatVector<int32_t>(
-                    234,
-                    [](auto row) { return (row + 3) % 21; },
-                    nullEvery(13)),
-                makeFlatVector<int32_t>(234, [](auto row) { return row; }),
-            });
-          }),
-      true);
-
-  // Right side keys are [-3, -2, -1, 0, 1, 2, 3].
-  std::vector<RowVectorPtr> buildVectors =
-      makeBatches(3, [&](int32_t /*unused*/) {
-        return makeRowVector({
-            makeFlatVector<int32_t>(
-                123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
-            makeFlatVector<int32_t>(
-                123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
-        });
-      });
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .numDrivers(numDrivers_)
-      .probeKeys({"c0"})
-      .probeVectors(std::move(probeVectors))
-      .buildKeys({"u_c0"})
-      .buildVectors(std::move(buildVectors))
-      .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
-      .joinType(core::JoinType::kRight)
-      .joinOutputLayout({"c0", "c1", "u_c1"})
-      .referenceQuery(
-          "SELECT t.c0, t.c1, u.c1 FROM t RIGHT JOIN u ON t.c0 = u.c0")
-      .run();
-}
-
-TEST_P(MultiThreadedHashJoinTest, rightJoinWithEmptyBuild) {
-  const std::vector<bool> finishOnEmptys = {false, true};
-  for (const auto finishOnEmpty : finishOnEmptys) {
-    SCOPED_TRACE(fmt::format("finishOnEmpty: {}", finishOnEmpty));
-
-    // Left side keys are [0, 1, 2,..10].
-    std::vector<RowVectorPtr> probeVectors = mergeBatches(
-        makeBatches(
-            3,
-            [&](int32_t /*unused*/) {
-              return makeRowVector({
-                  makeFlatVector<int32_t>(
-                      137, [](auto row) { return row % 11; }, nullEvery(13)),
-                  makeFlatVector<int32_t>(137, [](auto row) { return row; }),
-              });
-            }),
-        makeBatches(
-            3,
-            [&](int32_t /*unused*/) {
-              return makeRowVector({
-                  makeFlatVector<int32_t>(
-                      234,
-                      [](auto row) { return (row + 3) % 11; },
-                      nullEvery(13)),
-                  makeFlatVector<int32_t>(234, [](auto row) { return row; }),
-              });
-            }),
-        true);
-
-    // Right side keys are [-3, -2, -1, 0, 1, 2, 3].
-    std::vector<RowVectorPtr> buildVectors =
-        makeBatches(3, [&](int32_t /*unused*/) {
-          return makeRowVector({
-              makeFlatVector<int32_t>(
-                  123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
-              makeFlatVector<int32_t>(
-                  123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
-          });
-        });
-
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
-        .numDrivers(numDrivers_)
-        .probeKeys({"c0"})
-        .probeVectors(std::move(probeVectors))
-        .buildKeys({"u_c0"})
-        .buildVectors(std::move(buildVectors))
-        .buildFilter("c0 > 100")
-        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
-        .joinType(core::JoinType::kRight)
-        .joinOutputLayout({"c1"})
-        .referenceQuery("SELECT null LIMIT 0")
-        .checkSpillStats(false)
-        .run();
-  }
-}
-
-TEST_P(MultiThreadedHashJoinTest, rightJoinWithAllMatch) {
-  // Left side keys are [0, 1, 2,..20].
-  std::vector<RowVectorPtr> probeVectors = mergeBatches(
-      makeBatches(
-          3,
-          [&](int32_t /*unused*/) {
-            return makeRowVector({
-                makeFlatVector<int32_t>(
-                    137, [](auto row) { return row % 21; }, nullEvery(13)),
-                makeFlatVector<int32_t>(137, [](auto row) { return row; }),
-            });
-          }),
-      makeBatches(
-          3,
-          [&](int32_t /*unused*/) {
-            return makeRowVector({
-                makeFlatVector<int32_t>(
-                    234,
-                    [](auto row) { return (row + 3) % 21; },
-                    nullEvery(13)),
-                makeFlatVector<int32_t>(234, [](auto row) { return row; }),
-            });
-          }),
-      true);
-
-  // Right side keys are [-3, -2, -1, 0, 1, 2, 3].
-  std::vector<RowVectorPtr> buildVectors =
-      makeBatches(3, [&](int32_t /*unused*/) {
-        return makeRowVector({
-            makeFlatVector<int32_t>(
-                123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
-            makeFlatVector<int32_t>(
-                123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
-        });
-      });
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .numDrivers(numDrivers_)
-      .probeKeys({"c0"})
-      .probeVectors(std::move(probeVectors))
-      .buildKeys({"u_c0"})
-      .buildVectors(std::move(buildVectors))
-      .buildFilter("c0 >= 0")
-      .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
-      .joinType(core::JoinType::kRight)
-      .joinOutputLayout({"c0", "c1", "u_c1"})
-      .referenceQuery(
-          "SELECT t.c0, t.c1, u.c1 FROM t RIGHT JOIN (SELECT * FROM u WHERE c0 >= 0) u ON t.c0 = u.c0")
-      .run();
-}
-
-TEST_P(MultiThreadedHashJoinTest, rightJoinWithFilter) {
-  // Left side keys are [0, 1, 2,..20].
-  std::vector<RowVectorPtr> probeVectors = mergeBatches(
-      makeBatches(
-          3,
-          [&](int32_t /*unused*/) {
-            return makeRowVector({
-                makeFlatVector<int32_t>(
-                    137, [](auto row) { return row % 21; }, nullEvery(13)),
-                makeFlatVector<int32_t>(137, [](auto row) { return row; }),
-            });
-          }),
-      makeBatches(
-          3,
-          [&](int32_t /*unused*/) {
-            return makeRowVector({
-                makeFlatVector<int32_t>(
-                    234,
-                    [](auto row) { return (row + 3) % 21; },
-                    nullEvery(13)),
-                makeFlatVector<int32_t>(234, [](auto row) { return row; }),
-            });
-          }),
-      true);
-
-  // Right side keys are [-3, -2, -1, 0, 1, 2, 3].
-  std::vector<RowVectorPtr> buildVectors =
-      makeBatches(3, [&](int32_t /*unused*/) {
-        return makeRowVector({
-            makeFlatVector<int32_t>(
-                123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
-            makeFlatVector<int32_t>(
-                123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
-        });
-      });
-
-  // Filter with passed rows.
-  {
-    auto testProbeVectors = probeVectors;
-    auto testBuildVectors = buildVectors;
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .numDrivers(numDrivers_)
-        .probeKeys({"c0"})
-        .probeVectors(std::move(testProbeVectors))
-        .buildKeys({"u_c0"})
-        .buildVectors(std::move(testBuildVectors))
-        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
-        .joinType(core::JoinType::kRight)
-        .joinFilter("(c1 + u_c1) % 2 = 1")
-        .joinOutputLayout({"c0", "c1", "u_c1"})
-        .referenceQuery(
-            "SELECT t.c0, t.c1, u.c1 FROM t RIGHT JOIN u ON t.c0 = u.c0 AND (t.c1 + u.c1) % 2 = 1")
-        .run();
-  }
-
-  // Filter without passed rows.
-  {
-    auto testProbeVectors = probeVectors;
-    auto testBuildVectors = buildVectors;
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .numDrivers(numDrivers_)
-        .probeKeys({"c0"})
-        .probeVectors(std::move(testProbeVectors))
-        .buildKeys({"u_c0"})
-        .buildVectors(std::move(testBuildVectors))
-        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
-        .joinType(core::JoinType::kRight)
-        .joinFilter("(c1 + u_c1) % 2 = 3")
-        .joinOutputLayout({"c0", "c1", "u_c1"})
-        .referenceQuery(
-            "SELECT t.c0, t.c1, u.c1 FROM t RIGHT JOIN u ON t.c0 = u.c0 AND (t.c1 + u.c1) % 2 = 3")
-        .run();
-  }
-}
-
-TEST_P(MultiThreadedHashJoinTest, fullJoin) {
-  // Left side keys are [0, 1, 2,..20].
-  std::vector<RowVectorPtr> probeVectors = mergeBatches(
-      makeBatches(
-          3,
-          [&](int32_t /*unused*/) {
-            return makeRowVector({
-                makeFlatVector<int32_t>(
-                    213, [](auto row) { return row % 21; }, nullEvery(13)),
-                makeFlatVector<int32_t>(213, [](auto row) { return row; }),
-            });
-          }),
-      makeBatches(
-          2,
-          [&](int32_t /*unused*/) {
-            return makeRowVector({
-                makeFlatVector<int32_t>(
-                    137,
-                    [](auto row) { return (row + 3) % 21; },
-                    nullEvery(13)),
-                makeFlatVector<int32_t>(137, [](auto row) { return row; }),
-            });
-          }),
-      true);
-
-  // Right side keys are [-3, -2, -1,
-  // 0, 1, 2, 3].
-  std::vector<RowVectorPtr> buildVectors =
-      makeBatches(3, [&](int32_t /*unused*/) {
-        return makeRowVector({
-            makeFlatVector<int32_t>(
-                123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
-            makeFlatVector<int32_t>(
-                123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
-        });
-      });
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .numDrivers(numDrivers_)
-      .probeKeys({"c0"})
-      .probeVectors(std::move(probeVectors))
-      .buildKeys({"u_c0"})
-      .buildVectors(std::move(buildVectors))
-      .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
-      .joinType(core::JoinType::kFull)
-      .joinOutputLayout({"c0", "c1", "u_c1"})
-      .referenceQuery(
-          "SELECT t.c0, t.c1, u.c1 FROM t FULL OUTER JOIN u ON t.c0 = u.c0")
-      .run();
-}
-
-TEST_P(MultiThreadedHashJoinTest, fullJoinWithEmptyBuild) {
-  const std::vector<bool> finishOnEmptys = {false, true};
-  for (const auto finishOnEmpty : finishOnEmptys) {
-    SCOPED_TRACE(fmt::format("finishOnEmpty: {}", finishOnEmpty));
-
-    // Left side keys are [0, 1, 2,..10].
-    std::vector<RowVectorPtr> probeVectors = mergeBatches(
-        makeBatches(
-            3,
-            [&](int32_t /*unused*/) {
-              return makeRowVector({
-                  makeFlatVector<int32_t>(
-                      213, [](auto row) { return row % 11; }, nullEvery(13)),
-                  makeFlatVector<int32_t>(213, [](auto row) { return row; }),
-              });
-            }),
-        makeBatches(
-            2,
-            [&](int32_t /*unused*/) {
-              return makeRowVector({
-                  makeFlatVector<int32_t>(
-                      137,
-                      [](auto row) { return (row + 3) % 11; },
-                      nullEvery(13)),
-                  makeFlatVector<int32_t>(137, [](auto row) { return row; }),
-              });
-            }),
-        true);
-
-    // Right side keys are [-3, -2, -1, 0, 1, 2, 3].
-    std::vector<RowVectorPtr> buildVectors =
-        makeBatches(3, [&](int32_t /*unused*/) {
-          return makeRowVector({
-              makeFlatVector<int32_t>(
-                  123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
-              makeFlatVector<int32_t>(
-                  123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
-          });
-        });
-
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
-        .numDrivers(numDrivers_)
-        .probeKeys({"c0"})
-        .probeVectors(std::move(probeVectors))
-        .buildKeys({"u_c0"})
-        .buildVectors(std::move(buildVectors))
-        .buildFilter("c0 > 100")
-        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
-        .joinType(core::JoinType::kFull)
-        .joinOutputLayout({"c1"})
-        .referenceQuery(
-            "SELECT t.c1 FROM t FULL OUTER JOIN (SELECT * FROM u WHERE c0 > 100) u ON t.c0 = u.c0")
-        .checkSpillStats(false)
-        .run();
-  }
-}
-
-TEST_P(MultiThreadedHashJoinTest, fullJoinWithNoMatch) {
-  // Left side keys are [0, 1, 2,..10].
-  std::vector<RowVectorPtr> probeVectors = mergeBatches(
-      makeBatches(
-          3,
-          [&](int32_t /*unused*/) {
-            return makeRowVector({
-                makeFlatVector<int32_t>(
-                    213, [](auto row) { return row % 11; }, nullEvery(13)),
-                makeFlatVector<int32_t>(213, [](auto row) { return row; }),
-            });
-          }),
-      makeBatches(
-          2,
-          [&](int32_t /*unused*/) {
-            return makeRowVector({
-                makeFlatVector<int32_t>(
-                    137,
-                    [](auto row) { return (row + 3) % 11; },
-                    nullEvery(13)),
-                makeFlatVector<int32_t>(137, [](auto row) { return row; }),
-            });
-          }),
-      true);
-
-  // Right side keys are [-3, -2, -1, 0, 1, 2, 3].
-  std::vector<RowVectorPtr> buildVectors =
-      makeBatches(3, [&](int32_t /*unused*/) {
-        return makeRowVector({
-            makeFlatVector<int32_t>(
-                123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
-            makeFlatVector<int32_t>(
-                123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
-        });
-      });
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .numDrivers(numDrivers_)
-      .probeKeys({"c0"})
-      .probeVectors(std::move(probeVectors))
-      .buildKeys({"u_c0"})
-      .buildVectors(std::move(buildVectors))
-      .buildFilter("c0 < 0")
-      .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
-      .joinType(core::JoinType::kFull)
-      .joinOutputLayout({"c1"})
-      .referenceQuery(
-          "SELECT t.c1 FROM t FULL OUTER JOIN (SELECT * FROM u WHERE c0 < 0) u ON t.c0 = u.c0")
-      .run();
-}
-
-TEST_P(MultiThreadedHashJoinTest, fullJoinWithFilters) {
-  // Left side keys are [0, 1, 2,..10].
-  std::vector<RowVectorPtr> probeVectors = mergeBatches(
-      makeBatches(
-          3,
-          [&](int32_t /*unused*/) {
-            return makeRowVector({
-                makeFlatVector<int32_t>(
-                    213, [](auto row) { return row % 11; }, nullEvery(13)),
-                makeFlatVector<int32_t>(213, [](auto row) { return row; }),
-            });
-          }),
-      makeBatches(
-          2,
-          [&](int32_t /*unused*/) {
-            return makeRowVector({
-                makeFlatVector<int32_t>(
-                    137,
-                    [](auto row) { return (row + 3) % 11; },
-                    nullEvery(13)),
-                makeFlatVector<int32_t>(137, [](auto row) { return row; }),
-            });
-          }),
-      true);
-
-  // Right side keys are [-3, -2, -1, 0, 1, 2, 3].
-  std::vector<RowVectorPtr> buildVectors =
-      makeBatches(3, [&](int32_t /*unused*/) {
-        return makeRowVector({
-            makeFlatVector<int32_t>(
-                123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
-            makeFlatVector<int32_t>(
-                123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
-        });
-      });
-
-  // Filter with passed rows.
-  {
-    auto testProbeVectors = probeVectors;
-    auto testBuildVectors = buildVectors;
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .numDrivers(numDrivers_)
-        .probeKeys({"c0"})
-        .probeVectors(std::move(testProbeVectors))
-        .buildKeys({"u_c0"})
-        .buildVectors(std::move(testBuildVectors))
-        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
-        .joinType(core::JoinType::kFull)
-        .joinFilter("(c1 + u_c1) % 2 = 1")
-        .joinOutputLayout({"c0", "c1", "u_c1"})
-        .referenceQuery(
-            "SELECT t.c0, t.c1, u.c1 FROM t FULL OUTER JOIN u ON t.c0 = u.c0 AND (t.c1 + u.c1) % 2 = 1")
-        .run();
-  }
-
-  // Filter without passed rows.
-  {
-    auto testProbeVectors = probeVectors;
-    auto testBuildVectors = buildVectors;
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .numDrivers(numDrivers_)
-        .probeKeys({"c0"})
-        .probeVectors(std::move(testProbeVectors))
-        .buildKeys({"u_c0"})
-        .buildVectors(std::move(testBuildVectors))
-        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
-        .joinType(core::JoinType::kFull)
-        .joinFilter("(c1 + u_c1) % 2 = 3")
-        .joinOutputLayout({"c0", "c1", "u_c1"})
-        .referenceQuery(
-            "SELECT t.c0, t.c1, u.c1 FROM t FULL OUTER JOIN u ON t.c0 = u.c0 AND (t.c1 + u.c1) % 2 = 3")
-        .run();
-  }
-}
-
-TEST_P(MultiThreadedHashJoinTest, noSpillLevelLimit) {
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .numDrivers(numDrivers_)
-      .keyTypes({INTEGER()})
-      .probeVectors(1600, 5)
-      .buildVectors(1500, 5)
-      .referenceQuery(
-          "SELECT t_k0, t_data, u_k0, u_data FROM t, u WHERE t.t_k0 = u.u_k0")
-      .maxSpillLevel(-1)
-      .config(core::QueryConfig::kSpillStartPartitionBit, "51")
-      .config(core::QueryConfig::kSpillNumPartitionBits, "3")
-      .checkSpillStats(false)
-      .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-        if (!hasSpill) {
-          return;
-        }
-        ASSERT_EQ(maxHashBuildSpillLevel(*task), 3);
-      })
-      .run();
-}
-
-// Verify that dynamic filter pushed down is turned off for null-aware right
-// semi project join.
-TEST_F(HashJoinTest, nullAwareRightSemiProjectOverScan) {
-  std::vector<RowVectorPtr> probes;
-  std::vector<RowVectorPtr> builds;
-  // Matches present:
-  probes.push_back(makeRowVector(
-      {"t0"},
-      {
-          makeNullableFlatVector<int32_t>({1, std::nullopt, 2}),
-      }));
-  builds.push_back(makeRowVector(
-      {"u0"},
-      {
-          makeNullableFlatVector<int32_t>({1, 2, 3, std::nullopt}),
-      }));
-
-  // No matches present:
-  probes.push_back(makeRowVector(
-      {"t0"},
-      {
-          makeFlatVector<int32_t>({5, 6}),
-      }));
-  builds.push_back(makeRowVector(
-      {"u0"},
-      {
-          makeNullableFlatVector<int32_t>({1, 2, 3, std::nullopt}),
-      }));
-
-  for (int i = 0; i < probes.size(); i++) {
-    RowVectorPtr& probe = probes[i];
-    RowVectorPtr& build = builds[i];
-    std::shared_ptr<TempFilePath> probeFile = TempFilePath::create();
-    writeToFile(probeFile->getPath(), {probe});
-
-    std::shared_ptr<TempFilePath> buildFile = TempFilePath::create();
-    writeToFile(buildFile->getPath(), {build});
-
-    createDuckDbTable("t", {probe});
-    createDuckDbTable("u", {build});
-
-    core::PlanNodeId probeScanId;
-    core::PlanNodeId buildScanId;
-    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-    auto plan = PlanBuilder(planNodeIdGenerator)
-                    .tableScan(asRowType(probe->type()))
-                    .capturePlanNodeId(probeScanId)
-                    .hashJoin(
-                        {"t0"},
-                        {"u0"},
-                        PlanBuilder(planNodeIdGenerator)
-                            .tableScan(asRowType(build->type()))
-                            .capturePlanNodeId(buildScanId)
-                            .planNode(),
-                        "",
-                        {"u0", "match"},
-                        core::JoinType::kRightSemiProject,
-                        true /*nullAware*/)
-                    .planNode();
-
-    SplitInput splitInput = {
-        {probeScanId,
-         {exec::Split(makeHiveConnectorSplit(probeFile->getPath()))}},
-        {buildScanId,
-         {exec::Split(makeHiveConnectorSplit(buildFile->getPath()))}},
-    };
-
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .planNode(plan)
-        .inputSplits(splitInput)
-        .checkSpillStats(false)
-        .referenceQuery("SELECT u0, u0 IN (SELECT t0 FROM t) FROM u")
-        .run();
-  }
-}
-
-TEST_F(HashJoinTest, duplicateJoinKeys) {
-  auto leftVectors = makeBatches(3, [&](int32_t /*unused*/) {
-    return makeRowVector({
-        makeNullableFlatVector<int64_t>(
-            {1, 2, 2, 3, 3, std::nullopt, 4, 5, 5, 6, 7}),
-        makeNullableFlatVector<int64_t>(
-            {1, 2, 2, std::nullopt, 3, 3, 4, 5, 5, 6, 8}),
-    });
-  });
-
-  auto rightVectors = makeBatches(3, [&](int32_t /*unused*/) {
-    return makeRowVector({
-        makeNullableFlatVector<int64_t>({1, 1, 3, 4, std::nullopt, 5, 7, 8}),
-        makeNullableFlatVector<int64_t>({1, 1, 3, 4, 5, std::nullopt, 7, 8}),
-    });
-  });
-
-  createDuckDbTable("t", leftVectors);
-  createDuckDbTable("u", rightVectors);
-
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-
-  auto assertPlan = [&](const std::vector<std::string>& leftProject,
-                        const std::vector<std::string>& leftKeys,
-                        const std::vector<std::string>& rightProject,
-                        const std::vector<std::string>& rightKeys,
-                        const std::vector<std::string>& outputLayout,
-                        core::JoinType joinType,
-                        const std::string& query) {
-    auto plan = PlanBuilder(planNodeIdGenerator)
-                    .values(leftVectors)
-                    .project(leftProject)
-                    .hashJoin(
-                        leftKeys,
-                        rightKeys,
-                        PlanBuilder(planNodeIdGenerator)
-                            .values(rightVectors)
-                            .project(rightProject)
-                            .planNode(),
-                        "",
-                        outputLayout,
-                        joinType)
-                    .planNode();
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .planNode(plan)
-        .referenceQuery(query)
-        .run();
-  };
-
-  std::vector<std::pair<core::JoinType, std::string>> joins = {
-      {core::JoinType::kInner, "INNER JOIN"},
-      {core::JoinType::kLeft, "LEFT JOIN"},
-      {core::JoinType::kRight, "RIGHT JOIN"},
-      {core::JoinType::kFull, "FULL OUTER JOIN"}};
-
-  for (const auto& [joinType, joinTypeSql] : joins) {
-    // Duplicate keys on the build side.
-    assertPlan(
-        {"c0 AS t0", "c1 as t1"}, // leftProject
-        {"t0", "t1"}, // leftKeys
-        {"c0 AS u0"}, // rightProject
-        {"u0", "u0"}, // rightKeys
-        {"t0", "t1", "u0"}, // outputLayout
-        joinType,
-        "SELECT t.c0, t.c1, u.c0 FROM t " + joinTypeSql +
-            " u ON t.c0 = u.c0 and t.c1 = u.c0");
-  }
-
-  for (const auto& [joinType, joinTypeSql] : joins) {
-    // Duplicated keys on the probe side.
-    assertPlan(
-        {"c0 AS t0"}, // leftProject
-        {"t0", "t0"}, // leftKeys
-        {"c0 AS u0", "c1 AS u1"}, // rightProject
-        {"u0", "u1"}, // rightKeys
-        {"t0", "u0", "u1"}, // outputLayout
-        joinType,
-        "SELECT t.c0, u.c0, u.c1 FROM t " + joinTypeSql +
-            " u ON t.c0 = u.c0 and t.c0 = u.c1");
-  }
-}
-
-TEST_F(HashJoinTest, semiProject) {
-  // Some keys have multiple rows: 2, 3, 5.
-  auto probeVectors = makeBatches(3, [&](int32_t /*unused*/) {
-    return makeRowVector({
-        makeFlatVector<int64_t>({1, 2, 2, 3, 3, 3, 4, 5, 5, 6, 7}),
-        makeFlatVector<int64_t>({10, 20, 21, 30, 31, 32, 40, 50, 51, 60, 70}),
-    });
-  });
-
-  // Some keys are missing: 2, 6.
-  // Some have multiple rows: 1, 5.
-  // Some keys are not present on probe side: 8.
-  auto buildVectors = makeBatches(3, [&](int32_t /*unused*/) {
-    return makeRowVector({
-        makeFlatVector<int64_t>({1, 1, 3, 4, 5, 5, 7, 8}),
-        makeFlatVector<int64_t>({100, 101, 300, 400, 500, 501, 700, 800}),
-    });
-  });
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto plan = PlanBuilder(planNodeIdGenerator)
-                  .values(probeVectors)
-                  .project({"c0 AS t0", "c1 AS t1"})
-                  .hashJoin(
-                      {"t0"},
-                      {"u0"},
-                      PlanBuilder(planNodeIdGenerator)
-                          .values(buildVectors)
-                          .project({"c0 AS u0", "c1 AS u1"})
-                          .planNode(),
-                      "",
-                      {"t0", "t1", "match"},
-                      core::JoinType::kLeftSemiProject)
-                  .planNode();
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(plan)
-      .referenceQuery(
-          "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0) FROM t")
-      .run();
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(flipJoinSides(plan))
-      .referenceQuery(
-          "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0) FROM t")
-      .run();
-
-  // With extra filter.
-  planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  plan = PlanBuilder(planNodeIdGenerator)
-             .values(probeVectors)
-             .project({"c0 AS t0", "c1 AS t1"})
-             .hashJoin(
-                 {"t0"},
-                 {"u0"},
-                 PlanBuilder(planNodeIdGenerator)
-                     .values(buildVectors)
-                     .project({"c0 AS u0", "c1 AS u1"})
-                     .planNode(),
-                 "t1 * 10 <> u1",
-                 {"t0", "t1", "match"},
-                 core::JoinType::kLeftSemiProject)
-             .planNode();
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(plan)
-      .referenceQuery(
-          "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0 AND t.c1 * 10 <> u.c1) FROM t")
-      .run();
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(flipJoinSides(plan))
-      .referenceQuery(
-          "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0 AND t.c1 * 10 <> u.c1) FROM t")
-      .run();
-
-  // Empty build side.
-  planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  plan = PlanBuilder(planNodeIdGenerator)
-             .values(probeVectors)
-             .project({"c0 AS t0", "c1 AS t1"})
-             .hashJoin(
-                 {"t0"},
-                 {"u0"},
-                 PlanBuilder(planNodeIdGenerator)
-                     .values(buildVectors)
-                     .project({"c0 AS u0", "c1 AS u1"})
-                     .filter("u0 < 0")
-                     .planNode(),
-                 "",
-                 {"t0", "t1", "match"},
-                 core::JoinType::kLeftSemiProject)
-             .planNode();
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(plan)
-      .referenceQuery(
-          "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE u.c0 < 0 AND t.c0 = u.c0) FROM t")
-      // NOTE: there is no spilling in empty build test case as all the
-      // build-side rows have been filtered out.
-      .checkSpillStats(false)
-      .run();
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(flipJoinSides(plan))
-      .referenceQuery(
-          "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE u.c0 < 0 AND t.c0 = u.c0) FROM t")
-      // NOTE: there is no spilling in empty build test case as all the
-      // build-side rows have been filtered out.
-      .checkSpillStats(false)
-      .run();
-}
-
-TEST_F(HashJoinTest, semiProjectWithNullKeys) {
-  // Some keys have multiple rows: 2, 3, 5.
-  auto probeVectors = makeBatches(3, [&](int32_t /*unused*/) {
-    return makeRowVector(
-        {"t0", "t1"},
-        {
-            makeNullableFlatVector<int64_t>(
-                {1, 2, 2, 3, 3, 3, 4, std::nullopt, 5, 5, 6, 7}),
-            makeFlatVector<int64_t>(
-                {10, 20, 21, 30, 31, 32, 40, -1, 50, 51, 60, 70}),
-        });
-  });
-
-  // Some keys are missing: 2, 6.
-  // Some have multiple rows: 1, 5.
-  // Some keys are not present on probe side: 8.
-  auto buildVectors = makeBatches(3, [&](int32_t /*unused*/) {
-    return makeRowVector(
-        {"u0", "u1"},
-        {
-            makeNullableFlatVector<int64_t>(
-                {1, 1, 3, 4, std::nullopt, 5, 5, 7, 8}),
-            makeFlatVector<int64_t>(
-                {100, 101, 300, 400, -100, 500, 501, 700, 800}),
-        });
-  });
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  auto makePlan = [&](bool nullAware,
-                      const std::string& probeFilter = "",
-                      const std::string& buildFilter = "") {
-    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-    return PlanBuilder(planNodeIdGenerator)
-        .values(probeVectors)
-        .optionalFilter(probeFilter)
-        .hashJoin(
-            {"t0"},
-            {"u0"},
-            PlanBuilder(planNodeIdGenerator)
-                .values(buildVectors)
-                .optionalFilter(buildFilter)
-                .planNode(),
-            "",
-            {"t0", "t1", "match"},
-            core::JoinType::kLeftSemiProject,
-            nullAware)
-        .planNode();
-  };
-
-  // Null join keys on both sides.
-  auto plan = makePlan(false /*nullAware*/);
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(plan)
-      .referenceQuery(
-          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0) FROM t")
-      .run();
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(flipJoinSides(plan))
-      .referenceQuery(
-          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0) FROM t")
-      .run();
-
-  plan = makePlan(true /*nullAware*/);
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(plan)
-      .referenceQuery("SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t")
-      .run();
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(flipJoinSides(plan))
-      .referenceQuery("SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t")
-      .run();
-
-  // Null join keys on build side-only.
-  plan = makePlan(false /*nullAware*/, "t0 IS NOT NULL");
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(plan)
-      .referenceQuery(
-          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0) FROM t WHERE t0 IS NOT NULL")
-      .run();
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(flipJoinSides(plan))
-      .referenceQuery(
-          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0) FROM t WHERE t0 IS NOT NULL")
-      .run();
-
-  plan = makePlan(true /*nullAware*/, "t0 IS NOT NULL");
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(plan)
-      .referenceQuery(
-          "SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t WHERE t0 IS NOT NULL")
-      .run();
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(flipJoinSides(plan))
-      .referenceQuery(
-          "SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t WHERE t0 IS NOT NULL")
-      .run();
-
-  // Null join keys on probe side-only.
-  plan = makePlan(false /*nullAware*/, "", "u0 IS NOT NULL");
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(plan)
-      .referenceQuery(
-          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 IS NOT NULL) FROM t")
-      .run();
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(flipJoinSides(plan))
-      .referenceQuery(
-          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 IS NOT NULL) FROM t")
-      .run();
-
-  plan = makePlan(true /*nullAware*/, "", "u0 IS NOT NULL");
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(plan)
-      .referenceQuery(
-          "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 IS NOT NULL) FROM t")
-      .run();
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(flipJoinSides(plan))
-      .referenceQuery(
-          "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 IS NOT NULL) FROM t")
-      .run();
-
-  // Empty build side.
-  plan = makePlan(false /*nullAware*/, "", "u0 < 0");
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
-      .planNode(plan)
-      .checkSpillStats(false)
-      .referenceQuery(
-          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 < 0) FROM t")
-      .run();
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
-      .planNode(flipJoinSides(plan))
-      .checkSpillStats(false)
-      .referenceQuery(
-          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 < 0) FROM t")
-      .run();
-
-  plan = makePlan(true /*nullAware*/, "", "u0 < 0");
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
-      .planNode(plan)
-      .checkSpillStats(false)
-      .referenceQuery(
-          "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 < 0) FROM t")
-      .run();
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
-      .planNode(flipJoinSides(plan))
-      .checkSpillStats(false)
-      .referenceQuery(
-          "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 < 0) FROM t")
-      .run();
-
-  // Build side with all rows having null join keys.
-  plan = makePlan(false /*nullAware*/, "", "u0 IS NULL");
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
-      .planNode(plan)
-      .checkSpillStats(false)
-      .referenceQuery(
-          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 IS NULL) FROM t")
-      .run();
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
-      .planNode(flipJoinSides(plan))
-      .checkSpillStats(false)
-      .referenceQuery(
-          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 IS NULL) FROM t")
-      .run();
-
-  plan = makePlan(true /*nullAware*/, "", "u0 IS NULL");
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
-      .planNode(plan)
-      .checkSpillStats(false)
-      .referenceQuery(
-          "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 IS NULL) FROM t")
-      .run();
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
-      .planNode(flipJoinSides(plan))
-      .checkSpillStats(false)
-      .referenceQuery(
-          "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 IS NULL) FROM t")
-      .run();
-}
-
-TEST_F(HashJoinTest, semiProjectWithFilter) {
-  auto probeVectors = makeBatches(3, [&](auto /*unused*/) {
-    return makeRowVector(
-        {"t0", "t1"},
-        {
-            makeNullableFlatVector<int32_t>({1, 2, 3, std::nullopt, 5}),
-            makeFlatVector<int64_t>({10, 20, 30, 40, 50}),
-        });
-  });
-
-  auto buildVectors = makeBatches(3, [&](auto /*unused*/) {
-    return makeRowVector(
-        {"u0", "u1"},
-        {
-            makeNullableFlatVector<int32_t>({1, 2, 3, std::nullopt}),
-            makeFlatVector<int64_t>({11, 22, 33, 44}),
-        });
-  });
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  auto makePlan = [&](bool nullAware, const std::string& filter) {
-    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-    return PlanBuilder(planNodeIdGenerator)
-        .values(probeVectors)
-        .hashJoin(
-            {"t0"},
-            {"u0"},
-            PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode(),
-            filter,
-            {"t0", "t1", "match"},
-            core::JoinType::kLeftSemiProject,
-            nullAware)
-        .planNode();
-  };
-
-  std::vector<std::string> filters = {
-      "t1 <> u1",
-      "t1 < u1",
-      "t1 > u1",
-      "t1 is not null AND u1 is not null",
-      "t1 is null OR u1 is null",
-  };
-  for (const auto& filter : filters) {
-    auto plan = makePlan(true /*nullAware*/, filter);
-
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .planNode(plan)
-        .referenceQuery(fmt::format(
-            "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE {}) FROM t", filter))
-        .injectSpill(false)
-        .run();
-
-    plan = makePlan(false /*nullAware*/, filter);
-
-    // DuckDB Exists operator returns NULL when u0 or t0 is NULL. We exclude
-    // these values.
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .planNode(plan)
-        .referenceQuery(fmt::format(
-            "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE (u0 is not null OR t0 is not null) AND u0 = t0 AND {}) FROM t",
-            filter))
-        .injectSpill(false)
-        .run();
-  }
-}
-
-TEST_F(HashJoinTest, nullAwareRightSemiProjectWithFilterNotAllowed) {
-  auto probe = makeRowVector(ROW({"t0", "t1"}, {INTEGER(), BIGINT()}), 10);
-  auto build = makeRowVector(ROW({"u0", "u1"}, {INTEGER(), BIGINT()}), 10);
-
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  VELOX_ASSERT_THROW(
-      PlanBuilder(planNodeIdGenerator)
-          .values({probe})
-          .hashJoin(
-              {"t0"},
-              {"u0"},
-              PlanBuilder(planNodeIdGenerator).values({build}).planNode(),
-              "t1 > u1",
-              {"u0", "u1", "match"},
-              core::JoinType::kRightSemiProject,
-              true /* nullAware */),
-      "Null-aware right semi project join doesn't support extra filter");
-}
-
-TEST_F(HashJoinTest, leftSemiJoinWithExtraOutputCapacity) {
-  std::vector<RowVectorPtr> probeVectors;
-  std::vector<RowVectorPtr> buildVectors;
-  probeVectors.push_back(makeRowVector(
-      {"t0", "t1"},
-      {
-          makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6}),
-          makeFlatVector<int64_t>({10, 10, 10, 10, 10, 10}),
-      }));
-
-  buildVectors.push_back(makeRowVector(
-      {"u0", "u1"},
-      {
-          makeFlatVector<int32_t>({1, 1, 1, 1, 1}),
-          makeFlatVector<int64_t>({10, 10, 10, 10, 10}),
-      }));
-  buildVectors.push_back(makeRowVector(
-      {"u0", "u1"},
-      {
-          makeFlatVector<int32_t>({2, 3, 4, 5, 6}),
-          makeFlatVector<int64_t>({10, 10, 10, 10, 10}),
-      }));
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-  auto runQuery = [&](const std::string& query,
-                      const std::string& filter,
-                      core::JoinType joinType) {
-    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-    std::vector<std::string> outputLayout = {"t0", "t1"};
-    if (joinType == core::JoinType::kLeftSemiProject) {
-      outputLayout.push_back("match");
-    }
-    auto plan = PlanBuilder(planNodeIdGenerator)
-                    .values(probeVectors)
-                    .hashJoin(
-                        {"t0"},
-                        {"u0"},
-                        PlanBuilder(planNodeIdGenerator)
-                            .values(buildVectors)
-                            .planNode(),
-                        filter,
-                        outputLayout,
-                        joinType,
-                        false)
-                    .planNode();
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .planNode(plan)
-        .config(core::QueryConfig::kPreferredOutputBatchRows, "5")
-        .referenceQuery(query)
-        .injectSpill(false)
-        .run();
-  };
-  {
-    SCOPED_TRACE("left semi filter join");
-    std::string filter = "t1 = u1";
-    runQuery(
-        fmt::format(
-            "SELECT t0, t1 FROM t WHERE EXISTS (SELECT u0 FROM u WHERE t0 = u0 AND {})",
-            filter),
-        filter,
-        core::JoinType::kLeftSemiFilter);
-  }
-
-  {
-    SCOPED_TRACE("left semi project join");
-    std::string filter = "t1 <> u1";
-    runQuery(
-        fmt::format(
-            "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE {}) FROM t", filter),
-        filter,
-        core::JoinType::kLeftSemiProject);
-  }
-}
-
-TEST_F(HashJoinTest, nullAwareMultiKeyNotAllowed) {
-  auto probe = makeRowVector(
-      ROW({"t0", "t1", "t2"}, {INTEGER(), BIGINT(), VARCHAR()}), 10);
-  auto build = makeRowVector(
-      ROW({"u0", "u1", "u2"}, {INTEGER(), BIGINT(), VARCHAR()}), 10);
-
-  // Null-aware left semi project join.
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  VELOX_ASSERT_THROW(
-      PlanBuilder(planNodeIdGenerator)
-          .values({probe})
-          .hashJoin(
-              {"t0", "t1"},
-              {"u0", "u1"},
-              PlanBuilder(planNodeIdGenerator).values({build}).planNode(),
-              "",
-              {"t0", "t1", "match"},
-              core::JoinType::kLeftSemiProject,
-              true /* nullAware */),
-      "Null-aware joins allow only one join key");
-
-  // Null-aware right semi project join.
-  VELOX_ASSERT_THROW(
-      PlanBuilder(planNodeIdGenerator)
-          .values({probe})
-          .hashJoin(
-              {"t0", "t1"},
-              {"u0", "u1"},
-              PlanBuilder(planNodeIdGenerator).values({build}).planNode(),
-              "",
-              {"u0", "u1", "match"},
-              core::JoinType::kRightSemiProject,
-              true /* nullAware */),
-      "Null-aware joins allow only one join key");
-
-  // Null-aware anti join.
-  VELOX_ASSERT_THROW(
-      PlanBuilder(planNodeIdGenerator)
-          .values({probe})
-          .hashJoin(
-              {"t0", "t1"},
-              {"u0", "u1"},
-              PlanBuilder(planNodeIdGenerator).values({build}).planNode(),
-              "",
-              {"t0", "t1"},
-              core::JoinType::kAnti,
-              true /* nullAware */),
-      "Null-aware joins allow only one join key");
-}
-
-TEST_F(HashJoinTest, semiProjectOverLazyVectors) {
-  auto probeVectors = makeBatches(1, [&](auto /*unused*/) {
-    return makeRowVector(
-        {"t0", "t1"},
-        {
-            makeFlatVector<int32_t>(1'000, [](auto row) { return row; }),
-            makeFlatVector<int64_t>(1'000, [](auto row) { return row * 10; }),
-        });
-  });
-
-  auto buildVectors = makeBatches(3, [&](auto /*unused*/) {
-    return makeRowVector(
-        {"u0", "u1"},
-        {
-            makeFlatVector<int32_t>(
-                1'000, [](auto row) { return -100 + (row / 5); }),
-            makeFlatVector<int64_t>(
-                1'000, [](auto row) { return -1000 + (row / 5) * 10; }),
-        });
-  });
-
-  std::shared_ptr<TempFilePath> probeFile = TempFilePath::create();
-  writeToFile(probeFile->getPath(), probeVectors);
-
-  std::shared_ptr<TempFilePath> buildFile = TempFilePath::create();
-  writeToFile(buildFile->getPath(), buildVectors);
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  core::PlanNodeId probeScanId;
-  core::PlanNodeId buildScanId;
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto plan = PlanBuilder(planNodeIdGenerator)
-                  .tableScan(asRowType(probeVectors[0]->type()))
-                  .capturePlanNodeId(probeScanId)
-                  .hashJoin(
-                      {"t0"},
-                      {"u0"},
-                      PlanBuilder(planNodeIdGenerator)
-                          .tableScan(asRowType(buildVectors[0]->type()))
-                          .capturePlanNodeId(buildScanId)
-                          .planNode(),
-                      "",
-                      {"t0", "t1", "match"},
-                      core::JoinType::kLeftSemiProject)
-                  .planNode();
-
-  SplitInput splitInput = {
-      {probeScanId,
-       {exec::Split(makeHiveConnectorSplit(probeFile->getPath()))}},
-      {buildScanId,
-       {exec::Split(makeHiveConnectorSplit(buildFile->getPath()))}},
-  };
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(plan)
-      .inputSplits(splitInput)
-      .checkSpillStats(false)
-      .referenceQuery("SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t")
-      .run();
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(flipJoinSides(plan))
-      .inputSplits(splitInput)
-      .checkSpillStats(false)
-      .referenceQuery("SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t")
-      .run();
-
-  // With extra filter.
-  planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  plan = PlanBuilder(planNodeIdGenerator)
-             .tableScan(asRowType(probeVectors[0]->type()))
-             .capturePlanNodeId(probeScanId)
-             .hashJoin(
-                 {"t0"},
-                 {"u0"},
-                 PlanBuilder(planNodeIdGenerator)
-                     .tableScan(asRowType(buildVectors[0]->type()))
-                     .capturePlanNodeId(buildScanId)
-                     .planNode(),
-                 "(t1 + u1) % 3 = 0",
-                 {"t0", "t1", "match"},
-                 core::JoinType::kLeftSemiProject)
-             .planNode();
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(plan)
-      .inputSplits(splitInput)
-      .checkSpillStats(false)
-      .referenceQuery(
-          "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE (t1 + u1) % 3 = 0) FROM t")
-      .run();
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(flipJoinSides(plan))
-      .inputSplits(splitInput)
-      .checkSpillStats(false)
-      .referenceQuery(
-          "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE (t1 + u1) % 3 = 0) FROM t")
-      .run();
-}
-
-VELOX_INSTANTIATE_TEST_SUITE_P(
-    HashJoinTest,
-    MultiThreadedHashJoinTest,
-    testing::ValuesIn(MultiThreadedHashJoinTest::getTestParams()));
-
-// TODO: try to parallelize the following test cases if possible.
-TEST_F(HashJoinTest, memory) {
-  // Measures memory allocation in a 1:n hash join followed by
-  // projection and aggregation. We expect vectors to be mostly
-  // reused, except for t_k0 + 1, which is a dictionary after the
-  // join.
-  std::vector<RowVectorPtr> probeVectors =
-      makeBatches(10, [&](int32_t /*unused*/) {
-        return std::dynamic_pointer_cast<RowVector>(
-            BatchMaker::createBatch(probeType_, 1000, *pool_));
-      });
-
-  // auto buildType = makeRowType(keyTypes, "u_");
-  std::vector<RowVectorPtr> buildVectors =
-      makeBatches(10, [&](int32_t /*unused*/) {
-        return std::dynamic_pointer_cast<RowVector>(
-            BatchMaker::createBatch(buildType_, 1000, *pool_));
-      });
-
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  CursorParameters params;
-  params.planNode = PlanBuilder(planNodeIdGenerator)
-                        .values(probeVectors, true)
-                        .hashJoin(
-                            {"t_k1"},
-                            {"u_k1"},
-                            PlanBuilder(planNodeIdGenerator)
-                                .values(buildVectors, true)
-                                .planNode(),
-                            "",
-                            concat(probeType_->names(), buildType_->names()))
-                        .project({"t_k1 % 1000 AS k1", "u_k1 % 1000 AS k2"})
-                        .singleAggregation({}, {"sum(k1)", "sum(k2)"})
-                        .planNode();
-  params.queryCtx = core::QueryCtx::create(driverExecutor_.get());
-  auto [taskCursor, rows] = readCursor(params);
-  EXPECT_GT(3'500, params.queryCtx->pool()->stats().numAllocs);
-  EXPECT_GT(40'000'000, params.queryCtx->pool()->stats().cumulativeBytes);
-}
-
-TEST_F(HashJoinTest, lazyVectors) {
-  // a dataset of multiple row groups with multiple columns. We create
-  // different dictionary wrappings for different columns and load the
-  // rows in scope at different times.
-  auto probeVectors = makeBatches(3, [&](int32_t /*unused*/) {
-    return makeRowVector(
-        {makeFlatVector<int32_t>(3'000, [](auto row) { return row; }),
-         makeFlatVector<int64_t>(30'000, [](auto row) { return row % 23; }),
-         makeFlatVector<int32_t>(30'000, [](auto row) { return row % 31; }),
-         makeFlatVector<StringView>(30'000, [](auto row) {
-           return StringView::makeInline(fmt::format("{}   string", row % 43));
-         })});
-  });
-
-  std::vector<RowVectorPtr> buildVectors =
-      makeBatches(4, [&](int32_t /*unused*/) {
-        return makeRowVector(
-            {makeFlatVector<int32_t>(1'000, [](auto row) { return row * 3; }),
-             makeFlatVector<int64_t>(
-                 10'000, [](auto row) { return row % 31; })});
-      });
-
-  std::vector<std::shared_ptr<TempFilePath>> tempFiles;
-
-  for (const auto& probeVector : probeVectors) {
-    tempFiles.push_back(TempFilePath::create());
-    writeToFile(tempFiles.back()->getPath(), probeVector);
-  }
-  createDuckDbTable("t", probeVectors);
-
-  for (const auto& buildVector : buildVectors) {
-    tempFiles.push_back(TempFilePath::create());
-    writeToFile(tempFiles.back()->getPath(), buildVector);
-  }
-  createDuckDbTable("u", buildVectors);
-
-  auto makeInputSplits = [&](const core::PlanNodeId& probeScanId,
-                             const core::PlanNodeId& buildScanId) {
-    return [&] {
-      std::vector<exec::Split> probeSplits;
-      for (int i = 0; i < probeVectors.size(); ++i) {
-        probeSplits.push_back(
-            exec::Split(makeHiveConnectorSplit(tempFiles[i]->getPath())));
-      }
-      std::vector<exec::Split> buildSplits;
-      for (int i = 0; i < buildVectors.size(); ++i) {
-        buildSplits.push_back(exec::Split(makeHiveConnectorSplit(
-            tempFiles[probeSplits.size() + i]->getPath())));
-      }
-      SplitInput splits;
-      splits.emplace(probeScanId, probeSplits);
-      splits.emplace(buildScanId, buildSplits);
-      return splits;
-    };
-  };
-
-  {
-    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-    core::PlanNodeId probeScanId;
-    core::PlanNodeId buildScanId;
-    auto op = PlanBuilder(planNodeIdGenerator)
-                  .tableScan(ROW({"c0", "c1"}, {INTEGER(), BIGINT()}))
-                  .capturePlanNodeId(probeScanId)
-                  .hashJoin(
-                      {"c0"},
-                      {"c0"},
-                      PlanBuilder(planNodeIdGenerator)
-                          .tableScan(ROW({"c0"}, {INTEGER()}))
-                          .capturePlanNodeId(buildScanId)
-                          .planNode(),
-                      "",
-                      {"c1"})
-                  .project({"c1 + 1"})
-                  .planNode();
-
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .planNode(std::move(op))
-        .makeInputSplits(makeInputSplits(probeScanId, buildScanId))
-        .referenceQuery("SELECT t.c1 + 1 FROM t, u WHERE t.c0 = u.c0")
-        .run();
-  }
-
-  {
-    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-    core::PlanNodeId probeScanId;
-    core::PlanNodeId buildScanId;
-    auto op = PlanBuilder(planNodeIdGenerator)
-                  .tableScan(
-                      ROW({"c0", "c1", "c2", "c3"},
-                          {INTEGER(), BIGINT(), INTEGER(), VARCHAR()}))
-                  .capturePlanNodeId(probeScanId)
-                  .filter("c2 < 29")
-                  .hashJoin(
-                      {"c0"},
-                      {"bc0"},
-                      PlanBuilder(planNodeIdGenerator)
-                          .tableScan(ROW({"c0", "c1"}, {INTEGER(), BIGINT()}))
-                          .capturePlanNodeId(buildScanId)
-                          .project({"c0 as bc0", "c1 as bc1"})
-                          .planNode(),
-                      "(c1 + bc1) % 33 < 27",
-                      {"c1", "bc1", "c3"})
-                  .project({"c1 + 1", "bc1", "length(c3)"})
-                  .planNode();
-
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .planNode(std::move(op))
-        .makeInputSplits(makeInputSplits(probeScanId, buildScanId))
-        .referenceQuery(
-            "SELECT t.c1 + 1, U.c1, length(t.c3) FROM t, u WHERE t.c0 = u.c0 and t.c2 < 29 and (t.c1 + u.c1) % 33 < 27")
-        .run();
-  }
-}
-
-TEST_F(HashJoinTest, lazyVectorNotLoadedInFilter) {
-  // Ensure that if lazy vectors are temporarily wrapped during a filter's
-  // execution and remain unloaded, the temporary wrap is promptly
-  // discarded. This precaution prevents the generation of the probe's output
-  // from wrapping an unloaded vector while the temporary wrap is
-  // still alive.
-  // This is done by generating a sufficiently small batch to allow the lazy
-  // vector to remain unloaded, as it doesn't need to be split between batches.
-  // Then we use a filter that skips the execution of the expression containing
-  // the lazy vector, thereby avoiding its loading.
-
-  testLazyVectorsWithFilter(
-      core::JoinType::kInner,
-      "c1 >= 0 OR c2 > 0",
-      {"c1", "c2"},
-      "SELECT t.c1, t.c2 FROM t, u WHERE t.c0 = u.c0");
-}
-
-TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterLeftJoin) {
-  // Test the case where a filter loads a subset of the rows that will be output
-  // from a column on the probe side.
-
-  testLazyVectorsWithFilter(
-      core::JoinType::kLeft,
-      "c1 > 0 AND c2 > 0",
-      {"c1", "c2"},
-      "SELECT t.c1, t.c2 FROM t LEFT JOIN u ON t.c0 = u.c0 AND (c1 > 0 AND c2 > 0)");
-}
-
-TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterFullJoin) {
-  // Test the case where a filter loads a subset of the rows that will be output
-  // from a column on the probe side.
-
-  testLazyVectorsWithFilter(
-      core::JoinType::kFull,
-      "c1 > 0 AND c2 > 0",
-      {"c1", "c2"},
-      "SELECT t.c1, t.c2 FROM t FULL OUTER JOIN u ON t.c0 = u.c0 AND (c1 > 0 AND c2 > 0)");
-}
-
-TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterLeftSemiProject) {
-  // Test the case where a filter loads a subset of the rows that will be output
-  // from a column on the probe side.
-
-  testLazyVectorsWithFilter(
-      core::JoinType::kLeftSemiProject,
-      "c1 > 0 AND c2 > 0",
-      {"c1", "c2", "match"},
-      "SELECT t.c1, t.c2, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0 AND (t.c1 > 0 AND t.c2 > 0)) FROM t");
-}
-
-TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterAntiJoin) {
-  // Test the case where a filter loads a subset of the rows that will be output
-  // from a column on the probe side.
-
-  testLazyVectorsWithFilter(
-      core::JoinType::kAnti,
-      "c1 > 0 AND c2 > 0",
-      {"c1", "c2"},
-      "SELECT t.c1, t.c2 FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE t.c0 = u.c0 AND (t.c1 > 0 AND t.c2 > 0))");
-}
-
-TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterInnerJoin) {
-  // Test the case where a filter loads a subset of the rows that will be output
-  // from a column on the probe side.
-
-  testLazyVectorsWithFilter(
-      core::JoinType::kInner,
-      "not (c1 < 15 and c2 >= 0)",
-      {"c1", "c2"},
-      "SELECT t.c1, t.c2 FROM t, u WHERE t.c0 = u.c0 AND NOT (c1 < 15 AND c2 >= 0)");
-}
-
-TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterLeftSemiFilter) {
-  // Test the case where a filter loads a subset of the rows that will be output
-  // from a column on the probe side.
-
-  testLazyVectorsWithFilter(
-      core::JoinType::kLeftSemiFilter,
-      "not (c1 < 15 and c2 >= 0)",
-      {"c1", "c2"},
-      "SELECT t.c1, t.c2 FROM t WHERE c0 IN (SELECT u.c0 FROM u WHERE t.c0 = u.c0 AND NOT (t.c1 < 15 AND t.c2 >= 0))");
-}
-
-TEST_F(HashJoinTest, dynamicFilters) {
-  const int32_t numSplits = 10;
-  const int32_t numRowsProbe = 333;
-  const int32_t numRowsBuild = 100;
-
-  std::vector<RowVectorPtr> probeVectors;
-  probeVectors.reserve(numSplits);
-
-  std::vector<std::shared_ptr<TempFilePath>> tempFiles;
-  for (int32_t i = 0; i < numSplits; ++i) {
-    auto rowVector = makeRowVector({
-        makeFlatVector<int32_t>(
-            numRowsProbe, [&](auto row) { return row - i * 10; }),
-        makeFlatVector<int64_t>(numRowsProbe, [](auto row) { return row; }),
-    });
-    probeVectors.push_back(rowVector);
-    tempFiles.push_back(TempFilePath::create());
-    writeToFile(tempFiles.back()->getPath(), rowVector);
-  }
-  auto makeInputSplits = [&](const core::PlanNodeId& nodeId) {
-    return [&] {
-      std::vector<exec::Split> probeSplits;
-      for (auto& file : tempFiles) {
-        probeSplits.push_back(
-            exec::Split(makeHiveConnectorSplit(file->getPath())));
-      }
-      SplitInput splits;
-      splits.emplace(nodeId, probeSplits);
-      return splits;
-    };
-  };
-
-  // 100 key values in [35, 233] range.
-  std::vector<RowVectorPtr> buildVectors;
-  for (int i = 0; i < 5; ++i) {
-    buildVectors.push_back(makeRowVector({
-        makeFlatVector<int32_t>(
-            numRowsBuild / 5,
-            [i](auto row) { return 35 + 2 * (row + i * numRowsBuild / 5); }),
-        makeFlatVector<int64_t>(numRowsBuild / 5, [](auto row) { return row; }),
-    }));
-  }
-  std::vector<RowVectorPtr> keyOnlyBuildVectors;
-  for (int i = 0; i < 5; ++i) {
-    keyOnlyBuildVectors.push_back(
-        makeRowVector({makeFlatVector<int32_t>(numRowsBuild / 5, [i](auto row) {
-          return 35 + 2 * (row + i * numRowsBuild / 5);
-        })}));
-  }
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  auto probeType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
-
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-
-  auto buildSide = PlanBuilder(planNodeIdGenerator, pool_.get())
-                       .values(buildVectors)
-                       .project({"c0 AS u_c0", "c1 AS u_c1"})
-                       .planNode();
-  auto keyOnlyBuildSide = PlanBuilder(planNodeIdGenerator, pool_.get())
-                              .values(keyOnlyBuildVectors)
-                              .project({"c0 AS u_c0"})
-                              .planNode();
-
-  // Basic push-down.
-  {
-    SCOPED_TRACE("Inner join");
-    core::PlanNodeId probeScanId;
-    core::PlanNodeId joinId;
-    auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
-                  .tableScan(probeType)
-                  .capturePlanNodeId(probeScanId)
-                  .hashJoin(
-                      {"c0"},
-                      {"u_c0"},
-                      buildSide,
-                      "",
-                      {"c0", "c1", "u_c1"},
-                      core::JoinType::kInner)
-                  .capturePlanNodeId(joinId)
-                  .project({"c0", "c1 + 1", "c1 + u_c1"})
-                  .planNode();
-    {
-      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-          .planNode(std::move(op))
-          .makeInputSplits(makeInputSplits(probeScanId))
-          .referenceQuery(
-              "SELECT t.c0, t.c1 + 1, t.c1 + u.c1 FROM t, u WHERE t.c0 = u.c0")
-          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
-            auto planStats = toPlanStats(task->taskStats());
-            if (hasSpill) {
-              // Dynamic filtering should be disabled with spilling triggered.
-              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
-              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
-              ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
-              ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
-            } else {
-              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
-              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
-              ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
-              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
-              ASSERT_EQ(
-                  planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
-                  std::unordered_set<core::PlanNodeId>({joinId}));
-            }
-          })
-          .run();
-    }
-
-    // Left semi join.
-    op = PlanBuilder(planNodeIdGenerator, pool_.get())
-             .tableScan(probeType)
-             .capturePlanNodeId(probeScanId)
-             .hashJoin(
-                 {"c0"},
-                 {"u_c0"},
-                 buildSide,
-                 "",
-                 {"c0", "c1"},
-                 core::JoinType::kLeftSemiFilter)
-             .capturePlanNodeId(joinId)
-             .project({"c0", "c1 + 1"})
-             .planNode();
-
-    {
-      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-          .planNode(std::move(op))
-          .makeInputSplits(makeInputSplits(probeScanId))
-          .referenceQuery(
-              "SELECT t.c0, t.c1 + 1 FROM t WHERE t.c0 IN (SELECT c0 FROM u)")
-          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
-            auto planStats = toPlanStats(task->taskStats());
-            if (hasSpill) {
-              // Dynamic filtering should be disabled with spilling triggered.
-              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
-              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
-              ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
-              ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
-              ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
-            } else {
-              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
-              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
-              ASSERT_GT(getReplacedWithFilterRows(task, 1).sum, 0);
-              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
-              ASSERT_EQ(
-                  planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
-                  std::unordered_set<core::PlanNodeId>({joinId}));
-            }
-          })
-          .run();
-    }
-
-    // Right semi join.
-    op = PlanBuilder(planNodeIdGenerator, pool_.get())
-             .tableScan(probeType)
-             .capturePlanNodeId(probeScanId)
-             .hashJoin(
-                 {"c0"},
-                 {"u_c0"},
-                 buildSide,
-                 "",
-                 {"u_c0", "u_c1"},
-                 core::JoinType::kRightSemiFilter)
-             .capturePlanNodeId(joinId)
-             .project({"u_c0", "u_c1 + 1"})
-             .planNode();
-
-    {
-      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-          .planNode(std::move(op))
-          .makeInputSplits(makeInputSplits(probeScanId))
-          .referenceQuery(
-              "SELECT u.c0, u.c1 + 1 FROM u WHERE u.c0 IN (SELECT c0 FROM t)")
-          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
-            auto planStats = toPlanStats(task->taskStats());
-            if (hasSpill) {
-              // Dynamic filtering should be disabled with spilling triggered.
-              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
-              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
-              ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
-              ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
-              ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
-            } else {
-              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
-              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
-              ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
-              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
-              ASSERT_EQ(
-                  planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
-                  std::unordered_set<core::PlanNodeId>({joinId}));
-            }
-          })
-          .run();
-    }
-
-    // Right join.
-    op = PlanBuilder(planNodeIdGenerator, pool_.get())
-             .tableScan(probeType)
-             .capturePlanNodeId(probeScanId)
-             .hashJoin(
-                 {"c0"},
-                 {"u_c0"},
-                 buildSide,
-                 "",
-                 {"c0", "c1", "u_c1"},
-                 core::JoinType::kRight)
-             .capturePlanNodeId(joinId)
-             .project({"c0", "c1 + 1", "c1 + u_c1"})
-             .planNode();
-    {
-      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-          .planNode(std::move(op))
-          .makeInputSplits(makeInputSplits(probeScanId))
-          .referenceQuery(
-              "SELECT t.c0, t.c1 + 1, t.c1 + u.c1 FROM t RIGHT JOIN u ON t.c0 = u.c0")
-          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
-            auto planStats = toPlanStats(task->taskStats());
-            if (hasSpill) {
-              // Dynamic filtering should be disabled with spilling triggered.
-              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
-              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
-              ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
-              ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
-            } else {
-              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
-              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
-              ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
-              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
-              ASSERT_EQ(
-                  planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
-                  std::unordered_set<core::PlanNodeId>({joinId}));
-            }
-          })
-          .run();
-    }
-  }
-
-  // Basic push-down with column names projected out of the table scan
-  // having different names than column names in the files.
-  {
-    SCOPED_TRACE("Inner join column rename");
-    auto scanOutputType = ROW({"a", "b"}, {INTEGER(), BIGINT()});
-    connector::ColumnHandleMap assignments;
-    assignments["a"] = regularColumn("c0", INTEGER());
-    assignments["b"] = regularColumn("c1", BIGINT());
-
-    core::PlanNodeId probeScanId;
-    core::PlanNodeId joinId;
-    auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
-                  .startTableScan()
-                  .outputType(scanOutputType)
-                  .assignments(assignments)
-                  .endTableScan()
-                  .capturePlanNodeId(probeScanId)
-                  .hashJoin({"a"}, {"u_c0"}, buildSide, "", {"a", "b", "u_c1"})
-                  .capturePlanNodeId(joinId)
-                  .project({"a", "b + 1", "b + u_c1"})
-                  .planNode();
-
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .planNode(std::move(op))
-        .makeInputSplits(makeInputSplits(probeScanId))
-        .referenceQuery(
-            "SELECT t.c0, t.c1 + 1, t.c1 + u.c1 FROM t, u WHERE t.c0 = u.c0")
-        .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-          SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
-          auto planStats = toPlanStats(task->taskStats());
-          if (hasSpill) {
-            // Dynamic filtering should be disabled with spilling triggered.
-            ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
-            ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
-            ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
-            ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
-            ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
-          } else {
-            ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
-            ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
-            ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
-            ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
-            ASSERT_EQ(
-                planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
-                std::unordered_set<core::PlanNodeId>({joinId}));
-          }
-        })
-        .run();
-  }
-
-  // Push-down that requires merging filters.
-  {
-    SCOPED_TRACE("Merge filters");
-    core::PlanNodeId probeScanId;
-    core::PlanNodeId joinId;
-    auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
-                  .tableScan(probeType, {"c0 < 500::INTEGER"})
-                  .capturePlanNodeId(probeScanId)
-                  .hashJoin({"c0"}, {"u_c0"}, buildSide, "", {"c1", "u_c1"})
-                  .capturePlanNodeId(joinId)
-                  .project({"c1 + u_c1"})
-                  .planNode();
-
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .planNode(std::move(op))
-        .makeInputSplits(makeInputSplits(probeScanId))
-        .referenceQuery(
-            "SELECT t.c1 + u.c1 FROM t, u WHERE t.c0 = u.c0 AND t.c0 < 500")
-        .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-          SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
-          auto planStats = toPlanStats(task->taskStats());
-          if (hasSpill) {
-            // Dynamic filtering should be disabled with spilling triggered.
-            ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
-            ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
-            ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
-            ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
-            ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
-          } else {
-            ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
-            ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
-            ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
-            ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
-            ASSERT_EQ(
-                planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
-                std::unordered_set<core::PlanNodeId>({joinId}));
-          }
-        })
-        .run();
-  }
-
-  // Push-down that turns join into a no-op.
-  {
-    SCOPED_TRACE("canReplaceWithDynamicFilter");
-    core::PlanNodeId probeScanId;
-    core::PlanNodeId joinId;
-    auto op =
-        PlanBuilder(planNodeIdGenerator, pool_.get())
-            .tableScan(probeType)
-            .capturePlanNodeId(probeScanId)
-            .hashJoin({"c0"}, {"u_c0"}, keyOnlyBuildSide, "", {"c0", "c1"})
-            .capturePlanNodeId(joinId)
-            .project({"c0", "c1 + 1"})
-            .planNode();
-
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .planNode(std::move(op))
-        .makeInputSplits(makeInputSplits(probeScanId))
-        .referenceQuery("SELECT t.c0, t.c1 + 1 FROM t, u WHERE t.c0 = u.c0")
-        .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-          SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
-          auto planStats = toPlanStats(task->taskStats());
-          if (hasSpill) {
-            // Dynamic filtering should be disabled with spilling triggered.
-            ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
-            ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
-            ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
-            ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
-            ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
-          } else {
-            ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
-            ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
-            ASSERT_EQ(
-                getReplacedWithFilterRows(task, 1).sum,
-                numRowsBuild * numSplits);
-            ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
-            ASSERT_EQ(
-                planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
-                std::unordered_set<core::PlanNodeId>({joinId}));
-          }
-        })
-        .run();
-  }
-
-  // Push-down that turns join into a no-op with output having a different
-  // number of columns than the input.
-  {
-    SCOPED_TRACE("canReplaceWithDynamicFilter column rename");
-    core::PlanNodeId probeScanId;
-    core::PlanNodeId joinId;
-    auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
-                  .tableScan(probeType)
-                  .capturePlanNodeId(probeScanId)
-                  .hashJoin({"c0"}, {"u_c0"}, keyOnlyBuildSide, "", {"c0"})
-                  .capturePlanNodeId(joinId)
-                  .planNode();
-
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .planNode(std::move(op))
-        .makeInputSplits(makeInputSplits(probeScanId))
-        .referenceQuery("SELECT t.c0 FROM t JOIN u ON (t.c0 = u.c0)")
-        .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-          SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
-          auto planStats = toPlanStats(task->taskStats());
-          if (hasSpill) {
-            // Dynamic filtering should be disabled with spilling triggered.
-            ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
-            ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
-            ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
-            ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
-            ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
-          } else {
-            ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
-            ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
-            ASSERT_EQ(
-                getReplacedWithFilterRows(task, 1).sum,
-                numRowsBuild * numSplits);
-            ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
-            ASSERT_EQ(
-                planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
-                std::unordered_set<core::PlanNodeId>({joinId}));
-          }
-        })
-        .run();
-  }
-
-  // Push-down that requires merging filters and turns join into a no-op.
-  {
-    SCOPED_TRACE("canReplaceWithDynamicFilter merge filters");
-    core::PlanNodeId probeScanId;
-    core::PlanNodeId joinId;
-    auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
-                  .tableScan(probeType, {"c0 < 500::INTEGER"})
-                  .capturePlanNodeId(probeScanId)
-                  .hashJoin({"c0"}, {"u_c0"}, keyOnlyBuildSide, "", {"c1"})
-                  .capturePlanNodeId(joinId)
-                  .project({"c1 + 1"})
-                  .planNode();
-
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .planNode(std::move(op))
-        .makeInputSplits(makeInputSplits(probeScanId))
-        .referenceQuery(
-            "SELECT t.c1 + 1 FROM t, u WHERE t.c0 = u.c0 AND t.c0 < 500")
-        .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-          SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
-          auto planStats = toPlanStats(task->taskStats());
-          if (hasSpill) {
-            // Dynamic filtering should be disabled with spilling triggered.
-            ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
-            ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
-            ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
-            ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
-            ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
-          } else {
-            ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
-            ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
-            ASSERT_GT(getReplacedWithFilterRows(task, 1).sum, 0);
-            ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
-            ASSERT_EQ(
-                planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
-                std::unordered_set<core::PlanNodeId>({joinId}));
-          }
-        })
-        .run();
-  }
-
-  // Push-down with highly selective filter in the scan.
-  {
-    SCOPED_TRACE("Highly selective filter");
-    // Inner join.
-    core::PlanNodeId probeScanId;
-    core::PlanNodeId joinId;
-    auto op =
-        PlanBuilder(planNodeIdGenerator, pool_.get())
-            .tableScan(probeType, {"c0 < 200::INTEGER"})
-            .capturePlanNodeId(probeScanId)
-            .hashJoin(
-                {"c0"}, {"u_c0"}, buildSide, "", {"c1"}, core::JoinType::kInner)
-            .capturePlanNodeId(joinId)
-            .project({"c1 + 1"})
-            .planNode();
-
-    {
-      SCOPED_TRACE("Inner join");
-      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-          .planNode(std::move(op))
-          .makeInputSplits(makeInputSplits(probeScanId))
-          .referenceQuery(
-              "SELECT t.c1 + 1 FROM t, u WHERE t.c0 = u.c0 AND t.c0 < 200")
-          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
-            auto planStats = toPlanStats(task->taskStats());
-            if (hasSpill) {
-              // Dynamic filtering should be disabled with spilling triggered.
-              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
-              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
-              ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
-              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
-              ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
-            } else {
-              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
-              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
-              ASSERT_GT(getReplacedWithFilterRows(task, 1).sum, 0);
-              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
-              ASSERT_EQ(
-                  planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
-                  std::unordered_set<core::PlanNodeId>({joinId}));
-            }
-          })
-          .run();
-    }
-
-    // Left semi join.
-    op = PlanBuilder(planNodeIdGenerator, pool_.get())
-             .tableScan(probeType, {"c0 < 200::INTEGER"})
-             .capturePlanNodeId(probeScanId)
-             .hashJoin(
-                 {"c0"},
-                 {"u_c0"},
-                 buildSide,
-                 "",
-                 {"c1"},
-                 core::JoinType::kLeftSemiFilter)
-             .capturePlanNodeId(joinId)
-             .project({"c1 + 1"})
-             .planNode();
-
-    {
-      SCOPED_TRACE("Left semi join");
-      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-          .planNode(std::move(op))
-          .makeInputSplits(makeInputSplits(probeScanId))
-          .referenceQuery(
-              "SELECT t.c1 + 1 FROM t WHERE t.c0 IN (SELECT c0 FROM u) AND t.c0 < 200")
-          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
-            auto planStats = toPlanStats(task->taskStats());
-            if (hasSpill) {
-              // Dynamic filtering should be disabled with spilling triggered.
-              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
-              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
-              ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
-              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
-              ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
-            } else {
-              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
-              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
-              ASSERT_GT(getReplacedWithFilterRows(task, 1).sum, 0);
-              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
-              ASSERT_EQ(
-                  planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
-                  std::unordered_set<core::PlanNodeId>({joinId}));
-            }
-          })
-          .run();
-    }
-
-    // Right semi join.
-    op = PlanBuilder(planNodeIdGenerator, pool_.get())
-             .tableScan(probeType, {"c0 < 200::INTEGER"})
-             .capturePlanNodeId(probeScanId)
-             .hashJoin(
-                 {"c0"},
-                 {"u_c0"},
-                 buildSide,
-                 "",
-                 {"u_c1"},
-                 core::JoinType::kRightSemiFilter)
-             .capturePlanNodeId(joinId)
-             .project({"u_c1 + 1"})
-             .planNode();
-
-    {
-      SCOPED_TRACE("Right semi join");
-      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-          .planNode(std::move(op))
-          .makeInputSplits(makeInputSplits(probeScanId))
-          .referenceQuery(
-              "SELECT u.c1 + 1 FROM u WHERE u.c0 IN (SELECT c0 FROM t) AND u.c0 < 200")
-          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
-            auto planStats = toPlanStats(task->taskStats());
-            if (hasSpill) {
-              // Dynamic filtering should be disabled with spilling triggered.
-              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
-              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
-              ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
-              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
-              ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
-            } else {
-              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
-              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
-              ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
-              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
-              ASSERT_EQ(
-                  planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
-                  std::unordered_set<core::PlanNodeId>({joinId}));
-            }
-          })
-          .run();
-    }
-
-    // Right join.
-    op =
-        PlanBuilder(planNodeIdGenerator, pool_.get())
-            .tableScan(probeType, {"c0 < 200::INTEGER"})
-            .capturePlanNodeId(probeScanId)
-            .hashJoin(
-                {"c0"}, {"u_c0"}, buildSide, "", {"c1"}, core::JoinType::kRight)
-            .capturePlanNodeId(joinId)
-            .project({"c1 + 1"})
-            .planNode();
-
-    {
-      SCOPED_TRACE("Right join");
-      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-          .planNode(std::move(op))
-          .makeInputSplits(makeInputSplits(probeScanId))
-          .referenceQuery(
-              "SELECT t.c1 + 1 FROM (SELECT * FROM t WHERE t.c0 < 200) t RIGHT JOIN u ON t.c0 = u.c0")
-          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
-            auto planStats = toPlanStats(task->taskStats());
-            if (hasSpill) {
-              // Dynamic filtering should be disabled with spilling triggered.
-              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
-              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
-              ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
-              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
-              ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
-            } else {
-              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
-              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
-              ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
-              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
-              ASSERT_EQ(
-                  planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
-                  std::unordered_set<core::PlanNodeId>({joinId}));
-            }
-          })
-          .run();
-    }
-  }
-
-  // Disable filter push-down by using values in place of scan.
-  {
-    SCOPED_TRACE("Disabled in case of values node");
-    core::PlanNodeId joinId;
-    auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
-                  .values(probeVectors)
-                  .hashJoin({"c0"}, {"u_c0"}, buildSide, "", {"c1"})
-                  .capturePlanNodeId(joinId)
-                  .project({"c1 + 1"})
-                  .planNode();
-
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .planNode(std::move(op))
-        .referenceQuery("SELECT t.c1 + 1 FROM t, u WHERE t.c0 = u.c0")
-        .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-          auto planStats = toPlanStats(task->taskStats());
-          ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
-          ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
-          ASSERT_EQ(numRowsProbe * numSplits, getInputPositions(task, 1));
-        })
-        .run();
-  }
-
-  // Disable filter push-down by using an expression as the join key on the
-  // probe side.
-  {
-    SCOPED_TRACE("Disabled in case of join condition");
-    core::PlanNodeId probeScanId;
-    core::PlanNodeId joinId;
-    auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
-                  .tableScan(probeType)
-                  .capturePlanNodeId(probeScanId)
-                  .project({"cast(c0 + 1 as integer) AS t_key", "c1"})
-                  .hashJoin({"t_key"}, {"u_c0"}, buildSide, "", {"c1"})
-                  .capturePlanNodeId(joinId)
-                  .project({"c1 + 1"})
-                  .planNode();
-
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .planNode(std::move(op))
-        .makeInputSplits(makeInputSplits(probeScanId))
-        .referenceQuery("SELECT t.c1 + 1 FROM t, u WHERE (t.c0 + 1) = u.c0")
-        .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-          auto planStats = toPlanStats(task->taskStats());
-          ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
-          ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
-          ASSERT_EQ(numRowsProbe * numSplits, getInputPositions(task, 1));
-          ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
-        })
-        .run();
-  }
-}
-
-TEST_F(HashJoinTest, dynamicFiltersStatsWithChainedJoins) {
-  const int32_t numSplits = 10;
-  const int32_t numProbeRows = 333;
-  const int32_t numBuildRows = 100;
-
-  std::vector<RowVectorPtr> probeVectors;
-  probeVectors.reserve(numSplits);
-  std::vector<std::shared_ptr<TempFilePath>> tempFiles;
-  for (int32_t i = 0; i < numSplits; ++i) {
-    auto rowVector = makeRowVector({
-        makeFlatVector<int32_t>(
-            numProbeRows, [&](auto row) { return row - i * 10; }),
-        makeFlatVector<int64_t>(numProbeRows, [](auto row) { return row; }),
-    });
-    probeVectors.push_back(rowVector);
-    tempFiles.push_back(TempFilePath::create());
-    writeToFile(tempFiles.back()->getPath(), rowVector);
-  }
-  auto makeInputSplits = [&](const core::PlanNodeId& nodeId) {
-    return [&] {
-      std::vector<exec::Split> probeSplits;
-      for (auto& file : tempFiles) {
-        probeSplits.push_back(
-            exec::Split(makeHiveConnectorSplit(file->getPath())));
-      }
-      SplitInput splits;
-      splits.emplace(nodeId, probeSplits);
-      return splits;
-    };
-  };
-
-  // 100 key values in [35, 233] range.
-  std::vector<RowVectorPtr> buildVectors;
-  for (int i = 0; i < 5; ++i) {
-    buildVectors.push_back(makeRowVector({
-        makeFlatVector<int32_t>(
-            numBuildRows / 5,
-            [i](auto row) { return 35 + 2 * (row + i * numBuildRows / 5); }),
-        makeFlatVector<int64_t>(numBuildRows / 5, [](auto row) { return row; }),
-    }));
-  }
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  auto probeType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
-
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-
-  auto buildSide1 = PlanBuilder(planNodeIdGenerator, pool_.get())
-                        .values(buildVectors)
-                        .project({"c0 AS u_c0", "c1 AS u_c1"})
-                        .planNode();
-  auto buildSide2 = PlanBuilder(planNodeIdGenerator, pool_.get())
-                        .values(buildVectors)
-                        .project({"c0 AS u_c0", "c1 AS u_c1"})
-                        .planNode();
-  // Inner join pushdown.
-  core::PlanNodeId probeScanId;
-  core::PlanNodeId joinId1;
-  core::PlanNodeId joinId2;
-  auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
-                .tableScan(probeType)
-                .capturePlanNodeId(probeScanId)
-                .hashJoin(
-                    {"c0"},
-                    {"u_c0"},
-                    buildSide1,
-                    "",
-                    {"c0", "c1"},
-                    core::JoinType::kInner)
-                .capturePlanNodeId(joinId1)
-                .hashJoin(
-                    {"c0"},
-                    {"u_c0"},
-                    buildSide2,
-                    "",
-                    {"c0", "c1", "u_c1"},
-                    core::JoinType::kInner)
-                .capturePlanNodeId(joinId2)
-                .project({"c0", "c1 + 1", "c1 + u_c1"})
-                .planNode();
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(std::move(op))
-      .makeInputSplits(makeInputSplits(probeScanId))
-      .injectSpill(false)
-      .referenceQuery(
-          "SELECT t.c0, t.c1 + 1, t.c1 + u.c1 FROM t, u WHERE t.c0 = u.c0")
-      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-        auto planStats = toPlanStats(task->taskStats());
-        ASSERT_EQ(
-            planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
-            std::unordered_set<core::PlanNodeId>({joinId1, joinId2}));
-      })
-      .run();
-}
-
-TEST_F(HashJoinTest, dynamicFiltersWithSkippedSplits) {
-  const int32_t numSplits = 20;
-  const int32_t numNonSkippedSplits = 10;
-  const int32_t numRowsProbe = 333;
-  const int32_t numRowsBuild = 100;
-
-  std::vector<RowVectorPtr> probeVectors;
-  probeVectors.reserve(numSplits);
-
-  std::vector<std::shared_ptr<TempFilePath>> tempFiles;
-  // Each split has a column containing
-  // the split number. This is used to filter out whole splits based
-  // on metadata. We test how using metadata for dropping splits
-  // interactts with dynamic filters. In specific, if the first split
-  // is discarded based on metadata, the dynamic filters must not be
-  // lost even if there is no actual reader for the split.
-  for (int32_t i = 0; i < numSplits; ++i) {
-    auto rowVector = makeRowVector({
-        makeFlatVector<int32_t>(
-            numRowsProbe, [&](auto row) { return row - i * 10; }),
-        makeFlatVector<int64_t>(numRowsProbe, [](auto row) { return row; }),
-        makeFlatVector<int64_t>(
-            numRowsProbe, [&](auto /*row*/) { return i % 2 == 0 ? 0 : i; }),
-    });
-    probeVectors.push_back(rowVector);
-    tempFiles.push_back(TempFilePath::create());
-    writeToFile(tempFiles.back()->getPath(), rowVector);
-  }
-
-  auto makeInputSplits = [&](const core::PlanNodeId& nodeId) {
-    return [&] {
-      std::vector<exec::Split> probeSplits;
-      for (auto& file : tempFiles) {
-        probeSplits.push_back(
-            exec::Split(makeHiveConnectorSplit(file->getPath())));
-      }
-      // We add splits that have no rows.
-      auto makeEmpty = [&]() {
-        return exec::Split(
-            HiveConnectorSplitBuilder(tempFiles.back()->getPath())
-                .start(10000000)
-                .length(1)
-                .build());
-      };
-      std::vector<exec::Split> emptyFront = {makeEmpty(), makeEmpty()};
-      std::vector<exec::Split> emptyMiddle = {makeEmpty(), makeEmpty()};
-      probeSplits.insert(
-          probeSplits.begin(), emptyFront.begin(), emptyFront.end());
-      probeSplits.insert(
-          probeSplits.begin() + 13, emptyMiddle.begin(), emptyMiddle.end());
-      SplitInput splits;
-      splits.emplace(nodeId, probeSplits);
-      return splits;
-    };
-  };
-
-  // 100 key values in [35, 233] range.
-  std::vector<RowVectorPtr> buildVectors;
-  for (int i = 0; i < 5; ++i) {
-    buildVectors.push_back(makeRowVector({
-        makeFlatVector<int32_t>(
-            numRowsBuild / 5,
-            [i](auto row) { return 35 + 2 * (row + i * numRowsBuild / 5); }),
-        makeFlatVector<int64_t>(numRowsBuild / 5, [](auto row) { return row; }),
-    }));
-  }
-  std::vector<RowVectorPtr> keyOnlyBuildVectors;
-  for (int i = 0; i < 5; ++i) {
-    keyOnlyBuildVectors.push_back(
-        makeRowVector({makeFlatVector<int32_t>(numRowsBuild / 5, [i](auto row) {
-          return 35 + 2 * (row + i * numRowsBuild / 5);
-        })}));
-  }
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  auto probeType = ROW({"c0", "c1", "c2"}, {INTEGER(), BIGINT(), BIGINT()});
-
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-
-  auto buildSide = PlanBuilder(planNodeIdGenerator, pool_.get())
-                       .values(buildVectors)
-                       .project({"c0 AS u_c0", "c1 AS u_c1"})
-                       .planNode();
-  auto keyOnlyBuildSide = PlanBuilder(planNodeIdGenerator, pool_.get())
-                              .values(keyOnlyBuildVectors)
-                              .project({"c0 AS u_c0"})
-                              .planNode();
-
-  // Basic push-down.
-  {
-    // Inner join.
-    core::PlanNodeId probeScanId;
-    auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
-                  .tableScan(probeType, {"c2 > 0"})
-                  .capturePlanNodeId(probeScanId)
-                  .hashJoin(
-                      {"c0"},
-                      {"u_c0"},
-                      buildSide,
-                      "",
-                      {"c0", "c1", "u_c1"},
-                      core::JoinType::kInner)
-                  .project({"c0", "c1 + 1", "c1 + u_c1"})
-                  .planNode();
-    {
-      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-          .planNode(std::move(op))
-          .numDrivers(1)
-          .makeInputSplits(makeInputSplits(probeScanId))
-          .referenceQuery(
-              "SELECT t.c0, t.c1 + 1, t.c1 + u.c1 FROM t, u WHERE t.c0 = u.c0 AND t.c2 > 0")
-          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
-            if (hasSpill) {
-              // Dynamic filtering should be disabled with spilling triggered.
-              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
-              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
-              ASSERT_EQ(
-                  getInputPositions(task, 1),
-                  numRowsProbe * numNonSkippedSplits);
-            } else {
-              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
-              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
-              ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
-              ASSERT_LT(
-                  getInputPositions(task, 1),
-                  numRowsProbe * numNonSkippedSplits);
-            }
-          })
-          .run();
-    }
-
-    // Left semi join.
-    op = PlanBuilder(planNodeIdGenerator, pool_.get())
-             .tableScan(probeType, {"c2 > 0"})
-             .capturePlanNodeId(probeScanId)
-             .hashJoin(
-                 {"c0"},
-                 {"u_c0"},
-                 buildSide,
-                 "",
-                 {"c0", "c1"},
-                 core::JoinType::kLeftSemiFilter)
-             .project({"c0", "c1 + 1"})
-             .planNode();
-
-    {
-      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-          .planNode(std::move(op))
-          .numDrivers(1)
-          .makeInputSplits(makeInputSplits(probeScanId))
-          .referenceQuery(
-              "SELECT t.c0, t.c1 + 1 FROM t WHERE t.c0 IN (SELECT c0 FROM u) AND t.c2 > 0")
-          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
-            if (hasSpill) {
-              // Dynamic filtering should be disabled with spilling triggered.
-              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
-              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
-              ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
-              ASSERT_EQ(
-                  getInputPositions(task, 1),
-                  numRowsProbe * numNonSkippedSplits);
-            } else {
-              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
-              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
-              ASSERT_GT(getReplacedWithFilterRows(task, 1).sum, 0);
-              ASSERT_LT(
-                  getInputPositions(task, 1),
-                  numRowsProbe * numNonSkippedSplits);
-            }
-          })
-          .run();
-    }
-
-    // Right semi join.
-    op = PlanBuilder(planNodeIdGenerator, pool_.get())
-             .tableScan(probeType, {"c2 > 0"})
-             .capturePlanNodeId(probeScanId)
-             .hashJoin(
-                 {"c0"},
-                 {"u_c0"},
-                 buildSide,
-                 "",
-                 {"u_c0", "u_c1"},
-                 core::JoinType::kRightSemiFilter)
-             .project({"u_c0", "u_c1 + 1"})
-             .planNode();
-
-    {
-      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-          .planNode(std::move(op))
-          .numDrivers(1)
-          .makeInputSplits(makeInputSplits(probeScanId))
-          .referenceQuery(
-              "SELECT u.c0, u.c1 + 1 FROM u WHERE u.c0 IN (SELECT c0 FROM t WHERE t.c2 > 0)")
-          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
-            if (hasSpill) {
-              // Dynamic filtering should be disabled with spilling triggered.
-              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
-              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
-              ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
-              ASSERT_EQ(
-                  getInputPositions(task, 1),
-                  numRowsProbe * numNonSkippedSplits);
-            } else {
-              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
-              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
-              ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
-              ASSERT_LT(
-                  getInputPositions(task, 1),
-                  numRowsProbe * numNonSkippedSplits);
-            }
-          })
-          .run();
-    }
-  }
-}
-
-TEST_F(HashJoinTest, dynamicFiltersAppliedToPreloadedSplits) {
-  vector_size_t size = 1000;
-  const int32_t numSplits = 5;
-
-  std::vector<RowVectorPtr> probeVectors;
-  probeVectors.reserve(numSplits);
-
-  // Prepare probe side table.
-  std::vector<std::shared_ptr<TempFilePath>> tempFiles;
-  std::vector<exec::Split> probeSplits;
-  for (int32_t i = 0; i < numSplits; ++i) {
-    auto rowVector = makeRowVector(
-        {"p0", "p1"},
-        {
-            makeFlatVector<int64_t>(
-                size, [&](auto row) { return (row + 1) * (i + 1); }),
-            makeFlatVector<int64_t>(size, [&](auto /*row*/) { return i; }),
-        });
-    probeVectors.push_back(rowVector);
-    tempFiles.push_back(TempFilePath::create());
-    writeToFile(tempFiles.back()->getPath(), rowVector);
-    auto split = HiveConnectorSplitBuilder(tempFiles.back()->getPath())
-                     .partitionKey("p1", std::to_string(i))
-                     .build();
-    probeSplits.push_back(exec::Split(split));
-  }
-
-  auto outputType = ROW({"p0", "p1"}, {BIGINT(), BIGINT()});
-  connector::ColumnHandleMap assignments = {
-      {"p0", regularColumn("p0", BIGINT())},
-      {"p1", partitionKey("p1", BIGINT())}};
-  createDuckDbTable("p", probeVectors);
-
-  // Prepare build side table.
-  std::vector<RowVectorPtr> buildVectors{
-      makeRowVector({"b0"}, {makeFlatVector<int64_t>({0, numSplits})})};
-  createDuckDbTable("b", buildVectors);
-
-  // Executing the join with p1=b0, we expect a dynamic filter for p1 to prune
-  // the entire file/split. There are total of five splits, and all except the
-  // first one are expected to be pruned. The result 'preloadedSplits' > 1
-  // confirms the successful push of dynamic filters to the preloading data
-  // source.
-  core::PlanNodeId probeScanId;
-  core::PlanNodeId joinNodeId;
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto op =
-      PlanBuilder(planNodeIdGenerator)
-          .startTableScan()
-          .outputType(outputType)
-          .assignments(assignments)
-          .endTableScan()
-          .capturePlanNodeId(probeScanId)
-          .hashJoin(
-              {"p1"},
-              {"b0"},
-              PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode(),
-              "",
-              {"p0"},
-              core::JoinType::kInner)
-          .capturePlanNodeId(joinNodeId)
-          .project({"p0"})
-          .planNode();
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(std::move(op))
-      .config(core::QueryConfig::kMaxSplitPreloadPerDriver, "3")
-      .injectSpill(false)
-      .inputSplits({{probeScanId, probeSplits}})
-      .referenceQuery("select p.p0 from p, b where b.b0 = p.p1")
-      .checkSpillStats(false)
-      .verifier([&](const std::shared_ptr<Task>& task, bool /*hasSpill*/) {
-        auto planStats = toPlanStats(task->taskStats());
-        auto getStatSum = [&](const core::PlanNodeId& id,
-                              const std::string& name) {
-          return planStats.at(id).customStats.at(name).sum;
-        };
-        ASSERT_EQ(1, getStatSum(joinNodeId, "dynamicFiltersProduced"));
-        ASSERT_EQ(1, getStatSum(probeScanId, "dynamicFiltersAccepted"));
-        ASSERT_EQ(4, getStatSum(probeScanId, "skippedSplits"));
-        ASSERT_LT(1, getStatSum(probeScanId, "preloadedSplits"));
-      })
-      .run();
-}
-
-TEST_F(HashJoinTest, dynamicFiltersPushDownThroughAgg) {
-  const int32_t numRowsProbe = 300;
-  const int32_t numRowsBuild = 100;
-
-  // Create probe data
-  std::vector<RowVectorPtr> probeVectors{makeRowVector({
-      makeFlatVector<int32_t>(numRowsProbe, [&](auto row) { return row - 10; }),
-      makeFlatVector<int64_t>(numRowsProbe, folly::identity),
-  })};
-  std::shared_ptr<TempFilePath> probeFile = TempFilePath::create();
-  writeToFile(probeFile->getPath(), probeVectors);
-
-  // Create build data
-  std::vector<RowVectorPtr> buildVectors{makeRowVector(
-      {"u0"}, {makeFlatVector<int32_t>(numRowsBuild, [&](auto row) {
-        return 35 + 2 * (row + numRowsBuild / 5);
-      })})};
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  auto probeType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto buildSide =
-      PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode();
-
-  // Inner join.
-  core::PlanNodeId scanNodeId;
-  core::PlanNodeId joinNodeId;
-  core::PlanNodeId aggNodeId;
-  auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
-                .tableScan(probeType)
-                .capturePlanNodeId(scanNodeId)
-                .partialAggregation({"c0"}, {"sum(c1)"})
-                .capturePlanNodeId(aggNodeId)
-                .hashJoin(
-                    {"c0"},
-                    {"u0"},
-                    buildSide,
-                    "",
-                    {"c0", "a0"},
-                    core::JoinType::kInner)
-                .capturePlanNodeId(joinNodeId)
-                .planNode();
-
-  SplitInput splitInput = {
-      {scanNodeId, {Split(makeHiveConnectorSplit(probeFile->getPath()))}}};
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(std::move(op))
-      .inputSplits(splitInput)
-      .injectSpill(false)
-      .checkSpillStats(false)
-      .referenceQuery("SELECT c0, sum(c1) FROM t, u WHERE c0 = u0 group by c0")
-      .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-        auto planStats = toPlanStats(task->taskStats());
-        auto dynamicFilterStats = planStats.at(scanNodeId).dynamicFilterStats;
-        ASSERT_EQ(
-            1, getFiltersProduced(task, getOperatorIndex(joinNodeId)).sum);
-        ASSERT_EQ(
-            1, getFiltersAccepted(task, getOperatorIndex(scanNodeId)).sum);
-        ASSERT_LT(
-            getInputPositions(task, getOperatorIndex(aggNodeId)), numRowsProbe);
-        ASSERT_EQ(
-            dynamicFilterStats.producerNodeIds,
-            std::unordered_set({joinNodeId}));
-      })
-      .run();
-}
-
-TEST_F(HashJoinTest, noDynamicFiltersPushDownThroughRightJoin) {
-  std::vector<RowVectorPtr> innerBuild = {makeRowVector(
-      {"a"},
-      {
-          makeFlatVector<int64_t>(5, [](auto i) { return 2 * i; }),
-      })};
-  std::vector<RowVectorPtr> rightBuild = {makeRowVector(
-      {"b"},
-      {
-          makeFlatVector<int64_t>(5, [](auto i) { return 1 + 2 * i; }),
-      })};
-  std::vector<RowVectorPtr> rightProbe = {makeRowVector(
-      {"aa", "bb"},
-      {
-          makeFlatVector<int64_t>(10, folly::identity),
-          makeFlatVector<int64_t>(10, folly::identity),
-      })};
-  auto file = TempFilePath::create();
-  writeToFile(file->getPath(), rightProbe);
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  core::PlanNodeId scanNodeId;
-  auto plan =
-      PlanBuilder(planNodeIdGenerator)
-          .tableScan(asRowType(rightProbe[0]->type()))
-          .capturePlanNodeId(scanNodeId)
-          .hashJoin(
-              {"bb"},
-              {"b"},
-              PlanBuilder(planNodeIdGenerator).values(rightBuild).planNode(),
-              "",
-              {"aa", "b"},
-              core::JoinType::kRight)
-          .hashJoin(
-              {"aa"},
-              {"a"},
-              PlanBuilder(planNodeIdGenerator).values(innerBuild).planNode(),
-              "",
-              {"aa"})
-          .planNode();
-  AssertQueryBuilder(plan)
-      .split(scanNodeId, Split(makeHiveConnectorSplit(file->getPath())))
-      .assertResults(
-          BaseVector::create<RowVector>(innerBuild[0]->type(), 0, pool_.get()));
-}
-
-// Verify the size of the join output vectors when projecting build-side
-// variable-width column.
-TEST_F(HashJoinTest, memoryUsage) {
-  std::vector<RowVectorPtr> probeVectors =
-      makeBatches(10, [&](int32_t /*unused*/) {
-        return makeRowVector(
-            {makeFlatVector<int32_t>(1'000, [](auto row) { return row % 5; })});
-      });
-  std::vector<RowVectorPtr> buildVectors =
-      makeBatches(5, [&](int32_t /*unused*/) {
-        return makeRowVector(
-            {"u_c0", "u_c1"},
-            {makeFlatVector<int32_t>({0, 1, 2}),
-             makeFlatVector<std::string>({
-                 std::string(40, 'a'),
-                 std::string(50, 'b'),
-                 std::string(30, 'c'),
-             })});
-      });
-  core::PlanNodeId joinNodeId;
-
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto plan = PlanBuilder(planNodeIdGenerator)
-                  .values(probeVectors)
-                  .hashJoin(
-                      {"c0"},
-                      {"u_c0"},
-                      PlanBuilder(planNodeIdGenerator)
-                          .values({buildVectors})
-                          .planNode(),
-                      "",
-                      {"c0", "u_c1"})
-                  .capturePlanNodeId(joinNodeId)
-                  .singleAggregation({}, {"count(1)"})
-                  .planNode();
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(std::move(plan))
-      .referenceQuery("SELECT 30000")
-      .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-        if (hasSpill) {
-          return;
-        }
-        auto planStats = toPlanStats(task->taskStats());
-        auto outputBytes = planStats.at(joinNodeId).outputBytes;
-        ASSERT_LT(outputBytes, ((40 + 50 + 30) / 3 + 8) * 1000 * 10 * 5);
-        // Verify number of memory allocations. Should not be too high if
-        // hash join is able to re-use output vectors that contain
-        // build-side data.
-        ASSERT_GT(40, task->pool()->stats().numAllocs);
-      })
-      .run();
-}
-
-/// Test an edge case in producing small output batches where the logic to
-/// calculate the set of probe-side rows to load lazy vectors for was
-/// triggering a crash.
-TEST_F(HashJoinTest, smallOutputBatchSize) {
-  // Setup probe data with 50 non-null matching keys followed by 50 null
-  // keys: 1, 2, 1, 2,...null, null.
-  auto probeVectors = makeRowVector({
-      makeFlatVector<int32_t>(
-          100,
-          [](auto row) { return 1 + row % 2; },
-          [](auto row) { return row > 50; }),
-      makeFlatVector<int32_t>(100, [](auto row) { return row * 10; }),
-  });
-
-  // Setup build side to match non-null probe side keys.
-  auto buildVectors = makeRowVector(
-      {"u_c0", "u_c1"},
-      {
-          makeFlatVector<int32_t>({1, 2}),
-          makeFlatVector<int32_t>({100, 200}),
-      });
-
-  createDuckDbTable("t", {probeVectors});
-  createDuckDbTable("u", {buildVectors});
-
-  // Plan hash inner join with a filter.
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto plan = PlanBuilder(planNodeIdGenerator)
-                  .values({probeVectors})
-                  .hashJoin(
-                      {"c0"},
-                      {"u_c0"},
-                      PlanBuilder(planNodeIdGenerator)
-                          .values({buildVectors})
-                          .planNode(),
-                      "c1 < u_c1",
-                      {"c0", "u_c1"})
-                  .planNode();
-
-  // Use small output batch size to trigger logic for calculating set of
-  // probe-side rows to load lazy vectors for.
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(std::move(plan))
-      .config(core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
-      .referenceQuery("SELECT c0, u_c1 FROM t, u WHERE c0 = u_c0 AND c1 < u_c1")
-      .injectSpill(false)
-      .run();
-}
-
-TEST_F(HashJoinTest, spillFileSize) {
-  const std::vector<uint64_t> maxSpillFileSizes({0, 1, 1'000'000'000});
-  for (const auto spillFileSize : maxSpillFileSizes) {
-    SCOPED_TRACE(fmt::format("spillFileSize: {}", spillFileSize));
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .numDrivers(numDrivers_)
-        .keyTypes({BIGINT()})
-        .probeVectors(100, 3)
-        .buildVectors(100, 3)
-        .referenceQuery(
-            "SELECT t_k0, t_data, u_k0, u_data FROM t, u WHERE t.t_k0 = u.u_k0")
-        .config(core::QueryConfig::kSpillStartPartitionBit, "48")
-        .config(core::QueryConfig::kSpillNumPartitionBits, "3")
-        .config(
-            core::QueryConfig::kMaxSpillFileSize, std::to_string(spillFileSize))
-        .checkSpillStats(false)
-        .maxSpillLevel(0)
-        .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-          if (!hasSpill) {
-            return;
-          }
-          const auto statsPair = taskSpilledStats(*task);
-          const int32_t numPartitions = statsPair.first.spilledPartitions;
-          ASSERT_EQ(statsPair.second.spilledPartitions, numPartitions);
-          const auto fileSizes = numTaskSpillFiles(*task);
-          if (spillFileSize != 1) {
-            ASSERT_EQ(fileSizes.first, numPartitions);
-          } else {
-            ASSERT_GT(fileSizes.first, numPartitions);
-          }
-          verifyTaskSpilledRuntimeStats(*task, true);
-        })
-        .run();
-  }
-}
-
-TEST_F(HashJoinTest, spillPartitionBitsOverlap) {
-  auto builder =
-      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-          .numDrivers(numDrivers_)
-          .keyTypes({BIGINT(), BIGINT()})
-          .probeVectors(2'000, 3)
-          .buildVectors(2'000, 3)
-          .referenceQuery(
-              "SELECT t_k0, t_k1, t_data, u_k0, u_k1, u_data FROM t, u WHERE t_k0 = u_k0 and t_k1 = u_k1")
-          .config(core::QueryConfig::kSpillStartPartitionBit, "8")
-          .config(core::QueryConfig::kSpillNumPartitionBits, "1")
-          .checkSpillStats(false)
-          .maxSpillLevel(0);
-  VELOX_ASSERT_THROW(builder.run(), "vs. 8");
-}
-
-// The test is to verify if the hash build reservation has been released on
-// task error.
-DEBUG_ONLY_TEST_F(HashJoinTest, buildReservationReleaseCheck) {
-  std::vector<RowVectorPtr> probeVectors =
-      makeBatches(1, [&](int32_t /*unused*/) {
-        return std::dynamic_pointer_cast<RowVector>(
-            BatchMaker::createBatch(probeType_, 1000, *pool_));
-      });
-  std::vector<RowVectorPtr> buildVectors = makeBatches(10, [&](int32_t index) {
-    return std::dynamic_pointer_cast<RowVector>(
-        BatchMaker::createBatch(buildType_, 5000 * (1 + index), *pool_));
-  });
-
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  CursorParameters params;
-  params.planNode = PlanBuilder(planNodeIdGenerator)
-                        .values(probeVectors, true)
-                        .hashJoin(
-                            {"t_k1"},
-                            {"u_k1"},
-                            PlanBuilder(planNodeIdGenerator)
-                                .values(buildVectors, true)
-                                .planNode(),
-                            "",
-                            concat(probeType_->names(), buildType_->names()))
-                        .planNode();
-  params.queryCtx = core::QueryCtx::create(driverExecutor_.get());
-  // NOTE: the spilling setup is to trigger memory reservation code path which
-  // only gets executed when spilling is enabled. We don't care about if
-  // spilling is really triggered in test or not.
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
-  params.spillDirectory = spillDirectory->getPath();
-  params.queryCtx->testingOverrideConfigUnsafe(
-      {{core::QueryConfig::kSpillEnabled, "true"},
-       {core::QueryConfig::kMaxSpillLevel, "0"}});
-  params.maxDrivers = 1;
-
-  auto cursor = TaskCursor::create(params);
-  auto* task = cursor->task().get();
-
-  // Set up a testvalue to trigger task abort when hash build tries to reserve
-  // memory.
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve",
-      std::function<void(memory::MemoryPool*)>(
-          [&](memory::MemoryPool* /*unused*/) { task->requestAbort(); }));
-  auto runTask = [&]() {
-    while (cursor->moveNext()) {
-    }
-  };
-  VELOX_ASSERT_THROW(runTask(), "");
-  ASSERT_TRUE(waitForTaskAborted(task, 5'000'000));
-}
-
-TEST_F(HashJoinTest, dynamicFilterOnPartitionKey) {
-  vector_size_t size = 10;
-  auto filePaths = makeFilePaths(1);
-  auto rowVector = makeRowVector(
-      {makeFlatVector<int64_t>(size, [&](auto row) { return row; })});
-  createDuckDbTable("u", {rowVector});
-  writeToFile(filePaths[0]->getPath(), rowVector);
-  std::vector<RowVectorPtr> buildVectors{
-      makeRowVector({"c0"}, {makeFlatVector<int64_t>({0, 1, 2})})};
-  createDuckDbTable("t", buildVectors);
-  auto split = facebook::velox::exec::test::HiveConnectorSplitBuilder(
-                   filePaths[0]->getPath())
-                   .partitionKey("k", "0")
-                   .build();
-  auto outputType = ROW({"n1_0", "n1_1"}, {BIGINT(), BIGINT()});
-  connector::ColumnHandleMap assignments = {
-      {"n1_0", regularColumn("c0", BIGINT())},
-      {"n1_1", partitionKey("k", BIGINT())}};
-
-  core::PlanNodeId probeScanId;
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto op =
-      PlanBuilder(planNodeIdGenerator)
-          .startTableScan()
-          .outputType(outputType)
-          .assignments(assignments)
-          .endTableScan()
-          .capturePlanNodeId(probeScanId)
-          .hashJoin(
-              {"n1_1"},
-              {"c0"},
-              PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode(),
-              "",
-              {"c0"},
-              core::JoinType::kInner)
-          .project({"c0"})
-          .planNode();
-  SplitInput splits = {{probeScanId, {exec::Split(split)}}};
-
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(std::move(op))
-      .inputSplits(splits)
-      .referenceQuery("select t.c0 from t, u where t.c0 = 0")
-      .checkSpillStats(false)
-      .run();
-}
-
-TEST_F(HashJoinTest, probeMemoryLimitOnBuildProjection) {
-  const uint64_t numBuildRows = 20;
-  std::vector<RowVectorPtr> probeVectors =
-      makeBatches(10, [&](int32_t /*unused*/) {
-        return makeRowVector({makeFlatVector<int32_t>(
-            1'000, [](auto row) { return row % 25; })});
-      });
-
-  std::vector<RowVectorPtr> buildVectors =
-      makeBatches(1, [&](int32_t /*unused*/) {
-        return makeRowVector(
-            {"u_c0", "u_c1", "u_c2", "u_c3", "u_c4"},
-            {makeFlatVector<int32_t>(
-                 numBuildRows, [](auto row) { return row; }),
-             makeFlatVector<std::string>(
-                 numBuildRows,
-                 [](auto /* row */) { return std::string(4096, 'a'); }),
-             makeFlatVector<std::string>(
-                 numBuildRows,
-                 [](auto /* row */) { return std::string(4096, 'a'); }),
-             makeFlatVector<std::string>(
-                 numBuildRows,
-                 [](auto row) {
-                   // Row that has too large of size variation.
-                   if (row == 0) {
-                     return std::string(4096, 'a');
-                   } else {
-                     return std::string(1, 'a');
-                   }
-                 }),
-             makeFlatVector<std::string>(numBuildRows, [](auto row) {
-               // Row that has tolerable size variation.
-               if (row == 0) {
-                 return std::string(4096, 'a');
-               } else {
-                 return std::string(256, 'a');
-               }
-             })});
-      });
-
-  createDuckDbTable("t", {probeVectors});
-  createDuckDbTable("u", {buildVectors});
-
-  struct TestParam {
-    std::vector<int32_t> varSizeColumns;
-    int32_t numExpectedBatches;
-    std::string referenceQuery;
-    std::string debugString() const {
-      std::stringstream ss;
-      ss << "varSizeColumns [";
-      for (const auto& columnIndex : varSizeColumns) {
-        ss << columnIndex << ", ";
-      }
-      ss << "] ";
-      ss << "numExpectedBatches " << numExpectedBatches << ", referenceQuery '"
-         << referenceQuery << "'";
-      return ss.str();
-    }
-  };
-
-  std::vector<TestParam> testParams{
-      {{}, 10, "SELECT t.c0 FROM t JOIN u ON t.c0 = u.u_c0"},
-      {{1}, 4000, "SELECT t.c0, u.u_c1 FROM t JOIN u ON t.c0 = u.u_c0"},
-      {{1, 2},
-       8000,
-       "SELECT t.c0, u.u_c1, u.u_c2 FROM t JOIN u ON t.c0 = u.u_c0"},
-      {{3}, 210, "SELECT t.c0, u.u_c3 FROM t JOIN u ON t.c0 = u.u_c0"},
-      {{4}, 2670, "SELECT t.c0, u.u_c4 FROM t JOIN u ON t.c0 = u.u_c0"}};
-
-  for (const auto& testParam : testParams) {
-    SCOPED_TRACE(testParam.debugString());
-    core::PlanNodeId joinNodeId;
-    std::vector<std::string> outputLayout;
-    outputLayout.push_back("c0");
-    for (int32_t i = 0; i < testParam.varSizeColumns.size(); i++) {
-      outputLayout.push_back(fmt::format("u_c{}", testParam.varSizeColumns[i]));
-    }
-    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-    auto plan = PlanBuilder(planNodeIdGenerator)
-                    .values(probeVectors)
-                    .hashJoin(
-                        {"c0"},
-                        {"u_c0"},
-                        PlanBuilder(planNodeIdGenerator)
-                            .values({buildVectors})
-                            .planNode(),
-                        "",
-                        outputLayout)
-                    .capturePlanNodeId(joinNodeId)
-                    .planNode();
-
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .planNode(std::move(plan))
-        .config(core::QueryConfig::kPreferredOutputBatchBytes, "8192")
-        .injectSpill(false)
-        .referenceQuery(testParam.referenceQuery)
-        .verifier([&](const std::shared_ptr<Task>& task, bool /* unused */) {
-          auto planStats = toPlanStats(task->taskStats());
-          auto outputBatches = planStats.at(joinNodeId).outputVectors;
-          ASSERT_EQ(outputBatches, testParam.numExpectedBatches);
-        })
-        .run();
-  }
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringInputProcessing) {
-  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
-  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
-  const int32_t numBuildVectors = 10;
-  std::vector<RowVectorPtr> buildVectors;
-  for (int32_t i = 0; i < numBuildVectors; ++i) {
-    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
-  }
-  const int32_t numProbeVectors = 5;
-  std::vector<RowVectorPtr> probeVectors;
-  for (int32_t i = 0; i < numProbeVectors; ++i) {
-    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
-  }
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  struct {
-    // 0: trigger reclaim with some input processed.
-    // 1: trigger reclaim after all the inputs processed.
-    int triggerCondition;
-    bool spillEnabled;
-    bool expectedReclaimable;
-
-    std::string debugString() const {
-      return fmt::format(
-          "triggerCondition {}, spillEnabled {}, expectedReclaimable {}",
-          triggerCondition,
-          spillEnabled,
-          expectedReclaimable);
-    }
-  } testSettings[] = {
-      {0, true, true}, {0, true, true}, {0, false, false}, {0, false, false}};
-  for (const auto& testData : testSettings) {
-    SCOPED_TRACE(testData.debugString());
-
-    auto tempDirectory = exec::test::TempDirectoryPath::create();
-    auto queryPool = memory::memoryManager()->addRootPool(
-        "", kMaxBytes, memory::MemoryReclaimer::create());
-
-    core::PlanNodeId probeScanId;
-    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-    auto plan = PlanBuilder(planNodeIdGenerator)
-                    .values(probeVectors, false)
-                    .hashJoin(
-                        {"t_k1"},
-                        {"u_k1"},
-                        PlanBuilder(planNodeIdGenerator)
-                            .values(buildVectors, false)
-                            .planNode(),
-                        "",
-                        concat(probeType_->names(), buildType_->names()))
-                    .planNode();
-
-    folly::EventCount driverWait;
-    auto driverWaitKey = driverWait.prepareWait();
-    folly::EventCount testWait;
-    auto testWaitKey = testWait.prepareWait();
-
-    std::atomic<int> numInputs{0};
-    Operator* op;
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Driver::runInternal::addInput",
-        std::function<void(Operator*)>(([&](Operator* testOp) {
-          if (testOp->operatorType() != "HashBuild") {
-            return;
-          }
-          op = testOp;
-          ++numInputs;
-          if (testData.triggerCondition == 0) {
-            if (numInputs != 2) {
-              return;
-            }
-          }
-          if (testData.triggerCondition == 1) {
-            if (numInputs != numBuildVectors) {
-              return;
-            }
-          }
-          ASSERT_EQ(op->canReclaim(), testData.expectedReclaimable);
-          uint64_t reclaimableBytes{0};
-          const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
-          ASSERT_EQ(reclaimable, testData.expectedReclaimable);
-          if (testData.expectedReclaimable) {
-            ASSERT_GT(reclaimableBytes, 0);
-          } else {
-            ASSERT_EQ(reclaimableBytes, 0);
-          }
-          testWait.notify();
-          driverWait.wait(driverWaitKey);
-        })));
-
-    std::thread taskThread([&]() {
-      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-          .numDrivers(numDrivers_)
-          .planNode(plan)
-          .queryPool(std::move(queryPool))
-          .injectSpill(false)
-          .spillDirectory(testData.spillEnabled ? tempDirectory->getPath() : "")
-          .referenceQuery(
-              "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
-          .config(core::QueryConfig::kSpillStartPartitionBit, "29")
-          .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-            const auto statsPair = taskSpilledStats(*task);
-            if (testData.expectedReclaimable) {
-              ASSERT_GT(statsPair.first.spilledBytes, 0);
-              ASSERT_EQ(statsPair.first.spilledPartitions, 8);
-              ASSERT_GT(statsPair.second.spilledBytes, 0);
-              ASSERT_EQ(statsPair.second.spilledPartitions, 8);
-              verifyTaskSpilledRuntimeStats(*task, true);
-            } else {
-              ASSERT_EQ(statsPair.first.spilledBytes, 0);
-              ASSERT_EQ(statsPair.first.spilledPartitions, 0);
-              ASSERT_EQ(statsPair.second.spilledBytes, 0);
-              ASSERT_EQ(statsPair.second.spilledPartitions, 0);
-              verifyTaskSpilledRuntimeStats(*task, false);
-            }
-          })
-          .run();
-    });
-
-    testWait.wait(testWaitKey);
-    ASSERT_TRUE(op != nullptr);
-    auto task = op->operatorCtx()->task();
-    auto taskPauseWait = task->requestPause();
-    driverWait.notify();
-    taskPauseWait.wait();
-
-    uint64_t reclaimableBytes{0};
-    const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
-    ASSERT_EQ(op->canReclaim(), testData.expectedReclaimable);
-    ASSERT_EQ(reclaimable, testData.expectedReclaimable);
-    if (testData.expectedReclaimable) {
-      ASSERT_GT(reclaimableBytes, 0);
-    } else {
-      ASSERT_EQ(reclaimableBytes, 0);
-    }
-
-    if (testData.expectedReclaimable) {
-      {
-        memory::ScopedMemoryArbitrationContext ctx(op->pool());
-        op->pool()->reclaim(
-            folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
-            0,
-            reclaimerStats_);
-      }
-      ASSERT_GT(reclaimerStats_.reclaimExecTimeUs, 0);
-      ASSERT_GT(reclaimerStats_.reclaimedBytes, 0);
-      reclaimerStats_.reset();
-      ASSERT_EQ(op->pool()->usedBytes(), 0);
-    } else {
-      VELOX_ASSERT_THROW(
-          op->reclaim(
-              folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
-              reclaimerStats_),
-          "");
-    }
-
-    Task::resume(task);
-    task.reset();
-
-    taskThread.join();
-  }
-  ASSERT_EQ(reclaimerStats_, memory::MemoryReclaimer::Stats{});
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringReserve) {
-  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
-  const int32_t numBuildVectors = 3;
-  std::vector<RowVectorPtr> buildVectors;
-  for (int32_t i = 0; i < numBuildVectors; ++i) {
-    const size_t size = i == 0 ? 1 : 1'000;
-    VectorFuzzer fuzzer({.vectorSize = size}, pool());
-    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
-  }
-
-  const int32_t numProbeVectors = 3;
-  std::vector<RowVectorPtr> probeVectors;
-  for (int32_t i = 0; i < numProbeVectors; ++i) {
-    VectorFuzzer fuzzer({.vectorSize = 1'000}, pool());
-    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
-  }
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
-  auto queryPool = memory::memoryManager()->addRootPool(
-      "", kMaxBytes, memory::MemoryReclaimer::create());
-
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto plan = PlanBuilder(planNodeIdGenerator)
-                  .values(probeVectors, false)
-                  .hashJoin(
-                      {"t_k1"},
-                      {"u_k1"},
-                      PlanBuilder(planNodeIdGenerator)
-                          .values(buildVectors, false)
-                          .planNode(),
-                      "",
-                      concat(probeType_->names(), buildType_->names()))
-                  .planNode();
-
-  folly::EventCount driverWait;
-  std::atomic_bool driverWaitFlag{true};
-  folly::EventCount testWait;
-  std::atomic_bool testWaitFlag{true};
-
-  Operator* op{nullptr};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Driver::runInternal::addInput",
-      std::function<void(Operator*)>(([&](Operator* testOp) {
-        if (testOp->operatorType() != "HashBuild") {
-          return;
-        }
-        op = testOp;
-      })));
-
-  std::atomic<bool> injectOnce{true};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve",
-      std::function<void(memory::MemoryPoolImpl*)>(
-          ([&](memory::MemoryPoolImpl* pool) {
-            ASSERT_TRUE(op != nullptr);
-            if (!isHashBuildMemoryPool(*pool)) {
-              return;
-            }
-            ASSERT_TRUE(op->canReclaim());
-            if (op->pool()->usedBytes() == 0) {
-              // We skip trigger memory reclaim when the hash table is empty on
-              // memory reservation.
-              return;
-            }
-            if (!injectOnce.exchange(false)) {
-              return;
-            }
-            uint64_t reclaimableBytes{0};
-            const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
-            ASSERT_TRUE(reclaimable);
-            ASSERT_GT(reclaimableBytes, 0);
-            auto* driver = op->operatorCtx()->driver();
-            TestSuspendedSection suspendedSection(driver);
-            testWaitFlag = false;
-            testWait.notifyAll();
-            driverWait.await([&]() { return !driverWaitFlag.load(); });
-          })));
-
-  std::thread taskThread([&]() {
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .numDrivers(numDrivers_)
-        .planNode(plan)
-        .queryPool(std::move(queryPool))
-        .injectSpill(false)
-        .spillDirectory(tempDirectory->getPath())
-        .referenceQuery(
-            "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
-        .config(core::QueryConfig::kSpillStartPartitionBit, "29")
-        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-          const auto statsPair = taskSpilledStats(*task);
-          ASSERT_GT(statsPair.first.spilledBytes, 0);
-          ASSERT_EQ(statsPair.first.spilledPartitions, 8);
-          ASSERT_GT(statsPair.second.spilledBytes, 0);
-          ASSERT_EQ(statsPair.second.spilledPartitions, 8);
-          verifyTaskSpilledRuntimeStats(*task, true);
-        })
-        .run();
-  });
-
-  testWait.await([&]() { return !testWaitFlag.load(); });
-  ASSERT_TRUE(op != nullptr);
-  auto task = op->operatorCtx()->task();
-  task->requestPause().wait();
-
-  uint64_t reclaimableBytes{0};
-  const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
-  ASSERT_TRUE(op->canReclaim());
-  ASSERT_TRUE(reclaimable);
-  ASSERT_GT(reclaimableBytes, 0);
-
-  {
-    memory::ScopedMemoryArbitrationContext ctx(op->pool());
-    uint64_t reclaimedBytes = task->pool()->reclaim(
-        folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
-        0,
-        reclaimerStats_);
-    ASSERT_GT(reclaimedBytes, 0);
-  }
-  ASSERT_GT(reclaimerStats_.reclaimedBytes, 0);
-  ASSERT_GT(reclaimerStats_.reclaimExecTimeUs, 0);
-  ASSERT_EQ(op->pool()->usedBytes(), 0);
-
-  driverWaitFlag = false;
-  driverWait.notifyAll();
-  Task::resume(task);
-  task.reset();
-
-  taskThread.join();
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringAllocation) {
-  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
-  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
-  const int32_t numBuildVectors = 10;
-  std::vector<RowVectorPtr> buildVectors;
-  for (int32_t i = 0; i < numBuildVectors; ++i) {
-    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
-  }
-  const int32_t numProbeVectors = 5;
-  std::vector<RowVectorPtr> probeVectors;
-  for (int32_t i = 0; i < numProbeVectors; ++i) {
-    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
-  }
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  const std::vector<bool> enableSpillings = {false, true};
-  for (const auto enableSpilling : enableSpillings) {
-    SCOPED_TRACE(fmt::format("enableSpilling {}", enableSpilling));
-
-    auto tempDirectory = exec::test::TempDirectoryPath::create();
-    auto queryPool = memory::memoryManager()->addRootPool("", kMaxBytes);
-
-    core::PlanNodeId probeScanId;
-    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-    auto plan = PlanBuilder(planNodeIdGenerator)
-                    .values(probeVectors, false)
-                    .hashJoin(
-                        {"t_k1"},
-                        {"u_k1"},
-                        PlanBuilder(planNodeIdGenerator)
-                            .values(buildVectors, false)
-                            .planNode(),
-                        "",
-                        concat(probeType_->names(), buildType_->names()))
-                    .planNode();
-
-    folly::EventCount driverWait;
-    auto driverWaitKey = driverWait.prepareWait();
-    folly::EventCount testWait;
-    auto testWaitKey = testWait.prepareWait();
-
-    Operator* op;
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Driver::runInternal::addInput",
-        std::function<void(Operator*)>(([&](Operator* testOp) {
-          if (testOp->operatorType() != "HashBuild") {
-            return;
-          }
-          op = testOp;
-        })));
-
-    std::atomic<bool> injectOnce{true};
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::common::memory::MemoryPoolImpl::allocateNonContiguous",
-        std::function<void(memory::MemoryPoolImpl*)>(
-            ([&](memory::MemoryPoolImpl* pool) {
-              ASSERT_TRUE(op != nullptr);
-              const std::string re(".*HashBuild");
-              if (!RE2::FullMatch(pool->name(), re)) {
-                return;
-              }
-              if (!injectOnce.exchange(false)) {
-                return;
-              }
-              ASSERT_EQ(op->canReclaim(), enableSpilling);
-              uint64_t reclaimableBytes{0};
-              const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
-              ASSERT_EQ(reclaimable, enableSpilling);
-              if (enableSpilling) {
-                ASSERT_GE(reclaimableBytes, 0);
-              } else {
-                ASSERT_EQ(reclaimableBytes, 0);
-              }
-              auto* driver = op->operatorCtx()->driver();
-              TestSuspendedSection suspendedSection(driver);
-              testWait.notify();
-              driverWait.wait(driverWaitKey);
-            })));
-
-    std::thread taskThread([&]() {
-      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-          .numDrivers(numDrivers_)
-          .planNode(plan)
-          .queryPool(std::move(queryPool))
-          .injectSpill(false)
-          .spillDirectory(enableSpilling ? tempDirectory->getPath() : "")
-          .referenceQuery(
-              "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
-          .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-            const auto statsPair = taskSpilledStats(*task);
-            ASSERT_EQ(statsPair.first.spilledBytes, 0);
-            ASSERT_EQ(statsPair.first.spilledPartitions, 0);
-            ASSERT_EQ(statsPair.second.spilledBytes, 0);
-            ASSERT_EQ(statsPair.second.spilledPartitions, 0);
-            verifyTaskSpilledRuntimeStats(*task, false);
-          })
-          .run();
-    });
-
-    testWait.wait(testWaitKey);
-    ASSERT_TRUE(op != nullptr);
-    auto task = op->operatorCtx()->task();
-    auto taskPauseWait = task->requestPause();
-    taskPauseWait.wait();
-
-    uint64_t reclaimableBytes{0};
-    const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
-    ASSERT_EQ(op->canReclaim(), enableSpilling);
-    ASSERT_EQ(reclaimable, enableSpilling);
-    if (enableSpilling) {
-      ASSERT_GE(reclaimableBytes, 0);
-    } else {
-      ASSERT_EQ(reclaimableBytes, 0);
-    }
-    VELOX_ASSERT_THROW(
-        op->reclaim(
-            folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
-            reclaimerStats_),
-        "");
-
-    driverWait.notify();
-    Task::resume(task);
-    task.reset();
-
-    taskThread.join();
-  }
-  ASSERT_EQ(reclaimerStats_, memory::MemoryReclaimer::Stats{0});
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringOutputProcessing) {
-  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
-  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
-  const int32_t numBuildVectors = 10;
-  std::vector<RowVectorPtr> buildVectors;
-  for (int32_t i = 0; i < numBuildVectors; ++i) {
-    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
-  }
-  const int32_t numProbeVectors = 5;
-  std::vector<RowVectorPtr> probeVectors;
-  for (int32_t i = 0; i < numProbeVectors; ++i) {
-    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
-  }
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  const std::vector<bool> enableSpillings = {false, true};
-  for (const auto enableSpilling : enableSpillings) {
-    SCOPED_TRACE(fmt::format("enableSpilling {}", enableSpilling));
-    auto tempDirectory = exec::test::TempDirectoryPath::create();
-    auto queryPool = memory::memoryManager()->addRootPool(
-        "", kMaxBytes, memory::MemoryReclaimer::create());
-
-    core::PlanNodeId probeScanId;
-    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-    auto plan = PlanBuilder(planNodeIdGenerator)
-                    .values(probeVectors, false)
-                    .hashJoin(
-                        {"t_k1"},
-                        {"u_k1"},
-                        PlanBuilder(planNodeIdGenerator)
-                            .values(buildVectors, false)
-                            .planNode(),
-                        "",
-                        concat(probeType_->names(), buildType_->names()))
-                    .planNode();
-
-    std::atomic_bool driverWaitFlag{true};
-    folly::EventCount driverWait;
-    std::atomic_bool testWaitFlag{true};
-    folly::EventCount testWait;
-
-    std::atomic<bool> injectOnce{true};
-    Operator* op;
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Driver::runInternal::noMoreInput",
-        std::function<void(Operator*)>(([&](Operator* testOp) {
-          if (testOp->operatorType() != "HashBuild") {
-            return;
-          }
-          op = testOp;
-          if (!injectOnce.exchange(false)) {
-            return;
-          }
-          ASSERT_EQ(op->canReclaim(), enableSpilling);
-          uint64_t reclaimableBytes{0};
-          const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
-          ASSERT_EQ(reclaimable, enableSpilling);
-          if (enableSpilling) {
-            ASSERT_GT(reclaimableBytes, 0);
-          } else {
-            ASSERT_EQ(reclaimableBytes, 0);
-          }
-          testWaitFlag = false;
-          testWait.notifyAll();
-          driverWait.await([&]() { return !driverWaitFlag.load(); });
-        })));
-
-    std::thread taskThread([&]() {
-      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-          .numDrivers(numDrivers_)
-          .planNode(plan)
-          .queryPool(std::move(queryPool))
-          .injectSpill(false)
-          .spillDirectory(enableSpilling ? tempDirectory->getPath() : "")
-          .referenceQuery(
-              "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
-          .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-            const auto statsPair = taskSpilledStats(*task);
-            ASSERT_EQ(statsPair.first.spilledBytes, 0);
-            ASSERT_EQ(statsPair.first.spilledPartitions, 0);
-            ASSERT_EQ(statsPair.second.spilledBytes, 0);
-            ASSERT_EQ(statsPair.second.spilledPartitions, 0);
-            verifyTaskSpilledRuntimeStats(*task, false);
-          })
-          .run();
-    });
-
-    testWait.await([&]() { return !testWaitFlag.load(); });
-    ASSERT_TRUE(op != nullptr);
-    auto task = op->operatorCtx()->task();
-    auto taskPauseWait = task->requestPause();
-    driverWaitFlag = false;
-    driverWait.notifyAll();
-    taskPauseWait.wait();
-
-    uint64_t reclaimableBytes{0};
-    const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
-    ASSERT_EQ(op->canReclaim(), enableSpilling);
-    ASSERT_EQ(reclaimable, enableSpilling);
-
-    if (enableSpilling) {
-      ASSERT_GT(reclaimableBytes, 0);
-      const auto usedMemoryBytes = op->pool()->usedBytes();
-      {
-        memory::ScopedMemoryArbitrationContext ctx(op->pool());
-        op->pool()->reclaim(
-            folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
-            0,
-            reclaimerStats_);
-      }
-      ASSERT_GE(reclaimerStats_.reclaimedBytes, 0);
-      ASSERT_GT(reclaimerStats_.reclaimExecTimeUs, 0);
-      // No reclaim as the operator has started output processing.
-      ASSERT_EQ(usedMemoryBytes, op->pool()->usedBytes());
-    } else {
-      ASSERT_EQ(reclaimableBytes, 0);
-      VELOX_ASSERT_THROW(
-          op->reclaim(
-              folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
-              reclaimerStats_),
-          "");
-    }
-
-    Task::resume(task);
-    task.reset();
-
-    taskThread.join();
-  }
-  ASSERT_EQ(reclaimerStats_.numNonReclaimableAttempts, 1);
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringWaitForProbe) {
-  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
-  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
-  const int32_t numBuildVectors = 10;
-  std::vector<RowVectorPtr> buildVectors;
-  for (int32_t i = 0; i < numBuildVectors; ++i) {
-    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
-  }
-  const int32_t numProbeVectors = 5;
-  std::vector<RowVectorPtr> probeVectors;
-  for (int32_t i = 0; i < numProbeVectors; ++i) {
-    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
-  }
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
-  auto queryPool = memory::memoryManager()->addRootPool(
-      "", kMaxBytes, memory::MemoryReclaimer::create());
-
-  core::PlanNodeId probeScanId;
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto plan = PlanBuilder(planNodeIdGenerator)
-                  .values(probeVectors, false)
-                  .hashJoin(
-                      {"t_k1"},
-                      {"u_k1"},
-                      PlanBuilder(planNodeIdGenerator)
-                          .values(buildVectors, false)
-                          .planNode(),
-                      "",
-                      concat(probeType_->names(), buildType_->names()))
-                  .planNode();
-
-  std::atomic_bool driverWaitFlag{true};
-  folly::EventCount driverWait;
-  std::atomic_bool testWaitFlag{true};
-  folly::EventCount testWait;
-
-  Operator* op{nullptr};
-  std::atomic<bool> injectSpillOnce{true};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::HashBuild::finishHashBuild",
-      std::function<void(Operator*)>(([&](Operator* testOp) {
-        if (testOp->operatorType() != "HashBuild") {
-          return;
-        }
-        op = testOp;
-        if (!injectSpillOnce.exchange(false)) {
-          return;
-        }
-        auto* driver = op->operatorCtx()->driver();
-        auto task = driver->task();
-        memory::ScopedMemoryArbitrationContext ctx(op->pool());
-        Operator::ReclaimableSectionGuard guard(testOp);
-        testingRunArbitration(testOp->pool());
-      })));
-
-  std::atomic<bool> injectOnce{true};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Driver::runInternal::noMoreInput",
-      std::function<void(Operator*)>(([&](Operator* testOp) {
-        if (testOp->operatorType() != "HashProbe") {
-          return;
-        }
-        if (!injectOnce.exchange(false)) {
-          return;
-        }
-        ASSERT_TRUE(op != nullptr);
-        ASSERT_TRUE(op->canReclaim());
-        uint64_t reclaimableBytes{0};
-        const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
-        ASSERT_TRUE(reclaimable);
-        ASSERT_GT(reclaimableBytes, 0);
-        testWaitFlag = false;
-        testWait.notifyAll();
-        auto* driver = testOp->operatorCtx()->driver();
-        auto task = driver->task();
-        TestSuspendedSection suspendedSection(driver);
-        driverWait.await([&]() { return !driverWaitFlag.load(); });
-      })));
-
-  std::thread taskThread([&]() {
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .numDrivers(numDrivers_)
-        .planNode(plan)
-        .queryPool(std::move(queryPool))
-        .injectSpill(false)
-        .spillDirectory(tempDirectory->getPath())
-        .referenceQuery(
-            "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
-        .config(core::QueryConfig::kSpillStartPartitionBit, "29")
-        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-          const auto statsPair = taskSpilledStats(*task);
-          ASSERT_GT(statsPair.first.spilledBytes, 0);
-          ASSERT_EQ(statsPair.first.spilledPartitions, 8);
-          ASSERT_GT(statsPair.second.spilledBytes, 0);
-          ASSERT_EQ(statsPair.second.spilledPartitions, 8);
-        })
-        .run();
-  });
-
-  testWait.await([&]() { return !testWaitFlag.load(); });
-  ASSERT_TRUE(op != nullptr);
-  auto task = op->operatorCtx()->task();
-  auto taskPauseWait = task->requestPause();
-  taskPauseWait.wait();
-
-  uint64_t reclaimableBytes{0};
-  const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
-  ASSERT_TRUE(op->canReclaim());
-  ASSERT_TRUE(reclaimable);
-  ASSERT_GT(reclaimableBytes, 0);
-
-  const auto usedMemoryBytes = op->pool()->usedBytes();
-  reclaimerStats_.reset();
-  {
-    memory::ScopedMemoryArbitrationContext ctx(op->pool());
-    op->pool()->reclaim(
-        folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
-        0,
-        reclaimerStats_);
-  }
-  ASSERT_GE(reclaimerStats_.reclaimedBytes, 0);
-  ASSERT_GT(reclaimerStats_.reclaimExecTimeUs, 0);
-  //  No reclaim as the build operator is not in building table state.
-  ASSERT_EQ(usedMemoryBytes, op->pool()->usedBytes());
-
-  driverWaitFlag = false;
-  driverWait.notifyAll();
-  Task::resume(task);
-  task.reset();
-
-  taskThread.join();
-  ASSERT_EQ(reclaimerStats_.numNonReclaimableAttempts, 1);
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, hashBuildAbortDuringOutputProcessing) {
-  const auto buildVectors = makeVectors(buildType_, 10, 128);
-  const auto probeVectors = makeVectors(probeType_, 5, 128);
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  struct {
-    bool abortFromRootMemoryPool;
-    int numDrivers;
-
-    std::string debugString() const {
-      return fmt::format(
-          "abortFromRootMemoryPool {} numDrivers {}",
-          abortFromRootMemoryPool,
-          numDrivers);
-    }
-  } testSettings[] = {{true, 1}, {false, 1}, {true, 4}, {false, 4}};
-
-  for (const auto& testData : testSettings) {
-    SCOPED_TRACE(testData.debugString());
-
-    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-    auto plan = PlanBuilder(planNodeIdGenerator)
-                    .values(probeVectors, true)
-                    .hashJoin(
-                        {"t_k1"},
-                        {"u_k1"},
-                        PlanBuilder(planNodeIdGenerator)
-                            .values(buildVectors, true)
-                            .planNode(),
-                        "",
-                        concat(probeType_->names(), buildType_->names()))
-                    .planNode();
-
-    std::atomic<bool> injectOnce{true};
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Driver::runInternal::noMoreInput",
-        std::function<void(Operator*)>(([&](Operator* op) {
-          if (op->operatorType() != "HashBuild") {
-            return;
-          }
-          if (!injectOnce.exchange(false)) {
-            return;
-          }
-          ASSERT_GT(op->pool()->usedBytes(), 0);
-          auto* driver = op->operatorCtx()->driver();
-          ASSERT_EQ(
-              driver->task()->enterSuspended(driver->state()),
-              StopReason::kNone);
-          testData.abortFromRootMemoryPool ? abortPool(op->pool()->root())
-                                           : abortPool(op->pool());
-          // We can't directly reclaim memory from this hash build operator as
-          // its driver thread is running and in suspension state.
-          ASSERT_GT(op->pool()->root()->usedBytes(), 0);
-          ASSERT_EQ(
-              driver->task()->leaveSuspended(driver->state()),
-              StopReason::kAlreadyTerminated);
-          ASSERT_TRUE(op->pool()->aborted());
-          ASSERT_TRUE(op->pool()->root()->aborted());
-          VELOX_MEM_POOL_ABORTED("Memory pool aborted");
-        })));
-
-    VELOX_ASSERT_THROW(
-        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-            .numDrivers(numDrivers_)
-            .planNode(plan)
-            .injectSpill(false)
-            .referenceQuery(
-                "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
-            .run(),
-        "Manual MemoryPool Abortion");
-    waitForAllTasksToBeDeleted();
-  }
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, hashBuildAbortDuringInputProcessing) {
-  const auto buildVectors = makeVectors(buildType_, 10, 128);
-  const auto probeVectors = makeVectors(probeType_, 5, 128);
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  struct {
-    bool abortFromRootMemoryPool;
-    int numDrivers;
-
-    std::string debugString() const {
-      return fmt::format(
-          "abortFromRootMemoryPool {} numDrivers {}",
-          abortFromRootMemoryPool,
-          numDrivers);
-    }
-  } testSettings[] = {{true, 1}, {false, 1}, {true, 4}, {false, 4}};
-
-  for (const auto& testData : testSettings) {
-    SCOPED_TRACE(testData.debugString());
-
-    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-    auto plan = PlanBuilder(planNodeIdGenerator)
-                    .values(probeVectors, true)
-                    .hashJoin(
-                        {"t_k1"},
-                        {"u_k1"},
-                        PlanBuilder(planNodeIdGenerator)
-                            .values(buildVectors, true)
-                            .planNode(),
-                        "",
-                        concat(probeType_->names(), buildType_->names()))
-                    .planNode();
-
-    std::atomic<int> numInputs{0};
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Driver::runInternal::addInput",
-        std::function<void(Operator*)>(([&](Operator* op) {
-          if (op->operatorType() != "HashBuild") {
-            return;
-          }
-          if (++numInputs != 2) {
-            return;
-          }
-          ASSERT_GT(op->pool()->usedBytes(), 0);
-          auto* driver = op->operatorCtx()->driver();
-          ASSERT_EQ(
-              driver->task()->enterSuspended(driver->state()),
-              StopReason::kNone);
-          testData.abortFromRootMemoryPool ? abortPool(op->pool()->root())
-                                           : abortPool(op->pool());
-          // We can't directly reclaim memory from this hash build operator as
-          // its driver thread is running and in suspension state.
-          ASSERT_GT(op->pool()->root()->usedBytes(), 0);
-          ASSERT_EQ(
-              driver->task()->leaveSuspended(driver->state()),
-              StopReason::kAlreadyTerminated);
-          ASSERT_TRUE(op->pool()->aborted());
-          ASSERT_TRUE(op->pool()->root()->aborted());
-          VELOX_MEM_POOL_ABORTED("Memory pool aborted");
-        })));
-
-    VELOX_ASSERT_THROW(
-        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-            .numDrivers(numDrivers_)
-            .planNode(plan)
-            .injectSpill(false)
-            .referenceQuery(
-                "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
-            .run(),
-        "Manual MemoryPool Abortion");
-
-    waitForAllTasksToBeDeleted();
-  }
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, hashBuildAbortDuringAllocation) {
-  const auto buildVectors = makeVectors(buildType_, 10, 128);
-  const auto probeVectors = makeVectors(probeType_, 5, 128);
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  struct {
-    bool abortFromRootMemoryPool;
-    int numDrivers;
-
-    std::string debugString() const {
-      return fmt::format(
-          "abortFromRootMemoryPool {} numDrivers {}",
-          abortFromRootMemoryPool,
-          numDrivers);
-    }
-  } testSettings[] = {{true, 1}, {false, 1}, {true, 4}, {false, 4}};
-
-  for (const auto& testData : testSettings) {
-    SCOPED_TRACE(testData.debugString());
-
-    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-    auto plan = PlanBuilder(planNodeIdGenerator)
-                    .values(probeVectors, true)
-                    .hashJoin(
-                        {"t_k1"},
-                        {"u_k1"},
-                        PlanBuilder(planNodeIdGenerator)
-                            .values(buildVectors, true)
-                            .planNode(),
-                        "",
-                        concat(probeType_->names(), buildType_->names()))
-                    .planNode();
-
-    std::atomic_bool injectOnce{true};
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::common::memory::MemoryPoolImpl::allocateNonContiguous",
-        std::function<void(memory::MemoryPoolImpl*)>(
-            ([&](memory::MemoryPoolImpl* pool) {
-              if (!isHashBuildMemoryPool(*pool)) {
-                return;
-              }
-              if (!injectOnce.exchange(false)) {
-                return;
-              }
-
-              const auto* driverCtx = driverThreadContext()->driverCtx();
-              ASSERT_EQ(
-                  driverCtx->task->enterSuspended(driverCtx->driver->state()),
-                  StopReason::kNone);
-              testData.abortFromRootMemoryPool ? abortPool(pool->root())
-                                               : abortPool(pool);
-              // We can't directly reclaim memory from this hash build operator
-              // as its driver thread is running and in suspegnsion state.
-              ASSERT_GE(pool->root()->usedBytes(), 0);
-              ASSERT_EQ(
-                  driverCtx->task->leaveSuspended(driverCtx->driver->state()),
-                  StopReason::kAlreadyTerminated);
-              ASSERT_TRUE(pool->aborted());
-              ASSERT_TRUE(pool->root()->aborted());
-              VELOX_MEM_POOL_ABORTED("Memory pool aborted");
-            })));
-
-    VELOX_ASSERT_THROW(
-        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-            .numDrivers(numDrivers_)
-            .planNode(plan)
-            .injectSpill(false)
-            .referenceQuery(
-                "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
-            .run(),
-        "Manual MemoryPool Abortion");
-
-    waitForAllTasksToBeDeleted();
-  }
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeAbortDuringInputProcessing) {
-  const auto buildVectors = makeVectors(buildType_, 10, 128);
-  const auto probeVectors = makeVectors(probeType_, 5, 128);
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  struct {
-    bool abortFromRootMemoryPool;
-    int numDrivers;
-
-    std::string debugString() const {
-      return fmt::format(
-          "abortFromRootMemoryPool {} numDrivers {}",
-          abortFromRootMemoryPool,
-          numDrivers);
-    }
-  } testSettings[] = {{true, 1}, {false, 1}, {true, 4}, {false, 4}};
-
-  for (const auto& testData : testSettings) {
-    SCOPED_TRACE(testData.debugString());
-
-    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-    auto plan = PlanBuilder(planNodeIdGenerator)
-                    .values(probeVectors, true)
-                    .hashJoin(
-                        {"t_k1"},
-                        {"u_k1"},
-                        PlanBuilder(planNodeIdGenerator)
-                            .values(buildVectors, true)
-                            .planNode(),
-                        "",
-                        concat(probeType_->names(), buildType_->names()))
-                    .planNode();
-
-    std::atomic<int> numInputs{0};
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Driver::runInternal::addInput",
-        std::function<void(Operator*)>(([&](Operator* op) {
-          if (op->operatorType() != "HashProbe") {
-            return;
-          }
-          if (++numInputs != 2) {
-            return;
-          }
-          auto* driver = op->operatorCtx()->driver();
-          ASSERT_EQ(
-              driver->task()->enterSuspended(driver->state()),
-              StopReason::kNone);
-          testData.abortFromRootMemoryPool ? abortPool(op->pool()->root())
-                                           : abortPool(op->pool());
-          ASSERT_EQ(
-              driver->task()->leaveSuspended(driver->state()),
-              StopReason::kAlreadyTerminated);
-          ASSERT_TRUE(op->pool()->aborted());
-          ASSERT_TRUE(op->pool()->root()->aborted());
-          VELOX_MEM_POOL_ABORTED("Memory pool aborted");
-        })));
-
-    VELOX_ASSERT_THROW(
-        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-            .numDrivers(numDrivers_)
-            .planNode(plan)
-            .injectSpill(false)
-            .referenceQuery(
-                "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
-            .run(),
-        "Manual MemoryPool Abortion");
-    waitForAllTasksToBeDeleted();
-  }
-}
-
-TEST_F(HashJoinTest, leftJoinWithMissAtEndOfBatch) {
-  // Tests some cases where the row at the end of an output batch fails the
-  // filter.
-  auto probeVectors = std::vector<RowVectorPtr>{makeRowVector(
-      {"t_k1", "t_k2"},
-      {makeFlatVector<int32_t>(20, [](auto row) { return 1 + row % 2; }),
-       makeFlatVector<int32_t>(20, [](auto row) { return row; })})};
-  auto buildVectors = std::vector<RowVectorPtr>{
-      makeRowVector({"u_k1"}, {makeFlatVector<int32_t>({1, 2})})};
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", {buildVectors});
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-
-  auto test = [&](const std::string& filter) {
-    auto plan = PlanBuilder(planNodeIdGenerator)
-                    .values(probeVectors, true)
-                    .hashJoin(
-                        {"t_k1"},
-                        {"u_k1"},
-                        PlanBuilder(planNodeIdGenerator)
-                            .values(buildVectors, true)
-                            .planNode(),
-                        filter,
-                        {"t_k1", "u_k1"},
-                        core::JoinType::kLeft)
-                    .planNode();
-
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .planNode(plan)
-        .injectSpill(false)
-        .checkSpillStats(false)
-        .maxSpillLevel(0)
-        .numDrivers(1)
-        .config(
-            core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
-        .referenceQuery(fmt::format(
-            "SELECT t_k1, u_k1 from t left join u on t_k1 = u_k1 and {}",
-            filter))
-        .run();
-  };
-
-  // Alternate rows pass this filter and last row of a batch fails.
-  test("t_k1=1");
-
-  // All rows fail this filter.
-  test("t_k1=5");
-
-  // All rows in the second batch pass this filter.
-  test("t_k2 > 9");
-}
-
-TEST_F(HashJoinTest, leftJoinWithMissAtEndOfBatchMultipleBuildMatches) {
-  // Tests some cases where the row at the end of an output batch fails the
-  // filter and there are multiple matches with the build side..
-  auto probeVectors = std::vector<RowVectorPtr>{makeRowVector(
-      {"t_k1", "t_k2"},
-      {makeFlatVector<int32_t>(10, [](auto row) { return 1 + row % 2; }),
-       makeFlatVector<int32_t>(10, [](auto row) { return row; })})};
-  auto buildVectors = std::vector<RowVectorPtr>{
-      makeRowVector({"u_k1"}, {makeFlatVector<int32_t>({1, 2, 1, 2})})};
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", {buildVectors});
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-
-  auto test = [&](const std::string& filter) {
-    auto plan = PlanBuilder(planNodeIdGenerator)
-                    .values(probeVectors, true)
-                    .hashJoin(
-                        {"t_k1"},
-                        {"u_k1"},
-                        PlanBuilder(planNodeIdGenerator)
-                            .values(buildVectors, true)
-                            .planNode(),
-                        filter,
-                        {"t_k1", "u_k1"},
-                        core::JoinType::kLeft)
-                    .planNode();
-
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .planNode(plan)
-        .injectSpill(false)
-        .checkSpillStats(false)
-        .maxSpillLevel(0)
-        .numDrivers(1)
-        .config(
-            core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
-        .referenceQuery(fmt::format(
-            "SELECT t_k1, u_k1 from t left join u on t_k1 = u_k1 and {}",
-            filter))
-        .run();
-  };
-
-  // In this case the rows with t_k2 = 4 appear at the end of the first batch,
-  // meaning the last rows in that output batch are misses, and don't get added.
-  // The rows with t_k2 = 8 appear in the second batch so only one row is
-  // written, meaning there is space in the second output batch for the miss
-  // with tk_2 = 4 to get written.
-  test("t_k2 != 4 and t_k2 != 8");
-}
-
-TEST_F(HashJoinTest, leftJoinPreserveProbeOrder) {
-  const std::vector<RowVectorPtr> probeVectors = {
-      makeRowVector(
-          {"k1", "v1"},
-          {
-              makeConstant<int64_t>(0, 2),
-              makeFlatVector<int64_t>({1, 0}),
-          }),
-  };
-  const std::vector<RowVectorPtr> buildVectors = {
-      makeRowVector(
-          {"k2", "v2"},
-          {
-              makeConstant<int64_t>(0, 2),
-              makeConstant<int64_t>(0, 2),
-          }),
-  };
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto plan =
-      PlanBuilder(planNodeIdGenerator)
-          .values(probeVectors)
-          .hashJoin(
-              {"k1"},
-              {"k2"},
-              PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode(),
-              "v1 % 2 = v2 % 2",
-              {"v1"},
-              core::JoinType::kLeft)
-          .planNode();
-  auto result = AssertQueryBuilder(plan)
-                    .config(core::QueryConfig::kPreferredOutputBatchRows, "1")
-                    .serialExecution(true)
-                    .copyResults(pool_.get());
-  ASSERT_EQ(result->size(), 3);
-  auto* v1 =
-      result->childAt(0)->loadedVector()->asUnchecked<SimpleVector<int64_t>>();
-  ASSERT_FALSE(v1->mayHaveNulls());
-  ASSERT_EQ(v1->valueAt(0), 1);
-  ASSERT_EQ(v1->valueAt(1), 0);
-  ASSERT_EQ(v1->valueAt(2), 0);
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, minSpillableMemoryReservation) {
-  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
-  const int32_t numBuildVectors = 10;
-  std::vector<RowVectorPtr> buildVectors;
-  for (int32_t i = 0; i < numBuildVectors; ++i) {
-    buildVectors.push_back(fuzzer.fuzzInputRow(buildType_));
-  }
-  const int32_t numProbeVectors = 5;
-  std::vector<RowVectorPtr> probeVectors;
-  for (int32_t i = 0; i < numProbeVectors; ++i) {
-    probeVectors.push_back(fuzzer.fuzzInputRow(probeType_));
-  }
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  core::PlanNodeId probeScanId;
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto plan = PlanBuilder(planNodeIdGenerator)
-                  .values(probeVectors, false)
-                  .hashJoin(
-                      {"t_k1"},
-                      {"u_k1"},
-                      PlanBuilder(planNodeIdGenerator)
-                          .values(buildVectors, false)
-                          .planNode(),
-                      "",
-                      concat(probeType_->names(), buildType_->names()))
-                  .planNode();
-
-  for (int32_t minSpillableReservationPct : {5, 50, 100}) {
-    SCOPED_TRACE(fmt::format(
-        "minSpillableReservationPct: {}", minSpillableReservationPct));
-
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::HashBuild::addInput",
-        std::function<void(exec::HashBuild*)>(([&](exec::HashBuild* hashBuild) {
-          memory::MemoryPool* pool = hashBuild->pool();
-          const auto availableReservationBytes = pool->availableReservation();
-          const auto currentUsedBytes = pool->usedBytes();
-          // Verifies we always have min reservation after ensuring the input.
-          ASSERT_GE(
-              availableReservationBytes,
-              currentUsedBytes * minSpillableReservationPct / 100);
-        })));
-
-    auto tempDirectory = exec::test::TempDirectoryPath::create();
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .numDrivers(numDrivers_)
-        .planNode(plan)
-        .injectSpill(false)
-        .spillDirectory(tempDirectory->getPath())
-        .referenceQuery(
-            "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
-        .run();
-  }
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, exceededMaxSpillLevel) {
-  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
-  const int32_t numBuildVectors = 10;
-  std::vector<RowVectorPtr> buildVectors;
-  for (int32_t i = 0; i < numBuildVectors; ++i) {
-    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
-  }
-  const int32_t numProbeVectors = 5;
-  std::vector<RowVectorPtr> probeVectors;
-  for (int32_t i = 0; i < numProbeVectors; ++i) {
-    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
-  }
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  core::PlanNodeId probeScanId;
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto plan = PlanBuilder(planNodeIdGenerator)
-                  .values(probeVectors, false)
-                  .hashJoin(
-                      {"t_k1"},
-                      {"u_k1"},
-                      PlanBuilder(planNodeIdGenerator)
-                          .values(buildVectors, false)
-                          .planNode(),
-                      "",
-                      concat(probeType_->names(), buildType_->names()))
-                  .planNode();
-
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
-  const int exceededMaxSpillLevelCount =
-      common::globalSpillStats().spillMaxLevelExceededCount;
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::HashBuild::reclaim",
-      std::function<void(exec::Operator*)>(([&](exec::Operator* op) {
-        HashBuild* hashBuild = static_cast<HashBuild*>(op);
-        ASSERT_FALSE(hashBuild->testingExceededMaxSpillLevelLimit());
-      })));
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::HashProbe::reclaim",
-      std::function<void(exec::HashBuild*)>(([&](exec::Operator* op) {
-        HashProbe* hashProbe = static_cast<HashProbe*>(op);
-        ASSERT_FALSE(hashProbe->testingExceededMaxSpillLevelLimit());
-      })));
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::HashBuild::finishHashBuild",
-      std::function<void(exec::HashBuild*)>(([&](exec::HashBuild* hashBuild) {
-        Operator::ReclaimableSectionGuard guard(hashBuild);
-        testingRunArbitration(hashBuild->pool());
-      })));
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .numDrivers(1)
-      .planNode(plan)
-      // Always trigger spilling.
-      .injectSpill(false)
-      .maxSpillLevel(0)
-      .spillDirectory(tempDirectory->getPath())
-      .referenceQuery(
-          "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
-      .config(core::QueryConfig::kSpillStartPartitionBit, "29")
-      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-        auto opStats = toOperatorStats(task->taskStats());
-        ASSERT_EQ(
-            opStats.at("HashProbe")
-                .runtimeStats[Operator::kExceededMaxSpillLevel]
-                .sum,
-            8);
-        ASSERT_EQ(
-            opStats.at("HashProbe")
-                .runtimeStats[Operator::kExceededMaxSpillLevel]
-                .count,
-            1);
-        ASSERT_EQ(
-            opStats.at("HashBuild")
-                .runtimeStats[Operator::kExceededMaxSpillLevel]
-                .sum,
-            8);
-        ASSERT_EQ(
-            opStats.at("HashBuild")
-                .runtimeStats[Operator::kExceededMaxSpillLevel]
-                .count,
-            1);
-      })
-      .run();
-  ASSERT_EQ(
-      common::globalSpillStats().spillMaxLevelExceededCount,
-      exceededMaxSpillLevelCount + 16);
-}
-
-TEST_F(HashJoinTest, maxSpillBytes) {
-  const auto rowType =
-      ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), VARCHAR()});
-  const auto probeVectors = createVectors(rowType, 1024, 10 << 20);
-  const auto buildVectors = createVectors(rowType, 1024, 10 << 20);
-
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto plan = PlanBuilder(planNodeIdGenerator)
-                  .values(probeVectors, true)
-                  .project({"c0", "c1", "c2"})
-                  .hashJoin(
-                      {"c0"},
-                      {"u1"},
-                      PlanBuilder(planNodeIdGenerator)
-                          .values(buildVectors, true)
-                          .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
-                          .planNode(),
-                      "",
-                      {"c0", "c1", "c2"},
-                      core::JoinType::kInner)
-                  .planNode();
-
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
-  auto queryCtx = core::QueryCtx::create(executor_.get());
-
-  struct {
-    int32_t maxSpilledBytes;
-    bool expectedExceedLimit;
-    std::string debugString() const {
-      return fmt::format("maxSpilledBytes {}", maxSpilledBytes);
-    }
-  } testSettings[] = {{1 << 30, false}, {16 << 20, true}, {0, false}};
-
-  for (const auto& testData : testSettings) {
-    SCOPED_TRACE(testData.debugString());
-    try {
-      TestScopedSpillInjection scopedSpillInjection(100);
-      AssertQueryBuilder(plan)
-          .spillDirectory(spillDirectory->getPath())
-          .queryCtx(queryCtx)
-          .config(core::QueryConfig::kSpillEnabled, true)
-          .config(core::QueryConfig::kJoinSpillEnabled, true)
-          .config(core::QueryConfig::kMaxSpillBytes, testData.maxSpilledBytes)
-          .copyResults(pool_.get());
-      ASSERT_FALSE(testData.expectedExceedLimit);
-    } catch (const VeloxRuntimeError& e) {
-      ASSERT_TRUE(testData.expectedExceedLimit);
-      ASSERT_NE(
-          e.message().find(
-              "Query exceeded per-query local spill limit of 16.00MB"),
-          std::string::npos);
-      ASSERT_EQ(
-          e.errorCode(), facebook::velox::error_code::kSpillLimitExceeded);
-    }
-  }
-}
-
-TEST_F(HashJoinTest, onlyHashBuildMaxSpillBytes) {
-  const auto rowType =
-      ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), VARCHAR()});
-  const auto probeVectors = createVectors(rowType, 32, 128);
-  const auto buildVectors = createVectors(rowType, 1024, 10 << 20);
-
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto plan = PlanBuilder(planNodeIdGenerator)
-                  .values(probeVectors, true)
-                  .hashJoin(
-                      {"c0"},
-                      {"u1"},
-                      PlanBuilder(planNodeIdGenerator)
-                          .values(buildVectors, true)
-                          .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
-                          .planNode(),
-                      "",
-                      {"c0", "c1", "c2"},
-                      core::JoinType::kInner)
-                  .planNode();
-
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
-  auto queryCtx = core::QueryCtx::create(executor_.get());
-
-  struct {
-    int32_t maxSpilledBytes;
-    bool expectedExceedLimit;
-    std::string debugString() const {
-      return fmt::format("maxSpilledBytes {}", maxSpilledBytes);
-    }
-  } testSettings[] = {{1 << 30, false}, {16 << 20, true}, {0, false}};
-
-  for (const auto& testData : testSettings) {
-    SCOPED_TRACE(testData.debugString());
-    try {
-      TestScopedSpillInjection scopedSpillInjection(100);
-      AssertQueryBuilder(plan)
-          .spillDirectory(spillDirectory->getPath())
-          .queryCtx(queryCtx)
-          .config(core::QueryConfig::kSpillEnabled, true)
-          .config(core::QueryConfig::kJoinSpillEnabled, true)
-          .config(core::QueryConfig::kMaxSpillBytes, testData.maxSpilledBytes)
-          .copyResults(pool_.get());
-      ASSERT_FALSE(testData.expectedExceedLimit);
-    } catch (const VeloxRuntimeError& e) {
-      ASSERT_TRUE(testData.expectedExceedLimit);
-      ASSERT_NE(
-          e.message().find(
-              "Query exceeded per-query local spill limit of 16.00MB"),
-          std::string::npos);
-      ASSERT_EQ(
-          e.errorCode(), facebook::velox::error_code::kSpillLimitExceeded);
-    }
-  }
-}
-
-TEST_F(HashJoinTest, reclaimFromJoinBuilderWithMultiDrivers) {
-  auto rowType = ROW({
-      {"c0", INTEGER()},
-      {"c1", INTEGER()},
-      {"c2", VARCHAR()},
-  });
-  const auto vectors = createVectors(rowType, 64 << 20, fuzzerOpts_);
-  const int numDrivers = 4;
-
-  memory::MemoryManager::Options options;
-  options.allocatorCapacity = 8L << 30;
-  auto memoryManagerWithoutArbitrator =
-      std::make_unique<memory::MemoryManager>(options);
-  const auto expectedResult =
-      runHashJoinTask(
-          vectors,
-          newQueryCtx(
-              memoryManagerWithoutArbitrator.get(), executor_.get(), 8L << 30),
-          false,
-          numDrivers,
-          pool(),
-          false)
-          .data;
-
-  auto memoryManagerWithArbitrator = createMemoryManager();
-  const auto& arbitrator = memoryManagerWithArbitrator->arbitrator();
-  // Create a query ctx with a small capacity to trigger spilling.
-  auto result = runHashJoinTask(
-      vectors,
-      newQueryCtx(
-          memoryManagerWithArbitrator.get(), executor_.get(), 128 << 20),
-      false,
-      numDrivers,
-      pool(),
-      true,
-      expectedResult);
-  auto taskStats = exec::toPlanStats(result.task->taskStats());
-  auto& planStats = taskStats.at(result.planNodeId);
-  ASSERT_GT(planStats.spilledBytes, 0);
-  result.task.reset();
-
-  // This test uses on-demand created memory manager instead of the global
-  // one. We need to make sure any used memory got cleaned up before exiting
-  // the scope
-  waitForAllTasksToBeDeleted();
-  ASSERT_GT(arbitrator->stats().numRequests, 0);
-  ASSERT_GT(arbitrator->stats().reclaimedUsedBytes, 0);
-}
-
-DEBUG_ONLY_TEST_F(
-    HashJoinTest,
-    failedToReclaimFromHashJoinBuildersInNonReclaimableSection) {
-  auto rowType = ROW({
-      {"c0", INTEGER()},
-      {"c1", INTEGER()},
-      {"c2", VARCHAR()},
-  });
-  const auto vectors = createVectors(rowType, 64 << 20, fuzzerOpts_);
-  const int numDrivers = 1;
-  std::shared_ptr<core::QueryCtx> queryCtx =
-      newQueryCtx(memory::memoryManager(), executor_.get(), 512 << 20);
-  const auto expectedResult =
-      runHashJoinTask(vectors, queryCtx, false, numDrivers, pool(), false).data;
-
-  std::atomic_bool nonReclaimableSectionWaitFlag{true};
-  std::atomic_bool reclaimerInitializationWaitFlag{true};
-  folly::EventCount nonReclaimableSectionWait;
-  std::atomic_bool memoryArbitrationWaitFlag{true};
-  folly::EventCount memoryArbitrationWait;
-
-  std::atomic<uint32_t> numInitializedDrivers{0};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Driver::runInternal",
-      std::function<void(exec::Driver*)>([&](exec::Driver* driver) {
-        numInitializedDrivers++;
-        // We need to make sure reclaimers on both build and probe side are set
-        // (in Operator::initialize) to avoid race conditions, producing
-        // consistent test results.
-        if (numInitializedDrivers.load() == 2) {
-          reclaimerInitializationWaitFlag = false;
-          nonReclaimableSectionWait.notifyAll();
-        }
-      }));
-
-  std::atomic<bool> injectNonReclaimableSectionOnce{true};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::common::memory::MemoryPoolImpl::allocateNonContiguous",
-      std::function<void(memory::MemoryPoolImpl*)>(
-          ([&](memory::MemoryPoolImpl* pool) {
-            if (!isHashBuildMemoryPool(*pool)) {
-              return;
-            }
-            if (!injectNonReclaimableSectionOnce.exchange(false)) {
-              return;
-            }
-
-            // Signal the test control that one of the hash build operator has
-            // entered into non-reclaimable section.
-            nonReclaimableSectionWaitFlag = false;
-            nonReclaimableSectionWait.notifyAll();
-
-            // Suspend the driver to simulate the arbitration.
-            pool->reclaimer()->enterArbitration();
-            // Wait for the memory arbitration to complete.
-            memoryArbitrationWait.await(
-                [&]() { return !memoryArbitrationWaitFlag.load(); });
-            pool->reclaimer()->leaveArbitration();
-          })));
-
-  std::thread joinThread([&]() {
-    const auto result = runHashJoinTask(
-        vectors, queryCtx, false, numDrivers, pool(), true, expectedResult);
-    auto taskStats = exec::toPlanStats(result.task->taskStats());
-    auto& planStats = taskStats.at(result.planNodeId);
-    ASSERT_EQ(planStats.spilledBytes, 0);
-  });
-
-  // Wait for the hash build operators to enter into non-reclaimable section.
-  nonReclaimableSectionWait.await([&]() {
-    return (
-        !nonReclaimableSectionWaitFlag.load() &&
-        !reclaimerInitializationWaitFlag.load());
-  });
-
-  // We expect capacity grow fails as we can't reclaim from hash join operators.
-  memory::testingRunArbitration();
-
-  // Notify the hash build operator that memory arbitration has been done.
-  memoryArbitrationWaitFlag = false;
-  memoryArbitrationWait.notifyAll();
-
-  joinThread.join();
-
-  // This test uses on-demand created memory manager instead of the global
-  // one. We need to make sure any used memory got cleaned up before exiting
-  // the scope
-  waitForAllTasksToBeDeleted();
-  ASSERT_EQ(
-      memory::memoryManager()->arbitrator()->stats().numNonReclaimableAttempts,
-      2);
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringTableBuild) {
-  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
-  const int32_t numBuildVectors = 5;
-  std::vector<RowVectorPtr> buildVectors;
-  for (int32_t i = 0; i < numBuildVectors; ++i) {
-    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
-  }
-  const int32_t numProbeVectors = 5;
-  std::vector<RowVectorPtr> probeVectors;
-  for (int32_t i = 0; i < numProbeVectors; ++i) {
-    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
-  }
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  core::PlanNodeId probeScanId;
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto plan = PlanBuilder(planNodeIdGenerator)
-                  .values(probeVectors, false)
-                  .hashJoin(
-                      {"t_k1"},
-                      {"u_k1"},
-                      PlanBuilder(planNodeIdGenerator)
-                          .values(buildVectors, false)
-                          .planNode(),
-                      "",
-                      concat(probeType_->names(), buildType_->names()))
-                  .planNode();
-
-  std::atomic_bool injectSpillOnce{true};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::HashBuild::finishHashBuild",
-      std::function<void(Operator*)>([&](Operator* op) {
-        if (!injectSpillOnce.exchange(false)) {
-          return;
-        }
-        Operator::ReclaimableSectionGuard guard(op);
-        testingRunArbitration(op->pool());
-      }));
-
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .numDrivers(4)
-      .planNode(plan)
-      .injectSpill(false)
-      .maxSpillLevel(0)
-      .spillDirectory(tempDirectory->getPath())
-      .referenceQuery(
-          "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
-      .config(core::QueryConfig::kSpillStartPartitionBit, "29")
-      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-        auto opStats = toOperatorStats(task->taskStats());
-        ASSERT_GT(
-            opStats.at("HashBuild").runtimeStats[Operator::kSpillWrites].sum,
-            0);
-      })
-      .run();
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, exceptionDuringFinishJoinBuild) {
-  // This test is to make sure there is no memory leak when exceptions are
-  // thrown while parallelly preparing join table.
-  auto memoryManager = memory::memoryManager();
-  const auto& arbitrator = memoryManager->arbitrator();
-  const uint64_t numDrivers = 2;
-  const auto expectedFreeCapacityBytes = arbitrator->stats().freeCapacityBytes;
-
-  const uint64_t numBuildSideRows = 500;
-  auto buildKeyVector = makeFlatVector<int64_t>(
-      numBuildSideRows,
-      [](vector_size_t row) { return folly::Random::rand64(); });
-  auto buildSideVector =
-      makeRowVector({"b0", "b1"}, {buildKeyVector, buildKeyVector});
-  std::vector<RowVectorPtr> buildSideVectors;
-  for (int i = 0; i < numDrivers; ++i) {
-    buildSideVectors.push_back(buildSideVector);
-  }
-  createDuckDbTable("build", buildSideVectors);
-
-  const uint64_t numProbeSideRows = 10;
-  auto probeKeyVector = makeFlatVector<int64_t>(
-      numProbeSideRows,
-      [&](vector_size_t row) { return buildKeyVector->valueAt(row); });
-  auto probeSideVector =
-      makeRowVector({"p0", "p1"}, {probeKeyVector, probeKeyVector});
-  std::vector<RowVectorPtr> probeSideVectors;
-  for (int i = 0; i < numDrivers; ++i) {
-    probeSideVectors.push_back(probeSideVector);
-  }
-  createDuckDbTable("probe", probeSideVectors);
-
-  ASSERT_EQ(arbitrator->stats().freeCapacityBytes, expectedFreeCapacityBytes);
-
-  // We set the task to fail right before we reserve memory for other operators.
-  // We rely on the driver suspension before parallel join build to throw
-  // exceptions (suspension on an already terminated task throws).
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::HashBuild::ensureTableFits",
-      std::function<void(HashBuild*)>([&](HashBuild* buildOp) {
-        try {
-          VELOX_FAIL("Simulated failure");
-        } catch (VeloxException&) {
-          buildOp->operatorCtx()->task()->setError(std::current_exception());
-        }
-      }));
-
-  std::vector<RowVectorPtr> probeInput = {probeSideVector};
-  std::vector<RowVectorPtr> buildInput = {buildSideVector};
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
-
-  ASSERT_EQ(arbitrator->stats().freeCapacityBytes, expectedFreeCapacityBytes);
-  VELOX_ASSERT_THROW(
-      AssertQueryBuilder(duckDbQueryRunner_)
-          .spillDirectory(spillDirectory->getPath())
-          .config(core::QueryConfig::kSpillEnabled, true)
-          .config(core::QueryConfig::kJoinSpillEnabled, true)
-          .queryCtx(
-              newQueryCtx(memoryManager, executor_.get(), kMemoryCapacity))
-          .maxDrivers(numDrivers)
-          .plan(PlanBuilder(planNodeIdGenerator)
-                    .values(probeInput, true)
-                    .hashJoin(
-                        {"p0"},
-                        {"b0"},
-                        PlanBuilder(planNodeIdGenerator)
-                            .values(buildInput, true)
-                            .planNode(),
-                        "",
-                        {"p0", "p1", "b0", "b1"},
-                        core::JoinType::kInner)
-                    .planNode())
-          .assertResults(
-              "SELECT probe.p0, probe.p1, build.b0, build.b1 FROM probe "
-              "INNER JOIN build ON probe.p0 = build.b0"),
-      "Simulated failure");
-  // This test uses on-demand created memory manager instead of the global
-  // one. We need to make sure any used memory got cleaned up before exiting
-  // the scope
-  waitForAllTasksToBeDeleted();
-  ASSERT_EQ(arbitrator->stats().freeCapacityBytes, expectedFreeCapacityBytes);
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, arbitrationTriggeredDuringParallelJoinBuild) {
-  std::unique_ptr<memory::MemoryManager> memoryManager = createMemoryManager();
-  const uint64_t numDrivers = 2;
-
-  // Large build side key product to bump hash mode to kHash instead of kArray
-  // to trigger parallel join build.
-  const uint64_t numBuildSideRows = 500;
-  auto buildKeyVector = makeFlatVector<int64_t>(
-      numBuildSideRows,
-      [](vector_size_t row) { return folly::Random::rand64(); });
-  auto buildSideVector = makeRowVector(
-      {"b0", "b1", "b2"}, {buildKeyVector, buildKeyVector, buildKeyVector});
-  std::vector<RowVectorPtr> buildSideVectors;
-  for (int i = 0; i < numDrivers; ++i) {
-    buildSideVectors.push_back(buildSideVector);
-  }
-  createDuckDbTable("build", buildSideVectors);
-
-  const uint64_t numProbeSideRows = 10;
-  auto probeKeyVector = makeFlatVector<int64_t>(
-      numProbeSideRows,
-      [&](vector_size_t row) { return buildKeyVector->valueAt(row); });
-  auto probeSideVector = makeRowVector(
-      {"p0", "p1", "p2"}, {probeKeyVector, probeKeyVector, probeKeyVector});
-  std::vector<RowVectorPtr> probeSideVectors;
-  for (int i = 0; i < numDrivers; ++i) {
-    probeSideVectors.push_back(probeSideVector);
-  }
-  createDuckDbTable("probe", probeSideVectors);
-
-  std::shared_ptr<core::QueryCtx> joinQueryCtx =
-      newQueryCtx(memoryManager.get(), executor_.get(), kMemoryCapacity);
-
-  const int64_t allocSize = 512LL << 20;
-  std::atomic<bool> parallelBuildTriggered{false};
-  std::atomic<memory::MemoryPool*> joinBuildPool{nullptr};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::HashTable::parallelJoinBuild",
-      std::function<void(memory::MemoryPool*)>([&](memory::MemoryPool* pool) {
-        parallelBuildTriggered = true;
-        // Pick the last running driver threads' pool for later memory
-        // allocation. This pick is rather arbitrary, as it is un-important
-        // which pool is going to be allocated from later in a parallel join's
-        // off-driver thread.
-        joinBuildPool = pool;
-      }));
-
-  std::atomic_bool offThreadAllocationTriggered{false};
-  folly::EventCount asyncMoveWait;
-  std::atomic<bool> asyncMoveWaitFlag{true};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::AsyncSource::prepare",
-      std::function<void(void*)>([&](void* /* unused */) {
-        if (!offThreadAllocationTriggered.exchange(true)) {
-          SCOPE_EXIT {
-            asyncMoveWaitFlag = false;
-            asyncMoveWait.notifyAll();
-          };
-          // Executed by the first thread hitting the test value location. This
-          // allocation will trigger arbitration and fail.
-          VELOX_ASSERT_THROW(
-              joinBuildPool.load()->allocate(allocSize),
-              "Exceeded memory pool cap");
-        }
-      }));
-
-  // Wait for allocation (hence arbitration) on the prepare thread to finish
-  // before calling AsyncSource::move(). This is to ensure no other AsyncSource
-  // (hence arbitration) is running on the driver thread (on-thread) before the
-  // ongoing arbitration finishes. Without ensuring this, the on-thread
-  // arbitration (triggered by calling AsyncSource::move() first) has
-  // thread-local driver context by default, defying the purpose of this test.
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::AsyncSource::move",
-      std::function<void(void*)>([&](void* /* unused */) {
-        asyncMoveWait.await([&]() { return !asyncMoveWaitFlag.load(); });
-      }));
-
-  std::vector<RowVectorPtr> probeInput = {probeSideVector};
-  std::vector<RowVectorPtr> buildInput = {buildSideVector};
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
-  AssertQueryBuilder(duckDbQueryRunner_)
-      .spillDirectory(spillDirectory->getPath())
-      .config(core::QueryConfig::kSpillEnabled, true)
-      .config(core::QueryConfig::kJoinSpillEnabled, true)
-      // Set very low table size threshold to trigger parallel build.
-      .config(core::QueryConfig::kMinTableRowsForParallelJoinBuild, 0)
-      // Set multiple hash build drivers to trigger parallel build.
-      .maxDrivers(numDrivers)
-      .queryCtx(joinQueryCtx)
-      .plan(PlanBuilder(planNodeIdGenerator)
-                .values(probeInput, true)
-                .hashJoin(
-                    {"p0", "p1", "p2"},
-                    {"b0", "b1", "b2"},
-                    PlanBuilder(planNodeIdGenerator)
-                        .values(buildInput, true)
-                        .planNode(),
-                    "",
-                    {"p0", "p1", "b0", "b1"},
-                    core::JoinType::kInner)
-                .planNode())
-      .assertResults(
-          "SELECT probe.p0, probe.p1, build.b0, build.b1 FROM probe "
-          "INNER JOIN build ON probe.p0 = build.b0 AND probe.p1 = build.b1 AND "
-          "probe.p2 = build.b2");
-  ASSERT_TRUE(parallelBuildTriggered);
-
-  // This test uses on-demand created memory manager instead of the global
-  // one. We need to make sure any used memory got cleaned up before exiting
-  // the scope
-  waitForAllTasksToBeDeleted();
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, arbitrationTriggeredByEnsureJoinTableFit) {
-  // Use manual spill injection other than spill injection framework. This is
-  // because spill injection framework does not allow fine grain spill within a
-  // single operator (We do not want to spill during addInput() but only during
-  // finishHashBuild()).
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::HashBuild::ensureTableFits",
-      std::function<void(Operator*)>(([&](Operator* op) {
-        Operator::ReclaimableSectionGuard guard(op);
-        memory::testingRunArbitration(op->pool());
-      })));
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .numDrivers(numDrivers_)
-      .injectSpill(false)
-      .spillDirectory(tempDirectory->getPath())
-      .keyTypes({BIGINT()})
-      .probeVectors(1600, 5)
-      .buildVectors(1500, 5)
-      .referenceQuery(
-          "SELECT t_k0, t_data, u_k0, u_data FROM t, u WHERE t.t_k0 = u.u_k0")
-      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-        const auto statsPair = taskSpilledStats(*task);
-        ASSERT_GT(statsPair.first.spilledBytes, 0);
-      })
-      .run();
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, joinBuildSpillError) {
-  const int kMemoryCapacity = 32 << 20;
-  // Set a small memory capacity to trigger spill.
-  std::unique_ptr<memory::MemoryManager> memoryManager =
-      createMemoryManager(kMemoryCapacity, 0);
-  const auto& arbitrator = memoryManager->arbitrator();
-  auto rowType = ROW(
-      {{"c0", INTEGER()},
-       {"c1", INTEGER()},
-       {"c2", VARCHAR()},
-       {"c3", VARCHAR()}});
-
-  std::vector<RowVectorPtr> vectors = createVectors(16, rowType, fuzzerOpts_);
-  createDuckDbTable(vectors);
-
-  std::shared_ptr<core::QueryCtx> joinQueryCtx =
-      newQueryCtx(memoryManager.get(), executor_.get(), kMemoryCapacity);
-
-  const int numDrivers = 4;
-  std::atomic<int> numAppends{0};
-  const std::string injectedErrorMsg("injected spillError");
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::SpillState::appendToPartition",
-      std::function<void(exec::SpillState*)>([&](exec::SpillState* state) {
-        if (++numAppends != numDrivers) {
-          return;
-        }
-        VELOX_FAIL(injectedErrorMsg);
-      }));
-
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
-  auto plan = PlanBuilder(planNodeIdGenerator)
-                  .values(vectors)
-                  .project({"c0 AS t0", "c1 AS t1", "c2 AS t2"})
-                  .hashJoin(
-                      {"t0"},
-                      {"u0"},
-                      PlanBuilder(planNodeIdGenerator)
-                          .values(vectors)
-                          .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
-                          .planNode(),
-                      "",
-                      {"t1"},
-                      core::JoinType::kAnti)
-                  .planNode();
-  VELOX_ASSERT_THROW(
-      AssertQueryBuilder(plan)
-          .queryCtx(joinQueryCtx)
-          .spillDirectory(spillDirectory->getPath())
-          .config(core::QueryConfig::kSpillEnabled, true)
-          .copyResults(pool()),
-      injectedErrorMsg);
-
-  waitForAllTasksToBeDeleted();
-  ASSERT_EQ(arbitrator->stats().numFailures, 1);
-
-  // Wait again here as this test uses on-demand created memory manager instead
-  // of the global one. We need to make sure any used memory got cleaned up
-  // before exiting the scope
-  waitForAllTasksToBeDeleted();
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, probeSpillOnWaitForPeers) {
-  // This test creates a scenario when tester probe thread finishes processing
-  // input, entering kWaitForPeers state, and the other thread is still
-  // processing, spill is triggered properly performed.
-
-  folly::EventCount startWait;
-  folly::Synchronized<std::string> testerOpName;
-  std::atomic_bool injectedSpillOnce{false};
-
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Driver::runInternal::getOutput",
-      std::function<void(Operator*)>([&](Operator* op) {
-        if (!isHashProbeMemoryPool(*op->pool())) {
-          return;
-        }
-        testerOpName.withWLock([&](std::string& opName) {
-          if (opName.empty()) {
-            opName = op->pool()->name();
-          }
-        });
-        if (op->pool()->name() == *testerOpName.rlock()) {
-          // Do not block tester thread.
-          return;
-        }
-        startWait.await([&]() { return injectedSpillOnce.load(); });
-      }));
-
-  // tester probe operator is guaranteed to be in kWaitForPeers state the next
-  // isBlocked() is called after noMoreInput() is called.
-  std::atomic_bool noMoreInputCalled{false};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Driver::runInternal::noMoreInput",
-      std::function<void(Operator*)>([&](Operator* op) {
-        if (!isHashProbeMemoryPool(*op->pool())) {
-          return;
-        }
-        noMoreInputCalled = true;
-      }));
-
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Driver::runInternal::isBlocked",
-      std::function<void(Operator*)>([&](Operator* op) {
-        if (!isHashProbeMemoryPool(*op->pool())) {
-          return;
-        }
-        if (injectedSpillOnce || !noMoreInputCalled) {
-          return;
-        }
-        injectedSpillOnce = true;
-        EXPECT_EQ(
-            dynamic_cast<HashProbe*>(op)->testingState(),
-            ProbeOperatorState::kWaitForPeers);
-        testingRunArbitration(op->pool());
-      }));
-
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Task::requestPauseLocked",
-      std::function<void(Task*)>([&](Task* task) { startWait.notifyAll(); }));
-
-  const uint64_t numDrivers{2};
-  std::shared_ptr<core::QueryCtx> joinQueryCtx =
-      newQueryCtx(memory::memoryManager(), executor_.get(), kMemoryCapacity);
-  auto rowType = ROW({{"c0", INTEGER()}, {"c1", INTEGER()}});
-  fuzzerOpts_.vectorSize = 20;
-  std::vector<RowVectorPtr> vectors = createVectors(6, rowType, fuzzerOpts_);
-  std::vector<RowVectorPtr> totalVectors;
-  for (auto i = 0; i < numDrivers; ++i) {
-    totalVectors.insert(totalVectors.end(), vectors.begin(), vectors.end());
-  }
-  createDuckDbTable(totalVectors);
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto plan = PlanBuilder(planNodeIdGenerator)
-                  .values(vectors, true)
-                  .project({"c0 AS t0", "c1 AS t1"})
-                  .hashJoin(
-                      {"t0"},
-                      {"u0"},
-                      PlanBuilder(planNodeIdGenerator)
-                          .values(vectors, true)
-                          .project({"c0 AS u0", "c1 AS u1"})
-                          .planNode(),
-                      "",
-                      {"t1"},
-                      core::JoinType::kInner)
-                  .planNode();
-
-  {
-    auto task =
-        AssertQueryBuilder(duckDbQueryRunner_)
-            .plan(plan)
-            .queryCtx(joinQueryCtx)
-            .spillDirectory(spillDirectory->getPath())
-            .config(core::QueryConfig::kSpillEnabled, true)
-            .maxDrivers(numDrivers)
-            .assertResults("SELECT a.c1 from tmp a join tmp b on a.c0 = b.c0");
-
-    auto opStats = toOperatorStats(task->taskStats());
-    ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
-    ASSERT_EQ(opStats.at("HashBuild").spilledBytes, 0);
-
-    const auto* arbitrator = memory::memoryManager()->arbitrator();
-    ASSERT_GT(arbitrator->stats().reclaimedUsedBytes, 0);
-  }
-  waitForAllTasksToBeDeleted();
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, taskWaitTimeout) {
-  const int queryMemoryCapacity = 128 << 20;
-  // Creates a large number of vectors based on the query capacity to trigger
-  // memory arbitration.
-  fuzzerOpts_.vectorSize = 10'000;
-  auto rowType = ROW(
-      {{"c0", INTEGER()},
-       {"c1", INTEGER()},
-       {"c2", VARCHAR()},
-       {"c3", VARCHAR()}});
-  const auto vectors =
-      createVectors(rowType, queryMemoryCapacity / 2, fuzzerOpts_);
-  const int numDrivers = 4;
-  const auto expectedResult =
-      runHashJoinTask(vectors, nullptr, false, numDrivers, pool(), false).data;
-
-  for (uint64_t timeoutMs : {1'000, 30'000}) {
-    SCOPED_TRACE(fmt::format("timeout {}", succinctMillis(timeoutMs)));
-    auto memoryManager = createMemoryManager(512 << 20, 0, timeoutMs);
-    auto queryCtx =
-        newQueryCtx(memoryManager.get(), executor_.get(), queryMemoryCapacity);
-
-    // Set test injection to block one hash build operator to inject delay when
-    // memory reclaim waits for task to pause.
-    folly::EventCount buildBlockWait;
-    std::atomic<bool> buildBlockWaitFlag{true};
-    std::atomic<bool> blockOneBuild{true};
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve",
-        std::function<void(memory::MemoryPool*)>([&](memory::MemoryPool* pool) {
-          const std::string re(".*HashBuild");
-          if (!RE2::FullMatch(pool->name(), re)) {
-            return;
-          }
-          if (!blockOneBuild.exchange(false)) {
-            return;
-          }
-          buildBlockWait.await([&]() { return !buildBlockWaitFlag.load(); });
-        }));
-
-    folly::EventCount taskPauseWait;
-    std::atomic<bool> taskPauseWaitFlag{false};
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Task::requestPauseLocked",
-        std::function<void(Task*)>(([&](Task* /*unused*/) {
-          taskPauseWaitFlag = true;
-          taskPauseWait.notifyAll();
-        })));
-
-    std::thread queryThread([&]() {
-      // We expect failure on short time out.
-      if (timeoutMs == 1'000) {
-        VELOX_ASSERT_THROW(
-            runHashJoinTask(
-                vectors,
-                queryCtx,
-                false,
-                numDrivers,
-                pool(),
-                true,
-                expectedResult),
-            "Memory reclaim failed to wait");
-      } else {
-        // We expect succeed on large time out or no timeout.
-        const auto result = runHashJoinTask(
-            vectors, queryCtx, false, numDrivers, pool(), true, expectedResult);
-        auto taskStats = exec::toPlanStats(result.task->taskStats());
-        auto& planStats = taskStats.at(result.planNodeId);
-        ASSERT_GT(planStats.spilledBytes, 0);
-      }
-    });
-
-    // Wait for task pause to reach, and then delay for a while before unblock
-    // the blocked hash build operator.
-    taskPauseWait.await([&]() { return taskPauseWaitFlag.load(); });
-    // Wait for two seconds and expect the short reclaim wait timeout.
-    std::this_thread::sleep_for(std::chrono::seconds(2));
-    // Unblock the blocked build operator to let memory reclaim proceed.
-    buildBlockWaitFlag = false;
-    buildBlockWait.notifyAll();
-
-    queryThread.join();
-
-    // This test uses on-demand created memory manager instead of the global
-    // one. We need to make sure any used memory got cleaned up before exiting
-    // the scope
-    waitForAllTasksToBeDeleted();
-  }
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpill) {
-  struct {
-    bool triggerBuildSpill;
-    // Triggers after no more input or not.
-    bool afterNoMoreInput;
-    // The index of get output call to trigger probe side spilling.
-    int probeOutputIndex;
-
-    std::string debugString() const {
-      return fmt::format(
-          "triggerBuildSpill: {}, afterNoMoreInput: {}, probeOutputIndex: {}",
-          triggerBuildSpill,
-          afterNoMoreInput,
-          probeOutputIndex);
-    }
-  } testSettings[] = {
-      {false, false, 0},
-      {false, false, 1},
-      {false, false, 10},
-      {false, true, 0},
-      {true, false, 0},
-      {true, false, 1},
-      {true, false, 10},
-      {true, true, 0}};
-
-  for (const auto& testData : testSettings) {
-    SCOPED_TRACE(testData.debugString());
-
-    std::atomic_bool injectBuildSpillOnce{true};
-    std::atomic_int buildInputCount{0};
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Driver::runInternal::addInput",
-        std::function<void(Operator*)>([&](Operator* op) {
-          if (!testData.triggerBuildSpill) {
-            return;
-          }
-          if (!isHashBuildMemoryPool(*op->pool())) {
-            return;
-          }
-          if (buildInputCount++ != 1) {
-            return;
-          }
-          if (!injectBuildSpillOnce.exchange(false)) {
-            return;
-          }
-          testingRunArbitration(op->pool());
-        }));
-
-    std::atomic_bool injectProbeSpillOnce{true};
-    std::atomic_int probeOutputCount{0};
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Driver::runInternal::getOutput",
-        std::function<void(Operator*)>([&](Operator* op) {
-          if (!isHashProbeMemoryPool(*op->pool())) {
-            return;
-          }
-          if (testData.afterNoMoreInput) {
-            if (!op->testingNoMoreInput()) {
-              return;
-            }
-          } else {
-            if (probeOutputCount++ != testData.probeOutputIndex) {
-              return;
-            }
-          }
-          if (!injectProbeSpillOnce.exchange(false)) {
-            return;
-          }
-          testingRunArbitration(op->pool());
-        }));
-
-    fuzzerOpts_.vectorSize = 128;
-    auto probeVectors = createVectors(10, probeType_, fuzzerOpts_);
-    auto buildVectors = createVectors(20, buildType_, fuzzerOpts_);
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .numDrivers(1)
-        .spillDirectory(spillDirectory->getPath())
-        .probeKeys({"t_k1"})
-        .probeVectors(std::move(probeVectors))
-        .buildKeys({"u_k1"})
-        .buildVectors(std::move(buildVectors))
-        .config(core::QueryConfig::kJoinSpillEnabled, "true")
-        .joinType(core::JoinType::kRight)
-        .joinOutputLayout({"t_k1", "t_k2", "u_k1", "t_v1"})
-        .referenceQuery(
-            "SELECT t.t_k1, t.t_k2, u.u_k1, t.t_v1 FROM t RIGHT JOIN u ON t.t_k1 = u.u_k1")
-        .injectSpill(false)
-        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-          auto opStats = toOperatorStats(task->taskStats());
-          ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
-          if (testData.triggerBuildSpill) {
-            ASSERT_GT(opStats.at("HashBuild").spilledBytes, 0);
-          } else {
-            ASSERT_EQ(opStats.at("HashBuild").spilledBytes, 0);
-          }
-
-          const auto* arbitrator = memory::memoryManager()->arbitrator();
-          ASSERT_GT(arbitrator->stats().numRequests, 0);
-          ASSERT_GT(arbitrator->stats().reclaimedUsedBytes, 0);
-        })
-        .run();
-  }
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillInMiddeOfLastOutputProcessing) {
-  std::atomic_int outputCountAfterNoMoreInout{0};
-  std::atomic_bool injectOnce{true};
-  ::facebook::velox::common::testutil::ScopedTestValue abc(
-      "facebook::velox::exec::Driver::runInternal::getOutput",
-      std::function<void(Operator*)>([&](Operator* op) {
-        if (!isHashProbeMemoryPool(*op->pool())) {
-          return;
-        }
-        if (!op->testingNoMoreInput()) {
-          return;
-        }
-        if (outputCountAfterNoMoreInout++ != 1) {
-          return;
-        }
-        if (!injectOnce.exchange(false)) {
-          return;
-        }
-        testingRunArbitration(op->pool());
-      }));
-
-  fuzzerOpts_.vectorSize = 128;
-  auto probeVectors = createVectors(10, probeType_, fuzzerOpts_);
-  auto buildVectors = createVectors(20, buildType_, fuzzerOpts_);
-
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .numDrivers(1)
-      .spillDirectory(spillDirectory->getPath())
-      .probeKeys({"t_k1"})
-      .probeVectors(std::move(probeVectors))
-      .buildKeys({"u_k1"})
-      .buildVectors(std::move(buildVectors))
-      .config(core::QueryConfig::kJoinSpillEnabled, "true")
-      .config(core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
-      .joinType(core::JoinType::kRight)
-      .joinOutputLayout({"t_k1", "t_k2", "u_k1", "t_v1"})
-      .referenceQuery(
-          "SELECT t.t_k1, t.t_k2, u.u_k1, t.t_v1 FROM t RIGHT JOIN u ON t.t_k1 = u.u_k1")
-      .injectSpill(false)
-      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-        auto opStats = toOperatorStats(task->taskStats());
-        ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
-        // Verifies that we only spill the output which is single partitioned
-        // but not the hash table.
-        ASSERT_EQ(opStats.at("HashProbe").spilledPartitions, 1);
-      })
-      .run();
-}
-
-// Inject probe-side spilling in the middle of output processing. If
-// 'recursiveSpill' is true, we trigger probe-spilling when probe the hash table
-// built from spilled data.
-DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillInMiddeOfOutputProcessing) {
-  for (bool recursiveSpill : {false, true}) {
-    std::atomic_int buildInputCount{0};
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Driver::runInternal::addInput",
-        std::function<void(Operator*)>([&](Operator* op) {
-          if (!isHashBuildMemoryPool(*op->pool())) {
-            return;
-          }
-          if (!recursiveSpill) {
-            return;
-          }
-          // Trigger spill after the build side has processed some rows.
-          if (buildInputCount++ != 1) {
-            return;
-          }
-          testingRunArbitration(op->pool());
-        }));
-
-    std::atomic_bool injectProbeSpillOnce{true};
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Driver::runInternal::getOutput",
-        std::function<void(Operator*)>([&](Operator* op) {
-          if (!isHashProbeMemoryPool(*op->pool())) {
-            return;
-          }
-
-          if (op->testingHasInput()) {
-            return;
-          }
-          if (recursiveSpill) {
-            if (static_cast<HashProbe*>(op)->testingHasInputSpiller()) {
-              return;
-            }
-          }
-          if (!injectProbeSpillOnce.exchange(false)) {
-            return;
-          }
-          testingRunArbitration(op->pool());
-        }));
-
-    fuzzerOpts_.vectorSize = 128;
-    auto probeVectors = createVectors(10, probeType_, fuzzerOpts_);
-    auto buildVectors = createVectors(20, buildType_, fuzzerOpts_);
-
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .numDrivers(1)
-        .spillDirectory(spillDirectory->getPath())
-        .probeKeys({"t_k1"})
-        .probeVectors(std::move(probeVectors))
-        .buildKeys({"u_k1"})
-        .buildVectors(std::move(buildVectors))
-        .config(core::QueryConfig::kJoinSpillEnabled, "true")
-        .config(
-            core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
-        .joinType(core::JoinType::kRight)
-        .joinOutputLayout({"t_k1", "t_k2", "u_k1", "t_v1"})
-        .referenceQuery(
-            "SELECT t.t_k1, t.t_k2, u.u_k1, t.t_v1 FROM t RIGHT JOIN u ON t.t_k1 = u.u_k1")
-        .injectSpill(false)
-        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-          auto opStats = toOperatorStats(task->taskStats());
-          ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
-          ASSERT_GT(opStats.at("HashProbe").spilledPartitions, 1);
-        })
-        .run();
-  }
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillWhenOneOfProbeFinish) {
-  const int numDrivers{3};
-
-  std::atomic_bool probeWaitFlag{true};
-  folly::EventCount probeWait;
-  std::atomic_int numBlockedProbeOps{0};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Driver::runInternal::getOutput",
-      std::function<void(Operator*)>([&](Operator* op) {
-        if (!isHashProbeMemoryPool(*op->pool())) {
-          return;
-        }
-        if (++numBlockedProbeOps <= numDrivers - 1) {
-          probeWait.await([&]() { return !probeWaitFlag.load(); });
-          return;
-        }
-      }));
-
-  std::atomic_bool notifyOnce{true};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Driver::runInternal::noMoreInput",
-      std::function<void(Operator*)>([&](Operator* op) {
-        if (!isHashProbeMemoryPool(*op->pool())) {
-          return;
-        }
-        if (!notifyOnce.exchange(false)) {
-          return;
-        }
-        probeWaitFlag = false;
-        probeWait.notifyAll();
-      }));
-
-  std::thread queryThread([&]() {
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .numDrivers(numDrivers, true, true)
-        .spillDirectory(spillDirectory->getPath())
-        .keyTypes({BIGINT()})
-        .probeVectors(32, 5)
-        .buildVectors(32, 5)
-        .config(core::QueryConfig::kJoinSpillEnabled, "true")
-        .referenceQuery(
-            "SELECT t_k0, t_data, u_k0, u_data FROM t, u WHERE t.t_k0 = u.u_k0")
-        .injectSpill(false)
-        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-          auto opStats = toOperatorStats(task->taskStats());
-          ASSERT_EQ(opStats.at("HashBuild").spilledBytes, 0);
-          ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
-        })
-        .run();
-  });
-  // Wait until one of the hash probe operator has finished.
-  probeWait.await([&]() { return !probeWaitFlag.load(); });
-  memory::testingRunArbitration();
-  queryThread.join();
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillExceedLimit) {
-  // If 'buildTriggerSpill' is true, then spilling is triggered by hash build.
-  for (const bool buildTriggerSpill : {false, true}) {
-    SCOPED_TRACE(fmt::format("buildTriggerSpill {}", buildTriggerSpill));
-
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve",
-        std::function<void(memory::MemoryPool*)>([&](memory::MemoryPool* pool) {
-          if (buildTriggerSpill && !isHashBuildMemoryPool(*pool)) {
-            return;
-          }
-          if (!buildTriggerSpill && !isHashProbeMemoryPool(*pool)) {
-            return;
-          }
-          testingRunArbitration(pool);
-        }));
-
-    fuzzerOpts_.vectorSize = 128;
-    auto probeVectors = createVectors(32, probeType_, fuzzerOpts_);
-    auto buildVectors = createVectors(64, buildType_, fuzzerOpts_);
-    for (int i = 0; i < probeVectors.size(); ++i) {
-      const auto probeKeyChannel = probeType_->getChildIdx("t_k1");
-      const auto buildKeyChannle = buildType_->getChildIdx("u_k1");
-      probeVectors[i]->childAt(probeKeyChannel) =
-          buildVectors[i]->childAt(buildKeyChannle);
-    }
-
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .numDrivers(1)
-        .spillDirectory(spillDirectory->getPath())
-        .probeKeys({"t_k1"})
-        .probeVectors(std::move(probeVectors))
-        .buildKeys({"u_k1"})
-        .buildVectors(std::move(buildVectors))
-        .config(core::QueryConfig::kMaxSpillLevel, "1")
-        .config(core::QueryConfig::kSpillNumPartitionBits, "1")
-        .config(core::QueryConfig::kJoinSpillEnabled, "true")
-        // Set small write buffer size to have small vectors to read from
-        // spilled data.
-        .config(core::QueryConfig::kSpillWriteBufferSize, "1")
-        .config(
-            core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
-        .joinType(core::JoinType::kRight)
-        .joinOutputLayout({"t_k1", "t_k2", "u_k1", "t_v1"})
-        .referenceQuery(
-            "SELECT t.t_k1, t.t_k2, u.u_k1, t.t_v1 FROM t RIGHT JOIN u ON t.t_k1 = u.u_k1")
-        .injectSpill(false)
-        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-          auto opStats = toOperatorStats(task->taskStats());
-          if (buildTriggerSpill) {
-            ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
-            ASSERT_GT(opStats.at("HashBuild").spilledBytes, 0);
-          } else {
-            ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
-            ASSERT_EQ(opStats.at("HashBuild").spilledBytes, 0);
-          }
-          ASSERT_GT(
-              opStats.at("HashProbe")
-                  .runtimeStats[Operator::kExceededMaxSpillLevel]
-                  .sum,
-              0);
-          ASSERT_GT(
-              opStats.at("HashBuild")
-                  .runtimeStats[Operator::kExceededMaxSpillLevel]
-                  .sum,
-              0);
-        })
-        .run();
-  }
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillUnderNonReclaimableSection) {
-  std::atomic_bool injectOnce{true};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::common::memory::MemoryPoolImpl::allocateNonContiguous",
-      std::function<void(memory::MemoryPool*)>([&](memory::MemoryPool* pool) {
-        if (!isHashProbeMemoryPool(*pool)) {
-          return;
-        }
-        if (!injectOnce.exchange(false)) {
-          return;
-        }
-        auto* arbitrator = memory::memoryManager()->arbitrator();
-        const auto numNonReclaimableAttempts =
-            arbitrator->stats().numNonReclaimableAttempts;
-        testingRunArbitration(pool);
-        // Verifies that we run into non-reclaimable section when reclaim from
-        // hash probe.
-        ASSERT_EQ(
-            arbitrator->stats().numNonReclaimableAttempts,
-            numNonReclaimableAttempts + 1);
-      }));
-
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .numDrivers(1)
-      .spillDirectory(spillDirectory->getPath())
-      .keyTypes({BIGINT()})
-      .probeVectors(32, 5)
-      .buildVectors(32, 5)
-      .config(core::QueryConfig::kJoinSpillEnabled, "true")
-      .referenceQuery(
-          "SELECT t_k0, t_data, u_k0, u_data FROM t, u WHERE t.t_k0 = u.u_k0")
-      .injectSpill(false)
-      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-        auto opStats = toOperatorStats(task->taskStats());
-        ASSERT_EQ(opStats.at("HashProbe").spilledBytes, 0);
-        ASSERT_EQ(opStats.at("HashBuild").spilledBytes, 0);
-      })
-      .run();
-}
-
-// This test case is to cover the case that hash probe trigger spill for right
-// semi join types and the pending input needs to be processed in multiple
-// steps.
-DEBUG_ONLY_TEST_F(HashJoinTest, spillOutputWithRightSemiJoins) {
-  for (const auto joinType :
-       {core::JoinType::kRightSemiFilter, core::JoinType::kRightSemiProject}) {
-    std::atomic_bool injectOnce{true};
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Driver::runInternal::getOutput",
-        std::function<void(Operator*)>([&](Operator* op) {
-          if (op->operatorCtx()->operatorType() != "HashProbe") {
-            return;
-          }
-          if (!op->testingHasInput()) {
-            return;
-          }
-          if (!injectOnce.exchange(false)) {
-            return;
-          }
-          testingRunArbitration(op->pool());
-        }));
-
-    std::string duckDbSqlReference;
-    std::vector<std::string> joinOutputLayout;
-    bool nullAware{false};
-    if (joinType == core::JoinType::kRightSemiProject) {
-      duckDbSqlReference = "SELECT u_k2, u_k1 IN (SELECT t_k1 FROM t) FROM u";
-      joinOutputLayout = {"u_k2", "match"};
-      // Null aware is only supported for semi projection join type.
-      nullAware = true;
-    } else {
-      duckDbSqlReference =
-          "SELECT u_k2 FROM u WHERE u_k1 IN (SELECT t_k1 FROM t)";
-      joinOutputLayout = {"u_k2"};
-    }
-
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .numDrivers(1)
-        .spillDirectory(spillDirectory->getPath())
-        .probeType(probeType_)
-        .probeVectors(128, 3)
-        .probeKeys({"t_k1"})
-        .buildType(buildType_)
-        .buildVectors(128, 4)
-        .buildKeys({"u_k1"})
-        .joinType(joinType)
-        // Set a small number of output rows to process the input in multiple
-        // steps.
-        .config(
-            core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
-        .injectSpill(false)
-        .joinOutputLayout(std::move(joinOutputLayout))
-        .nullAware(nullAware)
-        .referenceQuery(duckDbSqlReference)
-        .run();
-  }
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, spillCheckOnLeftSemiFilterWithDynamicFilters) {
-  const int32_t numSplits = 10;
-  const int32_t numRowsProbe = 333;
-  const int32_t numRowsBuild = 100;
-
-  std::vector<RowVectorPtr> probeVectors;
-  probeVectors.reserve(numSplits);
-
-  std::vector<std::shared_ptr<TempFilePath>> tempFiles;
-  for (int32_t i = 0; i < numSplits; ++i) {
-    auto rowVector = makeRowVector({
-        makeFlatVector<int32_t>(
-            numRowsProbe, [&](auto row) { return row - i * 10; }),
-        makeFlatVector<int64_t>(numRowsProbe, [](auto row) { return row; }),
-    });
-    probeVectors.push_back(rowVector);
-    tempFiles.push_back(TempFilePath::create());
-    writeToFile(tempFiles.back()->getPath(), rowVector);
-  }
-  auto makeInputSplits = [&](const core::PlanNodeId& nodeId) {
-    return [&] {
-      std::vector<exec::Split> probeSplits;
-      for (auto& file : tempFiles) {
-        probeSplits.push_back(
-            exec::Split(makeHiveConnectorSplit(file->getPath())));
-      }
-      SplitInput splits;
-      splits.emplace(nodeId, probeSplits);
-      return splits;
-    };
-  };
-
-  // 100 key values in [35, 233] range.
-  std::vector<RowVectorPtr> buildVectors;
-  for (int i = 0; i < 5; ++i) {
-    buildVectors.push_back(makeRowVector({
-        makeFlatVector<int32_t>(
-            numRowsBuild / 5,
-            [i](auto row) { return 35 + 2 * (row + i * numRowsBuild / 5); }),
-        makeFlatVector<int64_t>(numRowsBuild / 5, [](auto row) { return row; }),
-    }));
-  }
-  std::vector<RowVectorPtr> keyOnlyBuildVectors;
-  for (int i = 0; i < 5; ++i) {
-    keyOnlyBuildVectors.push_back(
-        makeRowVector({makeFlatVector<int32_t>(numRowsBuild / 5, [i](auto row) {
-          return 35 + 2 * (row + i * numRowsBuild / 5);
-        })}));
-  }
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  auto probeType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
-
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-
-  auto buildSide = PlanBuilder(planNodeIdGenerator, pool_.get())
-                       .values(buildVectors)
-                       .project({"c0 AS u_c0", "c1 AS u_c1"})
-                       .planNode();
-
-  // Left semi join.
-  core::PlanNodeId probeScanId;
-  core::PlanNodeId joinNodeId;
-  const auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
-                      .tableScan(probeType)
-                      .capturePlanNodeId(probeScanId)
-                      .hashJoin(
-                          {"c0"},
-                          {"u_c0"},
-                          buildSide,
-                          "",
-                          {"c0", "c1"},
-                          core::JoinType::kLeftSemiFilter)
-                      .capturePlanNodeId(joinNodeId)
-                      .project({"c0", "c1 + 1"})
-                      .planNode();
-
-  std::atomic_bool injectOnce{true};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Driver::runInternal::getOutput",
-      std::function<void(Operator*)>([&](Operator* op) {
-        if (op->operatorCtx()->operatorType() != "HashProbe") {
-          return;
-        }
-        if (!op->testingHasInput()) {
-          return;
-        }
-        if (!injectOnce.exchange(false)) {
-          return;
-        }
-        testingRunArbitration(op->pool());
-      }));
-
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(std::move(op))
-      .makeInputSplits(makeInputSplits(probeScanId))
-      .spillDirectory(spillDirectory->getPath())
-      .injectSpill(false)
-      .referenceQuery(
-          "SELECT t.c0, t.c1 + 1 FROM t WHERE t.c0 IN (SELECT c0 FROM u)")
-      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-        // Verify spill hasn't triggered.
-        auto taskStats = exec::toPlanStats(task->taskStats());
-        auto& planStats = taskStats.at(joinNodeId);
-        ASSERT_GT(planStats.spilledBytes, 0);
-      })
-      .run();
-}
-
-// This test is to verify there is no memory reservation made before hash probe
-// start processing. This can cause unnecessary spill and query OOM under some
-// real workload with many stages as each hash probe might reserve non-trivial
-// amount of memory.
-DEBUG_ONLY_TEST_F(
+VELOX_INSTANTIATE_TEST_SUITE_P(
     HashJoinTest,
-    hashProbeMemoryReservationCheckBeforeProbeStartWithSpillEnabled) {
-  fuzzerOpts_.vectorSize = 128;
-  auto probeVectors = createVectors(10, probeType_, fuzzerOpts_);
-  auto buildVectors = createVectors(20, buildType_, fuzzerOpts_);
-
-  std::atomic_bool checkOnce{true};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Driver::runInternal::addInput",
-      std::function<void(Operator*)>(([&](Operator* op) {
-        if (op->operatorType() != "HashProbe") {
-          return;
-        }
-        if (!checkOnce.exchange(false)) {
-          return;
-        }
-        ASSERT_EQ(op->pool()->usedBytes(), 0);
-        ASSERT_EQ(op->pool()->reservedBytes(), 0);
-      })));
-
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .numDrivers(1)
-      .spillDirectory(spillDirectory->getPath())
-      .probeKeys({"t_k1"})
-      .probeVectors(std::move(probeVectors))
-      .buildKeys({"u_k1"})
-      .buildVectors(std::move(buildVectors))
-      .config(core::QueryConfig::kJoinSpillEnabled, "true")
-      .joinType(core::JoinType::kInner)
-      .joinOutputLayout({"t_k1", "t_k2", "u_k1", "t_v1"})
-      .referenceQuery(
-          "SELECT t.t_k1, t.t_k2, u.u_k1, t.t_v1 FROM t JOIN u ON t.t_k1 = u.u_k1")
-      .injectSpill(true)
-      .verifier([&](const std::shared_ptr<Task>& task, bool injectSpill) {
-        if (!injectSpill) {
-          return;
-        }
-        auto opStats = toOperatorStats(task->taskStats());
-        ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
-        ASSERT_GE(opStats.at("HashProbe").spilledPartitions, 1);
-      })
-      .run();
-}
-
-TEST_F(HashJoinTest, nanKeys) {
-  // Verify the NaN values with different binary representations are considered
-  // equal.
-  static const double kNan = std::numeric_limits<double>::quiet_NaN();
-  static const double kSNaN = std::numeric_limits<double>::signaling_NaN();
-  auto probeInput = makeRowVector(
-      {makeFlatVector<double>({kNan, kSNaN}), makeFlatVector<int64_t>({1, 2})});
-  auto buildInput = makeRowVector({makeFlatVector<double>({kNan, 1})});
-
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto plan = PlanBuilder(planNodeIdGenerator)
-                  .values({probeInput})
-                  .project({"c0 AS t0", "c1 AS t1"})
-                  .hashJoin(
-                      {"t0"},
-                      {"u0"},
-                      PlanBuilder(planNodeIdGenerator)
-                          .values({buildInput})
-                          .project({"c0 AS u0"})
-                          .planNode(),
-                      "",
-                      {"t0", "u0", "t1"},
-                      core::JoinType::kLeft)
-                  .planNode();
-  auto queryCtx = core::QueryCtx::create(executor_.get());
-  auto result =
-      AssertQueryBuilder(plan).queryCtx(queryCtx).copyResults(pool_.get());
-  auto expected = makeRowVector(
-      {makeFlatVector<double>({kNan, kNan}),
-       makeFlatVector<double>({kNan, kNan}),
-       makeFlatVector<int64_t>({1, 2})});
-  facebook::velox::test::assertEqualVectors(expected, result);
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, spillOnBlockedProbe) {
-  auto blockedOperatorFactoryUniquePtr =
-      std::make_unique<BlockedOperatorFactory>();
-  auto blockedOperatorFactory = blockedOperatorFactoryUniquePtr.get();
-  Operator::registerOperator(std::move(blockedOperatorFactoryUniquePtr));
-
-  std::vector<ContinuePromise> unblockPromises;
-  std::atomic_bool shouldBlock{true};
-  blockedOperatorFactory->setBlockedCb([&](ContinueFuture* future) {
-    if (!shouldBlock) {
-      return BlockingReason::kNotBlocked;
-    }
-    auto [p, f] = makeVeloxContinuePromiseContract("Blocked Operator");
-    *future = std::move(f);
-    unblockPromises.push_back(std::move(p));
-    return BlockingReason::kWaitForConsumer;
-  });
-
-  folly::EventCount arbitrationWait;
-  std::atomic<bool> arbitrationWaitFlag{true};
-  ::facebook::velox::common::testutil::ScopedTestValue _scopedTestValue15(
-      "facebook::velox::exec::HashBuild::finishHashBuild",
-      std::function<void(exec::HashBuild*)>([&](Operator* /* unused */) {
-        arbitrationWaitFlag = false;
-        arbitrationWait.notifyAll();
-      }));
-  std::thread arbitrationThread([&]() {
-    arbitrationWait.await([&]() { return !arbitrationWaitFlag.load(); });
-    memory::memoryManager()->shrinkPools();
-    shouldBlock = false;
-    for (auto& unblockPromise : unblockPromises) {
-      unblockPromise.setValue();
-    }
-  });
-
-  auto rowType = ROW({{"c0", INTEGER()}, {"c1", INTEGER()}});
-  std::vector<RowVectorPtr> vectors = createVectors(1, rowType, fuzzerOpts_);
-  createDuckDbTable(vectors);
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
-  auto plan = PlanBuilder(planNodeIdGenerator)
-                  .values(vectors)
-                  .project({"c0 AS t0", "c1 AS t1"})
-                  .hashJoin(
-                      {"t0"},
-                      {"u0"},
-                      PlanBuilder(planNodeIdGenerator)
-                          .values(vectors)
-                          .project({"c0 AS u0", "c1 AS u1"})
-                          .planNode(),
-                      "",
-                      {"t1"},
-                      core::JoinType::kInner)
-                  .addNode([&](std::string id, core::PlanNodePtr input) {
-                    return std::make_shared<BlockedNode>(id, input);
-                  })
-                  .planNode();
-
-  {
-    auto task =
-        AssertQueryBuilder(duckDbQueryRunner_)
-            .plan(plan)
-            .queryCtx(newQueryCtx(
-                memory::memoryManager(), executor_.get(), kMemoryCapacity))
-            .spillDirectory(spillDirectory->getPath())
-            .config(core::QueryConfig::kSpillEnabled, true)
-            .maxDrivers(1)
-            .assertResults("SELECT a.c1 from tmp a join tmp b on a.c0 = b.c0");
-    auto joinSpillStats = taskSpilledStats(*task);
-    auto buildSpillStats = joinSpillStats.first;
-    ASSERT_GT(buildSpillStats.spilledBytes, 0);
-  }
-  arbitrationThread.join();
-  waitForAllTasksToBeDeleted(30'000'000);
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, buildReclaimedMemoryReport) {
-  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
-  const int32_t numBuildVectors = 3;
-  std::vector<RowVectorPtr> buildVectors;
-  for (int32_t i = 0; i < numBuildVectors; ++i) {
-    VectorFuzzer fuzzer({.vectorSize = 200}, pool());
-    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
-  }
-
-  const int32_t numProbeVectors = 3;
-  std::vector<RowVectorPtr> probeVectors;
-  for (int32_t i = 0; i < numProbeVectors; ++i) {
-    VectorFuzzer fuzzer({.vectorSize = 200}, pool());
-    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
-  }
-
-  const int numDrivers{2};
-  // duckdb need double probe and build inputs as we run two drivers for hash
-  // join.
-  std::vector<RowVectorPtr> totalProbeVectors = probeVectors;
-  totalProbeVectors.insert(
-      totalProbeVectors.end(), probeVectors.begin(), probeVectors.end());
-  std::vector<RowVectorPtr> totalBuildVectors = buildVectors;
-  totalBuildVectors.insert(
-      totalBuildVectors.end(), buildVectors.begin(), buildVectors.end());
-
-  createDuckDbTable("t", totalProbeVectors);
-  createDuckDbTable("u", totalBuildVectors);
-
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
-  auto queryPool = memory::memoryManager()->addRootPool(
-      "", kMaxBytes, memory::MemoryReclaimer::create());
-
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto plan = PlanBuilder(planNodeIdGenerator)
-                  .values(probeVectors, true)
-                  .hashJoin(
-                      {"t_k1"},
-                      {"u_k1"},
-                      PlanBuilder(planNodeIdGenerator)
-                          .values(buildVectors, true)
-                          .planNode(),
-                      "",
-                      concat(probeType_->names(), buildType_->names()))
-                  .planNode();
-
-  folly::EventCount driverWait;
-  std::atomic_bool driverWaitFlag{true};
-  folly::EventCount taskWait;
-  std::atomic_bool taskWaitFlag{true};
-
-  Operator* op{nullptr};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::HashBuild::finishHashBuild",
-      std::function<void(Operator*)>(([&](Operator* testOp) { op = testOp; })));
-
-  std::atomic_bool injectOnce{true};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve",
-      std::function<void(memory::MemoryPoolImpl*)>(
-          ([&](memory::MemoryPoolImpl* pool) {
-            if (op == nullptr || op->pool() != pool) {
-              return;
-            }
-            ASSERT_TRUE(isHashBuildMemoryPool(*pool));
-            ASSERT_TRUE(op->canReclaim());
-            ASSERT_GT(op->pool()->usedBytes(), 0);
-            ASSERT_GT(
-                op->pool()->parent()->reservedBytes(),
-                op->pool()->reservedBytes());
-            if (!injectOnce.exchange(false)) {
-              return;
-            }
-            uint64_t reclaimableBytes{0};
-            const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
-            ASSERT_TRUE(reclaimable);
-            ASSERT_GT(reclaimableBytes, 0);
-            auto* driver = op->operatorCtx()->driver();
-            TestSuspendedSection suspendedSection(driver);
-            taskWaitFlag = false;
-            taskWait.notifyAll();
-            driverWait.await([&]() { return !driverWaitFlag.load(); });
-          })));
-
-  std::thread taskThread([&]() {
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .numDrivers(numDrivers)
-        .planNode(plan)
-        .queryPool(std::move(queryPool))
-        .injectSpill(false)
-        .spillDirectory(tempDirectory->getPath())
-        .referenceQuery(
-            "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
-        .config(core::QueryConfig::kSpillStartPartitionBit, "29")
-        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-          const auto statsPair = taskSpilledStats(*task);
-          ASSERT_GT(statsPair.first.spilledBytes, 0);
-          ASSERT_EQ(statsPair.first.spilledPartitions, 16);
-          ASSERT_GT(statsPair.second.spilledBytes, 0);
-          ASSERT_EQ(statsPair.second.spilledPartitions, 16);
-          verifyTaskSpilledRuntimeStats(*task, true);
-        })
-        .run();
-  });
-
-  taskWait.await([&]() { return !taskWaitFlag.load(); });
-  ASSERT_TRUE(op != nullptr);
-  auto task = op->operatorCtx()->task();
-  auto* nodePool = op->pool()->parent();
-  const auto nodeMemoryUsage = nodePool->reservedBytes();
-  {
-    memory::ScopedMemoryArbitrationContext ctx(op->pool());
-    const uint64_t reclaimedBytes = task->pool()->reclaim(
-        task->pool()->capacity(), 1'000'000, reclaimerStats_);
-    ASSERT_GT(reclaimedBytes, 0);
-    ASSERT_EQ(nodeMemoryUsage - nodePool->reservedBytes(), reclaimedBytes);
-  }
-  // Verify all the memory has been freed.
-  ASSERT_EQ(nodePool->reservedBytes(), 0);
-
-  driverWaitFlag = false;
-  driverWait.notifyAll();
-  task.reset();
-
-  taskThread.join();
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, probeReclaimedMemoryReport) {
-  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
-  const int32_t numBuildVectors = 3;
-  std::vector<RowVectorPtr> buildVectors;
-  for (int32_t i = 0; i < numBuildVectors; ++i) {
-    VectorFuzzer fuzzer({.vectorSize = 200}, pool());
-    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
-  }
-
-  const int32_t numProbeVectors = 3;
-  std::vector<RowVectorPtr> probeVectors;
-  for (int32_t i = 0; i < numProbeVectors; ++i) {
-    VectorFuzzer fuzzer({.vectorSize = 200}, pool());
-    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
-  }
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
-  auto queryPool = memory::memoryManager()->addRootPool(
-      "", kMaxBytes, memory::MemoryReclaimer::create());
-
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto plan = PlanBuilder(planNodeIdGenerator)
-                  .values(probeVectors, true)
-                  .hashJoin(
-                      {"t_k1"},
-                      {"u_k1"},
-                      PlanBuilder(planNodeIdGenerator)
-                          .values(buildVectors, true)
-                          .planNode(),
-                      "",
-                      concat(probeType_->names(), buildType_->names()))
-                  .planNode();
-
-  folly::EventCount driverWait;
-  std::atomic_bool driverWaitFlag{true};
-  folly::EventCount taskWait;
-  std::atomic_bool taskWaitFlag{true};
-
-  Operator* op{nullptr};
-  std::atomic_int probeInputCount{0};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Driver::runInternal::addInput",
-      std::function<void(Operator*)>(([&](Operator* testOp) {
-        if (testOp->operatorType() != "HashProbe") {
-          return;
-        }
-        op = testOp;
-
-        ASSERT_TRUE(op->canReclaim());
-        if (probeInputCount++ != 1) {
-          return;
-        }
-        auto* driver = op->operatorCtx()->driver();
-        TestSuspendedSection suspendedSection(driver);
-        taskWaitFlag = false;
-        taskWait.notifyAll();
-        driverWait.await([&]() { return !driverWaitFlag.load(); });
-      })));
-
-  std::thread taskThread([&]() {
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .numDrivers(1)
-        .planNode(plan)
-        .queryPool(std::move(queryPool))
-        .injectSpill(false)
-        .spillDirectory(tempDirectory->getPath())
-        .referenceQuery(
-            "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
-        .config(core::QueryConfig::kSpillStartPartitionBit, "29")
-        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-          const auto statsPair = taskSpilledStats(*task);
-          // The spill triggered at the probe side.
-          ASSERT_EQ(statsPair.first.spilledBytes, 0);
-          ASSERT_EQ(statsPair.first.spilledPartitions, 0);
-          ASSERT_GT(statsPair.second.spilledBytes, 0);
-          ASSERT_EQ(statsPair.second.spilledPartitions, 16);
-        })
-        .run();
-  });
-
-  taskWait.await([&]() { return !taskWaitFlag.load(); });
-  ASSERT_TRUE(op != nullptr);
-  auto task = op->operatorCtx()->task();
-  auto* nodePool = op->pool()->parent();
-  const auto nodeMemoryUsage = nodePool->reservedBytes();
-  {
-    memory::ScopedMemoryArbitrationContext ctx(op->pool());
-    const uint64_t reclaimedBytes = task->pool()->reclaim(
-        task->pool()->capacity(), 1'000'000, reclaimerStats_);
-    ASSERT_GT(reclaimedBytes, 0);
-    ASSERT_EQ(nodeMemoryUsage - nodePool->reservedBytes(), reclaimedBytes);
-  }
-  // Verify all the memory has been freed, except for the ones for hash lookup.
-  ASSERT_EQ(nodePool->reservedBytes(), 1048576);
-
-  driverWaitFlag = false;
-  driverWait.notifyAll();
-  task.reset();
-
-  taskThread.join();
-}
-
-DEBUG_ONLY_TEST_F(HashJoinTest, hashTableCleanupAfterProbeFinish) {
-  auto buildVectors = makeVectors(buildType_, 5, 100);
-  auto probeVectors = makeVectors(probeType_, 5, 100);
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  HashProbe* probeOp{nullptr};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Driver::runInternal::getOutput",
-      std::function<void(Operator*)>([&](Operator* op) {
-        if (probeOp == nullptr && op->operatorType() == "HashProbe") {
-          probeOp = dynamic_cast<HashProbe*>(op);
-        }
-      }));
-
-  bool tableEmpty{false};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Driver::runInternal::noMoreInput",
-      std::function<void(Operator*)>([&](Operator* op) {
-        if (op->operatorType() == "FilterProject") {
-          tableEmpty = (probeOp->testingTable()->numDistinct() == 0);
-        }
-      }));
-
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto plan = PlanBuilder(planNodeIdGenerator)
-                  .values(probeVectors, true)
-                  .hashJoin(
-                      {"t_k1"},
-                      {"u_k1"},
-                      PlanBuilder(planNodeIdGenerator)
-                          .values(buildVectors, true)
-                          .planNode(),
-                      "",
-                      concat(probeType_->names(), buildType_->names()))
-                  .project({"t_k1", "t_k2", "t_v1", "u_k1", "u_k2", "u_v1"})
-                  .planNode();
-
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .numDrivers(1)
-      .planNode(plan)
-      .injectSpill(false)
-      .spillDirectory(tempDirectory->getPath())
-      .referenceQuery(
-          "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
-      .config(core::QueryConfig::kSpillStartPartitionBit, "29")
-      .run();
-  ASSERT_TRUE(tableEmpty);
-}
+    HashJoinTest,
+    testing::ValuesIn(HashJoinTest::getTestParams()),
+    [](const testing::TestParamInfo<TestParam>& info) {
+      return TestParamToName(info.param);
+    });
 
 } // namespace
 } // namespace facebook::velox::exec
diff --git a/velox/exec/tests/HashJoinTestExtra.cpp b/velox/exec/tests/HashJoinTestExtra.cpp
new file mode 100644
index 00000000000..4e224f1632d
--- /dev/null
+++ b/velox/exec/tests/HashJoinTestExtra.cpp
@@ -0,0 +1,7966 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <re2/re2.h>
+
+#include <fmt/format.h>
+#include "folly/synchronization/EventCount.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
+#include "velox/common/testutil/TestValue.h"
+#include "velox/dwio/common/tests/utils/BatchMaker.h"
+#include "velox/exec/Cursor.h"
+#include "velox/exec/HashBuild.h"
+#include "velox/exec/HashJoinBridge.h"
+#include "velox/exec/HashProbe.h"
+#include "velox/exec/OperatorType.h"
+#include "velox/exec/OperatorUtils.h"
+#include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/tests/utils/ArbitratorTestUtil.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/HashJoinTestBase.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/VectorTestUtil.h"
+#include "velox/type/tests/utils/CustomTypesForTesting.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::common::testutil;
+
+using facebook::velox::test::BatchMaker;
+
+namespace facebook::velox::exec {
+namespace {
+
+class HashJoinTest : public HashJoinTestBase,
+                     public testing::WithParamInterface<TestParam> {
+ public:
+  HashJoinTest() : HashJoinTestBase(GetParam()) {}
+
+  explicit HashJoinTest(const TestParam& param) : HashJoinTestBase(param) {}
+
+  static std::vector<TestParam> getTestParams() {
+    return std::vector<TestParam>({TestParam{1, false}, TestParam{1, true}});
+  }
+};
+
+class MultiThreadedHashJoinTest : public HashJoinTest {
+ public:
+  MultiThreadedHashJoinTest() : HashJoinTest(GetParam()) {}
+
+  static std::vector<TestParam> getTestParams() {
+    return std::vector<TestParam>(
+        {TestParam{1, false},
+         TestParam{1, true},
+         TestParam{3, false},
+         TestParam{3, true}});
+  }
+};
+
+// TODO: try to parallelize the following test cases if possible.
+TEST_P(HashJoinTest, memory) {
+  // Measures memory allocation in a 1:n hash join followed by
+  // projection and aggregation. We expect vectors to be mostly
+  // reused, except for t_k0 + 1, which is a dictionary after the
+  // join.
+  std::vector<RowVectorPtr> probeVectors =
+      makeBatches(10, [&](int32_t /*unused*/) {
+        return std::dynamic_pointer_cast<RowVector>(
+            BatchMaker::createBatch(probeType_, 1000, *pool_));
+      });
+
+  // auto buildType = makeRowType(keyTypes, "u_");
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(10, [&](int32_t /*unused*/) {
+        return std::dynamic_pointer_cast<RowVector>(
+            BatchMaker::createBatch(buildType_, 1000, *pool_));
+      });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  CursorParameters params;
+  params.planNode = PlanBuilder(planNodeIdGenerator)
+                        .values(probeVectors, true)
+                        .hashJoin(
+                            {"t_k1"},
+                            {"u_k1"},
+                            PlanBuilder(planNodeIdGenerator)
+                                .values(buildVectors, true)
+                                .planNode(),
+                            "",
+                            concat(probeType_->names(), buildType_->names()))
+                        .project({"t_k1 % 1000 AS k1", "u_k1 % 1000 AS k2"})
+                        .singleAggregation({}, {"sum(k1)", "sum(k2)"})
+                        .planNode();
+  params.queryCtx = core::QueryCtx::create(driverExecutor_.get());
+  auto [taskCursor, rows] = readCursor(params);
+  EXPECT_GT(3'500, params.queryCtx->pool()->stats().numAllocs);
+  EXPECT_GT(40'000'000, params.queryCtx->pool()->stats().cumulativeBytes);
+}
+
+TEST_P(HashJoinTest, lazyVectors) {
+  // a dataset of multiple row groups with multiple columns. We create
+  // different dictionary wrappings for different columns and load the
+  // rows in scope at different times.
+  auto probeVectors = makeBatches(3, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {makeFlatVector<int32_t>(3'000, [](auto row) { return row; }),
+         makeFlatVector<int64_t>(30'000, [](auto row) { return row % 23; }),
+         makeFlatVector<int32_t>(30'000, [](auto row) { return row % 31; }),
+         makeFlatVector<StringView>(30'000, [](auto row) {
+           return StringView::makeInline(fmt::format("{}   string", row % 43));
+         })});
+  });
+
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(4, [&](int32_t /*unused*/) {
+        return makeRowVector(
+            {makeFlatVector<int32_t>(1'000, [](auto row) { return row * 3; }),
+             makeFlatVector<int64_t>(
+                 10'000, [](auto row) { return row % 31; })});
+      });
+
+  std::vector<std::shared_ptr<TempFilePath>> tempFiles;
+
+  for (const auto& probeVector : probeVectors) {
+    tempFiles.push_back(TempFilePath::create());
+    writeToFile(tempFiles.back()->getPath(), probeVector);
+  }
+  createDuckDbTable("t", probeVectors);
+
+  for (const auto& buildVector : buildVectors) {
+    tempFiles.push_back(TempFilePath::create());
+    writeToFile(tempFiles.back()->getPath(), buildVector);
+  }
+  createDuckDbTable("u", buildVectors);
+
+  auto makeInputSplits = [&](const core::PlanNodeId& probeScanId,
+                             const core::PlanNodeId& buildScanId) {
+    return [&] {
+      std::vector<exec::Split> probeSplits;
+      for (int i = 0; i < probeVectors.size(); ++i) {
+        probeSplits.push_back(
+            exec::Split(makeHiveConnectorSplit(tempFiles[i]->getPath())));
+      }
+      std::vector<exec::Split> buildSplits;
+      for (int i = 0; i < buildVectors.size(); ++i) {
+        buildSplits.push_back(
+            exec::Split(makeHiveConnectorSplit(
+                tempFiles[probeSplits.size() + i]->getPath())));
+      }
+      SplitInput splits;
+      splits.emplace(probeScanId, probeSplits);
+      splits.emplace(buildScanId, buildSplits);
+      return splits;
+    };
+  };
+
+  {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId probeScanId;
+    core::PlanNodeId buildScanId;
+    auto op = PlanBuilder(planNodeIdGenerator)
+                  .tableScan(ROW({"c0", "c1"}, {INTEGER(), BIGINT()}))
+                  .capturePlanNodeId(probeScanId)
+                  .hashJoin(
+                      {"c0"},
+                      {"c0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .tableScan(ROW({"c0"}, {INTEGER()}))
+                          .capturePlanNodeId(buildScanId)
+                          .planNode(),
+                      "",
+                      {"c1"})
+                  .project({"c1 + 1"})
+                  .planNode();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(std::move(op))
+        .makeInputSplits(makeInputSplits(probeScanId, buildScanId))
+        .referenceQuery("SELECT t.c1 + 1 FROM t, u WHERE t.c0 = u.c0")
+        .run();
+  }
+
+  {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId probeScanId;
+    core::PlanNodeId buildScanId;
+    auto op = PlanBuilder(planNodeIdGenerator)
+                  .tableScan(
+                      ROW({"c0", "c1", "c2", "c3"},
+                          {INTEGER(), BIGINT(), INTEGER(), VARCHAR()}))
+                  .capturePlanNodeId(probeScanId)
+                  .filter("c2 < 29")
+                  .hashJoin(
+                      {"c0"},
+                      {"bc0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .tableScan(ROW({"c0", "c1"}, {INTEGER(), BIGINT()}))
+                          .capturePlanNodeId(buildScanId)
+                          .project({"c0 as bc0", "c1 as bc1"})
+                          .planNode(),
+                      "(c1 + bc1) % 33 < 27",
+                      {"c1", "bc1", "c3"})
+                  .project({"c1 + 1", "bc1", "length(c3)"})
+                  .planNode();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(std::move(op))
+        .makeInputSplits(makeInputSplits(probeScanId, buildScanId))
+        .referenceQuery(
+            "SELECT t.c1 + 1, U.c1, length(t.c3) FROM t, u WHERE t.c0 = u.c0 and t.c2 < 29 and (t.c1 + u.c1) % 33 < 27")
+        .run();
+  }
+}
+
+TEST_P(HashJoinTest, lazyVectorNotLoadedInFilter) {
+  // Ensure that if lazy vectors are temporarily wrapped during a filter's
+  // execution and remain unloaded, the temporary wrap is promptly
+  // discarded. This precaution prevents the generation of the probe's output
+  // from wrapping an unloaded vector while the temporary wrap is
+  // still alive.
+  // This is done by generating a sufficiently small batch to allow the lazy
+  // vector to remain unloaded, as it doesn't need to be split between batches.
+  // Then we use a filter that skips the execution of the expression containing
+  // the lazy vector, thereby avoiding its loading.
+
+  testLazyVectorsWithFilter(
+      core::JoinType::kInner,
+      "c1 >= 0 OR c2 > 0",
+      {"c1", "c2"},
+      "SELECT t.c1, t.c2 FROM t, u WHERE t.c0 = u.c0");
+}
+
+TEST_P(HashJoinTest, lazyVectorPartiallyLoadedInFilterLeftJoin) {
+  // Test the case where a filter loads a subset of the rows that will be output
+  // from a column on the probe side.
+
+  testLazyVectorsWithFilter(
+      core::JoinType::kLeft,
+      "c1 > 0 AND c2 > 0",
+      {"c1", "c2"},
+      "SELECT t.c1, t.c2 FROM t LEFT JOIN u ON t.c0 = u.c0 AND (c1 > 0 AND c2 > 0)");
+}
+
+TEST_P(HashJoinTest, lazyVectorPartiallyLoadedInFilterFullJoin) {
+  // Test the case where a filter loads a subset of the rows that will be output
+  // from a column on the probe side.
+
+  testLazyVectorsWithFilter(
+      core::JoinType::kFull,
+      "c1 > 0 AND c2 > 0",
+      {"c1", "c2"},
+      "SELECT t.c1, t.c2 FROM t FULL OUTER JOIN u ON t.c0 = u.c0 AND (c1 > 0 AND c2 > 0)");
+}
+
+TEST_P(HashJoinTest, lazyVectorPartiallyLoadedInFilterLeftSemiProject) {
+  // Test the case where a filter loads a subset of the rows that will be output
+  // from a column on the probe side.
+
+  testLazyVectorsWithFilter(
+      core::JoinType::kLeftSemiProject,
+      "c1 > 0 AND c2 > 0",
+      {"c1", "c2", "match"},
+      "SELECT t.c1, t.c2, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0 AND (t.c1 > 0 AND t.c2 > 0)) FROM t");
+}
+
+TEST_P(HashJoinTest, lazyVectorPartiallyLoadedInFilterAntiJoin) {
+  // Test the case where a filter loads a subset of the rows that will be output
+  // from a column on the probe side.
+
+  testLazyVectorsWithFilter(
+      core::JoinType::kAnti,
+      "c1 > 0 AND c2 > 0",
+      {"c1", "c2"},
+      "SELECT t.c1, t.c2 FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE t.c0 = u.c0 AND (t.c1 > 0 AND t.c2 > 0))");
+}
+
+TEST_P(HashJoinTest, lazyVectorPartiallyLoadedInFilterInnerJoin) {
+  // Test the case where a filter loads a subset of the rows that will be output
+  // from a column on the probe side.
+
+  testLazyVectorsWithFilter(
+      core::JoinType::kInner,
+      "not (c1 < 15 and c2 >= 0)",
+      {"c1", "c2"},
+      "SELECT t.c1, t.c2 FROM t, u WHERE t.c0 = u.c0 AND NOT (c1 < 15 AND c2 >= 0)");
+}
+
+TEST_P(HashJoinTest, lazyVectorPartiallyLoadedInFilterLeftSemiFilter) {
+  // Test the case where a filter loads a subset of the rows that will be output
+  // from a column on the probe side.
+
+  testLazyVectorsWithFilter(
+      core::JoinType::kLeftSemiFilter,
+      "not (c1 < 15 and c2 >= 0)",
+      {"c1", "c2"},
+      "SELECT t.c1, t.c2 FROM t WHERE c0 IN (SELECT u.c0 FROM u WHERE t.c0 = u.c0 AND NOT (t.c1 < 15 AND t.c2 >= 0))");
+}
+
+// Verifies that lazy probe-side vectors are loaded in ensureLazyInputLoaded()
+// (inside a reclaimable section) BEFORE the non-reclaimable probe output loop
+// in getOutputInternal(). Tests fuzzed data with partial/all lazy columns and
+// deterministic low-selectivity data. When spill is injected via
+// HashJoinBuilder, verifies spill actually occurs and results remain correct.
+DEBUG_ONLY_TEST_P(HashJoinTest, hashProbeEnsureLazyInputLoaded) {
+  struct {
+    bool useDeterministicData;
+    std::vector<int> lazyColumnIndices;
+    bool useHashJoinBuilder;
+
+    std::string debugString() const {
+      return fmt::format(
+          "useDeterministicData: {}, lazyColumns: {}, useHashJoinBuilder: {}",
+          useDeterministicData,
+          lazyColumnIndices.empty() ? "all"
+                                    : folly::join(",", lazyColumnIndices),
+          useHashJoinBuilder);
+    }
+  } testSettings[] = {
+      // Fuzzed data, non-key columns lazy.
+      {false, {1, 2}, false},
+      // Deterministic low selectivity (~1% match rate), non-key columns lazy.
+      {true, {1, 2}, false},
+      // Fuzzed data, all columns lazy, with spill injection.
+      {false, {}, true},
+  };
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    std::vector<RowVectorPtr> probeVectors;
+    std::vector<RowVectorPtr> buildInput;
+
+    if (testData.useDeterministicData) {
+      auto probe = makeRowVector(
+          {"t_k1", "t_k2", "t_v1"},
+          {makeFlatVector<int32_t>(1'000, [](auto row) { return row; }),
+           makeFlatVector<StringView>(
+               1'000,
+               [](auto /*row*/) { return StringView::makeInline("probe"); }),
+           makeFlatVector<StringView>(1'000, [](auto /*row*/) {
+             return StringView::makeInline("val");
+           })});
+      probeVectors.push_back(
+          VectorFuzzer({.vectorSize = 1'000}, pool())
+              .fuzzRowChildrenToLazy(probe, testData.lazyColumnIndices));
+      createDuckDbTable(
+          "t",
+          {std::dynamic_pointer_cast<RowVector>(
+              probe->testingCopyPreserveEncodings())});
+
+      // Build data only has keys 0-9, so only ~1% of probe rows match.
+      // Use enough duplicates (200 per key) so the output exceeds
+      // outputBatchSize (default 1024) and spans multiple batches, ensuring
+      // the ensureLoadedIfNotAtEnd at-end optimization does not bypass the
+      // preloading path we are testing.
+      auto build = makeRowVector(
+          {"u_k1", "u_k2", "u_v1"},
+          {makeFlatVector<int32_t>(2'000, [](auto row) { return row % 10; }),
+           makeFlatVector<StringView>(
+               2'000,
+               [](auto /*row*/) { return StringView::makeInline("build"); }),
+           makeFlatVector<int32_t>(2'000, [](auto row) { return row * 100; })});
+      buildInput.push_back(build);
+      createDuckDbTable("u", {build});
+    } else {
+      VectorFuzzer::Options opts;
+      opts.vectorSize = 1'000;
+      VectorFuzzer fuzzer(opts, pool());
+
+      auto nonLazy = fuzzer.fuzzRow(probeType_);
+      // Overwrite the join key column (index 0) with values from a small
+      // range to guarantee probe-build matches. Without this, random int32
+      // keys across 1'000 rows have near-zero probability of overlapping.
+      nonLazy->childAt(0) =
+          makeFlatVector<int32_t>(1'000, [](auto row) { return row % 100; });
+      createDuckDbTable(
+          "t",
+          {std::dynamic_pointer_cast<RowVector>(
+              nonLazy->testingCopyPreserveEncodings())});
+      probeVectors.push_back(
+          testData.lazyColumnIndices.empty()
+              ? VectorFuzzer(opts, pool()).fuzzRowChildrenToLazy(nonLazy)
+              : VectorFuzzer(opts, pool())
+                    .fuzzRowChildrenToLazy(
+                        nonLazy, testData.lazyColumnIndices));
+
+      auto buildRow = fuzzer.fuzzRow(buildType_);
+      buildRow->childAt(0) =
+          makeFlatVector<int32_t>(1'000, [](auto row) { return row % 100; });
+      buildInput.push_back(buildRow);
+      createDuckDbTable("u", buildInput);
+    }
+
+    // Track whether fillOutput (the non-reclaimable probe output loop) has
+    // been entered. Lazy loading should happen BEFORE this point.
+    std::atomic_bool fillOutputEntered{false};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::HashProbe::fillOutput",
+        std::function<void(HashProbe*)>(
+            [&](HashProbe*) { fillOutputEntered = true; }));
+
+    std::atomic_int lazyLoadsBeforeFillOutput{0};
+    std::atomic_int lazyLoadsDuringFillOutput{0};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::{}::VectorLoaderWrap::loadInternal",
+        std::function<void(void*)>([&](void*) {
+          if (fillOutputEntered) {
+            ++lazyLoadsDuringFillOutput;
+          } else {
+            ++lazyLoadsBeforeFillOutput;
+          }
+        }));
+
+    const std::string referenceQuery =
+        "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1";
+
+    if (testData.useHashJoinBuilder) {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .numDrivers(numDrivers_)
+          .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+          .probeKeys({"t_k1"})
+          .probeVectors(std::move(probeVectors))
+          .buildKeys({"u_k1"})
+          .buildVectors(std::move(buildInput))
+          .referenceQuery(referenceQuery)
+          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+            if (hasSpill) {
+              const auto statsPair = taskSpilledStats(*task);
+              ASSERT_GT(statsPair.first.spilledBytes, 0);
+            }
+          })
+          .run();
+    } else {
+      const auto spillDirectory = TempDirectoryPath::create();
+      auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+      auto plan = PlanBuilder(planNodeIdGenerator)
+                      .values(probeVectors, false)
+                      .hashJoin(
+                          {"t_k1"},
+                          {"u_k1"},
+                          PlanBuilder(planNodeIdGenerator)
+                              .values(buildInput, false)
+                              .planNode(),
+                          "",
+                          concat(probeType_->names(), buildType_->names()))
+                      .planNode();
+
+      AssertQueryBuilder(duckDbQueryRunner_)
+          .spillDirectory(spillDirectory->getPath())
+          .config(core::QueryConfig::kSpillEnabled, true)
+          .config(core::QueryConfig::kJoinSpillEnabled, true)
+          .plan(plan)
+          .assertResults(referenceQuery);
+    }
+
+    // HashJoinBuilder runs the query twice (without and with spill).  On the
+    // first (non-spill) run canReclaim() is false, so ensureLazyInputLoaded()
+    // is a no-op and lazy vectors are loaded inside fillOutput().  The atomic
+    // counters accumulate across both runs, so only assert loading order for
+    // the single-run non-builder case where spill is explicitly configured.
+    if (!testData.useHashJoinBuilder) {
+      ASSERT_GT(lazyLoadsBeforeFillOutput, 0);
+      ASSERT_EQ(lazyLoadsDuringFillOutput, 0);
+    }
+  }
+}
+
+TEST_P(HashJoinTest, dynamicFilters) {
+  const int32_t numSplits = 10;
+  const int32_t numRowsProbe = 333;
+  const int32_t numRowsBuild = 100;
+
+  std::vector<RowVectorPtr> probeVectors;
+  probeVectors.reserve(numSplits);
+
+  std::vector<std::shared_ptr<TempFilePath>> tempFiles;
+  for (int32_t i = 0; i < numSplits; ++i) {
+    auto rowVector = makeRowVector({
+        makeFlatVector<int32_t>(
+            numRowsProbe, [&](auto row) { return row - i * 10; }),
+        makeFlatVector<int64_t>(numRowsProbe, [](auto row) { return row; }),
+    });
+    probeVectors.push_back(rowVector);
+    tempFiles.push_back(TempFilePath::create());
+    writeToFile(tempFiles.back()->getPath(), rowVector);
+  }
+  auto makeInputSplits = [&](const core::PlanNodeId& nodeId) {
+    return [&] {
+      std::vector<exec::Split> probeSplits;
+      for (auto& file : tempFiles) {
+        probeSplits.push_back(
+            exec::Split(makeHiveConnectorSplit(file->getPath())));
+      }
+      SplitInput splits;
+      splits.emplace(nodeId, probeSplits);
+      return splits;
+    };
+  };
+
+  // 100 key values in [35, 233] range.
+  std::vector<RowVectorPtr> buildVectors;
+  for (int i = 0; i < 5; ++i) {
+    buildVectors.push_back(makeRowVector({
+        makeFlatVector<int32_t>(
+            numRowsBuild / 5,
+            [i](auto row) { return 35 + 2 * (row + i * numRowsBuild / 5); }),
+        makeFlatVector<int64_t>(numRowsBuild / 5, [](auto row) { return row; }),
+    }));
+  }
+  std::vector<RowVectorPtr> keyOnlyBuildVectors;
+  for (int i = 0; i < 5; ++i) {
+    keyOnlyBuildVectors.push_back(
+        makeRowVector({makeFlatVector<int32_t>(numRowsBuild / 5, [i](auto row) {
+          return 35 + 2 * (row + i * numRowsBuild / 5);
+        })}));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto probeType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto buildSide = PlanBuilder(planNodeIdGenerator, pool_.get())
+                       .values(buildVectors)
+                       .project({"c0 AS u_c0", "c1 AS u_c1"})
+                       .planNode();
+  auto keyOnlyBuildSide = PlanBuilder(planNodeIdGenerator, pool_.get())
+                              .values(keyOnlyBuildVectors)
+                              .project({"c0 AS u_c0"})
+                              .planNode();
+
+  // Basic push-down.
+  {
+    SCOPED_TRACE("Inner join");
+    core::PlanNodeId probeScanId;
+    core::PlanNodeId joinId;
+    auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
+                  .tableScan(probeType)
+                  .capturePlanNodeId(probeScanId)
+                  .hashJoin(
+                      {"c0"},
+                      {"u_c0"},
+                      buildSide,
+                      "",
+                      {"c0", "c1", "u_c1"},
+                      core::JoinType::kInner)
+                  .capturePlanNodeId(joinId)
+                  .project({"c0", "c1 + 1", "c1 + u_c1"})
+                  .planNode();
+    {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .makeInputSplits(makeInputSplits(probeScanId))
+          .referenceQuery(
+              "SELECT t.c0, t.c1 + 1, t.c1 + u.c1 FROM t, u WHERE t.c0 = u.c0")
+          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+            auto planStats = toPlanStats(task->taskStats());
+            if (hasSpill) {
+              // Dynamic filtering should be disabled with spilling triggered.
+              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
+              ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
+            } else {
+              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
+              ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
+              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_EQ(
+                  planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                  std::unordered_set<core::PlanNodeId>({joinId}));
+            }
+          })
+          .run();
+    }
+
+    // Left semi join.
+    op = PlanBuilder(planNodeIdGenerator, pool_.get())
+             .tableScan(probeType)
+             .capturePlanNodeId(probeScanId)
+             .hashJoin(
+                 {"c0"},
+                 {"u_c0"},
+                 buildSide,
+                 "",
+                 {"c0", "c1"},
+                 core::JoinType::kLeftSemiFilter)
+             .capturePlanNodeId(joinId)
+             .project({"c0", "c1 + 1"})
+             .planNode();
+
+    {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .makeInputSplits(makeInputSplits(probeScanId))
+          .referenceQuery(
+              "SELECT t.c0, t.c1 + 1 FROM t WHERE t.c0 IN (SELECT c0 FROM u)")
+          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+            auto planStats = toPlanStats(task->taskStats());
+            if (hasSpill) {
+              // Dynamic filtering should be disabled with spilling triggered.
+              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
+              ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
+              ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
+            } else {
+              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
+              ASSERT_GT(getReplacedWithFilterRows(task, 1).sum, 0);
+              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_EQ(
+                  planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                  std::unordered_set<core::PlanNodeId>({joinId}));
+            }
+          })
+          .run();
+    }
+
+    // Right semi join.
+    op = PlanBuilder(planNodeIdGenerator, pool_.get())
+             .tableScan(probeType)
+             .capturePlanNodeId(probeScanId)
+             .hashJoin(
+                 {"c0"},
+                 {"u_c0"},
+                 buildSide,
+                 "",
+                 {"u_c0", "u_c1"},
+                 core::JoinType::kRightSemiFilter)
+             .capturePlanNodeId(joinId)
+             .project({"u_c0", "u_c1 + 1"})
+             .planNode();
+
+    {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .makeInputSplits(makeInputSplits(probeScanId))
+          .referenceQuery(
+              "SELECT u.c0, u.c1 + 1 FROM u WHERE u.c0 IN (SELECT c0 FROM t)")
+          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+            auto planStats = toPlanStats(task->taskStats());
+            if (hasSpill) {
+              // Dynamic filtering should be disabled with spilling triggered.
+              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
+              ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
+              ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
+            } else {
+              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
+              ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
+              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_EQ(
+                  planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                  std::unordered_set<core::PlanNodeId>({joinId}));
+            }
+          })
+          .run();
+    }
+
+    // Right join.
+    op = PlanBuilder(planNodeIdGenerator, pool_.get())
+             .tableScan(probeType)
+             .capturePlanNodeId(probeScanId)
+             .hashJoin(
+                 {"c0"},
+                 {"u_c0"},
+                 buildSide,
+                 "",
+                 {"c0", "c1", "u_c1"},
+                 core::JoinType::kRight)
+             .capturePlanNodeId(joinId)
+             .project({"c0", "c1 + 1", "c1 + u_c1"})
+             .planNode();
+    {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .makeInputSplits(makeInputSplits(probeScanId))
+          .referenceQuery(
+              "SELECT t.c0, t.c1 + 1, t.c1 + u.c1 FROM t RIGHT JOIN u ON t.c0 = u.c0")
+          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+            auto planStats = toPlanStats(task->taskStats());
+            if (hasSpill) {
+              // Dynamic filtering should be disabled with spilling triggered.
+              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
+              ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
+            } else {
+              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
+              ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
+              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_EQ(
+                  planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                  std::unordered_set<core::PlanNodeId>({joinId}));
+            }
+          })
+          .run();
+    }
+  }
+
+  // Basic push-down with column names projected out of the table scan
+  // having different names than column names in the files.
+  {
+    SCOPED_TRACE("Inner join column rename");
+    auto scanOutputType = ROW({"a", "b"}, {INTEGER(), BIGINT()});
+    connector::ColumnHandleMap assignments;
+    assignments["a"] = regularColumn("c0", INTEGER());
+    assignments["b"] = regularColumn("c1", BIGINT());
+
+    core::PlanNodeId probeScanId;
+    core::PlanNodeId joinId;
+    auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
+                  .startTableScan()
+                  .outputType(scanOutputType)
+                  .assignments(assignments)
+                  .endTableScan()
+                  .capturePlanNodeId(probeScanId)
+                  .hashJoin({"a"}, {"u_c0"}, buildSide, "", {"a", "b", "u_c1"})
+                  .capturePlanNodeId(joinId)
+                  .project({"a", "b + 1", "b + u_c1"})
+                  .planNode();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(std::move(op))
+        .makeInputSplits(makeInputSplits(probeScanId))
+        .referenceQuery(
+            "SELECT t.c0, t.c1 + 1, t.c1 + u.c1 FROM t, u WHERE t.c0 = u.c0")
+        .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+          SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+          auto planStats = toPlanStats(task->taskStats());
+          if (hasSpill) {
+            // Dynamic filtering should be disabled with spilling triggered.
+            ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
+            ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
+            ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
+            ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
+            ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
+          } else {
+            ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
+            ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
+            ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
+            ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+            ASSERT_EQ(
+                planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                std::unordered_set<core::PlanNodeId>({joinId}));
+          }
+        })
+        .run();
+  }
+
+  // Push-down that requires merging filters.
+  {
+    SCOPED_TRACE("Merge filters");
+    core::PlanNodeId probeScanId;
+    core::PlanNodeId joinId;
+    auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
+                  .tableScan(probeType, {"c0 < 500::INTEGER"})
+                  .capturePlanNodeId(probeScanId)
+                  .hashJoin({"c0"}, {"u_c0"}, buildSide, "", {"c1", "u_c1"})
+                  .capturePlanNodeId(joinId)
+                  .project({"c1 + u_c1"})
+                  .planNode();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(std::move(op))
+        .makeInputSplits(makeInputSplits(probeScanId))
+        .referenceQuery(
+            "SELECT t.c1 + u.c1 FROM t, u WHERE t.c0 = u.c0 AND t.c0 < 500")
+        .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+          SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+          auto planStats = toPlanStats(task->taskStats());
+          if (hasSpill) {
+            // Dynamic filtering should be disabled with spilling triggered.
+            ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
+            ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
+            ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
+            ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
+            ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
+          } else {
+            ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
+            ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
+            ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
+            ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+            ASSERT_EQ(
+                planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                std::unordered_set<core::PlanNodeId>({joinId}));
+          }
+        })
+        .run();
+  }
+
+  // Push-down that turns join into a no-op.
+  {
+    SCOPED_TRACE("canReplaceWithDynamicFilter");
+    core::PlanNodeId probeScanId;
+    core::PlanNodeId joinId;
+    auto op =
+        PlanBuilder(planNodeIdGenerator, pool_.get())
+            .tableScan(probeType)
+            .capturePlanNodeId(probeScanId)
+            .hashJoin({"c0"}, {"u_c0"}, keyOnlyBuildSide, "", {"c0", "c1"})
+            .capturePlanNodeId(joinId)
+            .project({"c0", "c1 + 1"})
+            .planNode();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(std::move(op))
+        .makeInputSplits(makeInputSplits(probeScanId))
+        .referenceQuery("SELECT t.c0, t.c1 + 1 FROM t, u WHERE t.c0 = u.c0")
+        .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+          SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+          auto planStats = toPlanStats(task->taskStats());
+          if (hasSpill) {
+            // Dynamic filtering should be disabled with spilling triggered.
+            ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
+            ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
+            ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
+            ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
+            ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
+          } else {
+            ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
+            ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
+            ASSERT_EQ(
+                getReplacedWithFilterRows(task, 1).sum,
+                numRowsBuild * numSplits);
+            ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+            ASSERT_EQ(
+                planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                std::unordered_set<core::PlanNodeId>({joinId}));
+          }
+        })
+        .run();
+  }
+
+  // Push-down that turns join into a no-op with output having a different
+  // number of columns than the input.
+  {
+    SCOPED_TRACE("canReplaceWithDynamicFilter column rename");
+    core::PlanNodeId probeScanId;
+    core::PlanNodeId joinId;
+    auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
+                  .tableScan(probeType)
+                  .capturePlanNodeId(probeScanId)
+                  .hashJoin({"c0"}, {"u_c0"}, keyOnlyBuildSide, "", {"c0"})
+                  .capturePlanNodeId(joinId)
+                  .planNode();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(std::move(op))
+        .makeInputSplits(makeInputSplits(probeScanId))
+        .referenceQuery("SELECT t.c0 FROM t JOIN u ON (t.c0 = u.c0)")
+        .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+          SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+          auto planStats = toPlanStats(task->taskStats());
+          if (hasSpill) {
+            // Dynamic filtering should be disabled with spilling triggered.
+            ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
+            ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
+            ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
+            ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
+            ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
+          } else {
+            ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
+            ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
+            ASSERT_EQ(
+                getReplacedWithFilterRows(task, 1).sum,
+                numRowsBuild * numSplits);
+            ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+            ASSERT_EQ(
+                planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                std::unordered_set<core::PlanNodeId>({joinId}));
+          }
+        })
+        .run();
+  }
+
+  // Push-down that requires merging filters and turns join into a no-op.
+  {
+    SCOPED_TRACE("canReplaceWithDynamicFilter merge filters");
+    core::PlanNodeId probeScanId;
+    core::PlanNodeId joinId;
+    auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
+                  .tableScan(probeType, {"c0 < 500::INTEGER"})
+                  .capturePlanNodeId(probeScanId)
+                  .hashJoin({"c0"}, {"u_c0"}, keyOnlyBuildSide, "", {"c1"})
+                  .capturePlanNodeId(joinId)
+                  .project({"c1 + 1"})
+                  .planNode();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(std::move(op))
+        .makeInputSplits(makeInputSplits(probeScanId))
+        .referenceQuery(
+            "SELECT t.c1 + 1 FROM t, u WHERE t.c0 = u.c0 AND t.c0 < 500")
+        .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+          SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+          auto planStats = toPlanStats(task->taskStats());
+          if (hasSpill) {
+            // Dynamic filtering should be disabled with spilling triggered.
+            ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
+            ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
+            ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
+            ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
+            ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
+          } else {
+            ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
+            ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
+            ASSERT_GT(getReplacedWithFilterRows(task, 1).sum, 0);
+            ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+            ASSERT_EQ(
+                planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                std::unordered_set<core::PlanNodeId>({joinId}));
+          }
+        })
+        .run();
+  }
+
+  // Push-down with highly selective filter in the scan.
+  {
+    SCOPED_TRACE("Highly selective filter");
+    // Inner join.
+    core::PlanNodeId probeScanId;
+    core::PlanNodeId joinId;
+    auto op =
+        PlanBuilder(planNodeIdGenerator, pool_.get())
+            .tableScan(probeType, {"c0 < 200::INTEGER"})
+            .capturePlanNodeId(probeScanId)
+            .hashJoin(
+                {"c0"}, {"u_c0"}, buildSide, "", {"c1"}, core::JoinType::kInner)
+            .capturePlanNodeId(joinId)
+            .project({"c1 + 1"})
+            .planNode();
+
+    {
+      SCOPED_TRACE("Inner join");
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .makeInputSplits(makeInputSplits(probeScanId))
+          .referenceQuery(
+              "SELECT t.c1 + 1 FROM t, u WHERE t.c0 = u.c0 AND t.c0 < 200")
+          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+            auto planStats = toPlanStats(task->taskStats());
+            if (hasSpill) {
+              // Dynamic filtering should be disabled with spilling triggered.
+              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
+              ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
+              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
+            } else {
+              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
+              ASSERT_GT(getReplacedWithFilterRows(task, 1).sum, 0);
+              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_EQ(
+                  planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                  std::unordered_set<core::PlanNodeId>({joinId}));
+            }
+          })
+          .run();
+    }
+
+    // Left semi join.
+    op = PlanBuilder(planNodeIdGenerator, pool_.get())
+             .tableScan(probeType, {"c0 < 200::INTEGER"})
+             .capturePlanNodeId(probeScanId)
+             .hashJoin(
+                 {"c0"},
+                 {"u_c0"},
+                 buildSide,
+                 "",
+                 {"c1"},
+                 core::JoinType::kLeftSemiFilter)
+             .capturePlanNodeId(joinId)
+             .project({"c1 + 1"})
+             .planNode();
+
+    {
+      SCOPED_TRACE("Left semi join");
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .makeInputSplits(makeInputSplits(probeScanId))
+          .referenceQuery(
+              "SELECT t.c1 + 1 FROM t WHERE t.c0 IN (SELECT c0 FROM u) AND t.c0 < 200")
+          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+            auto planStats = toPlanStats(task->taskStats());
+            if (hasSpill) {
+              // Dynamic filtering should be disabled with spilling triggered.
+              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
+              ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
+              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
+            } else {
+              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
+              ASSERT_GT(getReplacedWithFilterRows(task, 1).sum, 0);
+              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_EQ(
+                  planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                  std::unordered_set<core::PlanNodeId>({joinId}));
+            }
+          })
+          .run();
+    }
+
+    // Right semi join.
+    op = PlanBuilder(planNodeIdGenerator, pool_.get())
+             .tableScan(probeType, {"c0 < 200::INTEGER"})
+             .capturePlanNodeId(probeScanId)
+             .hashJoin(
+                 {"c0"},
+                 {"u_c0"},
+                 buildSide,
+                 "",
+                 {"u_c1"},
+                 core::JoinType::kRightSemiFilter)
+             .capturePlanNodeId(joinId)
+             .project({"u_c1 + 1"})
+             .planNode();
+
+    {
+      SCOPED_TRACE("Right semi join");
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .makeInputSplits(makeInputSplits(probeScanId))
+          .referenceQuery(
+              "SELECT u.c1 + 1 FROM u WHERE u.c0 IN (SELECT c0 FROM t) AND u.c0 < 200")
+          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+            auto planStats = toPlanStats(task->taskStats());
+            if (hasSpill) {
+              // Dynamic filtering should be disabled with spilling triggered.
+              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
+              ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
+              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
+            } else {
+              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
+              ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
+              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_EQ(
+                  planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                  std::unordered_set<core::PlanNodeId>({joinId}));
+            }
+          })
+          .run();
+    }
+
+    // Right join.
+    op =
+        PlanBuilder(planNodeIdGenerator, pool_.get())
+            .tableScan(probeType, {"c0 < 200::INTEGER"})
+            .capturePlanNodeId(probeScanId)
+            .hashJoin(
+                {"c0"}, {"u_c0"}, buildSide, "", {"c1"}, core::JoinType::kRight)
+            .capturePlanNodeId(joinId)
+            .project({"c1 + 1"})
+            .planNode();
+
+    {
+      SCOPED_TRACE("Right join");
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .makeInputSplits(makeInputSplits(probeScanId))
+          .referenceQuery(
+              "SELECT t.c1 + 1 FROM (SELECT * FROM t WHERE t.c0 < 200) t RIGHT JOIN u ON t.c0 = u.c0")
+          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+            auto planStats = toPlanStats(task->taskStats());
+            if (hasSpill) {
+              // Dynamic filtering should be disabled with spilling triggered.
+              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
+              ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
+              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
+            } else {
+              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
+              ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
+              ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_EQ(
+                  planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                  std::unordered_set<core::PlanNodeId>({joinId}));
+            }
+          })
+          .run();
+    }
+  }
+
+  // Disable filter push-down by using values in place of scan.
+  {
+    SCOPED_TRACE("Disabled in case of values node");
+    core::PlanNodeId joinId;
+    auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
+                  .values(probeVectors)
+                  .hashJoin({"c0"}, {"u_c0"}, buildSide, "", {"c1"})
+                  .capturePlanNodeId(joinId)
+                  .project({"c1 + 1"})
+                  .planNode();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(std::move(op))
+        .referenceQuery("SELECT t.c1 + 1 FROM t, u WHERE t.c0 = u.c0")
+        .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+          auto planStats = toPlanStats(task->taskStats());
+          ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
+          ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
+          ASSERT_EQ(numRowsProbe * numSplits, getInputPositions(task, 1));
+        })
+        .run();
+  }
+
+  // Disable filter push-down by using an expression as the join key on the
+  // probe side.
+  {
+    SCOPED_TRACE("Disabled in case of join condition");
+    core::PlanNodeId probeScanId;
+    core::PlanNodeId joinId;
+    auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
+                  .tableScan(probeType)
+                  .capturePlanNodeId(probeScanId)
+                  .project({"cast(c0 + 1 as integer) AS t_key", "c1"})
+                  .hashJoin({"t_key"}, {"u_c0"}, buildSide, "", {"c1"})
+                  .capturePlanNodeId(joinId)
+                  .project({"c1 + 1"})
+                  .planNode();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(std::move(op))
+        .makeInputSplits(makeInputSplits(probeScanId))
+        .referenceQuery("SELECT t.c1 + 1 FROM t, u WHERE (t.c0 + 1) = u.c0")
+        .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+          auto planStats = toPlanStats(task->taskStats());
+          ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
+          ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
+          ASSERT_EQ(numRowsProbe * numSplits, getInputPositions(task, 1));
+          ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
+        })
+        .run();
+  }
+}
+
+TEST_P(HashJoinTest, dynamicFiltersStatsWithChainedJoins) {
+  const int32_t numSplits = 10;
+  const int32_t numProbeRows = 333;
+  const int32_t numBuildRows = 100;
+
+  std::vector<RowVectorPtr> probeVectors;
+  probeVectors.reserve(numSplits);
+  std::vector<std::shared_ptr<TempFilePath>> tempFiles;
+  for (int32_t i = 0; i < numSplits; ++i) {
+    auto rowVector = makeRowVector({
+        makeFlatVector<int32_t>(
+            numProbeRows, [&](auto row) { return row - i * 10; }),
+        makeFlatVector<int64_t>(numProbeRows, [](auto row) { return row; }),
+    });
+    probeVectors.push_back(rowVector);
+    tempFiles.push_back(TempFilePath::create());
+    writeToFile(tempFiles.back()->getPath(), rowVector);
+  }
+  auto makeInputSplits = [&](const core::PlanNodeId& nodeId) {
+    return [&] {
+      std::vector<exec::Split> probeSplits;
+      for (auto& file : tempFiles) {
+        probeSplits.push_back(
+            exec::Split(makeHiveConnectorSplit(file->getPath())));
+      }
+      SplitInput splits;
+      splits.emplace(nodeId, probeSplits);
+      return splits;
+    };
+  };
+
+  // 100 key values in [35, 233] range.
+  std::vector<RowVectorPtr> buildVectors;
+  for (int i = 0; i < 5; ++i) {
+    buildVectors.push_back(makeRowVector({
+        makeFlatVector<int32_t>(
+            numBuildRows / 5,
+            [i](auto row) { return 35 + 2 * (row + i * numBuildRows / 5); }),
+        makeFlatVector<int64_t>(numBuildRows / 5, [](auto row) { return row; }),
+    }));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto probeType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto buildSide1 = PlanBuilder(planNodeIdGenerator, pool_.get())
+                        .values(buildVectors)
+                        .project({"c0 AS u_c0", "c1 AS u_c1"})
+                        .planNode();
+  auto buildSide2 = PlanBuilder(planNodeIdGenerator, pool_.get())
+                        .values(buildVectors)
+                        .project({"c0 AS u_c0", "c1 AS u_c1"})
+                        .planNode();
+  // Inner join pushdown.
+  core::PlanNodeId probeScanId;
+  core::PlanNodeId joinId1;
+  core::PlanNodeId joinId2;
+  auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
+                .tableScan(probeType)
+                .capturePlanNodeId(probeScanId)
+                .hashJoin(
+                    {"c0"},
+                    {"u_c0"},
+                    buildSide1,
+                    "",
+                    {"c0", "c1"},
+                    core::JoinType::kInner)
+                .capturePlanNodeId(joinId1)
+                .hashJoin(
+                    {"c0"},
+                    {"u_c0"},
+                    buildSide2,
+                    "",
+                    {"c0", "c1", "u_c1"},
+                    core::JoinType::kInner)
+                .capturePlanNodeId(joinId2)
+                .project({"c0", "c1 + 1", "c1 + u_c1"})
+                .planNode();
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(std::move(op))
+      .makeInputSplits(makeInputSplits(probeScanId))
+      .injectSpill(false)
+      .referenceQuery(
+          "SELECT t.c0, t.c1 + 1, t.c1 + u.c1 FROM t, u WHERE t.c0 = u.c0")
+      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+        auto planStats = toPlanStats(task->taskStats());
+        ASSERT_EQ(
+            planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+            std::unordered_set<core::PlanNodeId>({joinId1, joinId2}));
+      })
+      .run();
+}
+
+TEST_P(HashJoinTest, dynamicFiltersWithSkippedSplits) {
+  const int32_t numSplits = 20;
+  const int32_t numNonSkippedSplits = 10;
+  const int32_t numRowsProbe = 333;
+  const int32_t numRowsBuild = 100;
+
+  std::vector<RowVectorPtr> probeVectors;
+  probeVectors.reserve(numSplits);
+
+  std::vector<std::shared_ptr<TempFilePath>> tempFiles;
+  // Each split has a column containing
+  // the split number. This is used to filter out whole splits based
+  // on metadata. We test how using metadata for dropping splits
+  // interactts with dynamic filters. In specific, if the first split
+  // is discarded based on metadata, the dynamic filters must not be
+  // lost even if there is no actual reader for the split.
+  for (int32_t i = 0; i < numSplits; ++i) {
+    auto rowVector = makeRowVector({
+        makeFlatVector<int32_t>(
+            numRowsProbe, [&](auto row) { return row - i * 10; }),
+        makeFlatVector<int64_t>(numRowsProbe, [](auto row) { return row; }),
+        makeFlatVector<int64_t>(
+            numRowsProbe, [&](auto /*row*/) { return i % 2 == 0 ? 0 : i; }),
+    });
+    probeVectors.push_back(rowVector);
+    tempFiles.push_back(TempFilePath::create());
+    writeToFile(tempFiles.back()->getPath(), rowVector);
+  }
+
+  auto makeInputSplits = [&](const core::PlanNodeId& nodeId) {
+    return [&] {
+      std::vector<exec::Split> probeSplits;
+      for (auto& file : tempFiles) {
+        probeSplits.push_back(
+            exec::Split(makeHiveConnectorSplit(file->getPath())));
+      }
+      // We add splits that have no rows.
+      auto makeEmpty = [&]() {
+        return exec::Split(
+            HiveConnectorSplitBuilder(tempFiles.back()->getPath())
+                .start(10000000)
+                .length(1)
+                .build());
+      };
+      std::vector<exec::Split> emptyFront = {makeEmpty(), makeEmpty()};
+      std::vector<exec::Split> emptyMiddle = {makeEmpty(), makeEmpty()};
+      probeSplits.insert(
+          probeSplits.begin(), emptyFront.begin(), emptyFront.end());
+      probeSplits.insert(
+          probeSplits.begin() + 13, emptyMiddle.begin(), emptyMiddle.end());
+      SplitInput splits;
+      splits.emplace(nodeId, probeSplits);
+      return splits;
+    };
+  };
+
+  // 100 key values in [35, 233] range.
+  std::vector<RowVectorPtr> buildVectors;
+  for (int i = 0; i < 5; ++i) {
+    buildVectors.push_back(makeRowVector({
+        makeFlatVector<int32_t>(
+            numRowsBuild / 5,
+            [i](auto row) { return 35 + 2 * (row + i * numRowsBuild / 5); }),
+        makeFlatVector<int64_t>(numRowsBuild / 5, [](auto row) { return row; }),
+    }));
+  }
+  std::vector<RowVectorPtr> keyOnlyBuildVectors;
+  for (int i = 0; i < 5; ++i) {
+    keyOnlyBuildVectors.push_back(
+        makeRowVector({makeFlatVector<int32_t>(numRowsBuild / 5, [i](auto row) {
+          return 35 + 2 * (row + i * numRowsBuild / 5);
+        })}));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto probeType = ROW({"c0", "c1", "c2"}, {INTEGER(), BIGINT(), BIGINT()});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto buildSide = PlanBuilder(planNodeIdGenerator, pool_.get())
+                       .values(buildVectors)
+                       .project({"c0 AS u_c0", "c1 AS u_c1"})
+                       .planNode();
+  auto keyOnlyBuildSide = PlanBuilder(planNodeIdGenerator, pool_.get())
+                              .values(keyOnlyBuildVectors)
+                              .project({"c0 AS u_c0"})
+                              .planNode();
+
+  // Basic push-down.
+  {
+    // Inner join.
+    core::PlanNodeId probeScanId;
+    auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
+                  .tableScan(probeType, {"c2 > 0"})
+                  .capturePlanNodeId(probeScanId)
+                  .hashJoin(
+                      {"c0"},
+                      {"u_c0"},
+                      buildSide,
+                      "",
+                      {"c0", "c1", "u_c1"},
+                      core::JoinType::kInner)
+                  .project({"c0", "c1 + 1", "c1 + u_c1"})
+                  .planNode();
+    {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .numDrivers(1)
+          .makeInputSplits(makeInputSplits(probeScanId))
+          .referenceQuery(
+              "SELECT t.c0, t.c1 + 1, t.c1 + u.c1 FROM t, u WHERE t.c0 = u.c0 AND t.c2 > 0")
+          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+            if (hasSpill) {
+              // Dynamic filtering should be disabled with spilling triggered.
+              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
+              ASSERT_EQ(
+                  getInputPositions(task, 1),
+                  numRowsProbe * numNonSkippedSplits);
+            } else {
+              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
+              ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
+              ASSERT_LT(
+                  getInputPositions(task, 1),
+                  numRowsProbe * numNonSkippedSplits);
+            }
+          })
+          .run();
+    }
+
+    // Left semi join.
+    op = PlanBuilder(planNodeIdGenerator, pool_.get())
+             .tableScan(probeType, {"c2 > 0"})
+             .capturePlanNodeId(probeScanId)
+             .hashJoin(
+                 {"c0"},
+                 {"u_c0"},
+                 buildSide,
+                 "",
+                 {"c0", "c1"},
+                 core::JoinType::kLeftSemiFilter)
+             .project({"c0", "c1 + 1"})
+             .planNode();
+
+    {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .numDrivers(1)
+          .makeInputSplits(makeInputSplits(probeScanId))
+          .referenceQuery(
+              "SELECT t.c0, t.c1 + 1 FROM t WHERE t.c0 IN (SELECT c0 FROM u) AND t.c2 > 0")
+          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+            if (hasSpill) {
+              // Dynamic filtering should be disabled with spilling triggered.
+              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
+              ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
+              ASSERT_EQ(
+                  getInputPositions(task, 1),
+                  numRowsProbe * numNonSkippedSplits);
+            } else {
+              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
+              ASSERT_GT(getReplacedWithFilterRows(task, 1).sum, 0);
+              ASSERT_LT(
+                  getInputPositions(task, 1),
+                  numRowsProbe * numNonSkippedSplits);
+            }
+          })
+          .run();
+    }
+
+    // Right semi join.
+    op = PlanBuilder(planNodeIdGenerator, pool_.get())
+             .tableScan(probeType, {"c2 > 0"})
+             .capturePlanNodeId(probeScanId)
+             .hashJoin(
+                 {"c0"},
+                 {"u_c0"},
+                 buildSide,
+                 "",
+                 {"u_c0", "u_c1"},
+                 core::JoinType::kRightSemiFilter)
+             .project({"u_c0", "u_c1 + 1"})
+             .planNode();
+
+    {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .numDrivers(1)
+          .makeInputSplits(makeInputSplits(probeScanId))
+          .referenceQuery(
+              "SELECT u.c0, u.c1 + 1 FROM u WHERE u.c0 IN (SELECT c0 FROM t WHERE t.c2 > 0)")
+          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+            if (hasSpill) {
+              // Dynamic filtering should be disabled with spilling triggered.
+              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
+              ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
+              ASSERT_EQ(
+                  getInputPositions(task, 1),
+                  numRowsProbe * numNonSkippedSplits);
+            } else {
+              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
+              ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
+              ASSERT_LT(
+                  getInputPositions(task, 1),
+                  numRowsProbe * numNonSkippedSplits);
+            }
+          })
+          .run();
+    }
+  }
+
+  // Test with VARCHAR keys.
+  {
+    SCOPED_TRACE("VARCHAR keys with skipped splits");
+
+    std::vector<RowVectorPtr> stringProbeVectors;
+    std::vector<std::shared_ptr<TempFilePath>> stringTempFiles;
+    for (int32_t i = 0; i < numSplits; ++i) {
+      auto rowVector = makeRowVector({
+          makeFlatVector<StringView>(
+              numRowsProbe,
+              [&](auto row) {
+                return StringView::makeInline(
+                    fmt::format("key_{}", row - i * 10));
+              }),
+          makeFlatVector<int64_t>(numRowsProbe, [](auto row) { return row; }),
+          makeFlatVector<int64_t>(
+              numRowsProbe, [&](auto /*row*/) { return i % 2 == 0 ? 0 : i; }),
+      });
+      stringProbeVectors.push_back(rowVector);
+      stringTempFiles.push_back(TempFilePath::create());
+      writeToFile(stringTempFiles.back()->getPath(), rowVector);
+    }
+
+    auto makeStringInputSplits = [&](const core::PlanNodeId& nodeId) {
+      return [&] {
+        std::vector<exec::Split> probeSplits;
+        for (auto& file : stringTempFiles) {
+          probeSplits.push_back(
+              exec::Split(makeHiveConnectorSplit(file->getPath())));
+        }
+        // We add splits that have no rows.
+        auto makeEmpty = [&]() {
+          return exec::Split(
+              HiveConnectorSplitBuilder(stringTempFiles.back()->getPath())
+                  .start(10000000)
+                  .length(1)
+                  .build());
+        };
+        std::vector<exec::Split> emptyFront = {makeEmpty(), makeEmpty()};
+        std::vector<exec::Split> emptyMiddle = {makeEmpty(), makeEmpty()};
+        probeSplits.insert(
+            probeSplits.begin(), emptyFront.begin(), emptyFront.end());
+        probeSplits.insert(
+            probeSplits.begin() + 13, emptyMiddle.begin(), emptyMiddle.end());
+        SplitInput splits;
+        splits.emplace(nodeId, probeSplits);
+        return splits;
+      };
+    };
+
+    // Create build vectors in range [key_35, key_233].
+    std::vector<RowVectorPtr> stringBuildVectors;
+    for (int i = 0; i < 5; ++i) {
+      stringBuildVectors.push_back(makeRowVector({
+          makeFlatVector<StringView>(
+              numRowsBuild / 5,
+              [i](auto row) {
+                return StringView::makeInline(
+                    fmt::format(
+                        "key_{}", 35 + 2 * (row + i * numRowsBuild / 5)));
+              }),
+          makeFlatVector<int64_t>(
+              numRowsBuild / 5, [](auto row) { return row; }),
+      }));
+    }
+
+    createDuckDbTable("t_str_skip", stringProbeVectors);
+    createDuckDbTable("u_str_skip", stringBuildVectors);
+
+    auto stringProbeType =
+        ROW({"c0", "c1", "c2"}, {VARCHAR(), BIGINT(), BIGINT()});
+
+    auto stringBuildSide = PlanBuilder(planNodeIdGenerator, pool_.get())
+                               .values(stringBuildVectors)
+                               .project({"c0 AS u_c0", "c1 AS u_c1"})
+                               .planNode();
+
+    // Inner join.
+    {
+      SCOPED_TRACE("VARCHAR Inner join with skipped splits");
+      core::PlanNodeId probeScanId;
+      auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
+                    .tableScan(stringProbeType, {"c2 > 0"})
+                    .capturePlanNodeId(probeScanId)
+                    .hashJoin(
+                        {"c0"},
+                        {"u_c0"},
+                        stringBuildSide,
+                        "",
+                        {"c0", "c1", "u_c1"},
+                        core::JoinType::kInner)
+                    .project({"c0", "c1 + 1", "c1 + u_c1"})
+                    .planNode();
+
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .numDrivers(1)
+          .makeInputSplits(makeStringInputSplits(probeScanId))
+          .config(
+              core::QueryConfig::kHashProbeDynamicFilterPushdownEnabled, "true")
+          .config(
+              core::QueryConfig::kHashProbeStringDynamicFilterPushdownEnabled,
+              "true")
+          .referenceQuery(
+              "SELECT t_str_skip.c0, t_str_skip.c1 + 1, t_str_skip.c1 + u_str_skip.c1 FROM t_str_skip, u_str_skip WHERE t_str_skip.c0 = u_str_skip.c0 AND t_str_skip.c2 > 0")
+          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+            if (hasSpill) {
+              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
+              ASSERT_EQ(
+                  getInputPositions(task, 1),
+                  numRowsProbe * numNonSkippedSplits);
+            } else {
+              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
+              ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
+              ASSERT_LT(
+                  getInputPositions(task, 1),
+                  numRowsProbe * numNonSkippedSplits);
+            }
+          })
+          .run();
+    }
+
+    // Left semi join.
+    {
+      SCOPED_TRACE("VARCHAR Left semi join with skipped splits");
+      core::PlanNodeId probeScanId;
+      auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
+                    .tableScan(stringProbeType, {"c2 > 0"})
+                    .capturePlanNodeId(probeScanId)
+                    .hashJoin(
+                        {"c0"},
+                        {"u_c0"},
+                        stringBuildSide,
+                        "",
+                        {"c0", "c1"},
+                        core::JoinType::kLeftSemiFilter)
+                    .project({"c0", "c1 + 1"})
+                    .planNode();
+
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .numDrivers(1)
+          .makeInputSplits(makeStringInputSplits(probeScanId))
+          .config(
+              core::QueryConfig::kHashProbeDynamicFilterPushdownEnabled, "true")
+          .config(
+              core::QueryConfig::kHashProbeStringDynamicFilterPushdownEnabled,
+              "true")
+          .referenceQuery(
+              "SELECT t_str_skip.c0, t_str_skip.c1 + 1 FROM t_str_skip WHERE t_str_skip.c0 IN (SELECT c0 FROM u_str_skip) AND t_str_skip.c2 > 0")
+          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+            if (hasSpill) {
+              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
+              ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
+              ASSERT_EQ(
+                  getInputPositions(task, 1),
+                  numRowsProbe * numNonSkippedSplits);
+            } else {
+              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
+              ASSERT_GT(getReplacedWithFilterRows(task, 1).sum, 0);
+              ASSERT_LT(
+                  getInputPositions(task, 1),
+                  numRowsProbe * numNonSkippedSplits);
+            }
+          })
+          .run();
+    }
+
+    // Right semi join.
+    {
+      SCOPED_TRACE("VARCHAR Right semi join with skipped splits");
+      core::PlanNodeId probeScanId;
+      auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
+                    .tableScan(stringProbeType, {"c2 > 0"})
+                    .capturePlanNodeId(probeScanId)
+                    .hashJoin(
+                        {"c0"},
+                        {"u_c0"},
+                        stringBuildSide,
+                        "",
+                        {"u_c0", "u_c1"},
+                        core::JoinType::kRightSemiFilter)
+                    .project({"u_c0", "u_c1 + 1"})
+                    .planNode();
+
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .numDrivers(1)
+          .makeInputSplits(makeStringInputSplits(probeScanId))
+          .config(
+              core::QueryConfig::kHashProbeDynamicFilterPushdownEnabled, "true")
+          .config(
+              core::QueryConfig::kHashProbeStringDynamicFilterPushdownEnabled,
+              "true")
+          .referenceQuery(
+              "SELECT u_str_skip.c0, u_str_skip.c1 + 1 FROM u_str_skip WHERE u_str_skip.c0 IN (SELECT c0 FROM t_str_skip WHERE t_str_skip.c2 > 0)")
+          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+            if (hasSpill) {
+              ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
+              ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
+              ASSERT_EQ(
+                  getInputPositions(task, 1),
+                  numRowsProbe * numNonSkippedSplits);
+            } else {
+              ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
+              ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
+              ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
+              ASSERT_LT(
+                  getInputPositions(task, 1),
+                  numRowsProbe * numNonSkippedSplits);
+            }
+          })
+          .run();
+    }
+  }
+}
+
+TEST_P(HashJoinTest, dynamicFiltersAppliedToPreloadedSplits) {
+  vector_size_t size = 1000;
+  const int32_t numSplits = 5;
+
+  std::vector<RowVectorPtr> probeVectors;
+  probeVectors.reserve(numSplits);
+
+  // Prepare probe side table.
+  std::vector<std::shared_ptr<TempFilePath>> tempFiles;
+  std::vector<exec::Split> probeSplits;
+  for (int32_t i = 0; i < numSplits; ++i) {
+    auto rowVector = makeRowVector(
+        {"p0", "p1"},
+        {
+            makeFlatVector<int64_t>(
+                size, [&](auto row) { return (row + 1) * (i + 1); }),
+            makeFlatVector<int64_t>(size, [&](auto /*row*/) { return i; }),
+        });
+    probeVectors.push_back(rowVector);
+    tempFiles.push_back(TempFilePath::create());
+    writeToFile(tempFiles.back()->getPath(), rowVector);
+  }
+
+  auto makeInputSplits = [&](const core::PlanNodeId& nodeId) {
+    return [&] {
+      std::vector<exec::Split> splits;
+      splits.reserve(tempFiles.size());
+      for (int32_t i = 0; i < tempFiles.size(); ++i) {
+        auto split = HiveConnectorSplitBuilder(tempFiles[i]->getPath())
+                         .partitionKey("p1", std::to_string(i))
+                         .build();
+        splits.emplace_back(exec::Split(split));
+      }
+      SplitInput inputSplits;
+      inputSplits.emplace(nodeId, splits);
+      return inputSplits;
+    };
+  };
+
+  auto outputType = ROW({"p0", "p1"}, {BIGINT(), BIGINT()});
+  connector::ColumnHandleMap assignments = {
+      {"p0", regularColumn("p0", BIGINT())},
+      {"p1", partitionKey("p1", BIGINT())}};
+  createDuckDbTable("p", probeVectors);
+
+  // Prepare build side table.
+  std::vector<RowVectorPtr> buildVectors{
+      makeRowVector({"b0"}, {makeFlatVector<int64_t>({0, numSplits})})};
+  createDuckDbTable("b", buildVectors);
+
+  // Executing the join with p1=b0, we expect a dynamic filter for p1 to prune
+  // the entire file/split. There are total of five splits, and all except the
+  // first one are expected to be pruned. The result 'preloadedSplits' > 1
+  // confirms the successful push of dynamic filters to the preloading data
+  // source.
+  core::PlanNodeId probeScanId;
+  core::PlanNodeId joinNodeId;
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto op =
+      PlanBuilder(planNodeIdGenerator)
+          .startTableScan()
+          .outputType(outputType)
+          .assignments(assignments)
+          .endTableScan()
+          .capturePlanNodeId(probeScanId)
+          .hashJoin(
+              {"p1"},
+              {"b0"},
+              PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode(),
+              "",
+              {"p0"},
+              core::JoinType::kInner)
+          .capturePlanNodeId(joinNodeId)
+          .project({"p0"})
+          .planNode();
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(std::move(op))
+      .config(core::QueryConfig::kMaxSplitPreloadPerDriver, "3")
+      .injectSpill(false)
+      .makeInputSplits(makeInputSplits(probeScanId))
+      .referenceQuery("select p.p0 from p, b where b.b0 = p.p1")
+      .checkSpillStats(false)
+      .verifier([&](const std::shared_ptr<Task>& task, bool /*hasSpill*/) {
+        auto planStats = toPlanStats(task->taskStats());
+        auto getStatSum = [&](const core::PlanNodeId& id,
+                              const std::string& name) {
+          return planStats.at(id).customStats.at(name).sum;
+        };
+        ASSERT_EQ(1, getStatSum(joinNodeId, "dynamicFiltersProduced"));
+        ASSERT_EQ(1, getStatSum(probeScanId, "dynamicFiltersAccepted"));
+        ASSERT_EQ(4, getStatSum(probeScanId, "skippedSplits"));
+        ASSERT_LT(1, getStatSum(probeScanId, "preloadedSplits"));
+      })
+      .run();
+}
+
+TEST_P(HashJoinTest, dynamicFiltersPushDownThroughAgg) {
+  const int32_t numRowsProbe = 300;
+  const int32_t numRowsBuild = 100;
+
+  // Create probe data
+  std::vector<RowVectorPtr> probeVectors{makeRowVector({
+      makeFlatVector<int32_t>(numRowsProbe, [&](auto row) { return row - 10; }),
+      makeFlatVector<int64_t>(numRowsProbe, folly::identity),
+  })};
+  std::shared_ptr<TempFilePath> probeFile = TempFilePath::create();
+  writeToFile(probeFile->getPath(), probeVectors);
+
+  // Create build data
+  std::vector<RowVectorPtr> buildVectors{makeRowVector(
+      {"u0"}, {makeFlatVector<int32_t>(numRowsBuild, [&](auto row) {
+        return 35 + 2 * (row + numRowsBuild / 5);
+      })})};
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto probeType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto buildSide =
+      PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode();
+
+  // Inner join.
+  core::PlanNodeId scanNodeId;
+  core::PlanNodeId joinNodeId;
+  core::PlanNodeId aggNodeId;
+  auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
+                .tableScan(probeType)
+                .capturePlanNodeId(scanNodeId)
+                .partialAggregation({"c0"}, {"sum(c1)"})
+                .capturePlanNodeId(aggNodeId)
+                .hashJoin(
+                    {"c0"},
+                    {"u0"},
+                    buildSide,
+                    "",
+                    {"c0", "a0"},
+                    core::JoinType::kInner)
+                .capturePlanNodeId(joinNodeId)
+                .planNode();
+
+  SplitPath splitPaths = {{scanNodeId, {probeFile->getPath()}}};
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(std::move(op))
+      .inputSplits(splitPaths)
+      .injectSpill(false)
+      .checkSpillStats(false)
+      .referenceQuery("SELECT c0, sum(c1) FROM t, u WHERE c0 = u0 group by c0")
+      .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+        auto planStats = toPlanStats(task->taskStats());
+        auto dynamicFilterStats = planStats.at(scanNodeId).dynamicFilterStats;
+        ASSERT_EQ(
+            1, getFiltersProduced(task, getOperatorIndex(joinNodeId)).sum);
+        ASSERT_EQ(
+            1, getFiltersAccepted(task, getOperatorIndex(scanNodeId)).sum);
+        ASSERT_LT(
+            getInputPositions(task, getOperatorIndex(aggNodeId)), numRowsProbe);
+        ASSERT_EQ(
+            dynamicFilterStats.producerNodeIds,
+            std::unordered_set({joinNodeId}));
+      })
+      .run();
+}
+
+TEST_P(HashJoinTest, noDynamicFiltersPushDownThroughRightJoin) {
+  std::vector<RowVectorPtr> innerBuild = {makeRowVector(
+      {"a"},
+      {
+          makeFlatVector<int64_t>(5, [](auto i) { return 2 * i; }),
+      })};
+  std::vector<RowVectorPtr> rightBuild = {makeRowVector(
+      {"b"},
+      {
+          makeFlatVector<int64_t>(5, [](auto i) { return 1 + 2 * i; }),
+      })};
+  std::vector<RowVectorPtr> rightProbe = {makeRowVector(
+      {"aa", "bb"},
+      {
+          makeFlatVector<int64_t>(10, folly::identity),
+          makeFlatVector<int64_t>(10, folly::identity),
+      })};
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), rightProbe);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId scanNodeId;
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .tableScan(asRowType(rightProbe[0]->type()))
+          .capturePlanNodeId(scanNodeId)
+          .hashJoin(
+              {"bb"},
+              {"b"},
+              PlanBuilder(planNodeIdGenerator).values(rightBuild).planNode(),
+              "",
+              {"aa", "b"},
+              core::JoinType::kRight)
+          .hashJoin(
+              {"aa"},
+              {"a"},
+              PlanBuilder(planNodeIdGenerator).values(innerBuild).planNode(),
+              "",
+              {"aa"})
+          .planNode();
+  AssertQueryBuilder(plan)
+      .split(scanNodeId, Split(makeHiveConnectorSplit(file->getPath())))
+      .assertResults(
+          BaseVector::create<RowVector>(innerBuild[0]->type(), 0, pool_.get()));
+}
+
+// Verify the size of the join output vectors when projecting build-side
+// variable-width column.
+TEST_P(HashJoinTest, memoryUsage) {
+  std::vector<RowVectorPtr> probeVectors =
+      makeBatches(10, [&](int32_t /*unused*/) {
+        return makeRowVector(
+            {makeFlatVector<int32_t>(1'000, [](auto row) { return row % 5; })});
+      });
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(5, [&](int32_t /*unused*/) {
+        return makeRowVector(
+            {"u_c0", "u_c1"},
+            {makeFlatVector<int32_t>({0, 1, 2}),
+             makeFlatVector<std::string>({
+                 std::string(40, 'a'),
+                 std::string(50, 'b'),
+                 std::string(30, 'c'),
+             })});
+      });
+  core::PlanNodeId joinNodeId;
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors)
+                  .hashJoin(
+                      {"c0"},
+                      {"u_c0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .planNode(),
+                      "",
+                      {"c0", "u_c1"})
+                  .capturePlanNodeId(joinNodeId)
+                  .singleAggregation({}, {"count(1)"})
+                  .planNode();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(std::move(plan))
+      .referenceQuery("SELECT 30000")
+      .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+        if (hasSpill) {
+          return;
+        }
+        auto planStats = toPlanStats(task->taskStats());
+        auto outputBytes = planStats.at(joinNodeId).outputBytes;
+        ASSERT_LT(outputBytes, ((40 + 50 + 30) / 3 + 8) * 1000 * 10 * 5);
+        // Verify number of memory allocations. Should not be too high if
+        // hash join is able to re-use output vectors that contain
+        // build-side data.
+        ASSERT_GT(40, task->pool()->stats().numAllocs);
+      })
+      .run();
+}
+
+/// Test an edge case in producing small output batches where the logic to
+/// calculate the set of probe-side rows to load lazy vectors for was
+/// triggering a crash.
+TEST_P(HashJoinTest, smallOutputBatchSize) {
+  // Setup probe data with 50 non-null matching keys followed by 50 null
+  // keys: 1, 2, 1, 2,...null, null.
+  auto probeVectors = makeRowVector({
+      makeFlatVector<int32_t>(
+          100,
+          [](auto row) { return 1 + row % 2; },
+          [](auto row) { return row > 50; }),
+      makeFlatVector<int32_t>(100, [](auto row) { return row * 10; }),
+  });
+
+  // Setup build side to match non-null probe side keys.
+  auto buildVectors = makeRowVector(
+      {"u_c0", "u_c1"},
+      {
+          makeFlatVector<int32_t>({1, 2}),
+          makeFlatVector<int32_t>({100, 200}),
+      });
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  // Plan hash inner join with a filter.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .hashJoin(
+                      {"c0"},
+                      {"u_c0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .planNode(),
+                      "c1 < u_c1",
+                      {"c0", "u_c1"})
+                  .planNode();
+
+  // Use small output batch size to trigger logic for calculating set of
+  // probe-side rows to load lazy vectors for.
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(std::move(plan))
+      .config(core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
+      .referenceQuery("SELECT c0, u_c1 FROM t, u WHERE c0 = u_c0 AND c1 < u_c1")
+      .injectSpill(false)
+      .run();
+}
+
+TEST_P(HashJoinTest, spillFileSize) {
+  const std::vector<uint64_t> maxSpillFileSizes({0, 1, 1'000'000'000});
+  for (const auto spillFileSize : maxSpillFileSizes) {
+    SCOPED_TRACE(fmt::format("spillFileSize: {}", spillFileSize));
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+        .keyTypes({BIGINT()})
+        .probeVectors(100, 3)
+        .buildVectors(100, 3)
+        .referenceQuery(
+            "SELECT t_k0, t_data, u_k0, u_data FROM t, u WHERE t.t_k0 = u.u_k0")
+        .config(core::QueryConfig::kSpillStartPartitionBit, "48")
+        .config(core::QueryConfig::kSpillNumPartitionBits, "3")
+        .config(
+            core::QueryConfig::kMaxSpillFileSize, std::to_string(spillFileSize))
+        .checkSpillStats(false)
+        .maxSpillLevel(0)
+        .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+          if (!hasSpill) {
+            return;
+          }
+          const auto statsPair = taskSpilledStats(*task);
+          const int32_t numPartitions = statsPair.first.spilledPartitions;
+          ASSERT_EQ(statsPair.second.spilledPartitions, numPartitions);
+          const auto fileSizes = numTaskSpillFiles(*task);
+          if (spillFileSize != 1) {
+            ASSERT_EQ(fileSizes.first, numPartitions);
+          } else {
+            ASSERT_GT(fileSizes.first, numPartitions);
+          }
+          verifyTaskSpilledRuntimeStats(*task, true);
+        })
+        .run();
+  }
+}
+
+TEST_P(HashJoinTest, spillPartitionBitsOverlap) {
+  auto builder =
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .numDrivers(numDrivers_)
+          .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+          .keyTypes({BIGINT(), BIGINT()})
+          .probeVectors(2'000, 3)
+          .buildVectors(2'000, 3)
+          .referenceQuery(
+              "SELECT t_k0, t_k1, t_data, u_k0, u_k1, u_data FROM t, u WHERE t_k0 = u_k0 and t_k1 = u_k1")
+          .config(core::QueryConfig::kSpillStartPartitionBit, "8")
+          .config(core::QueryConfig::kSpillNumPartitionBits, "1")
+          .checkSpillStats(false)
+          .maxSpillLevel(0);
+  VELOX_ASSERT_THROW(builder.run(), "vs. 8");
+}
+
+// The test is to verify if the hash build reservation has been released on
+// task error.
+DEBUG_ONLY_TEST_P(HashJoinTest, buildReservationReleaseCheck) {
+  std::vector<RowVectorPtr> probeVectors =
+      makeBatches(1, [&](int32_t /*unused*/) {
+        return std::dynamic_pointer_cast<RowVector>(
+            BatchMaker::createBatch(probeType_, 1000, *pool_));
+      });
+  std::vector<RowVectorPtr> buildVectors = makeBatches(10, [&](int32_t index) {
+    return std::dynamic_pointer_cast<RowVector>(
+        BatchMaker::createBatch(buildType_, 5000 * (1 + index), *pool_));
+  });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  CursorParameters params;
+  params.planNode = PlanBuilder(planNodeIdGenerator)
+                        .values(probeVectors, true)
+                        .hashJoin(
+                            {"t_k1"},
+                            {"u_k1"},
+                            PlanBuilder(planNodeIdGenerator)
+                                .values(buildVectors, true)
+                                .planNode(),
+                            "",
+                            concat(probeType_->names(), buildType_->names()))
+                        .planNode();
+  params.queryCtx = core::QueryCtx::create(driverExecutor_.get());
+  // NOTE: the spilling setup is to trigger memory reservation code path which
+  // only gets executed when spilling is enabled. We don't care about if
+  // spilling is really triggered in test or not.
+  auto spillDirectory = TempDirectoryPath::create();
+  params.spillDirectory = spillDirectory->getPath();
+  params.queryCtx->testingOverrideConfigUnsafe(
+      {{core::QueryConfig::kSpillEnabled, "true"},
+       {core::QueryConfig::kMaxSpillLevel, "0"}});
+  params.maxDrivers = 1;
+
+  auto cursor = TaskCursor::create(params);
+  auto* task = cursor->task().get();
+
+  // Set up a testvalue to trigger task abort when hash build tries to reserve
+  // memory.
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve",
+      std::function<void(memory::MemoryPool*)>(
+          [&](memory::MemoryPool* /*unused*/) { task->requestAbort(); }));
+  auto runTask = [&]() {
+    while (cursor->moveNext()) {
+    }
+  };
+  VELOX_ASSERT_THROW(runTask(), "");
+  ASSERT_TRUE(waitForTaskAborted(task, 5'000'000));
+}
+
+TEST_P(HashJoinTest, dynamicFilterOnPartitionKey) {
+  vector_size_t size = 10;
+  auto filePaths = makeFilePaths(1);
+  auto rowVector = makeRowVector(
+      {makeFlatVector<int64_t>(size, [&](auto row) { return row; })});
+  createDuckDbTable("u", {rowVector});
+  writeToFile(filePaths[0]->getPath(), rowVector);
+  std::vector<RowVectorPtr> buildVectors{
+      makeRowVector({"c0"}, {makeFlatVector<int64_t>({0, 1, 2})})};
+  createDuckDbTable("t", buildVectors);
+  auto outputType = ROW({"n1_0", "n1_1"}, {BIGINT(), BIGINT()});
+  connector::ColumnHandleMap assignments = {
+      {"n1_0", regularColumn("c0", BIGINT())},
+      {"n1_1", partitionKey("k", BIGINT())}};
+
+  core::PlanNodeId probeScanId;
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto op =
+      PlanBuilder(planNodeIdGenerator)
+          .startTableScan()
+          .outputType(outputType)
+          .assignments(assignments)
+          .endTableScan()
+          .capturePlanNodeId(probeScanId)
+          .hashJoin(
+              {"n1_1"},
+              {"c0"},
+              PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode(),
+              "",
+              {"c0"},
+              core::JoinType::kInner)
+          .project({"c0"})
+          .planNode();
+
+  auto makeInputSplits = [&](const core::PlanNodeId& nodeId) {
+    return [&] {
+      auto split = facebook::velox::exec::test::HiveConnectorSplitBuilder(
+                       filePaths[0]->getPath())
+                       .partitionKey("k", "0")
+                       .build();
+      SplitInput splits = {{nodeId, {exec::Split(split)}}};
+      return splits;
+    };
+  };
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(std::move(op))
+      .makeInputSplits(makeInputSplits(probeScanId))
+      .referenceQuery("select t.c0 from t, u where t.c0 = 0")
+      .checkSpillStats(false)
+      .run();
+}
+
+TEST_P(HashJoinTest, probeMemoryLimitOnBuildProjection) {
+  const uint64_t numBuildRows = 20;
+  std::vector<RowVectorPtr> probeVectors =
+      makeBatches(10, [&](int32_t /*unused*/) {
+        return makeRowVector({makeFlatVector<int32_t>(
+            1'000, [](auto row) { return row % 25; })});
+      });
+
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(1, [&](int32_t /*unused*/) {
+        return makeRowVector(
+            {"u_c0", "u_c1", "u_c2", "u_c3", "u_c4"},
+            {makeFlatVector<int32_t>(
+                 numBuildRows, [](auto row) { return row; }),
+             makeFlatVector<std::string>(
+                 numBuildRows,
+                 [](auto /* row */) { return std::string(4096, 'a'); }),
+             makeFlatVector<std::string>(
+                 numBuildRows,
+                 [](auto /* row */) { return std::string(4096, 'a'); }),
+             makeFlatVector<std::string>(
+                 numBuildRows,
+                 [](auto row) {
+                   // Row that has too large of size variation.
+                   if (row == 0) {
+                     return std::string(4096, 'a');
+                   } else {
+                     return std::string(1, 'a');
+                   }
+                 }),
+             makeFlatVector<std::string>(numBuildRows, [](auto row) {
+               // Row that has tolerable size variation.
+               if (row == 0) {
+                 return std::string(4096, 'a');
+               } else {
+                 return std::string(256, 'a');
+               }
+             })});
+      });
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  struct TestParam {
+    std::vector<int32_t> varSizeColumns;
+    int32_t numExpectedBatches;
+    std::string referenceQuery;
+    std::string debugString() const {
+      std::stringstream ss;
+      ss << "varSizeColumns [";
+      for (const auto& columnIndex : varSizeColumns) {
+        ss << columnIndex << ", ";
+      }
+      ss << "] ";
+      ss << "numExpectedBatches " << numExpectedBatches << ", referenceQuery '"
+         << referenceQuery << "'";
+      return ss.str();
+    }
+  };
+
+  std::vector<TestParam> testParams{
+      {{}, 10, "SELECT t.c0 FROM t JOIN u ON t.c0 = u.u_c0"},
+      {{1}, 4000, "SELECT t.c0, u.u_c1 FROM t JOIN u ON t.c0 = u.u_c0"},
+      {{1, 2},
+       8000,
+       "SELECT t.c0, u.u_c1, u.u_c2 FROM t JOIN u ON t.c0 = u.u_c0"},
+      {{3}, 210, "SELECT t.c0, u.u_c3 FROM t JOIN u ON t.c0 = u.u_c0"},
+      {{4}, 2670, "SELECT t.c0, u.u_c4 FROM t JOIN u ON t.c0 = u.u_c0"}};
+
+  for (const auto& testParam : testParams) {
+    SCOPED_TRACE(testParam.debugString());
+    core::PlanNodeId joinNodeId;
+    std::vector<std::string> outputLayout;
+    outputLayout.push_back("c0");
+    for (int32_t i = 0; i < testParam.varSizeColumns.size(); i++) {
+      outputLayout.push_back(fmt::format("u_c{}", testParam.varSizeColumns[i]));
+    }
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(probeVectors)
+                    .hashJoin(
+                        {"c0"},
+                        {"u_c0"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values({buildVectors})
+                            .planNode(),
+                        "",
+                        outputLayout)
+                    .capturePlanNodeId(joinNodeId)
+                    .planNode();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(std::move(plan))
+        .config(core::QueryConfig::kPreferredOutputBatchBytes, "8192")
+        .injectSpill(false)
+        .referenceQuery(testParam.referenceQuery)
+        .verifier([&](const std::shared_ptr<Task>& task, bool /* unused */) {
+          auto planStats = toPlanStats(task->taskStats());
+          auto outputBatches = planStats.at(joinNodeId).outputVectors;
+          ASSERT_EQ(outputBatches, testParam.numExpectedBatches);
+        })
+        .run();
+  }
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, reclaimDuringInputProcessing) {
+  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
+  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
+  const int32_t numBuildVectors = 10;
+  std::vector<RowVectorPtr> buildVectors;
+  for (int32_t i = 0; i < numBuildVectors; ++i) {
+    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
+  }
+  const int32_t numProbeVectors = 5;
+  std::vector<RowVectorPtr> probeVectors;
+  for (int32_t i = 0; i < numProbeVectors; ++i) {
+    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  struct {
+    // 0: trigger reclaim with some input processed.
+    // 1: trigger reclaim after all the inputs processed.
+    int triggerCondition;
+    bool spillEnabled;
+    bool expectedReclaimable;
+
+    std::string debugString() const {
+      return fmt::format(
+          "triggerCondition {}, spillEnabled {}, expectedReclaimable {}",
+          triggerCondition,
+          spillEnabled,
+          expectedReclaimable);
+    }
+  } testSettings[] = {
+      {0, true, true}, {0, true, true}, {0, false, false}, {0, false, false}};
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    auto tempDirectory = TempDirectoryPath::create();
+    auto queryPool = memory::memoryManager()->addRootPool(
+        "", kMaxBytes, memory::MemoryReclaimer::create());
+
+    core::PlanNodeId probeScanId;
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(probeVectors, false)
+                    .hashJoin(
+                        {"t_k1"},
+                        {"u_k1"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildVectors, false)
+                            .planNode(),
+                        "",
+                        concat(probeType_->names(), buildType_->names()))
+                    .planNode();
+
+    folly::EventCount driverWait;
+    auto driverWaitKey = driverWait.prepareWait();
+    folly::EventCount testWait;
+    auto testWaitKey = testWait.prepareWait();
+
+    std::atomic<int> numInputs{0};
+    Operator* op;
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::addInput",
+        std::function<void(Operator*)>(([&](Operator* testOp) {
+          if (testOp->operatorType() != "HashBuild") {
+            return;
+          }
+          op = testOp;
+          ++numInputs;
+          if (testData.triggerCondition == 0) {
+            if (numInputs != 2) {
+              return;
+            }
+          }
+          if (testData.triggerCondition == 1) {
+            if (numInputs != numBuildVectors) {
+              return;
+            }
+          }
+          ASSERT_EQ(op->canReclaim(), testData.expectedReclaimable);
+          uint64_t reclaimableBytes{0};
+          const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
+          ASSERT_EQ(reclaimable, testData.expectedReclaimable);
+          if (testData.expectedReclaimable) {
+            ASSERT_GT(reclaimableBytes, 0);
+          } else {
+            ASSERT_EQ(reclaimableBytes, 0);
+          }
+          testWait.notify();
+          driverWait.wait(driverWaitKey);
+        })));
+
+    std::thread taskThread([&]() {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .numDrivers(numDrivers_)
+          .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+          .planNode(plan)
+          .queryPool(std::move(queryPool))
+          .injectSpill(false)
+          .spillDirectory(testData.spillEnabled ? tempDirectory->getPath() : "")
+          .referenceQuery(
+              "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+          .config(core::QueryConfig::kSpillStartPartitionBit, "29")
+          .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+            const auto statsPair = taskSpilledStats(*task);
+            if (testData.expectedReclaimable) {
+              ASSERT_GT(statsPair.first.spilledBytes, 0);
+              ASSERT_EQ(statsPair.first.spilledPartitions, 8);
+              ASSERT_GT(statsPair.second.spilledBytes, 0);
+              ASSERT_EQ(statsPair.second.spilledPartitions, 8);
+              verifyTaskSpilledRuntimeStats(*task, true);
+            } else {
+              ASSERT_EQ(statsPair.first.spilledBytes, 0);
+              ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+              ASSERT_EQ(statsPair.second.spilledBytes, 0);
+              ASSERT_EQ(statsPair.second.spilledPartitions, 0);
+              verifyTaskSpilledRuntimeStats(*task, false);
+            }
+          })
+          .run();
+    });
+
+    testWait.wait(testWaitKey);
+    ASSERT_TRUE(op != nullptr);
+    auto task = op->operatorCtx()->task();
+    auto taskPauseWait = task->requestPause();
+    driverWait.notify();
+    taskPauseWait.wait();
+
+    uint64_t reclaimableBytes{0};
+    const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
+    ASSERT_EQ(op->canReclaim(), testData.expectedReclaimable);
+    ASSERT_EQ(reclaimable, testData.expectedReclaimable);
+    if (testData.expectedReclaimable) {
+      ASSERT_GT(reclaimableBytes, 0);
+    } else {
+      ASSERT_EQ(reclaimableBytes, 0);
+    }
+
+    if (testData.expectedReclaimable) {
+      {
+        memory::ScopedMemoryArbitrationContext ctx(op->pool());
+        op->pool()->reclaim(
+            folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
+            0,
+            reclaimerStats_);
+      }
+      ASSERT_GT(reclaimerStats_.reclaimExecTimeUs, 0);
+      ASSERT_GT(reclaimerStats_.reclaimedBytes, 0);
+      reclaimerStats_.reset();
+      ASSERT_EQ(op->pool()->usedBytes(), 0);
+    } else {
+      VELOX_ASSERT_THROW(
+          op->reclaim(
+              folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
+              reclaimerStats_),
+          "");
+    }
+
+    Task::resume(task);
+    task.reset();
+
+    taskThread.join();
+  }
+  ASSERT_EQ(reclaimerStats_, memory::MemoryReclaimer::Stats{});
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, reclaimDuringReserve) {
+  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
+  const int32_t numBuildVectors = 3;
+  std::vector<RowVectorPtr> buildVectors;
+  for (int32_t i = 0; i < numBuildVectors; ++i) {
+    const size_t size = i == 0 ? 1 : 1'000;
+    VectorFuzzer fuzzer({.vectorSize = size}, pool());
+    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
+  }
+
+  const int32_t numProbeVectors = 3;
+  std::vector<RowVectorPtr> probeVectors;
+  for (int32_t i = 0; i < numProbeVectors; ++i) {
+    VectorFuzzer fuzzer({.vectorSize = 1'000}, pool());
+    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto tempDirectory = TempDirectoryPath::create();
+  auto queryPool = memory::memoryManager()->addRootPool(
+      "", kMaxBytes, memory::MemoryReclaimer::create());
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors, false)
+                  .hashJoin(
+                      {"t_k1"},
+                      {"u_k1"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors, false)
+                          .planNode(),
+                      "",
+                      concat(probeType_->names(), buildType_->names()))
+                  .planNode();
+
+  folly::EventCount driverWait;
+  std::atomic_bool driverWaitFlag{true};
+  folly::EventCount testWait;
+  std::atomic_bool testWaitFlag{true};
+
+  Operator* op{nullptr};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::addInput",
+      std::function<void(Operator*)>(([&](Operator* testOp) {
+        if (testOp->operatorType() != "HashBuild") {
+          return;
+        }
+        op = testOp;
+      })));
+
+  std::atomic<bool> injectOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve",
+      std::function<void(memory::MemoryPoolImpl*)>(
+          ([&](memory::MemoryPoolImpl* pool) {
+            ASSERT_TRUE(op != nullptr);
+            if (!isHashBuildMemoryPool(*pool)) {
+              return;
+            }
+            ASSERT_TRUE(op->canReclaim());
+            if (op->pool()->usedBytes() == 0) {
+              // We skip trigger memory reclaim when the hash table is empty on
+              // memory reservation.
+              return;
+            }
+            if (!injectOnce.exchange(false)) {
+              return;
+            }
+            uint64_t reclaimableBytes{0};
+            const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
+            ASSERT_TRUE(reclaimable);
+            ASSERT_GT(reclaimableBytes, 0);
+            auto* driver = op->operatorCtx()->driver();
+            TestSuspendedSection suspendedSection(driver);
+            testWaitFlag = false;
+            testWait.notifyAll();
+            driverWait.await([&]() { return !driverWaitFlag.load(); });
+          })));
+
+  std::thread taskThread([&]() {
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+        .planNode(plan)
+        .queryPool(std::move(queryPool))
+        .injectSpill(false)
+        .spillDirectory(tempDirectory->getPath())
+        .referenceQuery(
+            "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+        .config(core::QueryConfig::kSpillStartPartitionBit, "29")
+        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+          const auto statsPair = taskSpilledStats(*task);
+          ASSERT_GT(statsPair.first.spilledBytes, 0);
+          ASSERT_EQ(statsPair.first.spilledPartitions, 8);
+          ASSERT_GT(statsPair.second.spilledBytes, 0);
+          ASSERT_EQ(statsPair.second.spilledPartitions, 8);
+          verifyTaskSpilledRuntimeStats(*task, true);
+        })
+        .run();
+  });
+
+  testWait.await([&]() { return !testWaitFlag.load(); });
+  ASSERT_TRUE(op != nullptr);
+  auto task = op->operatorCtx()->task();
+  task->requestPause().wait();
+
+  uint64_t reclaimableBytes{0};
+  const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
+  ASSERT_TRUE(op->canReclaim());
+  ASSERT_TRUE(reclaimable);
+  ASSERT_GT(reclaimableBytes, 0);
+
+  {
+    memory::ScopedMemoryArbitrationContext ctx(op->pool());
+    uint64_t reclaimedBytes = task->pool()->reclaim(
+        folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
+        0,
+        reclaimerStats_);
+    ASSERT_GT(reclaimedBytes, 0);
+  }
+  ASSERT_GT(reclaimerStats_.reclaimedBytes, 0);
+  ASSERT_GT(reclaimerStats_.reclaimExecTimeUs, 0);
+  ASSERT_EQ(op->pool()->usedBytes(), 0);
+
+  driverWaitFlag = false;
+  driverWait.notifyAll();
+  Task::resume(task);
+  task.reset();
+
+  taskThread.join();
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, reclaimDuringAllocation) {
+  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
+  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
+  const int32_t numBuildVectors = 10;
+  std::vector<RowVectorPtr> buildVectors;
+  for (int32_t i = 0; i < numBuildVectors; ++i) {
+    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
+  }
+  const int32_t numProbeVectors = 5;
+  std::vector<RowVectorPtr> probeVectors;
+  for (int32_t i = 0; i < numProbeVectors; ++i) {
+    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  const std::vector<bool> enableSpillings = {false, true};
+  for (const auto enableSpilling : enableSpillings) {
+    SCOPED_TRACE(fmt::format("enableSpilling {}", enableSpilling));
+
+    auto tempDirectory = TempDirectoryPath::create();
+    auto queryPool = memory::memoryManager()->addRootPool("", kMaxBytes);
+
+    core::PlanNodeId probeScanId;
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(probeVectors, false)
+                    .hashJoin(
+                        {"t_k1"},
+                        {"u_k1"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildVectors, false)
+                            .planNode(),
+                        "",
+                        concat(probeType_->names(), buildType_->names()))
+                    .planNode();
+
+    folly::EventCount driverWait;
+    auto driverWaitKey = driverWait.prepareWait();
+    folly::EventCount testWait;
+    auto testWaitKey = testWait.prepareWait();
+
+    Operator* op;
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::addInput",
+        std::function<void(Operator*)>(([&](Operator* testOp) {
+          if (testOp->operatorType() != "HashBuild") {
+            return;
+          }
+          op = testOp;
+        })));
+
+    std::atomic<bool> injectOnce{true};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::common::memory::MemoryPoolImpl::allocateNonContiguous",
+        std::function<void(memory::MemoryPoolImpl*)>(
+            ([&](memory::MemoryPoolImpl* pool) {
+              ASSERT_TRUE(op != nullptr);
+              const std::string re(".*HashBuild");
+              if (!RE2::FullMatch(pool->name(), re)) {
+                return;
+              }
+              if (!injectOnce.exchange(false)) {
+                return;
+              }
+              ASSERT_EQ(op->canReclaim(), enableSpilling);
+              uint64_t reclaimableBytes{0};
+              const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
+              ASSERT_EQ(reclaimable, enableSpilling);
+              if (enableSpilling) {
+                ASSERT_GE(reclaimableBytes, 0);
+              } else {
+                ASSERT_EQ(reclaimableBytes, 0);
+              }
+              auto* driver = op->operatorCtx()->driver();
+              TestSuspendedSection suspendedSection(driver);
+              testWait.notify();
+              driverWait.wait(driverWaitKey);
+            })));
+
+    std::thread taskThread([&]() {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .numDrivers(numDrivers_)
+          .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+          .planNode(plan)
+          .queryPool(std::move(queryPool))
+          .injectSpill(false)
+          .spillDirectory(enableSpilling ? tempDirectory->getPath() : "")
+          .referenceQuery(
+              "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+          .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+            const auto statsPair = taskSpilledStats(*task);
+            ASSERT_EQ(statsPair.first.spilledBytes, 0);
+            ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+            ASSERT_EQ(statsPair.second.spilledBytes, 0);
+            ASSERT_EQ(statsPair.second.spilledPartitions, 0);
+            verifyTaskSpilledRuntimeStats(*task, false);
+          })
+          .run();
+    });
+
+    testWait.wait(testWaitKey);
+    ASSERT_TRUE(op != nullptr);
+    auto task = op->operatorCtx()->task();
+    auto taskPauseWait = task->requestPause();
+    taskPauseWait.wait();
+
+    uint64_t reclaimableBytes{0};
+    const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
+    ASSERT_EQ(op->canReclaim(), enableSpilling);
+    ASSERT_EQ(reclaimable, enableSpilling);
+    if (enableSpilling) {
+      ASSERT_GE(reclaimableBytes, 0);
+    } else {
+      ASSERT_EQ(reclaimableBytes, 0);
+    }
+    VELOX_ASSERT_THROW(
+        op->reclaim(
+            folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
+            reclaimerStats_),
+        "");
+
+    driverWait.notify();
+    Task::resume(task);
+    task.reset();
+
+    taskThread.join();
+  }
+  ASSERT_EQ(reclaimerStats_, memory::MemoryReclaimer::Stats{0});
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, reclaimDuringOutputProcessing) {
+  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
+  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
+  const int32_t numBuildVectors = 10;
+  std::vector<RowVectorPtr> buildVectors;
+  for (int32_t i = 0; i < numBuildVectors; ++i) {
+    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
+  }
+  const int32_t numProbeVectors = 5;
+  std::vector<RowVectorPtr> probeVectors;
+  for (int32_t i = 0; i < numProbeVectors; ++i) {
+    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  const std::vector<bool> enableSpillings = {false, true};
+  for (const auto enableSpilling : enableSpillings) {
+    SCOPED_TRACE(fmt::format("enableSpilling {}", enableSpilling));
+    auto tempDirectory = TempDirectoryPath::create();
+    auto queryPool = memory::memoryManager()->addRootPool(
+        "", kMaxBytes, memory::MemoryReclaimer::create());
+
+    core::PlanNodeId probeScanId;
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(probeVectors, false)
+                    .hashJoin(
+                        {"t_k1"},
+                        {"u_k1"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildVectors, false)
+                            .planNode(),
+                        "",
+                        concat(probeType_->names(), buildType_->names()))
+                    .planNode();
+
+    std::atomic_bool driverWaitFlag{true};
+    folly::EventCount driverWait;
+    std::atomic_bool testWaitFlag{true};
+    folly::EventCount testWait;
+
+    std::atomic<bool> injectOnce{true};
+    Operator* op;
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::noMoreInput",
+        std::function<void(Operator*)>(([&](Operator* testOp) {
+          if (testOp->operatorType() != "HashBuild") {
+            return;
+          }
+          op = testOp;
+          if (!injectOnce.exchange(false)) {
+            return;
+          }
+          ASSERT_EQ(op->canReclaim(), enableSpilling);
+          uint64_t reclaimableBytes{0};
+          const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
+          ASSERT_EQ(reclaimable, enableSpilling);
+          if (enableSpilling) {
+            ASSERT_GT(reclaimableBytes, 0);
+          } else {
+            ASSERT_EQ(reclaimableBytes, 0);
+          }
+          testWaitFlag = false;
+          testWait.notifyAll();
+          driverWait.await([&]() { return !driverWaitFlag.load(); });
+        })));
+
+    std::thread taskThread([&]() {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .numDrivers(numDrivers_)
+          .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+          .planNode(plan)
+          .queryPool(std::move(queryPool))
+          .injectSpill(false)
+          .spillDirectory(enableSpilling ? tempDirectory->getPath() : "")
+          .referenceQuery(
+              "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+          .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+            const auto statsPair = taskSpilledStats(*task);
+            ASSERT_EQ(statsPair.first.spilledBytes, 0);
+            ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+            ASSERT_EQ(statsPair.second.spilledBytes, 0);
+            ASSERT_EQ(statsPair.second.spilledPartitions, 0);
+            verifyTaskSpilledRuntimeStats(*task, false);
+          })
+          .run();
+    });
+
+    testWait.await([&]() { return !testWaitFlag.load(); });
+    ASSERT_TRUE(op != nullptr);
+    auto task = op->operatorCtx()->task();
+    auto taskPauseWait = task->requestPause();
+    driverWaitFlag = false;
+    driverWait.notifyAll();
+    taskPauseWait.wait();
+
+    uint64_t reclaimableBytes{0};
+    const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
+    ASSERT_EQ(op->canReclaim(), enableSpilling);
+    ASSERT_EQ(reclaimable, enableSpilling);
+
+    if (enableSpilling) {
+      ASSERT_GT(reclaimableBytes, 0);
+      const auto usedMemoryBytes = op->pool()->usedBytes();
+      {
+        memory::ScopedMemoryArbitrationContext ctx(op->pool());
+        op->pool()->reclaim(
+            folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
+            0,
+            reclaimerStats_);
+      }
+      ASSERT_GE(reclaimerStats_.reclaimedBytes, 0);
+      ASSERT_GT(reclaimerStats_.reclaimExecTimeUs, 0);
+      // No reclaim as the operator has started output processing.
+      ASSERT_EQ(usedMemoryBytes, op->pool()->usedBytes());
+    } else {
+      ASSERT_EQ(reclaimableBytes, 0);
+      VELOX_ASSERT_THROW(
+          op->reclaim(
+              folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
+              reclaimerStats_),
+          "");
+    }
+
+    Task::resume(task);
+    task.reset();
+
+    taskThread.join();
+  }
+  ASSERT_EQ(reclaimerStats_.numNonReclaimableAttempts, 1);
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, reclaimDuringWaitForProbe) {
+  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
+  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
+  const int32_t numBuildVectors = 10;
+  std::vector<RowVectorPtr> buildVectors;
+  for (int32_t i = 0; i < numBuildVectors; ++i) {
+    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
+  }
+  const int32_t numProbeVectors = 5;
+  std::vector<RowVectorPtr> probeVectors;
+  for (int32_t i = 0; i < numProbeVectors; ++i) {
+    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto tempDirectory = TempDirectoryPath::create();
+  auto queryPool = memory::memoryManager()->addRootPool(
+      "", kMaxBytes, memory::MemoryReclaimer::create());
+
+  core::PlanNodeId probeScanId;
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors, false)
+                  .hashJoin(
+                      {"t_k1"},
+                      {"u_k1"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors, false)
+                          .planNode(),
+                      "",
+                      concat(probeType_->names(), buildType_->names()))
+                  .planNode();
+
+  std::atomic_bool driverWaitFlag{true};
+  folly::EventCount driverWait;
+  std::atomic_bool testWaitFlag{true};
+  folly::EventCount testWait;
+
+  Operator* op{nullptr};
+  std::atomic<bool> injectSpillOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashBuild::finishHashBuild",
+      std::function<void(Operator*)>(([&](Operator* testOp) {
+        if (testOp->operatorType() != "HashBuild") {
+          return;
+        }
+        op = testOp;
+        if (!injectSpillOnce.exchange(false)) {
+          return;
+        }
+        auto* driver = op->operatorCtx()->driver();
+        auto task = driver->task();
+        memory::ScopedMemoryArbitrationContext ctx(op->pool());
+        Operator::ReclaimableSectionGuard guard(testOp);
+        testingRunArbitration(testOp->pool());
+      })));
+
+  std::atomic<bool> injectOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::noMoreInput",
+      std::function<void(Operator*)>(([&](Operator* testOp) {
+        if (testOp->operatorType() != "HashProbe") {
+          return;
+        }
+        if (!injectOnce.exchange(false)) {
+          return;
+        }
+        ASSERT_TRUE(op != nullptr);
+        ASSERT_TRUE(op->canReclaim());
+        uint64_t reclaimableBytes{0};
+        const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
+        ASSERT_TRUE(reclaimable);
+        ASSERT_GT(reclaimableBytes, 0);
+        testWaitFlag = false;
+        testWait.notifyAll();
+        auto* driver = testOp->operatorCtx()->driver();
+        auto task = driver->task();
+        TestSuspendedSection suspendedSection(driver);
+        driverWait.await([&]() { return !driverWaitFlag.load(); });
+      })));
+
+  std::thread taskThread([&]() {
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+        .planNode(plan)
+        .queryPool(std::move(queryPool))
+        .injectSpill(false)
+        .spillDirectory(tempDirectory->getPath())
+        .referenceQuery(
+            "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+        .config(core::QueryConfig::kSpillStartPartitionBit, "29")
+        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+          const auto statsPair = taskSpilledStats(*task);
+          ASSERT_GT(statsPair.first.spilledBytes, 0);
+          ASSERT_EQ(statsPair.first.spilledPartitions, 8);
+          ASSERT_GT(statsPair.second.spilledBytes, 0);
+          ASSERT_EQ(statsPair.second.spilledPartitions, 8);
+        })
+        .run();
+  });
+
+  testWait.await([&]() { return !testWaitFlag.load(); });
+  ASSERT_TRUE(op != nullptr);
+  auto task = op->operatorCtx()->task();
+  auto taskPauseWait = task->requestPause();
+  taskPauseWait.wait();
+
+  uint64_t reclaimableBytes{0};
+  const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
+  ASSERT_TRUE(op->canReclaim());
+  ASSERT_TRUE(reclaimable);
+  ASSERT_GT(reclaimableBytes, 0);
+
+  const auto usedMemoryBytes = op->pool()->usedBytes();
+  reclaimerStats_.reset();
+  {
+    memory::ScopedMemoryArbitrationContext ctx(op->pool());
+    op->pool()->reclaim(
+        folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
+        0,
+        reclaimerStats_);
+  }
+  ASSERT_GE(reclaimerStats_.reclaimedBytes, 0);
+  ASSERT_GT(reclaimerStats_.reclaimExecTimeUs, 0);
+  //  No reclaim as the build operator is not in building table state.
+  ASSERT_EQ(usedMemoryBytes, op->pool()->usedBytes());
+
+  driverWaitFlag = false;
+  driverWait.notifyAll();
+  Task::resume(task);
+  task.reset();
+
+  taskThread.join();
+  ASSERT_EQ(reclaimerStats_.numNonReclaimableAttempts, 1);
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, hashBuildAbortDuringOutputProcessing) {
+  const auto buildVectors = makeVectors(buildType_, 10, 128);
+  const auto probeVectors = makeVectors(probeType_, 5, 128);
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  struct {
+    bool abortFromRootMemoryPool;
+    int numDrivers;
+
+    std::string debugString() const {
+      return fmt::format(
+          "abortFromRootMemoryPool {} numDrivers {}",
+          abortFromRootMemoryPool,
+          numDrivers);
+    }
+  } testSettings[] = {{true, 1}, {false, 1}, {true, 4}, {false, 4}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(probeVectors, true)
+                    .hashJoin(
+                        {"t_k1"},
+                        {"u_k1"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildVectors, true)
+                            .planNode(),
+                        "",
+                        concat(probeType_->names(), buildType_->names()))
+                    .planNode();
+
+    std::atomic<bool> injectOnce{true};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::noMoreInput",
+        std::function<void(Operator*)>(([&](Operator* op) {
+          if (op->operatorType() != "HashBuild") {
+            return;
+          }
+          if (!injectOnce.exchange(false)) {
+            return;
+          }
+          ASSERT_GT(op->pool()->usedBytes(), 0);
+          auto* driver = op->operatorCtx()->driver();
+          ASSERT_EQ(
+              driver->task()->enterSuspended(driver->state()),
+              StopReason::kNone);
+          testData.abortFromRootMemoryPool ? abortPool(op->pool()->root())
+                                           : abortPool(op->pool());
+          // We can't directly reclaim memory from this hash build operator as
+          // its driver thread is running and in suspension state.
+          ASSERT_GT(op->pool()->root()->usedBytes(), 0);
+          ASSERT_EQ(
+              driver->task()->leaveSuspended(driver->state()),
+              StopReason::kAlreadyTerminated);
+          ASSERT_TRUE(op->pool()->aborted());
+          ASSERT_TRUE(op->pool()->root()->aborted());
+          VELOX_MEM_POOL_ABORTED("Memory pool aborted");
+        })));
+
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .numDrivers(numDrivers_)
+            .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+            .planNode(plan)
+            .injectSpill(false)
+            .referenceQuery(
+                "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+            .run(),
+        "Manual MemoryPool Abortion");
+    waitForAllTasksToBeDeleted();
+  }
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, hashBuildAbortDuringInputProcessing) {
+  const auto buildVectors = makeVectors(buildType_, 10, 128);
+  const auto probeVectors = makeVectors(probeType_, 5, 128);
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  struct {
+    bool abortFromRootMemoryPool;
+    int numDrivers;
+
+    std::string debugString() const {
+      return fmt::format(
+          "abortFromRootMemoryPool {} numDrivers {}",
+          abortFromRootMemoryPool,
+          numDrivers);
+    }
+  } testSettings[] = {{true, 1}, {false, 1}, {true, 4}, {false, 4}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(probeVectors, true)
+                    .hashJoin(
+                        {"t_k1"},
+                        {"u_k1"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildVectors, true)
+                            .planNode(),
+                        "",
+                        concat(probeType_->names(), buildType_->names()))
+                    .planNode();
+
+    std::atomic<int> numInputs{0};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::addInput",
+        std::function<void(Operator*)>(([&](Operator* op) {
+          if (op->operatorType() != "HashBuild") {
+            return;
+          }
+          if (++numInputs != 2) {
+            return;
+          }
+          ASSERT_GT(op->pool()->usedBytes(), 0);
+          auto* driver = op->operatorCtx()->driver();
+          ASSERT_EQ(
+              driver->task()->enterSuspended(driver->state()),
+              StopReason::kNone);
+          testData.abortFromRootMemoryPool ? abortPool(op->pool()->root())
+                                           : abortPool(op->pool());
+          // We can't directly reclaim memory from this hash build operator as
+          // its driver thread is running and in suspension state.
+          ASSERT_GT(op->pool()->root()->usedBytes(), 0);
+          ASSERT_EQ(
+              driver->task()->leaveSuspended(driver->state()),
+              StopReason::kAlreadyTerminated);
+          ASSERT_TRUE(op->pool()->aborted());
+          ASSERT_TRUE(op->pool()->root()->aborted());
+          VELOX_MEM_POOL_ABORTED("Memory pool aborted");
+        })));
+
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .numDrivers(numDrivers_)
+            .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+            .planNode(plan)
+            .injectSpill(false)
+            .referenceQuery(
+                "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+            .run(),
+        "Manual MemoryPool Abortion");
+
+    waitForAllTasksToBeDeleted();
+  }
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, hashBuildAbortDuringAllocation) {
+  const auto buildVectors = makeVectors(buildType_, 10, 128);
+  const auto probeVectors = makeVectors(probeType_, 5, 128);
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  struct {
+    bool abortFromRootMemoryPool;
+    int numDrivers;
+
+    std::string debugString() const {
+      return fmt::format(
+          "abortFromRootMemoryPool {} numDrivers {}",
+          abortFromRootMemoryPool,
+          numDrivers);
+    }
+  } testSettings[] = {{true, 1}, {false, 1}, {true, 4}, {false, 4}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(probeVectors, true)
+                    .hashJoin(
+                        {"t_k1"},
+                        {"u_k1"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildVectors, true)
+                            .planNode(),
+                        "",
+                        concat(probeType_->names(), buildType_->names()))
+                    .planNode();
+
+    std::atomic_bool injectOnce{true};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::common::memory::MemoryPoolImpl::allocateNonContiguous",
+        std::function<void(memory::MemoryPoolImpl*)>(
+            ([&](memory::MemoryPoolImpl* pool) {
+              if (!isHashBuildMemoryPool(*pool)) {
+                return;
+              }
+              if (!injectOnce.exchange(false)) {
+                return;
+              }
+
+              const auto* driverCtx = driverThreadContext()->driverCtx();
+              ASSERT_EQ(
+                  driverCtx->task->enterSuspended(driverCtx->driver->state()),
+                  StopReason::kNone);
+              testData.abortFromRootMemoryPool ? abortPool(pool->root())
+                                               : abortPool(pool);
+              // We can't directly reclaim memory from this hash build operator
+              // as its driver thread is running and in suspegnsion state.
+              ASSERT_GE(pool->root()->usedBytes(), 0);
+              ASSERT_EQ(
+                  driverCtx->task->leaveSuspended(driverCtx->driver->state()),
+                  StopReason::kAlreadyTerminated);
+              ASSERT_TRUE(pool->aborted());
+              ASSERT_TRUE(pool->root()->aborted());
+              VELOX_MEM_POOL_ABORTED("Memory pool aborted");
+            })));
+
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .numDrivers(numDrivers_)
+            .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+            .planNode(plan)
+            .injectSpill(false)
+            .referenceQuery(
+                "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+            .run(),
+        "Manual MemoryPool Abortion");
+
+    waitForAllTasksToBeDeleted();
+  }
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, hashProbeAbortDuringInputProcessing) {
+  const auto buildVectors = makeVectors(buildType_, 10, 128);
+  const auto probeVectors = makeVectors(probeType_, 5, 128);
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  struct {
+    bool abortFromRootMemoryPool;
+    int numDrivers;
+
+    std::string debugString() const {
+      return fmt::format(
+          "abortFromRootMemoryPool {} numDrivers {}",
+          abortFromRootMemoryPool,
+          numDrivers);
+    }
+  } testSettings[] = {{true, 1}, {false, 1}, {true, 4}, {false, 4}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(probeVectors, true)
+                    .hashJoin(
+                        {"t_k1"},
+                        {"u_k1"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildVectors, true)
+                            .planNode(),
+                        "",
+                        concat(probeType_->names(), buildType_->names()))
+                    .planNode();
+
+    std::atomic<int> numInputs{0};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::addInput",
+        std::function<void(Operator*)>(([&](Operator* op) {
+          if (op->operatorType() != "HashProbe") {
+            return;
+          }
+          if (++numInputs != 2) {
+            return;
+          }
+          auto* driver = op->operatorCtx()->driver();
+          ASSERT_EQ(
+              driver->task()->enterSuspended(driver->state()),
+              StopReason::kNone);
+          testData.abortFromRootMemoryPool ? abortPool(op->pool()->root())
+                                           : abortPool(op->pool());
+          ASSERT_EQ(
+              driver->task()->leaveSuspended(driver->state()),
+              StopReason::kAlreadyTerminated);
+          ASSERT_TRUE(op->pool()->aborted());
+          ASSERT_TRUE(op->pool()->root()->aborted());
+          VELOX_MEM_POOL_ABORTED("Memory pool aborted");
+        })));
+
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .numDrivers(numDrivers_)
+            .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+            .planNode(plan)
+            .injectSpill(false)
+            .referenceQuery(
+                "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+            .run(),
+        "Manual MemoryPool Abortion");
+    waitForAllTasksToBeDeleted();
+  }
+}
+
+TEST_P(HashJoinTest, leftJoinWithMissAtEndOfBatch) {
+  // Tests some cases where the row at the end of an output batch fails the
+  // filter.
+  auto probeVectors = std::vector<RowVectorPtr>{makeRowVector(
+      {"t_k1", "t_k2"},
+      {makeFlatVector<int32_t>(20, [](auto row) { return 1 + row % 2; }),
+       makeFlatVector<int32_t>(20, [](auto row) { return row; })})};
+  auto buildVectors = std::vector<RowVectorPtr>{
+      makeRowVector({"u_k1"}, {makeFlatVector<int32_t>({1, 2})})};
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", {buildVectors});
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto test = [&](const std::string& filter) {
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(probeVectors, true)
+                    .hashJoin(
+                        {"t_k1"},
+                        {"u_k1"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildVectors, true)
+                            .planNode(),
+                        filter,
+                        {"t_k1", "u_k1"},
+                        core::JoinType::kLeft)
+                    .planNode();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(plan)
+        .injectSpill(false)
+        .checkSpillStats(false)
+        .maxSpillLevel(0)
+        .numDrivers(1)
+        .config(
+            core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
+        .referenceQuery(
+            fmt::format(
+                "SELECT t_k1, u_k1 from t left join u on t_k1 = u_k1 and {}",
+                filter))
+        .run();
+  };
+
+  // Alternate rows pass this filter and last row of a batch fails.
+  test("t_k1=1");
+
+  // All rows fail this filter.
+  test("t_k1=5");
+
+  // All rows in the second batch pass this filter.
+  test("t_k2 > 9");
+}
+
+TEST_P(HashJoinTest, leftJoinWithMissAtEndOfBatchMultipleBuildMatches) {
+  // Tests some cases where the row at the end of an output batch fails the
+  // filter and there are multiple matches with the build side..
+  auto probeVectors = std::vector<RowVectorPtr>{makeRowVector(
+      {"t_k1", "t_k2"},
+      {makeFlatVector<int32_t>(10, [](auto row) { return 1 + row % 2; }),
+       makeFlatVector<int32_t>(10, [](auto row) { return row; })})};
+  auto buildVectors = std::vector<RowVectorPtr>{
+      makeRowVector({"u_k1"}, {makeFlatVector<int32_t>({1, 2, 1, 2})})};
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", {buildVectors});
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto test = [&](const std::string& filter) {
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(probeVectors, true)
+                    .hashJoin(
+                        {"t_k1"},
+                        {"u_k1"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildVectors, true)
+                            .planNode(),
+                        filter,
+                        {"t_k1", "u_k1"},
+                        core::JoinType::kLeft)
+                    .planNode();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(plan)
+        .injectSpill(false)
+        .checkSpillStats(false)
+        .maxSpillLevel(0)
+        .numDrivers(1)
+        .config(
+            core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
+        .referenceQuery(
+            fmt::format(
+                "SELECT t_k1, u_k1 from t left join u on t_k1 = u_k1 and {}",
+                filter))
+        .run();
+  };
+
+  // In this case the rows with t_k2 = 4 appear at the end of the first batch,
+  // meaning the last rows in that output batch are misses, and don't get added.
+  // The rows with t_k2 = 8 appear in the second batch so only one row is
+  // written, meaning there is space in the second output batch for the miss
+  // with tk_2 = 4 to get written.
+  test("t_k2 != 4 and t_k2 != 8");
+}
+
+TEST_P(HashJoinTest, leftJoinPreserveProbeOrder) {
+  const std::vector<RowVectorPtr> probeVectors = {
+      makeRowVector(
+          {"k1", "v1"},
+          {
+              makeConstant<int64_t>(0, 2),
+              makeFlatVector<int64_t>({1, 0}),
+          }),
+  };
+  const std::vector<RowVectorPtr> buildVectors = {
+      makeRowVector(
+          {"k2", "v2"},
+          {
+              makeConstant<int64_t>(0, 2),
+              makeConstant<int64_t>(0, 2),
+          }),
+  };
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values(probeVectors)
+          .hashJoin(
+              {"k1"},
+              {"k2"},
+              PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode(),
+              "v1 % 2 = v2 % 2",
+              {"v1"},
+              core::JoinType::kLeft)
+          .planNode();
+  auto result = AssertQueryBuilder(plan)
+                    .config(core::QueryConfig::kPreferredOutputBatchRows, "1")
+                    .serialExecution(true)
+                    .copyResults(pool_.get());
+  ASSERT_EQ(result->size(), 3);
+  auto* v1 =
+      result->childAt(0)->loadedVector()->asUnchecked<SimpleVector<int64_t>>();
+  ASSERT_FALSE(v1->mayHaveNulls());
+  ASSERT_EQ(v1->valueAt(0), 1);
+  ASSERT_EQ(v1->valueAt(1), 0);
+  ASSERT_EQ(v1->valueAt(2), 0);
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, minSpillableMemoryReservation) {
+  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
+  const int32_t numBuildVectors = 10;
+  std::vector<RowVectorPtr> buildVectors;
+  for (int32_t i = 0; i < numBuildVectors; ++i) {
+    buildVectors.push_back(fuzzer.fuzzInputRow(buildType_));
+  }
+  const int32_t numProbeVectors = 5;
+  std::vector<RowVectorPtr> probeVectors;
+  for (int32_t i = 0; i < numProbeVectors; ++i) {
+    probeVectors.push_back(fuzzer.fuzzInputRow(probeType_));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  core::PlanNodeId probeScanId;
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors, false)
+                  .hashJoin(
+                      {"t_k1"},
+                      {"u_k1"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors, false)
+                          .planNode(),
+                      "",
+                      concat(probeType_->names(), buildType_->names()))
+                  .planNode();
+
+  for (int32_t minSpillableReservationPct : {5, 50, 100}) {
+    SCOPED_TRACE(
+        fmt::format(
+            "minSpillableReservationPct: {}", minSpillableReservationPct));
+
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::HashBuild::addInput",
+        std::function<void(exec::HashBuild*)>(([&](exec::HashBuild* hashBuild) {
+          memory::MemoryPool* pool = hashBuild->pool();
+          const auto availableReservationBytes = pool->availableReservation();
+          const auto currentUsedBytes = pool->usedBytes();
+          // Verifies we always have min reservation after ensuring the input.
+          ASSERT_GE(
+              availableReservationBytes,
+              currentUsedBytes * minSpillableReservationPct / 100);
+        })));
+
+    auto tempDirectory = TempDirectoryPath::create();
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+        .planNode(plan)
+        .injectSpill(false)
+        .spillDirectory(tempDirectory->getPath())
+        .referenceQuery(
+            "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+        .run();
+  }
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, exceededMaxSpillLevel) {
+  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
+  const int32_t numBuildVectors = 10;
+  std::vector<RowVectorPtr> buildVectors;
+  for (int32_t i = 0; i < numBuildVectors; ++i) {
+    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
+  }
+  const int32_t numProbeVectors = 5;
+  std::vector<RowVectorPtr> probeVectors;
+  for (int32_t i = 0; i < numProbeVectors; ++i) {
+    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  core::PlanNodeId probeScanId;
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors, false)
+                  .hashJoin(
+                      {"t_k1"},
+                      {"u_k1"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors, false)
+                          .planNode(),
+                      "",
+                      concat(probeType_->names(), buildType_->names()))
+                  .planNode();
+
+  auto tempDirectory = TempDirectoryPath::create();
+  const int exceededMaxSpillLevelCount =
+      globalSpillStats().spillMaxLevelExceededCount;
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashBuild::reclaim",
+      std::function<void(exec::Operator*)>(([&](exec::Operator* op) {
+        HashBuild* hashBuild = static_cast<HashBuild*>(op);
+        ASSERT_FALSE(hashBuild->testingExceededMaxSpillLevelLimit());
+      })));
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashProbe::reclaim",
+      std::function<void(exec::HashBuild*)>(([&](exec::Operator* op) {
+        HashProbe* hashProbe = static_cast<HashProbe*>(op);
+        ASSERT_FALSE(hashProbe->testingExceededMaxSpillLevelLimit());
+      })));
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashBuild::finishHashBuild",
+      std::function<void(exec::HashBuild*)>(([&](exec::HashBuild* hashBuild) {
+        Operator::ReclaimableSectionGuard guard(hashBuild);
+        testingRunArbitration(hashBuild->pool());
+      })));
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(1)
+      .planNode(plan)
+      // Always trigger spilling.
+      .injectSpill(false)
+      .maxSpillLevel(0)
+      .spillDirectory(tempDirectory->getPath())
+      .referenceQuery(
+          "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+      .config(core::QueryConfig::kSpillStartPartitionBit, "29")
+      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+        auto opStats = toOperatorStats(task->taskStats());
+        ASSERT_EQ(
+            opStats.at("HashProbe")
+                .runtimeStats[std::string(Operator::kExceededMaxSpillLevel)]
+                .sum,
+            8);
+        ASSERT_EQ(
+            opStats.at("HashProbe")
+                .runtimeStats[std::string(Operator::kExceededMaxSpillLevel)]
+                .count,
+            1);
+        ASSERT_EQ(
+            opStats.at("HashBuild")
+                .runtimeStats[std::string(Operator::kExceededMaxSpillLevel)]
+                .sum,
+            8);
+        ASSERT_EQ(
+            opStats.at("HashBuild")
+                .runtimeStats[std::string(Operator::kExceededMaxSpillLevel)]
+                .count,
+            1);
+      })
+      .run();
+  ASSERT_EQ(
+      globalSpillStats().spillMaxLevelExceededCount,
+      exceededMaxSpillLevelCount + 16);
+}
+
+TEST_P(HashJoinTest, maxSpillBytes) {
+  const auto rowType =
+      ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), VARCHAR()});
+  const auto probeVectors = createVectors(rowType, 1024, 10 << 20);
+  const auto buildVectors = createVectors(rowType, 1024, 10 << 20);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors, true)
+                  .project({"c0", "c1", "c2"})
+                  .hashJoin(
+                      {"c0"},
+                      {"u1"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors, true)
+                          .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
+                          .planNode(),
+                      "",
+                      {"c0", "c1", "c2"},
+                      core::JoinType::kInner)
+                  .planNode();
+
+  auto spillDirectory = TempDirectoryPath::create();
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+
+  struct {
+    int32_t maxSpilledBytes;
+    bool expectedExceedLimit;
+    std::string debugString() const {
+      return fmt::format("maxSpilledBytes {}", maxSpilledBytes);
+    }
+  } testSettings[] = {{1 << 30, false}, {16 << 20, true}, {0, false}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    try {
+      TestScopedSpillInjection scopedSpillInjection(100);
+      AssertQueryBuilder(plan)
+          .spillDirectory(spillDirectory->getPath())
+          .queryCtx(queryCtx)
+          .config(core::QueryConfig::kSpillEnabled, true)
+          .config(core::QueryConfig::kJoinSpillEnabled, true)
+          .config(core::QueryConfig::kMaxSpillBytes, testData.maxSpilledBytes)
+          .copyResults(pool_.get());
+      ASSERT_FALSE(testData.expectedExceedLimit);
+    } catch (const VeloxRuntimeError& e) {
+      ASSERT_TRUE(testData.expectedExceedLimit);
+      ASSERT_NE(
+          e.message().find(
+              "Query exceeded per-query local spill limit of 16.00MB"),
+          std::string::npos);
+      ASSERT_EQ(
+          e.errorCode(), facebook::velox::error_code::kSpillLimitExceeded);
+    }
+  }
+}
+
+TEST_P(HashJoinTest, onlyHashBuildMaxSpillBytes) {
+  const auto rowType =
+      ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), VARCHAR()});
+  const auto probeVectors = createVectors(rowType, 32, 128);
+  const auto buildVectors = createVectors(rowType, 1024, 10 << 20);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors, true)
+                  .hashJoin(
+                      {"c0"},
+                      {"u1"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors, true)
+                          .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
+                          .planNode(),
+                      "",
+                      {"c0", "c1", "c2"},
+                      core::JoinType::kInner)
+                  .planNode();
+
+  auto spillDirectory = TempDirectoryPath::create();
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+
+  struct {
+    int32_t maxSpilledBytes;
+    bool expectedExceedLimit;
+    std::string debugString() const {
+      return fmt::format("maxSpilledBytes {}", maxSpilledBytes);
+    }
+  } testSettings[] = {{1 << 30, false}, {16 << 20, true}, {0, false}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    try {
+      TestScopedSpillInjection scopedSpillInjection(100);
+      AssertQueryBuilder(plan)
+          .spillDirectory(spillDirectory->getPath())
+          .queryCtx(queryCtx)
+          .config(core::QueryConfig::kSpillEnabled, true)
+          .config(core::QueryConfig::kJoinSpillEnabled, true)
+          .config(core::QueryConfig::kMaxSpillBytes, testData.maxSpilledBytes)
+          .copyResults(pool_.get());
+      ASSERT_FALSE(testData.expectedExceedLimit);
+    } catch (const VeloxRuntimeError& e) {
+      ASSERT_TRUE(testData.expectedExceedLimit);
+      ASSERT_NE(
+          e.message().find(
+              "Query exceeded per-query local spill limit of 16.00MB"),
+          std::string::npos);
+      ASSERT_EQ(
+          e.errorCode(), facebook::velox::error_code::kSpillLimitExceeded);
+    }
+  }
+}
+
+TEST_P(HashJoinTest, reclaimFromJoinBuilderWithMultiDrivers) {
+  auto rowType = ROW({
+      {"c0", INTEGER()},
+      {"c1", INTEGER()},
+      {"c2", VARCHAR()},
+  });
+  const auto vectors = createVectors(rowType, 64 << 20, fuzzerOpts_);
+  const int numDrivers = 4;
+
+  memory::MemoryManager::Options options;
+  options.allocatorCapacity = 8L << 30;
+  auto memoryManagerWithoutArbitrator =
+      std::make_unique<memory::MemoryManager>(options);
+  const auto expectedResult =
+      runHashJoinTask(
+          vectors,
+          newQueryCtx(
+              memoryManagerWithoutArbitrator.get(), executor_.get(), 8L << 30),
+          false,
+          numDrivers,
+          pool(),
+          false)
+          .data;
+
+  auto memoryManagerWithArbitrator = createMemoryManager();
+  const auto& arbitrator = memoryManagerWithArbitrator->arbitrator();
+  // Create a query ctx with a small capacity to trigger spilling.
+  auto result = runHashJoinTask(
+      vectors,
+      newQueryCtx(
+          memoryManagerWithArbitrator.get(), executor_.get(), 128 << 20),
+      false,
+      numDrivers,
+      pool(),
+      true,
+      expectedResult);
+  auto taskStats = exec::toPlanStats(result.task->taskStats());
+  auto& planStats = taskStats.at(result.planNodeId);
+  ASSERT_GT(planStats.spilledBytes, 0);
+  result.task.reset();
+
+  // This test uses on-demand created memory manager instead of the global
+  // one. We need to make sure any used memory got cleaned up before exiting
+  // the scope
+  waitForAllTasksToBeDeleted();
+  ASSERT_GT(arbitrator->stats().numRequests, 0);
+  ASSERT_GT(arbitrator->stats().reclaimedUsedBytes, 0);
+}
+
+TEST_P(HashJoinTest, semiJoinAbandonBuildNoDupHashEarly) {
+  auto probeVectors = makeBatches(3, [&](int32_t /*unused*/) {
+    return makeRowVector({
+        makeFlatVector<int64_t>({1, 2, 2, 3, 3, 3, 4, 5, 5, 6, 7}),
+        makeFlatVector<int64_t>({10, 20, 21, 30, 31, 32, 40, 50, 51, 60, 70}),
+    });
+  });
+
+  auto buildVectors = makeBatches(3, [&](int32_t /*unused*/) {
+    return makeRowVector({
+        makeFlatVector<int64_t>({1, 1, 3, 4, 5, 5, 7, 8}),
+        makeFlatVector<int64_t>({100, 101, 300, 400, 500, 501, 700, 800}),
+    });
+  });
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors)
+                  .project({"c0 AS t0", "c1 AS t1"})
+                  .hashJoin(
+                      {"t0"},
+                      {"u0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors)
+                          .project({"c0 AS u0", "c1 AS u1"})
+                          .planNode(),
+                      "",
+                      {"t0", "t1", "match"},
+                      core::JoinType::kLeftSemiProject)
+                  .planNode();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .config(core::QueryConfig::kAbandonDedupHashMapMinRows, "1")
+      .config(core::QueryConfig::kAbandonDedupHashMapMinPct, "10")
+      .planNode(plan)
+      .referenceQuery(
+          "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0) FROM t")
+      .run();
+}
+
+TEST_P(HashJoinTest, antiJoinAbandonBuildNoDupHashEarly) {
+  auto probeVectors = makeBatches(64, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"t0", "t1"},
+        {
+            makeNullableFlatVector<int32_t>({std::nullopt, 1, 2, 3, 4, 5, 6}),
+            makeFlatVector<int32_t>({0, 1, 2, 3, 4, 5, 6}),
+        });
+  });
+  auto buildVectors = makeBatches(64, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"u0", "u1"},
+        {
+            makeNullableFlatVector<int32_t>({std::nullopt, 2, 3, 4, 6, 7, 8}),
+            makeFlatVector<int32_t>({0, 2, 3, 4, 6, 7, 8}),
+        });
+  });
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .config(core::QueryConfig::kAbandonDedupHashMapMinRows, "1")
+      .config(core::QueryConfig::kAbandonDedupHashMapMinPct, "10")
+      .numDrivers(numDrivers_)
+      .probeKeys({"t0"})
+      .probeVectors(std::vector<RowVectorPtr>(probeVectors))
+      .buildKeys({"u0"})
+      .buildVectors(std::vector<RowVectorPtr>(buildVectors))
+      .joinType(core::JoinType::kAnti)
+      .joinOutputLayout({"t0", "t1"})
+      .referenceQuery(
+          "SELECT t.* FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE u.u0 = t.t0)")
+      .run();
+}
+
+TEST_P(HashJoinTest, semiJoinDeduplicateResetCapacity) {
+  const int32_t vectorSize = 10;
+  const int32_t numBatches = 210;
+  VectorFuzzer fuzzer({.vectorSize = vectorSize}, pool());
+
+  // Row type with double and int64_t columns
+  // Join Key is double -> VectorHasher::typeKindSupportsValueIds will
+  // return false -> HashMode is kHash
+  auto rowType = ROW({"c0", "c1"}, {DOUBLE(), BIGINT()});
+
+  auto probeVectors = makeBatches(
+      numBatches, [&](int32_t /*unused*/) { return fuzzer.fuzzRow(rowType); });
+
+  auto buildVectors = makeBatches(
+      numBatches, [&](int32_t /*unused*/) { return fuzzer.fuzzRow(rowType); });
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors)
+                  .project({"c0 AS t0", "c1 AS t1"})
+                  .hashJoin(
+                      {"t0"},
+                      {"u0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors)
+                          .project({"c0 AS u0", "c1 AS u1"})
+                          .planNode(),
+                      "",
+                      {"t0", "t1", "match"},
+                      core::JoinType::kLeftSemiProject)
+                  .planNode();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .config(core::QueryConfig::kAbandonDedupHashMapMinRows, "10")
+      .config(core::QueryConfig::kAbandonDedupHashMapMinPct, "50")
+      .numDrivers(1)
+      .checkSpillStats(false)
+      .planNode(plan)
+      .referenceQuery(
+          "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0) FROM t")
+      .run();
+}
+
+DEBUG_ONLY_TEST_P(
+    HashJoinTest,
+    failedToReclaimFromHashJoinBuildersInNonReclaimableSection) {
+  auto rowType = ROW({
+      {"c0", INTEGER()},
+      {"c1", INTEGER()},
+      {"c2", VARCHAR()},
+  });
+  const auto vectors = createVectors(rowType, 64 << 20, fuzzerOpts_);
+  const int numDrivers = 1;
+  std::shared_ptr<core::QueryCtx> queryCtx =
+      newQueryCtx(memory::memoryManager(), executor_.get(), 512 << 20);
+  const auto expectedResult =
+      runHashJoinTask(vectors, queryCtx, false, numDrivers, pool(), false).data;
+
+  std::atomic_bool nonReclaimableSectionWaitFlag{true};
+  std::atomic_bool reclaimerInitializationWaitFlag{true};
+  folly::EventCount nonReclaimableSectionWait;
+  std::atomic_bool memoryArbitrationWaitFlag{true};
+  folly::EventCount memoryArbitrationWait;
+
+  std::atomic<uint32_t> numInitializedDrivers{0};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal",
+      std::function<void(exec::Driver*)>([&](exec::Driver* driver) {
+        numInitializedDrivers++;
+        // We need to make sure reclaimers on both build and probe side are set
+        // (in Operator::initialize) to avoid race conditions, producing
+        // consistent test results.
+        if (numInitializedDrivers.load() == 2) {
+          reclaimerInitializationWaitFlag = false;
+          nonReclaimableSectionWait.notifyAll();
+        }
+      }));
+
+  std::atomic<bool> injectNonReclaimableSectionOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::common::memory::MemoryPoolImpl::allocateNonContiguous",
+      std::function<void(memory::MemoryPoolImpl*)>(
+          ([&](memory::MemoryPoolImpl* pool) {
+            if (!isHashBuildMemoryPool(*pool)) {
+              return;
+            }
+            if (!injectNonReclaimableSectionOnce.exchange(false)) {
+              return;
+            }
+
+            // Signal the test control that one of the hash build operator has
+            // entered into non-reclaimable section.
+            nonReclaimableSectionWaitFlag = false;
+            nonReclaimableSectionWait.notifyAll();
+
+            // Suspend the driver to simulate the arbitration.
+            pool->reclaimer()->enterArbitration();
+            // Wait for the memory arbitration to complete.
+            memoryArbitrationWait.await(
+                [&]() { return !memoryArbitrationWaitFlag.load(); });
+            pool->reclaimer()->leaveArbitration();
+          })));
+
+  std::thread joinThread([&]() {
+    const auto result = runHashJoinTask(
+        vectors, queryCtx, false, numDrivers, pool(), true, expectedResult);
+    auto taskStats = exec::toPlanStats(result.task->taskStats());
+    auto& planStats = taskStats.at(result.planNodeId);
+    ASSERT_EQ(planStats.spilledBytes, 0);
+  });
+
+  // Wait for the hash build operators to enter into non-reclaimable section.
+  nonReclaimableSectionWait.await([&]() {
+    return (
+        !nonReclaimableSectionWaitFlag.load() &&
+        !reclaimerInitializationWaitFlag.load());
+  });
+
+  // We expect capacity grow fails as we can't reclaim from hash join operators.
+  memory::testingRunArbitration();
+
+  // Notify the hash build operator that memory arbitration has been done.
+  memoryArbitrationWaitFlag = false;
+  memoryArbitrationWait.notifyAll();
+
+  joinThread.join();
+
+  // This test uses on-demand created memory manager instead of the global
+  // one. We need to make sure any used memory got cleaned up before exiting
+  // the scope
+  waitForAllTasksToBeDeleted();
+  ASSERT_EQ(
+      memory::memoryManager()->arbitrator()->stats().numNonReclaimableAttempts,
+      2);
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, reclaimDuringTableBuild) {
+  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
+  const int32_t numBuildVectors = 5;
+  std::vector<RowVectorPtr> buildVectors;
+  for (int32_t i = 0; i < numBuildVectors; ++i) {
+    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
+  }
+  const int32_t numProbeVectors = 5;
+  std::vector<RowVectorPtr> probeVectors;
+  for (int32_t i = 0; i < numProbeVectors; ++i) {
+    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  core::PlanNodeId probeScanId;
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors, false)
+                  .hashJoin(
+                      {"t_k1"},
+                      {"u_k1"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors, false)
+                          .planNode(),
+                      "",
+                      concat(probeType_->names(), buildType_->names()))
+                  .planNode();
+
+  std::atomic_bool injectSpillOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashBuild::finishHashBuild",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (!injectSpillOnce.exchange(false)) {
+          return;
+        }
+        Operator::ReclaimableSectionGuard guard(op);
+        testingRunArbitration(op->pool());
+      }));
+
+  auto tempDirectory = TempDirectoryPath::create();
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(4)
+      .planNode(plan)
+      .injectSpill(false)
+      .maxSpillLevel(0)
+      .spillDirectory(tempDirectory->getPath())
+      .referenceQuery(
+          "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+      .config(core::QueryConfig::kSpillStartPartitionBit, "29")
+      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+        auto opStats = toOperatorStats(task->taskStats());
+        ASSERT_GT(
+            opStats.at("HashBuild")
+                .runtimeStats[std::string(Operator::kSpillWrites)]
+                .sum,
+            0);
+      })
+      .run();
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, exceptionDuringFinishJoinBuild) {
+  // This test is to make sure there is no memory leak when exceptions are
+  // thrown while parallelly preparing join table.
+  auto memoryManager = memory::memoryManager();
+  const auto& arbitrator = memoryManager->arbitrator();
+  const uint64_t numDrivers = 2;
+  const auto expectedFreeCapacityBytes = arbitrator->stats().freeCapacityBytes;
+
+  const uint64_t numBuildSideRows = 500;
+  auto buildKeyVector = makeFlatVector<int64_t>(
+      numBuildSideRows,
+      [](vector_size_t row) { return folly::Random::rand64(); });
+  auto buildSideVector =
+      makeRowVector({"b0", "b1"}, {buildKeyVector, buildKeyVector});
+  std::vector<RowVectorPtr> buildSideVectors;
+  for (int i = 0; i < numDrivers; ++i) {
+    buildSideVectors.push_back(buildSideVector);
+  }
+  createDuckDbTable("build", buildSideVectors);
+
+  const uint64_t numProbeSideRows = 10;
+  auto probeKeyVector = makeFlatVector<int64_t>(
+      numProbeSideRows,
+      [&](vector_size_t row) { return buildKeyVector->valueAt(row); });
+  auto probeSideVector =
+      makeRowVector({"p0", "p1"}, {probeKeyVector, probeKeyVector});
+  std::vector<RowVectorPtr> probeSideVectors;
+  for (int i = 0; i < numDrivers; ++i) {
+    probeSideVectors.push_back(probeSideVector);
+  }
+  createDuckDbTable("probe", probeSideVectors);
+
+  ASSERT_EQ(arbitrator->stats().freeCapacityBytes, expectedFreeCapacityBytes);
+
+  // We set the task to fail right before we reserve memory for other operators.
+  // We rely on the driver suspension before parallel join build to throw
+  // exceptions (suspension on an already terminated task throws).
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashBuild::ensureTableFits",
+      std::function<void(HashBuild*)>([&](HashBuild* buildOp) {
+        try {
+          VELOX_FAIL("Simulated failure");
+        } catch (VeloxException&) {
+          buildOp->operatorCtx()->task()->setError(std::current_exception());
+        }
+      }));
+
+  std::vector<RowVectorPtr> probeInput = {probeSideVector};
+  std::vector<RowVectorPtr> buildInput = {buildSideVector};
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto spillDirectory = TempDirectoryPath::create();
+
+  ASSERT_EQ(arbitrator->stats().freeCapacityBytes, expectedFreeCapacityBytes);
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(duckDbQueryRunner_)
+          .spillDirectory(spillDirectory->getPath())
+          .config(core::QueryConfig::kSpillEnabled, true)
+          .config(core::QueryConfig::kJoinSpillEnabled, true)
+          .queryCtx(
+              newQueryCtx(memoryManager, executor_.get(), kMemoryCapacity))
+          .maxDrivers(numDrivers)
+          .plan(PlanBuilder(planNodeIdGenerator)
+                    .values(probeInput, true)
+                    .hashJoin(
+                        {"p0"},
+                        {"b0"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildInput, true)
+                            .planNode(),
+                        "",
+                        {"p0", "p1", "b0", "b1"},
+                        core::JoinType::kInner)
+                    .planNode())
+          .assertResults(
+              "SELECT probe.p0, probe.p1, build.b0, build.b1 FROM probe "
+              "INNER JOIN build ON probe.p0 = build.b0"),
+      "Simulated failure");
+  // This test uses on-demand created memory manager instead of the global
+  // one. We need to make sure any used memory got cleaned up before exiting
+  // the scope
+  waitForAllTasksToBeDeleted();
+  ASSERT_EQ(arbitrator->stats().freeCapacityBytes, expectedFreeCapacityBytes);
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, arbitrationTriggeredDuringParallelJoinBuild) {
+  std::unique_ptr<memory::MemoryManager> memoryManager = createMemoryManager();
+  const uint64_t numDrivers = 2;
+
+  // Large build side key product to bump hash mode to kHash instead of kArray
+  // to trigger parallel join build.
+  const uint64_t numBuildSideRows = 500;
+  auto buildKeyVector = makeFlatVector<int64_t>(
+      numBuildSideRows,
+      [](vector_size_t row) { return folly::Random::rand64(); });
+  auto buildSideVector = makeRowVector(
+      {"b0", "b1", "b2"}, {buildKeyVector, buildKeyVector, buildKeyVector});
+  std::vector<RowVectorPtr> buildSideVectors;
+  for (int i = 0; i < numDrivers; ++i) {
+    buildSideVectors.push_back(buildSideVector);
+  }
+  createDuckDbTable("build", buildSideVectors);
+
+  const uint64_t numProbeSideRows = 10;
+  auto probeKeyVector = makeFlatVector<int64_t>(
+      numProbeSideRows,
+      [&](vector_size_t row) { return buildKeyVector->valueAt(row); });
+  auto probeSideVector = makeRowVector(
+      {"p0", "p1", "p2"}, {probeKeyVector, probeKeyVector, probeKeyVector});
+  std::vector<RowVectorPtr> probeSideVectors;
+  for (int i = 0; i < numDrivers; ++i) {
+    probeSideVectors.push_back(probeSideVector);
+  }
+  createDuckDbTable("probe", probeSideVectors);
+
+  std::shared_ptr<core::QueryCtx> joinQueryCtx =
+      newQueryCtx(memoryManager.get(), executor_.get(), kMemoryCapacity);
+
+  const int64_t allocSize = 512LL << 20;
+  std::atomic<bool> parallelBuildTriggered{false};
+  std::atomic<memory::MemoryPool*> joinBuildPool{nullptr};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashTable::parallelJoinBuild",
+      std::function<void(memory::MemoryPool*)>([&](memory::MemoryPool* pool) {
+        parallelBuildTriggered = true;
+        // Pick the last running driver threads' pool for later memory
+        // allocation. This pick is rather arbitrary, as it is un-important
+        // which pool is going to be allocated from later in a parallel join's
+        // off-driver thread.
+        joinBuildPool = pool;
+      }));
+
+  std::atomic_bool offThreadAllocationTriggered{false};
+  folly::EventCount asyncMoveWait;
+  std::atomic<bool> asyncMoveWaitFlag{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::AsyncSource::prepare",
+      std::function<void(void*)>([&](void* /* unused */) {
+        if (!offThreadAllocationTriggered.exchange(true)) {
+          SCOPE_EXIT {
+            asyncMoveWaitFlag = false;
+            asyncMoveWait.notifyAll();
+          };
+          // Executed by the first thread hitting the test value location. This
+          // allocation will trigger arbitration and fail.
+          VELOX_ASSERT_THROW(
+              joinBuildPool.load()->allocate(allocSize),
+              "Exceeded memory pool cap");
+        }
+      }));
+
+  // Wait for allocation (hence arbitration) on the prepare thread to finish
+  // before calling AsyncSource::move(). This is to ensure no other AsyncSource
+  // (hence arbitration) is running on the driver thread (on-thread) before the
+  // ongoing arbitration finishes. Without ensuring this, the on-thread
+  // arbitration (triggered by calling AsyncSource::move() first) has
+  // thread-local driver context by default, defying the purpose of this test.
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::AsyncSource::move",
+      std::function<void(void*)>([&](void* /* unused */) {
+        asyncMoveWait.await([&]() { return !asyncMoveWaitFlag.load(); });
+      }));
+
+  std::vector<RowVectorPtr> probeInput = {probeSideVector};
+  std::vector<RowVectorPtr> buildInput = {buildSideVector};
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto spillDirectory = TempDirectoryPath::create();
+  AssertQueryBuilder(duckDbQueryRunner_)
+      .spillDirectory(spillDirectory->getPath())
+      .config(core::QueryConfig::kSpillEnabled, true)
+      .config(core::QueryConfig::kJoinSpillEnabled, true)
+      // Set very low table size threshold to trigger parallel build.
+      .config(core::QueryConfig::kMinTableRowsForParallelJoinBuild, 0)
+      // Set multiple hash build drivers to trigger parallel build.
+      .maxDrivers(numDrivers)
+      .queryCtx(joinQueryCtx)
+      .plan(PlanBuilder(planNodeIdGenerator)
+                .values(probeInput, true)
+                .hashJoin(
+                    {"p0", "p1", "p2"},
+                    {"b0", "b1", "b2"},
+                    PlanBuilder(planNodeIdGenerator)
+                        .values(buildInput, true)
+                        .planNode(),
+                    "",
+                    {"p0", "p1", "b0", "b1"},
+                    core::JoinType::kInner)
+                .planNode())
+      .assertResults(
+          "SELECT probe.p0, probe.p1, build.b0, build.b1 FROM probe "
+          "INNER JOIN build ON probe.p0 = build.b0 AND probe.p1 = build.b1 AND "
+          "probe.p2 = build.b2");
+  ASSERT_TRUE(parallelBuildTriggered);
+
+  // This test uses on-demand created memory manager instead of the global
+  // one. We need to make sure any used memory got cleaned up before exiting
+  // the scope
+  waitForAllTasksToBeDeleted();
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, arbitrationTriggeredByEnsureJoinTableFit) {
+  // Use manual spill injection other than spill injection framework. This is
+  // because spill injection framework does not allow fine grain spill within a
+  // single operator (We do not want to spill during addInput() but only during
+  // finishHashBuild()).
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashBuild::ensureTableFits",
+      std::function<void(Operator*)>(([&](Operator* op) {
+        Operator::ReclaimableSectionGuard guard(op);
+        memory::testingRunArbitration(op->pool());
+      })));
+  auto tempDirectory = TempDirectoryPath::create();
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+      .injectSpill(false)
+      .spillDirectory(tempDirectory->getPath())
+      .keyTypes({BIGINT()})
+      .probeVectors(1600, 5)
+      .buildVectors(1500, 5)
+      .referenceQuery(
+          "SELECT t_k0, t_data, u_k0, u_data FROM t, u WHERE t.t_k0 = u.u_k0")
+      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+        const auto statsPair = taskSpilledStats(*task);
+        ASSERT_GT(statsPair.first.spilledBytes, 0);
+      })
+      .run();
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, joinBuildSpillError) {
+  const int kMemoryCapacity = 27 << 20;
+  // Set a small memory capacity to trigger spill.
+  std::unique_ptr<memory::MemoryManager> memoryManager =
+      createMemoryManager(kMemoryCapacity, 0);
+  const auto& arbitrator = memoryManager->arbitrator();
+  auto rowType = ROW(
+      {{"c0", INTEGER()},
+       {"c1", INTEGER()},
+       {"c2", VARCHAR()},
+       {"c3", VARCHAR()}});
+
+  std::vector<RowVectorPtr> vectors = createVectors(16, rowType, fuzzerOpts_);
+  createDuckDbTable(vectors);
+
+  std::shared_ptr<core::QueryCtx> joinQueryCtx =
+      newQueryCtx(memoryManager.get(), executor_.get(), kMemoryCapacity);
+
+  const int numDrivers = 4;
+  std::atomic<int> numAppends{0};
+  const std::string injectedErrorMsg("injected spillError");
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::SpillState::appendToPartition",
+      std::function<void(exec::SpillState*)>([&](exec::SpillState* state) {
+        if (++numAppends != numDrivers) {
+          return;
+        }
+        VELOX_FAIL(injectedErrorMsg);
+      }));
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto spillDirectory = TempDirectoryPath::create();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(vectors)
+                  .project({"c0 AS t0", "c1 AS t1", "c2 AS t2"})
+                  .hashJoin(
+                      {"t0"},
+                      {"u0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(vectors)
+                          .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
+                          .planNode(),
+                      "",
+                      {"t1"},
+                      core::JoinType::kAnti)
+                  .planNode();
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan)
+          .queryCtx(joinQueryCtx)
+          .spillDirectory(spillDirectory->getPath())
+          .config(core::QueryConfig::kSpillEnabled, true)
+          .copyResults(pool()),
+      injectedErrorMsg);
+
+  waitForAllTasksToBeDeleted();
+  ASSERT_EQ(arbitrator->stats().numFailures, 1);
+
+  // Wait again here as this test uses on-demand created memory manager instead
+  // of the global one. We need to make sure any used memory got cleaned up
+  // before exiting the scope
+  waitForAllTasksToBeDeleted();
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, probeSpillOnWaitForPeers) {
+  // This test creates a scenario when tester probe thread finishes processing
+  // input, entering kWaitForPeers state, and the other thread is still
+  // processing, spill is triggered properly performed.
+
+  folly::EventCount startWait;
+  folly::Synchronized<std::string> testerOpName;
+  std::atomic_bool injectedSpillOnce{false};
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::getOutput",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (!isHashProbeMemoryPool(*op->pool())) {
+          return;
+        }
+        testerOpName.withWLock([&](std::string& opName) {
+          if (opName.empty()) {
+            opName = op->pool()->name();
+          }
+        });
+        if (op->pool()->name() == *testerOpName.rlock()) {
+          // Do not block tester thread.
+          return;
+        }
+        startWait.await([&]() { return injectedSpillOnce.load(); });
+      }));
+
+  // tester probe operator is guaranteed to be in kWaitForPeers state the next
+  // isBlocked() is called after noMoreInput() is called.
+  std::atomic_bool noMoreInputCalled{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::noMoreInput",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (!isHashProbeMemoryPool(*op->pool())) {
+          return;
+        }
+        noMoreInputCalled = true;
+      }));
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::isBlocked",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (!isHashProbeMemoryPool(*op->pool())) {
+          return;
+        }
+        if (injectedSpillOnce || !noMoreInputCalled) {
+          return;
+        }
+        injectedSpillOnce = true;
+        EXPECT_EQ(
+            dynamic_cast<HashProbe*>(op)->testingState(),
+            ProbeOperatorState::kWaitForPeers);
+        testingRunArbitration(op->pool());
+      }));
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Task::requestPauseLocked",
+      std::function<void(Task*)>([&](Task* task) { startWait.notifyAll(); }));
+
+  const uint64_t numDrivers{2};
+  std::shared_ptr<core::QueryCtx> joinQueryCtx =
+      newQueryCtx(memory::memoryManager(), executor_.get(), kMemoryCapacity);
+  auto rowType = ROW({{"c0", INTEGER()}, {"c1", INTEGER()}});
+  fuzzerOpts_.vectorSize = 20;
+  std::vector<RowVectorPtr> vectors = createVectors(6, rowType, fuzzerOpts_);
+  std::vector<RowVectorPtr> totalVectors;
+  for (auto i = 0; i < numDrivers; ++i) {
+    totalVectors.insert(totalVectors.end(), vectors.begin(), vectors.end());
+  }
+  createDuckDbTable(totalVectors);
+  auto spillDirectory = TempDirectoryPath::create();
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(vectors, true)
+                  .project({"c0 AS t0", "c1 AS t1"})
+                  .hashJoin(
+                      {"t0"},
+                      {"u0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(vectors, true)
+                          .project({"c0 AS u0", "c1 AS u1"})
+                          .planNode(),
+                      "",
+                      {"t1"},
+                      core::JoinType::kInner)
+                  .planNode();
+
+  {
+    auto task =
+        AssertQueryBuilder(duckDbQueryRunner_)
+            .plan(plan)
+            .queryCtx(joinQueryCtx)
+            .spillDirectory(spillDirectory->getPath())
+            .config(core::QueryConfig::kSpillEnabled, true)
+            .maxDrivers(numDrivers)
+            .assertResults("SELECT a.c1 from tmp a join tmp b on a.c0 = b.c0");
+
+    auto opStats = toOperatorStats(task->taskStats());
+    ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
+    ASSERT_EQ(opStats.at("HashBuild").spilledBytes, 0);
+
+    const auto* arbitrator = memory::memoryManager()->arbitrator();
+    ASSERT_GT(arbitrator->stats().reclaimedUsedBytes, 0);
+  }
+  waitForAllTasksToBeDeleted();
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, taskWaitTimeout) {
+  const int queryMemoryCapacity = 128 << 20;
+  // Creates a large number of vectors based on the query capacity to trigger
+  // memory arbitration.
+  fuzzerOpts_.vectorSize = 10'000;
+  auto rowType = ROW(
+      {{"c0", INTEGER()},
+       {"c1", INTEGER()},
+       {"c2", VARCHAR()},
+       {"c3", VARCHAR()}});
+  const auto vectors =
+      createVectors(rowType, queryMemoryCapacity / 2, fuzzerOpts_);
+  const int numDrivers = 4;
+  const auto expectedResult =
+      runHashJoinTask(vectors, nullptr, false, numDrivers, pool(), false).data;
+
+  for (uint64_t timeoutMs : {1'000, 30'000}) {
+    SCOPED_TRACE(fmt::format("timeout {}", succinctMillis(timeoutMs)));
+    auto memoryManager = createMemoryManager(512 << 20, 0, timeoutMs);
+    auto queryCtx =
+        newQueryCtx(memoryManager.get(), executor_.get(), queryMemoryCapacity);
+
+    // Set test injection to block one hash build operator to inject delay when
+    // memory reclaim waits for task to pause.
+    folly::EventCount buildBlockWait;
+    std::atomic<bool> buildBlockWaitFlag{true};
+    std::atomic<bool> blockOneBuild{true};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve",
+        std::function<void(memory::MemoryPool*)>([&](memory::MemoryPool* pool) {
+          const std::string re(".*HashBuild");
+          if (!RE2::FullMatch(pool->name(), re)) {
+            return;
+          }
+          if (!blockOneBuild.exchange(false)) {
+            return;
+          }
+          buildBlockWait.await([&]() { return !buildBlockWaitFlag.load(); });
+        }));
+
+    folly::EventCount taskPauseWait;
+    std::atomic<bool> taskPauseWaitFlag{false};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Task::requestPauseLocked",
+        std::function<void(Task*)>(([&](Task* /*unused*/) {
+          taskPauseWaitFlag = true;
+          taskPauseWait.notifyAll();
+        })));
+
+    std::thread queryThread([&]() {
+      // We expect failure on short time out.
+      if (timeoutMs == 1'000) {
+        VELOX_ASSERT_THROW(
+            runHashJoinTask(
+                vectors,
+                queryCtx,
+                false,
+                numDrivers,
+                pool(),
+                true,
+                expectedResult),
+            "Memory reclaim failed to wait");
+      } else {
+        // With 30s timeout, we expect either:
+        // 1. Success with spilling (operators become reclaimable in time), OR
+        // 2. kMemCapExceeded if operators remain in non-reclaimable state
+        try {
+          const auto result = runHashJoinTask(
+              vectors,
+              queryCtx,
+              false,
+              numDrivers,
+              pool(),
+              true,
+              expectedResult);
+          auto taskStats = exec::toPlanStats(result.task->taskStats());
+          auto& planStats = taskStats.at(result.planNodeId);
+          ASSERT_GT(planStats.spilledBytes, 0);
+        } catch (const VeloxRuntimeError& e) {
+          ASSERT_EQ(e.errorCode(), error_code::kMemCapExceeded)
+              << "Unexpected error: " << e.what();
+        }
+      }
+    });
+
+    // Wait for task pause to reach, and then delay for a while before unblock
+    // the blocked hash build operator.
+    taskPauseWait.await([&]() { return taskPauseWaitFlag.load(); });
+    // Wait for two seconds and expect the short reclaim wait timeout.
+    std::this_thread::sleep_for(std::chrono::seconds(2));
+    // Unblock the blocked build operator to let memory reclaim proceed.
+    buildBlockWaitFlag = false;
+    buildBlockWait.notifyAll();
+
+    queryThread.join();
+
+    // This test uses on-demand created memory manager instead of the global
+    // one. We need to make sure any used memory got cleaned up before exiting
+    // the scope
+    waitForAllTasksToBeDeleted();
+  }
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, hashProbeSpill) {
+  struct {
+    bool triggerBuildSpill;
+    // Triggers after no more input or not.
+    bool afterNoMoreInput;
+    // The index of get output call to trigger probe side spilling.
+    int probeOutputIndex;
+
+    std::string debugString() const {
+      return fmt::format(
+          "triggerBuildSpill: {}, afterNoMoreInput: {}, probeOutputIndex: {}",
+          triggerBuildSpill,
+          afterNoMoreInput,
+          probeOutputIndex);
+    }
+  } testSettings[] = {
+      {false, false, 0},
+      {false, false, 1},
+      {false, false, 10},
+      {false, true, 0},
+      {true, false, 0},
+      {true, false, 1},
+      {true, false, 10},
+      {true, true, 0}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    std::atomic_bool injectBuildSpillOnce{true};
+    std::atomic_int buildInputCount{0};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::addInput",
+        std::function<void(Operator*)>([&](Operator* op) {
+          if (!testData.triggerBuildSpill) {
+            return;
+          }
+          if (!isHashBuildMemoryPool(*op->pool())) {
+            return;
+          }
+          if (buildInputCount++ != 1) {
+            return;
+          }
+          if (!injectBuildSpillOnce.exchange(false)) {
+            return;
+          }
+          testingRunArbitration(op->pool());
+        }));
+
+    std::atomic_bool injectProbeSpillOnce{true};
+    std::atomic_int probeOutputCount{0};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::getOutput",
+        std::function<void(Operator*)>([&](Operator* op) {
+          if (!isHashProbeMemoryPool(*op->pool())) {
+            return;
+          }
+          if (testData.afterNoMoreInput) {
+            if (!op->testingNoMoreInput()) {
+              return;
+            }
+          } else {
+            if (probeOutputCount++ != testData.probeOutputIndex) {
+              return;
+            }
+          }
+          if (!injectProbeSpillOnce.exchange(false)) {
+            return;
+          }
+          testingRunArbitration(op->pool());
+        }));
+
+    fuzzerOpts_.vectorSize = 128;
+    auto probeVectors = createVectors(10, probeType_, fuzzerOpts_);
+    auto buildVectors = createVectors(20, buildType_, fuzzerOpts_);
+    const auto spillDirectory = TempDirectoryPath::create();
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(1)
+        .spillDirectory(spillDirectory->getPath())
+        .probeKeys({"t_k1"})
+        .probeVectors(std::move(probeVectors))
+        .buildKeys({"u_k1"})
+        .buildVectors(std::move(buildVectors))
+        .config(core::QueryConfig::kJoinSpillEnabled, "true")
+        .joinType(core::JoinType::kRight)
+        .joinOutputLayout({"t_k1", "t_k2", "u_k1", "t_v1"})
+        .referenceQuery(
+            "SELECT t.t_k1, t.t_k2, u.u_k1, t.t_v1 FROM t RIGHT JOIN u ON t.t_k1 = u.u_k1")
+        .injectSpill(false)
+        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+          auto opStats = toOperatorStats(task->taskStats());
+          if (!parallelBuildSideRowsEnabled_) {
+            ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
+          }
+          if (testData.triggerBuildSpill) {
+            ASSERT_GT(opStats.at("HashBuild").spilledBytes, 0);
+          } else {
+            ASSERT_EQ(opStats.at("HashBuild").spilledBytes, 0);
+          }
+
+          const auto* arbitrator = memory::memoryManager()->arbitrator();
+          ASSERT_GT(arbitrator->stats().numRequests, 0);
+          ASSERT_GT(arbitrator->stats().reclaimedUsedBytes, 0);
+        })
+        .run();
+  }
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, hashProbeSpillInMiddleOfLastOutputProcessing) {
+  std::atomic_int outputCountAfterNoMoreInout{0};
+  std::atomic_bool injectOnce{true};
+  ::facebook::velox::common::testutil::ScopedTestValue abc(
+      "facebook::velox::exec::Driver::runInternal::getOutput",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (!isHashProbeMemoryPool(*op->pool())) {
+          return;
+        }
+        if (!op->testingNoMoreInput()) {
+          return;
+        }
+        if (outputCountAfterNoMoreInout++ != 1) {
+          return;
+        }
+        if (!injectOnce.exchange(false)) {
+          return;
+        }
+        testingRunArbitration(op->pool());
+      }));
+
+  fuzzerOpts_.vectorSize = 128;
+  auto probeVectors = createVectors(10, probeType_, fuzzerOpts_);
+  auto buildVectors = createVectors(20, buildType_, fuzzerOpts_);
+
+  const auto spillDirectory = TempDirectoryPath::create();
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(1)
+      .spillDirectory(spillDirectory->getPath())
+      .probeKeys({"t_k1"})
+      .probeVectors(std::move(probeVectors))
+      .buildKeys({"u_k1"})
+      .buildVectors(std::move(buildVectors))
+      .config(core::QueryConfig::kJoinSpillEnabled, "true")
+      .config(core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
+      .joinType(core::JoinType::kRight)
+      .joinOutputLayout({"t_k1", "t_k2", "u_k1", "t_v1"})
+      .referenceQuery(
+          "SELECT t.t_k1, t.t_k2, u.u_k1, t.t_v1 FROM t RIGHT JOIN u ON t.t_k1 = u.u_k1")
+      .injectSpill(false)
+      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+        auto opStats = toOperatorStats(task->taskStats());
+        ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
+        // Verifies that we only spill the output which is single partitioned
+        // but not the hash table.
+        ASSERT_EQ(opStats.at("HashProbe").spilledPartitions, 1);
+      })
+      .run();
+}
+
+// Inject probe-side spilling in the middle of output processing. If
+// 'recursiveSpill' is true, we trigger probe-spilling when probe the hash table
+// built from spilled data.
+DEBUG_ONLY_TEST_P(HashJoinTest, hashProbeSpillInMiddleOfOutputProcessing) {
+  for (bool recursiveSpill : {false, true}) {
+    std::atomic_int buildInputCount{0};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::addInput",
+        std::function<void(Operator*)>([&](Operator* op) {
+          if (!isHashBuildMemoryPool(*op->pool())) {
+            return;
+          }
+          if (!recursiveSpill) {
+            return;
+          }
+          // Trigger spill after the build side has processed some rows.
+          if (buildInputCount++ != 1) {
+            return;
+          }
+          testingRunArbitration(op->pool());
+        }));
+
+    std::atomic_bool injectProbeSpillOnce{true};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::getOutput",
+        std::function<void(Operator*)>([&](Operator* op) {
+          if (!isHashProbeMemoryPool(*op->pool())) {
+            return;
+          }
+
+          if (op->testingHasInput()) {
+            return;
+          }
+          if (recursiveSpill) {
+            if (static_cast<HashProbe*>(op)->testingHasInputSpiller()) {
+              return;
+            }
+          }
+          if (!injectProbeSpillOnce.exchange(false)) {
+            return;
+          }
+          testingRunArbitration(op->pool());
+        }));
+
+    fuzzerOpts_.vectorSize = 128;
+    auto probeVectors = createVectors(10, probeType_, fuzzerOpts_);
+    auto buildVectors = createVectors(20, buildType_, fuzzerOpts_);
+
+    const auto spillDirectory = TempDirectoryPath::create();
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(1)
+        .spillDirectory(spillDirectory->getPath())
+        .probeKeys({"t_k1"})
+        .probeVectors(std::move(probeVectors))
+        .buildKeys({"u_k1"})
+        .buildVectors(std::move(buildVectors))
+        .config(core::QueryConfig::kJoinSpillEnabled, "true")
+        .config(
+            core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
+        .joinType(core::JoinType::kRight)
+        .joinOutputLayout({"t_k1", "t_k2", "u_k1", "t_v1"})
+        .referenceQuery(
+            "SELECT t.t_k1, t.t_k2, u.u_k1, t.t_v1 FROM t RIGHT JOIN u ON t.t_k1 = u.u_k1")
+        .injectSpill(false)
+        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+          auto opStats = toOperatorStats(task->taskStats());
+          ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
+          ASSERT_GT(opStats.at("HashProbe").spilledPartitions, 1);
+        })
+        .run();
+  }
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, hashProbeSpillWhenOneOfProbeFinish) {
+  const int numDrivers{3};
+
+  std::atomic_bool probeWaitFlag{true};
+  folly::EventCount probeWait;
+  std::atomic_int numBlockedProbeOps{0};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::getOutput",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (!isHashProbeMemoryPool(*op->pool())) {
+          return;
+        }
+        if (++numBlockedProbeOps <= numDrivers - 1) {
+          probeWait.await([&]() { return !probeWaitFlag.load(); });
+          return;
+        }
+      }));
+
+  std::atomic_bool notifyOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::noMoreInput",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (!isHashProbeMemoryPool(*op->pool())) {
+          return;
+        }
+        if (!notifyOnce.exchange(false)) {
+          return;
+        }
+        probeWaitFlag = false;
+        probeWait.notifyAll();
+      }));
+
+  std::thread queryThread([&]() {
+    const auto spillDirectory = TempDirectoryPath::create();
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers, true, true)
+        .spillDirectory(spillDirectory->getPath())
+        .keyTypes({BIGINT()})
+        .probeVectors(32, 5)
+        .buildVectors(32, 5)
+        .config(core::QueryConfig::kJoinSpillEnabled, "true")
+        .referenceQuery(
+            "SELECT t_k0, t_data, u_k0, u_data FROM t, u WHERE t.t_k0 = u.u_k0")
+        .injectSpill(false)
+        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+          auto opStats = toOperatorStats(task->taskStats());
+          ASSERT_EQ(opStats.at("HashBuild").spilledBytes, 0);
+          ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
+        })
+        .run();
+  });
+  // Wait until one of the hash probe operator has finished.
+  probeWait.await([&]() { return !probeWaitFlag.load(); });
+  memory::testingRunArbitration();
+  queryThread.join();
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, hashProbeSpillExceedLimit) {
+  // If 'buildTriggerSpill' is true, then spilling is triggered by hash build.
+  for (const bool buildTriggerSpill : {false, true}) {
+    SCOPED_TRACE(fmt::format("buildTriggerSpill {}", buildTriggerSpill));
+
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve",
+        std::function<void(memory::MemoryPool*)>([&](memory::MemoryPool* pool) {
+          if (buildTriggerSpill && !isHashBuildMemoryPool(*pool)) {
+            return;
+          }
+          if (!buildTriggerSpill && !isHashProbeMemoryPool(*pool)) {
+            return;
+          }
+          testingRunArbitration(pool);
+        }));
+
+    fuzzerOpts_.vectorSize = 128;
+    auto probeVectors = createVectors(32, probeType_, fuzzerOpts_);
+    auto buildVectors = createVectors(64, buildType_, fuzzerOpts_);
+    for (int i = 0; i < probeVectors.size(); ++i) {
+      const auto probeKeyChannel = probeType_->getChildIdx("t_k1");
+      const auto buildKeyChannle = buildType_->getChildIdx("u_k1");
+      probeVectors[i]->childAt(probeKeyChannel) =
+          buildVectors[i]->childAt(buildKeyChannle);
+    }
+
+    const auto spillDirectory = TempDirectoryPath::create();
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(1)
+        .spillDirectory(spillDirectory->getPath())
+        .probeKeys({"t_k1"})
+        .probeVectors(std::move(probeVectors))
+        .buildKeys({"u_k1"})
+        .buildVectors(std::move(buildVectors))
+        .config(core::QueryConfig::kMaxSpillLevel, "1")
+        .config(core::QueryConfig::kSpillNumPartitionBits, "1")
+        .config(core::QueryConfig::kJoinSpillEnabled, "true")
+        // Set small write buffer size to have small vectors to read from
+        // spilled data.
+        .config(core::QueryConfig::kSpillWriteBufferSize, "1")
+        .config(
+            core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
+        .joinType(core::JoinType::kRight)
+        .joinOutputLayout({"t_k1", "t_k2", "u_k1", "t_v1"})
+        .referenceQuery(
+            "SELECT t.t_k1, t.t_k2, u.u_k1, t.t_v1 FROM t RIGHT JOIN u ON t.t_k1 = u.u_k1")
+        .injectSpill(false)
+        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+          auto opStats = toOperatorStats(task->taskStats());
+          if (buildTriggerSpill) {
+            ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
+            ASSERT_GT(opStats.at("HashBuild").spilledBytes, 0);
+          } else {
+            ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
+            ASSERT_EQ(opStats.at("HashBuild").spilledBytes, 0);
+          }
+          ASSERT_GT(
+              opStats.at("HashProbe")
+                  .runtimeStats[std::string(Operator::kExceededMaxSpillLevel)]
+                  .sum,
+              0);
+          ASSERT_GT(
+              opStats.at("HashBuild")
+                  .runtimeStats[std::string(Operator::kExceededMaxSpillLevel)]
+                  .sum,
+              0);
+        })
+        .run();
+  }
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, hashProbeSpillUnderNonReclaimableSection) {
+  std::atomic_bool injectOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::common::memory::MemoryPoolImpl::allocateNonContiguous",
+      std::function<void(memory::MemoryPool*)>([&](memory::MemoryPool* pool) {
+        if (!isHashProbeMemoryPool(*pool)) {
+          return;
+        }
+        if (!injectOnce.exchange(false)) {
+          return;
+        }
+        auto* arbitrator = memory::memoryManager()->arbitrator();
+        const auto numNonReclaimableAttempts =
+            arbitrator->stats().numNonReclaimableAttempts;
+        testingRunArbitration(pool);
+        // Verifies that we run into non-reclaimable section when reclaim from
+        // hash probe.
+        ASSERT_EQ(
+            arbitrator->stats().numNonReclaimableAttempts,
+            numNonReclaimableAttempts + 1);
+      }));
+
+  const auto spillDirectory = TempDirectoryPath::create();
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(1)
+      .spillDirectory(spillDirectory->getPath())
+      .keyTypes({BIGINT()})
+      .probeVectors(32, 5)
+      .buildVectors(32, 5)
+      .config(core::QueryConfig::kJoinSpillEnabled, "true")
+      .referenceQuery(
+          "SELECT t_k0, t_data, u_k0, u_data FROM t, u WHERE t.t_k0 = u.u_k0")
+      .injectSpill(false)
+      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+        auto opStats = toOperatorStats(task->taskStats());
+        ASSERT_EQ(opStats.at("HashProbe").spilledBytes, 0);
+        ASSERT_EQ(opStats.at("HashBuild").spilledBytes, 0);
+      })
+      .run();
+}
+
+// This test case is to cover the case that hash probe trigger spill for right
+// semi join types and the pending input needs to be processed in multiple
+// steps.
+DEBUG_ONLY_TEST_P(HashJoinTest, spillOutputWithRightSemiJoins) {
+  for (const auto joinType :
+       {core::JoinType::kRightSemiFilter, core::JoinType::kRightSemiProject}) {
+    std::atomic_bool injectOnce{true};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::getOutput",
+        std::function<void(Operator*)>([&](Operator* op) {
+          if (op->operatorCtx()->operatorType() != "HashProbe") {
+            return;
+          }
+          if (!op->testingHasInput()) {
+            return;
+          }
+          if (!injectOnce.exchange(false)) {
+            return;
+          }
+          testingRunArbitration(op->pool());
+        }));
+
+    std::string duckDbSqlReference;
+    std::vector<std::string> joinOutputLayout;
+    bool nullAware{false};
+    if (joinType == core::JoinType::kRightSemiProject) {
+      duckDbSqlReference = "SELECT u_k2, u_k1 IN (SELECT t_k1 FROM t) FROM u";
+      joinOutputLayout = {"u_k2", "match"};
+      // Null aware is only supported for semi projection join type.
+      nullAware = true;
+    } else {
+      duckDbSqlReference =
+          "SELECT u_k2 FROM u WHERE u_k1 IN (SELECT t_k1 FROM t)";
+      joinOutputLayout = {"u_k2"};
+    }
+
+    const auto spillDirectory = TempDirectoryPath::create();
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(1)
+        .spillDirectory(spillDirectory->getPath())
+        .probeType(probeType_)
+        .probeVectors(128, 3)
+        .probeKeys({"t_k1"})
+        .buildType(buildType_)
+        .buildVectors(128, 4)
+        .buildKeys({"u_k1"})
+        .joinType(joinType)
+        // Set a small number of output rows to process the input in multiple
+        // steps.
+        .config(
+            core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
+        .injectSpill(false)
+        .joinOutputLayout(std::move(joinOutputLayout))
+        .nullAware(nullAware)
+        .referenceQuery(duckDbSqlReference)
+        .run();
+  }
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, spillCheckOnLeftSemiFilterWithDynamicFilters) {
+  const int32_t numSplits = 10;
+  const int32_t numRowsProbe = 333;
+  const int32_t numRowsBuild = 100;
+
+  std::vector<RowVectorPtr> probeVectors;
+  probeVectors.reserve(numSplits);
+
+  std::vector<std::shared_ptr<TempFilePath>> tempFiles;
+  for (int32_t i = 0; i < numSplits; ++i) {
+    auto rowVector = makeRowVector({
+        makeFlatVector<int32_t>(
+            numRowsProbe, [&](auto row) { return row - i * 10; }),
+        makeFlatVector<int64_t>(numRowsProbe, [](auto row) { return row; }),
+    });
+    probeVectors.push_back(rowVector);
+    tempFiles.push_back(TempFilePath::create());
+    writeToFile(tempFiles.back()->getPath(), rowVector);
+  }
+  auto makeInputSplits = [&](const core::PlanNodeId& nodeId) {
+    return [&] {
+      std::vector<exec::Split> probeSplits;
+      for (auto& file : tempFiles) {
+        probeSplits.push_back(
+            exec::Split(makeHiveConnectorSplit(file->getPath())));
+      }
+      SplitInput splits;
+      splits.emplace(nodeId, probeSplits);
+      return splits;
+    };
+  };
+
+  // 100 key values in [35, 233] range.
+  std::vector<RowVectorPtr> buildVectors;
+  for (int i = 0; i < 5; ++i) {
+    buildVectors.push_back(makeRowVector({
+        makeFlatVector<int32_t>(
+            numRowsBuild / 5,
+            [i](auto row) { return 35 + 2 * (row + i * numRowsBuild / 5); }),
+        makeFlatVector<int64_t>(numRowsBuild / 5, [](auto row) { return row; }),
+    }));
+  }
+  std::vector<RowVectorPtr> keyOnlyBuildVectors;
+  for (int i = 0; i < 5; ++i) {
+    keyOnlyBuildVectors.push_back(
+        makeRowVector({makeFlatVector<int32_t>(numRowsBuild / 5, [i](auto row) {
+          return 35 + 2 * (row + i * numRowsBuild / 5);
+        })}));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto probeType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto buildSide = PlanBuilder(planNodeIdGenerator, pool_.get())
+                       .values(buildVectors)
+                       .project({"c0 AS u_c0", "c1 AS u_c1"})
+                       .planNode();
+
+  // Left semi join.
+  core::PlanNodeId probeScanId;
+  core::PlanNodeId joinNodeId;
+  const auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
+                      .tableScan(probeType)
+                      .capturePlanNodeId(probeScanId)
+                      .hashJoin(
+                          {"c0"},
+                          {"u_c0"},
+                          buildSide,
+                          "",
+                          {"c0", "c1"},
+                          core::JoinType::kLeftSemiFilter)
+                      .capturePlanNodeId(joinNodeId)
+                      .project({"c0", "c1 + 1"})
+                      .planNode();
+
+  std::atomic_bool injectOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::getOutput",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (op->operatorCtx()->operatorType() != "HashProbe") {
+          return;
+        }
+        if (!op->testingHasInput()) {
+          return;
+        }
+        if (!injectOnce.exchange(false)) {
+          return;
+        }
+        testingRunArbitration(op->pool());
+      }));
+
+  auto spillDirectory = TempDirectoryPath::create();
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(std::move(op))
+      .makeInputSplits(makeInputSplits(probeScanId))
+      .spillDirectory(spillDirectory->getPath())
+      .injectSpill(false)
+      .referenceQuery(
+          "SELECT t.c0, t.c1 + 1 FROM t WHERE t.c0 IN (SELECT c0 FROM u)")
+      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+        // Verify spill hasn't triggered.
+        auto taskStats = exec::toPlanStats(task->taskStats());
+        auto& planStats = taskStats.at(joinNodeId);
+        ASSERT_GT(planStats.spilledBytes, 0);
+      })
+      .run();
+}
+
+// This test is to verify there is no memory reservation made before hash probe
+// start processing. This can cause unnecessary spill and query OOM under some
+// real workload with many stages as each hash probe might reserve non-trivial
+// amount of memory.
+DEBUG_ONLY_TEST_P(
+    HashJoinTest,
+    hashProbeMemoryReservationCheckBeforeProbeStartWithSpillEnabled) {
+  fuzzerOpts_.vectorSize = 128;
+  auto probeVectors = createVectors(10, probeType_, fuzzerOpts_);
+  auto buildVectors = createVectors(20, buildType_, fuzzerOpts_);
+
+  std::atomic_bool checkOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::addInput",
+      std::function<void(Operator*)>(([&](Operator* op) {
+        if (op->operatorType() != "HashProbe") {
+          return;
+        }
+        if (!checkOnce.exchange(false)) {
+          return;
+        }
+        ASSERT_EQ(op->pool()->usedBytes(), 0);
+        ASSERT_EQ(op->pool()->reservedBytes(), 0);
+      })));
+
+  const auto spillDirectory = TempDirectoryPath::create();
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(1)
+      .spillDirectory(spillDirectory->getPath())
+      .probeKeys({"t_k1"})
+      .probeVectors(std::move(probeVectors))
+      .buildKeys({"u_k1"})
+      .buildVectors(std::move(buildVectors))
+      .config(core::QueryConfig::kJoinSpillEnabled, "true")
+      .joinType(core::JoinType::kInner)
+      .joinOutputLayout({"t_k1", "t_k2", "u_k1", "t_v1"})
+      .referenceQuery(
+          "SELECT t.t_k1, t.t_k2, u.u_k1, t.t_v1 FROM t JOIN u ON t.t_k1 = u.u_k1")
+      .injectSpill(true)
+      .verifier([&](const std::shared_ptr<Task>& task, bool injectSpill) {
+        if (!injectSpill) {
+          return;
+        }
+        auto opStats = toOperatorStats(task->taskStats());
+        ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
+        ASSERT_GE(opStats.at("HashProbe").spilledPartitions, 1);
+      })
+      .run();
+}
+
+TEST_P(HashJoinTest, nanKeys) {
+  // Verify the NaN values with different binary representations are considered
+  // equal.
+  static const double kNan = std::numeric_limits<double>::quiet_NaN();
+  static const double kSNaN = std::numeric_limits<double>::signaling_NaN();
+  auto probeInput = makeRowVector(
+      {makeFlatVector<double>({kNan, kSNaN}), makeFlatVector<int64_t>({1, 2})});
+  auto buildInput = makeRowVector({makeFlatVector<double>({kNan, 1})});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeInput})
+                  .project({"c0 AS t0", "c1 AS t1"})
+                  .hashJoin(
+                      {"t0"},
+                      {"u0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildInput})
+                          .project({"c0 AS u0"})
+                          .planNode(),
+                      "",
+                      {"t0", "u0", "t1"},
+                      core::JoinType::kLeft)
+                  .planNode();
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+  auto result =
+      AssertQueryBuilder(plan).queryCtx(queryCtx).copyResults(pool_.get());
+  auto expected = makeRowVector(
+      {makeFlatVector<double>({kNan, kNan}),
+       makeFlatVector<double>({kNan, kNan}),
+       makeFlatVector<int64_t>({1, 2})});
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, spillOnBlockedProbe) {
+  auto blockedOperatorFactoryUniquePtr =
+      std::make_unique<BlockedOperatorFactory>();
+  auto blockedOperatorFactory = blockedOperatorFactoryUniquePtr.get();
+  Operator::registerOperator(std::move(blockedOperatorFactoryUniquePtr));
+
+  std::vector<ContinuePromise> unblockPromises;
+  std::atomic_bool shouldBlock{true};
+  blockedOperatorFactory->setBlockedCb([&](ContinueFuture* future) {
+    if (!shouldBlock) {
+      return BlockingReason::kNotBlocked;
+    }
+    auto [p, f] = makeVeloxContinuePromiseContract("Blocked Operator");
+    *future = std::move(f);
+    unblockPromises.push_back(std::move(p));
+    return BlockingReason::kWaitForConsumer;
+  });
+
+  folly::EventCount arbitrationWait;
+  std::atomic<bool> arbitrationWaitFlag{true};
+  ::facebook::velox::common::testutil::ScopedTestValue _scopedTestValue15(
+      "facebook::velox::exec::HashBuild::finishHashBuild",
+      std::function<void(exec::HashBuild*)>([&](Operator* /* unused */) {
+        arbitrationWaitFlag = false;
+        arbitrationWait.notifyAll();
+      }));
+  std::thread arbitrationThread([&]() {
+    arbitrationWait.await([&]() { return !arbitrationWaitFlag.load(); });
+    memory::memoryManager()->shrinkPools();
+    shouldBlock = false;
+    for (auto& unblockPromise : unblockPromises) {
+      unblockPromise.setValue();
+    }
+  });
+
+  auto rowType = ROW({{"c0", INTEGER()}, {"c1", INTEGER()}});
+  std::vector<RowVectorPtr> vectors = createVectors(1, rowType, fuzzerOpts_);
+  createDuckDbTable(vectors);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto spillDirectory = TempDirectoryPath::create();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(vectors)
+                  .project({"c0 AS t0", "c1 AS t1"})
+                  .hashJoin(
+                      {"t0"},
+                      {"u0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(vectors)
+                          .project({"c0 AS u0", "c1 AS u1"})
+                          .planNode(),
+                      "",
+                      {"t1"},
+                      core::JoinType::kInner)
+                  .addNode([&](std::string id, core::PlanNodePtr input) {
+                    return std::make_shared<BlockedNode>(id, input);
+                  })
+                  .planNode();
+
+  {
+    auto task =
+        AssertQueryBuilder(duckDbQueryRunner_)
+            .plan(plan)
+            .queryCtx(newQueryCtx(
+                memory::memoryManager(), executor_.get(), kMemoryCapacity))
+            .spillDirectory(spillDirectory->getPath())
+            .config(core::QueryConfig::kSpillEnabled, true)
+            .maxDrivers(1)
+            .assertResults("SELECT a.c1 from tmp a join tmp b on a.c0 = b.c0");
+    auto joinSpillStats = taskSpilledStats(*task);
+    auto buildSpillStats = joinSpillStats.first;
+    ASSERT_GT(buildSpillStats.spilledBytes, 0);
+  }
+  arbitrationThread.join();
+  waitForAllTasksToBeDeleted(30'000'000);
+  Operator::unregisterAllOperators();
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, buildReclaimedMemoryReport) {
+  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
+  const int32_t numBuildVectors = 3;
+  std::vector<RowVectorPtr> buildVectors;
+  for (int32_t i = 0; i < numBuildVectors; ++i) {
+    VectorFuzzer fuzzer({.vectorSize = 200}, pool());
+    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
+  }
+
+  const int32_t numProbeVectors = 3;
+  std::vector<RowVectorPtr> probeVectors;
+  for (int32_t i = 0; i < numProbeVectors; ++i) {
+    VectorFuzzer fuzzer({.vectorSize = 200}, pool());
+    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
+  }
+
+  const int numDrivers{2};
+  // duckdb need double probe and build inputs as we run two drivers for hash
+  // join.
+  std::vector<RowVectorPtr> totalProbeVectors = probeVectors;
+  totalProbeVectors.insert(
+      totalProbeVectors.end(), probeVectors.begin(), probeVectors.end());
+  std::vector<RowVectorPtr> totalBuildVectors = buildVectors;
+  totalBuildVectors.insert(
+      totalBuildVectors.end(), buildVectors.begin(), buildVectors.end());
+
+  createDuckDbTable("t", totalProbeVectors);
+  createDuckDbTable("u", totalBuildVectors);
+
+  auto tempDirectory = TempDirectoryPath::create();
+  auto queryPool = memory::memoryManager()->addRootPool(
+      "", kMaxBytes, memory::MemoryReclaimer::create());
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors, true)
+                  .hashJoin(
+                      {"t_k1"},
+                      {"u_k1"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors, true)
+                          .planNode(),
+                      "",
+                      concat(probeType_->names(), buildType_->names()))
+                  .planNode();
+
+  folly::EventCount driverWait;
+  std::atomic_bool driverWaitFlag{true};
+  folly::EventCount taskWait;
+  std::atomic_bool taskWaitFlag{true};
+
+  Operator* op{nullptr};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashBuild::finishHashBuild",
+      std::function<void(Operator*)>(([&](Operator* testOp) { op = testOp; })));
+
+  std::atomic_bool injectOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve",
+      std::function<void(memory::MemoryPoolImpl*)>(
+          ([&](memory::MemoryPoolImpl* pool) {
+            if (op == nullptr || op->pool() != pool) {
+              return;
+            }
+            ASSERT_TRUE(isHashBuildMemoryPool(*pool));
+            ASSERT_TRUE(op->canReclaim());
+            ASSERT_GT(op->pool()->usedBytes(), 0);
+            ASSERT_GT(
+                op->pool()->parent()->reservedBytes(),
+                op->pool()->reservedBytes());
+            if (!injectOnce.exchange(false)) {
+              return;
+            }
+            uint64_t reclaimableBytes{0};
+            const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
+            ASSERT_TRUE(reclaimable);
+            ASSERT_GT(reclaimableBytes, 0);
+            auto* driver = op->operatorCtx()->driver();
+            TestSuspendedSection suspendedSection(driver);
+            taskWaitFlag = false;
+            taskWait.notifyAll();
+            driverWait.await([&]() { return !driverWaitFlag.load(); });
+          })));
+
+  std::thread taskThread([&]() {
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers)
+        .planNode(plan)
+        .queryPool(std::move(queryPool))
+        .injectSpill(false)
+        .spillDirectory(tempDirectory->getPath())
+        .referenceQuery(
+            "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+        .config(core::QueryConfig::kSpillStartPartitionBit, "29")
+        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+          const auto statsPair = taskSpilledStats(*task);
+          ASSERT_GT(statsPair.first.spilledBytes, 0);
+          ASSERT_EQ(statsPair.first.spilledPartitions, 16);
+          ASSERT_GT(statsPair.second.spilledBytes, 0);
+          ASSERT_EQ(statsPair.second.spilledPartitions, 16);
+          verifyTaskSpilledRuntimeStats(*task, true);
+        })
+        .run();
+  });
+
+  taskWait.await([&]() { return !taskWaitFlag.load(); });
+  ASSERT_TRUE(op != nullptr);
+  auto task = op->operatorCtx()->task();
+  auto* nodePool = op->pool()->parent();
+  const auto nodeMemoryUsage = nodePool->reservedBytes();
+  {
+    memory::ScopedMemoryArbitrationContext ctx(op->pool());
+    const uint64_t reclaimedBytes = task->pool()->reclaim(
+        task->pool()->capacity(), 1'000'000, reclaimerStats_);
+    ASSERT_GT(reclaimedBytes, 0);
+    ASSERT_EQ(nodeMemoryUsage - nodePool->reservedBytes(), reclaimedBytes);
+  }
+  // Verify all the memory has been freed.
+  ASSERT_EQ(nodePool->reservedBytes(), 0);
+
+  driverWaitFlag = false;
+  driverWait.notifyAll();
+  task.reset();
+
+  taskThread.join();
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, probeReclaimedMemoryReport) {
+  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
+  const int32_t numBuildVectors = 3;
+  std::vector<RowVectorPtr> buildVectors;
+  for (int32_t i = 0; i < numBuildVectors; ++i) {
+    VectorFuzzer fuzzer({.vectorSize = 200}, pool());
+    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
+  }
+
+  const int32_t numProbeVectors = 3;
+  std::vector<RowVectorPtr> probeVectors;
+  for (int32_t i = 0; i < numProbeVectors; ++i) {
+    VectorFuzzer fuzzer({.vectorSize = 200}, pool());
+    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto tempDirectory = TempDirectoryPath::create();
+  auto queryPool = memory::memoryManager()->addRootPool(
+      "", kMaxBytes, memory::MemoryReclaimer::create());
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors, true)
+                  .hashJoin(
+                      {"t_k1"},
+                      {"u_k1"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors, true)
+                          .planNode(),
+                      "",
+                      concat(probeType_->names(), buildType_->names()))
+                  .planNode();
+
+  folly::EventCount driverWait;
+  std::atomic_bool driverWaitFlag{true};
+  folly::EventCount taskWait;
+  std::atomic_bool taskWaitFlag{true};
+
+  Operator* op{nullptr};
+  std::atomic_int probeInputCount{0};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::addInput",
+      std::function<void(Operator*)>(([&](Operator* testOp) {
+        if (testOp->operatorType() != "HashProbe") {
+          return;
+        }
+        op = testOp;
+
+        ASSERT_TRUE(op->canReclaim());
+        if (probeInputCount++ != 1) {
+          return;
+        }
+        auto* driver = op->operatorCtx()->driver();
+        TestSuspendedSection suspendedSection(driver);
+        taskWaitFlag = false;
+        taskWait.notifyAll();
+        driverWait.await([&]() { return !driverWaitFlag.load(); });
+      })));
+
+  std::thread taskThread([&]() {
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(1)
+        .planNode(plan)
+        .queryPool(std::move(queryPool))
+        .injectSpill(false)
+        .spillDirectory(tempDirectory->getPath())
+        .referenceQuery(
+            "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+        .config(core::QueryConfig::kSpillStartPartitionBit, "29")
+        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+          const auto statsPair = taskSpilledStats(*task);
+          // The spill triggered at the probe side.
+          ASSERT_EQ(statsPair.first.spilledBytes, 0);
+          ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+          ASSERT_GT(statsPair.second.spilledBytes, 0);
+          ASSERT_EQ(statsPair.second.spilledPartitions, 16);
+        })
+        .run();
+  });
+
+  taskWait.await([&]() { return !taskWaitFlag.load(); });
+  ASSERT_TRUE(op != nullptr);
+  auto task = op->operatorCtx()->task();
+  auto* nodePool = op->pool()->parent();
+  const auto nodeMemoryUsage = nodePool->reservedBytes();
+  {
+    memory::ScopedMemoryArbitrationContext ctx(op->pool());
+    const uint64_t reclaimedBytes = task->pool()->reclaim(
+        task->pool()->capacity(), 1'000'000, reclaimerStats_);
+    ASSERT_GT(reclaimedBytes, 0);
+    ASSERT_EQ(nodeMemoryUsage - nodePool->reservedBytes(), reclaimedBytes);
+  }
+  // Verify all the memory has been freed, except for the ones for hash lookup.
+  ASSERT_EQ(nodePool->reservedBytes(), 1048576);
+
+  driverWaitFlag = false;
+  driverWait.notifyAll();
+  task.reset();
+
+  taskThread.join();
+}
+
+DEBUG_ONLY_TEST_P(HashJoinTest, hashTableCleanupAfterProbeFinish) {
+  auto buildVectors = makeVectors(buildType_, 5, 100);
+  auto probeVectors = makeVectors(probeType_, 5, 100);
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  HashProbe* probeOp{nullptr};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::getOutput",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (probeOp == nullptr && op->operatorType() == "HashProbe") {
+          probeOp = dynamic_cast<HashProbe*>(op);
+        }
+      }));
+
+  bool tableEmpty{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::noMoreInput",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (op->operatorType() == "FilterProject") {
+          tableEmpty = (probeOp->testingTable()->numDistinct() == 0);
+        }
+      }));
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors, true)
+                  .hashJoin(
+                      {"t_k1"},
+                      {"u_k1"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors, true)
+                          .planNode(),
+                      "",
+                      concat(probeType_->names(), buildType_->names()))
+                  .project({"t_k1", "t_k2", "t_v1", "u_k1", "u_k2", "u_v1"})
+                  .planNode();
+
+  auto tempDirectory = TempDirectoryPath::create();
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(1)
+      .planNode(plan)
+      .injectSpill(false)
+      .spillDirectory(tempDirectory->getPath())
+      .referenceQuery(
+          "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+      .config(core::QueryConfig::kSpillStartPartitionBit, "29")
+      .run();
+  ASSERT_TRUE(tableEmpty);
+}
+
+TEST_P(HashJoinTest, innerJoinForTypeWithCustomComparisonAndSmallVector) {
+  // This test corresponds to the SQL query:
+  // SELECT
+  //   LEFT_TABLE.ip_addr as ip_left_string,
+  //   RIGHT_TABLE.ip_addr as ip_right_string,
+  //   CAST(LEFT_TABLE.ip_addr AS IPADDRESS) as ip_left_ip_address_type,
+  //   CAST(RIGHT_TABLE.ip_addr AS IPADDRESS) as ip_right_ip_address_type,
+  //   CAST(LEFT_TABLE.ip_addr AS IPADDRESS) = CAST(RIGHT_TABLE.ip_addr AS
+  //   IPADDRESS) as are_equal_as_ip_address_type
+  // FROM
+  //   (VALUES ('2620:10d:c0a8:f0::37'), ('2620:10d:c053:33::37')) AS
+  //   LEFT_TABLE(ip_addr) INNER JOIN (VALUES ('2620:10d:c0a8:f0::37')) AS
+  //   RIGHT_TABLE(ip_addr) ON CAST(LEFT_TABLE.ip_addr AS IPADDRESS) =
+  //   CAST(RIGHT_TABLE.ip_addr AS IPADDRESS)
+  // LIMIT 1000
+
+  auto leftVectors = makeRowVector({makeFlatVector<StringView>(
+      {StringView("2620:10d:c0a8:f0::37"),
+       StringView("2620:10d:c053:33::37")})});
+
+  auto rightVectors = makeRowVector(
+      {makeFlatVector<StringView>({StringView("2620:10d:c0a8:f0::37")})});
+  createDuckDbTable("t", {leftVectors});
+  createDuckDbTable("u", {rightVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto rightPlan = PlanBuilder(planNodeIdGenerator)
+                       .values({rightVectors})
+                       .project(
+                           {"c0 AS ip_addr_right",
+                            "CAST(c0 AS IPADDRESS) AS ip_addr_cast_right"})
+                       .planNode();
+
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values({leftVectors})
+          .project({"c0 AS ip_addr", "CAST(c0 AS IPADDRESS) AS ip_addr_cast"})
+          .hashJoin(
+              {"ip_addr_cast"},
+              {"ip_addr_cast_right"},
+              rightPlan,
+              "",
+              {"ip_addr", "ip_addr_cast"},
+              core::JoinType::kInner)
+          .limit(0, 1000, false)
+          .planNode();
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+
+  ASSERT_EQ(result->size(), 1);
+  auto ipAddr = result->childAt(0)->as<SimpleVector<StringView>>();
+
+  // We expect 1 row (only the matching IPv6 address: 2620:10d:c0a8:f0::37)
+  ASSERT_EQ(ipAddr->valueAt(0), StringView("2620:10d:c0a8:f0::37"));
+
+  // Test that different IPADDRESS values correctly don't match in hash join.
+  leftVectors = makeRowVector({
+      makeFlatVector<StringView>({
+          "2620:10d:c053:33::37"_sv,
+      }),
+  });
+
+  rightVectors = makeRowVector({
+      makeFlatVector<StringView>({
+          "2620:10d:c0a8:f0::37"_sv,
+      }),
+  });
+
+  planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  rightPlan = PlanBuilder(planNodeIdGenerator)
+                  .values({rightVectors})
+                  .project(
+                      {"c0 AS ip_addr_right",
+                       "CAST(c0 AS IPADDRESS) AS ip_addr_cast_right"})
+                  .planNode();
+
+  plan = PlanBuilder(planNodeIdGenerator)
+             .values({leftVectors})
+             .project(
+                 {"c0 AS ip_left",
+                  "CAST(c0 AS IPADDRESS) AS ip_left_cast",
+                  "CAST(c0 AS VARCHAR) AS ip_left_string"})
+             .hashJoin(
+                 {"ip_left_cast"},
+                 {"ip_addr_cast_right"},
+                 rightPlan,
+                 "",
+                 {"ip_left_cast", "ip_addr_cast_right", "ip_addr_right"},
+                 core::JoinType::kInner)
+             .planNode();
+
+  // Result should be empty since the IP addresses are different
+  result = AssertQueryBuilder(plan).copyResults(pool());
+  ASSERT_EQ(result->size(), 0)
+      << "Expected no matches between different IP addresses, but got "
+      << result->size() << " rows";
+}
+
+/// Test hash join where build-side keys have a type that supports custom
+/// comparison and come from a small range which would allow for array-based
+/// lookup instead of a hash table for other types.
+TEST_P(HashJoinTest, arrayBasedLookupCustomComparisonType) {
+  std::vector<RowVectorPtr> probeVectors = {
+      makeRowVector({makeFlatVector<int64_t>(
+          1'024,
+          [](auto row) { return row; },
+          nullptr,
+          velox::test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON())})};
+
+  std::vector<RowVectorPtr> buildVectors = {
+      makeRowVector({makeFlatVector<int64_t>(
+          256,
+          [](auto row) { return row; },
+          nullptr,
+          velox::test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON())})};
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto rightPlan = PlanBuilder(planNodeIdGenerator)
+                       .values({buildVectors})
+                       .project({"c0 as right"})
+                       .planNode();
+
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .project({"c0 as left"})
+                  .hashJoin(
+                      {"left"},
+                      {"right"},
+                      rightPlan,
+                      "",
+                      {"left"},
+                      core::JoinType::kInner)
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+
+  // The probe side consists of the values 0-1023, the build side consists of
+  // the values 0-255. If custom comparison is not respected, the join will
+  // produce 256 values (0-255). When custom comparison is respected equality is
+  // treated mod 256 so we get 1024 values (0-1023).
+  EXPECT_EQ(result->size(), 1'024);
+}
+
+DEBUG_ONLY_TEST_P(
+    HashJoinTest,
+    hashProbeShouldYieldWhenFilterConsistentlyRejectAll) {
+  const uint32_t kProbeSize = 100;
+  const uint32_t kBuildSize = 10'000;
+  const uint64_t kDriverCpuTimeSliceLimitMs = 1'000;
+  const std::string kLargeBatchSize =
+      folly::to<std::string>(kProbeSize * kBuildSize);
+
+  struct {
+    uint32_t numGetOutputCalls;
+    bool hasDelay;
+    std::string debugString() const {
+      return fmt::format(
+          "numGetOutputCalls: {}, hasDelay: {}", numGetOutputCalls, hasDelay);
+    }
+  } testSettings[] = {{0, false}, {0, true}};
+
+  // Create probe data with keys 0-99 and an additional filter column
+  const auto probeData = makeRowVector(
+      {"t_k1", "t_filter"},
+      {
+          makeFlatVector<int32_t>(kProbeSize, [](auto row) { return row; }),
+          makeFlatVector<int32_t>(
+              kProbeSize,
+              [](/*row=*/auto) { return 1; }), // All rows have value 1
+      });
+
+  const auto buildData = makeRowVector(
+      {"u_k1"},
+      {
+          makeFlatVector<int32_t>(kBuildSize, [](auto row) { return row; }),
+      });
+
+  createDuckDbTable("t", {probeData});
+  createDuckDbTable("u", {buildData});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto planNode =
+      PlanBuilder(planNodeIdGenerator)
+          .values({probeData})
+          .hashJoin(
+              {"t_k1"},
+              {"u_k1"},
+              PlanBuilder(planNodeIdGenerator).values({buildData}).planNode(),
+              // Filter that DOES find join matches but then rejects all of them
+              // This ensures numOut > 0 after listJoinResults, but == 0 after
+              // evalFilter All probe rows have t_filter=1, so the condition
+              // t_filter > 100000 rejects all
+              "t_filter > 100000",
+              {"t_k1", "u_k1"},
+              core::JoinType::kInner)
+          .planNode();
+
+  for (auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    std::atomic_int hashProbeGetOutputCalls{0};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::getOutput",
+        std::function<void(Operator*)>([&](Operator* op) {
+          if (op->operatorType() == "HashProbe") {
+            // Inject delay on the 2nd getOutput call when hasDelay is true
+            // This simulates the scenario where:
+            // 1. First getOutput: Probe data added via addInput
+            // 2. Second getOutput: Join finds matches, filter rejects all
+            //    During this call, we inject delay INSIDE the processing
+            //    to simulate CPU-intensive work in the loop
+            if (hashProbeGetOutputCalls.fetch_add(1) == 1 &&
+                testData.hasDelay) {
+              std::this_thread::sleep_for(
+                  std::chrono::milliseconds(2 * kDriverCpuTimeSliceLimitMs));
+            }
+          }
+        }));
+
+    auto queryCtx = core::QueryCtx::create(
+        executor_.get(),
+        core::QueryConfig({
+            {core::QueryConfig::kDriverCpuTimeSliceLimitMs,
+             folly::to<std::string>(kDriverCpuTimeSliceLimitMs)},
+            {core::QueryConfig::kPreferredOutputBatchRows, kLargeBatchSize},
+        }));
+
+    AssertQueryBuilder(planNode, duckDbQueryRunner_)
+        .queryCtx(queryCtx)
+        .maxDrivers(1)
+        .assertResults(
+            "SELECT t_k1, u_k1 FROM t, u WHERE t_k1 = u_k1 AND t_filter > 100000");
+    testData.numGetOutputCalls = hashProbeGetOutputCalls.load();
+  }
+  ASSERT_LT(
+      testSettings[0].numGetOutputCalls, testSettings[1].numGetOutputCalls);
+}
+
+// This test validates that when spillOutput() is running (toSpillOutput=true),
+// the operator should NOT yield even when shouldYield() returns true. This is
+// critical because yielding during spillOutput would break the spilling loop.
+DEBUG_ONLY_TEST_P(
+    HashJoinTest,
+    spillOutputShouldNotYieldWhenFilterConsistentlyRejectAll) {
+  const uint32_t kProbeSize = 100;
+  const uint32_t kBuildSize = 10'000;
+  const uint64_t driverCpuTimeSliceLimitMs = 1'000;
+  const std::string largeBatchSize =
+      folly::to<std::string>(kProbeSize * kBuildSize);
+
+  // Create probe data with keys 0-99 and an additional filter column
+  const auto probeData = makeRowVector(
+      {"t_k1", "t_filter"},
+      {
+          makeFlatVector<int32_t>(kProbeSize, [](auto row) { return row; }),
+          makeFlatVector<int32_t>(
+              kProbeSize,
+              [](/*row=*/auto) { return 1; }), // All rows have value 1
+      });
+
+  const auto buildData = makeRowVector(
+      {"u_k1"},
+      {
+          makeFlatVector<int32_t>(kBuildSize, [](auto row) { return row; }),
+      });
+
+  createDuckDbTable("t", {probeData});
+  createDuckDbTable("u", {buildData});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto planNode =
+      PlanBuilder(planNodeIdGenerator)
+          .values({probeData})
+          .hashJoin(
+              {"t_k1"},
+              {"u_k1"},
+              PlanBuilder(planNodeIdGenerator).values({buildData}).planNode(),
+              // Filter that DOES find join matches but then rejects all of them
+              // This ensures numOut > 0 after listJoinResults, but == 0 after
+              // evalFilter. All probe rows have t_filter=1, so the condition
+              // t_filter > 100000 rejects all
+              "t_filter > 100000",
+              {"t_k1", "u_k1"},
+              core::JoinType::kInner)
+          .planNode();
+
+  std::atomic_bool spillTriggered{false};
+  ::facebook ::velox ::common ::testutil ::ScopedTestValue _scopedTestValue5200(
+      "facebook::velox::exec::Driver::runInternal::getOutput",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (spillTriggered.load() || op->operatorType() != "HashProbe" ||
+            !op->testingHasInput()) {
+          return;
+        }
+        spillTriggered = true;
+        testingRunArbitration(op->pool());
+      }));
+
+  // We inject delay in reclaim to trigger shouldYield().
+  // The test verifies that the query completes successfully despite
+  // shouldYield() returning true, which would only happen if the
+  // !toSpillOutput check prevents early return.
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashProbe::reclaim",
+      std::function<void(HashProbe*)>([&](HashProbe* probe) {
+        if (!spillTriggered.load()) {
+          return;
+        }
+        // Inject delay once to trigger shouldYield()
+        std::this_thread::sleep_for(
+            std::chrono::milliseconds(2 * driverCpuTimeSliceLimitMs));
+      }));
+
+  const auto spillDirectory = TempDirectoryPath::create();
+  AssertQueryBuilder(planNode, duckDbQueryRunner_)
+      .queryCtx(core::QueryCtx::create(driverExecutor_.get()))
+      .maxDrivers(1)
+      .spillDirectory(spillDirectory->getPath())
+      .config(core::QueryConfig::kSpillEnabled, true)
+      .config(core::QueryConfig::kJoinSpillEnabled, true)
+      .config(core::QueryConfig::kSpillStartPartitionBit, 29)
+      .config(
+          core::QueryConfig::kDriverCpuTimeSliceLimitMs,
+          driverCpuTimeSliceLimitMs)
+      .config(core::QueryConfig::kPreferredOutputBatchRows, largeBatchSize)
+      .assertResults(
+          "SELECT t_k1, u_k1 FROM t, u WHERE t_k1 = u_k1 AND t_filter > 100000");
+
+  ASSERT_TRUE(spillTriggered.load());
+}
+
+TEST_P(MultiThreadedHashJoinTest, antiJoin) {
+  auto probeVectors = makeBatches(64, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"t0", "t1"},
+        {
+            makeNullableFlatVector<int32_t>({std::nullopt, 1, 2}),
+            makeFlatVector<int32_t>({0, 1, 2}),
+        });
+  });
+  auto buildVectors = makeBatches(64, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"u0", "u1"},
+        {
+            makeNullableFlatVector<int32_t>({std::nullopt, 2, 3}),
+            makeFlatVector<int32_t>({0, 2, 3}),
+        });
+  });
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+      .probeKeys({"t0"})
+      .probeVectors(std::vector<RowVectorPtr>(probeVectors))
+      .buildKeys({"u0"})
+      .buildVectors(std::vector<RowVectorPtr>(buildVectors))
+      .joinType(core::JoinType::kAnti)
+      .joinOutputLayout({"t0", "t1"})
+      .referenceQuery(
+          "SELECT t.* FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE u.u0 = t.t0)")
+      .run();
+
+  std::vector<std::string> filters({
+      "u1 > t1",
+      "u1 * t1 > 0",
+      // This filter is true on rows without a match. It should not prevent
+      // the row from being returned.
+      "coalesce(u1, t1, 0::integer) is not null",
+      // This filter throws if evaluated on rows without a match. The join
+      // should not evaluate filter on those rows and therefore should not
+      // fail.
+      "t1 / coalesce(u1, 0::integer) is not null",
+      // This filter triggers memory pool allocation at
+      // HashBuild::setupFilterForAntiJoins, which should not be invoked in
+      // operator's constructor.
+      "contains(array[1, 2, NULL], 1)",
+  });
+  for (const std::string& filter : filters) {
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+        .probeKeys({"t0"})
+        .probeVectors(std::vector<RowVectorPtr>(probeVectors))
+        .buildKeys({"u0"})
+        .buildVectors(std::vector<RowVectorPtr>(buildVectors))
+        .joinType(core::JoinType::kAnti)
+        .joinFilter(filter)
+        .joinOutputLayout({"t0", "t1"})
+        .referenceQuery(
+            fmt::format(
+                "SELECT t.* FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE u.u0 = t.t0 AND {})",
+                filter))
+        .run();
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, antiJoinWithFilterAndEmptyBuild) {
+  const std::vector<bool> finishOnEmptys = {false, true};
+  for (const auto finishOnEmpty : finishOnEmptys) {
+    SCOPED_TRACE(fmt::format("finishOnEmpty: {}", finishOnEmpty));
+
+    auto probeVectors = makeBatches(4, [&](int32_t /*unused*/) {
+      return makeRowVector(
+          {"t0", "t1"},
+          {
+              makeNullableFlatVector<int32_t>({std::nullopt, 1, 2}),
+              makeFlatVector<int32_t>({0, 1, 2}),
+          });
+    });
+    auto buildVectors = makeBatches(4, [&](int32_t /*unused*/) {
+      return makeRowVector(
+          {"u0", "u1"},
+          {
+              makeNullableFlatVector<int32_t>({3, 2, 3}),
+              makeFlatVector<int32_t>({0, 2, 3}),
+          });
+    });
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
+        .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+        .probeKeys({"t0"})
+        .probeVectors(std::vector<RowVectorPtr>(probeVectors))
+        .buildKeys({"u0"})
+        .buildVectors(std::vector<RowVectorPtr>(buildVectors))
+        .buildFilter("u0 < 0")
+        .joinType(core::JoinType::kAnti)
+        .joinFilter("u1 > t1")
+        .joinOutputLayout({"t0", "t1"})
+        .referenceQuery(
+            "SELECT t.* FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE u0 < 0 AND u.u0 = t.t0)")
+        .checkSpillStats(false)
+        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+          const auto statsPair = taskSpilledStats(*task);
+          ASSERT_EQ(statsPair.first.spilledRows, 0);
+          ASSERT_EQ(statsPair.first.spilledBytes, 0);
+          ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+          ASSERT_EQ(statsPair.first.spilledFiles, 0);
+          ASSERT_EQ(statsPair.second.spilledRows, 0);
+          ASSERT_EQ(statsPair.second.spilledBytes, 0);
+          ASSERT_EQ(statsPair.second.spilledPartitions, 0);
+          ASSERT_EQ(statsPair.second.spilledFiles, 0);
+          verifyTaskSpilledRuntimeStats(*task, false);
+          ASSERT_EQ(maxHashBuildSpillLevel(*task), -1);
+        })
+        .run();
+  }
+}
+
+// Reproduces a debug-mode crash in evalFilter for ANTI join with filter.
+// A batch of all matched rows followed by a batch of all non-matching rows
+// triggers DictionaryVector::validate on a stale filterResult_ whose shared
+// outputRowMapping_ buffer has been overwritten by listJoinResults.
+TEST_P(MultiThreadedHashJoinTest, antiJoinWithBooleanKeysAndFilter) {
+  // 5 build rows with key (true, true).
+  auto buildVectors = makeBatches(1, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"u0", "u1"},
+        {
+            makeFlatVector<bool>(5, [](auto /*row*/) { return true; }),
+            makeFlatVector<bool>(5, [](auto /*row*/) { return true; }),
+        });
+  });
+
+  // 10 probe rows: rows 0-1 match (2 * 5 = 10 output entries),
+  // rows 2-9 don't match (8 miss entries).
+  auto probeVectors = makeBatches(1, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"t0", "t1"},
+        {
+            makeFlatVector<bool>(10, [](auto row) { return row < 2; }),
+            makeFlatVector<bool>(10, [](auto row) { return row < 2; }),
+        });
+  });
+
+  // outputBatchSize=10 forces the split: 10 matches in batch 1,
+  // 8 misses in batch 2.
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(1)
+      .probeKeys({"t0", "t1"})
+      .probeVectors(std::move(probeVectors))
+      .buildKeys({"u0", "u1"})
+      .buildVectors(std::move(buildVectors))
+      .joinType(core::JoinType::kAnti)
+      .joinFilter("t1 = true")
+      .joinOutputLayout({"t0", "t1"})
+      .referenceQuery(
+          "SELECT t.* FROM t WHERE NOT EXISTS "
+          "(SELECT * FROM u WHERE t.t0 = u.u0 AND t.t1 = u.u1 AND t.t1 = true)")
+      .config(core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
+      .checkSpillStats(false)
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, leftJoin) {
+  // Left side keys are [0, 1, 2,..20].
+  // Use 3-rd column as row number to allow for asserting the order of
+  // results.
+  std::vector<RowVectorPtr> probeVectors = mergeBatches(
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector(
+                {"c0", "c1", "row_number"},
+                {
+                    makeFlatVector<int32_t>(
+                        77, [](auto row) { return row % 21; }, nullEvery(13)),
+                    makeFlatVector<int32_t>(77, [](auto row) { return row; }),
+                    makeFlatVector<int32_t>(77, [](auto row) { return row; }),
+                });
+          }),
+      makeBatches(
+          2,
+          [&](int32_t /*unused*/) {
+            return makeRowVector(
+                {"c0", "c1", "row_number"},
+                {
+                    makeFlatVector<int32_t>(
+                        97,
+                        [](auto row) { return (row + 3) % 21; },
+                        nullEvery(13)),
+                    makeFlatVector<int32_t>(97, [](auto row) { return row; }),
+                    makeFlatVector<int32_t>(
+                        97, [](auto row) { return 97 + row; }),
+                });
+          }),
+      true);
+
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(3, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                73, [](auto row) { return row % 5; }, nullEvery(7)),
+            makeFlatVector<int32_t>(
+                73, [](auto row) { return -111 + row * 2; }, nullEvery(7)),
+        });
+      });
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+      .probeKeys({"c0"})
+      .probeVectors(std::move(probeVectors))
+      .buildKeys({"u_c0"})
+      .buildVectors(std::move(buildVectors))
+      .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+      .joinType(core::JoinType::kLeft)
+      .joinOutputLayout({"row_number", "c0", "c1", "u_c0"})
+      .referenceQuery(
+          "SELECT t.row_number, t.c0, t.c1, u.c0 FROM t LEFT JOIN u ON t.c0 = u.c0")
+      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+        int nullJoinBuildKeyCount = 0;
+        int nullJoinProbeKeyCount = 0;
+
+        for (auto& pipeline : task->taskStats().pipelineStats) {
+          for (auto op : pipeline.operatorStats) {
+            if (op.operatorType == OperatorType::kHashBuild) {
+              nullJoinBuildKeyCount += op.numNullKeys;
+            }
+            if (op.operatorType == OperatorType::kHashProbe) {
+              nullJoinProbeKeyCount += op.numNullKeys;
+            }
+          }
+        }
+        ASSERT_EQ(nullJoinBuildKeyCount, 33 * GetParam().numDrivers);
+        ASSERT_EQ(nullJoinProbeKeyCount, 34 * GetParam().numDrivers);
+      })
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, nullStatsWithEmptyBuild) {
+  std::vector<RowVectorPtr> probeVectors =
+      makeBatches(1, [&](int32_t /*unused*/) {
+        return makeRowVector(
+            {"c0", "c1", "row_number"},
+            {
+                makeFlatVector<int32_t>(
+                    77, [](auto row) { return row % 21; }, nullEvery(13)),
+                makeFlatVector<int32_t>(77, [](auto row) { return row; }),
+                makeFlatVector<int32_t>(77, [](auto row) { return row; }),
+            });
+      });
+
+  // All null keys on build side.
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(1, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                1, [](auto row) { return row % 5; }, nullEvery(1)),
+            makeFlatVector<int32_t>(
+                1, [](auto row) { return -111 + row * 2; }, nullEvery(1)),
+        });
+      });
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+      .probeKeys({"c0"})
+      .probeVectors(std::move(probeVectors))
+      .buildKeys({"u_c0"})
+      .buildVectors(std::move(buildVectors))
+      .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+      .joinType(core::JoinType::kLeft)
+      .joinOutputLayout({"row_number", "c0", "c1", "u_c0"})
+      .referenceQuery(
+          "SELECT t.row_number, t.c0, t.c1, u.c0 FROM t LEFT JOIN u ON t.c0 = u.c0")
+      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+        int nullJoinBuildKeyCount = 0;
+        int nullJoinProbeKeyCount = 0;
+
+        for (auto& pipeline : task->taskStats().pipelineStats) {
+          for (auto op : pipeline.operatorStats) {
+            if (op.operatorType == OperatorType::kHashBuild) {
+              nullJoinBuildKeyCount += op.numNullKeys;
+            }
+            if (op.operatorType == OperatorType::kHashProbe) {
+              nullJoinProbeKeyCount += op.numNullKeys;
+            }
+          }
+        }
+        // Due to inaccurate stats tracking in case of empty build side,
+        // we will report 0 null keys on probe side.
+        ASSERT_EQ(nullJoinProbeKeyCount, 0);
+        ASSERT_EQ(nullJoinBuildKeyCount, 1 * GetParam().numDrivers);
+      })
+      .checkSpillStats(false)
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, leftJoinWithEmptyBuild) {
+  const std::vector<bool> finishOnEmptys = {false, true};
+  for (const auto finishOnEmpty : finishOnEmptys) {
+    SCOPED_TRACE(fmt::format("finishOnEmpty: {}", finishOnEmpty));
+
+    // Left side keys are [0, 1, 2,..10].
+    // Use 3-rd column as row number to allow for asserting the order of
+    // results.
+    std::vector<RowVectorPtr> probeVectors = mergeBatches(
+        makeBatches(
+            3,
+            [&](int32_t /*unused*/) {
+              return makeRowVector(
+                  {"c0", "c1", "row_number"},
+                  {
+                      makeFlatVector<int32_t>(
+                          77, [](auto row) { return row % 11; }, nullEvery(13)),
+                      makeFlatVector<int32_t>(77, [](auto row) { return row; }),
+                      makeFlatVector<int32_t>(77, [](auto row) { return row; }),
+                  });
+            }),
+        makeBatches(
+            2,
+            [&](int32_t /*unused*/) {
+              return makeRowVector(
+                  {"c0", "c1", "row_number"},
+                  {
+                      makeFlatVector<int32_t>(
+                          97,
+                          [](auto row) { return (row + 3) % 11; },
+                          nullEvery(13)),
+                      makeFlatVector<int32_t>(97, [](auto row) { return row; }),
+                      makeFlatVector<int32_t>(
+                          97, [](auto row) { return 97 + row; }),
+                  });
+            }),
+        true);
+
+    std::vector<RowVectorPtr> buildVectors =
+        makeBatches(3, [&](int32_t /*unused*/) {
+          return makeRowVector({
+              makeFlatVector<int32_t>(
+                  73, [](auto row) { return row % 5; }, nullEvery(7)),
+              makeFlatVector<int32_t>(
+                  73, [](auto row) { return -111 + row * 2; }, nullEvery(7)),
+          });
+        });
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
+        .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+        .probeKeys({"c0"})
+        .probeVectors(std::move(probeVectors))
+        .buildKeys({"u_c0"})
+        .buildVectors(std::move(buildVectors))
+        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+        .buildFilter("c0 < 0")
+        .joinType(core::JoinType::kLeft)
+        .joinOutputLayout({"row_number", "c1"})
+        .referenceQuery(
+            "SELECT t.row_number, t.c1 FROM t LEFT JOIN (SELECT c0 FROM u WHERE c0 < 0) u ON t.c0 = u.c0")
+        .checkSpillStats(false)
+        .run();
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, leftJoinWithNoJoin) {
+  // Left side keys are [0, 1, 2,..10].
+  // Use 3-rd column as row number to allow for asserting the order of
+  // results.
+  std::vector<RowVectorPtr> probeVectors = mergeBatches(
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector(
+                {"c0", "c1", "row_number"},
+                {
+                    makeFlatVector<int32_t>(
+                        77, [](auto row) { return row % 11; }, nullEvery(13)),
+                    makeFlatVector<int32_t>(77, [](auto row) { return row; }),
+                    makeFlatVector<int32_t>(77, [](auto row) { return row; }),
+                });
+          }),
+      makeBatches(
+          2,
+          [&](int32_t /*unused*/) {
+            return makeRowVector(
+                {"c0", "c1", "row_number"},
+                {
+                    makeFlatVector<int32_t>(
+                        97,
+                        [](auto row) { return (row + 3) % 11; },
+                        nullEvery(13)),
+                    makeFlatVector<int32_t>(97, [](auto row) { return row; }),
+                    makeFlatVector<int32_t>(
+                        97, [](auto row) { return 97 + row; }),
+                });
+          }),
+      true);
+
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(3, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                73, [](auto row) { return row % 5; }, nullEvery(7)),
+            makeFlatVector<int32_t>(
+                73, [](auto row) { return -111 + row * 2; }, nullEvery(7)),
+        });
+      });
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+      .probeKeys({"c0"})
+      .probeVectors(std::move(probeVectors))
+      .buildKeys({"u_c0"})
+      .buildVectors(std::move(buildVectors))
+      .buildProjections({"c0 - 123::INTEGER AS u_c0", "c1 AS u_c1"})
+      .joinType(core::JoinType::kLeft)
+      .joinOutputLayout({"row_number", "c0", "u_c1"})
+      .referenceQuery(
+          "SELECT t.row_number, t.c0, u.c1 FROM t LEFT JOIN (SELECT c0 - 123::INTEGER AS u_c0, c1 FROM u) u ON t.c0 = u.u_c0")
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, leftJoinWithAllMatch) {
+  // Left side keys are [0, 1, 2,..10].
+  // Use 3-rd column as row number to allow for asserting the order of
+  // results.
+  std::vector<RowVectorPtr> probeVectors = mergeBatches(
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector(
+                {"c0", "c1", "row_number"},
+                {
+                    makeFlatVector<int32_t>(
+                        77, [](auto row) { return row % 11; }, nullEvery(13)),
+                    makeFlatVector<int32_t>(77, [](auto row) { return row; }),
+                    makeFlatVector<int32_t>(77, [](auto row) { return row; }),
+                });
+          }),
+      makeBatches(
+          2,
+          [&](int32_t /*unused*/) {
+            return makeRowVector(
+                {"c0", "c1", "row_number"},
+                {
+                    makeFlatVector<int32_t>(
+                        97,
+                        [](auto row) { return (row + 3) % 11; },
+                        nullEvery(13)),
+                    makeFlatVector<int32_t>(97, [](auto row) { return row; }),
+                    makeFlatVector<int32_t>(
+                        97, [](auto row) { return 97 + row; }),
+                });
+          }),
+      true);
+
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(3, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                73, [](auto row) { return row % 5; }, nullEvery(7)),
+            makeFlatVector<int32_t>(
+                73, [](auto row) { return -111 + row * 2; }, nullEvery(7)),
+        });
+      });
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+      .probeKeys({"c0"})
+      .probeVectors(std::move(probeVectors))
+      .probeFilter("c0 < 5")
+      .buildKeys({"u_c0"})
+      .buildVectors(std::move(buildVectors))
+      .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+      .joinType(core::JoinType::kLeft)
+      .joinOutputLayout({"row_number", "c0", "c1", "u_c1"})
+      .referenceQuery(
+          "SELECT t.row_number, t.c0, t.c1, u.c1 FROM (SELECT * FROM t WHERE c0 < 5) t LEFT JOIN u ON t.c0 = u.c0")
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, leftJoinWithFilter) {
+  // Left side keys are [0, 1, 2,..10].
+  // Use 3-rd column as row number to allow for asserting the order of
+  // results.
+  std::vector<RowVectorPtr> probeVectors = mergeBatches(
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector(
+                {"c0", "c1", "row_number"},
+                {
+                    makeFlatVector<int32_t>(
+                        77, [](auto row) { return row % 11; }, nullEvery(13)),
+                    makeFlatVector<int32_t>(77, [](auto row) { return row; }),
+                    makeFlatVector<int32_t>(77, [](auto row) { return row; }),
+                });
+          }),
+      makeBatches(
+          2,
+          [&](int32_t /*unused*/) {
+            return makeRowVector(
+                {"c0", "c1", "row_number"},
+                {
+                    makeFlatVector<int32_t>(
+                        97,
+                        [](auto row) { return (row + 3) % 11; },
+                        nullEvery(13)),
+                    makeFlatVector<int32_t>(97, [](auto row) { return row; }),
+                    makeFlatVector<int32_t>(
+                        97, [](auto row) { return 97 + row; }),
+                });
+          }),
+      true);
+
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(3, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                73, [](auto row) { return row % 5; }, nullEvery(7)),
+            makeFlatVector<int32_t>(
+                73, [](auto row) { return -111 + row * 2; }, nullEvery(7)),
+        });
+      });
+
+  // Additional filter.
+  {
+    auto testProbeVectors = probeVectors;
+    auto testBuildVectors = buildVectors;
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+        .probeKeys({"c0"})
+        .probeVectors(std::move(testProbeVectors))
+        .buildKeys({"u_c0"})
+        .buildVectors(std::move(testBuildVectors))
+        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+        .joinType(core::JoinType::kLeft)
+        .joinFilter("(c1 + u_c1) % 2 = 1")
+        .joinOutputLayout({"row_number", "c0", "c1", "u_c1"})
+        .referenceQuery(
+            "SELECT t.row_number, t.c0, t.c1, u.c1 FROM t LEFT JOIN u ON t.c0 = u.c0 AND (t.c1 + u.c1) % 2 = 1")
+        .run();
+  }
+
+  // No rows pass the additional filter.
+  {
+    auto testProbeVectors = probeVectors;
+    auto testBuildVectors = buildVectors;
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+        .probeKeys({"c0"})
+        .probeVectors(std::move(testProbeVectors))
+        .buildKeys({"u_c0"})
+        .buildVectors(std::move(testBuildVectors))
+        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+        .joinType(core::JoinType::kLeft)
+        .joinFilter("(c1 + u_c1) % 2  = 3")
+        .joinOutputLayout({"row_number", "c0", "c1", "u_c1"})
+        .referenceQuery(
+            "SELECT t.row_number, t.c0, t.c1, u.c1 FROM t LEFT JOIN u ON t.c0 = u.c0 AND (t.c1 + u.c1) % 2 = 3")
+        .run();
+  }
+}
+
+/// Tests left join with a filter that may evaluate to true, false or null.
+/// Makes sure that null filter results are handled correctly, e.g. as if the
+/// filter returned false.
+TEST_P(MultiThreadedHashJoinTest, leftJoinWithNullableFilter) {
+  std::vector<RowVectorPtr> probeVectors = mergeBatches(
+      makeBatches(
+          5,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+                makeNullableFlatVector<int32_t>(
+                    {10, std::nullopt, 30, std::nullopt, 50}),
+            });
+          }),
+      makeBatches(
+          5,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+                makeNullableFlatVector<int32_t>(
+                    {std::nullopt, 20, 30, std::nullopt, 50}),
+            });
+          }),
+      true);
+
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(5, [&](int32_t /*unused*/) {
+        return makeRowVector(
+            {makeFlatVector<int32_t>(128, [](vector_size_t row) {
+              if (row < 3) {
+                return row;
+              }
+              return row + 10;
+            })});
+      });
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+      .probeKeys({"c0"})
+      .probeVectors(std::move(probeVectors))
+      .buildKeys({"u_c0"})
+      .buildVectors(std::move(buildVectors))
+      .buildProjections({"c0 AS u_c0"})
+      .joinType(core::JoinType::kLeft)
+      .joinFilter("c1 + u_c0 > 0")
+      .joinOutputLayout({"c0", "c1", "u_c0"})
+      .referenceQuery(
+          "SELECT * FROM t LEFT JOIN u ON (t.c0 = u.c0 AND t.c1 + u.c0 > 0)")
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, rightJoin) {
+  // Left side keys are [0, 1, 2,..20].
+  std::vector<RowVectorPtr> probeVectors = mergeBatches(
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    137, [](auto row) { return row % 21; }, nullEvery(13)),
+                makeFlatVector<int32_t>(137, [](auto row) { return row; }),
+            });
+          }),
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    234,
+                    [](auto row) { return (row + 3) % 21; },
+                    nullEvery(13)),
+                makeFlatVector<int32_t>(234, [](auto row) { return row; }),
+            });
+          }),
+      true);
+
+  // Right side keys are [-3, -2, -1, 0, 1, 2, 3].
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(3, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
+        });
+      });
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+      .probeKeys({"c0"})
+      .probeVectors(std::move(probeVectors))
+      .buildKeys({"u_c0"})
+      .buildVectors(std::move(buildVectors))
+      .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+      .joinType(core::JoinType::kRight)
+      .joinOutputLayout({"c0", "c1", "u_c1"})
+      .referenceQuery(
+          "SELECT t.c0, t.c1, u.c1 FROM t RIGHT JOIN u ON t.c0 = u.c0")
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, rightJoinWithEmptyBuild) {
+  const std::vector<bool> finishOnEmptys = {false, true};
+  for (const auto finishOnEmpty : finishOnEmptys) {
+    SCOPED_TRACE(fmt::format("finishOnEmpty: {}", finishOnEmpty));
+
+    // Left side keys are [0, 1, 2,..10].
+    std::vector<RowVectorPtr> probeVectors = mergeBatches(
+        makeBatches(
+            3,
+            [&](int32_t /*unused*/) {
+              return makeRowVector({
+                  makeFlatVector<int32_t>(
+                      137, [](auto row) { return row % 11; }, nullEvery(13)),
+                  makeFlatVector<int32_t>(137, [](auto row) { return row; }),
+              });
+            }),
+        makeBatches(
+            3,
+            [&](int32_t /*unused*/) {
+              return makeRowVector({
+                  makeFlatVector<int32_t>(
+                      234,
+                      [](auto row) { return (row + 3) % 11; },
+                      nullEvery(13)),
+                  makeFlatVector<int32_t>(234, [](auto row) { return row; }),
+              });
+            }),
+        true);
+
+    // Right side keys are [-3, -2, -1, 0, 1, 2, 3].
+    std::vector<RowVectorPtr> buildVectors =
+        makeBatches(3, [&](int32_t /*unused*/) {
+          return makeRowVector({
+              makeFlatVector<int32_t>(
+                  123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
+              makeFlatVector<int32_t>(
+                  123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
+          });
+        });
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
+        .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+        .probeKeys({"c0"})
+        .probeVectors(std::move(probeVectors))
+        .buildKeys({"u_c0"})
+        .buildVectors(std::move(buildVectors))
+        .buildFilter("c0 > 100")
+        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+        .joinType(core::JoinType::kRight)
+        .joinOutputLayout({"c1"})
+        .referenceQuery("SELECT null LIMIT 0")
+        .checkSpillStats(false)
+        .run();
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, rightJoinWithAllMatch) {
+  // Left side keys are [0, 1, 2,..20].
+  std::vector<RowVectorPtr> probeVectors = mergeBatches(
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    137, [](auto row) { return row % 21; }, nullEvery(13)),
+                makeFlatVector<int32_t>(137, [](auto row) { return row; }),
+            });
+          }),
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    234,
+                    [](auto row) { return (row + 3) % 21; },
+                    nullEvery(13)),
+                makeFlatVector<int32_t>(234, [](auto row) { return row; }),
+            });
+          }),
+      true);
+
+  // Right side keys are [-3, -2, -1, 0, 1, 2, 3].
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(3, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
+        });
+      });
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+      .probeKeys({"c0"})
+      .probeVectors(std::move(probeVectors))
+      .buildKeys({"u_c0"})
+      .buildVectors(std::move(buildVectors))
+      .buildFilter("c0 >= 0")
+      .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+      .joinType(core::JoinType::kRight)
+      .joinOutputLayout({"c0", "c1", "u_c1"})
+      .referenceQuery(
+          "SELECT t.c0, t.c1, u.c1 FROM t RIGHT JOIN (SELECT * FROM u WHERE c0 >= 0) u ON t.c0 = u.c0")
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, rightJoinWithFilter) {
+  // Left side keys are [0, 1, 2,..20].
+  std::vector<RowVectorPtr> probeVectors = mergeBatches(
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    137, [](auto row) { return row % 21; }, nullEvery(13)),
+                makeFlatVector<int32_t>(137, [](auto row) { return row; }),
+            });
+          }),
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    234,
+                    [](auto row) { return (row + 3) % 21; },
+                    nullEvery(13)),
+                makeFlatVector<int32_t>(234, [](auto row) { return row; }),
+            });
+          }),
+      true);
+
+  // Right side keys are [-3, -2, -1, 0, 1, 2, 3].
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(3, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
+        });
+      });
+
+  // Filter with passed rows.
+  {
+    auto testProbeVectors = probeVectors;
+    auto testBuildVectors = buildVectors;
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+        .probeKeys({"c0"})
+        .probeVectors(std::move(testProbeVectors))
+        .buildKeys({"u_c0"})
+        .buildVectors(std::move(testBuildVectors))
+        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+        .joinType(core::JoinType::kRight)
+        .joinFilter("(c1 + u_c1) % 2 = 1")
+        .joinOutputLayout({"c0", "c1", "u_c1"})
+        .referenceQuery(
+            "SELECT t.c0, t.c1, u.c1 FROM t RIGHT JOIN u ON t.c0 = u.c0 AND (t.c1 + u.c1) % 2 = 1")
+        .run();
+  }
+
+  // Filter without passed rows.
+  {
+    auto testProbeVectors = probeVectors;
+    auto testBuildVectors = buildVectors;
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+        .probeKeys({"c0"})
+        .probeVectors(std::move(testProbeVectors))
+        .buildKeys({"u_c0"})
+        .buildVectors(std::move(testBuildVectors))
+        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+        .joinType(core::JoinType::kRight)
+        .joinFilter("(c1 + u_c1) % 2 = 3")
+        .joinOutputLayout({"c0", "c1", "u_c1"})
+        .referenceQuery(
+            "SELECT t.c0, t.c1, u.c1 FROM t RIGHT JOIN u ON t.c0 = u.c0 AND (t.c1 + u.c1) % 2 = 3")
+        .run();
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, fullJoin) {
+  // Left side keys are [0, 1, 2,..20].
+  std::vector<RowVectorPtr> probeVectors = mergeBatches(
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    213, [](auto row) { return row % 21; }, nullEvery(13)),
+                makeFlatVector<int32_t>(213, [](auto row) { return row; }),
+            });
+          }),
+      makeBatches(
+          2,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    137,
+                    [](auto row) { return (row + 3) % 21; },
+                    nullEvery(13)),
+                makeFlatVector<int32_t>(137, [](auto row) { return row; }),
+            });
+          }),
+      true);
+
+  // Right side keys are [-3, -2, -1,
+  // 0, 1, 2, 3].
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(3, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
+        });
+      });
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+      .probeKeys({"c0"})
+      .probeVectors(std::move(probeVectors))
+      .buildKeys({"u_c0"})
+      .buildVectors(std::move(buildVectors))
+      .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+      .joinType(core::JoinType::kFull)
+      .joinOutputLayout({"c0", "c1", "u_c1"})
+      .referenceQuery(
+          "SELECT t.c0, t.c1, u.c1 FROM t FULL OUTER JOIN u ON t.c0 = u.c0")
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, fullJoinWithEmptyBuild) {
+  const std::vector<bool> finishOnEmptys = {false, true};
+  for (const auto finishOnEmpty : finishOnEmptys) {
+    SCOPED_TRACE(fmt::format("finishOnEmpty: {}", finishOnEmpty));
+
+    // Left side keys are [0, 1, 2,..10].
+    std::vector<RowVectorPtr> probeVectors = mergeBatches(
+        makeBatches(
+            3,
+            [&](int32_t /*unused*/) {
+              return makeRowVector({
+                  makeFlatVector<int32_t>(
+                      213, [](auto row) { return row % 11; }, nullEvery(13)),
+                  makeFlatVector<int32_t>(213, [](auto row) { return row; }),
+              });
+            }),
+        makeBatches(
+            2,
+            [&](int32_t /*unused*/) {
+              return makeRowVector({
+                  makeFlatVector<int32_t>(
+                      137,
+                      [](auto row) { return (row + 3) % 11; },
+                      nullEvery(13)),
+                  makeFlatVector<int32_t>(137, [](auto row) { return row; }),
+              });
+            }),
+        true);
+
+    // Right side keys are [-3, -2, -1, 0, 1, 2, 3].
+    std::vector<RowVectorPtr> buildVectors =
+        makeBatches(3, [&](int32_t /*unused*/) {
+          return makeRowVector({
+              makeFlatVector<int32_t>(
+                  123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
+              makeFlatVector<int32_t>(
+                  123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
+          });
+        });
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
+        .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+        .probeKeys({"c0"})
+        .probeVectors(std::move(probeVectors))
+        .buildKeys({"u_c0"})
+        .buildVectors(std::move(buildVectors))
+        .buildFilter("c0 > 100")
+        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+        .joinType(core::JoinType::kFull)
+        .joinOutputLayout({"c1"})
+        .referenceQuery(
+            "SELECT t.c1 FROM t FULL OUTER JOIN (SELECT * FROM u WHERE c0 > 100) u ON t.c0 = u.c0")
+        .checkSpillStats(false)
+        .run();
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, fullJoinWithNoMatch) {
+  // Left side keys are [0, 1, 2,..10].
+  std::vector<RowVectorPtr> probeVectors = mergeBatches(
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    213, [](auto row) { return row % 11; }, nullEvery(13)),
+                makeFlatVector<int32_t>(213, [](auto row) { return row; }),
+            });
+          }),
+      makeBatches(
+          2,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    137,
+                    [](auto row) { return (row + 3) % 11; },
+                    nullEvery(13)),
+                makeFlatVector<int32_t>(137, [](auto row) { return row; }),
+            });
+          }),
+      true);
+
+  // Right side keys are [-3, -2, -1, 0, 1, 2, 3].
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(3, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
+        });
+      });
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+      .probeKeys({"c0"})
+      .probeVectors(std::move(probeVectors))
+      .buildKeys({"u_c0"})
+      .buildVectors(std::move(buildVectors))
+      .buildFilter("c0 < 0")
+      .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+      .joinType(core::JoinType::kFull)
+      .joinOutputLayout({"c1"})
+      .referenceQuery(
+          "SELECT t.c1 FROM t FULL OUTER JOIN (SELECT * FROM u WHERE c0 < 0) u ON t.c0 = u.c0")
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, fullJoinWithFilters) {
+  // Left side keys are [0, 1, 2,..10].
+  std::vector<RowVectorPtr> probeVectors = mergeBatches(
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    213, [](auto row) { return row % 11; }, nullEvery(13)),
+                makeFlatVector<int32_t>(213, [](auto row) { return row; }),
+            });
+          }),
+      makeBatches(
+          2,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    137,
+                    [](auto row) { return (row + 3) % 11; },
+                    nullEvery(13)),
+                makeFlatVector<int32_t>(137, [](auto row) { return row; }),
+            });
+          }),
+      true);
+
+  // Right side keys are [-3, -2, -1, 0, 1, 2, 3].
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(3, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
+        });
+      });
+
+  // Filter with passed rows.
+  {
+    auto testProbeVectors = probeVectors;
+    auto testBuildVectors = buildVectors;
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+        .probeKeys({"c0"})
+        .probeVectors(std::move(testProbeVectors))
+        .buildKeys({"u_c0"})
+        .buildVectors(std::move(testBuildVectors))
+        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+        .joinType(core::JoinType::kFull)
+        .joinFilter("(c1 + u_c1) % 2 = 1")
+        .joinOutputLayout({"c0", "c1", "u_c1"})
+        .referenceQuery(
+            "SELECT t.c0, t.c1, u.c1 FROM t FULL OUTER JOIN u ON t.c0 = u.c0 AND (t.c1 + u.c1) % 2 = 1")
+        .run();
+  }
+
+  // Filter without passed rows.
+  {
+    auto testProbeVectors = probeVectors;
+    auto testBuildVectors = buildVectors;
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+        .probeKeys({"c0"})
+        .probeVectors(std::move(testProbeVectors))
+        .buildKeys({"u_c0"})
+        .buildVectors(std::move(testBuildVectors))
+        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+        .joinType(core::JoinType::kFull)
+        .joinFilter("(c1 + u_c1) % 2 = 3")
+        .joinOutputLayout({"c0", "c1", "u_c1"})
+        .referenceQuery(
+            "SELECT t.c0, t.c1, u.c1 FROM t FULL OUTER JOIN u ON t.c0 = u.c0 AND (t.c1 + u.c1) % 2 = 3")
+        .run();
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, noSpillLevelLimit) {
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+      .keyTypes({INTEGER()})
+      .probeVectors(1600, 5)
+      .buildVectors(1500, 5)
+      .referenceQuery(
+          "SELECT t_k0, t_data, u_k0, u_data FROM t, u WHERE t.t_k0 = u.u_k0")
+      .maxSpillLevel(-1)
+      .config(core::QueryConfig::kSpillStartPartitionBit, "51")
+      .config(core::QueryConfig::kSpillNumPartitionBits, "3")
+      .checkSpillStats(false)
+      .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+        if (!hasSpill) {
+          return;
+        }
+        ASSERT_EQ(maxHashBuildSpillLevel(*task), 3);
+      })
+      .run();
+}
+
+// Verify that dynamic filter pushed down is turned off for null-aware right
+// semi project join.
+TEST_P(HashJoinTest, nullAwareRightSemiProjectOverScan) {
+  std::vector<RowVectorPtr> probes;
+  std::vector<RowVectorPtr> builds;
+  // Matches present:
+  probes.push_back(makeRowVector(
+      {"t0"},
+      {
+          makeNullableFlatVector<int32_t>({1, std::nullopt, 2}),
+      }));
+  builds.push_back(makeRowVector(
+      {"u0"},
+      {
+          makeNullableFlatVector<int32_t>({1, 2, 3, std::nullopt}),
+      }));
+
+  // No matches present:
+  probes.push_back(makeRowVector(
+      {"t0"},
+      {
+          makeFlatVector<int32_t>({5, 6}),
+      }));
+  builds.push_back(makeRowVector(
+      {"u0"},
+      {
+          makeNullableFlatVector<int32_t>({1, 2, 3, std::nullopt}),
+      }));
+
+  for (int i = 0; i < probes.size(); i++) {
+    RowVectorPtr& probe = probes[i];
+    RowVectorPtr& build = builds[i];
+    std::shared_ptr<TempFilePath> probeFile = TempFilePath::create();
+    writeToFile(probeFile->getPath(), {probe});
+
+    std::shared_ptr<TempFilePath> buildFile = TempFilePath::create();
+    writeToFile(buildFile->getPath(), {build});
+
+    createDuckDbTable("t", {probe});
+    createDuckDbTable("u", {build});
+
+    core::PlanNodeId probeScanId;
+    core::PlanNodeId buildScanId;
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .tableScan(asRowType(probe->type()))
+                    .capturePlanNodeId(probeScanId)
+                    .hashJoin(
+                        {"t0"},
+                        {"u0"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .tableScan(asRowType(build->type()))
+                            .capturePlanNodeId(buildScanId)
+                            .planNode(),
+                        "",
+                        {"u0", "match"},
+                        core::JoinType::kRightSemiProject,
+                        true /*nullAware*/)
+                    .planNode();
+
+    SplitPath splitPaths = {
+        {probeScanId, {probeFile->getPath()}},
+        {buildScanId, {buildFile->getPath()}},
+    };
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(plan)
+        .inputSplits(splitPaths)
+        .checkSpillStats(false)
+        .referenceQuery("SELECT u0, u0 IN (SELECT t0 FROM t) FROM u")
+        .run();
+  }
+}
+
+TEST_P(HashJoinTest, duplicateJoinKeys) {
+  auto leftVectors = makeBatches(3, [&](int32_t /*unused*/) {
+    return makeRowVector({
+        makeNullableFlatVector<int64_t>(
+            {1, 2, 2, 3, 3, std::nullopt, 4, 5, 5, 6, 7}),
+        makeNullableFlatVector<int64_t>(
+            {1, 2, 2, std::nullopt, 3, 3, 4, 5, 5, 6, 8}),
+    });
+  });
+
+  auto rightVectors = makeBatches(3, [&](int32_t /*unused*/) {
+    return makeRowVector({
+        makeNullableFlatVector<int64_t>({1, 1, 3, 4, std::nullopt, 5, 7, 8}),
+        makeNullableFlatVector<int64_t>({1, 1, 3, 4, 5, std::nullopt, 7, 8}),
+    });
+  });
+
+  createDuckDbTable("t", leftVectors);
+  createDuckDbTable("u", rightVectors);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto assertPlan = [&](const std::vector<std::string>& leftProject,
+                        const std::vector<std::string>& leftKeys,
+                        const std::vector<std::string>& rightProject,
+                        const std::vector<std::string>& rightKeys,
+                        const std::vector<std::string>& outputLayout,
+                        core::JoinType joinType,
+                        const std::string& query) {
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(leftVectors)
+                    .project(leftProject)
+                    .hashJoin(
+                        leftKeys,
+                        rightKeys,
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(rightVectors)
+                            .project(rightProject)
+                            .planNode(),
+                        "",
+                        outputLayout,
+                        joinType)
+                    .planNode();
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(plan)
+        .referenceQuery(query)
+        .run();
+  };
+
+  std::vector<std::pair<core::JoinType, std::string>> joins = {
+      {core::JoinType::kInner, "INNER JOIN"},
+      {core::JoinType::kLeft, "LEFT JOIN"},
+      {core::JoinType::kRight, "RIGHT JOIN"},
+      {core::JoinType::kFull, "FULL OUTER JOIN"}};
+
+  for (const auto& [joinType, joinTypeSql] : joins) {
+    // Duplicate keys on the build side.
+    assertPlan(
+        {"c0 AS t0", "c1 as t1"}, // leftProject
+        {"t0", "t1"}, // leftKeys
+        {"c0 AS u0"}, // rightProject
+        {"u0", "u0"}, // rightKeys
+        {"t0", "t1", "u0"}, // outputLayout
+        joinType,
+        "SELECT t.c0, t.c1, u.c0 FROM t " + joinTypeSql +
+            " u ON t.c0 = u.c0 and t.c1 = u.c0");
+  }
+
+  for (const auto& [joinType, joinTypeSql] : joins) {
+    // Duplicated keys on the probe side.
+    assertPlan(
+        {"c0 AS t0"}, // leftProject
+        {"t0", "t0"}, // leftKeys
+        {"c0 AS u0", "c1 AS u1"}, // rightProject
+        {"u0", "u1"}, // rightKeys
+        {"t0", "u0", "u1"}, // outputLayout
+        joinType,
+        "SELECT t.c0, u.c0, u.c1 FROM t " + joinTypeSql +
+            " u ON t.c0 = u.c0 and t.c0 = u.c1");
+  }
+}
+
+TEST_P(HashJoinTest, semiProject) {
+  // Some keys have multiple rows: 2, 3, 5.
+  auto probeVectors = makeBatches(3, [&](int32_t /*unused*/) {
+    return makeRowVector({
+        makeFlatVector<int64_t>({1, 2, 2, 3, 3, 3, 4, 5, 5, 6, 7}),
+        makeFlatVector<int64_t>({10, 20, 21, 30, 31, 32, 40, 50, 51, 60, 70}),
+    });
+  });
+
+  // Some keys are missing: 2, 6.
+  // Some have multiple rows: 1, 5.
+  // Some keys are not present on probe side: 8.
+  auto buildVectors = makeBatches(3, [&](int32_t /*unused*/) {
+    return makeRowVector({
+        makeFlatVector<int64_t>({1, 1, 3, 4, 5, 5, 7, 8}),
+        makeFlatVector<int64_t>({100, 101, 300, 400, 500, 501, 700, 800}),
+    });
+  });
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors)
+                  .project({"c0 AS t0", "c1 AS t1"})
+                  .hashJoin(
+                      {"t0"},
+                      {"u0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors)
+                          .project({"c0 AS u0", "c1 AS u1"})
+                          .planNode(),
+                      "",
+                      {"t0", "t1", "match"},
+                      core::JoinType::kLeftSemiProject)
+                  .planNode();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(plan)
+      .referenceQuery(
+          "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0) FROM t")
+      .run();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(flipJoinSides(plan))
+      .referenceQuery(
+          "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0) FROM t")
+      .run();
+
+  // With extra filter.
+  planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  plan = PlanBuilder(planNodeIdGenerator)
+             .values(probeVectors)
+             .project({"c0 AS t0", "c1 AS t1"})
+             .hashJoin(
+                 {"t0"},
+                 {"u0"},
+                 PlanBuilder(planNodeIdGenerator)
+                     .values(buildVectors)
+                     .project({"c0 AS u0", "c1 AS u1"})
+                     .planNode(),
+                 "t1 * 10 <> u1",
+                 {"t0", "t1", "match"},
+                 core::JoinType::kLeftSemiProject)
+             .planNode();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(plan)
+      .referenceQuery(
+          "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0 AND t.c1 * 10 <> u.c1) FROM t")
+      .run();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(flipJoinSides(plan))
+      .referenceQuery(
+          "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0 AND t.c1 * 10 <> u.c1) FROM t")
+      .run();
+
+  // Empty build side.
+  planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  plan = PlanBuilder(planNodeIdGenerator)
+             .values(probeVectors)
+             .project({"c0 AS t0", "c1 AS t1"})
+             .hashJoin(
+                 {"t0"},
+                 {"u0"},
+                 PlanBuilder(planNodeIdGenerator)
+                     .values(buildVectors)
+                     .project({"c0 AS u0", "c1 AS u1"})
+                     .filter("u0 < 0")
+                     .planNode(),
+                 "",
+                 {"t0", "t1", "match"},
+                 core::JoinType::kLeftSemiProject)
+             .planNode();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(plan)
+      .referenceQuery(
+          "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE u.c0 < 0 AND t.c0 = u.c0) FROM t")
+      // NOTE: there is no spilling in empty build test case as all the
+      // build-side rows have been filtered out.
+      .checkSpillStats(false)
+      .run();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(flipJoinSides(plan))
+      .referenceQuery(
+          "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE u.c0 < 0 AND t.c0 = u.c0) FROM t")
+      // NOTE: there is no spilling in empty build test case as all the
+      // build-side rows have been filtered out.
+      .checkSpillStats(false)
+      .run();
+}
+
+TEST_P(HashJoinTest, semiProjectWithNullKeys) {
+  // Some keys have multiple rows: 2, 3, 5.
+  auto probeVectors = makeBatches(3, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"t0", "t1"},
+        {
+            makeNullableFlatVector<int64_t>(
+                {1, 2, 2, 3, 3, 3, 4, std::nullopt, 5, 5, 6, 7}),
+            makeFlatVector<int64_t>(
+                {10, 20, 21, 30, 31, 32, 40, -1, 50, 51, 60, 70}),
+        });
+  });
+
+  // Some keys are missing: 2, 6.
+  // Some have multiple rows: 1, 5.
+  // Some keys are not present on probe side: 8.
+  auto buildVectors = makeBatches(3, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"u0", "u1"},
+        {
+            makeNullableFlatVector<int64_t>(
+                {1, 1, 3, 4, std::nullopt, 5, 5, 7, 8}),
+            makeFlatVector<int64_t>(
+                {100, 101, 300, 400, -100, 500, 501, 700, 800}),
+        });
+  });
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto makePlan = [&](bool nullAware,
+                      const std::string& probeFilter = "",
+                      const std::string& buildFilter = "") {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    return PlanBuilder(planNodeIdGenerator)
+        .values(probeVectors)
+        .optionalFilter(probeFilter)
+        .hashJoin(
+            {"t0"},
+            {"u0"},
+            PlanBuilder(planNodeIdGenerator)
+                .values(buildVectors)
+                .optionalFilter(buildFilter)
+                .planNode(),
+            "",
+            {"t0", "t1", "match"},
+            core::JoinType::kLeftSemiProject,
+            nullAware)
+        .planNode();
+  };
+
+  // Null join keys on both sides.
+  auto plan = makePlan(false /*nullAware*/);
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(plan)
+      .referenceQuery(
+          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0) FROM t")
+      .run();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(flipJoinSides(plan))
+      .referenceQuery(
+          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0) FROM t")
+      .run();
+
+  plan = makePlan(true /*nullAware*/);
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(plan)
+      .referenceQuery("SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t")
+      .run();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(flipJoinSides(plan))
+      .referenceQuery("SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t")
+      .run();
+
+  // Null join keys on build side-only.
+  plan = makePlan(false /*nullAware*/, "t0 IS NOT NULL");
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(plan)
+      .referenceQuery(
+          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0) FROM t WHERE t0 IS NOT NULL")
+      .run();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(flipJoinSides(plan))
+      .referenceQuery(
+          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0) FROM t WHERE t0 IS NOT NULL")
+      .run();
+
+  plan = makePlan(true /*nullAware*/, "t0 IS NOT NULL");
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(plan)
+      .referenceQuery(
+          "SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t WHERE t0 IS NOT NULL")
+      .run();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(flipJoinSides(plan))
+      .referenceQuery(
+          "SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t WHERE t0 IS NOT NULL")
+      .run();
+
+  // Null join keys on probe side-only.
+  plan = makePlan(false /*nullAware*/, "", "u0 IS NOT NULL");
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(plan)
+      .referenceQuery(
+          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 IS NOT NULL) FROM t")
+      .run();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(flipJoinSides(plan))
+      .referenceQuery(
+          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 IS NOT NULL) FROM t")
+      .run();
+
+  plan = makePlan(true /*nullAware*/, "", "u0 IS NOT NULL");
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(plan)
+      .referenceQuery(
+          "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 IS NOT NULL) FROM t")
+      .run();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(flipJoinSides(plan))
+      .referenceQuery(
+          "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 IS NOT NULL) FROM t")
+      .run();
+
+  // Empty build side.
+  plan = makePlan(false /*nullAware*/, "", "u0 < 0");
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
+      .planNode(plan)
+      .checkSpillStats(false)
+      .referenceQuery(
+          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 < 0) FROM t")
+      .run();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
+      .planNode(flipJoinSides(plan))
+      .checkSpillStats(false)
+      .referenceQuery(
+          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 < 0) FROM t")
+      .run();
+
+  plan = makePlan(true /*nullAware*/, "", "u0 < 0");
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
+      .planNode(plan)
+      .checkSpillStats(false)
+      .referenceQuery(
+          "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 < 0) FROM t")
+      .run();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
+      .planNode(flipJoinSides(plan))
+      .checkSpillStats(false)
+      .referenceQuery(
+          "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 < 0) FROM t")
+      .run();
+
+  // Build side with all rows having null join keys.
+  plan = makePlan(false /*nullAware*/, "", "u0 IS NULL");
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
+      .planNode(plan)
+      .checkSpillStats(false)
+      .referenceQuery(
+          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 IS NULL) FROM t")
+      .run();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
+      .planNode(flipJoinSides(plan))
+      .checkSpillStats(false)
+      .referenceQuery(
+          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 IS NULL) FROM t")
+      .run();
+
+  plan = makePlan(true /*nullAware*/, "", "u0 IS NULL");
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
+      .planNode(plan)
+      .checkSpillStats(false)
+      .referenceQuery(
+          "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 IS NULL) FROM t")
+      .run();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
+      .planNode(flipJoinSides(plan))
+      .checkSpillStats(false)
+      .referenceQuery(
+          "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 IS NULL) FROM t")
+      .run();
+}
+
+TEST_P(HashJoinTest, semiProjectWithFilter) {
+  auto probeVectors = makeBatches(3, [&](auto /*unused*/) {
+    return makeRowVector(
+        {"t0", "t1"},
+        {
+            makeNullableFlatVector<int32_t>({1, 2, 3, std::nullopt, 5}),
+            makeFlatVector<int64_t>({10, 20, 30, 40, 50}),
+        });
+  });
+
+  auto buildVectors = makeBatches(3, [&](auto /*unused*/) {
+    return makeRowVector(
+        {"u0", "u1"},
+        {
+            makeNullableFlatVector<int32_t>({1, 2, 3, std::nullopt}),
+            makeFlatVector<int64_t>({11, 22, 33, 44}),
+        });
+  });
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto makePlan = [&](bool nullAware, const std::string& filter) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    return PlanBuilder(planNodeIdGenerator)
+        .values(probeVectors)
+        .hashJoin(
+            {"t0"},
+            {"u0"},
+            PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode(),
+            filter,
+            {"t0", "t1", "match"},
+            core::JoinType::kLeftSemiProject,
+            nullAware)
+        .planNode();
+  };
+
+  std::vector<std::string> filters = {
+      "t1 <> u1",
+      "t1 < u1",
+      "t1 > u1",
+      "t1 is not null AND u1 is not null",
+      "t1 is null OR u1 is null",
+  };
+  for (const auto& filter : filters) {
+    auto plan = makePlan(true /*nullAware*/, filter);
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(plan)
+        .referenceQuery(
+            fmt::format(
+                "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE {}) FROM t",
+                filter))
+        .injectSpill(false)
+        .run();
+
+    plan = makePlan(false /*nullAware*/, filter);
+
+    // DuckDB Exists operator returns NULL when u0 or t0 is NULL. We exclude
+    // these values.
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(plan)
+        .referenceQuery(
+            fmt::format(
+                "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE (u0 is not null OR t0 is not null) AND u0 = t0 AND {}) FROM t",
+                filter))
+        .injectSpill(false)
+        .run();
+  }
+}
+
+TEST_P(HashJoinTest, nullAwareRightSemiProjectWithFilterNotAllowed) {
+  auto probe = makeRowVector(ROW({"t0", "t1"}, {INTEGER(), BIGINT()}), 10);
+  auto build = makeRowVector(ROW({"u0", "u1"}, {INTEGER(), BIGINT()}), 10);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  VELOX_ASSERT_THROW(
+      PlanBuilder(planNodeIdGenerator)
+          .values({probe})
+          .hashJoin(
+              {"t0"},
+              {"u0"},
+              PlanBuilder(planNodeIdGenerator).values({build}).planNode(),
+              "t1 > u1",
+              {"u0", "u1", "match"},
+              core::JoinType::kRightSemiProject,
+              true /* nullAware */),
+      "Null-aware right semi project join doesn't support extra filter");
+}
+
+TEST_P(HashJoinTest, leftSemiJoinWithExtraOutputCapacity) {
+  std::vector<RowVectorPtr> probeVectors;
+  std::vector<RowVectorPtr> buildVectors;
+  probeVectors.push_back(makeRowVector(
+      {"t0", "t1"},
+      {
+          makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6}),
+          makeFlatVector<int64_t>({10, 10, 10, 10, 10, 10}),
+      }));
+
+  buildVectors.push_back(makeRowVector(
+      {"u0", "u1"},
+      {
+          makeFlatVector<int32_t>({1, 1, 1, 1, 1}),
+          makeFlatVector<int64_t>({10, 10, 10, 10, 10}),
+      }));
+  buildVectors.push_back(makeRowVector(
+      {"u0", "u1"},
+      {
+          makeFlatVector<int32_t>({2, 3, 4, 5, 6}),
+          makeFlatVector<int64_t>({10, 10, 10, 10, 10}),
+      }));
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+  auto runQuery = [&](const std::string& query,
+                      const std::string& filter,
+                      core::JoinType joinType) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    std::vector<std::string> outputLayout = {"t0", "t1"};
+    if (joinType == core::JoinType::kLeftSemiProject) {
+      outputLayout.push_back("match");
+    }
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(probeVectors)
+                    .hashJoin(
+                        {"t0"},
+                        {"u0"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildVectors)
+                            .planNode(),
+                        filter,
+                        outputLayout,
+                        joinType,
+                        false)
+                    .planNode();
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(plan)
+        .config(core::QueryConfig::kPreferredOutputBatchRows, "5")
+        .referenceQuery(query)
+        .injectSpill(false)
+        .run();
+  };
+  {
+    SCOPED_TRACE("left semi filter join");
+    std::string filter = "t1 = u1";
+    runQuery(
+        fmt::format(
+            "SELECT t0, t1 FROM t WHERE EXISTS (SELECT u0 FROM u WHERE t0 = u0 AND {})",
+            filter),
+        filter,
+        core::JoinType::kLeftSemiFilter);
+  }
+
+  {
+    SCOPED_TRACE("left semi project join");
+    std::string filter = "t1 <> u1";
+    runQuery(
+        fmt::format(
+            "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE {}) FROM t", filter),
+        filter,
+        core::JoinType::kLeftSemiProject);
+  }
+}
+
+TEST_P(HashJoinTest, nullAwareMultiKeyNotAllowed) {
+  auto probe = makeRowVector(
+      ROW({"t0", "t1", "t2"}, {INTEGER(), BIGINT(), VARCHAR()}), 10);
+  auto build = makeRowVector(
+      ROW({"u0", "u1", "u2"}, {INTEGER(), BIGINT(), VARCHAR()}), 10);
+
+  // Null-aware left semi project join.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  VELOX_ASSERT_THROW(
+      PlanBuilder(planNodeIdGenerator)
+          .values({probe})
+          .hashJoin(
+              {"t0", "t1"},
+              {"u0", "u1"},
+              PlanBuilder(planNodeIdGenerator).values({build}).planNode(),
+              "",
+              {"t0", "t1", "match"},
+              core::JoinType::kLeftSemiProject,
+              true /* nullAware */),
+      "Null-aware joins allow only one join key");
+
+  // Null-aware right semi project join.
+  VELOX_ASSERT_THROW(
+      PlanBuilder(planNodeIdGenerator)
+          .values({probe})
+          .hashJoin(
+              {"t0", "t1"},
+              {"u0", "u1"},
+              PlanBuilder(planNodeIdGenerator).values({build}).planNode(),
+              "",
+              {"u0", "u1", "match"},
+              core::JoinType::kRightSemiProject,
+              true /* nullAware */),
+      "Null-aware joins allow only one join key");
+
+  // Null-aware anti join.
+  VELOX_ASSERT_THROW(
+      PlanBuilder(planNodeIdGenerator)
+          .values({probe})
+          .hashJoin(
+              {"t0", "t1"},
+              {"u0", "u1"},
+              PlanBuilder(planNodeIdGenerator).values({build}).planNode(),
+              "",
+              {"t0", "t1"},
+              core::JoinType::kAnti,
+              true /* nullAware */),
+      "Null-aware joins allow only one join key");
+}
+
+TEST_P(HashJoinTest, semiProjectOverLazyVectors) {
+  auto probeVectors = makeBatches(1, [&](auto /*unused*/) {
+    return makeRowVector(
+        {"t0", "t1"},
+        {
+            makeFlatVector<int32_t>(1'000, [](auto row) { return row; }),
+            makeFlatVector<int64_t>(1'000, [](auto row) { return row * 10; }),
+        });
+  });
+
+  auto buildVectors = makeBatches(3, [&](auto /*unused*/) {
+    return makeRowVector(
+        {"u0", "u1"},
+        {
+            makeFlatVector<int32_t>(
+                1'000, [](auto row) { return -100 + (row / 5); }),
+            makeFlatVector<int64_t>(
+                1'000, [](auto row) { return -1000 + (row / 5) * 10; }),
+        });
+  });
+
+  std::shared_ptr<TempFilePath> probeFile = TempFilePath::create();
+  writeToFile(probeFile->getPath(), probeVectors);
+
+  std::shared_ptr<TempFilePath> buildFile = TempFilePath::create();
+  writeToFile(buildFile->getPath(), buildVectors);
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  core::PlanNodeId probeScanId;
+  core::PlanNodeId buildScanId;
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .tableScan(asRowType(probeVectors[0]->type()))
+                  .capturePlanNodeId(probeScanId)
+                  .hashJoin(
+                      {"t0"},
+                      {"u0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .tableScan(asRowType(buildVectors[0]->type()))
+                          .capturePlanNodeId(buildScanId)
+                          .planNode(),
+                      "",
+                      {"t0", "t1", "match"},
+                      core::JoinType::kLeftSemiProject)
+                  .planNode();
+
+  SplitPath splitPaths = {
+      {probeScanId, {probeFile->getPath()}},
+      {buildScanId, {buildFile->getPath()}},
+  };
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(plan)
+      .inputSplits(splitPaths)
+      .checkSpillStats(false)
+      .referenceQuery("SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t")
+      .run();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(flipJoinSides(plan))
+      .inputSplits(splitPaths)
+      .checkSpillStats(false)
+      .referenceQuery("SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t")
+      .run();
+
+  // With extra filter.
+  planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  plan = PlanBuilder(planNodeIdGenerator)
+             .tableScan(asRowType(probeVectors[0]->type()))
+             .capturePlanNodeId(probeScanId)
+             .hashJoin(
+                 {"t0"},
+                 {"u0"},
+                 PlanBuilder(planNodeIdGenerator)
+                     .tableScan(asRowType(buildVectors[0]->type()))
+                     .capturePlanNodeId(buildScanId)
+                     .planNode(),
+                 "(t1 + u1) % 3 = 0",
+                 {"t0", "t1", "match"},
+                 core::JoinType::kLeftSemiProject)
+             .planNode();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(plan)
+      .inputSplits(splitPaths)
+      .checkSpillStats(false)
+      .referenceQuery(
+          "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE (t1 + u1) % 3 = 0) FROM t")
+      .run();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(flipJoinSides(plan))
+      .inputSplits(splitPaths)
+      .checkSpillStats(false)
+      .referenceQuery(
+          "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE (t1 + u1) % 3 = 0) FROM t")
+      .run();
+}
+
+// Verifies that hash join with lazy probe input produces correct results
+// across multiple join types, with automatic spill injection via
+// HashJoinBuilder.
+TEST_P(MultiThreadedHashJoinTest, hashJoinWithLazyProbeInputAndSpill) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 1'000;
+  VectorFuzzer fuzzer(opts, pool());
+
+  const int32_t numProbeVectors = 3;
+  std::vector<RowVectorPtr> probeVectors;
+  std::vector<RowVectorPtr> probeReference;
+  probeVectors.reserve(numProbeVectors);
+  probeReference.reserve(numProbeVectors);
+  for (int32_t i = 0; i < numProbeVectors; ++i) {
+    auto nonLazy = fuzzer.fuzzRow(probeType_);
+    probeReference.push_back(
+        std::dynamic_pointer_cast<RowVector>(
+            nonLazy->testingCopyPreserveEncodings()));
+    probeVectors.push_back(
+        VectorFuzzer(opts, pool()).fuzzRowChildrenToLazy(nonLazy));
+  }
+  createDuckDbTable("t", probeReference);
+
+  const int32_t numBuildVectors = 3;
+  std::vector<RowVectorPtr> buildVectors;
+  buildVectors.reserve(numBuildVectors);
+  for (int32_t i = 0; i < numBuildVectors; ++i) {
+    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
+  }
+  createDuckDbTable("u", buildVectors);
+
+  struct {
+    core::JoinType joinType;
+    std::string filter;
+    std::vector<std::string> outputColumns;
+    std::string referenceQuery;
+  } testCases[] = {
+      {core::JoinType::kInner,
+       "",
+       concat(probeType_->names(), buildType_->names()),
+       "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1"},
+      {core::JoinType::kLeft,
+       "",
+       concat(probeType_->names(), buildType_->names()),
+       "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t LEFT JOIN u ON t.t_k1 = u.u_k1"},
+      {core::JoinType::kFull,
+       "",
+       concat(probeType_->names(), buildType_->names()),
+       "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t FULL OUTER JOIN u ON t.t_k1 = u.u_k1"},
+      {core::JoinType::kAnti,
+       "t_k2 <> u_k2",
+       probeType_->names(),
+       "SELECT t_k1, t_k2, t_v1 FROM t WHERE NOT EXISTS (SELECT 1 FROM u WHERE t.t_k1 = u.u_k1 AND t.t_k2 <> u.u_k2)"},
+      {core::JoinType::kLeftSemiProject,
+       "",
+       concat(probeType_->names(), {"match"}),
+       "SELECT t_k1, t_k2, t_v1, EXISTS (SELECT 1 FROM u WHERE t.t_k1 = u.u_k1) FROM t"},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(
+        fmt::format("joinType: {}", static_cast<int>(testCase.joinType)));
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
+        .probeKeys({"t_k1"})
+        .probeVectors(std::vector<RowVectorPtr>(probeVectors))
+        .buildKeys({"u_k1"})
+        .buildVectors(std::vector<RowVectorPtr>(buildVectors))
+        .joinType(testCase.joinType)
+        .joinFilter(testCase.filter)
+        .joinOutputLayout(std::vector<std::string>(testCase.outputColumns))
+        .referenceQuery(testCase.referenceQuery)
+        .run();
+  }
+}
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    MultiThreadedHashJoinTest,
+    MultiThreadedHashJoinTest,
+    testing::ValuesIn(MultiThreadedHashJoinTest::getTestParams()),
+    [](const testing::TestParamInfo<TestParam>& info) {
+      return TestParamToName(info.param);
+    });
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    HashJoinTest,
+    HashJoinTest,
+    testing::ValuesIn(HashJoinTest::getTestParams()),
+    [](const testing::TestParamInfo<TestParam>& info) {
+      return TestParamToName(info.param);
+    });
+
+// Test that hash join spill uses the hash_join_spill_file_create_config when
+// set, and other spillable operators use the default spill_file_create_config.
+DEBUG_ONLY_TEST_P(HashJoinTest, hashJoinSpillFileCreateConfig) {
+  const auto rowType =
+      ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), VARCHAR()});
+  const auto probeVectors = createVectors(rowType, 128, 10);
+  const auto buildVectors = createVectors(rowType, 128, 10);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  // Build a plan with hash join and orderBy. Hash join operators should use
+  // hash_join_spill_file_create_config and orderBy should use the default
+  // spill_file_create_config.
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors, true)
+                  .hashJoin(
+                      {"c0"},
+                      {"u0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors, true)
+                          .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
+                          .planNode(),
+                      "",
+                      {"c0", "c1", "c2"},
+                      core::JoinType::kInner)
+                  .orderBy({"c0 ASC NULLS LAST"}, false)
+                  .planNode();
+
+  auto spillDirectory = TempDirectoryPath::create();
+
+  std::atomic_bool hashJoinConfigVerified{false};
+  std::atomic_bool defaultConfigVerified{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::isBlocked",
+      std::function<void(exec::Operator*)>([&](exec::Operator* op) {
+        const auto* spillConfig = op->testingSpillConfig();
+        if (spillConfig == nullptr) {
+          return;
+        }
+        const auto& opType = op->operatorType();
+        if (opType == "HashBuild" || opType == "HashProbe") {
+          // Hash join operators should use hash_join_spill_file_create_config.
+          ASSERT_EQ(spillConfig->fileCreateConfig, "test_hashjoin_config")
+              << "Operator: " << opType;
+          hashJoinConfigVerified = true;
+        } else {
+          // Other spillable operators (e.g., OrderBy) should use the default
+          // spill_file_create_config.
+          ASSERT_EQ(spillConfig->fileCreateConfig, "test_default_config")
+              << "Operator: " << opType;
+          defaultConfigVerified = true;
+        }
+      }));
+
+  TestScopedSpillInjection scopedSpillInjection(100);
+  AssertQueryBuilder(plan)
+      .spillDirectory(spillDirectory->getPath())
+      .config(core::QueryConfig::kSpillEnabled, true)
+      .config(core::QueryConfig::kJoinSpillEnabled, true)
+      .config(core::QueryConfig::kOrderBySpillEnabled, true)
+      .config(core::QueryConfig::kSpillFileCreateConfig, "test_default_config")
+      .config(
+          core::QueryConfig::kHashJoinSpillFileCreateConfig,
+          "test_hashjoin_config")
+      .copyResults(pool_.get());
+
+  ASSERT_TRUE(hashJoinConfigVerified.load());
+  ASSERT_TRUE(defaultConfigVerified.load());
+}
+
+} // namespace
+} // namespace facebook::velox::exec
diff --git a/velox/exec/tests/HashJoinWithCacheTest.cpp b/velox/exec/tests/HashJoinWithCacheTest.cpp
new file mode 100644
index 00000000000..07b7ab8ef0c
--- /dev/null
+++ b/velox/exec/tests/HashJoinWithCacheTest.cpp
@@ -0,0 +1,827 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include <thread>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/memory/MemoryArbitrator.h"
+#include "velox/common/testutil/TestValue.h"
+#include "velox/exec/Cursor.h"
+#include "velox/exec/HashBuild.h"
+#include "velox/exec/HashJoinBridge.h"
+#include "velox/exec/HashProbe.h"
+#include "velox/exec/HashTable.h"
+#include "velox/exec/HashTableCache.h"
+#include "velox/exec/MemoryReclaimer.h"
+#include "velox/exec/PlanNodeStats.h"
+
+#include "velox/exec/tests/utils/ArbitratorTestUtil.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/QueryAssertions.h"
+
+#include "velox/exec/tests/utils/VectorTestUtil.h"
+
+namespace facebook::velox::exec::test {
+namespace {
+
+// Test fixture for hash join with hash table caching tests.
+class HashJoinWithCacheTest : public HiveConnectorTestBase {};
+
+// Tests hash table caching for broadcast joins.
+// First task builds the table (cache miss), second task reuses it (cache hit).
+TEST_F(HashJoinWithCacheTest, sequential) {
+  // Use a unique query ID for this test to ensure clean cache state.
+  const std::string queryId =
+      "hashTableCachingTest_" +
+      std::to_string(
+          std::chrono::steady_clock::now().time_since_epoch().count());
+
+  // Create probe and build vectors with distinct column names.
+  std::vector<RowVectorPtr> probeVectors = makeBatches(10, [&](int32_t) {
+    return makeRowVector(
+        {"t_k", "t_v"},
+        {
+            makeFlatVector<int32_t>(100, [](auto row) { return row % 23; }),
+            makeFlatVector<int64_t>(100, [](auto row) { return row; }),
+        });
+  });
+
+  std::vector<RowVectorPtr> buildVectors = makeBatches(5, [&](int32_t) {
+    return makeRowVector(
+        {"u_k", "u_v"},
+        {
+            makeFlatVector<int32_t>(50, [](auto row) { return row % 31; }),
+            makeFlatVector<int64_t>(50, [](auto row) { return row * 10; }),
+        });
+  });
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  // Build the plan using HashJoinNode::Builder to set useHashTableCache.
+  auto buildPlanNode =
+      PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode();
+
+  auto probePlanNode =
+      PlanBuilder(planNodeIdGenerator).values(probeVectors).planNode();
+
+  // Create HashJoinNode with useHashTableCache = true.
+  auto outputType = ROW(
+      {"t_k", "t_v", "u_k", "u_v"}, {INTEGER(), BIGINT(), INTEGER(), BIGINT()});
+
+  auto joinNode =
+      core::HashJoinNode::Builder()
+          .id(planNodeIdGenerator->next())
+          .joinType(core::JoinType::kInner)
+          .nullAware(false)
+          .leftKeys(
+              {std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "t_k")})
+          .rightKeys(
+              {std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "u_k")})
+          .left(probePlanNode)
+          .right(buildPlanNode)
+          .outputType(outputType)
+          .useHashTableCache(true)
+          .build();
+  const auto joinNodeId = joinNode->id();
+
+  const int numDrivers = 3;
+
+  // Create a shared QueryCtx for all tasks.
+  auto queryCtx = core::QueryCtx::create(
+      driverExecutor_.get(),
+      core::QueryConfig({}),
+      std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
+      cache::AsyncDataCache::getInstance(),
+      nullptr,
+      nullptr,
+      queryId);
+
+  // Helper to run a task and return the completed task.
+  // Both tasks use the same queryCtx so they share the cache entry.
+  auto runTask = [&]() {
+    return AssertQueryBuilder(joinNode, duckDbQueryRunner_)
+        .queryCtx(queryCtx)
+        .maxDrivers(numDrivers)
+        .assertResults(
+            "SELECT t.t_k, t.t_v, u.u_k, u.u_v FROM t, u WHERE t.t_k = u.u_k");
+  };
+
+  // First task - should build the table (cache miss).
+  auto task1 = runTask();
+
+  // Get stats from first task - expect cache miss.
+  auto opStats1 = toOperatorStats(task1->taskStats());
+  ASSERT_EQ(opStats1.count("HashBuild"), 1);
+  auto& hashBuildStats1 = opStats1.at("HashBuild");
+
+  // The last driver that finishes building reports the cache miss stat.
+  ASSERT_EQ(
+      hashBuildStats1.runtimeStats.count(
+          std::string(BaseHashTable::kHashTableCacheMiss)),
+      1)
+      << "First task should report cache miss";
+  EXPECT_EQ(
+      hashBuildStats1.runtimeStats
+          .at(std::string(BaseHashTable::kHashTableCacheMiss))
+          .count,
+      1)
+      << "Exactly one driver should report cache miss (the one that builds)";
+  EXPECT_EQ(
+      hashBuildStats1.runtimeStats.count(
+          std::string(BaseHashTable::kHashTableCacheHit)),
+      0)
+      << "First task should not have any cache hits";
+
+  // Second task - should reuse the cached table (cache hit).
+  auto task2 = runTask();
+
+  // Get stats from second task - expect cache hit.
+  auto opStats2 = toOperatorStats(task2->taskStats());
+  ASSERT_EQ(opStats2.count("HashBuild"), 1);
+  auto& hashBuildStats2 = opStats2.at("HashBuild");
+
+  // The last driver that finishes reports the cache hit stat.
+  ASSERT_EQ(
+      hashBuildStats2.runtimeStats.count(
+          std::string(BaseHashTable::kHashTableCacheHit)),
+      1)
+      << "Second task should report cache hit";
+  EXPECT_EQ(
+      hashBuildStats2.runtimeStats
+          .at(std::string(BaseHashTable::kHashTableCacheHit))
+          .count,
+      1)
+      << "Exactly one driver should report cache hit (the one after barrier)";
+  EXPECT_EQ(
+      hashBuildStats2.runtimeStats.count(
+          std::string(BaseHashTable::kHashTableCacheMiss)),
+      0)
+      << "Second task should not have any cache misses";
+
+  // Clean up cache entry before tasks are destroyed.
+  // The release callback on QueryCtx fires too late (after Task destruction
+  // starts), so we need explicit cleanup in tests.
+  const auto cacheKey = fmt::format("{}:{}", queryId, joinNodeId);
+  HashTableCache::instance()->drop(cacheKey);
+}
+
+// Tests that multiple tasks running concurrently share the cached hash table.
+// One task builds the table (cache miss), all others wait and reuse it
+// (cache hits).
+TEST_F(HashJoinWithCacheTest, concurrent) {
+  // Use a unique query ID for this test to ensure clean cache state.
+  const std::string queryId =
+      "hashTableCachingConcurrentTest_" +
+      std::to_string(
+          std::chrono::steady_clock::now().time_since_epoch().count());
+
+  // Create probe and build vectors with distinct column names.
+  std::vector<RowVectorPtr> probeVectors = makeBatches(10, [&](int32_t) {
+    return makeRowVector(
+        {"t_k", "t_v"},
+        {
+            makeFlatVector<int32_t>(100, [](auto row) { return row % 23; }),
+            makeFlatVector<int64_t>(100, [](auto row) { return row; }),
+        });
+  });
+
+  std::vector<RowVectorPtr> buildVectors = makeBatches(5, [&](int32_t) {
+    return makeRowVector(
+        {"u_k", "u_v"},
+        {
+            makeFlatVector<int32_t>(50, [](auto row) { return row % 31; }),
+            makeFlatVector<int64_t>(50, [](auto row) { return row * 10; }),
+        });
+  });
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  // Build the plan using HashJoinNode::Builder to set useHashTableCache.
+  auto buildPlanNode =
+      PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode();
+
+  auto probePlanNode =
+      PlanBuilder(planNodeIdGenerator).values(probeVectors).planNode();
+
+  // Create HashJoinNode with useHashTableCache = true.
+  auto outputType = ROW(
+      {"t_k", "t_v", "u_k", "u_v"}, {INTEGER(), BIGINT(), INTEGER(), BIGINT()});
+
+  auto joinNode =
+      core::HashJoinNode::Builder()
+          .id(planNodeIdGenerator->next())
+          .joinType(core::JoinType::kInner)
+          .nullAware(false)
+          .leftKeys(
+              {std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "t_k")})
+          .rightKeys(
+              {std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "u_k")})
+          .left(probePlanNode)
+          .right(buildPlanNode)
+          .outputType(outputType)
+          .useHashTableCache(true)
+          .build();
+  const auto joinNodeId = joinNode->id();
+
+  const int numDrivers = 3;
+
+  // Create a shared QueryCtx for all tasks.
+  auto queryCtx = core::QueryCtx::create(
+      driverExecutor_.get(),
+      core::QueryConfig({}),
+      std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
+      cache::AsyncDataCache::getInstance(),
+      nullptr,
+      nullptr,
+      queryId);
+
+  // Helper to run a task and return the completed task.
+  // All tasks use the same queryCtx so they share the cache entry.
+  auto runTask = [&]() {
+    return AssertQueryBuilder(joinNode, duckDbQueryRunner_)
+        .queryCtx(queryCtx)
+        .maxDrivers(numDrivers)
+        .assertResults(
+            "SELECT t.t_k, t.t_v, u.u_k, u.u_v FROM t, u WHERE t.t_k = u.u_k");
+  };
+
+  // Run 10 threads concurrently, each executing 5 tasks sequentially.
+  constexpr int kNumThreads = 10;
+  constexpr int kTasksPerThread = 5;
+  constexpr int kTotalTasks = kNumThreads * kTasksPerThread;
+
+  // Each thread maintains its own local vector of tasks.
+  std::vector<std::vector<std::shared_ptr<Task>>> threadTasks(kNumThreads);
+  std::vector<std::thread> threads;
+  threads.reserve(kNumThreads);
+
+  // Launch all threads at once.
+  for (int i = 0; i < kNumThreads; ++i) {
+    threads.emplace_back([&, i]() {
+      // Each thread runs multiple tasks sequentially into its local vector.
+      threadTasks[i].reserve(kTasksPerThread);
+      for (int j = 0; j < kTasksPerThread; ++j) {
+        threadTasks[i].push_back(runTask());
+      }
+    });
+  }
+
+  // Wait for all threads to complete.
+  for (auto& thread : threads) {
+    thread.join();
+  }
+
+  // Merge all thread-local task vectors into a single vector.
+  std::vector<std::shared_ptr<Task>> allTasks;
+  allTasks.reserve(kTotalTasks);
+  for (auto& tasks : threadTasks) {
+    for (auto& task : tasks) {
+      allTasks.push_back(std::move(task));
+    }
+  }
+
+  ASSERT_EQ(allTasks.size(), kTotalTasks);
+
+  // Collect stats from all tasks.
+  int totalCacheMisses = 0;
+  int totalCacheHits = 0;
+
+  for (const auto& task : allTasks) {
+    auto opStats = toOperatorStats(task->taskStats());
+    ASSERT_EQ(opStats.count("HashBuild"), 1);
+    auto& hashBuildStats = opStats.at("HashBuild");
+
+    if (hashBuildStats.runtimeStats.count(
+            std::string(BaseHashTable::kHashTableCacheMiss))) {
+      totalCacheMisses +=
+          hashBuildStats.runtimeStats
+              .at(std::string(BaseHashTable::kHashTableCacheMiss))
+              .count;
+    }
+    if (hashBuildStats.runtimeStats.count(
+            std::string(BaseHashTable::kHashTableCacheHit))) {
+      totalCacheHits += hashBuildStats.runtimeStats
+                            .at(std::string(BaseHashTable::kHashTableCacheHit))
+                            .count;
+    }
+  }
+
+  // Exactly one task should build (cache miss) and all others should reuse
+  // (cache hits).
+  EXPECT_EQ(totalCacheMisses, 1)
+      << "Exactly one task should report a cache miss (the builder)";
+  EXPECT_EQ(totalCacheHits, kTotalTasks - 1)
+      << "All other tasks should report cache hits";
+
+  // Clean up cache entry before tasks are destroyed.
+  const auto cacheKey = fmt::format("{}:{}", queryId, joinNodeId);
+  HashTableCache::instance()->drop(cacheKey);
+}
+
+// Tests that HashBuild and HashProbe cannot reclaim when using a cached hash
+// table. When useHashTableCache() is true, canReclaim() returns false for both
+// operators because spilling would clear the cached table and corrupt it for
+// other tasks. This test uses TestValue to verify canReclaim() returns false.
+DEBUG_ONLY_TEST_F(HashJoinWithCacheTest, probeCannotSpillWithCachedTable) {
+  const std::string queryId =
+      "probeCannotSpillTest_" +
+      std::to_string(
+          std::chrono::steady_clock::now().time_since_epoch().count());
+
+  // Create build and probe vectors.
+  std::vector<RowVectorPtr> buildVectors = makeBatches(1, [&](int32_t) {
+    return makeRowVector(
+        {"u_k", "u_v"},
+        {
+            makeFlatVector<int32_t>(100, [](auto row) { return row % 23; }),
+            makeFlatVector<int64_t>(100, [](auto row) { return row * 10; }),
+        });
+  });
+
+  std::vector<RowVectorPtr> probeVectors = makeBatches(5, [&](int32_t) {
+    return makeRowVector(
+        {"t_k", "t_v"},
+        {
+            makeFlatVector<int32_t>(100, [](auto row) { return row % 23; }),
+            makeFlatVector<int64_t>(100, [](auto row) { return row; }),
+        });
+  });
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto buildPlanNode =
+      PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode();
+  auto probePlanNode =
+      PlanBuilder(planNodeIdGenerator).values(probeVectors).planNode();
+
+  auto outputType = ROW(
+      {"t_k", "t_v", "u_k", "u_v"}, {INTEGER(), BIGINT(), INTEGER(), BIGINT()});
+
+  auto joinNode =
+      core::HashJoinNode::Builder()
+          .id(planNodeIdGenerator->next())
+          .joinType(core::JoinType::kInner)
+          .nullAware(false)
+          .leftKeys(
+              {std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "t_k")})
+          .rightKeys(
+              {std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "u_k")})
+          .left(probePlanNode)
+          .right(buildPlanNode)
+          .outputType(outputType)
+          .useHashTableCache(true)
+          .build();
+  const auto joinNodeId = joinNode->id();
+
+  auto queryCtx = core::QueryCtx::create(
+      driverExecutor_.get(),
+      core::QueryConfig({}),
+      std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
+      cache::AsyncDataCache::getInstance(),
+      nullptr,
+      nullptr,
+      queryId);
+
+  // Use TestValue to verify canReclaim() returns false for HashBuild.
+  std::atomic_bool hashBuildChecked{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashBuild::addInput",
+      std::function<void(HashBuild*)>([&](HashBuild* build) {
+        if (hashBuildChecked.exchange(true)) {
+          return;
+        }
+        ASSERT_FALSE(build->canReclaim())
+            << "HashBuild should not be reclaimable with cached hash table";
+      }));
+
+  // Use TestValue to verify canReclaim() returns false for HashProbe.
+  std::atomic_bool hashProbeChecked{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::addInput",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (!isHashProbeMemoryPool(*op->pool())) {
+          return;
+        }
+        if (hashProbeChecked.exchange(true)) {
+          return;
+        }
+        auto* probe = dynamic_cast<HashProbe*>(op);
+        ASSERT_NE(probe, nullptr);
+        ASSERT_FALSE(probe->canReclaim())
+            << "HashProbe should not be reclaimable with cached hash table";
+      }));
+
+  // Run the query and verify results.
+  auto task =
+      AssertQueryBuilder(joinNode, duckDbQueryRunner_)
+          .queryCtx(queryCtx)
+          .maxDrivers(1)
+          .assertResults(
+              "SELECT t.t_k, t.t_v, u.u_k, u.u_v FROM t, u WHERE t.t_k = u.u_k");
+
+  // Verify that both operators were checked.
+  ASSERT_TRUE(hashBuildChecked) << "HashBuild canReclaim check was not reached";
+  ASSERT_TRUE(hashProbeChecked) << "HashProbe canReclaim check was not reached";
+
+  // Verify that HashProbe operator stats show no spilling.
+  auto opStats = toOperatorStats(task->taskStats());
+  ASSERT_EQ(opStats.count("HashProbe"), 1);
+  auto& probeStats = opStats.at("HashProbe");
+
+  EXPECT_EQ(probeStats.spilledInputBytes, 0)
+      << "HashProbe should not spill when using cached hash table";
+  EXPECT_EQ(probeStats.spilledBytes, 0)
+      << "HashProbe should not spill when using cached hash table";
+
+  // Clean up cache entry before task is destroyed.
+  const auto cacheKey = fmt::format("{}:{}", queryId, joinNodeId);
+  HashTableCache::instance()->drop(cacheKey);
+}
+
+// Tests OOM behavior with cached hash tables via memory arbitration.
+// This test triggers memory arbitration during HashProbe to verify:
+// 1. HashProbe::canReclaim() returns false when useHashTableCache=true
+// 2. When an allocation exceeds capacity, arbitration runs but can't reclaim
+// 3. OOM is thrown by the arbitration framework
+// 4. Cleanup works correctly via QueryCtx release callbacks
+DEBUG_ONLY_TEST_F(HashJoinWithCacheTest, probeOOMWithCachedTable) {
+  const std::string queryId =
+      "probeOOMTest_" +
+      std::to_string(
+          std::chrono::steady_clock::now().time_since_epoch().count());
+
+  // Create build side with ~1MB hash table.
+  // 10 batches × 10,000 rows = 100,000 rows × 12 bytes = ~1.2MB raw data.
+  std::vector<RowVectorPtr> buildVectors = makeBatches(10, [&](int32_t) {
+    return makeRowVector(
+        {"u_k", "u_v"},
+        {
+            makeFlatVector<int32_t>(10000, [](auto row) { return row % 5000; }),
+            makeFlatVector<int64_t>(10000, [](auto row) { return row * 10; }),
+        });
+  });
+
+  // Create probe vectors with matching key range.
+  std::vector<RowVectorPtr> probeVectors = makeBatches(10, [&](int32_t) {
+    return makeRowVector(
+        {"t_k", "t_v"},
+        {
+            makeFlatVector<int32_t>(1000, [](auto row) { return row % 5000; }),
+            makeFlatVector<int64_t>(1000, [](auto row) { return row; }),
+        });
+  });
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto buildPlanNode =
+      PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode();
+  auto probePlanNode =
+      PlanBuilder(planNodeIdGenerator).values(probeVectors).planNode();
+
+  auto outputType = ROW(
+      {"t_k", "t_v", "u_k", "u_v"}, {INTEGER(), BIGINT(), INTEGER(), BIGINT()});
+
+  auto joinNode =
+      core::HashJoinNode::Builder()
+          .id(planNodeIdGenerator->next())
+          .joinType(core::JoinType::kInner)
+          .nullAware(false)
+          .leftKeys(
+              {std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "t_k")})
+          .rightKeys(
+              {std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "u_k")})
+          .left(probePlanNode)
+          .right(buildPlanNode)
+          .outputType(outputType)
+          .useHashTableCache(true)
+          .build();
+
+  // Create QueryCtx with sufficient memory for build but we'll exhaust it
+  // during probe via TestValue injection.
+  auto queryCtx = core::QueryCtx::create(
+      driverExecutor_.get(),
+      core::QueryConfig({}),
+      std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
+      cache::AsyncDataCache::getInstance(),
+      nullptr,
+      nullptr,
+      queryId);
+
+  // Use a pool with limited capacity. Build uses ~10MB, so 20MB should be
+  // enough for build but tight for additional allocations during probe.
+  constexpr int64_t kPoolCapacity = 20 * 1024 * 1024; // 20MB
+  queryCtx->testingOverrideMemoryPool(
+      memory::memoryManager()->addRootPool(
+          queryCtx->queryId(), kPoolCapacity, exec::MemoryReclaimer::create()));
+
+  // Use TestValue at the addInput injection point to trigger OOM during
+  // HashProbe. We allocate more memory than the pool has available, which
+  // triggers arbitration. Since HashProbe::canReclaim() returns false when
+  // useHashTableCache=true, arbitration cannot reclaim and OOM is thrown.
+  std::atomic_bool injected{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::addInput",
+      std::function<void(Operator*)>([&](Operator* op) {
+        // Only inject once, and only for HashProbe operator.
+        if (!isHashProbeMemoryPool(*op->pool())) {
+          return;
+        }
+        if (injected.exchange(true)) {
+          return;
+        }
+
+        auto* probe = dynamic_cast<HashProbe*>(op);
+        ASSERT_NE(probe, nullptr);
+
+        // Verify that HashProbe cannot reclaim when using cached hash table.
+        // canReclaim() returns false because canSpill() is false.
+        ASSERT_FALSE(probe->canReclaim())
+            << "HashProbe should not be reclaimable with cached hash table";
+
+        // Allocate memory equal to pool capacity.
+        // If HashProbe could spill, arbitration would reclaim memory and this
+        // allocation would succeed. But since canReclaim() returns false with
+        // cached hash table, arbitration can't free memory and OOM is thrown.
+        auto* pool = op->pool();
+        // This allocation will trigger arbitration and throw OOM.
+        pool->allocate(kPoolCapacity);
+      }));
+
+  // This should throw OOM during probe. The cleanup should work correctly.
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(joinNode, duckDbQueryRunner_)
+          .queryCtx(queryCtx)
+          .maxDrivers(1)
+          .copyResults(pool()),
+      "Exceeded memory pool capacity");
+
+  waitForAllTasksToBeDeleted();
+  queryCtx.reset();
+  // Cache should be cleaned up by QueryCtx destructor via release callback.
+}
+
+// Verifies that the hash table cache pool has a memory reclaimer that properly
+// suspends the driver thread during memory arbitration. Without a reclaimer,
+// allocations from the cache pool on a driver thread cause:
+// "Driver thread is not suspended under memory arbitration processing".
+DEBUG_ONLY_TEST_F(HashJoinWithCacheTest, cachePoolArbitration) {
+  const std::string queryId =
+      "cachePoolArbitrationTest_" +
+      std::to_string(
+          std::chrono::steady_clock::now().time_since_epoch().count());
+
+  std::vector<RowVectorPtr> buildVectors = makeBatches(10, [&](int32_t) {
+    return makeRowVector(
+        {"u_k", "u_v"},
+        {
+            makeFlatVector<int32_t>(
+                10'000, [](auto row) { return row % 5'000; }),
+            makeFlatVector<int64_t>(10'000, [](auto row) { return row * 10; }),
+        });
+  });
+
+  std::vector<RowVectorPtr> probeVectors = makeBatches(5, [&](int32_t) {
+    return makeRowVector(
+        {"t_k", "t_v"},
+        {
+            makeFlatVector<int32_t>(100, [](auto row) { return row % 5'000; }),
+            makeFlatVector<int64_t>(100, [](auto row) { return row; }),
+        });
+  });
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto buildPlanNode =
+      PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode();
+  auto probePlanNode =
+      PlanBuilder(planNodeIdGenerator).values(probeVectors).planNode();
+
+  auto outputType = ROW(
+      {"t_k", "t_v", "u_k", "u_v"}, {INTEGER(), BIGINT(), INTEGER(), BIGINT()});
+
+  auto joinNode =
+      core::HashJoinNode::Builder()
+          .id(planNodeIdGenerator->next())
+          .joinType(core::JoinType::kInner)
+          .nullAware(false)
+          .leftKeys(
+              {std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "t_k")})
+          .rightKeys(
+              {std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "u_k")})
+          .left(probePlanNode)
+          .right(buildPlanNode)
+          .outputType(outputType)
+          .useHashTableCache(true)
+          .build();
+  const auto joinNodeId = joinNode->id();
+
+  auto queryCtx = core::QueryCtx::create(
+      driverExecutor_.get(),
+      core::QueryConfig({}),
+      std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
+      cache::AsyncDataCache::getInstance(),
+      nullptr,
+      nullptr,
+      queryId);
+
+  // Tight pool so the large allocation in the TestValue callback triggers
+  // memory arbitration via growCapacity.
+  constexpr int64_t kPoolCapacity = 20 * 1024 * 1024; // 20MB
+  queryCtx->testingOverrideMemoryPool(
+      memory::memoryManager()->addRootPool(
+          queryCtx->queryId(), kPoolCapacity, exec::MemoryReclaimer::create()));
+
+  const auto cacheKey = fmt::format("{}:{}", queryId, joinNodeId);
+
+  std::atomic_bool injected{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashBuild::finishHashBuild",
+      std::function<void(exec::HashBuild*)>(([&](exec::HashBuild* hashBuild) {
+        if (injected.exchange(true)) {
+          return;
+        }
+        // Retrieve the cache entry to access the cache pool. Calling get()
+        // with the builder task's own ID returns the existing entry without
+        // side effects.
+        auto task = hashBuild->operatorCtx()->task();
+        ContinueFuture future;
+        auto entry = HashTableCache::instance()->get(
+            cacheKey, task->taskId(), task->queryCtx().get(), &future);
+
+        // Allocate enough from the cache pool to trigger growCapacity.
+        // growCapacity creates a MemoryPoolArbitrationSection on the
+        // requesting pool, which calls pool->enterArbitration(). The
+        // reclaimer's enterArbitration() must suspend the driver thread;
+        // without a reclaimer the driver is not suspended and the
+        // arbitration state check fails.
+        entry->tablePool->allocate(kPoolCapacity);
+      })));
+
+  // The query throws because the allocation exceeds capacity.
+  // With a proper reclaimer on the cache pool, the error is OOM
+  // ("Exceeded memory pool capacity"), not "Driver thread is not suspended".
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(joinNode, duckDbQueryRunner_)
+          .queryCtx(queryCtx)
+          .maxDrivers(1)
+          .copyResults(pool()),
+      "Exceeded memory pool capacity");
+
+  ASSERT_TRUE(injected) << "TestValue injection was not triggered";
+
+  waitForAllTasksToBeDeleted();
+  queryCtx.reset();
+}
+
+} // namespace
+
+// Reproduces a spin-loop bug where non-last drivers of the HashBuild pipeline
+// never reach kFinish when hash table caching is enabled.
+//
+// Root cause: after allPeersFinished() returns false, non-last drivers were
+// placed in kWaitForBuild state. When they wake from the peers-finished future,
+// isBlocked() enters the kWaitForBuild case and calls
+// receivedCachedHashTable(), which does setRunning() + noMoreInput().
+// noMoreInput() returns early (noMoreInput_ is already true), so the operator
+// stays in kRunning forever -- never reaching kFinish. The driver loop spins
+// calling isBlocked/getOutput/isFinished in a tight loop, burning CPU until the
+// task is terminated by the probe pipeline completing.
+//
+// Fix (D100200527): in finishHashBuild(), when allPeersFinished() returns false
+// and hash table caching is enabled, set kWaitForProbe instead of
+// kWaitForBuild. This skips receivedCachedHashTable() and goes directly to
+// postHashBuildProcess() -> kFinish.
+//
+// Detection: a TestValue fires at the exact point where the state is set for
+// each non-last driver. We verify the state is kWaitForProbe (the fix), not
+// kWaitForBuild (the bug). This check is deterministic: every non-last driver
+// hits the TestValue exactly once, regardless of thread scheduling.
+DEBUG_ONLY_TEST_F(HashJoinWithCacheTest, nonLastDriverSpinLoop) {
+  const std::string queryId =
+      "spinLoopTest_" +
+      std::to_string(
+          std::chrono::steady_clock::now().time_since_epoch().count());
+
+  std::vector<RowVectorPtr> buildVectors = makeBatches(1, [&](int32_t) {
+    return makeRowVector(
+        {"u_k", "u_v"},
+        {
+            makeFlatVector<int32_t>(50, [](auto row) { return row % 31; }),
+            makeFlatVector<int64_t>(50, [](auto row) { return row * 10; }),
+        });
+  });
+
+  std::vector<RowVectorPtr> probeVectors = makeBatches(3, [&](int32_t) {
+    return makeRowVector(
+        {"t_k", "t_v"},
+        {
+            makeFlatVector<int32_t>(100, [](auto row) { return row % 23; }),
+            makeFlatVector<int64_t>(100, [](auto row) { return row; }),
+        });
+  });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  // The build ValuesNode must be parallelizable so the build pipeline gets
+  // multiple drivers.
+  auto buildPlanNode = PlanBuilder(planNodeIdGenerator)
+                           .values(buildVectors, /*parallelizable=*/true)
+                           .planNode();
+  auto probePlanNode =
+      PlanBuilder(planNodeIdGenerator).values(probeVectors).planNode();
+
+  auto outputType = ROW(
+      {"t_k", "t_v", "u_k", "u_v"}, {INTEGER(), BIGINT(), INTEGER(), BIGINT()});
+
+  auto joinNode =
+      core::HashJoinNode::Builder()
+          .id(planNodeIdGenerator->next())
+          .joinType(core::JoinType::kInner)
+          .nullAware(false)
+          .leftKeys(
+              {std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "t_k")})
+          .rightKeys(
+              {std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "u_k")})
+          .left(probePlanNode)
+          .right(buildPlanNode)
+          .outputType(outputType)
+          .useHashTableCache(true)
+          .build();
+  const auto joinNodeId = joinNode->id();
+
+  const int numDrivers = 4;
+
+  auto queryCtx = core::QueryCtx::create(
+      driverExecutor_.get(),
+      core::QueryConfig({}),
+      std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
+      cache::AsyncDataCache::getInstance(),
+      nullptr,
+      nullptr,
+      queryId);
+
+  // Track non-last drivers via the finishHashBuild TestValue. This fires
+  // right after setState(kWaitForBuild) for each non-last driver. We verify
+  // the allPeersFinished coordination works (expected count = numDrivers - 1).
+  //
+  // The spin loop bug was in receivedCachedHashTable(): when non-last drivers
+  // woke from the peers-finished future and re-entered isBlocked(), the
+  // function would call setRunning() + noMoreInput() (a no-op), leaving the
+  // operator in kRunning forever. The fix adds a guard in
+  // receivedCachedHashTable() via hashTableCacheBuilderTask() so it returns
+  // false for builder tasks, letting the driver fall through to
+  // postHashBuildProcess -> kFinish.
+  std::atomic_int lastDriverCount{0};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashBuild::finishHashBuild",
+      std::function<void(HashBuild*)>([&](HashBuild*) { ++lastDriverCount; }));
+
+  // Run the builder task. Skip DuckDB comparison — parallelizable build source
+  // produces numDrivers copies of build data. This test checks the state
+  // machine, not result correctness (other tests cover that).
+  auto task = AssertQueryBuilder(joinNode)
+                  .queryCtx(queryCtx)
+                  .maxDrivers(numDrivers)
+                  .copyResults(pool());
+
+  // With numDrivers drivers, exactly 1 is the last driver.
+  EXPECT_EQ(lastDriverCount.load(), 1)
+      << "Expected exactly 1 last driver, got " << lastDriverCount.load();
+
+  // Verify the task completed successfully — if the spin loop bug were
+  // present, non-last drivers would spin in kRunning until the task is
+  // killed, wasting CPU. The task completing with correct output and
+  // exactly one last driver confirms the fix works.
+
+  const auto cacheKey = fmt::format("{}:{}", queryId, joinNodeId);
+  HashTableCache::instance()->drop(cacheKey);
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/HashTableCacheTest.cpp b/velox/exec/tests/HashTableCacheTest.cpp
new file mode 100644
index 00000000000..3736178af42
--- /dev/null
+++ b/velox/exec/tests/HashTableCacheTest.cpp
@@ -0,0 +1,276 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/HashTableCache.h"
+
+#include <gtest/gtest.h>
+
+#include "velox/common/caching/AsyncDataCache.h"
+#include "velox/common/memory/Memory.h"
+#include "velox/core/QueryCtx.h"
+
+namespace facebook::velox::exec::test {
+
+class HashTableCacheTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  void SetUp() override {
+    pool_ = memory::memoryManager()->addRootPool("HashTableCacheTest");
+    queryCtx_ = core::QueryCtx::create();
+  }
+
+  void TearDown() override {
+    // Clean up any cache entries created during tests.
+    auto* cache = HashTableCache::instance();
+    for (const auto& key : createdKeys_) {
+      cache->drop(key);
+    }
+    createdKeys_.clear();
+    queryCtx_.reset();
+  }
+
+  // Helper to track keys for cleanup.
+  void trackKey(const std::string& key) {
+    createdKeys_.push_back(key);
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_;
+  std::shared_ptr<core::QueryCtx> queryCtx_;
+  std::vector<std::string> createdKeys_;
+};
+
+TEST_F(HashTableCacheTest, basicGet) {
+  auto* cache = HashTableCache::instance();
+  const std::string key = "query1:node1";
+  trackKey(key);
+
+  ContinueFuture future = ContinueFuture::makeEmpty();
+  auto entry = cache->get(key, "task1", queryCtx_.get(), &future);
+
+  ASSERT_NE(entry, nullptr);
+  ASSERT_NE(entry->tablePool, nullptr);
+  EXPECT_EQ(entry->builderTaskId, "task1");
+  EXPECT_FALSE(entry->buildComplete);
+  // First caller should not get a future (they are the builder).
+  EXPECT_FALSE(future.valid());
+}
+
+TEST_F(HashTableCacheTest, secondCallerGetsWaitFuture) {
+  auto* cache = HashTableCache::instance();
+  const std::string key = "query2:node1";
+  trackKey(key);
+
+  // First caller (builder).
+  ContinueFuture future1 = ContinueFuture::makeEmpty();
+  auto entry1 = cache->get(key, "task1", queryCtx_.get(), &future1);
+  EXPECT_FALSE(future1.valid());
+  EXPECT_EQ(entry1->builderTaskId, "task1");
+
+  // Second caller (waiter).
+  ContinueFuture future2 = ContinueFuture::makeEmpty();
+  auto entry2 = cache->get(key, "task2", queryCtx_.get(), &future2);
+
+  // Should get the same entry.
+  EXPECT_EQ(entry1, entry2);
+  // Should get a valid future to wait on.
+  EXPECT_TRUE(future2.valid());
+  // Builder task ID should not change.
+  EXPECT_EQ(entry2->builderTaskId, "task1");
+}
+
+TEST_F(HashTableCacheTest, putNotifiesWaiters) {
+  auto* cache = HashTableCache::instance();
+  const std::string key = "query3:node1";
+  trackKey(key);
+
+  // First caller (builder).
+  ContinueFuture future1 = ContinueFuture::makeEmpty();
+  auto entry = cache->get(key, "task1", queryCtx_.get(), &future1);
+
+  // Second caller (waiter).
+  ContinueFuture future2 = ContinueFuture::makeEmpty();
+  cache->get(key, "task2", queryCtx_.get(), &future2);
+  ASSERT_TRUE(future2.valid());
+
+  // Put the table.
+  cache->put(key, nullptr, false);
+
+  // Entry should now be marked complete.
+  EXPECT_TRUE(entry->buildComplete);
+
+  // The future should be fulfilled.
+  EXPECT_TRUE(future2.isReady());
+}
+
+TEST_F(HashTableCacheTest, getAfterBuildComplete) {
+  auto* cache = HashTableCache::instance();
+  const std::string key = "query4:node1";
+  trackKey(key);
+
+  // First caller creates and builds.
+  ContinueFuture future1 = ContinueFuture::makeEmpty();
+  cache->get(key, "task1", queryCtx_.get(), &future1);
+  cache->put(key, nullptr, true);
+
+  // Later caller should get completed entry without waiting.
+  ContinueFuture future2 = ContinueFuture::makeEmpty();
+  auto entry = cache->get(key, "task2", queryCtx_.get(), &future2);
+
+  EXPECT_TRUE(entry->buildComplete);
+  EXPECT_FALSE(future2.valid()); // No need to wait.
+  EXPECT_TRUE(entry->hasNullKeys);
+}
+
+TEST_F(HashTableCacheTest, drop) {
+  auto* cache = HashTableCache::instance();
+  const std::string key = "query5:node1";
+  // Don't track - we're testing drop.
+
+  ContinueFuture future = ContinueFuture::makeEmpty();
+  auto entry1 = cache->get(key, "task1", queryCtx_.get(), &future);
+  ASSERT_NE(entry1, nullptr);
+
+  // Keep track of the original pool to verify it's different after flush.
+  auto originalPool = entry1->tablePool;
+
+  // Drop the entry.
+  cache->drop(key);
+
+  // Getting the same key should create a new entry.
+  // Use a new queryCtx with different pool to avoid the leaf child name
+  // collision.
+  auto pool2 = memory::memoryManager()->addRootPool("HashTableCacheTest2");
+  auto queryCtx2 = core::QueryCtx::create(
+      nullptr, // executor
+      core::QueryConfig{{}}, // queryConfig
+      {}, // connectorConfigs
+      cache::AsyncDataCache::getInstance(), // cache
+      pool2);
+  ContinueFuture future2 = ContinueFuture::makeEmpty();
+  auto entry2 = cache->get(key, "task2", queryCtx2.get(), &future2);
+
+  EXPECT_NE(entry1, entry2);
+  EXPECT_EQ(entry2->builderTaskId, "task2");
+  // The pool should be different (created under queryCtx2's pool).
+  EXPECT_NE(entry1->tablePool, entry2->tablePool);
+
+  // Cleanup.
+  cache->drop(key);
+}
+
+TEST_F(HashTableCacheTest, concurrentWaiters) {
+  auto* cache = HashTableCache::instance();
+  const std::string key = "query6:node1";
+  trackKey(key);
+
+  // First caller (builder).
+  ContinueFuture builderFuture = ContinueFuture::makeEmpty();
+  auto entry = cache->get(key, "builder", queryCtx_.get(), &builderFuture);
+
+  // Multiple waiters.
+  constexpr int kNumWaiters = 5;
+  std::vector<ContinueFuture> waiterFutures(kNumWaiters);
+
+  for (int i = 0; i < kNumWaiters; ++i) {
+    waiterFutures[i] = ContinueFuture::makeEmpty();
+    cache->get(
+        key, fmt::format("waiter{}", i), queryCtx_.get(), &waiterFutures[i]);
+    EXPECT_TRUE(waiterFutures[i].valid());
+  }
+
+  // Put the table.
+  cache->put(key, nullptr, false);
+
+  // All waiters should be notified.
+  for (int i = 0; i < kNumWaiters; ++i) {
+    EXPECT_TRUE(waiterFutures[i].isReady());
+  }
+}
+
+TEST_F(HashTableCacheTest, builderTaskDriversDoNotWait) {
+  auto* cache = HashTableCache::instance();
+  const std::string key = "query7:node1";
+  trackKey(key);
+
+  // First driver of builder task.
+  ContinueFuture future1 = ContinueFuture::makeEmpty();
+  auto entry1 = cache->get(key, "task1", queryCtx_.get(), &future1);
+  EXPECT_FALSE(future1.valid());
+
+  // Second driver of the same builder task should not wait.
+  ContinueFuture future2 = ContinueFuture::makeEmpty();
+  auto entry2 = cache->get(key, "task1", queryCtx_.get(), &future2);
+
+  EXPECT_EQ(entry1, entry2);
+  // Same task should not get a future - they coordinate via JoinBridge.
+  EXPECT_FALSE(future2.valid());
+}
+
+// Verifies that when the builder task fails (e.g., OOM in finishHashBuild()),
+// dropping the cache entry unblocks all waiting tasks and allows new tasks
+// to become builders.
+TEST_F(HashTableCacheTest, builderFailureUnblocksWaiters) {
+  auto* cache = HashTableCache::instance();
+  const std::string key = "query_oom:node1";
+
+  // Builder task gets the entry.
+  ContinueFuture builderFuture = ContinueFuture::makeEmpty();
+  auto builderEntry =
+      cache->get(key, "builder_task", queryCtx_.get(), &builderFuture);
+  ASSERT_FALSE(builderFuture.valid());
+
+  // Two waiter tasks arrive while builder is working.
+  ContinueFuture waiterFuture1 = ContinueFuture::makeEmpty();
+  cache->get(key, "waiter_task_1", queryCtx_.get(), &waiterFuture1);
+  ASSERT_TRUE(waiterFuture1.valid());
+
+  ContinueFuture waiterFuture2 = ContinueFuture::makeEmpty();
+  cache->get(key, "waiter_task_2", queryCtx_.get(), &waiterFuture2);
+  ASSERT_TRUE(waiterFuture2.valid());
+
+  // Simulate builder task failure: close() now calls drop() when the builder
+  // fails without completing the build.
+  cache->drop(key);
+  builderEntry.reset();
+
+  // Both waiters should be unblocked.
+  EXPECT_TRUE(waiterFuture1.isReady())
+      << "Pre-existing waiter should be unblocked after builder failure";
+  EXPECT_TRUE(waiterFuture2.isReady())
+      << "Second waiter should also be unblocked after builder failure";
+
+  // A new task arriving after drop should become a fresh builder.
+  auto pool2 = memory::memoryManager()->addRootPool("HashTableCacheTest_retry");
+  auto queryCtx2 = core::QueryCtx::create(
+      nullptr,
+      core::QueryConfig{{}},
+      {},
+      cache::AsyncDataCache::getInstance(),
+      pool2);
+  ContinueFuture newFuture = ContinueFuture::makeEmpty();
+  auto newEntry = cache->get(key, "new_builder", queryCtx2.get(), &newFuture);
+  EXPECT_FALSE(newFuture.valid())
+      << "New task after drop should become builder, not waiter";
+  EXPECT_EQ(newEntry->builderTaskId, "new_builder");
+  EXPECT_FALSE(newEntry->buildComplete);
+
+  cache->drop(key);
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/HashTableTest.cpp b/velox/exec/tests/HashTableTest.cpp
index bee323d38f8..5466bdf149d 100644
--- a/velox/exec/tests/HashTableTest.cpp
+++ b/velox/exec/tests/HashTableTest.cpp
@@ -15,7 +15,7 @@
  */
 
 #include "velox/exec/HashTable.h"
-#include "folly/experimental/EventCount.h"
+#include "folly/synchronization/EventCount.h"
 #include "velox/common/base/SelectivityInfo.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/testutil/TestValue.h"
@@ -132,11 +132,18 @@ class HashTableTest : public testing::TestWithParam<bool>,
       std::vector<RowVectorPtr> batches;
       std::vector<std::unique_ptr<VectorHasher>> keyHashers;
       for (auto channel = 0; channel < numKeys; ++channel) {
-        keyHashers.emplace_back(std::make_unique<VectorHasher>(
-            buildType->childAt(channel), channel));
+        keyHashers.emplace_back(
+            std::make_unique<VectorHasher>(
+                buildType->childAt(channel), channel));
       }
       auto table = HashTable<true>::createForJoin(
-          std::move(keyHashers), dependentTypes, true, false, 1'000, pool());
+          std::move(keyHashers),
+          dependentTypes,
+          true,
+          false,
+          false,
+          1'000,
+          pool());
 
       makeRows(size, 1, sequence, buildType, batches);
       copyVectorsToTable(batches, startOffset, table.get());
@@ -158,6 +165,8 @@ class HashTableTest : public testing::TestWithParam<bool>,
     topTable_->prepareJoinTable(
         std::move(otherTables),
         BaseHashTable::kNoSpillInputStartPartitionBit,
+        1'000'000,
+        false,
         executor_.get());
     ASSERT_GE(
         estimatedTableSize,
@@ -431,8 +440,9 @@ class HashTableTest : public testing::TestWithParam<bool>,
       TypePtr buildType,
       std::vector<RowVectorPtr>& batches) {
     for (auto i = 0; i < numBatches; ++i) {
-      batches.push_back(std::static_pointer_cast<RowVector>(
-          makeVector(buildType, batchSize, sequence)));
+      batches.push_back(
+          std::static_pointer_cast<RowVector>(
+              makeVector(buildType, batchSize, sequence)));
       sequence += batchSize;
     }
   }
@@ -539,10 +549,14 @@ class HashTableTest : public testing::TestWithParam<bool>,
     std::vector<std::unique_ptr<VectorHasher>> hashers;
     hashers.push_back(std::make_unique<VectorHasher>(keys->type(), 0));
     auto table = HashTable<false>::createForJoin(
-        std::move(hashers), {BIGINT()}, true, false, 1'000, pool());
+        std::move(hashers), {BIGINT()}, true, false, false, 1'000, pool());
     copyVectorsToTable({batch}, 0, table.get());
     table->prepareJoinTable(
-        {}, BaseHashTable::kNoSpillInputStartPartitionBit, executor_.get());
+        {},
+        BaseHashTable::kNoSpillInputStartPartitionBit,
+        1'000'000,
+        false,
+        executor_.get());
     ASSERT_EQ(table->hashMode(), mode);
     std::vector<char*> rows(nullValues.size());
     BaseHashTable::NullKeyRowsIterator iter;
@@ -835,12 +849,16 @@ TEST_P(HashTableTest, regularHashingTableSize) {
           std::make_unique<VectorHasher>(type->childAt(channel), channel));
     }
     auto table = HashTable<true>::createForJoin(
-        std::move(keyHashers), {}, true, false, 1'000, pool());
+        std::move(keyHashers), {}, true, false, false, 1'000, pool());
     std::vector<RowVectorPtr> batches;
     makeRows(1 << 12, 1, 0, type, batches);
     copyVectorsToTable(batches, 0, table.get());
     table->prepareJoinTable(
-        {}, BaseHashTable::kNoSpillInputStartPartitionBit, executor_.get());
+        {},
+        BaseHashTable::kNoSpillInputStartPartitionBit,
+        1'000'000,
+        false,
+        executor_.get());
     ASSERT_EQ(table->hashMode(), mode);
     EXPECT_GE(table->testingRehashSize(), table->numDistinct());
   };
@@ -872,6 +890,7 @@ TEST_P(HashTableTest, listJoinResultsSize) {
       {BIGINT(), VARCHAR()},
       true,
       false,
+      false,
       kNumRows,
       pool());
   std::vector<RowVectorPtr> batches;
@@ -1026,7 +1045,7 @@ DEBUG_ONLY_TEST_P(HashTableTest, nextBucketOffset) {
           std::make_unique<VectorHasher>(type->childAt(channel), channel));
     }
     auto table = HashTable<true>::createForJoin(
-        std::move(keyHashers), {}, true, false, 1'000, pool());
+        std::move(keyHashers), {}, true, false, false, 1'000, pool());
     auto testHelper = HashTableTestHelper<true>::create(table.get());
     const uint64_t numDistincts = bits::nextPowerOfTwo(
         2UL * std::numeric_limits<int32_t>::max() / testHelper.tableSlotSize());
@@ -1133,7 +1152,7 @@ DEBUG_ONLY_TEST_P(HashTableTest, failureInCreateRowPartitions) {
     // Set minTableSizeForParallelJoinBuild to be really small so we can trigger
     // a parallel join build without needing a lot of data.
     auto table = HashTable<false>::createForJoin(
-        std::move(hashers), {BIGINT()}, true, false, 1, pool());
+        std::move(hashers), {BIGINT()}, true, false, false, 1, pool());
     copyVectorsToTable({batch}, 0, table.get());
 
     if (topTable == nullptr) {
@@ -1146,6 +1165,8 @@ DEBUG_ONLY_TEST_P(HashTableTest, failureInCreateRowPartitions) {
   topTable->prepareJoinTable(
       std::move(otherTables),
       BaseHashTable::kNoSpillInputStartPartitionBit,
+      1'000'000,
+      false,
       executor_.get());
   auto topTabletestHelper = HashTableTestHelper<false>::create(topTable.get());
 
@@ -1225,6 +1246,7 @@ TEST_P(HashTableTest, toStringSingleKey) {
       {}, /*dependentTypes*/
       true /*allowDuplicates*/,
       false /*hasProbedFlag*/,
+      false /*hasCountFlag*/,
       1 /*minTableSizeForParallelJoinBuild*/,
       pool());
 
@@ -1234,7 +1256,8 @@ TEST_P(HashTableTest, toStringSingleKey) {
 
   store(*table->rows(), data);
 
-  table->prepareJoinTable({}, BaseHashTable::kNoSpillInputStartPartitionBit);
+  table->prepareJoinTable(
+      {}, BaseHashTable::kNoSpillInputStartPartitionBit, 1'000'000);
 
   ASSERT_NO_THROW(table->toString());
   ASSERT_NO_THROW(table->toString(0));
@@ -1253,6 +1276,7 @@ TEST_P(HashTableTest, toStringMultipleKeys) {
       {}, /*dependentTypes*/
       true /*allowDuplicates*/,
       false /*hasProbedFlag*/,
+      false /*hasCountFlag*/,
       1 /*minTableSizeForParallelJoinBuild*/,
       pool());
 
@@ -1265,16 +1289,18 @@ TEST_P(HashTableTest, toStringMultipleKeys) {
 
   store(*table->rows(), data);
 
-  table->prepareJoinTable({}, BaseHashTable::kNoSpillInputStartPartitionBit);
+  table->prepareJoinTable(
+      {}, BaseHashTable::kNoSpillInputStartPartitionBit, 1'000'000);
 
   ASSERT_NO_THROW(table->toString());
 }
 
 TEST(HashTableTest, tableInsertPartitionInfo) {
   std::vector<char*> overflows;
+  std::vector<uint64_t> overflowHashes;
   const auto testFn = [&](PartitionBoundIndexType start,
                           PartitionBoundIndexType end) {
-    TableInsertPartitionInfo info{start, end, overflows};
+    TableInsertPartitionInfo info{start, end, overflows, overflowHashes};
   };
   struct {
     PartitionBoundIndexType start;
@@ -1290,8 +1316,9 @@ TEST(HashTableTest, tableInsertPartitionInfo) {
     VELOX_ASSERT_THROW(testFn(badData.start, badData.end), "");
   }
   ASSERT_TRUE(overflows.empty());
+  ASSERT_TRUE(overflowHashes.empty());
 
-  TableInsertPartitionInfo info{1, 1000, overflows};
+  TableInsertPartitionInfo info{1, 1000, overflows, overflowHashes};
   ASSERT_TRUE(info.inRange(1));
   ASSERT_FALSE(info.inRange(0));
   ASSERT_FALSE(info.inRange(-1));
@@ -1299,17 +1326,23 @@ TEST(HashTableTest, tableInsertPartitionInfo) {
   ASSERT_FALSE(info.inRange(1'000));
   ASSERT_FALSE(info.inRange(12'000));
   ASSERT_TRUE(overflows.empty());
+  ASSERT_TRUE(overflowHashes.empty());
 
   const std::vector<uint64_t> insertBuffers{100, 200, 300, 500};
-  for (const auto insertBuffer : insertBuffers) {
-    info.addOverflow(reinterpret_cast<char*>(insertBuffer));
+  const std::vector<uint64_t> insertHashes{0xAA, 0xBB, 0xCC, 0xDD};
+  for (int i = 0; i < insertBuffers.size(); ++i) {
+    info.addOverflow(
+        reinterpret_cast<char*>(insertBuffers[i]), insertHashes[i]);
   }
   ASSERT_EQ(overflows.size(), insertBuffers.size());
+  ASSERT_EQ(overflowHashes.size(), insertHashes.size());
   for (int i = 0; i < insertBuffers.size(); ++i) {
     ASSERT_EQ(insertBuffers[i], reinterpret_cast<uint64_t>(info.overflows[i]));
+    ASSERT_EQ(insertHashes[i], info.overflowHashes[i]);
   }
   for (int i = 0; i < overflows.size(); ++i) {
     ASSERT_EQ(overflows[i], info.overflows[i]);
+    ASSERT_EQ(overflowHashes[i], info.overflowHashes[i]);
   }
 }
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/HilbertIndexTest.cpp b/velox/exec/tests/HilbertIndexTest.cpp
new file mode 100644
index 00000000000..85cc634f253
--- /dev/null
+++ b/velox/exec/tests/HilbertIndexTest.cpp
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/HilbertIndex.h"
+#include <gtest/gtest.h>
+#include <limits>
+
+using namespace ::testing;
+using namespace facebook::velox::exec;
+
+namespace facebook::velox::exec::test {
+
+class HilbertIndexTest : public virtual testing::Test {};
+
+TEST_F(HilbertIndexTest, testOrder) {
+  HilbertIndex hilbert(0, 0, 4, 4);
+
+  uint32_t h0 = hilbert.indexOf(0.0, 0.0);
+  uint32_t h1 = hilbert.indexOf(1.0, 1.0);
+  uint32_t h2 = hilbert.indexOf(1.0, 3.0);
+  uint32_t h3 = hilbert.indexOf(3.0, 3.0);
+  uint32_t h4 = hilbert.indexOf(3.0, 1.0);
+
+  ASSERT_LT(h0, h1);
+  ASSERT_LT(h1, h2);
+  ASSERT_LT(h2, h3);
+  ASSERT_LT(h3, h4);
+}
+
+TEST_F(HilbertIndexTest, testOutOfBounds) {
+  HilbertIndex hilbert(0, 0, 1, 1);
+
+  ASSERT_EQ(hilbert.indexOf(2.0, 2.0), std::numeric_limits<uint32_t>::max());
+}
+
+TEST_F(HilbertIndexTest, testDegenerateRectangle) {
+  HilbertIndex hilbert(0, 0, 0, 0);
+
+  ASSERT_EQ(hilbert.indexOf(0.0, 0.0), 0);
+  ASSERT_EQ(hilbert.indexOf(2.0, 2.0), std::numeric_limits<uint32_t>::max());
+}
+
+TEST_F(HilbertIndexTest, testDegenerateHorizontalRectangle) {
+  HilbertIndex hilbert(0, 0, 4, 0);
+
+  ASSERT_EQ(hilbert.indexOf(0.0, 0.0), 0);
+  ASSERT_LT(hilbert.indexOf(1.0, 0.0), hilbert.indexOf(2.0, 0.0));
+  ASSERT_EQ(hilbert.indexOf(0.0, 2.0), std::numeric_limits<uint32_t>::max());
+  ASSERT_EQ(hilbert.indexOf(2.0, 2.0), std::numeric_limits<uint32_t>::max());
+}
+
+TEST_F(HilbertIndexTest, testDegenerateVerticalRectangle) {
+  HilbertIndex hilbert(0, 0, 0, 4);
+
+  ASSERT_EQ(hilbert.indexOf(0.0, 0.0), 0);
+  ASSERT_LT(hilbert.indexOf(0.0, 1.0), hilbert.indexOf(0.0, 2.0));
+  ASSERT_EQ(hilbert.indexOf(2.0, 0.0), std::numeric_limits<uint32_t>::max());
+  ASSERT_EQ(hilbert.indexOf(2.0, 2.0), std::numeric_limits<uint32_t>::max());
+}
+
+TEST_F(HilbertIndexTest, testNegativeCoordinates) {
+  HilbertIndex hilbert(-10, -10, 10, 10);
+
+  uint32_t h0 = hilbert.indexOf(-5.0, -5.0);
+  uint32_t h1 = hilbert.indexOf(0.0, 0.0);
+  uint32_t h2 = hilbert.indexOf(5.0, 5.0);
+
+  ASSERT_LT(h0, h1);
+  ASSERT_LT(h1, h2);
+
+  ASSERT_EQ(
+      hilbert.indexOf(-15.0, -15.0), std::numeric_limits<uint32_t>::max());
+  ASSERT_EQ(hilbert.indexOf(15.0, 15.0), std::numeric_limits<uint32_t>::max());
+}
+
+TEST_F(HilbertIndexTest, testFloatingPointPrecision) {
+  HilbertIndex hilbert(0, 0, 1, 1);
+
+  uint32_t h1 = hilbert.indexOf(0.1, 0.1);
+  uint32_t h2 = hilbert.indexOf(0.2, 0.2);
+  uint32_t h3 = hilbert.indexOf(0.9, 0.9);
+
+  ASSERT_LT(h1, h2);
+  ASSERT_LT(h2, h3);
+}
+
+TEST_F(HilbertIndexTest, testBoundaryPoints) {
+  HilbertIndex hilbert(0, 0, 10, 10);
+
+  uint32_t h0 = hilbert.indexOf(0.0, 0.0);
+  uint32_t h1 = hilbert.indexOf(10.0, 10.0);
+  uint32_t h2 = hilbert.indexOf(0.0, 10.0);
+  // Bottom-right corner is at the end of the range, so may be MAX
+
+  ASSERT_NE(h0, std::numeric_limits<uint32_t>::max());
+  ASSERT_NE(h1, std::numeric_limits<uint32_t>::max());
+  ASSERT_NE(h2, std::numeric_limits<uint32_t>::max());
+}
+
+TEST_F(HilbertIndexTest, testLargeCoordinates) {
+  HilbertIndex hilbert(0, 0, 1000000, 1000000);
+
+  uint32_t h1 = hilbert.indexOf(100000, 100000);
+  uint32_t h2 = hilbert.indexOf(500000, 500000);
+  uint32_t h3 = hilbert.indexOf(900000, 900000);
+
+  ASSERT_LT(h1, h2);
+  ASSERT_LT(h2, h3);
+}
+
+TEST_F(HilbertIndexTest, testDensityInSmallRegion) {
+  HilbertIndex hilbert(0, 0, 100, 100);
+
+  std::vector<uint32_t> indices;
+  for (int i = 0; i < 10; ++i) {
+    for (int j = 0; j < 10; ++j) {
+      indices.push_back(hilbert.indexOf(i * 10.0f + 5.0f, j * 10.0f + 5.0f));
+    }
+  }
+
+  std::set<uint32_t> uniqueIndices(indices.begin(), indices.end());
+  ASSERT_EQ(indices.size(), 100);
+  ASSERT_GT(uniqueIndices.size(), 90);
+}
+
+TEST_F(HilbertIndexTest, testSpatialLocality) {
+  HilbertIndex hilbert(0, 0, 100, 100);
+
+  uint32_t h1 = hilbert.indexOf(50.0, 50.0);
+  uint32_t h2 = hilbert.indexOf(50.1, 50.1);
+  uint32_t h3 = hilbert.indexOf(50.2, 50.2);
+  uint32_t h4 = hilbert.indexOf(90.0, 90.0);
+
+  uint32_t diff12 = std::abs(static_cast<int32_t>(h1 - h2));
+  uint32_t diff23 = std::abs(static_cast<int32_t>(h2 - h3));
+  uint32_t diff14 = std::abs(static_cast<int32_t>(h1 - h4));
+
+  ASSERT_LT(diff12, diff14);
+  ASSERT_LT(diff23, diff14);
+}
+
+TEST_F(HilbertIndexTest, testIdenticalPoints) {
+  HilbertIndex hilbert(0, 0, 10, 10);
+
+  uint32_t h1 = hilbert.indexOf(5.0, 5.0);
+  uint32_t h2 = hilbert.indexOf(5.0, 5.0);
+
+  ASSERT_EQ(h1, h2);
+}
+
+TEST_F(HilbertIndexTest, testExtremelySmallBounds) {
+  HilbertIndex hilbert(0, 0, 0.001, 0.001);
+
+  uint32_t h1 = hilbert.indexOf(0.0, 0.0);
+  uint32_t h2 = hilbert.indexOf(0.0005, 0.0005);
+
+  ASSERT_NE(h1, std::numeric_limits<uint32_t>::max());
+  ASSERT_NE(h2, std::numeric_limits<uint32_t>::max());
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/IndexLookupJoinBridgeTest.cpp b/velox/exec/tests/IndexLookupJoinBridgeTest.cpp
new file mode 100644
index 00000000000..63ca4823748
--- /dev/null
+++ b/velox/exec/tests/IndexLookupJoinBridgeTest.cpp
@@ -0,0 +1,264 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/exec/IndexLookupJoinBridge.h"
+
+#include <folly/executors/InlineExecutor.h>
+#include <gtest/gtest.h>
+#include <thread>
+
+#include "velox/common/base/tests/GTestUtils.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::connector;
+
+namespace {
+
+std::shared_ptr<ConnectorSplit> makeFakeSplit(const std::string& id) {
+  return std::make_shared<ConnectorSplit>(id);
+}
+
+std::vector<std::shared_ptr<ConnectorSplit>> makeFakeSplits(int count) {
+  std::vector<std::shared_ptr<ConnectorSplit>> splits;
+  splits.reserve(count);
+  for (int i = 0; i < count; ++i) {
+    splits.push_back(makeFakeSplit("connector_" + std::to_string(i)));
+  }
+  return splits;
+}
+
+class IndexLookupJoinBridgeTest : public testing::Test {
+ protected:
+  std::shared_ptr<IndexLookupJoinBridge> createBridge() {
+    auto bridge = std::make_shared<IndexLookupJoinBridge>();
+    bridge->start();
+    return bridge;
+  }
+};
+
+TEST_F(IndexLookupJoinBridgeTest, setAndGetSplits) {
+  auto bridge = createBridge();
+  auto splits = makeFakeSplits(3);
+  const auto expectedSize = splits.size();
+
+  bridge->setIndexSplits(std::move(splits));
+
+  ContinueFuture future = ContinueFuture::makeEmpty();
+  auto result = bridge->splitsOrFuture(&future);
+  ASSERT_FALSE(future.valid());
+  ASSERT_EQ(result.size(), expectedSize);
+}
+
+TEST_F(IndexLookupJoinBridgeTest, splitsOrFutureBlocks) {
+  auto bridge = createBridge();
+
+  ContinueFuture future = ContinueFuture::makeEmpty();
+  auto result = bridge->splitsOrFuture(&future);
+  ASSERT_TRUE(future.valid());
+  ASSERT_TRUE(result.empty());
+
+  // Set splits and verify the future is fulfilled.
+  auto splits = makeFakeSplits(2);
+  bridge->setIndexSplits(std::move(splits));
+
+  std::move(future).via(&folly::InlineExecutor::instance()).get();
+
+  // Now splitsOrFuture should return immediately on repeated calls.
+  for (int i = 0; i < 3; ++i) {
+    ContinueFuture future2 = ContinueFuture::makeEmpty();
+    auto result2 = bridge->splitsOrFuture(&future2);
+    ASSERT_FALSE(future2.valid());
+    ASSERT_EQ(result2.size(), 2);
+  }
+}
+
+TEST_F(IndexLookupJoinBridgeTest, multipleFollowers) {
+  auto bridge = createBridge();
+
+  // Multiple followers wait for splits.
+  const int numFollowers = 4;
+  std::vector<ContinueFuture> futures;
+  for (int i = 0; i < numFollowers; ++i) {
+    ContinueFuture future = ContinueFuture::makeEmpty();
+    auto result = bridge->splitsOrFuture(&future);
+    ASSERT_TRUE(future.valid());
+    ASSERT_TRUE(result.empty());
+    futures.push_back(std::move(future));
+  }
+
+  // Leader sets splits.
+  bridge->setIndexSplits(makeFakeSplits(5));
+
+  // All futures should be fulfilled.
+  for (auto& future : futures) {
+    std::move(future).via(&folly::InlineExecutor::instance()).get();
+  }
+
+  // All followers can now get splits.
+  for (int i = 0; i < numFollowers; ++i) {
+    ContinueFuture future = ContinueFuture::makeEmpty();
+    auto result = bridge->splitsOrFuture(&future);
+    ASSERT_FALSE(future.valid());
+    ASSERT_EQ(result.size(), 5);
+  }
+}
+
+TEST_F(IndexLookupJoinBridgeTest, setBeforeGet) {
+  auto bridge = createBridge();
+
+  // Leader sets splits before any follower calls splitsOrFuture.
+  bridge->setIndexSplits(makeFakeSplits(3));
+
+  // Followers get splits immediately without blocking.
+  for (int i = 0; i < 3; ++i) {
+    ContinueFuture future = ContinueFuture::makeEmpty();
+    auto result = bridge->splitsOrFuture(&future);
+    ASSERT_FALSE(future.valid());
+    ASSERT_EQ(result.size(), 3);
+  }
+}
+
+TEST_F(IndexLookupJoinBridgeTest, setTwiceThrows) {
+  auto bridge = createBridge();
+  bridge->setIndexSplits(makeFakeSplits(1));
+
+  VELOX_ASSERT_THROW(
+      bridge->setIndexSplits(makeFakeSplits(1)),
+      "setIndexSplits must be called only once");
+}
+
+TEST_F(IndexLookupJoinBridgeTest, setEmptyTwiceThrows) {
+  auto bridge = createBridge();
+  bridge->setIndexSplits({});
+
+  VELOX_ASSERT_THROW(
+      bridge->setIndexSplits({}), "setIndexSplits must be called only once");
+}
+
+TEST_F(IndexLookupJoinBridgeTest, setEmptySplits) {
+  auto bridge = createBridge();
+  bridge->setIndexSplits({});
+
+  ContinueFuture future = ContinueFuture::makeEmpty();
+  auto result = bridge->splitsOrFuture(&future);
+  ASSERT_FALSE(future.valid());
+  ASSERT_TRUE(result.empty());
+}
+
+TEST_F(IndexLookupJoinBridgeTest, emptySplitsUnblockFollowers) {
+  auto bridge = createBridge();
+
+  ContinueFuture future = ContinueFuture::makeEmpty();
+  auto result = bridge->splitsOrFuture(&future);
+  ASSERT_TRUE(future.valid());
+  ASSERT_TRUE(result.empty());
+
+  bridge->setIndexSplits({});
+
+  std::move(future).via(&folly::InlineExecutor::instance()).get();
+
+  ContinueFuture future2 = ContinueFuture::makeEmpty();
+  auto result2 = bridge->splitsOrFuture(&future2);
+  ASSERT_FALSE(future2.valid());
+  ASSERT_TRUE(result2.empty());
+}
+
+TEST_F(IndexLookupJoinBridgeTest, setBeforeStartThrows) {
+  auto bridge = std::make_shared<IndexLookupJoinBridge>();
+  // Do not call start().
+
+  VELOX_ASSERT_THROW(
+      bridge->setIndexSplits(makeFakeSplits(1)),
+      "Bridge must be started before setting index splits");
+}
+
+TEST_F(IndexLookupJoinBridgeTest, cancelUnblocksFollowers) {
+  auto bridge = createBridge();
+
+  ContinueFuture future = ContinueFuture::makeEmpty();
+  auto result = bridge->splitsOrFuture(&future);
+  ASSERT_TRUE(future.valid());
+
+  bridge->cancel();
+
+  // Future should be fulfilled by cancel.
+  std::move(future).via(&folly::InlineExecutor::instance()).get();
+}
+
+TEST_F(IndexLookupJoinBridgeTest, getAfterCancelThrows) {
+  auto bridge = createBridge();
+  bridge->cancel();
+
+  ContinueFuture future = ContinueFuture::makeEmpty();
+  VELOX_ASSERT_THROW(
+      bridge->splitsOrFuture(&future),
+      "Getting index splits after the bridge is cancelled");
+}
+
+TEST_F(IndexLookupJoinBridgeTest, setAfterCancelThrows) {
+  auto bridge = createBridge();
+  bridge->cancel();
+
+  VELOX_ASSERT_THROW(
+      bridge->setIndexSplits(makeFakeSplits(1)),
+      "Setting index splits after the bridge is cancelled");
+}
+
+TEST_F(IndexLookupJoinBridgeTest, concurrentSetAndGet) {
+  auto bridge = createBridge();
+  const int numFollowers = 8;
+  const int numSplits = 5;
+
+  std::vector<std::thread> threads;
+  std::atomic_int successCount{0};
+  std::atomic_bool stop{false};
+
+  // Start followers that keep getting splits until stopped.
+  threads.reserve(numFollowers);
+  for (int i = 0; i < numFollowers; ++i) {
+    threads.emplace_back([&bridge, &successCount, &stop, numSplits]() {
+      ContinueFuture future = ContinueFuture::makeEmpty();
+      auto result = bridge->splitsOrFuture(&future);
+      if (future.valid()) {
+        std::move(future).via(&folly::InlineExecutor::instance()).get();
+      }
+      while (!stop.load()) {
+        ContinueFuture f = ContinueFuture::makeEmpty();
+        auto r = bridge->splitsOrFuture(&f);
+        ASSERT_FALSE(f.valid());
+        ASSERT_EQ(r.size(), numSplits);
+        ++successCount;
+      }
+    });
+  }
+
+  // Give followers time to register.
+  std::this_thread::sleep_for(std::chrono::milliseconds(10));
+
+  // Leader sets splits.
+  bridge->setIndexSplits(makeFakeSplits(numSplits));
+
+  // Let followers run for a while.
+  std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  stop.store(true);
+
+  for (auto& t : threads) {
+    t.join();
+  }
+  ASSERT_GE(successCount.load(), numFollowers);
+}
+
+} // namespace
diff --git a/velox/exec/tests/IndexLookupJoinTest.cpp b/velox/exec/tests/IndexLookupJoinTest.cpp
index f1e056f117e..a63af98d62b 100644
--- a/velox/exec/tests/IndexLookupJoinTest.cpp
+++ b/velox/exec/tests/IndexLookupJoinTest.cpp
@@ -15,12 +15,14 @@
  */
 
 #include "velox/exec/IndexLookupJoin.h"
-#include "folly/experimental/EventCount.h"
+#include "fmt/format.h"
+#include "folly/synchronization/EventCount.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest-matchers.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/connectors/Connector.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/core/PlanNode.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
@@ -28,37 +30,42 @@
 #include "velox/exec/tests/utils/IndexLookupJoinTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/exec/tests/utils/TestIndexStorageConnector.h"
+#include "velox/vector/LazyVector.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
 using namespace facebook::velox::common::testutil;
 
-namespace fecebook::velox::exec::test {
+namespace facebook::velox::exec::test {
 namespace {
 struct TestParam {
   bool asyncLookup;
   int32_t numPrefetches;
   bool serialExecution;
   bool hasNullKeys;
+  bool needsIndexSplit;
 
   TestParam(
       bool _asyncLookup,
       int32_t _numPrefetches,
       bool _serialExecution,
-      bool _hasNullKeys)
+      bool _hasNullKeys,
+      bool _needsIndexSplit = false)
       : asyncLookup(_asyncLookup),
         numPrefetches(_numPrefetches),
         serialExecution(_serialExecution),
-        hasNullKeys(_hasNullKeys) {}
+        hasNullKeys(_hasNullKeys),
+        needsIndexSplit(_needsIndexSplit) {}
 
   std::string toString() const {
     return fmt::format(
-        "asyncLookup={}, numPrefetches={}, serialExecution={}, hasNullKeys={}",
+        "asyncLookup={}, numPrefetches={}, serialExecution={}, hasNullKeys={}, needsIndexSplit={}",
         asyncLookup,
         numPrefetches,
         serialExecution,
-        hasNullKeys);
+        hasNullKeys,
+        needsIndexSplit);
   }
 };
 
@@ -71,8 +78,20 @@ class IndexLookupJoinTest : public IndexLookupJoinTestBase,
       for (int numPrefetches : {0, 3}) {
         for (bool serialExecution : {false, true}) {
           for (bool hasNullKeys : {false, true}) {
-            testParams.emplace_back(
-                asyncLookup, numPrefetches, serialExecution, hasNullKeys);
+            for (bool needsIndexSplit : {false, true}) {
+              // Serial execution doesn't support index split as it requires
+              // single-threaded execution which is incompatible with the
+              // split-based parallelism used by index lookup join.
+              if (serialExecution && needsIndexSplit) {
+                continue;
+              }
+              testParams.emplace_back(
+                  asyncLookup,
+                  numPrefetches,
+                  serialExecution,
+                  hasNullKeys,
+                  needsIndexSplit);
+            }
           }
         }
       }
@@ -98,7 +117,7 @@ class IndexLookupJoinTest : public IndexLookupJoinTestBase,
   }
 
   void TearDown() override {
-    connector::unregisterConnector(kTestIndexConnectorName);
+    connector::ConnectorRegistry::global().erase(kTestIndexConnectorName);
     HiveConnectorTestBase::TearDown();
   }
 
@@ -112,9 +131,10 @@ class IndexLookupJoinTest : public IndexLookupJoinTestBase,
   // flag.
   static std::shared_ptr<TestIndexTableHandle> makeIndexTableHandle(
       const std::shared_ptr<TestIndexTable>& indexTable,
-      bool asyncLookup) {
+      bool asyncLookup,
+      bool needsIndexSplit = false) {
     return std::make_shared<TestIndexTableHandle>(
-        kTestIndexConnectorName, indexTable, asyncLookup);
+        kTestIndexConnectorName, indexTable, asyncLookup, needsIndexSplit);
   }
 
   static connector::ColumnHandleMap makeIndexColumnHandles(
@@ -176,12 +196,23 @@ TEST_F(IndexLookupJoinTest, joinCondition) {
       PlanBuilder::parseIndexJoinCondition("c0=1", rowType, pool_.get());
   ASSERT_TRUE(equalFilterCondition->isFilter());
   ASSERT_EQ(equalFilterCondition->toString(), "ROW[\"c0\"] = 1");
+
+  auto equalJoinCondition =
+      PlanBuilder::parseIndexJoinCondition("c0=c1", rowType, pool_.get());
+  ASSERT_FALSE(equalJoinCondition->isFilter());
+  ASSERT_EQ(equalJoinCondition->toString(), "ROW[\"c0\"] = ROW[\"c1\"]");
+
+  auto equalJoinConditionAsFilter =
+      PlanBuilder::parseIndexJoinCondition("c0=1", rowType, pool_.get());
+  ASSERT_TRUE(equalJoinConditionAsFilter->isFilter());
+  ASSERT_EQ(equalJoinConditionAsFilter->toString(), "ROW[\"c0\"] = 1");
 }
 
 TEST_P(IndexLookupJoinTest, planNodeAndSerde) {
   TestIndexTableHandle::registerSerDe();
 
-  auto indexConnectorHandle = makeIndexTableHandle(nullptr, true);
+  auto indexConnectorHandle =
+      makeIndexTableHandle(nullptr, true, GetParam().needsIndexSplit);
 
   auto left = makeRowVector(
       {"t0", "t1", "t2", "t3", "t4"},
@@ -224,17 +255,18 @@ TEST_P(IndexLookupJoinTest, planNodeAndSerde) {
   for (const auto joinType : {core::JoinType::kLeft, core::JoinType::kInner}) {
     auto plan = PlanBuilder(planNodeIdGenerator)
                     .values({left})
-                    .indexLookupJoin(
-                        {"t0"},
-                        {"u0"},
-                        indexTableScan,
-                        {},
-                        /*includeMatchColumn=*/false,
-                        {"t0", "u1", "t2", "t1"},
-                        joinType)
+                    .startIndexLookupJoin()
+                    .leftKeys({"t0"})
+                    .rightKeys({"u0"})
+                    .indexSource(indexTableScan)
+                    .outputLayout({"t0", "u1", "t2", "t1"})
+                    .joinType(joinType)
+                    .endIndexLookupJoin()
                     .planNode();
     auto indexLookupJoinNode =
         std::dynamic_pointer_cast<const core::IndexLookupJoinNode>(plan);
+    ASSERT_EQ(
+        indexLookupJoinNode->needsIndexSplit(), GetParam().needsIndexSplit);
     ASSERT_TRUE(indexLookupJoinNode->joinConditions().empty());
     ASSERT_EQ(
         indexLookupJoinNode->lookupSource()->tableHandle()->connectorId(),
@@ -246,17 +278,19 @@ TEST_P(IndexLookupJoinTest, planNodeAndSerde) {
   for (const auto joinType : {core::JoinType::kLeft, core::JoinType::kInner}) {
     auto plan = PlanBuilder(planNodeIdGenerator, pool_.get())
                     .values({left})
-                    .indexLookupJoin(
-                        {"t0"},
-                        {"u0"},
-                        indexTableScan,
-                        {"contains(t3, u0)", "contains(t4, u1)"},
-                        /*includeMatchColumn=*/false,
-                        {"t0", "u1", "t2", "t1"},
-                        joinType)
+                    .startIndexLookupJoin()
+                    .leftKeys({"t0"})
+                    .rightKeys({"u0"})
+                    .indexSource(indexTableScan)
+                    .joinConditions({"contains(t3, u0)", "contains(t4, u1)"})
+                    .outputLayout({"t0", "u1", "t2", "t1"})
+                    .joinType(joinType)
+                    .endIndexLookupJoin()
                     .planNode();
     auto indexLookupJoinNode =
         std::dynamic_pointer_cast<const core::IndexLookupJoinNode>(plan);
+    ASSERT_EQ(
+        indexLookupJoinNode->needsIndexSplit(), GetParam().needsIndexSplit);
     ASSERT_EQ(indexLookupJoinNode->joinConditions().size(), 2);
     ASSERT_EQ(
         indexLookupJoinNode->lookupSource()->tableHandle()->connectorId(),
@@ -265,6 +299,85 @@ TEST_P(IndexLookupJoinTest, planNodeAndSerde) {
   }
 
   // with between join conditions.
+  for (const auto joinType : {core::JoinType::kLeft, core::JoinType::kInner}) {
+    auto plan = PlanBuilder(planNodeIdGenerator, pool_.get())
+                    .values({left})
+                    .startIndexLookupJoin()
+                    .leftKeys({"t0"})
+                    .rightKeys({"u0"})
+                    .indexSource(indexTableScan)
+                    .joinConditions(
+                        {"u0 between t0 AND t1",
+                         "u1 between t1 AND 10",
+                         "u1 between 10 AND t1"})
+                    .outputLayout({"t0", "u1", "t2", "t1"})
+                    .joinType(joinType)
+                    .endIndexLookupJoin()
+                    .planNode();
+    auto indexLookupJoinNode =
+        std::dynamic_pointer_cast<const core::IndexLookupJoinNode>(plan);
+    ASSERT_EQ(
+        indexLookupJoinNode->needsIndexSplit(), GetParam().needsIndexSplit);
+    ASSERT_EQ(indexLookupJoinNode->joinConditions().size(), 3);
+    ASSERT_EQ(
+        indexLookupJoinNode->lookupSource()->tableHandle()->connectorId(),
+        kTestIndexConnectorName);
+    testSerde(plan);
+  }
+
+  // with mix join conditions.
+  for (const auto joinType : {core::JoinType::kLeft, core::JoinType::kInner}) {
+    auto plan =
+        PlanBuilder(planNodeIdGenerator, pool_.get())
+            .values({left})
+            .startIndexLookupJoin()
+            .leftKeys({"t0"})
+            .rightKeys({"u0"})
+            .indexSource(indexTableScan)
+            .joinConditions({"contains(t3, u0)", "u1 between 10 AND t1"})
+            .outputLayout({"t0", "u1", "t2", "t1"})
+            .joinType(joinType)
+            .endIndexLookupJoin()
+            .planNode();
+    auto indexLookupJoinNode =
+        std::dynamic_pointer_cast<const core::IndexLookupJoinNode>(plan);
+    ASSERT_EQ(
+        indexLookupJoinNode->needsIndexSplit(), GetParam().needsIndexSplit);
+    ASSERT_EQ(indexLookupJoinNode->joinConditions().size(), 2);
+    ASSERT_EQ(
+        indexLookupJoinNode->lookupSource()->tableHandle()->connectorId(),
+        kTestIndexConnectorName);
+    testSerde(plan);
+  }
+
+  // with has match column.
+  {
+    auto plan =
+        PlanBuilder(planNodeIdGenerator, pool_.get())
+            .values({left})
+            .startIndexLookupJoin()
+            .leftKeys({"t0"})
+            .rightKeys({"u0"})
+            .indexSource(indexTableScan)
+            .joinConditions({"contains(t3, u0)", "u1 between 10 AND t1"})
+            .hasMarker(true)
+            .outputLayout({"t0", "u1", "t2", "t1", "match"})
+            .joinType(core::JoinType::kLeft)
+            .endIndexLookupJoin()
+            .planNode();
+    auto indexLookupJoinNode =
+        std::dynamic_pointer_cast<const core::IndexLookupJoinNode>(plan);
+    ASSERT_EQ(
+        indexLookupJoinNode->needsIndexSplit(), GetParam().needsIndexSplit);
+    ASSERT_EQ(indexLookupJoinNode->joinConditions().size(), 2);
+    ASSERT_EQ(indexLookupJoinNode->filter(), nullptr);
+    ASSERT_EQ(
+        indexLookupJoinNode->lookupSource()->tableHandle()->connectorId(),
+        kTestIndexConnectorName);
+    testSerde(plan);
+  }
+
+  // with filter.
   for (const auto joinType : {core::JoinType::kLeft, core::JoinType::kInner}) {
     auto plan = PlanBuilder(planNodeIdGenerator, pool_.get())
                     .values({left})
@@ -272,23 +385,27 @@ TEST_P(IndexLookupJoinTest, planNodeAndSerde) {
                         {"t0"},
                         {"u0"},
                         indexTableScan,
-                        {"u0 between t0 AND t1",
-                         "u1 between t1 AND 10",
-                         "u1 between 10 AND t1"},
-                        /*includeMatchColumn=*/false,
+                        {},
+                        /*filter=*/"t1 % 2 = 0",
+                        /*hasMarker=*/false,
                         {"t0", "u1", "t2", "t1"},
                         joinType)
                     .planNode();
     auto indexLookupJoinNode =
         std::dynamic_pointer_cast<const core::IndexLookupJoinNode>(plan);
-    ASSERT_EQ(indexLookupJoinNode->joinConditions().size(), 3);
+    ASSERT_TRUE(indexLookupJoinNode->joinConditions().empty());
+    ASSERT_NE(indexLookupJoinNode->filter(), nullptr);
+    ASSERT_EQ(
+        indexLookupJoinNode->needsIndexSplit(), GetParam().needsIndexSplit);
+    ASSERT_EQ(
+        indexLookupJoinNode->filter()->toString(), "eq(mod(ROW[\"t1\"],2),0)");
     ASSERT_EQ(
         indexLookupJoinNode->lookupSource()->tableHandle()->connectorId(),
         kTestIndexConnectorName);
     testSerde(plan);
   }
 
-  // with mix join conditions.
+  // with join conditions and filter.
   for (const auto joinType : {core::JoinType::kLeft, core::JoinType::kInner}) {
     auto plan = PlanBuilder(planNodeIdGenerator, pool_.get())
                     .values({left})
@@ -296,21 +413,28 @@ TEST_P(IndexLookupJoinTest, planNodeAndSerde) {
                         {"t0"},
                         {"u0"},
                         indexTableScan,
-                        {"contains(t3, u0)", "u1 between 10 AND t1"},
-                        /*includeMatchColumn=*/false,
+                        {"contains(t3, u0)"},
+                        /*filter=*/"u1 % 2 = 0 AND t2 > 5",
+                        /*hasMarker=*/false,
                         {"t0", "u1", "t2", "t1"},
                         joinType)
                     .planNode();
     auto indexLookupJoinNode =
         std::dynamic_pointer_cast<const core::IndexLookupJoinNode>(plan);
-    ASSERT_EQ(indexLookupJoinNode->joinConditions().size(), 2);
+    ASSERT_EQ(indexLookupJoinNode->joinConditions().size(), 1);
+    ASSERT_EQ(
+        indexLookupJoinNode->needsIndexSplit(), GetParam().needsIndexSplit);
+    ASSERT_NE(indexLookupJoinNode->filter(), nullptr);
+    ASSERT_EQ(
+        indexLookupJoinNode->filter()->toString(),
+        "and(eq(mod(ROW[\"u1\"],2),0),gt(ROW[\"t2\"],5))");
     ASSERT_EQ(
         indexLookupJoinNode->lookupSource()->tableHandle()->connectorId(),
         kTestIndexConnectorName);
     testSerde(plan);
   }
 
-  // with has match column.
+  // with filter and marker for left join.
   {
     auto plan = PlanBuilder(planNodeIdGenerator, pool_.get())
                     .values({left})
@@ -318,14 +442,50 @@ TEST_P(IndexLookupJoinTest, planNodeAndSerde) {
                         {"t0"},
                         {"u0"},
                         indexTableScan,
-                        {"contains(t3, u0)", "u1 between 10 AND t1"},
-                        /*includeMatchColumn=*/true,
+                        {"u1 between 10 AND t1"},
+                        /*filter=*/"t2 < u2",
+                        /*hasMarker=*/true,
                         {"t0", "u1", "t2", "t1", "match"},
                         core::JoinType::kLeft)
                     .planNode();
     auto indexLookupJoinNode =
         std::dynamic_pointer_cast<const core::IndexLookupJoinNode>(plan);
-    ASSERT_EQ(indexLookupJoinNode->joinConditions().size(), 2);
+    ASSERT_EQ(indexLookupJoinNode->joinConditions().size(), 1);
+    ASSERT_EQ(
+        indexLookupJoinNode->needsIndexSplit(), GetParam().needsIndexSplit);
+    ASSERT_NE(indexLookupJoinNode->filter(), nullptr);
+    ASSERT_EQ(
+        indexLookupJoinNode->filter()->toString(),
+        "lt(ROW[\"t2\"],ROW[\"u2\"])");
+    ASSERT_TRUE(indexLookupJoinNode->hasMarker());
+    ASSERT_EQ(
+        indexLookupJoinNode->lookupSource()->tableHandle()->connectorId(),
+        kTestIndexConnectorName);
+    testSerde(plan);
+  }
+
+  // with complex filter expression.
+  {
+    auto plan = PlanBuilder(planNodeIdGenerator, pool_.get())
+                    .values({left})
+                    .startIndexLookupJoin()
+                    .leftKeys({"t0"})
+                    .rightKeys({"u0"})
+                    .indexSource(indexTableScan)
+                    .filter("(t1 + u1) * 2 > 100 OR t2 = u2")
+                    .outputLayout({"t0", "u1", "t2", "t1"})
+                    .joinType(core::JoinType::kInner)
+                    .endIndexLookupJoin()
+                    .planNode();
+    auto indexLookupJoinNode =
+        std::dynamic_pointer_cast<const core::IndexLookupJoinNode>(plan);
+    ASSERT_TRUE(indexLookupJoinNode->joinConditions().empty());
+    ASSERT_EQ(
+        indexLookupJoinNode->needsIndexSplit(), GetParam().needsIndexSplit);
+    ASSERT_NE(indexLookupJoinNode->filter(), nullptr);
+    ASSERT_EQ(
+        indexLookupJoinNode->filter()->toString(),
+        "or(gt(multiply(plus(ROW[\"t1\"],ROW[\"u1\"]),2),100),eq(ROW[\"t2\"],ROW[\"u2\"]))");
     ASSERT_EQ(
         indexLookupJoinNode->lookupSource()->tableHandle()->connectorId(),
         kTestIndexConnectorName);
@@ -337,14 +497,13 @@ TEST_P(IndexLookupJoinTest, planNodeAndSerde) {
     VELOX_ASSERT_USER_THROW(
         PlanBuilder(planNodeIdGenerator)
             .values({left})
-            .indexLookupJoin(
-                {"t0"},
-                {"u0"},
-                indexTableScan,
-                {},
-                /*includeMatchColumn=*/false,
-                {"t0", "u1", "t2", "t1"},
-                core::JoinType::kFull)
+            .startIndexLookupJoin()
+            .leftKeys({"t0"})
+            .rightKeys({"u0"})
+            .indexSource(indexTableScan)
+            .outputLayout({"t0", "u1", "t2", "t1"})
+            .joinType(core::JoinType::kFull)
+            .endIndexLookupJoin()
             .planNode(),
         "Unsupported index lookup join type FULL");
   }
@@ -354,13 +513,12 @@ TEST_P(IndexLookupJoinTest, planNodeAndSerde) {
     VELOX_ASSERT_USER_THROW(
         PlanBuilder(planNodeIdGenerator)
             .values({left})
-            .indexLookupJoin(
-                {"t0"},
-                {"u0"},
-                nonIndexTableScan,
-                {},
-                /*includeMatchColumn=*/false,
-                {"t0", "u1", "t2", "t1"})
+            .startIndexLookupJoin()
+            .leftKeys({"t0"})
+            .rightKeys({"u0"})
+            .indexSource(nonIndexTableScan)
+            .outputLayout({"t0", "u1", "t2", "t1"})
+            .endIndexLookupJoin()
             .planNode(),
         "The lookup table handle hive_table from connector test-hive doesn't support index lookup");
   }
@@ -370,13 +528,13 @@ TEST_P(IndexLookupJoinTest, planNodeAndSerde) {
     VELOX_ASSERT_THROW(
         PlanBuilder(planNodeIdGenerator)
             .values({left})
-            .indexLookupJoin(
-                {"t0", "t1"},
-                {"u0"},
-                indexTableScan,
-                {"contains(t4, u0)"},
-                /*includeMatchColumn=*/false,
-                {"t0", "u1", "t2", "t1"})
+            .startIndexLookupJoin()
+            .leftKeys({"t0", "t1"})
+            .rightKeys({"u0"})
+            .indexSource(indexTableScan)
+            .joinConditions({"contains(t4, u0)"})
+            .outputLayout({"t0", "u1", "t2", "t1"})
+            .endIndexLookupJoin()
             .planNode(),
         "The index lookup join node requires same number of join keys on left and right sides");
   }
@@ -386,19 +544,19 @@ TEST_P(IndexLookupJoinTest, planNodeAndSerde) {
     VELOX_ASSERT_THROW(
         PlanBuilder(planNodeIdGenerator)
             .values({left})
-            .indexLookupJoin(
-                {},
-                {},
-                indexTableScan,
-                {"contains(t4, u0)"},
-                /*includeMatchColumn=*/false,
-                {"t0", "u1", "t2", "t1"})
+            .startIndexLookupJoin()
+            .leftKeys({})
+            .rightKeys({})
+            .indexSource(indexTableScan)
+            .joinConditions({"contains(t4, u0)"})
+            .outputLayout({"t0", "u1", "t2", "t1"})
+            .endIndexLookupJoin()
             .planNode(),
         "The index lookup join node requires at least one join key");
   }
 }
 
-TEST_P(IndexLookupJoinTest, equalJoin) {
+TEST_P(IndexLookupJoinTest, DISABLED_equalJoin) {
   struct {
     std::vector<int> keyCardinalities;
     int numProbeBatches;
@@ -750,7 +908,7 @@ TEST_P(IndexLookupJoinTest, equalJoin) {
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
 
-    SequenceTableData tableData;
+    IndexTableData tableData;
     generateIndexTableData(testData.keyCardinalities, tableData, pool_);
     auto probeVectors = generateProbeInput(
         testData.numProbeBatches,
@@ -767,15 +925,15 @@ TEST_P(IndexLookupJoinTest, equalJoin) {
         createProbeFiles(probeVectors);
 
     createDuckDbTable("t", probeVectors);
-    createDuckDbTable("u", {tableData.tableData});
+    createDuckDbTable("u", {tableData.tableVectors});
 
     const auto indexTable = TestIndexTable::create(
         /*numEqualJoinKeys=*/3,
-        tableData.keyData,
-        tableData.valueData,
+        tableData.keyVectors,
+        tableData.valueVectors,
         *pool());
-    const auto indexTableHandle =
-        makeIndexTableHandle(indexTable, GetParam().asyncLookup);
+    const auto indexTableHandle = makeIndexTableHandle(
+        indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
     const auto indexScanNode = makeIndexScanNode(
         planNodeIdGenerator,
@@ -789,7 +947,8 @@ TEST_P(IndexLookupJoinTest, equalJoin) {
         {"t0", "t1", "t2"},
         {"u0", "u1", "u2"},
         {},
-        /*includeMatchColumn=*/false,
+        /*filter=*/"",
+        /*hasMarker=*/false,
         testData.joinType,
         testData.outputColumns);
     runLookupQuery(
@@ -799,6 +958,7 @@ TEST_P(IndexLookupJoinTest, equalJoin) {
         GetParam().serialExecution,
         32,
         GetParam().numPrefetches,
+        GetParam().needsIndexSplit,
         testData.duckDbVerifySql);
     if (testData.joinType != core::JoinType::kLeft) {
       continue;
@@ -809,12 +969,18 @@ TEST_P(IndexLookupJoinTest, equalJoin) {
         indexScanNode,
         {"t0", "t1", "t2"},
         {"u0", "u1", "u2"},
-        {},
-        /*includeMatchColumn=*/true,
+        /*joinConditions=*/{},
+        /*filter=*/"",
+        /*hasMarker=*/true,
         testData.joinType,
         testData.outputColumns);
     verifyResultWithMatchColumn(
-        plan, probeScanId, planWithMatchColumn, probeScanNodeId_, probeFiles);
+        plan,
+        probeScanId,
+        planWithMatchColumn,
+        probeScanNodeId_,
+        probeFiles,
+        GetParam().needsIndexSplit);
   }
 }
 
@@ -1221,7 +1387,7 @@ TEST_P(IndexLookupJoinTest, betweenJoinCondition) {
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
 
-    SequenceTableData tableData;
+    IndexTableData tableData;
     generateIndexTableData(testData.keyCardinalities, tableData, pool_);
     auto probeVectors = generateProbeInput(
         testData.numProbeBatches,
@@ -1240,15 +1406,15 @@ TEST_P(IndexLookupJoinTest, betweenJoinCondition) {
         createProbeFiles(probeVectors);
 
     createDuckDbTable("t", probeVectors);
-    createDuckDbTable("u", {tableData.tableData});
+    createDuckDbTable("u", {tableData.tableVectors});
 
     const auto indexTable = TestIndexTable::create(
         /*numEqualJoinKeys=*/2,
-        tableData.keyData,
-        tableData.valueData,
+        tableData.keyVectors,
+        tableData.valueVectors,
         *pool());
-    const auto indexTableHandle =
-        makeIndexTableHandle(indexTable, GetParam().asyncLookup);
+    const auto indexTableHandle = makeIndexTableHandle(
+        indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
     const auto indexScanNode = makeIndexScanNode(
         planNodeIdGenerator,
@@ -1262,7 +1428,8 @@ TEST_P(IndexLookupJoinTest, betweenJoinCondition) {
         {"t0", "t1"},
         {"u0", "u1"},
         {testData.betweenCondition},
-        /*includeMatchColumn=*/false,
+        /*filter=*/"",
+        /*hasMarker=*/false,
         testData.joinType,
         testData.outputColumns);
     runLookupQuery(
@@ -1272,6 +1439,7 @@ TEST_P(IndexLookupJoinTest, betweenJoinCondition) {
         GetParam().serialExecution,
         32,
         GetParam().numPrefetches,
+        GetParam().needsIndexSplit,
         testData.duckDbVerifySql);
     if (testData.joinType != core::JoinType::kLeft) {
       continue;
@@ -1283,11 +1451,17 @@ TEST_P(IndexLookupJoinTest, betweenJoinCondition) {
         {"t0", "t1"},
         {"u0", "u1"},
         {testData.betweenCondition},
-        /*includeMatchColumn=*/true,
+        /*filter=*/"",
+        /*hasMarker=*/true,
         testData.joinType,
         testData.outputColumns);
     verifyResultWithMatchColumn(
-        plan, probeScanId, planWithMatchColumn, probeScanNodeId_, probeFiles);
+        plan,
+        probeScanId,
+        planWithMatchColumn,
+        probeScanNodeId_,
+        probeFiles,
+        GetParam().needsIndexSplit);
   }
 }
 
@@ -1561,7 +1735,7 @@ TEST_P(IndexLookupJoinTest, inJoinCondition) {
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
 
-    SequenceTableData tableData;
+    IndexTableData tableData;
     generateIndexTableData(testData.keyCardinalities, tableData, pool_);
     auto probeVectors = generateProbeInput(
         testData.numProbeBatches,
@@ -1579,15 +1753,15 @@ TEST_P(IndexLookupJoinTest, inJoinCondition) {
         createProbeFiles(probeVectors);
 
     createDuckDbTable("t", probeVectors);
-    createDuckDbTable("u", {tableData.tableData});
+    createDuckDbTable("u", {tableData.tableVectors});
 
     const auto indexTable = TestIndexTable::create(
         /*numEqualJoinKeys=*/2,
-        tableData.keyData,
-        tableData.valueData,
+        tableData.keyVectors,
+        tableData.valueVectors,
         *pool());
-    const auto indexTableHandle =
-        makeIndexTableHandle(indexTable, GetParam().asyncLookup);
+    const auto indexTableHandle = makeIndexTableHandle(
+        indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
     const auto indexScanNode = makeIndexScanNode(
         planNodeIdGenerator,
@@ -1601,7 +1775,8 @@ TEST_P(IndexLookupJoinTest, inJoinCondition) {
         {"t0", "t1"},
         {"u0", "u1"},
         {testData.inCondition},
-        /*includeMatchColumn=*/false,
+        /*filter=*/"",
+        /*hasMarker=*/false,
         testData.joinType,
         testData.outputColumns);
     runLookupQuery(
@@ -1611,6 +1786,7 @@ TEST_P(IndexLookupJoinTest, inJoinCondition) {
         GetParam().serialExecution,
         32,
         GetParam().numPrefetches,
+        GetParam().needsIndexSplit,
         testData.duckDbVerifySql);
     if (testData.joinType != core::JoinType::kLeft) {
       continue;
@@ -1622,11 +1798,17 @@ TEST_P(IndexLookupJoinTest, inJoinCondition) {
         {"t0", "t1"},
         {"u0", "u1"},
         {testData.inCondition},
-        /*includeMatchColumn=*/true,
+        /*filter=*/"",
+        /*hasMarker=*/true,
         testData.joinType,
         testData.outputColumns);
     verifyResultWithMatchColumn(
-        plan, probeScanId, planWithMatchColumn, probeScanNodeId_, probeFiles);
+        plan,
+        probeScanId,
+        planWithMatchColumn,
+        probeScanNodeId_,
+        probeFiles,
+        GetParam().needsIndexSplit);
   }
 }
 
@@ -1702,7 +1884,7 @@ TEST_P(IndexLookupJoinTest, prefixKeysEqualJoin) {
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
 
-    SequenceTableData tableData;
+    IndexTableData tableData;
     generateIndexTableData(testData.keyCardinalities, tableData, pool_);
 
     // Generate probe vectors with only the prefix of keys
@@ -1726,15 +1908,15 @@ TEST_P(IndexLookupJoinTest, prefixKeysEqualJoin) {
         createProbeFiles(probeVectors);
 
     createDuckDbTable("t", probeVectors);
-    createDuckDbTable("u", {tableData.tableData});
+    createDuckDbTable("u", {tableData.tableVectors});
 
     const auto indexTable = TestIndexTable::create(
         /*numEqualJoinKeys=*/testData.numKeysToUse,
-        tableData.keyData,
-        tableData.valueData,
+        tableData.keyVectors,
+        tableData.valueVectors,
         *pool());
-    const auto indexTableHandle =
-        makeIndexTableHandle(indexTable, GetParam().asyncLookup);
+    const auto indexTableHandle = makeIndexTableHandle(
+        indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
     const auto indexScanNode = makeIndexScanNode(
         planNodeIdGenerator,
@@ -1756,7 +1938,8 @@ TEST_P(IndexLookupJoinTest, prefixKeysEqualJoin) {
         leftKeys,
         rightKeys,
         {},
-        /*includeMatchColumn=*/false,
+        /*filter=*/"",
+        /*hasMarker=*/false,
         testData.joinType,
         testData.outputColumns);
     runLookupQuery(
@@ -1766,6 +1949,7 @@ TEST_P(IndexLookupJoinTest, prefixKeysEqualJoin) {
         GetParam().serialExecution,
         32,
         GetParam().numPrefetches,
+        GetParam().needsIndexSplit,
         testData.duckDbVerifySql);
     if (testData.joinType != core::JoinType::kLeft) {
       continue;
@@ -1777,11 +1961,17 @@ TEST_P(IndexLookupJoinTest, prefixKeysEqualJoin) {
         leftKeys,
         rightKeys,
         {},
-        /*includeMatchColumn=*/true,
+        /*filter=*/"",
+        /*hasMarker=*/true,
         testData.joinType,
         testData.outputColumns);
     verifyResultWithMatchColumn(
-        plan, probeScanId, planWithMatchColumn, probeScanNodeId_, probeFiles);
+        plan,
+        probeScanId,
+        planWithMatchColumn,
+        probeScanNodeId_,
+        probeFiles,
+        GetParam().needsIndexSplit);
   }
 }
 
@@ -1852,7 +2042,7 @@ TEST_P(IndexLookupJoinTest, prefixKeysbetweenJoinCondition) {
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
 
-    SequenceTableData tableData;
+    IndexTableData tableData;
     generateIndexTableData(testData.keyCardinalities, tableData, pool_);
 
     auto probeVectors = generateProbeInput(
@@ -1872,15 +2062,15 @@ TEST_P(IndexLookupJoinTest, prefixKeysbetweenJoinCondition) {
         createProbeFiles(probeVectors);
 
     createDuckDbTable("t", probeVectors);
-    createDuckDbTable("u", {tableData.tableData});
+    createDuckDbTable("u", {tableData.tableVectors});
 
     const auto indexTable = TestIndexTable::create(
         /*numEqualJoinKeys=*/1,
-        tableData.keyData,
-        tableData.valueData,
+        tableData.keyVectors,
+        tableData.valueVectors,
         *pool());
-    const auto indexTableHandle =
-        makeIndexTableHandle(indexTable, GetParam().asyncLookup);
+    const auto indexTableHandle = makeIndexTableHandle(
+        indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
     const auto indexScanNode = makeIndexScanNode(
         planNodeIdGenerator,
@@ -1894,7 +2084,8 @@ TEST_P(IndexLookupJoinTest, prefixKeysbetweenJoinCondition) {
         {"t0"},
         {"u0"},
         {testData.betweenCondition},
-        /*includeMatchColumn=*/false,
+        /*filter=*/"",
+        /*hasMarker=*/false,
         testData.joinType,
         testData.outputColumns);
     runLookupQuery(
@@ -1904,6 +2095,7 @@ TEST_P(IndexLookupJoinTest, prefixKeysbetweenJoinCondition) {
         GetParam().serialExecution,
         32,
         GetParam().numPrefetches,
+        GetParam().needsIndexSplit,
         testData.duckDbVerifySql);
     if (testData.joinType != core::JoinType::kLeft) {
       continue;
@@ -1915,11 +2107,17 @@ TEST_P(IndexLookupJoinTest, prefixKeysbetweenJoinCondition) {
         {"t0"},
         {"u0"},
         {testData.betweenCondition},
-        /*includeMatchColumn=*/true,
+        /*filter=*/"",
+        /*hasMarker=*/true,
         testData.joinType,
         testData.outputColumns);
     verifyResultWithMatchColumn(
-        plan, probeScanId, planWithMatchColumn, probeScanNodeId_, probeFiles);
+        plan,
+        probeScanId,
+        planWithMatchColumn,
+        probeScanNodeId_,
+        probeFiles,
+        GetParam().needsIndexSplit);
   }
 }
 
@@ -1993,7 +2191,7 @@ TEST_P(IndexLookupJoinTest, prefixInJoinCondition) {
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
 
-    SequenceTableData tableData;
+    IndexTableData tableData;
     generateIndexTableData(testData.keyCardinalities, tableData, pool_);
     auto probeVectors = generateProbeInput(
         testData.numProbeBatches,
@@ -2011,15 +2209,15 @@ TEST_P(IndexLookupJoinTest, prefixInJoinCondition) {
         createProbeFiles(probeVectors);
 
     createDuckDbTable("t", probeVectors);
-    createDuckDbTable("u", {tableData.tableData});
+    createDuckDbTable("u", {tableData.tableVectors});
 
     const auto indexTable = TestIndexTable::create(
         /*numEqualJoinKeys=*/1,
-        tableData.keyData,
-        tableData.valueData,
+        tableData.keyVectors,
+        tableData.valueVectors,
         *pool());
-    const auto indexTableHandle =
-        makeIndexTableHandle(indexTable, GetParam().asyncLookup);
+    const auto indexTableHandle = makeIndexTableHandle(
+        indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
     const auto indexScanNode = makeIndexScanNode(
         planNodeIdGenerator,
@@ -2033,7 +2231,8 @@ TEST_P(IndexLookupJoinTest, prefixInJoinCondition) {
         {"t0"},
         {"u0"},
         {testData.inCondition},
-        /*includeMatchColumn=*/false,
+        /*filter=*/"",
+        /*hasMarker=*/false,
         testData.joinType,
         testData.outputColumns);
     runLookupQuery(
@@ -2043,6 +2242,7 @@ TEST_P(IndexLookupJoinTest, prefixInJoinCondition) {
         GetParam().serialExecution,
         32,
         GetParam().numPrefetches,
+        GetParam().needsIndexSplit,
         testData.duckDbVerifySql);
     if (testData.joinType != core::JoinType::kLeft) {
       continue;
@@ -2054,16 +2254,22 @@ TEST_P(IndexLookupJoinTest, prefixInJoinCondition) {
         {"t0"},
         {"u0"},
         {testData.inCondition},
-        /*includeMatchColumn=*/true,
+        /*filter=*/"",
+        /*hasMarker=*/true,
         testData.joinType,
         testData.outputColumns);
     verifyResultWithMatchColumn(
-        plan, probeScanId, planWithMatchColumn, probeScanNodeId_, probeFiles);
+        plan,
+        probeScanId,
+        planWithMatchColumn,
+        probeScanNodeId_,
+        probeFiles,
+        GetParam().needsIndexSplit);
   }
 }
 
 DEBUG_ONLY_TEST_P(IndexLookupJoinTest, connectorError) {
-  SequenceTableData tableData;
+  IndexTableData tableData;
   generateIndexTableData({100, 1, 1}, tableData, pool_);
   const std::vector<RowVectorPtr> probeVectors = generateProbeInput(
       20,
@@ -2091,9 +2297,12 @@ DEBUG_ONLY_TEST_P(IndexLookupJoinTest, connectorError) {
       }));
 
   const auto indexTable = TestIndexTable::create(
-      /*numEqualJoinKeys=*/3, tableData.keyData, tableData.valueData, *pool());
-  const auto indexTableHandle =
-      makeIndexTableHandle(indexTable, GetParam().asyncLookup);
+      /*numEqualJoinKeys=*/3,
+      tableData.keyVectors,
+      tableData.valueVectors,
+      *pool());
+  const auto indexTableHandle = makeIndexTableHandle(
+      indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   const auto indexScanNode = makeIndexScanNode(
       planNodeIdGenerator,
@@ -2107,7 +2316,8 @@ DEBUG_ONLY_TEST_P(IndexLookupJoinTest, connectorError) {
       {"t0", "t1", "t2"},
       {"u0", "u1", "u2"},
       {},
-      /*includeMatchColumn=*/false,
+      /*filter=*/"",
+      /*hasMarker=*/false,
       core::JoinType::kInner,
       {"u0", "u1", "u2", "t5"});
   VELOX_ASSERT_THROW(
@@ -2118,6 +2328,7 @@ DEBUG_ONLY_TEST_P(IndexLookupJoinTest, connectorError) {
           GetParam().serialExecution,
           100,
           GetParam().numPrefetches,
+          GetParam().needsIndexSplit,
           "SELECT u.c0, u.c1, t.c2, t.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2"),
       errorMsg);
 }
@@ -2127,7 +2338,7 @@ DEBUG_ONLY_TEST_P(IndexLookupJoinTest, prefetch) {
     // This test only works for async lookup.
     return;
   }
-  SequenceTableData tableData;
+  IndexTableData tableData;
   generateIndexTableData({100, 1, 1}, tableData, pool_);
   const int numProbeBatches{20};
   ASSERT_GT(numProbeBatches, GetParam().numPrefetches);
@@ -2145,7 +2356,7 @@ DEBUG_ONLY_TEST_P(IndexLookupJoinTest, prefetch) {
   std::vector<std::shared_ptr<TempFilePath>> probeFiles =
       createProbeFiles(probeVectors);
   createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", {tableData.tableData});
+  createDuckDbTable("u", {tableData.tableVectors});
 
   std::atomic_int lookupCount{0};
   folly::EventCount asyncLookupWait;
@@ -2160,9 +2371,12 @@ DEBUG_ONLY_TEST_P(IndexLookupJoinTest, prefetch) {
       }));
 
   const auto indexTable = TestIndexTable::create(
-      /*numEqualJoinKeys=*/3, tableData.keyData, tableData.valueData, *pool());
-  const auto indexTableHandle =
-      makeIndexTableHandle(indexTable, GetParam().asyncLookup);
+      /*numEqualJoinKeys=*/3,
+      tableData.keyVectors,
+      tableData.valueVectors,
+      *pool());
+  const auto indexTableHandle = makeIndexTableHandle(
+      indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   const auto indexScanNode = makeIndexScanNode(
       planNodeIdGenerator,
@@ -2176,7 +2390,8 @@ DEBUG_ONLY_TEST_P(IndexLookupJoinTest, prefetch) {
       {"t0", "t1", "t2"},
       {"u0", "u1", "u2"},
       {},
-      /*includeMatchColumn=*/false,
+      /*filter=*/"",
+      /*hasMarker=*/false,
       core::JoinType::kInner,
       {"u3", "t5"});
   std::thread queryThread([&] {
@@ -2187,6 +2402,7 @@ DEBUG_ONLY_TEST_P(IndexLookupJoinTest, prefetch) {
         GetParam().serialExecution,
         100,
         GetParam().numPrefetches,
+        GetParam().needsIndexSplit,
         "SELECT u.c3, t.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2");
   });
   while (lookupCount < 1 + GetParam().numPrefetches) {
@@ -2200,7 +2416,7 @@ DEBUG_ONLY_TEST_P(IndexLookupJoinTest, prefetch) {
 }
 
 TEST_P(IndexLookupJoinTest, outputBatchSizeWithInnerJoin) {
-  SequenceTableData tableData;
+  IndexTableData tableData;
   generateIndexTableData({3'000, 1, 1}, tableData, pool_);
 
   struct {
@@ -2256,15 +2472,15 @@ TEST_P(IndexLookupJoinTest, outputBatchSizeWithInnerJoin) {
         createProbeFiles(probeVectors);
 
     createDuckDbTable("t", probeVectors);
-    createDuckDbTable("u", {tableData.tableData});
+    createDuckDbTable("u", {tableData.tableVectors});
 
     const auto indexTable = TestIndexTable::create(
         /*numEqualJoinKeys=*/3,
-        tableData.keyData,
-        tableData.valueData,
+        tableData.keyVectors,
+        tableData.valueVectors,
         *pool());
-    const auto indexTableHandle =
-        makeIndexTableHandle(indexTable, GetParam().asyncLookup);
+    const auto indexTableHandle = makeIndexTableHandle(
+        indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
 
     const auto indexScanNode = makeIndexScanNode(
@@ -2279,29 +2495,36 @@ TEST_P(IndexLookupJoinTest, outputBatchSizeWithInnerJoin) {
         {"t0", "t1", "t2"},
         {"u0", "u1", "u2"},
         {},
-        /*includeMatchColumn=*/false,
+        /*filter=*/"",
+        /*hasMarker=*/false,
         core::JoinType::kInner,
         {"t4", "u5"});
-    const auto task =
-        AssertQueryBuilder(duckDbQueryRunner_)
-            .plan(plan)
-            .config(
-                core::QueryConfig::kIndexLookupJoinMaxPrefetchBatches,
-                std::to_string(GetParam().numPrefetches))
-            .config(
-                core::QueryConfig::kPreferredOutputBatchRows,
-                std::to_string(testData.maxBatchRows))
-            .config(
-                core::QueryConfig::kPreferredOutputBatchBytes,
-                std::to_string(1ULL << 30))
-            .config(
-                core::QueryConfig::kIndexLookupJoinSplitOutput,
-                testData.splitOutput ? "true" : "false")
-            .splits(probeScanNodeId_, makeHiveConnectorSplits(probeFiles))
-            .serialExecution(GetParam().serialExecution)
-            .barrierExecution(GetParam().serialExecution)
-            .assertResults(
-                "SELECT t.c4, u.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2");
+    AssertQueryBuilder queryBuilder(duckDbQueryRunner_);
+    queryBuilder.plan(plan)
+        .config(
+            core::QueryConfig::kIndexLookupJoinMaxPrefetchBatches,
+            std::to_string(GetParam().numPrefetches))
+        .config(
+            core::QueryConfig::kPreferredOutputBatchRows,
+            std::to_string(testData.maxBatchRows))
+        .config(
+            core::QueryConfig::kPreferredOutputBatchBytes,
+            std::to_string(1ULL << 30))
+        .config(
+            core::QueryConfig::kIndexLookupJoinSplitOutput,
+            testData.splitOutput ? "true" : "false")
+        .splits(probeScanNodeId_, makeHiveConnectorSplits(probeFiles))
+        .serialExecution(GetParam().serialExecution)
+        .barrierExecution(GetParam().serialExecution);
+    if (GetParam().needsIndexSplit) {
+      queryBuilder.split(
+          indexScanNodeId_,
+          Split(
+              std::make_shared<TestIndexConnectorSplit>(
+                  kTestIndexConnectorName)));
+    }
+    const auto task = queryBuilder.assertResults(
+        "SELECT t.c4, u.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2");
     ASSERT_EQ(
         toPlanStats(task->taskStats()).at(joinNodeId_).outputVectors,
         testData.numExpectedOutputBatch);
@@ -2309,7 +2532,7 @@ TEST_P(IndexLookupJoinTest, outputBatchSizeWithInnerJoin) {
 }
 
 TEST_P(IndexLookupJoinTest, outputBatchSizeWithLeftJoin) {
-  SequenceTableData tableData;
+  IndexTableData tableData;
   generateIndexTableData({3'000, 1, 1}, tableData, pool_);
 
   struct {
@@ -2365,15 +2588,15 @@ TEST_P(IndexLookupJoinTest, outputBatchSizeWithLeftJoin) {
         createProbeFiles(probeVectors);
 
     createDuckDbTable("t", probeVectors);
-    createDuckDbTable("u", {tableData.tableData});
+    createDuckDbTable("u", {tableData.tableVectors});
 
     const auto indexTable = TestIndexTable::create(
         /*numEqualJoinKeys=*/3,
-        tableData.keyData,
-        tableData.valueData,
+        tableData.keyVectors,
+        tableData.valueVectors,
         *pool());
-    const auto indexTableHandle =
-        makeIndexTableHandle(indexTable, GetParam().asyncLookup);
+    const auto indexTableHandle = makeIndexTableHandle(
+        indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
     const auto indexScanNode = makeIndexScanNode(
         planNodeIdGenerator,
@@ -2387,29 +2610,36 @@ TEST_P(IndexLookupJoinTest, outputBatchSizeWithLeftJoin) {
         {"t0", "t1", "t2"},
         {"u0", "u1", "u2"},
         {},
-        /*includeMatchColumn=*/false,
+        /*filter=*/"",
+        /*hasMarker=*/false,
         core::JoinType::kLeft,
         {"t4", "u5"});
-    const auto task =
-        AssertQueryBuilder(duckDbQueryRunner_)
-            .plan(plan)
-            .config(
-                core::QueryConfig::kIndexLookupJoinMaxPrefetchBatches,
-                std::to_string(GetParam().numPrefetches))
-            .config(
-                core::QueryConfig::kPreferredOutputBatchRows,
-                std::to_string(testData.maxBatchRows))
-            .config(
-                core::QueryConfig::kPreferredOutputBatchBytes,
-                std::to_string(1ULL << 30))
-            .config(
-                core::QueryConfig::kIndexLookupJoinSplitOutput,
-                testData.splitOutput ? "true" : "false")
-            .splits(probeScanNodeId_, makeHiveConnectorSplits(probeFiles))
-            .serialExecution(GetParam().serialExecution)
-            .barrierExecution(GetParam().serialExecution)
-            .assertResults(
-                "SELECT t.c4, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2");
+    AssertQueryBuilder queryBuilder(duckDbQueryRunner_);
+    queryBuilder.plan(plan)
+        .config(
+            core::QueryConfig::kIndexLookupJoinMaxPrefetchBatches,
+            std::to_string(GetParam().numPrefetches))
+        .config(
+            core::QueryConfig::kPreferredOutputBatchRows,
+            std::to_string(testData.maxBatchRows))
+        .config(
+            core::QueryConfig::kPreferredOutputBatchBytes,
+            std::to_string(1ULL << 30))
+        .config(
+            core::QueryConfig::kIndexLookupJoinSplitOutput,
+            testData.splitOutput ? "true" : "false")
+        .splits(probeScanNodeId_, makeHiveConnectorSplits(probeFiles))
+        .serialExecution(GetParam().serialExecution)
+        .barrierExecution(GetParam().serialExecution);
+    if (GetParam().needsIndexSplit) {
+      queryBuilder.split(
+          indexScanNodeId_,
+          Split(
+              std::make_shared<TestIndexConnectorSplit>(
+                  kTestIndexConnectorName)));
+    }
+    const auto task = queryBuilder.assertResults(
+        "SELECT t.c4, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2");
     ASSERT_EQ(
         toPlanStats(task->taskStats()).at(joinNodeId_).outputVectors,
         testData.numExpectedOutputBatch);
@@ -2420,21 +2650,28 @@ TEST_P(IndexLookupJoinTest, outputBatchSizeWithLeftJoin) {
         {"t0", "t1", "t2"},
         {"u0", "u1", "u2"},
         {},
-        /*includeMatchColumn=*/true,
+        /*filter=*/"",
+        /*hasMarker=*/true,
         core::JoinType::kLeft,
         {"t4", "u5"});
     verifyResultWithMatchColumn(
-        plan, probeScanId, planWithMatchColumn, probeScanNodeId_, probeFiles);
+        plan,
+        probeScanId,
+        planWithMatchColumn,
+        probeScanNodeId_,
+        probeFiles,
+        GetParam().needsIndexSplit);
   }
 }
 
-DEBUG_ONLY_TEST_P(IndexLookupJoinTest, runtimeStats) {
-  SequenceTableData tableData;
+DEBUG_ONLY_TEST_P(IndexLookupJoinTest, statsSplitter) {
+  IndexTableData tableData;
   generateIndexTableData({100, 1, 1}, tableData, pool_);
   const int numProbeBatches{2};
+  const int batchSize{100};
   const std::vector<RowVectorPtr> probeVectors = generateProbeInput(
       numProbeBatches,
-      100,
+      batchSize,
       1,
       tableData,
       pool_,
@@ -2446,18 +2683,22 @@ DEBUG_ONLY_TEST_P(IndexLookupJoinTest, runtimeStats) {
   std::vector<std::shared_ptr<TempFilePath>> probeFiles =
       createProbeFiles(probeVectors);
   createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", {tableData.tableData});
+  createDuckDbTable("u", {tableData.tableVectors});
 
+  // Add a small delay in async lookup to ensure timing stats are captured.
   SCOPED_TESTVALUE_SET(
       "facebook::velox::exec::test::TestIndexSource::ResultIterator::asyncLookup",
       std::function<void(void*)>([&](void*) {
-        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // NOLINT
+        std::this_thread::sleep_for(std::chrono::milliseconds(10)); // NOLINT
       }));
 
   const auto indexTable = TestIndexTable::create(
-      /*numEqualJoinKeys=*/3, tableData.keyData, tableData.valueData, *pool());
-  const auto indexTableHandle =
-      makeIndexTableHandle(indexTable, GetParam().asyncLookup);
+      /*numEqualJoinKeys=*/3,
+      tableData.keyVectors,
+      tableData.valueVectors,
+      *pool());
+  const auto indexTableHandle = makeIndexTableHandle(
+      indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   const auto indexScanNode = makeIndexScanNode(
       planNodeIdGenerator,
@@ -2471,7 +2712,8 @@ DEBUG_ONLY_TEST_P(IndexLookupJoinTest, runtimeStats) {
       {"t0", "t1", "t2"},
       {"u0", "u1", "u2"},
       {},
-      /*includeMatchColumn=*/false,
+      /*filter=*/"",
+      /*hasMarker=*/false,
       core::JoinType::kInner,
       {"u3", "t5"});
   auto task = runLookupQuery(
@@ -2481,50 +2723,58 @@ DEBUG_ONLY_TEST_P(IndexLookupJoinTest, runtimeStats) {
       GetParam().serialExecution,
       100,
       0,
+      GetParam().needsIndexSplit,
       "SELECT u.c3, t.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2");
 
   auto taskStats = toPlanStats(task->taskStats());
-  auto& operatorStats = taskStats.at(joinNodeId_);
-  ASSERT_EQ(operatorStats.backgroundTiming.count, numProbeBatches);
-  ASSERT_GT(operatorStats.backgroundTiming.cpuNanos, 0);
-  ASSERT_GT(operatorStats.backgroundTiming.wallNanos, 0);
-  auto runtimeStats = operatorStats.customStats;
-  ASSERT_EQ(
-      runtimeStats.at(IndexLookupJoin::kConnectorLookupWallTime).count,
-      numProbeBatches);
-  ASSERT_GT(runtimeStats.at(IndexLookupJoin::kConnectorLookupWallTime).sum, 0);
-  ASSERT_EQ(
-      runtimeStats.at(IndexLookupJoin::kClientLookupWaitWallTime).count,
-      numProbeBatches);
-  ASSERT_GT(runtimeStats.at(IndexLookupJoin::kClientLookupWaitWallTime).sum, 0);
-  ASSERT_EQ(
-      runtimeStats.at(IndexLookupJoin::kConnectorResultPrepareTime).count,
-      numProbeBatches);
-  ASSERT_GT(
-      runtimeStats.at(IndexLookupJoin::kConnectorResultPrepareTime).sum, 0);
-  ASSERT_EQ(runtimeStats.count(IndexLookupJoin::kClientRequestProcessTime), 0);
-  ASSERT_EQ(runtimeStats.count(IndexLookupJoin::kClientResultProcessTime), 0);
-  ASSERT_EQ(runtimeStats.count(IndexLookupJoin::kClientLookupResultSize), 0);
-  ASSERT_EQ(runtimeStats.count(IndexLookupJoin::kClientLookupResultRawSize), 0);
-  ASSERT_THAT(
-      operatorStats.toString(true, true),
-      testing::MatchesRegex(".*Runtime stats.*connectorLookupWallNanos:.*"));
-  ASSERT_THAT(
-      operatorStats.toString(true, true),
-      testing::MatchesRegex(".*Runtime stats.*clientlookupWaitWallNanos.*"));
-  ASSERT_THAT(
-      operatorStats.toString(true, true),
-      testing::MatchesRegex(
-          ".*Runtime stats.*connectorResultPrepareCpuNanos.*"));
+
+  // Verify that both the IndexLookupJoin node and IndexSource node have stats.
+  ASSERT_GT(taskStats.count(joinNodeId_), 0);
+  ASSERT_GT(taskStats.count(indexScanNodeId_), 0);
+
+  const auto& joinStats = taskStats.at(joinNodeId_);
+  const auto& indexSourceStats = taskStats.at(indexScanNodeId_);
+
+  EXPECT_GT(joinStats.inputRows, 0);
+  EXPECT_GT(joinStats.outputRows, 0);
+
+  EXPECT_GT(indexSourceStats.outputRows, 0);
+  EXPECT_EQ(indexSourceStats.outputRows, joinStats.outputRows);
+
+  EXPECT_GT(indexSourceStats.inputRows, 0);
+  EXPECT_GT(indexSourceStats.inputBytes, 0);
+  EXPECT_EQ(indexSourceStats.inputRows, joinStats.inputRows);
+
+  EXPECT_GT(indexSourceStats.addInputTiming.count, 0);
+
+  EXPECT_GT(
+      indexSourceStats.customStats.count(
+          std::string(IndexLookupJoin::kConnectorLookupWallTime)),
+      0);
+  EXPECT_GT(
+      indexSourceStats.customStats
+          .at(std::string(IndexLookupJoin::kConnectorLookupWallTime))
+          .sum,
+      0);
+
+  // backgroundTiming should be cleared from join stats (moved to IndexSource).
+  EXPECT_EQ(joinStats.backgroundTiming.count, 0);
+  EXPECT_EQ(joinStats.backgroundTiming.cpuNanos, 0);
+  EXPECT_EQ(joinStats.backgroundTiming.wallNanos, 0);
 }
 
-TEST_P(IndexLookupJoinTest, barrier) {
-  SequenceTableData tableData;
+/// Verifies that the probe-side scan operator's inputBytes/outputBytes are not
+/// inflated with index lookup bytes. IndexLookupJoin uses a custom stat writer
+/// in getOutput() to redirect index-side lazy loading stats to separate names,
+/// so Driver::processLazyIoStats() only transfers probe-side stats to the scan.
+TEST_P(IndexLookupJoinTest, scanStatsNotInflated) {
+  IndexTableData tableData;
   generateIndexTableData({100, 1, 1}, tableData, pool_);
-  const int numProbeSplits{5};
-  const auto probeVectors = generateProbeInput(
-      numProbeSplits,
-      256,
+  const int numProbeBatches{2};
+  const int batchSize{100};
+  const std::vector<RowVectorPtr> probeVectors = generateProbeInput(
+      numProbeBatches,
+      batchSize,
       1,
       tableData,
       pool_,
@@ -2536,12 +2786,15 @@ TEST_P(IndexLookupJoinTest, barrier) {
   std::vector<std::shared_ptr<TempFilePath>> probeFiles =
       createProbeFiles(probeVectors);
   createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", {tableData.tableData});
+  createDuckDbTable("u", {tableData.tableVectors});
 
   const auto indexTable = TestIndexTable::create(
-      /*numEqualJoinKeys=*/3, tableData.keyData, tableData.valueData, *pool());
-  const auto indexTableHandle =
-      makeIndexTableHandle(indexTable, GetParam().asyncLookup);
+      /*numEqualJoinKeys=*/3,
+      tableData.keyVectors,
+      tableData.valueVectors,
+      *pool());
+  const auto indexTableHandle = makeIndexTableHandle(
+      indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   const auto indexScanNode = makeIndexScanNode(
       planNodeIdGenerator,
@@ -2555,236 +2808,130 @@ TEST_P(IndexLookupJoinTest, barrier) {
       {"t0", "t1", "t2"},
       {"u0", "u1", "u2"},
       {},
-      /*includeMatchColumn=*/false,
+      /*filter=*/"",
+      /*hasMarker=*/false,
       core::JoinType::kInner,
       {"u3", "t5"});
+  auto task = runLookupQuery(
+      plan,
+      probeFiles,
+      GetParam().serialExecution,
+      GetParam().serialExecution,
+      100,
+      0,
+      GetParam().needsIndexSplit,
+      "SELECT u.c3, t.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2");
 
-  struct {
-    int numPrefetches;
-    bool barrierExecution;
-
-    std::string debugString() const {
-      return fmt::format(
-          "numPrefetches {}, barrierExecution {}",
-          numPrefetches,
-          barrierExecution);
-    }
-  } testSettings[] = {
-      {0, true},
-      {0, false},
-      {1, true},
-      {1, false},
-      {4, true},
-      {4, false},
-      {256, true},
-      {256, false}};
+  auto taskStats = toPlanStats(task->taskStats());
 
-  for (const auto& testData : testSettings) {
-    SCOPED_TRACE(testData.debugString());
-    auto task = runLookupQuery(
-        plan,
-        probeFiles,
-        true,
-        testData.barrierExecution,
-        32,
-        testData.numPrefetches,
-        "SELECT u.c3, t.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2");
+  ASSERT_GT(taskStats.count(probeScanNodeId_), 0);
+  const auto& scanStats = taskStats.at(probeScanNodeId_);
+
+  EXPECT_GT(scanStats.inputRows, 0);
+  EXPECT_GT(scanStats.inputBytes, 0);
+  EXPECT_EQ(scanStats.inputBytes, scanStats.outputBytes);
+
+  // Verify that lazy loading stats are NOT present on the join node.
+  // Probe-side lazy stats accumulate in every non-scan operator's
+  // runtimeStats when lazy vectors are loaded. processLazyIoStats transfers
+  // timing deltas to the scan but doesn't erase the accumulated stats.
+  // For most operators this is harmless — the stats just sit in runtimeStats.
+  // But IndexLookupJoin's splitStats copies combinedStats to create the join
+  // node stats, so we must explicitly erase them to avoid exposing residual
+  // lazy stats on the join node.
+  const auto& joinStats = taskStats.at(joinNodeId_);
+  EXPECT_EQ(
+      joinStats.customStats.count(std::string(LazyVector::kInputBytes)), 0);
+}
 
-    const auto taskStats = task->taskStats();
-    ASSERT_EQ(
-        taskStats.numBarriers, testData.barrierExecution ? numProbeSplits : 0);
-    ASSERT_EQ(taskStats.numFinishedSplits, numProbeSplits);
+/// Verifies that IndexSource stats report rows BEFORE the join filter is
+/// applied, while IndexLookupJoin stats report rows AFTER the filter.
+DEBUG_ONLY_TEST_P(IndexLookupJoinTest, statsSplitterWithFilter) {
+  // Skip serial execution tests for simplicity - the stats behavior is the
+  // same.
+  if (GetParam().serialExecution || GetParam().hasNullKeys) {
+    return;
   }
-}
 
-TEST_P(IndexLookupJoinTest, nullKeys) {
-  SequenceTableData tableData;
+  IndexTableData tableData;
   generateIndexTableData({100, 1, 1}, tableData, pool_);
-  const int numProbeSplits{5};
-  const int probeBatchSize{256};
-  const auto probeVectors = generateProbeInput(
-      numProbeSplits,
-      probeBatchSize,
+  const int numProbeBatches{2};
+  const int batchSize{100};
+  const std::vector<RowVectorPtr> probeVectors = generateProbeInput(
+      numProbeBatches,
+      batchSize,
       1,
       tableData,
       pool_,
       {"t0", "t1", "t2"},
-      /*hasNullKeys=*/true,
+      /*hasNullKeys=*/false,
       {},
       {},
-      /*equalMatchPct=*/100);
-  // Set some probe key vector to all nulls to trigger the case that entire
-  // probe input is skipped.
-  for (int i = 0; i < numProbeSplits; i += 2) {
-    for (int row = 0; row < probeBatchSize; ++row) {
-      probeVectors[i]->childAt(i % keyType_->size())->setNull(row, true);
-    }
-  }
+      100);
   std::vector<std::shared_ptr<TempFilePath>> probeFiles =
       createProbeFiles(probeVectors);
   createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", {tableData.tableData});
+  createDuckDbTable("u", {tableData.tableVectors});
+
+  // Add a small delay in async lookup to ensure timing stats are captured.
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::test::TestIndexSource::ResultIterator::asyncLookup",
+      std::function<void(void*)>([&](void*) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(10)); // NOLINT
+      }));
 
   const auto indexTable = TestIndexTable::create(
-      /*numEqualJoinKeys=*/3, tableData.keyData, tableData.valueData, *pool());
-  const auto indexTableHandle =
-      makeIndexTableHandle(indexTable, GetParam().asyncLookup);
+      /*numEqualJoinKeys=*/3,
+      tableData.keyVectors,
+      tableData.valueVectors,
+      *pool());
+  const auto indexTableHandle = makeIndexTableHandle(
+      indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-      columnHandles;
   const auto indexScanNode = makeIndexScanNode(
       planNodeIdGenerator,
       indexTableHandle,
       makeScanOutputType({"u0", "u1", "u2", "u3", "u5"}),
       makeIndexColumnHandles({"u0", "u1", "u2", "u3", "u5"}));
 
-  const auto innerPlan = makeLookupPlan(
+  // Add a filter that should filter out approximately half the rows.
+  // The filter "u3 % 2 = 0" will keep only even values of u3.
+  auto plan = makeLookupPlan(
       planNodeIdGenerator,
       indexScanNode,
       {"t0", "t1", "t2"},
       {"u0", "u1", "u2"},
       {},
-      /*includeMatchColumn=*/false,
+      /*filter=*/"u3 % 2 = 0",
+      /*hasMarker=*/false,
       core::JoinType::kInner,
       {"u3", "t5"});
-
-  runLookupQuery(
-      innerPlan,
-      probeFiles,
-      true,
-      true,
-      32,
-      GetParam().numPrefetches,
-      "SELECT u.c3, t.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2");
-
-  const auto leftPlan = makeLookupPlan(
-      planNodeIdGenerator,
-      indexScanNode,
-      {"t0", "t1", "t2"},
-      {"u0", "u1", "u2"},
-      {},
-      /*includeMatchColumn=*/false,
-      core::JoinType::kLeft,
-      {"u3", "t5"});
-
-  runLookupQuery(
-      leftPlan,
-      probeFiles,
-      true,
-      true,
-      32,
-      GetParam().numPrefetches,
-      "SELECT u.c3, t.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2");
-
-  const auto probeScanId = probeScanNodeId_;
-  auto planWithMatchColumn = makeLookupPlan(
-      planNodeIdGenerator,
-      indexScanNode,
-      {"t0", "t1", "t2"},
-      {"u0", "u1", "u2"},
-      {},
-      /*includeMatchColumn=*/true,
-      core::JoinType::kLeft,
-      {"u3", "t5"});
-  verifyResultWithMatchColumn(
-      leftPlan, probeScanId, planWithMatchColumn, probeScanNodeId_, probeFiles);
-}
-
-TEST_P(IndexLookupJoinTest, joinFuzzer) {
-  SequenceTableData tableData;
-  generateIndexTableData({1024, 1, 1}, tableData, pool_);
-  const auto probeVectors = generateProbeInput(
-      50, 256, 1, tableData, pool_, {"t0", "t1", "t2"}, GetParam().hasNullKeys);
-  std::vector<std::shared_ptr<TempFilePath>> probeFiles =
-      createProbeFiles(probeVectors);
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", {tableData.tableData});
-
-  const auto indexTable = TestIndexTable::create(
-      /*numEqualJoinKeys=*/1, tableData.keyData, tableData.valueData, *pool());
-  const auto indexTableHandle =
-      makeIndexTableHandle(indexTable, GetParam().asyncLookup);
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto scanOutput = tableType_->names();
-  std::random_device rd;
-  std::mt19937 g(rd());
-  std::shuffle(scanOutput.begin(), scanOutput.end(), g);
-  const auto indexScanNode = makeIndexScanNode(
-      planNodeIdGenerator,
-      indexTableHandle,
-      makeScanOutputType(scanOutput),
-      makeIndexColumnHandles(scanOutput));
-
-  auto plan = makeLookupPlan(
-      planNodeIdGenerator,
-      indexScanNode,
-      {"t0"},
-      {"u0"},
-      {"contains(t4, u1)", "u2 between t1 and t2"},
-      /*includeMatchColumn=*/false,
-      core::JoinType::kInner,
-      {"u0", "u4", "t0", "t1", "t4"});
-  runLookupQuery(
+  auto task = runLookupQuery(
       plan,
       probeFiles,
       GetParam().serialExecution,
       GetParam().serialExecution,
-      32,
-      GetParam().numPrefetches,
-      "SELECT u.c0, u.c1, u.c2, u.c3, u.c4, u.c5, t.c0, t.c1, t.c2, t.c3, t.c4, t.c5 FROM t, u WHERE t.c0 = u.c0 AND array_contains(t.c4, u.c1) AND u.c2 BETWEEN t.c1 AND t.c2");
-}
+      100,
+      0,
+      GetParam().needsIndexSplit,
+      "SELECT u.c3, t.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2 AND u.c3 % 2 = 0");
 
-TEST_P(IndexLookupJoinTest, tableRowsWithDuplicateKeys) {
-  SequenceTableData tableData;
-  generateIndexTableData({10, 1, 1}, tableData, pool_);
-  for (int i = 0; i < keyType_->size(); ++i) {
-    tableData.keyData->childAt(i) = makeFlatVector<int64_t>(
-        tableData.keyData->childAt(i)->size(),
-        [](auto /*unused*/) { return 1; });
-    tableData.tableData->childAt(i) = makeFlatVector<int64_t>(
-        tableData.keyData->childAt(i)->size(),
-        [](auto /*unused*/) { return 1; });
-  }
+  auto taskStats = toPlanStats(task->taskStats());
 
-  auto probeVectors = generateProbeInput(
-      4, 32, 1, tableData, pool_, {"t0", "t1", "t2"}, false, {}, {}, 100);
-  std::vector<std::shared_ptr<TempFilePath>> probeFiles =
-      createProbeFiles(probeVectors);
+  ASSERT_GT(taskStats.count(joinNodeId_), 0);
+  ASSERT_GT(taskStats.count(indexScanNodeId_), 0);
 
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", {tableData.tableData});
+  const auto& joinStats = taskStats.at(joinNodeId_);
+  const auto& indexSourceStats = taskStats.at(indexScanNodeId_);
 
-  const auto indexTable = TestIndexTable::create(
-      /*numEqualJoinKeys=*/3, tableData.keyData, tableData.valueData, *pool());
-  const auto indexTableHandle =
-      makeIndexTableHandle(indexTable, GetParam().asyncLookup);
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto scanOutput = tableType_->names();
-  const auto indexScanNode = makeIndexScanNode(
-      planNodeIdGenerator,
-      indexTableHandle,
-      makeScanOutputType(scanOutput),
-      makeIndexColumnHandles(scanOutput));
+  EXPECT_GT(joinStats.inputRows, 0);
+  EXPECT_GT(joinStats.outputRows, 0);
+  EXPECT_GT(indexSourceStats.outputRows, 0);
 
-  auto plan = makeLookupPlan(
-      planNodeIdGenerator,
-      indexScanNode,
-      {"t0", "t1", "t2"},
-      {"u0", "u1", "u2"},
-      {},
-      /*includeMatchColumn=*/false,
-      core::JoinType::kInner,
-      scanOutput);
-  runLookupQuery(
-      plan,
-      probeFiles,
-      GetParam().serialExecution,
-      GetParam().serialExecution,
-      32,
-      GetParam().numPrefetches,
-      "SELECT u.c0, u.c1, u.c2, u.c3, u.c4, u.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1 AND u.c2 = t.c2");
+  // IndexSource reports rows before the filter; IndexLookupJoin reports after.
+  EXPECT_GT(indexSourceStats.outputRows, joinStats.outputRows);
 }
+
 } // namespace
 
 VELOX_INSTANTIATE_TEST_SUITE_P(
@@ -2793,10 +2940,11 @@ VELOX_INSTANTIATE_TEST_SUITE_P(
     testing::ValuesIn(IndexLookupJoinTest::getTestParams()),
     [](const testing::TestParamInfo<TestParam>& info) {
       return fmt::format(
-          "{}_{}prefetches_{}_{}",
+          "{}_{}prefetches_{}_{}_{}",
           info.param.asyncLookup ? "async" : "sync",
           info.param.numPrefetches,
           info.param.serialExecution ? "serial" : "parallel",
-          info.param.hasNullKeys ? "nullKeys" : "noNullKeys");
+          info.param.hasNullKeys ? "nullKeys" : "noNullKeys",
+          info.param.needsIndexSplit ? "needsIndexSplit" : "noSplit");
     });
-} // namespace fecebook::velox::exec::test
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/IndexLookupJoinTestExtra.cpp b/velox/exec/tests/IndexLookupJoinTestExtra.cpp
new file mode 100644
index 00000000000..6ab7347dfa4
--- /dev/null
+++ b/velox/exec/tests/IndexLookupJoinTestExtra.cpp
@@ -0,0 +1,2186 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "fmt/format.h"
+#include "folly/synchronization/EventCount.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest-matchers.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TestValue.h"
+#include "velox/connectors/Connector.h"
+#include "velox/connectors/ConnectorRegistry.h"
+#include "velox/core/PlanNode.h"
+#include "velox/exec/IndexLookupJoin.h"
+#include "velox/exec/OutputBufferManager.h"
+#include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/IndexLookupJoinTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/TestIndexStorageConnector.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::common::testutil;
+
+namespace facebook::velox::exec::test {
+namespace {
+struct TestParam {
+  bool asyncLookup;
+  int32_t numPrefetches;
+  bool serialExecution;
+  bool hasNullKeys;
+  bool needsIndexSplit;
+
+  TestParam(
+      bool _asyncLookup,
+      int32_t _numPrefetches,
+      bool _serialExecution,
+      bool _hasNullKeys,
+      bool _needsIndexSplit = false)
+      : asyncLookup(_asyncLookup),
+        numPrefetches(_numPrefetches),
+        serialExecution(_serialExecution),
+        hasNullKeys(_hasNullKeys),
+        needsIndexSplit(_needsIndexSplit) {}
+
+  std::string toString() const {
+    return fmt::format(
+        "asyncLookup={}, numPrefetches={}, serialExecution={}, hasNullKeys={}, needsIndexSplit={}",
+        asyncLookup,
+        numPrefetches,
+        serialExecution,
+        hasNullKeys,
+        needsIndexSplit);
+  }
+};
+
+class IndexLookupJoinTest : public IndexLookupJoinTestBase,
+                            public testing::WithParamInterface<TestParam> {
+ public:
+  static std::vector<TestParam> getTestParams() {
+    std::vector<TestParam> testParams;
+    for (bool asyncLookup : {false, true}) {
+      for (int numPrefetches : {0, 3}) {
+        for (bool serialExecution : {false, true}) {
+          for (bool hasNullKeys : {false, true}) {
+            for (bool needsIndexSplit : {false, true}) {
+              // Serial execution doesn't support index split as it requires
+              // single-threaded execution which is incompatible with the
+              // split-based parallelism used by index lookup join.
+              if (serialExecution && needsIndexSplit) {
+                continue;
+              }
+              testParams.emplace_back(
+                  asyncLookup,
+                  numPrefetches,
+                  serialExecution,
+                  hasNullKeys,
+                  needsIndexSplit);
+            }
+          }
+        }
+      }
+    }
+    return testParams;
+  }
+
+ protected:
+  void SetUp() override {
+    HiveConnectorTestBase::SetUp();
+    core::PlanNode::registerSerDe();
+    connector::hive::HiveColumnHandle::registerSerDe();
+    Type::registerSerDe();
+    core::ITypedExpr::registerSerDe();
+    TestIndexConnectorFactory::registerConnector(connectorCpuExecutor_.get());
+
+    keyType_ = ROW({"u0", "u1", "u2"}, {BIGINT(), BIGINT(), BIGINT()});
+    valueType_ = ROW({"u3", "u4", "u5"}, {BIGINT(), BIGINT(), VARCHAR()});
+    tableType_ = concat(keyType_, valueType_);
+    probeType_ = ROW(
+        {"t0", "t1", "t2", "t3", "t4", "t5"},
+        {BIGINT(), BIGINT(), BIGINT(), BIGINT(), ARRAY(BIGINT()), VARCHAR()});
+  }
+
+  void TearDown() override {
+    connector::ConnectorRegistry::global().erase(kTestIndexConnectorName);
+    HiveConnectorTestBase::TearDown();
+  }
+
+  void testSerde(const core::PlanNodePtr& plan) {
+    auto serialized = plan->serialize();
+    auto copy = ISerializable::deserialize<core::PlanNode>(serialized, pool());
+    ASSERT_EQ(plan->toString(true, true), copy->toString(true, true));
+  }
+
+  // Makes index table handle with the specified index table and async lookup
+  // flag.
+  static std::shared_ptr<TestIndexTableHandle> makeIndexTableHandle(
+      const std::shared_ptr<TestIndexTable>& indexTable,
+      bool asyncLookup,
+      bool needsIndexSplit = false) {
+    return std::make_shared<TestIndexTableHandle>(
+        kTestIndexConnectorName, indexTable, asyncLookup, needsIndexSplit);
+  }
+
+  static connector::ColumnHandleMap makeIndexColumnHandles(
+      const std::vector<std::string>& names) {
+    connector::ColumnHandleMap handles;
+    for (const auto& name : names) {
+      handles.emplace(name, std::make_shared<TestIndexColumnHandle>(name));
+    }
+
+    return handles;
+  }
+
+  const std::unique_ptr<folly::CPUThreadPoolExecutor> connectorCpuExecutor_{
+      std::make_unique<folly::CPUThreadPoolExecutor>(128)};
+};
+
+// Verifies that when splitOutput_ is false, trailing input rows that have no
+// lookup matches are included in the current output batch rather than being
+// emitted in a separate batch via produceRemainingOutputForLeftJoin.
+TEST_P(IndexLookupJoinTest, leftJoinTrailingMissesWithNoSplitOutput) {
+  IndexTableData tableData;
+  generateIndexTableData({500, 1, 1}, tableData, pool_);
+
+  struct {
+    int numProbeBatches;
+    int numRowsPerProbeBatch;
+    int maxBatchRows;
+    int equalMatchPct;
+    bool splitOutput;
+
+    std::string debugString() const {
+      return fmt::format(
+          "numProbeBatches: {}, numRowsPerProbeBatch: {}, maxBatchRows: {}, equalMatchPct: {}, splitOutput: {}",
+          numProbeBatches,
+          numRowsPerProbeBatch,
+          maxBatchRows,
+          equalMatchPct,
+          splitOutput);
+    }
+  } testSettings[] = {
+      // With splitOutput=false, trailing misses should be folded into the
+      // current batch. With splitOutput=true, they are emitted separately.
+      {10, 100, 200, 10, false},
+      {10, 100, 200, 50, false},
+      {10, 100, 200, 2, false},
+      {1, 500, 1000, 10, false},
+      {1, 500, 1000, 50, false},
+      {10, 50, 200, 10, false},
+      // With no matches, all rows are misses.
+      {10, 100, 200, 0, false},
+      // 100% matches - no trailing misses exist.
+      {10, 100, 200, 100, false},
+      // splitOutput=true as comparison.
+      {10, 100, 200, 10, true},
+      {10, 100, 200, 50, true},
+      {10, 100, 200, 0, true},
+  };
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    const auto probeVectors = generateProbeInput(
+        testData.numProbeBatches,
+        testData.numRowsPerProbeBatch,
+        1,
+        tableData,
+        pool_,
+        {"t0", "t1", "t2"},
+        GetParam().hasNullKeys,
+        {},
+        {},
+        testData.equalMatchPct);
+    std::vector<std::shared_ptr<TempFilePath>> probeFiles =
+        createProbeFiles(probeVectors);
+
+    createDuckDbTable("t", probeVectors);
+    createDuckDbTable("u", {tableData.tableVectors});
+
+    const auto indexTable = TestIndexTable::create(
+        /*numEqualJoinKeys=*/3,
+        tableData.keyVectors,
+        tableData.valueVectors,
+        *pool());
+    const auto indexTableHandle = makeIndexTableHandle(
+        indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    const auto indexScanNode = makeIndexScanNode(
+        planNodeIdGenerator,
+        indexTableHandle,
+        makeScanOutputType({"u0", "u1", "u2", "u5"}),
+        makeIndexColumnHandles({"u0", "u1", "u2", "u5"}));
+
+    auto plan = makeLookupPlan(
+        planNodeIdGenerator,
+        indexScanNode,
+        {"t0", "t1", "t2"},
+        {"u0", "u1", "u2"},
+        {},
+        /*filter=*/"",
+        /*hasMarker=*/false,
+        core::JoinType::kLeft,
+        {"t4", "u5"});
+    AssertQueryBuilder queryBuilder(duckDbQueryRunner_);
+    queryBuilder.plan(plan)
+        .config(
+            core::QueryConfig::kIndexLookupJoinMaxPrefetchBatches,
+            std::to_string(GetParam().numPrefetches))
+        .config(
+            core::QueryConfig::kPreferredOutputBatchRows,
+            std::to_string(testData.maxBatchRows))
+        .config(
+            core::QueryConfig::kPreferredOutputBatchBytes,
+            std::to_string(1ULL << 30))
+        .config(
+            core::QueryConfig::kIndexLookupJoinSplitOutput,
+            testData.splitOutput ? "true" : "false")
+        .splits(probeScanNodeId_, makeHiveConnectorSplits(probeFiles))
+        .serialExecution(GetParam().serialExecution)
+        .barrierExecution(GetParam().serialExecution);
+    if (GetParam().needsIndexSplit) {
+      queryBuilder.split(
+          indexScanNodeId_,
+          Split(
+              std::make_shared<TestIndexConnectorSplit>(
+                  kTestIndexConnectorName)));
+    }
+    const auto task = queryBuilder.assertResults(
+        "SELECT t.c4, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2");
+
+    // Verify match column correctness for all cases.
+    const auto probeScanId = probeScanNodeId_;
+    auto planWithMatchColumn = makeLookupPlan(
+        planNodeIdGenerator,
+        indexScanNode,
+        {"t0", "t1", "t2"},
+        {"u0", "u1", "u2"},
+        {},
+        /*filter=*/"",
+        /*hasMarker=*/true,
+        core::JoinType::kLeft,
+        {"t4", "u5"});
+    verifyResultWithMatchColumn(
+        plan,
+        probeScanId,
+        planWithMatchColumn,
+        probeScanNodeId_,
+        probeFiles,
+        GetParam().needsIndexSplit);
+  }
+}
+
+DEBUG_ONLY_TEST_P(IndexLookupJoinTest, runtimeStats) {
+  IndexTableData tableData;
+  generateIndexTableData({100, 1, 1}, tableData, pool_);
+  const int numProbeBatches{2};
+  const std::vector<RowVectorPtr> probeVectors = generateProbeInput(
+      numProbeBatches,
+      100,
+      1,
+      tableData,
+      pool_,
+      {"t0", "t1", "t2"},
+      GetParam().hasNullKeys,
+      {},
+      {},
+      100);
+  std::vector<std::shared_ptr<TempFilePath>> probeFiles =
+      createProbeFiles(probeVectors);
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", {tableData.tableVectors});
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::test::TestIndexSource::ResultIterator::asyncLookup",
+      std::function<void(void*)>([&](void*) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // NOLINT
+      }));
+
+  const auto indexTable = TestIndexTable::create(
+      /*numEqualJoinKeys=*/3,
+      tableData.keyVectors,
+      tableData.valueVectors,
+      *pool());
+  const auto indexTableHandle = makeIndexTableHandle(
+      indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto indexScanNode = makeIndexScanNode(
+      planNodeIdGenerator,
+      indexTableHandle,
+      makeScanOutputType({"u0", "u1", "u2", "u3", "u5"}),
+      makeIndexColumnHandles({"u0", "u1", "u2", "u3", "u5"}));
+
+  auto plan = makeLookupPlan(
+      planNodeIdGenerator,
+      indexScanNode,
+      {"t0", "t1", "t2"},
+      {"u0", "u1", "u2"},
+      {},
+      /*filter=*/"",
+      /*hasMarker=*/false,
+      core::JoinType::kInner,
+      {"u3", "t5"});
+  auto task = runLookupQuery(
+      plan,
+      probeFiles,
+      GetParam().serialExecution,
+      GetParam().serialExecution,
+      100,
+      0,
+      GetParam().needsIndexSplit,
+      "SELECT u.c3, t.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2");
+
+  auto taskStats = toPlanStats(task->taskStats());
+
+  // Check IndexSource stats - lookup timing should be here, not on join stats.
+  auto& indexSourceStats = taskStats.at(indexScanNodeId_);
+  ASSERT_EQ(indexSourceStats.addInputTiming.count, numProbeBatches);
+  ASSERT_GT(indexSourceStats.addInputTiming.cpuNanos, 0);
+  ASSERT_GT(indexSourceStats.addInputTiming.wallNanos, 0);
+
+  // Verify that backgroundTiming was cleared from join stats (moved to
+  // IndexSource to avoid double counting).
+  auto& operatorStats = taskStats.at(joinNodeId_);
+  ASSERT_EQ(operatorStats.backgroundTiming.count, 0);
+  ASSERT_EQ(operatorStats.backgroundTiming.cpuNanos, 0);
+  ASSERT_EQ(operatorStats.backgroundTiming.wallNanos, 0);
+
+  // Check runtime stats are present on IndexSource.
+  auto runtimeStats = indexSourceStats.customStats;
+  ASSERT_EQ(
+      runtimeStats.at(std::string(IndexLookupJoin::kConnectorLookupWallTime))
+          .count,
+      numProbeBatches);
+  ASSERT_GT(
+      runtimeStats.at(std::string(IndexLookupJoin::kConnectorLookupWallTime))
+          .sum,
+      0);
+  ASSERT_EQ(
+      runtimeStats.at(std::string(IndexLookupJoin::kClientLookupWaitWallTime))
+          .count,
+      numProbeBatches);
+  ASSERT_GT(
+      runtimeStats.at(std::string(IndexLookupJoin::kClientLookupWaitWallTime))
+          .sum,
+      0);
+  ASSERT_EQ(
+      runtimeStats.at(std::string(IndexLookupJoin::kConnectorResultPrepareTime))
+          .count,
+      numProbeBatches);
+  ASSERT_GT(
+      runtimeStats.at(std::string(IndexLookupJoin::kConnectorResultPrepareTime))
+          .sum,
+      0);
+  ASSERT_EQ(
+      runtimeStats.count(
+          std::string(IndexLookupJoin::kClientRequestProcessTime)),
+      0);
+  ASSERT_EQ(
+      runtimeStats.count(
+          std::string(IndexLookupJoin::kClientResultProcessTime)),
+      0);
+  ASSERT_EQ(
+      runtimeStats.count(std::string(IndexLookupJoin::kClientLookupResultSize)),
+      0);
+  ASSERT_EQ(
+      runtimeStats.count(
+          std::string(IndexLookupJoin::kClientLookupResultRawSize)),
+      0);
+  ASSERT_THAT(
+      indexSourceStats.toString(true, true),
+      testing::MatchesRegex(".*Runtime stats.*connectorLookupWallNanos:.*"));
+  ASSERT_THAT(
+      indexSourceStats.toString(true, true),
+      testing::MatchesRegex(".*Runtime stats.*clientlookupWaitWallNanos.*"));
+  ASSERT_THAT(
+      indexSourceStats.toString(true, true),
+      testing::MatchesRegex(
+          ".*Runtime stats.*connectorResultPrepareCpuNanos.*"));
+}
+
+/// Verifies that IndexLookupJoin's StatsSplitter correctly reports separate
+/// operator stats for both the IndexLookupJoin node and the IndexSource node.
+/// This ensures IndexSource appears with its own CPU/Scheduled/Output stats
+/// in the query plan visualization.
+DEBUG_ONLY_TEST_P(IndexLookupJoinTest, statsSplitter) {
+  IndexTableData tableData;
+  generateIndexTableData({100, 1, 1}, tableData, pool_);
+  const int numProbeBatches{2};
+  const int batchSize{100};
+  const std::vector<RowVectorPtr> probeVectors = generateProbeInput(
+      numProbeBatches,
+      batchSize,
+      1,
+      tableData,
+      pool_,
+      {"t0", "t1", "t2"},
+      GetParam().hasNullKeys,
+      {},
+      {},
+      100);
+  std::vector<std::shared_ptr<TempFilePath>> probeFiles =
+      createProbeFiles(probeVectors);
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", {tableData.tableVectors});
+
+  // Add a small delay in async lookup to ensure timing stats are captured.
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::test::TestIndexSource::ResultIterator::asyncLookup",
+      std::function<void(void*)>([&](void*) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(10)); // NOLINT
+      }));
+
+  const auto indexTable = TestIndexTable::create(
+      /*numEqualJoinKeys=*/3,
+      tableData.keyVectors,
+      tableData.valueVectors,
+      *pool());
+  const auto indexTableHandle = makeIndexTableHandle(
+      indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto indexScanNode = makeIndexScanNode(
+      planNodeIdGenerator,
+      indexTableHandle,
+      makeScanOutputType({"u0", "u1", "u2", "u3", "u5"}),
+      makeIndexColumnHandles({"u0", "u1", "u2", "u3", "u5"}));
+
+  auto plan = makeLookupPlan(
+      planNodeIdGenerator,
+      indexScanNode,
+      {"t0", "t1", "t2"},
+      {"u0", "u1", "u2"},
+      {},
+      /*filter=*/"",
+      /*hasMarker=*/false,
+      core::JoinType::kInner,
+      {"u3", "t5"});
+  auto task = runLookupQuery(
+      plan,
+      probeFiles,
+      GetParam().serialExecution,
+      GetParam().serialExecution,
+      100,
+      0,
+      GetParam().needsIndexSplit,
+      "SELECT u.c3, t.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2");
+
+  auto taskStats = toPlanStats(task->taskStats());
+
+  // Verify that both the IndexLookupJoin node and IndexSource node have stats.
+  ASSERT_TRUE(taskStats.count(joinNodeId_) > 0)
+      << "IndexLookupJoin node stats missing";
+  ASSERT_TRUE(taskStats.count(indexScanNodeId_) > 0)
+      << "IndexSource node stats missing";
+
+  const auto& joinStats = taskStats.at(joinNodeId_);
+  const auto& indexSourceStats = taskStats.at(indexScanNodeId_);
+
+  // Verify join stats have input from probe side.
+  EXPECT_GT(joinStats.inputRows, 0);
+  EXPECT_GT(joinStats.outputRows, 0);
+
+  // Verify IndexSource stats have output positions (the lookup results).
+  EXPECT_GT(indexSourceStats.outputRows, 0);
+  EXPECT_EQ(indexSourceStats.outputRows, joinStats.outputRows);
+
+  // Verify IndexSource stats have input positions (lookup keys sent to
+  // connector).
+  EXPECT_GT(indexSourceStats.inputRows, 0);
+  EXPECT_GT(indexSourceStats.inputBytes, 0);
+  // For inner join without filter, input rows should match join input rows
+  // (all probe rows are sent as lookup keys).
+  EXPECT_EQ(indexSourceStats.inputRows, joinStats.inputRows);
+
+  // Verify IndexSource stats have timing from backgroundTiming (lookup time).
+  // The addInputTiming should contain the lookup wall/cpu time.
+  EXPECT_GT(indexSourceStats.addInputTiming.count, 0);
+
+  // Verify runtime stats are present on IndexSource (connector metrics).
+  // These include connector lookup wall time, etc.
+  EXPECT_TRUE(
+      indexSourceStats.customStats.count(
+          std::string(IndexLookupJoin::kConnectorLookupWallTime)) > 0)
+      << "IndexSource should have connector lookup wall time";
+  EXPECT_GT(
+      indexSourceStats.customStats
+          .at(std::string(IndexLookupJoin::kConnectorLookupWallTime))
+          .sum,
+      0);
+
+  // Verify that backgroundTiming was cleared from join stats (moved to
+  // IndexSource to avoid double counting).
+  EXPECT_EQ(joinStats.backgroundTiming.count, 0);
+  EXPECT_EQ(joinStats.backgroundTiming.cpuNanos, 0);
+  EXPECT_EQ(joinStats.backgroundTiming.wallNanos, 0);
+
+  // Verify that index source stats are present in the raw operator-level
+  // Verify index source stats are copied into the operator's runtimeStats
+  // with the "indexSource." prefix for task-level stats visibility.
+  const auto rawTaskStats = task->taskStats();
+  bool foundJoinOp = false;
+  for (const auto& pipeline : rawTaskStats.pipelineStats) {
+    for (const auto& opStats : pipeline.operatorStats) {
+      if (opStats.operatorType == "IndexLookupJoin") {
+        foundJoinOp = true;
+        EXPECT_TRUE(opStats.runtimeStats.count(
+            fmt::format(
+                "indexSource.{}", IndexLookupJoin::kConnectorLookupWallTime)))
+            << "IndexLookupJoin operator runtimeStats should contain index "
+               "source stats for task-level stats reporting";
+        break;
+      }
+    }
+    if (foundJoinOp) {
+      break;
+    }
+  }
+  EXPECT_TRUE(foundJoinOp) << "IndexLookupJoin operator not found in raw stats";
+
+  // After splitStats (via toPlanStats above), the join node's customStats
+  // should NOT contain index source stats — they belong to IndexSource.
+  EXPECT_EQ(
+      joinStats.customStats.count(
+          std::string(IndexLookupJoin::kConnectorLookupWallTime)),
+      0)
+      << "Join node should not have index source stats after splitStats";
+}
+
+/// Verifies that IndexSource stats report rows BEFORE the join filter is
+/// applied, while IndexLookupJoin stats report rows AFTER the filter.
+DEBUG_ONLY_TEST_P(IndexLookupJoinTest, statsSplitterWithFilter) {
+  // Skip serial execution tests for simplicity - the stats behavior is the
+  // same.
+  if (GetParam().serialExecution || GetParam().hasNullKeys) {
+    return;
+  }
+
+  IndexTableData tableData;
+  generateIndexTableData({100, 1, 1}, tableData, pool_);
+  const int numProbeBatches{2};
+  const int batchSize{100};
+  const std::vector<RowVectorPtr> probeVectors = generateProbeInput(
+      numProbeBatches,
+      batchSize,
+      1,
+      tableData,
+      pool_,
+      {"t0", "t1", "t2"},
+      /*hasNullKeys=*/false,
+      {},
+      {},
+      100);
+  std::vector<std::shared_ptr<TempFilePath>> probeFiles =
+      createProbeFiles(probeVectors);
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", {tableData.tableVectors});
+
+  // Add a small delay in async lookup to ensure timing stats are captured.
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::test::TestIndexSource::ResultIterator::asyncLookup",
+      std::function<void(void*)>([&](void*) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(10)); // NOLINT
+      }));
+
+  const auto indexTable = TestIndexTable::create(
+      /*numEqualJoinKeys=*/3,
+      tableData.keyVectors,
+      tableData.valueVectors,
+      *pool());
+  const auto indexTableHandle = makeIndexTableHandle(
+      indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto indexScanNode = makeIndexScanNode(
+      planNodeIdGenerator,
+      indexTableHandle,
+      makeScanOutputType({"u0", "u1", "u2", "u3", "u5"}),
+      makeIndexColumnHandles({"u0", "u1", "u2", "u3", "u5"}));
+
+  // Add a filter that should filter out approximately half the rows.
+  // The filter "u3 % 2 = 0" will keep only even values of u3.
+  auto plan = makeLookupPlan(
+      planNodeIdGenerator,
+      indexScanNode,
+      {"t0", "t1", "t2"},
+      {"u0", "u1", "u2"},
+      {},
+      /*filter=*/"u3 % 2 = 0",
+      /*hasMarker=*/false,
+      core::JoinType::kInner,
+      {"u3", "t5"});
+  auto task = runLookupQuery(
+      plan,
+      probeFiles,
+      GetParam().serialExecution,
+      GetParam().serialExecution,
+      100,
+      0,
+      GetParam().needsIndexSplit,
+      "SELECT u.c3, t.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2 AND u.c3 % 2 = 0");
+
+  auto taskStats = toPlanStats(task->taskStats());
+
+  // Verify that both the IndexLookupJoin node and IndexSource node have stats.
+  ASSERT_TRUE(taskStats.count(joinNodeId_) > 0)
+      << "IndexLookupJoin node stats missing";
+  ASSERT_TRUE(taskStats.count(indexScanNodeId_) > 0)
+      << "IndexSource node stats missing";
+
+  const auto& joinStats = taskStats.at(joinNodeId_);
+  const auto& indexSourceStats = taskStats.at(indexScanNodeId_);
+
+  // Verify join stats have input from probe side.
+  EXPECT_GT(joinStats.inputRows, 0);
+  EXPECT_GT(joinStats.outputRows, 0);
+
+  // Verify IndexSource stats have output positions (rows before filter).
+  EXPECT_GT(indexSourceStats.outputRows, 0);
+
+  // KEY ASSERTION: IndexSource should have MORE rows than IndexLookupJoin
+  // because IndexSource reports rows BEFORE the filter ("u3 % 2 = 0") is
+  // applied.
+  EXPECT_GT(indexSourceStats.outputRows, joinStats.outputRows)
+      << "IndexSource should report more rows (before filter) than "
+      << "IndexLookupJoin (after filter)";
+}
+
+TEST_P(IndexLookupJoinTest, DISABLED_barrier) {
+  if (GetParam().needsIndexSplit) {
+    return;
+  }
+  IndexTableData tableData;
+  generateIndexTableData({100, 1, 1}, tableData, pool_);
+  const int numProbeSplits{5};
+  const auto probeVectors = generateProbeInput(
+      numProbeSplits,
+      256,
+      1,
+      tableData,
+      pool_,
+      {"t0", "t1", "t2"},
+      GetParam().hasNullKeys,
+      {},
+      {},
+      100);
+  std::vector<std::shared_ptr<TempFilePath>> probeFiles =
+      createProbeFiles(probeVectors);
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", {tableData.tableVectors});
+
+  const auto indexTable = TestIndexTable::create(
+      /*numEqualJoinKeys=*/3,
+      tableData.keyVectors,
+      tableData.valueVectors,
+      *pool());
+  const auto indexTableHandle = makeIndexTableHandle(
+      indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto indexScanNode = makeIndexScanNode(
+      planNodeIdGenerator,
+      indexTableHandle,
+      makeScanOutputType({"u0", "u1", "u2", "u3", "u5"}),
+      makeIndexColumnHandles({"u0", "u1", "u2", "u3", "u5"}));
+
+  auto plan = makeLookupPlan(
+      planNodeIdGenerator,
+      indexScanNode,
+      {"t0", "t1", "t2"},
+      {"u0", "u1", "u2"},
+      {},
+      /*filter=*/"",
+      /*hasMarker=*/false,
+      core::JoinType::kInner,
+      {"u3", "t5"});
+
+  struct {
+    int numPrefetches;
+    bool barrierExecution;
+    bool serialExecution;
+
+    std::string debugString() const {
+      return fmt::format(
+          "numPrefetches {}, barrierExecution {}, serialExecution {}",
+          numPrefetches,
+          barrierExecution,
+          serialExecution);
+    }
+  } testSettings[] = {
+      {0, false, false},
+      {0, false, true},
+      {1, true, true},
+      {1, false, true},
+      {4, true, true},
+      {4, false, true},
+      {256, true, true},
+      {256, false, true},
+      {0, true, false},
+      {0, false, false},
+      {1, true, false},
+      {1, false, false},
+      {4, true, false},
+      {4, false, false},
+      {256, true, false},
+      {256, false, false},
+  };
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    auto task = runLookupQuery(
+        plan,
+        probeFiles,
+        testData.serialExecution,
+        testData.barrierExecution,
+        32,
+        testData.numPrefetches,
+        GetParam().needsIndexSplit,
+        "SELECT u.c3, t.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2");
+
+    const auto taskStats = task->taskStats();
+    ASSERT_EQ(
+        taskStats.numBarriers, testData.barrierExecution ? numProbeSplits : 0);
+    ASSERT_EQ(taskStats.numFinishedSplits, numProbeSplits);
+  }
+}
+
+TEST_P(IndexLookupJoinTest, nullKeys) {
+  IndexTableData tableData;
+  generateIndexTableData({100, 1, 1}, tableData, pool_);
+  const int numProbeSplits{5};
+  const int probeBatchSize{256};
+  const auto probeVectors = generateProbeInput(
+      numProbeSplits,
+      probeBatchSize,
+      1,
+      tableData,
+      pool_,
+      {"t0", "t1", "t2"},
+      /*hasNullKeys=*/true,
+      {},
+      {},
+      /*equalMatchPct=*/100);
+  // Set some probe key vector to all nulls to trigger the case that entire
+  // probe input is skipped.
+  for (int i = 0; i < numProbeSplits; i += 2) {
+    for (int row = 0; row < probeBatchSize; ++row) {
+      probeVectors[i]->childAt(i % keyType_->size())->setNull(row, true);
+    }
+  }
+  std::vector<std::shared_ptr<TempFilePath>> probeFiles =
+      createProbeFiles(probeVectors);
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", {tableData.tableVectors});
+
+  const auto indexTable = TestIndexTable::create(
+      /*numEqualJoinKeys=*/3,
+      tableData.keyVectors,
+      tableData.valueVectors,
+      *pool());
+  const auto indexTableHandle = makeIndexTableHandle(
+      indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
+      columnHandles;
+  const auto indexScanNode = makeIndexScanNode(
+      planNodeIdGenerator,
+      indexTableHandle,
+      makeScanOutputType({"u0", "u1", "u2", "u3", "u5"}),
+      makeIndexColumnHandles({"u0", "u1", "u2", "u3", "u5"}));
+
+  const auto innerPlan = makeLookupPlan(
+      planNodeIdGenerator,
+      indexScanNode,
+      {"t0", "t1", "t2"},
+      {"u0", "u1", "u2"},
+      {},
+      /*filter=*/"",
+      /*hasMarker=*/false,
+      core::JoinType::kInner,
+      {"u3", "t5"});
+
+  runLookupQuery(
+      innerPlan,
+      probeFiles,
+      /*serialExecution=*/GetParam().serialExecution,
+      /*barrierExecution=*/GetParam().serialExecution,
+      32,
+      GetParam().numPrefetches,
+      GetParam().needsIndexSplit,
+      "SELECT u.c3, t.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2");
+
+  const auto leftPlan = makeLookupPlan(
+      planNodeIdGenerator,
+      indexScanNode,
+      {"t0", "t1", "t2"},
+      {"u0", "u1", "u2"},
+      {},
+      /*filter=*/"",
+      /*hasMarker=*/false,
+      core::JoinType::kLeft,
+      {"u3", "t5"});
+
+  runLookupQuery(
+      leftPlan,
+      probeFiles,
+      /*serialExecution=*/GetParam().serialExecution,
+      /*barrierExecution=*/GetParam().serialExecution,
+      32,
+      GetParam().numPrefetches,
+      GetParam().needsIndexSplit,
+      "SELECT u.c3, t.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2");
+
+  const auto probeScanId = probeScanNodeId_;
+  auto planWithMatchColumn = makeLookupPlan(
+      planNodeIdGenerator,
+      indexScanNode,
+      {"t0", "t1", "t2"},
+      {"u0", "u1", "u2"},
+      {},
+      /*filter=*/"",
+      /*hasMarker=*/true,
+      core::JoinType::kLeft,
+      {"u3", "t5"});
+  verifyResultWithMatchColumn(
+      leftPlan,
+      probeScanId,
+      planWithMatchColumn,
+      probeScanNodeId_,
+      probeFiles,
+      GetParam().needsIndexSplit);
+}
+
+TEST_P(IndexLookupJoinTest, joinFuzzer) {
+  IndexTableData tableData;
+  generateIndexTableData({1024, 1, 1}, tableData, pool_);
+  const auto probeVectors = generateProbeInput(
+      50, 256, 1, tableData, pool_, {"t0", "t1", "t2"}, GetParam().hasNullKeys);
+  std::vector<std::shared_ptr<TempFilePath>> probeFiles =
+      createProbeFiles(probeVectors);
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", {tableData.tableVectors});
+
+  const auto indexTable = TestIndexTable::create(
+      /*numEqualJoinKeys=*/1,
+      tableData.keyVectors,
+      tableData.valueVectors,
+      *pool());
+  const auto indexTableHandle = makeIndexTableHandle(
+      indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto scanOutput = tableType_->names();
+  std::random_device rd;
+  std::mt19937 g(rd());
+  std::shuffle(scanOutput.begin(), scanOutput.end(), g);
+  const auto indexScanNode = makeIndexScanNode(
+      planNodeIdGenerator,
+      indexTableHandle,
+      makeScanOutputType(scanOutput),
+      makeIndexColumnHandles(scanOutput));
+
+  auto plan = makeLookupPlan(
+      planNodeIdGenerator,
+      indexScanNode,
+      {"t0"},
+      {"u0"},
+      {"contains(t4, u1)", "u2 between t1 and t2"},
+      /*filter=*/"",
+      /*hasMarker=*/false,
+      core::JoinType::kInner,
+      {"u0", "u4", "t0", "t1", "t4"});
+  runLookupQuery(
+      plan,
+      probeFiles,
+      GetParam().serialExecution,
+      GetParam().serialExecution,
+      32,
+      GetParam().numPrefetches,
+      GetParam().needsIndexSplit,
+      "SELECT u.c0, u.c1, u.c2, u.c3, u.c4, u.c5, t.c0, t.c1, t.c2, t.c3, t.c4, t.c5 FROM t, u WHERE t.c0 = u.c0 AND array_contains(t.c4, u.c1) AND u.c2 BETWEEN t.c1 AND t.c2");
+}
+
+TEST_P(IndexLookupJoinTest, tableRowsWithDuplicateKeys) {
+  IndexTableData tableData;
+  generateIndexTableData({10, 1, 1}, tableData, pool_);
+  for (int i = 0; i < keyType_->size(); ++i) {
+    tableData.keyVectors->childAt(i) = makeFlatVector<int64_t>(
+        tableData.keyVectors->childAt(i)->size(),
+        [](auto /*unused*/) { return 1; });
+    tableData.tableVectors->childAt(i) = makeFlatVector<int64_t>(
+        tableData.keyVectors->childAt(i)->size(),
+        [](auto /*unused*/) { return 1; });
+  }
+
+  auto probeVectors = generateProbeInput(
+      4, 32, 1, tableData, pool_, {"t0", "t1", "t2"}, false, {}, {}, 100);
+  std::vector<std::shared_ptr<TempFilePath>> probeFiles =
+      createProbeFiles(probeVectors);
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", {tableData.tableVectors});
+
+  const auto indexTable = TestIndexTable::create(
+      /*numEqualJoinKeys=*/3,
+      tableData.keyVectors,
+      tableData.valueVectors,
+      *pool());
+  const auto indexTableHandle = makeIndexTableHandle(
+      indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto scanOutput = tableType_->names();
+  const auto indexScanNode = makeIndexScanNode(
+      planNodeIdGenerator,
+      indexTableHandle,
+      makeScanOutputType(scanOutput),
+      makeIndexColumnHandles(scanOutput));
+
+  auto plan = makeLookupPlan(
+      planNodeIdGenerator,
+      indexScanNode,
+      {"t0", "t1", "t2"},
+      {"u0", "u1", "u2"},
+      {},
+      /*filter=*/"",
+      /*hasMarker=*/false,
+      core::JoinType::kInner,
+      scanOutput);
+  runLookupQuery(
+      plan,
+      probeFiles,
+      GetParam().serialExecution,
+      GetParam().serialExecution,
+      32,
+      GetParam().numPrefetches,
+      GetParam().needsIndexSplit,
+      "SELECT u.c0, u.c1, u.c2, u.c3, u.c4, u.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1 AND u.c2 = t.c2");
+}
+
+TEST_P(IndexLookupJoinTest, withFilter) {
+  struct {
+    std::vector<int> keyCardinalities;
+    int numProbeBatches;
+    int numRowsPerProbeBatch;
+    int matchPct;
+    std::vector<std::string> scanOutputColumns;
+    std::vector<std::string> outputColumns;
+    core::JoinType joinType;
+    std::string filter;
+    std::string duckDbVerifySql;
+
+    std::string debugString() const {
+      return fmt::format(
+          "keyCardinalities: {}, numProbeBatches: {}, numRowsPerProbeBatch: {}, matchPct: {}, "
+          "scanOutputColumns: {}, outputColumns: {}, joinType: {}, filter: {}, "
+          "duckDbVerifySql: {}",
+          folly::join(",", keyCardinalities),
+          numProbeBatches,
+          numRowsPerProbeBatch,
+          matchPct,
+          folly::join(",", scanOutputColumns),
+          folly::join(",", outputColumns),
+          core::JoinTypeName::toName(joinType),
+          filter,
+          duckDbVerifySql);
+    }
+  } testSettings[] = {
+      // Inner join with filter on probe side
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kInner,
+       "t3 % 2 = 0",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c3 % 2 = 0"},
+      // Inner join with filter always be true.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kInner,
+       "t3 = t3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c3 = t.c3"},
+      // Inner join with filter always be false.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kInner,
+       "t3 != t3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c3 != t.c3"},
+
+      // Inner join with filter on lookup side
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kInner,
+       "u3 % 2 = 0",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t, u WHERE t.c0 = u.c0 AND u.c3 % 2 = 0"},
+      // Inner join with filter always be true.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kInner,
+       "u3 = u3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t, u WHERE t.c0 = u.c0 AND u.c3 = u.c3"},
+      // Inner join with filter always be false.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kInner,
+       "u3 != u3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t, u WHERE t.c0 = u.c0 AND u.c3 != u.c3"},
+
+      // Inner join with filter on both side
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kInner,
+       "u3 % 2 = 0 AND t3 % 2 = 0",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t, u WHERE t.c0 = u.c0 AND u.c3 % 2 = 0 AND t.c3 % 2 = 0"},
+      // Inner join with filter always be true.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kInner,
+       "u3 = u3 AND t3 = t3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t, u WHERE t.c0 = u.c0 AND u.c3 = u.c3 AND t.c3 = t.c3"},
+      // Inner join with filter always be false.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kInner,
+       "u3 != u3 AND t3 != t3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t, u WHERE t.c0 = u.c0 AND u.c3 != u.c3 AND t.c3 != t.c3"},
+
+      // Left join with filter on probe side
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kLeft,
+       "t3 % 2 = 0",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND t.c3 % 2 = 0"},
+      // Left join with filter always be true.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kLeft,
+       "t3 = t3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND t.c3 = t.c3"},
+      // Inner join with filter always be false.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kLeft,
+       "t3 != t3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND t.c3 != t.c3"},
+
+      // Left join with filter on lookup side
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kLeft,
+       "u3 % 2 = 0",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND u.c3 % 2 = 0"},
+      // Inner join with filter always be true.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kLeft,
+       "u3 = u3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND u.c3 = u.c3"},
+      // Left join with filter always be false.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kLeft,
+       "u3 != u3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND u.c3 != u.c3"},
+
+      // Left join with filter on both side
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kLeft,
+       "u3 % 2 = 0 AND t3 % 2 = 0",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND u.c3 % 2 = 0 AND t.c3 % 2 = 0"},
+      // Left join with filter always be true.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kLeft,
+       "u3 = u3 AND t3 = t3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND u.c3 = u.c3 AND t.c3 = t.c3"},
+      // Left join with filter always be false.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kLeft,
+       "u3 != u3 AND t3 != t3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND u.c3 != u.c3 AND t.c3 != t.c3"}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    IndexTableData tableData;
+    generateIndexTableData(testData.keyCardinalities, tableData, pool_);
+    auto probeVectors = generateProbeInput(
+        testData.numProbeBatches,
+        testData.numRowsPerProbeBatch,
+        1,
+        tableData,
+        pool_,
+        {"t0", "t1", "t2"},
+        GetParam().hasNullKeys,
+        {},
+        {},
+        testData.matchPct);
+    std::vector<std::shared_ptr<TempFilePath>> probeFiles =
+        createProbeFiles(probeVectors);
+
+    createDuckDbTable("t", probeVectors);
+    createDuckDbTable("u", {tableData.tableVectors});
+
+    const auto indexTable = TestIndexTable::create(
+        /*numEqualJoinKeys=*/3,
+        tableData.keyVectors,
+        tableData.valueVectors,
+        *pool());
+    const auto indexTableHandle = makeIndexTableHandle(
+        indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    const auto indexScanNode = makeIndexScanNode(
+        planNodeIdGenerator,
+        indexTableHandle,
+        makeScanOutputType(testData.scanOutputColumns),
+        makeIndexColumnHandles(testData.scanOutputColumns));
+
+    // Create a plan with filter
+    auto plan = makeLookupPlan(
+        planNodeIdGenerator,
+        indexScanNode,
+        {"t0", "t1", "t2"},
+        {"u0", "u1", "u2"},
+        {},
+        testData.filter,
+        /*hasMarker=*/false,
+        testData.joinType,
+        testData.outputColumns);
+
+    runLookupQuery(
+        plan,
+        probeFiles,
+        GetParam().serialExecution,
+        GetParam().serialExecution,
+        32,
+        GetParam().numPrefetches,
+        GetParam().needsIndexSplit,
+        testData.duckDbVerifySql);
+
+    if (testData.joinType != core::JoinType::kLeft) {
+      continue;
+    }
+    const auto probeScanId = probeScanNodeId_;
+    auto planWithMatchColumn = makeLookupPlan(
+        planNodeIdGenerator,
+        indexScanNode,
+        {"t0", "t1", "t2"},
+        {"u0", "u1", "u2"},
+        {},
+        testData.filter,
+        /*hasMarker=*/true,
+        testData.joinType,
+        testData.outputColumns);
+    verifyResultWithMatchColumn(
+        plan,
+        probeScanId,
+        planWithMatchColumn,
+        probeScanNodeId_,
+        probeFiles,
+        GetParam().needsIndexSplit);
+  }
+}
+
+TEST_P(IndexLookupJoinTest, mixedFilterBatches) {
+  // Create IndexTableData using VectorTestBase utilities
+  IndexTableData tableData;
+
+  const std::string dummyString("test");
+  StringView dummyStringView(dummyString);
+  // Create table key data (u0, u1, u2) using makeFlatVector
+  auto u0 = makeFlatVector<int64_t>(64, [&](auto row) { return row % 8; });
+  auto u1 = makeFlatVector<int64_t>(64, [&](auto row) { return row % 8; });
+  auto u2 = makeFlatVector<int64_t>(64, [&](auto row) { return row % 8; });
+  tableData.keyVectors = makeRowVector({"u0", "u1", "u2"}, {u0, u1, u2});
+
+  // Create table value data (u3, u4, u5) using makeFlatVector
+  auto u3 = makeFlatVector<int64_t>(64, [&](auto row) { return row; });
+  auto u4 = makeFlatVector<int64_t>(64, [&](auto row) { return row; });
+  auto u5 = makeFlatVector<StringView>(
+      64, [&](auto /*unused*/) { return dummyStringView; });
+  tableData.valueVectors = makeRowVector({"u3", "u4", "u5"}, {u3, u4, u5});
+
+  // Create complete table data by combining key and value data
+  tableData.tableVectors = makeRowVector(
+      {"u0", "u1", "u2", "u3", "u4", "u5"}, {u0, u1, u2, u3, u4, u5});
+
+  // Create probe vectors using makeArrayVectorFromJson in a loop
+  std::vector<RowVectorPtr> probeVectors;
+  probeVectors.reserve(5);
+  for (int i = 0; i < 5; ++i) {
+    probeVectors.push_back(makeRowVector(
+        {"t0", "t1", "t2", "t3", "t4", "t5"},
+        {makeFlatVector<int64_t>(128, [&](auto row) { return row; }),
+         makeFlatVector<int64_t>(128, [&](auto row) { return row; }),
+         makeFlatVector<int64_t>(128, [&](auto row) { return row; }),
+         makeFlatVector<int64_t>(128, [&](auto row) { return row; }),
+         makeArrayVector<int64_t>(
+             128,
+             [](vector_size_t /*unused*/) { return 1; },
+             [](vector_size_t, vector_size_t) { return 1; }),
+         makeFlatVector<StringView>(
+             128, [&](auto /*unused*/) { return dummyStringView; })}));
+  }
+
+  std::vector<std::shared_ptr<TempFilePath>> probeFiles =
+      createProbeFiles(probeVectors);
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", {tableData.tableVectors});
+
+  const auto indexTable = TestIndexTable::create(
+      /*numEqualJoinKeys=*/3,
+      tableData.keyVectors,
+      tableData.valueVectors,
+      *pool());
+  const auto indexTableHandle = makeIndexTableHandle(
+      indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto indexScanNode = makeIndexScanNode(
+      planNodeIdGenerator,
+      indexTableHandle,
+      makeScanOutputType({"u0", "u1", "u2", "u3", "u5"}),
+      makeIndexColumnHandles({"u0", "u1", "u2", "u3", "u5"}));
+
+  auto plan = makeLookupPlan(
+      planNodeIdGenerator,
+      indexScanNode,
+      {"t0", "t1", "t2"},
+      {"u0", "u1", "u2"},
+      {},
+      "t3 > 4",
+      /*hasMarker=*/false,
+      core::JoinType::kLeft,
+      {"t1", "u1", "u2", "u3", "u5"});
+
+  AssertQueryBuilder queryBuilder(duckDbQueryRunner_);
+  queryBuilder.plan(plan)
+      .config(
+          core::QueryConfig::kIndexLookupJoinMaxPrefetchBatches,
+          std::to_string(GetParam().numPrefetches))
+      .config(core::QueryConfig::kPreferredOutputBatchRows, "4")
+      .config(core::QueryConfig::kIndexLookupJoinSplitOutput, "true")
+      .splits(probeScanNodeId_, makeHiveConnectorSplits(probeFiles))
+      .serialExecution(GetParam().serialExecution)
+      .barrierExecution(GetParam().serialExecution);
+  if (GetParam().needsIndexSplit) {
+    queryBuilder.split(
+        indexScanNodeId_,
+        Split(
+            std::make_shared<TestIndexConnectorSplit>(
+                kTestIndexConnectorName)));
+  }
+  queryBuilder.assertResults(
+      "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2 AND t.c3 > 4");
+}
+
+// Tests the index split handling behavior of the IndexLookupJoin operator.
+// When needsIndexSplit is true:
+// - The operator blocks waiting for splits until it receives them
+// - Works correctly with various split counts (0, 1, 2, 3 splits)
+// - With 0 splits (partition pruning), LEFT JOIN emits probe rows with nulls
+// This test only runs when GetParam().needsIndexSplit is true.
+DEBUG_ONLY_TEST_P(IndexLookupJoinTest, needsIndexSplit) {
+  if (!GetParam().needsIndexSplit) {
+    return;
+  }
+  keyType_ = ROW({"u0"}, {BIGINT()});
+  valueType_ = ROW({"u1", "u2"}, {BIGINT(), VARCHAR()});
+  tableType_ = concat(keyType_, valueType_);
+  probeType_ = ROW({"t0", "t1", "t2"}, {BIGINT(), BIGINT(), VARCHAR()});
+
+  IndexTableData tableData;
+  generateIndexTableData({100}, tableData, pool_);
+  const auto probeVectors =
+      generateProbeInput(3, 100, 1, tableData, pool_, {"t0"});
+  const auto probeFiles = createProbeFiles(probeVectors);
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", {tableData.tableVectors});
+
+  const auto indexTable = TestIndexTable::create(
+      /*numEqualJoinKeys=*/1,
+      tableData.keyVectors,
+      tableData.valueVectors,
+      *pool());
+
+  const auto duckDbVerifySql =
+      "SELECT t.c0, t.c1, u.c1, u.c2 FROM t LEFT JOIN u ON t.c0 = u.c0";
+
+  struct {
+    int numIndexSplits;
+
+    std::string debugString() const {
+      return fmt::format("numIndexSplits: {}", numIndexSplits);
+    }
+  } testSettings[] = {
+      {1},
+      {2},
+      {3},
+      {0},
+  };
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    // Create index table handle that requires splits.
+    const auto indexTableHandle = makeIndexTableHandle(
+        indexTable, GetParam().asyncLookup, /*needsIndexSplit=*/true);
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    const auto indexScanNode = makeIndexScanNode(
+        planNodeIdGenerator,
+        indexTableHandle,
+        makeScanOutputType({"u0", "u1", "u2"}),
+        makeIndexColumnHandles({"u0", "u1", "u2"}));
+    auto plan = makeLookupPlan(
+        planNodeIdGenerator,
+        indexScanNode,
+        {"t0"},
+        {"u0"},
+        {},
+        "",
+        /*hasMarker=*/false,
+        core::JoinType::kLeft,
+        {"t0", "t1", "u1", "u2"});
+
+    // Track the number of times collectIndexSplits is called.
+    std::atomic_int collectSplitCallCount{0};
+    folly::EventCount waitCollectSplit;
+    std::atomic_bool waitCollectSplitFlag{true};
+
+    std::mutex mutex;
+    std::shared_ptr<Task> task;
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::IndexLookupJoin::collectIndexSplits",
+        std::function<void(const IndexLookupJoin*)>(
+            [&](const IndexLookupJoin* op) {
+              {
+                std::lock_guard<std::mutex> lock(mutex);
+                if (task == nullptr) {
+                  task = op->operatorCtx()->task();
+                  // Signal that we've entered collectIndexSplits for the first
+                  // time.
+                  waitCollectSplitFlag = false;
+                  waitCollectSplit.notifyAll();
+                }
+              }
+              ++collectSplitCallCount;
+            }));
+
+    // For 0 splits, the LEFT JOIN should produce all probe rows with nulls
+    // on the lookup side.
+    const auto expectedSql = testData.numIndexSplits == 0
+        ? "SELECT t.c0, t.c1, NULL, NULL FROM t"
+        : duckDbVerifySql;
+
+    // Run the query in a separate thread without providing index splits
+    // upfront. The main thread will provide splits after the task starts.
+    std::thread queryThread([&] {
+      AssertQueryBuilder queryBuilder(duckDbQueryRunner_);
+      queryBuilder.plan(plan)
+          .splits(probeScanNodeId_, makeHiveConnectorSplits(probeFiles))
+          .assertResults(expectedSql);
+    });
+
+    // Wait for collectIndexSplits to be called.
+    waitCollectSplit.await([&] { return !waitCollectSplitFlag.load(); });
+    // Wait for 1 second and expect the task to NOT finish since it's
+    // waiting for splits.
+    std::this_thread::sleep_for(std::chrono::seconds(1)); // NOLINT
+    {
+      std::lock_guard<std::mutex> lock(mutex);
+      ASSERT_NE(task, nullptr);
+      ASSERT_EQ(task->state(), TaskState::kRunning)
+          << "Task should still be running while waiting for splits";
+
+      for (int i = 0; i < testData.numIndexSplits; ++i) {
+        task->addSplit(
+            indexScanNodeId_,
+            Split(
+                std::make_shared<TestIndexConnectorSplit>(
+                    kTestIndexConnectorName)));
+      }
+      task->noMoreSplits(indexScanNodeId_);
+    }
+
+    queryThread.join();
+
+    // Verify collectIndexSplits was called the expected number of times:
+    // once initially when blocked, plus once after splits are available.
+    ASSERT_EQ(collectSplitCallCount.load(), 2)
+        << "collectIndexSplits should be called once initially (blocked), "
+           "then once when splits are available";
+  }
+}
+
+// Tests that when needsIndexSplit is false, the operator does NOT call
+// collectIndexSplits. The query should complete successfully without waiting
+// for any index splits.
+// This test only runs when GetParam().needsIndexSplit is false.
+DEBUG_ONLY_TEST_P(IndexLookupJoinTest, noNeedsIndexSplitNoCollect) {
+  if (GetParam().needsIndexSplit) {
+    return;
+  }
+
+  keyType_ = ROW({"u0"}, {BIGINT()});
+  valueType_ = ROW({"u1", "u2"}, {BIGINT(), VARCHAR()});
+  tableType_ = concat(keyType_, valueType_);
+  probeType_ = ROW({"t0", "t1", "t2"}, {BIGINT(), BIGINT(), VARCHAR()});
+
+  IndexTableData tableData;
+  generateIndexTableData({100}, tableData, pool_);
+  const auto probeVectors =
+      generateProbeInput(3, 100, 1, tableData, pool_, {"t0"});
+  const auto probeFiles = createProbeFiles(probeVectors);
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", {tableData.tableVectors});
+
+  const auto indexTable = TestIndexTable::create(
+      /*numEqualJoinKeys=*/1,
+      tableData.keyVectors,
+      tableData.valueVectors,
+      *pool());
+
+  const auto duckDbVerifySql =
+      "SELECT t.c0, t.c1, u.c1, u.c2 FROM t LEFT JOIN u ON t.c0 = u.c0";
+
+  // Create index table handle with needsIndexSplit=false.
+  const auto indexTableHandle = makeIndexTableHandle(
+      indexTable, GetParam().asyncLookup, /*needsIndexSplit=*/false);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto indexScanNode = makeIndexScanNode(
+      planNodeIdGenerator,
+      indexTableHandle,
+      makeScanOutputType({"u0", "u1", "u2"}),
+      makeIndexColumnHandles({"u0", "u1", "u2"}));
+  auto plan = makeLookupPlan(
+      planNodeIdGenerator,
+      indexScanNode,
+      {"t0"},
+      {"u0"},
+      {},
+      "",
+      /*hasMarker=*/false,
+      core::JoinType::kLeft,
+      {"t0", "t1", "u1", "u2"});
+
+  // Track if collectIndexSplits is ever called (it should NOT be).
+  std::atomic_bool collectSplitsCalled{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::IndexLookupJoin::collectIndexSplits",
+      std::function<void(const IndexLookupJoin*)>(
+          [&](const IndexLookupJoin* /*op*/) { collectSplitsCalled = true; }));
+
+  // Run the query - it should complete without waiting for splits.
+  AssertQueryBuilder(duckDbQueryRunner_)
+      .plan(plan)
+      .splits(probeScanNodeId_, makeHiveConnectorSplits(probeFiles))
+      .assertResults(duckDbVerifySql);
+
+  // Verify collectIndexSplits was never called since needsIndexSplit=false.
+  ASSERT_FALSE(collectSplitsCalled.load())
+      << "collectIndexSplits should not be called when needsIndexSplit is "
+         "false";
+}
+
+// Tests that when needsIndexSplit is false, adding splits or signaling
+// no-more-splits should fail because the index scan node is not registered
+// for split collection.
+// This test only runs when GetParam().needsIndexSplit is false.
+DEBUG_ONLY_TEST_P(IndexLookupJoinTest, noNeedsIndexSplitSplitOperationFails) {
+  if (GetParam().needsIndexSplit) {
+    return;
+  }
+
+  keyType_ = ROW({"u0"}, {BIGINT()});
+  valueType_ = ROW({"u1", "u2"}, {BIGINT(), VARCHAR()});
+  tableType_ = concat(keyType_, valueType_);
+  probeType_ = ROW({"t0", "t1", "t2"}, {BIGINT(), BIGINT(), VARCHAR()});
+
+  IndexTableData tableData;
+  generateIndexTableData({100}, tableData, pool_);
+  const auto probeVectors =
+      generateProbeInput(3, 100, 1, tableData, pool_, {"t0"});
+  const auto probeFiles = createProbeFiles(probeVectors);
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", {tableData.tableVectors});
+
+  const auto indexTable = TestIndexTable::create(
+      /*numEqualJoinKeys=*/1,
+      tableData.keyVectors,
+      tableData.valueVectors,
+      *pool());
+
+  const auto duckDbVerifySql =
+      "SELECT t.c0, t.c1, u.c1, u.c2 FROM t LEFT JOIN u ON t.c0 = u.c0";
+
+  // Create index table handle with needsIndexSplit=false.
+  const auto indexTableHandle = makeIndexTableHandle(
+      indexTable, GetParam().asyncLookup, /*needsIndexSplit=*/false);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto indexScanNode = makeIndexScanNode(
+      planNodeIdGenerator,
+      indexTableHandle,
+      makeScanOutputType({"u0", "u1", "u2"}),
+      makeIndexColumnHandles({"u0", "u1", "u2"}));
+  auto plan = makeLookupPlan(
+      planNodeIdGenerator,
+      indexScanNode,
+      {"t0"},
+      {"u0"},
+      {},
+      "",
+      /*hasMarker=*/false,
+      core::JoinType::kLeft,
+      {"t0", "t1", "u1", "u2"});
+
+  // Test both addSplit and noMoreSplits operations.
+  for (bool testAddSplit : {true, false}) {
+    SCOPED_TRACE(fmt::format("testAddSplit: {}", testAddSplit));
+
+    // Use TestValue to block the Task from starting to allow us to verify
+    // that split operations fail.
+    folly::EventCount taskEnterWait;
+    std::atomic_bool taskEnterWaitFlag{true};
+    std::shared_ptr<Task> task;
+    std::mutex mutex;
+
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Task::enter",
+        std::function<void(Task*)>([&](Task* taskPtr) {
+          {
+            std::lock_guard<std::mutex> lock(mutex);
+            if (task == nullptr) {
+              task = taskPtr->shared_from_this();
+            }
+          }
+          // Block until the test thread signals to continue.
+          taskEnterWait.await([&] { return !taskEnterWaitFlag.load(); });
+        }));
+
+    // Run the query in a separate thread.
+    std::thread queryThread([&] {
+      AssertQueryBuilder(duckDbQueryRunner_)
+          .plan(plan)
+          .splits(probeScanNodeId_, makeHiveConnectorSplits(probeFiles))
+          .assertResults(duckDbVerifySql);
+    });
+
+    // Wait a bit for the task to start and hit the TestValue.
+    std::this_thread::sleep_for(std::chrono::seconds(1)); // NOLINT
+
+    {
+      std::lock_guard<std::mutex> lock(mutex);
+      if (task != nullptr) {
+        if (testAddSplit) {
+          // Try to add a split - this should fail because the index scan node
+          // is not registered for split collection.
+          VELOX_ASSERT_THROW(
+              task->addSplit(
+                  indexScanNodeId_,
+                  Split(
+                      std::make_shared<TestIndexConnectorSplit>(
+                          kTestIndexConnectorName))),
+              "Splits can be associated only with leaf plan nodes which require splits. Plan node ID 0 doesn't refer to such plan node");
+        } else {
+          // Try to signal no more splits - this should fail because the index
+          // scan node is not registered for split collection.
+          VELOX_ASSERT_THROW(
+              task->noMoreSplits(indexScanNodeId_),
+              "Splits can be associated only with leaf plan nodes which require splits. Plan node ID 0 doesn't refer to such plan node.");
+        }
+      }
+    }
+
+    // Allow the query to complete.
+    taskEnterWaitFlag = false;
+    taskEnterWait.notifyAll();
+
+    queryThread.join();
+  }
+}
+// Verifies that when multiple drivers are waiting for index splits (the
+// collector waiting for splits from the task, followers waiting on the bridge),
+// aborting the task unblocks all drivers and the task terminates cleanly.
+DEBUG_ONLY_TEST_P(IndexLookupJoinTest, abortDuringIndexSplitWait) {
+  if (GetParam().serialExecution || !GetParam().needsIndexSplit) {
+    return;
+  }
+
+  keyType_ = ROW({"u0"}, {BIGINT()});
+  valueType_ = ROW({"u1", "u2"}, {BIGINT(), VARCHAR()});
+  tableType_ = concat(keyType_, valueType_);
+  probeType_ = ROW({"t0", "t1", "t2"}, {BIGINT(), BIGINT(), VARCHAR()});
+
+  IndexTableData tableData;
+  generateIndexTableData({100}, tableData, pool_);
+  const auto probeVectors =
+      generateProbeInput(3, 100, 1, tableData, pool_, {"t0"});
+  const auto probeFiles = createProbeFiles(probeVectors);
+
+  const auto indexTable = TestIndexTable::create(
+      /*numEqualJoinKeys=*/1,
+      tableData.keyVectors,
+      tableData.valueVectors,
+      *pool());
+  const auto indexTableHandle = makeIndexTableHandle(
+      indexTable, GetParam().asyncLookup, /*needsIndexSplit=*/true);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto indexScanNode = makeIndexScanNode(
+      planNodeIdGenerator,
+      indexTableHandle,
+      makeScanOutputType({"u0", "u1", "u2"}),
+      makeIndexColumnHandles({"u0", "u1", "u2"}));
+  auto plan = makeLookupPlan(
+      planNodeIdGenerator,
+      indexScanNode,
+      {"t0"},
+      {"u0"},
+      {},
+      /*filter=*/"",
+      /*hasMarker=*/false,
+      core::JoinType::kLeft,
+      {"t0", "t1", "u1", "u2"});
+
+  const int numDrivers = 4;
+
+  // Use TestValue to capture the task when the collector enters
+  // collectIndexSplits, and hold it there until the test signals.
+  folly::EventCount collectSplitWait;
+  std::atomic_bool collectSplitReached{false};
+  folly::EventCount collectUnblockWait;
+  std::atomic_bool collectUnblockFlag{false};
+  std::mutex mutex;
+  std::shared_ptr<Task> task;
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::IndexLookupJoin::collectIndexSplits",
+      std::function<void(const IndexLookupJoin*)>(
+          [&](const IndexLookupJoin* op) {
+            {
+              std::lock_guard<std::mutex> lock(mutex);
+              if (task == nullptr) {
+                task = op->operatorCtx()->task();
+                collectSplitReached = true;
+                collectSplitWait.notifyAll();
+              }
+            }
+            // Hold the collector here until the test signals.
+            collectUnblockWait.await([&] { return collectUnblockFlag.load(); });
+          }));
+
+  // Run the query in a separate thread. Don't provide index splits so the
+  // collector blocks.
+  std::thread queryThread([&] {
+    VELOX_ASSERT_THROW(
+        AssertQueryBuilder(duckDbQueryRunner_)
+            .plan(plan)
+            .splits(probeScanNodeId_, makeHiveConnectorSplits(probeFiles))
+            .maxDrivers(numDrivers)
+            .copyResults(pool()),
+        "Aborted");
+  });
+
+  // Wait for the collector to enter collectIndexSplits.
+  collectSplitWait.await([&] { return collectSplitReached.load(); });
+
+  // Wait until all non-collector drivers are off-thread (blocked on the
+  // bridge). The collector is held by the TestValue callback above.
+  while (true) {
+    int offThreadCount = 0;
+    task->testingVisitDrivers([&](Driver* driver) {
+      if (!driver->isOnThread()) {
+        ++offThreadCount;
+      }
+    });
+    // All followers (numDrivers - 1) should be off-thread.
+    if (offThreadCount >= numDrivers - 1) {
+      break;
+    }
+    std::this_thread::sleep_for(std::chrono::milliseconds(10)); // NOLINT
+  }
+
+  // Abort the task while all drivers are blocked.
+  {
+    std::lock_guard<std::mutex> lock(mutex);
+    ASSERT_NE(task, nullptr);
+    ASSERT_EQ(task->state(), TaskState::kRunning);
+    task->requestAbort();
+  }
+
+  // Wait for all follower drivers to finish. The collector is still held by
+  // the TestValue callback, so only 1 driver (the collector) should remain.
+  while (true) {
+    int aliveCount = 0;
+    task->testingVisitDrivers([&](Driver*) { ++aliveCount; });
+    if (aliveCount == 1) {
+      break;
+    }
+    std::this_thread::sleep_for(std::chrono::milliseconds(10)); // NOLINT
+  }
+
+  // Release the collector from the TestValue callback.
+  collectUnblockFlag = true;
+  collectUnblockWait.notifyAll();
+
+  queryThread.join();
+
+  // Verify the task terminated properly.
+  ASSERT_TRUE(waitForTaskAborted(task.get()));
+}
+
+TEST_P(IndexLookupJoinTest, multiDriverWithIndexSplits) {
+  if (GetParam().serialExecution || !GetParam().needsIndexSplit) {
+    return;
+  }
+  IndexTableData tableData;
+  generateIndexTableData({100, 1, 1}, tableData, pool_);
+  const int numProbeSplits{5};
+  const auto probeVectors = generateProbeInput(
+      numProbeSplits,
+      256,
+      1,
+      tableData,
+      pool_,
+      {"t0", "t1", "t2"},
+      GetParam().hasNullKeys,
+      {},
+      {},
+      100);
+  const auto probeFiles = createProbeFiles(probeVectors);
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", {tableData.tableVectors});
+
+  const auto indexTable = TestIndexTable::create(
+      /*numEqualJoinKeys=*/3,
+      tableData.keyVectors,
+      tableData.valueVectors,
+      *pool());
+  const auto indexTableHandle = makeIndexTableHandle(
+      indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto indexScanNode = makeIndexScanNode(
+      planNodeIdGenerator,
+      indexTableHandle,
+      makeScanOutputType({"u0", "u1", "u2", "u3", "u5"}),
+      makeIndexColumnHandles({"u0", "u1", "u2", "u3", "u5"}));
+
+  for (const auto joinType : {core::JoinType::kInner, core::JoinType::kLeft}) {
+    SCOPED_TRACE(
+        fmt::format("joinType: {}", core::JoinTypeName::toName(joinType)));
+    const auto duckDbSql = joinType == core::JoinType::kInner
+        ? "SELECT u.c3, t.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2"
+        : "SELECT u.c3, t.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2";
+    auto plan = makeLookupPlan(
+        planNodeIdGenerator,
+        indexScanNode,
+        {"t0", "t1", "t2"},
+        {"u0", "u1", "u2"},
+        {},
+        /*filter=*/"",
+        /*hasMarker=*/false,
+        joinType,
+        {"u3", "t5"});
+
+    for (int numDrivers : {2, 4}) {
+      SCOPED_TRACE(fmt::format("numDrivers: {}", numDrivers));
+      auto task = runLookupQuery(
+          plan,
+          probeFiles,
+          /*serialExecution=*/false,
+          /*barrierExecution=*/false,
+          100,
+          GetParam().numPrefetches,
+          GetParam().needsIndexSplit,
+          duckDbSql,
+          numDrivers);
+      auto taskStats = toPlanStats(task->taskStats());
+      ASSERT_EQ(taskStats.at(joinNodeId_).numDrivers, numDrivers);
+    }
+  }
+}
+
+// Verifies IndexLookupJoin works correctly with grouped execution where the
+// probe side is grouped. Each split group creates its own set of drivers with
+// partitionId 0..numDrivers-1, and the partitionId==0 driver in each group
+// acts as the split collector for that group's index splits.
+TEST_P(IndexLookupJoinTest, groupedExecution) {
+  if (GetParam().serialExecution || !GetParam().needsIndexSplit) {
+    return;
+  }
+  IndexTableData tableData;
+  generateIndexTableData({100, 1, 1}, tableData, pool_);
+  const int numProbeSplitsPerGroup{2};
+  const int numSplitGroups{3};
+  const int numDrivers{2};
+  const auto probeVectors = generateProbeInput(
+      numProbeSplitsPerGroup * numSplitGroups,
+      256,
+      1,
+      tableData,
+      pool_,
+      {"t0", "t1", "t2"},
+      GetParam().hasNullKeys,
+      {},
+      {},
+      100);
+  const auto probeFiles = createProbeFiles(probeVectors);
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", {tableData.tableVectors});
+
+  const auto indexTable = TestIndexTable::create(
+      /*numEqualJoinKeys=*/3,
+      tableData.keyVectors,
+      tableData.valueVectors,
+      *pool());
+  const auto indexTableHandle = makeIndexTableHandle(
+      indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto indexScanNode = makeIndexScanNode(
+      planNodeIdGenerator,
+      indexTableHandle,
+      makeScanOutputType({"u0", "u1", "u2", "u3", "u5"}),
+      makeIndexColumnHandles({"u0", "u1", "u2", "u3", "u5"}));
+
+  for (const auto joinType : {core::JoinType::kInner, core::JoinType::kLeft}) {
+    SCOPED_TRACE(
+        fmt::format("joinType: {}", core::JoinTypeName::toName(joinType)));
+    auto outputLayout = std::vector<std::string>{"u3", "t5"};
+    auto plan = PlanBuilder(planNodeIdGenerator, pool())
+                    .tableScan(probeType_)
+                    .capturePlanNodeId(probeScanNodeId_)
+                    .startIndexLookupJoin()
+                    .leftKeys({"t0", "t1", "t2"})
+                    .rightKeys({"u0", "u1", "u2"})
+                    .indexSource(indexScanNode)
+                    .outputLayout(outputLayout)
+                    .joinType(joinType)
+                    .endIndexLookupJoin()
+                    .capturePlanNodeId(joinNodeId_)
+                    .partitionedOutput({}, 1, outputLayout)
+                    .planFragment();
+
+    plan.executionStrategy = core::ExecutionStrategy::kGrouped;
+    plan.groupedExecutionLeafNodeIds.emplace(probeScanNodeId_);
+    plan.groupedExecutionLeafNodeIds.emplace(indexScanNodeId_);
+    plan.numSplitGroups = numSplitGroups;
+
+    auto queryCtx = core::QueryCtx::create(executor_.get());
+    std::unordered_map<std::string, std::string> configs;
+    configs[QueryConfig::kIndexLookupJoinMaxPrefetchBatches] =
+        std::to_string(GetParam().numPrefetches);
+    queryCtx->testingOverrideConfigUnsafe(std::move(configs));
+
+    auto task = exec::Task::create(
+        fmt::format("grouped-index-lookup-join-{}", joinType),
+        std::move(plan),
+        0,
+        std::move(queryCtx),
+        Task::ExecutionMode::kParallel);
+    task->start(numDrivers, /*concurrentSplitGroups=*/2);
+
+    // Add probe splits with group IDs.
+    int fileIdx = 0;
+    for (int group = 0; group < numSplitGroups; ++group) {
+      for (int j = 0; j < numProbeSplitsPerGroup; ++j) {
+        task->addSplit(
+            probeScanNodeId_,
+            Split(
+                makeHiveConnectorSplit(probeFiles[fileIdx++]->getPath()),
+                group));
+      }
+      task->noMoreSplitsForGroup(probeScanNodeId_, group);
+    }
+    task->noMoreSplits(probeScanNodeId_);
+
+    // Add one index split per group so each group's collector finds its split.
+    for (int group = 0; group < numSplitGroups; ++group) {
+      task->addSplit(
+          indexScanNodeId_,
+          Split(
+              std::make_shared<TestIndexConnectorSplit>(
+                  kTestIndexConnectorName),
+              group));
+      task->noMoreSplitsForGroup(indexScanNodeId_, group);
+    }
+
+    // Consume output via OutputBufferManager.
+    auto outputBufferManager = exec::OutputBufferManager::getInstanceRef();
+    outputBufferManager->deleteResults(task->taskId(), 0);
+
+    waitForTaskCompletion(task.get());
+    ASSERT_EQ(task->state(), TaskState::kFinished);
+
+    auto taskStats = toPlanStats(task->taskStats());
+    ASSERT_EQ(
+        taskStats.at(joinNodeId_).numDrivers, numDrivers * numSplitGroups);
+  }
+}
+
+// Verifies that grouped execution completes correctly when some split groups
+// receive no index splits (e.g., partition pruning eliminates all index
+// partitions for a group). For INNER JOIN, the pruned group produces no
+// output. For LEFT JOIN, the pruned group emits probe rows with nulls.
+TEST_P(IndexLookupJoinTest, groupedExecutionWithEmptyIndexSplits) {
+  if (GetParam().serialExecution || !GetParam().needsIndexSplit) {
+    return;
+  }
+  IndexTableData tableData;
+  generateIndexTableData({100, 1, 1}, tableData, pool_);
+  const int numProbeSplitsPerGroup{1};
+  const int numSplitGroups{3};
+  const int numDrivers{2};
+  const auto probeVectors = generateProbeInput(
+      numProbeSplitsPerGroup * numSplitGroups,
+      256,
+      1,
+      tableData,
+      pool_,
+      {"t0", "t1", "t2"},
+      GetParam().hasNullKeys,
+      {},
+      {},
+      100);
+  const auto probeFiles = createProbeFiles(probeVectors);
+
+  const auto indexTable = TestIndexTable::create(
+      /*numEqualJoinKeys=*/3,
+      tableData.keyVectors,
+      tableData.valueVectors,
+      *pool());
+  const auto indexTableHandle = makeIndexTableHandle(
+      indexTable, GetParam().asyncLookup, GetParam().needsIndexSplit);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto indexScanNode = makeIndexScanNode(
+      planNodeIdGenerator,
+      indexTableHandle,
+      makeScanOutputType({"u0", "u1", "u2", "u3", "u5"}),
+      makeIndexColumnHandles({"u0", "u1", "u2", "u3", "u5"}));
+
+  for (const auto joinType : {core::JoinType::kInner, core::JoinType::kLeft}) {
+    SCOPED_TRACE(
+        fmt::format("joinType: {}", core::JoinTypeName::toName(joinType)));
+    auto outputLayout = std::vector<std::string>{"u3", "t5"};
+    auto plan = PlanBuilder(planNodeIdGenerator, pool())
+                    .tableScan(probeType_)
+                    .capturePlanNodeId(probeScanNodeId_)
+                    .startIndexLookupJoin()
+                    .leftKeys({"t0", "t1", "t2"})
+                    .rightKeys({"u0", "u1", "u2"})
+                    .indexSource(indexScanNode)
+                    .outputLayout(outputLayout)
+                    .joinType(joinType)
+                    .endIndexLookupJoin()
+                    .capturePlanNodeId(joinNodeId_)
+                    .partitionedOutput({}, 1, outputLayout)
+                    .planFragment();
+
+    plan.executionStrategy = core::ExecutionStrategy::kGrouped;
+    plan.groupedExecutionLeafNodeIds.emplace(probeScanNodeId_);
+    plan.groupedExecutionLeafNodeIds.emplace(indexScanNodeId_);
+    plan.numSplitGroups = numSplitGroups;
+
+    auto queryCtx = core::QueryCtx::create(executor_.get());
+    std::unordered_map<std::string, std::string> configs;
+    configs[QueryConfig::kIndexLookupJoinMaxPrefetchBatches] =
+        std::to_string(GetParam().numPrefetches);
+    queryCtx->testingOverrideConfigUnsafe(std::move(configs));
+
+    auto task = exec::Task::create(
+        fmt::format("grouped-empty-index-splits-{}", joinType),
+        std::move(plan),
+        0,
+        std::move(queryCtx),
+        Task::ExecutionMode::kParallel);
+    task->start(numDrivers, /*concurrentSplitGroups=*/2);
+
+    // Add probe splits for all groups.
+    int fileIdx = 0;
+    for (int group = 0; group < numSplitGroups; ++group) {
+      for (int j = 0; j < numProbeSplitsPerGroup; ++j) {
+        task->addSplit(
+            probeScanNodeId_,
+            Split(
+                makeHiveConnectorSplit(probeFiles[fileIdx++]->getPath()),
+                group));
+      }
+      task->noMoreSplitsForGroup(probeScanNodeId_, group);
+    }
+    task->noMoreSplits(probeScanNodeId_);
+
+    // Add index splits only for group 0. Groups 1 and 2 get no index splits,
+    // simulating partition pruning.
+    task->addSplit(
+        indexScanNodeId_,
+        Split(
+            std::make_shared<TestIndexConnectorSplit>(kTestIndexConnectorName),
+            0));
+    task->noMoreSplitsForGroup(indexScanNodeId_, 0);
+    task->noMoreSplitsForGroup(indexScanNodeId_, 1);
+    task->noMoreSplitsForGroup(indexScanNodeId_, 2);
+
+    auto outputBufferManager = exec::OutputBufferManager::getInstanceRef();
+    outputBufferManager->deleteResults(task->taskId(), 0);
+
+    waitForTaskCompletion(task.get());
+    ASSERT_EQ(task->state(), TaskState::kFinished);
+
+    auto taskStats = toPlanStats(task->taskStats());
+    ASSERT_EQ(
+        taskStats.at(joinNodeId_).numDrivers, numDrivers * numSplitGroups);
+  }
+}
+
+// Verifies that grouped execution leaf validation passes when the index
+// source node ID is in groupedExecutionLeafNodeIds. Without the validation
+// exclusion in collectIndexLookupSourceIds, Task::start() would reject the
+// plan because it cannot find the index source node in any driver factory.
+TEST_P(IndexLookupJoinTest, groupedExecutionLeafValidation) {
+  if (GetParam().serialExecution) {
+    return;
+  }
+
+  const auto indexTableHandle = makeIndexTableHandle(
+      nullptr, GetParam().asyncLookup, GetParam().needsIndexSplit);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto indexScanNode = makeIndexScanNode(
+      planNodeIdGenerator,
+      indexTableHandle,
+      makeScanOutputType({"u0", "u1", "u2", "u3", "u5"}),
+      makeIndexColumnHandles({"u0", "u1", "u2", "u3", "u5"}));
+
+  auto outputLayout = std::vector<std::string>{"u3", "t5"};
+  auto plan = PlanBuilder(planNodeIdGenerator, pool())
+                  .tableScan(probeType_)
+                  .capturePlanNodeId(probeScanNodeId_)
+                  .startIndexLookupJoin()
+                  .leftKeys({"t0", "t1", "t2"})
+                  .rightKeys({"u0", "u1", "u2"})
+                  .indexSource(indexScanNode)
+                  .outputLayout(outputLayout)
+                  .joinType(core::JoinType::kInner)
+                  .endIndexLookupJoin()
+                  .capturePlanNodeId(joinNodeId_)
+                  .partitionedOutput({}, 1, outputLayout)
+                  .planFragment();
+
+  plan.executionStrategy = core::ExecutionStrategy::kGrouped;
+  plan.groupedExecutionLeafNodeIds.emplace(probeScanNodeId_);
+  plan.groupedExecutionLeafNodeIds.emplace(indexScanNodeId_);
+  plan.numSplitGroups = 1;
+
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+  auto task = exec::Task::create(
+      "grouped-execution-leaf-validation",
+      std::move(plan),
+      0,
+      std::move(queryCtx),
+      Task::ExecutionMode::kParallel);
+
+  // Task::start() runs validateGroupedExecutionLeafNodes which would throw
+  // if the index source node ID is not excluded from validation.
+  ASSERT_NO_THROW(task->start(1));
+
+  task->requestAbort().wait();
+  ASSERT_TRUE(waitForTaskAborted(task.get()));
+}
+
+} // namespace
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    IndexLookupJoinTest,
+    IndexLookupJoinTest,
+    testing::ValuesIn(IndexLookupJoinTest::getTestParams()),
+    [](const testing::TestParamInfo<TestParam>& info) {
+      return fmt::format(
+          "{}_{}prefetches_{}_{}_{}",
+          info.param.asyncLookup ? "async" : "sync",
+          info.param.numPrefetches,
+          info.param.serialExecution ? "serial" : "parallel",
+          info.param.hasNullKeys ? "nullKeys" : "noNullKeys",
+          info.param.needsIndexSplit ? "needsIndexSplit" : "noSplit");
+    });
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/LimitTest.cpp b/velox/exec/tests/LimitTest.cpp
index b83eb191a39..fb0badafb83 100644
--- a/velox/exec/tests/LimitTest.cpp
+++ b/velox/exec/tests/LimitTest.cpp
@@ -22,6 +22,7 @@
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
+using namespace facebook::velox::common::testutil;
 
 namespace {
 class LimitTest : public HiveConnectorTestBase {};
@@ -146,7 +147,7 @@ TEST_F(LimitTest, partialLimitEagerFlush) {
   test(false);
 }
 
-TEST_F(LimitTest, barrier) {
+TEST_F(LimitTest, DISABLED_barrier) {
   std::vector<RowVectorPtr> vectors;
   std::vector<std::shared_ptr<TempFilePath>> tempFiles;
   const int numSplits{5};
@@ -160,6 +161,7 @@ TEST_F(LimitTest, barrier) {
   createDuckDbTable(vectors);
 
   struct {
+    bool serialExecution;
     bool barrierExecution;
     int offset;
     int limit;
@@ -170,7 +172,8 @@ TEST_F(LimitTest, barrier) {
 
     std::string toString() const {
       return fmt::format(
-          "barrierExecution {}, offset: {}, limit: {}, numExpectedBarriers: {}, numExpectedOutputRows: {}, numExpectedFinishedSplits: {}, numExpectedOutputBatches: {}",
+          "serialExecution {}, barrierExecution {}, offset: {}, limit: {}, numExpectedBarriers: {}, numExpectedOutputRows: {}, numExpectedFinishedSplits: {}, numExpectedOutputBatches: {}",
+          serialExecution,
           barrierExecution,
           offset,
           limit,
@@ -179,130 +182,314 @@ TEST_F(LimitTest, barrier) {
           numExpectedFinishedSplits,
           numExpectedOutputBatches);
     }
-  } testSettings[] = {// Test the case where the limit covers all the input rows
-                      // with barrier and not.
-                      {true,
-                       0,
-                       numRowsPerSplit * numSplits,
-                       numSplits,
-                       numRowsPerSplit * numSplits,
-                       numSplits - 1,
-                       numSplits},
-                      {false,
-                       0,
-                       numRowsPerSplit * numSplits,
-                       0,
-                       numRowsPerSplit * numSplits,
-                       numSplits - 1,
-                       numSplits},
-                      // Test the cases where the limit covers the first entire
-                      // split rows with barrier or not. with barrier and not.
-                      {true, 0, numRowsPerSplit, 1, numRowsPerSplit, 0, 1},
-                      {false, 0, numRowsPerSplit, 0, numRowsPerSplit, 0, 1},
-                      // Test the case where the limit covers the one and half
-                      // split rows with barrier or not.
-                      {true,
-                       0,
-                       numRowsPerSplit + numRowsPerSplit / 2,
-                       2,
-                       numRowsPerSplit + numRowsPerSplit / 2,
-                       1,
-                       2},
-                      {false,
-                       0,
-                       numRowsPerSplit + numRowsPerSplit / 2,
-                       0,
-                       numRowsPerSplit + numRowsPerSplit / 2,
-                       1,
-                       2},
-                      {true,
-                       0,
-                       numRowsPerSplit + numRowsPerSplit - 1,
-                       2,
-                       numRowsPerSplit + numRowsPerSplit - 1,
-                       1,
-                       2},
-                      {false,
-                       0,
-                       numRowsPerSplit + numRowsPerSplit - 1,
-                       0,
-                       numRowsPerSplit + numRowsPerSplit - 1,
-                       1,
-                       2},
-                      // Test the case where the limit set to cover more than
-                      // all the input rows with barrier or not.
-                      {true,
-                       0,
-                       numRowsPerSplit * (numSplits + 1),
-                       numSplits,
-                       numRowsPerSplit * numSplits,
-                       numSplits,
-                       numSplits},
-                      {false,
-                       0,
-                       numRowsPerSplit * (numSplits + 1),
-                       0,
-                       numRowsPerSplit * numSplits,
-                       numSplits,
-                       numSplits},
-                      // Test the cases where the limit set to cover partial
-                      // input rows in the middle with barrier or not.
-                      {true,
-                       numRowsPerSplit,
-                       numRowsPerSplit + numRowsPerSplit - 1,
-                       3,
-                       numRowsPerSplit + numRowsPerSplit - 1,
-                       2,
-                       2},
-                      {false,
-                       numRowsPerSplit,
-                       numRowsPerSplit + numRowsPerSplit - 1,
-                       0,
-                       numRowsPerSplit + numRowsPerSplit - 1,
-                       2,
-                       2},
-                      {true,
-                       numRowsPerSplit,
-                       numRowsPerSplit * (numSplits - 1),
-                       numSplits,
-                       numRowsPerSplit * (numSplits - 1),
-                       numSplits - 1,
-                       numSplits - 1},
-                      {false,
-                       numRowsPerSplit,
-                       numRowsPerSplit * (numSplits - 1),
-                       0,
-                       numRowsPerSplit * (numSplits - 1),
-                       numSplits - 1,
-                       numSplits - 1},
-                      {true,
-                       numRowsPerSplit,
-                       numRowsPerSplit / 2,
-                       2,
-                       numRowsPerSplit / 2,
-                       1,
-                       1},
-                      {false,
-                       numRowsPerSplit,
-                       numRowsPerSplit / 2,
-                       0,
-                       numRowsPerSplit / 2,
-                       1,
-                       1},
-                      {true,
-                       numRowsPerSplit / 2,
-                       numRowsPerSplit * numSplits,
-                       numSplits,
-                       numRowsPerSplit * numSplits - numRowsPerSplit / 2,
-                       numSplits,
-                       numSplits},
-                      {false,
-                       numRowsPerSplit / 2,
-                       numRowsPerSplit * numSplits,
-                       0,
-                       numRowsPerSplit * numSplits - numRowsPerSplit / 2,
-                       numSplits,
-                       numSplits}};
+  } testSettings[] = {
+      // Test the case where the limit covers all the input rows
+      // with barrier and not.
+      {false,
+       false,
+       0,
+       numRowsPerSplit * numSplits,
+       numSplits,
+       numRowsPerSplit * numSplits,
+       numSplits - 1,
+       numSplits},
+      {true,
+       false,
+       0,
+       numRowsPerSplit * numSplits,
+       0,
+       numRowsPerSplit * numSplits,
+       numSplits - 1,
+       numSplits},
+      {false,
+       true,
+       0,
+       numRowsPerSplit * numSplits,
+       numSplits,
+       numRowsPerSplit * numSplits,
+       numSplits - 1,
+       numSplits},
+      {false,
+       false,
+       0,
+       numRowsPerSplit * numSplits,
+       0,
+       numRowsPerSplit * numSplits,
+       numSplits - 1,
+       numSplits},
+      // Test the cases where the limit covers the first entire
+      // split rows with barrier or not. with barrier and not.
+      {
+          true,
+          true,
+          0,
+          numRowsPerSplit,
+          1,
+          numRowsPerSplit,
+          0,
+          1,
+      },
+      {
+          true,
+          false,
+          0,
+          numRowsPerSplit,
+          0,
+          numRowsPerSplit,
+          0,
+          1,
+      },
+      {
+          false,
+          true,
+          0,
+          numRowsPerSplit,
+          1,
+          numRowsPerSplit,
+          0,
+          1,
+      },
+      {
+          false,
+          false,
+          0,
+          numRowsPerSplit,
+          0,
+          numRowsPerSplit,
+          0,
+          1,
+      },
+      // Test the case where the limit covers the one and half
+      // split rows with barrier or not.
+      {true,
+       true,
+       0,
+       numRowsPerSplit + numRowsPerSplit / 2,
+       2,
+       numRowsPerSplit + numRowsPerSplit / 2,
+       1,
+       2},
+      {true,
+       false,
+       0,
+       numRowsPerSplit + numRowsPerSplit / 2,
+       0,
+       numRowsPerSplit + numRowsPerSplit / 2,
+       1,
+       2},
+      {false,
+       true,
+       0,
+       numRowsPerSplit + numRowsPerSplit / 2,
+       2,
+       numRowsPerSplit + numRowsPerSplit / 2,
+       1,
+       2},
+      {false,
+       false,
+       0,
+       numRowsPerSplit + numRowsPerSplit / 2,
+       0,
+       numRowsPerSplit + numRowsPerSplit / 2,
+       1,
+       2},
+      {true,
+       true,
+       0,
+       numRowsPerSplit + numRowsPerSplit - 1,
+       2,
+       numRowsPerSplit + numRowsPerSplit - 1,
+       1,
+       2},
+      {true,
+       false,
+       0,
+       numRowsPerSplit + numRowsPerSplit - 1,
+       0,
+       numRowsPerSplit + numRowsPerSplit - 1,
+       1,
+       2},
+      {false,
+       true,
+       0,
+       numRowsPerSplit + numRowsPerSplit - 1,
+       2,
+       numRowsPerSplit + numRowsPerSplit - 1,
+       1,
+       2},
+      {false,
+       false,
+       0,
+       numRowsPerSplit + numRowsPerSplit - 1,
+       0,
+       numRowsPerSplit + numRowsPerSplit - 1,
+       1,
+       2},
+      // Test the case where the limit set to cover more than
+      // all the input rows with barrier or not.
+      {true,
+       true,
+       0,
+       numRowsPerSplit * (numSplits + 1),
+       numSplits,
+       numRowsPerSplit * numSplits,
+       numSplits,
+       numSplits},
+      {true,
+       false,
+       0,
+       numRowsPerSplit * (numSplits + 1),
+       0,
+       numRowsPerSplit * numSplits,
+       numSplits,
+       numSplits},
+      {false,
+       true,
+       0,
+       numRowsPerSplit * (numSplits + 1),
+       numSplits,
+       numRowsPerSplit * numSplits,
+       numSplits,
+       numSplits},
+      {false,
+       false,
+       0,
+       numRowsPerSplit * (numSplits + 1),
+       0,
+       numRowsPerSplit * numSplits,
+       numSplits,
+       numSplits},
+      // Test the cases where the limit set to cover partial
+      // input rows in the middle with barrier or not.
+      {true,
+       true,
+       numRowsPerSplit,
+       numRowsPerSplit + numRowsPerSplit - 1,
+       3,
+       numRowsPerSplit + numRowsPerSplit - 1,
+       2,
+       2},
+      {true,
+       false,
+       numRowsPerSplit,
+       numRowsPerSplit + numRowsPerSplit - 1,
+       0,
+       numRowsPerSplit + numRowsPerSplit - 1,
+       2,
+       2},
+      {false,
+       true,
+       numRowsPerSplit,
+       numRowsPerSplit + numRowsPerSplit - 1,
+       3,
+       numRowsPerSplit + numRowsPerSplit - 1,
+       2,
+       2},
+      {false,
+       false,
+       numRowsPerSplit,
+       numRowsPerSplit + numRowsPerSplit - 1,
+       0,
+       numRowsPerSplit + numRowsPerSplit - 1,
+       2,
+       2},
+      {true,
+       true,
+       numRowsPerSplit,
+       numRowsPerSplit * (numSplits - 1),
+       numSplits,
+       numRowsPerSplit * (numSplits - 1),
+       numSplits - 1,
+       numSplits - 1},
+      {true,
+       false,
+       numRowsPerSplit,
+       numRowsPerSplit * (numSplits - 1),
+       0,
+       numRowsPerSplit * (numSplits - 1),
+       numSplits - 1,
+       numSplits - 1},
+      {false,
+       true,
+       numRowsPerSplit,
+       numRowsPerSplit * (numSplits - 1),
+       numSplits,
+       numRowsPerSplit * (numSplits - 1),
+       numSplits - 1,
+       numSplits - 1},
+      {false,
+       false,
+       numRowsPerSplit,
+       numRowsPerSplit * (numSplits - 1),
+       0,
+       numRowsPerSplit * (numSplits - 1),
+       numSplits - 1,
+       numSplits - 1},
+      {true,
+       true,
+       numRowsPerSplit,
+       numRowsPerSplit / 2,
+       2,
+       numRowsPerSplit / 2,
+       1,
+       1},
+      {true,
+       false,
+       numRowsPerSplit,
+       numRowsPerSplit / 2,
+       0,
+       numRowsPerSplit / 2,
+       1,
+       1},
+      {false,
+       true,
+       numRowsPerSplit,
+       numRowsPerSplit / 2,
+       2,
+       numRowsPerSplit / 2,
+       1,
+       1},
+      {false,
+       false,
+       numRowsPerSplit,
+       numRowsPerSplit / 2,
+       0,
+       numRowsPerSplit / 2,
+       1,
+       1},
+      {true,
+       true,
+       numRowsPerSplit / 2,
+       numRowsPerSplit * numSplits,
+       numSplits,
+       numRowsPerSplit * numSplits - numRowsPerSplit / 2,
+       numSplits,
+       numSplits},
+      {true,
+       false,
+       numRowsPerSplit / 2,
+       numRowsPerSplit * numSplits,
+       0,
+       numRowsPerSplit * numSplits - numRowsPerSplit / 2,
+       numSplits,
+       numSplits},
+      {false,
+       true,
+       numRowsPerSplit / 2,
+       numRowsPerSplit * numSplits,
+       numSplits,
+       numRowsPerSplit * numSplits - numRowsPerSplit / 2,
+       numSplits,
+       numSplits},
+      {false,
+       false,
+       numRowsPerSplit / 2,
+       numRowsPerSplit * numSplits,
+       0,
+       numRowsPerSplit * numSplits - numRowsPerSplit / 2,
+       numSplits,
+       numSplits},
+  };
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.toString());
     core::PlanNodeId limitPlanNodeId;
@@ -313,15 +500,15 @@ TEST_F(LimitTest, barrier) {
                     .planNode();
     auto task = AssertQueryBuilder(plan, duckDbQueryRunner_)
                     .splits(makeHiveConnectorSplits(tempFiles))
-                    .serialExecution(true)
+                    .serialExecution(testData.serialExecution)
                     .barrierExecution(testData.barrierExecution)
-                    .assertResults(fmt::format(
-                        "SELECT * FROM tmp LIMIT {} OFFSET {}",
-                        testData.limit,
-                        testData.offset));
+                    .assertResults(
+                        fmt::format(
+                            "SELECT * FROM tmp LIMIT {} OFFSET {}",
+                            testData.limit,
+                            testData.offset));
     const auto taskStats = task->taskStats();
     ASSERT_EQ(taskStats.numBarriers, testData.numExpectedBarriers);
-    ASSERT_EQ(taskStats.numFinishedSplits, testData.numExpectedFinishedSplits);
     ASSERT_EQ(
         exec::toPlanStats(taskStats).at(limitPlanNodeId).outputRows,
         testData.numExpectedOutputRows);
diff --git a/velox/exec/tests/LocalPartitionTest.cpp b/velox/exec/tests/LocalPartitionTest.cpp
index 7dbf886fda6..ee59473fb88 100644
--- a/velox/exec/tests/LocalPartitionTest.cpp
+++ b/velox/exec/tests/LocalPartitionTest.cpp
@@ -24,6 +24,7 @@
 using facebook::velox::test::BatchMaker;
 
 namespace facebook::velox::exec::test {
+using namespace facebook::velox::common::testutil;
 namespace {
 
 class LocalPartitionTest : public HiveConnectorTestBase {
@@ -329,6 +330,80 @@ TEST_F(LocalPartitionTest, partitionBuffering) {
       queryBuilder.assertResults(query), 2200, 2, 2);
 }
 
+TEST_F(LocalPartitionTest, partitionBufferingWithStringBuffers) {
+  // Test string buffer memory accounting with partition buffering.
+  // String buffers are multiply-referenced across partitions. The fix
+  // amortizes string buffer sizes across partitions to avoid over-counting,
+  // which allows more efficient buffering.
+  std::vector<RowVectorPtr> vectors;
+  for (auto i = 0; i < 4; ++i) {
+    vectors.emplace_back(makeRowVector(
+        {"c0", "c1"},
+        {makeFlatVector<int32_t>(100, [](auto row) { return row % 2; }),
+         makeFlatVector<std::string>(
+             100, [](auto /*row*/) { return std::string(100, 'a'); })}));
+  }
+
+  auto runQuery = [&](const std::vector<RowVectorPtr>& input,
+                      int maxDrivers,
+                      int maxPartitionBufferSize) {
+    std::string query{"SELECT c0, arbitrary(c1) FROM tmp GROUP BY c0"};
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan =
+        PlanBuilder(planNodeIdGenerator)
+            .localPartition(
+                {"c0"},
+                {PlanBuilder(planNodeIdGenerator).values(input).planNode()})
+            .partialAggregation({"c0"}, {"arbitrary(c1)"})
+            .planNode();
+    createDuckDbTable(vectors);
+
+    AssertQueryBuilder queryBuilder(plan, duckDbQueryRunner_);
+    queryBuilder.maxDrivers(maxDrivers);
+
+    std::unordered_map<std::string, std::string> configs;
+    configs[core::QueryConfig::
+                kMinLocalExchangePartitionCountToUsePartitionBuffer] =
+        std::to_string(2);
+    configs[core::QueryConfig::kMaxLocalExchangePartitionBufferSize] =
+        std::to_string(maxPartitionBufferSize);
+    queryBuilder.configs(configs);
+
+    return queryBuilder.assertResults(query);
+  };
+
+  // With amortized string buffer accounting, the buffer can accumulate rows
+  // from all input vectors. So only 2 vectors are flushed to
+  // LocalExchangeQueues, compared to 8 if not amortizing string buffer sizes.
+  verifyExchangeSourceOperatorStats(runQuery(vectors, 2, 50000), 400, 2, 2);
+
+  // Test case with 99% of data belonging to one partition. We expect all
+  // partition buffers getting flushed together when the total size of all
+  // partition buffers exceeds the limit, instead of flushing each partiton
+  // buffer individually.
+  vectors.clear();
+  for (auto i = 0; i < 4; ++i) {
+    vectors.emplace_back(makeRowVector(
+        {"c0", "c1"},
+        {makeFlatVector<int32_t>(
+             100,
+             [](auto row) {
+               if (row == 0) {
+                 return 0;
+               } else {
+                 return 1;
+               }
+             }),
+         makeFlatVector<std::string>(
+             100, [](auto /*row*/) { return std::string(100, 'a'); })}));
+  }
+
+  // The total size of all partition buffers should exceed the limit and trigger
+  // the flush of all partition buffers at every batch, hence flushing a total
+  // of 8 vectors.
+  verifyExchangeSourceOperatorStats(runQuery(vectors, 2, 20000), 400, 8, 2);
+}
+
 TEST_F(LocalPartitionTest, partitionBufferingPreserveEncoding) {
   std::vector<RowVectorPtr> vectors = {
       makeRowVector({"c0"}, {makeConstant<int32_t>(0, 100)}),
@@ -388,8 +463,9 @@ TEST_F(LocalPartitionTest, maxBufferSizeGather) {
 
   auto valuesNode = [&](int start, int end) {
     return PlanBuilder(planNodeIdGenerator)
-        .values(std::vector<RowVectorPtr>(
-            vectors.begin() + start, vectors.begin() + end))
+        .values(
+            std::vector<RowVectorPtr>(
+                vectors.begin() + start, vectors.begin() + end))
         .planNode();
   };
 
@@ -961,8 +1037,9 @@ TEST_F(LocalPartitionTest, unionAllLocalExchangeWithInterDependency) {
       }
     };
 
-    Operator::registerOperator(std::make_unique<BlockingNodeFactory>(
-        std::move(blockingCallback), std::move(finishCallback)));
+    Operator::registerOperator(
+        std::make_unique<BlockingNodeFactory>(
+            std::move(blockingCallback), std::move(finishCallback)));
 
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
     auto plan = PlanBuilder(planNodeIdGenerator)
@@ -1030,8 +1107,9 @@ TEST_F(
 
   auto finishCallback = [&](bool /*unused*/) {};
 
-  Operator::registerOperator(std::make_unique<BlockingNodeFactory>(
-      std::move(blockingCallback), std::move(finishCallback)));
+  Operator::registerOperator(
+      std::make_unique<BlockingNodeFactory>(
+          std::move(blockingCallback), std::move(finishCallback)));
 
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   auto plan = PlanBuilder(planNodeIdGenerator)
@@ -1143,11 +1221,23 @@ TEST_F(LocalPartitionTest, barrier) {
                           tableScanNode(),
                       })
                   .planNode();
+  struct {
+    bool hasBarrier;
+    bool serialExecution;
 
-  for (const auto hasBarrier : {false, true}) {
-    SCOPED_TRACE(fmt::format("hasBarrier {}", hasBarrier));
+    std::string toString() const {
+      return fmt::format(
+          "hasBarrier: {}, serialExecution: {}", hasBarrier, serialExecution);
+    }
+  } testSettings[] = {
+      {false, false}, {false, true}, {true, false}, {true, true}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.toString());
     AssertQueryBuilder queryBuilder(plan, duckDbQueryRunner_);
-    queryBuilder.barrierExecution(hasBarrier).serialExecution(true);
+    queryBuilder.barrierExecution(testData.hasBarrier)
+        .serialExecution(testData.serialExecution)
+        .maxDrivers(testData.serialExecution ? 1 : 3);
     for (auto i = 0; i < numSources; ++i) {
       for (auto j = 0; j < numSplits; ++j) {
         queryBuilder.split(
@@ -1156,7 +1246,8 @@ TEST_F(LocalPartitionTest, barrier) {
     }
 
     const auto task = queryBuilder.assertResults("SELECT * FROM tmp");
-    ASSERT_EQ(task->taskStats().numBarriers, hasBarrier ? numSplits : 0);
+    ASSERT_EQ(
+        task->taskStats().numBarriers, testData.hasBarrier ? numSplits : 0);
   }
 }
 
diff --git a/velox/exec/tests/Main.cpp b/velox/exec/tests/Main.cpp
index 164b6422fe8..39c009ebdd7 100644
--- a/velox/exec/tests/Main.cpp
+++ b/velox/exec/tests/Main.cpp
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/common/memory/Memory.h"
 #include "velox/common/process/ThreadDebugInfo.h"
 
 #include <folly/Unit.h>
@@ -25,5 +26,6 @@ int main(int argc, char** argv) {
   // Signal handler required for ThreadDebugInfoTest
   facebook::velox::process::addDefaultFatalSignalHandler();
   folly::Init init(&argc, &argv, false);
+  facebook::velox::memory::MemoryManager::initialize({});
   return RUN_ALL_TESTS();
 }
diff --git a/velox/exec/tests/MarkDistinctTest.cpp b/velox/exec/tests/MarkDistinctTest.cpp
index c7f04b41517..80faa68925b 100644
--- a/velox/exec/tests/MarkDistinctTest.cpp
+++ b/velox/exec/tests/MarkDistinctTest.cpp
@@ -14,13 +14,20 @@
  * limitations under the License.
  */
 
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 using namespace facebook::velox;
-using namespace facebook::velox::test;
 using namespace facebook::velox::exec::test;
+using namespace facebook::velox::test;
+using facebook::velox::exec::Operator;
+using facebook::velox::exec::TestScopedSpillInjection;
+using facebook::velox::memory::testingRunArbitration;
 
 class MarkDistinctTest : public OperatorTestBase {
  public:
@@ -42,6 +49,18 @@ class MarkDistinctTest : public OperatorTestBase {
     auto results = AssertQueryBuilder(plan).copyResults(pool());
     assertEqualVectors(expectedResults, results);
   }
+
+ protected:
+  MarkDistinctTest() {
+    filesystems::registerLocalFileSystem();
+  }
+
+  RowTypePtr rowType_{ROW({"c0", "c1"}, {BIGINT(), BIGINT()})};
+
+  VectorFuzzer::Options fuzzerOpts_{
+      .vectorSize = 1024,
+      .nullRatio = 0,
+      .allowLazyVector = false};
 };
 
 template <typename T>
@@ -141,3 +160,385 @@ TEST_F(MarkDistinctTest, aggregation) {
       .assertResults(
           "SELECT c0, sum(distinct c1), sum(distinct c2) FROM tmp GROUP BY 1");
 }
+
+TEST_F(MarkDistinctTest, spill) {
+  auto vectors = createVectors(8, rowType_, fuzzerOpts_);
+  createDuckDbTable(vectors);
+
+  struct {
+    uint32_t spillPartitionBits;
+    uint32_t numSpills;
+    uint32_t cpuTimeSliceLimitMs;
+
+    std::string debugString() const {
+      return fmt::format(
+          "spillPartitionBits {}, numSpills {}, cpuTimeSliceLimitMs {}",
+          spillPartitionBits,
+          numSpills,
+          cpuTimeSliceLimitMs);
+    }
+  } testSettings[] = {{2, 1, 0}, {3, 1, 0}, {2, 2, 0}, {2, 2, 10}, {2, 3, 10}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto queryCtx = core::QueryCtx::create(executor_.get());
+    TestScopedSpillInjection scopedSpillInjection(
+        100, ".*", testData.numSpills);
+
+    core::PlanNodeId markDistinctId;
+    auto task =
+        AssertQueryBuilder(duckDbQueryRunner_)
+            .spillDirectory(spillDirectory->getPath())
+            .config(core::QueryConfig::kSpillEnabled, true)
+            .config(core::QueryConfig::kMarkDistinctSpillEnabled, true)
+            .config(
+                core::QueryConfig::kSpillNumPartitionBits,
+                testData.spillPartitionBits)
+            .config(
+                core::QueryConfig::kDriverCpuTimeSliceLimitMs,
+                testData.cpuTimeSliceLimitMs)
+            .config(core::QueryConfig::kAggregationSpillEnabled, false)
+            .queryCtx(queryCtx)
+            .plan(
+                PlanBuilder()
+                    .values(vectors)
+                    .markDistinct("c1_distinct", {"c0", "c1"})
+                    .capturePlanNodeId(markDistinctId)
+                    .singleAggregation({"c0"}, {"count(c1)"}, {"c1_distinct"})
+                    .planNode())
+            .assertResults("SELECT c0, count(distinct c1) FROM tmp GROUP BY 1");
+
+    auto taskStats = exec::toPlanStats(task->taskStats());
+    auto& planStats = taskStats.at(markDistinctId);
+    ASSERT_GT(planStats.spilledBytes, 0);
+    ASSERT_GT(planStats.spilledFiles, 0);
+    ASSERT_GT(planStats.spilledRows, 0);
+    ASSERT_GT(planStats.spilledPartitions, 0);
+
+    task.reset();
+    waitForAllTasksToBeDeleted();
+  }
+}
+
+DEBUG_ONLY_TEST_F(MarkDistinctTest, reclaimDuringInputOrOutput) {
+  auto vectors = createVectors(8, rowType_, fuzzerOpts_);
+  createDuckDbTable(vectors);
+
+  struct {
+    std::string spillInjectionPoint;
+    uint32_t spillPartitionBits;
+
+    std::string debugString() const {
+      return fmt::format(
+          "spillInjectionPoint {}, spillPartitionBits {}",
+          spillInjectionPoint,
+          spillPartitionBits);
+    }
+  } testSettings[] = {
+      {"facebook::velox::exec::Driver::runInternal::addInput", 2},
+      {"facebook::velox::exec::Driver::runInternal::getOutput", 2},
+      {"facebook::velox::exec::Driver::runInternal::addInput", 3},
+      {"facebook::velox::exec::Driver::runInternal::getOutput", 3}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto queryCtx = core::QueryCtx::create(executor_.get());
+
+    std::atomic_int numRound{0};
+    SCOPED_TESTVALUE_SET(
+        testData.spillInjectionPoint,
+        std::function<void(Operator*)>(([&](Operator* op) {
+          if (op->operatorType() != "MarkDistinct") {
+            return;
+          }
+          if (++numRound != 5) {
+            return;
+          }
+          testingRunArbitration(op->pool(), 0);
+        })));
+
+    core::PlanNodeId markDistinctId;
+    auto task =
+        AssertQueryBuilder(duckDbQueryRunner_)
+            .spillDirectory(spillDirectory->getPath())
+            .config(core::QueryConfig::kSpillEnabled, true)
+            .config(core::QueryConfig::kMarkDistinctSpillEnabled, true)
+            .config(
+                core::QueryConfig::kSpillNumPartitionBits,
+                testData.spillPartitionBits)
+            .config(core::QueryConfig::kAggregationSpillEnabled, false)
+            .queryCtx(queryCtx)
+            .plan(
+                PlanBuilder()
+                    .values(vectors)
+                    .markDistinct("c1_distinct", {"c0", "c1"})
+                    .capturePlanNodeId(markDistinctId)
+                    .singleAggregation({"c0"}, {"count(c1)"}, {"c1_distinct"})
+                    .planNode())
+            .assertResults("SELECT c0, count(distinct c1) FROM tmp GROUP BY 1");
+
+    auto taskStats = exec::toPlanStats(task->taskStats());
+    auto& planStats = taskStats.at(markDistinctId);
+    ASSERT_GT(planStats.spilledBytes, 0);
+    ASSERT_GT(planStats.spilledFiles, 0);
+    ASSERT_GT(planStats.spilledRows, 0);
+    ASSERT_GT(planStats.spilledPartitions, 0);
+
+    task.reset();
+    waitForAllTasksToBeDeleted();
+  }
+}
+
+DEBUG_ONLY_TEST_F(MarkDistinctTest, recursiveSpill) {
+  auto vectors = createVectors(32, rowType_, fuzzerOpts_);
+  createDuckDbTable(vectors);
+
+  struct {
+    int32_t numSpills;
+    int32_t maxSpillLevel;
+
+    std::string debugString() const {
+      return fmt::format(
+          "numSpills {}, maxSpillLevel {}", numSpills, maxSpillLevel);
+    }
+  } testSettings[] = {{2, 3}, {8, 4}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto queryCtx = core::QueryCtx::create(executor_.get());
+
+    std::atomic_int numSpills{0};
+    std::atomic_int numInputs{0};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::addInput",
+        std::function<void(Operator*)>(([&](Operator* op) {
+          if (op->operatorType() != "MarkDistinct") {
+            return;
+          }
+          if (++numInputs != 5) {
+            return;
+          }
+          ++numSpills;
+          testingRunArbitration(op->pool(), 0);
+        })));
+
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::getOutput",
+        std::function<void(Operator*)>(([&](Operator* op) {
+          if (op->operatorType() != "MarkDistinct") {
+            return;
+          }
+          if (!op->testingNoMoreInput()) {
+            return;
+          }
+          if (numSpills++ >= testData.numSpills) {
+            return;
+          }
+          testingRunArbitration(op->pool(), 0);
+        })));
+
+    core::PlanNodeId markDistinctId;
+    auto task =
+        AssertQueryBuilder(duckDbQueryRunner_)
+            .spillDirectory(spillDirectory->getPath())
+            .config(core::QueryConfig::kSpillEnabled, true)
+            .config(core::QueryConfig::kMarkDistinctSpillEnabled, true)
+            .config(
+                core::QueryConfig::kMaxSpillLevel, testData.maxSpillLevel - 1)
+            .config(core::QueryConfig::kAggregationSpillEnabled, false)
+            .queryCtx(queryCtx)
+            .plan(
+                PlanBuilder()
+                    .values(vectors)
+                    .markDistinct("c1_distinct", {"c0", "c1"})
+                    .capturePlanNodeId(markDistinctId)
+                    .singleAggregation({"c0"}, {"count(c1)"}, {"c1_distinct"})
+                    .planNode())
+            .assertResults("SELECT c0, count(distinct c1) FROM tmp GROUP BY 1");
+
+    auto taskStats = exec::toPlanStats(task->taskStats());
+    auto& planStats = taskStats.at(markDistinctId);
+    ASSERT_GT(planStats.spilledBytes, 0);
+    ASSERT_GT(planStats.spilledFiles, 0);
+    ASSERT_GT(planStats.spilledRows, 0);
+
+    auto runTimeStats =
+        task->taskStats().pipelineStats.back().operatorStats.at(1).runtimeStats;
+    if (testData.numSpills > testData.maxSpillLevel) {
+      ASSERT_GT(runTimeStats["exceededMaxSpillLevel"].sum, 0);
+    } else {
+      ASSERT_EQ(runTimeStats.count("exceededMaxSpillLevel"), 0);
+    }
+
+    task.reset();
+    waitForAllTasksToBeDeleted();
+  }
+}
+
+TEST_F(MarkDistinctTest, spillWithDuplicateKeys) {
+  // Verifies correctness when the same key appears in both pre-spill and
+  // post-spill input batches. The hash table state must be preserved through
+  // spill/restore so that keys already marked as distinct before spill are not
+  // re-marked during restore.
+  auto vectors = {
+      makeRowVector({
+          makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+          makeFlatVector<int64_t>({10, 20, 30, 40, 50}),
+      }),
+      makeRowVector({
+          makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+          makeFlatVector<int64_t>({10, 20, 30, 40, 50}),
+      }),
+      makeRowVector({
+          makeFlatVector<int64_t>({1, 2, 6, 7, 8}),
+          makeFlatVector<int64_t>({10, 20, 60, 70, 80}),
+      }),
+      makeRowVector({
+          makeFlatVector<int64_t>({1, 2, 3, 9, 10}),
+          makeFlatVector<int64_t>({10, 20, 30, 90, 100}),
+      }),
+  };
+  createDuckDbTable(vectors);
+
+  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+  // Trigger spill after the second batch so pre-spill output includes keys
+  // that also appear in post-spill batches.
+  TestScopedSpillInjection scopedSpillInjection(100, ".*", 1);
+
+  core::PlanNodeId markDistinctId;
+  auto task =
+      AssertQueryBuilder(duckDbQueryRunner_)
+          .spillDirectory(spillDirectory->getPath())
+          .config(core::QueryConfig::kSpillEnabled, true)
+          .config(core::QueryConfig::kMarkDistinctSpillEnabled, true)
+          .config(core::QueryConfig::kAggregationSpillEnabled, false)
+          .queryCtx(queryCtx)
+          .plan(
+              PlanBuilder()
+                  .values(vectors)
+                  .markDistinct("c1_distinct", {"c0", "c1"})
+                  .capturePlanNodeId(markDistinctId)
+                  .singleAggregation({"c0"}, {"count(c1)"}, {"c1_distinct"})
+                  .planNode())
+          .assertResults("SELECT c0, count(distinct c1) FROM tmp GROUP BY 1");
+
+  auto taskStats = exec::toPlanStats(task->taskStats());
+  auto& planStats = taskStats.at(markDistinctId);
+  ASSERT_GT(planStats.spilledBytes, 0);
+  ASSERT_GT(planStats.spilledRows, 0);
+
+  task.reset();
+  waitForAllTasksToBeDeleted();
+}
+
+TEST_F(MarkDistinctTest, memoryUsage) {
+  const auto rowType =
+      ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), VARCHAR()});
+  const auto vectors = createVectors(rowType, 1024, 100 << 20);
+
+  core::PlanNodeId markDistinctId;
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .markDistinct("c1_distinct", {"c0", "c1"})
+                  .capturePlanNodeId(markDistinctId)
+                  .singleAggregation({"c0"}, {"count(c1)"}, {"c1_distinct"})
+                  .planNode();
+
+  struct {
+    uint8_t numSpills;
+
+    std::string debugString() const {
+      return fmt::format("numSpills {}", numSpills);
+    }
+  } testSettings[] = {{1}, {3}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    int64_t peakBytesWithSpilling = 0;
+    int64_t peakBytesWithOutSpilling = 0;
+
+    for (const auto& spillEnable : {false, true}) {
+      auto queryCtx = core::QueryCtx::create(executor_.get());
+      auto spillDirectory = exec::test::TempDirectoryPath::create();
+      const std::string spillEnableConfig = std::to_string(spillEnable);
+
+      std::shared_ptr<exec::Task> task;
+      TestScopedSpillInjection scopedSpillInjection(
+          100, ".*", testData.numSpills);
+      AssertQueryBuilder(plan)
+          .spillDirectory(spillDirectory->getPath())
+          .queryCtx(queryCtx)
+          .config(core::QueryConfig::kSpillEnabled, spillEnableConfig)
+          .config(
+              core::QueryConfig::kMarkDistinctSpillEnabled, spillEnableConfig)
+          .config(core::QueryConfig::kAggregationSpillEnabled, "false")
+          .copyResults(pool_.get(), task);
+
+      if (spillEnable) {
+        peakBytesWithSpilling = queryCtx->pool()->peakBytes();
+        auto taskStats = exec::toPlanStats(task->taskStats());
+        const auto& stats = taskStats.at(markDistinctId);
+
+        ASSERT_GT(stats.spilledBytes, 0);
+        ASSERT_GT(stats.spilledRows, 0);
+        ASSERT_GT(stats.spilledFiles, 0);
+        ASSERT_GT(stats.spilledPartitions, 0);
+      } else {
+        peakBytesWithOutSpilling = queryCtx->pool()->peakBytes();
+      }
+    }
+
+    ASSERT_GT(peakBytesWithOutSpilling, peakBytesWithSpilling);
+  }
+}
+
+TEST_F(MarkDistinctTest, maxSpillBytes) {
+  auto rowType = ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), VARCHAR()});
+  auto vectors = createVectors(rowType, 1024, 15 << 20);
+
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .markDistinct("c1_distinct", {"c0", "c1"})
+                  .singleAggregation({"c0"}, {"count(c1)"}, {"c1_distinct"})
+                  .planNode();
+
+  struct {
+    int32_t maxSpilledBytes;
+    bool expectedExceedLimit;
+
+    std::string debugString() const {
+      return fmt::format("maxSpilledBytes {}", maxSpilledBytes);
+    }
+  } testSettings[] = {{1 << 30, false}, {1 << 20, true}, {0, false}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto queryCtx = core::QueryCtx::create(executor_.get());
+    try {
+      TestScopedSpillInjection scopedSpillInjection(100, ".*", 1);
+      AssertQueryBuilder(plan)
+          .spillDirectory(spillDirectory->getPath())
+          .queryCtx(queryCtx)
+          .config(core::QueryConfig::kSpillEnabled, true)
+          .config(core::QueryConfig::kMarkDistinctSpillEnabled, true)
+          .config(core::QueryConfig::kAggregationSpillEnabled, false)
+          .config(core::QueryConfig::kMaxSpillBytes, testData.maxSpilledBytes)
+          .copyResults(pool_.get());
+      ASSERT_FALSE(testData.expectedExceedLimit);
+    } catch (const VeloxRuntimeError& e) {
+      ASSERT_TRUE(testData.expectedExceedLimit);
+      ASSERT_NE(
+          e.message().find(
+              "Query exceeded per-query local spill limit of 1.00MB"),
+          std::string::npos);
+      ASSERT_EQ(
+          e.errorCode(), facebook::velox::error_code::kSpillLimitExceeded);
+    }
+  }
+}
diff --git a/velox/exec/tests/MarkSortedTest.cpp b/velox/exec/tests/MarkSortedTest.cpp
new file mode 100644
index 00000000000..1f79ea64c6d
--- /dev/null
+++ b/velox/exec/tests/MarkSortedTest.cpp
@@ -0,0 +1,482 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::core;
+
+class MarkSortedTest : public OperatorTestBase {
+ protected:
+  void assertMarkSortedResults(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<std::string>& sortingKeys,
+      const std::vector<core::SortOrder>& sortingOrders,
+      const std::string& markerName,
+      const std::vector<bool>& expectedMarkers) {
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .markSorted(markerName, sortingKeys, sortingOrders)
+                    .planNode();
+
+    auto results = AssertQueryBuilder(plan).copyResults(pool());
+
+    // Verify marker column exists and has correct values.
+    auto markerIdx = static_cast<column_index_t>(results->childrenSize() - 1);
+    auto markerVector = results->childAt(markerIdx);
+    ASSERT_EQ(markerVector->size(), expectedMarkers.size());
+
+    auto flatMarker = markerVector->as<FlatVector<bool>>();
+    for (vector_size_t i = 0; i < expectedMarkers.size(); ++i) {
+      ASSERT_EQ(flatMarker->valueAt(i), expectedMarkers[i])
+          << "Mismatch at row " << i;
+    }
+  }
+
+  void assertMarkSortedResultsWithConfig(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<std::string>& sortingKeys,
+      const std::vector<core::SortOrder>& sortingOrders,
+      const std::string& markerName,
+      const std::vector<bool>& expectedMarkers,
+      const std::unordered_map<std::string, std::string>& configs) {
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .markSorted(markerName, sortingKeys, sortingOrders)
+                    .planNode();
+
+    auto builder = AssertQueryBuilder(plan);
+    for (const auto& [key, value] : configs) {
+      builder.config(key, value);
+    }
+    auto results = builder.copyResults(pool());
+
+    auto markerIdx = static_cast<column_index_t>(results->childrenSize() - 1);
+    auto markerVector = results->childAt(markerIdx);
+    ASSERT_EQ(markerVector->size(), expectedMarkers.size());
+
+    auto flatMarker = markerVector->as<FlatVector<bool>>();
+    for (vector_size_t i = 0; i < expectedMarkers.size(); ++i) {
+      ASSERT_EQ(flatMarker->valueAt(i), expectedMarkers[i])
+          << "Mismatch at row " << i;
+    }
+  }
+};
+
+TEST_F(MarkSortedTest, singleKeyAscSorted) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+  });
+
+  assertMarkSortedResults(
+      {data},
+      {"c0"},
+      {core::kAscNullsLast},
+      "is_sorted",
+      {true, true, true, true, true});
+}
+
+TEST_F(MarkSortedTest, singleKeyDescSorted) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({5, 4, 3, 2, 1}),
+  });
+
+  assertMarkSortedResults(
+      {data},
+      {"c0"},
+      {core::kDescNullsLast},
+      "is_sorted",
+      {true, true, true, true, true});
+}
+
+TEST_F(MarkSortedTest, singleKeyAscUnsorted) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({1, 3, 2, 4, 5}),
+  });
+
+  assertMarkSortedResults(
+      {data},
+      {"c0"},
+      {core::kAscNullsLast},
+      "is_sorted",
+      {true, true, false, true, true});
+}
+
+TEST_F(MarkSortedTest, singleKeyDescUnsorted) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({5, 4, 6, 2, 1}),
+  });
+
+  assertMarkSortedResults(
+      {data},
+      {"c0"},
+      {core::kDescNullsLast},
+      "is_sorted",
+      {true, true, false, true, true});
+}
+
+TEST_F(MarkSortedTest, multipleKeysSorted) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({1, 1, 2, 2, 3}),
+      makeFlatVector<int32_t>({1, 2, 1, 2, 1}),
+  });
+
+  assertMarkSortedResults(
+      {data},
+      {"c0", "c1"},
+      {core::kAscNullsLast, core::kAscNullsLast},
+      "is_sorted",
+      {true, true, true, true, true});
+}
+
+TEST_F(MarkSortedTest, multipleKeysUnsorted) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({1, 1, 2, 2, 3}),
+      makeFlatVector<int32_t>({1, 3, 2, 1, 1}),
+  });
+
+  assertMarkSortedResults(
+      {data},
+      {"c0", "c1"},
+      {core::kAscNullsLast, core::kAscNullsLast},
+      "is_sorted",
+      {true, true, true, false, true});
+}
+
+TEST_F(MarkSortedTest, nullsFirstSorted) {
+  auto data = makeRowVector({
+      makeNullableFlatVector<int32_t>({std::nullopt, std::nullopt, 1, 2, 3}),
+  });
+
+  assertMarkSortedResults(
+      {data},
+      {"c0"},
+      {core::kAscNullsFirst},
+      "is_sorted",
+      {true, true, true, true, true});
+}
+
+TEST_F(MarkSortedTest, nullsLastSorted) {
+  auto data = makeRowVector({
+      makeNullableFlatVector<int32_t>({1, 2, 3, std::nullopt, std::nullopt}),
+  });
+
+  assertMarkSortedResults(
+      {data},
+      {"c0"},
+      {core::kAscNullsLast},
+      "is_sorted",
+      {true, true, true, true, true});
+}
+
+TEST_F(MarkSortedTest, nullsFirstUnsorted) {
+  auto data = makeRowVector({
+      makeNullableFlatVector<int32_t>({1, std::nullopt, 2, 3, 4}),
+  });
+
+  assertMarkSortedResults(
+      {data},
+      {"c0"},
+      {core::kAscNullsFirst},
+      "is_sorted",
+      {true, false, true, true, true});
+}
+
+TEST_F(MarkSortedTest, crossBatchSorted) {
+  auto batch1 = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 3}),
+  });
+  auto batch2 = makeRowVector({
+      makeFlatVector<int32_t>({4, 5, 6}),
+  });
+
+  assertMarkSortedResults(
+      {batch1, batch2},
+      {"c0"},
+      {core::kAscNullsLast},
+      "is_sorted",
+      {true, true, true, true, true, true});
+}
+
+TEST_F(MarkSortedTest, crossBatchUnsorted) {
+  auto batch1 = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 5}),
+  });
+  auto batch2 = makeRowVector({
+      makeFlatVector<int32_t>({3, 4, 6}),
+  });
+
+  assertMarkSortedResults(
+      {batch1, batch2},
+      {"c0"},
+      {core::kAscNullsLast},
+      "is_sorted",
+      {true, true, true, false, true, true});
+}
+
+TEST_F(MarkSortedTest, emptyBatch) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({}),
+  });
+
+  assertMarkSortedResults(
+      {data}, {"c0"}, {core::kAscNullsLast}, "is_sorted", {});
+}
+
+TEST_F(MarkSortedTest, allNullValues) {
+  auto data = makeRowVector({
+      makeNullableFlatVector<int32_t>(
+          {std::nullopt, std::nullopt, std::nullopt}),
+  });
+
+  assertMarkSortedResults(
+      {data}, {"c0"}, {core::kAscNullsLast}, "is_sorted", {true, true, true});
+}
+
+TEST_F(MarkSortedTest, firstRowAlwaysTrue) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({100, 1, 2, 3}),
+  });
+
+  assertMarkSortedResults(
+      {data},
+      {"c0"},
+      {core::kAscNullsLast},
+      "is_sorted",
+      {true, false, true, true});
+}
+
+TEST_F(MarkSortedTest, singleRow) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({42}),
+  });
+
+  assertMarkSortedResults(
+      {data}, {"c0"}, {core::kAscNullsLast}, "is_sorted", {true});
+}
+
+TEST_F(MarkSortedTest, stringKey) {
+  auto data = makeRowVector({
+      makeFlatVector<std::string>({"apple", "banana", "cherry", "date"}),
+  });
+
+  assertMarkSortedResults(
+      {data},
+      {"c0"},
+      {core::kAscNullsLast},
+      "is_sorted",
+      {true, true, true, true});
+}
+
+TEST_F(MarkSortedTest, stringKeyUnsorted) {
+  auto data = makeRowVector({
+      makeFlatVector<std::string>({"apple", "cherry", "banana", "date"}),
+  });
+
+  assertMarkSortedResults(
+      {data},
+      {"c0"},
+      {core::kAscNullsLast},
+      "is_sorted",
+      {true, true, false, true});
+}
+
+// --- Optimization tests ---
+
+TEST_F(MarkSortedTest, constantVectorSorted) {
+  // All key columns are constant non-null — trivially sorted.
+  auto data = makeRowVector({
+      BaseVector::createConstant(INTEGER(), 42, 5, pool()),
+  });
+
+  assertMarkSortedResults(
+      {data},
+      {"c0"},
+      {core::kAscNullsLast},
+      "is_sorted",
+      {true, true, true, true, true});
+}
+
+TEST_F(MarkSortedTest, constantVectorWithNull) {
+  // Constant null key — falls back to generic path.
+  auto data = makeRowVector({
+      BaseVector::createNullConstant(INTEGER(), 5, pool()),
+  });
+
+  assertMarkSortedResults(
+      {data},
+      {"c0"},
+      {core::kAscNullsLast},
+      "is_sorted",
+      {true, true, true, true, true});
+}
+
+TEST_F(MarkSortedTest, simdPathInteger) {
+  // Single flat non-null INTEGER key — uses SIMD path (ascending).
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6, 7, 8}),
+  });
+
+  assertMarkSortedResults(
+      {data},
+      {"c0"},
+      {core::kAscNullsLast},
+      "is_sorted",
+      {true, true, true, true, true, true, true, true});
+}
+
+TEST_F(MarkSortedTest, simdPathBigint) {
+  // SIMD path with BIGINT key (descending), with unsorted violations.
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({100, 90, 80, 85, 70, 60, 50, 40}),
+  });
+
+  assertMarkSortedResults(
+      {data},
+      {"c0"},
+      {core::kDescNullsLast},
+      "is_sorted",
+      {true, true, true, false, true, true, true, true});
+}
+
+TEST_F(MarkSortedTest, genericPathDouble) {
+  // DOUBLE key — SIMD not applicable for floating point, uses generic path.
+  auto data = makeRowVector({
+      makeFlatVector<double>({1.0, 2.0, 3.0, 2.5, 4.0}),
+  });
+
+  assertMarkSortedResults(
+      {data},
+      {"c0"},
+      {core::kAscNullsLast},
+      "is_sorted",
+      {true, true, true, false, true});
+}
+
+TEST_F(MarkSortedTest, simdFallbackMultiKey) {
+  // Multi-key: SIMD not applicable, falls back to generic.
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({1, 1, 2, 2, 3}),
+      makeFlatVector<int32_t>({1, 2, 1, 2, 1}),
+  });
+
+  assertMarkSortedResults(
+      {data},
+      {"c0", "c1"},
+      {core::kAscNullsLast, core::kAscNullsLast},
+      "is_sorted",
+      {true, true, true, true, true});
+}
+
+TEST_F(MarkSortedTest, simdFallbackVarchar) {
+  // VARCHAR key: SIMD not applicable, falls back to generic.
+  auto data = makeRowVector({
+      makeFlatVector<std::string>({"a", "b", "c", "d", "e"}),
+  });
+
+  assertMarkSortedResults(
+      {data},
+      {"c0"},
+      {core::kAscNullsLast},
+      "is_sorted",
+      {true, true, true, true, true});
+}
+
+TEST_F(MarkSortedTest, simdFallbackWithNulls) {
+  // Flat vector with nulls — SIMD not applicable, falls back to generic.
+  // With kAscNullsLast, null > any value, so row 3 (4 after null) is unsorted.
+  auto data = makeRowVector({
+      makeNullableFlatVector<int32_t>({1, 2, std::nullopt, 4, 5}),
+  });
+
+  assertMarkSortedResults(
+      {data},
+      {"c0"},
+      {core::kAscNullsLast},
+      "is_sorted",
+      {true, true, true, false, true});
+}
+
+TEST_F(MarkSortedTest, zeroCopySmallBatch) {
+  // Small batches (< threshold) use zero-copy cross-batch. Verify correctness.
+  auto batch1 = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 3}),
+  });
+  auto batch2 = makeRowVector({
+      makeFlatVector<int32_t>({4, 5, 6}),
+  });
+
+  // Default threshold is 1000, so 3-row batches use zero-copy.
+  assertMarkSortedResults(
+      {batch1, batch2},
+      {"c0"},
+      {core::kAscNullsLast},
+      "is_sorted",
+      {true, true, true, true, true, true});
+}
+
+TEST_F(MarkSortedTest, copyLargeBatch) {
+  // Set threshold very low so even small batches use copy mode.
+  auto batch1 = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 5}),
+  });
+  auto batch2 = makeRowVector({
+      makeFlatVector<int32_t>({3, 4, 6}),
+  });
+
+  assertMarkSortedResultsWithConfig(
+      {batch1, batch2},
+      {"c0"},
+      {core::kAscNullsLast},
+      "is_sorted",
+      {true, true, true, false, true, true},
+      {{QueryConfig::kMarkSortedZeroCopyThreshold, "1"}});
+}
+
+TEST_F(MarkSortedTest, zeroCopyThresholdConfig) {
+  // Verify threshold is configurable: set to 2 so batch of 3 uses copy mode
+  // and batch of 1 uses zero-copy.
+  auto batch1 = makeRowVector({
+      makeFlatVector<int32_t>({10}),
+  });
+  auto batch2 = makeRowVector({
+      makeFlatVector<int32_t>({5, 6, 7}),
+  });
+
+  // batch1 (1 row) < threshold(2) → zero-copy
+  // batch2 first row (5) < prev (10) → unsorted for ascending
+  assertMarkSortedResultsWithConfig(
+      {batch1, batch2},
+      {"c0"},
+      {core::kAscNullsLast},
+      "is_sorted",
+      {true, false, true, true},
+      {{QueryConfig::kMarkSortedZeroCopyThreshold, "2"}});
+}
+
+TEST_F(MarkSortedTest, simdSmallBatch) {
+  // SIMD works correctly with very small batches (< 16 rows).
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({3, 1, 2}),
+  });
+
+  assertMarkSortedResults(
+      {data}, {"c0"}, {core::kAscNullsLast}, "is_sorted", {true, false, true});
+}
diff --git a/velox/exec/tests/MergeJoinTest.cpp b/velox/exec/tests/MergeJoinTest.cpp
index 4019cc9b80b..cbaae09a0bf 100644
--- a/velox/exec/tests/MergeJoinTest.cpp
+++ b/velox/exec/tests/MergeJoinTest.cpp
@@ -16,11 +16,12 @@
 
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/testutil/TestValue.h"
+#include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 
-#include "folly/experimental/EventCount.h"
+#include "folly/synchronization/EventCount.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::common::testutil;
@@ -112,12 +113,13 @@ class MergeJoinTest : public HiveConnectorTestBase {
     for (const auto& row : input) {
       std::vector<VectorPtr> children;
       for (const auto& child : row->children()) {
-        children.push_back(std::make_shared<LazyVector>(
-            pool(),
-            child->type(),
-            child->size(),
-            std::make_unique<MySimpleVectorLoader>(
-                batchId, counter, [=, this](RowSet) { return child; })));
+        children.push_back(
+            std::make_shared<LazyVector>(
+                pool(),
+                child->type(),
+                child->size(),
+                std::make_unique<MySimpleVectorLoader>(
+                    batchId, counter, [=, this](RowSet) { return child; })));
       }
 
       data.push_back(makeRowVector(children));
@@ -369,6 +371,87 @@ class MergeJoinTest : public HiveConnectorTestBase {
         std::bind(
             &MergeJoinTest::generateLazyInput, this, std::placeholders::_1));
   }
+
+  void testJoinTwoKeysWithNulls(
+      RowVectorPtr& leftVectors,
+      RowVectorPtr& rightVectors) {
+    auto leftFile = TempFilePath::create();
+    writeToFile(leftFile->getPath(), leftVectors);
+    createDuckDbTable("t", {leftVectors});
+    auto rightFile = TempFilePath::create();
+    writeToFile(rightFile->getPath(), rightVectors);
+    createDuckDbTable("u", {rightVectors});
+
+    auto joinTypes = {
+        core::JoinType::kInner,
+        core::JoinType::kLeft,
+        core::JoinType::kRight,
+        core::JoinType::kFull,
+    };
+
+    for (auto joinType : joinTypes) {
+      auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+      core::PlanNodeId leftScanId;
+      core::PlanNodeId rightScanId;
+      auto op = PlanBuilder(planNodeIdGenerator)
+                    .tableScan(
+                        ROW({"c0", "c1", "c2", "c3"},
+                            {VARCHAR(), VARCHAR(), VARCHAR(), VARCHAR()}))
+                    .capturePlanNodeId(leftScanId)
+                    .mergeJoin(
+                        {"c0", "c1"},
+                        {"rc0", "rc1"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .tableScan(
+                                ROW({"rc0", "rc1", "rc2"},
+                                    {VARCHAR(), VARCHAR(), VARCHAR()}))
+                            .capturePlanNodeId(rightScanId)
+                            .planNode(),
+                        "",
+                        {"c0", "c1", "c2", "c3", "rc0", "rc1", "rc2"},
+                        joinType)
+                    .planNode();
+      AssertQueryBuilder(op, duckDbQueryRunner_)
+          .split(rightScanId, makeHiveConnectorSplit(rightFile->getPath()))
+          .split(leftScanId, makeHiveConnectorSplit(leftFile->getPath()))
+          .assertResults(
+              fmt::format(
+                  "SELECT * FROM t {} JOIN u "
+                  "ON t.c0 = u.rc0 AND t.c1 = u.rc1",
+                  core::JoinTypeName::toName(joinType)));
+    }
+
+    {
+      // anti join
+      auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+      core::PlanNodeId leftScanId;
+      core::PlanNodeId rightScanId;
+      auto op = PlanBuilder(planNodeIdGenerator)
+                    .tableScan(
+                        ROW({"c0", "c1", "c2", "c3"},
+                            {VARCHAR(), VARCHAR(), VARCHAR(), VARCHAR()}))
+                    .capturePlanNodeId(leftScanId)
+                    .mergeJoin(
+                        {"c0", "c1"},
+                        {"rc0", "rc1"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .tableScan(
+                                ROW({"rc0", "rc1", "rc2"},
+                                    {VARCHAR(), VARCHAR(), VARCHAR()}))
+                            .capturePlanNodeId(rightScanId)
+                            .planNode(),
+                        "",
+                        {"c0", "c1", "c2", "c3"},
+                        core::JoinType::kAnti)
+                    .planNode();
+      AssertQueryBuilder(op, duckDbQueryRunner_)
+          .split(rightScanId, makeHiveConnectorSplit(rightFile->getPath()))
+          .split(leftScanId, makeHiveConnectorSplit(leftFile->getPath()))
+          .assertResults(
+              "SELECT * FROM t WHERE NOT exists (select * from u "
+              "where t.c0 = u.rc0 AND t.c1 = u.rc1)");
+    }
+  }
 };
 
 TEST_F(MergeJoinTest, oneToOneAllMatch) {
@@ -870,10 +953,11 @@ TEST_F(MergeJoinTest, lazyVectors) {
     AssertQueryBuilder(op, duckDbQueryRunner_)
         .split(rightScanId, makeHiveConnectorSplit(rightFile->getPath()))
         .split(leftScanId, makeHiveConnectorSplit(leftFile->getPath()))
-        .assertResults(fmt::format(
-            "SELECT c0, rc0, c1, rc1, c2, c3 FROM t {} JOIN u "
-            "ON t.c0 = u.rc0 AND c1 + rc1 < 30",
-            core::JoinTypeName::toName(joinType)));
+        .assertResults(
+            fmt::format(
+                "SELECT c0, rc0, c1, rc1, c2, c3 FROM t {} JOIN u "
+                "ON t.c0 = u.rc0 AND c1 + rc1 < 30",
+                core::JoinTypeName::toName(joinType)));
   }
 }
 
@@ -1310,6 +1394,160 @@ TEST_F(MergeJoinTest, antiJoinWithTwoJoinKeys) {
           "SELECT * FROM t WHERE NOT exists (select * from u where t.a = u.c and t.b < u.d)");
 }
 
+TEST_F(MergeJoinTest, matchRatioStats) {
+  // Test match ratio statistics for different join scenarios.
+
+  // Inner join with full match (all rows match).
+  {
+    auto left = makeRowVector(
+        {"t0"}, {makeNullableFlatVector<int64_t>({1, 2, 3, 4, 5})});
+    auto right = makeRowVector(
+        {"u0"}, {makeNullableFlatVector<int64_t>({1, 2, 3, 4, 5})});
+
+    createDuckDbTable("t", {left});
+    createDuckDbTable("u", {right});
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId mergeJoinNodeId;
+    auto plan =
+        PlanBuilder(planNodeIdGenerator)
+            .values({left})
+            .mergeJoin(
+                {"t0"},
+                {"u0"},
+                PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+                "",
+                {"t0", "u0"},
+                core::JoinType::kInner)
+            .capturePlanNodeId(mergeJoinNodeId)
+            .planNode();
+
+    auto task = AssertQueryBuilder(plan, duckDbQueryRunner_)
+                    .assertResults("SELECT t0, u0 FROM t, u WHERE t0 = u0");
+
+    auto stats = toPlanStats(task->taskStats());
+    ASSERT_EQ(stats.at(mergeJoinNodeId).outputRows, 5);
+
+    auto runtimeStats = stats.at(mergeJoinNodeId).customStats;
+    ASSERT_EQ(runtimeStats.at("matchedLeftRows").sum, 5);
+    ASSERT_EQ(runtimeStats.at("matchedRightRows").sum, 5);
+  }
+
+  // Inner join with partial match.
+  {
+    auto left = makeRowVector(
+        {"t0"}, {makeNullableFlatVector<int64_t>({1, 2, 3, 4, 5, 6, 7, 8})});
+    auto right = makeRowVector(
+        {"u0"}, {makeNullableFlatVector<int64_t>({2, 4, 6, 10, 12})});
+
+    createDuckDbTable("t", {left});
+    createDuckDbTable("u", {right});
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId mergeJoinNodeId;
+    auto plan =
+        PlanBuilder(planNodeIdGenerator)
+            .values({left})
+            .mergeJoin(
+                {"t0"},
+                {"u0"},
+                PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+                "",
+                {"t0", "u0"},
+                core::JoinType::kInner)
+            .capturePlanNodeId(mergeJoinNodeId)
+            .planNode();
+
+    auto task = AssertQueryBuilder(plan, duckDbQueryRunner_)
+                    .assertResults("SELECT t0, u0 FROM t, u WHERE t0 = u0");
+
+    auto stats = toPlanStats(task->taskStats());
+    ASSERT_EQ(stats.at(mergeJoinNodeId).outputRows, 3);
+
+    auto runtimeStats = stats.at(mergeJoinNodeId).customStats;
+    // Only 3 left rows match (2, 4, 6).
+    ASSERT_EQ(runtimeStats.at("matchedLeftRows").sum, 3);
+    // Only 3 right rows match (2, 4, 6).
+    ASSERT_EQ(runtimeStats.at("matchedRightRows").sum, 3);
+  }
+
+  // Left join - all left rows appear in output.
+  {
+    auto left = makeRowVector(
+        {"t0"}, {makeNullableFlatVector<int64_t>({1, 2, 3, 4, 5})});
+    auto right =
+        makeRowVector({"u0"}, {makeNullableFlatVector<int64_t>({2, 4})});
+
+    createDuckDbTable("t", {left});
+    createDuckDbTable("u", {right});
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId mergeJoinNodeId;
+    auto plan =
+        PlanBuilder(planNodeIdGenerator)
+            .values({left})
+            .mergeJoin(
+                {"t0"},
+                {"u0"},
+                PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+                "",
+                {"t0", "u0"},
+                core::JoinType::kLeft)
+            .capturePlanNodeId(mergeJoinNodeId)
+            .planNode();
+
+    auto task =
+        AssertQueryBuilder(plan, duckDbQueryRunner_)
+            .assertResults("SELECT t0, u0 FROM t LEFT JOIN u ON t0 = u0");
+
+    auto stats = toPlanStats(task->taskStats());
+    ASSERT_EQ(stats.at(mergeJoinNodeId).outputRows, 5);
+
+    auto runtimeStats = stats.at(mergeJoinNodeId).customStats;
+    // Only 2 left rows match (2, 4).
+    ASSERT_EQ(runtimeStats.at("matchedLeftRows").sum, 2);
+    ASSERT_EQ(runtimeStats.at("matchedRightRows").sum, 2);
+  }
+
+  // Join with duplicate keys (cartesian product).
+  {
+    auto left = makeRowVector(
+        {"t0"}, {makeNullableFlatVector<int64_t>({1, 1, 1, 2, 2})});
+    auto right = makeRowVector(
+        {"u0"}, {makeNullableFlatVector<int64_t>({1, 1, 2, 2, 2})});
+
+    createDuckDbTable("t", {left});
+    createDuckDbTable("u", {right});
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId mergeJoinNodeId;
+    auto plan =
+        PlanBuilder(planNodeIdGenerator)
+            .values({left})
+            .mergeJoin(
+                {"t0"},
+                {"u0"},
+                PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+                "",
+                {"t0", "u0"},
+                core::JoinType::kInner)
+            .capturePlanNodeId(mergeJoinNodeId)
+            .planNode();
+
+    auto task = AssertQueryBuilder(plan, duckDbQueryRunner_)
+                    .assertResults("SELECT t0, u0 FROM t, u WHERE t0 = u0");
+
+    auto stats = toPlanStats(task->taskStats());
+    ASSERT_EQ(stats.at(mergeJoinNodeId).outputRows, 12);
+
+    auto runtimeStats = stats.at(mergeJoinNodeId).customStats;
+    // 3 left rows with key=1 and 2 left rows with key=2.
+    ASSERT_EQ(runtimeStats.at("matchedLeftRows").sum, 5);
+    // 2 right rows with key=1 and 3 right rows with key=2.
+    ASSERT_EQ(runtimeStats.at("matchedRightRows").sum, 5);
+  }
+}
+
 TEST_F(MergeJoinTest, antiJoinWithUniqueJoinKeys) {
   auto left = makeRowVector(
       {"a", "b"},
@@ -1704,6 +1942,20 @@ TEST_F(MergeJoinTest, barrier) {
 
   createDuckDbTable("t", {left});
   createDuckDbTable("u", {right});
+  struct {
+    bool hasBarrier;
+    bool serialExecution;
+
+    std::string toString() const {
+      return fmt::format(
+          "hasBarrier: {}, serialExecution: {}", hasBarrier, serialExecution);
+    }
+  } testSettings[] = {
+      {false, false},
+      {false, true},
+      {true, false},
+      {true, true},
+  };
 
   {
     // Inner join.
@@ -1730,10 +1982,12 @@ TEST_F(MergeJoinTest, barrier) {
                 {"t0", "t1", "u0", "u1"},
                 core::JoinType::kInner)
             .planNode();
-    for (const auto hasBarrier : {false, true}) {
-      SCOPED_TRACE(fmt::format("hasBarrier {}", hasBarrier));
+    for (const auto& testData : testSettings) {
+      SCOPED_TRACE(testData.toString());
       AssertQueryBuilder queryBuilder(plan, duckDbQueryRunner_);
-      queryBuilder.barrierExecution(hasBarrier).serialExecution(true);
+      queryBuilder.barrierExecution(testData.hasBarrier)
+          .serialExecution(testData.serialExecution)
+          .maxDrivers(testData.serialExecution ? 1 : 3);
       queryBuilder.split(
           leftNodeId, makeHiveConnectorSplit(leftFile->getPath()));
       queryBuilder.split(
@@ -1742,8 +1996,10 @@ TEST_F(MergeJoinTest, barrier) {
 
       const auto task = queryBuilder.assertResults(
           "SELECT t0, t1, u0, u1 FROM t INNER JOIN u ON t.t0 = u.u0");
-      ASSERT_EQ(task->taskStats().numBarriers, hasBarrier ? 1 : 0);
-      ASSERT_EQ(task->taskStats().numFinishedSplits, hasBarrier ? 2 : 1);
+      ASSERT_EQ(task->taskStats().numBarriers, testData.hasBarrier ? 1 : 0);
+      ASSERT_EQ(
+          task->taskStats().numFinishedSplits,
+          (testData.hasBarrier || !testData.serialExecution) ? 2 : 1);
     }
   }
 
@@ -1772,10 +2028,12 @@ TEST_F(MergeJoinTest, barrier) {
                 {"t0", "t1", "u0", "u1"},
                 core::JoinType::kFull)
             .planNode();
-    for (const auto hasBarrier : {false, true}) {
-      SCOPED_TRACE(fmt::format("hasBarrier {}", hasBarrier));
+    for (const auto& testData : testSettings) {
+      SCOPED_TRACE(testData.toString());
       AssertQueryBuilder queryBuilder(plan, duckDbQueryRunner_);
-      queryBuilder.barrierExecution(hasBarrier).serialExecution(true);
+      queryBuilder.barrierExecution(testData.hasBarrier)
+          .serialExecution(testData.serialExecution)
+          .maxDrivers(testData.serialExecution ? 1 : 3);
       queryBuilder.split(
           leftNodeId, makeHiveConnectorSplit(leftFile->getPath()));
       queryBuilder.split(
@@ -1784,7 +2042,7 @@ TEST_F(MergeJoinTest, barrier) {
 
       const auto task = queryBuilder.assertResults(
           "SELECT t0, t1, u0, u1 FROM t FULL OUTER JOIN u ON t.t0 = u.u0");
-      ASSERT_EQ(task->taskStats().numBarriers, hasBarrier ? 1 : 0);
+      ASSERT_EQ(task->taskStats().numBarriers, testData.hasBarrier ? 1 : 0);
       ASSERT_EQ(task->taskStats().numFinishedSplits, 2);
     }
   }
@@ -1814,10 +2072,12 @@ TEST_F(MergeJoinTest, barrier) {
                 {"t0", "t1", "u0", "u1"},
                 core::JoinType::kRight)
             .planNode();
-    for (const auto hasBarrier : {false, true}) {
-      SCOPED_TRACE(fmt::format("hasBarrier {}", hasBarrier));
+    for (const auto& testData : testSettings) {
+      SCOPED_TRACE(testData.toString());
       AssertQueryBuilder queryBuilder(plan, duckDbQueryRunner_);
-      queryBuilder.barrierExecution(hasBarrier).serialExecution(true);
+      queryBuilder.barrierExecution(testData.hasBarrier)
+          .serialExecution(testData.serialExecution)
+          .maxDrivers(testData.serialExecution ? 1 : 3);
       queryBuilder.split(
           leftNodeId, makeHiveConnectorSplit(leftFile->getPath()));
       queryBuilder.split(
@@ -1826,7 +2086,7 @@ TEST_F(MergeJoinTest, barrier) {
 
       const auto task = queryBuilder.assertResults(
           "SELECT t0, t1, u0, u1 FROM t RIGHT JOIN u ON t.t0 = u.u0");
-      ASSERT_EQ(task->taskStats().numBarriers, hasBarrier ? 1 : 0);
+      ASSERT_EQ(task->taskStats().numBarriers, testData.hasBarrier ? 1 : 0);
       ASSERT_EQ(task->taskStats().numFinishedSplits, 2);
     }
   }
@@ -1856,10 +2116,12 @@ TEST_F(MergeJoinTest, barrier) {
                 {"t0", "t1", "u0", "u1"},
                 core::JoinType::kLeft)
             .planNode();
-    for (const auto hasBarrier : {true}) {
-      SCOPED_TRACE(fmt::format("hasBarrier {}", hasBarrier));
+    for (const auto& testData : testSettings) {
+      SCOPED_TRACE(testData.toString());
       AssertQueryBuilder queryBuilder(plan, duckDbQueryRunner_);
-      queryBuilder.barrierExecution(hasBarrier).serialExecution(true);
+      queryBuilder.barrierExecution(testData.hasBarrier)
+          .serialExecution(testData.serialExecution)
+          .maxDrivers(testData.serialExecution ? 1 : 3);
       queryBuilder.split(
           leftNodeId, makeHiveConnectorSplit(leftFile->getPath()));
       queryBuilder.split(
@@ -1868,8 +2130,10 @@ TEST_F(MergeJoinTest, barrier) {
 
       const auto task = queryBuilder.assertResults(
           "SELECT t0, t1, u0, u1 FROM t LEFT JOIN u ON t.t0 = u.u0");
-      ASSERT_EQ(task->taskStats().numBarriers, hasBarrier ? 1 : 0);
-      ASSERT_EQ(task->taskStats().numFinishedSplits, hasBarrier ? 2 : 1);
+      ASSERT_EQ(task->taskStats().numBarriers, testData.hasBarrier ? 1 : 0);
+      ASSERT_EQ(
+          task->taskStats().numFinishedSplits,
+          (testData.hasBarrier || !testData.serialExecution) ? 2 : 1);
     }
   }
 
@@ -1898,10 +2162,12 @@ TEST_F(MergeJoinTest, barrier) {
                 {"t0", "t1"},
                 core::JoinType::kAnti)
             .planNode();
-    for (const auto hasBarrier : {true}) {
-      SCOPED_TRACE(fmt::format("hasBarrier {}", hasBarrier));
+    for (const auto& testData : testSettings) {
+      SCOPED_TRACE(testData.toString());
       AssertQueryBuilder queryBuilder(plan, duckDbQueryRunner_);
-      queryBuilder.barrierExecution(hasBarrier).serialExecution(true);
+      queryBuilder.barrierExecution(testData.hasBarrier)
+          .serialExecution(testData.serialExecution)
+          .maxDrivers(testData.serialExecution ? 1 : 3);
       queryBuilder.split(
           leftNodeId, makeHiveConnectorSplit(leftFile->getPath()));
       queryBuilder.split(
@@ -1910,10 +2176,13 @@ TEST_F(MergeJoinTest, barrier) {
 
       const auto task = queryBuilder.assertResults(
           "SELECT t0, t1 FROM t WHERE NOT exists (select u0, u1 from u where t0 = u0)");
-      ASSERT_EQ(task->taskStats().numBarriers, hasBarrier ? 1 : 0);
-      ASSERT_EQ(task->taskStats().numFinishedSplits, hasBarrier ? 2 : 1);
+      ASSERT_EQ(task->taskStats().numBarriers, testData.hasBarrier ? 1 : 0);
+      ASSERT_EQ(
+          task->taskStats().numFinishedSplits,
+          (testData.hasBarrier || !testData.serialExecution) ? 2 : 1);
     }
   }
+  waitForAllTasksToBeDeleted();
 }
 
 TEST_F(MergeJoinTest, antiJoinWithFilterWithMultiMatchedRows) {
@@ -1977,3 +2246,409 @@ TEST_F(MergeJoinTest, antiJoinWithTwoJoinKeysInDifferentBatch) {
       .assertResults(
           "SELECT * FROM t WHERE NOT exists (select * from u where t.a = u.c and t.b < u.d)");
 }
+
+TEST_F(MergeJoinTest, testJoinWithTwoKeysAndSecondColumnHasNulls) {
+  auto left = makeRowVector(
+      {"c0", "c1", "c2", "c3"},
+      {
+          makeNullableFlatVector<StringView>(
+              {"202408", "202409", "202409", "202410"}),
+          makeNullableFlatVector<StringView>({"1", std::nullopt, "2", "3"}),
+          makeNullableFlatVector<StringView>({"1", "2", "2", "3"}),
+          makeNullableFlatVector<StringView>({"1", "2", "2", "3"}),
+      });
+  auto right = makeRowVector(
+      {"rc0", "rc1", "rc2"},
+      {makeNullableFlatVector<StringView>(
+           {"202408", "202409", "202409", "202410"}),
+       makeNullableFlatVector<StringView>({"1", std::nullopt, "2", "3"}),
+       makeNullableFlatVector<StringView>({"1", std::nullopt, "2", "3"})});
+
+  testJoinTwoKeysWithNulls(left, right);
+}
+
+// Test that the dynamic output batch sizing follows the expected growth pattern
+// Verifies that when dynamic batch sizing is enabled
+// (mergeJoinOutputBatchStartSize > 0), MergeJoin adjusts output batch size
+// based on average row size and preferred bytes.
+TEST_F(MergeJoinTest, dynamicOutputBatchSizing) {
+  // Create simple two-column BIGINT data for both left and right sides.
+  // Each row is approximately 16 bytes (2 x 8 bytes for BIGINT).
+  // We create enough rows to see multiple output batches.
+  const vector_size_t numRows = 1000;
+
+  auto left = makeRowVector(
+      {"t_c0", "t_c1"},
+      {
+          makeFlatVector<int64_t>(numRows, [](auto row) { return row; }),
+          makeFlatVector<int64_t>(numRows, [](auto row) { return row * 10; }),
+      });
+
+  auto right = makeRowVector(
+      {"u_c0", "u_c1"},
+      {
+          makeFlatVector<int64_t>(numRows, [](auto row) { return row; }),
+          makeFlatVector<int64_t>(numRows, [](auto row) { return row * 100; }),
+      });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId mergeJoinNodeId;
+
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values({left})
+          .mergeJoin(
+              {"t_c0"},
+              {"u_c0"},
+              PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+              "",
+              {"t_c0", "t_c1", "u_c1"},
+              core::JoinType::kInner)
+          .capturePlanNodeId(mergeJoinNodeId)
+          .planNode();
+
+  // Set a very high preferred row count (10000) but a relatively small byte
+  // limit. The dynamic sizing should compute batch size based on
+  // preferredBytes / avgRowSize, rather than immediately producing 10000 rows.
+  const uint32_t highPreferredRows = 10000;
+  // Set preferred bytes to allow roughly 64 rows per batch (each output row is
+  // ~24 bytes: 3 x 8 bytes for 3 BIGINT columns).
+  const uint64_t preferredBytes = 24 * 64;
+
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+  queryCtx->testingOverrideConfigUnsafe({
+      {core::QueryConfig::kPreferredOutputBatchRows,
+       std::to_string(highPreferredRows)},
+      {core::QueryConfig::kPreferredOutputBatchBytes,
+       std::to_string(preferredBytes)},
+      // Enable dynamic batch sizing by setting a non-zero start size.
+      {core::QueryConfig::kMergeJoinOutputBatchStartSize, "1"},
+  });
+
+  CursorParameters params;
+  params.planNode = plan;
+  params.queryCtx = queryCtx;
+
+  auto cursor = TaskCursor::create(params);
+  cursor->start();
+
+  std::vector<vector_size_t> outputBatchSizes;
+  while (cursor->moveNext()) {
+    auto result = cursor->current();
+    if (result && result->size() > 0) {
+      outputBatchSizes.push_back(result->size());
+    }
+  }
+
+  // Verify that we got multiple output batches.
+  ASSERT_GT(outputBatchSizes.size(), 1);
+
+  // Verify the first batch starts small (should be 1 row due to initial
+  // outputBatchSize_ = 1).
+  EXPECT_EQ(outputBatchSizes[0], 1);
+
+  // After the first batch, the batch size should immediately jump to the
+  // computed size based on preferredBytes / avgRowSize (roughly 64 rows).
+  // All subsequent batches (except the last which may have fewer remaining
+  // rows) should be approximately this computed size.
+  for (size_t i = 1; i < outputBatchSizes.size() - 1; ++i) {
+    EXPECT_GT(outputBatchSizes[i], 8)
+        << "Batch " << i
+        << " should be computed based on preferredBytes / avgRowSize";
+  }
+
+  // Verify we never exceed the preferred row count.
+  for (size_t i = 0; i < outputBatchSizes.size(); ++i) {
+    EXPECT_LE(outputBatchSizes[i], highPreferredRows);
+  }
+}
+
+// Test that filterInput_ properly handles the case where outputBatchSize_
+// increases after initial creation.
+//
+// This test uses variable-length string data where:
+// - First batch of rows have LARGE strings (causing small batch size when
+//   filterInput_ is created)
+// - Later batches have SMALL strings (causing batch size to increase)
+//
+// CRITICAL: The filter expression references columns that are NOT in the
+// output projection. This creates non-shared child vectors in filterInput_
+// that are allocated with the initial outputBatchSize_. When outputBatchSize_
+// increases, copyRow() would write beyond the buffer capacity if not handled
+// correctly.
+TEST_F(MergeJoinTest, dynamicOutputBatchSizingWithFilter) {
+  const vector_size_t numRows = 1000;
+
+  // Left side has 4 columns: t_c0 (join key), t_c1 (in output), t_c2 (in
+  // output), t_c3 (ONLY in filter, NOT in output).
+  auto left = makeRowVector(
+      {"t_c0", "t_c1", "t_c2", "t_c3"},
+      {
+          makeFlatVector<int64_t>(numRows, [](auto row) { return row; }),
+          makeFlatVector<int64_t>(numRows, [](auto row) { return row * 10; }),
+          makeFlatVector<std::string>(
+              numRows,
+              [](auto row) {
+                if (row < 100) {
+                  return std::string(1000, 'A' + (row % 26));
+                } else {
+                  return std::to_string(row);
+                }
+              }),
+          makeFlatVector<int64_t>(numRows, [](auto row) { return row % 10; }),
+      });
+
+  auto right = makeRowVector(
+      {"u_c0", "u_c1", "u_c2", "u_c3"},
+      {
+          makeFlatVector<int64_t>(numRows, [](auto row) { return row; }),
+          makeFlatVector<int64_t>(numRows, [](auto row) { return row * 100; }),
+          makeFlatVector<std::string>(
+              numRows,
+              [](auto row) {
+                if (row < 100) {
+                  return std::string(1000, 'X' + (row % 3));
+                } else {
+                  return std::to_string(row * 2);
+                }
+              }),
+          makeFlatVector<int64_t>(numRows, [](auto row) { return row % 5; }),
+      });
+
+  createDuckDbTable("t", {left});
+  createDuckDbTable("u", {right});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId mergeJoinNodeId;
+
+  // The filter references t_c3 and u_c3 which are NOT in the output projection.
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values({left})
+          .mergeJoin(
+              {"t_c0"},
+              {"u_c0"},
+              PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+              "(t_c3 + u_c3) % 3 = 0",
+              {"t_c0", "t_c1", "t_c2", "u_c1", "u_c2"},
+              core::JoinType::kInner)
+          .capturePlanNodeId(mergeJoinNodeId)
+          .planNode();
+
+  const uint32_t highPreferredRows = 10000;
+  const uint64_t preferredBytes = 10000;
+
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+  queryCtx->testingOverrideConfigUnsafe({
+      {core::QueryConfig::kPreferredOutputBatchRows,
+       std::to_string(highPreferredRows)},
+      {core::QueryConfig::kPreferredOutputBatchBytes,
+       std::to_string(preferredBytes)},
+      {core::QueryConfig::kMergeJoinOutputBatchStartSize, "1"},
+  });
+
+  // If filterInput_ buffer overflow occurs, ASAN will catch it.
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .queryCtx(queryCtx)
+      .assertResults(
+          "SELECT t_c0, t_c1, t_c2, u_c1, u_c2 FROM t, u "
+          "WHERE t_c0 = u_c0 AND (t.t_c3 + u.u_c3) % 3 = 0");
+}
+
+// Verifies that when mergeJoinOutputBatchStartSize is 0 (default), dynamic
+// batch sizing is disabled and the batch size is fixed at
+// preferredOutputBatchRows.
+TEST_F(MergeJoinTest, dynamicOutputBatchSizingDisabledByDefault) {
+  const vector_size_t numRows = 1000;
+
+  auto left = makeRowVector(
+      {"t_c0", "t_c1"},
+      {
+          makeFlatVector<int64_t>(numRows, [](auto row) { return row; }),
+          makeFlatVector<int64_t>(numRows, [](auto row) { return row * 10; }),
+      });
+
+  auto right = makeRowVector(
+      {"u_c0", "u_c1"},
+      {
+          makeFlatVector<int64_t>(numRows, [](auto row) { return row; }),
+          makeFlatVector<int64_t>(numRows, [](auto row) { return row * 100; }),
+      });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId mergeJoinNodeId;
+
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values({left})
+          .mergeJoin(
+              {"t_c0"},
+              {"u_c0"},
+              PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+              "",
+              {"t_c0", "t_c1", "u_c1"},
+              core::JoinType::kInner)
+          .capturePlanNodeId(mergeJoinNodeId)
+          .planNode();
+
+  // Use the default config (mergeJoinOutputBatchStartSize = 0), which disables
+  // dynamic batch sizing. The batch size should be fixed at
+  // preferredOutputBatchRows.
+  const uint32_t preferredRows = 100;
+
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+  queryCtx->testingOverrideConfigUnsafe({
+      {core::QueryConfig::kPreferredOutputBatchRows,
+       std::to_string(preferredRows)},
+  });
+
+  CursorParameters params;
+  params.planNode = plan;
+  params.queryCtx = queryCtx;
+
+  auto cursor = TaskCursor::create(params);
+  cursor->start();
+
+  std::vector<vector_size_t> outputBatchSizes;
+  while (cursor->moveNext()) {
+    auto result = cursor->current();
+    if (result && result->size() > 0) {
+      outputBatchSizes.push_back(result->size());
+    }
+  }
+
+  // Verify that we got multiple output batches.
+  ASSERT_GT(outputBatchSizes.size(), 1);
+
+  // Since dynamic batch sizing is disabled, all batches (except possibly the
+  // last one) should be exactly preferredRows in size.
+  for (size_t i = 0; i < outputBatchSizes.size() - 1; ++i) {
+    EXPECT_EQ(outputBatchSizes[i], preferredRows)
+        << "Batch " << i << " should be exactly " << preferredRows
+        << " rows when dynamic batch sizing is disabled";
+  }
+
+  // The last batch should be <= preferredRows (may have fewer remaining rows).
+  EXPECT_LE(outputBatchSizes.back(), preferredRows);
+}
+
+TEST_F(MergeJoinTest, flatMapVectorInnerJoin) {
+  auto left = makeRowVector(
+      {"t_c0", "t_c1"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3}),
+          makeFlatMapVector<int64_t, int64_t>({
+              {{1, 10}, {2, 20}},
+              {{1, 30}, {3, 40}},
+              {{2, 50}},
+          }),
+      });
+
+  auto right = makeRowVector(
+      {"u_c0", "u_c1"},
+      {
+          makeFlatVector<int64_t>({1, 2, 4}),
+          makeFlatMapVector<int64_t, int64_t>({
+              {{1, 100}, {2, 200}},
+              {{3, 300}},
+              {{1, 400}, {2, 500}, {3, 600}},
+          }),
+      });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values({left})
+          .mergeJoin(
+              {"t_c0"},
+              {"u_c0"},
+              PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+              "",
+              {"t_c0", "t_c1", "u_c1"},
+              core::JoinType::kInner)
+          .planNode();
+
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>({1, 2}),
+      makeFlatMapVector<int64_t, int64_t>({
+          {{1, 10}, {2, 20}},
+          {{1, 30}, {3, 40}},
+      }),
+      makeFlatMapVector<int64_t, int64_t>({
+          {{1, 100}, {2, 200}},
+          {{3, 300}},
+      }),
+  });
+
+  CursorParameters params;
+  params.planNode = plan;
+  auto [cursor, results] = readCursor(params);
+  facebook::velox::test::assertEqualVectors(expected, results[0]);
+  ASSERT_EQ(
+      results[0]->childAt(1)->wrappedVector()->encoding(),
+      VectorEncoding::Simple::FLAT_MAP);
+  ASSERT_EQ(
+      results[0]->childAt(2)->wrappedVector()->encoding(),
+      VectorEncoding::Simple::FLAT_MAP);
+}
+
+TEST_F(MergeJoinTest, flatMapVectorLeftJoin) {
+  auto left = makeRowVector(
+      {"t_c0", "t_c1"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3}),
+          makeFlatMapVector<int64_t, int64_t>({
+              {{1, 10}, {2, 20}},
+              {{1, 30}, {3, 40}},
+              {{2, 50}},
+          }),
+      });
+
+  auto right = makeRowVector(
+      {"u_c0", "u_c1"},
+      {
+          makeFlatVector<int64_t>({1, 2}),
+          makeFlatMapVector<int64_t, int64_t>({
+              {{1, 100}, {2, 200}},
+              {{3, 300}},
+          }),
+      });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values({left})
+          .mergeJoin(
+              {"t_c0"},
+              {"u_c0"},
+              PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+              "",
+              {"t_c0", "t_c1", "u_c1"},
+              core::JoinType::kLeft)
+          .planNode();
+
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      makeFlatMapVector<int64_t, int64_t>({
+          {{1, 10}, {2, 20}},
+          {{1, 30}, {3, 40}},
+          {{2, 50}},
+      }),
+      makeNullableFlatMapVector<int64_t, int64_t>({
+          {{{1, 100}, {2, 200}}},
+          {{{3, 300}}},
+          std::nullopt,
+      }),
+  });
+
+  CursorParameters params;
+  params.planNode = plan;
+  auto [cursor, results] = readCursor(params);
+  facebook::velox::test::assertEqualVectors(expected, results[0]);
+  ASSERT_EQ(
+      results[0]->childAt(1)->wrappedVector()->encoding(),
+      VectorEncoding::Simple::FLAT_MAP);
+  ASSERT_EQ(
+      results[0]->childAt(2)->wrappedVector()->encoding(),
+      VectorEncoding::Simple::FLAT_MAP);
+}
diff --git a/velox/exec/tests/MergeTest.cpp b/velox/exec/tests/MergeTest.cpp
index 02f80fcd140..cf0c6de444f 100644
--- a/velox/exec/tests/MergeTest.cpp
+++ b/velox/exec/tests/MergeTest.cpp
@@ -15,14 +15,14 @@
  */
 
 #include "velox/exec/Merge.h"
-#include "folly/experimental/EventCount.h"
+#include "folly/synchronization/EventCount.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
@@ -403,9 +403,13 @@ class MergeTest : public OperatorTestBase {
       ASSERT_EQ(planStats.spilledFiles, 0);
       ASSERT_EQ(planStats.spilledRows, 0);
       ASSERT_EQ(
-          planStats.customStats.count(Merge::kSpilledSourceReadWallNanos), 0);
+          planStats.customStats.count(
+              std::string(Merge::kSpilledSourceReadWallNanos)),
+          0);
       ASSERT_GE(
-          planStats.customStats.count(Merge::kStreamingSourceReadWallNanos), 0);
+          planStats.customStats.count(
+              std::string(Merge::kStreamingSourceReadWallNanos)),
+          0);
     } else {
       const auto expectedFiles =
           (inputVectors.size() + numMaxMergeSources - 1) / numMaxMergeSources;
@@ -415,9 +419,13 @@ class MergeTest : public OperatorTestBase {
       ASSERT_EQ(planStats.spilledFiles, expectedFiles);
       ASSERT_EQ(planStats.spilledRows, expectedSpillRows);
       ASSERT_GE(
-          planStats.customStats.count(Merge::kSpilledSourceReadWallNanos), 0);
+          planStats.customStats.count(
+              std::string(Merge::kSpilledSourceReadWallNanos)),
+          0);
       ASSERT_GE(
-          planStats.customStats.count(Merge::kStreamingSourceReadWallNanos), 0);
+          planStats.customStats.count(
+              std::string(Merge::kStreamingSourceReadWallNanos)),
+          0);
     }
     ASSERT_EQ(
         planStats.outputRows,
@@ -601,6 +609,38 @@ TEST_F(MergeTest, localMergeSpillPartialEmpty) {
   ASSERT_EQ(planStats.spilledRows, 120);
 }
 
+DEBUG_ONLY_TEST_F(MergeTest, localMergeSpillWithException) {
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < 9; ++i) {
+    constexpr vector_size_t batchSize = 137;
+    auto c0 = makeFlatVector<int64_t>(
+        batchSize, [&](auto row) { return batchSize * i + row; }, nullEvery(5));
+    auto c1 = makeFlatVector<int64_t>(
+        batchSize, [&](auto row) { return row; }, nullEvery(5));
+    auto c2 = makeFlatVector<double>(
+        batchSize, [](auto row) { return row * 0.1; }, nullEvery(11));
+    auto c3 = makeFlatVector<StringView>(batchSize, [](auto row) {
+      return StringView::makeInline(std::to_string(row));
+    });
+    vectors.push_back(makeRowVector({c0, c1, c2, c3}));
+  }
+  createDuckDbTable(vectors);
+
+  for (auto i = 0; i < 11; ++i) {
+    std::atomic_int cnt{0};
+    const auto errorMessage = "ConcatFilesSpillBatchStream::nextBatch fail";
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::ConcatFilesSpillBatchStream::nextBatch",
+        std::function<void(void*)>([&](void* /*unused*/) {
+          if (cnt++ == i) {
+            VELOX_FAIL("ConcatFilesSpillBatchStream::nextBatch fail");
+          }
+        }));
+
+    VELOX_ASSERT_THROW(testSingleKeyWithSpill(vectors, "c0"), errorMessage);
+  }
+}
+
 DEBUG_ONLY_TEST_F(MergeTest, localMergeSmallBatch) {
   std::vector<RowVectorPtr> vectors;
   for (int32_t i = 0; i < 9; ++i) {
@@ -735,7 +775,7 @@ DEBUG_ONLY_TEST_F(MergeTest, localMergeAbort) {
           }));
 
   SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::SpillMerger::asyncReadFromSpillFileStream",
+      "facebook::velox::exec::SpillMerger::readFromSpillFileStream",
       std::function<void(void*)>([&](void* /*unused*/) {
         if (cnt++ == 2) {
           blocked = true;
@@ -915,3 +955,275 @@ TEST_F(MergeTest, localMergeOutputSizeWithoutSpill) {
         testData.numExpectedOutputBatches);
   }
 }
+
+/// Tests that MultiThreadedTaskCursor correctly preserves FlatMapVector
+/// encoding when reading data directly without a merge step.
+TEST_F(MergeTest, preserveVectorEncoding) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      vectorMaker_.flatMapVector<int64_t, int64_t>({
+          {{1, 10}, {2, 20}},
+          {{1, 30}},
+          {{2, 40}, {3, 50}},
+      }),
+  });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator).values({data}).planNode();
+
+  CursorParameters params;
+  params.planNode = plan;
+  params.queryCtx = core::QueryCtx::create(executor_.get());
+  params.maxDrivers = 2;
+
+  auto result = readCursor(params);
+  ASSERT_EQ(result.second.size(), 1);
+
+  auto output = result.second[0];
+  ASSERT_EQ(output->size(), 3);
+
+  auto mapColumn = output->childAt(1);
+  EXPECT_EQ(mapColumn->encoding(), VectorEncoding::Simple::FLAT_MAP);
+  auto flatMapVector = mapColumn->as<FlatMapVector>();
+  EXPECT_EQ(flatMapVector->distinctKeys()->size(), 3);
+
+  auto verifier = vectorMaker_.flatMapVector<int64_t, int64_t>({
+      {{1, 10}, {2, 20}},
+      {{1, 30}},
+      {{2, 40}, {3, 50}},
+  });
+  facebook::velox::test::assertEqualVectors(mapColumn, verifier);
+}
+
+/// Tests that LocalMerge correctly preserves FlatMapVector encoding
+/// when merging data with FlatMapVector columns.
+TEST_F(MergeTest, flatMapVectorEncoding) {
+  // Create input data with FlatMapVector columns.
+  // Data is already sorted by c0.
+  auto data1 = makeRowVector({
+      makeFlatVector<int64_t>({0, 2, 4}),
+      vectorMaker_.flatMapVector<int64_t, int64_t>({
+          {{1, 10}, {2, 20}},
+          {{1, 30}, {3, 40}},
+          {{2, 50}},
+      }),
+  });
+
+  auto data2 = makeRowVector({
+      makeFlatVector<int64_t>({1, 3, 5}),
+      vectorMaker_.flatMapVector<int64_t, int64_t>({
+          {{1, 100}, {2, 200}},
+          {{3, 300}},
+          {{1, 400}, {2, 500}, {3, 600}},
+      }),
+  });
+
+  auto verifyResult = [this](const std::vector<RowVectorPtr>& results) {
+    ASSERT_EQ(results.size(), 1);
+
+    auto output = results[0];
+    ASSERT_EQ(output->size(), 6);
+
+    auto sortKey = output->childAt(0)->asFlatVector<int64_t>();
+    for (int i = 0; i < 6; ++i) {
+      EXPECT_EQ(sortKey->valueAt(i), i);
+    }
+
+    auto mapColumn = output->childAt(1);
+    EXPECT_EQ(mapColumn->encoding(), VectorEncoding::Simple::FLAT_MAP);
+    auto flatMapVector = mapColumn->as<FlatMapVector>();
+    EXPECT_EQ(flatMapVector->distinctKeys()->size(), 3);
+    auto verifier = vectorMaker_.flatMapVector<int64_t, int64_t>({
+        {{1, 10}, {2, 20}},
+        {{1, 100}, {2, 200}},
+        {{1, 30}, {3, 40}},
+        {{3, 300}},
+        {{2, 50}},
+        {{1, 400}, {2, 500}, {3, 600}},
+    });
+    // Merge does not resize child vectors.
+    verifier->resize(mapColumn->size());
+    facebook::velox::test::assertEqualVectors(mapColumn, verifier);
+  };
+
+  // Test multi-threaded execution.
+  {
+    SCOPED_TRACE("Multi-threaded execution");
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan =
+        PlanBuilder(planNodeIdGenerator)
+            .localMerge(
+                {"c0"},
+                {
+                    PlanBuilder(planNodeIdGenerator).values({data1}).planNode(),
+                    PlanBuilder(planNodeIdGenerator).values({data2}).planNode(),
+                })
+            .planNode();
+
+    CursorParameters params;
+    params.planNode = plan;
+    params.queryCtx = core::QueryCtx::create(executor_.get());
+    params.maxDrivers = 2;
+
+    auto result = readCursor(params);
+    verifyResult(result.second);
+  }
+
+  // Test serial execution.
+  {
+    SCOPED_TRACE("Serial execution");
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan =
+        PlanBuilder(planNodeIdGenerator)
+            .localMerge(
+                {"c0"},
+                {
+                    PlanBuilder(planNodeIdGenerator).values({data1}).planNode(),
+                    PlanBuilder(planNodeIdGenerator).values({data2}).planNode(),
+                })
+            .planNode();
+
+    CursorParameters params;
+    params.planNode = plan;
+    params.queryCtx = core::QueryCtx::create();
+    params.serialExecution = true;
+
+    auto result = readCursor(params);
+    verifyResult(result.second);
+  }
+}
+
+/// Tests that LocalMerge correctly handles FlatMapVector encoding
+/// when the first source is empty but subsequent sources have data.
+TEST_F(MergeTest, flatMapVectorEncodingWithEmptyFirstSource) {
+  // Create an empty first source.
+  auto emptyData = makeRowVector(
+      {"c0", "c1"},
+      {
+          makeFlatVector<int64_t>({}),
+          vectorMaker_.flatMapVector<int64_t, int64_t>({}),
+      });
+
+  // Create second source with FlatMapVector data.
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      vectorMaker_.flatMapVector<int64_t, int64_t>({
+          {{1, 10}, {2, 20}},
+          {{1, 30}},
+          {{2, 40}, {3, 50}},
+      }),
+  });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .localMerge(
+              {"c0"},
+              {
+                  PlanBuilder(planNodeIdGenerator)
+                      .values({emptyData})
+                      .planNode(),
+                  PlanBuilder(planNodeIdGenerator).values({data}).planNode(),
+              })
+          .planNode();
+
+  CursorParameters params;
+  params.planNode = plan;
+  params.queryCtx = core::QueryCtx::create(executor_.get());
+  params.maxDrivers = 2;
+
+  auto result = readCursor(params);
+  ASSERT_EQ(result.second.size(), 1);
+
+  auto output = result.second[0];
+  ASSERT_EQ(output->size(), 3);
+
+  // Verify the FlatMapVector encoding is preserved even when first source is
+  // empty.
+  auto mapColumn = output->childAt(1);
+  EXPECT_EQ(mapColumn->encoding(), VectorEncoding::Simple::FLAT_MAP);
+  auto flatMapVector = mapColumn->as<FlatMapVector>();
+  EXPECT_EQ(flatMapVector->distinctKeys()->size(), 3);
+  auto verifier = vectorMaker_.flatMapVector<int64_t, int64_t>({
+      {{1, 10}, {2, 20}},
+      {{1, 30}},
+      {{2, 40}, {3, 50}},
+  });
+  verifier->resize(mapColumn->size());
+  facebook::velox::test::assertEqualVectors(mapColumn, verifier);
+}
+
+/// Tests that LocalMerge correctly merges multiple sources with FlatMapVector
+/// columns and different key sets.
+TEST_F(MergeTest, flatMapVectorEncodingMultipleSources) {
+  auto data1 = makeRowVector({
+      makeFlatVector<int64_t>({0, 3}),
+      vectorMaker_.flatMapVector<int64_t, int64_t>({
+          {{1, 10}},
+          {{1, 40}, {2, 50}},
+      }),
+  });
+
+  auto data2 = makeRowVector({
+      makeFlatVector<int64_t>({1, 4}),
+      vectorMaker_.flatMapVector<int64_t, int64_t>({
+          {{2, 20}},
+          {{3, 60}},
+      }),
+  });
+
+  auto data3 = makeRowVector({
+      makeFlatVector<int64_t>({2, 5}),
+      vectorMaker_.flatMapVector<int64_t, int64_t>({
+          {{1, 30}, {3, 35}},
+          {{1, 70}, {2, 80}, {3, 90}},
+      }),
+  });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .localMerge(
+              {"c0"},
+              {
+                  PlanBuilder(planNodeIdGenerator).values({data1}).planNode(),
+                  PlanBuilder(planNodeIdGenerator).values({data2}).planNode(),
+                  PlanBuilder(planNodeIdGenerator).values({data3}).planNode(),
+              })
+          .planNode();
+
+  CursorParameters params;
+  params.planNode = plan;
+  params.queryCtx = core::QueryCtx::create(executor_.get());
+  params.maxDrivers = 3;
+
+  auto result = readCursor(params);
+  ASSERT_EQ(result.second.size(), 1);
+
+  auto output = result.second[0];
+  ASSERT_EQ(output->size(), 6);
+
+  // Verify the output is sorted correctly.
+  auto sortKey = output->childAt(0)->asFlatVector<int64_t>();
+  for (int i = 0; i < 6; ++i) {
+    EXPECT_EQ(sortKey->valueAt(i), i);
+  }
+
+  // Verify the FlatMapVector encoding is preserved.
+  auto mapColumn = output->childAt(1);
+  EXPECT_EQ(mapColumn->encoding(), VectorEncoding::Simple::FLAT_MAP);
+  auto flatMapVector = mapColumn->as<FlatMapVector>();
+  EXPECT_EQ(flatMapVector->distinctKeys()->size(), 3);
+  auto verifier = vectorMaker_.flatMapVector<int64_t, int64_t>({
+      {{1, 10}},
+      {{2, 20}},
+      {{1, 30}, {3, 35}},
+      {{1, 40}, {2, 50}},
+      {{3, 60}},
+      {{1, 70}, {2, 80}, {3, 90}},
+  });
+  verifier->resize(mapColumn->size());
+  facebook::velox::test::assertEqualVectors(mapColumn, verifier);
+}
diff --git a/velox/exec/tests/MergerTest.cpp b/velox/exec/tests/MergerTest.cpp
index e1845fc552e..2a7a21f4e15 100644
--- a/velox/exec/tests/MergerTest.cpp
+++ b/velox/exec/tests/MergerTest.cpp
@@ -14,13 +14,15 @@
  * limitations under the License.
  */
 
+#include <folly/system/HardwareConcurrency.h>
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/exec/Merge.h"
 #include "velox/exec/MergeSource.h"
 #include "velox/exec/SortBuffer.h"
 #include "velox/exec/Spill.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/type/Type.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
@@ -33,6 +35,7 @@ using namespace facebook::velox;
 using namespace facebook::velox::memory;
 
 namespace facebook::velox::exec::test {
+using namespace facebook::velox::common::testutil;
 
 class MergerTest : public OperatorTestBase {
  protected:
@@ -100,11 +103,12 @@ class MergerTest : public OperatorTestBase {
       std::vector<std::unique_ptr<SpillReadFile>> spillReadFiles;
       spillReadFiles.reserve(spillFiles.size());
       for (const auto& spillFile : spillFiles) {
-        spillReadFiles.emplace_back(SpillReadFile::create(
-            spillFile,
-            spillConfig_.readBufferSize,
-            pool_.get(),
-            spillStats_.get()));
+        spillReadFiles.emplace_back(
+            SpillReadFile::create(
+                spillFile,
+                spillConfig_.readBufferSize,
+                pool_.get(),
+                spillStats_.get()));
       }
       spillReadFilesGroups.emplace_back(std::move(spillReadFiles));
     }
@@ -148,8 +152,9 @@ class MergerTest : public OperatorTestBase {
       uint64_t outputBatchBytes) const {
     std::vector<std::unique_ptr<SourceStream>> sourceStreams;
     for (const auto& source : sources) {
-      sourceStreams.push_back(std::make_unique<SourceStream>(
-          source.get(), sortingKeys_, outputBatchRows));
+      sourceStreams.push_back(
+          std::make_unique<SourceStream>(
+              source.get(), sortingKeys_, outputBatchRows));
     }
     return std::make_unique<SourceMerger>(
         inputType_,
@@ -291,7 +296,7 @@ class MergerTest : public OperatorTestBase {
   const RowTypePtr inputType_ = ROW({{"c0", BIGINT()}, {"c1", SMALLINT()}});
   const std::shared_ptr<folly::Executor> executor_{
       std::make_shared<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency())};
+          folly::available_concurrency())};
   const std::vector<column_index_t> sortColumnIndices_{0, 1};
   const std::vector<CompareFlags> sortCompareFlags_{
       CompareFlags{.ascending = true},
@@ -299,7 +304,7 @@ class MergerTest : public OperatorTestBase {
   const std::vector<SpillSortKey> sortingKeys_ =
       SpillState::makeSortingKeys(sortColumnIndices_, sortCompareFlags_);
   const std::shared_ptr<TempDirectoryPath> spillDirectory_ =
-      exec::test::TempDirectoryPath::create();
+      TempDirectoryPath::create();
   const common::SpillConfig spillConfig_{
       [&]() -> const std::string& { return spillDirectory_->getPath(); },
       [&](uint64_t) {},
@@ -316,10 +321,11 @@ class MergerTest : public OperatorTestBase {
       0,
       0,
       "none",
+      0,
       std::nullopt};
 
-  std::shared_ptr<folly::Synchronized<common::SpillStats>> spillStats_ =
-      std::make_shared<folly::Synchronized<common::SpillStats>>();
+  std::shared_ptr<exec::SpillStats> spillStats_ =
+      std::make_shared<exec::SpillStats>();
   tsan_atomic<bool> nonReclaimableSection_{false};
 };
 } // namespace facebook::velox::exec::test
@@ -420,3 +426,37 @@ TEST_F(MergerTest, spillMerger) {
     checkResults(expectedResults, results);
   }
 }
+
+DEBUG_ONLY_TEST_F(MergerTest, spillMergerException) {
+  struct TestSetting {
+    size_t maxOutputRows;
+    size_t numSources;
+    size_t queueSize;
+
+    std::string debugString() const {
+      return fmt::format(
+          "maxOutputRows:{}, numStreams:{}, queueSize:{}",
+          maxOutputRows,
+          numSources,
+          queueSize);
+    }
+  };
+
+  std::atomic_int cnt{0};
+  const auto errorMessage = "ConcatFilesSpillBatchStream::nextBatch fail";
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::ConcatFilesSpillBatchStream::nextBatch",
+      std::function<void(void*)>([&](void* /*unused*/) {
+        if (cnt++ == 11) {
+          VELOX_FAIL("ConcatFilesSpillBatchStream::nextBatch fail");
+        }
+      }));
+  const auto numSources = 5;
+  const auto queueSize = 2;
+  const auto sources = createMergeSources(numSources, queueSize);
+  auto [inputs, filesGroup] = generateInputs(numSources, 16);
+  const auto spillMerger =
+      createSpillMerger(std::move(filesGroup), 100, queueSize);
+  spillMerger->start();
+  VELOX_ASSERT_THROW(getOutputFromSpillMerger(spillMerger.get()), errorMessage);
+}
diff --git a/velox/exec/tests/MixedUnionTest.cpp b/velox/exec/tests/MixedUnionTest.cpp
new file mode 100644
index 00000000000..0940515666a
--- /dev/null
+++ b/velox/exec/tests/MixedUnionTest.cpp
@@ -0,0 +1,1521 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/TempFilePath.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+class MixedUnionTest : public OperatorTestBase {
+ protected:
+  std::shared_ptr<core::MixedUnionNode> makeUnionNode(
+      std::vector<core::PlanNodePtr> sources,
+      std::shared_ptr<core::PlanNodeIdGenerator> planNodeIdGenerator) {
+    return std::make_shared<core::MixedUnionNode>(
+        planNodeIdGenerator->next(), std::move(sources));
+  }
+};
+
+TEST_F(MixedUnionTest, basicUnion) {
+  auto data1 = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 3}),
+      makeFlatVector<std::string>({"a", "b", "c"}),
+  });
+  auto data2 = makeRowVector({
+      makeFlatVector<int32_t>({4, 5, 6}),
+      makeFlatVector<std::string>({"d", "e", "f"}),
+  });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto unionNode = makeUnionNode(
+      {PlanBuilder(planNodeIdGenerator).values({data1}).planNode(),
+       PlanBuilder(planNodeIdGenerator).values({data2}).planNode()},
+      planNodeIdGenerator);
+
+  assertQuery(
+      CursorParameters{
+          .planNode = unionNode,
+          .maxDrivers = 1,
+      },
+      "VALUES (1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'), (6, 'f')");
+}
+
+TEST_F(MixedUnionTest, singleSource) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 3}),
+      makeFlatVector<std::string>({"a", "b", "c"}),
+  });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto unionNode = makeUnionNode(
+      {PlanBuilder(planNodeIdGenerator).values({data}).planNode()},
+      planNodeIdGenerator);
+
+  assertQuery(
+      CursorParameters{
+          .planNode = unionNode,
+          .maxDrivers = 1,
+      },
+      "VALUES (1, 'a'), (2, 'b'), (3, 'c')");
+}
+
+TEST_F(MixedUnionTest, emptyFirstSource) {
+  auto emptyData = makeRowVector(
+      {makeFlatVector<int32_t>({}), makeFlatVector<std::string>({})});
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({1, 2}),
+      makeFlatVector<std::string>({"a", "b"}),
+  });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto unionNode = makeUnionNode(
+      {PlanBuilder(planNodeIdGenerator).values({emptyData}).planNode(),
+       PlanBuilder(planNodeIdGenerator).values({data}).planNode()},
+      planNodeIdGenerator);
+
+  assertQuery(
+      CursorParameters{
+          .planNode = unionNode,
+          .maxDrivers = 1,
+      },
+      "VALUES (1, 'a'), (2, 'b')");
+}
+
+TEST_F(MixedUnionTest, emptyLastSource) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({1, 2}),
+      makeFlatVector<std::string>({"a", "b"}),
+  });
+  auto emptyData = makeRowVector(
+      {makeFlatVector<int32_t>({}), makeFlatVector<std::string>({})});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto unionNode = makeUnionNode(
+      {PlanBuilder(planNodeIdGenerator).values({data}).planNode(),
+       PlanBuilder(planNodeIdGenerator).values({emptyData}).planNode()},
+      planNodeIdGenerator);
+
+  assertQuery(
+      CursorParameters{
+          .planNode = unionNode,
+          .maxDrivers = 1,
+      },
+      "VALUES (1, 'a'), (2, 'b')");
+}
+
+TEST_F(MixedUnionTest, allEmptySources) {
+  auto emptyData = makeRowVector(
+      {makeFlatVector<int32_t>({}), makeFlatVector<std::string>({})});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto unionNode = makeUnionNode(
+      {PlanBuilder(planNodeIdGenerator).values({emptyData}).planNode(),
+       PlanBuilder(planNodeIdGenerator).values({emptyData}).planNode()},
+      planNodeIdGenerator);
+
+  auto result = AssertQueryBuilder(unionNode).copyResults(pool());
+  ASSERT_EQ(result->size(), 0);
+}
+
+TEST_F(MixedUnionTest, multipleInputs) {
+  auto data1 = makeRowVector({
+      makeFlatVector<int32_t>({1}),
+      makeFlatVector<std::string>({"a"}),
+  });
+  auto data2 = makeRowVector({
+      makeFlatVector<int32_t>({2}),
+      makeFlatVector<std::string>({"b"}),
+  });
+  auto data3 = makeRowVector({
+      makeFlatVector<int32_t>({3}),
+      makeFlatVector<std::string>({"c"}),
+  });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto unionNode = makeUnionNode(
+      {PlanBuilder(planNodeIdGenerator).values({data1}).planNode(),
+       PlanBuilder(planNodeIdGenerator).values({data2}).planNode(),
+       PlanBuilder(planNodeIdGenerator).values({data3}).planNode()},
+      planNodeIdGenerator);
+
+  assertQuery(
+      CursorParameters{
+          .planNode = unionNode,
+          .maxDrivers = 1,
+      },
+      "VALUES (1, 'a'), (2, 'b'), (3, 'c')");
+}
+
+TEST_F(MixedUnionTest, manySources) {
+  constexpr int kNumSources = 10;
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  std::vector<core::PlanNodePtr> sources;
+  sources.reserve(kNumSources);
+  for (int i = 0; i < kNumSources; ++i) {
+    auto data = makeRowVector({
+        makeFlatVector<int64_t>({i}),
+    });
+    sources.push_back(
+        PlanBuilder(planNodeIdGenerator).values({data}).planNode());
+  }
+
+  auto unionNode = makeUnionNode(std::move(sources), planNodeIdGenerator);
+  auto result = AssertQueryBuilder(unionNode).copyResults(pool());
+  ASSERT_EQ(result->size(), kNumSources);
+}
+
+TEST_F(MixedUnionTest, unequalSourceSizes) {
+  auto data1 = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+  });
+  auto data2 = makeRowVector({
+      makeFlatVector<int64_t>({6, 7}),
+  });
+  auto data3 = makeRowVector({
+      makeFlatVector<int64_t>({8, 9, 10, 11, 12, 13, 14}),
+  });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto unionNode = makeUnionNode(
+      {PlanBuilder(planNodeIdGenerator).values({data1}).planNode(),
+       PlanBuilder(planNodeIdGenerator).values({data2}).planNode(),
+       PlanBuilder(planNodeIdGenerator).values({data3}).planNode()},
+      planNodeIdGenerator);
+
+  auto result = AssertQueryBuilder(unionNode).copyResults(pool());
+  ASSERT_EQ(result->size(), 14);
+}
+
+TEST_F(MixedUnionTest, multipleBatchesPerSource) {
+  // Test that union correctly handles the case where sources provide data
+  // in a single batch each
+  auto data1 = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4, 5, 6}),
+  });
+  auto data2 = makeRowVector({
+      makeFlatVector<int64_t>({7, 8, 9, 10, 11, 12}),
+  });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto unionNode = makeUnionNode(
+      {PlanBuilder(planNodeIdGenerator).values({data1}).planNode(),
+       PlanBuilder(planNodeIdGenerator).values({data2}).planNode()},
+      planNodeIdGenerator);
+
+  auto result = AssertQueryBuilder(unionNode).copyResults(pool());
+  ASSERT_EQ(result->size(), 12);
+}
+
+TEST_F(MixedUnionTest, withNulls) {
+  auto data1 = makeRowVector({
+      makeNullableFlatVector<int64_t>({1, std::nullopt, 3}),
+      makeNullableFlatVector<std::string>({"a", "b", std::nullopt}),
+  });
+  auto data2 = makeRowVector({
+      makeNullableFlatVector<int64_t>({std::nullopt, 5, 6}),
+      makeNullableFlatVector<std::string>({std::nullopt, "e", "f"}),
+  });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto unionNode = makeUnionNode(
+      {PlanBuilder(planNodeIdGenerator).values({data1}).planNode(),
+       PlanBuilder(planNodeIdGenerator).values({data2}).planNode()},
+      planNodeIdGenerator);
+
+  auto result = AssertQueryBuilder(unionNode).copyResults(pool());
+  ASSERT_EQ(result->size(), 6);
+
+  auto* col0 = result->childAt(0)->asFlatVector<int64_t>();
+  EXPECT_TRUE(col0->isNullAt(1));
+  EXPECT_TRUE(col0->isNullAt(3));
+
+  auto* col1 = result->childAt(1)->asFlatVector<StringView>();
+  EXPECT_TRUE(col1->isNullAt(2));
+  EXPECT_TRUE(col1->isNullAt(3));
+}
+
+TEST_F(MixedUnionTest, variousTypes) {
+  auto data1 = makeRowVector({
+      makeFlatVector<int64_t>({1, 2}),
+      makeFlatVector<double>({1.1, 2.2}),
+      makeFlatVector<bool>({true, false}),
+      makeFlatVector<StringView>({"hello", "world"}),
+  });
+  auto data2 = makeRowVector({
+      makeFlatVector<int64_t>({3, 4}),
+      makeFlatVector<double>({3.3, 4.4}),
+      makeFlatVector<bool>({false, true}),
+      makeFlatVector<StringView>({"foo", "bar"}),
+  });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto unionNode = makeUnionNode(
+      {PlanBuilder(planNodeIdGenerator).values({data1}).planNode(),
+       PlanBuilder(planNodeIdGenerator).values({data2}).planNode()},
+      planNodeIdGenerator);
+
+  auto result = AssertQueryBuilder(unionNode).copyResults(pool());
+  ASSERT_EQ(result->size(), 4);
+
+  auto* int64Col = result->childAt(0)->asFlatVector<int64_t>();
+  EXPECT_EQ(int64Col->valueAt(0), 1);
+  EXPECT_EQ(int64Col->valueAt(3), 4);
+
+  auto* doubleCol = result->childAt(1)->asFlatVector<double>();
+  EXPECT_DOUBLE_EQ(doubleCol->valueAt(0), 1.1);
+  EXPECT_DOUBLE_EQ(doubleCol->valueAt(3), 4.4);
+}
+
+TEST_F(MixedUnionTest, largeDataVolume) {
+  constexpr int kRowsPerSource = 1000;
+  constexpr int kNumSources = 3;
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  std::vector<core::PlanNodePtr> sources;
+  sources.reserve(kNumSources);
+
+  for (int s = 0; s < kNumSources; ++s) {
+    auto data = makeRowVector({
+        makeFlatVector<int64_t>(
+            kRowsPerSource, [s](auto row) { return s * 10000 + row; }),
+        makeFlatVector<double>(
+            kRowsPerSource, [](auto row) { return row * 0.1; }),
+    });
+    sources.push_back(
+        PlanBuilder(planNodeIdGenerator).values({data}).planNode());
+  }
+
+  auto unionNode = makeUnionNode(std::move(sources), planNodeIdGenerator);
+  auto result = AssertQueryBuilder(unionNode).copyResults(pool());
+  ASSERT_EQ(result->size(), kRowsPerSource * kNumSources);
+}
+
+TEST_F(MixedUnionTest, stats) {
+  constexpr int kRowsPerSource = 100;
+  auto data1 = makeRowVector({
+      makeFlatVector<int64_t>(kRowsPerSource, [](auto row) { return row; }),
+  });
+  auto data2 = makeRowVector({
+      makeFlatVector<int64_t>(
+          kRowsPerSource, [](auto row) { return row + 100; }),
+  });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId unionNodeId;
+  auto unionNode = std::make_shared<core::MixedUnionNode>(
+      planNodeIdGenerator->next(),
+      std::vector<core::PlanNodePtr>{
+          PlanBuilder(planNodeIdGenerator).values({data1}).planNode(),
+          PlanBuilder(planNodeIdGenerator).values({data2}).planNode()});
+  unionNodeId = unionNode->id();
+
+  auto task = AssertQueryBuilder(unionNode).copyResults(pool());
+  ASSERT_EQ(task->size(), kRowsPerSource * 2);
+}
+
+TEST_F(MixedUnionTest, withFilter) {
+  auto data1 = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+  });
+  auto data2 = makeRowVector({
+      makeFlatVector<int64_t>({6, 7, 8, 9, 10}),
+  });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto unionNode = makeUnionNode(
+      {PlanBuilder(planNodeIdGenerator).values({data1}).planNode(),
+       PlanBuilder(planNodeIdGenerator).values({data2}).planNode()},
+      planNodeIdGenerator);
+
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .addNode([&](auto, auto) { return unionNode; })
+                  .filter("c0 > 5")
+                  .planNode();
+
+  assertQuery(plan, "VALUES (6), (7), (8), (9), (10)");
+}
+
+TEST_F(MixedUnionTest, withProject) {
+  auto data1 = makeRowVector({
+      makeFlatVector<int64_t>({1, 2}),
+      makeFlatVector<int64_t>({10, 20}),
+  });
+  auto data2 = makeRowVector({
+      makeFlatVector<int64_t>({3, 4}),
+      makeFlatVector<int64_t>({30, 40}),
+  });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto unionNode = makeUnionNode(
+      {PlanBuilder(planNodeIdGenerator).values({data1}).planNode(),
+       PlanBuilder(planNodeIdGenerator).values({data2}).planNode()},
+      planNodeIdGenerator);
+
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .addNode([&](auto, auto) { return unionNode; })
+                  .project({"c0 + c1 as sum"})
+                  .planNode();
+
+  assertQuery(plan, "VALUES (11), (22), (33), (44)");
+}
+
+TEST_F(MixedUnionTest, withAggregation) {
+  auto data1 = makeRowVector({
+      makeFlatVector<int64_t>({1, 1, 2}),
+      makeFlatVector<int64_t>({10, 20, 30}),
+  });
+  auto data2 = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 2}),
+      makeFlatVector<int64_t>({40, 50, 60}),
+  });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto unionNode = makeUnionNode(
+      {PlanBuilder(planNodeIdGenerator).values({data1}).planNode(),
+       PlanBuilder(planNodeIdGenerator).values({data2}).planNode()},
+      planNodeIdGenerator);
+
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .addNode([&](auto, auto) { return unionNode; })
+                  .singleAggregation({"c0"}, {"sum(c1)"})
+                  .planNode();
+
+  assertQuery(plan, "VALUES (1, 70), (2, 140)");
+}
+
+/// Test fixture for MixedUnion barrier execution tests using HiveConnector.
+class MixedUnionBarrierTest : public HiveConnectorTestBase {
+ protected:
+  void SetUp() override {
+    HiveConnectorTestBase::SetUp();
+  }
+
+  std::shared_ptr<core::MixedUnionNode> makeUnionNode(
+      std::vector<core::PlanNodePtr> sources,
+      std::shared_ptr<core::PlanNodeIdGenerator> planNodeIdGenerator) {
+    return std::make_shared<core::MixedUnionNode>(
+        planNodeIdGenerator->next(), std::move(sources));
+  }
+
+  std::vector<std::shared_ptr<TempFilePath>> writeDataToFiles(
+      const std::vector<RowVectorPtr>& data) {
+    std::vector<std::shared_ptr<TempFilePath>> files;
+    files.reserve(data.size());
+    for (const auto& vector : data) {
+      auto file = TempFilePath::create();
+      writeToFile(file->getPath(), vector);
+      files.push_back(file);
+    }
+    return files;
+  }
+};
+
+TEST_F(MixedUnionBarrierTest, supportsBarrier) {
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto rowType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  core::PlanNodeId scanNodeId;
+  core::PlanNodePtr unionNode;
+  const auto plan = PlanBuilder(planNodeIdGenerator)
+                        .tableScan(rowType)
+                        .capturePlanNodeId(scanNodeId)
+                        .addNode([&](const auto& id, auto source) {
+                          return std::make_shared<core::MixedUnionNode>(
+                              id,
+                              std::vector<core::PlanNodePtr>{
+                                  source,
+                                  PlanBuilder(planNodeIdGenerator)
+                                      .tableScan(rowType)
+                                      .planNode()});
+                        })
+                        .capturePlanNode(unionNode)
+                        .planNode();
+
+  auto mixedUnionNode =
+      std::dynamic_pointer_cast<const core::MixedUnionNode>(unionNode);
+  ASSERT_TRUE(mixedUnionNode != nullptr);
+  ASSERT_TRUE(mixedUnionNode->supportsBarrier());
+}
+
+TEST_F(MixedUnionBarrierTest, barrierExecution) {
+  const auto rowType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  // Create test data for two sources
+  auto leftData = makeRowVector({
+      makeFlatVector<int32_t>(100, [](auto row) { return row; }),
+      makeFlatVector<int64_t>(100, [](auto row) { return row * 10; }),
+  });
+  auto rightData = makeRowVector({
+      makeFlatVector<int32_t>(100, [](auto row) { return row + 100; }),
+      makeFlatVector<int64_t>(100, [](auto row) { return row * 10 + 1000; }),
+  });
+
+  // Write data to files
+  auto leftFile = TempFilePath::create();
+  writeToFile(leftFile->getPath(), leftData);
+  auto rightFile = TempFilePath::create();
+  writeToFile(rightFile->getPath(), rightData);
+
+  // Build plan with MixedUnion
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId leftScanNodeId;
+  core::PlanNodeId rightScanNodeId;
+
+  auto leftScan = PlanBuilder(planNodeIdGenerator)
+                      .tableScan(rowType)
+                      .capturePlanNodeId(leftScanNodeId)
+                      .planNode();
+  auto rightScan = PlanBuilder(planNodeIdGenerator)
+                       .tableScan(rowType)
+                       .capturePlanNodeId(rightScanNodeId)
+                       .planNode();
+
+  auto plan = std::make_shared<core::MixedUnionNode>(
+      planNodeIdGenerator->next(),
+      std::vector<core::PlanNodePtr>{leftScan, rightScan});
+
+  for (const auto hasBarrier : {false, true}) {
+    SCOPED_TRACE(fmt::format("hasBarrier {}", hasBarrier));
+    AssertQueryBuilder queryBuilder(plan);
+    queryBuilder.barrierExecution(hasBarrier).serialExecution(true);
+    queryBuilder.split(
+        leftScanNodeId, makeHiveConnectorSplit(leftFile->getPath()));
+    queryBuilder.split(
+        rightScanNodeId, makeHiveConnectorSplit(rightFile->getPath()));
+
+    std::shared_ptr<Task> task;
+    auto result = queryBuilder.copyResults(pool(), task);
+    ASSERT_EQ(result->size(), 200);
+
+    const auto taskStats = task->taskStats();
+    ASSERT_EQ(taskStats.numBarriers, hasBarrier ? 1 : 0);
+  }
+}
+
+TEST_F(MixedUnionBarrierTest, barrierWithMultipleSplits) {
+  const auto rowType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  // Create test data for multiple splits on each side
+  std::vector<std::shared_ptr<TempFilePath>> leftFiles;
+  std::vector<std::shared_ptr<TempFilePath>> rightFiles;
+  constexpr int kSplitsPerSide = 3;
+  constexpr int kRowsPerSplit = 50;
+
+  for (int i = 0; i < kSplitsPerSide; ++i) {
+    auto leftData = makeRowVector({
+        makeFlatVector<int32_t>(
+            kRowsPerSplit, [i](auto row) { return i * 1000 + row; }),
+        makeFlatVector<int64_t>(
+            kRowsPerSplit, [i](auto row) { return i * 10000 + row * 10; }),
+    });
+    auto rightData = makeRowVector({
+        makeFlatVector<int32_t>(
+            kRowsPerSplit, [i](auto row) { return i * 1000 + row + 500; }),
+        makeFlatVector<int64_t>(
+            kRowsPerSplit,
+            [i](auto row) { return i * 10000 + row * 10 + 5000; }),
+    });
+
+    auto leftFile = TempFilePath::create();
+    writeToFile(leftFile->getPath(), leftData);
+    leftFiles.push_back(leftFile);
+
+    auto rightFile = TempFilePath::create();
+    writeToFile(rightFile->getPath(), rightData);
+    rightFiles.push_back(rightFile);
+  }
+
+  // Build plan
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId leftScanNodeId;
+  core::PlanNodeId rightScanNodeId;
+
+  auto leftScan = PlanBuilder(planNodeIdGenerator)
+                      .tableScan(rowType)
+                      .capturePlanNodeId(leftScanNodeId)
+                      .planNode();
+  auto rightScan = PlanBuilder(planNodeIdGenerator)
+                       .tableScan(rowType)
+                       .capturePlanNodeId(rightScanNodeId)
+                       .planNode();
+
+  auto plan = std::make_shared<core::MixedUnionNode>(
+      planNodeIdGenerator->next(),
+      std::vector<core::PlanNodePtr>{leftScan, rightScan});
+
+  for (const auto hasBarrier : {false, true}) {
+    SCOPED_TRACE(fmt::format("hasBarrier {}", hasBarrier));
+    AssertQueryBuilder queryBuilder(plan);
+    queryBuilder.barrierExecution(hasBarrier).serialExecution(true);
+
+    for (const auto& file : leftFiles) {
+      queryBuilder.split(
+          leftScanNodeId, makeHiveConnectorSplit(file->getPath()));
+    }
+    for (const auto& file : rightFiles) {
+      queryBuilder.split(
+          rightScanNodeId, makeHiveConnectorSplit(file->getPath()));
+    }
+
+    auto result = queryBuilder.copyResults(pool());
+    ASSERT_EQ(result->size(), kSplitsPerSide * kRowsPerSplit * 2);
+  }
+}
+
+TEST_F(MixedUnionBarrierTest, barrierWithProject) {
+  const auto rowType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  auto leftData = makeRowVector({
+      makeFlatVector<int32_t>(50, [](auto row) { return row; }),
+      makeFlatVector<int64_t>(50, [](auto row) { return row * 2; }),
+  });
+  auto rightData = makeRowVector({
+      makeFlatVector<int32_t>(50, [](auto row) { return row + 50; }),
+      makeFlatVector<int64_t>(50, [](auto row) { return (row + 50) * 2; }),
+  });
+
+  auto leftFile = TempFilePath::create();
+  writeToFile(leftFile->getPath(), leftData);
+  auto rightFile = TempFilePath::create();
+  writeToFile(rightFile->getPath(), rightData);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId leftScanNodeId;
+  core::PlanNodeId rightScanNodeId;
+
+  auto leftScan = PlanBuilder(planNodeIdGenerator)
+                      .tableScan(rowType)
+                      .capturePlanNodeId(leftScanNodeId)
+                      .planNode();
+  auto rightScan = PlanBuilder(planNodeIdGenerator)
+                       .tableScan(rowType)
+                       .capturePlanNodeId(rightScanNodeId)
+                       .planNode();
+
+  auto unionNode = std::make_shared<core::MixedUnionNode>(
+      planNodeIdGenerator->next(),
+      std::vector<core::PlanNodePtr>{leftScan, rightScan});
+
+  // Add a project on top of the union
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .addNode([&](const auto&, auto) { return unionNode; })
+                  .project({"c0", "c1", "c0 + c1 as sum"})
+                  .planNode();
+
+  for (const auto hasBarrier : {false, true}) {
+    SCOPED_TRACE(fmt::format("hasBarrier {}", hasBarrier));
+    AssertQueryBuilder queryBuilder(plan);
+    queryBuilder.barrierExecution(hasBarrier).serialExecution(true);
+    queryBuilder.split(
+        leftScanNodeId, makeHiveConnectorSplit(leftFile->getPath()));
+    queryBuilder.split(
+        rightScanNodeId, makeHiveConnectorSplit(rightFile->getPath()));
+
+    auto result = queryBuilder.copyResults(pool());
+    ASSERT_EQ(result->size(), 100);
+    ASSERT_EQ(result->type()->size(), 3);
+  }
+}
+
+TEST_F(MixedUnionBarrierTest, barrierWithFilter) {
+  const auto rowType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  auto leftData = makeRowVector({
+      makeFlatVector<int32_t>(100, [](auto row) { return row; }),
+      makeFlatVector<int64_t>(100, [](auto row) { return row * 10; }),
+  });
+  auto rightData = makeRowVector({
+      makeFlatVector<int32_t>(100, [](auto row) { return row + 100; }),
+      makeFlatVector<int64_t>(100, [](auto row) { return row * 10 + 1000; }),
+  });
+
+  auto leftFile = TempFilePath::create();
+  writeToFile(leftFile->getPath(), leftData);
+  auto rightFile = TempFilePath::create();
+  writeToFile(rightFile->getPath(), rightData);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId leftScanNodeId;
+  core::PlanNodeId rightScanNodeId;
+
+  auto leftScan = PlanBuilder(planNodeIdGenerator)
+                      .tableScan(rowType)
+                      .capturePlanNodeId(leftScanNodeId)
+                      .planNode();
+  auto rightScan = PlanBuilder(planNodeIdGenerator)
+                       .tableScan(rowType)
+                       .capturePlanNodeId(rightScanNodeId)
+                       .planNode();
+
+  auto unionNode = std::make_shared<core::MixedUnionNode>(
+      planNodeIdGenerator->next(),
+      std::vector<core::PlanNodePtr>{leftScan, rightScan});
+
+  // Add a filter on top of the union
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .addNode([&](const auto&, auto) { return unionNode; })
+                  .filter("c0 >= 50 AND c0 < 150")
+                  .planNode();
+
+  for (const auto hasBarrier : {false, true}) {
+    SCOPED_TRACE(fmt::format("hasBarrier {}", hasBarrier));
+    AssertQueryBuilder queryBuilder(plan);
+    queryBuilder.barrierExecution(hasBarrier).serialExecution(true);
+    queryBuilder.split(
+        leftScanNodeId, makeHiveConnectorSplit(leftFile->getPath()));
+    queryBuilder.split(
+        rightScanNodeId, makeHiveConnectorSplit(rightFile->getPath()));
+
+    auto result = queryBuilder.copyResults(pool());
+    // Left source: rows 50-99 (50 rows)
+    // Right source: rows 100-149 (50 rows from 100-199 range, but capped at
+    // 149)
+    ASSERT_EQ(result->size(), 100);
+  }
+}
+
+TEST_F(MixedUnionBarrierTest, barrierWithThreeSources) {
+  const auto rowType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  auto data1 = makeRowVector({
+      makeFlatVector<int32_t>(100, [](auto row) { return row; }),
+      makeFlatVector<int64_t>(100, [](auto row) { return row * 10; }),
+  });
+  auto data2 = makeRowVector({
+      makeFlatVector<int32_t>(100, [](auto row) { return row + 100; }),
+      makeFlatVector<int64_t>(100, [](auto row) { return row * 10 + 1000; }),
+  });
+  auto data3 = makeRowVector({
+      makeFlatVector<int32_t>(100, [](auto row) { return row + 200; }),
+      makeFlatVector<int64_t>(100, [](auto row) { return row * 10 + 2000; }),
+  });
+
+  auto file1 = TempFilePath::create();
+  writeToFile(file1->getPath(), data1);
+  auto file2 = TempFilePath::create();
+  writeToFile(file2->getPath(), data2);
+  auto file3 = TempFilePath::create();
+  writeToFile(file3->getPath(), data3);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId scanNodeId1;
+  core::PlanNodeId scanNodeId2;
+  core::PlanNodeId scanNodeId3;
+
+  auto scan1 = PlanBuilder(planNodeIdGenerator)
+                   .tableScan(rowType)
+                   .capturePlanNodeId(scanNodeId1)
+                   .planNode();
+  auto scan2 = PlanBuilder(planNodeIdGenerator)
+                   .tableScan(rowType)
+                   .capturePlanNodeId(scanNodeId2)
+                   .planNode();
+  auto scan3 = PlanBuilder(planNodeIdGenerator)
+                   .tableScan(rowType)
+                   .capturePlanNodeId(scanNodeId3)
+                   .planNode();
+
+  auto plan = std::make_shared<core::MixedUnionNode>(
+      planNodeIdGenerator->next(),
+      std::vector<core::PlanNodePtr>{scan1, scan2, scan3});
+
+  for (const auto hasBarrier : {false, true}) {
+    SCOPED_TRACE(fmt::format("hasBarrier {}", hasBarrier));
+    AssertQueryBuilder queryBuilder(plan);
+    queryBuilder.barrierExecution(hasBarrier).serialExecution(true);
+    queryBuilder.split(scanNodeId1, makeHiveConnectorSplit(file1->getPath()));
+    queryBuilder.split(scanNodeId2, makeHiveConnectorSplit(file2->getPath()));
+    queryBuilder.split(scanNodeId3, makeHiveConnectorSplit(file3->getPath()));
+
+    auto result = queryBuilder.copyResults(pool());
+    ASSERT_EQ(result->size(), 300);
+  }
+}
+
+TEST_F(MixedUnionBarrierTest, barrierWithEmptySource) {
+  const auto rowType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  auto leftData = makeRowVector({
+      makeFlatVector<int32_t>(100, [](auto row) { return row; }),
+      makeFlatVector<int64_t>(100, [](auto row) { return row * 10; }),
+  });
+  // Empty right source
+  auto rightData = makeRowVector({
+      makeFlatVector<int32_t>({}),
+      makeFlatVector<int64_t>({}),
+  });
+
+  auto leftFile = TempFilePath::create();
+  writeToFile(leftFile->getPath(), leftData);
+  auto rightFile = TempFilePath::create();
+  writeToFile(rightFile->getPath(), rightData);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId leftScanNodeId;
+  core::PlanNodeId rightScanNodeId;
+
+  auto leftScan = PlanBuilder(planNodeIdGenerator)
+                      .tableScan(rowType)
+                      .capturePlanNodeId(leftScanNodeId)
+                      .planNode();
+  auto rightScan = PlanBuilder(planNodeIdGenerator)
+                       .tableScan(rowType)
+                       .capturePlanNodeId(rightScanNodeId)
+                       .planNode();
+
+  auto plan = std::make_shared<core::MixedUnionNode>(
+      planNodeIdGenerator->next(),
+      std::vector<core::PlanNodePtr>{leftScan, rightScan});
+
+  for (const auto hasBarrier : {false, true}) {
+    SCOPED_TRACE(fmt::format("hasBarrier {}", hasBarrier));
+    AssertQueryBuilder queryBuilder(plan);
+    queryBuilder.barrierExecution(hasBarrier).serialExecution(true);
+    queryBuilder.split(
+        leftScanNodeId, makeHiveConnectorSplit(leftFile->getPath()));
+    queryBuilder.split(
+        rightScanNodeId, makeHiveConnectorSplit(rightFile->getPath()));
+
+    auto result = queryBuilder.copyResults(pool());
+    ASSERT_EQ(result->size(), 100);
+  }
+}
+
+TEST_F(MixedUnionBarrierTest, barrierWithUnequalSourceSizes) {
+  const auto rowType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  // Left source has significantly more data
+  auto leftData = makeRowVector({
+      makeFlatVector<int32_t>(1000, [](auto row) { return row; }),
+      makeFlatVector<int64_t>(1000, [](auto row) { return row * 10; }),
+  });
+  // Right source has much less data
+  auto rightData = makeRowVector({
+      makeFlatVector<int32_t>(10, [](auto row) { return row + 1000; }),
+      makeFlatVector<int64_t>(10, [](auto row) { return row * 10 + 10000; }),
+  });
+
+  auto leftFile = TempFilePath::create();
+  writeToFile(leftFile->getPath(), leftData);
+  auto rightFile = TempFilePath::create();
+  writeToFile(rightFile->getPath(), rightData);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId leftScanNodeId;
+  core::PlanNodeId rightScanNodeId;
+
+  auto leftScan = PlanBuilder(planNodeIdGenerator)
+                      .tableScan(rowType)
+                      .capturePlanNodeId(leftScanNodeId)
+                      .planNode();
+  auto rightScan = PlanBuilder(planNodeIdGenerator)
+                       .tableScan(rowType)
+                       .capturePlanNodeId(rightScanNodeId)
+                       .planNode();
+
+  auto plan = std::make_shared<core::MixedUnionNode>(
+      planNodeIdGenerator->next(),
+      std::vector<core::PlanNodePtr>{leftScan, rightScan});
+
+  for (const auto hasBarrier : {false, true}) {
+    SCOPED_TRACE(fmt::format("hasBarrier {}", hasBarrier));
+    AssertQueryBuilder queryBuilder(plan);
+    queryBuilder.barrierExecution(hasBarrier).serialExecution(true);
+    queryBuilder.split(
+        leftScanNodeId, makeHiveConnectorSplit(leftFile->getPath()));
+    queryBuilder.split(
+        rightScanNodeId, makeHiveConnectorSplit(rightFile->getPath()));
+
+    auto result = queryBuilder.copyResults(pool());
+    ASSERT_EQ(result->size(), 1010);
+  }
+}
+
+TEST_F(MixedUnionBarrierTest, barrierTaskStats) {
+  const auto rowType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  auto leftData = makeRowVector({
+      makeFlatVector<int32_t>(100, [](auto row) { return row; }),
+      makeFlatVector<int64_t>(100, [](auto row) { return row * 10; }),
+  });
+  auto rightData = makeRowVector({
+      makeFlatVector<int32_t>(100, [](auto row) { return row + 100; }),
+      makeFlatVector<int64_t>(100, [](auto row) { return row * 10 + 1000; }),
+  });
+
+  auto leftFile = TempFilePath::create();
+  writeToFile(leftFile->getPath(), leftData);
+  auto rightFile = TempFilePath::create();
+  writeToFile(rightFile->getPath(), rightData);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId leftScanNodeId;
+  core::PlanNodeId rightScanNodeId;
+
+  auto leftScan = PlanBuilder(planNodeIdGenerator)
+                      .tableScan(rowType)
+                      .capturePlanNodeId(leftScanNodeId)
+                      .planNode();
+  auto rightScan = PlanBuilder(planNodeIdGenerator)
+                       .tableScan(rowType)
+                       .capturePlanNodeId(rightScanNodeId)
+                       .planNode();
+
+  auto plan = std::make_shared<core::MixedUnionNode>(
+      planNodeIdGenerator->next(),
+      std::vector<core::PlanNodePtr>{leftScan, rightScan});
+
+  for (const auto hasBarrier : {false, true}) {
+    SCOPED_TRACE(fmt::format("hasBarrier {}", hasBarrier));
+    AssertQueryBuilder queryBuilder(plan);
+    queryBuilder.barrierExecution(hasBarrier).serialExecution(true);
+    queryBuilder.split(
+        leftScanNodeId, makeHiveConnectorSplit(leftFile->getPath()));
+    queryBuilder.split(
+        rightScanNodeId, makeHiveConnectorSplit(rightFile->getPath()));
+
+    std::shared_ptr<Task> task;
+    auto result = queryBuilder.copyResults(pool(), task);
+    ASSERT_EQ(result->size(), 200);
+
+    const auto taskStats = task->taskStats();
+    ASSERT_EQ(taskStats.numBarriers, hasBarrier ? 1 : 0);
+    ASSERT_EQ(taskStats.numFinishedSplits, 2);
+  }
+}
+
+// Tests barrier with multiple splits per source. Each split triggers a separate
+// barrier cycle, exercising the drain-reset logic in finishDrain(). After each
+// cycle, sourcesDrained_ is reset so the next split group can proceed.
+TEST_F(MixedUnionBarrierTest, barrierMultipleBarrierCycles) {
+  const auto rowType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  constexpr int kSplitsPerSide = 3;
+  constexpr int kRowsPerSplit = 40;
+
+  std::vector<std::shared_ptr<TempFilePath>> leftFiles;
+  std::vector<std::shared_ptr<TempFilePath>> rightFiles;
+
+  for (int i = 0; i < kSplitsPerSide; ++i) {
+    auto leftData = makeRowVector({
+        makeFlatVector<int32_t>(
+            kRowsPerSplit, [i](auto row) { return i * 1000 + row; }),
+        makeFlatVector<int64_t>(
+            kRowsPerSplit, [i](auto row) { return i * 10000 + row * 10; }),
+    });
+    auto rightData = makeRowVector({
+        makeFlatVector<int32_t>(
+            kRowsPerSplit, [i](auto row) { return i * 1000 + row + 500; }),
+        makeFlatVector<int64_t>(
+            kRowsPerSplit,
+            [i](auto row) { return i * 10000 + row * 10 + 5000; }),
+    });
+
+    auto leftFile = TempFilePath::create();
+    writeToFile(leftFile->getPath(), leftData);
+    leftFiles.push_back(leftFile);
+
+    auto rightFile = TempFilePath::create();
+    writeToFile(rightFile->getPath(), rightData);
+    rightFiles.push_back(rightFile);
+  }
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId leftScanNodeId;
+  core::PlanNodeId rightScanNodeId;
+
+  auto leftScan = PlanBuilder(planNodeIdGenerator)
+                      .tableScan(rowType)
+                      .capturePlanNodeId(leftScanNodeId)
+                      .planNode();
+  auto rightScan = PlanBuilder(planNodeIdGenerator)
+                       .tableScan(rowType)
+                       .capturePlanNodeId(rightScanNodeId)
+                       .planNode();
+
+  auto plan = std::make_shared<core::MixedUnionNode>(
+      planNodeIdGenerator->next(),
+      std::vector<core::PlanNodePtr>{leftScan, rightScan});
+
+  AssertQueryBuilder queryBuilder(plan);
+  queryBuilder.barrierExecution(true).serialExecution(true);
+
+  for (const auto& file : leftFiles) {
+    queryBuilder.split(leftScanNodeId, makeHiveConnectorSplit(file->getPath()));
+  }
+  for (const auto& file : rightFiles) {
+    queryBuilder.split(
+        rightScanNodeId, makeHiveConnectorSplit(file->getPath()));
+  }
+
+  std::shared_ptr<Task> task;
+  auto result = queryBuilder.copyResults(pool(), task);
+  ASSERT_EQ(result->size(), kSplitsPerSide * kRowsPerSplit * 2);
+
+  const auto taskStats = task->taskStats();
+  ASSERT_EQ(taskStats.numBarriers, kSplitsPerSide);
+}
+
+// Tests barrier where one source has very little data and likely finishes
+// before the drain signal arrives. This exercises the code path in startDrain()
+// and maybeFinishDrain() that sets sourcesDrained_[i] = true when
+// sourcesFinished_[i] is already true.
+TEST_F(MixedUnionBarrierTest, barrierWithSourceFinishedBeforeDrain) {
+  const auto rowType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  // Left source has a lot of data.
+  auto leftData = makeRowVector({
+      makeFlatVector<int32_t>(1000, [](auto row) { return row; }),
+      makeFlatVector<int64_t>(1000, [](auto row) { return row * 10; }),
+  });
+  // Right source has very little data — likely finishes before drain starts.
+  auto rightData = makeRowVector({
+      makeFlatVector<int32_t>(1, [](auto /*row*/) { return 9999; }),
+      makeFlatVector<int64_t>(1, [](auto /*row*/) { return 99990; }),
+  });
+
+  auto leftFile = TempFilePath::create();
+  writeToFile(leftFile->getPath(), leftData);
+  auto rightFile = TempFilePath::create();
+  writeToFile(rightFile->getPath(), rightData);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId leftScanNodeId;
+  core::PlanNodeId rightScanNodeId;
+
+  auto leftScan = PlanBuilder(planNodeIdGenerator)
+                      .tableScan(rowType)
+                      .capturePlanNodeId(leftScanNodeId)
+                      .planNode();
+  auto rightScan = PlanBuilder(planNodeIdGenerator)
+                       .tableScan(rowType)
+                       .capturePlanNodeId(rightScanNodeId)
+                       .planNode();
+
+  auto plan = std::make_shared<core::MixedUnionNode>(
+      planNodeIdGenerator->next(),
+      std::vector<core::PlanNodePtr>{leftScan, rightScan});
+
+  for (const auto hasBarrier : {false, true}) {
+    SCOPED_TRACE(fmt::format("hasBarrier {}", hasBarrier));
+    AssertQueryBuilder queryBuilder(plan);
+    queryBuilder.barrierExecution(hasBarrier).serialExecution(true);
+    queryBuilder.split(
+        leftScanNodeId, makeHiveConnectorSplit(leftFile->getPath()));
+    queryBuilder.split(
+        rightScanNodeId, makeHiveConnectorSplit(rightFile->getPath()));
+
+    auto result = queryBuilder.copyResults(pool());
+    ASSERT_EQ(result->size(), 1001);
+  }
+}
+
+// Tests barrier where all sources are empty. The drain cycle should complete
+// immediately since all sources finish without producing data.
+TEST_F(MixedUnionBarrierTest, barrierWithAllEmptySources) {
+  const auto rowType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  auto emptyData = makeRowVector({
+      makeFlatVector<int32_t>({}),
+      makeFlatVector<int64_t>({}),
+  });
+
+  auto leftFile = TempFilePath::create();
+  writeToFile(leftFile->getPath(), emptyData);
+  auto rightFile = TempFilePath::create();
+  writeToFile(rightFile->getPath(), emptyData);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId leftScanNodeId;
+  core::PlanNodeId rightScanNodeId;
+
+  auto leftScan = PlanBuilder(planNodeIdGenerator)
+                      .tableScan(rowType)
+                      .capturePlanNodeId(leftScanNodeId)
+                      .planNode();
+  auto rightScan = PlanBuilder(planNodeIdGenerator)
+                       .tableScan(rowType)
+                       .capturePlanNodeId(rightScanNodeId)
+                       .planNode();
+
+  auto plan = std::make_shared<core::MixedUnionNode>(
+      planNodeIdGenerator->next(),
+      std::vector<core::PlanNodePtr>{leftScan, rightScan});
+
+  for (const auto hasBarrier : {false, true}) {
+    SCOPED_TRACE(fmt::format("hasBarrier {}", hasBarrier));
+    AssertQueryBuilder queryBuilder(plan);
+    queryBuilder.barrierExecution(hasBarrier).serialExecution(true);
+    queryBuilder.split(
+        leftScanNodeId, makeHiveConnectorSplit(leftFile->getPath()));
+    queryBuilder.split(
+        rightScanNodeId, makeHiveConnectorSplit(rightFile->getPath()));
+
+    auto result = queryBuilder.copyResults(pool());
+    ASSERT_EQ(result->size(), 0);
+  }
+}
+
+// Tests barrier with three sources where one source is empty. Validates that
+// the drain cycle correctly handles a mix of finished and active sources.
+TEST_F(MixedUnionBarrierTest, barrierWithThreeSourcesOneEmpty) {
+  const auto rowType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  auto data1 = makeRowVector({
+      makeFlatVector<int32_t>(100, [](auto row) { return row; }),
+      makeFlatVector<int64_t>(100, [](auto row) { return row * 10; }),
+  });
+  auto emptyData = makeRowVector({
+      makeFlatVector<int32_t>({}),
+      makeFlatVector<int64_t>({}),
+  });
+  auto data3 = makeRowVector({
+      makeFlatVector<int32_t>(50, [](auto row) { return row + 200; }),
+      makeFlatVector<int64_t>(50, [](auto row) { return row * 10 + 2000; }),
+  });
+
+  auto file1 = TempFilePath::create();
+  writeToFile(file1->getPath(), data1);
+  auto file2 = TempFilePath::create();
+  writeToFile(file2->getPath(), emptyData);
+  auto file3 = TempFilePath::create();
+  writeToFile(file3->getPath(), data3);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId scanNodeId1;
+  core::PlanNodeId scanNodeId2;
+  core::PlanNodeId scanNodeId3;
+
+  auto scan1 = PlanBuilder(planNodeIdGenerator)
+                   .tableScan(rowType)
+                   .capturePlanNodeId(scanNodeId1)
+                   .planNode();
+  auto scan2 = PlanBuilder(planNodeIdGenerator)
+                   .tableScan(rowType)
+                   .capturePlanNodeId(scanNodeId2)
+                   .planNode();
+  auto scan3 = PlanBuilder(planNodeIdGenerator)
+                   .tableScan(rowType)
+                   .capturePlanNodeId(scanNodeId3)
+                   .planNode();
+
+  auto plan = std::make_shared<core::MixedUnionNode>(
+      planNodeIdGenerator->next(),
+      std::vector<core::PlanNodePtr>{scan1, scan2, scan3});
+
+  for (const auto hasBarrier : {false, true}) {
+    SCOPED_TRACE(fmt::format("hasBarrier {}", hasBarrier));
+    AssertQueryBuilder queryBuilder(plan);
+    queryBuilder.barrierExecution(hasBarrier).serialExecution(true);
+    queryBuilder.split(scanNodeId1, makeHiveConnectorSplit(file1->getPath()));
+    queryBuilder.split(scanNodeId2, makeHiveConnectorSplit(file2->getPath()));
+    queryBuilder.split(scanNodeId3, makeHiveConnectorSplit(file3->getPath()));
+
+    auto result = queryBuilder.copyResults(pool());
+    ASSERT_EQ(result->size(), 150);
+  }
+}
+
+// Tests drain where one source finishes producing data very quickly (and is
+// marked finished) while the other source is still producing large amounts of
+// data. The finished source should be marked as drained immediately in
+// startDrain() and maybeFinishDrain().
+TEST_F(MixedUnionBarrierTest, drainOneSideFinishedOtherProducing) {
+  const auto rowType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  // Left source produces a lot of data in small batches.
+  constexpr int kLeftBatches = 10;
+  constexpr int kRowsPerBatch = 50;
+  auto leftFile = TempFilePath::create();
+  {
+    auto leftData = makeRowVector({
+        makeFlatVector<int32_t>(
+            kLeftBatches * kRowsPerBatch, [](auto row) { return row; }),
+        makeFlatVector<int64_t>(
+            kLeftBatches * kRowsPerBatch, [](auto row) { return row * 10; }),
+    });
+    writeToFile(leftFile->getPath(), leftData);
+  }
+
+  // Right source is empty — finishes immediately.
+  auto rightFile = TempFilePath::create();
+  {
+    auto rightData = makeRowVector({
+        makeFlatVector<int32_t>({}),
+        makeFlatVector<int64_t>({}),
+    });
+    writeToFile(rightFile->getPath(), rightData);
+  }
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId leftScanNodeId;
+  core::PlanNodeId rightScanNodeId;
+
+  auto leftScan = PlanBuilder(planNodeIdGenerator)
+                      .tableScan(rowType)
+                      .capturePlanNodeId(leftScanNodeId)
+                      .planNode();
+  auto rightScan = PlanBuilder(planNodeIdGenerator)
+                       .tableScan(rowType)
+                       .capturePlanNodeId(rightScanNodeId)
+                       .planNode();
+
+  auto plan = std::make_shared<core::MixedUnionNode>(
+      planNodeIdGenerator->next(),
+      std::vector<core::PlanNodePtr>{leftScan, rightScan});
+
+  AssertQueryBuilder queryBuilder(plan);
+  queryBuilder.barrierExecution(true).serialExecution(true);
+  queryBuilder.split(
+      leftScanNodeId, makeHiveConnectorSplit(leftFile->getPath()));
+  queryBuilder.split(
+      rightScanNodeId, makeHiveConnectorSplit(rightFile->getPath()));
+
+  std::shared_ptr<Task> task;
+  auto result = queryBuilder.copyResults(pool(), task);
+  ASSERT_EQ(result->size(), kLeftBatches * kRowsPerBatch);
+
+  const auto taskStats = task->taskStats();
+  ASSERT_EQ(taskStats.numBarriers, 1);
+}
+
+// Tests drain where both sources have produced some data but one is drained
+// (signals no more data) while the other still has pending data buffered.
+// This exercises the code path where pendingData_ is drained while one source
+// has already signaled drained.
+TEST_F(MixedUnionBarrierTest, drainWithPendingDataOnOneSide) {
+  const auto rowType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  // Both sources have data, but different amounts to create asymmetric
+  // completion.
+  auto leftData = makeRowVector({
+      makeFlatVector<int32_t>(200, [](auto row) { return row; }),
+      makeFlatVector<int64_t>(200, [](auto row) { return row * 10; }),
+  });
+  auto rightData = makeRowVector({
+      makeFlatVector<int32_t>(50, [](auto row) { return row + 1000; }),
+      makeFlatVector<int64_t>(50, [](auto row) { return row * 10 + 10000; }),
+  });
+
+  auto leftFile = TempFilePath::create();
+  writeToFile(leftFile->getPath(), leftData);
+  auto rightFile = TempFilePath::create();
+  writeToFile(rightFile->getPath(), rightData);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId leftScanNodeId;
+  core::PlanNodeId rightScanNodeId;
+
+  auto leftScan = PlanBuilder(planNodeIdGenerator)
+                      .tableScan(rowType)
+                      .capturePlanNodeId(leftScanNodeId)
+                      .planNode();
+  auto rightScan = PlanBuilder(planNodeIdGenerator)
+                       .tableScan(rowType)
+                       .capturePlanNodeId(rightScanNodeId)
+                       .planNode();
+
+  auto plan = std::make_shared<core::MixedUnionNode>(
+      planNodeIdGenerator->next(),
+      std::vector<core::PlanNodePtr>{leftScan, rightScan});
+
+  AssertQueryBuilder queryBuilder(plan);
+  queryBuilder.barrierExecution(true).serialExecution(true);
+  queryBuilder.split(
+      leftScanNodeId, makeHiveConnectorSplit(leftFile->getPath()));
+  queryBuilder.split(
+      rightScanNodeId, makeHiveConnectorSplit(rightFile->getPath()));
+
+  std::shared_ptr<Task> task;
+  auto result = queryBuilder.copyResults(pool(), task);
+  ASSERT_EQ(result->size(), 250);
+
+  const auto taskStats = task->taskStats();
+  ASSERT_EQ(taskStats.numBarriers, 1);
+}
+
+// Tests multiple barrier cycles where sources complete in different orders
+// each cycle. This exercises the reset logic in finishDrain() ensuring
+// sourcesDrained_ is properly cleared between cycles.
+TEST_F(MixedUnionBarrierTest, multipleBarrierCyclesAlternatingCompletion) {
+  const auto rowType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  constexpr int kSplitsPerSide = 4;
+
+  std::vector<std::shared_ptr<TempFilePath>> leftFiles;
+  std::vector<std::shared_ptr<TempFilePath>> rightFiles;
+
+  // Create splits with alternating sizes so completion order varies.
+  for (int i = 0; i < kSplitsPerSide; ++i) {
+    // Alternate which side has more data.
+    int leftRows = (i % 2 == 0) ? 100 : 10;
+    int rightRows = (i % 2 == 0) ? 10 : 100;
+
+    auto leftData = makeRowVector({
+        makeFlatVector<int32_t>(
+            leftRows, [i](auto row) { return i * 1000 + row; }),
+        makeFlatVector<int64_t>(
+            leftRows, [i](auto row) { return i * 10000 + row * 10; }),
+    });
+    auto rightData = makeRowVector({
+        makeFlatVector<int32_t>(
+            rightRows, [i](auto row) { return i * 1000 + row + 500; }),
+        makeFlatVector<int64_t>(
+            rightRows, [i](auto row) { return i * 10000 + row * 10 + 5000; }),
+    });
+
+    auto leftFile = TempFilePath::create();
+    writeToFile(leftFile->getPath(), leftData);
+    leftFiles.push_back(leftFile);
+
+    auto rightFile = TempFilePath::create();
+    writeToFile(rightFile->getPath(), rightData);
+    rightFiles.push_back(rightFile);
+  }
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId leftScanNodeId;
+  core::PlanNodeId rightScanNodeId;
+
+  auto leftScan = PlanBuilder(planNodeIdGenerator)
+                      .tableScan(rowType)
+                      .capturePlanNodeId(leftScanNodeId)
+                      .planNode();
+  auto rightScan = PlanBuilder(planNodeIdGenerator)
+                       .tableScan(rowType)
+                       .capturePlanNodeId(rightScanNodeId)
+                       .planNode();
+
+  auto plan = std::make_shared<core::MixedUnionNode>(
+      planNodeIdGenerator->next(),
+      std::vector<core::PlanNodePtr>{leftScan, rightScan});
+
+  AssertQueryBuilder queryBuilder(plan);
+  queryBuilder.barrierExecution(true).serialExecution(true);
+
+  for (const auto& file : leftFiles) {
+    queryBuilder.split(leftScanNodeId, makeHiveConnectorSplit(file->getPath()));
+  }
+  for (const auto& file : rightFiles) {
+    queryBuilder.split(
+        rightScanNodeId, makeHiveConnectorSplit(file->getPath()));
+  }
+
+  std::shared_ptr<Task> task;
+  auto result = queryBuilder.copyResults(pool(), task);
+  // Each cycle: 2 splits alternate 100+10 and 10+100 = 110 rows per cycle.
+  // Total: 4 cycles * 110 = 440 rows.
+  ASSERT_EQ(result->size(), 440);
+
+  const auto taskStats = task->taskStats();
+  ASSERT_EQ(taskStats.numBarriers, kSplitsPerSide);
+}
+
+// Tests drain with three sources where they complete in different orders:
+// first source finishes, second is drained, third still has pending data.
+TEST_F(MixedUnionBarrierTest, drainThreeSourcesMixedStates) {
+  const auto rowType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  // Source 1: Empty (finishes immediately).
+  auto data1 = makeRowVector({
+      makeFlatVector<int32_t>({}),
+      makeFlatVector<int64_t>({}),
+  });
+  // Source 2: Small amount (drains quickly).
+  auto data2 = makeRowVector({
+      makeFlatVector<int32_t>(20, [](auto row) { return row + 100; }),
+      makeFlatVector<int64_t>(20, [](auto row) { return row * 10 + 1000; }),
+  });
+  // Source 3: Large amount (still producing when others complete).
+  auto data3 = makeRowVector({
+      makeFlatVector<int32_t>(500, [](auto row) { return row + 200; }),
+      makeFlatVector<int64_t>(500, [](auto row) { return row * 10 + 2000; }),
+  });
+
+  auto file1 = TempFilePath::create();
+  writeToFile(file1->getPath(), data1);
+  auto file2 = TempFilePath::create();
+  writeToFile(file2->getPath(), data2);
+  auto file3 = TempFilePath::create();
+  writeToFile(file3->getPath(), data3);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId scanNodeId1;
+  core::PlanNodeId scanNodeId2;
+  core::PlanNodeId scanNodeId3;
+
+  auto scan1 = PlanBuilder(planNodeIdGenerator)
+                   .tableScan(rowType)
+                   .capturePlanNodeId(scanNodeId1)
+                   .planNode();
+  auto scan2 = PlanBuilder(planNodeIdGenerator)
+                   .tableScan(rowType)
+                   .capturePlanNodeId(scanNodeId2)
+                   .planNode();
+  auto scan3 = PlanBuilder(planNodeIdGenerator)
+                   .tableScan(rowType)
+                   .capturePlanNodeId(scanNodeId3)
+                   .planNode();
+
+  auto plan = std::make_shared<core::MixedUnionNode>(
+      planNodeIdGenerator->next(),
+      std::vector<core::PlanNodePtr>{scan1, scan2, scan3});
+
+  AssertQueryBuilder queryBuilder(plan);
+  queryBuilder.barrierExecution(true).serialExecution(true);
+  queryBuilder.split(scanNodeId1, makeHiveConnectorSplit(file1->getPath()));
+  queryBuilder.split(scanNodeId2, makeHiveConnectorSplit(file2->getPath()));
+  queryBuilder.split(scanNodeId3, makeHiveConnectorSplit(file3->getPath()));
+
+  std::shared_ptr<Task> task;
+  auto result = queryBuilder.copyResults(pool(), task);
+  ASSERT_EQ(result->size(), 520);
+
+  const auto taskStats = task->taskStats();
+  ASSERT_EQ(taskStats.numBarriers, 1);
+}
+
+// Tests that the operator correctly handles rapid barrier cycles with minimal
+// data. This ensures that state reset between cycles is complete and doesn't
+// leave stale flags.
+TEST_F(MixedUnionBarrierTest, rapidBarrierCyclesMinimalData) {
+  const auto rowType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  constexpr int kSplitsPerSide = 5;
+  constexpr int kRowsPerSplit = 5;
+
+  std::vector<std::shared_ptr<TempFilePath>> leftFiles;
+  std::vector<std::shared_ptr<TempFilePath>> rightFiles;
+
+  for (int i = 0; i < kSplitsPerSide; ++i) {
+    auto leftData = makeRowVector({
+        makeFlatVector<int32_t>(
+            kRowsPerSplit, [i](auto row) { return i * 100 + row; }),
+        makeFlatVector<int64_t>(
+            kRowsPerSplit, [i](auto row) { return i * 1000 + row * 10; }),
+    });
+    auto rightData = makeRowVector({
+        makeFlatVector<int32_t>(
+            kRowsPerSplit, [i](auto row) { return i * 100 + row + 50; }),
+        makeFlatVector<int64_t>(
+            kRowsPerSplit, [i](auto row) { return i * 1000 + row * 10 + 500; }),
+    });
+
+    auto leftFile = TempFilePath::create();
+    writeToFile(leftFile->getPath(), leftData);
+    leftFiles.push_back(leftFile);
+
+    auto rightFile = TempFilePath::create();
+    writeToFile(rightFile->getPath(), rightData);
+    rightFiles.push_back(rightFile);
+  }
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId leftScanNodeId;
+  core::PlanNodeId rightScanNodeId;
+
+  auto leftScan = PlanBuilder(planNodeIdGenerator)
+                      .tableScan(rowType)
+                      .capturePlanNodeId(leftScanNodeId)
+                      .planNode();
+  auto rightScan = PlanBuilder(planNodeIdGenerator)
+                       .tableScan(rowType)
+                       .capturePlanNodeId(rightScanNodeId)
+                       .planNode();
+
+  auto plan = std::make_shared<core::MixedUnionNode>(
+      planNodeIdGenerator->next(),
+      std::vector<core::PlanNodePtr>{leftScan, rightScan});
+
+  AssertQueryBuilder queryBuilder(plan);
+  queryBuilder.barrierExecution(true).serialExecution(true);
+
+  for (const auto& file : leftFiles) {
+    queryBuilder.split(leftScanNodeId, makeHiveConnectorSplit(file->getPath()));
+  }
+  for (const auto& file : rightFiles) {
+    queryBuilder.split(
+        rightScanNodeId, makeHiveConnectorSplit(file->getPath()));
+  }
+
+  std::shared_ptr<Task> task;
+  auto result = queryBuilder.copyResults(pool(), task);
+  ASSERT_EQ(result->size(), kSplitsPerSide * kRowsPerSplit * 2);
+
+  const auto taskStats = task->taskStats();
+  ASSERT_EQ(taskStats.numBarriers, kSplitsPerSide);
+}
+
+TEST_F(MixedUnionBarrierTest, barrierWithAggregation) {
+  const auto rowType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  auto leftData = makeRowVector({
+      makeFlatVector<int32_t>(100, [](auto row) { return row % 10; }),
+      makeFlatVector<int64_t>(100, [](auto row) { return row; }),
+  });
+  auto rightData = makeRowVector({
+      makeFlatVector<int32_t>(100, [](auto row) { return row % 10; }),
+      makeFlatVector<int64_t>(100, [](auto row) { return row + 100; }),
+  });
+
+  auto leftFile = TempFilePath::create();
+  writeToFile(leftFile->getPath(), leftData);
+  auto rightFile = TempFilePath::create();
+  writeToFile(rightFile->getPath(), rightData);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId leftScanNodeId;
+  core::PlanNodeId rightScanNodeId;
+
+  auto leftScan = PlanBuilder(planNodeIdGenerator)
+                      .tableScan(rowType)
+                      .capturePlanNodeId(leftScanNodeId)
+                      .planNode();
+  auto rightScan = PlanBuilder(planNodeIdGenerator)
+                       .tableScan(rowType)
+                       .capturePlanNodeId(rightScanNodeId)
+                       .planNode();
+
+  auto unionNode = std::make_shared<core::MixedUnionNode>(
+      planNodeIdGenerator->next(),
+      std::vector<core::PlanNodePtr>{leftScan, rightScan});
+
+  // Add a single aggregation on top of the union.
+  // Note: Only non-barrier mode works with singleAggregation since hash
+  // aggregation doesn't support barriers (only streaming aggregation does).
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .addNode([&](const auto&, auto) { return unionNode; })
+                  .singleAggregation({"c0"}, {"sum(c1)"})
+                  .planNode();
+
+  // Aggregation doesn't support barriers, so only test non-barrier mode.
+  AssertQueryBuilder queryBuilder(plan);
+  queryBuilder.serialExecution(true);
+  queryBuilder.split(
+      leftScanNodeId, makeHiveConnectorSplit(leftFile->getPath()));
+  queryBuilder.split(
+      rightScanNodeId, makeHiveConnectorSplit(rightFile->getPath()));
+
+  auto result = queryBuilder.copyResults(pool());
+  // 10 distinct groups
+  ASSERT_EQ(result->size(), 10);
+}
diff --git a/velox/exec/tests/MixedUnionWithTableScanTest.cpp b/velox/exec/tests/MixedUnionWithTableScanTest.cpp
new file mode 100644
index 00000000000..fb6f8011191
--- /dev/null
+++ b/velox/exec/tests/MixedUnionWithTableScanTest.cpp
@@ -0,0 +1,688 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+/// Tests for MixedUnion operator with TableScan sources.
+/// Similar to koski's TestLocalWarehouseReadSplit.cpp but exercises
+/// velox execution directly.
+class MixedUnionWithTableScanTest : public HiveConnectorTestBase {
+ protected:
+  void SetUp() override {
+    HiveConnectorTestBase::SetUp();
+  }
+
+  void TearDown() override {
+    HiveConnectorTestBase::TearDown();
+  }
+
+  /// Helper to create a MixedUnionNode from multiple plan node sources.
+  std::shared_ptr<core::MixedUnionNode> makeMixedUnionNode(
+      std::vector<core::PlanNodePtr> sources,
+      std::shared_ptr<core::PlanNodeIdGenerator> planNodeIdGenerator) {
+    return std::make_shared<core::MixedUnionNode>(
+        planNodeIdGenerator->next(), std::move(sources));
+  }
+
+  /// Helper to create a table scan plan node.
+  core::PlanNodePtr makeTableScanNode(
+      const RowTypePtr& rowType,
+      std::shared_ptr<core::PlanNodeIdGenerator> planNodeIdGenerator) {
+    return PlanBuilder(planNodeIdGenerator).tableScan(rowType).planNode();
+  }
+
+  /// Helper to write test data to files and return the file paths.
+  std::vector<std::shared_ptr<TempFilePath>> writeTestData(
+      const std::vector<RowVectorPtr>& vectors) {
+    auto filePaths = makeFilePaths(vectors.size());
+    for (size_t i = 0; i < vectors.size(); ++i) {
+      writeToFile(filePaths[i]->getPath(), vectors[i]);
+    }
+    return filePaths;
+  }
+
+  RowTypePtr testSchema_{ROW({"c0", "c1"}, {BIGINT(), VARCHAR()})};
+};
+
+/// Basic test: Union of two table scans.
+TEST_F(MixedUnionWithTableScanTest, basicUnionOfTableScans) {
+  // Create test data for two tables.
+  auto data1 = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      makeFlatVector<StringView>({"a", "b", "c"}),
+  });
+  auto data2 = makeRowVector({
+      makeFlatVector<int64_t>({4, 5, 6}),
+      makeFlatVector<StringView>({"d", "e", "f"}),
+  });
+
+  // Write data to files.
+  auto filePath1 = TempFilePath::create();
+  auto filePath2 = TempFilePath::create();
+  writeToFile(filePath1->getPath(), data1);
+  writeToFile(filePath2->getPath(), data2);
+
+  // Build plan with MixedUnion of two table scans.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto rowType = asRowType(data1->type());
+
+  core::PlanNodeId tableScan1Id;
+  auto source1 = PlanBuilder(planNodeIdGenerator)
+                     .tableScan(rowType)
+                     .capturePlanNodeId(tableScan1Id)
+                     .planNode();
+
+  core::PlanNodeId tableScan2Id;
+  auto source2 = PlanBuilder(planNodeIdGenerator)
+                     .tableScan(rowType)
+                     .capturePlanNodeId(tableScan2Id)
+                     .planNode();
+
+  auto unionNode = makeMixedUnionNode({source1, source2}, planNodeIdGenerator);
+
+  // Execute query with splits.
+  auto result =
+      AssertQueryBuilder(unionNode)
+          .split(tableScan1Id, makeHiveConnectorSplit(filePath1->getPath()))
+          .split(tableScan2Id, makeHiveConnectorSplit(filePath2->getPath()))
+          .copyResults(pool());
+
+  ASSERT_EQ(result->size(), 6);
+
+  // Validate result content and row order.
+  // MixedUnion preserves row order: data1 rows come first, then data2 rows.
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4, 5, 6}),
+      makeFlatVector<StringView>({"a", "b", "c", "d", "e", "f"}),
+  });
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+/// Test union of a single table scan (edge case).
+TEST_F(MixedUnionWithTableScanTest, singleTableScanUnion) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      makeFlatVector<StringView>({"a", "b", "c"}),
+  });
+
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), data);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto rowType = asRowType(data->type());
+
+  core::PlanNodeId tableScanId;
+  auto source = PlanBuilder(planNodeIdGenerator)
+                    .tableScan(rowType)
+                    .capturePlanNodeId(tableScanId)
+                    .planNode();
+
+  auto unionNode = makeMixedUnionNode({source}, planNodeIdGenerator);
+
+  auto result =
+      AssertQueryBuilder(unionNode)
+          .split(tableScanId, makeHiveConnectorSplit(filePath->getPath()))
+          .copyResults(pool());
+
+  ASSERT_EQ(result->size(), 3);
+
+  // Validate result content and row order.
+  facebook::velox::test::assertEqualVectors(data, result);
+}
+
+/// Test union with multiple table scans (more than 2).
+TEST_F(MixedUnionWithTableScanTest, multipleTableScanUnion) {
+  constexpr int kNumSources = 5;
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  std::vector<std::shared_ptr<TempFilePath>> filePaths;
+  std::vector<core::PlanNodePtr> sources;
+  std::vector<core::PlanNodeId> tableScanIds;
+
+  auto rowType = ROW({"c0"}, {BIGINT()});
+
+  for (int i = 0; i < kNumSources; ++i) {
+    auto data = makeRowVector({
+        makeFlatVector<int64_t>({i * 10, i * 10 + 1}),
+    });
+
+    auto filePath = TempFilePath::create();
+    writeToFile(filePath->getPath(), data);
+    filePaths.push_back(filePath);
+
+    core::PlanNodeId tableScanId;
+    auto source = PlanBuilder(planNodeIdGenerator)
+                      .tableScan(rowType)
+                      .capturePlanNodeId(tableScanId)
+                      .planNode();
+    sources.push_back(source);
+    tableScanIds.push_back(tableScanId);
+  }
+
+  auto unionNode = makeMixedUnionNode(std::move(sources), planNodeIdGenerator);
+
+  auto queryBuilder = AssertQueryBuilder(unionNode);
+  for (int i = 0; i < kNumSources; ++i) {
+    queryBuilder.split(
+        tableScanIds[i], makeHiveConnectorSplit(filePaths[i]->getPath()));
+  }
+
+  auto result = queryBuilder.copyResults(pool());
+  ASSERT_EQ(result->size(), kNumSources * 2);
+
+  // Validate result content and row order.
+  // MixedUnion preserves row order: source 0, 1, 2, 3, 4.
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>({0, 1, 10, 11, 20, 21, 30, 31, 40, 41}),
+  });
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+/// Test union with empty table scan source.
+TEST_F(MixedUnionWithTableScanTest, emptyTableScanSource) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      makeFlatVector<StringView>({"a", "b", "c"}),
+  });
+  auto emptyData = makeRowVector({
+      makeFlatVector<int64_t>({}),
+      makeFlatVector<StringView>({}),
+  });
+
+  auto filePath1 = TempFilePath::create();
+  auto filePath2 = TempFilePath::create();
+  writeToFile(filePath1->getPath(), data);
+  writeToFile(filePath2->getPath(), emptyData);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto rowType = asRowType(data->type());
+
+  core::PlanNodeId tableScan1Id;
+  auto source1 = PlanBuilder(planNodeIdGenerator)
+                     .tableScan(rowType)
+                     .capturePlanNodeId(tableScan1Id)
+                     .planNode();
+
+  core::PlanNodeId tableScan2Id;
+  auto source2 = PlanBuilder(planNodeIdGenerator)
+                     .tableScan(rowType)
+                     .capturePlanNodeId(tableScan2Id)
+                     .planNode();
+
+  auto unionNode = makeMixedUnionNode({source1, source2}, planNodeIdGenerator);
+
+  auto result =
+      AssertQueryBuilder(unionNode)
+          .split(tableScan1Id, makeHiveConnectorSplit(filePath1->getPath()))
+          .split(tableScan2Id, makeHiveConnectorSplit(filePath2->getPath()))
+          .copyResults(pool());
+
+  // Should only get data from non-empty source.
+  ASSERT_EQ(result->size(), 3);
+
+  // Validate result content and row order.
+  facebook::velox::test::assertEqualVectors(data, result);
+}
+
+/// Test union with filter pushed down to table scan.
+TEST_F(MixedUnionWithTableScanTest, unionWithFilteredTableScans) {
+  auto data1 = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+      makeFlatVector<StringView>({"a", "b", "c", "d", "e"}),
+  });
+  auto data2 = makeRowVector({
+      makeFlatVector<int64_t>({6, 7, 8, 9, 10}),
+      makeFlatVector<StringView>({"f", "g", "h", "i", "j"}),
+  });
+
+  auto filePath1 = TempFilePath::create();
+  auto filePath2 = TempFilePath::create();
+  writeToFile(filePath1->getPath(), data1);
+  writeToFile(filePath2->getPath(), data2);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto rowType = asRowType(data1->type());
+
+  // Build table scans with filters.
+  core::PlanNodeId tableScan1Id;
+  auto source1 = PlanBuilder(planNodeIdGenerator)
+                     .tableScan(rowType)
+                     .capturePlanNodeId(tableScan1Id)
+                     .filter("c0 > 2")
+                     .planNode();
+
+  core::PlanNodeId tableScan2Id;
+  auto source2 = PlanBuilder(planNodeIdGenerator)
+                     .tableScan(rowType)
+                     .capturePlanNodeId(tableScan2Id)
+                     .filter("c0 < 9")
+                     .planNode();
+
+  auto unionNode = makeMixedUnionNode({source1, source2}, planNodeIdGenerator);
+
+  auto result =
+      AssertQueryBuilder(unionNode)
+          .split(tableScan1Id, makeHiveConnectorSplit(filePath1->getPath()))
+          .split(tableScan2Id, makeHiveConnectorSplit(filePath2->getPath()))
+          .copyResults(pool());
+
+  // source1: 3,4,5 (3 rows), source2: 6,7,8 (3 rows).
+  ASSERT_EQ(result->size(), 6);
+
+  // Validate result content and row order.
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>({3, 4, 5, 6, 7, 8}),
+      makeFlatVector<StringView>({"c", "d", "e", "f", "g", "h"}),
+  });
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+/// Test union with projection after table scan.
+TEST_F(MixedUnionWithTableScanTest, unionWithProjectedTableScans) {
+  auto data1 = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      makeFlatVector<int64_t>({10, 20, 30}),
+  });
+  auto data2 = makeRowVector({
+      makeFlatVector<int64_t>({4, 5, 6}),
+      makeFlatVector<int64_t>({40, 50, 60}),
+  });
+
+  auto filePath1 = TempFilePath::create();
+  auto filePath2 = TempFilePath::create();
+  writeToFile(filePath1->getPath(), data1);
+  writeToFile(filePath2->getPath(), data2);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto rowType = asRowType(data1->type());
+
+  // Build table scans with projections (sum of columns).
+  core::PlanNodeId tableScan1Id;
+  auto source1 = PlanBuilder(planNodeIdGenerator)
+                     .tableScan(rowType)
+                     .capturePlanNodeId(tableScan1Id)
+                     .project({"c0 + c1 as sum"})
+                     .planNode();
+
+  core::PlanNodeId tableScan2Id;
+  auto source2 = PlanBuilder(planNodeIdGenerator)
+                     .tableScan(rowType)
+                     .capturePlanNodeId(tableScan2Id)
+                     .project({"c0 + c1 as sum"})
+                     .planNode();
+
+  auto unionNode = makeMixedUnionNode({source1, source2}, planNodeIdGenerator);
+
+  auto result =
+      AssertQueryBuilder(unionNode)
+          .split(tableScan1Id, makeHiveConnectorSplit(filePath1->getPath()))
+          .split(tableScan2Id, makeHiveConnectorSplit(filePath2->getPath()))
+          .copyResults(pool());
+
+  ASSERT_EQ(result->size(), 6);
+
+  // Validate result content and row order.
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>({11, 22, 33, 44, 55, 66}),
+  });
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+/// Test union followed by aggregation.
+TEST_F(MixedUnionWithTableScanTest, unionWithAggregation) {
+  auto data1 = makeRowVector({
+      makeFlatVector<int64_t>({1, 1, 2}),
+      makeFlatVector<int64_t>({10, 20, 30}),
+  });
+  auto data2 = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 2}),
+      makeFlatVector<int64_t>({40, 50, 60}),
+  });
+
+  auto filePath1 = TempFilePath::create();
+  auto filePath2 = TempFilePath::create();
+  writeToFile(filePath1->getPath(), data1);
+  writeToFile(filePath2->getPath(), data2);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto rowType = asRowType(data1->type());
+
+  core::PlanNodeId tableScan1Id;
+  auto source1 = PlanBuilder(planNodeIdGenerator)
+                     .tableScan(rowType)
+                     .capturePlanNodeId(tableScan1Id)
+                     .planNode();
+
+  core::PlanNodeId tableScan2Id;
+  auto source2 = PlanBuilder(planNodeIdGenerator)
+                     .tableScan(rowType)
+                     .capturePlanNodeId(tableScan2Id)
+                     .planNode();
+
+  auto unionNode = makeMixedUnionNode({source1, source2}, planNodeIdGenerator);
+
+  // Add aggregation after union.
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .addNode([&](auto, auto) { return unionNode; })
+                  .singleAggregation({"c0"}, {"sum(c1)"})
+                  .planNode();
+
+  auto result =
+      AssertQueryBuilder(plan)
+          .split(tableScan1Id, makeHiveConnectorSplit(filePath1->getPath()))
+          .split(tableScan2Id, makeHiveConnectorSplit(filePath2->getPath()))
+          .copyResults(pool());
+
+  // Group 1: 10 + 20 + 40 = 70.
+  // Group 2: 30 + 50 + 60 = 140.
+  ASSERT_EQ(result->size(), 2);
+}
+
+/// Test union with multiple splits per table scan.
+TEST_F(MixedUnionWithTableScanTest, unionWithMultipleSplitsPerSource) {
+  auto data1a = makeRowVector({
+      makeFlatVector<int64_t>({1, 2}),
+  });
+  auto data1b = makeRowVector({
+      makeFlatVector<int64_t>({3, 4}),
+  });
+  auto data2a = makeRowVector({
+      makeFlatVector<int64_t>({5, 6}),
+  });
+  auto data2b = makeRowVector({
+      makeFlatVector<int64_t>({7, 8}),
+  });
+
+  auto filePath1a = TempFilePath::create();
+  auto filePath1b = TempFilePath::create();
+  auto filePath2a = TempFilePath::create();
+  auto filePath2b = TempFilePath::create();
+  writeToFile(filePath1a->getPath(), data1a);
+  writeToFile(filePath1b->getPath(), data1b);
+  writeToFile(filePath2a->getPath(), data2a);
+  writeToFile(filePath2b->getPath(), data2b);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto rowType = asRowType(data1a->type());
+
+  core::PlanNodeId tableScan1Id;
+  auto source1 = PlanBuilder(planNodeIdGenerator)
+                     .tableScan(rowType)
+                     .capturePlanNodeId(tableScan1Id)
+                     .planNode();
+
+  core::PlanNodeId tableScan2Id;
+  auto source2 = PlanBuilder(planNodeIdGenerator)
+                     .tableScan(rowType)
+                     .capturePlanNodeId(tableScan2Id)
+                     .planNode();
+
+  auto unionNode = makeMixedUnionNode({source1, source2}, planNodeIdGenerator);
+
+  // Add multiple splits per table scan.
+  auto result =
+      AssertQueryBuilder(unionNode)
+          .split(tableScan1Id, makeHiveConnectorSplit(filePath1a->getPath()))
+          .split(tableScan1Id, makeHiveConnectorSplit(filePath1b->getPath()))
+          .split(tableScan2Id, makeHiveConnectorSplit(filePath2a->getPath()))
+          .split(tableScan2Id, makeHiveConnectorSplit(filePath2b->getPath()))
+          .copyResults(pool());
+
+  ASSERT_EQ(result->size(), 8);
+
+  // Validate result content and row order.
+  // MixedUnion preserves row order: data1a, data1b, data2a, data2b.
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 5, 6, 3, 4, 7, 8}),
+  });
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+/// Test union with null values in data.
+TEST_F(MixedUnionWithTableScanTest, unionWithNullValues) {
+  auto data1 = makeRowVector({
+      makeNullableFlatVector<int64_t>({1, std::nullopt, 3}),
+      makeNullableFlatVector<StringView>({"a", "b", std::nullopt}),
+  });
+  auto data2 = makeRowVector({
+      makeNullableFlatVector<int64_t>({std::nullopt, 5, 6}),
+      makeNullableFlatVector<StringView>({std::nullopt, "e", "f"}),
+  });
+
+  auto filePath1 = TempFilePath::create();
+  auto filePath2 = TempFilePath::create();
+  writeToFile(filePath1->getPath(), data1);
+  writeToFile(filePath2->getPath(), data2);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto rowType = asRowType(data1->type());
+
+  core::PlanNodeId tableScan1Id;
+  auto source1 = PlanBuilder(planNodeIdGenerator)
+                     .tableScan(rowType)
+                     .capturePlanNodeId(tableScan1Id)
+                     .planNode();
+
+  core::PlanNodeId tableScan2Id;
+  auto source2 = PlanBuilder(planNodeIdGenerator)
+                     .tableScan(rowType)
+                     .capturePlanNodeId(tableScan2Id)
+                     .planNode();
+
+  auto unionNode = makeMixedUnionNode({source1, source2}, planNodeIdGenerator);
+
+  auto result =
+      AssertQueryBuilder(unionNode)
+          .split(tableScan1Id, makeHiveConnectorSplit(filePath1->getPath()))
+          .split(tableScan2Id, makeHiveConnectorSplit(filePath2->getPath()))
+          .copyResults(pool());
+
+  ASSERT_EQ(result->size(), 6);
+
+  // Validate result content and row order, including nulls.
+  auto expected = makeRowVector({
+      makeNullableFlatVector<int64_t>({1, std::nullopt, 3, std::nullopt, 5, 6}),
+      makeNullableFlatVector<StringView>(
+          {"a", "b", std::nullopt, std::nullopt, "e", "f"}),
+  });
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+/// Test union with various data types.
+TEST_F(MixedUnionWithTableScanTest, unionWithVariousTypes) {
+  auto data1 = makeRowVector({
+      makeFlatVector<int64_t>({1, 2}),
+      makeFlatVector<double>({1.1, 2.2}),
+      makeFlatVector<bool>({true, false}),
+      makeFlatVector<StringView>({"hello", "world"}),
+  });
+  auto data2 = makeRowVector({
+      makeFlatVector<int64_t>({3, 4}),
+      makeFlatVector<double>({3.3, 4.4}),
+      makeFlatVector<bool>({false, true}),
+      makeFlatVector<StringView>({"foo", "bar"}),
+  });
+
+  auto filePath1 = TempFilePath::create();
+  auto filePath2 = TempFilePath::create();
+  writeToFile(filePath1->getPath(), data1);
+  writeToFile(filePath2->getPath(), data2);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto rowType = asRowType(data1->type());
+
+  core::PlanNodeId tableScan1Id;
+  auto source1 = PlanBuilder(planNodeIdGenerator)
+                     .tableScan(rowType)
+                     .capturePlanNodeId(tableScan1Id)
+                     .planNode();
+
+  core::PlanNodeId tableScan2Id;
+  auto source2 = PlanBuilder(planNodeIdGenerator)
+                     .tableScan(rowType)
+                     .capturePlanNodeId(tableScan2Id)
+                     .planNode();
+
+  auto unionNode = makeMixedUnionNode({source1, source2}, planNodeIdGenerator);
+
+  auto result =
+      AssertQueryBuilder(unionNode)
+          .split(tableScan1Id, makeHiveConnectorSplit(filePath1->getPath()))
+          .split(tableScan2Id, makeHiveConnectorSplit(filePath2->getPath()))
+          .copyResults(pool());
+
+  ASSERT_EQ(result->size(), 4);
+
+  // Validate result content and row order.
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4}),
+      makeFlatVector<double>({1.1, 2.2, 3.3, 4.4}),
+      makeFlatVector<bool>({true, false, false, true}),
+      makeFlatVector<StringView>({"hello", "world", "foo", "bar"}),
+  });
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+/// Test union with unequal source sizes.
+TEST_F(MixedUnionWithTableScanTest, unionWithUnequalSourceSizes) {
+  auto data1 = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+  });
+  auto data2 = makeRowVector({
+      makeFlatVector<int64_t>({6, 7}),
+  });
+  auto data3 = makeRowVector({
+      makeFlatVector<int64_t>({8, 9, 10, 11, 12, 13, 14}),
+  });
+
+  auto filePath1 = TempFilePath::create();
+  auto filePath2 = TempFilePath::create();
+  auto filePath3 = TempFilePath::create();
+  writeToFile(filePath1->getPath(), data1);
+  writeToFile(filePath2->getPath(), data2);
+  writeToFile(filePath3->getPath(), data3);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto rowType = asRowType(data1->type());
+
+  core::PlanNodeId tableScan1Id;
+  auto source1 = PlanBuilder(planNodeIdGenerator)
+                     .tableScan(rowType)
+                     .capturePlanNodeId(tableScan1Id)
+                     .planNode();
+
+  core::PlanNodeId tableScan2Id;
+  auto source2 = PlanBuilder(planNodeIdGenerator)
+                     .tableScan(rowType)
+                     .capturePlanNodeId(tableScan2Id)
+                     .planNode();
+
+  core::PlanNodeId tableScan3Id;
+  auto source3 = PlanBuilder(planNodeIdGenerator)
+                     .tableScan(rowType)
+                     .capturePlanNodeId(tableScan3Id)
+                     .planNode();
+
+  auto unionNode =
+      makeMixedUnionNode({source1, source2, source3}, planNodeIdGenerator);
+
+  auto result =
+      AssertQueryBuilder(unionNode)
+          .split(tableScan1Id, makeHiveConnectorSplit(filePath1->getPath()))
+          .split(tableScan2Id, makeHiveConnectorSplit(filePath2->getPath()))
+          .split(tableScan3Id, makeHiveConnectorSplit(filePath3->getPath()))
+          .copyResults(pool());
+
+  ASSERT_EQ(result->size(), 14);
+
+  // Validate result content and row order.
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}),
+  });
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+/// Test union with large data volume.
+TEST_F(MixedUnionWithTableScanTest, unionWithLargeDataVolume) {
+  constexpr int kRowsPerSource = 1000;
+  constexpr int kNumSources = 3;
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  std::vector<std::shared_ptr<TempFilePath>> filePaths;
+  std::vector<core::PlanNodePtr> sources;
+  std::vector<core::PlanNodeId> tableScanIds;
+
+  auto rowType = ROW({"c0", "c1"}, {BIGINT(), DOUBLE()});
+
+  for (int s = 0; s < kNumSources; ++s) {
+    auto data = makeRowVector({
+        makeFlatVector<int64_t>(
+            kRowsPerSource, [s](auto row) { return s * 10000 + row; }),
+        makeFlatVector<double>(
+            kRowsPerSource, [](auto row) { return row * 0.1; }),
+    });
+
+    auto filePath = TempFilePath::create();
+    writeToFile(filePath->getPath(), data);
+    filePaths.push_back(filePath);
+
+    core::PlanNodeId tableScanId;
+    auto source = PlanBuilder(planNodeIdGenerator)
+                      .tableScan(rowType)
+                      .capturePlanNodeId(tableScanId)
+                      .planNode();
+    sources.push_back(source);
+    tableScanIds.push_back(tableScanId);
+  }
+
+  auto unionNode = makeMixedUnionNode(std::move(sources), planNodeIdGenerator);
+
+  auto queryBuilder = AssertQueryBuilder(unionNode);
+  for (int i = 0; i < kNumSources; ++i) {
+    queryBuilder.split(
+        tableScanIds[i], makeHiveConnectorSplit(filePaths[i]->getPath()));
+  }
+
+  auto result = queryBuilder.copyResults(pool());
+  ASSERT_EQ(result->size(), kRowsPerSource * kNumSources);
+
+  // Validate result content and row order.
+  // MixedUnion preserves row order: source 0 rows, then source 1 rows, etc.
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>(
+          kRowsPerSource * kNumSources,
+          [](auto row) {
+            int source = row / 1000;
+            int rowInSource = row % 1000;
+            return source * 10000 + rowInSource;
+          }),
+      makeFlatVector<double>(
+          kRowsPerSource * kNumSources,
+          [](auto row) {
+            int rowInSource = row % 1000;
+            return rowInSource * 0.1;
+          }),
+  });
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
diff --git a/velox/exec/tests/MultiFragmentTest.cpp b/velox/exec/tests/MultiFragmentTest.cpp
index f58cab54e27..2606802afea 100644
--- a/velox/exec/tests/MultiFragmentTest.cpp
+++ b/velox/exec/tests/MultiFragmentTest.cpp
@@ -13,8 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "folly/experimental/EventCount.h"
+#include "folly/synchronization/EventCount.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
@@ -30,7 +31,6 @@
 #include "velox/exec/tests/utils/LocalExchangeSource.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/exec/tests/utils/SerializedPageUtil.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 using namespace facebook::velox::exec::test;
 
@@ -38,15 +38,14 @@ using facebook::velox::common::testutil::TestValue;
 using facebook::velox::test::BatchMaker;
 
 namespace facebook::velox::exec {
+using namespace facebook::velox::common::testutil;
 namespace {
 
 struct TestParam {
-  VectorSerde::Kind serdeKind;
+  std::string serdeKind;
   common::CompressionKind compressionKind;
 
-  TestParam(
-      VectorSerde::Kind _serdeKind,
-      common::CompressionKind _compressionKind)
+  TestParam(std::string _serdeKind, common::CompressionKind _compressionKind)
       : serdeKind(_serdeKind), compressionKind(_compressionKind) {}
 };
 
@@ -55,18 +54,12 @@ class MultiFragmentTest : public HiveConnectorTestBase,
  public:
   static std::vector<TestParam> getTestParams() {
     std::vector<TestParam> params;
-    params.emplace_back(
-        VectorSerde::Kind::kPresto, common::CompressionKind_NONE);
-    params.emplace_back(
-        VectorSerde::Kind::kCompactRow, common::CompressionKind_NONE);
-    params.emplace_back(
-        VectorSerde::Kind::kUnsafeRow, common::CompressionKind_NONE);
-    params.emplace_back(
-        VectorSerde::Kind::kPresto, common::CompressionKind_LZ4);
-    params.emplace_back(
-        VectorSerde::Kind::kCompactRow, common::CompressionKind_LZ4);
-    params.emplace_back(
-        VectorSerde::Kind::kUnsafeRow, common::CompressionKind_LZ4);
+    params.emplace_back("Presto", common::CompressionKind_NONE);
+    params.emplace_back("CompactRow", common::CompressionKind_NONE);
+    params.emplace_back("UnsafeRow", common::CompressionKind_NONE);
+    params.emplace_back("Presto", common::CompressionKind_LZ4);
+    params.emplace_back("CompactRow", common::CompressionKind_LZ4);
+    params.emplace_back("UnsafeRow", common::CompressionKind_LZ4);
     return params;
   }
 
@@ -109,8 +102,9 @@ class MultiFragmentTest : public HiveConnectorTestBase,
     auto queryCtx = core::QueryCtx::create(
         executor ? executor : executor_.get(),
         core::QueryConfig(std::move(configCopy)));
-    queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-        queryCtx->queryId(), maxMemory, MemoryReclaimer::create()));
+    queryCtx->testingOverrideMemoryPool(
+        memory::memoryManager()->addRootPool(
+            queryCtx->queryId(), maxMemory, MemoryReclaimer::create()));
     core::PlanFragment planFragment{planNode};
     return Task::create(
         taskId,
@@ -127,7 +121,9 @@ class MultiFragmentTest : public HiveConnectorTestBase,
       std::unordered_map<std::string, std::string>& extraQueryConfigs,
       int destination = 0,
       Consumer consumer = nullptr,
-      int64_t maxMemory = memory::kMaxMemory) const {
+      int64_t maxMemory = memory::kMaxMemory,
+      const std::optional<common::SpillDiskOptions>& diskSpillOpts =
+          std::nullopt) const {
     auto configCopy = configSettings_;
     for (const auto& [k, v] : extraQueryConfigs) {
       configCopy[k] = v;
@@ -139,8 +135,9 @@ class MultiFragmentTest : public HiveConnectorTestBase,
         nullptr,
         nullptr,
         executor_.get());
-    queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-        queryCtx->queryId(), maxMemory, MemoryReclaimer::create()));
+    queryCtx->testingOverrideMemoryPool(
+        memory::memoryManager()->addRootPool(
+            queryCtx->queryId(), maxMemory, MemoryReclaimer::create()));
     core::PlanFragment planFragment{planNode};
     return Task::create(
         taskId,
@@ -148,7 +145,9 @@ class MultiFragmentTest : public HiveConnectorTestBase,
         destination,
         std::move(queryCtx),
         Task::ExecutionMode::kParallel,
-        std::move(consumer));
+        std::move(consumer),
+        /*memoryArbitrationPriority=*/0,
+        diskSpillOpts);
   }
 
   std::vector<RowVectorPtr> makeVectors(int count, int rowsPerVector) {
@@ -252,7 +251,7 @@ class MultiFragmentTest : public HiveConnectorTestBase,
         exchangeStats.at("localExchangeSource.numPages").count);
     ASSERT_EQ(
         expectedBackgroundCpuCount,
-        exchangeStats.at(ExchangeClient::kBackgroundCpuTimeMs).count);
+        exchangeStats.at(std::string(Operator::kBackgroundCpuTimeNanos)).count);
     ASSERT_EQ(
         expectedBackgroundCpuCount, taskStats.at("0").backgroundTiming.count);
   }
@@ -376,23 +375,27 @@ TEST_P(MultiFragmentTest, aggregationSingleKey) {
   auto leafPlanStats = toPlanStats(leafTask->taskStats());
   const auto serdeKindRuntimsStats =
       leafPlanStats.at(partitionNodeId)
-          .customStats.at(Operator::kShuffleSerdeKind);
+          .customStats.at(std::string(Operator::kShuffleSerdeKind));
   ASSERT_EQ(serdeKindRuntimsStats.count, 4);
   ASSERT_EQ(
-      serdeKindRuntimsStats.min, static_cast<int64_t>(GetParam().serdeKind));
+      serdeKindRuntimsStats.min,
+      static_cast<int64_t>(VectorSerde::kindByName(GetParam().serdeKind)));
   ASSERT_EQ(
-      serdeKindRuntimsStats.max, static_cast<int64_t>(GetParam().serdeKind));
+      serdeKindRuntimsStats.max,
+      static_cast<int64_t>(VectorSerde::kindByName(GetParam().serdeKind)));
 
   for (const auto& finalTask : finalTasks) {
     auto finalPlanStats = toPlanStats(finalTask->taskStats());
     const auto serdeKindRuntimsStats =
         finalPlanStats.at(exchangeNodeId)
-            .customStats.at(Operator::kShuffleSerdeKind);
+            .customStats.at(std::string(Operator::kShuffleSerdeKind));
     ASSERT_EQ(serdeKindRuntimsStats.count, 1);
     ASSERT_EQ(
-        serdeKindRuntimsStats.min, static_cast<int64_t>(GetParam().serdeKind));
+        serdeKindRuntimsStats.min,
+        static_cast<int64_t>(VectorSerde::kindByName(GetParam().serdeKind)));
     ASSERT_EQ(
-        serdeKindRuntimsStats.max, static_cast<int64_t>(GetParam().serdeKind));
+        serdeKindRuntimsStats.max,
+        static_cast<int64_t>(VectorSerde::kindByName(GetParam().serdeKind)));
   }
 }
 
@@ -675,13 +678,15 @@ TEST_P(MultiFragmentTest, mergeExchange) {
   EXPECT_LT(0, mergeExchangeStats.inputBytes);
   EXPECT_LT(0, mergeExchangeStats.rawInputBytes);
 
-  const auto serdeKindRuntimsStats =
-      mergeExchangeStats.customStats.at(Operator::kShuffleSerdeKind);
+  const auto serdeKindRuntimsStats = mergeExchangeStats.customStats.at(
+      std::string(Operator::kShuffleSerdeKind));
   ASSERT_EQ(serdeKindRuntimsStats.count, 1);
   ASSERT_EQ(
-      serdeKindRuntimsStats.min, static_cast<int64_t>(GetParam().serdeKind));
+      serdeKindRuntimsStats.min,
+      static_cast<int64_t>(VectorSerde::kindByName(GetParam().serdeKind)));
   ASSERT_EQ(
-      serdeKindRuntimsStats.max, static_cast<int64_t>(GetParam().serdeKind));
+      serdeKindRuntimsStats.max,
+      static_cast<int64_t>(VectorSerde::kindByName(GetParam().serdeKind)));
 }
 
 // Test reordering and dropping columns in PartitionedOutput operator.
@@ -917,11 +922,17 @@ TEST_P(MultiFragmentTest, mergeExchangeWithSpill) {
             .capturePlanNodeId(partitionNodeId)
             .planNode();
     localMergeNodeIds.push_back(localMergeNodeId);
-    auto sortTask =
-        makeTask(sortTaskId, partialSortPlan, spillMergeConfigs, tasks.size());
     spillDirectories.push_back(TempDirectoryPath::create());
-    sortTask->setSpillDirectory(
-        spillDirectories[numPartialSortTasks]->getPath());
+    common::SpillDiskOptions spillOpts;
+    spillOpts.spillDirPath = spillDirectories[numPartialSortTasks]->getPath();
+    auto sortTask = makeTask(
+        sortTaskId,
+        partialSortPlan,
+        spillMergeConfigs,
+        tasks.size(),
+        /*consumer=*/nullptr,
+        memory::kMaxMemory,
+        spillOpts);
     tasks.push_back(sortTask);
     sortTask->start(4);
 
@@ -986,13 +997,15 @@ TEST_P(MultiFragmentTest, mergeExchangeWithSpill) {
   EXPECT_LT(0, mergeExchangeStats.inputBytes);
   EXPECT_LT(0, mergeExchangeStats.rawInputBytes);
 
-  const auto serdeKindRuntimsStats =
-      mergeExchangeStats.customStats.at(Operator::kShuffleSerdeKind);
+  const auto serdeKindRuntimsStats = mergeExchangeStats.customStats.at(
+      std::string(Operator::kShuffleSerdeKind));
   ASSERT_EQ(serdeKindRuntimsStats.count, 1);
   ASSERT_EQ(
-      serdeKindRuntimsStats.min, static_cast<int64_t>(GetParam().serdeKind));
+      serdeKindRuntimsStats.min,
+      static_cast<int64_t>(VectorSerde::kindByName(GetParam().serdeKind)));
   ASSERT_EQ(
-      serdeKindRuntimsStats.max, static_cast<int64_t>(GetParam().serdeKind));
+      serdeKindRuntimsStats.max,
+      static_cast<int64_t>(VectorSerde::kindByName(GetParam().serdeKind)));
 }
 
 TEST_P(MultiFragmentTest, noHashPartitionSkew) {
@@ -1665,7 +1678,7 @@ namespace {
 core::PlanNodePtr makeJoinOverExchangePlan(
     const RowTypePtr& exchangeType,
     const RowVectorPtr& buildData,
-    VectorSerde::Kind serdeKind) {
+    std::string serdeKind) {
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   return PlanBuilder(planNodeIdGenerator)
       .exchange(exchangeType, serdeKind)
@@ -2083,14 +2096,14 @@ class TestCustomExchangeNode : public core::PlanNode {
   TestCustomExchangeNode(
       const core::PlanNodeId& id,
       const RowTypePtr type,
-      VectorSerde::Kind serdeKind)
+      std::string serdeKind)
       : PlanNode(id), outputType_(type), serdeKind_(serdeKind) {}
 
   const RowTypePtr& outputType() const override {
     return outputType_;
   }
 
-  VectorSerde::Kind serdeKind() const {
+  const std::string& serdeKind() const {
     return serdeKind_;
   }
 
@@ -2117,7 +2130,7 @@ class TestCustomExchangeNode : public core::PlanNode {
   }
 
   const RowTypePtr outputType_;
-  const VectorSerde::Kind serdeKind_;
+  const std::string serdeKind_;
 };
 
 class TestCustomExchange : public exec::Exchange {
@@ -2204,12 +2217,15 @@ TEST_P(MultiFragmentTest, customPlanNodeWithExchangeClient) {
 
   auto planStats = toPlanStats(leafTask->taskStats());
   const auto serdeKindRuntimsStats =
-      planStats.at(partitionNodeId).customStats.at(Operator::kShuffleSerdeKind);
+      planStats.at(partitionNodeId)
+          .customStats.at(std::string(Operator::kShuffleSerdeKind));
   ASSERT_EQ(serdeKindRuntimsStats.count, 1);
   ASSERT_EQ(
-      serdeKindRuntimsStats.min, static_cast<int64_t>(GetParam().serdeKind));
+      serdeKindRuntimsStats.min,
+      static_cast<int64_t>(VectorSerde::kindByName(GetParam().serdeKind)));
   ASSERT_EQ(
-      serdeKindRuntimsStats.max, static_cast<int64_t>(GetParam().serdeKind));
+      serdeKindRuntimsStats.max,
+      static_cast<int64_t>(VectorSerde::kindByName(GetParam().serdeKind)));
 }
 
 // This test is to reproduce the race condition between task terminate and no
@@ -2902,12 +2918,12 @@ TEST_P(MultiFragmentTest, mergeSmallBatchesInExchange) {
     ASSERT_EQ(numPages, stats.customStats.at("numReceivedPages").sum);
   };
 
-  if (GetParam().serdeKind == VectorSerde::Kind::kPresto) {
+  if (GetParam().serdeKind == "Presto") {
     test(1, 1'000);
     test(1'000, 56);
-    test(10'000, 6);
-    test(100'000, 1);
-  } else if (GetParam().serdeKind == VectorSerde::Kind::kCompactRow) {
+    test(10'000, 7);
+    test(100'000, 2);
+  } else if (GetParam().serdeKind == "CompactRow") {
     test(1, 1'000);
     test(1'000, 39);
     test(10'000, 5);
@@ -2915,13 +2931,13 @@ TEST_P(MultiFragmentTest, mergeSmallBatchesInExchange) {
   } else {
     test(1, 1'000);
     test(1'000, 72);
-    test(10'000, 7);
-    test(100'000, 1);
+    test(10'000, 8);
+    test(100'000, 2);
   }
 }
 
 TEST_P(MultiFragmentTest, splitLargeCompactRowsInExchange) {
-  if (GetParam().serdeKind != VectorSerde::Kind::kCompactRow) {
+  if (GetParam().serdeKind != "CompactRow") {
     return;
   }
   const uint64_t kNumColumns = 100;
@@ -2947,14 +2963,13 @@ TEST_P(MultiFragmentTest, splitLargeCompactRowsInExchange) {
                               {"c0"},
                               kNumPartitions,
                               /*outputLayout=*/{},
-                              VectorSerde::Kind::kCompactRow)
+                              "CompactRow")
                           .planNode();
   const auto producerTaskId = "local://t1";
 
-  auto plan =
-      test::PlanBuilder()
-          .exchange(asRowType(data->type()), VectorSerde::Kind::kCompactRow)
-          .planNode();
+  auto plan = test::PlanBuilder()
+                  .exchange(asRowType(data->type()), "CompactRow")
+                  .planNode();
 
   auto expected = makeRowVector(columns);
 
@@ -3036,33 +3051,41 @@ TEST_P(MultiFragmentTest, compression) {
     auto consumerTaskStats = exec::toPlanStats(consumerTask->taskStats());
     const auto& consumerPlanStats = consumerTaskStats.at("0");
     ASSERT_EQ(
-        consumerPlanStats.customStats.at(Operator::kShuffleCompressionKind).min,
+        consumerPlanStats.customStats
+            .at(std::string(Operator::kShuffleCompressionKind))
+            .min,
         static_cast<common::CompressionKind>(GetParam().compressionKind));
     ASSERT_EQ(
-        consumerPlanStats.customStats.at(Operator::kShuffleCompressionKind).max,
+        consumerPlanStats.customStats
+            .at(std::string(Operator::kShuffleCompressionKind))
+            .max,
         static_cast<common::CompressionKind>(GetParam().compressionKind));
     ASSERT_EQ(data->size() * kNumRepeats, consumerPlanStats.outputRows);
 
     auto producerTaskStats = exec::toPlanStats(producerTask->taskStats());
     const auto& producerStats = producerTaskStats.at("1");
     ASSERT_EQ(
-        producerStats.customStats.at(Operator::kShuffleCompressionKind).min,
+        producerStats.customStats
+            .at(std::string(Operator::kShuffleCompressionKind))
+            .min,
         static_cast<common::CompressionKind>(GetParam().compressionKind));
     ASSERT_EQ(
-        producerStats.customStats.at(Operator::kShuffleCompressionKind).max,
+        producerStats.customStats
+            .at(std::string(Operator::kShuffleCompressionKind))
+            .max,
         static_cast<common::CompressionKind>(GetParam().compressionKind));
     if (GetParam().compressionKind == common::CompressionKind_NONE) {
       ASSERT_EQ(
           producerStats.customStats.count(
-              IterativeVectorSerializer::kCompressedBytes),
+              std::string(IterativeVectorSerializer::kCompressedBytes)),
           0);
       ASSERT_EQ(
           producerStats.customStats.count(
-              IterativeVectorSerializer::kCompressionInputBytes),
+              std::string(IterativeVectorSerializer::kCompressionInputBytes)),
           0);
       ASSERT_EQ(
           producerStats.customStats.count(
-              IterativeVectorSerializer::kCompressionSkippedBytes),
+              std::string(IterativeVectorSerializer::kCompressionSkippedBytes)),
           0);
       return;
     }
@@ -3070,18 +3093,22 @@ TEST_P(MultiFragmentTest, compression) {
     if (!expectSkipCompression) {
       ASSERT_LT(
           producerStats.customStats
-              .at(IterativeVectorSerializer::kCompressedBytes)
+              .at(std::string(IterativeVectorSerializer::kCompressedBytes))
               .sum,
           producerStats.customStats
-              .at(IterativeVectorSerializer::kCompressionInputBytes)
+              .at(std::string(
+                  IterativeVectorSerializer::kCompressionInputBytes))
               .sum);
       ASSERT_EQ(producerStats.customStats.count("compressionSkippedBytes"), 0);
     } else {
-      ASSERT_LT(
-          0,
-          producerStats.customStats
-              .at(IterativeVectorSerializer::kCompressionSkippedBytes)
-              .sum);
+      // Note: With the crash fix for PartitionedOutput, the serializer is
+      // recreated after each flush, which resets the compression skip counter.
+      // This means compression is always attempted, so we verify compression
+      // stats exist rather than checking for skipped bytes.
+      ASSERT_GT(
+          producerStats.customStats.count(
+              std::string(IterativeVectorSerializer::kCompressionInputBytes)),
+          0);
     }
   };
 
@@ -3093,10 +3120,68 @@ TEST_P(MultiFragmentTest, compression) {
       test("local://t1", 0.7, false);
     }
     SCOPED_TRACE(fmt::format("minCompressionRatio 0.0000001"));
-    { test("local://t2", 0.0000001, true); }
+    {
+      test("local://t2", 0.0000001, true);
+    }
   }
 }
 
+TEST_P(MultiFragmentTest, compressionPageSizeSkip) {
+  if (GetParam().compressionKind == common::CompressionKind_NONE) {
+    GTEST_SKIP() << "Page size skip only applies with compression enabled";
+  }
+  if (GetParam().serdeKind != "Presto") {
+    GTEST_SKIP()
+        << "Page size skip only implemented in PrestoIterativeVectorSerializer";
+  }
+
+  const auto data = makeRowVector({makeFlatVector<int64_t>({1, 2, 3})});
+
+  const auto producerPlan =
+      test::PlanBuilder()
+          .values({data})
+          .partitionedOutput({}, 1, /*outputLayout=*/{}, GetParam().serdeKind)
+          .planNode();
+
+  const auto plan = test::PlanBuilder()
+                        .exchange(asRowType(data->type()), GetParam().serdeKind)
+                        .singleAggregation({}, {"sum(c0)"})
+                        .planNode();
+
+  const auto expected =
+      makeRowVector({makeFlatVector<int64_t>(std::vector<int64_t>{6})});
+
+  std::unordered_map<std::string, std::string> producerConfig;
+  producerConfig[core::QueryConfig::kShuffleCompressionKind] =
+      common::compressionKindToString(GetParam().compressionKind);
+  producerConfig[core::QueryConfig::kMinShuffleCompressionPageSizeBytes] =
+      std::to_string(1 << 30);
+
+  auto producerTask =
+      makeTask("local://pageSizeSkip", producerPlan, producerConfig);
+  producerTask->start(1);
+
+  auto consumerTask =
+      test::AssertQueryBuilder(plan)
+          .split(remoteSplit("local://pageSizeSkip"))
+          .config(
+              core::QueryConfig::kShuffleCompressionKind,
+              common::compressionKindToString(GetParam().compressionKind))
+          .destination(0)
+          .assertResults(expected);
+
+  auto producerTaskStats = exec::toPlanStats(producerTask->taskStats());
+  const auto& producerStats = producerTaskStats.at("1");
+  ASSERT_GT(
+      producerStats.customStats.count(
+          std::string(IterativeVectorSerializer::kCompressionSkippedBytes)),
+      0);
+  ASSERT_EQ(
+      producerStats.customStats.count(
+          std::string(IterativeVectorSerializer::kCompressionInputBytes)),
+      0);
+}
+
 TEST_P(MultiFragmentTest, scaledTableScan) {
   const int numSplits = 20;
   std::vector<std::shared_ptr<TempFilePath>> splitFiles;
@@ -3195,34 +3280,189 @@ TEST_P(MultiFragmentTest, scaledTableScan) {
     if (testData.scaleEnabled) {
       ASSERT_EQ(
           planStats.at(scanNodeId)
-              .customStats.count(TableScan::kNumRunningScaleThreads),
+              .customStats.count(
+                  std::string(TableScan::kNumRunningScaleThreads)),
           1);
       if (testData.expectScaleUp) {
         ASSERT_GE(
             planStats.at(scanNodeId)
-                .customStats[TableScan::kNumRunningScaleThreads]
+                .customStats[std::string(TableScan::kNumRunningScaleThreads)]
                 .sum,
             1);
         ASSERT_LE(
             planStats.at(scanNodeId)
-                .customStats[TableScan::kNumRunningScaleThreads]
+                .customStats[std::string(TableScan::kNumRunningScaleThreads)]
                 .sum,
             numLeafDrivers);
       } else {
         ASSERT_EQ(
             planStats.at(scanNodeId)
-                .customStats.count(TableScan::kNumRunningScaleThreads),
+                .customStats.count(
+                    std::string(TableScan::kNumRunningScaleThreads)),
             1);
       }
     } else {
       ASSERT_EQ(
           planStats.at(scanNodeId)
-              .customStats.count(TableScan::kNumRunningScaleThreads),
+              .customStats.count(
+                  std::string(TableScan::kNumRunningScaleThreads)),
           0);
     }
   }
 }
 
+// Test row output with no columns (empty schema).
+TEST_P(MultiFragmentTest, emptySchema) {
+  // Create data with rows but no columns
+  auto emptyRowType = ROW({}, {});
+  auto data = makeRowVector(emptyRowType, 1'000);
+
+  std::vector<std::shared_ptr<Task>> tasks;
+  auto leafTaskId = makeTaskId("leaf", 0);
+
+  // Leaf task: Values -> PartitionedOutput
+  auto leafPlan =
+      PlanBuilder()
+          .values({data})
+          .partitionedOutput({}, 1, /*outputLayout=*/{}, GetParam().serdeKind)
+          .planNode();
+
+  auto leafTask = makeTask(leafTaskId, leafPlan, tasks.size());
+  tasks.push_back(leafTask);
+  leafTask->start(4);
+
+  // Root task: Exchange -> Project
+  auto rootTaskId = makeTaskId("root", 0);
+  auto rootPlan = PlanBuilder()
+                      .exchange(emptyRowType, GetParam().serdeKind)
+                      .singleAggregation({}, {"count(1)"})
+                      .planNode();
+
+  test::AssertQueryBuilder(rootPlan, duckDbQueryRunner_)
+      .split(remoteSplit(leafTaskId))
+      .config(
+          core::QueryConfig::kShuffleCompressionKind,
+          common::compressionKindToString(GetParam().compressionKind))
+      .assertResults("SELECT 1000");
+
+  for (auto& task : tasks) {
+    ASSERT_TRUE(waitForTaskCompletion(task.get())) << task->taskId();
+  }
+}
+
+// Test stateful deserialization with different batch byte limits.
+// This validates that the Exchange operator correctly breaks in the middle
+// and continues from the leftover when batch size limits are reached.
+TEST_P(MultiFragmentTest, batchBytes) {
+  auto test = [&](int32_t numBatches,
+                  int32_t rowsPerBatch,
+                  uint64_t preferredBatchBytes,
+                  uint64_t expectedAtLeastOutputBatches = 0) {
+    SCOPED_TRACE(
+        fmt::format(
+            "numBatches={}, rowsPerBatch={}, preferredBatchBytes={}",
+            numBatches,
+            rowsPerBatch,
+            succinctBytes(preferredBatchBytes)));
+
+    std::vector<RowVectorPtr> batches;
+    batches.reserve(numBatches);
+
+    for (int i = 0; i < numBatches; ++i) {
+      auto batch = makeRowVector({
+          makeFlatVector<int64_t>(
+              rowsPerBatch,
+              [i, rowsPerBatch](auto row) { return i * rowsPerBatch + row; }),
+          makeFlatVector<int32_t>(
+              rowsPerBatch,
+              [i, rowsPerBatch](auto row) {
+                return (i * rowsPerBatch + row) % 1000;
+              }),
+          makeFlatVector<double>(
+              rowsPerBatch,
+              [i, rowsPerBatch](auto row) {
+                return (i * rowsPerBatch + row) * 1.5;
+              }),
+      });
+      batches.push_back(batch);
+    }
+
+    auto leafTaskId = makeTaskId("leaf", 0);
+    auto leafPlan =
+        PlanBuilder()
+            .values(batches)
+            .partitionedOutput({}, 1, {"c0", "c1", "c2"}, GetParam().serdeKind)
+            .planNode();
+
+    auto leafTask = makeTask(leafTaskId, leafPlan, 0);
+    leafTask->start(1);
+
+    core::PlanNodeId exchangeNodeId;
+    auto rootPlan =
+        PlanBuilder()
+            .exchange(
+                ROW({"c0", "c1", "c2"}, {BIGINT(), INTEGER(), DOUBLE()}),
+                GetParam().serdeKind)
+            .capturePlanNodeId(exchangeNodeId)
+            .singleAggregation({}, {"count(1)", "sum(c0)", "avg(c2)"})
+            .planNode();
+
+    auto extraConfigs = std::unordered_map<std::string, std::string>{
+        {core::QueryConfig::kPreferredOutputBatchBytes,
+         std::to_string(preferredBatchBytes)},
+        {core::QueryConfig::kShuffleCompressionKind,
+         common::compressionKindToString(GetParam().compressionKind)}};
+
+    auto task = test::AssertQueryBuilder(rootPlan, duckDbQueryRunner_)
+                    .split(remoteSplit(leafTaskId))
+                    .configs(extraConfigs)
+                    .assertResults(
+                        fmt::format(
+                            "SELECT {}, {}, {}",
+                            numBatches * rowsPerBatch,
+                            (static_cast<int64_t>(numBatches) * rowsPerBatch *
+                             (numBatches * rowsPerBatch - 1)) /
+                                2,
+                            (static_cast<int64_t>(numBatches) * rowsPerBatch *
+                             (numBatches * rowsPerBatch - 1)) /
+                                2 * 1.5 / (numBatches * rowsPerBatch)));
+
+    waitForTaskCompletion(leafTask.get());
+
+    // Verify Exchange stats to ensure data was processed correctly
+    auto rootTaskStats = toPlanStats(task->taskStats());
+    const auto& exchangeStats = rootTaskStats.at(exchangeNodeId);
+
+    EXPECT_GE(exchangeStats.outputVectors, expectedAtLeastOutputBatches);
+  };
+
+  // Presto serialization operates at page-level granularity (pages are atomic).
+  // The number of output batches depends on how many Presto pages are created
+  // during serialization, which varies based on encoding, compression, and
+  // data.
+  //
+  // For this test (100 input batches × 100 rows = 10,000 rows):
+  // The actual behavior shows all pages are merged and processed together,
+  // resulting in a single batch output currently.
+  //
+  // This is a known limitation - Presto pages cannot be partially deserialized.
+  // The fix prevents INT32_MAX overflow by controlling the merge size, but
+  // fine-grained batch control requires deeper changes to PrestoVectorSerde.
+
+  if (GetParam().serdeKind == "Presto") {
+    // Current implementation merges all pages and processes in one batch
+    // The key improvement is preventing overflow, not fine-grained batching
+    test(100, 100, 1, 1); // Expect single batch with all data
+    test(100, 100, 1ULL << 30, 1); // Expect single batch with all data
+  } else {
+    // Row-based serialization (CompactRow/UnsafeRow) supports row-level
+    // batching With 1 byte limit: Can produce many small batches
+    test(100, 100, 1, 100);
+    // With 1GB limit: All rows fit in one batch
+    test(100, 100, 1ULL << 30, 1);
+  }
+}
+
 VELOX_INSTANTIATE_TEST_SUITE_P(
     MultiFragmentTest,
     MultiFragmentTest,
@@ -3230,7 +3470,7 @@ VELOX_INSTANTIATE_TEST_SUITE_P(
     [](const testing::TestParamInfo<TestParam>& info) {
       return fmt::format(
           "{}_{}",
-          VectorSerde::kindName(info.param.serdeKind),
+          info.param.serdeKind,
           compressionKindToString(info.param.compressionKind));
     });
 } // namespace
diff --git a/velox/exec/tests/NestedLoopJoinTest.cpp b/velox/exec/tests/NestedLoopJoinTest.cpp
index 611b67cb13a..4baec4a8c43 100644
--- a/velox/exec/tests/NestedLoopJoinTest.cpp
+++ b/velox/exec/tests/NestedLoopJoinTest.cpp
@@ -100,11 +100,12 @@ class NestedLoopJoinTest : public HiveConnectorTestBase {
 
     for (const auto joinType : joinTypes_) {
       for (const auto& comparison : comparisons_) {
-        SCOPED_TRACE(fmt::format(
-            "maxDrivers:{} joinType:{} comparison:{}",
-            std::to_string(numDrivers),
-            core::JoinTypeName::toName(joinType),
-            comparison));
+        SCOPED_TRACE(
+            fmt::format(
+                "maxDrivers:{} joinType:{} comparison:{}",
+                std::to_string(numDrivers),
+                core::JoinTypeName::toName(joinType),
+                comparison));
 
         params.planNode =
             PlanBuilder(planNodeIdGenerator)
diff --git a/velox/exec/tests/OperatorTraceTest.cpp b/velox/exec/tests/OperatorTraceTest.cpp
index 968fcbb6c2b..6ded9826b5d 100644
--- a/velox/exec/tests/OperatorTraceTest.cpp
+++ b/velox/exec/tests/OperatorTraceTest.cpp
@@ -21,24 +21,28 @@
 
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/exec/OperatorTraceReader.h"
 #include "velox/exec/PartitionFunction.h"
 #include "velox/exec/Split.h"
 #include "velox/exec/TaskTraceReader.h"
 #include "velox/exec/TaskTraceWriter.h"
-#include "velox/exec/Trace.h"
-#include "velox/exec/TraceUtil.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/exec/trace/Trace.h"
+#include "velox/exec/trace/TraceUtil.h"
 #include "velox/serializers/PrestoSerializer.h"
 
-using namespace facebook::velox::exec::test;
-
 namespace facebook::velox::exec::trace::test {
-class OperatorTraceTest : public HiveConnectorTestBase {
+namespace {
+using namespace facebook::velox::common::testutil;
+using exec::test::assertEqualResults;
+using exec::test::AssertQueryBuilder;
+using exec::test::PlanBuilder;
+
+class OperatorTraceTest : public exec::test::HiveConnectorTestBase {
  protected:
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
@@ -106,6 +110,13 @@ class OperatorTraceTest : public HiveConnectorTestBase {
     return std::make_unique<DriverCtx>(nullptr, 0, 0, 0, 0);
   }
 
+  std::string getTaskTraceDirectory(
+      const std::string& traceDir,
+      const Task& task) {
+    return trace::getTaskTraceDirectory(
+        traceDir, task.queryCtx()->queryId(), task.taskId());
+  }
+
   RowTypePtr dataType_;
   VectorFuzzer vectorFuzzer_;
 };
@@ -299,16 +310,17 @@ TEST_F(OperatorTraceTest, traceMetadata) {
       executor_.get(),
       core::QueryConfig(expectedQueryConfigs),
       expectedConnectorProperties);
-  auto writer = trace::TaskTraceMetadataWriter(outputDir->getPath(), pool());
-  auto traceNode = getTraceNode(planNode, traceNodeId);
-  writer.write(queryCtx, traceNode);
+  auto writer =
+      trace::TaskTraceMetadataWriter(outputDir->getPath(), traceNodeId, pool());
+  writer.write(*queryCtx, *planNode);
   const auto reader =
       trace::TaskTraceMetadataReader(outputDir->getPath(), pool());
   const auto actualQueryConfigs = reader.queryConfigs();
   const auto actualConnectorProperties = reader.connectorProperties();
   const auto actualQueryPlan = reader.queryPlan();
 
-  ASSERT_TRUE(isSamePlan(actualQueryPlan, traceNode));
+  auto expectedTraceNode = getTraceNode(*planNode, traceNodeId);
+  ASSERT_TRUE(isSamePlan(actualQueryPlan, expectedTraceNode));
   ASSERT_EQ(actualQueryConfigs.size(), expectedQueryConfigs.size());
   for (const auto& [key, value] : actualQueryConfigs) {
     ASSERT_EQ(actualQueryConfigs.at(key), expectedQueryConfigs.at(key));
@@ -424,7 +436,7 @@ TEST_F(OperatorTraceTest, task) {
     const auto actualQueryPlan = reader.queryPlan();
 
     ASSERT_TRUE(
-        isSamePlan(actualQueryPlan, getTraceNode(planNode, hashJoinNodeId)));
+        isSamePlan(actualQueryPlan, getTraceNode(*planNode, hashJoinNodeId)));
     ASSERT_EQ(actualQueryConfigs.size(), expectedQueryConfigs.size());
     for (const auto& [key, value] : actualQueryConfigs) {
       ASSERT_EQ(actualQueryConfigs.at(key), expectedQueryConfigs.at(key));
@@ -445,7 +457,8 @@ TEST_F(OperatorTraceTest, task) {
 }
 
 TEST_F(OperatorTraceTest, error) {
-  const auto planNode = PlanBuilder().values({}).planNode();
+  const auto planNode =
+      PlanBuilder().values(std::vector<RowVectorPtr>{}).planNode();
   // No trace dir.
   {
     const auto queryConfigs = std::unordered_map<std::string, std::string>{
@@ -505,8 +518,7 @@ TEST_F(OperatorTraceTest, error) {
             .queryCtx(queryCtx)
             .maxDrivers(1)
             .copyResults(pool()),
-
-        "Trace plan node ID = nonexist not found from task");
+        "Trace plan node ID = 'nonexist' not found from task");
   }
 }
 
@@ -846,12 +858,12 @@ TEST_F(OperatorTraceTest, traceSplitPartial) {
   auto ioBuf = folly::IOBuf::create(12 + 16);
   folly::io::Appender appender(ioBuf.get(), 0);
   // Writes an invalid split without crc.
-  appender.writeLE(length);
+  appender.writeLE<uint32_t>(length);
   appender.push(reinterpret_cast<const uint8_t*>(split.data()), length);
   // Writes a valid spilt.
-  appender.writeLE(length);
+  appender.writeLE<uint32_t>(length);
   appender.push(reinterpret_cast<const uint8_t*>(split.data()), length);
-  appender.writeLE(crc32);
+  appender.writeLE<uint32_t>(crc32);
   splitInfoFile->append(std::move(ioBuf));
   splitInfoFile->close();
 
@@ -935,13 +947,13 @@ TEST_F(OperatorTraceTest, traceSplitCorrupted) {
   auto ioBuf = folly::IOBuf::create(16 * 2);
   folly::io::Appender appender(ioBuf.get(), 0);
   // Writes an invalid split with a wrong checksum.
-  appender.writeLE(length);
+  appender.writeLE<uint32_t>(length);
   appender.push(reinterpret_cast<const uint8_t*>(split.data()), length);
-  appender.writeLE(crc32 - 1);
+  appender.writeLE<uint32_t>(crc32 - 1);
   // Writes a valid split.
-  appender.writeLE(length);
+  appender.writeLE<uint32_t>(length);
   appender.push(reinterpret_cast<const uint8_t*>(split.data()), length);
-  appender.writeLE(crc32);
+  appender.writeLE<uint32_t>(crc32);
   splitInfoFile->append(std::move(ioBuf));
   splitInfoFile->close();
 
@@ -1124,12 +1136,15 @@ TEST_F(OperatorTraceTest, canTrace) {
       {"IndexLookupJoin", true},
       {"Unnest", true},
       {"RowNumber", false},
-      {"OrderBy", false},
+      {"OrderBy", true},
+      {"TopNRowNumber", true},
       {"PartialAggregation", true},
       {"Aggregation", true},
       {"TableWrite", true},
       {"TableScan", true},
-      {"FilterProject", true}};
+      {"FilterProject", true},
+      {"Exchange", true},
+      {"MergeExchange", true}};
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
     ASSERT_EQ(testData.canTrace, trace::canTrace(testData.operatorType));
@@ -1162,10 +1177,12 @@ TEST_F(OperatorTraceTest, hiveConnectorId) {
       .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
       .config(core::QueryConfig::kQueryTraceNodeId, "0")
       .splits(splits)
-      .runWithoutResults(task);
+      .countResults(task);
   const auto taskTraceDir =
       getTaskTraceDirectory(traceDirPath->getPath(), *task);
   const auto reader = trace::TaskTraceMetadataReader(taskTraceDir, pool());
   ASSERT_EQ("test-hive", reader.connectorId("0"));
 }
+
+} // namespace
 } // namespace facebook::velox::exec::trace::test
diff --git a/velox/exec/tests/OperatorUtilsTest.cpp b/velox/exec/tests/OperatorUtilsTest.cpp
index 45da6804d67..937823afd6e 100644
--- a/velox/exec/tests/OperatorUtilsTest.cpp
+++ b/velox/exec/tests/OperatorUtilsTest.cpp
@@ -15,8 +15,10 @@
  */
 #include "velox/exec/OperatorUtils.h"
 #include <gtest/gtest.h>
+#include <string_view>
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/exec/Operator.h"
+#include "velox/exec/tests/utils/MergeTestBase.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
@@ -48,7 +50,8 @@ class OperatorUtilsTest : public OperatorTestBase {
         std::move(planFragment),
         0,
         core::QueryCtx::create(executor_.get()),
-        Task::ExecutionMode::kParallel);
+        Task::ExecutionMode::kParallel,
+        exec::Consumer{});
     driver_ = Driver::testingCreate();
     driverCtx_ = std::make_unique<DriverCtx>(task_, 0, 0, 0, 0);
     driverCtx_->driver = driver_.get();
@@ -57,7 +60,8 @@ class OperatorUtilsTest : public OperatorTestBase {
   void gatherCopyTest(
       const std::shared_ptr<const RowType>& targetType,
       const std::shared_ptr<const RowType>& sourceType,
-      int numSources) {
+      int numSources,
+      bool flattenSources = true) {
     folly::Random::DefaultGenerator rng(1);
     const int kNumRows = 500;
     const int kNumColumns = sourceType->size();
@@ -65,8 +69,9 @@ class OperatorUtilsTest : public OperatorTestBase {
     // Build source vectors with nulls.
     std::vector<RowVectorPtr> sources;
     for (int i = 0; i < numSources; ++i) {
-      sources.push_back(std::static_pointer_cast<RowVector>(
-          BatchMaker::createBatch(sourceType, kNumRows, *pool_)));
+      sources.push_back(
+          std::static_pointer_cast<RowVector>(
+              BatchMaker::createBatch(sourceType, kNumRows, *pool_)));
       for (int j = 0; j < kNumColumns; ++j) {
         auto vector = sources.back()->childAt(j);
         int nullRow = (folly::Random::rand32() % kNumRows) / 4;
@@ -78,6 +83,23 @@ class OperatorUtilsTest : public OperatorTestBase {
       }
     }
 
+    if (!flattenSources) {
+      for (int i = 0; i < numSources; ++i) {
+        const auto source = sources[i];
+        const auto numRows = source->size();
+        std::vector<vector_size_t> sortIndices(numRows, 0);
+        for (auto i = 0; i < numRows; ++i) {
+          sortIndices[i] = i;
+        }
+        BufferPtr indices = allocateIndices(numRows, pool_.get());
+        auto rawIndices = indices->asMutable<vector_size_t>();
+        for (size_t i = 0; i < numRows; ++i) {
+          rawIndices[i] = sortIndices[i];
+        }
+        sources[i] = wrap(numRows, indices, source);
+      }
+    }
+
     std::vector<IdentityProjection> columnMap;
     if (sourceType != targetType) {
       for (column_index_t sourceChannel = 0; sourceChannel < kNumColumns;
@@ -133,6 +155,61 @@ class OperatorUtilsTest : public OperatorTestBase {
     }
   }
 
+  void gatherMergeTest(
+      int32_t numValues,
+      int numMergeWays,
+      int targetSize,
+      bool useRandom) {
+    auto goldenVector = makeRowVector({
+        makeFlatVector<int32_t>(numValues, [&](auto row) { return row; }),
+    });
+    std::vector<std::vector<int32_t>> mergeWays(numMergeWays);
+    for (int32_t value = 0; value < numValues; value++) {
+      int way = useRandom ? folly::Random::rand32() % numMergeWays
+                          : value % numMergeWays;
+      mergeWays[way].push_back(value);
+    }
+    std::vector<RowVectorPtr> sources;
+    std::vector<std::unique_ptr<SpillMergeStream>> streams;
+    std::vector<SpillSortKey> sortKeys = {{0, {true, true}}};
+    for (int way = 0; way < numMergeWays; way++) {
+      auto source = makeRowVector({
+          makeFlatVector<int32_t>(
+              mergeWays[way].size(),
+              [&](auto row) { return mergeWays[way][row]; }),
+      });
+      sources.push_back(source);
+      streams.push_back(
+          std::make_unique<TestingSpillMergeStream>(way, sortKeys, source));
+    }
+    auto mergeTree =
+        std::make_unique<TreeOfLosers<SpillMergeStream>>(std::move(streams));
+    RowVectorPtr targetVector = std::static_pointer_cast<RowVector>(
+        BaseVector::create(sources[0]->type(), targetSize, pool_.get()));
+    std::vector<const RowVector*> bufferSources(targetSize);
+    std::vector<vector_size_t> bufferSourceIndices(targetSize);
+    for (int32_t batch = 0; batch * targetSize < numValues; batch++) {
+      int32_t valueBegin = batch * targetSize;
+      int32_t valueEnd = valueBegin + targetSize;
+      valueEnd = std::min(valueEnd, numValues);
+      VectorPtr tmp = std::move(targetVector);
+      BaseVector::prepareForReuse(tmp, targetSize);
+      targetVector = std::static_pointer_cast<RowVector>(tmp);
+      for (auto& child : targetVector->children()) {
+        child->resize(targetSize);
+      }
+      int count = 0;
+      testingGatherMerge(
+          targetVector, *mergeTree, count, bufferSources, bufferSourceIndices);
+      EXPECT_EQ(count, valueEnd - valueBegin);
+      auto result = targetVector->childAt(0).get();
+      auto golden = goldenVector->childAt(0).get();
+      for (int32_t row = 0; row < valueEnd - valueBegin; row++) {
+        EXPECT_TRUE(result->equalValueAt(golden, row, valueBegin + row));
+      }
+    }
+  }
+
   void setTaskOutputBatchConfig(
       uint32_t preferredBatchSize,
       uint32_t maxRows,
@@ -373,6 +450,67 @@ TEST_F(OperatorUtilsTest, gatherCopy) {
   }
 }
 
+TEST_F(OperatorUtilsTest, gatherCopyEncoding) {
+  std::shared_ptr<const RowType> rowType;
+  std::shared_ptr<const RowType> reversedRowType;
+  {
+    std::vector<std::string> names = {
+        "bool_val",
+        "tiny_val",
+        "small_val",
+        "int_val",
+        "long_val",
+        "ordinal",
+        "float_val",
+        "double_val",
+        "string_val",
+        "array_val",
+        "struct_val",
+        "map_val"};
+    std::vector<std::string> reversedNames = names;
+    std::reverse(reversedNames.begin(), reversedNames.end());
+
+    std::vector<std::shared_ptr<const Type>> types = {
+        BOOLEAN(),
+        TINYINT(),
+        SMALLINT(),
+        INTEGER(),
+        BIGINT(),
+        BIGINT(),
+        REAL(),
+        DOUBLE(),
+        VARCHAR(),
+        ARRAY(VARCHAR()),
+        ROW({{"s_int", INTEGER()}, {"s_array", ARRAY(REAL())}}),
+        MAP(VARCHAR(),
+            MAP(BIGINT(),
+                ROW({{"s2_int", INTEGER()}, {"s2_string", VARCHAR()}})))};
+    std::vector<std::shared_ptr<const Type>> reversedTypes = types;
+    std::reverse(reversedTypes.begin(), reversedTypes.end());
+
+    rowType = ROW(std::move(names), std::move(types));
+    reversedRowType = ROW(std::move(reversedNames), std::move(reversedTypes));
+  }
+
+  // Gather copy with identical column mapping.
+  gatherCopyTest(rowType, rowType, 1, false);
+  gatherCopyTest(rowType, rowType, 5, false);
+  // Gather copy with non-identical column mapping.
+  gatherCopyTest(rowType, reversedRowType, 1, false);
+  gatherCopyTest(rowType, reversedRowType, 5, false);
+}
+
+TEST_F(OperatorUtilsTest, gatherMerge) {
+  gatherMergeTest(1234, 2, 10, false);
+  gatherMergeTest(1234, 2, 100, false);
+  gatherMergeTest(1234, 10, 10, false);
+  gatherMergeTest(1234, 10, 100, false);
+  gatherMergeTest(1234, 2, 10, true);
+  gatherMergeTest(1234, 2, 100, true);
+  gatherMergeTest(1234, 10, 10, true);
+  gatherMergeTest(1234, 10, 100, true);
+}
+
 TEST_F(OperatorUtilsTest, makeOperatorSpillPath) {
   EXPECT_EQ("spill/3_1_100", makeOperatorSpillPath("spill", 3, 1, 100));
 }
@@ -426,56 +564,56 @@ TEST_F(OperatorUtilsTest, wrap) {
 
 TEST_F(OperatorUtilsTest, addOperatorRuntimeStats) {
   std::unordered_map<std::string, RuntimeMetric> stats;
-  const std::string statsName("stats");
+  constexpr std::string_view statsName{"stats"};
   const RuntimeCounter minStatsValue(100, RuntimeCounter::Unit::kBytes);
   const RuntimeCounter maxStatsValue(200, RuntimeCounter::Unit::kBytes);
   addOperatorRuntimeStats(statsName, minStatsValue, stats);
-  ASSERT_EQ(stats[statsName].count, 1);
-  ASSERT_EQ(stats[statsName].sum, 100);
-  ASSERT_EQ(stats[statsName].max, 100);
-  ASSERT_EQ(stats[statsName].min, 100);
+  ASSERT_EQ(stats[std::string(statsName)].count, 1);
+  ASSERT_EQ(stats[std::string(statsName)].sum, 100);
+  ASSERT_EQ(stats[std::string(statsName)].max, 100);
+  ASSERT_EQ(stats[std::string(statsName)].min, 100);
 
   addOperatorRuntimeStats(statsName, maxStatsValue, stats);
-  ASSERT_EQ(stats[statsName].count, 2);
-  ASSERT_EQ(stats[statsName].sum, 300);
-  ASSERT_EQ(stats[statsName].max, 200);
-  ASSERT_EQ(stats[statsName].min, 100);
+  ASSERT_EQ(stats[std::string(statsName)].count, 2);
+  ASSERT_EQ(stats[std::string(statsName)].sum, 300);
+  ASSERT_EQ(stats[std::string(statsName)].max, 200);
+  ASSERT_EQ(stats[std::string(statsName)].min, 100);
 
   addOperatorRuntimeStats(statsName, maxStatsValue, stats);
-  ASSERT_EQ(stats[statsName].count, 3);
-  ASSERT_EQ(stats[statsName].sum, 500);
-  ASSERT_EQ(stats[statsName].max, 200);
-  ASSERT_EQ(stats[statsName].min, 100);
+  ASSERT_EQ(stats[std::string(statsName)].count, 3);
+  ASSERT_EQ(stats[std::string(statsName)].sum, 500);
+  ASSERT_EQ(stats[std::string(statsName)].max, 200);
+  ASSERT_EQ(stats[std::string(statsName)].min, 100);
 }
 
 TEST_F(OperatorUtilsTest, setOperatorRuntimeStats) {
   std::unordered_map<std::string, RuntimeMetric> stats;
-  const std::string statsName("stats");
+  constexpr std::string_view statsName{"stats"};
   const RuntimeCounter minStatsValue(100, RuntimeCounter::Unit::kBytes);
   const RuntimeCounter maxStatsValue(200, RuntimeCounter::Unit::kBytes);
   setOperatorRuntimeStats(statsName, minStatsValue, stats);
-  ASSERT_EQ(stats[statsName].count, 1);
-  ASSERT_EQ(stats[statsName].sum, 100);
-  ASSERT_EQ(stats[statsName].max, 100);
-  ASSERT_EQ(stats[statsName].min, 100);
+  ASSERT_EQ(stats[std::string(statsName)].count, 1);
+  ASSERT_EQ(stats[std::string(statsName)].sum, 100);
+  ASSERT_EQ(stats[std::string(statsName)].max, 100);
+  ASSERT_EQ(stats[std::string(statsName)].min, 100);
 
   setOperatorRuntimeStats(statsName, maxStatsValue, stats);
-  ASSERT_EQ(stats[statsName].count, 1);
-  ASSERT_EQ(stats[statsName].sum, 200);
-  ASSERT_EQ(stats[statsName].max, 200);
-  ASSERT_EQ(stats[statsName].min, 200);
+  ASSERT_EQ(stats[std::string(statsName)].count, 1);
+  ASSERT_EQ(stats[std::string(statsName)].sum, 200);
+  ASSERT_EQ(stats[std::string(statsName)].max, 200);
+  ASSERT_EQ(stats[std::string(statsName)].min, 200);
 
   addOperatorRuntimeStats(statsName, maxStatsValue, stats);
-  ASSERT_EQ(stats[statsName].count, 2);
-  ASSERT_EQ(stats[statsName].sum, 400);
-  ASSERT_EQ(stats[statsName].max, 200);
-  ASSERT_EQ(stats[statsName].min, 200);
+  ASSERT_EQ(stats[std::string(statsName)].count, 2);
+  ASSERT_EQ(stats[std::string(statsName)].sum, 400);
+  ASSERT_EQ(stats[std::string(statsName)].max, 200);
+  ASSERT_EQ(stats[std::string(statsName)].min, 200);
 
   setOperatorRuntimeStats(statsName, minStatsValue, stats);
-  ASSERT_EQ(stats[statsName].count, 1);
-  ASSERT_EQ(stats[statsName].sum, 100);
-  ASSERT_EQ(stats[statsName].max, 100);
-  ASSERT_EQ(stats[statsName].min, 100);
+  ASSERT_EQ(stats[std::string(statsName)].count, 1);
+  ASSERT_EQ(stats[std::string(statsName)].sum, 100);
+  ASSERT_EQ(stats[std::string(statsName)].max, 100);
+  ASSERT_EQ(stats[std::string(statsName)].min, 100);
 }
 
 TEST_F(OperatorUtilsTest, initializeRowNumberMapping) {
diff --git a/velox/exec/tests/OrderByTest.cpp b/velox/exec/tests/OrderByTest.cpp
index c343dbe8020..685660511a3 100644
--- a/velox/exec/tests/OrderByTest.cpp
+++ b/velox/exec/tests/OrderByTest.cpp
@@ -16,10 +16,11 @@
 #include <re2/re2.h>
 
 #include <fmt/format.h>
-#include "folly/experimental/EventCount.h"
+#include "folly/synchronization/EventCount.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/memory/tests/SharedArbitratorTestUtil.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/core/QueryConfig.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
@@ -30,7 +31,6 @@
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/exec/tests/utils/QueryAssertions.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
 using namespace facebook::velox;
@@ -42,8 +42,8 @@ using namespace facebook::velox::exec::test;
 namespace facebook::velox::exec::test {
 namespace {
 // Returns aggregated spilled stats by 'task'.
-common::SpillStats spilledStats(const exec::Task& task) {
-  common::SpillStats spilledStats;
+exec::SpillStats spilledStats(const exec::Task& task) {
+  exec::SpillStats spilledStats;
   auto stats = task.taskStats();
   for (auto& pipeline : stats.pipelineStats) {
     for (auto op : pipeline.operatorStats) {
@@ -194,7 +194,7 @@ class OrderByTest : public OperatorTestBase {
     }
     {
       SCOPED_TRACE("run with spilling");
-      auto spillDirectory = exec::test::TempDirectoryPath::create();
+      auto spillDirectory = TempDirectoryPath::create();
       auto queryCtx = core::QueryCtx::create(executor_.get());
       TestScopedSpillInjection scopedSpillInjection(100);
       queryCtx->testingOverrideConfigUnsafe({
@@ -495,7 +495,7 @@ TEST_F(OrderByTest, spill) {
 
   const auto expectedResult = AssertQueryBuilder(plan).copyResults(pool_.get());
 
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
   TestScopedSpillInjection scopedSpillInjection(100);
   auto task = AssertQueryBuilder(plan)
                   .spillDirectory(spillDirectory->getPath())
@@ -510,20 +510,29 @@ TEST_F(OrderByTest, spill) {
   ASSERT_GT(planStats.spilledInputBytes, 0);
   ASSERT_EQ(planStats.spilledPartitions, 1);
   ASSERT_GT(planStats.spilledFiles, 0);
-  ASSERT_GT(planStats.customStats[Operator::kSpillRuns].count, 0);
-  ASSERT_GT(planStats.customStats[Operator::kSpillFillTime].sum, 0);
-  ASSERT_GT(planStats.customStats[Operator::kSpillSortTime].sum, 0);
-  ASSERT_GT(planStats.customStats[Operator::kSpillExtractVectorTime].sum, 0);
-  ASSERT_GT(planStats.customStats[Operator::kSpillSerializationTime].sum, 0);
-  ASSERT_GT(planStats.customStats[Operator::kSpillFlushTime].sum, 0);
+  ASSERT_GT(planStats.customStats[std::string(Operator::kSpillRuns)].count, 0);
+  ASSERT_GT(
+      planStats.customStats[std::string(Operator::kSpillFillTime)].sum, 0);
+  ASSERT_GT(
+      planStats.customStats[std::string(Operator::kSpillSortTime)].sum, 0);
+  ASSERT_GT(
+      planStats.customStats[std::string(Operator::kSpillExtractVectorTime)].sum,
+      0);
+  ASSERT_GT(
+      planStats.customStats[std::string(Operator::kSpillSerializationTime)].sum,
+      0);
+  ASSERT_GT(
+      planStats.customStats[std::string(Operator::kSpillFlushTime)].sum, 0);
   ASSERT_EQ(
-      planStats.customStats[Operator::kSpillSerializationTime].count,
-      planStats.customStats[Operator::kSpillFlushTime].count);
-  ASSERT_GT(planStats.customStats[Operator::kSpillWrites].sum, 0);
-  ASSERT_GT(planStats.customStats[Operator::kSpillWriteTime].sum, 0);
+      planStats.customStats[std::string(Operator::kSpillSerializationTime)]
+          .count,
+      planStats.customStats[std::string(Operator::kSpillFlushTime)].count);
+  ASSERT_GT(planStats.customStats[std::string(Operator::kSpillWrites)].sum, 0);
+  ASSERT_GT(
+      planStats.customStats[std::string(Operator::kSpillWriteTime)].sum, 0);
   ASSERT_EQ(
-      planStats.customStats[Operator::kSpillWrites].count,
-      planStats.customStats[Operator::kSpillWriteTime].count);
+      planStats.customStats[std::string(Operator::kSpillWrites)].count,
+      planStats.customStats[std::string(Operator::kSpillWriteTime)].count);
   OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
 }
 
@@ -556,10 +565,11 @@ DEBUG_ONLY_TEST_F(OrderByTest, reclaimDuringInputProcessing) {
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
 
-    auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto spillDirectory = TempDirectoryPath::create();
     auto queryCtx = core::QueryCtx::create(executor_.get());
-    queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-        queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
+    queryCtx->testingOverrideMemoryPool(
+        memory::memoryManager()->addRootPool(
+            queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
     auto expectedResult =
         AssertQueryBuilder(
             PlanBuilder()
@@ -698,10 +708,11 @@ DEBUG_ONLY_TEST_F(OrderByTest, reclaimDuringReserve) {
     batches.push_back(fuzzer.fuzzRow(rowType));
   }
 
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
   auto queryCtx = core::QueryCtx::create(executor_.get());
-  queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-      queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
+  queryCtx->testingOverrideMemoryPool(
+      memory::memoryManager()->addRootPool(
+          queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
   auto expectedResult =
       AssertQueryBuilder(
           PlanBuilder()
@@ -814,7 +825,7 @@ DEBUG_ONLY_TEST_F(OrderByTest, reclaimDuringAllocation) {
   const std::vector<bool> enableSpillings = {false, true};
   for (const auto enableSpilling : enableSpillings) {
     SCOPED_TRACE(fmt::format("enableSpilling {}", enableSpilling));
-    auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto spillDirectory = TempDirectoryPath::create();
     auto queryCtx = core::QueryCtx::create(executor_.get());
     queryCtx->testingOverrideMemoryPool(
         memory::memoryManager()->addRootPool(queryCtx->queryId(), kMaxBytes));
@@ -944,10 +955,11 @@ DEBUG_ONLY_TEST_F(OrderByTest, reclaimDuringOutputProcessing) {
   const std::vector<bool> enableSpillings = {false, true};
   for (const auto enableSpilling : enableSpillings) {
     SCOPED_TRACE(fmt::format("enableSpilling {}", enableSpilling));
-    auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto spillDirectory = TempDirectoryPath::create();
     auto queryCtx = core::QueryCtx::create(executor_.get());
-    queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-        queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
+    queryCtx->testingOverrideMemoryPool(
+        memory::memoryManager()->addRootPool(
+            queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
     auto expectedResult =
         AssertQueryBuilder(
             PlanBuilder()
@@ -1226,7 +1238,7 @@ DEBUG_ONLY_TEST_F(OrderByTest, spillWithNoMoreOutput) {
         ASSERT_EQ(reclaimerStats_.reclaimedBytes, 0);
       })));
 
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
   auto task =
       AssertQueryBuilder(plan)
           .spillDirectory(spillDirectory->getPath())
@@ -1259,7 +1271,7 @@ TEST_F(OrderByTest, maxSpillBytes) {
           .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
           .capturePlanNodeId(orderNodeId)
           .planNode();
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
   auto queryCtx = core::QueryCtx::create(executor_.get());
 
   struct {
@@ -1312,18 +1324,19 @@ DEBUG_ONLY_TEST_F(OrderByTest, reclaimFromOrderBy) {
         memory::testingRunArbitration();
       })));
 
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  const auto spillDirectory = TempDirectoryPath::create();
   core::PlanNodeId orderById;
   auto task =
       AssertQueryBuilder(duckDbQueryRunner_)
           .spillDirectory(spillDirectory->getPath())
           .config(core::QueryConfig::kSpillEnabled, true)
           .config(core::QueryConfig::kOrderBySpillEnabled, true)
-          .plan(PlanBuilder()
-                    .values(vectors)
-                    .orderBy({"c0 ASC NULLS LAST"}, false)
-                    .capturePlanNodeId(orderById)
-                    .planNode())
+          .plan(
+              PlanBuilder()
+                  .values(vectors)
+                  .orderBy({"c0 ASC NULLS LAST"}, false)
+                  .capturePlanNodeId(orderById)
+                  .planNode())
           .assertResults("SELECT * FROM tmp ORDER BY c0 ASC NULLS LAST");
   auto taskStats = exec::toPlanStats(task->taskStats());
   auto& planStats = taskStats.at(orderById);
@@ -1351,16 +1364,17 @@ DEBUG_ONLY_TEST_F(OrderByTest, reclaimFromEmptyOrderBy) {
         testingRunArbitration(op->pool());
       })));
 
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  const auto spillDirectory = TempDirectoryPath::create();
   auto task =
       AssertQueryBuilder(duckDbQueryRunner_)
           .spillDirectory(spillDirectory->getPath())
           .config(core::QueryConfig::kSpillEnabled, true)
           .config(core::QueryConfig::kOrderBySpillEnabled, true)
-          .plan(PlanBuilder()
-                    .values(vectors)
-                    .orderBy({"c0 ASC NULLS LAST"}, false)
-                    .planNode())
+          .plan(
+              PlanBuilder()
+                  .values(vectors)
+                  .orderBy({"c0 ASC NULLS LAST"}, false)
+                  .planNode())
           .assertResults("SELECT * FROM tmp ORDER BY c0 ASC NULLS LAST");
   // Verify no spill has been triggered.
   const auto stats = task->taskStats().pipelineStats;
@@ -1376,8 +1390,9 @@ DEBUG_ONLY_TEST_F(OrderByTest, orderByWithLazyInput) {
       VectorFuzzer(fuzzerOpts_, pool()).fuzzRowChildrenToLazy(nonLazyVector));
 
   std::vector<RowVectorPtr> lazyInputCopy;
-  lazyInputCopy.push_back(std::dynamic_pointer_cast<RowVector>(
-      nonLazyVector->testingCopyPreserveEncodings()));
+  lazyInputCopy.push_back(
+      std::dynamic_pointer_cast<RowVector>(
+          nonLazyVector->testingCopyPreserveEncodings()));
   createDuckDbTable(lazyInputCopy);
 
   std::atomic_bool nonReclaimableSectionEntered{false};
@@ -1398,16 +1413,17 @@ DEBUG_ONLY_TEST_F(OrderByTest, orderByWithLazyInput) {
         }
       })));
 
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  const auto spillDirectory = TempDirectoryPath::create();
   auto task =
       AssertQueryBuilder(duckDbQueryRunner_)
           .spillDirectory(spillDirectory->getPath())
           .config(core::QueryConfig::kSpillEnabled, true)
           .config(core::QueryConfig::kOrderBySpillEnabled, true)
-          .plan(PlanBuilder()
-                    .values(lazyInput)
-                    .orderBy({"c0 ASC NULLS LAST"}, false)
-                    .planNode())
+          .plan(
+              PlanBuilder()
+                  .values(lazyInput)
+                  .orderBy({"c0 ASC NULLS LAST"}, false)
+                  .planNode())
           .assertResults("SELECT * FROM tmp ORDER BY c0 ASC NULLS LAST");
 
   ASSERT_TRUE(lazyLoadedInNonReclaimableSection.has_value());
diff --git a/velox/exec/tests/OutputBufferManagerTest.cpp b/velox/exec/tests/OutputBufferManagerTest.cpp
index f72957c9281..8855b4332b9 100644
--- a/velox/exec/tests/OutputBufferManagerTest.cpp
+++ b/velox/exec/tests/OutputBufferManagerTest.cpp
@@ -14,8 +14,9 @@
  * limitations under the License.
  */
 #include "velox/exec/OutputBufferManager.h"
+#include <folly/system/HardwareConcurrency.h>
 #include <gtest/gtest.h>
-#include "folly/experimental/EventCount.h"
+#include "folly/synchronization/EventCount.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/exec/Task.h"
@@ -33,23 +34,25 @@ using facebook::velox::test::BatchMaker;
 
 struct TestParam {
   PartitionedOutputNode::Kind outputKind;
-  VectorSerde::Kind serdeKind;
+  std::string serdeKind;
 
-  TestParam(
-      PartitionedOutputNode::Kind _outputKind,
-      VectorSerde::Kind _serdeKind)
+  TestParam(PartitionedOutputNode::Kind _outputKind, std::string _serdeKind)
       : outputKind(_outputKind), serdeKind(_serdeKind) {}
 };
 
+inline void PrintTo(const TestParam& param, std::ostream* os) {
+  *os << fmt::format("{}_{}", param.outputKind, param.serdeKind);
+}
+
 class OutputBufferManagerTest : public testing::Test {
  protected:
-  OutputBufferManagerTest() : serdeKind_(VectorSerde::Kind::kPresto) {
+  OutputBufferManagerTest() : serdeKind_("Presto") {
     std::vector<std::string> names = {"c0", "c1"};
     std::vector<TypePtr> types = {BIGINT(), VARCHAR()};
     rowType_ = ROW(std::move(names), std::move(types));
   }
 
-  explicit OutputBufferManagerTest(VectorSerde::Kind serdeKind)
+  explicit OutputBufferManagerTest(std::string serdeKind)
       : serdeKind_(serdeKind) {
     std::vector<std::string> names = {"c0", "c1"};
     std::vector<TypePtr> types = {BIGINT(), VARCHAR()};
@@ -71,14 +74,14 @@ class OutputBufferManagerTest : public testing::Test {
             serializer::presto::PrestoOutputStreamListener>();
       });
     }
-    if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kPresto)) {
+    if (!isRegisteredNamedVectorSerde("Presto")) {
       facebook::velox::serializer::presto::PrestoVectorSerde::
           registerNamedVectorSerde();
     }
-    if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kCompactRow)) {
+    if (!isRegisteredNamedVectorSerde("CompactRow")) {
       serializer::CompactRowVectorSerde::registerNamedVectorSerde();
     }
-    if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kUnsafeRow)) {
+    if (!isRegisteredNamedVectorSerde("UnsafeRow")) {
       serializer::spark::UnsafeRowVectorSerde::registerNamedVectorSerde();
     }
   }
@@ -109,13 +112,14 @@ class OutputBufferManagerTest : public testing::Test {
         std::move(planFragment),
         0,
         std::move(queryCtx),
-        Task::ExecutionMode::kParallel);
+        Task::ExecutionMode::kParallel,
+        exec::Consumer{});
 
     bufferManager_->initializeTask(task, kind, numDestinations, numDrivers);
     return task;
   }
 
-  std::unique_ptr<SerializedPage> makeSerializedPage(
+  std::unique_ptr<SerializedPageBase> makeSerializedPage(
       RowTypePtr rowType,
       vector_size_t size) {
     auto vector = std::dynamic_pointer_cast<RowVector>(
@@ -375,8 +379,9 @@ class OutputBufferManagerTest : public testing::Test {
               std::vector<std::unique_ptr<folly::IOBuf>> pages,
               int64_t inSequence,
               std::vector<int64_t> remainingBytes) {
-            promise.setValue(Response{
-                std::move(pages), inSequence, std::move(remainingBytes)});
+            promise.setValue(
+                Response{
+                    std::move(pages), inSequence, std::move(remainingBytes)});
           });
       future.wait();
       ASSERT_TRUE(future.isReady());
@@ -432,10 +437,10 @@ class OutputBufferManagerTest : public testing::Test {
     }
   }
 
-  const VectorSerde::Kind serdeKind_;
+  const std::string serdeKind_;
   std::shared_ptr<folly::Executor> executor_{
       std::make_shared<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency())};
+          folly::available_concurrency())};
   std::shared_ptr<facebook::velox::memory::MemoryPool> pool_;
   std::shared_ptr<OutputBufferManager> bufferManager_;
   RowTypePtr rowType_;
@@ -443,13 +448,11 @@ class OutputBufferManagerTest : public testing::Test {
 
 class OutputBufferManagerWithDifferentSerdeKindsTest
     : public OutputBufferManagerTest,
-      public testing::WithParamInterface<VectorSerde::Kind> {
+      public testing::WithParamInterface<std::string> {
  public:
-  static std::vector<VectorSerde::Kind> getTestParams() {
-    static std::vector<VectorSerde::Kind> params = {
-        VectorSerde::Kind::kPresto,
-        VectorSerde::Kind::kCompactRow,
-        VectorSerde::Kind::kUnsafeRow};
+  static std::vector<std::string> getTestParams() {
+    static std::vector<std::string> params = {
+        "Presto", "CompactRow", "UnsafeRow"};
     return params;
   }
 };
@@ -460,21 +463,15 @@ class AllOutputBufferManagerTest
  public:
   static std::vector<TestParam> getTestParams() {
     static std::vector<TestParam> params = {
-        {PartitionedOutputNode::Kind::kBroadcast, VectorSerde::Kind::kPresto},
-        {PartitionedOutputNode::Kind::kBroadcast,
-         VectorSerde::Kind::kCompactRow},
-        {PartitionedOutputNode::Kind::kBroadcast,
-         VectorSerde::Kind::kUnsafeRow},
-        {PartitionedOutputNode::Kind::kPartitioned, VectorSerde::Kind::kPresto},
-        {PartitionedOutputNode::Kind::kPartitioned,
-         VectorSerde::Kind::kCompactRow},
-        {PartitionedOutputNode::Kind::kPartitioned,
-         VectorSerde::Kind::kUnsafeRow},
-        {PartitionedOutputNode::Kind::kArbitrary, VectorSerde::Kind::kPresto},
-        {PartitionedOutputNode::Kind::kArbitrary,
-         VectorSerde::Kind::kCompactRow},
-        {PartitionedOutputNode::Kind::kArbitrary,
-         VectorSerde::Kind::kUnsafeRow}};
+        {PartitionedOutputNode::Kind::kBroadcast, "Presto"},
+        {PartitionedOutputNode::Kind::kBroadcast, "CompactRow"},
+        {PartitionedOutputNode::Kind::kBroadcast, "UnsafeRow"},
+        {PartitionedOutputNode::Kind::kPartitioned, "Presto"},
+        {PartitionedOutputNode::Kind::kPartitioned, "CompactRow"},
+        {PartitionedOutputNode::Kind::kPartitioned, "UnsafeRow"},
+        {PartitionedOutputNode::Kind::kArbitrary, "Presto"},
+        {PartitionedOutputNode::Kind::kArbitrary, "CompactRow"},
+        {PartitionedOutputNode::Kind::kArbitrary, "UnsafeRow"}};
     return params;
   }
 
@@ -1470,7 +1467,7 @@ TEST_P(
   std::memcpy(iobuf->writableData(), payload.data(), payloadSize);
   iobuf->append(payloadSize);
 
-  auto page = std::make_unique<SerializedPage>(std::move(iobuf));
+  auto page = std::make_unique<PrestoSerializedPage>(std::move(iobuf));
 
   auto queue = std::make_shared<ExchangeQueue>(1, 0);
   std::vector<ContinuePromise> promises;
diff --git a/velox/exec/tests/PartitionedOutputTest.cpp b/velox/exec/tests/PartitionedOutputTest.cpp
index be921e80c91..fb4f4492159 100644
--- a/velox/exec/tests/PartitionedOutputTest.cpp
+++ b/velox/exec/tests/PartitionedOutputTest.cpp
@@ -23,15 +23,11 @@
 
 namespace facebook::velox::exec::test {
 
-class PartitionedOutputTest
-    : public OperatorTestBase,
-      public testing::WithParamInterface<VectorSerde::Kind> {
+class PartitionedOutputTest : public OperatorTestBase,
+                              public testing::WithParamInterface<std::string> {
  public:
-  static std::vector<VectorSerde::Kind> getTestParams() {
-    const std::vector<VectorSerde::Kind> kinds(
-        {VectorSerde::Kind::kPresto,
-         VectorSerde::Kind::kCompactRow,
-         VectorSerde::Kind::kUnsafeRow});
+  static std::vector<std::string> getTestParams() {
+    const std::vector<std::string> kinds({"Presto", "CompactRow", "UnsafeRow"});
     return kinds;
   }
 
@@ -159,10 +155,15 @@ TEST_P(PartitionedOutputTest, flush) {
 
   auto planStats = toPlanStats(task->taskStats());
   const auto serdeKindRuntimsStats =
-      planStats.at(partitionNodeId).customStats.at(Operator::kShuffleSerdeKind);
+      planStats.at(partitionNodeId)
+          .customStats.at(std::string(Operator::kShuffleSerdeKind));
   ASSERT_EQ(serdeKindRuntimsStats.count, 1);
-  ASSERT_EQ(serdeKindRuntimsStats.min, static_cast<int64_t>(GetParam()));
-  ASSERT_EQ(serdeKindRuntimsStats.max, static_cast<int64_t>(GetParam()));
+  ASSERT_EQ(
+      serdeKindRuntimsStats.min,
+      static_cast<int64_t>(VectorSerde::kindByName(GetParam())));
+  ASSERT_EQ(
+      serdeKindRuntimsStats.max,
+      static_cast<int64_t>(VectorSerde::kindByName(GetParam())));
 }
 
 TEST_P(PartitionedOutputTest, keyChannelNotAtBeginningWithNulls) {
@@ -206,6 +207,81 @@ TEST_P(PartitionedOutputTest, keyChannelNotAtBeginningWithNulls) {
           .count()));
 }
 
+// This test verifies that the Destination properly handles multiple
+// flush-then-append cycles. After flush(), the VectorStreamGroup must be
+// properly reset so that subsequent advance() calls create a fresh serializer
+// with proper initialization via createStreamTree(). This test exercises
+// the fix for T254261397 where crashes occurred due to improper state after
+// flush when current_->clear() was called instead of current_.reset().
+TEST_P(PartitionedOutputTest, multipleFlushCycles) {
+  // Create input data where each row is large enough to trigger a flush
+  // (exceeds kMinDestinationSize), but we have many batches to ensure
+  // multiple flush-then-advance cycles occur for the same destination.
+  const auto largeString =
+      std::string(PartitionedOutput::kMinDestinationSize * 2, 'x');
+
+  auto input = makeRowVector(
+      {"p1", "v1"},
+      {// All rows go to partition 0 to ensure multiple flushes on same dest.
+       makeFlatVector<int32_t>({0, 0, 0, 0}),
+       makeFlatVector<std::string>(
+           {largeString, largeString, largeString, largeString})});
+
+  core::PlanNodeId partitionNodeId;
+  // Use 20 batches to ensure many flush cycles (each row triggers a flush).
+  auto plan = PlanBuilder()
+                  .values({input}, false, 20)
+                  .partitionedOutput(
+                      {"p1"}, 2, std::vector<std::string>{"v1"}, GetParam())
+                  .capturePlanNodeId(partitionNodeId)
+                  .planNode();
+
+  auto taskId = "local://test-partitioned-output-multiple-flush-cycles-0";
+  auto task = Task::create(
+      taskId,
+      core::PlanFragment{plan},
+      0,
+      createQueryContext(
+          {{core::QueryConfig::kMaxPartitionedOutputBufferSize,
+            std::to_string(PartitionedOutput::kMinDestinationSize * 2)}}),
+      Task::ExecutionMode::kParallel);
+  task->start(1);
+
+  const auto partition0 = getAllData(taskId, 0);
+  const auto partition1 = getAllData(taskId, 1);
+
+  const auto taskWaitUs = std::chrono::duration_cast<std::chrono::microseconds>(
+                              std::chrono::seconds{10})
+                              .count();
+  auto future = task->taskCompletionFuture()
+                    .within(std::chrono::microseconds(taskWaitUs))
+                    .via(executor_.get());
+  future.wait();
+
+  ASSERT_TRUE(waitForTaskDriversToFinish(task.get(), taskWaitUs));
+
+  // With 20 batches * 4 rows per batch = 80 rows going to partition 0.
+  // Each row exceeds the flush threshold, so we expect many pages (~80).
+  // The exact count may vary due to targetSizePct randomization, but we
+  // should have at least 40 pages (assuming some batching).
+  ASSERT_GE(partition0.size(), 40);
+
+  // Partition 1 should have no data (or just the final flush marker).
+  ASSERT_LE(partition1.size(), 1);
+
+  auto planStats = toPlanStats(task->taskStats());
+  const auto serdeKindRuntimsStats =
+      planStats.at(partitionNodeId)
+          .customStats.at(std::string(Operator::kShuffleSerdeKind));
+  ASSERT_EQ(serdeKindRuntimsStats.count, 1);
+  ASSERT_EQ(
+      serdeKindRuntimsStats.min,
+      static_cast<int64_t>(VectorSerde::kindByName(GetParam())));
+  ASSERT_EQ(
+      serdeKindRuntimsStats.max,
+      static_cast<int64_t>(VectorSerde::kindByName(GetParam())));
+}
+
 VELOX_INSTANTIATE_TEST_SUITE_P(
     PartitionedOutputTest,
     PartitionedOutputTest,
diff --git a/velox/exec/tests/PlanBuilderTest.cpp b/velox/exec/tests/PlanBuilderTest.cpp
index ca2a2c073f7..3366cb71a8a 100644
--- a/velox/exec/tests/PlanBuilderTest.cpp
+++ b/velox/exec/tests/PlanBuilderTest.cpp
@@ -13,10 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/core/Expressions.h"
 #include "velox/exec/WindowFunction.h"
+#include "velox/exec/tests/utils/ExpressionBuilder.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/TestIndexStorageConnector.h"
 #include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
@@ -255,51 +258,75 @@ TEST_F(PlanBuilderTest, missingOutputType) {
 }
 
 TEST_F(PlanBuilderTest, projectExpressions) {
+  using namespace velox::expr_builder;
+
   // Non-typed Expressions.
   // Simple field access.
   auto data = ROW({"c0"}, {BIGINT()});
   VELOX_CHECK_EQ(
       PlanBuilder()
           .tableScan("tmp", data)
-          .projectExpressions(
-              {std::make_shared<core::FieldAccessExpr>("c0", std::nullopt)})
+          .projectExpressions({col("c0")})
           .planNode()
           ->toString(true, false),
       "-- Project[1][expressions: (c0:BIGINT, ROW[\"c0\"])] -> c0:BIGINT\n");
+
   // Dereference test using field access query.
   data = ROW({"c0"}, {ROW({"field0"}, {BIGINT()})});
   VELOX_CHECK_EQ(
       PlanBuilder()
           .tableScan("tmp", data)
-          .projectExpressions({std::make_shared<core::FieldAccessExpr>(
-              "field0",
-              std::nullopt,
-              std::vector<core::ExprPtr>{
-                  std::make_shared<core::FieldAccessExpr>(
-                      "c0", std::nullopt)})})
+          .projectExpressions({col("c0").subfield("field0")})
           .planNode()
           ->toString(true, false),
       "-- Project[1][expressions: (field0:BIGINT, ROW[\"c0\"][field0])] -> field0:BIGINT\n");
 
   // Test Typed Expressions
+  auto rowType = ROW({"c0"}, {VARCHAR()});
   VELOX_CHECK_EQ(
       PlanBuilder()
-          .tableScan("tmp", ROW({"c0"}, {ROW({VARCHAR()})}))
+          .tableScan("tmp", rowType)
           .projectExpressions(
-              {std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0")})
+              {core::Expressions::inferTypes(col("c0"), rowType, pool_.get())})
+          .planNode()
+          ->toString(true, false),
+      "-- Project[1][expressions: (p0:VARCHAR, ROW[\"c0\"])] -> p0:VARCHAR\n");
+
+  rowType = ROW({"c0"}, {ROW({"field0"}, {VARCHAR()})});
+  VELOX_CHECK_EQ(
+      PlanBuilder()
+          .tableScan("tmp", rowType)
+          .projectExpressions({core::Expressions::inferTypes(
+              col("c0").subfield("field0"), rowType, pool_.get())})
+          .planNode()
+          ->toString(true, false),
+      "-- Project[1][expressions: (p0:VARCHAR, ROW[\"c0\"][field0])] -> p0:VARCHAR\n");
+}
+
+TEST_F(PlanBuilderTest, filter) {
+  auto data = ROW({"c0"}, {BIGINT()});
+  constexpr std::string_view expectation =
+      "-- Filter[1][expression: gt(plus(ROW[\"c0\"],10),100)] -> c0:BIGINT\n";
+
+  // Filter with SQL snippet.
+  VELOX_CHECK_EQ(
+      PlanBuilder()
+          .tableScan("tmp", data)
+          .filter("c0 + 10 > 100")
           .planNode()
           ->toString(true, false),
-      "-- Project[1][expressions: (p0:VARCHAR, \"c0\")] -> p0:VARCHAR\n");
+      expectation);
+
+  using namespace velox::expr_builder;
+
+  // Filter with untyped expression (same expression as above).
   VELOX_CHECK_EQ(
       PlanBuilder()
-          .tableScan("tmp", ROW({"c0"}, {ROW({VARCHAR()})}))
-          .projectExpressions({std::make_shared<core::FieldAccessTypedExpr>(
-              VARCHAR(),
-              std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0"),
-              "field0")})
+          .tableScan("tmp", data)
+          .filter(col("c0") + 10L > 100L)
           .planNode()
           ->toString(true, false),
-      "-- Project[1][expressions: (p0:VARCHAR, \"c0\"[\"field0\"])] -> p0:VARCHAR\n");
+      expectation);
 }
 
 TEST_F(PlanBuilderTest, commitStrategyParameter) {
@@ -374,9 +401,10 @@ TEST_F(PlanBuilderTest, indexLookupJoinBuilder) {
                   .rightKeys({"u0"})
                   .indexSource(rightScan)
                   .joinConditions({"contains(t1, u1)"})
-                  .includeMatchColumn(false)
+                  .hasMarker(false)
                   .outputLayout({"t0", "u1"})
                   .joinType(core::JoinType::kInner)
+                  .filter("t0 > 0")
                   .endIndexLookupJoin()
                   .planNode();
 
@@ -389,7 +417,61 @@ TEST_F(PlanBuilderTest, indexLookupJoinBuilder) {
   ASSERT_EQ(indexJoinNode->leftKeys()[0]->name(), "t0");
   ASSERT_EQ(indexJoinNode->rightKeys()[0]->name(), "u0");
   ASSERT_EQ(indexJoinNode->joinConditions().size(), 1);
-  ASSERT_FALSE(indexJoinNode->includeMatchColumn());
+  ASSERT_FALSE(indexJoinNode->hasMarker());
+  ASSERT_EQ(indexJoinNode->outputType()->names().size(), 2);
+  ASSERT_EQ(indexJoinNode->outputType()->names()[0], "t0");
+  ASSERT_EQ(indexJoinNode->outputType()->names()[1], "u1");
+  ASSERT_EQ(indexJoinNode->filter()->toString(), "gt(ROW[\"t0\"],0)");
+}
+
+TEST_F(PlanBuilderTest, insertTableHandleParameter) {
+  auto data = makeRowVector({makeFlatVector<int64_t>(10, folly::identity)});
+  auto directory = "/some/test/directory";
+
+  // Lambda to create a plan with given insertableHandle and verify it
+  auto testInsertTableHandle =
+      [&](std::shared_ptr<core::InsertTableHandle> insertTableHandle) {
+        // Create a plan with insertTableHandle
+        auto planBuilder = PlanBuilder().values({data}).tableWrite(
+            directory,
+            {},
+            0,
+            {},
+            {},
+            dwio::common::FileFormat::DWRF,
+            {},
+            PlanBuilder::kHiveDefaultConnectorId,
+            {},
+            nullptr,
+            "",
+            common::CompressionKind_NONE,
+            nullptr,
+            false,
+            connector::CommitStrategy::kNoCommit,
+            insertTableHandle);
+
+        // Verify the plan node has the correct insert Table Handle.
+        auto tableWriteNode =
+            std::dynamic_pointer_cast<const core::TableWriteNode>(
+                planBuilder.planNode());
+        ASSERT_NE(tableWriteNode, nullptr);
+        ASSERT_EQ(tableWriteNode->insertTableHandle(), insertTableHandle);
+      };
+
+  auto rowType = ROW({"c0", "c1", "c2"}, {BIGINT(), INTEGER(), SMALLINT()});
+  auto hiveHandle = HiveConnectorTestBase::makeHiveInsertTableHandle(
+      rowType->names(),
+      rowType->children(),
+      {rowType->names()[0]}, // partitionedBy
+      nullptr, // bucketProperty
+      HiveConnectorTestBase::makeLocationHandle(
+          "/path/to/test",
+          std::nullopt,
+          connector::hive::LocationHandle::TableType::kNew));
+
+  auto insertHandle = std::make_shared<core::InsertTableHandle>(
+      std::string(PlanBuilder::kHiveDefaultConnectorId), hiveHandle);
+  testInsertTableHandle(insertHandle);
 }
 
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/PlanNodeSerdeTest.cpp b/velox/exec/tests/PlanNodeSerdeTest.cpp
index 6802958dd20..92652b0ad4b 100644
--- a/velox/exec/tests/PlanNodeSerdeTest.cpp
+++ b/velox/exec/tests/PlanNodeSerdeTest.cpp
@@ -16,10 +16,12 @@
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/exec/PartitionFunction.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 #include "velox/parse/TypeResolver.h"
+#include "velox/type/TypeSerde.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
 #include <gtest/gtest.h>
@@ -176,6 +178,14 @@ TEST_F(PlanNodeSerdeTest, markDistinct) {
   testSerde(plan);
 }
 
+TEST_F(PlanNodeSerdeTest, enforceDistinct) {
+  auto plan = PlanBuilder()
+                  .values({data_})
+                  .enforceDistinct({"c0", "c1", "c2"}, "Test error message")
+                  .planNode();
+  testSerde(plan);
+}
+
 TEST_F(PlanNodeSerdeTest, nestedLoopJoin) {
   auto left = makeRowVector(
       {"t0", "t1", "t2"},
@@ -223,10 +233,8 @@ TEST_F(PlanNodeSerdeTest, enforceSingleRow) {
 }
 
 TEST_F(PlanNodeSerdeTest, exchange) {
-  for (auto serdeKind : std::vector<VectorSerde::Kind>{
-           VectorSerde::Kind::kPresto,
-           VectorSerde::Kind::kCompactRow,
-           VectorSerde::Kind::kUnsafeRow}) {
+  for (auto serdeKind :
+       std::vector<std::string>{"Presto", "CompactRow", "UnsafeRow"}) {
     SCOPED_TRACE(fmt::format("serdeKind: {}", serdeKind));
     auto plan = PlanBuilder()
                     .exchange(
@@ -310,10 +318,8 @@ TEST_F(PlanNodeSerdeTest, limit) {
 }
 
 TEST_F(PlanNodeSerdeTest, mergeExchange) {
-  for (auto serdeKind : std::vector<VectorSerde::Kind>{
-           VectorSerde::Kind::kPresto,
-           VectorSerde::Kind::kCompactRow,
-           VectorSerde::Kind::kUnsafeRow}) {
+  for (auto serdeKind :
+       std::vector<std::string>{"Presto", "CompactRow", "UnsafeRow"}) {
     auto plan = PlanBuilder()
                     .mergeExchange(
                         ROW({"a", "b", "c"}, {BIGINT(), DOUBLE(), VARCHAR()}),
@@ -420,10 +426,8 @@ TEST_F(PlanNodeSerdeTest, orderBy) {
 }
 
 TEST_F(PlanNodeSerdeTest, partitionedOutput) {
-  for (auto serdeKind : std::vector<VectorSerde::Kind>{
-           VectorSerde::Kind::kPresto,
-           VectorSerde::Kind::kCompactRow,
-           VectorSerde::Kind::kUnsafeRow}) {
+  for (auto serdeKind :
+       std::vector<std::string>{"Presto", "CompactRow", "UnsafeRow"}) {
     SCOPED_TRACE(fmt::format("serdeKind: {}", serdeKind));
 
     auto plan = PlanBuilder()
@@ -534,6 +538,22 @@ TEST_F(PlanNodeSerdeTest, hashJoin) {
              .planNode();
 
   testSerde(plan);
+
+  // nullAsValue join (used for EXCEPT/INTERSECT).
+  plan = PlanBuilder(planNodeIdGenerator)
+             .values({probe})
+             .hashJoin(
+                 {"t0"},
+                 {"u0"},
+                 PlanBuilder(planNodeIdGenerator).values({build}).planNode(),
+                 "",
+                 {"t0", "t1"},
+                 core::JoinType::kAnti,
+                 /*nullAware=*/false,
+                 /*nullAsValue=*/true)
+             .planNode();
+
+  testSerde(plan);
 }
 
 TEST_F(PlanNodeSerdeTest, topN) {
@@ -656,14 +676,44 @@ TEST_F(PlanNodeSerdeTest, rowNumber) {
 }
 
 TEST_F(PlanNodeSerdeTest, scan) {
-  auto plan = PlanBuilder(pool_.get())
-                  .tableScan(
-                      ROW({"a", "b", "c", "d"},
-                          {BIGINT(), BIGINT(), BOOLEAN(), DOUBLE()}),
-                      {"a < 5", "b = 7", "c = true", "d > 0.01"},
-                      "a + b < 100")
-                  .planNode();
-  testSerde(plan);
+  {
+    auto plan = PlanBuilder(pool_.get())
+                    .tableScan(
+                        ROW({"a", "b", "c", "d"},
+                            {BIGINT(), BIGINT(), BOOLEAN(), DOUBLE()}),
+                        {"a < 5", "b = 7", "c = true", "d > 0.01"},
+                        "a + b < 100")
+                    .planNode();
+    testSerde(plan);
+  }
+
+  {
+    auto plan =
+        PlanBuilder()
+            .startTableScan()
+            .outputType(ROW({"x"}, {BIGINT()}))
+            .assignments(
+                {{"x", HiveConnectorTestBase::regularColumn("a", BIGINT())}})
+            .dataColumns(ROW({"a", "b"}, {BIGINT(), BIGINT()}))
+            .filterColumnHandles({
+                HiveConnectorTestBase::partitionKey("ds", VARCHAR()),
+                HiveConnectorTestBase::regularColumn("a", BIGINT()),
+            })
+            .remainingFilter("length(ds) + a % 2 > 0")
+            .endTableScan()
+            .planNode();
+    testSerde(plan);
+  }
+
+  {
+    auto plan = PlanBuilder()
+                    .startTableScan()
+                    .outputType(ROW({"x"}, {BIGINT()}))
+                    .sampleRate(0.5)
+                    .endTableScan()
+                    .planNode();
+    testSerde(plan);
+  }
 }
 
 TEST_F(PlanNodeSerdeTest, topNRowNumber) {
@@ -964,4 +1014,27 @@ TEST_F(PlanNodeSerdeTest, columnStatsSpec) {
   }
 }
 
+TEST_F(PlanNodeSerdeTest, countingJoin) {
+  for (auto joinType :
+       {core::JoinType::kCountingAnti,
+        core::JoinType::kCountingLeftSemiFilter}) {
+    SCOPED_TRACE(core::JoinTypeName::toName(joinType));
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values({data_})
+                    .hashJoin(
+                        {"c0"},
+                        {"u_c0"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values({data_})
+                            .project({"c0 as u_c0"})
+                            .planNode(),
+                        "",
+                        {"c0", "c1"},
+                        joinType)
+                    .planNode();
+    testSerde(plan);
+  }
+}
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/PlanNodeStatsTest.cpp b/velox/exec/tests/PlanNodeStatsTest.cpp
new file mode 100644
index 00000000000..2a59537eb43
--- /dev/null
+++ b/velox/exec/tests/PlanNodeStatsTest.cpp
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/PlanNodeStats.h"
+#include <gtest/gtest.h>
+
+namespace facebook::velox::exec::test {
+
+TEST(PlanNodeStatsTest, exprStatsTotal) {
+  PlanNodeStats stats;
+  stats.expressionStats["foo"] = ExprStats{
+      .timing = {.wallNanos = 1, .cpuNanos = 2},
+      .numProcessedRows = 3,
+      .numProcessedVectors = 4};
+
+  PlanNodeStats total;
+  total += stats;
+  EXPECT_EQ(total.expressionStats["foo"], stats.expressionStats["foo"]);
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/PlanNodeToStringTest.cpp b/velox/exec/tests/PlanNodeToStringTest.cpp
index 334c35127db..d734e1f3a5a 100644
--- a/velox/exec/tests/PlanNodeToStringTest.cpp
+++ b/velox/exec/tests/PlanNodeToStringTest.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/exec/WindowFunction.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
@@ -412,6 +413,28 @@ TEST_F(PlanNodeToStringTest, hashJoin) {
   ASSERT_EQ(
       "-- HashJoin[2][ANTI t_c0=u_c0] -> t_c0:SMALLINT, t_c1:INTEGER\n",
       plan->toString(true, false));
+
+  plan = PlanBuilder()
+             .values({data_})
+             .project({"c0 as t_c0", "c1 as t_c1"})
+             .hashJoin(
+                 {"t_c0"},
+                 {"u_c0"},
+                 PlanBuilder()
+                     .values({data_})
+                     .project({"c0 as u_c0", "c1 as u_c1"})
+                     .planNode(),
+                 "",
+                 {"t_c0", "t_c1"},
+                 core::JoinType::kAnti,
+                 false /*nullAware*/,
+                 true /*nullAsValue*/)
+             .planNode();
+
+  ASSERT_EQ("-- HashJoin[2]\n", plan->toString());
+  ASSERT_EQ(
+      "-- HashJoin[2][ANTI t_c0=u_c0, null as value] -> t_c0:SMALLINT, t_c1:INTEGER\n",
+      plan->toString(true, false));
 }
 
 TEST_F(PlanNodeToStringTest, mergeJoin) {
@@ -592,10 +615,8 @@ TEST_F(PlanNodeToStringTest, localPartition) {
 }
 
 TEST_F(PlanNodeToStringTest, partitionedOutput) {
-  for (auto serdeKind : std::vector<VectorSerde::Kind>{
-           VectorSerde::Kind::kPresto,
-           VectorSerde::Kind::kCompactRow,
-           VectorSerde::Kind::kUnsafeRow}) {
+  for (auto serdeKind :
+       std::vector<std::string>{"Presto", "CompactRow", "UnsafeRow"}) {
     SCOPED_TRACE(fmt::format("serdeKind: {}", serdeKind));
     auto plan =
         PlanBuilder()
@@ -698,10 +719,8 @@ TEST_F(PlanNodeToStringTest, localMerge) {
 }
 
 TEST_F(PlanNodeToStringTest, exchange) {
-  for (auto serdeKind : std::vector<VectorSerde::Kind>{
-           VectorSerde::Kind::kPresto,
-           VectorSerde::Kind::kCompactRow,
-           VectorSerde::Kind::kUnsafeRow}) {
+  for (auto serdeKind :
+       std::vector<std::string>{"Presto", "CompactRow", "UnsafeRow"}) {
     SCOPED_TRACE(fmt::format("serdeKind: {}", serdeKind));
 
     auto plan = PlanBuilder()
@@ -716,10 +735,8 @@ TEST_F(PlanNodeToStringTest, exchange) {
 }
 
 TEST_F(PlanNodeToStringTest, mergeExchange) {
-  for (auto serdeKind : std::vector<VectorSerde::Kind>{
-           VectorSerde::Kind::kPresto,
-           VectorSerde::Kind::kCompactRow,
-           VectorSerde::Kind::kUnsafeRow}) {
+  for (auto serdeKind :
+       std::vector<std::string>{"Presto", "CompactRow", "UnsafeRow"}) {
     SCOPED_TRACE(fmt::format("serdeKind: {}", serdeKind));
 
     auto plan =
@@ -994,5 +1011,103 @@ TEST_F(PlanNodeToStringTest, markDistinct) {
       op->toString(true, false));
 }
 
+TEST_F(PlanNodeToStringTest, tableWrite) {
+  auto outputDir = common::testutil::TempDirectoryPath::create();
+
+  // TableWrite without stats.
+  {
+    auto plan = PlanBuilder()
+                    .values({data_})
+                    .tableWrite(outputDir->getPath())
+                    .planNode();
+    ASSERT_EQ("-- TableWrite[1]\n", plan->toString());
+    ASSERT_EQ(
+        "-- TableWrite[1][test-hive, c0, c1, c2] -> rows:BIGINT, fragments:VARBINARY, commitcontext:VARBINARY\n",
+        plan->toString(true, false));
+  }
+
+  // TableWrite with stats (no grouping keys) and TableWriteMerge.
+  {
+    core::TableWriteNodePtr writeNode;
+    auto plan = PlanBuilder()
+                    .values({data_})
+                    .tableWrite(
+                        outputDir->getPath(),
+                        dwio::common::FileFormat::DWRF,
+                        {"min(c0)"})
+                    .capturePlanNode(writeNode)
+                    .localGather()
+                    .tableWriteMerge()
+                    .planNode();
+
+    ASSERT_EQ("-- TableWrite[1]\n", writeNode->toString());
+    ASSERT_EQ(
+        "-- TableWrite[1][test-hive, c0, c1, c2, stats[PARTIAL: min(ROW[\"c0\"])]] -> rows:BIGINT, fragments:VARBINARY, commitcontext:VARBINARY, a0:SMALLINT\n",
+        writeNode->toString(true, false));
+
+    ASSERT_EQ("-- TableWriteMerge[3]\n", plan->toString());
+    ASSERT_EQ(
+        "-- TableWriteMerge[3][stats[INTERMEDIATE: min(\"a0\")]] -> rows:BIGINT, fragments:VARBINARY, commitcontext:VARBINARY, a0:SMALLINT\n",
+        plan->toString(true, false));
+  }
+
+  // TableWrite with stats and grouping keys (partitioned table).
+  {
+    core::TableWriteNodePtr writeNode;
+    auto plan = PlanBuilder()
+                    .values({data_})
+                    .tableWrite(
+                        outputDir->getPath(),
+                        {"c2"},
+                        dwio::common::FileFormat::DWRF,
+                        {"min(c0)", "max(c1)"})
+                    .capturePlanNode(writeNode)
+                    .localGather()
+                    .tableWriteMerge()
+                    .planNode();
+
+    ASSERT_EQ("-- TableWrite[1]\n", writeNode->toString());
+    ASSERT_EQ(
+        "-- TableWrite[1][test-hive, c0, c1, c2, stats[PARTIAL [c2]: min(ROW[\"c0\"]), max(ROW[\"c1\"])]] -> rows:BIGINT, fragments:VARBINARY, commitcontext:VARBINARY, c2:BIGINT, a0:SMALLINT, a1:INTEGER\n",
+        writeNode->toString(true, false));
+
+    ASSERT_EQ("-- TableWriteMerge[3]\n", plan->toString());
+    ASSERT_EQ(
+        "-- TableWriteMerge[3][stats[INTERMEDIATE [c2]: min(\"a0\"), max(\"a1\")]] -> rows:BIGINT, fragments:VARBINARY, commitcontext:VARBINARY, c2:BIGINT, a0:SMALLINT, a1:INTEGER\n",
+        plan->toString(true, false));
+  }
+}
+
+TEST_F(PlanNodeToStringTest, countingJoin) {
+  auto makePlan = [&](core::JoinType joinType) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    return PlanBuilder(planNodeIdGenerator)
+        .values({data_})
+        .hashJoin(
+            {"c0"},
+            {"u_c0"},
+            PlanBuilder(planNodeIdGenerator)
+                .values({data_})
+                .project({"c0 as u_c0"})
+                .planNode(),
+            "",
+            {"c0", "c1"},
+            joinType)
+        .planNode();
+  };
+
+  auto plan = makePlan(core::JoinType::kCountingAnti);
+  ASSERT_EQ("-- HashJoin[3]\n", plan->toString());
+  ASSERT_EQ(
+      "-- HashJoin[3][COUNTING ANTI c0=u_c0] -> c0:SMALLINT, c1:INTEGER\n",
+      plan->toString(true, false));
+
+  plan = makePlan(core::JoinType::kCountingLeftSemiFilter);
+  ASSERT_EQ("-- HashJoin[3]\n", plan->toString());
+  ASSERT_EQ(
+      "-- HashJoin[3][COUNTING LEFT SEMI (FILTER) c0=u_c0] -> c0:SMALLINT, c1:INTEGER\n",
+      plan->toString(true, false));
+}
+
 } // namespace
 } // namespace facebook::velox::exec
diff --git a/velox/exec/tests/PrefixSortTest.cpp b/velox/exec/tests/PrefixSortTest.cpp
index f404fa05ac4..732d590dc05 100644
--- a/velox/exec/tests/PrefixSortTest.cpp
+++ b/velox/exec/tests/PrefixSortTest.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include <fmt/ranges.h>
 #include <gtest/gtest.h>
 
 #include "velox/exec/PrefixSort.h"
diff --git a/velox/exec/tests/PrestoQueryRunnerIntermediateTypeTransformTestBase.cpp b/velox/exec/tests/PrestoQueryRunnerIntermediateTypeTransformTestBase.cpp
index 5bc0a66bc91..a52fc815068 100644
--- a/velox/exec/tests/PrestoQueryRunnerIntermediateTypeTransformTestBase.cpp
+++ b/velox/exec/tests/PrestoQueryRunnerIntermediateTypeTransformTestBase.cpp
@@ -148,20 +148,22 @@ void PrestoQueryRunnerIntermediateTypeTransformTestBase::testRow(
   test(vectorMaker_.rowVector({field1, field2, field3}));
 
   // Test row vector some nulls.
-  test(std::make_shared<RowVector>(
-      pool_.get(),
-      rowType,
-      makeNulls(size, [](vector_size_t row) { return row % 10 == 0; }),
-      size,
-      std::vector<VectorPtr>{field1, field2, field3}));
+  test(
+      std::make_shared<RowVector>(
+          pool_.get(),
+          rowType,
+          makeNulls(size, [](vector_size_t row) { return row % 10 == 0; }),
+          size,
+          std::vector<VectorPtr>{field1, field2, field3}));
 
   // Test row vector all nulls.
-  test(std::make_shared<RowVector>(
-      pool_.get(),
-      rowType,
-      makeNulls(size, [](vector_size_t) { return true; }),
-      size,
-      std::vector<VectorPtr>{field1, field2, field3}));
+  test(
+      std::make_shared<RowVector>(
+          pool_.get(),
+          rowType,
+          makeNulls(size, [](vector_size_t) { return true; }),
+          size,
+          std::vector<VectorPtr>{field1, field2, field3}));
 
   const auto base = vectorMaker_.rowVector({field1, field2, field3});
   testDictionary(base);
diff --git a/velox/exec/tests/PrestoQueryRunnerKHyperLogLogTransformTest.cpp b/velox/exec/tests/PrestoQueryRunnerKHyperLogLogTransformTest.cpp
new file mode 100644
index 00000000000..80a4f5a7cd1
--- /dev/null
+++ b/velox/exec/tests/PrestoQueryRunnerKHyperLogLogTransformTest.cpp
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.h"
+#include "velox/exec/tests/PrestoQueryRunnerIntermediateTypeTransformTestBase.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+
+namespace facebook::velox::exec::test {
+namespace {
+
+class PrestoQueryRunnerKHyperLogLogTransformTest
+    : public PrestoQueryRunnerIntermediateTypeTransformTestBase {};
+
+TEST_F(PrestoQueryRunnerKHyperLogLogTransformTest, isIntermediateOnlyType) {
+  ASSERT_TRUE(isIntermediateOnlyType(KHYPERLOGLOG()));
+  ASSERT_TRUE(isIntermediateOnlyType(ARRAY(KHYPERLOGLOG())));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(KHYPERLOGLOG(), SMALLINT())));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(VARBINARY(), KHYPERLOGLOG())));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW({KHYPERLOGLOG(), SMALLINT()})));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW(
+      {SMALLINT(),
+       TIMESTAMP(),
+       ARRAY(ROW({MAP(VARCHAR(), KHYPERLOGLOG())}))})));
+}
+
+TEST_F(PrestoQueryRunnerKHyperLogLogTransformTest, transform) {
+  test(KHYPERLOGLOG());
+}
+
+TEST_F(PrestoQueryRunnerKHyperLogLogTransformTest, transformArray) {
+  testArray(KHYPERLOGLOG());
+}
+
+TEST_F(PrestoQueryRunnerKHyperLogLogTransformTest, transformMap) {
+  testMap(KHYPERLOGLOG());
+}
+
+TEST_F(PrestoQueryRunnerKHyperLogLogTransformTest, transformRow) {
+  testRow(KHYPERLOGLOG());
+}
+
+} // namespace
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/PrestoQueryRunnerSetDigestTransformTest.cpp b/velox/exec/tests/PrestoQueryRunnerSetDigestTransformTest.cpp
new file mode 100644
index 00000000000..af15b0dec71
--- /dev/null
+++ b/velox/exec/tests/PrestoQueryRunnerSetDigestTransformTest.cpp
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.h"
+#include "velox/exec/tests/PrestoQueryRunnerIntermediateTypeTransformTestBase.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
+
+namespace facebook::velox::exec::test {
+namespace {
+
+class PrestoQueryRunnerSetDigestTransformTest
+    : public PrestoQueryRunnerIntermediateTypeTransformTestBase {};
+
+TEST_F(PrestoQueryRunnerSetDigestTransformTest, isIntermediateOnlyType) {
+  ASSERT_TRUE(isIntermediateOnlyType(SETDIGEST()));
+  ASSERT_TRUE(isIntermediateOnlyType(ARRAY(SETDIGEST())));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(SETDIGEST(), SMALLINT())));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(VARBINARY(), SETDIGEST())));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW({SETDIGEST(), SMALLINT()})));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW(
+      {SMALLINT(), TIMESTAMP(), ARRAY(ROW({MAP(VARCHAR(), SETDIGEST())}))})));
+}
+
+TEST_F(PrestoQueryRunnerSetDigestTransformTest, transform) {
+  test(SETDIGEST());
+}
+
+TEST_F(PrestoQueryRunnerSetDigestTransformTest, transformArray) {
+  testArray(SETDIGEST());
+}
+
+TEST_F(PrestoQueryRunnerSetDigestTransformTest, transformMap) {
+  testMap(SETDIGEST());
+}
+
+TEST_F(PrestoQueryRunnerSetDigestTransformTest, transformRow) {
+  testRow(SETDIGEST());
+}
+
+} // namespace
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/PrestoQueryRunnerTimeTransformTest.cpp b/velox/exec/tests/PrestoQueryRunnerTimeTransformTest.cpp
new file mode 100644
index 00000000000..0e72861ff20
--- /dev/null
+++ b/velox/exec/tests/PrestoQueryRunnerTimeTransformTest.cpp
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/tests/PrestoQueryRunnerIntermediateTypeTransformTestBase.h"
+
+namespace facebook::velox::exec::test {
+namespace {
+
+class PrestoQueryRunnerTimeTransformTest
+    : public PrestoQueryRunnerIntermediateTypeTransformTestBase {};
+
+// Test that TIME is recognized as an intermediate type that needs
+// transformation
+TEST_F(PrestoQueryRunnerTimeTransformTest, isIntermediateOnlyType) {
+  // Core test: TIME should be an intermediate type
+  ASSERT_TRUE(isIntermediateOnlyType(TIME()));
+
+  // Complex types containing TIME should also be intermediate types
+  ASSERT_TRUE(isIntermediateOnlyType(ARRAY(TIME())));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(VARCHAR(), TIME())));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(TIME(), VARCHAR())));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW({TIME(), BIGINT()})));
+}
+
+TEST_F(PrestoQueryRunnerTimeTransformTest, roundTrip) {
+  // Test basic TIME values (no nulls, some nulls, all nulls)
+  std::vector<std::optional<int64_t>> no_nulls{0, 3661000, 43200000, 86399999};
+  test(makeNullableFlatVector(no_nulls, TIME()));
+
+  std::vector<std::optional<int64_t>> some_nulls{
+      0, 3661000, std::nullopt, 86399999};
+  test(makeNullableFlatVector(some_nulls, TIME()));
+
+  std::vector<std::optional<int64_t>> all_nulls{
+      std::nullopt, std::nullopt, std::nullopt};
+  test(makeNullableFlatVector(all_nulls, TIME()));
+}
+
+TEST_F(PrestoQueryRunnerTimeTransformTest, transformArray) {
+  auto input = makeNullableFlatVector(
+      std::vector<std::optional<int64_t>>{
+          0, // 00:00:00.000
+          1000, // 00:00:01.000
+          3661000, // 01:01:01.000
+          43200000, // 12:00:00.000 (noon)
+          86399999, // 23:59:59.999
+          3723456, // 01:02:03.456
+          45678901, // 12:41:18.901
+          std::nullopt,
+          72000000, // 20:00:00.000
+          36000000 // 10:00:00.000
+      },
+      TIME());
+  testArray(input);
+}
+
+TEST_F(PrestoQueryRunnerTimeTransformTest, transformMap) {
+  // keys can't be null for maps
+  auto keys = makeNullableFlatVector(
+      std::vector<std::optional<int64_t>>{
+          0, // 00:00:00.000
+          3661000, // 01:01:01.000
+          43200000, // 12:00:00.000
+          86399999, // 23:59:59.999
+          36000000, // 10:00:00.000
+          72000000, // 20:00:00.000
+          1800000, // 00:30:00.000
+          7200000, // 02:00:00.000
+          64800000, // 18:00:00.000
+          32400000 // 09:00:00.000
+      },
+      TIME());
+
+  auto values = makeNullableFlatVector<int64_t>(
+      {100, 200, std::nullopt, 400, 500, std::nullopt, 700, 800, 900, 1000},
+      BIGINT());
+
+  testMap(keys, values);
+}
+
+TEST_F(PrestoQueryRunnerTimeTransformTest, transformRow) {
+  auto input = makeNullableFlatVector(
+      std::vector<std::optional<int64_t>>{
+          0, // 00:00:00.000
+          3661000, // 01:01:01.000
+          43200000, // 12:00:00.000
+          86399999, // 23:59:59.999
+          std::nullopt,
+          36000000, // 10:00:00.000
+          72000000, // 20:00:00.000
+          1800000, // 00:30:00.000
+          7200000, // 02:00:00.000
+          64800000 // 18:00:00.000
+      },
+      TIME());
+  testRow({input}, {"time_col"});
+}
+
+} // namespace
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/PrestoQueryRunnerTimestampWithTimeZoneTransformTest.cpp b/velox/exec/tests/PrestoQueryRunnerTimestampWithTimeZoneTransformTest.cpp
index afcd8d33239..4b60208686e 100644
--- a/velox/exec/tests/PrestoQueryRunnerTimestampWithTimeZoneTransformTest.cpp
+++ b/velox/exec/tests/PrestoQueryRunnerTimestampWithTimeZoneTransformTest.cpp
@@ -169,20 +169,22 @@ TEST_F(
   test(vectorMaker_.rowVector({field1, field2, field3}));
 
   // Test row vector some nulls.
-  test(std::make_shared<RowVector>(
-      pool_.get(),
-      rowType,
-      makeNulls(size, [](vector_size_t row) { return row % 10 == 0; }),
-      size,
-      std::vector<VectorPtr>{field1, field2, field3}));
+  test(
+      std::make_shared<RowVector>(
+          pool_.get(),
+          rowType,
+          makeNulls(size, [](vector_size_t row) { return row % 10 == 0; }),
+          size,
+          std::vector<VectorPtr>{field1, field2, field3}));
 
   // Test row vector all nulls.
-  test(std::make_shared<RowVector>(
-      pool_.get(),
-      rowType,
-      makeNulls(size, [](vector_size_t) { return true; }),
-      size,
-      std::vector<VectorPtr>{field1, field2, field3}));
+  test(
+      std::make_shared<RowVector>(
+          pool_.get(),
+          rowType,
+          makeNulls(size, [](vector_size_t) { return true; }),
+          size,
+          std::vector<VectorPtr>{field1, field2, field3}));
 
   const auto base = vectorMaker_.rowVector({field1, field2, field3});
   testDictionary(base);
diff --git a/velox/exec/tests/PrintPlanWithStatsTest.cpp b/velox/exec/tests/PrintPlanWithStatsTest.cpp
index 73928fce6a5..b718c0c71b9 100644
--- a/velox/exec/tests/PrintPlanWithStatsTest.cpp
+++ b/velox/exec/tests/PrintPlanWithStatsTest.cpp
@@ -15,17 +15,18 @@
  */
 
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 #include <gtest/gtest.h>
 #include <re2/re2.h>
 
 using namespace facebook::velox;
 using namespace facebook::velox::exec::test;
+using namespace facebook::velox::common::testutil;
 
 using facebook::velox::exec::test::PlanBuilder;
 
@@ -48,6 +49,12 @@ void compareOutputs(
   for (; std::getline(iss, line);) {
     lineCount++;
     std::vector<std::string> potentialLines;
+    if (expectedLineIndex >= expectedRegex.size()) {
+      ASSERT_FALSE(true) << "Output has more lines than expected."
+                         << "\n  Source: " << testName
+                         << "\n  Line number: " << lineCount
+                         << "\n  Unexpected Line: " << line;
+    }
     auto expectedLine = expectedRegex.at(expectedLineIndex++);
     while (!RE2::FullMatch(line, expectedLine.line)) {
       potentialLines.push_back(expectedLine.line);
@@ -59,11 +66,18 @@ void compareOutputs(
                            << "\n  Expected Line one of: "
                            << folly::join(",", potentialLines);
       }
+      if (expectedLineIndex >= expectedRegex.size()) {
+        ASSERT_FALSE(true)
+            << "Output did not match and no more patterns to check."
+            << "\n  Source: " << testName << "\n  Line number: " << lineCount
+            << "\n  Line: " << line
+            << "\n  Expected Line one of: " << folly::join(",", potentialLines);
+      }
       expectedLine = expectedRegex.at(expectedLineIndex++);
     }
   }
   for (int i = expectedLineIndex; i < expectedRegex.size(); i++) {
-    ASSERT_TRUE(expectedRegex[expectedLineIndex].optional);
+    ASSERT_TRUE(expectedRegex[i].optional);
   }
 }
 
@@ -157,22 +171,28 @@ TEST_F(PrintPlanWithStatsTest, innerJoinWithTableScan) {
        {"      dataSourceLazyCpuNanos[ ]* sum: .+, count: .+, min: .+, max: .+"},
        {"      dataSourceLazyInputBytes[ ]* sum: .+, count: .+, min: .+, max: .+"},
        {"      dataSourceLazyWallNanos[ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"      driverCpuTimeNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"      runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"      runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"      runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"      runningIsBlockedWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"  -- HashJoin\\[3\\]\\[INNER c0=u_c0\\] -> c0:INTEGER, c1:BIGINT, u_c1:BIGINT"},
        {"     Output: 2000 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, CPU breakdown: B/I/O/F (.+/.+/.+/.+)"},
        {"     HashBuild: Input: 100 rows \\(.+\\), Output: 0 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, CPU breakdown: B/I/O/F (.+/.+/.+/.+)"},
        {"        distinctKey0\\s+sum: 101, count: 1, min: 101, max: 101, avg: 101"},
+       {"        driverCpuTimeNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"        hashtable.buildWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"        hashtable.capacity\\s+sum: 200, count: 1, min: 200, max: 200, avg: 200"},
+       {"        hashtable.hashMode\\s+sum: \\d+, count: 1, min: \\d+, max: \\d+, avg: \\d+"},
        {"        hashtable.numDistinct\\s+sum: 100, count: 1, min: 100, max: 100, avg: 100"},
        {"        hashtable.numRehashes\\s+sum: 1, count: 1, min: 1, max: 1, avg: 1"},
+       {"        hashtable.vectorHasherMergeCpuNanos\\s+sum: .*, count: 1, min: .*, max: .*, avg: .*"},
        {"        queuedWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"        rangeKey0\\s+sum: 200, count: 1, min: 200, max: 200, avg: 200"},
        {"        runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"        runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"        runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"        runningIsBlockedWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"     HashProbe: Input: 2000 rows \\(.+\\), Output: 2000 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, CPU breakdown: B/I/O/F (.+/.+/.+/.+)"},
        // These lines may or may not appear depending on whether the operator
        // gets blocked during a run.
@@ -180,6 +200,8 @@ TEST_F(PrintPlanWithStatsTest, innerJoinWithTableScan) {
         true},
        {"        blockedWaitForJoinBuildWallNanos\\s+sum: .+, count: 1, min: .+, max: .+",
         true},
+       {"        driverCpuTimeNanos\\s+sum: .+, count: 1, min: .+, max: .+",
+        true},
        {"        dynamicFiltersProduced\\s+sum: 1, count: 1, min: 1, max: 1, avg: 1",
         true},
        {"        queuedWallNanos\\s+sum: .+, count: 1, min: .+, max: .+", true},
@@ -189,46 +211,78 @@ TEST_F(PrintPlanWithStatsTest, innerJoinWithTableScan) {
        {"        runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"        runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"        runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"        runningIsBlockedWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"    -- TableScan\\[2\\]\\[table: hive_table\\] -> c0:INTEGER, c1:BIGINT"},
        {"       Input: 2000 rows \\(.+\\), Raw Input: 20480 rows \\(.+\\), Output: 2000 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, Splits: 20, DynamicFilter producer plan nodes: 3, CPU breakdown: B/I/O/F (.+/.+/.+/.+)"},
+       // These lines may or may not appear depending on whether the operator
+       // gets blocked waiting for a split during a run.
+       {"          blockedWaitForSplitTimes\\s+sum: .+, count: .+, min: 1, max: 1, avg: 1",
+        true},
+       {"          blockedWaitForSplitWallNanos\\s+sum: .+, count: .+, min: .+, max: .+",
+        true},
+       {"          cacheWaitWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+",
+        true},
+       {"          coalescedSsdLoadWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+",
+        true},
+       {"          coalescedStorageLoadWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+",
+        true},
        {"          connectorSplitSize[ ]* sum: .+, count: .+, min: .+, max: .+"},
-       {"          dataSourceAddSplitWallNanos[ ]* sum: .+, count: 1, min: .+, max: .+"},
        {"          dataSourceReadWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+"},
+       {"          driverCpuTimeNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"          dynamicFiltersAccepted[ ]* sum: 1, count: 1, min: 1, max: 1, avg: 1"},
+       {"          fileFormat\\.dwrf[ ]* sum: .+, count: 1, min: .+, max: .+, avg: .+",
+        true},
        {"          footerBufferOverread[ ]* sum: .+, count: 1, min: .+, max: .+"},
-       {"          ioWaitWallNanos      [ ]* sum: .+, count: .+ min: .+, max: .+"},
-       {"          maxSingleIoWaitWallNanos[ ]*sum: .+, count: 1, min: .+, max: .+"},
-       {"          numPrefetch         [ ]* sum: .+, count: 1, min: .+, max: .+"},
-       {"          numRamRead          [ ]* sum: 60, count: 1, min: 60, max: 60, avg: 60"},
-       {"          numStorageRead      [ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"          ioWaitWallNanos      [ ]* sum: .+, count: .+ min: .+, max: .+",
+        true},
+       {"          numPrefetch         [ ]* sum: .+, count: 1, min: .+, max: .+",
+        true},
+       {"          numRamRead          [ ]* sum: .+, count: 1, min: .+, max: .+, avg: .+",
+        true},
        {"          numStripes[ ]* sum: .+, count: 1, min: .+, max: .+"},
-       {"          overreadBytes[ ]* sum: 0B, count: 1, min: 0B, max: 0B, avg: 0B"},
-       {"          prefetchBytes       [ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"          overreadBytes[ ]* sum: .+, count: 1, min: .+, max: .+",
+        true},
+       {"          prefetchBytes       [ ]* sum: .+, count: .+, min: .+, max: .+",
+        true},
        {"          preloadSplitPrepareTimeNanos[ ]* sum: .+, count: .+, min: .+, max: .+, avg: .+"},
        {"          preloadedSplits[ ]+sum: .+, count: .+, min: .+, max: .+",
         true},
        {"          processedSplits[ ]+sum: 20, count: 1, min: 20, max: 20, avg: 20"},
        {"          processedStrides[ ]+sum: 20, count: 1, min: 20, max: 20, avg: 20"},
-       {"          ramReadBytes        [ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"          processedUnits      [ ]* sum: .+, count: .+, min: .+, max: .+"},
+       {"          ramReadBytes        [ ]* sum: .+, count: .+, min: .+, max: .+",
+        true},
        {"          readyPreloadedSplits[ ]+sum: .+, count: .+, min: .+, max: .+",
         true},
        {"          runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"          runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"          runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
-       {"          storageReadBytes    [ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"          runningIsBlockedWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"          ssdCacheReadWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+",
+        true},
+       {"          storageReadBytes    [ ]* sum: .+, count: .+, min: .+, max: .+"},
+       {"          storageReadWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+",
+        true},
+       {"          totalRemainingFilterCpuNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
        {"          totalRemainingFilterWallNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
-       {"          totalScanTime       [ ]* sum: .+, count: .+, min: .+, max: .+"},
+       {"          totalScanTime       [ ]* sum: .+, count: .+, min: .+, max: .+",
+        true},
+       {"          unitLoadNanos[ ]* sum: .+, count: .+, min: .+, max: .+, avg: .+"},
        {"          waitForPreloadSplitNanos[ ]* sum: .+, count: .+, min: .+, max: .+, avg: .+"},
        {"    -- Project\\[1\\]\\[expressions: \\(u_c0:INTEGER, ROW\\[\"c0\"\\]\\), \\(u_c1:BIGINT, ROW\\[\"c1\"\\]\\)\\] -> u_c0:INTEGER, u_c1:BIGINT"},
        {"       Output: 100 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: 0B, Memory allocations: .+, Threads: 1, CPU breakdown: B/I/O/F (.+/.+/.+/.+)"},
+       {"          driverCpuTimeNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"          runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"          runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"          runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"          runningIsBlockedWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"      -- Values\\[0\\]\\[100 rows in 1 vectors\\] -> c0:INTEGER, c1:BIGINT"},
        {"         Input: 0 rows \\(.+\\), Output: 100 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: 0B, Memory allocations: .+, Threads: 1, CPU breakdown: B/I/O/F (.+/.+/.+/.+)"},
+       {"            driverCpuTimeNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"            runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"            runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
-       {"            runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"}});
+       {"            runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"            runningIsBlockedWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"}});
 }
 
 TEST_F(PrintPlanWithStatsTest, partialAggregateWithTableScan) {
@@ -269,51 +323,142 @@ TEST_F(PrintPlanWithStatsTest, partialAggregateWithTableScan) {
          {"  -- TableScan\\[0\\]\\[table: hive_table\\] -> c0:BIGINT, c1:INTEGER, c2:SMALLINT, c3:REAL, c4:DOUBLE, c5:VARCHAR"},
          {"     Input: 10000 rows \\(.+\\), Output: 10000 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, Splits: 1, CPU breakdown: B/I/O/F (.+/.+/.+/.+)"}});
 
+    std::vector<ExpectedLine> metrics = {
+        {"-- Aggregation\\[1\\]\\[PARTIAL \\[c5\\] a0 := max\\(ROW\\[\"c0\"\\]\\), a1 := sum\\(ROW\\[\"c1\"\\]\\), a2 := sum\\(ROW\\[\"c2\"\\]\\), a3 := sum\\(ROW\\[\"c3\"\\]\\), a4 := sum\\(ROW\\[\"c4\"\\]\\)\\] -> c5:VARCHAR, a0:BIGINT, a1:BIGINT, a2:BIGINT, a3:DOUBLE, a4:DOUBLE"},
+        {"   Output: .+, Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, CPU breakdown: B/I/O/F (.+/.+/.+/.+)"},
+        {"      dataSourceLazyCpuNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
+        {"      dataSourceLazyInputBytes\\s+sum: .+, count: .+, min: .+, max: .+"},
+        {"      dataSourceLazyWallNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
+        {"      distinctKey0\\s+sum: .+, count: 1, min: .+, max: .+"},
+        {"      driverCpuTimeNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+        {"      hashtable.capacity\\s+sum: (?:1273|1252), count: 1, min: (?:1273|1252), max: (?:1273|1252), avg: (?:1273|1252)"},
+        {"      hashtable.hashMode\\s+sum: \\d+, count: 1, min: \\d+, max: \\d+, avg: \\d+"},
+        {"      hashtable.numDistinct\\s+sum: (?:849|835), count: 1, min: (?:849|835), max: (?:849|835), avg: (?:849|835)"},
+        {"      hashtable.numRehashes\\s+sum: 1, count: 1, min: 1, max: 1, avg: 1"},
+        {"      loadedToValueHook\\s+sum: 50000, count: 5, min: 10000, max: 10000, avg: 10000"},
+        {"      runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+        {"      runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+        {"      runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+        {"      runningIsBlockedWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"}};
+
+    std::vector<ExpectedLine> scanDisablePrefetchMetrics = {
+        {"  -- TableScan\\[0\\]\\[table: hive_table\\] -> c0:BIGINT, c1:INTEGER, c2:SMALLINT, c3:REAL, c4:DOUBLE, c5:VARCHAR"},
+        {"     Input: 10000 rows \\(.+\\), Output: 10000 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, Splits: 1, CPU breakdown: B/I/O/F (.+/.+/.+/.+)"},
+        {"        blockedWaitForSplitTimes\\s+sum: 1, count: 1, min: 1, max: 1, avg: 1",
+         true},
+        {"        blockedWaitForSplitWallNanos\\s+sum: .+, count: 1, min: .+, max: .+",
+         true},
+        {"        cacheWaitWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+",
+         true},
+        {"        coalescedSsdLoadWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+",
+         true},
+        {"        coalescedStorageLoadWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+",
+         true},
+        {"        connectorSplitSize[ ]* sum: .+, count: .+, min: .+, max: .+"},
+        {"        dataSourceAddSplitWallNanos[ ]* sum: .+, count: 1, min: .+, max: .+"},
+        {"        dataSourceReadWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+"},
+        {"        driverCpuTimeNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+        {"        fileFormat\\.dwrf[ ]* sum: .+, count: 1, min: .+, max: .+, avg: .+",
+         true},
+        {"        footerBufferOverread[ ]* sum: .+, count: 1, min: .+, max: .+",
+         true},
+        {"        ioWaitWallNanos      [ ]* sum: .+, count: .+ min: .+, max: .+",
+         true},
+        {"        numPrefetch      [ ]* sum: .+, count: .+, min: .+, max: .+",
+         true},
+        {"        numRamRead       [ ]* sum: .+, count: 1, min: .+, max: .+, avg: .+",
+         true},
+        {"        numStripes[ ]* sum: .+, count: 1, min: .+, max: .+"},
+        {"        overreadBytes[ ]* sum: .+, count: 1, min: .+, max: .+", true},
+        {"        prefetchBytes    [ ]* sum: .+, count: .+, min: .+, max: .+",
+         true},
+        {"        processedSplits  [ ]* sum: 1, count: 1, min: 1, max: 1, avg: 1"},
+        {"        processedStrides [ ]* sum: 1, count: 1, min: 1, max: 1, avg: 1"},
+        {"        processedUnits   [ ]* sum: .+, count: .+, min: .+, max: .+"},
+        {"        preloadedSplits[ ]+sum: .+, count: .+, min: .+, max: .+",
+         true},
+        {"        ramReadBytes     [ ]* sum: .+, count: .+, min: .+, max: .+",
+         true},
+        {"        readyPreloadedSplits[ ]+sum: .+, count: .+, min: .+, max: .+",
+         true},
+        {"        runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+        {"        runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+        {"        runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+        {"        runningIsBlockedWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+        {"        ssdCacheReadWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+",
+         true},
+        {"        storageReadBytes [ ]* sum: .+, count: .+, min: .+, max: .+"},
+        {"        storageReadWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+",
+         true},
+        {"        totalRemainingFilterCpuNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
+        {"        totalRemainingFilterWallNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
+        {"        totalScanTime    [ ]* sum: .+, count: .+, min: .+, max: .+",
+         true},
+        {"        unitLoadNanos[ ]* sum: .+, count: .+, min: .+, max: .+, avg: .+"}};
+
+    std::vector<ExpectedLine> scanPrefetchMetrics = {
+        {"  -- TableScan\\[0\\]\\[table: hive_table\\] -> c0:BIGINT, c1:INTEGER, c2:SMALLINT, c3:REAL, c4:DOUBLE, c5:VARCHAR"},
+        {"     Input: 10000 rows \\(.+\\), Output: 10000 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, Splits: 1, CPU breakdown: B/I/O/F (.+/.+/.+/.+)"},
+        {"        blockedWaitForSplitTimes\\s+sum: 1, count: 1, min: 1, max: 1, avg: 1",
+         true},
+        {"        blockedWaitForSplitWallNanos\\s+sum: .+, count: 1, min: .+, max: .+",
+         true},
+        {"        cacheWaitWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+",
+         true},
+        {"        coalescedSsdLoadWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+",
+         true},
+        {"        coalescedStorageLoadWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+",
+         true},
+        {"        connectorSplitSize[ ]* sum: .+, count: .+, min: .+, max: .+"},
+        {"        dataSourceReadWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+"},
+        {"        driverCpuTimeNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+        {"        fileFormat\\.dwrf[ ]* sum: .+, count: 1, min: .+, max: .+, avg: .+",
+         true},
+        {"        footerBufferOverread[ ]* sum: .+, count: 1, min: .+, max: .+"},
+        {"        ioWaitWallNanos      [ ]* sum: .+, count: .+ min: .+, max: .+",
+         true},
+        {"        numPrefetch      [ ]* sum: .+, count: .+, min: .+, max: .+",
+         true},
+        {"        numRamRead       [ ]* sum: .+, count: 1, min: .+, max: .+, avg: .+",
+         true},
+        {"        numStripes[ ]* sum: .+, count: 1, min: .+, max: .+"},
+        {"        overreadBytes[ ]* sum: .+, count: 1, min: .+, max: .+", true},
+        {"        prefetchBytes    [ ]* sum: .+, count: .+, min: .+, max: .+",
+         true},
+        {"        preloadSplitPrepareTimeNanos [ ]* sum: .+, count: 1, min: .+, max: .+, avg: .+"},
+        {"        preloadedSplits [ ]* sum: 1, count: 1, min: 1, max: 1, avg: 1"},
+        {"        processedSplits  [ ]* sum: 1, count: 1, min: 1, max: 1, avg: 1"},
+        {"        processedStrides [ ]* sum: 1, count: 1, min: 1, max: 1, avg: 1"},
+        {"        processedUnits   [ ]* sum: .+, count: .+, min: .+, max: .+"},
+        {"        preloadedSplits[ ]+sum: .+, count: .+, min: .+, max: .+",
+         true},
+        {"        ramReadBytes     [ ]* sum: .+, count: .+, min: .+, max: .+",
+         true},
+        {"        readyPreloadedSplits[ ]+sum: .+, count: .+, min: .+, max: .+",
+         true},
+        {"        runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+        {"        runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+        {"        runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+        {"        runningIsBlockedWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+        {"        storageReadBytes [ ]* sum: .+, count: .+, min: .+, max: .+"},
+        {"        storageReadWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+",
+         true},
+        {"        totalRemainingFilterCpuNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
+        {"        totalRemainingFilterWallNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
+        {"        totalScanTime    [ ]* sum: .+, count: .+, min: .+, max: .+",
+         true},
+        {"        unitLoadNanos[ ]* sum: .+, count: .+, min: .+, max: .+, avg: .+"},
+        {"        waitForPreloadSplitNanos [ ]* sum: .+, count: 1, min: .+, max: .+, avg: .+"}};
+
+    auto scanMetrics = numPrefetchSplit == 0 ? scanDisablePrefetchMetrics
+                                             : scanPrefetchMetrics;
+    metrics.reserve(metrics.size() + scanMetrics.size());
+    metrics.insert(metrics.end(), scanMetrics.begin(), scanMetrics.end());
+
     compareOutputs(
         ::testing::UnitTest::GetInstance()->current_test_info()->name(),
         printPlanWithStats(*op, task->taskStats(), true),
-        {{"-- Aggregation\\[1\\]\\[PARTIAL \\[c5\\] a0 := max\\(ROW\\[\"c0\"\\]\\), a1 := sum\\(ROW\\[\"c1\"\\]\\), a2 := sum\\(ROW\\[\"c2\"\\]\\), a3 := sum\\(ROW\\[\"c3\"\\]\\), a4 := sum\\(ROW\\[\"c4\"\\]\\)\\] -> c5:VARCHAR, a0:BIGINT, a1:BIGINT, a2:BIGINT, a3:DOUBLE, a4:DOUBLE"},
-         {"   Output: .+, Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, CPU breakdown: B/I/O/F (.+/.+/.+/.+)"},
-         {"      dataSourceLazyCpuNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
-         {"      dataSourceLazyInputBytes\\s+sum: .+, count: .+, min: .+, max: .+"},
-         {"      dataSourceLazyWallNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
-         {"      distinctKey0\\s+sum: .+, count: 1, min: .+, max: .+"},
-         {"      hashtable.capacity\\s+sum: (?:1273|1252), count: 1, min: (?:1273|1252), max: (?:1273|1252), avg: (?:1273|1252)"},
-         {"      hashtable.numDistinct\\s+sum: (?:849|835), count: 1, min: (?:849|835), max: (?:849|835), avg: (?:849|835)"},
-         {"      hashtable.numRehashes\\s+sum: 1, count: 1, min: 1, max: 1, avg: 1"},
-         {"      hashtable.numTombstones\\s+sum: 0, count: 1, min: 0, max: 0, avg: 0"},
-         {"      loadedToValueHook\\s+sum: 50000, count: 5, min: 10000, max: 10000, avg: 10000"},
-         {"      runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
-         {"      runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
-         {"      runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
-         {"  -- TableScan\\[0\\]\\[table: hive_table\\] -> c0:BIGINT, c1:INTEGER, c2:SMALLINT, c3:REAL, c4:DOUBLE, c5:VARCHAR"},
-         {"     Input: 10000 rows \\(.+\\), Output: 10000 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, Splits: 1, CPU breakdown: B/I/O/F (.+/.+/.+/.+)"},
-         {"        connectorSplitSize[ ]* sum: .+, count: .+, min: .+, max: .+"},
-         {"        dataSourceAddSplitWallNanos[ ]* sum: .+, count: 1, min: .+, max: .+"},
-         {"        dataSourceReadWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+"},
-         {"        footerBufferOverread[ ]* sum: .+, count: 1, min: .+, max: .+"},
-         {"        ioWaitWallNanos      [ ]* sum: .+, count: .+ min: .+, max: .+"},
-         {"        maxSingleIoWaitWallNanos[ ]*sum: .+, count: 1, min: .+, max: .+"},
-         {"        numPrefetch      [ ]* sum: .+, count: .+, min: .+, max: .+"},
-         {"        numRamRead       [ ]* sum: 7, count: 1, min: 7, max: 7, avg: 7"},
-         {"        numStorageRead   [ ]* sum: .+, count: 1, min: .+, max: .+"},
-         {"        numStripes[ ]* sum: .+, count: 1, min: .+, max: .+"},
-         {"        overreadBytes[ ]* sum: 0B, count: 1, min: 0B, max: 0B, avg: 0B"},
-
-         {"        prefetchBytes    [ ]* sum: .+, count: 1, min: .+, max: .+"},
-         {"        processedSplits  [ ]* sum: 1, count: 1, min: 1, max: 1, avg: 1"},
-         {"        processedStrides [ ]* sum: 1, count: 1, min: 1, max: 1, avg: 1"},
-         {"        preloadedSplits[ ]+sum: .+, count: .+, min: .+, max: .+",
-          true},
-         {"        ramReadBytes     [ ]* sum: .+, count: 1, min: .+, max: .+"},
-         {"        readyPreloadedSplits[ ]+sum: .+, count: .+, min: .+, max: .+",
-          true},
-         {"        runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
-         {"        runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
-         {"        runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
-         {"        storageReadBytes [ ]* sum: .+, count: 1, min: .+, max: .+"},
-         {"        totalRemainingFilterWallNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
-         {"        totalScanTime    [ ]* sum: .+, count: .+, min: .+, max: .+"}});
+        metrics);
   }
 }
 
@@ -340,7 +485,7 @@ TEST_F(PrintPlanWithStatsTest, tableWriterWithTableScan) {
   compareOutputs(
       ::testing::UnitTest::GetInstance()->current_test_info()->name(),
       printPlanWithStats(*writePlan, task->taskStats()),
-      {{R"(-- TableWrite\[1\]\[.+InsertTableHandle .+)"},
+      {{R"(-- TableWrite\[1\]\[test-hive, c0, c1, c2, c3, c4, c5\] -> rows:BIGINT, fragments:VARBINARY, commitcontext:VARBINARY)"},
        {"   Output: .+, Physical written output: .+, Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, CPU breakdown: B/I/O/F (.+/.+/.+/.+)"},
        {R"(  -- TableScan\[0\]\[table: hive_table\] -> c0:BIGINT, c1:INTEGER, c2:SMALLINT, c3:REAL, c4:DOUBLE, c5:VARCHAR)"},
        {R"(     Input: 100 rows \(.+\), Output: 100 rows \(.+\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, Splits: 1, CPU breakdown: B/I/O/F (.+/.+/.+/.+))"}});
@@ -348,46 +493,78 @@ TEST_F(PrintPlanWithStatsTest, tableWriterWithTableScan) {
   compareOutputs(
       ::testing::UnitTest::GetInstance()->current_test_info()->name(),
       printPlanWithStats(*writePlan, task->taskStats(), true),
-      {{R"(-- TableWrite\[1\]\[.+InsertTableHandle .+)"},
-       {"   Output: .+, Physical written output: .+, Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, CPU breakdown: B/I/O/F (.+/.+/.+/.+)"},
-       {"      dataSourceLazyCpuNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
-       {"      dataSourceLazyInputBytes\\s+sum: .+, count: .+, min: .+, max: .+"},
-       {"      dataSourceLazyWallNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
-       {"      numWrittenFiles\\s+sum: .+, count: 1, min: .+, max: .+"},
-       {"      runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
-       {"      runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
-       {"      runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
-       {"      runningWallNanos\\s+sum: .+, count: 1, min: .+, max: .+, avg: .+"},
-       {"      stripeSize\\s+sum: .+, count: 1, min: .+, max: .+"},
-       {"      writeIOWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
-       {R"(  -- TableScan\[0\]\[table: hive_table\] -> c0:BIGINT, c1:INTEGER, c2:SMALLINT, c3:REAL, c4:DOUBLE, c5:VARCHAR)"},
-       {R"(     Input: 100 rows \(.+\), Output: 100 rows \(.+\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, Splits: 1, CPU breakdown: B/I/O/F (.+/.+/.+/.+))"},
-       {"        connectorSplitSize[ ]* sum: .+, count: .+, min: .+, max: .+"},
-       {"        dataSourceAddSplitWallNanos[ ]* sum: .+, count: 1, min: .+, max: .+"},
-       {"        dataSourceReadWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+"},
-       {"        footerBufferOverread[ ]* sum: .+, count: 1, min: .+, max: .+"},
-       {"        ioWaitWallNanos      [ ]* sum: .+, count: .+ min: .+, max: .+"},
-       {"        maxSingleIoWaitWallNanos[ ]*sum: .+, count: 1, min: .+, max: .+"},
-       {"        numPrefetch      [ ]* sum: .+, count: .+, min: .+, max: .+"},
-       {"        numRamRead       [ ]* sum: 7, count: 1, min: 7, max: 7, avg: 7"},
-       {"        numStorageRead   [ ]* sum: .+, count: 1, min: .+, max: .+"},
-       {"        numStripes[ ]* sum: .+, count: 1, min: .+, max: .+"},
-       {"        overreadBytes[ ]* sum: 0B, count: 1, min: 0B, max: 0B, avg: 0B"},
-
-       {"        prefetchBytes    [ ]* sum: .+, count: 1, min: .+, max: .+"},
-       {"        processedSplits  [ ]* sum: 1, count: 1, min: 1, max: 1, avg: 1"},
-       {"        processedStrides [ ]* sum: 1, count: 1, min: 1, max: 1, avg: 1"},
-       {"        preloadedSplits[ ]+sum: .+, count: .+, min: .+, max: .+",
-        true},
-       {"        ramReadBytes     [ ]* sum: .+, count: 1, min: .+, max: .+"},
-       {"        readyPreloadedSplits[ ]+sum: .+, count: .+, min: .+, max: .+",
-        true},
-       {"        runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
-       {"        runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
-       {"        runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
-       {"        storageReadBytes [ ]* sum: .+, count: 1, min: .+, max: .+"},
-       {"        totalRemainingFilterWallNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
-       {"        totalScanTime    [ ]* sum: .+, count: .+, min: .+, max: .+"}});
+      {
+          {R"(-- TableWrite\[1\]\[test-hive, c0, c1, c2, c3, c4, c5\] -> rows:BIGINT, fragments:VARBINARY, commitcontext:VARBINARY)"},
+          {"   Output: .+, Physical written output: .+, Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, CPU breakdown: B/I/O/F (.+/.+/.+/.+)"},
+          {"      dataSourceLazyCpuNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
+          {"      dataSourceLazyInputBytes\\s+sum: .+, count: .+, min: .+, max: .+"},
+          {"      dataSourceLazyWallNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
+          {"      driverCpuTimeNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+          {"      dwrfWriterCount\\s+sum: .+, count: 1, min: .+, max: .+"},
+          {"      numWrittenFiles\\s+sum: .+, count: 1, min: .+, max: .+"},
+          {"      runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+          {"      runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+          {"      runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+          {"      runningIsBlockedWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+          {"      runningWallNanos\\s+sum: .+, count: 1, min: .+, max: .+, avg: .+"},
+          {"      stripeSize\\s+sum: .+, count: 1, min: .+, max: .+"},
+          {"      writeIOWallNanos\\s+sum: .+, count: 1, min: .+, max: .+, avg: .+"},
+          {R"(  -- TableScan\[0\]\[table: hive_table\] -> c0:BIGINT, c1:INTEGER, c2:SMALLINT, c3:REAL, c4:DOUBLE, c5:VARCHAR)"},
+          {R"(     Input: 100 rows \(.+\), Output: 100 rows \(.+\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, Splits: 1, CPU breakdown: B/I/O/F (.+/.+/.+/.+))"},
+          // These lines may or may not appear depending on whether the operator
+          // gets blocked waiting for a split during a run.
+          {"        blockedWaitForSplitTimes\\s+sum: 1, count: 1, min: 1, max: 1, avg: 1",
+           true},
+          {"        blockedWaitForSplitWallNanos\\s+sum: .+, count: 1, min: .+, max: .+",
+           true},
+          {"        cacheWaitWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+",
+           true},
+          {"        coalescedSsdLoadWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+",
+           true},
+          {"        coalescedStorageLoadWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+",
+           true},
+          {"        connectorSplitSize[ ]* sum: .+, count: .+, min: .+, max: .+"},
+          {"        dataSourceReadWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+"},
+          {"        driverCpuTimeNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+          {"        fileFormat\\.dwrf[ ]* sum: .+, count: 1, min: .+, max: .+, avg: .+",
+           true},
+          {"        footerBufferOverread[ ]* sum: .+, count: 1, min: .+, max: .+"},
+          {"        ioWaitWallNanos      [ ]* sum: .+, count: .+ min: .+, max: .+",
+           true},
+          {"        numPrefetch      [ ]* sum: .+, count: .+, min: .+, max: .+",
+           true},
+          {"        numRamRead       [ ]* sum: .+, count: 1, min: .+, max: .+, avg: .+",
+           true},
+          {"        numStripes[ ]* sum: .+, count: 1, min: .+, max: .+"},
+          {"        overreadBytes[ ]* sum: .+, count: 1, min: .+, max: .+",
+           true},
+          {"        prefetchBytes    [ ]* sum: .+, count: .+, min: .+, max: .+",
+           true},
+          {"        preloadSplitPrepareTimeNanos [ ]* sum: .+, count: 1, min: .+, max: .+, avg: .+"},
+          {"        preloadedSplits [ ]* sum: 1, count: 1, min: 1, max: 1, avg: 1"},
+          {"        processedSplits  [ ]* sum: 1, count: 1, min: 1, max: 1, avg: 1"},
+          {"        processedStrides [ ]* sum: 1, count: 1, min: 1, max: 1, avg: 1"},
+          {"        processedUnits   [ ]* sum: .+, count: .+, min: .+, max: .+"},
+          {"        preloadedSplits[ ]+sum: .+, count: .+, min: .+, max: .+",
+           true},
+          {"        ramReadBytes     [ ]* sum: .+, count: .+, min: .+, max: .+",
+           true},
+          {"        readyPreloadedSplits[ ]+sum: .+, count: .+, min: .+, max: .+",
+           true},
+          {"        runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+          {"        runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+          {"        runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+          {"        runningIsBlockedWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+          {"        storageReadBytes [ ]* sum: .+, count: .+, min: .+, max: .+"},
+          {"        storageReadWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+",
+           true},
+          {"        totalRemainingFilterCpuNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
+          {"        totalRemainingFilterWallNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
+          {"        totalScanTime    [ ]* sum: .+, count: .+, min: .+, max: .+",
+           true},
+          {"        unitLoadNanos[ ]* sum: .+, count: .+, min: .+, max: .+, avg: .+"},
+          {"        waitForPreloadSplitNanos [ ]* sum: .+, count: 1, min: .+, max: .+, avg: .+"},
+      });
 }
 
 TEST_F(PrintPlanWithStatsTest, taskAPI) {
diff --git a/velox/exec/tests/QueryAssertionsTest.cpp b/velox/exec/tests/QueryAssertionsTest.cpp
index 21b5d60099a..eb08c7b14b7 100644
--- a/velox/exec/tests/QueryAssertionsTest.cpp
+++ b/velox/exec/tests/QueryAssertionsTest.cpp
@@ -182,7 +182,7 @@ TEST_F(QueryAssertionsTest, singleFloatColumn) {
           size,
           [&](auto row) {
             return row == 302
-                ? 2.01 + std::max(kEpsilon, double(6 * FLT_EPSILON))
+                ? 2.01 + std::max(Variant::kEpsilon, double(6 * FLT_EPSILON))
                 : row % 6 + 0.01;
           },
           nullEvery(7)),
@@ -282,15 +282,17 @@ TEST_F(QueryAssertionsTest, multiFloatColumnWithUniqueKeys) {
       makeFlatVector<float>(
           size,
           [&](auto row) {
-            return row == 6 ? 2 + std::max(float(kEpsilon), 6 * FLT_EPSILON)
-                            : row % 4;
+            return row == 6
+                ? 2 + std::max(float(Variant::kEpsilon), 6 * FLT_EPSILON)
+                : row % 4;
           },
           nullEvery(5)),
       makeFlatVector<double>(
           size,
           [&](auto row) {
-            return row == 1 ? 1.01 + std::max(kEpsilon, double(3 * FLT_EPSILON))
-                            : row % 6 + 0.01;
+            return row == 1
+                ? 1.01 + std::max(Variant::kEpsilon, double(3 * FLT_EPSILON))
+                : row % 6 + 0.01;
           },
           nullEvery(7)),
   });
diff --git a/velox/exec/tests/RowContainerTest.cpp b/velox/exec/tests/RowContainerTest.cpp
index 94884361d0a..05777919e2e 100644
--- a/velox/exec/tests/RowContainerTest.cpp
+++ b/velox/exec/tests/RowContainerTest.cpp
@@ -108,7 +108,8 @@ class RowContainerTestHelper {
   RowContainer* const rowContainer_;
 };
 
-class RowContainerTest : public exec::test::RowContainerTestBase {
+class RowContainerTest : public exec::test::RowContainerTestBase,
+                         public testing::WithParamInterface<bool> {
  protected:
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
@@ -344,7 +345,9 @@ class RowContainerTest : public exec::test::RowContainerTestBase {
       sum += data.rowSize(row) - data.fixedRowSize();
     }
     auto usage = data.stringAllocator().currentBytes();
-    EXPECT_EQ(usage, sum);
+    if (data.testingRowPointers().empty()) {
+      EXPECT_EQ(usage, sum);
+    }
   }
 
   std::vector<char*> store(
@@ -484,11 +487,12 @@ class RowContainerTest : public exec::test::RowContainerTestBase {
       const VectorPtr& expected,
       std::optional<CompareFlags> flags) {
     // If no flags provided then it must be the default of {true, true}.
-    SCOPED_TRACE(fmt::format(
-        "{}, ascending = {}, nullsFirst = {}",
-        type->toString(),
-        flags.has_value() ? flags.value().ascending : true,
-        flags.has_value() ? flags.value().nullsFirst : true));
+    SCOPED_TRACE(
+        fmt::format(
+            "{}, ascending = {}, nullsFirst = {}",
+            type->toString(),
+            flags.has_value() ? flags.value().ascending : true,
+            flags.has_value() ? flags.value().nullsFirst : true));
 
     // Set 'isJoinBuild' to true to enable nullable sort key in test.
     auto rowContainer = makeRowContainer({type}, {type}, false);
@@ -570,8 +574,8 @@ class RowContainerTest : public exec::test::RowContainerTestBase {
     for (auto row : rows) {
       ASSERT_EQ(
           expected[index],
-          rowContainer->equals<canHandleNulls>(
-              row, rowContainer->columnAt(0), rhsDecoded, index))
+          rowContainer->compare<canHandleNulls>(
+              row, rowContainer->columnAt(0), rhsDecoded, index) == 0)
           << fmt::format(
                  "Mismatch at index {} with canHandleNulls {}",
                  index,
@@ -831,8 +835,8 @@ class RowContainerTest : public exec::test::RowContainerTestBase {
         kNumRows, rawValues, rawExpected);
     // Remove nulls in data because keys cannot be null.
     auto numNulls = countLeadingNulls(rawValues);
-    rawValues.erase(rawValues.begin(), rawValues.begin() + numNulls);
-    rawExpected.erase(rawExpected.begin(), rawExpected.begin() + numNulls);
+    rawValues.erase(rawValues.cbegin(), rawValues.cbegin() + numNulls);
+    rawExpected.erase(rawExpected.cbegin(), rawExpected.cbegin() + numNulls);
     std::optional<int32_t> second = 0;
     for (auto value : rawValues) {
       std::vector<std::pair<T, std::optional<int32_t>>> temp{
@@ -935,7 +939,7 @@ static int32_t sign(int32_t n) {
 }
 } // namespace
 
-TEST_F(RowContainerTest, extractWithNullsAndTargetOffset) {
+TEST_P(RowContainerTest, extractWithNullsAndTargetOffset) {
   constexpr int32_t kNumRows = 100;
   // The second column must have no nulls in the first batch.
   auto rowVector1 = makeRowVector({
@@ -961,8 +965,8 @@ TEST_F(RowContainerTest, extractWithNullsAndTargetOffset) {
   // Create and fill up two row containers from two row vectors.
   std::vector<TypePtr> vecTypes = {BOOLEAN(), VARCHAR(), TINYINT()};
   RowTypePtr rowType = VectorMaker::rowType({BOOLEAN(), VARCHAR(), TINYINT()});
-  auto data1 = makeRowContainer({}, vecTypes);
-  auto data2 = makeRowContainer({}, vecTypes);
+  auto data1 = makeRowContainer({}, vecTypes, true, GetParam());
+  auto data2 = makeRowContainer({}, vecTypes, true, GetParam());
   for (auto i = 0; i < kNumRows; i++) {
     data1->newRow();
     data2->newRow();
@@ -1045,7 +1049,7 @@ TEST_F(RowContainerTest, storeExtractArrayOfVarchar) {
   roundTrip(input);
 }
 
-TEST_F(RowContainerTest, types) {
+TEST_P(RowContainerTest, types) {
   constexpr int32_t kNumRows = 100;
   auto batch = makeDataset(
       ROW(
@@ -1105,7 +1109,7 @@ TEST_F(RowContainerTest, types) {
   std::vector<TypePtr> dependents;
   dependents.insert(
       dependents.begin(), types.begin() + types.size() / 2, types.end());
-  auto data = makeRowContainer(keys, dependents);
+  auto data = makeRowContainer(keys, dependents, true, GetParam());
 
   EXPECT_GT(data->nextOffset(), 0);
   EXPECT_GT(data->probedFlagOffset(), 0);
@@ -1177,11 +1181,13 @@ TEST_F(RowContainerTest, types) {
       EXPECT_EQ(source->hashValueAt(i), hashes[i]);
       // Test non-null and nullable variants of equals.
       if (column < keys.size()) {
-        EXPECT_TRUE(
-            data->equals<false>(rows[i], data->columnAt(column), decoded, i));
+        EXPECT_EQ(
+            data->compare<false>(rows[i], data->columnAt(column), decoded, i),
+            0);
       } else if (!columnType->isMap()) {
-        EXPECT_TRUE(
-            data->equals<true>(rows[i], data->columnAt(column), decoded, i));
+        EXPECT_EQ(
+            data->compare<true>(rows[i], data->columnAt(column), decoded, i),
+            0);
       }
       // Non-key map columns are not comparable, as the map keys are not sorted.
       if (columnType->isMap() && column >= keys.size()) {
@@ -1215,7 +1221,7 @@ TEST_F(RowContainerTest, types) {
   EXPECT_LT(0, free.second);
 }
 
-TEST_F(RowContainerTest, extractNulls) {
+TEST_P(RowContainerTest, extractNulls) {
   constexpr int32_t kNumRows = 100;
   auto batch = makeRowVector({
       makeFlatVector<bool>(
@@ -1266,7 +1272,7 @@ TEST_F(RowContainerTest, extractNulls) {
       ARRAY(INTEGER()),
       MAP(INTEGER(), INTEGER()),
       ROW({INTEGER(), INTEGER()})};
-  auto data = makeRowContainer({}, rowType);
+  auto data = makeRowContainer({}, rowType, true, GetParam());
   for (int i = 0; i < kNumRows; i++) {
     data->newRow();
   }
@@ -1347,11 +1353,11 @@ TEST_F(RowContainerTest, erase) {
   RowContainerTestHelper(data.get()).checkConsistency();
 }
 
-TEST_F(RowContainerTest, initialNulls) {
+TEST_P(RowContainerTest, initialNulls) {
   std::vector<TypePtr> keys{INTEGER()};
   std::vector<TypePtr> dependent{INTEGER()};
   // Join build.
-  auto data = makeRowContainer(keys, dependent, true);
+  auto data = makeRowContainer(keys, dependent, true, GetParam());
   auto row = data->newRow();
   auto isNullAt = [](const RowContainer& data, const char* row, int32_t i) {
     auto column = data.columnAt(i);
@@ -1361,7 +1367,7 @@ TEST_F(RowContainerTest, initialNulls) {
   EXPECT_FALSE(isNullAt(*data, row, 0));
   EXPECT_FALSE(isNullAt(*data, row, 1));
   // Non-join build.
-  data = makeRowContainer(keys, dependent, false);
+  data = makeRowContainer(keys, dependent, false, GetParam());
   row = data->newRow();
   EXPECT_FALSE(isNullAt(*data, row, 0));
   EXPECT_FALSE(isNullAt(*data, row, 1));
@@ -1369,7 +1375,7 @@ TEST_F(RowContainerTest, initialNulls) {
 
 TEST_F(RowContainerTest, rowSize) {
   constexpr int32_t kNumRows = 100;
-  auto data = makeRowContainer({SMALLINT()}, {VARCHAR()});
+  auto data = makeRowContainer({SMALLINT()}, {VARCHAR()}, true);
 
   // The layout is expected to be smallint - 6 bytes of padding - 1 byte of bits
   // - StringView - rowSize - next pointer. The bits are a null flag for the
@@ -1405,10 +1411,10 @@ TEST_F(RowContainerTest, rowSize) {
   EXPECT_EQ(rows, rowsFromContainer);
 }
 
-TEST_F(RowContainerTest, columnSize) {
+TEST_P(RowContainerTest, columnSize) {
   const uint64_t kNumRows = 1000;
-  auto rowContainer =
-      makeRowContainer({BIGINT(), VARCHAR()}, {BIGINT(), VARCHAR()});
+  auto rowContainer = makeRowContainer(
+      {BIGINT(), VARCHAR()}, {BIGINT(), VARCHAR()}, true, GetParam());
 
   VectorFuzzer fuzzer(
       {
@@ -1452,8 +1458,8 @@ TEST_F(RowContainerTest, columnSize) {
   }
 }
 
-TEST_F(RowContainerTest, rowSizeWithNormalizedKey) {
-  auto data = makeRowContainer({SMALLINT()}, {VARCHAR()});
+TEST_P(RowContainerTest, rowSizeWithNormalizedKey) {
+  auto data = makeRowContainer({SMALLINT()}, {VARCHAR()}, true, GetParam());
   data->newRow();
   data->disableNormalizedKeys();
   data->newRow();
@@ -1469,7 +1475,7 @@ TEST_F(RowContainerTest, estimateRowSize) {
 
   // Make a RowContainer with a fixed-length key column and a variable-length
   // dependent column.
-  auto rowContainer = makeRowContainer({BIGINT()}, {VARCHAR()});
+  auto rowContainer = makeRowContainer({BIGINT()}, {VARCHAR()}, true);
   EXPECT_FALSE(rowContainer->estimateRowSize().has_value());
 
   // Store rows to the container.
@@ -1511,7 +1517,9 @@ TEST_F(RowContainerTest, alignment) {
       false,
       false,
       true,
+      false, // hasCountFlag
       true,
+      false,
       pool_.get());
   constexpr int kNumRows = 100;
   char* rows[kNumRows];
@@ -1678,7 +1686,9 @@ TEST_F(RowContainerTest, probedFlag) {
       true, // hasNext
       true, // isJoinBuild
       true, // hasProbedFlag
+      false, // hasCountFlag
       false, // hasNormalizedKey
+      false, // useListRowIndex
       pool_.get());
 
   auto input = makeRowVector({
@@ -1782,6 +1792,32 @@ TEST_F(RowContainerTest, probedFlag) {
       result);
 }
 
+TEST_F(RowContainerTest, countFlag) {
+  RowContainer rows(
+      {INTEGER()},
+      true, // nullableKeys
+      std::vector<Accumulator>{},
+      {}, // dependentTypes
+      false, // hasNext
+      true, // isJoinBuild
+      false, // hasProbedFlag
+      true, // hasCountFlag
+      false, // hasNormalizedKey
+      false, // useListRowIndex
+      pool_.get());
+
+  ASSERT_NE(rows.countOffset(), 0);
+
+  auto* row = rows.newRow();
+  EXPECT_EQ(rows.count(row), 1);
+  rows.incrementCount(row);
+  EXPECT_EQ(rows.count(row), 2);
+  rows.decrementCount(row);
+  EXPECT_EQ(rows.count(row), 1);
+  rows.decrementCount(row);
+  EXPECT_EQ(rows.count(row), 0);
+}
+
 TEST_F(RowContainerTest, mixedFree) {
   constexpr int32_t kNumRows = 100'000;
   constexpr int32_t kNumBad = 100;
@@ -1868,8 +1904,10 @@ TEST_F(RowContainerTest, unknown) {
   }
 
   for (size_t row = 0; row < size; ++row) {
-    ASSERT_TRUE(rowContainer->equals<false>(
-        rows[row], rowContainer->columnAt(0), decoded, row));
+    ASSERT_EQ(
+        rowContainer->compare</*mayHaveNulls=*/true>(
+            rows[row], rowContainer->columnAt(0), decoded, row),
+        0);
   }
 
   {
@@ -1892,24 +1930,29 @@ TEST_F(RowContainerTest, unknown) {
   // Verify compare method with row and decoded vector as input
   // Sorting a NULL constant Vector doesn't change the Vector, so we just
   // validate that it runs without throwing an exception.
-  EXPECT_NO_THROW(std::sort(
-      indexedRows.begin(),
-      indexedRows.end(),
-      [&](const std::pair<int, char*>& l, const std::pair<int, char*>& r) {
-        return rowContainer->compare(
-                   l.second, rowContainer->columnAt(0), decoded, r.first, {}) <
-            0;
-      }));
+  EXPECT_NO_THROW(
+      std::sort(
+          indexedRows.begin(),
+          indexedRows.end(),
+          [&](const std::pair<int, char*>& l, const std::pair<int, char*>& r) {
+            return rowContainer->compare(
+                       l.second,
+                       rowContainer->columnAt(0),
+                       decoded,
+                       r.first,
+                       {}) < 0;
+          }));
 
   // Verify compareRows method with row as input.
   // Sorting a NULL constant Vector doesn't change the Vector, so we just
   // validate that it runs without throwing an exception.
-  EXPECT_NO_THROW(std::sort(
-      indexedRows.begin(),
-      indexedRows.end(),
-      [&](const std::pair<int, char*>& l, const std::pair<int, char*>& r) {
-        return rowContainer->compareRows(l.second, r.second) < 0;
-      }));
+  EXPECT_NO_THROW(
+      std::sort(
+          indexedRows.begin(),
+          indexedRows.end(),
+          [&](const std::pair<int, char*>& l, const std::pair<int, char*>& r) {
+            return rowContainer->compareRows(l.second, r.second) < 0;
+          }));
 }
 
 TEST_F(RowContainerTest, nans) {
@@ -1945,8 +1988,10 @@ TEST_F(RowContainerTest, nans) {
 
   // Verify that they are considered equal.
   for (size_t row = 0; row < size; ++row) {
-    ASSERT_TRUE(rowContainer->equals<false>(
-        rows[row], rowContainer->columnAt(0), decoded, row));
+    ASSERT_EQ(
+        rowContainer->compare<false>(
+            rows[row], rowContainer->columnAt(0), decoded, row),
+        0);
   }
   ASSERT_EQ(rowContainer->compare(rows[0], rows[1], 0, {}), 0);
 }
@@ -2133,7 +2178,7 @@ DEBUG_ONLY_TEST_F(RowContainerTest, eraseAfterOomStoringString) {
   rowContainer->eraseRows(folly::Range<char**>(rows.data(), numRows));
 }
 
-TEST_F(RowContainerTest, hugeIntStoreWithNulls) {
+TEST_P(RowContainerTest, hugeIntStoreWithNulls) {
   constexpr int32_t kNumRows = 100;
   constexpr int32_t kColumnIndex = 0;
 
@@ -2166,7 +2211,7 @@ TEST_F(RowContainerTest, hugeIntStoreWithNulls) {
       dictNulls, dictIndices, kNumRows, hugeIntVector);
 
   std::vector<TypePtr> keys;
-  auto data = makeRowContainer({HUGEINT()}, {}, false);
+  auto data = makeRowContainer({HUGEINT()}, {}, false, GetParam());
   std::vector<char*> rows(kNumRows);
   for (auto i = 0; i < kNumRows; ++i) {
     rows[i] = data->newRow();
@@ -2181,9 +2226,9 @@ TEST_F(RowContainerTest, hugeIntStoreWithNulls) {
   assertEqualVectors(source, extracted);
 }
 
-TEST_F(RowContainerTest, columnHasNulls) {
-  auto rowContainer =
-      makeRowContainer({BIGINT(), BIGINT()}, {BIGINT(), BIGINT()}, false);
+TEST_P(RowContainerTest, columnHasNulls) {
+  auto rowContainer = makeRowContainer(
+      {BIGINT(), BIGINT()}, {BIGINT(), BIGINT()}, false, GetParam());
   for (int i = 0; i < rowContainer->columnTypes().size(); ++i) {
     ASSERT_FALSE(rowContainer->columnHasNulls(i));
   }
@@ -2234,7 +2279,7 @@ TEST_F(RowContainerTest, columnHasNulls) {
   }
 }
 
-TEST_F(RowContainerTest, store) {
+TEST_P(RowContainerTest, store) {
   const uint64_t kNumRows = 1000;
   auto rowVectorWithNulls = makeRowVector({
       makeFlatVector<int64_t>(
@@ -2264,7 +2309,7 @@ TEST_F(RowContainerTest, store) {
   });
   for (auto& rowVector : {rowVectorWithNulls, rowVectorNoNulls}) {
     auto rowContainer = makeRowContainer(
-        {BIGINT(), VARCHAR()}, {BIGINT(), ARRAY(BIGINT())}, false);
+        {BIGINT(), VARCHAR()}, {BIGINT(), ARRAY(BIGINT())}, false, GetParam());
     std::vector<char*> rows;
     rows.reserve(kNumRows);
 
@@ -2408,7 +2453,7 @@ TEST_F(RowContainerTest, customComparisonRow) {
       });
 }
 
-TEST_F(RowContainerTest, isNanAt) {
+TEST_P(RowContainerTest, isNanAt) {
   const auto kNan = std::numeric_limits<double>::quiet_NaN();
   const auto kNanF = std::numeric_limits<float>::quiet_NaN();
   auto rowVector = makeRowVector({
@@ -2419,8 +2464,8 @@ TEST_F(RowContainerTest, isNanAt) {
   });
   const auto kNumRows = rowVector->size();
 
-  auto rowContainer =
-      makeRowContainer({REAL(), DOUBLE()}, {REAL(), DOUBLE()}, false);
+  auto rowContainer = makeRowContainer(
+      {REAL(), DOUBLE()}, {REAL(), DOUBLE()}, false, GetParam());
   std::vector<char*> rows;
   rows.reserve(kNumRows);
 
@@ -2653,7 +2698,7 @@ TEST_F(RowContainerTest, rowColumnStats) {
   EXPECT_EQ(stats.nullCount(), 3);
 }
 
-TEST_F(RowContainerTest, storeAndCollectColumnStats) {
+TEST_P(RowContainerTest, storeAndCollectColumnStats) {
   const uint64_t kNumRows = 1000;
   auto rowVector = makeRowVector({
       makeFlatVector<int64_t>(
@@ -2664,7 +2709,8 @@ TEST_F(RowContainerTest, storeAndCollectColumnStats) {
           nullEvery(7)),
   });
 
-  auto rowContainer = makeRowContainer({BIGINT(), VARCHAR()}, {}, false);
+  auto rowContainer =
+      makeRowContainer({BIGINT(), VARCHAR()}, {}, false, GetParam());
   std::vector<char*> rows;
   rows.reserve(kNumRows);
 
@@ -2722,6 +2768,8 @@ TEST_F(RowContainerTest, setAllNull) {
       false,
       true,
       false,
+      false, // hasCountFlag
+      false,
       false,
       pool_.get());
 
@@ -2746,4 +2794,9 @@ TEST_F(RowContainerTest, setAllNull) {
       (row[accColumn.initializedByte()] & accColumn.initializedMask()), 0);
 }
 
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    RowContainerTest,
+    RowContainerTest,
+    testing::ValuesIn({false, true}));
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/RowNumberTest.cpp b/velox/exec/tests/RowNumberTest.cpp
index 84e272d4273..ba832c12daf 100644
--- a/velox/exec/tests/RowNumberTest.cpp
+++ b/velox/exec/tests/RowNumberTest.cpp
@@ -16,13 +16,14 @@
 
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 namespace facebook::velox::exec::test {
+using namespace facebook::velox::common::testutil;
 
 class RowNumberTest : public OperatorTestBase {
  protected:
@@ -204,7 +205,7 @@ TEST_F(RowNumberTest, spill) {
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto spillDirectory = TempDirectoryPath::create();
     auto queryCtx = core::QueryCtx::create(executor_.get());
     TestScopedSpillInjection scopedSpillInjection(100, ".*", 1);
 
@@ -218,11 +219,12 @@ TEST_F(RowNumberTest, spill) {
                 core::QueryConfig::kSpillNumPartitionBits,
                 testData.spillPartitionBits)
             .queryCtx(queryCtx)
-            .plan(PlanBuilder()
-                      .values(vectors)
-                      .rowNumber({"c0"})
-                      .capturePlanNodeId(rowNumberPlanNodeId)
-                      .planNode())
+            .plan(
+                PlanBuilder()
+                    .values(vectors)
+                    .rowNumber({"c0"})
+                    .capturePlanNodeId(rowNumberPlanNodeId)
+                    .planNode())
             .assertResults(
                 "SELECT *, row_number() over (partition by c0) FROM tmp");
     auto taskStats = toPlanStats(task->taskStats());
@@ -237,11 +239,13 @@ TEST_F(RowNumberTest, spill) {
         task->taskStats().pipelineStats.back().operatorStats.at(1);
     auto runtimeStats = operatorStats.runtimeStats;
     ASSERT_EQ(
-        runtimeStats.at(Operator::kSpillReadBytes).sum,
+        runtimeStats.at(std::string(Operator::kSpillReadBytes)).sum,
         operatorStats.spilledBytes);
-    ASSERT_GT(runtimeStats.at(Operator::kSpillReads).sum, 0);
-    ASSERT_GT(runtimeStats.at(Operator::kSpillReadTime).sum, 0);
-    ASSERT_GT(runtimeStats.at(Operator::kSpillDeserializationTime).sum, 0);
+    ASSERT_GT(runtimeStats.at(std::string(Operator::kSpillReads)).sum, 0);
+    ASSERT_GT(runtimeStats.at(std::string(Operator::kSpillReadTime)).sum, 0);
+    ASSERT_GT(
+        runtimeStats.at(std::string(Operator::kSpillDeserializationTime)).sum,
+        0);
 
     task.reset();
     waitForAllTasksToBeDeleted();
@@ -268,7 +272,7 @@ TEST_F(RowNumberTest, maxSpillBytes) {
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto spillDirectory = TempDirectoryPath::create();
     auto queryCtx = core::QueryCtx::create(executor_.get());
     try {
       TestScopedSpillInjection scopedSpillInjection(100, ".*", 1);
@@ -320,7 +324,7 @@ TEST_F(RowNumberTest, memoryUsage) {
 
     for (const auto& spillEnable : {false, true}) {
       auto queryCtx = core::QueryCtx::create(executor_.get());
-      auto spillDirectory = exec::test::TempDirectoryPath::create();
+      auto spillDirectory = TempDirectoryPath::create();
       const std::string spillEnableConfig = std::to_string(spillEnable);
 
       std::shared_ptr<Task> task;
@@ -374,7 +378,7 @@ DEBUG_ONLY_TEST_F(RowNumberTest, spillOnlyDuringInputOrOutput) {
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto spillDirectory = TempDirectoryPath::create();
     auto queryCtx = core::QueryCtx::create(executor_.get());
 
     std::atomic_int numRound{0};
@@ -404,11 +408,12 @@ DEBUG_ONLY_TEST_F(RowNumberTest, spillOnlyDuringInputOrOutput) {
                 core::QueryConfig::kSpillNumPartitionBits,
                 testData.spillPartitionBits)
             .queryCtx(queryCtx)
-            .plan(PlanBuilder()
-                      .values(vectors)
-                      .rowNumber({"c0"})
-                      .capturePlanNodeId(rowNumberPlanNodeId)
-                      .planNode())
+            .plan(
+                PlanBuilder()
+                    .values(vectors)
+                    .rowNumber({"c0"})
+                    .capturePlanNodeId(rowNumberPlanNodeId)
+                    .planNode())
             .assertResults(
                 "SELECT *, row_number() over (partition by c0) FROM tmp");
     auto taskStats = toPlanStats(task->taskStats());
@@ -441,7 +446,7 @@ DEBUG_ONLY_TEST_F(RowNumberTest, recursiveSpill) {
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto spillDirectory = TempDirectoryPath::create();
     auto queryCtx = core::QueryCtx::create(executor_.get());
 
     std::atomic_int numSpills{0};
@@ -488,11 +493,12 @@ DEBUG_ONLY_TEST_F(RowNumberTest, recursiveSpill) {
             .config(
                 core::QueryConfig::kMaxSpillLevel, testData.maxSpillLevel - 1)
             .queryCtx(queryCtx)
-            .plan(PlanBuilder()
-                      .values(vectors)
-                      .rowNumber({"c0"})
-                      .capturePlanNodeId(rowNumberPlanNodeId)
-                      .planNode())
+            .plan(
+                PlanBuilder()
+                    .values(vectors)
+                    .rowNumber({"c0"})
+                    .capturePlanNodeId(rowNumberPlanNodeId)
+                    .planNode())
             .assertResults(
                 "SELECT *, row_number() over (partition by c0) FROM tmp");
     auto taskStats = toPlanStats(task->taskStats());
@@ -537,7 +543,7 @@ TEST_F(RowNumberTest, spillWithYield) {
     SCOPED_TRACE(testData.debugString());
     TestScopedSpillInjection scopedSpillInjection(
         100, ".*", testData.numSpills);
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto spillDirectory = TempDirectoryPath::create();
     auto queryCtx = core::QueryCtx::create(executor_.get());
 
     core::PlanNodeId rowNumberPlanNodeId;
@@ -550,11 +556,12 @@ TEST_F(RowNumberTest, spillWithYield) {
                 core::QueryConfig::kDriverCpuTimeSliceLimitMs,
                 testData.cpuTimeSliceLimitMs)
             .queryCtx(queryCtx)
-            .plan(PlanBuilder()
-                      .values(vectors)
-                      .rowNumber({"c0"})
-                      .capturePlanNodeId(rowNumberPlanNodeId)
-                      .planNode())
+            .plan(
+                PlanBuilder()
+                    .values(vectors)
+                    .rowNumber({"c0"})
+                    .capturePlanNodeId(rowNumberPlanNodeId)
+                    .planNode())
             .assertResults(
                 "SELECT *, row_number() over (partition by c0) FROM tmp");
     auto taskStats = toPlanStats(task->taskStats());
@@ -568,4 +575,41 @@ TEST_F(RowNumberTest, spillWithYield) {
   }
 }
 
+DEBUG_ONLY_TEST_F(RowNumberTest, rowNumberSpillFileCreateConfig) {
+  auto vectors = createVectors(8, rowType_, fuzzerOpts_);
+  createDuckDbTable(vectors);
+
+  auto tempDirectory = TempDirectoryPath::create();
+
+  std::atomic_bool rowNumberConfigVerified{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::isBlocked",
+      std::function<void(exec::Operator*)>([&](exec::Operator* op) {
+        const auto* spillConfig = op->testingSpillConfig();
+        if (spillConfig == nullptr) {
+          return;
+        }
+        const auto& opType = op->operatorType();
+        if (opType == "RowNumber") {
+          ASSERT_EQ(spillConfig->fileCreateConfig, "test_row_number_config")
+              << "Operator: " << opType;
+          rowNumberConfigVerified = true;
+        }
+      }));
+
+  TestScopedSpillInjection scopedSpillInjection(100);
+  AssertQueryBuilder(duckDbQueryRunner_)
+      .spillDirectory(tempDirectory->getPath())
+      .config(core::QueryConfig::kSpillEnabled, true)
+      .config(core::QueryConfig::kRowNumberSpillEnabled, true)
+      .config(core::QueryConfig::kSpillFileCreateConfig, "test_default_config")
+      .config(
+          core::QueryConfig::kRowNumberSpillFileCreateConfig,
+          "test_row_number_config")
+      .plan(PlanBuilder().values(vectors).rowNumber({"c0"}).planNode())
+      .assertResults("SELECT *, row_number() over (partition by c0) FROM tmp");
+
+  ASSERT_TRUE(rowNumberConfigVerified.load());
+}
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/ScaleWriterLocalPartitionTest.cpp b/velox/exec/tests/ScaleWriterLocalPartitionTest.cpp
index 2dda1e2e868..8a6ee39a705 100644
--- a/velox/exec/tests/ScaleWriterLocalPartitionTest.cpp
+++ b/velox/exec/tests/ScaleWriterLocalPartitionTest.cpp
@@ -81,6 +81,10 @@ class TestExchangeController {
     if (holdBufferBytes_ == 0) {
       return;
     }
+    if (holdBuffer_ != nullptr) {
+      return;
+    }
+
     holdPool_ = pool;
     holdBuffer_ = holdPool_->allocate(holdBufferBytes_);
   }
@@ -227,11 +231,6 @@ class FakeSourceOperator : public SourceOperator {
  private:
   void initialize() override {
     Operator::initialize();
-
-    if (operatorCtx_->driverCtx()->driverId != 0) {
-      return;
-    }
-
     testController_->maybeHoldBuffer(pool());
   }
 
@@ -495,10 +494,11 @@ class ScaleWriterLocalPartitionTest : public HiveConnectorTestBase {
     for (const auto& name : rowType_->names()) {
       orderByKeys.push_back(fmt::format("{} ASC NULLS FIRST", name));
     }
-    AssertQueryBuilder queryBuilder(PlanBuilder()
-                                        .values(inputVectors)
-                                        .orderBy(orderByKeys, false)
-                                        .planNode());
+    AssertQueryBuilder queryBuilder(
+        PlanBuilder()
+            .values(inputVectors)
+            .orderBy(orderByKeys, false)
+            .planNode());
     return queryBuilder.copyResults(pool_.get());
   }
 
@@ -680,22 +680,26 @@ TEST_F(ScaleWriterLocalPartitionTest, unpartitionBasic) {
     if (testData.expectedRebalance) {
       ASSERT_GT(
           planStats.at(exchnangeNodeId)
-              .customStats.at(ScaleWriterLocalPartition::kScaledWriters)
+              .customStats
+              .at(std::string(ScaleWriterLocalPartition::kScaledWriters))
               .sum,
           0);
       ASSERT_LE(
           planStats.at(exchnangeNodeId)
-              .customStats.at(ScaleWriterLocalPartition::kScaledWriters)
+              .customStats
+              .at(std::string(ScaleWriterLocalPartition::kScaledWriters))
               .sum,
           planStats.at(exchnangeNodeId)
-                  .customStats.at(ScaleWriterLocalPartition::kScaledWriters)
+                  .customStats
+                  .at(std::string(ScaleWriterLocalPartition::kScaledWriters))
                   .count *
               (testData.numConsumers - 1));
       ASSERT_GT(nonEmptyConsumers, 1);
     } else {
       ASSERT_EQ(
           planStats.at(exchnangeNodeId)
-              .customStats.count(ScaleWriterLocalPartition::kScaledWriters),
+              .customStats.count(
+                  std::string(ScaleWriterLocalPartition::kScaledWriters)),
           0);
       ASSERT_EQ(nonEmptyConsumers, 1);
     }
@@ -893,40 +897,51 @@ TEST_F(ScaleWriterLocalPartitionTest, partitionBasic) {
       ASSERT_LE(
           planStats.at(exchnangeNodeId)
               .customStats.count(
-                  ScaleWriterPartitioningLocalPartition::kScaledPartitions),
+                  std::string(
+                      ScaleWriterPartitioningLocalPartition::
+                          kScaledPartitions)),
           1);
       if (planStats.at(exchnangeNodeId)
               .customStats.count(
-                  ScaleWriterPartitioningLocalPartition::kScaledPartitions) ==
-          1) {
+                  std::string(
+                      ScaleWriterPartitioningLocalPartition::
+                          kScaledPartitions)) == 1) {
         ASSERT_GT(
             planStats.at(exchnangeNodeId)
                 .customStats
-                .at(ScaleWriterPartitioningLocalPartition::kScaledPartitions)
+                .at(std::string(
+                    ScaleWriterPartitioningLocalPartition::kScaledPartitions))
                 .sum,
             0);
       }
       ASSERT_EQ(
           planStats.at(exchnangeNodeId)
               .customStats.count(
-                  ScaleWriterPartitioningLocalPartition::kRebalanceTriggers),
+                  std::string(
+                      ScaleWriterPartitioningLocalPartition::
+                          kRebalanceTriggers)),
           1);
       ASSERT_GT(
           planStats.at(exchnangeNodeId)
               .customStats
-              .at(ScaleWriterPartitioningLocalPartition::kRebalanceTriggers)
+              .at(std::string(
+                  ScaleWriterPartitioningLocalPartition::kRebalanceTriggers))
               .sum,
           0);
     } else {
       ASSERT_EQ(
           planStats.at(exchnangeNodeId)
               .customStats.count(
-                  ScaleWriterPartitioningLocalPartition::kScaledPartitions),
+                  std::string(
+                      ScaleWriterPartitioningLocalPartition::
+                          kScaledPartitions)),
           0);
       ASSERT_EQ(
           planStats.at(exchnangeNodeId)
               .customStats.count(
-                  ScaleWriterPartitioningLocalPartition::kRebalanceTriggers),
+                  std::string(
+                      ScaleWriterPartitioningLocalPartition::
+                          kRebalanceTriggers)),
           0);
       verifyDisjointPartitionKeys(testController.get());
     }
diff --git a/velox/exec/tests/SimpleAggregateAdapterTest.cpp b/velox/exec/tests/SimpleAggregateAdapterTest.cpp
index 52ed8b1e17a..d104443453b 100644
--- a/velox/exec/tests/SimpleAggregateAdapterTest.cpp
+++ b/velox/exec/tests/SimpleAggregateAdapterTest.cpp
@@ -29,6 +29,8 @@ namespace {
 const char* const kSimpleAvg = "simple_avg";
 const char* const kSimpleArrayAgg = "simple_array_agg";
 const char* const kSimpleCountNulls = "simple_count_nulls";
+const char* const kSimpleVariadicSum = "simple_variadic_sum";
+const char* const kSimpleVariadicArrayAgg = "simple_variadic_array_agg";
 
 class SimpleAverageAggregationTest : public AggregationTestBase {
  protected:
@@ -602,5 +604,340 @@ TEST_F(SimpleFuncLevelVariableAggregationTest, simpleAggregateVariables) {
       {});
 }
 
+class SimpleVariadicSumAggregationTest : public AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+    registerSimpleVariadicSumAggregate(kSimpleVariadicSum);
+  }
+};
+
+TEST_F(SimpleVariadicSumAggregationTest, basicVariadicSum) {
+  // Test global with 3 variadic arguments: sum each column across rows.
+  // Input:
+  //   Row 1: count=3, a=1, b=2, c=3
+  //   Row 2: count=3, a=4, b=5, c=6
+  // Expected output: [1+4, 2+5, 3+6] = [5, 7, 9]
+  auto inputVectors = makeRowVector({
+      makeFlatVector<int64_t>({3, 3}),
+      makeFlatVector<int64_t>({1, 4}),
+      makeFlatVector<int64_t>({2, 5}),
+      makeFlatVector<int64_t>({3, 6}),
+  });
+
+  auto expected = makeRowVector({makeArrayVector<int64_t>({{5, 7, 9}})});
+
+  testAggregations(
+      {inputVectors}, {}, {"simple_variadic_sum(c0, c1, c2, c3)"}, {expected});
+
+  // Test with grouping.
+  // Group true: [1+5, 2+6] = [6, 8]
+  // Group false: [3+7, 4+8] = [10, 12]
+  inputVectors = makeRowVector({
+      makeFlatVector<bool>({true, false, true, false}),
+      makeFlatVector<int64_t>({2, 2, 2, 2}),
+      makeFlatVector<int64_t>({1, 3, 5, 7}),
+      makeFlatVector<int64_t>({2, 4, 6, 8}),
+  });
+
+  expected = makeRowVector({
+      makeFlatVector<bool>({true, false}),
+      makeArrayVector<int64_t>({{6, 8}, {10, 12}}),
+  });
+
+  testAggregations(
+      {inputVectors}, {"c0"}, {"simple_variadic_sum(c1, c2, c3)"}, {expected});
+}
+
+TEST_F(SimpleVariadicSumAggregationTest, variadicSumWithNulls) {
+  // Test global handling of null values in variadic arguments.
+  // With default null behavior, rows with any null variadic element are
+  // skipped entirely.
+  // Row 0: variadic=[1, null, 3] -> SKIPPED (null in variadic)
+  // Row 1: variadic=[4, 5, 6]   -> processed
+  // Row 2: variadic=[7, 8, 9]   -> processed
+  // Expected: [4+7, 5+8, 6+9] = [11, 13, 15]
+  auto inputVectors = makeRowVector({
+      makeFlatVector<int64_t>({3, 3, 3}),
+      makeNullableFlatVector<int64_t>({1, 4, 7}),
+      makeNullableFlatVector<int64_t>({std::nullopt, 5, 8}),
+      makeNullableFlatVector<int64_t>({3, 6, 9}),
+  });
+
+  auto expected = makeRowVector({makeArrayVector<int64_t>({{11, 13, 15}})});
+
+  testAggregations(
+      {inputVectors}, {}, {"simple_variadic_sum(c0, c1, c2, c3)"}, {expected});
+
+  // Test with grouping and null values.
+  // Row 0 (true):  variadic=[1, 2, 3]    -> processed
+  // Row 1 (false): variadic=[4, null, 6]  -> SKIPPED
+  // Row 2 (true):  variadic=[null, 8, 9]  -> SKIPPED
+  // Row 3 (false): variadic=[10, 11, 12]  -> processed
+  // Group true: only row 0 -> [1, 2, 3]
+  // Group false: only row 3 -> [10, 11, 12]
+  inputVectors = makeRowVector({
+      makeFlatVector<bool>({true, false, true, false}),
+      makeFlatVector<int64_t>({3, 3, 3, 3}),
+      makeNullableFlatVector<int64_t>({1, 4, std::nullopt, 10}),
+      makeNullableFlatVector<int64_t>({2, std::nullopt, 8, 11}),
+      makeNullableFlatVector<int64_t>({3, 6, 9, 12}),
+  });
+
+  expected = makeRowVector({
+      makeFlatVector<bool>({true, false}),
+      makeArrayVector<int64_t>({{1, 2, 3}, {10, 11, 12}}),
+  });
+
+  testAggregations(
+      {inputVectors},
+      {"c0"},
+      {"simple_variadic_sum(c1, c2, c3, c4)"},
+      {expected});
+}
+
+TEST_F(SimpleVariadicSumAggregationTest, singleVariadicArg) {
+  // Test global with only 1 variadic argument.
+  // Input:
+  //   Row 1: dummy=1, a=10
+  //   Row 2: dummy=1, a=20
+  // Expected output: [10+20] = [30]
+  auto inputVectors = makeRowVector({
+      makeFlatVector<int64_t>({1, 1}),
+      makeFlatVector<int64_t>({10, 20}),
+  });
+
+  auto expected = makeRowVector({makeArrayVector<int64_t>({{30}})});
+
+  testAggregations(
+      {inputVectors}, {}, {"simple_variadic_sum(c0, c1)"}, {expected});
+
+  // Test with only 1 variadic argument with grouping.
+  // Group true: [10+30] = [40]
+  // Group false: [20+40] = [60]
+  inputVectors = makeRowVector({
+      makeFlatVector<bool>({true, false, true, false}),
+      makeFlatVector<int64_t>({1, 1, 1, 1}),
+      makeFlatVector<int64_t>({10, 20, 30, 40}),
+  });
+
+  expected = makeRowVector({
+      makeFlatVector<bool>({true, false}),
+      makeArrayVector<int64_t>({{40}, {60}}),
+  });
+
+  testAggregations(
+      {inputVectors}, {"c0"}, {"simple_variadic_sum(c1, c2)"}, {expected});
+}
+
+TEST_F(SimpleVariadicSumAggregationTest, noVariadicArg) {
+  // Test global with no variadic argument.
+  // Expected output: []
+  auto inputVectors = makeRowVector({
+      makeFlatVector<int64_t>({1, 1}),
+  });
+
+  auto expected = makeRowVector({makeArrayVector<int64_t>({{}})});
+
+  testAggregations({inputVectors}, {}, {"simple_variadic_sum(c0)"}, {expected});
+
+  // Test with no variadic argument with grouping.
+  // Group true: []
+  // Group false: []
+  inputVectors = makeRowVector({
+      makeFlatVector<bool>({true, false, true, false}),
+      makeFlatVector<int64_t>({1, 1, 1, 1}),
+  });
+
+  expected = makeRowVector({
+      makeFlatVector<bool>({true, false}),
+      makeArrayVector<int64_t>({{}, {}}),
+  });
+
+  testAggregations(
+      {inputVectors}, {"c0"}, {"simple_variadic_sum(c1)"}, {expected});
+}
+
+class SimpleVariadicArrayAggAggregationTest : public AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+    registerSimpleVariadicArrayAggAggregate(kSimpleVariadicArrayAgg);
+  }
+};
+
+TEST_F(SimpleVariadicArrayAggAggregationTest, basicVariadicArrayAgg) {
+  // Test global with 3 variadic arguments: collect all values into a single
+  // array. Input:
+  //   Row 1: a=1, b=2, c=3
+  //   Row 2: a=4, b=5, c=6
+  // Expected output: [1, 2, 3, 4, 5, 6]
+  auto inputVectors = makeRowVector({
+      makeFlatVector<int64_t>({1, 4}),
+      makeFlatVector<int64_t>({2, 5}),
+      makeFlatVector<int64_t>({3, 6}),
+  });
+
+  auto expected =
+      makeRowVector({makeArrayVector<int64_t>({{1, 2, 3, 4, 5, 6}})});
+
+  testAggregations(
+      {inputVectors},
+      {},
+      {"simple_variadic_array_agg(c0, c1, c2)"},
+      {"array_sort(a0)"},
+      {expected});
+
+  // Test with grouping.
+  // Group true: rows 1 and 3 -> [1, 2, 5, 6]
+  // Group false: rows 2 and 4 -> [3, 4, 7, 8]
+  inputVectors = makeRowVector({
+      makeFlatVector<bool>({true, false, true, false}),
+      makeFlatVector<int64_t>({1, 3, 5, 7}),
+      makeFlatVector<int64_t>({2, 4, 6, 8}),
+  });
+
+  expected = makeRowVector({
+      makeFlatVector<bool>({false, true}),
+      makeArrayVector<int64_t>({{3, 4, 7, 8}, {1, 2, 5, 6}}),
+  });
+
+  testAggregations(
+      {inputVectors},
+      {"c0"},
+      {"simple_variadic_array_agg(c1, c2)"},
+      {"c0", "array_sort(a0)"},
+      {expected});
+}
+
+TEST_F(SimpleVariadicArrayAggAggregationTest, variadicArrayAggWithNulls) {
+  // Test global handling of null values in variadic arguments.
+  // Nulls should be included in the output array (non-default null behavior).
+  // Row 1: 1, null, 3
+  // Row 2: 4, 5, null
+  // Expected: [1, 3, 4, 5, null, null]
+  auto inputVectors = makeRowVector({
+      makeNullableFlatVector<int64_t>({1, 4}),
+      makeNullableFlatVector<int64_t>({std::nullopt, 5}),
+      makeNullableFlatVector<int64_t>({3, std::nullopt}),
+  });
+
+  auto expected = makeRowVector({vectorMaker_.arrayVectorNullable<int64_t>(
+      {{{1, 3, 4, 5, std::nullopt, std::nullopt}}})});
+
+  testAggregations(
+      {inputVectors},
+      {},
+      {"simple_variadic_array_agg(c0, c1, c2)"},
+      {"array_sort(a0)"},
+      {expected});
+
+  // Test with grouping and null values.
+  // Group true: rows 1, 3 -> [1, null, 3, 5, 7, null]
+  // Group false: rows 2, 4 -> [2, 4, null, 6, null, 8]
+  inputVectors = makeRowVector({
+      makeFlatVector<bool>({true, false, true, false}),
+      makeNullableFlatVector<int64_t>({1, 2, 5, 6}),
+      makeNullableFlatVector<int64_t>({std::nullopt, 4, 7, std::nullopt}),
+      makeNullableFlatVector<int64_t>({3, std::nullopt, std::nullopt, 8}),
+  });
+
+  expected = makeRowVector({
+      makeFlatVector<bool>({false, true}),
+      vectorMaker_.arrayVectorNullable<int64_t>(
+          {{{2, 4, 6, 8, std::nullopt, std::nullopt}},
+           {{1, 3, 5, 7, std::nullopt, std::nullopt}}}),
+  });
+
+  testAggregations(
+      {inputVectors},
+      {"c0"},
+      {"simple_variadic_array_agg(c1, c2, c3)"},
+      {"c0", "array_sort(a0)"},
+      {expected});
+}
+
+TEST_F(SimpleVariadicArrayAggAggregationTest, variadicArrayAggStrings) {
+  // Test global with string type to verify Generic<T1> works with different
+  // types.
+  auto inputVectors = makeRowVector({
+      makeFlatVector<StringView>({"a", "d"}),
+      makeFlatVector<StringView>({"b", "e"}),
+      makeFlatVector<StringView>({"c", "f"}),
+  });
+
+  auto expected = makeRowVector(
+      {makeArrayVector<StringView>({{"a", "b", "c", "d", "e", "f"}})});
+
+  testAggregations(
+      {inputVectors},
+      {},
+      {"simple_variadic_array_agg(c0, c1, c2)"},
+      {"array_sort(a0)"},
+      {expected});
+
+  // Test with grouping and string type.
+  // Group true: rows 1, 3 -> ["a", "b", "e", "f"]
+  // Group false: rows 2, 4 -> ["c", "d", "g", "h"]
+  inputVectors = makeRowVector({
+      makeFlatVector<bool>({true, false, true, false}),
+      makeFlatVector<StringView>({"a", "c", "e", "g"}),
+      makeFlatVector<StringView>({"b", "d", "f", "h"}),
+  });
+
+  expected = makeRowVector({
+      makeFlatVector<bool>({false, true}),
+      makeArrayVector<StringView>({{"c", "d", "g", "h"}, {"a", "b", "e", "f"}}),
+  });
+
+  testAggregations(
+      {inputVectors},
+      {"c0"},
+      {"simple_variadic_array_agg(c1, c2)"},
+      {"c0", "array_sort(a0)"},
+      {expected});
+}
+
+TEST_F(SimpleVariadicArrayAggAggregationTest, singleVariadicArg) {
+  // Test global with only 1 variadic argument.
+  // Input:
+  //   Row 1: a=10
+  //   Row 2: a=20
+  //   Row 3: a=30
+  // Expected output: [10, 20, 30]
+  auto inputVectors = makeRowVector({
+      makeFlatVector<int64_t>({10, 20, 30}),
+  });
+
+  auto expected = makeRowVector({makeArrayVector<int64_t>({{10, 20, 30}})});
+
+  testAggregations(
+      {inputVectors},
+      {},
+      {"simple_variadic_array_agg(c0)"},
+      {"array_sort(a0)"},
+      {expected});
+
+  // Test with only 1 variadic argument with grouping.
+  // Group true: [10, 30]
+  // Group false: [20, 40]
+  inputVectors = makeRowVector({
+      makeFlatVector<bool>({true, false, true, false}),
+      makeFlatVector<int64_t>({10, 20, 30, 40}),
+  });
+
+  expected = makeRowVector({
+      makeFlatVector<bool>({false, true}),
+      makeArrayVector<int64_t>({{20, 40}, {10, 30}}),
+  });
+
+  testAggregations(
+      {inputVectors},
+      {"c0"},
+      {"simple_variadic_array_agg(c1)"},
+      {"c0", "array_sort(a0)"},
+      {expected});
+}
+
 } // namespace
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/exec/tests/SimpleAggregateFunctionsRegistration.h b/velox/exec/tests/SimpleAggregateFunctionsRegistration.h
index 06095ab92e6..760615bf9d3 100644
--- a/velox/exec/tests/SimpleAggregateFunctionsRegistration.h
+++ b/velox/exec/tests/SimpleAggregateFunctionsRegistration.h
@@ -28,4 +28,10 @@ exec::AggregateRegistrationResult registerSimpleAverageAggregate(
 exec::AggregateRegistrationResult registerSimpleArrayAggAggregate(
     const std::string& name);
 
+exec::AggregateRegistrationResult registerSimpleVariadicSumAggregate(
+    const std::string& name);
+
+exec::AggregateRegistrationResult registerSimpleVariadicArrayAggAggregate(
+    const std::string& name);
+
 } // namespace facebook::velox::aggregate
diff --git a/velox/exec/tests/SimpleArrayAggAggregate.cpp b/velox/exec/tests/SimpleArrayAggAggregate.cpp
index 40a4f4e583e..ed0c793e0be 100644
--- a/velox/exec/tests/SimpleArrayAggAggregate.cpp
+++ b/velox/exec/tests/SimpleArrayAggAggregate.cpp
@@ -127,7 +127,7 @@ exec::AggregateRegistrationResult registerSimpleArrayAggAggregate(
 
   return exec::registerAggregateFunction(
       name,
-      std::move(signatures),
+      signatures,
       [name](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
diff --git a/velox/exec/tests/SimpleAverageAggregate.cpp b/velox/exec/tests/SimpleAverageAggregate.cpp
index fea9254cb1c..ea710380b3b 100644
--- a/velox/exec/tests/SimpleAverageAggregate.cpp
+++ b/velox/exec/tests/SimpleAverageAggregate.cpp
@@ -34,9 +34,8 @@ class AverageAggregate {
   using InputType = Row<T>;
 
   // Type of intermediate result vector wrapped in Row.
-  using IntermediateType =
-      Row</*sum*/ double,
-          /*count*/ int64_t>;
+  using IntermediateType = Row</*sum*/ double,
+                               /*count*/ int64_t>;
 
   // Type of output vector.
   using OutputType =
@@ -102,18 +101,20 @@ exec::AggregateRegistrationResult registerSimpleAverageAggregate(
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
 
   for (const auto& inputType : {"smallint", "integer", "bigint", "double"}) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType("double")
-                             .intermediateType("row(double,bigint)")
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType("double")
+            .intermediateType("row(double,bigint)")
+            .argumentType(inputType)
+            .build());
   }
 
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .returnType("real")
-                           .intermediateType("row(double,bigint)")
-                           .argumentType("real")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType("real")
+          .intermediateType("row(double,bigint)")
+          .argumentType("real")
+          .build());
 
   return exec::registerAggregateFunction(
       name,
diff --git a/velox/exec/tests/SimpleVariadicArrayAggAggregate.cpp b/velox/exec/tests/SimpleVariadicArrayAggAggregate.cpp
new file mode 100644
index 00000000000..32886393536
--- /dev/null
+++ b/velox/exec/tests/SimpleVariadicArrayAggAggregate.cpp
@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/Aggregate.h"
+#include "velox/exec/SimpleAggregateAdapter.h"
+#include "velox/expression/FunctionSignature.h"
+#include "velox/functions/lib/aggregates/ValueList.h"
+
+using namespace facebook::velox::exec;
+
+namespace facebook::velox::aggregate {
+
+namespace {
+
+// An aggregate function that demonstrates variadic argument support with
+// Generic types and non-default null behavior in SimpleAggregateAdapter. This
+// function takes a variadic list of values of the same type and aggregates all
+// of them into a single array, including nulls.
+//
+// Example:
+//   SELECT variadic_array_agg(a, b, c) FROM (
+//     VALUES (1, 2, 3), (4, 5, 6)
+//   ) AS t(a, b, c)
+//   => [1, 2, 3, 4, 5, 6]
+class VariadicArrayAggAggregate {
+ public:
+  using InputType = AggregateInputType<Variadic<Generic<T1>>>;
+
+  using IntermediateType = Array<Generic<T1>>;
+
+  using OutputType = Array<Generic<T1>>;
+
+  static constexpr bool default_null_behavior_ = false;
+
+  static bool toIntermediate(
+      exec::out_type<Array<Generic<T1>>>& out,
+      exec::optional_arg_type<Variadic<Generic<T1>>> variadicArgs) {
+    if (!variadicArgs.has_value()) {
+      VELOX_UNREACHABLE(
+          "simple_variadic_array_agg requires at least one variadic argument.");
+    }
+    for (auto i = 0; i < variadicArgs.value().size(); ++i) {
+      if (variadicArgs->at(i).has_value()) {
+        out.add_item().copy_from(variadicArgs->at(i).value());
+      } else {
+        out.add_null();
+      }
+    }
+    return true;
+  }
+
+  struct AccumulatorType {
+    ValueList elements_;
+
+    AccumulatorType() = delete;
+
+    explicit AccumulatorType(
+        HashStringAllocator* /*allocator*/,
+        VariadicArrayAggAggregate* /*fn*/)
+        : elements_{} {}
+
+    static constexpr bool is_fixed_size_ = false;
+
+    bool addInput(
+        HashStringAllocator* allocator,
+        exec::optional_arg_type<Variadic<Generic<T1>>> variadicArgs) {
+      if (!variadicArgs.has_value()) {
+        VELOX_UNREACHABLE(
+            "simple_variadic_array_agg requires at least one variadic argument.");
+      }
+      for (auto i = 0; i < variadicArgs.value().size(); ++i) {
+        elements_.appendValue(variadicArgs->at(i), allocator);
+      }
+      return true;
+    }
+
+    bool combine(
+        HashStringAllocator* allocator,
+        exec::optional_arg_type<Array<Generic<T1>>> other) {
+      if (!other.has_value()) {
+        return false;
+      }
+      for (auto i = 0; i < other.value().size(); ++i) {
+        elements_.appendValue(other->at(i), allocator);
+      }
+      return true;
+    }
+
+    bool writeFinalResult(
+        bool nonNullGroup,
+        exec::out_type<Array<Generic<T1>>>& out) {
+      if (!nonNullGroup) {
+        return false;
+      }
+      copyValueListToArrayWriter(out, elements_);
+      return true;
+    }
+
+    bool writeIntermediateResult(
+        bool nonNullGroup,
+        exec::out_type<Array<Generic<T1>>>& out) {
+      if (!nonNullGroup) {
+        return false;
+      }
+      copyValueListToArrayWriter(out, elements_);
+      return true;
+    }
+
+    void destroy(HashStringAllocator* allocator) {
+      elements_.free(allocator);
+    }
+  };
+};
+
+} // namespace
+
+exec::AggregateRegistrationResult registerSimpleVariadicArrayAggAggregate(
+    const std::string& name) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
+      exec::AggregateFunctionSignatureBuilder()
+          .typeVariable("E")
+          .returnType("array(E)")
+          .intermediateType("array(E)")
+          .argumentType("E")
+          .variableArity()
+          .build()};
+
+  return exec::registerAggregateFunction(
+      name,
+      signatures,
+      [name](
+          core::AggregationNode::Step step,
+          const std::vector<TypePtr>& argTypes,
+          const TypePtr& resultType,
+          const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        VELOX_CHECK_GE(
+            argTypes.size(), 1, "{} requires at least 1 argument", name);
+        return std::make_unique<
+            SimpleAggregateAdapter<VariadicArrayAggAggregate>>(
+            step, argTypes, resultType);
+      },
+      true /*registerCompanionFunctions*/,
+      true /*overwrite*/);
+}
+
+} // namespace facebook::velox::aggregate
diff --git a/velox/exec/tests/SimpleVariadicSumAggregate.cpp b/velox/exec/tests/SimpleVariadicSumAggregate.cpp
new file mode 100644
index 00000000000..b1703e20fa3
--- /dev/null
+++ b/velox/exec/tests/SimpleVariadicSumAggregate.cpp
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/Aggregate.h"
+#include "velox/exec/SimpleAggregateAdapter.h"
+#include "velox/expression/FunctionSignature.h"
+
+using namespace facebook::velox::exec;
+
+namespace facebook::velox::aggregate {
+
+namespace {
+
+// An aggregate function that demonstrates variadic argument support in
+// SimpleAggregateAdapter. This function takes a dummy integer argument followed
+// by a variadic list of integers. It returns an array where the i-th element is
+// the sum of all i-th variadic arguments across all rows.
+//
+// Example:
+//   SELECT variadic_sum_agg(3, a, b, c) FROM (
+//     VALUES (1, 2, 3), (4, 5, 6)
+//   ) AS t(a, b, c)
+//   => [5, 7, 9]  (i.e., [1+4, 2+5, 3+6])
+class VariadicSumAggregate {
+ public:
+  // Force the function to take a dummy integer before the variadic arguments to
+  // test variadic list not starting from the beginning.
+  using InputType = AggregateInputType<int64_t, Variadic<int64_t>>;
+
+  using IntermediateType = Array<int64_t>;
+
+  using OutputType = Array<int64_t>;
+
+  struct AccumulatorType {
+    std::vector<int64_t> sums_;
+
+    AccumulatorType() = delete;
+
+    explicit AccumulatorType(
+        HashStringAllocator* /*allocator*/,
+        VariadicSumAggregate* /*fn*/)
+        : sums_{} {}
+
+    static constexpr bool is_fixed_size_ = false;
+    static constexpr bool use_external_memory_ = true;
+
+    void addInput(
+        HashStringAllocator* /*allocator*/,
+        exec::arg_type<int64_t> /*dummy*/,
+        exec::arg_type<Variadic<int64_t>> variadicArgs) {
+      // Initialize sums_ based on the actual number of variadic arguments.
+      if (sums_.empty()) {
+        sums_.resize(variadicArgs.size(), 0);
+      }
+
+      for (auto i = 0; i < variadicArgs.size(); ++i) {
+        sums_[i] += variadicArgs.at(i).value();
+      }
+    }
+
+    void combine(
+        HashStringAllocator* /*allocator*/,
+        exec::arg_type<Array<int64_t>> other) {
+      // Initialize sums_ based on the incoming array size if not yet
+      // initialized.
+      if (sums_.empty()) {
+        sums_.resize(other.size(), 0);
+      }
+
+      // Add element-wise.
+      for (auto i = 0; i < other.size(); ++i) {
+        if (other.at(i).has_value()) {
+          sums_[i] += other.at(i).value();
+        }
+      }
+    }
+
+    bool writeFinalResult(exec::out_type<Array<int64_t>>& out) {
+      for (const auto& sum : sums_) {
+        out.add_item() = sum;
+      }
+      return true;
+    }
+
+    bool writeIntermediateResult(exec::out_type<Array<int64_t>>& out) {
+      for (const auto& sum : sums_) {
+        out.add_item() = sum;
+      }
+      return true;
+    }
+  };
+};
+
+} // namespace
+
+exec::AggregateRegistrationResult registerSimpleVariadicSumAggregate(
+    const std::string& name) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType("array(bigint)")
+          .intermediateType("array(bigint)")
+          .argumentType("bigint")
+          .argumentType("bigint")
+          .variableArity()
+          .build()};
+
+  return exec::registerAggregateFunction(
+      name,
+      signatures,
+      [name](
+          core::AggregationNode::Step step,
+          const std::vector<TypePtr>& argTypes,
+          const TypePtr& resultType,
+          const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        VELOX_CHECK_GE(
+            argTypes.size(), 1, "{} requires at least 1 argument", name);
+        return std::make_unique<SimpleAggregateAdapter<VariadicSumAggregate>>(
+            step, argTypes, resultType);
+      },
+      true /*registerCompanionFunctions*/,
+      true /*overwrite*/);
+}
+
+} // namespace facebook::velox::aggregate
diff --git a/velox/exec/tests/SortBufferTest.cpp b/velox/exec/tests/SortBufferTest.cpp
index 93bf32edf4d..684aae78051 100644
--- a/velox/exec/tests/SortBufferTest.cpp
+++ b/velox/exec/tests/SortBufferTest.cpp
@@ -15,12 +15,13 @@
  */
 
 #include "velox/exec/SortBuffer.h"
+#include <folly/system/HardwareConcurrency.h>
 #include <gtest/gtest.h>
 
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/type/Type.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
@@ -31,6 +32,7 @@ using namespace facebook::velox;
 using namespace facebook::velox::memory;
 
 namespace facebook::velox::functions::test {
+using namespace facebook::velox::common::testutil;
 namespace {
 // Class to write runtime stats in the tests to the stats container.
 class TestRuntimeStatWriter : public BaseRuntimeStatWriter {
@@ -39,7 +41,7 @@ class TestRuntimeStatWriter : public BaseRuntimeStatWriter {
       std::unordered_map<std::string, RuntimeMetric>& stats)
       : stats_{stats} {}
 
-  void addRuntimeStat(const std::string& name, const RuntimeCounter& value)
+  void addRuntimeStat(std::string_view name, const RuntimeCounter& value)
       override {
     addOperatorRuntimeStats(name, value, stats_);
   }
@@ -89,6 +91,7 @@ class SortBufferTest : public OperatorTestBase,
         0,
         0,
         "none",
+        0,
         spillPrefixSortConfig);
   }
 
@@ -118,7 +121,9 @@ class SortBufferTest : public OperatorTestBase,
 
   const std::shared_ptr<folly::Executor> executor_{
       std::make_shared<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency())};
+          folly::available_concurrency())};
+  const std::shared_ptr<memory::MemoryPool> fuzzerPool_ =
+      memory::memoryManager()->addLeafPool("SortBufferTest");
 
   tsan_atomic<bool> nonReclaimableSection_{false};
   folly::Random::DefaultGenerator rng_;
@@ -199,16 +204,16 @@ TEST_P(SortBufferTest, singleKey) {
     }
     if (GetParam()) {
       ASSERT_EQ(
-          stats_.at(PrefixSort::kNumPrefixSortKeys).sum,
+          stats_.at(std::string(PrefixSort::kNumPrefixSortKeys)).sum,
           sortColumnIndices_.size());
       ASSERT_EQ(
-          stats_.at(PrefixSort::kNumPrefixSortKeys).max,
+          stats_.at(std::string(PrefixSort::kNumPrefixSortKeys)).max,
           sortColumnIndices_.size());
       ASSERT_EQ(
-          stats_.at(PrefixSort::kNumPrefixSortKeys).min,
+          stats_.at(std::string(PrefixSort::kNumPrefixSortKeys)).min,
           sortColumnIndices_.size());
     } else {
-      ASSERT_EQ(stats_.count(PrefixSort::kNumPrefixSortKeys), 0);
+      ASSERT_EQ(stats_.count(std::string(PrefixSort::kNumPrefixSortKeys)), 0);
     }
     stats_.clear();
   }
@@ -261,16 +266,16 @@ TEST_P(SortBufferTest, multipleKeys) {
   ASSERT_EQ(output->childAt(1)->asFlatVector<int32_t>()->valueAt(9), 5);
   if (GetParam()) {
     ASSERT_EQ(
-        stats_.at(PrefixSort::kNumPrefixSortKeys).sum,
+        stats_.at(std::string(PrefixSort::kNumPrefixSortKeys)).sum,
         sortColumnIndices_.size());
     ASSERT_EQ(
-        stats_.at(PrefixSort::kNumPrefixSortKeys).max,
+        stats_.at(std::string(PrefixSort::kNumPrefixSortKeys)).max,
         sortColumnIndices_.size());
     ASSERT_EQ(
-        stats_.at(PrefixSort::kNumPrefixSortKeys).min,
+        stats_.at(std::string(PrefixSort::kNumPrefixSortKeys)).min,
         sortColumnIndices_.size());
   } else {
-    ASSERT_EQ(stats_.count(PrefixSort::kNumPrefixSortKeys), 0);
+    ASSERT_EQ(stats_.count(std::string(PrefixSort::kNumPrefixSortKeys)), 0);
   }
 }
 
@@ -335,13 +340,10 @@ TEST_P(SortBufferTest, DISABLED_randomData) {
         &nonReclaimableSection_,
         prefixSortConfig_);
 
-    const std::shared_ptr<memory::MemoryPool> fuzzerPool =
-        memory::memoryManager()->addLeafPool("VectorFuzzer");
-
     std::vector<RowVectorPtr> inputVectors;
     inputVectors.reserve(3);
     for (size_t inputRows : {1000, 1000, 1000}) {
-      VectorFuzzer fuzzer({.vectorSize = inputRows}, fuzzerPool.get());
+      VectorFuzzer fuzzer({.vectorSize = inputRows}, fuzzerPool_.get());
       RowVectorPtr input = fuzzer.fuzzRow(inputType_);
       sortBuffer->addInput(input);
       inputVectors.push_back(input);
@@ -384,7 +386,7 @@ TEST_P(SortBufferTest, batchOutput) {
   TestScopedSpillInjection scopedSpillInjection(100);
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto spillDirectory = TempDirectoryPath::create();
     auto spillConfig = common::SpillConfig(
         [&]() -> const std::string& { return spillDirectory->getPath(); },
         [&](uint64_t) {},
@@ -401,8 +403,9 @@ TEST_P(SortBufferTest, batchOutput) {
         0,
         0,
         "none",
+        0,
         prefixSortConfig_);
-    folly::Synchronized<common::SpillStats> spillStats;
+    exec::SpillStats spillStats;
     auto sortBuffer = std::make_unique<SortBuffer>(
         inputType_,
         sortColumnIndices_,
@@ -413,15 +416,11 @@ TEST_P(SortBufferTest, batchOutput) {
         testData.triggerSpill ? &spillConfig : nullptr,
         &spillStats);
     ASSERT_EQ(sortBuffer->canSpill(), testData.triggerSpill);
-
-    const std::shared_ptr<memory::MemoryPool> fuzzerPool =
-        memory::memoryManager()->addLeafPool("VectorFuzzer");
-
     std::vector<RowVectorPtr> inputVectors;
     inputVectors.reserve(testData.numInputRows.size());
     uint64_t totalNumInput = 0;
     for (size_t inputRows : testData.numInputRows) {
-      VectorFuzzer fuzzer({.vectorSize = inputRows}, fuzzerPool.get());
+      VectorFuzzer fuzzer({.vectorSize = inputRows}, fuzzerPool_.get());
       RowVectorPtr input = fuzzer.fuzzRow(inputType_);
       sortBuffer->addInput(input);
       inputVectors.push_back(input);
@@ -438,14 +437,14 @@ TEST_P(SortBufferTest, batchOutput) {
     }
 
     if (!testData.triggerSpill) {
-      ASSERT_TRUE(spillStats.rlock()->empty());
+      ASSERT_TRUE(spillStats.empty());
     } else {
-      ASSERT_FALSE(spillStats.rlock()->empty());
-      ASSERT_GT(spillStats.rlock()->spilledRows, 0);
-      ASSERT_LE(spillStats.rlock()->spilledRows, totalNumInput);
-      ASSERT_GT(spillStats.rlock()->spilledBytes, 0);
-      ASSERT_EQ(spillStats.rlock()->spilledPartitions, 1);
-      ASSERT_GT(spillStats.rlock()->spilledFiles, 0);
+      ASSERT_FALSE(spillStats.empty());
+      ASSERT_GT(spillStats.spilledRows, 0);
+      ASSERT_LE(spillStats.spilledRows, totalNumInput);
+      ASSERT_GT(spillStats.spilledBytes, 0);
+      ASSERT_EQ(spillStats.spilledPartitions, 1);
+      ASSERT_GT(spillStats.spilledFiles, 0);
     }
   }
 }
@@ -476,7 +475,7 @@ TEST_P(SortBufferTest, spill) {
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto spillDirectory = TempDirectoryPath::create();
     // memory pool limit is 20M
     // Set 'kSpillableReservationGrowthPct' to an extreme large value to trigger
     // memory reservation failure and thus trigger disk spilling.
@@ -498,8 +497,9 @@ TEST_P(SortBufferTest, spill) {
         0,
         0,
         "none",
+        0,
         prefixSortConfig_);
-    folly::Synchronized<common::SpillStats> spillStats;
+    exec::SpillStats spillStats;
     auto sortBuffer = std::make_unique<SortBuffer>(
         inputType_,
         sortColumnIndices_,
@@ -510,9 +510,7 @@ TEST_P(SortBufferTest, spill) {
         testData.spillEnabled ? &spillConfig : nullptr,
         &spillStats);
 
-    const std::shared_ptr<memory::MemoryPool> fuzzerPool =
-        memory::memoryManager()->addLeafPool("spillSource");
-    VectorFuzzer fuzzer({.vectorSize = 1024}, fuzzerPool.get());
+    VectorFuzzer fuzzer({.vectorSize = 1024}, fuzzerPool_.get());
     uint64_t totalNumInput = 0;
 
     ASSERT_EQ(memory::spillMemoryPool()->stats().usedBytes, 0);
@@ -528,20 +526,20 @@ TEST_P(SortBufferTest, spill) {
     sortBuffer->noMoreInput();
 
     if (!testData.spillTriggered) {
-      ASSERT_TRUE(spillStats.rlock()->empty());
+      ASSERT_TRUE(spillStats.empty());
       if (!testData.spillEnabled) {
         VELOX_ASSERT_THROW(sortBuffer->spill(), "spill config is null");
       }
     } else {
-      ASSERT_FALSE(spillStats.rlock()->empty());
-      ASSERT_GT(spillStats.rlock()->spilledRows, 0);
-      ASSERT_LE(spillStats.rlock()->spilledRows, totalNumInput);
-      ASSERT_GT(spillStats.rlock()->spilledBytes, 0);
-      ASSERT_EQ(spillStats.rlock()->spilledPartitions, 1);
+      ASSERT_FALSE(spillStats.empty());
+      ASSERT_GT(spillStats.spilledRows, 0);
+      ASSERT_LE(spillStats.spilledRows, totalNumInput);
+      ASSERT_GT(spillStats.spilledBytes, 0);
+      ASSERT_EQ(spillStats.spilledPartitions, 1);
       // SortBuffer shall not respect maxFileSize. Total files should be num
       // addInput() calls minus one which is the first one that has nothing to
       // spill.
-      ASSERT_EQ(spillStats.rlock()->spilledFiles, 3);
+      ASSERT_EQ(spillStats.spilledFiles, 3);
       sortBuffer.reset();
       ASSERT_EQ(memory::spillMemoryPool()->stats().usedBytes, 0);
       if (memory::spillMemoryPool()->trackUsage()) {
@@ -552,25 +550,25 @@ TEST_P(SortBufferTest, spill) {
     }
     if (GetParam()) {
       ASSERT_GE(
-          stats_.at(PrefixSort::kNumPrefixSortKeys).sum,
+          stats_.at(std::string(PrefixSort::kNumPrefixSortKeys)).sum,
           sortColumnIndices_.size());
       ASSERT_EQ(
-          stats_.at(PrefixSort::kNumPrefixSortKeys).max,
+          stats_.at(std::string(PrefixSort::kNumPrefixSortKeys)).max,
           sortColumnIndices_.size());
       ASSERT_EQ(
-          stats_.at(PrefixSort::kNumPrefixSortKeys).min,
+          stats_.at(std::string(PrefixSort::kNumPrefixSortKeys)).min,
           sortColumnIndices_.size());
     } else {
-      ASSERT_EQ(stats_.count(PrefixSort::kNumPrefixSortKeys), 0);
+      ASSERT_EQ(stats_.count(std::string(PrefixSort::kNumPrefixSortKeys)), 0);
     }
     stats_.clear();
   }
 }
 
 DEBUG_ONLY_TEST_P(SortBufferTest, spillDuringInput) {
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
   const auto spillConfig = getSpillConfig(spillDirectory->getPath());
-  folly::Synchronized<common::SpillStats> spillStats;
+  exec::SpillStats spillStats;
   auto sortBuffer = std::make_unique<SortBuffer>(
       inputType_,
       sortColumnIndices_,
@@ -595,9 +593,7 @@ DEBUG_ONLY_TEST_P(SortBufferTest, spillDuringInput) {
         ASSERT_EQ(sortBuffer->pool()->usedBytes(), 0);
       })));
 
-  const std::shared_ptr<memory::MemoryPool> fuzzerPool =
-      memory::memoryManager()->addLeafPool("spillDuringInput");
-  VectorFuzzer fuzzer({.vectorSize = 1024}, fuzzerPool.get());
+  VectorFuzzer fuzzer({.vectorSize = 1024}, fuzzerPool_.get());
 
   ASSERT_EQ(memory::spillMemoryPool()->stats().usedBytes, 0);
   const auto peakSpillMemoryUsage =
@@ -608,12 +604,12 @@ DEBUG_ONLY_TEST_P(SortBufferTest, spillDuringInput) {
   }
   sortBuffer->noMoreInput();
 
-  ASSERT_FALSE(spillStats.rlock()->empty());
-  ASSERT_GT(spillStats.rlock()->spilledRows, 0);
-  ASSERT_EQ(spillStats.rlock()->spilledRows, numInputs * 1024);
-  ASSERT_GT(spillStats.rlock()->spilledBytes, 0);
-  ASSERT_EQ(spillStats.rlock()->spilledPartitions, 1);
-  ASSERT_EQ(spillStats.rlock()->spilledFiles, 2);
+  ASSERT_FALSE(spillStats.empty());
+  ASSERT_GT(spillStats.spilledRows, 0);
+  ASSERT_EQ(spillStats.spilledRows, numInputs * 1024);
+  ASSERT_GT(spillStats.spilledBytes, 0);
+  ASSERT_EQ(spillStats.spilledPartitions, 1);
+  ASSERT_EQ(spillStats.spilledFiles, 2);
 
   ASSERT_EQ(memory::spillMemoryPool()->stats().usedBytes, 0);
   if (memory::spillMemoryPool()->trackUsage()) {
@@ -621,12 +617,13 @@ DEBUG_ONLY_TEST_P(SortBufferTest, spillDuringInput) {
     ASSERT_GE(
         memory::spillMemoryPool()->stats().peakBytes, peakSpillMemoryUsage);
   }
+  ASSERT_EQ(pool_->usedBytes(), 0);
 }
 
 DEBUG_ONLY_TEST_P(SortBufferTest, spillDuringOutput) {
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
   const auto spillConfig = getSpillConfig(spillDirectory->getPath());
-  folly::Synchronized<common::SpillStats> spillStats;
+  exec::SpillStats spillStats;
   auto sortBuffer = std::make_unique<SortBuffer>(
       inputType_,
       sortColumnIndices_,
@@ -645,10 +642,7 @@ DEBUG_ONLY_TEST_P(SortBufferTest, spillDuringOutput) {
         sortBuffer->spill();
         ASSERT_EQ(sortBuffer->pool()->usedBytes(), 0);
       })));
-
-  const std::shared_ptr<memory::MemoryPool> fuzzerPool =
-      memory::memoryManager()->addLeafPool("spillDuringOutput");
-  VectorFuzzer fuzzer({.vectorSize = 1024}, fuzzerPool.get());
+  VectorFuzzer fuzzer({.vectorSize = 1024}, fuzzerPool_.get());
 
   ASSERT_EQ(memory::spillMemoryPool()->stats().usedBytes, 0);
   const auto peakSpillMemoryUsage =
@@ -659,12 +653,12 @@ DEBUG_ONLY_TEST_P(SortBufferTest, spillDuringOutput) {
   }
   sortBuffer->noMoreInput();
 
-  ASSERT_FALSE(spillStats.rlock()->empty());
-  ASSERT_GT(spillStats.rlock()->spilledRows, 0);
-  ASSERT_EQ(spillStats.rlock()->spilledRows, numInputs * 1024);
-  ASSERT_GT(spillStats.rlock()->spilledBytes, 0);
-  ASSERT_EQ(spillStats.rlock()->spilledPartitions, 1);
-  ASSERT_EQ(spillStats.rlock()->spilledFiles, 1);
+  ASSERT_FALSE(spillStats.empty());
+  ASSERT_GT(spillStats.spilledRows, 0);
+  ASSERT_EQ(spillStats.spilledRows, numInputs * 1024);
+  ASSERT_GT(spillStats.spilledBytes, 0);
+  ASSERT_EQ(spillStats.spilledPartitions, 1);
+  ASSERT_EQ(spillStats.spilledFiles, 1);
 
   ASSERT_EQ(memory::spillMemoryPool()->stats().usedBytes, 0);
   if (memory::spillMemoryPool()->trackUsage()) {
@@ -678,9 +672,9 @@ DEBUG_ONLY_TEST_P(SortBufferTest, reserveMemorySortGetOutput) {
   for (bool spillEnabled : {false, true}) {
     SCOPED_TRACE(fmt::format("spillEnabled {}", spillEnabled));
 
-    auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto spillDirectory = TempDirectoryPath::create();
     const auto spillConfig = getSpillConfig(spillDirectory->getPath());
-    folly::Synchronized<common::SpillStats> spillStats;
+    exec::SpillStats spillStats;
     auto sortBuffer = std::make_unique<SortBuffer>(
         inputType_,
         sortColumnIndices_,
@@ -690,10 +684,7 @@ DEBUG_ONLY_TEST_P(SortBufferTest, reserveMemorySortGetOutput) {
         prefixSortConfig_,
         spillEnabled ? &spillConfig : nullptr,
         &spillStats);
-
-    const std::shared_ptr<memory::MemoryPool> fuzzerPool =
-        memory::memoryManager()->addLeafPool("reserveMemoryGetOutput");
-    VectorFuzzer fuzzer({.vectorSize = 1024}, fuzzerPool.get());
+    VectorFuzzer fuzzer({.vectorSize = 1024}, fuzzerPool_.get());
 
     const int numInputs{10};
     for (int i = 0; i < numInputs; ++i) {
@@ -735,11 +726,14 @@ DEBUG_ONLY_TEST_P(SortBufferTest, reserveMemorySort) {
   } testSettings[] = {{false, true}, {true, false}, {true, true}};
 
   for (const auto [usePrefixSort, spillEnabled] : testSettings) {
-    SCOPED_TRACE(fmt::format(
-        "usePrefixSort: {}, spillEnabled: {}, ", usePrefixSort, spillEnabled));
-    auto spillDirectory = exec::test::TempDirectoryPath::create();
+    SCOPED_TRACE(
+        fmt::format(
+            "usePrefixSort: {}, spillEnabled: {}, ",
+            usePrefixSort,
+            spillEnabled));
+    auto spillDirectory = TempDirectoryPath::create();
     auto spillConfig = getSpillConfig(spillDirectory->getPath(), usePrefixSort);
-    folly::Synchronized<common::SpillStats> spillStats;
+    exec::SpillStats spillStats;
     auto sortBuffer = std::make_unique<SortBuffer>(
         inputType_,
         sortColumnIndices_,
@@ -777,14 +771,11 @@ DEBUG_ONLY_TEST_P(SortBufferTest, reserveMemorySort) {
 }
 
 TEST_P(SortBufferTest, emptySpill) {
-  const std::shared_ptr<memory::MemoryPool> fuzzerPool =
-      memory::memoryManager()->addLeafPool("emptySpillSource");
-
   for (bool hasPostSpillData : {false, true}) {
     SCOPED_TRACE(fmt::format("hasPostSpillData {}", hasPostSpillData));
-    auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto spillDirectory = TempDirectoryPath::create();
     auto spillConfig = getSpillConfig(spillDirectory->getPath());
-    folly::Synchronized<common::SpillStats> spillStats;
+    exec::SpillStats spillStats;
     auto sortBuffer = std::make_unique<SortBuffer>(
         inputType_,
         sortColumnIndices_,
@@ -797,11 +788,11 @@ TEST_P(SortBufferTest, emptySpill) {
 
     sortBuffer->spill();
     if (hasPostSpillData) {
-      VectorFuzzer fuzzer({.vectorSize = 1024}, fuzzerPool.get());
+      VectorFuzzer fuzzer({.vectorSize = 1024}, fuzzerPool_.get());
       sortBuffer->addInput(fuzzer.fuzzRow(inputType_));
     }
     sortBuffer->noMoreInput();
-    ASSERT_TRUE(spillStats.rlock()->empty());
+    ASSERT_TRUE(spillStats.empty());
   }
 }
 
diff --git a/velox/exec/tests/SpatialIndexTest.cpp b/velox/exec/tests/SpatialIndexTest.cpp
new file mode 100644
index 00000000000..e2a7778cd52
--- /dev/null
+++ b/velox/exec/tests/SpatialIndexTest.cpp
@@ -0,0 +1,550 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/SpatialIndex.h"
+#include <gtest/gtest.h>
+#include <algorithm>
+
+using namespace ::testing;
+using namespace facebook::velox::exec;
+
+namespace facebook::velox::exec::test {
+
+class SpatialIndexTest : public virtual testing::Test {
+ protected:
+  void makeIndex(
+      std::vector<Envelope> envelopes,
+      uint32_t branchSize = SpatialIndex::kDefaultRTreeBranchSize) {
+    branchSize_ = branchSize;
+    Envelope bounds = Envelope::of(envelopes);
+    index_ = SpatialIndex(std::move(bounds), std::move(envelopes), branchSize);
+  }
+
+  Envelope indexBounds() const {
+    return index_.bounds();
+  }
+
+  void assertQuery(
+      double minX,
+      double minY,
+      double maxX,
+      double maxY,
+      std::vector<int32_t> expected) const {
+    std::vector<int32_t> actual =
+        index_.query(Envelope::from(minX, minY, maxX, maxY));
+    std::sort(actual.begin(), actual.end());
+    std::sort(expected.begin(), expected.end());
+    ASSERT_EQ(actual, expected);
+  }
+
+  SpatialIndex index_;
+  uint32_t branchSize_ = SpatialIndex::kDefaultRTreeBranchSize;
+};
+
+TEST_F(SpatialIndexTest, testEnvelope) {
+  Envelope empty = Envelope::empty();
+  ASSERT_TRUE(empty.isEmpty());
+  ASSERT_FALSE(Envelope::intersects(empty, empty));
+
+  Envelope point =
+      Envelope{.minX = 0, .minY = 0, .maxX = 0, .maxY = 0, .rowIndex = -1};
+  ASSERT_FALSE(point.isEmpty());
+  ASSERT_FALSE(Envelope::intersects(empty, point));
+  ASSERT_TRUE(Envelope::intersects(point, point));
+}
+
+TEST_F(SpatialIndexTest, testNaNHandling) {
+  float nan = std::numeric_limits<float>::quiet_NaN();
+
+  Envelope envWithNaN{
+      .minX = nan, .minY = 0, .maxX = 1, .maxY = 1, .rowIndex = 0};
+  ASSERT_TRUE(envWithNaN.isEmpty());
+
+  Envelope envWithNaN2{
+      .minX = 0, .minY = 0, .maxX = nan, .maxY = 1, .rowIndex = 0};
+  ASSERT_TRUE(envWithNaN2.isEmpty());
+
+  Envelope envWithNaN3{
+      .minX = 0, .minY = nan, .maxX = 1, .maxY = 1, .rowIndex = 0};
+  ASSERT_TRUE(envWithNaN3.isEmpty());
+
+  Envelope envWithNaN4{
+      .minX = 0, .minY = 0, .maxX = 1, .maxY = nan, .rowIndex = 0};
+  ASSERT_TRUE(envWithNaN4.isEmpty());
+
+  Envelope envWithNaN5{
+      .minX = nan, .minY = nan, .maxX = nan, .maxY = nan, .rowIndex = 0};
+  ASSERT_TRUE(envWithNaN5.isEmpty());
+}
+
+TEST_F(SpatialIndexTest, testEmptyIndex) {
+  makeIndex(std::vector<Envelope>{});
+  Envelope bounds = indexBounds();
+  ASSERT_EQ(bounds.minX, std::numeric_limits<double>::infinity());
+  ASSERT_EQ(bounds.minY, std::numeric_limits<double>::infinity());
+  ASSERT_EQ(bounds.maxX, -std::numeric_limits<double>::infinity());
+  ASSERT_EQ(bounds.maxY, -std::numeric_limits<double>::infinity());
+  ASSERT_EQ(bounds.rowIndex, -1);
+
+  assertQuery(0, 0, 1, 1, {});
+}
+
+TEST_F(SpatialIndexTest, testSingleEnvelope) {
+  makeIndex(
+      std::vector<Envelope>{Envelope{
+          .minX = 1, .minY = 11, .maxX = 2, .maxY = 12, .rowIndex = 0}});
+
+  Envelope bounds = indexBounds();
+  ASSERT_EQ(bounds.minX, 1);
+  ASSERT_EQ(bounds.minY, 11);
+  ASSERT_EQ(bounds.maxX, 2);
+  ASSERT_EQ(bounds.maxY, 12);
+
+  assertQuery(1.5, 11.5, 1.5, 11.5, {0});
+  assertQuery(0.5, 10.5, 1.5, 11.5, {0});
+  assertQuery(0, 10, 0.5, 10.5, {});
+  assertQuery(3, 13, 4, 14, {});
+}
+
+TEST_F(SpatialIndexTest, testPointProbe) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 1, .minY = 0, .maxX = 1, .maxY = 0, .rowIndex = 6},
+          Envelope{.minX = 0, .minY = 0, .maxX = 0, .maxY = 0, .rowIndex = 5},
+          Envelope{.minX = 0, .minY = 0, .maxX = 1, .maxY = 1, .rowIndex = 4},
+          Envelope{.minX = -1, .minY = -1, .maxX = 0, .maxY = 0, .rowIndex = 3},
+          Envelope{.minX = -1, .minY = -1, .maxX = 1, .maxY = 1, .rowIndex = 2},
+          Envelope{
+              .minX = 0.5, .minY = 0.5, .maxX = 1, .maxY = 1, .rowIndex = 1},
+      });
+  Envelope bounds = indexBounds();
+  ASSERT_EQ(bounds.minX, -1);
+  ASSERT_EQ(bounds.minY, -1);
+  ASSERT_EQ(bounds.maxX, 1);
+  ASSERT_EQ(bounds.maxY, 1);
+  ASSERT_EQ(bounds.rowIndex, -1);
+
+  assertQuery(0, 0, 0, 0, {2, 3, 4, 5});
+  assertQuery(0, 1, 0, 1, {2, 4});
+}
+
+TEST_F(SpatialIndexTest, testFloatImprecision) {
+  // Since the index casts doubles to floats then nudges the result,
+  // we should make sure that the index gives the right results on
+  // cases where the double doesn't have an exact float representation.
+  float float1 = 1.0f;
+  float float1Down =
+      std::nextafterf(float1, -std::numeric_limits<float>::infinity());
+  float float2 = 2.0f;
+  float float2Up =
+      std::nextafterf(float2, std::numeric_limits<float>::infinity());
+
+  double baseMax = static_cast<double>(float2);
+  double baseMaxUp =
+      std::nextafter<double>(baseMax, std::numeric_limits<double>::infinity());
+  double baseMaxDown =
+      std::nextafter<double>(baseMax, -std::numeric_limits<double>::infinity());
+  double baseMin = static_cast<double>(float1);
+  double baseMinUp =
+      std::nextafter<double>(baseMin, std::numeric_limits<double>::infinity());
+  double baseMinDown =
+      std::nextafter<double>(baseMin, -std::numeric_limits<double>::infinity());
+
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope::from(baseMin, baseMin, baseMax, baseMax, 1),
+          Envelope::from(baseMinUp, baseMinUp, baseMaxUp, baseMaxUp, 2),
+          Envelope::from(baseMinDown, baseMinDown, baseMaxDown, baseMaxDown, 3),
+      });
+
+  Envelope bounds = indexBounds();
+  ASSERT_EQ(bounds.minX, float1Down);
+  ASSERT_EQ(bounds.minY, float1Down);
+  ASSERT_EQ(bounds.maxX, float2Up);
+  ASSERT_EQ(bounds.maxY, float2Up);
+
+  assertQuery(2.1, 2.1, 2.1, 2.1, {});
+  assertQuery(baseMin, baseMin, baseMin, baseMin, {1, 2, 3});
+  assertQuery(baseMinDown, baseMinDown, baseMinDown, baseMinDown, {1, 2, 3});
+  assertQuery(baseMinUp, baseMinUp, baseMinUp, baseMinUp, {1, 2, 3});
+  assertQuery(baseMax, baseMax, baseMax, baseMax, {1, 2, 3});
+  assertQuery(baseMaxDown, baseMaxDown, baseMaxDown, baseMaxDown, {1, 2, 3});
+  assertQuery(baseMaxUp, baseMaxUp, baseMaxUp, baseMaxUp, {1, 2, 3});
+}
+
+TEST_F(SpatialIndexTest, testFloatImprecisionSubnormal) {
+  // Check that our bumping rules work for subnormal floats as well.
+  float subnormalFloatDown =
+      std::nextafterf(0.0, -std::numeric_limits<float>::infinity());
+  float subnormalFloatUp =
+      std::nextafterf(0.0, std::numeric_limits<float>::infinity());
+
+  double subnormalDoubleDown =
+      std::nextafter<double>(0.0, -std::numeric_limits<double>::infinity());
+  double subnormalDoubleUp =
+      std::nextafter<double>(0.0, std::numeric_limits<double>::infinity());
+
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope::from(0.0, 0.0, 0.0, 0.0, 1),
+          Envelope::from(
+              subnormalDoubleDown,
+              subnormalDoubleDown,
+              subnormalDoubleDown,
+              subnormalDoubleDown,
+              2),
+          Envelope::from(
+              subnormalDoubleUp,
+              subnormalDoubleUp,
+              subnormalDoubleUp,
+              subnormalDoubleUp,
+              3),
+          Envelope::from(
+              subnormalDoubleDown,
+              subnormalDoubleDown,
+              subnormalDoubleUp,
+              subnormalDoubleUp,
+              4),
+      });
+
+  Envelope bounds = indexBounds();
+  ASSERT_EQ(bounds.minX, subnormalFloatDown);
+  ASSERT_EQ(bounds.minY, subnormalFloatDown);
+  ASSERT_EQ(bounds.maxX, subnormalFloatUp);
+  ASSERT_EQ(bounds.maxY, subnormalFloatUp);
+
+  assertQuery(0.1, 0.1, 0.1, 0.1, {});
+  assertQuery(0.0, 0.0, 0.0, 0.0, {1, 2, 3, 4});
+  assertQuery(
+      subnormalDoubleDown,
+      subnormalDoubleDown,
+      subnormalDoubleDown,
+      subnormalDoubleDown,
+      {1, 2, 3, 4});
+  assertQuery(
+      subnormalDoubleUp,
+      subnormalDoubleUp,
+      subnormalDoubleUp,
+      subnormalDoubleUp,
+      {1, 2, 3, 4});
+  assertQuery(
+      subnormalDoubleDown,
+      subnormalDoubleDown,
+      subnormalDoubleUp,
+      subnormalDoubleUp,
+      {1, 2, 3, 4});
+}
+
+TEST_F(SpatialIndexTest, testNegativeCoordinates) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{
+              .minX = -5, .minY = -5, .maxX = -1, .maxY = -1, .rowIndex = 0},
+          Envelope{
+              .minX = -10, .minY = -10, .maxX = -6, .maxY = -6, .rowIndex = 1},
+          Envelope{
+              .minX = -3, .minY = -8, .maxX = 2, .maxY = -4, .rowIndex = 2}});
+
+  Envelope bounds = indexBounds();
+  ASSERT_EQ(bounds.minX, -10);
+  ASSERT_EQ(bounds.minY, -10);
+  ASSERT_EQ(bounds.maxX, 2);
+  ASSERT_EQ(bounds.maxY, -1);
+
+  assertQuery(-7, -7, -7, -7, {1});
+  assertQuery(-2, -5, -2, -5, {0, 2});
+  assertQuery(0, 0, 1, 1, {});
+}
+
+TEST_F(SpatialIndexTest, testOverlappingEnvelopes) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 0, .minY = 0, .maxX = 10, .maxY = 10, .rowIndex = 0},
+          Envelope{.minX = 5, .minY = 5, .maxX = 15, .maxY = 15, .rowIndex = 1},
+          Envelope{.minX = 2, .minY = 2, .maxX = 8, .maxY = 8, .rowIndex = 2},
+          Envelope{
+              .minX = 7, .minY = 7, .maxX = 12, .maxY = 12, .rowIndex = 3}});
+
+  assertQuery(6, 6, 6, 6, {0, 1, 2});
+  assertQuery(8, 8, 8, 8, {0, 1, 2, 3});
+  assertQuery(9, 9, 9, 9, {0, 1, 3});
+  assertQuery(3, 3, 3, 3, {0, 2});
+  assertQuery(13, 13, 13, 13, {1});
+}
+
+TEST_F(SpatialIndexTest, testNonOverlappingEnvelopes) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 0, .minY = 0, .maxX = 1, .maxY = 1, .rowIndex = 0},
+          Envelope{.minX = 2, .minY = 2, .maxX = 3, .maxY = 3, .rowIndex = 1},
+          Envelope{.minX = 4, .minY = 4, .maxX = 5, .maxY = 5, .rowIndex = 2},
+          Envelope{.minX = 6, .minY = 6, .maxX = 7, .maxY = 7, .rowIndex = 3}});
+
+  assertQuery(0.5, 0.5, 0.5, 0.5, {0});
+  assertQuery(2.5, 2.5, 2.5, 2.5, {1});
+  assertQuery(4.5, 4.5, 4.5, 4.5, {2});
+  assertQuery(6.5, 6.5, 6.5, 6.5, {3});
+  assertQuery(1.5, 1.5, 1.5, 1.5, {});
+}
+
+TEST_F(SpatialIndexTest, testLargeQueryEnvelope) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 1, .minY = 1, .maxX = 2, .maxY = 2, .rowIndex = 0},
+          Envelope{.minX = 3, .minY = 3, .maxX = 4, .maxY = 4, .rowIndex = 1},
+          Envelope{.minX = 5, .minY = 5, .maxX = 6, .maxY = 6, .rowIndex = 2}});
+
+  assertQuery(0, 0, 10, 10, {0, 1, 2});
+  assertQuery(-100, -100, 100, 100, {0, 1, 2});
+}
+
+TEST_F(SpatialIndexTest, testSmallQueryEnvelope) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{
+              .minX = 0, .minY = 0, .maxX = 100, .maxY = 100, .rowIndex = 0},
+          Envelope{
+              .minX = 50,
+              .minY = 50,
+              .maxX = 150,
+              .maxY = 150,
+              .rowIndex = 1}});
+
+  assertQuery(25, 25, 26, 26, {0});
+  assertQuery(75, 75, 76, 76, {0, 1});
+  assertQuery(125, 125, 126, 126, {1});
+  assertQuery(0.1, 0.1, 0.2, 0.2, {0});
+}
+
+TEST_F(SpatialIndexTest, testEdgeTouching) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 0, .minY = 0, .maxX = 5, .maxY = 5, .rowIndex = 0},
+          Envelope{.minX = 5, .minY = 0, .maxX = 10, .maxY = 5, .rowIndex = 1},
+          Envelope{.minX = 0, .minY = 5, .maxX = 5, .maxY = 10, .rowIndex = 2},
+          Envelope{
+              .minX = 5, .minY = 5, .maxX = 10, .maxY = 10, .rowIndex = 3}});
+
+  assertQuery(5, 5, 5, 5, {0, 1, 2, 3});
+  assertQuery(5, 2, 5, 2, {0, 1});
+  assertQuery(2, 5, 2, 5, {0, 2});
+}
+
+TEST_F(SpatialIndexTest, testCornerTouching) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 0, .minY = 0, .maxX = 5, .maxY = 5, .rowIndex = 0},
+          Envelope{
+              .minX = 5, .minY = 5, .maxX = 10, .maxY = 10, .rowIndex = 1}});
+
+  assertQuery(5, 5, 5, 5, {0, 1});
+  assertQuery(4.9, 4.9, 5.1, 5.1, {0, 1});
+}
+
+TEST_F(SpatialIndexTest, testInfiniteValues) {
+  float inf = std::numeric_limits<float>::infinity();
+  float negInf = -std::numeric_limits<float>::infinity();
+
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 0, .minY = 0, .maxX = 1, .maxY = 1, .rowIndex = 0}});
+
+  assertQuery(inf, inf, inf, inf, {});
+  assertQuery(negInf, negInf, negInf, negInf, {});
+  assertQuery(negInf, negInf, inf, inf, {0});
+}
+
+TEST_F(SpatialIndexTest, testLargeDataset) {
+  std::vector<Envelope> envelopes;
+  envelopes.reserve(1000);
+  for (int i = 0; i < 1000; ++i) {
+    envelopes.push_back(
+        Envelope{
+            .minX = static_cast<float>(i),
+            .minY = static_cast<float>(i),
+            .maxX = static_cast<float>(i + 1),
+            .maxY = static_cast<float>(i + 1),
+            .rowIndex = i});
+  }
+  makeIndex(std::move(envelopes));
+
+  assertQuery(500.5, 500.5, 500.5, 500.5, {500});
+  assertQuery(100.5, 100.5, 104.5, 104.5, {100, 101, 102, 103, 104});
+  assertQuery(-1, -1, -1, -1, {});
+  assertQuery(1001, 1001, 1001, 1001, {});
+
+  Envelope bounds = indexBounds();
+  ASSERT_EQ(bounds.minX, 0);
+  ASSERT_EQ(bounds.minY, 0);
+  ASSERT_EQ(bounds.maxX, 1000);
+  ASSERT_EQ(bounds.maxY, 1000);
+}
+
+TEST_F(SpatialIndexTest, testVeryLargeCoordinates) {
+  float largeVal = 1e20f;
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{
+              .minX = -largeVal,
+              .minY = -largeVal,
+              .maxX = -largeVal + 1,
+              .maxY = -largeVal + 1,
+              .rowIndex = 0},
+          Envelope{
+              .minX = largeVal - 1,
+              .minY = largeVal - 1,
+              .maxX = largeVal,
+              .maxY = largeVal,
+              .rowIndex = 1}});
+
+  assertQuery(
+      -largeVal + 0.5, -largeVal + 0.5, -largeVal + 0.5, -largeVal + 0.5, {0});
+  assertQuery(
+      largeVal - 0.5, largeVal - 0.5, largeVal - 0.5, largeVal - 0.5, {1});
+  assertQuery(0, 0, 0, 0, {});
+}
+
+TEST_F(SpatialIndexTest, testQueryOutsideBounds) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 0, .minY = 0, .maxX = 10, .maxY = 10, .rowIndex = 0},
+          Envelope{
+              .minX = 5, .minY = 5, .maxX = 15, .maxY = 15, .rowIndex = 1}});
+
+  assertQuery(-10, -10, -5, -5, {});
+  assertQuery(20, 20, 25, 25, {});
+  assertQuery(-10, 5, -5, 10, {});
+  assertQuery(5, 20, 10, 25, {});
+}
+
+TEST_F(SpatialIndexTest, testPartialOverlap) {
+  makeIndex(
+      std::vector<Envelope>{Envelope{
+          .minX = 0, .minY = 0, .maxX = 10, .maxY = 10, .rowIndex = 0}});
+
+  assertQuery(-5, -5, 5, 5, {0});
+  assertQuery(5, -5, 15, 5, {0});
+  assertQuery(-5, 5, 5, 15, {0});
+  assertQuery(5, 5, 15, 15, {0});
+}
+
+TEST_F(SpatialIndexTest, testMixedSizeEnvelopes) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{
+              .minX = 0, .minY = 0, .maxX = 0.1, .maxY = 0.1, .rowIndex = 0},
+          Envelope{
+              .minX = 1, .minY = 1, .maxX = 100, .maxY = 100, .rowIndex = 1},
+          Envelope{
+              .minX = 50, .minY = 50, .maxX = 51, .maxY = 51, .rowIndex = 2}});
+
+  assertQuery(0.05, 0.05, 0.05, 0.05, {0});
+  assertQuery(50, 50, 100, 100, {1, 2});
+  assertQuery(25, 25, 25, 25, {1});
+}
+
+TEST_F(SpatialIndexTest, testZeroAreaEnvelopes) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 0, .minY = 0, .maxX = 0, .maxY = 0, .rowIndex = 0},
+          Envelope{.minX = 1, .minY = 1, .maxX = 1, .maxY = 1, .rowIndex = 1},
+          Envelope{.minX = 2, .minY = 2, .maxX = 2, .maxY = 2, .rowIndex = 2}});
+
+  assertQuery(0, 0, 0, 0, {0});
+  assertQuery(1, 1, 1, 1, {1});
+  assertQuery(2, 2, 2, 2, {2});
+  assertQuery(0.5, 0.5, 0.5, 0.5, {});
+  assertQuery(0, 0, 2, 2, {0, 1, 2});
+}
+
+TEST_F(SpatialIndexTest, testIdenticalEnvelopes) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 5, .minY = 5, .maxX = 10, .maxY = 10, .rowIndex = 0},
+          Envelope{.minX = 5, .minY = 5, .maxX = 10, .maxY = 10, .rowIndex = 1},
+          Envelope{
+              .minX = 5, .minY = 5, .maxX = 10, .maxY = 10, .rowIndex = 2}});
+
+  assertQuery(7, 7, 7, 7, {0, 1, 2});
+  assertQuery(5, 5, 10, 10, {0, 1, 2});
+  assertQuery(4, 4, 4, 4, {});
+}
+
+TEST_F(SpatialIndexTest, testDifferentBranchSizes) {
+  std::vector<uint32_t> branchSizes = {2, 3, 4, 8, 16, 32, 64, 128, 256};
+
+  for (uint32_t branchSize : branchSizes) {
+    std::vector<Envelope> envelopes;
+    envelopes.reserve(100);
+    for (int i = 0; i < 100; ++i) {
+      envelopes.push_back(
+          Envelope{
+              .minX = static_cast<float>(i),
+              .minY = static_cast<float>(i),
+              .maxX = static_cast<float>(i + 1),
+              .maxY = static_cast<float>(i + 1),
+              .rowIndex = i});
+    }
+    makeIndex(std::move(envelopes), branchSize);
+
+    assertQuery(50.5, 50.5, 50.5, 50.5, {50});
+    assertQuery(10.5, 10.5, 14.5, 14.5, {10, 11, 12, 13, 14});
+    assertQuery(-1, -1, -1, -1, {});
+    assertQuery(101, 101, 101, 101, {});
+
+    Envelope bounds = indexBounds();
+    ASSERT_EQ(bounds.minX, 0);
+    ASSERT_EQ(bounds.minY, 0);
+    ASSERT_EQ(bounds.maxX, 100);
+    ASSERT_EQ(bounds.maxY, 100);
+  }
+}
+
+TEST_F(SpatialIndexTest, testSmallBranchSize) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 0, .minY = 0, .maxX = 10, .maxY = 10, .rowIndex = 0},
+          Envelope{.minX = 5, .minY = 5, .maxX = 15, .maxY = 15, .rowIndex = 1},
+          Envelope{.minX = 2, .minY = 2, .maxX = 8, .maxY = 8, .rowIndex = 2},
+          Envelope{
+              .minX = 7, .minY = 7, .maxX = 12, .maxY = 12, .rowIndex = 3}},
+      2);
+
+  assertQuery(6, 6, 6, 6, {0, 1, 2});
+  assertQuery(8, 8, 8, 8, {0, 1, 2, 3});
+  assertQuery(9, 9, 9, 9, {0, 1, 3});
+  assertQuery(3, 3, 3, 3, {0, 2});
+  assertQuery(13, 13, 13, 13, {1});
+}
+
+TEST_F(SpatialIndexTest, testLargeBranchSize) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 0, .minY = 0, .maxX = 10, .maxY = 10, .rowIndex = 0},
+          Envelope{.minX = 5, .minY = 5, .maxX = 15, .maxY = 15, .rowIndex = 1},
+          Envelope{.minX = 2, .minY = 2, .maxX = 8, .maxY = 8, .rowIndex = 2},
+          Envelope{
+              .minX = 7, .minY = 7, .maxX = 12, .maxY = 12, .rowIndex = 3}},
+      512);
+
+  assertQuery(6, 6, 6, 6, {0, 1, 2});
+  assertQuery(8, 8, 8, 8, {0, 1, 2, 3});
+  assertQuery(9, 9, 9, 9, {0, 1, 3});
+  assertQuery(3, 3, 3, 3, {0, 2});
+  assertQuery(13, 13, 13, 13, {1});
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/SpatialJoinTest.cpp b/velox/exec/tests/SpatialJoinTest.cpp
index 539f132c6e6..01606121a40 100644
--- a/velox/exec/tests/SpatialJoinTest.cpp
+++ b/velox/exec/tests/SpatialJoinTest.cpp
@@ -16,6 +16,7 @@
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/core/PlanFragment.h"
 #include "velox/core/PlanNode.h"
+#include "velox/core/QueryConfig.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
@@ -67,56 +68,40 @@ class SpatialJoinTest : public OperatorTestBase {
   void runTest(
       const std::vector<std::optional<std::string_view>>& probeWkts,
       const std::vector<std::optional<std::string_view>>& buildWkts,
+      const std::optional<const std::vector<std::optional<double>>>& radiiOpt,
       const std::string& predicate,
       core::JoinType joinType,
       const std::vector<std::optional<std::string_view>>& expectedLeftWkts,
       const std::vector<std::optional<std::string_view>>& expectedRightWkts) {
-    runTestWithDrivers(
-        probeWkts,
-        buildWkts,
-        predicate,
-        joinType,
-        expectedLeftWkts,
-        expectedRightWkts,
-        1,
-        false);
-    runTestWithDrivers(
-        probeWkts,
-        buildWkts,
-        predicate,
-        joinType,
-        expectedLeftWkts,
-        expectedRightWkts,
-        1,
-        true);
-    runTestWithDrivers(
-        probeWkts,
-        buildWkts,
-        predicate,
-        joinType,
-        expectedLeftWkts,
-        expectedRightWkts,
-        4,
-        false);
-    runTestWithDrivers(
-        probeWkts,
-        buildWkts,
-        predicate,
-        joinType,
-        expectedLeftWkts,
-        expectedRightWkts,
-        4,
-        true);
+    for (bool separateProbeBatches : {false, true}) {
+      for (size_t maxBatchSize : {128, 3, 2, 1}) {
+        for (int32_t maxDrivers : {1, 4}) {
+          runTestWithConfig(
+              probeWkts,
+              buildWkts,
+              radiiOpt,
+              predicate,
+              joinType,
+              expectedLeftWkts,
+              expectedRightWkts,
+              maxDrivers,
+              maxBatchSize,
+              separateProbeBatches);
+        }
+      }
+    }
   }
 
-  void runTestWithDrivers(
+  void runTestWithConfig(
       const std::vector<std::optional<std::string_view>>& probeWkts,
       const std::vector<std::optional<std::string_view>>& buildWkts,
+      const std::optional<const std::vector<std::optional<double>>>& radiiOpt,
       const std::string& predicate,
       core::JoinType joinType,
       const std::vector<std::optional<std::string_view>>& expectedLeftWkts,
       const std::vector<std::optional<std::string_view>>& expectedRightWkts,
       int32_t maxDrivers,
+      size_t maxBatchSize,
       bool separateBatches) {
     std::vector<std::optional<std::string>> probeWktsStr(
         probeWkts.begin(), probeWkts.end());
@@ -126,6 +111,13 @@ class SpatialJoinTest : public OperatorTestBase {
         expectedLeftWkts.begin(), expectedLeftWkts.end());
     std::vector<std::optional<std::string>> expectedRightWktsStr(
         expectedRightWkts.begin(), expectedRightWkts.end());
+    auto radii = radiiOpt.value_or(
+        std::vector<std::optional<double>>(buildWkts.size(), std::nullopt));
+    VELOX_CHECK_EQ(radii.size(), buildWkts.size());
+    std::optional<std::string> radiusVariable = std::nullopt;
+    if (radiiOpt.has_value()) {
+      radiusVariable = "radius";
+    }
 
     std::vector<RowVectorPtr> probeBatches;
     std::vector<RowVectorPtr> buildBatches;
@@ -134,15 +126,31 @@ class SpatialJoinTest : public OperatorTestBase {
         probeBatches.push_back(makeRowVector(
             {"left_g"}, {makeNullableFlatVector<std::string>({wkt})}));
       }
-      for (const auto& wkt : buildWktsStr) {
+      if (probeBatches.empty()) {
+        probeBatches.push_back(makeRowVector(
+            {"left_g"}, {makeNullableFlatVector<std::string>({})}));
+      }
+
+      for (size_t idx = 0; idx < buildWktsStr.size(); ++idx) {
+        auto& wkt = buildWktsStr[idx];
+        buildBatches.push_back(makeRowVector(
+            {"right_g", "radius"},
+            {makeNullableFlatVector<std::string>({wkt}),
+             makeNullableFlatVector<double>({radii[idx]})}));
+      }
+      if (buildBatches.empty()) {
         buildBatches.push_back(makeRowVector(
-            {"right_g"}, {makeNullableFlatVector<std::string>({wkt})}));
+            {"right_g", "radius"},
+            {makeNullableFlatVector<std::string>({}),
+             makeNullableFlatVector<double>({})}));
       }
     } else {
       probeBatches.push_back(makeRowVector(
           {"left_g"}, {makeNullableFlatVector<std::string>(probeWktsStr)}));
       buildBatches.push_back(makeRowVector(
-          {"right_g"}, {makeNullableFlatVector<std::string>(buildWktsStr)}));
+          {"right_g", "radius"},
+          {makeNullableFlatVector<std::string>(buildWktsStr),
+           makeNullableFlatVector<double>(radii)}));
     }
     auto expectedRows = makeRowVector(
         {"left_g", "right_g"},
@@ -158,10 +166,14 @@ class SpatialJoinTest : public OperatorTestBase {
             .spatialJoin(
                 PlanBuilder(planNodeIdGenerator)
                     .values(buildBatches)
-                    .project({"ST_GeometryFromText(right_g) AS right_g"})
+                    .project(
+                        {"ST_GeometryFromText(right_g) AS right_g", "radius"})
                     .localPartition({})
                     .planNode(),
                 predicate,
+                "left_g",
+                "right_g",
+                radiusVariable,
                 {"left_g", "right_g"},
                 joinType)
             .project(
@@ -169,27 +181,79 @@ class SpatialJoinTest : public OperatorTestBase {
                  "ST_AsText(right_g) AS right_g"})
             .planNode();
     AssertQueryBuilder builder{plan};
-    builder.maxDrivers(maxDrivers).assertResults({expectedRows});
+    builder.maxDrivers(maxDrivers)
+        .config(core::QueryConfig::kPreferredOutputBatchRows, maxBatchSize)
+        .config(core::QueryConfig::kMaxOutputBatchRows, maxBatchSize)
+        .assertResults({expectedRows});
   }
 };
-TEST_F(SpatialJoinTest, simpleSpatialJoin) {
+
+TEST_F(SpatialJoinTest, testTrivialSpatialJoin) {
+  runTest(
+      {"POINT (1 1)"},
+      {"POINT (1 1)"},
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kInner,
+      {"POINT (1 1)"},
+      {"POINT (1 1)"});
+}
+
+TEST_F(SpatialJoinTest, testSimpleSpatialInnerJoin) {
   runTest(
       {"POINT (1 1)", "POINT (1 2)"},
       {"POINT (1 1)", "POINT (2 1)"},
+      std::nullopt,
       "ST_Intersects(left_g, right_g)",
       core::JoinType::kInner,
       {"POINT (1 1)"},
       {"POINT (1 1)"});
+}
+
+TEST_F(SpatialJoinTest, testSimpleSpatialLeftJoin) {
   runTest(
       {"POINT (1 1)", "POINT (1 2)"},
       {"POINT (1 1)", "POINT (2 1)"},
+      std::nullopt,
       "ST_Intersects(left_g, right_g)",
       core::JoinType::kLeft,
       {"POINT (1 1)", "POINT (1 2)"},
       {"POINT (1 1)", std::nullopt});
 }
 
-TEST_F(SpatialJoinTest, selfSpatialJoin) {
+TEST_F(SpatialJoinTest, testSpatialJoinNullRows) {
+  runTest(
+      {"POINT (0 0)", std::nullopt, "POINT (1 1)", std::nullopt},
+      {"POINT (0 0)", "POINT (1 1)", std::nullopt, std::nullopt},
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kInner,
+      {"POINT (0 0)", "POINT (1 1)"},
+      {"POINT (0 0)", "POINT (1 1)"});
+  runTest(
+      {"POINT (0 0)", std::nullopt, "POINT (2 2)", std::nullopt},
+      {"POINT (0 0)", "POINT (1 1)", std::nullopt, std::nullopt},
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kLeft,
+      {"POINT (0 0)", "POINT (2 2)", std::nullopt, std::nullopt},
+      {"POINT (0 0)", std::nullopt, std::nullopt, std::nullopt});
+}
+
+// Test geometries that don't intersect but their envelopes do.
+// Important to test spatial index
+TEST_F(SpatialJoinTest, simpleSpatialJoinEnvelopes) {
+  runTest(
+      {"POINT (0.5 0.6)", "POINT (0.5 0.5)", "LINESTRING (0 0.1, 0.9 1)"},
+      {"POLYGON ((0 0, 1 1, 1 0, 0 0))"},
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kInner,
+      {"POINT (0.5 0.5)"},
+      {"POLYGON ((0 0, 1 1, 1 0, 0 0))"});
+}
+
+TEST_F(SpatialJoinTest, testSelfSpatialJoin) {
   std::vector<std::optional<std::string_view>> inputWkts = {
       kPolygonA, kPolygonB, kPolygonC, kPolygonD};
   std::vector<std::optional<std::string_view>> leftOutputWkts = {
@@ -200,6 +264,7 @@ TEST_F(SpatialJoinTest, selfSpatialJoin) {
   runTest(
       inputWkts,
       inputWkts,
+      std::nullopt,
       "ST_Intersects(left_g, right_g)",
       core::JoinType::kInner,
       leftOutputWkts,
@@ -208,6 +273,7 @@ TEST_F(SpatialJoinTest, selfSpatialJoin) {
   runTest(
       inputWkts,
       inputWkts,
+      std::nullopt,
       "ST_Intersects(left_g, right_g)",
       core::JoinType::kLeft,
       leftOutputWkts,
@@ -216,6 +282,7 @@ TEST_F(SpatialJoinTest, selfSpatialJoin) {
   runTest(
       inputWkts,
       inputWkts,
+      std::nullopt,
       "ST_Overlaps(left_g, right_g)",
       core::JoinType::kInner,
       {kPolygonA, kPolygonB},
@@ -224,6 +291,7 @@ TEST_F(SpatialJoinTest, selfSpatialJoin) {
   runTest(
       inputWkts,
       inputWkts,
+      std::nullopt,
       "ST_Intersects(left_g, right_g) AND ST_Overlaps(left_g, right_g)",
       core::JoinType::kInner,
       {kPolygonA, kPolygonB},
@@ -232,6 +300,7 @@ TEST_F(SpatialJoinTest, selfSpatialJoin) {
   runTest(
       inputWkts,
       inputWkts,
+      std::nullopt,
       "ST_Overlaps(left_g, right_g)",
       core::JoinType::kLeft,
       {kPolygonA, kPolygonB, kPolygonC, kPolygonD},
@@ -240,6 +309,7 @@ TEST_F(SpatialJoinTest, selfSpatialJoin) {
   runTest(
       inputWkts,
       inputWkts,
+      std::nullopt,
       "ST_Equals(left_g, right_g)",
       core::JoinType::kInner,
       inputWkts,
@@ -248,6 +318,7 @@ TEST_F(SpatialJoinTest, selfSpatialJoin) {
   runTest(
       inputWkts,
       inputWkts,
+      std::nullopt,
       "ST_Equals(left_g, right_g)",
       core::JoinType::kLeft,
       inputWkts,
@@ -294,12 +365,314 @@ TEST_F(SpatialJoinTest, pointPolygonSpatialJoin) {
   runTest(
       pointWkts,
       polygonWkts,
+      std::nullopt,
       "ST_Intersects(left_g, right_g)",
       core::JoinType::kInner,
       pointOutputWkts,
       polygonOutputWkts);
 }
 
+TEST_F(SpatialJoinTest, testSimpleNullRowsJoin) {
+  runTest(
+      {"POINT (1 1)", std::nullopt, "POINT (1 2)"},
+      {"POINT (1 1)", "POINT (2 1)", std::nullopt},
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kInner,
+      {"POINT (1 1)"},
+      {"POINT (1 1)"});
+}
+
+TEST_F(SpatialJoinTest, testGeometryCollection) {
+  runTest(
+      {"GEOMETRYCOLLECTION (POINT (1 1))",
+       "GEOMETRYCOLLECTION EMPTY",
+       "POINT (1 1)"},
+      {"GEOMETRYCOLLECTION (POINT (1 1))",
+       "GEOMETRYCOLLECTION EMPTY",
+       "POINT (1 1)"},
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kInner,
+      {"GEOMETRYCOLLECTION (POINT (1 1))",
+       "GEOMETRYCOLLECTION (POINT (1 1))",
+       "POINT (1 1)",
+       "POINT (1 1)"},
+      {"GEOMETRYCOLLECTION (POINT (1 1))",
+       "POINT (1 1)",
+       "GEOMETRYCOLLECTION (POINT (1 1))",
+       "POINT (1 1)"});
+
+  runTest(
+      {"GEOMETRYCOLLECTION (POINT (1 1))",
+       "GEOMETRYCOLLECTION EMPTY",
+       "POINT (1 1)"},
+      {"GEOMETRYCOLLECTION (POINT (1 2))",
+       "GEOMETRYCOLLECTION EMPTY",
+       "POINT (1 2)"},
+      std::vector<std::optional<double>>{1.0, 1.0, 1.0},
+      "ST_Distance(left_g, right_g) <= radius",
+      core::JoinType::kInner,
+      {"GEOMETRYCOLLECTION (POINT (1 1))",
+       "GEOMETRYCOLLECTION (POINT (1 1))",
+       "POINT (1 1)",
+       "POINT (1 1)"},
+      {"GEOMETRYCOLLECTION (POINT (1 2))",
+       "POINT (1 2)",
+       "GEOMETRYCOLLECTION (POINT (1 2))",
+       "POINT (1 2)"});
+}
+
+TEST_F(SpatialJoinTest, testDistanceJoin) {
+  runTest(
+      {"POINT (1 2)", "POLYGON ((1 2, 2 2, 2 3, 1 3, 1 2))", std::nullopt},
+      {"POINT (2 2)",
+       "POINT (1 1)",
+       std::nullopt,
+       "POINT (1 2)",
+       "POLYGON ((1 1, 1 0, 0 0, 0 1, 1 1))"},
+      std::vector<std::optional<double>>{std::nullopt, 1.0, 0.0, 0.0, 1.0},
+      "ST_Distance(left_g, right_g) <= radius",
+      core::JoinType::kInner,
+      {"POINT (1 2)",
+       "POLYGON ((1 2, 1 3, 2 3, 2 2, 1 2))",
+       "POINT (1 2)",
+       "POLYGON ((1 2, 1 3, 2 3, 2 2, 1 2))",
+       "POINT (1 2)",
+       "POLYGON ((1 2, 1 3, 2 3, 2 2, 1 2))"},
+      {"POINT (1 1)",
+       "POINT (1 1)",
+       "POINT (1 2)",
+       "POINT (1 2)",
+       "POLYGON ((1 1, 1 0, 0 0, 0 1, 1 1))",
+       "POLYGON ((1 1, 1 0, 0 0, 0 1, 1 1))"});
+}
+
+TEST_F(SpatialJoinTest, testContainsPointsInPolygons) {
+  // Tests ST_Contains(polygon, point) - which polygons contain which points
+  std::vector<std::optional<std::string_view>> pointWkts = {
+      kPointX, kPointY, kPointZ, kPointW};
+  std::vector<std::optional<std::string_view>> polygonWkts = {
+      kPolygonA, kPolygonB, kPolygonC, kPolygonD};
+
+  // Expected: A contains X, B contains Y, B contains Z, A contains Y, D
+  // contains nothing from our test set Note: Y is in both A and B since they
+  // overlap
+  std::vector<std::optional<std::string_view>> pointOutputWkts = {
+      kPointX, kPointY, kPointY, kPointZ};
+  std::vector<std::optional<std::string_view>> polygonOutputWkts = {
+      kPolygonA, kPolygonA, kPolygonB, kPolygonB};
+
+  runTest(
+      pointWkts,
+      polygonWkts,
+      std::nullopt,
+      "ST_Contains(right_g, left_g)",
+      core::JoinType::kInner,
+      pointOutputWkts,
+      polygonOutputWkts);
+}
+
+TEST_F(SpatialJoinTest, testContainsPolygonsInPolygons) {
+  // Tests ST_Contains(polygon, polygon) - which polygons contain which polygons
+  // From the Java test, polygon C contains polygon B (C is larger and covers B)
+  std::vector<std::optional<std::string_view>> polygonWkts = {
+      kPolygonA, kPolygonB, kPolygonC, kPolygonD};
+
+  // Each polygon contains itself, plus any additional containments
+  // Based on the spatial relations, we need to check which polygons actually
+  // contain others For now, test self-containment which should always work
+  std::vector<std::optional<std::string_view>> leftOutputWkts = {
+      kPolygonA, kPolygonB, kPolygonC, kPolygonD};
+  std::vector<std::optional<std::string_view>> rightOutputWkts = {
+      kPolygonA, kPolygonB, kPolygonC, kPolygonD};
+
+  runTest(
+      polygonWkts,
+      polygonWkts,
+      std::nullopt,
+      "ST_Contains(right_g, left_g)",
+      core::JoinType::kInner,
+      leftOutputWkts,
+      rightOutputWkts);
+}
+
+TEST_F(SpatialJoinTest, testContainsLeftJoin) {
+  // Tests ST_Contains with LEFT join - all probe rows should appear
+  std::vector<std::optional<std::string_view>> pointWkts = {
+      kPointX, kPointY, kPointZ, kPointW};
+  std::vector<std::optional<std::string_view>> polygonWkts = {
+      kPolygonA, kPolygonB};
+
+  // W is outside both polygons, so it should have null for the right side
+  std::vector<std::optional<std::string_view>> pointOutputWkts = {
+      kPointX, kPointY, kPointY, kPointZ, kPointW};
+  std::vector<std::optional<std::string_view>> polygonOutputWkts = {
+      kPolygonA, kPolygonA, kPolygonB, kPolygonB, std::nullopt};
+
+  runTest(
+      pointWkts,
+      polygonWkts,
+      std::nullopt,
+      "ST_Contains(right_g, left_g)",
+      core::JoinType::kLeft,
+      pointOutputWkts,
+      polygonOutputWkts);
+}
+
+TEST_F(SpatialJoinTest, testTouches) {
+  // Test ST_Touches - geometries that touch at boundary but don't overlap
+  // Polygon and a point on its boundary
+  std::vector<std::optional<std::string_view>> probeWkts = {
+      "POINT (1 2)", "POINT (3 2)", "LINESTRING (0 0, 1 1)"};
+  std::vector<std::optional<std::string_view>> buildWkts = {
+      "POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))",
+      "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))"};
+
+  // Point (1,2) touches both polygons (on their boundaries)
+  // Point (3,2) touches second polygon (on its boundary)
+  // LineString (0 0, 1 1) touches both polygons (endpoint at (1,1))
+  std::vector<std::optional<std::string_view>> probeOutputWkts = {
+      "POINT (1 2)",
+      "POINT (1 2)",
+      "POINT (3 2)",
+      "LINESTRING (0 0, 1 1)",
+      "LINESTRING (0 0, 1 1)"};
+  std::vector<std::optional<std::string_view>> buildOutputWkts = {
+      "POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))",
+      "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))",
+      "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))",
+      "POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))",
+      "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))"};
+
+  runTest(
+      probeWkts,
+      buildWkts,
+      std::nullopt,
+      "ST_Touches(left_g, right_g)",
+      core::JoinType::kInner,
+      probeOutputWkts,
+      buildOutputWkts);
+}
+
+TEST_F(SpatialJoinTest, testTouchesPolygons) {
+  // Test ST_Touches with two polygons that touch at a corner
+  std::vector<std::optional<std::string_view>> probeWkts = {
+      "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))",
+      "POLYGON ((5 5, 5 6, 6 6, 6 5, 5 5))"};
+  std::vector<std::optional<std::string_view>> buildWkts = {
+      "POLYGON ((3 3, 3 5, 5 5, 5 3, 3 3))"};
+
+  // Both polygons touch the build polygon at corners:
+  // - First polygon touches at (3,3)
+  // - Second polygon touches at (5,5)
+  std::vector<std::optional<std::string_view>> probeOutputWkts = {
+      "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))",
+      "POLYGON ((5 5, 5 6, 6 6, 6 5, 5 5))"};
+  std::vector<std::optional<std::string_view>> buildOutputWkts = {
+      "POLYGON ((3 3, 3 5, 5 5, 5 3, 3 3))",
+      "POLYGON ((3 3, 3 5, 5 5, 5 3, 3 3))"};
+
+  runTest(
+      probeWkts,
+      buildWkts,
+      std::nullopt,
+      "ST_Touches(left_g, right_g)",
+      core::JoinType::kInner,
+      probeOutputWkts,
+      buildOutputWkts);
+}
+
+TEST_F(SpatialJoinTest, testCrosses) {
+  // Test ST_Crosses - geometries that cross each other
+  // A linestring crossing a polygon
+  std::vector<std::optional<std::string_view>> probeWkts = {
+      "LINESTRING (0 0, 4 4)", // Crosses both polygons
+      "LINESTRING (5 0, 5 4)", // Outside both
+      "LINESTRING (1 1, 2 2)" // Contained in polygon, doesn't cross
+  };
+  std::vector<std::optional<std::string_view>> buildWkts = {
+      "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))"};
+
+  // Only the first linestring crosses the polygon
+  std::vector<std::optional<std::string_view>> probeOutputWkts = {
+      "LINESTRING (0 0, 4 4)"};
+  std::vector<std::optional<std::string_view>> buildOutputWkts = {
+      "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))"};
+
+  runTest(
+      probeWkts,
+      buildWkts,
+      std::nullopt,
+      "ST_Crosses(left_g, right_g)",
+      core::JoinType::kInner,
+      probeOutputWkts,
+      buildOutputWkts);
+}
+
+TEST_F(SpatialJoinTest, testCrossesLineStrings) {
+  // Test ST_Crosses with two linestrings that cross each other
+  std::vector<std::optional<std::string_view>> probeWkts = {
+      "LINESTRING (0 0, 1 1)", // Crosses first build linestring
+      "LINESTRING (2 2, 3 3)" // Parallel, doesn't cross
+  };
+  std::vector<std::optional<std::string_view>> buildWkts = {
+      "LINESTRING (1 0, 0 1)"};
+
+  // Only the first linestring crosses
+  std::vector<std::optional<std::string_view>> probeOutputWkts = {
+      "LINESTRING (0 0, 1 1)"};
+  std::vector<std::optional<std::string_view>> buildOutputWkts = {
+      "LINESTRING (1 0, 0 1)"};
+
+  runTest(
+      probeWkts,
+      buildWkts,
+      std::nullopt,
+      "ST_Crosses(left_g, right_g)",
+      core::JoinType::kInner,
+      probeOutputWkts,
+      buildOutputWkts);
+}
+
+TEST_F(SpatialJoinTest, testEmptyBuild) {
+  runTest(
+      {kPointX, std::nullopt, kPointY, kPointZ, kPointW},
+      {},
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kInner,
+      {},
+      {});
+  runTest(
+      {kPointX, std::nullopt, kPointY, kPointZ, kPointW},
+      {},
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kLeft,
+      {kPointX, std::nullopt, kPointY, kPointZ, kPointW},
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt});
+}
+
+TEST_F(SpatialJoinTest, testEmptyProbe) {
+  runTest(
+      {},
+      {kPointX, std::nullopt, kPointY, kPointZ, kPointW},
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kInner,
+      {},
+      {});
+  runTest(
+      {},
+      {kPointX, std::nullopt, kPointY, kPointZ, kPointW},
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kLeft,
+      {},
+      {});
+}
+
 TEST_F(SpatialJoinTest, failOnGroupedExecution) {
   std::vector<RowVectorPtr> batches{
       makeRowVector({"wkt"}, {makeFlatVector<std::string>({"POINT(0 0)"})})};
@@ -317,6 +690,9 @@ TEST_F(SpatialJoinTest, failOnGroupedExecution) {
                   .localPartition({})
                   .planNode(),
               "ST_Intersects(left_g, right_g)",
+              "left_g",
+              "right_g",
+              std::nullopt,
               {"left_g", "right_g"},
               core::JoinType::kInner)
           .project(
@@ -335,4 +711,57 @@ TEST_F(SpatialJoinTest, failOnGroupedExecution) {
       task->start(1), "Spatial joins do not support grouped execution.");
 }
 
+TEST_F(SpatialJoinTest, testLargeJoinSize) {
+  size_t numRows = 64;
+  size_t maxCoord = 17;
+  std::vector<std::string> buildWkts;
+  buildWkts.reserve(numRows);
+  std::vector<std::string> probeWkts;
+  probeWkts.reserve(numRows);
+  for (size_t i = 0; i < numRows; ++i) {
+    buildWkts.push_back(
+        fmt::format("POINT ({} {})", (i + 1) % maxCoord, (i + 2) % maxCoord));
+    probeWkts.push_back(
+        fmt::format("POINT ({} {})", i % maxCoord, (i + 1) % maxCoord));
+  }
+
+  std::vector<std::optional<std::string_view>> buildWktsView;
+  buildWktsView.reserve(numRows);
+  std::vector<std::optional<std::string_view>> probeWktsView;
+  probeWktsView.reserve(numRows);
+  for (size_t i = 0; i < numRows; ++i) {
+    buildWktsView.push_back(buildWkts[i]);
+    probeWktsView.push_back(probeWkts[i]);
+  }
+
+  std::vector<std::optional<std::string_view>> expectedLeftWkts;
+  expectedLeftWkts.reserve(numRows * numRows / maxCoord);
+  std::vector<std::optional<std::string_view>> expectedRightWkts;
+  expectedRightWkts.reserve(numRows * numRows / maxCoord);
+  for (size_t innerIdx = 0; innerIdx < numRows; ++innerIdx) {
+    for (size_t outerIdx = 0; outerIdx < numRows; ++outerIdx) {
+      if (probeWkts[outerIdx] == buildWkts[innerIdx]) {
+        expectedLeftWkts.push_back(probeWkts[outerIdx]);
+        expectedRightWkts.push_back(buildWkts[innerIdx]);
+      }
+    }
+  }
+
+  for (bool separateProbeBatches : {false, true}) {
+    for (size_t maxBatchSize : {64, 13, 7, 5, 3, 2, 1}) {
+      runTestWithConfig(
+          buildWktsView,
+          probeWktsView,
+          std::nullopt,
+          "ST_Equals(left_g, right_g)",
+          core::JoinType::kInner,
+          expectedLeftWkts,
+          expectedRightWkts,
+          1,
+          maxBatchSize,
+          separateProbeBatches);
+    }
+  }
+}
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/common/base/tests/SpillStatsTest.cpp b/velox/exec/tests/SpillStatsTest.cpp
similarity index 98%
rename from velox/common/base/tests/SpillStatsTest.cpp
rename to velox/exec/tests/SpillStatsTest.cpp
index 96564011482..7f881ed0c4d 100644
--- a/velox/common/base/tests/SpillStatsTest.cpp
+++ b/velox/exec/tests/SpillStatsTest.cpp
@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-#include "velox/common/base/SpillStats.h"
+#include "velox/exec/SpillStats.h"
 #include <gtest/gtest.h>
 #include "velox/common/base/VeloxException.h"
 #include "velox/common/base/tests/GTestUtils.h"
 
-using namespace facebook::velox::common;
+using namespace facebook::velox::exec;
 
 TEST(SpillStatsTest, spillStats) {
   SpillStats stats1;
diff --git a/velox/exec/tests/SpillTest.cpp b/velox/exec/tests/SpillTest.cpp
index 9097abd7f66..eb633428d9c 100644
--- a/velox/exec/tests/SpillTest.cpp
+++ b/velox/exec/tests/SpillTest.cpp
@@ -21,9 +21,10 @@
 #include "velox/common/base/RuntimeMetrics.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/Spill.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/exec/tests/utils/MergeTestBase.h"
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/type/Timestamp.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
@@ -32,7 +33,7 @@ using namespace facebook;
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
 using namespace facebook::velox::filesystems;
-using facebook::velox::exec::test::TempDirectoryPath;
+using namespace facebook::velox::common::testutil;
 
 namespace {
 static const int64_t kGB = 1'000'000'000;
@@ -44,7 +45,7 @@ class TestRuntimeStatWriter : public BaseRuntimeStatWriter {
       std::unordered_map<std::string, RuntimeMetric>& stats)
       : stats_{stats} {}
 
-  void addRuntimeStat(const std::string& name, const RuntimeCounter& value)
+  void addRuntimeStat(std::string_view name, const RuntimeCounter& value)
       override {
     addOperatorRuntimeStats(name, value, stats_);
   }
@@ -78,6 +79,10 @@ struct TestParam {
   }
 };
 
+inline void PrintTo(const TestParam& param, std::ostream* os) {
+  *os << param.toString();
+}
+
 class SpillTest : public ::testing::TestWithParam<uint32_t>,
                   public facebook::velox::test::VectorTestBase {
  public:
@@ -128,7 +133,7 @@ class SpillTest : public ::testing::TestWithParam<uint32_t>,
       facebook::velox::serializer::presto::PrestoVectorSerde::
           registerVectorSerde();
     }
-    if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kPresto)) {
+    if (!isRegisteredNamedVectorSerde("Presto")) {
       facebook::velox::serializer::presto::PrestoVectorSerde::
           registerNamedVectorSerde();
     }
@@ -136,7 +141,7 @@ class SpillTest : public ::testing::TestWithParam<uint32_t>,
 
   void SetUp() override {
     allocator_ = memory::memoryManager()->allocator();
-    tempDir_ = exec::test::TempDirectoryPath::create();
+    tempDir_ = TempDirectoryPath::create();
     filesystems::registerLocalFileSystem();
     rng_.seed(1);
     compressionKind_ = TestParam{GetParam()}.compressionKind;
@@ -236,7 +241,7 @@ class SpillTest : public ::testing::TestWithParam<uint32_t>,
     batchesByPartition_.clear();
     values_.clear();
     runtimeStats_.clear();
-    spillStats_.wlock()->reset();
+    spillStats_.reset();
 
     fileNamePrefix_ = "test";
     values_.resize(numBatches * numRowsPerBatch);
@@ -282,7 +287,7 @@ class SpillTest : public ::testing::TestWithParam<uint32_t>,
     // vectors have the ith element = i * 'numBatches' + batch, where batch is
     // the batch number of the vector in the partition. When read back, both
     // partitions produce an ascending sequence of integers without gaps.
-    spillStats_.wlock()->reset();
+    spillStats_.reset();
     const std::optional<common::PrefixSortConfig> prefixSortConfig =
         enablePrefixSort_
         ? std::optional<common::PrefixSortConfig>(common::PrefixSortConfig())
@@ -302,8 +307,8 @@ class SpillTest : public ::testing::TestWithParam<uint32_t>,
         pool(),
         &spillStats_);
     ASSERT_EQ(targetFileSize, state_->targetFileSize());
-    ASSERT_EQ(spillStats_.rlock()->spilledPartitions, 0);
-    ASSERT_EQ(spillStats_.rlock()->spilledPartitions, 0);
+    ASSERT_EQ(spillStats_.spilledPartitions, 0);
+    ASSERT_EQ(spillStats_.spilledPartitions, 0);
     ASSERT_TRUE(state_->spilledPartitionIdSet().empty());
     ASSERT_EQ(compressionKind_, state_->compressionKind());
     ASSERT_EQ(state_->sortingKeys().size(), numSortKeys);
@@ -369,7 +374,7 @@ class SpillTest : public ::testing::TestWithParam<uint32_t>,
             partitionId));
       }
     }
-    ASSERT_EQ(spillStats_.rlock()->spilledPartitions, partitionIds.size());
+    ASSERT_EQ(spillStats_.spilledPartitions, partitionIds.size());
     for (const auto& partitionId : partitionIds) {
       ASSERT_TRUE(state_->spilledPartitionIdSet().contains(partitionId));
     }
@@ -383,10 +388,9 @@ class SpillTest : public ::testing::TestWithParam<uint32_t>,
     if (targetFileSize > 1) {
       expectedFiles /= 2;
     }
-    ASSERT_EQ(spillStats_.rlock()->spilledFiles, expectedFiles);
+    ASSERT_EQ(spillStats_.spilledFiles, expectedFiles);
     ASSERT_GT(
-        spillStats_.rlock()->spilledBytes,
-        numPartitions * numBatches * sizeof(int64_t));
+        spillStats_.spilledBytes, numPartitions * numBatches * sizeof(int64_t));
     int numFinishedFiles{0};
     for (const auto& partitionId : partitionIds) {
       numFinishedFiles += state_->numFinishedFiles(partitionId);
@@ -394,6 +398,31 @@ class SpillTest : public ::testing::TestWithParam<uint32_t>,
     ASSERT_EQ(numFinishedFiles, expectedFiles);
   }
 
+  void hybridSpillStateTest(
+      int64_t targetFileSize,
+      int numPartitions,
+      int numBatches,
+      int numDuplicates,
+      const std::vector<CompareFlags>& compareFlags,
+      uint64_t expectedNumSpilledFiles) {
+    int mergeWayThresholdBegin = 0;
+    int mergeWayThresholdEnd = 4;
+    for (int i = mergeWayThresholdBegin; i < mergeWayThresholdEnd; i++) {
+      if (i == 1) {
+        // Skip invalid value.
+        continue;
+      }
+      spillStateTest(
+          targetFileSize,
+          numPartitions,
+          numBatches,
+          numDuplicates,
+          compareFlags,
+          expectedNumSpilledFiles,
+          i);
+    }
+  }
+
   // 'numDuplicates' specifies the number of duplicates generated for each
   // distinct sort key value in test.
   void spillStateTest(
@@ -402,18 +431,20 @@ class SpillTest : public ::testing::TestWithParam<uint32_t>,
       int numBatches,
       int numDuplicates,
       const std::vector<CompareFlags>& compareFlags,
-      uint64_t expectedNumSpilledFiles) {
+      uint64_t expectedNumSpilledFiles,
+      int mergeWayThreshold) {
     const int numRowsPerBatch = 1'000;
-    SCOPED_TRACE(fmt::format(
-        "targetFileSize: {}, numPartitions: {}, numBatches: {}, numDuplicates: {}, nullsFirst: {}, ascending: {}",
-        targetFileSize,
-        numPartitions,
-        numBatches,
-        numDuplicates,
-        compareFlags.empty() ? true : compareFlags[0].nullsFirst,
-        compareFlags.empty() ? true : compareFlags[0].ascending));
+    SCOPED_TRACE(
+        fmt::format(
+            "targetFileSize: {}, numPartitions: {}, numBatches: {}, numDuplicates: {}, nullsFirst: {}, ascending: {}",
+            targetFileSize,
+            numPartitions,
+            numBatches,
+            numDuplicates,
+            compareFlags.empty() ? true : compareFlags[0].nullsFirst,
+            compareFlags.empty() ? true : compareFlags[0].ascending));
 
-    const auto prevGStats = common::globalSpillStats();
+    const auto prevGStats = globalSpillStats();
 
     SpillPartitionIdSet partitionIds = genPartitionIdSet(numPartitions);
 
@@ -425,7 +456,7 @@ class SpillTest : public ::testing::TestWithParam<uint32_t>,
         numRowsPerBatch,
         numDuplicates,
         compareFlags);
-    const auto stats = spillStats_.copy();
+    const auto& stats = spillStats_;
     ASSERT_EQ(stats.spilledPartitions, numPartitions);
     ASSERT_EQ(stats.spilledFiles, expectedNumSpilledFiles);
     ASSERT_GT(stats.spilledBytes, 0);
@@ -438,7 +469,7 @@ class SpillTest : public ::testing::TestWithParam<uint32_t>,
     // NOTE: the following stats are not collected by spill state.
     ASSERT_EQ(stats.spillFillTimeNanos, 0);
     ASSERT_EQ(stats.spillSortTimeNanos, 0);
-    const auto newGStats = common::globalSpillStats();
+    const auto newGStats = globalSpillStats();
     ASSERT_EQ(
         prevGStats.spilledPartitions + stats.spilledPartitions,
         newGStats.spilledPartitions);
@@ -488,13 +519,20 @@ class SpillTest : public ::testing::TestWithParam<uint32_t>,
     ASSERT_EQ(stats.spilledBytes, totalFileBytes);
     ASSERT_EQ(prevGStats.spilledBytes + totalFileBytes, newGStats.spilledBytes);
 
+    bool usePreMerge = mergeWayThreshold >= 2;
     for (const auto& partitionId : partitionIds) {
       auto spillFiles = state_->finish(partitionId);
       ASSERT_EQ(state_->numFinishedFiles(partitionId), 0);
       auto spillPartition =
           SpillPartition(SpillPartitionId(partitionId), std::move(spillFiles));
-      auto merge =
-          spillPartition.createOrderedReader(1 << 20, pool(), &spillStats_);
+      auto spillConfig = common::SpillConfig();
+      spillConfig.numMaxMergeFiles = mergeWayThreshold;
+      spillConfig.readBufferSize = 1 << 20;
+      spillConfig.writeBufferSize = 1 << 20;
+      spillConfig.updateAndCheckSpillLimitCb = [](int64_t) {};
+      spillConfig.fileCreateConfig = "";
+      std::unique_ptr<TreeOfLosers<SpillMergeStream>> merge =
+          spillPartition.createOrderedReader(spillConfig, pool(), &spillStats_);
       int numReadBatches = 0;
       // We expect all the rows in dense increasing order.
       for (auto i = 0; i < numBatches * numRowsPerBatch; ++i) {
@@ -527,11 +565,13 @@ class SpillTest : public ::testing::TestWithParam<uint32_t>,
         }
       }
       ASSERT_EQ(nullptr, merge->next());
-      // We do two append writes per each input batch.
-      ASSERT_EQ(numBatches, numReadBatches);
+      if (!usePreMerge) {
+        // We do two append writes per each input batch.
+        ASSERT_EQ(numBatches, numReadBatches);
+      }
     }
 
-    const auto finalStats = spillStats_.copy();
+    const auto& finalStats = spillStats_;
     ASSERT_EQ(finalStats.spillReadBytes, finalStats.spilledBytes);
     ASSERT_GT(finalStats.spillReads, 0);
     ASSERT_GT(finalStats.spillReadTimeNanos, 0);
@@ -567,7 +607,67 @@ class SpillTest : public ::testing::TestWithParam<uint32_t>,
       ASSERT_TRUE(fs->exists(spilledFile));
     }
     // Verify stats.
-    ASSERT_EQ(runtimeStats_["spillFileSize"].count, spilledFiles.size());
+    if (!usePreMerge) {
+      ASSERT_EQ(runtimeStats_["spillFileSize"].count, spilledFiles.size());
+    } else {
+      ASSERT_GE(runtimeStats_["spillFileSize"].count, spilledFiles.size());
+    }
+  }
+
+  void gatherMergeTest(
+      int32_t numValues,
+      int numMergeWays,
+      int targetSize,
+      bool useRandom) {
+    auto goldenVector = makeRowVector({
+        makeFlatVector<int32_t>(numValues, [&](auto row) { return row; }),
+    });
+    std::vector<std::vector<int32_t>> mergeWays(numMergeWays);
+    for (int32_t value = 0; value < numValues; value++) {
+      int way = useRandom ? folly::Random::rand32() % numMergeWays
+                          : value % numMergeWays;
+      mergeWays[way].push_back(value);
+    }
+    std::vector<RowVectorPtr> sources;
+    std::vector<std::unique_ptr<SpillMergeStream>> streams;
+    std::vector<SpillSortKey> sortKeys = {{0, {true, true}}};
+    for (int way = 0; way < numMergeWays; way++) {
+      auto source = makeRowVector({
+          makeFlatVector<int32_t>(
+              mergeWays[way].size(),
+              [&](auto row) { return mergeWays[way][row]; }),
+      });
+      sources.push_back(source);
+      streams.push_back(
+          std::make_unique<exec::test::TestingSpillMergeStream>(
+              way, sortKeys, source));
+    }
+    auto mergeTree =
+        std::make_unique<TreeOfLosers<SpillMergeStream>>(std::move(streams));
+    RowVectorPtr targetVector = std::static_pointer_cast<RowVector>(
+        BaseVector::create(sources[0]->type(), targetSize, pool_.get()));
+    std::vector<const RowVector*> bufferSources(targetSize);
+    std::vector<vector_size_t> bufferSourceIndices(targetSize);
+    for (int32_t batch = 0; batch * targetSize < numValues; batch++) {
+      int32_t valueBegin = batch * targetSize;
+      int32_t valueEnd = valueBegin + targetSize;
+      valueEnd = std::min(valueEnd, numValues);
+      VectorPtr tmp = std::move(targetVector);
+      BaseVector::prepareForReuse(tmp, targetSize);
+      targetVector = std::static_pointer_cast<RowVector>(tmp);
+      for (auto& child : targetVector->children()) {
+        child->resize(targetSize);
+      }
+      int count = 0;
+      testingGatherMerge(
+          targetVector, *mergeTree, count, bufferSources, bufferSourceIndices);
+      EXPECT_EQ(count, valueEnd - valueBegin);
+      auto result = targetVector->childAt(0).get();
+      auto golden = goldenVector->childAt(0).get();
+      for (int32_t row = 0; row < valueEnd - valueBegin; row++) {
+        EXPECT_TRUE(result->equalValueAt(golden, row, valueBegin + row));
+      }
+    }
   }
 
   folly::Random::DefaultGenerator rng_;
@@ -579,7 +679,7 @@ class SpillTest : public ::testing::TestWithParam<uint32_t>,
   folly::F14FastMap<SpillPartitionId, std::vector<RowVectorPtr>>
       batchesByPartition_;
   std::string fileNamePrefix_;
-  folly::Synchronized<common::SpillStats> spillStats_;
+  exec::SpillStats spillStats_;
   std::unique_ptr<SpillState> state_;
   std::unordered_map<std::string, RuntimeMetric> runtimeStats_;
   std::unique_ptr<TestRuntimeStatWriter> statWriter_;
@@ -591,24 +691,24 @@ TEST_P(SpillTest, spillState) {
   // triggered by batch write.
 
   // Test with distinct sort keys.
-  spillStateTest(kGB, 2, 8, 1, {CompareFlags{true, true}}, 8);
-  spillStateTest(kGB, 2, 8, 1, {CompareFlags{true, false}}, 8);
-  spillStateTest(kGB, 2, 8, 1, {CompareFlags{false, true}}, 8);
-  spillStateTest(kGB, 2, 8, 1, {CompareFlags{false, false}}, 8);
-  spillStateTest(kGB, 2, 8, 1, {}, 8);
+  hybridSpillStateTest(kGB, 2, 8, 1, {CompareFlags{true, true}}, 8);
+  hybridSpillStateTest(kGB, 2, 8, 1, {CompareFlags{true, false}}, 8);
+  hybridSpillStateTest(kGB, 2, 8, 1, {CompareFlags{false, true}}, 8);
+  hybridSpillStateTest(kGB, 2, 8, 1, {CompareFlags{false, false}}, 8);
+  hybridSpillStateTest(kGB, 2, 8, 1, {}, 8);
 
   // Test with duplicate sort keys.
-  spillStateTest(kGB, 2, 8, 8, {CompareFlags{true, true}}, 8);
-  spillStateTest(kGB, 2, 8, 8, {CompareFlags{true, false}}, 8);
-  spillStateTest(kGB, 2, 8, 8, {CompareFlags{false, true}}, 8);
-  spillStateTest(kGB, 2, 8, 8, {CompareFlags{false, false}}, 8);
-  spillStateTest(kGB, 2, 8, 8, {}, 8);
+  hybridSpillStateTest(kGB, 2, 8, 8, {CompareFlags{true, true}}, 8);
+  hybridSpillStateTest(kGB, 2, 8, 8, {CompareFlags{true, false}}, 8);
+  hybridSpillStateTest(kGB, 2, 8, 8, {CompareFlags{false, true}}, 8);
+  hybridSpillStateTest(kGB, 2, 8, 8, {CompareFlags{false, false}}, 8);
+  hybridSpillStateTest(kGB, 2, 8, 8, {}, 8);
 }
 
 TEST_P(SpillTest, spillTimestamp) {
   // Verify that timestamp type retains it nanosecond precision when spilled and
   // read back.
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  auto tempDirectory = TempDirectoryPath::create();
   std::vector<CompareFlags> emptyCompareFlags;
   const std::string spillPath = tempDirectory->getPath() + "/test";
   std::vector<Timestamp> timeValues = {
@@ -646,11 +746,17 @@ TEST_P(SpillTest, spillTimestamp) {
       state.testingNonEmptySpilledPartitionIdSet().contains(partitionId));
 
   SpillPartition spillPartition(SpillPartitionId{0}, state.finish(partitionId));
+  auto spillConfig = common::SpillConfig();
+  spillConfig.numMaxMergeFiles = 2;
+  spillConfig.readBufferSize = 1 << 20;
+  spillConfig.writeBufferSize = 1 << 20;
+  spillConfig.updateAndCheckSpillLimitCb = [](int64_t) {};
+  spillConfig.fileCreateConfig = "";
   auto merge =
-      spillPartition.createOrderedReader(1 << 20, pool(), &spillStats_);
+      spillPartition.createOrderedReader(spillConfig, pool(), &spillStats_);
   ASSERT_TRUE(merge != nullptr);
   ASSERT_TRUE(
-      spillPartition.createOrderedReader(1 << 20, pool(), &spillStats_) ==
+      spillPartition.createOrderedReader(spillConfig, pool(), &spillStats_) ==
       nullptr);
   for (auto i = 0; i < timeValues.size(); ++i) {
     auto* stream = merge->next();
@@ -668,18 +774,18 @@ TEST_P(SpillTest, spillStateWithSmallTargetFileSize) {
   // write.
 
   // Test with distinct sort keys.
-  spillStateTest(1, 2, 8, 1, {CompareFlags{true, true}}, 8 * 2);
-  spillStateTest(1, 2, 8, 1, {CompareFlags{true, false}}, 8 * 2);
-  spillStateTest(1, 2, 8, 1, {CompareFlags{false, true}}, 8 * 2);
-  spillStateTest(1, 2, 8, 1, {CompareFlags{false, false}}, 8 * 2);
-  spillStateTest(1, 2, 8, 1, {}, 8 * 2);
+  hybridSpillStateTest(1, 2, 8, 1, {CompareFlags{true, true}}, 8 * 2);
+  hybridSpillStateTest(1, 2, 8, 1, {CompareFlags{true, false}}, 8 * 2);
+  hybridSpillStateTest(1, 2, 8, 1, {CompareFlags{false, true}}, 8 * 2);
+  hybridSpillStateTest(1, 2, 8, 1, {CompareFlags{false, false}}, 8 * 2);
+  hybridSpillStateTest(1, 2, 8, 1, {}, 8 * 2);
 
   // Test with duplicated sort keys.
-  spillStateTest(1, 2, 8, 8, {CompareFlags{true, false}}, 8 * 2);
-  spillStateTest(1, 2, 8, 8, {CompareFlags{true, true}}, 8 * 2);
-  spillStateTest(1, 2, 8, 8, {CompareFlags{false, false}}, 8 * 2);
-  spillStateTest(1, 2, 8, 8, {CompareFlags{false, true}}, 8 * 2);
-  spillStateTest(1, 2, 8, 8, {}, 8 * 2);
+  hybridSpillStateTest(1, 2, 8, 8, {CompareFlags{true, false}}, 8 * 2);
+  hybridSpillStateTest(1, 2, 8, 8, {CompareFlags{true, true}}, 8 * 2);
+  hybridSpillStateTest(1, 2, 8, 8, {CompareFlags{false, false}}, 8 * 2);
+  hybridSpillStateTest(1, 2, 8, 8, {CompareFlags{false, true}}, 8 * 2);
+  hybridSpillStateTest(1, 2, 8, 8, {}, 8 * 2);
 }
 
 TEST_P(SpillTest, spillPartitionId) {
@@ -958,12 +1064,15 @@ TEST_P(SpillTest, spillPartitionFunctionBasic) {
     std::vector<VectorPtr> columns;
     columns.push_back(
         makeFlatVector<int64_t>(numRows, [](auto row) { return row; }));
-    columns.push_back(makeFlatVector<std::string>(
-        numRows, [](auto row) { return fmt::format("key_{}", row); }));
-    columns.push_back(makeFlatVector<std::string>(
-        numRows, [](auto row) { return fmt::format("key_{}_{}", row, row); }));
-    columns.push_back(makeFlatVector<std::string>(
-        numRows, [](auto row) { return fmt::format("val_{}", row); }));
+    columns.push_back(makeFlatVector<std::string>(numRows, [](auto row) {
+      return fmt::format("key_{}", row);
+    }));
+    columns.push_back(makeFlatVector<std::string>(numRows, [](auto row) {
+      return fmt::format("key_{}_{}", row, row);
+    }));
+    columns.push_back(makeFlatVector<std::string>(numRows, [](auto row) {
+      return fmt::format("val_{}", row);
+    }));
     inputVectors.push_back(makeRowVector(columns));
   }
 
@@ -1404,7 +1513,7 @@ TEST_P(SpillTest, validatePerSpillWriteSize) {
     }
   };
 
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  auto tempDirectory = TempDirectoryPath::create();
   SpillState state(
       [&]() -> const std::string& { return tempDirectory->getPath(); },
       updateSpilledBytesCb_,
@@ -1428,7 +1537,7 @@ TEST_P(SpillTest, validatePerSpillWriteSize) {
 
 namespace {
 SpillFiles makeFakeSpillFiles(int32_t numFiles) {
-  auto tempDir = exec::test::TempDirectoryPath::create();
+  auto tempDir = TempDirectoryPath::create();
   static uint32_t fakeFileId{0};
   SpillFiles files;
   files.reserve(numFiles);
@@ -1522,6 +1631,17 @@ TEST(SpillTest, scopedSpillInjectionRegex) {
   }
 }
 
+TEST_P(SpillTest, gatherMerge) {
+  gatherMergeTest(1234, 2, 10, false);
+  gatherMergeTest(1234, 2, 100, false);
+  gatherMergeTest(1234, 10, 10, false);
+  gatherMergeTest(1234, 10, 100, false);
+  gatherMergeTest(1234, 2, 10, true);
+  gatherMergeTest(1234, 2, 100, true);
+  gatherMergeTest(1234, 10, 10, true);
+  gatherMergeTest(1234, 10, 100, true);
+}
+
 VELOX_INSTANTIATE_TEST_SUITE_P(
     SpillTestSuite,
     SpillTest,
diff --git a/velox/exec/tests/SpillerAggregateBenchmarkTest.cpp b/velox/exec/tests/SpillerAggregateBenchmarkTest.cpp
index d0b34a244f7..92398385ec5 100644
--- a/velox/exec/tests/SpillerAggregateBenchmarkTest.cpp
+++ b/velox/exec/tests/SpillerAggregateBenchmarkTest.cpp
@@ -37,7 +37,8 @@ int main(int argc, char* argv[]) {
         "AggregationOutputSpiller], the aggregate spiller dose not support it.",
         spillerType);
   }
-  auto test = std::make_unique<test::AggregateSpillBenchmarkBase>(spillerType);
+  auto test =
+      std::make_unique<exec::test::AggregateSpillBenchmarkBase>(spillerType);
   test->setUp();
   test->run();
   test->printStats();
diff --git a/velox/exec/tests/SpillerBenchmarkBase.cpp b/velox/exec/tests/SpillerBenchmarkBase.cpp
index ab94f79c62e..640cb7ea88f 100644
--- a/velox/exec/tests/SpillerBenchmarkBase.cpp
+++ b/velox/exec/tests/SpillerBenchmarkBase.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include <folly/system/HardwareConcurrency.h>
 #include <gflags/gflags.h>
 #include <glog/logging.h>
 #include <filesystem>
@@ -23,9 +24,9 @@
 #include "velox/common/compression/Compression.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/memory/MmapAllocator.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/exec/Spiller.h"
 #include "velox/exec/tests/SpillerBenchmarkBase.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
 DEFINE_string(
@@ -56,7 +57,7 @@ DEFINE_uint32(
     "The number of key columns");
 DEFINE_uint32(
     spiller_benchmark_spill_executor_size,
-    std::thread::hardware_concurrency(),
+    folly::available_concurrency(),
     "The spiller executor size in number of threads");
 DEFINE_uint32(
     spiller_benchmark_spill_vector_size,
@@ -78,6 +79,7 @@ DEFINE_uint64(
 using namespace facebook::velox::memory;
 
 namespace facebook::velox::exec::test {
+using namespace facebook::velox::common::testutil;
 
 void SpillerBenchmarkBase::setUp() {
   rootPool_ =
@@ -108,7 +110,7 @@ void SpillerBenchmarkBase::setUp() {
   }
 
   if (FLAGS_spiller_benchmark_path.empty()) {
-    tempDir_ = exec::test::TempDirectoryPath::create();
+    tempDir_ = TempDirectoryPath::create();
     spillDir_ = tempDir_->getPath();
   } else {
     spillDir_ = FLAGS_spiller_benchmark_path;
diff --git a/velox/exec/tests/SpillerBenchmarkBase.h b/velox/exec/tests/SpillerBenchmarkBase.h
index a4a4fcc228e..5268823d5a0 100644
--- a/velox/exec/tests/SpillerBenchmarkBase.h
+++ b/velox/exec/tests/SpillerBenchmarkBase.h
@@ -19,8 +19,8 @@
 #include <folly/executors/IOThreadPoolExecutor.h>
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/memory/MmapAllocator.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/exec/Spiller.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/type/Type.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
@@ -37,6 +37,8 @@ DECLARE_uint64(spiller_benchmark_min_spill_run_size);
 DECLARE_uint64(spiller_benchmark_write_buffer_size);
 
 namespace facebook::velox::exec::test {
+
+/// This test measures
 /// This test measures the spill input overhead in spill join & probe.
 class SpillerBenchmarkBase {
  public:
@@ -65,12 +67,12 @@ class SpillerBenchmarkBase {
   std::unique_ptr<VectorFuzzer> vectorFuzzer_;
   std::vector<RowVectorPtr> rowVectors_;
   std::unique_ptr<folly::IOThreadPoolExecutor> executor_;
-  std::shared_ptr<exec::test::TempDirectoryPath> tempDir_;
+  std::shared_ptr<velox::common::testutil::TempDirectoryPath> tempDir_;
   std::string spillDir_;
   std::shared_ptr<filesystems::FileSystem> fs_;
   std::unique_ptr<SpillerBase> spiller_;
   // Stats.
   uint64_t executionTimeUs_{0};
-  folly::Synchronized<common::SpillStats> spillStats_;
+  exec::SpillStats spillStats_;
 };
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/SpillerTest.cpp b/velox/exec/tests/SpillerTest.cpp
index 807025162a1..ee8dc60aa36 100644
--- a/velox/exec/tests/SpillerTest.cpp
+++ b/velox/exec/tests/SpillerTest.cpp
@@ -57,7 +57,7 @@ class TestRuntimeStatWriter : public BaseRuntimeStatWriter {
       std::unordered_map<std::string, RuntimeMetric>& stats)
       : stats_{stats} {}
 
-  void addRuntimeStat(const std::string& name, const RuntimeCounter& value)
+  void addRuntimeStat(std::string_view name, const RuntimeCounter& value)
       override {
     addOperatorRuntimeStats(name, value, stats_);
   }
@@ -119,6 +119,10 @@ struct TestParam {
   }
 };
 
+inline void PrintTo(const TestParam& param, std::ostream* os) {
+  *os << param.toString();
+}
+
 struct TestParamsBuilder {
   std::vector<TestParam> getTestParams() {
     std::vector<TestParam> params;
@@ -269,7 +273,7 @@ class SpillerTest : public exec::test::RowContainerTestBase {
     rng_.seed(1);
     const bool asyncRead = folly::Random::oneIn(2);
     LOG(INFO) << "Async read " << asyncRead;
-    tempDirPath_ = exec::test::TempDirectoryPath::create(true);
+    tempDirPath_ = TempDirectoryPath::create(true);
     fs_ = filesystems::getFileSystem(tempDirPath_->getPath(), nullptr);
     faultyFs_ = static_cast<tests::utils::FaultyFileSystem*>(fs_.get());
     fsExecutor_ = std::make_unique<folly::CPUThreadPoolExecutor>(32);
@@ -331,15 +335,16 @@ class SpillerTest : public exec::test::RowContainerTestBase {
       bool ascending = true,
       bool makeError = false,
       uint64_t readBufferSize = 1 << 20) {
-    SCOPED_TRACE(fmt::format(
-        "spillType: {} numDuplicates: {} outputBatchSize: {} ascending: {} makeError: {}",
-        typeName(type_),
-        numDuplicates,
-        outputBatchSize,
-        ascending,
-        makeError));
+    SCOPED_TRACE(
+        fmt::format(
+            "spillType: {} numDuplicates: {} outputBatchSize: {} ascending: {} makeError: {}",
+            typeName(type_),
+            numDuplicates,
+            outputBatchSize,
+            ascending,
+            makeError));
     constexpr int32_t kNumRows = 5'000;
-    const auto prevGStats = common::globalSpillStats();
+    const auto prevGStats = globalSpillStats();
 
     setupSpillData(numKeys_, kNumRows, numDuplicates, [&](RowVectorPtr rows) {
       // Set ordinal so that the sorted order is unambiguous.
@@ -355,8 +360,8 @@ class SpillerTest : public exec::test::RowContainerTestBase {
       return;
     }
     // Verify the spilled file exist on file system.
-    auto stats = spiller_->stats();
-    const auto numSpilledFiles = stats.spilledFiles;
+    const auto& stats = spiller_->stats();
+    const auto numSpilledFiles = stats.spilledFiles.load();
     if (type_ == SpillerType::AGGREGATION_OUTPUT) {
       ASSERT_EQ(numSpilledFiles, 1);
     } else {
@@ -388,45 +393,50 @@ class SpillerTest : public exec::test::RowContainerTestBase {
 
     verifySortedSpillData(spillPartitionSet, outputBatchSize);
 
-    stats = spiller_->stats();
-    ASSERT_EQ(stats.spilledFiles, spilledFileSet.size());
-    ASSERT_EQ(stats.spilledPartitions, numPartitions_);
-    ASSERT_EQ(stats.spilledRows, kNumRows);
+    const auto& updatedStats = spiller_->stats();
+    ASSERT_EQ(updatedStats.spilledFiles.load(), spilledFileSet.size());
+    ASSERT_EQ(updatedStats.spilledPartitions.load(), numPartitions_);
+    ASSERT_EQ(updatedStats.spilledRows.load(), kNumRows);
 
-    ASSERT_EQ(stats.spilledBytes, totalSpilledBytes);
-    ASSERT_EQ(stats.spillReadBytes, totalSpilledBytes);
-    ASSERT_GT(stats.spillWriteTimeNanos, 0);
+    ASSERT_EQ(updatedStats.spilledBytes.load(), totalSpilledBytes);
+    ASSERT_EQ(updatedStats.spillReadBytes.load(), totalSpilledBytes);
+    ASSERT_GT(updatedStats.spillWriteTimeNanos.load(), 0);
     if (type_ == SpillerType::AGGREGATION_OUTPUT) {
-      ASSERT_EQ(stats.spillSortTimeNanos, 0);
+      ASSERT_EQ(updatedStats.spillSortTimeNanos.load(), 0);
     } else {
-      ASSERT_GT(stats.spillSortTimeNanos, 0);
+      ASSERT_GT(updatedStats.spillSortTimeNanos.load(), 0);
     }
-    ASSERT_GT(stats.spillExtractVectorTimeNanos, 0);
-    ASSERT_GT(stats.spillFlushTimeNanos, 0);
-    ASSERT_GT(stats.spillFillTimeNanos, 0);
-    ASSERT_GT(stats.spillSerializationTimeNanos, 0);
-    ASSERT_GT(stats.spillWrites, 0);
+    ASSERT_GT(updatedStats.spillExtractVectorTimeNanos.load(), 0);
+    ASSERT_GT(updatedStats.spillFlushTimeNanos.load(), 0);
+    ASSERT_GT(updatedStats.spillFillTimeNanos.load(), 0);
+    ASSERT_GT(updatedStats.spillSerializationTimeNanos.load(), 0);
+    ASSERT_GT(updatedStats.spillWrites.load(), 0);
 
-    const auto newGStats = common::globalSpillStats();
+    const auto newGStats = globalSpillStats();
     ASSERT_EQ(
-        prevGStats.spilledFiles + stats.spilledFiles, newGStats.spilledFiles);
+        prevGStats.spilledFiles + updatedStats.spilledFiles.load(),
+        newGStats.spilledFiles);
     ASSERT_EQ(
-        prevGStats.spilledRows + stats.spilledRows, newGStats.spilledRows);
+        prevGStats.spilledRows + updatedStats.spilledRows.load(),
+        newGStats.spilledRows);
     ASSERT_EQ(
-        prevGStats.spilledPartitions + stats.spilledPartitions,
+        prevGStats.spilledPartitions + updatedStats.spilledPartitions.load(),
         newGStats.spilledPartitions);
     ASSERT_EQ(
-        prevGStats.spilledBytes + stats.spilledBytes, newGStats.spilledBytes);
+        prevGStats.spilledBytes + updatedStats.spilledBytes.load(),
+        newGStats.spilledBytes);
     ASSERT_EQ(
-        prevGStats.spillReadBytes + stats.spillReadBytes,
+        prevGStats.spillReadBytes + updatedStats.spillReadBytes.load(),
         newGStats.spillReadBytes);
-    ASSERT_EQ(prevGStats.spillReads + stats.spillReads, newGStats.spillReads);
     ASSERT_EQ(
-        prevGStats.spillReadTimeNanos + stats.spillReadTimeNanos,
+        prevGStats.spillReads + updatedStats.spillReads.load(),
+        newGStats.spillReads);
+    ASSERT_EQ(
+        prevGStats.spillReadTimeNanos + updatedStats.spillReadTimeNanos.load(),
         newGStats.spillReadTimeNanos);
     ASSERT_EQ(
         prevGStats.spillDeserializationTimeNanos +
-            stats.spillDeserializationTimeNanos,
+            updatedStats.spillDeserializationTimeNanos.load(),
         newGStats.spillDeserializationTimeNanos);
     ASSERT_EQ(
         prevGStats.spillWriteTimeNanos + stats.spillWriteTimeNanos,
@@ -614,7 +624,8 @@ class SpillerTest : public exec::test::RowContainerTestBase {
       return tempDirPath_->getPath();
     };
     stats_.clear();
-    spillStats_ = folly::Synchronized<common::SpillStats>();
+    spillStats_ = folly::Synchronized<exec::SpillStats>();
+    spillIoStats_ = IoStats();
 
     spillConfig_.startPartitionBit = hashBits_.begin();
     spillConfig_.numPartitionBits = hashBits_.numBits();
@@ -635,7 +646,11 @@ class SpillerTest : public exec::test::RowContainerTestBase {
 
     if (type_ == SpillerType::NO_ROW_CONTAINER) {
       spiller_ = std::make_unique<NoRowContainerSpiller>(
-          rowType_, std::nullopt, hashBits_, &spillConfig_, &spillStats_);
+          rowType_,
+          std::nullopt,
+          hashBits_,
+          &spillConfig_,
+          spillStats_.wlock().operator->());
     } else if (type_ == SpillerType::SORT_INPUT) {
       const auto sortingKeys = SpillState::makeSortingKeys(
           compareFlags_.empty()
@@ -646,10 +661,13 @@ class SpillerTest : public exec::test::RowContainerTestBase {
           rowType_,
           sortingKeys,
           &spillConfig_,
-          &spillStats_);
+          spillStats_.wlock().operator->());
     } else if (type_ == SpillerType::SORT_OUTPUT) {
       spiller_ = std::make_unique<SortOutputSpiller>(
-          rowContainer_.get(), rowType_, &spillConfig_, &spillStats_);
+          rowContainer_.get(),
+          rowType_,
+          &spillConfig_,
+          spillStats_.wlock().operator->());
     } else if (type_ == SpillerType::HASH_BUILD) {
       spiller_ = std::make_unique<HashBuildSpiller>(
           joinType_,
@@ -658,7 +676,7 @@ class SpillerTest : public exec::test::RowContainerTestBase {
           rowType_,
           hashBits_,
           &spillConfig_,
-          &spillStats_);
+          spillStats_.wlock().operator->());
     } else if (type_ == SpillerType::AGGREGATION_INPUT) {
       const auto sortingKeys = SpillState::makeSortingKeys(
           compareFlags_.empty()
@@ -670,10 +688,13 @@ class SpillerTest : public exec::test::RowContainerTestBase {
           hashBits_,
           sortingKeys,
           &spillConfig_,
-          &spillStats_);
+          spillStats_.wlock().operator->());
     } else if (type_ == SpillerType::AGGREGATION_OUTPUT) {
       spiller_ = std::make_unique<AggregationOutputSpiller>(
-          rowContainer_.get(), rowType_, &spillConfig_, &spillStats_);
+          rowContainer_.get(),
+          rowType_,
+          &spillConfig_,
+          spillStats_.wlock().operator->());
     } else if (type_ == SpillerType::ROW_NUMBER_HASH_TABLE) {
       spiller_ = std::make_unique<RowNumberHashTableSpiller>(
           rowContainer_.get(),
@@ -681,7 +702,7 @@ class SpillerTest : public exec::test::RowContainerTestBase {
           rowType_,
           hashBits_,
           &spillConfig_,
-          &spillStats_);
+          spillStats_.wlock().operator->());
     } else {
       VELOX_UNREACHABLE("Unknown spiller type");
     }
@@ -714,11 +735,12 @@ class SpillerTest : public exec::test::RowContainerTestBase {
       // We make a merge reader that merges the spill files and the rows that
       // are still in the RowContainer.
       auto merge = spillPartition->createOrderedReader(
-          spillConfig_.readBufferSize, pool(), &spillStats_);
+          spillConfig_, pool(), spillStats_.wlock().operator->());
       ASSERT_TRUE(merge != nullptr);
       ASSERT_TRUE(
           spillPartition->createOrderedReader(
-              spillConfig_.readBufferSize, pool(), &spillStats_) == nullptr);
+              spillConfig_, pool(), spillStats_.wlock().operator->()) ==
+          nullptr);
 
       // We read the spilled data back and check that it matches the sorted
       // order of the partition.
@@ -865,14 +887,15 @@ class SpillerTest : public exec::test::RowContainerTestBase {
       ss << partitionId.toString() << " ";
     }
     ss << "]";
-    SCOPED_TRACE(fmt::format(
-        "Param: {}, numSpillers: {}, numBatchRows: {}, numAppendBatches: {}, targetFileSize: {}, spillPartitionIdSet: {}",
-        param_.toString(),
-        numSpillers,
-        numBatchRows,
-        numAppendBatches,
-        targetFileSize,
-        ss.str()));
+    SCOPED_TRACE(
+        fmt::format(
+            "Param: {}, numSpillers: {}, numBatchRows: {}, numAppendBatches: {}, targetFileSize: {}, spillPartitionIdSet: {}",
+            param_.toString(),
+            numSpillers,
+            numBatchRows,
+            numAppendBatches,
+            targetFileSize,
+            ss.str()));
 
     std::vector<std::vector<RowVectorPtr>> inputsByPartition(numPartitions_);
 
@@ -882,7 +905,7 @@ class SpillerTest : public exec::test::RowContainerTestBase {
     // them by partition.
     std::vector<std::unique_ptr<SpillerBase>> spillers;
     for (int iter = 0; iter < numSpillers; ++iter) {
-      const auto prevGStats = common::globalSpillStats();
+      const auto prevGStats = globalSpillStats();
       setupSpillData(
           numKeys_,
           (type_ != SpillerType::NO_ROW_CONTAINER) ? numBatchRows * 10 : 0,
@@ -963,7 +986,7 @@ class SpillerTest : public exec::test::RowContainerTestBase {
         ASSERT_EQ(stats.spillFillTimeNanos, 0);
       }
 
-      const auto newGStats = common::globalSpillStats();
+      const auto newGStats = globalSpillStats();
       ASSERT_EQ(
           prevGStats.spilledFiles + stats.spilledFiles, newGStats.spilledFiles);
       ASSERT_EQ(
@@ -1007,7 +1030,7 @@ class SpillerTest : public exec::test::RowContainerTestBase {
 
     // Spilled file stats should be updated after finalizing spiller.
     if (numAppendBatches > 0) {
-      ASSERT_GT(common::globalSpillStats().spilledFiles, 0);
+      ASSERT_GT(globalSpillStats().spilledFiles, 0);
     }
   }
 
@@ -1047,7 +1070,9 @@ class SpillerTest : public exec::test::RowContainerTestBase {
               spillConfig_.startPartitionBit,
               spillConfig_.numPartitionBits));
       auto reader = spillPartitionEntry.second->createUnorderedReader(
-          spillConfig_.readBufferSize, pool(), &spillStats_);
+          spillConfig_.readBufferSize,
+          pool(),
+          spillStats_.wlock().operator->());
       if (type_ == SpillerType::NO_ROW_CONTAINER) {
         // For hash probe type, we append each input vector as one batch in
         // spill file so that we can do one-to-one comparison.
@@ -1129,7 +1154,9 @@ class SpillerTest : public exec::test::RowContainerTestBase {
               spillConfig_.startPartitionBit,
               spillConfig_.numPartitionBits));
       auto reader = spillPartitionEntry.second->createUnorderedReader(
-          spillConfig_.readBufferSize, pool(), &spillStats_);
+          spillConfig_.readBufferSize,
+          pool(),
+          spillStats_.wlock().operator->());
       if (type_ == SpillerType::NO_ROW_CONTAINER) {
         // For hash probe type, we append each input vector as one batch in
         // spill file so that we can do one-to-one comparison.
@@ -1231,7 +1258,9 @@ class SpillerTest : public exec::test::RowContainerTestBase {
   std::vector<CompareFlags> compareFlags_;
   std::unique_ptr<SpillerBase> spiller_;
   common::SpillConfig spillConfig_;
-  folly::Synchronized<common::SpillStats> spillStats_;
+  folly::Synchronized<exec::SpillStats> spillStats_;
+  // Filesystem I/O stats for spill operations.
+  IoStats spillIoStats_;
 };
 
 struct AllTypesTestParam {
@@ -1573,7 +1602,7 @@ TEST_P(AggregationOutputOnly, basic) {
       ASSERT_EQ(spillPartitionSet.size(), 1);
       auto spillPartition = std::move(spillPartitionSet.begin()->second);
       auto merge = spillPartition->createOrderedReader(
-          spillConfig_.readBufferSize, pool(), &spillStats_);
+          spillConfig_, pool(), spillStats_.wlock().operator->());
 
       for (auto i = 0; i < expectedNumSpilledRows; ++i) {
         auto* stream = merge->next();
@@ -1687,7 +1716,7 @@ TEST_P(SortOutputOnly, basic) {
 
     const int expectedNumSpilledRows = numListedRows;
     auto merge = spillPartition->createOrderedReader(
-        spillConfig_.readBufferSize, pool(), &spillStats_);
+        spillConfig_, pool(), spillStats_.wlock().operator->());
     if (expectedNumSpilledRows == 0) {
       ASSERT_TRUE(merge == nullptr);
     } else {
diff --git a/velox/exec/tests/SplitListenerTest.cpp b/velox/exec/tests/SplitListenerTest.cpp
index 15c8ebc613a..17421713494 100644
--- a/velox/exec/tests/SplitListenerTest.cpp
+++ b/velox/exec/tests/SplitListenerTest.cpp
@@ -14,15 +14,16 @@
  * limitations under the License.
  */
 
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/exec/Task.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 using namespace facebook::velox::exec;
 
 namespace facebook::velox::exec::test {
+using namespace facebook::velox::common::testutil;
 namespace {
 
 std::unordered_map<std::string, std::unordered_map<core::PlanNodeId, int64_t>>
@@ -131,10 +132,11 @@ class SplitListenerTest : public HiveConnectorTestBase {
     std::vector<std::shared_ptr<connector::ConnectorSplit>> splits;
     splits.reserve(filePaths_.size());
     for (const auto& filePath : filePaths_) {
-      splits.emplace_back(connector::hive::HiveConnectorSplitBuilder(filePath)
-                              .connectorId(kHiveConnectorId)
-                              .fileFormat(dwio::common::FileFormat::DWRF)
-                              .build());
+      splits.emplace_back(
+          connector::hive::HiveConnectorSplitBuilder(filePath)
+              .connectorId(kHiveConnectorId)
+              .fileFormat(dwio::common::FileFormat::DWRF)
+              .build());
     }
     return splits;
   }
diff --git a/velox/exec/tests/StreamingAggregationTest.cpp b/velox/exec/tests/StreamingAggregationTest.cpp
index 493163413b3..f8c1d265152 100644
--- a/velox/exec/tests/StreamingAggregationTest.cpp
+++ b/velox/exec/tests/StreamingAggregationTest.cpp
@@ -13,22 +13,33 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/exec/StreamingAggregation.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TempFilePath.h"
+#include "velox/common/testutil/TestValue.h"
 #include "velox/core/Expressions.h"
+
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/exec/tests/utils/SumNonPODAggregate.h"
-#include "velox/exec/tests/utils/TempFilePath.h"
+
+using namespace facebook::velox::common::testutil;
 
 namespace facebook::velox::exec {
 namespace {
 
 using namespace facebook::velox::exec::test;
 
-class StreamingAggregationTest : public HiveConnectorTestBase,
-                                 public testing::WithParamInterface<int32_t> {
+struct TestParams {
+  int32_t streamingMinOutputBatchSize;
+  uint64_t preferredOutputBatchBytes;
+};
+
+class StreamingAggregationTest
+    : public HiveConnectorTestBase,
+      public testing::WithParamInterface<TestParams> {
  protected:
   void SetUp() override {
     HiveConnectorTestBase::SetUp();
@@ -36,7 +47,11 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
   }
 
   int32_t flushRows() {
-    return GetParam();
+    return GetParam().streamingMinOutputBatchSize;
+  }
+
+  uint64_t preferredOutputBatchBytes() {
+    return GetParam().preferredOutputBatchBytes;
   }
 
   AssertQueryBuilder& config(
@@ -48,7 +63,10 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
             std::to_string(outputBatchSize))
         .config(
             core::QueryConfig::kStreamingAggregationMinOutputBatchRows,
-            std::to_string(flushRows()));
+            std::to_string(flushRows()))
+        .config(
+            core::QueryConfig::kPreferredOutputBatchBytes,
+            std::to_string(preferredOutputBatchBytes()));
   }
 
   void testAggregation(
@@ -156,8 +174,9 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
     core::PlanNodeId aggregationNodeId;
     auto plan = PlanBuilder(planNodeIdGenerator)
                     .startTableScan()
-                    .outputType(std::dynamic_pointer_cast<const RowType>(
-                        inputVectors[0]->type()))
+                    .outputType(
+                        std::dynamic_pointer_cast<const RowType>(
+                            inputVectors[0]->type()))
                     .endTableScan()
                     .streamingAggregation(
                         {"c0"},
@@ -170,20 +189,34 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
                     .capturePlanNodeId(aggregationNodeId)
                     .planNode();
 
-    for (const auto barrierExecution : {false, true}) {
-      SCOPED_TRACE(fmt::format("barrierExecution {}", barrierExecution));
+    struct {
+      bool hasBarrier;
+      bool serialExecution;
+
+      std::string toString() const {
+        return fmt::format(
+            "hasBarrier: {}, serialExecution: {}", hasBarrier, serialExecution);
+      }
+    } testSettings[] = {
+        {false, false},
+        {false, true},
+        {true, false},
+        {true, true},
+    };
+    for (const auto& testData : testSettings) {
+      SCOPED_TRACE(testData.toString());
       auto task =
           AssertQueryBuilder(plan, duckDbQueryRunner_)
               .splits(makeHiveConnectorSplits(tempFiles))
-              .serialExecution(true)
-              .barrierExecution(barrierExecution)
+              .serialExecution(testData.serialExecution)
+              .barrierExecution(testData.hasBarrier)
               .config(
                   core::QueryConfig::kPreferredOutputBatchRows,
                   std::to_string(outputBatchSize))
               .assertResults(
                   "SELECT c0, max(c1 order by c2), max(c1 order by c2 desc), array_agg(c1 order by c2) FROM tmp GROUP BY c0");
       const auto taskStats = task->taskStats();
-      ASSERT_EQ(taskStats.numBarriers, barrierExecution ? numSplits : 0);
+      ASSERT_EQ(taskStats.numBarriers, testData.hasBarrier ? numSplits : 0);
       ASSERT_EQ(taskStats.numFinishedSplits, numSplits);
       ASSERT_EQ(
           velox::exec::toPlanStats(taskStats)
@@ -251,8 +284,9 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
       core::PlanNodeId aggregationNodeId;
       auto plan = PlanBuilder(planNodeIdGenerator)
                       .startTableScan()
-                      .outputType(std::dynamic_pointer_cast<const RowType>(
-                          inputVectors[0]->type()))
+                      .outputType(
+                          std::dynamic_pointer_cast<const RowType>(
+                              inputVectors[0]->type()))
                       .endTableScan()
                       .streamingAggregation(
                           {"c0"},
@@ -265,13 +299,30 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
                           false)
                       .capturePlanNodeId(aggregationNodeId)
                       .planNode();
-      for (const auto barrierExecution : {false, true}) {
-        SCOPED_TRACE(fmt::format("barrierExecution {}", barrierExecution));
+      struct {
+        bool hasBarrier;
+        bool serialExecution;
+
+        std::string toString() const {
+          return fmt::format(
+              "hasBarrier: {}, serialExecution: {}",
+              hasBarrier,
+              serialExecution);
+        }
+      } testSettings[] = {
+          {false, true},
+          {false, false},
+          {true, true},
+          {true, false},
+      };
+      for (const auto& testData : testSettings) {
+        SCOPED_TRACE(testData.toString());
         auto task =
             AssertQueryBuilder(plan, duckDbQueryRunner_)
                 .splits(makeHiveConnectorSplits(tempFiles))
-                .serialExecution(true)
-                .barrierExecution(barrierExecution)
+                .serialExecution(testData.serialExecution)
+                .barrierExecution(testData.hasBarrier)
+                .maxDrivers(testData.serialExecution ? 1 : 3)
                 .config(
                     core::QueryConfig::kPreferredOutputBatchRows,
                     std::to_string(outputBatchSize))
@@ -279,7 +330,7 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
                     "SELECT c0, array_agg(distinct c1), array_agg(c1 order by c2), "
                     "count(distinct c1), array_agg(c2) FROM tmp GROUP BY c0");
         const auto taskStats = task->taskStats();
-        ASSERT_EQ(taskStats.numBarriers, barrierExecution ? numSplits : 0);
+        ASSERT_EQ(taskStats.numBarriers, testData.hasBarrier ? numSplits : 0);
         ASSERT_EQ(taskStats.numFinishedSplits, numSplits);
         ASSERT_EQ(
             velox::exec::toPlanStats(taskStats)
@@ -294,8 +345,9 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
       auto plan =
           PlanBuilder(planNodeIdGenerator)
               .startTableScan()
-              .outputType(std::dynamic_pointer_cast<const RowType>(
-                  inputVectors[0]->type()))
+              .outputType(
+                  std::dynamic_pointer_cast<const RowType>(
+                      inputVectors[0]->type()))
               .endTableScan()
               .streamingAggregation(
                   {"c0"}, {}, {}, core::AggregationNode::Step::kSingle, false)
@@ -500,8 +552,9 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
       auto plan =
           PlanBuilder(planNodeIdGenerator)
               .startTableScan()
-              .outputType(std::dynamic_pointer_cast<const RowType>(
-                  inputVectors[0]->type()))
+              .outputType(
+                  std::dynamic_pointer_cast<const RowType>(
+                      inputVectors[0]->type()))
               .endTableScan()
               .streamingAggregation(
                   keys[0]->type()->asRow().names(),
@@ -524,18 +577,34 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
           keySql.str(),
           keySql.str());
 
-      for (const auto barrierExecution : {false, true}) {
-        SCOPED_TRACE(fmt::format("barrierExecution {}", barrierExecution));
+      struct {
+        bool hasBarrier;
+        bool serialExecution;
+
+        std::string toString() const {
+          return fmt::format(
+              "hasBarrier: {}, serialExecution: {}",
+              hasBarrier,
+              serialExecution);
+        }
+      } testSettings[] = {
+          {false, false},
+          {false, true},
+          {true, false},
+          {true, true},
+      };
+      for (const auto& testData : testSettings) {
+        SCOPED_TRACE(testData.toString());
         auto task = AssertQueryBuilder(plan, duckDbQueryRunner_)
                         .splits(makeHiveConnectorSplits(tempFiles))
-                        .serialExecution(true)
-                        .barrierExecution(barrierExecution)
+                        .serialExecution(testData.serialExecution)
+                        .barrierExecution(testData.hasBarrier)
                         .config(
                             core::QueryConfig::kPreferredOutputBatchRows,
                             std::to_string(outputBatchSize))
                         .assertResults(sql);
         const auto taskStats = task->taskStats();
-        ASSERT_EQ(taskStats.numBarriers, barrierExecution ? numSplits : 0);
+        ASSERT_EQ(taskStats.numBarriers, testData.hasBarrier ? numSplits : 0);
         ASSERT_EQ(taskStats.numFinishedSplits, numSplits);
         EXPECT_EQ(NonPODInt64::constructed, NonPODInt64::destructed);
       }
@@ -545,8 +614,9 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
       core::PlanNodeId aggregationNodeId;
       auto plan = PlanBuilder(planNodeIdGenerator)
                       .startTableScan()
-                      .outputType(std::dynamic_pointer_cast<const RowType>(
-                          inputVectors[0]->type()))
+                      .outputType(
+                          std::dynamic_pointer_cast<const RowType>(
+                              inputVectors[0]->type()))
                       .endTableScan()
                       .streamingAggregation(
                           keys[0]->type()->asRow().names(),
@@ -566,18 +636,34 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
 
       const auto sql = fmt::format("SELECT distinct {} FROM tmp", keySql.str());
 
-      for (const auto barrierExecution : {false, true}) {
-        SCOPED_TRACE(fmt::format("barrierExecution {}", barrierExecution));
+      struct {
+        bool hasBarrier;
+        bool serialExecution;
+
+        std::string toString() const {
+          return fmt::format(
+              "hasBarrier: {}, serialExecution: {}",
+              hasBarrier,
+              serialExecution);
+        }
+      } testSettings[] = {
+          {false, false},
+          {false, true},
+          {true, false},
+          {true, true},
+      };
+      for (const auto& testData : testSettings) {
+        SCOPED_TRACE(testData.toString());
         auto task = AssertQueryBuilder(plan, duckDbQueryRunner_)
                         .splits(makeHiveConnectorSplits(tempFiles))
-                        .serialExecution(true)
-                        .barrierExecution(barrierExecution)
+                        .serialExecution(testData.serialExecution)
+                        .barrierExecution(testData.hasBarrier)
                         .config(
                             core::QueryConfig::kPreferredOutputBatchRows,
                             std::to_string(outputBatchSize))
                         .assertResults(sql);
         const auto taskStats = task->taskStats();
-        ASSERT_EQ(taskStats.numBarriers, barrierExecution ? numSplits : 0);
+        ASSERT_EQ(taskStats.numBarriers, testData.hasBarrier ? numSplits : 0);
         ASSERT_EQ(taskStats.numFinishedSplits, numSplits);
         EXPECT_EQ(NonPODInt64::constructed, NonPODInt64::destructed);
       }
@@ -588,13 +674,32 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
 VELOX_INSTANTIATE_TEST_SUITE_P(
     StreamingAggregationTest,
     StreamingAggregationTest,
-    testing::ValuesIn({0, 1, 64, std::numeric_limits<int32_t>::max()}),
-    [](const testing::TestParamInfo<int32_t>& info) {
+    testing::Values(
+        TestParams{0, 1},
+        TestParams{0, 1024},
+        TestParams{0, std::numeric_limits<uint64_t>::max()},
+        TestParams{1, 1},
+        TestParams{1, 1024},
+        TestParams{1, std::numeric_limits<uint64_t>::max()},
+        TestParams{64, 1},
+        TestParams{64, 1024},
+        TestParams{64, std::numeric_limits<uint64_t>::max()},
+        TestParams{std::numeric_limits<int32_t>::max(), 1},
+        TestParams{std::numeric_limits<int32_t>::max(), 1024},
+        TestParams{
+            std::numeric_limits<int32_t>::max(),
+            std::numeric_limits<uint64_t>::max()}),
+    [](const testing::TestParamInfo<TestParams>& info) {
       return fmt::format(
-          "streamingMinOutputBatchSize_{}",
-          info.param == std::numeric_limits<int32_t>::max()
+          "streamingMinOutputBatchSize_{}_preferredOutputBatchBytes_{}",
+          info.param.streamingMinOutputBatchSize ==
+                  std::numeric_limits<int32_t>::max()
+              ? "inf"
+              : std::to_string(info.param.streamingMinOutputBatchSize),
+          info.param.preferredOutputBatchBytes ==
+                  std::numeric_limits<uint64_t>::max()
               ? "inf"
-              : std::to_string(info.param));
+              : std::to_string(info.param.preferredOutputBatchBytes));
     });
 
 TEST_P(StreamingAggregationTest, smallInputBatches) {
@@ -1036,16 +1141,17 @@ TEST_P(StreamingAggregationTest, clusteredInputWithBarrier) {
 
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   core::PlanNodeId streamingAggregationNodeId;
-  auto plan = PlanBuilder(planNodeIdGenerator)
-                  .startTableScan()
-                  .outputType(std::dynamic_pointer_cast<const RowType>(
-                      inputVectors[0]->type()))
-                  .endTableScan()
-                  .partialStreamingAggregation(
-                      {"c0"}, {"count(c1)", "arbitrary(c1)", "array_agg(c1)"})
-                  .capturePlanNodeId(streamingAggregationNodeId)
-                  .finalAggregation()
-                  .planNode();
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .startTableScan()
+          .outputType(
+              std::dynamic_pointer_cast<const RowType>(inputVectors[0]->type()))
+          .endTableScan()
+          .partialStreamingAggregation(
+              {"c0"}, {"count(c1)", "arbitrary(c1)", "array_agg(c1)"})
+          .capturePlanNodeId(streamingAggregationNodeId)
+          .finalAggregation()
+          .planNode();
   const auto expected = makeRowVector(
       {makeNullableFlatVector<int32_t>(
            {1, 2, std::nullopt, 3, 4, 9, 10, 11, 12, 17, 18, 19}),
@@ -1137,6 +1243,166 @@ TEST_P(StreamingAggregationTest, constantInput) {
   config(AssertQueryBuilder(plan), 10).assertResults(expected);
 }
 
+TEST_P(StreamingAggregationTest, preferredOutputBatchBytes) {
+  // Use grouping keys that span one or more batches.
+  std::vector<VectorPtr> keys = {
+      makeNullableFlatVector<int32_t>({1, 1, std::nullopt, 2, 2}),
+      makeFlatVector<int32_t>({2, 3, 3, 4}),
+      makeFlatVector<int32_t>({5, 6, 6, 6}),
+      makeFlatVector<int32_t>({6, 6, 6, 6}),
+      makeFlatVector<int32_t>({6, 7, 8}),
+  };
+
+  auto data = addPayload(keys, 1);
+
+  auto plan = PlanBuilder()
+                  .values(data)
+                  .partialStreamingAggregation(
+                      {"c0"},
+                      {"count(1)",
+                       "min(c1)",
+                       "max(c1)",
+                       "sum(c1)",
+                       "sumnonpod(1)",
+                       "sum(cast(NULL as INT))"})
+                  .finalAggregation()
+                  .planNode();
+
+  auto results =
+      config(AssertQueryBuilder(plan), 1024).copyResultBatches(pool_.get());
+
+  // If streamingMinOutputBatchSize is set to 1, we expect an output batch for:
+  // {1, NULL}, {2}, {3, 4}, {5}, {6}, {7, 8}.
+  // Otherwise, we expect the output batches to be determined by
+  // preferredOutputBatchBytes.
+  size_t expectedOutputBatches;
+  if (GetParam().streamingMinOutputBatchSize == 1) {
+    expectedOutputBatches = 6;
+  } else if (GetParam().preferredOutputBatchBytes == 1) {
+    expectedOutputBatches = 5;
+  } else if (GetParam().preferredOutputBatchBytes == 1024) {
+    expectedOutputBatches = 2;
+  } else {
+    ASSERT_EQ(
+        GetParam().preferredOutputBatchBytes,
+        std::numeric_limits<uint64_t>::max());
+    expectedOutputBatches = 1;
+  }
+
+  ASSERT_EQ(results.size(), expectedOutputBatches);
+}
+
+TEST_F(StreamingAggregationTest, noGroupsSpanBatchesSingleGroup) {
+  // Create input batches where each batch has exactly one unique group.
+  // This tests the corner case where numGroups_ == 1 and noGroupsSpanBatches_
+  // is true.
+  std::vector<VectorPtr> keys = {
+      makeFlatVector<int32_t>({1, 1, 1, 1}),
+      makeFlatVector<int32_t>({2, 2, 2, 2}),
+      makeFlatVector<int32_t>({3, 3, 3, 3}),
+  };
+
+  auto data = addPayload(keys, 1);
+  createDuckDbTable(data);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId aggregationNodeId;
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(data)
+                  .streamingAggregation(
+                      {"c0"},
+                      {"count(1)", "sum(c1)"},
+                      {},
+                      core::AggregationNode::Step::kSingle,
+                      /*ignoreNullKeys=*/false,
+                      /*noGroupsSpanBatches=*/true)
+                  .capturePlanNodeId(aggregationNodeId)
+                  .planNode();
+
+  auto task =
+      AssertQueryBuilder(plan, duckDbQueryRunner_)
+          .config(
+              core::QueryConfig::kStreamingAggregationMinOutputBatchRows,
+              std::to_string(1))
+          .assertResults("SELECT c0, count(1), sum(c1) FROM tmp GROUP BY c0");
+
+  // Verify the number of output batches matches the number of input batches
+  // because each batch contains a single group that should be output
+  // immediately.
+  const auto taskStats = task->taskStats();
+  ASSERT_EQ(
+      velox::exec::toPlanStats(taskStats).at(aggregationNodeId).outputVectors,
+      keys.size());
+}
+
+// Tests that when noGroupsSpanBatches is set, the number of output batches
+// matches the number of input batches when minOutputBatchRows is set to 1.
+// When minOutputBatchRows is set to an extremely large value, we expect a
+// single output batch.
+TEST_F(StreamingAggregationTest, noGroupsSpanBatches) {
+  // Create input batches where no group spans across batches.
+  // Each batch has unique grouping keys that don't appear in other batches.
+  std::vector<VectorPtr> keys = {
+      makeFlatVector<int32_t>({1, 1, 2, 2}),
+      makeFlatVector<int32_t>({3, 3, 4, 4}),
+      makeFlatVector<int32_t>({5, 5, 6, 6}),
+      makeFlatVector<int32_t>({7, 7, 8, 8}),
+      makeFlatVector<int32_t>({9, 9, 10, 10}),
+  };
+
+  auto data = addPayload(keys, 1);
+  createDuckDbTable(data);
+
+  struct {
+    int32_t minOutputBatchRows;
+    size_t expectedOutputBatches;
+
+    std::string debugString() const {
+      return fmt::format(
+          "minOutputBatchRows={}, expectedOutputBatches={}",
+          minOutputBatchRows,
+          expectedOutputBatches);
+    }
+  } testSettings[] = {
+      // Regardless of the value of minOutputBatchRows, each input batch
+      // produces an output batch.
+      // We do not respect minOutputBatchRows when noGroupsSpanBatches is set.
+      {1, keys.size()},
+      {std::numeric_limits<int32_t>::max(), keys.size()},
+  };
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId aggregationNodeId;
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(data)
+                    .streamingAggregation(
+                        {"c0"},
+                        {"count(1)", "sum(c1)"},
+                        {},
+                        core::AggregationNode::Step::kSingle,
+                        /*ignoreNullKeys=*/false,
+                        /*noGroupsSpanBatches=*/true)
+                    .capturePlanNodeId(aggregationNodeId)
+                    .planNode();
+
+    auto task =
+        AssertQueryBuilder(plan, duckDbQueryRunner_)
+            .config(
+                core::QueryConfig::kStreamingAggregationMinOutputBatchRows,
+                std::to_string(testData.minOutputBatchRows))
+            .assertResults("SELECT c0, count(1), sum(c1) FROM tmp GROUP BY c0");
+
+    // Verify the number of output batches.
+    const auto taskStats = task->taskStats();
+    ASSERT_EQ(
+        velox::exec::toPlanStats(taskStats).at(aggregationNodeId).outputVectors,
+        testData.expectedOutputBatches);
+  }
+}
+
 namespace {
 class InputSourceNode : public core::PlanNode {
  public:
@@ -1286,5 +1552,41 @@ TEST_P(StreamingAggregationTest, needsInputWhenSplitOutput) {
       velox::exec::toPlanStats(taskStats).at(aggregationNodeId).outputVectors,
       9);
 }
+// Verify that during createOutput, the aggregation state is destroyed.
+DEBUG_ONLY_TEST_P(StreamingAggregationTest, singleAggregationCleansState) {
+  auto size = 1'000;
+
+  VectorPtr keys =
+      makeFlatVector<int32_t>(size, [](auto row) { return row / 10; });
+
+  auto data = addPayload({keys, keys, keys, keys}, 1);
+
+  bool checkedAtLeastOnce = false;
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::StreamingAggregation::createOutput",
+      std::function<void(StreamingAggregation*)>([&](StreamingAggregation*) {
+        checkedAtLeastOnce = true;
+        EXPECT_GT(NonPODInt64::destructed, 0);
+      }));
+
+  auto plan = PlanBuilder()
+                  .values(data)
+                  .streamingAggregation(
+                      {"c0"},
+                      {"sumnonpod(1)"},
+                      {},
+                      core::AggregationNode::Step::kSingle,
+                      false,
+                      true /* noGroupsSpanBatches */)
+                  .planNode();
+
+  config(AssertQueryBuilder(plan), 100).copyResults(pool());
+
+  EXPECT_TRUE(checkedAtLeastOnce)
+      << "TestValue callback was never invoked; createOutput may not have "
+         "been called";
+  EXPECT_EQ(NonPODInt64::constructed, NonPODInt64::destructed);
+}
+
 } // namespace
 } // namespace facebook::velox::exec
diff --git a/velox/exec/tests/StreamingEnforceDistinctTest.cpp b/velox/exec/tests/StreamingEnforceDistinctTest.cpp
new file mode 100644
index 00000000000..df70a816bae
--- /dev/null
+++ b/velox/exec/tests/StreamingEnforceDistinctTest.cpp
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+using namespace facebook::velox::exec::test;
+
+namespace facebook::velox::exec {
+namespace {
+
+class StreamingEnforceDistinctTest : public OperatorTestBase {
+ protected:
+  core::PlanNodePtr makePlan(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<std::string>& keys,
+      const std::string& errorMessage) {
+    return PlanBuilder()
+        .values(input)
+        .streamingEnforceDistinct(keys, errorMessage)
+        .planNode();
+  }
+
+  core::PlanNodePtr makePlan(
+      const RowVectorPtr& input,
+      const std::string& key,
+      const std::string& errorMessage) {
+    return PlanBuilder()
+        .values({input})
+        .streamingEnforceDistinct({key}, errorMessage)
+        .planNode();
+  }
+
+  void assertDistinct(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<std::string>& keys) {
+    auto plan = makePlan(input, keys, "Duplicate key found");
+    AssertQueryBuilder(plan).assertResults(input);
+  }
+};
+
+TEST_F(StreamingEnforceDistinctTest, uniqueRowsSingleKey) {
+  auto data = makeRowVector({
+      makeNullableFlatVector<int32_t>({1, 2, 3, std::nullopt, 5, 6, 7, 8, 9}),
+      makeFlatVector<std::string>(
+          {"a", "a", "b", "b", "a", "a", "b", "b", "a"}),
+  });
+
+  assertDistinct(split(data, 3), {"c0"});
+}
+
+TEST_F(StreamingEnforceDistinctTest, uniqueRowsMultipleKeys) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({1, 1, 2, 2, 3, 3, 4, 4, 5}),
+      makeFlatVector<std::string>(
+          {"x", "x", "y", "y", "x", "x", "y", "y", "x"}),
+      makeFlatVector<int64_t>({10, 20, 10, 20, 10, 20, 10, 20, 10}),
+  });
+
+  assertDistinct(split(data, 3), {"c0", "c2"});
+}
+
+TEST_F(StreamingEnforceDistinctTest, duplicateWithinBatch) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 2, 3, 4}),
+  });
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(makePlan(data, "c0", "Duplicate key found"))
+          .countResults(),
+      "Duplicate key found");
+}
+
+TEST_F(StreamingEnforceDistinctTest, duplicateAcrossBatches) {
+  auto batch1 = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 3}),
+  });
+
+  auto batch2 = makeRowVector({
+      makeFlatVector<int32_t>({3, 4, 5}),
+  });
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(
+          makePlan({batch1, batch2}, {"c0"}, "Duplicate key found"))
+          .countResults(),
+      "Duplicate key found");
+}
+
+TEST_F(StreamingEnforceDistinctTest, emptyInput) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({}),
+  });
+
+  assertDistinct({data}, {"c0"});
+}
+
+TEST_F(StreamingEnforceDistinctTest, singleRow) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({42}),
+  });
+
+  assertDistinct({data}, {"c0"});
+}
+
+TEST_F(StreamingEnforceDistinctTest, duplicateNulls) {
+  auto data = makeRowVector({
+      makeNullableFlatVector<int32_t>({1, std::nullopt, std::nullopt, 4, 5}),
+  });
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(makePlan(data, "c0", "Duplicate key found"))
+          .countResults(),
+      "Duplicate key found");
+}
+
+TEST_F(StreamingEnforceDistinctTest, duplicateNullsAcrossBatches) {
+  auto batch1 = makeRowVector({
+      makeNullableFlatVector<int32_t>({1, 2, std::nullopt}),
+  });
+
+  auto batch2 = makeRowVector({
+      makeNullableFlatVector<int32_t>({std::nullopt, 4, 5}),
+  });
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(
+          makePlan({batch1, batch2}, {"c0"}, "Duplicate key found"))
+          .countResults(),
+      "Duplicate key found");
+}
+
+} // namespace
+} // namespace facebook::velox::exec
diff --git a/velox/exec/tests/TableEvolutionFuzzer.cpp b/velox/exec/tests/TableEvolutionFuzzer.cpp
index a353cbe5057..f9bb3814549 100644
--- a/velox/exec/tests/TableEvolutionFuzzer.cpp
+++ b/velox/exec/tests/TableEvolutionFuzzer.cpp
@@ -15,13 +15,13 @@
  */
 
 #include "velox/exec/tests/TableEvolutionFuzzer.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
 #include "velox/dwio/common/tests/utils/FilterGenerator.h"
 #include "velox/dwio/dwrf/common/Config.h"
 #include "velox/exec/Cursor.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/exec/tests/utils/QueryAssertions.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/expression/fuzzer/ExpressionFuzzer.h"
 #include "velox/functions/FunctionRegistry.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
@@ -48,7 +48,15 @@ DEFINE_bool(
     "up after failures. Therefore, results are not compared when this is "
     "enabled. Note that this option only works in debug builds.");
 
+DEFINE_int32(
+    aggregation_pushdown_frequency,
+    5,
+    "Controls the frequency of aggregation pushdown. The aggregation pushdown "
+    "is enabled with probability 1/N where N is this value. For example, "
+    "N=5 means 20% chance, N=2 means 50% chance.");
+
 namespace facebook::velox::exec::test {
+using namespace facebook::velox::common::testutil;
 
 std::ostream& operator<<(
     std::ostream& out,
@@ -70,6 +78,14 @@ VectorFuzzer::Options makeVectorFuzzerOptions() {
   return options;
 }
 
+template <typename T>
+void removeFromVector(std::vector<T>& vec, const T& value) {
+  auto it = std::find(vec.begin(), vec.end(), value);
+  if (it != vec.end()) {
+    vec.erase(it);
+  }
+}
+
 bool hasUnsupportedMapKey(const TypePtr& type) {
   switch (type->kind()) {
     case TypeKind::MAP: {
@@ -172,6 +188,43 @@ TableEvolutionFuzzer::parseFileFormats(std::string input) {
 
 namespace {
 
+// Helper function to randomly select aggregates from available columns
+// without replacement. Returns a list of aggregate expressions.
+void generateAggregatesForColumns(
+    const std::vector<int>& availableColumns,
+    const std::vector<std::string>& supportedAggFuncs,
+    const RowTypePtr& schema,
+    FuzzerGenerator& rng,
+    std::vector<std::string>& aggregates) {
+  if (availableColumns.empty()) {
+    return;
+  }
+
+  int numAggregates = std::min(
+      static_cast<int>(availableColumns.size()),
+      std::min(
+          static_cast<int>(5),
+          static_cast<int>(
+              folly::Random::rand32(1, availableColumns.size() + 1, rng))));
+
+  std::unordered_set<int> selectedIndices;
+  for (int i = 0; i < numAggregates; ++i) {
+    if (folly::Random::oneIn(2, rng)) {
+      int randomIdx;
+      do {
+        randomIdx = folly::Random::rand32(availableColumns.size(), rng);
+      } while (selectedIndices.count(randomIdx) > 0);
+      selectedIndices.insert(randomIdx);
+
+      int colIdx = availableColumns[randomIdx];
+      std::string aggFunc = supportedAggFuncs[folly::Random::rand32(
+          supportedAggFuncs.size(), rng)];
+      aggregates.push_back(
+          fmt::format("{}({})", aggFunc, schema->nameOf(colIdx)));
+    }
+  }
+}
+
 std::vector<std::vector<RowVectorPtr>> runTaskCursors(
     const std::vector<std::shared_ptr<TaskCursor>>& cursors,
     folly::Executor& executor) {
@@ -218,9 +271,9 @@ std::vector<std::vector<RowVectorPtr>> runTaskCursors(
     });
   }
   std::vector<std::vector<RowVectorPtr>> results;
-  constexpr std::chrono::seconds kTaskTimeout(10);
+  results.reserve(futures.size());
   for (auto& future : futures) {
-    results.push_back(std::move(future).get(kTaskTimeout));
+    results.push_back(std::move(future).get());
   }
   return results;
 }
@@ -243,7 +296,7 @@ void buildScanSplitFromTableWriteResult(
   auto* fragments =
       writeResult[0]->childAt(1)->asChecked<SimpleVector<StringView>>();
   for (int i = 1; i < writeResult[0]->size(); ++i) {
-    auto fragment = folly::parseJson(fragments->valueAt(i));
+    auto fragment = folly::parseJson(std::string_view(fragments->valueAt(i)));
     auto fileName = fragment["fileWriteInfos"][0]["writeFileName"].asString();
     auto hiveSplit = std::make_shared<connector::hive::HiveConnectorSplit>(
         TableEvolutionFuzzer::connectorId(),
@@ -268,7 +321,7 @@ void buildScanSplitFromTableWriteResult(
       for (auto bucketColumnIndex : bucketColumnIndices) {
         auto handle = std::make_unique<connector::hive::HiveColumnHandle>(
             tableSchema->nameOf(bucketColumnIndex),
-            connector::hive::HiveColumnHandle::ColumnType::kRegular,
+            connector::hive::FileColumnHandle::ColumnType::kRegular,
             tableSchema->childAt(bucketColumnIndex),
             tableSchema->childAt(bucketColumnIndex));
         bucketConversion.bucketColumnHandles.push_back(std::move(handle));
@@ -392,6 +445,102 @@ fuzzer::ExpressionFuzzer::FuzzedExpressionData generateRemainingFilters(
   return expressionFuzzer.fuzzExpressions(1);
 }
 
+// Generate random aggregation configuration for pushdown testing.
+// Only generates aggregations that are eligible for pushdown:
+// - Supported aggregate functions: min, max, bool_and, bool_or
+// - Each column can only be used by at most one aggregate
+// - Grouping keys are optional (can be empty for global aggregation)
+// - Columns with filters (subfield or remaining) are excluded to enable
+// pushdown
+std::optional<AggregationConfig> generateAggregationConfig(
+    const RowTypePtr& schema,
+    FuzzerGenerator& rng,
+    const std::unordered_set<std::string>& filteredColumns) {
+  // List of aggregate functions that support pushdown
+  // Note: Excluding 'sum' to avoid integer overflow in fuzzer with random data
+  static const std::vector<std::string> supportedNumericAggs = {"min", "max"};
+  static const std::vector<std::string> supportedBooleanAggs = {
+      "bool_and", "bool_or"};
+  static const std::vector<std::string> supportedIntegerAggs = {
+      "bitwise_and_agg", "bitwise_or_agg", "bitwise_xor_agg"};
+
+  // Randomly decide number of grouping keys (0 to 2)
+  int numGroupingKeys = folly::Random::rand32(3, rng);
+  std::vector<std::string> groupingKeys;
+  std::unordered_set<int> usedColumnIndices;
+
+  // Select random columns for grouping keys
+  for (int i = 0; i < numGroupingKeys && i < schema->size(); ++i) {
+    int colIdx = folly::Random::rand32(schema->size(), rng);
+    if (usedColumnIndices.count(colIdx) == 0) {
+      groupingKeys.push_back(schema->nameOf(colIdx));
+      usedColumnIndices.insert(colIdx);
+    }
+  }
+
+  // Generate aggregates on remaining columns
+  // For aggregation pushdown to work, each column should only be used once
+  // and columns with filters should be excluded
+  std::vector<std::string> aggregates;
+  std::vector<int> availableNumericColumns;
+  std::vector<int> availableIntegerColumns;
+  std::vector<int> availableBooleanColumns;
+  for (int i = 0; i < schema->size(); ++i) {
+    if (usedColumnIndices.count(i) == 0) {
+      auto columnName = schema->nameOf(i);
+      // Skip columns that have filters (subfield or remaining)
+      if (filteredColumns.count(columnName) > 0) {
+        continue;
+      }
+
+      auto type = schema->childAt(i);
+      // Integer types: randomly choose between min/max or bitwise aggregations
+      // Note: Exclude DATE/Interval type as it doesn't support bitwise
+      // aggregations
+      if ((type->isInteger() || type->isBigint() || type->isSmallint() ||
+           type->isTinyint()) &&
+          !type->isDate() && !type->isIntervalDayTime() &&
+          !type->isIntervalYearMonth()) {
+        if (folly::Random::oneIn(2, rng)) {
+          availableIntegerColumns.push_back(i);
+        } else {
+          availableNumericColumns.push_back(i);
+        }
+      }
+      // Float types support min/max only
+      else if ((type->isReal() || type->isDouble()) && !type->isDecimal()) {
+        availableNumericColumns.push_back(i);
+      }
+      // Boolean types support bool_and/bool_or
+      else if (type->isBoolean()) {
+        availableBooleanColumns.push_back(i);
+      }
+    }
+  }
+
+  // Need at least one column to aggregate
+  if (availableNumericColumns.empty() && availableBooleanColumns.empty() &&
+      availableIntegerColumns.empty()) {
+    return std::nullopt;
+  }
+
+  // Randomly pick columns for aggregates without replacement
+  generateAggregatesForColumns(
+      availableNumericColumns, supportedNumericAggs, schema, rng, aggregates);
+  generateAggregatesForColumns(
+      availableBooleanColumns, supportedBooleanAggs, schema, rng, aggregates);
+  generateAggregatesForColumns(
+      availableIntegerColumns, supportedIntegerAggs, schema, rng, aggregates);
+
+  if (aggregates.empty()) {
+    return std::nullopt;
+  }
+
+  return AggregationConfig{
+      .groupingKeys = std::move(groupingKeys),
+      .aggregates = std::move(aggregates)};
+}
+
 } // namespace
 
 VectorPtr TableEvolutionFuzzer::liftToType(
@@ -484,8 +633,9 @@ VectorPtr TableEvolutionFuzzer::liftToType(
         if (i < children.size()) {
           children[i] = liftToType(children[i], childType);
         } else {
-          children.push_back(BaseVector::createNullConstant(
-              childType, row->size(), config_.pool));
+          children.push_back(
+              BaseVector::createNullConstant(
+                  childType, row->size(), config_.pool));
         }
       }
       return std::make_shared<RowVector>(
@@ -559,12 +709,17 @@ void TableEvolutionFuzzer::run() {
       2 * config_.evolutionCount - 1);
   RowVectorPtr finalExpectedData;
 
+  folly::F14FastMap<int, folly::F14FastSet<std::string>> globalMapColumnKeys;
+  std::vector<int> globallyConsistentColumnIndexVector;
+
   createWriteTasks(
       testSetups,
       bucketColumnIndices,
       tableOutputRootDir->getPath(),
       writeTasks,
-      finalExpectedData);
+      finalExpectedData,
+      globalMapColumnKeys,
+      globallyConsistentColumnIndexVector);
 
   auto executor = folly::getGlobalCPUExecutor();
   auto writeResults = runTaskCursors(writeTasks, *executor);
@@ -584,17 +739,17 @@ void TableEvolutionFuzzer::run() {
       selectedBucket,
       finalExpectedData);
 
-  // Step 5: Setup scan tasks with filters
+  // Step 5: Setup scan tasks with filters and optional aggregation pushdown
   auto rowType = testSetups.back().schema;
-  PushdownConfig pushownConfig;
+  PushdownConfig pushdownConfig;
 
   // Generate subfield filters first
-  pushownConfig.subfieldFiltersMap =
+  pushdownConfig.subfieldFiltersMap =
       generateSubfieldFilters(rowType, finalExpectedData);
 
   // Extract field names used by subfield filters to avoid conflicts
   std::unordered_set<std::string> subfieldFilteredFields;
-  for (const auto& [subfield, filter] : pushownConfig.subfieldFiltersMap) {
+  for (const auto& [subfield, filter] : pushdownConfig.subfieldFiltersMap) {
     auto fieldName = subfield.toString();
     VLOG(1) << "Raw subfield: " << fieldName << ' ' << filter->toString();
     // Extract the root field name (before any nested access)
@@ -613,15 +768,63 @@ void TableEvolutionFuzzer::run() {
     applyRemainingFilters(
         generatedRemainingFilters,
         columnNameMapping,
-        pushownConfig,
+        pushdownConfig,
         subfieldFilteredFields);
   }
 
+  // Collect all filtered columns (both subfield and remaining filters)
+  std::unordered_set<std::string> allFilteredColumns = subfieldFilteredFields;
+
+  // Extract columns from remaining filter if present
+  if (!pushdownConfig.remainingFilter.empty()) {
+    for (const auto& name : rowType->names()) {
+      // Check if the column name appears in the remaining filter
+      if (pushdownConfig.remainingFilter.find(name) != std::string::npos) {
+        allFilteredColumns.insert(name);
+      }
+    }
+  }
+
+  // Enable aggregation testing
+  std::optional<AggregationConfig> aggConfig;
+  bool shouldTestAggregation =
+      folly::Random::oneIn(FLAGS_aggregation_pushdown_frequency, rng_);
+  if (shouldTestAggregation) {
+    aggConfig = generateAggregationConfig(rowType, rng_, allFilteredColumns);
+    if (aggConfig.has_value()) {
+      VLOG(1) << "Testing aggregation pushdown with grouping keys: ["
+              << folly::join(", ", aggConfig->groupingKeys)
+              << "] and aggregates: ["
+              << folly::join(", ", aggConfig->aggregates) << "]";
+    } else {
+      VLOG(1) << "Could not generate valid aggregation configuration";
+      aggConfig = std::nullopt;
+    }
+  }
+
   std::vector<std::shared_ptr<TaskCursor>> scanTasks(2);
-  scanTasks[0] =
-      makeScanTask(rowType, std::move(actualSplits), pushownConfig, false);
-  scanTasks[1] =
-      makeScanTask(rowType, std::move(expectedSplits), pushownConfig, true);
+  // actual: TableScan -> Aggregation (allows pushdown)
+  pushdownConfig.aggregationConfig = aggConfig;
+  scanTasks[0] = makeScanTask(
+      rowType,
+      std::move(actualSplits),
+      pushdownConfig,
+      false,
+      false, // insertProjectToBlockPushdown
+      globalMapColumnKeys,
+      globallyConsistentColumnIndexVector);
+
+  // expected: TableScan -> Project -> Aggregation (blocks pushdown)
+  // Insert a Project node to prevent aggregation pushdown
+  pushdownConfig.aggregationConfig = aggConfig;
+  scanTasks[1] = makeScanTask(
+      rowType,
+      std::move(expectedSplits),
+      pushdownConfig,
+      true,
+      true, // insertProjectToBlockPushdown
+      globalMapColumnKeys,
+      globallyConsistentColumnIndexVector);
 
   ScopedOOMInjector oomInjectorReadPath(
       [this]() -> bool { return folly::Random::oneIn(10, rng_); },
@@ -799,7 +1002,9 @@ std::unique_ptr<TaskCursor> TableEvolutionFuzzer::makeWriteTask(
     const std::string& outputDir,
     const std::vector<column_index_t>& bucketColumnIndices,
     FuzzerGenerator& rng,
-    bool enableFlatMap) {
+    bool enableFlatMap,
+    folly::F14FastMap<int, folly::F14FastSet<std::string>>& globalMapColumnKeys,
+    std::vector<int>& globallyCompatibleFlatmapColumns) {
   auto builder = PlanBuilder().values({data});
 
   // Create serdeParameters using proper dwrf::Config for flatmap configuration
@@ -813,6 +1018,7 @@ std::unique_ptr<TaskCursor> TableEvolutionFuzzer::makeWriteTask(
       if (setup.schema->childAt(i)->isMap()) {
         // Check if this specific map column has any empty elements
         if (hasEmptyElement(data, i)) {
+          removeFromVector(globallyCompatibleFlatmapColumns, i);
           continue;
         }
 
@@ -822,7 +1028,76 @@ std::unique_ptr<TaskCursor> TableEvolutionFuzzer::makeWriteTask(
             supportedMapColumnIndices.push_back(static_cast<uint32_t>(i));
             VLOG(1) << "Write column " << setup.schema->nameOf(i)
                     << " as flatmap";
+
+            // Extract actual keys from the map data and collect directly into
+            // global set
+            SelectivityVector allRows(data->childAt(i)->size());
+            DecodedVector decodedMap(*data->childAt(i), allRows);
+            auto* mapVector = decodedMap.base()->asChecked<MapVector>();
+            if (mapVector->size() > 0) {
+              auto keys = mapVector->mapKeys();
+
+              if (keys) {
+                // Collect keys directly into the global set
+                auto& uniqueKeys = globalMapColumnKeys[static_cast<int>(i)];
+
+                // Iterate through the decoded rows, not the raw mapVector
+                // indices
+                for (vector_size_t row = 0; row < data->childAt(i)->size();
+                     ++row) {
+                  auto decodedIndex = decodedMap.index(row);
+                  if (!decodedMap.isNullAt(row) &&
+                      !mapVector->isNullAt(decodedIndex)) {
+                    // Get the map entry for this decoded row
+                    auto mapOffset = mapVector->offsetAt(decodedIndex);
+                    auto mapSize = mapVector->sizeAt(decodedIndex);
+
+                    // Process all keys in this map entry
+                    for (vector_size_t keyIdx = 0; keyIdx < mapSize; ++keyIdx) {
+                      auto keyPosition = mapOffset + keyIdx;
+                      if (!keys->isNullAt(keyPosition)) {
+                        std::string keyStr;
+                        if (keys->type()->isVarchar() ||
+                            keys->type()->isVarbinary()) {
+                          auto* keyVector = keys->asFlatVector<StringView>();
+                          auto keyView = keyVector->valueAt(keyPosition);
+                          keyStr = std::string(keyView);
+                        } else if (keys->type()->isInteger()) {
+                          auto* keyVector = keys->asFlatVector<int32_t>();
+                          auto keyVal = keyVector->valueAt(keyPosition);
+                          keyStr = std::to_string(keyVal);
+                        } else if (keys->type()->isBigint()) {
+                          auto* keyVector = keys->asFlatVector<int64_t>();
+                          auto keyVal = keyVector->valueAt(keyPosition);
+                          keyStr = std::to_string(keyVal);
+                        } else if (keys->type()->isSmallint()) {
+                          auto* keyVector = keys->asFlatVector<int16_t>();
+                          auto keyVal = keyVector->valueAt(keyPosition);
+                          keyStr = std::to_string(keyVal);
+                        } else if (keys->type()->isTinyint()) {
+                          auto* keyVector = keys->asFlatVector<int8_t>();
+                          auto keyVal = keyVector->valueAt(keyPosition);
+                          keyStr = std::to_string(keyVal);
+                        } else {
+                          // This should not be reached since
+                          // hasUnsupportedMapKey filters out unsupported types
+                          VELOX_UNREACHABLE(
+                              "Unsupported map key type: {}",
+                              keys->type()->toString());
+                        }
+                        uniqueKeys.insert(keyStr);
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          } else {
+            // Remove this column from globallyCompatibleFlatmapColumns
+            removeFromVector(globallyCompatibleFlatmapColumns, i);
           }
+        } else {
+          removeFromVector(globallyCompatibleFlatmapColumns, i);
         }
       }
     }
@@ -906,22 +1181,101 @@ VectorPtr TableEvolutionFuzzer::liftToPrimitiveType(
       std::vector<BufferPtr>({}));
 }
 
+RowTypePtr TableEvolutionFuzzer::buildFlatmapAsStructSchema(
+    const RowTypePtr& tableSchema,
+    const folly::F14FastMap<int, folly::F14FastSet<std::string>>&
+        globalMapColumnKeys,
+    const std::vector<int>& globallyCompatibleFlatmapColumns) {
+  if (globallyCompatibleFlatmapColumns.empty()) {
+    return tableSchema;
+  }
+
+  VLOG(1) << "Setting up struct reading for "
+          << globallyCompatibleFlatmapColumns.size()
+          << " flatmap columns with real keys";
+
+  auto names = tableSchema->names();
+  auto types = tableSchema->children();
+
+  // Filter globalMapColumnKeys to only include globally compatible columns
+  std::unordered_map<int, folly::F14FastSet<std::string>> filteredMapColumnKeys;
+  for (int mapColumnIndex : globallyCompatibleFlatmapColumns) {
+    if (globalMapColumnKeys.find(mapColumnIndex) != globalMapColumnKeys.end()) {
+      // Add 50% probability to include this column in filteredMapColumnKeys
+      if (folly::Random::oneIn(2, rng_)) {
+        filteredMapColumnKeys[mapColumnIndex] =
+            globalMapColumnKeys.at(mapColumnIndex);
+      }
+    }
+  }
+
+  // Use the filteredMapColumnKeys for struct reading
+  for (const auto& [mapColumnIndex, keysSet] : filteredMapColumnKeys) {
+    // Convert map type to struct type for struct reading
+    auto finalMapType = types[mapColumnIndex]->asMap();
+    auto finalValueType = finalMapType.valueType();
+    // Convert F14FastSet to vector for ROW constructor
+    std::vector<std::string> keys(keysSet.begin(), keysSet.end());
+    // Construct struct schema with real keys from write time + final value
+    // type
+    std::vector<TypePtr> finalStructFieldTypes(keys.size(), finalValueType);
+    auto finalStructSchema = ROW(keys, finalStructFieldTypes);
+
+    // Replace the map type with struct type in the schema
+    types[mapColumnIndex] = finalStructSchema;
+  }
+
+  // Build new schema using struct reading for flatmap columns
+  return ROW(names, types);
+}
+
 std::unique_ptr<TaskCursor> TableEvolutionFuzzer::makeScanTask(
     const RowTypePtr& tableSchema,
     std::vector<Split> splits,
     const PushdownConfig& pushdownConfig,
-    bool useFiltersAsNode) {
+    bool useFiltersAsNode,
+    bool insertProjectToBlockPushdown,
+    const folly::F14FastMap<int, folly::F14FastSet<std::string>>&
+        globalMapColumnKeys,
+    const std::vector<int>& globallyCompatibleFlatmapColumns) {
+  // Build schema for flatmap as struct reading
+  RowTypePtr newSchemaUsingStructReadingFlatMap = buildFlatmapAsStructSchema(
+      tableSchema, globalMapColumnKeys, globallyCompatibleFlatmapColumns);
+
   CursorParameters params;
   params.serialExecution = true;
-  // TODO: Mix in filter and aggregate pushdowns.
-  params.planNode = PlanBuilder()
-                        .filtersAsNode(useFiltersAsNode)
-                        .tableScanWithPushDown(
-                            tableSchema,
-                            /*pushdownConfig=*/pushdownConfig,
-                            tableSchema,
-                            {})
-                        .planNode();
+
+  auto builder = PlanBuilder()
+                     .filtersAsNode(useFiltersAsNode)
+                     .tableScanWithPushDown(
+                         newSchemaUsingStructReadingFlatMap, // Use struct
+                                                             // schema for
+                                                             // flatmap reading
+                         /*pushdownConfig=*/pushdownConfig,
+                         tableSchema, // Original schema as dataColumns
+                         {});
+
+  // If insertProjectToBlockPushdown is set, insert an identity Project node
+  // to prevent Driver::mayPushdownAggregation() from allowing pushdown
+  if (insertProjectToBlockPushdown &&
+      pushdownConfig.aggregationConfig.has_value()) {
+    // Create identity projection: simply pass through all columns
+    std::vector<std::string> projectExprs;
+    for (const auto& name : newSchemaUsingStructReadingFlatMap->names()) {
+      projectExprs.push_back(name);
+    }
+    builder.project(projectExprs);
+  }
+
+  // Add aggregation if enabled in pushdown config
+  if (pushdownConfig.aggregationConfig.has_value()) {
+    builder.singleAggregation(
+        pushdownConfig.aggregationConfig->groupingKeys,
+        pushdownConfig.aggregationConfig->aggregates);
+  }
+
+  params.planNode = builder.planNode();
+
   auto cursor = TaskCursor::create(params);
   for (auto& split : splits) {
     cursor->task()->addSplit("0", std::move(split));
@@ -986,16 +1340,41 @@ void TableEvolutionFuzzer::createWriteTasks(
     const std::vector<column_index_t>& bucketColumnIndices,
     const std::string& tableOutputRootDirPath,
     std::vector<std::shared_ptr<TaskCursor>>& writeTasks,
-    RowVectorPtr& finalExpectedData) {
+    RowVectorPtr& finalExpectedData,
+    folly::F14FastMap<int, folly::F14FastSet<std::string>>& globalMapColumnKeys,
+    std::vector<int>& globallyConsistentColumnIndexVector) {
+  // Initialize globallyConsistentColumnIndexVector with all map column indices
+  // from the first schema, then filter out incompatible ones during processing
+  if (hasMapColumns(testSetups[0].schema)) {
+    for (int j = 0; j < testSetups[0].schema->size(); ++j) {
+      if (testSetups[0].schema->childAt(j)->isMap() &&
+          !hasUnsupportedMapKey(testSetups[0].schema->childAt(j))) {
+        globallyConsistentColumnIndexVector.push_back(j);
+      }
+    }
+  }
+
+  // Generate data and create write tasks in a single loop
   for (int i = 0; i < config_.evolutionCount; ++i) {
+    // Generate fresh data for each evolution step independently
     auto data = vectorFuzzer_.fuzzRow(testSetups[i].schema, kVectorSize, false);
     for (auto& child : data->children()) {
       BaseVector::flattenVector(child);
     }
+
     auto actualDir = fmt::format("{}/actual_{}", tableOutputRootDirPath, i);
     VELOX_CHECK(std::filesystem::create_directory(actualDir));
+
+    // Pass globally consistent columns to restrict flatmap usage
     writeTasks[2 * i] = makeWriteTask(
-        testSetups[i], data, actualDir, bucketColumnIndices, rng_, true);
+        testSetups[i],
+        data,
+        actualDir,
+        bucketColumnIndices,
+        rng_,
+        true,
+        globalMapColumnKeys,
+        globallyConsistentColumnIndexVector);
 
     if (i == config_.evolutionCount - 1) {
       finalExpectedData = std::move(data);
@@ -1012,7 +1391,9 @@ void TableEvolutionFuzzer::createWriteTasks(
         expectedDir,
         bucketColumnIndices,
         rng_,
-        true);
+        true,
+        globalMapColumnKeys,
+        globallyConsistentColumnIndexVector);
   }
 }
 
diff --git a/velox/exec/tests/TableEvolutionFuzzer.h b/velox/exec/tests/TableEvolutionFuzzer.h
index f00a25923a2..80f0ff95538 100644
--- a/velox/exec/tests/TableEvolutionFuzzer.h
+++ b/velox/exec/tests/TableEvolutionFuzzer.h
@@ -105,7 +105,10 @@ class TableEvolutionFuzzer {
       const std::string& outputDir,
       const std::vector<column_index_t>& bucketColumnIndices,
       FuzzerGenerator& rng,
-      bool enableFlatMap);
+      bool enableFlatMap,
+      folly::F14FastMap<int, folly::F14FastSet<std::string>>&
+          globalMapColumnKeys,
+      std::vector<int>& globallyCompatibleFlatmapColumns);
 
   template <typename To, typename From>
   VectorPtr liftToPrimitiveType(
@@ -118,7 +121,19 @@ class TableEvolutionFuzzer {
       const RowTypePtr& tableSchema,
       std::vector<Split> splits,
       const PushdownConfig& pushdownConfig,
-      bool useFiltersAsNode);
+      bool useFiltersAsNode,
+      bool insertProjectToBlockPushdown,
+      const folly::F14FastMap<int, folly::F14FastSet<std::string>>&
+          globalMapColumnKeys = {},
+      const std::vector<int>& globallyCompatibleFlatmapColumns = {});
+
+  /// Builds schema for flatmap as struct reading by converting selected map
+  /// columns to struct types.
+  RowTypePtr buildFlatmapAsStructSchema(
+      const RowTypePtr& tableSchema,
+      const folly::F14FastMap<int, folly::F14FastSet<std::string>>&
+          globalMapColumnKeys,
+      const std::vector<int>& globallyCompatibleFlatmapColumns);
 
   /// Randomly generates bucket column indices for partitioning data.
   /// Returns a vector of column indices that will be used for bucketing,
@@ -134,7 +149,10 @@ class TableEvolutionFuzzer {
       const std::vector<column_index_t>& bucketColumnIndices,
       const std::string& tableOutputRootDirPath,
       std::vector<std::shared_ptr<TaskCursor>>& writeTasks,
-      RowVectorPtr& finalExpectedData);
+      RowVectorPtr& finalExpectedData,
+      folly::F14FastMap<int, folly::F14FastSet<std::string>>&
+          globalMapColumnKeys,
+      std::vector<int>& globallyConsistentColumnIndexVector);
 
   /// Creates scan splits from write results.
   /// Converts the output of write tasks into scan splits that can be used
diff --git a/velox/exec/tests/TableEvolutionFuzzerTest.cpp b/velox/exec/tests/TableEvolutionFuzzerTest.cpp
index 45039496844..41fa19997af 100644
--- a/velox/exec/tests/TableEvolutionFuzzerTest.cpp
+++ b/velox/exec/tests/TableEvolutionFuzzerTest.cpp
@@ -15,9 +15,12 @@
  */
 
 #include "velox/exec/tests/TableEvolutionFuzzer.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/hive/HiveConnector.h"
+#include "velox/dwio/common/FileSink.h"
 #include "velox/dwio/dwrf/RegisterDwrfReader.h"
 #include "velox/dwio/dwrf/RegisterDwrfWriter.h"
+#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 
 #include <folly/init/Init.h>
@@ -40,9 +43,11 @@ void registerFactories(folly::Executor* ioExecutor) {
   auto hiveConnector = factory.newConnector(
       TableEvolutionFuzzer::connectorId(),
       std::make_shared<config::ConfigBase>(
-          std::unordered_map<std::string, std::string>()),
+          std::unordered_map<std::string, std::string>{
+              {connector::hive::HiveConfig::kEnableFileHandleCache, "false"}}),
       ioExecutor);
-  connector::registerConnector(hiveConnector);
+  connector::ConnectorRegistry::global().insert(
+      hiveConnector->connectorId(), hiveConnector);
   dwio::common::registerFileSinks();
   dwrf::registerDwrfReaderFactory();
   dwrf::registerDwrfWriterFactory();
@@ -84,6 +89,7 @@ int main(int argc, char** argv) {
   auto ioExecutor = folly::getGlobalIOExecutor();
   facebook::velox::exec::test::registerFactories(ioExecutor.get());
   facebook::velox::functions::prestosql::registerAllScalarFunctions();
+  facebook::velox::aggregate::prestosql::registerAllAggregateFunctions();
   facebook::velox::parse::registerTypeResolver();
   return RUN_ALL_TESTS();
 }
diff --git a/velox/exec/tests/TableScanTest.cpp b/velox/exec/tests/TableScanTest.cpp
index 2bc53f8fcf6..4e580276971 100644
--- a/velox/exec/tests/TableScanTest.cpp
+++ b/velox/exec/tests/TableScanTest.cpp
@@ -17,8 +17,8 @@
 #include <shared_mutex>
 
 #include <fmt/ranges.h>
-#include <folly/experimental/EventCount.h>
 #include <folly/synchronization/Baton.h>
+#include <folly/synchronization/EventCount.h>
 #include <folly/synchronization/Latch.h>
 #include <filesystem>
 
@@ -30,12 +30,16 @@
 #include "velox/common/file/tests/FaultyFile.h"
 #include "velox/common/file/tests/FaultyFileSystem.h"
 #include "velox/common/memory/MemoryArbitrator.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/common/testutil/TestValue.h"
+#include "velox/connectors/ConnectorRegistry.h"
+#include "velox/connectors/hive/ExtractionUtils.h"
 #include "velox/connectors/hive/HiveConfig.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/connectors/hive/HiveDataSource.h"
 #include "velox/connectors/hive/HivePartitionFunction.h"
 #include "velox/dwio/common/tests/utils/DataFiles.h"
+#include "velox/dwio/orc/reader/OrcReader.h"
 #include "velox/exec/Cursor.h"
 #include "velox/exec/Exchange.h"
 #include "velox/exec/PlanNodeStats.h"
@@ -44,8 +48,8 @@
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/exec/tests/utils/TableScanTestBase.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/expression/ExprToSubfieldFilter.h"
+#include "velox/functions/lib/IsNull.h"
 #include "velox/type/Timestamp.h"
 #include "velox/type/Type.h"
 #include "velox/type/tests/SubfieldFiltersBuilder.h"
@@ -61,6 +65,7 @@ using namespace facebook::velox::tests::utils;
 DECLARE_int32(cache_prefetch_min_pct);
 
 namespace facebook::velox::exec {
+using namespace facebook::velox::common::testutil;
 namespace {
 void verifyCacheStats(
     const FileHandleCacheStats& cacheStats,
@@ -72,7 +77,12 @@ void verifyCacheStats(
   EXPECT_EQ(cacheStats.numLookups, numLookups);
 }
 
-class TableScanTest : public TableScanTestBase {};
+class TableScanTest : public TableScanTestBase {
+  void SetUp() override {
+    TableScanTestBase::SetUp();
+    orc::registerOrcReaderFactory();
+  }
+};
 
 TEST_F(TableScanTest, allColumns) {
   auto vectors = makeVectors(10, 1'000);
@@ -112,6 +122,13 @@ TEST_F(TableScanTest, directBufferInputRawInputBytes) {
                   .endTableScan()
                   .planNode();
 
+  // Disable file preloading to ensure individual stream reads are tracked
+  // for overreadBytes verification.
+  resetHiveConnector(
+      std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>{
+              {connector::hive::HiveConfig::kFilePreloadThreshold, "0"}}));
+
   std::unordered_map<std::string, std::string> config;
   std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>
       connectorConfigs = {};
@@ -137,7 +154,8 @@ TEST_F(TableScanTest, directBufferInputRawInputBytes) {
   auto overreadBytes = getTableScanRuntimeStats(task).at("overreadBytes").sum;
   ASSERT_GE(rawInputBytes, 500);
   ASSERT_EQ(overreadBytes, 13);
-  ASSERT_EQ(
+  // Without preloading, storageReadBytes is the sum of individual stream reads.
+  ASSERT_LE(
       getTableScanRuntimeStats(task).at("storageReadBytes").sum,
       rawInputBytes + overreadBytes);
   ASSERT_GT(getTableScanRuntimeStats(task)["totalScanTime"].sum, 0);
@@ -181,9 +199,9 @@ DEBUG_ONLY_TEST_F(TableScanTest, pendingCoalescedIoWhenTaskFailed) {
   // on-demand load.
   const std::string errMsg{"injectedError"};
   SCOPED_TESTVALUE_SET(
-      "facebook::velox::connector::hive::HiveDataSource::next",
-      std::function<void(connector::hive::HiveDataSource*)>(
-          [&](connector::hive::HiveDataSource* /*unused*/) {
+      "facebook::velox::connector::hive::FileDataSource::next",
+      std::function<void(connector::hive::FileDataSource*)>(
+          [&](connector::hive::FileDataSource* /*unused*/) {
             VELOX_FAIL(errMsg);
           }));
   SCOPED_TESTVALUE_SET(
@@ -207,7 +225,7 @@ DEBUG_ONLY_TEST_F(TableScanTest, pendingCoalescedIoWhenTaskFailed) {
 TEST_F(TableScanTest, connectorStats) {
   auto hiveConnector =
       std::dynamic_pointer_cast<connector::hive::HiveConnector>(
-          connector::getConnector(kHiveConnectorId));
+          connector::ConnectorRegistry::tryGet(kHiveConnectorId));
   EXPECT_NE(nullptr, hiveConnector);
   verifyCacheStats(hiveConnector->fileHandleCacheStats(), 0, 0, 0);
 
@@ -426,6 +444,7 @@ TEST_F(TableScanTest, timestampPrecisionDefaultMillisecond) {
       makeFlatVector<Timestamp>(
           1, [](auto) { return Timestamp(1, 1'000'000); }),
   });
+  split = makeHiveConnectorSplit(file->getPath());
   AssertQueryBuilder(plan).split(split).assertResults(expected);
 }
 
@@ -503,6 +522,30 @@ DEBUG_ONLY_TEST_F(TableScanTest, timeLimitInGetOutput) {
   EXPECT_GE(numBailed, 12);
 }
 
+TEST_F(TableScanTest, outputBatchRowsOverride) {
+  auto vectors = makeVectors(1, 500);
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors);
+
+  constexpr uint32_t kBatchRowsOverride{100};
+  auto plan = tableScanNode();
+  auto batches = AssertQueryBuilder(duckDbQueryRunner_)
+                     .plan(plan)
+                     .splits(makeHiveConnectorSplits({filePath}))
+                     .config(
+                         QueryConfig::kTableScanOutputBatchRowsOverride,
+                         folly::to<std::string>(kBatchRowsOverride))
+                     .copyResultBatches(pool_.get());
+
+  ASSERT_FALSE(batches.empty());
+  for (auto i = 0; i + 1 < batches.size(); ++i) {
+    EXPECT_EQ(batches[i]->size(), kBatchRowsOverride);
+  }
+  EXPECT_LE(batches.back()->size(), kBatchRowsOverride);
+
+  assertEqualResults(vectors, batches);
+}
+
 TEST_F(TableScanTest, subfieldPruningRowType) {
   // rowType: ROW
   // └── "e": ROW
@@ -521,7 +564,7 @@ TEST_F(TableScanTest, subfieldPruningRowType) {
   connector::ColumnHandleMap assignments;
   assignments["e"] = std::make_shared<HiveColumnHandle>(
       "e",
-      HiveColumnHandle::ColumnType::kRegular,
+      FileColumnHandle::ColumnType::kRegular,
       columnType,
       columnType,
       std::move(requiredSubfields));
@@ -577,7 +620,7 @@ TEST_F(TableScanTest, subfieldPruningRemainingFilterSubfieldsMissing) {
   connector::ColumnHandleMap assignments;
   assignments["e"] = std::make_shared<HiveColumnHandle>(
       "e",
-      HiveColumnHandle::ColumnType::kRegular,
+      FileColumnHandle::ColumnType::kRegular,
       columnType,
       columnType,
       std::move(requiredSubfields));
@@ -610,6 +653,7 @@ TEST_F(TableScanTest, subfieldPruningRemainingFilterSubfieldsMissing) {
            .assignments(assignments)
            .endTableScan()
            .planNode();
+  split = makeHiveConnectorSplit(filePath->getPath());
   result = AssertQueryBuilder(op).split(split).copyResults(pool());
   rows = result->as<RowVector>();
   e = rows->childAt(0)->as<RowVector>();
@@ -631,7 +675,7 @@ TEST_F(TableScanTest, subfieldPruningRemainingFilterRootFieldMissing) {
   writeToFile(filePath->getPath(), vectors);
   connector::ColumnHandleMap assignments;
   assignments["d"] = std::make_shared<HiveColumnHandle>(
-      "d", HiveColumnHandle::ColumnType::kRegular, BIGINT(), BIGINT());
+      "d", FileColumnHandle::ColumnType::kRegular, BIGINT(), BIGINT());
   auto op = PlanBuilder()
                 .startTableScan()
                 .outputType(ROW({{"d", BIGINT()}}))
@@ -673,7 +717,7 @@ TEST_F(TableScanTest, subfieldPruningRemainingFilterStruct) {
       SCOPED_TRACE(fmt::format("{} {}", outputColumn, filterColumn));
       connector::ColumnHandleMap assignments;
       assignments["d"] = std::make_shared<HiveColumnHandle>(
-          "d", HiveColumnHandle::ColumnType::kRegular, BIGINT(), BIGINT());
+          "d", FileColumnHandle::ColumnType::kRegular, BIGINT(), BIGINT());
       if (outputColumn > kNoOutput) {
         std::vector<common::Subfield> subfields;
         if (outputColumn == kSubfieldOnly) {
@@ -681,7 +725,7 @@ TEST_F(TableScanTest, subfieldPruningRemainingFilterStruct) {
         }
         assignments["c"] = std::make_shared<HiveColumnHandle>(
             "c",
-            HiveColumnHandle::ColumnType::kRegular,
+            FileColumnHandle::ColumnType::kRegular,
             structType,
             structType,
             std::move(subfields));
@@ -758,7 +802,7 @@ TEST_F(TableScanTest, subfieldPruningRemainingFilterMap) {
       SCOPED_TRACE(fmt::format("{} {}", outputColumn, filterColumn));
       connector::ColumnHandleMap assignments;
       assignments["a"] = std::make_shared<HiveColumnHandle>(
-          "a", HiveColumnHandle::ColumnType::kRegular, BIGINT(), BIGINT());
+          "a", FileColumnHandle::ColumnType::kRegular, BIGINT(), BIGINT());
       if (outputColumn > kNoOutput) {
         std::vector<common::Subfield> subfields;
         if (outputColumn == kSubfieldOnly) {
@@ -766,15 +810,14 @@ TEST_F(TableScanTest, subfieldPruningRemainingFilterMap) {
         }
         assignments["b"] = std::make_shared<HiveColumnHandle>(
             "b",
-            HiveColumnHandle::ColumnType::kRegular,
+            FileColumnHandle::ColumnType::kRegular,
             mapType,
             mapType,
             std::move(subfields));
       }
       std::string remainingFilter;
       if (filterColumn == kWholeColumn) {
-        remainingFilter =
-            "coalesce(b, cast(null AS MAP(BIGINT, BIGINT)))[0] == 0";
+        remainingFilter = "coalesce(b, map_concat(b, b))[0] == 0";
       } else {
         remainingFilter = "b[0] == 0";
       }
@@ -858,7 +901,7 @@ TEST_F(TableScanTest, subfieldPruningMapType) {
   connector::ColumnHandleMap assignments;
   assignments["c"] = std::make_shared<HiveColumnHandle>(
       "c",
-      HiveColumnHandle::ColumnType::kRegular,
+      FileColumnHandle::ColumnType::kRegular,
       mapType,
       mapType,
       std::move(requiredSubfields));
@@ -941,7 +984,7 @@ TEST_F(TableScanTest, subfieldPruningArrayType) {
   connector::ColumnHandleMap assignments;
   assignments["c"] = std::make_shared<HiveColumnHandle>(
       "c",
-      HiveColumnHandle::ColumnType::kRegular,
+      FileColumnHandle::ColumnType::kRegular,
       arrayType,
       arrayType,
       std::move(requiredSubfields));
@@ -1099,7 +1142,7 @@ TEST_F(TableScanTest, missingColumns) {
   common::SubfieldFilters filters;
   filters[common::Subfield("c1")] = lessThanOrEqualDouble(1050.0, true);
   auto tableHandle = std::make_shared<HiveTableHandle>(
-      kHiveConnectorId, "tmp", true, std::move(filters), nullptr, dataColumns);
+      kHiveConnectorId, "tmp", std::move(filters), nullptr, dataColumns);
   connector::ColumnHandleMap assignments;
   assignments["c0"] = regularColumn("c0", BIGINT());
   op = PlanBuilder(pool_.get())
@@ -1352,6 +1395,80 @@ TEST_F(TableScanTest, batchSize) {
   }
 }
 
+DEBUG_ONLY_TEST_F(TableScanTest, batchSizeFileEstimateFallback) {
+  const auto rowSize = 1024;
+  const auto columnSize = sizeof(int64_t);
+  const auto numColumns = 2 * rowSize / columnSize;
+  const auto numRowsSplit1 = 100;
+  const auto numRowsSplit2 = 2000;
+  const auto kDefaultBatchRows = 1024;
+
+  std::vector<std::string> names;
+  names.reserve(numColumns);
+  for (size_t i = 0; i < numColumns; i++) {
+    names.push_back(fmt::format("c{}", i));
+  }
+  auto rowType =
+      ROW(std::move(names), std::vector<TypePtr>(numColumns, BIGINT()));
+
+  auto vector1 = makeVectors(1, numRowsSplit1, rowType);
+  auto vector2 = makeVectors(1, numRowsSplit2, rowType);
+
+  auto filePath1 = TempFilePath::create();
+  auto filePath2 = TempFilePath::create();
+  writeToFile(filePath1->getPath(), vector1);
+  writeToFile(filePath2->getPath(), vector2);
+
+  std::vector<RowVectorPtr> allVectors;
+  allVectors.reserve(2);
+  allVectors.push_back(vector1[0]);
+  allVectors.push_back(vector2[0]);
+  createDuckDbTable(allVectors);
+
+  auto plan = PlanBuilder().tableScan(rowType).planNode();
+
+  std::atomic_int splitCount{0};
+  std::vector<int32_t> batchSizesUsed;
+  std::mutex mutex;
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::TableScan::getOutput::gotSplit",
+      std::function<void(const TableScan*)>([&](const TableScan* tableScan) {
+        ++splitCount;
+        std::lock_guard<std::mutex> lock(mutex);
+        batchSizesUsed.push_back(tableScan->testingReadBatchSize());
+      }));
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::connector::hive::FileDataSource::estimatedRowSize",
+      std::function<void(int64_t*)>([&](int64_t* estimatedRowSize) {
+        if (splitCount.load() >= 2) {
+          *estimatedRowSize = connector::DataSource::kUnknownRowSize;
+        }
+      }));
+
+  auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                  .plan(plan)
+                  .splits(makeHiveConnectorSplits({filePath1, filePath2}))
+                  .config(
+                      QueryConfig::kPreferredOutputBatchBytes,
+                      folly::to<std::string>(rowSize * 100))
+                  .config(
+                      QueryConfig::kPreferredOutputBatchRows,
+                      folly::to<std::string>(kDefaultBatchRows))
+                  .assertResults("SELECT * FROM tmp");
+
+  const auto opStats = task->taskStats().pipelineStats[0].operatorStats[0];
+
+  EXPECT_EQ(opStats.outputPositions, numRowsSplit1 + numRowsSplit2);
+  EXPECT_GE(splitCount.load(), 2);
+  ASSERT_GE(batchSizesUsed.size(), 2);
+
+  EXPECT_LT(batchSizesUsed[1], kDefaultBatchRows)
+      << "Second split should use the last known estimated row size, not default";
+  EXPECT_GT(opStats.outputVectors, 3);
+}
+
 // Test that adding the same split with the same sequence id does not cause
 // double read and the 2nd split is ignored.
 TEST_F(TableScanTest, sequentialSplitNoDoubleRead) {
@@ -1463,6 +1580,20 @@ TEST_F(TableScanTest, multipleSplits) {
   }
 }
 
+TEST_F(TableScanTest, preloadSplits) {
+  auto filePaths = makeFilePaths(10);
+  auto vectors = makeVectors(10, 10);
+  for (int32_t i = 0; i < vectors.size(); i++) {
+    writeToFile(filePaths[i]->getPath(), vectors[i]);
+  }
+  createDuckDbTable(vectors);
+
+  auto task = assertQuery(
+      tableScanNode(), filePaths, "SELECT * FROM tmp", /*numPrefetchSplit=*/10);
+  auto stats = getTableScanRuntimeStats(task);
+  ASSERT_EQ(stats.at("preloadedSplits").sum, 10);
+}
+
 TEST_F(TableScanTest, preloadingSplitClose) {
   auto filePaths = makeFilePaths(100);
   auto vectors = makeVectors(100, 100);
@@ -1590,8 +1721,7 @@ DEBUG_ONLY_TEST_F(TableScanTest, tableScanSplitsAndWeights) {
   auto leafTaskId = "local://leaf-0";
   auto leafPlan = PlanBuilder()
                       .values(vectors)
-                      .partitionedOutput(
-                          {}, 1, {"c0", "c1", "c2"}, VectorSerde::Kind::kPresto)
+                      .partitionedOutput({}, 1, {"c0", "c1", "c2"}, "Presto")
                       .planNode();
   std::unordered_map<std::string, std::string> config;
   auto queryCtx = core::QueryCtx::create(
@@ -1610,23 +1740,22 @@ DEBUG_ONLY_TEST_F(TableScanTest, tableScanSplitsAndWeights) {
   // Main task plan with table scan and remote exchange.
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   core::PlanNodeId scanNodeId, exchangeNodeId;
-  auto planNode =
-      PlanBuilder(planNodeIdGenerator, pool_.get())
-          .tableScan(rowType_)
-          .capturePlanNodeId(scanNodeId)
-          .project({"c0 AS t0", "c1 AS t1", "c2 AS t2"})
-          .hashJoin(
-              {"t0"},
-              {"u0"},
-              PlanBuilder(planNodeIdGenerator, pool_.get())
-                  .exchange(leafPlan->outputType(), VectorSerde::Kind::kPresto)
-                  .capturePlanNodeId(exchangeNodeId)
-                  .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
-                  .planNode(),
-              "",
-              {"t1"},
-              core::JoinType::kAnti)
-          .planNode();
+  auto planNode = PlanBuilder(planNodeIdGenerator, pool_.get())
+                      .tableScan(rowType_)
+                      .capturePlanNodeId(scanNodeId)
+                      .project({"c0 AS t0", "c1 AS t1", "c2 AS t2"})
+                      .hashJoin(
+                          {"t0"},
+                          {"u0"},
+                          PlanBuilder(planNodeIdGenerator, pool_.get())
+                              .exchange(leafPlan->outputType(), "Presto")
+                              .capturePlanNodeId(exchangeNodeId)
+                              .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
+                              .planNode(),
+                          "",
+                          {"t1"},
+                          core::JoinType::kAnti)
+                      .planNode();
 
   // Create task, cursor, start the task and supply the table scan splits.
   const int32_t numDrivers = 6;
@@ -1719,9 +1848,9 @@ TEST_F(TableScanTest, splitOffsetAndLength) {
 }
 
 TEST_F(TableScanTest, fileNotFound) {
-  auto split =
-      exec::test::HiveConnectorSplitBuilder("/path/to/nowhere.orc").build();
   auto assertMissingFile = [&](bool ignoreMissingFiles) {
+    auto split =
+        exec::test::HiveConnectorSplitBuilder("/path/to/nowhere.orc").build();
     AssertQueryBuilder(tableScanNode())
         .connectorSessionProperty(
             kHiveConnectorId,
@@ -1896,7 +2025,7 @@ TEST_F(TableScanTest, partitionedTableDateKey) {
         18506, std::numeric_limits<int64_t>::max(), false);
 
     auto tableHandle = std::make_shared<HiveTableHandle>(
-        "test-hive", "hive_table", true, std::move(filters), nullptr, nullptr);
+        "test-hive", "hive_table", std::move(filters), nullptr, nullptr);
     auto op = std::make_shared<TableScanNode>(
         "0",
         std::move(outputType),
@@ -1921,10 +2050,6 @@ TEST_F(TableScanTest, partitionedTableTimestampKey) {
   // Test partition value is null.
   testPartitionedTable(filePath->getPath(), partitionType, std::nullopt);
 
-  auto split = exec::test::HiveConnectorSplitBuilder(filePath->getPath())
-                   .partitionKey("pkey", partitionValue)
-                   .build();
-
   connector::ColumnHandleMap assignments = {
       {"pkey", partitionKey("pkey", TIMESTAMP())},
       {"c0", regularColumn("c0", BIGINT())},
@@ -1956,6 +2081,9 @@ TEST_F(TableScanTest, partitionedTableTimestampKey) {
             .planNode();
 
     auto expect = [&](bool asLocalTime) {
+      auto split = exec::test::HiveConnectorSplitBuilder(filePath->getPath())
+                       .partitionKey("pkey", partitionValue)
+                       .build();
       AssertQueryBuilder(plan, duckDbQueryRunner_)
           .connectorSessionProperty(
               kHiveConnectorId,
@@ -1963,8 +2091,10 @@ TEST_F(TableScanTest, partitionedTableTimestampKey) {
                   kReadTimestampPartitionValueAsLocalTimeSession,
               asLocalTime ? "true" : "false")
           .splits({split})
-          .assertResults(fmt::format(
-              "SELECT {}, * FROM tmp", asLocalTime ? tsValueAsLocal : tsValue));
+          .assertResults(
+              fmt::format(
+                  "SELECT {}, * FROM tmp",
+                  asLocalTime ? tsValueAsLocal : tsValue));
     };
 
     expect(true);
@@ -1983,6 +2113,9 @@ TEST_F(TableScanTest, partitionedTableTimestampKey) {
             .planNode();
 
     auto expect = [&](bool asLocalTime) {
+      auto split = exec::test::HiveConnectorSplitBuilder(filePath->getPath())
+                       .partitionKey("pkey", partitionValue)
+                       .build();
       AssertQueryBuilder(plan, duckDbQueryRunner_)
           .connectorSessionProperty(
               kHiveConnectorId,
@@ -1990,9 +2123,10 @@ TEST_F(TableScanTest, partitionedTableTimestampKey) {
                   kReadTimestampPartitionValueAsLocalTimeSession,
               asLocalTime ? "true" : "false")
           .splits({split})
-          .assertResults(fmt::format(
-              "SELECT c0, {}, c1 FROM tmp",
-              asLocalTime ? tsValueAsLocal : tsValue));
+          .assertResults(
+              fmt::format(
+                  "SELECT c0, {}, c1 FROM tmp",
+                  asLocalTime ? tsValueAsLocal : tsValue));
     };
     expect(true);
     expect(false);
@@ -2010,6 +2144,9 @@ TEST_F(TableScanTest, partitionedTableTimestampKey) {
             .planNode();
 
     auto expect = [&](bool asLocalTime) {
+      auto split = exec::test::HiveConnectorSplitBuilder(filePath->getPath())
+                       .partitionKey("pkey", partitionValue)
+                       .build();
       AssertQueryBuilder(plan, duckDbQueryRunner_)
           .connectorSessionProperty(
               kHiveConnectorId,
@@ -2017,9 +2154,10 @@ TEST_F(TableScanTest, partitionedTableTimestampKey) {
                   kReadTimestampPartitionValueAsLocalTimeSession,
               asLocalTime ? "true" : "false")
           .splits({split})
-          .assertResults(fmt::format(
-              "SELECT c0, c1, {} FROM tmp",
-              asLocalTime ? tsValueAsLocal : tsValue));
+          .assertResults(
+              fmt::format(
+                  "SELECT c0, c1, {} FROM tmp",
+                  asLocalTime ? tsValueAsLocal : tsValue));
     };
     expect(true);
     expect(false);
@@ -2037,6 +2175,9 @@ TEST_F(TableScanTest, partitionedTableTimestampKey) {
             .planNode();
 
     auto expect = [&](bool asLocalTime) {
+      auto split = exec::test::HiveConnectorSplitBuilder(filePath->getPath())
+                       .partitionKey("pkey", partitionValue)
+                       .build();
       AssertQueryBuilder(plan, duckDbQueryRunner_)
           .connectorSessionProperty(
               kHiveConnectorId,
@@ -2044,8 +2185,10 @@ TEST_F(TableScanTest, partitionedTableTimestampKey) {
                   kReadTimestampPartitionValueAsLocalTimeSession,
               asLocalTime ? "true" : "false")
           .splits({split})
-          .assertResults(fmt::format(
-              "SELECT {} FROM tmp", asLocalTime ? tsValueAsLocal : tsValue));
+          .assertResults(
+              fmt::format(
+                  "SELECT {} FROM tmp",
+                  asLocalTime ? tsValueAsLocal : tsValue));
     };
     expect(true);
     expect(false);
@@ -2068,12 +2211,7 @@ TEST_F(TableScanTest, partitionedTableTimestampKey) {
       filters[common::Subfield("pkey")] =
           std::make_unique<common::TimestampRange>(lower, lower, false);
       auto tableHandle = std::make_shared<HiveTableHandle>(
-          "test-hive",
-          "hive_table",
-          true,
-          std::move(filters),
-          nullptr,
-          nullptr);
+          "test-hive", "hive_table", std::move(filters), nullptr, nullptr);
 
       return PlanBuilder()
           .startTableScan()
@@ -2085,6 +2223,9 @@ TEST_F(TableScanTest, partitionedTableTimestampKey) {
     };
 
     auto expect = [&](bool asLocalTime) {
+      auto split = exec::test::HiveConnectorSplitBuilder(filePath->getPath())
+                       .partitionKey("pkey", partitionValue)
+                       .build();
       AssertQueryBuilder(planWithSubfilter(asLocalTime), duckDbQueryRunner_)
           .connectorSessionProperty(
               kHiveConnectorId,
@@ -2092,8 +2233,10 @@ TEST_F(TableScanTest, partitionedTableTimestampKey) {
                   kReadTimestampPartitionValueAsLocalTimeSession,
               asLocalTime ? "true" : "false")
           .splits({split})
-          .assertResults(fmt::format(
-              "SELECT {}, * FROM tmp", asLocalTime ? tsValueAsLocal : tsValue));
+          .assertResults(
+              fmt::format(
+                  "SELECT {}, * FROM tmp",
+                  asLocalTime ? tsValueAsLocal : tsValue));
     };
     expect(true);
     expect(false);
@@ -2501,7 +2644,7 @@ TEST_F(TableScanTest, statsBasedSkippingWithoutDecompression) {
   auto assertQuery = [&](const std::string& filter) {
     auto rowType = asRowType(rowVector->type());
     return TableScanTest::assertQuery(
-        PlanBuilder(pool_.get()).tableScan(rowType, {filter}).planNode(),
+        PlanBuilder(pool_.get()).tableScan(rowType, {}, {filter}).planNode(),
         filePaths,
         "SELECT * FROM tmp WHERE " + filter);
   };
@@ -2952,6 +3095,81 @@ TEST_F(TableScanTest, fileSizeAndModifiedTime) {
   filterTest(fmt::format("\"{}\" = {}", kModifiedTime, fileTimeValue));
 }
 
+// Test that synthesized column filter validation throws an error when the
+// filter doesn't match the split's value.
+TEST_F(TableScanTest, synthesizedColumnFilterValidation) {
+  auto rowType = ROW({"a"}, {BIGINT()});
+  auto filePath = makeFilePaths(1)[0];
+  auto vector = makeVectors(1, 10, rowType)[0];
+  writeToFile(filePath->getPath(), vector);
+
+  static const char* kPath = "$path";
+  auto assignments = allRegularColumns(rowType);
+  assignments[kPath] = synthesizedColumn(kPath, VARCHAR());
+
+  auto typeWithPath = ROW({kPath, "a"}, {VARCHAR(), BIGINT()});
+
+  // Create a filter that doesn't match the actual $path value.
+  auto tableHandle = makeTableHandle(
+      common::SubfieldFilters{},
+      parseExpr(
+          fmt::format("\"{}\" = '/nonexistent/path'", kPath), typeWithPath));
+
+  auto op = PlanBuilder()
+                .startTableScan()
+                .outputType(typeWithPath)
+                .tableHandle(tableHandle)
+                .assignments(assignments)
+                .endTableScan()
+                .planNode();
+
+  auto split =
+      exec::test::HiveConnectorSplitBuilder(filePath->getPath()).build();
+
+  // The query should throw an exception because the filter doesn't match.
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(op).splits({split}).copyResults(pool()),
+      "Synthesized column '$path' failed filter validation");
+}
+
+// Test that synthesized column filter validation throws an error for
+// $file_modified_time when the filter doesn't match the split's value.
+TEST_F(TableScanTest, synthesizedColumnFilterValidationModifiedTime) {
+  auto rowType = ROW({"a"}, {BIGINT()});
+  auto filePath = makeFilePaths(1)[0];
+  auto vector = makeVectors(1, 10, rowType)[0];
+  writeToFile(filePath->getPath(), vector);
+
+  static const char* kModifiedTime = "$file_modified_time";
+  auto assignments = allRegularColumns(rowType);
+  assignments[kModifiedTime] = synthesizedColumn(kModifiedTime, BIGINT());
+
+  auto typeWithModifiedTime = ROW({kModifiedTime, "a"}, {BIGINT(), BIGINT()});
+
+  // Create a filter that doesn't match the actual $file_modified_time value.
+  // Use 0 which won't match any real file's modification time.
+  auto tableHandle = makeTableHandle(
+      common::SubfieldFilters{},
+      parseExpr(
+          fmt::format("\"{}\" = 0", kModifiedTime), typeWithModifiedTime));
+
+  auto op = PlanBuilder()
+                .startTableScan()
+                .outputType(typeWithModifiedTime)
+                .tableHandle(tableHandle)
+                .assignments(assignments)
+                .endTableScan()
+                .planNode();
+
+  // Use makeHiveConnectorSplits to ensure infoColumns are set properly.
+  auto splits = makeHiveConnectorSplits({filePath});
+
+  // The query should throw an exception because the filter doesn't match.
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(op).splits(splits).copyResults(pool()),
+      "Synthesized column '$file_modified_time' failed filter validation");
+}
+
 TEST_F(TableScanTest, bucket) {
   vector_size_t size = 1'000;
   int numBatches = 5;
@@ -3102,7 +3320,7 @@ TEST_F(TableScanTest, bucketConversion) {
                         {"c2",
                          std::make_shared<HiveColumnHandle>(
                              "c2",
-                             HiveColumnHandle::ColumnType::kRowIndex,
+                             FileColumnHandle::ColumnType::kRowIndex,
                              BIGINT(),
                              BIGINT())},
                         {"c1", makeColumnHandle("c1", BIGINT(), {})},
@@ -4310,6 +4528,53 @@ TEST_F(TableScanTest, parallelPrepare) {
       .copyResults(pool_.get());
 }
 
+TEST_F(TableScanTest, parallelPrepareWithSubfieldFilters) {
+  // Test metadataFilter is correctly transferred during split prefetch.
+  constexpr int32_t kNumParallel = 100;
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>(100, [](auto row) { return row; }),
+      makeFlatVector<int64_t>(100, [](auto row) { return row * 2; }),
+  });
+
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), {data});
+
+  auto subfieldFilters = SubfieldFiltersBuilder()
+                             .add("c0", greaterThanOrEqual(10))
+                             .add("c1", lessThan(150))
+                             .build();
+
+  auto outputType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+  auto remainingFilter = parseExpr("c0 % 2 = 0", outputType);
+  auto tableHandle =
+      makeTableHandle(std::move(subfieldFilters), remainingFilter);
+  auto assignments = allRegularColumns(outputType);
+
+  auto plan = exec::test::PlanBuilder(pool_.get())
+                  .startTableScan()
+                  .outputType(outputType)
+                  .tableHandle(tableHandle)
+                  .assignments(assignments)
+                  .endTableScan()
+                  .planNode();
+
+  std::vector<exec::Split> splits;
+  for (auto i = 0; i < kNumParallel; ++i) {
+    splits.push_back(makeHiveSplit(filePath->getPath()));
+  }
+
+  auto result = AssertQueryBuilder(plan)
+                    .config(
+                        core::QueryConfig::kMaxSplitPreloadPerDriver,
+                        std::to_string(kNumParallel))
+                    .splits(splits)
+                    .copyResults(pool_.get());
+
+  // Verify results: c0 >= 10 AND c1 < 150 AND c0 % 2 = 0
+  // So rows [10,12,14,...,74] = 33 rows per split
+  ASSERT_EQ(result->size(), 33 * kNumParallel);
+}
+
 TEST_F(TableScanTest, dictionaryMemo) {
   constexpr int kSize = 100;
   const char* baseStrings[] = {
@@ -4364,10 +4629,15 @@ TEST_F(TableScanTest, reuseRowVector) {
                   .tableScan(rowType, {}, "c0 < 5")
                   .project({"c1.c0"})
                   .planNode();
-  auto split = exec::test::HiveConnectorSplitBuilder(file->getPath()).build();
+  auto firstSplit =
+      exec::test::HiveConnectorSplitBuilder(file->getPath()).build();
+  auto secondSplit =
+      exec::test::HiveConnectorSplitBuilder(file->getPath()).build();
   auto expected = makeRowVector(
       {makeFlatVector<int32_t>(10, [](auto i) { return i % 5; })});
-  AssertQueryBuilder(plan).splits({split, split}).assertResults(expected);
+  AssertQueryBuilder(plan)
+      .splits({firstSplit, secondSplit})
+      .assertResults(expected);
 }
 
 // Tests queries that read more row fields than exist in the data.
@@ -4623,6 +4893,7 @@ TEST_F(TableScanTest, readMissingFieldsInMap) {
 
   // Now run query with column mapping using names - we should not be able to
   // find any names.
+  split = makeHiveConnectorSplit(filePath->getPath());
   result = AssertQueryBuilder(op)
                .connectorSessionProperty(
                    kHiveConnectorId,
@@ -4679,6 +4950,7 @@ TEST_F(TableScanTest, readMissingFieldsInMap) {
            .endTableScan()
            .project({"i1"})
            .planNode();
+  split = makeHiveConnectorSplit(filePath->getPath());
 
   EXPECT_THROW(
       AssertQueryBuilder(op).split(split).copyResults(pool()), VeloxUserError);
@@ -4883,6 +5155,7 @@ TEST_F(TableScanTest, readMissingFieldsWithMoreColumns) {
 
   // Now run query with column mapping using names - we should not be able to
   // find any names, except for the last string column.
+  split = makeHiveConnectorSplit(filePath->getPath());
   result = AssertQueryBuilder(op)
                .connectorSessionProperty(
                    kHiveConnectorId,
@@ -5086,6 +5359,42 @@ TEST_F(TableScanTest, readFlatMapAsStruct) {
   AssertQueryBuilder(plan).split(split).assertResults(expected);
 }
 
+// Test reading flatmap as struct when none of the requested keys exist in the
+// file.  All projected struct fields should be null.
+TEST_F(TableScanTest, readFlatMapAsStructNoMatchingKeys) {
+  constexpr int kSize = 10;
+  std::vector<std::string> keys = {"1", "2", "3"};
+  auto c0 = makeRowVector(
+      keys,
+      {
+          makeFlatVector<int64_t>(kSize, folly::identity),
+          makeFlatVector<int64_t>(kSize, folly::identity),
+          makeFlatVector<int64_t>(kSize, folly::identity),
+      });
+  auto vector = makeRowVector({c0});
+  auto config = std::make_shared<dwrf::Config>();
+  config->set(dwrf::Config::FLATTEN_MAP, true);
+  config->set<const std::vector<uint32_t>>(dwrf::Config::MAP_FLAT_COLS, {0});
+  config->set<const std::vector<std::vector<std::string>>>(
+      dwrf::Config::MAP_FLAT_COLS_STRUCT_KEYS, {keys});
+  auto file = TempFilePath::create();
+  auto writeSchema = ROW({"c0"}, {MAP(INTEGER(), BIGINT())});
+  writeToFile(file->getPath(), {vector}, config, writeSchema);
+
+  // Request keys "4" and "5" which don't exist in the file.
+  auto readSchema = ROW({"c0"}, {ROW({"4", "5"}, {BIGINT(), BIGINT()})});
+  auto plan =
+      PlanBuilder().tableScan(readSchema, {}, "", writeSchema).planNode();
+  auto split = makeHiveConnectorSplit(file->getPath());
+  auto expected = makeRowVector({makeRowVector(
+      {"4", "5"},
+      {
+          makeNullConstant(TypeKind::BIGINT, kSize),
+          makeNullConstant(TypeKind::BIGINT, kSize),
+      })});
+  AssertQueryBuilder(plan).split(split).assertResults(expected);
+}
+
 TEST_F(TableScanTest, flatMapReadOffset) {
   auto vector = makeRowVector(
       {makeNullableMapVector<int64_t, int64_t>({std::nullopt, {{{1, 2}}}})});
@@ -5112,13 +5421,13 @@ TEST_F(TableScanTest, flatMapKeyTypeEvolution) {
   config->set<const std::vector<uint32_t>>(dwrf::Config::MAP_FLAT_COLS, {0});
   auto file = TempFilePath::create();
   writeToFile(file->getPath(), {vector}, config);
-  auto split = makeHiveConnectorSplit(file->getPath());
   auto schema = ROW({"c0"}, {MAP(BIGINT(), BIGINT())});
   {
     SCOPED_TRACE("Read as map");
     auto plan = PlanBuilder().tableScan(schema).planNode();
     auto expected =
         makeRowVector({makeMapVector<int64_t, int64_t>({{{1, 2}, {3, 4}}})});
+    auto split = makeHiveConnectorSplit(file->getPath());
     AssertQueryBuilder(plan).split(split).assertResults(expected);
   }
   {
@@ -5128,6 +5437,7 @@ TEST_F(TableScanTest, flatMapKeyTypeEvolution) {
     auto expected = makeRowVector({makeRowVector(
         {"1", "3"},
         {makeConstant<int64_t>(2, 1), makeConstant<int64_t>(4, 1)})});
+    auto split = makeHiveConnectorSplit(file->getPath());
     AssertQueryBuilder(plan).split(split).assertResults(expected);
   }
 }
@@ -5146,7 +5456,6 @@ TEST_F(TableScanTest, flatMapLazyRowValue) {
   config->set<const std::vector<uint32_t>>(dwrf::Config::MAP_FLAT_COLS, {0});
   auto file = TempFilePath::create();
   writeToFile(file->getPath(), {vector}, config);
-  auto split = makeHiveConnectorSplit(file->getPath());
   {
     SCOPED_TRACE("Read as map");
     auto plan = PlanBuilder()
@@ -5157,6 +5466,7 @@ TEST_F(TableScanTest, flatMapLazyRowValue) {
                         vector->rowType())
                     .planNode();
     auto expected = makeRowVector({wrapInDictionary(makeIndices({1}), c0)});
+    auto split = makeHiveConnectorSplit(file->getPath());
     AssertQueryBuilder(plan).split(split).assertResults(expected);
   }
   {
@@ -5182,6 +5492,7 @@ TEST_F(TableScanTest, flatMapLazyRowValue) {
                 makeConstant<int64_t>(10, 1),
             }),
         })});
+    auto split = makeHiveConnectorSplit(file->getPath());
     AssertQueryBuilder(plan).split(split).assertResults(expected);
   }
 }
@@ -5255,13 +5566,13 @@ TEST_F(TableScanTest, dynamicFilterWithRowIndexColumn) {
   connector::ColumnHandleMap assignments;
   assignments["a"] = std::make_shared<connector::hive::HiveColumnHandle>(
       "a",
-      connector::hive::HiveColumnHandle::ColumnType::kRegular,
+      connector::hive::FileColumnHandle::ColumnType::kRegular,
       BIGINT(),
       BIGINT());
   assignments["row_index"] =
       std::make_shared<connector::hive::HiveColumnHandle>(
           "row_index",
-          connector::hive::HiveColumnHandle::ColumnType::kRowIndex,
+          connector::hive::FileColumnHandle::ColumnType::kRowIndex,
           BIGINT(),
           BIGINT());
   std::shared_ptr<TempFilePath> files[2];
@@ -5296,6 +5607,63 @@ TEST_F(TableScanTest, dynamicFilterWithRowIndexColumn) {
       .assertResults(resVector);
 }
 
+TEST_F(TableScanTest, bloomFilterPushdown) {
+  auto build = makeRowVector(
+      {"b"},
+      {
+          makeFlatVector<int64_t>(
+              10'001 + VectorHasher::kMaxDistinct,
+              [](auto i) { return 1000 * i; }),
+      });
+  auto probe = makeRowVector(
+      {"a"},
+      {
+          makeFlatVector<int64_t>(
+              2 * build->size(), [](auto i) { return 500 * i; }),
+      });
+  std::shared_ptr<TempFilePath> files[2];
+  files[0] = TempFilePath::create();
+  writeToFile(files[0]->getPath(), {probe});
+  files[1] = TempFilePath::create();
+  writeToFile(files[1]->getPath(), {build});
+  auto idGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId probeScanId, buildScanId, joinId;
+  auto plan = PlanBuilder(idGenerator)
+                  .tableScan(ROW({"a"}, {BIGINT()}))
+                  .capturePlanNodeId(probeScanId)
+                  .hashJoin(
+                      {"a"},
+                      {"b"},
+                      PlanBuilder(idGenerator)
+                          .tableScan(ROW({"b"}, {BIGINT()}))
+                          .capturePlanNodeId(buildScanId)
+                          .planNode(),
+                      /*filter=*/"",
+                      {"a"})
+                  .capturePlanNodeId(joinId)
+                  .planNode();
+  for (bool parallelBuild : {false, true}) {
+    SCOPED_TRACE(fmt::format("parallelBuild={}", parallelBuild));
+    AssertQueryBuilder builder(plan);
+    builder
+        .config(
+            core::QueryConfig::kHashProbeBloomFilterPushdownMaxSize,
+            std::to_string(4 * build->size()))
+        .split(probeScanId, makeHiveConnectorSplit(files[0]->getPath()))
+        .split(buildScanId, makeHiveConnectorSplit(files[1]->getPath()));
+    if (parallelBuild) {
+      builder.serialExecution(false).maxDrivers(2).config(
+          core::QueryConfig::kMinTableRowsForParallelJoinBuild, "1");
+    }
+    auto task = builder.assertResults(build);
+    auto planStats = toPlanStats(task->taskStats());
+    ASSERT_EQ(
+        planStats.at(joinId).customStats.at("dynamicFiltersProduced").sum,
+        parallelBuild ? 2 : 1);
+    ASSERT_GT(planStats.at(joinId).customStats.at("bloomFilterSize").sum, 0);
+  }
+}
+
 // TODO: re-enable this test once we add back driver suspension support for
 // table scan.
 TEST_F(TableScanTest, DISABLED_memoryArbitrationWithSlowTableScan) {
@@ -5356,7 +5724,7 @@ TEST_F(TableScanTest, DISABLED_memoryArbitrationWithSlowTableScan) {
           .planNode();
 
   std::thread queryThread([&]() {
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto spillDirectory = TempDirectoryPath::create();
     auto task = assertQuery(
         op,
         filePaths,
@@ -5482,9 +5850,9 @@ DEBUG_ONLY_TEST_F(TableScanTest, cancellationToken) {
 
   std::atomic_bool cancelled{false};
   SCOPED_TESTVALUE_SET(
-      "facebook::velox::connector::hive::HiveDataSource::next",
-      std::function<void(connector::hive::HiveDataSource*)>(
-          [&](connector::hive::HiveDataSource* source) {
+      "facebook::velox::connector::hive::FileDataSource::next",
+      std::function<void(connector::hive::FileDataSource*)>(
+          [&](connector::hive::FileDataSource* source) {
             auto cancellationToken =
                 source->testingConnectorQueryCtx()->cancellationToken();
             while (true) {
@@ -5546,7 +5914,7 @@ TEST_F(TableScanTest, rowNumberInRemainingFilter) {
                       {"r1",
                        std::make_shared<HiveColumnHandle>(
                            "r1",
-                           HiveColumnHandle::ColumnType::kRowIndex,
+                           FileColumnHandle::ColumnType::kRowIndex,
                            BIGINT(),
                            BIGINT())},
                   })
@@ -5596,7 +5964,7 @@ TEST_F(TableScanTest, rowId) {
   writeToFile(file->getPath(), {vector});
   auto makeRowIdColumnHandle = [&](auto& name) {
     return std::make_shared<HiveColumnHandle>(
-        name, HiveColumnHandle::ColumnType::kRowId, rowIdType, rowIdType);
+        name, FileColumnHandle::ColumnType::kRowId, rowIdType, rowIdType);
   };
   {
     SCOPED_TRACE("Preload");
@@ -5703,11 +6071,11 @@ TEST_F(TableScanTest, footerIOCount) {
           .assertResults(
               BaseVector::create<RowVector>(vector->type(), 0, pool()));
   auto stats = getTableScanRuntimeStats(task);
-  ASSERT_EQ(stats.at("numStorageRead").sum, 1);
+  ASSERT_EQ(stats.at("storageReadBytes").count, 1);
   ASSERT_GT(stats.at("footerBufferOverread").sum, 0);
 }
 
-TEST_F(TableScanTest, statsBasedFilterReorderDisabled) {
+TEST_F(TableScanTest, statsBasedFilterReorderBothEnabledAndDisabled) {
   gflags::FlagSaver gflagSaver;
   // Disable prefetch to avoid test flakiness.
   FLAGS_cache_prefetch_min_pct = 200;
@@ -5736,8 +6104,8 @@ TEST_F(TableScanTest, statsBasedFilterReorderDisabled) {
   }
   createDuckDbTable(vectors);
 
-  for (auto disableReoder : {false}) {
-    SCOPED_TRACE(fmt::format("disableReoder {}", disableReoder));
+  for (auto disableReorder : {false, true}) {
+    SCOPED_TRACE(fmt::format("disableReorder {}", disableReorder));
     auto* cache = cache::AsyncDataCache::getInstance();
     cache->clear();
 
@@ -5770,7 +6138,7 @@ TEST_F(TableScanTest, statsBasedFilterReorderDisabled) {
                   kHiveConnectorId,
                   connector::hive::HiveConfig::
                       kReadStatsBasedFilterReorderDisabledSession,
-                  disableReoder ? "true" : "false")
+                  disableReorder ? "true" : "false")
               // Disable coalesce so that each column stream has a separate read
               // per split at least.
               .connectorSessionProperty(
@@ -5794,7 +6162,7 @@ TEST_F(TableScanTest, statsBasedFilterReorderDisabled) {
       auto tableScanStats = getTableScanStats(task);
       ASSERT_EQ(tableScanStats.customStats.count("storageReadBytes"), 1);
       ASSERT_GT(tableScanStats.customStats["storageReadBytes"].sum, 0);
-      ASSERT_EQ(tableScanStats.customStats["storageReadBytes"].count, 1);
+      ASSERT_GT(tableScanStats.customStats["storageReadBytes"].count, 0);
       ASSERT_EQ(tableScanStats.numSplits, numSplits);
     }
 
@@ -5806,7 +6174,7 @@ TEST_F(TableScanTest, statsBasedFilterReorderDisabled) {
                   kHiveConnectorId,
                   connector::hive::HiveConfig::
                       kReadStatsBasedFilterReorderDisabledSession,
-                  disableReoder ? "true" : "false")
+                  disableReorder ? "true" : "false")
               .connectorSessionProperty(
                   kHiveConnectorId,
                   connector::hive::HiveConfig::kMaxCoalescedBytesSession,
@@ -5824,15 +6192,17 @@ TEST_F(TableScanTest, statsBasedFilterReorderDisabled) {
                   "SELECT c0 FROM tmp WHERE (c1 IN (1,7,11) OR c1 IS NULL) AND (c3 IN (1,7,11)  OR c3 IS NULL)");
 
       auto tableScanStats = getTableScanStats(task);
-      if (disableReoder) {
+      if (disableReorder) {
         ASSERT_EQ(tableScanStats.customStats.count("storageReadBytes"), 0);
       } else {
+        // Cache hit
         if (tableScanStats.customStats.count("storageReadBytes") == 0) {
           continue;
         }
+        // Cache miss, should behave like first time run
         ASSERT_EQ(tableScanStats.customStats.count("storageReadBytes"), 1);
         ASSERT_GT(tableScanStats.customStats["storageReadBytes"].sum, 0);
-        ASSERT_EQ(tableScanStats.customStats["storageReadBytes"].count, 1);
+        ASSERT_GT(tableScanStats.customStats["storageReadBytes"].count, 0);
       }
       ASSERT_EQ(tableScanStats.numSplits, numSplits);
     }
@@ -5932,7 +6302,10 @@ TEST_F(TableScanTest, textfileEscape) {
   auto it = planStats.find(scanNodeId);
   ASSERT_TRUE(it != planStats.end());
   auto rawInputBytes = it->second.rawInputBytes;
-  auto overreadBytes = getTableScanRuntimeStats(task).at("overreadBytes").sum;
+  auto runtimeStats = getTableScanRuntimeStats(task);
+  auto overreadIt = runtimeStats.find("overreadBytes");
+  const int64_t overreadBytes =
+      overreadIt != runtimeStats.end() ? overreadIt->second.sum : 0;
 
   ASSERT_EQ(rawInputBytes, 11);
   ASSERT_EQ(overreadBytes, 0);
@@ -6112,5 +6485,1273 @@ TEST_F(TableScanTest, duplicateFieldProject) {
       .assertResults("SELECT id, id FROM tmp WHERE name = 'John'");
 }
 
+TEST_F(TableScanTest, parallelUnitLoader) {
+  auto vectors = makeVectors(10, 1'000);
+  auto filePath = TempFilePath::create();
+  writeToFile(
+      filePath->getPath(),
+      vectors,
+      std::make_shared<facebook::velox::dwrf::Config>(),
+      []() { return std::make_unique<dwrf::DefaultFlushPolicy>(1000, 0); });
+  createDuckDbTable(vectors);
+  auto plan = tableScanNode();
+  auto task =
+      AssertQueryBuilder(plan)
+          .splits(makeHiveConnectorSplits({filePath}))
+          .connectorSessionProperty(
+              kHiveConnectorId,
+              connector::hive::HiveConfig::kParallelUnitLoadCountSession,
+              std::to_string(3))
+          .assertTypeAndNumRows(rowType_, 10'000);
+  auto stats = getTableScanRuntimeStats(task);
+  // Verify that parallel unit loader is enabled.
+  ASSERT_GT(stats.count("waitForUnitReadyNanos"), 0);
+}
+
+TEST_F(TableScanTest, filterColumnHandles) {
+  auto data = makeVectors(1, 10, ROW({"a", "b"}, BIGINT()));
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), data);
+  auto split = exec::test::HiveConnectorSplitBuilder(filePath->getPath())
+                   .partitionKey("ds", "2025-10-23")
+                   .build();
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(ROW({"x"}, {BIGINT()}))
+                  .assignments({{"x", regularColumn("a", BIGINT())}})
+                  .dataColumns(asRowType(data[0]->type()))
+                  .filterColumnHandles({
+                      partitionKey("ds", VARCHAR()),
+                      regularColumn("a", BIGINT()),
+                  })
+                  .remainingFilter("length(ds) + a % 2 > 0")
+                  .endTableScan()
+                  .planNode();
+  AssertQueryBuilder(plan).split(split).assertResults(
+      makeRowVector({data[0]->childAt(0)}));
+}
+
+TEST_F(TableScanTest, columnPostProcessorWithSubfieldFilters) {
+  auto data = makeFlatVector<int64_t>(10, folly::identity);
+  auto vector = makeRowVector({data, data, data});
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector});
+  ChainedVectorLoader::PostVectorLoadProcessor postProc;
+  postProc = [&](auto& column) {
+    if (column->isLazy()) {
+      auto* lazy = column->template asUnchecked<LazyVector>();
+      if (lazy->isLoaded()) {
+        column = lazy->loadedVectorShared();
+        postProc(column);
+      } else {
+        lazy->chain(postProc);
+      }
+      return;
+    }
+    if (column->encoding() == VectorEncoding::Simple::DICTIONARY) {
+      auto alphabet = column->valueVector();
+      postProc(alphabet);
+      column->setValueVector(std::move(alphabet));
+      return;
+    }
+    auto* values =
+        column->template asChecked<FlatVector<int64_t>>()->mutableRawValues();
+    for (vector_size_t i = 0; i < column->size(); ++i) {
+      ++values[i];
+    }
+  };
+  auto c0Handle = std::make_shared<HiveColumnHandle>(
+      "c0",
+      FileColumnHandle::ColumnType::kRegular,
+      BIGINT(),
+      BIGINT(),
+      std::vector<common::Subfield>{},
+      HiveColumnHandle::ColumnParseParameters{},
+      postProc);
+  auto c1Handle = regularColumn("c1", BIGINT());
+  auto c2Handle = std::make_shared<HiveColumnHandle>(
+      "c2",
+      FileColumnHandle::ColumnType::kRegular,
+      BIGINT(),
+      BIGINT(),
+      std::vector<common::Subfield>{},
+      HiveColumnHandle::ColumnParseParameters{},
+      postProc);
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>({1, 3, 5, 7, 9}),
+      makeFlatVector<int64_t>({0, 2, 4, 6, 8}),
+      makeFlatVector<int64_t>({1, 3, 5, 7, 9}),
+  });
+  {
+    SCOPED_TRACE("Subfield filters");
+    auto plan =
+        PlanBuilder(pool())
+            .startTableScan()
+            .outputType(asRowType(vector->type()))
+            .subfieldFilter("c0 in (0, 2, 4, 6, 8)")
+            .assignments({{"c0", c0Handle}, {"c1", c1Handle}, {"c2", c2Handle}})
+            .endTableScan()
+            .planNode();
+    auto split = makeHiveConnectorSplit(file->getPath());
+    AssertQueryBuilder(plan).split(split).assertResults(expected);
+  }
+  {
+    SCOPED_TRACE("Remaining filter");
+    auto plan =
+        PlanBuilder()
+            .startTableScan()
+            .outputType(asRowType(vector->type()))
+            .remainingFilter("c0 % 2 = 0")
+            .assignments({{"c0", c0Handle}, {"c1", c1Handle}, {"c2", c2Handle}})
+            .endTableScan()
+            .planNode();
+    auto split = makeHiveConnectorSplit(file->getPath());
+    AssertQueryBuilder(plan).split(split).assertResults(expected);
+  }
+}
+
+TEST_F(TableScanTest, shortDecimalFilter) {
+  functions::registerIsNotNullFunction("isnotnull");
+
+  std::vector<std::optional<int64_t>> values = {
+      123456789123456789L,
+      987654321123456L,
+      std::nullopt,
+      2000000000000000L,
+      5000000000000000L,
+      987654321987654321L,
+      100000000000000L,
+      1230000000123456L,
+      120000000123456L,
+      std::nullopt};
+  auto rowVector = makeRowVector(
+      {"a"},
+      {
+          makeNullableFlatVector<int64_t>(values, DECIMAL(18, 6)),
+      });
+  createDuckDbTable({rowVector});
+
+  auto filePath = facebook::velox::test::getDataFilePath(
+      "velox/exec/tests", "data/decimal.orc");
+  auto createSplit = [&]() {
+    return exec::test::HiveConnectorSplitBuilder(filePath)
+        .start(0)
+        .length(fs::file_size(filePath))
+        .fileFormat(dwio::common::FileFormat::ORC)
+        .build();
+  };
+
+  auto rowType = rowVector->rowType();
+  // Is not null.
+  auto op =
+      PlanBuilder().tableScan(rowType, {}, "isnotnull(a)", rowType).planNode();
+  assertQuery(op, createSplit(), "SELECT a FROM tmp where a is not null");
+
+  // Is null.
+  op = PlanBuilder().tableScan(rowType, {}, "is_null(a)", rowType).planNode();
+  assertQuery(op, createSplit(), "SELECT a FROM tmp where a is null");
+
+  // BigintRange.
+  op =
+      PlanBuilder()
+          .tableScan(
+              rowType,
+              {},
+              "a > 2000000000.0::DECIMAL(18, 6) and a < 6000000000.0::DECIMAL(18, 6)",
+              rowType)
+          .planNode();
+  assertQuery(
+      op,
+      createSplit(),
+      "SELECT a FROM tmp where a > 2000000000.0 and a < 6000000000.0");
+
+  // NegatedBigintRange.
+  op =
+      PlanBuilder()
+          .tableScan(
+              rowType,
+              {},
+              "not(a between 2000000000.0::DECIMAL(18, 6) and 6000000000.0::DECIMAL(18, 6))",
+              rowType)
+          .planNode();
+  assertQuery(
+      op,
+      createSplit(),
+      "SELECT a FROM tmp where a < 2000000000.0 or a > 6000000000.0");
+}
+
+TEST_F(TableScanTest, longDecimalFilter) {
+  functions::registerIsNotNullFunction("isnotnull");
+
+  std::vector<std::optional<int64_t>> shortValues = {
+      123456789123456789L,
+      987654321123456L,
+      std::nullopt,
+      2000000000000000L,
+      5000000000000000L,
+      987654321987654321L,
+      100000000000000L,
+      1230000000123456L,
+      120000000123456L,
+      std::nullopt};
+
+  std::vector<std::optional<int128_t>> longValues = {
+      HugeInt::parse("123456789123456789123456789" + std::string(9, '0')),
+      HugeInt::parse("987654321123456789" + std::string(9, '0')),
+      std::nullopt,
+      HugeInt::parse("2" + std::string(37, '0')),
+      HugeInt::parse("5" + std::string(37, '0')),
+      HugeInt::parse("987654321987654321987654321" + std::string(9, '0')),
+      HugeInt::parse("1" + std::string(26, '0')),
+      HugeInt::parse("123000000012345678" + std::string(10, '0')),
+      HugeInt::parse("120000000123456789" + std::string(9, '0')),
+      HugeInt::parse("9" + std::string(37, '0'))};
+
+  auto rowVector = makeRowVector(
+      {"a", "b"},
+      {
+          makeNullableFlatVector<int64_t>(shortValues, DECIMAL(18, 6)),
+          makeNullableFlatVector<int128_t>(longValues, DECIMAL(38, 18)),
+      });
+  createDuckDbTable({rowVector});
+
+  auto filePath = facebook::velox::test::getDataFilePath(
+      "velox/exec/tests", "data/decimal.orc");
+  auto createSplit = [&]() {
+    return exec::test::HiveConnectorSplitBuilder(filePath)
+        .start(0)
+        .length(fs::file_size(filePath))
+        .fileFormat(dwio::common::FileFormat::ORC)
+        .build();
+  };
+
+  auto outputType = ROW({"b"}, {DECIMAL(38, 18)});
+  auto dataColumns = rowVector->rowType();
+
+  auto op = PlanBuilder()
+                .tableScan(outputType, {}, "isnotnull(b)", dataColumns)
+                .planNode();
+  assertQuery(op, createSplit(), "SELECT b FROM tmp where b is not null");
+
+  // Is null.
+  op = PlanBuilder()
+           .tableScan(outputType, {}, "is_null(b)", dataColumns)
+           .planNode();
+  assertQuery(op, createSplit(), "SELECT b FROM tmp where b is null");
+
+  // HugeintRange.
+  op =
+      PlanBuilder()
+          .tableScan(
+              outputType,
+              {},
+              "b > 2000000000.0::DECIMAL(38, 18) and b < 6000000000.0::DECIMAL(38, 18)",
+              dataColumns)
+          .planNode();
+  assertQuery(
+      op,
+      createSplit(),
+      "SELECT b FROM tmp where b > 2000000000.0 and b < 6000000000.0");
+
+  // Test filter column not being projected out.
+  op = PlanBuilder()
+           .tableScan(outputType, {}, "a is null", dataColumns)
+           .planNode();
+  assertQuery(op, createSplit(), "SELECT b FROM tmp WHERE a is null");
+}
+
+TEST_F(TableScanTest, fileFormatRuntimeStats) {
+  auto vectors = makeVectors(3, 1'000);
+
+  // Write 3 DWRF files.
+  auto filePaths = makeFilePaths(3);
+  for (const auto& filePath : filePaths) {
+    writeToFile(filePath->getPath(), vectors);
+  }
+
+  // DuckDB reference table needs all data from all 3 files.
+  std::vector<RowVectorPtr> allVectors;
+  for (int i = 0; i < 3; ++i) {
+    allVectors.insert(allVectors.end(), vectors.begin(), vectors.end());
+  }
+  createDuckDbTable(allVectors);
+
+  auto task = assertQuery(tableScanNode(), filePaths, "SELECT * FROM tmp");
+  auto stats = getTableScanRuntimeStats(task);
+  ASSERT_EQ(stats.count("fileFormat.dwrf"), 1);
+  ASSERT_EQ(stats.at("fileFormat.dwrf").sum, 3);
+}
+
+TEST_F(TableScanTest, scanBatchCallback) {
+  auto vectors = makeVectors(3, 1'000);
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors);
+
+  uint64_t totalRows{0};
+  uint64_t callbackCount{0};
+  std::string receivedTableName;
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+  queryCtx->setScanBatchCallback([&](const core::ScanBatchEvent& event) {
+    totalRows += event.numRows;
+    if (const auto* fileEvent =
+            dynamic_cast<const connector::hive::FileScanBatchEvent*>(&event)) {
+      receivedTableName = std::string(fileEvent->tableName);
+    }
+    ++callbackCount;
+  });
+
+  auto plan = tableScanNode();
+  auto task = AssertQueryBuilder(plan)
+                  .splits(makeHiveConnectorSplits({filePath}))
+                  .queryCtx(queryCtx)
+                  .copyResults(pool_.get());
+
+  EXPECT_GT(totalRows, 0);
+  EXPECT_GT(callbackCount, 0);
+  EXPECT_FALSE(receivedTableName.empty());
+}
+
+TEST_F(TableScanTest, scanBatchCallbackPartitionKeys) {
+  auto vectors = makeVectors(1, 1'000);
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors);
+
+  std::unordered_map<std::string, std::optional<std::string>>
+      receivedPartitionKeys;
+  bool callbackFired{false};
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+  queryCtx->setScanBatchCallback([&](const core::ScanBatchEvent& event) {
+    if (const auto* fileEvent =
+            dynamic_cast<const connector::hive::FileScanBatchEvent*>(&event)) {
+      if (fileEvent->partitionKeys) {
+        receivedPartitionKeys = *fileEvent->partitionKeys;
+      }
+    }
+    callbackFired = true;
+  });
+
+  connector::ColumnHandleMap assignments = {
+      {"c0", regularColumn("c0", BIGINT())},
+      {"ds", partitionKey("ds", VARCHAR())},
+  };
+
+  auto outputType = ROW({"c0", "ds"}, {BIGINT(), VARCHAR()});
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(outputType)
+                  .assignments(assignments)
+                  .endTableScan()
+                  .planNode();
+
+  auto split = exec::test::HiveConnectorSplitBuilder(filePath->getPath())
+                   .partitionKey("ds", "2026-05-12")
+                   .build();
+
+  AssertQueryBuilder(plan).queryCtx(queryCtx).split(split).copyResults(
+      pool_.get());
+
+  ASSERT_TRUE(callbackFired);
+  const std::unordered_map<std::string, std::optional<std::string>> expected{
+      {"ds", "2026-05-12"}};
+  ASSERT_EQ(receivedPartitionKeys, expected);
+}
+
+TEST_F(TableScanTest, scanBatchCallbackNotSetIsNoOp) {
+  auto vectors = makeVectors(3, 1'000);
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors);
+
+  auto plan = tableScanNode();
+  auto result = AssertQueryBuilder(plan)
+                    .splits(makeHiveConnectorSplits({filePath}))
+                    .copyResults(pool_.get());
+  EXPECT_GT(result->size(), 0);
+}
+
+// --- Column extraction pushdown table scan tests ---
+
+TEST_F(TableScanTest, extractionMapKeys) {
+  // Write a MAP(VARCHAR, BIGINT) column, read with MapKeys extraction.
+  auto mapVector = makeMapVector<StringView, int64_t>(
+      {{{"a", 1}, {"b", 2}}, {{"c", 3}, {"d", 4}, {"e", 5}}});
+  auto vector = makeRowVector({"col"}, {mapVector});
+
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector});
+
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  auto outputType = ROW({"col"}, {ARRAY(VARCHAR())});
+  std::vector<NamedExtraction> extractions = {
+      {"col",
+       {ExtractionPathElement::simple(ExtractionStep::kMapKeys)},
+       ARRAY(VARCHAR())}};
+
+  auto handle = std::make_shared<HiveColumnHandle>(
+      "col",
+      HiveColumnHandle::ColumnType::kRegular,
+      ARRAY(VARCHAR()),
+      hiveType,
+      std::vector<common::Subfield>{},
+      std::move(extractions));
+
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(outputType)
+                  .assignments({{"col", handle}})
+                  .endTableScan()
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan)
+                    .split(makeHiveConnectorSplit(file->getPath()))
+                    .copyResults(pool_.get());
+
+  ASSERT_EQ(result->size(), 2);
+  auto* resultArray = result->childAt(0)->as<ArrayVector>();
+  ASSERT_EQ(resultArray->sizeAt(0), 2);
+  ASSERT_EQ(resultArray->sizeAt(1), 3);
+}
+
+TEST_F(TableScanTest, extractionMapValues) {
+  // Write a MAP(VARCHAR, BIGINT) column, read with MapValues extraction.
+  auto mapVector =
+      makeMapVector<StringView, int64_t>({{{"a", 10}}, {{"b", 20}, {"c", 30}}});
+  auto vector = makeRowVector({"col"}, {mapVector});
+
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector});
+
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  auto outputType = ROW({"col"}, {ARRAY(BIGINT())});
+  std::vector<NamedExtraction> extractions = {
+      {"col",
+       {ExtractionPathElement::simple(ExtractionStep::kMapValues)},
+       ARRAY(BIGINT())}};
+
+  auto handle = std::make_shared<HiveColumnHandle>(
+      "col",
+      HiveColumnHandle::ColumnType::kRegular,
+      ARRAY(BIGINT()),
+      hiveType,
+      std::vector<common::Subfield>{},
+      std::move(extractions));
+
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(outputType)
+                  .assignments({{"col", handle}})
+                  .endTableScan()
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan)
+                    .split(makeHiveConnectorSplit(file->getPath()))
+                    .copyResults(pool_.get());
+
+  ASSERT_EQ(result->size(), 2);
+  auto* resultArray = result->childAt(0)->as<ArrayVector>();
+  ASSERT_EQ(resultArray->sizeAt(0), 1);
+  ASSERT_EQ(resultArray->sizeAt(1), 2);
+}
+
+TEST_F(TableScanTest, extractionSize) {
+  // Write a MAP(VARCHAR, BIGINT) column, read with Size extraction.
+  auto mapVector = makeMapVector<StringView, int64_t>(
+      {{{"a", 1}, {"b", 2}, {"c", 3}}, {{"d", 4}}});
+  auto vector = makeRowVector({"col"}, {mapVector});
+
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector});
+
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  auto outputType = ROW({"col"}, {BIGINT()});
+  std::vector<NamedExtraction> extractions = {
+      {"col",
+       {ExtractionPathElement::simple(ExtractionStep::kSize)},
+       BIGINT()}};
+
+  auto handle = std::make_shared<HiveColumnHandle>(
+      "col",
+      HiveColumnHandle::ColumnType::kRegular,
+      BIGINT(),
+      hiveType,
+      std::vector<common::Subfield>{},
+      std::move(extractions));
+
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(outputType)
+                  .assignments({{"col", handle}})
+                  .endTableScan()
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan)
+                    .split(makeHiveConnectorSplit(file->getPath()))
+                    .copyResults(pool_.get());
+
+  ASSERT_EQ(result->size(), 2);
+  auto expected = makeRowVector({"col"}, {makeFlatVector<int64_t>({3, 1})});
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(TableScanTest, extractionMapKeyFilter) {
+  // Write a MAP(VARCHAR, BIGINT) column with string keys, read with
+  // MapKeyFilter extraction to keep only selected keys.
+  auto mapVector = makeMapVector<StringView, int64_t>(
+      {{{"a", 1}, {"b", 2}, {"c", 3}}, {{"a", 10}, {"d", 40}, {"b", 50}}});
+  auto vector = makeRowVector({"col"}, {mapVector});
+
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector});
+
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  auto outputType = ROW({"col"}, {MAP(VARCHAR(), BIGINT())});
+  std::vector<NamedExtraction> extractions = {
+      {"col",
+       {ExtractionPathElement::mapKeyFilter(
+           std::vector<std::string>{"a", "b"})},
+       MAP(VARCHAR(), BIGINT())}};
+
+  auto handle = std::make_shared<HiveColumnHandle>(
+      "col",
+      HiveColumnHandle::ColumnType::kRegular,
+      MAP(VARCHAR(), BIGINT()),
+      hiveType,
+      std::vector<common::Subfield>{},
+      std::move(extractions));
+
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(outputType)
+                  .assignments({{"col", handle}})
+                  .endTableScan()
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan)
+                    .split(makeHiveConnectorSplit(file->getPath()))
+                    .copyResults(pool_.get());
+
+  ASSERT_EQ(result->size(), 2);
+  auto* filteredMap = result->childAt(0)->as<MapVector>();
+  // Row 0: {"a":1, "b":2} kept, "c" filtered out.
+  ASSERT_EQ(filteredMap->sizeAt(0), 2);
+  // Row 1: {"a":10, "b":50} kept, "d" filtered out.
+  ASSERT_EQ(filteredMap->sizeAt(1), 2);
+}
+
+TEST_F(TableScanTest, extractionMapKeyFilterIntegerKeys) {
+  // Write a MAP(BIGINT, VARCHAR) column, read with MapKeyFilter using
+  // integer filter keys.
+  auto keys = makeFlatVector<int64_t>({10, 20, 30, 10, 40});
+  auto values = makeFlatVector<StringView>({"aa", "bb", "cc", "dd", "ee"});
+  auto mapVector = makeMapVector({0, 3}, keys, values);
+  auto vector = makeRowVector({"col"}, {mapVector});
+
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector});
+
+  auto hiveType = MAP(BIGINT(), VARCHAR());
+  auto outputType = ROW({"col"}, {MAP(BIGINT(), VARCHAR())});
+  std::vector<NamedExtraction> extractions = {
+      {"col",
+       {ExtractionPathElement::mapKeyFilter(std::vector<int64_t>{10, 30})},
+       MAP(BIGINT(), VARCHAR())}};
+
+  auto handle = std::make_shared<HiveColumnHandle>(
+      "col",
+      HiveColumnHandle::ColumnType::kRegular,
+      MAP(BIGINT(), VARCHAR()),
+      hiveType,
+      std::vector<common::Subfield>{},
+      std::move(extractions));
+
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(outputType)
+                  .assignments({{"col", handle}})
+                  .endTableScan()
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan)
+                    .split(makeHiveConnectorSplit(file->getPath()))
+                    .copyResults(pool_.get());
+
+  ASSERT_EQ(result->size(), 2);
+  auto* filteredMap = result->childAt(0)->as<MapVector>();
+  // Row 0: keys {10, 30} kept, 20 filtered out.
+  ASSERT_EQ(filteredMap->sizeAt(0), 2);
+  // Row 1: key {10} kept, 40 filtered out.
+  ASSERT_EQ(filteredMap->sizeAt(1), 1);
+}
+
+TEST_F(TableScanTest, extractionStructField) {
+  // Write a ROW(x: INT, y: VARCHAR) column, extract just field "x".
+  auto structVector = makeRowVector(
+      {"x", "y"},
+      {makeFlatVector<int32_t>({10, 20, 30}),
+       makeFlatVector<StringView>({"aa", "bb", "cc"})});
+  auto vector = makeRowVector({"col"}, {structVector});
+
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector});
+
+  auto hiveType = ROW({{"x", INTEGER()}, {"y", VARCHAR()}});
+  auto outputType = ROW({"col"}, {INTEGER()});
+  std::vector<NamedExtraction> extractions = {
+      {"col", {ExtractionPathElement::structField("x")}, INTEGER()}};
+
+  auto handle = std::make_shared<HiveColumnHandle>(
+      "col",
+      HiveColumnHandle::ColumnType::kRegular,
+      INTEGER(),
+      hiveType,
+      std::vector<common::Subfield>{},
+      std::move(extractions));
+
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(outputType)
+                  .assignments({{"col", handle}})
+                  .endTableScan()
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan)
+                    .split(makeHiveConnectorSplit(file->getPath()))
+                    .copyResults(pool_.get());
+
+  ASSERT_EQ(result->size(), 3);
+  auto expected =
+      makeRowVector({"col"}, {makeFlatVector<int32_t>({10, 20, 30})});
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(TableScanTest, extractionArrayElementsStructField) {
+  // Write an ARRAY(ROW(x: INT, y: INT)) column, extract the "x" field from
+  // each array element -> ARRAY(INT).
+  auto innerStruct = makeRowVector(
+      {"x", "y"},
+      {makeFlatVector<int32_t>({1, 2, 3, 4}),
+       makeFlatVector<int32_t>({10, 20, 30, 40})});
+  auto arrayVector = makeArrayVector({0, 2}, innerStruct);
+  auto vector = makeRowVector({"col"}, {arrayVector});
+
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector});
+
+  auto hiveType = ARRAY(ROW({{"x", INTEGER()}, {"y", INTEGER()}}));
+  auto outputType = ROW({"col"}, {ARRAY(INTEGER())});
+  std::vector<NamedExtraction> extractions = {
+      {"col",
+       {ExtractionPathElement::simple(ExtractionStep::kArrayElements),
+        ExtractionPathElement::structField("x")},
+       ARRAY(INTEGER())}};
+
+  auto handle = std::make_shared<HiveColumnHandle>(
+      "col",
+      HiveColumnHandle::ColumnType::kRegular,
+      ARRAY(INTEGER()),
+      hiveType,
+      std::vector<common::Subfield>{},
+      std::move(extractions));
+
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(outputType)
+                  .assignments({{"col", handle}})
+                  .endTableScan()
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan)
+                    .split(makeHiveConnectorSplit(file->getPath()))
+                    .copyResults(pool_.get());
+
+  ASSERT_EQ(result->size(), 2);
+  auto* resultArray = result->childAt(0)->as<ArrayVector>();
+  ASSERT_EQ(resultArray->sizeAt(0), 2);
+  ASSERT_EQ(resultArray->sizeAt(1), 2);
+  auto* elements = resultArray->elements()->as<FlatVector<int32_t>>();
+  ASSERT_EQ(elements->valueAt(0), 1);
+  ASSERT_EQ(elements->valueAt(1), 2);
+  ASSERT_EQ(elements->valueAt(2), 3);
+  ASSERT_EQ(elements->valueAt(3), 4);
+}
+
+TEST_F(TableScanTest, extractionArraySize) {
+  // Write an ARRAY(BIGINT) column, read with Size extraction.
+  auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3}, {4}, {5, 6}});
+  auto vector = makeRowVector({"col"}, {arrayVector});
+
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector});
+
+  auto hiveType = ARRAY(BIGINT());
+  auto outputType = ROW({"col"}, {BIGINT()});
+  std::vector<NamedExtraction> extractions = {
+      {"col",
+       {ExtractionPathElement::simple(ExtractionStep::kSize)},
+       BIGINT()}};
+
+  auto handle = std::make_shared<HiveColumnHandle>(
+      "col",
+      HiveColumnHandle::ColumnType::kRegular,
+      BIGINT(),
+      hiveType,
+      std::vector<common::Subfield>{},
+      std::move(extractions));
+
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(outputType)
+                  .assignments({{"col", handle}})
+                  .endTableScan()
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan)
+                    .split(makeHiveConnectorSplit(file->getPath()))
+                    .copyResults(pool_.get());
+
+  ASSERT_EQ(result->size(), 3);
+  auto expected = makeRowVector({"col"}, {makeFlatVector<int64_t>({3, 1, 2})});
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(TableScanTest, extractionMapValuesStructField) {
+  // Write MAP(VARCHAR, ROW(x: INT, y: INT)), extract values.x -> ARRAY(INT).
+  auto keys = makeFlatVector<StringView>({"a", "b", "c"});
+  auto structValues = makeRowVector(
+      {"x", "y"},
+      {makeFlatVector<int32_t>({10, 20, 30}),
+       makeFlatVector<int32_t>({100, 200, 300})});
+  auto mapVector = makeMapVector({0, 2}, keys, structValues);
+  auto vector = makeRowVector({"col"}, {mapVector});
+
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector});
+
+  auto hiveType = MAP(VARCHAR(), ROW({{"x", INTEGER()}, {"y", INTEGER()}}));
+  auto outputType = ROW({"col"}, {ARRAY(INTEGER())});
+  std::vector<NamedExtraction> extractions = {
+      {"col",
+       {ExtractionPathElement::simple(ExtractionStep::kMapValues),
+        ExtractionPathElement::simple(ExtractionStep::kArrayElements),
+        ExtractionPathElement::structField("x")},
+       ARRAY(INTEGER())}};
+
+  auto handle = std::make_shared<HiveColumnHandle>(
+      "col",
+      HiveColumnHandle::ColumnType::kRegular,
+      ARRAY(INTEGER()),
+      hiveType,
+      std::vector<common::Subfield>{},
+      std::move(extractions));
+
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(outputType)
+                  .assignments({{"col", handle}})
+                  .endTableScan()
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan)
+                    .split(makeHiveConnectorSplit(file->getPath()))
+                    .copyResults(pool_.get());
+
+  ASSERT_EQ(result->size(), 2);
+  auto* resultArray = result->childAt(0)->as<ArrayVector>();
+  ASSERT_EQ(resultArray->sizeAt(0), 2);
+  ASSERT_EQ(resultArray->sizeAt(1), 1);
+  auto* elements = resultArray->elements()->as<FlatVector<int32_t>>();
+  ASSERT_EQ(elements->valueAt(0), 10);
+  ASSERT_EQ(elements->valueAt(1), 20);
+  ASSERT_EQ(elements->valueAt(2), 30);
+}
+
+TEST_F(TableScanTest, extractionMultipleFromSameColumn) {
+  // Write MAP(VARCHAR, BIGINT), extract both keys and size.
+  auto mapVector =
+      makeMapVector<StringView, int64_t>({{{"a", 1}, {"b", 2}}, {{"c", 3}}});
+  auto vector = makeRowVector({"col"}, {mapVector});
+
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector});
+
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  auto keysType = ARRAY(VARCHAR());
+  auto sizeType = BIGINT();
+  auto rowOutputType = ROW({{"keys", keysType}, {"sz", sizeType}});
+  auto outputType = ROW({"col"}, {rowOutputType});
+
+  std::vector<NamedExtraction> extractions = {
+      {"keys",
+       {ExtractionPathElement::simple(ExtractionStep::kMapKeys)},
+       keysType},
+      {"sz", {ExtractionPathElement::simple(ExtractionStep::kSize)}, sizeType}};
+
+  auto handle = std::make_shared<HiveColumnHandle>(
+      "col",
+      HiveColumnHandle::ColumnType::kRegular,
+      rowOutputType,
+      hiveType,
+      std::vector<common::Subfield>{},
+      std::move(extractions));
+
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(outputType)
+                  .assignments({{"col", handle}})
+                  .endTableScan()
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan)
+                    .split(makeHiveConnectorSplit(file->getPath()))
+                    .copyResults(pool_.get());
+
+  ASSERT_EQ(result->size(), 2);
+  auto* outputRow = result->childAt(0)->as<RowVector>();
+  // Check sizes.
+  auto* sizes = outputRow->childAt(1)->as<FlatVector<int64_t>>();
+  ASSERT_EQ(sizes->valueAt(0), 2);
+  ASSERT_EQ(sizes->valueAt(1), 1);
+  // Check keys.
+  auto* keysArray = outputRow->childAt(0)->as<ArrayVector>();
+  ASSERT_EQ(keysArray->sizeAt(0), 2);
+  ASSERT_EQ(keysArray->sizeAt(1), 1);
+}
+
+TEST_F(TableScanTest, extractionWithRegularColumn) {
+  // Write two columns: a regular BIGINT and a MAP with extraction.
+  auto idColumn = makeFlatVector<int64_t>({100, 200, 300});
+  auto mapVector = makeMapVector<StringView, int64_t>(
+      {{{"x", 1}}, {{"y", 2}, {"z", 3}}, {{"w", 4}}});
+  auto vector = makeRowVector({"id", "m"}, {idColumn, mapVector});
+
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector});
+
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  auto outputType = ROW({"id", "m"}, {BIGINT(), ARRAY(VARCHAR())});
+  std::vector<NamedExtraction> extractions = {
+      {"m",
+       {ExtractionPathElement::simple(ExtractionStep::kMapKeys)},
+       ARRAY(VARCHAR())}};
+
+  auto extractionHandle = std::make_shared<HiveColumnHandle>(
+      "m",
+      HiveColumnHandle::ColumnType::kRegular,
+      ARRAY(VARCHAR()),
+      hiveType,
+      std::vector<common::Subfield>{},
+      std::move(extractions));
+
+  auto plan =
+      PlanBuilder()
+          .startTableScan()
+          .outputType(outputType)
+          .assignments(
+              {{"id", regularColumn("id", BIGINT())}, {"m", extractionHandle}})
+          .endTableScan()
+          .planNode();
+
+  auto result = AssertQueryBuilder(plan)
+                    .split(makeHiveConnectorSplit(file->getPath()))
+                    .copyResults(pool_.get());
+
+  ASSERT_EQ(result->size(), 3);
+  // Verify regular column.
+  auto* ids = result->childAt(0)->as<FlatVector<int64_t>>();
+  ASSERT_EQ(ids->valueAt(0), 100);
+  ASSERT_EQ(ids->valueAt(1), 200);
+  ASSERT_EQ(ids->valueAt(2), 300);
+  // Verify extracted keys.
+  auto* keysArray = result->childAt(1)->as<ArrayVector>();
+  ASSERT_EQ(keysArray->sizeAt(0), 1);
+  ASSERT_EQ(keysArray->sizeAt(1), 2);
+  ASSERT_EQ(keysArray->sizeAt(2), 1);
+}
+
+TEST_F(TableScanTest, extractionSizeAndMapKeyFilter) {
+  // Extract both kSize (full map length) and kMapKeyFilter (selected keys)
+  // from the same MAP column.  Size should reflect all entries while the
+  // filtered map should contain only the selected keys.
+  auto mapVector = makeMapVector<StringView, int64_t>(
+      {{{"a", 1}, {"b", 2}, {"c", 3}}, {{"a", 10}, {"d", 40}}});
+  auto vector = makeRowVector({"col"}, {mapVector});
+
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector});
+
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  auto sizeType = BIGINT();
+  auto filteredMapType = MAP(VARCHAR(), BIGINT());
+  auto rowOutputType = ROW({{"sz", sizeType}, {"filtered", filteredMapType}});
+  auto outputType = ROW({"col"}, {rowOutputType});
+
+  std::vector<NamedExtraction> extractions = {
+      {"sz", {ExtractionPathElement::simple(ExtractionStep::kSize)}, sizeType},
+      {"filtered",
+       {ExtractionPathElement::mapKeyFilter(
+           std::vector<std::string>{"a", "b"})},
+       filteredMapType}};
+
+  auto handle = std::make_shared<HiveColumnHandle>(
+      "col",
+      HiveColumnHandle::ColumnType::kRegular,
+      rowOutputType,
+      hiveType,
+      std::vector<common::Subfield>{},
+      std::move(extractions));
+
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(outputType)
+                  .assignments({{"col", handle}})
+                  .endTableScan()
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan)
+                    .split(makeHiveConnectorSplit(file->getPath()))
+                    .copyResults(pool_.get());
+
+  ASSERT_EQ(result->size(), 2);
+  auto* outputRow = result->childAt(0)->as<RowVector>();
+  // Check sizes — should be the full map lengths.
+  auto* sizes = outputRow->childAt(0)->as<FlatVector<int64_t>>();
+  ASSERT_EQ(sizes->valueAt(0), 3); // {"a","b","c"}
+  ASSERT_EQ(sizes->valueAt(1), 2); // {"a","d"}
+  // Check filtered map — only keys "a" and "b".
+  auto* filteredMap = outputRow->childAt(1)->as<MapVector>();
+  ASSERT_EQ(filteredMap->sizeAt(0), 2); // "a" and "b"
+  ASSERT_EQ(filteredMap->sizeAt(1), 1); // "a" only ("d" filtered out)
+}
+
+TEST_F(TableScanTest, extractionSizeLargeDataMultipleBatches) {
+  // Write enough data to produce multiple output batches.  Verify
+  // correctness across batches (implicitly tests result vector reuse
+  // since the reader reuses the FlatVector<int64_t> across batches).
+  constexpr int kNumRows = 10'000;
+  // Build map data: each row has (i%5)+1 entries.
+  vector_size_t totalEntries = 0;
+  for (int i = 0; i < kNumRows; ++i) {
+    totalEntries += (i % 5) + 1;
+  }
+  std::vector<std::string> keyStrs(totalEntries);
+  for (int i = 0; i < totalEntries; ++i) {
+    keyStrs[i] = std::to_string(i);
+  }
+  auto keys = makeFlatVector<StringView>(
+      totalEntries, [&](auto i) { return StringView(keyStrs[i]); });
+  auto values = makeFlatVector<int64_t>(totalEntries, folly::identity);
+  std::vector<vector_size_t> offsets(kNumRows);
+  vector_size_t offset = 0;
+  for (int i = 0; i < kNumRows; ++i) {
+    offsets[i] = offset;
+    offset += (i % 5) + 1;
+  }
+  auto mapVector = makeMapVector(offsets, keys, values);
+  auto vector = makeRowVector({"col"}, {mapVector});
+
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector});
+
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  auto outputType = ROW({"col"}, {BIGINT()});
+  std::vector<NamedExtraction> extractions = {
+      {"col",
+       {ExtractionPathElement::simple(ExtractionStep::kSize)},
+       BIGINT()}};
+
+  auto handle = std::make_shared<HiveColumnHandle>(
+      "col",
+      HiveColumnHandle::ColumnType::kRegular,
+      BIGINT(),
+      hiveType,
+      std::vector<common::Subfield>{},
+      std::move(extractions));
+
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(outputType)
+                  .assignments({{"col", handle}})
+                  .endTableScan()
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan)
+                    .split(makeHiveConnectorSplit(file->getPath()))
+                    .copyResults(pool_.get());
+
+  // Verify all rows are present with correct sizes.
+  ASSERT_EQ(result->size(), kNumRows);
+  auto* sizes = result->childAt(0)->as<FlatVector<int64_t>>();
+  for (int i = 0; i < kNumRows; ++i) {
+    ASSERT_EQ(sizes->valueAt(i), (i % 5) + 1) << "Incorrect size at row " << i;
+  }
+}
+
+TEST_F(TableScanTest, extractionDeeplyNestedChain) {
+  // Test deeply nested extraction on a MAP column:
+  //   MAP(VARCHAR, ROW(x: INT, y: ARRAY(BIGINT)))
+  //   Chain: MapValues -> ArrayElements -> StructField("y") -> Size
+  //   Output: ARRAY(BIGINT)
+  //
+  // With recursive ScanSpec configuration:
+  //   - MAP: kValues (reader skips decoding keys)
+  //   - ROW values: "x" pruned (reader skips decoding x)
+  //   - "y" ARRAY: kSize (reader skips decoding array elements)
+  // The effective remaining transform is just [StructField("y")] to extract
+  // the y field from the ROW.  Size is handled by kSize on the ScanSpec.
+
+  // MAP(VARCHAR, ROW(x: INT, y: ARRAY(BIGINT)))
+  // Row 0: {"k1" -> {x:1, y:[10,20]}, "k2" -> {x:2, y:[30]}}
+  // Row 1: {"k3" -> {x:3, y:[40,50,60]}}
+  auto mapKeys = makeFlatVector<StringView>({"k1", "k2", "k3"});
+  auto allInnerStructs = makeRowVector(
+      {"x", "y"},
+      {makeFlatVector<int32_t>({1, 2, 3}),
+       makeArrayVector<int64_t>({{10, 20}, {30}, {40, 50, 60}})});
+  auto mapVector = makeMapVector({0, 2}, mapKeys, allInnerStructs);
+  auto tableVector = makeRowVector({"col"}, {mapVector});
+
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {tableVector});
+
+  auto innerStructType = ROW({{"x", INTEGER()}, {"y", ARRAY(BIGINT())}});
+  auto hiveType = MAP(VARCHAR(), innerStructType);
+
+  // Extraction chain: MapValues -> ArrayElements -> StructField("y") -> Size
+  // Output type: ARRAY(BIGINT) — MapValues produces ARRAY(ROW(...)),
+  // ArrayElements enters each element, StructField("y") gets the array field,
+  // Size produces BIGINT.  The result is wrapped back into ARRAY(BIGINT).
+  auto outputColType = ARRAY(BIGINT());
+
+  std::vector<NamedExtraction> extractions = {
+      {"col",
+       {ExtractionPathElement::simple(ExtractionStep::kMapValues),
+        ExtractionPathElement::simple(ExtractionStep::kArrayElements),
+        ExtractionPathElement::structField("y"),
+        ExtractionPathElement::simple(ExtractionStep::kSize)},
+       outputColType}};
+
+  auto handle = std::make_shared<HiveColumnHandle>(
+      "col",
+      HiveColumnHandle::ColumnType::kRegular,
+      outputColType,
+      hiveType,
+      std::vector<common::Subfield>{},
+      std::move(extractions));
+
+  auto outputType = ROW({"col"}, {outputColType});
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(outputType)
+                  .assignments({{"col", handle}})
+                  .endTableScan()
+                  .planNode();
+
+  auto extractionTask =
+      AssertQueryBuilder(plan)
+          .config(core::QueryConfig::kMaxSplitPreloadPerDriver, "0")
+          .split(makeHiveConnectorSplit(file->getPath()))
+          .copyResults(pool_.get());
+
+  ASSERT_EQ(extractionTask->size(), 2);
+  auto* resultArray = extractionTask->childAt(0)->as<ArrayVector>();
+
+  // Row 0: map values are [{x:1,y:[10,20]}, {x:2,y:[30]}]
+  //   -> y sizes = [2, 1]
+  ASSERT_EQ(resultArray->sizeAt(0), 2);
+  auto* elements = resultArray->elements()->as<FlatVector<int64_t>>();
+  ASSERT_EQ(elements->valueAt(resultArray->offsetAt(0)), 2); // size of [10,20]
+  ASSERT_EQ(elements->valueAt(resultArray->offsetAt(0) + 1), 1); // size of [30]
+
+  // Row 1: map values are [{x:3,y:[40,50,60]}]
+  //   -> y sizes = [3]
+  ASSERT_EQ(resultArray->sizeAt(1), 1);
+  ASSERT_EQ(
+      elements->valueAt(resultArray->offsetAt(1)), 3); // size of [40,50,60]
+
+  // I/O reduction is validated at the reader level in
+  // TestReader.extractionMapKeysIoReduction (ReaderTest.cpp).
+  // Recursive ScanSpec pushdown skips decoding map keys, struct field "x",
+  // and array element data — only map/array lengths and "y" lengths are read.
+}
+
+TEST_F(TableScanTest, extractionMultipleFormatsMultipleSplits) {
+  // Test processing DWRF, TEXT, DWRF splits with MapKeys extraction in a
+  // single table scan.  Exercises the extraction code path across format
+  // switches within a single split reader.
+
+  // Data: MAP(VARCHAR, BIGINT) with 2 rows.
+  auto mapVector =
+      makeMapVector<StringView, int64_t>({{{"a", 1}, {"b", 2}}, {{"c", 3}}});
+  auto vector = makeRowVector({"col"}, {mapVector});
+
+  // Write DWRF files for splits 1 and 3.
+  auto dwrfFile1 = TempFilePath::create();
+  auto dwrfFile2 = TempFilePath::create();
+  writeToFile(dwrfFile1->getPath(), {vector});
+  writeToFile(dwrfFile2->getPath(), {vector});
+
+  // Write TEXT file for split 2.  Text format uses field/collection/map-key
+  // delimiters.  The same 2 rows: {"a":1,"b":2} and {"c":3}.
+  auto textFile = TempFilePath::create();
+  {
+    // TempFilePath already created the file; open for truncating write.
+    auto writeFile =
+        std::make_unique<LocalWriteFile>(textFile->getPath(), true, false);
+    // Row format: map entries separated by \x02, key-value by \x03.
+    writeFile->append(
+        "a\x03"
+        "1\x02"
+        "b\x03"
+        "2\nc\x03"
+        "3\n");
+    writeFile->close();
+  }
+
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  auto outputType = ROW({"col"}, {ARRAY(VARCHAR())});
+  auto dataColumns = ROW({"col"}, {hiveType});
+  std::vector<NamedExtraction> extractions = {
+      {"col",
+       {ExtractionPathElement::simple(ExtractionStep::kMapKeys)},
+       ARRAY(VARCHAR())}};
+
+  auto handle = std::make_shared<HiveColumnHandle>(
+      "col",
+      HiveColumnHandle::ColumnType::kRegular,
+      ARRAY(VARCHAR()),
+      hiveType,
+      std::vector<common::Subfield>{},
+      std::move(extractions));
+
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .dataColumns(dataColumns)
+                  .outputType(outputType)
+                  .assignments({{"col", handle}})
+                  .endTableScan()
+                  .planNode();
+
+  // TEXT split with serde parameters for delimiters.
+  std::unordered_map<std::string, std::string> serdeParameters{
+      {dwio::common::SerDeOptions::kFieldDelim, "\x01"},
+      {dwio::common::SerDeOptions::kCollectionDelim, "\x02"},
+      {dwio::common::SerDeOptions::kMapKeyDelim, "\x03"}};
+  auto textSplit = std::make_shared<connector::hive::HiveConnectorSplit>(
+      kHiveConnectorId,
+      textFile->getPath(),
+      dwio::common::FileFormat::TEXT,
+      0,
+      std::numeric_limits<uint64_t>::max(),
+      std::unordered_map<std::string, std::optional<std::string>>{},
+      std::nullopt,
+      std::unordered_map<std::string, std::string>{},
+      nullptr,
+      serdeParameters);
+
+  // Process 3 splits: DWRF, TEXT, DWRF.  Disable split preloading to ensure
+  // all splits are processed by a single split reader.
+  auto result = AssertQueryBuilder(plan)
+                    .config(core::QueryConfig::kMaxSplitPreloadPerDriver, "0")
+                    .split(makeHiveConnectorSplit(dwrfFile1->getPath()))
+                    .split(exec::Split(textSplit))
+                    .split(makeHiveConnectorSplit(dwrfFile2->getPath()))
+                    .copyResults(pool_.get());
+
+  // 2 rows per split × 3 splits = 6 rows total.
+  ASSERT_EQ(result->size(), 6);
+  auto* resultArray = result->childAt(0)->as<ArrayVector>();
+  for (int split = 0; split < 3; ++split) {
+    ASSERT_EQ(resultArray->sizeAt(split * 2), 2);
+    ASSERT_EQ(resultArray->sizeAt(split * 2 + 1), 1);
+  }
+}
+
+TEST_F(TableScanTest, extractionMultipleExtractionsTextFormat) {
+  // Test multiple extractions (MapKeys + Size) on a MAP column read from a
+  // TEXT format split.  With multiple extractions, ExtractionType stays as
+  // kNone and full chains are used in the transform.
+
+  // Data: MAP(VARCHAR, BIGINT) with 2 rows.
+  //   Row 0: {"a":1, "b":2}
+  //   Row 1: {"c":3}
+  auto textFile = TempFilePath::create();
+  {
+    auto writeFile =
+        std::make_unique<LocalWriteFile>(textFile->getPath(), true, false);
+    // Row format: map entries separated by \x02, key-value by \x03.
+    writeFile->append(
+        "a\x03"
+        "1\x02"
+        "b\x03"
+        "2\nc\x03"
+        "3\n");
+    writeFile->close();
+  }
+
+  auto hiveType = MAP(VARCHAR(), BIGINT());
+  // Output: ROW(keys: ARRAY(VARCHAR), size: BIGINT)
+  auto outputColType = ROW({"keys", "size"}, {ARRAY(VARCHAR()), BIGINT()});
+  auto dataColumns = ROW({"col"}, {hiveType});
+  std::vector<NamedExtraction> extractions = {
+      {"keys",
+       {ExtractionPathElement::simple(ExtractionStep::kMapKeys)},
+       ARRAY(VARCHAR())},
+      {"size",
+       {ExtractionPathElement::simple(ExtractionStep::kSize)},
+       BIGINT()}};
+
+  auto handle = std::make_shared<HiveColumnHandle>(
+      "col",
+      HiveColumnHandle::ColumnType::kRegular,
+      outputColType,
+      hiveType,
+      std::vector<common::Subfield>{},
+      std::move(extractions));
+
+  auto outputType = ROW({"col"}, {outputColType});
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .dataColumns(dataColumns)
+                  .outputType(outputType)
+                  .assignments({{"col", handle}})
+                  .endTableScan()
+                  .planNode();
+
+  std::unordered_map<std::string, std::string> serdeParameters{
+      {dwio::common::SerDeOptions::kFieldDelim, "\x01"},
+      {dwio::common::SerDeOptions::kCollectionDelim, "\x02"},
+      {dwio::common::SerDeOptions::kMapKeyDelim, "\x03"}};
+  auto textSplit = std::make_shared<connector::hive::HiveConnectorSplit>(
+      kHiveConnectorId,
+      textFile->getPath(),
+      dwio::common::FileFormat::TEXT,
+      0,
+      std::numeric_limits<uint64_t>::max(),
+      std::unordered_map<std::string, std::optional<std::string>>{},
+      std::nullopt,
+      std::unordered_map<std::string, std::string>{},
+      nullptr,
+      serdeParameters);
+
+  auto result = AssertQueryBuilder(plan)
+                    .config(core::QueryConfig::kMaxSplitPreloadPerDriver, "0")
+                    .split(exec::Split(textSplit))
+                    .copyResults(pool_.get());
+
+  ASSERT_EQ(result->size(), 2);
+  // Output is a single column "col" of type ROW{keys, size}.
+  auto* outerRow = result->childAt(0)->as<RowVector>();
+  ASSERT_NE(outerRow, nullptr);
+
+  // Verify keys (ARRAY(VARCHAR)).
+  auto* keysArray = outerRow->childAt(0)->as<ArrayVector>();
+  ASSERT_EQ(keysArray->sizeAt(0), 2); // Row 0: {"a", "b"}
+  ASSERT_EQ(keysArray->sizeAt(1), 1); // Row 1: {"c"}
+
+  // Verify size (BIGINT).
+  auto* sizeVector = outerRow->childAt(1)->as<FlatVector<int64_t>>();
+  ASSERT_EQ(sizeVector->valueAt(0), 2); // Row 0: 2 entries
+  ASSERT_EQ(sizeVector->valueAt(1), 1); // Row 1: 1 entry
+}
+
 } // namespace
 } // namespace facebook::velox::exec
diff --git a/velox/exec/tests/TableWriterTest.cpp b/velox/exec/tests/TableWriterTest.cpp
index 2b91f729c37..fd8c79865f9 100644
--- a/velox/exec/tests/TableWriterTest.cpp
+++ b/velox/exec/tests/TableWriterTest.cpp
@@ -19,33 +19,33 @@
 #include "folly/dynamic.h"
 #include "velox/common/base/Fs.h"
 #include "velox/common/base/tests/GTestUtils.h"
-#include "velox/common/hyperloglog/SparseHll.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/connectors/hive/HiveConfig.h"
-#include "velox/connectors/hive/HivePartitionFunction.h"
 #include "velox/dwio/common/WriterFactory.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/TableWriter.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
 #include <re2/re2.h>
 #include <string>
-#include "folly/experimental/EventCount.h"
+#include "folly/synchronization/EventCount.h"
 #include "velox/common/memory/MemoryArbitrator.h"
 #include "velox/dwio/common/Options.h"
 #include "velox/dwio/dwrf/writer/Writer.h"
 #include "velox/exec/tests/utils/ArbitratorTestUtil.h"
 
 namespace velox::exec::test {
+using namespace facebook::velox::common::testutil;
+
 constexpr uint64_t kQueryMemoryCapacity = 512 * MB;
 
-class BasicTableWriterTestBase : public HiveConnectorTestBase {};
+class BasicTableWriterTest : public HiveConnectorTestBase {};
 
-TEST_F(BasicTableWriterTestBase, roundTrip) {
+TEST_F(BasicTableWriterTest, roundTrip) {
   vector_size_t size = 1'000;
   auto data = makeRowVector({
       makeFlatVector<int32_t>(size, [](auto row) { return row; }),
@@ -82,7 +82,7 @@ TEST_F(BasicTableWriterTestBase, roundTrip) {
                      ->as<FlatVector<StringView>>();
   ASSERT_TRUE(details->isNullAt(0));
   ASSERT_FALSE(details->isNullAt(1));
-  folly::dynamic obj = folly::parseJson(details->valueAt(1));
+  folly::dynamic obj = folly::parseJson(std::string_view(details->valueAt(1)));
 
   ASSERT_EQ(size, obj["rowCount"].asInt());
   auto fileWriteInfos = obj["fileWriteInfos"];
@@ -93,16 +93,18 @@ TEST_F(BasicTableWriterTestBase, roundTrip) {
   // Read from 'writeFileName' and verify the data matches the original.
   plan = PlanBuilder().tableScan(rowType).planNode();
 
-  auto copy = AssertQueryBuilder(plan)
-                  .split(makeHiveConnectorSplit(fmt::format(
-                      "{}/{}", targetDirectoryPath->getPath(), writeFileName)))
-                  .copyResults(pool());
+  auto copy =
+      AssertQueryBuilder(plan)
+          .split(makeHiveConnectorSplit(
+              fmt::format(
+                  "{}/{}", targetDirectoryPath->getPath(), writeFileName)))
+          .copyResults(pool());
   assertEqualResults({data}, {copy});
 }
 
 // Generates a struct (row), write it as a flap map, and check that it is read
 // back as a map.
-TEST_F(BasicTableWriterTestBase, structAsMap) {
+TEST_F(BasicTableWriterTest, structAsMap) {
   // Input struct type.
   vector_size_t size = 1'000;
   auto data = makeRowVector(
@@ -162,7 +164,7 @@ TEST_F(BasicTableWriterTestBase, structAsMap) {
       .assertResults(expected);
 }
 
-TEST_F(BasicTableWriterTestBase, targetFileName) {
+TEST_F(BasicTableWriterTest, targetFileName) {
   constexpr const char* kFileName = "test.dwrf";
   auto data = makeRowVector({makeFlatVector<int64_t>(10, folly::identity)});
   auto directory = TempDirectoryPath::create();
@@ -178,7 +180,7 @@ TEST_F(BasicTableWriterTestBase, targetFileName) {
   auto results = AssertQueryBuilder(plan).copyResults(pool());
   auto* details = results->childAt(TableWriteTraits::kFragmentChannel)
                       ->asUnchecked<SimpleVector<StringView>>();
-  auto detail = folly::parseJson(details->valueAt(1));
+  auto detail = folly::parseJson(std::string_view(details->valueAt(1)));
   auto fileWriteInfos = detail["fileWriteInfos"];
   ASSERT_EQ(1, fileWriteInfos.size());
   ASSERT_EQ(fileWriteInfos[0]["writeFileName"].asString(), kFileName);
@@ -205,66 +207,72 @@ class PartitionedTableWriterTest
     for (bool multiDrivers : multiDriverOptions) {
       for (FileFormat fileFormat : fileFormats) {
         for (bool scaleWriter : {false, true}) {
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kPartitioned,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kPartitioned,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kBucketed,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kBucketed,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kBucketed,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kPrestoNative,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kBucketed,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kPrestoNative,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kPartitioned,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kPartitioned,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kBucketed,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kBucketed,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kBucketed,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kPrestoNative,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kBucketed,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kPrestoNative,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
         }
       }
     }
@@ -288,26 +296,28 @@ class UnpartitionedTableWriterTest
     for (bool multiDrivers : multiDriverOptions) {
       for (FileFormat fileFormat : fileFormats) {
         for (bool scaleWriter : {false, true}) {
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kUnpartitioned,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_NONE,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kUnpartitioned,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_NONE,
-              scaleWriter}
-                                   .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kUnpartitioned,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_NONE,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kUnpartitioned,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_NONE,
+                  scaleWriter}
+                  .value);
         }
       }
     }
@@ -331,26 +341,28 @@ class BucketedUnpartitionedTableWriterTest
     const std::vector<TestMode> bucketModes = {TestMode::kOnlyBucketed};
     for (bool multiDrivers : multiDriverOptions) {
       for (FileFormat fileFormat : fileFormats) {
-        testParams.push_back(TestParam{
-            fileFormat,
-            TestMode::kOnlyBucketed,
-            CommitStrategy::kNoCommit,
-            HiveBucketProperty::Kind::kHiveCompatible,
-            true,
-            multiDrivers,
-            facebook::velox::common::CompressionKind_ZSTD,
-            /*scaleWriter=*/false}
-                                 .value);
-        testParams.push_back(TestParam{
-            fileFormat,
-            TestMode::kOnlyBucketed,
-            CommitStrategy::kTaskCommit,
-            HiveBucketProperty::Kind::kHiveCompatible,
-            true,
-            multiDrivers,
-            facebook::velox::common::CompressionKind_NONE,
-            /*scaleWriter=*/false}
-                                 .value);
+        testParams.push_back(
+            TestParam{
+                fileFormat,
+                TestMode::kOnlyBucketed,
+                CommitStrategy::kNoCommit,
+                HiveBucketProperty::Kind::kHiveCompatible,
+                true,
+                multiDrivers,
+                facebook::velox::common::CompressionKind_ZSTD,
+                /*scaleWriter=*/false}
+                .value);
+        testParams.push_back(
+            TestParam{
+                fileFormat,
+                TestMode::kOnlyBucketed,
+                CommitStrategy::kTaskCommit,
+                HiveBucketProperty::Kind::kHiveCompatible,
+                true,
+                multiDrivers,
+                facebook::velox::common::CompressionKind_NONE,
+                /*scaleWriter=*/false}
+                .value);
       }
     }
     return testParams;
@@ -375,76 +387,83 @@ class BucketedTableOnlyWriteTest
     for (bool multiDrivers : multiDriverOptions) {
       for (FileFormat fileFormat : fileFormats) {
         for (auto bucketMode : bucketModes) {
-          testParams.push_back(TestParam{
-              fileFormat,
-              bucketMode,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              /*scaleWriter=*/false}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              bucketMode,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              true,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              /*scaleWriter=*/false}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              bucketMode,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              /*scaleWriter=*/false}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              bucketMode,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              true,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              /*scaleWriter=*/false}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              bucketMode,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kPrestoNative,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              /*scaleWriter=*/false}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              bucketMode,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kPrestoNative,
-              true,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              /*scaleWriter=*/false}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              bucketMode,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kPrestoNative,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              /*scaleWriter=*/false}
-                                   .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  bucketMode,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  /*scaleWriter=*/false}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  bucketMode,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  true,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  /*scaleWriter=*/false}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  bucketMode,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  /*scaleWriter=*/false}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  bucketMode,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  true,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  /*scaleWriter=*/false}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  bucketMode,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kPrestoNative,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  /*scaleWriter=*/false}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  bucketMode,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kPrestoNative,
+                  true,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  /*scaleWriter=*/false}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  bucketMode,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kPrestoNative,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  /*scaleWriter=*/false}
+                  .value);
         }
       }
     }
@@ -470,26 +489,28 @@ class BucketSortOnlyTableWriterTest
     for (bool multiDrivers : multiDriverOptions) {
       for (FileFormat fileFormat : fileFormats) {
         for (auto bucketMode : bucketModes) {
-          testParams.push_back(TestParam{
-              fileFormat,
-              bucketMode,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              true,
-              multiDrivers,
-              facebook::velox::common::CompressionKind_ZSTD,
-              /*scaleWriter=*/false}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              bucketMode,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              true,
-              multiDrivers,
-              facebook::velox::common::CompressionKind_NONE,
-              /*scaleWriter=*/false}
-                                   .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  bucketMode,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  true,
+                  multiDrivers,
+                  facebook::velox::common::CompressionKind_ZSTD,
+                  /*scaleWriter=*/false}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  bucketMode,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  true,
+                  multiDrivers,
+                  facebook::velox::common::CompressionKind_NONE,
+                  /*scaleWriter=*/false}
+                  .value);
         }
       }
     }
@@ -513,26 +534,28 @@ class PartitionedWithoutBucketTableWriterTest
     for (bool multiDrivers : multiDriverOptions) {
       for (FileFormat fileFormat : fileFormats) {
         for (bool scaleWriter : {false, true}) {
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kPartitioned,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kPartitioned,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kPartitioned,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kPartitioned,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
         }
       }
     }
@@ -555,126 +578,138 @@ class AllTableWriterTest : public TableWriterTestBase,
     for (bool multiDrivers : multiDriverOptions) {
       for (FileFormat fileFormat : fileFormats) {
         for (bool scaleWriter : {false, true}) {
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kUnpartitioned,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kUnpartitioned,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kPartitioned,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kPartitioned,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kBucketed,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kBucketed,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kBucketed,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kPrestoNative,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kBucketed,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kPrestoNative,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kOnlyBucketed,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kOnlyBucketed,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kOnlyBucketed,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kPrestoNative,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kOnlyBucketed,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kPrestoNative,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kUnpartitioned,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kUnpartitioned,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kPartitioned,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kPartitioned,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kBucketed,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kBucketed,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kBucketed,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kPrestoNative,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kBucketed,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kPrestoNative,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kOnlyBucketed,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kOnlyBucketed,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kOnlyBucketed,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kPrestoNative,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kOnlyBucketed,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kPrestoNative,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
         }
       }
     }
@@ -1523,10 +1558,16 @@ TEST_P(UnpartitionedTableWriterTest, runtimeStatsCheck) {
     }
     ASSERT_EQ(
         stats[1].runtimeStats["stripeSize"].count, testData.expectedNumStripes);
-    ASSERT_EQ(stats[1].runtimeStats[TableWriter::kNumWrittenFiles].sum, 1);
-    ASSERT_EQ(stats[1].runtimeStats[TableWriter::kNumWrittenFiles].count, 1);
-    ASSERT_GE(stats[1].runtimeStats[TableWriter::kWriteIOTime].sum, 0);
-    ASSERT_EQ(stats[1].runtimeStats[TableWriter::kWriteIOTime].count, 1);
+    ASSERT_EQ(
+        stats[1].runtimeStats[std::string(TableWriter::kNumWrittenFiles)].sum,
+        1);
+    ASSERT_EQ(
+        stats[1].runtimeStats[std::string(TableWriter::kNumWrittenFiles)].count,
+        1);
+    ASSERT_GE(
+        stats[1].runtimeStats[std::string(TableWriter::kWriteIOTime)].sum, 0);
+    ASSERT_EQ(
+        stats[1].runtimeStats[std::string(TableWriter::kWriteIOTime)].count, 1);
   }
 }
 
@@ -1782,7 +1823,8 @@ TEST_P(AllTableWriterTest, tableWriteOutputCheck) {
     }
     if (!fragmentVector->isNullAt(i)) {
       ASSERT_FALSE(fragmentVector->isNullAt(i));
-      folly::dynamic obj = folly::parseJson(fragmentVector->valueAt(i));
+      folly::dynamic obj =
+          folly::parseJson(std::string_view(fragmentVector->valueAt(i)));
       if (testMode_ == TestMode::kUnpartitioned) {
         ASSERT_EQ(obj["targetPath"], outputDirectory->getPath());
         ASSERT_EQ(obj["writePath"], outputDirectory->getPath());
@@ -1791,13 +1833,17 @@ TEST_P(AllTableWriterTest, tableWriteOutputCheck) {
         for (const auto& partitionBy : partitionedBy_) {
           partitionDirRe += fmt::format("/{}=.+", partitionBy);
         }
-        ASSERT_TRUE(RE2::FullMatch(
-            obj["targetPath"].asString(),
-            fmt::format("{}{}", outputDirectory->getPath(), partitionDirRe)))
+        ASSERT_TRUE(
+            RE2::FullMatch(
+                obj["targetPath"].asString(),
+                fmt::format(
+                    "{}{}", outputDirectory->getPath(), partitionDirRe)))
             << obj["targetPath"].asString();
-        ASSERT_TRUE(RE2::FullMatch(
-            obj["writePath"].asString(),
-            fmt::format("{}{}", outputDirectory->getPath(), partitionDirRe)))
+        ASSERT_TRUE(
+            RE2::FullMatch(
+                obj["writePath"].asString(),
+                fmt::format(
+                    "{}{}", outputDirectory->getPath(), partitionDirRe)))
             << obj["writePath"].asString();
       }
       numRows += obj["rowCount"].asInt();
@@ -1822,7 +1868,7 @@ TEST_P(AllTableWriterTest, tableWriteOutputCheck) {
         ASSERT_EQ(writeFileName, targetFileName);
       } else {
         const std::string kParquetSuffix = ".parquet";
-        if (folly::StringPiece(targetFileName).endsWith(kParquetSuffix)) {
+        if (targetFileName.ends_with(kParquetSuffix)) {
           // Remove the .parquet suffix.
           auto trimmedFilename = targetFileName.substr(
               0, targetFileName.size() - kParquetSuffix.size());
@@ -1833,9 +1879,11 @@ TEST_P(AllTableWriterTest, tableWriteOutputCheck) {
       }
     }
     if (!commitContextVector->isNullAt(i)) {
-      ASSERT_TRUE(RE2::FullMatch(
-          commitContextVector->valueAt(i).getString(),
-          fmt::format(".*{}.*", CommitStrategyName::toName(commitStrategy_))))
+      ASSERT_TRUE(
+          RE2::FullMatch(
+              commitContextVector->valueAt(i).getString(),
+              fmt::format(
+                  ".*{}.*", CommitStrategyName::toName(commitStrategy_))))
           << commitContextVector->valueAt(i);
     }
   }
@@ -1904,8 +1952,9 @@ TEST_P(AllTableWriterTest, columnStatsDataTypes) {
   std::vector<FieldAccessTypedExprPtr> groupingKeyFields;
   groupingKeyFields.reserve(partitionedBy_.size());
   for (int i = 0; i < partitionedBy_.size(); ++i) {
-    groupingKeyFields.emplace_back(std::make_shared<core::FieldAccessTypedExpr>(
-        partitionTypes_.at(i), partitionedBy_.at(i)));
+    groupingKeyFields.emplace_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            partitionTypes_.at(i), partitionedBy_.at(i)));
   }
 
   // aggregation node
@@ -2025,7 +2074,7 @@ TEST_P(AllTableWriterTest, columnStatsDataTypes) {
   const auto distinctCountStatsVector =
       result->childAt(nextColumnStatsIndex++)->asFlatVector<StringView>();
   HashStringAllocator allocator{pool_.get()};
-  DenseHll denseHll{
+  DenseHll<> denseHll{
       std::string(distinctCountStatsVector->valueAt(0)).c_str(), &allocator};
   ASSERT_EQ(denseHll.cardinality(), 1000);
   const auto maxDataSizeStatsVector =
@@ -2245,6 +2294,301 @@ TEST_P(AllTableWriterTest, columnStatsWithTableWriteMerge) {
   }
 }
 
+// Verifies TableWriteMerge with kFinal step and multiple drivers.
+// Each driver runs TableWrite(kPartial), LocalGather collects, and
+// TableWriteMerge(kFinal) produces final statistics.
+TEST_F(BasicTableWriterTest, columnStatsWithTableWriteMergeFinal) {
+  auto outputDirectory = TempDirectoryPath::create();
+  auto input = makeRowVector({
+      makeFlatVector<int32_t>(100, folly::identity),
+  });
+
+  // Stats columns: min(c0), max(c0) at channels 3 and 4.
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .tableWrite(
+                      outputDirectory->getPath(),
+                      dwio::common::FileFormat::DWRF,
+                      {"min(c0)", "max(c0)"})
+                  .localGather()
+                  .tableWriteMerge(core::AggregationNode::Step::kFinal)
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan).maxDrivers(4).copyResults(pool());
+  ASSERT_GT(result->size(), 0);
+
+  // Verify the output: expect fragment rows, one stats row with values,
+  // and one summary row with the total row count.
+  auto* rowCountVector = result->childAt(TableWriteTraits::kRowCountChannel)
+                             ->as<SimpleVector<int64_t>>();
+  // Stats columns start at kStatsChannel: min(c0) at +0, max(c0) at +1.
+  auto* minVector = result->childAt(TableWriteTraits::kStatsChannel)
+                        ->as<SimpleVector<int32_t>>();
+  auto* maxVector = result->childAt(TableWriteTraits::kStatsChannel + 1)
+                        ->as<SimpleVector<int32_t>>();
+
+  int32_t numFragments = 0;
+  int32_t numStatsWithValues = 0;
+  int32_t numSummary = 0;
+  for (vector_size_t i = 0; i < result->size(); ++i) {
+    if (!result->childAt(TableWriteTraits::kFragmentChannel)->isNullAt(i)) {
+      ++numFragments;
+    } else if (!minVector->isNullAt(i)) {
+      ++numStatsWithValues;
+      EXPECT_EQ(0, minVector->valueAt(i));
+      EXPECT_EQ(99, maxVector->valueAt(i));
+    } else if (!rowCountVector->isNullAt(i)) {
+      ++numSummary;
+      EXPECT_EQ(100, rowCountVector->valueAt(i));
+    } else {
+      FAIL() << "Unexpected row " << i << ": " << result->toString(i);
+    }
+  }
+
+  EXPECT_EQ(1, numFragments);
+  EXPECT_EQ(1, numStatsWithValues);
+  EXPECT_EQ(1, numSummary);
+}
+
+// Same as above but with a partition key as grouping key for stats.
+TEST_F(BasicTableWriterTest, columnStatsWithTableWriteMergeFinalPartitioned) {
+  auto outputDirectory = TempDirectoryPath::create();
+  auto input = makeRowVector({
+      makeFlatVector<int32_t>(100, folly::identity),
+      makeFlatVector<int32_t>(100, [](auto row) { return row % 3; }),
+  });
+
+  // Partition by c1, collect min/max on c0 grouped by c1.
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .tableWrite(
+                      outputDirectory->getPath(),
+                      {"c1"},
+                      dwio::common::FileFormat::DWRF,
+                      {"min(c0)", "max(c0)"})
+                  .localGather()
+                  .tableWriteMerge(core::AggregationNode::Step::kFinal)
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan).maxDrivers(4).copyResults(pool());
+  ASSERT_GT(result->size(), 0);
+
+  // With 3 partitions, expect 3 stats rows (one per partition key value).
+  auto* rowCountVector = result->childAt(TableWriteTraits::kRowCountChannel)
+                             ->as<SimpleVector<int64_t>>();
+  // Partition key is at kStatsChannel, stats start at kStatsChannel + 1.
+  auto* partKeyVector = result->childAt(TableWriteTraits::kStatsChannel)
+                            ->as<SimpleVector<int32_t>>();
+  auto* minVector = result->childAt(TableWriteTraits::kStatsChannel + 1)
+                        ->as<SimpleVector<int32_t>>();
+  auto* maxVector = result->childAt(TableWriteTraits::kStatsChannel + 2)
+                        ->as<SimpleVector<int32_t>>();
+
+  // Input: c0 = 0..99, c1 = c0 % 3. Per-partition min/max of c0:
+  //   partition 0: min=0, max=99
+  //   partition 1: min=1, max=97
+  //   partition 2: min=2, max=98
+  std::map<int32_t, std::pair<int32_t, int32_t>> expectedStats = {
+      {0, {0, 99}}, {1, {1, 97}}, {2, {2, 98}}};
+
+  int32_t numFragments = 0;
+  int32_t numSummary = 0;
+  for (vector_size_t i = 0; i < result->size(); ++i) {
+    if (!result->childAt(TableWriteTraits::kFragmentChannel)->isNullAt(i)) {
+      ++numFragments;
+    } else if (!minVector->isNullAt(i)) {
+      ASSERT_FALSE(partKeyVector->isNullAt(i));
+      auto partKey = partKeyVector->valueAt(i);
+      auto it = expectedStats.find(partKey);
+      ASSERT_NE(it, expectedStats.end())
+          << "Unexpected or duplicate stats key: " << partKey;
+      EXPECT_EQ(it->second.first, minVector->valueAt(i));
+      EXPECT_EQ(it->second.second, maxVector->valueAt(i));
+      expectedStats.erase(it);
+    } else if (!rowCountVector->isNullAt(i)) {
+      ++numSummary;
+      EXPECT_EQ(100, rowCountVector->valueAt(i));
+    } else {
+      FAIL() << "Unexpected row " << i << ": " << result->toString(i);
+    }
+  }
+
+  EXPECT_EQ(3, numFragments);
+  EXPECT_TRUE(expectedStats.empty())
+      << "Missing stats: " << expectedStats.size();
+  EXPECT_EQ(1, numSummary);
+}
+
+// Extracts file paths from a fragment JSON object.
+std::vector<std::string> extractFragmentFiles(const folly::dynamic& fragment) {
+  std::vector<std::string> files;
+  auto targetPath = fragment["targetPath"].asString();
+  for (const auto& fileInfo : fragment["fileWriteInfos"]) {
+    files.push_back(
+        fmt::format(
+            "{}/{}", targetPath, fileInfo["targetFileName"].asString()));
+  }
+  return files;
+}
+
+// Builds a kFinal ColumnStatsSpec from a worker plan's kIntermediate spec.
+// The input type is used to resolve aggregate input column references.
+core::ColumnStatsSpec makeFinalStatsSpec(
+    const core::PlanNodePtr& workerPlan,
+    const RowType& inputType) {
+  auto mergeNode =
+      std::dynamic_pointer_cast<const core::TableWriteMergeNode>(workerPlan);
+  VELOX_CHECK_NOT_NULL(mergeNode);
+  VELOX_CHECK(mergeNode->hasColumnStatsSpec());
+
+  auto spec = mergeNode->columnStatsSpec().value();
+  spec.aggregationStep = core::AggregationNode::Step::kFinal;
+  for (size_t i = 0; i < spec.aggregates.size(); ++i) {
+    auto& aggregate = spec.aggregates[i];
+    const auto& name = spec.aggregateNames[i];
+    aggregate.call = std::make_shared<core::CallTypedExpr>(
+        aggregate.call->type(),
+        aggregate.call->name(),
+        std::make_shared<core::FieldAccessTypedExpr>(
+            inputType.findChild(name), name));
+  }
+  return spec;
+}
+
+// Simulates multi-node table write stats merging:
+// 1. Runs worker plan twice on different inputs (simulating 2 workers):
+//    Values → RoundRobinPartition → TableWrite(kPartial) → LocalGather →
+//    TableWriteMerge(kIntermediate)
+// 2. Collects all worker outputs and feeds them to a coordinator plan:
+//    Values(allWorkerOutputs) → TableWriteMerge(kFinal)
+// This tests mixed stats/data batches, cross-worker merge with different
+// taskIds, and dictionary-encoded input handling.
+TEST_F(BasicTableWriterTest, columnStatsWithTwoStageMerge) {
+  // Run worker plan on 2 different inputs (simulating 2 workers).
+  // Worker 1: c0 = 0..49, Worker 2: c0 = 50..99.
+  std::vector<RowVectorPtr> workerInputs = {
+      makeRowVector({makeFlatVector<int32_t>(50, folly::identity)}),
+      makeRowVector(
+          {makeFlatVector<int32_t>(50, [](auto row) { return row + 50; })}),
+  };
+
+  core::PlanNodePtr workerPlan;
+  std::vector<RowVectorPtr> allWorkerOutputs;
+  std::vector<std::shared_ptr<TempDirectoryPath>> outputDirectories;
+  for (const auto& input : workerInputs) {
+    // Each worker writes to a separate directory.
+    auto outputDirectory = TempDirectoryPath::create();
+    outputDirectories.push_back(outputDirectory);
+    workerPlan = PlanBuilder()
+                     .values(split(input, 4))
+                     .localPartitionRoundRobin()
+                     .tableWrite(
+                         outputDirectory->getPath(),
+                         dwio::common::FileFormat::DWRF,
+                         {"min(c0)", "max(c0)"})
+                     .localGather()
+                     .tableWriteMerge()
+                     .planNode();
+
+    auto workerResult =
+        AssertQueryBuilder(workerPlan).maxDrivers(4).copyResults(pool());
+    ASSERT_GT(workerResult->size(), 0);
+    allWorkerOutputs.push_back(workerResult);
+  }
+
+  // Count fragment rows from worker outputs to know expected total.
+  int32_t expectedFragments = 0;
+  for (const auto& output : allWorkerOutputs) {
+    for (vector_size_t i = 0; i < output->size(); ++i) {
+      if (!output->childAt(TableWriteTraits::kFragmentChannel)->isNullAt(i)) {
+        ++expectedFragments;
+      }
+    }
+  }
+  ASSERT_GE(expectedFragments, 2);
+
+  auto verifyCoordinatorResult = [&](const RowVectorPtr& result) {
+    ASSERT_GT(result->size(), 0);
+
+    auto* rowCountVector = result->childAt(TableWriteTraits::kRowCountChannel)
+                               ->as<SimpleVector<int64_t>>();
+    auto* minVector = result->childAt(TableWriteTraits::kStatsChannel)
+                          ->as<SimpleVector<int32_t>>();
+    auto* maxVector = result->childAt(TableWriteTraits::kStatsChannel + 1)
+                          ->as<SimpleVector<int32_t>>();
+
+    auto* fragmentVector = result->childAt(TableWriteTraits::kFragmentChannel)
+                               ->as<SimpleVector<StringView>>();
+
+    int32_t numStatsWithValues = 0;
+    int32_t numSummary = 0;
+    int64_t totalFragmentRows = 0;
+    std::set<std::string> fragmentFiles;
+    for (vector_size_t i = 0; i < result->size(); ++i) {
+      if (!fragmentVector->isNullAt(i)) {
+        auto fragment =
+            folly::parseJson(std::string(fragmentVector->valueAt(i)));
+        totalFragmentRows += fragment["rowCount"].asInt();
+        for (const auto& file : extractFragmentFiles(fragment)) {
+          EXPECT_TRUE(fragmentFiles.insert(file).second)
+              << "Duplicate fragment file: " << file;
+        }
+      } else if (!minVector->isNullAt(i)) {
+        ++numStatsWithValues;
+        EXPECT_EQ(0, minVector->valueAt(i));
+        EXPECT_EQ(99, maxVector->valueAt(i));
+      } else if (!rowCountVector->isNullAt(i)) {
+        ++numSummary;
+        EXPECT_EQ(100, rowCountVector->valueAt(i));
+      } else {
+        FAIL() << "Unexpected row " << i << ": " << result->toString(i);
+      }
+    }
+
+    // Verify fragment files match what's on disk.
+    std::set<std::string> diskFiles;
+    for (const auto& dir : outputDirectories) {
+      for (const auto& entry :
+           std::filesystem::directory_iterator(dir->getPath())) {
+        if (entry.is_regular_file()) {
+          diskFiles.insert(entry.path().string());
+        }
+      }
+    }
+    EXPECT_EQ(fragmentFiles, diskFiles);
+    EXPECT_EQ(100, totalFragmentRows);
+    EXPECT_EQ(1, numStatsWithValues);
+    EXPECT_EQ(1, numSummary);
+  };
+
+  auto spec = makeFinalStatsSpec(workerPlan, *allWorkerOutputs[0]->rowType());
+
+  auto runCoordinator = [&](const std::vector<RowVectorPtr>& input) {
+    auto plan = PlanBuilder().values(input).tableWriteMerge(spec).planNode();
+    verifyCoordinatorResult(
+        AssertQueryBuilder(plan).maxDrivers(1).copyResults(pool()));
+  };
+
+  // Run coordinator on worker outputs in order.
+  runCoordinator(allWorkerOutputs);
+
+  // Run coordinator on reversed worker outputs (worker 2 first).
+  {
+    auto reversed = allWorkerOutputs;
+    std::reverse(reversed.begin(), reversed.end());
+    runCoordinator(reversed);
+  }
+
+  // Run coordinator on split and interleaved worker outputs. Splits each
+  // worker output into 2 vectors, creating mixed batches with both stats
+  // and data rows.
+  {
+    auto parts1 = split(allWorkerOutputs[0], 2);
+    auto parts2 = split(allWorkerOutputs[1], 2);
+    runCoordinator({parts2[0], parts1[0], parts1[1], parts2[1]});
+  }
+}
+
 // TODO: add partitioned table write update mode tests and more failure tests.
 
 TEST_P(AllTableWriterTest, tableWriterStats) {
@@ -2307,17 +2651,17 @@ TEST_P(AllTableWriterTest, tableWriterStats) {
       fixedWrittenBytes);
   ASSERT_EQ(
       stats.operatorStats.at("TableWrite")
-          ->customStats.at(TableWriter::kNumWrittenFiles)
+          ->customStats.at(std::string(TableWriter::kNumWrittenFiles))
           .sum,
       numWrittenFiles);
   ASSERT_GE(
       stats.operatorStats.at("TableWrite")
-          ->customStats.at(TableWriter::kWriteIOTime)
+          ->customStats.at(std::string(TableWriter::kWriteIOTime))
           .sum,
       0);
   ASSERT_GE(
       stats.operatorStats.at("TableWrite")
-          ->customStats.at(TableWriter::kRunningWallNanos)
+          ->customStats.at(std::string(TableWriter::kRunningWallNanos))
           .sum,
       0);
 }
@@ -2408,9 +2752,9 @@ DEBUG_ONLY_TEST_P(UnpartitionedTableWriterTest, dataSinkAbortError) {
 
   std::atomic<bool> triggerAbortErrorOnce{true};
   SCOPED_TESTVALUE_SET(
-      "facebook::velox::connector::hive::HiveDataSink::closeInternal",
-      std::function<void(const HiveDataSink*)>(
-          [&](const HiveDataSink* /*unused*/) {
+      "facebook::velox::connector::hive::FileDataSink::closeInternal",
+      std::function<void(const FileDataSink*)>(
+          [&](const FileDataSink* /*unused*/) {
             if (!triggerAbortErrorOnce.exchange(false)) {
               return;
             }
@@ -2466,14 +2810,16 @@ TEST_P(BucketSortOnlyTableWriterTest, sortWriterSpill) {
   // One spilled partition per each written files.
   const int numWrittenFiles = stats.customStats["numWrittenFiles"].sum;
   ASSERT_GE(stats.spilledPartitions, numWrittenFiles);
-  ASSERT_GT(stats.customStats[Operator::kSpillRuns].sum, 0);
-  ASSERT_GT(stats.customStats[Operator::kSpillFillTime].sum, 0);
-  ASSERT_GT(stats.customStats[Operator::kSpillSortTime].sum, 0);
-  ASSERT_GT(stats.customStats[Operator::kSpillExtractVectorTime].sum, 0);
-  ASSERT_GT(stats.customStats[Operator::kSpillSerializationTime].sum, 0);
-  ASSERT_GT(stats.customStats[Operator::kSpillFlushTime].sum, 0);
-  ASSERT_GT(stats.customStats[Operator::kSpillWrites].sum, 0);
-  ASSERT_GT(stats.customStats[Operator::kSpillWriteTime].sum, 0);
+  ASSERT_GT(stats.customStats[std::string(Operator::kSpillRuns)].sum, 0);
+  ASSERT_GT(stats.customStats[std::string(Operator::kSpillFillTime)].sum, 0);
+  ASSERT_GT(stats.customStats[std::string(Operator::kSpillSortTime)].sum, 0);
+  ASSERT_GT(
+      stats.customStats[std::string(Operator::kSpillExtractVectorTime)].sum, 0);
+  ASSERT_GT(
+      stats.customStats[std::string(Operator::kSpillSerializationTime)].sum, 0);
+  ASSERT_GT(stats.customStats[std::string(Operator::kSpillFlushTime)].sum, 0);
+  ASSERT_GT(stats.customStats[std::string(Operator::kSpillWrites)].sum, 0);
+  ASSERT_GT(stats.customStats[std::string(Operator::kSpillWriteTime)].sum, 0);
 }
 
 DEBUG_ONLY_TEST_P(BucketSortOnlyTableWriterTest, outputBatchRows) {
@@ -2490,13 +2836,14 @@ DEBUG_ONLY_TEST_P(BucketSortOnlyTableWriterTest, outputBatchRows) {
           maxOutputBytes,
           expectedOutputCount);
     }
-  } testSettings[] = {// we have 4 buckets thus 4 writers.
-                      {10000, "1000kB", 4},
-                      // when maxOutputRows = 1, 1000 rows triggers 1000 writes
-                      {1, "1kB", 1000},
-                      // estimatedRowSize is ~62bytes, when maxOutputSize = 62 *
-                      // 100, 1000 rows triggers ~10 writes
-                      {10000, "6200B", 12}};
+  } testSettings[] = {
+      // we have 4 buckets thus 4 writers.
+      {10000, "1000kB", 4},
+      // when maxOutputRows = 1, 1000 rows triggers 1000 writes
+      {1, "1kB", 1000},
+      // estimatedRowSize is ~62bytes, when maxOutputSize = 62 *
+      // 100, 1000 rows triggers ~10 writes
+      {10000, "6200B", 12}};
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
@@ -2772,8 +3119,10 @@ DEBUG_ONLY_TEST_F(TableWriterArbitrationTest, reclaimFromTableWriter) {
       const int numPrevArbitrationFailures = arbitrator->stats().numFailures;
       const int numPrevNonReclaimableAttempts =
           arbitrator->stats().numNonReclaimableAttempts;
-      auto queryCtx = core::QueryCtx::create(
-          executor_.get(), QueryConfig{{}}, {}, nullptr, std::move(queryPool));
+      auto queryCtx = core::QueryCtx::Builder()
+                          .executor(executor_.get())
+                          .pool(std::move(queryPool))
+                          .build();
       ASSERT_EQ(queryCtx->pool()->capacity(), kQueryMemoryCapacity);
 
       std::atomic_int numInputs{0};
@@ -2891,11 +3240,13 @@ DEBUG_ONLY_TEST_F(TableWriterArbitrationTest, reclaimFromSortTableWriter) {
       const int numPrevArbitrationFailures = arbitrator->stats().numFailures;
       const int numPrevNonReclaimableAttempts =
           arbitrator->stats().numNonReclaimableAttempts;
-      auto queryCtx = core::QueryCtx::create(
-          executor_.get(), QueryConfig{{}}, {}, nullptr, std::move(queryPool));
+      auto queryCtx = core::QueryCtx::Builder()
+                          .executor(executor_.get())
+                          .pool(std::move(queryPool))
+                          .build();
       ASSERT_EQ(queryCtx->pool()->capacity(), kQueryMemoryCapacity);
 
-      const auto spillStats = common::globalSpillStats();
+      const auto spillStats = globalSpillStats();
       std::atomic<int> numInputs{0};
       SCOPED_TESTVALUE_SET(
           "facebook::velox::exec::Driver::runInternal::addInput",
@@ -2963,7 +3314,7 @@ DEBUG_ONLY_TEST_F(TableWriterArbitrationTest, reclaimFromSortTableWriter) {
           numPrevNonReclaimableAttempts);
 
       waitForAllTasksToBeDeleted(3'000'000);
-      const auto updatedSpillStats = common::globalSpillStats();
+      const auto updatedSpillStats = globalSpillStats();
       if (writerSpillEnabled) {
         ASSERT_GT(updatedSpillStats.spilledBytes, spillStats.spilledBytes);
         ASSERT_GT(
@@ -2994,10 +3345,11 @@ DEBUG_ONLY_TEST_F(TableWriterArbitrationTest, writerFlushThreshold) {
   const std::vector<TestParam> testParams{
       {0, 0}, {0, 1UL << 30}, {64UL << 20, 1UL << 30}};
   for (const auto& testParam : testParams) {
-    SCOPED_TRACE(fmt::format(
-        "bytesToReserve: {}, writerFlushThreshold: {}",
-        succinctBytes(testParam.bytesToReserve),
-        succinctBytes(testParam.writerFlushThreshold)));
+    SCOPED_TRACE(
+        fmt::format(
+            "bytesToReserve: {}, writerFlushThreshold: {}",
+            succinctBytes(testParam.bytesToReserve),
+            succinctBytes(testParam.writerFlushThreshold)));
 
     auto queryPool = memory::memoryManager()->addRootPool(
         "writerFlushThreshold", kQueryMemoryCapacity);
@@ -3005,8 +3357,11 @@ DEBUG_ONLY_TEST_F(TableWriterArbitrationTest, writerFlushThreshold) {
     const int numPrevArbitrationFailures = arbitrator->stats().numFailures;
     const int numPrevNonReclaimableAttempts =
         arbitrator->stats().numNonReclaimableAttempts;
-    auto queryCtx = core::QueryCtx::create(
-        executor_.get(), QueryConfig{{}}, {}, nullptr, std::move(queryPool));
+    auto queryCtx = core::QueryCtx::Builder()
+                        .executor(executor_.get())
+                        .pool(std::move(queryPool))
+                        .build();
+
     ASSERT_EQ(queryCtx->pool()->capacity(), kQueryMemoryCapacity);
 
     memory::MemoryPool* compressionPool{nullptr};
@@ -3113,8 +3468,11 @@ DEBUG_ONLY_TEST_F(
   const int numPrevArbitrationFailures = arbitrator->stats().numFailures;
   const int numPrevNonReclaimableAttempts =
       arbitrator->stats().numNonReclaimableAttempts;
-  auto queryCtx = core::QueryCtx::create(
-      executor_.get(), QueryConfig{{}}, {}, nullptr, std::move(queryPool));
+  auto queryCtx = core::QueryCtx::Builder()
+                      .executor(executor_.get())
+                      .pool(std::move(queryPool))
+                      .build();
+
   ASSERT_EQ(queryCtx->pool()->capacity(), kQueryMemoryCapacity);
 
   std::atomic<bool> injectFakeAllocationOnce{true};
@@ -3196,8 +3554,10 @@ DEBUG_ONLY_TEST_F(
   const int numPrevNonReclaimableAttempts =
       arbitrator->stats().numNonReclaimableAttempts;
   const int numPrevReclaimedBytes = arbitrator->stats().reclaimedUsedBytes;
-  auto queryCtx = core::QueryCtx::create(
-      executor_.get(), QueryConfig{{}}, {}, nullptr, std::move(queryPool));
+  auto queryCtx = core::QueryCtx::Builder()
+                      .executor(executor_.get())
+                      .pool(std::move(queryPool))
+                      .build();
   ASSERT_EQ(queryCtx->pool()->capacity(), kQueryMemoryCapacity);
 
   std::atomic<bool> writerNoMoreInput{false};
@@ -3296,8 +3656,10 @@ DEBUG_ONLY_TEST_F(
   const int numPrevArbitrationFailures = arbitrator->stats().numFailures;
   const int numPrevNonReclaimableAttempts =
       arbitrator->stats().numNonReclaimableAttempts;
-  auto queryCtx = core::QueryCtx::create(
-      executor_.get(), QueryConfig{{}}, {}, nullptr, std::move(queryPool));
+  auto queryCtx = core::QueryCtx::Builder()
+                      .executor(executor_.get())
+                      .pool(std::move(queryPool))
+                      .build();
   ASSERT_EQ(queryCtx->pool()->capacity(), kQueryMemoryCapacity);
 
   std::atomic<bool> injectFakeAllocationOnce{true};
@@ -3340,7 +3702,7 @@ DEBUG_ONLY_TEST_F(
               {fmt::format("sum({})", TableWriteTraits::rowCountColumnName())})
           .planNode();
 
-  const auto spillStats = common::globalSpillStats();
+  const auto spillStats = globalSpillStats();
   const auto spillDirectory = TempDirectoryPath::create();
   AssertQueryBuilder(duckDbQueryRunner_)
       .queryCtx(queryCtx)
@@ -3366,7 +3728,7 @@ DEBUG_ONLY_TEST_F(
   ASSERT_EQ(
       arbitrator->stats().numNonReclaimableAttempts,
       numPrevNonReclaimableAttempts + 1);
-  const auto updatedSpillStats = common::globalSpillStats();
+  const auto updatedSpillStats = globalSpillStats();
   ASSERT_EQ(updatedSpillStats, spillStats);
   waitForAllTasksToBeDeleted();
 }
@@ -3388,8 +3750,11 @@ DEBUG_ONLY_TEST_F(TableWriterArbitrationTest, tableFileWriteError) {
 
   auto queryPool = memory::memoryManager()->addRootPool(
       "tableFileWriteError", kQueryMemoryCapacity);
-  auto queryCtx = core::QueryCtx::create(
-      executor_.get(), QueryConfig{{}}, {}, nullptr, std::move(queryPool));
+  auto queryCtx = core::QueryCtx::Builder()
+                      .executor(executor_.get())
+                      .pool(std::move(queryPool))
+                      .build();
+
   ASSERT_EQ(queryCtx->pool()->capacity(), kQueryMemoryCapacity);
 
   std::atomic_bool injectWriterErrorOnce{true};
@@ -3456,8 +3821,10 @@ DEBUG_ONLY_TEST_F(TableWriterArbitrationTest, tableWriteSpillUseMoreMemory) {
 
   auto queryPool = memory::memoryManager()->addRootPool(
       "tableWriteSpillUseMoreMemory", kQueryMemoryCapacity / 4);
-  auto queryCtx = core::QueryCtx::create(
-      executor_.get(), QueryConfig{{}}, {}, nullptr, std::move(queryPool));
+  auto queryCtx = core::QueryCtx::Builder()
+                      .executor(executor_.get())
+                      .pool(std::move(queryPool))
+                      .build();
   ASSERT_EQ(queryCtx->pool()->capacity(), kQueryMemoryCapacity / 4);
 
   auto fakeLeafPool = queryCtx->pool()->addLeafChild(
@@ -3543,14 +3910,18 @@ DEBUG_ONLY_TEST_F(TableWriterArbitrationTest, tableWriteReclaimOnClose) {
 
   auto queryPool = memory::memoryManager()->addRootPool(
       "tableWriteSpillUseMoreMemory", kQueryMemoryCapacity);
-  auto queryCtx = core::QueryCtx::create(
-      executor_.get(), QueryConfig{{}}, {}, nullptr, std::move(queryPool));
+  auto queryCtx = core::QueryCtx::Builder()
+                      .executor(executor_.get())
+                      .pool(std::move(queryPool))
+                      .build();
   ASSERT_EQ(queryCtx->pool()->capacity(), kQueryMemoryCapacity);
 
   auto fakeQueryPool =
       memory::memoryManager()->addRootPool("fake", kQueryMemoryCapacity);
-  auto fakeQueryCtx = core::QueryCtx::create(
-      executor_.get(), QueryConfig{{}}, {}, nullptr, std::move(fakeQueryPool));
+  auto fakeQueryCtx = core::QueryCtx::Builder()
+                          .executor(executor_.get())
+                          .pool(std::move(fakeQueryPool))
+                          .build();
   ASSERT_EQ(fakeQueryCtx->pool()->capacity(), kQueryMemoryCapacity);
 
   auto fakeLeafPool = fakeQueryCtx->pool()->addLeafChild(
@@ -3636,8 +4007,10 @@ DEBUG_ONLY_TEST_F(
           .data;
   auto queryPool = memory::memoryManager()->addRootPool(
       "tableWriteSpillUseMoreMemory", kQueryMemoryCapacity);
-  auto queryCtx = core::QueryCtx::create(
-      executor_.get(), QueryConfig{{}}, {}, nullptr, std::move(queryPool));
+  auto queryCtx = core::QueryCtx::Builder()
+                      .executor(executor_.get())
+                      .pool(std::move(queryPool))
+                      .build();
   ASSERT_EQ(queryCtx->pool()->capacity(), kQueryMemoryCapacity);
 
   std::atomic_bool writerCloseWaitFlag{true};
diff --git a/velox/exec/tests/TaskTest.cpp b/velox/exec/tests/TaskTest.cpp
index e230dfbbd47..2bfcda8f94d 100644
--- a/velox/exec/tests/TaskTest.cpp
+++ b/velox/exec/tests/TaskTest.cpp
@@ -15,17 +15,17 @@
  */
 
 #include "velox/exec/Task.h"
-#include "folly/experimental/EventCount.h"
+#include "folly/synchronization/EventCount.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/tests/FaultyFileSystem.h"
 #include "velox/common/future/VeloxPromise.h"
 #include "velox/common/memory/MemoryArbitrator.h"
 #include "velox/common/memory/SharedArbitrator.h"
 #include "velox/common/memory/tests/SharedArbitratorTestUtil.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
 #include "velox/exec/Cursor.h"
-#include "velox/exec/HashAggregation.h"
 #include "velox/exec/OutputBufferManager.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/Values.h"
@@ -33,13 +33,15 @@
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/exec/tests/utils/QueryAssertions.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::common::testutil;
 
 namespace facebook::velox::exec::test {
+
+using TempDirectoryPath = facebook::velox::common::testutil::TempDirectoryPath;
+
 namespace {
 // A test join node whose build is skewed in terms of process time. The driver
 // id 0 processes slower than other drivers if paralelism greater than 1
@@ -256,7 +258,8 @@ class ExternalBlocker {
  public:
   folly::SemiFuture<folly::Unit> continueFuture() {
     if (isBlocked_) {
-      auto [promise, future] = makeVeloxContinuePromiseContract();
+      auto [promise, future] =
+          makeVeloxContinuePromiseContract("ExternalBlocker::continueFuture");
       continuePromise_ = std::move(promise);
       return std::move(future);
     }
@@ -524,7 +527,8 @@ class TaskTest : public HiveConnectorTestBase {
         plan,
         0,
         core::QueryCtx::create(),
-        Task::ExecutionMode::kSerial);
+        Task::ExecutionMode::kSerial,
+        exec::Consumer{});
 
     for (const auto& [nodeId, paths] : filePaths) {
       for (const auto& path : paths) {
@@ -573,7 +577,8 @@ TEST_F(TaskTest, toJson) {
       std::move(plan),
       0,
       core::QueryCtx::create(driverExecutor_.get()),
-      Task::ExecutionMode::kParallel);
+      Task::ExecutionMode::kParallel,
+      exec::Consumer{});
 
   ASSERT_EQ(
       task->toString(),
@@ -638,7 +643,8 @@ TEST_F(TaskTest, wrongPlanNodeForSplit) {
       std::move(plan),
       0,
       core::QueryCtx::create(driverExecutor_.get()),
-      Task::ExecutionMode::kParallel);
+      Task::ExecutionMode::kParallel,
+      exec::Consumer{});
 
   // Add split for the source node.
   task->addSplit("0", exec::Split(folly::copy(connectorSplit)));
@@ -694,7 +700,8 @@ TEST_F(TaskTest, wrongPlanNodeForSplit) {
       std::move(plan),
       0,
       core::QueryCtx::create(driverExecutor_.get()),
-      Task::ExecutionMode::kParallel);
+      Task::ExecutionMode::kParallel,
+      exec::Consumer{});
   errorMessage =
       "Splits can be associated only with leaf plan nodes which require splits. Plan node ID 0 doesn't refer to such plan node.";
   VELOX_ASSERT_THROW(
@@ -721,7 +728,8 @@ TEST_F(TaskTest, duplicatePlanNodeIds) {
           std::move(plan),
           0,
           core::QueryCtx::create(driverExecutor_.get()),
-          Task::ExecutionMode::kParallel),
+          Task::ExecutionMode::kParallel,
+          exec::Consumer{}),
       "Plan node IDs must be unique. Found duplicate ID: 0.")
 }
 
@@ -897,8 +905,8 @@ TEST_F(TaskTest, hasMixedExecutionGroupJoin) {
 
   task->start(1);
 
-  ASSERT_FALSE(
-      task->hasMixedExecutionGroupJoin(dynamic_cast<const core::HashJoinNode*>(
+  ASSERT_FALSE(task->hasMixedExecutionGroupJoin(
+      dynamic_cast<const core::HashJoinNode*>(
           nonMixedGroupedModeJoinNode.get())));
   ASSERT_TRUE(task->hasMixedExecutionGroupJoin(
       dynamic_cast<const core::HashJoinNode*>(mixedGroupedModeJoinNode.get())));
@@ -1228,7 +1236,8 @@ TEST_F(TaskTest, serialExecutionExternalBlockable) {
       plan,
       0,
       core::QueryCtx::create(),
-      Task::ExecutionMode::kSerial);
+      Task::ExecutionMode::kSerial,
+      exec::Consumer{});
   std::vector<RowVectorPtr> results;
   for (;;) {
     auto result = nonBlockingTask->next(&continueFuture);
@@ -1254,7 +1263,8 @@ TEST_F(TaskTest, serialExecutionExternalBlockable) {
       plan,
       0,
       core::QueryCtx::create(),
-      Task::ExecutionMode::kSerial);
+      Task::ExecutionMode::kSerial,
+      exec::Consumer{});
   // Before we block, we expect `next` to get data normally.
   results.push_back(blockingTask->next(&continueFuture));
   EXPECT_TRUE(results.back() != nullptr);
@@ -1291,16 +1301,17 @@ TEST_F(TaskTest, supportSerialExecutionMode) {
                   .project({"c0 % 10"})
                   .partitionedOutput({}, 1, std::vector<std::string>{"p0"})
                   .planFragment();
-  auto task = Task::create(
-      "single.execution.task.0",
-      plan,
-      0,
-      core::QueryCtx::create(),
-      Task::ExecutionMode::kSerial);
-
   // PartitionedOutput does not support serial execution mode, therefore the
   // task doesn't support it either.
-  ASSERT_FALSE(task->supportSerialExecutionMode());
+  VELOX_ASSERT_THROW(
+      Task::create(
+          "single.execution.task.0",
+          plan,
+          0,
+          core::QueryCtx::create(),
+          Task::ExecutionMode::kSerial,
+          exec::Consumer{}),
+      "");
 }
 
 TEST_F(TaskTest, updateBroadCastOutputBuffers) {
@@ -1316,7 +1327,8 @@ TEST_F(TaskTest, updateBroadCastOutputBuffers) {
         plan,
         0,
         core::QueryCtx::create(driverExecutor_.get()),
-        Task::ExecutionMode::kParallel);
+        Task::ExecutionMode::kParallel,
+        exec::Consumer{});
 
     task->start(1, 1);
 
@@ -1334,7 +1346,8 @@ TEST_F(TaskTest, updateBroadCastOutputBuffers) {
         plan,
         0,
         core::QueryCtx::create(driverExecutor_.get()),
-        Task::ExecutionMode::kParallel);
+        Task::ExecutionMode::kParallel,
+        exec::Consumer{});
 
     task->start(1, 1);
 
@@ -1606,8 +1619,7 @@ DEBUG_ONLY_TEST_F(TaskTest, inconsistentExecutionMode) {
     VELOX_ASSERT_THROW(task->next(), "Inconsistent task execution mode.");
     getOutputWaitFlag = true;
     getOutputWait.notify();
-    while (cursor->hasNext()) {
-      cursor->moveNext();
+    while (cursor->moveNext()) {
     }
     waitForTaskCompletion(task);
   }
@@ -1622,8 +1634,13 @@ DEBUG_ONLY_TEST_F(TaskTest, inconsistentExecutionMode) {
     auto plan =
         PlanBuilder().values({data, data, data}).project({"c0"}).planFragment();
     auto queryCtx = core::QueryCtx::create(driverExecutor_.get());
-    auto task =
-        Task::create("task.0", plan, 0, queryCtx, Task::ExecutionMode::kSerial);
+    auto task = Task::create(
+        "task.0",
+        plan,
+        0,
+        queryCtx,
+        Task::ExecutionMode::kSerial,
+        exec::Consumer{});
 
     task->next();
     VELOX_ASSERT_THROW(task->start(4, 1), "Inconsistent task execution mode.");
@@ -1868,7 +1885,7 @@ DEBUG_ONLY_TEST_F(TaskTest, driverCounters) {
   pauseDriverRunInternal.lock();
   SCOPED_TESTVALUE_SET(
       "facebook::velox::exec::Driver::runInternal",
-      std::function<void(Driver*)>([&](Driver*) {
+      std::function<void(Driver*)>([&](Driver* /*unused*/) {
         pauseDriverRunInternal.lock_shared();
         pauseDriverRunInternal.unlock_shared();
       }));
@@ -1957,17 +1974,24 @@ TEST_F(TaskTest, driverCreationMemoryAllocationCheck) {
           .planFragment();
   for (bool singleThreadExecution : {false, true}) {
     SCOPED_TRACE(fmt::format("singleThreadExecution: ", singleThreadExecution));
-    auto badTask = Task::create(
-        "driverCreationMemoryAllocationCheck",
-        plan,
-        0,
-        core::QueryCtx::create(
-            singleThreadExecution ? nullptr : driverExecutor_.get()),
-        singleThreadExecution ? Task::ExecutionMode::kSerial
-                              : Task::ExecutionMode::kParallel);
     if (singleThreadExecution) {
-      VELOX_ASSERT_THROW(badTask->next(), "Unexpected memory pool allocations");
+      VELOX_ASSERT_THROW(
+          Task::create(
+              "driverCreationMemoryAllocationCheck",
+              plan,
+              0,
+              core::QueryCtx::create(nullptr),
+              Task::ExecutionMode::kSerial,
+              exec::Consumer{}),
+          "Unexpected memory pool allocations");
     } else {
+      auto badTask = Task::create(
+          "driverCreationMemoryAllocationCheck",
+          plan,
+          0,
+          core::QueryCtx::create(driverExecutor_.get()),
+          Task::ExecutionMode::kParallel,
+          exec::Consumer{});
       VELOX_ASSERT_THROW(
           badTask->start(1), "Unexpected memory pool allocations");
     }
@@ -1994,36 +2018,34 @@ TEST_F(TaskTest, spillDirectoryCallback) {
       {{core::QueryConfig::kSpillEnabled, "true"},
        {core::QueryConfig::kAggregationSpillEnabled, "true"}});
   params.maxDrivers = 1;
-
-  auto cursor = TaskCursor::create(params);
-
-  std::shared_ptr<Task> task = cursor->task();
-  auto tmpRootDir = exec::test::TempDirectoryPath::create();
-  auto tmpParentSpillDir = fmt::format(
+  auto spillRootDir = TempDirectoryPath::create();
+  auto spillParentDir = fmt::format(
       "{}{}/parent_spill/",
       tests::utils::FaultyFileSystem::scheme(),
-      tmpRootDir->getPath());
-  auto tmpSpillDir = fmt::format(
+      spillRootDir->getPath());
+  auto spillDir = fmt::format(
       "{}{}/parent_spill/spill/",
       tests::utils::FaultyFileSystem::scheme(),
-      tmpRootDir->getPath());
-
-  EXPECT_FALSE(task->hasCreateSpillDirectoryCb());
+      spillRootDir->getPath());
 
-  task->setCreateSpillDirectoryCb([tmpParentSpillDir, tmpSpillDir]() {
-    auto filesystem = filesystems::getFileSystem(tmpParentSpillDir, nullptr);
+  params.spillDirectory = spillDir;
+  params.spillDirectoryCallback = [spillParentDir, spillDir]() {
+    auto filesystem = filesystems::getFileSystem(spillParentDir, nullptr);
     filesystems::DirectoryOptions options;
     options.values.emplace(
         filesystems::DirectoryOptions::kMakeDirectoryConfig.toString(),
         "dummy.config=123");
-    filesystem->mkdir(tmpParentSpillDir, options);
-    filesystem->mkdir(tmpSpillDir);
-    return tmpSpillDir;
-  });
+    filesystem->mkdir(spillParentDir, options);
+    filesystem->mkdir(spillDir);
+    return spillDir;
+  };
 
+  auto cursor = TaskCursor::create(params);
+  std::shared_ptr<Task> task = cursor->task();
   EXPECT_TRUE(task->hasCreateSpillDirectoryCb());
+
   auto fs = std::dynamic_pointer_cast<tests::utils::FaultyFileSystem>(
-      filesystems::getFileSystem(tmpParentSpillDir, nullptr));
+      filesystems::getFileSystem(spillParentDir, nullptr));
 
   fs->setFileSystemInjectionError(
       std::make_exception_ptr(std::runtime_error("test exception")),
@@ -2039,7 +2061,7 @@ TEST_F(TaskTest, spillDirectoryCallback) {
     auto mkdirOp =
         static_cast<tests::utils::FaultFileSystemMkdirOperation*>(op);
     if (mkdirOp->path ==
-        fmt::format("{}/parent_spill/", tmpRootDir->getPath())) {
+        fmt::format("{}/parent_spill/", spillRootDir->getPath())) {
       parentDirectoryCreated = true;
       auto it = mkdirOp->options.values.find(
           filesystems::DirectoryOptions::kMakeDirectoryConfig.toString());
@@ -2047,7 +2069,7 @@ TEST_F(TaskTest, spillDirectoryCallback) {
       EXPECT_EQ(it->second, "dummy.config=123");
     }
     if (mkdirOp->path ==
-        fmt::format("{}/parent_spill/spill/", tmpRootDir->getPath())) {
+        fmt::format("{}/parent_spill/spill/", spillRootDir->getPath())) {
       spillDirectoryCreated = true;
     }
     return;
@@ -2092,13 +2114,13 @@ TEST_F(TaskTest, spillDirectoryLifecycleManagement) {
       {{core::QueryConfig::kSpillEnabled, "true"},
        {core::QueryConfig::kAggregationSpillEnabled, "true"}});
   params.maxDrivers = 1;
+  const auto rootTempDir = TempDirectoryPath::create();
+  const auto tmpDirectoryPath =
+      rootTempDir->getPath() + "/spillDirectoryLifecycleManagement";
+  params.spillDirectory = tmpDirectoryPath;
 
   auto cursor = TaskCursor::create(params);
   std::shared_ptr<Task> task = cursor->task();
-  auto rootTempDir = exec::test::TempDirectoryPath::create();
-  auto tmpDirectoryPath =
-      rootTempDir->getPath() + "/spillDirectoryLifecycleManagement";
-  task->setSpillDirectory(tmpDirectoryPath, false);
 
   TestScopedSpillInjection scopedSpillInjection(100);
   while (cursor->moveNext()) {
@@ -2152,9 +2174,8 @@ TEST_F(TaskTest, spillDirNotCreated) {
 
   auto cursor = TaskCursor::create(params);
   auto* task = cursor->task().get();
-  auto rootTempDir = exec::test::TempDirectoryPath::create();
+  auto rootTempDir = TempDirectoryPath::create();
   auto tmpDirectoryPath = rootTempDir->getPath() + "/spillDirNotCreated";
-  task->setSpillDirectory(tmpDirectoryPath, false);
 
   while (cursor->moveNext()) {
   }
@@ -2191,7 +2212,7 @@ DEBUG_ONLY_TEST_F(TaskTest, resumeAfterTaskFinish) {
   SCOPED_TESTVALUE_SET(
       "facebook::velox::exec::Values::getOutput",
       std::function<void(const velox::exec::Values*)>(
-          ([&](const velox::exec::Values* values) {
+          ([&](const velox::exec::Values* /*unused*/) {
             valuesWait.await([&]() { return !valuesWaitFlag.load(); });
           })));
 
@@ -2200,7 +2221,8 @@ DEBUG_ONLY_TEST_F(TaskTest, resumeAfterTaskFinish) {
       std::move(plan),
       0,
       core::QueryCtx::create(driverExecutor_.get()),
-      Task::ExecutionMode::kParallel);
+      Task::ExecutionMode::kParallel,
+      exec::Consumer{});
   task->start(4, 1);
 
   // Request pause and then unblock operators to proceed.
@@ -2231,7 +2253,12 @@ DEBUG_ONLY_TEST_F(TaskTest, serialLongRunningOperatorInTaskReclaimerAbort) {
   auto queryCtx = core::QueryCtx::create(driverExecutor_.get());
 
   auto blockingTask = Task::create(
-      "blocking.task.0", plan, 0, queryCtx, Task::ExecutionMode::kSerial);
+      "blocking.task.0",
+      plan,
+      0,
+      queryCtx,
+      Task::ExecutionMode::kSerial,
+      exec::Consumer{});
 
   // Before we block, we expect `next` to get data normally.
   EXPECT_NE(nullptr, blockingTask->next());
@@ -2306,7 +2333,12 @@ DEBUG_ONLY_TEST_F(TaskTest, longRunningOperatorInTaskReclaimerAbort) {
   auto queryCtx = core::QueryCtx::create(driverExecutor_.get());
 
   auto blockingTask = Task::create(
-      "blocking.task.0", plan, 0, queryCtx, Task::ExecutionMode::kParallel);
+      "blocking.task.0",
+      plan,
+      0,
+      queryCtx,
+      Task::ExecutionMode::kParallel,
+      exec::Consumer{});
 
   blockingTask->start(4, 1);
   const std::string abortErrorMessage("Synthetic Exception");
@@ -2372,7 +2404,8 @@ DEBUG_ONLY_TEST_F(TaskTest, taskReclaimStats) {
       std::move(plan),
       0,
       std::move(queryCtx),
-      Task::ExecutionMode::kParallel);
+      Task::ExecutionMode::kParallel,
+      exec::Consumer{});
   task->start(4, 1);
 
   const int numReclaims{10};
@@ -2410,6 +2443,7 @@ DEBUG_ONLY_TEST_F(TaskTest, taskPauseTime) {
   opts.vectorSize = 32;
   VectorFuzzer fuzzer(opts, pool_.get());
   std::vector<RowVectorPtr> valueInputs;
+  valueInputs.reserve(4);
   for (int32_t i = 0; i < 4; ++i) {
     valueInputs.push_back(fuzzer.fuzzRow(rowType));
   }
@@ -2424,13 +2458,15 @@ DEBUG_ONLY_TEST_F(TaskTest, taskPauseTime) {
   folly::EventCount taskPauseWait;
   SCOPED_TESTVALUE_SET(
       "facebook::velox::exec::Values::getOutput",
-      std::function<void(const exec::Values*)>([&](const exec::Values* values) {
-        if (taskPauseWaitFlag.exchange(false)) {
-          taskPauseWait.notifyAll();
-        }
-        // Inject some delay for task pause stats verification.
-        std::this_thread::sleep_for(std::chrono::milliseconds(10)); // NOLINT
-      }));
+      std::function<void(const exec::Values*)>(
+          [&](const exec::Values* /*unused*/) {
+            if (taskPauseWaitFlag.exchange(false)) {
+              taskPauseWait.notifyAll();
+            }
+            // Inject some delay for task pause stats verification.
+            std::this_thread::sleep_for(
+                std::chrono::milliseconds(10)); // NOLINT
+          }));
 
   auto queryPool = memory::memoryManager()->addRootPool(
       "taskPauseTime", 1UL << 30, exec::MemoryReclaimer::create());
@@ -2446,7 +2482,8 @@ DEBUG_ONLY_TEST_F(TaskTest, taskPauseTime) {
       std::move(plan),
       0,
       std::move(queryCtx),
-      Task::ExecutionMode::kParallel);
+      Task::ExecutionMode::kParallel,
+      exec::Consumer{});
   task->start(4, 1);
 
   // Wait for the task driver starts to run.
@@ -2468,11 +2505,11 @@ DEBUG_ONLY_TEST_F(TaskTest, taskPauseTime) {
   ASSERT_EQ(taskStats.pipelineStats[0].driverStats.size(), 1);
   const auto& driverStats = taskStats.pipelineStats[0].driverStats[0];
   const auto& totalPauseTime =
-      driverStats.runtimeStats.at(DriverStats::kTotalPauseTime);
+      driverStats.runtimeStats.at(std::string(DriverStats::kTotalPauseTime));
   ASSERT_EQ(totalPauseTime.count, 1);
   ASSERT_GE(totalPauseTime.sum, 0);
-  const auto& totalOffThreadTime =
-      driverStats.runtimeStats.at(DriverStats::kTotalOffThreadTime);
+  const auto& totalOffThreadTime = driverStats.runtimeStats.at(
+      std::string(DriverStats::kTotalOffThreadTime));
   ASSERT_EQ(totalOffThreadTime.count, 1);
   ASSERT_GE(totalOffThreadTime.sum, 0);
 
@@ -2495,7 +2532,8 @@ TEST_F(TaskTest, updateStatsWhileCloseOffThreadDriver) {
       std::move(plan),
       0,
       core::QueryCtx::create(driverExecutor_.get()),
-      Task::ExecutionMode::kParallel);
+      Task::ExecutionMode::kParallel,
+      exec::Consumer{});
   task->start(4, 1);
   std::this_thread::sleep_for(std::chrono::milliseconds(100));
   task->testingVisitDrivers(
@@ -2508,13 +2546,119 @@ TEST_F(TaskTest, updateStatsWhileCloseOffThreadDriver) {
   ASSERT_EQ(taskStats.pipelineStats.size(), 1);
   ASSERT_EQ(taskStats.pipelineStats[0].driverStats.size(), 4);
   const auto& driverStats = taskStats.pipelineStats[0].driverStats[0];
-  ASSERT_EQ(driverStats.runtimeStats.count(DriverStats::kTotalPauseTime), 0);
-  const auto& totalOffThreadTime =
-      driverStats.runtimeStats.at(DriverStats::kTotalOffThreadTime);
+  ASSERT_EQ(
+      driverStats.runtimeStats.count(std::string(DriverStats::kTotalPauseTime)),
+      0);
+  const auto& totalOffThreadTime = driverStats.runtimeStats.at(
+      std::string(DriverStats::kTotalOffThreadTime));
   ASSERT_EQ(totalOffThreadTime.count, 1);
   ASSERT_GE(totalOffThreadTime.sum, 0);
 }
 
+// Verifies that driver-level lifecycle timing metrics
+// (driverQueuedWallNanos, driverOnThreadWallNanos, driverBlockedWallNanos)
+// are reported correctly for each pipeline.
+TEST_F(TaskTest, driverLifecycleTimingStats) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>(1'000, [](auto row) { return row % 10; }),
+      makeFlatVector<int64_t>(1'000, [](auto row) { return row; }),
+  });
+
+  auto buildData = makeRowVector(
+      {"u0", "u1"},
+      {
+          makeFlatVector<int64_t>(100, [](auto row) { return row % 10; }),
+          makeFlatVector<int64_t>(100, [](auto row) { return row; }),
+      });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  // Build a hash join plan to get multiple pipelines:
+  // Pipeline 0 (probe): Values -> HashProbe -> sink
+  // Pipeline 1 (build): Values -> HashBuild
+  core::PlanNodeId probeScanId;
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values({data})
+          .capturePlanNodeId(probeScanId)
+          .hashJoin(
+              {"c0"},
+              {"u0"},
+              PlanBuilder(planNodeIdGenerator).values({buildData}).planNode(),
+              "",
+              {"c0", "c1"})
+          .planNode();
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool_.get());
+  ASSERT_GT(result->size(), 0);
+
+  // Get task stats from the most recently completed task.
+  auto tasks = Task::getRunningTasks();
+  // Tasks may already be cleaned up. Use a cursor-based approach instead.
+
+  // Re-run using CursorParameters to access the task directly.
+  CursorParameters params;
+  params.planNode = plan;
+  params.queryCtx = core::QueryCtx::create(driverExecutor_.get());
+  params.maxDrivers = 2;
+
+  auto cursor = TaskCursor::create(params);
+  while (cursor->moveNext()) {
+  }
+  auto task = cursor->task();
+  ASSERT_TRUE(waitForTaskCompletion(task.get()));
+
+  auto taskStats = task->taskStats();
+  // We should have at least 2 pipelines (probe and build).
+  ASSERT_GE(taskStats.pipelineStats.size(), 2);
+
+  // Helper to find a driver stat by substring match across all pipelines.
+  auto findDriverStat =
+      [&taskStats](
+          const std::string& statSubstr) -> std::optional<RuntimeMetric> {
+    for (const auto& pipeline : taskStats.pipelineStats) {
+      for (const auto& ds : pipeline.driverStats) {
+        for (const auto& [name, metric] : ds.runtimeStats) {
+          if (name.find(statSubstr) != std::string::npos) {
+            return metric;
+          }
+        }
+      }
+    }
+    return std::nullopt;
+  };
+
+  // Verify driver lifecycle metrics exist and have sensible values.
+  auto queued = findDriverStat("driverQueuedWallNanos");
+  auto onThread = findDriverStat("driverOnThreadWallNanos");
+  auto blocked = findDriverStat("driverBlockedWallNanos");
+
+  ASSERT_TRUE(queued.has_value()) << "driverQueuedWallNanos not found";
+  ASSERT_TRUE(onThread.has_value()) << "driverOnThreadWallNanos not found";
+  ASSERT_TRUE(blocked.has_value()) << "driverBlockedWallNanos not found";
+
+  // Each metric should have count >= 1 (at least one driver reported).
+  ASSERT_GE(queued->count, 1);
+  ASSERT_GE(onThread->count, 1);
+  ASSERT_GE(blocked->count, 1);
+
+  // On-thread time must be positive (drivers did real work).
+  ASSERT_GT(onThread->sum, 0);
+  ASSERT_GT(onThread->max, 0);
+
+  // Queued and blocked times must be non-negative.
+  ASSERT_GE(queued->sum, 0);
+  ASSERT_GE(blocked->sum, 0);
+
+  // Verify the stat names contain the pipeline prefix and source operator.
+  // Look for probe pipeline stats (source is Values with probeScanId).
+  auto probePrefix = fmt::format("P0-Values.{}", probeScanId);
+  auto probeOnThread = findDriverStat(probePrefix + ".driverOnThreadWallNanos");
+  ASSERT_TRUE(probeOnThread.has_value())
+      << "Probe pipeline stat not found with prefix: " << probePrefix;
+  ASSERT_GT(probeOnThread->max, 0);
+}
+
 DEBUG_ONLY_TEST_F(TaskTest, driverEnqueAfterFailedAndPausedTask) {
   const auto data = makeRowVector({
       makeFlatVector<int64_t>(50, [](auto row) { return row; }),
@@ -2530,8 +2674,8 @@ DEBUG_ONLY_TEST_F(TaskTest, driverEnqueAfterFailedAndPausedTask) {
   folly::EventCount driverWait;
   SCOPED_TESTVALUE_SET(
       "facebook::velox::exec::Task::enter",
-      std::function<void(const velox::exec::ThreadState*)>(
-          ([&](const velox::exec::ThreadState* /*unused*/) {
+      std::function<void(const velox::exec::Task*)>(
+          ([&](const velox::exec::Task* /*unused*/) {
             driverWait.await([&]() { return !driverWaitFlag.load(); });
           })));
 
@@ -2540,7 +2684,8 @@ DEBUG_ONLY_TEST_F(TaskTest, driverEnqueAfterFailedAndPausedTask) {
       std::move(plan),
       0,
       core::QueryCtx::create(driverExecutor_.get()),
-      Task::ExecutionMode::kParallel);
+      Task::ExecutionMode::kParallel,
+      exec::Consumer{});
   task->start(4, 1);
 
   // Request pause.
@@ -2576,17 +2721,18 @@ DEBUG_ONLY_TEST_F(TaskTest, taskReclaimFailure) {
           [&](SpillerBase* /*unused*/) { VELOX_FAIL(spillTableError); }));
 
   TestScopedSpillInjection injection(100);
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  const auto spillDirectory = TempDirectoryPath::create();
   VELOX_ASSERT_THROW(
       AssertQueryBuilder(duckDbQueryRunner_)
           .spillDirectory(spillDirectory->getPath())
           .config(core::QueryConfig::kSpillEnabled, true)
           .config(core::QueryConfig::kAggregationSpillEnabled, true)
           .maxDrivers(1)
-          .plan(PlanBuilder()
-                    .values(inputVectors)
-                    .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                    .planNode())
+          .plan(
+              PlanBuilder()
+                  .values(inputVectors)
+                  .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                  .planNode())
           .assertResults(
               "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1"),
       spillTableError);
@@ -2611,10 +2757,11 @@ DEBUG_ONLY_TEST_F(TaskTest, taskDeletionPromise) {
   std::thread queryThread([&]() {
     AssertQueryBuilder(duckDbQueryRunner_)
         .maxDrivers(1)
-        .plan(PlanBuilder()
-                  .values(inputVectors)
-                  .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                  .planNode())
+        .plan(
+            PlanBuilder()
+                .values(inputVectors)
+                .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                .planNode())
         .assertResults("SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
   });
 
@@ -2650,8 +2797,8 @@ DEBUG_ONLY_TEST_F(TaskTest, taskCancellation) {
   folly::EventCount driverWait;
   SCOPED_TESTVALUE_SET(
       "facebook::velox::exec::Task::enter",
-      std::function<void(const velox::exec::ThreadState*)>(
-          ([&](const velox::exec::ThreadState* /*unused*/) {
+      std::function<void(const velox::exec::Task*)>(
+          ([&](const velox::exec::Task* /*unused*/) {
             driverWait.await([&]() { return !driverWaitFlag.load(); });
           })));
 
@@ -2660,7 +2807,8 @@ DEBUG_ONLY_TEST_F(TaskTest, taskCancellation) {
       std::move(plan),
       0,
       core::QueryCtx::create(driverExecutor_.get()),
-      Task::ExecutionMode::kParallel);
+      Task::ExecutionMode::kParallel,
+      exec::Consumer{});
   task->start(4, 1);
   auto cancellationToken = task->getCancellationToken();
   ASSERT_FALSE(cancellationToken.isCancellationRequested());
@@ -2724,17 +2872,42 @@ TEST_F(TaskTest, invalidPlanNodeForBarrier) {
                         .project({"c0 + 5"})
                         .planFragment();
   ASSERT_TRUE(plan.firstNodeNotSupportingBarrier());
+  {
+    const auto task = Task::create(
+        "invalidPlanNodeForBarrier",
+        plan,
+        0,
+        core::QueryCtx::create(),
+        Task::ExecutionMode::kSerial);
+    ASSERT_TRUE(!task->underBarrier());
+    VELOX_ASSERT_THROW(
+        task->requestBarrier(),
+        "Name of the first node that doesn't support barriered execution:");
+    while (auto next = task->next()) {
+    }
+    ASSERT_TRUE(task->isFinished());
+  }
 
-  const auto task = Task::create(
-      "invalidPlanNodeForBarrier",
-      plan,
-      0,
-      core::QueryCtx::create(),
-      Task::ExecutionMode::kSerial);
-  ASSERT_TRUE(!task->underBarrier());
-  VELOX_ASSERT_THROW(
-      task->requestBarrier(),
-      "Name of the first node that doesn't support barriered execution:");
+  {
+    const auto task = Task::create(
+        "invalidPlanNodeForBarrier",
+        plan,
+        0,
+        core::QueryCtx::create(executor_.get()),
+        Task::ExecutionMode::kParallel,
+        [](const RowVectorPtr& vector,
+           bool drained,
+           velox::ContinueFuture* future) {
+          return BlockingReason::kNotBlocked;
+        });
+    task->start(2);
+    ASSERT_TRUE(!task->underBarrier());
+    VELOX_ASSERT_THROW(
+        task->requestBarrier(),
+        "Name of the first node that doesn't support barriered execution:");
+    task->taskCompletionFuture().wait();
+    ASSERT_TRUE(task->isFinished());
+  }
 }
 
 TEST_F(TaskTest, barrierAfterNoMoreSplits) {
@@ -2752,50 +2925,54 @@ TEST_F(TaskTest, barrierAfterNoMoreSplits) {
                         .filter("c0 < 100")
                         .project({"c0 + 5"})
                         .planFragment();
+  {
+    const auto task = Task::create(
+        "barrierAfterNoMoreSplits",
+        plan,
+        0,
+        core::QueryCtx::create(),
+        Task::ExecutionMode::kSerial);
+    ASSERT_TRUE(!task->underBarrier());
 
-  const auto task = Task::create(
-      "barrierAfterNoMoreSplits",
-      plan,
-      0,
-      core::QueryCtx::create(),
-      Task::ExecutionMode::kSerial);
-  ASSERT_TRUE(!task->underBarrier());
-
-  task->addSplit(
-      scanId, exec::Split(makeHiveConnectorSplit(filePath->getPath())));
-  task->noMoreSplits(scanId);
-  ASSERT_TRUE(!task->underBarrier());
-
-  VELOX_ASSERT_THROW(
-      task->requestBarrier(),
-      "Can't start barrier on task which has already received no more splits");
-}
+    task->addSplit(
+        scanId, exec::Split(makeHiveConnectorSplit(filePath->getPath())));
+    task->noMoreSplits(scanId);
+    ASSERT_TRUE(!task->underBarrier());
 
-TEST_F(TaskTest, invalidTaskModeForBarrier) {
-  auto data = makeRowVector({
-      makeFlatVector<int64_t>(1'000, [](auto row) { return row; }),
-  });
+    VELOX_ASSERT_THROW(
+        task->requestBarrier(),
+        "Can't start barrier on task which has already received no more splits");
+    task->requestAbort().wait();
+    ASSERT_TRUE(!task->isRunning());
+  }
 
-  // Filter + Project.
-  core::PlanNodeId scanId;
-  const auto plan = PlanBuilder()
-                        .tableScan(asRowType(data->type()))
-                        .capturePlanNodeId(scanId)
-                        .filter("c0 < 100")
-                        .project({"c0 + 5"})
-                        .planFragment();
-  ASSERT_TRUE(plan.firstNodeNotSupportingBarrier() == nullptr);
+  {
+    const auto task = Task::create(
+        "invalidPlanNodeForBarrier",
+        plan,
+        0,
+        core::QueryCtx::create(executor_.get()),
+        Task::ExecutionMode::kParallel,
+        [](const RowVectorPtr& vector,
+           bool drained,
+           velox::ContinueFuture* future) {
+          return BlockingReason::kNotBlocked;
+        });
+
+    ASSERT_TRUE(!task->underBarrier());
+    task->start(2);
+    task->addSplit(
+        scanId, exec::Split(makeHiveConnectorSplit(filePath->getPath())));
+    task->noMoreSplits(scanId);
+    ASSERT_TRUE(!task->underBarrier());
 
-  const auto task = Task::create(
-      "invalidTaskModeForBarrier",
-      plan,
-      0,
-      core::QueryCtx::create(),
-      Task::ExecutionMode::kParallel);
-  ASSERT_TRUE(!task->underBarrier());
-  VELOX_ASSERT_THROW(
-      task->requestBarrier(),
-      "(Parallel vs. Serial) Task doesn't support barriered execution.");
+    VELOX_ASSERT_THROW(
+        task->requestBarrier(),
+        "Can't start barrier on task which has already received no more splits");
+    task->requestAbort().wait();
+    ASSERT_TRUE(!task->isRunning());
+  }
+  waitForAllTasksToBeDeleted();
 }
 
 TEST_F(TaskTest, addSplitAfterBarrier) {
@@ -2814,30 +2991,55 @@ TEST_F(TaskTest, addSplitAfterBarrier) {
                         .project({"c0 + 5"})
                         .planFragment();
   ASSERT_TRUE(plan.firstNodeNotSupportingBarrier() == nullptr);
+  {
+    const auto task = Task::create(
+        "barrierAfterNoMoreSplits",
+        plan,
+        0,
+        core::QueryCtx::create(),
+        Task::ExecutionMode::kSerial);
+    ASSERT_TRUE(!task->underBarrier());
 
-  const auto task = Task::create(
-      "barrierAfterNoMoreSplits",
-      plan,
-      0,
-      core::QueryCtx::create(),
-      Task::ExecutionMode::kSerial);
-  ASSERT_TRUE(!task->underBarrier());
+    task->addSplit(
+        scanId, exec::Split(makeHiveConnectorSplit(filePath->getPath())));
+    auto future = task->requestBarrier();
+    ASSERT_TRUE(task->underBarrier());
+    VELOX_ASSERT_THROW(
+        task->addSplit(
+            scanId, exec::Split(makeHiveConnectorSplit(filePath->getPath()))),
+        "Can't add new split under barrier processing");
+    std::this_thread::sleep_for(std::chrono::seconds(1)); // NOLINT
+    ASSERT_TRUE(task->isRunning());
+    ASSERT_FALSE(future.isReady());
+    task->requestAbort().wait();
+    ASSERT_TRUE(!task->isRunning());
+    ASSERT_TRUE(future.isReady());
+    future.wait();
+  }
 
-  task->addSplit(
-      scanId, exec::Split(makeHiveConnectorSplit(filePath->getPath())));
-  auto future = task->requestBarrier();
-  ASSERT_TRUE(task->underBarrier());
-  VELOX_ASSERT_THROW(
-      task->addSplit(
-          scanId, exec::Split(makeHiveConnectorSplit(filePath->getPath()))),
-      "Can't add new split under barrier processing");
-  std::this_thread::sleep_for(std::chrono::seconds(1)); // NOLINT
-  ASSERT_TRUE(task->isRunning());
-  ASSERT_FALSE(future.isReady());
-  task->requestAbort().wait();
-  ASSERT_TRUE(!task->isRunning());
-  ASSERT_TRUE(future.isReady());
-  future.wait();
+  {
+    const auto task = Task::create(
+        "barrierAfterNoMoreSplits",
+        plan,
+        0,
+        core::QueryCtx::create(executor_.get()),
+        Task::ExecutionMode::kParallel,
+        [](const RowVectorPtr& vector,
+           bool drained,
+           velox::ContinueFuture* future) {
+          return BlockingReason::kNotBlocked;
+        });
+    task->start(2);
+    ASSERT_TRUE(!task->underBarrier());
+    task->addSplit(
+        scanId, exec::Split(makeHiveConnectorSplit(filePath->getPath())));
+    auto future = task->requestBarrier();
+    future.wait();
+    ASSERT_FALSE(task->underBarrier());
+    task->requestAbort().wait();
+    ASSERT_TRUE(!task->isRunning());
+  }
+  waitForAllTasksToBeDeleted();
 }
 
 TEST_F(TaskTest, testTerminateDuringBarrier) {
@@ -2854,36 +3056,119 @@ TEST_F(TaskTest, testTerminateDuringBarrier) {
                   .capturePlanNodeId(scanId)
                   .project({"c0"})
                   .planFragment();
+  {
+    auto queryCtx = core::QueryCtx::create();
+    queryCtx->testingOverrideConfigUnsafe(
+        {{core::QueryConfig::kMaxOutputBatchRows, "1"}});
+    const auto task = Task::create(
+        "testTerminateDuringBarrier",
+        plan,
+        0,
+        std::move(queryCtx),
+        Task::ExecutionMode::kSerial);
+    ASSERT_TRUE(!task->underBarrier());
+    task->addSplit(
+        scanId, exec::Split(makeHiveConnectorSplit(filePath->getPath())));
+    auto barrierFuture = task->requestBarrier();
+    ASSERT_TRUE(task->underBarrier());
+    for (int i = 0; i < numRows / 2; ++i) {
+      ContinueFuture future{ContinueFuture::makeEmpty()};
+      auto result = task->next(&future);
+      ASSERT_TRUE(result != nullptr);
+      ASSERT_FALSE(future.valid());
+    }
+    task->requestAbort();
+    ASSERT_FALSE(task->isRunning());
+    VELOX_ASSERT_THROW(
+        task->next(nullptr), "Task has already finished processing");
+    ASSERT_TRUE(barrierFuture.isReady());
+    barrierFuture.wait();
+    const auto taskStats = task->taskStats();
+    ASSERT_EQ(taskStats.numFinishedSplits, 0);
+    ASSERT_EQ(taskStats.numBarriers, 1);
+  }
 
-  auto queryCtx = core::QueryCtx::create();
-  queryCtx->testingOverrideConfigUnsafe(
-      {{core::QueryConfig::kMaxOutputBatchRows, "1"}});
-  const auto task = Task::create(
-      "testTerminateDuringBarrier",
-      plan,
-      0,
-      std::move(queryCtx),
-      Task::ExecutionMode::kSerial);
-  ASSERT_TRUE(!task->underBarrier());
-  task->addSplit(
-      scanId, exec::Split(makeHiveConnectorSplit(filePath->getPath())));
-  auto barrierFuture = task->requestBarrier();
-  ASSERT_TRUE(task->underBarrier());
-  for (int i = 0; i < numRows / 2; ++i) {
-    ContinueFuture future{ContinueFuture::makeEmpty()};
-    auto result = task->next(&future);
-    ASSERT_TRUE(result != nullptr);
-    ASSERT_FALSE(future.valid());
+  {
+    const auto task = Task::create(
+        "invalidPlanNodeForBarrier",
+        plan,
+        0,
+        core::QueryCtx::create(executor_.get()),
+        Task::ExecutionMode::kParallel,
+        [](const RowVectorPtr& vector,
+           bool drained,
+           velox::ContinueFuture* future) {
+          return BlockingReason::kNotBlocked;
+        });
+    task->start(2);
+    ASSERT_TRUE(!task->underBarrier());
+    task->addSplit(
+        scanId, exec::Split(makeHiveConnectorSplit(filePath->getPath())));
+    auto barrierFuture = task->requestBarrier();
+    task->requestAbort().wait();
+    ASSERT_FALSE(task->isRunning());
+    ASSERT_TRUE(barrierFuture.isReady());
+    ASSERT_EQ(task->taskStats().numBarriers, 1);
   }
-  task->requestAbort();
-  ASSERT_FALSE(task->isRunning());
-  VELOX_ASSERT_THROW(
-      task->next(nullptr), "Task has already finished processing");
-  ASSERT_TRUE(barrierFuture.isReady());
-  barrierFuture.wait();
-  const auto taskStats = task->taskStats();
-  ASSERT_EQ(taskStats.numFinishedSplits, 0);
-  ASSERT_EQ(taskStats.numBarriers, 1);
+}
+
+TEST_F(TaskTest, testBarrierClearedOnTerminate) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>(100, [](auto row) { return row; }),
+  });
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), {data});
+
+  core::PlanNodeId scanId;
+  auto plan = PlanBuilder()
+                  .tableScan(asRowType(data->type()))
+                  .capturePlanNodeId(scanId)
+                  .project({"c0"})
+                  .planFragment();
+
+  // Verify that barrierRequested_ is cleared when task is aborted while under
+  // barrier in serial execution mode.
+  {
+    const auto task = Task::create(
+        "barrierClearedOnTerminate.serial",
+        plan,
+        0,
+        core::QueryCtx::create(),
+        Task::ExecutionMode::kSerial);
+    task->addSplit(
+        scanId, exec::Split(makeHiveConnectorSplit(filePath->getPath())));
+    auto barrierFuture = task->requestBarrier();
+    ASSERT_TRUE(task->underBarrier());
+    task->requestAbort().wait();
+    ASSERT_FALSE(task->isRunning());
+    ASSERT_FALSE(task->underBarrier());
+    ASSERT_TRUE(barrierFuture.isReady());
+  }
+
+  // Verify that barrierRequested_ is cleared when task is aborted while under
+  // barrier in parallel execution mode.
+  {
+    const auto task = Task::create(
+        "barrierClearedOnTerminate.parallel",
+        plan,
+        0,
+        core::QueryCtx::create(executor_.get()),
+        Task::ExecutionMode::kParallel,
+        [](const RowVectorPtr& /*vector*/,
+           bool /*drained*/,
+           velox::ContinueFuture* /*future*/) {
+          return BlockingReason::kNotBlocked;
+        });
+    task->start(2);
+    task->addSplit(
+        scanId, exec::Split(makeHiveConnectorSplit(filePath->getPath())));
+    auto barrierFuture = task->requestBarrier();
+    task->requestAbort().wait();
+    ASSERT_FALSE(task->isRunning());
+    ASSERT_FALSE(task->underBarrier());
+    ASSERT_TRUE(barrierFuture.isReady());
+  }
+  waitForAllTasksToBeDeleted();
 }
 
 namespace {
@@ -2964,7 +3249,7 @@ class TestBarrierOperator : public exec::Operator {
       return nullptr;
     }
     auto output = inputs_.front();
-    inputs_.erase(inputs_.begin());
+    inputs_.erase(inputs_.cbegin());
     return output;
   }
 
@@ -3378,4 +3663,74 @@ DEBUG_ONLY_TEST_F(TaskTest, operatorShouldYieldMethod) {
   }
 }
 
+// Verifies that blocked wait time is recorded even when an operator is
+// terminated while blocked.
+DEBUG_ONLY_TEST_F(TaskTest, blockedWaitTimeOnAbort) {
+  // Test that blocked time is recorded even when a task is aborted while
+  // an operator is blocked.
+  //
+  // We use a simple table scan that blocks waiting for splits. By starting
+  // the task without adding splits, the scan operator will block on
+  // kWaitForSplit. We then abort the task while blocked and verify that
+  // the blocked time is recorded via closeByTask().
+  constexpr int kBlockTimeMs = 100;
+
+  // Build a simple plan with a table scan.
+  core::PlanNodeId scanNodeId;
+  auto plan = PlanBuilder()
+                  .tableScan(ROW({"c0"}, {BIGINT()}))
+                  .capturePlanNodeId(scanNodeId)
+                  .planFragment();
+
+  auto task = Task::create(
+      "blockedWaitTimeOnAbort",
+      plan,
+      0,
+      core::QueryCtx::create(driverExecutor_.get()),
+      Task::ExecutionMode::kParallel);
+
+  task->start(1, 1);
+
+  // Wait for the driver to become blocked waiting for splits.
+  auto startTime = std::chrono::steady_clock::now();
+  while (BlockingState::numBlockedDrivers() == 0) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(
+                       std::chrono::steady_clock::now() - startTime)
+                       .count();
+    if (elapsed > 5) {
+      task->requestAbort().wait();
+      GTEST_SKIP() << "Operator did not block in time";
+    }
+  }
+
+  // Let some time pass while blocked to have measurable blocked time.
+  std::this_thread::sleep_for(std::chrono::milliseconds(kBlockTimeMs));
+
+  // Abort the task while the operator is still blocked waiting for splits.
+  task->requestAbort().wait();
+
+  // Wait for the task to be fully aborted.
+  ASSERT_TRUE(waitForTaskAborted(task.get()));
+
+  // Verify that blocked wait time was recorded despite the abort.
+  const auto stats = task->taskStats().pipelineStats;
+  ASSERT_FALSE(stats.empty());
+  ASSERT_FALSE(stats[0].operatorStats.empty());
+
+  // Find operator stats with blocked time recorded.
+  bool foundBlockedTime = false;
+  for (const auto& opStats : stats[0].operatorStats) {
+    if (opStats.blockedWallNanos > 0) {
+      foundBlockedTime = true;
+      // Verify the blocked time is at least what we waited (with tolerance).
+      EXPECT_GE(opStats.blockedWallNanos, (kBlockTimeMs - 30) * 1'000'000)
+          << "Blocked time should be at least " << (kBlockTimeMs - 30) << "ms";
+      break;
+    }
+  }
+  EXPECT_TRUE(foundBlockedTime)
+      << "Operator should have recorded blocked time despite task abort";
+}
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/ThreadDebugInfoTest.cpp b/velox/exec/tests/ThreadDebugInfoTest.cpp
index 75bab5b3759..6bcb1801e14 100644
--- a/velox/exec/tests/ThreadDebugInfoTest.cpp
+++ b/velox/exec/tests/ThreadDebugInfoTest.cpp
@@ -63,6 +63,7 @@ template <typename T>
 struct InduceSegFaultFunction {
   template <typename TResult, typename TInput>
   void call(TResult& out, const TInput& in) {
+    LOG(ERROR) << "error";
     int* nullpointer = nullptr;
     *nullpointer = 6;
   }
@@ -117,9 +118,10 @@ DEBUG_ONLY_TEST_F(ThreadDebugInfoDeathTest, withinTheCallingThread) {
 
 #ifndef IS_BUILDING_WITH_SAN
   ASSERT_DEATH(
-      (task->next()),
+      task->next(),
       ".*Fatal signal handler. Query Id= TaskCursorQuery_0 Task Id= single.execution.task.0.*");
 #endif
+  task->requestCancel();
 }
 
 DEBUG_ONLY_TEST_F(ThreadDebugInfoDeathTest, noThreadContextSet) {
diff --git a/velox/exec/tests/TopNRowNumberTest.cpp b/velox/exec/tests/TopNRowNumberTest.cpp
index fac57658c2c..7f79ab80de7 100644
--- a/velox/exec/tests/TopNRowNumberTest.cpp
+++ b/velox/exec/tests/TopNRowNumberTest.cpp
@@ -15,26 +15,40 @@
  */
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 using namespace facebook::velox::exec::test;
 
 namespace facebook::velox::exec {
+using namespace facebook::velox::common::testutil;
 
 namespace {
 
 class TopNRowNumberTest : public OperatorTestBase {
  protected:
-  TopNRowNumberTest() {
+  explicit TopNRowNumberTest(core::TopNRowNumberNode::RankFunction function)
+      : functionName_(core::TopNRowNumberNode::rankFunctionName(function)) {}
+
+  void SetUp() override {
+    exec::test::OperatorTestBase::SetUp();
     filesystems::registerLocalFileSystem();
   }
+
+  const std::string functionName_;
+};
+
+class MultiTopNRowNumberTest : public TopNRowNumberTest,
+                               public testing::WithParamInterface<
+                                   core::TopNRowNumberNode::RankFunction> {
+ public:
+  MultiTopNRowNumberTest() : TopNRowNumberTest(GetParam()) {}
 };
 
-TEST_F(TopNRowNumberTest, basic) {
+TEST_P(MultiTopNRowNumberTest, basic) {
   auto data = makeRowVector({
       // Partitioning key.
       makeFlatVector<int64_t>({1, 1, 2, 2, 1, 2, 1}),
@@ -50,38 +64,101 @@ TEST_F(TopNRowNumberTest, basic) {
     // Emit row numbers.
     auto plan = PlanBuilder()
                     .values({data})
-                    .topNRowNumber({"c0"}, {"c1"}, limit, true)
+                    .topNRank(functionName_, {"c0"}, {"c1"}, limit, true)
+                    .planNode();
+    assertQuery(
+        plan,
+        fmt::format(
+            "SELECT * FROM (SELECT *, {}() over (partition by c0 order by c1) as rn FROM tmp) "
+            " WHERE rn <= {}",
+            functionName_,
+            limit));
+
+    // Do not emit row numbers.
+    plan = PlanBuilder()
+               .values({data})
+               .topNRank(functionName_, {"c0"}, {"c1"}, limit, false)
+               .planNode();
+
+    assertQuery(
+        plan,
+        fmt::format(
+            "SELECT c0, c1, c2 FROM (SELECT *, {}() over (partition by c0 order by c1) as rn FROM tmp) "
+            " WHERE rn <= {}",
+            functionName_,
+            limit));
+
+    // No partitioning keys.
+    plan = PlanBuilder()
+               .values({data})
+               .topNRank(functionName_, {}, {"c1"}, limit, true)
+               .planNode();
+    assertQuery(
+        plan,
+        fmt::format(
+            "SELECT * FROM (SELECT *, {}() over (order by c1) as rn FROM tmp) "
+            " WHERE rn <= {}",
+            functionName_,
+            limit));
+  };
+
+  testLimit(1);
+  testLimit(2);
+  testLimit(3);
+  testLimit(5);
+}
+
+TEST_P(MultiTopNRowNumberTest, basicWithPeers) {
+  auto data = makeRowVector({
+      // Partitioning key.
+      makeFlatVector<int64_t>({1, 1, 2, 2, 1, 2, 1, 1, 1, 1, 1}),
+      // Sorting key.
+      makeFlatVector<int64_t>({33, 11, 55, 44, 11, 22, 11, 11, 11, 33, 33}),
+      // Data. Mapping data to matching sorting keys to avoid ordering issues.
+      makeFlatVector<int64_t>({10, 50, 30, 40, 50, 60, 50, 50, 50, 10, 10}),
+  });
+
+  createDuckDbTable({data});
+
+  auto testLimit = [&](auto limit) {
+    // Emit row numbers.
+    auto plan = PlanBuilder()
+                    .values({data})
+                    .topNRank(functionName_, {"c0"}, {"c1"}, limit, true)
                     .planNode();
     assertQuery(
         plan,
         fmt::format(
-            "SELECT * FROM (SELECT *, row_number() over (partition by c0 order by c1) as rn FROM tmp) "
+            "SELECT * FROM (SELECT *, {}() over (partition by c0 order by c1) as rn FROM tmp) "
             " WHERE rn <= {}",
+            functionName_,
             limit));
 
     // Do not emit row numbers.
     plan = PlanBuilder()
                .values({data})
-               .topNRowNumber({"c0"}, {"c1"}, limit, false)
+               .topNRank(functionName_, {"c0"}, {"c1"}, limit, false)
                .planNode();
 
     assertQuery(
         plan,
         fmt::format(
-            "SELECT c0, c1, c2 FROM (SELECT *, row_number() over (partition by c0 order by c1) as rn FROM tmp) "
+            "SELECT c0, c1, c2 FROM (SELECT *, {}() over (partition by c0 order by c1) as rn FROM tmp) "
             " WHERE rn <= {}",
+            functionName_,
             limit));
 
     // No partitioning keys.
     plan = PlanBuilder()
                .values({data})
-               .topNRowNumber({}, {"c1"}, limit, true)
+               .topNRank(functionName_, {}, {"c1"}, limit, true)
                .planNode();
     assertQuery(
         plan,
         fmt::format(
-            "SELECT * FROM (SELECT *, row_number() over (order by c1) as rn FROM tmp) "
+            "SELECT * FROM (SELECT *, {}() over (order by c1) as rn FROM tmp) "
             " WHERE rn <= {}",
+            functionName_,
             limit));
   };
 
@@ -91,7 +168,7 @@ TEST_F(TopNRowNumberTest, basic) {
   testLimit(5);
 }
 
-TEST_F(TopNRowNumberTest, largeOutput) {
+TEST_P(MultiTopNRowNumberTest, largeOutput) {
   // Make 10 vectors. Use different types for partitioning key, sorting key and
   // data. Use order of columns different from partitioning keys, followed by
   // sorting keys, followed by data.
@@ -112,20 +189,21 @@ TEST_F(TopNRowNumberTest, largeOutput) {
 
   createDuckDbTable(data);
 
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
 
   auto testLimit = [&](auto limit) {
     SCOPED_TRACE(fmt::format("Limit: {}", limit));
     core::PlanNodeId topNRowNumberId;
     auto plan = PlanBuilder()
                     .values(data)
-                    .topNRowNumber({"p"}, {"s"}, limit, true)
+                    .topNRank(functionName_, {"p"}, {"s"}, limit, true)
                     .capturePlanNodeId(topNRowNumberId)
                     .planNode();
 
     auto sql = fmt::format(
-        "SELECT * FROM (SELECT *, row_number() over (partition by p order by s) as rn FROM tmp) "
+        "SELECT * FROM (SELECT *, {}() over (partition by p order by s) as rn FROM tmp) "
         " WHERE rn <= {}",
+        functionName_,
         limit);
     AssertQueryBuilder(plan, duckDbQueryRunner_)
         .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
@@ -154,15 +232,17 @@ TEST_F(TopNRowNumberTest, largeOutput) {
     // No partitioning keys.
     plan = PlanBuilder()
                .values(data)
-               .topNRowNumber({}, {"s"}, limit, true)
+               .topNRank(functionName_, {}, {"s"}, limit, true)
                .planNode();
 
     AssertQueryBuilder(plan, duckDbQueryRunner_)
         .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
-        .assertResults(fmt::format(
-            "SELECT * FROM (SELECT *, row_number() over (order by s) as rn FROM tmp) "
-            " WHERE rn <= {}",
-            limit));
+        .assertResults(
+            fmt::format(
+                "SELECT * FROM (SELECT *, {}() over (order by s) as rn FROM tmp) "
+                " WHERE rn <= {}",
+                functionName_,
+                limit));
   };
 
   testLimit(1);
@@ -172,7 +252,7 @@ TEST_F(TopNRowNumberTest, largeOutput) {
   testLimit(2000);
 }
 
-TEST_F(TopNRowNumberTest, manyPartitions) {
+TEST_P(MultiTopNRowNumberTest, manyPartitions) {
   const vector_size_t size = 10'000;
   auto data = split(
       makeRowVector(
@@ -196,20 +276,21 @@ TEST_F(TopNRowNumberTest, manyPartitions) {
 
   createDuckDbTable(data);
 
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
 
   auto testLimit = [&](auto limit, size_t outputBatchBytes = 1024) {
     SCOPED_TRACE(fmt::format("Limit: {}", limit));
     core::PlanNodeId topNRowNumberId;
     auto plan = PlanBuilder()
                     .values(data)
-                    .topNRowNumber({"p"}, {"s"}, limit, true)
+                    .topNRank(functionName_, {"p"}, {"s"}, limit, true)
                     .capturePlanNodeId(topNRowNumberId)
                     .planNode();
 
     auto sql = fmt::format(
-        "SELECT * FROM (SELECT *, row_number() over (partition by p order by s) as rn FROM tmp) "
+        "SELECT * FROM (SELECT *, {}() over (partition by p order by s) as rn FROM tmp) "
         " WHERE rn <= {}",
+        functionName_,
         limit);
     assertQuery(plan, sql);
 
@@ -243,7 +324,7 @@ TEST_F(TopNRowNumberTest, manyPartitions) {
   testLimit(1, 1);
 }
 
-TEST_F(TopNRowNumberTest, fewPartitions) {
+TEST_P(MultiTopNRowNumberTest, fewPartitions) {
   const vector_size_t size = 10'000;
   auto data = split(
       makeRowVector(
@@ -267,20 +348,21 @@ TEST_F(TopNRowNumberTest, fewPartitions) {
 
   createDuckDbTable(data);
 
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
 
   auto testLimit = [&](auto limit, size_t outputBatchBytes = 1024) {
     SCOPED_TRACE(fmt::format("Limit: {}", limit));
     core::PlanNodeId topNRowNumberId;
     auto plan = PlanBuilder()
                     .values(data)
-                    .topNRowNumber({"p"}, {"s"}, limit, true)
+                    .topNRank(functionName_, {"p"}, {"s"}, limit, true)
                     .capturePlanNodeId(topNRowNumberId)
                     .planNode();
 
     auto sql = fmt::format(
-        "SELECT * FROM (SELECT *, row_number() over (partition by p order by s) as rn FROM tmp) "
+        "SELECT * FROM (SELECT *, {}() over (partition by p order by s) as rn FROM tmp) "
         " WHERE rn <= {}",
+        functionName_,
         limit);
     assertQuery(plan, sql);
 
@@ -312,7 +394,7 @@ TEST_F(TopNRowNumberTest, fewPartitions) {
   testLimit(100);
 }
 
-TEST_F(TopNRowNumberTest, abandonPartialEarly) {
+TEST_P(MultiTopNRowNumberTest, abandonPartialEarly) {
   auto data = makeRowVector(
       {"p", "s"},
       {
@@ -326,9 +408,9 @@ TEST_F(TopNRowNumberTest, abandonPartialEarly) {
   auto runPlan = [&](int32_t minRows) {
     auto plan = PlanBuilder()
                     .values(split(data, 10))
-                    .topNRowNumber({"p"}, {"s"}, 99, false)
+                    .topNRank(functionName_, {"p"}, {"s"}, 99, false)
                     .capturePlanNodeId(topNRowNumberId)
-                    .topNRowNumber({"p"}, {"s"}, 99, true)
+                    .topNRank(functionName_, {"p"}, {"s"}, 99, true)
                     .planNode();
     auto task =
         AssertQueryBuilder(plan, duckDbQueryRunner_)
@@ -337,8 +419,10 @@ TEST_F(TopNRowNumberTest, abandonPartialEarly) {
                 fmt::format("{}", minRows))
             .config(core::QueryConfig::kAbandonPartialTopNRowNumberMinPct, "80")
             .assertResults(
-                "SELECT * FROM (SELECT *, row_number() over (partition by p order by s) as rn FROM tmp) "
-                "WHERE rn <= 99");
+                fmt::format(
+                    "SELECT * FROM (SELECT *, {}() over (partition by p order by s) as rn FROM tmp) "
+                    "WHERE rn <= 99",
+                    functionName_));
 
     return exec::toPlanStats(task->taskStats());
   };
@@ -360,7 +444,7 @@ TEST_F(TopNRowNumberTest, abandonPartialEarly) {
   }
 }
 
-TEST_F(TopNRowNumberTest, planNodeValidation) {
+TEST_P(MultiTopNRowNumberTest, planNodeValidation) {
   auto data = makeRowVector(
       ROW({"a", "b", "c", "d", "e"},
           {
@@ -377,7 +461,7 @@ TEST_F(TopNRowNumberTest, planNodeValidation) {
                   int32_t limit = 10) {
     PlanBuilder()
         .values({data})
-        .topNRowNumber(partitionKeys, sortingKeys, limit, true)
+        .topNRank(functionName_, partitionKeys, sortingKeys, limit, true)
         .planNode();
   };
 
@@ -403,15 +487,16 @@ TEST_F(TopNRowNumberTest, planNodeValidation) {
       plan({"a", "b"}, {"c"}, 0), "Limit must be greater than zero");
 }
 
-TEST_F(TopNRowNumberTest, maxSpillBytes) {
+TEST_P(MultiTopNRowNumberTest, maxSpillBytes) {
   const auto rowType =
       ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), VARCHAR()});
   const auto vectors = createVectors(rowType, 1024, 15 << 20);
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   auto plan = PlanBuilder(planNodeIdGenerator)
                   .values(vectors)
-                  .topNRowNumber({"c0"}, {"c1"}, 100, true)
+                  .topNRank(functionName_, {"c0"}, {"c1"}, 100, true)
                   .planNode();
+
   struct {
     int32_t maxSpilledBytes;
     bool expectedExceedLimit;
@@ -420,7 +505,7 @@ TEST_F(TopNRowNumberTest, maxSpillBytes) {
     }
   } testSettings[] = {{1 << 30, false}, {13 << 20, true}, {0, false}};
 
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
   auto queryCtx = core::QueryCtx::create(executor_.get());
 
   for (const auto& testData : testSettings) {
@@ -451,7 +536,7 @@ TEST_F(TopNRowNumberTest, maxSpillBytes) {
 
 // This test verifies that TopNRowNumber operator reclaim all the memory after
 // spill.
-DEBUG_ONLY_TEST_F(TopNRowNumberTest, memoryUsageCheckAfterReclaim) {
+DEBUG_ONLY_TEST_P(MultiTopNRowNumberTest, memoryUsageCheckAfterReclaim) {
   std::atomic_int inputCount{0};
   SCOPED_TESTVALUE_SET(
       "facebook::velox::exec::Driver::runInternal::addInput",
@@ -491,18 +576,19 @@ DEBUG_ONLY_TEST_F(TopNRowNumberTest, memoryUsageCheckAfterReclaim) {
 
   createDuckDbTable(data);
 
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
 
   core::PlanNodeId topNRowNumberId;
   auto plan = PlanBuilder()
                   .values(data)
-                  .topNRowNumber({"p"}, {"s"}, 1'000, true)
+                  .topNRank(functionName_, {"p"}, {"s"}, 1'000, true)
                   .capturePlanNodeId(topNRowNumberId)
                   .planNode();
 
-  const auto sql =
-      "SELECT * FROM (SELECT *, row_number() over (partition by p order by s) as rn FROM tmp) "
-      " WHERE rn <= 1000";
+  const auto sql = fmt::format(
+      "SELECT * FROM (SELECT *, {}() over (partition by p order by s) as rn FROM tmp) "
+      " WHERE rn <= 1000",
+      functionName_);
   auto task = AssertQueryBuilder(plan, duckDbQueryRunner_)
                   .config(core::QueryConfig::kSpillEnabled, "true")
                   .config(core::QueryConfig::kTopNRowNumberSpillEnabled, "true")
@@ -520,7 +606,7 @@ DEBUG_ONLY_TEST_F(TopNRowNumberTest, memoryUsageCheckAfterReclaim) {
 
 // This test verifies that TopNRowNumber operator can be closed twice which
 // might be triggered by memory pool abort.
-DEBUG_ONLY_TEST_F(TopNRowNumberTest, doubleClose) {
+DEBUG_ONLY_TEST_P(MultiTopNRowNumberTest, doubleClose) {
   const std::string errorMessage("doubleClose");
   SCOPED_TESTVALUE_SET(
       "facebook::velox::exec::Driver::runInternal::noMoreInput",
@@ -556,15 +642,72 @@ DEBUG_ONLY_TEST_F(TopNRowNumberTest, doubleClose) {
   core::PlanNodeId topNRowNumberId;
   auto plan = PlanBuilder()
                   .values(data)
-                  .topNRowNumber({"p"}, {"s"}, 1'000, true)
+                  .topNRank(functionName_, {"p"}, {"s"}, 1'000, true)
                   .capturePlanNodeId(topNRowNumberId)
                   .planNode();
 
-  const auto sql =
-      "SELECT * FROM (SELECT *, row_number() over (partition by p order by s) as rn FROM tmp) "
-      " WHERE rn <= 1000";
+  const auto sql = fmt::format(
+      "SELECT * FROM (SELECT *, {}() over (partition by p order by s) as rn FROM tmp) "
+      " WHERE rn <= 1000",
+      functionName_);
 
   VELOX_ASSERT_THROW(assertQuery(plan, sql), errorMessage);
 }
+
+// This test verifies that TopNRowNumber operator handles OOM that occurs in the
+// middle of groupProbe, after inserting some new rows into the row container.
+DEBUG_ONLY_TEST_P(MultiTopNRowNumberTest, oomInGroupProbe) {
+  const std::string errorMessage("Simulated OOM in groupProbe");
+  std::atomic_int insertCount{0};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashTable::insertEntry",
+      std::function<void(memory::MemoryPool*)>(
+          ([&](memory::MemoryPool* /*pool*/) {
+            // Trigger OOM after inserting some rows to simulate failure in the
+            // middle of groupProbe insertion.
+            if (++insertCount == 100) {
+              VELOX_FAIL(errorMessage);
+            }
+          })));
+
+  const vector_size_t size = 10'000;
+  auto data = split(
+      makeRowVector(
+          {"d", "s", "p"},
+          {
+              // Data.
+              makeFlatVector<int64_t>(
+                  size, [](auto row) { return row; }, nullEvery(11)),
+              // Sorting key.
+              makeFlatVector<int64_t>(
+                  size,
+                  [](auto row) { return (size - row) * 10; },
+                  [](auto row) { return row == 123; }),
+              // Partitioning key. Make sure to spread rows from the same
+              // partition across multiple batches.
+              makeFlatVector<int64_t>(
+                  size, [](auto row) { return row % 5'000; }, nullEvery(7)),
+          }),
+      10);
+
+  core::PlanNodeId topNRowNumberId;
+  auto plan = PlanBuilder()
+                  .values(data)
+                  .topNRank(functionName_, {"p"}, {"s"}, 1'000, true)
+                  .capturePlanNodeId(topNRowNumberId)
+                  .planNode();
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan).copyResults(pool_.get()), errorMessage);
+}
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    TopNRowNumberTest,
+    MultiTopNRowNumberTest,
+    testing::ValuesIn(
+        std::vector<core::TopNRowNumberNode::RankFunction>(
+            {core::TopNRowNumberNode::RankFunction::kRowNumber,
+             core::TopNRowNumberNode::RankFunction::kRank,
+             core::TopNRowNumberNode::RankFunction::kDenseRank})));
 } // namespace
 } // namespace facebook::velox::exec
diff --git a/velox/exec/tests/TraceUtilTest.cpp b/velox/exec/tests/TraceUtilTest.cpp
index acb94280ba5..c5fdab5ff65 100644
--- a/velox/exec/tests/TraceUtilTest.cpp
+++ b/velox/exec/tests/TraceUtilTest.cpp
@@ -21,13 +21,13 @@
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/file/tests/FaultyFileSystem.h"
-#include "velox/exec/Trace.h"
-#include "velox/exec/TraceUtil.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
-
-using namespace facebook::velox::exec::test;
+#include "velox/common/testutil/TempDirectoryPath.h"
+#include "velox/exec/trace/Trace.h"
+#include "velox/exec/trace/TraceUtil.h"
 
 namespace facebook::velox::exec::trace::test {
+using namespace facebook::velox::common::testutil;
+
 class TraceUtilTest : public testing::Test {
  protected:
   static void SetUpTestCase() {
@@ -253,7 +253,7 @@ TEST_F(TraceUtilTest, getDriverIds) {
 }
 
 TEST_F(TraceUtilTest, createTraceDirectoryTest) {
-  auto tmpRootDir = exec::test::TempDirectoryPath::create();
+  auto tmpRootDir = TempDirectoryPath::create();
   auto tmpTraceDir = fmt::format(
       "{}{}/trace",
       tests::utils::FaultyFileSystem::scheme(),
diff --git a/velox/exec/tests/TreeOfLosersTest.cpp b/velox/exec/tests/TreeOfLosersTest.cpp
index 8e193e40fcd..0a56a4f4970 100644
--- a/velox/exec/tests/TreeOfLosersTest.cpp
+++ b/velox/exec/tests/TreeOfLosersTest.cpp
@@ -181,8 +181,9 @@ TEST_F(TreeOfLosersTest, allSorted) {
 TEST_F(TreeOfLosersTest, allEmpty) {
   for (bool testNextEqual : {false, true}) {
     for (int numStreams : {0, 1, 5, 100}) {
-      SCOPED_TRACE(fmt::format(
-          "numStreams: {}, testNextEqual", numStreams, testNextEqual));
+      SCOPED_TRACE(
+          fmt::format(
+              "numStreams: {}, testNextEqual", numStreams, testNextEqual));
       std::vector<std::unique_ptr<TestingStream>> mergeStreams;
       for (int i = 0; i < numStreams; ++i) {
         mergeStreams.push_back(
@@ -211,12 +212,13 @@ TEST_F(TreeOfLosersTest, randomWithDuplicates) {
     for (int iter = 0; iter < 10; ++iter) {
       const int numCount = std::max<int>(1, folly::Random::rand32(1000'000));
       const int numStreams = std::max<int>(3, folly::Random::rand32(100));
-      SCOPED_TRACE(fmt::format(
-          "iter: {}, testNextEqual: {}, numCount: {}, numStreams: {}",
-          iter,
-          testNextEqual,
-          numCount,
-          numStreams));
+      SCOPED_TRACE(
+          fmt::format(
+              "iter: {}, testNextEqual: {}, numCount: {}, numStreams: {}",
+              iter,
+              testNextEqual,
+              numCount,
+              numStreams));
       std::vector<std::vector<uint32_t>> streamNumVectors(numStreams);
       for (int i = 0; i < numCount; ++i) {
         const int streamIndex = folly::Random::rand32(numStreams);
diff --git a/velox/exec/tests/UnnestTest.cpp b/velox/exec/tests/UnnestTest.cpp
index 53979988f05..d35a2deaa71 100644
--- a/velox/exec/tests/UnnestTest.cpp
+++ b/velox/exec/tests/UnnestTest.cpp
@@ -15,15 +15,16 @@
  */
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/testutil/OptionalEmpty.h"
+#include "velox/common/testutil/TempFilePath.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempFilePath.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
+using namespace facebook::velox::common::testutil;
 
 class UnnestTest : public HiveConnectorTestBase,
                    public testing::WithParamInterface<vector_size_t> {
@@ -285,7 +286,7 @@ TEST_P(UnnestTest, arrayWithOrdinality) {
   assertQuery(params, expectedInDict);
 }
 
-TEST_P(UnnestTest, arrayWithEmptyUnnestValue) {
+TEST_P(UnnestTest, arrayWithMarker) {
   const auto array = makeArrayVectorFromJson<int32_t>(
       {"[1, 2, null, 4]", "null", "[5, 6]", "[]", "[null]", "[7, 8, 9]"});
   const auto input = makeRowVector(
@@ -312,7 +313,7 @@ TEST_P(UnnestTest, arrayWithEmptyUnnestValue) {
        expected->childAt(1),
        makeNullableFlatVector<int64_t>({1, 2, 3, 4, 1, 2, 1, 1, 2, 3})});
 
-  const auto expectedWithEmptyUnnestValue = makeRowVector(
+  const auto expectedWithMarker = makeRowVector(
       {makeNullableFlatVector<double>(
            {1.1,
             1.1,
@@ -340,23 +341,23 @@ TEST_P(UnnestTest, arrayWithEmptyUnnestValue) {
             8,
             9}),
        makeNullableFlatVector<bool>(
-           {false,
-            false,
-            false,
-            false,
+           {true,
+            true,
             true,
-            false,
-            false,
             true,
             false,
+            true,
+            true,
             false,
-            false,
-            false})});
+            true,
+            true,
+            true,
+            true})});
   const auto expectedWithBoth = makeRowVector(
-      {expectedWithEmptyUnnestValue->childAt(0),
-       expectedWithEmptyUnnestValue->childAt(1),
+      {expectedWithMarker->childAt(0),
+       expectedWithMarker->childAt(1),
        makeNullableFlatVector<int64_t>({1, 2, 3, 4, 0, 1, 2, 0, 1, 1, 2, 3}),
-       expectedWithEmptyUnnestValue->childAt(2)});
+       expectedWithMarker->childAt(2)});
 
   struct {
     bool hasOrdinality;
@@ -375,7 +376,7 @@ TEST_P(UnnestTest, arrayWithEmptyUnnestValue) {
   } testSettings[] = {
       {false, false, input, expected},
       {true, false, input, expectedWithOrdinality},
-      {false, true, input, expectedWithEmptyUnnestValue},
+      {false, true, input, expectedWithMarker},
       {true, true, input, expectedWithBoth}};
 
   for (const auto& testData : testSettings) {
@@ -385,13 +386,13 @@ TEST_P(UnnestTest, arrayWithEmptyUnnestValue) {
     if (testData.hasOrdinality) {
       ordinalityName = "ordinal";
     }
-    std::optional<std::string> emptyUnnestValueName;
+    std::optional<std::string> markerName;
     if (testData.hasEmptyUnnestValue) {
-      emptyUnnestValueName = "emptyUnnestValue";
+      markerName = "emptyUnnestValue";
     }
     auto op = PlanBuilder()
                   .values({testData.input})
-                  .unnest({"c0"}, {"c1"}, ordinalityName, emptyUnnestValueName)
+                  .unnest({"c0"}, {"c1"}, ordinalityName, markerName)
                   .planNode();
     auto params = makeCursorParameters(op);
     assertQuery(params, testData.expected);
@@ -466,7 +467,7 @@ TEST_P(UnnestTest, mapWithOrdinality) {
   assertQuery(params, expectedInDict);
 }
 
-TEST_P(UnnestTest, mapWithEmptyUnnestValue) {
+TEST_P(UnnestTest, mapWithMarker) {
   const auto map = makeNullableMapVector<int32_t, double>(
       {{{{1, 1.1}, {2, std::nullopt}}},
        common::testutil::optionalEmpty,
@@ -489,7 +490,7 @@ TEST_P(UnnestTest, mapWithEmptyUnnestValue) {
        expected->childAt(2),
        makeNullableFlatVector<int64_t>({1, 2, 1, 2, 3, 1})});
 
-  const auto expectedWithEmptyUnnestValue = makeRowVector(
+  const auto expectedWithMarker = makeRowVector(
       {makeNullableFlatVector<int32_t>({1, 1, 2, 3, 3, 3, 4, 5}),
        makeNullableFlatVector<int32_t>(
            {1, 2, std::nullopt, 3, 4, 5, std::nullopt, 6}),
@@ -503,14 +504,14 @@ TEST_P(UnnestTest, mapWithEmptyUnnestValue) {
             std::nullopt,
             std::nullopt}),
        makeNullableFlatVector<bool>(
-           {false, false, true, false, false, false, true, false})});
+           {true, true, false, true, true, true, false, true})});
 
   const auto expectedWithBoth = makeRowVector(
-      {expectedWithEmptyUnnestValue->childAt(0),
-       expectedWithEmptyUnnestValue->childAt(1),
-       expectedWithEmptyUnnestValue->childAt(2),
+      {expectedWithMarker->childAt(0),
+       expectedWithMarker->childAt(1),
+       expectedWithMarker->childAt(2),
        makeNullableFlatVector<int64_t>({1, 2, 0, 1, 2, 3, 0, 1}),
-       expectedWithEmptyUnnestValue->childAt(3)});
+       expectedWithMarker->childAt(3)});
 
   struct {
     bool hasOrdinality;
@@ -529,7 +530,7 @@ TEST_P(UnnestTest, mapWithEmptyUnnestValue) {
   } testSettings[] = {
       {false, false, input, expected},
       {true, false, input, expectedWithOrdinality},
-      {false, true, input, expectedWithEmptyUnnestValue},
+      {false, true, input, expectedWithMarker},
       {true, true, input, expectedWithBoth}};
 
   for (const auto& testData : testSettings) {
@@ -539,13 +540,13 @@ TEST_P(UnnestTest, mapWithEmptyUnnestValue) {
     if (testData.hasOrdinality) {
       ordinalityName = "ordinal";
     }
-    std::optional<std::string> emptyUnnestValueName;
+    std::optional<std::string> markerName;
     if (testData.hasEmptyUnnestValue) {
-      emptyUnnestValueName = "emptyUnnestValue";
+      markerName = "emptyUnnestValue";
     }
     auto op = PlanBuilder()
                   .values({testData.input})
-                  .unnest({"c0"}, {"c1"}, ordinalityName, emptyUnnestValueName)
+                  .unnest({"c0"}, {"c1"}, ordinalityName, markerName)
                   .planNode();
     auto params = makeCursorParameters(op);
     assertQuery(params, testData.expected);
@@ -848,15 +849,16 @@ TEST_P(UnnestTest, barrier) {
   // Unnest 1K rows into 3K rows.
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   core::PlanNodeId unnestPlanNodeId;
-  const auto plan = PlanBuilder(planNodeIdGenerator)
-                        .startTableScan()
-                        .outputType(std::dynamic_pointer_cast<const RowType>(
-                            vectors[0]->type()))
-                        .endTableScan()
-                        .project({"sequence(1, 3) as s"})
-                        .unnest({}, {"s"})
-                        .capturePlanNodeId(unnestPlanNodeId)
-                        .planNode();
+  const auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .startTableScan()
+          .outputType(
+              std::dynamic_pointer_cast<const RowType>(vectors[0]->type()))
+          .endTableScan()
+          .project({"sequence(1, 3) as s"})
+          .unnest({}, {"s"})
+          .capturePlanNodeId(unnestPlanNodeId)
+          .planNode();
 
   const auto expectedResult = makeRowVector({
       makeFlatVector<int64_t>(
@@ -866,15 +868,22 @@ TEST_P(UnnestTest, barrier) {
 
   struct {
     bool barrierExecution;
+    bool serialExecution;
     int numOutputRows;
 
     std::string toString() const {
       return fmt::format(
-          "barrierExecution {}, numOutputRows {}",
+          "barrierExecution {}, serialExecution {}, numOutputRows {}",
           barrierExecution,
+          serialExecution,
           numOutputRows);
     }
-  } testSettings[] = {{true, 23}, {false, 23}, {true, 200}, {false, 200}};
+  } testSettings[] = {
+      {true, true, 23},
+      {true, false, 23},
+      {false, true, 200},
+      {false, false, 200},
+  };
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.toString());
     const int numExpectedOutputVectors =
@@ -886,7 +895,8 @@ TEST_P(UnnestTest, barrier) {
                         core::QueryConfig::kMaxSplitPreloadPerDriver,
                         std::to_string(tempFiles.size()))
                     .splits(makeHiveConnectorSplits(tempFiles))
-                    .serialExecution(true)
+                    .serialExecution(testData.serialExecution)
+                    .maxDrivers(testData.serialExecution ? 1 : 3)
                     .barrierExecution(testData.barrierExecution)
                     .config(
                         core::QueryConfig::kPreferredOutputBatchRows,
@@ -936,13 +946,13 @@ TEST_P(UnnestTest, spiltOutput) {
 
   struct {
     bool produceSingleOutput;
-    int expectedNumOutputExectors;
+    int expectedNumOutputVectors;
 
     std::string toString() const {
       return fmt::format(
-          "produceSingleOutput {}, expectedNumOutputExectors {}",
+          "produceSingleOutput {}, expectedNumOutputVectors {}",
           produceSingleOutput,
-          expectedNumOutputExectors);
+          expectedNumOutputVectors);
     }
   } testSettings[] = {
       {true, numBatches},
@@ -960,7 +970,100 @@ TEST_P(UnnestTest, spiltOutput) {
     const auto taskStats = task->taskStats();
     ASSERT_EQ(
         exec::toPlanStats(taskStats).at(unnestPlanNodeId).outputVectors,
-        testData.expectedNumOutputExectors);
+        testData.expectedNumOutputVectors);
+  }
+}
+
+// Test that UnnestNode::splitOutput overrides query config.
+TEST_P(UnnestTest, splitOutputNodeOverride) {
+  const auto numBatches = 3;
+  const auto inputBatchSize = 256;
+  std::vector<RowVectorPtr> vectors;
+  vectors.reserve(numBatches);
+  for (int32_t i = 0; i < numBatches; ++i) {
+    vectors.push_back(makeRowVector({
+        makeFlatVector<int64_t>(inputBatchSize, [](auto row) { return row; }),
+    }));
+  }
+
+  const auto expectedResult = makeRowVector({
+      makeFlatVector<int64_t>(
+          numBatches * 3 * inputBatchSize,
+          [](auto row) { return 1 + row % 3; }),
+  });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  // Create a plan with project node to generate the sequence.
+  auto projectPlan = PlanBuilder(planNodeIdGenerator)
+                         .values(vectors)
+                         .project({"sequence(1, 3) as s"})
+                         .planNode();
+
+  // Get the output type from the project node.
+  auto projectOutput = projectPlan->outputType();
+  std::vector<std::shared_ptr<const core::FieldAccessTypedExpr>> unnestFields;
+  unnestFields.emplace_back(
+      std::make_shared<core::FieldAccessTypedExpr>(
+          projectOutput->childAt(0), "s"));
+
+  struct {
+    std::optional<bool> nodeSplitOutput;
+    bool configSplitOutput{};
+    bool expectSplit{};
+
+    std::string toString() const {
+      return fmt::format(
+          "nodeSplitOutput: {}, configSplitOutput: {}, expectSplit: {}",
+          nodeSplitOutput.has_value()
+              ? (nodeSplitOutput.value() ? "true" : "false")
+              : "nullopt",
+          configSplitOutput,
+          expectSplit);
+    }
+  } testSettings[] = {
+      // Node splitOutput not set, use config.
+      {std::nullopt, true, true},
+      {std::nullopt, false, false},
+      // Node splitOutput=true overrides config.
+      {true, true, true},
+      {true, false, true},
+      // Node splitOutput=false overrides config.
+      {false, true, false},
+      {false, false, false},
+  };
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.toString());
+
+    core::PlanNodeId unnestPlanNodeId;
+    auto unnestNode = std::make_shared<core::UnnestNode>(
+        planNodeIdGenerator->next(),
+        std::vector<std::shared_ptr<const core::FieldAccessTypedExpr>>{},
+        unnestFields,
+        std::vector<std::string>{"s_e"},
+        std::nullopt,
+        std::nullopt,
+        testData.nodeSplitOutput,
+        projectPlan);
+    unnestPlanNodeId = unnestNode->id();
+
+    const int expectedNumOutputVectors = testData.expectSplit
+        ? bits::divRoundUp(inputBatchSize * 3, GetParam()) * numBatches
+        : numBatches;
+
+    auto task = AssertQueryBuilder(unnestNode)
+                    .config(
+                        core::QueryConfig::kPreferredOutputBatchRows,
+                        std::to_string(GetParam()))
+                    .config(
+                        core::QueryConfig::kUnnestSplitOutput,
+                        testData.configSplitOutput ? "true" : "false")
+                    .assertResults(expectedResult);
+    const auto taskStats = task->taskStats();
+    ASSERT_EQ(
+        exec::toPlanStats(taskStats).at(unnestPlanNodeId).outputVectors,
+        expectedNumOutputVectors);
   }
 }
 
diff --git a/velox/exec/tests/ValuesTest.cpp b/velox/exec/tests/ValuesTest.cpp
index 368fb17bfb5..ed8218e3c97 100644
--- a/velox/exec/tests/ValuesTest.cpp
+++ b/velox/exec/tests/ValuesTest.cpp
@@ -47,7 +47,9 @@ class ValuesTest : public OperatorTestBase {
 
 TEST_F(ValuesTest, empty) {
   // Base case: no vectors.
-  AssertQueryBuilder(PlanBuilder().values({}).planNode()).assertEmptyResults();
+  AssertQueryBuilder(
+      PlanBuilder().values(std::vector<RowVectorPtr>{}).planNode())
+      .assertEmptyResults();
 
   // Empty input vector.
   auto emptyInput = makeRowVector({});
diff --git a/velox/exec/tests/VectorHasherTest.cpp b/velox/exec/tests/VectorHasherTest.cpp
index 2a3cb8ef9f7..deca96c94ac 100644
--- a/velox/exec/tests/VectorHasherTest.cpp
+++ b/velox/exec/tests/VectorHasherTest.cpp
@@ -462,14 +462,15 @@ TEST_F(VectorHasherTest, stringDistinctOverflow) {
   for (auto i = 0; i < 7; ++i) {
     auto& stringVec = strings[i];
     stringVec.resize(numRows);
-    batches.emplace_back(makeFlatVector<StringView>(
-        numRows, [&i, &stringVec, numRows](vector_size_t row) {
-          const auto num = numRows * i + row;
-          stringVec[row] = (row != 0)
-              ? fmt::format("abcdefghijabcdefghij{}", num)
-              : fmt::format("s{}", num);
-          return StringView(stringVec[row]);
-        }));
+    batches.emplace_back(
+        makeFlatVector<StringView>(
+            numRows, [&i, &stringVec, numRows](vector_size_t row) {
+              const auto num = numRows * i + row;
+              stringVec[row] = (row != 0)
+                  ? fmt::format("abcdefghijabcdefghij{}", num)
+                  : fmt::format("s{}", num);
+              return StringView(stringVec[row]);
+            }));
   }
 
   SelectivityVector rows(numRows, true);
@@ -680,9 +681,9 @@ TEST_F(VectorHasherTest, merge) {
   VectorHasher emptyHasher(BIGINT(), 0);
   VectorHasher otherEmptyHasher(BIGINT(), 0);
   EXPECT_TRUE(emptyHasher.empty());
-  emptyHasher.merge(otherHasher);
-  hasher.merge(emptyHasher);
-  hasher.merge(otherEmptyHasher);
+  emptyHasher.merge(otherHasher, 1'000'000);
+  hasher.merge(emptyHasher, 1'000'000);
+  hasher.merge(otherEmptyHasher, 1'000'000);
   uint64_t numRange;
   uint64_t numDistinct;
   hasher.cardinality(0, numRange, numDistinct);
@@ -720,6 +721,45 @@ TEST_F(VectorHasherTest, merge) {
   EXPECT_EQ(numDistinct - 1, ids.size());
 }
 
+TEST_F(VectorHasherTest, mergeMaxNumDistinct) {
+  constexpr vector_size_t kSize = 100;
+  SelectivityVector rows(kSize);
+  raw_vector<uint64_t> hashes(kSize);
+
+  auto vector1 =
+      makeFlatVector<int64_t>(kSize, [](vector_size_t row) { return row; });
+  auto vector2 = makeFlatVector<int64_t>(
+      kSize, [](vector_size_t row) { return 1000 + row; });
+  auto vector3 = makeFlatVector<int64_t>(
+      kSize, [](vector_size_t row) { return 2000 + row; });
+
+  VectorHasher hasher1(BIGINT(), 0);
+  hasher1.decode(*vector1, rows);
+  hasher1.computeValueIds(rows, hashes);
+
+  VectorHasher hasher2(BIGINT(), 0);
+  hasher2.decode(*vector2, rows);
+  hasher2.computeValueIds(rows, hashes);
+
+  VectorHasher hasher3(BIGINT(), 0);
+  hasher3.decode(*vector3, rows);
+  hasher3.computeValueIds(rows, hashes);
+
+  hasher1.merge(hasher2, kSize * 2);
+  uint64_t numRange;
+  uint64_t numDistinct;
+  hasher1.cardinality(0, numRange, numDistinct);
+  EXPECT_EQ(numDistinct, kSize * 2 + 1);
+
+  hasher1.merge(hasher3, kSize * 2);
+  hasher1.cardinality(0, numRange, numDistinct);
+  EXPECT_EQ(numDistinct, VectorHasher::kRangeTooLarge);
+
+  hasher1.merge(hasher3, kSize * 10);
+  hasher1.cardinality(0, numRange, numDistinct);
+  EXPECT_EQ(numDistinct, VectorHasher::kRangeTooLarge);
+}
+
 TEST_F(VectorHasherTest, computeValueIdsBigint) {
   testComputeValueIds<int64_t>(false);
   testComputeValueIds<int64_t>(true);
@@ -1061,6 +1101,52 @@ TEST_F(VectorHasherTest, simdRange) {
   }
 }
 
+TEST_F(VectorHasherTest, lookupValueIdsDictionaryWithLargerBase) {
+  auto base = makeNullableFlatVector<int32_t>({10, 11, 12, 13, 14, 15});
+
+  auto hasher = VectorHasher::create(INTEGER(), 0);
+  raw_vector<uint64_t> result(8, pool());
+  std::fill(result.begin(), result.end(), 0);
+  SelectivityVector allRows(base->size());
+  hasher->decode(*base, allRows);
+  hasher->computeValueIds(allRows, result);
+
+  auto probeBase =
+      makeNullableFlatVector<int32_t>({15, 100, 11, 14, std::nullopt, 10});
+  auto indices = makeIndices(8, [](vector_size_t row) {
+    static constexpr vector_size_t kIndices[] = {0, 1, 2, 3, 4, 5, 0, 2};
+    return kIndices[row];
+  });
+  auto probe =
+      BaseVector::wrapInDictionary(BufferPtr(nullptr), indices, 8, probeBase);
+
+  SelectivityVector rows(8);
+  rows.clearAll();
+  rows.setValid(0, true);
+  rows.setValid(1, true);
+  rows.setValid(2, true);
+  rows.setValid(4, true);
+  rows.setValid(6, true);
+  rows.updateBounds();
+  std::fill(result.begin(), result.end(), 0);
+
+  VectorHasher::ScratchMemory scratch;
+  hasher->lookupValueIds(*probe, rows, scratch, result);
+
+  EXPECT_TRUE(rows.isValid(0));
+  EXPECT_FALSE(rows.isValid(1));
+  EXPECT_TRUE(rows.isValid(2));
+  EXPECT_TRUE(rows.isValid(4));
+  EXPECT_TRUE(rows.isValid(6));
+  EXPECT_EQ(rows.countSelected(), 4);
+
+  EXPECT_EQ(result[0], 6);
+  EXPECT_EQ(result[1], 0);
+  EXPECT_EQ(result[2], 2);
+  EXPECT_EQ(result[4], 0);
+  EXPECT_EQ(result[6], 6);
+}
+
 TEST_F(VectorHasherTest, typeMismatch) {
   auto hasher = VectorHasher::create(BIGINT(), 0);
 
@@ -1197,3 +1283,200 @@ TEST_F(VectorHasherTest, customComparisonRow) {
               {std::nullopt, 0, 1, 0, 1, 0, 1},
               velox::test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON())}));
 }
+
+TEST_F(VectorHasherTest, customComparisonValueIds) {
+  // Test that VectorHasher created with custom comparison type
+  // has value IDs disabled (distinctOverflow_ and rangeOverflow_ set).
+  auto vectorHasher = exec::VectorHasher::create(
+      velox::test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON(), 1);
+
+  // Test that types with custom comparison do not support value IDs.
+  EXPECT_FALSE(vectorHasher->typeSupportsValueIds());
+
+  // Verify that mayUseValueIds() returns false for custom comparison types.
+  EXPECT_FALSE(vectorHasher->mayUseValueIds());
+}
+
+TEST_F(VectorHasherTest, stringFilter) {
+  // Test that getFilter() returns a BytesValues filter for string types.
+  auto vector = makeFlatVector<StringView>(
+      {"apple", "banana", "cherry", "apple", "banana", "date"});
+
+  auto hasher = exec::VectorHasher::create(VARCHAR(), 0);
+  SelectivityVector rows(vector->size());
+  raw_vector<uint64_t> hashes(vector->size());
+
+  // Analyze the sample data.
+  hasher->decode(*vector, rows);
+  hasher->computeValueIds(rows, hashes);
+
+  // Test nullAllowed = false.
+  auto filter = hasher->getFilter(false);
+  ASSERT_TRUE(filter != nullptr);
+
+  auto bytesValues = dynamic_cast<common::BytesValues*>(filter.get());
+  ASSERT_TRUE(bytesValues != nullptr);
+  ASSERT_FALSE(bytesValues->testNull());
+
+  ASSERT_TRUE(bytesValues->testBytes("apple", 5));
+  ASSERT_TRUE(bytesValues->testBytes("banana", 6));
+  ASSERT_TRUE(bytesValues->testBytes("cherry", 6));
+  ASSERT_TRUE(bytesValues->testBytes("date", 4));
+  ASSERT_FALSE(bytesValues->testBytes("elderberry", 10));
+  ASSERT_FALSE(bytesValues->testBytes("fig", 3));
+  ASSERT_FALSE(bytesValues->testBytes("grape", 5));
+
+  // Test nullAllowed = true.
+  auto filterWithNull = hasher->getFilter(true);
+  ASSERT_TRUE(filterWithNull != nullptr);
+
+  auto bytesValuesWithNull =
+      dynamic_cast<common::BytesValues*>(filterWithNull.get());
+  ASSERT_TRUE(bytesValuesWithNull != nullptr);
+  ASSERT_TRUE(bytesValuesWithNull->testNull());
+  ASSERT_TRUE(bytesValuesWithNull->testBytes("apple", 5));
+  ASSERT_FALSE(bytesValuesWithNull->testBytes("unknown", 7));
+}
+
+TEST_F(VectorHasherTest, stringFilterWithLongStrings) {
+  // Test string filter with strings longer than 8 bytes (stored as pointers).
+  // Keep strings in a vector to ensure they persist throughout the test.
+  std::vector<std::string> strings = {
+      "short",
+      "this is a very very very very very long string",
+      "this is a very long string",
+      "short",
+      "medium length",
+  };
+
+  auto vector = makeFlatVector<StringView>(
+      strings.size(),
+      [&strings](vector_size_t row) { return StringView(strings[row]); });
+
+  auto hasher = exec::VectorHasher::create(VARCHAR(), 0);
+  SelectivityVector rows(vector->size());
+  raw_vector<uint64_t> hashes(vector->size());
+
+  // Analyze the data.
+  hasher->decode(*vector, rows);
+  hasher->computeValueIds(rows, hashes);
+
+  // Get the filter.
+  auto filter = hasher->getFilter(false);
+  ASSERT_TRUE(filter != nullptr);
+
+  auto bytesValues = dynamic_cast<common::BytesValues*>(filter.get());
+  ASSERT_TRUE(bytesValues != nullptr);
+
+  // Test that both short and long strings are handled correctly.
+  ASSERT_TRUE(bytesValues->testBytes(strings[0].data(), strings[0].size()));
+  ASSERT_TRUE(bytesValues->testBytes(strings[1].data(), strings[1].size()));
+  ASSERT_TRUE(bytesValues->testBytes(strings[2].data(), strings[2].size()));
+  ASSERT_TRUE(bytesValues->testBytes(strings[4].data(), strings[4].size()));
+
+  // Test rejection of non-existent strings.
+  ASSERT_FALSE(bytesValues->testBytes("not in the set", 14));
+  ASSERT_FALSE(bytesValues->testBytes("different", 9));
+}
+
+TEST_F(VectorHasherTest, stringFilterDistinctOverflow) {
+  // Test that getFilter() returns nullptr when distinctOverflow_ is true.
+  auto hasher = exec::VectorHasher::create(VARCHAR(), 0);
+
+  constexpr uint32_t numRows = 10000;
+  constexpr int numBatches = 15;
+
+  SelectivityVector rows(numRows);
+  raw_vector<uint64_t> hashes(numRows);
+
+  // Process enough batches with distinct strings to trigger overflow.
+  // kMaxDistinct is 100,000, so 15 batches * 10,000 = 150,000 distinct strings.
+  for (int batch = 0; batch < numBatches; ++batch) {
+    std::vector<std::string> strings;
+    strings.resize(numRows);
+
+    // Create distinct strings for each batch.
+    for (auto i = 0; i < numRows; ++i) {
+      strings[i] = fmt::format("batch_{}_string_{}", batch, i);
+    }
+
+    auto vector = makeFlatVector<StringView>(
+        numRows,
+        [&strings](vector_size_t row) { return StringView(strings[row]); });
+
+    hasher->decode(*vector, rows);
+    hasher->computeValueIds(rows, hashes);
+  }
+
+  // After overflow, getFilter should return nullptr.
+  auto filter = hasher->getFilter(false);
+  ASSERT_TRUE(filter == nullptr);
+}
+
+DEBUG_ONLY_TEST_F(VectorHasherTest, customComparisonNoValueIds) {
+  // Test that custom comparison types cannot use value IDs for optimization.
+  auto data = makeRowVector({makeNullableFlatVector<int64_t>(
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
+      velox::test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON())});
+
+  auto hasher = exec::VectorHasher::create(
+      velox::test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON(), 0);
+
+  SelectivityVector allRows(data->size());
+  raw_vector<uint64_t> result(data->size());
+  std::fill(result.begin(), result.end(), 0);
+
+  hasher->decode(*data->childAt(0), allRows);
+
+  VELOX_ASSERT_THROW(
+      hasher->computeValueIds(allRows, result), "Value IDs cannot be used");
+  VectorHasher::ScratchMemory scratchMemory;
+  VELOX_ASSERT_THROW(
+      hasher->lookupValueIds(*data->childAt(0), allRows, scratchMemory, result),
+      "Value IDs cannot be used");
+  EXPECT_EQ(nullptr, hasher->getFilter(true));
+  VELOX_ASSERT_THROW(
+      hasher->enableValueRange(1, 50), "Value IDs cannot be used");
+  VELOX_ASSERT_THROW(
+      hasher->enableValueRange(1, 50), "Value IDs cannot be used");
+}
+
+DEBUG_ONLY_TEST_F(VectorHasherTest, computeValueIdsForRowsCustomComparison) {
+  // Test that computeValueIdsForRows throws an exception for types with custom
+  // comparison.
+  auto hasher = exec::VectorHasher::create(
+      velox::test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON(), 0);
+
+  constexpr int32_t kNumGroups = 5;
+  constexpr int32_t kRowSize = 16;
+  constexpr int32_t kValueOffset = 0;
+  constexpr int32_t kNullByte = 8;
+  constexpr uint8_t kNullMask = 1;
+
+  // Allocate memory for row-wise data.
+  std::vector<std::vector<char>> rowData(kNumGroups);
+  std::vector<char*> groups(kNumGroups);
+
+  for (int i = 0; i < kNumGroups; ++i) {
+    rowData[i].resize(kRowSize, 0);
+    groups[i] = rowData[i].data();
+
+    // Set values for all rows (no nulls for simplicity).
+    *reinterpret_cast<int64_t*>(groups[i] + kValueOffset) = i * 256;
+  }
+
+  raw_vector<uint64_t> result(kNumGroups);
+  std::fill(result.begin(), result.end(), 0);
+
+  // computeValueIdsForRows should throw an exception for types with custom
+  // comparison.
+  VELOX_ASSERT_THROW(
+      hasher->computeValueIdsForRows(
+          groups.data(),
+          kNumGroups,
+          kValueOffset,
+          kNullByte,
+          kNullMask,
+          result),
+      "Value IDs cannot be used");
+}
diff --git a/velox/exec/tests/VeloxIn10MinDemo.cpp b/velox/exec/tests/VeloxIn10MinDemo.cpp
index 87d571a1788..23a57b6bd2c 100644
--- a/velox/exec/tests/VeloxIn10MinDemo.cpp
+++ b/velox/exec/tests/VeloxIn10MinDemo.cpp
@@ -14,10 +14,11 @@
  * limitations under the License.
  */
 #include <folly/init/Init.h>
+#include <folly/system/HardwareConcurrency.h>
 #include "velox/common/memory/Memory.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/tpch/TpchConnector.h"
 #include "velox/connectors/tpch/TpchConnectorSplit.h"
-#include "velox/core/Expressions.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/expression/Expr.h"
@@ -47,33 +48,25 @@ class VeloxIn10MinDemo : public VectorTestBase {
     // Register type resolver with DuckDB SQL parser.
     parse::registerTypeResolver();
 
-    // Register the TPC-H Connector Factory.
-    connector::registerConnectorFactory(
-        std::make_shared<connector::tpch::TpchConnectorFactory>());
-
     // Create and register a TPC-H connector.
-    auto tpchConnector =
-        connector::getConnectorFactory(
-            connector::tpch::TpchConnectorFactory::kTpchConnectorName)
-            ->newConnector(
-                kTpchConnectorId,
-                std::make_shared<config::ConfigBase>(
-                    std::unordered_map<std::string, std::string>()));
-    connector::registerConnector(tpchConnector);
+    connector::tpch::TpchConnectorFactory factory;
+    auto tpchConnector = factory.newConnector(
+        kTpchConnectorId,
+        std::make_shared<config::ConfigBase>(
+            std::unordered_map<std::string, std::string>()));
+    connector::ConnectorRegistry::global().insert(
+        tpchConnector->connectorId(), tpchConnector);
   }
 
   ~VeloxIn10MinDemo() {
-    connector::unregisterConnector(kTpchConnectorId);
-    connector::unregisterConnectorFactory(
-        connector::tpch::TpchConnectorFactory::kTpchConnectorName);
+    connector::ConnectorRegistry::global().erase(kTpchConnectorId);
   }
 
   /// Parse SQL expression into a typed expression tree using DuckDB SQL parser.
   core::TypedExprPtr parseExpression(
       const std::string& text,
       const RowTypePtr& rowType) {
-    parse::ParseOptions options;
-    auto untyped = parse::parseExpr(text, options);
+    auto untyped = parse::DuckSqlExpressionsParser().parseExpr(text);
     return core::Expressions::inferTypes(untyped, rowType, execCtx_->pool());
   }
 
@@ -99,8 +92,9 @@ class VeloxIn10MinDemo : public VectorTestBase {
 
   /// Make TPC-H split to add to TableScan node.
   exec::Split makeTpchSplit() const {
-    return exec::Split(std::make_shared<connector::tpch::TpchConnectorSplit>(
-        kTpchConnectorId, /*cacheable=*/true, 1, 0));
+    return exec::Split(
+        std::make_shared<connector::tpch::TpchConnectorSplit>(
+            kTpchConnectorId, /*cacheable=*/true, 1, 0));
   }
 
   /// Run the demo.
@@ -108,7 +102,7 @@ class VeloxIn10MinDemo : public VectorTestBase {
 
   std::shared_ptr<folly::Executor> executor_{
       std::make_shared<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency())};
+          folly::available_concurrency())};
   std::shared_ptr<core::QueryCtx> queryCtx_{
       core::QueryCtx::create(executor_.get())};
   std::unique_ptr<core::ExecCtx> execCtx_{
diff --git a/velox/exec/tests/WindowFunctionRegistryTest.cpp b/velox/exec/tests/WindowFunctionRegistryTest.cpp
index f78b18a0502..5fab67f5de0 100644
--- a/velox/exec/tests/WindowFunctionRegistryTest.cpp
+++ b/velox/exec/tests/WindowFunctionRegistryTest.cpp
@@ -15,13 +15,19 @@
  */
 #include <gtest/gtest.h>
 
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/WindowFunction.h"
+#include "velox/exec/tests/AggregateRegistryTestUtil.h"
 #include "velox/expression/SignatureBinder.h"
 #include "velox/functions/prestosql/window/WindowFunctionsRegistration.h"
 
 namespace facebook::velox::exec::test {
 
 namespace {
+std::vector<TypePtr> nullTypes(size_t n) {
+  return std::vector<TypePtr>(n, nullptr);
+}
+
 void registerWindowFunction(const std::string& name) {
   std::vector<exec::FunctionSignaturePtr> signatures{
       exec::FunctionSignatureBuilder()
@@ -50,6 +56,7 @@ class WindowFunctionRegistryTest : public testing::Test {
   WindowFunctionRegistryTest() {
     registerWindowFunction("window_func");
     registerWindowFunction("window_Func_Alias");
+    registerAggregateFunc("agg_func");
   }
 
   TypePtr resolveWindowFunction(
@@ -57,7 +64,7 @@ class WindowFunctionRegistryTest : public testing::Test {
       const std::vector<TypePtr>& argTypes) {
     if (auto windowFunctionSignatures = getWindowFunctionSignatures(name)) {
       for (const auto& signature : windowFunctionSignatures.value()) {
-        SignatureBinder binder(*signature, argTypes);
+        SignatureBinder binder(*signature, argTypes, TypeCoercer::defaults());
         if (binder.tryBind()) {
           return binder.tryResolveReturnType();
         }
@@ -78,6 +85,35 @@ class WindowFunctionRegistryTest : public testing::Test {
       EXPECT_EQ(actualType, nullptr);
     }
   }
+
+  void testNoCoercions(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes,
+      const TypePtr& expectedReturnType) {
+    VELOX_EXPECT_EQ_TYPES(
+        resolveWindowResultType(name, argTypes), expectedReturnType);
+
+    std::vector<TypePtr> coercions;
+    auto type = resolveWindowResultTypeWithCoercions(
+        name, argTypes, coercions, TypeCoercer::defaults());
+    VELOX_EXPECT_EQ_TYPES(type, expectedReturnType);
+    EXPECT_EQ(coercions, nullTypes(argTypes.size()));
+  }
+
+  void testCoercions(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes,
+      const TypePtr& expectedReturnType,
+      const std::vector<TypePtr>& expectedCoercions) {
+    std::vector<TypePtr> coercions;
+    auto type = resolveWindowResultTypeWithCoercions(
+        name, argTypes, coercions, TypeCoercer::defaults());
+    VELOX_EXPECT_EQ_TYPES(type, expectedReturnType);
+    EXPECT_EQ(coercions.size(), expectedCoercions.size());
+    for (auto i = 0; i < coercions.size(); ++i) {
+      VELOX_EXPECT_EQ_TYPES(coercions[i], expectedCoercions[i]);
+    }
+  }
 };
 
 TEST_F(WindowFunctionRegistryTest, basic) {
@@ -134,4 +170,81 @@ TEST_F(WindowFunctionRegistryTest, prefix) {
   }
 }
 
+TEST_F(WindowFunctionRegistryTest, resolveResultType) {
+  testNoCoercions("window_func", {BIGINT(), DOUBLE()}, BIGINT());
+  testNoCoercions("window_func", {DOUBLE(), DOUBLE()}, DOUBLE());
+  testNoCoercions("window_func", {}, DATE());
+
+  // Aggregate function registered as a window function.
+  testNoCoercions("agg_func", {BIGINT(), DOUBLE()}, BIGINT());
+  testNoCoercions("agg_func", {}, DATE());
+}
+
+TEST_F(WindowFunctionRegistryTest, resolveResultTypeErrors) {
+  // Wrong function name.
+  VELOX_ASSERT_THROW(
+      resolveWindowResultType("nonexistent_func", {BIGINT(), DOUBLE()}),
+      "Window function not registered");
+
+  // Wrong signature for a window function.
+  VELOX_ASSERT_THROW(
+      resolveWindowResultType("window_func", {BIGINT()}),
+      "Window function signature is not supported");
+
+  // resolveWindowResultTypeWithCoercions: wrong function name.
+  {
+    std::vector<TypePtr> coercions;
+    VELOX_ASSERT_THROW(
+        resolveWindowResultTypeWithCoercions(
+            "nonexistent_func",
+            {BIGINT(), DOUBLE()},
+            coercions,
+            TypeCoercer::defaults()),
+        "Window function not registered");
+  }
+
+  // resolveWindowResultTypeWithCoercions: wrong signature.
+  {
+    std::vector<TypePtr> coercions;
+    VELOX_ASSERT_THROW(
+        resolveWindowResultTypeWithCoercions(
+            "window_func", {VARCHAR()}, coercions, TypeCoercer::defaults()),
+        "Window function signature is not supported");
+  }
+
+  // resolveWindowResultTypeWithCoercions: correct name and arg count, but
+  // incompatible types (VARCHAR cannot be coerced to match any signature).
+  {
+    std::vector<TypePtr> coercions;
+    VELOX_ASSERT_THROW(
+        resolveWindowResultTypeWithCoercions(
+            "window_func",
+            {VARCHAR(), BIGINT()},
+            coercions,
+            TypeCoercer::defaults()),
+        "Window function signature is not supported");
+  }
+}
+
+TEST_F(WindowFunctionRegistryTest, resolveResultTypeWithCoercions) {
+  // Exact match: no coercions needed.
+  testNoCoercions("window_func", {BIGINT(), DOUBLE()}, BIGINT());
+
+  // Window function signature with coercion: (double, bigint) doesn't
+  // exactly match (bigint, double) or (T, T), but (T, T) matches with
+  // coercion.
+  testCoercions(
+      "window_func", {DOUBLE(), BIGINT()}, DOUBLE(), {nullptr, DOUBLE()});
+
+  // Coercion with smaller integer types.
+  testCoercions(
+      "window_func", {TINYINT(), BIGINT()}, BIGINT(), {BIGINT(), nullptr});
+
+  // Aggregate function registered as a window function.
+  testNoCoercions("agg_func", {BIGINT(), DOUBLE()}, BIGINT());
+
+  testCoercions(
+      "agg_func", {DOUBLE(), BIGINT()}, DOUBLE(), {nullptr, DOUBLE()});
+}
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/WindowTest.cpp b/velox/exec/tests/WindowTest.cpp
index f1399a7af17..64e4ae543ef 100644
--- a/velox/exec/tests/WindowTest.cpp
+++ b/velox/exec/tests/WindowTest.cpp
@@ -14,9 +14,11 @@
  * limitations under the License.
  */
 #include "velox/exec/Window.h"
+#include <folly/system/HardwareConcurrency.h>
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/exec/OrderBy.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/RowsStreamingWindowBuild.h"
@@ -24,13 +26,12 @@
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/functions/prestosql/window/WindowFunctionsRegistration.h"
 
 using namespace facebook::velox::exec::test;
 
 namespace facebook::velox::exec {
-
+using namespace facebook::velox::common::testutil;
 namespace {
 
 class WindowTest : public OperatorTestBase {
@@ -63,12 +64,13 @@ class WindowTest : public OperatorTestBase {
         0,
         0,
         "none",
+        0,
         prefixSortConfig);
   }
 
   const std::shared_ptr<folly::Executor> executor_{
       std::make_shared<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency())};
+          folly::available_concurrency())};
 
   tsan_atomic<bool> nonReclaimableSection_{false};
 };
@@ -115,6 +117,112 @@ TEST_F(WindowTest, spill) {
   ASSERT_GT(stats.spilledPartitions, 0);
 }
 
+TEST_F(WindowTest, spillBatchReadTinyPartitions) {
+  const vector_size_t size = 1'000;
+  const uint32_t minReadBatchRows = 100;
+  // Each tiny partition has 1 row.
+  const uint32_t partitionRows = 1;
+  auto data = makeRowVector(
+      {"d", "p", "s"},
+      {
+          // Payload.
+          makeFlatVector<int64_t>(size, [](auto row) { return row; }),
+          // Partition key.
+          makeFlatVector<int16_t>(
+              size, [](auto row) { return row / partitionRows; }),
+          // Sorting key.
+          makeFlatVector<int32_t>(size, [](auto row) { return row; }),
+      });
+
+  createDuckDbTable({data});
+
+  core::PlanNodeId windowId;
+  auto plan = PlanBuilder()
+                  .values(split(data, 10))
+                  .window({"row_number() over (partition by p order by s)"})
+                  .capturePlanNodeId(windowId)
+                  .planNode();
+
+  auto spillDirectory = TempDirectoryPath::create();
+  TestScopedSpillInjection scopedSpillInjection(100);
+  auto task =
+      AssertQueryBuilder(plan, duckDbQueryRunner_)
+          .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
+          .config(core::QueryConfig::kSpillEnabled, "true")
+          .config(core::QueryConfig::kWindowSpillEnabled, "true")
+          .config(
+              core::QueryConfig::kWindowSpillMinReadBatchRows, minReadBatchRows)
+          .spillDirectory(spillDirectory->getPath())
+          .assertResults(
+              "SELECT *, row_number() over (partition by p order by s) FROM tmp");
+
+  auto taskStats = exec::toPlanStats(task->taskStats());
+  const auto& stats = taskStats.at(windowId);
+
+  ASSERT_GT(stats.spilledBytes, 0);
+  ASSERT_GT(stats.spilledRows, 0);
+  ASSERT_GT(stats.spilledFiles, 0);
+  ASSERT_GT(stats.spilledPartitions, 0);
+  ASSERT_EQ(
+      stats.operatorStats.at("Window")
+          ->customStats[std::string(Window::kWindowSpillReadNumBatches)]
+          .sum,
+      size / minReadBatchRows);
+}
+
+TEST_F(WindowTest, spillBatchReadHugePartitions) {
+  const vector_size_t size = 1'000;
+  const uint32_t minReadBatchRows = 100;
+  // Each huge partition has 200 rows, which is larger than minReadBatchRows.
+  const uint32_t partitionRows = 200;
+  auto data = makeRowVector(
+      {"d", "p", "s"},
+      {
+          // Payload.
+          makeFlatVector<int64_t>(size, [](auto row) { return row; }),
+          // Partition key.
+          makeFlatVector<int16_t>(
+              size, [](auto row) { return row / partitionRows; }),
+          // Sorting key.
+          makeFlatVector<int32_t>(size, [](auto row) { return row; }),
+      });
+
+  createDuckDbTable({data});
+
+  core::PlanNodeId windowId;
+  auto plan = PlanBuilder()
+                  .values(split(data, 10))
+                  .window({"row_number() over (partition by p order by s)"})
+                  .capturePlanNodeId(windowId)
+                  .planNode();
+
+  auto spillDirectory = TempDirectoryPath::create();
+  TestScopedSpillInjection scopedSpillInjection(100);
+  auto task =
+      AssertQueryBuilder(plan, duckDbQueryRunner_)
+          .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
+          .config(core::QueryConfig::kSpillEnabled, "true")
+          .config(core::QueryConfig::kWindowSpillEnabled, "true")
+          .config(
+              core::QueryConfig::kWindowSpillMinReadBatchRows, minReadBatchRows)
+          .spillDirectory(spillDirectory->getPath())
+          .assertResults(
+              "SELECT *, row_number() over (partition by p order by s) FROM tmp");
+
+  auto taskStats = exec::toPlanStats(task->taskStats());
+  const auto& stats = taskStats.at(windowId);
+
+  ASSERT_GT(stats.spilledBytes, 0);
+  ASSERT_GT(stats.spilledRows, 0);
+  ASSERT_GT(stats.spilledFiles, 0);
+  ASSERT_GT(stats.spilledPartitions, 0);
+  ASSERT_EQ(
+      stats.operatorStats.at("Window")
+          ->customStats[std::string(Window::kWindowSpillReadNumBatches)]
+          .sum,
+      size / partitionRows);
+}
+
 TEST_F(WindowTest, spillUnsupported) {
   const vector_size_t size = 1'000;
   auto data = makeRowVector(
@@ -156,7 +264,10 @@ TEST_F(WindowTest, spillUnsupported) {
   ASSERT_EQ(stats.spilledPartitions, 0);
   auto opStats = toOperatorStats(task->taskStats());
   ASSERT_GT(
-      opStats.at("Window").runtimeStats[Operator::kSpillNotSupported].sum, 1);
+      opStats.at("Window")
+          .runtimeStats[std::string(Operator::kSpillNotSupported)]
+          .sum,
+      1);
 }
 
 TEST_F(WindowTest, rowBasedStreamingWindowOOM) {
@@ -180,10 +291,11 @@ TEST_F(WindowTest, rowBasedStreamingWindowOOM) {
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   CursorParameters params;
   auto queryCtx = core::QueryCtx::create(executor_.get());
-  queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-      queryCtx->queryId(),
-      8'388'608 /* 8MB */,
-      exec::MemoryReclaimer::create()));
+  queryCtx->testingOverrideMemoryPool(
+      memory::memoryManager()->addRootPool(
+          queryCtx->queryId(),
+          8'388'608 /* 8MB */,
+          exec::MemoryReclaimer::create()));
 
   params.queryCtx = queryCtx;
 
@@ -325,6 +437,122 @@ DEBUG_ONLY_TEST_F(WindowTest, valuesRowsStreamingWindowBuild) {
   ASSERT_TRUE(isStreamCreated.load());
 }
 
+TEST_F(WindowTest, prePartitionedSortBuild) {
+  const vector_size_t size = 1'000;
+  const int numPartitions = 37;
+  const int numSubPartitions = 4;
+  auto data = makeRowVector(
+      {"p", "s"},
+      {
+          // Partition key.
+          makeFlatVector<int16_t>(
+              size, [](auto row) { return row % numPartitions; }),
+          // Sorting key.
+          makeFlatVector<int32_t>(size, [](auto row) { return row; }),
+      });
+
+  createDuckDbTable({data});
+
+  core::PlanNodeId windowId;
+  auto plan =
+      PlanBuilder()
+          .values(split(data, 10))
+          .window({"row_number() over (partition by p order by s desc)"})
+          .capturePlanNodeId(windowId)
+          .planNode();
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
+      .config(
+          core::QueryConfig::kWindowNumSubPartitions,
+          std::to_string(numSubPartitions))
+      .assertResults(
+          "SELECT *, row_number() over (partition by p order by s desc) FROM tmp ORDER BY s");
+}
+
+TEST_F(WindowTest, prePartitionedSortBuildSkewed) {
+  const vector_size_t size = 1'000;
+  const int numPartitions = 4;
+  const int numSubPartitions = 16;
+  auto data = makeRowVector(
+      {"p", "s"},
+      {
+          // Partition key.
+          makeFlatVector<int16_t>(
+              size, [](auto row) { return row % numPartitions; }),
+          // Sorting key.
+          makeFlatVector<int32_t>(size, [](auto row) { return row; }),
+      });
+
+  createDuckDbTable({data});
+
+  core::PlanNodeId windowId;
+  auto plan =
+      PlanBuilder()
+          .values(split(data, 10))
+          .window({"row_number() over (partition by p order by s desc)"})
+          .capturePlanNodeId(windowId)
+          .planNode();
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
+      .config(
+          core::QueryConfig::kWindowNumSubPartitions,
+          std::to_string(numSubPartitions))
+      .assertResults(
+          "SELECT *, row_number() over (partition by p order by s desc) FROM tmp ORDER BY s");
+}
+
+TEST_F(WindowTest, prePartitionedBuildWithSpill) {
+  const vector_size_t size = 1'000;
+  const int numPartitions = 37;
+  const int numSubPartitions = 4;
+  auto data = makeRowVector(
+      {"d", "p", "s"},
+      {
+          // Payload.
+          makeFlatVector<int64_t>(size, [](auto row) { return row; }),
+          // Partition key.
+          makeFlatVector<int16_t>(
+              size, [](auto row) { return row % numPartitions; }),
+          // Sorting key.
+          makeFlatVector<int32_t>(size, [](auto row) { return row; }),
+      });
+
+  createDuckDbTable({data});
+
+  core::PlanNodeId windowId;
+  auto plan =
+      PlanBuilder()
+          .values(split(data, 10))
+          .window({"row_number() over (partition by p order by s desc)"})
+          .capturePlanNodeId(windowId)
+          .planNode();
+
+  auto spillDirectory = TempDirectoryPath::create();
+  TestScopedSpillInjection scopedSpillInjection(100);
+  auto task =
+      AssertQueryBuilder(plan, duckDbQueryRunner_)
+          .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
+          .config(
+              core::QueryConfig::kWindowNumSubPartitions,
+              std::to_string(numSubPartitions))
+          .config(core::QueryConfig::kSpillEnabled, "true")
+          .config(core::QueryConfig::kWindowSpillEnabled, "true")
+          .config(core::QueryConfig::kOrderBySpillEnabled, "false")
+          .spillDirectory(spillDirectory->getPath())
+          .assertResults(
+              "SELECT *, row_number() over (partition by p order by s desc) FROM tmp ORDER BY s");
+
+  auto taskStats = exec::toPlanStats(task->taskStats());
+  const auto& stats = taskStats.at(windowId);
+
+  ASSERT_GT(stats.spilledBytes, 0);
+  ASSERT_GT(stats.spilledRows, 0);
+  ASSERT_GT(stats.spilledFiles, 0);
+  ASSERT_GT(stats.spilledPartitions, 0);
+}
+
 DEBUG_ONLY_TEST_F(WindowTest, aggregationWithNonDefaultFrame) {
   const vector_size_t size = 1'00;
 
@@ -552,10 +780,11 @@ TEST_F(WindowTest, nagativeFrameArg) {
             .planNode();
     VELOX_ASSERT_USER_THROW(
         AssertQueryBuilder(plan, duckDbQueryRunner_)
-            .assertResults(fmt::format(
-                "SELECT *, regr_count(c0, c1) over (partition by p0, p1 order by row_number  ROWS between {} PRECEDING and {} FOLLOWING) from tmp",
-                startOffset,
-                endOffset)),
+            .assertResults(
+                fmt::format(
+                    "SELECT *, regr_count(c0, c1) over (partition by p0, p1 order by row_number  ROWS between {} PRECEDING and {} FOLLOWING) from tmp",
+                    startOffset,
+                    endOffset)),
         testData.debugString());
   }
 }
@@ -645,25 +874,28 @@ DEBUG_ONLY_TEST_F(WindowTest, reserveMemorySort) {
 
   for (const auto [usePrefixSort, spillEnabled, enableSpillPrefixSort] :
        testSettings) {
-    SCOPED_TRACE(fmt::format(
-        "usePrefixSort: {}, spillEnabled: {}, enableSpillPrefixSort: {}",
-        usePrefixSort,
-        spillEnabled,
-        enableSpillPrefixSort));
-    auto spillDirectory = exec::test::TempDirectoryPath::create();
+    SCOPED_TRACE(
+        fmt::format(
+            "usePrefixSort: {}, spillEnabled: {}, enableSpillPrefixSort: {}",
+            usePrefixSort,
+            spillEnabled,
+            enableSpillPrefixSort));
+    auto spillDirectory = TempDirectoryPath::create();
     auto spillConfig =
         getSpillConfig(spillDirectory->getPath(), enableSpillPrefixSort);
-    folly::Synchronized<common::SpillStats> spillStats;
+    exec::SpillStats spillStats;
     const auto plan = usePrefixSort ? prefixSortPlan : nonPrefixSortPlan;
     velox::common::PrefixSortConfig prefixSortConfig =
         velox::common::PrefixSortConfig{
             std::numeric_limits<int32_t>::max(), 130, 12};
+    folly::Synchronized<OperatorStats> opStats;
     auto sortWindowBuild = std::make_unique<SortWindowBuild>(
         plan,
         pool_.get(),
         std::move(prefixSortConfig),
         spillEnabled ? &spillConfig : nullptr,
         &nonReclaimableSection_,
+        &opStats,
         &spillStats);
 
     TestScopedSpillInjection scopedSpillInjection(0);
@@ -713,18 +945,20 @@ TEST_F(WindowTest, NaNFrameBound) {
           if (startBound == "following" && endBound == "preceding") {
             continue;
           }
-          frames.push_back(fmt::format(
-              "{} over (order by s0 {} range between off0 {} and off1 {})",
-              call,
-              order,
-              startBound,
-              endBound));
-          frames.push_back(fmt::format(
-              "{} over (order by s0 {} range between off1 {} and off0 {})",
-              call,
-              order,
-              startBound,
-              endBound));
+          frames.push_back(
+              fmt::format(
+                  "{} over (order by s0 {} range between off0 {} and off1 {})",
+                  call,
+                  order,
+                  startBound,
+                  endBound));
+          frames.push_back(
+              fmt::format(
+                  "{} over (order by s0 {} range between off1 {} and off0 {})",
+                  call,
+                  order,
+                  startBound,
+                  endBound));
         }
       }
     }
diff --git a/velox/exec/tests/WriterFuzzerUtilTest.cpp b/velox/exec/tests/WriterFuzzerUtilTest.cpp
index d0b765dd813..93ebe8a5c29 100644
--- a/velox/exec/tests/WriterFuzzerUtilTest.cpp
+++ b/velox/exec/tests/WriterFuzzerUtilTest.cpp
@@ -16,15 +16,16 @@
 
 #include <gtest/gtest.h>
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/exec/fuzzer/WriterFuzzer.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::exec::test;
+using namespace facebook::velox::common::testutil;
 
 TEST(WriterFuzzerUtilTest, listFolders) {
   facebook::velox::filesystems::registerLocalFileSystem();
-  const auto tempFolder = exec::test::TempDirectoryPath::create();
+  const auto tempFolder = TempDirectoryPath::create();
   // Directory layout:
   // First layer:   dir1/   dir2/      dir3/    a
   // Second layer:  b       dir2_1/
diff --git a/velox/exec/tests/data/decimal.orc b/velox/exec/tests/data/decimal.orc
new file mode 100644
index 00000000000..b89662b65f6
Binary files /dev/null and b/velox/exec/tests/data/decimal.orc differ
diff --git a/velox/exec/tests/utils/AggregationResolver.cpp b/velox/exec/tests/utils/AggregationResolver.cpp
index 44cc0058b14..89ab458d199 100644
--- a/velox/exec/tests/utils/AggregationResolver.cpp
+++ b/velox/exec/tests/utils/AggregationResolver.cpp
@@ -22,15 +22,13 @@
 namespace facebook::velox::exec::test {
 namespace {
 std::string throwAggregateFunctionDoesntExist(const std::string& name) {
-  std::stringstream error;
-  error << "Aggregate function doesn't exist: " << name << ".";
   exec::aggregateFunctions().withRLock([&](const auto& functionsMap) {
     if (functionsMap.empty()) {
-      error << " Registry of aggregate functions is empty. "
-               "Make sure to register some aggregate functions.";
+      VELOX_USER_FAIL(
+          "Registry of aggregate functions is empty. Make sure to register some aggregate functions.");
     }
   });
-  VELOX_USER_FAIL(error.str());
+  VELOX_USER_FAIL("Aggregate function doesn't exist: {}.", name);
 }
 
 std::string throwAggregateFunctionSignatureNotSupported(
@@ -38,11 +36,10 @@ std::string throwAggregateFunctionSignatureNotSupported(
     const std::vector<TypePtr>& types,
     const std::vector<std::shared_ptr<AggregateFunctionSignature>>&
         signatures) {
-  std::stringstream error;
-  error << "Aggregate function signature is not supported: "
-        << toString(name, types)
-        << ". Supported signatures: " << toString(signatures) << ".";
-  VELOX_USER_FAIL(error.str());
+  VELOX_USER_FAIL(
+      "Aggregate function signature is not supported: {}. Supported signatures: {}.",
+      toString(name, types),
+      toString(signatures));
 }
 } // namespace
 
@@ -53,7 +50,8 @@ TypePtr resolveAggregateType(
     bool nullOnFailure) {
   if (auto signatures = exec::getAggregateFunctionSignatures(aggregateName)) {
     for (const auto& signature : signatures.value()) {
-      exec::SignatureBinder binder(*signature, rawInputTypes);
+      exec::SignatureBinder binder(
+          *signature, rawInputTypes, TypeCoercer::defaults());
       if (binder.tryBind()) {
         return binder.tryResolveType(
             exec::isPartialOutput(step) ? signature->intermediateType()
diff --git a/velox/exec/tests/utils/ArbitratorTestUtil.cpp b/velox/exec/tests/utils/ArbitratorTestUtil.cpp
index 8c3bb9dc8ac..f6fbc9862ec 100644
--- a/velox/exec/tests/utils/ArbitratorTestUtil.cpp
+++ b/velox/exec/tests/utils/ArbitratorTestUtil.cpp
@@ -19,10 +19,8 @@
 #include "velox/dwio/dwrf/common/Config.h"
 #include "velox/exec/TableWriter.h"
 
-using namespace facebook::velox;
-using namespace facebook::velox::exec;
-using namespace facebook::velox::exec::test;
 using namespace facebook::velox::memory;
+using namespace facebook::velox::common::testutil;
 
 namespace facebook::velox::exec::test {
 
@@ -31,18 +29,11 @@ std::shared_ptr<core::QueryCtx> newQueryCtx(
     folly::Executor* executor,
     int64_t memoryCapacity,
     const std::string& queryId) {
-  std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>> configs;
-  std::shared_ptr<MemoryPool> pool =
-      memoryManager->addRootPool("", memoryCapacity);
-  auto queryCtx = core::QueryCtx::create(
-      executor,
-      core::QueryConfig({}),
-      configs,
-      cache::AsyncDataCache::getInstance(),
-      std::move(pool),
-      nullptr,
-      queryId);
-  return queryCtx;
+  return core::QueryCtx::Builder()
+      .executor(executor)
+      .pool(memoryManager->addRootPool("", memoryCapacity))
+      .queryId(queryId)
+      .build();
 }
 
 std::unique_ptr<memory::MemoryManager> createMemoryManager(
@@ -104,7 +95,7 @@ QueryTestResult runHashJoinTask(
   QueryTestResult result;
   const auto plan = hashJoinPlan(vectors, result.planNodeId);
   if (enableSpilling) {
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto spillDirectory = TempDirectoryPath::create();
     result.data = AssertQueryBuilder(plan)
                       .serialExecution(serialExecution)
                       .spillDirectory(spillDirectory->getPath())
@@ -149,7 +140,7 @@ QueryTestResult runAggregateTask(
   QueryTestResult result;
   const auto plan = aggregationPlan(vectors, result.planNodeId);
   if (enableSpilling) {
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto spillDirectory = TempDirectoryPath::create();
     result.data =
         AssertQueryBuilder(plan)
             .serialExecution(serialExecution)
@@ -195,7 +186,7 @@ QueryTestResult runOrderByTask(
   QueryTestResult result;
   const auto plan = orderByPlan(vectors, result.planNodeId);
   if (enableSpilling) {
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto spillDirectory = TempDirectoryPath::create();
     result.data = AssertQueryBuilder(plan)
                       .serialExecution(serialExecution)
                       .spillDirectory(spillDirectory->getPath())
@@ -240,7 +231,7 @@ QueryTestResult runRowNumberTask(
   QueryTestResult result;
   const auto plan = rowNumberPlan(vectors, result.planNodeId);
   if (enableSpilling) {
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto spillDirectory = TempDirectoryPath::create();
     result.data = AssertQueryBuilder(plan)
                       .serialExecution(serialExecution)
                       .spillDirectory(spillDirectory->getPath())
@@ -285,7 +276,7 @@ QueryTestResult runTopNTask(
   QueryTestResult result;
   const auto plan = topNPlan(vectors, result.planNodeId);
   if (enableSpilling) {
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto spillDirectory = TempDirectoryPath::create();
     result.data =
         AssertQueryBuilder(plan)
             .serialExecution(serialExecution)
@@ -335,7 +326,7 @@ QueryTestResult runWriteTask(
   const auto outputDirectory = TempDirectoryPath::create();
   auto plan = writePlan(vectors, outputDirectory->getPath(), result.planNodeId);
   if (enableSpilling) {
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto spillDirectory = TempDirectoryPath::create();
     result.data =
         AssertQueryBuilder(plan)
             .serialExecution(serialExecution)
diff --git a/velox/exec/tests/utils/ArbitratorTestUtil.h b/velox/exec/tests/utils/ArbitratorTestUtil.h
index 8021db65608..85024deb800 100644
--- a/velox/exec/tests/utils/ArbitratorTestUtil.h
+++ b/velox/exec/tests/utils/ArbitratorTestUtil.h
@@ -19,15 +19,17 @@
 #include <memory>
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/memory/MemoryPool.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/exec/Driver.h"
 #include "velox/exec/MemoryReclaimer.h"
 #include "velox/exec/Task.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 namespace facebook::velox::exec::test {
 
+using TempDirectoryPath = common::testutil::TempDirectoryPath;
+
 constexpr int64_t KB = 1024L;
 constexpr int64_t MB = 1024L * KB;
 
@@ -112,7 +114,7 @@ std::shared_ptr<core::QueryCtx> newQueryCtx(
 std::unique_ptr<memory::MemoryManager> createMemoryManager(
     int64_t arbitratorCapacity = kMemoryCapacity,
     uint64_t memoryPoolInitCapacity = kMemoryPoolInitCapacity,
-    uint64_t maxReclaimWaitMs = 5 * 60 * 1'000,
+    uint64_t maxReclaimWaitMs = 60 * 1'000,
     uint64_t fastExponentialGrowthCapacityLimit = 0,
     double slowCapacityGrowPct = 0);
 
diff --git a/velox/exec/tests/utils/AssertQueryBuilder.cpp b/velox/exec/tests/utils/AssertQueryBuilder.cpp
index 1b68b77cf71..ff443ae1b40 100644
--- a/velox/exec/tests/utils/AssertQueryBuilder.cpp
+++ b/velox/exec/tests/utils/AssertQueryBuilder.cpp
@@ -266,7 +266,26 @@ RowVectorPtr AssertQueryBuilder::copyResults(
   return copy;
 }
 
-uint64_t AssertQueryBuilder::runWithoutResults(std::shared_ptr<Task>& task) {
+std::vector<RowVectorPtr> AssertQueryBuilder::copyResultBatches(
+    memory::MemoryPool* pool) {
+  auto [cursor, results] = readCursor();
+
+  if (results.empty()) {
+    return results;
+  }
+
+  std::vector<RowVectorPtr> copies;
+  copies.reserve(results.size());
+  for (const auto& result : results) {
+    copies.push_back(
+        BaseVector::create<RowVector>(result->type(), result->size(), pool));
+    copies.back()->copy(result.get(), 0, 0, result->size());
+  }
+
+  return copies;
+}
+
+uint64_t AssertQueryBuilder::countResults(std::shared_ptr<Task>& task) {
   auto [cursor, results] = readCursor();
   uint64_t count = 0;
   for (const auto& result : results) {
@@ -276,6 +295,11 @@ uint64_t AssertQueryBuilder::runWithoutResults(std::shared_ptr<Task>& task) {
   return count;
 }
 
+uint64_t AssertQueryBuilder::countResults() {
+  std::shared_ptr<Task> task;
+  return countResults(task);
+}
+
 std::pair<std::unique_ptr<TaskCursor>, std::vector<RowVectorPtr>>
 AssertQueryBuilder::readCursor() {
   VELOX_CHECK_NOT_NULL(params_.planNode);
@@ -287,17 +311,14 @@ AssertQueryBuilder::readCursor() {
       static std::atomic<uint64_t> cursorQueryId{0};
       const std::string queryId =
           fmt::format("TaskCursorQuery_{}", cursorQueryId++);
-      auto queryPool = memory::memoryManager()->addRootPool(
-          queryId, params_.maxQueryCapacity);
-      params_.queryCtx = core::QueryCtx::create(
-          executor_.get(),
-          core::QueryConfig({}),
-          std::
-              unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
-          cache::AsyncDataCache::getInstance(),
-          std::move(queryPool),
-          nullptr,
-          queryId);
+
+      params_.queryCtx = core::QueryCtx::Builder()
+                             .executor(executor_.get())
+                             .pool(
+                                 memory::memoryManager()->addRootPool(
+                                     queryId, params_.maxQueryCapacity))
+                             .queryId(queryId)
+                             .build();
     }
   }
   if (!configs_.empty()) {
@@ -310,52 +331,55 @@ AssertQueryBuilder::readCursor() {
     }
   }
 
-  return test::readCursor(params_, [&](exec::TaskCursor* taskCursor) {
-    if (taskCursor->noMoreSplits()) {
-      return;
-    }
-    auto& task = taskCursor->task();
-    VELOX_CHECK(!params_.barrierExecution || params_.serialExecution);
-    if (params_.barrierExecution) {
-      int numSplits{0};
-      for (auto& [nodeId, nodeSplits] : splits_) {
-        if (nodeSplits.empty()) {
-          task->noMoreSplits(nodeId);
-          continue;
+  return test::readCursorAsync(
+      params_,
+      [&](exec::TaskCursor* taskCursor) {
+        if (taskCursor->noMoreSplits()) {
+          return ContinueFuture::makeEmpty();
         }
-        ++numSplits;
-        if (addSplitWithSequence_) {
-          task->addSplitWithSequence(
-              nodeId, std::move(nodeSplits[0]), ++sequenceId_);
-          task->setMaxSplitSequenceId(nodeId, sequenceId_);
+        auto& task = taskCursor->task();
+        if (params_.barrierExecution) {
+          int numSplits{0};
+          for (auto& [nodeId, nodeSplits] : splits_) {
+            if (nodeSplits.empty()) {
+              task->noMoreSplits(nodeId);
+              continue;
+            }
+            ++numSplits;
+            if (addSplitWithSequence_) {
+              task->addSplitWithSequence(
+                  nodeId, std::move(nodeSplits[0]), ++sequenceId_);
+              task->setMaxSplitSequenceId(nodeId, sequenceId_);
+            } else {
+              task->addSplit(nodeId, std::move(nodeSplits[0]));
+            }
+            nodeSplits.erase(nodeSplits.cbegin());
+          }
+          if (numSplits > 0) {
+            VELOX_CHECK_EQ(
+                numSplits,
+                splits_.size(),
+                "Barrier task execution mode requires all the sources have the same number of splits");
+            return task->requestBarrier();
+          }
+          taskCursor->setNoMoreSplits();
         } else {
-          task->addSplit(nodeId, std::move(nodeSplits[0]));
-        }
-        nodeSplits.erase(nodeSplits.begin());
-      }
-      if (numSplits > 0) {
-        VELOX_CHECK_EQ(
-            numSplits,
-            splits_.size(),
-            "Barrier task execution mode requires all the sources have the same number of splits");
-        task->requestBarrier();
-      } else {
-        taskCursor->setNoMoreSplits();
-      }
-    } else {
-      for (auto& [nodeId, nodeSplits] : splits_) {
-        for (auto& split : nodeSplits) {
-          if (addSplitWithSequence_) {
-            task->addSplitWithSequence(nodeId, std::move(split), ++sequenceId_);
-            task->setMaxSplitSequenceId(nodeId, sequenceId_);
-          } else {
-            task->addSplit(nodeId, std::move(split));
+          for (auto& [nodeId, nodeSplits] : splits_) {
+            for (auto& split : nodeSplits) {
+              if (addSplitWithSequence_) {
+                task->addSplitWithSequence(
+                    nodeId, std::move(split), ++sequenceId_);
+                task->setMaxSplitSequenceId(nodeId, sequenceId_);
+              } else {
+                task->addSplit(nodeId, std::move(split));
+              }
+            }
+            task->noMoreSplits(nodeId);
           }
+          taskCursor->setNoMoreSplits();
         }
-        task->noMoreSplits(nodeId);
-      }
-      taskCursor->setNoMoreSplits();
-    }
-  });
+        return ContinueFuture::makeEmpty();
+      },
+      maxWaitMicros_);
 }
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/AssertQueryBuilder.h b/velox/exec/tests/utils/AssertQueryBuilder.h
index 8e9f15d9831..b96b0fda74f 100644
--- a/velox/exec/tests/utils/AssertQueryBuilder.h
+++ b/velox/exec/tests/utils/AssertQueryBuilder.h
@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include <folly/system/HardwareConcurrency.h>
 #include "velox/exec/tests/utils/QueryAssertions.h"
 
 namespace facebook::velox::exec::test {
@@ -127,6 +128,13 @@ class AssertQueryBuilder {
     return *this;
   }
 
+  /// Set the maximum time to wait for task completion after all results have
+  /// been consumed. Default is 5 seconds.
+  AssertQueryBuilder& maxWaitMicros(uint64_t maxWaitMicros) {
+    maxWaitMicros_ = maxWaitMicros;
+    return *this;
+  }
+
   /// Spilling directory, if not empty, then the task's spilling directory would
   /// be built from it.
   AssertQueryBuilder& spillDirectory(const std::string& dir) {
@@ -182,8 +190,7 @@ class AssertQueryBuilder {
       const TypePtr& expectedType,
       vector_size_t expectedNumRows);
 
-  /// Run the query and collect all results into a single vector. Throws if
-  /// query returns empty result.
+  /// Run the query and collect all results into a single vector.
   RowVectorPtr copyResults(memory::MemoryPool* pool);
 
   /// Similar to above method and also returns the task.
@@ -191,8 +198,15 @@ class AssertQueryBuilder {
       memory::MemoryPool* pool,
       std::shared_ptr<Task>& task);
 
+  /// Run the query and copy the result Vectors as their original batches.
+  std::vector<RowVectorPtr> copyResultBatches(memory::MemoryPool* pool);
+
   /// Run the query and return the number of result rows.
-  uint64_t runWithoutResults(std::shared_ptr<Task>& task);
+  uint64_t countResults(std::shared_ptr<Task>& task);
+
+  /// Run the query and return the number of result rows without requiring a
+  /// task parameter.
+  uint64_t countResults();
 
  private:
   std::pair<std::unique_ptr<TaskCursor>, std::vector<RowVectorPtr>>
@@ -200,7 +214,7 @@ class AssertQueryBuilder {
 
   static std::unique_ptr<folly::Executor> newExecutor() {
     return std::make_unique<folly::CPUThreadPoolExecutor>(
-        std::thread::hardware_concurrency());
+        folly::available_concurrency());
   }
 
   // Used by the created task as the default driver executor.
@@ -214,6 +228,9 @@ class AssertQueryBuilder {
   bool addSplitWithSequence_{false};
   // The sequence Id to be used when addSplitWithSequence_ is true.
   int32_t sequenceId_{0};
+  // Maximum time in microseconds to wait for task completion after all results
+  // have been consumed.
+  uint64_t maxWaitMicros_{5'000'000};
 };
 
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/CMakeLists.txt b/velox/exec/tests/utils/CMakeLists.txt
index cf3ef9dbb10..9174c761628 100644
--- a/velox/exec/tests/utils/CMakeLists.txt
+++ b/velox/exec/tests/utils/CMakeLists.txt
@@ -12,10 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_temp_path TempFilePath.cpp TempDirectoryPath.cpp)
-
-target_link_libraries(velox_temp_path velox_exception)
-
 add_library(
   velox_exec_test_lib
   AggregationResolver.cpp
@@ -33,16 +29,44 @@ add_library(
   TableScanTestBase.cpp
   TestIndexStorageConnector.cpp
   TpchQueryBuilder.cpp
+  TpcdsQueryBuilder.cpp
+  VeloxPlanLoader.cpp
   VectorTestUtil.cpp
   PortUtil.cpp
   SerializedPageUtil.cpp
 )
+velox_add_test_headers(
+  velox_exec_test_lib
+  AggregationResolver.h
+  ArbitratorTestUtil.h
+  AssertQueryBuilder.h
+  ExpressionBuilder.h
+  FilterToExpression.h
+  HashJoinTestBase.h
+  HiveConnectorTestBase.h
+  IndexLookupJoinTestBase.h
+  LocalExchangeSource.h
+  MergeTestBase.h
+  OperatorTestBase.h
+  PlanBuilder.h
+  PortUtil.h
+  QueryAssertions.h
+  RowContainerTestBase.h
+  SerializedPageUtil.h
+  SumNonPODAggregate.h
+  TableScanTestBase.h
+  TableWriterTestBase.h
+  TestIndexStorageConnector.h
+  TpchQueryBuilder.h
+  TpcdsQueryBuilder.h
+  VectorTestUtil.h
+  VeloxPlanLoader.h
+)
 
 target_link_libraries(
   velox_exec_test_lib
   velox_vector_test_lib
   velox_vector_fuzzer
-  velox_temp_path
   velox_cursor
   velox_core
   velox_exception
@@ -63,3 +87,5 @@ target_link_libraries(
   velox_functions_prestosql
   velox_aggregates
 )
+
+velox_add_library(velox_temp_path INTERFACE HEADERS TempDirectoryPath.h TempFilePath.h)
diff --git a/velox/exec/tests/utils/ExpressionBuilder.h b/velox/exec/tests/utils/ExpressionBuilder.h
new file mode 100644
index 00000000000..d2d208b2964
--- /dev/null
+++ b/velox/exec/tests/utils/ExpressionBuilder.h
@@ -0,0 +1,478 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/parse/Expressions.h"
+
+namespace facebook::velox::expr_builder {
+
+/// Fluent Expression Builder.
+///
+/// This file contains fluent methods that make it convenient to create
+/// (untyped) expression trees. This provides similar functionality to a SQL
+/// parser, without bringing dependency on external libraries or bringing leaked
+/// semantics from other systems.
+///
+/// The untyped expressions can then be turned into typed expressions ready for
+/// execution using type binding from `core::Expressions::inferTypes()`.
+///
+/// The API provided is as close to the actual expression trees as possible.
+/// Comparisons, arithmetics, conjuncts, function calls, literals, aliases, and
+/// more are supported with this API.
+///
+/// For example, to create a column reference, you can:
+///
+/// > using namespace expr_builder;
+/// > core::ExprPtr e = col("c0");
+///
+/// You can also use the "_c" C++ literal provided:
+///
+/// > core::ExprPtr e = "c0"_c;
+///
+/// Expressions created using ExpressionBuilder functions can be used in any
+/// places that accept a ExprPtr. In practice, they create a ExprWrapper object,
+/// but ExprWrappers are implicitly convertible to ExprSet.
+///
+/// Nested column references can be specified as either:
+///
+/// > col("parent", "child");
+/// > col("parent").subfield("child");
+///
+/// To debug the expression generated, you can simply:
+///
+/// > LOG(INFO) << *e;
+///
+/// Comparisons and other expressions can be fluently created using C++
+/// overloaded operators:
+///
+/// > col("c") > 10; // "c > 10"
+/// > col("c") != "bar"; // "c != 'bar'"
+/// > col("c") == nullptr; // "c = null"
+///
+/// C++ literals are automatically converted into ConstantExpr (expression
+/// literals) when part of an expression. To explicitly create a literal you can
+/// use:
+///
+/// > lit(10.3);
+/// > lit("str");
+///
+/// Casts can be done using one of the two formats:
+///
+/// > lit(3).cast(TINYINT());
+/// > cast("str", VARBINARY());
+///
+/// Null checking filters:
+///
+/// > isNull(col("c")) // "c is null"
+/// > !isNull(col("c")) // "c is not null"
+///
+/// Conjuncts and "between":
+///
+/// > (col("a") && col("b")) || col("c"); // "(a AND b) OR c"
+/// > between(col("a"), 0, 10); // "a between 0 and 10"
+///
+/// You can also use fluent version of these APIs:
+///
+/// > col("a").between(0, 10); // "a between 0 and 10"
+///
+/// Arithmetic operators are also overloaded:
+///
+/// > col("c") * 100 + col("b"); // "c * 100 + b"
+///
+/// In any expression, as long as one of the sides is an expression node, the
+/// correct expression will be created. For example, both version work as
+/// expected:
+///
+/// > col("c") * 100; // "c * 100"
+/// > 100 * col("c"); // "100 * c"
+///
+/// When building long expressions, be careful about C++ constant folding and
+/// operator precedence:
+///
+/// > col("c") + 5 * 100;
+///
+/// C++ will fold "5 * 100" and generate the expression "c + 500". To force the
+/// expected behavior, you can explicitly spell out the literal:
+///
+/// > col("c") + 5 * lit(100);
+/// > col("c") + lit(5) * 100;
+///
+/// Both will generate "col + 5 * 100", which is "plus(col, multiply(5, 100))".
+///
+/// Generic function calls can be created using `call()`:
+///
+/// > call("func", 10); // "func(10)"
+///
+/// `call()` supports arbitrary parameters, which can be other expressions or
+/// (C++) literals.
+///
+/// Lambdas can be created using the following syntax:
+///
+/// > lambda({"x", "y"}, col("x") * col("y") + 1)
+///
+/// Where the first parameter is a vector of the lambda arguments, and the
+/// second the lambda body.
+///
+/// All functions above can be nested and combined in arbitrary ways.
+///
+/// > 10L * col("c1") > call("func", 3.4, col("g") / col("h"), call("j"));
+///
+/// is the same as "10 * c1 > func(3.4, g / h, j())".
+///
+/// Comparisons, arithmetics, and other operators are mapped to function names
+/// according to the table below. It is the user's responsibility to make sure
+/// that there names map to their appropriate implementation:
+///
+///  -------------------------------
+///  | C++        |  Function Name |
+///  -------------------------------
+///  | operator== |  eq            |
+///  | operator!= |  neq           |
+///  | operator<  |  lt            |
+///  | operator<= |  lte           |
+///  | operator>  |  gt            |
+///  | operator>= |  gte           |
+///  | operator!  |  not           |
+///  | operator&& |  and           |
+///  | operator|| |  or            |
+///  | operator+  |  plus          |
+///  | operator-  |  minus         |
+///  | operator*  |  multiply      |
+///  | operator/  |  divide        |
+///  | operator%  |  mode          |
+///  | operator== |  eq            |
+///  -------------------------------
+
+namespace detail {
+
+class ExprWrapper;
+
+/// Either builds a ConstantExpr (literal) based on a scalar value, or passes
+/// through an ExprWrapper already constructed.
+template <typename T>
+inline ExprWrapper toExprWrapper(T value);
+
+// Specialization for long to avoid ambiguity.
+inline ExprWrapper toExprWrapper(long value);
+
+template <>
+inline ExprWrapper toExprWrapper<ExprWrapper>(ExprWrapper expr);
+
+/// Wrapper library used so we can safely overload operators.
+class ExprWrapper {
+ public:
+  ExprWrapper(const core::ExprPtr& expr) : expr_(expr) {}
+
+  std::string toString() const {
+    return expr_->toString();
+  }
+
+  core::ExprPtr expr() const {
+    return expr_;
+  }
+
+  /// Add an alias to the current expression:
+  ///
+  /// > col("c0").alias("my_column");
+  ExprWrapper& alias(const std::string& newAlias) {
+    expr_ = expr_->withAlias(newAlias);
+    return *this;
+  }
+
+  /// Add a "subfield" expression to enable access of subfields in
+  /// rows/structs:
+  ///
+  /// > col("parent_col").subfield("child_name");
+  ExprWrapper& subfield(std::string childName) {
+    expr_ = std::make_shared<core::FieldAccessExpr>(
+        std::move(childName), std::nullopt, std::vector<core::ExprPtr>{expr_});
+    return *this;
+  }
+
+  /// Add a "cast" to the current expression:
+  ///
+  /// > col("c0").cast(VARBINARY());
+  /// > lit(10).cast(TINYINT());
+  ExprWrapper& cast(const TypePtr& castType) {
+    expr_ =
+        std::make_shared<core::CastExpr>(castType, expr_, false, std::nullopt);
+    return *this;
+  }
+
+  /// Add a "try_cast" to the current expression:
+  ///
+  /// > col("c0").tryCast(VARBINARY());
+  /// > lit(10).tryCast(TINYINT());
+  ExprWrapper& tryCast(const TypePtr& castType) {
+    expr_ =
+        std::make_shared<core::CastExpr>(castType, expr_, true, std::nullopt);
+    return *this;
+  }
+
+  /// Add a "is_null" to the current expression:
+  ///
+  /// > col("c0").isNull();
+  ExprWrapper& isNull() {
+    expr_ = std::make_shared<core::CallExpr>(
+        "is_null", std::vector<core::ExprPtr>{expr_}, std::nullopt);
+    return *this;
+  }
+
+  /// Add a "between" clause to the current expression wrapper:
+  ///
+  /// > col("a").between(1, 10);
+  template <typename T1, typename T2>
+  ExprWrapper& between(const T1& value1, const T2& value2) {
+    expr_ = std::make_shared<core::CallExpr>(
+        "between",
+        std::vector<core::ExprPtr>{
+            expr_,
+            detail::toExprWrapper(value1),
+            detail::toExprWrapper(value2)},
+        std::nullopt);
+    return *this;
+  }
+
+  /// If equality is used against an actual ExpPtr (not the wrapper), this will
+  /// compare the expressions themselves.
+  ///
+  /// It won't assume this is generating a eq() Velox expression.
+  bool operator==(const core::ExprPtr& other) const {
+    return *expr_ == *other;
+  }
+
+  /// Provide better gtest failure messages.
+  friend std::ostream& operator<<(std::ostream& os, const ExprWrapper& expr) {
+    return os << expr.expr_->toString();
+  }
+
+  /// For convenience, enable implicit conversions to ExprPtr.
+  operator core::ExprPtr() const {
+    return expr_;
+  }
+
+ private:
+  core::ExprPtr expr_;
+};
+
+/// Unpacks a list of variadic template parameters in a
+/// std::vector<core::ExprPtr>. The elements could be ExprWrapper or C++
+/// literals, which will get converted to ConstantExpr.
+///
+/// Base of recursion.
+inline std::vector<core::ExprPtr> unpackList() {
+  return {};
+}
+
+template <typename TFirst, typename... TArgs>
+inline std::vector<core::ExprPtr> unpackList(TFirst first, TArgs&&... args) {
+  std::vector<core::ExprPtr> head = {toExprWrapper(first)};
+  auto tail = unpackList(std::forward<TArgs>(args)...);
+  head.insert(head.end(), tail.begin(), tail.end());
+  return head;
+}
+
+} // namespace detail
+
+/// Column references.
+inline detail::ExprWrapper col(std::string name) {
+  return {std::make_shared<const core::FieldAccessExpr>(
+      std::move(name), std::nullopt)};
+}
+
+/// Enable users to use a custom C++ literal to add a column reference.
+/// For example: "col"_c
+inline detail::ExprWrapper operator"" _c(const char* str, size_t len) {
+  return col(std::string(str, len));
+}
+
+/// Nested column names. Ror rows/struct member references.
+inline detail::ExprWrapper col(std::string parentName, std::string childName) {
+  return col(std::move(parentName)).subfield(std::move(childName));
+}
+
+/// Literals.
+inline detail::ExprWrapper lit(int64_t value) {
+  return {std::make_shared<core::ConstantExpr>(BIGINT(), value, std::nullopt)};
+}
+
+inline detail::ExprWrapper lit(int32_t value) {
+  return {std::make_shared<core::ConstantExpr>(INTEGER(), value, std::nullopt)};
+}
+
+inline detail::ExprWrapper lit(int16_t value) {
+  return {
+      std::make_shared<core::ConstantExpr>(SMALLINT(), value, std::nullopt)};
+}
+
+inline detail::ExprWrapper lit(int8_t value) {
+  return {std::make_shared<core::ConstantExpr>(TINYINT(), value, std::nullopt)};
+}
+
+inline detail::ExprWrapper lit(bool value) {
+  return {std::make_shared<core::ConstantExpr>(BOOLEAN(), value, std::nullopt)};
+}
+
+inline detail::ExprWrapper lit(double value) {
+  return {std::make_shared<core::ConstantExpr>(DOUBLE(), value, std::nullopt)};
+}
+
+inline detail::ExprWrapper lit(float value) {
+  return {std::make_shared<core::ConstantExpr>(REAL(), value, std::nullopt)};
+}
+
+/// Different string flavors.
+inline detail::ExprWrapper lit(const char* value) {
+  return {std::make_shared<core::ConstantExpr>(VARCHAR(), value, std::nullopt)};
+}
+
+inline detail::ExprWrapper lit(const std::string_view& value) {
+  return {std::make_shared<core::ConstantExpr>(
+      VARCHAR(), std::string(value), std::nullopt)};
+}
+
+inline detail::ExprWrapper lit(const std::string& value) {
+  return {std::make_shared<core::ConstantExpr>(VARCHAR(), value, std::nullopt)};
+}
+
+/// lit(nullptr).
+inline detail::ExprWrapper lit(std::nullptr_t) {
+  return {std::make_shared<core::ConstantExpr>(
+      UNKNOWN(), variant::null(TypeKind::UNKNOWN), std::nullopt)};
+}
+
+/// Macro to reduce builerplate when overloading C++ operators. The template
+/// magic basically means that the overload is matched if either left or right
+/// operands are an ExprWrapper. This is so that both "c"_f + 10 and 10 + "c"_f
+/// are supported, for example.
+///
+/// If either left or right side are ExprWrapper, we either convert the other
+/// side as a constant/literal, or use it as-is if it is already an ExprWrapper.
+#define VELOX_EXPR_BUILDER_OPERATOR(__op, __name)                    \
+  template <typename T1, typename T2>                                \
+  inline std::enable_if_t<                                           \
+      std::is_same_v<T1, detail::ExprWrapper> ||                     \
+          std::is_same_v<T2, detail::ExprWrapper>,                   \
+      detail::ExprWrapper>                                           \
+  __op(T1 lhs, T2 rhs) {                                             \
+    return {std::make_shared<core::CallExpr>(                        \
+        __name,                                                      \
+        std::vector<core::ExprPtr>{                                  \
+            detail::toExprWrapper(lhs), detail::toExprWrapper(rhs)}, \
+        std::nullopt)};                                              \
+  }
+
+/// Define C++ operator overload for comparisons.
+VELOX_EXPR_BUILDER_OPERATOR(operator==, "eq");
+VELOX_EXPR_BUILDER_OPERATOR(operator!=, "neq");
+VELOX_EXPR_BUILDER_OPERATOR(operator<, "lt");
+VELOX_EXPR_BUILDER_OPERATOR(operator<=, "lte");
+VELOX_EXPR_BUILDER_OPERATOR(operator>, "gt");
+VELOX_EXPR_BUILDER_OPERATOR(operator>=, "gte");
+
+/// Define C++ operator overload for arithmetics.
+VELOX_EXPR_BUILDER_OPERATOR(operator+, "plus");
+VELOX_EXPR_BUILDER_OPERATOR(operator-, "minus");
+VELOX_EXPR_BUILDER_OPERATOR(operator*, "multiply");
+VELOX_EXPR_BUILDER_OPERATOR(operator/, "divide");
+VELOX_EXPR_BUILDER_OPERATOR(operator%, "mod");
+
+VELOX_EXPR_BUILDER_OPERATOR(operator&&, "and");
+VELOX_EXPR_BUILDER_OPERATOR(operator||, "or");
+
+/// "not" is an unary operator.
+inline detail::ExprWrapper operator!(detail::ExprWrapper expr) {
+  return {std::make_shared<core::CallExpr>(
+      "not", std::vector<core::ExprPtr>{expr.expr()}, std::nullopt)};
+}
+
+/// "is_null" is also unary.
+template <typename T>
+inline detail::ExprWrapper isNull(const T& expr) {
+  return detail::toExprWrapper(expr).isNull();
+}
+
+/// "alias" as a free function.
+template <typename TInput>
+inline detail::ExprWrapper alias(TInput lhs, const std::string& newAlias) {
+  return detail::toExprWrapper(lhs).alias(newAlias);
+}
+
+/// "cast" as a free function.
+template <typename TInput>
+inline detail::ExprWrapper cast(TInput lhs, const TypePtr& castType) {
+  return detail::toExprWrapper(lhs).cast(castType);
+}
+
+/// "tryCast" as a free function.
+template <typename TInput>
+inline detail::ExprWrapper tryCast(TInput lhs, const TypePtr& castType) {
+  return detail::toExprWrapper(lhs).tryCast(castType);
+}
+
+/// "between" as a free function.
+template <typename T1, typename T2>
+inline detail::ExprWrapper
+between(detail::ExprWrapper lhs, const T1& value1, const T2& value2) {
+  return lhs.between(value1, value2);
+}
+
+/// Creates a lambda expressions, given the function parameters and an
+/// expression for the function body.
+template <typename TInput>
+inline detail::ExprWrapper lambda(
+    std::initializer_list<std::string> args,
+    const TInput& body) {
+  return {std::make_shared<core::LambdaExpr>(
+      std::move(args), detail::toExprWrapper(body))};
+}
+
+/// Convenience lambda builder for single argument lambdas.
+template <typename TInput>
+inline detail::ExprWrapper lambda(std::string arg, const TInput& body) {
+  return lambda({std::move(arg)}, body);
+}
+
+/// Regular function calls. First parameter is the function name, followed by
+/// their parameters. Parameters can be other expression nodes or literals.
+template <typename... TArgs>
+inline detail::ExprWrapper call(std::string name, TArgs&&... args) {
+  return {std::make_shared<core::CallExpr>(
+      std::move(name),
+      detail::unpackList(std::forward<TArgs>(args)...),
+      std::nullopt)};
+}
+
+namespace detail {
+
+template <typename T>
+inline ExprWrapper toExprWrapper(T value) {
+  return lit(value);
+}
+
+inline ExprWrapper toExprWrapper(long value) {
+  return lit(static_cast<int64_t>(value));
+}
+
+template <>
+inline ExprWrapper toExprWrapper<ExprWrapper>(ExprWrapper expr) {
+  return expr;
+}
+
+} // namespace detail
+
+} // namespace facebook::velox::expr_builder
diff --git a/velox/exec/tests/utils/FilterToExpression.cpp b/velox/exec/tests/utils/FilterToExpression.cpp
index 4a73f9c9def..7546694935d 100644
--- a/velox/exec/tests/utils/FilterToExpression.cpp
+++ b/velox/exec/tests/utils/FilterToExpression.cpp
@@ -146,8 +146,9 @@ core::TypedExprPtr filterToExpr(
               subfieldType,
               variant(static_cast<int32_t>(rangeFilter->lower())));
 
-          conditions.push_back(std::make_shared<CallTypedExpr>(
-              BOOLEAN(), "gte", subfieldExpr, lower));
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "gte", subfieldExpr, lower));
         }
 
         if (rangeFilter->upper() < kMaxInt64) {
@@ -155,8 +156,9 @@ core::TypedExprPtr filterToExpr(
               subfieldType,
               variant(static_cast<int32_t>(rangeFilter->upper())));
 
-          conditions.push_back(std::make_shared<CallTypedExpr>(
-              BOOLEAN(), "lte", subfieldExpr, upper));
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "lte", subfieldExpr, upper));
         }
 
         auto rangeExpr = createBooleanExpr(conditions);
@@ -258,11 +260,13 @@ core::TypedExprPtr filterToExpr(
         }
 
         if (doubleFilter->lowerExclusive()) {
-          conditions.push_back(std::make_shared<CallTypedExpr>(
-              BOOLEAN(), "gt", subfieldExpr, lower));
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "gt", subfieldExpr, lower));
         } else {
-          conditions.push_back(std::make_shared<CallTypedExpr>(
-              BOOLEAN(), "gte", subfieldExpr, lower));
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "gte", subfieldExpr, lower));
         }
       }
 
@@ -283,11 +287,13 @@ core::TypedExprPtr filterToExpr(
         }
 
         if (doubleFilter->upperExclusive()) {
-          conditions.push_back(std::make_shared<CallTypedExpr>(
-              BOOLEAN(), "lt", subfieldExpr, upper));
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "lt", subfieldExpr, upper));
         } else {
-          conditions.push_back(std::make_shared<CallTypedExpr>(
-              BOOLEAN(), "lte", subfieldExpr, upper));
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "lte", subfieldExpr, upper));
         }
       }
 
@@ -308,11 +314,13 @@ core::TypedExprPtr filterToExpr(
             subfieldType, variant(static_cast<float>(lowerValue)));
 
         if (floatFilter->lowerExclusive()) {
-          conditions.push_back(std::make_shared<CallTypedExpr>(
-              BOOLEAN(), "gt", subfieldExpr, lower));
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "gt", subfieldExpr, lower));
         } else {
-          conditions.push_back(std::make_shared<CallTypedExpr>(
-              BOOLEAN(), "gte", subfieldExpr, lower));
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "gte", subfieldExpr, lower));
         }
       }
 
@@ -322,11 +330,13 @@ core::TypedExprPtr filterToExpr(
             subfieldType, variant(static_cast<float>(upperValue)));
 
         if (floatFilter->upperExclusive()) {
-          conditions.push_back(std::make_shared<CallTypedExpr>(
-              BOOLEAN(), "lt", subfieldExpr, upper));
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "lt", subfieldExpr, upper));
         } else {
-          conditions.push_back(std::make_shared<CallTypedExpr>(
-              BOOLEAN(), "lte", subfieldExpr, upper));
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "lte", subfieldExpr, upper));
         }
       }
 
@@ -346,11 +356,13 @@ core::TypedExprPtr filterToExpr(
             subfieldType, variant(bytesFilter->lower()));
 
         if (bytesFilter->isLowerExclusive()) {
-          conditions.push_back(std::make_shared<CallTypedExpr>(
-              BOOLEAN(), "gt", subfieldExpr, lower));
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "gt", subfieldExpr, lower));
         } else {
-          conditions.push_back(std::make_shared<CallTypedExpr>(
-              BOOLEAN(), "gte", subfieldExpr, lower));
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "gte", subfieldExpr, lower));
         }
       }
 
@@ -359,11 +371,13 @@ core::TypedExprPtr filterToExpr(
             subfieldType, variant(bytesFilter->upper()));
 
         if (bytesFilter->isUpperExclusive()) {
-          conditions.push_back(std::make_shared<CallTypedExpr>(
-              BOOLEAN(), "lt", subfieldExpr, upper));
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "lt", subfieldExpr, upper));
         } else {
-          conditions.push_back(std::make_shared<CallTypedExpr>(
-              BOOLEAN(), "lte", subfieldExpr, upper));
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "lte", subfieldExpr, upper));
         }
       }
 
@@ -401,21 +415,25 @@ core::TypedExprPtr filterToExpr(
       for (const auto& value : values) {
         switch (subfieldType->kind()) {
           case TypeKind::TINYINT:
-            valueExprs.push_back(std::make_shared<ConstantTypedExpr>(
-                subfieldType, variant(static_cast<int8_t>(value))));
+            valueExprs.push_back(
+                std::make_shared<ConstantTypedExpr>(
+                    subfieldType, variant(static_cast<int8_t>(value))));
             break;
           case TypeKind::SMALLINT:
-            valueExprs.push_back(std::make_shared<ConstantTypedExpr>(
-                subfieldType, variant(static_cast<int16_t>(value))));
+            valueExprs.push_back(
+                std::make_shared<ConstantTypedExpr>(
+                    subfieldType, variant(static_cast<int16_t>(value))));
             break;
           case TypeKind::INTEGER:
-            valueExprs.push_back(std::make_shared<ConstantTypedExpr>(
-                subfieldType, variant(static_cast<int32_t>(value))));
+            valueExprs.push_back(
+                std::make_shared<ConstantTypedExpr>(
+                    subfieldType, variant(static_cast<int32_t>(value))));
             break;
           case TypeKind::BIGINT:
           default:
-            valueExprs.push_back(std::make_shared<ConstantTypedExpr>(
-                subfieldType, variant(value)));
+            valueExprs.push_back(
+                std::make_shared<ConstantTypedExpr>(
+                    subfieldType, variant(value)));
             break;
         }
       }
diff --git a/velox/exec/tests/utils/HashJoinTestBase.h b/velox/exec/tests/utils/HashJoinTestBase.h
index 1f01b7a2e28..6d9ee6b7854 100644
--- a/velox/exec/tests/utils/HashJoinTestBase.h
+++ b/velox/exec/tests/utils/HashJoinTestBase.h
@@ -17,20 +17,21 @@
 #include <re2/re2.h>
 
 #include <fmt/format.h>
-#include "folly/experimental/EventCount.h"
+#include "folly/synchronization/EventCount.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/exec/Cursor.h"
 #include "velox/exec/HashBuild.h"
 #include "velox/exec/HashJoinBridge.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/tests/utils/ArbitratorTestUtil.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/exec/tests/utils/VectorTestUtil.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
@@ -42,28 +43,45 @@ using facebook::velox::test::BatchMaker;
 
 struct TestParam {
   int64_t numDrivers{1};
+  bool parallelBuildSideRowsEnabled;
 
-  explicit TestParam(int _numDrivers) : numDrivers(_numDrivers) {}
+  explicit TestParam(int _numDrivers)
+      : numDrivers(_numDrivers), parallelBuildSideRowsEnabled(false) {}
+
+  TestParam(int _numDrivers, bool _parallelBuildSideRowsEnabled)
+      : numDrivers(_numDrivers),
+        parallelBuildSideRowsEnabled(_parallelBuildSideRowsEnabled) {}
 };
 
+// Required for GTest to generate unique parameterized test names.
+inline std::string TestParamToName(const TestParam& param) {
+  return fmt::format(
+      "{}_drivers_{}_parallelBuildSideRowsEnabled",
+      param.numDrivers,
+      param.parallelBuildSideRowsEnabled ? "with" : "without");
+}
+
+using SplitPath =
+    std::unordered_map<core::PlanNodeId, std::vector<std::string>>;
+
 using SplitInput =
     std::unordered_map<core::PlanNodeId, std::vector<exec::Split>>;
 
 // Returns aggregated spilled stats by build and probe operators from 'task'.
-std::pair<common::SpillStats, common::SpillStats> taskSpilledStats(
+std::pair<exec::SpillStats, exec::SpillStats> taskSpilledStats(
     const exec::Task& task) {
-  common::SpillStats buildStats;
-  common::SpillStats probeStats;
+  exec::SpillStats buildStats;
+  exec::SpillStats probeStats;
   auto stats = task.taskStats();
   for (auto& pipeline : stats.pipelineStats) {
     for (auto op : pipeline.operatorStats) {
-      if (op.operatorType == "HashBuild") {
+      if (op.operatorType == OperatorType::kHashBuild) {
         buildStats.spilledInputBytes += op.spilledInputBytes;
         buildStats.spilledBytes += op.spilledBytes;
         buildStats.spilledRows += op.spilledRows;
         buildStats.spilledPartitions += op.spilledPartitions;
         buildStats.spilledFiles += op.spilledFiles;
-      } else if (op.operatorType == "HashProbe") {
+      } else if (op.operatorType == OperatorType::kHashProbe) {
         probeStats.spilledInputBytes += op.spilledInputBytes;
         probeStats.spilledBytes += op.spilledBytes;
         probeStats.spilledRows += op.spilledRows;
@@ -81,55 +99,90 @@ void verifyTaskSpilledRuntimeStats(const exec::Task& task, bool expectedSpill) {
   auto stats = task.taskStats();
   for (auto& pipeline : stats.pipelineStats) {
     for (auto op : pipeline.operatorStats) {
-      if ((op.operatorType == "HashBuild") ||
-          (op.operatorType == "HashProbe")) {
+      if ((op.operatorType == OperatorType::kHashBuild) ||
+          (op.operatorType == OperatorType::kHashProbe)) {
         if (!expectedSpill) {
-          ASSERT_EQ(op.runtimeStats[Operator::kSpillRuns].count, 0);
-          ASSERT_EQ(op.runtimeStats[Operator::kSpillFillTime].count, 0);
-          ASSERT_EQ(op.runtimeStats[Operator::kSpillSortTime].count, 0);
           ASSERT_EQ(
-              op.runtimeStats[Operator::kSpillExtractVectorTime].count, 0);
+              op.runtimeStats[std::string(Operator::kSpillRuns)].count, 0);
+          ASSERT_EQ(
+              op.runtimeStats[std::string(Operator::kSpillFillTime)].count, 0);
+          ASSERT_EQ(
+              op.runtimeStats[std::string(Operator::kSpillSortTime)].count, 0);
+          ASSERT_EQ(
+              op.runtimeStats[std::string(Operator::kSpillExtractVectorTime)]
+                  .count,
+              0);
+          ASSERT_EQ(
+              op.runtimeStats[std::string(Operator::kSpillSerializationTime)]
+                  .count,
+              0);
+          ASSERT_EQ(
+              op.runtimeStats[std::string(Operator::kSpillFlushTime)].count, 0);
           ASSERT_EQ(
-              op.runtimeStats[Operator::kSpillSerializationTime].count, 0);
-          ASSERT_EQ(op.runtimeStats[Operator::kSpillFlushTime].count, 0);
-          ASSERT_EQ(op.runtimeStats[Operator::kSpillWrites].count, 0);
-          ASSERT_EQ(op.runtimeStats[Operator::kSpillWriteTime].count, 0);
-          ASSERT_EQ(op.runtimeStats[Operator::kSpillReadBytes].count, 0);
-          ASSERT_EQ(op.runtimeStats[Operator::kSpillReads].count, 0);
-          ASSERT_EQ(op.runtimeStats[Operator::kSpillReadTime].count, 0);
+              op.runtimeStats[std::string(Operator::kSpillWrites)].count, 0);
           ASSERT_EQ(
-              op.runtimeStats[Operator::kSpillDeserializationTime].count, 0);
+              op.runtimeStats[std::string(Operator::kSpillWriteTime)].count, 0);
+          ASSERT_EQ(
+              op.runtimeStats[std::string(Operator::kSpillReadBytes)].count, 0);
+          ASSERT_EQ(
+              op.runtimeStats[std::string(Operator::kSpillReads)].count, 0);
+          ASSERT_EQ(
+              op.runtimeStats[std::string(Operator::kSpillReadTime)].count, 0);
+          ASSERT_EQ(
+              op.runtimeStats[std::string(Operator::kSpillDeserializationTime)]
+                  .count,
+              0);
         } else {
-          if (op.operatorType == "HashBuild") {
-            ASSERT_GT(op.runtimeStats[Operator::kSpillRuns].count, 0);
-            ASSERT_GT(op.runtimeStats[Operator::kSpillFillTime].sum, 0);
+          if (op.operatorType == OperatorType::kHashBuild) {
             ASSERT_GT(
-                op.runtimeStats[Operator::kSpillExtractVectorTime].sum, 0);
+                op.runtimeStats[std::string(Operator::kSpillRuns)].count, 0);
+            ASSERT_GT(
+                op.runtimeStats[std::string(Operator::kSpillFillTime)].sum, 0);
+            ASSERT_GT(
+                op.runtimeStats[std::string(Operator::kSpillExtractVectorTime)]
+                    .sum,
+                0);
           } else {
             // The table spilling might also be triggered from hash probe side.
-            ASSERT_GE(op.runtimeStats[Operator::kSpillRuns].count, 0);
-            ASSERT_GE(op.runtimeStats[Operator::kSpillFillTime].sum, 0);
             ASSERT_GE(
-                op.runtimeStats[Operator::kSpillExtractVectorTime].sum, 0);
+                op.runtimeStats[std::string(Operator::kSpillRuns)].count, 0);
+            ASSERT_GE(
+                op.runtimeStats[std::string(Operator::kSpillFillTime)].sum, 0);
+            ASSERT_GE(
+                op.runtimeStats[std::string(Operator::kSpillExtractVectorTime)]
+                    .sum,
+                0);
           }
-          ASSERT_EQ(op.runtimeStats[Operator::kSpillSortTime].sum, 0);
-          ASSERT_GT(op.runtimeStats[Operator::kSpillSerializationTime].sum, 0);
-          ASSERT_GE(op.runtimeStats[Operator::kSpillFlushTime].sum, 0);
+          ASSERT_EQ(
+              op.runtimeStats[std::string(Operator::kSpillSortTime)].sum, 0);
+          ASSERT_GT(
+              op.runtimeStats[std::string(Operator::kSpillSerializationTime)]
+                  .sum,
+              0);
+          ASSERT_GE(
+              op.runtimeStats[std::string(Operator::kSpillFlushTime)].sum, 0);
           // NOTE: spill flush might take less than one microsecond.
           ASSERT_GE(
-              op.runtimeStats[Operator::kSpillSerializationTime].count,
-              op.runtimeStats[Operator::kSpillFlushTime].count);
-          ASSERT_GT(op.runtimeStats[Operator::kSpillWrites].sum, 0);
-          ASSERT_GE(op.runtimeStats[Operator::kSpillWriteTime].sum, 0);
+              op.runtimeStats[std::string(Operator::kSpillSerializationTime)]
+                  .count,
+              op.runtimeStats[std::string(Operator::kSpillFlushTime)].count);
+          ASSERT_GT(
+              op.runtimeStats[std::string(Operator::kSpillWrites)].sum, 0);
+          ASSERT_GE(
+              op.runtimeStats[std::string(Operator::kSpillWriteTime)].sum, 0);
           // NOTE: spill flush might take less than one microsecond.
           ASSERT_GE(
-              op.runtimeStats[Operator::kSpillWrites].count,
-              op.runtimeStats[Operator::kSpillWriteTime].count);
-          ASSERT_GT(op.runtimeStats[Operator::kSpillReadBytes].sum, 0);
-          ASSERT_GT(op.runtimeStats[Operator::kSpillReads].sum, 0);
-          ASSERT_GT(op.runtimeStats[Operator::kSpillReadTime].sum, 0);
+              op.runtimeStats[std::string(Operator::kSpillWrites)].count,
+              op.runtimeStats[std::string(Operator::kSpillWriteTime)].count);
           ASSERT_GT(
-              op.runtimeStats[Operator::kSpillDeserializationTime].sum, 0);
+              op.runtimeStats[std::string(Operator::kSpillReadBytes)].sum, 0);
+          ASSERT_GT(op.runtimeStats[std::string(Operator::kSpillReads)].sum, 0);
+          ASSERT_GT(
+              op.runtimeStats[std::string(Operator::kSpillReadTime)].sum, 0);
+          ASSERT_GT(
+              op.runtimeStats[std::string(Operator::kSpillDeserializationTime)]
+                  .sum,
+              0);
         }
       }
     }
@@ -155,12 +208,15 @@ int32_t maxHashBuildSpillLevel(const exec::Task& task) {
   int32_t maxSpillLevel = -1;
   for (auto& pipelineStat : task.taskStats().pipelineStats) {
     for (auto& operatorStat : pipelineStat.operatorStats) {
-      if (operatorStat.operatorType == "HashBuild") {
-        if (operatorStat.runtimeStats.count("maxSpillLevel") == 0) {
+      if (operatorStat.operatorType == OperatorType::kHashBuild) {
+        if (operatorStat.runtimeStats.count(
+                std::string(HashBuild::kMaxSpillLevel)) == 0) {
           continue;
         }
         maxSpillLevel = std::max<int32_t>(
-            maxSpillLevel, operatorStat.runtimeStats["maxSpillLevel"].max);
+            maxSpillLevel,
+            operatorStat.runtimeStats[std::string(HashBuild::kMaxSpillLevel)]
+                .max);
       }
     }
   }
@@ -175,11 +231,11 @@ std::pair<int32_t, int32_t> numTaskSpillFiles(const exec::Task& task) {
       if (operatorStat.runtimeStats.count("spillFileSize") == 0) {
         continue;
       }
-      if (operatorStat.operatorType == "HashBuild") {
+      if (operatorStat.operatorType == OperatorType::kHashBuild) {
         numBuildFiles += operatorStat.runtimeStats["spillFileSize"].count;
         continue;
       }
-      if (operatorStat.operatorType == "HashProbe") {
+      if (operatorStat.operatorType == OperatorType::kHashProbe) {
         numProbeFiles += operatorStat.runtimeStats["spillFileSize"].count;
       }
     }
@@ -344,6 +400,11 @@ class HashJoinBuilder {
     return *this;
   }
 
+  HashJoinBuilder& nullAsValue(bool nullAsValue) {
+    nullAsValue_ = nullAsValue;
+    return *this;
+  }
+
   HashJoinBuilder& joinFilter(const std::string& joinFilter) {
     joinFilter_ = joinFilter;
     return *this;
@@ -361,8 +422,20 @@ class HashJoinBuilder {
     return *this;
   }
 
-  HashJoinBuilder& inputSplits(const SplitInput& inputSplits) {
-    makeInputSplits_ = [inputSplits] { return inputSplits; };
+  HashJoinBuilder& inputSplits(const SplitPath& splitPaths) {
+    makeInputSplits_ = [splitPaths] {
+      SplitInput inputSplits;
+      for (const auto& [nodeId, paths] : splitPaths) {
+        std::vector<exec::Split> splits;
+        splits.reserve(paths.size());
+        for (const auto& path : paths) {
+          splits.emplace_back(
+              exec::Split(HiveConnectorSplitBuilder(path).build()));
+        }
+        inputSplits[nodeId] = std::move(splits);
+      }
+      return inputSplits;
+    };
     return *this;
   }
 
@@ -407,6 +480,11 @@ class HashJoinBuilder {
     return *this;
   }
 
+  HashJoinBuilder& parallelizeJoinBuildRows(bool value) {
+    parallelJoinBuildRowsEnabled_ = value;
+    return *this;
+  }
+
   HashJoinBuilder& spillDirectory(const std::string& spillDirectory) {
     spillDirectory_ = spillDirectory;
     return *this;
@@ -467,8 +545,9 @@ class HashJoinBuilder {
     }
 
     for (const auto& testData : testSettings) {
-      SCOPED_TRACE(fmt::format(
-          "{} numDrivers: {}", testData.debugString(), numDrivers_));
+      SCOPED_TRACE(
+          fmt::format(
+              "{} numDrivers: {}", testData.debugString(), numDrivers_));
       auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
       std::shared_ptr<const core::HashJoinNode> joinNode;
       auto planNode =
@@ -492,7 +571,8 @@ class HashJoinBuilder {
                   joinFilter_,
                   joinOutputLayout_,
                   joinType_,
-                  nullAware_)
+                  nullAware_,
+                  nullAsValue_)
               .capturePlanNode<core::HashJoinNode>(joinNode)
               .optionalProject(outputProjections_)
               .planNode();
@@ -596,19 +676,18 @@ class HashJoinBuilder {
         builder.splits(splitEntry.first, splitEntry.second);
       }
     }
-    auto queryCtx = core::QueryCtx::create(
-        executor_,
-        core::QueryConfig{{}},
-        std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
-        cache::AsyncDataCache::getInstance(),
-        memory::MemoryManager::getInstance()->addRootPool(
-            "query_pool",
-            memory::kMaxMemory,
-            memory::MemoryReclaimer::create()));
+    auto queryCtx = core::QueryCtx::Builder()
+                        .executor(executor_)
+                        .pool(
+                            memory::MemoryManager::getInstance()->addRootPool(
+                                "query_pool",
+                                memory::kMaxMemory,
+                                memory::MemoryReclaimer::create()))
+                        .build();
     std::shared_ptr<TempDirectoryPath> spillDirectory;
     int32_t spillPct{0};
     if (injectSpill) {
-      spillDirectory = exec::test::TempDirectoryPath::create();
+      spillDirectory = TempDirectoryPath::create();
       builder.spillDirectory(spillDirectory->getPath());
       config(core::QueryConfig::kSpillEnabled, "true");
       config(core::QueryConfig::kMaxSpillLevel, std::to_string(maxSpillLevel));
@@ -628,6 +707,9 @@ class HashJoinBuilder {
     config(
         core::QueryConfig::kHashProbeFinishEarlyOnEmptyBuild,
         hashProbeFinishEarlyOnEmptyBuild_ ? "true" : "false");
+    config(
+        core::QueryConfig::kParallelOutputJoinBuildRowsEnabled,
+        parallelJoinBuildRowsEnabled_ ? "true" : "false");
     if (maxDriverYieldTimeMs != 0) {
       config(
           core::QueryConfig::kDriverCpuTimeSliceLimitMs,
@@ -728,6 +810,7 @@ class HashJoinBuilder {
   int32_t numDrivers_{1};
   core::JoinType joinType_{core::JoinType::kInner};
   bool nullAware_{false};
+  bool nullAsValue_{false};
   std::string referenceQuery_;
 
   RowTypePtr probeType_;
@@ -759,8 +842,8 @@ class HashJoinBuilder {
   std::shared_ptr<memory::MemoryPool> queryPool_;
   std::string spillDirectory_;
   bool hashProbeFinishEarlyOnEmptyBuild_{true};
+  bool parallelJoinBuildRowsEnabled_{false};
 
-  SplitInput inputSplits_;
   std::function<SplitInput()> makeInputSplits_;
   core::PlanNodePtr planNode_;
   std::unordered_map<std::string, std::string> configs_;
@@ -773,7 +856,8 @@ class HashJoinTestBase : public HiveConnectorTestBase {
   HashJoinTestBase() : HashJoinTestBase(TestParam(1)) {}
 
   explicit HashJoinTestBase(const TestParam& param)
-      : numDrivers_(param.numDrivers) {}
+      : numDrivers_(param.numDrivers),
+        parallelBuildSideRowsEnabled_(param.parallelBuildSideRowsEnabled) {}
 
   void SetUp() override {
     HiveConnectorTestBase::SetUp();
@@ -855,15 +939,13 @@ class HashJoinTestBase : public HiveConnectorTestBase {
                       outputLayout,
                       joinType)
                   .planNode();
-    SplitInput splitInput = {
-        {probeScanId,
-         {exec::Split(makeHiveConnectorSplit(probeFile->getPath()))}},
-        {buildScanId,
-         {exec::Split(makeHiveConnectorSplit(buildFile->getPath()))}},
+    SplitPath splitPaths = {
+        {probeScanId, {probeFile->getPath()}},
+        {buildScanId, {buildFile->getPath()}},
     };
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .planNode(std::move(op))
-        .inputSplits(splitInput)
+        .inputSplits(splitPaths)
         .checkSpillStats(false)
         .referenceQuery(referenceQuery)
         .run();
@@ -966,6 +1048,7 @@ class HashJoinTestBase : public HiveConnectorTestBase {
   }
 
   const int32_t numDrivers_;
+  const bool parallelBuildSideRowsEnabled_;
 
   // The default left and right table types used for test.
   RowTypePtr probeType_;
diff --git a/velox/exec/tests/utils/HiveConnectorTestBase.cpp b/velox/exec/tests/utils/HiveConnectorTestBase.cpp
index 6e12c0d98aa..a8a0cd09a0c 100644
--- a/velox/exec/tests/utils/HiveConnectorTestBase.cpp
+++ b/velox/exec/tests/utils/HiveConnectorTestBase.cpp
@@ -16,9 +16,12 @@
 
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 
+#include "velox/common/caching/AsyncDataCache.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/file/tests/FaultyFileSystem.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/hive/HiveConnector.h"
+#include "velox/dwio/common/FileSink.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/dwio/dwrf/RegisterDwrfReader.h"
 #include "velox/dwio/dwrf/RegisterDwrfWriter.h"
@@ -28,6 +31,7 @@
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 
 namespace facebook::velox::exec::test {
+using namespace facebook::velox::common::testutil;
 
 HiveConnectorTestBase::HiveConnectorTestBase() {
   filesystems::registerLocalFileSystem();
@@ -36,13 +40,21 @@ HiveConnectorTestBase::HiveConnectorTestBase() {
 
 void HiveConnectorTestBase::SetUp() {
   OperatorTestBase::SetUp();
+
+  // Clear any stale cache entries from previous tests to avoid reading
+  // corrupted/stale data when temp files are reused (same inode/fileNum).
+  if (auto* cache = cache::AsyncDataCache::getInstance()) {
+    cache->clear();
+  }
+
   connector::hive::HiveConnectorFactory factory;
   auto hiveConnector = factory.newConnector(
       kHiveConnectorId,
       std::make_shared<config::ConfigBase>(
           std::unordered_map<std::string, std::string>()),
       ioExecutor_.get());
-  connector::registerConnector(hiveConnector);
+  connector::ConnectorRegistry::global().insert(
+      hiveConnector->connectorId(), hiveConnector);
   dwio::common::registerFileSinks();
   dwrf::registerDwrfReaderFactory();
   dwrf::registerDwrfWriterFactory();
@@ -55,19 +67,20 @@ void HiveConnectorTestBase::TearDown() {
   ioExecutor_.reset();
   dwrf::unregisterDwrfReaderFactory();
   dwrf::unregisterDwrfWriterFactory();
-  connector::unregisterConnector(kHiveConnectorId);
+  connector::ConnectorRegistry::global().erase(kHiveConnectorId);
   text::unregisterTextReaderFactory();
   OperatorTestBase::TearDown();
 }
 
 void HiveConnectorTestBase::resetHiveConnector(
     const std::shared_ptr<const config::ConfigBase>& config) {
-  connector::unregisterConnector(kHiveConnectorId);
+  connector::ConnectorRegistry::global().erase(kHiveConnectorId);
 
   connector::hive::HiveConnectorFactory factory;
   auto hiveConnector =
       factory.newConnector(kHiveConnectorId, config, ioExecutor_.get());
-  connector::registerConnector(hiveConnector);
+  connector::ConnectorRegistry::global().insert(
+      hiveConnector->connectorId(), hiveConnector);
 }
 
 void HiveConnectorTestBase::writeToFiles(
@@ -244,7 +257,7 @@ HiveConnectorTestBase::makeColumnHandle(
     const TypePtr& dataType,
     const TypePtr& hiveType,
     const std::vector<std::string>& requiredSubfields,
-    connector::hive::HiveColumnHandle::ColumnType columnType) {
+    connector::hive::FileColumnHandle::ColumnType columnType) {
   std::vector<common::Subfield> subfields;
   subfields.reserve(requiredSubfields.size());
   for (auto& path : requiredSubfields) {
@@ -320,7 +333,7 @@ HiveConnectorTestBase::makeHiveInsertTableHandle(
       std::move(locationHandle),
       tableStorageFormat,
       compressionKind,
-      {},
+      {}, // serdeParameters
       writerOptions,
       ensureFiles);
 }
@@ -337,7 +350,8 @@ HiveConnectorTestBase::makeHiveInsertTableHandle(
     const std::optional<common::CompressionKind> compressionKind,
     const std::unordered_map<std::string, std::string>& serdeParameters,
     const std::shared_ptr<dwio::common::WriterOptions>& writerOptions,
-    const bool ensureFiles) {
+    const bool ensureFiles,
+    const std::unordered_map<std::string, std::string>& storageParameters) {
   std::vector<std::shared_ptr<const connector::hive::HiveColumnHandle>>
       columnHandles;
   std::vector<std::string> bucketedBy;
@@ -371,14 +385,14 @@ HiveConnectorTestBase::makeHiveInsertTableHandle(
       columnHandles.push_back(
           std::make_shared<connector::hive::HiveColumnHandle>(
               tableColumnNames.at(i),
-              connector::hive::HiveColumnHandle::ColumnType::kPartitionKey,
+              connector::hive::FileColumnHandle::ColumnType::kPartitionKey,
               tableColumnTypes.at(i),
               tableColumnTypes.at(i)));
     } else {
       columnHandles.push_back(
           std::make_shared<connector::hive::HiveColumnHandle>(
               tableColumnNames.at(i),
-              connector::hive::HiveColumnHandle::ColumnType::kRegular,
+              connector::hive::FileColumnHandle::ColumnType::kRegular,
               tableColumnTypes.at(i),
               tableColumnTypes.at(i)));
     }
@@ -395,7 +409,9 @@ HiveConnectorTestBase::makeHiveInsertTableHandle(
       compressionKind,
       serdeParameters,
       writerOptions,
-      ensureFiles);
+      ensureFiles,
+      std::make_shared<const connector::hive::HiveInsertFileNameGenerator>(),
+      storageParameters);
 }
 
 std::shared_ptr<connector::hive::HiveColumnHandle>
@@ -404,7 +420,7 @@ HiveConnectorTestBase::regularColumn(
     const TypePtr& type) {
   return std::make_shared<connector::hive::HiveColumnHandle>(
       name,
-      connector::hive::HiveColumnHandle::ColumnType::kRegular,
+      connector::hive::FileColumnHandle::ColumnType::kRegular,
       type,
       type);
 }
@@ -415,7 +431,7 @@ HiveConnectorTestBase::synthesizedColumn(
     const TypePtr& type) {
   return std::make_shared<connector::hive::HiveColumnHandle>(
       name,
-      connector::hive::HiveColumnHandle::ColumnType::kSynthesized,
+      connector::hive::FileColumnHandle::ColumnType::kSynthesized,
       type,
       type);
 }
@@ -426,7 +442,7 @@ HiveConnectorTestBase::partitionKey(
     const TypePtr& type) {
   return std::make_shared<connector::hive::HiveColumnHandle>(
       name,
-      connector::hive::HiveColumnHandle::ColumnType::kPartitionKey,
+      connector::hive::FileColumnHandle::ColumnType::kPartitionKey,
       type,
       type);
 }
diff --git a/velox/exec/tests/utils/HiveConnectorTestBase.h b/velox/exec/tests/utils/HiveConnectorTestBase.h
index b3660714f50..a402fb9de91 100644
--- a/velox/exec/tests/utils/HiveConnectorTestBase.h
+++ b/velox/exec/tests/utils/HiveConnectorTestBase.h
@@ -15,16 +15,18 @@
  */
 #pragma once
 
+#include "velox/common/testutil/TempFilePath.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
 #include "velox/connectors/hive/HiveDataSink.h"
 #include "velox/connectors/hive/TableHandle.h"
 #include "velox/dwio/dwrf/common/Config.h"
 #include "velox/dwio/dwrf/writer/FlushPolicy.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
-#include "velox/exec/tests/utils/TempFilePath.h"
 
 namespace facebook::velox::exec::test {
 
+using TempFilePath = common::testutil::TempFilePath;
+
 static const std::string kHiveConnectorId = "test-hive";
 
 class HiveConnectorTestBase : public OperatorTestBase {
@@ -35,7 +37,9 @@ class HiveConnectorTestBase : public OperatorTestBase {
   void TearDown() override;
 
   void resetHiveConnector(
-      const std::shared_ptr<const config::ConfigBase>& config);
+      const std::shared_ptr<const config::ConfigBase>& config =
+          std::make_shared<config::ConfigBase>(
+              std::unordered_map<std::string, std::string>()));
 
   void writeToFiles(
       const std::vector<std::string>& filePaths,
@@ -130,17 +134,17 @@ class HiveConnectorTestBase : public OperatorTestBase {
       const core::TypedExprPtr& remainingFilter = nullptr,
       const std::string& tableName = "hive_table",
       const RowTypePtr& dataColumns = nullptr,
-      bool filterPushdownEnabled = true,
-      const std::unordered_map<std::string, std::string>& tableParameters =
+      const std::vector<std::string>& indexColumns = {},
+      const std::unordered_map<std::string, std::string>& storageParameters =
           {}) {
     return std::make_shared<connector::hive::HiveTableHandle>(
         kHiveConnectorId,
         tableName,
-        filterPushdownEnabled,
         std::move(subfieldFilters),
         remainingFilter,
         dataColumns,
-        tableParameters);
+        indexColumns,
+        storageParameters);
   }
 
   /// @param name Column name.
@@ -160,8 +164,8 @@ class HiveConnectorTestBase : public OperatorTestBase {
       const TypePtr& dataType,
       const TypePtr& hiveType,
       const std::vector<std::string>& requiredSubfields,
-      connector::hive::HiveColumnHandle::ColumnType columnType =
-          connector::hive::HiveColumnHandle::ColumnType::kRegular);
+      connector::hive::FileColumnHandle::ColumnType columnType =
+          connector::hive::FileColumnHandle::ColumnType::kRegular);
 
   /// @param targetDirectory Final directory of the target table after commit.
   /// @param writeDirectory Write directory of the target table before commit.
@@ -203,7 +207,9 @@ class HiveConnectorTestBase : public OperatorTestBase {
       const std::unordered_map<std::string, std::string>& serdeParameters = {},
       const std::shared_ptr<dwio::common::WriterOptions>& writerOptions =
           nullptr,
-      const bool ensureFiles = false);
+      const bool ensureFiles = false,
+      const std::unordered_map<std::string, std::string>& storageParameters =
+          {});
 
   static std::shared_ptr<connector::hive::HiveInsertTableHandle>
   makeHiveInsertTableHandle(
diff --git a/velox/exec/tests/utils/IndexLookupJoinTestBase.cpp b/velox/exec/tests/utils/IndexLookupJoinTestBase.cpp
index 9b4e85eb931..0f518b1ad6c 100644
--- a/velox/exec/tests/utils/IndexLookupJoinTestBase.cpp
+++ b/velox/exec/tests/utils/IndexLookupJoinTestBase.cpp
@@ -17,13 +17,14 @@
 #include "velox/exec/tests/utils/IndexLookupJoinTestBase.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/TestIndexStorageConnector.h"
 
-namespace fecebook::velox::exec::test {
-using namespace facebook::velox::test;
+namespace facebook::velox::exec::test {
+using namespace facebook::velox::common::testutil;
+using velox::test::assertEqualVectors;
 
 namespace {
-std::vector<std::string> appendMatchColumn(
-    const std::vector<std::string> columns) {
+std::vector<std::string> appendMarker(const std::vector<std::string> columns) {
   std::vector<std::string> resultColumns;
   resultColumns.reserve(columns.size() + 1);
   for (const auto& column : columns) {
@@ -56,7 +57,7 @@ std::vector<RowVectorPtr> IndexLookupJoinTestBase::generateProbeInput(
     size_t numBatches,
     size_t batchSize,
     size_t numDuplicateProbeRows,
-    SequenceTableData& tableData,
+    IndexTableData& tableData,
     std::shared_ptr<memory::MemoryPool>& pool,
     const std::vector<std::string>& probeJoinKeys,
     bool hasNullKeys,
@@ -80,7 +81,7 @@ std::vector<RowVectorPtr> IndexLookupJoinTestBase::generateProbeInput(
     probeInputs.push_back(fuzzer.fuzzInputRow(probeType_));
     // NOTE: index connector doesn't expect in condition column rray elements to
     // be null.
-    if ((!inMatchPct.has_value() || tableData.keyData->size() == 0) &&
+    if ((!inMatchPct.has_value() || tableData.keyVectors->size() == 0) &&
         hasNullKeys) {
       for (int i = 0; i < probeType_->size(); ++i) {
         const auto columnType = probeType_->childAt(i);
@@ -97,14 +98,14 @@ std::vector<RowVectorPtr> IndexLookupJoinTestBase::generateProbeInput(
     }
   }
 
-  if (tableData.keyData->size() == 0) {
+  if (tableData.keyVectors->size() == 0) {
     return probeInputs;
   }
 
-  const auto numTableRows = tableData.keyData->size();
+  const auto numTableRows = tableData.keyVectors->size();
   std::vector<FlatVectorPtr<int64_t>> tableKeyVectors;
   for (int i = 0; i < probeJoinKeys.size(); ++i) {
-    auto keyVector = tableData.keyData->childAt(i);
+    auto keyVector = tableData.keyVectors->childAt(i);
     keyVector->loadedVector();
     BaseVector::flattenVector(keyVector);
     tableKeyVectors.push_back(
@@ -117,10 +118,11 @@ std::vector<RowVectorPtr> IndexLookupJoinTestBase::generateProbeInput(
     for (int i = 0; i < numBatches; ++i) {
       std::vector<FlatVectorPtr<int64_t>> probeKeyVectors;
       for (int j = 0; j < probeJoinKeys.size(); ++j) {
-        probeKeyVectors.push_back(BaseVector::create<FlatVector<int64_t>>(
-            probeType_->findChild(probeJoinKeys[j]),
-            probeInputs[i]->size(),
-            pool.get()));
+        probeKeyVectors.push_back(
+            BaseVector::create<FlatVector<int64_t>>(
+                probeType_->findChild(probeJoinKeys[j]),
+                probeInputs[i]->size(),
+                pool.get()));
       }
       for (int row = 0; row < probeInputs[i]->size();
            row += numDuplicateProbeRows) {
@@ -259,7 +261,7 @@ PlanNodePtr IndexLookupJoinTestBase::makeLookupPlan(
     const std::vector<std::string>& leftKeys,
     const std::vector<std::string>& rightKeys,
     const std::vector<std::string>& joinConditions,
-    bool includeMatchColumn,
+    bool hasMarker,
     JoinType joinType,
     const std::vector<std::string>& outputColumns,
     PlanNodeId& joinNodeId) {
@@ -267,14 +269,15 @@ PlanNodePtr IndexLookupJoinTestBase::makeLookupPlan(
   VELOX_CHECK_LE(leftKeys.size(), keyType_->size());
   return PlanBuilder(planNodeIdGenerator, pool_.get())
       .values(probeVectors)
-      .indexLookupJoin(
-          leftKeys,
-          rightKeys,
-          indexScanNode,
-          joinConditions,
-          includeMatchColumn,
-          includeMatchColumn ? appendMatchColumn(outputColumns) : outputColumns,
-          joinType)
+      .startIndexLookupJoin()
+      .leftKeys(leftKeys)
+      .rightKeys(rightKeys)
+      .indexSource(indexScanNode)
+      .joinConditions(joinConditions)
+      .hasMarker(hasMarker)
+      .outputLayout(hasMarker ? appendMarker(outputColumns) : outputColumns)
+      .joinType(joinType)
+      .endIndexLookupJoin()
       .capturePlanNodeId(joinNodeId)
       .planNode();
 }
@@ -285,7 +288,8 @@ PlanNodePtr IndexLookupJoinTestBase::makeLookupPlan(
     const std::vector<std::string>& leftKeys,
     const std::vector<std::string>& rightKeys,
     const std::vector<std::string>& joinConditions,
-    bool includeMatchColumn,
+    const std::string& filter,
+    bool hasMarker,
     JoinType joinType,
     const std::vector<std::string>& outputColumns) {
   VELOX_CHECK_EQ(leftKeys.size(), rightKeys.size());
@@ -295,14 +299,16 @@ PlanNodePtr IndexLookupJoinTestBase::makeLookupPlan(
       .outputType(probeType_)
       .endTableScan()
       .captureScanNodeId(probeScanNodeId_)
-      .indexLookupJoin(
-          leftKeys,
-          rightKeys,
-          indexScanNode,
-          joinConditions,
-          includeMatchColumn,
-          includeMatchColumn ? appendMatchColumn(outputColumns) : outputColumns,
-          joinType)
+      .startIndexLookupJoin()
+      .leftKeys(leftKeys)
+      .rightKeys(rightKeys)
+      .indexSource(indexScanNode)
+      .joinConditions(joinConditions)
+      .filter(filter)
+      .hasMarker(hasMarker)
+      .outputLayout(hasMarker ? appendMarker(outputColumns) : outputColumns)
+      .joinType(joinType)
+      .endIndexLookupJoin()
       .capturePlanNodeId(joinNodeId_)
       .planNode();
 }
@@ -346,7 +352,7 @@ TableScanNodePtr IndexLookupJoinTestBase::makeIndexScanNode(
 
 void IndexLookupJoinTestBase::generateIndexTableData(
     const std::vector<int>& keyCardinalities,
-    SequenceTableData& tableData,
+    IndexTableData& tableData,
     std::shared_ptr<memory::MemoryPool>& pool) {
   VELOX_CHECK_EQ(keyCardinalities.size(), keyType_->size());
   const auto numRows = getNumRows(keyCardinalities);
@@ -356,10 +362,10 @@ void IndexLookupJoinTestBase::generateIndexTableData(
   opts.allowSlice = false;
   VectorFuzzer fuzzer(opts, pool.get());
 
-  tableData.keyData = fuzzer.fuzzInputFlatRow(keyType_);
-  tableData.valueData = fuzzer.fuzzInputFlatRow(valueType_);
+  tableData.keyVectors = fuzzer.fuzzInputFlatRow(keyType_);
+  tableData.valueVectors = fuzzer.fuzzInputFlatRow(valueType_);
 
-  VELOX_CHECK_EQ(numRows, tableData.keyData->size());
+  VELOX_CHECK_EQ(numRows, tableData.keyVectors->size());
   tableData.maxKeys.resize(keyType_->size());
   tableData.minKeys.resize(keyType_->size());
   // Set the key column vector to the same value to easy testing with
@@ -369,8 +375,8 @@ void IndexLookupJoinTestBase::generateIndexTableData(
     int64_t minKey = std::numeric_limits<int64_t>::max();
     int64_t maxKey = std::numeric_limits<int64_t>::min();
     int numKeys = keyCardinalities[i];
-    tableData.keyData->childAt(i) =
-        makeFlatVector<int64_t>(tableData.keyData->size(), [&](auto row) {
+    tableData.keyVectors->childAt(i) =
+        makeFlatVector<int64_t>(tableData.keyVectors->size(), [&](auto row) {
           const int64_t keyValue = 1 + (row / numRepeats) % numKeys;
           minKey = std::min(minKey, keyValue);
           maxKey = std::max(maxKey, keyValue);
@@ -384,12 +390,12 @@ void IndexLookupJoinTestBase::generateIndexTableData(
   VELOX_CHECK_EQ(tableType_->size(), keyType_->size() + valueType_->size());
   tableColumns.reserve(tableType_->size());
   for (auto i = 0; i < keyType_->size(); ++i) {
-    tableColumns.push_back(tableData.keyData->childAt(i));
+    tableColumns.push_back(tableData.keyVectors->childAt(i));
   }
   for (auto i = 0; i < valueType_->size(); ++i) {
-    tableColumns.push_back(tableData.valueData->childAt(i));
+    tableColumns.push_back(tableData.valueVectors->childAt(i));
   }
-  tableData.tableData = makeRowVector(tableType_->names(), tableColumns);
+  tableData.tableVectors = makeRowVector(tableType_->names(), tableColumns);
 }
 
 RowTypePtr IndexLookupJoinTestBase::makeScanOutputType(
@@ -415,13 +421,13 @@ bool IndexLookupJoinTestBase::isFilter(const std::string& conditionSql) const {
 std::shared_ptr<Task> IndexLookupJoinTestBase::runLookupQuery(
     const PlanNodePtr& plan,
     int numPrefetchBatches,
-    const std::string& duckDbVefifySql) {
+    const std::string& duckDbVerifySql) {
   return AssertQueryBuilder(duckDbQueryRunner_)
       .plan(plan)
       .config(
           QueryConfig::kIndexLookupJoinMaxPrefetchBatches,
           std::to_string(numPrefetchBatches))
-      .assertResults(duckDbVefifySql);
+      .assertResults(duckDbVerifySql);
 }
 
 std::shared_ptr<Task> IndexLookupJoinTestBase::runLookupQuery(
@@ -431,17 +437,30 @@ std::shared_ptr<Task> IndexLookupJoinTestBase::runLookupQuery(
     bool barrierExecution,
     int maxOutputRows,
     int numPrefetchBatches,
-    const std::string& duckDbVefifySql) {
-  return AssertQueryBuilder(duckDbQueryRunner_)
-      .plan(plan)
+    bool needsIndexSplit,
+    const std::string& duckDbVerifySql,
+    int maxDrivers) {
+  AssertQueryBuilder queryBuilder(duckDbQueryRunner_);
+  queryBuilder.plan(plan)
       .splits(probeScanNodeId_, makeHiveConnectorSplits(probeFiles))
       .serialExecution(serialExecution)
       .barrierExecution(barrierExecution)
+      .maxDrivers(maxDrivers)
       .config(QueryConfig::kMaxOutputBatchRows, std::to_string(maxOutputRows))
       .config(
           QueryConfig::kIndexLookupJoinMaxPrefetchBatches,
-          std::to_string(numPrefetchBatches))
-      .assertResults(duckDbVefifySql);
+          std::to_string(numPrefetchBatches));
+  if (needsIndexSplit) {
+    // Add a fake split for the index source. The test index source doesn't
+    // actually use splits, but this is used to verify the split passing
+    // mechanism works correctly.
+    queryBuilder.split(
+        indexScanNodeId_,
+        Split(
+            std::make_shared<TestIndexConnectorSplit>(
+                kTestIndexConnectorName)));
+  }
+  return queryBuilder.assertResults(duckDbVerifySql);
 }
 
 void IndexLookupJoinTestBase::verifyResultWithMatchColumn(
@@ -449,21 +468,36 @@ void IndexLookupJoinTestBase::verifyResultWithMatchColumn(
     const PlanNodeId& probeScanNodeIdWithoutMatchColumn,
     const PlanNodePtr& planWithMatchColumn,
     const PlanNodeId& probeScanNodeIdWithMatchColumn,
-    const std::vector<std::shared_ptr<TempFilePath>>& probeFiles) {
-  VectorPtr expectedResult = AssertQueryBuilder(duckDbQueryRunner_)
-                                 .plan(planWithoutMatchColumn)
-                                 .splits(
-                                     probeScanNodeIdWithoutMatchColumn,
-                                     makeHiveConnectorSplits(probeFiles))
-                                 .copyResults(pool());
+    const std::vector<std::shared_ptr<TempFilePath>>& probeFiles,
+    bool needsIndexSplit) {
+  AssertQueryBuilder expectedResultBuilder(duckDbQueryRunner_);
+  expectedResultBuilder.plan(planWithoutMatchColumn)
+      .splits(
+          probeScanNodeIdWithoutMatchColumn,
+          makeHiveConnectorSplits(probeFiles));
+  if (needsIndexSplit) {
+    expectedResultBuilder.split(
+        indexScanNodeId_,
+        Split(
+            std::make_shared<TestIndexConnectorSplit>(
+                kTestIndexConnectorName)));
+  }
+  VectorPtr expectedResult = expectedResultBuilder.copyResults(pool());
   BaseVector::flattenVector(expectedResult);
 
-  VectorPtr resultWithMatchColumn = AssertQueryBuilder(duckDbQueryRunner_)
-                                        .plan(planWithMatchColumn)
-                                        .splits(
-                                            probeScanNodeIdWithMatchColumn,
-                                            makeHiveConnectorSplits(probeFiles))
-                                        .copyResults(pool());
+  AssertQueryBuilder resultWithMatchColumnBuilder(duckDbQueryRunner_);
+  resultWithMatchColumnBuilder.plan(planWithMatchColumn)
+      .splits(
+          probeScanNodeIdWithMatchColumn, makeHiveConnectorSplits(probeFiles));
+  if (needsIndexSplit) {
+    resultWithMatchColumnBuilder.split(
+        indexScanNodeId_,
+        Split(
+            std::make_shared<TestIndexConnectorSplit>(
+                kTestIndexConnectorName)));
+  }
+  VectorPtr resultWithMatchColumn =
+      resultWithMatchColumnBuilder.copyResults(pool());
   BaseVector::flattenVector(resultWithMatchColumn);
   auto rowResultWithMatchMatchColumn =
       std::dynamic_pointer_cast<RowVector>(resultWithMatchColumn);
@@ -512,4 +546,4 @@ IndexLookupJoinTestBase::createProbeFiles(
   writeToFiles(toFilePaths(probeFiles), probeVectors);
   return probeFiles;
 }
-} // namespace fecebook::velox::exec::test
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/IndexLookupJoinTestBase.h b/velox/exec/tests/utils/IndexLookupJoinTestBase.h
index 561b6dfe9fe..d27284cd92c 100644
--- a/velox/exec/tests/utils/IndexLookupJoinTestBase.h
+++ b/velox/exec/tests/utils/IndexLookupJoinTestBase.h
@@ -19,12 +19,13 @@
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/parse/PlanNodeIdGenerator.h"
 
-namespace fecebook::velox::exec::test {
+namespace facebook::velox::exec::test {
 
 using namespace facebook::velox;
 using namespace facebook::velox::core;
 using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
+using namespace facebook::velox::common::testutil;
 
 class IndexLookupJoinTestBase : public HiveConnectorTestBase {
  protected:
@@ -35,10 +36,10 @@ class IndexLookupJoinTestBase : public HiveConnectorTestBase {
     rng_.seed(123);
   }
 
-  struct SequenceTableData {
-    RowVectorPtr keyData;
-    RowVectorPtr valueData;
-    RowVectorPtr tableData;
+  struct IndexTableData {
+    RowVectorPtr keyVectors;
+    RowVectorPtr valueVectors;
+    RowVectorPtr tableVectors;
     std::vector<int64_t> minKeys;
     std::vector<int64_t> maxKeys;
   };
@@ -70,7 +71,7 @@ class IndexLookupJoinTestBase : public HiveConnectorTestBase {
       size_t numBatches,
       size_t batchSize,
       size_t numDuplicateProbeRows,
-      SequenceTableData& tableData,
+      IndexTableData& tableData,
       std::shared_ptr<memory::MemoryPool>& pool,
       const std::vector<std::string>& probeJoinKeys,
       bool hasNullKeys = false,
@@ -86,7 +87,7 @@ class IndexLookupJoinTestBase : public HiveConnectorTestBase {
   /// @param probeVectors: the probe input vectors.
   /// @param leftKeys: the left join keys of index lookup join.
   /// @param rightKeys: the right join keys of index lookup join.
-  /// @param includeMatchColumn: whether the index join output includes a match
+  /// @param hasMarker: whether the index join output includes a match
   /// column at the end.
   /// @param joinType: the join type of index lookup join.
   /// @param outputColumns: the output column names of index lookup join.
@@ -99,30 +100,32 @@ class IndexLookupJoinTestBase : public HiveConnectorTestBase {
       const std::vector<std::string>& leftKeys,
       const std::vector<std::string>& rightKeys,
       const std::vector<std::string>& joinConditions,
-      bool includeMatchColumn,
+      bool hasMarker,
       core::JoinType joinType,
       const std::vector<std::string>& outputColumns,
       core::PlanNodeId& joinNodeId);
 
   /// Makes lookup join plan with the following parameters:
+  /// @param planNodeIdGenerator: generator for creating unique plan node IDs.
   /// @param indexScanNode: the index table scan node.
-  /// @param probeVectors: the probe input vectors.
   /// @param leftKeys: the left join keys of index lookup join.
   /// @param rightKeys: the right join keys of index lookup join.
-  /// @param includeMatchColumn: whether the index join output includes a match
+  /// @param joinConditions: the join conditions for index lookup join that
+  /// can't be converted into simple equality join conditions.
+  /// @param filter: additional filter condition SQL string to apply on join
+  /// results. Can be empty string if no additional filter is needed.
+  /// @param hasMarker: whether the index join output includes a match
   /// column at the end.
   /// @param joinType: the join type of index lookup join.
   /// @param outputColumns: the output column names of index lookup join.
-  /// @param joinNodeId: returns the plan node id of the index lookup join
-  /// node.
-  /// @param probeScanNodeId: returns the plan node id of the probe table scan
   PlanNodePtr makeLookupPlan(
       const std::shared_ptr<PlanNodeIdGenerator>& planNodeIdGenerator,
       TableScanNodePtr indexScanNode,
       const std::vector<std::string>& leftKeys,
       const std::vector<std::string>& rightKeys,
       const std::vector<std::string>& joinConditions,
-      bool includeMatchColumn,
+      const std::string& filter,
+      bool hasMarker,
       JoinType joinType,
       const std::vector<std::string>& outputColumns);
 
@@ -148,7 +151,7 @@ class IndexLookupJoinTestBase : public HiveConnectorTestBase {
   /// each index column.
   void generateIndexTableData(
       const std::vector<int>& keyCardinalities,
-      SequenceTableData& tableData,
+      IndexTableData& tableData,
       std::shared_ptr<memory::MemoryPool>& pool);
 
   /// Write 'probeVectors' to a number of files with one per each file.
@@ -162,7 +165,7 @@ class IndexLookupJoinTestBase : public HiveConnectorTestBase {
   std::shared_ptr<Task> runLookupQuery(
       const PlanNodePtr& plan,
       int numPrefetchBatches,
-      const std::string& duckDbVefifySql);
+      const std::string& duckDbVerifySql);
 
   std::shared_ptr<Task> runLookupQuery(
       const PlanNodePtr& plan,
@@ -171,7 +174,9 @@ class IndexLookupJoinTestBase : public HiveConnectorTestBase {
       bool barrierExecution,
       int maxBatchRows,
       int numPrefetchBatches,
-      const std::string& duckDbVefifySql);
+      bool needsIndexSplit,
+      const std::string& duckDbVerifySql,
+      int maxDrivers = 1);
 
   /// Verifies the results of the index lookup join query with and without match
   /// column.
@@ -180,7 +185,8 @@ class IndexLookupJoinTestBase : public HiveConnectorTestBase {
       const PlanNodeId& probeScanNodeIdWithoutMatchColumn,
       const PlanNodePtr& planWithMatchColumn,
       const PlanNodeId& probeScanNodeIdWithMatchColumn,
-      const std::vector<std::shared_ptr<TempFilePath>>& probeFiles);
+      const std::vector<std::shared_ptr<TempFilePath>>& probeFiles,
+      bool needsIndexSplit);
 
   RowTypePtr keyType_;
   std::optional<RowTypePtr> partitionType_;
@@ -192,4 +198,4 @@ class IndexLookupJoinTestBase : public HiveConnectorTestBase {
   PlanNodeId probeScanNodeId_;
   folly::Random::DefaultGenerator rng_;
 };
-} // namespace fecebook::velox::exec::test
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/LocalExchangeSource.cpp b/velox/exec/tests/utils/LocalExchangeSource.cpp
index d64dad29387..08963d226ed 100644
--- a/velox/exec/tests/utils/LocalExchangeSource.cpp
+++ b/velox/exec/tests/utils/LocalExchangeSource.cpp
@@ -17,7 +17,7 @@
 #include <folly/executors/IOThreadPoolExecutor.h>
 #include <atomic>
 #include "velox/common/testutil/TestValue.h"
-#include "velox/exec/ExchangeClient.h"
+#include "velox/exec/Operator.h"
 #include "velox/exec/OutputBufferManager.h"
 
 namespace facebook::velox::exec::test {
@@ -84,13 +84,13 @@ class LocalExchangeSource : public exec::ExchangeSource {
                 << requestedSequence;
         int64_t nExtra = requestedSequence - sequence;
         VELOX_CHECK(nExtra < data.size());
-        data.erase(data.begin(), data.begin() + nExtra);
+        data.erase(data.cbegin(), data.cbegin() + nExtra);
         sequence = requestedSequence;
       }
       if (data.empty()) {
         sequence = requestedSequence;
       }
-      std::vector<std::unique_ptr<SerializedPage>> pages;
+      std::vector<std::unique_ptr<SerializedPageBase>> pages;
       bool atEnd = false;
       int64_t totalBytes = 0;
       for (auto& inputPage : data) {
@@ -101,7 +101,8 @@ class LocalExchangeSource : public exec::ExchangeSource {
         }
         totalBytes += inputPage->length();
         inputPage->unshare();
-        pages.push_back(std::make_unique<SerializedPage>(std::move(inputPage)));
+        pages.push_back(
+            std::make_unique<PrestoSerializedPage>(std::move(inputPage)));
         inputPage = nullptr;
       }
       numPages_ += pages.size();
@@ -190,7 +191,7 @@ class LocalExchangeSource : public exec::ExchangeSource {
         {"localExchangeSource.numPages", RuntimeMetric(numPages_)},
         {"localExchangeSource.totalBytes",
          RuntimeMetric(totalBytes_, RuntimeCounter::Unit::kBytes)},
-        {ExchangeClient::kBackgroundCpuTimeMs,
+        {std::string(Operator::kBackgroundCpuTimeNanos),
          RuntimeMetric(123 * 1000000, RuntimeCounter::Unit::kNanos)},
     };
   }
@@ -271,7 +272,7 @@ class LocalExchangeSource : public exec::ExchangeSource {
   }
 
   bool checkSetRequestPromise() {
-    VeloxPromise<Response> promise;
+    VeloxPromise<Response> promise{VeloxPromise<Response>::makeEmpty()};
     {
       std::lock_guard<std::mutex> l(queue_->mutex());
       promise = std::move(promise_);
diff --git a/velox/exec/tests/utils/MergeTestBase.h b/velox/exec/tests/utils/MergeTestBase.h
index 54d4bdbac70..e20118f8df1 100644
--- a/velox/exec/tests/utils/MergeTestBase.h
+++ b/velox/exec/tests/utils/MergeTestBase.h
@@ -15,8 +15,9 @@
  */
 
 #include "velox/common/base/Exceptions.h"
+#include "velox/common/base/TreeOfLosers.h"
 #include "velox/common/time/Timer.h"
-#include "velox/exec/TreeOfLosers.h"
+#include "velox/exec/Spill.h"
 
 #include <folly/Random.h>
 
@@ -100,6 +101,44 @@ class TestingStream final : public MergeStream {
   std::vector<uint32_t> numbers_;
 };
 
+class TestingSpillMergeStream : public SpillMergeStream {
+ public:
+  TestingSpillMergeStream(
+      uint32_t id,
+      const std::vector<SpillSortKey>& sortingKeys,
+      RowVectorPtr rowVector)
+      : id_(id), sortingKeys_(sortingKeys) {
+    rowVector_ = rowVector;
+    size_ = rowVector_->size();
+  }
+
+  uint32_t id() const override {
+    return id_;
+  }
+
+ private:
+  const std::vector<SpillSortKey>& sortingKeys() const override {
+    VELOX_CHECK(!closed_);
+    return sortingKeys_;
+  }
+
+  void nextBatch() override {
+    VELOX_CHECK(!closed_);
+    index_ = 0;
+    size_ = 0;
+    close();
+    rowVector_.reset();
+  }
+
+  void close() override {
+    VELOX_CHECK(!closed_);
+    SpillMergeStream::close();
+  }
+
+  uint32_t id_;
+  const std::vector<SpillSortKey> sortingKeys_;
+};
+
 // Test data for merging.
 struct TestData {
   // Globally sorted sequence of test keys.
diff --git a/velox/exec/tests/utils/OperatorTestBase.cpp b/velox/exec/tests/utils/OperatorTestBase.cpp
index 276cfc1735a..6951bdb206b 100644
--- a/velox/exec/tests/utils/OperatorTestBase.cpp
+++ b/velox/exec/tests/utils/OperatorTestBase.cpp
@@ -126,13 +126,13 @@ void OperatorTestBase::SetUp() {
   if (!isRegisteredVectorSerde()) {
     this->registerVectorSerde();
   }
-  if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kPresto)) {
+  if (!isRegisteredNamedVectorSerde("Presto")) {
     serializer::presto::PrestoVectorSerde::registerNamedVectorSerde();
   }
-  if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kCompactRow)) {
+  if (!isRegisteredNamedVectorSerde("CompactRow")) {
     serializer::CompactRowVectorSerde::registerNamedVectorSerde();
   }
-  if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kUnsafeRow)) {
+  if (!isRegisteredNamedVectorSerde("UnsafeRow")) {
     serializer::spark::UnsafeRowVectorSerde::registerNamedVectorSerde();
   }
   driverExecutor_ = std::make_unique<folly::CPUThreadPoolExecutor>(3);
@@ -153,6 +153,7 @@ void OperatorTestBase::SetUp() {
 void OperatorTestBase::TearDown() {
   waitForAllTasksToBeDeleted();
   stopPeriodicStatsReporter();
+  executor_.reset();
   // There might be lingering exchange source on executor even after all tasks
   // are deleted. This can cause memory leak because exchange source holds
   // reference to memory pool. We need to make sure they are properly cleaned.
@@ -243,7 +244,7 @@ core::TypedExprPtr OperatorTestBase::parseExpr(
     const std::string& text,
     RowTypePtr rowType,
     const parse::ParseOptions& options) {
-  auto untyped = parse::parseExpr(text, options);
+  auto untyped = parse::DuckSqlExpressionsParser(options).parseExpr(text);
   return core::Expressions::inferTypes(untyped, rowType, pool_.get());
 }
 
diff --git a/velox/exec/tests/utils/PlanBuilder.cpp b/velox/exec/tests/utils/PlanBuilder.cpp
index d48914fd168..32fbbaad617 100644
--- a/velox/exec/tests/utils/PlanBuilder.cpp
+++ b/velox/exec/tests/utils/PlanBuilder.cpp
@@ -46,7 +46,7 @@ core::TypedExprPtr parseExpr(
     const RowTypePtr& rowType,
     const parse::ParseOptions& options,
     memory::MemoryPool* pool) {
-  auto untyped = parse::parseExpr(text, options);
+  auto untyped = parse::DuckSqlExpressionsParser(options).parseExpr(text);
   return core::Expressions::inferTypes(untyped, rowType, pool);
 }
 
@@ -143,7 +143,8 @@ PlanBuilder& PlanBuilder::tpchTableScan(
 
   core::TypedExprPtr filterExpression;
   if (!filter.empty()) {
-    auto expression = parse::parseExpr(filter, options_);
+    auto expression =
+        parse::DuckSqlExpressionsParser(options_).parseExpr(filter);
     filterExpression =
         core::Expressions::inferTypes(expression, rowType, pool_);
   }
@@ -184,12 +185,65 @@ PlanBuilder& PlanBuilder::tpcdsTableScan(
   auto rowType = ROW(std::move(columnNames), std::move(outputTypes));
   return TableScanBuilder(*this)
       .outputType(rowType)
-      .tableHandle(std::make_shared<connector::tpcds::TpcdsTableHandle>(
-          std::string(connectorId), table, scaleFactor))
+      .tableHandle(
+          std::make_shared<connector::tpcds::TpcdsTableHandle>(
+              std::string(connectorId), table, scaleFactor))
       .assignments(assignmentsMap)
       .endTableScan();
 }
 
+namespace {
+
+// Analyzes 'expr' to determine if it can be expressed as a subfield filter.
+// Returns a pair of subfield and filter if so. Otherwise, throws.
+//
+// Supports all expressions supported by
+// exec::ExprToSubfieldFilterParser::leafCallToSubfieldFilter + negations and
+// disjunctions over same subfield.
+//
+//  Examples:
+//    a = 1
+//    a = 1 OR a > 10
+//    not (a = 1)
+std::pair<common::Subfield, std::unique_ptr<common::Filter>> toSubfieldFilter(
+    const core::TypedExprPtr& expr,
+    core::ExpressionEvaluator* evaluator) {
+  if (expr->isCallKind();
+      auto* call = expr->asUnchecked<core::CallTypedExpr>()) {
+    if (call->name() == "or") {
+      VELOX_CHECK_EQ(call->inputs().size(), 2);
+      auto left = toSubfieldFilter(call->inputs()[0], evaluator);
+      auto right = toSubfieldFilter(call->inputs()[1], evaluator);
+      VELOX_CHECK(left.first == right.first);
+      auto filter = exec::ExprToSubfieldFilterParser::makeOrFilter(
+          std::move(left.second), std::move(right.second));
+      VELOX_CHECK_NOT_NULL(filter);
+      return {std::move(left.first), std::move(filter)};
+    }
+
+    if (call->name() == "not") {
+      const auto& input = call->inputs()[0];
+      if (input->isCallKind();
+          auto* inner = input->asUnchecked<core::CallTypedExpr>()) {
+        if (auto result =
+                exec::ExprToSubfieldFilterParser::getInstance()
+                    ->leafCallToSubfieldFilter(*inner, evaluator, true)) {
+          return std::move(result).value();
+        }
+      }
+    } else {
+      if (auto result =
+              exec::ExprToSubfieldFilterParser::getInstance()
+                  ->leafCallToSubfieldFilter(*call, evaluator, false)) {
+        return std::move(result).value();
+      }
+    }
+  }
+  VELOX_UNSUPPORTED(
+      "Unsupported expression for range filter: {}", expr->toString());
+}
+} // namespace
+
 PlanBuilder::TableScanBuilder& PlanBuilder::TableScanBuilder::subfieldFilters(
     std::vector<std::string> subfieldFilters) {
   VELOX_CHECK(subfieldFiltersMap_.empty());
@@ -204,13 +258,13 @@ PlanBuilder::TableScanBuilder& PlanBuilder::TableScanBuilder::subfieldFilters(
   const RowTypePtr& parseType = dataColumns_ ? dataColumns_ : outputType_;
 
   for (const auto& filter : subfieldFilters) {
-    auto untypedExpr = parse::parseExpr(filter, planBuilder_.options_);
+    auto untypedExpr = parse::DuckSqlExpressionsParser(planBuilder_.options_)
+                           .parseExpr(filter);
 
     // Parse directly to subfieldFiltersMap_
     auto filterExpr = core::Expressions::inferTypes(
         untypedExpr, parseType, planBuilder_.pool_);
-    auto [subfield, subfieldFilter] =
-        exec::toSubfieldFilter(filterExpr, &evaluator);
+    auto [subfield, subfieldFilter] = toSubfieldFilter(filterExpr, &evaluator);
 
     auto it = columnAliases_.find(subfield.toString());
     if (it != columnAliases_.end()) {
@@ -239,11 +293,17 @@ PlanBuilder::TableScanBuilder::subfieldFiltersMap(
 PlanBuilder::TableScanBuilder& PlanBuilder::TableScanBuilder::remainingFilter(
     std::string remainingFilter) {
   if (!remainingFilter.empty()) {
-    remainingFilter_ = parse::parseExpr(remainingFilter, planBuilder_.options_);
+    remainingFilter_ = parse::DuckSqlExpressionsParser(planBuilder_.options_)
+                           .parseExpr(remainingFilter);
   }
   return *this;
 }
 
+PlanBuilder::TableScanBuilder& PlanBuilder::TableScanBuilder::sampleRate(
+    double sampleRate) {
+  sampleRate_ = sampleRate;
+  return *this;
+}
 namespace {
 void addConjunct(
     const core::TypedExprPtr& conjunct,
@@ -279,13 +339,24 @@ core::PlanNodePtr PlanBuilder::TableScanBuilder::build(core::PlanNodeId id) {
           {name,
            std::make_shared<HiveColumnHandle>(
                hiveColumnName,
-               HiveColumnHandle::ColumnType::kRegular,
+               FileColumnHandle::ColumnType::kRegular,
                type,
                type)});
     }
   }
 
-  const RowTypePtr& parseType = dataColumns_ ? dataColumns_ : outputType_;
+  RowTypePtr parseType = dataColumns_ ? dataColumns_ : outputType_;
+  if (!filterColumnHandles_.empty()) {
+    auto names = parseType->names();
+    auto types = parseType->children();
+    for (auto& handle : filterColumnHandles_) {
+      if (!parseType->containsChild(handle->name())) {
+        names.push_back(handle->name());
+        types.push_back(handle->hiveType());
+      }
+    }
+    parseType = ROW(std::move(names), std::move(types));
+  }
 
   core::TypedExprPtr filterNodeExpr;
 
@@ -315,10 +386,12 @@ core::PlanNodePtr PlanBuilder::TableScanBuilder::build(core::PlanNodeId id) {
     tableHandle_ = std::make_shared<HiveTableHandle>(
         connectorId_,
         tableName_,
-        true,
         std::move(subfieldFiltersMap_),
         remainingFilterExpr,
-        dataColumns_);
+        dataColumns_,
+        indexColumns_,
+        /*tableParameters=*/std::unordered_map<std::string, std::string>{},
+        filterColumnHandles_);
   }
   core::PlanNodePtr result = std::make_shared<core::TableScanNode>(
       id, outputType_, tableHandle_, assignments_);
@@ -354,8 +427,8 @@ core::PlanNodePtr PlanBuilder::TableWriterBuilder::build(core::PlanNodeId id) {
           std::make_shared<connector::hive::HiveColumnHandle>(
               column,
               isPartitionKey
-                  ? connector::hive::HiveColumnHandle::ColumnType::kPartitionKey
-                  : connector::hive::HiveColumnHandle::ColumnType::kRegular,
+                  ? connector::hive::FileColumnHandle::ColumnType::kPartitionKey
+                  : connector::hive::FileColumnHandle::ColumnType::kRegular,
               outputType->childAt(i),
               outputType->childAt(i)));
     }
@@ -393,8 +466,9 @@ core::PlanNodePtr PlanBuilder::TableWriterBuilder::build(core::PlanNodeId id) {
     std::vector<core::FieldAccessTypedExprPtr> groupingKeys;
     groupingKeys.reserve(partitionBy_.size());
     for (const auto& partitionBy : partitionBy_) {
-      groupingKeys.push_back(std::make_shared<core::FieldAccessTypedExpr>(
-          outputType->findChild(partitionBy), partitionBy));
+      groupingKeys.push_back(
+          std::make_shared<core::FieldAccessTypedExpr>(
+              outputType->findChild(partitionBy), partitionBy));
     }
     columnStatsSpec = core::ColumnStatsSpec(
         std::move(groupingKeys),
@@ -445,7 +519,7 @@ PlanBuilder& PlanBuilder::traceScan(
 
 PlanBuilder& PlanBuilder::exchange(
     const RowTypePtr& outputType,
-    VectorSerde::Kind serdeKind) {
+    std::string serdeKind) {
   VELOX_CHECK_NULL(planNode_, "Exchange must be the source node");
   planNode_ = std::make_shared<core::ExchangeNode>(
       nextPlanNodeId(), outputType, serdeKind);
@@ -464,7 +538,7 @@ parseOrderByClauses(
   std::vector<std::shared_ptr<const core::FieldAccessTypedExpr>> sortingKeys;
   std::vector<core::SortOrder> sortingOrders;
   for (const auto& key : keys) {
-    auto orderBy = parse::parseOrderByExpr(key);
+    auto orderBy = parse::DuckSqlExpressionsParser().parseOrderByExpr(key);
     auto typedExpr =
         core::Expressions::inferTypes(orderBy.expr, inputType, pool);
 
@@ -485,7 +559,7 @@ parseOrderByClauses(
 PlanBuilder& PlanBuilder::mergeExchange(
     const RowTypePtr& outputType,
     const std::vector<std::string>& keys,
-    VectorSerde::Kind serdeKind) {
+    std::string serdeKind) {
   VELOX_CHECK_NULL(planNode_, "MergeExchange must be the source node");
   auto [sortingKeys, sortingOrders] =
       parseOrderByClauses(keys, outputType, pool_);
@@ -556,7 +630,8 @@ PlanBuilder& PlanBuilder::project(const std::vector<std::string>& projections) {
   std::vector<std::shared_ptr<const core::IExpr>> expressions;
   expressions.reserve(projections.size());
   for (auto i = 0; i < projections.size(); ++i) {
-    expressions.push_back(parse::parseExpr(projections[i], options_));
+    expressions.push_back(
+        parse::DuckSqlExpressionsParser(options_).parseExpr(projections[i]));
   }
   return projectExpressions(expressions);
 }
@@ -578,7 +653,8 @@ PlanBuilder& PlanBuilder::parallelProject(
     typedExprs.reserve(group.size());
 
     for (const auto& expr : group) {
-      const auto typedExpr = inferTypes(parse::parseExpr(expr, options_));
+      const auto typedExpr =
+          inferTypes(parse::DuckSqlExpressionsParser(options_).parseExpr(expr));
       typedExprs.push_back(typedExpr);
 
       if (auto fieldExpr =
@@ -609,7 +685,8 @@ PlanBuilder& PlanBuilder::lazyDereference(
   std::vector<core::TypedExprPtr> expressions;
   std::vector<std::string> projectNames;
   for (auto i = 0; i < projections.size(); ++i) {
-    auto expr = inferTypes(parse::parseExpr(projections[i], options_));
+    auto expr = inferTypes(
+        parse::DuckSqlExpressionsParser(options_).parseExpr(projections[i]));
     expressions.push_back(expr);
     if (auto* fieldExpr =
             dynamic_cast<const core::FieldAccessExpr*>(expr.get())) {
@@ -645,15 +722,21 @@ PlanBuilder& PlanBuilder::optionalFilter(const std::string& optionalFilter) {
   return filter(optionalFilter);
 }
 
-PlanBuilder& PlanBuilder::filter(const std::string& filter) {
+PlanBuilder& PlanBuilder::filter(const core::ExprPtr& filterExpr) {
   VELOX_CHECK_NOT_NULL(planNode_, "Filter cannot be the source node");
-  auto expr = parseExpr(filter, planNode_->outputType(), options_, pool_);
-  planNode_ =
-      std::make_shared<core::FilterNode>(nextPlanNodeId(), expr, planNode_);
+  auto typedExpr =
+      core::Expressions::inferTypes(filterExpr, planNode_->outputType(), pool_);
+  planNode_ = std::make_shared<core::FilterNode>(
+      nextPlanNodeId(), typedExpr, planNode_);
   VELOX_CHECK(planNode_->supportsBarrier());
   return *this;
 }
 
+PlanBuilder& PlanBuilder::filter(const std::string& filterExpr) {
+  return filter(
+      parse::DuckSqlExpressionsParser(options_).parseExpr(filterExpr));
+}
+
 PlanBuilder& PlanBuilder::tableWrite(
     const std::string& outputDirectoryPath,
     const dwio::common::FileFormat fileFormat,
@@ -718,7 +801,8 @@ PlanBuilder& PlanBuilder::tableWrite(
     const common::CompressionKind compressionKind,
     const RowTypePtr& schema,
     const bool ensureFiles,
-    const connector::CommitStrategy commitStrategy) {
+    const connector::CommitStrategy commitStrategy,
+    std::shared_ptr<core::InsertTableHandle> insertTableHandle) {
   return TableWriterBuilder(*this)
       .outputDirectoryPath(outputDirectoryPath)
       .outputFileName(outputFileName)
@@ -735,6 +819,7 @@ PlanBuilder& PlanBuilder::tableWrite(
       .compressionKind(compressionKind)
       .ensureFiles(ensureFiles)
       .commitStrategy(commitStrategy)
+      .insertHandle(insertTableHandle)
       .endTableWriter();
 }
 
@@ -754,51 +839,56 @@ const core::TableWriteNodePtr findTableWrite(const core::PlanNodePtr planNode) {
 }
 } // namespace
 
-PlanBuilder& PlanBuilder::tableWriteMerge() {
+PlanBuilder& PlanBuilder::tableWriteMerge(core::AggregationNode::Step step) {
   VELOX_CHECK_NOT_NULL(planNode_, "TableWriteMerge cannot be the source node");
   auto writer = findTableWrite(planNode_);
   VELOX_CHECK_NOT_NULL(
-      writer, "TableWriteMerge can only be added after TableWrite node");
+      writer, "TableWriteMerge requires a TableWrite node in the plan tree");
 
   std::optional<core::ColumnStatsSpec> columnStatsSpec;
   if (writer->hasColumnStatsSpec()) {
-    const auto writerSpec = writer->columnStatsSpec().value();
-    VELOX_CHECK_EQ(
-        writerSpec.aggregationStep, core::AggregationNode::Step::kPartial);
-    std::vector<std::vector<TypePtr>> aggregateRawInputs;
-    const auto numAggregates = writerSpec.aggregates.size();
-    aggregateRawInputs.reserve(numAggregates);
-    for (const auto& aggregate : writerSpec.aggregates) {
-      aggregateRawInputs.push_back(aggregate.rawInputTypes);
-    }
+    const auto& writerSpec = writer->columnStatsSpec().value();
     const auto& inputType = planNode_->outputType();
+    const auto numAggregates = writerSpec.aggregates.size();
 
     std::vector<std::string> aggregateNames;
     aggregateNames.reserve(numAggregates);
     std::vector<core::AggregationNode::Aggregate> aggregates;
     aggregates.reserve(numAggregates);
-    for (int i = 0; i < numAggregates; ++i) {
-      core::AggregationNode::Aggregate aggregate = writerSpec.aggregates[i];
+    for (size_t i = 0; i < numAggregates; ++i) {
+      auto aggregate = writerSpec.aggregates[i];
       aggregate.call = std::make_shared<core::CallTypedExpr>(
           aggregate.call->type(),
           aggregate.call->name(),
           field(inputType, writerSpec.aggregateNames[i]));
       aggregates.push_back(std::move(aggregate));
-      aggregateNames.push_back(fmt::format("a{}", i));
+      aggregateNames.push_back(writerSpec.aggregateNames[i]);
     }
     columnStatsSpec = core::ColumnStatsSpec{
         writerSpec.groupingKeys,
-        core::AggregationNode::Step::kIntermediate,
+        step,
         std::move(aggregateNames),
         std::move(aggregates)};
   }
 
+  auto outputType = TableWriteTraits::outputType(columnStatsSpec);
   planNode_ = std::make_shared<core::TableWriteMergeNode>(
       nextPlanNodeId(),
-      TableWriteTraits::outputType(columnStatsSpec),
-      columnStatsSpec,
+      std::move(outputType),
+      std::move(columnStatsSpec),
+      planNode_);
+  return *this;
+}
+
+PlanBuilder& PlanBuilder::tableWriteMerge(
+    core::ColumnStatsSpec columnStatsSpec) {
+  VELOX_CHECK_NOT_NULL(planNode_, "TableWriteMerge cannot be the source node");
+  auto outputType = TableWriteTraits::outputType(columnStatsSpec);
+  planNode_ = std::make_shared<core::TableWriteMergeNode>(
+      nextPlanNodeId(),
+      std::move(outputType),
+      std::move(columnStatsSpec),
       planNode_);
-  VELOX_CHECK(!planNode_->supportsBarrier());
   return *this;
 }
 
@@ -850,6 +940,7 @@ core::PlanNodePtr PlanBuilder::createIntermediateOrFinalAggregation(
       partialAggNode->aggregateNames(),
       aggregates,
       partialAggNode->ignoreNullKeys(),
+      partialAggNode->noGroupsSpanBatches(),
       planNode_);
   VELOX_CHECK_EQ(
       aggregationNode->supportsBarrier(), aggregationNode->isPreGrouped());
@@ -943,12 +1034,17 @@ PlanBuilder::AggregatesAndNames PlanBuilder::createAggregateExpressionsAndNames(
       resolver.setRawInputTypes(rawInputTypes[i]);
     }
 
-    auto untypedExpr = duckdb::parseAggregateExpr(aggregate, options);
+    auto aggCall = duckdb::parseAggregateExpr(aggregate, options);
+
+    // Build a plain CallExpr for type resolution (AggregateCallExpr carries
+    // options that CallTypedExpr doesn't need).
+    auto plainCall = std::make_shared<core::CallExpr>(
+        aggCall->name(), aggCall->inputs(), std::nullopt);
 
     core::AggregationNode::Aggregate agg;
 
     agg.call = std::dynamic_pointer_cast<const core::CallTypedExpr>(
-        inferTypes(untypedExpr.expr));
+        inferTypes(plainCall));
 
     if (step == core::AggregationNode::Step::kPartial ||
         step == core::AggregationNode::Step::kSingle) {
@@ -959,10 +1055,10 @@ PlanBuilder::AggregatesAndNames PlanBuilder::createAggregateExpressionsAndNames(
       agg.rawInputTypes = rawInputTypes[i];
     }
 
-    if (untypedExpr.maskExpr != nullptr) {
+    if (aggCall->filter() != nullptr) {
       auto maskExpr =
           std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(
-              inferTypes(untypedExpr.maskExpr));
+              inferTypes(aggCall->filter()));
       VELOX_CHECK_NOT_NULL(
           maskExpr,
           "FILTER clause must use a column name, not an expression: {}",
@@ -977,9 +1073,9 @@ PlanBuilder::AggregatesAndNames PlanBuilder::createAggregateExpressionsAndNames(
       agg.mask = field(masks[i]);
     }
 
-    agg.distinct = untypedExpr.distinct;
+    agg.distinct = aggCall->isDistinct();
 
-    if (!untypedExpr.orderBy.empty()) {
+    if (!aggCall->orderBy().empty()) {
       auto* entry = exec::getAggregateFunctionEntry(agg.call->name());
       const auto& metadata = entry->metadata;
       if (metadata.orderSensitive) {
@@ -989,25 +1085,25 @@ PlanBuilder::AggregatesAndNames PlanBuilder::createAggregateExpressionsAndNames(
             "into partial and final: {}.",
             aggregate);
       }
-    }
 
-    for (const auto& orderBy : untypedExpr.orderBy) {
-      auto sortingKey =
-          std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(
-              inferTypes(orderBy.expr));
-      VELOX_CHECK_NOT_NULL(
-          sortingKey,
-          "ORDER BY clause must use a column name, not an expression: {}",
-          aggregate);
+      for (const auto& orderBy : aggCall->orderBy()) {
+        auto sortingKey =
+            std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(
+                inferTypes(orderBy.expr));
+        VELOX_CHECK_NOT_NULL(
+            sortingKey,
+            "ORDER BY clause must use a column name, not an expression: {}",
+            aggregate);
 
-      agg.sortingKeys.push_back(sortingKey);
-      agg.sortingOrders.emplace_back(orderBy.ascending, orderBy.nullsFirst);
+        agg.sortingKeys.push_back(sortingKey);
+        agg.sortingOrders.emplace_back(orderBy.ascending, orderBy.nullsFirst);
+      }
     }
 
     aggs.emplace_back(agg);
 
-    if (untypedExpr.expr->alias().has_value()) {
-      names.push_back(untypedExpr.expr->alias().value());
+    if (aggCall->alias().has_value()) {
+      names.push_back(aggCall->alias().value());
     } else {
       names.push_back(fmt::format("a{}", i));
     }
@@ -1055,6 +1151,7 @@ PlanBuilder& PlanBuilder::aggregation(
       globalGroupingSets,
       groupId,
       ignoreNullKeys,
+      /*noGroupsSpanBatches=*/false,
       planNode_);
   VELOX_CHECK_EQ(
       aggregationNode->supportsBarrier(), aggregationNode->isPreGrouped());
@@ -1067,7 +1164,8 @@ PlanBuilder& PlanBuilder::streamingAggregation(
     const std::vector<std::string>& aggregates,
     const std::vector<std::string>& masks,
     core::AggregationNode::Step step,
-    bool ignoreNullKeys) {
+    bool ignoreNullKeys,
+    bool noGroupsSpanBatches) {
   auto aggregatesAndNames =
       createAggregateExpressionsAndNames(aggregates, masks, step);
   auto aggregationNode = std::make_shared<core::AggregationNode>(
@@ -1078,6 +1176,7 @@ PlanBuilder& PlanBuilder::streamingAggregation(
       aggregatesAndNames.names,
       aggregatesAndNames.aggregates,
       ignoreNullKeys,
+      noGroupsSpanBatches,
       planNode_);
   VELOX_CHECK_EQ(
       aggregationNode->supportsBarrier(), aggregationNode->isPreGrouped());
@@ -1093,7 +1192,8 @@ PlanBuilder& PlanBuilder::groupId(
   std::vector<core::GroupIdNode::GroupingKeyInfo> groupingKeyInfos;
   groupingKeyInfos.reserve(groupingKeys.size());
   for (const auto& groupingKey : groupingKeys) {
-    auto untypedExpr = parse::parseExpr(groupingKey, options_);
+    auto untypedExpr =
+        parse::DuckSqlExpressionsParser(options_).parseExpr(groupingKey);
     const auto* fieldAccessExpr =
         dynamic_cast<const core::FieldAccessExpr*>(untypedExpr.get());
     VELOX_USER_CHECK(
@@ -1162,7 +1262,9 @@ PlanBuilder& PlanBuilder::expand(
     std::vector<core::TypedExprPtr> projectExpr;
     VELOX_CHECK_EQ(numColumns, projections[i].size());
     for (auto j = 0; j < numColumns; j++) {
-      auto untypedExpression = parse::parseExpr(projections[i][j], options_);
+      auto untypedExpression =
+          parse::DuckSqlExpressionsParser(options_).parseExpr(
+              projections[i][j]);
       auto typedExpression = inferTypes(untypedExpression);
 
       if (i == 0) {
@@ -1186,8 +1288,9 @@ PlanBuilder& PlanBuilder::expand(
               dynamic_cast<const core::ConstantExpr*>(untypedExpression.get());
           VELOX_CHECK_NOT_NULL(constantExpr);
           VELOX_CHECK(constantExpr->value().isNull());
-          projectExpr.push_back(std::make_shared<core::ConstantTypedExpr>(
-              expectedType, variant::null(expectedType->kind())));
+          projectExpr.push_back(
+              std::make_shared<core::ConstantTypedExpr>(
+                  expectedType, variant::null(expectedType->kind())));
         }
       }
     }
@@ -1354,7 +1457,7 @@ PlanBuilder& PlanBuilder::partitionedOutput(
     const std::vector<std::string>& keys,
     int numPartitions,
     const std::vector<std::string>& outputLayout,
-    VectorSerde::Kind serdeKind) {
+    std::string serdeKind) {
   return partitionedOutput(keys, numPartitions, false, outputLayout, serdeKind);
 }
 
@@ -1363,7 +1466,7 @@ PlanBuilder& PlanBuilder::partitionedOutput(
     int numPartitions,
     bool replicateNullsAndAny,
     const std::vector<std::string>& outputLayout,
-    VectorSerde::Kind serdeKind) {
+    std::string serdeKind) {
   VELOX_CHECK_NOT_NULL(
       planNode_, "PartitionedOutput cannot be the source node");
 
@@ -1383,7 +1486,7 @@ PlanBuilder& PlanBuilder::partitionedOutput(
     bool replicateNullsAndAny,
     core::PartitionFunctionSpecPtr partitionFunctionSpec,
     const std::vector<std::string>& outputLayout,
-    VectorSerde::Kind serdeKind) {
+    std::string serdeKind) {
   VELOX_CHECK_NOT_NULL(
       planNode_, "PartitionedOutput cannot be the source node");
   auto outputType = outputLayout.empty()
@@ -1405,7 +1508,7 @@ PlanBuilder& PlanBuilder::partitionedOutput(
 
 PlanBuilder& PlanBuilder::partitionedOutputBroadcast(
     const std::vector<std::string>& outputLayout,
-    VectorSerde::Kind serdeKind) {
+    std::string serdeKind) {
   VELOX_CHECK_NOT_NULL(
       planNode_, "PartitionedOutput cannot be the source node");
   auto outputType = outputLayout.empty()
@@ -1419,7 +1522,7 @@ PlanBuilder& PlanBuilder::partitionedOutputBroadcast(
 
 PlanBuilder& PlanBuilder::partitionedOutputArbitrary(
     const std::vector<std::string>& outputLayout,
-    VectorSerde::Kind serdeKind) {
+    std::string serdeKind) {
   VELOX_CHECK_NOT_NULL(
       planNode_, "PartitionedOutput cannot be the source node");
   auto outputType = outputLayout.empty()
@@ -1456,6 +1559,10 @@ PlanBuilder& PlanBuilder::localPartition(const std::vector<std::string>& keys) {
   return *this;
 }
 
+PlanBuilder& PlanBuilder::localGather() {
+  return localPartition(std::vector<std::string>{});
+}
+
 PlanBuilder& PlanBuilder::scaleWriterlocalPartition(
     const std::vector<std::string>& keys) {
   std::vector<column_index_t> keyIndices;
@@ -1622,7 +1729,8 @@ PlanBuilder& PlanBuilder::hashJoin(
     const std::string& filter,
     const std::vector<std::string>& outputLayout,
     core::JoinType joinType,
-    bool nullAware) {
+    bool nullAware,
+    bool nullAsValue) {
   VELOX_CHECK_NOT_NULL(planNode_, "HashJoin cannot be the source node");
   VELOX_CHECK_EQ(leftKeys.size(), rightKeys.size());
 
@@ -1663,7 +1771,9 @@ PlanBuilder& PlanBuilder::hashJoin(
       std::move(filterExpr),
       std::move(planNode_),
       build,
-      outputType);
+      outputType,
+      /*useHashTableCache=*/false,
+      nullAsValue);
   VELOX_CHECK(!planNode_->supportsBarrier());
   return *this;
 }
@@ -1741,20 +1851,35 @@ PlanBuilder& PlanBuilder::nestedLoopJoin(
 PlanBuilder& PlanBuilder::spatialJoin(
     const core::PlanNodePtr& right,
     const std::string& joinCondition,
+    const std::string& probeGeometry,
+    const std::string& buildGeometry,
+    const std::optional<std::string>& radius,
     const std::vector<std::string>& outputLayout,
     core::JoinType joinType) {
   VELOX_CHECK_NOT_NULL(planNode_, "SpatialJoin cannot be the source node");
-  auto resultType = concat(planNode_->outputType(), right->outputType());
+  auto probeType = planNode_->outputType();
+  auto buildType = right->outputType();
+  auto resultType = concat(probeType, buildType);
   auto outputType = extract(resultType, outputLayout);
 
   VELOX_CHECK(!joinCondition.empty(), "SpatialJoin condition cannot be empty");
   core::TypedExprPtr joinConditionExpr =
       parseExpr(joinCondition, resultType, options_, pool_);
 
+  auto probeGeometryField = field(probeType, probeGeometry);
+  auto buildGeometryField = field(buildType, buildGeometry);
+  std::optional<core::FieldAccessTypedExprPtr> radiusField;
+  if (radius.has_value()) {
+    radiusField = field(buildType, radius.value());
+  }
+
   planNode_ = std::make_shared<core::SpatialJoinNode>(
       nextPlanNodeId(),
       joinType,
       std::move(joinConditionExpr),
+      std::move(probeGeometryField),
+      std::move(buildGeometryField),
+      std::move(radiusField),
       std::move(planNode_),
       right,
       outputType);
@@ -1965,12 +2090,13 @@ PlanBuilder& PlanBuilder::indexLookupJoin(
     const std::vector<std::string>& rightKeys,
     const core::TableScanNodePtr& right,
     const std::vector<std::string>& joinConditions,
-    bool includeMatchColumn,
+    const std::string& filter,
+    bool hasMarker,
     const std::vector<std::string>& outputLayout,
     core::JoinType joinType) {
   VELOX_CHECK_NOT_NULL(planNode_, "indexLookupJoin cannot be the source node");
   auto inputType = concat(planNode_->outputType(), right->outputType());
-  if (includeMatchColumn) {
+  if (hasMarker) {
     auto names = inputType->names();
     names.push_back(outputLayout.back());
     auto types = inputType->children();
@@ -1988,13 +2114,20 @@ PlanBuilder& PlanBuilder::indexLookupJoin(
         parseIndexJoinCondition(joinCondition, inputType, pool_));
   }
 
+  // Parse filter expression if provided
+  core::TypedExprPtr filterExpr;
+  if (!filter.empty()) {
+    filterExpr = parseExpr(filter, inputType, options_, pool_);
+  }
+
   planNode_ = std::make_shared<core::IndexLookupJoinNode>(
       nextPlanNodeId(),
       joinType,
       std::move(leftKeyFields),
       std::move(rightKeyFields),
       std::move(joinConditionPtrs),
-      includeMatchColumn,
+      filterExpr,
+      hasMarker,
       std::move(planNode_),
       right,
       std::move(outputType));
@@ -2006,7 +2139,7 @@ PlanBuilder& PlanBuilder::unnest(
     const std::vector<std::string>& replicateColumns,
     const std::vector<std::string>& unnestColumns,
     const std::optional<std::string>& ordinalColumn,
-    const std::optional<std::string>& emptyUnnestValueName) {
+    const std::optional<std::string>& markerName) {
   VELOX_CHECK_NOT_NULL(planNode_, "Unnest cannot be the source node");
   std::vector<std::shared_ptr<const core::FieldAccessTypedExpr>>
       replicateFields;
@@ -2042,7 +2175,7 @@ PlanBuilder& PlanBuilder::unnest(
       unnestFields,
       unnestNames,
       ordinalColumn,
-      emptyUnnestValueName,
+      markerName,
       planNode_);
   VELOX_CHECK(planNode_->supportsBarrier());
   return *this;
@@ -2050,24 +2183,21 @@ PlanBuilder& PlanBuilder::unnest(
 
 namespace {
 std::string throwWindowFunctionDoesntExist(const std::string& name) {
-  std::stringstream error;
-  error << "Window function doesn't exist: " << name << ".";
   if (exec::windowFunctions().empty()) {
-    error << " Registry of window functions is empty. "
-             "Make sure to register some window functions.";
+    VELOX_USER_FAIL(
+        "Registry of window functions is empty. Make sure to register some window functions.");
   }
-  VELOX_USER_FAIL(error.str());
+  VELOX_USER_FAIL("Window function doesn't exist: {}.", name);
 }
 
 std::string throwWindowFunctionSignatureNotSupported(
     const std::string& name,
     const std::vector<TypePtr>& types,
     const std::vector<FunctionSignaturePtr>& signatures) {
-  std::stringstream error;
-  error << "Window function signature is not supported: "
-        << toString(name, types)
-        << ". Supported signatures: " << toString(signatures) << ".";
-  VELOX_USER_FAIL(error.str());
+  VELOX_USER_FAIL(
+      "Window function signature is not supported: {}. Supported signatures: {}.",
+      toString(name, types),
+      toString(signatures));
 }
 
 TypePtr resolveWindowType(
@@ -2076,7 +2206,8 @@ TypePtr resolveWindowType(
     bool nullOnFailure) {
   if (auto signatures = exec::getWindowFunctionSignatures(windowFunctionName)) {
     for (const auto& signature : signatures.value()) {
-      exec::SignatureBinder binder(*signature, inputTypes);
+      exec::SignatureBinder binder(
+          *signature, inputTypes, TypeCoercer::defaults());
       if (binder.tryBind()) {
         return binder.tryResolveType(signature->returnType());
       }
@@ -2129,48 +2260,51 @@ class WindowTypeResolver {
 };
 
 const core::WindowNode::Frame createWindowFrame(
-    const duckdb::IExprWindowFrame& windowFrame,
+    const core::WindowCallExpr& windowCall,
     const TypePtr& inputRow,
     memory::MemoryPool* pool) {
-  core::WindowNode::Frame frame;
-  frame.type = (windowFrame.type == duckdb::WindowType::kRows)
-      ? core::WindowNode::WindowType::kRows
-      : core::WindowNode::WindowType::kRange;
-
-  auto boundTypeConversion =
-      [](duckdb::BoundType boundType) -> core::WindowNode::BoundType {
+  auto boundTypeConversion = [](core::WindowCallExpr::BoundType boundType)
+      -> core::WindowNode::BoundType {
     switch (boundType) {
-      case duckdb::BoundType::kCurrentRow:
+      case core::WindowCallExpr::BoundType::kCurrentRow:
         return core::WindowNode::BoundType::kCurrentRow;
-      case duckdb::BoundType::kFollowing:
+      case core::WindowCallExpr::BoundType::kFollowing:
         return core::WindowNode::BoundType::kFollowing;
-      case duckdb::BoundType::kPreceding:
+      case core::WindowCallExpr::BoundType::kPreceding:
         return core::WindowNode::BoundType::kPreceding;
-      case duckdb::BoundType::kUnboundedFollowing:
+      case core::WindowCallExpr::BoundType::kUnboundedFollowing:
         return core::WindowNode::BoundType::kUnboundedFollowing;
-      case duckdb::BoundType::kUnboundedPreceding:
+      case core::WindowCallExpr::BoundType::kUnboundedPreceding:
         return core::WindowNode::BoundType::kUnboundedPreceding;
     }
     VELOX_UNREACHABLE();
   };
-  frame.startType = boundTypeConversion(windowFrame.startType);
-  frame.startValue = windowFrame.startValue
-      ? core::Expressions::inferTypes(windowFrame.startValue, inputRow, pool)
+
+  core::WindowNode::Frame frame;
+  const auto& windowFrame = windowCall.frame();
+  VELOX_CHECK(windowFrame.has_value(), "Window frame must be specified");
+
+  frame.type = (windowFrame->type == core::WindowCallExpr::WindowType::kRows)
+      ? core::WindowNode::WindowType::kRows
+      : core::WindowNode::WindowType::kRange;
+  frame.startType = boundTypeConversion(windowFrame->startType);
+  frame.startValue = windowFrame->startValue
+      ? core::Expressions::inferTypes(windowFrame->startValue, inputRow, pool)
       : nullptr;
-  frame.endType = boundTypeConversion(windowFrame.endType);
-  frame.endValue = windowFrame.endValue
-      ? core::Expressions::inferTypes(windowFrame.endValue, inputRow, pool)
+  frame.endType = boundTypeConversion(windowFrame->endType);
+  frame.endValue = windowFrame->endValue
+      ? core::Expressions::inferTypes(windowFrame->endValue, inputRow, pool)
       : nullptr;
   return frame;
 }
 
 std::vector<core::FieldAccessTypedExprPtr> parsePartitionKeys(
-    const duckdb::IExprWindowFunction& windowExpr,
+    const core::WindowCallExpr& windowCall,
     const std::string& windowString,
     const TypePtr& inputRow,
     memory::MemoryPool* pool) {
   std::vector<core::FieldAccessTypedExprPtr> partitionKeys;
-  for (const auto& partitionKey : windowExpr.partitionBy) {
+  for (const auto& partitionKey : windowCall.partitionKeys()) {
     auto typedExpr =
         core::Expressions::inferTypes(partitionKey, inputRow, pool);
     auto typedPartitionKey =
@@ -2188,14 +2322,14 @@ std::pair<
     std::vector<core::FieldAccessTypedExprPtr>,
     std::vector<core::SortOrder>>
 parseOrderByKeys(
-    const duckdb::IExprWindowFunction& windowExpr,
+    const core::WindowCallExpr& windowCall,
     const std::string& windowString,
     const TypePtr& inputRow,
     memory::MemoryPool* pool) {
   std::vector<core::FieldAccessTypedExprPtr> sortingKeys;
   std::vector<core::SortOrder> sortingOrders;
 
-  for (const auto& orderBy : windowExpr.orderBy) {
+  for (const auto& orderBy : windowCall.orderByKeys()) {
     auto typedExpr =
         core::Expressions::inferTypes(orderBy.expr, inputRow, pool);
     auto sortingKey =
@@ -2259,33 +2393,34 @@ PlanBuilder& PlanBuilder::window(
 
   auto errorOnMismatch = [&](const std::string& windowString,
                              const std::string& mismatchTypeString) -> void {
-    std::stringstream error;
-    error << "Window function invocations " << windowString << " and "
-          << windowFunctions[0] << " do not match " << mismatchTypeString
-          << " clauses.";
-    VELOX_USER_FAIL(error.str());
+    VELOX_USER_FAIL(
+        "Window function invocations {} and {} do not match {} clauses.",
+        windowString,
+        windowFunctions[0],
+        mismatchTypeString);
   };
 
   WindowTypeResolver windowResolver;
   facebook::velox::duckdb::ParseOptions options;
   options.parseIntegerAsBigint = options_.parseIntegerAsBigint;
   for (const auto& windowString : windowFunctions) {
-    const auto& windowExpr = duckdb::parseWindowExpr(windowString, options);
+    auto windowExprPtr = duckdb::parseWindowExpr(windowString, options);
+    auto* windowCall = windowExprPtr->as<core::WindowCallExpr>();
     // All window function SQL strings in the list are expected to have the same
     // PARTITION BY and ORDER BY clauses. Validate this assumption.
     if (first) {
       partitionKeys =
-          parsePartitionKeys(windowExpr, windowString, inputType, pool_);
+          parsePartitionKeys(*windowCall, windowString, inputType, pool_);
       auto sortPair =
-          parseOrderByKeys(windowExpr, windowString, inputType, pool_);
+          parseOrderByKeys(*windowCall, windowString, inputType, pool_);
       sortingKeys = sortPair.first;
       sortingOrders = sortPair.second;
       first = false;
     } else {
       auto latestPartitionKeys =
-          parsePartitionKeys(windowExpr, windowString, inputType, pool_);
+          parsePartitionKeys(*windowCall, windowString, inputType, pool_);
       auto [latestSortingKeys, latestSortingOrders] =
-          parseOrderByKeys(windowExpr, windowString, inputType, pool_);
+          parseOrderByKeys(*windowCall, windowString, inputType, pool_);
 
       if (!equalFieldAccessTypedExprPtrList(
               partitionKeys, latestPartitionKeys)) {
@@ -2301,15 +2436,19 @@ PlanBuilder& PlanBuilder::window(
       }
     }
 
-    auto windowCall = std::dynamic_pointer_cast<const core::CallTypedExpr>(
+    // Build a plain CallExpr for type resolution (WindowCallExpr carries
+    // partition/order metadata that CallTypedExpr doesn't need).
+    auto plainCall = std::make_shared<core::CallExpr>(
+        windowCall->name(), windowCall->inputs(), std::nullopt);
+    auto typedCall = std::dynamic_pointer_cast<const core::CallTypedExpr>(
         core::Expressions::inferTypes(
-            windowExpr.functionCall, planNode_->outputType(), pool_));
+            plainCall, planNode_->outputType(), pool_));
     windowNodeFunctions.push_back(
-        {std::move(windowCall),
-         createWindowFrame(windowExpr.frame, planNode_->outputType(), pool_),
-         windowExpr.ignoreNulls});
-    if (windowExpr.functionCall->alias().has_value()) {
-      windowNames.push_back(windowExpr.functionCall->alias().value());
+        {std::move(typedCall),
+         createWindowFrame(*windowCall, planNode_->outputType(), pool_),
+         windowCall->isIgnoreNulls()});
+    if (windowExprPtr->alias().has_value()) {
+      windowNames.push_back(windowExprPtr->alias().value());
     } else {
       windowNames.push_back(fmt::format("w{}", i++));
     }
@@ -2404,6 +2543,49 @@ PlanBuilder& PlanBuilder::markDistinct(
   return *this;
 }
 
+PlanBuilder& PlanBuilder::enforceDistinct(
+    const std::vector<std::string>& distinctKeys,
+    std::string errorMessage,
+    const std::vector<std::string>& preGroupedKeys) {
+  VELOX_CHECK_NOT_NULL(planNode_, "EnforceDistinct cannot be the source node");
+  planNode_ = std::make_shared<core::EnforceDistinctNode>(
+      nextPlanNodeId(),
+      fields(planNode_->outputType(), distinctKeys),
+      fields(planNode_->outputType(), preGroupedKeys),
+      std::move(errorMessage),
+      planNode_);
+  VELOX_CHECK(!planNode_->supportsBarrier());
+  return *this;
+}
+
+PlanBuilder& PlanBuilder::streamingEnforceDistinct(
+    const std::vector<std::string>& distinctKeys,
+    std::string errorMessage) {
+  return enforceDistinct(distinctKeys, std::move(errorMessage), distinctKeys);
+}
+
+PlanBuilder& PlanBuilder::markSorted(
+    const std::string& markerKey,
+    const std::vector<std::string>& sortingKeys,
+    const std::vector<core::SortOrder>& sortingOrders) {
+  VELOX_CHECK_NOT_NULL(planNode_, "MarkSorted cannot be the source node");
+  VELOX_CHECK_EQ(sortingKeys.size(), sortingOrders.size());
+
+  std::vector<core::FieldAccessTypedExprPtr> keyExprs;
+  for (const auto& key : sortingKeys) {
+    keyExprs.push_back(field(planNode_->outputType(), key));
+  }
+
+  planNode_ = core::MarkSortedNode::Builder()
+                  .id(nextPlanNodeId())
+                  .markerName(markerKey)
+                  .sortingKeys(keyExprs)
+                  .sortingOrders(sortingOrders)
+                  .source(planNode_)
+                  .build();
+  return *this;
+}
+
 core::PlanNodeId PlanBuilder::nextPlanNodeId() {
   return planNodeIdGenerator_->next();
 }
@@ -2479,7 +2661,9 @@ std::vector<core::TypedExprPtr> PlanBuilder::exprs(
   std::vector<core::TypedExprPtr> typedExpressions;
   for (auto& expr : expressions) {
     auto typedExpression = core::Expressions::inferTypes(
-        parse::parseExpr(expr, options_), inputType, pool_);
+        parse::DuckSqlExpressionsParser(options_).parseExpr(expr),
+        inputType,
+        pool_);
 
     if (dynamic_cast<const core::FieldAccessTypedExpr*>(
             typedExpression.get())) {
@@ -2508,7 +2692,7 @@ core::PlanNodePtr PlanBuilder::IndexLookupJoinBuilder::build(
       planBuilder_.planNode_, "IndexLookupJoin cannot be the source node");
   auto inputType =
       concat(planBuilder_.planNode_->outputType(), indexSource_->outputType());
-  if (includeMatchColumn_) {
+  if (hasMarker_) {
     auto names = inputType->names();
     names.push_back(outputLayout_.back());
     auto types = inputType->children();
@@ -2524,8 +2708,16 @@ core::PlanNodePtr PlanBuilder::IndexLookupJoinBuilder::build(
   std::vector<core::IndexLookupConditionPtr> joinConditionPtrs{};
   joinConditionPtrs.reserve(joinConditions_.size());
   for (const auto& joinCondition : joinConditions_) {
-    joinConditionPtrs.push_back(PlanBuilder::parseIndexJoinCondition(
-        joinCondition, inputType, planBuilder_.pool_));
+    joinConditionPtrs.push_back(
+        PlanBuilder::parseIndexJoinCondition(
+            joinCondition, inputType, planBuilder_.pool_));
+  }
+
+  // Parse filter expression if provided
+  core::TypedExprPtr filterExpr;
+  if (!filter_.empty()) {
+    filterExpr = parseExpr(
+        filter_, inputType, planBuilder_.options_, planBuilder_.pool_);
   }
 
   return std::make_shared<core::IndexLookupJoinNode>(
@@ -2534,7 +2726,8 @@ core::PlanNodePtr PlanBuilder::IndexLookupJoinBuilder::build(
       std::move(leftKeyFields),
       std::move(rightKeyFields),
       std::move(joinConditionPtrs),
-      includeMatchColumn_,
+      filterExpr,
+      hasMarker_,
       std::move(planBuilder_.planNode_),
       indexSource_,
       std::move(outputType));
diff --git a/velox/exec/tests/utils/PlanBuilder.h b/velox/exec/tests/utils/PlanBuilder.h
index 96b65390a86..f8896cdcbca 100644
--- a/velox/exec/tests/utils/PlanBuilder.h
+++ b/velox/exec/tests/utils/PlanBuilder.h
@@ -35,9 +35,16 @@ enum class Table : uint8_t;
 
 namespace facebook::velox::exec::test {
 
+struct AggregationConfig {
+  std::vector<std::string> groupingKeys;
+  std::vector<std::string> aggregates;
+};
+
 struct PushdownConfig {
   common::SubfieldFilters subfieldFiltersMap;
   std::string remainingFilter;
+  // Aggregation pushdown configuration
+  std::optional<AggregationConfig> aggregationConfig;
 };
 
 /// A builder class with fluent API for building query plans. Plans are built
@@ -289,6 +296,8 @@ class PlanBuilder {
     /// AND'ed with all the subfieldFilters.
     TableScanBuilder& remainingFilter(std::string remainingFilter);
 
+    TableScanBuilder& sampleRate(double sampleRate);
+
     /// @param dataColumns can be different from 'outputType' for the purposes
     /// of testing queries using missing columns. It is used, if specified, for
     /// parseExpr call and as 'dataColumns' for the TableHandle. You supply more
@@ -316,6 +325,12 @@ class PlanBuilder {
       return *this;
     }
 
+    TableScanBuilder& filterColumnHandles(
+        std::vector<connector::hive::HiveColumnHandlePtr> filterColumnHandles) {
+      filterColumnHandles_ = std::move(filterColumnHandles);
+      return *this;
+    }
+
     /// @param assignments Optional ColumnHandles.
     /// outputType names should match the keys in the 'assignments' map. The
     /// 'assignments' map may contain more columns than 'outputType' if some
@@ -325,6 +340,13 @@ class PlanBuilder {
       return *this;
     }
 
+    /// @param indexColumns Names of columns that form the index key for the
+    /// table. When set, enables index-based lookups.
+    TableScanBuilder& indexColumns(std::vector<std::string> indexColumns) {
+      indexColumns_ = std::move(indexColumns);
+      return *this;
+    }
+
     /// Stop the TableScanBuilder.
     PlanBuilder& endTableScan() {
       planBuilder_.planNode_ = build(planBuilder_.nextPlanNodeId());
@@ -340,7 +362,10 @@ class PlanBuilder {
     std::string connectorId_{kHiveDefaultConnectorId};
     RowTypePtr outputType_;
     core::ExprPtr remainingFilter_;
+    double sampleRate_{1.0};
     RowTypePtr dataColumns_;
+    std::vector<std::string> indexColumns_;
+    std::vector<connector::hive::HiveColumnHandlePtr> filterColumnHandles_;
     std::unordered_map<std::string, std::string> columnAliases_;
     connector::ConnectorTableHandlePtr tableHandle_;
     connector::ColumnHandleMap assignments_;
@@ -395,8 +420,8 @@ class PlanBuilder {
       return *this;
     }
 
-    IndexLookupJoinBuilder& includeMatchColumn(bool includeMatchColumn) {
-      includeMatchColumn_ = includeMatchColumn;
+    IndexLookupJoinBuilder& hasMarker(bool hasMarker) {
+      hasMarker_ = hasMarker;
       return *this;
     }
 
@@ -406,6 +431,13 @@ class PlanBuilder {
       return *this;
     }
 
+    /// @param filter SQL expression for the additional join filter. Can
+    /// use columns from both probe and build sides of the join.
+    IndexLookupJoinBuilder& filter(std::string filter) {
+      filter_ = std::move(filter);
+      return *this;
+    }
+
     /// @param joinType Type of the join supported: inner, left.
     IndexLookupJoinBuilder& joinType(core::JoinType joinType) {
       joinType_ = joinType;
@@ -427,7 +459,8 @@ class PlanBuilder {
     std::vector<std::string> rightKeys_;
     core::TableScanNodePtr indexSource_;
     std::vector<std::string> joinConditions_;
-    bool includeMatchColumn_{false};
+    std::string filter_;
+    bool hasMarker_{false};
     std::vector<std::string> outputLayout_;
     core::JoinType joinType_{core::JoinType::kInner};
   };
@@ -622,6 +655,11 @@ class PlanBuilder {
       bool parallelizable = false,
       size_t repeatTimes = 1);
 
+  /// Convenience overload that wraps a single RowVectorPtr in a vector.
+  PlanBuilder& values(const RowVectorPtr& value) {
+    return values(std::vector<RowVectorPtr>{value});
+  }
+
   PlanBuilder& filtersAsNode(bool filtersAsNode) {
     filtersAsNode_ = filtersAsNode;
     return *this;
@@ -649,9 +687,7 @@ class PlanBuilder {
   ///
   /// @param outputType The type of the data coming in and out of the exchange.
   /// @param serdekind The kind of seralized data format.
-  PlanBuilder& exchange(
-      const RowTypePtr& outputType,
-      VectorSerde::Kind serdekind);
+  PlanBuilder& exchange(const RowTypePtr& outputType, std::string serdekind);
 
   /// Add a MergeExchangeNode using specified ORDER BY clauses.
   ///
@@ -664,7 +700,7 @@ class PlanBuilder {
   PlanBuilder& mergeExchange(
       const RowTypePtr& outputType,
       const std::vector<std::string>& keys,
-      VectorSerde::Kind serdekind);
+      std::string serdekind);
 
   /// Add a ProjectNode using specified SQL expressions.
   ///
@@ -726,7 +762,10 @@ class PlanBuilder {
   /// Add a FilterNode using specified SQL expression.
   ///
   /// @param filter SQL expression of type boolean.
-  PlanBuilder& filter(const std::string& filter);
+  PlanBuilder& filter(const std::string& filterExpr);
+
+  /// Same as above, but takes an untyped expression.
+  PlanBuilder& filter(const core::ExprPtr& filterExpr);
 
   /// Similar to filter() except 'optionalFilter' could be empty and the
   /// function will skip creating a FilterNode in that case.
@@ -817,6 +856,12 @@ class PlanBuilder {
   /// output of the previous operator.
   /// @param ensureFiles When this option is set the HiveDataSink will always
   /// create a file even if there is no data.
+  /// @param commitStrategy The commit strategy to use for the table write
+  /// operation, default is kNoCommit.
+  /// @param insertTableHandle Encapsulates information needed to write data
+  /// to a table through a connector. If not specified, tableWrite will build
+  /// a HiveInsertTableHandle with columnHandles, bucketProperty and
+  /// locationHandle.
   PlanBuilder& tableWrite(
       const std::string& outputDirectoryPath,
       const std::vector<std::string>& partitionBy,
@@ -835,10 +880,21 @@ class PlanBuilder {
       const RowTypePtr& schema = nullptr,
       const bool ensureFiles = false,
       const connector::CommitStrategy commitStrategy =
-          connector::CommitStrategy::kNoCommit);
-
-  /// Add a TableWriteMergeNode.
-  PlanBuilder& tableWriteMerge();
+          connector::CommitStrategy::kNoCommit,
+      std::shared_ptr<core::InsertTableHandle> insertTableHandle = nullptr);
+
+  /// Add a TableWriteMergeNode. Derives the ColumnStatsSpec from the
+  /// TableWriteNode in the plan tree and applies the given step.
+  /// Finds the TableWriteNode through LocalPartitionNode if present.
+  /// @param step Must be kIntermediate or kFinal. Defaults to kIntermediate.
+  PlanBuilder& tableWriteMerge(
+      core::AggregationNode::Step step =
+          core::AggregationNode::Step::kIntermediate);
+
+  /// Add a TableWriteMergeNode with an explicit ColumnStatsSpec. Use for
+  /// coordinator-side merge where the TableWriteNode is in a different
+  /// fragment (e.g. after an Exchange).
+  PlanBuilder& tableWriteMerge(core::ColumnStatsSpec columnStatsSpec);
 
   /// Add an AggregationNode representing partial aggregation with the
   /// specified grouping keys, aggregates and optional masks.
@@ -1014,7 +1070,8 @@ class PlanBuilder {
       const std::vector<std::string>& aggregates,
       const std::vector<std::string>& masks,
       core::AggregationNode::Step step,
-      bool ignoreNullKeys);
+      bool ignoreNullKeys,
+      bool noGroupsSpanBatches = false);
 
   /// Add a GroupIdNode using the specified grouping keys, grouping sets,
   /// aggregation inputs and a groupId column name.
@@ -1134,14 +1191,14 @@ class PlanBuilder {
       int numPartitions,
       bool replicateNullsAndAny,
       const std::vector<std::string>& outputLayout = {},
-      VectorSerde::Kind serdeKind = VectorSerde::Kind::kPresto);
+      std::string serdeKind = "Presto");
 
   /// Same as above, but assumes 'replicateNullsAndAny' is false.
   PlanBuilder& partitionedOutput(
       const std::vector<std::string>& keys,
       int numPartitions,
       const std::vector<std::string>& outputLayout = {},
-      VectorSerde::Kind serdeKind = VectorSerde::Kind::kPresto);
+      std::string serdeKind = "Presto");
 
   /// Same as above, but allows to provide custom partition function.
   PlanBuilder& partitionedOutput(
@@ -1150,7 +1207,7 @@ class PlanBuilder {
       bool replicateNullsAndAny,
       core::PartitionFunctionSpecPtr partitionFunctionSpec,
       const std::vector<std::string>& outputLayout = {},
-      VectorSerde::Kind serdeKind = VectorSerde::Kind::kPresto);
+      std::string serdeKind = "Presto");
 
   /// Adds a PartitionedOutputNode to broadcast the input data.
   ///
@@ -1160,12 +1217,12 @@ class PlanBuilder {
   /// duplicated in the output.
   PlanBuilder& partitionedOutputBroadcast(
       const std::vector<std::string>& outputLayout = {},
-      VectorSerde::Kind serdeKind = VectorSerde::Kind::kPresto);
+      std::string serdeKind = "Presto");
 
   /// Adds a PartitionedOutputNode to put data into arbitrary buffer.
   PlanBuilder& partitionedOutputArbitrary(
       const std::vector<std::string>& outputLayout = {},
-      VectorSerde::Kind serdeKind = VectorSerde::Kind::kPresto);
+      std::string serdeKind = "Presto");
 
   /// Adds a LocalPartitionNode to hash-partition the input on the specified
   /// keys using exec::HashPartitionFunction. Number of partitions is determined
@@ -1182,6 +1239,9 @@ class PlanBuilder {
   /// current plan node).
   PlanBuilder& localPartition(const std::vector<std::string>& keys);
 
+  /// Add a LocalPartitionNode with gather type (N-to-1, empty partition keys).
+  PlanBuilder& localGather();
+
   /// A convenience method to add a LocalPartitionNode with hive partition
   /// function.
   PlanBuilder& localPartition(
@@ -1244,7 +1304,8 @@ class PlanBuilder {
       const std::string& filter,
       const std::vector<std::string>& outputLayout,
       core::JoinType joinType = core::JoinType::kInner,
-      bool nullAware = false);
+      bool nullAware = false,
+      bool nullAsValue = false);
 
   /// Add a MergeJoinNode to join two inputs using one or more join keys and an
   /// optional filter. The caller is responsible to ensure that inputs are
@@ -1302,6 +1363,9 @@ class PlanBuilder {
   PlanBuilder& spatialJoin(
       const core::PlanNodePtr& right,
       const std::string& joinCondition,
+      const std::string& probeGeometry,
+      const std::string& buildGeometry,
+      const std::optional<std::string>& radius,
       const std::vector<std::string>& outputLayout,
       core::JoinType joinType = core::JoinType::kInner);
 
@@ -1315,6 +1379,11 @@ class PlanBuilder {
   /// node. Second input is specified in 'right' parameter and must be a
   /// table source with the connector table handle with index lookup support.
   ///
+  /// @param leftKeys Join keys from the probe side, the preceding plan node.
+  /// Cannot be empty.
+  /// @param rightKeys Join keys from the index lookup side, the plan node
+  /// specified in 'right' parameter. The number and types of left and right
+  /// keys must be the same.
   /// @param right The right input source with index lookup support.
   /// @param joinConditions SQL expressions as the join conditions. Each join
   /// condition must use columns from both sides. For the right side, it can
@@ -1327,18 +1396,23 @@ class PlanBuilder {
   /// where "a" is the index column from right side and "b", "c" are either
   /// condition column from left side or a constant but at least one of them
   /// must not be constant. They all have the same type.
-  /// @param joinType Type of the join supported: inner, left.
-  /// @param includeMatchColumn if true, 'outputLayout' should include a boolean
+  /// @param filter SQL expression for the additional join filter to apply on
+  /// join results. This supports filters that can't be converted into join
+  /// conditions or lookup conditions. Can be an empty string if no additional
+  /// filter is needed.
+  /// @param hasMarker if true, 'outputLayout' should include a boolean
   /// column at the end to indicate if a join output row has a match or not.
   /// This only applies for left join.
-  ///
-  /// See hashJoin method for the description of the other parameters.
+  /// @param outputLayout Output layout consisting of columns from probe and
+  /// build sides.
+  /// @param joinType Type of the join supported: inner, left.
   PlanBuilder& indexLookupJoin(
       const std::vector<std::string>& leftKeys,
       const std::vector<std::string>& rightKeys,
       const core::TableScanNodePtr& right,
       const std::vector<std::string>& joinConditions,
-      bool includeMatchColumn,
+      const std::string& filter,
+      bool hasMarker,
       const std::vector<std::string>& outputLayout,
       core::JoinType joinType = core::JoinType::kInner);
 
@@ -1360,16 +1434,16 @@ class PlanBuilder {
   /// @param ordinalColumn An optional name for the 'ordinal' column to produce.
   /// This column contains the index of the element of the unnested array or
   /// map. If not specified, the output will not contain this column.
-  /// @param emptyUnnestValueName An optional name for the
-  /// 'emptyUnnestValue' column to produce. This column contains a boolean
-  /// indicating if the output row has empty unnest value or not. If not
-  /// specified, the output will not contain this column and the unnest operator
-  /// also skips producing output rows with empty unnest value.
+  /// @param markerName An optional name for the marker column to produce.
+  /// This column contains a boolean indicating whether the output row has
+  /// non-empty unnested value. If not specified, the output will not contain
+  /// this column and the unnest operator also skips producing output rows
+  /// with empty unnest value.
   PlanBuilder& unnest(
       const std::vector<std::string>& replicateColumns,
       const std::vector<std::string>& unnestColumns,
       const std::optional<std::string>& ordinalColumn = std::nullopt,
-      const std::optional<std::string>& emptyUnnestValueName = std::nullopt);
+      const std::optional<std::string>& markerName = std::nullopt);
 
   /// Add a WindowNode to compute one or more windowFunctions.
   /// @param windowFunctions A list of one or more window function SQL like
@@ -1429,6 +1503,41 @@ class PlanBuilder {
       std::string markerKey,
       const std::vector<std::string>& distinctKeys);
 
+  /// Add an EnforceDistinctNode to ensure input has unique values for the
+  /// specified keys at runtime. Throws with the specified error message if
+  /// duplicates are found.
+  /// @param distinctKeys List of columns that must have unique values.
+  /// @param errorMessage Error message to include in the exception when
+  /// duplicates are found.
+  /// @param preGroupedKeys Optional subset of distinctKeys that input is
+  /// already clustered on. When equal to distinctKeys, uses streaming
+  /// enforcement.
+  PlanBuilder& enforceDistinct(
+      const std::vector<std::string>& distinctKeys,
+      std::string errorMessage,
+      const std::vector<std::string>& preGroupedKeys = {});
+
+  /// Add an EnforceDistinctNode to ensure pre-grouped input has unique
+  /// values for the specified keys. Equivalent to calling enforceDistinct with
+  /// preGroupedKeys equal to distinctKeys, which uses the streaming
+  /// implementation.
+  /// @param distinctKeys List of columns that must have unique values. Input
+  /// must be clustered on these keys.
+  /// @param errorMessage Error message to include in the exception when
+  /// duplicates are found.
+  PlanBuilder& streamingEnforceDistinct(
+      const std::vector<std::string>& distinctKeys,
+      std::string errorMessage);
+
+  /// Add a MarkSortedNode to mark rows indicating sortedness.
+  /// @param markerKey Name of output marker column (boolean).
+  /// @param sortingKeys List of columns used for sorting.
+  /// @param sortingOrders Sort orders for each sorting key.
+  PlanBuilder& markSorted(
+      const std::string& markerKey,
+      const std::vector<std::string>& sortingKeys,
+      const std::vector<core::SortOrder>& sortingOrders);
+
   /// Stores the latest plan node ID into the specified variable. Useful for
   /// capturing IDs of the leaf plan nodes (table scans, exchanges, etc.) to use
   /// when adding splits at runtime.
diff --git a/velox/exec/tests/utils/QueryAssertions.cpp b/velox/exec/tests/utils/QueryAssertions.cpp
index 58adaf6f997..abb184b333b 100644
--- a/velox/exec/tests/utils/QueryAssertions.cpp
+++ b/velox/exec/tests/utils/QueryAssertions.cpp
@@ -21,6 +21,8 @@
 #include "velox/duckdb/conversion/DuckConversion.h"
 #include "velox/exec/Cursor.h"
 #include "velox/exec/tests/utils/QueryAssertions.h"
+#include "velox/type/Type.h"
+#include "velox/vector/VariantToVector.h"
 #include "velox/vector/VectorTypeUtils.h"
 
 using facebook::velox::duckdb::duckdbTimestampToVelox;
@@ -100,8 +102,9 @@ ::duckdb::Value duckValueAt<TypeKind::INTEGER>(
     vector_size_t index) {
   auto type = vector->type();
   if (type->isDate()) {
-    return ::duckdb::Value::DATE(::duckdb::Date::EpochDaysToDate(
-        vector->as<SimpleVector<int32_t>>()->valueAt(index)));
+    return ::duckdb::Value::DATE(
+        ::duckdb::Date::EpochDaysToDate(
+            vector->as<SimpleVector<int32_t>>()->valueAt(index)));
   }
   return ::duckdb::Value(vector->as<SimpleVector<int32_t>>()->valueAt(index));
 }
@@ -129,6 +132,14 @@ ::duckdb::Value duckValueAt<TypeKind::BIGINT>(
     return ::duckdb::Value::INTERVAL(0, days, microseconds);
   }
 
+  if (type->isTime()) {
+    VELOX_DCHECK(type->equivalent(*TIME()));
+    // TIME is stored as milliseconds since midnight in Velox.
+    // DuckDB TIME is stored as microseconds since midnight.
+    const auto timeMillis = vector->as<SimpleVector<int64_t>>()->valueAt(index);
+    return ::duckdb::Value::TIME(::duckdb::dtime_t(timeMillis * 1000L));
+  }
+
   return ::duckdb::Value(vector->as<SimpleVector<T>>()->valueAt(index));
 }
 
@@ -216,9 +227,10 @@ ::duckdb::Value duckValueAt<TypeKind::MAP>(
   const auto& mapValues = mapVector->mapValues();
   auto offset = mapVector->offsetAt(mapRow);
   auto size = mapVector->sizeAt(mapRow);
-  auto mapType = ::duckdb::ListType::GetChildType(::duckdb::LogicalType::MAP(
-      duckdb::fromVeloxType(mapKeys->type()),
-      duckdb::fromVeloxType(mapValues->type())));
+  auto mapType = ::duckdb::ListType::GetChildType(
+      ::duckdb::LogicalType::MAP(
+          duckdb::fromVeloxType(mapKeys->type()),
+          duckdb::fromVeloxType(mapValues->type())));
   if (size == 0) {
     return ::duckdb::Value::MAP(mapType, ::duckdb::vector<::duckdb::Value>());
   }
@@ -274,7 +286,8 @@ variant variantAt<TypeKind::VARBINARY>(
     int32_t row,
     int32_t column) {
   return variant::binary(
-      StringView(::duckdb::StringValue::Get(dataChunk->GetValue(column, row))));
+      std::string(
+          ::duckdb::StringValue::Get(dataChunk->GetValue(column, row))));
 }
 
 template <>
@@ -319,7 +332,7 @@ variant variantAt<TypeKind::VARCHAR>(const ::duckdb::Value& value) {
 
 template <>
 variant variantAt<TypeKind::VARBINARY>(const ::duckdb::Value& value) {
-  return variant::binary(StringView(::duckdb::StringValue::Get(value)));
+  return variant::binary(std::string(::duckdb::StringValue::Get(value)));
 }
 
 variant nullVariant(const TypePtr& type) {
@@ -435,12 +448,21 @@ std::vector<MaterializedRow> materialize(
       } else if (type->isDecimal()) {
         row.push_back(duckdb::decimalVariant(dataChunk->GetValue(j, i)));
       } else if (type->isIntervalDayTime()) {
-        auto value = variant(::duckdb::Interval::GetMicro(
-            dataChunk->GetValue(j, i).GetValue<::duckdb::interval_t>()));
+        auto value = variant(
+            ::duckdb::Interval::GetMicro(
+                dataChunk->GetValue(j, i).GetValue<::duckdb::interval_t>()));
         row.push_back(value);
       } else if (type->isDate()) {
-        auto value = variant(::duckdb::Date::EpochDays(
-            dataChunk->GetValue(j, i).GetValue<::duckdb::date_t>()));
+        auto value = variant(
+            ::duckdb::Date::EpochDays(
+                dataChunk->GetValue(j, i).GetValue<::duckdb::date_t>()));
+        row.push_back(value);
+      } else if (type->isTime()) {
+        VELOX_DCHECK(type->equivalent(*TIME()));
+        // DuckDB TIME is in microseconds, Velox TIME is in milliseconds.
+        auto value = variant(
+            dataChunk->GetValue(j, i).GetValue<::duckdb::dtime_t>().micros /
+            1000L);
         row.push_back(value);
       } else {
         auto value = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
@@ -708,7 +730,7 @@ std::string toTypeString(const MaterializedRow& row) {
     if (i > 0) {
       out << ", ";
     }
-    out << mapTypeKindToName(row[i].kind());
+    out << TypeKindName::toName(row[i].kind());
   }
   out << ")";
   return out.str();
@@ -1340,12 +1362,31 @@ std::pair<std::unique_ptr<TaskCursor>, std::vector<RowVectorPtr>> readCursor(
     const CursorParameters& params,
     std::function<void(TaskCursor*)> addSplits,
     uint64_t maxWaitMicros) {
+  return readCursorAsync(
+      params,
+      [addSplitsVoid = std::move(addSplits)](TaskCursor* cursor) {
+        addSplitsVoid(cursor);
+        return ContinueFuture::makeEmpty();
+      },
+      maxWaitMicros);
+}
+
+std::pair<std::unique_ptr<TaskCursor>, std::vector<RowVectorPtr>>
+readCursorAsync(
+    const CursorParameters& params,
+    std::function<ContinueFuture(TaskCursor*)> addSplits,
+    uint64_t maxWaitMicros) {
   auto cursor = TaskCursor::create(params);
   // 'result' borrows memory from cursor so the life cycle must be shorter.
   std::vector<RowVectorPtr> result;
   auto* task = cursor->task().get();
+  cursor->start();
+  auto future = ContinueFuture::makeEmpty();
   while (!cursor->noMoreSplits()) {
-    addSplits(cursor.get());
+    if (future.valid()) {
+      future.wait();
+    }
+    future = addSplits(cursor.get());
     while (cursor->moveNext()) {
       auto vector = cursor->current();
       vector->loadedVector();
@@ -1441,6 +1482,15 @@ void waitForAllTasksToBeDeleted(uint64_t maxWaitUs) {
       folly::join("\n", pendingTaskStats));
 }
 
+void cancelAllTasks() {
+  std::vector<std::shared_ptr<Task>> pendingTasks = Task::getRunningTasks();
+  for (const auto& task : pendingTasks) {
+    if (task->isRunning()) {
+      task->requestCancel();
+    }
+  }
+}
+
 std::shared_ptr<Task> assertQuery(
     const core::PlanNodePtr& plan,
     std::function<void(exec::TaskCursor*)> addSplits,
diff --git a/velox/exec/tests/utils/QueryAssertions.h b/velox/exec/tests/utils/QueryAssertions.h
index 3acfa88885d..276d58257c2 100644
--- a/velox/exec/tests/utils/QueryAssertions.h
+++ b/velox/exec/tests/utils/QueryAssertions.h
@@ -22,6 +22,9 @@
 #include "velox/exec/Operator.h"
 #include "velox/vector/ComplexVector.h"
 
+#ifdef BLOCK_SIZE
+#undef BLOCK_SIZE
+#endif
 #include <duckdb.hpp> // @manual
 
 namespace facebook::velox::exec::test {
@@ -185,6 +188,19 @@ std::pair<std::unique_ptr<TaskCursor>, std::vector<RowVectorPtr>> readCursor(
         },
     uint64_t maxWaitMicros = 5'000'000);
 
+std::pair<std::unique_ptr<TaskCursor>, std::vector<RowVectorPtr>>
+readCursorAsync(
+    const CursorParameters& params,
+    std::function<ContinueFuture(TaskCursor*)> addSplits =
+        [](TaskCursor* taskCursor) {
+          if (taskCursor->noMoreSplits()) {
+            return ContinueFuture::makeEmpty();
+          }
+          taskCursor->setNoMoreSplits();
+          return ContinueFuture::makeEmpty();
+        },
+    uint64_t maxWaitMicros = 5'000'000);
+
 /// The Task can return results before the Driver is finished executing.
 /// Wait upto maxWaitMicros for the Task to finish as 'expectedState' before
 /// returning to ensure it's stable e.g. the Driver isn't updating it anymore.
@@ -221,6 +237,11 @@ bool waitForTaskStateChange(
 /// during this wait call. This is for testing purpose for now.
 void waitForAllTasksToBeDeleted(uint64_t maxWaitUs = 3'000'000);
 
+/// Cancels all currently running tasks across all available task managers.
+/// This is primarily used in testing scenarios to clean up active tasks
+/// and ensure test isolation between test cases.
+void cancelAllTasks();
+
 std::shared_ptr<Task> assertQuery(
     const core::PlanNodePtr& plan,
     const std::string& duckDbSql,
@@ -307,6 +328,13 @@ bool assertEqualResults(
     const core::PlanNodePtr& plan1,
     const core::PlanNodePtr& plan2);
 
+bool assertEqualResults(
+    const MaterializedRowMultiset& expectedRows,
+    const TypePtr& expectedType,
+    const MaterializedRowMultiset& actualRows,
+    const TypePtr& actualType,
+    const std::string& message);
+
 /// Ensure both datasets have the same type and number of rows.
 void assertEqualTypeAndNumRows(
     const TypePtr& expectedType,
diff --git a/velox/exec/tests/utils/RowContainerTestBase.h b/velox/exec/tests/utils/RowContainerTestBase.h
index c9d126fa869..9c04dcca7b9 100644
--- a/velox/exec/tests/utils/RowContainerTestBase.h
+++ b/velox/exec/tests/utils/RowContainerTestBase.h
@@ -16,9 +16,9 @@
 #include <gtest/gtest.h>
 
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/exec/RowContainer.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/serializers/CompactRowSerializer.h"
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/serializers/UnsafeRowSerializer.h"
@@ -26,6 +26,8 @@
 
 namespace facebook::velox::exec::test {
 
+using TempDirectoryPath = common::testutil::TempDirectoryPath;
+
 class RowContainerTestBase : public testing::Test,
                              public velox::test::VectorTestBase {
  protected:
@@ -46,15 +48,15 @@ class RowContainerTestBase : public testing::Test,
       facebook::velox::serializer::presto::PrestoVectorSerde::
           registerVectorSerde();
     }
-    if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kPresto)) {
+    if (!isRegisteredNamedVectorSerde("Presto")) {
       facebook::velox::serializer::presto::PrestoVectorSerde::
           registerNamedVectorSerde();
     }
-    if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kCompactRow)) {
+    if (!isRegisteredNamedVectorSerde("CompactRow")) {
       facebook::velox::serializer::CompactRowVectorSerde::
           registerNamedVectorSerde();
     }
-    if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kUnsafeRow)) {
+    if (!isRegisteredNamedVectorSerde("UnsafeRow")) {
       facebook::velox::serializer::spark::UnsafeRowVectorSerde::
           registerNamedVectorSerde();
     }
@@ -76,7 +78,8 @@ class RowContainerTestBase : public testing::Test,
   std::unique_ptr<RowContainer> makeRowContainer(
       const std::vector<TypePtr>& keyTypes,
       const std::vector<TypePtr>& dependentTypes,
-      bool isJoinBuild = true) {
+      bool isJoinBuild = true,
+      bool useListRowIndex = false) {
     auto container = std::make_unique<RowContainer>(
         keyTypes,
         !isJoinBuild,
@@ -85,7 +88,9 @@ class RowContainerTestBase : public testing::Test,
         isJoinBuild,
         isJoinBuild,
         true,
+        false, // hasCountFlag
         true,
+        useListRowIndex,
         pool_.get());
     VELOX_CHECK(container->testingMutable());
     return container;
diff --git a/velox/exec/tests/utils/SerializedPageUtil.cpp b/velox/exec/tests/utils/SerializedPageUtil.cpp
index 4316f1a783f..86150055cea 100644
--- a/velox/exec/tests/utils/SerializedPageUtil.cpp
+++ b/velox/exec/tests/utils/SerializedPageUtil.cpp
@@ -20,9 +20,9 @@ using namespace facebook::velox;
 
 namespace facebook::velox::exec::test {
 
-std::unique_ptr<SerializedPage> toSerializedPage(
+std::unique_ptr<SerializedPageBase> toSerializedPage(
     const RowVectorPtr& vector,
-    VectorSerde::Kind serdeKind,
+    std::string serdeKind,
     const std::shared_ptr<OutputBufferManager>& bufferManager,
     memory::MemoryPool* pool) {
   auto data =
@@ -34,7 +34,8 @@ std::unique_ptr<SerializedPage> toSerializedPage(
   auto listener = bufferManager->newListener();
   IOBufOutputStream stream(*pool, listener.get(), data->size());
   data->flush(&stream);
-  return std::make_unique<SerializedPage>(stream.getIOBuf(), nullptr, size);
+  return std::make_unique<PrestoSerializedPage>(
+      stream.getIOBuf(), nullptr, size);
 }
 
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/SerializedPageUtil.h b/velox/exec/tests/utils/SerializedPageUtil.h
index 6890693d634..c19387c9bb9 100644
--- a/velox/exec/tests/utils/SerializedPageUtil.h
+++ b/velox/exec/tests/utils/SerializedPageUtil.h
@@ -23,9 +23,9 @@
 namespace facebook::velox::exec::test {
 
 /// Helper function for serializing RowVector to PrestoPage format.
-std::unique_ptr<SerializedPage> toSerializedPage(
+std::unique_ptr<SerializedPageBase> toSerializedPage(
     const RowVectorPtr& vector,
-    VectorSerde::Kind serdeKind,
+    std::string serdeKind,
     const std::shared_ptr<OutputBufferManager>& bufferManager,
     memory::MemoryPool* pool);
 
diff --git a/velox/exec/tests/utils/TableScanTestBase.cpp b/velox/exec/tests/utils/TableScanTestBase.cpp
index 394020fe1b5..c3b10d466fe 100644
--- a/velox/exec/tests/utils/TableScanTestBase.cpp
+++ b/velox/exec/tests/utils/TableScanTestBase.cpp
@@ -19,6 +19,8 @@
 #include "velox/exec/tests/utils/LocalExchangeSource.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 
+using namespace facebook::velox::common::testutil;
+
 namespace facebook::velox::exec::test {
 
 void TableScanTestBase::verifyCacheStats(
@@ -183,6 +185,9 @@ void TableScanTestBase::testPartitionedTableImpl(
            .assignments(assignments)
            .endTableScan()
            .planNode();
+  split = exec::test::HiveConnectorSplitBuilder(filePath)
+              .partitionKey("pkey", partitionValue)
+              .build();
   assertQuery(
       op, split, fmt::format("SELECT c0, {}, c1 FROM tmp", partitionValueStr));
   outputType = ROW({"c0", "c1", "pkey"}, {BIGINT(), DOUBLE(), partitionType});
@@ -192,6 +197,9 @@ void TableScanTestBase::testPartitionedTableImpl(
            .assignments(assignments)
            .endTableScan()
            .planNode();
+  split = exec::test::HiveConnectorSplitBuilder(filePath)
+              .partitionKey("pkey", partitionValue)
+              .build();
   assertQuery(
       op, split, fmt::format("SELECT c0, c1, {} FROM tmp", partitionValueStr));
 
@@ -204,6 +212,9 @@ void TableScanTestBase::testPartitionedTableImpl(
            .assignments(assignments)
            .endTableScan()
            .planNode();
+  split = exec::test::HiveConnectorSplitBuilder(filePath)
+              .partitionKey("pkey", partitionValue)
+              .build();
   assertQuery(op, split, fmt::format("SELECT {} FROM tmp", partitionValueStr));
 }
 
diff --git a/velox/exec/tests/utils/TableScanTestBase.h b/velox/exec/tests/utils/TableScanTestBase.h
index f7e2929f284..16c6178ce0f 100644
--- a/velox/exec/tests/utils/TableScanTestBase.h
+++ b/velox/exec/tests/utils/TableScanTestBase.h
@@ -17,8 +17,8 @@
 
 #include <fmt/ranges.h>
 
-#include <folly/experimental/EventCount.h>
 #include <folly/synchronization/Baton.h>
+#include <folly/synchronization/EventCount.h>
 #include <folly/synchronization/Latch.h>
 #include "velox/connectors/hive/FileHandle.h"
 #include "velox/exec/PlanNodeStats.h"
@@ -27,6 +27,8 @@
 
 namespace facebook::velox::exec::test {
 
+using TempFilePath = common::testutil::TempFilePath;
+
 class TableScanTestBase : public HiveConnectorTestBase {
  protected:
   void SetUp() override;
diff --git a/velox/exec/tests/utils/TableWriterTestBase.cpp b/velox/exec/tests/utils/TableWriterTestBase.cpp
index 34304d94ab2..bf349d8b2ca 100644
--- a/velox/exec/tests/utils/TableWriterTestBase.cpp
+++ b/velox/exec/tests/utils/TableWriterTestBase.cpp
@@ -17,6 +17,7 @@
 #include "velox/exec/tests/utils/TableWriterTestBase.h"
 
 namespace velox::exec::test {
+using namespace facebook::velox::common::testutil;
 
 TableWriterTestBase::TestParam::TestParam(
     FileFormat fileFormat,
@@ -399,8 +400,9 @@ TableWriterTestBase::makeHiveConnectorSplits(const std::string& directoryPath) {
   std::vector<std::shared_ptr<connector::ConnectorSplit>> splits;
   for (auto& path : fs::recursive_directory_iterator(directoryPath)) {
     if (path.is_regular_file()) {
-      splits.push_back(HiveConnectorTestBase::makeHiveConnectorSplits(
-          path.path().string(), 1, fileFormat_)[0]);
+      splits.push_back(
+          HiveConnectorTestBase::makeHiveConnectorSplits(
+              path.path().string(), 1, fileFormat_)[0]);
     }
   }
   return splits;
@@ -426,8 +428,9 @@ TableWriterTestBase::makeHiveConnectorSplits(
     const std::vector<std::filesystem::path>& filePaths) {
   std::vector<std::shared_ptr<connector::ConnectorSplit>> splits;
   for (const auto& filePath : filePaths) {
-    splits.push_back(HiveConnectorTestBase::makeHiveConnectorSplits(
-        filePath.string(), 1, fileFormat_)[0]);
+    splits.push_back(
+        HiveConnectorTestBase::makeHiveConnectorSplits(
+            filePath.string(), 1, fileFormat_)[0]);
   }
   return splits;
 }
@@ -781,9 +784,10 @@ std::string TableWriterTestBase::partitionNameToPredicate(
   for (auto i = 0; i < partitionKeyValues.size(); ++i) {
     if (partitionTypes[i]->isVarchar() || partitionTypes[i]->isVarbinary() ||
         partitionTypes[i]->isDate()) {
-      conjuncts.push_back(partitionKeyValues[i]
-                              .replace(partitionKeyValues[i].find("="), 1, "='")
-                              .append("'"));
+      conjuncts.push_back(
+          partitionKeyValues[i]
+              .replace(partitionKeyValues[i].find("="), 1, "='")
+              .append("'"));
     } else {
       conjuncts.push_back(partitionKeyValues[i]);
     }
@@ -799,9 +803,10 @@ std::string TableWriterTestBase::partitionNameToPredicate(
   for (auto i = 0; i < partitionDirNames.size(); ++i) {
     if (partitionTypes_[i]->isVarchar() || partitionTypes_[i]->isVarbinary() ||
         partitionTypes_[i]->isDate()) {
-      conjuncts.push_back(partitionKeyValues[i]
-                              .replace(partitionKeyValues[i].find("="), 1, "='")
-                              .append("'"));
+      conjuncts.push_back(
+          partitionKeyValues[i]
+              .replace(partitionKeyValues[i].find("="), 1, "='")
+              .append("'"));
     } else {
       conjuncts.push_back(partitionDirNames[i]);
     }
@@ -814,20 +819,22 @@ void TableWriterTestBase::verifyUnbucketedFilePath(
     const std::string& targetDir) {
   ASSERT_EQ(filePath.parent_path().string(), targetDir);
   if (commitStrategy_ == CommitStrategy::kNoCommit) {
-    ASSERT_TRUE(RE2::FullMatch(
-        filePath.filename().string(),
-        fmt::format(
-            "test_cursor.+_[0-{}]_{}_.+",
-            numTableWriterCount_ - 1,
-            tableWriteNodeId_)))
+    ASSERT_TRUE(
+        RE2::FullMatch(
+            filePath.filename().string(),
+            fmt::format(
+                "test_cursor.+_[0-{}]_{}_.+",
+                numTableWriterCount_ - 1,
+                tableWriteNodeId_)))
         << filePath.filename().string();
   } else {
-    ASSERT_TRUE(RE2::FullMatch(
-        filePath.filename().string(),
-        fmt::format(
-            ".tmp.velox.test_cursor.+_[0-{}]_{}_.+",
-            numTableWriterCount_ - 1,
-            tableWriteNodeId_)))
+    ASSERT_TRUE(
+        RE2::FullMatch(
+            filePath.filename().string(),
+            fmt::format(
+                ".tmp.velox.test_cursor.+_[0-{}]_{}_.+",
+                numTableWriterCount_ - 1,
+                tableWriteNodeId_)))
         << filePath.filename().string();
   }
 }
@@ -843,25 +850,29 @@ void TableWriterTestBase::verifyBucketedFileName(
     const std::filesystem::path& filePath) {
   if (commitStrategy_ == CommitStrategy::kNoCommit) {
     if (fileFormat_ == FileFormat::PARQUET) {
-      ASSERT_TRUE(RE2::FullMatch(
-          filePath.filename().string(),
-          "0[0-9]+_0_TaskCursorQuery_[0-9]+\\.parquet$"))
+      ASSERT_TRUE(
+          RE2::FullMatch(
+              filePath.filename().string(),
+              "0[0-9]+_0_TaskCursorQuery_[0-9]+\\.parquet$"))
           << filePath.filename().string();
     } else {
-      ASSERT_TRUE(RE2::FullMatch(
-          filePath.filename().string(), "0[0-9]+_0_TaskCursorQuery_[0-9]+"))
+      ASSERT_TRUE(
+          RE2::FullMatch(
+              filePath.filename().string(), "0[0-9]+_0_TaskCursorQuery_[0-9]+"))
           << filePath.filename().string();
     }
   } else {
     if (fileFormat_ == FileFormat::PARQUET) {
-      ASSERT_TRUE(RE2::FullMatch(
-          filePath.filename().string(),
-          ".tmp.velox.0[0-9]+_0_TaskCursorQuery_[0-9]+_.+\\.parquet$"))
+      ASSERT_TRUE(
+          RE2::FullMatch(
+              filePath.filename().string(),
+              ".tmp.velox.0[0-9]+_0_TaskCursorQuery_[0-9]+_.+\\.parquet$"))
           << filePath.filename().string();
     } else {
-      ASSERT_TRUE(RE2::FullMatch(
-          filePath.filename().string(),
-          ".tmp.velox.0[0-9]+_0_TaskCursorQuery_[0-9]+_.+"))
+      ASSERT_TRUE(
+          RE2::FullMatch(
+              filePath.filename().string(),
+              ".tmp.velox.0[0-9]+_0_TaskCursorQuery_[0-9]+_.+"))
           << filePath.filename().string();
     }
   }
diff --git a/velox/exec/tests/utils/TableWriterTestBase.h b/velox/exec/tests/utils/TableWriterTestBase.h
index f0c71f92bee..83c21b3075c 100644
--- a/velox/exec/tests/utils/TableWriterTestBase.h
+++ b/velox/exec/tests/utils/TableWriterTestBase.h
@@ -17,6 +17,7 @@
 #include "velox/common/base/Fs.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/hyperloglog/SparseHll.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/connectors/hive/HiveConfig.h"
 #include "velox/connectors/hive/HivePartitionFunction.h"
@@ -26,12 +27,11 @@
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
 #include <re2/re2.h>
 #include <string>
-#include "folly/experimental/EventCount.h"
+#include "folly/synchronization/EventCount.h"
 #include "velox/common/memory/MemoryArbitrator.h"
 #include "velox/dwio/common/Options.h"
 #include "velox/dwio/dwrf/writer/Writer.h"
diff --git a/velox/exec/tests/utils/TempDirectoryPath.h b/velox/exec/tests/utils/TempDirectoryPath.h
index e719d0949d8..0e236e1bcc5 100644
--- a/velox/exec/tests/utils/TempDirectoryPath.h
+++ b/velox/exec/tests/utils/TempDirectoryPath.h
@@ -15,53 +15,9 @@
  */
 #pragma once
 
-#include <unistd.h>
-#include <cstdlib>
-#include <memory>
-#include <string>
-
-#include "velox/common/base/Exceptions.h"
+// DEPRECATED: Use velox/common/testutil/TempDirectoryPath.h instead.
+#include "velox/common/testutil/TempDirectoryPath.h"
 
 namespace facebook::velox::exec::test {
-
-/// Manages the lifetime of a temporary directory.
-class TempDirectoryPath {
- public:
-  /// If 'enableFaultInjection' is true, we enable fault injection on the
-  /// created file directory.
-  static std::shared_ptr<TempDirectoryPath> create(
-      bool enableFaultInjection = false);
-
-  virtual ~TempDirectoryPath();
-
-  TempDirectoryPath(const TempDirectoryPath&) = delete;
-  TempDirectoryPath& operator=(const TempDirectoryPath&) = delete;
-
-  /// If fault injection is enabled, the returned file path will have the faulty
-  /// file system prefix scheme. The velox fs then opens the directory through
-  /// the faulty file system. The file operation will then either fail or be
-  /// delegated to the actual file.
-  const std::string& getPath() const {
-    return path_;
-  }
-
-  /// The actual file path if fault injection is enabled.
-  const std::string& getDelegatePath() const {
-    return tempPath_;
-  }
-
- private:
-  static std::string createTempDirectory();
-
-  explicit TempDirectoryPath(bool enableFaultInjection)
-      : enableFaultInjection_(enableFaultInjection),
-        tempPath_(createTempDirectory()),
-        path_(
-            enableFaultInjection_ ? fmt::format("faulty:{}", tempPath_)
-                                  : tempPath_) {}
-
-  const bool enableFaultInjection_{false};
-  const std::string tempPath_;
-  const std::string path_;
-};
+using facebook::velox::common::testutil::TempDirectoryPath;
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/TempFilePath.h b/velox/exec/tests/utils/TempFilePath.h
index 4a4f95c042e..0a34011ddb0 100644
--- a/velox/exec/tests/utils/TempFilePath.h
+++ b/velox/exec/tests/utils/TempFilePath.h
@@ -15,82 +15,10 @@
  */
 #pragma once
 
-#include <sys/stat.h>
-#include <unistd.h>
-#include <cstdlib>
-#include <fstream>
-#include <memory>
-#include <string>
-
-#include "velox/common/base/Exceptions.h"
+// DEPRECATED: Use velox/common/testutil/TempFilePath.h instead.
+#include "velox/common/testutil/TempFilePath.h"
 
 namespace facebook::velox::exec::test {
-
-/// Manages the lifetime of a temporary file.
-class TempFilePath {
- public:
-  /// If 'enableFaultInjection' is true, we enable fault injection on the
-  /// created file.
-  static std::shared_ptr<TempFilePath> create(
-      bool enableFaultInjection = false);
-
-  ~TempFilePath();
-
-  TempFilePath(const TempFilePath&) = delete;
-  TempFilePath& operator=(const TempFilePath&) = delete;
-
-  void append(std::string data) {
-    std::ofstream file(tempPath_, std::ios_base::app);
-    file << data;
-    file.flush();
-    file.close();
-  }
-
-  const int64_t fileSize() {
-    struct stat st;
-    ::stat(tempPath_.data(), &st);
-    return st.st_size;
-  }
-
-  int64_t fileModifiedTime() {
-    struct stat st;
-    ::stat(tempPath_.data(), &st);
-    return st.st_mtime;
-  }
-
-  /// If fault injection is enabled, the returned the file path has the faulty
-  /// file system prefix scheme. The velox fs then opens the file through the
-  /// faulty file system. The actual file operation might either fails or
-  /// delegate to the actual file.
-  const std::string& getPath() const {
-    return path_;
-  }
-
-  // Returns the delegated file path if fault injection is enabled.
-  const std::string& tempFilePath() const {
-    return tempPath_;
-  }
-
- private:
-  static std::string createTempFile(TempFilePath* tempFilePath);
-
-  TempFilePath(bool enableFaultInjection)
-      : enableFaultInjection_(enableFaultInjection),
-        tempPath_(createTempFile(this)),
-        path_(
-            enableFaultInjection_ ? fmt::format("faulty:{}", tempPath_)
-                                  : tempPath_) {
-    VELOX_CHECK_NE(fd_, -1);
-  }
-
-  const bool enableFaultInjection_;
-  const std::string tempPath_;
-  const std::string path_;
-
-  int fd_;
-};
-
-std::vector<std::string> toFilePaths(
-    const std::vector<std::shared_ptr<TempFilePath>>& tempFiles);
-
+using facebook::velox::common::testutil::TempFilePath;
+using facebook::velox::common::testutil::toFilePaths;
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/TestIndexStorageConnector.cpp b/velox/exec/tests/utils/TestIndexStorageConnector.cpp
index b2dc3a81bdd..232c6e4903f 100644
--- a/velox/exec/tests/utils/TestIndexStorageConnector.cpp
+++ b/velox/exec/tests/utils/TestIndexStorageConnector.cpp
@@ -72,6 +72,7 @@ std::shared_ptr<TestIndexTable> TestIndexTable::create(
       /*dependentTypes=*/dependentTypes,
       /*allowDuplicates=*/true,
       /*hasProbedFlag=*/false,
+      /*hasCountFlag=*/false,
       /*minTableSizeForParallelJoinBuild=*/1,
       &pool);
 
@@ -96,7 +97,8 @@ std::shared_ptr<TestIndexTable> TestIndexTable::create(
   }
 
   // Build the table index.
-  table->prepareJoinTable({}, BaseHashTable::kNoSpillInputStartPartitionBit);
+  table->prepareJoinTable(
+      {}, BaseHashTable::kNoSpillInputStartPartitionBit, 1'000'000);
   return std::make_shared<TestIndexTable>(
       std::move(keyType), std::move(valueType), std::move(table));
 }
@@ -115,40 +117,82 @@ core::TypedExprPtr toJoinConditionExpr(
   std::vector<core::TypedExprPtr> conditionExprs;
   conditionExprs.reserve(joinConditions.size());
   for (const auto& condition : joinConditions) {
+    // Check for EqualIndexLookupCondition first to skip equi-join conditions
+    // before creating indexColumnExpr, since equi-join key names may not exist
+    // in keyType (they are handled by hash table lookup, not filter
+    // evaluation).
+    if (auto equalCondition =
+            std::dynamic_pointer_cast<core::EqualIndexLookupCondition>(
+                condition)) {
+      // Skip equi-join conditions (non-constant values) as they are handled
+      // by the hash table lookup, not by filter evaluation.
+      if (!equalCondition->isFilter()) {
+        continue;
+      }
+      // Filter conditions (constant values) need to be evaluated.
+      auto indexColumnExpr = std::make_shared<core::FieldAccessTypedExpr>(
+          keyType->findChild(condition->key->name()), condition->key->name());
+      conditionExprs.push_back(
+          std::make_shared<const core::CallTypedExpr>(
+              BOOLEAN(),
+              "eq",
+              std::move(indexColumnExpr),
+              equalCondition->value));
+      continue;
+    }
     auto indexColumnExpr = std::make_shared<core::FieldAccessTypedExpr>(
         keyType->findChild(condition->key->name()), condition->key->name());
     if (auto inCondition =
             std::dynamic_pointer_cast<core::InIndexLookupCondition>(
                 condition)) {
-      conditionExprs.push_back(std::make_shared<const core::CallTypedExpr>(
-          BOOLEAN(),
-          "contains",
-          inCondition->list,
-          std::move(indexColumnExpr)));
+      conditionExprs.push_back(
+          std::make_shared<const core::CallTypedExpr>(
+              BOOLEAN(),
+              "contains",
+              inCondition->list,
+              std::move(indexColumnExpr)));
       continue;
     }
     if (auto betweenCondition =
             std::dynamic_pointer_cast<core::BetweenIndexLookupCondition>(
                 condition)) {
-      conditionExprs.push_back(std::make_shared<const core::CallTypedExpr>(
-          BOOLEAN(),
-          "between",
-          std::move(indexColumnExpr),
-          betweenCondition->lower,
-          betweenCondition->upper));
+      conditionExprs.push_back(
+          std::make_shared<const core::CallTypedExpr>(
+              BOOLEAN(),
+              "between",
+              std::move(indexColumnExpr),
+              betweenCondition->lower,
+              betweenCondition->upper));
       continue;
     }
+    VELOX_FAIL("Invalid index join condition: {}", condition->toString());
+  }
+  if (conditionExprs.empty()) {
+    return nullptr;
+  }
+  if (conditionExprs.size() == 1) {
+    return conditionExprs[0];
+  }
+  return std::make_shared<core::CallTypedExpr>(
+      BOOLEAN(), conditionExprs, "and");
+}
+
+// Counts the number of equi-join keys in the given join conditions.
+// An equi-join key is an EqualIndexLookupCondition where isFilter()
+// returns false (i.e., the value references a probe column, not a constant).
+size_t countEqualJoinKeys(
+    const std::vector<core::IndexLookupConditionPtr>& joinConditions) {
+  size_t count = 0;
+  for (const auto& condition : joinConditions) {
     if (auto equalCondition =
             std::dynamic_pointer_cast<core::EqualIndexLookupCondition>(
                 condition)) {
-      conditionExprs.push_back(std::make_shared<const core::CallTypedExpr>(
-          BOOLEAN(), "eq", std::move(indexColumnExpr), equalCondition->value));
-      continue;
+      if (!equalCondition->isFilter()) {
+        ++count;
+      }
     }
-    VELOX_FAIL("Invalid index join condition: {}", condition->toString());
   }
-  return std::make_shared<core::CallTypedExpr>(
-      BOOLEAN(), conditionExprs, "and");
+  return count;
 }
 
 // Copy values from 'rows' of 'table' according to 'projections' in
@@ -222,11 +266,16 @@ void TestIndexSource::checkNotFailed() {
   }
 }
 
-std::shared_ptr<connector::IndexSource::LookupResultIterator>
-TestIndexSource::lookup(const LookupRequest& request) {
+std::shared_ptr<connector::IndexSource::ResultIterator> TestIndexSource::lookup(
+    const Request& request) {
   checkNotFailed();
+  VELOX_CHECK(!tableHandle_->needsIndexSplit() || !splits_.empty());
   const auto numInputRows = request.input->size();
-  auto& hashTable = tableHandle_->indexTable()->table;
+  auto* indexTable = tableHandle_->indexTable().get();
+  auto& hashTable = indexTable->table;
+  // Serialize access to the shared hash table. The hashers contain stateful
+  // DecodedVectors that are not thread-safe for concurrent access.
+  std::lock_guard<std::mutex> l(indexTable->mutex);
   auto lookup = std::make_unique<HashLookup>(hashTable->hashers(), pool_.get());
   SelectivityVector activeRows(numInputRows);
   VELOX_CHECK(activeRows.isAllSelected());
@@ -298,13 +347,13 @@ void TestIndexSource::recordCpuTiming(const CpuWallTiming& timing) {
   std::lock_guard<std::mutex> l(mutex_);
   if (timing.wallNanos != 0) {
     addOperatorRuntimeStats(
-        IndexLookupJoin::kConnectorLookupWallTime,
+        std::string(IndexLookupJoin::kConnectorLookupWallTime),
         RuntimeCounter(timing.wallNanos, RuntimeCounter::Unit::kNanos),
         runtimeStats_);
     // This is just for testing purpose to check if the runtime stats has been
     // set properly.
     addOperatorRuntimeStats(
-        IndexLookupJoin::kClientLookupWaitWallTime,
+        std::string(IndexLookupJoin::kClientLookupWaitWallTime),
         RuntimeCounter(timing.wallNanos, RuntimeCounter::Unit::kNanos),
         runtimeStats_);
   }
@@ -312,7 +361,7 @@ void TestIndexSource::recordCpuTiming(const CpuWallTiming& timing) {
     // This is just for testing purpose to check if the runtime stats has been
     // set properly.
     addOperatorRuntimeStats(
-        IndexLookupJoin::kConnectorResultPrepareTime,
+        std::string(IndexLookupJoin::kConnectorResultPrepareTime),
         RuntimeCounter(timing.cpuNanos, RuntimeCounter::Unit::kNanos),
         runtimeStats_);
   }
@@ -325,7 +374,7 @@ std::unordered_map<std::string, RuntimeMetric> TestIndexSource::runtimeStats() {
 
 TestIndexSource::ResultIterator::ResultIterator(
     std::shared_ptr<TestIndexSource> source,
-    const LookupRequest& request,
+    const Request& request,
     std::unique_ptr<HashLookup> lookupResult,
     folly::Executor* executor)
     : source_(std::move(source)),
@@ -338,7 +387,17 @@ TestIndexSource::ResultIterator::ResultIterator(
   lookupResultIter_->reset(*lookupResult_);
 }
 
-std::optional<std::unique_ptr<connector::IndexSource::LookupResult>>
+bool TestIndexSource::ResultIterator::hasNext() {
+  // If we have an async result ready, we have more to return.
+  if (asyncResult_.has_value()) {
+    return true;
+  }
+
+  // If the iterator is not at end, there are more results to fetch.
+  return !lookupResultIter_->atEnd();
+}
+
+std::optional<std::unique_ptr<connector::IndexSource::Result>>
 TestIndexSource::ResultIterator::next(
     vector_size_t size,
     ContinueFuture& future) {
@@ -417,7 +476,7 @@ void TestIndexSource::ResultIterator::asyncLookup(
   });
 }
 
-std::unique_ptr<connector::IndexSource::LookupResult>
+std::unique_ptr<connector::IndexSource::Result>
 TestIndexSource::ResultIterator::syncLookup(vector_size_t size) {
   VELOX_CHECK(hasPendingRequest_);
   if (lookupResultIter_->atEnd()) {
@@ -476,7 +535,8 @@ TestIndexSource::ResultIterator::syncLookup(vector_size_t size) {
         lookupOutput_);
     VELOX_CHECK_EQ(lookupOutput_->size(), numHits);
     VELOX_CHECK_EQ(inputHitIndices_->size() / sizeof(vector_size_t), numHits);
-    return std::make_unique<LookupResult>(inputHitIndices_, lookupOutput_);
+    return std::make_unique<connector::IndexSource::Result>(
+        inputHitIndices_, lookupOutput_);
   } catch (const std::exception& e) {
     VELOX_CHECK(source_->error_.empty());
     source_->error_ = e.what();
@@ -546,13 +606,14 @@ TestIndexConnector::TestIndexConnector(
 
 std::shared_ptr<connector::IndexSource> TestIndexConnector::createIndexSource(
     const RowTypePtr& inputType,
-    size_t numJoinKeys,
     const std::vector<core::IndexLookupConditionPtr>& joinConditions,
     const RowTypePtr& outputType,
     const connector::ConnectorTableHandlePtr& tableHandle,
     const connector::ColumnHandleMap& columnHandles,
     connector::ConnectorQueryCtx* connectorQueryCtx) {
-  VELOX_CHECK_GE(inputType->size(), numJoinKeys + joinConditions.size());
+  const size_t numEqualJoinKeys = countEqualJoinKeys(joinConditions);
+  VELOX_CHECK_GE(inputType->size(), numEqualJoinKeys);
+
   auto testIndexTableHandle =
       std::dynamic_pointer_cast<const TestIndexTableHandle>(tableHandle);
   VELOX_CHECK_NOT_NULL(testIndexTableHandle);
@@ -572,7 +633,7 @@ std::shared_ptr<connector::IndexSource> TestIndexConnector::createIndexSource(
   return std::make_shared<TestIndexSource>(
       inputType,
       outputType,
-      numJoinKeys,
+      numEqualJoinKeys,
       joinConditionExpr,
       testIndexTableHandle,
       testColumnHandles,
diff --git a/velox/exec/tests/utils/TestIndexStorageConnector.h b/velox/exec/tests/utils/TestIndexStorageConnector.h
index d9fbbe315e8..a4f3029031f 100644
--- a/velox/exec/tests/utils/TestIndexStorageConnector.h
+++ b/velox/exec/tests/utils/TestIndexStorageConnector.h
@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/exec/HashTable.h"
 #include "velox/type/Type.h"
 
@@ -30,6 +31,11 @@ struct TestIndexTable {
   RowTypePtr dataType;
   std::shared_ptr<BaseHashTable> table;
 
+  // Mutex to serialize concurrent access to the hash table. The hash table's
+  // hashers contain stateful DecodedVectors that are not thread-safe for
+  // concurrent joinProbe calls from multiple index sources.
+  mutable std::mutex mutex;
+
   TestIndexTable(
       RowTypePtr _keyType,
       RowTypePtr _dataType,
@@ -52,18 +58,21 @@ class TestIndexTableHandle : public connector::ConnectorTableHandle {
   explicit TestIndexTableHandle(
       std::string connectorId,
       std::shared_ptr<TestIndexTable> indexTable,
-      bool asyncLookup)
+      bool asyncLookup,
+      bool needsIndexSplit = false)
       : ConnectorTableHandle(std::move(connectorId)),
         indexTable_(std::move(indexTable)),
-        asyncLookup_(asyncLookup) {}
+        asyncLookup_(asyncLookup),
+        needsIndexSplit_(needsIndexSplit) {}
 
   ~TestIndexTableHandle() override = default;
 
   std::string toString() const override {
     return fmt::format(
-        "IndexTableHandle: num of rows: {}, asyncLookup: {}",
+        "IndexTableHandle: num of rows: {}, asyncLookup: {}, needsIndexSplit: {}",
         indexTable_ ? indexTable_->table->rows()->numRows() : 0,
-        asyncLookup_);
+        asyncLookup_,
+        needsIndexSplit_);
   }
 
   const std::string& name() const override {
@@ -80,6 +89,7 @@ class TestIndexTableHandle : public connector::ConnectorTableHandle {
     obj["name"] = name();
     obj["connectorId"] = connectorId();
     obj["asyncLookup"] = asyncLookup_;
+    obj["needsIndexSplit"] = needsIndexSplit_;
     // For testing purpose only, we serialize the index table pointer as an
     // long integer.
     obj["indexTable"] = reinterpret_cast<int64_t>(indexTable_.get());
@@ -96,7 +106,8 @@ class TestIndexTableHandle : public connector::ConnectorTableHandle {
     return std::make_shared<TestIndexTableHandle>(
         obj["connectorId"].getString(),
         std::shared_ptr<TestIndexTable>(indexTablePtr, [](TestIndexTable*) {}),
-        obj["asyncLookup"].asBool());
+        obj["asyncLookup"].asBool(),
+        obj["needsIndexSplit"].asBool());
   }
 
   static void registerSerDe() {
@@ -113,13 +124,53 @@ class TestIndexTableHandle : public connector::ConnectorTableHandle {
     return asyncLookup_;
   }
 
+  /// If true, the index source requires a split to perform lookup. This is for
+  /// testing the split collection logic in the IndexLookupJoin operator.
+  bool needsIndexSplit() const override {
+    return needsIndexSplit_;
+  }
+
  private:
   const std::shared_ptr<TestIndexTable> indexTable_;
   const bool asyncLookup_;
+  const bool needsIndexSplit_;
 };
 
 using TestIndexTableHandlePtr = std::shared_ptr<const TestIndexTableHandle>;
 
+/// A fake split class for testing the split collection logic in the
+/// IndexLookupJoin operator. The test index source doesn't actually use splits,
+/// but this is used to verify the split passing mechanism works correctly.
+class TestIndexConnectorSplit : public connector::ConnectorSplit {
+ public:
+  explicit TestIndexConnectorSplit(std::string connectorId)
+      : ConnectorSplit(std::move(connectorId)) {}
+
+  std::string toString() const override {
+    return "TestIndexConnectorSplit";
+  }
+
+  folly::dynamic serialize() const override {
+    folly::dynamic obj = folly::dynamic::object;
+    obj["name"] = "TestIndexConnectorSplit";
+    obj["connectorId"] = connectorId;
+    return obj;
+  }
+
+  static std::shared_ptr<TestIndexConnectorSplit> create(
+      const folly::dynamic& obj) {
+    return std::make_shared<TestIndexConnectorSplit>(
+        obj["connectorId"].getString());
+  }
+
+  static void registerSerDe() {
+    auto& registry = DeserializationWithContextRegistryForSharedPtr();
+    registry.Register(
+        "TestIndexConnectorSplit",
+        [](const folly::dynamic& obj, void*) { return create(obj); });
+  }
+};
+
 class TestIndexColumnHandle : public connector::ColumnHandle {
  public:
   explicit TestIndexColumnHandle(std::string name) : name_{std::move(name)} {}
@@ -165,8 +216,15 @@ class TestIndexSource : public connector::IndexSource,
       connector::ConnectorQueryCtx* connectorQueryCtx,
       folly::Executor* executor);
 
-  std::shared_ptr<LookupResultIterator> lookup(
-      const LookupRequest& request) override;
+  void addSplits(
+      std::vector<std::shared_ptr<connector::ConnectorSplit>> splits) override {
+    VELOX_CHECK(tableHandle_->needsIndexSplit());
+    VELOX_CHECK(!splits.empty());
+    VELOX_CHECK(splits_.empty());
+    splits_ = std::move(splits);
+  }
+
+  std::shared_ptr<ResultIterator> lookup(const Request& request) override;
 
   std::unordered_map<std::string, RuntimeMetric> runtimeStats() override;
 
@@ -186,15 +244,17 @@ class TestIndexSource : public connector::IndexSource,
     return lookupOutputProjections_;
   }
 
-  class ResultIterator : public LookupResultIterator {
+  class ResultIterator : public connector::IndexSource::ResultIterator {
    public:
     ResultIterator(
         std::shared_ptr<TestIndexSource> source,
-        const LookupRequest& request,
+        const Request& request,
         std::unique_ptr<HashLookup> lookupResult,
         folly::Executor* executor);
 
-    std::optional<std::unique_ptr<LookupResult>> next(
+    bool hasNext() override;
+
+    std::optional<std::unique_ptr<connector::IndexSource::Result>> next(
         vector_size_t size,
         ContinueFuture& future) override;
 
@@ -236,16 +296,17 @@ class TestIndexSource : public connector::IndexSource,
 
     // Synchronously lookup the index table and return up to 'size' number of
     // output rows in result.
-    std::unique_ptr<LookupResult> syncLookup(vector_size_t size);
+    std::unique_ptr<connector::IndexSource::Result> syncLookup(
+        vector_size_t size);
 
     const std::shared_ptr<TestIndexSource> source_;
-    const LookupRequest request_;
+    const Request request_;
     const std::unique_ptr<HashLookup> lookupResult_;
     folly::Executor* const executor_{nullptr};
 
     std::atomic_bool hasPendingRequest_{false};
     std::unique_ptr<BaseHashTable::JoinResultIterator> lookupResultIter_;
-    std::optional<std::unique_ptr<LookupResult>> asyncResult_;
+    std::optional<std::unique_ptr<connector::IndexSource::Result>> asyncResult_;
 
     // The reusable buffers for lookup result processing.
     // The input row number in lookup request for each matched result which is
@@ -294,7 +355,7 @@ class TestIndexSource : public connector::IndexSource,
   const std::shared_ptr<memory::MemoryPool> pool_;
   folly::Executor* const executor_;
 
-  mutable std::mutex mutex_;
+  std::mutex mutex_;
 
   // Join condition filter input type.
   RowTypePtr conditionInputType_;
@@ -311,6 +372,11 @@ class TestIndexSource : public connector::IndexSource,
   std::vector<IdentityProjection> conditionTableProjections_;
   std::vector<IdentityProjection> lookupOutputProjections_;
   std::unordered_map<std::string, RuntimeMetric> runtimeStats_;
+
+  // Collected splits for the index source (if tableHandle_->needsIndexSplit()
+  // returns true). This is only used for testing the split interface but not
+  // actually used in the lookup.
+  std::vector<std::shared_ptr<connector::ConnectorSplit>> splits_;
 };
 
 class TestIndexConnector : public connector::Connector {
@@ -334,7 +400,6 @@ class TestIndexConnector : public connector::Connector {
 
   std::shared_ptr<connector::IndexSource> createIndexSource(
       const RowTypePtr& inputType,
-      size_t numJoinKeys,
       const std::vector<core::IndexLookupConditionPtr>& joinConditions,
       const RowTypePtr& outputType,
       const connector::ConnectorTableHandlePtr& tableHandle,
@@ -370,7 +435,8 @@ class TestIndexConnectorFactory : public connector::ConnectorFactory {
     TestIndexConnectorFactory factory;
     std::shared_ptr<connector::Connector> connector =
         factory.newConnector(kTestIndexConnectorName, {}, nullptr, cpuExecutor);
-    connector::registerConnector(connector);
+    connector::ConnectorRegistry::global().insert(
+        connector->connectorId(), connector);
   }
 };
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/TpcdsQueryBuilder.cpp b/velox/exec/tests/utils/TpcdsQueryBuilder.cpp
new file mode 100644
index 00000000000..8c474697210
--- /dev/null
+++ b/velox/exec/tests/utils/TpcdsQueryBuilder.cpp
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/exec/tests/utils/TpcdsQueryBuilder.h"
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/connectors/ConnectorRegistry.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+
+#include <filesystem>
+namespace fs = std::filesystem;
+
+namespace {
+
+/// Try to find data files for a table name. First tries exact match,
+/// then strips any schema prefix (e.g. "tpcds.store_sales" ->
+/// "store_sales").
+const std::vector<std::string>* findDataFiles(
+    const std::unordered_map<std::string, std::vector<std::string>>&
+        tableDataFiles,
+    const std::string& tableName) {
+  auto it = tableDataFiles.find(tableName);
+  if (it != tableDataFiles.end() && !it->second.empty()) {
+    return &it->second;
+  }
+
+  auto dotPos = tableName.rfind('.');
+  if (dotPos != std::string::npos) {
+    it = tableDataFiles.find(tableName.substr(dotPos + 1));
+    if (it != tableDataFiles.end() && !it->second.empty()) {
+      return &it->second;
+    }
+  }
+
+  return nullptr;
+}
+
+} // namespace
+
+namespace facebook::velox::exec::test {
+
+TpcdsQueryBuilder::TpcdsQueryBuilder(dwio::common::FileFormat format)
+    : format_(format) {}
+
+void TpcdsQueryBuilder::initialize(const std::string& dataPath) {
+  tableDataFiles_.clear();
+
+  std::error_code ec;
+  for (auto const& tableEntry :
+       fs::directory_iterator{dataPath, fs::directory_options(), ec}) {
+    if (!tableEntry.is_directory()) {
+      continue;
+    }
+    const auto tableName = tableEntry.path().filename().string();
+
+    // Skip hidden directories.
+    if (tableName.empty() || tableName[0] == '.') {
+      continue;
+    }
+
+    auto& files = tableDataFiles_[tableName];
+
+    std::error_code fileEc;
+    for (auto const& fileEntry : fs::directory_iterator{
+             tableEntry.path(), fs::directory_options(), fileEc}) {
+      if (!fileEntry.is_regular_file()) {
+        continue;
+      }
+      // Skip hidden files.
+      if (fileEntry.path().filename().c_str()[0] == '.') {
+        continue;
+      }
+      files.push_back(fileEntry.path().string());
+    }
+
+    // Sort for deterministic ordering.
+    std::sort(files.begin(), files.end());
+  }
+
+  VELOX_USER_CHECK(
+      !tableDataFiles_.empty(),
+      "No table subdirectories found in data path: {}",
+      dataPath);
+}
+
+void TpcdsQueryBuilder::registerHiveConnector(
+    const std::string& connectorId,
+    folly::Executor* /*ioExecutor*/) {
+  auto hiveConnector = connector::hive::HiveConnectorFactory().newConnector(
+      connectorId,
+      std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>()));
+  connector::ConnectorRegistry::global().insert(
+      hiveConnector->connectorId(), hiveConnector);
+}
+
+VeloxPlan TpcdsQueryBuilder::getQueryPlan(
+    int queryId,
+    const std::string& planDir,
+    memory::MemoryPool* pool) {
+  VeloxPlanLoader loader(planDir, pool);
+  auto veloxPlan = loader.loadPlanByQueryId(queryId);
+
+  // Collect all TableScan nodes from the plan tree.
+  auto scanNodes = VeloxPlanLoader::collectTableScanNodes(veloxPlan.plan);
+
+  // Detect connector ID from the plan's TableScan nodes.
+  // Presto plans typically use "hive" while the test fixture registers
+  // "test-hive". We need to register a connector under the plan's ID.
+  if (!scanNodes.empty() && connectorId_.empty()) {
+    connectorId_ = scanNodes[0]->tableHandle()->connectorId();
+    LOG(INFO) << "TpcdsQueryBuilder: detected connector ID '" << connectorId_
+              << "' from plan";
+
+    if (connector::ConnectorRegistry::tryGet(connectorId_) == nullptr) {
+      registerHiveConnector(connectorId_);
+      ownedConnector_ = true;
+      LOG(INFO) << "TpcdsQueryBuilder: registered connector under ID '"
+                << connectorId_ << "'";
+    }
+  }
+
+  // For each TableScan, look up the table name and populate data files.
+  for (const auto& scanNode : scanNodes) {
+    const auto& tableName = scanNode->tableHandle()->name();
+
+    const auto* files = findDataFiles(tableDataFiles_, tableName);
+    if (files) {
+      veloxPlan.dataFiles[scanNode->id()] = *files;
+    } else {
+      LOG(WARNING) << "TpcdsQueryBuilder: no data files found for table '"
+                   << tableName << "' (scan node " << scanNode->id() << ")";
+    }
+  }
+
+  veloxPlan.dataFileFormat = format_;
+  return veloxPlan;
+}
+
+std::shared_ptr<connector::ConnectorSplit> TpcdsQueryBuilder::makeSplit(
+    const std::string& filePath) const {
+  const auto& id = connectorId_.empty() ? kHiveConnectorId : connectorId_;
+  return connector::hive::HiveConnectorSplitBuilder(filePath)
+      .connectorId(id)
+      .fileFormat(format_)
+      .build();
+}
+
+void TpcdsQueryBuilder::shutdown() {
+  if (ownedConnector_ && !connectorId_.empty()) {
+    connector::ConnectorRegistry::global().erase(connectorId_);
+    ownedConnector_ = false;
+  }
+  connectorId_.clear();
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/TpcdsQueryBuilder.h b/velox/exec/tests/utils/TpcdsQueryBuilder.h
new file mode 100644
index 00000000000..516cc7e1125
--- /dev/null
+++ b/velox/exec/tests/utils/TpcdsQueryBuilder.h
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/dwio/common/Options.h"
+#include "velox/exec/tests/utils/VeloxPlanLoader.h"
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace facebook::velox::exec::test {
+
+/// Builds TPC-DS query plans from pre-dumped JSON plan files and data files
+/// located in a given data directory. Each table's data must be placed in
+/// hive-style partitioning: a sub-directory per table name under the data path.
+///
+/// Example:
+///   ls /gds/datasets/tpcds/sf100/
+///     store_sales/  customer/  item/  ...
+///
+///   ls /gds/datasets/tpcds/sf100/store_sales/
+///     store_sales_part-00000.parquet  store_sales_part-00001.parquet  ...
+///
+/// This class is CuDF-free. To use CudfHiveConnector instead of HiveConnector,
+/// subclass and override registerConnector().
+class TpcdsQueryBuilder {
+ public:
+  explicit TpcdsQueryBuilder(
+      dwio::common::FileFormat format = dwio::common::FileFormat::PARQUET);
+
+  virtual ~TpcdsQueryBuilder() = default;
+
+  /// Scan dataPath for table subdirectories and collect all data file paths
+  /// per table.
+  void initialize(const std::string& dataPath);
+
+  /// Load the deserialized plan from JSON (via VeloxPlanLoader) and populate
+  /// dataFiles for each TableScan node by matching table names to the
+  /// discovered data files in the data path.
+  ///
+  /// The connector ID is auto-detected from the plan's TableScan nodes (e.g.
+  /// Presto plans use "hive"). If no connector is registered under that ID,
+  /// registerConnector() is called to register one.
+  ///
+  /// Table name matching is flexible: if the exact name from the plan (e.g.
+  /// "tpcds.store_sales") doesn't match a data directory, the part after the
+  /// last '.' is tried (e.g. "store_sales").
+  ///
+  /// @param queryId TPC-DS query number (1..99)
+  /// @param planDir Directory containing plan JSON files (Q1.json, ...)
+  /// @param pool Memory pool for plan deserialization
+  VeloxPlan getQueryPlan(
+      int queryId,
+      const std::string& planDir,
+      memory::MemoryPool* pool);
+
+  /// Create a ConnectorSplit for a given file path using HiveConnectorSplit.
+  /// The connector ID used matches the one discovered from the plan.
+  std::shared_ptr<connector::ConnectorSplit> makeSplit(
+      const std::string& filePath) const;
+
+  /// Clean up: unregisters any connector that was auto-registered by
+  /// getQueryPlan.
+  virtual void shutdown();
+
+  /// Returns the connector ID discovered from the plan.
+  const std::string& connectorId() const {
+    return connectorId_;
+  }
+
+ protected:
+  /// Called when a connector needs to be registered for the given ID.
+  /// Default implementation registers a HiveConnector.
+  /// Override in subclasses to register CudfHiveConnector or others.
+  /// @param connectorId The connector ID from the plan.
+  /// @param ioExecutor Optional IO executor.
+  virtual void registerHiveConnector(
+      const std::string& connectorId,
+      folly::Executor* ioExecutor = nullptr);
+
+  dwio::common::FileFormat format_;
+  /// Connector ID auto-detected from the plan's TableScan nodes.
+  std::string connectorId_;
+  /// Whether we registered a connector ourselves (need to unregister on
+  /// shutdown).
+  bool ownedConnector_{false};
+
+ private:
+  /// tableName -> list of data file paths
+  std::unordered_map<std::string, std::vector<std::string>> tableDataFiles_;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/TpchQueryBuilder.cpp b/velox/exec/tests/utils/TpchQueryBuilder.cpp
index 75df732e2a2..d7bfd6bfa00 100644
--- a/velox/exec/tests/utils/TpchQueryBuilder.cpp
+++ b/velox/exec/tests/utils/TpchQueryBuilder.cpp
@@ -70,7 +70,9 @@ void TpchQueryBuilder::readFileSchema(
     const std::string& tableName,
     const std::string& filePath,
     const std::vector<std::string>& columns) {
-  dwio::common::ReaderOptions readerOptions{pool_.get()};
+  dwio::common::ReaderOptions readerOptions(pool_.get());
+  readerOptions.setDataIoStats(dataIoStats_);
+  readerOptions.setMetadataIoStats(metadataIoStats_);
   readerOptions.setFileFormat(format_);
   auto uniqueReadFile =
       filesystems::getFileSystem(filePath, nullptr)->openFileForRead(filePath);
diff --git a/velox/exec/tests/utils/TpchQueryBuilder.h b/velox/exec/tests/utils/TpchQueryBuilder.h
index 30a1ef050bd..a444c1d8951 100644
--- a/velox/exec/tests/utils/TpchQueryBuilder.h
+++ b/velox/exec/tests/utils/TpchQueryBuilder.h
@@ -15,18 +15,14 @@
  */
 #pragma once
 
+#include "velox/common/io/IoStatistics.h"
 #include "velox/dwio/common/Options.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/VeloxPlanLoader.h"
 
 namespace facebook::velox::exec::test {
 
-/// Contains the query plan and input data files keyed on source plan node ID.
-/// All data files use the same file format specified in 'dataFileFormat'.
-struct TpchPlan {
-  core::PlanNodePtr plan;
-  std::unordered_map<core::PlanNodeId, std::vector<std::string>> dataFiles;
-  dwio::common::FileFormat dataFileFormat;
-};
+using TpchPlan = VeloxPlan;
 
 /// Contains type information, data files, and file column names for a table.
 /// This information is inferred from the input data files.
@@ -149,6 +145,10 @@ class TpchQueryBuilder {
   static constexpr const char* kPartsupp = "partsupp";
   std::shared_ptr<memory::MemoryPool> pool_ =
       memory::memoryManager()->addLeafPool();
+  std::shared_ptr<io::IoStatistics> dataIoStats_ =
+      std::make_shared<io::IoStatistics>();
+  std::shared_ptr<io::IoStatistics> metadataIoStats_ =
+      std::make_shared<io::IoStatistics>();
   const bool filtersAsNode_;
 };
 
diff --git a/velox/exec/tests/utils/VeloxPlanLoader.cpp b/velox/exec/tests/utils/VeloxPlanLoader.cpp
new file mode 100644
index 00000000000..f50d9136e63
--- /dev/null
+++ b/velox/exec/tests/utils/VeloxPlanLoader.cpp
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/exec/tests/utils/VeloxPlanLoader.h"
+#include <folly/json.h>
+#include <cstdlib>
+#include <fstream>
+#include <sstream>
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/serialization/Serializable.h"
+#include "velox/core/PlanNode.h"
+
+#if __has_include("filesystem")
+#include <filesystem>
+namespace fs = std::filesystem;
+#else
+#include <experimental/filesystem>
+namespace fs = std::experimental::filesystem;
+#endif
+
+namespace facebook::velox::exec::test {
+
+namespace {
+
+void collectTableScanNodesRecursive(
+    const core::PlanNodePtr& node,
+    std::vector<core::TableScanNodePtr>& out) {
+  if (auto scan = std::dynamic_pointer_cast<const core::TableScanNode>(node)) {
+    out.push_back(scan);
+  }
+  for (const auto& source : node->sources()) {
+    collectTableScanNodesRecursive(source, out);
+  }
+}
+
+std::string readFileToString(const std::string& path) {
+  std::ifstream in(path);
+  if (!in) {
+    VELOX_FAIL("Failed to open plan file: {}", path);
+  }
+  std::stringstream buffer;
+  buffer << in.rdbuf();
+  return buffer.str();
+}
+
+} // namespace
+
+// static
+std::string VeloxPlanLoader::resolvePlanDirectory(
+    const std::string& defaultDir,
+    const std::string& envVarName) {
+  if (!envVarName.empty()) {
+    const char* env = std::getenv(envVarName.c_str());
+    if (env && *env != '\0') {
+      return std::string(env);
+    }
+  }
+  return defaultDir;
+}
+
+VeloxPlanLoader::VeloxPlanLoader(
+    const std::string& planDirectory,
+    memory::MemoryPool* pool,
+    bool stripPartitionedOutput)
+    : planDir_(planDirectory),
+      pool_(pool),
+      stripPartitionedOutput_(stripPartitionedOutput) {
+  if (pool_ == nullptr) {
+    ownedPool_ = memory::memoryManager()->addLeafPool("VeloxPlanLoader");
+    pool_ = ownedPool_.get();
+  }
+}
+
+std::string VeloxPlanLoader::pathForQuery(int queryId) const {
+  const std::string path = planDir_ + "/Q" + std::to_string(queryId) + ".json";
+  if (fs::exists(path)) {
+    return path;
+  }
+  VELOX_USER_FAIL("Plan file does not exist: {}", path);
+}
+
+void VeloxPlanLoader::maybeStripPartitionedOutput(
+    core::PlanNodePtr& plan) const {
+  if (!stripPartitionedOutput_ || !plan) {
+    return;
+  }
+  if (auto partitionedOutput =
+          std::dynamic_pointer_cast<const core::PartitionedOutputNode>(plan)) {
+    VELOX_CHECK_EQ(
+        partitionedOutput->sources().size(),
+        1,
+        "PartitionedOutput should have exactly one source");
+    plan = partitionedOutput->sources()[0];
+    LOG(INFO) << "VeloxPlanLoader: stripped PartitionedOutput root from plan";
+  }
+}
+
+VeloxPlan VeloxPlanLoader::loadPlan(const std::string& path) const {
+  const std::string contents = readFileToString(path);
+  folly::dynamic planJson;
+  try {
+    planJson = folly::parseJson(contents);
+  } catch (const std::exception& e) {
+    VELOX_FAIL("Failed to parse plan JSON from {}: {}", path, e.what());
+  }
+  core::PlanNodePtr plan;
+  try {
+    plan = velox::ISerializable::deserialize<core::PlanNode>(planJson, pool_);
+  } catch (const std::exception& e) {
+    VELOX_FAIL("Failed to deserialize plan from {}: {}", path, e.what());
+  }
+  maybeStripPartitionedOutput(plan);
+  VeloxPlan result;
+  result.plan = std::move(plan);
+  result.dataFiles = {};
+  result.dataFileFormat = dwio::common::FileFormat::PARQUET;
+  return result;
+}
+
+VeloxPlan VeloxPlanLoader::loadPlanByQueryId(int queryId) const {
+  VELOX_USER_CHECK(
+      queryId >= 1 && queryId <= 99, "queryId must be 1..99, got {}", queryId);
+  std::string path = pathForQuery(queryId);
+  return loadPlan(path);
+}
+
+// static
+std::vector<core::TableScanNodePtr> VeloxPlanLoader::collectTableScanNodes(
+    const core::PlanNodePtr& plan) {
+  std::vector<core::TableScanNodePtr> out;
+  if (plan) {
+    collectTableScanNodesRecursive(plan, out);
+  }
+  return out;
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/VeloxPlanLoader.h b/velox/exec/tests/utils/VeloxPlanLoader.h
new file mode 100644
index 00000000000..a4e9694c7fc
--- /dev/null
+++ b/velox/exec/tests/utils/VeloxPlanLoader.h
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <string>
+#include <vector>
+#include "velox/core/PlanNode.h"
+#include "velox/dwio/common/Options.h"
+
+namespace facebook::velox::exec::test {
+
+/// Contains a deserialized Velox query plan and optional data files keyed on
+/// source plan node ID. TpchPlan (in TpchQueryBuilder.h) is a type alias for
+/// this struct.
+struct VeloxPlan {
+  core::PlanNodePtr plan;
+  std::unordered_map<core::PlanNodeId, std::vector<std::string>> dataFiles;
+  dwio::common::FileFormat dataFileFormat{dwio::common::FileFormat::PARQUET};
+};
+
+/// Generic loader for Velox plan JSON files (e.g. dumped from a Presto
+/// worker's plan-dump-dir). Not specific to any benchmark suite -- works for
+/// TPC-DS, TPC-H, or any arbitrary single-node query plan.
+///
+/// Plan directory layout (for loadPlanByQueryId):
+/// - Canonical names Q1.json, Q2.json, ... Q99.json.
+///
+/// When stripPartitionedOutput is true (default), the loader strips the
+/// PartitionedOutput root node that Presto always adds for distributed
+/// shuffle. This makes the plan runnable locally via AssertQueryBuilder /
+/// TaskCursor.
+class VeloxPlanLoader {
+ public:
+  /// @param planDirectory  Directory containing plan JSON files.
+  /// @param pool           Memory pool for plan deserialization. If nullptr,
+  ///                       a leaf pool is created from the global
+  ///                       MemoryManager (which must already be initialized).
+  /// @param stripPartitionedOutput  If true, strip PartitionedOutput root.
+  VeloxPlanLoader(
+      const std::string& planDirectory,
+      memory::MemoryPool* pool = nullptr,
+      bool stripPartitionedOutput = true);
+
+  /// Resolve a plan directory from either an environment variable or a
+  /// supplied default. If envVarName is non-empty and the env var is set, its
+  /// value is used; otherwise defaultDir is returned.
+  static std::string resolvePlanDirectory(
+      const std::string& defaultDir,
+      const std::string& envVarName = "");
+
+  /// Load a plan from a specific file path.
+  VeloxPlan loadPlan(const std::string& path) const;
+
+  /// Load plan by query ID (1..99). Looks for planDir/Q{id}.json.
+  VeloxPlan loadPlanByQueryId(int queryId) const;
+
+  /// Collects all TableScan plan nodes in the plan tree.
+  static std::vector<core::TableScanNodePtr> collectTableScanNodes(
+      const core::PlanNodePtr& plan);
+
+ private:
+  std::string planDir_;
+  memory::MemoryPool* pool_;
+  std::shared_ptr<memory::MemoryPool> ownedPool_;
+  bool stripPartitionedOutput_;
+
+  std::string pathForQuery(int queryId) const;
+
+  /// If stripPartitionedOutput_ is true and the plan root is a
+  /// PartitionedOutputNode, replace it with its single child.
+  void maybeStripPartitionedOutput(core::PlanNodePtr& plan) const;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/trace/CMakeLists.txt b/velox/exec/trace/CMakeLists.txt
new file mode 100644
index 00000000000..8a4803ef14b
--- /dev/null
+++ b/velox/exec/trace/CMakeLists.txt
@@ -0,0 +1,34 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+velox_add_library(
+  velox_trace
+  Trace.cpp
+  TraceUtil.cpp
+  HEADERS
+  Trace.h
+  TraceCtx.h
+  TraceUtil.h
+  TraceWriter.h
+)
+
+velox_link_libraries(
+  velox_trace
+  velox_common_base
+  velox_exception
+  velox_file
+  velox_core
+  velox_type
+  velox_vector
+)
diff --git a/velox/exec/Trace.cpp b/velox/exec/trace/Trace.cpp
similarity index 97%
rename from velox/exec/Trace.cpp
rename to velox/exec/trace/Trace.cpp
index 6ff55787fc5..f50f5948a73 100644
--- a/velox/exec/Trace.cpp
+++ b/velox/exec/trace/Trace.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "velox/exec/Trace.h"
+#include "velox/exec/trace/Trace.h"
 
 #include <fmt/core.h>
 
diff --git a/velox/exec/Trace.h b/velox/exec/trace/Trace.h
similarity index 58%
rename from velox/exec/Trace.h
rename to velox/exec/trace/Trace.h
index 699de5253cd..cd473680d1e 100644
--- a/velox/exec/Trace.h
+++ b/velox/exec/trace/Trace.h
@@ -19,31 +19,33 @@
 #include <cstdint>
 #include <optional>
 #include <string>
+#include <string_view>
 
 namespace facebook::velox::exec::trace {
+
 /// Defines the shared constants used by query trace implementation.
 struct TraceTraits {
-  static inline const std::string kPlanNodeKey = "planNode";
-  static inline const std::string kQueryConfigKey = "queryConfig";
-  static inline const std::string kConnectorPropertiesKey =
+  static constexpr std::string_view kPlanNodeKey = "planNode";
+  static constexpr std::string_view kQueryConfigKey = "queryConfig";
+  static constexpr std::string_view kConnectorPropertiesKey =
       "connectorProperties";
 
-  static inline const std::string kTaskMetaFileName = "task_trace_meta.json";
+  static constexpr std::string_view kTaskMetaFileName = "task_trace_meta.json";
 };
 
 struct OperatorTraceTraits {
-  static inline const std::string kSummaryFileName = "op_trace_summary.json";
-  static inline const std::string kInputFileName = "op_input_trace.data";
-  static inline const std::string kSplitFileName = "op_split_trace.split";
+  static constexpr std::string_view kSummaryFileName = "op_trace_summary.json";
+  static constexpr std::string_view kInputFileName = "op_input_trace.data";
+  static constexpr std::string_view kSplitFileName = "op_split_trace.split";
 
   /// Keys for operator trace summary file.
-  static inline const std::string kOpTypeKey = "opType";
-  static inline const std::string kPeakMemoryKey = "peakMemory";
-  static inline const std::string kInputRowsKey = "inputRows";
-  static inline const std::string kInputBytesKey = "inputBytes";
-  static inline const std::string kRawInputRowsKey = "rawInputRows";
-  static inline const std::string kRawInputBytesKey = "rawInputBytes";
-  static inline const std::string kNumSplitsKey = "numSplits";
+  static constexpr std::string_view kOpTypeKey = "opType";
+  static constexpr std::string_view kPeakMemoryKey = "peakMemory";
+  static constexpr std::string_view kInputRowsKey = "inputRows";
+  static constexpr std::string_view kInputBytesKey = "inputBytes";
+  static constexpr std::string_view kRawInputRowsKey = "rawInputRows";
+  static constexpr std::string_view kRawInputBytesKey = "rawInputBytes";
+  static constexpr std::string_view kNumSplitsKey = "numSplits";
 };
 
 /// Contains the summary of an operator trace.
diff --git a/velox/exec/trace/TraceCtx.h b/velox/exec/trace/TraceCtx.h
new file mode 100644
index 00000000000..2c171c2b917
--- /dev/null
+++ b/velox/exec/trace/TraceCtx.h
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <string_view>
+#include "velox/exec/trace/TraceWriter.h"
+
+namespace facebook::velox::exec {
+class Operator;
+}
+
+namespace facebook::velox::exec::trace {
+
+class TraceCtx {
+ public:
+  TraceCtx(bool dryRun) : dryRun_(dryRun) {}
+
+  virtual ~TraceCtx() = default;
+
+  /// Overwrite the methods below to provide a concrete trace writer
+  /// implementation for input, split, and task metadata.
+  virtual std::unique_ptr<trace::TraceInputWriter> createInputTracer(
+      Operator&) const {
+    return nullptr;
+  }
+
+  virtual std::unique_ptr<trace::TraceSplitWriter> createSplitTracer(
+      Operator&) const {
+    return nullptr;
+  }
+
+  virtual std::unique_ptr<trace::TraceMetadataWriter> createMetadataTracer()
+      const {
+    return nullptr;
+  }
+
+  /// Returns whether a particular operator should be traced. Called before the
+  /// task starts execution, when operators are instantiated.
+  virtual bool shouldTrace(const Operator&) const {
+    return false;
+  }
+
+  /// Returns whether a particular expression function should be traced. Called
+  /// during operator initialization in Expr::maybeSetupTracer().
+  virtual bool shouldTraceExpr(std::string_view /*functionName*/) const {
+    return false;
+  }
+
+  /// Creates a writer for capturing output batches from a traced expression.
+  /// The instanceIndex distinguishes multiple Expr nodes with the same
+  /// function name within a single operator. Ownership is transferred to the
+  /// caller.
+  virtual std::unique_ptr<trace::TraceExprWriter> createExprOutputTracer(
+      const Operator& /*op*/,
+      std::string_view /*functionName*/,
+      int /*instanceIndex*/) const {
+    return nullptr;
+  }
+
+  bool dryRun() const {
+    return dryRun_;
+  }
+
+ private:
+  /// If true, we only collect operator input trace without the actual
+  /// execution. This is used by crash debugging so that we can collect the
+  /// input that triggers the crash.
+  bool dryRun_{false};
+};
+
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/TraceUtil.cpp b/velox/exec/trace/TraceUtil.cpp
similarity index 78%
rename from velox/exec/TraceUtil.cpp
rename to velox/exec/trace/TraceUtil.cpp
index f2f9c49d8aa..58c721e7c3c 100644
--- a/velox/exec/TraceUtil.cpp
+++ b/velox/exec/trace/TraceUtil.cpp
@@ -14,20 +14,21 @@
  * limitations under the License.
  */
 
-#include "velox/exec/TraceUtil.h"
+#include "velox/exec/trace/TraceUtil.h"
 
 #include <folly/json.h>
-
 #include <utility>
 
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/file/File.h"
 #include "velox/common/file/FileSystems.h"
-#include "velox/exec/TableWriter.h"
-#include "velox/exec/Trace.h"
+#include "velox/core/TableWriteTraits.h"
+#include "velox/exec/OperatorType.h"
+#include "velox/exec/trace/Trace.h"
 
 namespace facebook::velox::exec::trace {
 namespace {
+
 std::string findLastPathNode(const std::string& path) {
   std::vector<std::string> pathNodes;
   folly::split("/", path, pathNodes);
@@ -38,51 +39,11 @@ std::string findLastPathNode(const std::string& path) {
   return pathNodes.back();
 }
 
-const std::vector<core::PlanNodePtr> kEmptySources;
-
-class DummySourceNode final : public core::PlanNode {
- public:
-  explicit DummySourceNode(RowTypePtr outputType)
-      : PlanNode(""), outputType_(std::move(outputType)) {}
-
-  const RowTypePtr& outputType() const override {
-    return outputType_;
-  }
-
-  const std::vector<core::PlanNodePtr>& sources() const override {
-    return kEmptySources;
-  }
-
-  std::string_view name() const override {
-    return "DummySource";
-  }
-
-  folly::dynamic serialize() const override {
-    folly::dynamic obj = folly::dynamic::object;
-    obj["name"] = "DummySource";
-    obj["outputType"] = outputType_->serialize();
-    return obj;
-  }
-
-  static core::PlanNodePtr create(const folly::dynamic& obj, void* context) {
-    return std::make_shared<DummySourceNode>(
-        ISerializable::deserialize<RowType>(obj["outputType"]));
-  }
-
- private:
-  void addDetails(std::stringstream& stream) const override {
-    // Nothing to add.
-  }
-
-  const RowTypePtr outputType_;
-};
-
-void registerDummySourceSerDe();
-
 std::unordered_map<std::string, TraceNodeFactory>& traceNodeRegistry() {
   static std::unordered_map<std::string, TraceNodeFactory> registry;
   return registry;
 }
+
 } // namespace
 
 void createTraceDirectory(
@@ -123,13 +84,6 @@ std::string getQueryTraceDirectory(
   return fmt::format("{}/{}", normalizedTraceDir, queryId);
 }
 
-std::string getTaskTraceDirectory(
-    const std::string& traceDir,
-    const Task& task) {
-  return getTaskTraceDirectory(
-      traceDir, task.queryCtx()->queryId(), task.taskId());
-}
-
 std::string getTaskTraceDirectory(
     const std::string& traceDir,
     const std::string& queryId,
@@ -221,10 +175,8 @@ RowTypePtr getDataType(
     const core::PlanNodePtr& tracedPlan,
     const std::string& tracedNodeId,
     size_t sourceIndex) {
-  const auto* traceNode = core::PlanNode::findFirstNode(
-      tracedPlan.get(), [&tracedNodeId](const core::PlanNode* node) {
-        return node->id() == tracedNodeId;
-      });
+  const auto* traceNode =
+      core::PlanNode::findNodeById(tracedPlan.get(), tracedNodeId);
   VELOX_CHECK_NOT_NULL(
       traceNode,
       "traced node id {} not found in the traced plan",
@@ -285,17 +237,23 @@ std::vector<uint32_t> extractDriverIds(const std::string& driverIds) {
 }
 
 bool canTrace(const std::string& operatorType) {
-  static const std::unordered_set<std::string> kSupportedOperatorTypes{
-      "Aggregation",
-      "FilterProject",
-      "HashBuild",
-      "HashProbe",
-      "IndexLookupJoin",
-      "Unnest",
-      "PartialAggregation",
-      "PartitionedOutput",
-      "TableScan",
-      "TableWrite"};
+  static const std::unordered_set<std::string_view> kSupportedOperatorTypes{
+      OperatorType::kAggregation,
+      OperatorType::kCallbackSink,
+      OperatorType::kExchange,
+      OperatorType::kFilterProject,
+      OperatorType::kHashBuild,
+      OperatorType::kHashProbe,
+      OperatorType::kIndexLookupJoin,
+      OperatorType::kMergeExchange,
+      OperatorType::kMergeJoin,
+      OperatorType::kOrderBy,
+      OperatorType::kPartialAggregation,
+      OperatorType::kPartitionedOutput,
+      OperatorType::kTableScan,
+      OperatorType::kTableWrite,
+      OperatorType::kTopNRowNumber,
+      OperatorType::kUnnest};
   if (kSupportedOperatorTypes.count(operatorType) > 0 ||
       traceNodeRegistry().count(operatorType) > 0) {
     return true;
@@ -304,11 +262,9 @@ bool canTrace(const std::string& operatorType) {
 }
 
 core::PlanNodePtr getTraceNode(
-    const core::PlanNodePtr& plan,
+    const core::PlanNode& plan,
     core::PlanNodeId nodeId) {
-  const auto* traceNode = core::PlanNode::findFirstNode(
-      plan.get(),
-      [&nodeId](const core::PlanNode* node) { return node->id() == nodeId; });
+  const auto* traceNode = core::PlanNode::findNodeById(&plan, nodeId);
   VELOX_CHECK_NOT_NULL(traceNode, "Failed to find node with id {}", nodeId);
   if (const auto* hashJoinNode =
           dynamic_cast<const core::HashJoinNode*>(traceNode)) {
@@ -326,6 +282,21 @@ core::PlanNodePtr getTraceNode(
         hashJoinNode->outputType());
   }
 
+  if (const auto* mergeJoinNode =
+          dynamic_cast<const core::MergeJoinNode*>(traceNode)) {
+    return std::make_shared<core::MergeJoinNode>(
+        nodeId,
+        mergeJoinNode->joinType(),
+        mergeJoinNode->leftKeys(),
+        mergeJoinNode->rightKeys(),
+        mergeJoinNode->filter(),
+        std::make_shared<DummySourceNode>(
+            mergeJoinNode->sources()[0]->outputType()),
+        std::make_shared<DummySourceNode>(
+            mergeJoinNode->sources()[1]->outputType()),
+        mergeJoinNode->outputType());
+  }
+
   if (const auto* filterNode =
           dynamic_cast<const core::FilterNode*>(traceNode)) {
     // Single FilterNode.
@@ -380,6 +351,7 @@ core::PlanNodePtr getTraceNode(
         aggregationNode->globalGroupingSets(),
         aggregationNode->groupId(),
         aggregationNode->ignoreNullKeys(),
+        aggregationNode->noGroupsSpanBatches(),
         std::make_shared<DummySourceNode>(
             aggregationNode->sources().front()->outputType()));
   }
@@ -394,7 +366,7 @@ core::PlanNodePtr getTraceNode(
         partitionedOutputNode->isReplicateNullsAndAny(),
         partitionedOutputNode->partitionFunctionSpecPtr(),
         partitionedOutputNode->outputType(),
-        VectorSerde::Kind::kPresto,
+        "Presto",
         std::make_shared<DummySourceNode>(
             partitionedOutputNode->sources().front()->outputType()));
   }
@@ -407,7 +379,8 @@ core::PlanNodePtr getTraceNode(
         indexLookupJoinNode->leftKeys(),
         indexLookupJoinNode->rightKeys(),
         indexLookupJoinNode->joinConditions(),
-        indexLookupJoinNode->includeMatchColumn(),
+        indexLookupJoinNode->filter(),
+        indexLookupJoinNode->hasMarker(),
         std::make_shared<DummySourceNode>(
             indexLookupJoinNode->sources().front()->outputType()), // Probe side
         indexLookupJoinNode->lookupSource(), // Index side
@@ -432,7 +405,7 @@ core::PlanNodePtr getTraceNode(
         tableWriteNode->columnStatsSpec(),
         tableWriteNode->insertTableHandle(),
         tableWriteNode->hasPartitioningScheme(),
-        TableWriteTraits::outputType(tableWriteNode->columnStatsSpec()),
+        core::TableWriteTraits::outputType(tableWriteNode->columnStatsSpec()),
         tableWriteNode->commitStrategy(),
         std::make_shared<DummySourceNode>(
             tableWriteNode->sources().front()->outputType()));
@@ -446,11 +419,56 @@ core::PlanNodePtr getTraceNode(
         unnestNode->unnestVariables(),
         unnestNode->unnestNames(),
         unnestNode->ordinalityName(),
-        unnestNode->emptyUnnestValueName(),
+        unnestNode->markerName(),
         std::make_shared<DummySourceNode>(
             unnestNode->sources().front()->outputType()));
   }
 
+  if (const auto* orderByNode =
+          dynamic_cast<const core::OrderByNode*>(traceNode)) {
+    return std::make_shared<core::OrderByNode>(
+        nodeId,
+        orderByNode->sortingKeys(),
+        orderByNode->sortingOrders(),
+        orderByNode->isPartial(),
+        std::make_shared<DummySourceNode>(
+            orderByNode->sources().front()->outputType()));
+  }
+
+  if (const auto* topNRowNumberNode =
+          dynamic_cast<const core::TopNRowNumberNode*>(traceNode)) {
+    const auto generateRowNumber = topNRowNumberNode->generateRowNumber();
+    return std::make_shared<core::TopNRowNumberNode>(
+        nodeId,
+        topNRowNumberNode->rankFunction(),
+        topNRowNumberNode->partitionKeys(),
+        topNRowNumberNode->sortingKeys(),
+        topNRowNumberNode->sortingOrders(),
+        generateRowNumber ? std::make_optional(
+                                topNRowNumberNode->outputType()->names().back())
+                          : std::nullopt,
+        topNRowNumberNode->limit(),
+        std::make_shared<DummySourceNode>(
+            topNRowNumberNode->sources().front()->outputType()));
+  }
+
+  if (const auto* exchangeNode =
+          dynamic_cast<const core::ExchangeNode*>(traceNode)) {
+    // Check if it's a MergeExchangeNode
+    if (const auto* mergeExchangeNode =
+            dynamic_cast<const core::MergeExchangeNode*>(traceNode)) {
+      return std::make_shared<core::MergeExchangeNode>(
+          nodeId,
+          mergeExchangeNode->outputType(),
+          mergeExchangeNode->sortingKeys(),
+          mergeExchangeNode->sortingOrders(),
+          mergeExchangeNode->serdeKind());
+    }
+    // Regular ExchangeNode
+    return std::make_shared<core::ExchangeNode>(
+        nodeId, exchangeNode->outputType(), exchangeNode->serdeKind());
+  }
+
   for (const auto& factory : traceNodeRegistry()) {
     if (auto node = factory.second(traceNode, nodeId)) {
       return node;
diff --git a/velox/exec/trace/TraceUtil.h b/velox/exec/trace/TraceUtil.h
new file mode 100644
index 00000000000..1d7a86d2ab5
--- /dev/null
+++ b/velox/exec/trace/TraceUtil.h
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+#include <vector>
+#include "velox/common/file/FileSystems.h"
+#include "velox/core/PlanNode.h"
+#include "velox/type/Type.h"
+
+#include <folly/dynamic.h>
+
+namespace facebook::velox::exec::trace {
+
+static const std::vector<core::PlanNodePtr> kEmptySources;
+
+class DummySourceNode final : public core::PlanNode {
+ public:
+  explicit DummySourceNode(RowTypePtr outputType)
+      : PlanNode(""), outputType_(std::move(outputType)) {}
+
+  const RowTypePtr& outputType() const override {
+    return outputType_;
+  }
+
+  const std::vector<core::PlanNodePtr>& sources() const override {
+    return kEmptySources;
+  }
+
+  std::string_view name() const override {
+    return "DummySource";
+  }
+
+  folly::dynamic serialize() const override {
+    folly::dynamic obj = folly::dynamic::object;
+    obj["name"] = "DummySource";
+    obj["outputType"] = outputType_->serialize();
+    return obj;
+  }
+
+  static core::PlanNodePtr create(const folly::dynamic& obj, void* context) {
+    return std::make_shared<DummySourceNode>(
+        ISerializable::deserialize<RowType>(obj["outputType"]));
+  }
+
+ private:
+  void addDetails(std::stringstream& stream) const override {
+    // Nothing to add.
+  }
+
+  const RowTypePtr outputType_;
+};
+
+/// Creates a directory to store the query trace metdata and data.
+void createTraceDirectory(
+    const std::string& traceDir,
+    const std::string& directoryConfig = "");
+
+/// Returns the trace directory for a given query.
+std::string getQueryTraceDirectory(
+    const std::string& traceDir,
+    const std::string& queryId);
+
+/// Returns the trace directory for a given query task.
+std::string getTaskTraceDirectory(
+    const std::string& traceDir,
+    const std::string& queryId,
+    const std::string& taskId);
+
+/// Returns the file path for a given task's metadata trace file.
+std::string getTaskTraceMetaFilePath(const std::string& taskTraceDir);
+
+/// Returns the trace directory for a given traced plan node.
+std::string getNodeTraceDirectory(
+    const std::string& taskTraceDir,
+    const std::string& nodeId);
+
+/// Returns the trace directory for a given traced pipeline.
+std::string getPipelineTraceDirectory(
+    const std::string& nodeTraceDir,
+    uint32_t pipelineId);
+
+/// Returns the trace directory for a given traced operator.
+std::string getOpTraceDirectory(
+    const std::string& taskTraceDir,
+    const std::string& nodeId,
+    uint32_t pipelineId,
+    uint32_t driverId);
+
+std::string getOpTraceDirectory(
+    const std::string& nodeTraceDir,
+    uint32_t pipelineId,
+    uint32_t driverId);
+
+/// Returns the file path for a given operator's traced input file.
+std::string getOpTraceInputFilePath(const std::string& opTraceDir);
+
+/// Returns the file path for a given operator's traced split file.
+std::string getOpTraceSplitFilePath(const std::string& opTraceDir);
+
+/// Returns the file path for a given operator's traced input file.
+std::string getOpTraceSummaryFilePath(const std::string& opTraceDir);
+
+/// Extracts the input data type for the trace scan operator. The function first
+/// uses the traced node id to find traced operator's plan node from the traced
+/// plan fragment. Then it uses the specified source node index to find the
+/// output data type from its source node plans as the input data type of the
+/// traced plan node.
+///
+/// For hash join plan node, there are two source nodes, the  output data type
+/// of the first node is the input data type of the 'HashProbe' operator, and
+/// the output data type of the second one is the input data type of the
+/// 'HashBuild' operator.
+///
+/// @param tracedPlan The root node of the trace plan fragment.
+/// @param tracedNodeId The node id of the trace node.
+/// @param sourceIndex The source index of the specific traced operator.
+RowTypePtr getDataType(
+    const core::PlanNodePtr& tracedPlan,
+    const std::string& tracedNodeId,
+    size_t sourceIndex = 0);
+
+/// Extracts pipeline IDs in ascending order by listing the trace directory,
+/// then decoding the names of the subdirectories to obtain the pipeline IDs,
+/// and finally sorting them. 'nodeTraceDir' corresponds to the trace directory
+/// of the plan node.
+std::vector<uint32_t> listPipelineIds(
+    const std::string& nodeTraceDir,
+    const std::shared_ptr<filesystems::FileSystem>& fs);
+
+/// Extracts driver IDs in ascending order by listing the trace directory for a
+/// given pipeline then decoding the names of the subdirectories to obtain the
+/// driver IDs, and finally sorting them. 'nodeTraceDir' corresponds to the
+/// trace directory of the plan node.
+std::vector<uint32_t> listDriverIds(
+    const std::string& nodeTraceDir,
+    uint32_t pipelineId,
+    const std::shared_ptr<filesystems::FileSystem>& fs);
+
+/// Extracts the driver IDs from the comma-separated list of driver IDs string.
+std::vector<uint32_t> extractDriverIds(const std::string& driverIds);
+
+/// Extracts task ids of the query tracing by listing the query trace directory.
+/// 'traceDir' is the root trace directory. 'queryId' is the query id.
+std::vector<std::string> getTaskIds(
+    const std::string& traceDir,
+    const std::string& queryId,
+    const std::shared_ptr<filesystems::FileSystem>& fs);
+
+/// Gets the metadata from a given task metadata file which includes query plan,
+/// configs and connector properties.
+folly::dynamic getTaskMetadata(
+    const std::string& taskMetaFilePath,
+    const std::shared_ptr<filesystems::FileSystem>& fs);
+
+/// Checks whether the operator can be traced.
+bool canTrace(const std::string& operatorType);
+
+/// Gets the specified the trace node from 'plan'. In the returned trace node,
+/// we replace its source nodes with DummySourceNode for replay.
+core::PlanNodePtr getTraceNode(
+    const core::PlanNode& plan,
+    core::PlanNodeId nodeId);
+
+using TraceNodeFactory = std::function<
+    core::PlanNodePtr(const core::PlanNode*, const core::PlanNodeId&)>;
+
+void registerTraceNodeFactory(
+    const std::string& operatorType,
+    TraceNodeFactory&& factory);
+
+void registerDummySourceSerDe();
+
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/TraceWriter.h b/velox/exec/trace/TraceWriter.h
new file mode 100644
index 00000000000..4565c49c756
--- /dev/null
+++ b/velox/exec/trace/TraceWriter.h
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/vector/ComplexVector.h"
+
+namespace facebook::velox::exec {
+struct Split;
+}
+
+namespace facebook::velox::core {
+class PlanNode;
+class QueryCtx;
+} // namespace facebook::velox::core
+
+namespace facebook::velox::exec::trace {
+
+/// Abstract interface for capturing traced input. Implementations are
+/// responsible for serializing and/or storing row batches during query
+/// execution tracing, along with associated metadata and summaries.
+class TraceInputWriter {
+ public:
+  virtual ~TraceInputWriter() = default;
+
+  /// Serializes rows and writes out each batch. Return whether the driver
+  /// should block the pipeline. If it returns true, a future needs to be set
+  /// (returned) to signal the driver when it can resume execution.
+  virtual bool write(const RowVectorPtr& rows, ContinueFuture* future) = 0;
+
+  /// Closes the data file and writes out the data summary.
+  virtual void finish() = 0;
+};
+
+/// Abstract interface for capturing traced expression output. Implementations
+/// are responsible for processing individual expression result vectors during
+/// query execution tracing.
+class TraceExprWriter {
+ public:
+  virtual ~TraceExprWriter() = default;
+
+  /// Writes a single expression output vector. Expression tracing runs inside
+  /// Expr::apply(), which has no mechanism to block the driver pipeline.
+  virtual void write(const VectorPtr& result) = 0;
+
+  /// Closes the data file and writes out the data summary.
+  virtual void finish() = 0;
+};
+
+/// Abstract interface for capturing traced split information. Implementations
+/// are responsible for processing and/or recording the splits found during
+/// query execution tracing, enabling replay and analysis of query input
+/// patterns.
+class TraceSplitWriter {
+ public:
+  virtual ~TraceSplitWriter() = default;
+
+  virtual void write(const exec::Split& split) const = 0;
+
+  virtual void finish() = 0;
+};
+
+/// Abstract interface for capturing task metadata.
+class TraceMetadataWriter {
+ public:
+  virtual ~TraceMetadataWriter() = default;
+
+  virtual void write(
+      const core::QueryCtx& queryCtx,
+      const core::PlanNode& planNode) = 0;
+};
+
+} // namespace facebook::velox::exec::trace
diff --git a/velox/experimental/breeze/CMakeLists.txt b/velox/experimental/breeze/CMakeLists.txt
index 90001307ee8..922624a5946 100644
--- a/velox/experimental/breeze/CMakeLists.txt
+++ b/velox/experimental/breeze/CMakeLists.txt
@@ -118,7 +118,7 @@ if(BUILD_TRACING)
   include_directories(external/perfetto/sdk)
   add_library(perfetto STATIC ../../external/perfetto/sdk/perfetto.cc)
   target_compile_features(perfetto PRIVATE cxx_std_17)
-  target_compile_options(perfetto PRIVATE -fPIC)
+  target_compile_options(perfetto PRIVATE -fPIC -Wno-array-bounds -Wno-stringop-overflow)
   target_include_directories(perfetto INTERFACE ../../external/perfetto/sdk)
   target_compile_definitions(perfetto INTERFACE TRACING=1)
 endif()
diff --git a/velox/experimental/breeze/breeze/platforms/cuda.cuh b/velox/experimental/breeze/breeze/platforms/cuda.cuh
index 661e0743b46..02378f9af45 100644
--- a/velox/experimental/breeze/breeze/platforms/cuda.cuh
+++ b/velox/experimental/breeze/breeze/platforms/cuda.cuh
@@ -371,12 +371,12 @@ CudaSpecialization::atomic_add<breeze::utils::Slice<
   static_assert(sizeof(double) == sizeof(unsigned long long),
                 "unexpected type sizes");
   unsigned long long old =
-      *reinterpret_cast<unsigned long long *>(address.data());
+      *reinterpret_cast<unsigned long long*>(address.data());
   unsigned long long assumed;
   do {
     assumed = old;
     old = atomicCAS(
-        reinterpret_cast<unsigned long long *>(address.data()), assumed,
+        reinterpret_cast<unsigned long long*>(address.data()), assumed,
         __double_as_longlong(value + __longlong_as_double(assumed)));
   } while (assumed != old);
 
@@ -394,9 +394,9 @@ CudaSpecialization::atomic_add<breeze::utils::Slice<
         address,
     long long value) {
   unsigned long long result =
-      atomicAdd(reinterpret_cast<unsigned long long *>(address.data()),
-                *reinterpret_cast<unsigned long long *>(&value));
-  return *reinterpret_cast<long long *>(&result);
+      atomicAdd(reinterpret_cast<unsigned long long*>(address.data()),
+                *reinterpret_cast<unsigned long long*>(&value));
+  return *reinterpret_cast<long long*>(&result);
 }
 
 // specialization for T=Slice<GLOBAL, BLOCKED, float>
@@ -409,10 +409,10 @@ __device__ __forceinline__ void CudaSpecialization::atomic_min<
   static_assert(sizeof(float) == sizeof(unsigned), "unexpected type sizes");
   float current = atomic_load(address);
   while (current > value) {
-    unsigned old = atomicCAS(reinterpret_cast<unsigned *>(address.data()),
-                             *reinterpret_cast<unsigned *>(&current),
-                             *reinterpret_cast<unsigned *>(&value));
-    current = *reinterpret_cast<float *>(&old);
+    unsigned old = atomicCAS(reinterpret_cast<unsigned*>(address.data()),
+                             *reinterpret_cast<unsigned*>(&current),
+                             *reinterpret_cast<unsigned*>(&value));
+    current = *reinterpret_cast<float*>(&old);
     if (current == value) {
       break;
     }
@@ -429,10 +429,10 @@ __device__ __forceinline__ void CudaSpecialization::atomic_max<
   static_assert(sizeof(float) == sizeof(unsigned), "unexpected type sizes");
   float current = atomic_load(address);
   while (current < value) {
-    unsigned old = atomicCAS(reinterpret_cast<unsigned *>(address.data()),
-                             *reinterpret_cast<unsigned *>(&current),
-                             *reinterpret_cast<unsigned *>(&value));
-    current = *reinterpret_cast<float *>(&old);
+    unsigned old = atomicCAS(reinterpret_cast<unsigned*>(address.data()),
+                             *reinterpret_cast<unsigned*>(&current),
+                             *reinterpret_cast<unsigned*>(&value));
+    current = *reinterpret_cast<float*>(&old);
     if (current == value) {
       break;
     }
@@ -452,10 +452,10 @@ CudaSpecialization::atomic_min<breeze::utils::Slice<
   double current = atomic_load(address);
   while (current > value) {
     unsigned long long old =
-        atomicCAS(reinterpret_cast<unsigned long long *>(address.data()),
-                  *reinterpret_cast<unsigned long long *>(&current),
-                  *reinterpret_cast<unsigned long long *>(&value));
-    current = *reinterpret_cast<double *>(&old);
+        atomicCAS(reinterpret_cast<unsigned long long*>(address.data()),
+                  *reinterpret_cast<unsigned long long*>(&current),
+                  *reinterpret_cast<unsigned long long*>(&value));
+    current = *reinterpret_cast<double*>(&old);
     if (current == value) {
       break;
     }
@@ -475,10 +475,10 @@ CudaSpecialization::atomic_max<breeze::utils::Slice<
   double current = atomic_load(address);
   while (current < value) {
     unsigned long long old =
-        atomicCAS(reinterpret_cast<unsigned long long *>(address.data()),
-                  *reinterpret_cast<unsigned long long *>(&current),
-                  *reinterpret_cast<unsigned long long *>(&value));
-    current = *reinterpret_cast<double *>(&old);
+        atomicCAS(reinterpret_cast<unsigned long long*>(address.data()),
+                  *reinterpret_cast<unsigned long long*>(&current),
+                  *reinterpret_cast<unsigned long long*>(&value));
+    current = *reinterpret_cast<double*>(&old);
     if (current == value) {
       break;
     }
@@ -496,10 +496,10 @@ __device__ __forceinline__ long long CudaSpecialization::atomic_cas<
         address,
     long long compare, long long value) {
   unsigned long long old =
-      atomicCAS(reinterpret_cast<unsigned long long *>(address.data()),
-                *reinterpret_cast<unsigned long long *>(&compare),
-                *reinterpret_cast<unsigned long long *>(&value));
-  return *reinterpret_cast<long long *>(&old);
+      atomicCAS(reinterpret_cast<unsigned long long*>(address.data()),
+                *reinterpret_cast<unsigned long long*>(&compare),
+                *reinterpret_cast<unsigned long long*>(&value));
+  return *reinterpret_cast<long long*>(&old);
 }
 
 // specialization for T=Slice<SHARED, BLOCKED, long long>
@@ -518,9 +518,9 @@ __device__ __forceinline__ long long CudaSpecialization::atomic_cas<
                                     unsigned long long>::pointer_type;
   unsigned long long old =
       atomicCAS(reinterpret_cast<pointer_type>(address.data()),
-                *reinterpret_cast<unsigned long long *>(&compare),
-                *reinterpret_cast<unsigned long long *>(&value));
-  return *reinterpret_cast<long long *>(&old);
+                *reinterpret_cast<unsigned long long*>(&compare),
+                *reinterpret_cast<unsigned long long*>(&value));
+  return *reinterpret_cast<long long*>(&old);
 }
 
 // specialization for T=Slice<GLOBAL, BLOCKED, float>
@@ -532,10 +532,10 @@ __device__ __forceinline__ float CudaSpecialization::atomic_cas<
         address,
     float compare, float value) {
   static_assert(sizeof(float) == sizeof(unsigned), "unexpected type sizes");
-  unsigned old = atomicCAS(reinterpret_cast<unsigned *>(address.data()),
-                           *reinterpret_cast<unsigned *>(&compare),
-                           *reinterpret_cast<unsigned *>(&value));
-  return *reinterpret_cast<float *>(&old);
+  unsigned old = atomicCAS(reinterpret_cast<unsigned*>(address.data()),
+                           *reinterpret_cast<unsigned*>(&compare),
+                           *reinterpret_cast<unsigned*>(&value));
+  return *reinterpret_cast<float*>(&old);
 }
 
 #if __CUDA_ARCH__ >= 800
diff --git a/velox/experimental/breeze/breeze/platforms/hip.hpp b/velox/experimental/breeze/breeze/platforms/hip.hpp
index 2ddef322d5e..9f9b38d19f7 100644
--- a/velox/experimental/breeze/breeze/platforms/hip.hpp
+++ b/velox/experimental/breeze/breeze/platforms/hip.hpp
@@ -70,11 +70,11 @@ struct HipPlatform {
   }
   template <typename SliceT, typename T = typename SliceT::data_type>
   __device__ __forceinline__ T atomic_load(SliceT address) {
-    return *reinterpret_cast<volatile T *>(address.data());
+    return *reinterpret_cast<volatile T*>(address.data());
   }
   template <typename SliceT, typename T = typename SliceT::data_type>
   __device__ __forceinline__ void atomic_store(SliceT address, T value) {
-    *reinterpret_cast<volatile T *>(address.data()) = value;
+    *reinterpret_cast<volatile T*>(address.data()) = value;
   }
   template <typename SliceT, typename T = typename SliceT::data_type>
   __device__ __forceinline__ T atomic_cas(SliceT address, T compare, T value) {
diff --git a/velox/experimental/breeze/breeze/platforms/metal.h b/velox/experimental/breeze/breeze/platforms/metal.h
index c1a3e28882f..498fa31858c 100644
--- a/velox/experimental/breeze/breeze/platforms/metal.h
+++ b/velox/experimental/breeze/breeze/platforms/metal.h
@@ -78,16 +78,15 @@ struct MetalPlatform {
     MetalSpecialization::atomic_store<SliceT, T>(address, value);
   }
   template <template <breeze::utils::AddressSpace,
-                      breeze::utils::DataArrangement, typename>
-            class SliceT>
+                      breeze::utils::DataArrangement, typename> class SliceT>
   inline uint atomic_cas(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, uint> address,
       uint expected, uint desired) {
-    volatile device uint *ptr = address.data();
+    volatile device uint* ptr = address.data();
     uint current = expected;
     do {
       if (metal::atomic_compare_exchange_weak_explicit(
-              (device metal::atomic_uint *)ptr, &current, desired,
+              (device metal::atomic_uint*)ptr, &current, desired,
               metal::memory_order_relaxed, metal::memory_order_relaxed)) {
         return expected;
       }
@@ -95,16 +94,15 @@ struct MetalPlatform {
     return current;
   }
   template <template <breeze::utils::AddressSpace,
-                      breeze::utils::DataArrangement, typename>
-            class SliceT>
+                      breeze::utils::DataArrangement, typename> class SliceT>
   inline bool atomic_cas(
       SliceT<breeze::utils::SHARED, breeze::utils::BLOCKED, uint> address,
       uint expected, uint desired) {
-    volatile threadgroup uint *ptr = address.data();
+    volatile threadgroup uint* ptr = address.data();
     uint current = expected;
     do {
       if (metal::atomic_compare_exchange_weak_explicit(
-              (threadgroup metal::atomic_uint *)ptr, &current, desired,
+              (threadgroup metal::atomic_uint*)ptr, &current, desired,
               metal::memory_order_relaxed, metal::memory_order_relaxed)) {
         return expected;
       }
@@ -112,110 +110,101 @@ struct MetalPlatform {
     return current;
   }
   template <template <breeze::utils::AddressSpace,
-                      breeze::utils::DataArrangement, typename>
-            class SliceT>
+                      breeze::utils::DataArrangement, typename> class SliceT>
   inline int atomic_add(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, int> address,
       int value) {
-    volatile device int *ptr = address.data();
-    return metal::atomic_fetch_add_explicit((device metal::atomic_int *)ptr,
+    volatile device int* ptr = address.data();
+    return metal::atomic_fetch_add_explicit((device metal::atomic_int*)ptr,
                                             value, metal::memory_order_relaxed);
   }
   template <template <breeze::utils::AddressSpace,
-                      breeze::utils::DataArrangement, typename>
-            class SliceT>
+                      breeze::utils::DataArrangement, typename> class SliceT>
   inline int atomic_add(
       SliceT<breeze::utils::SHARED, breeze::utils::BLOCKED, int> address,
       int value) {
-    volatile threadgroup int *ptr = address.data();
-    return metal::atomic_fetch_add_explicit(
-        (threadgroup metal::atomic_int *)ptr, value,
-        metal::memory_order_relaxed);
+    volatile threadgroup int* ptr = address.data();
+    return metal::atomic_fetch_add_explicit((threadgroup metal::atomic_int*)ptr,
+                                            value, metal::memory_order_relaxed);
   }
   template <template <breeze::utils::AddressSpace,
-                      breeze::utils::DataArrangement, typename>
-            class SliceT>
+                      breeze::utils::DataArrangement, typename> class SliceT>
   inline uint atomic_add(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, uint> address,
       uint value) {
-    volatile device uint *ptr = address.data();
-    return metal::atomic_fetch_add_explicit((device metal::atomic_uint *)ptr,
+    volatile device uint* ptr = address.data();
+    return metal::atomic_fetch_add_explicit((device metal::atomic_uint*)ptr,
                                             value, metal::memory_order_relaxed);
   }
   template <template <breeze::utils::AddressSpace,
-                      breeze::utils::DataArrangement, typename>
-            class SliceT>
+                      breeze::utils::DataArrangement, typename> class SliceT>
   inline uint atomic_add(
       SliceT<breeze::utils::SHARED, breeze::utils::BLOCKED, uint> address,
       uint value) {
-    volatile threadgroup uint *ptr = address.data();
+    volatile threadgroup uint* ptr = address.data();
     return metal::atomic_fetch_add_explicit(
-        (threadgroup metal::atomic_uint *)ptr, value,
+        (threadgroup metal::atomic_uint*)ptr, value,
         metal::memory_order_relaxed);
   }
   template <template <breeze::utils::AddressSpace,
-                      breeze::utils::DataArrangement, typename>
-            class SliceT>
+                      breeze::utils::DataArrangement, typename> class SliceT>
   inline void atomic_min(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, int> address,
       int value) {
-    volatile device int *ptr = address.data();
-    int current = metal::atomic_load_explicit((device metal::atomic_int *)ptr,
+    volatile device int* ptr = address.data();
+    int current = metal::atomic_load_explicit((device metal::atomic_int*)ptr,
                                               metal::memory_order_relaxed);
     while (current > value) {
       if (metal::atomic_compare_exchange_weak_explicit(
-              (device metal::atomic_int *)ptr, &current, value,
+              (device metal::atomic_int*)ptr, &current, value,
               metal::memory_order_relaxed, metal::memory_order_relaxed)) {
         break;
       }
     }
   }
   template <template <breeze::utils::AddressSpace,
-                      breeze::utils::DataArrangement, typename>
-            class SliceT>
+                      breeze::utils::DataArrangement, typename> class SliceT>
   inline void atomic_min(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, uint> address,
       uint value) {
-    volatile device uint *ptr = address.data();
-    uint current = metal::atomic_load_explicit((device metal::atomic_uint *)ptr,
+    volatile device uint* ptr = address.data();
+    uint current = metal::atomic_load_explicit((device metal::atomic_uint*)ptr,
                                                metal::memory_order_relaxed);
     while (current > value) {
       if (metal::atomic_compare_exchange_weak_explicit(
-              (device metal::atomic_uint *)ptr, &current, value,
+              (device metal::atomic_uint*)ptr, &current, value,
               metal::memory_order_relaxed, metal::memory_order_relaxed)) {
         break;
       }
     }
   }
   template <template <breeze::utils::AddressSpace,
-                      breeze::utils::DataArrangement, typename>
-            class SliceT>
+                      breeze::utils::DataArrangement, typename> class SliceT>
   inline void atomic_max(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, int> address,
       int value) {
-    volatile device int *ptr = address.data();
-    int current = metal::atomic_load_explicit((device metal::atomic_int *)ptr,
+    volatile device int* ptr = address.data();
+    int current = metal::atomic_load_explicit((device metal::atomic_int*)ptr,
                                               metal::memory_order_relaxed);
     while (current < value) {
       if (metal::atomic_compare_exchange_weak_explicit(
-              (device metal::atomic_int *)ptr, &current, value,
+              (device metal::atomic_int*)ptr, &current, value,
               metal::memory_order_relaxed, metal::memory_order_relaxed)) {
         break;
       }
     }
   }
   template <template <breeze::utils::AddressSpace,
-                      breeze::utils::DataArrangement, typename>
-            class SliceT>
+                      breeze::utils::DataArrangement, typename> class SliceT>
   inline void atomic_max(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, uint> address,
       uint value) {
-    volatile device uint *ptr = address.data();
-    uint current = metal::atomic_load_explicit((device metal::atomic_uint *)ptr,
+    volatile device uint* ptr = address.data();
+    uint current = metal::atomic_load_explicit((device metal::atomic_uint*)ptr,
                                                metal::memory_order_relaxed);
     while (current < value) {
       if (metal::atomic_compare_exchange_weak_explicit(
-              (device metal::atomic_uint *)ptr, &current, value,
+              (device metal::atomic_uint*)ptr, &current, value,
               metal::memory_order_relaxed, metal::memory_order_relaxed)) {
         break;
       }
@@ -295,8 +284,8 @@ inline uint MetalSpecialization::atomic_load<
     breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED, uint>>(
     breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED, uint>
         address) {
-  volatile device uint *ptr = address.data();
-  return metal::atomic_load_explicit((device metal::atomic_uint *)ptr,
+  volatile device uint* ptr = address.data();
+  return metal::atomic_load_explicit((device metal::atomic_uint*)ptr,
                                      metal::memory_order_relaxed);
 }
 
@@ -307,8 +296,8 @@ inline void MetalSpecialization::atomic_store<
     breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED, int>
         address,
     int value) {
-  volatile device int *ptr = address.data();
-  metal::atomic_store_explicit((device metal::atomic_int *)ptr, value,
+  volatile device int* ptr = address.data();
+  metal::atomic_store_explicit((device metal::atomic_int*)ptr, value,
                                metal::memory_order_relaxed);
 }
 
@@ -319,7 +308,7 @@ inline void MetalSpecialization::atomic_store<
     breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED, uint>
         address,
     uint value) {
-  volatile device uint *ptr = address.data();
-  metal::atomic_store_explicit((device metal::atomic_uint *)ptr, value,
+  volatile device uint* ptr = address.data();
+  metal::atomic_store_explicit((device metal::atomic_uint*)ptr, value,
                                metal::memory_order_relaxed);
 }
diff --git a/velox/experimental/breeze/breeze/platforms/opencl.h b/velox/experimental/breeze/breeze/platforms/opencl.h
index f4c5394e98e..41e319bd579 100644
--- a/velox/experimental/breeze/breeze/platforms/opencl.h
+++ b/velox/experimental/breeze/breeze/platforms/opencl.h
@@ -56,11 +56,11 @@ struct OpenCLPlatform {
   }
   template <typename SliceT, typename T = typename SliceT::data_type>
   inline T atomic_load(SliceT address) {
-    return *reinterpret_cast<const volatile T *>(address.data());
+    return *reinterpret_cast<const volatile T*>(address.data());
   }
   template <typename SliceT, typename T>
   inline void atomic_store(SliceT address, T value) {
-    *reinterpret_cast<volatile T *>(address.data()) = value;
+    *reinterpret_cast<volatile T*>(address.data()) = value;
   }
   template <typename SliceT, typename T>
   inline T atomic_cas(SliceT address, T compare, T value) {
diff --git a/velox/experimental/breeze/breeze/platforms/openmp.h b/velox/experimental/breeze/breeze/platforms/openmp.h
index 05123099a42..dae8c82be67 100644
--- a/velox/experimental/breeze/breeze/platforms/openmp.h
+++ b/velox/experimental/breeze/breeze/platforms/openmp.h
@@ -31,9 +31,9 @@ template <typename T>
 struct supported_type {
   static T min();
   static T max();
-  static T atomic_load(T *address);
-  static void atomic_store(T *address, T value);
-  static bool atomic_cas(T *address, T *compare, T value, bool weak);
+  static T atomic_load(T* address);
+  static void atomic_store(T* address, T value);
+  static bool atomic_cas(T* address, T* compare, T value, bool weak);
   static int count_leading_zeros(T value);
   static int population_count(T value);
   static T extract_bits(T value, int start_bit, int num_bits);
@@ -44,13 +44,13 @@ template <>
 struct supported_type<unsigned> {
   static unsigned min() { return 0; }
   static unsigned max() { return __INT_MAX__ * 2u + 1; }
-  static unsigned atomic_load(unsigned *address) {
+  static unsigned atomic_load(unsigned* address) {
     return __atomic_load_n(address, __ATOMIC_RELAXED);
   }
-  static void atomic_store(unsigned *address, unsigned value) {
+  static void atomic_store(unsigned* address, unsigned value) {
     __atomic_store_n(address, value, __ATOMIC_RELAXED);
   }
-  static bool atomic_cas(unsigned *address, unsigned *compare, unsigned value,
+  static bool atomic_cas(unsigned* address, unsigned* compare, unsigned value,
                          bool weak) {
     return __atomic_compare_exchange_n(address, compare, value, weak,
                                        __ATOMIC_RELAXED, __ATOMIC_RELAXED);
@@ -72,13 +72,13 @@ template <>
 struct supported_type<int> {
   static int min() { return -__INT_MAX__ - 1; }
   static int max() { return __INT_MAX__; }
-  static int atomic_load(int *address) {
+  static int atomic_load(int* address) {
     return __atomic_load_n(address, __ATOMIC_RELAXED);
   }
-  static void atomic_store(int *address, int value) {
+  static void atomic_store(int* address, int value) {
     __atomic_store_n(address, value, __ATOMIC_RELAXED);
   }
-  static bool atomic_cas(int *address, int *compare, int value, bool weak) {
+  static bool atomic_cas(int* address, int* compare, int value, bool weak) {
     return __atomic_compare_exchange_n(address, compare, value, weak,
                                        __ATOMIC_RELAXED, __ATOMIC_RELAXED);
   }
@@ -89,15 +89,15 @@ template <>
 struct supported_type<unsigned long long> {
   static unsigned long long min() { return 0; }
   static unsigned long long max() { return __LONG_LONG_MAX__ * 2ull + 1; }
-  static unsigned long long atomic_load(unsigned long long *address) {
+  static unsigned long long atomic_load(unsigned long long* address) {
     return __atomic_load_n(address, __ATOMIC_RELAXED);
   }
-  static void atomic_store(unsigned long long *address,
+  static void atomic_store(unsigned long long* address,
                            unsigned long long value) {
     __atomic_store_n(address, value, __ATOMIC_RELAXED);
   }
-  static bool atomic_cas(unsigned long long *address,
-                         unsigned long long *compare, unsigned long long value,
+  static bool atomic_cas(unsigned long long* address,
+                         unsigned long long* compare, unsigned long long value,
                          bool weak) {
     return __atomic_compare_exchange_n(address, compare, value, weak,
                                        __ATOMIC_RELAXED, __ATOMIC_RELAXED);
@@ -120,13 +120,13 @@ template <>
 struct supported_type<long long> {
   static long long min() { return -__LONG_LONG_MAX__ - 1; }
   static long long max() { return __LONG_LONG_MAX__; }
-  static long long atomic_load(long long *address) {
+  static long long atomic_load(long long* address) {
     return __atomic_load_n(address, __ATOMIC_RELAXED);
   }
-  static void atomic_store(long long *address, long long value) {
+  static void atomic_store(long long* address, long long value) {
     __atomic_store_n(address, value, __ATOMIC_RELAXED);
   }
-  static bool atomic_cas(long long *address, long long *compare,
+  static bool atomic_cas(long long* address, long long* compare,
                          long long value, bool weak) {
     return __atomic_compare_exchange_n(address, compare, value, weak,
                                        __ATOMIC_RELAXED, __ATOMIC_RELAXED);
@@ -139,24 +139,24 @@ struct supported_type<float> {
   static_assert(sizeof(float) == sizeof(unsigned), "unexpected type sizes");
   static float min() { return __FLT_MIN__; }
   static float max() { return __FLT_MAX__; }
-  static float atomic_load(float *address) {
+  static float atomic_load(float* address) {
     union {
       float value;
       unsigned raw;
     } content;
-    content.raw = __atomic_load_n(reinterpret_cast<unsigned *>(address),
-                                  __ATOMIC_RELAXED);
+    content.raw =
+        __atomic_load_n(reinterpret_cast<unsigned*>(address), __ATOMIC_RELAXED);
     return content.value;
   }
-  static void atomic_store(float *address, float value) {
-    __atomic_store_n(reinterpret_cast<unsigned *>(address),
-                     *reinterpret_cast<unsigned *>(&value), __ATOMIC_RELAXED);
+  static void atomic_store(float* address, float value) {
+    __atomic_store_n(reinterpret_cast<unsigned*>(address),
+                     *reinterpret_cast<unsigned*>(&value), __ATOMIC_RELAXED);
   }
-  static bool atomic_cas(float *address, float *compare, float value,
+  static bool atomic_cas(float* address, float* compare, float value,
                          bool weak) {
-    return __atomic_compare_exchange_n(reinterpret_cast<unsigned *>(address),
-                                       reinterpret_cast<unsigned *>(compare),
-                                       *reinterpret_cast<unsigned *>(&value),
+    return __atomic_compare_exchange_n(reinterpret_cast<unsigned*>(address),
+                                       reinterpret_cast<unsigned*>(compare),
+                                       *reinterpret_cast<unsigned*>(&value),
                                        weak, __ATOMIC_RELAXED,
                                        __ATOMIC_RELAXED);
   }
@@ -169,26 +169,26 @@ struct supported_type<double> {
                 "unexpected type sizes");
   static double min() { return __DBL_MIN__; }
   static double max() { return __DBL_MAX__; }
-  static double atomic_load(double *address) {
+  static double atomic_load(double* address) {
     union {
       double value;
       unsigned long long raw;
     } content;
     content.raw = __atomic_load_n(
-        reinterpret_cast<unsigned long long *>(address), __ATOMIC_RELAXED);
+        reinterpret_cast<unsigned long long*>(address), __ATOMIC_RELAXED);
     return content.value;
   }
-  static void atomic_store(double *address, double value) {
-    __atomic_store_n(reinterpret_cast<unsigned long long *>(address),
-                     *reinterpret_cast<unsigned long long *>(&value),
+  static void atomic_store(double* address, double value) {
+    __atomic_store_n(reinterpret_cast<unsigned long long*>(address),
+                     *reinterpret_cast<unsigned long long*>(&value),
                      __ATOMIC_RELAXED);
   }
-  static bool atomic_cas(double *address, double *compare, double value,
+  static bool atomic_cas(double* address, double* compare, double value,
                          bool weak) {
     return __atomic_compare_exchange_n(
-        reinterpret_cast<unsigned long long *>(address),
-        reinterpret_cast<unsigned long long *>(compare),
-        *reinterpret_cast<unsigned long long *>(&value), weak, __ATOMIC_RELAXED,
+        reinterpret_cast<unsigned long long*>(address),
+        reinterpret_cast<unsigned long long*>(compare),
+        *reinterpret_cast<unsigned long long*>(&value), weak, __ATOMIC_RELAXED,
         __ATOMIC_RELAXED);
   }
 };
@@ -198,13 +198,13 @@ template <>
 struct supported_type<unsigned char> {
   static unsigned char min() { return 0; }
   static unsigned char max() { return 255; }
-  static unsigned atomic_load(unsigned char *address) {
+  static unsigned atomic_load(unsigned char* address) {
     return __atomic_load_n(address, __ATOMIC_RELAXED);
   }
-  static void atomic_store(unsigned char *address, unsigned char value) {
+  static void atomic_store(unsigned char* address, unsigned char value) {
     __atomic_store_n(address, value, __ATOMIC_RELAXED);
   }
-  static bool atomic_cas(unsigned char *address, unsigned char *compare,
+  static bool atomic_cas(unsigned char* address, unsigned char* compare,
                          unsigned char value, bool weak) {
     return __atomic_compare_exchange_n(address, compare, value, weak,
                                        __ATOMIC_RELAXED, __ATOMIC_RELAXED);
@@ -308,7 +308,7 @@ struct OpenMPPlatform {
     static_assert(WARP_THREADS == BLOCK_THREADS,
                   "WARP_THREADS must be the same as BLOCK_THREADS");
 
-    T *scratch = reinterpret_cast<T *>(shared_scratch_);
+    T* scratch = reinterpret_cast<T*>(shared_scratch_);
 #pragma omp single
     scratch[0] = static_cast<T>(0);
 
@@ -325,7 +325,7 @@ struct OpenMPPlatform {
     static_assert(WARP_THREADS == BLOCK_THREADS,
                   "WARP_THREADS must be the same as BLOCK_THREADS");
 
-    T *scratch = reinterpret_cast<T *>(shared_scratch_);
+    T* scratch = reinterpret_cast<T*>(shared_scratch_);
 
 #pragma omp single
     scratch[0] = supported_type<T>::max();
@@ -343,7 +343,7 @@ struct OpenMPPlatform {
     static_assert(WARP_THREADS == BLOCK_THREADS,
                   "WARP_THREADS must be the same as BLOCK_THREADS");
 
-    T *scratch = reinterpret_cast<T *>(shared_scratch_);
+    T* scratch = reinterpret_cast<T*>(shared_scratch_);
 #pragma omp single
     scratch[0] = supported_type<T>::min();
 
@@ -360,7 +360,7 @@ struct OpenMPPlatform {
     static_assert(WARP_THREADS == BLOCK_THREADS,
                   "WARP_THREADS must be the same as BLOCK_THREADS");
 
-    T *scratch = reinterpret_cast<T *>(shared_scratch_);
+    T* scratch = reinterpret_cast<T*>(shared_scratch_);
 #pragma omp single
     scratch[0] = static_cast<T>(0);
 
@@ -420,7 +420,7 @@ struct OpenMPPlatform {
   template <typename SliceT>
   inline void prefetch(SliceT) {}
   int block_idx_;
-  void *shared_scratch_;
+  void* shared_scratch_;
 };
 
 #pragma GCC diagnostic pop
diff --git a/velox/experimental/breeze/breeze/platforms/specialization/cuda-ptx.cuh b/velox/experimental/breeze/breeze/platforms/specialization/cuda-ptx.cuh
index 47014f6204c..7a4d49434fd 100644
--- a/velox/experimental/breeze/breeze/platforms/specialization/cuda-ptx.cuh
+++ b/velox/experimental/breeze/breeze/platforms/specialization/cuda-ptx.cuh
@@ -69,7 +69,7 @@ __device__ __forceinline__ unsigned CudaSpecialization::extract_bits(
   return BFE(value, start_bit, num_bits);
 }
 
-__device__ __forceinline__ void PREFETCH(void *ptr) {
+__device__ __forceinline__ void PREFETCH(void* ptr) {
   asm("prefetch.global.L1 [%0];" ::"l"(ptr));
 }
 
diff --git a/velox/experimental/breeze/breeze/platforms/sycl.hpp b/velox/experimental/breeze/breeze/platforms/sycl.hpp
index bc8c4dd8bbf..e4693d9cfa5 100644
--- a/velox/experimental/breeze/breeze/platforms/sycl.hpp
+++ b/velox/experimental/breeze/breeze/platforms/sycl.hpp
@@ -66,24 +66,24 @@ struct SyCLPlatform {
   inline T max(T lhs, T rhs) {
     return cl::sycl::max(lhs, rhs);
   }
-  template <typename T, template <breeze::utils::AddressSpace,
-                                  breeze::utils::DataArrangement, typename>
-                        typename SliceT>
+  template <typename T,
+            template <breeze::utils::AddressSpace,
+                      breeze::utils::DataArrangement, typename> typename SliceT>
   inline T atomic_load(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, T> address) {
     return cl::sycl::atomic<T>{cl::sycl::global_ptr<T>{address.data()}}.load();
   }
-  template <typename T, template <breeze::utils::AddressSpace,
-                                  breeze::utils::DataArrangement, typename>
-                        typename SliceT>
+  template <typename T,
+            template <breeze::utils::AddressSpace,
+                      breeze::utils::DataArrangement, typename> typename SliceT>
   inline void atomic_store(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, T> address,
       T value) {
     cl::sycl::atomic<T>{cl::sycl::global_ptr<T>{address.data()}}.store(value);
   }
-  template <typename T, template <breeze::utils::AddressSpace,
-                                  breeze::utils::DataArrangement, typename>
-                        typename SliceT>
+  template <typename T,
+            template <breeze::utils::AddressSpace,
+                      breeze::utils::DataArrangement, typename> typename SliceT>
   inline T atomic_cas(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, T> address,
       T compare, T value) {
@@ -91,18 +91,18 @@ struct SyCLPlatform {
         .compare_exchange_strong(compare, value);
     return compare;
   }
-  template <typename T, template <breeze::utils::AddressSpace,
-                                  breeze::utils::DataArrangement, typename>
-                        typename SliceT>
+  template <typename T,
+            template <breeze::utils::AddressSpace,
+                      breeze::utils::DataArrangement, typename> typename SliceT>
   inline T atomic_add(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, T> address,
       T value) {
     return cl::sycl::atomic<T>{cl::sycl::global_ptr<T>{address.data()}}
         .fetch_add(value);
   }
-  template <typename T, template <breeze::utils::AddressSpace,
-                                  breeze::utils::DataArrangement, typename>
-                        typename SliceT>
+  template <typename T,
+            template <breeze::utils::AddressSpace,
+                      breeze::utils::DataArrangement, typename> typename SliceT>
   inline T atomic_add(
       SliceT<breeze::utils::SHARED, breeze::utils::BLOCKED, T> address,
       T value) {
@@ -110,18 +110,18 @@ struct SyCLPlatform {
         cl::sycl::local_ptr<T>{address.data()}}
         .fetch_add(value);
   }
-  template <typename T, template <breeze::utils::AddressSpace,
-                                  breeze::utils::DataArrangement, typename>
-                        typename SliceT>
+  template <typename T,
+            template <breeze::utils::AddressSpace,
+                      breeze::utils::DataArrangement, typename> typename SliceT>
   inline void atomic_min(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, T> address,
       T value) {
     cl::sycl::atomic<T>{cl::sycl::global_ptr<T>{address.data()}}.fetch_min(
         value);
   }
-  template <typename T, template <breeze::utils::AddressSpace,
-                                  breeze::utils::DataArrangement, typename>
-                        typename SliceT>
+  template <typename T,
+            template <breeze::utils::AddressSpace,
+                      breeze::utils::DataArrangement, typename> typename SliceT>
   inline void atomic_max(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, T> address,
       T value) {
diff --git a/velox/experimental/breeze/breeze/utils/trace.h b/velox/experimental/breeze/breeze/utils/trace.h
index 0877957bda6..d957955aebe 100644
--- a/velox/experimental/breeze/breeze/utils/trace.h
+++ b/velox/experimental/breeze/breeze/utils/trace.h
@@ -35,7 +35,11 @@
 #define __noinline__ noinline
 #endif
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Warray-bounds"
+#pragma GCC diagnostic ignored "-Wstringop-overflow"
 #include <perfetto.h>
+#pragma GCC diagnostic pop
 
 #include <condition_variable>
 #include <fstream>
diff --git a/velox/experimental/breeze/breeze/utils/types.h b/velox/experimental/breeze/breeze/utils/types.h
index 256d92d1787..c6acd1ee881 100644
--- a/velox/experimental/breeze/breeze/utils/types.h
+++ b/velox/experimental/breeze/breeze/utils/types.h
@@ -170,7 +170,7 @@ class BadDeviceAlloc : public std::exception {
                  ",free=" + std::to_string(free) +
                  ",total=" + std::to_string(total) + ")") {}
 
-  virtual const char *what() const noexcept { return message_.c_str(); }
+  virtual const char* what() const noexcept { return message_.c_str(); }
 
  private:
   std::string message_;
@@ -219,13 +219,13 @@ class Slice<THREAD, A, T> {
   static constant DataArrangement ARRANGEMENT = A;
   using data_type = T;
 
-  ATTR explicit Slice(thread T *data) : data_(data) {}
-  ATTR T const thread &operator[](int index) const { return data_[index]; }
-  ATTR T thread &operator[](int index) { return data_[index]; }
-  ATTR T const thread &operator*() const { return *data_; }
-  ATTR T thread &operator*() { return *data_; }
-  ATTR T const thread *operator->() const { return data_; }
-  ATTR T thread *operator->() { return data_; }
+  ATTR explicit Slice(thread T* data) : data_(data) {}
+  ATTR T const thread& operator[](int index) const { return data_[index]; }
+  ATTR T thread& operator[](int index) { return data_[index]; }
+  ATTR T const thread& operator*() const { return *data_; }
+  ATTR T thread& operator*() { return *data_; }
+  ATTR T const thread* operator->() const { return data_; }
+  ATTR T thread* operator->() { return data_; }
   ATTR Slice<THREAD, A, T> subslice(int offset) {
     return Slice<THREAD, A, T>(data_ + offset);
   }
@@ -233,15 +233,15 @@ class Slice<THREAD, A, T> {
     return Slice<THREAD, A, T>(data_ + offset);
   }
   ATTR operator bool() const { return data_ != nullptr; }
-  ATTR T thread *data() { return data_; }
-  ATTR T const thread *data() const { return data_; }
+  ATTR T thread* data() { return data_; }
+  ATTR T const thread* data() const { return data_; }
 
  private:
-  thread T *data_;
+  thread T* data_;
 };
 
 template <AddressSpace A = THREAD, DataArrangement B = STRIPED, typename T>
-ATTR Slice<THREAD, B, T> constexpr make_slice(thread T *data) {
+ATTR Slice<THREAD, B, T> constexpr make_slice(thread T* data) {
   return Slice<THREAD, B, T>(data);
 }
 
@@ -253,13 +253,13 @@ class Slice<SHARED, A, T> {
   static constant DataArrangement ARRANGEMENT = A;
   using data_type = T;
 
-  ATTR explicit Slice(threadgroup T *data) : data_(data) {}
-  ATTR T const threadgroup &operator[](int index) const { return data_[index]; }
-  ATTR T threadgroup &operator[](int index) { return data_[index]; }
-  ATTR T const threadgroup &operator*() const { return *data_; }
-  ATTR T threadgroup &operator*() { return *data_; }
-  ATTR T const threadgroup *operator->() const { return data_; }
-  ATTR T threadgroup *operator->() { return data_; }
+  ATTR explicit Slice(threadgroup T* data) : data_(data) {}
+  ATTR T const threadgroup& operator[](int index) const { return data_[index]; }
+  ATTR T threadgroup& operator[](int index) { return data_[index]; }
+  ATTR T const threadgroup& operator*() const { return *data_; }
+  ATTR T threadgroup& operator*() { return *data_; }
+  ATTR T const threadgroup* operator->() const { return data_; }
+  ATTR T threadgroup* operator->() { return data_; }
   ATTR Slice<SHARED, A, T> subslice(int offset) {
     return Slice<SHARED, A, T>(data_ + offset);
   }
@@ -267,8 +267,8 @@ class Slice<SHARED, A, T> {
     return Slice<SHARED, A, T>(data_ + offset);
   }
   ATTR operator bool() const { return data_ != nullptr; }
-  ATTR T threadgroup *data() { return data_; }
-  ATTR T const threadgroup *data() const { return data_; }
+  ATTR T threadgroup* data() { return data_; }
+  ATTR T const threadgroup* data() const { return data_; }
 
   template <AddressSpace OTHER>
   ATTR Slice<OTHER, A, T> reinterpret();
@@ -279,11 +279,11 @@ class Slice<SHARED, A, T> {
   }
 
  private:
-  threadgroup T *data_;
+  threadgroup T* data_;
 };
 
 template <AddressSpace A = SHARED, DataArrangement B = BLOCKED, typename T>
-ATTR Slice<SHARED, B, T> constexpr make_slice(threadgroup T *data) {
+ATTR Slice<SHARED, B, T> constexpr make_slice(threadgroup T* data) {
   return Slice<SHARED, B, T>(data);
 }
 
@@ -295,11 +295,11 @@ class Slice<GLOBAL, A, T> {
   static constant DataArrangement ARRANGEMENT = A;
   using data_type = T;
 
-  ATTR explicit Slice(device T *data) : data_(data) {}
-  ATTR T const device &operator[](int index) const { return data_[index]; }
-  ATTR T device &operator[](int index) { return data_[index]; }
-  ATTR T const device &operator*() const { return *data_; }
-  ATTR T device &operator*() { return *data_; }
+  ATTR explicit Slice(device T* data) : data_(data) {}
+  ATTR T const device& operator[](int index) const { return data_[index]; }
+  ATTR T device& operator[](int index) { return data_[index]; }
+  ATTR T const device& operator*() const { return *data_; }
+  ATTR T device& operator*() { return *data_; }
   ATTR Slice<GLOBAL, A, T> subslice(int offset) {
     return Slice<GLOBAL, A, T>(data_ + offset);
   }
@@ -307,15 +307,15 @@ class Slice<GLOBAL, A, T> {
     return Slice<GLOBAL, A, T>(data_ + offset);
   }
   ATTR operator bool() const { return data_ != nullptr; }
-  ATTR T device *data() { return data_; }
-  ATTR T const device *data() const { return data_; }
+  ATTR T device* data() { return data_; }
+  ATTR T const device* data() const { return data_; }
 
  private:
-  device T *data_;
+  device T* data_;
 };
 
 template <AddressSpace A = GLOBAL, DataArrangement B = BLOCKED, typename T>
-ATTR Slice<GLOBAL, B, T> constexpr make_slice(device T *data) {
+ATTR Slice<GLOBAL, B, T> constexpr make_slice(device T* data) {
   return Slice<GLOBAL, B, T>(data);
 }
 
@@ -332,13 +332,13 @@ class Slice<THREAD, A, T> {
   static constexpr DataArrangement ARRANGEMENT = A;
   using data_type = T;
 
-  ATTR explicit Slice(__private T *data) : data_(data) {}
-  ATTR T const __private &operator[](int index) const { return data_[index]; }
-  ATTR T __private &operator[](int index) { return data_[index]; }
-  ATTR T const __private &operator*() const { return *data_; }
-  ATTR T __private &operator*() { return *data_; }
-  ATTR T const __private *operator->() const { return data_; }
-  ATTR T __private *operator->() { return data_; }
+  ATTR explicit Slice(__private T* data) : data_(data) {}
+  ATTR T const __private& operator[](int index) const { return data_[index]; }
+  ATTR T __private& operator[](int index) { return data_[index]; }
+  ATTR T const __private& operator*() const { return *data_; }
+  ATTR T __private& operator*() { return *data_; }
+  ATTR T const __private* operator->() const { return data_; }
+  ATTR T __private* operator->() { return data_; }
   ATTR Slice<THREAD, A, T> subslice(int offset) {
     return Slice<THREAD, A, T>(data_ + offset);
   }
@@ -346,8 +346,8 @@ class Slice<THREAD, A, T> {
     return Slice<THREAD, A, T>(data_ + offset);
   }
   ATTR operator bool() const { return data_ != nullptr; }
-  ATTR T __private *data() { return data_; }
-  ATTR T const __private *data() const { return data_; }
+  ATTR T __private* data() { return data_; }
+  ATTR T const __private* data() const { return data_; }
 
   template <AddressSpace OTHER>
   ATTR Slice<OTHER, A, T> reinterpret();
@@ -358,11 +358,11 @@ class Slice<THREAD, A, T> {
   }
 
  private:
-  __private T *data_;
+  __private T* data_;
 };
 
 template <AddressSpace A = THREAD, DataArrangement B = STRIPED, typename T>
-ATTR Slice<THREAD, B, T> constexpr make_slice(private T *data) {
+ATTR Slice<THREAD, B, T> constexpr make_slice(private T* data) {
   return Slice<THREAD, B, T>(data);
 }
 
@@ -374,13 +374,13 @@ class Slice<SHARED, A, T> {
   static constexpr DataArrangement ARRANGEMENT = A;
   using data_type = T;
 
-  ATTR explicit Slice(local T *data) : data_(data) {}
-  ATTR T const local &operator[](int index) const { return data_[index]; }
-  ATTR T local &operator[](int index) { return data_[index]; }
-  ATTR T const local &operator*() const { return *data_; }
-  ATTR T local &operator*() { return *data_; }
-  ATTR T const local *operator->() const { return data_; }
-  ATTR T local *operator->() { return data_; }
+  ATTR explicit Slice(local T* data) : data_(data) {}
+  ATTR T const local& operator[](int index) const { return data_[index]; }
+  ATTR T local& operator[](int index) { return data_[index]; }
+  ATTR T const local& operator*() const { return *data_; }
+  ATTR T local& operator*() { return *data_; }
+  ATTR T const local* operator->() const { return data_; }
+  ATTR T local* operator->() { return data_; }
   ATTR Slice<SHARED, A, T> subslice(int offset) {
     return Slice<SHARED, A, T>(data_ + offset);
   }
@@ -388,8 +388,8 @@ class Slice<SHARED, A, T> {
     return Slice<SHARED, A, T>(data_ + offset);
   }
   ATTR operator bool() const { return data_ != nullptr; }
-  ATTR T local *data() { return data_; }
-  ATTR T const local *data() const { return data_; }
+  ATTR T local* data() { return data_; }
+  ATTR T const local* data() const { return data_; }
 
   template <AddressSpace OTHER>
   ATTR Slice<OTHER, A, T> reinterpret();
@@ -400,11 +400,11 @@ class Slice<SHARED, A, T> {
   }
 
  private:
-  local T *data_;
+  local T* data_;
 };
 
 template <AddressSpace A = SHARED, DataArrangement B = BLOCKED, typename T>
-ATTR Slice<SHARED, B, T> constexpr make_slice(local T *data) {
+ATTR Slice<SHARED, B, T> constexpr make_slice(local T* data) {
   return Slice<SHARED, B, T>(data);
 }
 
@@ -416,11 +416,11 @@ class Slice<GLOBAL, A, T> {
   static constexpr DataArrangement ARRANGEMENT = A;
   using data_type = T;
 
-  ATTR explicit Slice(global T *data) : data_(data) {}
-  ATTR T const global &operator[](int index) const { return data_[index]; }
-  ATTR T global &operator[](int index) { return data_[index]; }
-  ATTR T const global &operator*() const { return *data_; }
-  ATTR T global &operator*() { return *data_; }
+  ATTR explicit Slice(global T* data) : data_(data) {}
+  ATTR T const global& operator[](int index) const { return data_[index]; }
+  ATTR T global& operator[](int index) { return data_[index]; }
+  ATTR T const global& operator*() const { return *data_; }
+  ATTR T global& operator*() { return *data_; }
   ATTR Slice<GLOBAL, A, T> subslice(int offset) {
     return Slice<GLOBAL, A, T>(data_ + offset);
   }
@@ -428,15 +428,15 @@ class Slice<GLOBAL, A, T> {
     return Slice<GLOBAL, A, T>(data_ + offset);
   }
   ATTR operator bool() const { return data_ != nullptr; }
-  ATTR T global *data() { return data_; }
-  ATTR T const global *data() const { return data_; }
+  ATTR T global* data() { return data_; }
+  ATTR T const global* data() const { return data_; }
 
  private:
-  global T *data_;
+  global T* data_;
 };
 
 template <AddressSpace A = GLOBAL, DataArrangement B = BLOCKED, typename T>
-ATTR Slice<GLOBAL, B, T> constexpr make_slice(global T *data) {
+ATTR Slice<GLOBAL, B, T> constexpr make_slice(global T* data) {
   return Slice<GLOBAL, B, T>(data);
 }
 
@@ -448,15 +448,15 @@ class Slice {
   static constexpr AddressSpace ADDRESS_SPACE = A;
   static constexpr DataArrangement ARRANGEMENT = B;
   using data_type = T;
-  using pointer_type = T *;
+  using pointer_type = T*;
 
   ATTR explicit Slice(pointer_type data) : data_(data) {}
-  ATTR T const &operator[](int index) const { return data_[index]; }
-  ATTR T &operator[](int index) { return data_[index]; }
-  ATTR T const &operator*() const { return *data_; }
-  ATTR T &operator*() { return *data_; }
-  ATTR T const *operator->() const { return data_; }
-  ATTR T *operator->() { return data_; }
+  ATTR T const& operator[](int index) const { return data_[index]; }
+  ATTR T& operator[](int index) { return data_[index]; }
+  ATTR T const& operator*() const { return *data_; }
+  ATTR T& operator*() { return *data_; }
+  ATTR T const* operator->() const { return data_; }
+  ATTR T* operator->() { return data_; }
   ATTR Slice<A, B, T> subslice(int offset) {
     return Slice<A, B, T>(data_ + offset);
   }
@@ -464,8 +464,8 @@ class Slice {
     return Slice<A, B, T>(data_ + offset);
   }
   ATTR operator bool() const { return data_ != nullptr; }
-  ATTR T *data() { return data_; }
-  ATTR T const *data() const { return data_; }
+  ATTR T* data() { return data_; }
+  ATTR T const* data() const { return data_; }
 
   template <AddressSpace OTHER, DataArrangement OTHER_ARRANGEMENT =
                                     OTHER == THREAD ? STRIPED : BLOCKED>
@@ -482,7 +482,7 @@ class Slice {
 // arrangement by default for other address spaces
 template <AddressSpace A = THREAD,
           DataArrangement B = A == THREAD ? STRIPED : BLOCKED, typename T>
-ATTR Slice<A, B, T> constexpr make_slice(T *data) {
+ATTR Slice<A, B, T> constexpr make_slice(T* data) {
   return Slice<A, B, T>(data);
 }
 
diff --git a/velox/experimental/breeze/test/algorithms/kernels.metal b/velox/experimental/breeze/test/algorithms/kernels.metal
index 07a91a7161b..50caf7a9bea 100644
--- a/velox/experimental/breeze/test/algorithms/kernels.metal
+++ b/velox/experimental/breeze/test/algorithms/kernels.metal
@@ -39,8 +39,8 @@ using namespace breeze::utils;
 
 #define GEN_REDUCE_T(O, T, BT, IPT)                                     \
   kernel void NAME(reduce_##O##_##T, T, BT, IPT)(                       \
-      const device T *in [[buffer(0)]], device T *out [[buffer(1)]],    \
-      const device int *num_items [[buffer(2)]],                        \
+      const device T* in [[buffer(0)]], device T* out [[buffer(1)]],    \
+      const device int* num_items [[buffer(2)]],                        \
       uint thread_idx [[thread_index_in_threadgroup]],                  \
       uint block_idx [[threadgroup_position_in_grid]]) {                \
     MetalPlatform<BT, WARP_THREADS> p{thread_idx, block_idx};           \
@@ -60,10 +60,10 @@ GEN_REDUCE(max)
 
 #define GEN_SCAN_T(O, T, BT, IPT, LD)                                          \
   kernel void NAME(scan_##O##_##T, uint_##T, BT, IPT##x##LD)(                  \
-      const device T *in [[buffer(0)]], device T *out [[buffer(1)]],           \
-      device int *next_block_idx [[buffer(2)]],                                \
-      device uint *blocks [[buffer(3)]],                                       \
-      const device int *num_items [[buffer(4)]],                               \
+      const device T* in [[buffer(0)]], device T* out [[buffer(1)]],           \
+      device int* next_block_idx [[buffer(2)]],                                \
+      device uint* blocks [[buffer(3)]],                                       \
+      const device int* num_items [[buffer(4)]],                               \
       uint thread_idx [[thread_index_in_threadgroup]],                         \
       uint block_idx [[threadgroup_position_in_grid]]) {                       \
     MetalPlatform<BT, WARP_THREADS> p{thread_idx, block_idx};                  \
@@ -82,8 +82,8 @@ GEN_SCAN(add)
 
 #define GEN_RADIX_SORT_HISTOGRAM_T(T, BT, IPT, TS, RB)                   \
   kernel void NAME(radix_sort_histogram, T, BT, IPT##x##TS##x##RB)(      \
-      const device T *in [[buffer(0)]], device uint *out [[buffer(1)]],  \
-      const device int *num_items [[buffer(2)]],                         \
+      const device T* in [[buffer(0)]], device uint* out [[buffer(1)]],  \
+      const device int* num_items [[buffer(2)]],                         \
       uint thread_idx [[thread_index_in_threadgroup]],                   \
       uint block_idx [[threadgroup_position_in_grid]]) {                 \
     threadgroup DeviceRadixSortHistogram<RB, T>::Scratch scratch;        \
@@ -104,16 +104,16 @@ GEN_RADIX_SORT_HISTOGRAM(uint)
 
 #define GEN_RADIX_SORT(KT, VT, BT, IPT, RB)                                \
   kernel void NAME2(radix_sort, KT, VT, BT, IPT##x##RB)(                   \
-      const device KT *in_keys [[buffer(0)]],                              \
-      const device VT##_value_type *in_values [[buffer(1)]],               \
-      const device uint *in_offsets [[buffer(2)]],                         \
-      const device int *start_bit [[buffer(3)]],                           \
-      const device int *num_pass_bits [[buffer(4)]],                       \
-      device KT *out_keys [[buffer(5)]],                                   \
-      device VT##_value_type *out_values [[buffer(6)]],                    \
-      device int *next_block_idx [[buffer(7)]],                            \
-      device uint *blocks [[buffer(8)]],                                   \
-      const device int *num_items [[buffer(9)]],                           \
+      const device KT* in_keys [[buffer(0)]],                              \
+      const device VT##_value_type* in_values [[buffer(1)]],               \
+      const device uint* in_offsets [[buffer(2)]],                         \
+      const device int* start_bit [[buffer(3)]],                           \
+      const device int* num_pass_bits [[buffer(4)]],                       \
+      device KT* out_keys [[buffer(5)]],                                   \
+      device VT##_value_type* out_values [[buffer(6)]],                    \
+      device int* next_block_idx [[buffer(7)]],                            \
+      device uint* blocks [[buffer(8)]],                                   \
+      const device int* num_items [[buffer(9)]],                           \
       uint thread_idx [[thread_index_in_threadgroup]],                     \
       uint block_idx [[threadgroup_position_in_grid]]) {                   \
     MetalPlatform<BT, WARP_THREADS> p{thread_idx, block_idx};              \
diff --git a/velox/experimental/breeze/test/functions/kernels.metal b/velox/experimental/breeze/test/functions/kernels.metal
index f8193bfad9b..c211a78beca 100644
--- a/velox/experimental/breeze/test/functions/kernels.metal
+++ b/velox/experimental/breeze/test/functions/kernels.metal
@@ -35,8 +35,8 @@ using namespace breeze::utils;
 
 #define GEN_LOAD(T)                                                          \
   kernel void NAME(load, T, 4, 2)(                                           \
-      const device T *in [[buffer(0)]], device T *out [[buffer(1)]],         \
-      const device int *num_items [[buffer(2)]],                             \
+      const device T* in [[buffer(0)]], device T* out [[buffer(1)]],         \
+      const device int* num_items [[buffer(2)]],                             \
       uint thread_idx [[thread_index_in_threadgroup]]) {                     \
     block_load<4, 2>(MetalPlatform<4, WARP_THREADS>{thread_idx, 0}, in, out, \
                      *num_items);                                            \
@@ -50,9 +50,9 @@ GEN_LOAD(float)
 
 #define GEN_LOAD_IF(T)                                                        \
   kernel void NAME(load_if, T, 4, 2)(                                         \
-      const device T *in [[buffer(0)]],                                       \
-      const device int *in_selection_flags [[buffer(1)]],                     \
-      device T *out [[buffer(2)]], const device int *num_items [[buffer(3)]], \
+      const device T* in [[buffer(0)]],                                       \
+      const device int* in_selection_flags [[buffer(1)]],                     \
+      device T* out [[buffer(2)]], const device int* num_items [[buffer(3)]], \
       uint thread_idx [[thread_index_in_threadgroup]]) {                      \
     block_load_if<4, 2>(MetalPlatform<4, WARP_THREADS>{thread_idx, 0}, in,    \
                         in_selection_flags, out, *num_items);                 \
@@ -66,9 +66,9 @@ GEN_LOAD_IF(float)
 
 #define GEN_LOAD_FROM(T)                                                     \
   kernel void NAME(load_from, T, 4, 2)(                                      \
-      const device T *in [[buffer(0)]],                                      \
-      const device int *offsets [[buffer(1)]], device T *out [[buffer(2)]],  \
-      const device int *num_items [[buffer(3)]],                             \
+      const device T* in [[buffer(0)]],                                      \
+      const device int* offsets [[buffer(1)]], device T* out [[buffer(2)]],  \
+      const device int* num_items [[buffer(3)]],                             \
       uint thread_idx [[thread_index_in_threadgroup]]) {                     \
     block_load_from<4, 2>(MetalPlatform<4, WARP_THREADS>{thread_idx, 0}, in, \
                           offsets, out, *num_items);                         \
@@ -82,8 +82,8 @@ GEN_LOAD_FROM(float)
 
 #define GEN_STORE(T)                                                          \
   kernel void NAME(store, T, 4, 2)(                                           \
-      const device T *in [[buffer(0)]], device T *out [[buffer(1)]],          \
-      const device int *num_items [[buffer(2)]],                              \
+      const device T* in [[buffer(0)]], device T* out [[buffer(1)]],          \
+      const device int* num_items [[buffer(2)]],                              \
       uint thread_idx [[thread_index_in_threadgroup]]) {                      \
     block_store<4, 2>(MetalPlatform<4, WARP_THREADS>{thread_idx, 0}, in, out, \
                       *num_items);                                            \
@@ -97,9 +97,9 @@ GEN_STORE(float)
 
 #define GEN_STORE_IF(T)                                                       \
   kernel void NAME(store_if, T, 4, 2)(                                        \
-      const device T *in [[buffer(0)]],                                       \
-      const device int *selection_flags [[buffer(1)]],                        \
-      device T *out [[buffer(2)]], const device int *num_items [[buffer(3)]], \
+      const device T* in [[buffer(0)]],                                       \
+      const device int* selection_flags [[buffer(1)]],                        \
+      device T* out [[buffer(2)]], const device int* num_items [[buffer(3)]], \
       uint thread_idx [[thread_index_in_threadgroup]]) {                      \
     block_store_if<4, 2>(MetalPlatform<4, WARP_THREADS>{thread_idx, 0}, in,   \
                          selection_flags, out, *num_items);                   \
@@ -113,9 +113,9 @@ GEN_STORE_IF(float)
 
 #define GEN_STORE_AT(T)                                                     \
   kernel void NAME(store_at, T, 1, 8)(                                      \
-      const device T *in [[buffer(0)]],                                     \
-      const device int *offsets [[buffer(1)]], device T *out [[buffer(2)]], \
-      const device int *num_items [[buffer(3)]],                            \
+      const device T* in [[buffer(0)]],                                     \
+      const device int* offsets [[buffer(1)]], device T* out [[buffer(2)]], \
+      const device int* num_items [[buffer(3)]],                            \
       uint thread_idx [[thread_index_in_threadgroup]]) {                    \
     block_store_at<1, 8>(MetalPlatform<1, WARP_THREADS>{thread_idx, 0}, in, \
                          offsets, out, *num_items);                         \
@@ -129,10 +129,10 @@ GEN_STORE_AT(float)
 
 #define GEN_STORE_AT_IF(T)                                                     \
   kernel void NAME(store_at_if, T, 1, 8)(                                      \
-      const device T *in [[buffer(0)]],                                        \
-      const device int *offsets [[buffer(1)]],                                 \
-      const device int *selection_flags [[buffer(2)]],                         \
-      device T *out [[buffer(3)]], const device int *num_items [[buffer(4)]],  \
+      const device T* in [[buffer(0)]],                                        \
+      const device int* offsets [[buffer(1)]],                                 \
+      const device int* selection_flags [[buffer(2)]],                         \
+      device T* out [[buffer(3)]], const device int* num_items [[buffer(4)]],  \
       uint thread_idx [[thread_index_in_threadgroup]]) {                       \
     block_store_at_if<1, 8>(MetalPlatform<1, WARP_THREADS>{thread_idx, 0}, in, \
                             offsets, selection_flags, out, *num_items);        \
@@ -146,8 +146,8 @@ GEN_STORE_AT_IF(float)
 
 #define GEN_FILL(T)                                                        \
   kernel void NAME(fill, T, 4, 2)(                                         \
-      const device T *value [[buffer(0)]], device T *out [[buffer(1)]],    \
-      const device int *num_items [[buffer(2)]],                           \
+      const device T* value [[buffer(0)]], device T* out [[buffer(1)]],    \
+      const device int* num_items [[buffer(2)]],                           \
       uint thread_idx [[thread_index_in_threadgroup]]) {                   \
     block_fill<4, 2>(MetalPlatform<4, WARP_THREADS>{thread_idx, 0}, value, \
                      out, *num_items);                                     \
@@ -161,10 +161,10 @@ GEN_FILL(float)
 
 #define GEN_FILL_AT_IF(T)                                                     \
   kernel void NAME(fill_at_if, T, 1, 8)(                                      \
-      const device T *value [[buffer(0)]],                                    \
-      const device int *offsets [[buffer(1)]],                                \
-      const device int *selection_flags [[buffer(2)]],                        \
-      device T *out [[buffer(3)]], const device int *num_items [[buffer(4)]], \
+      const device T* value [[buffer(0)]],                                    \
+      const device int* offsets [[buffer(1)]],                                \
+      const device int* selection_flags [[buffer(2)]],                        \
+      device T* out [[buffer(3)]], const device int* num_items [[buffer(4)]], \
       uint thread_idx [[thread_index_in_threadgroup]]) {                      \
     block_fill_at_if<1, 8>(MetalPlatform<1, WARP_THREADS>{thread_idx, 0},     \
                            value, offsets, selection_flags, out, *num_items); \
@@ -182,8 +182,8 @@ GEN_FILL_AT_IF(float)
 
 #define GEN_REDUCE_T(O, T, BT, IPT)                                         \
   kernel void NAME(reduce_##O##_##T, T, BT, IPT)(                           \
-      const device T *in [[buffer(0)]], device T *out [[buffer(1)]],        \
-      const device int *num_items [[buffer(2)]],                            \
+      const device T* in [[buffer(0)]], device T* out [[buffer(1)]],        \
+      const device int* num_items [[buffer(2)]],                            \
       uint thread_idx [[thread_index_in_threadgroup]]) {                    \
     MetalPlatform<BT, WARP_THREADS> p{thread_idx, 0};                       \
     threadgroup BlockReduce<decltype(p), T>::Scratch scratch;               \
@@ -206,8 +206,8 @@ GEN_REDUCE(max)
 
 #define GEN_SCAN_T(O, T, BT, IPT)                                       \
   kernel void NAME(scan_##O##_##T, T, BT, IPT)(                         \
-      const device T *in [[buffer(0)]], device T *out [[buffer(1)]],    \
-      const device int *num_items [[buffer(2)]],                        \
+      const device T* in [[buffer(0)]], device T* out [[buffer(1)]],    \
+      const device int* num_items [[buffer(2)]],                        \
       uint thread_idx [[thread_index_in_threadgroup]]) {                \
     MetalPlatform<BT, WARP_THREADS> p{thread_idx, 0};                   \
     threadgroup BlockScan<decltype(p), T, IPT>::Scratch scratch;        \
@@ -226,8 +226,8 @@ GEN_SCAN(add)
 
 #define GEN_RADIX_RANK(T, BT, IPT, RB)                                 \
   kernel void NAME(radix_rank, T, BT, IPT##x##RB)(                     \
-      const device T *in [[buffer(0)]], device int *out [[buffer(1)]], \
-      const device int *num_items [[buffer(2)]],                       \
+      const device T* in [[buffer(0)]], device int* out [[buffer(1)]], \
+      const device int* num_items [[buffer(2)]],                       \
       uint thread_idx [[thread_index_in_threadgroup]]) {               \
     MetalPlatform<BT, WARP_THREADS> p{thread_idx, 0};                  \
     threadgroup BlockRadixRank<decltype(p), IPT, RB>::Scratch scratch; \
@@ -242,11 +242,11 @@ GEN_RADIX_RANK(uint, 64, 2, 6)
 
 #define GEN_RADIX_SORT(KT, VT, BT, IPT, RB)                                    \
   kernel void NAME2(radix_sort, KT, VT, BT, IPT##x##RB)(                       \
-      const device KT *in_keys [[buffer(0)]],                                  \
-      const device VT##_value_type *in_values [[buffer(1)]],                   \
-      device KT *out_keys [[buffer(2)]],                                       \
-      device VT##_value_type *out_values [[buffer(3)]],                        \
-      const device int *num_items [[buffer(4)]],                               \
+      const device KT* in_keys [[buffer(0)]],                                  \
+      const device VT##_value_type* in_values [[buffer(1)]],                   \
+      device KT* out_keys [[buffer(2)]],                                       \
+      device VT##_value_type* out_values [[buffer(3)]],                        \
+      const device int* num_items [[buffer(4)]],                               \
       uint thread_idx [[thread_index_in_threadgroup]]) {                       \
     MetalPlatform<BT, WARP_THREADS> p{thread_idx, 0};                          \
     threadgroup BlockRadixSort<decltype(p), IPT, RB, KT,                       \
diff --git a/velox/experimental/cudf/CMakeLists.txt b/velox/experimental/cudf/CMakeLists.txt
index 96fcdb0d557..edbb5feeebe 100644
--- a/velox/experimental/cudf/CMakeLists.txt
+++ b/velox/experimental/cudf/CMakeLists.txt
@@ -12,10 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_subdirectory(exec)
 add_subdirectory(connectors)
+add_subdirectory(exec)
+add_subdirectory(expression)
 add_subdirectory(vector)
 
 if(VELOX_BUILD_TESTING)
   add_subdirectory(tests)
+elseif(VELOX_BUILD_TEST_UTILS)
+  add_subdirectory(tests/utils)
+endif()
+
+if(VELOX_ENABLE_BENCHMARKS)
+  add_subdirectory(benchmarks)
 endif()
diff --git a/velox/experimental/cudf/CudfConfig.h b/velox/experimental/cudf/CudfConfig.h
new file mode 100644
index 00000000000..48b6677f377
--- /dev/null
+++ b/velox/experimental/cudf/CudfConfig.h
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cudf/types.hpp>
+
+#include <optional>
+#include <string>
+#include <unordered_map>
+
+namespace facebook::velox::cudf_velox {
+
+struct CudfConfig {
+  /// Keys used by the initialize() method.
+  static constexpr const char* kCudfEnabled{"cudf.enabled"};
+  static constexpr const char* kCudfDebugEnabled{"cudf.debug_enabled"};
+  static constexpr const char* kCudfMemoryResource{"cudf.memory_resource"};
+  static constexpr const char* kCudfMemoryPercent{"cudf.memory_percent"};
+  static constexpr const char* kCudfFunctionNamePrefix{
+      "cudf.function_name_prefix"};
+  static constexpr const char* kCudfAstExpressionEnabled{
+      "cudf.ast_expression_enabled"};
+  static constexpr const char* kCudfAstExpressionPriority{
+      "cudf.ast_expression_priority"};
+  static constexpr const char* kCudfJitExpressionEnabled{
+      "cudf.jit_expression_enabled"};
+  static constexpr const char* kCudfJitExpressionPriority{
+      "cudf.jit_expression_priority"};
+  static constexpr const char* kCudfOutputMr{"cudf.output_mr"};
+  static constexpr const char* kCudfAllowCpuFallback{"cudf.allow_cpu_fallback"};
+  static constexpr const char* kCudfLogFallback{"cudf.log_fallback"};
+  static constexpr const char* kCudfBatchSizeMinThreshold{
+      "cudf.batch_size_min_threshold"};
+  static constexpr const char* kCudfBatchSizeMaxThreshold{
+      "cudf.batch_size_max_threshold"};
+  static constexpr const char* kCudfConcatOptimizationEnabled{
+      "cudf.concat_optimization_enabled"};
+  static constexpr const char* kCudfTimestampUnit{"cudf.timestamp_unit"};
+  /// Query session configs for the cuDF Operators.
+  static constexpr const char* kCudfTopNBatchSize{"cudf.topk_batch_size"};
+
+  /// Singleton CudfConfig instance.
+  /// Clients must set the configs below before invoking registerCudf().
+  static CudfConfig& getInstance();
+
+  /// Initialize from a map with the above keys.
+  void initialize(std::unordered_map<std::string, std::string>&&);
+
+  /// Enable cudf by default.
+  /// Clients can disable here and enable it via the QueryConfig as well.
+  bool enabled{true};
+
+  /// Enable debug printing.
+  bool debugEnabled{false};
+
+  /// Allow fallback to CPU operators if GPU operator replacement fails.
+  bool allowCpuFallback{true};
+
+  /// Memory resource for cuDF.
+  /// Possible values are (cuda, pool, async, arena, managed, managed_pool).
+  std::string memoryResource{"async"};
+
+  /// The initial percent of GPU memory to allocate for pool or arena memory
+  /// resources.
+  int32_t memoryPercent{50};
+
+  /// Memory resource for output vectors. When set to a value different from
+  /// memoryResource, a separate MR is created for output allocations.
+  /// When empty, the main memoryResource is used.
+  std::string outputMemoryResource;
+
+  /// Register all the functions with the functionNamePrefix.
+  std::string functionNamePrefix;
+
+  /// Enable AST in expression evaluation.
+  bool astExpressionEnabled{true};
+
+  /// Enable JIT in expression evaluation.
+  bool jitExpressionEnabled{true};
+
+  /// Priority of AST expression. Expression with higher priority is chosen for
+  /// a given root expression.
+  /// Example:
+  /// Priority of expression that uses individual cuDF functions is 50.
+  /// If AST priority is 100 then for a velox expression node that is supported
+  /// by both, AST will be chosen as replacement for cudf execution, if AST
+  /// priority is 25 then standalone cudf function is chosen.
+  int astExpressionPriority{100};
+
+  /// Priority of JIT expression.
+  int jitExpressionPriority{101};
+
+  /// Whether to log a reason for falling back to Velox CPU execution.
+  bool logFallback{true};
+
+  /// Whether to insert CudfBatchConcat operators before supported Cudf
+  /// operators.
+  /// This can improve performance by reducing the number of cuda kernel
+  /// launches on addInput of certain operators by collecting a minimum number
+  /// of rows before concatenating and passing on to the next operator.
+  /// This batch size is determined by batchSizeMinThreshold and
+  /// batchSizeMaxThreshold
+  bool concatOptimizationEnabled{false};
+
+  /// Minimum rows to accumulate before GPU-side concatenation in
+  /// `CudfBatchConcat` (default 100k).
+  int32_t batchSizeMinThreshold{100000};
+
+  /// Maximum rows allowed in a concatenated batch (user configurable).
+  /// When not set, cuDF's own `size_type::max()` is used.
+  std::optional<int32_t> batchSizeMaxThreshold;
+  // Query config key for the TopN batch size in the cuDF TopN operator.
+  int32_t topNBatchSize{5};
+
+  /// Timestamp unit for cuDF timestamp types.
+  /// Can be configured via kCudfTimestampUnit with string values:
+  /// "s" (seconds), "ms" (milliseconds), "us" (microseconds), "ns"
+  /// (nanoseconds).
+  cudf::type_id timestampUnit = cudf::type_id::TIMESTAMP_NANOSECONDS;
+};
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/CudfDefaultStreamOverload.h b/velox/experimental/cudf/CudfDefaultStreamOverload.h
new file mode 100644
index 00000000000..7fa5ebe4f33
--- /dev/null
+++ b/velox/experimental/cudf/CudfDefaultStreamOverload.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+// Tag-dispatched overload of cudf::get_default_stream() that bypasses the
+// __attribute__((error)) poison in CudfNoDefaults.h. Call sites that
+// intentionally need the default CUDA stream should use:
+//
+//   cudf::get_default_stream(cudf::allow_default_stream)
+//
+// The definition lives in GpuResources.cpp (which does NOT include
+// CudfNoDefaults.h, so it can call the real cudf::get_default_stream()).
+
+#include <rmm/cuda_stream_view.hpp>
+
+namespace cudf {
+
+struct allow_default_stream_t {};
+constexpr allow_default_stream_t allow_default_stream{};
+
+rmm::cuda_stream_view const get_default_stream(allow_default_stream_t);
+
+} // namespace cudf
diff --git a/velox/experimental/cudf/CudfNoDefaults.h b/velox/experimental/cudf/CudfNoDefaults.h
new file mode 100644
index 00000000000..7a37a755384
--- /dev/null
+++ b/velox/experimental/cudf/CudfNoDefaults.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+// Include this header AFTER all cudf headers in .cpp files under
+// velox/experimental/cudf/ to detect accidental use of cudf default arguments
+// for stream and mr parameters at compile time.
+//
+// cudf public APIs declare defaults like:
+//   rmm::cuda_stream_view stream = cudf::get_default_stream(),
+//   rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref()
+//
+// When a call site omits stream or mr, the compiler generates a call to these
+// default getter functions. The __attribute__((error)) redeclarations below
+// cause a hard compile error for any such generated call. The noinline
+// attribute prevents the inline body of get_current_device_resource_ref() from
+// being substituted, ensuring the call (and thus the error) survives.
+//
+// For intentional explicit usage where you want the current device memory
+// resource, use get_temp_mr(). It calls the underlying RMM
+// function directly, bypassing the error-attributed cudf wrapper.
+
+#include "velox/experimental/cudf/CudfDefaultStreamOverload.h"
+
+#include <rmm/mr/per_device_resource.hpp>
+#include <rmm/resource_ref.hpp>
+
+namespace cudf {
+
+#if defined(__GNUC__) && !defined(__clang__)
+
+__attribute__((
+    error("cudf default stream argument used. Pass stream explicitly."),
+    noinline)) rmm::cuda_stream_view const get_default_stream();
+
+__attribute__((
+    error("cudf default memory resource argument used. Pass mr explicitly."),
+    noinline)) rmm::device_async_resource_ref
+get_current_device_resource_ref();
+
+#endif
+
+} // namespace cudf
+
+namespace facebook::velox::cudf_velox {
+
+/// Returns the current device memory resource as an async resource reference.
+/// Equivalent to cudf::get_current_device_resource_ref(), but bypasses the
+/// __attribute__((error)) redeclaration above by calling the underlying RMM
+/// function directly. Use this at call sites where you intentionally want
+/// the current default device memory resource.
+inline rmm::device_async_resource_ref get_temp_mr() {
+  return rmm::mr::get_current_device_resource_ref();
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/README.md b/velox/experimental/cudf/README.md
new file mode 100644
index 00000000000..ebc80614be4
--- /dev/null
+++ b/velox/experimental/cudf/README.md
@@ -0,0 +1,70 @@
+# Velox-cuDF
+
+Velox-cuDF is a Velox extension module that uses the cuDF library to implement a GPU-accelerated backend for executing Velox plans. [cuDF](https://github.com/rapidsai/cudf) is an open source library for GPU data processing, and Velox-cuDF integrates with "[libcudf](https://github.com/rapidsai/cudf/tree/main/cpp)", the CUDA C++ core of cuDF. libcudf uses [Arrow](https://arrow.apache.org)-compatible data layouts and includes single-node, single-GPU algorithms for data processing.
+
+## How Velox and cuDF work together
+
+Velox-cuDF implements the Velox [DriverAdapter](https://github.com/facebookincubator/velox/blob/d9f953cd23880f29593534f1ba9031c6cea8ba06/velox/exec/Driver.h#L695) interface as [CudfDriverAdapter](https://github.com/facebookincubator/velox/blob/226b92cefedce4b8a484bfc351260edbd3d2e501/velox/experimental/cudf/exec/ToCudf.cpp#L301) to rewrite query plans for GPU execution. Generally the cuDF DriverAdapter replaces operators one-to-one. For end-to-end GPU execution where cuDF replaces all of the Velox CPU operators, cuDF relies on Velox's [pipeline-based execution model](https://facebookincubator.github.io/velox/develop/task.html) to separate stages of execution, partition the work across drivers, and schedule concurrent work on the GPU.
+
+For more information please refer to our blog: "[Extending Velox - GPU Acceleration with cuDF](https://velox-lib.io/blog/extending-velox-with-cudf)."
+
+## Getting started with Velox-cuDF
+
+cuDF supports Linux and WSL2 but not Windows or MacOS. cuDF also has minimum CUDA version, NVIDIA driver and GPU architecture requirements which can be found in the [RAPIDS Installation Guide](https://docs.rapids.ai/install/). Please refer to cuDF's [readme](https://github.com/rapidsai/cudf) and [developer guide](https://github.com/rapidsai/cudf/blob/main/cpp/doxygen/developer_guide/DEVELOPER_GUIDE.md) for more information.
+
+### Building Velox with cuDF
+
+The cuDF backend is included in Velox builds when the [VELOX_ENABLE_CUDF](https://github.com/facebookincubator/velox/blob/43df50c4f24bcbfa96f5739c072ab0894d41cf4c/CMakeLists.txt#L455) CMake option is set. The `adapters-cuda` service in Velox's [docker-compose.yml](https://github.com/facebookincubator/velox/blob/43df50c4f24bcbfa96f5739c072ab0894d41cf4c/docker-compose.yml#L69) is an excellent starting point for Velox builds with cuDF.
+
+1. Use `docker compose` to run an `adapters-cuda` image.
+```shell
+docker compose -f docker-compose.yml run -e NUM_THREADS=8 --rm -v "$(pwd):/velox" adapters-cuda /bin/bash
+```
+2. Once inside the image, build cuDF with the following flags:
+```shell
+CUDA_ARCHITECTURES="native" EXTRA_CMAKE_FLAGS="-DVELOX_ENABLE_ARROW=ON -DVELOX_ENABLE_PARQUET=ON -DVELOX_ENABLE_BENCHMARKS=ON -DVELOX_ENABLE_BENCHMARKS_BASIC=ON" make cudf
+```
+3. After cuDF is built, verify the build by running the unit tests.
+```shell
+cd _build/release
+ctest -R cudf -V
+```
+
+Velox-cuDF builds are included in Velox CI as part of the [adapters build](https://github.com/facebookincubator/velox/blob/de31a3eb07b5ec3cbd1e6320a989fcb2ee1a95a7/.github/workflows/linux-build-base.yml#L85). The build step for cuDF does not require the worker to have a GPU, so adding a Velox-cuDF build step to Velox CI is compatible with the existing runners.
+
+### Configuring Velox-cuDF
+
+Velox-cuDF provides several configuration properties to control GPU execution behavior, memory management, and debugging. These configurations are available when compiled with cuDF support and can be set via Velox's configuration system. For a complete list of cuDF-specific configuration properties and their descriptions, see the [Cudf-specific Configuration section](https://facebookincubator.github.io/velox/configs.html#cudf-specific-configuration-experimental) in the Velox configuration documentation.
+
+### Testing Velox with cuDF
+
+Tests with Velox-cuDF can only be run on GPU-enabled hardware. The Velox-cuDF tests in [experimental/cudf/tests](https://github.com/facebookincubator/velox/blob/main/velox/experimental/cudf/tests) include several types of tests:
+* operator tests
+* function tests
+* fuzz tests (not yet implemented)
+
+The repo [rapidsai/velox-testing](https://github.com/rapidsai/velox-testing/) includes standard scripts for testing Velox-cuDF. Please refer to the [test_velox.sh](https://github.com/rapidsai/velox-testing/blob/main/velox/scripts/test_velox.sh) for running the Velox-cuDF unit tests. We plan to first develop GitHub Actions for GPU CI in [rapidsai/velox-testing](https://github.com/rapidsai/velox-testing/), and then later transition GPU-enabled GitHub Actions to Velox mainline.
+
+#### Operator tests
+
+Many of the tests for cuDF are "operator tests" which confirm correct execution of simple query plans. cuDF's operator tests use `CudfDriverAdapter` to modify the test plan with GPU operators before executing it. The operator tests for cuDF include both tests that assert successful GPU operator replacement, and tests that pass with CPU fallback.
+
+#### Function tests
+
+Velox-cuDF also includes "function tests" which cover the behavior of shared functions that could be called in multiple operators. Velox-cuDF function tests assess the correctness of functions using one or more cuDF API calls to provide the output. [SubfieldFilterAstTest](https://github.com/facebookincubator/velox/blob/99a04b94eed42d1c35ae99101da3bf77b31652e8/velox/experimental/cudf/tests/SubfieldFilterAstTest.cpp#L158) includes several examples of function tests. Please note that unit tests for cuDF APIs are included in [cudf/cpp/tests](https://github.com/rapidsai/cudf/tree/branch-25.10/cpp/tests) rather than Velox.
+
+#### Fuzz tests
+
+Velox includes components for "fuzz testing" to ensure robustness of Velox operators. For instance, the [Join Fuzzer](https://github.com/facebookincubator/velox/blob/99a04b94eed42d1c35ae99101da3bf77b31652e8/velox/docs/develop/testing/join-fuzzer.rst) executes a random join type with random inputs and compares the Velox results with a reference query engine. Fuzz testing tools have been used for cuDF operator development, but fuzz testing for cuDF is not yet integrated into Velox mainline.
+
+### Benchmarking Velox with cuDF
+
+Velox's [TpchBenchmark](https://github.com/facebookincubator/velox/blob/d9f953cd23880f29593534f1ba9031c6cea8ba06/velox/benchmarks/tpch/TpchBenchmark.cpp) is derived from [TPC-H](https://www.tpc.org/tpch/) and provides a convenient tool for  benchmarking Velox's performance with OLAP (Online Analytical Processing) workloads. Velox-cuDF includes GPU operators for the hand-built query plans located in [TpchQueryBuilder](https://github.com/facebookincubator/velox/blob/43df50c4f24bcbfa96f5739c072ab0894d41cf4c/velox/exec/tests/utils/TpchQueryBuilder.cpp). Velox [PR 13695](https://github.com/facebookincubator/velox/pull/13695) extends Velox's TpchBenchmark to the cuDF backend.
+
+Please note that Velox's hand-built query plans require the data set to have floating-point types in place of the fixed-point types defined in the standard. Further development of Velox's TpchBenchmark could allow correct behavior with both fixed-point and floating-point types.
+
+## Contributing
+
+Velox-cuDF's development priorities are documented as Velox issues using the "[cuDF]" prefix. Please check out the [open issues](https://github.com/facebookincubator/velox/issues?q=is%3Aissue%20state%3Aopen%20%5BcuDF%5D) to learn more.
+
+We would love to hear from you in Velox's Slack workspace, please see Velox discussion [11348](https://github.com/facebookincubator/velox/discussions/11348) for information on joining.
diff --git a/velox/experimental/cudf/benchmarks/CMakeLists.txt b/velox/experimental/cudf/benchmarks/CMakeLists.txt
new file mode 100644
index 00000000000..eb6a6a4da7d
--- /dev/null
+++ b/velox/experimental/cudf/benchmarks/CMakeLists.txt
@@ -0,0 +1,49 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# --- TPC-H benchmarks ---
+
+add_executable(velox_cudf_tpch_benchmark CudfTpchBenchmark.cpp)
+
+target_link_libraries(
+  velox_cudf_tpch_benchmark
+  velox_cudf_exec
+  velox_cudf_exec_test_lib
+  velox_tpch_benchmark_lib
+)
+
+# --- TPC-DS benchmarks ---
+
+add_executable(velox_cudf_tpcds_benchmark CudfTpcdsBenchmark.cpp)
+
+target_link_libraries(
+  velox_cudf_tpcds_benchmark
+  velox_cudf_exec
+  velox_cudf_exec_test_lib
+  velox_tpcds_benchmark_lib
+)
+
+# --- other benchmarks ---
+
+add_executable(velox_cudf_interop_benchmark CudfInteropBenchmark.cpp)
+
+target_link_libraries(
+  velox_cudf_interop_benchmark
+  velox_cudf_exec
+  velox_memory
+  velox_vector
+  velox_vector_fuzzer
+  Folly::folly
+  Folly::follybenchmark
+)
diff --git a/velox/experimental/cudf/benchmarks/CudfInteropBenchmark.cpp b/velox/experimental/cudf/benchmarks/CudfInteropBenchmark.cpp
new file mode 100644
index 00000000000..3b0f14dacf2
--- /dev/null
+++ b/velox/experimental/cudf/benchmarks/CudfInteropBenchmark.cpp
@@ -0,0 +1,423 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+
+#include "velox/common/memory/Memory.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+#include <cudf/utilities/default_stream.hpp>
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+namespace facebook::velox::cudf_velox {
+namespace {
+
+class CudfInteropBenchmark {
+ public:
+  CudfInteropBenchmark() {
+    pool_ = memory::memoryManager()->addLeafPool();
+  }
+
+  std::unique_ptr<cudf::table> veloxToCudf(const RowVectorPtr& data) {
+    // Ensure the vector is flat before exporting.
+    VectorPtr flatData = data;
+    BaseVector::flattenVector(flatData);
+    auto cudfTable = with_arrow::toCudfTable(
+        std::static_pointer_cast<RowVector>(flatData), pool_.get(), stream, mr);
+    stream.synchronize();
+    VELOX_CHECK_NOT_NULL(cudfTable);
+    VELOX_CHECK_EQ(cudfTable->num_rows(), flatData->size());
+    return cudfTable;
+  }
+
+  void cudfToVelox(
+      std::unique_ptr<cudf::table>& cudfTable,
+      const RowTypePtr& rowType) {
+    auto veloxData = with_arrow::toVeloxColumn(
+        cudfTable->view(), pool_.get(), rowType, stream, mr);
+    stream.synchronize();
+    VELOX_CHECK_NOT_NULL(veloxData);
+    VELOX_CHECK_EQ(veloxData->size(), cudfTable->num_rows());
+  }
+
+  std::unique_ptr<cudf::table> veloxToCudfLarge(
+      const RowTypePtr& rowType,
+      size_t numRows) {
+    folly::BenchmarkSuspender suspender;
+    auto data = makeLargeData(rowType, numRows);
+    // Ensure the vector is flat before exporting.
+    VectorPtr flatData = data;
+    BaseVector::flattenVector(flatData);
+    suspender.dismiss();
+
+    auto stream = cudf::get_default_stream();
+    auto mr = cudf::get_current_device_resource_ref();
+    auto cudfTable = with_arrow::toCudfTable(
+        std::static_pointer_cast<RowVector>(flatData), pool_.get(), stream, mr);
+    stream.synchronize();
+    VELOX_CHECK_NOT_NULL(cudfTable);
+    VELOX_CHECK_EQ(cudfTable->num_rows(), flatData->size());
+    return cudfTable;
+  }
+
+  void cudfToVeloxLarge(
+      std::unique_ptr<cudf::table>& cudfTable,
+      const RowTypePtr& rowType) {
+    auto veloxData = with_arrow::toVeloxColumn(
+        cudfTable->view(), pool_.get(), rowType, stream, mr);
+    stream.synchronize();
+    VELOX_CHECK_NOT_NULL(veloxData);
+    VELOX_CHECK_EQ(veloxData->size(), cudfTable->num_rows());
+  }
+
+  RowVectorPtr makeLargeData(const RowTypePtr& rowType, size_t maxRows) {
+    VectorFuzzer::Options options;
+    options.vectorSize = 1'000;
+    options.nullRatio = 0.25;
+    options.allowDictionaryVector = false;
+
+    const auto seed = 1; // For reproducibility.
+    VectorFuzzer fuzzer(options, pool_.get(), seed);
+
+    // Create initial batch
+    auto result = fuzzer.fuzzInputRow(rowType);
+
+    // Use exponential growth: append result to itself to double the size
+    // Check if doubling would exceed maxRows before appending
+    size_t currentSize = result->size();
+    while (currentSize * 2 < maxRows) {
+      // Append result to itself for exponential growth
+      result->append(result.get());
+      currentSize = result->size();
+    }
+
+    return result;
+  }
+
+  RowVectorPtr makeData(const RowTypePtr& rowType, double nullRatio = 0.25) {
+    folly::BenchmarkSuspender suspender;
+    VectorFuzzer::Options options;
+    options.vectorSize = 1'000;
+    options.nullRatio = nullRatio;
+    options.allowDictionaryVector = false;
+
+    const auto seed = 1; // For reproducibility.
+    VectorFuzzer fuzzer(options, pool_.get(), seed);
+    auto vector = fuzzer.fuzzInputRow(rowType);
+    suspender.dismiss();
+    return vector;
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_;
+  rmm::cuda_stream_view stream = cudf::get_default_stream();
+  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref();
+};
+
+size_t iters = 2000;
+
+#define INTEROP_BENCHMARKS(name, rowType)         \
+  BENCHMARK(velox_to_cudf_##name) {               \
+    CudfInteropBenchmark benchmark;               \
+                                                  \
+    folly::BenchmarkSuspender suspender;          \
+    auto data = benchmark.makeData(rowType);      \
+    suspender.dismiss();                          \
+                                                  \
+    for (auto i = 0; i < iters; ++i) {            \
+      benchmark.veloxToCudf(data);                \
+    }                                             \
+  }                                               \
+                                                  \
+  BENCHMARK(cudf_to_velox_##name) {               \
+    CudfInteropBenchmark benchmark;               \
+                                                  \
+    folly::BenchmarkSuspender suspender;          \
+    auto data = benchmark.makeData(rowType);      \
+    auto cudfTable = benchmark.veloxToCudf(data); \
+    suspender.dismiss();                          \
+                                                  \
+    for (auto i = 0; i < iters; ++i) {            \
+      benchmark.cudfToVelox(cudfTable, rowType);  \
+    }                                             \
+  }                                               \
+                                                  \
+  BENCHMARK(velox_to_cudf_non_null_##name) {      \
+    CudfInteropBenchmark benchmark;               \
+                                                  \
+    folly::BenchmarkSuspender suspender;          \
+    auto data = benchmark.makeData(rowType, 0);   \
+    suspender.dismiss();                          \
+                                                  \
+    for (auto i = 0; i < iters; ++i) {            \
+      benchmark.veloxToCudf(data);                \
+    }                                             \
+  }                                               \
+                                                  \
+  BENCHMARK(cudf_to_velox_non_null_##name) {      \
+    CudfInteropBenchmark benchmark;               \
+                                                  \
+    folly::BenchmarkSuspender suspender;          \
+    auto data = benchmark.makeData(rowType, 0);   \
+    auto cudfTable = benchmark.veloxToCudf(data); \
+    suspender.dismiss();                          \
+                                                  \
+    for (auto i = 0; i < iters; ++i) {            \
+      benchmark.cudfToVelox(cudfTable, rowType);  \
+    }                                             \
+  }
+
+// Fixed-width type benchmarks with non-null variants (1000 rows)
+INTEROP_BENCHMARKS(
+    fixedWidth5,
+    ROW({BIGINT(), DOUBLE(), BOOLEAN(), TINYINT(), REAL()}));
+
+INTEROP_BENCHMARKS(
+    fixedWidth10,
+    ROW({
+        BIGINT(),
+        BIGINT(),
+        BIGINT(),
+        BIGINT(),
+        BIGINT(),
+        BIGINT(),
+        DOUBLE(),
+        BIGINT(),
+        BIGINT(),
+        BIGINT(),
+    }));
+
+INTEROP_BENCHMARKS(
+    fixedWidth20,
+    ROW({
+        BIGINT(), BIGINT(), BIGINT(), BIGINT(), BIGINT(), BIGINT(), BIGINT(),
+        BIGINT(), BIGINT(), BIGINT(), DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE(),
+        DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE(), BIGINT(), BIGINT(),
+    }));
+
+// Decimal benchmarks
+INTEROP_BENCHMARKS(decimals, ROW({BIGINT(), DECIMAL(12, 2), DECIMAL(38, 18)}));
+
+// String benchmarks with non-null variants (1000 rows)
+INTEROP_BENCHMARKS(strings1, ROW({BIGINT(), VARCHAR()}));
+
+INTEROP_BENCHMARKS(
+    strings5,
+    ROW({
+        BIGINT(),
+        VARCHAR(),
+        VARCHAR(),
+        VARCHAR(),
+        VARCHAR(),
+        VARCHAR(),
+    }));
+
+// Array benchmarks with non-null variants (1000 rows)
+INTEROP_BENCHMARKS(arrays, ROW({BIGINT(), ARRAY(BIGINT())}));
+
+INTEROP_BENCHMARKS(nestedArrays, ROW({BIGINT(), ARRAY(ARRAY(BIGINT()))}));
+
+// Struct benchmarks with non-null variants (1000 rows)
+INTEROP_BENCHMARKS(
+    structs,
+    ROW({BIGINT(), ROW({BIGINT(), DOUBLE(), BOOLEAN(), TINYINT(), REAL()})}));
+
+// Mixed type benchmarks with non-null variants (1000 rows)
+INTEROP_BENCHMARKS(
+    mixed,
+    ROW({
+        BIGINT(),
+        VARCHAR(),
+        DOUBLE(),
+        ARRAY(BIGINT()),
+        ROW({BIGINT(), VARCHAR()}),
+    }));
+
+// Date and timestamp benchmarks with non-null variants (1000 rows)
+INTEROP_BENCHMARKS(dates, ROW({BIGINT(), DATE()}));
+
+INTEROP_BENCHMARKS(timestamps, ROW({BIGINT(), TIMESTAMP()}));
+
+INTEROP_BENCHMARKS(
+    dateTimeMixed,
+    ROW({BIGINT(), DATE(), TIMESTAMP(), VARCHAR()}));
+
+// Large vector benchmarks with different row counts
+#define LARGE_INTEROP_BENCHMARKS(name, rowType, numRows)   \
+  BENCHMARK(velox_to_cudf_large_##name##_##numRows) {      \
+    CudfInteropBenchmark benchmark;                        \
+                                                           \
+    folly::BenchmarkSuspender suspender;                   \
+    auto data = benchmark.makeLargeData(rowType, numRows); \
+    suspender.dismiss();                                   \
+                                                           \
+    for (auto i = 0; i < iters; ++i) {                     \
+      benchmark.veloxToCudf(data);                         \
+    }                                                      \
+  }                                                        \
+                                                           \
+  BENCHMARK(cudf_to_velox_large_##name##_##numRows) {      \
+    CudfInteropBenchmark benchmark;                        \
+                                                           \
+    folly::BenchmarkSuspender suspender;                   \
+    auto data = benchmark.makeLargeData(rowType, numRows); \
+    auto cudfTable = benchmark.veloxToCudf(data);          \
+    suspender.dismiss();                                   \
+                                                           \
+    for (auto i = 0; i < iters; ++i) {                     \
+      benchmark.cudfToVeloxLarge(cudfTable, rowType);      \
+    }                                                      \
+  }
+
+// Test with 10,000 rows
+LARGE_INTEROP_BENCHMARKS(
+    fixedWidth10,
+    ROW({
+        BIGINT(),
+        BIGINT(),
+        BIGINT(),
+        BIGINT(),
+        BIGINT(),
+        BIGINT(),
+        DOUBLE(),
+        BIGINT(),
+        BIGINT(),
+        BIGINT(),
+    }),
+    10000);
+
+LARGE_INTEROP_BENCHMARKS(
+    strings5,
+    ROW({
+        BIGINT(),
+        VARCHAR(),
+        VARCHAR(),
+        VARCHAR(),
+        VARCHAR(),
+        VARCHAR(),
+    }),
+    10000);
+
+LARGE_INTEROP_BENCHMARKS(
+    mixed,
+    ROW({
+        BIGINT(),
+        VARCHAR(),
+        DOUBLE(),
+        ARRAY(BIGINT()),
+        ROW({BIGINT(), VARCHAR()}),
+    }),
+    10000);
+
+LARGE_INTEROP_BENCHMARKS(timestamps, ROW({BIGINT(), TIMESTAMP()}), 10000);
+
+LARGE_INTEROP_BENCHMARKS(booleans, ROW({BIGINT(), BOOLEAN()}), 10000);
+
+LARGE_INTEROP_BENCHMARKS(arrays, ROW({ARRAY(BIGINT())}), 10000);
+
+// Test with 40,000 rows
+LARGE_INTEROP_BENCHMARKS(
+    fixedWidth10,
+    ROW({
+        BIGINT(),
+        BIGINT(),
+        BIGINT(),
+        BIGINT(),
+        BIGINT(),
+        BIGINT(),
+        DOUBLE(),
+        BIGINT(),
+        BIGINT(),
+        BIGINT(),
+    }),
+    40000);
+
+LARGE_INTEROP_BENCHMARKS(
+    strings5,
+    ROW({
+        BIGINT(),
+        VARCHAR(),
+        VARCHAR(),
+        VARCHAR(),
+        VARCHAR(),
+        VARCHAR(),
+    }),
+    40000);
+
+LARGE_INTEROP_BENCHMARKS(
+    mixed,
+    ROW({
+        BIGINT(),
+        VARCHAR(),
+        DOUBLE(),
+        ARRAY(BIGINT()),
+        ROW({BIGINT(), VARCHAR()}),
+    }),
+    40000);
+
+// Test with 80,000 rows
+LARGE_INTEROP_BENCHMARKS(
+    fixedWidth10,
+    ROW({
+        BIGINT(),
+        BIGINT(),
+        BIGINT(),
+        BIGINT(),
+        BIGINT(),
+        BIGINT(),
+        DOUBLE(),
+        BIGINT(),
+        BIGINT(),
+        BIGINT(),
+    }),
+    80000);
+
+LARGE_INTEROP_BENCHMARKS(
+    strings5,
+    ROW({
+        BIGINT(),
+        VARCHAR(),
+        VARCHAR(),
+        VARCHAR(),
+        VARCHAR(),
+        VARCHAR(),
+    }),
+    80000);
+
+LARGE_INTEROP_BENCHMARKS(
+    mixed,
+    ROW({
+        BIGINT(),
+        VARCHAR(),
+        DOUBLE(),
+        ARRAY(BIGINT()),
+        ROW({BIGINT(), VARCHAR()}),
+    }),
+    80000);
+
+} // namespace
+} // namespace facebook::velox::cudf_velox
+
+int main(int argc, char** argv) {
+  folly::Init init{&argc, &argv};
+  facebook::velox::memory::MemoryManager::initialize(
+      facebook::velox::memory::MemoryManager::Options{});
+  folly::runBenchmarks();
+  return 0;
+}
+
+// Made with Bob
diff --git a/velox/experimental/cudf/benchmarks/CudfTpcdsBenchmark.cpp b/velox/experimental/cudf/benchmarks/CudfTpcdsBenchmark.cpp
new file mode 100644
index 00000000000..9de1208e845
--- /dev/null
+++ b/velox/experimental/cudf/benchmarks/CudfTpcdsBenchmark.cpp
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/benchmarks/CudfTpcdsBenchmark.h"
+#include "velox/experimental/cudf/benchmarks/CudfTpchBenchmark.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveConfig.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveConnector.h"
+#include "velox/experimental/cudf/exec/CudfConversion.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/tests/utils/CudfTpcdsQueryBuilder.h"
+
+#include "velox/connectors/ConnectorRegistry.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+
+DECLARE_string(data_path);
+DECLARE_string(data_format);
+DECLARE_int64(max_coalesced_bytes);
+DECLARE_string(max_coalesced_distance_bytes);
+DECLARE_int32(parquet_prefetch_rowgroups);
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::dwio::common;
+
+DEFINE_uint64(
+    cudf_chunk_read_limit,
+    0,
+    "Output table chunk read limit for cudf::parquet_chunked_reader.");
+
+DEFINE_uint64(
+    cudf_pass_read_limit,
+    0,
+    "Pass read limit for cudf::parquet_chunked_reader.");
+
+DEFINE_int32(
+    cudf_gpu_batch_size_rows,
+    100000,
+    "Preferred output batch size in rows for cudf operators.");
+
+DEFINE_bool(velox_cudf_table_scan, true, "Enable cuDF table scan");
+
+DEFINE_string(
+    cudf_properties,
+    "",
+    "Path to a properties file for CudfConfig. Each line should be key=value "
+    "(e.g. cudf.memory_resource=async). See CudfConfig for available keys.");
+
+void CudfTpcdsBenchmark::initQueryBuilder() {
+  auto cudfBuilder =
+      std::make_unique<cudf_velox::exec::test::CudfTpcdsQueryBuilder>(
+          toFileFormat(FLAGS_data_format), ioExecutor_.get());
+  cudfBuilder->enableCudf();
+  cudfBuilder->initialize(FLAGS_data_path);
+  queryBuilder_ = std::move(cudfBuilder);
+}
+
+void CudfTpcdsBenchmark::initialize() {
+  // Must be set before TpcdsBenchmark::initialize(), which calls
+  // initQueryBuilder() -> registerCudf(), which bakes the prefix into the
+  // step-aware aggregation registry.
+  auto& config = cudf_velox::CudfConfig::getInstance();
+  config.functionNamePrefix = kPrestoFunctionNamespacePrefix;
+
+  if (!FLAGS_cudf_properties.empty()) {
+    config.initialize(cudf_velox::loadPropertiesFile(FLAGS_cudf_properties));
+  }
+
+  TpcdsBenchmark::initialize();
+
+  const std::string prestoConnectorId{kPrestoHiveConnectorId};
+  if (FLAGS_velox_cudf_table_scan) {
+    // The base class registered a HiveConnector. Unregister it so the
+    // CudfTpcdsQueryBuilder can register CudfHiveConnector under the plan's
+    // connector ID instead. The query builder handles this when getQueryPlan()
+    // is called.
+    if (connector::ConnectorRegistry::tryGet(prestoConnectorId) != nullptr) {
+      connector::ConnectorRegistry::global().erase(prestoConnectorId);
+    }
+
+    // Re-register with CuDF properties.
+    auto properties = makeConnectorProperties();
+    cudf_velox::connector::hive::CudfHiveConnectorFactory cudfHiveFactory;
+    auto cudfHiveConnector = cudfHiveFactory.newConnector(
+        prestoConnectorId, properties, ioExecutor_.get());
+    connector::ConnectorRegistry::global().insert(
+        cudfHiveConnector->connectorId(), cudfHiveConnector);
+  }
+
+  queryConfigs_[cudf_velox::CudfFromVelox::kGpuBatchSizeRows] =
+      std::to_string(FLAGS_cudf_gpu_batch_size_rows);
+}
+
+std::shared_ptr<config::ConfigBase>
+CudfTpcdsBenchmark::makeConnectorProperties() {
+  auto cfg = TpcdsBenchmark::makeConnectorProperties();
+  using CudfHiveCfg = cudf_velox::connector::hive::CudfHiveConfig;
+
+  cfg->set(
+      CudfHiveCfg::kMaxChunkReadLimit,
+      std::to_string(FLAGS_cudf_chunk_read_limit));
+  cfg->set(
+      CudfHiveCfg::kMaxPassReadLimit,
+      std::to_string(FLAGS_cudf_pass_read_limit));
+  cfg->set(CudfHiveCfg::kAllowMismatchedCudfHiveSchemas, "true");
+
+  return cfg;
+}
+
+void CudfTpcdsBenchmark::shutdown() {
+  // CudfTpcdsQueryBuilder::shutdown() handles unregisterCudf().
+  TpcdsBenchmark::shutdown();
+}
+
+int main(int argc, char** argv) {
+  std::string kUsage(
+      "This program benchmarks TPC-DS queries with CuDF GPU acceleration.\n"
+      "  --data_path        Path to TPC-DS data directory\n"
+      "  --plan_path        Path to plan JSON directory\n"
+      "  --cudf_properties  Path to CudfConfig properties file\n");
+  gflags::SetUsageMessage(kUsage);
+  folly::Init init{&argc, &argv, false};
+  tpcdsBenchmark = std::make_unique<CudfTpcdsBenchmark>();
+  tpcdsBenchmarkMain();
+}
diff --git a/velox/experimental/cudf/benchmarks/CudfTpcdsBenchmark.h b/velox/experimental/cudf/benchmarks/CudfTpcdsBenchmark.h
new file mode 100644
index 00000000000..6bc4947c45d
--- /dev/null
+++ b/velox/experimental/cudf/benchmarks/CudfTpcdsBenchmark.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/benchmarks/tpcds/TpcdsBenchmark.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+/// CuDF-accelerated TPC-DS benchmark. Extends TpcdsBenchmark by:
+/// - Replacing the HiveConnector with CudfHiveConnector.
+/// - Registering cuDF GPU operator replacements.
+/// - Adding CuDF-specific configuration flags.
+class CudfTpcdsBenchmark : public TpcdsBenchmark {
+ public:
+  void initialize() override;
+
+  std::shared_ptr<facebook::velox::config::ConfigBase> makeConnectorProperties()
+      override;
+
+  void shutdown() override;
+
+ protected:
+  /// Creates CudfTpcdsQueryBuilder and calls enableCudf().
+  void initQueryBuilder() override;
+};
diff --git a/velox/experimental/cudf/benchmarks/CudfTpchBenchmark.cpp b/velox/experimental/cudf/benchmarks/CudfTpchBenchmark.cpp
new file mode 100644
index 00000000000..a2ffe560769
--- /dev/null
+++ b/velox/experimental/cudf/benchmarks/CudfTpchBenchmark.cpp
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/benchmarks/CudfTpchBenchmark.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveConfig.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.h"
+#include "velox/experimental/cudf/exec/CudfConversion.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.h"
+
+#include "velox/connectors/ConnectorRegistry.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+
+#include <experimental/cudf/connectors/hive/CudfHiveConnector.h>
+
+DECLARE_int64(max_coalesced_bytes);
+DECLARE_string(max_coalesced_distance_bytes);
+DECLARE_int32(parquet_prefetch_rowgroups);
+
+using namespace facebook::velox;
+using namespace facebook::velox::common::testutil;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::dwio::common;
+
+DEFINE_uint64(
+    cudf_chunk_read_limit,
+    0,
+    "Output table chunk read limit for cudf::parquet_chunked_reader.");
+
+DEFINE_uint64(
+    cudf_pass_read_limit,
+    0,
+    "Pass read limit for cudf::parquet_chunked_reader.");
+
+DEFINE_int32(
+    cudf_gpu_batch_size_rows,
+    100000,
+    "Preferred output batch size in rows for cudf operators.");
+
+DEFINE_bool(velox_cudf_table_scan, true, "Enable cuDF table scan");
+
+DEFINE_string(
+    cudf_properties,
+    "",
+    "Path to a properties file for CudfConfig. Each line should be key=value "
+    "(e.g. cudf.memory_resource=async). See CudfConfig for available keys.");
+
+void CudfTpchBenchmark::initialize() {
+  if (!FLAGS_cudf_properties.empty()) {
+    cudf_velox::CudfConfig::getInstance().initialize(
+        cudf_velox::loadPropertiesFile(FLAGS_cudf_properties));
+  }
+
+  TpchBenchmark::initialize();
+
+  if (FLAGS_velox_cudf_table_scan) {
+    connector::ConnectorRegistry::global().erase(
+        facebook::velox::exec::test::kHiveConnectorId);
+
+    auto cudfHiveConfigurationValues =
+        std::unordered_map<std::string, std::string>();
+    cudfHiveConfigurationValues
+        [cudf_velox::connector::hive::CudfHiveConfig::kMaxChunkReadLimit] =
+            std::to_string(FLAGS_cudf_chunk_read_limit);
+    cudfHiveConfigurationValues
+        [cudf_velox::connector::hive::CudfHiveConfig::kMaxPassReadLimit] =
+            std::to_string(FLAGS_cudf_pass_read_limit);
+    cudfHiveConfigurationValues[cudf_velox::connector::hive::CudfHiveConfig::
+                                    kAllowMismatchedCudfHiveSchemas] =
+        std::to_string(true);
+    auto cudfHiveProperties = std::make_shared<const config::ConfigBase>(
+        std::move(cudfHiveConfigurationValues));
+
+    cudf_velox::connector::hive::CudfHiveConnectorFactory cudfHiveFactory;
+    auto cudfHiveConnector = cudfHiveFactory.newConnector(
+        facebook::velox::exec::test::kHiveConnectorId,
+        cudfHiveProperties,
+        ioExecutor_.get());
+    connector::ConnectorRegistry::global().insert(
+        cudfHiveConnector->connectorId(), cudfHiveConnector);
+  }
+
+  cudf_velox::registerCudf();
+
+  queryConfigs_[facebook::velox::cudf_velox::CudfFromVelox::kGpuBatchSizeRows] =
+      std::to_string(FLAGS_cudf_gpu_batch_size_rows);
+}
+
+std::shared_ptr<config::ConfigBase>
+CudfTpchBenchmark::makeConnectorProperties() {
+  auto cfg = TpchBenchmark::makeConnectorProperties();
+  using CudfHiveCfg = cudf_velox::connector::hive::CudfHiveConfig;
+
+  // CuDF-specific properties.
+  cfg->set(
+      CudfHiveCfg::kMaxChunkReadLimit,
+      std::to_string(FLAGS_cudf_chunk_read_limit));
+  cfg->set(
+      CudfHiveCfg::kMaxPassReadLimit,
+      std::to_string(FLAGS_cudf_pass_read_limit));
+  cfg->set(CudfHiveCfg::kAllowMismatchedCudfHiveSchemas, "true");
+
+  return cfg;
+}
+
+std::vector<std::shared_ptr<connector::ConnectorSplit>>
+CudfTpchBenchmark::listSplits(
+    const std::string& path,
+    int32_t numSplitsPerFile,
+    const exec::test::TpchPlan& plan) {
+  // TODO (dm): Figure out a way to enforce 1 split per file in
+  // CudfHiveDataSource outside of this benchmark
+  if (FLAGS_velox_cudf_table_scan) {
+    // TODO (dm): Instead of this, we can maybe use
+    // makeHiveConnectorSplits(vector<shared_ptr<TempFilePath>>&
+    // filePaths)
+    std::vector<std::shared_ptr<connector::ConnectorSplit>> result;
+    auto temp = HiveConnectorTestBase::makeHiveConnectorSplits(
+        path, 1, plan.dataFileFormat);
+    for (auto& i : temp) {
+      result.push_back(i);
+    }
+    return result;
+  }
+
+  return TpchBenchmark::listSplits(path, numSplitsPerFile, plan);
+}
+
+void CudfTpchBenchmark::shutdown() {
+  cudf_velox::unregisterCudf();
+  TpchBenchmark::shutdown();
+}
+
+int main(int argc, char** argv) {
+  std::string kUsage(
+      "This program benchmarks TPC-H queries. Run 'velox_cudf_tpch_benchmark -helpon=TpchBenchmark' for available options.\n");
+  gflags::SetUsageMessage(kUsage);
+  folly::Init init{&argc, &argv, false};
+  benchmark = std::make_unique<CudfTpchBenchmark>();
+  tpchBenchmarkMain();
+}
diff --git a/velox/experimental/cudf/benchmarks/CudfTpchBenchmark.h b/velox/experimental/cudf/benchmarks/CudfTpchBenchmark.h
new file mode 100644
index 00000000000..e5f26225884
--- /dev/null
+++ b/velox/experimental/cudf/benchmarks/CudfTpchBenchmark.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/benchmarks/tpch/TpchBenchmark.h"
+#include "velox/common/base/Exceptions.h"
+
+#include <algorithm>
+#include <filesystem>
+#include <fstream>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+class CudfTpchBenchmark : public TpchBenchmark {
+ public:
+  void initialize() override;
+
+  std::shared_ptr<facebook::velox::config::ConfigBase> makeConnectorProperties()
+      override;
+
+  std::vector<std::shared_ptr<facebook::velox::connector::ConnectorSplit>>
+  listSplits(
+      const std::string& path,
+      int32_t numSplitsPerFile,
+      const facebook::velox::exec::test::TpchPlan& plan) override;
+
+  void shutdown() override;
+};
+
+namespace facebook::velox::cudf_velox {
+
+/// Parse a properties file into a key-value map.
+/// Each line should be key=value. Lines starting with '#' and blank lines are
+/// skipped. Lines without '=' are logged as warnings and ignored.
+inline std::unordered_map<std::string, std::string> loadPropertiesFile(
+    const std::string& path) {
+  auto fsPath = std::filesystem::path(path);
+  VELOX_USER_CHECK(
+      std::filesystem::exists(fsPath), "Properties file not found: {}", path);
+  std::unordered_map<std::string, std::string> properties;
+  std::string line;
+  std::ifstream configFile(fsPath);
+  while (std::getline(configFile, line)) {
+    line.erase(std::remove_if(line.begin(), line.end(), isspace), line.end());
+    if (line.empty() || line[0] == '#') {
+      continue;
+    }
+    LOG(INFO) << "Setting property " << line;
+    const auto delimiterPos = line.find('=');
+    if (delimiterPos == std::string::npos) {
+      LOG(WARNING) << "Skipping malformed config line (no '='): " << line;
+      continue;
+    }
+    properties.emplace(
+        line.substr(0, delimiterPos), line.substr(delimiterPos + 1));
+  }
+  return properties;
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/benchmarks/README.md b/velox/experimental/cudf/benchmarks/README.md
new file mode 100644
index 00000000000..92668ea354f
--- /dev/null
+++ b/velox/experimental/cudf/benchmarks/README.md
@@ -0,0 +1,190 @@
+# CuDF Benchmarks
+
+Benchmark binaries for TPC-H and TPC-DS queries with optional CuDF GPU acceleration.
+
+## Binaries
+
+| Binary | Benchmark | Mode | Source |
+|--------|-----------|------|--------|
+| `velox_tpch_benchmark` | TPC-H (Q1-Q22) | CPU | `velox/benchmarks/tpch/` |
+| `velox_cudf_tpch_benchmark` | TPC-H (Q1-Q22) | GPU | `CudfTpchBenchmark.cpp` |
+| `velox_tpcds_benchmark` | TPC-DS (Q1-Q99) | CPU | `velox/benchmarks/tpcds/` |
+| `velox_cudf_tpcds_benchmark` | TPC-DS (Q1-Q99) | GPU | `CudfTpcdsBenchmark.cpp` |
+
+CPU binaries use HiveConnector. GPU binaries use CudfHiveConnector and register
+cuDF GPU operator replacements.
+
+## Build
+
+```bash
+# GPU binaries (requires CUDA)
+CUDA_ARCHITECTURES="native" EXTRA_CMAKE_FLAGS="-DVELOX_ENABLE_BENCHMARKS=ON" make cudf
+cd _build/release
+ninja velox_cudf_tpch_benchmark velox_cudf_tpcds_benchmark
+
+# CPU-only binaries (no CUDA required)
+ninja velox_tpch_benchmark velox_tpcds_benchmark
+```
+
+---
+
+## TPC-H Benchmark
+
+### Data
+
+Generate TPC-H parquet data using the [velox-testing](https://github.com/rapidsai/velox-testing) data generation tool (see [Data Generation](#data-generation) below), or the standard `dbgen` tool and convert decimal columns to float.
+
+### Run
+
+```bash
+# CPU - all queries
+./velox_tpch_benchmark --data_path=/path/to/tpch/sf100 --data_format=parquet
+
+# GPU (CuDF) - all queries
+./velox_cudf_tpch_benchmark --data_path=/path/to/tpch/sf100 --data_format=parquet
+```
+
+---
+
+## TPC-DS Benchmark
+
+TPC-DS plans are loaded from pre-dumped Velox plan JSON files (serialized from Presto).
+
+### 1. Get Plan JSON Files
+
+Clone the plans repository:
+
+```bash
+git clone https://github.com/karthikeyann/VeloxPlans.git
+# Plans are at: VeloxPlans/presto/tpcds/sf100/
+```
+
+The directory contains `Q1.json`, `Q2.json`, ..., `Q99.json`.
+
+### 2. Get TPC-DS Data
+
+Generate TPC-DS parquet data using the [velox-testing](https://github.com/rapidsai/velox-testing) data generation tool (see [Data Generation](#data-generation) below). The data directory must have one subdirectory per table:
+
+```
+/path/to/tpcds/sf100/
+  store_sales/
+  customer/
+  date_dim/
+  item/
+  ...
+```
+
+Each subdirectory contains parquet files for that table.
+
+### 3. Run
+
+**CPU - all queries (folly benchmark mode):**
+
+```bash
+./velox_tpcds_benchmark \
+  --data_path=/path/to/tpcds/sf100 \
+  --plan_path=/path/to/VeloxPlans/presto/tpcds/sf100 \
+  --data_format=parquet
+```
+
+**CPU - single query with stats:**
+
+```bash
+./velox_tpcds_benchmark \
+  --data_path=/path/to/tpcds/sf100 \
+  --plan_path=/path/to/VeloxPlans/presto/tpcds/sf100 \
+  --data_format=parquet \
+  --run_query_verbose=1
+```
+
+**GPU (CuDF) - all queries:**
+
+```bash
+./velox_cudf_tpcds_benchmark \
+  --data_path=/path/to/tpcds/sf100 \
+  --plan_path=/path/to/VeloxPlans/presto/tpcds/sf100 \
+  --data_format=parquet
+```
+
+**GPU (CuDF) - single query with stats:**
+
+```bash
+./velox_cudf_tpcds_benchmark \
+  --data_path=/path/to/tpcds/sf100 \
+  --plan_path=/path/to/VeloxPlans/presto/tpcds/sf100 \
+  --data_format=parquet \
+  --run_query_verbose=1
+```
+
+### TPC-DS Flags
+
+These flags are shared by both CPU and GPU binaries:
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--data_path` | (required) | Root directory of TPC-DS table data |
+| `--plan_path` | (required) | Directory containing Q*.json plan files |
+| `--data_format` | `parquet` | Data file format |
+| `--run_query_verbose` | `-1` | Run single query with stats (`-1` = run all) |
+| `--num_drivers` | `4` | Number of parallel drivers |
+| `--include_results` | `false` | Print query results |
+
+### CuDF Flags (GPU binaries only)
+
+These flags apply to `velox_cudf_tpch_benchmark` and `velox_cudf_tpcds_benchmark`:
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--cudf_chunk_read_limit` | `0` | Chunk read limit for cuDF parquet reader |
+| `--cudf_pass_read_limit` | `0` | Pass read limit for cuDF parquet reader |
+| `--cudf_gpu_batch_size_rows` | `100000` | GPU batch size in rows |
+| `--velox_cudf_table_scan` | `true` | Use CuDF table scan |
+| `--cudf_properties` | `""` | Path to a CudfConfig properties file (key=value per line). See `CudfConfig.h` for available keys |
+
+---
+
+## Data Generation
+
+Both TPC-H and TPC-DS parquet data can be generated using the
+[velox-testing](https://github.com/rapidsai/velox-testing) repository.
+Full instructions are also available in the
+[VeloxPlans TPC-DS README](https://github.com/karthikeyann/VeloxPlans/tree/main/presto/tpcds/sf100).
+
+### Quick Start
+
+```bash
+# 1. Clone velox-testing
+git clone https://github.com/rapidsai/velox-testing.git
+cd velox-testing
+
+# 2. Install Python dependencies
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -r benchmark_data_tools/requirements.txt
+
+# 3. Generate TPC-DS data (sf100)
+python benchmark_data_tools/generate_data_files.py \
+  --benchmark-type tpcds \
+  --data-dir-path /path/to/tpcds/sf100/data \
+  --scale-factor 100 \
+  --convert-decimals-to-floats
+
+# 4. Generate TPC-H data (sf100)
+python benchmark_data_tools/generate_data_files.py \
+  --benchmark-type tpch \
+  --data-dir-path /path/to/tpch/sf100/data \
+  --scale-factor 100 \
+  --convert-decimals-to-floats
+```
+
+### Key Flags
+
+| Flag | Description |
+|------|-------------|
+| `--benchmark-type` | `tpcds` or `tpch` |
+| `--data-dir-path` | Output directory for parquet files |
+| `--scale-factor` | Scale factor (e.g. `1`, `10`, `100`) |
+| `--convert-decimals-to-floats` | Convert decimal columns to double (recommended for Velox) |
+
+The output directory will contain one subdirectory per table, each with `.parquet` files.
+For a quick sanity check, use `--scale-factor 1` first.
diff --git a/velox/experimental/cudf/benchmarks/benchmark.sh b/velox/experimental/cudf/benchmarks/benchmark.sh
new file mode 100755
index 00000000000..6af41d25575
--- /dev/null
+++ b/velox/experimental/cudf/benchmarks/benchmark.sh
@@ -0,0 +1,80 @@
+#!/bin/bash
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set -euo pipefail
+
+# Put the generated data in the directory velox-tpch-sf10-data at the root of this repo
+
+# Run this to launch the CUDA container:
+# docker-compose run -e NUM_THREADS=$(nproc) --rm adapters-cuda /bin/bash
+# Then run the following to build with GPU support.
+# CUDA_ARCHITECTURES=native EXTRA_CMAKE_FLAGS="-DVELOX_ENABLE_BENCHMARKS=ON" make cudf
+# Then invoke this script from the root of the repo:
+# ./velox/experimental/cudf/benchmarks/benchmark.sh
+
+mkdir -p benchmark_results
+
+queries=${1:-$(seq 1 22)}
+devices=${2:-"cpu gpu"}
+profile=${3:-"false"}
+# Resolve script dir so binaries can be run from anywhere
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "${SCRIPT_DIR}/../../../../" && pwd)"
+
+cudf_chunk_read_limit=$((1024 * 1024 * 1024 * 1))
+cudf_pass_read_limit=0
+VELOX_CUDF_MEMORY_RESOURCE="async"
+VELOX_CUDF_MEMORY_PERCENT=0
+
+for query_number in ${queries}; do
+  printf -v query_number '%02d' "${query_number}"
+  for device in ${devices}; do
+    case "${device}" in
+    "cpu")
+      num_drivers=${NUM_DRIVERS:-32}
+      BENCHMARK_EXECUTABLE="${REPO_ROOT}/_build/release/velox/benchmarks/tpch/velox_tpch_benchmark"
+      CUDF_FLAGS=""
+      ;;
+    "gpu")
+      num_drivers=${NUM_DRIVERS:-4}
+      BENCHMARK_EXECUTABLE="${REPO_ROOT}/_build/release/velox/experimental/cudf/benchmarks/velox_cudf_tpch_benchmark"
+      CUDF_FLAGS="--velox_cudf_table_scan=true --cudf_chunk_read_limit=${cudf_chunk_read_limit} --cudf_pass_read_limit=${cudf_pass_read_limit} --cudf_memory_resource=${VELOX_CUDF_MEMORY_RESOURCE} --cudf_memory_percent=${VELOX_CUDF_MEMORY_PERCENT}"
+      ;;
+    esac
+    echo "Running query ${query_number} on ${device} with ${num_drivers} drivers."
+    # The benchmarks segfault after reporting results, so we disable errors
+    PROFILE_CMD=""
+    if [[ ${profile} == "true" ]]; then
+      PROFILE_CMD="nsys profile -t nvtx,cuda,osrt -f true --cuda-memory-usage=true --cuda-um-cpu-page-faults=true --cuda-um-gpu-page-faults=true --output=benchmark_results/q${query_number}_${device}_${num_drivers}_drivers.nsys-rep"
+      # Enable GPU metrics if supported (Ampere or newer)
+      if [[ "$(nvidia-smi --query-gpu=compute_cap --format=csv,noheader -i 0 | cut -d '.' -f 1)" -gt 7 ]]; then
+        device_id=${CUDA_VISIBLE_DEVICES:-"0"}
+        PROFILE_CMD="${PROFILE_CMD} --gpu-metrics-devices=${device_id}"
+      fi
+    fi
+
+    set +e -x
+    ${PROFILE_CMD} \
+      ${BENCHMARK_EXECUTABLE} \
+      --data_path=velox-tpch-sf10-data \
+      --data_format=parquet \
+      --run_query_verbose=${query_number} \
+      --num_repeats=1 \
+      --num_drivers=${num_drivers} \
+      ${CUDF_FLAGS} 2>&1 |
+      tee benchmark_results/q${query_number}_${device}_${num_drivers}_drivers
+    { set -e +x; } &>/dev/null
+  done
+done
diff --git a/velox/experimental/cudf/connectors/hive/CMakeLists.txt b/velox/experimental/cudf/connectors/hive/CMakeLists.txt
index 78ab125893b..e2622644291 100644
--- a/velox/experimental/cudf/connectors/hive/CMakeLists.txt
+++ b/velox/experimental/cudf/connectors/hive/CMakeLists.txt
@@ -12,26 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_cudf_hive_config CudfHiveConfig.cpp)
-
-set_target_properties(velox_cudf_hive_config PROPERTIES CUDA_ARCHITECTURES native)
-
-target_link_libraries(velox_cudf_hive_config velox_core velox_exception cudf::cudf)
-
 add_library(
   velox_cudf_hive_connector
-  OBJECT
   CudfHiveConfig.cpp
   CudfHiveConnector.cpp
   CudfHiveConnectorSplit.cpp
-  CudfHiveDataSource.cpp
   CudfHiveDataSink.cpp
+  CudfHiveDataSource.cpp
   CudfHiveTableHandle.cpp
+  CudfSplitReader.cpp
+  CudfSplitReaderHelpers.cpp
 )
 
 set_target_properties(velox_cudf_hive_connector PROPERTIES CUDA_ARCHITECTURES native)
 
 target_link_libraries(
   velox_cudf_hive_connector
-  PRIVATE cudf::cudf velox_common_io velox_connector velox_type_tz velox_gcs
+  PRIVATE velox_dwio_common velox_hive_connector
+  PUBLIC cudf::cudf velox_cudf_expression
 )
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveConfig.cpp b/velox/experimental/cudf/connectors/hive/CudfHiveConfig.cpp
index 13ce6228628..9ec93b54e25 100644
--- a/velox/experimental/cudf/connectors/hive/CudfHiveConfig.cpp
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveConfig.cpp
@@ -25,17 +25,6 @@
 
 namespace facebook::velox::cudf_velox::connector::hive {
 
-int64_t CudfHiveConfig::skipRows() const {
-  return config_->get<int64_t>(kSkipRows, 0);
-}
-
-std::optional<cudf::size_type> CudfHiveConfig::numRows() const {
-  auto numRows = config_->get<cudf::size_type>(kNumRows);
-  return numRows.has_value()
-      ? std::make_optional<cudf::size_type>(numRows.value())
-      : std::nullopt;
-}
-
 std::size_t CudfHiveConfig::maxChunkReadLimit() const {
   // chunk read limit = 0 means no limit
   return config_->get<std::size_t>(kMaxChunkReadLimit, 0);
@@ -133,6 +122,27 @@ cudf::data_type CudfHiveConfig::timestampTypeSession(
   return cudf::data_type(cudf::type_id{unit});
 }
 
+bool CudfHiveConfig::useBufferedInput() const {
+  return config_->get<bool>(kUseBufferedInput, true);
+}
+
+bool CudfHiveConfig::useBufferedInputSession(
+    const config::ConfigBase* session) const {
+  return session->get<bool>(
+      kUseBufferedInputSession, config_->get<bool>(kUseBufferedInput, true));
+}
+
+bool CudfHiveConfig::useExperimentalCudfReader() const {
+  return config_->get<bool>(kUseExperimentalCudfReader, false);
+}
+
+bool CudfHiveConfig::useExperimentalCudfReaderSession(
+    const config::ConfigBase* session) const {
+  return session->get<bool>(
+      kUseExperimentalCudfReaderSession,
+      config_->get<bool>(kUseExperimentalCudfReader, false));
+}
+
 bool CudfHiveConfig::immutableFiles() const {
   return config_->get<bool>(kImmutableFiles, false);
 }
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveConfig.h b/velox/experimental/cudf/connectors/hive/CudfHiveConfig.h
index d2977d93f71..1d46574dd5f 100644
--- a/velox/experimental/cudf/connectors/hive/CudfHiveConfig.h
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveConfig.h
@@ -32,13 +32,6 @@ class CudfHiveConfig {
  public:
   // Reader config options
 
-  // Number of rows to skip from the start; CudfHive stores the number of rows
-  // as int64_t
-  static constexpr const char* kSkipRows = "parquet.reader.skip-rows";
-
-  // Number of rows to read; `nullopt` is all
-  static constexpr const char* kNumRows = "parquet.reader.num-rows";
-
   // This isn't a typo; parquet connector and session config names are different
   // ('-' vs '_').
   static constexpr const char* kMaxChunkReadLimit =
@@ -81,6 +74,20 @@ class CudfHiveConfig {
   static constexpr const char* kTimestampTypeSession =
       "parquet.reader.timestamp_type";
 
+  // Whether to use the BufferedInput source for CudfHiveDataSource. The
+  // buffered source takes advantage of the `AsyncDataCache` if available. The
+  // `AsyncDataCache` is controlled (default: enabled) using the
+  // HiveConfig::kEnableFileHandleCache config option
+  static constexpr const char* kUseBufferedInput =
+      "cudf.hive.use-buffered-input";
+  static constexpr const char* kUseBufferedInputSession =
+      "cudf.hive.use_buffered_input";
+
+  static constexpr const char* kUseExperimentalCudfReader =
+      "cudf.hive.use-experimental-reader";
+  static constexpr const char* kUseExperimentalCudfReaderSession =
+      "cudf.hive.use_experimental_reader";
+
   // Writer config options
 
   /// Whether new data can be inserted into a CudfHive file
@@ -90,7 +97,7 @@ class CudfHiveConfig {
   /// Sort Writer will exit finish() method after this many milliseconds even if
   /// it has not completed its work yet. Zero means no time limit.
   static constexpr const char* kSortWriterFinishTimeSliceLimitMs =
-      "sort-writer_finish_time_slice_limit_ms";
+      "sort-writer-finish-time-slice-limit-ms";
   static constexpr const char* kSortWriterFinishTimeSliceLimitMsSession =
       "sort_writer_finish_time_slice_limit_ms";
 
@@ -128,9 +135,6 @@ class CudfHiveConfig {
   std::size_t maxPassReadLimit() const;
   std::size_t maxPassReadLimitSession(const config::ConfigBase* session) const;
 
-  int64_t skipRows() const;
-  std::optional<cudf::size_type> numRows() const;
-
   bool isConvertStringsToCategories() const;
   bool isConvertStringsToCategoriesSession(
       const config::ConfigBase* session) const;
@@ -148,6 +152,13 @@ class CudfHiveConfig {
   cudf::data_type timestampType() const;
   cudf::data_type timestampTypeSession(const config::ConfigBase* session) const;
 
+  bool useBufferedInput() const;
+  bool useBufferedInputSession(const config::ConfigBase* session) const;
+
+  bool useExperimentalCudfReader() const;
+  bool useExperimentalCudfReaderSession(
+      const config::ConfigBase* session) const;
+
   bool immutableFiles() const;
 
   bool writeTimestampsAsUTC() const;
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveConnector.cpp b/velox/experimental/cudf/connectors/hive/CudfHiveConnector.cpp
index 4479e211682..0947cbfe1dd 100644
--- a/velox/experimental/cudf/connectors/hive/CudfHiveConnector.cpp
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveConnector.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "velox/experimental/cudf/CudfNoDefaults.h"
 #include "velox/experimental/cudf/connectors/hive/CudfHiveConnector.h"
 #include "velox/experimental/cudf/connectors/hive/CudfHiveDataSource.h"
 #include "velox/experimental/cudf/exec/ToCudf.h"
@@ -29,7 +30,9 @@ CudfHiveConnector::CudfHiveConnector(
     std::shared_ptr<const facebook::velox::config::ConfigBase> config,
     folly::Executor* executor)
     : ::facebook::velox::connector::hive::HiveConnector(id, config, executor),
-      cudfHiveConfig_(std::make_shared<CudfHiveConfig>(config)) {}
+      cudfHiveConfig_(std::make_shared<CudfHiveConfig>(config)) {
+  VLOG(1) << "cuDF Hive connector created";
+}
 
 std::unique_ptr<DataSource> CudfHiveConnector::createDataSource(
     const RowTypePtr& outputType,
@@ -46,6 +49,7 @@ std::unique_ptr<DataSource> CudfHiveConnector::createDataSource(
         outputType,
         tableHandle,
         columnHandles,
+        &fileHandleFactory_,
         ioExecutor_,
         connectorQueryCtx,
         cudfHiveConfig_);
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveConnector.h b/velox/experimental/cudf/connectors/hive/CudfHiveConnector.h
index fbb5929f3f4..eb48c04c268 100644
--- a/velox/experimental/cudf/connectors/hive/CudfHiveConnector.h
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveConnector.h
@@ -47,6 +47,10 @@ class CudfHiveConnector final
     return false;
   }
 
+  bool supportsSplitPreload() const override {
+    return false;
+  }
+
   // TODO (dm): Re-add data sink
 
  protected:
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.cpp b/velox/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.cpp
index 8c609dabea0..a7a3f5f5266 100644
--- a/velox/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.cpp
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.cpp
@@ -14,14 +14,26 @@
  * limitations under the License.
  */
 
+#include "velox/experimental/cudf/CudfNoDefaults.h"
 #include "velox/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.h"
 
 #include <cudf/io/types.hpp>
 
 #include <string>
+#include <unordered_map>
 
 namespace facebook::velox::cudf_velox::connector::hive {
 
+namespace {
+std::string stripFilePrefix(const std::string& targetPath) {
+  const std::string prefix = "file:";
+  if (targetPath.rfind(prefix, 0) == 0) {
+    return targetPath.substr(prefix.length());
+  }
+  return targetPath;
+}
+} // namespace
+
 std::string CudfHiveConnectorSplit::toString() const {
   return fmt::format("CudfHive: {}", filePath);
 }
@@ -31,15 +43,57 @@ std::string CudfHiveConnectorSplit::getFileName() const {
   return i == std::string::npos ? filePath : filePath.substr(i + 1);
 }
 
+uint64_t CudfHiveConnectorSplit::size() const {
+  return length;
+}
+
+CudfHiveConnectorSplit::CudfHiveConnectorSplit(
+    const std::string& connectorId,
+    const std::string& _filePath,
+    uint64_t _start,
+    uint64_t _length,
+    int64_t _splitWeight,
+    const std::unordered_map<std::string, std::string>& _infoColumns)
+    : facebook::velox::connector::ConnectorSplit(connectorId, _splitWeight),
+      filePath(stripFilePrefix(_filePath)),
+      start(_start),
+      length(_length),
+      cudfSourceInfo(std::make_unique<cudf::io::source_info>(filePath)),
+      infoColumns(_infoColumns) {}
+
 // static
 std::shared_ptr<CudfHiveConnectorSplit> CudfHiveConnectorSplit::create(
     const folly::dynamic& obj) {
   const auto connectorId = obj["connectorId"].asString();
-  const auto splitWeight = obj["splitWeight"].asInt();
   const auto filePath = obj["filePath"].asString();
+  const auto start = static_cast<uint64_t>(obj["start"].asInt());
+  const auto length = static_cast<uint64_t>(obj["length"].asInt());
+  const auto splitWeight = obj["splitWeight"].asInt();
+
+  std::unordered_map<std::string, std::string> infoColumns;
+  for (const auto& [key, value] : obj["infoColumns"].items()) {
+    infoColumns[key.asString()] = value.asString();
+  }
 
   return std::make_shared<CudfHiveConnectorSplit>(
-      connectorId, filePath, splitWeight);
+      connectorId, filePath, start, length, splitWeight, infoColumns);
+}
+
+folly::dynamic CudfHiveConnectorSplit::serialize() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["connectorId"] = connectorId;
+  obj["filePath"] = filePath;
+  obj["start"] = start;
+  obj["length"] = length;
+  obj["splitWeight"] = splitWeight;
+
+  folly::dynamic infoColumnsObj = folly::dynamic::object;
+  for (const auto& [key, value] : infoColumns) {
+    infoColumnsObj[key] = value;
+  }
+  obj["infoColumns"] = infoColumnsObj;
+
+  return obj;
 }
 
 } // namespace facebook::velox::cudf_velox::connector::hive
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.h b/velox/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.h
index 53633a4bc35..7bd186ab048 100644
--- a/velox/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.h
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.h
@@ -27,23 +27,30 @@ struct source_info;
 
 #include <memory>
 #include <string>
+#include <unordered_map>
 
 namespace facebook::velox::cudf_velox::connector::hive {
 
 struct CudfHiveConnectorSplit
     : public facebook::velox::connector::ConnectorSplit {
   const std::string filePath;
+  const uint64_t start;
+  const uint64_t length;
   const facebook::velox::dwio::common::FileFormat fileFormat{
       facebook::velox::dwio::common::FileFormat::PARQUET};
   const std::unique_ptr<cudf::io::source_info> cudfSourceInfo;
 
+  /// These represent columns like $file_size, $file_modified_time that are
+  /// associated with the CudfHiveConnectorSplit.
+  std::unordered_map<std::string, std::string> infoColumns = {};
+
   CudfHiveConnectorSplit(
       const std::string& connectorId,
       const std::string& _filePath,
-      int64_t _splitWeight = 0)
-      : facebook::velox::connector::ConnectorSplit(connectorId, _splitWeight),
-        filePath(_filePath),
-        cudfSourceInfo(std::make_unique<cudf::io::source_info>(filePath)) {}
+      uint64_t _start = 0,
+      uint64_t _length = std::numeric_limits<uint64_t>::max(),
+      int64_t _splitWeight = 0,
+      const std::unordered_map<std::string, std::string>& _infoColumns = {});
 
   std::string toString() const override;
   std::string getFileName() const;
@@ -52,6 +59,10 @@ struct CudfHiveConnectorSplit
     return *cudfSourceInfo;
   }
 
+  uint64_t size() const override;
+
+  folly::dynamic serialize() const override;
+
   static std::shared_ptr<CudfHiveConnectorSplit> create(
       const folly::dynamic& obj);
 };
@@ -61,6 +72,23 @@ class CudfHiveConnectorSplitBuilder {
   explicit CudfHiveConnectorSplitBuilder(std::string filePath)
       : filePath_{std::move(filePath)} {}
 
+  CudfHiveConnectorSplitBuilder& start(uint64_t start) {
+    start_ = start;
+    return *this;
+  }
+
+  CudfHiveConnectorSplitBuilder& length(uint64_t length) {
+    length_ = length;
+    return *this;
+  }
+
+  CudfHiveConnectorSplitBuilder& infoColumn(
+      const std::string& name,
+      const std::string& value) {
+    infoColumns_.emplace(std::move(name), std::move(value));
+    return *this;
+  }
+
   CudfHiveConnectorSplitBuilder& splitWeight(int64_t splitWeight) {
     splitWeight_ = splitWeight;
     return *this;
@@ -73,13 +101,16 @@ class CudfHiveConnectorSplitBuilder {
 
   std::shared_ptr<CudfHiveConnectorSplit> build() const {
     return std::make_shared<CudfHiveConnectorSplit>(
-        connectorId_, filePath_, splitWeight_);
+        connectorId_, filePath_, start_, length_, splitWeight_, infoColumns_);
   }
 
  private:
   const std::string filePath_;
+  uint64_t start_{0};
+  uint64_t length_{std::numeric_limits<uint64_t>::max()};
   std::string connectorId_;
   int64_t splitWeight_{0};
+  std::unordered_map<std::string, std::string> infoColumns_ = {};
 };
 
 } // namespace facebook::velox::cudf_velox::connector::hive
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveDataSink.cpp b/velox/experimental/cudf/connectors/hive/CudfHiveDataSink.cpp
index 7c6d06163c4..055040f574b 100644
--- a/velox/experimental/cudf/connectors/hive/CudfHiveDataSink.cpp
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveDataSink.cpp
@@ -14,10 +14,11 @@
  * limitations under the License.
  */
 
+#include "velox/experimental/cudf/CudfNoDefaults.h"
 #include "velox/experimental/cudf/connectors/hive/CudfHiveConfig.h"
 #include "velox/experimental/cudf/connectors/hive/CudfHiveDataSink.h"
 #include "velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.h"
-#include "velox/experimental/cudf/exec/Utilities.h"
+#include "velox/experimental/cudf/exec/GpuResources.h"
 #include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
 #include "velox/experimental/cudf/vector/CudfVector.h"
 
@@ -157,14 +158,15 @@ void CudfHiveDataSink::appendData(RowVectorPtr input) {
 
   // Convert the input RowVectorPtr to cudf::table
   auto stream = cudfGlobalStreamPool().get_stream();
-  auto cudfInput = with_arrow::toCudfTable(input, input->pool(), stream);
+  auto cudfInput =
+      with_arrow::toCudfTable(input, input->pool(), stream, get_temp_mr());
   stream.synchronize();
   VELOX_CHECK_NOT_NULL(
       cudfInput, "Failed to convert input RowVectorPtr to cudf::table");
 
   // Check if the writer doesn't already exist
   if (writer_ == nullptr) {
-    writer_ = createCudfWriter(cudfInput->view());
+    writer_ = createCudfWriter(cudfInput->view(), stream);
   }
 
   // Write the table to the sink
@@ -174,7 +176,9 @@ void CudfHiveDataSink::appendData(RowVectorPtr input) {
 }
 
 std::unique_ptr<cudf::io::chunked_parquet_writer>
-CudfHiveDataSink::createCudfWriter(cudf::table_view cudfTable) {
+CudfHiveDataSink::createCudfWriter(
+    cudf::table_view cudfTable,
+    rmm::cuda_stream_view stream) {
   // Create a table_input_metadata from the input
   auto tableInputMetadata = createCudfTableInputMetadata(cudfTable);
 
@@ -257,7 +261,8 @@ CudfHiveDataSink::createCudfWriter(cudf::table_view cudfTable) {
     }
   }
 
-  return std::make_unique<cudf::io::chunked_parquet_writer>(cudfWriterOptions);
+  return std::make_unique<cudf::io::chunked_parquet_writer>(
+      cudfWriterOptions, stream);
 }
 
 cudf::io::table_input_metadata CudfHiveDataSink::createCudfTableInputMetadata(
@@ -330,8 +335,8 @@ DataSink::Stats CudfHiveDataSink::stats() const {
   int64_t numWrittenBytes{0};
   int64_t writeIOTimeUs{0};
 
-  numWrittenBytes += ioStats_->rawBytesWritten();
-  writeIOTimeUs += ioStats_->writeIOTimeUs();
+  numWrittenBytes += ioStatistics_->rawBytesWritten();
+  writeIOTimeUs += ioStatistics_->writeIOTimeUs();
 
   stats.numWrittenBytes = numWrittenBytes;
   stats.writeIOTimeUs = writeIOTimeUs;
@@ -342,9 +347,8 @@ DataSink::Stats CudfHiveDataSink::stats() const {
 
   stats.numWrittenFiles = 1;
   VELOX_CHECK_NOT_NULL(writerInfo_);
-  const auto spillStats = writerInfo_->spillStats->rlock();
-  if (!spillStats->empty()) {
-    stats.spillStats += *spillStats;
+  if (!writerInfo_->spillStats->empty()) {
+    stats.spillStats += *writerInfo_->spillStats;
   }
 
   return stats;
@@ -403,10 +407,10 @@ std::vector<std::string> CudfHiveDataSink::close() {
           folly::dynamic::object
             ("writeFileName", writerInfo_->writerParameters.writeFileName())
             ("targetFileName", writerInfo_->writerParameters.targetFileName())
-            ("fileSize", ioStats_->rawBytesWritten())))
+            ("fileSize", ioStatistics_->rawBytesWritten())))
         ("rowCount", writerInfo_->numWrittenRows)
         ("inMemoryDataSizeInBytes", writerInfo_->inputSizeInBytes)
-        ("onDiskDataSizeInBytes", ioStats_->rawBytesWritten())
+        ("onDiskDataSizeInBytes", ioStatistics_->rawBytesWritten())
         ("containsNumberedFileNames", true));
   // clang-format on
   partitionUpdates.emplace_back(partitionUpdateJson);
@@ -456,7 +460,7 @@ void CudfHiveDataSink::makeWriterOptions(
       std::move(sinkPool),
       std::move(sortPool));
 
-  ioStats_ = std::make_shared<io::IoStatistics>();
+  ioStatistics_ = std::make_shared<io::IoStatistics>();
 
   // Take the writer options provided by the user as a starting point,
   // or allocate a new one.
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveDataSink.h b/velox/experimental/cudf/connectors/hive/CudfHiveDataSink.h
index 02984124c24..aa85c510555 100644
--- a/velox/experimental/cudf/connectors/hive/CudfHiveDataSink.h
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveDataSink.h
@@ -163,7 +163,7 @@ struct CudfHiveWriterInfo {
       std::shared_ptr<memory::MemoryPool> _sortPool)
       : writerParameters(std::move(parameters)),
         nonReclaimableSectionHolder(new tsan_atomic<bool>(false)),
-        spillStats(std::make_unique<folly::Synchronized<common::SpillStats>>()),
+        spillStats(std::make_unique<exec::SpillStats>()),
         writerPool(std::move(_writerPool)),
         sinkPool(std::move(_sinkPool)),
         sortPool(std::move(_sortPool)) {}
@@ -172,7 +172,7 @@ struct CudfHiveWriterInfo {
   const std::unique_ptr<tsan_atomic<bool>> nonReclaimableSectionHolder;
   /// Collects the spill stats from sort writer if the spilling has been
   /// triggered.
-  const std::unique_ptr<folly::Synchronized<common::SpillStats>> spillStats;
+  const std::unique_ptr<exec::SpillStats> spillStats;
   const std::shared_ptr<memory::MemoryPool> writerPool;
   const std::shared_ptr<memory::MemoryPool> sinkPool;
   const std::shared_ptr<memory::MemoryPool> sortPool;
@@ -308,7 +308,8 @@ class CudfHiveDataSink : public DataSink {
  private:
   // Creates a new cudf chunked parquet writer.
   std::unique_ptr<cudf::io::chunked_parquet_writer> createCudfWriter(
-      cudf::table_view cudfTable);
+      cudf::table_view cudfTable,
+      rmm::cuda_stream_view stream);
   cudf::io::table_input_metadata createCudfTableInputMetadata(
       cudf::table_view cudfTable);
 
@@ -352,7 +353,7 @@ class CudfHiveDataSink : public DataSink {
   std::shared_ptr<CudfHiveWriterInfo> writerInfo_;
 
   // IO statistics collected for writer.
-  std::shared_ptr<io::IoStatistics> ioStats_;
+  std::shared_ptr<io::IoStatistics> ioStatistics_;
 };
 
 FOLLY_ALWAYS_INLINE std::ostream& operator<<(
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveDataSource.cpp b/velox/experimental/cudf/connectors/hive/CudfHiveDataSource.cpp
index e703f15b43e..160ef026b52 100644
--- a/velox/experimental/cudf/connectors/hive/CudfHiveDataSource.cpp
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveDataSource.cpp
@@ -14,33 +14,27 @@
  * limitations under the License.
  */
 
+#include "velox/experimental/cudf/CudfNoDefaults.h"
 #include "velox/experimental/cudf/connectors/hive/CudfHiveConfig.h"
 #include "velox/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.h"
 #include "velox/experimental/cudf/connectors/hive/CudfHiveDataSource.h"
 #include "velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.h"
-#include "velox/experimental/cudf/exec/ExpressionEvaluator.h"
+#include "velox/experimental/cudf/exec/GpuResources.h"
 #include "velox/experimental/cudf/exec/ToCudf.h"
-#include "velox/experimental/cudf/exec/Utilities.h"
 #include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
+#include "velox/experimental/cudf/expression/SubfieldFiltersToAst.h"
 #include "velox/experimental/cudf/vector/CudfVector.h"
 
 #include "velox/common/time/Timer.h"
+#include "velox/connectors/hive/FileHandle.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/connectors/hive/HiveConnectorUtil.h"
+#include "velox/connectors/hive/HiveDataSource.h"
 #include "velox/connectors/hive/TableHandle.h"
 #include "velox/expression/FieldReference.h"
 
-#include <cudf/io/parquet.hpp>
-#include <cudf/io/types.hpp>
 #include <cudf/stream_compaction.hpp>
-#include <cudf/table/table.hpp>
-#include <cudf/table/table_view.hpp>
-#include <cudf/transform.hpp>
-
-#include <cuda_runtime.h>
-
-#include <filesystem>
-#include <memory>
-#include <string>
 
 namespace facebook::velox::cudf_velox::connector::hive {
 
@@ -51,18 +45,20 @@ CudfHiveDataSource::CudfHiveDataSource(
     const RowTypePtr& outputType,
     const ConnectorTableHandlePtr& tableHandle,
     const ColumnHandleMap& columnHandles,
+    facebook::velox::FileHandleFactory* fileHandleFactory,
     folly::Executor* executor,
     const ConnectorQueryCtx* connectorQueryCtx,
-    const std::shared_ptr<CudfHiveConfig>& parquetConfig)
+    const std::shared_ptr<CudfHiveConfig>& cudfHiveConfig)
     : NvtxHelper(
           nvtx3::rgb{80, 171, 241}, // CudfHive blue,
           std::nullopt,
           fmt::format("[{}]", tableHandle->name())),
-      parquetConfig_(parquetConfig),
+      cudfHiveConfig_(cudfHiveConfig),
+      fileHandleFactory_(fileHandleFactory),
       executor_(executor),
       connectorQueryCtx_(connectorQueryCtx),
-      pool_(connectorQueryCtx->memoryPool()),
       outputType_(outputType),
+      pool_(connectorQueryCtx->memoryPool()),
       expressionEvaluator_(connectorQueryCtx->expressionEvaluator()) {
   // Set up column projection if needed
   auto readColumnTypes = outputType_->children();
@@ -74,6 +70,7 @@ CudfHiveDataSource::CudfHiveDataSource(
         outputName);
 
     auto* handle = static_cast<const hive::HiveColumnHandle*>(it->second.get());
+    readColumnSet_.emplace(handle->name());
     readColumnNames_.emplace_back(handle->name());
   }
 
@@ -82,138 +79,189 @@ CudfHiveDataSource::CudfHiveDataSource(
   VELOX_CHECK_NOT_NULL(
       tableHandle_, "TableHandle must be an instance of HiveTableHandle");
 
-  // Create empty IOStats for later use
-  ioStats_ = std::make_shared<io::IoStatistics>();
-
-  // Copy subfield filters
+  // Copy subfield filters.
   for (const auto& [k, v] : tableHandle_->subfieldFilters()) {
     subfieldFilters_.emplace(k.clone(), v->clone());
-    // Add fields in the filter to the columns to read if not there
-    for (const auto& [field, _] : subfieldFilters_) {
-      if (std::find(
-              readColumnNames_.begin(),
-              readColumnNames_.end(),
-              field.toString()) == readColumnNames_.end()) {
-        readColumnNames_.push_back(field.toString());
-      }
-    }
   }
 
-  // Create remaining filter
-  auto remainingFilter = tableHandle_->remainingFilter();
+  // Extract additional simple filters from remainingFilter (same as CPU path).
+  // This extracts single-column filters like "col = 'X'" or "col <> 'Y'" from
+  // complex expressions and adds them to subfieldFilters_ for pushdown.
+  double sampleRate = tableHandle_->sampleRate();
+  auto remainingFilter =
+      facebook::velox::connector::hive::extractFiltersFromRemainingFilter(
+          tableHandle_->remainingFilter(),
+          expressionEvaluator_,
+          subfieldFilters_,
+          sampleRate);
+
+  // Add fields in the filter to the columns to read if not there
+  for (const auto& [field, _] : subfieldFilters_) {
+    if (readColumnSet_.count(field.toString()) == 0) {
+      readColumnSet_.emplace(field.toString());
+      readColumnNames_.emplace_back(field.toString());
+    }
+  }
   if (remainingFilter) {
     remainingFilterExprSet_ = expressionEvaluator_->compile(remainingFilter);
     for (const auto& field : remainingFilterExprSet_->distinctFields()) {
       // Add fields in the filter to the columns to read if not there
-      if (std::find(
-              readColumnNames_.begin(),
-              readColumnNames_.end(),
-              field->name()) == readColumnNames_.end()) {
-        readColumnNames_.push_back(field->name());
+      if (readColumnSet_.count(field->name()) == 0) {
+        readColumnSet_.emplace(field->name());
+        readColumnNames_.emplace_back(field->name());
       }
     }
 
-    const RowTypePtr remainingFilterType_ = [&] {
-      if (tableHandle_->dataColumns()) {
-        std::vector<std::string> new_names;
-        std::vector<TypePtr> new_types;
-
-        for (const auto& name : readColumnNames_) {
-          auto parsedType = tableHandle_->dataColumns()->findChild(name);
-          new_names.emplace_back(std::move(name));
-          new_types.push_back(parsedType);
-        }
-
-        return ROW(std::move(new_names), std::move(new_types));
-      } else {
-        return outputType_;
-      }
-    }();
-
-    cudfExpressionEvaluator_ = velox::cudf_velox::ExpressionEvaluator(
-        remainingFilterExprSet_->exprs(), remainingFilterType_);
+    auto const remainingFilterType = getTableRowType();
+    cudfExpressionEvaluator_ = velox::cudf_velox::createCudfExpression(
+        remainingFilterExprSet_->exprs()[0], remainingFilterType);
     // TODO(kn): Get column names and subfields from remaining filter and add to
     // readColumnNames_
   }
+
+  // Build a combined AST for all subfield filters once. This is query-constant
+  // and doesn't depend on split-specific state.
+  if (!subfieldFilters_.empty()) {
+    auto const readerFilterType = getTableRowType();
+    subfieldFilterExpr_ = &createAstFromSubfieldFilters(
+        subfieldFilters_, subfieldTree_, subfieldScalars_, readerFilterType);
+  }
+
+  VELOX_CHECK_NOT_NULL(fileHandleFactory_, "No FileHandleFactory present");
+
+  // Create empty IOStats and FsStats for later use
+  ioStatistics_ = std::make_shared<io::IoStatistics>();
+  ioStats_ = std::make_shared<facebook::velox::IoStats>();
+
+  // Whether to use the experimental cuDF reader
+  useExperimentalCudfReader_ =
+      cudfHiveConfig_->useExperimentalCudfReaderSession(
+          connectorQueryCtx_->sessionProperties());
 }
 
-std::optional<RowVectorPtr> CudfHiveDataSource::next(
-    uint64_t /*size*/,
-    velox::ContinueFuture& /* future */) {
-  VELOX_NVTX_OPERATOR_FUNC_RANGE();
-  // Basic sanity checks
-  VELOX_CHECK_NOT_NULL(split_, "No split to process. Call addSplit first.");
-  VELOX_CHECK_NOT_NULL(splitReader_, "No split reader present");
+std::unique_ptr<CudfSplitReader> CudfHiveDataSource::createCudfSplitReader() {
+  return std::make_unique<CudfSplitReader>(
+      split_,
+      tableHandle_,
+      outputType_,
+      readColumnNames_,
+      fileHandleFactory_,
+      executor_,
+      connectorQueryCtx_,
+      cudfHiveConfig_,
+      ioStatistics_,
+      ioStats_,
+      useExperimentalCudfReader_,
+      subfieldFilterExpr_);
+}
 
-  if (not splitReader_->has_next()) {
-    return nullptr;
+void CudfHiveDataSource::convertSplit(std::shared_ptr<ConnectorSplit> split) {
+  // Dynamic cast split to `CudfHiveConnectorSplit`
+  if (std::dynamic_pointer_cast<CudfHiveConnectorSplit>(split)) {
+    split_ = std::dynamic_pointer_cast<CudfHiveConnectorSplit>(split);
+    return;
   }
 
-  // Record start time before reading chunk
-  auto startTimeUs = getCurrentTimeMicro();
-
-  std::unique_ptr<cudf::table> cudfTable;
-  // Read a table chunk
-  auto [table, metadata] = splitReader_->read_chunk();
-  cudfTable = std::move(table);
-  // Fill in the column names if reading the first chunk.
-  if (columnNames_.empty()) {
-    for (const auto& schema : metadata.schema_info) {
-      columnNames_.emplace_back(schema.name);
-    }
+  // Convert `HiveConnectorSplit` to `CudfHiveConnectorSplit`
+  auto hiveSplit = checkedPointerCast<hive::HiveConnectorSplit>(split);
+
+  VELOX_CHECK_EQ(
+      hiveSplit->fileFormat,
+      dwio::common::FileFormat::PARQUET,
+      "Unsupported file format for conversion from HiveConnectorSplit to CudfHiveConnectorSplit");
+
+  // Remove "file:" prefix from the file path if present
+  std::string cleanedPath = hiveSplit->filePath;
+  constexpr std::string_view kFilePrefix = "file:";
+  constexpr std::string_view kS3APrefix = "s3a:";
+  if (cleanedPath.compare(0, kFilePrefix.size(), kFilePrefix) == 0) {
+    cleanedPath = cleanedPath.substr(kFilePrefix.size());
+  } else if (cleanedPath.compare(0, kS3APrefix.size(), kS3APrefix) == 0) {
+    // KvikIO does not support "s3a:" prefix. We need to translate it to "s3:".
+    cleanedPath.erase(kS3APrefix.size() - 2, 1);
+  }
+
+  auto cudfHiveSplitBuilder = CudfHiveConnectorSplitBuilder(cleanedPath)
+                                  .start(hiveSplit->start)
+                                  .length(hiveSplit->length)
+                                  .connectorId(hiveSplit->connectorId)
+                                  .splitWeight(hiveSplit->splitWeight);
+  for (auto const& infoColumn : hiveSplit->infoColumns) {
+    cudfHiveSplitBuilder.infoColumn(infoColumn.first, infoColumn.second);
   }
+  split_ = cudfHiveSplitBuilder.build();
+
+  VLOG(1) << "Adding split " << split_->toString();
+}
+
+void CudfHiveDataSource::addSplit(std::shared_ptr<ConnectorSplit> split) {
+  // Virtual method for class-specific conversion of the split
+  convertSplit(split);
 
-  TotalScanTimeCallbackData* callbackData =
-      new TotalScanTimeCallbackData{startTimeUs, ioStats_};
+  cudfSplitReader_ = createCudfSplitReader();
+  cudfSplitReader_->prepareSplit(runtimeStats_);
 
-  // Launch host callback to calculate timing when scan completes
-  cudaLaunchHostFunc(
-      stream_.value(),
-      &CudfHiveDataSource::totalScanTimeCalculator,
-      callbackData);
+  // TODO: `completedBytes_` should be updated in `next()` as we read more and
+  // more table bytes
+  try {
+    const auto fileHandleKey = FileHandleKey{
+        .filename = split_->filePath,
+        .tokenProvider = connectorQueryCtx_->fsTokenProvider()};
+    auto fileProperties = FileProperties{};
+    auto const fileHandleCachePtr = fileHandleFactory_->generate(
+        fileHandleKey, &fileProperties, ioStats_ ? ioStats_.get() : nullptr);
+    if (fileHandleCachePtr.get() and fileHandleCachePtr.get()->file) {
+      completedBytes_ += fileHandleCachePtr->file->size();
+    }
+  } catch (const std::exception& e) {
+    // Unable to get the file size, log a warning and continue
+    LOG(WARNING) << "Failed to get file size for " << split_->filePath << ": "
+                 << e.what();
+  }
+}
+
+std::optional<RowVectorPtr> CudfHiveDataSource::next(
+    uint64_t size,
+    velox::ContinueFuture& /* future */) {
+  VELOX_CHECK_NOT_NULL(split_, "No split present. Call addSplit() first.");
+  VELOX_CHECK_NOT_NULL(cudfSplitReader_, "No split to process.");
+  auto chunkOpt = cudfSplitReader_->next(size);
+  if (!chunkOpt.has_value()) {
+    return nullptr;
+  }
+  auto cudfTable = std::move(chunkOpt.value());
+  auto stream = cudfSplitReader_->stream();
 
   uint64_t filterTimeUs{0};
-  // Apply remaining filter if present
   if (remainingFilterExprSet_) {
     MicrosecondTimer filterTimer(&filterTimeUs);
     auto cudfTableColumns = cudfTable->release();
-    const auto originalNumColumns = cudfTableColumns.size();
-    // Filter may need addtional computed columns which are added to
-    // cudfTableColumns
-    auto filterResult = cudfExpressionEvaluator_.compute(
-        cudfTableColumns, stream_, cudf::get_current_device_resource_ref());
-    // discard computed columns
-    std::vector<std::unique_ptr<cudf::column>> originalColumns;
-    originalColumns.reserve(originalNumColumns);
-    std::move(
-        cudfTableColumns.begin(),
-        cudfTableColumns.begin() + originalNumColumns,
-        std::back_inserter(originalColumns));
+    std::vector<cudf::column_view> inputViews;
+    inputViews.reserve(cudfTableColumns.size());
+    for (auto& col : cudfTableColumns) {
+      inputViews.push_back(col->view());
+    }
+    auto filterResult =
+        cudfExpressionEvaluator_->eval(inputViews, stream, get_temp_mr());
     auto originalTable =
-        std::make_unique<cudf::table>(std::move(originalColumns));
-    // Keep only rows where the filter is true
+        std::make_unique<cudf::table>(std::move(cudfTableColumns));
     cudfTable = cudf::apply_boolean_mask(
-        *originalTable,
-        *filterResult[0],
-        stream_,
-        cudf::get_current_device_resource_ref());
+        *originalTable, asView(filterResult), stream, get_output_mr());
   }
   totalRemainingFilterTime_.fetch_add(
       filterTimeUs * 1000, std::memory_order_relaxed);
 
-  // Output RowVectorPtr
   const auto nRows = cudfTable->num_rows();
 
-  // keep only outputType_.size() columns in cudfTable_
   if (outputType_->size() < cudfTable->num_columns()) {
     auto cudfTableColumns = cudfTable->release();
-    std::vector<std::unique_ptr<cudf::column>> originalColumns;
-    originalColumns.reserve(outputType_->size());
+    std::vector<std::unique_ptr<cudf::column>> outputColumns;
+    outputColumns.reserve(outputType_->size());
     std::move(
         cudfTableColumns.begin(),
         cudfTableColumns.begin() + outputType_->size(),
-        std::back_inserter(originalColumns));
-    cudfTable = std::make_unique<cudf::table>(std::move(originalColumns));
+        std::back_inserter(outputColumns));
+    cudfTable = std::make_unique<cudf::table>(std::move(outputColumns));
   }
 
   // TODO (dm): Should we only enable table scan if cudf is registered?
@@ -221,15 +269,13 @@ std::optional<RowVectorPtr> CudfHiveDataSource::next(
   // We still can, but I'm wondering if this is the right thing to do
   auto output = cudfIsRegistered()
       ? std::make_shared<CudfVector>(
-            pool_, outputType_, nRows, std::move(cudfTable), stream_)
+            pool_, outputType_, nRows, std::move(cudfTable), stream)
       : with_arrow::toVeloxColumn(
-            cudfTable->view(), pool_, outputType_->names(), stream_);
-  stream_.synchronize();
+            cudfTable->view(), pool_, outputType_, stream, get_temp_mr());
+  stream.synchronize();
 
-  // Check if conversion yielded a nullptr
   VELOX_CHECK_NOT_NULL(output, "Cudf to Velox conversion yielded a nullptr");
 
-  // Update completedRows_.
   completedRows_ += output->size();
 
   // TODO: Update `completedBytes_` here instead of in `addSplit()`
@@ -237,151 +283,42 @@ std::optional<RowVectorPtr> CudfHiveDataSource::next(
   return output;
 }
 
-void CudfHiveDataSource::totalScanTimeCalculator(void* userData) {
-  TotalScanTimeCallbackData* data =
-      static_cast<TotalScanTimeCallbackData*>(userData);
-
-  // Record end time in callback
-  auto endTimeUs = getCurrentTimeMicro();
-
-  // Calculate elapsed time in microseconds and convert to nanoseconds
-  auto elapsedUs = endTimeUs - data->startTimeUs;
-  auto elapsedNs = elapsedUs * 1000; // Convert microseconds to nanoseconds
-
-  // Update totalScanTime
-  data->ioStats->incTotalScanTime(elapsedNs);
-
-  delete data;
-}
-
-void CudfHiveDataSource::addSplit(std::shared_ptr<ConnectorSplit> split) {
-  split_ = [&]() {
-    // Dynamic cast split to `CudfHiveConnectorSplit`
-    if (std::dynamic_pointer_cast<CudfHiveConnectorSplit>(split)) {
-      return std::dynamic_pointer_cast<CudfHiveConnectorSplit>(split);
-      // Convert `HiveConnectorSplit` to `CudfHiveConnectorSplit`
-    } else if (std::dynamic_pointer_cast<hive::HiveConnectorSplit>(split)) {
-      const auto hiveSplit =
-          std::dynamic_pointer_cast<hive::HiveConnectorSplit>(split);
-      VELOX_CHECK_EQ(
-          hiveSplit->fileFormat,
-          dwio::common::FileFormat::PARQUET,
-          "Unsupported file format for conversion from HiveConnectorSplit to CudfHiveConnectorSplit");
-      // Remove "file:" prefix from the file path if present
-      std::string cleanedPath = hiveSplit->filePath;
-      constexpr std::string_view kFilePrefix = "file:";
-      if (cleanedPath.compare(0, kFilePrefix.size(), kFilePrefix) == 0) {
-        cleanedPath = cleanedPath.substr(kFilePrefix.size());
-      }
-      return CudfHiveConnectorSplitBuilder(cleanedPath)
-          .connectorId(hiveSplit->connectorId)
-          .splitWeight(hiveSplit->splitWeight)
-          .build();
-    } else {
-      VELOX_FAIL("Unsupported split type: {}", split->toString());
-    }
-  }();
-
-  VLOG(1) << "Adding split " << split_->toString();
-
-  // Split reader already exists, reset
-  if (splitReader_) {
-    splitReader_.reset();
-  }
-
-  // Clear columnNames if not empty
-  if (not columnNames_.empty()) {
-    columnNames_.clear();
-  }
-
-  // Create a `cudf::io::chunked_parquet_reader` SplitReader
-  splitReader_ = createSplitReader();
-
-  // TODO: `completedBytes_` should be updated in `next()` as we read more and
-  // more table bytes
-  const auto& filePaths = split_->getCudfSourceInfo().filepaths();
-  for (const auto& filePath : filePaths) {
-    completedBytes_ += std::filesystem::file_size(filePath);
+std::unordered_map<std::string, RuntimeMetric>
+CudfHiveDataSource::getRuntimeStats() {
+  auto result = runtimeStats_.toRuntimeMetricMap();
+  result.insert({
+      {std::string(connector::hive::HiveDataSource::kTotalScanTime),
+       RuntimeMetric(
+           ioStatistics_->totalScanTimeNs(), RuntimeCounter::Unit::kNanos)},
+      {std::string(Connector::kTotalRemainingFilterTime),
+       RuntimeMetric(
+           totalRemainingFilterTime_.load(std::memory_order_relaxed),
+           RuntimeCounter::Unit::kNanos)},
+  });
+  const auto& ioStats = ioStats_->stats();
+  for (const auto& storageStats : ioStats) {
+    result.emplace(storageStats.first, storageStats.second);
   }
+  return result;
 }
 
-std::unique_ptr<cudf::io::chunked_parquet_reader>
-CudfHiveDataSource::createSplitReader() {
-  // Reader options
-  auto readerOptions =
-      cudf::io::parquet_reader_options::builder(split_->getCudfSourceInfo())
-          .skip_rows(parquetConfig_->skipRows())
-          .use_pandas_metadata(parquetConfig_->isUsePandasMetadata())
-          .use_arrow_schema(parquetConfig_->isUseArrowSchema())
-          .allow_mismatched_pq_schemas(
-              parquetConfig_->isAllowMismatchedCudfHiveSchemas())
-          .timestamp_type(parquetConfig_->timestampType())
-          .build();
-
-  // Set num_rows only if available
-  if (parquetConfig_->numRows().has_value()) {
-    readerOptions.set_num_rows(parquetConfig_->numRows().value());
-  }
-
-  if (subfieldFilters_.size()) {
-    const RowTypePtr readerFilterType = [&] {
-      if (tableHandle_->dataColumns()) {
-        std::vector<std::string> newNames;
-        std::vector<TypePtr> newTypes;
-
-        for (const auto& name : readColumnNames_) {
-          // Ensure all columns being read are available to the filter
-          auto parsedType = tableHandle_->dataColumns()->findChild(name);
-          newNames.emplace_back(std::move(name));
-          newTypes.push_back(parsedType);
-        }
-
-        return ROW(std::move(newNames), std::move(newTypes));
-      } else {
-        return outputType_;
-      }
-    }();
-
-    // Build a combined AST for all subfield filters.
-    auto const& combinedExpr = createAstFromSubfieldFilters(
-        subfieldFilters_, subfieldTree_, subfieldScalars_, readerFilterType);
-
-    readerOptions.set_filter(combinedExpr);
+const RowTypePtr CudfHiveDataSource::getTableRowType() {
+  if (cachedTableRowType_) {
+    return cachedTableRowType_;
   }
-
-  // Set column projection if needed
-  if (readColumnNames_.size()) {
-    readerOptions.set_columns(readColumnNames_);
+  if (tableHandle_->dataColumns()) {
+    std::vector<std::string> names;
+    std::vector<TypePtr> types;
+    for (const auto& name : readColumnNames_) {
+      auto parsedType = tableHandle_->dataColumns()->findChild(name);
+      names.emplace_back(std::move(name));
+      types.push_back(parsedType);
+    }
+    cachedTableRowType_ = ROW(std::move(names), std::move(types));
+    return cachedTableRowType_;
   }
-
-  stream_ = cudfGlobalStreamPool().get_stream();
-  // Create a parquet reader
-  return std::make_unique<cudf::io::chunked_parquet_reader>(
-      parquetConfig_->maxChunkReadLimit(),
-      parquetConfig_->maxPassReadLimit(),
-      readerOptions,
-      stream_,
-      cudf::get_current_device_resource_ref());
-}
-
-void CudfHiveDataSource::resetSplit() {
-  split_.reset();
-  splitReader_.reset();
-  columnNames_.clear();
-}
-
-std::unordered_map<std::string, RuntimeCounter>
-CudfHiveDataSource::runtimeStats() {
-  auto res = runtimeStats_.toMap();
-  res.insert({
-      {"totalScanTime",
-       RuntimeCounter(ioStats_->totalScanTime(), RuntimeCounter::Unit::kNanos)},
-      {"totalRemainingFilterTime",
-       RuntimeCounter(
-           totalRemainingFilterTime_.load(std::memory_order_relaxed),
-           RuntimeCounter::Unit::kNanos)},
-  });
-  return res;
+  cachedTableRowType_ = outputType_;
+  return cachedTableRowType_;
 }
 
 } // namespace facebook::velox::cudf_velox::connector::hive
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveDataSource.h b/velox/experimental/cudf/connectors/hive/CudfHiveDataSource.h
index ecdc5b13f54..0c6f3937813 100644
--- a/velox/experimental/cudf/connectors/hive/CudfHiveDataSource.h
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveDataSource.h
@@ -18,18 +18,23 @@
 
 #include "velox/experimental/cudf/connectors/hive/CudfHiveConfig.h"
 #include "velox/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.h"
-#include "velox/experimental/cudf/exec/ExpressionEvaluator.h"
+#include "velox/experimental/cudf/connectors/hive/CudfSplitReader.h"
 #include "velox/experimental/cudf/exec/NvtxHelper.h"
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
 
 #include "velox/common/base/RandomUtil.h"
 #include "velox/common/io/IoStatistics.h"
+#include "velox/common/io/Options.h"
 #include "velox/connectors/Connector.h"
+#include "velox/connectors/hive/FileHandle.h"
 #include "velox/connectors/hive/TableHandle.h"
 #include "velox/dwio/common/Statistics.h"
 #include "velox/type/Type.h"
 
-#include <cudf/io/parquet.hpp>
-#include <cudf/io/types.hpp>
+#include <cudf/ast/expressions.hpp>
+
+#include <mutex>
+#include <unordered_set>
 
 namespace facebook::velox::cudf_velox::connector::hive {
 
@@ -41,6 +46,7 @@ class CudfHiveDataSource : public DataSource, public NvtxHelper {
       const RowTypePtr& outputType,
       const ConnectorTableHandlePtr& tableHandle,
       const ColumnHandleMap& columnHandles,
+      facebook::velox::FileHandleFactory* fileHandleFactory,
       folly::Executor* executor,
       const ConnectorQueryCtx* connectorQueryCtx,
       const std::shared_ptr<CudfHiveConfig>& CudfHiveConfig);
@@ -71,81 +77,68 @@ class CudfHiveDataSource : public DataSource, public NvtxHelper {
     return completedBytes_;
   }
 
-  std::unordered_map<std::string, RuntimeCounter> runtimeStats() override;
+  std::unordered_map<std::string, RuntimeMetric> getRuntimeStats() override;
 
- private:
-  // Create a cudf::io::chunked_parquet_reader with the given split.
-  std::unique_ptr<cudf::io::chunked_parquet_reader> createSplitReader();
-  // Clear split_ and splitReader after split has been fully processed.  Keep
-  // readers around to hold adaptation.
-  void resetSplit();
-  // Clear cudfTable_ and currentCudfTableView_ once we have successfully
-  // converted it to `RowVectorPtr` and returned.
-  void resetCudfTableAndView();
-  const RowVectorPtr& getEmptyOutput() {
-    if (!emptyOutput_) {
-      emptyOutput_ = RowVector::createEmpty(outputType_, pool_);
-    }
-    return emptyOutput_;
-  }
-  RowVectorPtr emptyOutput_;
+ protected:
+  // Virtual method to create a `CudfSplitReader` or subclass for the data
+  // source.
+  virtual std::unique_ptr<CudfSplitReader> createCudfSplitReader();
+
+  // Virtual method to convert the input `ConnectorSplit` to appropriate
+  // subclass(es).
+  virtual void convertSplit(std::shared_ptr<ConnectorSplit> split);
 
   std::shared_ptr<CudfHiveConnectorSplit> split_;
   std::shared_ptr<const ::facebook::velox::connector::hive::HiveTableHandle>
       tableHandle_;
 
-  const std::shared_ptr<CudfHiveConfig> parquetConfig_;
-
+  const std::shared_ptr<CudfHiveConfig> cudfHiveConfig_;
+  facebook::velox::FileHandleFactory* const fileHandleFactory_;
   folly::Executor* const executor_;
   const ConnectorQueryCtx* const connectorQueryCtx_;
 
-  memory::MemoryPool* const pool_;
+  // Columns to read.
+  std::vector<std::string> readColumnNames_;
 
-  // cuDF CudfHive reader stuff.
-  cudf::io::parquet_reader_options readerOptions_;
-  std::unique_ptr<cudf::io::chunked_parquet_reader> splitReader_;
-  rmm::cuda_stream_view stream_;
+  std::shared_ptr<io::IoStatistics> ioStatistics_;
+  std::shared_ptr<velox::IoStats> ioStats_;
 
-  // Table column names read from the CudfHive file
-  std::vector<std::string> columnNames_;
+  // The row type for the data source output, not including filter-only columns.
+  const RowTypePtr outputType_;
 
-  // Output type from file reader.  This is different from outputType_ that it
-  // contains column names before assignment, and columns that only used in
-  // remaining filter.
-  RowTypePtr readerOutputType_;
+  bool useExperimentalCudfReader_;
 
-  // Columns to read.
-  std::vector<std::string> readColumnNames_;
+  // Cached combined subfield filter expression owned by 'subfieldTree_'.
+  cudf::ast::expression const* subfieldFilterExpr_{nullptr};
 
-  std::shared_ptr<io::IoStatistics> ioStats_;
+ private:
+  // Construct and cache a RowTypePtr for the table column names and types.
+  const RowTypePtr getTableRowType();
+  RowTypePtr cachedTableRowType_{};
+
+  memory::MemoryPool* const pool_;
 
   size_t completedRows_{0};
   size_t completedBytes_{0};
 
-  // The row type for the data source output, not including filter-only columns
-  const RowTypePtr outputType_;
+  dwio::common::RuntimeStatistics runtimeStats_;
+
+  std::unique_ptr<CudfSplitReader> cudfSplitReader_;
+
+  std::unique_ptr<exec::ExprSet> remainingFilterExprSet_;
+  std::shared_ptr<velox::cudf_velox::CudfExpression> cudfExpressionEvaluator_;
+
+  std::atomic<uint64_t> totalRemainingFilterTime_{0};
+
+  std::unordered_set<std::string> readColumnSet_;
 
   // Expression evaluator for remaining filter.
   core::ExpressionEvaluator* const expressionEvaluator_;
-  std::unique_ptr<exec::ExprSet> remainingFilterExprSet_;
-  velox::cudf_velox::ExpressionEvaluator cudfExpressionEvaluator_;
 
   // Expression evaluator for subfield filter.
   std::vector<std::unique_ptr<cudf::scalar>> subfieldScalars_;
   cudf::ast::tree subfieldTree_;
   common::SubfieldFilters subfieldFilters_;
-
-  dwio::common::RuntimeStatistics runtimeStats_;
-  std::atomic<uint64_t> totalRemainingFilterTime_{0};
-
-  // Create callback data for total scan timing calculation
-  struct TotalScanTimeCallbackData {
-    uint64_t startTimeUs;
-    std::shared_ptr<io::IoStatistics> ioStats;
-  };
-
-  // Host callback function to calculate total scan time
-  static void totalScanTimeCalculator(void* userData);
 };
 
 } // namespace facebook::velox::cudf_velox::connector::hive
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.cpp b/velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.cpp
index 64286506cf0..eed47886098 100644
--- a/velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.cpp
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "velox/experimental/cudf/CudfNoDefaults.h"
 #include "velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.h"
 
 #include "velox/connectors/Connector.h"
@@ -35,13 +36,11 @@ std::string CudfHiveColumnHandle::toString() const {
 CudfHiveTableHandle::CudfHiveTableHandle(
     std::string connectorId,
     const std::string& tableName,
-    bool filterPushdownEnabled,
     const core::TypedExprPtr& subfieldFilterExpr,
     const core::TypedExprPtr& remainingFilter,
     const RowTypePtr& dataColumns)
     : ConnectorTableHandle(std::move(connectorId)),
       tableName_(tableName),
-      filterPushdownEnabled_(filterPushdownEnabled),
       subfieldFilterExpr_(subfieldFilterExpr),
       remainingFilter_(remainingFilter),
       dataColumns_(dataColumns) {}
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.h b/velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.h
index 8d97db028d4..f8644ab1058 100644
--- a/velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.h
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.h
@@ -74,7 +74,6 @@ class CudfHiveTableHandle : public ConnectorTableHandle {
   CudfHiveTableHandle(
       std::string connectorId,
       const std::string& tableName,
-      bool filterPushdownEnabled,
       const core::TypedExprPtr& subfieldFilterExpr,
       const core::TypedExprPtr& remainingFilter = nullptr,
       const RowTypePtr& dataColumns = nullptr);
@@ -83,10 +82,6 @@ class CudfHiveTableHandle : public ConnectorTableHandle {
     return tableName_;
   }
 
-  bool isFilterPushdownEnabled() const {
-    return filterPushdownEnabled_;
-  }
-
   const core::TypedExprPtr& subfieldFilterExpr() const {
     return subfieldFilterExpr_;
   }
@@ -108,7 +103,6 @@ class CudfHiveTableHandle : public ConnectorTableHandle {
 
  private:
   const std::string tableName_;
-  const bool filterPushdownEnabled_;
   // This expression is used for predicate pushdown.
   const core::TypedExprPtr subfieldFilterExpr_;
   // This expression is used for post-scan filtering.
diff --git a/velox/experimental/cudf/connectors/hive/CudfSplitReader.cpp b/velox/experimental/cudf/connectors/hive/CudfSplitReader.cpp
new file mode 100644
index 00000000000..caa933361c4
--- /dev/null
+++ b/velox/experimental/cudf/connectors/hive/CudfSplitReader.cpp
@@ -0,0 +1,364 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/CudfNoDefaults.h"
+#include "velox/experimental/cudf/connectors/hive/CudfSplitReader.h"
+#include "velox/experimental/cudf/connectors/hive/CudfSplitReaderHelpers.h"
+#include "velox/experimental/cudf/exec/GpuResources.h"
+
+#include "velox/common/caching/CacheTTLController.h"
+#include "velox/common/time/Timer.h"
+#include "velox/connectors/hive/BufferedInputBuilder.h"
+#include "velox/connectors/hive/FileHandle.h"
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/connectors/hive/HiveDataSource.h"
+#include "velox/connectors/hive/TableHandle.h"
+
+#include <cudf/io/datasource.hpp>
+#include <cudf/io/experimental/hybrid_scan.hpp>
+#include <cudf/io/parquet.hpp>
+#include <cudf/io/text/byte_range_info.hpp>
+#include <cudf/io/types.hpp>
+#include <cudf/table/table.hpp>
+#include <cudf/table/table_view.hpp>
+
+#include <cuda_runtime.h>
+#include <nvtx3/nvtx3.hpp>
+
+#include <memory>
+
+namespace facebook::velox::cudf_velox::connector::hive {
+
+using namespace facebook::velox::connector;
+using namespace facebook::velox::connector::hive;
+
+CudfSplitReader::CudfSplitReader(
+    std::shared_ptr<CudfHiveConnectorSplit> split,
+    std::shared_ptr<const HiveTableHandle> tableHandle,
+    const RowTypePtr& outputType,
+    const std::vector<std::string>& readColumnNames,
+    FileHandleFactory* fileHandleFactory,
+    folly::Executor* executor,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    const std::shared_ptr<CudfHiveConfig>& cudfHiveConfig,
+    const std::shared_ptr<io::IoStatistics>& ioStatistics,
+    const std::shared_ptr<IoStats>& ioStats,
+    bool useExperimentalCudfReader,
+    cudf::ast::expression const* subfieldFilterExpr)
+    : NvtxHelper(
+          nvtx3::rgb{80, 171, 241},
+          std::nullopt,
+          fmt::format("[split:{}]", split ? split->filePath : "unknown")),
+      split_(std::move(split)),
+      tableHandle_(std::move(tableHandle)),
+      outputType_(outputType),
+      readColumnNames_(readColumnNames),
+      fileHandleFactory_(fileHandleFactory),
+      executor_(executor),
+      connectorQueryCtx_(connectorQueryCtx),
+      ioStatistics_(ioStatistics),
+      ioStats_(ioStats),
+      cudfHiveConfig_(cudfHiveConfig),
+      pool_(connectorQueryCtx->memoryPool()),
+      useExperimentalCudfReader_(useExperimentalCudfReader),
+      baseReaderOpts_(pool_),
+      subfieldFilterExpr_(subfieldFilterExpr) {
+  baseReaderOpts_.setDataIoStats(ioStatistics_);
+  baseReaderOpts_.setMetadataIoStats(ioStatistics_);
+}
+
+void CudfSplitReader::prepareSplit(
+    dwio::common::RuntimeStatistics& runtimeStats) {
+  // Reset existing split and split readers, if any
+  resetSplit();
+
+  // Acquire a stream from the global stream pool
+  stream_ = cudfGlobalStreamPool().get_stream();
+
+  // Create a cuDF split reader
+  if (useExperimentalCudfReader_) {
+    createExperimentalReader();
+    hybridScanState_ = std::make_unique<HybridScanState>();
+  } else {
+    createCudfReader(get_output_mr());
+  }
+
+  // Update runtime stats
+  runtimeStats.processedSplits++;
+}
+
+std::optional<std::unique_ptr<cudf::table>> CudfSplitReader::next(
+    uint64_t /*size*/) {
+  VELOX_NVTX_OPERATOR_FUNC_RANGE();
+  VELOX_CHECK(
+      splitReader_ or exptSplitReader_,
+      "No Cudf Split reader present. Call prepareSplit() first.");
+
+  // Record start time before reading chunk
+  auto startTimeUs = getCurrentTimeMicro();
+
+  auto chunkOpt = readNextChunk(get_output_mr());
+  if (!chunkOpt.has_value()) {
+    return std::nullopt;
+  }
+  auto cudfTable = std::move(chunkOpt.value());
+
+  TotalScanTimeCallbackData* callbackData =
+      new TotalScanTimeCallbackData{startTimeUs, ioStatistics_};
+
+  // Launch host callback to calculate timing when scan completes
+  cudaLaunchHostFunc(
+      stream_.value(), &CudfSplitReader::totalScanTimeCalculator, callbackData);
+
+  return cudfTable;
+}
+
+std::optional<std::unique_ptr<cudf::table>> CudfSplitReader::readNextChunk(
+    rmm::device_async_resource_ref output_mr) {
+  if (!useExperimentalCudfReader_) {
+    // Read table using the regular cudf parquet reader
+    VELOX_CHECK_NOT_NULL(splitReader_, "cudf parquet reader not present");
+
+    if (!splitReader_->has_next()) {
+      return std::nullopt;
+    }
+
+    auto tableWithMetadata = splitReader_->read_chunk();
+    return std::move(tableWithMetadata.tbl);
+  }
+
+  // Read table using the experimental parquet reader
+  VELOX_CHECK_NOT_NULL(exptSplitReader_, "cuDF hybrid scan reader not present");
+  VELOX_CHECK_NOT_NULL(hybridScanState_, "hybrid scan state not present");
+
+  std::call_once(*hybridScanState_->isHybridScanSetup_, [&]() {
+    auto rowGroupIndices = exptSplitReader_->all_row_groups(readerOptions_);
+
+    // Filter row groups using row group byte ranges
+    if (readerOptions_.get_skip_bytes() > 0 or
+        readerOptions_.get_num_bytes().has_value()) {
+      rowGroupIndices = exptSplitReader_->filter_row_groups_with_byte_range(
+          rowGroupIndices, readerOptions_);
+    }
+
+    // Filter row groups using column chunk statistics
+    if (readerOptions_.get_filter().has_value()) {
+      rowGroupIndices = exptSplitReader_->filter_row_groups_with_stats(
+          rowGroupIndices, readerOptions_, stream_);
+    }
+
+    // Get column chunk byte ranges to fetch
+    const auto columnChunkByteRanges =
+        exptSplitReader_->all_column_chunks_byte_ranges(
+            rowGroupIndices, readerOptions_);
+
+    // Fetch column chunk byte ranges
+    nvtxRangePush("fetchByteRanges");
+
+    // Tuple containing a vector of device buffers, a vector of device spans
+    // for each input byte range, and a future to wait for all reads to
+    // complete
+    auto ioData = fetchByteRangesAsync(
+        dataSource_, columnChunkByteRanges, stream_, get_temp_mr());
+
+    // Wait for all pending reads to complete
+    std::get<2>(ioData).wait();
+    nvtxRangePop();
+
+    // Save state for hybrid scan reader for future calls to `next()`
+    hybridScanState_->columnChunkBuffers_ = std::move(std::get<0>(ioData));
+    hybridScanState_->columnChunkData_ = std::move(std::get<1>(ioData));
+
+    exptSplitReader_->setup_chunking_for_all_columns(
+        cudfHiveConfig_->maxChunkReadLimit(),
+        cudfHiveConfig_->maxPassReadLimit(),
+        rowGroupIndices,
+        hybridScanState_->columnChunkData_,
+        readerOptions_,
+        stream_,
+        output_mr);
+    // TODO: check remainingFilterExprSet_ flag here to choose mr
+  });
+
+  if (!exptSplitReader_->has_next_table_chunk()) {
+    return std::nullopt;
+  }
+
+  auto tableWithMetadata = exptSplitReader_->materialize_all_columns_chunk();
+  return std::move(tableWithMetadata.tbl);
+}
+
+void CudfSplitReader::resetSplit() {
+  splitReader_.reset();
+  exptSplitReader_.reset();
+  hybridScanState_.reset();
+  dataSource_.reset();
+}
+
+void CudfSplitReader::setupCudfDataSource() {
+  if (dataSource_) {
+    return;
+  }
+
+  // Use file data source if we don't want to use the BufferedInput source
+  if (not cudfHiveConfig_->useBufferedInputSession(
+          connectorQueryCtx_->sessionProperties())) {
+    VLOG(1) << "Using file data source for CudfSplitReader";
+    dataSource_ = std::move(
+        cudf::io::make_datasources(cudf::io::source_info{split_->filePath})
+            .front());
+    return;
+  }
+
+  auto fileHandleCachePtr = FileHandleCachedPtr{};
+  try {
+    const auto fileHandleKey = FileHandleKey{
+        .filename = split_->filePath,
+        .tokenProvider = connectorQueryCtx_->fsTokenProvider()};
+    auto fileProperties = FileProperties{};
+    fileHandleCachePtr = fileHandleFactory_->generate(
+        fileHandleKey, &fileProperties, ioStats_ ? ioStats_.get() : nullptr);
+    VELOX_CHECK_NOT_NULL(fileHandleCachePtr.get());
+  } catch (const VeloxRuntimeError& e) {
+    LOG(WARNING) << fmt::format(
+        "Failed to generate file handle cache for file {}, falling back to kvikio data source for CudfSplitReader",
+        split_->filePath);
+    dataSource_ = std::move(
+        cudf::io::make_datasources(cudf::io::source_info{split_->filePath})
+            .front());
+    return;
+  }
+
+  // Here we keep adding new entries to CacheTTLController when new
+  // fileHandles are generated, if CacheTTLController was created. Creator of
+  // CacheTTLController needs to make sure a size control strategy was
+  // available such as removing aged out entries.
+  if (auto* cacheTTLController = cache::CacheTTLController::getInstance()) {
+    cacheTTLController->addOpenFileInfo(fileHandleCachePtr->uuid.id());
+  }
+
+  auto bufferedInput =
+      velox::connector::hive::BufferedInputBuilder::getInstance()->create(
+          *fileHandleCachePtr,
+          baseReaderOpts_,
+          connectorQueryCtx_,
+          ioStatistics_,
+          ioStats_,
+          executor_);
+  if (not bufferedInput) {
+    LOG(WARNING) << fmt::format(
+        "Failed to create buffered input source for file {}, falling back to kvikio data source for CudfSplitReader",
+        split_->filePath);
+    dataSource_ = std::move(
+        cudf::io::make_datasources(cudf::io::source_info{split_->filePath})
+            .front());
+    return;
+  }
+  dataSource_ =
+      std::make_unique<BufferedInputDataSource>(std::move(bufferedInput));
+}
+
+void CudfSplitReader::setupReaderOptions() {
+  VELOX_CHECK_NOT_NULL(
+      dataSource_, "CudfSplitReader failed to setup a cuDF datasource");
+  auto sourceInfo = cudf::io::source_info{dataSource_.get()};
+
+  // Reader options
+  readerOptions_ =
+      cudf::io::parquet_reader_options::builder(std::move(sourceInfo))
+          .use_pandas_metadata(cudfHiveConfig_->isUsePandasMetadata())
+          .use_arrow_schema(cudfHiveConfig_->isUseArrowSchema())
+          .allow_mismatched_pq_schemas(
+              cudfHiveConfig_->isAllowMismatchedCudfHiveSchemas())
+          .timestamp_type(cudfHiveConfig_->timestampType())
+          .build();
+
+  // Set skip_bytes and num_bytes if available
+  if (split_->start != 0) {
+    readerOptions_.set_skip_bytes(split_->start);
+  }
+  if (split_->size() != std::numeric_limits<uint64_t>::max()) {
+    readerOptions_.set_num_bytes(split_->size());
+  }
+
+  if (subfieldFilterExpr_ != nullptr) {
+    readerOptions_.set_filter(*subfieldFilterExpr_);
+  }
+
+  // Set column projection if needed
+  if (readColumnNames_.size()) {
+    readerOptions_.set_column_names(readColumnNames_);
+  }
+}
+
+void CudfSplitReader::createCudfReader(
+    rmm::device_async_resource_ref output_mr) {
+  // Setup datasource and reader options
+  setupCudfDataSource();
+  setupReaderOptions();
+
+  // Create a parquet reader
+  splitReader_ = std::make_unique<cudf::io::chunked_parquet_reader>(
+      cudfHiveConfig_->maxChunkReadLimit(),
+      cudfHiveConfig_->maxPassReadLimit(),
+      readerOptions_,
+      stream_,
+      output_mr);
+}
+
+void CudfSplitReader::createExperimentalReader() {
+  // Setup datasource and reader options
+  setupCudfDataSource();
+  setupReaderOptions();
+
+  // Create a hybrid scan reader
+  nvtxRangePush("hybridScanReader");
+  auto const footerBuffer = fetchFooterBytes(dataSource_);
+  auto reader =
+      std::make_unique<CudfHybridScanReader>(*footerBuffer, readerOptions_);
+  nvtxRangePop();
+
+  // Setup page index if available
+  auto const pageIndexByteRange = reader->page_index_byte_range();
+  if (not pageIndexByteRange.is_empty()) {
+    nvtxRangePush("setupPageIndex");
+    auto const pageIndexBuffer =
+        fetchPageIndexBytes(dataSource_, pageIndexByteRange);
+    reader->setup_page_index(*pageIndexBuffer);
+    nvtxRangePop();
+  }
+
+  exptSplitReader_ = std::move(reader);
+}
+
+void CudfSplitReader::totalScanTimeCalculator(void* userData) {
+  TotalScanTimeCallbackData* data =
+      static_cast<TotalScanTimeCallbackData*>(userData);
+
+  // Record end time in callback
+  auto endTimeUs = getCurrentTimeMicro();
+
+  // Calculate elapsed time in microseconds and convert to nanoseconds
+  auto elapsedUs = endTimeUs - data->startTimeUs;
+  auto elapsedNs = elapsedUs * 1000; // Convert microseconds to nanoseconds
+
+  // Update totalScanTime
+  data->ioStatistics->incTotalScanTimeNs(elapsedNs);
+
+  delete data;
+}
+
+} // namespace facebook::velox::cudf_velox::connector::hive
diff --git a/velox/experimental/cudf/connectors/hive/CudfSplitReader.h b/velox/experimental/cudf/connectors/hive/CudfSplitReader.h
new file mode 100644
index 00000000000..ecfbe08a16e
--- /dev/null
+++ b/velox/experimental/cudf/connectors/hive/CudfSplitReader.h
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/experimental/cudf/connectors/hive/CudfHiveConfig.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.h"
+#include "velox/experimental/cudf/connectors/hive/CudfSplitReaderHelpers.h"
+#include "velox/experimental/cudf/exec/NvtxHelper.h"
+
+#include "velox/common/io/IoStatistics.h"
+#include "velox/common/io/Options.h"
+#include "velox/connectors/Connector.h"
+#include "velox/connectors/hive/FileHandle.h"
+#include "velox/connectors/hive/TableHandle.h"
+#include "velox/dwio/common/Statistics.h"
+#include "velox/type/Type.h"
+
+#include <cudf/io/datasource.hpp>
+#include <cudf/io/experimental/hybrid_scan.hpp>
+#include <cudf/io/parquet.hpp>
+#include <cudf/io/types.hpp>
+
+namespace facebook::velox::cudf_velox::connector::hive {
+
+using namespace facebook::velox::connector;
+
+using CudfParquetReader = cudf::io::chunked_parquet_reader;
+using CudfParquetReaderPtr = std::unique_ptr<CudfParquetReader>;
+
+using CudfHybridScanReader =
+    cudf::io::parquet::experimental::hybrid_scan_reader;
+using CudfHybridScanReaderPtr = std::unique_ptr<CudfHybridScanReader>;
+
+class CudfSplitReader : public NvtxHelper {
+ public:
+  CudfSplitReader(
+      std::shared_ptr<CudfHiveConnectorSplit> split,
+      std::shared_ptr<const ::facebook::velox::connector::hive::HiveTableHandle>
+          tableHandle,
+      const RowTypePtr& outputType,
+      const std::vector<std::string>& readColumnNames,
+      FileHandleFactory* fileHandleFactory,
+      folly::Executor* executor,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      const std::shared_ptr<CudfHiveConfig>& cudfHiveConfig,
+      const std::shared_ptr<io::IoStatistics>& ioStatistics,
+      const std::shared_ptr<IoStats>& ioStats,
+      bool useExperimentalCudfReader,
+      cudf::ast::expression const* subfieldFilterExpr);
+
+  virtual ~CudfSplitReader() = default;
+
+  /// Prepare the split: open cudf reader, set up data source and options.
+  /// @param runtimeStats Reference to the DataSource's runtime statistics
+  virtual void prepareSplit(dwio::common::RuntimeStatistics& runtimeStats);
+
+  /// Read the next raw cudf table chunk. Returns nullopt when done.
+  virtual std::optional<std::unique_ptr<cudf::table>> next(uint64_t size);
+
+  /// Get the stream.
+  rmm::cuda_stream_view stream() const {
+    return stream_;
+  }
+
+ protected:
+  /// Create the chunked parquet reader.
+  virtual void createCudfReader(rmm::device_async_resource_ref output_mr);
+
+  /// Setup the cuDF data source
+  void setupCudfDataSource();
+
+  /// Clear splitReaders and datasources after split has been fully processed.
+  void resetSplit();
+
+  /// Read the next raw chunk from the parquet reader (regular or hybrid).
+  /// Returns nullopt when no more data.
+  virtual std::optional<std::unique_ptr<cudf::table>> readNextChunk(
+      rmm::device_async_resource_ref output_mr);
+
+  std::shared_ptr<CudfHiveConnectorSplit> split_;
+  std::shared_ptr<const ::facebook::velox::connector::hive::HiveTableHandle>
+      tableHandle_;
+  const RowTypePtr outputType_;
+  std::vector<std::string> readColumnNames_;
+
+  FileHandleFactory* fileHandleFactory_;
+  folly::Executor* executor_;
+  const ConnectorQueryCtx* connectorQueryCtx_;
+
+  std::shared_ptr<io::IoStatistics> ioStatistics_;
+  std::shared_ptr<IoStats> ioStats_;
+
+  std::shared_ptr<cudf::io::datasource> dataSource_;
+  rmm::cuda_stream_view stream_;
+
+ private:
+  /// Setup the cuDF reader options
+  void setupReaderOptions();
+
+  /// Create the experimental hybrid scan reader.
+  void createExperimentalReader();
+
+  std::shared_ptr<CudfHiveConfig> cudfHiveConfig_;
+  memory::MemoryPool* pool_;
+
+  // cuDF split reader stuff.
+  cudf::io::parquet_reader_options readerOptions_;
+  CudfParquetReaderPtr splitReader_;
+  CudfHybridScanReaderPtr exptSplitReader_;
+  std::unique_ptr<HybridScanState> hybridScanState_;
+  bool useExperimentalCudfReader_;
+
+  dwio::common::ReaderOptions baseReaderOpts_;
+
+  cudf::ast::expression const* subfieldFilterExpr_;
+
+  struct TotalScanTimeCallbackData {
+    uint64_t startTimeUs;
+    std::shared_ptr<io::IoStatistics> ioStatistics;
+  };
+
+  static void totalScanTimeCalculator(void* userData);
+};
+
+} // namespace facebook::velox::cudf_velox::connector::hive
diff --git a/velox/experimental/cudf/connectors/hive/CudfSplitReaderHelpers.cpp b/velox/experimental/cudf/connectors/hive/CudfSplitReaderHelpers.cpp
new file mode 100644
index 00000000000..f2990b32c00
--- /dev/null
+++ b/velox/experimental/cudf/connectors/hive/CudfSplitReaderHelpers.cpp
@@ -0,0 +1,361 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/CudfNoDefaults.h"
+#include "velox/experimental/cudf/connectors/hive/CudfSplitReaderHelpers.h"
+
+#include "velox/common/Casts.h"
+#include "velox/dwio/common/BufferedInput.h"
+
+#include <cudf/detail/utilities/integer_utils.hpp>
+#include <cudf/io/datasource.hpp>
+#include <cudf/io/parquet.hpp>
+#include <cudf/io/parquet_io_utils.hpp>
+#include <cudf/io/types.hpp>
+
+#include <cuda/iterator>
+#include <cuda/std/tuple>
+
+#include <folly/futures/Future.h>
+
+#include <future>
+#include <mutex>
+#include <vector>
+
+namespace {
+
+/**
+ * @brief Static mutex to serialize batches of IO operations across drivers
+ *
+ * Mutex to ensure no interleaving of IO operations across drivers to ensure
+ * drivers can move ahead without waiting for other drivers to finish their IO.
+ */
+std::mutex& ioBatchMutex() {
+  static std::mutex mutex;
+  return mutex;
+}
+
+template <typename T>
+std::future<T> toStdFuture(folly::Future<T> follyFuture) {
+  auto promise = std::make_shared<std::promise<T>>();
+  auto stdFuture = promise->get_future();
+
+  std::move(follyFuture).thenTry([promise](folly::Try<T>&& result) mutable {
+    if (result.hasValue()) {
+      promise->set_value(std::move(result.value()));
+    } else {
+      promise->set_exception(result.exception().to_exception_ptr());
+    }
+  });
+
+  return stdFuture;
+}
+} // namespace
+
+namespace facebook::velox::cudf_velox::connector::hive {
+
+BufferedInputDataSource::BufferedInputDataSource(
+    std::shared_ptr<facebook::velox::dwio::common::BufferedInput> input)
+    : input_(std::move(input)), fileSize_(input_->getReadFile()->size()) {}
+
+size_t BufferedInputDataSource::size() const {
+  return fileSize_;
+}
+
+void BufferedInputDataSource::enqueueForDevice(
+    uint64_t offset,
+    uint64_t size,
+    uint8_t* dst) {
+  auto inputStream = input_->enqueue({offset, size});
+  std::shared_ptr sharedStream(std::move(inputStream));
+  pendingDeviceLoads_.push_back(
+      [dst, size, sharedStream](rmm::cuda_stream_view stream) {
+        std::vector<uint8_t> buffer(size);
+        sharedStream->readFully(reinterpret_cast<char*>(buffer.data()), size);
+        CUDF_CUDA_TRY(cudaMemcpyAsync(
+            dst, buffer.data(), size, cudaMemcpyHostToDevice, stream.value()));
+      });
+}
+
+void BufferedInputDataSource::load(rmm::cuda_stream_view stream) {
+  input_->load(velox::dwio::common::LogType::FILE);
+  std::lock_guard<std::mutex> lock(ioBatchMutex());
+  for (auto& deviceLoad : pendingDeviceLoads_) {
+    deviceLoad(stream);
+  }
+}
+
+std::unique_ptr<cudf::io::datasource::buffer>
+BufferedInputDataSource::host_read(size_t offset, size_t size) {
+  if (offset >= fileSize_) {
+    return cudf::io::datasource::buffer::create(std::vector<uint8_t>{});
+  }
+  const size_t readSize = std::min(size, fileSize_ - offset);
+  std::vector<uint8_t> data(readSize);
+  readContiguous(offset, readSize, data.data());
+  return cudf::io::datasource::buffer::create(std::move(data));
+}
+
+size_t
+BufferedInputDataSource::host_read(size_t offset, size_t size, uint8_t* dst) {
+  if (offset >= fileSize_) {
+    return 0;
+  }
+  const size_t readSize = std::min(size, fileSize_ - offset);
+  readContiguous(offset, readSize, dst);
+  return readSize;
+}
+
+std::future<std::unique_ptr<cudf::io::datasource::buffer>>
+BufferedInputDataSource::host_read_async(size_t offset, size_t size) {
+  return std::async(std::launch::deferred, [this, offset, size]() {
+    return this->host_read(offset, size);
+  });
+}
+
+std::future<size_t> BufferedInputDataSource::host_read_async(
+    size_t offset,
+    size_t size,
+    uint8_t* dst) {
+  return std::async(std::launch::deferred, [this, offset, size, dst]() {
+    return this->host_read(offset, size, dst);
+  });
+}
+
+std::future<size_t> BufferedInputDataSource::device_read_async(
+    size_t offset,
+    size_t size,
+    uint8_t* dst,
+    rmm::cuda_stream_view stream) {
+  VELOX_CHECK(input_->executor() != nullptr, "IO executor is not initialized");
+  auto future = folly::via(input_->executor())
+                    .thenValue([this, offset, size, dst, stream](auto&&) {
+                      auto hostBuffer = this->host_read(offset, size);
+                      CUDF_CUDA_TRY(cudaMemcpyAsync(
+                          dst,
+                          hostBuffer->data(),
+                          hostBuffer->size(),
+                          cudaMemcpyHostToDevice,
+                          stream.value()));
+                      return hostBuffer->size();
+                    });
+  return toStdFuture(std::move(future));
+}
+
+bool BufferedInputDataSource::supports_device_read() const {
+  return true;
+}
+
+void BufferedInputDataSource::readContiguous(
+    size_t offset,
+    size_t size,
+    uint8_t* dst) {
+  using namespace facebook::velox::dwio::common;
+  // BufferedInput::read gives us a stream over the exact region.
+  auto stream = input_->read(offset, size, LogType::FILE);
+  VELOX_CHECK(stream != nullptr, "read() returned null stream");
+  stream->readFully(reinterpret_cast<char*>(dst), size);
+}
+
+std::unique_ptr<cudf::io::datasource::buffer> fetchFooterBytes(
+    std::shared_ptr<cudf::io::datasource> dataSource) {
+  // Using libcudf utility but may have custom implementation in the future
+  return cudf::io::parquet::fetch_footer_to_host(*dataSource);
+}
+
+std::unique_ptr<cudf::io::datasource::buffer> fetchPageIndexBytes(
+    std::shared_ptr<cudf::io::datasource> dataSource,
+    const cudf::io::text::byte_range_info pageIndexBytes) {
+  // Using libcudf utility but may have custom implementation in the future
+  return cudf::io::parquet::fetch_page_index_to_host(
+      *dataSource, pageIndexBytes);
+}
+
+std::tuple<
+    std::vector<rmm::device_buffer>,
+    std::vector<cudf::device_span<const uint8_t>>,
+    std::future<void>>
+fetchByteRangesAsync(
+    std::shared_ptr<cudf::io::datasource> dataSource,
+    cudf::host_span<const cudf::io::text::byte_range_info> byteRanges,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  // Pad buffer sizes to be a multiple of 8 bytes. Required by
+  // `decode_page_data_kernel` in cuDF Parquet reader.
+  constexpr auto kBufferPaddingMultiple = 8;
+
+  // Allocate device spans for each column chunk
+  std::vector<cudf::device_span<const uint8_t>> columnChunkData{};
+  columnChunkData.reserve(byteRanges.size());
+
+  // Total IO size across all byte ranges
+  auto totalSize = std::accumulate(
+      byteRanges.begin(),
+      byteRanges.end(),
+      std::size_t{0},
+      [&](auto acc, const auto& byteRange) { return acc + byteRange.size(); });
+
+  // Allocate single device buffer for all column chunks
+  std::vector<rmm::device_buffer> columnChunkBuffers{};
+  columnChunkBuffers.emplace_back(
+      cudf::util::round_up_safe<size_t>(totalSize, kBufferPaddingMultiple),
+      stream,
+      mr);
+
+  // Compute device spans for each column chunk
+  auto bufferData = static_cast<uint8_t*>(columnChunkBuffers.back().data());
+  std::ignore = std::accumulate(
+      byteRanges.begin(),
+      byteRanges.end(),
+      std::size_t{0},
+      [&](auto acc, const auto& byteRange) {
+        columnChunkData.emplace_back(
+            bufferData + acc, static_cast<size_t>(byteRange.size()));
+        return acc + byteRange.size();
+      });
+
+  // For BufferedInputDataSource, enqueue reads into the buffer and launch the
+  // actual load asynchronously.
+  if (auto bufferedInput =
+          dynamic_cast<BufferedInputDataSource*>(dataSource.get())) {
+    auto iter =
+        cuda::make_zip_iterator(byteRanges.begin(), columnChunkData.begin());
+    std::for_each(
+        iter, iter + byteRanges.size(), [bufferedInput](const auto& tuple) {
+          const auto& byteRange = cuda::std::get<0>(tuple);
+          const auto& destination = cuda::std::get<1>(tuple);
+          bufferedInput->enqueueForDevice(
+              static_cast<uint64_t>(byteRange.offset()),
+              static_cast<uint64_t>(byteRange.size()),
+              const_cast<uint8_t*>(destination.data()));
+        });
+
+    // load buffered input data source
+    auto syncFunction = [](std::shared_ptr<cudf::io::datasource> dataSource,
+                           rmm::cuda_stream_view stream) {
+      auto buffer =
+          checkedPointerCast<BufferedInputDataSource>(dataSource.get());
+      buffer->load(stream);
+    };
+
+    return {
+        std::move(columnChunkBuffers),
+        std::move(columnChunkData),
+        std::async(std::launch::deferred, syncFunction, dataSource, stream)};
+  }
+
+  // KvikIO dataSource: Impl borrowed from `fetch_byte_ranges_to_device_async()`
+  // in `parquet_io_utils.cpp` in cuDF.
+  std::vector<size_t> ioOffsets;
+  std::vector<size_t> ioSizes;
+  std::vector<uint8_t*> destinations;
+
+  for (size_t chunk = 0; chunk < byteRanges.size();) {
+    const auto ioOffset = static_cast<size_t>(byteRanges[chunk].offset());
+    auto ioSize = static_cast<size_t>(byteRanges[chunk].size());
+    size_t nextChunk = chunk + 1;
+    while (nextChunk < byteRanges.size()) {
+      const size_t nextOffset = byteRanges[nextChunk].offset();
+      if (nextOffset != ioOffset + ioSize) {
+        break;
+      }
+      ioSize += byteRanges[nextChunk].size();
+      nextChunk++;
+    }
+    if (ioSize != 0) {
+      ioOffsets.push_back(ioOffset);
+      ioSizes.push_back(ioSize);
+      destinations.push_back(
+          const_cast<uint8_t*>(columnChunkData[chunk].data()));
+    }
+    chunk = nextChunk;
+  }
+  VELOX_CHECK_EQ(
+      ioOffsets.size(),
+      ioSizes.size(),
+      "Number of IO offsets and sizes must be equal");
+  VELOX_CHECK_EQ(
+      ioSizes.size(),
+      destinations.size(),
+      "Number of IO sizes and destinations must be equal");
+
+  auto iter = cuda::make_zip_iterator(
+      ioOffsets.begin(), ioSizes.begin(), destinations.begin());
+
+  std::vector<std::future<size_t>> deviceReadTasks;
+  std::vector<std::future<size_t>> hostReadTasks;
+  deviceReadTasks.reserve(ioOffsets.size());
+  hostReadTasks.reserve(ioOffsets.size());
+
+  // device_read_async is not guaranteed to follow stream-ordering (see
+  // datasource API docs)
+  stream.synchronize();
+
+  {
+    std::lock_guard<std::mutex> lock(ioBatchMutex());
+
+    std::for_each(iter, iter + ioOffsets.size(), [&](const auto& tuple) {
+      const auto ioOffset = cuda::std::get<0>(tuple);
+      const auto ioSize = cuda::std::get<1>(tuple);
+      const auto dest = cuda::std::get<2>(tuple);
+
+      if (dataSource->supports_device_read() and
+          dataSource->is_device_read_preferred(ioSize)) {
+        deviceReadTasks.emplace_back(
+            dataSource->device_read_async(ioOffset, ioSize, dest, stream));
+      } else {
+        // TODO(mh): We can't yet guarantee (without a safe thread pool) that
+        // all `cudaMemcpyAsync`s will be launched by the time we release the
+        // mutex. That said, this is a rare usecase as host-buffer data should
+        // prefer using a `BufferedInputDataSource` datasource.
+        hostReadTasks.emplace_back(
+            std::async(
+                std::launch::async,
+                [dataSource, ioOffset, ioSize, dest, stream]() {
+                  auto hostBuffer = dataSource->host_read(ioOffset, ioSize);
+                  CUDF_CUDA_TRY(cudaMemcpyAsync(
+                      dest,
+                      hostBuffer->data(),
+                      hostBuffer->size(),
+                      cudaMemcpyHostToDevice,
+                      stream.value()));
+                  return ioSize;
+                }));
+      }
+    });
+  }
+
+  auto syncFunction = [](decltype(hostReadTasks)&& hostReadTasks,
+                         decltype(deviceReadTasks)&& deviceReadTasks) {
+    for (auto& task : hostReadTasks) {
+      task.get();
+    }
+    for (auto& task : deviceReadTasks) {
+      task.get();
+    }
+  };
+
+  return {
+      std::move(columnChunkBuffers),
+      std::move(columnChunkData),
+      std::async(
+          std::launch::deferred,
+          std::move(syncFunction),
+          std::move(hostReadTasks),
+          std::move(deviceReadTasks))};
+}
+
+} // namespace facebook::velox::cudf_velox::connector::hive
diff --git a/velox/experimental/cudf/connectors/hive/CudfSplitReaderHelpers.h b/velox/experimental/cudf/connectors/hive/CudfSplitReaderHelpers.h
new file mode 100644
index 00000000000..ecc80bd31f0
--- /dev/null
+++ b/velox/experimental/cudf/connectors/hive/CudfSplitReaderHelpers.h
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/dwio/common/BufferedInput.h"
+
+#include <cudf/ast/detail/expression_transformer.hpp>
+#include <cudf/ast/detail/operators.hpp>
+#include <cudf/ast/expressions.hpp>
+#include <cudf/detail/utilities/integer_utils.hpp>
+#include <cudf/io/datasource.hpp>
+#include <cudf/io/parquet.hpp>
+#include <cudf/io/parquet_schema.hpp>
+#include <cudf/io/text/byte_range_info.hpp>
+#include <cudf/io/types.hpp>
+
+#include <rmm/cuda_stream_view.hpp>
+#include <rmm/resource_ref.hpp>
+
+#include <vector>
+
+namespace facebook::velox::cudf_velox::connector::hive {
+
+// ---------------- Internal helper ----------------
+// A cudf::io::datasource that serves bytes via Velox BufferedInput so that
+// reads benefit from AsyncDataCache / SSD cache and are always returned as
+// contiguous buffers.
+class BufferedInputDataSource : public cudf::io::datasource {
+ public:
+  explicit BufferedInputDataSource(
+      std::shared_ptr<facebook::velox::dwio::common::BufferedInput> input);
+
+  [[nodiscard]] size_t size() const override;
+
+  std::unique_ptr<datasource::buffer> host_read(size_t offset, size_t size)
+      override;
+
+  size_t host_read(size_t offset, size_t size, uint8_t* dst) override;
+
+  std::future<std::unique_ptr<datasource::buffer>> host_read_async(
+      size_t offset,
+      size_t size) override;
+
+  std::future<size_t> host_read_async(size_t offset, size_t size, uint8_t* dst);
+
+  [[nodiscard]] bool supports_device_read() const override;
+
+  std::future<size_t> device_read_async(
+      size_t offset,
+      size_t size,
+      uint8_t* dst,
+      rmm::cuda_stream_view stream) override;
+
+  // Use the enqueue API from dwio::common::BufferedInput.
+  // Pass a device buffer to copy to after load.
+  void enqueueForDevice(uint64_t offset, uint64_t size, uint8_t* dst);
+
+  // loads and copies to device.
+  void load(rmm::cuda_stream_view stream);
+
+ private:
+  void readContiguous(size_t offset, size_t size, uint8_t* dst);
+
+  std::shared_ptr<facebook::velox::dwio::common::BufferedInput> input_;
+  const size_t fileSize_;
+  std::vector<std::function<void(rmm::cuda_stream_view stream)>>
+      pendingDeviceLoads_;
+};
+
+/**
+ * @brief Hybrid scan reader state
+ *
+ * This struct is used to store the column chunk data for the hybrid scan reader
+ * and a once flag to ensure the setup is only done once.
+ */
+struct HybridScanState {
+  HybridScanState() : isHybridScanSetup_(std::make_unique<std::once_flag>()) {}
+
+  std::vector<rmm::device_buffer> columnChunkBuffers_;
+  std::vector<cudf::device_span<const uint8_t>> columnChunkData_;
+  std::unique_ptr<std::once_flag> isHybridScanSetup_;
+};
+
+/**
+ * @brief Fetches a host buffer of Parquet footer bytes from the input data
+ * source
+ *
+ * @param dataSource Input data source
+ * @return Host buffer containing footer bytes
+ */
+std::unique_ptr<cudf::io::datasource::buffer> fetchFooterBytes(
+    std::shared_ptr<cudf::io::datasource> dataSource);
+
+/**
+ * @brief Fetches a host buffer of Parquet page index from the input data source
+ *
+ * @param dataSource Input datasource
+ * @param pageIndexBytes Byte range of page index
+ * @return Host buffer containing page index bytes
+ */
+std::unique_ptr<cudf::io::datasource::buffer> fetchPageIndexBytes(
+    std::shared_ptr<cudf::io::datasource> dataSource,
+    const cudf::io::text::byte_range_info pageIndexBytes);
+
+/**
+ * @brief Fetches a list of byte ranges from a host buffer into device buffers
+ *
+ * @param dataSource Input datasource
+ * @param byteRanges Byte ranges to fetch
+ * @param stream CUDA stream
+ * @param mr Device memory resource
+ *
+ * @return A tuple containing the device buffers, the device spans of the
+ * fetched data, and a future to wait on the read tasks
+ */
+std::tuple<
+    std::vector<rmm::device_buffer>,
+    std::vector<cudf::device_span<const uint8_t>>,
+    std::future<void>>
+fetchByteRangesAsync(
+    std::shared_ptr<cudf::io::datasource> dataSource,
+    cudf::host_span<const cudf::io::text::byte_range_info> byteRanges,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr);
+
+} // namespace facebook::velox::cudf_velox::connector::hive
diff --git a/velox/experimental/cudf/exec/AggregationRegistry.cpp b/velox/experimental/cudf/exec/AggregationRegistry.cpp
new file mode 100644
index 00000000000..224feb52574
--- /dev/null
+++ b/velox/experimental/cudf/exec/AggregationRegistry.cpp
@@ -0,0 +1,580 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/exec/AggregationRegistry.h"
+
+namespace facebook::velox::cudf_velox {
+
+namespace {
+
+void appendAggregationFunctionForStep(
+    StepAwareAggregationRegistry& registry,
+    const std::string& name,
+    core::AggregationNode::Step step,
+    const exec::FunctionSignaturePtr& signature) {
+  registry[name][step].push_back(signature);
+}
+
+} // namespace
+
+StepAwareAggregationRegistry& getGroupbyAggregationRegistry() {
+  static StepAwareAggregationRegistry registry;
+  return registry;
+}
+
+StepAwareAggregationRegistry& getReduceAggregationRegistry() {
+  static StepAwareAggregationRegistry registry;
+  return registry;
+}
+
+bool registerAggregationFunctionForStep(
+    StepAwareAggregationRegistry& registry,
+    const std::string& name,
+    core::AggregationNode::Step step,
+    const std::vector<exec::FunctionSignaturePtr>& signatures,
+    bool overwrite) {
+  if (!overwrite && registry.find(name) != registry.end() &&
+      registry[name].find(step) != registry[name].end()) {
+    return false;
+  }
+
+  registry[name][step] = signatures;
+  return true;
+}
+
+void registerCommonAggregationFunctions(
+    StepAwareAggregationRegistry& registry,
+    const std::string& prefix) {
+  using exec::FunctionSignatureBuilder;
+
+  auto sumSingleSignatures = std::vector<exec::FunctionSignaturePtr>{
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("tinyint")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("smallint")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("integer")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("bigint")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("double")
+          .build()};
+
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "sum",
+      core::AggregationNode::Step::kSingle,
+      sumSingleSignatures);
+
+  auto sumPartialSignatures = std::vector<exec::FunctionSignaturePtr>{
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("tinyint")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("smallint")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("integer")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("bigint")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("double")
+          .build()};
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "sum",
+      core::AggregationNode::Step::kPartial,
+      sumPartialSignatures);
+
+  auto sumFinalIntermediateSignatures = std::vector<exec::FunctionSignaturePtr>{
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("bigint")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("double")
+          .build()};
+
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "sum",
+      core::AggregationNode::Step::kFinal,
+      sumFinalIntermediateSignatures);
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "sum",
+      core::AggregationNode::Step::kIntermediate,
+      sumFinalIntermediateSignatures);
+
+  auto countSinglePartialSignatures = std::vector<exec::FunctionSignaturePtr>{
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("tinyint")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("smallint")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("integer")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("bigint")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("real")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("double")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("varchar")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("boolean")
+          .build(),
+      FunctionSignatureBuilder().returnType("bigint").build()};
+
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "count",
+      core::AggregationNode::Step::kSingle,
+      countSinglePartialSignatures);
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "count",
+      core::AggregationNode::Step::kPartial,
+      countSinglePartialSignatures);
+
+  auto countFinalIntermediateSignatures =
+      std::vector<exec::FunctionSignaturePtr>{FunctionSignatureBuilder()
+                                                  .returnType("bigint")
+                                                  .argumentType("bigint")
+                                                  .build()};
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "count",
+      core::AggregationNode::Step::kFinal,
+      countFinalIntermediateSignatures);
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "count",
+      core::AggregationNode::Step::kIntermediate,
+      countFinalIntermediateSignatures);
+
+  auto minMaxSignatures = std::vector<exec::FunctionSignaturePtr>{
+      FunctionSignatureBuilder()
+          .returnType("tinyint")
+          .argumentType("tinyint")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("smallint")
+          .argumentType("smallint")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("integer")
+          .argumentType("integer")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("bigint")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("real")
+          .argumentType("real")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("double")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("varchar")
+          .argumentType("varchar")
+          .build()};
+
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "min",
+      core::AggregationNode::Step::kSingle,
+      minMaxSignatures);
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "min",
+      core::AggregationNode::Step::kPartial,
+      minMaxSignatures);
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "min",
+      core::AggregationNode::Step::kFinal,
+      minMaxSignatures);
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "min",
+      core::AggregationNode::Step::kIntermediate,
+      minMaxSignatures);
+
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "max",
+      core::AggregationNode::Step::kSingle,
+      minMaxSignatures);
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "max",
+      core::AggregationNode::Step::kPartial,
+      minMaxSignatures);
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "max",
+      core::AggregationNode::Step::kFinal,
+      minMaxSignatures);
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "max",
+      core::AggregationNode::Step::kIntermediate,
+      minMaxSignatures);
+
+  auto avgSingleSignatures = std::vector<exec::FunctionSignaturePtr>{
+      FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("smallint")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("integer")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("bigint")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("double")
+          .build()};
+
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "avg",
+      core::AggregationNode::Step::kSingle,
+      avgSingleSignatures);
+
+  auto avgPartialSignatures = std::vector<exec::FunctionSignaturePtr>{
+      FunctionSignatureBuilder()
+          .returnType("row(double,bigint)")
+          .argumentType("smallint")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("row(double,bigint)")
+          .argumentType("integer")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("row(double,bigint)")
+          .argumentType("bigint")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("row(double,bigint)")
+          .argumentType("real")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("row(double,bigint)")
+          .argumentType("double")
+          .build()};
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "avg",
+      core::AggregationNode::Step::kPartial,
+      avgPartialSignatures);
+
+  auto avgFinalSignatures = std::vector<exec::FunctionSignaturePtr>{
+      FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("row(double,bigint)")
+          .build()};
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "avg",
+      core::AggregationNode::Step::kFinal,
+      avgFinalSignatures);
+
+  auto avgIntermediateSignatures = std::vector<exec::FunctionSignaturePtr>{
+      FunctionSignatureBuilder()
+          .returnType("row(double,bigint)")
+          .argumentType("row(double,bigint)")
+          .build()};
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "avg",
+      core::AggregationNode::Step::kIntermediate,
+      avgIntermediateSignatures);
+}
+
+void registerGroupbyOnlyAggregationFunctions(
+    StepAwareAggregationRegistry& registry,
+    const std::string& prefix) {
+  using exec::FunctionSignatureBuilder;
+
+  // Register stddev_samp function (sample standard deviation)
+  // Note: stddev_samp uses M2/MERGE_M2 aggregations which are only available
+  // for groupby, not reduce.
+
+  // kSingle: numeric -> double
+  auto stddevSampSingleSignatures = std::vector<exec::FunctionSignaturePtr>{
+      FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("bigint")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("double")
+          .build()};
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "stddev_samp",
+      core::AggregationNode::Step::kSingle,
+      stddevSampSingleSignatures);
+  // Register stddev as alias for stddev_samp
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "stddev",
+      core::AggregationNode::Step::kSingle,
+      stddevSampSingleSignatures);
+
+  // kPartial: numeric -> row(bigint, double, double) representing (count, mean,
+  // m2)
+  auto stddevSampPartialSignatures = std::vector<exec::FunctionSignaturePtr>{
+      FunctionSignatureBuilder()
+          .returnType("row(bigint,double,double)")
+          .argumentType("bigint")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("row(bigint,double,double)")
+          .argumentType("double")
+          .build()};
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "stddev_samp",
+      core::AggregationNode::Step::kPartial,
+      stddevSampPartialSignatures);
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "stddev",
+      core::AggregationNode::Step::kPartial,
+      stddevSampPartialSignatures);
+
+  // kIntermediate: row(bigint,double,double) -> row(bigint,double,double)
+  auto stddevSampIntermediateSignatures =
+      std::vector<exec::FunctionSignaturePtr>{
+          FunctionSignatureBuilder()
+              .returnType("row(bigint,double,double)")
+              .argumentType("row(bigint,double,double)")
+              .build()};
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "stddev_samp",
+      core::AggregationNode::Step::kIntermediate,
+      stddevSampIntermediateSignatures);
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "stddev",
+      core::AggregationNode::Step::kIntermediate,
+      stddevSampIntermediateSignatures);
+
+  // kFinal: row(bigint,double,double) -> double
+  auto stddevSampFinalSignatures = std::vector<exec::FunctionSignaturePtr>{
+      FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("row(bigint,double,double)")
+          .build()};
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "stddev_samp",
+      core::AggregationNode::Step::kFinal,
+      stddevSampFinalSignatures);
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "stddev",
+      core::AggregationNode::Step::kFinal,
+      stddevSampFinalSignatures);
+}
+
+void registerReduceOnlyAggregationFunctions(
+    StepAwareAggregationRegistry& registry,
+    const std::string& prefix) {
+  using exec::FunctionSignatureBuilder;
+
+  auto approxDistinctSingleSignatures = std::vector<exec::FunctionSignaturePtr>{
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("tinyint")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("smallint")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("integer")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("bigint")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("real")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("double")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("varchar")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("varbinary")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("date")
+          .build(),
+      FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("timestamp")
+          .build()};
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "approx_distinct",
+      core::AggregationNode::Step::kSingle,
+      approxDistinctSingleSignatures);
+
+  auto approxDistinctPartialSignatures =
+      std::vector<exec::FunctionSignaturePtr>{
+          FunctionSignatureBuilder()
+              .returnType("varbinary")
+              .argumentType("tinyint")
+              .build(),
+          FunctionSignatureBuilder()
+              .returnType("varbinary")
+              .argumentType("smallint")
+              .build(),
+          FunctionSignatureBuilder()
+              .returnType("varbinary")
+              .argumentType("integer")
+              .build(),
+          FunctionSignatureBuilder()
+              .returnType("varbinary")
+              .argumentType("bigint")
+              .build(),
+          FunctionSignatureBuilder()
+              .returnType("varbinary")
+              .argumentType("real")
+              .build(),
+          FunctionSignatureBuilder()
+              .returnType("varbinary")
+              .argumentType("double")
+              .build(),
+          FunctionSignatureBuilder()
+              .returnType("varbinary")
+              .argumentType("varchar")
+              .build(),
+          FunctionSignatureBuilder()
+              .returnType("varbinary")
+              .argumentType("varbinary")
+              .build(),
+          FunctionSignatureBuilder()
+              .returnType("varbinary")
+              .argumentType("date")
+              .build(),
+          FunctionSignatureBuilder()
+              .returnType("varbinary")
+              .argumentType("timestamp")
+              .build()};
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "approx_distinct",
+      core::AggregationNode::Step::kPartial,
+      approxDistinctPartialSignatures);
+
+  auto approxDistinctIntermediateSignatures =
+      std::vector<exec::FunctionSignaturePtr>{FunctionSignatureBuilder()
+                                                  .returnType("varbinary")
+                                                  .argumentType("varbinary")
+                                                  .build()};
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "approx_distinct",
+      core::AggregationNode::Step::kIntermediate,
+      approxDistinctIntermediateSignatures);
+
+  auto approxDistinctFinalSignatures =
+      std::vector<exec::FunctionSignaturePtr>{FunctionSignatureBuilder()
+                                                  .returnType("bigint")
+                                                  .argumentType("varbinary")
+                                                  .build()};
+  registerAggregationFunctionForStep(
+      registry,
+      prefix + "approx_distinct",
+      core::AggregationNode::Step::kFinal,
+      approxDistinctFinalSignatures);
+}
+
+void appendGroupbyAggregationFunctionForStep(
+    const std::string& name,
+    core::AggregationNode::Step step,
+    const exec::FunctionSignaturePtr& signature) {
+  appendAggregationFunctionForStep(
+      getGroupbyAggregationRegistry(), name, step, signature);
+}
+
+void appendReduceAggregationFunctionForStep(
+    const std::string& name,
+    core::AggregationNode::Step step,
+    const exec::FunctionSignaturePtr& signature) {
+  appendAggregationFunctionForStep(
+      getReduceAggregationRegistry(), name, step, signature);
+}
+
+void unregisterAggregateFunctions() {
+  getGroupbyAggregationRegistry().clear();
+  getReduceAggregationRegistry().clear();
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/AggregationRegistry.h b/velox/experimental/cudf/exec/AggregationRegistry.h
new file mode 100644
index 00000000000..b816d66b14c
--- /dev/null
+++ b/velox/experimental/cudf/exec/AggregationRegistry.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/core/PlanNode.h"
+#include "velox/expression/FunctionSignature.h"
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace facebook::velox::cudf_velox {
+
+// Step-aware aggregation function registry
+// Map of function name -> Map of step -> signatures
+using StepAwareAggregationRegistry = std::unordered_map<
+    std::string,
+    std::unordered_map<
+        core::AggregationNode::Step,
+        std::vector<exec::FunctionSignaturePtr>>>;
+
+/// Runtime aggregation registries keyed by physical execution kind.
+StepAwareAggregationRegistry& getGroupbyAggregationRegistry();
+StepAwareAggregationRegistry& getReduceAggregationRegistry();
+
+/// Shared registration helpers used to populate a target physical registry.
+bool registerAggregationFunctionForStep(
+    StepAwareAggregationRegistry& registry,
+    const std::string& name,
+    core::AggregationNode::Step step,
+    const std::vector<exec::FunctionSignaturePtr>& signatures,
+    bool overwrite = true);
+
+/// Shared common aggregation registration used by engine-specific builders.
+void registerCommonAggregationFunctions(
+    StepAwareAggregationRegistry& registry,
+    const std::string& prefix);
+
+/// Shared groupby-only aggregation registration (e.g., stddev_samp which uses
+/// M2/MERGE_M2 aggregations that are only available for groupby).
+void registerGroupbyOnlyAggregationFunctions(
+    StepAwareAggregationRegistry& registry,
+    const std::string& prefix);
+
+/// Shared reduce-only registration used by engine-specific builders.
+void registerReduceOnlyAggregationFunctions(
+    StepAwareAggregationRegistry& registry,
+    const std::string& prefix);
+
+/// Append a single signature to the current groupby aggregation registry.
+void appendGroupbyAggregationFunctionForStep(
+    const std::string& name,
+    core::AggregationNode::Step step,
+    const exec::FunctionSignaturePtr& signature);
+
+/// Append a single signature to the current reduce aggregation registry.
+void appendReduceAggregationFunctionForStep(
+    const std::string& name,
+    core::AggregationNode::Step step,
+    const exec::FunctionSignaturePtr& signature);
+
+/// Clear all physical aggregation registries.
+void unregisterAggregateFunctions();
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CMakeLists.txt b/velox/experimental/cudf/exec/CMakeLists.txt
index 91e8e1cc0c7..7977a2d470b 100644
--- a/velox/experimental/cudf/exec/CMakeLists.txt
+++ b/velox/experimental/cudf/exec/CMakeLists.txt
@@ -14,15 +14,29 @@
 
 add_library(
   velox_cudf_exec
+  AggregationRegistry.cpp
+  CudfAggregation.cpp
+  CudfAssignUniqueId.cpp
+  CudfBatchConcat.cpp
   CudfConversion.cpp
+  CudfDistinct.cpp
+  CudfEnforceSingleRow.cpp
   CudfFilterProject.cpp
-  CudfHashAggregation.cpp
+  CudfGroupId.cpp
+  CudfGroupby.cpp
   CudfHashJoin.cpp
   CudfLimit.cpp
   CudfLocalPartition.cpp
+  CudfMarkDistinct.cpp
+  CudfNestedLoopJoin.cpp
   CudfOrderBy.cpp
+  CudfReduce.cpp
+  CudfTopN.cpp
   DebugUtil.cpp
-  ExpressionEvaluator.cpp
+  GpuResources.cpp
+  OperatorAdapters.cpp
+  PrestoAggregateFunctions.cpp
+  SparkAggregateFunctions.cpp
   ToCudf.cpp
   Utilities.cpp
   VeloxCudfInterop.cpp
@@ -34,11 +48,12 @@ target_link_libraries(
   PRIVATE
     arrow
     velox_arrow_bridge
-    velox_exception
     velox_common_base
+    velox_cudf_expression
+    velox_cudf_hive_connector
     velox_cudf_vector
+    velox_exception
     velox_exec
-    velox_cudf_hive_connector
 )
 
 target_compile_options(velox_cudf_exec PRIVATE -Wno-missing-field-initializers)
diff --git a/velox/experimental/cudf/exec/CudfAggregation.cpp b/velox/experimental/cudf/exec/CudfAggregation.cpp
new file mode 100644
index 00000000000..d99513aaded
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfAggregation.cpp
@@ -0,0 +1,380 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/exec/CudfAggregation.h"
+#include "velox/experimental/cudf/exec/CudfFilterProject.h"
+#include "velox/experimental/cudf/exec/CudfGroupby.h"
+#include "velox/experimental/cudf/exec/CudfReduce.h"
+
+#include "velox/core/Expressions.h"
+#include "velox/exec/Aggregate.h"
+#include "velox/exec/AggregateFunctionRegistry.h"
+#include "velox/expression/SignatureBinder.h"
+
+#include <algorithm>
+#include <numeric>
+
+namespace facebook::velox::cudf_velox {
+
+bool isCountFunctionName(std::string_view kind) {
+  auto prefix = CudfConfig::getInstance().functionNamePrefix;
+  return kind.rfind(prefix + "count", 0) == 0;
+}
+
+CountInputKind getCountInputKind(
+    const core::AggregationNode::Aggregate& aggregate,
+    const VectorPtr& constant) {
+  if (aggregate.call->inputs().empty()) {
+    return CountInputKind::kCountAll;
+  }
+  if (constant != nullptr) {
+    return constant->isNullAt(0) ? CountInputKind::kNullConstant
+                                 : CountInputKind::kCountAll;
+  }
+  return CountInputKind::kColumn;
+}
+
+bool hasOnlyConstantArguments(const core::CallTypedExpr& call) {
+  return !call.inputs().empty() &&
+      std::all_of(
+          call.inputs().begin(), call.inputs().end(), [](const auto& arg) {
+            return dynamic_cast<const core::ConstantTypedExpr*>(arg.get()) !=
+                nullptr;
+          });
+}
+
+core::AggregationNode::Step getCompanionStep(
+    std::string const& kind,
+    core::AggregationNode::Step step) {
+  if (kind.ends_with("_merge")) {
+    return core::AggregationNode::Step::kIntermediate;
+  }
+
+  if (kind.ends_with("_partial")) {
+    return core::AggregationNode::Step::kPartial;
+  }
+
+  // The format is count_merge_extract_BIGINT or count_merge_extract.
+  if (kind.find("_merge_extract") != std::string::npos) {
+    return core::AggregationNode::Step::kFinal;
+  }
+
+  return step;
+}
+
+std::string getOriginalName(const std::string& kind) {
+  if (kind.ends_with("_merge")) {
+    return kind.substr(0, kind.size() - std::string("_merge").size());
+  }
+
+  if (kind.ends_with("_partial")) {
+    return kind.substr(0, kind.size() - std::string("_partial").size());
+  }
+  // The format is count_merge_extract_BIGINT or count_merge_extract.
+  if (auto pos = kind.find("_merge_extract"); pos != std::string::npos) {
+    return kind.substr(0, pos);
+  }
+
+  return kind;
+}
+
+namespace {
+bool isCompanionAggregateName(std::string const& kind) {
+  return kind.ends_with("_merge") || kind.ends_with("_partial") ||
+      kind.find("_merge_extract") != std::string::npos;
+}
+
+bool isSupportedZeroColumnAggregation(
+    const core::AggregationNode& aggregationNode) {
+  // Zero-column input: only global prefixed `count` aggregates (same as
+  // createAggregator). No GROUP BY keys.
+  return aggregationNode.groupingKeys().empty() &&
+      !aggregationNode.aggregates().empty() &&
+      std::all_of(
+             aggregationNode.aggregates().begin(),
+             aggregationNode.aggregates().end(),
+             [](const auto& aggregate) {
+               return isCountFunctionName(aggregate.call->name());
+             });
+}
+} // namespace
+
+bool hasCompanionAggregates(
+    std::vector<core::AggregationNode::Aggregate> const& aggregates) {
+  return std::any_of(aggregates.begin(), aggregates.end(), [](auto const& agg) {
+    return isCompanionAggregateName(agg.call->name());
+  });
+}
+
+std::vector<ResolvedAggregateInfo> resolveAggregateInfos(
+    core::AggregationNode const& aggregationNode,
+    core::AggregationNode::Step step,
+    TypePtr const& outputType,
+    std::vector<VectorPtr> const& constants) {
+  const auto numKeys = aggregationNode.groupingKeys().size();
+
+  std::vector<ResolvedAggregateInfo> params;
+  params.reserve(aggregationNode.aggregates().size());
+  for (size_t i = 0; i < aggregationNode.aggregates().size(); ++i) {
+    auto const& aggregate = aggregationNode.aggregates()[i];
+    auto const companionStep = getCompanionStep(aggregate.call->name(), step);
+    const auto originalName = getOriginalName(aggregate.call->name());
+    const auto resultType = exec::isPartialOutput(companionStep)
+        ? exec::resolveIntermediateType(originalName, aggregate.rawInputTypes)
+        : outputType->childAt(numKeys + i);
+
+    params.emplace_back(
+        companionStep,
+        aggregate.call->name(),
+        static_cast<uint32_t>(numKeys + i),
+        constants[i],
+        resultType,
+        isCountFunctionName(aggregate.call->name())
+            ? std::make_optional(getCountInputKind(aggregate, constants[i]))
+            : std::nullopt);
+  }
+  return params;
+}
+
+AggregationInputChannels buildAggregationInputChannels(
+    core::AggregationNode const& aggregationNode,
+    exec::OperatorCtx const& operatorCtx,
+    RowTypePtr const& inputRowSchema,
+    std::vector<column_index_t> const& groupingKeyInputChannels) {
+  AggregationInputChannels result;
+  result.constants.resize(aggregationNode.aggregates().size());
+  result.channels.reserve(
+      groupingKeyInputChannels.size() + aggregationNode.aggregates().size());
+  result.channels.insert(
+      result.channels.end(),
+      groupingKeyInputChannels.begin(),
+      groupingKeyInputChannels.end());
+
+  const auto fallbackChannel =
+      groupingKeyInputChannels.empty() ? 0 : groupingKeyInputChannels.front();
+
+  for (auto i = 0; i < aggregationNode.aggregates().size(); ++i) {
+    auto const& aggregate = aggregationNode.aggregates()[i];
+    std::vector<column_index_t> aggInputs;
+    for (auto const& arg : aggregate.call->inputs()) {
+      if (auto const field =
+              dynamic_cast<core::FieldAccessTypedExpr const*>(arg.get())) {
+        aggInputs.push_back(inputRowSchema->getChildIdx(field->name()));
+      } else if (
+          auto constant =
+              dynamic_cast<const core::ConstantTypedExpr*>(arg.get())) {
+        result.constants[i] = constant->toConstantVector(operatorCtx.pool());
+        aggInputs.push_back(fallbackChannel);
+      } else {
+        VELOX_NYI("Constants and lambdas not yet supported");
+      }
+    }
+
+    VELOX_CHECK(aggInputs.size() <= 1);
+    if (aggInputs.empty()) {
+      aggInputs.push_back(fallbackChannel);
+    }
+
+    if (aggregate.distinct) {
+      VELOX_NYI("De-dup before aggregation is not yet supported");
+    }
+
+    result.channels.push_back(aggInputs[0]);
+  }
+
+  return result;
+}
+
+RowTypePtr getBufferedResultType(core::AggregationNode const& aggregationNode) {
+  const auto outputRowType = asRowType(aggregationNode.outputType());
+  const auto numKeys = aggregationNode.groupingKeys().size();
+
+  std::vector<std::string> names = outputRowType->names();
+  std::vector<TypePtr> types = outputRowType->children();
+
+  VELOX_CHECK_EQ(names.size(), types.size());
+  VELOX_CHECK_GE(types.size(), numKeys + aggregationNode.aggregates().size());
+
+  for (auto i = 0; i < aggregationNode.aggregates().size(); ++i) {
+    auto const& aggregate = aggregationNode.aggregates()[i];
+    const auto originalName = getOriginalName(aggregate.call->name());
+    types[numKeys + i] =
+        exec::resolveIntermediateType(originalName, aggregate.rawInputTypes);
+  }
+
+  return ROW(std::move(names), std::move(types));
+}
+
+bool hasFinalAggs(
+    std::vector<core::AggregationNode::Aggregate> const& aggregates) {
+  return std::any_of(aggregates.begin(), aggregates.end(), [](auto const& agg) {
+    return agg.call->name().ends_with("_merge_extract");
+  });
+}
+
+void setupGroupingKeyChannelProjections(
+    const core::AggregationNode& aggregationNode,
+    std::vector<column_index_t>& groupingKeyInputChannels,
+    std::vector<column_index_t>& groupingKeyOutputChannels) {
+  VELOX_CHECK(groupingKeyInputChannels.empty());
+  VELOX_CHECK(groupingKeyOutputChannels.empty());
+
+  auto const& inputType = aggregationNode.sources()[0]->outputType();
+  auto const& groupingKeys = aggregationNode.groupingKeys();
+  // The map from the grouping key output channel to the input channel.
+  //
+  // NOTE: grouping key output order is specified as 'groupingKeys' in
+  // 'aggregationNode_'.
+  std::vector<exec::IdentityProjection> groupingKeyProjections;
+  groupingKeyProjections.reserve(groupingKeys.size());
+  for (auto i = 0; i < groupingKeys.size(); ++i) {
+    groupingKeyProjections.emplace_back(
+        exec::exprToChannel(groupingKeys[i].get(), inputType), i);
+  }
+
+  groupingKeyInputChannels.reserve(groupingKeys.size());
+  for (auto i = 0; i < groupingKeys.size(); ++i) {
+    groupingKeyInputChannels.push_back(groupingKeyProjections[i].inputChannel);
+  }
+
+  groupingKeyOutputChannels.resize(groupingKeys.size());
+
+  std::iota(
+      groupingKeyOutputChannels.begin(), groupingKeyOutputChannels.end(), 0);
+}
+
+bool matchTypedCallAgainstSignatures(
+    const core::CallTypedExpr& call,
+    const std::vector<exec::FunctionSignaturePtr>& sigs) {
+  const auto n = call.inputs().size();
+  std::vector<TypePtr> argTypes;
+  argTypes.reserve(n);
+  for (const auto& input : call.inputs()) {
+    argTypes.push_back(input->type());
+  }
+  for (const auto& sig : sigs) {
+    std::vector<Coercion> coercions(n);
+    exec::SignatureBinder binder(*sig, argTypes, TypeCoercer::defaults());
+    if (!binder.tryBindWithCoercions(coercions)) {
+      continue;
+    }
+
+    // For simplicity we skip checking for constant agruments, this may be added
+    // in the future
+
+    return true;
+  }
+  return false;
+}
+
+bool canAggregationBeEvaluatedByRegistry(
+    const StepAwareAggregationRegistry& registry,
+    const core::CallTypedExpr& call,
+    core::AggregationNode::Step step,
+    const std::vector<TypePtr>& rawInputTypes,
+    core::QueryCtx* queryCtx) {
+  // Check against step-aware aggregation registry
+  const auto companionStep = getCompanionStep(call.name(), step);
+  const auto originalName = getOriginalName(call.name());
+  auto funcIt = registry.find(originalName);
+  if (funcIt == registry.end()) {
+    return false;
+  }
+
+  auto stepIt = funcIt->second.find(companionStep);
+  if (stepIt == funcIt->second.end()) {
+    return false;
+  }
+
+  if (isCountFunctionName(call.name())) {
+    return true;
+  }
+
+  if (hasOnlyConstantArguments(call)) {
+    return false;
+  }
+
+  // Validate against step-specific signatures from registry.
+  return matchTypedCallAgainstSignatures(call, stepIt->second);
+}
+
+bool canBeEvaluatedByCudf(
+    const core::AggregationNode& aggregationNode,
+    core::QueryCtx* queryCtx) {
+  const core::PlanNode* sourceNode = aggregationNode.sources().empty()
+      ? nullptr
+      : aggregationNode.sources()[0].get();
+
+  if (sourceNode && sourceNode->outputType()->size() == 0 &&
+      !isSupportedZeroColumnAggregation(aggregationNode)) {
+    return false;
+  }
+
+  bool isGlobal = aggregationNode.groupingKeys().empty();
+  bool isDistinct = !isGlobal && aggregationNode.aggregates().empty();
+
+  if (isDistinct) {
+    return canGroupingKeysBeEvaluatedByCudf(
+        aggregationNode.groupingKeys(), sourceNode, queryCtx);
+  } else if (isGlobal) {
+    return canReduceBeEvaluatedByCudf(aggregationNode, queryCtx);
+  } else {
+    return canGroupbyBeEvaluatedByCudf(aggregationNode, queryCtx);
+  }
+}
+
+core::TypedExprPtr expandFieldReference(
+    const core::TypedExprPtr& expr,
+    const core::PlanNode* sourceNode) {
+  // If this is a field reference and we have a source projection, expand it
+  if (expr->kind() == core::ExprKind::kFieldAccess && sourceNode) {
+    auto projectNode = dynamic_cast<const core::ProjectNode*>(sourceNode);
+    if (projectNode) {
+      auto fieldExpr =
+          std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(expr);
+      if (fieldExpr) {
+        // Find the corresponding projection expression
+        const auto& projections = projectNode->projections();
+        const auto& names = projectNode->names();
+        for (size_t i = 0; i < names.size(); ++i) {
+          if (names[i] == fieldExpr->name()) {
+            return projections[i];
+          }
+        }
+      }
+    }
+  }
+  return expr;
+}
+
+bool canGroupingKeysBeEvaluatedByCudf(
+    const std::vector<core::FieldAccessTypedExprPtr>& groupingKeys,
+    const core::PlanNode* sourceNode,
+    core::QueryCtx* queryCtx) {
+  // Check grouping key expressions (with expansion)
+  for (const auto& groupingKey : groupingKeys) {
+    auto expandedKey = expandFieldReference(groupingKey, sourceNode);
+    std::vector<core::TypedExprPtr> exprs = {expandedKey};
+    if (!canBeEvaluatedByCudf(exprs, queryCtx)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfAggregation.h b/velox/experimental/cudf/exec/CudfAggregation.h
new file mode 100644
index 00000000000..48a79df9705
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfAggregation.h
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/experimental/cudf/exec/AggregationRegistry.h"
+#include "velox/experimental/cudf/vector/CudfVector.h"
+
+#include "velox/exec/Operator.h"
+#include "velox/expression/FunctionSignature.h"
+
+#include <optional>
+#include <string_view>
+
+namespace facebook::velox::cudf_velox {
+
+/// \brief Convert companion function to step for the aggregation function
+///
+/// Companion functions are functions that are registered in velox along with
+/// their main aggregation functions. These are designed to always function
+/// with a fixed `step`. This is to allow spark style planNodes where `step` is
+/// the property of the aggregation function rather than the planNode.
+/// Companion functions allow us to override the planNode's step and use
+/// aggregations of different steps in the same planNode
+/// If an agg function name contains companionStep keyword, may cause error, now
+/// it does not exist.
+core::AggregationNode::Step getCompanionStep(
+    std::string const& kind,
+    core::AggregationNode::Step step);
+
+std::string getOriginalName(const std::string& kind);
+
+enum class CountInputKind {
+  kColumn,
+  kCountAll,
+  kNullConstant,
+};
+
+CountInputKind getCountInputKind(
+    const core::AggregationNode::Aggregate& aggregate,
+    const VectorPtr& constant);
+
+// Resolved per-aggregate parameters shared by groupby and reduce aggregator
+// construction.  Computed once by resolveAggregateInfo and consumed by the
+// type-specific factory in each module.
+struct ResolvedAggregateInfo {
+  core::AggregationNode::Step companionStep;
+  std::string kind;
+  uint32_t inputIndex;
+  VectorPtr constant;
+  TypePtr resultType;
+  std::optional<CountInputKind> countInputKind;
+};
+
+// Parse aggregate inputs from the aggregation node and resolve companion steps,
+// original names, and result types. Returns one entry per aggregate.
+std::vector<ResolvedAggregateInfo> resolveAggregateInfos(
+    core::AggregationNode const& aggregationNode,
+    core::AggregationNode::Step step,
+    TypePtr const& outputType,
+    std::vector<VectorPtr> const& constants);
+
+// Result of buildAggregationInputChannels: a channel permutation that places
+// grouping keys first, followed by aggregate input columns in aggregate order,
+// plus per-aggregate constants.
+struct AggregationInputChannels {
+  std::vector<column_index_t> channels;
+  std::vector<VectorPtr> constants;
+};
+
+// Build the input channel permutation for an aggregation node.  The returned
+// channels vector contains grouping key channels first, then one channel per
+// aggregate (resolved from the aggregate's input expression).  Constants are
+// stored in the parallel constants vector (nullptr when the aggregate uses a
+// column, non-null when it uses a constant).
+AggregationInputChannels buildAggregationInputChannels(
+    core::AggregationNode const& aggregationNode,
+    exec::OperatorCtx const& operatorCtx,
+    RowTypePtr const& inputRowSchema,
+    std::vector<column_index_t> const& groupingKeyInputChannels);
+
+bool isCountFunctionName(std::string_view kind);
+
+bool hasOnlyConstantArguments(const core::CallTypedExpr& call);
+
+// Returns true if the aggregation node contains companion aggregates
+// (e.g. _merge, _partial, _merge_extract suffixes), which disables streaming.
+bool hasCompanionAggregates(
+    std::vector<core::AggregationNode::Aggregate> const& aggregates);
+
+// Compute the intermediate ROW type used for buffered results in kFinal/kSingle
+// streaming.  The key columns keep their original types but aggregate columns
+// are replaced with the corresponding intermediate types.
+RowTypePtr getBufferedResultType(core::AggregationNode const& aggregationNode);
+
+bool hasFinalAggs(
+    std::vector<core::AggregationNode::Aggregate> const& aggregates);
+
+void setupGroupingKeyChannelProjections(
+    const core::AggregationNode& aggregationNode,
+    std::vector<column_index_t>& groupingKeyInputChannels,
+    std::vector<column_index_t>& groupingKeyOutputChannels);
+
+// Top-level validation: dispatches to groupby or reduce validation based on
+// whether the aggregation node is global.
+bool canBeEvaluatedByCudf(
+    const core::AggregationNode& aggregationNode,
+    core::QueryCtx* queryCtx);
+
+// Utility functions shared by groupby and reduce validation.
+core::TypedExprPtr expandFieldReference(
+    const core::TypedExprPtr& expr,
+    const core::PlanNode* sourceNode);
+
+bool canGroupingKeysBeEvaluatedByCudf(
+    const std::vector<core::FieldAccessTypedExprPtr>& groupingKeys,
+    const core::PlanNode* sourceNode,
+    core::QueryCtx* queryCtx);
+
+bool matchTypedCallAgainstSignatures(
+    const core::CallTypedExpr& call,
+    const std::vector<exec::FunctionSignaturePtr>& sigs);
+
+// Validate a single aggregation call against a given registry.
+bool canAggregationBeEvaluatedByRegistry(
+    const StepAwareAggregationRegistry& registry,
+    const core::CallTypedExpr& call,
+    core::AggregationNode::Step step,
+    const std::vector<TypePtr>& rawInputTypes,
+    core::QueryCtx* queryCtx);
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfAssignUniqueId.cpp b/velox/experimental/cudf/exec/CudfAssignUniqueId.cpp
new file mode 100644
index 00000000000..80643a1f090
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfAssignUniqueId.cpp
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/cudf/CudfNoDefaults.h"
+#include "velox/experimental/cudf/exec/CudfAssignUniqueId.h"
+#include "velox/experimental/cudf/exec/GpuResources.h"
+
+#include <cudf/lists/filling.hpp>
+
+#include <utility>
+
+namespace facebook::velox::cudf_velox {
+
+CudfAssignUniqueId::CudfAssignUniqueId(
+    int32_t operatorId,
+    exec::DriverCtx* driverCtx,
+    const std::shared_ptr<const core::AssignUniqueIdNode>& planNode,
+    int32_t uniqueTaskId,
+    std::shared_ptr<std::atomic_int64_t> rowIdPool)
+    : CudfOperatorBase(
+          operatorId,
+          driverCtx,
+          planNode->outputType(),
+          planNode->id(),
+          "CudfAssignUniqueId",
+          nvtx3::rgb{160, 82, 45}, // Sienna
+          NvtxMethodFlag::kAll,
+          std::nullopt,
+          planNode),
+      rowIdPool_(std::move(rowIdPool)) {
+  VELOX_USER_CHECK_LT(
+      uniqueTaskId,
+      kTaskUniqueIdLimit,
+      "Unique 24-bit ID specified for CudfAssignUniqueId exceeds the limit");
+  uniqueValueMask_ = static_cast<int64_t>(uniqueTaskId) << 40;
+
+  rowIdCounter_ = 0;
+  maxRowIdCounterValue_ = 0;
+}
+
+void CudfAssignUniqueId::doAddInput(RowVectorPtr input) {
+  auto numInput = input->size();
+  VELOX_CHECK_NE(
+      numInput, 0, "CudfAssignUniqueId::addInput received empty set of rows");
+  input_ = std::move(input);
+}
+
+RowVectorPtr CudfAssignUniqueId::doGetOutput() {
+  if (input_ == nullptr) {
+    return nullptr;
+  }
+
+  auto cudfVector = std::dynamic_pointer_cast<CudfVector>(input_);
+  VELOX_CHECK(cudfVector, "Input must be a CudfVector");
+  auto stream = cudfVector->stream();
+  auto uniqueIdColumn =
+      generateIdColumn(input_->size(), stream, get_output_mr());
+  auto size = cudfVector->size();
+  auto columns = cudfVector->release()->release();
+  columns.push_back(std::move(uniqueIdColumn));
+  auto output = std::make_shared<CudfVector>(
+      input_->pool(),
+      outputType_,
+      size,
+      std::make_unique<cudf::table>(std::move(columns)),
+      stream);
+  input_ = nullptr;
+  return output;
+}
+
+bool CudfAssignUniqueId::isFinished() {
+  return noMoreInput_ && input_ == nullptr;
+}
+
+std::unique_ptr<cudf::column> CudfAssignUniqueId::generateIdColumn(
+    vector_size_t size,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  std::vector<int64_t> starts, sizes;
+  starts.reserve(size / kRowIdsPerRequest + 1);
+  sizes.reserve(size / kRowIdsPerRequest + 1);
+
+  vector_size_t start = 0;
+  while (start < size) {
+    if (rowIdCounter_ >= maxRowIdCounterValue_) {
+      requestRowIds();
+    }
+
+    const auto numAvailableIds =
+        std::min(maxRowIdCounterValue_ - rowIdCounter_, kRowIdsPerRequest);
+    const vector_size_t end =
+        std::min(static_cast<int64_t>(size), start + numAvailableIds);
+    VELOX_CHECK_EQ(
+        (rowIdCounter_ + (end - start)) & uniqueValueMask_,
+        0,
+        "Ran out of unique IDs at {}. Need {} more.",
+        rowIdCounter_,
+        (end - start));
+    starts.push_back(uniqueValueMask_ | rowIdCounter_);
+    sizes.push_back(end - start);
+
+    rowIdCounter_ += (end - start);
+    start = end;
+  }
+
+  // Copy starts and sizes to device.
+  rmm::device_buffer d_starts_buffer(
+      starts.data(), starts.size() * sizeof(int64_t), stream, mr);
+  rmm::device_buffer d_sizes_buffer(
+      sizes.data(), sizes.size() * sizeof(int64_t), stream, mr);
+  auto d_starts_column_view = cudf::column_view(
+      cudf::data_type(cudf::type_id::INT64),
+      starts.size(),
+      d_starts_buffer.data(),
+      nullptr,
+      0,
+      0);
+  auto d_sizes_column_view = cudf::column_view(
+      cudf::data_type(cudf::type_id::INT64),
+      sizes.size(),
+      d_sizes_buffer.data(),
+      nullptr,
+      0,
+      0);
+
+  auto list_sequence = cudf::lists::sequences(
+      d_starts_column_view, d_sizes_column_view, stream, mr);
+  // Discard offsets.
+  return std::move(list_sequence->release().children[1]);
+}
+
+void CudfAssignUniqueId::requestRowIds() {
+  rowIdCounter_ = rowIdPool_->fetch_add(kRowIdsPerRequest);
+  maxRowIdCounterValue_ =
+      std::min(rowIdCounter_ + kRowIdsPerRequest, kMaxRowId);
+}
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfAssignUniqueId.h b/velox/experimental/cudf/exec/CudfAssignUniqueId.h
new file mode 100644
index 00000000000..a210e84cb3e
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfAssignUniqueId.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/experimental/cudf/exec/CudfOperator.h"
+#include "velox/experimental/cudf/vector/CudfVector.h"
+
+#include "velox/exec/Operator.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::cudf_velox {
+
+class CudfAssignUniqueId : public CudfOperatorBase {
+ public:
+  CudfAssignUniqueId(
+      int32_t operatorId,
+      exec::DriverCtx* driverCtx,
+      const std::shared_ptr<const core::AssignUniqueIdNode>& planNode,
+      int32_t uniqueTaskId,
+      std::shared_ptr<std::atomic_int64_t> rowIdPool);
+
+  bool isFilter() const override {
+    return true;
+  }
+
+  bool preservesOrder() const override {
+    return true;
+  }
+
+  bool needsInput() const override {
+    return input_ == nullptr;
+  }
+
+  exec::BlockingReason isBlocked(ContinueFuture* /*future*/) override {
+    return exec::BlockingReason::kNotBlocked;
+  }
+
+  bool startDrain() override {
+    // No need to drain for assignUniqueId operator.
+    return false;
+  }
+
+  bool isFinished() override;
+
+ protected:
+  void doAddInput(RowVectorPtr input) override;
+  RowVectorPtr doGetOutput() override;
+
+ private:
+  std::unique_ptr<cudf::column> generateIdColumn(
+      vector_size_t size,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr);
+
+  void requestRowIds();
+
+  const int64_t kRowIdsPerRequest = 1L << 20;
+  const int64_t kMaxRowId = 1L << 40;
+  const int64_t kTaskUniqueIdLimit = 1L << 24;
+
+  int64_t uniqueValueMask_;
+  int64_t rowIdCounter_;
+  int64_t maxRowIdCounterValue_;
+
+  std::shared_ptr<std::atomic_int64_t> rowIdPool_;
+};
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfBatchConcat.cpp b/velox/experimental/cudf/exec/CudfBatchConcat.cpp
new file mode 100644
index 00000000000..0d22f51b163
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfBatchConcat.cpp
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/CudfNoDefaults.h"
+#include "velox/experimental/cudf/exec/CudfBatchConcat.h"
+#include "velox/experimental/cudf/exec/GpuResources.h"
+#include "velox/experimental/cudf/exec/Utilities.h"
+
+namespace facebook::velox::cudf_velox {
+
+CudfBatchConcat::CudfBatchConcat(
+    int32_t operatorId,
+    exec::DriverCtx* driverCtx,
+    std::shared_ptr<const core::PlanNode> planNode)
+    : CudfOperatorBase(
+          operatorId,
+          driverCtx,
+          planNode->outputType(),
+          planNode->id(),
+          "CudfBatchConcat",
+          nvtx3::rgb{211, 211, 211}, /* LightGrey */
+          NvtxMethodFlag::kAll,
+          std::nullopt,
+          planNode),
+      driverCtx_(driverCtx),
+      targetRows_(CudfConfig::getInstance().batchSizeMinThreshold) {}
+
+void CudfBatchConcat::doAddInput(RowVectorPtr input) {
+  auto cudfVector = std::dynamic_pointer_cast<CudfVector>(input);
+  VELOX_CHECK_NOT_NULL(cudfVector, "CudfBatchConcat expects CudfVector input");
+
+  // Push input cudf table to buffer
+  currentNumRows_ += cudfVector->getTableView().num_rows();
+  buffer_.push_back(std::move(cudfVector));
+}
+
+RowVectorPtr CudfBatchConcat::doGetOutput() {
+  // Drain the queue if there is any output to be flushed
+  if (!outputQueue_.empty()) {
+    auto table = std::move(outputQueue_.front());
+    auto rowCount = table->num_rows();
+    outputQueue_.pop();
+    return std::make_shared<CudfVector>(
+        pool(), outputType_, rowCount, std::move(table), outputQueueStream_);
+  }
+
+  // Merge tables if there are enough rows
+  if (!buffer_.empty() && (currentNumRows_ >= targetRows_ || noMoreInput_)) {
+    // Use stream from existing buffer vectors
+    outputQueueStream_ = buffer_[0]->stream();
+    auto tables = getConcatenatedTableBatched(
+        std::exchange(buffer_, {}),
+        outputType_,
+        outputQueueStream_,
+        get_output_mr());
+
+    currentNumRows_ = 0;
+
+    for (auto it = tables.begin(); it + 1 != tables.end(); ++it) {
+      outputQueue_.push(std::move(*it));
+    }
+
+    // If last table is a smaller batch and we still expect more input and keep
+    // it in buffer.
+    auto& last = tables.back();
+    auto rowCount = last->num_rows();
+
+    if (!noMoreInput_ && rowCount < targetRows_) {
+      currentNumRows_ = rowCount;
+      buffer_.push_back(
+          std::make_shared<CudfVector>(
+              pool(),
+              outputType_,
+              rowCount,
+              std::move(last),
+              outputQueueStream_));
+    } else {
+      outputQueue_.push(std::move(last));
+    }
+
+    // Return the first batch from the new queue
+    if (!outputQueue_.empty()) {
+      auto table = std::move(outputQueue_.front());
+      auto rowCount = table->num_rows();
+      outputQueue_.pop();
+      return std::make_shared<CudfVector>(
+          pool(), outputType_, rowCount, std::move(table), outputQueueStream_);
+    }
+  }
+
+  return nullptr;
+}
+
+bool CudfBatchConcat::isFinished() {
+  return noMoreInput_ && buffer_.empty() && outputQueue_.empty();
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfBatchConcat.h b/velox/experimental/cudf/exec/CudfBatchConcat.h
new file mode 100644
index 00000000000..9ddf6058b5e
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfBatchConcat.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/experimental/cudf/exec/CudfOperator.h"
+#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+#include "velox/experimental/cudf/vector/CudfVector.h"
+
+#include "velox/exec/Operator.h"
+
+#include <queue>
+
+namespace facebook::velox::cudf_velox {
+
+class CudfBatchConcat : public CudfOperatorBase {
+ public:
+  CudfBatchConcat(
+      int32_t operatorId,
+      exec::DriverCtx* driverCtx,
+      std::shared_ptr<const core::PlanNode> planNode);
+
+  bool needsInput() const override {
+    return !noMoreInput_ && outputQueue_.empty() &&
+        currentNumRows_ < targetRows_;
+  }
+
+  exec::BlockingReason isBlocked(ContinueFuture* /*future*/) override {
+    return exec::BlockingReason::kNotBlocked;
+  }
+
+  bool isFinished() override;
+
+ protected:
+  void doAddInput(RowVectorPtr input) override;
+  RowVectorPtr doGetOutput() override;
+
+ private:
+  exec::DriverCtx* const driverCtx_;
+  std::vector<CudfVectorPtr> buffer_;
+  std::queue<std::unique_ptr<cudf::table>> outputQueue_;
+  rmm::cuda_stream_view outputQueueStream_{rmm::cuda_stream_default};
+  size_t currentNumRows_{0};
+  const size_t targetRows_{0};
+};
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfConversion.cpp b/velox/experimental/cudf/exec/CudfConversion.cpp
index 09c8f4774fd..be83c791690 100644
--- a/velox/experimental/cudf/exec/CudfConversion.cpp
+++ b/velox/experimental/cudf/exec/CudfConversion.cpp
@@ -14,19 +14,20 @@
  * limitations under the License.
  */
 
+#include "velox/experimental/cudf/CudfNoDefaults.h"
 #include "velox/experimental/cudf/exec/CudfConversion.h"
+#include "velox/experimental/cudf/exec/GpuResources.h"
 #include "velox/experimental/cudf/exec/NvtxHelper.h"
-#include "velox/experimental/cudf/exec/ToCudf.h"
 #include "velox/experimental/cudf/exec/Utilities.h"
 #include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
 #include "velox/experimental/cudf/vector/CudfVector.h"
 
+#include "velox/core/QueryConfig.h"
 #include "velox/exec/Driver.h"
 #include "velox/exec/Operator.h"
 #include "velox/vector/ComplexVector.h"
 
-#include <cudf/copying.hpp>
-#include <cudf/table/table.hpp>
+#include <cudf/types.hpp>
 #include <cudf/utilities/default_stream.hpp>
 
 namespace facebook::velox::cudf_velox {
@@ -38,6 +39,9 @@ RowVectorPtr mergeRowVectors(
     const std::vector<RowVectorPtr>& results,
     velox::memory::MemoryPool* pool) {
   VELOX_NVTX_FUNC_RANGE();
+  if (results.size() == 1) {
+    return results[0];
+  }
   vector_size_t totalCount = 0;
   for (const auto& result : results) {
     totalCount += result->size();
@@ -71,19 +75,30 @@ CudfFromVelox::CudfFromVelox(
     RowTypePtr outputType,
     exec::DriverCtx* driverCtx,
     std::string planNodeId)
-    : exec::Operator(
+    : CudfOperatorBase(
+          operatorId,
           driverCtx,
           outputType,
-          operatorId,
           planNodeId,
-          "CudfFromVelox"),
-      NvtxHelper(
+          "CudfFromVelox",
           nvtx3::rgb{255, 140, 0}, // Orange
-          operatorId,
-          fmt::format("[{}]", planNodeId)) {}
+          NvtxMethodFlag::kAll,
+          std::nullopt,
+          std::nullopt),
+      timestampTimeZone_(driverCtx->queryConfig().get<std::string>(
+          facebook::velox::core::QueryConfig::kSessionTimezone)) {
+  auto parentId = planNodeId.substr(0, planNodeId.find("-from-velox"));
+  stats_.withWLock([&](auto& stats) {
+    stats.setStatSplitter(
+        [parentId = std::move(parentId)](const auto& combinedStats) {
+          auto result = combinedStats;
+          result.planNodeId = parentId;
+          return std::vector<exec::OperatorStats>{std::move(result)};
+        });
+  });
+}
 
-void CudfFromVelox::addInput(RowVectorPtr input) {
-  VELOX_NVTX_OPERATOR_FUNC_RANGE();
+void CudfFromVelox::doAddInput(RowVectorPtr input) {
   if (input->size() > 0) {
     // Materialize lazy vectors
     for (auto& child : input->children()) {
@@ -97,8 +112,7 @@ void CudfFromVelox::addInput(RowVectorPtr input) {
   }
 }
 
-RowVectorPtr CudfFromVelox::getOutput() {
-  VELOX_NVTX_OPERATOR_FUNC_RANGE();
+RowVectorPtr CudfFromVelox::doGetOutput() {
   const auto targetOutputSize =
       preferredGpuBatchSizeRows(operatorCtx_->driverCtx()->queryConfig());
 
@@ -139,22 +153,25 @@ RowVectorPtr CudfFromVelox::getOutput() {
   // Get a stream from the global stream pool
   auto stream = cudfGlobalStreamPool().get_stream();
 
-  // Convert RowVector to cudf table
-  auto tbl = with_arrow::toCudfTable(input, input->pool(), stream);
-
-  stream.synchronize();
+  // Convert RowVector to cudf table.  toCudfTable synchronizes the stream
+  // internally before releasing Arrow host buffers, so no additional sync
+  // is needed here.
+  auto tbl = with_arrow::toCudfTable(
+      input, input->pool(), stream, get_output_mr(), timestampTimeZone_);
 
   VELOX_CHECK_NOT_NULL(tbl);
 
   // Return a CudfVector that owns the cudf table
   const auto size = tbl->num_rows();
+
   return std::make_shared<CudfVector>(
       input->pool(), outputType_, size, std::move(tbl), stream);
 }
 
-void CudfFromVelox::close() {
-  cudf::get_default_stream().synchronize();
-  exec::Operator::close();
+void CudfFromVelox::doClose() {
+  // TODO(kn): Remove default stream after redesign of CudfFromVelox
+  cudf::get_default_stream(cudf::allow_default_stream).synchronize();
+  Operator::close();
   inputs_.clear();
 }
 
@@ -163,23 +180,33 @@ CudfToVelox::CudfToVelox(
     RowTypePtr outputType,
     exec::DriverCtx* driverCtx,
     std::string planNodeId)
-    : exec::Operator(
+    : CudfOperatorBase(
+          operatorId,
           driverCtx,
           outputType,
-          operatorId,
           planNodeId,
-          "CudfToVelox"),
-      NvtxHelper(
+          "CudfToVelox",
           nvtx3::rgb{148, 0, 211}, // Purple
-          operatorId,
-          fmt::format("[{}]", planNodeId)) {}
+          NvtxMethodFlag::kAll,
+          std::nullopt,
+          std::nullopt) {
+  auto parentId = planNodeId.substr(0, planNodeId.find("-to-velox"));
+  stats_.withWLock([&](auto& stats) {
+    stats.setStatSplitter(
+        [parentId = std::move(parentId)](const auto& combinedStats) {
+          auto result = combinedStats;
+          result.planNodeId = parentId;
+          return std::vector<exec::OperatorStats>{std::move(result)};
+        });
+  });
+}
 
 bool CudfToVelox::isPassthroughMode() const {
   return operatorCtx_->driverCtx()->queryConfig().get<bool>(
       kPassthroughMode, true);
 }
 
-void CudfToVelox::addInput(RowVectorPtr input) {
+void CudfToVelox::doAddInput(RowVectorPtr input) {
   // Accumulate inputs
   if (input->size() > 0) {
     auto cudfInput = std::dynamic_pointer_cast<CudfVector>(input);
@@ -196,113 +223,151 @@ std::optional<uint64_t> CudfToVelox::averageRowSize() {
   return averageRowSize_;
 }
 
-RowVectorPtr CudfToVelox::getOutput() {
-  VELOX_NVTX_OPERATOR_FUNC_RANGE();
-  if (finished_ || inputs_.empty()) {
-    finished_ = noMoreInput_ && inputs_.empty();
+// Pop inputs_.front(), convert its GPU table to a Velox RowVector via a
+// single to_arrow_host + synchronize, and return it.  The caller is
+// responsible for any further slicing.
+RowVectorPtr CudfToVelox::convertFrontToVelox() {
+  auto cudfVector = std::move(inputs_.front());
+  inputs_.pop_front();
+  auto stream = cudfVector->stream();
+  auto tableView = cudfVector->getTableView();
+  auto output = with_arrow::toVeloxColumn(
+      tableView, pool(), outputType_, "", stream, get_temp_mr());
+  stream.synchronize();
+  output->setType(outputType_);
+  return output;
+}
+
+// Output batching strategy
+// ========================
+// The key constraint is minimising D->H (device-to-host) transfers.
+// Each call to toVeloxColumn / to_arrow_host triggers one D->H copy per
+// column, so calling it once per output batch (rather than once per row
+// or once per input batch) is critical for performance.
+//
+// Two cases arise depending on the size of the front GPU input relative
+// to targetBatchSize:
+//
+//  (A) Front input >= targetBatchSize  (e.g. CudfOrderBy: one large sorted
+//      table).  We convert the whole input to Velox in one shot and then
+//      slice it purely on the CPU using BaseVector::slice().  Subsequent
+//      getOutput() calls return successive CPU slices with no additional
+//      D->H work until veloxBuffer_ is exhausted.
+//
+//  (B) Front input < targetBatchSize  (e.g. CudfFilterProject with high
+//      selectivity: many small GPU batches).  We concatenate inputs on device
+//      until we accumulate targetBatchSize rows, then convert the concat
+//      result to Velox in one shot.  This preserves the GPU-side merge
+//      that avoids emitting many undersized Velox batches downstream.
+//
+// In both cases exactly one toVeloxColumn + stream.synchronize() is issued
+// per output batch, regardless of how many GPU inputs were consumed.
+RowVectorPtr CudfToVelox::doGetOutput() {
+  if (finished_) {
     return nullptr;
   }
 
-  // Get the target batch size
-  const auto targetBatchSize = outputBatchRows(averageRowSize());
-  auto stream = inputs_.front()->stream();
-
-  // Process single input directly in these cases:
-  // 1. In passthrough mode
-  // 2. If we only have one input and it's smaller than or equal to the target
-  // batch size
-  if (isPassthroughMode() ||
-      (inputs_.size() == 1 && inputs_.front()->size() <= targetBatchSize)) {
-    std::unique_ptr<cudf::table> tbl = inputs_.front()->release();
-    inputs_.pop_front();
-
-    VELOX_CHECK_NOT_NULL(tbl);
-    if (tbl->num_rows() == 0) {
-      finished_ = noMoreInput_ && inputs_.empty();
-      return nullptr;
+  if (outputType_->size() == 0) {
+    // cuDF zero-column tables do not have a row count, so we sum the sizes
+    // of all CudfVectors in the inputs_, to maintain the logical count.
+    // This is necessary to ensure correct behavior for e.g. `count` operators.
+    vector_size_t totalSize = 0;
+    while (!inputs_.empty()) {
+      totalSize += inputs_.front()->size();
+      inputs_.pop_front();
     }
-    RowVectorPtr output =
-        with_arrow::toVeloxColumn(tbl->view(), pool(), "", stream);
-    stream.synchronize();
     finished_ = noMoreInput_ && inputs_.empty();
-    output->setType(outputType_);
-    return output;
+    if (totalSize == 0) {
+      return nullptr;
+    }
+    return BaseVector::create<RowVector>(outputType_, totalSize, pool());
   }
 
-  // Calculate how many tables we need to concatenate to reach the target batch
-  // size and collect them in a vector
-  std::vector<CudfVectorPtr> selectedInputs;
-  vector_size_t totalSize = 0;
+  // Drain veloxBuffer_ (populated on a previous call) before consuming
+  // more GPU inputs.
+  if (!veloxBuffer_) {
+    if (inputs_.empty()) {
+      finished_ = noMoreInput_;
+      return nullptr;
+    }
 
-  while (!inputs_.empty() && totalSize < targetBatchSize) {
-    auto& input = inputs_.front();
-    if (totalSize + input->size() <= targetBatchSize) {
-      totalSize += input->size();
-      selectedInputs.push_back(std::move(input));
-      inputs_.pop_front();
+    // Passthrough mode: emit each GPU input as a single Velox batch with no
+    // re-batching.  Used when the caller knows the batch size is already
+    // correct (e.g. default pipeline without explicit batch-size overrides).
+    if (isPassthroughMode()) {
+      auto output = convertFrontToVelox();
+      finished_ = noMoreInput_ && inputs_.empty();
+      if (output->size() == 0) {
+        return nullptr;
+      }
+      return output;
+    }
+
+    const auto targetBatchSize = outputBatchRows(averageRowSize());
+
+    if (static_cast<vector_size_t>(inputs_.front()->size()) >=
+        targetBatchSize) {
+      // Case A: large input.  Convert once; subsequent calls slice CPU-side.
+      veloxBuffer_ = convertFrontToVelox();
+      veloxOffset_ = 0;
+      averageRowSize_ = std::nullopt; // recompute from next input
     } else {
-      // If the next input would exceed targetBatchSize,
-      // we need to split it and only take what we need
-      auto cudfTableView = input->getTableView();
-      auto partitions = std::vector<cudf::size_type>{
-          static_cast<cudf::size_type>(targetBatchSize - totalSize)};
-      auto tableSplits = cudf::split(cudfTableView, partitions);
-
-      // Create new CudfVector from the first part
-      auto firstPart = std::make_unique<cudf::table>(tableSplits[0], stream);
-      auto firstPartSize = firstPart->num_rows();
-      auto firstPartVector = std::make_shared<CudfVector>(
-          pool(), input->type(), firstPartSize, std::move(firstPart), stream);
-
-      // Create new CudfVector from the second part
-      auto secondPart = std::make_unique<cudf::table>(tableSplits[1], stream);
-      auto secondPartSize = secondPart->num_rows();
-      auto secondPartVector = std::make_shared<CudfVector>(
-          pool(), input->type(), secondPartSize, std::move(secondPart), stream);
-
-      // Replace the original input with the second part
-      input = std::move(secondPartVector);
-
-      // Add the first part to selectedInputs
-      selectedInputs.push_back(std::move(firstPartVector));
-      totalSize += firstPartSize;
-      break;
+      // Case B: small inputs.  GPU-concat until we reach targetBatchSize,
+      // then convert the merged table in one D->H transfer.
+      auto stream = inputs_.front()->stream();
+      std::vector<CudfVectorPtr> toConcat;
+      vector_size_t accumulated = 0;
+      while (!inputs_.empty() && accumulated < targetBatchSize) {
+        accumulated += static_cast<vector_size_t>(inputs_.front()->size());
+        toConcat.push_back(std::move(inputs_.front()));
+        inputs_.pop_front();
+      }
+      VELOX_CHECK_LE(
+          accumulated,
+          std::numeric_limits<cudf::size_type>::max(),
+          "Accumulated row count exceeds cudf int32 limit");
+      auto concatTable = getConcatenatedTable(
+          std::move(toConcat), outputType_, stream, get_temp_mr());
+      auto tableView = concatTable->view();
+      veloxBuffer_ = with_arrow::toVeloxColumn(
+          tableView, pool(), outputType_, "", stream, get_temp_mr());
+      stream.synchronize();
+      veloxBuffer_->setType(outputType_);
+      veloxOffset_ = 0;
+      averageRowSize_ = std::nullopt;
     }
   }
 
-  finished_ = noMoreInput_ && inputs_.empty();
-
-  // If we have no inputs to process, return nullptr
-  if (selectedInputs.empty()) {
+  // Slice veloxBuffer_ on the CPU to produce the next output batch.
+  const auto totalRows = static_cast<vector_size_t>(veloxBuffer_->size());
+  if (veloxOffset_ >= totalRows) {
+    veloxBuffer_.reset();
+    finished_ = noMoreInput_ && inputs_.empty();
     return nullptr;
   }
 
-  // Concatenate the selected tables on the GPU
-  std::unique_ptr<cudf::table> resultTable;
-  if (selectedInputs.size() == 1) {
-    resultTable = selectedInputs[0]->release();
-  } else {
-    resultTable = getConcatenatedTable(selectedInputs, stream);
-  }
+  const auto targetBatchSize = outputBatchRows(
+      veloxBuffer_->estimateFlatSize() /
+      static_cast<uint64_t>(std::max<vector_size_t>(totalRows, 1)));
+  const auto take = std::min(targetBatchSize, totalRows - veloxOffset_);
 
-  // Convert the concatenated table to a RowVector
-  const auto size = resultTable->num_rows();
-  VELOX_CHECK_NOT_NULL(resultTable);
-  if (size == 0) {
-    return nullptr;
+  auto slice = std::dynamic_pointer_cast<RowVector>(
+      veloxBuffer_->slice(veloxOffset_, take));
+  VELOX_CHECK_NOT_NULL(slice);
+  veloxOffset_ += take;
+
+  if (veloxOffset_ >= totalRows) {
+    veloxBuffer_.reset();
+    finished_ = noMoreInput_ && inputs_.empty();
   }
 
-  RowVectorPtr output =
-      with_arrow::toVeloxColumn(resultTable->view(), pool(), "", stream);
-  stream.synchronize();
-  finished_ = noMoreInput_ && inputs_.empty();
-  output->setType(outputType_);
-  return output;
+  return slice;
 }
 
-void CudfToVelox::close() {
-  exec::Operator::close();
+void CudfToVelox::doClose() {
+  Operator::close();
   inputs_.clear();
+  veloxBuffer_.reset();
 }
 
 } // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfConversion.h b/velox/experimental/cudf/exec/CudfConversion.h
index 879f21d512b..3d6f1b7d7ab 100644
--- a/velox/experimental/cudf/exec/CudfConversion.h
+++ b/velox/experimental/cudf/exec/CudfConversion.h
@@ -16,7 +16,7 @@
 
 #pragma once
 
-#include "velox/experimental/cudf/exec/NvtxHelper.h"
+#include "velox/experimental/cudf/exec/CudfOperator.h"
 #include "velox/experimental/cudf/vector/CudfVector.h"
 
 #include "velox/exec/Driver.h"
@@ -29,7 +29,7 @@
 
 namespace facebook::velox::cudf_velox {
 
-class CudfFromVelox : public exec::Operator, public NvtxHelper {
+class CudfFromVelox : public CudfOperatorBase {
  public:
   static constexpr const char* kGpuBatchSizeRows =
       "velox.cudf.gpu_batch_size_rows";
@@ -44,10 +44,6 @@ class CudfFromVelox : public exec::Operator, public NvtxHelper {
     return !finished_;
   }
 
-  void addInput(RowVectorPtr input) override;
-
-  RowVectorPtr getOutput() override;
-
   exec::BlockingReason isBlocked(ContinueFuture* /*future*/) override {
     return exec::BlockingReason::kNotBlocked;
   }
@@ -56,15 +52,19 @@ class CudfFromVelox : public exec::Operator, public NvtxHelper {
     return finished_;
   }
 
-  void close() override;
+ protected:
+  void doAddInput(RowVectorPtr input) override;
+  RowVectorPtr doGetOutput() override;
+  void doClose() override;
 
  private:
+  const std::optional<std::string> timestampTimeZone_;
   std::vector<RowVectorPtr> inputs_;
   std::size_t currentOutputSize_ = 0;
   bool finished_ = false;
 };
 
-class CudfToVelox : public exec::Operator, public NvtxHelper {
+class CudfToVelox : public CudfOperatorBase {
  public:
   static constexpr const char* kPassthroughMode =
       "velox.cudf.to_velox.passthrough_mode";
@@ -79,10 +79,6 @@ class CudfToVelox : public exec::Operator, public NvtxHelper {
     return !finished_;
   }
 
-  void addInput(RowVectorPtr input) override;
-
-  RowVectorPtr getOutput() override;
-
   exec::BlockingReason isBlocked(ContinueFuture* /*future*/) override {
     return exec::BlockingReason::kNotBlocked;
   }
@@ -91,13 +87,22 @@ class CudfToVelox : public exec::Operator, public NvtxHelper {
     return finished_;
   }
 
-  void close() override;
+ protected:
+  void doAddInput(RowVectorPtr input) override;
+  RowVectorPtr doGetOutput() override;
+  void doClose() override;
 
  private:
   bool isPassthroughMode() const;
   std::optional<uint64_t> averageRowSize();
+  // Convert inputs_.front() to Velox once; slice it CPU-side per batch.
+  RowVectorPtr convertFrontToVelox();
   std::optional<uint64_t> averageRowSize_;
   std::deque<CudfVectorPtr> inputs_;
+  // Converted CPU-side buffer being drained by successive doGetOutput() calls.
+  RowVectorPtr veloxBuffer_;
+  // Current offset into veloxBuffer_ for the next slice.
+  vector_size_t veloxOffset_{0};
   bool finished_ = false;
 };
 
diff --git a/velox/experimental/cudf/exec/CudfDistinct.cpp b/velox/experimental/cudf/exec/CudfDistinct.cpp
new file mode 100644
index 00000000000..a4207efd98e
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfDistinct.cpp
@@ -0,0 +1,229 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/exec/CudfDistinct.h"
+#include "velox/experimental/cudf/exec/GpuResources.h"
+#include "velox/experimental/cudf/exec/Utilities.h"
+
+#include "velox/exec/Aggregate.h"
+#include "velox/exec/HashAggregation.h"
+
+#include <cudf/concatenate.hpp>
+#include <cudf/detail/utilities/stream_pool.hpp>
+#include <cudf/stream_compaction.hpp>
+
+namespace facebook::velox::cudf_velox {
+
+CudfDistinct::CudfDistinct(
+    int32_t operatorId,
+    exec::DriverCtx* driverCtx,
+    std::shared_ptr<core::AggregationNode const> const& aggregationNode)
+    : CudfOperatorBase(
+          operatorId,
+          driverCtx,
+          aggregationNode->outputType(),
+          aggregationNode->id(),
+          std::string{"CudfDistinct"} +
+              std::string{
+                  core::AggregationNode::toName(aggregationNode->step())},
+          nvtx3::rgb{34, 139, 34}, // Forest Green
+          NvtxMethodFlag::kAddInput | NvtxMethodFlag::kGetOutput,
+          std::nullopt,
+          aggregationNode),
+      aggregationNode_(aggregationNode),
+      isPartialOutput_(
+          exec::isPartialOutput(aggregationNode->step()) &&
+          !hasFinalAggs(aggregationNode->aggregates())),
+      maxPartialAggregationMemoryUsage_(
+          driverCtx->queryConfig().maxPartialAggregationMemoryUsage()) {}
+
+void CudfDistinct::initialize() {
+  Operator::initialize();
+
+  inputType_ = aggregationNode_->sources()[0]->outputType();
+  setupGroupingKeyChannelProjections(
+      *aggregationNode_, groupingKeyInputChannels_, groupingKeyOutputChannels_);
+
+  aggregationNode_.reset();
+}
+
+void CudfDistinct::computePartialDistinctStreaming(CudfVectorPtr tbl) {
+  // For every input, we'll concat with existing distinct results and then do a
+  // distinct on the concatenated results.
+
+  auto inputTableStream = tbl->stream();
+
+  if (bufferedResult_) {
+    // Concatenate the input table with the existing distinct results.
+    std::vector<cudf::table_view> tablesToConcat;
+    tablesToConcat.push_back(bufferedResult_->getTableView());
+    tablesToConcat.push_back(tbl->getTableView().select(
+        groupingKeyInputChannels_.begin(), groupingKeyInputChannels_.end()));
+
+    auto partialOutputStream = bufferedResult_->stream();
+    // We need to join the input table stream on the partial output stream to
+    // make sure the input table is available when we do the concat.
+    cudf::detail::join_streams(
+        std::vector<rmm::cuda_stream_view>{inputTableStream},
+        partialOutputStream);
+
+    auto concatenatedTable =
+        cudf::concatenate(tablesToConcat, partialOutputStream, get_output_mr());
+    cudf::detail::join_streams(
+        std::vector<rmm::cuda_stream_view>{partialOutputStream},
+        inputTableStream);
+
+    // Do a distinct on the concatenated results.
+    // Keep concatenatedTable alive while we use its view.
+    auto distinctOutput = getDistinctKeys(
+        concatenatedTable->view(),
+        groupingKeyOutputChannels_,
+        partialOutputStream);
+    bufferedResult_ = distinctOutput;
+  } else {
+    // First time processing, just store the result of the input batch's
+    // distinct. Use getTableView() to avoid expensive materialization for
+    // packed_table. tbl stays alive during this function call.
+    bufferedResult_ = getDistinctKeys(
+        tbl->getTableView(), groupingKeyInputChannels_, inputTableStream);
+  }
+}
+
+void CudfDistinct::doAddInput(RowVectorPtr input) {
+  if (input->size() == 0) {
+    return;
+  }
+  numInputRows_ += input->size();
+
+  auto cudfInput = std::dynamic_pointer_cast<cudf_velox::CudfVector>(input);
+  VELOX_CHECK_NOT_NULL(cudfInput);
+
+  if (isPartialOutput_) {
+    computePartialDistinctStreaming(cudfInput);
+    return;
+  }
+
+  inputs_.push_back(std::move(cudfInput));
+}
+
+CudfVectorPtr CudfDistinct::getDistinctKeys(
+    cudf::table_view tableView,
+    std::vector<column_index_t> const& groupByKeys,
+    rmm::cuda_stream_view stream) {
+  auto result = cudf::distinct(
+      tableView.select(groupByKeys.begin(), groupByKeys.end()),
+      {groupingKeyOutputChannels_.begin(), groupingKeyOutputChannels_.end()},
+      cudf::duplicate_keep_option::KEEP_FIRST,
+      cudf::null_equality::EQUAL,
+      cudf::nan_equality::ALL_EQUAL,
+      stream,
+      get_output_mr());
+
+  auto numRows = result->num_rows();
+
+  // velox expects nullptr instead of a table with 0 rows
+  if (numRows == 0) {
+    return nullptr;
+  }
+
+  return std::make_shared<cudf_velox::CudfVector>(
+      pool(), outputType_, numRows, std::move(result), stream);
+}
+
+CudfVectorPtr CudfDistinct::releaseAndResetBufferedResult() {
+  auto numOutputRows = bufferedResult_->size();
+  const double aggregationPct =
+      numOutputRows == 0 ? 0 : (numOutputRows * 1.0) / numInputRows_ * 100;
+  {
+    auto lockedStats = stats_.wlock();
+    lockedStats->addRuntimeStat(
+        std::string(exec::HashAggregation::kFlushRowCount),
+        RuntimeCounter(numOutputRows));
+    lockedStats->addRuntimeStat(
+        std::string(exec::HashAggregation::kFlushTimes), RuntimeCounter(1));
+    lockedStats->addRuntimeStat(
+        std::string(exec::HashAggregation::kPartialAggregationPct),
+        RuntimeCounter(aggregationPct));
+  }
+
+  numInputRows_ = 0;
+  // We're moving bufferedResult_ to the caller because we want it to be null
+  // after this call.
+  return std::move(bufferedResult_);
+}
+
+RowVectorPtr CudfDistinct::doGetOutput() {
+  if (isPartialOutput_) {
+    if (bufferedResult_ &&
+        bufferedResult_->estimateFlatSize() >
+            maxPartialAggregationMemoryUsage_) {
+      return releaseAndResetBufferedResult();
+    }
+    if (not noMoreInput_) {
+      // Don't produce output if the partial output hasn't reached memory limit
+      // and there's more batches to come.
+      return nullptr;
+    }
+    if (!bufferedResult_ && finished_) {
+      return nullptr;
+    }
+    return releaseAndResetBufferedResult();
+  }
+
+  if (finished_) {
+    return nullptr;
+  }
+
+  if (!noMoreInput_) {
+    // Final aggregation has to wait for all batches to arrive so we cannot
+    // return any results here.
+    return nullptr;
+  }
+
+  if (inputs_.empty() && !noMoreInput_) {
+    return nullptr;
+  }
+
+  auto stream = cudfGlobalStreamPool().get_stream();
+
+  auto tbl = getConcatenatedTable(
+      std::exchange(inputs_, {}), inputType_, stream, get_output_mr());
+
+  // Release input data after synchronizing.
+  stream.synchronize();
+  inputs_.clear();
+
+  if (noMoreInput_) {
+    finished_ = true;
+  }
+
+  VELOX_CHECK_NOT_NULL(tbl);
+
+  return getDistinctKeys(tbl->view(), groupingKeyInputChannels_, stream);
+}
+
+void CudfDistinct::doNoMoreInput() {
+  Operator::noMoreInput();
+  if (isPartialOutput_ && inputs_.empty()) {
+    finished_ = true;
+  }
+}
+
+bool CudfDistinct::isFinished() {
+  return finished_;
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfDistinct.h b/velox/experimental/cudf/exec/CudfDistinct.h
new file mode 100644
index 00000000000..2c7ab92660b
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfDistinct.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/experimental/cudf/exec/CudfAggregation.h"
+#include "velox/experimental/cudf/exec/CudfOperator.h"
+
+namespace facebook::velox::cudf_velox {
+
+class CudfDistinct : public CudfOperatorBase {
+ public:
+  CudfDistinct(
+      int32_t operatorId,
+      exec::DriverCtx* driverCtx,
+      std::shared_ptr<const core::AggregationNode> const& aggregationNode);
+
+  void initialize() override;
+
+  bool needsInput() const override {
+    return !noMoreInput_;
+  }
+
+  exec::BlockingReason isBlocked(ContinueFuture* /* unused */) override {
+    return exec::BlockingReason::kNotBlocked;
+  }
+
+  bool isFinished() override;
+
+ protected:
+  void doAddInput(RowVectorPtr input) override;
+
+  RowVectorPtr doGetOutput() override;
+
+  void doNoMoreInput() override;
+
+ private:
+  CudfVectorPtr getDistinctKeys(
+      cudf::table_view tableView,
+      std::vector<column_index_t> const& groupByKeys,
+      rmm::cuda_stream_view stream);
+
+  CudfVectorPtr releaseAndResetBufferedResult();
+
+  void computePartialDistinctStreaming(CudfVectorPtr tbl);
+
+  std::vector<column_index_t> groupingKeyInputChannels_;
+  std::vector<column_index_t> groupingKeyOutputChannels_;
+
+  std::shared_ptr<const core::AggregationNode> aggregationNode_;
+
+  const bool isPartialOutput_;
+  const int64_t maxPartialAggregationMemoryUsage_;
+  int64_t numInputRows_ = 0;
+
+  bool finished_ = false;
+
+  std::vector<CudfVectorPtr> inputs_;
+  TypePtr inputType_;
+  CudfVectorPtr bufferedResult_;
+};
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfEnforceSingleRow.cpp b/velox/experimental/cudf/exec/CudfEnforceSingleRow.cpp
new file mode 100644
index 00000000000..e373b27d7bc
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfEnforceSingleRow.cpp
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/CudfNoDefaults.h"
+#include "velox/experimental/cudf/exec/CudfEnforceSingleRow.h"
+#include "velox/experimental/cudf/exec/GpuResources.h"
+#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+
+#include <cudf/table/table.hpp>
+
+namespace facebook::velox::cudf_velox {
+
+CudfEnforceSingleRow::CudfEnforceSingleRow(
+    int32_t operatorId,
+    exec::DriverCtx* driverCtx,
+    const std::shared_ptr<const core::EnforceSingleRowNode>& planNode)
+    : CudfOperatorBase(
+          operatorId,
+          driverCtx,
+          planNode->outputType(),
+          planNode->id(),
+          "CudfEnforceSingleRow",
+          nvtx3::rgb{255, 127, 80}, // Coral
+          NvtxMethodFlag::kAll,
+          std::nullopt,
+          planNode) {}
+
+bool CudfEnforceSingleRow::needsInput() const {
+  return true;
+}
+
+void CudfEnforceSingleRow::doAddInput(RowVectorPtr input) {
+  // Cast to CudfVector to access GPU data
+  auto cudfInput = std::dynamic_pointer_cast<CudfVector>(input);
+  VELOX_CHECK_NOT_NULL(
+      cudfInput, "CudfEnforceSingleRow expects CudfVector input");
+
+  auto numInput = cudfInput->size();
+
+  VELOX_CHECK_NE(
+      numInput, 0, "CudfEnforceSingleRow::addInput received empty set of rows");
+
+  if (input_ == nullptr) {
+    VELOX_USER_CHECK_EQ(
+        numInput,
+        1,
+        "Expected single row of input. Received {} rows.",
+        numInput);
+    input_ = std::move(cudfInput);
+  } else {
+    VELOX_USER_FAIL(
+        "Expected single row of input. Received {} extra rows.", numInput);
+  }
+}
+
+void CudfEnforceSingleRow::doNoMoreInput() {
+  if (!noMoreInput_ && input_ == nullptr) {
+    // We have not seen any data. Return a single row of all nulls.
+    auto nullRow = BaseVector::create<RowVector>(outputType_, 1, pool());
+    for (auto& child : nullRow->children()) {
+      child->resize(1);
+      child->setNull(0, true);
+    }
+
+    // Convert to CudfVector
+    auto stream = cudf::get_default_stream(cudf::allow_default_stream);
+    auto cudfTable =
+        with_arrow::toCudfTable(nullRow, pool(), stream, get_output_mr());
+    stream.synchronize();
+    input_ = std::make_shared<CudfVector>(
+        pool(), outputType_, 1, std::move(cudfTable), stream);
+  }
+
+  Operator::noMoreInput();
+}
+
+RowVectorPtr CudfEnforceSingleRow::doGetOutput() {
+  if (!noMoreInput_) {
+    return nullptr;
+  }
+
+  return std::exchange(input_, nullptr);
+}
+
+bool CudfEnforceSingleRow::isFinished() {
+  return noMoreInput_ && input_ == nullptr;
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfEnforceSingleRow.h b/velox/experimental/cudf/exec/CudfEnforceSingleRow.h
new file mode 100644
index 00000000000..273e3e2cfeb
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfEnforceSingleRow.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/experimental/cudf/exec/CudfOperator.h"
+#include "velox/experimental/cudf/vector/CudfVector.h"
+
+#include "velox/core/PlanNode.h"
+#include "velox/exec/Operator.h"
+
+namespace facebook::velox::cudf_velox {
+
+/**
+ * @brief GPU operator that validates input contains at most one row.
+ *
+ * This operator is used for scalar subqueries that must return exactly 0 or 1
+ * row. If the input contains more than one row, it throws a user error. If the
+ * input is empty, it returns a single row of nulls.
+ *
+ * This is a pass-through operator that performs validation on GPU metadata
+ * (row count) without transferring data between host and device.
+ */
+class CudfEnforceSingleRow : public CudfOperatorBase {
+ public:
+  CudfEnforceSingleRow(
+      int32_t operatorId,
+      exec::DriverCtx* driverCtx,
+      const std::shared_ptr<const core::EnforceSingleRowNode>& planNode);
+
+  bool isFilter() const override {
+    return true;
+  }
+
+  bool preservesOrder() const override {
+    return true;
+  }
+
+  bool needsInput() const override;
+
+  bool isFinished() override;
+
+  exec::BlockingReason isBlocked(ContinueFuture* /*future*/) override {
+    return exec::BlockingReason::kNotBlocked;
+  }
+
+ protected:
+  void doAddInput(RowVectorPtr input) override;
+  RowVectorPtr doGetOutput() override;
+  void doNoMoreInput() override;
+};
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfFilterProject.cpp b/velox/experimental/cudf/exec/CudfFilterProject.cpp
index 0aca5c55c4b..838abf3bff2 100644
--- a/velox/experimental/cudf/exec/CudfFilterProject.cpp
+++ b/velox/experimental/cudf/exec/CudfFilterProject.cpp
@@ -14,18 +14,23 @@
  * limitations under the License.
  */
 
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/CudfNoDefaults.h"
 #include "velox/experimental/cudf/exec/CudfFilterProject.h"
-#include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/exec/GpuResources.h"
 #include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
 #include "velox/experimental/cudf/vector/CudfVector.h"
 
+#include "velox/common/memory/Memory.h"
 #include "velox/expression/Expr.h"
+#include "velox/expression/FieldReference.h"
 
 #include <cudf/aggregation.hpp>
 #include <cudf/reduction.hpp>
 #include <cudf/stream_compaction.hpp>
 #include <cudf/unary.hpp>
 
+#include <iostream>
 #include <unordered_map>
 
 namespace facebook::velox::cudf_velox {
@@ -34,64 +39,200 @@ namespace {
 
 void debugPrintTree(
     const std::shared_ptr<velox::exec::Expr>& expr,
-    int indent = 0) {
-  std::cout << std::string(indent, ' ') << expr->name() << std::endl;
+    int indent = 0,
+    std::ostream& os = std::cout) {
+  if (indent == 0)
+    os << "=== Expression Tree ===" << std::endl;
+  os << std::string(indent, ' ') << expr->name() << "("
+     << expr->type()->toString() << ")" << std::endl;
   for (auto& input : expr->inputs()) {
-    debugPrintTree(input, indent + 2);
+    debugPrintTree(input, indent + 2, os);
   }
 }
+
+bool checkAddIdentityProjection(
+    const core::TypedExprPtr& projection,
+    const RowTypePtr& inputType,
+    column_index_t outputChannel,
+    std::vector<exec::IdentityProjection>& identityProjections) {
+  if (auto field = core::TypedExprs::asFieldAccess(projection)) {
+    const auto& inputs = field->inputs();
+    if (inputs.empty() ||
+        (inputs.size() == 1 &&
+         dynamic_cast<const core::InputTypedExpr*>(inputs[0].get()))) {
+      const auto inputChannel = inputType->getChildIdx(field->name());
+      identityProjections.emplace_back(inputChannel, outputChannel);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+// Split stats to attrbitute cardinality reduction to the Filter node.
+std::vector<exec::OperatorStats> splitStats(
+    const exec::OperatorStats& combinedStats,
+    const core::PlanNodeId& filterNodeId) {
+  exec::OperatorStats filterStats;
+
+  filterStats.operatorId = combinedStats.operatorId;
+  filterStats.pipelineId = combinedStats.pipelineId;
+  filterStats.planNodeId = filterNodeId;
+  filterStats.operatorType = combinedStats.operatorType;
+  filterStats.numDrivers = combinedStats.numDrivers;
+
+  filterStats.inputBytes = combinedStats.inputBytes;
+  filterStats.inputPositions = combinedStats.inputPositions;
+  filterStats.inputVectors = combinedStats.inputVectors;
+
+  // Estimate Filter's output bytes based on cardinality change.
+  const double filterRate = combinedStats.inputPositions > 0
+      ? (combinedStats.outputPositions * 1.0 / combinedStats.inputPositions)
+      : 1.0;
+
+  filterStats.outputBytes = (uint64_t)(filterStats.inputBytes * filterRate);
+  filterStats.outputPositions = combinedStats.outputPositions;
+  filterStats.outputVectors = combinedStats.outputVectors;
+
+  auto projectStats = combinedStats;
+  projectStats.inputBytes = filterStats.outputBytes;
+  projectStats.inputPositions = filterStats.outputPositions;
+  projectStats.inputVectors = filterStats.outputVectors;
+
+  return {std::move(projectStats), std::move(filterStats)};
+}
+
 } // namespace
 
+bool canBeEvaluatedByCudf(
+    const std::vector<core::TypedExprPtr>& exprs,
+    core::QueryCtx* queryCtx) {
+  if (exprs.empty()) {
+    return true;
+  }
+
+  auto precompilePool =
+      memory::memoryManager()->addLeafPool("", /*threadSafe*/ false);
+  core::ExecCtx precompileCtx(precompilePool.get(), queryCtx);
+
+  bool lazyDereference = false;
+  std::vector<core::TypedExprPtr> exprsCopy = exprs;
+  std::unique_ptr<exec::ExprSet> exprSet = exec::makeExprSetFromFlag(
+      std::move(exprsCopy), &precompileCtx, lazyDereference);
+
+  for (const auto& e : exprSet->exprs()) {
+    if (!canBeEvaluatedByCudf(e)) {
+      return false;
+    }
+  }
+  return true;
+}
+
 CudfFilterProject::CudfFilterProject(
     int32_t operatorId,
     velox::exec::DriverCtx* driverCtx,
-    const velox::exec::FilterProject::Export& info,
-    std::vector<velox::exec::IdentityProjection> identityProjections,
     const std::shared_ptr<const core::FilterNode>& filter,
     const std::shared_ptr<const core::ProjectNode>& project)
-    : Operator(
+    : CudfOperatorBase(
+          operatorId,
           driverCtx,
           project ? project->outputType() : filter->outputType(),
-          operatorId,
           project ? project->id() : filter->id(),
-          "CudfFilterProject"),
-      NvtxHelper(
+          "CudfFilterProject",
           nvtx3::rgb{220, 20, 60}, // Crimson
-          operatorId,
-          fmt::format("[{}]", project ? project->id() : filter->id())),
-      hasFilter_(info.hasFilter),
+          NvtxMethodFlag::kAll,
+          std::nullopt,
+          project ? std::static_pointer_cast<const core::PlanNode>(project)
+                  : std::static_pointer_cast<const core::PlanNode>(filter)),
+      hasFilter_(filter != nullptr),
       project_(project),
       filter_(filter) {
-  resultProjections_ = *(info.resultProjections);
-  identityProjections_ = std::move(identityProjections);
+  if (filter_ != nullptr && project_ != nullptr) {
+    folly::Synchronized<exec::OperatorStats>& opStats = Operator::stats();
+    opStats.withWLock([&](auto& stats) {
+      stats.setStatSplitter(
+          [filterId = filter_->id()](const auto& combinedStats) {
+            return splitStats(combinedStats, filterId);
+          });
+    });
+  }
+}
+
+void CudfFilterProject::initialize() {
+  Operator::initialize();
+
+  std::vector<core::TypedExprPtr> allExprs;
+  if (hasFilter_) {
+    VELOX_CHECK_NOT_NULL(filter_);
+    allExprs.push_back(filter_->filter());
+  }
+
+  if (project_) {
+    const auto& inputType = project_->sources()[0]->outputType();
+
+    for (column_index_t i = 0; i < project_->projections().size(); i++) {
+      auto& projection = project_->projections()[i];
+      bool identityProjection = checkAddIdentityProjection(
+          projection, inputType, i, identityProjections_);
+      if (!identityProjection) {
+        allExprs.push_back(projection);
+        resultProjections_.emplace_back(allExprs.size() - 1, i);
+      }
+    }
+  } else {
+    for (column_index_t i = 0; i < outputType_->size(); ++i) {
+      identityProjections_.emplace_back(i, i);
+    }
+    isIdentityProjection_ = true;
+  }
+
+  auto lazyDereference =
+      (dynamic_cast<const core::LazyDereferenceNode*>(project_.get()) !=
+       nullptr);
+  VELOX_CHECK(!(lazyDereference && filter_));
+  auto expr = exec::makeExprSetFromFlag(
+      std::move(allExprs), operatorCtx_->execCtx(), lazyDereference);
+
   const auto inputType = project_ ? project_->sources()[0]->outputType()
                                   : filter_->sources()[0]->outputType();
 
   // convert to AST
-  if (cudfDebugEnabled()) {
+  if (CudfConfig::getInstance().debugEnabled) {
     int i = 0;
-    for (auto expr : info.exprs->exprs()) {
-      std::cout << "expr[" << i++ << "] " << expr->toString() << std::endl;
-      debugPrintTree(expr);
+    for (const auto& expr : expr->exprs()) {
+      LOG(INFO) << "expr[" << i++ << "] " << expr->toString();
+      debugPrintTree(expr, 0, LOG(INFO));
     }
   }
-  std::vector<std::shared_ptr<velox::exec::Expr>> projectExprs;
   if (hasFilter_) {
     // First expr is Filter, rest are Project
-    filterEvaluator_ = ExpressionEvaluator({info.exprs->exprs()[0]}, inputType);
-    projectExprs = {info.exprs->exprs().begin() + 1, info.exprs->exprs().end()};
+    filterEvaluator_ = createCudfExpression(expr->exprs()[0], inputType);
+    std::transform(
+        expr->exprs().begin() + 1,
+        expr->exprs().end(),
+        std::back_inserter(projectEvaluators_),
+        [inputType](const auto& expr) {
+          return createCudfExpression(expr, inputType);
+        });
+  } else {
+    std::transform(
+        expr->exprs().begin(),
+        expr->exprs().end(),
+        std::back_inserter(projectEvaluators_),
+        [inputType](const auto& expr) {
+          return createCudfExpression(expr, inputType);
+        });
   }
-  projectEvaluator_ = ExpressionEvaluator(
-      hasFilter_ ? projectExprs : info.exprs->exprs(), inputType);
+
+  filter_.reset();
+  project_.reset();
 }
 
-void CudfFilterProject::addInput(RowVectorPtr input) {
+void CudfFilterProject::doAddInput(RowVectorPtr input) {
   input_ = std::move(input);
 }
 
-RowVectorPtr CudfFilterProject::getOutput() {
-  VELOX_NVTX_OPERATOR_FUNC_RANGE();
-
+RowVectorPtr CudfFilterProject::doGetOutput() {
   if (allInputProcessed()) {
     return nullptr;
   }
@@ -104,27 +245,30 @@ RowVectorPtr CudfFilterProject::getOutput() {
   VELOX_CHECK_NOT_NULL(cudfInput);
   auto stream = cudfInput->stream();
   auto inputTableColumns = cudfInput->release()->release();
+  auto outputSize = input_->size();
 
   if (hasFilter_) {
     filter(inputTableColumns, stream);
   }
+  if (!inputTableColumns.empty()) {
+    outputSize = inputTableColumns.front()->size();
+  }
   auto outputColumns = project(inputTableColumns, stream);
 
   auto outputTable = std::make_unique<cudf::table>(std::move(outputColumns));
-  stream.synchronize();
   auto const numColumns = outputTable->num_columns();
-  auto const size = outputTable->num_rows();
-  if (cudfDebugEnabled()) {
-    std::cout << "cudfProject Output: " << size << " rows, " << numColumns
-              << " columns " << std::endl;
+  auto const size = numColumns > 0 ? outputTable->num_rows() : outputSize;
+  if (CudfConfig::getInstance().debugEnabled) {
+    VLOG(1) << "cudfProject Output: " << size << " rows, " << numColumns
+            << " columns";
+  }
+  if (size == 0) {
+    input_.reset();
+    return nullptr;
   }
-
   auto cudfOutput = std::make_shared<CudfVector>(
       input_->pool(), outputType_, size, std::move(outputTable), stream);
   input_.reset();
-  if (numColumns == 0 or size == 0) {
-    return nullptr;
-  }
   return cudfOutput;
 }
 
@@ -132,20 +276,25 @@ void CudfFilterProject::filter(
     std::vector<std::unique_ptr<cudf::column>>& inputTableColumns,
     rmm::cuda_stream_view stream) {
   // Evaluate the Filter
-  auto filterColumns = filterEvaluator_.compute(
-      inputTableColumns, stream, cudf::get_current_device_resource_ref());
-  auto filterColumn = filterColumns[0]->view();
+  std::vector<cudf::column_view> inputViews;
+  inputViews.reserve(inputTableColumns.size());
+  for (auto& col : inputTableColumns) {
+    inputViews.push_back(col->view());
+  }
+  auto filterColumn =
+      filterEvaluator_->eval(inputViews, stream, get_temp_mr(), true);
+  auto filterColumnView = asView(filterColumn);
   bool shouldApplyFilter = [&]() {
-    if (filterColumn.has_nulls()) {
+    if (filterColumnView.has_nulls()) {
       return true;
     }
-    // check if all values in filterColumn are true
+    // check if all values in filterColumnView are true
     auto isAllTrue = cudf::reduce(
-        filterColumn,
+        filterColumnView,
         *cudf::make_all_aggregation<cudf::reduce_aggregation>(),
         cudf::data_type(cudf::type_id::BOOL8),
         stream,
-        cudf::get_current_device_resource_ref());
+        get_temp_mr());
     using ScalarType = cudf::scalar_type_t<bool>;
     auto result = static_cast<ScalarType*>(isAllTrue.get());
     // If filter is not all true, apply the filter
@@ -154,8 +303,8 @@ void CudfFilterProject::filter(
   if (shouldApplyFilter) {
     auto filterTable =
         std::make_unique<cudf::table>(std::move(inputTableColumns));
-    auto filteredTable =
-        cudf::apply_boolean_mask(*filterTable, filterColumn, stream);
+    auto filteredTable = cudf::apply_boolean_mask(
+        *filterTable, filterColumnView, stream, get_output_mr());
     inputTableColumns = filteredTable->release();
   }
 }
@@ -163,15 +312,32 @@ void CudfFilterProject::filter(
 std::vector<std::unique_ptr<cudf::column>> CudfFilterProject::project(
     std::vector<std::unique_ptr<cudf::column>>& inputTableColumns,
     rmm::cuda_stream_view stream) {
-  auto columns = projectEvaluator_.compute(
-      inputTableColumns, stream, cudf::get_current_device_resource_ref());
+  std::vector<cudf::column_view> inputViews;
+  inputViews.reserve(inputTableColumns.size());
+  for (auto& col : inputTableColumns) {
+    inputViews.push_back(col->view());
+  }
+  std::vector<ColumnOrView> columns;
+  for (auto& projectEvaluator : projectEvaluators_) {
+    columns.push_back(
+        projectEvaluator->eval(inputViews, stream, get_output_mr(), true));
+  }
 
   // Rearrange columns to match outputType_
   std::vector<std::unique_ptr<cudf::column>> outputColumns(outputType_->size());
   // computed resultProjections
   for (int i = 0; i < resultProjections_.size(); i++) {
-    VELOX_CHECK_NOT_NULL(columns[i]);
-    outputColumns[resultProjections_[i].outputChannel] = std::move(columns[i]);
+    auto& columnOrView = columns[i];
+    if (std::holds_alternative<std::unique_ptr<cudf::column>>(columnOrView)) {
+      // Move the owned column
+      outputColumns[resultProjections_[i].outputChannel] =
+          std::move(std::get<std::unique_ptr<cudf::column>>(columnOrView));
+    } else {
+      // Materialize the column_view into an owned column
+      auto view = std::get<cudf::column_view>(columnOrView);
+      outputColumns[resultProjections_[i].outputChannel] =
+          std::make_unique<cudf::column>(view, stream, get_output_mr());
+    }
   }
 
   // Count occurrences of each inputChannel, and move columns if they occur only
@@ -191,24 +357,12 @@ std::vector<std::unique_ptr<cudf::column>> CudfFilterProject::project(
     } else {
       // Otherwise, copy the column and decrement the count
       outputColumns[identity.outputChannel] = std::make_unique<cudf::column>(
-          *inputTableColumns[identity.inputChannel],
-          stream,
-          cudf::get_current_device_resource_ref());
+          *inputTableColumns[identity.inputChannel], stream, get_output_mr());
     }
     VELOX_CHECK_GT(inputChannelCount[identity.inputChannel], 0);
     inputChannelCount[identity.inputChannel]--;
   }
 
-  for (auto i = 0; i < outputColumns.size(); ++i) {
-    const auto cudfOutputType =
-        cudf::data_type(cudf_velox::veloxToCudfTypeId(outputType_->childAt(i)));
-
-    if (outputColumns[i]->type() != cudfOutputType) {
-      outputColumns[i] =
-          cudf::cast(*(outputColumns[i]), cudfOutputType, stream);
-    }
-  }
-
   return outputColumns;
 }
 
diff --git a/velox/experimental/cudf/exec/CudfFilterProject.h b/velox/experimental/cudf/exec/CudfFilterProject.h
index 23853ddb47e..cecb9cedb3a 100644
--- a/velox/experimental/cudf/exec/CudfFilterProject.h
+++ b/velox/experimental/cudf/exec/CudfFilterProject.h
@@ -16,8 +16,8 @@
 
 #pragma once
 
-#include "velox/experimental/cudf/exec/ExpressionEvaluator.h"
-#include "velox/experimental/cudf/exec/NvtxHelper.h"
+#include "velox/experimental/cudf/exec/CudfOperator.h"
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
 
 #include "velox/core/Expressions.h"
 #include "velox/core/PlanNode.h"
@@ -28,24 +28,20 @@
 namespace facebook::velox::cudf_velox {
 
 // TODO: Does not support Filter yet.
-class CudfFilterProject : public exec::Operator, public NvtxHelper {
+class CudfFilterProject : public CudfOperatorBase {
  public:
   CudfFilterProject(
       int32_t operatorId,
       velox::exec::DriverCtx* driverCtx,
-      const velox::exec::FilterProject::Export& info,
-      std::vector<velox::exec::IdentityProjection> identityProjections,
       const std::shared_ptr<const core::FilterNode>& filter,
       const std::shared_ptr<const core::ProjectNode>& project);
 
+  void initialize() override;
+
   bool needsInput() const override {
     return !input_;
   }
 
-  void addInput(RowVectorPtr input) override;
-
-  RowVectorPtr getOutput() override;
-
   void filter(
       std::vector<std::unique_ptr<cudf::column>>& inputTableColumns,
       rmm::cuda_stream_view stream);
@@ -60,25 +56,36 @@ class CudfFilterProject : public exec::Operator, public NvtxHelper {
 
   bool isFinished() override;
 
-  void close() override {
+ protected:
+  void doAddInput(RowVectorPtr input) override;
+  RowVectorPtr doGetOutput() override;
+
+  void doClose() override {
     Operator::close();
-    projectEvaluator_.close();
-    filterEvaluator_.close();
+    projectEvaluators_.clear();
+    filterEvaluator_.reset();
   }
 
  private:
   bool allInputProcessed();
+
   // If true exprs_[0] is a filter and the other expressions are projections
   const bool hasFilter_{false};
+
   // Cached filter and project node for lazy initialization. After
   // initialization, they will be reset, and initialized_ will be set to true.
   std::shared_ptr<const core::ProjectNode> project_;
   std::shared_ptr<const core::FilterNode> filter_;
-  ExpressionEvaluator projectEvaluator_;
-  ExpressionEvaluator filterEvaluator_;
+
+  std::vector<CudfExpressionPtr> projectEvaluators_;
+  CudfExpressionPtr filterEvaluator_;
 
   std::vector<velox::exec::IdentityProjection> resultProjections_;
   std::vector<velox::exec::IdentityProjection> identityProjections_;
 };
 
+bool canBeEvaluatedByCudf(
+    const std::vector<core::TypedExprPtr>& exprs,
+    core::QueryCtx* queryCtx);
+
 } // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfGroupId.cpp b/velox/experimental/cudf/exec/CudfGroupId.cpp
new file mode 100644
index 00000000000..9bc14bf82c6
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfGroupId.cpp
@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/CudfNoDefaults.h"
+#include "velox/experimental/cudf/exec/CudfGroupId.h"
+#include "velox/experimental/cudf/exec/GpuResources.h"
+#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+#include "velox/experimental/cudf/vector/CudfVector.h"
+
+#include <cudf/column/column_factories.hpp>
+#include <cudf/scalar/scalar.hpp>
+#include <cudf/scalar/scalar_factories.hpp>
+#include <cudf/table/table.hpp>
+
+namespace facebook::velox::cudf_velox {
+
+CudfGroupId::CudfGroupId(
+    int32_t operatorId,
+    exec::DriverCtx* driverCtx,
+    const std::shared_ptr<const core::GroupIdNode>& groupIdNode)
+    : CudfOperatorBase(
+          operatorId,
+          driverCtx,
+          groupIdNode->outputType(),
+          groupIdNode->id(),
+          "CudfGroupId",
+          nvtx3::rgb{128, 0, 128}, // Purple
+          NvtxMethodFlag::kAddInput | NvtxMethodFlag::kGetOutput,
+          std::nullopt,
+          groupIdNode) {
+  const auto& inputType = groupIdNode->sources()[0]->outputType();
+
+  // Build output-to-input mapping for grouping keys
+  std::unordered_map<column_index_t, column_index_t>
+      outputToInputGroupingKeyMapping;
+  for (const auto& groupingKeyInfo : groupIdNode->groupingKeyInfos()) {
+    outputToInputGroupingKeyMapping[outputType_->getChildIdx(
+        groupingKeyInfo.output)] =
+        inputType->getChildIdx(groupingKeyInfo.input->name());
+  }
+
+  numGroupingKeys_ = groupIdNode->numGroupingKeys();
+  numGroupingSets_ = groupIdNode->groupingSets().size();
+
+  // Build groupingKeyMappings_ - one vector per grouping set
+  groupingKeyMappings_.reserve(numGroupingSets_);
+  for (const auto& groupingSet : groupIdNode->groupingSets()) {
+    std::vector<column_index_t> mappings(numGroupingKeys_, kMissingGroupingKey);
+    for (const auto& groupingKey : groupingSet) {
+      auto outputChannel = outputType_->getChildIdx(groupingKey);
+      VELOX_USER_CHECK_NE(
+          outputToInputGroupingKeyMapping.count(outputChannel),
+          0,
+          "GroupIdNode didn't map grouping key {} to input channel",
+          groupingKey);
+      VELOX_CHECK_LT(
+          outputChannel,
+          outputToInputGroupingKeyMapping.size(),
+          "outputChannel out of bounds in outputToInputGroupingKeyMapping");
+      auto inputChannel = outputToInputGroupingKeyMapping.at(outputChannel);
+      VELOX_CHECK_LT(
+          outputChannel,
+          mappings.size(),
+          "outputChannel out of bounds in mappings");
+      mappings[outputChannel] = inputChannel;
+    }
+    groupingKeyMappings_.emplace_back(std::move(mappings));
+  }
+
+  // Build aggregationInputs_ - indices of aggregation input columns
+  const auto& aggregationInputs = groupIdNode->aggregationInputs();
+  aggregationInputs_.reserve(aggregationInputs.size());
+  for (const auto& input : aggregationInputs) {
+    aggregationInputs_.push_back(inputType->getChildIdx(input->name()));
+  }
+
+  // Precompute cudf data types for grouping key columns (used to create
+  // all-null columns for keys not in a grouping set).
+  groupingKeyCudfTypes_.reserve(numGroupingKeys_);
+  for (size_t i = 0; i < numGroupingKeys_; ++i) {
+    groupingKeyCudfTypes_.push_back(
+        veloxToCudfDataType(outputType_->childAt(i)));
+  }
+}
+
+bool CudfGroupId::needsInput() const {
+  return !noMoreInput_ && inputColumns_.empty();
+}
+
+void CudfGroupId::doAddInput(RowVectorPtr input) {
+  VELOX_CHECK(inputColumns_.empty(), "Previous input not fully consumed");
+
+  auto cudfInput = std::dynamic_pointer_cast<CudfVector>(input);
+  VELOX_CHECK_NOT_NULL(cudfInput, "CudfGroupId expects CudfVector input");
+
+  inputStream_ = cudfInput->stream();
+  inputSize_ = static_cast<cudf::size_type>(cudfInput->size());
+
+  // Store input columns for cycling through grouping sets
+  auto table = cudfInput->release();
+  inputColumns_ = table->release();
+  groupingSetIndex_ = 0;
+}
+
+RowVectorPtr CudfGroupId::doGetOutput() {
+  if (inputColumns_.empty()) {
+    return nullptr;
+  }
+
+  auto stream = inputStream_;
+  auto outputMr = get_output_mr();
+  auto tempMr = get_temp_mr();
+  auto numRows = inputSize_;
+
+  VELOX_CHECK_LT(
+      groupingSetIndex_,
+      groupingKeyMappings_.size(),
+      "groupingSetIndex_ out of bounds");
+  const auto& mapping = groupingKeyMappings_[groupingSetIndex_];
+  std::vector<std::unique_ptr<cudf::column>> outputColumns(outputType_->size());
+
+  // Only move columns on the last grouping set; otherwise copy since
+  // inputColumns_ is reused across multiple getOutput() calls.
+  const bool isLastGroupingSet = (groupingSetIndex_ == numGroupingSets_ - 1);
+
+  // Count occurrences of each input column in the last grouping set.
+  // Move columns that occur only once, copy and decrement otherwise.
+  std::unordered_map<column_index_t, int> inputColumnUsage;
+  if (isLastGroupingSet) {
+    for (size_t i = 0; i < numGroupingKeys_; ++i) {
+      if (mapping[i] != kMissingGroupingKey) {
+        ++inputColumnUsage[mapping[i]];
+      }
+    }
+    for (auto inputIdx : aggregationInputs_) {
+      ++inputColumnUsage[inputIdx];
+    }
+  }
+
+  // Fill in grouping keys
+  for (size_t i = 0; i < numGroupingKeys_; ++i) {
+    if (mapping[i] == kMissingGroupingKey) {
+      // Create an all-null column for keys not in this grouping set
+      auto nullScalar = cudf::make_default_constructed_scalar(
+          groupingKeyCudfTypes_[i], stream, tempMr);
+      outputColumns[i] =
+          cudf::make_column_from_scalar(*nullScalar, numRows, stream, outputMr);
+    } else {
+      auto inputIdx = mapping[i];
+      if (isLastGroupingSet && inputColumnUsage[inputIdx] == 1) {
+        outputColumns[i] = std::move(inputColumns_[inputIdx]);
+      } else {
+        outputColumns[i] = std::make_unique<cudf::column>(
+            *inputColumns_[inputIdx], stream, outputMr);
+      }
+      if (isLastGroupingSet) {
+        VELOX_CHECK_GT(inputColumnUsage[inputIdx], 0);
+        --inputColumnUsage[inputIdx];
+      }
+    }
+  }
+
+  // Fill in aggregation inputs
+  for (size_t i = 0; i < aggregationInputs_.size(); ++i) {
+    auto inputIdx = aggregationInputs_[i];
+    auto outputIdx = numGroupingKeys_ + i;
+    VELOX_CHECK_LT(
+        inputIdx,
+        inputColumns_.size(),
+        "inputIdx out of bounds in aggregation inputs");
+    VELOX_CHECK_LT(
+        outputIdx,
+        outputColumns.size(),
+        "outputIdx out of bounds in aggregation inputs");
+    if (isLastGroupingSet && inputColumnUsage[inputIdx] == 1) {
+      outputColumns[outputIdx] = std::move(inputColumns_[inputIdx]);
+    } else {
+      outputColumns[outputIdx] = std::make_unique<cudf::column>(
+          *inputColumns_[inputIdx], stream, outputMr);
+    }
+    if (isLastGroupingSet) {
+      VELOX_CHECK_GT(inputColumnUsage[inputIdx], 0);
+      --inputColumnUsage[inputIdx];
+    }
+  }
+
+  // Add group_id column (constant BIGINT with current grouping set index)
+  auto groupIdScalar = cudf::numeric_scalar<int64_t>(
+      static_cast<int64_t>(groupingSetIndex_), true, stream, tempMr);
+  outputColumns[outputType_->size() - 1] =
+      cudf::make_column_from_scalar(groupIdScalar, numRows, stream, outputMr);
+
+  // Build output table
+  auto outputTable = std::make_unique<cudf::table>(std::move(outputColumns));
+
+  // Advance to next grouping set
+  ++groupingSetIndex_;
+  if (groupingSetIndex_ == numGroupingSets_) {
+    // All grouping sets processed for this input
+    inputColumns_.clear();
+    groupingSetIndex_ = 0;
+  }
+
+  return std::make_shared<CudfVector>(
+      pool(), outputType_, numRows, std::move(outputTable), stream);
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfGroupId.h b/velox/experimental/cudf/exec/CudfGroupId.h
new file mode 100644
index 00000000000..bb81b4207fe
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfGroupId.h
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/experimental/cudf/exec/CudfOperator.h"
+
+#include "velox/exec/Operator.h"
+
+#include <cudf/types.hpp>
+
+namespace facebook::velox::cudf_velox {
+
+/// GPU implementation of the GroupId operator for GROUPING SETS, CUBE, and
+/// ROLLUP operations. Takes a single input batch and produces N output batches
+/// (one per grouping set).
+class CudfGroupId : public CudfOperatorBase {
+ public:
+  CudfGroupId(
+      int32_t operatorId,
+      exec::DriverCtx* driverCtx,
+      const std::shared_ptr<const core::GroupIdNode>& groupIdNode);
+
+  bool needsInput() const override;
+
+  exec::BlockingReason isBlocked(ContinueFuture* /*future*/) override {
+    return exec::BlockingReason::kNotBlocked;
+  }
+
+  bool isFinished() override {
+    return noMoreInput_ && inputColumns_.empty();
+  }
+
+ protected:
+  void doAddInput(RowVectorPtr input) override;
+  RowVectorPtr doGetOutput() override;
+
+ private:
+  static constexpr column_index_t kMissingGroupingKey =
+      std::numeric_limits<column_index_t>::max();
+
+  /// A grouping set contains a subset of all the grouping keys. This list
+  /// contains one entry per grouping set and identifies the grouping keys that
+  /// are part of the set as indices of the input columns. The position in the
+  /// list identifies the grouping key column in the output. Positions with
+  /// kMissingGroupingKey correspond to grouping keys which are not included in
+  /// the set.
+  std::vector<std::vector<column_index_t>> groupingKeyMappings_;
+
+  /// A list of input column indices corresponding to aggregation inputs.
+  std::vector<column_index_t> aggregationInputs_;
+
+  /// Precomputed cudf data types for each grouping key output column, used to
+  /// create all-null columns for keys not in a grouping set.
+  std::vector<cudf::data_type> groupingKeyCudfTypes_;
+
+  /// Stored input columns for cycling through grouping sets.
+  std::vector<std::unique_ptr<cudf::column>> inputColumns_;
+
+  /// Size of the current input batch.
+  cudf::size_type inputSize_{0};
+
+  /// Stream associated with the input data.
+  rmm::cuda_stream_view inputStream_;
+
+  /// Index of the grouping set to output in the next getOutput call.
+  size_t groupingSetIndex_{0};
+
+  /// Total number of grouping sets.
+  size_t numGroupingSets_{0};
+
+  /// Number of grouping key columns in output (first N output columns).
+  size_t numGroupingKeys_{0};
+};
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfGroupby.cpp b/velox/experimental/cudf/exec/CudfGroupby.cpp
new file mode 100644
index 00000000000..a6ebeb33571
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfGroupby.cpp
@@ -0,0 +1,1000 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/CudfNoDefaults.h"
+#include "velox/experimental/cudf/exec/CudfFilterProject.h"
+#include "velox/experimental/cudf/exec/CudfGroupby.h"
+#include "velox/experimental/cudf/exec/GpuResources.h"
+#include "velox/experimental/cudf/exec/Utilities.h"
+#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+
+#include "velox/exec/Aggregate.h"
+#include "velox/exec/AggregateFunctionRegistry.h"
+#include "velox/exec/HashAggregation.h"
+#include "velox/exec/Task.h"
+#include "velox/expression/Expr.h"
+
+#include <cudf/binaryop.hpp>
+#include <cudf/column/column_factories.hpp>
+#include <cudf/concatenate.hpp>
+#include <cudf/copying.hpp>
+#include <cudf/detail/utilities/stream_pool.hpp>
+#include <cudf/unary.hpp>
+
+namespace {
+
+using namespace facebook::velox;
+using cudf_velox::CountInputKind;
+using cudf_velox::get_output_mr;
+using cudf_velox::get_temp_mr;
+using cudf_velox::GroupbyAggregator;
+using cudf_velox::ResolvedAggregateInfo;
+
+#define DEFINE_SIMPLE_GROUPBY_AGGREGATOR(Name, name, KIND)                    \
+  struct Groupby##Name##Aggregator : GroupbyAggregator {                      \
+    Groupby##Name##Aggregator(                                                \
+        core::AggregationNode::Step step,                                     \
+        uint32_t inputIndex,                                                  \
+        VectorPtr constant,                                                   \
+        const TypePtr& resultType)                                            \
+        : GroupbyAggregator(step, inputIndex, constant, resultType) {}        \
+                                                                              \
+    void addGroupbyRequest(                                                   \
+        cudf::table_view const& tbl,                                          \
+        std::vector<cudf::groupby::aggregation_request>& requests) override { \
+      VELOX_CHECK(                                                            \
+          constant == nullptr,                                                \
+          #Name "Aggregator does not yet support constant input");            \
+      auto& request = requests.emplace_back();                                \
+      output_idx = requests.size() - 1;                                       \
+      request.values = tbl.column(inputIndex);                                \
+      request.aggregations.push_back(                                         \
+          cudf::make_##name##_aggregation<cudf::groupby_aggregation>());      \
+    }                                                                         \
+                                                                              \
+    std::unique_ptr<cudf::column> makeOutputColumn(                           \
+        std::vector<cudf::groupby::aggregation_result>& results,              \
+        rmm::cuda_stream_view stream) override {                              \
+      auto col = std::move(results[output_idx].results[0]);                   \
+      const auto cudfType =                                                   \
+          cudf::data_type(cudf_velox::veloxToCudfTypeId(resultType));         \
+      if (col->type() != cudfType) {                                          \
+        col = cudf::cast(*col, cudfType, stream, get_output_mr());            \
+      }                                                                       \
+      return col;                                                             \
+    }                                                                         \
+                                                                              \
+   private:                                                                   \
+    uint32_t output_idx;                                                      \
+  };
+
+DEFINE_SIMPLE_GROUPBY_AGGREGATOR(Sum, sum, SUM)
+DEFINE_SIMPLE_GROUPBY_AGGREGATOR(Min, min, MIN)
+DEFINE_SIMPLE_GROUPBY_AGGREGATOR(Max, max, MAX)
+
+struct GroupbyCountAggregator : GroupbyAggregator {
+  GroupbyCountAggregator(
+      core::AggregationNode::Step step,
+      uint32_t inputIndex,
+      CountInputKind inputKind,
+      const TypePtr& resultType)
+      : GroupbyAggregator(step, inputIndex, nullptr, resultType),
+        inputKind_(inputKind) {}
+
+  void addGroupbyRequest(
+      cudf::table_view const& tbl,
+      std::vector<cudf::groupby::aggregation_request>& requests) override {
+    auto& request = requests.emplace_back();
+    outputIndex_ = requests.size() - 1;
+    // kCountAll and kNullConstant both submit a count-all-rows request;
+    // kNullConstant overrides the result with zeros in makeOutputColumn.
+    const bool countAll = (inputKind_ != CountInputKind::kColumn);
+    // For raw input, count(*) can use any column (column 0) since we just
+    // need a row count. For non-raw input (intermediate/final in streaming),
+    // the input is partial results where column 0 is the grouping key;
+    // we must use inputIndex to access the partial count column.
+    request.values =
+        tbl.column((countAll && exec::isRawInput(step)) ? 0 : inputIndex);
+    std::unique_ptr<cudf::groupby_aggregation> aggRequest =
+        exec::isRawInput(step)
+        ? cudf::make_count_aggregation<cudf::groupby_aggregation>(
+              countAll ? cudf::null_policy::INCLUDE
+                       : cudf::null_policy::EXCLUDE)
+        : cudf::make_sum_aggregation<cudf::groupby_aggregation>();
+    request.aggregations.push_back(std::move(aggRequest));
+  }
+
+  std::unique_ptr<cudf::column> makeOutputColumn(
+      std::vector<cudf::groupby::aggregation_result>& results,
+      rmm::cuda_stream_view stream) override {
+    auto col = std::move(results[outputIndex_].results[0]);
+    if (inputKind_ == CountInputKind::kNullConstant) {
+      auto zero = cudf::numeric_scalar<int64_t>(0, true, stream, get_temp_mr());
+      col = cudf::make_column_from_scalar(
+          zero, col->size(), stream, get_output_mr());
+    }
+    // cudf produces int32 for count but velox expects int64.
+    const auto cudfOutputType =
+        cudf::data_type(cudf_velox::veloxToCudfTypeId(resultType));
+    if (col->type() != cudfOutputType) {
+      col = cudf::cast(*col, cudfOutputType, stream, get_output_mr());
+    }
+    return col;
+  }
+
+ private:
+  CountInputKind inputKind_;
+  uint32_t outputIndex_;
+};
+
+struct GroupbyMeanAggregator : GroupbyAggregator {
+  GroupbyMeanAggregator(
+      core::AggregationNode::Step step,
+      uint32_t inputIndex,
+      VectorPtr constant,
+      const TypePtr& resultType)
+      : GroupbyAggregator(step, inputIndex, constant, resultType) {}
+
+  void addGroupbyRequest(
+      cudf::table_view const& tbl,
+      std::vector<cudf::groupby::aggregation_request>& requests) override {
+    switch (step) {
+      case core::AggregationNode::Step::kSingle: {
+        auto& request = requests.emplace_back();
+        meanIdx_ = requests.size() - 1;
+        request.values = tbl.column(inputIndex);
+        request.aggregations.push_back(
+            cudf::make_mean_aggregation<cudf::groupby_aggregation>());
+        break;
+      }
+      case core::AggregationNode::Step::kPartial: {
+        auto& request = requests.emplace_back();
+        sumIdx_ = requests.size() - 1;
+        request.values = tbl.column(inputIndex);
+        request.aggregations.push_back(
+            cudf::make_sum_aggregation<cudf::groupby_aggregation>());
+        request.aggregations.push_back(
+            cudf::make_count_aggregation<cudf::groupby_aggregation>(
+                cudf::null_policy::EXCLUDE));
+        break;
+      }
+      case core::AggregationNode::Step::kIntermediate:
+      case core::AggregationNode::Step::kFinal: {
+        // In intermediate and final aggregation, the previously computed sum
+        // and count are in the child columns of the input column.
+        auto& request = requests.emplace_back();
+        sumIdx_ = requests.size() - 1;
+        request.values = tbl.column(inputIndex).child(0);
+        request.aggregations.push_back(
+            cudf::make_sum_aggregation<cudf::groupby_aggregation>());
+
+        auto& request2 = requests.emplace_back();
+        countIdx_ = requests.size() - 1;
+        request2.values = tbl.column(inputIndex).child(1);
+        // The counts are already computed in partial aggregation, so we just
+        // need to sum them up again.
+        request2.aggregations.push_back(
+            cudf::make_sum_aggregation<cudf::groupby_aggregation>());
+        break;
+      }
+      default:
+        VELOX_NYI("Unsupported aggregation step for mean");
+    }
+  }
+
+  std::unique_ptr<cudf::column> makeOutputColumn(
+      std::vector<cudf::groupby::aggregation_result>& results,
+      rmm::cuda_stream_view stream) override {
+    const auto& outputType = asRowType(resultType);
+    switch (step) {
+      case core::AggregationNode::Step::kSingle:
+        return std::move(results[meanIdx_].results[0]);
+      case core::AggregationNode::Step::kPartial: {
+        auto sum = std::move(results[sumIdx_].results[0]);
+        auto count = std::move(results[sumIdx_].results[1]);
+
+        auto const size = sum->size();
+        auto const cudfSumType = cudf::data_type(
+            cudf_velox::veloxToCudfTypeId(outputType->childAt(0)));
+        auto const cudfCountType = cudf::data_type(
+            cudf_velox::veloxToCudfTypeId(outputType->childAt(1)));
+        if (sum->type() != cudf::data_type(cudfSumType)) {
+          sum = cudf::cast(
+              *sum, cudf::data_type(cudfSumType), stream, get_output_mr());
+        }
+        if (count->type() != cudf::data_type(cudfCountType)) {
+          count = cudf::cast(
+              *count, cudf::data_type(cudfCountType), stream, get_output_mr());
+        }
+
+        auto children = std::vector<std::unique_ptr<cudf::column>>();
+        children.push_back(std::move(sum));
+        children.push_back(std::move(count));
+
+        // TODO: Handle nulls. This can happen if all values are null in a
+        // group.
+        return std::make_unique<cudf::column>(
+            cudf::data_type(cudf::type_id::STRUCT),
+            size,
+            rmm::device_buffer{},
+            rmm::device_buffer{},
+            0,
+            std::move(children));
+      }
+      case core::AggregationNode::Step::kIntermediate: {
+        // The difference between intermediate and partial is in where the
+        // sum and count are coming from. In partial, since the input column is
+        // the same, the sum and count are in the same agg result. In
+        // intermediate, the input columns are different (it's the child
+        // columns of the input column) and so the sum and count are in
+        // different agg results.
+        auto sum = std::move(results[sumIdx_].results[0]);
+        auto count = std::move(results[countIdx_].results[0]);
+
+        auto size = sum->size();
+        auto const cudfSumType = cudf::data_type(
+            cudf_velox::veloxToCudfTypeId(outputType->childAt(0)));
+        auto const cudfCountType = cudf::data_type(
+            cudf_velox::veloxToCudfTypeId(outputType->childAt(1)));
+        if (sum->type() != cudf::data_type(cudfSumType)) {
+          sum = cudf::cast(
+              *sum, cudf::data_type(cudfSumType), stream, get_output_mr());
+        }
+        if (count->type() != cudf::data_type(cudfCountType)) {
+          count = cudf::cast(
+              *count, cudf::data_type(cudfCountType), stream, get_output_mr());
+        }
+
+        auto children = std::vector<std::unique_ptr<cudf::column>>();
+        children.push_back(std::move(sum));
+        children.push_back(std::move(count));
+
+        return std::make_unique<cudf::column>(
+            cudf::data_type(cudf::type_id::STRUCT),
+            size,
+            rmm::device_buffer{},
+            rmm::device_buffer{},
+            0,
+            std::move(children));
+      }
+      case core::AggregationNode::Step::kFinal: {
+        auto sum = std::move(results[sumIdx_].results[0]);
+        auto count = std::move(results[countIdx_].results[0]);
+        auto avg = cudf::binary_operation(
+            *sum,
+            *count,
+            cudf::binary_operator::DIV,
+            cudf::data_type(cudf_velox::veloxToCudfTypeId(resultType)),
+            stream,
+            get_output_mr());
+        return avg;
+      }
+      default:
+        VELOX_NYI("Unsupported aggregation step for mean");
+    }
+  }
+
+ private:
+  // These indices are used to track where the desired result columns
+  // (mean/<sum, count>) are in the output of cudf::groupby::aggregate().
+  uint32_t meanIdx_;
+  uint32_t sumIdx_;
+  uint32_t countIdx_;
+};
+
+struct GroupbyStddevSampAggregator : GroupbyAggregator {
+  GroupbyStddevSampAggregator(
+      core::AggregationNode::Step step,
+      uint32_t inputIndex,
+      VectorPtr constant,
+      const TypePtr& resultType)
+      : GroupbyAggregator(step, inputIndex, constant, resultType) {}
+
+  void addGroupbyRequest(
+      cudf::table_view const& tbl,
+      std::vector<cudf::groupby::aggregation_request>& requests) override {
+    auto& request = requests.emplace_back();
+    outputIdx_ = requests.size() - 1;
+    request.values = tbl.column(inputIndex);
+
+    switch (step) {
+      case core::AggregationNode::Step::kSingle:
+        // Use cuDF's built-in std aggregation with ddof=1 (sample stddev)
+        request.aggregations.push_back(
+            cudf::make_std_aggregation<cudf::groupby_aggregation>(1));
+        break;
+      case core::AggregationNode::Step::kPartial:
+        // Compute count, mean, m2 from raw values
+        request.aggregations.push_back(
+            cudf::make_count_aggregation<cudf::groupby_aggregation>(
+                cudf::null_policy::EXCLUDE));
+        request.aggregations.push_back(
+            cudf::make_mean_aggregation<cudf::groupby_aggregation>());
+        request.aggregations.push_back(
+            cudf::make_m2_aggregation<cudf::groupby_aggregation>());
+        break;
+      case core::AggregationNode::Step::kIntermediate:
+      case core::AggregationNode::Step::kFinal:
+        // Input is struct(count, mean, m2) - use MERGE_M2 to merge
+        request.aggregations.push_back(
+            cudf::make_merge_m2_aggregation<cudf::groupby_aggregation>());
+        break;
+      default:
+        VELOX_NYI("Unsupported aggregation step for stddev_samp");
+    }
+  }
+
+  std::unique_ptr<cudf::column> makeOutputColumn(
+      std::vector<cudf::groupby::aggregation_result>& results,
+      rmm::cuda_stream_view stream) override {
+    switch (step) {
+      case core::AggregationNode::Step::kSingle:
+        return std::move(results[outputIdx_].results[0]);
+      case core::AggregationNode::Step::kPartial: {
+        auto count = std::move(results[outputIdx_].results[0]);
+        auto mean = std::move(results[outputIdx_].results[1]);
+        auto m2 = std::move(results[outputIdx_].results[2]);
+        return makeM2StructColumn(
+            std::move(count), std::move(mean), std::move(m2), stream);
+      }
+      case core::AggregationNode::Step::kIntermediate: {
+        auto merged = std::move(results[outputIdx_].results[0]);
+
+        // Check if types already match expected output - avoid copies if so
+        const auto& outputType = asRowType(resultType);
+        auto const cudfCountType = cudf::data_type(
+            cudf_velox::veloxToCudfTypeId(outputType->childAt(0)));
+        auto const cudfMeanType = cudf::data_type(
+            cudf_velox::veloxToCudfTypeId(outputType->childAt(1)));
+        auto const cudfM2Type = cudf::data_type(
+            cudf_velox::veloxToCudfTypeId(outputType->childAt(2)));
+
+        auto mergedView = merged->view();
+        bool typesMatch = mergedView.child(0).type() == cudfCountType &&
+            mergedView.child(1).type() == cudfMeanType &&
+            mergedView.child(2).type() == cudfM2Type;
+
+        if (typesMatch) {
+          // Types match - return merged directly to avoid device copies
+          return merged;
+        }
+
+        // Types don't match - need to copy and cast (use output_mr since
+        // these become part of the output)
+        auto count = std::make_unique<cudf::column>(
+            mergedView.child(0), stream, get_output_mr());
+        auto mean = std::make_unique<cudf::column>(
+            mergedView.child(1), stream, get_output_mr());
+        auto m2 = std::make_unique<cudf::column>(
+            mergedView.child(2), stream, get_output_mr());
+        return makeM2StructColumn(
+            std::move(count), std::move(mean), std::move(m2), stream);
+      }
+      case core::AggregationNode::Step::kFinal: {
+        // MERGE_M2 returns struct(count, mean, m2)
+        // Compute sqrt(m2 / (count - 1)) with NULL where count < 2
+        auto merged = std::move(results[outputIdx_].results[0]);
+        auto mergedView = merged->view();
+        auto countView = mergedView.child(0);
+        auto m2View = mergedView.child(2);
+
+        // count - 1 (binary_operation handles type promotion)
+        cudf::numeric_scalar<double> one(1.0, true, stream, get_temp_mr());
+        auto countMinus1 = cudf::binary_operation(
+            countView,
+            one,
+            cudf::binary_operator::SUB,
+            cudf::data_type{cudf::type_id::FLOAT64},
+            stream,
+            get_temp_mr());
+
+        // m2 / (count - 1)
+        auto variance = cudf::binary_operation(
+            m2View,
+            *countMinus1,
+            cudf::binary_operator::DIV,
+            cudf::data_type{cudf::type_id::FLOAT64},
+            stream,
+            get_temp_mr());
+
+        // sqrt(variance)
+        auto stddev = cudf::unary_operation(
+            *variance, cudf::unary_operator::SQRT, stream, get_temp_mr());
+
+        // count >= 2
+        cudf::numeric_scalar<int64_t> two(2, true, stream, get_temp_mr());
+        auto validMask = cudf::binary_operation(
+            countView,
+            two,
+            cudf::binary_operator::GREATER_EQUAL,
+            cudf::data_type{cudf::type_id::BOOL8},
+            stream,
+            get_temp_mr());
+
+        // Apply mask: where count < 2, result is NULL
+        cudf::numeric_scalar<double> nullDouble(
+            0.0, false, stream, get_temp_mr());
+        return cudf::copy_if_else(
+            *stddev, nullDouble, *validMask, stream, get_output_mr());
+      }
+      default:
+        VELOX_NYI("Unsupported aggregation step for stddev_samp");
+    }
+  }
+
+ private:
+  // Build a struct column with (count, mean, m2), casting to expected types.
+  std::unique_ptr<cudf::column> makeM2StructColumn(
+      std::unique_ptr<cudf::column> count,
+      std::unique_ptr<cudf::column> mean,
+      std::unique_ptr<cudf::column> m2,
+      rmm::cuda_stream_view stream) {
+    const auto& outputType = asRowType(resultType);
+    auto const cudfCountType =
+        cudf::data_type(cudf_velox::veloxToCudfTypeId(outputType->childAt(0)));
+    auto const cudfMeanType =
+        cudf::data_type(cudf_velox::veloxToCudfTypeId(outputType->childAt(1)));
+    auto const cudfM2Type =
+        cudf::data_type(cudf_velox::veloxToCudfTypeId(outputType->childAt(2)));
+
+    if (count->type() != cudfCountType) {
+      count = cudf::cast(*count, cudfCountType, stream, get_output_mr());
+    }
+    if (mean->type() != cudfMeanType) {
+      mean = cudf::cast(*mean, cudfMeanType, stream, get_output_mr());
+    }
+    if (m2->type() != cudfM2Type) {
+      m2 = cudf::cast(*m2, cudfM2Type, stream, get_output_mr());
+    }
+
+    auto const size = count->size();
+    std::vector<std::unique_ptr<cudf::column>> children;
+    children.push_back(std::move(count));
+    children.push_back(std::move(mean));
+    children.push_back(std::move(m2));
+
+    return std::make_unique<cudf::column>(
+        cudf::data_type(cudf::type_id::STRUCT),
+        size,
+        rmm::device_buffer{},
+        rmm::device_buffer{},
+        0,
+        std::move(children));
+  }
+
+  uint32_t outputIdx_;
+};
+
+std::unique_ptr<GroupbyAggregator> createGroupbyAggregator(
+    const ResolvedAggregateInfo& p) {
+  auto const& kind = p.kind;
+  auto prefix = cudf_velox::CudfConfig::getInstance().functionNamePrefix;
+  if (kind.rfind(prefix + "sum", 0) == 0) {
+    return std::make_unique<GroupbySumAggregator>(
+        p.companionStep, p.inputIndex, p.constant, p.resultType);
+  } else if (kind.rfind(prefix + "count", 0) == 0) {
+    VELOX_CHECK(p.countInputKind.has_value());
+    return std::make_unique<GroupbyCountAggregator>(
+        p.companionStep, p.inputIndex, *p.countInputKind, p.resultType);
+  } else if (kind.rfind(prefix + "min", 0) == 0) {
+    return std::make_unique<GroupbyMinAggregator>(
+        p.companionStep, p.inputIndex, p.constant, p.resultType);
+  } else if (kind.rfind(prefix + "max", 0) == 0) {
+    return std::make_unique<GroupbyMaxAggregator>(
+        p.companionStep, p.inputIndex, p.constant, p.resultType);
+  } else if (kind.rfind(prefix + "avg", 0) == 0) {
+    return std::make_unique<GroupbyMeanAggregator>(
+        p.companionStep, p.inputIndex, p.constant, p.resultType);
+  } else if (kind.rfind(prefix + "stddev_samp", 0) == 0) {
+    return std::make_unique<GroupbyStddevSampAggregator>(
+        p.companionStep, p.inputIndex, p.constant, p.resultType);
+  } else if (kind.rfind(prefix + "stddev", 0) == 0) {
+    // stddev is an alias for stddev_samp
+    return std::make_unique<GroupbyStddevSampAggregator>(
+        p.companionStep, p.inputIndex, p.constant, p.resultType);
+  } else {
+    VELOX_NYI("Aggregation not yet supported, kind: {}", kind);
+  }
+}
+
+} // namespace
+
+namespace facebook::velox::cudf_velox {
+
+std::vector<std::unique_ptr<GroupbyAggregator>> toGroupbyAggregators(
+    core::AggregationNode const& aggregationNode,
+    core::AggregationNode::Step step,
+    TypePtr const& outputType,
+    std::vector<VectorPtr> const& constants) {
+  auto params =
+      resolveAggregateInfos(aggregationNode, step, outputType, constants);
+
+  std::vector<std::unique_ptr<GroupbyAggregator>> aggregators;
+  aggregators.reserve(params.size());
+  for (const auto& p : params) {
+    aggregators.push_back(createGroupbyAggregator(p));
+  }
+  return aggregators;
+}
+
+bool canGroupbyAggregationBeEvaluatedByCudf(
+    const core::CallTypedExpr& call,
+    core::AggregationNode::Step step,
+    const std::vector<TypePtr>& rawInputTypes,
+    core::QueryCtx* queryCtx) {
+  return canAggregationBeEvaluatedByRegistry(
+      getGroupbyAggregationRegistry(), call, step, rawInputTypes, queryCtx);
+}
+
+bool canGroupbyBeEvaluatedByCudf(
+    const core::AggregationNode& aggregationNode,
+    core::QueryCtx* queryCtx) {
+  const core::PlanNode* sourceNode = aggregationNode.sources().empty()
+      ? nullptr
+      : aggregationNode.sources()[0].get();
+
+  // Get the aggregation step from the node
+  auto step = aggregationNode.step();
+
+  // Check supported aggregation functions using step-aware aggregation registry
+  for (const auto& aggregate : aggregationNode.aggregates()) {
+    // Use step-aware validation that handles partial/final/intermediate steps
+    if (!canGroupbyAggregationBeEvaluatedByCudf(
+            *aggregate.call, step, aggregate.rawInputTypes, queryCtx)) {
+      return false;
+    }
+
+    // `distinct` aggregations are not supported, in testing fails with "De-dup
+    // before aggregation is not yet supported"
+    if (aggregate.distinct) {
+      return false;
+    }
+
+    // `mask` is NOT supported (in testing do not appear to be be applied and
+    // return incorrect results )
+    if (aggregate.mask) {
+      return false;
+    }
+
+    if (isCountFunctionName(aggregate.call->name())) {
+      continue;
+    }
+
+    // Check input expressions can be evaluated by cuDF, expand the input first.
+    for (const auto& input : aggregate.call->inputs()) {
+      auto expandedInput = expandFieldReference(input, sourceNode);
+      std::vector<core::TypedExprPtr> exprs = {expandedInput};
+      if (!canBeEvaluatedByCudf(exprs, queryCtx)) {
+        return false;
+      }
+    }
+  }
+
+  // Check grouping key expressions
+  if (!canGroupingKeysBeEvaluatedByCudf(
+          aggregationNode.groupingKeys(), sourceNode, queryCtx)) {
+    return false;
+  }
+
+  return true;
+}
+
+CudfGroupby::CudfGroupby(
+    int32_t operatorId,
+    exec::DriverCtx* driverCtx,
+    std::shared_ptr<core::AggregationNode const> const& aggregationNode)
+    : CudfOperatorBase(
+          operatorId,
+          driverCtx,
+          aggregationNode->outputType(),
+          aggregationNode->id(),
+          std::string{"CudfGroupby"} +
+              std::string{
+                  core::AggregationNode::toName(aggregationNode->step())},
+          nvtx3::rgb{34, 139, 34}, // Forest Green
+          NvtxMethodFlag::kAddInput | NvtxMethodFlag::kGetOutput,
+          std::nullopt,
+          aggregationNode),
+      aggregationNode_(aggregationNode),
+      isPartialOutput_(
+          exec::isPartialOutput(aggregationNode->step()) &&
+          !hasFinalAggs(aggregationNode->aggregates())),
+      isSingleStep_(
+          aggregationNode->step() == core::AggregationNode::Step::kSingle),
+      maxPartialAggregationMemoryUsage_(
+          driverCtx->queryConfig().maxPartialAggregationMemoryUsage()) {}
+
+void CudfGroupby::initialize() {
+  Operator::initialize();
+
+  inputType_ = aggregationNode_->sources()[0]->outputType();
+  ignoreNullKeys_ = aggregationNode_->ignoreNullKeys();
+  setupGroupingKeyChannelProjections(
+      *aggregationNode_, groupingKeyInputChannels_, groupingKeyOutputChannels_);
+
+  // Velox CPU does optimizations related to pre-grouped keys. This can be
+  // done in cudf by passing sort information to cudf::groupby() constructor.
+  // We're postponing this for now.
+
+  numAggregates_ = aggregationNode_->aggregates().size();
+  const auto inputRowSchema = asRowType(inputType_);
+  auto aggregationInput = buildAggregationInputChannels(
+      *aggregationNode_,
+      *operatorCtx_,
+      inputRowSchema,
+      groupingKeyInputChannels_);
+  aggregationInputChannels_ = std::move(aggregationInput.channels);
+  aggregators_ = toGroupbyAggregators(
+      *aggregationNode_,
+      aggregationNode_->step(),
+      outputType_,
+      aggregationInput.constants);
+  streamingEnabled_ = !hasCompanionAggregates(aggregationNode_->aggregates());
+
+  // Make aggregators for intermediate step when streaming is enabled.
+  if (streamingEnabled_) {
+    const bool isFinalOrSingle =
+        aggregationNode_->step() == core::AggregationNode::Step::kFinal ||
+        aggregationNode_->step() == core::AggregationNode::Step::kSingle;
+    bufferedResultType_ = isFinalOrSingle
+        ? getBufferedResultType(*aggregationNode_)
+        : outputType_;
+
+    std::vector<VectorPtr> nullConstants(numAggregates_);
+    intermediateAggregators_ = toGroupbyAggregators(
+        *aggregationNode_,
+        core::AggregationNode::Step::kIntermediate,
+        bufferedResultType_,
+        nullConstants);
+
+    if (isSingleStep_) {
+      partialAggregators_ = toGroupbyAggregators(
+          *aggregationNode_,
+          core::AggregationNode::Step::kPartial,
+          bufferedResultType_,
+          aggregationInput.constants);
+      finalAggregators_ = toGroupbyAggregators(
+          *aggregationNode_,
+          core::AggregationNode::Step::kFinal,
+          outputType_,
+          nullConstants);
+    }
+  }
+
+  // Check that aggregate result type match the output type.
+  // TODO: This is output schema validation. In velox CPU, it's done using
+  // output types reported by aggregation functions. We can't do that in cudf
+  // groupby.
+
+  // TODO: Set identity projections used by HashProbe to pushdown dynamic
+  // filters to table scan.
+
+  // TODO: Add support for grouping sets and group ids.
+
+  aggregationNode_.reset();
+}
+
+void CudfGroupby::computePartialGroupbyStreaming(CudfVectorPtr tbl) {
+  // For every input, we'll do a groupby and compact results with the existing
+  // intermediate groupby results.
+
+  auto inputTableStream = tbl->stream();
+  // Use getTableView() to avoid expensive materialization for packed_table.
+  // tbl stays alive during this function call, keeping the view valid.
+  auto permutedInputView = tbl->getTableView().select(
+      aggregationInputChannels_.begin(), aggregationInputChannels_.end());
+  auto groupbyOnInput = doGroupByAggregation(
+      permutedInputView,
+      groupingKeyOutputChannels_,
+      aggregators_,
+      bufferedResultType_,
+      inputTableStream);
+
+  // If we already have partial output, concatenate the new results with it.
+  if (bufferedResult_) {
+    auto partialOutputStream = bufferedResult_->stream();
+    std::vector<CudfVectorPtr> tablesToConcat;
+    tablesToConcat.push_back(bufferedResult_);
+    tablesToConcat.push_back(groupbyOnInput);
+    auto concatenatedTable = getConcatenatedTable(
+        std::move(tablesToConcat),
+        bufferedResultType_,
+        partialOutputStream,
+        get_output_mr());
+
+    // Now we have to groupby again but this time with intermediate aggregators.
+    // Keep concatenatedTable alive while we use its view.
+    auto compactedOutput = doGroupByAggregation(
+        concatenatedTable->view(),
+        groupingKeyOutputChannels_,
+        intermediateAggregators_,
+        bufferedResultType_,
+        partialOutputStream);
+    bufferedResult_ = compactedOutput;
+  } else {
+    // First time processing, just store the result of the input batch's groupby
+    // This means we're storing the stream from the first batch.
+    bufferedResult_ = groupbyOnInput;
+  }
+}
+
+void CudfGroupby::computeFinalGroupbyStreaming(CudfVectorPtr tbl) {
+  auto inputTableStream = tbl->stream();
+  auto permutedInputView = tbl->getTableView().select(
+      aggregationInputChannels_.begin(), aggregationInputChannels_.end());
+
+  if (!bufferedResult_) {
+    auto groupbyOnInput = doGroupByAggregation(
+        permutedInputView,
+        groupingKeyOutputChannels_,
+        intermediateAggregators_,
+        bufferedResultType_,
+        inputTableStream);
+    if (!groupbyOnInput) {
+      return;
+    }
+    bufferedResult_ = groupbyOnInput;
+    return;
+  }
+
+  std::vector<cudf::table_view> tablesToConcat;
+  tablesToConcat.push_back(bufferedResult_->getTableView());
+  tablesToConcat.push_back(permutedInputView);
+
+  auto finalStream = bufferedResult_->stream();
+  cudf::detail::join_streams(
+      std::vector<rmm::cuda_stream_view>{inputTableStream}, finalStream);
+
+  auto concatenatedTable =
+      cudf::concatenate(tablesToConcat, finalStream, get_temp_mr());
+  cudf::detail::join_streams(
+      std::vector<rmm::cuda_stream_view>{finalStream}, inputTableStream);
+  auto compactedOutput = doGroupByAggregation(
+      concatenatedTable->view(),
+      groupingKeyOutputChannels_,
+      intermediateAggregators_,
+      bufferedResultType_,
+      finalStream);
+  bufferedResult_ = compactedOutput;
+}
+
+void CudfGroupby::computeSingleGroupbyStreaming(CudfVectorPtr tbl) {
+  auto inputTableStream = tbl->stream();
+  auto permutedInputView = tbl->getTableView().select(
+      aggregationInputChannels_.begin(), aggregationInputChannels_.end());
+  auto groupbyOnInput = doGroupByAggregation(
+      permutedInputView,
+      groupingKeyOutputChannels_,
+      partialAggregators_,
+      bufferedResultType_,
+      inputTableStream);
+
+  if (bufferedResult_) {
+    auto partialOutputStream = bufferedResult_->stream();
+    std::vector<CudfVectorPtr> tablesToConcat;
+    tablesToConcat.push_back(bufferedResult_);
+    tablesToConcat.push_back(groupbyOnInput);
+    auto concatenatedTable = getConcatenatedTable(
+        std::move(tablesToConcat),
+        bufferedResultType_,
+        partialOutputStream,
+        get_temp_mr());
+
+    auto compactedOutput = doGroupByAggregation(
+        concatenatedTable->view(),
+        groupingKeyOutputChannels_,
+        intermediateAggregators_,
+        bufferedResultType_,
+        partialOutputStream);
+    bufferedResult_ = compactedOutput;
+  } else {
+    bufferedResult_ = groupbyOnInput;
+  }
+}
+
+void CudfGroupby::doAddInput(RowVectorPtr input) {
+  if (input->size() == 0) {
+    return;
+  }
+  numInputRows_ += input->size();
+
+  auto cudfInput = std::dynamic_pointer_cast<cudf_velox::CudfVector>(input);
+  VELOX_CHECK_NOT_NULL(cudfInput);
+
+  if (streamingEnabled_) {
+    if (isPartialOutput_) {
+      computePartialGroupbyStreaming(cudfInput);
+      return;
+    } else if (isSingleStep_) {
+      computeSingleGroupbyStreaming(cudfInput);
+      return;
+    } else {
+      computeFinalGroupbyStreaming(cudfInput);
+      return;
+    }
+  }
+
+  // Handle non-streaming cases.
+  inputs_.push_back(std::move(cudfInput));
+}
+
+CudfVectorPtr CudfGroupby::doGroupByAggregation(
+    cudf::table_view tableView,
+    std::vector<column_index_t> const& groupByKeys,
+    std::vector<std::unique_ptr<GroupbyAggregator>>& aggregators,
+    TypePtr const& outputType,
+    rmm::cuda_stream_view stream) {
+  auto groupbyKeyView =
+      tableView.select(groupByKeys.begin(), groupByKeys.end());
+
+  // TODO: All other args to groupby are related to sort groupby. We don't
+  // support optimizations related to it yet.
+  cudf::groupby::groupby groupByOwner(
+      groupbyKeyView,
+      ignoreNullKeys_ ? cudf::null_policy::EXCLUDE
+                      : cudf::null_policy::INCLUDE);
+
+  std::vector<cudf::groupby::aggregation_request> requests;
+  for (auto& aggregator : aggregators) {
+    aggregator->addGroupbyRequest(tableView, requests);
+  }
+
+  auto [groupKeys, results] =
+      groupByOwner.aggregate(requests, stream, get_output_mr());
+  // flatten the results
+  std::vector<std::unique_ptr<cudf::column>> resultColumns;
+
+  // first fill the grouping keys
+  auto groupKeysColumns = groupKeys->release();
+  resultColumns.insert(
+      resultColumns.begin(),
+      std::make_move_iterator(groupKeysColumns.begin()),
+      std::make_move_iterator(groupKeysColumns.end()));
+
+  // then fill the aggregation results
+  for (auto& aggregator : aggregators) {
+    resultColumns.push_back(aggregator->makeOutputColumn(results, stream));
+  }
+
+  // make a cudf table out of columns
+  auto resultTable = std::make_unique<cudf::table>(std::move(resultColumns));
+
+  auto numRows = resultTable->num_rows();
+
+  // velox expects nullptr instead of a table with 0 rows
+  if (numRows == 0) {
+    return nullptr;
+  }
+
+  return std::make_shared<cudf_velox::CudfVector>(
+      pool(), outputType, numRows, std::move(resultTable), stream);
+}
+
+CudfVectorPtr CudfGroupby::releaseAndResetBufferedResult() {
+  auto numOutputRows = bufferedResult_->size();
+  const double aggregationPct =
+      numOutputRows == 0 ? 0 : (numOutputRows * 1.0) / numInputRows_ * 100;
+  {
+    auto lockedStats = stats_.wlock();
+    lockedStats->addRuntimeStat(
+        std::string(exec::HashAggregation::kFlushRowCount),
+        RuntimeCounter(numOutputRows));
+    lockedStats->addRuntimeStat(
+        std::string(exec::HashAggregation::kFlushTimes), RuntimeCounter(1));
+    lockedStats->addRuntimeStat(
+        std::string(exec::HashAggregation::kPartialAggregationPct),
+        RuntimeCounter(aggregationPct));
+  }
+
+  numInputRows_ = 0;
+  // We're moving bufferedResult_ to the caller because we want it to be null
+  // after this call.
+  return std::move(bufferedResult_);
+}
+
+RowVectorPtr CudfGroupby::doGetOutput() {
+  // Handle partial streaming groupby.
+  if (isPartialOutput_ && streamingEnabled_) {
+    if (bufferedResult_ &&
+        bufferedResult_->estimateFlatSize() >
+            maxPartialAggregationMemoryUsage_) {
+      return releaseAndResetBufferedResult();
+    }
+    if (not noMoreInput_) {
+      // Don't produce output if the partial output hasn't reached memory limit
+      // and there's more batches to come.
+      return nullptr;
+    }
+    if (!bufferedResult_ && finished_) {
+      return nullptr;
+    }
+    return releaseAndResetBufferedResult();
+  }
+
+  if (finished_) {
+    return nullptr;
+  }
+
+  if (!isPartialOutput_ && !noMoreInput_) {
+    // Final aggregation has to wait for all batches to arrive so we cannot
+    // return any results here.
+    return nullptr;
+  }
+
+  // Streaming finalization: single step uses finalAggregators_ to convert
+  // intermediate results to final output; final step uses aggregators_.
+  // At this point isPartialOutput_ is false (handled above) and noMoreInput_
+  // is true (guarded by the check above).
+  if (streamingEnabled_) {
+    finished_ = true;
+    if (!bufferedResult_) {
+      return nullptr;
+    }
+    auto& aggs = isSingleStep_ ? finalAggregators_ : aggregators_;
+    auto stream = bufferedResult_->stream();
+    auto result = doGroupByAggregation(
+        bufferedResult_->getTableView(),
+        groupingKeyOutputChannels_,
+        aggs,
+        outputType_,
+        stream);
+    stream.synchronize();
+    bufferedResult_.reset();
+    return result;
+  }
+
+  if (inputs_.empty() && !noMoreInput_) {
+    return nullptr;
+  }
+
+  auto stream = cudfGlobalStreamPool().get_stream();
+
+  auto tbl = getConcatenatedTable(
+      std::exchange(inputs_, {}), inputType_, stream, get_output_mr());
+
+  // Release input data after synchronizing.
+  stream.synchronize();
+  inputs_.clear();
+
+  if (noMoreInput_) {
+    finished_ = true;
+  }
+
+  VELOX_CHECK_NOT_NULL(tbl);
+
+  auto permutedInputView = tbl->view().select(
+      aggregationInputChannels_.begin(), aggregationInputChannels_.end());
+  return doGroupByAggregation(
+      permutedInputView,
+      groupingKeyOutputChannels_,
+      aggregators_,
+      outputType_,
+      stream);
+}
+
+void CudfGroupby::doNoMoreInput() {
+  Operator::noMoreInput();
+  if (isPartialOutput_ && inputs_.empty()) {
+    finished_ = true;
+  }
+}
+
+bool CudfGroupby::isFinished() {
+  return finished_;
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfGroupby.h b/velox/experimental/cudf/exec/CudfGroupby.h
new file mode 100644
index 00000000000..27ca367fa50
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfGroupby.h
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/experimental/cudf/exec/CudfAggregation.h"
+#include "velox/experimental/cudf/exec/CudfOperator.h"
+
+#include <cudf/groupby.hpp>
+
+namespace facebook::velox::cudf_velox {
+
+struct GroupbyAggregator {
+  core::AggregationNode::Step step;
+  uint32_t inputIndex;
+  VectorPtr constant;
+  TypePtr resultType;
+
+  virtual void addGroupbyRequest(
+      cudf::table_view const& tbl,
+      std::vector<cudf::groupby::aggregation_request>& requests) = 0;
+
+  virtual std::unique_ptr<cudf::column> makeOutputColumn(
+      std::vector<cudf::groupby::aggregation_result>& results,
+      rmm::cuda_stream_view stream) = 0;
+
+  virtual ~GroupbyAggregator() = default;
+
+ protected:
+  GroupbyAggregator(
+      core::AggregationNode::Step step,
+      uint32_t inputIndex,
+      VectorPtr constant,
+      const TypePtr& resultType)
+      : step(step),
+        inputIndex(inputIndex),
+        constant(constant),
+        resultType(resultType) {}
+};
+
+// Factory functions for creating groupby aggregators from plan nodes.
+std::vector<std::unique_ptr<GroupbyAggregator>> toGroupbyAggregators(
+    core::AggregationNode const& aggregationNode,
+    core::AggregationNode::Step step,
+    TypePtr const& outputType,
+    std::vector<VectorPtr> const& constants);
+
+// Groupby-specific validation
+bool canGroupbyBeEvaluatedByCudf(
+    const core::AggregationNode& aggregationNode,
+    core::QueryCtx* queryCtx);
+
+bool canGroupbyAggregationBeEvaluatedByCudf(
+    const core::CallTypedExpr& call,
+    core::AggregationNode::Step step,
+    const std::vector<TypePtr>& rawInputTypes,
+    core::QueryCtx* queryCtx);
+
+class CudfGroupby : public CudfOperatorBase {
+ public:
+  CudfGroupby(
+      int32_t operatorId,
+      exec::DriverCtx* driverCtx,
+      std::shared_ptr<const core::AggregationNode> const& aggregationNode);
+
+  void initialize() override;
+
+  bool needsInput() const override {
+    return !noMoreInput_;
+  }
+
+  exec::BlockingReason isBlocked(ContinueFuture* /* unused */) override {
+    return exec::BlockingReason::kNotBlocked;
+  }
+
+  bool isFinished() override;
+
+ protected:
+  void doAddInput(RowVectorPtr input) override;
+
+  RowVectorPtr doGetOutput() override;
+
+  void doNoMoreInput() override;
+
+ private:
+  CudfVectorPtr doGroupByAggregation(
+      cudf::table_view tableView,
+      std::vector<column_index_t> const& groupByKeys,
+      std::vector<std::unique_ptr<GroupbyAggregator>>& aggregators,
+      TypePtr const& outputType,
+      rmm::cuda_stream_view stream);
+
+  CudfVectorPtr releaseAndResetBufferedResult();
+
+  void computePartialGroupbyStreaming(CudfVectorPtr tbl);
+  void computeFinalGroupbyStreaming(CudfVectorPtr tbl);
+  void computeSingleGroupbyStreaming(CudfVectorPtr tbl);
+
+  std::vector<column_index_t> groupingKeyInputChannels_;
+  std::vector<column_index_t> groupingKeyOutputChannels_;
+  std::vector<column_index_t> aggregationInputChannels_;
+
+  std::shared_ptr<const core::AggregationNode> aggregationNode_;
+  std::vector<std::unique_ptr<GroupbyAggregator>> aggregators_;
+  std::vector<std::unique_ptr<GroupbyAggregator>> intermediateAggregators_;
+  // Used for kSingle streaming: partial-step aggregators (raw -> intermediate)
+  // and final-step aggregators (intermediate -> final).
+  std::vector<std::unique_ptr<GroupbyAggregator>> partialAggregators_;
+  std::vector<std::unique_ptr<GroupbyAggregator>> finalAggregators_;
+
+  const bool isPartialOutput_;
+  const bool isSingleStep_;
+  // Streaming aggregation is disabled if companion aggregates are present.
+  bool streamingEnabled_{true};
+  const int64_t maxPartialAggregationMemoryUsage_;
+  int64_t numInputRows_ = 0;
+
+  bool finished_ = false;
+  size_t numAggregates_;
+  bool ignoreNullKeys_;
+
+  std::vector<CudfVectorPtr> inputs_;
+  TypePtr inputType_;
+  RowTypePtr bufferedResultType_;
+  CudfVectorPtr bufferedResult_;
+};
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfHashAggregation.cpp b/velox/experimental/cudf/exec/CudfHashAggregation.cpp
deleted file mode 100644
index 31d387c10ee..00000000000
--- a/velox/experimental/cudf/exec/CudfHashAggregation.cpp
+++ /dev/null
@@ -1,992 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/cudf/exec/CudfHashAggregation.h"
-#include "velox/experimental/cudf/exec/ToCudf.h"
-#include "velox/experimental/cudf/exec/Utilities.h"
-#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
-
-#include "velox/exec/Aggregate.h"
-#include "velox/exec/AggregateFunctionRegistry.h"
-#include "velox/exec/PrefixSort.h"
-#include "velox/exec/Task.h"
-#include "velox/expression/Expr.h"
-
-#include <cudf/binaryop.hpp>
-#include <cudf/column/column_factories.hpp>
-#include <cudf/concatenate.hpp>
-#include <cudf/reduction.hpp>
-#include <cudf/stream_compaction.hpp>
-#include <cudf/unary.hpp>
-
-namespace {
-
-using namespace facebook::velox;
-
-bool isFloatingPointType(const TypePtr& type) {
-  return type->kind() != TypeKind::REAL && type->kind() != TypeKind::DOUBLE;
-}
-
-#define DEFINE_SIMPLE_AGGREGATOR(Name, name, KIND)                            \
-  struct Name##Aggregator : cudf_velox::CudfHashAggregation::Aggregator {     \
-    Name##Aggregator(                                                         \
-        core::AggregationNode::Step step,                                     \
-        uint32_t inputIndex,                                                  \
-        VectorPtr constant,                                                   \
-        bool is_global,                                                       \
-        const TypePtr& resultType)                                            \
-        : Aggregator(                                                         \
-              step,                                                           \
-              cudf::aggregation::KIND,                                        \
-              inputIndex,                                                     \
-              constant,                                                       \
-              is_global,                                                      \
-              resultType) {}                                                  \
-                                                                              \
-    void addGroupbyRequest(                                                   \
-        cudf::table_view const& tbl,                                          \
-        std::vector<cudf::groupby::aggregation_request>& requests) override { \
-      VELOX_CHECK(                                                            \
-          constant == nullptr,                                                \
-          #Name "Aggregator does not yet support constant input");            \
-      auto& request = requests.emplace_back();                                \
-      output_idx = requests.size() - 1;                                       \
-      request.values = tbl.column(inputIndex);                                \
-      request.aggregations.push_back(                                         \
-          cudf::make_##name##_aggregation<cudf::groupby_aggregation>());      \
-    }                                                                         \
-                                                                              \
-    std::unique_ptr<cudf::column> makeOutputColumn(                           \
-        std::vector<cudf::groupby::aggregation_result>& results,              \
-        rmm::cuda_stream_view stream) override {                              \
-      auto col = std::move(results[output_idx].results[0]);                   \
-      const auto cudfType =                                                   \
-          cudf::data_type(cudf_velox::veloxToCudfTypeId(resultType));         \
-      if (col->type() != cudfType) {                                          \
-        col = cudf::cast(*col, cudfType, stream);                             \
-      }                                                                       \
-      return col;                                                             \
-    }                                                                         \
-                                                                              \
-    std::unique_ptr<cudf::column> doReduce(                                   \
-        cudf::table_view const& input,                                        \
-        TypePtr const& outputType,                                            \
-        rmm::cuda_stream_view stream) override {                              \
-      auto const aggRequest =                                                 \
-          cudf::make_##name##_aggregation<cudf::reduce_aggregation>();        \
-      auto const cudfOutputType =                                             \
-          cudf::data_type(cudf_velox::veloxToCudfTypeId(outputType));         \
-      auto const resultScalar = cudf::reduce(                                 \
-          input.column(inputIndex), *aggRequest, cudfOutputType, stream);     \
-      return cudf::make_column_from_scalar(*resultScalar, 1, stream);         \
-    }                                                                         \
-                                                                              \
-   private:                                                                   \
-    uint32_t output_idx;                                                      \
-  };
-
-DEFINE_SIMPLE_AGGREGATOR(Sum, sum, SUM)
-DEFINE_SIMPLE_AGGREGATOR(Min, min, MIN)
-DEFINE_SIMPLE_AGGREGATOR(Max, max, MAX)
-
-struct CountAggregator : cudf_velox::CudfHashAggregation::Aggregator {
-  CountAggregator(
-      core::AggregationNode::Step step,
-      uint32_t inputIndex,
-      VectorPtr constant,
-      bool isGlobal,
-      const TypePtr& resultType)
-      : Aggregator(
-            step,
-            cudf::aggregation::COUNT_VALID,
-            inputIndex,
-            constant,
-            isGlobal,
-            resultType) {}
-
-  void addGroupbyRequest(
-      cudf::table_view const& tbl,
-      std::vector<cudf::groupby::aggregation_request>& requests) override {
-    auto& request = requests.emplace_back();
-    outputIdx_ = requests.size() - 1;
-    request.values = tbl.column(constant == nullptr ? inputIndex : 0);
-    std::unique_ptr<cudf::groupby_aggregation> aggRequest =
-        exec::isRawInput(step)
-        ? cudf::make_count_aggregation<cudf::groupby_aggregation>(
-              constant == nullptr ? cudf::null_policy::EXCLUDE
-                                  : cudf::null_policy::INCLUDE)
-        : cudf::make_sum_aggregation<cudf::groupby_aggregation>();
-    request.aggregations.push_back(std::move(aggRequest));
-  }
-
-  std::unique_ptr<cudf::column> doReduce(
-      cudf::table_view const& input,
-      TypePtr const& outputType,
-      rmm::cuda_stream_view stream) override {
-    if (exec::isRawInput(step)) {
-      // For raw input, implement count using size + null count
-      auto inputCol = input.column(constant == nullptr ? inputIndex : 0);
-
-      // count_valid: size - null_count, count_all: just the size
-      int64_t count = constant == nullptr
-          ? inputCol.size() - inputCol.null_count()
-          : inputCol.size();
-
-      auto resultScalar = cudf::numeric_scalar<int64_t>(count);
-
-      return cudf::make_column_from_scalar(resultScalar, 1, stream);
-    } else {
-      // For non-raw input (intermediate/final), use sum aggregation
-      auto const aggRequest =
-          cudf::make_sum_aggregation<cudf::reduce_aggregation>();
-      auto const cudfOutputType = cudf::data_type(cudf::type_id::INT64);
-      auto const resultScalar = cudf::reduce(
-          input.column(inputIndex), *aggRequest, cudfOutputType, stream);
-      resultScalar->set_valid_async(true, stream);
-      return cudf::make_column_from_scalar(*resultScalar, 1, stream);
-    }
-    return nullptr;
-  }
-
-  std::unique_ptr<cudf::column> makeOutputColumn(
-      std::vector<cudf::groupby::aggregation_result>& results,
-      rmm::cuda_stream_view stream) override {
-    // cudf produces int32 for count(0) but velox expects int64
-    auto col = std::move(results[outputIdx_].results[0]);
-    const auto cudfOutputType =
-        cudf::data_type(cudf_velox::veloxToCudfTypeId(resultType));
-    if (col->type() != cudfOutputType) {
-      col = cudf::cast(*col, cudfOutputType, stream);
-    }
-    return col;
-  }
-
- private:
-  uint32_t outputIdx_;
-};
-
-struct MeanAggregator : cudf_velox::CudfHashAggregation::Aggregator {
-  MeanAggregator(
-      core::AggregationNode::Step step,
-      uint32_t inputIndex,
-      VectorPtr constant,
-      bool isGlobal,
-      const TypePtr& resultType)
-      : Aggregator(
-            step,
-            cudf::aggregation::MEAN,
-            inputIndex,
-            constant,
-            isGlobal,
-            resultType) {}
-
-  void addGroupbyRequest(
-      cudf::table_view const& tbl,
-      std::vector<cudf::groupby::aggregation_request>& requests) override {
-    switch (step) {
-      case core::AggregationNode::Step::kSingle: {
-        auto& request = requests.emplace_back();
-        meanIdx_ = requests.size() - 1;
-        request.values = tbl.column(inputIndex);
-        request.aggregations.push_back(
-            cudf::make_mean_aggregation<cudf::groupby_aggregation>());
-        break;
-      }
-      case core::AggregationNode::Step::kPartial: {
-        auto& request = requests.emplace_back();
-        sumIdx_ = requests.size() - 1;
-        request.values = tbl.column(inputIndex);
-        request.aggregations.push_back(
-            cudf::make_sum_aggregation<cudf::groupby_aggregation>());
-        request.aggregations.push_back(
-            cudf::make_count_aggregation<cudf::groupby_aggregation>(
-                cudf::null_policy::EXCLUDE));
-        break;
-      }
-      case core::AggregationNode::Step::kIntermediate:
-      case core::AggregationNode::Step::kFinal: {
-        // In intermediate and final aggregation, the previously computed sum
-        // and count are in the child columns of the input column.
-        auto& request = requests.emplace_back();
-        sumIdx_ = requests.size() - 1;
-        request.values = tbl.column(inputIndex).child(0);
-        request.aggregations.push_back(
-            cudf::make_sum_aggregation<cudf::groupby_aggregation>());
-
-        auto& request2 = requests.emplace_back();
-        countIdx_ = requests.size() - 1;
-        request2.values = tbl.column(inputIndex).child(1);
-        // The counts are already computed in partial aggregation, so we just
-        // need to sum them up again.
-        request2.aggregations.push_back(
-            cudf::make_sum_aggregation<cudf::groupby_aggregation>());
-        break;
-      }
-      default:
-        // We don't know how to handle kIntermediate step for mean
-        VELOX_NYI("Unsupported aggregation step for mean");
-    }
-  }
-
-  std::unique_ptr<cudf::column> makeOutputColumn(
-      std::vector<cudf::groupby::aggregation_result>& results,
-      rmm::cuda_stream_view stream) override {
-    const auto& outputType = asRowType(resultType);
-    switch (step) {
-      case core::AggregationNode::Step::kSingle:
-        return std::move(results[meanIdx_].results[0]);
-      case core::AggregationNode::Step::kPartial: {
-        auto sum = std::move(results[sumIdx_].results[0]);
-        auto count = std::move(results[sumIdx_].results[1]);
-
-        auto const size = sum->size();
-        auto const cudfSumType = cudf::data_type(
-            cudf_velox::veloxToCudfTypeId(outputType->childAt(0)));
-        auto const cudfCountType = cudf::data_type(
-            cudf_velox::veloxToCudfTypeId(outputType->childAt(1)));
-        if (sum->type() != cudf::data_type(cudfSumType)) {
-          sum = cudf::cast(*sum, cudf::data_type(cudfSumType), stream);
-        }
-        if (count->type() != cudf::data_type(cudfCountType)) {
-          count = cudf::cast(*count, cudf::data_type(cudfCountType), stream);
-        }
-
-        auto children = std::vector<std::unique_ptr<cudf::column>>();
-        children.push_back(std::move(sum));
-        children.push_back(std::move(count));
-
-        // TODO: Handle nulls. This can happen if all values are null in a
-        // group.
-        return std::make_unique<cudf::column>(
-            cudf::data_type(cudf::type_id::STRUCT),
-            size,
-            rmm::device_buffer{},
-            rmm::device_buffer{},
-            0,
-            std::move(children));
-      }
-      case core::AggregationNode::Step::kIntermediate: {
-        // The difference between intermediate and partial is in where the
-        // sum and count are coming from. In partial, since the input column is
-        // the same, the sum and count are in the same agg result. In
-        // intermediate, the input columns are different (it's the child
-        // columns of the input column) and so the sum and count are in
-        // different agg results.
-        auto sum = std::move(results[sumIdx_].results[0]);
-        auto count = std::move(results[countIdx_].results[0]);
-
-        auto size = sum->size();
-        auto const cudfSumType = cudf::data_type(
-            cudf_velox::veloxToCudfTypeId(outputType->childAt(0)));
-        auto const cudfCountType = cudf::data_type(
-            cudf_velox::veloxToCudfTypeId(outputType->childAt(1)));
-        if (sum->type() != cudf::data_type(cudfSumType)) {
-          sum = cudf::cast(*sum, cudf::data_type(cudfSumType), stream);
-        }
-        if (count->type() != cudf::data_type(cudfCountType)) {
-          count = cudf::cast(*count, cudf::data_type(cudfCountType), stream);
-        }
-
-        auto children = std::vector<std::unique_ptr<cudf::column>>();
-        children.push_back(std::move(sum));
-        children.push_back(std::move(count));
-
-        return std::make_unique<cudf::column>(
-            cudf::data_type(cudf::type_id::STRUCT),
-            size,
-            rmm::device_buffer{},
-            rmm::device_buffer{},
-            0,
-            std::move(children));
-      }
-      case core::AggregationNode::Step::kFinal: {
-        auto sum = std::move(results[sumIdx_].results[0]);
-        auto count = std::move(results[countIdx_].results[0]);
-        auto avg = cudf::binary_operation(
-            *sum,
-            *count,
-            cudf::binary_operator::DIV,
-            cudf::data_type(cudf_velox::veloxToCudfTypeId(resultType)),
-            stream);
-        return avg;
-      }
-      default:
-        VELOX_NYI("Unsupported aggregation step for mean");
-    }
-  }
-
-  std::unique_ptr<cudf::column> doReduce(
-      cudf::table_view const& input,
-      TypePtr const& outputType,
-      rmm::cuda_stream_view stream) override {
-    switch (step) {
-      case core::AggregationNode::Step::kSingle: {
-        auto const aggRequest =
-            cudf::make_mean_aggregation<cudf::reduce_aggregation>();
-        auto const cudfOutputType =
-            cudf::data_type(cudf_velox::veloxToCudfTypeId(outputType));
-        auto const resultScalar = cudf::reduce(
-            input.column(inputIndex), *aggRequest, cudfOutputType, stream);
-        return cudf::make_column_from_scalar(*resultScalar, 1, stream);
-      }
-      case core::AggregationNode::Step::kPartial: {
-        VELOX_CHECK(outputType->isRow());
-        auto const& rowType = outputType->asRow();
-        auto const sumType = rowType.childAt(0);
-        auto const countType = rowType.childAt(1);
-        auto const cudfSumType =
-            cudf::data_type(cudf_velox::veloxToCudfTypeId(sumType));
-        auto const cudfCountType =
-            cudf::data_type(cudf_velox::veloxToCudfTypeId(countType));
-
-        // sum
-        auto const aggRequest =
-            cudf::make_sum_aggregation<cudf::reduce_aggregation>();
-        auto const sumResultScalar = cudf::reduce(
-            input.column(inputIndex), *aggRequest, cudfSumType, stream);
-        auto sumCol =
-            cudf::make_column_from_scalar(*sumResultScalar, 1, stream);
-
-        // libcudf doesn't have a count agg for reduce. What we want is to
-        // count the number of valid rows.
-        auto countCol = cudf::make_column_from_scalar(
-            cudf::numeric_scalar<int64_t>(
-                input.column(inputIndex).size() -
-                input.column(inputIndex).null_count()),
-            1,
-            stream);
-
-        // Assemble into struct as expected by velox.
-        auto children = std::vector<std::unique_ptr<cudf::column>>();
-        children.push_back(std::move(sumCol));
-        children.push_back(std::move(countCol));
-        return std::make_unique<cudf::column>(
-            cudf::data_type(cudf::type_id::STRUCT),
-            1,
-            rmm::device_buffer{},
-            rmm::device_buffer{},
-            0,
-            std::move(children));
-      }
-      case core::AggregationNode::Step::kFinal: {
-        // Input column has two children: sum and count
-        auto const sumCol = input.column(inputIndex).child(0);
-        auto const countCol = input.column(inputIndex).child(1);
-
-        // sum the sums
-        auto const sumAggRequest =
-            cudf::make_sum_aggregation<cudf::reduce_aggregation>();
-        auto const sumResultScalar =
-            cudf::reduce(sumCol, *sumAggRequest, sumCol.type(), stream);
-        auto sumResultCol =
-            cudf::make_column_from_scalar(*sumResultScalar, 1, stream);
-
-        // sum the counts
-        auto const countAggRequest =
-            cudf::make_sum_aggregation<cudf::reduce_aggregation>();
-        auto const countResultScalar =
-            cudf::reduce(countCol, *countAggRequest, countCol.type(), stream);
-
-        // divide the sums by the counts
-        auto const cudfOutputType =
-            cudf::data_type(cudf_velox::veloxToCudfTypeId(outputType));
-        return cudf::binary_operation(
-            *sumResultCol,
-            *countResultScalar,
-            cudf::binary_operator::DIV,
-            cudfOutputType,
-            stream);
-      }
-      default:
-        VELOX_NYI("Unsupported aggregation step for mean");
-    }
-  }
-
- private:
-  // These indices are used to track where the desired result columns
-  // (mean/<sum, count>) are in the output of cudf::groupby::aggregate().
-  uint32_t meanIdx_;
-  uint32_t sumIdx_;
-  uint32_t countIdx_;
-};
-
-std::unique_ptr<cudf_velox::CudfHashAggregation::Aggregator> createAggregator(
-    core::AggregationNode::Step step,
-    std::string const& kind,
-    uint32_t inputIndex,
-    VectorPtr constant,
-    bool isGlobal,
-    const TypePtr& resultType) {
-  auto prefix = cudf_velox::CudfOptions::getInstance().prefix();
-  if (kind.rfind(prefix + "sum", 0) == 0) {
-    return std::make_unique<SumAggregator>(
-        step, inputIndex, constant, isGlobal, resultType);
-  } else if (kind.rfind(prefix + "count", 0) == 0) {
-    return std::make_unique<CountAggregator>(
-        step, inputIndex, constant, isGlobal, resultType);
-  } else if (kind.rfind(prefix + "min", 0) == 0) {
-    return std::make_unique<MinAggregator>(
-        step, inputIndex, constant, isGlobal, resultType);
-  } else if (kind.rfind(prefix + "max", 0) == 0) {
-    return std::make_unique<MaxAggregator>(
-        step, inputIndex, constant, isGlobal, resultType);
-  } else if (kind.rfind(prefix + "avg", 0) == 0) {
-    return std::make_unique<MeanAggregator>(
-        step, inputIndex, constant, isGlobal, resultType);
-  } else {
-    VELOX_NYI("Aggregation not yet supported");
-  }
-}
-
-static const std::unordered_map<std::string, core::AggregationNode::Step>
-    companionStep = {
-        {"_partial", core::AggregationNode::Step::kPartial},
-        {"_merge", core::AggregationNode::Step::kIntermediate},
-        {"_merge_extract", core::AggregationNode::Step::kFinal}};
-
-/// \brief Convert companion function to step for the aggregation function
-///
-/// Companion functions are functions that are registered in velox along with
-/// their main aggregation functions. These are designed to always function
-/// with a fixed `step`. This is to allow spark style planNodes where `step` is
-/// the property of the aggregation function rather than the planNode.
-/// Companion functions allow us to override the planNode's step and use
-/// aggregations of different steps in the same planNode
-core::AggregationNode::Step getCompanionStep(
-    std::string const& kind,
-    core::AggregationNode::Step step) {
-  for (const auto& [k, v] : companionStep) {
-    if (folly::StringPiece(kind).endsWith(k)) {
-      step = v;
-      break;
-    }
-  }
-  return step;
-}
-
-std::string getOriginalName(std::string const& kind) {
-  for (const auto& [k, v] : companionStep) {
-    if (folly::StringPiece(kind).endsWith(k)) {
-      return kind.substr(0, kind.length() - k.length());
-    }
-  }
-  return kind;
-}
-
-bool hasFinalAggs(
-    std::vector<core::AggregationNode::Aggregate> const& aggregates) {
-  return std::any_of(aggregates.begin(), aggregates.end(), [](auto const& agg) {
-    return folly::StringPiece(agg.call->name()).endsWith("_merge_extract");
-  });
-}
-
-auto toAggregators(
-    core::AggregationNode const& aggregationNode,
-    exec::OperatorCtx const& operatorCtx) {
-  auto const step = aggregationNode.step();
-  bool const isGlobal = aggregationNode.groupingKeys().empty();
-  auto const& inputRowSchema = aggregationNode.sources()[0]->outputType();
-  const auto numKeys = aggregationNode.groupingKeys().size();
-  const auto outputType = aggregationNode.outputType();
-
-  std::vector<std::unique_ptr<cudf_velox::CudfHashAggregation::Aggregator>>
-      aggregators;
-  for (auto i = 0; i < aggregationNode.aggregates().size(); ++i) {
-    auto const& aggregate = aggregationNode.aggregates()[i];
-    std::vector<column_index_t> aggInputs;
-    std::vector<VectorPtr> aggConstants;
-    for (auto const& arg : aggregate.call->inputs()) {
-      if (auto const field =
-              dynamic_cast<core::FieldAccessTypedExpr const*>(arg.get())) {
-        aggInputs.push_back(inputRowSchema->getChildIdx(field->name()));
-      } else if (
-          auto constant =
-              dynamic_cast<const core::ConstantTypedExpr*>(arg.get())) {
-        aggInputs.push_back(kConstantChannel);
-        aggConstants.push_back(constant->toConstantVector(operatorCtx.pool()));
-      } else {
-        VELOX_NYI("Constants and lambdas not yet supported");
-      }
-    }
-    // The loop on aggregate.call->inputs() is taken from
-    // AggregateInfo.cpp::toAggregateInfo(). It seems to suggest that there can
-    // be multiple inputs to an aggregate.
-    // We're postponing properly supporting this for now because the currently
-    // supported aggregation functions in cudf_velox don't use it.
-    VELOX_CHECK(aggInputs.size() <= 1);
-    if (aggInputs.empty()) {
-      aggInputs.push_back(0);
-    }
-
-    if (aggregate.distinct) {
-      VELOX_NYI("De-dup before aggregation is not yet supported");
-    }
-
-    auto const kind = aggregate.call->name();
-    auto const inputIndex = aggInputs[0];
-    auto const constant = aggConstants.empty() ? nullptr : aggConstants[0];
-    auto const companionStep = getCompanionStep(kind, step);
-    const auto originalName = getOriginalName(kind);
-    const auto resultType = exec::isPartialOutput(companionStep)
-        ? exec::resolveAggregateFunction(originalName, aggregate.rawInputTypes)
-              .second
-        : outputType->childAt(numKeys + i);
-
-    aggregators.push_back(createAggregator(
-        companionStep, kind, inputIndex, constant, isGlobal, resultType));
-  }
-  return aggregators;
-}
-
-auto toIntermediateAggregators(
-    core::AggregationNode const& aggregationNode,
-    exec::OperatorCtx const& operatorCtx) {
-  auto const step = core::AggregationNode::Step::kIntermediate;
-  bool const isGlobal = aggregationNode.groupingKeys().empty();
-  auto const& inputRowSchema = aggregationNode.outputType();
-
-  std::vector<std::unique_ptr<cudf_velox::CudfHashAggregation::Aggregator>>
-      aggregators;
-  for (size_t i = 0; i < aggregationNode.aggregates().size(); i++) {
-    // Intermediate aggregation has a 1:1 mapping between input and output.
-    // We don't need to figure out input from the aggregate function.
-    auto const& aggregate = aggregationNode.aggregates()[i];
-    auto const inputIndex = aggregationNode.groupingKeys().size() + i;
-    auto const kind = aggregate.call->name();
-    auto const constant = nullptr;
-    const auto originalName = getOriginalName(kind);
-    auto const companionStep = getCompanionStep(kind, step);
-    if (exec::isPartialOutput(companionStep)) {
-      const auto resultType =
-          exec::resolveAggregateFunction(originalName, aggregate.rawInputTypes)
-              .second;
-      aggregators.push_back(createAggregator(
-          step, kind, inputIndex, constant, isGlobal, resultType));
-    } else {
-      // Final step aggregator will not use the intermediate aggregator.
-      aggregators.push_back(nullptr);
-    }
-  }
-  return aggregators;
-}
-
-std::unique_ptr<cudf::table> makeEmptyTable(TypePtr const& inputType) {
-  std::vector<std::unique_ptr<cudf::column>> emptyColumns;
-  for (size_t i = 0; i < inputType->size(); ++i) {
-    if (auto const& childType = inputType->childAt(i);
-        childType->kind() == TypeKind::ROW) {
-      auto tbl = makeEmptyTable(childType);
-      auto structColumn = std::make_unique<cudf::column>(
-          cudf::data_type(cudf::type_id::STRUCT),
-          0,
-          rmm::device_buffer(),
-          rmm::device_buffer(),
-          0,
-          tbl->release());
-      emptyColumns.push_back(std::move(structColumn));
-    } else {
-      auto emptyColumn = cudf::make_empty_column(
-          cudf_velox::veloxToCudfTypeId(inputType->childAt(i)));
-      emptyColumns.push_back(std::move(emptyColumn));
-    }
-  }
-  return std::make_unique<cudf::table>(std::move(emptyColumns));
-}
-
-} // namespace
-
-namespace facebook::velox::cudf_velox {
-
-CudfHashAggregation::CudfHashAggregation(
-    int32_t operatorId,
-    exec::DriverCtx* driverCtx,
-    std::shared_ptr<core::AggregationNode const> const& aggregationNode)
-    : Operator(
-          driverCtx,
-          aggregationNode->outputType(),
-          operatorId,
-          aggregationNode->id(),
-          aggregationNode->step() == core::AggregationNode::Step::kPartial
-              ? "CudfPartialAggregation"
-              : "CudfAggregation",
-          aggregationNode->canSpill(driverCtx->queryConfig())
-              ? driverCtx->makeSpillConfig(operatorId)
-              : std::nullopt),
-      NvtxHelper(
-          nvtx3::rgb{34, 139, 34}, // Forest Green
-          operatorId,
-          fmt::format("[{}]", aggregationNode->id())),
-      aggregationNode_(aggregationNode),
-      isPartialOutput_(
-          exec::isPartialOutput(aggregationNode->step()) &&
-          !hasFinalAggs(aggregationNode->aggregates())),
-      isGlobal_(aggregationNode->groupingKeys().empty()),
-      isDistinct_(!isGlobal_ && aggregationNode->aggregates().empty()),
-      maxPartialAggregationMemoryUsage_(
-          driverCtx->queryConfig().maxPartialAggregationMemoryUsage()) {}
-
-void CudfHashAggregation::initialize() {
-  Operator::initialize();
-
-  inputType_ = aggregationNode_->sources()[0]->outputType();
-  ignoreNullKeys_ = aggregationNode_->ignoreNullKeys();
-  setupGroupingKeyChannelProjections(
-      groupingKeyInputChannels_, groupingKeyOutputChannels_);
-
-  auto const numGroupingKeys = groupingKeyOutputChannels_.size();
-
-  // Velox CPU does optimizations related to pre-grouped keys. This can be
-  // done in cudf by passing sort information to cudf::groupby() constructor.
-  // We're postponing this for now.
-
-  numAggregates_ = aggregationNode_->aggregates().size();
-  aggregators_ = toAggregators(*aggregationNode_, *operatorCtx_);
-  intermediateAggregators_ =
-      toIntermediateAggregators(*aggregationNode_, *operatorCtx_);
-
-  // Check that aggregate result type match the output type.
-  // TODO: This is output schema validation. In velox CPU, it's done using
-  // output types reported by aggregation functions. We can't do that in cudf
-  // groupby.
-
-  // TODO: Set identity projections used by HashProbe to pushdown dynamic
-  // filters to table scan.
-
-  // TODO: Add support for grouping sets and group ids.
-
-  aggregationNode_.reset();
-}
-
-void CudfHashAggregation::setupGroupingKeyChannelProjections(
-    std::vector<column_index_t>& groupingKeyInputChannels,
-    std::vector<column_index_t>& groupingKeyOutputChannels) const {
-  VELOX_CHECK(groupingKeyInputChannels.empty());
-  VELOX_CHECK(groupingKeyOutputChannels.empty());
-
-  auto const& inputType = aggregationNode_->sources()[0]->outputType();
-  auto const& groupingKeys = aggregationNode_->groupingKeys();
-  // The map from the grouping key output channel to the input channel.
-  //
-  // NOTE: grouping key output order is specified as 'groupingKeys' in
-  // 'aggregationNode_'.
-  std::vector<exec::IdentityProjection> groupingKeyProjections;
-  groupingKeyProjections.reserve(groupingKeys.size());
-  for (auto i = 0; i < groupingKeys.size(); ++i) {
-    groupingKeyProjections.emplace_back(
-        exec::exprToChannel(groupingKeys[i].get(), inputType), i);
-  }
-
-  groupingKeyInputChannels.reserve(groupingKeys.size());
-  for (auto i = 0; i < groupingKeys.size(); ++i) {
-    groupingKeyInputChannels.push_back(groupingKeyProjections[i].inputChannel);
-  }
-
-  groupingKeyOutputChannels.resize(groupingKeys.size());
-
-  std::iota(
-      groupingKeyOutputChannels.begin(), groupingKeyOutputChannels.end(), 0);
-}
-
-void CudfHashAggregation::computeIntermediateGroupbyPartial(CudfVectorPtr tbl) {
-  // For every input, we'll do a groupby and compact results with the existing
-  // intermediate groupby results.
-
-  auto inputTableStream = tbl->stream();
-  auto groupbyOnInput = doGroupByAggregation(
-      tbl->release(),
-      groupingKeyInputChannels_,
-      aggregators_,
-      inputTableStream);
-
-  // If we already have partial output, concatenate the new results with it.
-  if (partialOutput_) {
-    // Create a vector of tables to concatenate
-    std::vector<cudf::table_view> tablesToConcat;
-    tablesToConcat.push_back(partialOutput_->getTableView());
-    tablesToConcat.push_back(groupbyOnInput->getTableView());
-
-    auto partialOutputStream = partialOutput_->stream();
-    // We need to join the input table stream on the partial output stream to
-    // make sure the intermediate results are available when we do the concat.
-    cudf::detail::join_streams(
-        std::vector<rmm::cuda_stream_view>{inputTableStream},
-        partialOutputStream);
-
-    // Concatenate the tables
-    auto concatenatedTable =
-        cudf::concatenate(tablesToConcat, partialOutputStream);
-
-    // Now we have to groupby again but this time with intermediate aggregators.
-    auto compactedOutput = doGroupByAggregation(
-        std::move(concatenatedTable),
-        groupingKeyOutputChannels_,
-        intermediateAggregators_,
-        partialOutputStream);
-    partialOutput_ = compactedOutput;
-  } else {
-    // First time processing, just store the result of the input batch's groupby
-    // This means we're storing the stream from the first batch.
-    partialOutput_ = groupbyOnInput;
-  }
-}
-
-void CudfHashAggregation::computeIntermediateDistinctPartial(
-    CudfVectorPtr tbl) {
-  // For every input, we'll concat with existing distinct results and then do a
-  // distinct on the concatenated results.
-
-  auto inputTableStream = tbl->stream();
-
-  if (partialOutput_) {
-    // Concatenate the input table with the existing distinct results.
-    std::vector<cudf::table_view> tablesToConcat;
-    tablesToConcat.push_back(partialOutput_->getTableView());
-    tablesToConcat.push_back(tbl->getTableView().select(
-        groupingKeyInputChannels_.begin(), groupingKeyInputChannels_.end()));
-
-    auto partialOutputStream = partialOutput_->stream();
-    // We need to join the input table stream on the partial output stream to
-    // make sure the input table is available when we do the concat.
-    cudf::detail::join_streams(
-        std::vector<rmm::cuda_stream_view>{inputTableStream},
-        partialOutputStream);
-
-    auto concatenatedTable =
-        cudf::concatenate(tablesToConcat, partialOutputStream);
-
-    // Do a distinct on the concatenated results.
-    auto distinctOutput = getDistinctKeys(
-        std::move(concatenatedTable),
-        groupingKeyOutputChannels_,
-        inputTableStream);
-    partialOutput_ = distinctOutput;
-  } else {
-    // First time processing, just store the result of the input batch's
-    // distinct.
-    partialOutput_ = getDistinctKeys(
-        tbl->release(), groupingKeyInputChannels_, inputTableStream);
-  }
-}
-
-void CudfHashAggregation::addInput(RowVectorPtr input) {
-  VELOX_NVTX_OPERATOR_FUNC_RANGE();
-  if (input->size() == 0) {
-    return;
-  }
-  numInputRows_ += input->size();
-
-  auto cudfInput = std::dynamic_pointer_cast<cudf_velox::CudfVector>(input);
-  VELOX_CHECK_NOT_NULL(cudfInput);
-
-  if (isPartialOutput_ && !isGlobal_) {
-    if (isDistinct_) {
-      // Handle partial distinct aggregation.
-      computeIntermediateDistinctPartial(cudfInput);
-    } else {
-      // Handle partial groupby aggregation.
-      computeIntermediateGroupbyPartial(cudfInput);
-    }
-    return;
-  }
-
-  // Handle final aggregation or global cases.
-  inputs_.push_back(std::move(cudfInput));
-}
-
-CudfVectorPtr CudfHashAggregation::doGroupByAggregation(
-    std::unique_ptr<cudf::table> tbl,
-    std::vector<column_index_t> const& groupByKeys,
-    std::vector<std::unique_ptr<Aggregator>>& aggregators,
-    rmm::cuda_stream_view stream) {
-  auto groupbyKeyView = tbl->select(groupByKeys.begin(), groupByKeys.end());
-
-  size_t const numGroupingKeys = groupbyKeyView.num_columns();
-
-  // TODO: All other args to groupby are related to sort groupby. We don't
-  // support optimizations related to it yet.
-  cudf::groupby::groupby groupByOwner(
-      groupbyKeyView,
-      ignoreNullKeys_ ? cudf::null_policy::EXCLUDE
-                      : cudf::null_policy::INCLUDE);
-
-  std::vector<cudf::groupby::aggregation_request> requests;
-  for (auto& aggregator : aggregators) {
-    aggregator->addGroupbyRequest(tbl->view(), requests);
-  }
-
-  auto [groupKeys, results] = groupByOwner.aggregate(requests, stream);
-  // flatten the results
-  std::vector<std::unique_ptr<cudf::column>> resultColumns;
-
-  // first fill the grouping keys
-  auto groupKeysColumns = groupKeys->release();
-  resultColumns.insert(
-      resultColumns.begin(),
-      std::make_move_iterator(groupKeysColumns.begin()),
-      std::make_move_iterator(groupKeysColumns.end()));
-
-  // then fill the aggregation results
-  for (auto& aggregator : aggregators) {
-    resultColumns.push_back(aggregator->makeOutputColumn(results, stream));
-  }
-
-  // make a cudf table out of columns
-  auto resultTable = std::make_unique<cudf::table>(std::move(resultColumns));
-
-  auto numRows = resultTable->num_rows();
-
-  // velox expects nullptr instead of a table with 0 rows
-  if (numRows == 0) {
-    return nullptr;
-  }
-
-  return std::make_shared<cudf_velox::CudfVector>(
-      pool(), outputType_, numRows, std::move(resultTable), stream);
-}
-
-CudfVectorPtr CudfHashAggregation::doGlobalAggregation(
-    std::unique_ptr<cudf::table> tbl,
-    rmm::cuda_stream_view stream) {
-  std::vector<std::unique_ptr<cudf::column>> resultColumns;
-  resultColumns.reserve(aggregators_.size());
-  for (auto i = 0; i < aggregators_.size(); i++) {
-    resultColumns.push_back(aggregators_[i]->doReduce(
-        tbl->view(), outputType_->childAt(i), stream));
-  }
-
-  return std::make_shared<cudf_velox::CudfVector>(
-      pool(),
-      outputType_,
-      1,
-      std::make_unique<cudf::table>(std::move(resultColumns)),
-      stream);
-}
-
-CudfVectorPtr CudfHashAggregation::getDistinctKeys(
-    std::unique_ptr<cudf::table> tbl,
-    std::vector<column_index_t> const& groupByKeys,
-    rmm::cuda_stream_view stream) {
-  auto result = cudf::distinct(
-      tbl->view().select(groupByKeys.begin(), groupByKeys.end()),
-      {groupingKeyOutputChannels_.begin(), groupingKeyOutputChannels_.end()},
-      cudf::duplicate_keep_option::KEEP_FIRST,
-      cudf::null_equality::EQUAL,
-      cudf::nan_equality::ALL_EQUAL,
-      stream);
-
-  auto numRows = result->num_rows();
-
-  // velox expects nullptr instead of a table with 0 rows
-  if (numRows == 0) {
-    return nullptr;
-  }
-
-  return std::make_shared<cudf_velox::CudfVector>(
-      pool(), outputType_, numRows, std::move(result), stream);
-}
-
-CudfVectorPtr CudfHashAggregation::releaseAndResetPartialOutput() {
-  VELOX_DCHECK(!isGlobal_);
-  auto numOutputRows = partialOutput_->size();
-  const double aggregationPct =
-      numOutputRows == 0 ? 0 : (numOutputRows * 1.0) / numInputRows_ * 100;
-  {
-    auto lockedStats = stats_.wlock();
-    lockedStats->addRuntimeStat("flushRowCount", RuntimeCounter(numOutputRows));
-    lockedStats->addRuntimeStat("flushTimes", RuntimeCounter(1));
-    lockedStats->addRuntimeStat(
-        "partialAggregationPct", RuntimeCounter(aggregationPct));
-  }
-
-  numInputRows_ = 0;
-  // We're moving partialOutput_ to the caller because we want it to be null
-  // after this call.
-  return std::move(partialOutput_);
-}
-
-RowVectorPtr CudfHashAggregation::getOutput() {
-  VELOX_NVTX_OPERATOR_FUNC_RANGE();
-
-  // Handle partial groupby and distinct.
-  if (isPartialOutput_ && !isGlobal_) {
-    if (partialOutput_ &&
-        partialOutput_->estimateFlatSize() >
-            maxPartialAggregationMemoryUsage_) {
-      // This is basically a flush of the partial output.
-      return releaseAndResetPartialOutput();
-    }
-    if (not noMoreInput_) {
-      // Don't produce output if the partial output hasn't reached memory limit
-      // and there's more batches to come.
-      return nullptr;
-    }
-    if (!partialOutput_ && finished_) {
-      return nullptr;
-    }
-    return releaseAndResetPartialOutput();
-  }
-
-  if (finished_) {
-    return nullptr;
-  }
-
-  if (!isPartialOutput_ && !noMoreInput_) {
-    // Final aggregation has to wait for all batches to arrive so we cannot
-    // return any results here.
-    return nullptr;
-  }
-
-  if (inputs_.empty() && !noMoreInput_) {
-    return nullptr;
-  }
-
-  auto stream = cudfGlobalStreamPool().get_stream();
-
-  auto tbl = inputs_.empty() ? makeEmptyTable(inputType_)
-                             : getConcatenatedTable(inputs_, stream);
-
-  // Release input data after synchronizing.
-  stream.synchronize();
-  inputs_.clear();
-
-  if (noMoreInput_) {
-    finished_ = true;
-  }
-
-  VELOX_CHECK_NOT_NULL(tbl);
-
-  if (isDistinct_) {
-    return getDistinctKeys(std::move(tbl), groupingKeyInputChannels_, stream);
-  } else if (isGlobal_) {
-    return doGlobalAggregation(std::move(tbl), stream);
-  } else {
-    return doGroupByAggregation(
-        std::move(tbl), groupingKeyInputChannels_, aggregators_, stream);
-  }
-}
-
-void CudfHashAggregation::noMoreInput() {
-  Operator::noMoreInput();
-  if (isPartialOutput_ && inputs_.empty()) {
-    finished_ = true;
-  }
-}
-
-bool CudfHashAggregation::isFinished() {
-  return finished_;
-}
-
-} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfHashAggregation.h b/velox/experimental/cudf/exec/CudfHashAggregation.h
deleted file mode 100644
index 5b31de5a299..00000000000
--- a/velox/experimental/cudf/exec/CudfHashAggregation.h
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include "velox/experimental/cudf/exec/NvtxHelper.h"
-#include "velox/experimental/cudf/vector/CudfVector.h"
-
-#include "velox/exec/Operator.h"
-
-#include <cudf/groupby.hpp>
-
-namespace facebook::velox::cudf_velox {
-
-class CudfHashAggregation : public exec::Operator, public NvtxHelper {
- public:
-  struct Aggregator {
-    core::AggregationNode::Step step;
-    bool is_global;
-    cudf::aggregation::Kind kind;
-    uint32_t inputIndex;
-    VectorPtr constant;
-    TypePtr resultType;
-
-    virtual void addGroupbyRequest(
-        cudf::table_view const& tbl,
-        std::vector<cudf::groupby::aggregation_request>& requests) = 0;
-
-    virtual std::unique_ptr<cudf::column> doReduce(
-        cudf::table_view const& input,
-        TypePtr const& outputType,
-        rmm::cuda_stream_view stream) = 0;
-
-    virtual std::unique_ptr<cudf::column> makeOutputColumn(
-        std::vector<cudf::groupby::aggregation_result>& results,
-        rmm::cuda_stream_view stream) = 0;
-
-   protected:
-    Aggregator(
-        core::AggregationNode::Step step,
-        cudf::aggregation::Kind kind,
-        uint32_t inputIndex,
-        VectorPtr constant,
-        bool isGlobal,
-        const TypePtr& _resultType)
-        : step(step),
-          is_global(isGlobal),
-          kind(kind),
-          inputIndex(inputIndex),
-          constant(constant),
-          resultType(_resultType) {}
-  };
-
-  CudfHashAggregation(
-      int32_t operatorId,
-      exec::DriverCtx* driverCtx,
-      std::shared_ptr<const core::AggregationNode> const& aggregationNode);
-
-  void initialize() override;
-
-  void addInput(RowVectorPtr input) override;
-
-  RowVectorPtr getOutput() override;
-
-  bool needsInput() const override {
-    return !noMoreInput_;
-  }
-
-  void noMoreInput() override;
-
-  exec::BlockingReason isBlocked(ContinueFuture* /* unused */) override {
-    return exec::BlockingReason::kNotBlocked;
-  }
-
-  bool isFinished() override;
-
- private:
-  // Setups the projections for accessing grouping keys stored in grouping
-  // set.
-  // For 'groupingKeyInputChannels', the index is the key column index from
-  // the grouping set, and the value is the key column channel from the input.
-  // For 'outputChannelProjections', the index is the key column channel from
-  // the output, and the value is the key column index from the grouping set.
-  void setupGroupingKeyChannelProjections(
-      std::vector<column_index_t>& groupingKeyInputChannels,
-      std::vector<column_index_t>& groupingKeyOutputChannels) const;
-
-  CudfVectorPtr doGroupByAggregation(
-      std::unique_ptr<cudf::table> tbl,
-      std::vector<column_index_t> const& groupByKeys,
-      std::vector<std::unique_ptr<Aggregator>>& aggregators,
-      rmm::cuda_stream_view stream);
-  CudfVectorPtr doGlobalAggregation(
-      std::unique_ptr<cudf::table> tbl,
-      rmm::cuda_stream_view stream);
-  CudfVectorPtr getDistinctKeys(
-      std::unique_ptr<cudf::table> tbl,
-      std::vector<column_index_t> const& groupByKeys,
-      rmm::cuda_stream_view stream);
-
-  CudfVectorPtr releaseAndResetPartialOutput();
-
-  std::vector<column_index_t> groupingKeyInputChannels_;
-  std::vector<column_index_t> groupingKeyOutputChannels_;
-
-  std::shared_ptr<const core::AggregationNode> aggregationNode_;
-  std::vector<std::unique_ptr<Aggregator>> aggregators_;
-  std::vector<std::unique_ptr<Aggregator>> intermediateAggregators_;
-
-  // Partial aggregation is the first phase of aggregation. e.g. count(*) when
-  // in partial phase will do a count_agg but in the final phase will do a sum
-  // of the previous calculated counts
-  const bool isPartialOutput_;
-  // Global means it's an aggregation without groupby. Like cudf::reduce
-  const bool isGlobal_;
-  // Distinct means it's a count distinct on the groupby keys, without any
-  // aggregations
-  const bool isDistinct_;
-
-  // Maximum memory usage for partial aggregation.
-  const int64_t maxPartialAggregationMemoryUsage_;
-  // Number of rows received in the input so far.
-  int64_t numInputRows_ = 0;
-
-  bool finished_ = false;
-
-  size_t numAggregates_;
-  bool ignoreNullKeys_;
-
-  std::vector<cudf_velox::CudfVectorPtr> inputs_;
-
-  TypePtr inputType_;
-
-  // This is for partial aggregation to keep reducing the amount of memory it
-  // has to hold on to.
-  void computeIntermediateGroupbyPartial(CudfVectorPtr tbl);
-
-  void computeIntermediateDistinctPartial(CudfVectorPtr tbl);
-
-  CudfVectorPtr partialOutput_;
-};
-
-} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfHashJoin.cpp b/velox/experimental/cudf/exec/CudfHashJoin.cpp
index 8e52a8952a1..5a7f82dfbcf 100644
--- a/velox/experimental/cudf/exec/CudfHashJoin.cpp
+++ b/velox/experimental/cudf/exec/CudfHashJoin.cpp
@@ -14,26 +14,83 @@
  * limitations under the License.
  */
 
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/CudfNoDefaults.h"
 #include "velox/experimental/cudf/exec/CudfHashJoin.h"
-#include "velox/experimental/cudf/exec/ExpressionEvaluator.h"
-#include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/exec/GpuResources.h"
 #include "velox/experimental/cudf/exec/Utilities.h"
 #include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+#include "velox/experimental/cudf/expression/AstExpression.h"
+#include "velox/experimental/cudf/expression/AstExpressionUtils.h"
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
 
-#include "velox/exec/Task.h"
+#include "velox/core/PlanNode.h"
+#include "velox/exec/Task.h" // NOLINT(misc-unused-headers)
+#include "velox/type/TypeUtil.h"
 
+#include <cudf/aggregation.hpp>
+#include <cudf/binaryop.hpp>
+#include <cudf/column/column_factories.hpp>
+#include <cudf/concatenate.hpp>
 #include <cudf/copying.hpp>
+#include <cudf/detail/utilities/stream_pool.hpp>
+#include <cudf/filling.hpp>
+#include <cudf/groupby.hpp>
+#include <cudf/join/filtered_join.hpp>
+#include <cudf/join/join.hpp>
+#include <cudf/join/mixed_join.hpp>
 #include <cudf/null_mask.hpp>
+#include <cudf/reduction.hpp>
+#include <cudf/reshape.hpp>
+#include <cudf/scalar/scalar_factories.hpp>
+#include <cudf/search.hpp>
 #include <cudf/stream_compaction.hpp>
+#include <cudf/unary.hpp>
+
+#include <rmm/cuda_stream_view.hpp>
+#include <rmm/device_uvector.hpp>
+#include <rmm/exec_policy.hpp>
 
 #include <nvtx3/nvtx3.hpp>
 
 namespace facebook::velox::cudf_velox {
 
+namespace {
+
+/// Creates extended table view by appending precomputed columns
+cudf::table_view createExtendedTableView(
+    cudf::table_view originalView,
+    std::vector<ColumnOrView>& precomputedColumns) {
+  if (precomputedColumns.empty()) {
+    return originalView;
+  }
+
+  std::vector<cudf::column_view> allViews;
+  allViews.reserve(originalView.num_columns() + precomputedColumns.size());
+
+  for (cudf::size_type i = 0; i < originalView.num_columns(); ++i) {
+    allViews.push_back(originalView.column(i));
+  }
+  for (auto& col : precomputedColumns) {
+    allViews.push_back(asView(col));
+  }
+
+  return cudf::table_view(allViews);
+}
+
+} // namespace
+
+void CudfHashJoinProbe::doClose() {
+  Operator::close();
+  filterEvaluator_.reset();
+  scalars_.clear();
+  tree_ = {};
+}
+
 void CudfHashJoinBridge::setHashTable(
     std::optional<CudfHashJoinBridge::hash_type> hashObject) {
-  if (cudfDebugEnabled()) {
-    std::cout << "Calling CudfHashJoinBridge::setHashTable" << std::endl;
+  if (CudfConfig::getInstance().debugEnabled) {
+    VLOG(2) << "Calling CudfHashJoinBridge::setHashTable";
   }
   std::vector<ContinuePromise> promises;
   {
@@ -49,64 +106,62 @@ void CudfHashJoinBridge::setHashTable(
 
 std::optional<CudfHashJoinBridge::hash_type> CudfHashJoinBridge::hashOrFuture(
     ContinueFuture* future) {
-  if (cudfDebugEnabled()) {
-    std::cout << "Calling CudfHashJoinBridge::hashOrFuture" << std::endl;
+  if (CudfConfig::getInstance().debugEnabled) {
+    VLOG(2) << "Calling CudfHashJoinBridge::hashOrFuture";
   }
   std::lock_guard<std::mutex> l(mutex_);
   if (hashObject_.has_value()) {
     return hashObject_;
   }
-  if (cudfDebugEnabled()) {
-    std::cout << "Calling CudfHashJoinBridge::hashOrFuture constructing promise"
-              << std::endl;
+  if (CudfConfig::getInstance().debugEnabled) {
+    VLOG(2) << "Calling CudfHashJoinBridge::hashOrFuture constructing promise";
   }
   promises_.emplace_back("CudfHashJoinBridge::hashOrFuture");
-  if (cudfDebugEnabled()) {
-    std::cout << "Calling CudfHashJoinBridge::hashOrFuture getSemiFuture"
-              << std::endl;
+  if (CudfConfig::getInstance().debugEnabled) {
+    VLOG(2) << "Calling CudfHashJoinBridge::hashOrFuture getSemiFuture";
   }
   *future = promises_.back().getSemiFuture();
-  if (cudfDebugEnabled()) {
-    std::cout << "Calling CudfHashJoinBridge::hashOrFuture returning nullopt"
-              << std::endl;
+  if (CudfConfig::getInstance().debugEnabled) {
+    VLOG(2) << "Calling CudfHashJoinBridge::hashOrFuture returning nullopt";
   }
   return std::nullopt;
 }
 
+void CudfHashJoinBridge::setBuildStream(rmm::cuda_stream_view buildStream) {
+  std::lock_guard<std::mutex> l(mutex_);
+  buildStream_ = buildStream;
+}
+
+std::optional<rmm::cuda_stream_view> CudfHashJoinBridge::getBuildStream() {
+  std::lock_guard<std::mutex> l(mutex_);
+  return buildStream_;
+}
+
 CudfHashJoinBuild::CudfHashJoinBuild(
     int32_t operatorId,
     exec::DriverCtx* driverCtx,
     std::shared_ptr<const core::HashJoinNode> joinNode)
     // TODO check outputType should be set or not?
-    : exec::Operator(
-          driverCtx,
-          nullptr, // joinNode->sources(),
+    : CudfOperatorBase(
           operatorId,
+          driverCtx,
+          nullptr, // outputType
           joinNode->id(),
-          "CudfHashJoinBuild"),
-      NvtxHelper(
+          "CudfHashJoinBuild",
           nvtx3::rgb{65, 105, 225}, // Royal Blue
-          operatorId,
-          fmt::format("[{}]", joinNode->id())),
-      joinNode_(joinNode) {
-  if (cudfDebugEnabled()) {
-    std::cout << "CudfHashJoinBuild constructor" << std::endl;
-  }
-}
+          NvtxMethodFlag::kAll,
+          std::nullopt, // spillConfig
+          joinNode),
+      joinNode_(joinNode) {}
 
-void CudfHashJoinBuild::addInput(RowVectorPtr input) {
-  if (cudfDebugEnabled()) {
-    std::cout << "Calling CudfHashJoinBuild::addInput" << std::endl;
-  }
+void CudfHashJoinBuild::doAddInput(RowVectorPtr input) {
   // Queue inputs, process all at once.
   if (input->size() > 0) {
     auto cudfInput = std::dynamic_pointer_cast<CudfVector>(input);
     VELOX_CHECK_NOT_NULL(cudfInput);
     // Count nulls in join key columns
     auto [_, null_count] = cudf::bitmask_and(
-        cudfInput->getTableView(),
-        cudfInput->stream(),
-        cudf::get_current_device_resource_ref());
+        cudfInput->getTableView(), cudfInput->stream(), get_temp_mr());
     {
       // Update statistics for null keys in join operator.
       auto lockedStats = stats_.wlock();
@@ -117,21 +172,14 @@ void CudfHashJoinBuild::addInput(RowVectorPtr input) {
 }
 
 bool CudfHashJoinBuild::needsInput() const {
-  if (cudfDebugEnabled()) {
-    std::cout << "Calling CudfHashJoinBuild::needsInput" << std::endl;
-  }
   return !noMoreInput_;
 }
 
-RowVectorPtr CudfHashJoinBuild::getOutput() {
+RowVectorPtr CudfHashJoinBuild::doGetOutput() {
   return nullptr;
 }
 
-void CudfHashJoinBuild::noMoreInput() {
-  if (cudfDebugEnabled()) {
-    std::cout << "Calling CudfHashJoinBuild::noMoreInput" << std::endl;
-  }
-  VELOX_NVTX_OPERATOR_FUNC_RANGE();
+void CudfHashJoinBuild::doNoMoreInput() {
   Operator::noMoreInput();
   std::vector<ContinuePromise> promises;
   std::vector<std::shared_ptr<exec::Driver>> peers;
@@ -157,66 +205,90 @@ void CudfHashJoinBuild::noMoreInput() {
     }
   };
 
-  auto stream = cudfGlobalStreamPool().get_stream();
-  std::unique_ptr<cudf::table> tbl;
-  if (inputs_.size() == 0) {
-    auto emptyRowVector = RowVector::createEmpty(
-        joinNode_->sources()[1]->outputType(), operatorCtx_->pool());
-    tbl = facebook::velox::cudf_velox::with_arrow::toCudfTable(
-        emptyRowVector, operatorCtx_->pool(), stream);
-  } else {
-    tbl = getConcatenatedTable(inputs_, stream);
+  if (CudfConfig::getInstance().debugEnabled) {
+    VLOG(1) << "CudfHashJoinBuild: build batches count: " << inputs_.size();
+    if (!inputs_.empty()) {
+      VLOG(1) << "Build batches number of columns: "
+              << inputs_[0]->getTableView().num_columns();
+    }
+    for (auto i = 0; i < inputs_.size(); i++) {
+      VLOG(1) << "Build batch " << i
+              << ": number of rows: " << inputs_[i]->getTableView().num_rows();
+    }
   }
 
-  // Release input data after synchronizing
-  stream.synchronize();
-  inputs_.clear();
+  auto stream = cudfGlobalStreamPool().get_stream();
+  // Using output_mr here to allow spilling queued up large tables
+  auto tbls = getConcatenatedTableBatched(
+      std::exchange(inputs_, {}),
+      joinNode_->sources()[1]->outputType(),
+      stream,
+      get_output_mr());
 
-  VELOX_CHECK_NOT_NULL(tbl);
-  if (cudfDebugEnabled()) {
-    std::cout << "Build table number of columns: " << tbl->num_columns()
-              << std::endl;
-    std::cout << "Build table number of rows: " << tbl->num_rows() << std::endl;
+  for (auto const& tbl : tbls) {
+    VELOX_CHECK_NOT_NULL(tbl);
+  }
+  if (CudfConfig::getInstance().debugEnabled && !tbls.empty()) {
+    VLOG(1) << "Build table number of columns: " << tbls[0]->num_columns();
+    for (auto i = 0; i < tbls.size(); i++) {
+      VLOG(1) << "Build table " << i
+              << ": number of rows: " << tbls[i]->num_rows();
+    }
   }
 
-  auto buildType = joinNode_->sources()[1]->outputType();
   auto rightKeys = joinNode_->rightKeys();
 
   auto buildKeyIndices = std::vector<cudf::size_type>(rightKeys.size());
+  auto buildType = joinNode_->sources()[1]->outputType();
   for (size_t i = 0; i < buildKeyIndices.size(); i++) {
     buildKeyIndices[i] = static_cast<cudf::size_type>(
         buildType->getChildIdx(rightKeys[i]->name()));
   }
 
-  // Only need to construct hash_join object if it's an inner join or left join
-  // and doesn't have a filter. All other cases use a standalone function in
-  // cudf
-  bool buildHashJoin = (joinNode_->isInnerJoin() || joinNode_->isLeftJoin()) &&
-      !joinNode_->filter();
-  auto hashObject = (buildHashJoin) ? std::make_shared<cudf::hash_join>(
-                                          tbl->view().select(buildKeyIndices),
-                                          cudf::null_equality::UNEQUAL,
-                                          stream)
-                                    : nullptr;
-  if (buildHashJoin) {
-    VELOX_CHECK_NOT_NULL(hashObject);
-  }
+  // Construct hash_join object for join types that use hb->inner_join() or
+  // hb->left_join(). Semi filter and anti joins use standalone cudf functions
+  // (e.g., mixed_left_semi_join, filtered_join) that build hash tables
+  // internally, so they don't need this.
+  bool buildHashJoin =
+      (joinNode_->isInnerJoin() || joinNode_->isLeftJoin() ||
+       joinNode_->isRightJoin() || joinNode_->isFullJoin() ||
+       joinNode_->isLeftSemiProjectJoin());
 
-  if (cudfDebugEnabled()) {
-    if (hashObject != nullptr) {
-      printf("hashObject is not nullptr %p\n", hashObject.get());
-    } else {
-      printf("hashObject is *** nullptr\n");
+  std::vector<std::shared_ptr<cudf::hash_join>> hashObjects;
+  for (auto i = 0; i < tbls.size(); i++) {
+    hashObjects.push_back(
+        (buildHashJoin) ? std::make_shared<cudf::hash_join>(
+                              tbls[i]->view().select(buildKeyIndices),
+                              cudf::null_equality::UNEQUAL,
+                              stream)
+                        : nullptr);
+    if (buildHashJoin) {
+      VELOX_CHECK_NOT_NULL(hashObjects.back());
+    }
+    if (CudfConfig::getInstance().debugEnabled) {
+      if (hashObjects.back() != nullptr) {
+        VLOG(2) << "hashObject " << i << " is not nullptr "
+                << hashObjects.back().get() << "\n";
+      } else {
+        VLOG(2) << "hashObject " << i << " is *** nullptr\n";
+      }
     }
   }
 
+  std::vector<std::shared_ptr<cudf::table>> shared_tbls;
+  for (auto& tbl : tbls) {
+    shared_tbls.push_back(std::move(tbl));
+  }
   // set hash table to CudfHashJoinBridge
   auto joinBridge = operatorCtx_->task()->getCustomJoinBridge(
       operatorCtx_->driverCtx()->splitGroupId, planNodeId());
   auto cudfHashJoinBridge =
       std::dynamic_pointer_cast<CudfHashJoinBridge>(joinBridge);
-  cudfHashJoinBridge->setHashTable(std::make_optional(
-      std::make_pair(std::shared_ptr(std::move(tbl)), std::move(hashObject))));
+
+  cudfHashJoinBridge->setBuildStream(stream);
+  cudfHashJoinBridge->setHashTable(
+      std::make_optional(
+          std::make_pair(std::move(shared_tbls), std::move(hashObjects))));
 }
 
 exec::BlockingReason CudfHashJoinBuild::isBlocked(ContinueFuture* future) {
@@ -235,59 +307,55 @@ CudfHashJoinProbe::CudfHashJoinProbe(
     int32_t operatorId,
     exec::DriverCtx* driverCtx,
     std::shared_ptr<const core::HashJoinNode> joinNode)
-    : exec::Operator(
+    : CudfOperatorBase(
+          operatorId,
           driverCtx,
           joinNode->outputType(),
-          operatorId,
           joinNode->id(),
-          "CudfHashJoinProbe"),
-      NvtxHelper(
+          "CudfHashJoinProbe",
           nvtx3::rgb{0, 128, 128}, // Teal
-          operatorId,
-          fmt::format("[{}]", joinNode->id())),
-      joinNode_(joinNode) {
-  if (cudfDebugEnabled()) {
-    std::cout << "CudfHashJoinProbe constructor" << std::endl;
-  }
-  auto probeType = joinNode_->sources()[0]->outputType();
-  auto buildType = joinNode_->sources()[1]->outputType();
+          NvtxMethodFlag::kAll,
+          std::nullopt, // spillConfig
+          joinNode),
+      joinNode_(joinNode),
+      probeType_(joinNode_->sources()[0]->outputType()),
+      buildType_(joinNode_->sources()[1]->outputType()),
+      cudaEvent_(std::make_unique<CudaEvent>(cudaEventDisableTiming)) {
   auto const& leftKeys = joinNode_->leftKeys(); // probe keys
   auto const& rightKeys = joinNode_->rightKeys(); // build keys
 
-  if (cudfDebugEnabled()) {
-    for (int i = 0; i < probeType->names().size(); i++) {
-      std::cout << "Left column " << i << ": " << probeType->names()[i]
-                << std::endl;
+  if (CudfConfig::getInstance().debugEnabled) {
+    for (int i = 0; i < probeType_->names().size(); i++) {
+      VLOG(1) << "Left column " << i << ": " << probeType_->names()[i];
     }
 
-    for (int i = 0; i < buildType->names().size(); i++) {
-      std::cout << "Right column " << i << ": " << buildType->names()[i]
-                << std::endl;
+    for (int i = 0; i < buildType_->names().size(); i++) {
+      VLOG(1) << "Right column " << i << ": " << buildType_->names()[i];
     }
 
     for (int i = 0; i < leftKeys.size(); i++) {
-      std::cout << "Left key " << i << ": " << leftKeys[i]->name() << " "
-                << leftKeys[i]->type()->kind() << std::endl;
+      VLOG(1) << "Left key " << i << ": " << leftKeys[i]->name() << " "
+              << leftKeys[i]->type()->kind();
     }
 
     for (int i = 0; i < rightKeys.size(); i++) {
-      std::cout << "Right key " << i << ": " << rightKeys[i]->name() << " "
-                << rightKeys[i]->type()->kind() << std::endl;
+      VLOG(1) << "Right key " << i << ": " << rightKeys[i]->name() << " "
+              << rightKeys[i]->type()->kind();
     }
   }
 
-  auto const probeTableNumColumns = probeType->size();
+  auto const probeTableNumColumns = probeType_->size();
   leftKeyIndices_ = std::vector<cudf::size_type>(leftKeys.size());
   for (size_t i = 0; i < leftKeyIndices_.size(); i++) {
     leftKeyIndices_[i] = static_cast<cudf::size_type>(
-        probeType->getChildIdx(leftKeys[i]->name()));
+        probeType_->getChildIdx(leftKeys[i]->name()));
     VELOX_CHECK_LT(leftKeyIndices_[i], probeTableNumColumns);
   }
-  auto const buildTableNumColumns = buildType->size();
+  auto const buildTableNumColumns = buildType_->size();
   rightKeyIndices_ = std::vector<cudf::size_type>(rightKeys.size());
   for (size_t i = 0; i < rightKeyIndices_.size(); i++) {
     rightKeyIndices_[i] = static_cast<cudf::size_type>(
-        buildType->getChildIdx(rightKeys[i]->name()));
+        buildType_->getChildIdx(rightKeys[i]->name()));
     VELOX_CHECK_LT(rightKeyIndices_[i], buildTableNumColumns);
   }
 
@@ -298,85 +366,129 @@ CudfHashJoinProbe::CudfHashJoinProbe(
   rightColumnOutputIndices_ = std::vector<size_t>();
   for (int i = 0; i < outputType->names().size(); i++) {
     auto const outputName = outputType->names()[i];
-    if (cudfDebugEnabled()) {
-      std::cout << "Output column " << i << ": " << outputName << std::endl;
+    if (CudfConfig::getInstance().debugEnabled) {
+      VLOG(1) << "Output column " << i << ": " << outputName;
     }
-    auto channel = probeType->getChildIdxIfExists(outputName);
+    auto channel = probeType_->getChildIdxIfExists(outputName);
     if (channel.has_value()) {
       leftColumnIndicesToGather_.push_back(
           static_cast<cudf::size_type>(channel.value()));
       leftColumnOutputIndices_.push_back(i);
       continue;
     }
-    channel = buildType->getChildIdxIfExists(outputName);
+    channel = buildType_->getChildIdxIfExists(outputName);
     if (channel.has_value()) {
       rightColumnIndicesToGather_.push_back(
           static_cast<cudf::size_type>(channel.value()));
       rightColumnOutputIndices_.push_back(i);
       continue;
     }
+    // For LEFT SEMI PROJECT, the last column is the boolean "match" column
+    // which is not in probe or build types - skip it here, handled separately
+    if (isLeftSemiProjectJoin(joinNode_->joinType()) &&
+        i == outputType->size() - 1 &&
+        outputType->childAt(i)->kind() == TypeKind::BOOLEAN) {
+      continue;
+    }
     VELOX_FAIL(
         "Join field {} not in probe or build input", outputType->children()[i]);
   }
 
-  if (cudfDebugEnabled()) {
+  if (CudfConfig::getInstance().debugEnabled) {
     for (int i = 0; i < leftColumnIndicesToGather_.size(); i++) {
-      std::cout << "Left index to gather " << i << ": "
-                << leftColumnIndicesToGather_[i] << std::endl;
+      VLOG(1) << "Left index to gather " << i << ": "
+              << leftColumnIndicesToGather_[i];
     }
 
     for (int i = 0; i < rightColumnIndicesToGather_.size(); i++) {
-      std::cout << "Right index to gather " << i << ": "
-                << rightColumnIndicesToGather_[i] << std::endl;
+      VLOG(1) << "Right index to gather " << i << ": "
+              << rightColumnIndicesToGather_[i];
     }
   }
+}
 
-  // Setup filter in case it exists
-  if (joinNode_->filter()) {
-    // simplify expression
-    exec::ExprSet exprs({joinNode_->filter()}, operatorCtx_->execCtx());
-    VELOX_CHECK_EQ(exprs.exprs().size(), 1);
+void CudfHashJoinProbe::initialize() {
+  Operator::initialize();
 
-    // We don't need to get tables that contain conditional comparison columns
-    // We'll pass the entire table. The ast will handle finding the required
-    // columns. This is required because we build the ast with whole row schema
-    // and the column locations in that schema translate to column locations
-    // in whole tables
+  if (!joinNode_->filter()) {
+    return;
+  }
+
+  // simplify expression
+  exec::ExprSet exprs({joinNode_->filter()}, operatorCtx_->execCtx());
+  VELOX_CHECK_EQ(exprs.exprs().size(), 1);
 
+  // For now we disable AST-based filtering (and force precomputation)
+  // if the filter expression contains decimal types, using the same
+  // shallow search as used for regular expression evaluation.
+  if (containsDecimalType(exprs.exprs()[0], false)) {
+    useAstFilter_ = false;
+  }
+
+  // Validate AST filtering for this join type now to avoid run-time error.
+  if (joinNode_->isRightSemiFilterJoin() || joinNode_->isLeftSemiFilterJoin() ||
+      joinNode_->isAntiJoin()) {
+    VELOX_CHECK(
+        useAstFilter_,
+        "AST expression evaluation must be enabled for semi-filter and anti joins.");
+  }
+
+  // Create a reusable evaluator for the filter column. This is expensive to
+  // build, and the expression + input schema are stable for the lifetime of
+  // the operator instance.
+  std::vector<velox::RowTypePtr> filterRowTypes{probeType_, buildType_};
+  filterEvaluator_ = createCudfExpression(
+      exprs.exprs()[0], facebook::velox::type::concatRowTypes(filterRowTypes));
+
+  // Check if the filter expression spans both join sides (e.g., switch
+  // expressions referencing columns from both probe and build). If so, we
+  // cannot use AST-based filtering and must fall back to filterEvaluator_.
+  if (hasNonAstSubexprSpanningBothSides(
+          exprs.exprs()[0], probeType_, buildType_)) {
+    VLOG(1) << "Filter expression spans both join sides, using "
+               "filterEvaluator_ instead of AST";
+    useAstFilter_ = false;
+    return;
+  }
+
+  // We don't need to get tables that contain conditional comparison columns
+  // We'll pass the entire table. The ast will handle finding the required
+  // columns. This is required because we build the ast with whole row schema
+  // and the column locations in that schema translate to column locations
+  // in whole tables
+
+  if (useAstFilter_) {
     // create ast tree
-    std::vector<PrecomputeInstruction> rightPrecomputeInstructions;
-    std::vector<PrecomputeInstruction> leftPrecomputeInstructions;
     if (joinNode_->isRightJoin() || joinNode_->isRightSemiFilterJoin()) {
       createAstTree(
           exprs.exprs()[0],
           tree_,
           scalars_,
-          buildType,
-          probeType,
-          rightPrecomputeInstructions,
-          leftPrecomputeInstructions);
+          buildType_,
+          probeType_,
+          rightPrecomputeInstructions_,
+          leftPrecomputeInstructions_);
     } else {
       createAstTree(
           exprs.exprs()[0],
           tree_,
           scalars_,
-          probeType,
-          buildType,
-          leftPrecomputeInstructions,
-          rightPrecomputeInstructions);
-    }
-    if (leftPrecomputeInstructions.size() > 0 ||
-        rightPrecomputeInstructions.size() > 0) {
-      VELOX_NYI("Filters that require precomputation are not yet supported");
+          probeType_,
+          buildType_,
+          leftPrecomputeInstructions_,
+          rightPrecomputeInstructions_);
     }
   }
 }
 
 bool CudfHashJoinProbe::needsInput() const {
-  return !finished_ && input_ == nullptr;
+  if (joinNode_->isRightSemiFilterJoin()) {
+    return !noMoreInput_;
+  }
+  return !noMoreInput_ && !finished_ && input_ == nullptr;
 }
 
-void CudfHashJoinProbe::addInput(RowVectorPtr input) {
+void CudfHashJoinProbe::doAddInput(RowVectorPtr input) {
   if (skipInput_) {
     VELOX_CHECK_NULL(input_);
     return;
@@ -385,165 +497,767 @@ void CudfHashJoinProbe::addInput(RowVectorPtr input) {
   VELOX_CHECK_NOT_NULL(cudfInput);
   // Count nulls in join key columns
   auto [_, null_count] = cudf::bitmask_and(
-      cudfInput->getTableView(),
-      cudfInput->stream(),
-      cudf::get_current_device_resource_ref());
+      cudfInput->getTableView(), cudfInput->stream(), get_temp_mr());
   {
     // Update statistics for null keys in join operator.
     auto lockedStats = stats_.wlock();
     lockedStats->numNullKeys += null_count;
   }
-  input_ = std::move(input);
+  if (joinNode_->isRightSemiFilterJoin()) {
+    // Queue inputs and process all at once
+    if (input->size() > 0) {
+      inputs_.push_back(std::move(cudfInput));
+    }
+    return;
+  }
+
+  if (input->size() > 0) {
+    input_ = std::move(input);
+  }
 }
 
-RowVectorPtr CudfHashJoinProbe::getOutput() {
-  if (cudfDebugEnabled()) {
-    std::cout << "Calling CudfHashJoinProbe::getOutput" << std::endl;
+void CudfHashJoinProbe::doNoMoreInput() {
+  Operator::noMoreInput();
+  if (!joinNode_->isRightJoin() && !joinNode_->isRightSemiFilterJoin() &&
+      !joinNode_->isFullJoin()) {
+    return;
+  }
+  std::vector<ContinuePromise> promises;
+  std::vector<std::shared_ptr<exec::Driver>> peers;
+  // Only last driver collects all answers
+  if (!operatorCtx_->task()->allPeersFinished(
+          planNodeId(), operatorCtx_->driver(), &future_, promises, peers)) {
+    return;
   }
-  VELOX_NVTX_OPERATOR_FUNC_RANGE();
 
-  if (finished_ or !hashObject_.has_value()) {
-    return nullptr;
+  SCOPE_EXIT {
+    // Realize the promises so that the other Drivers (which were not
+    // the last to finish) can continue from the barrier and finish.
+    peers.clear();
+    for (auto& promise : promises) {
+      promise.setValue();
+    }
+  };
+
+  if (joinNode_->isRightJoin() || joinNode_->isFullJoin()) {
+    isLastDriver_ = true;
+    if (hashObject_.has_value()) {
+      auto stream = cudfGlobalStreamPool().get_stream();
+
+      // The allPeersFinished barrier above synchronizes CPU threads, but not
+      // GPU streams. A driver's CPU thread may return from getOutput() while
+      // its GPU work (updating rightMatchedFlags_) is still in flight.
+      // join_streams establishes GPU-side ordering so that all probe stream
+      // operations complete before the BITWISE_OR reads below.
+      // Drivers without lastProbeStream_ (no probe batches) are skipped:
+      // their flags are all-false from host-synchronized init with no pending
+      // GPU work.
+      std::vector<rmm::cuda_stream_view> inputStreams;
+      if (lastProbeStream_.has_value()) {
+        inputStreams.push_back(lastProbeStream_.value());
+      }
+      for (auto& peer : peers) {
+        if (peer.get() == operatorCtx_->driver()) {
+          continue;
+        }
+        auto op = peer->findOperator(planNodeId());
+        auto* probe = dynamic_cast<CudfHashJoinProbe*>(op);
+        if (probe != nullptr && probe->lastProbeStream_.has_value()) {
+          inputStreams.push_back(probe->lastProbeStream_.value());
+        }
+      }
+      if (!inputStreams.empty()) {
+        cudf::detail::join_streams(inputStreams, stream);
+      }
+
+      for (auto& peer : peers) {
+        if (peer.get() == operatorCtx_->driver()) {
+          continue;
+        }
+        auto op = peer->findOperator(planNodeId());
+        auto* probe = dynamic_cast<CudfHashJoinProbe*>(op);
+        if (probe == nullptr) {
+          continue;
+        }
+        // Combine flags per partition using cuDF bitwise OR
+        // DM: This needs a relook. This is for when build side exceeds cudf
+        // size_type limits. In case of multiple right side chunks, I'm not sure
+        // if partitions to combine are in the same place p
+        for (size_t p = 0; p < rightMatchedFlags_.size(); ++p) {
+          auto or_result = cudf::binary_operation(
+              rightMatchedFlags_[p]->view(),
+              probe->rightMatchedFlags_[p]->view(),
+              cudf::binary_operator::BITWISE_OR,
+              cudf::data_type{cudf::type_id::BOOL8},
+              stream,
+              get_temp_mr());
+          // binary_operation is async on `stream`; the old column destructs via
+          // cudaFreeAsync on its allocation stream (not `stream`), so the free
+          // can race the kernel. Drain `stream` before the move-assign.
+          stream.synchronize();
+          rightMatchedFlags_[p] = std::move(or_result);
+        }
+      }
+      stream.synchronize();
+    }
+    return;
   }
 
-  if (!input_) {
-    return nullptr;
+  // Handling RightSemiFilterJoin
+  // Collect results from peers
+  for (auto& peer : peers) {
+    auto op = peer->findOperator(planNodeId());
+    auto* probe = dynamic_cast<CudfHashJoinProbe*>(op);
+    VELOX_CHECK_NOT_NULL(probe);
+    inputs_.insert(inputs_.end(), probe->inputs_.begin(), probe->inputs_.end());
   }
-  auto cudfInput = std::dynamic_pointer_cast<CudfVector>(input_);
-  VELOX_CHECK_NOT_NULL(cudfInput);
-  auto stream = cudfInput->stream();
-  auto leftTable = cudfInput->release(); // probe table
-  if (cudfDebugEnabled()) {
-    std::cout << "Probe table number of columns: " << leftTable->num_columns()
-              << std::endl;
-    std::cout << "Probe table number of rows: " << leftTable->num_rows()
-              << std::endl;
-  }
-
-  // TODO pass the input pool !!!
-  // TODO: We should probably subset columns before calling to_cudf_table?
-  // Maybe that isn't a problem if we fuse operators together.
-  auto& rightTable = hashObject_.value().first;
-  auto& hb = hashObject_.value().second;
-  VELOX_CHECK_NOT_NULL(rightTable);
-  if (cudfDebugEnabled()) {
-    if (rightTable != nullptr)
-      printf(
-          "right_table is not nullptr %p hasValue(%d)\n",
-          rightTable.get(),
-          hashObject_.has_value());
-    if (hb != nullptr)
-      printf(
-          "hb is not nullptr %p hasValue(%d)\n",
-          hb.get(),
-          hashObject_.has_value());
+
+  auto stream = cudfGlobalStreamPool().get_stream();
+  // Using output_mr here to allow spilling queued up large tables
+  auto tbl = getConcatenatedTable(
+      std::exchange(inputs_, {}),
+      joinNode_->sources()[1]->outputType(),
+      stream,
+      get_output_mr());
+
+  VELOX_CHECK_NOT_NULL(tbl);
+
+  if (CudfConfig::getInstance().debugEnabled) {
+    VLOG(1) << "Probe table number of columns: " << tbl->num_columns();
+    VLOG(1) << "Probe table number of rows: " << tbl->num_rows();
   }
 
-  // Special case for null-aware anti join where
-  // build table is not empty, no nulls, and probe table has nulls
-  if (joinNode_->isNullAware() and !joinNode_->filter()) {
-    auto const rightTableHasNulls =
-        cudf::has_nulls(rightTable->view().select(rightKeyIndices_));
-    auto const leftTableHasNulls =
-        cudf::has_nulls(leftTable->view().select(leftKeyIndices_));
-    if (rightTable->num_rows() > 0 and !rightTableHasNulls and
-        leftTableHasNulls) {
-      // drop nulls on probe table
-      leftTable = cudf::drop_nulls(
-          leftTable->view(),
-          leftKeyIndices_,
+  // Store the concatenated table in input_
+  input_ = std::make_shared<CudfVector>(
+      operatorCtx_->pool(),
+      joinNode_->outputType(),
+      tbl->num_rows(),
+      std::move(tbl),
+      stream);
+}
+
+std::unique_ptr<cudf::table> CudfHashJoinProbe::unfilteredOutput(
+    cudf::table_view leftTableView,
+    cudf::column_view leftIndicesCol,
+    cudf::table_view rightTableView,
+    cudf::column_view rightIndicesCol,
+    rmm::cuda_stream_view stream) {
+  std::vector<std::unique_ptr<cudf::column>> joinedCols;
+  auto leftInput = leftTableView.select(leftColumnIndicesToGather_);
+  auto rightInput = rightTableView.select(rightColumnIndicesToGather_);
+  auto leftResult = cudf::gather(
+      leftInput, leftIndicesCol, oobPolicy, stream, get_output_mr());
+  auto rightResult = cudf::gather(
+      rightInput, rightIndicesCol, oobPolicy, stream, get_output_mr());
+
+  if (CudfConfig::getInstance().debugEnabled) {
+    VLOG(1) << "Left result number of columns: " << leftResult->num_columns();
+    VLOG(1) << "Right result number of columns: " << rightResult->num_columns();
+  }
+
+  auto leftCols = leftResult->release();
+  auto rightCols = rightResult->release();
+  joinedCols.resize(outputType_->names().size());
+  for (int i = 0; i < leftColumnOutputIndices_.size(); i++) {
+    joinedCols[leftColumnOutputIndices_[i]] = std::move(leftCols[i]);
+  }
+  for (int i = 0; i < rightColumnOutputIndices_.size(); i++) {
+    joinedCols[rightColumnOutputIndices_[i]] = std::move(rightCols[i]);
+  }
+  if (buildStream_.has_value()) {
+    // Ensure deallocation of build table happens after probe gathers
+    cudaEvent_->recordFrom(stream).waitOn(buildStream_.value());
+  }
+  stream.synchronize();
+  return std::make_unique<cudf::table>(std::move(joinedCols));
+}
+
+std::unique_ptr<cudf::table> CudfHashJoinProbe::filteredOutput(
+    cudf::table_view leftTableView,
+    cudf::column_view leftIndicesCol,
+    cudf::table_view rightTableView,
+    cudf::column_view rightIndicesCol,
+    std::function<std::vector<std::unique_ptr<cudf::column>>(
+        std::vector<std::unique_ptr<cudf::column>>&&,
+        cudf::column_view)> func,
+    rmm::cuda_stream_view stream) {
+  auto leftResult = cudf::gather(
+      leftTableView, leftIndicesCol, oobPolicy, stream, get_output_mr());
+  auto rightResult = cudf::gather(
+      rightTableView, rightIndicesCol, oobPolicy, stream, get_output_mr());
+  auto leftColsSize = leftResult->num_columns();
+  auto rightColsSize = rightResult->num_columns();
+
+  std::vector<std::unique_ptr<cudf::column>> joinedCols = leftResult->release();
+  auto rightCols = rightResult->release();
+  joinedCols.insert(
+      joinedCols.end(),
+      std::make_move_iterator(rightCols.begin()),
+      std::make_move_iterator(rightCols.end()));
+
+  VELOX_CHECK_NOT_NULL(
+      filterEvaluator_,
+      "Join filter evaluator must be initialized before filteredOutput()");
+  std::vector<cudf::column_view> joinedColViews;
+  joinedColViews.reserve(joinedCols.size());
+  for (const auto& col : joinedCols) {
+    joinedColViews.push_back(col->view());
+  }
+  auto filterColumns =
+      filterEvaluator_->eval(joinedColViews, stream, get_output_mr());
+  auto filterColumn = asView(filterColumns);
+
+  joinedCols = func(std::move(joinedCols), filterColumn);
+
+  auto filteredjoinedCols =
+      std::vector<std::unique_ptr<cudf::column>>(outputType_->names().size());
+  for (int i = 0; i < leftColumnOutputIndices_.size(); i++) {
+    filteredjoinedCols[leftColumnOutputIndices_[i]] =
+        std::move(joinedCols[leftColumnIndicesToGather_[i]]);
+  }
+  for (int i = 0; i < rightColumnOutputIndices_.size(); i++) {
+    filteredjoinedCols[rightColumnOutputIndices_[i]] =
+        std::move(joinedCols[leftColsSize + rightColumnIndicesToGather_[i]]);
+  }
+  joinedCols = std::move(filteredjoinedCols);
+  if (buildStream_.has_value()) {
+    // Ensure any deallocation of join indices is ordered wrt probe gathers
+    cudaEvent_->recordFrom(stream).waitOn(buildStream_.value());
+  }
+  stream.synchronize();
+  return std::make_unique<cudf::table>(std::move(joinedCols));
+}
+
+std::unique_ptr<cudf::table> CudfHashJoinProbe::filteredOutputIndices(
+    cudf::table_view leftTableView,
+    cudf::column_view leftIndicesCol,
+    cudf::table_view rightTableView,
+    cudf::column_view rightIndicesCol,
+    cudf::table_view extendedLeftView,
+    cudf::table_view extendedRightView,
+    cudf::join_kind joinKind,
+    rmm::cuda_stream_view stream) {
+  // Use extended views (with precomputed columns) for filter evaluation
+  auto [filteredLeftJoinIndices, filteredRightJoinIndices] =
+      cudf::filter_join_indices(
+          extendedLeftView,
+          extendedRightView,
+          leftIndicesCol,
+          rightIndicesCol,
+          tree_.back(),
+          joinKind,
           stream,
-          cudf::get_current_device_resource_ref());
-    }
+          get_temp_mr());
+
+  auto filteredLeftIndicesSpan =
+      cudf::device_span<cudf::size_type const>{*filteredLeftJoinIndices};
+  auto filteredRightIndicesSpan =
+      cudf::device_span<cudf::size_type const>{*filteredRightJoinIndices};
+  auto filteredLeftIndicesCol = cudf::column_view{filteredLeftIndicesSpan};
+  auto filteredRightIndicesCol = cudf::column_view{filteredRightIndicesSpan};
+  // Use original views (without precomputed columns) for gathering output
+  return unfilteredOutput(
+      leftTableView,
+      filteredLeftIndicesCol,
+      rightTableView,
+      filteredRightIndicesCol,
+      stream);
+}
+
+std::vector<std::unique_ptr<cudf::table>> CudfHashJoinProbe::innerJoin(
+    cudf::table_view leftTableView,
+    rmm::cuda_stream_view stream) {
+  std::vector<std::unique_ptr<cudf::table>> cudfOutputs;
+
+  auto& rightTables = hashObject_.value().first;
+  auto& hbs = hashObject_.value().second;
+
+  // Precompute left (probe) table columns if needed (once, outside loop)
+  std::vector<ColumnOrView> leftPrecomputed;
+  cudf::table_view extendedLeftView = leftTableView;
+  if (joinNode_->filter() && useAstFilter_ &&
+      !leftPrecomputeInstructions_.empty()) {
+    auto leftColumnViews = tableViewToColumnViews(leftTableView);
+    leftPrecomputed = precomputeSubexpressions(
+        leftColumnViews,
+        leftPrecomputeInstructions_,
+        scalars_,
+        probeType_,
+        stream);
+    extendedLeftView = createExtendedTableView(leftTableView, leftPrecomputed);
   }
 
-  std::unique_ptr<rmm::device_uvector<cudf::size_type>> leftJoinIndices;
-  std::unique_ptr<rmm::device_uvector<cudf::size_type>> rightJoinIndices;
+  for (auto i = 0; i < rightTables.size(); i++) {
+    auto rightTableView = rightTables[i]->view();
+    auto& hb = hbs[i];
 
-  auto leftTableView = leftTable->view();
-  auto rightTableView = rightTable->view();
+    // Use cached precomputed columns for right (build) table
+    cudf::table_view extendedRightView =
+        (joinNode_->filter() && useAstFilter_ &&
+         !rightPrecomputeInstructions_.empty())
+        ? cachedExtendedRightViews_[i]
+        : rightTableView;
 
-  if (joinNode_->isInnerJoin()) {
     // left = probe, right = build
+    VELOX_CHECK_NOT_NULL(hb);
+    if (buildStream_.has_value()) {
+      // Make build stream wait for probe tables to become valid
+      cudaEvent_->recordFrom(stream).waitOn(buildStream_.value());
+    }
+    auto [leftJoinIndices, rightJoinIndices] = hb->inner_join(
+        leftTableView.select(leftKeyIndices_),
+        std::nullopt,
+        buildStream_.has_value() ? buildStream_.value() : stream,
+        get_temp_mr());
+    if (buildStream_.has_value()) {
+      // Make probe stream wait for join completion before using indices
+      cudaEvent_->recordFrom(buildStream_.value()).waitOn(stream);
+    }
+
+    auto leftIndicesSpan =
+        cudf::device_span<cudf::size_type const>{*leftJoinIndices};
+    auto rightIndicesSpan =
+        cudf::device_span<cudf::size_type const>{*rightJoinIndices};
+    auto leftIndicesCol = cudf::column_view{leftIndicesSpan};
+    auto rightIndicesCol = cudf::column_view{rightIndicesSpan};
+    std::vector<std::unique_ptr<cudf::column>> joinedCols;
+
     if (joinNode_->filter()) {
-      std::tie(leftJoinIndices, rightJoinIndices) = cudf::mixed_inner_join(
-          leftTableView.select(leftKeyIndices_),
-          rightTableView.select(rightKeyIndices_),
+      if (useAstFilter_) {
+        cudfOutputs.push_back(filteredOutputIndices(
+            leftTableView,
+            leftIndicesCol,
+            rightTableView,
+            rightIndicesCol,
+            extendedLeftView,
+            extendedRightView,
+            cudf::join_kind::INNER_JOIN,
+            stream));
+      } else {
+        auto filterFunc =
+            [stream](
+                std::vector<std::unique_ptr<cudf::column>>&& joinedCols,
+                cudf::column_view filterColumn) {
+              auto filterTable =
+                  std::make_unique<cudf::table>(std::move(joinedCols));
+              auto filteredTable = cudf::apply_boolean_mask(
+                  *filterTable, filterColumn, stream, get_output_mr());
+              return filteredTable->release();
+            };
+        cudfOutputs.push_back(filteredOutput(
+            leftTableView,
+            leftIndicesCol,
+            rightTableView,
+            rightIndicesCol,
+            filterFunc,
+            stream));
+      }
+    } else {
+      cudfOutputs.push_back(unfilteredOutput(
           leftTableView,
+          leftIndicesCol,
           rightTableView,
-          tree_.back(),
-          cudf::null_equality::UNEQUAL,
-          std::nullopt,
-          stream);
-    } else {
-      VELOX_CHECK_NOT_NULL(hb);
-      std::tie(leftJoinIndices, rightJoinIndices) = hb->inner_join(
-          leftTableView.select(leftKeyIndices_), std::nullopt, stream);
+          rightIndicesCol,
+          stream));
+    }
+  }
+  return cudfOutputs;
+}
+
+std::vector<std::unique_ptr<cudf::table>> CudfHashJoinProbe::leftJoin(
+    cudf::table_view leftTableView,
+    rmm::cuda_stream_view stream) {
+  std::vector<std::unique_ptr<cudf::table>> cudfOutputs;
+
+  auto& rightTables = hashObject_.value().first;
+  auto& hbs = hashObject_.value().second;
+
+  // Precompute left (probe) table columns if needed (once, outside loop)
+  std::vector<ColumnOrView> leftPrecomputed;
+  cudf::table_view extendedLeftView = leftTableView;
+  if (joinNode_->filter() && !leftPrecomputeInstructions_.empty()) {
+    auto leftColumnViews = tableViewToColumnViews(leftTableView);
+    leftPrecomputed = precomputeSubexpressions(
+        leftColumnViews,
+        leftPrecomputeInstructions_,
+        scalars_,
+        probeType_,
+        stream);
+    extendedLeftView = createExtendedTableView(leftTableView, leftPrecomputed);
+  }
+
+  for (auto i = 0; i < rightTables.size(); i++) {
+    auto rightTableView = rightTables[i]->view();
+    auto& hb = hbs[i];
+
+    // Use cached precomputed columns for right (build) table
+    cudf::table_view extendedRightView =
+        (joinNode_->filter() && !rightPrecomputeInstructions_.empty())
+        ? cachedExtendedRightViews_[i]
+        : rightTableView;
+
+    VELOX_CHECK_NOT_NULL(hb);
+    if (buildStream_.has_value()) {
+      cudaEvent_->recordFrom(stream).waitOn(buildStream_.value());
+    }
+    auto [leftJoinIndices, rightJoinIndices] = hb->left_join(
+        leftTableView.select(leftKeyIndices_),
+        std::nullopt,
+        buildStream_.has_value() ? buildStream_.value() : stream,
+        get_temp_mr());
+    if (buildStream_.has_value()) {
+      cudaEvent_->recordFrom(buildStream_.value()).waitOn(stream);
     }
-  } else if (joinNode_->isLeftJoin()) {
+
+    auto leftIndicesSpan =
+        cudf::device_span<cudf::size_type const>{*leftJoinIndices};
+    auto rightIndicesSpan =
+        cudf::device_span<cudf::size_type const>{*rightJoinIndices};
+    auto leftIndicesCol = cudf::column_view{leftIndicesSpan};
+    auto rightIndicesCol = cudf::column_view{rightIndicesSpan};
+    std::vector<std::unique_ptr<cudf::column>> joinedCols;
+
     if (joinNode_->filter()) {
-      std::tie(leftJoinIndices, rightJoinIndices) = cudf::mixed_left_join(
-          leftTableView.select(leftKeyIndices_),
-          rightTableView.select(rightKeyIndices_),
+      if (useAstFilter_) {
+        cudfOutputs.push_back(filteredOutputIndices(
+            leftTableView,
+            leftIndicesCol,
+            rightTableView,
+            rightIndicesCol,
+            extendedLeftView,
+            extendedRightView,
+            cudf::join_kind::LEFT_JOIN,
+            stream));
+      } else {
+        auto filterFunc =
+            [stream](
+                std::vector<std::unique_ptr<cudf::column>>&& joinedCols,
+                cudf::column_view filterColumn) {
+              auto filterTable =
+                  std::make_unique<cudf::table>(std::move(joinedCols));
+              auto filteredTable = cudf::apply_boolean_mask(
+                  *filterTable, filterColumn, stream, get_output_mr());
+              return filteredTable->release();
+            };
+        cudfOutputs.push_back(filteredOutput(
+            leftTableView,
+            leftIndicesCol,
+            rightTableView,
+            rightIndicesCol,
+            filterFunc,
+            stream));
+      }
+    } else {
+      cudfOutputs.push_back(unfilteredOutput(
           leftTableView,
+          leftIndicesCol,
           rightTableView,
-          tree_.back(),
-          cudf::null_equality::UNEQUAL,
-          std::nullopt,
-          stream);
-    } else {
-      VELOX_CHECK_NOT_NULL(hb);
-      std::tie(leftJoinIndices, rightJoinIndices) = hb->left_join(
-          leftTableView.select(leftKeyIndices_), std::nullopt, stream);
+          rightIndicesCol,
+          stream));
+    }
+  }
+  return cudfOutputs;
+}
+
+std::vector<std::unique_ptr<cudf::table>> CudfHashJoinProbe::rightJoin(
+    cudf::table_view leftTableView,
+    rmm::cuda_stream_view stream) {
+  std::vector<std::unique_ptr<cudf::table>> cudfOutputs;
+
+  auto& rightTables = hashObject_.value().first;
+  auto& hbs = hashObject_.value().second;
+
+  for (auto i = 0; i < rightTables.size(); i++) {
+    auto rightTableView = rightTables[i]->view();
+    auto& hb = hbs[i];
+
+    VELOX_CHECK_NOT_NULL(hb);
+    if (buildStream_.has_value()) {
+      cudaEvent_->recordFrom(stream).waitOn(buildStream_.value());
     }
-  } else if (joinNode_->isRightJoin()) {
+    auto [leftJoinIndices, rightJoinIndices] = hb->inner_join(
+        leftTableView.select(leftKeyIndices_),
+        std::nullopt,
+        buildStream_.has_value() ? buildStream_.value() : stream,
+        get_temp_mr());
+    if (buildStream_.has_value()) {
+      cudaEvent_->recordFrom(buildStream_.value()).waitOn(stream);
+    }
+    if (!joinNode_->filter()) {
+      // Mark matched build rows by checking which row indices appear in
+      // rightJoinIndices. Use contains to avoid scatter with duplicate indices.
+      auto rightIdxCol = cudf::column_view{
+          cudf::device_span<cudf::size_type const>{*rightJoinIndices}};
+
+      // Create sequence [0, 1, ..., n-1] for build table row indices
+      auto n = rightTableView.num_rows();
+      auto rowIndices = cudf::sequence(
+          n,
+          cudf::numeric_scalar<cudf::size_type>(0, true, stream, get_temp_mr()),
+          cudf::numeric_scalar<cudf::size_type>(1, true, stream, get_temp_mr()),
+          stream,
+          get_temp_mr());
+
+      // Check which build row indices are present in the join result
+      auto matchedInBatch = cudf::contains(
+          rightIdxCol, rowIndices->view(), stream, get_temp_mr());
+
+      // OR with existing flags to accumulate matches across batches
+      auto updatedFlags = cudf::binary_operation(
+          rightMatchedFlags_[i]->view(),
+          matchedInBatch->view(),
+          cudf::binary_operator::BITWISE_OR,
+          cudf::data_type{cudf::type_id::BOOL8},
+          stream,
+          get_temp_mr());
+      // binary_operation is async on `stream`; the old column destructs via
+      // cudaFreeAsync on its allocation stream (not `stream`), so the free
+      // can race the kernel. Drain `stream` before the move-assign.
+      stream.synchronize();
+      rightMatchedFlags_[i] = std::move(updatedFlags);
+    }
+
+    auto leftIndicesSpan =
+        cudf::device_span<cudf::size_type const>{*leftJoinIndices};
+    auto rightIndicesSpan =
+        cudf::device_span<cudf::size_type const>{*rightJoinIndices};
+    auto leftIndicesCol = cudf::column_view{leftIndicesSpan};
+    auto rightIndicesCol = cudf::column_view{rightIndicesSpan};
+    std::vector<std::unique_ptr<cudf::column>> joinedCols;
+
     if (joinNode_->filter()) {
-      std::tie(rightJoinIndices, leftJoinIndices) = cudf::mixed_left_join(
-          rightTableView.select(rightKeyIndices_),
-          leftTableView.select(leftKeyIndices_),
-          rightTableView,
+      auto& rightMatchedFlags = rightMatchedFlags_[i];
+      auto numBuildRows = rightTableView.num_rows();
+      auto filterFunc =
+          [&rightMatchedFlags, rightIndicesSpan, numBuildRows, stream](
+              std::vector<std::unique_ptr<cudf::column>>&& joinedCols,
+              cudf::column_view filterColumn) {
+            // apply the filter
+            auto filterTable =
+                std::make_unique<cudf::table>(std::move(joinedCols));
+            auto filteredTable = cudf::apply_boolean_mask(
+                *filterTable, filterColumn, stream, get_output_mr());
+            joinedCols = filteredTable->release();
+
+            // For streaming right join, after applying filter, we record
+            // matched right indices filter rightJoinIndices with the same mask
+            // to update matched flags
+            auto rightIdxCol = cudf::column_view{rightIndicesSpan};
+            auto filteredIdxTable = cudf::apply_boolean_mask(
+                cudf::table_view{std::vector<cudf::column_view>{rightIdxCol}},
+                filterColumn,
+                stream,
+                get_temp_mr());
+            auto filteredCols = filteredIdxTable->release();
+            auto filteredRightIdxCol = std::move(filteredCols[0]);
+
+            // Use contains to check which build row indices passed the filter
+            auto rowIndices = cudf::sequence(
+                numBuildRows,
+                cudf::numeric_scalar<cudf::size_type>(
+                    0, true, stream, get_temp_mr()),
+                cudf::numeric_scalar<cudf::size_type>(
+                    1, true, stream, get_temp_mr()),
+                stream,
+                get_temp_mr());
+
+            auto matchedInBatch = cudf::contains(
+                filteredRightIdxCol->view(),
+                rowIndices->view(),
+                stream,
+                get_temp_mr());
+
+            // OR with existing flags to accumulate matches across batches
+            auto updatedFlags = cudf::binary_operation(
+                rightMatchedFlags->view(),
+                matchedInBatch->view(),
+                cudf::binary_operator::BITWISE_OR,
+                cudf::data_type{cudf::type_id::BOOL8},
+                stream,
+                get_temp_mr());
+            // binary_operation is async on `stream`; the old column destructs
+            // via cudaFreeAsync on its allocation stream (not `stream`), so the
+            // free can race the kernel. Drain `stream` before the move-assign.
+            stream.synchronize();
+            rightMatchedFlags = std::move(updatedFlags);
+            return std::move(joinedCols);
+          };
+      cudfOutputs.push_back(filteredOutput(
           leftTableView,
-          tree_.back(),
-          cudf::null_equality::UNEQUAL,
-          std::nullopt,
-          stream);
+          leftIndicesCol,
+          rightTableView,
+          rightIndicesCol,
+          filterFunc,
+          stream));
     } else {
-      std::tie(rightJoinIndices, leftJoinIndices) = cudf::left_join(
-          rightTableView.select(rightKeyIndices_),
-          leftTableView.select(leftKeyIndices_),
-          cudf::null_equality::UNEQUAL,
+      cudfOutputs.push_back(unfilteredOutput(
+          leftTableView,
+          leftIndicesCol,
+          rightTableView,
+          rightIndicesCol,
+          stream));
+    }
+  }
+  return cudfOutputs;
+}
+
+std::vector<std::unique_ptr<cudf::table>> CudfHashJoinProbe::fullJoin(
+    cudf::table_view leftTableView,
+    rmm::cuda_stream_view stream) {
+  std::vector<std::unique_ptr<cudf::table>> cudfOutputs;
+
+  auto& rightTables = hashObject_.value().first;
+  auto& hbs = hashObject_.value().second;
+
+  // For now, AST support is necessary to filter join output
+  if (joinNode_->filter() && !useAstFilter_) {
+    VELOX_NYI("Full join requires AST support for filtering");
+  }
+
+  for (auto i = 0; i < rightTables.size(); i++) {
+    auto rightTableView = rightTables[i]->view();
+    auto& hb = hbs[i];
+
+    VELOX_CHECK_NOT_NULL(hb);
+    if (buildStream_.has_value()) {
+      cudaEvent_->recordFrom(stream).waitOn(buildStream_.value());
+    }
+    // Use left_join to get all probe rows (matched + unmatched).
+    // Track matched build rows in rightMatchedFlags_ for last driver to emit
+    // unmatched build rows at the end.
+    auto [leftJoinIndices, rightJoinIndices] = hb->left_join(
+        leftTableView.select(leftKeyIndices_),
+        std::nullopt,
+        buildStream_.has_value() ? buildStream_.value() : stream,
+        get_temp_mr());
+    if (buildStream_.has_value()) {
+      cudaEvent_->recordFrom(buildStream_.value()).waitOn(stream);
+    }
+    if (!joinNode_->filter()) {
+      // Mark matched build rows by checking which row indices appear in
+      // rightJoinIndices. Use contains to avoid scatter with duplicate indices.
+      auto rightIdxCol = cudf::column_view{
+          cudf::device_span<cudf::size_type const>{*rightJoinIndices}};
+
+      // Create sequence [0, 1, ..., n-1] for build table row indices
+      auto n = rightTableView.num_rows();
+      auto rowIndices = cudf::sequence(
+          n,
+          cudf::numeric_scalar<cudf::size_type>(0, true, stream, get_temp_mr()),
+          cudf::numeric_scalar<cudf::size_type>(1, true, stream, get_temp_mr()),
+          stream,
+          get_temp_mr());
+
+      // Check which build row indices are present in the join result
+      auto matchedInBatch = cudf::contains(
+          rightIdxCol, rowIndices->view(), stream, get_temp_mr());
+
+      // OR with existing flags to accumulate matches across batches
+      auto updatedFlags = cudf::binary_operation(
+          rightMatchedFlags_[i]->view(),
+          matchedInBatch->view(),
+          cudf::binary_operator::BITWISE_OR,
+          cudf::data_type{cudf::type_id::BOOL8},
           stream,
-          cudf::get_current_device_resource_ref());
+          get_temp_mr());
+      // binary_operation is async on `stream`; the old column destructs via
+      // cudaFreeAsync on its allocation stream (not `stream`), so the free
+      // can race the kernel. Drain `stream` before the move-assign.
+      stream.synchronize();
+      rightMatchedFlags_[i] = std::move(updatedFlags);
     }
-  } else if (joinNode_->isAntiJoin()) {
+
+    auto leftIndicesSpan =
+        cudf::device_span<cudf::size_type const>{*leftJoinIndices};
+    auto rightIndicesSpan =
+        cudf::device_span<cudf::size_type const>{*rightJoinIndices};
+    auto leftIndicesCol = cudf::column_view{leftIndicesSpan};
+    auto rightIndicesCol = cudf::column_view{rightIndicesSpan};
+
     if (joinNode_->filter()) {
-      leftJoinIndices = cudf::mixed_left_anti_join(
-          leftTableView.select(leftKeyIndices_),
-          rightTableView.select(rightKeyIndices_),
+      // Use filter_join_indices with LEFT_JOIN to get proper full join probe
+      // semantics: all probe rows are kept, build columns are NULL when filter
+      // fails or no match.
+      auto [filteredLeftJoinIndices, filteredRightJoinIndices] =
+          cudf::filter_join_indices(
+              leftTableView,
+              rightTableView,
+              leftIndicesCol,
+              rightIndicesCol,
+              tree_.back(),
+              cudf::join_kind::LEFT_JOIN,
+              stream,
+              get_temp_mr());
+
+      // Track matched build rows for unmatched row emission at end.
+      // Use contains to check which build row indices passed the filter.
+      auto& rightMatchedFlags = rightMatchedFlags_[i];
+      auto filteredRightIndicesSpan =
+          cudf::device_span<cudf::size_type const>{*filteredRightJoinIndices};
+      auto filteredRightIdxCol = cudf::column_view{filteredRightIndicesSpan};
+
+      // Create sequence [0, 1, ..., n-1] for build table row indices
+      auto n = rightTableView.num_rows();
+      auto rowIndices = cudf::sequence(
+          n,
+          cudf::numeric_scalar<cudf::size_type>(0, true, stream, get_temp_mr()),
+          cudf::numeric_scalar<cudf::size_type>(1, true, stream, get_temp_mr()),
+          stream,
+          get_temp_mr());
+
+      // Check which build row indices are present in the filtered join result
+      auto matchedInBatch = cudf::contains(
+          filteredRightIdxCol, rowIndices->view(), stream, get_temp_mr());
+
+      // OR with existing flags to accumulate matches across batches
+      auto updatedFlags = cudf::binary_operation(
+          rightMatchedFlags->view(),
+          matchedInBatch->view(),
+          cudf::binary_operator::BITWISE_OR,
+          cudf::data_type{cudf::type_id::BOOL8},
+          stream,
+          get_temp_mr());
+      // binary_operation is async on `stream`; the old column destructs via
+      // cudaFreeAsync on its allocation stream (not `stream`), so the free
+      // can race the kernel. Drain `stream` before the move-assign.
+      stream.synchronize();
+      rightMatchedFlags = std::move(updatedFlags);
+
+      // Build output using filtered indices
+      auto filteredLeftIndicesSpan =
+          cudf::device_span<cudf::size_type const>{*filteredLeftJoinIndices};
+      auto filteredLeftIndicesCol = cudf::column_view{filteredLeftIndicesSpan};
+      auto filteredRightIndicesCol =
+          cudf::column_view{filteredRightIndicesSpan};
+      cudfOutputs.push_back(unfilteredOutput(
           leftTableView,
+          filteredLeftIndicesCol,
           rightTableView,
-          tree_.back(),
-          cudf::null_equality::UNEQUAL,
-          stream,
-          cudf::get_current_device_resource_ref());
+          filteredRightIndicesCol,
+          stream));
     } else {
-      auto const rightTableHasNulls =
-          cudf::has_nulls(rightTableView.select(rightKeyIndices_));
-      if (joinNode_->isNullAware() and rightTableHasNulls) {
-        // empty result
-        leftJoinIndices =
-            std::make_unique<rmm::device_uvector<cudf::size_type>>(
-                0, stream, cudf::get_current_device_resource_ref());
-      } else {
-        leftJoinIndices = cudf::left_anti_join(
-            leftTableView.select(leftKeyIndices_),
-            rightTableView.select(rightKeyIndices_),
-            cudf::null_equality::UNEQUAL,
-            stream,
-            cudf::get_current_device_resource_ref());
-      }
+      cudfOutputs.push_back(unfilteredOutput(
+          leftTableView,
+          leftIndicesCol,
+          rightTableView,
+          rightIndicesCol,
+          stream));
     }
-  } else if (joinNode_->isLeftSemiFilterJoin()) {
+  }
+  return cudfOutputs;
+}
+
+std::vector<std::unique_ptr<cudf::table>> CudfHashJoinProbe::leftSemiFilterJoin(
+    cudf::table_view leftTableView,
+    rmm::cuda_stream_view stream) {
+  std::vector<std::unique_ptr<cudf::table>> cudfOutputs;
+
+  auto& rightTables = hashObject_.value().first;
+
+  for (auto i = 0; i < rightTables.size(); i++) {
+    auto rightTableView = rightTables[i]->view();
+    std::unique_ptr<rmm::device_uvector<cudf::size_type>> leftJoinIndices;
+
     if (joinNode_->filter()) {
       leftJoinIndices = cudf::mixed_left_semi_join(
           leftTableView.select(leftKeyIndices_),
@@ -553,83 +1267,846 @@ RowVectorPtr CudfHashJoinProbe::getOutput() {
           tree_.back(),
           cudf::null_equality::UNEQUAL,
           stream,
-          cudf::get_current_device_resource_ref());
+          get_temp_mr());
     } else {
-      leftJoinIndices = cudf::left_semi_join(
-          leftTableView.select(leftKeyIndices_),
+      cudf::filtered_join filter_join(
           rightTableView.select(rightKeyIndices_),
           cudf::null_equality::UNEQUAL,
-          stream,
-          cudf::get_current_device_resource_ref());
+          stream);
+      leftJoinIndices = filter_join.semi_join(
+          leftTableView.select(leftKeyIndices_), stream, get_temp_mr());
     }
-  } else if (joinNode_->isRightSemiFilterJoin()) {
+
+    auto leftIndicesSpan =
+        cudf::device_span<cudf::size_type const>{*leftJoinIndices};
+    auto leftIndicesCol = cudf::column_view{leftIndicesSpan};
+    auto rightIndicesCol = cudf::empty_like(leftIndicesCol);
+
+    cudfOutputs.push_back(unfilteredOutput(
+        leftTableView,
+        leftIndicesCol,
+        rightTableView,
+        rightIndicesCol->view(),
+        stream));
+  }
+  return cudfOutputs;
+}
+
+namespace {
+/// Creates a boolean column indicating which rows have NULL in ANY key column.
+/// Returns a column where row[i] = true if ANY key column is NULL at row i.
+std::unique_ptr<cudf::column> createProbeKeyNullMask(
+    cudf::table_view keyView,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  auto numRows = keyView.num_rows();
+
+  if (keyView.num_columns() == 0 || numRows == 0) {
+    auto falseScalar = cudf::numeric_scalar<bool>(false, true, stream, mr);
+    return cudf::make_column_from_scalar(falseScalar, numRows, stream, mr);
+  }
+
+  // Start with first column's null mask
+  auto result = cudf::is_null(keyView.column(0), stream, mr);
+
+  // OR with other columns' null masks
+  for (cudf::size_type i = 1; i < keyView.num_columns(); i++) {
+    auto colIsNull = cudf::is_null(keyView.column(i), stream, mr);
+    result = cudf::binary_operation(
+        result->view(),
+        colIsNull->view(),
+        cudf::binary_operator::BITWISE_OR,
+        cudf::data_type{cudf::type_id::BOOL8},
+        stream,
+        mr);
+  }
+  return result;
+}
+
+/// Applies a null mask to a boolean column.
+/// Where nullMask[i] is true, result[i] becomes NULL.
+/// Where nullMask[i] is false, result[i] keeps its original value from col.
+std::unique_ptr<cudf::column> applyNullMask(
+    cudf::column_view col,
+    cudf::column_view nullMask,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  // Create a null scalar (valid=false means NULL)
+  auto nullScalar = cudf::numeric_scalar<bool>(false, false, stream, mr);
+
+  // copy_if_else: where nullMask is true, use nullScalar (NULL); else use col
+  // value
+  return cudf::copy_if_else(nullScalar, col, nullMask, stream, mr);
+}
+
+/// Get row indices where mask is true.
+/// Returns a column of size_type indices.
+std::unique_ptr<cudf::column> getIndicesWhere(
+    cudf::column_view mask,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  // Create sequence [0, 1, 2, ..., mask.size()-1]
+  auto seq = cudf::sequence(
+      mask.size(),
+      cudf::numeric_scalar<cudf::size_type>(0, true, stream, mr),
+      cudf::numeric_scalar<cudf::size_type>(1, true, stream, mr),
+      stream,
+      mr);
+
+  // Filter to keep only indices where mask is true
+  auto indicesTable = cudf::apply_boolean_mask(
+      cudf::table_view{{seq->view()}}, mask, stream, mr);
+
+  return std::move(indicesTable->release()[0]);
+}
+
+/// Create cross-product of two index columns.
+/// Given left = [a, b, c] and right = [x, y], produces:
+///   leftOut = [a, a, b, b, c, c]
+///   rightOut = [x, y, x, y, x, y]
+/// Uses cudf::repeat for left (repeat each element) and cudf::tile for right.
+std::pair<std::unique_ptr<cudf::column>, std::unique_ptr<cudf::column>>
+createCrossProductIndices(
+    cudf::column_view leftIndices,
+    cudf::column_view rightIndices,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  auto numLeft = leftIndices.size();
+  auto numRight = rightIndices.size();
+
+  if (numLeft == 0 || numRight == 0) {
+    // Return empty columns
+    auto emptyLeft = cudf::make_empty_column(cudf::type_id::INT32);
+    auto emptyRight = cudf::make_empty_column(cudf::type_id::INT32);
+    return {std::move(emptyLeft), std::move(emptyRight)};
+  }
+
+  // Repeat each left element numRight times: [a,a,b,b,c,c]
+  auto leftRepeated =
+      cudf::repeat(cudf::table_view{{leftIndices}}, numRight, stream, mr);
+
+  // Tile the right indices numLeft times: [x,y,x,y,x,y]
+  auto rightTiled =
+      cudf::tile(cudf::table_view{{rightIndices}}, numLeft, stream, mr);
+
+  return {
+      std::move(leftRepeated->release()[0]),
+      std::move(rightTiled->release()[0])};
+}
+
+} // namespace
+
+// LEFT SEMI PROJECT returns all probe rows with a boolean "match" column
+// indicating whether each probe row has at least one matching build row
+// (that also passes the filter, if specified). Unlike LEFT SEMI FILTER
+// which filters out non-matching rows, this preserves all probe rows.
+// Output cardinality always equals probe side cardinality.
+//
+// Implementation approach:
+// 1. Use inner_join to get valid (probe_idx, build_idx) pairs where keys match
+// 2. If filter exists, apply filter_join_indices(INNER_JOIN) to keep only
+//    pairs where the filter passes
+// 3. Use cudf::contains to check which probe row indices appear in the result.
+//    This correctly handles duplicate probe indices (when one probe row matches
+//    multiple build rows) by returning true if the index appears at least once.
+// 4. Accumulate matches across build table batches using BITWISE_OR
+// 5. For null-aware mode (without filter): apply null mask based on probe key
+//    nullity and build side null keys presence
+// 6. Output: all probe columns + match column
+std::vector<std::unique_ptr<cudf::table>>
+CudfHashJoinProbe::leftSemiProjectJoin(
+    cudf::table_view leftTableView,
+    rmm::cuda_stream_view stream) {
+  std::vector<std::unique_ptr<cudf::table>> cudfOutputs;
+
+  // For now, AST support is necessary to filter join output
+  if (joinNode_->filter() && !useAstFilter_) {
+    VELOX_NYI("Left semi project join requires AST support for filtering");
+  }
+
+  auto& rightTables = hashObject_.value().first;
+  auto& hbs = hashObject_.value().second;
+  auto numProbeRows = leftTableView.num_rows();
+
+  const bool isNullAware = joinNode_->isNullAware();
+  const bool hasFilter = joinNode_->filter() != nullptr;
+  // For null-aware without filter, we use a different code path (existing)
+  // For null-aware with filter, we need to compute indeterminate cases
+  const bool isNullAwareWithFilter = isNullAware && hasFilter;
+  const bool isNullAwareWithoutFilter = isNullAware && !hasFilter;
+
+  // Create probe row indices sequence: [0, 1, 2, ..., numProbeRows-1]
+  // Used with cudf::contains to create the match column
+  auto probeRowIndices = cudf::sequence(
+      numProbeRows,
+      cudf::numeric_scalar<cudf::size_type>(0, true, stream, get_temp_mr()),
+      cudf::numeric_scalar<cudf::size_type>(1, true, stream, get_temp_mr()),
+      stream,
+      get_temp_mr());
+
+  // Initialize match column to all false
+  auto falseScalar =
+      cudf::numeric_scalar<bool>(false, true, stream, get_output_mr());
+  auto matchCol = cudf::make_column_from_scalar(
+      falseScalar, numProbeRows, stream, get_output_mr());
+
+  // Precompute left (probe) table columns if needed for filter
+  std::vector<ColumnOrView> leftPrecomputed;
+  cudf::table_view extendedLeftView = leftTableView;
+  if (joinNode_->filter() && !leftPrecomputeInstructions_.empty()) {
+    auto leftColumnViews = tableViewToColumnViews(leftTableView);
+    leftPrecomputed = precomputeSubexpressions(
+        leftColumnViews,
+        leftPrecomputeInstructions_,
+        scalars_,
+        probeType_,
+        stream);
+    extendedLeftView = createExtendedTableView(leftTableView, leftPrecomputed);
+  }
+
+  for (auto i = 0; i < rightTables.size(); i++) {
+    auto rightTableView = rightTables[i]->view();
+    auto& hb = hbs[i];
+
+    // Use cached precomputed columns for right (build) table
+    cudf::table_view extendedRightView =
+        (joinNode_->filter() && !rightPrecomputeInstructions_.empty())
+        ? cachedExtendedRightViews_[i]
+        : rightTableView;
+
+    // Step 1: Inner join to get (probe_idx, build_idx) pairs where keys match.
+    // Unlike left_join, inner_join only returns valid pairs (no JoinNoMatch).
+    VELOX_CHECK_NOT_NULL(hb);
+    if (buildStream_.has_value()) {
+      // Make build stream wait for probe tables to become valid
+      cudaEvent_->recordFrom(stream).waitOn(buildStream_.value());
+    }
+    auto [leftJoinIndices, rightJoinIndices] = hb->inner_join(
+        leftTableView.select(leftKeyIndices_),
+        std::nullopt,
+        buildStream_.has_value() ? buildStream_.value() : stream,
+        get_temp_mr());
+    if (buildStream_.has_value()) {
+      // Make probe stream wait for join completion before using indices
+      cudaEvent_->recordFrom(buildStream_.value()).waitOn(stream);
+    }
+
+    if (leftJoinIndices->size() == 0) {
+      continue; // No matches from this build table
+    }
+
+    auto leftIndicesSpan =
+        cudf::device_span<cudf::size_type const>{*leftJoinIndices};
+    auto rightIndicesSpan =
+        cudf::device_span<cudf::size_type const>{*rightJoinIndices};
+    auto leftIndicesCol = cudf::column_view{leftIndicesSpan};
+    auto rightIndicesCol = cudf::column_view{rightIndicesSpan};
+
+    cudf::column_view matchedProbeIndices;
+    std::unique_ptr<rmm::device_uvector<cudf::size_type>> filteredLeftIndices;
+
     if (joinNode_->filter()) {
-      rightJoinIndices = cudf::mixed_left_semi_join(
-          rightTableView.select(rightKeyIndices_),
-          leftTableView.select(leftKeyIndices_),
-          rightTableView,
-          leftTableView,
+      // Step 2: Apply filter to the join pairs. INNER_JOIN mode keeps only
+      // pairs where the predicate evaluates to true.
+      auto [filteredLeft, filteredRight] = cudf::filter_join_indices(
+          extendedLeftView,
+          extendedRightView,
+          leftIndicesSpan,
+          rightIndicesSpan,
           tree_.back(),
-          cudf::null_equality::UNEQUAL,
+          cudf::join_kind::INNER_JOIN,
           stream,
-          cudf::get_current_device_resource_ref());
+          get_temp_mr());
+
+      filteredLeftIndices = std::move(filteredLeft);
+      if (filteredLeftIndices->size() == 0) {
+        continue; // No matches passed filter
+      }
+      auto filteredLeftSpan =
+          cudf::device_span<cudf::size_type const>{*filteredLeftIndices};
+      matchedProbeIndices = cudf::column_view{filteredLeftSpan};
     } else {
-      rightJoinIndices = cudf::left_semi_join(
-          rightTableView.select(rightKeyIndices_),
-          leftTableView.select(leftKeyIndices_),
-          cudf::null_equality::UNEQUAL,
+      // No filter - use inner join results directly
+      matchedProbeIndices = leftIndicesCol;
+    }
+
+    // Step 3: Create match flags using cudf::contains. For each probe row index
+    // in [0, numProbeRows), check if it appears in matchedProbeIndices.
+    // This handles duplicates correctly - if a probe row matches multiple build
+    // rows, it appears multiple times in matchedProbeIndices, but contains()
+    // returns true if it appears at least once.
+    auto matchedInBatch = cudf::contains(
+        matchedProbeIndices, probeRowIndices->view(), stream, get_temp_mr());
+
+    // Step 4: Accumulate matches across build table batches using OR.
+    // A probe row's final match value is true if it matched in ANY batch.
+    auto updatedMatch = cudf::binary_operation(
+        matchCol->view(),
+        matchedInBatch->view(),
+        cudf::binary_operator::BITWISE_OR,
+        cudf::data_type{cudf::type_id::BOOL8},
+        stream,
+        get_output_mr());
+    stream.synchronize();
+    matchCol = std::move(updatedMatch);
+  }
+
+  // Step 5: Handle null-aware semantics (IN vs EXISTS).
+  // For null-aware mode, we need to compute three-valued logic:
+  // - TRUE: at least one match passes filter
+  // - FALSE: no match passes filter AND no indeterminate cases
+  // - NULL: probe key is NULL, OR (no match AND build has null keys that might
+  // match)
+
+  if (isNullAwareWithFilter) {
+    // Null-aware LEFT SEMI PROJECT with filter implements SQL IN semantics:
+    //   SELECT t0 IN (SELECT u0 FROM u WHERE filter) FROM t
+    //
+    // "Indeterminate" means the result should be NULL (unknown) rather than
+    // FALSE. This happens when we cannot definitively say the probe value is
+    // NOT IN the subquery because NULL comparisons are involved:
+    //
+    // - Type B (null probe key): When probe key is NULL, we can't determine
+    //   if NULL equals any subquery value. If the filter passes for ANY build
+    //   row, result is NULL (might match). If filter fails for ALL build rows,
+    //   the subquery is empty, so result is FALSE.
+    //
+    // - Type A (non-null probe key, no match): When probe key doesn't match
+    //   any non-NULL build key, but build has NULL keys where filter passes,
+    //   we can't rule out a match (NULL might equal our probe key), so result
+    //   is NULL.
+    //
+    // We evaluate these by creating synthetic (probe, build) index pairs and
+    // running the filter to see if any pair passes.
+
+    // Lambda to create device_span from a column
+    auto toSpan = [](cudf::column_view col) {
+      return cudf::device_span<cudf::size_type const>{
+          static_cast<cudf::size_type const*>(col.head()),
+          static_cast<size_t>(col.size())};
+    };
+
+    // Lambda to run filter on synthetic pairs and accumulate indeterminate
+    // flags. Creates cross-product of probeIndices × buildIndices, runs the
+    // filter, and ORs any passing probe rows into indeterminateCol.
+    auto accumulateIndeterminate =
+        [&](cudf::column_view probeIndices,
+            cudf::column_view buildIndices,
+            cudf::table_view extendedRight,
+            std::unique_ptr<cudf::column>& indeterminateCol) {
+          if (probeIndices.size() == 0 || buildIndices.size() == 0) {
+            return;
+          }
+
+          auto [syntheticLeft, syntheticRight] = createCrossProductIndices(
+              probeIndices, buildIndices, stream, get_temp_mr());
+
+          if (syntheticLeft->size() == 0) {
+            return;
+          }
+
+          auto [filteredLeft, filteredRight] = cudf::filter_join_indices(
+              extendedLeftView,
+              extendedRight,
+              toSpan(syntheticLeft->view()),
+              toSpan(syntheticRight->view()),
+              tree_.back(),
+              cudf::join_kind::INNER_JOIN,
+              stream,
+              get_temp_mr());
+
+          if (filteredLeft->size() == 0) {
+            return;
+          }
+
+          auto filteredLeftSpan =
+              cudf::device_span<cudf::size_type const>{*filteredLeft};
+          auto filteredLeftCol = cudf::column_view{filteredLeftSpan};
+          auto indeterminate = cudf::contains(
+              filteredLeftCol, probeRowIndices->view(), stream, get_temp_mr());
+
+          indeterminateCol = cudf::binary_operation(
+              indeterminateCol->view(),
+              indeterminate->view(),
+              cudf::binary_operator::BITWISE_OR,
+              cudf::data_type{cudf::type_id::BOOL8},
+              stream,
+              get_temp_mr());
+        };
+
+    bool buildSideEmpty = true;
+    for (const auto& rt : rightTables) {
+      if (rt->num_rows() > 0) {
+        buildSideEmpty = false;
+        break;
+      }
+    }
+
+    // For empty build side, IN returns FALSE (already set in matchCol).
+    if (!buildSideEmpty) {
+      auto probeKeyView = leftTableView.select(leftKeyIndices_);
+      bool probeHasNulls = cudf::has_nulls(probeKeyView);
+
+      // Compute probe key null mask upfront
+      auto probeKeyNullMask =
+          createProbeKeyNullMask(probeKeyView, stream, get_temp_mr());
+
+      // Initialize indeterminate column to all false
+      auto falseScalar =
+          cudf::numeric_scalar<bool>(false, true, stream, get_temp_mr());
+      auto indeterminateCol = cudf::make_column_from_scalar(
+          falseScalar, numProbeRows, stream, get_temp_mr());
+
+      // Process each build batch for indeterminate cases
+      for (size_t i = 0; i < rightTables.size(); i++) {
+        auto rightTableView = rightTables[i]->view();
+        auto buildKeyView = rightTableView.select(rightKeyIndices_);
+        bool buildBatchHasNullKeys = cudf::has_nulls(buildKeyView);
+        auto numBuildRows = rightTableView.num_rows();
+
+        if (numBuildRows == 0) {
+          continue;
+        }
+
+        // Get extended views for filter evaluation
+        cudf::table_view extendedRightView =
+            (!rightPrecomputeInstructions_.empty())
+            ? cachedExtendedRightViews_[i]
+            : rightTableView;
+
+        // Type B: Null probe keys × all build rows
+        if (probeHasNulls) {
+          auto nullProbeIndices =
+              getIndicesWhere(probeKeyNullMask->view(), stream, get_temp_mr());
+          auto allBuildIndices = cudf::sequence(
+              numBuildRows,
+              cudf::numeric_scalar<cudf::size_type>(
+                  0, true, stream, get_temp_mr()),
+              cudf::numeric_scalar<cudf::size_type>(
+                  1, true, stream, get_temp_mr()),
+              stream,
+              get_temp_mr());
+
+          accumulateIndeterminate(
+              nullProbeIndices->view(),
+              allBuildIndices->view(),
+              extendedRightView,
+              indeterminateCol);
+        }
+
+        // Type A: Non-null, non-matching probe keys × null-key build rows
+        if (buildBatchHasNullKeys) {
+          auto notProbeNull = cudf::unary_operation(
+              probeKeyNullMask->view(),
+              cudf::unary_operator::NOT,
+              stream,
+              get_temp_mr());
+          auto noMatch = cudf::unary_operation(
+              matchCol->view(),
+              cudf::unary_operator::NOT,
+              stream,
+              get_temp_mr());
+          auto typeAMask = cudf::binary_operation(
+              notProbeNull->view(),
+              noMatch->view(),
+              cudf::binary_operator::BITWISE_AND,
+              cudf::data_type{cudf::type_id::BOOL8},
+              stream,
+              get_temp_mr());
+
+          auto typeAProbeIndices =
+              getIndicesWhere(typeAMask->view(), stream, get_temp_mr());
+          auto buildKeyNullMask =
+              createProbeKeyNullMask(buildKeyView, stream, get_temp_mr());
+          auto nullBuildIndices =
+              getIndicesWhere(buildKeyNullMask->view(), stream, get_temp_mr());
+
+          accumulateIndeterminate(
+              typeAProbeIndices->view(),
+              nullBuildIndices->view(),
+              extendedRightView,
+              indeterminateCol);
+        }
+      }
+
+      // Apply three-valued logic:
+      // - Where matchCol is TRUE → keep TRUE (takes precedence)
+      // - Where matchCol is FALSE and indeterminateCol is TRUE → set NULL
+      // - Where matchCol is FALSE and indeterminateCol is FALSE → keep FALSE
+      auto notMatch = cudf::unary_operation(
+          matchCol->view(), cudf::unary_operator::NOT, stream, get_temp_mr());
+      auto shouldBeNull = cudf::binary_operation(
+          notMatch->view(),
+          indeterminateCol->view(),
+          cudf::binary_operator::BITWISE_AND,
+          cudf::data_type{cudf::type_id::BOOL8},
           stream,
-          cudf::get_current_device_resource_ref());
+          get_temp_mr());
+
+      matchCol = applyNullMask(
+          matchCol->view(), shouldBeNull->view(), stream, get_output_mr());
+    }
+  } else if (isNullAwareWithoutFilter) {
+    // Original null-aware without filter logic
+    bool buildSideEmpty = true;
+    for (const auto& rt : rightTables) {
+      if (rt->num_rows() > 0) {
+        buildSideEmpty = false;
+        break;
+      }
+    }
+
+    // For empty build side, IN returns FALSE (already set in matchCol).
+    if (!buildSideEmpty) {
+      auto probeKeyView = leftTableView.select(leftKeyIndices_);
+      bool probeHasNulls = cudf::has_nulls(probeKeyView);
+
+      if (probeHasNulls || buildSideHasNullKeys_) {
+        // Compute null mask: true where result should be NULL
+        auto probeKeyNullMask =
+            createProbeKeyNullMask(probeKeyView, stream, get_temp_mr());
+
+        std::unique_ptr<cudf::column> nullMask;
+        if (buildSideHasNullKeys_) {
+          // NULL where: probe key is NULL OR no match
+          auto noMatchMask = cudf::unary_operation(
+              matchCol->view(),
+              cudf::unary_operator::NOT,
+              stream,
+              get_temp_mr());
+          nullMask = cudf::binary_operation(
+              probeKeyNullMask->view(),
+              noMatchMask->view(),
+              cudf::binary_operator::BITWISE_OR,
+              cudf::data_type{cudf::type_id::BOOL8},
+              stream,
+              get_temp_mr());
+        } else {
+          // NULL only where probe key is NULL
+          nullMask = std::move(probeKeyNullMask);
+        }
+
+        matchCol = applyNullMask(
+            matchCol->view(), nullMask->view(), stream, get_output_mr());
+      }
     }
-  } else {
-    VELOX_FAIL("Unsupported join type: ", joinNode_->joinType());
   }
-  auto leftIndicesSpan = leftJoinIndices
-      ? cudf::device_span<cudf::size_type const>{*leftJoinIndices}
-      : cudf::device_span<cudf::size_type const>{};
-  auto rightIndicesSpan = rightJoinIndices
-      ? cudf::device_span<cudf::size_type const>{*rightJoinIndices}
-      : cudf::device_span<cudf::size_type const>{};
 
+  // Step 6: Build output table with all probe columns + match column
+  std::vector<std::unique_ptr<cudf::column>> outputCols;
+  outputCols.resize(outputType_->names().size());
+
+  // Copy probe columns
   auto leftInput = leftTableView.select(leftColumnIndicesToGather_);
-  auto rightInput = rightTableView.select(rightColumnIndicesToGather_);
+  for (size_t i = 0; i < leftColumnIndicesToGather_.size(); i++) {
+    outputCols[leftColumnOutputIndices_[i]] = std::make_unique<cudf::column>(
+        leftInput.column(i), stream, get_output_mr());
+  }
 
-  auto leftIndicesCol = cudf::column_view{leftIndicesSpan};
+  // Add match column as the last column
+  outputCols.back() = std::move(matchCol);
+
+  if (buildStream_.has_value()) {
+    cudaEvent_->recordFrom(stream).waitOn(buildStream_.value());
+  }
+  stream.synchronize();
+
+  cudfOutputs.push_back(std::make_unique<cudf::table>(std::move(outputCols)));
+  return cudfOutputs;
+}
+
+std::vector<std::unique_ptr<cudf::table>>
+CudfHashJoinProbe::rightSemiFilterJoin(
+    cudf::table_view leftTableView,
+    rmm::cuda_stream_view stream) {
+  std::vector<std::unique_ptr<cudf::table>> cudfOutputs;
+
+  auto& rightTables = hashObject_.value().first;
+  auto rightTableView = rightTables[0]->view();
+
+  VELOX_CHECK_EQ(
+      rightTables.size(),
+      1,
+      "Multiple right tables not yet supported for rightSemiFilterJoin");
+
+  std::unique_ptr<rmm::device_uvector<cudf::size_type>> rightJoinIndices;
+  if (joinNode_->filter()) {
+    rightJoinIndices = cudf::mixed_left_semi_join(
+        rightTableView.select(rightKeyIndices_),
+        leftTableView.select(leftKeyIndices_),
+        rightTableView,
+        leftTableView,
+        tree_.back(),
+        cudf::null_equality::UNEQUAL,
+        stream,
+        get_temp_mr());
+  } else {
+    cudf::filtered_join filter_join(
+        leftTableView.select(leftKeyIndices_),
+        cudf::null_equality::UNEQUAL,
+        stream);
+    rightJoinIndices = filter_join.semi_join(
+        rightTableView.select(rightKeyIndices_), stream, get_temp_mr());
+  }
+
+  auto rightIndicesSpan =
+      cudf::device_span<cudf::size_type const>{*rightJoinIndices};
   auto rightIndicesCol = cudf::column_view{rightIndicesSpan};
-  auto constexpr oobPolicy = cudf::out_of_bounds_policy::NULLIFY;
-  auto leftResult = cudf::gather(leftInput, leftIndicesCol, oobPolicy, stream);
-  auto rightResult =
-      cudf::gather(rightInput, rightIndicesCol, oobPolicy, stream);
+  auto leftIndicesCol = cudf::empty_like(rightIndicesCol);
+  cudfOutputs.push_back(unfilteredOutput(
+      leftTableView,
+      leftIndicesCol->view(),
+      rightTableView,
+      rightIndicesCol,
+      stream));
+
+  return cudfOutputs;
+}
+
+std::vector<std::unique_ptr<cudf::table>> CudfHashJoinProbe::antiJoin(
+    cudf::table_view leftTableViewParam,
+    rmm::cuda_stream_view stream) {
+  std::vector<std::unique_ptr<cudf::table>> cudfOutputs;
+
+  auto& rightTables = hashObject_.value().first;
 
-  if (cudfDebugEnabled()) {
-    std::cout << "Left result number of columns: " << leftResult->num_columns()
-              << std::endl;
-    std::cout << "Right result number of columns: "
-              << rightResult->num_columns() << std::endl;
+  VELOX_CHECK_EQ(
+      rightTables.size(),
+      1,
+      "Multiple right tables not yet supported for antiJoin");
+
+  auto rightTableView = rightTables[0]->view();
+
+  // For the special case where we need to drop nulls, we create a local table.
+  // Otherwise, we use the input view directly.
+  std::unique_ptr<cudf::table> modifiedLeftTable;
+  cudf::table_view leftTableView = leftTableViewParam;
+
+  // Special case for null-aware anti join where
+  // build table is not empty, no nulls, and probe table has nulls
+  if (joinNode_->isNullAware() and !joinNode_->filter()) {
+    auto const leftTableHasNulls =
+        cudf::has_nulls(leftTableViewParam.select(leftKeyIndices_));
+    auto const rightTableHasNulls =
+        cudf::has_nulls(rightTableView.select(rightKeyIndices_));
+    if (rightTables[0]->num_rows() > 0 and !rightTableHasNulls and
+        leftTableHasNulls) {
+      // drop nulls on probe table - creates a new table
+      modifiedLeftTable = cudf::drop_nulls(
+          leftTableViewParam, leftKeyIndices_, stream, get_temp_mr());
+      leftTableView = modifiedLeftTable->view();
+    }
   }
 
-  auto leftCols = leftResult->release();
-  auto rightCols = rightResult->release();
-  auto joinedCols =
-      std::vector<std::unique_ptr<cudf::column>>(outputType_->names().size());
-  for (int i = 0; i < leftColumnOutputIndices_.size(); i++) {
-    joinedCols[leftColumnOutputIndices_[i]] = std::move(leftCols[i]);
+  std::unique_ptr<rmm::device_uvector<cudf::size_type>> leftJoinIndices;
+  if (joinNode_->filter()) {
+    leftJoinIndices = cudf::mixed_left_anti_join(
+        leftTableView.select(leftKeyIndices_),
+        rightTableView.select(rightKeyIndices_),
+        leftTableView,
+        rightTableView,
+        tree_.back(),
+        cudf::null_equality::UNEQUAL,
+        stream,
+        get_temp_mr());
+  } else {
+    auto const rightTableHasNulls =
+        cudf::has_nulls(rightTableView.select(rightKeyIndices_));
+    if (joinNode_->isNullAware() and rightTableHasNulls) {
+      // empty result
+      leftJoinIndices = std::make_unique<rmm::device_uvector<cudf::size_type>>(
+          0, stream, get_temp_mr());
+    } else {
+      cudf::filtered_join filter_join(
+          rightTableView.select(rightKeyIndices_),
+          cudf::null_equality::UNEQUAL,
+          stream);
+      leftJoinIndices = filter_join.anti_join(
+          leftTableView.select(leftKeyIndices_), stream, get_temp_mr());
+    }
   }
-  for (int i = 0; i < rightColumnOutputIndices_.size(); i++) {
-    joinedCols[rightColumnOutputIndices_[i]] = std::move(rightCols[i]);
+
+  auto leftIndicesSpan =
+      cudf::device_span<cudf::size_type const>{*leftJoinIndices};
+  auto leftIndicesCol = cudf::column_view{leftIndicesSpan};
+  auto rightIndicesCol = cudf::empty_like(leftIndicesCol);
+  cudfOutputs.push_back(unfilteredOutput(
+      leftTableView,
+      leftIndicesCol,
+      rightTableView,
+      rightIndicesCol->view(),
+      stream));
+
+  return cudfOutputs;
+}
+
+RowVectorPtr CudfHashJoinProbe::doGetOutput() {
+  if (finished_ or !hashObject_.has_value()) {
+    return nullptr;
+  }
+  if (!input_) {
+    // If no more input, emit unmatched-right rows if needed.
+    if ((joinNode_->isRightJoin() || joinNode_->isFullJoin()) && noMoreInput_ &&
+        !finished_ && isLastDriver_) {
+      auto& rightTables = hashObject_.value().first;
+      auto stream = cudfGlobalStreamPool().get_stream();
+      std::vector<std::unique_ptr<cudf::table>> toConcat;
+      for (size_t i = 0; i < rightTables.size(); ++i) {
+        auto& rightTable = rightTables[i];
+        auto n = rightTable->num_rows();
+        if (n == 0) {
+          continue;
+        }
+        auto& flags = rightMatchedFlags_[i];
+        // Build a boolean mask: unmatched = NOT(flags)
+        auto boolMask = cudf::unary_operation(
+            flags->view(), cudf::unary_operator::NOT, stream, get_temp_mr());
+
+        // Count unmatched rows by summing the boolean mask
+        auto unmatchedCountScalar = cudf::reduce(
+            boolMask->view(),
+            *cudf::make_sum_aggregation<cudf::reduce_aggregation>(),
+            cudf::data_type{cudf::type_id::INT32},
+            stream,
+            get_temp_mr());
+        auto m = static_cast<cudf::numeric_scalar<int32_t>*>(
+                     unmatchedCountScalar.get())
+                     ->value(stream);
+        if (m == 0) {
+          continue;
+        }
+
+        // Build left null columns
+        std::vector<std::unique_ptr<cudf::column>> outCols(outputType_->size());
+        // Left side nulls (types derive from probe schema at the matching
+        // channel indices)
+        for (size_t li = 0; li < leftColumnOutputIndices_.size(); ++li) {
+          auto outIdx = leftColumnOutputIndices_[li];
+          auto probeChannel = leftColumnIndicesToGather_[li];
+          auto leftCudfDataType =
+              veloxToCudfDataType(probeType_->childAt(probeChannel));
+          auto nullScalar = cudf::make_default_constructed_scalar(
+              leftCudfDataType, stream, get_temp_mr());
+          outCols[outIdx] = cudf::make_column_from_scalar(
+              *nullScalar, m, stream, get_output_mr());
+        }
+        // Right side - gather unmatched build columns if any
+        if (!rightColumnIndicesToGather_.empty()) {
+          auto rightInput =
+              rightTable->view().select(rightColumnIndicesToGather_);
+          auto unmatchedRight = cudf::apply_boolean_mask(
+              rightInput, boolMask->view(), stream, get_output_mr());
+          auto rightCols = unmatchedRight->release();
+          for (size_t ri = 0; ri < rightColumnOutputIndices_.size(); ++ri) {
+            auto outIdx = rightColumnOutputIndices_[ri];
+            outCols[outIdx] = std::move(rightCols[ri]);
+          }
+        }
+        toConcat.push_back(std::make_unique<cudf::table>(std::move(outCols)));
+      }
+      // TODO (dm): We build multiple right chunks only when they are too large
+      // to fit in cudf::size_type. In case of a right join which doesn't have a
+      // lot of matches we'll get outCols of similar size. This concatenation
+      // will overflow. Try emitting result of one right chunk at a time.
+      if (!toConcat.empty()) {
+        auto out =
+            concatenateTables(std::move(toConcat), stream, get_output_mr());
+        finished_ = true;
+        auto size = out->num_rows();
+        if (out->num_columns() == 0 || size == 0) {
+          return nullptr;
+        }
+        return std::make_shared<CudfVector>(
+            pool(), outputType_, size, std::move(out), stream);
+      }
+      finished_ = true;
+    }
+    return nullptr;
   }
-  auto cudfOutput = std::make_unique<cudf::table>(std::move(joinedCols));
-  stream.synchronize();
 
+  auto cudfInput = std::dynamic_pointer_cast<CudfVector>(input_);
+  VELOX_CHECK_NOT_NULL(cudfInput);
+  auto stream = cudfInput->stream();
+  // Use getTableView() to avoid expensive materialization for packed_table.
+  // cudfInput is staying alive until the table view is no longer needed.
+  auto leftTableView = cudfInput->getTableView();
+  if (CudfConfig::getInstance().debugEnabled) {
+    VLOG(1) << "Probe table number of columns: " << leftTableView.num_columns();
+    VLOG(1) << "Probe table number of rows: " << leftTableView.num_rows();
+  }
+
+  auto& rightTables = hashObject_.value().first;
+  auto& hbs = hashObject_.value().second;
+  for (auto i = 0; i < rightTables.size(); i++) {
+    auto& rightTable = rightTables[i];
+    auto& hb = hbs[i];
+    VELOX_CHECK_NOT_NULL(rightTable);
+    if (CudfConfig::getInstance().debugEnabled) {
+      if (rightTable != nullptr)
+        VLOG(2) << "right_table is not nullptr " << rightTable.get()
+                << " hasValue(" << hashObject_.has_value() << ")\n";
+      if (hb != nullptr)
+        VLOG(2) << "hb is not nullptr " << hb.get() << " hasValue("
+                << hashObject_.has_value() << ")\n";
+    }
+  }
+
+  std::vector<std::unique_ptr<cudf::table>> cudfOutputs;
+  switch (joinNode_->joinType()) {
+    case core::JoinType::kInner:
+      cudfOutputs = innerJoin(leftTableView, stream);
+      break;
+    case core::JoinType::kLeft:
+      cudfOutputs = leftJoin(leftTableView, stream);
+      break;
+    case core::JoinType::kRight:
+      cudfOutputs = rightJoin(leftTableView, stream);
+      break;
+    case core::JoinType::kLeftSemiFilter:
+      cudfOutputs = leftSemiFilterJoin(leftTableView, stream);
+      break;
+    case core::JoinType::kLeftSemiProject:
+      cudfOutputs = leftSemiProjectJoin(leftTableView, stream);
+      break;
+    case core::JoinType::kRightSemiFilter:
+      cudfOutputs = rightSemiFilterJoin(leftTableView, stream);
+      break;
+    case core::JoinType::kAnti:
+      cudfOutputs = antiJoin(leftTableView, stream);
+      break;
+    case core::JoinType::kFull:
+      cudfOutputs = fullJoin(leftTableView, stream);
+      break;
+    default:
+      VELOX_FAIL("Unsupported join type: ", joinNode_->joinType());
+  }
+
+  // Record probe stream for cross-driver synchronization in noMoreInput().
+  if (joinNode_->isRightJoin() || joinNode_->isFullJoin()) {
+    lastProbeStream_ = stream;
+  }
+
+  // Release input CudfVector to free GPU memory before creating output.
+  // This reduces peak memory from (input + output) to max(input, output).
+  // cudfInput must be released first since input_.reset() only decrements
+  // the refcount while cudfInput still holds a reference.
+  cudfInput.reset();
   input_.reset();
-  finished_ = noMoreInput_;
+  finished_ =
+      noMoreInput_ && !joinNode_->isRightJoin() && !joinNode_->isFullJoin();
 
+  auto cudfOutput =
+      concatenateTables(std::move(cudfOutputs), stream, get_output_mr());
   auto const size = cudfOutput->num_rows();
   if (cudfOutput->num_columns() == 0 or size == 0) {
     return nullptr;
   }
   return std::make_shared<CudfVector>(
-      pool(), outputType_, size, std::move(cudfOutput), stream);
+      pool(),
+      outputType_,
+      cudfOutput->num_rows(),
+      std::move(cudfOutput),
+      stream);
 }
 
 bool CudfHashJoinProbe::skipProbeOnEmptyBuild() const {
@@ -640,6 +2117,16 @@ bool CudfHashJoinProbe::skipProbeOnEmptyBuild() const {
 }
 
 exec::BlockingReason CudfHashJoinProbe::isBlocked(ContinueFuture* future) {
+  if ((joinNode_->isRightJoin() || joinNode_->isRightSemiFilterJoin() ||
+       joinNode_->isFullJoin()) &&
+      hashObject_.has_value()) {
+    if (!future_.valid()) {
+      return exec::BlockingReason::kNotBlocked;
+    }
+    *future = std::move(future_);
+    return exec::BlockingReason::kWaitForJoinProbe;
+  }
+
   if (hashObject_.has_value()) {
     return exec::BlockingReason::kNotBlocked;
   }
@@ -653,18 +2140,80 @@ exec::BlockingReason CudfHashJoinProbe::isBlocked(ContinueFuture* future) {
   auto hashObject = cudfJoinBridge->hashOrFuture(future);
 
   if (!hashObject.has_value()) {
-    if (cudfDebugEnabled()) {
-      std::cout << "CudfHashJoinProbe is blocked, waiting for join build"
-                << std::endl;
+    if (CudfConfig::getInstance().debugEnabled) {
+      VLOG(2) << "CudfHashJoinProbe is blocked, waiting for join build";
     }
     return exec::BlockingReason::kWaitForJoinBuild;
   }
   hashObject_ = std::move(hashObject);
+  buildStream_ = cudfJoinBridge->getBuildStream();
 
-  auto& rightTable = hashObject_.value().first;
+  // Lazy initialize matched flags only when build side is done
+  if (joinNode_->isRightJoin() || joinNode_->isFullJoin()) {
+    auto& rightTablesInit = hashObject_.value().first;
+    rightMatchedFlags_.clear();
+    rightMatchedFlags_.reserve(rightTablesInit.size());
+    auto initStream = cudfGlobalStreamPool().get_stream();
+    for (auto& rt : rightTablesInit) {
+      auto n = rt->num_rows();
+      auto false_scalar =
+          cudf::numeric_scalar<bool>(false, true, initStream, get_temp_mr());
+      auto flags_col = cudf::make_column_from_scalar(
+          false_scalar, n, initStream, get_temp_mr());
+      rightMatchedFlags_.push_back(std::move(flags_col));
+    }
+    initStream.synchronize();
+  }
+
+  // Precompute right table columns if filter exists (once when build is done)
+  if (joinNode_->filter() && !rightPrecomputeInstructions_.empty()) {
+    auto& rightTablesInit = hashObject_.value().first;
+    cachedRightPrecomputed_.clear();
+    cachedExtendedRightViews_.clear();
+    cachedRightPrecomputed_.reserve(rightTablesInit.size());
+    cachedExtendedRightViews_.reserve(rightTablesInit.size());
+
+    auto initStream = cudfGlobalStreamPool().get_stream();
+    for (auto& rt : rightTablesInit) {
+      auto rightTableView = rt->view();
+      auto rightColumnViews = tableViewToColumnViews(rightTableView);
+      auto rightPrecomputed = precomputeSubexpressions(
+          rightColumnViews,
+          rightPrecomputeInstructions_,
+          scalars_,
+          buildType_,
+          initStream);
+      auto extendedView =
+          createExtendedTableView(rightTableView, rightPrecomputed);
+      cachedRightPrecomputed_.push_back(std::move(rightPrecomputed));
+      cachedExtendedRightViews_.push_back(extendedView);
+    }
+    initStream.synchronize();
+  }
+
+  // Check if build side has any null keys (needed for null-aware left semi
+  // project)
+  if (joinNode_->isLeftSemiProjectJoin() && joinNode_->isNullAware()) {
+    auto& rightTablesInit = hashObject_.value().first;
+    buildSideHasNullKeys_ = false;
+    for (auto& rt : rightTablesInit) {
+      auto keyView = rt->view().select(rightKeyIndices_);
+      for (cudf::size_type k = 0; k < keyView.num_columns(); k++) {
+        if (keyView.column(k).has_nulls()) {
+          buildSideHasNullKeys_ = true;
+          break;
+        }
+      }
+      if (buildSideHasNullKeys_) {
+        break;
+      }
+    }
+  }
+
+  auto& rightTables = hashObject_.value().first;
   // should be rightTable->numDistinct() but it needs compute,
   // so we use num_rows()
-  if (rightTable->num_rows() == 0) {
+  if (rightTables[0]->num_rows() == 0) {
     if (skipProbeOnEmptyBuild()) {
       if (operatorCtx_->driverCtx()
               ->queryConfig()
@@ -675,6 +2224,12 @@ exec::BlockingReason CudfHashJoinProbe::isBlocked(ContinueFuture* future) {
       }
     }
   }
+  if ((joinNode_->isRightJoin() || joinNode_->isRightSemiFilterJoin() ||
+       joinNode_->isFullJoin()) &&
+      future_.valid()) {
+    *future = std::move(future_);
+    return exec::BlockingReason::kWaitForJoinProbe;
+  }
   return exec::BlockingReason::kNotBlocked;
 }
 
@@ -692,9 +2247,8 @@ std::unique_ptr<exec::Operator> CudfHashJoinBridgeTranslator::toOperator(
     exec::DriverCtx* ctx,
     int32_t id,
     const core::PlanNodePtr& node) {
-  if (cudfDebugEnabled()) {
-    std::cout << "Calling CudfHashJoinBridgeTranslator::toOperator"
-              << std::endl;
+  if (CudfConfig::getInstance().debugEnabled) {
+    VLOG(2) << "Calling CudfHashJoinBridgeTranslator::toOperator";
   }
   if (auto joinNode =
           std::dynamic_pointer_cast<const core::HashJoinNode>(node)) {
@@ -705,9 +2259,8 @@ std::unique_ptr<exec::Operator> CudfHashJoinBridgeTranslator::toOperator(
 
 std::unique_ptr<exec::JoinBridge> CudfHashJoinBridgeTranslator::toJoinBridge(
     const core::PlanNodePtr& node) {
-  if (cudfDebugEnabled()) {
-    std::cout << "Calling CudfHashJoinBridgeTranslator::toJoinBridge"
-              << std::endl;
+  if (CudfConfig::getInstance().debugEnabled) {
+    VLOG(2) << "Calling CudfHashJoinBridgeTranslator::toJoinBridge";
   }
   if (auto joinNode =
           std::dynamic_pointer_cast<const core::HashJoinNode>(node)) {
@@ -719,9 +2272,8 @@ std::unique_ptr<exec::JoinBridge> CudfHashJoinBridgeTranslator::toJoinBridge(
 
 exec::OperatorSupplier CudfHashJoinBridgeTranslator::toOperatorSupplier(
     const core::PlanNodePtr& node) {
-  if (cudfDebugEnabled()) {
-    std::cout << "Calling CudfHashJoinBridgeTranslator::toOperatorSupplier"
-              << std::endl;
+  if (CudfConfig::getInstance().debugEnabled) {
+    VLOG(2) << "Calling CudfHashJoinBridgeTranslator::toOperatorSupplier";
   }
   if (auto joinNode =
           std::dynamic_pointer_cast<const core::HashJoinNode>(node)) {
diff --git a/velox/experimental/cudf/exec/CudfHashJoin.h b/velox/experimental/cudf/exec/CudfHashJoin.h
index 00a9b987854..d8325e8abe4 100644
--- a/velox/experimental/cudf/exec/CudfHashJoin.h
+++ b/velox/experimental/cudf/exec/CudfHashJoin.h
@@ -16,62 +16,116 @@
 
 #pragma once
 
-#include "velox/experimental/cudf/exec/NvtxHelper.h"
+#include "velox/experimental/cudf/exec/CudfOperator.h"
+#include "velox/experimental/cudf/expression/AstExpression.h"
+#include "velox/experimental/cudf/expression/AstExpressionUtils.h"
 #include "velox/experimental/cudf/vector/CudfVector.h"
 
-#include "velox/core/Expressions.h"
 #include "velox/core/PlanNode.h"
 #include "velox/exec/JoinBridge.h"
 #include "velox/exec/Operator.h"
 #include "velox/vector/ComplexVector.h"
 
 #include <cudf/ast/expressions.hpp>
+#include <cudf/copying.hpp>
 #include <cudf/join/hash_join.hpp>
-#include <cudf/join/join.hpp>
-#include <cudf/join/mixed_join.hpp>
 #include <cudf/table/table.hpp>
 
+#include <rmm/cuda_stream_view.hpp>
+
+#include <memory>
+
 namespace facebook::velox::cudf_velox {
 
+class CudaEvent;
+class CudfExpression;
+
+/**
+ * @brief Bridge for transferring build-side hash tables between build and probe
+ * operators.
+ *
+ * This bridge manages the lifecycle of CUDF hash join objects and ensures
+ * proper synchronization between build and probe phases. It stores the
+ * constructed hash tables and hash join objects created from build-side data,
+ * making them available to probe operators across different driver threads.
+ *
+ * The bridge handles batched hash tables when build data exceeds
+ * cudf::size_type limits, and manages CUDA stream coordination between build
+ * and probe operations.
+ */
 class CudfHashJoinBridge : public exec::JoinBridge {
  public:
-  using hash_type =
-      std::pair<std::shared_ptr<cudf::table>, std::shared_ptr<cudf::hash_join>>;
+  // The bridge transfers all build side batches and the hash join objects
+  // constructed from them to the probe operator
+  /** @brief Hash tables paired with their corresponding join objects for
+   * batched processing */
+  using hash_type = std::pair<
+      std::vector<std::shared_ptr<cudf::table>>,
+      std::vector<std::shared_ptr<cudf::hash_join>>>;
 
   void setHashTable(std::optional<hash_type> hashObject);
 
   std::optional<hash_type> hashOrFuture(ContinueFuture* future);
 
+  // Store and retrieve the CUDA stream used for building the hash join.
+  void setBuildStream(rmm::cuda_stream_view buildStream);
+
+  std::optional<rmm::cuda_stream_view> getBuildStream();
+
  private:
+  /** @brief Hash tables and join objects transferred from build to probe
+   * operators */
   std::optional<hash_type> hashObject_;
+  /** @brief CUDA stream used by build operator for proper synchronization */
+  std::optional<rmm::cuda_stream_view> buildStream_;
 };
 
-class CudfHashJoinBuild : public exec::Operator, public NvtxHelper {
+/**
+ * @brief Build operator that constructs CUDF hash tables from build-side input
+ * data.
+ *
+ * This operator accumulates all build-side input batches and constructs hash
+ * tables when all input is received. It handles batching when data exceeds
+ * cudf::size_type limits and coordinates with other driver threads to ensure
+ * only one driver performs the final hash table construction. The constructed
+ * hash tables are transferred to probe operators via CudfHashJoinBridge.
+ */
+class CudfHashJoinBuild : public CudfOperatorBase {
  public:
   CudfHashJoinBuild(
       int32_t operatorId,
       exec::DriverCtx* driverCtx,
       std::shared_ptr<const core::HashJoinNode> joinNode);
 
-  void addInput(RowVectorPtr input) override;
-
   bool needsInput() const override;
 
-  RowVectorPtr getOutput() override;
-
-  void noMoreInput() override;
-
   exec::BlockingReason isBlocked(ContinueFuture* future) override;
 
   bool isFinished() override;
 
+ protected:
+  void doAddInput(RowVectorPtr input) override;
+  RowVectorPtr doGetOutput() override;
+  void doNoMoreInput() override;
+
  private:
   std::shared_ptr<const core::HashJoinNode> joinNode_;
   std::vector<CudfVectorPtr> inputs_;
   ContinueFuture future_{ContinueFuture::makeEmpty()};
 };
 
-class CudfHashJoinProbe : public exec::Operator, public NvtxHelper {
+/**
+ * @brief Probe operator that performs CUDF hash join operations on probe-side
+ * input.
+ *
+ * This operator receives hash tables from CudfHashJoinBuild via the bridge and
+ * performs join operations on probe-side input data. It supports all standard
+ * join types (inner, left, right, anti, semi) with optional filter conditions.
+ * The operator handles stream synchronization between build and probe phases,
+ * manages right join state across multiple drivers, and supports batched
+ * processing for large datasets.
+ */
+class CudfHashJoinProbe : public CudfOperatorBase {
  public:
   using hash_type = CudfHashJoinBridge::hash_type;
 
@@ -80,43 +134,90 @@ class CudfHashJoinProbe : public exec::Operator, public NvtxHelper {
       exec::DriverCtx* driverCtx,
       std::shared_ptr<const core::HashJoinNode> joinNode);
 
-  bool needsInput() const override;
-
-  void addInput(RowVectorPtr input) override;
+  void initialize() override;
 
-  RowVectorPtr getOutput() override;
+  bool needsInput() const override;
 
   bool skipProbeOnEmptyBuild() const;
 
   exec::BlockingReason isBlocked(ContinueFuture* future) override;
 
+  /// Returns true if the join type is supported by cudf hash join.
+  /// Supported types:
+  /// - Inner, Left, Right, Full joins
+  /// - Left/Right Semi Filter joins
+  /// - Left Semi Project join (excluding null-aware join with filter)
+  /// - Anti join (non-null-aware, or null-aware without filter)
+  /// Note: Right Semi Project, and null-aware left semi-project join with
+  /// filter not yet supported.
   static bool isSupportedJoinType(core::JoinType joinType) {
     return joinType == core::JoinType::kInner ||
         joinType == core::JoinType::kLeft ||
         joinType == core::JoinType::kAnti ||
-        joinType == core::JoinType::kLeftSemiFilter;
+        joinType == core::JoinType::kLeftSemiFilter ||
+        joinType == core::JoinType::kLeftSemiProject ||
+        joinType == core::JoinType::kRight ||
+        joinType == core::JoinType::kRightSemiFilter ||
+        joinType == core::JoinType::kFull;
   }
 
   bool isFinished() override;
 
+ protected:
+  void doAddInput(RowVectorPtr input) override;
+  RowVectorPtr doGetOutput() override;
+  void doNoMoreInput() override;
+  void doClose() override;
+
  private:
   std::shared_ptr<const core::HashJoinNode> joinNode_;
+  /** @brief Hash tables and join objects received from build operator */
   std::optional<hash_type> hashObject_;
 
   // Filter related members
+  /** @brief Whether to use AST-based filtering (false if filter spans both
+   * sides or if filter deals with decimal types) */
+  bool useAstFilter_{true};
+  /** @brief CUDF AST tree for join filter evaluation */
   cudf::ast::tree tree_;
+  /** @brief Scalar values used in filter expressions */
   std::vector<std::unique_ptr<cudf::scalar>> scalars_;
+  /** @brief Precompute instructions for left (probe) table columns */
+  std::vector<PrecomputeInstruction> leftPrecomputeInstructions_;
+  /** @brief Precompute instructions for right (build) table columns */
+  std::vector<PrecomputeInstruction> rightPrecomputeInstructions_;
+  /** @brief Row type for probe table (needed for precomputation) */
+  RowTypePtr probeType_;
+  /** @brief Row type for build table (needed for precomputation) */
+  RowTypePtr buildType_;
+  /** @brief Cached evaluator for post-join filter column */
+  std::shared_ptr<CudfExpression> filterEvaluator_;
 
   bool rightPrecomputed_{false};
 
+  // Batched probe inputs needed for right join
+  std::vector<CudfVectorPtr> inputs_;
+  ContinueFuture future_{ContinueFuture::makeEmpty()};
+
+  /** @brief Column indices for join keys in left (probe) table */
   std::vector<cudf::size_type> leftKeyIndices_;
+  /** @brief Column indices for join keys in right (build) table */
   std::vector<cudf::size_type> rightKeyIndices_;
+  /** @brief Column indices to gather from left table for output */
   std::vector<cudf::size_type> leftColumnIndicesToGather_;
+  /** @brief Column indices to gather from right table for output */
   std::vector<cudf::size_type> rightColumnIndicesToGather_;
+  /** @brief Output column positions for left table columns */
   std::vector<size_t> leftColumnOutputIndices_;
+  /** @brief Output column positions for right table columns */
   std::vector<size_t> rightColumnOutputIndices_;
   bool finished_{false};
 
+  /// True if any build table has NULL values in join key columns.
+  /// Used for null-aware LEFT SEMI PROJECT to determine match column
+  /// nullability.
+  bool buildSideHasNullKeys_{false};
+
   // Copied from HashProbe.h
   // Indicates whether to skip probe input data processing or not. It only
   // applies for a specific set of join types (see skipProbeOnEmptyBuild()), and
@@ -125,8 +226,170 @@ class CudfHashJoinProbe : public exec::Operator, public NvtxHelper {
   // probe input from the sources have been processed. It prevents the exchange
   // hanging problem at the producer side caused by the early query finish.
   bool skipInput_{false};
+
+  /** @brief CUDA stream from build operator for synchronization */
+  std::optional<rmm::cuda_stream_view> buildStream_;
+  /** @brief CUDA event for coordinating stream synchronization */
+  std::unique_ptr<CudaEvent> cudaEvent_;
+
+  // Streaming right join state
+  // Per-build-table flags indicating whether a build row has had at least one
+  // left match.
+  /** @brief Flags tracking which build rows have been matched (for right joins)
+   */
+  std::vector<std::unique_ptr<cudf::column>> rightMatchedFlags_;
+
+  /// Cached precomputed columns for right (build) tables
+  std::vector<std::vector<ColumnOrView>> cachedRightPrecomputed_;
+  /// Cached extended views for right tables (original + precomputed columns)
+  std::vector<cudf::table_view> cachedExtendedRightViews_;
+
+  // For Right joins, only one driver collects the unmatched rows mask and
+  // emits. This value is set true only for that driver. See noMoreInput
+  bool isLastDriver_{false};
+
+  /// CUDA stream used during the last getOutput() probe operation. Set only
+  /// for right/full joins, and only for drivers that process at least one probe
+  /// batch. Used in noMoreInput() to synchronize GPU streams across drivers
+  /// before combining rightMatchedFlags_. Drivers with no probe input are safe
+  /// to skip: the driver loop guarantees all addInput batches are consumed by
+  /// getOutput() before noMoreInput() fires, and unset flags remain in their
+  /// host-synchronized all-false init state with no pending GPU work.
+  std::optional<rmm::cuda_stream_view> lastProbeStream_;
+
+  static constexpr auto oobPolicy = cudf::out_of_bounds_policy::NULLIFY;
+
+  /**
+   * @brief Performs inner join between probe table and all build tables.
+   * @param leftTable Probe-side table to join
+   * @param stream CUDA stream for operations
+   * @return Vector of result tables (multiple if build data was batched)
+   */
+  std::vector<std::unique_ptr<cudf::table>> innerJoin(
+      cudf::table_view leftTableView,
+      rmm::cuda_stream_view stream);
+  /**
+   * @brief Performs left join between probe table and all build tables.
+   * @param leftTableView Probe-side table view to join
+   * @param stream CUDA stream for operations
+   * @return Vector of result tables (multiple if build data was batched)
+   */
+  std::vector<std::unique_ptr<cudf::table>> leftJoin(
+      cudf::table_view leftTableView,
+      rmm::cuda_stream_view stream);
+  /**
+   * @brief Performs right join between probe table and all build tables.
+   * @param leftTableView Probe-side table view to join
+   * @param stream CUDA stream for operations
+   * @return Vector of result tables (multiple if build data was batched)
+   */
+  std::vector<std::unique_ptr<cudf::table>> rightJoin(
+      cudf::table_view leftTableView,
+      rmm::cuda_stream_view stream);
+  /**
+   * @brief Performs full outer join between probe table and all build tables.
+   * @param leftTableView Probe-side table view to join
+   * @param stream CUDA stream for operations
+   * @return Vector of result tables (multiple if build data was batched)
+   */
+  std::vector<std::unique_ptr<cudf::table>> fullJoin(
+      cudf::table_view leftTableView,
+      rmm::cuda_stream_view stream);
+  /**
+   * @brief Performs left semi filter join between probe table and all build
+   * tables.
+   * @param leftTableView Probe-side table view to join
+   * @param stream CUDA stream for operations
+   * @return Vector of result tables (multiple if build data was batched)
+   */
+  std::vector<std::unique_ptr<cudf::table>> leftSemiFilterJoin(
+      cudf::table_view leftTableView,
+      rmm::cuda_stream_view stream);
+  /**
+   * @brief Performs left semi project join between probe table and all build
+   * tables. Returns all probe rows with a boolean match column indicating
+   * whether each row has a match on the build side.
+   * @param leftTableView Probe-side table view to join
+   * @param stream CUDA stream for operations
+   * @return Vector of result tables (multiple if build data was batched)
+   */
+  std::vector<std::unique_ptr<cudf::table>> leftSemiProjectJoin(
+      cudf::table_view leftTableView,
+      rmm::cuda_stream_view stream);
+  /**
+   * @brief Performs right semi filter join between probe table and all build
+   * tables.
+   * @param leftTableView Probe-side table view to join
+   * @param stream CUDA stream for operations
+   * @return Vector of result tables (multiple if build data was batched)
+   */
+  std::vector<std::unique_ptr<cudf::table>> rightSemiFilterJoin(
+      cudf::table_view leftTableView,
+      rmm::cuda_stream_view stream);
+  /**
+   * @brief Performs anti join between probe table and all build tables.
+   * @param leftTableView Probe-side table view to join
+   * @param stream CUDA stream for operations
+   * @return Vector of result tables (multiple if build data was batched)
+   */
+  std::vector<std::unique_ptr<cudf::table>> antiJoin(
+      cudf::table_view leftTableView,
+      rmm::cuda_stream_view stream);
+  /**
+   * @brief Constructs join output table without applying filter conditions.
+   * @param leftTableView Input probe table view
+   * @param leftIndicesCol Column of indices into left table
+   * @param rightTableView Input build table view
+   * @param rightIndicesCol Column of indices into right table
+   * @param stream CUDA stream for operations
+   * @return Join result table with gathered columns from both sides
+   */
+  std::unique_ptr<cudf::table> unfilteredOutput(
+      cudf::table_view leftTableView,
+      cudf::column_view leftIndicesCol,
+      cudf::table_view rightTableView,
+      cudf::column_view rightIndicesCol,
+      rmm::cuda_stream_view stream);
+  /**
+   * @brief Constructs join output table with filter condition applied.
+   * @param leftTableView Input probe table view
+   * @param leftIndicesCol Column of indices into left table
+   * @param rightTableView Input build table view
+   * @param rightIndicesCol Column of indices into right table
+   * @param func Filter function to apply to joined data
+   * @param stream CUDA stream for operations
+   * @return Filtered join result table
+   */
+  std::unique_ptr<cudf::table> filteredOutput(
+      cudf::table_view leftTableView,
+      cudf::column_view leftIndicesCol,
+      cudf::table_view rightTableView,
+      cudf::column_view rightIndicesCol,
+      std::function<std::vector<std::unique_ptr<cudf::column>>(
+          std::vector<std::unique_ptr<cudf::column>>&&,
+          cudf::column_view)> func,
+      rmm::cuda_stream_view stream);
+
+  std::unique_ptr<cudf::table> filteredOutputIndices(
+      cudf::table_view leftTableView,
+      cudf::column_view leftIndicesCol,
+      cudf::table_view rightTableView,
+      cudf::column_view rightIndicesCol,
+      cudf::table_view extendedLeftView,
+      cudf::table_view extendedRightView,
+      cudf::join_kind joinKind,
+      rmm::cuda_stream_view stream);
 };
 
+/**
+ * @brief Factory for creating CUDF hash join operators and bridges from plan
+ * nodes.
+ *
+ * This translator converts HashJoinNode plan nodes into the appropriate
+ * CUDF-specific operators and bridges. It creates CudfHashJoinProbe operators
+ * for probe-side processing, CudfHashJoinBuild operators for build-side
+ * processing, and CudfHashJoinBridge instances for coordinating between them.
+ */
 class CudfHashJoinBridgeTranslator : public exec::Operator::PlanNodeTranslator {
  public:
   std::unique_ptr<exec::Operator>
diff --git a/velox/experimental/cudf/exec/CudfLimit.cpp b/velox/experimental/cudf/exec/CudfLimit.cpp
index 7cf320c89a6..b99dd090459 100644
--- a/velox/experimental/cudf/exec/CudfLimit.cpp
+++ b/velox/experimental/cudf/exec/CudfLimit.cpp
@@ -14,7 +14,9 @@
  * limitations under the License.
  */
 
+#include "velox/experimental/cudf/CudfNoDefaults.h"
 #include "velox/experimental/cudf/exec/CudfLimit.h"
+#include "velox/experimental/cudf/exec/GpuResources.h"
 #include "velox/experimental/cudf/vector/CudfVector.h"
 
 #include <cudf/copying.hpp>
@@ -25,16 +27,16 @@ CudfLimit::CudfLimit(
     int32_t operatorId,
     exec::DriverCtx* driverCtx,
     const std::shared_ptr<const core::LimitNode>& limitNode)
-    : Operator(
+    : CudfOperatorBase(
+          operatorId,
           driverCtx,
           limitNode->outputType(),
-          operatorId,
           limitNode->id(),
-          "CudfLimit"),
-      NvtxHelper(
+          "CudfLimit",
           nvtx3::rgb{112, 128, 144}, // Slate Gray
-          operatorId,
-          fmt::format("[{}]", limitNode->id())),
+          NvtxMethodFlag::kAll,
+          std::nullopt,
+          limitNode),
       remainingOffset_{limitNode->offset()},
       remainingLimit_{limitNode->count()} {
   isIdentityProjection_ = true;
@@ -50,13 +52,12 @@ bool CudfLimit::needsInput() const {
   return !finished_ && input_ == nullptr;
 }
 
-void CudfLimit::addInput(RowVectorPtr input) {
+void CudfLimit::doAddInput(RowVectorPtr input) {
   VELOX_CHECK_NULL(input_);
   input_ = input;
 }
 
-RowVectorPtr CudfLimit::getOutput() {
-  VELOX_NVTX_OPERATOR_FUNC_RANGE();
+RowVectorPtr CudfLimit::doGetOutput() {
   if (input_ == nullptr || (remainingOffset_ == 0 && remainingLimit_ == 0)) {
     return nullptr;
   }
@@ -84,8 +85,8 @@ RowVectorPtr CudfLimit::getOutput() {
          static_cast<int>(remainingOffset_ + outputSize)},
         cudfInput->stream());
 
-    auto materializedTable =
-        std::make_unique<cudf::table>(slicedTable[0], cudfInput->stream());
+    auto materializedTable = std::make_unique<cudf::table>(
+        slicedTable[0], cudfInput->stream(), get_output_mr());
 
     remainingOffset_ = 0;
     remainingLimit_ -= outputSize;
@@ -122,8 +123,8 @@ RowVectorPtr CudfLimit::getOutput() {
       {0, static_cast<int>(remainingLimit_)},
       cudfInput->stream());
 
-  auto materializedTable =
-      std::make_unique<cudf::table>(slicedTable[0], cudfInput->stream());
+  auto materializedTable = std::make_unique<cudf::table>(
+      slicedTable[0], cudfInput->stream(), get_output_mr());
 
   auto output = std::make_shared<cudf_velox::CudfVector>(
       input_->pool(),
diff --git a/velox/experimental/cudf/exec/CudfLimit.h b/velox/experimental/cudf/exec/CudfLimit.h
index c6220e26f92..a61b5489213 100644
--- a/velox/experimental/cudf/exec/CudfLimit.h
+++ b/velox/experimental/cudf/exec/CudfLimit.h
@@ -16,12 +16,12 @@
 
 #pragma once
 
-#include "velox/experimental/cudf/exec/NvtxHelper.h"
+#include "velox/experimental/cudf/exec/CudfOperator.h"
 
 #include "velox/exec/Operator.h"
 
 namespace facebook::velox::cudf_velox {
-class CudfLimit : public exec::Operator, public NvtxHelper {
+class CudfLimit : public CudfOperatorBase {
  public:
   CudfLimit(
       int32_t operatorId,
@@ -30,10 +30,6 @@ class CudfLimit : public exec::Operator, public NvtxHelper {
 
   bool needsInput() const override;
 
-  void addInput(RowVectorPtr input) override;
-
-  RowVectorPtr getOutput() override;
-
   exec::BlockingReason isBlocked(ContinueFuture* /*future*/) override {
     return exec::BlockingReason::kNotBlocked;
   }
@@ -42,6 +38,10 @@ class CudfLimit : public exec::Operator, public NvtxHelper {
     return finished_ || (noMoreInput_ && input_ == nullptr);
   }
 
+ protected:
+  void doAddInput(RowVectorPtr input) override;
+  RowVectorPtr doGetOutput() override;
+
  private:
   int64_t remainingOffset_;
   int64_t remainingLimit_;
diff --git a/velox/experimental/cudf/exec/CudfLocalPartition.cpp b/velox/experimental/cudf/exec/CudfLocalPartition.cpp
index 6ccc3559f62..29091665af5 100644
--- a/velox/experimental/cudf/exec/CudfLocalPartition.cpp
+++ b/velox/experimental/cudf/exec/CudfLocalPartition.cpp
@@ -14,10 +14,14 @@
  * limitations under the License.
  */
 
+#include "velox/experimental/cudf/CudfNoDefaults.h"
 #include "velox/experimental/cudf/exec/CudfLocalPartition.h"
+#include "velox/experimental/cudf/exec/GpuResources.h"
 #include "velox/experimental/cudf/vector/CudfVector.h"
 
+#include "velox/core/PlanNode.h"
 #include "velox/exec/HashPartitionFunction.h"
+#include "velox/exec/RoundRobinPartitionFunction.h"
 #include "velox/exec/Task.h"
 
 #include <cudf/copying.hpp>
@@ -25,29 +29,45 @@
 
 namespace facebook::velox::cudf_velox {
 
+namespace {
+template <class... Deriveds, class Base>
+bool isAnyOf(const Base* p) {
+  return ((dynamic_cast<const Deriveds*>(p) != nullptr) || ...);
+}
+} // namespace
+
 bool CudfLocalPartition::shouldReplace(
     const std::shared_ptr<const core::LocalPartitionNode>& planNode) {
-  auto* hashFunctionSpec = dynamic_cast<const exec::HashPartitionFunctionSpec*>(
-      &planNode->partitionFunctionSpec());
-  // Only replace LocalPartition with CudfLocalPartition for hash partitioning.
-  // TODO: Round Robin Row-Wise Partitioning can be supported in future.
-  return hashFunctionSpec;
+  // Only replace for Hash, Round Robin, and Round Robin Row-Wise Partitioning.
+  if (isAnyOf<
+          exec::HashPartitionFunctionSpec,
+          exec::RoundRobinPartitionFunctionSpec,
+          core::GatherPartitionFunctionSpec>(
+          &planNode->partitionFunctionSpec())) {
+    return true;
+  }
+  std::string spec = planNode->partitionFunctionSpec().toString();
+  if (spec.find("ROUND ROBIN ROW") != std::string::npos) {
+    return true;
+  }
+  LOG(WARNING) << "CudfLocalPartition unsupported spec = " << spec;
+  return false;
 }
 
 CudfLocalPartition::CudfLocalPartition(
     int32_t operatorId,
     exec::DriverCtx* ctx,
     const std::shared_ptr<const core::LocalPartitionNode>& planNode)
-    : Operator(
+    : CudfOperatorBase(
+          operatorId,
           ctx,
           planNode->outputType(),
-          operatorId,
           planNode->id(),
-          "CudfLocalPartition"),
-      NvtxHelper(
+          "CudfLocalPartition",
           nvtx3::rgb{255, 215, 0}, // Gold
-          operatorId,
-          fmt::format("[{}]", planNode->id())),
+          NvtxMethodFlag::kAll,
+          std::nullopt,
+          planNode),
       queues_{
           ctx->task->getLocalExchangeQueues(ctx->splitGroupId, planNode->id())},
       numPartitions_{queues_.size()} {
@@ -98,8 +118,20 @@ CudfLocalPartition::CudfLocalPartition(
         partitionKeyIndices_.push_back(fieldIndex);
       }
     }
+    partitionFunctionType_ = PartitionFunctionType::kHash;
+  } else if (
+      dynamic_cast<const exec::RoundRobinPartitionFunctionSpec*>(
+          &planNode->partitionFunctionSpec()) &&
+      numPartitions_ > 1) {
+    partitionFunctionType_ = PartitionFunctionType::kRoundRobin;
+  } else if (
+      numPartitions_ > 1 && spec.find("ROUND ROBIN ROW") != std::string::npos) {
+    partitionFunctionType_ = PartitionFunctionType::kRoundRobinRow;
   }
-  VELOX_CHECK(numPartitions_ == 1 || partitionKeyIndices_.size() > 0);
+  VELOX_CHECK(
+      numPartitions_ == 1 || partitionKeyIndices_.size() > 0 ||
+      partitionFunctionType_ == PartitionFunctionType::kRoundRobin ||
+      partitionFunctionType_ == PartitionFunctionType::kRoundRobinRow);
 
   // Since we're replacing the LocalPartition with CudfLocalPartition, the
   // number of producers is already set. Adding producer only adds to a counter
@@ -117,64 +149,109 @@ void CudfLocalPartition::recordOutputStats(RowVectorPtr& input) {
   }
 }
 
-void CudfLocalPartition::addInput(RowVectorPtr input) {
-  VELOX_NVTX_OPERATOR_FUNC_RANGE();
+void CudfLocalPartition::flushVectorPool() {
+  // We reuse the LocalExchangeQueue from the CPU implementation. That impl
+  // stores used vectors in a vector pool for the CPU LocalPartition to re-use.
+  // CudfLocalPartition does not need it and does not extract it. This results
+  // in unnecessary extension of the lifetimes of vectors that were exchanged,
+  // resulting in kind of a memory leak.
+  // This is a hack to forcefully flush the vector pools.
+
+  for (auto& queue : queues_) {
+    queue->getVector();
+  }
+}
+
+void CudfLocalPartition::enqueuePartition(
+    int partitionIndex,
+    const CudfVectorPtr& cudfVector) {
+  if (cudfVector->size() == 0) {
+    // Skip empty partitions.
+    return;
+  }
+
+  ContinueFuture future;
+  auto blockingReason =
+      queues_[partitionIndex]->enqueue(cudfVector, cudfVector->size(), &future);
+  if (blockingReason != exec::BlockingReason::kNotBlocked) {
+    blockingReasons_.push_back(blockingReason);
+    futures_.push_back(std::move(future));
+  }
+}
+
+void CudfLocalPartition::doAddInput(RowVectorPtr input) {
+  flushVectorPool();
   recordOutputStats(input);
   auto cudfVector = std::dynamic_pointer_cast<CudfVector>(input);
   VELOX_CHECK(cudfVector, "Input must be a CudfVector");
   auto stream = cudfVector->stream();
 
   if (numPartitions_ > 1) {
-    // Use cudf hash partitioning
-    auto tableView = cudfVector->getTableView();
-    std::vector<cudf::size_type> partitionKeyIndices;
-    for (const auto& idx : partitionKeyIndices_) {
-      partitionKeyIndices.push_back(static_cast<cudf::size_type>(idx));
+    if (partitionFunctionType_ == PartitionFunctionType::kRoundRobin) {
+      const auto partition = counter_ % numPartitions_;
+      ++counter_;
+      enqueuePartition(partition, cudfVector);
+      return;
     }
+    auto [partitionedTable, partitionOffsets] = [&]() {
+      auto tableView = cudfVector->getTableView();
+      // Use cudf hash partitioning
+      if (partitionFunctionType_ == PartitionFunctionType::kHash) {
+        std::vector<cudf::size_type> partitionKeyIndices;
+        for (const auto& idx : partitionKeyIndices_) {
+          partitionKeyIndices.push_back(static_cast<cudf::size_type>(idx));
+        }
 
-    auto [partitionedTable, partitionOffsets] = cudf::hash_partition(
-        tableView,
-        partitionKeyIndices,
-        numPartitions_,
-        cudf::hash_id::HASH_MURMUR3,
-        cudf::DEFAULT_HASH_SEED,
-        stream);
+        return cudf::hash_partition(
+            tableView,
+            partitionKeyIndices,
+            numPartitions_,
+            cudf::hash_id::HASH_MURMUR3,
+            cudf::DEFAULT_HASH_SEED,
+            stream,
+            get_temp_mr());
+      } else if (
+          partitionFunctionType_ == PartitionFunctionType::kRoundRobinRow) {
+        auto result = cudf::round_robin_partition(
+            tableView, numPartitions_, counter_, stream, get_temp_mr());
+        counter_ = (counter_ + cudfVector->size()) % numPartitions_;
+        return result;
+      }
+      VELOX_FAIL("Unsupported partition function");
+    }();
 
-    VELOX_CHECK(partitionOffsets.size() == numPartitions_);
+    // cuDF partitioning APIs return num_partitions + 1 offsets where:
+    // - offsets[i] is the starting row index for partition i
+    // - offsets[num_partitions] is the total row count
+    VELOX_CHECK(partitionOffsets.size() == numPartitions_ + 1);
     VELOX_CHECK(partitionOffsets[0] == 0);
 
-    // Erase first element since it's always 0 and we don't need it.
+    // cudf::split expects split points (excluding first 0 and last totalRows).
+    // Erase first element (always 0) and last element (total row count).
     partitionOffsets.erase(partitionOffsets.begin());
+    partitionOffsets.pop_back();
 
     auto partitionedTables =
-        cudf::split(partitionedTable->view(), partitionOffsets);
+        cudf::split(partitionedTable->view(), partitionOffsets, stream);
 
+    // DM: We should investigate if keeping partitionedTables alive and using
+    // the table view in partitionData is more efficient than creating a new
+    // table each time. Currently out of scope because it would need a new
+    // type of RowVector that can hold a table view and shared_ptr to the
+    // table.
     for (int i = 0; i < numPartitions_; ++i) {
       auto partitionData = partitionedTables[i];
       if (partitionData.num_rows() == 0) {
-        // Skip empty partitions.
         continue;
       }
 
-      ContinueFuture future;
-      // DM: We should investigate if keeping partitionedTables alive and using
-      // the table view in partitonedData is more efficient than creating a new
-      // table each time. Currently out of scope because it would need a new
-      // type of RowVector that can hold a table view and shared_ptr to the
-      // table.
-      auto blockingReason = queues_[i]->enqueue(
-          std::make_shared<CudfVector>(
-              pool(),
-              outputType_,
-              partitionData.num_rows(),
-              std::make_unique<cudf::table>(partitionData),
-              stream),
+      auto partitionCudfVector = std::make_shared<CudfVector>(
+          pool(),
+          outputType_,
           partitionData.num_rows(),
-          &future);
-      if (blockingReason != exec::BlockingReason::kNotBlocked) {
-        blockingReasons_.push_back(blockingReason);
-        futures_.push_back(std::move(future));
-      }
+          std::make_unique<cudf::table>(partitionData, stream, get_output_mr()),
+          stream);
+      enqueuePartition(i, partitionCudfVector);
     }
   } else {
     // Single partition case.
@@ -200,7 +277,7 @@ exec::BlockingReason CudfLocalPartition::isBlocked(ContinueFuture* future) {
   return exec::BlockingReason::kNotBlocked;
 }
 
-void CudfLocalPartition::noMoreInput() {
+void CudfLocalPartition::doNoMoreInput() {
   Operator::noMoreInput();
   for (const auto& queue : queues_) {
     queue->noMoreData();
@@ -211,6 +288,7 @@ bool CudfLocalPartition::isFinished() {
   if (!futures_.empty() || !noMoreInput_) {
     return false;
   }
+  flushVectorPool();
 
   return true;
 }
diff --git a/velox/experimental/cudf/exec/CudfLocalPartition.h b/velox/experimental/cudf/exec/CudfLocalPartition.h
index ee215f19c76..4bf7342dc66 100644
--- a/velox/experimental/cudf/exec/CudfLocalPartition.h
+++ b/velox/experimental/cudf/exec/CudfLocalPartition.h
@@ -15,14 +15,21 @@
  */
 #pragma once
 
-#include "velox/experimental/cudf/exec/NvtxHelper.h"
+#include "velox/experimental/cudf/exec/CudfOperator.h"
+#include "velox/experimental/cudf/vector/CudfVector.h"
 
 #include "velox/exec/LocalPartition.h"
 #include "velox/exec/Operator.h"
 
 namespace facebook::velox::cudf_velox {
 
-class CudfLocalPartition : public exec::Operator, public NvtxHelper {
+enum class PartitionFunctionType {
+  kHash,
+  kRoundRobin,
+  kRoundRobinRow,
+};
+
+class CudfLocalPartition : public CudfOperatorBase {
  public:
   CudfLocalPartition(
       int32_t operatorId,
@@ -35,12 +42,6 @@ class CudfLocalPartition : public exec::Operator, public NvtxHelper {
 
   void recordOutputStats(RowVectorPtr& input);
 
-  void addInput(RowVectorPtr input) override;
-
-  RowVectorPtr getOutput() override {
-    return nullptr;
-  }
-
   /// Always true but the caller will check isBlocked before adding input, hence
   /// the blocked state does not accumulate input.
   bool needsInput() const override {
@@ -49,16 +50,29 @@ class CudfLocalPartition : public exec::Operator, public NvtxHelper {
 
   exec::BlockingReason isBlocked(ContinueFuture* future) override;
 
-  void noMoreInput() override;
-
   bool isFinished() override;
 
   static bool shouldReplace(
       const std::shared_ptr<const core::LocalPartitionNode>& planNode);
 
+ protected:
+  void doAddInput(RowVectorPtr input) override;
+
+  RowVectorPtr doGetOutput() override {
+    return nullptr;
+  }
+
+  void doNoMoreInput() override;
+
+ private:
+  void enqueuePartition(int partitionIndex, const CudfVectorPtr& cudfVector);
+  void flushVectorPool();
+
  protected:
   const std::vector<std::shared_ptr<exec::LocalExchangeQueue>> queues_;
   const size_t numPartitions_;
+  PartitionFunctionType partitionFunctionType_;
+  size_t counter_{0};
 
   std::vector<exec::BlockingReason> blockingReasons_;
   std::vector<ContinueFuture> futures_;
diff --git a/velox/experimental/cudf/exec/CudfMarkDistinct.cpp b/velox/experimental/cudf/exec/CudfMarkDistinct.cpp
new file mode 100644
index 00000000000..c46ad77caf3
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfMarkDistinct.cpp
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/CudfNoDefaults.h"
+#include "velox/experimental/cudf/exec/CudfMarkDistinct.h"
+#include "velox/experimental/cudf/exec/GpuResources.h"
+
+#include <cudf/column/column_factories.hpp>
+#include <cudf/concatenate.hpp>
+#include <cudf/copying.hpp>
+#include <cudf/scalar/scalar.hpp>
+#include <cudf/stream_compaction.hpp>
+#include <cudf/utilities/error.hpp>
+
+namespace facebook::velox::cudf_velox {
+
+CudfMarkDistinct::CudfMarkDistinct(
+    int32_t operatorId,
+    exec::DriverCtx* driverCtx,
+    const std::shared_ptr<const core::MarkDistinctNode>& planNode)
+    : CudfOperatorBase(
+          operatorId,
+          driverCtx,
+          planNode->outputType(),
+          planNode->id(),
+          "CudfMarkDistinct",
+          nvtx3::rgb{255, 165, 0}, // Orange
+          NvtxMethodFlag::kAddInput | NvtxMethodFlag::kGetOutput,
+          std::nullopt,
+          planNode) {
+  const auto& inputType = planNode->sources()[0]->outputType();
+  for (const auto& key : planNode->distinctKeys()) {
+    auto idx = inputType->getChildIdx(key->name());
+    distinctKeyIndices_.push_back(static_cast<cudf::size_type>(idx));
+  }
+}
+
+void CudfMarkDistinct::doAddInput(RowVectorPtr input) {
+  VELOX_CHECK_NULL(input_);
+  input_ = std::move(input);
+}
+
+RowVectorPtr CudfMarkDistinct::doGetOutput() {
+  if (input_ == nullptr) {
+    return nullptr;
+  }
+
+  auto cudfInput = std::dynamic_pointer_cast<CudfVector>(input_);
+  VELOX_CHECK_NOT_NULL(cudfInput, "CudfMarkDistinct expects CudfVector input");
+
+  auto stream = cudfInput->stream();
+  auto outputMr = get_output_mr();
+  auto tempMr = get_temp_mr();
+  auto tableView = cudfInput->getTableView();
+  auto numRows = static_cast<cudf::size_type>(tableView.num_rows());
+
+  if (numRows == 0) {
+    input_ = nullptr;
+    return nullptr;
+  }
+
+  // Extract key columns from the input batch.
+  auto batchKeys = tableView.select(distinctKeyIndices_);
+
+  // Create marker column (all false initially).
+  cudf::numeric_scalar<bool> falseScalar(false, true, stream, tempMr);
+  auto markerCol =
+      cudf::make_column_from_scalar(falseScalar, numRows, stream, outputMr);
+
+  // Find first occurrences within this batch (returns a column of indices).
+  auto batchDistinctIdxCol = cudf::distinct_indices(
+      batchKeys,
+      cudf::duplicate_keep_option::KEEP_FIRST,
+      cudf::null_equality::EQUAL,
+      cudf::nan_equality::ALL_EQUAL,
+      stream,
+      tempMr);
+
+  // column_view used to pass indices to gather/scatter.
+  std::unique_ptr<cudf::column> newRowIndicesCol;
+
+  if (seenFilter_ == nullptr) {
+    // First batch: all first-occurrence rows are new.
+    newRowIndicesCol = std::move(batchDistinctIdxCol);
+
+    // Initialize seenKeys_ by gathering the unique key rows using the indices
+    // we already computed.
+    seenKeys_ = cudf::gather(
+        batchKeys,
+        newRowIndicesCol->view(),
+        cudf::out_of_bounds_policy::DONT_CHECK,
+        stream,
+        tempMr);
+    seenFilter_ = std::make_unique<cudf::filtered_join>(
+        seenKeys_->view(), cudf::null_equality::EQUAL, stream);
+
+  } else {
+    // Subsequent batch: probe the persistent filter — no hash table rebuild.
+
+    // Gather the unique keys from this batch.
+    auto uniqueBatchKeys = cudf::gather(
+        batchKeys,
+        batchDistinctIdxCol->view(),
+        cudf::out_of_bounds_policy::DONT_CHECK,
+        stream,
+        tempMr);
+
+    // Anti-join against the persistent seenFilter_ to find new keys.
+    auto newKeyLocalIndices =
+        seenFilter_->anti_join(uniqueBatchKeys->view(), stream, tempMr);
+
+    if (!newKeyLocalIndices->is_empty()) {
+      // Map local indices back to original batch row indices via gather.
+      // Wrap device_uvector as column_view (same pattern as CudfHashJoin).
+      auto localSpan =
+          cudf::device_span<cudf::size_type const>{*newKeyLocalIndices};
+      auto localCol = cudf::column_view{localSpan};
+      auto remappedCol = cudf::gather(
+          cudf::table_view{{batchDistinctIdxCol->view()}},
+          localCol,
+          cudf::out_of_bounds_policy::DONT_CHECK,
+          stream,
+          tempMr);
+      newRowIndicesCol = std::move(remappedCol->release()[0]);
+
+      // Append only the new unique keys to seenKeys_ and rebuild the filter.
+      auto newKeys = cudf::gather(
+          uniqueBatchKeys->view(),
+          localCol,
+          cudf::out_of_bounds_policy::DONT_CHECK,
+          stream,
+          tempMr);
+
+      // Append new keys and rebuild the filter. This concatenates all seen
+      // keys on every batch that introduces new keys, which is O(D) per such
+      // batch. An amortized-doubling scheme (accumulate in a pending table,
+      // consolidate when it reaches the size of seenKeys_) would reduce total
+      // copy work to O(D), but that pattern does not yet exist in this
+      // codebase. CudfHashAggregation::computePartialGroupbyStreaming and
+      // computePartialDistinctStreaming use the same unconditional
+      // concatenate-per-batch idiom.
+      std::vector<cudf::table_view> seenPlusNew = {
+          seenKeys_->view(), newKeys->view()};
+      seenKeys_ = cudf::concatenate(seenPlusNew, stream, tempMr);
+      seenFilter_ = std::make_unique<cudf::filtered_join>(
+          seenKeys_->view(), cudf::null_equality::EQUAL, stream);
+    }
+  }
+
+  // Scatter TRUE at new row positions.
+  if (newRowIndicesCol && newRowIndicesCol->size() > 0) {
+    cudf::numeric_scalar<bool> trueScalar(true, true, stream, tempMr);
+    std::vector<std::reference_wrapper<const cudf::scalar>> sources = {
+        trueScalar};
+    cudf::table_view markerTableView({markerCol->view()});
+    auto scatteredTable = cudf::scatter(
+        sources, newRowIndicesCol->view(), markerTableView, stream, outputMr);
+    markerCol = std::move(scatteredTable->release()[0]);
+  }
+
+  // Append marker column to output.
+  auto pool = cudfInput->pool();
+  auto size = cudfInput->size();
+  auto columns = cudfInput->release()->release();
+  columns.push_back(std::move(markerCol));
+  cudfInput.reset();
+  input_ = nullptr;
+  return std::make_shared<CudfVector>(
+      pool,
+      outputType_,
+      size,
+      std::make_unique<cudf::table>(std::move(columns)),
+      stream);
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfMarkDistinct.h b/velox/experimental/cudf/exec/CudfMarkDistinct.h
new file mode 100644
index 00000000000..5e877055059
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfMarkDistinct.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/experimental/cudf/exec/CudfOperator.h"
+#include "velox/experimental/cudf/vector/CudfVector.h"
+
+#include "velox/core/PlanNode.h"
+
+#include <cudf/join/filtered_join.hpp>
+#include <cudf/table/table.hpp>
+#include <cudf/types.hpp>
+
+#include <memory>
+#include <vector>
+
+namespace facebook::velox::cudf_velox {
+
+/// GPU operator that marks first occurrences of distinct key combinations.
+///
+/// For each input row, appends a boolean column indicating whether this is the
+/// first time the key combination has been seen.
+///
+/// Unlike the CPU implementation, this operator does not support spilling.
+class CudfMarkDistinct : public CudfOperatorBase {
+ public:
+  CudfMarkDistinct(
+      int32_t operatorId,
+      exec::DriverCtx* driverCtx,
+      const std::shared_ptr<const core::MarkDistinctNode>& planNode);
+
+  bool isFilter() const override {
+    return true;
+  }
+
+  bool preservesOrder() const override {
+    return false;
+  }
+
+  bool needsInput() const override {
+    return !noMoreInput_ && input_ == nullptr;
+  }
+
+  bool isFinished() override {
+    return noMoreInput_ && input_ == nullptr;
+  }
+
+  exec::BlockingReason isBlocked(ContinueFuture* /*future*/) override {
+    return exec::BlockingReason::kNotBlocked;
+  }
+
+ protected:
+  void doAddInput(RowVectorPtr input) override;
+  RowVectorPtr doGetOutput() override;
+
+ private:
+  /// Column indices in the input schema that form the distinct key.
+  std::vector<cudf::size_type> distinctKeyIndices_;
+
+  /// Accumulated distinct keys seen across all batches processed so far.
+  std::unique_ptr<cudf::table> seenKeys_;
+
+  /// Persistent hash filter built from seenKeys_. Probed each batch to find
+  /// new distinct keys. Only rebuilt when seenKeys_ grows (new keys found).
+  /// Null until the first batch has been processed.
+  std::unique_ptr<cudf::filtered_join> seenFilter_;
+};
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfNestedLoopJoin.cpp b/velox/experimental/cudf/exec/CudfNestedLoopJoin.cpp
new file mode 100644
index 00000000000..de49cf1eeae
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfNestedLoopJoin.cpp
@@ -0,0 +1,1028 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/CudfNoDefaults.h"
+#include "velox/experimental/cudf/exec/CudfNestedLoopJoin.h"
+#include "velox/experimental/cudf/exec/GpuResources.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/exec/Utilities.h"
+#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+#include "velox/experimental/cudf/expression/AstExpression.h"
+#include "velox/experimental/cudf/expression/AstExpressionUtils.h"
+#include "velox/experimental/cudf/expression/PrecomputeInstruction.h"
+
+#include "velox/exec/Task.h"
+
+#include <cudf/ast/expressions.hpp>
+#include <cudf/binaryop.hpp>
+#include <cudf/column/column_factories.hpp>
+#include <cudf/concatenate.hpp>
+#include <cudf/copying.hpp>
+#include <cudf/detail/utilities/stream_pool.hpp>
+#include <cudf/filling.hpp>
+#include <cudf/join/conditional_join.hpp>
+#include <cudf/join/join.hpp>
+#include <cudf/scalar/scalar_factories.hpp>
+#include <cudf/search.hpp>
+#include <cudf/stream_compaction.hpp>
+#include <cudf/unary.hpp>
+
+namespace facebook::velox::cudf_velox {
+
+namespace {
+
+// Appends precomputed columns to a table view for filter AST evaluation.
+// TODO: Consolidate with the identical helper in CudfHashJoin.cpp.
+cudf::table_view createExtendedTableView(
+    cudf::table_view originalView,
+    std::vector<ColumnOrView>& precomputedColumns) {
+  if (precomputedColumns.empty()) {
+    return originalView;
+  }
+  std::vector<cudf::column_view> allViews;
+  allViews.reserve(originalView.num_columns() + precomputedColumns.size());
+  for (cudf::size_type i = 0; i < originalView.num_columns(); ++i) {
+    allViews.push_back(originalView.column(i));
+  }
+  for (auto& col : precomputedColumns) {
+    allViews.push_back(asView(col));
+  }
+  return cudf::table_view(allViews);
+}
+
+} // namespace
+
+void CudfNestedLoopJoinBridge::setData(
+    std::optional<CudfNestedLoopJoinBridge::build_data_type> data) {
+  std::vector<ContinuePromise> promises;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    VELOX_CHECK(!data_.has_value(), "Bridge already has data");
+    data_ = std::move(data);
+    promises = std::move(promises_); // Extract promises to fulfill outside lock
+  }
+  notify(std::move(promises)); // Wake up all blocked probe operators
+}
+
+// Returns build data if available, otherwise returns a future to wait on.
+// Called by probe operators in isBlocked().
+std::optional<CudfNestedLoopJoinBridge::build_data_type>
+CudfNestedLoopJoinBridge::dataOrFuture(ContinueFuture* future) {
+  std::lock_guard<std::mutex> l(mutex_);
+  VELOX_CHECK(!cancelled_, "Getting data after the build side is aborted");
+  if (data_.has_value()) {
+    return data_;
+  }
+  // Data not ready yet, create a promise that will be fulfilled by setData()
+  promises_.emplace_back("CudfNestedLoopJoinBridge::dataOrFuture");
+  *future = promises_.back().getSemiFuture();
+  return std::nullopt; // Probe will block on the future
+}
+
+void CudfNestedLoopJoinBridge::setBuildStream(
+    rmm::cuda_stream_view buildStream) {
+  std::lock_guard<std::mutex> l(mutex_);
+  buildStream_ = buildStream;
+}
+
+std::optional<rmm::cuda_stream_view>
+CudfNestedLoopJoinBridge::getBuildStream() {
+  std::lock_guard<std::mutex> l(mutex_);
+  return buildStream_;
+}
+
+// ============================================================================
+// Build Operator Implementation
+// ============================================================================
+// Accumulates all build-side input batches in GPU memory and transfers them
+// to the bridge when all input is received.
+
+CudfNestedLoopJoinBuild::CudfNestedLoopJoinBuild(
+    int32_t operatorId,
+    exec::DriverCtx* driverCtx,
+    std::shared_ptr<const core::NestedLoopJoinNode> joinNode)
+    : CudfOperatorBase(
+          operatorId,
+          driverCtx,
+          nullptr,
+          joinNode->id(),
+          "CudfNestedLoopJoinBuild",
+          nvtx3::rgb{65, 105, 225}, // Royal Blue
+          NvtxMethodFlag::kNoMoreInput,
+          std::nullopt,
+          joinNode),
+      joinNode_(joinNode) {}
+
+// Accumulates input batches in memory.
+// All batches are kept as CudfVectors (GPU memory) until join completes.
+void CudfNestedLoopJoinBuild::doAddInput(RowVectorPtr input) {
+  if (input->size() > 0) {
+    auto cudfInput = std::dynamic_pointer_cast<CudfVector>(input);
+    VELOX_CHECK_NOT_NULL(cudfInput);
+    inputs_.push_back(std::move(cudfInput)); // Store in GPU memory
+  }
+}
+
+bool CudfNestedLoopJoinBuild::needsInput() const {
+  return !noMoreInput_;
+}
+
+RowVectorPtr CudfNestedLoopJoinBuild::doGetOutput() {
+  return nullptr;
+}
+
+// Called when upstream finishes. Coordinates with peer build operators
+// to transfer accumulated data to the bridge.
+//
+// Multi-driver coordination:
+// - Multiple build operators may run in parallel (one per driver)
+// - allPeersFinished() chooses ONE operator to collect and transfer data
+// - Other operators just return and mark themselves finished
+// - The chosen operator collects data from all peers and sets it on the bridge
+void CudfNestedLoopJoinBuild::doNoMoreInput() {
+  Operator::noMoreInput();
+
+  std::vector<ContinuePromise> promises;
+  std::vector<std::shared_ptr<exec::Driver>> peers;
+
+  // Synchronization point: only the LAST driver to finish will proceed
+  // Other drivers return here and will be woken when data transfer completes
+  if (!operatorCtx_->task()->allPeersFinished(
+          planNodeId(), operatorCtx_->driver(), &future_, promises, peers)) {
+    return; // Not the last driver - just wait
+  }
+
+  // This driver was chosen to collect data from all peers
+  for (auto& peer : peers) {
+    auto op = peer->findOperator(planNodeId());
+    auto* build = dynamic_cast<CudfNestedLoopJoinBuild*>(op);
+    VELOX_CHECK_NOT_NULL(build);
+    inputs_.insert(
+        inputs_.end(),
+        std::make_move_iterator(build->inputs_.begin()),
+        std::make_move_iterator(build->inputs_.end()));
+  }
+
+  // Wake up peer build operators when we finish transferring data
+  SCOPE_EXIT {
+    peers.clear();
+    for (auto& promise : promises) {
+      promise.setValue(); // Unblock other build operators
+    }
+  };
+
+  // Concatenate all input batches into a single cuDF table.
+  // getConcatenatedTable throws if the total row count exceeds cudf::size_type
+  // limits (~2.1B rows). We don't use getConcatenatedTableBatched here because
+  // batching the build side does not prevent output overflow for NLJ: a cross
+  // join output is probe_rows × build_rows regardless of how the build is
+  // split.
+  auto stream = cudfGlobalStreamPool().get_stream();
+  auto table = getConcatenatedTable(
+      std::exchange(inputs_, {}),
+      joinNode_->sources()[1]->outputType(),
+      stream,
+      get_output_mr());
+
+  // Transfer build data to bridge - this will unblock probe operators.
+  // No stream sync is required: the probe side uses syncBuildStream() via a
+  // CUDA event to ensure the build table is ready before reading it.
+  auto joinBridge = operatorCtx_->task()->getCustomJoinBridge(
+      operatorCtx_->driverCtx()->splitGroupId, planNodeId());
+  auto bridge = std::dynamic_pointer_cast<CudfNestedLoopJoinBridge>(joinBridge);
+
+  bridge->setBuildStream(stream); // Pass stream for CUDA synchronization
+  bridge->setData(
+      std::make_optional(
+          std::shared_ptr<cudf::table>(std::move(table)))); // Wake probes
+}
+
+exec::BlockingReason CudfNestedLoopJoinBuild::isBlocked(
+    ContinueFuture* future) {
+  if (!future_.valid()) {
+    return exec::BlockingReason::kNotBlocked;
+  }
+  *future = std::move(future_);
+  return exec::BlockingReason::kWaitForJoinBuild;
+}
+
+bool CudfNestedLoopJoinBuild::isFinished() {
+  return !future_.valid() && noMoreInput_;
+}
+
+void CudfNestedLoopJoinBuild::doClose() {
+  inputs_.clear();
+  Operator::close();
+}
+
+// ============================================================================
+// Probe Operator Implementation
+// ============================================================================
+// Performs the actual nested loop join by combining probe batches with
+// build data using cuDF's cross_join or conditional_inner_join APIs.
+
+CudfNestedLoopJoinProbe::CudfNestedLoopJoinProbe(
+    int32_t operatorId,
+    exec::DriverCtx* driverCtx,
+    std::shared_ptr<const core::NestedLoopJoinNode> joinNode)
+    : CudfOperatorBase(
+          operatorId,
+          driverCtx,
+          joinNode->outputType(),
+          joinNode->id(),
+          "CudfNestedLoopJoinProbe",
+          nvtx3::rgb{0, 128, 128}, // Teal
+          NvtxMethodFlag::kGetOutput | NvtxMethodFlag::kNoMoreInput,
+          std::nullopt,
+          joinNode),
+      joinNode_(joinNode) {
+  joinType_ = joinNode_->joinType();
+  probeType_ = joinNode_->sources()[0]->outputType();
+  buildType_ = joinNode_->sources()[1]->outputType();
+
+  // For kLeftSemiProject, the last output column is a BOOLEAN match flag
+  // that doesn't exist in probe or build types — skip it during resolution.
+  auto numColumnsToResolve = outputType_->size();
+  if (joinType_ == core::JoinType::kLeftSemiProject) {
+    VELOX_CHECK_GE(numColumnsToResolve, 1);
+    --numColumnsToResolve;
+  }
+
+  for (size_t i = 0; i < numColumnsToResolve; ++i) {
+    const auto& name = outputType_->nameOf(i);
+    auto probeIdx = probeType_->getChildIdxIfExists(name);
+    if (probeIdx.has_value()) {
+      probeColumnIndicesToGather_.push_back(
+          static_cast<cudf::size_type>(probeIdx.value()));
+      probeColumnOutputIndices_.push_back(i);
+      continue;
+    }
+    auto buildIdx = buildType_->getChildIdxIfExists(name);
+    if (buildIdx.has_value()) {
+      buildColumnIndicesToGather_.push_back(
+          static_cast<cudf::size_type>(buildIdx.value()));
+      buildColumnOutputIndices_.push_back(i);
+      continue;
+    }
+    VELOX_FAIL("Output column not found in probe or build types: {}", name);
+  }
+}
+
+void CudfNestedLoopJoinProbe::initialize() {
+  // Filter construction is deferred from the ctor to avoid memory allocation
+  // during driver initialization. Mirrors #17045 for CudfHashJoinProbe.
+  Operator::initialize();
+
+  if (!joinNode_->joinCondition()) {
+    return;
+  }
+
+  exec::ExprSet exprs({joinNode_->joinCondition()}, operatorCtx_->execCtx());
+  VELOX_CHECK_EQ(exprs.exprs().size(), 1);
+
+  // Convert Velox expression to cuDF AST expression tree.
+  // The AST will be passed to cudf::conditional_inner_join() for GPU
+  // evaluation.
+  createAstTree(
+      exprs.exprs()[0],
+      tree_,
+      scalars_,
+      probeType_,
+      buildType_,
+      leftPrecomputeInstructions_,
+      rightPrecomputeInstructions_);
+
+  // Set hasFilter_ only after the AST has been fully built so that a throw
+  // from createAstTree() does not leave the operator marked as having a filter
+  // with a partially-initialized tree.
+  hasFilter_ = true;
+}
+
+void CudfNestedLoopJoinProbe::doClose() {
+  Operator::close();
+  buildData_.reset();
+  probeMatchedFlags_.reset();
+  buildMatchedFlags_.reset();
+  buildPrecomputed_.clear();
+  scalars_.clear();
+  tree_ = {};
+}
+
+bool CudfNestedLoopJoinProbe::needsInput() const {
+  return !noMoreInput_ && !finished_ && input_ == nullptr &&
+      buildData_.has_value();
+}
+
+void CudfNestedLoopJoinProbe::doAddInput(RowVectorPtr input) {
+  // Skip input processing when build is empty for join types with no output.
+  if (skipInput_) {
+    VELOX_CHECK_NULL(input_);
+    return;
+  }
+  VELOX_CHECK_NULL(input_, "Probe input already set");
+  input_ = std::move(input);
+  probeMatchedFlags_.reset();
+}
+
+void CudfNestedLoopJoinProbe::doNoMoreInput() {
+  Operator::noMoreInput();
+
+  if (!isRightOrFullJoin()) {
+    return;
+  }
+
+  // Empty build has no matched flags to merge across peers.
+  if (buildEmpty_) {
+    return;
+  }
+
+  std::vector<ContinuePromise> promises;
+  std::vector<std::shared_ptr<exec::Driver>> peers;
+
+  if (!operatorCtx_->task()->allPeersFinished(
+          planNodeId(),
+          operatorCtx_->driver(),
+          &peerFuture_,
+          promises,
+          peers)) {
+    return;
+  }
+
+  SCOPE_EXIT {
+    peers.clear();
+    for (auto& promise : promises) {
+      promise.setValue();
+    }
+  };
+
+  isLastDriver_ = true;
+
+  // Unfiltered cross_join matches every build row on every probe batch, so
+  // every driver's buildMatchedFlags_ would be all-true. Skip the stream-join
+  // and peer merge when there is no filter.
+  if (!buildEmpty_ && hasFilter_) {
+    auto stream = cudfGlobalStreamPool().get_stream();
+
+    // GPU stream synchronization: allPeersFinished synchronizes CPU threads
+    // but not GPU streams. A peer's CPU thread may have returned from
+    // getOutput() while its GPU work (updating buildMatchedFlags_) is still
+    // in flight. join_streams establishes GPU-side ordering.
+    std::vector<rmm::cuda_stream_view> inputStreams;
+    if (lastProbeStream_.has_value()) {
+      inputStreams.push_back(lastProbeStream_.value());
+    }
+    for (auto& peer : peers) {
+      if (peer.get() == operatorCtx_->driver()) {
+        continue;
+      }
+      auto op = peer->findOperator(planNodeId());
+      auto* probe = dynamic_cast<CudfNestedLoopJoinProbe*>(op);
+      if (probe != nullptr && probe->lastProbeStream_.has_value()) {
+        inputStreams.push_back(probe->lastProbeStream_.value());
+      }
+    }
+    if (!inputStreams.empty()) {
+      cudf::detail::join_streams(inputStreams, stream);
+    }
+
+    // Merge buildMatchedFlags_ from all peers via BITWISE_OR.
+    for (auto& peer : peers) {
+      if (peer.get() == operatorCtx_->driver()) {
+        continue;
+      }
+      auto op = peer->findOperator(planNodeId());
+      auto* probe = dynamic_cast<CudfNestedLoopJoinProbe*>(op);
+      if (probe == nullptr) {
+        continue;
+      }
+      auto orResult = cudf::binary_operation(
+          buildMatchedFlags_->view(),
+          probe->buildMatchedFlags_->view(),
+          cudf::binary_operator::BITWISE_OR,
+          cudf::data_type{cudf::type_id::BOOL8},
+          stream,
+          get_temp_mr());
+      // binary_operation is async on `stream`; the old column destructs via
+      // cudaFreeAsync on its allocation stream (not `stream`), so the free
+      // can race the kernel. Drain `stream` before the move-assign.
+      stream.synchronize();
+      buildMatchedFlags_ = std::move(orResult);
+    }
+  }
+}
+
+bool CudfNestedLoopJoinProbe::isFinished() {
+  if (finished_) {
+    return true;
+  }
+  // For right/full join, the last driver must not finish until build mismatch
+  // rows have been emitted. Non-last drivers finish normally.
+  if (isRightOrFullJoin() && noMoreInput_ && input_ == nullptr) {
+    if (!isLastDriver_) {
+      return true;
+    }
+    return buildMismatchEmitted_;
+  }
+  return false;
+}
+
+exec::BlockingReason CudfNestedLoopJoinProbe::isBlocked(
+    ContinueFuture* future) {
+  // For right/full join: after build data is available, also block on peer
+  // probes finishing (allPeersFinished barrier in noMoreInput).
+  if (isRightOrFullJoin() && buildData_.has_value()) {
+    if (!peerFuture_.valid()) {
+      return exec::BlockingReason::kNotBlocked;
+    }
+    *future = std::move(peerFuture_);
+    return exec::BlockingReason::kWaitForJoinProbe;
+  }
+
+  if (buildData_.has_value()) {
+    return exec::BlockingReason::kNotBlocked;
+  }
+
+  auto joinBridge = operatorCtx_->task()->getCustomJoinBridge(
+      operatorCtx_->driverCtx()->splitGroupId, planNodeId());
+  auto bridge = std::dynamic_pointer_cast<CudfNestedLoopJoinBridge>(joinBridge);
+  VELOX_CHECK_NOT_NULL(bridge);
+  VELOX_CHECK_NOT_NULL(future);
+
+  buildData_ = bridge->dataOrFuture(future);
+  if (!buildData_.has_value()) {
+    return exec::BlockingReason::kWaitForJoinBuild;
+  }
+
+  buildStream_ = bridge->getBuildStream();
+
+  if (buildData_.value()->num_rows() == 0) {
+    buildEmpty_ = true;
+    // For inner/right join, set skipInput_ to consume probe batches without
+    // processing (prevents upstream exchange hanging). Match CPU NLJ behavior
+    // which always consumes input rather than finishing early.
+    if (skipProbeOnEmptyBuild()) {
+      skipInput_ = true;
+    }
+  }
+
+  // Initialize build matched flags for filtered right/full join (single BOOL8
+  // column with one element per build row, all false). Unfiltered cross_join
+  // matches every build row, so flags aren't needed.
+  if (isRightOrFullJoin() && hasFilter_ && !buildEmpty_) {
+    auto initStream = cudfGlobalStreamPool().get_stream();
+    auto numRows = buildData_.value()->num_rows();
+    auto falseScalar =
+        cudf::numeric_scalar<bool>(false, true, initStream, get_temp_mr());
+    buildMatchedFlags_ = cudf::make_column_from_scalar(
+        falseScalar, numRows, initStream, get_temp_mr());
+    initStream.synchronize();
+  }
+
+  // Precompute build-side sub-expressions for filter evaluation (once, here,
+  // since the build table is fixed for the lifetime of this probe operator).
+  if (hasFilter_ && !rightPrecomputeInstructions_.empty() && !buildEmpty_) {
+    auto precomputeStream = cudfGlobalStreamPool().get_stream();
+    auto buildColumnViews = tableViewToColumnViews(buildData_.value()->view());
+    buildPrecomputed_ = precomputeSubexpressions(
+        buildColumnViews,
+        rightPrecomputeInstructions_,
+        scalars_,
+        buildType_,
+        precomputeStream);
+    buildExtendedView_ =
+        createExtendedTableView(buildData_.value()->view(), buildPrecomputed_);
+    precomputeStream.synchronize();
+  }
+
+  return exec::BlockingReason::kNotBlocked;
+}
+
+void CudfNestedLoopJoinProbe::syncBuildStream(
+    rmm::cuda_stream_view probeStream) {
+  if (buildStream_.has_value()) {
+    if (!cudaEvent_) {
+      cudaEvent_ = std::make_unique<CudaEvent>();
+    }
+    cudaEvent_->recordFrom(buildStream_.value()).waitOn(probeStream);
+    buildStream_.reset();
+  }
+}
+
+std::unique_ptr<cudf::table> CudfNestedLoopJoinProbe::joinWithBuildBatch(
+    cudf::table_view probeTableView,
+    cudf::table_view buildView,
+    rmm::cuda_stream_view stream) {
+  VELOX_NVTX_FUNC_RANGE();
+
+  syncBuildStream(stream);
+
+  auto numOutputColumns = outputType_->size();
+
+  // Extend probe view with precomputed columns for filter AST evaluation.
+  std::vector<ColumnOrView> leftPrecomputed;
+  cudf::table_view extendedProbeView = probeTableView;
+  if (hasFilter_ && !leftPrecomputeInstructions_.empty()) {
+    auto probeColumnViews = tableViewToColumnViews(probeTableView);
+    leftPrecomputed = precomputeSubexpressions(
+        probeColumnViews,
+        leftPrecomputeInstructions_,
+        scalars_,
+        probeType_,
+        stream);
+    extendedProbeView =
+        createExtendedTableView(probeTableView, leftPrecomputed);
+  }
+  // Use cached extended build view if build-side precompute was needed.
+  const cudf::table_view& extendedBuildView =
+      buildPrecomputed_.empty() ? buildView : buildExtendedView_;
+
+  if (hasFilter_) {
+    VELOX_CHECK(
+        isInitialized(),
+        "Filter must be initialized before joinWithBuildBatch");
+    auto [leftIndices, rightIndices] = cudf::conditional_inner_join(
+        extendedProbeView,
+        extendedBuildView,
+        tree_.back(),
+        std::nullopt,
+        stream,
+        get_temp_mr());
+
+    VELOX_CHECK_LE(
+        static_cast<int64_t>(leftIndices->size()),
+        std::numeric_limits<cudf::size_type>::max(),
+        "Conditional join output exceeds cudf::size_type limit: {} rows",
+        leftIndices->size());
+
+    auto leftIndicesView = cudf::column_view(
+        cudf::data_type{cudf::type_to_id<cudf::size_type>()},
+        leftIndices->size(),
+        leftIndices->data(),
+        nullptr,
+        0);
+
+    auto rightIndicesView = cudf::column_view(
+        cudf::data_type{cudf::type_to_id<cudf::size_type>()},
+        rightIndices->size(),
+        rightIndices->data(),
+        nullptr,
+        0);
+
+    // Track which probe rows matched for left/full join mismatch handling.
+    // Uses cudf::contains to check which probe row indices [0..N) appear
+    // in the join result.
+    if (isLeftOrFullJoin()) {
+      auto numProbeRows = probeTableView.num_rows();
+      auto probeRowSequence = cudf::sequence(
+          numProbeRows,
+          cudf::numeric_scalar<cudf::size_type>(0, true, stream, get_temp_mr()),
+          cudf::numeric_scalar<cudf::size_type>(1, true, stream, get_temp_mr()),
+          stream,
+          get_temp_mr());
+
+      // The build side is concatenated into a single table (see
+      // CudfNestedLoopJoinBuild::doNoMoreInput), so joinWithBuildBatch runs
+      // exactly once per probe input. probeMatchedFlags_ is the result of
+      // this single contains() call; no cross-batch BITWISE_OR is needed.
+      probeMatchedFlags_ = cudf::contains(
+          leftIndicesView, probeRowSequence->view(), stream, get_temp_mr());
+    }
+
+    // Track which build rows matched for right/full join mismatch handling.
+    if (isRightOrFullJoin()) {
+      auto numBuildRows = buildView.num_rows();
+      auto buildRowSequence = cudf::sequence(
+          numBuildRows,
+          cudf::numeric_scalar<cudf::size_type>(0, true, stream, get_temp_mr()),
+          cudf::numeric_scalar<cudf::size_type>(1, true, stream, get_temp_mr()),
+          stream,
+          get_temp_mr());
+
+      auto matchedInBatch = cudf::contains(
+          rightIndicesView, buildRowSequence->view(), stream, get_temp_mr());
+
+      auto updatedFlags = cudf::binary_operation(
+          buildMatchedFlags_->view(),
+          matchedInBatch->view(),
+          cudf::binary_operator::BITWISE_OR,
+          cudf::data_type{cudf::type_id::BOOL8},
+          stream,
+          get_temp_mr());
+      stream.synchronize();
+      buildMatchedFlags_ = std::move(updatedFlags);
+    }
+
+    // Gather only the columns needed for output.
+    auto probeGatherView = probeTableView.select(probeColumnIndicesToGather_);
+    auto buildGatherView = buildView.select(buildColumnIndicesToGather_);
+
+    auto gatheredProbe = cudf::gather(
+        probeGatherView,
+        leftIndicesView,
+        cudf::out_of_bounds_policy::DONT_CHECK,
+        stream,
+        get_output_mr());
+
+    auto gatheredBuild = cudf::gather(
+        buildGatherView,
+        rightIndicesView,
+        cudf::out_of_bounds_policy::DONT_CHECK,
+        stream,
+        get_output_mr());
+
+    std::vector<std::unique_ptr<cudf::column>> outCols(numOutputColumns);
+    auto probeCols = gatheredProbe->release();
+    auto buildCols = gatheredBuild->release();
+    for (size_t i = 0; i < probeColumnOutputIndices_.size(); ++i) {
+      outCols[probeColumnOutputIndices_[i]] = std::move(probeCols[i]);
+    }
+    for (size_t i = 0; i < buildColumnOutputIndices_.size(); ++i) {
+      outCols[buildColumnOutputIndices_[i]] = std::move(buildCols[i]);
+    }
+
+    return std::make_unique<cudf::table>(std::move(outCols));
+  }
+
+  // Unfiltered join using cross_join.
+  auto outputRows = static_cast<int64_t>(probeTableView.num_rows()) *
+      static_cast<int64_t>(buildView.num_rows());
+  VELOX_CHECK_LE(
+      outputRows,
+      std::numeric_limits<cudf::size_type>::max(),
+      "Cross join output exceeds cudf::size_type limit: {} x {} = {} rows",
+      probeTableView.num_rows(),
+      buildView.num_rows(),
+      outputRows);
+
+  auto crossResult =
+      cudf::cross_join(probeTableView, buildView, stream, get_output_mr());
+
+  // Cross join matches every row, so no per-row matched flags are needed:
+  // probeMatchedFlags_ is only consumed via emitProbeMismatchRows, which is
+  // unreachable in the unfiltered path (see doGetOutput). buildMatchedFlags_
+  // is skipped in isBlocked for !hasFilter_; emitBuildMismatchRows early-
+  // returns in that case.
+
+  auto allCols = crossResult->release();
+  auto numProbeCols = probeTableView.num_columns();
+
+  std::vector<std::unique_ptr<cudf::column>> outCols(numOutputColumns);
+  for (size_t i = 0; i < probeColumnOutputIndices_.size(); ++i) {
+    outCols[probeColumnOutputIndices_[i]] =
+        std::move(allCols[probeColumnIndicesToGather_[i]]);
+  }
+  for (size_t i = 0; i < buildColumnOutputIndices_.size(); ++i) {
+    outCols[buildColumnOutputIndices_[i]] =
+        std::move(allCols[numProbeCols + buildColumnIndicesToGather_[i]]);
+  }
+
+  return std::make_unique<cudf::table>(std::move(outCols));
+}
+
+std::unique_ptr<cudf::table> CudfNestedLoopJoinProbe::emitProbeMismatchRows(
+    cudf::table_view probeTableView,
+    rmm::cuda_stream_view stream) {
+  auto probeGatherView = probeTableView.select(probeColumnIndicesToGather_);
+
+  std::unique_ptr<cudf::table> unmatchedProbe;
+  if (!probeMatchedFlags_) {
+    // No flags means all probe rows are unmatched (empty build case).
+    unmatchedProbe =
+        std::make_unique<cudf::table>(probeGatherView, stream, get_output_mr());
+  } else {
+    auto unmatchedMask = cudf::unary_operation(
+        probeMatchedFlags_->view(),
+        cudf::unary_operator::NOT,
+        stream,
+        get_temp_mr());
+    unmatchedProbe = cudf::apply_boolean_mask(
+        probeGatherView, unmatchedMask->view(), stream, get_output_mr());
+  }
+
+  auto numUnmatched = static_cast<cudf::size_type>(unmatchedProbe->num_rows());
+  if (numUnmatched == 0) {
+    return nullptr;
+  }
+
+  auto numOutputColumns = outputType_->size();
+  std::vector<std::unique_ptr<cudf::column>> outCols(numOutputColumns);
+
+  // Place unmatched probe columns at their output positions.
+  auto probeCols = unmatchedProbe->release();
+  for (size_t i = 0; i < probeColumnOutputIndices_.size(); ++i) {
+    outCols[probeColumnOutputIndices_[i]] = std::move(probeCols[i]);
+  }
+
+  // Create all-null columns for the build side.
+  for (size_t i = 0; i < buildColumnOutputIndices_.size(); ++i) {
+    auto outIdx = buildColumnOutputIndices_[i];
+    auto buildChannel = buildColumnIndicesToGather_[i];
+    auto buildCudfType = veloxToCudfTypeId(buildType_->childAt(buildChannel));
+    auto nullScalar = cudf::make_default_constructed_scalar(
+        cudf::data_type{buildCudfType}, stream, get_temp_mr());
+    outCols[outIdx] = cudf::make_column_from_scalar(
+        *nullScalar, numUnmatched, stream, get_output_mr());
+  }
+
+  return std::make_unique<cudf::table>(std::move(outCols));
+}
+
+RowVectorPtr CudfNestedLoopJoinProbe::emitBuildMismatchRows(
+    rmm::cuda_stream_view stream) {
+  // Unfiltered cross_join already emitted every build row, so no mismatches
+  // to emit. buildMatchedFlags_ is not allocated in that case.
+  if (!buildMatchedFlags_) {
+    finished_ = true;
+    return nullptr;
+  }
+  auto& buildTable = buildData_.value();
+  auto numOutputColumns = outputType_->size();
+
+  // Invert flags: unmatched = NOT(matched).
+  auto unmatchedMask = cudf::unary_operation(
+      buildMatchedFlags_->view(),
+      cudf::unary_operator::NOT,
+      stream,
+      get_temp_mr());
+
+  // Select unmatched build rows.
+  auto buildGatherView = buildTable->view().select(buildColumnIndicesToGather_);
+  auto unmatchedBuild = cudf::apply_boolean_mask(
+      buildGatherView, unmatchedMask->view(), stream, get_output_mr());
+  auto numUnmatched = static_cast<cudf::size_type>(unmatchedBuild->num_rows());
+
+  finished_ = true;
+  if (numUnmatched == 0) {
+    return nullptr;
+  }
+
+  std::vector<std::unique_ptr<cudf::column>> outCols(numOutputColumns);
+
+  // Create all-null columns for the probe side.
+  for (size_t li = 0; li < probeColumnOutputIndices_.size(); ++li) {
+    auto outIdx = probeColumnOutputIndices_[li];
+    auto probeChannel = probeColumnIndicesToGather_[li];
+    auto probeCudfType = veloxToCudfTypeId(probeType_->childAt(probeChannel));
+    auto nullScalar = cudf::make_default_constructed_scalar(
+        cudf::data_type{probeCudfType}, stream, get_temp_mr());
+    outCols[outIdx] = cudf::make_column_from_scalar(
+        *nullScalar, numUnmatched, stream, get_output_mr());
+  }
+
+  // Place unmatched build columns at their output positions.
+  auto buildCols = unmatchedBuild->release();
+  for (size_t ri = 0; ri < buildColumnOutputIndices_.size(); ++ri) {
+    outCols[buildColumnOutputIndices_[ri]] = std::move(buildCols[ri]);
+  }
+
+  auto out = std::make_unique<cudf::table>(std::move(outCols));
+  auto size = static_cast<vector_size_t>(out->num_rows());
+  return std::make_shared<CudfVector>(
+      operatorCtx_->pool(), outputType_, size, std::move(out), stream);
+}
+
+RowVectorPtr CudfNestedLoopJoinProbe::doGetOutput() {
+  if (!input_) {
+    // Right/full join: after all probe inputs, the last driver emits
+    // unmatched build rows with null probe columns.
+    if (isRightOrFullJoin() && noMoreInput_ && isLastDriver_ &&
+        !buildMismatchEmitted_) {
+      buildMismatchEmitted_ = true;
+      auto stream = cudfGlobalStreamPool().get_stream();
+      return emitBuildMismatchRows(stream);
+    }
+    if (noMoreInput_) {
+      finished_ = true;
+    }
+    return nullptr;
+  }
+
+  VELOX_CHECK(buildData_.has_value(), "Build data not available in getOutput");
+  auto cudfInput = std::dynamic_pointer_cast<CudfVector>(input_);
+  VELOX_CHECK_NOT_NULL(cudfInput);
+  auto stream = cudfInput->stream();
+  lastProbeStream_ = stream;
+
+  // LeftSemiProject: emit all probe rows with a boolean match column.
+  if (joinType_ == core::JoinType::kLeftSemiProject) {
+    auto probeTableView = cudfInput->getTableView();
+    auto numProbeRows = static_cast<cudf::size_type>(probeTableView.num_rows());
+
+    std::unique_ptr<cudf::column> matchFlags;
+    if (buildEmpty_ || !hasFilter_) {
+      // No filter + non-empty build: all probe rows match (true).
+      // Empty build: no probe rows match (false).
+      auto scalar =
+          cudf::numeric_scalar<bool>(!buildEmpty_, true, stream, get_temp_mr());
+      matchFlags = cudf::make_column_from_scalar(
+          scalar, numProbeRows, stream, get_temp_mr());
+    } else {
+      // Filtered: compute matched probe indices against the single build table.
+      auto falseScalar =
+          cudf::numeric_scalar<bool>(false, true, stream, get_temp_mr());
+      matchFlags = cudf::make_column_from_scalar(
+          falseScalar, numProbeRows, stream, get_temp_mr());
+
+      // Extend probe view with precomputed columns if needed.
+      std::vector<ColumnOrView> leftPrecomputed;
+      cudf::table_view extendedProbeView = probeTableView;
+      if (!leftPrecomputeInstructions_.empty()) {
+        auto probeColumnViews = tableViewToColumnViews(probeTableView);
+        leftPrecomputed = precomputeSubexpressions(
+            probeColumnViews,
+            leftPrecomputeInstructions_,
+            scalars_,
+            probeType_,
+            stream);
+        extendedProbeView =
+            createExtendedTableView(probeTableView, leftPrecomputed);
+      }
+      const cudf::table_view& extendedBuildView = buildPrecomputed_.empty()
+          ? buildData_.value()->view()
+          : buildExtendedView_;
+
+      auto matchedIndices = cudf::conditional_left_semi_join(
+          extendedProbeView,
+          extendedBuildView,
+          tree_.back(),
+          {},
+          stream,
+          get_temp_mr());
+
+      if (matchedIndices->size() > 0) {
+        // Build a sequence [0..numProbeRows) and check which indices
+        // appear in the semi-join result.
+        auto probeRowSequence = cudf::sequence(
+            numProbeRows,
+            cudf::numeric_scalar<cudf::size_type>(
+                0, true, stream, get_temp_mr()),
+            cudf::numeric_scalar<cudf::size_type>(
+                1, true, stream, get_temp_mr()),
+            stream,
+            get_temp_mr());
+
+        auto matchedIndicesView = cudf::column_view(
+            cudf::data_type{cudf::type_to_id<cudf::size_type>()},
+            matchedIndices->size(),
+            matchedIndices->data(),
+            nullptr,
+            0);
+
+        auto matchedInBatch = cudf::contains(
+            matchedIndicesView,
+            probeRowSequence->view(),
+            stream,
+            get_temp_mr());
+
+        matchFlags = cudf::binary_operation(
+            matchFlags->view(),
+            matchedInBatch->view(),
+            cudf::binary_operator::BITWISE_OR,
+            cudf::data_type{cudf::type_id::BOOL8},
+            stream,
+            get_temp_mr());
+      }
+    }
+
+    // Copy match flags into output memory resource since they go into the
+    // output table passed downstream.
+    auto outputMatchFlags = std::make_unique<cudf::column>(
+        matchFlags->view(), stream, get_output_mr());
+
+    // Assemble output: probe columns at their mapped positions + match column
+    // at the last position.
+    auto probeGatherView = probeTableView.select(probeColumnIndicesToGather_);
+    auto gatheredProbe =
+        std::make_unique<cudf::table>(probeGatherView, stream, get_output_mr());
+    auto probeCols = gatheredProbe->release();
+
+    auto numOutputColumns = outputType_->size();
+    std::vector<std::unique_ptr<cudf::column>> outCols(numOutputColumns);
+    for (size_t i = 0; i < probeColumnOutputIndices_.size(); ++i) {
+      outCols[probeColumnOutputIndices_[i]] = std::move(probeCols[i]);
+    }
+    outCols[numOutputColumns - 1] = std::move(outputMatchFlags);
+
+    auto result = std::make_unique<cudf::table>(std::move(outCols));
+    input_.reset();
+
+    if (result->num_rows() == 0) {
+      return nullptr;
+    }
+    auto size = static_cast<vector_size_t>(result->num_rows());
+    return std::make_shared<CudfVector>(
+        operatorCtx_->pool(), outputType_, size, std::move(result), stream);
+  }
+
+  // For left/full join with filter: two-phase per probe input.
+  // Phase 1 (probeMatchedFlags_ null): join; joinWithBuildBatch populates
+  // probeMatchedFlags_ from the single build table.
+  // Phase 2 (probeMatchedFlags_ set): emit unmatched probe rows.
+  if (isLeftOrFullJoin() && hasFilter_ && !buildEmpty_) {
+    if (probeMatchedFlags_ == nullptr) {
+      auto result = joinWithBuildBatch(
+          cudfInput->getTableView(), buildData_.value()->view(), stream);
+      if (result->num_rows() > 0) {
+        auto size = static_cast<vector_size_t>(result->num_rows());
+        return std::make_shared<CudfVector>(
+            operatorCtx_->pool(), outputType_, size, std::move(result), stream);
+      }
+      // Join produced no matched rows; fall through to mismatch emission.
+    }
+
+    // Emit unmatched probe rows with null build columns.
+    auto mismatchResult =
+        emitProbeMismatchRows(cudfInput->getTableView(), stream);
+    input_.reset();
+    probeMatchedFlags_.reset();
+    if (mismatchResult && mismatchResult->num_rows() > 0) {
+      auto size = static_cast<vector_size_t>(mismatchResult->num_rows());
+      return std::make_shared<CudfVector>(
+          operatorCtx_->pool(),
+          outputType_,
+          size,
+          std::move(mismatchResult),
+          stream);
+    }
+    return nullptr;
+  }
+
+  // Join probe against the single build table.
+  if (!buildEmpty_) {
+    auto result = joinWithBuildBatch(
+        cudfInput->getTableView(), buildData_.value()->view(), stream);
+    if (result->num_rows() > 0) {
+      input_.reset();
+      auto size = static_cast<vector_size_t>(result->num_rows());
+      return std::make_shared<CudfVector>(
+          operatorCtx_->pool(), outputType_, size, std::move(result), stream);
+    }
+  }
+
+  // Left/full join with empty build: emit all probe rows as mismatches.
+  if (isLeftOrFullJoin() && buildEmpty_) {
+    auto mismatchResult =
+        emitProbeMismatchRows(cudfInput->getTableView(), stream);
+    input_.reset();
+    probeMatchedFlags_.reset();
+    if (mismatchResult && mismatchResult->num_rows() > 0) {
+      auto size = static_cast<vector_size_t>(mismatchResult->num_rows());
+      return std::make_shared<CudfVector>(
+          operatorCtx_->pool(),
+          outputType_,
+          size,
+          std::move(mismatchResult),
+          stream);
+    }
+    return nullptr;
+  }
+
+  input_.reset();
+  return nullptr;
+}
+
+// BridgeTranslator implementation
+std::unique_ptr<exec::Operator> CudfNestedLoopJoinBridgeTranslator::toOperator(
+    exec::DriverCtx* ctx,
+    int32_t id,
+    const core::PlanNodePtr& node) {
+  if (auto joinNode =
+          std::dynamic_pointer_cast<const core::NestedLoopJoinNode>(node)) {
+    return std::make_unique<CudfNestedLoopJoinProbe>(id, ctx, joinNode);
+  }
+  return nullptr;
+}
+
+std::unique_ptr<exec::JoinBridge>
+CudfNestedLoopJoinBridgeTranslator::toJoinBridge(
+    const core::PlanNodePtr& /* node */) {
+  return std::make_unique<CudfNestedLoopJoinBridge>();
+}
+
+exec::OperatorSupplier CudfNestedLoopJoinBridgeTranslator::toOperatorSupplier(
+    const core::PlanNodePtr& node) {
+  if (auto joinNode =
+          std::dynamic_pointer_cast<const core::NestedLoopJoinNode>(node)) {
+    return [joinNode](int32_t operatorId, exec::DriverCtx* ctx) {
+      return std::make_unique<CudfNestedLoopJoinBuild>(
+          operatorId, ctx, joinNode);
+    };
+  }
+  return nullptr;
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfNestedLoopJoin.h b/velox/experimental/cudf/exec/CudfNestedLoopJoin.h
new file mode 100644
index 00000000000..144ae4c18df
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfNestedLoopJoin.h
@@ -0,0 +1,298 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/experimental/cudf/exec/CudfOperator.h"
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
+#include "velox/experimental/cudf/expression/PrecomputeInstruction.h"
+#include "velox/experimental/cudf/vector/CudfVector.h"
+
+#include "velox/core/PlanNode.h"
+#include "velox/exec/JoinBridge.h"
+
+#include <cudf/ast/expressions.hpp>
+#include <cudf/column/column.hpp>
+#include <cudf/scalar/scalar.hpp>
+#include <cudf/table/table.hpp>
+
+#include <rmm/cuda_stream_view.hpp>
+
+#include <memory>
+
+namespace facebook::velox::cudf_velox {
+
+class CudaEvent;
+
+/// Coordinates data transfer from build to probe operators for nested loop
+/// join. Build operators accumulate batches, then one operator transfers them
+/// to the bridge. Probe operators block until build data is available, then
+/// perform a cartesian product (cross join) with optional filtering.
+///
+/// Thread-safety: All methods use mutex locking for concurrent access.
+class CudfNestedLoopJoinBridge : public exec::JoinBridge {
+ public:
+  // Build data: single concatenated build-side table. NLJ requires a single
+  // table because the cross-join output is probe_rows × build_rows — batching
+  // the build side does not prevent output overflow, so we enforce a single
+  // table and fail early if the build side exceeds cudf::size_type limits.
+  using build_data_type = std::shared_ptr<cudf::table>;
+
+  void setData(std::optional<build_data_type> data);
+
+  std::optional<build_data_type> dataOrFuture(ContinueFuture* future);
+
+  void setBuildStream(rmm::cuda_stream_view buildStream);
+
+  std::optional<rmm::cuda_stream_view> getBuildStream();
+
+ private:
+  std::optional<build_data_type> data_;
+  std::optional<rmm::cuda_stream_view> buildStream_;
+};
+
+/// Accumulates build-side input for nested loop join.
+///
+/// Lifecycle:
+/// 1. addInput() - Collects all input batches in memory (as CudfVectors)
+/// 2. noMoreInput() - Called when upstream finishes
+///    - One build operator (chosen via allPeersFinished) transfers all
+///      accumulated data to the bridge
+///    - Other operators just mark themselves as finished
+/// 3. getOutput() - Always returns nullptr (build operators don't produce
+/// output)
+/// 4. isFinished() - True after noMoreInput() and bridge transfer completes
+///
+/// Memory: All build-side data is kept in GPU memory until the join completes.
+/// For very large build sides, this could be memory-intensive.
+class CudfNestedLoopJoinBuild : public CudfOperatorBase {
+ public:
+  CudfNestedLoopJoinBuild(
+      int32_t operatorId,
+      exec::DriverCtx* driverCtx,
+      std::shared_ptr<const core::NestedLoopJoinNode> joinNode);
+
+  bool needsInput() const override;
+
+  exec::BlockingReason isBlocked(ContinueFuture* future) override;
+
+  bool isFinished() override;
+
+ protected:
+  void doAddInput(RowVectorPtr input) override;
+  RowVectorPtr doGetOutput() override;
+  void doNoMoreInput() override;
+  void doClose() override;
+
+ private:
+  std::shared_ptr<const core::NestedLoopJoinNode> joinNode_;
+  std::vector<CudfVectorPtr> inputs_;
+  ContinueFuture future_{ContinueFuture::makeEmpty()};
+};
+
+/// Performs nested loop join using cuDF APIs.
+///
+/// Supports inner, left, right, full outer, and left semi project joins.
+///
+/// Algorithm (two-path approach for optimal performance):
+///
+/// Path 1 - No filter (cross join):
+///   Uses cudf::cross_join(probe, build) for full cartesian product.
+///
+/// Path 2 - With filter (conditional join):
+///   Uses cudf::conditional_inner_join(probe, build, ast) to evaluate the
+///   filter on GPU, returning only matching row index pairs, then gathers
+///   actual data using indices.
+///
+/// Mismatch handling (left/right joins):
+///   We cannot use per-probe left/right join APIs (a probe row unmatched
+///   against the build may still match in another probe batch). Instead, we
+///   always use conditional_inner_join and track mismatches via GPU-side BOOL8
+///   flag columns:
+///   - Left join: probeMatchedFlags_ tracks probe mismatches for the current
+///     probe batch. After the build is exhausted, unmatched probe rows are
+///     emitted with null build columns.
+///   - Right join: buildMatchedFlags_ tracks build mismatches across all probe
+///     inputs. After all probes finish, the last driver (via allPeersFinished)
+///     merges flags from all peers and emits unmatched build rows with null
+///     probe columns.
+///
+/// Lifecycle:
+/// 1. Constructor - Builds AST filter if join condition exists
+/// 2. isBlocked() - Waits for build data from bridge; for right join, also
+///    blocks on peer probes finishing (allPeersFinished barrier)
+/// 3. addInput() - Receives probe batches one at a time
+/// 4. getOutput() - Performs join, returns results (including mismatch rows
+///    for left/right joins)
+/// 5. noMoreInput() - For right join, coordinates multi-driver build mismatch
+///    flag merging
+///
+/// Thread-safety: Each probe operator processes one batch at a time.
+/// Multiple probe operators can run concurrently on different batches.
+class CudfNestedLoopJoinProbe : public CudfOperatorBase {
+ public:
+  using build_data_type = CudfNestedLoopJoinBridge::build_data_type;
+
+  CudfNestedLoopJoinProbe(
+      int32_t operatorId,
+      exec::DriverCtx* driverCtx,
+      std::shared_ptr<const core::NestedLoopJoinNode> joinNode);
+
+  void initialize() override;
+
+  bool needsInput() const override;
+
+  exec::BlockingReason isBlocked(ContinueFuture* future) override;
+
+  bool isFinished() override;
+
+  static bool isSupportedJoinType(core::JoinType joinType) {
+    return joinType == core::JoinType::kInner ||
+        joinType == core::JoinType::kLeft ||
+        joinType == core::JoinType::kRight ||
+        joinType == core::JoinType::kFull ||
+        joinType == core::JoinType::kLeftSemiProject;
+  }
+
+  /// Returns true if we should skip probe input when build side is empty.
+  bool skipProbeOnEmptyBuild() const {
+    return joinType_ == core::JoinType::kInner ||
+        joinType_ == core::JoinType::kRight;
+  }
+
+ protected:
+  void doAddInput(RowVectorPtr input) override;
+  RowVectorPtr doGetOutput() override;
+  void doNoMoreInput() override;
+  void doClose() override;
+
+ private:
+  /// Joins a single probe batch against the build table. Uses cross_join for
+  /// unfiltered joins and conditional_inner_join for filtered joins. Updates
+  /// probeMatchedFlags_ for left/full joins and buildMatchedFlags_ for
+  /// right/full joins.
+  std::unique_ptr<cudf::table> joinWithBuildBatch(
+      cudf::table_view probeTableView,
+      cudf::table_view buildView,
+      rmm::cuda_stream_view stream);
+
+  /// Emits probe rows that had no match across all build batches, with null
+  /// build columns. Used for left/full joins after all build batches exhausted.
+  std::unique_ptr<cudf::table> emitProbeMismatchRows(
+      cudf::table_view probeTableView,
+      rmm::cuda_stream_view stream);
+
+  /// Emits build rows that had no match across all probe inputs, with null
+  /// probe columns. Used for right/full joins after all probes finish. Only
+  /// called by the last driver after merging flags from all peers.
+  RowVectorPtr emitBuildMismatchRows(rmm::cuda_stream_view stream);
+
+  /// Ensures build-stream data is visible on the given probe stream.
+  void syncBuildStream(rmm::cuda_stream_view probeStream);
+
+  bool isLeftOrFullJoin() const {
+    return joinType_ == core::JoinType::kLeft ||
+        joinType_ == core::JoinType::kFull;
+  }
+
+  bool isRightOrFullJoin() const {
+    return joinType_ == core::JoinType::kRight ||
+        joinType_ == core::JoinType::kFull;
+  }
+
+  std::shared_ptr<const core::NestedLoopJoinNode> joinNode_;
+  core::JoinType joinType_;
+  std::optional<build_data_type> buildData_;
+
+  // Filter condition AST (for conditional_inner_join when filter exists).
+  bool hasFilter_{false};
+  cudf::ast::tree tree_;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars_;
+  // Precompute instructions for expressions not directly representable in cuDF
+  // AST. These sub-expressions are evaluated into extra columns appended to
+  // each table view before it is passed to cuDF join APIs.
+  std::vector<PrecomputeInstruction> leftPrecomputeInstructions_;
+  std::vector<PrecomputeInstruction> rightPrecomputeInstructions_;
+
+  // Output column mapping resolved by name from the output type.
+  // Handles arbitrary column ordering (e.g., {"b0", "p0"}).
+  std::vector<cudf::size_type> probeColumnIndicesToGather_;
+  std::vector<cudf::size_type> buildColumnIndicesToGather_;
+  std::vector<size_t> probeColumnOutputIndices_;
+  std::vector<size_t> buildColumnOutputIndices_;
+
+  // Probe and build types (cached for null column creation in left joins).
+  RowTypePtr probeType_;
+  RowTypePtr buildType_;
+
+  bool finished_{false};
+
+  // Probe mismatch tracking for left/full joins: BOOL8 column, one element
+  // per probe row in the current input batch. Populated by
+  // joinWithBuildBatch against the concatenated build table (single batch);
+  // reset between probe inputs.
+  std::unique_ptr<cudf::column> probeMatchedFlags_;
+
+  // True when build side has no rows.
+  bool buildEmpty_{false};
+
+  // Skip probe input processing when build is empty for specific join types.
+  // Prevents upstream exchange hanging by consuming all probe input.
+  bool skipInput_{false};
+
+  // Cached precomputed columns for the build table (populated once in
+  // isBlocked() when rightPrecomputeInstructions_ is non-empty). Kept alive
+  // alongside buildExtendedView_ which holds non-owning views into them.
+  std::vector<ColumnOrView> buildPrecomputed_;
+  // Extended build table view: original build columns + precomputed columns.
+  // Valid only when buildPrecomputed_ is non-empty.
+  cudf::table_view buildExtendedView_{};
+
+  // Build mismatch tracking for right/full joins: BOOL8 column, one element
+  // per build row. Updated across all probe inputs via BITWISE_OR. Merged from
+  // peers in noMoreInput() before the last driver emits unmatched build rows.
+  std::unique_ptr<cudf::column> buildMatchedFlags_;
+
+  // Multi-driver coordination for right/full join build mismatch emission.
+  bool isLastDriver_{false};
+  ContinueFuture peerFuture_{ContinueFuture::makeEmpty()};
+  bool buildMismatchEmitted_{false};
+
+  // Last CUDA stream used for probing, needed for join_streams in
+  // noMoreInput() to ensure GPU-side ordering before flag merge.
+  std::optional<rmm::cuda_stream_view> lastProbeStream_;
+
+  // CUDA stream synchronization for build data visibility.
+  std::optional<rmm::cuda_stream_view> buildStream_;
+  std::unique_ptr<CudaEvent> cudaEvent_;
+};
+
+/// Creates CUDF nested loop join operators and bridges.
+class CudfNestedLoopJoinBridgeTranslator
+    : public exec::Operator::PlanNodeTranslator {
+ public:
+  /// Creates a CudfNestedLoopJoinProbe operator for the given plan node.
+  std::unique_ptr<exec::Operator>
+  toOperator(exec::DriverCtx* ctx, int32_t id, const core::PlanNodePtr& node);
+
+  /// Creates a CudfNestedLoopJoinBridge for the given plan node.
+  std::unique_ptr<exec::JoinBridge> toJoinBridge(const core::PlanNodePtr& node);
+
+  /// Returns a supplier that creates CudfNestedLoopJoinBuild operators.
+  exec::OperatorSupplier toOperatorSupplier(const core::PlanNodePtr& node);
+};
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfOperator.h b/velox/experimental/cudf/exec/CudfOperator.h
new file mode 100644
index 00000000000..2ae2f49db60
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfOperator.h
@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/exec/DebugUtil.h"
+#include "velox/experimental/cudf/exec/NvtxHelper.h"
+
+#include "velox/common/base/SpillConfig.h"
+#include "velox/core/PlanNode.h"
+#include "velox/exec/Operator.h"
+
+#include <glog/logging.h>
+
+#include <type_traits>
+
+namespace facebook::velox::cudf_velox {
+
+/// Bitmask controlling which operator methods get NVTX profiling ranges.
+/// Operators pass flags for the do* methods they actually override, so
+/// no-op methods don't pollute nsys profiles with empty ranges.
+enum NvtxMethodFlag : uint8_t {
+  kNone = 0,
+  kAddInput = 1 << 0,
+  kGetOutput = 1 << 1,
+  kNoMoreInput = 1 << 2,
+  kClose = 1 << 3,
+  kAll = kAddInput | kGetOutput | kNoMoreInput | kClose,
+};
+
+inline NvtxMethodFlag operator|(NvtxMethodFlag a, NvtxMethodFlag b) {
+  using EnumT = std::underlying_type_t<NvtxMethodFlag>;
+  return static_cast<NvtxMethodFlag>(
+      static_cast<EnumT>(a) | static_cast<EnumT>(b));
+}
+
+inline NvtxMethodFlag operator&(NvtxMethodFlag a, NvtxMethodFlag b) {
+  using EnumT = std::underlying_type_t<NvtxMethodFlag>;
+  return static_cast<NvtxMethodFlag>(
+      static_cast<EnumT>(a) & static_cast<EnumT>(b));
+}
+
+/// The user defined operator will inherit this operator, the operator accepts
+/// CudfOperator and output CudfVector.
+class CudfOperator : public NvtxHelper {
+ public:
+  CudfOperator(
+      int32_t operatorId,
+      const core::PlanNodeId& nodeId,
+      std::optional<nvtx3::color> color = std::nullopt)
+      : NvtxHelper(color, operatorId, fmt::format("[{}]", nodeId)) {}
+};
+
+/// Base class for all built-in cuDF operators in Velox.
+///
+/// All cuDF operators MUST extend this class rather than extending
+/// exec::Operator and NvtxHelper directly. This class implements the template
+/// method pattern:
+/// the public operator interface methods (addInput, getOutput, noMoreInput,
+/// close) are marked final and must NOT be overridden by derived classes.
+/// Instead, derived classes should ONLY override the corresponding protected
+/// do* virtual methods:
+///   - doAddInput()    -- receives input rows; called by addInput()
+///   - doGetOutput()   -- produces output rows; called by getOutput()
+///   - doNoMoreInput() -- signals end of input; called by noMoreInput()
+///                        (defaults to Operator::noMoreInput())
+///   - doClose()       -- releases resources; called by close()
+///                        (defaults to Operator::close())
+///
+/// This design ensures that NVTX profiling ranges are applied uniformly
+/// across all operators without each subclass having to manage them. The
+/// nvtxMethods bitmask (NvtxMethodFlag) lets operators suppress NVTX ranges
+/// for do* methods they do not override, keeping nsys profiles clean.
+///
+/// Example:
+///   class MyCudfOperator : public CudfOperatorBase {
+///    public:
+///     MyCudfOperator(int32_t operatorId, exec::DriverCtx* ctx,
+///                    RowTypePtr outputType, const core::PlanNodeId& nodeId)
+///         : CudfOperatorBase(
+///               operatorId, ctx, outputType, nodeId, "MyCudfOperator",
+///               std::nullopt,
+///               NvtxMethodFlag::kAddInput | NvtxMethodFlag::kGetOutput) {}
+///
+///     bool needsInput() const override { return !noMoreInput_; }
+///
+///    protected:
+///     void doAddInput(RowVectorPtr input) override { /* process input */ }
+///     RowVectorPtr doGetOutput() override { /* return output or nullptr */ }
+///   };
+class CudfOperatorBase : public exec::Operator, public NvtxHelper {
+ public:
+  CudfOperatorBase(
+      int32_t operatorId,
+      exec::DriverCtx* driverCtx,
+      RowTypePtr outputType,
+      const core::PlanNodeId& planNodeId,
+      const std::string& operatorName,
+      std::optional<nvtx3::color> color = std::nullopt,
+      NvtxMethodFlag nvtxMethods = NvtxMethodFlag::kAll,
+      std::optional<common::SpillConfig> spillConfig = std::nullopt,
+      std::optional<std::shared_ptr<const core::PlanNode>> planNode =
+          std::nullopt)
+      : Operator(
+            driverCtx,
+            outputType,
+            operatorId,
+            planNodeId,
+            operatorName,
+            spillConfig),
+        NvtxHelper(color, operatorId, fmt::format("[{}]", planNodeId)),
+        className_(operatorName),
+        nvtxMethods_(nvtxMethods) {}
+
+  void addInput(RowVectorPtr input) final {
+    VELOX_NVTX_OPERATOR_FUNC_RANGE_IF(
+        nvtxMethods_ & NvtxMethodFlag::kAddInput, className_);
+    doAddInput(std::move(input));
+    checkCudaErrorInDebug();
+  }
+
+  RowVectorPtr getOutput() final {
+    VELOX_NVTX_OPERATOR_FUNC_RANGE_IF(
+        nvtxMethods_ & NvtxMethodFlag::kGetOutput, className_);
+    auto result = doGetOutput();
+    checkCudaErrorInDebug();
+    return result;
+  }
+
+  void noMoreInput() final {
+    VELOX_NVTX_OPERATOR_FUNC_RANGE_IF(
+        nvtxMethods_ & NvtxMethodFlag::kNoMoreInput, className_);
+    doNoMoreInput();
+    checkCudaErrorInDebug();
+  }
+
+  void close() final {
+    VELOX_NVTX_OPERATOR_FUNC_RANGE_IF(
+        nvtxMethods_ & NvtxMethodFlag::kClose, className_);
+    doClose();
+    checkCudaErrorInDebug();
+  }
+
+ protected:
+  virtual void doAddInput(RowVectorPtr input) = 0;
+
+  virtual RowVectorPtr doGetOutput() = 0;
+
+  virtual void doNoMoreInput() {
+    Operator::noMoreInput();
+  }
+
+  virtual void doClose() {
+    Operator::close();
+  }
+
+ private:
+  const std::string className_;
+  const NvtxMethodFlag nvtxMethods_;
+};
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfOrderBy.cpp b/velox/experimental/cudf/exec/CudfOrderBy.cpp
index d395ac9d0a9..3bb6416c660 100644
--- a/velox/experimental/cudf/exec/CudfOrderBy.cpp
+++ b/velox/experimental/cudf/exec/CudfOrderBy.cpp
@@ -14,7 +14,9 @@
  * limitations under the License.
  */
 
+#include "velox/experimental/cudf/CudfNoDefaults.h"
 #include "velox/experimental/cudf/exec/CudfOrderBy.h"
+#include "velox/experimental/cudf/exec/GpuResources.h"
 #include "velox/experimental/cudf/exec/NvtxHelper.h"
 #include "velox/experimental/cudf/exec/Utilities.h"
 
@@ -26,16 +28,16 @@ CudfOrderBy::CudfOrderBy(
     int32_t operatorId,
     exec::DriverCtx* driverCtx,
     const std::shared_ptr<const core::OrderByNode>& orderByNode)
-    : exec::Operator(
+    : CudfOperatorBase(
+          operatorId,
           driverCtx,
           orderByNode->outputType(),
-          operatorId,
           orderByNode->id(),
-          "CudfOrderBy"),
-      NvtxHelper(
+          "CudfOrderBy",
           nvtx3::rgb{64, 224, 208}, // Turquoise
-          operatorId,
-          fmt::format("[{}]", orderByNode->id())),
+          NvtxMethodFlag::kAll,
+          std::nullopt,
+          orderByNode),
       orderByNode_(orderByNode) {
   sortKeys_.reserve(orderByNode->sortingKeys().size());
   columnOrder_.reserve(orderByNode->sortingKeys().size());
@@ -58,7 +60,7 @@ CudfOrderBy::CudfOrderBy(
   }
 }
 
-void CudfOrderBy::addInput(RowVectorPtr input) {
+void CudfOrderBy::doAddInput(RowVectorPtr input) {
   // Accumulate inputs
   if (input->size() > 0) {
     auto cudfInput = std::dynamic_pointer_cast<CudfVector>(input);
@@ -67,43 +69,39 @@ void CudfOrderBy::addInput(RowVectorPtr input) {
   }
 }
 
-void CudfOrderBy::noMoreInput() {
-  exec::Operator::noMoreInput();
-
-  VELOX_NVTX_OPERATOR_FUNC_RANGE();
+void CudfOrderBy::doNoMoreInput() {
+  Operator::noMoreInput();
 
   if (inputs_.empty()) {
     return;
   }
 
   auto stream = cudfGlobalStreamPool().get_stream();
-  auto tbl = getConcatenatedTable(inputs_, stream);
-
-  // Release input data after synchronizing
-  stream.synchronize();
-  inputs_.clear();
+  // Using the output memory resource to allow spilling to CPU memory.
+  auto tbl = getConcatenatedTable(
+      std::exchange(inputs_, {}), outputType_, stream, get_output_mr());
 
   VELOX_CHECK_NOT_NULL(tbl);
 
   auto keys = tbl->view().select(sortKeys_);
   auto values = tbl->view();
-  auto result =
-      cudf::sort_by_key(values, keys, columnOrder_, nullOrder_, stream);
+  auto result = cudf::sort_by_key(
+      values, keys, columnOrder_, nullOrder_, stream, get_output_mr());
   auto const size = result->num_rows();
   outputTable_ = std::make_shared<CudfVector>(
       pool(), outputType_, size, std::move(result), stream);
 }
 
-RowVectorPtr CudfOrderBy::getOutput() {
+RowVectorPtr CudfOrderBy::doGetOutput() {
   if (finished_ || !noMoreInput_) {
     return nullptr;
   }
-  finished_ = noMoreInput_;
+  finished_ = true;
   return outputTable_;
 }
 
-void CudfOrderBy::close() {
-  exec::Operator::close();
+void CudfOrderBy::doClose() {
+  Operator::close();
   // Release stored inputs
   // Release cudf memory resources
   inputs_.clear();
diff --git a/velox/experimental/cudf/exec/CudfOrderBy.h b/velox/experimental/cudf/exec/CudfOrderBy.h
index 10bf768d5d5..f427fd10a19 100644
--- a/velox/experimental/cudf/exec/CudfOrderBy.h
+++ b/velox/experimental/cudf/exec/CudfOrderBy.h
@@ -16,7 +16,7 @@
 
 #pragma once
 
-#include "velox/experimental/cudf/exec/NvtxHelper.h"
+#include "velox/experimental/cudf/exec/CudfOperator.h"
 #include "velox/experimental/cudf/vector/CudfVector.h"
 
 #include "velox/exec/Operator.h"
@@ -26,7 +26,7 @@
 
 namespace facebook::velox::cudf_velox {
 
-class CudfOrderBy : public exec::Operator, public NvtxHelper {
+class CudfOrderBy : public CudfOperatorBase {
  public:
   CudfOrderBy(
       int32_t operatorId,
@@ -37,12 +37,6 @@ class CudfOrderBy : public exec::Operator, public NvtxHelper {
     return !finished_;
   }
 
-  void addInput(RowVectorPtr input) override;
-
-  void noMoreInput() override;
-
-  RowVectorPtr getOutput() override;
-
   exec::BlockingReason isBlocked(ContinueFuture* /*future*/) override {
     return exec::BlockingReason::kNotBlocked;
   }
@@ -51,7 +45,11 @@ class CudfOrderBy : public exec::Operator, public NvtxHelper {
     return finished_;
   }
 
-  void close() override;
+ protected:
+  void doAddInput(RowVectorPtr input) override;
+  RowVectorPtr doGetOutput() override;
+  void doNoMoreInput() override;
+  void doClose() override;
 
  private:
   CudfVectorPtr outputTable_;
diff --git a/velox/experimental/cudf/exec/CudfReduce.cpp b/velox/experimental/cudf/exec/CudfReduce.cpp
new file mode 100644
index 00000000000..dbf71b5143f
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfReduce.cpp
@@ -0,0 +1,677 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/CudfNoDefaults.h"
+#include "velox/experimental/cudf/exec/CudfAggregation.h"
+#include "velox/experimental/cudf/exec/CudfFilterProject.h"
+#include "velox/experimental/cudf/exec/CudfReduce.h"
+#include "velox/experimental/cudf/exec/GpuResources.h"
+#include "velox/experimental/cudf/exec/Utilities.h"
+#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+
+#include "velox/exec/Aggregate.h"
+#include "velox/exec/AggregateFunctionRegistry.h"
+#include "velox/exec/Task.h"
+#include "velox/expression/Expr.h"
+
+#include <cudf/binaryop.hpp>
+#include <cudf/column/column_factories.hpp>
+#include <cudf/reduction.hpp>
+#include <cudf/reduction/approx_distinct_count.hpp>
+#include <cudf/strings/strings_column_view.hpp>
+#include <cudf/unary.hpp>
+#include <cudf/utilities/error.hpp>
+
+namespace {
+
+using namespace facebook::velox;
+using facebook::velox::cudf_velox::CountInputKind;
+using facebook::velox::cudf_velox::get_output_mr;
+using facebook::velox::cudf_velox::get_temp_mr;
+using facebook::velox::cudf_velox::ReduceAggregator;
+using facebook::velox::cudf_velox::ResolvedAggregateInfo;
+
+#define DEFINE_SIMPLE_REDUCE_AGGREGATOR(Name, name)                    \
+  struct Reduce##Name##Aggregator : ReduceAggregator {                 \
+    Reduce##Name##Aggregator(                                          \
+        core::AggregationNode::Step step,                              \
+        uint32_t inputIndex,                                           \
+        VectorPtr constant,                                            \
+        const TypePtr& resultType)                                     \
+        : ReduceAggregator(step, inputIndex, constant, resultType) {}  \
+                                                                       \
+    std::unique_ptr<cudf::column> doReduce(                            \
+        cudf::table_view const& input,                                 \
+        TypePtr const& outputType,                                     \
+        rmm::cuda_stream_view stream,                                  \
+        vector_size_t /*inputRowCount*/) override {                    \
+      auto const aggRequest =                                          \
+          cudf::make_##name##_aggregation<cudf::reduce_aggregation>(); \
+      auto const cudfOutputType =                                      \
+          cudf::data_type(cudf_velox::veloxToCudfTypeId(outputType));  \
+      auto const resultScalar = cudf::reduce(                          \
+          input.column(inputIndex),                                    \
+          *aggRequest,                                                 \
+          cudfOutputType,                                              \
+          stream,                                                      \
+          get_temp_mr());                                              \
+      return cudf::make_column_from_scalar(                            \
+          *resultScalar, 1, stream, get_output_mr());                  \
+    }                                                                  \
+  };
+
+DEFINE_SIMPLE_REDUCE_AGGREGATOR(Sum, sum)
+DEFINE_SIMPLE_REDUCE_AGGREGATOR(Min, min)
+DEFINE_SIMPLE_REDUCE_AGGREGATOR(Max, max)
+
+struct ReduceCountAggregator : ReduceAggregator {
+  ReduceCountAggregator(
+      core::AggregationNode::Step step,
+      uint32_t inputIndex,
+      CountInputKind inputKind,
+      const TypePtr& resultType)
+      : ReduceAggregator(step, inputIndex, nullptr, resultType),
+        inputKind_(inputKind) {}
+
+  std::unique_ptr<cudf::column> doReduce(
+      cudf::table_view const& input,
+      TypePtr const& outputType,
+      rmm::cuda_stream_view stream,
+      vector_size_t inputRowCount) override {
+    if (exec::isRawInput(step)) {
+      int64_t count;
+      switch (inputKind_) {
+        case CountInputKind::kNullConstant:
+          count = 0;
+          break;
+        case CountInputKind::kCountAll:
+          count = input.num_columns() > 0 ? input.num_rows() : inputRowCount;
+          break;
+        case CountInputKind::kColumn: {
+          VELOX_CHECK_GT(
+              input.num_columns(),
+              0,
+              "count(column) requires at least one input column");
+          auto inputCol = input.column(inputIndex);
+          count = inputCol.size() - inputCol.null_count();
+          break;
+        }
+        default:
+          VELOX_UNREACHABLE();
+      }
+
+      auto resultScalar =
+          cudf::numeric_scalar<int64_t>(count, true, stream, get_temp_mr());
+
+      return cudf::make_column_from_scalar(
+          resultScalar, 1, stream, get_output_mr());
+    } else {
+      // For non-raw input (intermediate/final), use sum aggregation
+      auto const aggRequest =
+          cudf::make_sum_aggregation<cudf::reduce_aggregation>();
+      auto const cudfOutputType = cudf::data_type(cudf::type_id::INT64);
+      auto const resultScalar = cudf::reduce(
+          input.column(inputIndex),
+          *aggRequest,
+          cudfOutputType,
+          stream,
+          get_temp_mr());
+      resultScalar->set_valid_async(true, stream);
+      return cudf::make_column_from_scalar(
+          *resultScalar, 1, stream, get_output_mr());
+    }
+  }
+
+ private:
+  CountInputKind inputKind_;
+};
+
+struct ReduceMeanAggregator : ReduceAggregator {
+  ReduceMeanAggregator(
+      core::AggregationNode::Step step,
+      uint32_t inputIndex,
+      VectorPtr constant,
+      const TypePtr& resultType)
+      : ReduceAggregator(step, inputIndex, constant, resultType) {}
+
+  std::unique_ptr<cudf::column> doReduce(
+      cudf::table_view const& input,
+      TypePtr const& outputType,
+      rmm::cuda_stream_view stream,
+      vector_size_t /*inputRowCount*/) override {
+    switch (step) {
+      case core::AggregationNode::Step::kSingle: {
+        auto const aggRequest =
+            cudf::make_mean_aggregation<cudf::reduce_aggregation>();
+        auto const cudfOutputType =
+            cudf::data_type(cudf_velox::veloxToCudfTypeId(outputType));
+        auto const resultScalar = cudf::reduce(
+            input.column(inputIndex),
+            *aggRequest,
+            cudfOutputType,
+            stream,
+            get_temp_mr());
+        return cudf::make_column_from_scalar(
+            *resultScalar, 1, stream, get_output_mr());
+      }
+      case core::AggregationNode::Step::kPartial: {
+        VELOX_CHECK(outputType->isRow());
+        auto const& rowType = outputType->asRow();
+        auto const sumType = rowType.childAt(0);
+        auto const countType = rowType.childAt(1);
+        auto const cudfSumType =
+            cudf::data_type(cudf_velox::veloxToCudfTypeId(sumType));
+        auto const cudfCountType =
+            cudf::data_type(cudf_velox::veloxToCudfTypeId(countType));
+
+        // sum
+        auto const aggRequest =
+            cudf::make_sum_aggregation<cudf::reduce_aggregation>();
+        auto const sumResultScalar = cudf::reduce(
+            input.column(inputIndex),
+            *aggRequest,
+            cudfSumType,
+            stream,
+            get_temp_mr());
+        auto sumCol = cudf::make_column_from_scalar(
+            *sumResultScalar, 1, stream, get_output_mr());
+
+        // libcudf doesn't have a count agg for reduce. What we want is to
+        // count the number of valid rows.
+        auto countCol = cudf::make_column_from_scalar(
+            cudf::numeric_scalar<int64_t>(
+                input.column(inputIndex).size() -
+                    input.column(inputIndex).null_count(),
+                true,
+                stream,
+                get_temp_mr()),
+            1,
+            stream,
+            get_output_mr());
+
+        // Assemble into struct as expected by velox.
+        auto children = std::vector<std::unique_ptr<cudf::column>>();
+        children.push_back(std::move(sumCol));
+        children.push_back(std::move(countCol));
+        return std::make_unique<cudf::column>(
+            cudf::data_type(cudf::type_id::STRUCT),
+            1,
+            rmm::device_buffer{},
+            rmm::device_buffer{},
+            0,
+            std::move(children));
+      }
+      case core::AggregationNode::Step::kFinal: {
+        // Input column has two children: sum and count
+        auto const sumCol = input.column(inputIndex).child(0);
+        auto const countCol = input.column(inputIndex).child(1);
+
+        // sum the sums
+        auto const sumAggRequest =
+            cudf::make_sum_aggregation<cudf::reduce_aggregation>();
+        auto const sumResultScalar = cudf::reduce(
+            sumCol, *sumAggRequest, sumCol.type(), stream, get_temp_mr());
+        auto sumResultCol = cudf::make_column_from_scalar(
+            *sumResultScalar, 1, stream, get_output_mr());
+
+        // sum the counts
+        auto const countAggRequest =
+            cudf::make_sum_aggregation<cudf::reduce_aggregation>();
+        auto const countResultScalar = cudf::reduce(
+            countCol, *countAggRequest, countCol.type(), stream, get_temp_mr());
+
+        // divide the sums by the counts
+        auto const cudfOutputType =
+            cudf::data_type(cudf_velox::veloxToCudfTypeId(outputType));
+        return cudf::binary_operation(
+            *sumResultCol,
+            *countResultScalar,
+            cudf::binary_operator::DIV,
+            cudfOutputType,
+            stream,
+            get_output_mr());
+      }
+      default:
+        VELOX_NYI("Unsupported aggregation step for mean");
+    }
+  }
+};
+
+struct ApproxDistinctAggregator : ReduceAggregator {
+  static constexpr cudf::null_policy kNullPolicy = cudf::null_policy::EXCLUDE;
+  static constexpr cudf::nan_policy kNanPolicy = cudf::nan_policy::NAN_IS_VALID;
+
+  ApproxDistinctAggregator(
+      core::AggregationNode::Step step,
+      uint32_t inputIndex,
+      VectorPtr constant,
+      const TypePtr& resultType,
+      std::int32_t precision = 11) // Default 11 matches Velox's 2.3% standard
+                                   // error (2^11 = 2048 buckets)
+      : ReduceAggregator{step, inputIndex, constant, resultType},
+        precision_{precision} {
+    VELOX_CHECK(
+        constant == nullptr,
+        "ApproxDistinctAggregator does not support constant input");
+  }
+
+  std::unique_ptr<cudf::column> doReduce(
+      cudf::table_view const& input,
+      TypePtr const& outputType,
+      rmm::cuda_stream_view stream,
+      vector_size_t /*inputRowCount*/) override {
+    if (exec::isRawInput(step)) {
+      return doPartialReduce(input, stream);
+    } else if (step == core::AggregationNode::Step::kIntermediate) {
+      return doIntermediateReduce(input, stream);
+    } else {
+      return doFinalReduce(input, stream);
+    }
+  }
+
+ private:
+  std::unique_ptr<cudf::column> makeSketchColumn(
+      cuda::std::span<cuda::std::byte const> sketch_bytes,
+      rmm::cuda_stream_view stream) {
+    auto sketch_size = static_cast<cudf::size_type>(sketch_bytes.size());
+
+    cudf::size_type offsets[2] = {0, sketch_size};
+    rmm::device_buffer offsets_device{2 * sizeof(cudf::size_type), stream};
+    CUDF_CUDA_TRY(cudaMemcpyAsync(
+        offsets_device.data(),
+        offsets,
+        2 * sizeof(cudf::size_type),
+        cudaMemcpyHostToDevice,
+        stream.value()));
+
+    rmm::device_buffer chars_buffer{sketch_bytes.size(), stream};
+    CUDF_CUDA_TRY(cudaMemcpyAsync(
+        chars_buffer.data(),
+        sketch_bytes.data(),
+        sketch_bytes.size(),
+        cudaMemcpyDeviceToDevice,
+        stream.value()));
+
+    // Sync stream before stack-allocated offsets goes out of scope
+    stream.synchronize();
+
+    auto offsets_column = std::make_unique<cudf::column>(
+        cudf::data_type{cudf::type_id::INT32},
+        2,
+        std::move(offsets_device),
+        rmm::device_buffer{},
+        0);
+
+    return cudf::make_strings_column(
+        1,
+        std::move(offsets_column),
+        std::move(chars_buffer),
+        0,
+        rmm::device_buffer{});
+  }
+
+  template <typename Func>
+  auto mergeSketchesAndApply(
+      cudf::column_view const& sketch_column,
+      Func&& func,
+      rmm::cuda_stream_view stream) {
+    auto strings_col = cudf::strings_column_view(sketch_column);
+    auto offsets_col = strings_col.offsets();
+    auto chars_ptr = strings_col.chars_begin(stream);
+
+    auto num_offsets = sketch_column.size() + 1;
+    std::vector<cudf::size_type> host_offsets(num_offsets);
+    CUDF_CUDA_TRY(cudaMemcpyAsync(
+        host_offsets.data(),
+        offsets_col.begin<cudf::size_type>(),
+        num_offsets * sizeof(cudf::size_type),
+        cudaMemcpyDeviceToHost,
+        stream.value()));
+    stream.synchronize(); // Need host_offsets before proceeding
+
+    cudf::size_type first_offset = host_offsets[0];
+    cudf::size_type first_size = host_offsets[1] - first_offset;
+
+    // Copy to mutable aligned buffer - cudf::approx_distinct_count requires
+    // non-const span and proper alignment for int32 registers
+    rmm::device_buffer aligned_sketch{
+        static_cast<std::size_t>(first_size), stream};
+    CUDF_CUDA_TRY(cudaMemcpyAsync(
+        aligned_sketch.data(),
+        chars_ptr + first_offset,
+        static_cast<std::size_t>(first_size),
+        cudaMemcpyDeviceToDevice,
+        stream.value()));
+
+    cudf::approx_distinct_count merged_sketch(
+        cuda::std::span<cuda::std::byte>(
+            static_cast<cuda::std::byte*>(aligned_sketch.data()), first_size),
+        precision_,
+        kNullPolicy,
+        kNanPolicy);
+
+    for (cudf::size_type i = 1; i < sketch_column.size(); ++i) {
+      cudf::size_type start_offset = host_offsets[i];
+      cudf::size_type end_offset = host_offsets[i + 1];
+      cudf::size_type size = end_offset - start_offset;
+
+      if (size > 0) {
+        rmm::device_buffer temp_sketch{static_cast<std::size_t>(size), stream};
+        CUDF_CUDA_TRY(cudaMemcpyAsync(
+            temp_sketch.data(),
+            chars_ptr + start_offset,
+            size,
+            cudaMemcpyDeviceToDevice,
+            stream.value()));
+
+        merged_sketch.merge(
+            cuda::std::span<cuda::std::byte>(
+                static_cast<cuda::std::byte*>(temp_sketch.data()), size),
+            stream);
+      }
+    }
+
+    return func(merged_sketch);
+  }
+
+  std::unique_ptr<cudf::column> doPartialReduce(
+      cudf::table_view const& input,
+      rmm::cuda_stream_view stream) {
+    auto inputTable = cudf::table_view({input.column(inputIndex)});
+
+    cudf::approx_distinct_count sketch{
+        inputTable, precision_, kNullPolicy, kNanPolicy, stream};
+
+    return makeSketchColumn(sketch.sketch(), stream);
+  }
+
+  std::unique_ptr<cudf::column> doIntermediateReduce(
+      cudf::table_view const& input,
+      rmm::cuda_stream_view stream) {
+    auto sketch_column = input.column(inputIndex);
+
+    if (sketch_column.size() == 0) {
+      return makeSketchColumn({}, stream);
+    }
+
+    return mergeSketchesAndApply(
+        sketch_column,
+        [this, stream](cudf::approx_distinct_count& sketch) {
+          return makeSketchColumn(sketch.sketch(), stream);
+        },
+        stream);
+  }
+
+  std::unique_ptr<cudf::column> doFinalReduce(
+      cudf::table_view const& input,
+      rmm::cuda_stream_view stream) {
+    auto sketch_column = input.column(inputIndex);
+
+    if (sketch_column.size() == 0) {
+      return cudf::make_column_from_scalar(
+          cudf::numeric_scalar<int64_t>(0, true, stream, get_temp_mr()),
+          1,
+          stream,
+          get_output_mr());
+    }
+
+    return mergeSketchesAndApply(
+        sketch_column,
+        [stream](cudf::approx_distinct_count& sketch) {
+          std::size_t estimate = sketch.estimate(stream);
+          return cudf::make_column_from_scalar(
+              cudf::numeric_scalar<int64_t>(
+                  static_cast<int64_t>(estimate), true, stream, get_temp_mr()),
+              1,
+              stream,
+              get_output_mr());
+        },
+        stream);
+  }
+
+  std::int32_t precision_;
+};
+
+std::unique_ptr<ReduceAggregator> createReduceAggregator(
+    const ResolvedAggregateInfo& p) {
+  auto const& kind = p.kind;
+  auto prefix = cudf_velox::CudfConfig::getInstance().functionNamePrefix;
+  if (kind.rfind(prefix + "sum", 0) == 0) {
+    return std::make_unique<ReduceSumAggregator>(
+        p.companionStep, p.inputIndex, p.constant, p.resultType);
+  } else if (kind.rfind(prefix + "count", 0) == 0) {
+    VELOX_CHECK(p.countInputKind.has_value());
+    return std::make_unique<ReduceCountAggregator>(
+        p.companionStep, p.inputIndex, *p.countInputKind, p.resultType);
+  } else if (kind.rfind(prefix + "min", 0) == 0) {
+    return std::make_unique<ReduceMinAggregator>(
+        p.companionStep, p.inputIndex, p.constant, p.resultType);
+  } else if (kind.rfind(prefix + "max", 0) == 0) {
+    return std::make_unique<ReduceMaxAggregator>(
+        p.companionStep, p.inputIndex, p.constant, p.resultType);
+  } else if (kind.rfind(prefix + "avg", 0) == 0) {
+    return std::make_unique<ReduceMeanAggregator>(
+        p.companionStep, p.inputIndex, p.constant, p.resultType);
+  } else if (kind.rfind(prefix + "approx_distinct", 0) == 0) {
+    return std::make_unique<ApproxDistinctAggregator>(
+        p.companionStep, p.inputIndex, p.constant, p.resultType);
+  } else {
+    VELOX_NYI("Reduce aggregation not yet supported, kind: {}", kind);
+  }
+}
+
+} // namespace
+
+namespace facebook::velox::cudf_velox {
+
+std::vector<std::unique_ptr<ReduceAggregator>> toReduceAggregators(
+    core::AggregationNode const& aggregationNode,
+    core::AggregationNode::Step step,
+    TypePtr const& outputType,
+    std::vector<VectorPtr> const& constants) {
+  auto params =
+      resolveAggregateInfos(aggregationNode, step, outputType, constants);
+
+  std::vector<std::unique_ptr<ReduceAggregator>> aggregators;
+  aggregators.reserve(params.size());
+  for (const auto& p : params) {
+    aggregators.push_back(createReduceAggregator(p));
+  }
+  return aggregators;
+}
+
+bool canReduceAggregationBeEvaluatedByCudf(
+    const core::CallTypedExpr& call,
+    core::AggregationNode::Step step,
+    const std::vector<TypePtr>& rawInputTypes,
+    core::QueryCtx* queryCtx) {
+  return canAggregationBeEvaluatedByRegistry(
+      getReduceAggregationRegistry(), call, step, rawInputTypes, queryCtx);
+}
+
+bool canReduceBeEvaluatedByCudf(
+    const core::AggregationNode& aggregationNode,
+    core::QueryCtx* queryCtx) {
+  const core::PlanNode* sourceNode = aggregationNode.sources().empty()
+      ? nullptr
+      : aggregationNode.sources()[0].get();
+
+  // Get the aggregation step from the node
+  auto step = aggregationNode.step();
+
+  // Check supported aggregation functions using reduce registry
+  for (const auto& aggregate : aggregationNode.aggregates()) {
+    // Use step-aware validation that handles partial/final/intermediate steps
+    if (!canReduceAggregationBeEvaluatedByCudf(
+            *aggregate.call, step, aggregate.rawInputTypes, queryCtx)) {
+      return false;
+    }
+
+    // `distinct` aggregations are not supported, in testing fails with "De-dup
+    // before aggregation is not yet supported"
+    if (aggregate.distinct) {
+      return false;
+    }
+
+    // `mask` is NOT supported (in testing do not appear to be be applied and
+    // return incorrect results )
+    if (aggregate.mask) {
+      return false;
+    }
+
+    if (isCountFunctionName(aggregate.call->name())) {
+      continue;
+    }
+
+    // Check input expressions can be evaluated by cuDF, expand the input first.
+    for (const auto& input : aggregate.call->inputs()) {
+      auto expandedInput = expandFieldReference(input, sourceNode);
+      std::vector<core::TypedExprPtr> exprs = {expandedInput};
+      if (!canBeEvaluatedByCudf(exprs, queryCtx)) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+CudfReduce::CudfReduce(
+    int32_t operatorId,
+    exec::DriverCtx* driverCtx,
+    std::shared_ptr<core::AggregationNode const> const& aggregationNode)
+    : CudfOperatorBase(
+          operatorId,
+          driverCtx,
+          aggregationNode->outputType(),
+          aggregationNode->id(),
+          std::string{"CudfReduce"} +
+              std::string{
+                  core::AggregationNode::toName(aggregationNode->step())},
+          nvtx3::rgb{34, 139, 34}, // Forest Green
+          NvtxMethodFlag::kAddInput | NvtxMethodFlag::kGetOutput,
+          std::nullopt,
+          aggregationNode),
+      aggregationNode_(aggregationNode),
+      isPartialOutput_(
+          exec::isPartialOutput(aggregationNode->step()) &&
+          !hasFinalAggs(aggregationNode->aggregates())) {}
+
+void CudfReduce::initialize() {
+  Operator::initialize();
+
+  inputType_ = aggregationNode_->sources()[0]->outputType();
+
+  numAggregates_ = aggregationNode_->aggregates().size();
+  const auto inputRowSchema = asRowType(inputType_);
+  std::vector<column_index_t> emptyKeys;
+  auto aggregationInput = buildAggregationInputChannels(
+      *aggregationNode_, *operatorCtx_, inputRowSchema, emptyKeys);
+  aggregationInputChannels_ = std::move(aggregationInput.channels);
+  aggregators_ = toReduceAggregators(
+      *aggregationNode_,
+      aggregationNode_->step(),
+      outputType_,
+      aggregationInput.constants);
+
+  aggregationNode_.reset();
+}
+
+void CudfReduce::doAddInput(RowVectorPtr input) {
+  if (input->size() == 0) {
+    return;
+  }
+  numInputRows_ += input->size();
+
+  auto cudfInput = std::dynamic_pointer_cast<cudf_velox::CudfVector>(input);
+  VELOX_CHECK_NOT_NULL(cudfInput);
+
+  inputs_.push_back(std::move(cudfInput));
+}
+
+CudfVectorPtr CudfReduce::doGlobalAggregation(
+    cudf::table_view tableView,
+    rmm::cuda_stream_view stream) {
+  std::vector<std::unique_ptr<cudf::column>> resultColumns;
+  resultColumns.reserve(aggregators_.size());
+  for (auto i = 0; i < aggregators_.size(); i++) {
+    resultColumns.push_back(
+        aggregators_[i]->doReduce(
+            tableView, outputType_->childAt(i), stream, numInputRows_));
+  }
+
+  return std::make_shared<cudf_velox::CudfVector>(
+      pool(),
+      outputType_,
+      1,
+      std::make_unique<cudf::table>(std::move(resultColumns)),
+      stream);
+}
+
+RowVectorPtr CudfReduce::doGetOutput() {
+  if (finished_) {
+    return nullptr;
+  }
+
+  if (!isPartialOutput_ && !noMoreInput_) {
+    // Final aggregation has to wait for all batches to arrive so we cannot
+    // return any results here.
+    return nullptr;
+  }
+
+  if (inputs_.empty() && !noMoreInput_) {
+    return nullptr;
+  }
+
+  auto stream = cudfGlobalStreamPool().get_stream();
+
+  auto tbl = getConcatenatedTable(
+      std::move(inputs_), inputType_, stream, get_output_mr());
+
+  // Release input data after synchronizing.
+  stream.synchronize();
+  inputs_.clear();
+
+  if (noMoreInput_) {
+    finished_ = true;
+  }
+
+  VELOX_CHECK_NOT_NULL(tbl);
+
+  auto tableView = tbl->view().num_columns() == 0
+      ? tbl->view()
+      : tbl->view().select(
+            aggregationInputChannels_.begin(), aggregationInputChannels_.end());
+  auto output = doGlobalAggregation(tableView, stream);
+  if (isPartialOutput_ && !noMoreInput_) {
+    numInputRows_ = 0;
+  }
+  return output;
+}
+
+void CudfReduce::doNoMoreInput() {
+  Operator::noMoreInput();
+  if (isPartialOutput_ && inputs_.empty()) {
+    finished_ = true;
+  }
+}
+
+bool CudfReduce::isFinished() {
+  return finished_;
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfReduce.h b/velox/experimental/cudf/exec/CudfReduce.h
new file mode 100644
index 00000000000..117adc42f71
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfReduce.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/experimental/cudf/exec/CudfAggregation.h"
+#include "velox/experimental/cudf/exec/CudfOperator.h"
+
+namespace facebook::velox::cudf_velox {
+
+struct ReduceAggregator {
+  core::AggregationNode::Step step;
+  uint32_t inputIndex;
+  VectorPtr constant;
+  TypePtr resultType;
+
+  virtual std::unique_ptr<cudf::column> doReduce(
+      cudf::table_view const& input,
+      TypePtr const& outputType,
+      rmm::cuda_stream_view stream,
+      vector_size_t inputRowCount) = 0;
+
+  virtual ~ReduceAggregator() = default;
+
+ protected:
+  ReduceAggregator(
+      core::AggregationNode::Step step,
+      uint32_t inputIndex,
+      VectorPtr constant,
+      const TypePtr& resultType)
+      : step(step),
+        inputIndex(inputIndex),
+        constant(constant),
+        resultType(resultType) {}
+};
+
+std::vector<std::unique_ptr<ReduceAggregator>> toReduceAggregators(
+    core::AggregationNode const& aggregationNode,
+    core::AggregationNode::Step step,
+    TypePtr const& outputType,
+    std::vector<VectorPtr> const& constants);
+
+bool canReduceBeEvaluatedByCudf(
+    const core::AggregationNode& aggregationNode,
+    core::QueryCtx* queryCtx);
+
+bool canReduceAggregationBeEvaluatedByCudf(
+    const core::CallTypedExpr& call,
+    core::AggregationNode::Step step,
+    const std::vector<TypePtr>& rawInputTypes,
+    core::QueryCtx* queryCtx);
+
+class CudfReduce : public CudfOperatorBase {
+ public:
+  CudfReduce(
+      int32_t operatorId,
+      exec::DriverCtx* driverCtx,
+      std::shared_ptr<const core::AggregationNode> const& aggregationNode);
+
+  void initialize() override;
+
+  bool needsInput() const override {
+    return !noMoreInput_;
+  }
+
+  exec::BlockingReason isBlocked(ContinueFuture* /* unused */) override {
+    return exec::BlockingReason::kNotBlocked;
+  }
+
+  bool isFinished() override;
+
+ protected:
+  void doAddInput(RowVectorPtr input) override;
+
+  RowVectorPtr doGetOutput() override;
+
+  void doNoMoreInput() override;
+
+ private:
+  CudfVectorPtr doGlobalAggregation(
+      cudf::table_view tableView,
+      rmm::cuda_stream_view stream);
+
+  std::shared_ptr<const core::AggregationNode> aggregationNode_;
+  std::vector<std::unique_ptr<ReduceAggregator>> aggregators_;
+
+  std::vector<column_index_t> aggregationInputChannels_;
+
+  const bool isPartialOutput_;
+  // Number of input rows accumulated since the last output.
+  int64_t numInputRows_ = 0;
+
+  bool finished_ = false;
+  size_t numAggregates_;
+
+  std::vector<CudfVectorPtr> inputs_;
+  TypePtr inputType_;
+};
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfTopN.cpp b/velox/experimental/cudf/exec/CudfTopN.cpp
new file mode 100644
index 00000000000..8da7a0f34ae
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfTopN.cpp
@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/CudfNoDefaults.h"
+#include "velox/experimental/cudf/exec/CudfTopN.h"
+#include "velox/experimental/cudf/exec/GpuResources.h"
+#include "velox/experimental/cudf/exec/Utilities.h"
+
+#include <cudf/copying.hpp>
+#include <cudf/detail/utilities/stream_pool.hpp>
+#include <cudf/merge.hpp>
+#include <cudf/sorting.hpp>
+
+namespace facebook::velox::cudf_velox {
+CudfTopN::CudfTopN(
+    int32_t operatorId,
+    exec::DriverCtx* driverCtx,
+    const std::shared_ptr<const core::TopNNode>& topNNode)
+    : CudfOperatorBase(
+          operatorId,
+          driverCtx,
+          topNNode->outputType(),
+          topNNode->id(),
+          "CudfTopN",
+          nvtx3::rgb{175, 238, 238}, // Pale Turquoise
+          NvtxMethodFlag::kAll,
+          std::nullopt,
+          topNNode),
+      count_(topNNode->count()),
+      topNNode_(topNNode),
+      cudaEvent_(std::make_unique<CudaEvent>(cudaEventDisableTiming)) {
+  kBatchSize_ = driverCtx->queryConfig().get<int32_t>(
+      CudfConfig::kCudfTopNBatchSize, kBatchSize_);
+  const auto numColumns{outputType_->children().size()};
+  const auto numSortingKeys{topNNode->sortingKeys().size()};
+  std::vector<bool> isSortingKey(numColumns);
+  sortKeys_.reserve(numSortingKeys);
+  columnOrder_.reserve(numSortingKeys);
+  nullOrder_.reserve(numSortingKeys);
+
+  for (int i = 0; i < numSortingKeys; ++i) {
+    const auto channel =
+        exec::exprToChannel(topNNode->sortingKeys()[i].get(), outputType_);
+    VELOX_CHECK(
+        channel != kConstantChannel,
+        "TopN doesn't allow constant sorting keys");
+    sortKeys_.push_back(channel);
+    isSortingKey[channel] = true;
+    auto const& sortingOrder = topNNode->sortingOrders()[i];
+    columnOrder_.push_back(
+        sortingOrder.isAscending() ? cudf::order::ASCENDING
+                                   : cudf::order::DESCENDING);
+    nullOrder_.push_back(
+        (sortingOrder.isNullsFirst() ^ !sortingOrder.isAscending())
+            ? cudf::null_order::BEFORE
+            : cudf::null_order::AFTER);
+  }
+}
+
+CudfVectorPtr CudfTopN::mergeTopK(
+    std::vector<CudfVectorPtr> topNBatches,
+    int32_t k,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  std::vector<cudf::table_view> tableViews;
+  std::vector<rmm::cuda_stream_view> inputStreams;
+  tableViews.reserve(topNBatches.size());
+  inputStreams.reserve(topNBatches.size());
+  for (const auto& batch : topNBatches) {
+    if (!batch) {
+      continue;
+    }
+    tableViews.push_back(batch->getTableView());
+    inputStreams.push_back(batch->stream());
+  }
+  cudf::detail::join_streams(inputStreams, stream);
+  auto mergedTable =
+      cudf::merge(tableViews, sortKeys_, columnOrder_, nullOrder_, stream, mr);
+  // Ensure input-stream deallocations don't race with merge stream.
+  streamsWaitForStream(*cudaEvent_, inputStreams, stream);
+  // slice it
+  auto topk =
+      cudf::split(
+          mergedTable->view(), {std::min(k, mergedTable->num_rows())}, stream)
+          .front();
+  auto const size = topk.num_rows();
+  return std::make_shared<CudfVector>(
+      topNBatches[0]->pool(),
+      outputType_,
+      size,
+      std::make_unique<cudf::table>(topk, stream, mr),
+      stream);
+}
+
+std::unique_ptr<cudf::table> CudfTopN::getTopK(
+    cudf::table_view const& values,
+    int32_t k,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  auto keys = values.select(sortKeys_);
+  auto const indices =
+      cudf::stable_sorted_order(keys, columnOrder_, nullOrder_, stream, mr);
+  auto const kIndices =
+      cudf::split(indices->view(), {std::min(k, indices->size())}, stream)
+          .front();
+  return cudf::gather(
+      values,
+      kIndices,
+      cudf::out_of_bounds_policy::DONT_CHECK,
+      cudf::negative_index_policy::NOT_ALLOWED,
+      stream,
+      mr);
+}
+
+// helper to get topk of a table
+CudfVectorPtr CudfTopN::getTopKBatch(CudfVectorPtr cudfInput, int32_t k) {
+  if (k == 0 || cudfInput->size() == 0) {
+    return nullptr;
+  }
+  auto stream = cudfInput->stream();
+  auto mr = get_output_mr();
+  auto values = cudfInput->getTableView();
+  auto result = getTopK(values, k, stream, mr);
+  auto const size = result->num_rows();
+  return std::make_shared<CudfVector>(
+      cudfInput->pool(), cudfInput->type(), size, std::move(result), stream);
+}
+
+void CudfTopN::doAddInput(RowVectorPtr input) {
+  if (count_ == 0 || input->size() == 0) {
+    return;
+  }
+
+  auto cudfInput = std::dynamic_pointer_cast<CudfVector>(input);
+  VELOX_CHECK_NOT_NULL(cudfInput);
+  // Take topk of each input, add to batch.
+  // If got kBatchSize_ batches, concat batches and topk once.
+  // During getOutput, concat batches and topk once.
+  topNBatches_.push_back(getTopKBatch(cudfInput, count_));
+  // sum of sizes of topNBatches_ >= count_, then concat and topk once.
+  auto totalSize = std::accumulate(
+      topNBatches_.begin(),
+      topNBatches_.end(),
+      0,
+      [](int32_t sum, const auto& batch) {
+        return sum + (batch ? batch->size() : 0);
+      });
+  if (topNBatches_.size() >= kBatchSize_ and totalSize >= count_) {
+    auto stream = cudfGlobalStreamPool().get_stream();
+    auto mr = get_output_mr();
+
+    auto result = mergeTopK(topNBatches_, count_, stream, mr);
+    topNBatches_.clear();
+    topNBatches_.push_back(std::move(result));
+  }
+}
+
+RowVectorPtr CudfTopN::doGetOutput() {
+  if (finished_ || !noMoreInput_) {
+    return nullptr;
+  }
+  if (topNBatches_.empty()) {
+    finished_ = noMoreInput_;
+    return nullptr;
+  }
+
+  auto stream = topNBatches_[0]->stream();
+  auto mr = get_output_mr();
+  auto result = mergeTopK(topNBatches_, count_, stream, mr);
+  topNBatches_.clear();
+  finished_ = noMoreInput_ && topNBatches_.empty();
+  return result;
+}
+
+void CudfTopN::doNoMoreInput() {
+  Operator::noMoreInput();
+  if (topNBatches_.empty()) {
+    finished_ = true;
+    return;
+  }
+}
+
+bool CudfTopN::isFinished() {
+  return finished_;
+}
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfTopN.h b/velox/experimental/cudf/exec/CudfTopN.h
new file mode 100644
index 00000000000..3c7b902c1e3
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfTopN.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/experimental/cudf/exec/CudfOperator.h"
+#include "velox/experimental/cudf/vector/CudfVector.h"
+
+#include "velox/exec/Operator.h"
+
+namespace facebook::velox::cudf_velox {
+
+class CudaEvent;
+
+class CudfTopN : public CudfOperatorBase {
+ public:
+  CudfTopN(
+      int32_t operatorId,
+      exec::DriverCtx* driverCtx,
+      const std::shared_ptr<const core::TopNNode>& topNNode);
+
+  bool needsInput() const override {
+    return !noMoreInput_;
+  }
+
+  exec::BlockingReason isBlocked(ContinueFuture* /*future*/) override {
+    return exec::BlockingReason::kNotBlocked;
+  }
+
+  bool isFinished() override;
+
+ protected:
+  void doAddInput(RowVectorPtr input) override;
+  RowVectorPtr doGetOutput() override;
+  void doNoMoreInput() override;
+
+ private:
+  const int32_t count_; // N value of TopN
+
+  std::shared_ptr<const core::TopNNode> topNNode_;
+  std::vector<cudf::size_type> sortKeys_;
+  std::vector<cudf::order> columnOrder_;
+  std::vector<cudf::null_order> nullOrder_;
+
+  CudfVectorPtr mergeTopK(
+      std::vector<CudfVectorPtr> topNBatches,
+      int32_t k,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr);
+
+  CudfVectorPtr getTopKBatch(CudfVectorPtr cudfInput, int32_t k);
+  std::unique_ptr<cudf::table> getTopK(
+      cudf::table_view const& values,
+      int32_t k,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr);
+
+  // As the inputs are added to TopN operator, we use topNBatches_
+  // (a vector of CudfVectorPtrs) to keep track of the topN rows of each input.
+  // We only update the topNBatches_ if number of batches >= kBatchSize_
+  // and number of rows in topNBatches_ >= count_. Once all inputs are
+  // available, we concat the topNBatches_ and get the topN rows.
+  std::vector<CudfVectorPtr> topNBatches_;
+  int32_t kBatchSize_{5};
+  bool finished_ = false;
+  std::unique_ptr<CudaEvent> cudaEvent_;
+};
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/DebugUtil.cpp b/velox/experimental/cudf/exec/DebugUtil.cpp
index b1153c17c0d..ff24cb9d1ea 100644
--- a/velox/experimental/cudf/exec/DebugUtil.cpp
+++ b/velox/experimental/cudf/exec/DebugUtil.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "velox/experimental/cudf/CudfNoDefaults.h"
 #include "velox/experimental/cudf/exec/DebugUtil.h"
 #include "velox/experimental/cudf/exec/Utilities.h"
 #include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
@@ -25,7 +26,8 @@ std::string DebugUtil::toString(
     rmm::cuda_stream_view stream,
     vector_size_t from,
     vector_size_t to) {
-  auto rowVector = with_arrow::toVeloxColumn(table, pool_.get(), "", stream);
+  auto rowVector =
+      with_arrow::toVeloxColumn(table, pool_.get(), "", stream, get_temp_mr());
   stream.synchronize();
   return rowVector->toString(from, to);
 }
diff --git a/velox/experimental/cudf/exec/DebugUtil.h b/velox/experimental/cudf/exec/DebugUtil.h
index 7fc4de0ea4c..57eccf3f855 100644
--- a/velox/experimental/cudf/exec/DebugUtil.h
+++ b/velox/experimental/cudf/exec/DebugUtil.h
@@ -16,9 +16,24 @@
 
 #pragma once
 
+#include "velox/experimental/cudf/CudfConfig.h"
 #include "velox/experimental/cudf/vector/CudfVector.h"
 
+#include "velox/common/base/Exceptions.h"
+
+#include <cuda_runtime.h>
+
 namespace facebook::velox::cudf_velox {
+
+/// Helper function to check for CUDA errors in debug mode.
+inline void checkCudaErrorInDebug() {
+  if (CudfConfig::getInstance().debugEnabled) {
+    cudaError_t err = cudaGetLastError();
+    VELOX_CHECK(
+        err == cudaSuccess, "CUDA error detected: {}", cudaGetErrorString(err));
+  }
+}
+
 class DebugUtil {
  public:
   std::string toString(
diff --git a/velox/experimental/cudf/exec/ExpressionEvaluator.cpp b/velox/experimental/cudf/exec/ExpressionEvaluator.cpp
deleted file mode 100644
index 01360e7eac1..00000000000
--- a/velox/experimental/cudf/exec/ExpressionEvaluator.cpp
+++ /dev/null
@@ -1,1665 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "velox/experimental/cudf/exec/ExpressionEvaluator.h"
-#include "velox/experimental/cudf/exec/ToCudf.h"
-
-#include "velox/expression/ConstantExpr.h"
-#include "velox/expression/FieldReference.h"
-#include "velox/type/Type.h"
-#include "velox/vector/BaseVector.h"
-#include "velox/vector/ComplexVector.h"
-#include "velox/vector/ConstantVector.h"
-#include "velox/vector/VectorTypeUtils.h"
-
-#include <cudf/column/column_factories.hpp>
-#include <cudf/datetime.hpp>
-#include <cudf/lists/count_elements.hpp>
-#include <cudf/replace.hpp>
-#include <cudf/strings/attributes.hpp>
-#include <cudf/strings/case.hpp>
-#include <cudf/strings/contains.hpp>
-#include <cudf/strings/find.hpp>
-#include <cudf/strings/slice.hpp>
-#include <cudf/strings/split/split.hpp>
-#include <cudf/table/table.hpp>
-#include <cudf/transform.hpp>
-
-#include <limits>
-#include <type_traits>
-
-namespace facebook::velox::cudf_velox {
-namespace {
-template <TypeKind kind>
-cudf::ast::literal makeScalarAndLiteral(
-    const TypePtr& type,
-    const variant& var,
-    std::vector<std::unique_ptr<cudf::scalar>>& scalars) {
-  using T = typename facebook::velox::KindToFlatVector<kind>::WrapperType;
-  auto stream = cudf::get_default_stream();
-  auto mr = cudf::get_current_device_resource_ref();
-
-  if constexpr (cudf::is_fixed_width<T>()) {
-    T value = var.value<T>();
-    if (type->isShortDecimal()) {
-      VELOX_FAIL("Short decimal not supported");
-      /* TODO: enable after rewriting using binary ops
-      using CudfDecimalType = cudf::numeric::decimal64;
-      using cudfScalarType = cudf::fixed_point_scalar<CudfDecimalType>;
-      auto scalar = std::make_unique<cudfScalarType>(value,
-                    type->scale(),
-                     true,
-                     stream,
-                     mr);
-      scalars.emplace_back(std::move(scalar));
-      return cudf::ast::literal{
-          *static_cast<cudfScalarType*>(scalars.back().get())};
-      */
-    } else if (type->isLongDecimal()) {
-      VELOX_FAIL("Long decimal not supported");
-      /* TODO: enable after rewriting using binary ops
-      using CudfDecimalType = cudf::numeric::decimal128;
-      using cudfScalarType = cudf::fixed_point_scalar<CudfDecimalType>;
-      auto scalar = std::make_unique<cudfScalarType>(value,
-                    type->scale(),
-                     true,
-                     stream,
-                     mr);
-      scalars.emplace_back(std::move(scalar));
-      return cudf::ast::literal{
-          *static_cast<cudfScalarType*>(scalars.back().get())};
-      */
-    } else if (type->isIntervalYearMonth()) {
-      // no support for interval year month in cudf
-      VELOX_FAIL("Interval year month not supported");
-    } else if (type->isIntervalDayTime()) {
-      using CudfDurationType = cudf::duration_ms;
-      if constexpr (std::is_same_v<T, CudfDurationType::rep>) {
-        using CudfScalarType = cudf::duration_scalar<CudfDurationType>;
-        auto scalar = std::make_unique<CudfScalarType>(value, true, stream, mr);
-        scalars.emplace_back(std::move(scalar));
-        return cudf::ast::literal{
-            *static_cast<CudfScalarType*>(scalars.back().get())};
-      }
-    } else if (type->isDate()) {
-      using CudfDateType = cudf::timestamp_D;
-      if constexpr (std::is_same_v<T, CudfDateType::rep>) {
-        using CudfScalarType = cudf::timestamp_scalar<CudfDateType>;
-        auto scalar = std::make_unique<CudfScalarType>(value, true, stream, mr);
-        scalars.emplace_back(std::move(scalar));
-        return cudf::ast::literal{
-            *static_cast<CudfScalarType*>(scalars.back().get())};
-      }
-    } else {
-      // Create a numeric scalar of type T, store it in the scalars vector,
-      // and use its reference in the literal expression.
-      using CudfScalarType = cudf::numeric_scalar<T>;
-      scalars.emplace_back(
-          std::make_unique<CudfScalarType>(value, true, stream, mr));
-      return cudf::ast::literal{
-          *static_cast<CudfScalarType*>(scalars.back().get())};
-    }
-    VELOX_FAIL("Unsupported base type for literal");
-  } else if (kind == TypeKind::VARCHAR) {
-    auto stringValue = var.value<StringView>();
-    scalars.emplace_back(
-        std::make_unique<cudf::string_scalar>(stringValue, true, stream, mr));
-    return cudf::ast::literal{
-        *static_cast<cudf::string_scalar*>(scalars.back().get())};
-  } else {
-    // TODO for non-numeric types too.
-    VELOX_NYI(
-        "Non-numeric types not yet implemented for kind " +
-        mapTypeKindToName(kind));
-  }
-}
-
-template <TypeKind kind>
-variant getVariant(const VectorPtr& vector, size_t atIndex = 0) {
-  using T = typename facebook::velox::KindToFlatVector<kind>::WrapperType;
-  if constexpr (!std::is_same_v<T, ComplexType>) {
-    return vector->as<SimpleVector<T>>()->valueAt(atIndex);
-  } else {
-    return Variant();
-  }
-}
-
-cudf::ast::literal createLiteral(
-    const VectorPtr& vector,
-    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
-    size_t atIndex = 0) {
-  const auto kind = vector->typeKind();
-  const auto& type = vector->type();
-  variant value =
-      VELOX_DYNAMIC_TYPE_DISPATCH(getVariant, kind, vector, atIndex);
-  return VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
-      makeScalarAndLiteral, kind, type, value, scalars);
-}
-
-// Helper function to extract literals from array elements based on type
-void extractArrayLiterals(
-    const ArrayVector* arrayVector,
-    std::vector<cudf::ast::literal>& literals,
-    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
-    vector_size_t offset,
-    vector_size_t size) {
-  auto elements = arrayVector->elements();
-
-  for (auto i = offset; i < offset + size; ++i) {
-    if (elements->isNullAt(i)) {
-      // Skip null values for IN expressions
-      continue;
-    } else {
-      literals.emplace_back(createLiteral(elements, scalars, i));
-    }
-  }
-}
-
-// Function to create literals from an array vector
-std::vector<cudf::ast::literal> createLiteralsFromArray(
-    const VectorPtr& vector,
-    std::vector<std::unique_ptr<cudf::scalar>>& scalars) {
-  std::vector<cudf::ast::literal> literals;
-
-  // Check if it's a constant vector containing an array
-  if (vector->isConstantEncoding()) {
-    auto constantVector = vector->asUnchecked<ConstantVector<ComplexType>>();
-    if (constantVector->isNullAt(0)) {
-      // Return empty vector for null array
-      return literals;
-    }
-
-    auto valueVector = constantVector->valueVector();
-    if (valueVector->encoding() == VectorEncoding::Simple::ARRAY) {
-      auto arrayVector = valueVector->as<ArrayVector>();
-      auto index = constantVector->index();
-      auto size = arrayVector->sizeAt(index);
-      if (size == 0) {
-        // Return empty vector for empty array
-        return literals;
-      }
-
-      auto offset = arrayVector->offsetAt(index);
-      auto elements = arrayVector->elements();
-
-      // Handle different element types
-      if (elements->isScalar()) {
-        literals.reserve(size);
-        extractArrayLiterals(arrayVector, literals, scalars, offset, size);
-      } else if (elements->typeKind() == TypeKind::ARRAY) {
-        // Nested arrays not supported in IN expressions
-        VELOX_FAIL("Nested arrays not supported in IN expressions");
-      } else {
-        VELOX_FAIL(
-            "Unsupported element type in array: {}",
-            elements->type()->toString());
-      }
-    } else {
-      VELOX_FAIL("Expected ARRAY encoding");
-    }
-  } else {
-    VELOX_FAIL("Expected constant vector for IN list");
-  }
-
-  return literals;
-}
-
-std::string stripPrefix(const std::string& input, const std::string& prefix) {
-  if (input.size() >= prefix.size() &&
-      input.compare(0, prefix.size(), prefix) == 0) {
-    return input.substr(prefix.size());
-  }
-  return input;
-}
-} // namespace
-
-using Op = cudf::ast::ast_operator;
-const std::unordered_map<std::string, Op> prestoBinaryOps = {
-    {"plus", Op::ADD},
-    {"minus", Op::SUB},
-    {"multiply", Op::MUL},
-    {"divide", Op::DIV},
-    {"eq", Op::EQUAL},
-    {"neq", Op::NOT_EQUAL},
-    {"lt", Op::LESS},
-    {"gt", Op::GREATER},
-    {"lte", Op::LESS_EQUAL},
-    {"gte", Op::GREATER_EQUAL},
-    {"and", Op::NULL_LOGICAL_AND},
-    {"or", Op::NULL_LOGICAL_OR},
-    {"mod", Op::MOD},
-};
-
-const std::unordered_map<std::string, Op> sparkBinaryOps = {
-    {"add", Op::ADD},
-    {"subtract", Op::SUB},
-    {"multiply", Op::MUL},
-    {"divide", Op::DIV},
-    {"equalto", Op::EQUAL},
-    {"lessthan", Op::LESS},
-    {"greaterthan", Op::GREATER},
-    {"lessthanorequal", Op::LESS_EQUAL},
-    {"greaterthanorequal", Op::GREATER_EQUAL},
-    {"and", Op::NULL_LOGICAL_AND},
-    {"or", Op::NULL_LOGICAL_OR},
-    {"mod", Op::MOD},
-};
-
-const std::unordered_map<std::string, Op> binaryOps = [] {
-  std::unordered_map<std::string, Op> merged(
-      sparkBinaryOps.begin(), sparkBinaryOps.end());
-  merged.insert(prestoBinaryOps.begin(), prestoBinaryOps.end());
-  return merged;
-}();
-
-const std::map<std::string, Op> unaryOps = {
-    {"not", Op::NOT},
-    {"is_null", Op::IS_NULL}};
-
-const std::unordered_set<std::string> supportedOps = {
-    "literal",
-    "between",
-    "in",
-    "cast",
-    "try_cast",
-    "switch",
-    "year",
-    "length",
-    "substr",
-    "substring",
-    "startswith",
-    "endswith",
-    "contains",
-    "isnotnull",
-    "like",
-    "cardinality",
-    "split",
-    "coalesce",
-    "lower"};
-
-namespace detail {
-
-bool canBeEvaluated(const std::shared_ptr<velox::exec::Expr>& expr) {
-  const auto name =
-      stripPrefix(expr->name(), CudfOptions::getInstance().prefix());
-  if (supportedOps.count(name) || binaryOps.count(name) ||
-      unaryOps.count(name)) {
-    return std::all_of(
-        expr->inputs().begin(), expr->inputs().end(), canBeEvaluated);
-  }
-  return std::dynamic_pointer_cast<velox::exec::FieldReference>(expr) !=
-      nullptr;
-}
-
-} // namespace detail
-
-struct AstContext {
-  cudf::ast::tree& tree;
-  std::vector<std::unique_ptr<cudf::scalar>>& scalars;
-  const std::vector<RowTypePtr> inputRowSchema;
-  const std::vector<std::reference_wrapper<std::vector<PrecomputeInstruction>>>
-      precomputeInstructions;
-  const std::shared_ptr<velox::exec::Expr>
-      rootExpr; // Track the root expression
-
-  cudf::ast::expression const& pushExprToTree(
-      const std::shared_ptr<velox::exec::Expr>& expr);
-  cudf::ast::expression const& addPrecomputeInstructionOnSide(
-      size_t sideIdx,
-      size_t columnIndex,
-      std::string const& instruction,
-      std::string const& fieldName,
-      const std::shared_ptr<CudfExpressionNode>& node = nullptr);
-  cudf::ast::expression const& addPrecomputeInstruction(
-      std::string const& name,
-      std::string const& instruction,
-      std::string const& fieldName = {},
-      const std::shared_ptr<CudfExpressionNode>& node = nullptr);
-  cudf::ast::expression const& multipleInputsToPairWise(
-      const std::shared_ptr<velox::exec::Expr>& expr);
-  static bool canBeEvaluated(const std::shared_ptr<velox::exec::Expr>& expr);
-};
-
-// Create tree from Expr
-// and collect precompute instructions for non-ast operations
-cudf::ast::expression const& createAstTree(
-    const std::shared_ptr<velox::exec::Expr>& expr,
-    cudf::ast::tree& tree,
-    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
-    const RowTypePtr& inputRowSchema,
-    std::vector<PrecomputeInstruction>& precomputeInstructions) {
-  AstContext context{
-      tree, scalars, {inputRowSchema}, {precomputeInstructions}, expr};
-  return context.pushExprToTree(expr);
-}
-
-cudf::ast::expression const& createAstTree(
-    const std::shared_ptr<velox::exec::Expr>& expr,
-    cudf::ast::tree& tree,
-    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
-    const RowTypePtr& leftRowSchema,
-    const RowTypePtr& rightRowSchema,
-    std::vector<PrecomputeInstruction>& leftPrecomputeInstructions,
-    std::vector<PrecomputeInstruction>& rightPrecomputeInstructions) {
-  AstContext context{
-      tree,
-      scalars,
-      {leftRowSchema, rightRowSchema},
-      {leftPrecomputeInstructions, rightPrecomputeInstructions},
-      expr};
-  return context.pushExprToTree(expr);
-}
-
-// get nested column indices
-std::vector<int> getNestedColumnIndices(
-    const TypePtr& rowType,
-    const std::string& fieldName) {
-  std::vector<int> indices;
-  auto rowTypePtr = asRowType(rowType);
-  if (rowTypePtr->containsChild(fieldName)) {
-    auto columnIndex = rowTypePtr->getChildIdx(fieldName);
-    indices.push_back(columnIndex);
-  }
-  return indices;
-}
-
-cudf::ast::expression const& AstContext::addPrecomputeInstructionOnSide(
-    size_t sideIdx,
-    size_t columnIndex,
-    std::string const& instruction,
-    std::string const& fieldName,
-    const std::shared_ptr<CudfExpressionNode>& node) {
-  auto newColumnIndex = inputRowSchema[sideIdx].get()->size() +
-      precomputeInstructions[sideIdx].get().size();
-  if (fieldName.empty()) {
-    // This custom op should be added to input columns.
-    precomputeInstructions[sideIdx].get().emplace_back(
-        columnIndex, instruction, newColumnIndex, node);
-  } else {
-    auto nestedIndices = getNestedColumnIndices(
-        inputRowSchema[sideIdx].get()->childAt(columnIndex), fieldName);
-    precomputeInstructions[sideIdx].get().emplace_back(
-        columnIndex, instruction, newColumnIndex, nestedIndices, node);
-  }
-  auto side = static_cast<cudf::ast::table_reference>(sideIdx);
-  return tree.push(cudf::ast::column_reference(newColumnIndex, side));
-}
-
-cudf::ast::expression const& AstContext::addPrecomputeInstruction(
-    std::string const& name,
-    std::string const& instruction,
-    std::string const& fieldName,
-    const std::shared_ptr<CudfExpressionNode>& node) {
-  for (size_t sideIdx = 0; sideIdx < inputRowSchema.size(); ++sideIdx) {
-    if (inputRowSchema[sideIdx].get()->containsChild(name)) {
-      auto columnIndex = inputRowSchema[sideIdx].get()->getChildIdx(name);
-      return addPrecomputeInstructionOnSide(
-          sideIdx, columnIndex, instruction, fieldName, node);
-    }
-  }
-  VELOX_FAIL("Field not found, " + name);
-}
-
-/// Handles logical AND/OR expressions with multiple inputs by converting them
-/// into a chain of binary operations. For example, "a AND b AND c" becomes
-/// "(a AND b) AND c".
-///
-/// @param expr The expression containing multiple inputs for AND/OR operation
-/// @return A reference to the resulting AST expression
-cudf::ast::expression const& AstContext::multipleInputsToPairWise(
-    const std::shared_ptr<velox::exec::Expr>& expr) {
-  using Operation = cudf::ast::operation;
-
-  const auto name =
-      stripPrefix(expr->name(), CudfOptions::getInstance().prefix());
-  auto len = expr->inputs().size();
-  // Create a simple chain of operations
-  auto result = &pushExprToTree(expr->inputs()[0]);
-
-  // Chain the rest of the inputs sequentially
-  for (size_t i = 1; i < len; i++) {
-    auto const& nextInput = pushExprToTree(expr->inputs()[i]);
-    result = &tree.push(Operation{binaryOps.at(name), *result, nextInput});
-  }
-  return *result;
-}
-
-/// Pushes an expression into the AST tree and returns a reference to the
-/// resulting expression.
-///
-/// @param expr The expression to push into the AST tree
-/// @return A reference to the resulting AST expression
-cudf::ast::expression const& AstContext::pushExprToTree(
-    const std::shared_ptr<velox::exec::Expr>& expr) {
-  using Op = cudf::ast::ast_operator;
-  using Operation = cudf::ast::operation;
-  using velox::exec::ConstantExpr;
-  using velox::exec::FieldReference;
-
-  const auto name =
-      stripPrefix(expr->name(), CudfOptions::getInstance().prefix());
-  auto len = expr->inputs().size();
-  auto& type = expr->type();
-
-  if (name == "literal") {
-    auto c = dynamic_cast<ConstantExpr*>(expr.get());
-    VELOX_CHECK_NOT_NULL(c, "literal expression should be ConstantExpr");
-    auto value = c->value();
-    VELOX_CHECK(value->isConstantEncoding());
-
-    // Special case: VARCHAR literals cannot be handled by cudf::compute_column
-    // as the final output due to variable-width output limitation.
-    // However, if this is part of a larger expression tree (e.g., string
-    // comparison), then cudf can handle it fine since the final output won't be
-    // VARCHAR. We only need special handling when this literal will be the
-    // final output.
-    if (expr->type()->kind() == TypeKind::VARCHAR && expr == rootExpr) {
-      // convert to cudf scalar and store it
-      createLiteral(value, scalars);
-      // The scalar index is scalars.size() - 1 since we just added it
-      std::string fillExpr = "fill " + std::to_string(scalars.size() - 1);
-      // For literals, we use the first column just to get the size, but create
-      // a new column The new column will be appended after the original input
-      // columns
-      return addPrecomputeInstruction(inputRowSchema[0]->nameOf(0), fillExpr);
-    }
-
-    return tree.push(createLiteral(value, scalars));
-  } else if (binaryOps.find(name) != binaryOps.end()) {
-    if (len > 2 and (name == "and" or name == "or")) {
-      return multipleInputsToPairWise(expr);
-    }
-    VELOX_CHECK_EQ(len, 2);
-    auto const& op1 = pushExprToTree(expr->inputs()[0]);
-    auto const& op2 = pushExprToTree(expr->inputs()[1]);
-    return tree.push(Operation{binaryOps.at(name), op1, op2});
-  } else if (unaryOps.find(name) != unaryOps.end()) {
-    VELOX_CHECK_EQ(len, 1);
-    auto const& op1 = pushExprToTree(expr->inputs()[0]);
-    return tree.push(Operation{unaryOps.at(name), op1});
-  } else if (name == "isnotnull") {
-    VELOX_CHECK_EQ(len, 1);
-    auto const& op1 = pushExprToTree(expr->inputs()[0]);
-    auto const& nullOp = tree.push(Operation{Op::IS_NULL, op1});
-    return tree.push(Operation{Op::NOT, nullOp});
-  } else if (name == "between") {
-    VELOX_CHECK_EQ(len, 3);
-    auto const& value = pushExprToTree(expr->inputs()[0]);
-    auto const& lower = pushExprToTree(expr->inputs()[1]);
-    auto const& upper = pushExprToTree(expr->inputs()[2]);
-    // construct between(op2, op3) using >= and <=
-    auto const& geLower = tree.push(Operation{Op::GREATER_EQUAL, value, lower});
-    auto const& leUpper = tree.push(Operation{Op::LESS_EQUAL, value, upper});
-    return tree.push(Operation{Op::NULL_LOGICAL_AND, geLower, leUpper});
-  } else if (name == "in") {
-    // number of inputs is variable. >=2
-    VELOX_CHECK_EQ(len, 2);
-    // actually len is 2, second input is ARRAY
-    auto const& op1 = pushExprToTree(expr->inputs()[0]);
-    auto c = dynamic_cast<ConstantExpr*>(expr->inputs()[1].get());
-    VELOX_CHECK_NOT_NULL(c, "literal expression should be ConstantExpr");
-    auto value = c->value();
-    VELOX_CHECK_NOT_NULL(value, "ConstantExpr value is null");
-
-    // Use the new createLiteralsFromArray function to get literals
-    auto literals = createLiteralsFromArray(value, scalars);
-
-    // Create equality expressions for each literal and OR them together
-    std::vector<const cudf::ast::expression*> exprVec;
-    for (auto& literal : literals) {
-      auto const& opi = tree.push(std::move(literal));
-      auto const& logicalNode = tree.push(Operation{Op::EQUAL, op1, opi});
-      exprVec.push_back(&logicalNode);
-    }
-
-    // Handle empty IN list case
-    if (exprVec.empty()) {
-      // FAIL
-      VELOX_FAIL("Empty IN list");
-      // Return FALSE for empty IN list
-      // auto falseValue = std::make_shared<ConstantVector<bool>>(
-      //     value->pool(), 1, false, TypeKind::BOOLEAN, false);
-      // return tree.push(createLiteral(falseValue, scalars));
-    }
-
-    // OR all logical nodes
-    auto* result = exprVec[0];
-    for (size_t i = 1; i < exprVec.size(); i++) {
-      auto const& treeNode =
-          tree.push(Operation{Op::NULL_LOGICAL_OR, *result, *exprVec[i]});
-      result = &treeNode;
-    }
-    return *result;
-  } else if (name == "cast" || name == "try_cast") {
-    VELOX_CHECK_EQ(len, 1);
-    auto const& op1 = pushExprToTree(expr->inputs()[0]);
-    if (expr->type()->kind() == TypeKind::INTEGER) {
-      // No int32 cast in cudf ast
-      return tree.push(Operation{Op::CAST_TO_INT64, op1});
-    } else if (expr->type()->kind() == TypeKind::BIGINT) {
-      return tree.push(Operation{Op::CAST_TO_INT64, op1});
-    } else if (expr->type()->kind() == TypeKind::DOUBLE) {
-      return tree.push(Operation{Op::CAST_TO_FLOAT64, op1});
-    } else {
-      VELOX_FAIL("Unsupported type for cast operation");
-    }
-  } else if (name == "switch") {
-    VELOX_CHECK_EQ(len, 3);
-    // check if input[1], input[2] are literals 1 and 0.
-    // then simplify as typecast bool to int
-    auto c1 = dynamic_cast<ConstantExpr*>(expr->inputs()[1].get());
-    auto c2 = dynamic_cast<ConstantExpr*>(expr->inputs()[2].get());
-    if ((c1 and c1->toString() == "1:BIGINT" and c2 and
-         c2->toString() == "0:BIGINT") ||
-        (c1 and c1->toString() == "1:INTEGER" and c2 and
-         c2->toString() == "0:INTEGER")) {
-      auto const& op1 = pushExprToTree(expr->inputs()[0]);
-      return tree.push(Operation{Op::CAST_TO_INT64, op1});
-    } else if (c2 and c2->toString() == "0:DOUBLE") {
-      auto const& op1 = pushExprToTree(expr->inputs()[0]);
-      auto const& op1d = tree.push(Operation{Op::CAST_TO_FLOAT64, op1});
-      auto const& op2 = pushExprToTree(expr->inputs()[1]);
-      return tree.push(Operation{Op::MUL, op1d, op2});
-    } else if (
-        c1 and c1->toString() == "1:INTEGER" and c2 and
-        c2->toString() == "0:INTEGER") {
-      return pushExprToTree(expr->inputs()[0]);
-    } else {
-      VELOX_NYI("Unsupported switch complex operation " + expr->toString());
-    }
-  } else if (name == "year") {
-    VELOX_CHECK_EQ(len, 1);
-
-    auto fieldExpr =
-        std::dynamic_pointer_cast<FieldReference>(expr->inputs()[0]);
-    VELOX_CHECK_NOT_NULL(fieldExpr, "Expression is not a field");
-
-    auto const& colRef = addPrecomputeInstruction(fieldExpr->name(), "year");
-    if (type->kind() == TypeKind::BIGINT) {
-      // Presto returns int64.
-      return tree.push(Operation{Op::CAST_TO_INT64, colRef});
-    } else {
-      // Cudf returns smallint while spark returns int, cast the output column
-      // in execution.
-      return colRef;
-    }
-
-  } else if (name == "length") {
-    VELOX_CHECK_EQ(len, 1);
-
-    auto fieldExpr =
-        std::dynamic_pointer_cast<FieldReference>(expr->inputs()[0]);
-    VELOX_CHECK_NOT_NULL(fieldExpr, "Expression is not a field");
-
-    auto const& colRef = addPrecomputeInstruction(fieldExpr->name(), "length");
-
-    return tree.push(Operation{Op::CAST_TO_INT64, colRef});
-  } else if (name == "lower") {
-    VELOX_CHECK_EQ(len, 1);
-
-    auto fieldExpr =
-        std::dynamic_pointer_cast<FieldReference>(expr->inputs()[0]);
-    VELOX_CHECK_NOT_NULL(fieldExpr, "Expression is not a field");
-    return addPrecomputeInstruction(fieldExpr->name(), "lower");
-  } else if (name == "substr" or name == "substring") {
-    // Build a cudf expression node for recursive evaluation
-    auto node = CudfExpressionNode::create(expr);
-    return addPrecomputeInstructionOnSide(0, 0, "substr", "", node);
-  } else if (name == "startswith") {
-    VELOX_CHECK_EQ(len, 2);
-
-    auto fieldExpr =
-        std::dynamic_pointer_cast<FieldReference>(expr->inputs()[0]);
-    VELOX_CHECK_NOT_NULL(fieldExpr, "Expression is not a field");
-    auto literalExpr =
-        std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[1]);
-    VELOX_CHECK_NOT_NULL(literalExpr, "Expression is not a literal");
-
-    createLiteral(literalExpr->value(), scalars);
-
-    std::string startswithExpr =
-        "startswith " + std::to_string(scalars.size() - 1);
-
-    return addPrecomputeInstruction(fieldExpr->name(), startswithExpr);
-  } else if (name == "endswith") {
-    VELOX_CHECK_EQ(len, 2);
-
-    auto fieldExpr =
-        std::dynamic_pointer_cast<FieldReference>(expr->inputs()[0]);
-    VELOX_CHECK_NOT_NULL(fieldExpr, "Expression is not a field");
-    auto literalExpr =
-        std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[1]);
-    VELOX_CHECK_NOT_NULL(literalExpr, "Expression is not a literal");
-
-    createLiteral(literalExpr->value(), scalars);
-
-    std::string endswithExpr = "endswith " + std::to_string(scalars.size() - 1);
-
-    return addPrecomputeInstruction(fieldExpr->name(), endswithExpr);
-  } else if (name == "contains") {
-    VELOX_CHECK_EQ(len, 2);
-
-    auto fieldExpr =
-        std::dynamic_pointer_cast<FieldReference>(expr->inputs()[0]);
-    VELOX_CHECK_NOT_NULL(fieldExpr, "Expression is not a field");
-    auto literalExpr =
-        std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[1]);
-    VELOX_CHECK_NOT_NULL(literalExpr, "Expression is not a literal");
-
-    createLiteral(literalExpr->value(), scalars);
-
-    std::string containsExpr = "contains " + std::to_string(scalars.size() - 1);
-
-    return addPrecomputeInstruction(fieldExpr->name(), containsExpr);
-  } else if (name == "like") {
-    VELOX_CHECK(
-        len == 2 or len == 3, "like expression should have 2 or 3 inputs");
-
-    auto fieldExpr =
-        std::dynamic_pointer_cast<FieldReference>(expr->inputs()[0]);
-    VELOX_CHECK_NOT_NULL(fieldExpr, "Expression is not a field");
-    auto literalExpr =
-        std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[1]);
-    VELOX_CHECK_NOT_NULL(literalExpr, "Expression is not a literal");
-
-    createLiteral(literalExpr->value(), scalars);
-
-    std::string likeExpr = "like " + std::to_string(scalars.size() - 1);
-    if (len == 3) {
-      auto literalEscapeExpr =
-          std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[2]);
-      VELOX_CHECK_NOT_NULL(literalEscapeExpr, "Expression is not a literal");
-      createLiteral(literalEscapeExpr->value(), scalars);
-      likeExpr += " " + std::to_string(scalars.size() - 1);
-    }
-
-    return addPrecomputeInstruction(fieldExpr->name(), likeExpr);
-  } else if (name == "cardinality") {
-    VELOX_CHECK_EQ(len, 1);
-    // Build a cudf expression node for recursive evaluation
-    auto node = CudfExpressionNode::create(expr);
-    auto const& colRef =
-        addPrecomputeInstructionOnSide(0, 0, "cardinality", "", node);
-
-    return tree.push(Operation{Op::CAST_TO_INT64, colRef});
-  } else if (name == "split") {
-    VELOX_CHECK_EQ(len, 3);
-    auto node = CudfExpressionNode::create(expr);
-    return addPrecomputeInstructionOnSide(0, 0, "split", "", node);
-  } else if (name == "coalesce") {
-    auto node = CudfExpressionNode::create(expr);
-    return addPrecomputeInstructionOnSide(0, 0, "coalesce", "", node);
-  } else if (auto fieldExpr = std::dynamic_pointer_cast<FieldReference>(expr)) {
-    // Refer to the appropriate side
-    const auto fieldName =
-        fieldExpr->inputs().empty() ? name : fieldExpr->inputs()[0]->name();
-    for (size_t sideIdx = 0; sideIdx < inputRowSchema.size(); ++sideIdx) {
-      auto& schema = inputRowSchema[sideIdx];
-      if (schema.get()->containsChild(fieldName)) {
-        auto columnIndex = schema.get()->getChildIdx(fieldName);
-        // This column may be complex data type like ROW, we need to get the
-        // name from row. Push fieldName.name to the tree.
-        auto side = static_cast<cudf::ast::table_reference>(sideIdx);
-        if (fieldExpr->field() == fieldName) {
-          return tree.push(cudf::ast::column_reference(columnIndex, side));
-        } else {
-          return addPrecomputeInstruction(
-              fieldName, "nested_column", fieldExpr->field());
-        }
-      }
-    }
-    VELOX_FAIL("Field not found, " + name);
-  } else {
-    VELOX_FAIL("Unsupported expression: " + name);
-  }
-}
-
-class SplitFunction : public CudfFunction {
- public:
-  SplitFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
-    using velox::exec::ConstantExpr;
-
-    auto stream = cudf::get_default_stream();
-    auto mr = cudf::get_current_device_resource_ref();
-
-    auto delimiterExpr =
-        std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[1]);
-    VELOX_CHECK_NOT_NULL(delimiterExpr, "split delimiter must be a constant");
-    delimiterScalar_ = std::make_unique<cudf::string_scalar>(
-        delimiterExpr->value()->toString(0), true, stream, mr);
-
-    auto limitExpr =
-        std::dynamic_pointer_cast<velox::exec::ConstantExpr>(expr->inputs()[2]);
-    VELOX_CHECK_NOT_NULL(limitExpr, "split limit must be a constant");
-    maxSplitCount_ = std::stoll(limitExpr->value()->toString(0));
-
-    // Presto specifies maxSplitCount as the maximum size of the returned array
-    // while cuDF understands the parameter as how many splits can it perform.
-    maxSplitCount_ -= 1;
-  }
-
-  ColumnOrView eval(
-      std::vector<ColumnOrView>& inputColumns,
-      rmm::cuda_stream_view stream,
-      rmm::device_async_resource_ref mr) const override {
-    auto inputCol = asView(inputColumns[0]);
-    return cudf::strings::split_record(
-        inputCol, *delimiterScalar_, maxSplitCount_, stream, mr);
-  };
-
- private:
-  std::unique_ptr<cudf::string_scalar> delimiterScalar_;
-  cudf::size_type maxSplitCount_;
-};
-
-class CardinalityFunction : public CudfFunction {
- public:
-  CardinalityFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
-    // Cardinality doesn't need any pre-computed scalars, just validates input
-    // count
-    VELOX_CHECK_EQ(
-        expr->inputs().size(), 1, "cardinality expects exactly 1 input");
-  }
-
-  ColumnOrView eval(
-      std::vector<ColumnOrView>& inputColumns,
-      rmm::cuda_stream_view stream,
-      rmm::device_async_resource_ref mr) const override {
-    auto inputCol = asView(inputColumns[0]);
-    return cudf::lists::count_elements(inputCol, stream, mr);
-  }
-};
-
-class SubstrFunction : public CudfFunction {
- public:
-  SubstrFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
-    using velox::exec::ConstantExpr;
-
-    VELOX_CHECK_GE(
-        expr->inputs().size(), 2, "substr expects at least 2 inputs");
-    VELOX_CHECK_LE(expr->inputs().size(), 3, "substr expects at most 3 inputs");
-
-    auto stream = cudf::get_default_stream();
-    auto mr = cudf::get_current_device_resource_ref();
-
-    auto startExpr = std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[1]);
-    VELOX_CHECK_NOT_NULL(startExpr, "substr start must be a constant");
-
-    auto startValue =
-        startExpr->value()->as<SimpleVector<int64_t>>()->valueAt(0);
-    cudf::size_type adjustedStart = static_cast<cudf::size_type>(startValue);
-    if (startValue >= 1) {
-      // cuDF indexing starts at 0.
-      // Presto indexing starts at 1.
-      // Positive indices need to substract 1.
-      adjustedStart = static_cast<cudf::size_type>(startValue - 1);
-    }
-
-    startScalar_ = std::make_unique<cudf::numeric_scalar<cudf::size_type>>(
-        adjustedStart, true, stream, mr);
-
-    if (expr->inputs().size() > 2) {
-      auto lengthExpr =
-          std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[2]);
-      VELOX_CHECK_NOT_NULL(lengthExpr, "substr length must be a constant");
-
-      auto lengthValue =
-          lengthExpr->value()->as<SimpleVector<int64_t>>()->valueAt(0);
-      // cuDF uses indices [begin, end).
-      // Presto uses length as the length of the substring.
-      // We compute the end as start + length.
-      cudf::size_type endPosition =
-          adjustedStart + static_cast<cudf::size_type>(lengthValue);
-
-      endScalar_ = std::make_unique<cudf::numeric_scalar<cudf::size_type>>(
-          endPosition, true, stream, mr);
-    } else {
-      endScalar_ = std::make_unique<cudf::numeric_scalar<cudf::size_type>>(
-          0, false, stream, mr);
-    }
-
-    stepScalar_ = std::make_unique<cudf::numeric_scalar<cudf::size_type>>(
-        1, true, stream, mr);
-  }
-
-  ColumnOrView eval(
-      std::vector<ColumnOrView>& inputColumns,
-      rmm::cuda_stream_view stream,
-      rmm::device_async_resource_ref mr) const override {
-    auto inputCol = asView(inputColumns[0]);
-    return cudf::strings::slice_strings(
-        inputCol, *startScalar_, *endScalar_, *stepScalar_, stream, mr);
-  }
-
- private:
-  std::unique_ptr<cudf::numeric_scalar<cudf::size_type>> startScalar_;
-  std::unique_ptr<cudf::numeric_scalar<cudf::size_type>> endScalar_;
-  std::unique_ptr<cudf::numeric_scalar<cudf::size_type>> stepScalar_;
-};
-
-class CoalesceFunction : public CudfFunction {
- public:
-  CoalesceFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
-    using velox::exec::ConstantExpr;
-
-    // Storing the first literal that appears in inputs because we don't need to
-    // process after that. This is the last fallback.
-    numColumnsBeforeLiteral_ = expr->inputs().size();
-    for (size_t i = 0; i < expr->inputs().size(); ++i) {
-      const auto& input = expr->inputs()[i];
-      if (input->name() == "literal") {
-        auto c = std::dynamic_pointer_cast<ConstantExpr>(input);
-        if (c && c->value()) {
-          std::vector<std::unique_ptr<cudf::scalar>> scalars;
-          (void)createLiteral(c->value(), scalars);
-          if (!scalars.empty()) {
-            literalScalar_ = std::move(scalars.back());
-            numColumnsBeforeLiteral_ = i;
-          }
-        }
-        break;
-      }
-    }
-  }
-
-  ColumnOrView eval(
-      std::vector<ColumnOrView>& inputColumns,
-      rmm::cuda_stream_view stream,
-      rmm::device_async_resource_ref mr) const override {
-    // Coalesce is practically a cudf::replace_nulls over multiple columns.
-    // Starting from first column, we keep calling replace nulls with subsequent
-    // cols until we get an all valid col or run out of columns
-
-    // If a literal comes before any column input, fill the result with it.
-    if (literalScalar_ && numColumnsBeforeLiteral_ == 0) {
-      if (inputColumns.empty()) {
-        // We need at least one column to tell us the required output size
-        VELOX_NYI("coalesce with only literal inputs is not supported");
-      }
-      auto size = asView(inputColumns[0]).size();
-      return cudf::make_column_from_scalar(*literalScalar_, size, stream, mr);
-    }
-
-    VELOX_CHECK(
-        !inputColumns.empty(),
-        "coalesce requires at least one non-literal input");
-    ColumnOrView result = asView(inputColumns[0]);
-    size_t stop = std::min(numColumnsBeforeLiteral_, inputColumns.size());
-    for (size_t i = 1; i < stop && asView(result).has_nulls(); ++i) {
-      result = cudf::replace_nulls(
-          asView(result), asView(inputColumns[i]), stream, mr);
-    }
-
-    if (literalScalar_ && asView(result).has_nulls()) {
-      result = cudf::replace_nulls(asView(result), *literalScalar_, stream, mr);
-    }
-
-    return result;
-  }
-
- private:
-  size_t numColumnsBeforeLiteral_;
-  std::unique_ptr<cudf::scalar> literalScalar_;
-};
-
-std::unordered_map<std::string, CudfFunctionFactory>&
-getCudfFunctionRegistry() {
-  static std::unordered_map<std::string, CudfFunctionFactory> registry;
-  return registry;
-}
-
-bool registerCudfFunction(
-    const std::string& name,
-    CudfFunctionFactory factory,
-    bool overwrite) {
-  auto& registry = getCudfFunctionRegistry();
-  if (!overwrite && registry.find(name) != registry.end()) {
-    return false;
-  }
-  registry[name] = factory;
-  return true;
-}
-
-std::shared_ptr<CudfFunction> createCudfFunction(
-    const std::string& name,
-    const std::shared_ptr<velox::exec::Expr>& expr) {
-  auto& registry = getCudfFunctionRegistry();
-  auto it = registry.find(name);
-  if (it != registry.end()) {
-    return it->second(name, expr);
-  }
-  return nullptr;
-}
-
-bool registerBuiltinFunctions(const std::string& prefix) {
-  registerCudfFunction(
-      "split",
-      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
-        return std::make_shared<SplitFunction>(expr);
-      });
-
-  registerCudfFunction(
-      prefix + "split",
-      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
-        return std::make_shared<SplitFunction>(expr);
-      });
-
-  registerCudfFunction(
-      "cardinality",
-      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
-        return std::make_shared<CardinalityFunction>(expr);
-      });
-
-  registerCudfFunction(
-      prefix + "cardinality",
-      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
-        return std::make_shared<CardinalityFunction>(expr);
-      });
-
-  registerCudfFunction(
-      "substr",
-      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
-        return std::make_shared<SubstrFunction>(expr);
-      });
-
-  registerCudfFunction(
-      prefix + "substr",
-      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
-        return std::make_shared<SubstrFunction>(expr);
-      });
-
-  registerCudfFunction(
-      "coalesce",
-      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
-        return std::make_shared<CoalesceFunction>(expr);
-      });
-
-  return true;
-}
-
-std::shared_ptr<CudfExpressionNode> CudfExpressionNode::create(
-    const std::shared_ptr<velox::exec::Expr>& expr) {
-  auto node = std::make_shared<CudfExpressionNode>();
-  node->expr = expr;
-
-  auto name = expr->name();
-  node->function = createCudfFunction(name, expr);
-
-  if (node->function) {
-    for (const auto& input : expr->inputs()) {
-      if (input->name() != "literal") {
-        node->subexpressions.push_back(CudfExpressionNode::create(input));
-      }
-    }
-  }
-
-  return node;
-}
-
-ColumnOrView CudfExpressionNode::eval(
-    std::vector<std::unique_ptr<cudf::column>>& inputTableColumns,
-    const RowTypePtr& inputRowSchema,
-    rmm::cuda_stream_view stream,
-    rmm::device_async_resource_ref mr) {
-  using velox::exec::FieldReference;
-
-  if (auto fieldExpr = std::dynamic_pointer_cast<FieldReference>(expr)) {
-    auto name = fieldExpr->name();
-    auto columnIndex = inputRowSchema->getChildIdx(name);
-    return inputTableColumns[columnIndex]->view();
-  }
-
-  if (function) {
-    std::vector<ColumnOrView> inputColumns;
-    inputColumns.reserve(subexpressions.size());
-
-    for (const auto& subexpr : subexpressions) {
-      inputColumns.push_back(
-          subexpr->eval(inputTableColumns, inputRowSchema, stream, mr));
-    }
-
-    return function->eval(inputColumns, stream, mr);
-  }
-
-  VELOX_FAIL(
-      "Unsupported expression for recursive evaluation: " + expr->name());
-}
-
-void addPrecomputedColumns(
-    std::vector<std::unique_ptr<cudf::column>>& inputTableColumns,
-    const std::vector<PrecomputeInstruction>& precomputeInstructions,
-    const std::vector<std::unique_ptr<cudf::scalar>>& scalars,
-    const RowTypePtr& inputRowSchema,
-    rmm::cuda_stream_view stream) {
-  for (const auto& instruction : precomputeInstructions) {
-    auto
-        [dependent_column_index,
-         ins_name,
-         new_column_index,
-         nested_dependent_column_indices,
-         cudf_node] = instruction;
-
-    // If a compiled cudf node is available, evaluate it directly.
-    if (cudf_node) {
-      auto result = cudf_node->eval(
-          inputTableColumns,
-          inputRowSchema,
-          stream,
-          cudf::get_current_device_resource_ref());
-      if (std::holds_alternative<cudf::column_view>(result)) {
-        inputTableColumns.emplace_back(std::make_unique<cudf::column>(
-            std::get<cudf::column_view>(result),
-            stream,
-            cudf::get_current_device_resource_ref()));
-      } else {
-        inputTableColumns.emplace_back(
-            std::move(std::get<std::unique_ptr<cudf::column>>(result)));
-      }
-      continue;
-    }
-    if (ins_name == "year") {
-      auto newColumn = cudf::datetime::extract_datetime_component(
-          inputTableColumns[dependent_column_index]->view(),
-          cudf::datetime::datetime_component::YEAR,
-          stream,
-          cudf::get_current_device_resource_ref());
-      inputTableColumns.emplace_back(std::move(newColumn));
-    } else if (ins_name == "length") {
-      auto newColumn = cudf::strings::count_characters(
-          inputTableColumns[dependent_column_index]->view(),
-          stream,
-          cudf::get_current_device_resource_ref());
-      inputTableColumns.emplace_back(std::move(newColumn));
-    } else if (ins_name == "lower") {
-      auto newColumn = cudf::strings::to_lower(
-          inputTableColumns[dependent_column_index]->view(),
-          stream,
-          cudf::get_current_device_resource_ref());
-      inputTableColumns.emplace_back(std::move(newColumn));
-    } else if (ins_name.rfind("like", 0) == 0) {
-      std::istringstream iss(ins_name.substr(4));
-      int patternIndex{-1}, escapeIndex{-1};
-      iss >> patternIndex >> escapeIndex;
-      auto newColumn = cudf::strings::like(
-          inputTableColumns[dependent_column_index]->view(),
-          *static_cast<cudf::string_scalar*>(scalars[patternIndex].get()),
-          escapeIndex == -1
-              ? cudf::string_scalar(
-                    "", true, stream, cudf::get_current_device_resource_ref())
-              : *static_cast<cudf::string_scalar*>(scalars[escapeIndex].get()),
-          stream,
-          cudf::get_current_device_resource_ref());
-      inputTableColumns.emplace_back(std::move(newColumn));
-    } else if (ins_name.rfind("startswith", 0) == 0) {
-      auto scalarIndex = std::stoi(ins_name.substr(10));
-      auto newColumn = cudf::strings::starts_with(
-          inputTableColumns[dependent_column_index]->view(),
-          *static_cast<cudf::string_scalar*>(scalars[scalarIndex].get()),
-          stream,
-          cudf::get_current_device_resource_ref());
-      inputTableColumns.emplace_back(std::move(newColumn));
-    } else if (ins_name.rfind("endswith", 0) == 0) {
-      auto scalarIndex = std::stoi(ins_name.substr(8));
-      auto newColumn = cudf::strings::ends_with(
-          inputTableColumns[dependent_column_index]->view(),
-          *static_cast<cudf::string_scalar*>(scalars[scalarIndex].get()),
-          stream,
-          cudf::get_current_device_resource_ref());
-      inputTableColumns.emplace_back(std::move(newColumn));
-    } else if (ins_name.rfind("contains", 0) == 0) {
-      auto scalarIndex = std::stoi(ins_name.substr(8));
-      auto newColumn = cudf::strings::contains(
-          inputTableColumns[dependent_column_index]->view(),
-          *static_cast<cudf::string_scalar*>(scalars[scalarIndex].get()),
-          stream,
-          cudf::get_current_device_resource_ref());
-      inputTableColumns.emplace_back(std::move(newColumn));
-    } else if (ins_name.rfind("like", 0) == 0) {
-      std::istringstream iss(ins_name.substr(4));
-      int patternIndex{-1}, escapeIndex{-1};
-      iss >> patternIndex >> escapeIndex;
-      auto newColumn = cudf::strings::like(
-          inputTableColumns[dependent_column_index]->view(),
-          *static_cast<cudf::string_scalar*>(scalars[patternIndex].get()),
-          escapeIndex == -1
-              ? cudf::string_scalar(
-                    "", true, stream, cudf::get_current_device_resource_ref())
-              : *static_cast<cudf::string_scalar*>(scalars[escapeIndex].get()),
-          stream,
-          cudf::get_current_device_resource_ref());
-      inputTableColumns.emplace_back(std::move(newColumn));
-    } else if (ins_name.rfind("fill", 0) == 0) {
-      auto scalarIndex =
-          std::stoi(ins_name.substr(5)); // "fill " is 5 characters
-      auto newColumn = cudf::make_column_from_scalar(
-          *static_cast<cudf::string_scalar*>(scalars[scalarIndex].get()),
-          inputTableColumns[dependent_column_index]->size(),
-          stream,
-          cudf::get_current_device_resource_ref());
-      inputTableColumns.emplace_back(std::move(newColumn));
-    } else if (ins_name.rfind("fill", 0) == 0) {
-      auto scalarIndex =
-          std::stoi(ins_name.substr(5)); // "fill " is 5 characters
-      auto newColumn = cudf::make_column_from_scalar(
-          *static_cast<cudf::string_scalar*>(scalars[scalarIndex].get()),
-          inputTableColumns[dependent_column_index]->size(),
-          stream,
-          cudf::get_current_device_resource_ref());
-      inputTableColumns.emplace_back(std::move(newColumn));
-    } else if (ins_name == "nested_column") {
-      auto newColumn = std::make_unique<cudf::column>(
-          inputTableColumns[dependent_column_index]->view().child(
-              nested_dependent_column_indices[0]),
-          stream,
-          cudf::get_current_device_resource_ref());
-      inputTableColumns.emplace_back(std::move(newColumn));
-    } else {
-      VELOX_FAIL("Unsupported precompute operation " + ins_name);
-    }
-  }
-}
-
-ExpressionEvaluator::ExpressionEvaluator(
-    const std::vector<std::shared_ptr<velox::exec::Expr>>& exprs,
-    const RowTypePtr& inputRowSchema)
-    : inputRowSchema_(inputRowSchema) {
-  exprAst_.reserve(exprs.size());
-  for (const auto& expr : exprs) {
-    cudf::ast::tree tree;
-    createAstTree(
-        expr, tree, scalars_, inputRowSchema, precomputeInstructions_);
-    exprAst_.emplace_back(std::move(tree));
-  }
-}
-
-void ExpressionEvaluator::close() {
-  exprAst_.clear();
-  scalars_.clear();
-  precomputeInstructions_.clear();
-}
-
-std::vector<std::unique_ptr<cudf::column>> ExpressionEvaluator::compute(
-    std::vector<std::unique_ptr<cudf::column>>& inputTableColumns,
-    rmm::cuda_stream_view stream,
-    rmm::device_async_resource_ref mr) {
-  auto numColumns = inputTableColumns.size();
-  addPrecomputedColumns(
-      inputTableColumns,
-      precomputeInstructions_,
-      scalars_,
-      inputRowSchema_,
-      stream);
-  auto astInputTable =
-      std::make_unique<cudf::table>(std::move(inputTableColumns));
-  auto astInputTableView = astInputTable->view();
-  std::vector<std::unique_ptr<cudf::column>> columns;
-  for (auto& tree : exprAst_) {
-    if (auto colRefPtr =
-            dynamic_cast<cudf::ast::column_reference const*>(&tree.back())) {
-      auto col = std::make_unique<cudf::column>(
-          astInputTableView.column(colRefPtr->get_column_index()), stream, mr);
-      columns.emplace_back(std::move(col));
-    } else {
-      auto col =
-          cudf::compute_column(astInputTableView, tree.back(), stream, mr);
-      columns.emplace_back(std::move(col));
-    }
-  }
-  inputTableColumns = astInputTable->release();
-  inputTableColumns.resize(numColumns);
-  return columns;
-}
-
-bool ExpressionEvaluator::canBeEvaluated(
-    const std::vector<std::shared_ptr<velox::exec::Expr>>& exprs) {
-  return std::all_of(exprs.begin(), exprs.end(), detail::canBeEvaluated);
-}
-
-namespace {
-
-template <
-    typename RangeT,
-    typename ScalarT,
-    typename = std::enable_if_t<
-        std::is_base_of_v<facebook::velox::common::AbstractRange, RangeT>>>
-const cudf::ast::expression& createRangeExpr(
-    const facebook::velox::common::Filter& filter,
-    cudf::ast::tree& tree,
-    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
-    const cudf::ast::expression& columnRef,
-    rmm::cuda_stream_view stream,
-    rmm::device_async_resource_ref mr) {
-  using Op = cudf::ast::ast_operator;
-  using Operation = cudf::ast::operation;
-
-  auto* range = dynamic_cast<const RangeT*>(&filter);
-  VELOX_CHECK_NOT_NULL(range, "Filter is not the expected range type");
-
-  const bool lowerUnbounded = range->lowerUnbounded();
-  const bool upperUnbounded = range->upperUnbounded();
-
-  const cudf::ast::expression* lowerExpr = nullptr;
-  const cudf::ast::expression* upperExpr = nullptr;
-
-  auto addLiteral = [&](auto value) -> const cudf::ast::expression& {
-    scalars.emplace_back(std::make_unique<ScalarT>(value, true, stream, mr));
-    return tree.push(
-        cudf::ast::literal{*static_cast<ScalarT*>(scalars.back().get())});
-  };
-
-  // If RangeT is BytesValues and it's a single value, return a simple equality
-  // expression. This is an early return for the single-value IN-list filter on
-  // bytes.
-  if constexpr (std::is_same_v<RangeT, facebook::velox::common::BytesRange>) {
-    if (range->isSingleValue()) {
-      // Only one value in the IN-list, so just compare for equality.
-      auto singleValue = range->lower();
-      const auto& literal = addLiteral(singleValue);
-      return tree.push(Operation{Op::EQUAL, columnRef, literal});
-    }
-  }
-
-  if (!lowerUnbounded) {
-    auto lowerValue = range->lower();
-    const auto& lowerLiteral = addLiteral(lowerValue);
-
-    auto lowerOp = range->lowerExclusive() ? Op::GREATER : Op::GREATER_EQUAL;
-    lowerExpr = &tree.push(Operation{lowerOp, columnRef, lowerLiteral});
-  }
-
-  if (!upperUnbounded) {
-    auto upperValue = range->upper();
-    const auto& upperLiteral = addLiteral(upperValue);
-
-    auto upperOp = range->upperExclusive() ? Op::LESS : Op::LESS_EQUAL;
-    upperExpr = &tree.push(Operation{upperOp, columnRef, upperLiteral});
-  }
-
-  if (lowerExpr && upperExpr) {
-    return tree.push(Operation{Op::NULL_LOGICAL_AND, *lowerExpr, *upperExpr});
-  } else if (lowerExpr) {
-    return *lowerExpr;
-  } else if (upperExpr) {
-    return *upperExpr;
-  }
-
-  // Both bounds unbounded => Pass-through filter (everything).
-  return tree.push(Operation{Op::EQUAL, columnRef, columnRef});
-}
-
-template <TypeKind Kind>
-std::reference_wrapper<const cudf::ast::expression> buildBigintRangeExpr(
-    const common::Filter& filter,
-    cudf::ast::tree& tree,
-    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
-    const cudf::ast::expression& columnRef,
-    rmm::cuda_stream_view stream,
-    rmm::device_async_resource_ref mr,
-    const TypePtr& columnTypePtr) {
-  using NativeT = typename TypeTraits<Kind>::NativeType;
-
-  if constexpr (std::is_integral_v<NativeT>) {
-    using Op = cudf::ast::ast_operator;
-    using Operation = cudf::ast::operation;
-
-    auto* bigintRange = static_cast<const common::BigintRange*>(&filter);
-
-    const auto lower = bigintRange->lower();
-    const auto upper = bigintRange->upper();
-
-    const bool skipLowerBound =
-        lower <= static_cast<int64_t>(std::numeric_limits<NativeT>::min());
-    const bool skipUpperBound =
-        upper >= static_cast<int64_t>(std::numeric_limits<NativeT>::max());
-
-    auto addLiteral = [&](int64_t value) -> const cudf::ast::expression& {
-      variant veloxVariant = static_cast<NativeT>(value);
-      const auto& literal =
-          makeScalarAndLiteral<Kind>(columnTypePtr, veloxVariant, scalars);
-      return tree.push(literal);
-    };
-
-    if (bigintRange->isSingleValue()) {
-      // Equal comparison: column = value. This value is the same as the
-      // lower/upper bound.
-      if (skipLowerBound || skipUpperBound) {
-        // If the singular value of this filter lies outside the range of the
-        // column's NativeT type then we want to be always false
-        return tree.push(Operation{Op::NOT_EQUAL, columnRef, columnRef});
-      } else {
-        auto const& literal = addLiteral(lower);
-        return tree.push(Operation{Op::EQUAL, columnRef, literal});
-      }
-    } else {
-      // Range comparison: column >= lower AND column <= upper
-
-      const cudf::ast::expression* lowerExpr = nullptr;
-      if (!skipLowerBound) {
-        auto const& lowerLiteral = addLiteral(lower);
-        lowerExpr =
-            &tree.push(Operation{Op::GREATER_EQUAL, columnRef, lowerLiteral});
-      }
-
-      const cudf::ast::expression* upperExpr = nullptr;
-      if (!skipUpperBound) {
-        auto const& upperLiteral = addLiteral(upper);
-        upperExpr =
-            &tree.push(Operation{Op::LESS_EQUAL, columnRef, upperLiteral});
-      }
-
-      if (lowerExpr && upperExpr) {
-        auto const& result =
-            tree.push(Operation{Op::NULL_LOGICAL_AND, *lowerExpr, *upperExpr});
-        return result;
-      } else if (lowerExpr) {
-        return *lowerExpr;
-      } else if (upperExpr) {
-        return *upperExpr;
-      }
-
-      // If neither lower nor upper bound expressions were created, it means
-      // the filter covers the entire range of the type, so it's a no-op
-      return tree.push(Operation{Op::EQUAL, columnRef, columnRef});
-    }
-  } else {
-    VELOX_FAIL(
-        "Unsupported type for buildBigintRangeExpr: {}",
-        mapTypeKindToName(Kind));
-  }
-}
-
-template <typename T>
-auto createFloatingPointRangeExpr(
-    const common::Filter& filter,
-    cudf::ast::tree& tree,
-    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
-    const cudf::ast::expression& columnRef,
-    rmm::cuda_stream_view stream,
-    rmm::device_async_resource_ref mr) -> const cudf::ast::expression& {
-  return createRangeExpr<
-      facebook::velox::common::FloatingPointRange<T>,
-      cudf::numeric_scalar<T>>(filter, tree, scalars, columnRef, stream, mr);
-};
-
-const cudf::ast::expression& createBytesRangeExpr(
-    const common::Filter& filter,
-    cudf::ast::tree& tree,
-    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
-    const cudf::ast::expression& columnRef,
-    rmm::cuda_stream_view stream,
-    rmm::device_async_resource_ref mr) {
-  return createRangeExpr<
-      facebook::velox::common::BytesRange,
-      cudf::string_scalar>(filter, tree, scalars, columnRef, stream, mr);
-}
-
-template <typename FilterT, typename ScalarT>
-const cudf::ast::expression& buildInListExpr(
-    const common::Filter& filter,
-    cudf::ast::tree& tree,
-    const cudf::ast::expression& columnRef,
-    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
-    bool isNegated,
-    rmm::cuda_stream_view stream,
-    rmm::device_async_resource_ref mr) {
-  using Op = cudf::ast::ast_operator;
-  using Operation = cudf::ast::operation;
-
-  auto* valuesFilter = dynamic_cast<const FilterT*>(&filter);
-  VELOX_CHECK_NOT_NULL(valuesFilter, "Filter is not a List filter");
-  auto const& values = valuesFilter->values();
-  if (values.empty()) {
-    VELOX_FAIL("Empty List filter not supported");
-  }
-
-  std::vector<const cudf::ast::expression*> exprVec;
-  for (const auto& value : values) {
-    scalars.emplace_back(std::make_unique<ScalarT>(value, true, stream, mr));
-    auto const& literal = tree.push(
-        cudf::ast::literal{*static_cast<ScalarT*>(scalars.back().get())});
-    auto const& equalExpr = tree.push(
-        Operation{isNegated ? Op::NOT_EQUAL : Op::EQUAL, columnRef, literal});
-    exprVec.push_back(&equalExpr);
-  }
-
-  const cudf::ast::expression* result = exprVec[0];
-  for (size_t i = 1; i < exprVec.size(); ++i) {
-    if (isNegated) {
-      result =
-          &tree.push(Operation{Op::NULL_LOGICAL_AND, *result, *exprVec[i]});
-    } else {
-      result = &tree.push(Operation{Op::NULL_LOGICAL_OR, *result, *exprVec[i]});
-    }
-  }
-  return *result;
-}
-
-// Build an IN-list expression for integer columns where the filter values are
-// provided as int64_t but the column may be any integral type. Values outside
-// the target type's range are ignored. If all values are out of range, this
-// returns a constant false expression (col != col).
-template <TypeKind Kind>
-std::reference_wrapper<const cudf::ast::expression> buildIntegerInListExpr(
-    const common::Filter& filter,
-    cudf::ast::tree& tree,
-    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
-    const cudf::ast::expression& columnRef,
-    rmm::cuda_stream_view /*stream*/,
-    rmm::device_async_resource_ref /*mr*/,
-    const TypePtr& columnTypePtr) {
-  using NativeT = typename TypeTraits<Kind>::NativeType;
-
-  if constexpr (std::is_integral_v<NativeT>) {
-    using Op = cudf::ast::ast_operator;
-    using Operation = cudf::ast::operation;
-
-    auto* valuesFilter =
-        static_cast<const common::BigintValuesUsingBitmask*>(&filter);
-    const auto& values = valuesFilter->values();
-
-    std::vector<const cudf::ast::expression*> exprVec;
-    exprVec.reserve(values.size());
-
-    for (const int64_t value : values) {
-      if (value < static_cast<int64_t>(std::numeric_limits<NativeT>::min()) ||
-          value > static_cast<int64_t>(std::numeric_limits<NativeT>::max())) {
-        // Skip values that cannot be represented in the column type.
-        continue;
-      }
-
-      variant veloxVariant = static_cast<NativeT>(value);
-      const auto& literal =
-          makeScalarAndLiteral<Kind>(columnTypePtr, veloxVariant, scalars);
-      auto const& cudfLiteral = tree.push(literal);
-      auto const& equalExpr =
-          tree.push(Operation{Op::EQUAL, columnRef, cudfLiteral});
-      exprVec.push_back(&equalExpr);
-    }
-
-    if (exprVec.empty()) {
-      // No representable values -> always false
-      auto const& alwaysFalse =
-          tree.push(Operation{Op::NOT_EQUAL, columnRef, columnRef});
-      return std::ref(alwaysFalse);
-    }
-
-    const cudf::ast::expression* result = exprVec[0];
-    for (size_t i = 1; i < exprVec.size(); ++i) {
-      result = &tree.push(Operation{Op::NULL_LOGICAL_OR, *result, *exprVec[i]});
-    }
-    return std::ref(*result);
-  } else {
-    VELOX_FAIL(
-        "Unsupported type for buildIntegerInListExpr: {}",
-        mapTypeKindToName(Kind));
-  }
-}
-
-} // namespace
-
-// Convert subfield filters to cudf AST
-cudf::ast::expression const& createAstFromSubfieldFilter(
-    const common::Subfield& subfield,
-    const common::Filter& filter,
-    cudf::ast::tree& tree,
-    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
-    const RowTypePtr& inputRowSchema) {
-  // First, create column reference from subfield
-  // For now, only support simple field references
-  if (subfield.path().empty() ||
-      subfield.path()[0]->kind() != common::SubfieldKind::kNestedField) {
-    VELOX_FAIL(
-        "Only simple field references are supported in subfield filters");
-  }
-
-  auto nestedField = static_cast<const common::Subfield::NestedField*>(
-      subfield.path()[0].get());
-  const std::string& fieldName = nestedField->name();
-
-  if (!inputRowSchema->containsChild(fieldName)) {
-    VELOX_FAIL("Field '{}' not found in input schema", fieldName);
-  }
-
-  auto columnIndex = inputRowSchema->getChildIdx(fieldName);
-  auto const& columnRef = tree.push(cudf::ast::column_reference(columnIndex));
-
-  using Op = cudf::ast::ast_operator;
-  using Operation = cudf::ast::operation;
-
-  auto stream = cudf::get_default_stream();
-  auto mr = cudf::get_current_device_resource_ref();
-
-  switch (filter.kind()) {
-    case common::FilterKind::kBigintRange: {
-      auto const& columnType = inputRowSchema->childAt(columnIndex);
-      auto result = VELOX_DYNAMIC_TYPE_DISPATCH(
-          buildBigintRangeExpr,
-          columnType->kind(),
-          filter,
-          tree,
-          scalars,
-          columnRef,
-          stream,
-          mr,
-          columnType);
-      return result.get();
-    }
-
-    case common::FilterKind::kBigintValuesUsingBitmask: {
-      auto const& columnType = inputRowSchema->childAt(columnIndex);
-      // Dispatch by the column's integer kind and cast filter values to it.
-      auto result = VELOX_DYNAMIC_TYPE_DISPATCH(
-          buildIntegerInListExpr,
-          columnType->kind(),
-          filter,
-          tree,
-          scalars,
-          columnRef,
-          stream,
-          mr,
-          columnType);
-      return result.get();
-    }
-
-    case common::FilterKind::kBytesValues: {
-      return buildInListExpr<common::BytesValues, cudf::string_scalar>(
-          filter, tree, columnRef, scalars, false, stream, mr);
-    }
-
-    case common::FilterKind::kNegatedBytesValues: {
-      return buildInListExpr<common::NegatedBytesValues, cudf::string_scalar>(
-          filter, tree, columnRef, scalars, true, stream, mr);
-    }
-
-    case common::FilterKind::kDoubleRange: {
-      return createFloatingPointRangeExpr<double>(
-          filter, tree, scalars, columnRef, stream, mr);
-    }
-
-    case common::FilterKind::kFloatRange: {
-      return createFloatingPointRangeExpr<float>(
-          filter, tree, scalars, columnRef, stream, mr);
-    }
-
-    case common::FilterKind::kBytesRange: {
-      return createBytesRangeExpr(filter, tree, scalars, columnRef, stream, mr);
-    }
-
-    case common::FilterKind::kBoolValue: {
-      auto* boolValue = static_cast<const common::BoolValue*>(&filter);
-      auto matchesTrue = boolValue->testBool(true);
-      scalars.emplace_back(std::make_unique<cudf::numeric_scalar<bool>>(
-          matchesTrue, true, stream, mr));
-      auto const& matchesBoolExpr = tree.push(cudf::ast::literal{
-          *static_cast<cudf::numeric_scalar<bool>*>(scalars.back().get())});
-      return tree.push(Operation{Op::EQUAL, columnRef, matchesBoolExpr});
-    }
-
-    case common::FilterKind::kIsNull: {
-      return tree.push(Operation{Op::IS_NULL, columnRef});
-    }
-
-    case common::FilterKind::kIsNotNull: {
-      // For IsNotNull, we can use NOT(IS_NULL)
-      auto const& nullCheck = tree.push(Operation{Op::IS_NULL, columnRef});
-      return tree.push(Operation{Op::NOT, nullCheck});
-    }
-
-    default:
-      VELOX_NYI(
-          "Filter type {} not yet supported for subfield filter conversion",
-          static_cast<int>(filter.kind()));
-  }
-}
-
-// Create a combined AST from a set of subfield filters by chaining them with
-// logical ANDs. The returned expression is owned by the provided 'tree'.
-cudf::ast::expression const& createAstFromSubfieldFilters(
-    const common::SubfieldFilters& subfieldFilters,
-    cudf::ast::tree& tree,
-    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
-    const RowTypePtr& inputRowSchema) {
-  using Op = cudf::ast::ast_operator;
-  using Operation = cudf::ast::operation;
-
-  std::vector<const cudf::ast::expression*> exprRefs;
-
-  // Build individual filter expressions.
-  for (const auto& [subfield, filterPtr] : subfieldFilters) {
-    if (!filterPtr) {
-      continue;
-    }
-    auto const& expr = createAstFromSubfieldFilter(
-        subfield, *filterPtr, tree, scalars, inputRowSchema);
-    exprRefs.push_back(&expr);
-  }
-
-  VELOX_CHECK_GT(exprRefs.size(), 0, "No subfield filters provided");
-
-  if (exprRefs.size() == 1) {
-    return *exprRefs[0];
-  }
-
-  // Combine expressions with NULL_LOGICAL_AND.
-  const cudf::ast::expression* result = exprRefs[0];
-  for (size_t i = 1; i < exprRefs.size(); ++i) {
-    auto const& andExpr =
-        tree.push(Operation{Op::NULL_LOGICAL_AND, *result, *exprRefs[i]});
-    result = &andExpr;
-  }
-
-  return *result;
-}
-} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/ExpressionEvaluator.h b/velox/experimental/cudf/exec/ExpressionEvaluator.h
deleted file mode 100644
index 6472cb03be5..00000000000
--- a/velox/experimental/cudf/exec/ExpressionEvaluator.h
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include "velox/expression/Expr.h"
-#include "velox/type/Filter.h"
-#include "velox/type/Subfield.h"
-#include "velox/type/Type.h"
-
-#include <cudf/ast/expressions.hpp>
-#include <cudf/column/column.hpp>
-
-#include <memory>
-#include <string>
-#include <variant>
-#include <vector>
-
-namespace facebook::velox::cudf_velox {
-
-// Forward declaration to allow usage in PrecomputeInstruction
-struct CudfExpressionNode;
-
-// Pre-compute instructions for the expression,
-// for ops that are not supported by cudf::ast
-struct PrecomputeInstruction {
-  int dependent_column_index;
-  std::string ins_name;
-  int new_column_index;
-  std::vector<int> nested_dependent_column_indices;
-  // Optional: compiled cudf expression node for recursive/non-AST eval
-  std::shared_ptr<CudfExpressionNode> cudf_node;
-
-  // Constructor to initialize the struct with values
-  PrecomputeInstruction(
-      int depIndex,
-      const std::string& name,
-      int newIndex,
-      const std::shared_ptr<CudfExpressionNode>& node = nullptr)
-      : dependent_column_index(depIndex),
-        ins_name(name),
-        new_column_index(newIndex),
-        cudf_node(node) {}
-
-  // TODO (dm): This two ctor situation is crazy.
-  PrecomputeInstruction(
-      int depIndex,
-      const std::string& name,
-      int newIndex,
-      const std::vector<int>& nestedIndices,
-      const std::shared_ptr<CudfExpressionNode>& node = nullptr)
-      : dependent_column_index(depIndex),
-        ins_name(name),
-        new_column_index(newIndex),
-        nested_dependent_column_indices(nestedIndices),
-        cudf_node(node) {}
-};
-
-// Holds either a non-owning cudf::column_view (zero-copy) or an owning
-// cudf::column (materialised result).
-using ColumnOrView =
-    std::variant<cudf::column_view, std::unique_ptr<cudf::column>>;
-
-// Helper to always obtain a column_view.
-inline cudf::column_view asView(ColumnOrView& holder) {
-  return std::visit(
-      [](auto& h) -> cudf::column_view {
-        using T = std::decay_t<decltype(h)>;
-        if constexpr (std::is_same_v<T, cudf::column_view>) {
-          return h;
-        } else {
-          return h->view();
-        }
-      },
-      holder);
-}
-
-class CudfFunction {
- public:
-  virtual ~CudfFunction() = default;
-  virtual ColumnOrView eval(
-      std::vector<ColumnOrView>& inputColumns,
-      rmm::cuda_stream_view stream,
-      rmm::device_async_resource_ref mr) const = 0;
-};
-
-using CudfFunctionFactory = std::function<std::shared_ptr<CudfFunction>(
-    const std::string& name,
-    const std::shared_ptr<velox::exec::Expr>& expr)>;
-
-bool registerCudfFunction(
-    const std::string& name,
-    CudfFunctionFactory factory,
-    bool overwrite = true);
-
-bool registerBuiltinFunctions(const std::string& prefix);
-
-struct CudfExpressionNode {
-  std::shared_ptr<velox::exec::Expr> expr;
-  std::shared_ptr<CudfFunction> function;
-  std::vector<std::shared_ptr<CudfExpressionNode>> subexpressions;
-
-  static std::shared_ptr<CudfExpressionNode> create(
-      const std::shared_ptr<velox::exec::Expr>& expr);
-
-  // TODO (dm): A storage for keeping results in case this is a multiply
-  // referenced subexpression (to do CSE)
-
-  ColumnOrView eval(
-      std::vector<std::unique_ptr<cudf::column>>& inputTableColumns,
-      const RowTypePtr& inputRowSchema,
-      rmm::cuda_stream_view stream,
-      rmm::device_async_resource_ref mr);
-};
-
-cudf::ast::expression const& createAstTree(
-    const std::shared_ptr<velox::exec::Expr>& expr,
-    cudf::ast::tree& tree,
-    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
-    const RowTypePtr& inputRowSchema,
-    std::vector<PrecomputeInstruction>& precomputeInstructions);
-
-cudf::ast::expression const& createAstTree(
-    const std::shared_ptr<velox::exec::Expr>& expr,
-    cudf::ast::tree& tree,
-    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
-    const RowTypePtr& leftRowSchema,
-    const RowTypePtr& rightRowSchema,
-    std::vector<PrecomputeInstruction>& leftPrecomputeInstructions,
-    std::vector<PrecomputeInstruction>& rightPrecomputeInstructions);
-
-// Convert subfield filters to cudf AST
-cudf::ast::expression const& createAstFromSubfieldFilter(
-    const common::Subfield& subfield,
-    const common::Filter& filter,
-    cudf::ast::tree& tree,
-    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
-    const RowTypePtr& inputRowSchema);
-
-// Build a single AST expression representing logical AND of all filters in
-// 'subfieldFilters'. The resulting expression reference is owned by the passed
-// 'tree'.
-cudf::ast::expression const& createAstFromSubfieldFilters(
-    const common::SubfieldFilters& subfieldFilters,
-    cudf::ast::tree& tree,
-    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
-    const RowTypePtr& inputRowSchema);
-
-// Evaluates the expression tree
-class ExpressionEvaluator {
- public:
-  ExpressionEvaluator() = default;
-  // Converts velox expressions to cudf::ast::tree, scalars and
-  // precompute instructions and stores them
-  ExpressionEvaluator(
-      const std::vector<std::shared_ptr<velox::exec::Expr>>& exprs,
-      const RowTypePtr& inputRowSchema);
-
-  // Evaluates the expression tree for the given input columns
-  std::vector<std::unique_ptr<cudf::column>> compute(
-      std::vector<std::unique_ptr<cudf::column>>& inputTableColumns,
-      rmm::cuda_stream_view stream,
-      rmm::device_async_resource_ref mr);
-
-  void close();
-
-  static bool canBeEvaluated(
-      const std::vector<std::shared_ptr<velox::exec::Expr>>& exprs);
-
- private:
-  std::vector<cudf::ast::tree> exprAst_;
-  std::vector<std::unique_ptr<cudf::scalar>> scalars_;
-  // instruction on dependent column to get new column index on non-ast
-  // supported operations in expressions
-  // <dependent_column_index, "instruction", new_column_index>
-  std::vector<PrecomputeInstruction> precomputeInstructions_;
-  RowTypePtr inputRowSchema_;
-};
-
-} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/GpuResources.cpp b/velox/experimental/cudf/exec/GpuResources.cpp
new file mode 100644
index 00000000000..92d7e7613c6
--- /dev/null
+++ b/velox/experimental/cudf/exec/GpuResources.cpp
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/CudfDefaultStreamOverload.h"
+#include "velox/experimental/cudf/exec/GpuResources.h"
+
+#include <cudf/detail/utilities/stream_pool.hpp>
+#include <cudf/utilities/default_stream.hpp>
+#include <cudf/utilities/memory_resource.hpp>
+#include <cudf/utilities/prefetch.hpp>
+
+#include <rmm/mr/arena_memory_resource.hpp>
+#include <rmm/mr/cuda_async_managed_memory_resource.hpp>
+#include <rmm/mr/cuda_async_memory_resource.hpp>
+#include <rmm/mr/cuda_memory_resource.hpp>
+#include <rmm/mr/managed_memory_resource.hpp>
+#include <rmm/mr/pool_memory_resource.hpp>
+#include <rmm/mr/prefetch_resource_adaptor.hpp>
+
+#include <common/base/Exceptions.h>
+
+#include <cstdlib>
+#include <string_view>
+
+namespace facebook::velox::cudf_velox {
+
+cuda::mr::any_resource<cuda::mr::device_accessible> createMemoryResource(
+    std::string_view mode,
+    int percent) {
+  if (mode == "cuda") {
+    return rmm::mr::cuda_memory_resource{};
+  } else if (mode == "pool") {
+    return rmm::mr::pool_memory_resource(
+        rmm::mr::cuda_memory_resource{},
+        rmm::percent_of_free_device_memory(percent));
+  } else if (mode == "async") {
+    return rmm::mr::cuda_async_memory_resource{};
+  } else if (mode == "arena") {
+    return rmm::mr::arena_memory_resource(
+        rmm::mr::cuda_memory_resource{},
+        rmm::percent_of_free_device_memory(percent));
+  } else if (mode == "managed") {
+    return rmm::mr::managed_memory_resource{};
+  } else if (mode == "managed_pool") {
+    return rmm::mr::pool_memory_resource(
+        rmm::mr::managed_memory_resource{},
+        rmm::percent_of_free_device_memory(percent));
+  } else if (mode == "managed_async") {
+    return rmm::mr::cuda_async_managed_memory_resource{};
+  } else if (mode == "prefetch_managed") {
+    cudf::prefetch::enable();
+    return rmm::mr::prefetch_resource_adaptor(
+        rmm::mr::managed_memory_resource{});
+  } else if (mode == "prefetch_managed_pool") {
+    cudf::prefetch::enable();
+    return rmm::mr::prefetch_resource_adaptor(
+        rmm::mr::pool_memory_resource(
+            rmm::mr::managed_memory_resource{},
+            rmm::percent_of_free_device_memory(percent)));
+  } else if (mode == "prefetch_managed_async") {
+    cudf::prefetch::enable();
+    return rmm::mr::prefetch_resource_adaptor(
+        rmm::mr::cuda_async_managed_memory_resource{});
+  }
+  VELOX_FAIL(
+      "Unknown memory resource mode: " + std::string(mode) +
+      "\nExpecting: cuda, pool, async, arena, managed, prefetch_managed, " +
+      "managed_pool, prefetch_managed_pool, managed_async, prefetch_managed_async");
+}
+
+cudf::detail::cuda_stream_pool& cudfGlobalStreamPool() {
+  return cudf::detail::global_cuda_stream_pool();
+};
+
+std::optional<cuda::mr::any_resource<cuda::mr::device_accessible>> mr_;
+std::optional<cuda::mr::any_resource<cuda::mr::device_accessible>> output_mr_;
+
+rmm::device_async_resource_ref get_output_mr() {
+  return output_mr_.value();
+}
+
+} // namespace facebook::velox::cudf_velox
+
+// This must NOT be in a file that includes CudfNoDefaults.h, because
+// CudfNoDefaults.h redeclares cudf::get_default_stream() with
+// __attribute__((error)). The overload below calls the real function.
+namespace cudf {
+
+rmm::cuda_stream_view const get_default_stream(allow_default_stream_t) {
+  return cudf::get_default_stream();
+}
+
+} // namespace cudf
diff --git a/velox/experimental/cudf/exec/GpuResources.h b/velox/experimental/cudf/exec/GpuResources.h
new file mode 100644
index 00000000000..4640645ee33
--- /dev/null
+++ b/velox/experimental/cudf/exec/GpuResources.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cudf/detail/utilities/stream_pool.hpp>
+
+#include <rmm/resource_ref.hpp>
+
+#include <cuda/memory_resource>
+
+#include <optional>
+#include <string_view>
+
+namespace facebook::velox::cudf_velox {
+
+extern std::optional<cuda::mr::any_resource<cuda::mr::device_accessible>> mr_;
+extern std::optional<cuda::mr::any_resource<cuda::mr::device_accessible>>
+    output_mr_;
+
+/// Returns the memory resource designated for output vector allocations.
+rmm::device_async_resource_ref get_output_mr();
+
+/**
+ * @brief Creates a memory resource based on the given mode.
+ *
+ * @param mode rmm::mr::pool_memory_resource mode.
+ * @param percent The initial percent of GPU memory to allocate for memory
+ * resource.
+ */
+[[nodiscard]] cuda::mr::any_resource<cuda::mr::device_accessible>
+createMemoryResource(std::string_view mode, int percent);
+
+/**
+ * @brief Returns the global CUDA stream pool used by cudf.
+ */
+[[nodiscard]] cudf::detail::cuda_stream_pool& cudfGlobalStreamPool();
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/NvtxHelper.h b/velox/experimental/cudf/exec/NvtxHelper.h
index 46e7655aab0..07d7bebeee0 100644
--- a/velox/experimental/cudf/exec/NvtxHelper.h
+++ b/velox/experimental/cudf/exec/NvtxHelper.h
@@ -16,8 +16,12 @@
 
 #pragma once
 
+#include "velox/experimental/cudf/CudfConfig.h"
+
 #include <nvtx3/nvtx3.hpp>
 
+#include <glog/logging.h>
+
 #include <optional>
 
 namespace facebook::velox::cudf_velox {
@@ -26,10 +30,12 @@ class NvtxHelper {
  public:
   NvtxHelper();
   NvtxHelper(
-      nvtx3::color color,
+      std::optional<nvtx3::color> color = std::nullopt,
       std::optional<int64_t> payload = std::nullopt,
       std::optional<std::string> extraInfo = std::nullopt)
-      : color_(color), payload_(payload), extraInfo_(extraInfo) {}
+      : color_(color.value_or(nvtx3::rgb{160, 82, 45} /* Sienna */)),
+        payload_(payload),
+        extraInfo_(extraInfo) {}
 
   nvtx3::color color_{nvtx3::rgb{125, 125, 125}}; // Gray
   std::optional<int64_t> payload_{};
@@ -50,8 +56,8 @@ using NvtxRegisteredStringT = nvtx3::registered_string_in<VeloxDomain>;
  *
  * This function parses a string like:
  * "virtual facebook::velox::RowVectorPtr
- * facebook::velox::cudf_velox::CudfHashAggregation::getOutput()" and returns
- * "CudfHashAggregation::getOutput"
+ * facebook::velox::cudf_velox::CudfGroupby::getOutput()" and returns
+ * "CudfGroupby::getOutput"
  *
  * @param prettyFunction The string from __PRETTY_FUNCTION__
  * @return A simplified string in the format "classname::function"
@@ -79,23 +85,75 @@ constexpr std::string_view extractClassAndFunction(
   return prettyFunction.substr(prevColonPos + 2, parenPos - prevColonPos - 2);
 }
 
-#define VELOX_NVTX_OPERATOR_FUNC_RANGE()                                         \
-  static_assert(                                                                 \
-      std::is_base_of<NvtxHelper, std::remove_pointer<decltype(this)>::type>::   \
-          value,                                                                 \
-      "VELOX_NVTX_OPERATOR_FUNC_RANGE can only be used"                          \
-      " in Operators derived from NvtxHelper");                                  \
-  static std::string const nvtx3_func_name__{                                    \
-      std::string(extractClassAndFunction(__PRETTY_FUNCTION__))};                \
-  std::string const nvtx3_func_extra_info__{                                     \
-      nvtx3_func_name__ + " " + this->extraInfo_.value_or("")};                  \
-  ::nvtx3::event_attributes const nvtx3_func_attr__{                           \
-      this->payload_.has_value() ?                                             \
-          ::nvtx3::event_attributes{nvtx3_func_extra_info__, this->color_,     \
-                                   nvtx3::payload{this->payload_.value()}} :   \
+/// Extracts only the function name (without class) from __PRETTY_FUNCTION__.
+/// For example, "CudfOperatorBase::addInput" becomes "addInput".
+constexpr std::string_view extractFunctionName(
+    std::string_view prettyFunction) {
+  auto parenPos = prettyFunction.find('(');
+  if (parenPos == std::string_view::npos) {
+    parenPos = prettyFunction.size();
+  }
+
+  auto lastColonPos = prettyFunction.rfind("::", parenPos);
+  if (lastColonPos == std::string_view::npos) {
+    return prettyFunction.substr(0, parenPos);
+  }
+
+  return prettyFunction.substr(lastColonPos + 2, parenPos - lastColonPos - 2);
+}
+
+#define VELOX_NVTX_OPERATOR_FUNC_RANGE(...)                                       \
+  static_assert(                                                                  \
+      std::is_base_of<NvtxHelper, std::remove_pointer<decltype(this)>::type>::    \
+          value,                                                                  \
+      "VELOX_NVTX_OPERATOR_FUNC_RANGE can only be used"                           \
+      " in Operators derived from NvtxHelper");                                   \
+  static std::string const nvtx3_func_name__{                                     \
+      std::string(extractClassAndFunction(__PRETTY_FUNCTION__))};                 \
+  std::string const nvtx3_func_display_name__{__VA_OPT__(                         \
+      std::string(__VA_ARGS__) +                                                  \
+      "::" + std::string(extractFunctionName(__PRETTY_FUNCTION__)))               \
+                                                  __VA_OPT__(+) ""};              \
+  std::string const nvtx3_func_extra_info__{                                      \
+      (nvtx3_func_display_name__.empty() ? nvtx3_func_name__                      \
+                                         : nvtx3_func_display_name__) +           \
+      " " + this->extraInfo_.value_or("")};                                       \
+  ::nvtx3::event_attributes const nvtx3_func_attr__{                            \
+      this->payload_.has_value() ?                                               \
+          ::nvtx3::event_attributes{nvtx3_func_extra_info__, this->color_,      \
+                                   nvtx3::payload{this->payload_.value()}} :    \
           ::nvtx3::event_attributes{nvtx3_func_extra_info__, this->color_}}; \
   ::nvtx3::scoped_range_in<VeloxDomain> const nvtx3_range__{nvtx3_func_attr__};
 
+#define VELOX_NVTX_OPERATOR_FUNC_RANGE_IF(condition, ...)                          \
+  static_assert(                                                                   \
+      std::is_base_of<NvtxHelper, std::remove_pointer<decltype(this)>::type>::     \
+          value,                                                                   \
+      "VELOX_NVTX_OPERATOR_FUNC_RANGE_IF can only be used"                         \
+      " in Operators derived from NvtxHelper");                                    \
+  ::nvtx3::detail::optional_scoped_range_in<VeloxDomain> nvtx3_opt_range__;        \
+  if (condition) {                                                                 \
+    static std::string const nvtx3_func_name__{                                    \
+        std::string(extractClassAndFunction(__PRETTY_FUNCTION__))};                \
+    std::string const nvtx3_func_display_name__{__VA_OPT__(                        \
+        std::string(__VA_ARGS__) +                                                 \
+        "::" + std::string(extractFunctionName(__PRETTY_FUNCTION__)))              \
+                                                    __VA_OPT__(+) ""};             \
+    std::string const nvtx3_func_extra_info__{                                     \
+        (nvtx3_func_display_name__.empty() ? nvtx3_func_name__                     \
+                                           : nvtx3_func_display_name__) +          \
+        " " + this->extraInfo_.value_or("")};                                      \
+    if (CudfConfig::getInstance().debugEnabled) {                                  \
+      VLOG(2) << "Calling " << nvtx3_func_extra_info__;                            \
+    }                                                                              \
+    ::nvtx3::event_attributes const nvtx3_func_attr__{                           \
+        this->payload_.has_value() ?                                             \
+            ::nvtx3::event_attributes{nvtx3_func_extra_info__, this->color_,    \
+                                     nvtx3::payload{this->payload_.value()}} :  \
+            ::nvtx3::event_attributes{nvtx3_func_extra_info__, this->color_}}; \
+    nvtx3_opt_range__.begin(nvtx3_func_attr__);                                    \
+  }
+
 #define VELOX_NVTX_PRETTY_FUNC_RANGE()                                         \
   static NvtxRegisteredStringT const nvtx3_func_name__{                        \
       std::string(__func__) + " " + std::string(__PRETTY_FUNCTION__)};         \
diff --git a/velox/experimental/cudf/exec/OperatorAdapters.cpp b/velox/experimental/cudf/exec/OperatorAdapters.cpp
new file mode 100644
index 00000000000..dedc05d675a
--- /dev/null
+++ b/velox/experimental/cudf/exec/OperatorAdapters.cpp
@@ -0,0 +1,1031 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveConnector.h"
+#include "velox/experimental/cudf/exec/CudfAggregation.h"
+#include "velox/experimental/cudf/exec/CudfAssignUniqueId.h"
+#include "velox/experimental/cudf/exec/CudfBatchConcat.h"
+#include "velox/experimental/cudf/exec/CudfDistinct.h"
+#include "velox/experimental/cudf/exec/CudfEnforceSingleRow.h"
+#include "velox/experimental/cudf/exec/CudfFilterProject.h"
+#include "velox/experimental/cudf/exec/CudfGroupId.h"
+#include "velox/experimental/cudf/exec/CudfGroupby.h"
+#include "velox/experimental/cudf/exec/CudfHashJoin.h"
+#include "velox/experimental/cudf/exec/CudfLimit.h"
+#include "velox/experimental/cudf/exec/CudfLocalPartition.h"
+#include "velox/experimental/cudf/exec/CudfMarkDistinct.h"
+#include "velox/experimental/cudf/exec/CudfNestedLoopJoin.h"
+#include "velox/experimental/cudf/exec/CudfOrderBy.h"
+#include "velox/experimental/cudf/exec/CudfReduce.h"
+#include "velox/experimental/cudf/exec/CudfTopN.h"
+#include "velox/experimental/cudf/exec/OperatorAdapters.h"
+#include "velox/experimental/cudf/exec/Utilities.h"
+#include "velox/experimental/cudf/exec/Validation.h"
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
+
+#include "velox/connectors/ConnectorRegistry.h"
+#include "velox/exec/AssignUniqueId.h"
+#include "velox/exec/CallbackSink.h"
+#include "velox/exec/EnforceSingleRow.h"
+#include "velox/exec/FilterProject.h"
+#include "velox/exec/GroupId.h"
+#include "velox/exec/HashAggregation.h"
+#include "velox/exec/HashBuild.h"
+#include "velox/exec/HashProbe.h"
+#include "velox/exec/Limit.h"
+#include "velox/exec/LocalPartition.h"
+#include "velox/exec/MarkDistinct.h"
+#include "velox/exec/NestedLoopJoinBuild.h"
+#include "velox/exec/NestedLoopJoinProbe.h"
+#include "velox/exec/OrderBy.h"
+#include "velox/exec/StreamingAggregation.h"
+#include "velox/exec/TableScan.h"
+#include "velox/exec/Task.h"
+#include "velox/exec/TopN.h"
+#include "velox/exec/Values.h"
+
+namespace facebook::velox::cudf_velox {
+
+/// OperatorAdapterRegistry Implementation
+OperatorAdapterRegistry& OperatorAdapterRegistry::getInstance() {
+  static OperatorAdapterRegistry instance;
+  return instance;
+}
+
+void OperatorAdapterRegistry::registerAdapter(
+    std::unique_ptr<OperatorAdapter> adapter) {
+  adapters_.push_back(std::move(adapter));
+}
+
+const OperatorAdapter* OperatorAdapterRegistry::findAdapter(
+    const exec::Operator* op) const {
+  for (const auto& adapter : adapters_) {
+    if (adapter->canHandle(op)) {
+      return adapter.get();
+    }
+  }
+  // Note: It is possible to have priority based adapter search.
+  // But this is not implemented because it is not needed for now.
+  return nullptr;
+}
+
+const std::vector<std::unique_ptr<OperatorAdapter>>&
+OperatorAdapterRegistry::getAdapters() const {
+  return adapters_;
+}
+
+void OperatorAdapterRegistry::clear() {
+  adapters_.clear();
+}
+
+/// TableScanAdapter - Keeps original operator (produces GPU output)
+class TableScanAdapter : public OperatorAdapter {
+ public:
+  TableScanAdapter() : OperatorAdapter("TableScan") {}
+
+  bool canHandle(const exec::Operator* op) const override {
+    return dynamic_cast<const exec::TableScan*>(op) != nullptr;
+  }
+
+  bool canRunOnGPU(
+      const exec::Operator* op,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* /*ctx*/) const override {
+    auto tableScanNode =
+        std::dynamic_pointer_cast<const core::TableScanNode>(planNode);
+    if (!tableScanNode) {
+      LOG_FALLBACK(
+          "TableScan planNode is not TableScanNode, PlanNode id: {}",
+          planNode->id());
+      return false;
+    }
+    auto const& connector = velox::connector::ConnectorRegistry::tryGet(
+        tableScanNode->tableHandle()->connectorId());
+    auto cudfHiveConnector = std::dynamic_pointer_cast<
+        facebook::velox::cudf_velox::connector::hive::CudfHiveConnector>(
+        connector);
+    if (!cudfHiveConnector) {
+      LOG_FALLBACK(
+          "TableScan connector is not CudfHiveConnector, PlanNode id: {}",
+          planNode->id());
+    }
+    return cudfHiveConnector != nullptr;
+  }
+
+  bool acceptsGpuInput() const override {
+    return false;
+  }
+
+  bool producesGpuOutput() const override {
+    return true;
+  }
+
+  std::vector<std::unique_ptr<exec::Operator>> createReplacements(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& /*planNode*/,
+      exec::DriverCtx* /*ctx*/,
+      int32_t /*operatorId*/) const override {
+    return {}; // Keep original operator
+  }
+
+  bool keepOperator() const override {
+    return true;
+  }
+};
+
+/// FilterProjectAdapter - Replaces with CudfFilterProject
+class FilterProjectAdapter : public OperatorAdapter {
+ public:
+  FilterProjectAdapter() : OperatorAdapter("FilterProject") {}
+
+  bool canHandle(const exec::Operator* op) const override {
+    return dynamic_cast<const exec::FilterProject*>(op) != nullptr;
+  }
+
+  bool canRunOnGPU(
+      const exec::Operator* op,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* ctx) const override {
+    auto filterProjectOp = dynamic_cast<const exec::FilterProject*>(op);
+    if (!filterProjectOp) {
+      LOG_FALLBACK(
+          "FilterProjectAdapter operator is not FilterProject, PlanNode id: {}",
+          planNode->id());
+      return false;
+    }
+
+    auto projectPlanNode =
+        std::dynamic_pointer_cast<const core::ProjectNode>(planNode);
+    auto filterNode = filterProjectOp->filterNode();
+
+    if (projectPlanNode) {
+      if (projectPlanNode->sources()[0]->outputType()->size() == 0) {
+        if (filterNode || !projectPlanNode->projections().empty()) {
+          LOG_FALLBACK(
+              "FilterProject empty input type with filter or projections, PlanNode id: {}",
+              planNode->id());
+          return false;
+        }
+      }
+    }
+
+    // Check filter separately
+    if (filterNode) {
+      if (!canBeEvaluatedByCudf(
+              {filterNode->filter()}, ctx->task->queryCtx().get())) {
+        LOG_FALLBACK(
+            "FilterProject filter cannot be evaluated by cuDF, PlanNode id: {}",
+            planNode->id());
+        return false;
+      }
+    }
+
+    // Check projects separately
+    if (projectPlanNode) {
+      if (!canBeEvaluatedByCudf(
+              projectPlanNode->projections(), ctx->task->queryCtx().get())) {
+        LOG_FALLBACK(
+            "FilterProject projections cannot be evaluated by cuDF, PlanNode id: {}",
+            planNode->id());
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool acceptsGpuInput() const override {
+    return true;
+  }
+
+  bool producesGpuOutput() const override {
+    return true;
+  }
+
+  std::vector<std::unique_ptr<exec::Operator>> createReplacements(
+      const exec::Operator* op,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* ctx,
+      int32_t operatorId) const override {
+    auto filterProjectOp = dynamic_cast<const exec::FilterProject*>(op);
+    auto projectPlanNode =
+        std::dynamic_pointer_cast<const core::ProjectNode>(planNode);
+    auto filterPlanNode = filterProjectOp->filterNode();
+
+    std::vector<std::unique_ptr<exec::Operator>> result;
+    result.push_back(
+        std::make_unique<CudfFilterProject>(
+            operatorId, ctx, filterPlanNode, projectPlanNode));
+    return result;
+  }
+};
+
+/// AggregationAdapter - Replaces with CudfGroupby, CudfDistinct, or CudfReduce
+class AggregationAdapter : public OperatorAdapter {
+ public:
+  AggregationAdapter() : OperatorAdapter("Aggregation") {}
+
+  bool canHandle(const exec::Operator* op) const override {
+    return dynamic_cast<const exec::HashAggregation*>(op) != nullptr ||
+        dynamic_cast<const exec::StreamingAggregation*>(op) != nullptr;
+  }
+
+  bool canRunOnGPU(
+      const exec::Operator* op,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* ctx) const override {
+    if (!canHandle(op)) {
+      LOG_FALLBACK(
+          "Aggregation op is not HashAggregation or StreamingAggregation, PlanNode id: {}",
+          planNode->id());
+      return false;
+    }
+
+    auto aggregationPlanNode =
+        std::dynamic_pointer_cast<const core::AggregationNode>(planNode);
+    if (!aggregationPlanNode) {
+      LOG_FALLBACK(
+          "Aggregation planNode is not AggregationNode, PlanNode id: {}",
+          planNode->id());
+      return false;
+    }
+
+    bool canEvaluate =
+        canBeEvaluatedByCudf(*aggregationPlanNode, ctx->task->queryCtx().get());
+    if (!canEvaluate) {
+      LOG_FALLBACK(
+          "Aggregation aggregation cannot be evaluated by cuDF, PlanNode id: {}",
+          planNode->id());
+    }
+    return canEvaluate;
+  }
+
+  bool acceptsGpuInput() const override {
+    return true;
+  }
+
+  bool producesGpuOutput() const override {
+    return true;
+  }
+
+  std::vector<std::unique_ptr<exec::Operator>> createReplacements(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* ctx,
+      int32_t operatorId) const override {
+    auto aggregationPlanNode =
+        std::dynamic_pointer_cast<const core::AggregationNode>(planNode);
+
+    bool isGlobal = aggregationPlanNode->groupingKeys().empty();
+    bool isDistinct = !isGlobal && aggregationPlanNode->aggregates().empty();
+
+    std::vector<std::unique_ptr<exec::Operator>> result;
+    if (CudfConfig::getInstance().concatOptimizationEnabled) {
+      result.push_back(
+          std::make_unique<CudfBatchConcat>(
+              operatorId, ctx, aggregationPlanNode));
+    }
+    if (isGlobal) {
+      result.push_back(
+          std::make_unique<CudfReduce>(operatorId, ctx, aggregationPlanNode));
+    } else if (isDistinct) {
+      result.push_back(
+          std::make_unique<CudfDistinct>(operatorId, ctx, aggregationPlanNode));
+    } else {
+      result.push_back(
+          std::make_unique<CudfGroupby>(operatorId, ctx, aggregationPlanNode));
+    }
+    return result;
+  }
+};
+
+class CudfHashJoinBaseAdapter : public OperatorAdapter {
+ public:
+  using OperatorAdapter::OperatorAdapter;
+
+  bool canRunOnGPU(
+      const exec::Operator* op,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* ctx) const override {
+    if (!canHandle(op)) {
+      LOG_FALLBACK(
+          "HashJoin operator is not HashBuild or HashProbe, PlanNode id: {}",
+          planNode->id());
+      return false;
+    }
+
+    auto joinPlanNode =
+        std::dynamic_pointer_cast<const core::HashJoinNode>(planNode);
+    if (!joinPlanNode) {
+      LOG_FALLBACK(
+          "HashJoin planNode is not HashJoinNode, PlanNode id: {}",
+          planNode->id());
+      return false;
+    }
+
+    if (!CudfHashJoinProbe::isSupportedJoinType(joinPlanNode->joinType())) {
+      LOG_FALLBACK(
+          "HashJoin unsupported join type, PlanNode id: {}", planNode->id());
+      return false;
+    }
+
+    // Disabling null-aware anti join with filter until we implement it right
+    if (joinPlanNode->joinType() == core::JoinType::kAnti &&
+        joinPlanNode->isNullAware() && joinPlanNode->filter()) {
+      LOG_FALLBACK(
+          "HashJoin null-aware anti join with filter not implemented, PlanNode id: {}",
+          planNode->id());
+      return false;
+    }
+
+    if (joinPlanNode->filter()) {
+      if (!canBeEvaluatedByCudf(
+              {joinPlanNode->filter()}, ctx->task->queryCtx().get())) {
+        LOG_FALLBACK(
+            "HashJoin join filter cannot be evaluated by cuDF, PlanNode id: {}",
+            planNode->id());
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+/// HashJoinBuildAdapter - Replaces with CudfHashJoinBuild
+class HashJoinBuildAdapter : public CudfHashJoinBaseAdapter {
+ public:
+  HashJoinBuildAdapter() : CudfHashJoinBaseAdapter("HashJoinBuild") {}
+
+  bool canHandle(const exec::Operator* op) const override {
+    return dynamic_cast<const exec::HashBuild*>(op) != nullptr;
+  }
+
+  bool acceptsGpuInput() const override {
+    return true;
+  }
+
+  bool producesGpuOutput() const override {
+    return false;
+  }
+
+  std::vector<std::unique_ptr<exec::Operator>> createReplacements(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* ctx,
+      int32_t operatorId) const override {
+    auto joinPlanNode =
+        std::dynamic_pointer_cast<const core::HashJoinNode>(planNode);
+
+    std::vector<std::unique_ptr<exec::Operator>> result;
+    result.push_back(
+        std::make_unique<CudfHashJoinBuild>(operatorId, ctx, joinPlanNode));
+    return result;
+  }
+};
+
+/// HashJoinProbeAdapter - Replaces with CudfHashJoinProbe
+class HashJoinProbeAdapter : public CudfHashJoinBaseAdapter {
+ public:
+  HashJoinProbeAdapter() : CudfHashJoinBaseAdapter("HashJoinProbe") {}
+
+  bool canHandle(const exec::Operator* op) const override {
+    return dynamic_cast<const exec::HashProbe*>(op) != nullptr;
+  }
+
+  bool acceptsGpuInput() const override {
+    return true;
+  }
+
+  bool producesGpuOutput() const override {
+    return true;
+  }
+
+  std::vector<std::unique_ptr<exec::Operator>> createReplacements(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* ctx,
+      int32_t operatorId) const override {
+    auto joinPlanNode =
+        std::dynamic_pointer_cast<const core::HashJoinNode>(planNode);
+
+    std::vector<std::unique_ptr<exec::Operator>> result;
+    result.push_back(
+        std::make_unique<CudfHashJoinProbe>(operatorId, ctx, joinPlanNode));
+    return result;
+  }
+};
+
+class CudfNestedLoopJoinBaseAdapter : public OperatorAdapter {
+ public:
+  using OperatorAdapter::OperatorAdapter;
+
+  bool canRunOnGPU(
+      const exec::Operator* op,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* ctx) const override {
+    if (!canHandle(op)) {
+      return false;
+    }
+
+    auto joinPlanNode =
+        std::dynamic_pointer_cast<const core::NestedLoopJoinNode>(planNode);
+    if (!joinPlanNode) {
+      LOG_FALLBACK(
+          "NestedLoopJoin planNode is not NestedLoopJoinNode, PlanNode id: {}",
+          planNode->id());
+      return false;
+    }
+
+    if (!CudfNestedLoopJoinProbe::isSupportedJoinType(
+            joinPlanNode->joinType())) {
+      LOG_FALLBACK(
+          "NestedLoopJoin unsupported join type: {}, PlanNode id: {}",
+          static_cast<int>(joinPlanNode->joinType()),
+          planNode->id());
+      return false;
+    }
+
+    // Check if join condition can be evaluated on GPU
+    if (joinPlanNode->joinCondition()) {
+      if (!canBeEvaluatedByCudf(
+              {joinPlanNode->joinCondition()}, ctx->task->queryCtx().get())) {
+        LOG_FALLBACK(
+            "NestedLoopJoin filter cannot be evaluated by cuDF, PlanNode id: {}",
+            planNode->id());
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+/// NestedLoopJoinBuildAdapter - Replaces with CudfNestedLoopJoinBuild
+class NestedLoopJoinBuildAdapter : public CudfNestedLoopJoinBaseAdapter {
+ public:
+  NestedLoopJoinBuildAdapter()
+      : CudfNestedLoopJoinBaseAdapter("NestedLoopJoinBuild") {}
+
+  bool canHandle(const exec::Operator* op) const override {
+    return dynamic_cast<const exec::NestedLoopJoinBuild*>(op) != nullptr;
+  }
+
+  bool acceptsGpuInput() const override {
+    return true;
+  }
+
+  bool producesGpuOutput() const override {
+    return false;
+  }
+
+  std::vector<std::unique_ptr<exec::Operator>> createReplacements(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* ctx,
+      int32_t operatorId) const override {
+    auto joinPlanNode =
+        std::dynamic_pointer_cast<const core::NestedLoopJoinNode>(planNode);
+
+    std::vector<std::unique_ptr<exec::Operator>> result;
+    result.push_back(
+        std::make_unique<CudfNestedLoopJoinBuild>(
+            operatorId, ctx, joinPlanNode));
+    return result;
+  }
+};
+
+/// NestedLoopJoinProbeAdapter - Replaces with CudfNestedLoopJoinProbe
+class NestedLoopJoinProbeAdapter : public CudfNestedLoopJoinBaseAdapter {
+ public:
+  NestedLoopJoinProbeAdapter()
+      : CudfNestedLoopJoinBaseAdapter("NestedLoopJoinProbe") {}
+
+  bool canHandle(const exec::Operator* op) const override {
+    return dynamic_cast<const exec::NestedLoopJoinProbe*>(op) != nullptr;
+  }
+
+  bool acceptsGpuInput() const override {
+    return true;
+  }
+
+  bool producesGpuOutput() const override {
+    return true;
+  }
+
+  std::vector<std::unique_ptr<exec::Operator>> createReplacements(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* ctx,
+      int32_t operatorId) const override {
+    auto joinPlanNode =
+        std::dynamic_pointer_cast<const core::NestedLoopJoinNode>(planNode);
+
+    std::vector<std::unique_ptr<exec::Operator>> result;
+    result.push_back(
+        std::make_unique<CudfNestedLoopJoinProbe>(
+            operatorId, ctx, joinPlanNode));
+    return result;
+  }
+};
+
+/// OrderByAdapter - Replaces with CudfOrderBy
+class OrderByAdapter : public OperatorAdapter {
+ public:
+  OrderByAdapter() : OperatorAdapter("OrderBy") {}
+
+  bool canHandle(const exec::Operator* op) const override {
+    return dynamic_cast<const exec::OrderBy*>(op) != nullptr;
+  }
+
+  bool canRunOnGPU(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* /*ctx*/) const override {
+    return std::dynamic_pointer_cast<const core::OrderByNode>(planNode) !=
+        nullptr;
+  }
+
+  bool acceptsGpuInput() const override {
+    return true;
+  }
+
+  bool producesGpuOutput() const override {
+    return true;
+  }
+
+  std::vector<std::unique_ptr<exec::Operator>> createReplacements(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* ctx,
+      int32_t operatorId) const override {
+    auto orderByPlanNode =
+        std::dynamic_pointer_cast<const core::OrderByNode>(planNode);
+
+    std::vector<std::unique_ptr<exec::Operator>> result;
+    result.push_back(
+        std::make_unique<CudfOrderBy>(operatorId, ctx, orderByPlanNode));
+    return result;
+  }
+};
+
+/// TopNAdapter - Replaces with CudfTopN
+class TopNAdapter : public OperatorAdapter {
+ public:
+  TopNAdapter() : OperatorAdapter("TopN") {}
+
+  bool canHandle(const exec::Operator* op) const override {
+    return dynamic_cast<const exec::TopN*>(op) != nullptr;
+  }
+
+  bool canRunOnGPU(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* /*ctx*/) const override {
+    return std::dynamic_pointer_cast<const core::TopNNode>(planNode) != nullptr;
+  }
+
+  bool acceptsGpuInput() const override {
+    return true;
+  }
+
+  bool producesGpuOutput() const override {
+    return true;
+  }
+
+  std::vector<std::unique_ptr<exec::Operator>> createReplacements(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* ctx,
+      int32_t operatorId) const override {
+    auto topNPlanNode =
+        std::dynamic_pointer_cast<const core::TopNNode>(planNode);
+
+    std::vector<std::unique_ptr<exec::Operator>> result;
+    result.push_back(std::make_unique<CudfTopN>(operatorId, ctx, topNPlanNode));
+    return result;
+  }
+};
+
+/// LimitAdapter - Replaces with CudfLimit
+class LimitAdapter : public OperatorAdapter {
+ public:
+  LimitAdapter() : OperatorAdapter("Limit") {}
+
+  bool canHandle(const exec::Operator* op) const override {
+    return dynamic_cast<const exec::Limit*>(op) != nullptr;
+  }
+
+  bool canRunOnGPU(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* /*ctx*/) const override {
+    return std::dynamic_pointer_cast<const core::LimitNode>(planNode) !=
+        nullptr;
+  }
+
+  bool acceptsGpuInput() const override {
+    return true;
+  }
+
+  bool producesGpuOutput() const override {
+    return true;
+  }
+
+  std::vector<std::unique_ptr<exec::Operator>> createReplacements(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* ctx,
+      int32_t operatorId) const override {
+    auto limitPlanNode =
+        std::dynamic_pointer_cast<const core::LimitNode>(planNode);
+
+    std::vector<std::unique_ptr<exec::Operator>> result;
+    result.push_back(
+        std::make_unique<CudfLimit>(operatorId, ctx, limitPlanNode));
+    return result;
+  }
+};
+
+/// LocalPartitionAdapter - Conditionally replaces with CudfLocalPartition
+class LocalPartitionAdapter : public OperatorAdapter {
+ public:
+  LocalPartitionAdapter() : OperatorAdapter("LocalPartition") {}
+
+  bool canHandle(const exec::Operator* op) const override {
+    return dynamic_cast<const exec::LocalPartition*>(op) != nullptr;
+  }
+
+  bool canRunOnGPU(
+      const exec::Operator* op,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* /*ctx*/) const override {
+    auto localPartitionPlanNode =
+        std::dynamic_pointer_cast<const core::LocalPartitionNode>(planNode);
+    bool canRun = canHandle(op) && localPartitionPlanNode &&
+        CudfLocalPartition::shouldReplace(localPartitionPlanNode);
+    if (!canRun) {
+      LOG_FALLBACK(
+          "LocalPartitionAdapter {}, PlanNode id: {}",
+          !canHandle(op) ? "operator is not LocalPartition"
+              : !localPartitionPlanNode
+              ? "planNode is not LocalPartitionNode"
+              : "CudfLocalPartition::shouldReplace returned false",
+          planNode->id());
+    }
+    return canRun;
+  }
+
+  bool acceptsGpuInput() const override {
+    return true;
+  }
+
+  bool producesGpuOutput() const override {
+    return false;
+  }
+
+  std::vector<std::unique_ptr<exec::Operator>> createReplacements(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* ctx,
+      int32_t operatorId) const override {
+    auto localPartitionPlanNode =
+        std::dynamic_pointer_cast<const core::LocalPartitionNode>(planNode);
+
+    std::vector<std::unique_ptr<exec::Operator>> result;
+    result.push_back(
+        std::make_unique<CudfLocalPartition>(
+            operatorId, ctx, localPartitionPlanNode));
+    return result;
+  }
+
+  bool keepOperator() const override {
+    return false;
+  }
+};
+
+/// LocalExchangeAdapter - Keeps original operator
+class LocalExchangeAdapter : public OperatorAdapter {
+ public:
+  LocalExchangeAdapter() : OperatorAdapter("LocalExchange") {}
+
+  bool canHandle(const exec::Operator* op) const override {
+    return dynamic_cast<const exec::LocalExchange*>(op) != nullptr;
+  }
+
+  bool canRunOnGPU(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& /*planNode*/,
+      exec::DriverCtx* /*ctx*/) const override {
+    return true;
+  }
+
+  bool acceptsGpuInput() const override {
+    return false;
+  }
+
+  bool producesGpuOutput() const override {
+    return true;
+  }
+
+  std::vector<std::unique_ptr<exec::Operator>> createReplacements(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& /*planNode*/,
+      exec::DriverCtx* /*ctx*/,
+      int32_t /*operatorId*/) const override {
+    return {}; // Keep original operator
+  }
+
+  bool keepOperator() const override {
+    return true;
+  }
+};
+
+/// AssignUniqueIdAdapter - Replaces with CudfAssignUniqueId
+class AssignUniqueIdAdapter : public OperatorAdapter {
+ public:
+  AssignUniqueIdAdapter() : OperatorAdapter("AssignUniqueId") {}
+
+  bool canHandle(const exec::Operator* op) const override {
+    return dynamic_cast<const exec::AssignUniqueId*>(op) != nullptr;
+  }
+
+  bool canRunOnGPU(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* /*ctx*/) const override {
+    return std::dynamic_pointer_cast<const core::AssignUniqueIdNode>(
+               planNode) != nullptr;
+  }
+
+  bool acceptsGpuInput() const override {
+    return true;
+  }
+
+  bool producesGpuOutput() const override {
+    return true;
+  }
+
+  std::vector<std::unique_ptr<exec::Operator>> createReplacements(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* ctx,
+      int32_t operatorId) const override {
+    auto assignUniqueIdPlanNode =
+        std::dynamic_pointer_cast<const core::AssignUniqueIdNode>(planNode);
+
+    std::vector<std::unique_ptr<exec::Operator>> result;
+    result.push_back(
+        std::make_unique<CudfAssignUniqueId>(
+            operatorId,
+            ctx,
+            assignUniqueIdPlanNode,
+            assignUniqueIdPlanNode->taskUniqueId(),
+            assignUniqueIdPlanNode->uniqueIdCounter()));
+    return result;
+  }
+};
+
+/// ValuesAdapter - Keeps original operator
+class ValuesAdapter : public OperatorAdapter {
+ public:
+  ValuesAdapter() : OperatorAdapter("Values") {}
+
+  bool canHandle(const exec::Operator* op) const override {
+    return dynamic_cast<const exec::Values*>(op) != nullptr;
+  }
+
+  bool canRunOnGPU(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* /*ctx*/) const override {
+    LOG_FALLBACK(
+        "Values operator not supported on cuDF, PlanNode id: {}",
+        planNode->id());
+    return false;
+  }
+
+  bool acceptsGpuInput() const override {
+    return false;
+  }
+
+  bool producesGpuOutput() const override {
+    return false;
+  }
+
+  std::vector<std::unique_ptr<exec::Operator>> createReplacements(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& /*planNode*/,
+      exec::DriverCtx* /*ctx*/,
+      int32_t /*operatorId*/) const override {
+    return {}; // Keep original operator
+  }
+
+  bool keepOperator() const override {
+    return true;
+  }
+};
+
+/// MarkDistinctAdapter - Replaces with CudfMarkDistinct
+class MarkDistinctAdapter : public OperatorAdapter {
+ public:
+  MarkDistinctAdapter() : OperatorAdapter("MarkDistinct") {}
+
+  bool canHandle(const exec::Operator* op) const override {
+    return dynamic_cast<const exec::MarkDistinct*>(op) != nullptr;
+  }
+
+  bool canRunOnGPU(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* /*ctx*/) const override {
+    return std::dynamic_pointer_cast<const core::MarkDistinctNode>(planNode) !=
+        nullptr;
+  }
+
+  bool acceptsGpuInput() const override {
+    return true;
+  }
+
+  bool producesGpuOutput() const override {
+    return true;
+  }
+
+  std::vector<std::unique_ptr<exec::Operator>> createReplacements(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* ctx,
+      int32_t operatorId) const override {
+    auto markDistinctPlanNode =
+        std::dynamic_pointer_cast<const core::MarkDistinctNode>(planNode);
+
+    std::vector<std::unique_ptr<exec::Operator>> result;
+    result.push_back(
+        std::make_unique<CudfMarkDistinct>(
+            operatorId, ctx, markDistinctPlanNode));
+    return result;
+  }
+};
+
+/// EnforceSingleRowAdapter - Replaces with CudfEnforceSingleRow
+class EnforceSingleRowAdapter : public OperatorAdapter {
+ public:
+  EnforceSingleRowAdapter() : OperatorAdapter("EnforceSingleRow") {}
+
+  bool canHandle(const exec::Operator* op) const override {
+    return dynamic_cast<const exec::EnforceSingleRow*>(op) != nullptr;
+  }
+
+  bool canRunOnGPU(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* /*ctx*/) const override {
+    return std::dynamic_pointer_cast<const core::EnforceSingleRowNode>(
+               planNode) != nullptr;
+  }
+
+  bool acceptsGpuInput() const override {
+    return true;
+  }
+
+  bool producesGpuOutput() const override {
+    return true;
+  }
+
+  std::vector<std::unique_ptr<exec::Operator>> createReplacements(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* ctx,
+      int32_t operatorId) const override {
+    auto enforceSingleRowPlanNode =
+        std::dynamic_pointer_cast<const core::EnforceSingleRowNode>(planNode);
+
+    std::vector<std::unique_ptr<exec::Operator>> result;
+    result.push_back(
+        std::make_unique<CudfEnforceSingleRow>(
+            operatorId, ctx, enforceSingleRowPlanNode));
+    return result;
+  }
+};
+
+/// CallbackSinkAdapter - Keeps original operator
+class CallbackSinkAdapter : public OperatorAdapter {
+ public:
+  CallbackSinkAdapter() : OperatorAdapter("CallbackSink") {}
+
+  bool canHandle(const exec::Operator* op) const override {
+    return dynamic_cast<const exec::CallbackSink*>(op) != nullptr;
+  }
+
+  bool canRunOnGPU(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* /*ctx*/) const override {
+    LOG_FALLBACK(
+        "CallbackSink operator not supported on cuDF, PlanNode id: {}",
+        planNode->id());
+    return false;
+  }
+
+  bool acceptsGpuInput() const override {
+    return false;
+  }
+
+  bool producesGpuOutput() const override {
+    return false;
+  }
+
+  std::vector<std::unique_ptr<exec::Operator>> createReplacements(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& /*planNode*/,
+      exec::DriverCtx* /*ctx*/,
+      int32_t /*operatorId*/) const override {
+    return {}; // Keep original operator
+  }
+
+  bool keepOperator() const override {
+    return true;
+  }
+};
+
+/// GroupIdAdapter - Replaces with CudfGroupId
+class GroupIdAdapter : public OperatorAdapter {
+ public:
+  GroupIdAdapter() : OperatorAdapter("GroupId") {}
+
+  bool canHandle(const exec::Operator* op) const override {
+    return dynamic_cast<const exec::GroupId*>(op) != nullptr;
+  }
+
+  bool canRunOnGPU(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* /*ctx*/) const override {
+    return std::dynamic_pointer_cast<const core::GroupIdNode>(planNode) !=
+        nullptr;
+  }
+
+  bool acceptsGpuInput() const override {
+    return true;
+  }
+
+  bool producesGpuOutput() const override {
+    return true;
+  }
+
+  std::vector<std::unique_ptr<exec::Operator>> createReplacements(
+      const exec::Operator* /*op*/,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* ctx,
+      int32_t operatorId) const override {
+    auto groupIdNode =
+        std::dynamic_pointer_cast<const core::GroupIdNode>(planNode);
+    VELOX_CHECK_NOT_NULL(groupIdNode);
+
+    std::vector<std::unique_ptr<exec::Operator>> result;
+    result.push_back(
+        std::make_unique<CudfGroupId>(operatorId, ctx, groupIdNode));
+    return result;
+  }
+};
+
+/// Registration Function
+void registerAllOperatorAdapters() {
+  auto& registry = OperatorAdapterRegistry::getInstance();
+
+  // Clear any existing adapters
+  registry.clear();
+
+  // Register all adapters
+  registry.registerAdapter(std::make_unique<TableScanAdapter>());
+  registry.registerAdapter(std::make_unique<FilterProjectAdapter>());
+  registry.registerAdapter(std::make_unique<AggregationAdapter>());
+  registry.registerAdapter(std::make_unique<HashJoinBuildAdapter>());
+  registry.registerAdapter(std::make_unique<HashJoinProbeAdapter>());
+  registry.registerAdapter(std::make_unique<NestedLoopJoinBuildAdapter>());
+  registry.registerAdapter(std::make_unique<NestedLoopJoinProbeAdapter>());
+  registry.registerAdapter(std::make_unique<OrderByAdapter>());
+  registry.registerAdapter(std::make_unique<TopNAdapter>());
+  registry.registerAdapter(std::make_unique<LimitAdapter>());
+  registry.registerAdapter(std::make_unique<LocalPartitionAdapter>());
+  registry.registerAdapter(std::make_unique<LocalExchangeAdapter>());
+  registry.registerAdapter(std::make_unique<AssignUniqueIdAdapter>());
+  registry.registerAdapter(std::make_unique<MarkDistinctAdapter>());
+  registry.registerAdapter(std::make_unique<EnforceSingleRowAdapter>());
+  registry.registerAdapter(std::make_unique<GroupIdAdapter>());
+  registry.registerAdapter(std::make_unique<ValuesAdapter>());
+  registry.registerAdapter(std::make_unique<CallbackSinkAdapter>());
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/OperatorAdapters.h b/velox/experimental/cudf/exec/OperatorAdapters.h
new file mode 100644
index 00000000000..656d7bf2680
--- /dev/null
+++ b/velox/experimental/cudf/exec/OperatorAdapters.h
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/core/PlanNode.h"
+#include "velox/exec/Driver.h"
+#include "velox/exec/Operator.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace facebook::velox::cudf_velox {
+
+/// Base interface for operator adapters that handle GPU operator
+/// replacement.
+///
+/// Each adapter is responsible for:
+/// - Determining if it can handle a specific operator type
+/// - Checking if the operator is supported for GPU execution
+/// - Creating GPU replacement operators
+/// - Providing metadata about GPU input/output capabilities
+class OperatorAdapter {
+ public:
+  explicit OperatorAdapter(std::string name) : name_(std::move(name)) {}
+  virtual ~OperatorAdapter() = default;
+
+  /// Check if this adapter can handle the given operator type. Returns true
+  /// if this adapter handles this operator type.
+  virtual bool canHandle(const exec::Operator* op) const = 0;
+
+  /// Check if the operator is supported for GPU execution. Returns true if
+  /// the operator can be executed on GPU.
+  virtual bool canRunOnGPU(
+      const exec::Operator* op,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* ctx) const = 0;
+
+  /// Check if this operator accepts GPU input. Returns true if the operator
+  /// can accept GPU vectors as input.
+  virtual bool acceptsGpuInput() const = 0;
+
+  /// Check if this operator produces GPU output. Returns true if the operator
+  /// produces GPU vectors as output.
+  virtual bool producesGpuOutput() const = 0;
+
+  /// Bundled GPU capability properties for an operator.
+  struct Properties {
+    bool canRunOnGPU = false;
+    bool acceptsGpuInput = false;
+    bool producesGpuOutput = false;
+  };
+
+  /// Query all GPU capability properties at once for the given operator.
+  /// acceptsGpuInput and producesGpuOutput are AND-gated with canRunOnGPU.
+  Properties properties(
+      const exec::Operator* op,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* ctx) const {
+    Properties props;
+    props.canRunOnGPU = canRunOnGPU(op, planNode, ctx);
+    props.acceptsGpuInput = props.canRunOnGPU && acceptsGpuInput();
+    props.producesGpuOutput = props.canRunOnGPU && producesGpuOutput();
+    return props;
+  }
+
+  /// Create replacement GPU operator(s). Returns a vector of replacement
+  /// operators (empty if operator should be kept).
+  virtual std::vector<std::unique_ptr<exec::Operator>> createReplacements(
+      const exec::Operator* op,
+      const core::PlanNodePtr& planNode,
+      exec::DriverCtx* ctx,
+      int32_t operatorId) const = 0;
+
+  /// Check if the original operator should be kept (not replaced). Returns
+  /// true if the original operator should be kept, false otherwise.
+  virtual bool keepOperator() const {
+    return false;
+  }
+
+  /// Get the name of this adapter for debugging.
+  const std::string& name() const {
+    return name_;
+  }
+
+ private:
+  const std::string name_;
+};
+
+/// Registry for operator adapters.
+///
+/// Manages the collection of operator adapters and provides lookup
+/// functionality to find the appropriate adapter for a given operator.
+class OperatorAdapterRegistry {
+ public:
+  /// Get the singleton instance of the registry.
+  static OperatorAdapterRegistry& getInstance();
+
+  /// Register an adapter with the registry.
+  void registerAdapter(std::unique_ptr<OperatorAdapter> adapter);
+
+  /// Find an adapter that can handle the given operator. Returns a pointer
+  /// to the adapter, or nullptr if none found.
+  const OperatorAdapter* findAdapter(const exec::Operator* op) const;
+
+  /// Get all registered adapters.
+  const std::vector<std::unique_ptr<OperatorAdapter>>& getAdapters() const;
+
+  /// Clear all registered adapters.
+  void clear();
+
+ private:
+  OperatorAdapterRegistry() = default;
+  std::vector<std::unique_ptr<OperatorAdapter>> adapters_;
+};
+
+/// Register all operator adapters.
+///
+/// This function should be called from registerCudf() to register all
+/// operator adapters with the registry.
+void registerAllOperatorAdapters();
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/PrestoAggregateFunctions.cpp b/velox/experimental/cudf/exec/PrestoAggregateFunctions.cpp
new file mode 100644
index 00000000000..316ecfd7e9e
--- /dev/null
+++ b/velox/experimental/cudf/exec/PrestoAggregateFunctions.cpp
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/exec/AggregationRegistry.h"
+#include "velox/experimental/cudf/exec/PrestoAggregateFunctions.h"
+
+#include "velox/expression/FunctionSignature.h"
+
+namespace facebook::velox::cudf_velox {
+
+void registerPrestoAggregateFunctions(const std::string& prefix) {
+  using exec::FunctionSignatureBuilder;
+
+  unregisterAggregateFunctions();
+  registerCommonAggregationFunctions(getGroupbyAggregationRegistry(), prefix);
+  registerCommonAggregationFunctions(getReduceAggregationRegistry(), prefix);
+  registerGroupbyOnlyAggregationFunctions(
+      getGroupbyAggregationRegistry(), prefix);
+  registerReduceOnlyAggregationFunctions(
+      getReduceAggregationRegistry(), prefix);
+
+  // Presto (default): SUM(REAL) -> REAL, AVG(REAL) -> REAL.
+  appendGroupbyAggregationFunctionForStep(
+      prefix + "sum",
+      core::AggregationNode::Step::kSingle,
+      FunctionSignatureBuilder()
+          .returnType("real")
+          .argumentType("real")
+          .build());
+  appendReduceAggregationFunctionForStep(
+      prefix + "sum",
+      core::AggregationNode::Step::kSingle,
+      FunctionSignatureBuilder()
+          .returnType("real")
+          .argumentType("real")
+          .build());
+  appendGroupbyAggregationFunctionForStep(
+      prefix + "sum",
+      core::AggregationNode::Step::kPartial,
+      FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("real")
+          .build());
+  appendReduceAggregationFunctionForStep(
+      prefix + "sum",
+      core::AggregationNode::Step::kPartial,
+      FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("real")
+          .build());
+  appendGroupbyAggregationFunctionForStep(
+      prefix + "sum",
+      core::AggregationNode::Step::kFinal,
+      FunctionSignatureBuilder()
+          .returnType("real")
+          .argumentType("double")
+          .build());
+  appendReduceAggregationFunctionForStep(
+      prefix + "sum",
+      core::AggregationNode::Step::kFinal,
+      FunctionSignatureBuilder()
+          .returnType("real")
+          .argumentType("double")
+          .build());
+  appendGroupbyAggregationFunctionForStep(
+      prefix + "sum",
+      core::AggregationNode::Step::kIntermediate,
+      FunctionSignatureBuilder()
+          .returnType("real")
+          .argumentType("double")
+          .build());
+  appendReduceAggregationFunctionForStep(
+      prefix + "sum",
+      core::AggregationNode::Step::kIntermediate,
+      FunctionSignatureBuilder()
+          .returnType("real")
+          .argumentType("double")
+          .build());
+
+  appendGroupbyAggregationFunctionForStep(
+      prefix + "avg",
+      core::AggregationNode::Step::kSingle,
+      FunctionSignatureBuilder()
+          .returnType("real")
+          .argumentType("real")
+          .build());
+  appendReduceAggregationFunctionForStep(
+      prefix + "avg",
+      core::AggregationNode::Step::kSingle,
+      FunctionSignatureBuilder()
+          .returnType("real")
+          .argumentType("real")
+          .build());
+  appendGroupbyAggregationFunctionForStep(
+      prefix + "avg",
+      core::AggregationNode::Step::kFinal,
+      FunctionSignatureBuilder()
+          .returnType("real")
+          .argumentType("row(double,bigint)")
+          .build());
+  appendReduceAggregationFunctionForStep(
+      prefix + "avg",
+      core::AggregationNode::Step::kFinal,
+      FunctionSignatureBuilder()
+          .returnType("real")
+          .argumentType("row(double,bigint)")
+          .build());
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/PrestoAggregateFunctions.h b/velox/experimental/cudf/exec/PrestoAggregateFunctions.h
new file mode 100644
index 00000000000..b84b0a2ea9a
--- /dev/null
+++ b/velox/experimental/cudf/exec/PrestoAggregateFunctions.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace facebook::velox::cudf_velox {
+
+/// Rebuild current aggregation registries with Presto-specific signatures.
+/// \param prefix Function name prefix (e.g., "presto." or "")
+void registerPrestoAggregateFunctions(const std::string& prefix);
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/SparkAggregateFunctions.cpp b/velox/experimental/cudf/exec/SparkAggregateFunctions.cpp
new file mode 100644
index 00000000000..7794e003e3b
--- /dev/null
+++ b/velox/experimental/cudf/exec/SparkAggregateFunctions.cpp
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/exec/AggregationRegistry.h"
+#include "velox/experimental/cudf/exec/SparkAggregateFunctions.h"
+
+#include "velox/expression/FunctionSignature.h"
+
+namespace facebook::velox::cudf_velox {
+
+void registerSparkAggregateFunctions(const std::string& prefix) {
+  using exec::FunctionSignatureBuilder;
+
+  unregisterAggregateFunctions();
+  registerCommonAggregationFunctions(getGroupbyAggregationRegistry(), prefix);
+  registerCommonAggregationFunctions(getReduceAggregationRegistry(), prefix);
+  registerGroupbyOnlyAggregationFunctions(
+      getGroupbyAggregationRegistry(), prefix);
+  registerReduceOnlyAggregationFunctions(
+      getReduceAggregationRegistry(), prefix);
+
+  // Spark: SUM(REAL) -> DOUBLE, AVG(REAL) -> DOUBLE
+  appendGroupbyAggregationFunctionForStep(
+      prefix + "sum",
+      core::AggregationNode::Step::kSingle,
+      FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("real")
+          .build());
+  appendReduceAggregationFunctionForStep(
+      prefix + "sum",
+      core::AggregationNode::Step::kSingle,
+      FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("real")
+          .build());
+  appendGroupbyAggregationFunctionForStep(
+      prefix + "sum",
+      core::AggregationNode::Step::kPartial,
+      FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("real")
+          .build());
+  appendReduceAggregationFunctionForStep(
+      prefix + "sum",
+      core::AggregationNode::Step::kPartial,
+      FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("real")
+          .build());
+  // SUM final/intermediate: DOUBLE->DOUBLE already registered.
+
+  appendGroupbyAggregationFunctionForStep(
+      prefix + "avg",
+      core::AggregationNode::Step::kSingle,
+      FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("real")
+          .build());
+  appendReduceAggregationFunctionForStep(
+      prefix + "avg",
+      core::AggregationNode::Step::kSingle,
+      FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("real")
+          .build());
+  // AVG final: row(DOUBLE,BIGINT)->DOUBLE already registered.
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/SparkAggregateFunctions.h b/velox/experimental/cudf/exec/SparkAggregateFunctions.h
new file mode 100644
index 00000000000..c9cc7957076
--- /dev/null
+++ b/velox/experimental/cudf/exec/SparkAggregateFunctions.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace facebook::velox::cudf_velox {
+
+/// Rebuild current aggregation registries with Spark-specific signatures.
+/// \param prefix Function name prefix (e.g., "spark." or "")
+void registerSparkAggregateFunctions(const std::string& prefix);
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/ToCudf.cpp b/velox/experimental/cudf/exec/ToCudf.cpp
index 789854fd41d..5672500e105 100644
--- a/velox/experimental/cudf/exec/ToCudf.cpp
+++ b/velox/experimental/cudf/exec/ToCudf.cpp
@@ -14,40 +14,36 @@
  * limitations under the License.
  */
 
-#include "velox/experimental/cudf/connectors/hive/CudfHiveConnector.h"
-#include "velox/experimental/cudf/connectors/hive/CudfHiveDataSource.h"
+#include "velox/experimental/cudf/CudfConfig.h"
 #include "velox/experimental/cudf/exec/CudfConversion.h"
-#include "velox/experimental/cudf/exec/CudfFilterProject.h"
-#include "velox/experimental/cudf/exec/CudfHashAggregation.h"
+#include "velox/experimental/cudf/exec/CudfGroupby.h"
 #include "velox/experimental/cudf/exec/CudfHashJoin.h"
-#include "velox/experimental/cudf/exec/CudfLimit.h"
-#include "velox/experimental/cudf/exec/CudfLocalPartition.h"
+#include "velox/experimental/cudf/exec/CudfNestedLoopJoin.h"
+#include "velox/experimental/cudf/exec/CudfOperator.h"
 #include "velox/experimental/cudf/exec/CudfOrderBy.h"
-#include "velox/experimental/cudf/exec/ExpressionEvaluator.h"
+#include "velox/experimental/cudf/exec/CudfReduce.h"
+#include "velox/experimental/cudf/exec/CudfTopN.h"
+#include "velox/experimental/cudf/exec/GpuResources.h"
+#include "velox/experimental/cudf/exec/OperatorAdapters.h"
+#include "velox/experimental/cudf/exec/PrestoAggregateFunctions.h"
 #include "velox/experimental/cudf/exec/ToCudf.h"
-#include "velox/experimental/cudf/exec/Utilities.h"
+#include "velox/experimental/cudf/expression/AstExpression.h"
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
+#include "velox/experimental/cudf/expression/JitExpression.h"
 
-#include "velox/connectors/hive/HiveConnector.h"
-#include "velox/connectors/hive/TableHandle.h"
+#include "folly/Conv.h"
 #include "velox/exec/Driver.h"
-#include "velox/exec/FilterProject.h"
-#include "velox/exec/HashAggregation.h"
-#include "velox/exec/HashBuild.h"
-#include "velox/exec/HashProbe.h"
-#include "velox/exec/Limit.h"
 #include "velox/exec/Operator.h"
-#include "velox/exec/OrderBy.h"
-#include "velox/exec/TableScan.h"
+#include "velox/exec/Values.h"
 
 #include <cudf/detail/nvtx/ranges.hpp>
+#include <cudf/utilities/memory_resource.hpp>
 
 #include <cuda.h>
 
 #include <iostream>
 
-DEFINE_bool(velox_cudf_enabled, true, "Enable cuDF-Velox acceleration");
-DEFINE_string(velox_cudf_memory_resource, "async", "Memory resource for cuDF");
-DEFINE_bool(velox_cudf_debug, false, "Enable debug printing");
+static const std::string kCudfAdapterName = "cuDF";
 
 namespace facebook::velox::cudf_velox {
 
@@ -60,127 +56,75 @@ bool isAnyOf(const Base* p) {
 
 } // namespace
 
-bool CompileState::compile() {
+core::PlanNodePtr CompileState::getPlanNode(const core::PlanNodeId& id) const {
+  auto& nodes = driverFactory_.planNodes;
+  auto it = std::find_if(nodes.cbegin(), nodes.cend(), [&id](const auto& node) {
+    return node->id() == id;
+  });
+  if (it != nodes.end()) {
+    return *it;
+  }
+  VELOX_CHECK(driverFactory_.consumerNode->id() == id);
+  return driverFactory_.consumerNode;
+}
+
+bool CompileState::compile(bool allowCpuFallback) {
   auto operators = driver_.operators();
 
-  if (FLAGS_velox_cudf_debug) {
-    std::cout << "Operators before adapting for cuDF: count ["
-              << operators.size() << "]" << std::endl;
-    for (auto& op : operators) {
-      std::cout << "  Operator: ID " << op->operatorId() << ": "
-                << op->toString() << std::endl;
+  // Cache debug flag to avoid repeated getInstance() calls
+  const bool debugEnabled = CudfConfig::getInstance().debugEnabled;
+
+  // Cache "before" operator descriptions so we can print before/after together.
+  std::vector<std::pair<int32_t, std::string>> beforeOperators;
+  if (debugEnabled) {
+    for (const auto& op : operators) {
+      beforeOperators.emplace_back(op->operatorId(), op->toString());
     }
   }
 
-  // Make sure operator states are initialized.  We will need to inspect some of
-  // them during the transformation.
-  driver_.initializeOperators();
-
   bool replacementsMade = false;
   auto ctx = driver_.driverCtx();
 
-  // Get plan node by id lookup.
-  auto getPlanNode = [&](const core::PlanNodeId& id) {
-    auto& nodes = driverFactory_.planNodes;
-    auto it =
-        std::find_if(nodes.cbegin(), nodes.cend(), [&id](const auto& node) {
-          return node->id() == id;
-        });
-    if (it != nodes.end()) {
-      return *it;
-    }
-    VELOX_CHECK(driverFactory_.consumerNode->id() == id);
-    return driverFactory_.consumerNode;
+  // Helper to check if planNodeId is valid (some operators like CallbackSink
+  // have "N/A")
+  auto isValidPlanNodeId = [](const core::PlanNodeId& id) {
+    return !id.empty() && id != "N/A";
   };
 
-  auto isTableScanSupported = [getPlanNode](const exec::Operator* op) {
-    if (!isAnyOf<exec::TableScan>(op)) {
-      return false;
-    }
-    auto tableScanNode = std::dynamic_pointer_cast<const core::TableScanNode>(
-        getPlanNode(op->planNodeId()));
-    VELOX_CHECK(tableScanNode != nullptr);
-    auto const& connector = velox::connector::getConnector(
-        tableScanNode->tableHandle()->connectorId());
-    auto cudfHiveConnector = std::dynamic_pointer_cast<
-        facebook::velox::cudf_velox::connector::hive::CudfHiveConnector>(
-        connector);
-    if (!cudfHiveConnector) {
-      return false;
-    }
-    // TODO (dm): we need to ask CudfHiveConnector whether this table handle is
-    // supported by it. It may choose to produce a HiveDatasource.
-    return true;
-  };
+  // Use adapter registry for GPU Operator Replacement
+  auto& registry = OperatorAdapterRegistry::getInstance();
 
-  auto isFilterProjectSupported = [](const exec::Operator* op) {
-    if (auto filterProjectOp = dynamic_cast<const exec::FilterProject*>(op)) {
-      auto info = filterProjectOp->exprsAndProjection();
-      return ExpressionEvaluator::canBeEvaluated(info.exprs->exprs());
-    }
-    return false;
+  // Cached operator properties including adapter pointer.
+  struct OperatorProperties : OperatorAdapter::Properties {
+    const OperatorAdapter* adapter = nullptr;
   };
 
-  auto isJoinSupported = [getPlanNode](const exec::Operator* op) {
-    if (!isAnyOf<exec::HashBuild, exec::HashProbe>(op)) {
-      return false;
-    }
-    auto planNode = std::dynamic_pointer_cast<const core::HashJoinNode>(
-        getPlanNode(op->planNodeId()));
-    if (!planNode) {
-      return false;
-    }
-    if (!CudfHashJoinProbe::isSupportedJoinType(planNode->joinType())) {
-      return false;
-    }
-    // disabling null-aware anti join with filter until we implement it right
-    if (planNode->joinType() == core::JoinType::kAnti and
-        planNode->isNullAware() and planNode->filter()) {
-      return false;
-    }
-    return true;
-  };
-
-  auto isSupportedGpuOperator =
-      [isFilterProjectSupported, isJoinSupported, isTableScanSupported](
-          const exec::Operator* op) {
-        return isAnyOf<
-                   exec::OrderBy,
-                   exec::HashAggregation,
-                   exec::Limit,
-                   exec::LocalPartition,
-                   exec::LocalExchange>(op) ||
-            isFilterProjectSupported(op) || isJoinSupported(op) ||
-            isTableScanSupported(op);
+  auto getOperatorProperties =
+      [&registry, this, &isValidPlanNodeId, ctx](const exec::Operator* op) {
+        OperatorProperties props;
+        auto adapter = registry.findAdapter(op);
+        props.adapter = adapter;
+        if (adapter && isValidPlanNodeId(op->planNodeId())) {
+          static_cast<OperatorAdapter::Properties&>(props) =
+              adapter->properties(op, getPlanNode(op->planNodeId()), ctx);
+        }
+        if (isAnyOf<CudfOperator>(op)) {
+          // CudfOperator is always fully GPU compatible
+          // (runs on GPU, accepts GPU input, produces GPU output).
+          props.canRunOnGPU = true;
+          props.acceptsGpuInput = true;
+          props.producesGpuOutput = true;
+        }
+        return props;
       };
 
-  std::vector<bool> isSupportedGpuOperators(operators.size());
+  // caching operator properties
+  std::vector<OperatorProperties> opProps(operators.size());
   std::transform(
       operators.begin(),
       operators.end(),
-      isSupportedGpuOperators.begin(),
-      isSupportedGpuOperator);
-  auto acceptsGpuInput = [isFilterProjectSupported,
-                          isJoinSupported](const exec::Operator* op) {
-    return isAnyOf<
-               exec::OrderBy,
-               exec::HashAggregation,
-               exec::Limit,
-               exec::LocalPartition>(op) ||
-        isFilterProjectSupported(op) || isJoinSupported(op);
-  };
-  auto producesGpuOutput = [isFilterProjectSupported,
-                            isJoinSupported,
-                            isTableScanSupported](const exec::Operator* op) {
-    return isAnyOf<
-               exec::OrderBy,
-               exec::HashAggregation,
-               exec::Limit,
-               exec::LocalExchange>(op) ||
-        isFilterProjectSupported(op) ||
-        (isAnyOf<exec::HashProbe>(op) && isJoinSupported(op)) ||
-        (isTableScanSupported(op));
-  };
+      opProps.begin(),
+      getOperatorProperties);
 
   int32_t operatorsOffset = 0;
   for (int32_t operatorIndex = 0; operatorIndex < operators.size();
@@ -190,21 +134,28 @@ bool CompileState::compile() {
     exec::Operator* oper = operators[operatorIndex];
     auto replacingOperatorIndex = operatorIndex + operatorsOffset;
     VELOX_CHECK(oper);
+    const auto& thisOpProps =
+        opProps[operatorIndex]; // cached operator properties
 
     const bool previousOperatorIsNotGpu =
-        (operatorIndex > 0 and !isSupportedGpuOperators[operatorIndex - 1]);
-    const bool nextOperatorIsNotGpu =
-        (operatorIndex < operators.size() - 1 and
-         !isSupportedGpuOperators[operatorIndex + 1]);
+        operatorIndex > 0 and !opProps[operatorIndex - 1].producesGpuOutput;
+    const bool nextOperatorIsNotGpu = (operatorIndex < operators.size() - 1) and
+        !opProps[operatorIndex + 1].acceptsGpuInput;
     const bool isLastOperatorOfTask =
         driverFactory_.outputDriver and operatorIndex == operators.size() - 1;
 
     auto id = oper->operatorId();
-    if (previousOperatorIsNotGpu and acceptsGpuInput(oper)) {
-      auto planNode = getPlanNode(oper->planNodeId());
-      replaceOp.push_back(std::make_unique<CudfFromVelox>(
-          id, planNode->outputType(), ctx, planNode->id() + "-from-velox"));
-      replaceOp.back()->initialize();
+
+    // Cache planNode for this operator (avoid multiple lookups)
+    core::PlanNodePtr planNode = nullptr;
+    if (isValidPlanNodeId(oper->planNodeId())) {
+      planNode = getPlanNode(oper->planNodeId());
+    }
+
+    if (previousOperatorIsNotGpu and thisOpProps.acceptsGpuInput and planNode) {
+      replaceOp.push_back(
+          std::make_unique<CudfFromVelox>(
+              id, planNode->outputType(), ctx, planNode->id() + "-from-velox"));
     }
     if (not replaceOp.empty()) {
       // from-velox only, because need to inserted before current operator.
@@ -219,92 +170,75 @@ bool CompileState::compile() {
       replacementsMade = true;
     }
 
-    // This is used to denote if the current operator is kept or replaced.
-    auto keepOperator = 0;
-    // TableScan
-    if (isTableScanSupported(oper)) {
-      auto planNode = std::dynamic_pointer_cast<const core::TableScanNode>(
-          getPlanNode(oper->planNodeId()));
-      VELOX_CHECK(planNode != nullptr);
-      keepOperator = 1;
-    } else if (isJoinSupported(oper)) {
-      if (auto joinBuildOp = dynamic_cast<exec::HashBuild*>(oper)) {
-        auto planNode = std::dynamic_pointer_cast<const core::HashJoinNode>(
-            getPlanNode(joinBuildOp->planNodeId()));
-        VELOX_CHECK(planNode != nullptr);
-        // From-Velox (optional)
-        replaceOp.push_back(
-            std::make_unique<CudfHashJoinBuild>(id, ctx, planNode));
-        replaceOp.back()->initialize();
-      } else if (auto joinProbeOp = dynamic_cast<exec::HashProbe*>(oper)) {
-        auto planNode = std::dynamic_pointer_cast<const core::HashJoinNode>(
-            getPlanNode(joinProbeOp->planNodeId()));
-        VELOX_CHECK(planNode != nullptr);
-        // From-Velox (optional)
-        replaceOp.push_back(
-            std::make_unique<CudfHashJoinProbe>(id, ctx, planNode));
-        replaceOp.back()->initialize();
-        // To-Velox (optional)
+    // Use adapter registry to handle operator replacement
+    auto keepOperator = 1; // Default: keep original
+    const auto& adapter = thisOpProps.adapter;
+    bool isPureCpuOperator = true;
+
+    if (adapter) {
+      keepOperator = adapter->keepOperator();
+      if (keepOperator == 0) {
+        if (planNode && thisOpProps.canRunOnGPU) {
+          auto replacements =
+              adapter->createReplacements(oper, planNode, ctx, id);
+          for (auto& r : replacements) {
+            replaceOp.push_back(std::move(r));
+          }
+          isPureCpuOperator = false;
+        } else {
+          // This is the CPU fallback case.
+          isPureCpuOperator = true;
+        }
+      } else {
+        // adapter is present and keepOperator is 1, so this is GPU compatible
+        // operator. so this CPU operators is allowed even if fallback is
+        // disabled.
+        isPureCpuOperator = false;
       }
-    } else if (auto orderByOp = dynamic_cast<exec::OrderBy*>(oper)) {
-      auto id = orderByOp->operatorId();
-      auto planNode = std::dynamic_pointer_cast<const core::OrderByNode>(
-          getPlanNode(orderByOp->planNodeId()));
-      VELOX_CHECK(planNode != nullptr);
-      replaceOp.push_back(std::make_unique<CudfOrderBy>(id, ctx, planNode));
-      replaceOp.back()->initialize();
-    } else if (auto hashAggOp = dynamic_cast<exec::HashAggregation*>(oper)) {
-      auto planNode = std::dynamic_pointer_cast<const core::AggregationNode>(
-          getPlanNode(hashAggOp->planNodeId()));
-      VELOX_CHECK(planNode != nullptr);
-      replaceOp.push_back(
-          std::make_unique<CudfHashAggregation>(id, ctx, planNode));
-      replaceOp.back()->initialize();
-    } else if (isFilterProjectSupported(oper)) {
-      auto filterProjectOp = dynamic_cast<exec::FilterProject*>(oper);
-      auto info = filterProjectOp->exprsAndProjection();
-      auto& idProjections = filterProjectOp->identityProjections();
-      auto projectPlanNode = std::dynamic_pointer_cast<const core::ProjectNode>(
-          getPlanNode(filterProjectOp->planNodeId()));
-      auto filterPlanNode = std::dynamic_pointer_cast<const core::FilterNode>(
-          getPlanNode(filterProjectOp->planNodeId()));
-      // If filter only, filter node only exists.
-      // If project only, or filter and project, project node only exists.
-      VELOX_CHECK(projectPlanNode != nullptr or filterPlanNode != nullptr);
-      replaceOp.push_back(std::make_unique<CudfFilterProject>(
-          id, ctx, info, idProjections, filterPlanNode, projectPlanNode));
-      replaceOp.back()->initialize();
-    } else if (auto limitOp = dynamic_cast<exec::Limit*>(oper)) {
-      auto planNode = std::dynamic_pointer_cast<const core::LimitNode>(
-          getPlanNode(limitOp->planNodeId()));
-      VELOX_CHECK(planNode != nullptr);
-      replaceOp.push_back(std::make_unique<CudfLimit>(id, ctx, planNode));
-      replaceOp.back()->initialize();
-    } else if (
-        auto localPartitionOp = dynamic_cast<exec::LocalPartition*>(oper)) {
-      auto planNode = std::dynamic_pointer_cast<const core::LocalPartitionNode>(
-          getPlanNode(localPartitionOp->planNodeId()));
-      VELOX_CHECK(planNode != nullptr);
-      if (CudfLocalPartition::shouldReplace(planNode)) {
-        replaceOp.push_back(
-            std::make_unique<CudfLocalPartition>(id, ctx, planNode));
-        replaceOp.back()->initialize();
+    } else {
+      // special case for CudfOperator
+      if (isAnyOf<CudfOperator>(oper)) {
+        isPureCpuOperator = false;
       } else {
-        // Round Robin batch-wise Partitioning is supported by CPU operator with
-        // GPU Vector.
-        keepOperator = 1;
+        // CPU operator without adapter
+        isPureCpuOperator = true;
       }
-    } else if (
-        auto localExchangeOp = dynamic_cast<exec::LocalExchange*>(oper)) {
-      keepOperator = 1;
     }
 
-    if (producesGpuOutput(oper) and
-        (nextOperatorIsNotGpu or isLastOperatorOfTask)) {
+    if (thisOpProps.producesGpuOutput and
+        (nextOperatorIsNotGpu or isLastOperatorOfTask) and planNode) {
+      replaceOp.push_back(
+          std::make_unique<CudfToVelox>(
+              id, planNode->outputType(), ctx, planNode->id() + "-to-velox"));
+    }
+
+    if (debugEnabled) {
+      VLOG(1) << "Operator: ID " << oper->operatorId() << ": "
+              << oper->toString() << ", keepOperator = " << keepOperator
+              << ", isPureCpuOperator = " << isPureCpuOperator
+              << ", replaceOp.size() = " << replaceOp.size()
+              << ", previousOperatorIsNotGpu = " << previousOperatorIsNotGpu
+              << ", nextOperatorIsNotGpu = " << nextOperatorIsNotGpu
+              << ", isLastOperatorOfTask = " << isLastOperatorOfTask
+              << ", canRunOnGPU[" << operatorIndex
+              << "] = " << thisOpProps.canRunOnGPU << ", acceptsGpuInput["
+              << operatorIndex << "] = " << thisOpProps.acceptsGpuInput
+              << ", producesGpuOutput[" << operatorIndex
+              << "] = " << thisOpProps.producesGpuOutput
+              << ", planNode = " << bool(planNode);
+    }
+    if (!allowCpuFallback) {
+      // condition is if GPU replacement success or if CPU operators itself is
+      // GPU compatible. or if specific CPU operator is allowed even when
+      // fallback is disabled.
+      VELOX_CHECK(!isPureCpuOperator, "Replacement with cuDF operator failed");
+    } else if (isPureCpuOperator) {
+      LOG(WARNING)
+          << "Replacement with cuDF operator failed. Falling back to CPU execution";
+      LOG(WARNING) << "Replacement Failed Operator: " << oper->toString();
       auto planNode = getPlanNode(oper->planNodeId());
-      replaceOp.push_back(std::make_unique<CudfToVelox>(
-          id, planNode->outputType(), ctx, planNode->id() + "-to-velox"));
-      replaceOp.back()->initialize();
+      LOG(WARNING) << "Replacement Failed PlanNode: "
+                   << planNode->toString(true, false);
     }
 
     if (not replaceOp.empty()) {
@@ -319,13 +253,21 @@ bool CompileState::compile() {
     }
   }
 
-  if (FLAGS_velox_cudf_debug) {
+  if (debugEnabled) {
+    // Print before/after together for easy comparison.
+    LOG(INFO) << "Operators " << "before adapting for cuDF"
+              << ": count [" << beforeOperators.size() << "]";
+    for (const auto& [id, desc] : beforeOperators) {
+      LOG(INFO) << "  Operator: ID " << id << ": " << desc;
+    }
+    LOG(INFO) << "allowCpuFallback = " << allowCpuFallback;
+
     operators = driver_.operators();
-    std::cout << "Operators after adapting for cuDF: count ["
-              << operators.size() << "]" << std::endl;
-    for (auto& op : operators) {
-      std::cout << "  Operator: ID " << op->operatorId() << ": "
-                << op->toString() << std::endl;
+    LOG(INFO) << "Operators " << "after adapting for cuDF"
+              << ": count [" << operators.size() << "]";
+    for (const auto& op : operators) {
+      LOG(INFO) << "  Operator: ID " << op->operatorId() << ": "
+                << op->toString();
     }
   }
 
@@ -333,47 +275,82 @@ bool CompileState::compile() {
 }
 
 struct CudfDriverAdapter {
-  std::shared_ptr<rmm::mr::device_memory_resource> mr_;
-
-  CudfDriverAdapter(std::shared_ptr<rmm::mr::device_memory_resource> mr)
-      : mr_(mr) {}
+  CudfDriverAdapter(bool allowCpuFallback)
+      : allowCpuFallback_{allowCpuFallback} {}
 
   // Call operator needed by DriverAdapter
   bool operator()(const exec::DriverFactory& factory, exec::Driver& driver) {
+    if (!driver.driverCtx()->queryConfig().get<bool>(
+            CudfConfig::kCudfEnabled, CudfConfig::getInstance().enabled) &&
+        allowCpuFallback_) {
+      return false;
+    }
     auto state = CompileState(factory, driver);
-    auto res = state.compile();
+    auto res = state.compile(allowCpuFallback_);
     return res;
   }
+
+ private:
+  bool allowCpuFallback_;
 };
 
 static bool isCudfRegistered = false;
 
-void registerCudf(const CudfOptions& options) {
+bool cudfIsRegistered() {
+  return isCudfRegistered;
+}
+
+void registerCudf() {
   if (cudfIsRegistered()) {
     return;
   }
-  if (!options.cudfEnabled) {
-    return;
-  }
 
-  registerBuiltinFunctions(options.prefix());
+  // Register operator adapters
+  registerAllOperatorAdapters();
+
+  auto prefix = CudfConfig::getInstance().functionNamePrefix;
+  registerBuiltinFunctions(prefix);
+  registerPrestoAggregateFunctions(prefix);
 
   CUDF_FUNC_RANGE();
   cudaFree(nullptr); // Initialize CUDA context at startup
 
-  const std::string mrMode = options.cudfMemoryResource;
-  auto mr = cudf_velox::createMemoryResource(mrMode, options.memoryPercent);
-  cudf::set_current_device_resource(mr.get());
+  const std::string mrMode = CudfConfig::getInstance().memoryResource;
+  auto mr = cudf_velox::createMemoryResource(
+      mrMode, CudfConfig::getInstance().memoryPercent);
+  cudf::set_current_device_resource(mr);
+  mr_ = std::move(mr);
+
+  const auto& outputMrMode = CudfConfig::getInstance().outputMemoryResource;
+  if (!outputMrMode.empty() && outputMrMode != mrMode) {
+    output_mr_ = cudf_velox::createMemoryResource(
+        outputMrMode, CudfConfig::getInstance().memoryPercent);
+  } else {
+    output_mr_ = mr_;
+  }
 
   exec::Operator::registerOperator(
       std::make_unique<CudfHashJoinBridgeTranslator>());
-  CudfDriverAdapter cda{mr};
+  exec::Operator::registerOperator(
+      std::make_unique<CudfNestedLoopJoinBridgeTranslator>());
+  CudfDriverAdapter cda{CudfConfig::getInstance().allowCpuFallback};
   exec::DriverAdapter cudfAdapter{kCudfAdapterName, {}, cda};
   exec::DriverFactory::registerAdapter(cudfAdapter);
+
+  if (CudfConfig::getInstance().astExpressionEnabled) {
+    registerAstEvaluator(CudfConfig::getInstance().astExpressionPriority);
+  }
+
+  if (CudfConfig::getInstance().jitExpressionEnabled) {
+    registerJitEvaluator(CudfConfig::getInstance().jitExpressionPriority);
+  }
+
   isCudfRegistered = true;
 }
 
 void unregisterCudf() {
+  output_mr_.reset();
+  mr_.reset();
   exec::DriverFactory::adapters.erase(
       std::remove_if(
           exec::DriverFactory::adapters.begin(),
@@ -386,12 +363,77 @@ void unregisterCudf() {
   isCudfRegistered = false;
 }
 
-bool cudfIsRegistered() {
-  return isCudfRegistered;
+CudfConfig& CudfConfig::getInstance() {
+  static CudfConfig instance;
+  return instance;
 }
 
-bool cudfDebugEnabled() {
-  return FLAGS_velox_cudf_debug;
+void CudfConfig::initialize(
+    std::unordered_map<std::string, std::string>&& config) {
+  if (config.find(kCudfEnabled) != config.end()) {
+    enabled = folly::to<bool>(config[kCudfEnabled]);
+  }
+  if (config.find(kCudfDebugEnabled) != config.end()) {
+    debugEnabled = folly::to<bool>(config[kCudfDebugEnabled]);
+  }
+  if (config.find(kCudfMemoryResource) != config.end()) {
+    memoryResource = config[kCudfMemoryResource];
+  }
+  if (config.find(kCudfMemoryPercent) != config.end()) {
+    memoryPercent = folly::to<int32_t>(config[kCudfMemoryPercent]);
+  }
+  if (config.find(kCudfOutputMr) != config.end()) {
+    outputMemoryResource = config[kCudfOutputMr];
+  }
+  if (config.find(kCudfBatchSizeMinThreshold) != config.end()) {
+    batchSizeMinThreshold =
+        folly::to<int32_t>(config[kCudfBatchSizeMinThreshold]);
+  }
+  if (config.find(kCudfBatchSizeMaxThreshold) != config.end()) {
+    batchSizeMaxThreshold =
+        folly::to<int32_t>(config[kCudfBatchSizeMaxThreshold]);
+  }
+  if (config.find(kCudfConcatOptimizationEnabled) != config.end()) {
+    concatOptimizationEnabled =
+        folly::to<bool>(config[kCudfConcatOptimizationEnabled]);
+  }
+  if (config.find(kCudfFunctionNamePrefix) != config.end()) {
+    functionNamePrefix = config[kCudfFunctionNamePrefix];
+  }
+  if (config.find(kCudfAstExpressionEnabled) != config.end()) {
+    astExpressionEnabled = folly::to<bool>(config[kCudfAstExpressionEnabled]);
+  }
+  if (config.find(kCudfJitExpressionEnabled) != config.end()) {
+    jitExpressionEnabled = folly::to<bool>(config[kCudfJitExpressionEnabled]);
+  }
+  if (config.find(kCudfAstExpressionPriority) != config.end()) {
+    astExpressionPriority =
+        folly::to<int32_t>(config[kCudfAstExpressionPriority]);
+  }
+  if (config.find(kCudfAllowCpuFallback) != config.end()) {
+    allowCpuFallback = folly::to<bool>(config[kCudfAllowCpuFallback]);
+  }
+  if (config.find(kCudfLogFallback) != config.end()) {
+    logFallback = folly::to<bool>(config[kCudfLogFallback]);
+  }
+  if (config.find(kCudfTopNBatchSize) != config.end()) {
+    topNBatchSize = folly::to<int32_t>(config[kCudfTopNBatchSize]);
+  }
+  if (config.find(kCudfTimestampUnit) != config.end()) {
+    const auto& unit = config[kCudfTimestampUnit];
+    if (unit == "s") {
+      timestampUnit = cudf::type_id::TIMESTAMP_SECONDS;
+    } else if (unit == "ms") {
+      timestampUnit = cudf::type_id::TIMESTAMP_MILLISECONDS;
+    } else if (unit == "us") {
+      timestampUnit = cudf::type_id::TIMESTAMP_MICROSECONDS;
+    } else if (unit == "ns") {
+      timestampUnit = cudf::type_id::TIMESTAMP_NANOSECONDS;
+    } else {
+      VELOX_FAIL(
+          "Invalid timestamp unit: {}. Valid values are: s, ms, us, ns", unit);
+    }
+  }
 }
 
 } // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/ToCudf.h b/velox/experimental/cudf/exec/ToCudf.h
index 612ae1e3255..1184bf4dd9e 100644
--- a/velox/experimental/cudf/exec/ToCudf.h
+++ b/velox/experimental/cudf/exec/ToCudf.h
@@ -19,16 +19,8 @@
 #include "velox/exec/Driver.h"
 #include "velox/exec/Operator.h"
 
-#include <gflags/gflags.h>
-
-DECLARE_bool(velox_cudf_enabled);
-DECLARE_string(velox_cudf_memory_resource);
-DECLARE_bool(velox_cudf_debug);
-
 namespace facebook::velox::cudf_velox {
 
-static const std::string kCudfAdapterName = "cuDF";
-
 class CompileState {
  public:
   CompileState(const exec::DriverFactory& driverFactory, exec::Driver& driver)
@@ -38,56 +30,22 @@ class CompileState {
     return driver_;
   }
 
+  // Get plan node by id lookup.
+  core::PlanNodePtr getPlanNode(const core::PlanNodeId& id) const;
+
   // Replaces sequences of Operators in the Driver given at construction with
   // cuDF equivalents. Returns true if the Driver was changed.
-  bool compile();
+  bool compile(bool allow_cpu_fallback);
 
   const exec::DriverFactory& driverFactory_;
   exec::Driver& driver_;
 };
 
-class CudfOptions {
- public:
-  static CudfOptions& getInstance() {
-    static CudfOptions instance;
-    return instance;
-  }
-
-  void setPrefix(const std::string& prefix) {
-    prefix_ = prefix;
-  }
-
-  const std::string& prefix() const {
-    return prefix_;
-  }
-
-  const bool cudfEnabled;
-  const std::string cudfMemoryResource;
-  // The initial percent of GPU memory to allocate for memory resource for one
-  // thread.
-  int memoryPercent;
-
- private:
-  CudfOptions()
-      : cudfEnabled(FLAGS_velox_cudf_enabled),
-        cudfMemoryResource(FLAGS_velox_cudf_memory_resource),
-        memoryPercent(50),
-        prefix_("") {}
-  CudfOptions(const CudfOptions&) = delete;
-  CudfOptions& operator=(const CudfOptions&) = delete;
-  std::string prefix_;
-};
-
 /// Registers adapter to add cuDF operators to Drivers.
-void registerCudf(const CudfOptions& options = CudfOptions::getInstance());
+void registerCudf();
 void unregisterCudf();
 
 /// Returns true if cuDF is registered.
 bool cudfIsRegistered();
 
-/**
- * @brief Returns true if the velox_cudf_debug flag is set to true.
- */
-bool cudfDebugEnabled();
-
 } // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/Utilities.cpp b/velox/experimental/cudf/exec/Utilities.cpp
index fe8678e3ec3..3f0f00c3ff6 100644
--- a/velox/experimental/cudf/exec/Utilities.cpp
+++ b/velox/experimental/cudf/exec/Utilities.cpp
@@ -14,87 +14,24 @@
  * limitations under the License.
  */
 
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/CudfNoDefaults.h"
 #include "velox/experimental/cudf/exec/Utilities.h"
+#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
 
+#include <cudf/column/column_factories.hpp>
 #include <cudf/concatenate.hpp>
 #include <cudf/detail/utilities/stream_pool.hpp>
-#include <cudf/utilities/default_stream.hpp>
-#include <cudf/utilities/error.hpp>
 #include <cudf/utilities/memory_resource.hpp>
 
-#include <rmm/mr/device/arena_memory_resource.hpp>
-#include <rmm/mr/device/cuda_async_memory_resource.hpp>
-#include <rmm/mr/device/cuda_memory_resource.hpp>
-#include <rmm/mr/device/device_memory_resource.hpp>
-#include <rmm/mr/device/managed_memory_resource.hpp>
-#include <rmm/mr/device/owning_wrapper.hpp>
-#include <rmm/mr/device/pool_memory_resource.hpp>
-
-#include <common/base/Exceptions.h>
-
-#include <cstdlib>
-#include <memory>
-#include <string_view>
+#include <limits>
 
 namespace facebook::velox::cudf_velox {
 
-namespace {
-[[nodiscard]] auto makeCudaMr() {
-  return std::make_shared<rmm::mr::cuda_memory_resource>();
-}
-
-[[nodiscard]] auto makePoolMr(int percent) {
-  return rmm::mr::make_owning_wrapper<rmm::mr::pool_memory_resource>(
-      makeCudaMr(), rmm::percent_of_free_device_memory(percent));
-}
-
-[[nodiscard]] auto makeAsyncMr(int percent) {
-  return std::make_shared<rmm::mr::cuda_async_memory_resource>(
-      rmm::percent_of_free_device_memory(percent));
-}
-
-[[nodiscard]] auto makeManagedMr() {
-  return std::make_shared<rmm::mr::managed_memory_resource>();
-}
-
-[[nodiscard]] auto makeArenaMr(int percent) {
-  return rmm::mr::make_owning_wrapper<rmm::mr::arena_memory_resource>(
-      makeCudaMr(), rmm::percent_of_free_device_memory(percent));
-}
-
-[[nodiscard]] auto makeManagedPoolMr(int percent) {
-  return rmm::mr::make_owning_wrapper<rmm::mr::pool_memory_resource>(
-      makeManagedMr(), rmm::percent_of_free_device_memory(percent));
-}
-} // namespace
-
-std::shared_ptr<rmm::mr::device_memory_resource> createMemoryResource(
-    std::string_view mode,
-    int percent) {
-  if (mode == "cuda")
-    return makeCudaMr();
-  if (mode == "pool")
-    return makePoolMr(percent);
-  if (mode == "async")
-    return makeAsyncMr(percent);
-  if (mode == "arena")
-    return makeArenaMr(percent);
-  if (mode == "managed")
-    return makeManagedMr();
-  if (mode == "managed_pool")
-    return makeManagedPoolMr(percent);
-  VELOX_FAIL(
-      "Unknown memory resource mode: " + std::string(mode) +
-      "\nExpecting: cuda, pool, async, arena, managed, or managed_pool");
-}
-
-cudf::detail::cuda_stream_pool& cudfGlobalStreamPool() {
-  return cudf::detail::global_cuda_stream_pool();
-};
-
 std::unique_ptr<cudf::table> concatenateTables(
     std::vector<std::unique_ptr<cudf::table>> tables,
-    rmm::cuda_stream_view stream) {
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
   // Check for empty vector
   VELOX_CHECK_GT(tables.size(), 0);
 
@@ -108,15 +45,41 @@ std::unique_ptr<cudf::table> concatenateTables(
       tables.end(),
       std::back_inserter(tableViews),
       [&](const auto& tbl) { return tbl->view(); });
-  return cudf::concatenate(
-      tableViews, stream, cudf::get_current_device_resource_ref());
+  return cudf::concatenate(tableViews, stream, mr);
+}
+
+std::unique_ptr<cudf::table> makeEmptyTable(TypePtr const& inputType) {
+  std::vector<std::unique_ptr<cudf::column>> emptyColumns;
+  for (size_t i = 0; i < inputType->size(); ++i) {
+    if (auto const& childType = inputType->childAt(i);
+        childType->kind() == TypeKind::ROW) {
+      auto tbl = makeEmptyTable(childType);
+      auto structColumn = std::make_unique<cudf::column>(
+          cudf::data_type(cudf::type_id::STRUCT),
+          0,
+          rmm::device_buffer(),
+          rmm::device_buffer(),
+          0,
+          tbl->release());
+      emptyColumns.push_back(std::move(structColumn));
+    } else {
+      auto emptyColumn = cudf::make_empty_column(
+          cudf_velox::veloxToCudfDataType(inputType->childAt(i)));
+      emptyColumns.push_back(std::move(emptyColumn));
+    }
+  }
+  return std::make_unique<cudf::table>(std::move(emptyColumns));
 }
 
 std::unique_ptr<cudf::table> getConcatenatedTable(
-    std::vector<CudfVectorPtr>& tables,
-    rmm::cuda_stream_view stream) {
+    std::vector<CudfVectorPtr>&& tables,
+    const TypePtr& tableType,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
   // Check for empty vector
-  VELOX_CHECK_GT(tables.size(), 0);
+  if (tables.size() == 0) {
+    return makeEmptyTable(tableType);
+  }
 
   auto inputStreams = std::vector<rmm::cuda_stream_view>();
   auto tableViews = std::vector<cudf::table_view>();
@@ -132,14 +95,125 @@ std::unique_ptr<cudf::table> getConcatenatedTable(
 
   cudf::detail::join_streams(inputStreams, stream);
 
-  if (tables.size() == 1) {
-    return tables[0]->release();
+  // Even for a single input table we must concatenate (copy) rather than
+  // release in-place: the output is owned by `stream` but the input buffer was
+  // allocated on a different stream, so releasing it would bind deallocation to
+  // the wrong stream.
+  auto output = cudf::concatenate(tableViews, stream, mr);
+
+  // Order input deallocations after the concatenate read.
+  // Since memory resources are stream-ordered, deallocations
+  // on inputStreams will be ordered after the concatenate completes.
+  CudaEvent event(cudaEventDisableTiming);
+  streamsWaitForStream(event, inputStreams, stream);
+  // Input tables are deallocated here when 'tables' goes out of scope.
+  return output;
+}
+
+std::vector<std::unique_ptr<cudf::table>> getConcatenatedTableBatched(
+    std::vector<CudfVectorPtr>&& tables,
+    const TypePtr& tableType,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  std::vector<std::unique_ptr<cudf::table>> concatTables;
+  // Check for empty vector
+  if (tables.size() == 0) {
+    concatTables.push_back(makeEmptyTable(tableType));
+    return concatTables;
   }
 
-  auto output = cudf::concatenate(
-      tableViews, stream, cudf::get_current_device_resource_ref());
-  stream.synchronize();
-  return output;
+  auto inputStreams = std::vector<rmm::cuda_stream_view>();
+  auto tableViews = std::vector<cudf::table_view>();
+
+  inputStreams.reserve(tables.size());
+  tableViews.reserve(tables.size());
+
+  for (const auto& table : tables) {
+    VELOX_CHECK_NOT_NULL(table);
+    tableViews.push_back(table->getTableView());
+    inputStreams.push_back(table->stream());
+  }
+
+  cudf::detail::join_streams(inputStreams, stream);
+
+  std::vector<std::unique_ptr<cudf::table>> outputTables;
+  const auto& cudfConfig = CudfConfig::getInstance();
+  auto const maxRows = cudfConfig.batchSizeMaxThreshold
+      ? static_cast<size_t>(cudfConfig.batchSizeMaxThreshold.value())
+      : static_cast<size_t>(std::numeric_limits<cudf::size_type>::max());
+  size_t startpos = 0;
+  size_t runningRows = 0;
+  for (size_t i = 0; i < tableViews.size(); ++i) {
+    auto const numRows = static_cast<size_t>(tableViews[i].num_rows());
+    // If adding this table would exceed the limit, flush current batch
+    // [startpos, i).
+    if (runningRows > 0 && runningRows + numRows > maxRows) {
+      outputTables.push_back(
+          cudf::concatenate(
+              std::vector<cudf::table_view>(
+                  tableViews.begin() + startpos, tableViews.begin() + i),
+              stream,
+              mr));
+      startpos = i;
+      runningRows = 0;
+    }
+    runningRows += numRows;
+  }
+  // Flush the final batch [startpos, end).
+  if (startpos < tableViews.size()) {
+    outputTables.push_back(
+        cudf::concatenate(
+            std::vector<cudf::table_view>(
+                tableViews.begin() + startpos, tableViews.end()),
+            stream,
+            mr));
+  }
+  // Order input deallocations after the concatenate reads by making all input
+  // streams wait for the output stream.
+  // Since memory resources are stream-ordered, deallocations
+  // on inputStreams will be ordered after the concatenate completes.
+  CudaEvent event(cudaEventDisableTiming);
+  streamsWaitForStream(event, inputStreams, stream);
+
+  // Input tables are deallocated here when 'tables' goes out of scope.
+  return outputTables;
+}
+
+void streamsWaitForStream(
+    CudaEvent& event,
+    const std::vector<rmm::cuda_stream_view>& streams,
+    rmm::cuda_stream_view stream) {
+  event.recordFrom(stream);
+  for (const auto& strm : streams) {
+    event.waitOn(strm);
+  }
+}
+
+CudaEvent::CudaEvent(unsigned int flags) {
+  cudaEvent_t ev{};
+  CUDF_CUDA_TRY(cudaEventCreateWithFlags(&ev, flags));
+  event_ = ev;
+}
+
+CudaEvent::~CudaEvent() {
+  if (event_ != nullptr) {
+    cudaEventDestroy(event_);
+    event_ = nullptr;
+  }
+}
+
+CudaEvent::CudaEvent(CudaEvent&& other) noexcept : event_(other.event_) {
+  other.event_ = nullptr;
+}
+
+const CudaEvent& CudaEvent::recordFrom(rmm::cuda_stream_view stream) const {
+  CUDF_CUDA_TRY(cudaEventRecord(event_, stream.value()));
+  return *this;
+}
+
+const CudaEvent& CudaEvent::waitOn(rmm::cuda_stream_view stream) const {
+  CUDF_CUDA_TRY(cudaStreamWaitEvent(stream.value(), event_, 0));
+  return *this;
 }
 
 } // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/Utilities.h b/velox/experimental/cudf/exec/Utilities.h
index d1cd239af45..c609c9a996e 100644
--- a/velox/experimental/cudf/exec/Utilities.h
+++ b/velox/experimental/cudf/exec/Utilities.h
@@ -18,41 +18,166 @@
 
 #include "velox/experimental/cudf/vector/CudfVector.h"
 
-#include <cudf/detail/utilities/stream_pool.hpp>
 #include <cudf/table/table.hpp>
 
-#include <rmm/mr/device/device_memory_resource.hpp>
+#include <rmm/cuda_stream_view.hpp>
 
 #include <memory>
-#include <string_view>
 
 namespace facebook::velox::cudf_velox {
 
+// Concatenate a vector of cuDF tables into a single table
+[[nodiscard]] std::unique_ptr<cudf::table> concatenateTables(
+    std::vector<std::unique_ptr<cudf::table>> tables,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr);
+
 /**
- * @brief Creates a memory resource based on the given mode.
+ * @brief Concatenates multiple CudfVectors into a single cudf::table.
+ *
+ * This function concatenates a vector of CudfVectors into a single cudf::table.
+ * It handles stream synchronization by joining all input streams on the
+ * provided output stream before concatenation. After concatenation, input
+ * streams wait for the output stream to ensure safe deallocation.
  *
- * @param mode rmm::mr::pool_memory_resource mode.
- * @param percent The initial percent of GPU memory to allocate for memory
- * resource.
+ * The input tables are consumed and deallocated when the function returns.
+ * If the input vector is empty, returns an empty table matching tableType.
+ *
+ * @param tables Input vector of CudfVectors to concatenate (consumed during
+ * operation)
+ * @param tableType Velox type representation for creating empty tables when
+ * needed
+ * @param stream CUDA stream for concatenation and memory management
+ * @param mr Memory resource for output allocation
+ * @return Single concatenated table
  */
-[[nodiscard]] std::shared_ptr<rmm::mr::device_memory_resource>
-createMemoryResource(std::string_view mode, int percent);
+[[nodiscard]] std::unique_ptr<cudf::table> getConcatenatedTable(
+    std::vector<CudfVectorPtr>&& tables,
+    const TypePtr& tableType,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr);
 
 /**
- * @brief Returns the global CUDA stream pool used by cudf.
+ * @brief Concatenates multiple CUDF tables with automatic batching based on
+ * size limits.
+ *
+ * This function concatenates a vector of CUDF tables while respecting size
+ * limits imposed by cudf::size_type i.e. 32-bit signed integer. Unlike
+ * getConcatenatedTable that returns a single concatenated table, this batched
+ * version splits the concatenation into multiple output tables when the total
+ * number of rows would exceeds ~2.1 billion, the maximum value representable by
+ * cudf::size_type
+ *
+ * The function is stream-safe and handles proper stream synchronization. All
+ * input streams from individual tables are collected and joined on the provided
+ * output stream. Tables that may have been created on different CUDA streams
+ * are also properly synchronized. The input tables are consumed and deallocated
+ * after synchronization.
+ *
+ * @param tables Input vector of CUDF tables to concatenate (consumed during
+ * operation)
+ * @param tableType Velox type representation for creating empty tables when
+ * needed
+ * @param stream CUDA stream for asynchronous operations and memory management
+ * @return Vector of concatenated tables (multiple if input exceeded size
+ * limits)
+ *
  */
-[[nodiscard]] cudf::detail::cuda_stream_pool& cudfGlobalStreamPool();
+[[nodiscard]] std::vector<std::unique_ptr<cudf::table>>
+getConcatenatedTableBatched(
+    std::vector<CudfVectorPtr>&& tables,
+    const TypePtr& tableType,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr);
 
-// Concatenate a vector of cuDF tables into a single table
-[[nodiscard]] std::unique_ptr<cudf::table> concatenateTables(
-    std::vector<std::unique_ptr<cudf::table>> tables,
-    rmm::cuda_stream_view stream);
+/**
+ * @brief Wrapper for CUDA events used for stream synchronization.
+ *
+ * CudaEvent provides a safe, move-only wrapper around cudaEvent_t that
+ * automatically manages the event lifecycle.
+ *
+ * @note This class is non-copyable but move-constructible, ensuring exclusive
+ * ownership of the underlying CUDA event.
+ *
+ * Example usage:
+ * @code
+ *   // Create an event
+ *   CudaEvent event;
+ *
+ *   // Record the event on stream1 after some work
+ *   // ... launch kernels on stream1 ...
+ *   event.recordFrom(stream1);
+ *
+ *   // Make stream2 wait for the event before proceeding
+ *   event.waitOn(stream2);
+ *   // ... launch kernels on stream2 (will wait for stream1 to reach event) ...
+ * @endcode
+ */
+class CudaEvent {
+ public:
+  /**
+   * @brief Constructs a CUDA event with the specified flags.
+   *
+   * @param flags Optional flags for event creation (default: 0).
+   *              Common flags include:
+   *              - cudaEventDefault: Default event creation flag
+   *              - cudaEventBlockingSync: Use blocking synchronization
+   *              - cudaEventDisableTiming: Event will not record timing data
+   *              - cudaEventInterprocess: Event may be used for interprocess
+   *
+   * @throws May throw if CUDA event creation fails
+   */
+  explicit CudaEvent(unsigned int flags = 0);
 
-// Concatenate a vector of cuDF tables into a single table.
-// This function joins the streams owned by individual tables on the passed
-// stream. Inputs are not safe to use after calling this function.
-[[nodiscard]] std::unique_ptr<cudf::table> getConcatenatedTable(
-    std::vector<CudfVectorPtr>& tables,
-    rmm::cuda_stream_view stream);
+  ~CudaEvent();
+
+  CudaEvent(const CudaEvent&) = delete;
+
+  CudaEvent& operator=(const CudaEvent&) = delete;
+
+  CudaEvent(CudaEvent&& other) noexcept;
 
+  /**
+   * @brief Records this event in the specified CUDA stream.
+   *
+   * The event will be recorded after all previously issued operations in the
+   * stream have completed. This does not block the host thread or the stream.
+   *
+   * @param stream The CUDA stream in which to record the event
+   * @return Reference to this CudaEvent for method chaining
+   */
+  const CudaEvent& recordFrom(rmm::cuda_stream_view stream) const;
+
+  /**
+   * @brief Makes the specified stream wait until this event has been recorded.
+   *
+   * All future operations in the specified stream will wait until this event
+   * has been recorded (i.e., all operations before the recordFrom() call have
+   * completed). This enables synchronization between different CUDA streams
+   * without blocking the host thread.
+   *
+   * @param stream The CUDA stream that should wait for this event
+   * @return Reference to this CudaEvent for method chaining
+   */
+  const CudaEvent& waitOn(rmm::cuda_stream_view stream) const;
+
+ private:
+  cudaEvent_t event_{};
+};
+
+/**
+ * @brief Makes all target streams wait for a source stream's pending work.
+ *
+ * Records an event on @p stream, then makes each stream in @p streams wait
+ * for that event. This is useful when multiple streams hold resources that
+ * must not be freed until work on @p stream has completed.
+ *
+ * @param event   A reusable CudaEvent (avoids per-call creation overhead)
+ * @param streams The streams that should wait
+ * @param stream  The stream whose pending work must complete first
+ */
+void streamsWaitForStream(
+    CudaEvent& event,
+    const std::vector<rmm::cuda_stream_view>& streams,
+    rmm::cuda_stream_view stream);
 } // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/Validation.h b/velox/experimental/cudf/exec/Validation.h
new file mode 100644
index 00000000000..d5ac57d666f
--- /dev/null
+++ b/velox/experimental/cudf/exec/Validation.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/experimental/cudf/CudfConfig.h"
+
+#include "velox/common/base/ExceptionHelper.h"
+
+namespace facebook::velox::cudf_velox {
+
+/// Log a reason for falling back to Velox CPU execution if
+/// CudfConfig::getInstance().logFallback is enabled. It captures the
+/// file name, line number, function name, and reason for the failure. The
+/// validation failure introduces extra data format conversion which can
+/// negatively impact the performance, so log the messgage to notify the
+/// important reason.
+///
+/// Usage:
+///
+/// LOG_FALLBACK("Sort merge join");
+/// LOG_FALLBACK(functionName);
+/// LOG_FALLBACK("Cast from {} to {}", fromType->toString(),
+/// toType->toString());
+#define LOG_FALLBACK(...)                                                                                \
+  do {                                                                                                   \
+    if (CudfConfig::getInstance().logFallback) {                                                         \
+      auto message = ::facebook::velox::errorMessage(__VA_ARGS__);                                       \
+      LOG(WARNING) << fmt::format(                                                                       \
+          "Validation failed at function: {}, reason: Operation is not supported in cuDF execution: {}", \
+          __FUNCTION__,                                                                                  \
+          message);                                                                                      \
+    }                                                                                                    \
+  } while (0)
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/VeloxCudfInterop.cpp b/velox/experimental/cudf/exec/VeloxCudfInterop.cpp
index 6f6529b0d81..0a73bfcf34c 100644
--- a/velox/experimental/cudf/exec/VeloxCudfInterop.cpp
+++ b/velox/experimental/cudf/exec/VeloxCudfInterop.cpp
@@ -14,7 +14,8 @@
  * limitations under the License.
  */
 
-#include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/CudfNoDefaults.h"
 #include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
 
 #include "velox/common/memory/Memory.h"
@@ -34,59 +35,87 @@
 #include <arrow/io/interfaces.h>
 #include <arrow/table.h>
 
+#include <cstdlib>
+#include <cstring>
+
 namespace facebook::velox::cudf_velox {
 
 cudf::type_id veloxToCudfTypeId(const TypePtr& type) {
+  // Legacy helper retained for compatibility. Note: returning cudf::type_id
+  // discards decimal scale; prefer veloxToCudfDataType when scale matters.
+  return veloxToCudfDataType(type).id();
+}
+
+cudf::data_type veloxToCudfDataType(const TypePtr& type) {
   switch (type->kind()) {
     case TypeKind::BOOLEAN:
-      return cudf::type_id::BOOL8;
+      return cudf::data_type{cudf::type_id::BOOL8};
     case TypeKind::TINYINT:
-      return cudf::type_id::INT8;
+      return cudf::data_type{cudf::type_id::INT8};
     case TypeKind::SMALLINT:
-      return cudf::type_id::INT16;
+      return cudf::data_type{cudf::type_id::INT16};
     case TypeKind::INTEGER:
       // TODO: handle interval types (durations?)
       // if (type->isIntervalYearMonth()) {
       //   return cudf::type_id::...;
       // }
       if (type->isDate()) {
-        return cudf::type_id::TIMESTAMP_DAYS;
+        return cudf::data_type{cudf::type_id::TIMESTAMP_DAYS};
       }
-      return cudf::type_id::INT32;
+      return cudf::data_type{cudf::type_id::INT32};
     case TypeKind::BIGINT:
-      return cudf::type_id::INT64;
+      // BIGINT is used for both INT64 and DECIMAL64
+      if (type->isDecimal()) {
+        auto const decimalType =
+            std::dynamic_pointer_cast<const ShortDecimalType>(type);
+        VELOX_CHECK(decimalType, "Invalid Decimal Type (failed dynamic_cast)");
+        auto const cudfScale = numeric::scale_type{-decimalType->scale()};
+        return cudf::data_type{cudf::type_id::DECIMAL64, cudfScale};
+      }
+      return cudf::data_type{cudf::type_id::INT64};
+    case TypeKind::HUGEINT: {
+      // HUGEINT is used only for DECIMAL128
+      // per facebookincubator/velox PR 4434 (May 2, 2023)
+      // although see commented-out HUGEINT -> DURATION_DAYS below
+      VELOX_CHECK(
+          type->isDecimal(), "HUGEINT should only be used for DECIMAL128");
+      auto const decimalType =
+          std::dynamic_pointer_cast<const LongDecimalType>(type);
+      VELOX_CHECK(decimalType, "Invalid Decimal Type (failed dynamic_cast)");
+      auto const cudfScale = numeric::scale_type{-decimalType->scale()};
+      return cudf::data_type{cudf::type_id::DECIMAL128, cudfScale};
+    }
     case TypeKind::REAL:
-      return cudf::type_id::FLOAT32;
+      return cudf::data_type{cudf::type_id::FLOAT32};
     case TypeKind::DOUBLE:
-      return cudf::type_id::FLOAT64;
+      return cudf::data_type{cudf::type_id::FLOAT64};
     case TypeKind::VARCHAR:
-      return cudf::type_id::STRING;
+      return cudf::data_type{cudf::type_id::STRING};
     case TypeKind::VARBINARY:
-      return cudf::type_id::STRING;
+      return cudf::data_type{cudf::type_id::STRING};
     case TypeKind::TIMESTAMP:
-      return cudf::type_id::TIMESTAMP_NANOSECONDS;
+      return cudf::data_type{CudfConfig::getInstance().timestampUnit};
     // case TypeKind::HUGEINT: return cudf::type_id::DURATION_DAYS;
     // TODO: DATE was converted to a logical type:
     // https://github.com/facebookincubator/velox/commit/e480f5c03a6c47897ef4488bd56918a89719f908
     // case TypeKind::DATE: return cudf::type_id::DURATION_DAYS;
     // case TypeKind::INTERVAL_DAY_TIME: return cudf::type_id::EMPTY;
-    // TODO: Decimals are now logical types:
-    // https://github.com/facebookincubator/velox/commit/73d2f935b55f084d30557c7be94b9768efb8e56f
-    // case TypeKind::SHORT_DECIMAL: return cudf::type_id::DECIMAL64;
-    // case TypeKind::LONG_DECIMAL: return cudf::type_id::DECIMAL128;
     case TypeKind::ARRAY:
-      return cudf::type_id::LIST;
-    // case TypeKind::MAP: return cudf::type_id::EMPTY;
+      return cudf::data_type{cudf::type_id::LIST};
     case TypeKind::ROW:
-      return cudf::type_id::STRUCT;
+      return cudf::data_type{cudf::type_id::STRUCT};
+    // case TypeKind::MAP: return cudf::type_id::EMPTY;
     // case TypeKind::UNKNOWN: return cudf::type_id::EMPTY;
     // case TypeKind::FUNCTION: return cudf::type_id::EMPTY;
     // case TypeKind::OPAQUE: return cudf::type_id::EMPTY;
     // case TypeKind::INVALID: return cudf::type_id::EMPTY;
     default:
-      CUDF_FAIL("Unsupported Velox type: " + mapTypeKindToName(type->kind()));
-      return cudf::type_id::EMPTY;
+      break;
   }
+  CUDF_FAIL(
+      "Unsupported Velox type: " +
+      std::string(TypeKindName::toName(type->kind())));
+  return cudf::data_type{cudf::type_id::EMPTY};
 }
 
 namespace with_arrow {
@@ -94,10 +123,36 @@ namespace with_arrow {
 std::unique_ptr<cudf::table> toCudfTable(
     const facebook::velox::RowVectorPtr& veloxTable,
     facebook::velox::memory::MemoryPool* pool,
-    rmm::cuda_stream_view stream) {
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr,
+    std::optional<std::string> timestampTimeZone) {
+  TimestampUnit unit;
+  switch (CudfConfig::getInstance().timestampUnit) {
+    case cudf::type_id::TIMESTAMP_NANOSECONDS:
+      unit = TimestampUnit::kNano;
+      break;
+    case cudf::type_id::TIMESTAMP_MICROSECONDS:
+      unit = TimestampUnit::kMicro;
+      break;
+    case cudf::type_id::TIMESTAMP_MILLISECONDS:
+      unit = TimestampUnit::kMilli;
+      break;
+    case cudf::type_id::TIMESTAMP_SECONDS:
+      unit = TimestampUnit::kSecond;
+      break;
+    default:
+      VELOX_UNSUPPORTED();
+  }
   // Need to flattenDictionary and flattenConstant, otherwise we observe issues
-  // in the null mask.
-  ArrowOptions arrowOptions{true, true};
+  // in the null mask. Also, libcudf does not support Arrow binary, so we export
+  // VARBINARY as UTF-8.
+  ArrowOptions arrowOptions{
+      .flattenDictionary = true,
+      .flattenConstant = true,
+      .timestampUnit = unit,
+      .timestampTimeZone = timestampTimeZone,
+      .exportVarbinaryAsString = true,
+      .useDecimalTypeWidth = true};
   ArrowArray arrowArray;
   exportToArrow(
       std::dynamic_pointer_cast<facebook::velox::BaseVector>(veloxTable),
@@ -109,7 +164,14 @@ std::unique_ptr<cudf::table> toCudfTable(
       std::dynamic_pointer_cast<facebook::velox::BaseVector>(veloxTable),
       arrowSchema,
       arrowOptions);
-  auto tbl = cudf::from_arrow(&arrowSchema, &arrowArray, stream);
+  auto tbl = cudf::from_arrow(&arrowSchema, &arrowArray, stream, mr);
+
+  // Synchronize before releasing Arrow resources.  cudf::from_arrow uses
+  // cudaMemcpyBatchAsync (CUDA 13.0+) with cudaMemcpySrcAccessOrderStream,
+  // which defers reading the host source buffers until the stream reaches
+  // each copy.  The Arrow arrays must therefore stay alive until the stream
+  // has executed those copies.
+  stream.synchronize();
 
   // Release Arrow resources
   if (arrowArray.release) {
@@ -123,16 +185,74 @@ std::unique_ptr<cudf::table> toCudfTable(
 
 namespace {
 
+void setArrowFormatBackToVarbinary(ArrowSchema* schema, const TypePtr& type) {
+  switch (type->kind()) {
+    case TypeKind::ROW: {
+      if (schema->n_children != static_cast<int64_t>(type->size())) {
+        break;
+      }
+      for (size_t i = 0; i < type->size(); ++i) {
+        setArrowFormatBackToVarbinary(schema->children[i], type->childAt(i));
+      }
+      break;
+    }
+    case TypeKind::VARBINARY: {
+      // Replace any format string with "z" to indicate VARBINARY.
+      static constexpr const char* kVarbinaryArrowFormat = "z";
+      if (schema->format != nullptr) {
+        std::free(const_cast<char*>(schema->format));
+        schema->format = nullptr;
+      }
+      const size_t bufferLen = std::strlen(kVarbinaryArrowFormat) + 1;
+      auto* buffer = static_cast<char*>(std::malloc(bufferLen));
+      VELOX_CHECK_NOT_NULL(buffer);
+      std::memcpy(buffer, kVarbinaryArrowFormat, bufferLen);
+      schema->format = buffer;
+      break;
+    }
+    default:
+      break;
+  }
+}
+
 RowVectorPtr toVeloxColumn(
     const cudf::table_view& table,
     memory::MemoryPool* pool,
     const std::vector<cudf::column_metadata>& metadata,
-    rmm::cuda_stream_view stream) {
-  auto arrowDeviceArray = cudf::to_arrow_host(table, stream);
-  auto& arrowArray = arrowDeviceArray->array;
+    const RowTypePtr* outputType,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  // To avoid ownership issues, we make copies of the Arrow objects
+  // returned from cuDF as unique_ptrs, then mark the originals as
+  // released so their destructors don't try to free the resources.
+  //
+  // A better solution would be alternative versions of the cuDF
+  // to_arrow_host functions that return Arrow objects by value
+  // or populate objects passed by reference, but that would require
+  // changes to cuDF.
+  //
+  // seves 1/17/26
+
+  auto arrowDeviceArray = cudf::to_arrow_host(table, stream, mr);
+  ArrowArray arrayCopy = arrowDeviceArray->array;
+  arrowDeviceArray->array.release = nullptr;
 
   auto arrowSchema = cudf::to_arrow_schema(table, metadata);
-  auto veloxTable = importFromArrowAsOwner(*arrowSchema, arrowArray, pool);
+  ArrowSchema schemaCopy = *arrowSchema;
+  arrowSchema->release = nullptr;
+
+  // Override schema type recursively with outputType if provided. This is
+  // needed for some types like VARBINARY which are exported as STRING (the
+  // format is overridden to "z" when the exportVarbinaryAsString option is set
+  // to true in the exportToArrow() call) because cuDF does not have a VARBINARY
+  // type. This code implements the other side of the conversion, to change the
+  // format back to "z" so that the data re-imports as VARBINARY.
+  if (outputType) {
+    setArrowFormatBackToVarbinary(&schemaCopy, *outputType);
+  }
+
+  auto veloxTable = importFromArrowAsOwner(schemaCopy, arrayCopy, pool);
+
   // BaseVector to RowVector
   auto castedPtr =
       std::dynamic_pointer_cast<facebook::velox::RowVector>(veloxTable);
@@ -154,28 +274,78 @@ getMetadata(Iterator begin, Iterator end, const std::string& namePrefix) {
   return metadata;
 }
 
+// Recursively generate metadata using exact names from Velox RowType.
+cudf::column_metadata getMetadataWithName(
+    const facebook::velox::TypePtr& type,
+    const std::string& name) {
+  cudf::column_metadata meta(name);
+  if (type->kind() == facebook::velox::TypeKind::ROW) {
+    auto rowType =
+        std::dynamic_pointer_cast<const facebook::velox::RowType>(type);
+    for (size_t i = 0; i < rowType->size(); ++i) {
+      meta.children_meta.push_back(
+          getMetadataWithName(rowType->childAt(i), rowType->nameOf(i)));
+    }
+  } else if (type->kind() == facebook::velox::TypeKind::ARRAY) {
+    // cudf::lists_column_view::child_column_index is 1, the first metadata is
+    // offsets
+    meta.children_meta.emplace_back(cudf::column_metadata(name + "_offsets"));
+    meta.children_meta.push_back(
+        getMetadataWithName(type->childAt(0), "element"));
+  }
+  return meta;
+}
+
+std::vector<cudf::column_metadata> getMetadataWithName(
+    const RowTypePtr& rowType) {
+  std::vector<cudf::column_metadata> metadata;
+  for (size_t i = 0; i < rowType->size(); ++i) {
+    metadata.push_back(
+        getMetadataWithName(rowType->childAt(i), rowType->nameOf(i)));
+  }
+  return metadata;
+}
+
 } // namespace
 
 facebook::velox::RowVectorPtr toVeloxColumn(
     const cudf::table_view& table,
     facebook::velox::memory::MemoryPool* pool,
     std::string namePrefix,
-    rmm::cuda_stream_view stream) {
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
   auto metadata = getMetadata(table.begin(), table.end(), namePrefix);
-  return toVeloxColumn(table, pool, metadata, stream);
+  return toVeloxColumn(table, pool, metadata, nullptr, stream, mr);
 }
 
+facebook::velox::RowVectorPtr toVeloxColumn(
+    const cudf::table_view& table,
+    facebook::velox::memory::MemoryPool* pool,
+    const facebook::velox::RowTypePtr& outputType,
+    std::string namePrefix,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  auto metadata = getMetadata(table.begin(), table.end(), namePrefix);
+  return toVeloxColumn(table, pool, metadata, &outputType, stream, mr);
+}
+
+// New overload: Accepts a Velox TypePtr for recursive metadata construction.
 RowVectorPtr toVeloxColumn(
     const cudf::table_view& table,
     memory::MemoryPool* pool,
-    const std::vector<std::string>& columnNames,
-    rmm::cuda_stream_view stream) {
-  std::vector<cudf::column_metadata> metadata;
-  for (auto name : columnNames) {
-    metadata.emplace_back(cudf::column_metadata(name));
-  }
-  return toVeloxColumn(table, pool, metadata, stream);
+    const TypePtr& type,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  // Recursively generate metadata using Velox type names for all columns.
+  // This assumes 'type' is a RowType and its children match the cudf table
+  // columns.
+  auto rowType =
+      std::dynamic_pointer_cast<const facebook::velox::RowType>(type);
+  VELOX_CHECK_NOT_NULL(rowType);
+  auto metadata = getMetadataWithName(rowType);
+  return toVeloxColumn(table, pool, metadata, &rowType, stream, mr);
 }
 
 } // namespace with_arrow
+
 } // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/VeloxCudfInterop.h b/velox/experimental/cudf/exec/VeloxCudfInterop.h
index 39ed39bb708..47f638a8b6a 100644
--- a/velox/experimental/cudf/exec/VeloxCudfInterop.h
+++ b/velox/experimental/cudf/exec/VeloxCudfInterop.h
@@ -28,24 +28,39 @@ namespace facebook::velox::cudf_velox {
 
 cudf::type_id veloxToCudfTypeId(const TypePtr& type);
 
+cudf::data_type veloxToCudfDataType(const TypePtr& type);
+
 namespace with_arrow {
 
 std::unique_ptr<cudf::table> toCudfTable(
     const facebook::velox::RowVectorPtr& veloxTable,
     facebook::velox::memory::MemoryPool* pool,
-    rmm::cuda_stream_view stream);
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr,
+    std::optional<std::string> timestampTimeZone = std::nullopt);
+
+facebook::velox::RowVectorPtr toVeloxColumn(
+    const cudf::table_view& table,
+    facebook::velox::memory::MemoryPool* pool,
+    std::string namePrefix,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr);
 
+// Accepts a Velox TypePtr for recursive metadata construction.
 facebook::velox::RowVectorPtr toVeloxColumn(
     const cudf::table_view& table,
     facebook::velox::memory::MemoryPool* pool,
+    const facebook::velox::RowTypePtr& outputType,
     std::string namePrefix,
-    rmm::cuda_stream_view stream);
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr);
 
 facebook::velox::RowVectorPtr toVeloxColumn(
     const cudf::table_view& table,
     facebook::velox::memory::MemoryPool* pool,
-    const std::vector<std::string>& columnNames,
-    rmm::cuda_stream_view stream);
+    const TypePtr& type,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr);
 
 } // namespace with_arrow
 
diff --git a/velox/experimental/cudf/expression/AstExpression.cpp b/velox/experimental/cudf/expression/AstExpression.cpp
new file mode 100644
index 00000000000..28d4aa87409
--- /dev/null
+++ b/velox/experimental/cudf/expression/AstExpression.cpp
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+#include "velox/experimental/cudf/expression/AstExpression.h"
+#include "velox/experimental/cudf/expression/AstExpressionUtils.h"
+#include "velox/experimental/cudf/expression/AstPrinter.h"
+#include "velox/experimental/cudf/expression/AstUtils.h"
+#include "velox/experimental/cudf/vector/TableViewPrinter.h"
+
+#include "velox/expression/ConstantExpr.h"
+#include "velox/expression/FieldReference.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/ConstantVector.h"
+
+namespace facebook::velox::cudf_velox {
+
+// Create tree from Expr
+// and collect precompute instructions for non-ast operations
+cudf::ast::expression const& createAstTree(
+    const std::shared_ptr<velox::exec::Expr>& expr,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const RowTypePtr& inputRowSchema,
+    std::vector<PrecomputeInstruction>& precomputeInstructions) {
+  AstContext context{
+      tree, scalars, {inputRowSchema}, {precomputeInstructions}, expr};
+  return context.pushExprToTree(expr);
+}
+
+cudf::ast::expression const& createAstTree(
+    const std::shared_ptr<velox::exec::Expr>& expr,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const RowTypePtr& leftRowSchema,
+    const RowTypePtr& rightRowSchema,
+    std::vector<PrecomputeInstruction>& leftPrecomputeInstructions,
+    std::vector<PrecomputeInstruction>& rightPrecomputeInstructions) {
+  AstContext context{
+      tree,
+      scalars,
+      {leftRowSchema, rightRowSchema},
+      {leftPrecomputeInstructions, rightPrecomputeInstructions},
+      expr};
+  return context.pushExprToTree(expr);
+}
+
+ASTExpression::ASTExpression(
+    std::shared_ptr<velox::exec::Expr> expr,
+    const RowTypePtr& inputRowSchema)
+    : expr_(expr), inputRowSchema_(inputRowSchema) {
+  createAstTree(
+      expr, cudfTree_, scalars_, inputRowSchema, precomputeInstructions_);
+}
+
+void ASTExpression::close() {
+  cudfTree_ = {};
+  scalars_.clear();
+  precomputeInstructions_.clear();
+}
+
+ColumnOrView ASTExpression::eval(
+    std::vector<cudf::column_view> inputColumnViews,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr,
+    bool finalize) {
+  auto precomputedColumns = precomputeSubexpressions(
+      inputColumnViews,
+      precomputeInstructions_,
+      scalars_,
+      inputRowSchema_,
+      stream);
+
+  // Make table_view from input columns and precomputed columns
+  std::vector<cudf::column_view> allColumnViews(inputColumnViews);
+  allColumnViews.reserve(inputColumnViews.size() + precomputedColumns.size());
+  for (auto& precomputedCol : precomputedColumns) {
+    allColumnViews.push_back(asView(precomputedCol));
+  }
+
+  cudf::table_view astInputTableView(allColumnViews);
+
+  auto result = [&]() -> ColumnOrView {
+    if (auto colRefPtr = dynamic_cast<cudf::ast::column_reference const*>(
+            &cudfTree_.back())) {
+      auto columnIndex = colRefPtr->get_column_index();
+      if (columnIndex < inputColumnViews.size()) {
+        return inputColumnViews[columnIndex];
+      } else {
+        // Referencing a precomputed column return as it is (view or owned)
+        return std::move(
+            precomputedColumns[columnIndex - inputColumnViews.size()]);
+      }
+    } else {
+      if (CudfConfig::getInstance().debugEnabled) {
+        LOG(INFO) << cudf::ast::expression_to_string(cudfTree_.back());
+        LOG(INFO) << cudf::table_schema_to_string(astInputTableView);
+      }
+      return cudf::compute_column(
+          astInputTableView, cudfTree_.back(), stream, mr);
+    }
+  }();
+  if (finalize) {
+    const auto requestedType = cudf_velox::veloxToCudfDataType(expr_->type());
+    auto resultView = asView(result);
+    if (resultView.type() != requestedType) {
+      result = cudf::cast(resultView, requestedType, stream, mr);
+    }
+  }
+  return result;
+}
+
+bool ASTExpression::canEvaluate(std::shared_ptr<velox::exec::Expr> expr) {
+  return detail::isAstExprSupported(expr);
+}
+
+void registerAstEvaluator(int priority) {
+  registerCudfExpressionEvaluator(
+      kAstEvaluatorName,
+      priority,
+      [](std::shared_ptr<velox::exec::Expr> expr) {
+        return ASTExpression::canEvaluate(expr);
+      },
+      [](std::shared_ptr<velox::exec::Expr> expr, const RowTypePtr& row) {
+        return std::make_shared<ASTExpression>(std::move(expr), row);
+      },
+      /*overwrite=*/false);
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/AstExpression.h b/velox/experimental/cudf/expression/AstExpression.h
new file mode 100644
index 00000000000..47f88404c84
--- /dev/null
+++ b/velox/experimental/cudf/expression/AstExpression.h
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
+#include "velox/experimental/cudf/expression/PrecomputeInstruction.h"
+
+#include <cudf/ast/expressions.hpp>
+
+namespace facebook::velox::cudf_velox {
+
+const std::string kAstEvaluatorName = "ast";
+
+cudf::ast::expression const& createAstTree(
+    const std::shared_ptr<velox::exec::Expr>& expr,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const RowTypePtr& inputRowSchema,
+    std::vector<PrecomputeInstruction>& precomputeInstructions);
+
+cudf::ast::expression const& createAstTree(
+    const std::shared_ptr<velox::exec::Expr>& expr,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const RowTypePtr& leftRowSchema,
+    const RowTypePtr& rightRowSchema,
+    std::vector<PrecomputeInstruction>& leftPrecomputeInstructions,
+    std::vector<PrecomputeInstruction>& rightPrecomputeInstructions);
+
+// Evaluates the expression tree
+class ASTExpression : public CudfExpression {
+ public:
+  ASTExpression() = default;
+  // Converts velox expressions to cudf::ast::tree, scalars and
+  // precompute instructions and stores them
+  ASTExpression(
+      std::shared_ptr<velox::exec::Expr> expr,
+      const RowTypePtr& inputRowSchema);
+
+  // Evaluates the expression tree for the given input columns
+  ColumnOrView eval(
+      std::vector<cudf::column_view> inputColumnViews,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr,
+      bool finalize = false) override;
+
+  void close() override;
+
+  // Check if this specific operation (not its children) can be evaluated by
+  // ASTExpression
+  static bool canEvaluate(std::shared_ptr<velox::exec::Expr> expr);
+
+ private:
+  std::shared_ptr<velox::exec::Expr> expr_;
+
+  cudf::ast::tree cudfTree_;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars_;
+  // instruction on dependent column to get new column index on non-ast
+  // supported operations in expressions
+  // <dependent_column_index, "instruction", new_column_index>
+  std::vector<PrecomputeInstruction> precomputeInstructions_;
+  RowTypePtr inputRowSchema_;
+
+  friend class JitExpression;
+};
+
+void registerAstEvaluator(int priority);
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/AstExpressionUtils.h b/velox/experimental/cudf/expression/AstExpressionUtils.h
new file mode 100644
index 00000000000..70fcdbbc5fa
--- /dev/null
+++ b/velox/experimental/cudf/expression/AstExpressionUtils.h
@@ -0,0 +1,793 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/exec/GpuResources.h"
+#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+#include "velox/experimental/cudf/expression/AstExpression.h"
+#include "velox/experimental/cudf/expression/AstUtils.h"
+// TODO(kn): in another PR
+// #include "velox/experimental/cudf/CudfNoDefaults.h"
+#include "velox/experimental/cudf/expression/DecimalTypeCheck.h"
+
+#include "velox/expression/ConstantExpr.h"
+#include "velox/expression/FieldReference.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/ConstantVector.h"
+
+#include <cudf/ast/detail/operators.hpp>
+#include <cudf/ast/expressions.hpp>
+#include <cudf/column/column_factories.hpp>
+#include <cudf/table/table.hpp>
+#include <cudf/transform.hpp>
+#include <cudf/unary.hpp>
+#include <cudf/utilities/traits.hpp>
+
+namespace facebook::velox::cudf_velox {
+namespace {
+
+cudf::ast::literal createLiteral(
+    const VectorPtr& vector,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    size_t atIndex = 0) {
+  const auto kind = vector->typeKind();
+  const auto& type = vector->type();
+  variant value =
+      VELOX_DYNAMIC_TYPE_DISPATCH(getVariant, kind, vector, atIndex);
+  return VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
+      makeScalarAndLiteral,
+      kind,
+      type,
+      value,
+      vector->isNullAt(atIndex),
+      scalars);
+}
+
+// Helper function to extract literals from array elements based on type
+void extractArrayLiterals(
+    const ArrayVector* arrayVector,
+    std::vector<cudf::ast::literal>& literals,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    vector_size_t offset,
+    vector_size_t size) {
+  auto elements = arrayVector->elements();
+
+  for (auto i = offset; i < offset + size; ++i) {
+    if (elements->isNullAt(i)) {
+      // Skip null values for IN expressions
+      continue;
+    } else {
+      literals.emplace_back(createLiteral(elements, scalars, i));
+    }
+  }
+}
+
+// Function to create literals from an array vector
+std::vector<cudf::ast::literal> createLiteralsFromArray(
+    const VectorPtr& vector,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars) {
+  std::vector<cudf::ast::literal> literals;
+
+  // Check if it's a constant vector containing an array
+  if (vector->isConstantEncoding()) {
+    auto constantVector = vector->asUnchecked<ConstantVector<ComplexType>>();
+    if (constantVector->isNullAt(0)) {
+      // Return empty vector for null array
+      return literals;
+    }
+
+    auto valueVector = constantVector->valueVector();
+    if (valueVector->encoding() == VectorEncoding::Simple::ARRAY) {
+      auto arrayVector = valueVector->as<ArrayVector>();
+      auto index = constantVector->index();
+      auto size = arrayVector->sizeAt(index);
+      if (size == 0) {
+        // Return empty vector for empty array
+        return literals;
+      }
+
+      auto offset = arrayVector->offsetAt(index);
+      auto elements = arrayVector->elements();
+
+      // Handle different element types
+      if (elements->isScalar()) {
+        literals.reserve(size);
+        extractArrayLiterals(arrayVector, literals, scalars, offset, size);
+      } else if (elements->typeKind() == TypeKind::ARRAY) {
+        // Nested arrays not supported in IN expressions
+        VELOX_FAIL("Nested arrays not supported in IN expressions");
+      } else {
+        VELOX_FAIL(
+            "Unsupported element type in array: {}",
+            elements->type()->toString());
+      }
+    } else {
+      VELOX_FAIL("Expected ARRAY encoding");
+    }
+  } else {
+    VELOX_FAIL("Expected constant vector for IN list");
+  }
+
+  return literals;
+}
+
+std::string stripPrefix(const std::string& input, const std::string& prefix) {
+  if (input.size() >= prefix.size() &&
+      input.compare(0, prefix.size(), prefix) == 0) {
+    return input.substr(prefix.size());
+  }
+  return input;
+}
+
+using Op = cudf::ast::ast_operator;
+const std::unordered_map<std::string, Op> prestoBinaryOps = {
+    {"plus", Op::ADD},
+    {"minus", Op::SUB},
+    {"multiply", Op::MUL},
+    {"divide", Op::DIV},
+    {"eq", Op::EQUAL},
+    {"neq", Op::NOT_EQUAL},
+    {"lt", Op::LESS},
+    {"gt", Op::GREATER},
+    {"lte", Op::LESS_EQUAL},
+    {"gte", Op::GREATER_EQUAL},
+    {"and", Op::NULL_LOGICAL_AND},
+    {"or", Op::NULL_LOGICAL_OR},
+    {"mod", Op::MOD},
+};
+
+const std::unordered_map<std::string, Op> sparkBinaryOps = {
+    {"add", Op::ADD},
+    {"subtract", Op::SUB},
+    {"multiply", Op::MUL},
+    {"divide", Op::DIV},
+    {"equalto", Op::EQUAL},
+    {"lessthan", Op::LESS},
+    {"greaterthan", Op::GREATER},
+    {"lessthanorequal", Op::LESS_EQUAL},
+    {"greaterthanorequal", Op::GREATER_EQUAL},
+    {"and", Op::NULL_LOGICAL_AND},
+    {"or", Op::NULL_LOGICAL_OR},
+    {"mod", Op::MOD},
+};
+
+const std::unordered_map<std::string, Op> binaryOps = [] {
+  std::unordered_map<std::string, Op> merged(
+      sparkBinaryOps.begin(), sparkBinaryOps.end());
+  merged.insert(prestoBinaryOps.begin(), prestoBinaryOps.end());
+  return merged;
+}();
+
+const std::unordered_map<std::string, Op> prestoUnaryOps = {
+    {"not", Op::NOT},
+    {"is_null", Op::IS_NULL},
+    // Trigonometric functions
+    {"sin", Op::SIN},
+    {"cos", Op::COS},
+    {"tan", Op::TAN},
+    {"asin", Op::ARCSIN},
+    {"acos", Op::ARCCOS},
+    {"atan", Op::ARCTAN},
+    {"cosh", Op::COSH},
+    {"tanh", Op::TANH},
+    // Exponential and logarithmic functions
+    {"exp", Op::EXP},
+    {"ln", Op::LOG},
+    {"sqrt", Op::SQRT},
+    {"cbrt", Op::CBRT},
+    // Other functions
+    {"abs", Op::ABS},
+};
+
+const std::unordered_map<std::string, Op> sparkUnaryOps = {
+    {"not", Op::NOT},
+    {"is_null", Op::IS_NULL},
+    // Trigonometric functions
+    {"sin", Op::SIN},
+    {"cos", Op::COS},
+    {"tan", Op::TAN},
+    {"asin", Op::ARCSIN},
+    {"acos", Op::ARCCOS},
+    {"atan", Op::ARCTAN},
+    // Hyperbolic functions
+    {"sinh", Op::SINH},
+    {"cosh", Op::COSH},
+    {"tanh", Op::TANH},
+    {"asinh", Op::ARCSINH},
+    {"acosh", Op::ARCCOSH},
+    {"atanh", Op::ARCTANH},
+    // Exponential and logarithmic functions
+    {"exp", Op::EXP},
+    {"log", Op::LOG},
+    {"ln", Op::LOG},
+    // Root functions
+    {"sqrt", Op::SQRT},
+    {"cbrt", Op::CBRT},
+    // Rounding functions
+    {"ceil", Op::CEIL},
+    {"floor", Op::FLOOR},
+    {"rint", Op::RINT},
+    // Other functions
+    {"abs", Op::ABS},
+};
+
+const std::unordered_map<std::string, Op> unaryOps = [] {
+  std::unordered_map<std::string, Op> merged(
+      sparkUnaryOps.begin(), sparkUnaryOps.end());
+  merged.insert(prestoUnaryOps.begin(), prestoUnaryOps.end());
+  return merged;
+}();
+
+namespace detail {
+
+// return the AST operator for the given expression name, if any
+std::optional<Op> opFromFunctionName(const std::string& funcName) {
+  if (binaryOps.find(funcName) != binaryOps.end()) {
+    return binaryOps.at(funcName);
+  } else if (unaryOps.find(funcName) != unaryOps.end()) {
+    return unaryOps.at(funcName);
+  }
+  return std::nullopt;
+}
+
+bool isOpAndInputsSupported(
+    const cudf::ast::ast_operator op,
+    const std::vector<cudf::data_type>& inputCudfDataTypes) {
+  // check arity
+  const auto arity = cudf::ast::detail::ast_operator_arity(op);
+  if (arity != static_cast<int>(inputCudfDataTypes.size())) {
+    LOG(WARNING) << "Arity mismatch for operator: " << static_cast<int>(op)
+                 << " with input types size " << inputCudfDataTypes.size();
+    return false;
+  }
+  // check for a cuDF implementation of this op with these inputs
+  try {
+    // this will throw if no matching implementation is found
+    const auto returnCudfType =
+        cudf::ast::detail::ast_operator_return_type(op, inputCudfDataTypes);
+    // check it's a sensible type
+    return returnCudfType.id() != cudf::type_id::EMPTY;
+  } catch (...) {
+    // no matching cuDF implementation
+  }
+  return false;
+}
+
+// not special form, name = function, so unsupported for astpure
+// "in", "between", "isnotnull" are not special form, but supported for astpure
+// enum class SpecialFormKind : int32_t {
+//   kFieldAccess = 0, supported if not nested column / function
+//   kConstant = 1, "literal" for fixed_width and VARCHAR / function
+//   kCast = 2, "cast" or "try_cast" to int32, int64, double only / function
+//   kCoalesce = 3, unsupported/function
+//   kSwitch = 4, unsupported
+//   kLambda = 5, unsupported
+//   kTry = 6, unsupported
+//   kAnd = 7, "and" or "or" with multiple inputs
+//   kOr = 8,
+//   kCustom = 999,
+// };
+// check if the expression (name + input types) is supported in AST
+bool isAstExprSupported(const std::shared_ptr<velox::exec::Expr>& expr) {
+  using velox::exec::FieldReference;
+  using Op = cudf::ast::ast_operator;
+
+  // For now, AST does not support expressions with DECIMAL output, or immediate
+  // DECIMAL inputs.
+  // @TODO implement DECIMAL in AST and JIT
+  if (containsDecimalType(expr, false)) {
+    if (cudf_velox::CudfConfig::getInstance().debugEnabled) {
+      LOG(WARNING)
+          << "Expression contains DECIMAL type, which is not supported by AST/JIT: "
+          << expr->toString();
+    }
+    return false;
+  }
+
+  const auto name =
+      stripPrefix(expr->name(), CudfConfig::getInstance().functionNamePrefix);
+  const auto len = expr->inputs().size();
+
+  // Literals and field references are always supported
+  auto isSupportedLiteral = [&](const TypePtr& type) {
+    try {
+      auto cudfType = veloxToCudfDataType(type);
+      return cudf::is_fixed_width(cudfType) ||
+          cudfType.id() == cudf::type_id::STRING;
+    } catch (...) {
+      LOG(WARNING) << "Unsupported type for literal: " << type->toString();
+      return false;
+    }
+  };
+  if (name == "literal") {
+    auto type = expr->type();
+    return isSupportedLiteral(type);
+  }
+  if (auto fieldExpr = std::dynamic_pointer_cast<FieldReference>(expr)) {
+    const auto fieldName =
+        fieldExpr->inputs().empty() ? name : fieldExpr->inputs()[0]->name();
+    if (fieldExpr->field() == fieldName) {
+      return true;
+    }
+    LOG(WARNING) << "Field " << name << "not found, in expression "
+                 << expr->toString();
+    return false;
+  }
+
+  // Convert input types to CUDF types once
+  std::vector<cudf::data_type> inputCudfDataTypes;
+  inputCudfDataTypes.reserve(len);
+  for (const auto& input : expr->inputs()) {
+    try {
+      inputCudfDataTypes.push_back(veloxToCudfDataType(input->type()));
+    } catch (...) {
+      return false;
+    }
+  }
+
+  // Binary operations
+  if (binaryOps.find(name) != binaryOps.end()) {
+    // AND/OR can handle multiple inputs by chaining
+    if ((name == "and" || name == "or") && len > 2) {
+      for (size_t i = 1; i < len; i++) {
+        if (!isOpAndInputsSupported(
+                binaryOps.at(name),
+                {inputCudfDataTypes[0], inputCudfDataTypes[i]})) {
+          return false;
+        }
+      }
+      return true;
+    }
+    return len == 2 &&
+        isOpAndInputsSupported(binaryOps.at(name), inputCudfDataTypes);
+  }
+
+  // Unary operations (includes both unaryOps and "isnotnull")
+  if (unaryOps.find(name) != unaryOps.end()) {
+    return isOpAndInputsSupported(unaryOps.at(name), inputCudfDataTypes);
+  }
+  if (name == "isnotnull" && len == 1) {
+    return isOpAndInputsSupported(Op::IS_NULL, inputCudfDataTypes);
+  }
+
+  // Between: value >= lower AND value <= upper
+  if (name == "between" && len == 3) {
+    return isOpAndInputsSupported(
+               Op::GREATER_EQUAL,
+               {inputCudfDataTypes[0], inputCudfDataTypes[1]}) &&
+        isOpAndInputsSupported(
+               Op::LESS_EQUAL, {inputCudfDataTypes[0], inputCudfDataTypes[2]});
+  }
+
+  // In: chain of EQUAL operations
+  if (name == "in") {
+    return len == 2 && isSupportedLiteral(expr->inputs()[0]->type()) &&
+        isOpAndInputsSupported(
+               Op::EQUAL, {inputCudfDataTypes[0], inputCudfDataTypes[0]});
+  }
+
+  // Cast operations: only INTEGER, BIGINT, DOUBLE supported in pure AST
+  if ((name == "cast" || name == "try_cast") && len == 1) {
+    const auto outputKind = expr->type()->kind();
+    if (outputKind == TypeKind::INTEGER || outputKind == TypeKind::BIGINT) {
+      return isOpAndInputsSupported(Op::CAST_TO_INT64, inputCudfDataTypes);
+    }
+    if (outputKind == TypeKind::DOUBLE) {
+      return isOpAndInputsSupported(Op::CAST_TO_FLOAT64, inputCudfDataTypes);
+    }
+    return false;
+  }
+
+  LOG(WARNING) << "Unsupported expression by AST: " << expr->toString();
+  return false;
+}
+
+} // namespace detail
+
+struct AstContext {
+  cudf::ast::tree& tree;
+  std::vector<std::unique_ptr<cudf::scalar>>& scalars;
+  const std::vector<RowTypePtr> inputRowSchema;
+  const std::vector<std::reference_wrapper<std::vector<PrecomputeInstruction>>>
+      precomputeInstructions;
+  const std::shared_ptr<velox::exec::Expr>
+      rootExpr; // Track the root expression
+  bool allowPureAstOnly;
+
+  cudf::ast::expression const& pushExprToTree(
+      const std::shared_ptr<velox::exec::Expr>& expr);
+  cudf::ast::expression const& addPrecomputeInstructionOnSide(
+      size_t sideIdx,
+      size_t columnIndex,
+      std::string const& instruction,
+      std::string const& fieldName,
+      const std::shared_ptr<CudfExpression>& node = nullptr);
+  cudf::ast::expression const& addPrecomputeInstruction(
+      std::string const& name,
+      std::string const& instruction,
+      std::string const& fieldName = {},
+      const std::shared_ptr<CudfExpression>& node = nullptr);
+  cudf::ast::expression const& multipleInputsToPairWise(
+      const std::shared_ptr<velox::exec::Expr>& expr);
+  static bool canBeEvaluated(const std::shared_ptr<velox::exec::Expr>& expr);
+  // Determines which side (0=left, 1=right) an expression references by
+  // examining its field references. Returns -1 if no fields found, -2 if spans
+  // both sides.
+  int findExpressionSide(const std::shared_ptr<velox::exec::Expr>& expr) const;
+};
+
+/// Checks if an expression contains sub-expressions that:
+/// 1. Cannot be represented natively in cuDF AST (need precomputation)
+/// 2. AND reference fields from both sides of a join
+/// Returns true only if such problematic sub-expressions exist.
+inline bool hasNonAstSubexprSpanningBothSides(
+    const std::shared_ptr<velox::exec::Expr>& expr,
+    const RowTypePtr& leftSchema,
+    const RowTypePtr& rightSchema) {
+  // Check if the expression is natively supported by AST
+  // If it is, we don't need to precompute it, so cross-side references are fine
+  if (detail::isAstExprSupported(expr)) {
+    // Recursively check children
+    for (const auto& child : expr->inputs()) {
+      if (hasNonAstSubexprSpanningBothSides(child, leftSchema, rightSchema)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Expression needs precomputation - check if it spans both sides
+  bool hasLeft = false, hasRight = false;
+  for (const auto* field : expr->distinctFields()) {
+    hasLeft |= leftSchema->containsChild(field->field());
+    hasRight |= rightSchema->containsChild(field->field());
+    if (hasLeft && hasRight) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// get nested column indices
+std::vector<int> getNestedColumnIndices(
+    const TypePtr& rowType,
+    const std::string& fieldName) {
+  std::vector<int> indices;
+  auto rowTypePtr = asRowType(rowType);
+  if (rowTypePtr->containsChild(fieldName)) {
+    auto columnIndex = rowTypePtr->getChildIdx(fieldName);
+    indices.push_back(columnIndex);
+  }
+  return indices;
+}
+
+cudf::ast::expression const& AstContext::addPrecomputeInstructionOnSide(
+    size_t sideIdx,
+    size_t columnIndex,
+    std::string const& instruction,
+    std::string const& fieldName,
+    const std::shared_ptr<CudfExpression>& node) {
+  auto newColumnIndex = inputRowSchema[sideIdx].get()->size() +
+      precomputeInstructions[sideIdx].get().size();
+  if (fieldName.empty()) {
+    // This custom op should be added to input columns.
+    precomputeInstructions[sideIdx].get().emplace_back(
+        columnIndex, instruction, newColumnIndex, node);
+  } else {
+    auto nestedIndices = getNestedColumnIndices(
+        inputRowSchema[sideIdx].get()->childAt(columnIndex), fieldName);
+    precomputeInstructions[sideIdx].get().emplace_back(
+        columnIndex,
+        instruction,
+        newColumnIndex,
+        std::move(nestedIndices),
+        node);
+  }
+  auto side = static_cast<cudf::ast::table_reference>(sideIdx);
+  return tree.push(cudf::ast::column_reference(newColumnIndex, side));
+}
+
+cudf::ast::expression const& AstContext::addPrecomputeInstruction(
+    std::string const& name,
+    std::string const& instruction,
+    std::string const& fieldName,
+    const std::shared_ptr<CudfExpression>& node) {
+  for (size_t sideIdx = 0; sideIdx < inputRowSchema.size(); ++sideIdx) {
+    if (inputRowSchema[sideIdx].get()->containsChild(name)) {
+      auto columnIndex = inputRowSchema[sideIdx].get()->getChildIdx(name);
+      return addPrecomputeInstructionOnSide(
+          sideIdx, columnIndex, instruction, fieldName, node);
+    }
+  }
+  VELOX_FAIL("Field not found: {}", name);
+}
+
+/// Handles logical AND/OR expressions with multiple inputs by converting them
+/// into a chain of binary operations. For example, "a AND b AND c" becomes
+/// "(a AND b) AND c".
+///
+/// @param expr The expression containing multiple inputs for AND/OR operation
+/// @return A reference to the resulting AST expression
+cudf::ast::expression const& AstContext::multipleInputsToPairWise(
+    const std::shared_ptr<velox::exec::Expr>& expr) {
+  using Operation = cudf::ast::operation;
+
+  const auto name =
+      stripPrefix(expr->name(), CudfConfig::getInstance().functionNamePrefix);
+  auto len = expr->inputs().size();
+  // Create a simple chain of operations
+  auto result = &pushExprToTree(expr->inputs()[0]);
+
+  // Chain the rest of the inputs sequentially
+  for (size_t i = 1; i < len; i++) {
+    auto const& nextInput = pushExprToTree(expr->inputs()[i]);
+    result = &tree.push(Operation{binaryOps.at(name), *result, nextInput});
+  }
+  return *result;
+}
+
+/// Pushes an expression into the AST tree and returns a reference to the
+/// resulting expression.
+///
+/// @param expr The expression to push into the AST tree
+/// @return A reference to the resulting AST expression
+cudf::ast::expression const& AstContext::pushExprToTree(
+    const std::shared_ptr<velox::exec::Expr>& expr) {
+  using Op = cudf::ast::ast_operator;
+  using Operation = cudf::ast::operation;
+  using velox::exec::ConstantExpr;
+  using velox::exec::FieldReference;
+
+  const auto name =
+      stripPrefix(expr->name(), CudfConfig::getInstance().functionNamePrefix);
+
+  if (!detail::isAstExprSupported(expr)) {
+    if (canBeEvaluatedByCudf(expr, /*deep=*/false)) {
+      // Shallow check: only verify this operation is supported
+      // Children will be recursively handled by createCudfExpression
+      // Determine which side this expression references
+      int sideIdx = findExpressionSide(expr);
+      if (sideIdx == -2) {
+        // Expression spans both sides of the join - cannot precompute on one
+        // side
+        VELOX_FAIL(
+            "Expression spans both join sides and cannot be precomputed: " +
+            name);
+      }
+      if (sideIdx < 0) {
+        sideIdx = 0; // Default to left side if no fields found
+      }
+      auto node = createCudfExpression(expr, inputRowSchema[sideIdx]);
+      return addPrecomputeInstructionOnSide(sideIdx, 0, name, "", node);
+    }
+    VELOX_FAIL("Unsupported expression: {}", name);
+  }
+
+  auto len = expr->inputs().size();
+  auto& type = expr->type();
+
+  if (name == "literal") {
+    auto c = dynamic_cast<ConstantExpr*>(expr.get());
+    VELOX_CHECK_NOT_NULL(c, "literal expression should be ConstantExpr");
+    auto value = c->value();
+    VELOX_CHECK(value->isConstantEncoding());
+
+    // Materialize NULL literals via make_column_from_scalar so the output
+    // column preserves nullness for downstream operators like count(column).
+    //
+    // Also keep the standalone literal workaround: cudf::compute_column can
+    // produce spurious nulls for root literal expressions. See comment below.
+    //
+    // TODO: There is a scalar stream synchronization bug that causes
+    // cudf::compute_column to produce spurious nulls for standalone
+    // literal expressions.  Work around it by materialising via
+    // make_column_from_scalar instead.
+    if (value->isNullAt(0) || expr == rootExpr) {
+      // convert to cudf scalar and store it
+      createLiteral(value, scalars);
+      // The scalar index is scalars.size() - 1 since we just added it
+      std::string fillExpr = "fill " + std::to_string(scalars.size() - 1);
+      // For literals, we use the first column just to get the size, but create
+      // a new column The new column will be appended after the original input
+      // columns
+      return addPrecomputeInstruction(inputRowSchema[0]->nameOf(0), fillExpr);
+    }
+
+    return tree.push(createLiteral(value, scalars));
+  } else if (binaryOps.find(name) != binaryOps.end()) {
+    if (name == "and" or name == "or") {
+      return multipleInputsToPairWise(expr);
+    }
+    VELOX_CHECK_EQ(len, 2);
+    auto const& op1 = pushExprToTree(expr->inputs()[0]);
+    auto const& op2 = pushExprToTree(expr->inputs()[1]);
+    return tree.push(Operation{binaryOps.at(name), op1, op2});
+  } else if (unaryOps.find(name) != unaryOps.end()) {
+    VELOX_CHECK_EQ(len, 1);
+    auto const& op1 = pushExprToTree(expr->inputs()[0]);
+    // Spark result type is different with presto, presto is same with cudf
+    const auto& op2 = tree.push(Operation{unaryOps.at(name), op1});
+    if ((name == "ceil" || name == "floor") &&
+        expr->type()->kind() == TypeKind::BIGINT) {
+      return tree.push(Operation{Op::CAST_TO_INT64, op2});
+    }
+    return op2;
+  } else if (name == "isnotnull") {
+    VELOX_CHECK_EQ(len, 1);
+    auto const& op1 = pushExprToTree(expr->inputs()[0]);
+    auto const& nullOp = tree.push(Operation{Op::IS_NULL, op1});
+    return tree.push(Operation{Op::NOT, nullOp});
+  } else if (name == "between") {
+    VELOX_CHECK_EQ(len, 3);
+    auto const& value = pushExprToTree(expr->inputs()[0]);
+    auto const& lower = pushExprToTree(expr->inputs()[1]);
+    auto const& upper = pushExprToTree(expr->inputs()[2]);
+    // construct between(op2, op3) using >= and <=
+    auto const& geLower = tree.push(Operation{Op::GREATER_EQUAL, value, lower});
+    auto const& leUpper = tree.push(Operation{Op::LESS_EQUAL, value, upper});
+    return tree.push(Operation{Op::NULL_LOGICAL_AND, geLower, leUpper});
+  } else if (name == "in") {
+    // number of inputs is variable. >=2
+    VELOX_CHECK_EQ(len, 2);
+    // actually len is 2, second input is ARRAY
+    auto const& op1 = pushExprToTree(expr->inputs()[0]);
+    auto c = dynamic_cast<ConstantExpr*>(expr->inputs()[1].get());
+    VELOX_CHECK_NOT_NULL(c, "literal expression should be ConstantExpr");
+    auto value = c->value();
+    VELOX_CHECK_NOT_NULL(value, "ConstantExpr value is null");
+
+    // Use the new createLiteralsFromArray function to get literals
+    auto literals = createLiteralsFromArray(value, scalars);
+
+    // Create equality expressions for each literal and OR them together
+    std::vector<const cudf::ast::expression*> exprVec;
+    for (auto& literal : literals) {
+      auto const& opi = tree.push(std::move(literal));
+      auto const& logicalNode = tree.push(Operation{Op::EQUAL, op1, opi});
+      exprVec.push_back(&logicalNode);
+    }
+
+    // Handle empty IN list case
+    if (exprVec.empty()) {
+      // FAIL
+      VELOX_FAIL("Empty IN list");
+      // Return FALSE for empty IN list
+      // auto falseValue = std::make_shared<ConstantVector<bool>>(
+      //     value->pool(), 1, false, TypeKind::BOOLEAN, false);
+      // return tree.push(createLiteral(falseValue, scalars));
+    }
+
+    // OR all logical nodes
+    auto* result = exprVec[0];
+    for (size_t i = 1; i < exprVec.size(); i++) {
+      auto const& treeNode =
+          tree.push(Operation{Op::NULL_LOGICAL_OR, *result, *exprVec[i]});
+      result = &treeNode;
+    }
+    return *result;
+  } else if (name == "cast" || name == "try_cast") {
+    VELOX_CHECK_EQ(len, 1);
+    auto const& op1 = pushExprToTree(expr->inputs()[0]);
+    if (expr->type()->kind() == TypeKind::INTEGER) {
+      // No int32 cast in cudf ast
+      return tree.push(Operation{Op::CAST_TO_INT64, op1});
+    } else if (expr->type()->kind() == TypeKind::BIGINT) {
+      return tree.push(Operation{Op::CAST_TO_INT64, op1});
+    } else if (expr->type()->kind() == TypeKind::DOUBLE) {
+      return tree.push(Operation{Op::CAST_TO_FLOAT64, op1});
+    } else {
+      VELOX_FAIL("Unsupported type for cast operation");
+    }
+  } else if (auto fieldExpr = std::dynamic_pointer_cast<FieldReference>(expr)) {
+    // Refer to the appropriate side
+    const auto fieldName =
+        fieldExpr->inputs().empty() ? name : fieldExpr->inputs()[0]->name();
+    for (size_t sideIdx = 0; sideIdx < inputRowSchema.size(); ++sideIdx) {
+      auto& schema = inputRowSchema[sideIdx];
+      if (schema.get()->containsChild(fieldName)) {
+        auto columnIndex = schema.get()->getChildIdx(fieldName);
+        // This column may be complex data type like ROW, we need to get the
+        // name from row. Push fieldName.name to the tree.
+        auto side = static_cast<cudf::ast::table_reference>(sideIdx);
+        if (fieldExpr->field() == fieldName) {
+          return tree.push(cudf::ast::column_reference(columnIndex, side));
+        } else if (!allowPureAstOnly) {
+          return addPrecomputeInstruction(
+              fieldName, "nested_column", fieldExpr->field());
+        } else {
+          VELOX_FAIL("Unsupported type for nested column operation");
+        }
+      }
+    }
+    VELOX_FAIL("Field not found: {}", name);
+  } else {
+    VELOX_UNREACHABLE("Unsupported expression: {}", name);
+  }
+}
+
+// Returns: 0 = left only, 1 = right only, -1 = no fields, -2 = spans both sides
+int AstContext::findExpressionSide(
+    const std::shared_ptr<velox::exec::Expr>& expr) const {
+  int foundSide = -1;
+  for (const auto* field : expr->distinctFields()) {
+    for (size_t sideIdx = 0; sideIdx < inputRowSchema.size(); ++sideIdx) {
+      if (inputRowSchema[sideIdx].get()->containsChild(field->field())) {
+        if (foundSide == -1) {
+          foundSide = static_cast<int>(sideIdx);
+        } else if (foundSide != static_cast<int>(sideIdx)) {
+          // Expression spans both sides
+          return -2;
+        }
+        break;
+      }
+    }
+  }
+  return foundSide;
+}
+
+std::vector<ColumnOrView> precomputeSubexpressions(
+    const std::vector<cudf::column_view>& inputColumnViews,
+    const std::vector<PrecomputeInstruction>& precomputeInstructions,
+    const std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const RowTypePtr& inputRowSchema,
+    rmm::cuda_stream_view stream) {
+  std::vector<ColumnOrView> precomputedColumns;
+  precomputedColumns.reserve(precomputeInstructions.size());
+
+  for (const auto& instruction : precomputeInstructions) {
+    auto
+        [dependent_column_index,
+         ins_name,
+         new_column_index,
+         nested_dependent_column_indices,
+         cudf_expression] = instruction;
+
+    // If a compiled cudf node is available, evaluate it directly.
+    if (cudf_expression) {
+      auto result = cudf_expression->eval(
+          inputColumnViews,
+          stream,
+          get_output_mr(),
+          /*finalize=*/true);
+      precomputedColumns.push_back(std::move(result));
+      continue;
+    }
+    if (ins_name.rfind("fill", 0) == 0) {
+      auto scalarIndex =
+          std::stoi(ins_name.substr(5)); // "fill " is 5 characters
+      auto newColumn = cudf::make_column_from_scalar(
+          *scalars[scalarIndex],
+          inputColumnViews[dependent_column_index].size(),
+          stream,
+          get_output_mr());
+      precomputedColumns.push_back(std::move(newColumn));
+    } else if (ins_name == "nested_column") {
+      // Nested column already exists in input. Don't materialize.
+      auto view = inputColumnViews[dependent_column_index].child(
+          nested_dependent_column_indices[0]);
+      precomputedColumns.push_back(view);
+    } else {
+      VELOX_FAIL("Unsupported precompute operation {}", ins_name);
+    }
+  }
+
+  return precomputedColumns;
+}
+
+} // namespace
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/AstPrinter.h b/velox/experimental/cudf/expression/AstPrinter.h
new file mode 100644
index 00000000000..e12df3b37f3
--- /dev/null
+++ b/velox/experimental/cudf/expression/AstPrinter.h
@@ -0,0 +1,471 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*
+ * A standalone AST expression tree printer for cudf::ast::expression.
+ * Can be copied to any project that uses cudf AST expressions.
+ *
+ * Usage:
+ *   cudf::ast::expression const& expr = ...;
+ *   cudf::ast::print_expression(expr);
+ *   // or
+ *   std::string str = cudf::ast::expression_to_string(expr);
+ */
+#pragma once
+
+#include <cudf/ast/ast_operator.hpp>
+#include <cudf/ast/expressions.hpp>
+
+#include <iostream>
+#include <sstream>
+#include <string>
+
+namespace cudf {
+namespace ast {
+
+/**
+ * @brief Get the string representation of an ast_operator
+ */
+inline std::string ast_operator_to_string(ast_operator op) {
+  switch (op) {
+    // Binary operators
+    case ast_operator::ADD:
+      return "ADD (+)";
+    case ast_operator::SUB:
+      return "SUB (-)";
+    case ast_operator::MUL:
+      return "MUL (*)";
+    case ast_operator::DIV:
+      return "DIV (/)";
+    case ast_operator::TRUE_DIV:
+      return "TRUE_DIV";
+    case ast_operator::FLOOR_DIV:
+      return "FLOOR_DIV";
+    case ast_operator::MOD:
+      return "MOD (%)";
+    case ast_operator::PYMOD:
+      return "PYMOD";
+    case ast_operator::POW:
+      return "POW (^)";
+    case ast_operator::EQUAL:
+      return "EQUAL (==)";
+    case ast_operator::NULL_EQUAL:
+      return "NULL_EQUAL";
+    case ast_operator::NOT_EQUAL:
+      return "NOT_EQUAL (!=)";
+    case ast_operator::LESS:
+      return "LESS (<)";
+    case ast_operator::GREATER:
+      return "GREATER (>)";
+    case ast_operator::LESS_EQUAL:
+      return "LESS_EQUAL (<=)";
+    case ast_operator::GREATER_EQUAL:
+      return "GREATER_EQUAL (>=)";
+    case ast_operator::BITWISE_AND:
+      return "BITWISE_AND (&)";
+    case ast_operator::BITWISE_OR:
+      return "BITWISE_OR (|)";
+    case ast_operator::BITWISE_XOR:
+      return "BITWISE_XOR (^)";
+    case ast_operator::LOGICAL_AND:
+      return "LOGICAL_AND (&&)";
+    case ast_operator::NULL_LOGICAL_AND:
+      return "NULL_LOGICAL_AND";
+    case ast_operator::LOGICAL_OR:
+      return "LOGICAL_OR (||)";
+    case ast_operator::NULL_LOGICAL_OR:
+      return "NULL_LOGICAL_OR";
+    // Unary operators
+    case ast_operator::IDENTITY:
+      return "IDENTITY";
+    case ast_operator::IS_NULL:
+      return "IS_NULL";
+    case ast_operator::SIN:
+      return "SIN";
+    case ast_operator::COS:
+      return "COS";
+    case ast_operator::TAN:
+      return "TAN";
+    case ast_operator::ARCSIN:
+      return "ARCSIN";
+    case ast_operator::ARCCOS:
+      return "ARCCOS";
+    case ast_operator::ARCTAN:
+      return "ARCTAN";
+    case ast_operator::SINH:
+      return "SINH";
+    case ast_operator::COSH:
+      return "COSH";
+    case ast_operator::TANH:
+      return "TANH";
+    case ast_operator::ARCSINH:
+      return "ARCSINH";
+    case ast_operator::ARCCOSH:
+      return "ARCCOSH";
+    case ast_operator::ARCTANH:
+      return "ARCTANH";
+    case ast_operator::EXP:
+      return "EXP";
+    case ast_operator::LOG:
+      return "LOG";
+    case ast_operator::SQRT:
+      return "SQRT";
+    case ast_operator::CBRT:
+      return "CBRT";
+    case ast_operator::CEIL:
+      return "CEIL";
+    case ast_operator::FLOOR:
+      return "FLOOR";
+    case ast_operator::ABS:
+      return "ABS";
+    case ast_operator::RINT:
+      return "RINT";
+    case ast_operator::BIT_INVERT:
+      return "BIT_INVERT (~)";
+    case ast_operator::NOT:
+      return "NOT (!)";
+    case ast_operator::CAST_TO_INT64:
+      return "CAST_TO_INT64";
+    case ast_operator::CAST_TO_UINT64:
+      return "CAST_TO_UINT64";
+    case ast_operator::CAST_TO_FLOAT64:
+      return "CAST_TO_FLOAT64";
+    default:
+      return "UNKNOWN_OPERATOR";
+  }
+}
+
+/**
+ * @brief Get the string representation of a table_reference
+ */
+inline std::string table_reference_to_string(table_reference ref) {
+  switch (ref) {
+    case table_reference::LEFT:
+      return "LEFT";
+    case table_reference::RIGHT:
+      return "RIGHT";
+    case table_reference::OUTPUT:
+      return "OUTPUT";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+/**
+ * @brief Get the string representation of a cudf::type_id
+ */
+inline std::string type_id_to_string(cudf::type_id id) {
+  switch (id) {
+    case cudf::type_id::EMPTY:
+      return "EMPTY";
+    case cudf::type_id::INT8:
+      return "INT8";
+    case cudf::type_id::INT16:
+      return "INT16";
+    case cudf::type_id::INT32:
+      return "INT32";
+    case cudf::type_id::INT64:
+      return "INT64";
+    case cudf::type_id::UINT8:
+      return "UINT8";
+    case cudf::type_id::UINT16:
+      return "UINT16";
+    case cudf::type_id::UINT32:
+      return "UINT32";
+    case cudf::type_id::UINT64:
+      return "UINT64";
+    case cudf::type_id::FLOAT32:
+      return "FLOAT32";
+    case cudf::type_id::FLOAT64:
+      return "FLOAT64";
+    case cudf::type_id::BOOL8:
+      return "BOOL8";
+    case cudf::type_id::TIMESTAMP_DAYS:
+      return "TIMESTAMP_DAYS";
+    case cudf::type_id::TIMESTAMP_SECONDS:
+      return "TIMESTAMP_SECONDS";
+    case cudf::type_id::TIMESTAMP_MILLISECONDS:
+      return "TIMESTAMP_MILLISECONDS";
+    case cudf::type_id::TIMESTAMP_MICROSECONDS:
+      return "TIMESTAMP_MICROSECONDS";
+    case cudf::type_id::TIMESTAMP_NANOSECONDS:
+      return "TIMESTAMP_NANOSECONDS";
+    case cudf::type_id::DURATION_DAYS:
+      return "DURATION_DAYS";
+    case cudf::type_id::DURATION_SECONDS:
+      return "DURATION_SECONDS";
+    case cudf::type_id::DURATION_MILLISECONDS:
+      return "DURATION_MILLISECONDS";
+    case cudf::type_id::DURATION_MICROSECONDS:
+      return "DURATION_MICROSECONDS";
+    case cudf::type_id::DURATION_NANOSECONDS:
+      return "DURATION_NANOSECONDS";
+    case cudf::type_id::DICTIONARY32:
+      return "DICTIONARY32";
+    case cudf::type_id::STRING:
+      return "STRING";
+    case cudf::type_id::LIST:
+      return "LIST";
+    case cudf::type_id::DECIMAL32:
+      return "DECIMAL32";
+    case cudf::type_id::DECIMAL64:
+      return "DECIMAL64";
+    case cudf::type_id::DECIMAL128:
+      return "DECIMAL128";
+    case cudf::type_id::STRUCT:
+      return "STRUCT";
+    default:
+      return "UNKNOWN_TYPE";
+  }
+}
+
+/**
+ * @brief A visitor class that prints an AST expression tree
+ *
+ * Uses dynamic_cast (RTTI) to identify expression types since modifying
+ * the base expression class is not possible for a standalone file.
+ */
+class expression_printer {
+ public:
+  /**
+   * @brief Construct a new expression printer
+   *
+   * @param os Output stream to write to
+   * @param indent_str String to use for each level of indentation
+   */
+  explicit expression_printer(std::ostream& os, std::string indent_str = "  ")
+      : _os(os), _indent_str(std::move(indent_str)) {}
+
+  /**
+   * @brief Visit and print an expression tree
+   *
+   * @param expr The expression to print
+   * @param depth Current depth in the tree (for indentation)
+   * @return The index of this node in the visitation order
+   */
+  int visit(expression const& expr, int depth = 0) {
+    int current_index = _node_index++;
+
+    // Try each expression type using dynamic_cast
+    if (auto const* lit = dynamic_cast<literal const*>(&expr)) {
+      visit_literal(*lit, current_index, depth);
+    } else if (
+        auto const* col_ref = dynamic_cast<column_reference const*>(&expr)) {
+      visit_column_reference(*col_ref, current_index, depth);
+    } else if (auto const* op = dynamic_cast<operation const*>(&expr)) {
+      visit_operation(*op, current_index, depth);
+    } else if (
+        auto const* col_name =
+            dynamic_cast<column_name_reference const*>(&expr)) {
+      visit_column_name_reference(*col_name, current_index, depth);
+    } else {
+      print_indent(depth);
+      _os << "[" << current_index << "] UNKNOWN_EXPRESSION_TYPE\n";
+    }
+
+    return current_index;
+  }
+
+  /**
+   * @brief Reset the node index counter
+   */
+  void reset() {
+    _node_index = 0;
+  }
+
+  /**
+   * @brief Get the current node count
+   */
+  [[nodiscard]] int node_count() const {
+    return _node_index;
+  }
+
+ private:
+  std::ostream& _os;
+  std::string _indent_str;
+  int _node_index = 0;
+
+  void print_indent(int depth) {
+    for (int i = 0; i < depth; ++i) {
+      _os << _indent_str;
+    }
+  }
+
+  void visit_literal(literal const& expr, int index, int depth) {
+    print_indent(depth);
+    _os << "[" << index << "] LITERAL\n";
+
+    print_indent(depth + 1);
+    _os << "data_type: " << type_id_to_string(expr.get_data_type().id())
+        << "\n";
+
+    // Note: Cannot print the actual value without knowing the type at compile
+    // time and having device memory access. The scalar is on the device.
+    print_indent(depth + 1);
+    _os << "(value is stored on device, type-specific access required)\n";
+  }
+
+  void
+  visit_column_reference(column_reference const& expr, int index, int depth) {
+    print_indent(depth);
+    _os << "[" << index << "] COLUMN_REFERENCE\n";
+
+    print_indent(depth + 1);
+    _os << "column_index: " << expr.get_column_index() << "\n";
+
+    print_indent(depth + 1);
+    _os << "table_source: "
+        << table_reference_to_string(expr.get_table_source()) << "\n";
+  }
+
+  void visit_operation(operation const& expr, int index, int depth) {
+    print_indent(depth);
+    _os << "[" << index << "] OPERATION\n";
+
+    print_indent(depth + 1);
+    _os << "operator: " << ast_operator_to_string(expr.get_operator()) << "\n";
+
+    auto const& operands = expr.get_operands();
+    print_indent(depth + 1);
+    _os << "arity: " << operands.size() << "\n";
+
+    if (!operands.empty()) {
+      print_indent(depth + 1);
+      _os << "operands:\n";
+      for (size_t i = 0; i < operands.size(); ++i) {
+        print_indent(depth + 2);
+        _os << "operand[" << i << "]:\n";
+        visit(operands[i].get(), depth + 3);
+      }
+    }
+  }
+
+  void visit_column_name_reference(
+      column_name_reference const& expr,
+      int index,
+      int depth) {
+    print_indent(depth);
+    _os << "[" << index << "] COLUMN_NAME_REFERENCE\n";
+
+    print_indent(depth + 1);
+    _os << "column_name: \"" << expr.get_column_name() << "\"\n";
+  }
+};
+
+/**
+ * @brief Print an AST expression tree to an output stream
+ *
+ * @param expr The expression to print
+ * @param os Output stream (defaults to std::cout)
+ * @param indent_str Indentation string for each level
+ */
+inline void print_expression(
+    expression const& expr,
+    std::ostream& os = std::cout,
+    std::string const& indent_str = "  ") {
+  os << "=== AST Expression Tree ===\n";
+  expression_printer printer(os, indent_str);
+  printer.visit(expr);
+  os << "=== Total nodes: " << printer.node_count() << " ===\n";
+}
+
+/**
+ * @brief Convert an AST expression tree to a string
+ *
+ * @param expr The expression to convert
+ * @param indent_str Indentation string for each level
+ * @return String representation of the expression tree
+ */
+inline std::string expression_to_string(
+    expression const& expr,
+    std::string const& indent_str = "  ") {
+  std::ostringstream oss;
+  print_expression(expr, oss, indent_str);
+  return oss.str();
+}
+
+/**
+ * @brief A compact one-line representation of an expression
+ *
+ * Creates a more compact representation suitable for logging/debugging
+ */
+class compact_expression_printer {
+ public:
+  /**
+   * @brief Get a compact string representation of an expression
+   *
+   * @param expr The expression to represent
+   * @return Compact string representation
+   */
+  static std::string to_string(expression const& expr) {
+    return visit_impl(expr);
+  }
+
+ private:
+  static std::string visit_impl(expression const& expr) {
+    if (auto const* lit = dynamic_cast<literal const*>(&expr)) {
+      return "Literal(" + type_id_to_string(lit->get_data_type().id()) + ")";
+    }
+
+    if (auto const* col_ref = dynamic_cast<column_reference const*>(&expr)) {
+      return "Col(" + table_reference_to_string(col_ref->get_table_source()) +
+          "[" + std::to_string(col_ref->get_column_index()) + "])";
+    }
+
+    if (auto const* op = dynamic_cast<operation const*>(&expr)) {
+      auto const& operands = op->get_operands();
+      std::string result = ast_operator_to_string(op->get_operator()) + "(";
+      for (size_t i = 0; i < operands.size(); ++i) {
+        if (i > 0)
+          result += ", ";
+        result += visit_impl(operands[i].get());
+      }
+      result += ")";
+      return result;
+    }
+
+    if (auto const* col_name =
+            dynamic_cast<column_name_reference const*>(&expr)) {
+      return "ColName(\"" + col_name->get_column_name() + "\")";
+    }
+
+    return "Unknown";
+  }
+};
+
+/**
+ * @brief Get a compact one-line string representation of an expression
+ *
+ * @param expr The expression to represent
+ * @return Compact string representation
+ */
+inline std::string expression_to_compact_string(expression const& expr) {
+  return compact_expression_printer::to_string(expr);
+}
+
+/**
+ * @brief Print a compact one-line representation of an expression
+ *
+ * @param expr The expression to print
+ * @param os Output stream (defaults to std::cout)
+ */
+inline void print_expression_compact(
+    expression const& expr,
+    std::ostream& os = std::cout) {
+  os << expression_to_compact_string(expr) << "\n";
+}
+
+} // namespace ast
+} // namespace cudf
diff --git a/velox/experimental/cudf/expression/AstUtils.h b/velox/experimental/cudf/expression/AstUtils.h
new file mode 100644
index 00000000000..ee232588a18
--- /dev/null
+++ b/velox/experimental/cudf/expression/AstUtils.h
@@ -0,0 +1,226 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/experimental/cudf/CudfNoDefaults.h"
+
+#include "velox/expression/ConstantExpr.h"
+#include "velox/type/Type.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/SimpleVector.h"
+#include "velox/vector/VectorTypeUtils.h"
+
+#include <cudf/ast/expressions.hpp>
+#include <cudf/fixed_point/fixed_point.hpp>
+#include <cudf/scalar/scalar.hpp>
+#include <cudf/utilities/default_stream.hpp>
+
+namespace facebook::velox::cudf_velox {
+
+template <typename T>
+cudf::ast::literal makeLiteralFromScalar(
+    cudf::scalar& scalar,
+    const TypePtr& type) {
+  if constexpr (cudf::is_fixed_width<T>()) {
+    if (type->isDecimal()) {
+      if (type->kind() == TypeKind::BIGINT) {
+        using CudfScalarType = cudf::fixed_point_scalar<numeric::decimal64>;
+        return cudf::ast::literal{*static_cast<CudfScalarType*>(&scalar)};
+      }
+      if (type->kind() == TypeKind::HUGEINT) {
+        using CudfScalarType = cudf::fixed_point_scalar<numeric::decimal128>;
+        return cudf::ast::literal{*static_cast<CudfScalarType*>(&scalar)};
+      }
+      VELOX_UNREACHABLE(
+          "Invalid Decimal Type (bad TypeKind: {})", type->kind());
+    } else if (type->isIntervalDayTime()) {
+      using CudfDurationType = cudf::duration_ms;
+      if constexpr (std::is_same_v<T, CudfDurationType::rep>) {
+        using CudfScalarType = cudf::duration_scalar<CudfDurationType>;
+        return cudf::ast::literal{*static_cast<CudfScalarType*>(&scalar)};
+      }
+    } else if (type->isDate()) {
+      using CudfDateType = cudf::timestamp_D;
+      if constexpr (std::is_same_v<T, CudfDateType::rep>) {
+        using CudfScalarType = cudf::timestamp_scalar<CudfDateType>;
+        return cudf::ast::literal{*static_cast<CudfScalarType*>(&scalar)};
+      }
+    } else {
+      // Create a numeric scalar of type T, store it in the scalars vector,
+      // and use its reference in the literal expression.
+      using CudfScalarType = cudf::numeric_scalar<T>;
+      return cudf::ast::literal{*static_cast<CudfScalarType*>(&scalar)};
+    }
+    VELOX_FAIL("Unsupported base type for literal");
+  } else if (type->kind() == TypeKind::VARCHAR) {
+    return cudf::ast::literal{*static_cast<cudf::string_scalar*>(&scalar)};
+  } else {
+    // TODO for non-numeric types too.
+    VELOX_NYI(
+        "Non-numeric types not yet implemented for type {}", type->toString());
+  }
+}
+
+template <TypeKind kind>
+variant getVariant(const VectorPtr& vector, size_t atIndex = 0) {
+  using T = typename facebook::velox::KindToFlatVector<kind>::WrapperType;
+  if constexpr (!std::is_same_v<T, ComplexType>) {
+    return vector->as<SimpleVector<T>>()->valueAt(atIndex);
+  } else {
+    return Variant();
+  }
+}
+
+template <typename T>
+std::unique_ptr<cudf::scalar> makeScalarFromValue(
+    const TypePtr& type,
+    T value,
+    bool isNull,
+    std::optional<cudf::type_id> toType = std::nullopt) {
+  auto stream = cudf::get_default_stream(cudf::allow_default_stream);
+  auto mr = get_temp_mr();
+
+  // Scalars are constructed once at init time but later consumed on
+  // an arbitrary per-batch CUDA stream.  The underlying device_buffer
+  // is allocated with cudaMallocAsync on `stream`.  Without a sync
+  // the allocation may still be pending when a different stream reads
+  // the scalar, causing use-before-alloc.  Synchronising here is
+  // cheap (one-time cost per scalar) and guarantees the memory is
+  // available on every stream.
+
+  if constexpr (cudf::is_fixed_width<T>()) {
+    if (type->isDecimal()) {
+      // Velox DECIMAL scale is positive for fractional digits
+      // cuDF scale is negative for fractional digits
+      // @TODO check the bigger picture here!
+      if (type->kind() == TypeKind::BIGINT) {
+        auto const decimalType =
+            std::dynamic_pointer_cast<const ShortDecimalType>(type);
+        VELOX_CHECK(decimalType, "Invalid Decimal Type (failed dynamic_cast)");
+        auto const cudfScale = numeric::scale_type{-decimalType->scale()};
+        using CudfDecimalType = cudf::fixed_point_scalar<numeric::decimal64>;
+        auto scalar = std::make_unique<CudfDecimalType>(
+            value, cudfScale, !isNull, stream, mr);
+        stream.synchronize();
+        return scalar;
+      } else if (type->kind() == TypeKind::HUGEINT) {
+        auto const decimalType =
+            std::dynamic_pointer_cast<const LongDecimalType>(type);
+        VELOX_CHECK(decimalType, "Invalid Decimal Type (failed dynamic_cast)");
+        auto const cudfScale = numeric::scale_type{-decimalType->scale()};
+        using CudfDecimalType = cudf::fixed_point_scalar<numeric::decimal128>;
+        auto scalar = std::make_unique<CudfDecimalType>(
+            value, cudfScale, !isNull, stream, mr);
+        stream.synchronize();
+        return scalar;
+      }
+      VELOX_UNREACHABLE(
+          "Invalid Decimal Type (bad TypeKind: {})", type->kind());
+    } else if (type->isIntervalYearMonth()) {
+      VELOX_FAIL("Interval year month not supported");
+    } else if (type->isIntervalDayTime()) {
+      using CudfDurationType = cudf::duration_ms;
+      if constexpr (std::is_same_v<T, CudfDurationType::rep>) {
+        auto scalar = std::make_unique<cudf::duration_scalar<CudfDurationType>>(
+            value, !isNull, stream, mr);
+        stream.synchronize();
+        return scalar;
+      }
+    } else if (type->isDate()) {
+      using CudfDateType = cudf::timestamp_D;
+      if constexpr (std::is_same_v<T, CudfDateType::rep>) {
+        auto scalar = std::make_unique<cudf::timestamp_scalar<CudfDateType>>(
+            value, !isNull, stream, mr);
+        stream.synchronize();
+        return scalar;
+      }
+    } else if (toType.has_value()) {
+      if (toType == cudf::type_id::DURATION_DAYS) {
+        auto scalar = std::make_unique<cudf::duration_scalar<cudf::duration_D>>(
+            value, !isNull, stream, mr);
+        stream.synchronize();
+        return scalar;
+      }
+      VELOX_FAIL(
+          "Unsupported result type {}", static_cast<int32_t>(toType.value()));
+    } else {
+      auto scalar =
+          std::make_unique<cudf::numeric_scalar<T>>(value, !isNull, stream, mr);
+      stream.synchronize();
+      return scalar;
+    }
+    VELOX_FAIL("Unsupported fixed-width scalar type");
+  } else if constexpr (
+      std::is_same_v<T, StringView> || std::is_same_v<T, std::string_view> ||
+      std::is_same_v<T, std::string>) {
+    auto scalar = std::make_unique<cudf::string_scalar>(
+        std::string_view(value.data(), value.size()), !isNull, stream, mr);
+    stream.synchronize();
+    return scalar;
+  }
+  VELOX_NYI("Scalar creation not implemented for type {}", type->toString());
+}
+
+template <TypeKind Kind>
+static std::unique_ptr<cudf::scalar> createCudfScalar(
+    const velox::VectorPtr& value,
+    std::optional<cudf::type_id> toType = std::nullopt) {
+  using T = typename TypeTraits<Kind>::NativeType;
+  auto vector = value->as<velox::ConstantVector<T>>();
+  return makeScalarFromValue<T>(
+      vector->type(), vector->value(), vector->isNullAt(0), toType);
+}
+
+inline std::unique_ptr<cudf::scalar> makeScalarFromConstantExpr(
+    const std::shared_ptr<velox::exec::Expr>& expr,
+    std::optional<cudf::type_id> toType = std::nullopt) {
+  auto constExpr = std::dynamic_pointer_cast<velox::exec::ConstantExpr>(expr);
+  VELOX_CHECK_NOT_NULL(constExpr);
+  auto constValue = constExpr->value();
+  return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+      createCudfScalar, constValue->typeKind(), constValue, toType);
+}
+
+template <TypeKind kind>
+cudf::ast::literal makeScalarAndLiteral(
+    const TypePtr& type,
+    const variant& var,
+    bool isNull,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars) {
+  using T = typename TypeTraits<kind>::NativeType;
+  if constexpr (cudf::is_fixed_width<T>() || kind == TypeKind::VARCHAR) {
+    if (isNull) {
+      auto scalar = makeScalarFromValue<T>(type, T{}, true);
+      scalars.emplace_back(std::move(scalar));
+      return makeLiteralFromScalar<T>(*(scalars.back()), type);
+    }
+    auto value = var.value<T>();
+    auto scalar = makeScalarFromValue(type, value, false);
+    scalars.emplace_back(std::move(scalar));
+    return makeLiteralFromScalar<T>(*(scalars.back()), type);
+  }
+  VELOX_NYI("Scalar creation not implemented for type {}", type->toString());
+}
+
+template <TypeKind kind>
+cudf::ast::literal makeScalarAndLiteral(
+    const TypePtr& type,
+    const variant& var,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars) {
+  return makeScalarAndLiteral<kind>(type, var, false, scalars);
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/CMakeLists.txt b/velox/experimental/cudf/expression/CMakeLists.txt
new file mode 100644
index 00000000000..078a0752065
--- /dev/null
+++ b/velox/experimental/cudf/expression/CMakeLists.txt
@@ -0,0 +1,36 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_library(
+  velox_cudf_expression
+  AstExpression.cpp
+  DecimalExpressionKernels.cpp
+  DecimalExpressionKernels.cu
+  DecimalTypeCheck.cpp
+  ExpressionEvaluator.cpp
+  JitExpression.cpp
+  PrestoFunctions.cpp
+  SparkFunctions.cpp
+  SubfieldFiltersToAst.cpp
+)
+
+target_link_libraries(
+  velox_cudf_expression
+  PUBLIC cudf::cudf
+  PRIVATE arrow velox_common_base velox_cudf_vector velox_exception
+)
+
+target_compile_options(velox_cudf_expression PRIVATE -Wno-missing-field-initializers)
+
+set_target_properties(velox_cudf_expression PROPERTIES CUDA_STANDARD 20 CUDA_STANDARD_REQUIRED ON)
diff --git a/velox/experimental/cudf/expression/DecimalExpressionKernels.cpp b/velox/experimental/cudf/expression/DecimalExpressionKernels.cpp
new file mode 100644
index 00000000000..84e4e72eb66
--- /dev/null
+++ b/velox/experimental/cudf/expression/DecimalExpressionKernels.cpp
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/cudf/expression/AstPrinter.h"
+#include "velox/experimental/cudf/expression/DecimalExpressionKernels.h"
+
+#include "velox/common/base/Exceptions.h"
+
+#include <cudf/binaryop.hpp>
+#include <cudf/copying.hpp>
+#include <cudf/scalar/scalar_factories.hpp>
+
+namespace facebook::velox::cudf_velox {
+
+// Scatters null values to positions where the divisor is zero.
+// Returns a new column with nulls at zero-divisor positions.
+std::unique_ptr<cudf::column> scatterNullsAtZeroDivisor(
+    std::unique_ptr<cudf::column> result,
+    const cudf::column_view& divisor,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  // Create zero scalar for comparison and null scalar for scattering.
+  std::unique_ptr<cudf::scalar> zeroScalar;
+  std::unique_ptr<cudf::scalar> nullScalar;
+  auto divisorScale = numeric::scale_type{divisor.type().scale()};
+  auto outputScale = numeric::scale_type{result->type().scale()};
+
+  if (divisor.type().id() == cudf::type_id::DECIMAL64) {
+    zeroScalar = cudf::make_fixed_point_scalar<numeric::decimal64>(
+        0, divisorScale, stream, mr);
+    nullScalar = cudf::make_fixed_point_scalar<numeric::decimal64>(
+        0, outputScale, stream, mr);
+  } else if (divisor.type().id() == cudf::type_id::DECIMAL128) {
+    zeroScalar = cudf::make_fixed_point_scalar<numeric::decimal128>(
+        0, divisorScale, stream, mr);
+    nullScalar = cudf::make_fixed_point_scalar<numeric::decimal128>(
+        0, outputScale, stream, mr);
+  } else {
+    VELOX_FAIL(
+        "Unsupported decimal type {} for division",
+        cudf::ast::type_id_to_string(divisor.type().id()));
+  }
+  nullScalar->set_valid_async(false, stream);
+
+  // Create boolean column: TRUE where divisor == 0, FALSE otherwise.
+  auto divisorIsZero = cudf::binary_operation(
+      divisor,
+      *zeroScalar,
+      cudf::binary_operator::EQUAL,
+      cudf::data_type{cudf::type_id::BOOL8},
+      stream,
+      mr);
+
+  // Scatter nulls where divisor is zero.
+  return cudf::copy_if_else(
+      *nullScalar, *result, divisorIsZero->view(), stream, mr);
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/DecimalExpressionKernels.cu b/velox/experimental/cudf/expression/DecimalExpressionKernels.cu
new file mode 100644
index 00000000000..cd9291ff493
--- /dev/null
+++ b/velox/experimental/cudf/expression/DecimalExpressionKernels.cu
@@ -0,0 +1,333 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/cudf/expression/DecimalExpressionKernels.h"
+
+#include <cudf/binaryop.hpp>
+#include <cudf/column/column_factories.hpp>
+#include <cudf/copying.hpp>
+#include <cudf/fixed_point/fixed_point.hpp>
+#include <cudf/null_mask.hpp>
+#include <cudf/scalar/scalar.hpp>
+#include <cudf/scalar/scalar_factories.hpp>
+#include <cudf/table/table_view.hpp>
+#include <cudf/types.hpp>
+#include <cudf/utilities/error.hpp>
+#include <cudf/utilities/memory_resource.hpp>
+
+#include <cub/device/device_for.cuh>
+#include <thrust/iterator/counting_iterator.h>
+
+#include <cstdint>
+
+namespace facebook::velox::cudf_velox {
+namespace {
+
+template <typename OutT>
+__device__ OutT
+decimalDivideImpl(__int128_t numerator, __int128_t denom, __int128_t scale) {
+  if (denom == 0) {
+    return OutT{0};
+  }
+  int sign = 1;
+  if (numerator < 0) {
+    numerator = -numerator;
+    sign = -sign;
+  }
+  if (denom < 0) {
+    denom = -denom;
+    sign = -sign;
+  }
+  __int128_t scaled = numerator * scale;
+  __int128_t quotient = scaled / denom;
+  __int128_t remainder = scaled % denom;
+  if (remainder * 2 >= denom) {
+    ++quotient;
+  }
+  if (sign < 0) {
+    quotient = -quotient;
+  }
+  return static_cast<OutT>(quotient);
+}
+
+inline __int128_t pow10Int128(int32_t exp) {
+  __int128_t value = 1;
+  for (int32_t i = 0; i < exp; ++i) {
+    value *= 10;
+  }
+  return value;
+}
+
+template <typename InT, typename OutT>
+struct DivideFunctor {
+  const InT* lhs;
+  const InT* rhs;
+  OutT* out;
+  __int128_t scale;
+
+  __device__ void operator()(int32_t idx) const {
+    out[idx] = decimalDivideImpl<OutT>(lhs[idx], rhs[idx], scale);
+  }
+};
+
+template <typename InColT, typename OutT>
+struct DivideLhsScalarFunctor {
+  __int128_t lhsValue;
+  const InColT* rhs;
+  OutT* out;
+  __int128_t scale;
+
+  __device__ void operator()(int32_t idx) const {
+    out[idx] = decimalDivideImpl<OutT>(lhsValue, rhs[idx], scale);
+  }
+};
+
+template <typename InColT, typename OutT>
+struct DivideRhsScalarFunctor {
+  const InColT* lhs;
+  __int128_t rhsValue;
+  OutT* out;
+  __int128_t scale;
+
+  __device__ void operator()(int32_t idx) const {
+    out[idx] = decimalDivideImpl<OutT>(lhs[idx], rhsValue, scale);
+  }
+};
+
+template <typename InT, typename OutT>
+void launchDivideKernel(
+    const cudf::column_view& lhs,
+    const cudf::column_view& rhs,
+    cudf::mutable_column_view out,
+    int32_t aRescale,
+    rmm::cuda_stream_view stream) {
+  if (lhs.size() == 0) {
+    return;
+  }
+  DivideFunctor<InT, OutT> op{
+      lhs.data<InT>(),
+      rhs.data<InT>(),
+      out.data<OutT>(),
+      pow10Int128(aRescale)};
+  cub::DeviceFor::ForEachN(
+      thrust::counting_iterator<int32_t>(0), lhs.size(), op, stream.value());
+}
+
+template <typename InColT, typename OutT>
+void launchDivideKernelLhsScalar(
+    __int128_t lhsValue,
+    const cudf::column_view& rhs,
+    cudf::mutable_column_view out,
+    int32_t aRescale,
+    rmm::cuda_stream_view stream) {
+  if (rhs.size() == 0) {
+    return;
+  }
+  DivideLhsScalarFunctor<InColT, OutT> op{
+      lhsValue, rhs.data<InColT>(), out.data<OutT>(), pow10Int128(aRescale)};
+  cub::DeviceFor::ForEachN(
+      thrust::counting_iterator<int32_t>(0), rhs.size(), op, stream.value());
+}
+
+template <typename InColT, typename OutT>
+void launchDivideKernelRhsScalar(
+    const cudf::column_view& lhs,
+    __int128_t rhsValue,
+    cudf::mutable_column_view out,
+    int32_t aRescale,
+    rmm::cuda_stream_view stream) {
+  if (lhs.size() == 0) {
+    return;
+  }
+  DivideRhsScalarFunctor<InColT, OutT> op{
+      lhs.data<InColT>(), rhsValue, out.data<OutT>(), pow10Int128(aRescale)};
+  cub::DeviceFor::ForEachN(
+      thrust::counting_iterator<int32_t>(0), lhs.size(), op, stream.value());
+}
+
+__int128_t getDecimalScalarValue(
+    const cudf::scalar& s,
+    rmm::cuda_stream_view stream) {
+  if (s.type().id() == cudf::type_id::DECIMAL64) {
+    auto const& dec =
+        static_cast<cudf::fixed_point_scalar<numeric::decimal64> const&>(s);
+    return static_cast<__int128_t>(static_cast<int64_t>(dec.value(stream)));
+  }
+  auto const& dec =
+      static_cast<cudf::fixed_point_scalar<numeric::decimal128> const&>(s);
+  return static_cast<__int128_t>(dec.value(stream));
+}
+
+/// Column of \p outputType with \p size rows, all null (e.g. NULL scalar
+/// operand).
+std::unique_ptr<cudf::column> makeAllNullDecimalColumn(
+    cudf::data_type outputType,
+    cudf::size_type size,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  if (size == 0) {
+    return cudf::make_empty_column(outputType);
+  }
+  return cudf::make_fixed_width_column(
+      outputType, size, cudf::mask_state::ALL_NULL, stream, mr);
+}
+
+} // namespace
+
+std::unique_ptr<cudf::column> decimalDivide(
+    const cudf::column_view& lhs,
+    const cudf::column_view& rhs,
+    cudf::data_type outputType,
+    int32_t aRescale,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  CUDF_EXPECTS(lhs.size() == rhs.size(), "Decimal divide requires equal sizes");
+  CUDF_EXPECTS(
+      lhs.type().id() == rhs.type().id(),
+      "Decimal divide requires matching input types");
+  CUDF_EXPECTS(
+      aRescale >= 0, "Decimal divide requires non-negative rescale factor");
+
+  // Combine input null masks (lhs and rhs nulls).
+  auto [nullMask, nullCount] =
+      cudf::bitmask_and(cudf::table_view({lhs, rhs}), stream, mr);
+
+  // Create output column with input null mask and perform division.
+  auto out = cudf::make_fixed_width_column(
+      outputType, lhs.size(), std::move(nullMask), nullCount, stream, mr);
+
+  if (lhs.type().id() == cudf::type_id::DECIMAL64) {
+    if (outputType.id() == cudf::type_id::DECIMAL64) {
+      launchDivideKernel<int64_t, int64_t>(
+          lhs, rhs, out->mutable_view(), aRescale, stream);
+    } else {
+      CUDF_EXPECTS(
+          outputType.id() == cudf::type_id::DECIMAL128,
+          "Unexpected output type for decimal divide");
+      launchDivideKernel<int64_t, __int128_t>(
+          lhs, rhs, out->mutable_view(), aRescale, stream);
+    }
+  } else {
+    CUDF_EXPECTS(
+        lhs.type().id() == cudf::type_id::DECIMAL128,
+        "Unsupported input type for decimal divide");
+    CUDF_EXPECTS(
+        outputType.id() == cudf::type_id::DECIMAL128,
+        "Unexpected output type for decimal divide");
+    launchDivideKernel<__int128_t, __int128_t>(
+        lhs, rhs, out->mutable_view(), aRescale, stream);
+  }
+
+  // Scatter nulls where divisor is zero.
+  return scatterNullsAtZeroDivisor(std::move(out), rhs, stream, mr);
+}
+
+std::unique_ptr<cudf::column> decimalDivide(
+    const cudf::column_view& lhs,
+    const cudf::scalar& rhs,
+    cudf::data_type outputType,
+    int32_t aRescale,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  CUDF_EXPECTS(
+      aRescale >= 0, "Decimal divide requires non-negative rescale factor");
+
+  if (!rhs.is_valid(stream)) {
+    return makeAllNullDecimalColumn(outputType, lhs.size(), stream, mr);
+  }
+
+  auto nullMask = cudf::copy_bitmask(lhs, stream, mr);
+  auto nullCount = lhs.null_count();
+  auto out = cudf::make_fixed_width_column(
+      outputType, lhs.size(), std::move(nullMask), nullCount, stream, mr);
+
+  auto rhsValue = getDecimalScalarValue(rhs, stream);
+
+  if (lhs.type().id() == cudf::type_id::DECIMAL64) {
+    if (outputType.id() == cudf::type_id::DECIMAL64) {
+      launchDivideKernelRhsScalar<int64_t, int64_t>(
+          lhs, rhsValue, out->mutable_view(), aRescale, stream);
+    } else {
+      CUDF_EXPECTS(
+          outputType.id() == cudf::type_id::DECIMAL128,
+          "Unexpected output type for decimal divide");
+      launchDivideKernelRhsScalar<int64_t, __int128_t>(
+          lhs, rhsValue, out->mutable_view(), aRescale, stream);
+    }
+  } else {
+    CUDF_EXPECTS(
+        lhs.type().id() == cudf::type_id::DECIMAL128,
+        "Unsupported input type for decimal divide");
+    CUDF_EXPECTS(
+        outputType.id() == cudf::type_id::DECIMAL128,
+        "Unexpected output type for decimal divide");
+    launchDivideKernelRhsScalar<__int128_t, __int128_t>(
+        lhs, rhsValue, out->mutable_view(), aRescale, stream);
+  }
+
+  return out;
+}
+
+std::unique_ptr<cudf::column> decimalDivide(
+    const cudf::scalar& lhs,
+    const cudf::column_view& rhs,
+    cudf::data_type outputType,
+    int32_t aRescale,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  CUDF_EXPECTS(
+      aRescale >= 0, "Decimal divide requires non-negative rescale factor");
+
+  if (!lhs.is_valid(stream)) {
+    return makeAllNullDecimalColumn(outputType, rhs.size(), stream, mr);
+  }
+
+  // Copy rhs null mask.
+  auto nullMask = cudf::copy_bitmask(rhs, stream, mr);
+  auto nullCount = rhs.null_count();
+
+  // Create output column and perform division.
+  auto out = cudf::make_fixed_width_column(
+      outputType, rhs.size(), std::move(nullMask), nullCount, stream, mr);
+
+  auto lhsValue = getDecimalScalarValue(lhs, stream);
+
+  if (rhs.type().id() == cudf::type_id::DECIMAL64) {
+    if (outputType.id() == cudf::type_id::DECIMAL64) {
+      launchDivideKernelLhsScalar<int64_t, int64_t>(
+          lhsValue, rhs, out->mutable_view(), aRescale, stream);
+    } else {
+      CUDF_EXPECTS(
+          outputType.id() == cudf::type_id::DECIMAL128,
+          "Unexpected output type for decimal divide");
+      launchDivideKernelLhsScalar<int64_t, __int128_t>(
+          lhsValue, rhs, out->mutable_view(), aRescale, stream);
+    }
+  } else {
+    CUDF_EXPECTS(
+        rhs.type().id() == cudf::type_id::DECIMAL128,
+        "Unsupported input type for decimal divide");
+    CUDF_EXPECTS(
+        outputType.id() == cudf::type_id::DECIMAL128,
+        "Unexpected output type for decimal divide");
+    launchDivideKernelLhsScalar<__int128_t, __int128_t>(
+        lhsValue, rhs, out->mutable_view(), aRescale, stream);
+  }
+
+  // Scatter nulls where divisor is zero.
+  return scatterNullsAtZeroDivisor(std::move(out), rhs, stream, mr);
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/DecimalExpressionKernels.h b/velox/experimental/cudf/expression/DecimalExpressionKernels.h
new file mode 100644
index 00000000000..d7576ccdcf0
--- /dev/null
+++ b/velox/experimental/cudf/expression/DecimalExpressionKernels.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cudf/column/column.hpp>
+#include <cudf/column/column_view.hpp>
+#include <cudf/scalar/scalar.hpp>
+#include <cudf/types.hpp>
+
+#include <rmm/cuda_stream_view.hpp>
+
+#include <memory>
+
+namespace facebook::velox::cudf_velox {
+
+std::unique_ptr<cudf::column> decimalDivide(
+    const cudf::column_view& lhs,
+    const cudf::column_view& rhs,
+    cudf::data_type outputType,
+    int32_t aRescale,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr);
+
+std::unique_ptr<cudf::column> decimalDivide(
+    const cudf::column_view& lhs,
+    const cudf::scalar& rhs,
+    cudf::data_type outputType,
+    int32_t aRescale,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr);
+
+std::unique_ptr<cudf::column> decimalDivide(
+    const cudf::scalar& lhs,
+    const cudf::column_view& rhs,
+    cudf::data_type outputType,
+    int32_t aRescale,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr);
+
+// Helper function to scatter nulls at zero-divisor positions.
+// Moved to .cpp file to allow use of VELOX_FAIL (incompatible with nvcc).
+std::unique_ptr<cudf::column> scatterNullsAtZeroDivisor(
+    std::unique_ptr<cudf::column> result,
+    const cudf::column_view& divisor,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr);
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/DecimalTypeCheck.cpp b/velox/experimental/cudf/expression/DecimalTypeCheck.cpp
new file mode 100644
index 00000000000..28e70d59631
--- /dev/null
+++ b/velox/experimental/cudf/expression/DecimalTypeCheck.cpp
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/expression/DecimalTypeCheck.h"
+
+namespace facebook::velox::cudf_velox {
+
+bool isOfDecimalType(const std::shared_ptr<velox::exec::Expr>& expr) {
+  return expr && expr->type() && expr->type()->isDecimal();
+}
+
+bool containsDecimalType(
+    const std::shared_ptr<velox::exec::Expr>& expr,
+    const bool deep) {
+  // check output type
+  if (isOfDecimalType(expr)) {
+    return true;
+  }
+  if (deep) {
+    // check recursively
+    for (const auto& input : expr->inputs()) {
+      if (containsDecimalType(input, true)) {
+        return true;
+      }
+    }
+  } else {
+    // only check immediate inputs
+    for (const auto& input : expr->inputs()) {
+      if (isOfDecimalType(input)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/connectors/hive/HivePartitionUtil.h b/velox/experimental/cudf/expression/DecimalTypeCheck.h
similarity index 69%
rename from velox/connectors/hive/HivePartitionUtil.h
rename to velox/experimental/cudf/expression/DecimalTypeCheck.h
index a1047869b80..5f58d8212e3 100644
--- a/velox/connectors/hive/HivePartitionUtil.h
+++ b/velox/experimental/cudf/expression/DecimalTypeCheck.h
@@ -15,12 +15,12 @@
  */
 #pragma once
 
-#include "velox/vector/ComplexVector.h"
+#include "velox/expression/Expr.h"
 
-namespace facebook::velox::connector::hive {
+namespace facebook::velox::cudf_velox {
 
-std::vector<std::pair<std::string, std::string>> extractPartitionKeyValues(
-    const RowVectorPtr& partitionsVector,
-    vector_size_t row);
+bool containsDecimalType(
+    const std::shared_ptr<velox::exec::Expr>& expr,
+    const bool deep);
 
-} // namespace facebook::velox::connector::hive
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/ExpressionEvaluator.cpp b/velox/experimental/cudf/expression/ExpressionEvaluator.cpp
new file mode 100644
index 00000000000..68c6bd6a739
--- /dev/null
+++ b/velox/experimental/cudf/expression/ExpressionEvaluator.cpp
@@ -0,0 +1,2468 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/cudf/exec/Validation.h"
+#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+#include "velox/experimental/cudf/expression/AstUtils.h"
+#include "velox/experimental/cudf/expression/DecimalExpressionKernels.h"
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/expression/ConstantExpr.h"
+#include "velox/expression/FieldReference.h"
+#include "velox/expression/FunctionSignature.h"
+#include "velox/expression/SignatureBinder.h"
+#include "velox/type/DecimalUtil.h"
+#include "velox/type/Type.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/ConstantVector.h"
+
+#include <cudf/aggregation.hpp>
+#include <cudf/binaryop.hpp>
+#include <cudf/column/column_factories.hpp>
+#include <cudf/copying.hpp>
+#include <cudf/datetime.hpp>
+#include <cudf/fixed_point/fixed_point.hpp>
+#include <cudf/hashing.hpp>
+#include <cudf/lists/count_elements.hpp>
+#include <cudf/null_mask.hpp>
+#include <cudf/reduction.hpp>
+#include <cudf/replace.hpp>
+#include <cudf/round.hpp>
+#include <cudf/scalar/scalar.hpp>
+#include <cudf/scalar/scalar_factories.hpp>
+#include <cudf/strings/attributes.hpp>
+#include <cudf/strings/case.hpp>
+#include <cudf/strings/combine.hpp>
+#include <cudf/strings/contains.hpp>
+#include <cudf/strings/find.hpp>
+#include <cudf/strings/replace.hpp>
+#include <cudf/strings/slice.hpp>
+#include <cudf/strings/split/split.hpp>
+#include <cudf/strings/string_view.hpp>
+#include <cudf/strings/strings_column_view.hpp>
+#include <cudf/table/table.hpp>
+#include <cudf/transform.hpp>
+#include <cudf/types.hpp>
+#include <cudf/unary.hpp>
+#include <cudf/utilities/traits.hpp>
+
+#include <rmm/device_uvector.hpp>
+
+#include <memory>
+
+namespace facebook::velox::cudf_velox {
+namespace {
+
+bool decimalScalarIsZero(
+    const cudf::scalar& scalar,
+    rmm::cuda_stream_view stream) {
+  if (!scalar.is_valid(stream)) {
+    return false;
+  }
+  if (scalar.type().id() == cudf::type_id::DECIMAL64) {
+    auto const& dec =
+        static_cast<cudf::fixed_point_scalar<numeric::decimal64> const&>(
+            scalar);
+    return dec.value(stream) == 0;
+  }
+  if (scalar.type().id() == cudf::type_id::DECIMAL128) {
+    auto const& dec =
+        static_cast<cudf::fixed_point_scalar<numeric::decimal128> const&>(
+            scalar);
+    return dec.value(stream) == 0;
+  }
+  return false;
+}
+
+bool hasDecimalZero(
+    const cudf::column_view& col,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  if (col.is_empty()) {
+    return false;
+  }
+  std::unique_ptr<cudf::scalar> zero;
+  auto scale = numeric::scale_type{col.type().scale()};
+  if (col.type().id() == cudf::type_id::DECIMAL64) {
+    zero =
+        cudf::make_fixed_point_scalar<numeric::decimal64>(0, scale, stream, mr);
+  } else if (col.type().id() == cudf::type_id::DECIMAL128) {
+    zero = cudf::make_fixed_point_scalar<numeric::decimal128>(
+        0, scale, stream, mr);
+  } else {
+    return false;
+  }
+
+  auto equals = cudf::binary_operation(
+      col,
+      *zero,
+      cudf::binary_operator::EQUAL,
+      cudf::data_type{cudf::type_id::BOOL8},
+      stream,
+      mr);
+  auto anyAgg = cudf::make_any_aggregation<cudf::reduce_aggregation>();
+  auto anyScalar = cudf::reduce(
+      equals->view(),
+      *anyAgg,
+      cudf::data_type{cudf::type_id::BOOL8},
+      stream,
+      mr);
+  auto const& boolScalar =
+      static_cast<cudf::numeric_scalar<bool> const&>(*anyScalar);
+  return boolScalar.is_valid(stream) && boolScalar.value(stream);
+}
+
+std::unique_ptr<cudf::scalar> castDecimalScalar(
+    const cudf::scalar& src,
+    cudf::data_type targetType,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  if (!src.is_valid(stream)) {
+    VELOX_CHECK(
+        targetType.id() == cudf::type_id::DECIMAL64 ||
+            targetType.id() == cudf::type_id::DECIMAL128,
+        "castDecimalScalar: target must be DECIMAL64 or DECIMAL128");
+    if (targetType.id() == cudf::type_id::DECIMAL128) {
+      return std::make_unique<cudf::fixed_point_scalar<numeric::decimal128>>(
+          0, numeric::scale_type{targetType.scale()}, false, stream, mr);
+    }
+    return std::make_unique<cudf::fixed_point_scalar<numeric::decimal64>>(
+        0, numeric::scale_type{targetType.scale()}, false, stream, mr);
+  }
+
+  __int128_t rep;
+  if (src.type().id() == cudf::type_id::DECIMAL64) {
+    auto const& dec =
+        static_cast<cudf::fixed_point_scalar<numeric::decimal64> const&>(src);
+    rep = static_cast<int64_t>(dec.value(stream));
+  } else {
+    auto const& dec =
+        static_cast<cudf::fixed_point_scalar<numeric::decimal128> const&>(src);
+    rep = static_cast<__int128_t>(dec.value(stream));
+  }
+
+  int32_t scaleDiff = src.type().scale() - targetType.scale();
+  if (scaleDiff > 0) {
+    for (int32_t i = 0; i < scaleDiff; ++i) {
+      rep *= 10;
+    }
+  } else if (scaleDiff < 0) {
+    for (int32_t i = 0; i < -scaleDiff; ++i) {
+      rep /= 10;
+    }
+  }
+
+  if (targetType.id() == cudf::type_id::DECIMAL128) {
+    return cudf::make_fixed_point_scalar<numeric::decimal128>(
+        rep, numeric::scale_type{targetType.scale()}, stream, mr);
+  }
+  return cudf::make_fixed_point_scalar<numeric::decimal64>(
+      static_cast<int64_t>(rep),
+      numeric::scale_type{targetType.scale()},
+      stream,
+      mr);
+}
+
+struct CudfExpressionEvaluatorEntry {
+  int priority;
+  CudfExpressionEvaluatorCanEvaluate canEvaluate;
+  CudfExpressionEvaluatorCreate create;
+};
+
+static std::unordered_map<std::string, CudfExpressionEvaluatorEntry>&
+getCudfExpressionEvaluatorRegistry() {
+  static std::unordered_map<std::string, CudfExpressionEvaluatorEntry> registry;
+  return registry;
+}
+
+static void ensureBuiltinExpressionEvaluatorsRegistered() {
+  static bool registered = false;
+  if (registered) {
+    return;
+  }
+
+  // Default priority for function evaluator
+  const int kFunctionPriority = 50;
+
+  // Function evaluator
+  registerCudfExpressionEvaluator(
+      "function",
+      kFunctionPriority,
+      [](std::shared_ptr<velox::exec::Expr> expr) {
+        return FunctionExpression::canEvaluate(std::move(expr));
+      },
+      [](std::shared_ptr<velox::exec::Expr> expr, const RowTypePtr& row) {
+        return FunctionExpression::create(std::move(expr), row);
+      },
+      /*overwrite=*/false);
+
+  registered = true;
+}
+
+} // namespace
+
+bool registerCudfExpressionEvaluator(
+    const std::string& name,
+    int priority,
+    CudfExpressionEvaluatorCanEvaluate canEvaluate,
+    CudfExpressionEvaluatorCreate create,
+    bool overwrite) {
+  auto& registry = getCudfExpressionEvaluatorRegistry();
+  if (!overwrite && registry.find(name) != registry.end()) {
+    return false;
+  }
+  registry[name] = CudfExpressionEvaluatorEntry{
+      priority, std::move(canEvaluate), std::move(create)};
+  return true;
+}
+
+std::unordered_map<std::string, std::vector<CudfFunctionSpec>>&
+getCudfFunctionRegistry() {
+  static std::unordered_map<std::string, std::vector<CudfFunctionSpec>>
+      registry;
+  return registry;
+}
+
+namespace {
+
+static bool matchCallAgainstSignatures(
+    const velox::exec::Expr& call,
+    const std::vector<exec::FunctionSignaturePtr>& sigs) {
+  const auto n = call.inputs().size();
+  std::vector<TypePtr> argTypes;
+  argTypes.reserve(n);
+  for (const auto& in : call.inputs()) {
+    argTypes.push_back(in->type());
+  }
+  for (const auto& sig : sigs) {
+    exec::SignatureBinder binder(*sig, argTypes, TypeCoercer::defaults());
+    if (!binder.tryBind()) {
+      continue;
+    }
+    // binder does not confirm whether positional arguments are
+    // constants(scalars) as expected. we have to check manually
+    const auto& constArgs = sig->constantArguments();
+    const size_t fixed = std::min(constArgs.size(), n);
+    bool ok = true;
+    for (size_t i = 0; i < fixed; ++i) {
+      if (constArgs[i] && call.inputs()[i]->name() != "literal") {
+        ok = false;
+        break;
+      }
+    }
+    if (!ok) {
+      continue;
+    }
+    return true;
+  }
+  return false;
+}
+
+void mergeSecondaryNullsIntoResult(
+    cudf::column& result,
+    cudf::column_view secondaryColumn,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  // cuDF string pattern predicates already propagate input nulls to the result.
+  // Only merge the secondary-input nulls back when they are present so Velox
+  // CPU null propagation semantics are preserved without extra mask work unless
+  // it is required.
+  if (!secondaryColumn.has_nulls()) {
+    return;
+  }
+
+  if (!result.nullable()) {
+    result.set_null_mask(
+        cudf::copy_bitmask(secondaryColumn, stream, mr),
+        secondaryColumn.null_count());
+    return;
+  }
+
+  std::vector<cudf::bitmask_type const*> masks{
+      result.view().null_mask(),
+      secondaryColumn.null_mask(),
+  };
+  std::vector<cudf::size_type> beginBits{0, secondaryColumn.offset()};
+  auto [nullMask, nullCount] =
+      cudf::bitmask_and(masks, beginBits, result.size(), stream, mr);
+  result.set_null_mask(std::move(nullMask), nullCount);
+}
+
+} // namespace
+
+class SplitFunction : public CudfFunction {
+ public:
+  SplitFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    using velox::exec::ConstantExpr;
+
+    auto delimiterExpr =
+        std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[1]);
+    VELOX_CHECK_NOT_NULL(delimiterExpr, "split delimiter must be a constant");
+    delimiter_ = delimiterExpr->value()->toString(0);
+
+    auto limitExpr =
+        std::dynamic_pointer_cast<velox::exec::ConstantExpr>(expr->inputs()[2]);
+    VELOX_CHECK_NOT_NULL(limitExpr, "split limit must be a constant");
+    maxSplitCount_ = std::stoll(limitExpr->value()->toString(0));
+
+    // Presto specifies maxSplitCount as the maximum size of the returned array
+    // while cuDF understands the parameter as how many splits can it perform.
+    maxSplitCount_ -= 1;
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    auto inputCol = asView(inputColumns[0]);
+    cudf::string_scalar delimiterScalar(delimiter_, true, stream, mr);
+    return cudf::strings::split_record(
+        inputCol, delimiterScalar, maxSplitCount_, stream, mr);
+  };
+
+ private:
+  std::string delimiter_;
+  cudf::size_type maxSplitCount_;
+};
+
+class CastFunction : public CudfFunction {
+ public:
+  CastFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    VELOX_CHECK_EQ(expr->inputs().size(), 1, "cast expects exactly 1 input");
+
+    targetCudfType_ = cudf_velox::veloxToCudfDataType(expr->type());
+    auto sourceType =
+        cudf_velox::veloxToCudfDataType(expr->inputs()[0]->type());
+    VELOX_CHECK(
+        cudf::is_supported_cast(sourceType, targetCudfType_),
+        "Cast from {} to {} is not supported",
+        expr->inputs()[0]->type()->toString(),
+        expr->type()->toString());
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    auto inputCol = asView(inputColumns[0]);
+    return cudf::cast(inputCol, targetCudfType_, stream, mr);
+  }
+
+ private:
+  cudf::data_type targetCudfType_;
+};
+
+class CardinalityFunction : public CudfFunction {
+ public:
+  CardinalityFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    // Cardinality doesn't need any pre-computed scalars, just validates input
+    // count
+    VELOX_CHECK_EQ(
+        expr->inputs().size(), 1, "cardinality expects exactly 1 input");
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    auto inputCol = asView(inputColumns[0]);
+    return cudf::lists::count_elements(inputCol, stream, mr);
+  }
+};
+
+class RoundFunction : public CudfFunction {
+ public:
+  explicit RoundFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    const auto argSize = expr->inputs().size();
+    VELOX_CHECK(argSize >= 1 && argSize <= 2, "round expects 1 or 2 inputs");
+    VELOX_CHECK_NULL(
+        std::dynamic_pointer_cast<exec::ConstantExpr>(expr->inputs()[0]),
+        "round expects first column is not literal");
+    if (argSize == 2) {
+      auto scaleExpr =
+          std::dynamic_pointer_cast<exec::ConstantExpr>(expr->inputs()[1]);
+      VELOX_CHECK_NOT_NULL(scaleExpr, "round scale must be a constant");
+      scale_ = scaleExpr->value()->as<SimpleVector<int32_t>>()->valueAt(0);
+    }
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    return cudf::round_decimal(
+        asView(inputColumns[0]),
+        scale_,
+        cudf::rounding_method::HALF_UP,
+        stream,
+        mr);
+    ;
+  }
+
+ private:
+  int32_t scale_ = 0;
+};
+
+class BinaryFunction : public CudfFunction {
+ public:
+  BinaryFunction(
+      const std::shared_ptr<velox::exec::Expr>& expr,
+      cudf::binary_operator op)
+      : op_(op), type_(cudf_velox::veloxToCudfDataType(expr->type())) {
+    VELOX_CHECK_EQ(
+        expr->inputs().size(), 2, "Binary function expects exactly 2 inputs");
+    if (auto constExpr = std::dynamic_pointer_cast<velox::exec::ConstantExpr>(
+            expr->inputs()[0])) {
+      auto constValue = constExpr->value();
+      left_ = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+          createCudfScalar, constValue->typeKind(), constValue);
+    } else if (
+        auto constExpr = std::dynamic_pointer_cast<velox::exec::ConstantExpr>(
+            expr->inputs()[1])) {
+      auto constValue = constExpr->value();
+      right_ = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+          createCudfScalar, constValue->typeKind(), constValue);
+    }
+
+    VELOX_CHECK(
+        !(left_ != nullptr && right_ != nullptr),
+        "Binary function on two literals is not supported");
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    auto isComparisonOp = [](cudf::binary_operator op) {
+      switch (op) {
+        case cudf::binary_operator::EQUAL:
+        case cudf::binary_operator::NOT_EQUAL:
+        case cudf::binary_operator::GREATER:
+        case cudf::binary_operator::GREATER_EQUAL:
+        case cudf::binary_operator::LESS:
+        case cudf::binary_operator::LESS_EQUAL:
+          return true;
+        default:
+          return false;
+      }
+    };
+    if (left_ == nullptr && right_ == nullptr) {
+      if (op_ == cudf::binary_operator::DIV && cudf::is_fixed_point(type_)) {
+        auto lhsView = asView(inputColumns[0]);
+        auto rhsView = asView(inputColumns[1]);
+        std::unique_ptr<cudf::column> lhsCast;
+        std::unique_ptr<cudf::column> rhsCast;
+        if (type_.id() == cudf::type_id::DECIMAL128) {
+          if (lhsView.type().id() == cudf::type_id::DECIMAL64) {
+            auto castType = cudf::data_type{
+                cudf::type_id::DECIMAL128, lhsView.type().scale()};
+            lhsCast = cudf::cast(lhsView, castType, stream, mr);
+            lhsView = lhsCast->view();
+          }
+          if (rhsView.type().id() == cudf::type_id::DECIMAL64) {
+            auto castType = cudf::data_type{
+                cudf::type_id::DECIMAL128, rhsView.type().scale()};
+            rhsCast = cudf::cast(rhsView, castType, stream, mr);
+            rhsView = rhsCast->view();
+          }
+        }
+        auto lhsScale = -lhsView.type().scale();
+        auto rhsScale = -rhsView.type().scale();
+        auto outScale = -type_.scale();
+        auto aRescale = outScale - lhsScale + rhsScale;
+        return decimalDivide(lhsView, rhsView, type_, aRescale, stream, mr);
+      }
+      auto lhsView = asView(inputColumns[0]);
+      auto rhsView = asView(inputColumns[1]);
+      if (isComparisonOp(op_) && cudf::is_fixed_point(lhsView.type()) &&
+          cudf::is_fixed_point(rhsView.type())) {
+        auto lhsScale = -lhsView.type().scale();
+        auto rhsScale = -rhsView.type().scale();
+        auto targetScale = lhsScale > rhsScale ? lhsScale : rhsScale;
+        auto targetTypeId = (lhsView.type().id() == cudf::type_id::DECIMAL128 ||
+                             rhsView.type().id() == cudf::type_id::DECIMAL128)
+            ? cudf::type_id::DECIMAL128
+            : cudf::type_id::DECIMAL64;
+        auto targetType =
+            cudf::data_type{targetTypeId, numeric::scale_type{-targetScale}};
+        std::unique_ptr<cudf::column> lhsCast;
+        std::unique_ptr<cudf::column> rhsCast;
+        if (lhsView.type() != targetType) {
+          lhsCast = cudf::cast(lhsView, targetType, stream, mr);
+          lhsView = lhsCast->view();
+        }
+        if (rhsView.type() != targetType) {
+          rhsCast = cudf::cast(rhsView, targetType, stream, mr);
+          rhsView = rhsCast->view();
+        }
+        // @TODO Check for divide-by-zero as in the DECIMAL case above?
+        return cudf::binary_operation(lhsView, rhsView, op_, type_, stream, mr);
+      }
+      if (cudf::is_fixed_point(type_)) {
+        if (op_ == cudf::binary_operator::ADD ||
+            op_ == cudf::binary_operator::SUB ||
+            op_ == cudf::binary_operator::MOD) {
+          std::unique_ptr<cudf::column> lhsCast;
+          std::unique_ptr<cudf::column> rhsCast;
+          if (lhsView.type() != type_) {
+            lhsCast = cudf::cast(lhsView, type_, stream, mr);
+            lhsView = lhsCast->view();
+          }
+          if (rhsView.type() != type_) {
+            rhsCast = cudf::cast(rhsView, type_, stream, mr);
+            rhsView = rhsCast->view();
+          }
+          // @TODO Check for divide-by-zero as in the DECIMAL case above?
+          return cudf::binary_operation(
+              lhsView, rhsView, op_, type_, stream, mr);
+        }
+        if (op_ == cudf::binary_operator::MUL) {
+          std::unique_ptr<cudf::column> lhsCast;
+          std::unique_ptr<cudf::column> rhsCast;
+          if (type_.id() == cudf::type_id::DECIMAL128) {
+            if (lhsView.type().id() == cudf::type_id::DECIMAL64) {
+              auto castType = cudf::data_type{
+                  cudf::type_id::DECIMAL128, lhsView.type().scale()};
+              lhsCast = cudf::cast(lhsView, castType, stream, mr);
+              lhsView = lhsCast->view();
+            }
+            if (rhsView.type().id() == cudf::type_id::DECIMAL64) {
+              auto castType = cudf::data_type{
+                  cudf::type_id::DECIMAL128, rhsView.type().scale()};
+              rhsCast = cudf::cast(rhsView, castType, stream, mr);
+              rhsView = rhsCast->view();
+            }
+          }
+          // @TODO Check for divide-by-zero as in the DECIMAL case above?
+          return cudf::binary_operation(
+              lhsView, rhsView, op_, type_, stream, mr);
+        }
+      }
+      // @TODO Check for divide-by-zero as in the DECIMAL case above?
+      return cudf::binary_operation(lhsView, rhsView, op_, type_, stream, mr);
+    } else if (left_ == nullptr) {
+      if (op_ == cudf::binary_operator::DIV && cudf::is_fixed_point(type_)) {
+        if (decimalScalarIsZero(*right_, stream)) {
+          VELOX_USER_FAIL("Division by zero");
+        }
+        auto lhsView = asView(inputColumns[0]);
+        auto lhsScale = -lhsView.type().scale();
+        auto rhsScale = -right_->type().scale();
+        auto outScale = -type_.scale();
+        auto aRescale = outScale - lhsScale + rhsScale;
+        return decimalDivide(lhsView, *right_, type_, aRescale, stream, mr);
+      }
+      auto lhsView = asView(inputColumns[0]);
+      if (isComparisonOp(op_) && cudf::is_fixed_point(lhsView.type()) &&
+          cudf::is_fixed_point(right_->type())) {
+        auto lhsScale = -lhsView.type().scale();
+        auto rhsScale = -right_->type().scale();
+        auto targetScale = lhsScale > rhsScale ? lhsScale : rhsScale;
+        auto targetTypeId = (lhsView.type().id() == cudf::type_id::DECIMAL128 ||
+                             right_->type().id() == cudf::type_id::DECIMAL128)
+            ? cudf::type_id::DECIMAL128
+            : cudf::type_id::DECIMAL64;
+        auto targetType =
+            cudf::data_type{targetTypeId, numeric::scale_type{-targetScale}};
+        std::unique_ptr<cudf::column> lhsCast;
+        if (lhsView.type() != targetType) {
+          lhsCast = cudf::cast(lhsView, targetType, stream, mr);
+          lhsView = lhsCast->view();
+        }
+        if (right_->type() != targetType) {
+          auto rhsScalar = castDecimalScalar(*right_, targetType, stream, mr);
+          return cudf::binary_operation(
+              lhsView, *rhsScalar, op_, type_, stream, mr);
+        }
+        return cudf::binary_operation(lhsView, *right_, op_, type_, stream, mr);
+      }
+      if (cudf::is_fixed_point(type_)) {
+        if (op_ == cudf::binary_operator::ADD ||
+            op_ == cudf::binary_operator::SUB ||
+            op_ == cudf::binary_operator::MOD) {
+          std::unique_ptr<cudf::column> lhsCast;
+          if (lhsView.type() != type_) {
+            lhsCast = cudf::cast(lhsView, type_, stream, mr);
+            lhsView = lhsCast->view();
+          }
+          if (right_->type() != type_) {
+            auto rhsScalar = castDecimalScalar(*right_, type_, stream, mr);
+            return cudf::binary_operation(
+                lhsView, *rhsScalar, op_, type_, stream, mr);
+          }
+          return cudf::binary_operation(
+              lhsView, *right_, op_, type_, stream, mr);
+        }
+        if (op_ == cudf::binary_operator::MUL) {
+          std::unique_ptr<cudf::column> lhsCast;
+          std::unique_ptr<cudf::scalar> rhsScalar;
+          if (type_.id() == cudf::type_id::DECIMAL128) {
+            if (lhsView.type().id() == cudf::type_id::DECIMAL64) {
+              auto castType = cudf::data_type{
+                  cudf::type_id::DECIMAL128, lhsView.type().scale()};
+              lhsCast = cudf::cast(lhsView, castType, stream, mr);
+              lhsView = lhsCast->view();
+            }
+            if (right_->type().id() == cudf::type_id::DECIMAL64) {
+              auto castType = cudf::data_type{
+                  cudf::type_id::DECIMAL128, right_->type().scale()};
+              rhsScalar = castDecimalScalar(*right_, castType, stream, mr);
+            }
+          }
+          return cudf::binary_operation(
+              lhsView,
+              rhsScalar ? *rhsScalar : *right_,
+              op_,
+              type_,
+              stream,
+              mr);
+        }
+      }
+      return cudf::binary_operation(
+          asView(inputColumns[0]), *right_, op_, type_, stream, mr);
+    }
+    if (op_ == cudf::binary_operator::DIV && cudf::is_fixed_point(type_)) {
+      auto rhsView = asView(inputColumns[0]);
+      auto lhsScale = -left_->type().scale();
+      auto rhsScale = -rhsView.type().scale();
+      auto outScale = -type_.scale();
+      auto aRescale = outScale - lhsScale + rhsScale;
+      return decimalDivide(*left_, rhsView, type_, aRescale, stream, mr);
+    }
+    auto rhsView = asView(inputColumns[0]);
+    if (isComparisonOp(op_) && cudf::is_fixed_point(left_->type()) &&
+        cudf::is_fixed_point(rhsView.type())) {
+      auto lhsScale = -left_->type().scale();
+      auto rhsScale = -rhsView.type().scale();
+      auto targetScale = lhsScale > rhsScale ? lhsScale : rhsScale;
+      auto targetTypeId = (left_->type().id() == cudf::type_id::DECIMAL128 ||
+                           rhsView.type().id() == cudf::type_id::DECIMAL128)
+          ? cudf::type_id::DECIMAL128
+          : cudf::type_id::DECIMAL64;
+      auto targetType =
+          cudf::data_type{targetTypeId, numeric::scale_type{-targetScale}};
+      std::unique_ptr<cudf::column> rhsCast;
+      if (rhsView.type() != targetType) {
+        rhsCast = cudf::cast(rhsView, targetType, stream, mr);
+        rhsView = rhsCast->view();
+      }
+      if (left_->type() != targetType) {
+        auto lhsScalar = castDecimalScalar(*left_, targetType, stream, mr);
+        return cudf::binary_operation(
+            *lhsScalar, rhsView, op_, type_, stream, mr);
+      }
+      return cudf::binary_operation(*left_, rhsView, op_, type_, stream, mr);
+    }
+    if (cudf::is_fixed_point(type_)) {
+      if (op_ == cudf::binary_operator::ADD ||
+          op_ == cudf::binary_operator::SUB ||
+          op_ == cudf::binary_operator::MOD) {
+        std::unique_ptr<cudf::column> rhsCast;
+        if (rhsView.type() != type_) {
+          rhsCast = cudf::cast(rhsView, type_, stream, mr);
+          rhsView = rhsCast->view();
+        }
+        if (left_->type() != type_) {
+          auto lhsScalar = castDecimalScalar(*left_, type_, stream, mr);
+          return cudf::binary_operation(
+              *lhsScalar, rhsView, op_, type_, stream, mr);
+        }
+        return cudf::binary_operation(*left_, rhsView, op_, type_, stream, mr);
+      }
+      if (op_ == cudf::binary_operator::MUL) {
+        std::unique_ptr<cudf::column> rhsCast;
+        std::unique_ptr<cudf::scalar> lhsScalar;
+        if (type_.id() == cudf::type_id::DECIMAL128) {
+          if (rhsView.type().id() == cudf::type_id::DECIMAL64) {
+            auto castType = cudf::data_type{
+                cudf::type_id::DECIMAL128, rhsView.type().scale()};
+            rhsCast = cudf::cast(rhsView, castType, stream, mr);
+            rhsView = rhsCast->view();
+          }
+          if (left_->type().id() == cudf::type_id::DECIMAL64) {
+            auto castType = cudf::data_type{
+                cudf::type_id::DECIMAL128, left_->type().scale()};
+            lhsScalar = castDecimalScalar(*left_, castType, stream, mr);
+          }
+        }
+        return cudf::binary_operation(
+            lhsScalar ? *lhsScalar : *left_, rhsView, op_, type_, stream, mr);
+      }
+    }
+    return cudf::binary_operation(*left_, rhsView, op_, type_, stream, mr);
+  }
+
+ private:
+  const cudf::binary_operator op_;
+  const cudf::data_type type_;
+  std::unique_ptr<cudf::scalar> left_;
+  std::unique_ptr<cudf::scalar> right_;
+};
+
+// @TODO 4/22/26
+// Simplify or remove the logic in this class that handles constant-folding or
+// short-circuiting of logical operations, once the cuDF expression optimizer
+// enhancements land (Velox PR #17108, see also Velox Issue #17307).
+class LogicalFunction : public CudfFunction {
+ public:
+  LogicalFunction(
+      const std::shared_ptr<velox::exec::Expr>& expr,
+      cudf::binary_operator op)
+      : op_(op) {
+    VELOX_CHECK_GE(
+        expr->inputs().size(), 2, "Logical function expects at least 2 inputs");
+    literals_.reserve(expr->inputs().size());
+    for (const auto& input : expr->inputs()) {
+      auto constExpr =
+          std::dynamic_pointer_cast<velox::exec::ConstantExpr>(input);
+      if (constExpr) {
+        VELOX_CHECK_EQ(
+            constExpr->value()->typeKind(),
+            TypeKind::BOOLEAN,
+            "Logical function only supports boolean literals");
+        auto boolConst = constExpr->value()->as<ConstantVector<bool>>();
+        VELOX_CHECK_NOT_NULL(boolConst);
+        if (!shortCircuitScalar_ && !boolConst->isNullAt(0)) {
+          const bool v = boolConst->valueAt(0);
+          if ((op_ == cudf::binary_operator::NULL_LOGICAL_AND && !v) ||
+              (op_ == cudf::binary_operator::NULL_LOGICAL_OR && v)) {
+            // If we encounter non-null false (for AND) or true (for OR), we
+            // know what the final result must be, although it will still need
+            // to be expanded to a column the same size as the input columns. No
+            // need to continue capturing literals in that case.
+            shortCircuitScalar_ =
+                createCudfScalar<TypeKind::BOOLEAN>(constExpr->value());
+            break;
+          }
+        }
+        literals_.push_back(
+            createCudfScalar<TypeKind::BOOLEAN>(constExpr->value()));
+      } else {
+        literals_.push_back(nullptr);
+      }
+    }
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    // If there are no input columns, the result is a scalar.
+    const size_t rowCount =
+        inputColumns.empty() ? 1 : asView(inputColumns[0]).size();
+
+    // If we determined a short-circuit result in the constructor, we
+    // return it directly here, expanded to the size of the input
+    // columns if not all the inputs are literals.
+    if (shortCircuitScalar_) {
+      return cudf::make_column_from_scalar(
+          *shortCircuitScalar_, rowCount, stream, mr);
+    }
+
+    // Now build the vector of actual operands, each of which is either a
+    // pre-computed literal or an input column.
+    struct Operand {
+      const cudf::scalar* scalar;
+      cudf::column_view column;
+    };
+    std::vector<Operand> operands;
+    operands.reserve(literals_.size());
+    size_t columnIndex = 0;
+    for (const auto& literal : literals_) {
+      if (literal) {
+        operands.push_back(Operand{literal.get(), {}});
+      } else {
+        VELOX_CHECK_LT(columnIndex, inputColumns.size());
+        operands.push_back(
+            Operand{nullptr, asView(inputColumns[columnIndex++])});
+      }
+    }
+
+    // There must be at least one operand.
+    VELOX_CHECK(!operands.empty());
+
+    // If there is only one operand, we can return it directly,
+    // again expanded to the size of the input columns if needed.
+    if (operands.size() == 1) {
+      const auto& only = operands[0];
+      if (only.scalar) {
+        return cudf::make_column_from_scalar(
+            *only.scalar, rowCount, stream, mr);
+      }
+      return ColumnOrView(only.column);
+    }
+
+    // If we get this far, we have at least two operands. We can
+    // now compute the result by iterating over the operands and
+    // applying the binary operator to each pair of operands.
+    const auto& left = operands[0];
+    const auto& right = operands[1];
+    std::unique_ptr<cudf::column> result;
+    if (left.scalar && right.scalar) {
+      // This case may still happen even in the case where a short-circuit
+      // result was not determined in the constructor, for example, if the
+      // inputs are 'true OR true' or 'false AND false'.
+      auto tmp =
+          cudf::make_column_from_scalar(*left.scalar, rowCount, stream, mr);
+      result = cudf::binary_operation(
+          tmp->view(), *right.scalar, op_, kBoolType, stream, mr);
+    } else if (left.scalar) {
+      result = cudf::binary_operation(
+          *left.scalar, right.column, op_, kBoolType, stream, mr);
+    } else if (right.scalar) {
+      result = cudf::binary_operation(
+          left.column, *right.scalar, op_, kBoolType, stream, mr);
+    } else {
+      result = cudf::binary_operation(
+          left.column, right.column, op_, kBoolType, stream, mr);
+    }
+    for (size_t i = 2; i < operands.size(); ++i) {
+      const auto& next = operands[i];
+      if (next.scalar) {
+        result = cudf::binary_operation(
+            result->view(), *next.scalar, op_, kBoolType, stream, mr);
+      } else {
+        result = cudf::binary_operation(
+            result->view(), next.column, op_, kBoolType, stream, mr);
+      }
+    }
+    return result;
+  }
+
+ private:
+  static constexpr cudf::data_type kBoolType{cudf::type_id::BOOL8};
+  const cudf::binary_operator op_;
+  std::unique_ptr<cudf::scalar> shortCircuitScalar_;
+  std::vector<std::unique_ptr<cudf::scalar>> literals_;
+};
+
+class UnaryFunction : public CudfFunction {
+ public:
+  UnaryFunction(
+      const std::shared_ptr<velox::exec::Expr>& expr,
+      cudf::unary_operator op)
+      : op_(op) {
+    VELOX_CHECK_EQ(
+        expr->inputs().size(), 1, "Unary function expects exactly 1 input");
+    auto constExpr =
+        std::dynamic_pointer_cast<velox::exec::ConstantExpr>(expr->inputs()[0]);
+    VELOX_CHECK_NULL(
+        constExpr, "Unary function on literal input is not supported");
+    // @TODO (seves 1/28/26)
+    // binary functions require at least ONE input to be non-literal
+    // do we need to support unary functions with ONLY a literal input?
+    // assuming not for now
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    return cudf::unary_operation(asView(inputColumns[0]), op_, stream, mr);
+  }
+
+ private:
+  const cudf::unary_operator op_;
+};
+
+class BetweenFunction : public CudfFunction {
+ public:
+  BetweenFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    // must have exactly three inputs: value, min, max
+    VELOX_CHECK_EQ(
+        expr->inputs().size(), 3, "Between function expects exactly 3 inputs");
+    // value must not be a literal
+    auto constExpr =
+        std::dynamic_pointer_cast<velox::exec::ConstantExpr>(expr->inputs()[0]);
+    VELOX_CHECK_NULL(
+        constExpr, "Between function with literal input is not supported");
+    if (auto constExpr = std::dynamic_pointer_cast<velox::exec::ConstantExpr>(
+            expr->inputs()[1])) {
+      // min is a literal
+      auto constValue = constExpr->value();
+      minLiteral_ = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+          createCudfScalar, constValue->typeKind(), constValue);
+    }
+    if (auto constExpr = std::dynamic_pointer_cast<velox::exec::ConstantExpr>(
+            expr->inputs()[2])) {
+      // max is a literal
+      auto constValue = constExpr->value();
+      maxLiteral_ = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+          createCudfScalar, constValue->typeKind(), constValue);
+    }
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    // return (value >= min) && (value <= max)
+    std::unique_ptr<cudf::column> geResultColumn, leResultColumn;
+    if (minLiteral_) {
+      geResultColumn = cudf::binary_operation(
+          asView(inputColumns[0]),
+          *minLiteral_,
+          cudf::binary_operator::GREATER_EQUAL,
+          kBoolType,
+          stream,
+          mr);
+    } else {
+      geResultColumn = cudf::binary_operation(
+          asView(inputColumns[0]),
+          asView(inputColumns[1]),
+          cudf::binary_operator::GREATER_EQUAL,
+          kBoolType,
+          stream,
+          mr);
+    }
+    if (maxLiteral_) {
+      leResultColumn = cudf::binary_operation(
+          asView(inputColumns[0]),
+          *maxLiteral_,
+          cudf::binary_operator::LESS_EQUAL,
+          kBoolType,
+          stream,
+          mr);
+    } else {
+      leResultColumn = cudf::binary_operation(
+          asView(inputColumns[0]),
+          asView(inputColumns[2]),
+          cudf::binary_operator::LESS_EQUAL,
+          kBoolType,
+          stream,
+          mr);
+    }
+    return cudf::binary_operation(
+        geResultColumn->view(),
+        leResultColumn->view(),
+        cudf::binary_operator::LOGICAL_AND,
+        kBoolType,
+        stream,
+        mr);
+  }
+
+ private:
+  static constexpr cudf::data_type kBoolType{cudf::type_id::BOOL8};
+  std::unique_ptr<cudf::scalar> minLiteral_;
+  std::unique_ptr<cudf::scalar> maxLiteral_;
+};
+
+template <TypeKind Kind>
+static VectorPtr foldConstantPair(
+    const VectorPtr& a,
+    const VectorPtr& b,
+    cudf::binary_operator op) {
+  using T = typename TypeTraits<Kind>::NativeType;
+  if (a->isNullAt(0))
+    return b;
+  if (b->isNullAt(0))
+    return a;
+  auto aVal = a->as<ConstantVector<T>>()->value();
+  auto bVal = b->as<ConstantVector<T>>()->value();
+  bool bWins =
+      (op == cudf::binary_operator::NULL_MAX) ? (bVal > aVal) : (bVal < aVal);
+  return bWins ? b : a;
+}
+
+class GreatestLeastFunction : public CudfFunction {
+ public:
+  GreatestLeastFunction(
+      const std::shared_ptr<velox::exec::Expr>& expr,
+      cudf::binary_operator op)
+      : op_(op), type_(cudf_velox::veloxToCudfDataType(expr->type())) {
+    VELOX_CHECK_GE(
+        expr->inputs().size(),
+        2,
+        "Greatest/Least function expects at least 2 inputs");
+    // Separate column inputs (into order_) from constant inputs (folded into
+    // a single scalar). Column indices refer to positions in the packed
+    // inputColumns vector that eval() receives (which excludes literals).
+    std::vector<VectorPtr> constValues;
+    size_t columnIndex = 0;
+    for (const auto& input : expr->inputs()) {
+      if (auto constExpr =
+              std::dynamic_pointer_cast<velox::exec::ConstantExpr>(input)) {
+        constValues.push_back(constExpr->value());
+      } else {
+        order_.push_back(columnIndex++);
+      }
+    }
+    // Fold all constant values into a single scalar on the host.
+    if (!constValues.empty()) {
+      auto winner = constValues[0];
+      for (size_t i = 1; i < constValues.size(); ++i) {
+        winner = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+            foldConstantPair, winner->typeKind(), winner, constValues[i], op);
+      }
+      foldedScalar_ = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+          createCudfScalar, winner->typeKind(), winner);
+    }
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    // All inputs were constant -- return the pre-folded scalar as a column.
+    if (order_.empty()) {
+      return cudf::make_column_from_scalar(*foldedScalar_, 1, stream, mr);
+    }
+
+    // Accumulate across column inputs.
+    std::unique_ptr<cudf::column> result;
+    for (size_t i = 1; i < order_.size(); ++i) {
+      cudf::column_view lhs =
+          result ? result->view() : asView(inputColumns[order_[0]]);
+      result = cudf::binary_operation(
+          lhs, asView(inputColumns[order_[i]]), op_, type_, stream, mr);
+    }
+
+    // Apply the folded constant as a final (column, scalar) operation.
+    if (foldedScalar_) {
+      cudf::column_view lhs =
+          result ? result->view() : asView(inputColumns[order_[0]]);
+      result =
+          cudf::binary_operation(lhs, *foldedScalar_, op_, type_, stream, mr);
+    }
+    return result;
+  }
+
+ private:
+  const cudf::binary_operator op_;
+  const cudf::data_type type_;
+  std::unique_ptr<cudf::scalar> foldedScalar_;
+  std::vector<size_t> order_;
+};
+
+class SwitchFunction : public CudfFunction {
+ public:
+  SwitchFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    VELOX_CHECK_EQ(
+        expr->inputs().size(), 3, "case when expects exactly 3 inputs");
+    VELOX_CHECK_EQ(
+        expr->inputs()[0]->type()->kind(),
+        TypeKind::BOOLEAN,
+        "The switch condition result type should be boolean");
+    VELOX_CHECK_NULL(
+        std::dynamic_pointer_cast<velox::exec::ConstantExpr>(expr),
+        "The condition should not be constant");
+    if (auto constExpr = std::dynamic_pointer_cast<velox::exec::ConstantExpr>(
+            expr->inputs()[1])) {
+      auto constValue = constExpr->value();
+      left_ = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+          createCudfScalar, constValue->typeKind(), constValue);
+    }
+    if (auto constExpr = std::dynamic_pointer_cast<velox::exec::ConstantExpr>(
+            expr->inputs()[2])) {
+      auto constValue = constExpr->value();
+      right_ = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+          createCudfScalar, constValue->typeKind(), constValue);
+    }
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    if (left_ == nullptr && right_ == nullptr) {
+      return cudf::copy_if_else(
+          asView(inputColumns[1]),
+          asView(inputColumns[2]),
+          asView(inputColumns[0]),
+          stream,
+          mr);
+    } else if (left_ == nullptr) {
+      return cudf::copy_if_else(
+          asView(inputColumns[1]),
+          *right_,
+          asView(inputColumns[0]),
+          stream,
+          mr);
+    } else if (right_ == nullptr) {
+      return cudf::copy_if_else(
+          *left_, asView(inputColumns[1]), asView(inputColumns[0]), stream, mr);
+    }
+    // right != null and left != null
+    return cudf::copy_if_else(
+        *left_, *right_, asView(inputColumns[0]), stream, mr);
+  }
+
+ private:
+  std::unique_ptr<cudf::scalar> left_;
+  std::unique_ptr<cudf::scalar> right_;
+};
+
+class SubstrFunction : public CudfFunction {
+ public:
+  SubstrFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    using velox::exec::ConstantExpr;
+
+    VELOX_CHECK_GE(
+        expr->inputs().size(), 2, "substr expects at least 2 inputs");
+    VELOX_CHECK_LE(expr->inputs().size(), 3, "substr expects at most 3 inputs");
+
+    auto startExpr = std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[1]);
+    VELOX_CHECK_NOT_NULL(startExpr, "substr start must be a constant");
+
+    auto startValue =
+        startExpr->value()->as<SimpleVector<int64_t>>()->valueAt(0);
+    start_ = static_cast<cudf::size_type>(startValue);
+    if (startValue >= 1) {
+      // cuDF indexing starts at 0.
+      // Presto indexing starts at 1.
+      // Positive indices need to substract 1.
+      start_ = static_cast<cudf::size_type>(startValue - 1);
+    }
+
+    if (expr->inputs().size() > 2) {
+      auto lengthExpr =
+          std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[2]);
+      VELOX_CHECK_NOT_NULL(lengthExpr, "substr length must be a constant");
+
+      auto lengthValue =
+          lengthExpr->value()->as<SimpleVector<int64_t>>()->valueAt(0);
+      // cuDF uses indices [begin, end).
+      // Presto uses length as the length of the substring.
+      // We compute the end as start + length.
+      end_ = start_ + static_cast<cudf::size_type>(lengthValue);
+      hasEnd_ = true;
+    }
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    auto inputCol = asView(inputColumns[0]);
+    cudf::numeric_scalar<cudf::size_type> startScalar(start_, true, stream, mr);
+    cudf::numeric_scalar<cudf::size_type> endScalar(
+        hasEnd_ ? end_ : 0, hasEnd_, stream, mr);
+    cudf::numeric_scalar<cudf::size_type> stepScalar(1, true, stream, mr);
+    return cudf::strings::slice_strings(
+        inputCol, startScalar, endScalar, stepScalar, stream, mr);
+  }
+
+ private:
+  cudf::size_type start_{0};
+  cudf::size_type end_{0};
+  bool hasEnd_{false};
+};
+
+class CoalesceFunction : public CudfFunction {
+ public:
+  CoalesceFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    using velox::exec::ConstantExpr;
+
+    // Storing the first literal that appears in inputs because we don't need to
+    // process after that. This is the last fallback.
+    numColumnsBeforeLiteral_ = expr->inputs().size();
+    for (size_t i = 0; i < expr->inputs().size(); ++i) {
+      const auto& input = expr->inputs()[i];
+      if (auto c =
+              std::dynamic_pointer_cast<velox::exec::ConstantExpr>(input)) {
+        if (!c->value()->isNullAt(0)) {
+          literalScalar_ = makeScalarFromConstantExpr(c);
+          numColumnsBeforeLiteral_ = i;
+          break;
+        }
+      } else if (input->distinctFields().empty() && !input->inputs().empty()) {
+        // Handle constant expressions that weren't folded (e.g., cast of
+        // literal).
+        if (auto innerConst =
+                std::dynamic_pointer_cast<velox::exec::ConstantExpr>(
+                    input->inputs()[0])) {
+          if (!innerConst->value()->isNullAt(0)) {
+            literalScalar_ = makeScalarFromConstantExpr(innerConst);
+            numColumnsBeforeLiteral_ = i;
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    // Coalesce is practically a cudf::replace_nulls over multiple columns.
+    // Starting from first column, we keep calling replace nulls with
+    // subsequent cols until we get an all valid col or run out of columns
+
+    // If a literal comes before any column input, fill the result with it.
+    if (literalScalar_ && numColumnsBeforeLiteral_ == 0) {
+      if (inputColumns.empty()) {
+        // We need at least one column to tell us the required output size
+        VELOX_NYI("coalesce with only literal inputs is not supported");
+      }
+      auto size = asView(inputColumns[0]).size();
+      return cudf::make_column_from_scalar(*literalScalar_, size, stream, mr);
+    }
+
+    VELOX_CHECK(
+        !inputColumns.empty(),
+        "coalesce requires at least one non-literal input");
+    ColumnOrView result = asView(inputColumns[0]);
+    size_t stop = std::min(numColumnsBeforeLiteral_, inputColumns.size());
+    for (size_t i = 1; i < stop && asView(result).has_nulls(); ++i) {
+      result = cudf::replace_nulls(
+          asView(result), asView(inputColumns[i]), stream, mr);
+    }
+
+    if (literalScalar_ && asView(result).has_nulls()) {
+      result = cudf::replace_nulls(asView(result), *literalScalar_, stream, mr);
+    }
+
+    return result;
+  }
+
+ private:
+  size_t numColumnsBeforeLiteral_;
+  std::unique_ptr<cudf::scalar> literalScalar_;
+};
+
+class YearFunction : public CudfFunction {
+ public:
+  explicit YearFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    VELOX_CHECK_EQ(
+        expr->inputs().size(), 1, "year expects exactly 1 input column");
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    auto inputCol = asView(inputColumns[0]);
+    return cudf::datetime::extract_datetime_component(
+        inputCol, cudf::datetime::datetime_component::YEAR, stream, mr);
+  }
+};
+
+class LengthFunction : public CudfFunction {
+ public:
+  explicit LengthFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    VELOX_CHECK_EQ(
+        expr->inputs().size(), 1, "length expects exactly 1 input column");
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    auto inputCol = asView(inputColumns[0]);
+    return cudf::strings::count_characters(inputCol, stream, mr);
+  }
+};
+
+class LowerFunction : public CudfFunction {
+ public:
+  explicit LowerFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    VELOX_CHECK_EQ(
+        expr->inputs().size(), 1, "lower expects exactly 1 input column");
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    auto inputCol = asView(inputColumns[0]);
+    return cudf::strings::to_lower(inputCol, stream, mr);
+  }
+};
+
+class UpperFunction : public CudfFunction {
+ public:
+  explicit UpperFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    VELOX_CHECK_EQ(
+        expr->inputs().size(), 1, "upper expects exactly 1 input column");
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    auto inputCol = asView(inputColumns[0]);
+    return cudf::strings::to_upper(inputCol, stream, mr);
+  }
+};
+
+class LikeFunction : public CudfFunction {
+ public:
+  explicit LikeFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    using velox::exec::ConstantExpr;
+    VELOX_CHECK(
+        expr->inputs().size() == 2 || expr->inputs().size() == 3,
+        "like expects 2 or 3 inputs");
+
+    if (auto inputExpr =
+            std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[0])) {
+      inputIsConstant_ = true;
+      inputIsNull_ = inputExpr->value()->isNullAt(0);
+      if (!inputIsNull_) {
+        input_ = inputExpr->value()->toString(0);
+      }
+    }
+
+    if (auto patternExpr =
+            std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[1])) {
+      patternIsConstant_ = true;
+      patternIsNull_ = patternExpr->value()->isNullAt(0);
+      if (!patternIsNull_) {
+        pattern_ = patternExpr->value()->toString(0);
+      }
+    }
+
+    VELOX_CHECK(
+        !(inputIsConstant_ && patternIsConstant_),
+        "like with constant input and pattern is not supported by the cuDF "
+        "evaluator because there is no input column to derive the output row "
+        "count from");
+
+    hasEscape_ = expr->inputs().size() == 3;
+    if (expr->inputs().size() == 3) {
+      auto escapeExpr =
+          std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[2]);
+      VELOX_CHECK_NOT_NULL(escapeExpr, "like escape must be a constant");
+      escapeIsNull_ = escapeExpr->value()->isNullAt(0);
+      if (!escapeIsNull_) {
+        escape_ = escapeExpr->value()->toString(0);
+        if (!patternIsConstant_ && escape_.size() == 1) {
+          // Column-pattern LIKE ESCAPE reuses the same three legal escape
+          // sequences for every batch, so cache those tiny helper columns once
+          // here. Constant patterns are validated on the host and don't need
+          // these columns.
+          auto stream = cudf::get_default_stream(cudf::allow_default_stream);
+          auto mr = get_temp_mr();
+          targetsColumn_ = makeEscapeTargetsColumn(escape_[0], stream, mr);
+          replacementsColumn_ = makeEscapeReplacementsColumn(stream, mr);
+        }
+      }
+    }
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    size_t nextInput = 0;
+    VELOX_CHECK(
+        !inputColumns.empty(),
+        "like requires at least one non-literal input column");
+    // inputColumns only contains non-literal children, so the first entry
+    // determines the output row count even when the input itself is constant.
+    auto outputRowCount = asView(inputColumns[0]).size();
+
+    std::unique_ptr<cudf::column> inputColumnHolder;
+    cudf::column_view inputCol;
+    if (inputIsConstant_) {
+      cudf::string_scalar inputScalar(input_, !inputIsNull_, stream, mr);
+      inputColumnHolder = cudf::make_column_from_scalar(
+          inputScalar, outputRowCount, stream, mr);
+      inputCol = inputColumnHolder->view();
+    } else {
+      inputCol = asView(inputColumns[nextInput++]);
+    }
+
+    auto makeAllNullResult = [&]() {
+      // Match Velox CPU null propagation for constant null pattern/escape
+      // inputs by producing a fully null boolean column.
+      auto nullScalar = cudf::numeric_scalar<bool>(false, false, stream, mr);
+      return cudf::make_column_from_scalar(
+          nullScalar, inputCol.size(), stream, mr);
+    };
+
+    if (patternIsConstant_ && patternIsNull_) {
+      return makeAllNullResult();
+    }
+    if (hasEscape_ && escapeIsNull_) {
+      return makeAllNullResult();
+    }
+
+    char escapeChar{0};
+    if (hasEscape_) {
+      VELOX_USER_CHECK_EQ(
+          escape_.size(), 1, "Escape string must be a single character");
+      escapeChar = escape_[0];
+    }
+
+    if (patternIsConstant_) {
+      if (hasEscape_) {
+        validateConstantPattern(pattern_, escapeChar);
+      }
+      return cudf::strings::like(inputCol, pattern_, escape_, stream, mr);
+    }
+
+    auto patternCol = asView(inputColumns[nextInput]);
+    if (hasEscape_) {
+      validatePatternColumn(patternCol, escapeChar, stream, mr);
+    }
+
+    std::unique_ptr<cudf::column> sanitizedPatternHolder;
+    auto sanitizedPattern = patternCol;
+    if (patternCol.has_nulls()) {
+      // libcudf rejects null pattern rows for column/column LIKE. Replace them
+      // only for the LIKE call after validation so the temporary column
+      // overlaps less with the validation intermediates above.
+      cudf::string_scalar emptyPattern("", true, stream, mr);
+      sanitizedPatternHolder =
+          cudf::replace_nulls(patternCol, emptyPattern, stream, mr);
+      sanitizedPattern = sanitizedPatternHolder->view();
+    }
+
+    cudf::string_scalar escapeScalar(escape_, true, stream, mr);
+    auto result = cudf::strings::like(
+        inputCol, sanitizedPattern, escapeScalar, stream, mr);
+    sanitizedPatternHolder.reset();
+    // Velox returns null if either the input or pattern row is null. cuDF
+    // already propagated input nulls into the result, so only merge the pattern
+    // nulls back when needed.
+    mergeSecondaryNullsIntoResult(*result, patternCol, stream, mr);
+    return result;
+  }
+
+ private:
+  static void validateConstantPattern(std::string_view pattern, char escape);
+
+  static std::unique_ptr<cudf::column> makeEscapeTargetsColumn(
+      char escape,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr);
+
+  static std::unique_ptr<cudf::column> makeEscapeReplacementsColumn(
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr);
+
+  void validatePatternColumn(
+      cudf::column_view patternColumn,
+      char escape,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const;
+
+  bool inputIsConstant_{false};
+  bool inputIsNull_{false};
+  bool patternIsConstant_{false};
+  bool patternIsNull_{false};
+  bool hasEscape_{false};
+  bool escapeIsNull_{false};
+  std::string input_;
+  std::string pattern_;
+  std::string escape_;
+  std::unique_ptr<cudf::column> targetsColumn_;
+  std::unique_ptr<cudf::column> replacementsColumn_;
+};
+
+void LikeFunction::validateConstantPattern(
+    std::string_view pattern,
+    char escape) {
+  // Match Velox CPU invalid escape validation before calling libcudf LIKE.
+  for (size_t index = 0; index < pattern.size(); ++index) {
+    if (pattern[index] != escape) {
+      continue;
+    }
+
+    VELOX_USER_CHECK_LT(
+        index + 1,
+        pattern.size(),
+        "Escape character must be followed by '%', '_' or the escape character itself");
+    auto next = pattern[index + 1];
+    if (next != escape && next != '%' && next != '_') {
+      VELOX_USER_FAIL(
+          "Escape character must be followed by '%', '_' or the escape character itself");
+    }
+    ++index;
+  }
+}
+
+std::unique_ptr<cudf::column> LikeFunction::makeEscapeTargetsColumn(
+    char escape,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  // Build the three legal escape sequences so column-pattern LIKE ESCAPE can
+  // strip them before checking whether any invalid escape usage remains. This
+  // keeps cuDF aligned with Velox CPU pattern validation semantics.
+  cudf::string_scalar escapedEscapeScalar(
+      std::string(2, escape), true, stream, mr);
+  cudf::string_scalar escapedPercentScalar(
+      std::string(1, escape) + '%', true, stream, mr);
+  cudf::string_scalar escapedUnderscoreScalar(
+      std::string(1, escape) + '_', true, stream, mr);
+  auto escapedEscapeView = escapedEscapeScalar.value(stream);
+  auto escapedPercentView = escapedPercentScalar.value(stream);
+  auto escapedUnderscoreView = escapedUnderscoreScalar.value(stream);
+  rmm::device_uvector<cudf::string_view> deviceTargetViews(3, stream, mr);
+  deviceTargetViews.set_element_async(0, escapedEscapeView, stream);
+  deviceTargetViews.set_element_async(1, escapedPercentView, stream);
+  deviceTargetViews.set_element_async(2, escapedUnderscoreView, stream);
+  auto targetsColumn = cudf::make_strings_column(
+      cudf::device_span<cudf::string_view const>{deviceTargetViews},
+      cudf::string_view{nullptr, 0},
+      stream,
+      mr);
+  // The temporary scalars and string_view array above back async work used to
+  // build the output column, so wait for the stream before returning.
+  stream.synchronize();
+  return targetsColumn;
+}
+
+std::unique_ptr<cudf::column> LikeFunction::makeEscapeReplacementsColumn(
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  cudf::string_scalar emptyString("", true, stream, mr);
+  auto replacementsColumn =
+      cudf::make_column_from_scalar(emptyString, 1, stream, mr);
+  // make_column_from_scalar(string_scalar) reads the scalar's device string
+  // data asynchronously, so keep the scalar alive until the stream completes.
+  stream.synchronize();
+  return replacementsColumn;
+}
+
+void LikeFunction::validatePatternColumn(
+    cudf::column_view patternColumn,
+    char escape,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) const {
+  VELOX_CHECK_NOT_NULL(targetsColumn_);
+  VELOX_CHECK_NOT_NULL(replacementsColumn_);
+
+  // Remove the three legal escape forms first. Any remaining escape character
+  // must be dangling or followed by an unsupported character, which matches the
+  // Velox CPU invalid-escape check.
+  auto normalized = cudf::strings::replace_multiple(
+      cudf::strings_column_view(patternColumn),
+      cudf::strings_column_view(targetsColumn_->view()),
+      cudf::strings_column_view(replacementsColumn_->view()),
+      stream,
+      mr);
+
+  auto escapeScalar =
+      cudf::string_scalar(std::string(1, escape), true, stream, mr);
+  auto hasDanglingEscape = cudf::strings::contains(
+      cudf::strings_column_view(normalized->view()), escapeScalar, stream, mr);
+  normalized.reset();
+
+  auto anyAggregation = cudf::make_any_aggregation<cudf::reduce_aggregation>();
+  auto invalidScalar = cudf::reduce(
+      hasDanglingEscape->view(),
+      *anyAggregation,
+      cudf::data_type{cudf::type_id::BOOL8},
+      stream,
+      mr);
+  hasDanglingEscape.reset();
+
+  auto const& invalidBool =
+      static_cast<cudf::numeric_scalar<bool> const&>(*invalidScalar);
+  auto hasInvalidEscapeUsageValue =
+      invalidBool.is_valid(stream) && invalidBool.value(stream);
+  invalidScalar.reset();
+
+  VELOX_USER_CHECK(
+      !hasInvalidEscapeUsageValue,
+      "Escape character must be followed by '%', '_' or the escape character itself");
+}
+
+class StringPatternPredicateFunction : public CudfFunction {
+ public:
+  explicit StringPatternPredicateFunction(
+      const std::shared_ptr<velox::exec::Expr>& expr,
+      std::string_view functionName) {
+    using velox::exec::ConstantExpr;
+    VELOX_CHECK_EQ(
+        expr->inputs().size(), 2, "{} expects 2 inputs", functionName);
+
+    if (auto inputExpr =
+            std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[0])) {
+      inputIsConstant_ = true;
+      inputIsNull_ = inputExpr->value()->isNullAt(0);
+      if (!inputIsNull_) {
+        input_ = inputExpr->value()->toString(0);
+      }
+    }
+
+    if (auto patternExpr =
+            std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[1])) {
+      patternIsConstant_ = true;
+      patternIsNull_ = patternExpr->value()->isNullAt(0);
+      if (!patternIsNull_) {
+        pattern_ = patternExpr->value()->toString(0);
+      }
+    }
+
+    // Fully constant string-match calls stay off the cuDF path because the
+    // evaluator has no input column to derive the output row count from.
+    VELOX_CHECK(
+        !(inputIsConstant_ && patternIsConstant_),
+        "{} with two constant inputs is not supported by the cuDF evaluator",
+        functionName);
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    size_t nextInput = 0;
+    auto rowCount = inputColumns.empty() ? vector_size_t{1}
+                                         : asView(inputColumns[0]).size();
+
+    std::unique_ptr<cudf::column> inputColumnHolder;
+    cudf::column_view inputCol;
+    if (inputIsConstant_) {
+      cudf::string_scalar inputScalar(input_, !inputIsNull_, stream, mr);
+      inputColumnHolder =
+          cudf::make_column_from_scalar(inputScalar, rowCount, stream, mr);
+      inputCol = inputColumnHolder->view();
+    } else {
+      inputCol = asView(inputColumns[nextInput++]);
+    }
+
+    if (patternIsConstant_) {
+      if (patternIsNull_) {
+        auto nullScalar = cudf::numeric_scalar<bool>(false, false, stream, mr);
+        return cudf::make_column_from_scalar(
+            nullScalar, inputCol.size(), stream, mr);
+      }
+      cudf::string_scalar patternScalar(pattern_, true, stream, mr);
+      return evaluateMatch(inputCol, patternScalar, stream, mr);
+    }
+
+    auto patternCol = asView(inputColumns[nextInput]);
+    auto result = evaluateMatch(inputCol, patternCol, stream, mr);
+    // Match Velox CPU null propagation for column/column evaluation: libcudf
+    // can return a valid false when the pattern row is null, but Velox returns
+    // null if either side is null. cuDF already propagated input nulls into the
+    // result, so only merge the pattern nulls back when needed.
+    mergeSecondaryNullsIntoResult(*result, patternCol, stream, mr);
+    return result;
+  }
+
+ protected:
+  virtual std::unique_ptr<cudf::column> evaluateMatch(
+      cudf::column_view inputCol,
+      cudf::string_scalar const& patternScalar,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const = 0;
+
+  virtual std::unique_ptr<cudf::column> evaluateMatch(
+      cudf::column_view inputCol,
+      cudf::column_view patternCol,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const = 0;
+
+  bool inputIsConstant_{false};
+  bool inputIsNull_{false};
+  bool patternIsNull_{false};
+  bool patternIsConstant_{false};
+  std::string input_;
+  std::string pattern_;
+};
+
+class StartswithFunction : public StringPatternPredicateFunction {
+ public:
+  explicit StartswithFunction(const std::shared_ptr<velox::exec::Expr>& expr)
+      : StringPatternPredicateFunction(expr, "startswith") {}
+
+ protected:
+  std::unique_ptr<cudf::column> evaluateMatch(
+      cudf::column_view inputCol,
+      cudf::string_scalar const& patternScalar,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    return cudf::strings::starts_with(inputCol, patternScalar, stream, mr);
+  }
+
+  std::unique_ptr<cudf::column> evaluateMatch(
+      cudf::column_view inputCol,
+      cudf::column_view patternCol,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    return cudf::strings::starts_with(inputCol, patternCol, stream, mr);
+  }
+};
+
+class EndswithFunction : public StringPatternPredicateFunction {
+ public:
+  explicit EndswithFunction(const std::shared_ptr<velox::exec::Expr>& expr)
+      : StringPatternPredicateFunction(expr, "endswith") {}
+
+ protected:
+  std::unique_ptr<cudf::column> evaluateMatch(
+      cudf::column_view inputCol,
+      cudf::string_scalar const& patternScalar,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    return cudf::strings::ends_with(inputCol, patternScalar, stream, mr);
+  }
+
+  std::unique_ptr<cudf::column> evaluateMatch(
+      cudf::column_view inputCol,
+      cudf::column_view patternCol,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    return cudf::strings::ends_with(inputCol, patternCol, stream, mr);
+  }
+};
+
+class ContainsFunction : public StringPatternPredicateFunction {
+ public:
+  explicit ContainsFunction(const std::shared_ptr<velox::exec::Expr>& expr)
+      : StringPatternPredicateFunction(expr, "contains") {}
+
+ protected:
+  std::unique_ptr<cudf::column> evaluateMatch(
+      cudf::column_view inputCol,
+      cudf::string_scalar const& patternScalar,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    return cudf::strings::contains(inputCol, patternScalar, stream, mr);
+  }
+
+  std::unique_ptr<cudf::column> evaluateMatch(
+      cudf::column_view inputCol,
+      cudf::column_view patternCol,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    return cudf::strings::contains(inputCol, patternCol, stream, mr);
+  }
+};
+
+class ConcatFunction : public CudfFunction {
+ public:
+  explicit ConcatFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    using velox::exec::ConstantExpr;
+    numInputs_ = expr->inputs().size();
+    VELOX_CHECK_GE(numInputs_, 2, "concat expects at least 2 inputs");
+
+    // Scan inputs for literals and store strings in map by input index.
+    for (size_t i = 0; i < numInputs_; ++i) {
+      if (auto constant =
+              std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[i])) {
+        inputIndexToLiteral_[i] = constant->value()->toString(0);
+      }
+    }
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    // Validate sizes.
+    VELOX_CHECK_EQ(
+        inputColumns.size() + inputIndexToLiteral_.size(),
+        numInputs_,
+        "Unexpected number of input columns");
+
+    // If there is at least one input column, fetch its size as the output size.
+    // If there are no input columns, this means that all the inputs are
+    // literals, and the output size will be 1.
+    const size_t outputSize =
+        inputColumns.empty() ? 1u : asView(inputColumns[0]).size();
+
+    // Iterate the inputs, building a vector of column views, either a literal
+    // from the map, or the next input column. We also keep a vector of the
+    // columns created for literals, so that they persist while their views
+    // are used in the concatenation.
+    std::vector<cudf::column_view> columnViews;
+    std::vector<std::unique_ptr<cudf::column>> literalColumns;
+    size_t nextInputColumnIndex = 0u;
+    for (size_t i = 0; i < numInputs_; ++i) {
+      auto it = inputIndexToLiteral_.find(i);
+      if (it == inputIndexToLiteral_.end()) {
+        // No literal for this input. Use the next input column.
+        auto& column = inputColumns[nextInputColumnIndex++];
+        columnViews.push_back(asView(column));
+      } else {
+        // Create a column of the literal repeated for the entire output size.
+        auto const& literal = it->second;
+        cudf::string_scalar scalar(literal, true, stream, mr);
+        auto col =
+            cudf::make_column_from_scalar(scalar, outputSize, stream, mr);
+        columnViews.push_back(col->view());
+        literalColumns.emplace_back(std::move(col));
+      }
+    }
+
+    // Concatenate the columns, nulls as empty strings, no separators.
+    cudf::string_scalar emptyString("", true, stream, mr);
+    return cudf::strings::concatenate(
+        cudf::table_view(columnViews),
+        emptyString,
+        emptyString,
+        cudf::strings::separator_on_nulls::YES,
+        stream,
+        mr);
+  }
+
+ private:
+  std::map<int, std::string> inputIndexToLiteral_;
+  size_t numInputs_{0};
+};
+
+bool registerCudfFunction(
+    const std::string& name,
+    CudfFunctionFactory factory,
+    const std::vector<exec::FunctionSignaturePtr>& signatures,
+    bool overwrite) {
+  auto& registry = getCudfFunctionRegistry();
+  if (!overwrite && !registry[name].empty()) {
+    return false;
+  }
+  registry[name].push_back(CudfFunctionSpec{std::move(factory), signatures});
+  return true;
+}
+
+void registerCudfFunctions(
+    const std::vector<std::string>& aliases,
+    CudfFunctionFactory factory,
+    const std::vector<exec::FunctionSignaturePtr>& signatures,
+    bool overwrite) {
+  for (const auto& name : aliases) {
+    registerCudfFunction(name, factory, signatures, overwrite);
+  }
+}
+
+std::shared_ptr<CudfFunction> createCudfFunction(
+    const std::string& name,
+    const std::shared_ptr<velox::exec::Expr>& expr) {
+  auto& registry = getCudfFunctionRegistry();
+  auto it = registry.find(name);
+  if (it == registry.end()) {
+    return nullptr;
+  }
+  for (const auto& spec : it->second) {
+    // Empty signatures matching must be allowed to handle
+    // the special case of cast
+    if (spec.signatures.empty() ||
+        matchCallAgainstSignatures(*expr, spec.signatures)) {
+      return spec.factory(name, expr);
+    }
+  }
+  return nullptr;
+}
+
+bool registerBuiltinFunctions(const std::string& prefix) {
+  using exec::FunctionSignatureBuilder;
+
+  registerCudfFunction(
+      prefix + "split",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<SplitFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("array(varchar)")
+           .argumentType("varchar")
+           .constantArgumentType("varchar")
+           .constantArgumentType("integer")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("array(varchar)")
+           .argumentType("varchar")
+           .constantArgumentType("varchar")
+           // cuDF expects cudf::size_type (int32) but we may get bigint from
+           // presto. SplitFunction hacks around this by converting to string
+           // and back
+           .constantArgumentType("bigint")
+           .build()});
+
+  registerCudfFunction(
+      prefix + "cardinality",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<CardinalityFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("integer")
+           .argumentType("array(any)")
+           .build()});
+
+  registerCudfFunctions(
+      {prefix + "substr", prefix + "substring"},
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<SubstrFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("varchar")
+           .argumentType("varchar")
+           .constantArgumentType("bigint")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("varchar")
+           .argumentType("varchar")
+           .constantArgumentType("bigint")
+           .constantArgumentType("bigint")
+           .build()});
+
+  // Coalesce is special form and doesn't have a prefix in its name.
+  registerCudfFunction(
+      "coalesce",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<CoalesceFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .typeVariable("T")
+           .returnType("T")
+           .argumentType("T")
+           .variableArity("T")
+           .build()});
+
+  registerCudfFunction(
+      "and",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<LogicalFunction>(
+            expr, cudf::binary_operator::NULL_LOGICAL_AND);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("boolean")
+           .argumentType("boolean")
+           .variableArity("boolean")
+           .build()});
+
+  registerCudfFunction(
+      "or",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<LogicalFunction>(
+            expr, cudf::binary_operator::NULL_LOGICAL_OR);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("boolean")
+           .argumentType("boolean")
+           .variableArity("boolean")
+           .build()});
+
+  registerCudfFunction(
+      prefix + "round",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<RoundFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .integerVariable("p")
+           .integerVariable("s")
+           .returnType("decimal(p,s)")
+           .argumentType("decimal(p,s)")
+           .build(),
+       FunctionSignatureBuilder()
+           .integerVariable("p")
+           .integerVariable("s")
+           .returnType("decimal(p,s)")
+           .argumentType("decimal(p,s)")
+           .constantArgumentType("integer")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("tinyint")
+           .argumentType("tinyint")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("tinyint")
+           .argumentType("tinyint")
+           .constantArgumentType("integer")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("smallint")
+           .argumentType("smallint")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("smallint")
+           .argumentType("smallint")
+           .constantArgumentType("integer")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("integer")
+           .argumentType("integer")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("integer")
+           .argumentType("integer")
+           .constantArgumentType("integer")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("bigint")
+           .argumentType("bigint")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("bigint")
+           .argumentType("bigint")
+           .constantArgumentType("integer")
+           .build()});
+
+  registerCudfFunction(
+      prefix + "year",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<YearFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("integer")
+           .argumentType("timestamp")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("integer")
+           .argumentType("date")
+           .build()});
+
+  registerCudfFunction(
+      prefix + "length",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<LengthFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("bigint")
+           .argumentType("varchar")
+           .build()});
+
+  registerCudfFunction(
+      prefix + "lower",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<LowerFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("varchar")
+           .argumentType("varchar")
+           .build()});
+
+  registerCudfFunction(
+      prefix + "upper",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<UpperFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("varchar")
+           .argumentType("varchar")
+           .build()});
+
+  registerCudfFunction(
+      prefix + "like",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<LikeFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("boolean")
+           .argumentType("varchar")
+           .argumentType("varchar")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("boolean")
+           .argumentType("varchar")
+           .argumentType("varchar")
+           .constantArgumentType("varchar")
+           .build()});
+
+  registerCudfFunction(
+      prefix + "startswith",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<StartswithFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("boolean")
+           .argumentType("varchar")
+           .argumentType("varchar")
+           .build()});
+
+  registerCudfFunction(
+      prefix + "endswith",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<EndswithFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("boolean")
+           .argumentType("varchar")
+           .argumentType("varchar")
+           .build()});
+
+  registerCudfFunction(
+      prefix + "contains",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<ContainsFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("boolean")
+           .argumentType("varchar")
+           .argumentType("varchar")
+           .build()});
+
+  registerCudfFunction(
+      prefix + "concat",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<ConcatFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("varchar")
+           .argumentType("varchar")
+           .variableArity("varchar")
+           .build()});
+
+  // No prefix because switch and if are special form
+  registerCudfFunctions(
+      {"switch", "if"},
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<SwitchFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .typeVariable("T")
+           .returnType("T")
+           .argumentType("boolean")
+           .argumentType("T")
+           .argumentType("T")
+           .build()});
+
+  registerCudfFunctions(
+      // No signatures required for cast and try_cast. They are special forms.
+      {"try_cast", "cast"},
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<CastFunction>(expr);
+      },
+      {
+          // Cast needs special handling dynamically using cudf.
+      });
+
+  //
+  // regular binary operators
+  //
+
+  auto registerBinaryOp = [&](const std::vector<std::string>& aliases,
+                              cudf::binary_operator op) {
+    auto decimalBinarySignature = [&]() {
+      return FunctionSignatureBuilder()
+          .integerVariable("a_precision")
+          .integerVariable("a_scale")
+          .integerVariable("b_precision")
+          .integerVariable("b_scale")
+          .integerVariable("r_precision")
+          .integerVariable("r_scale")
+          .returnType("decimal(r_precision, r_scale)")
+          .argumentType("decimal(a_precision, a_scale)")
+          .argumentType("decimal(b_precision, b_scale)")
+          .build();
+    };
+
+    registerCudfFunctions(
+        aliases,
+        [op](
+            const std::string&,
+            const std::shared_ptr<velox::exec::Expr>& expr) {
+          return std::make_shared<BinaryFunction>(expr, op);
+        },
+        {FunctionSignatureBuilder()
+             .returnType("double")
+             .argumentType("double")
+             .argumentType("double")
+             .build(),
+         decimalBinarySignature()});
+  };
+
+  registerBinaryOp(
+      {prefix + "plus", prefix + "add"}, cudf::binary_operator::ADD);
+  registerBinaryOp(
+      {prefix + "minus", prefix + "subtract"}, cudf::binary_operator::SUB);
+  registerBinaryOp({prefix + "multiply"}, cudf::binary_operator::MUL);
+  registerBinaryOp({prefix + "divide"}, cudf::binary_operator::DIV);
+  registerBinaryOp({prefix + "mod"}, cudf::binary_operator::MOD);
+
+  //
+  // regular comparison operators
+  //
+
+  auto registerComparisonOp = [&](const std::vector<std::string>& aliases,
+                                  cudf::binary_operator op) {
+    registerCudfFunctions(
+        aliases,
+        [op](
+            const std::string&,
+            const std::shared_ptr<velox::exec::Expr>& expr) {
+          return std::make_shared<BinaryFunction>(expr, op);
+        },
+        {FunctionSignatureBuilder()
+             .returnType("boolean")
+             .argumentType("double")
+             .argumentType("double")
+             .build(),
+         FunctionSignatureBuilder()
+             .integerVariable("a_precision")
+             .integerVariable("a_scale")
+             .integerVariable("b_precision")
+             .integerVariable("b_scale")
+             .returnType("boolean")
+             .argumentType("decimal(a_precision, a_scale)")
+             .argumentType("decimal(b_precision, b_scale)")
+             .build()});
+  };
+
+  registerComparisonOp(
+      {prefix + "equal", prefix + "eq"}, cudf::binary_operator::EQUAL);
+  registerComparisonOp(
+      {prefix + "notequal", prefix + "neq"}, cudf::binary_operator::NOT_EQUAL);
+  registerComparisonOp(
+      {prefix + "greaterthanorequal", prefix + "gte"},
+      cudf::binary_operator::GREATER_EQUAL);
+  registerComparisonOp(
+      {prefix + "lessthanorequal", prefix + "lte"},
+      cudf::binary_operator::LESS_EQUAL);
+  registerComparisonOp(
+      {prefix + "greaterthan", prefix + "gt"}, cudf::binary_operator::GREATER);
+  registerComparisonOp(
+      {prefix + "lessthan", prefix + "lt"}, cudf::binary_operator::LESS);
+
+  //
+  // regular unary operators
+  //
+
+  auto registerUnaryOp = [&](const std::vector<std::string>& aliases,
+                             cudf::unary_operator op) {
+    registerCudfFunctions(
+        aliases,
+        [op](
+            const std::string&,
+            const std::shared_ptr<velox::exec::Expr>& expr) {
+          return std::make_shared<UnaryFunction>(expr, op);
+        },
+        {FunctionSignatureBuilder()
+             .returnType("double")
+             .argumentType("double")
+             .build(),
+         FunctionSignatureBuilder()
+             .integerVariable("p")
+             .integerVariable("s")
+             .returnType("decimal(p,s)")
+             .argumentType("decimal(p,s)")
+             .build()});
+  };
+
+  registerUnaryOp({prefix + "abs"}, cudf::unary_operator::ABS);
+  registerUnaryOp({prefix + "negate"}, cudf::unary_operator::NEGATE);
+  registerUnaryOp({prefix + "floor"}, cudf::unary_operator::FLOOR);
+  registerUnaryOp({prefix + "ceil"}, cudf::unary_operator::CEIL);
+
+  // @TODO (seves 1/28/26)
+  // truncate
+  // no direct cudf mapping
+  // perhaps a compound operation using round/round_decimal
+
+  //
+  // between
+  //
+
+  registerCudfFunction(
+      prefix + "between",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<BetweenFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("boolean")
+           .argumentType("double")
+           .argumentType("double")
+           .argumentType("double")
+           .build(),
+       FunctionSignatureBuilder()
+           .integerVariable("p")
+           .integerVariable("s")
+           .returnType("boolean")
+           .argumentType("decimal(p,s)")
+           .argumentType("decimal(p,s)")
+           .argumentType("decimal(p,s)")
+           .build()});
+
+  //
+  // greatest & least
+  //
+
+  registerCudfFunction(
+      prefix + "greatest",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<GreatestLeastFunction>(
+            expr, cudf::binary_operator::NULL_MAX);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("double")
+           .argumentType("double")
+           .variableArity("double")
+           .build(),
+       FunctionSignatureBuilder()
+           .integerVariable("p")
+           .integerVariable("s")
+           .returnType("decimal(p,s)")
+           .argumentType("decimal(p,s)")
+           .variableArity("decimal(p,s)")
+           .build()});
+
+  registerCudfFunction(
+      prefix + "least",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<GreatestLeastFunction>(
+            expr, cudf::binary_operator::NULL_MIN);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("double")
+           .argumentType("double")
+           .variableArity("double")
+           .build(),
+       FunctionSignatureBuilder()
+           .integerVariable("p")
+           .integerVariable("s")
+           .returnType("decimal(p,s)")
+           .argumentType("decimal(p,s)")
+           .variableArity("decimal(p,s)")
+           .build()});
+
+  return true;
+}
+
+std::shared_ptr<FunctionExpression> FunctionExpression::create(
+    const std::shared_ptr<velox::exec::Expr>& expr,
+    const RowTypePtr& inputRowSchema) {
+  auto node = std::make_shared<FunctionExpression>();
+  node->expr_ = expr;
+  node->inputRowSchema_ = inputRowSchema;
+
+  auto name = expr->name();
+  node->function_ = createCudfFunction(name, expr);
+
+  if (node->function_) {
+    for (const auto& input : expr->inputs()) {
+      if (input->name() != "literal") {
+        node->subexpressions_.push_back(
+            createCudfExpression(input, inputRowSchema));
+      }
+    }
+  }
+
+  return node;
+}
+
+ColumnOrView FunctionExpression::eval(
+    std::vector<cudf::column_view> inputColumnViews,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr,
+    bool finalize) {
+  using velox::exec::FieldReference;
+
+  if (auto fieldExpr = std::dynamic_pointer_cast<FieldReference>(expr_)) {
+    auto name = fieldExpr->name();
+    auto columnIndex = inputRowSchema_->getChildIdx(name);
+    return inputColumnViews[columnIndex];
+  }
+
+  if (function_) {
+    std::vector<ColumnOrView> subexprResults;
+    subexprResults.reserve(subexpressions_.size());
+
+    for (const auto& subexpr : subexpressions_) {
+      subexprResults.push_back(subexpr->eval(inputColumnViews, stream, mr));
+    }
+
+    auto result = function_->eval(subexprResults, stream, mr);
+    if (finalize) {
+      const auto requestedType = cudf_velox::veloxToCudfDataType(expr_->type());
+      auto resultView = asView(result);
+      if (resultView.type() != requestedType) {
+        return cudf::cast(resultView, requestedType, stream, mr);
+      }
+    }
+    return result;
+  }
+
+  VELOX_FAIL(
+      "Unsupported expression for recursive evaluation: " + expr_->name());
+}
+
+void FunctionExpression::close() {
+  function_.reset();
+  subexpressions_.clear();
+}
+
+bool FunctionExpression::canEvaluate(std::shared_ptr<velox::exec::Expr> expr) {
+  using velox::exec::FieldReference;
+
+  if (std::dynamic_pointer_cast<FieldReference>(expr)) {
+    return true;
+  }
+
+  const auto& opName = expr->name();
+  if (opName == "cast" || opName == "try_cast") {
+    const auto& srcType =
+        expr->inputs().empty() ? nullptr : expr->inputs()[0]->type();
+    const auto& dstType = expr->type();
+    if (srcType == nullptr || dstType == nullptr) {
+      return false;
+    }
+    auto src = cudf_velox::veloxToCudfDataType(srcType);
+    auto dst = cudf_velox::veloxToCudfDataType(dstType);
+    return cudf::is_supported_cast(src, dst);
+  }
+
+  auto& registry = getCudfFunctionRegistry();
+  auto it = registry.find(expr->name());
+  if (it == registry.end()) {
+    return false;
+  }
+  for (const auto& spec : it->second) {
+    if (spec.signatures.empty() ||
+        matchCallAgainstSignatures(*expr, spec.signatures)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool canBeEvaluatedByCudf(std::shared_ptr<velox::exec::Expr> expr, bool deep) {
+  ensureBuiltinExpressionEvaluatorsRegistered();
+  const auto& registry = getCudfExpressionEvaluatorRegistry();
+
+  bool supported = false;
+  for (const auto& [name, entry] : registry) {
+    if (entry.canEvaluate && entry.canEvaluate(expr)) {
+      supported = true;
+      break;
+    }
+  }
+  if (!supported) {
+    LOG_FALLBACK(expr->toString());
+    return false;
+  }
+
+  if (deep) {
+    for (const auto& input : expr->inputs()) {
+      if (input->name() != "literal" && !canBeEvaluatedByCudf(input, true)) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+std::shared_ptr<CudfExpression> createCudfExpression(
+    std::shared_ptr<velox::exec::Expr> expr,
+    const RowTypePtr& inputRowSchema) {
+  ensureBuiltinExpressionEvaluatorsRegistered();
+  const auto& registry = getCudfExpressionEvaluatorRegistry();
+
+  const CudfExpressionEvaluatorEntry* best = nullptr;
+  for (const auto& [name, entry] : registry) {
+    if (entry.canEvaluate && entry.canEvaluate(expr)) {
+      if (best == nullptr || entry.priority > best->priority) {
+        best = &entry;
+      }
+    }
+  }
+
+  if (best != nullptr) {
+    return best->create(expr, inputRowSchema);
+  }
+
+  return FunctionExpression::create(expr, inputRowSchema);
+}
+
+void unregisterFunctions() {
+  auto& registry = getCudfFunctionRegistry();
+  registry.clear();
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/ExpressionEvaluator.h b/velox/experimental/cudf/expression/ExpressionEvaluator.h
new file mode 100644
index 00000000000..d5967ced2dd
--- /dev/null
+++ b/velox/experimental/cudf/expression/ExpressionEvaluator.h
@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/expression/Expr.h"
+#include "velox/expression/FunctionSignature.h"
+#include "velox/type/Type.h"
+
+#include <cudf/column/column.hpp>
+#include <cudf/table/table_view.hpp>
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <variant>
+#include <vector>
+
+namespace facebook::velox::cudf_velox {
+
+// Holds either a non-owning cudf::column_view (zero-copy) or an owning
+// cudf::column (materialised result).
+using ColumnOrView =
+    std::variant<cudf::column_view, std::unique_ptr<cudf::column>>;
+
+// Helper to always obtain a column_view.
+inline cudf::column_view asView(ColumnOrView& holder) {
+  return std::visit(
+      [](auto& h) -> cudf::column_view {
+        using T = std::decay_t<decltype(h)>;
+        if constexpr (std::is_same_v<T, cudf::column_view>) {
+          return h;
+        } else {
+          return h->view();
+        }
+      },
+      holder);
+}
+
+// Helper to convert a table_view to a vector of column_views.
+inline std::vector<cudf::column_view> tableViewToColumnViews(
+    cudf::table_view tableView) {
+  std::vector<cudf::column_view> result;
+  result.reserve(tableView.num_columns());
+  for (cudf::size_type i = 0; i < tableView.num_columns(); ++i) {
+    result.push_back(tableView.column(i));
+  }
+  return result;
+}
+
+class CudfFunction {
+ public:
+  virtual ~CudfFunction() = default;
+  virtual ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const = 0;
+};
+
+using CudfFunctionFactory = std::function<std::shared_ptr<CudfFunction>(
+    const std::string& name,
+    const std::shared_ptr<velox::exec::Expr>& expr)>;
+
+struct CudfFunctionSpec {
+  CudfFunctionFactory factory;
+  std::vector<exec::FunctionSignaturePtr> signatures;
+};
+
+bool registerCudfFunction(
+    const std::string& name,
+    CudfFunctionFactory factory,
+    const std::vector<exec::FunctionSignaturePtr>& signatures,
+    bool overwrite = true);
+
+void registerCudfFunctions(
+    const std::vector<std::string>& aliases,
+    CudfFunctionFactory factory,
+    const std::vector<exec::FunctionSignaturePtr>& signatures,
+    bool overwrite = true);
+
+/// Create a CudfFunction for the given name and expression.
+/// Returns nullptr if no registered function matches the expression's
+/// signature.
+std::shared_ptr<CudfFunction> createCudfFunction(
+    const std::string& name,
+    const std::shared_ptr<velox::exec::Expr>& expr);
+
+bool registerBuiltinFunctions(const std::string& prefix);
+
+void unregisterFunctions();
+
+class CudfExpression {
+ public:
+  virtual ~CudfExpression() = default;
+  virtual void close() = 0;
+
+  virtual ColumnOrView eval(
+      std::vector<cudf::column_view> inputColumnViews,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr,
+      bool finalize = false) = 0;
+};
+
+using CudfExpressionPtr = std::shared_ptr<CudfExpression>;
+
+using CudfExpressionEvaluatorCanEvaluate =
+    std::function<bool(std::shared_ptr<velox::exec::Expr> expr)>;
+using CudfExpressionEvaluatorCreate =
+    std::function<std::shared_ptr<CudfExpression>(
+        std::shared_ptr<velox::exec::Expr> expr,
+        const RowTypePtr& inputRowSchema)>;
+
+// Register a CudfExpression evaluator.
+// - name: unique identifier (e.g., "ast", "function", "my_custom").
+// - priority: higher number = higher priority.
+// - canEvaluate: shallow check whether evaluator can handle current expr root.
+// - create: factory to build the evaluator node.
+// - overwrite: replace existing registration with the same name if true.
+bool registerCudfExpressionEvaluator(
+    const std::string& name,
+    int priority,
+    CudfExpressionEvaluatorCanEvaluate canEvaluate,
+    CudfExpressionEvaluatorCreate create,
+    bool overwrite = true);
+
+class FunctionExpression : public CudfExpression {
+ public:
+  static std::shared_ptr<FunctionExpression> create(
+      const std::shared_ptr<velox::exec::Expr>& expr,
+      const RowTypePtr& inputRowSchema);
+
+  // TODO (dm): A storage for keeping results in case this is a multiply
+  // referenced subexpression (to do CSE)
+
+  ColumnOrView eval(
+      std::vector<cudf::column_view> inputColumnViews,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr,
+      bool finalize = false) override;
+
+  void close() override;
+
+  // Check if this specific operation can be evaluated by FunctionExpression
+  // (does not recursively check children)
+  static bool canEvaluate(std::shared_ptr<velox::exec::Expr> expr);
+
+ private:
+  std::shared_ptr<velox::exec::Expr> expr_;
+  std::shared_ptr<CudfFunction> function_;
+  std::vector<std::shared_ptr<CudfExpression>> subexpressions_;
+
+  RowTypePtr inputRowSchema_;
+};
+
+std::shared_ptr<CudfExpression> createCudfExpression(
+    std::shared_ptr<velox::exec::Expr> expr,
+    const RowTypePtr& inputRowSchema);
+
+/// Lightweight check if an expression tree is supported by any CUDF evaluator
+/// without initializing CudfExpression objects.
+/// \param expr Expression to check
+/// \param deep If true, recursively check all children in the expression tree;
+///             if false, only check if the top-level operation is supported
+///             (useful when delegating to subexpressions)
+bool canBeEvaluatedByCudf(
+    std::shared_ptr<velox::exec::Expr> expr,
+    bool deep = true);
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/JitExpression.cpp b/velox/experimental/cudf/expression/JitExpression.cpp
new file mode 100644
index 00000000000..3b0b5b2c64b
--- /dev/null
+++ b/velox/experimental/cudf/expression/JitExpression.cpp
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/cudf/expression/AstExpressionUtils.h"
+#include "velox/experimental/cudf/expression/JitExpression.h"
+
+namespace facebook::velox::cudf_velox {
+
+JitExpression::JitExpression(
+    std::shared_ptr<velox::exec::Expr> expr,
+    const RowTypePtr& inputRowSchema)
+    : expr_{expr, inputRowSchema} {}
+
+void JitExpression::close() {
+  expr_.close();
+}
+
+ColumnOrView JitExpression::eval(
+    std::vector<cudf::column_view> inputColumnViews,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr,
+    bool finalize) {
+  auto precomputedColumns = precomputeSubexpressions(
+      inputColumnViews,
+      expr_.precomputeInstructions_,
+      expr_.scalars_,
+      expr_.inputRowSchema_,
+      stream);
+
+  // Make table_view from input columns and precomputed columns
+  std::vector<cudf::column_view> allColumnViews(inputColumnViews);
+  allColumnViews.reserve(inputColumnViews.size() + precomputedColumns.size());
+  for (auto& precomputedCol : precomputedColumns) {
+    allColumnViews.push_back(asView(precomputedCol));
+  }
+
+  cudf::table_view astInputTableView(allColumnViews);
+
+  auto result = [&]() -> ColumnOrView {
+    if (auto colRefPtr = dynamic_cast<cudf::ast::column_reference const*>(
+            &expr_.cudfTree_.back())) {
+      auto columnIndex = colRefPtr->get_column_index();
+      if (columnIndex < inputColumnViews.size()) {
+        return inputColumnViews[columnIndex];
+      } else {
+        // Referencing a precomputed column return as it is (view or owned)
+        return std::move(
+            precomputedColumns[columnIndex - inputColumnViews.size()]);
+      }
+    } else {
+      return cudf::compute_column_jit(
+          astInputTableView, expr_.cudfTree_.back(), stream, mr);
+    }
+  }();
+  if (finalize) {
+    const auto requestedType =
+        cudf_velox::veloxToCudfDataType(expr_.expr_->type());
+    auto resultView = asView(result);
+    if (resultView.type() != requestedType) {
+      result = cudf::cast(resultView, requestedType, stream, mr);
+    }
+  }
+  return result;
+}
+
+bool JitExpression::canEvaluate(std::shared_ptr<velox::exec::Expr> expr) {
+  return ASTExpression::canEvaluate(expr);
+}
+
+void registerJitEvaluator(int priority) {
+  registerCudfExpressionEvaluator(
+      kJitEvaluatorName,
+      priority,
+      [](std::shared_ptr<velox::exec::Expr> expr) {
+        return JitExpression::canEvaluate(expr);
+      },
+      [](std::shared_ptr<velox::exec::Expr> expr, const RowTypePtr& row) {
+        return std::make_shared<JitExpression>(std::move(expr), row);
+      },
+      /*overwrite=*/false);
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/JitExpression.h b/velox/experimental/cudf/expression/JitExpression.h
new file mode 100644
index 00000000000..73ca9ccff09
--- /dev/null
+++ b/velox/experimental/cudf/expression/JitExpression.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/experimental/cudf/expression/AstExpression.h"
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
+
+#include <cudf/ast/expressions.hpp>
+
+namespace facebook::velox::cudf_velox {
+
+const std::string kJitEvaluatorName = "jit";
+
+// Evaluates the JIT expression tree
+class JitExpression : public CudfExpression {
+ public:
+  JitExpression() = default;
+  // Converts velox expressions to cudf::ast::tree, scalars and
+  // precompute instructions and stores them
+  JitExpression(
+      std::shared_ptr<velox::exec::Expr> expr,
+      const RowTypePtr& inputRowSchema);
+
+  // Evaluates the expression tree for the given input columns
+  ColumnOrView eval(
+      std::vector<cudf::column_view> inputColumnViews,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr,
+      bool finalize = false) override;
+
+  void close() override;
+
+  // Check if this specific operation (not its children) can be evaluated by
+  // JitExpression
+  static bool canEvaluate(std::shared_ptr<velox::exec::Expr> expr);
+
+ private:
+  ASTExpression expr_;
+};
+
+void registerJitEvaluator(int priority);
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/PrecomputeInstruction.h b/velox/experimental/cudf/expression/PrecomputeInstruction.h
new file mode 100644
index 00000000000..4e8fb024ee1
--- /dev/null
+++ b/velox/experimental/cudf/expression/PrecomputeInstruction.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
+
+#include <cudf/ast/expressions.hpp>
+
+#include <utility>
+
+namespace facebook::velox::cudf_velox {
+
+// Pre-compute instructions for the expression,
+// for ops that are not supported by cudf::ast
+struct PrecomputeInstruction {
+  int dependent_column_index;
+  std::string ins_name;
+  int new_column_index;
+  std::vector<int> nested_dependent_column_indices;
+  std::shared_ptr<CudfExpression> cudf_expression;
+
+  // Constructor to initialize the struct with values
+  PrecomputeInstruction(
+      int depIndex,
+      const std::string& name,
+      int newIndex,
+      const std::shared_ptr<CudfExpression>& node = nullptr)
+      : dependent_column_index(depIndex),
+        ins_name(name),
+        new_column_index(newIndex),
+        cudf_expression(node) {}
+
+  // TODO (dm): This two ctor situation is crazy.
+  PrecomputeInstruction(
+      int depIndex,
+      const std::string& name,
+      int newIndex,
+      std::vector<int>&& nestedIndices,
+      const std::shared_ptr<CudfExpression>& node = nullptr)
+      : dependent_column_index(depIndex),
+        ins_name(name),
+        new_column_index(newIndex),
+        nested_dependent_column_indices(std::move(nestedIndices)),
+        cudf_expression(node) {}
+};
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/PrestoFunctions.cpp b/velox/experimental/cudf/expression/PrestoFunctions.cpp
new file mode 100644
index 00000000000..e46baf28f21
--- /dev/null
+++ b/velox/experimental/cudf/expression/PrestoFunctions.cpp
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
+#include "velox/experimental/cudf/expression/PrestoFunctions.h"
+
+namespace facebook::velox::cudf_velox {
+
+void registerPrestoFunctions(const std::string& prefix) {
+  // Presto-specific functions will be registered here in the future
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/PrestoFunctions.h b/velox/experimental/cudf/expression/PrestoFunctions.h
new file mode 100644
index 00000000000..6e4ca8272dd
--- /dev/null
+++ b/velox/experimental/cudf/expression/PrestoFunctions.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace facebook::velox::cudf_velox {
+
+/// Register Presto-specific CUDF functions.
+void registerPrestoFunctions(const std::string& prefix);
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/SparkFunctions.cpp b/velox/experimental/cudf/expression/SparkFunctions.cpp
new file mode 100644
index 00000000000..7a3c33e7dc6
--- /dev/null
+++ b/velox/experimental/cudf/expression/SparkFunctions.cpp
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/expression/AstUtils.h"
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
+#include "velox/experimental/cudf/expression/SparkFunctions.h"
+
+#include "velox/expression/ConstantExpr.h"
+#include "velox/expression/FunctionSignature.h"
+#include "velox/vector/BaseVector.h"
+
+#include <cudf/binaryop.hpp>
+#include <cudf/hashing.hpp>
+#include <cudf/table/table.hpp>
+
+namespace facebook::velox::cudf_velox {
+namespace {
+
+// Spark date_add function implementation.
+// For the presto date_add, the first value is unit string,
+// may need to get the function with prefix, if the prefix is "", it is Spark
+// function.
+class DateAddFunction : public CudfFunction {
+ public:
+  DateAddFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    VELOX_CHECK_EQ(
+        expr->inputs().size(), 2, "date_add function expects exactly 2 inputs");
+    VELOX_CHECK(
+        expr->inputs()[0]->type()->isDate(),
+        "First argument to date_add must be a date");
+    VELOX_CHECK_NULL(
+        std::dynamic_pointer_cast<velox::exec::ConstantExpr>(
+            expr->inputs()[0]));
+    // The date_add second argument could be int8_t, int16_t, int32_t.
+    value_ = makeScalarFromConstantExpr(
+        expr->inputs()[1], cudf::type_id::DURATION_DAYS);
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    auto inputCol = asView(inputColumns[0]);
+    return cudf::binary_operation(
+        inputCol,
+        *value_,
+        cudf::binary_operator::ADD,
+        cudf::data_type(cudf::type_id::TIMESTAMP_DAYS),
+        stream,
+        mr);
+  }
+
+ private:
+  std::unique_ptr<cudf::scalar> value_;
+};
+
+class HashFunction : public CudfFunction {
+ public:
+  HashFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    using velox::exec::ConstantExpr;
+    VELOX_CHECK_GE(expr->inputs().size(), 2, "hash expects at least 2 inputs");
+    auto seedExpr = std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[0]);
+    VELOX_CHECK_NOT_NULL(seedExpr, "hash seed must be a constant");
+    int32_t seedValue =
+        seedExpr->value()->as<SimpleVector<int32_t>>()->valueAt(0);
+    VELOX_CHECK_GE(seedValue, 0);
+    seedValue_ = seedValue;
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    VELOX_CHECK(!inputColumns.empty());
+    auto inputTableView = convertToTableView(inputColumns);
+    return cudf::hashing::murmurhash3_x86_32(
+        inputTableView, seedValue_, stream, mr);
+  }
+
+ private:
+  static cudf::table_view convertToTableView(
+      std::vector<ColumnOrView>& inputColumns) {
+    std::vector<cudf::column_view> columns;
+    columns.reserve(inputColumns.size());
+
+    for (auto& col : inputColumns) {
+      columns.push_back(asView(col));
+    }
+
+    return cudf::table_view(columns);
+  }
+
+  uint32_t seedValue_;
+};
+
+} // namespace
+
+void registerSparkFunctions(const std::string& prefix) {
+  using exec::FunctionSignatureBuilder;
+
+  registerCudfFunction(
+      prefix + "hash_with_seed",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<HashFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("bigint")
+           .constantArgumentType("integer")
+           .argumentType("any")
+           .build()});
+
+  registerCudfFunction(
+      prefix + "date_add",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<DateAddFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("date")
+           .argumentType("date")
+           .constantArgumentType("tinyint")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("date")
+           .argumentType("date")
+           .constantArgumentType("smallint")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("date")
+           .argumentType("date")
+           .constantArgumentType("integer")
+           .build()});
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/SparkFunctions.h b/velox/experimental/cudf/expression/SparkFunctions.h
new file mode 100644
index 00000000000..82cc212241d
--- /dev/null
+++ b/velox/experimental/cudf/expression/SparkFunctions.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace facebook::velox::cudf_velox {
+
+/// Register Spark-specific CUDF functions.
+void registerSparkFunctions(const std::string& prefix);
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/SubfieldFiltersToAst.cpp b/velox/experimental/cudf/expression/SubfieldFiltersToAst.cpp
new file mode 100644
index 00000000000..1c2507a56d7
--- /dev/null
+++ b/velox/experimental/cudf/expression/SubfieldFiltersToAst.cpp
@@ -0,0 +1,555 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/cudf/expression/AstUtils.h"
+#include "velox/experimental/cudf/expression/SubfieldFiltersToAst.h"
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/type/DecimalUtil.h"
+
+#include <cudf/ast/detail/expression_parser.hpp>
+#include <cudf/ast/expressions.hpp>
+#include <cudf/scalar/scalar_device_view.cuh>
+#include <cudf/types.hpp>
+
+#include <limits>
+
+namespace facebook::velox::cudf_velox {
+namespace {
+std::pair<int128_t, int128_t> getInt128BoundsForType(const TypePtr& type) {
+  if (type->isDecimal()) {
+    const auto [precision, _] = getDecimalPrecisionScale(*type);
+    const auto maxAbs = DecimalUtil::kPowersOfTen[precision] - 1;
+    return {-maxAbs, maxAbs};
+  }
+  return {
+      std::numeric_limits<int128_t>::min(),
+      std::numeric_limits<int128_t>::max()};
+}
+
+template <
+    typename RangeT,
+    typename ScalarT,
+    typename = std::enable_if_t<
+        std::is_base_of_v<facebook::velox::common::AbstractRange, RangeT>>>
+const cudf::ast::expression& createRangeExpr(
+    const facebook::velox::common::Filter& filter,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const cudf::ast::expression& columnRef,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  using Op = cudf::ast::ast_operator;
+  using Operation = cudf::ast::operation;
+
+  auto* range = dynamic_cast<const RangeT*>(&filter);
+  VELOX_CHECK_NOT_NULL(range, "Filter is not the expected range type");
+
+  const bool lowerUnbounded = range->lowerUnbounded();
+  const bool upperUnbounded = range->upperUnbounded();
+
+  const cudf::ast::expression* lowerExpr = nullptr;
+  const cudf::ast::expression* upperExpr = nullptr;
+
+  auto addLiteral = [&](auto value) -> const cudf::ast::expression& {
+    scalars.emplace_back(std::make_unique<ScalarT>(value, true, stream, mr));
+    stream.synchronize();
+    return tree.push(
+        cudf::ast::literal{*static_cast<ScalarT*>(scalars.back().get())});
+  };
+
+  // If RangeT is BytesValues and it's a single value, return a simple equality
+  // expression. This is an early return for the single-value IN-list filter on
+  // bytes.
+  if constexpr (std::is_same_v<RangeT, facebook::velox::common::BytesRange>) {
+    if (range->isSingleValue()) {
+      // Only one value in the IN-list, so just compare for equality.
+      auto singleValue = range->lower();
+      const auto& literal = addLiteral(singleValue);
+      return tree.push(Operation{Op::EQUAL, columnRef, literal});
+    }
+  }
+
+  if (!lowerUnbounded) {
+    auto lowerValue = range->lower();
+    const auto& lowerLiteral = addLiteral(lowerValue);
+
+    auto lowerOp = range->lowerExclusive() ? Op::GREATER : Op::GREATER_EQUAL;
+    lowerExpr = &tree.push(Operation{lowerOp, columnRef, lowerLiteral});
+  }
+
+  if (!upperUnbounded) {
+    auto upperValue = range->upper();
+    const auto& upperLiteral = addLiteral(upperValue);
+
+    auto upperOp = range->upperExclusive() ? Op::LESS : Op::LESS_EQUAL;
+    upperExpr = &tree.push(Operation{upperOp, columnRef, upperLiteral});
+  }
+
+  if (lowerExpr && upperExpr) {
+    return tree.push(Operation{Op::NULL_LOGICAL_AND, *lowerExpr, *upperExpr});
+  } else if (lowerExpr) {
+    return *lowerExpr;
+  } else if (upperExpr) {
+    return *upperExpr;
+  }
+
+  // Both bounds unbounded => Pass-through filter (everything).
+  return tree.push(Operation{Op::EQUAL, columnRef, columnRef});
+}
+
+template <TypeKind Kind, typename FilterT>
+std::reference_wrapper<const cudf::ast::expression> buildIntegerRangeExpr(
+    const common::Filter& filter,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const cudf::ast::expression& columnRef,
+    const TypePtr& columnTypePtr) {
+  using NativeT = typename TypeTraits<Kind>::NativeType;
+
+  if constexpr (
+      (std::is_same_v<FilterT, common::BigintRange> &&
+       std::is_integral_v<NativeT>) ||
+      std::is_same_v<FilterT, common::HugeintRange>) {
+    using Op = cudf::ast::ast_operator;
+    using Operation = cudf::ast::operation;
+
+    auto* rangeFilter = static_cast<const FilterT*>(&filter);
+    const auto lower = rangeFilter->lower();
+    const auto upper = rangeFilter->upper();
+    using ValueT = std::decay_t<decltype(lower)>;
+
+    const auto [minBound, maxBound] = [&]() -> std::pair<ValueT, ValueT> {
+      if constexpr (std::is_same_v<FilterT, common::HugeintRange>) {
+        return getInt128BoundsForType(columnTypePtr);
+      } else {
+        return {
+            static_cast<ValueT>(std::numeric_limits<NativeT>::min()),
+            static_cast<ValueT>(std::numeric_limits<NativeT>::max())};
+      }
+    }();
+
+    const bool skipLowerBound = lower <= minBound;
+    const bool skipUpperBound = upper >= maxBound;
+
+    auto addLiteral = [&](ValueT value) -> const cudf::ast::expression& {
+      variant veloxVariant = static_cast<NativeT>(value);
+      const auto& literal =
+          makeScalarAndLiteral<Kind>(columnTypePtr, veloxVariant, scalars);
+      return tree.push(literal);
+    };
+
+    if (lower == upper) {
+      // Equal comparison: column = value.
+      if (lower < minBound || lower > maxBound) {
+        // Value is outside the representable range of NativeT, always false.
+        return tree.push(Operation{Op::NOT_EQUAL, columnRef, columnRef});
+      }
+      auto const& literal = addLiteral(lower);
+      return tree.push(Operation{Op::EQUAL, columnRef, literal});
+    }
+
+    // Range comparison: column >= lower AND column <= upper.
+    const cudf::ast::expression* lowerExpr = nullptr;
+    if (!skipLowerBound) {
+      auto const& lowerLiteral = addLiteral(lower);
+      lowerExpr =
+          &tree.push(Operation{Op::GREATER_EQUAL, columnRef, lowerLiteral});
+    }
+    const cudf::ast::expression* upperExpr = nullptr;
+    if (!skipUpperBound) {
+      auto const& upperLiteral = addLiteral(upper);
+      upperExpr =
+          &tree.push(Operation{Op::LESS_EQUAL, columnRef, upperLiteral});
+    }
+    if (lowerExpr && upperExpr) {
+      return tree.push(Operation{Op::NULL_LOGICAL_AND, *lowerExpr, *upperExpr});
+    } else if (lowerExpr) {
+      return *lowerExpr;
+    } else if (upperExpr) {
+      return *upperExpr;
+    }
+
+    // If neither lower nor upper bound expressions were created, it means
+    // the filter covers the entire range of the type, so it's a no-op.
+    return tree.push(Operation{Op::EQUAL, columnRef, columnRef});
+  } else {
+    VELOX_FAIL("Unsupported type for buildRangeExpr: {}", Kind);
+  }
+}
+
+template <TypeKind Kind>
+std::reference_wrapper<const cudf::ast::expression> buildBigintRangeExpr(
+    const common::Filter& filter,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const cudf::ast::expression& columnRef,
+    const TypePtr& columnTypePtr) {
+  return buildIntegerRangeExpr<Kind, common::BigintRange>(
+      filter, tree, scalars, columnRef, columnTypePtr);
+}
+
+std::reference_wrapper<const cudf::ast::expression> buildHugeintRangeExpr(
+    const common::Filter& filter,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const cudf::ast::expression& columnRef,
+    const TypePtr& columnTypePtr) {
+  return buildIntegerRangeExpr<TypeKind::HUGEINT, common::HugeintRange>(
+      filter, tree, scalars, columnRef, columnTypePtr);
+}
+
+template <TypeKind Kind, typename FilterT, typename ValueT>
+const cudf::ast::expression& buildValuesListExpr(
+    const common::Filter& filter,
+    cudf::ast::tree& tree,
+    const cudf::ast::expression& columnRef,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const TypePtr& columnTypePtr,
+    bool isNegated = false) {
+  using Op = cudf::ast::ast_operator;
+  using Operation = cudf::ast::operation;
+
+  auto* valuesFilter = dynamic_cast<const FilterT*>(&filter);
+  VELOX_CHECK_NOT_NULL(valuesFilter, "Filter is not a values list filter");
+  auto const& values = valuesFilter->values();
+  VELOX_CHECK(!values.empty(), "Empty List filter not supported");
+
+  std::vector<const cudf::ast::expression*> exprVec;
+  for (const auto& value : values) {
+    variant veloxVariant = static_cast<ValueT>(value);
+    auto const& literal = tree.push(
+        makeScalarAndLiteral<Kind>(columnTypePtr, veloxVariant, scalars));
+    auto const& equalExpr = tree.push(
+        Operation{isNegated ? Op::NOT_EQUAL : Op::EQUAL, columnRef, literal});
+    exprVec.push_back(&equalExpr);
+  }
+
+  const cudf::ast::expression* result = exprVec[0];
+  for (size_t i = 1; i < exprVec.size(); ++i) {
+    result = &tree.push(
+        Operation{
+            isNegated ? Op::NULL_LOGICAL_AND : Op::NULL_LOGICAL_OR,
+            *result,
+            *exprVec[i]});
+  }
+
+  return *result;
+}
+
+template <typename T>
+auto createFloatingPointRangeExpr(
+    const common::Filter& filter,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const cudf::ast::expression& columnRef,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) -> const cudf::ast::expression& {
+  return createRangeExpr<
+      facebook::velox::common::FloatingPointRange<T>,
+      cudf::numeric_scalar<T>>(filter, tree, scalars, columnRef, stream, mr);
+};
+
+const cudf::ast::expression& createBytesRangeExpr(
+    const common::Filter& filter,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const cudf::ast::expression& columnRef,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  return createRangeExpr<
+      facebook::velox::common::BytesRange,
+      cudf::string_scalar>(filter, tree, scalars, columnRef, stream, mr);
+}
+
+// Build an IN-list expression for integer columns where the filter values are
+// provided as int64_t but the column may be any integral type. Values outside
+// the target type's range are ignored. If all values are out of range, this
+// returns a constant false expression (col != col).
+template <TypeKind Kind>
+std::reference_wrapper<const cudf::ast::expression> buildIntegerInListExpr(
+    const common::Filter& filter,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const cudf::ast::expression& columnRef,
+    rmm::cuda_stream_view /*stream*/,
+    rmm::device_async_resource_ref /*mr*/,
+    const TypePtr& columnTypePtr) {
+  using NativeT = typename TypeTraits<Kind>::NativeType;
+
+  if constexpr (std::is_integral_v<NativeT>) {
+    using Op = cudf::ast::ast_operator;
+    using Operation = cudf::ast::operation;
+
+    auto* valuesFilter =
+        static_cast<const common::BigintValuesUsingBitmask*>(&filter);
+    const auto& values = valuesFilter->values();
+
+    std::vector<const cudf::ast::expression*> exprVec;
+    exprVec.reserve(values.size());
+
+    for (const int64_t value : values) {
+      if (value < static_cast<int64_t>(std::numeric_limits<NativeT>::min()) ||
+          value > static_cast<int64_t>(std::numeric_limits<NativeT>::max())) {
+        // Skip values that cannot be represented in the column type.
+        continue;
+      }
+
+      variant veloxVariant = static_cast<NativeT>(value);
+      const auto& literal =
+          makeScalarAndLiteral<Kind>(columnTypePtr, veloxVariant, scalars);
+      auto const& cudfLiteral = tree.push(literal);
+      auto const& equalExpr =
+          tree.push(Operation{Op::EQUAL, columnRef, cudfLiteral});
+      exprVec.push_back(&equalExpr);
+    }
+
+    if (exprVec.empty()) {
+      // No representable values -> always false
+      auto const& alwaysFalse =
+          tree.push(Operation{Op::NOT_EQUAL, columnRef, columnRef});
+      return std::ref(alwaysFalse);
+    }
+
+    const cudf::ast::expression* result = exprVec[0];
+    for (size_t i = 1; i < exprVec.size(); ++i) {
+      result = &tree.push(Operation{Op::NULL_LOGICAL_OR, *result, *exprVec[i]});
+    }
+    return std::ref(*result);
+  } else {
+    VELOX_FAIL("Unsupported type for buildIntegerInListExpr: {}", Kind);
+  }
+}
+
+} // namespace
+
+// Convert subfield filters to cudf AST
+cudf::ast::expression const& createAstFromSubfieldFilter(
+    const common::Subfield& subfield,
+    const common::Filter& filter,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const RowTypePtr& inputRowSchema) {
+  // First, create column reference from subfield
+  // For now, only support simple field references
+  if (subfield.path().empty() ||
+      subfield.path()[0]->kind() != common::SubfieldKind::kNestedField) {
+    VELOX_FAIL(
+        "Only simple field references are supported in subfield filters");
+  }
+
+  auto nestedField = static_cast<const common::Subfield::NestedField*>(
+      subfield.path()[0].get());
+  const std::string& fieldName = nestedField->name();
+
+  if (!inputRowSchema->containsChild(fieldName)) {
+    VELOX_FAIL("Field '{}' not found in input schema", fieldName);
+  }
+
+  auto columnIndex = inputRowSchema->getChildIdx(fieldName);
+  auto const& columnRef = tree.push(cudf::ast::column_reference(columnIndex));
+
+  using Op = cudf::ast::ast_operator;
+  using Operation = cudf::ast::operation;
+
+  auto stream = cudf::get_default_stream(cudf::allow_default_stream);
+  auto mr = get_temp_mr();
+
+  switch (filter.kind()) {
+    case common::FilterKind::kBigintRange: {
+      auto const& columnType = inputRowSchema->childAt(columnIndex);
+      auto result = VELOX_DYNAMIC_TYPE_DISPATCH(
+          buildBigintRangeExpr,
+          columnType->kind(),
+          filter,
+          tree,
+          scalars,
+          columnRef,
+          columnType);
+      return result.get();
+    }
+
+    case common::FilterKind::kHugeintRange: {
+      auto const& columnType = inputRowSchema->childAt(columnIndex);
+      auto const& expr =
+          buildHugeintRangeExpr(filter, tree, scalars, columnRef, columnType);
+      return expr.get();
+    }
+
+    case common::FilterKind::kBigintValuesUsingHashTable: {
+      auto const& columnType = inputRowSchema->childAt(columnIndex);
+      return buildValuesListExpr<
+          TypeKind::BIGINT,
+          common::BigintValuesUsingHashTable,
+          int64_t>(filter, tree, columnRef, scalars, columnType);
+    }
+
+    case common::FilterKind::kBigintValuesUsingBitmask: {
+      auto const& columnType = inputRowSchema->childAt(columnIndex);
+      // Dispatch by the column's integer kind and cast filter values to it.
+      auto result = VELOX_DYNAMIC_TYPE_DISPATCH(
+          buildIntegerInListExpr,
+          columnType->kind(),
+          filter,
+          tree,
+          scalars,
+          columnRef,
+          stream,
+          mr,
+          columnType);
+      return result.get();
+    }
+
+    case common::FilterKind::kHugeintValuesUsingHashTable: {
+      auto const& columnType = inputRowSchema->childAt(columnIndex);
+      return buildValuesListExpr<
+          TypeKind::HUGEINT,
+          common::HugeintValuesUsingHashTable,
+          int128_t>(filter, tree, columnRef, scalars, columnType);
+    }
+
+    case common::FilterKind::kBytesValues: {
+      auto const& columnType = inputRowSchema->childAt(columnIndex);
+      return buildValuesListExpr<
+          TypeKind::VARCHAR,
+          common::BytesValues,
+          StringView>(filter, tree, columnRef, scalars, columnType);
+    }
+
+    case common::FilterKind::kNegatedBytesValues: {
+      auto const& columnType = inputRowSchema->childAt(columnIndex);
+      return buildValuesListExpr<
+          TypeKind::VARCHAR,
+          common::NegatedBytesValues,
+          StringView>(filter, tree, columnRef, scalars, columnType, true);
+    }
+
+    case common::FilterKind::kDoubleRange: {
+      return createFloatingPointRangeExpr<double>(
+          filter, tree, scalars, columnRef, stream, mr);
+    }
+
+    case common::FilterKind::kFloatRange: {
+      return createFloatingPointRangeExpr<float>(
+          filter, tree, scalars, columnRef, stream, mr);
+    }
+
+    case common::FilterKind::kBytesRange: {
+      return createBytesRangeExpr(filter, tree, scalars, columnRef, stream, mr);
+    }
+
+    case common::FilterKind::kBoolValue: {
+      auto* boolValue = static_cast<const common::BoolValue*>(&filter);
+      auto matchesTrue = boolValue->testBool(true);
+      scalars.emplace_back(
+          std::make_unique<cudf::numeric_scalar<bool>>(
+              matchesTrue, true, stream, mr));
+      stream.synchronize();
+      auto const& matchesBoolExpr = tree.push(
+          cudf::ast::literal{
+              *static_cast<cudf::numeric_scalar<bool>*>(scalars.back().get())});
+      return tree.push(Operation{Op::EQUAL, columnRef, matchesBoolExpr});
+    }
+
+    case common::FilterKind::kIsNull: {
+      return tree.push(Operation{Op::IS_NULL, columnRef});
+    }
+
+    case common::FilterKind::kIsNotNull: {
+      // For IsNotNull, we can use NOT(IS_NULL)
+      auto const& nullCheck = tree.push(Operation{Op::IS_NULL, columnRef});
+      return tree.push(Operation{Op::NOT, nullCheck});
+    }
+
+    case common::FilterKind::kBigintMultiRange:
+    case common::FilterKind::kMultiRange: {
+      // Both multi-range types recurse into sub-filters and combine with OR.
+      std::vector<const common::Filter*> subFilters;
+      if (filter.kind() == common::FilterKind::kBigintMultiRange) {
+        auto* multiRange =
+            static_cast<const common::BigintMultiRange*>(&filter);
+        for (const auto& range : multiRange->ranges()) {
+          subFilters.push_back(range.get());
+        }
+      } else {
+        auto* multiRange = static_cast<const common::MultiRange*>(&filter);
+        for (const auto& f : multiRange->filters()) {
+          subFilters.push_back(f.get());
+        }
+      }
+      VELOX_CHECK(!subFilters.empty(), "MultiRange filter must not be empty");
+
+      std::vector<const cudf::ast::expression*> exprRefs;
+      exprRefs.reserve(subFilters.size());
+      for (const auto* subFilter : subFilters) {
+        auto const& subExpr = createAstFromSubfieldFilter(
+            subfield, *subFilter, tree, scalars, inputRowSchema);
+        exprRefs.push_back(&subExpr);
+      }
+
+      const cudf::ast::expression* result = exprRefs[0];
+      for (size_t i = 1; i < exprRefs.size(); ++i) {
+        result =
+            &tree.push(Operation{Op::NULL_LOGICAL_OR, *result, *exprRefs[i]});
+      }
+      return *result;
+    }
+
+    default:
+      VELOX_NYI(
+          "Filter type {} not yet supported for subfield filter conversion",
+          static_cast<int>(filter.kind()));
+  }
+}
+
+// Create a combined AST from a set of subfield filters by chaining them with
+// logical ANDs. The returned expression is owned by the provided 'tree'.
+cudf::ast::expression const& createAstFromSubfieldFilters(
+    const common::SubfieldFilters& subfieldFilters,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const RowTypePtr& inputRowSchema) {
+  using Op = cudf::ast::ast_operator;
+  using Operation = cudf::ast::operation;
+
+  std::vector<const cudf::ast::expression*> exprRefs;
+
+  // Build individual filter expressions.
+  for (const auto& [subfield, filterPtr] : subfieldFilters) {
+    if (!filterPtr) {
+      continue;
+    }
+    auto const& expr = createAstFromSubfieldFilter(
+        subfield, *filterPtr, tree, scalars, inputRowSchema);
+    exprRefs.push_back(&expr);
+  }
+
+  VELOX_CHECK_GT(exprRefs.size(), 0, "No subfield filters provided");
+
+  if (exprRefs.size() == 1) {
+    return *exprRefs[0];
+  }
+
+  // Combine expressions with NULL_LOGICAL_AND.
+  const cudf::ast::expression* result = exprRefs[0];
+  for (size_t i = 1; i < exprRefs.size(); ++i) {
+    auto const& andExpr =
+        tree.push(Operation{Op::NULL_LOGICAL_AND, *result, *exprRefs[i]});
+    result = &andExpr;
+  }
+
+  return *result;
+}
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/SubfieldFiltersToAst.h b/velox/experimental/cudf/expression/SubfieldFiltersToAst.h
new file mode 100644
index 00000000000..e44e2bea15b
--- /dev/null
+++ b/velox/experimental/cudf/expression/SubfieldFiltersToAst.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/type/Filter.h"
+#include "velox/type/Subfield.h"
+#include "velox/type/Type.h"
+
+#include <cudf/ast/expressions.hpp>
+#include <cudf/scalar/scalar.hpp>
+
+#include <memory>
+#include <vector>
+
+namespace cudf {
+namespace ast {
+class tree;
+}
+} // namespace cudf
+
+namespace facebook::velox::cudf_velox {
+
+// Convert subfield filters to cudf AST
+cudf::ast::expression const& createAstFromSubfieldFilter(
+    const common::Subfield& subfield,
+    const common::Filter& filter,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const RowTypePtr& inputRowSchema);
+
+// Build a single AST expression representing logical AND of all filters in
+// 'subfieldFilters'. The resulting expression reference is owned by the passed
+// 'tree'.
+cudf::ast::expression const& createAstFromSubfieldFilters(
+    const common::SubfieldFilters& subfieldFilters,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const RowTypePtr& inputRowSchema);
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/tests/AdapterOperatorTest.cpp b/velox/experimental/cudf/tests/AdapterOperatorTest.cpp
new file mode 100644
index 00000000000..5cbcb558bea
--- /dev/null
+++ b/velox/experimental/cudf/tests/AdapterOperatorTest.cpp
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/tests/CudfFunctionBaseTest.h"
+
+#include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+class AdapterOperatorTest : public OperatorTestBase {
+ protected:
+  void SetUp() override {
+    OperatorTestBase::SetUp();
+    cudf_velox::CudfConfig::getInstance().allowCpuFallback = false;
+    cudf_velox::registerCudf();
+  }
+
+  void TearDown() override {
+    cudf_velox::unregisterCudf();
+    OperatorTestBase::TearDown();
+  }
+};
+
+TEST_F(AdapterOperatorTest, adapterStatsMergedIntoPlanNode) {
+  auto data = makeRowVector({"c0"}, {makeFlatVector<int32_t>({1, 2, 3, 4, 5})});
+
+  core::PlanNodeId projNodeId;
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .project({"c0 * 2 as x"})
+                  .capturePlanNodeId(projNodeId)
+                  .planNode();
+
+  std::shared_ptr<exec::Task> task;
+  AssertQueryBuilder(plan).copyResults(pool(), task);
+
+  auto stats = toPlanStats(task->taskStats());
+  auto& projStats = stats.at(projNodeId);
+
+  EXPECT_TRUE(projStats.isMultiOperatorTypeNode());
+  EXPECT_TRUE(projStats.operatorStats.count("CudfToVelox"));
+}
diff --git a/velox/experimental/cudf/tests/AggregationSelectionTest.cpp b/velox/experimental/cudf/tests/AggregationSelectionTest.cpp
new file mode 100644
index 00000000000..c1f8e179c6f
--- /dev/null
+++ b/velox/experimental/cudf/tests/AggregationSelectionTest.cpp
@@ -0,0 +1,756 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/exec/CudfAggregation.h"
+#include "velox/experimental/cudf/exec/CudfGroupby.h"
+#include "velox/experimental/cudf/exec/CudfReduce.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
+#include "velox/experimental/cudf/tests/utils/ExpressionTestUtil.h"
+
+#include "velox/common/memory/Memory.h"
+
+namespace {
+// Simple wrapper for test compatibility - checks if an aggregation function
+// is supported in either the groupby or reduce registry (kSingle step).
+bool canAggregationBeEvaluatedByCudf(
+    const facebook::velox::core::CallTypedExpr& call,
+    facebook::velox::core::QueryCtx* queryCtx) {
+  std::vector<facebook::velox::TypePtr> rawInputTypes;
+  for (const auto& input : call.inputs()) {
+    rawInputTypes.push_back(input->type());
+  }
+  return facebook::velox::cudf_velox::canGroupbyAggregationBeEvaluatedByCudf(
+             call,
+             facebook::velox::core::AggregationNode::Step::kSingle,
+             rawInputTypes,
+             queryCtx) ||
+      facebook::velox::cudf_velox::canReduceAggregationBeEvaluatedByCudf(
+             call,
+             facebook::velox::core::AggregationNode::Step::kSingle,
+             rawInputTypes,
+             queryCtx);
+}
+} // namespace
+#include "velox/core/QueryCtx.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/functions/sparksql/registration/Register.h"
+#include "velox/parse/TypeResolver.h"
+#include "velox/type/Type.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+#include <gtest/gtest.h>
+
+using namespace facebook::velox;
+using namespace facebook::velox::cudf_velox;
+using namespace facebook::velox::cudf_velox::test_utils;
+using namespace facebook::velox::exec::test;
+
+namespace {
+
+class CudfAggregationSelectionTest : public ::testing::Test,
+                                     public test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    pool_ = memory::memoryManager()->addLeafPool();
+    queryCtx_ = core::QueryCtx::create();
+    execCtx_ = std::make_unique<core::ExecCtx>(pool_.get(), queryCtx_.get());
+    facebook::velox::functions::prestosql::registerAllScalarFunctions();
+    facebook::velox::aggregate::prestosql::registerAllAggregateFunctions();
+    cudf_velox::registerCudf();
+
+    rowType_ = ROW({
+        {"c0", BIGINT()},
+        {"c1", BIGINT()},
+        {"c2", INTEGER()},
+        {"c3", DOUBLE()},
+        {"c4", REAL()},
+        {"c5", DOUBLE()},
+        {"c6", VARCHAR()},
+        {"c7", BOOLEAN()},
+    });
+
+    parse::registerTypeResolver();
+  }
+
+  void TearDown() override {
+    cudf_velox::unregisterCudf();
+    execCtx_.reset();
+    queryCtx_.reset();
+    pool_.reset();
+  }
+
+  std::shared_ptr<const core::AggregationNode> createAggregationNode(
+      const std::vector<std::string>& groupingKeys,
+      const std::vector<std::string>& aggregates) {
+    auto plan = PlanBuilder()
+                    .values({makeRowVector({
+                        makeFlatVector<int64_t>({1, 2, 3}),
+                        makeFlatVector<int64_t>({10, 20, 30}),
+                        makeFlatVector<int32_t>({100, 200, 300}),
+                        makeFlatVector<double>({1.1, 2.2, 3.3}),
+                        makeFlatVector<float>({1.5f, 2.5f, 3.5f}),
+                        makeFlatVector<double>({10.1, 20.2, 30.3}),
+                        makeFlatVector<std::string>({"a", "b", "c"}),
+                        makeFlatVector<bool>({true, false, true}),
+                    })})
+                    .aggregation(
+                        groupingKeys,
+                        aggregates,
+                        {},
+                        core::AggregationNode::Step::kSingle,
+                        false)
+                    .planNode();
+
+    return std::dynamic_pointer_cast<const core::AggregationNode>(plan);
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_;
+  std::shared_ptr<core::QueryCtx> queryCtx_;
+  std::unique_ptr<core::ExecCtx> execCtx_;
+  RowTypePtr rowType_;
+};
+
+// Test supported aggregation functions
+TEST_F(CudfAggregationSelectionTest, supportedAggregationFunctions) {
+  auto aggregationNode = createAggregationNode(
+      {"c0"}, {"sum(c1)", "count(c2)", "min(c3)", "max(c4)", "avg(c5)"});
+
+  ASSERT_TRUE(canBeEvaluatedByCudf(*aggregationNode, queryCtx_.get()));
+}
+
+// Test stddev_samp is supported
+TEST_F(CudfAggregationSelectionTest, stddevSampSupported) {
+  auto aggregationNode =
+      createAggregationNode({"c0"}, {"stddev_samp(c1)", "stddev_samp(c5)"});
+
+  ASSERT_TRUE(canBeEvaluatedByCudf(*aggregationNode, queryCtx_.get()));
+}
+
+// Test unsupported aggregation functions
+TEST_F(CudfAggregationSelectionTest, unsupportedAggregationFunctions) {
+  auto aggregationNode =
+      createAggregationNode({"c0"}, {"stddev(c1)", "variance(c2)"});
+
+  ASSERT_FALSE(canBeEvaluatedByCudf(*aggregationNode, queryCtx_.get()));
+}
+
+// Test mixed supported and unsupported functions - should reject if any
+// function is unsupported
+TEST_F(CudfAggregationSelectionTest, mixedSupportedUnsupportedFunctions) {
+  auto aggregationNode =
+      createAggregationNode({"c0"}, {"sum(c1)", "variance(c2)"});
+
+  ASSERT_FALSE(canBeEvaluatedByCudf(*aggregationNode, queryCtx_.get()));
+}
+
+// Test supported grouping key expressions (simple field references)
+TEST_F(CudfAggregationSelectionTest, supportedGroupingKeyExpressions) {
+  auto aggregationNode = createAggregationNode({"c0", "c1"}, {"sum(c2)"});
+
+  ASSERT_TRUE(canBeEvaluatedByCudf(*aggregationNode, queryCtx_.get()));
+}
+
+// Test unsupported aggregation functions (using variance as example)
+TEST_F(CudfAggregationSelectionTest, unsupportedGroupingKeyExpressions) {
+  auto aggregationNode =
+      createAggregationNode({"c0"}, {"sum(c1)", "variance(c2)"});
+
+  ASSERT_FALSE(canBeEvaluatedByCudf(*aggregationNode, queryCtx_.get()));
+}
+
+// Test supported aggregation input expressions
+TEST_F(CudfAggregationSelectionTest, supportedAggregationInputExpressions) {
+  auto aggregationNode =
+      createAggregationNode({"c0"}, {"sum(c1 + c2)", "max(length(c6))"});
+
+  ASSERT_TRUE(canBeEvaluatedByCudf(*aggregationNode, queryCtx_.get()));
+}
+
+// Test unsupported aggregation input expressions
+TEST_F(CudfAggregationSelectionTest, unsupportedAggregationInputExpressions) {
+  auto aggregationNode = createAggregationNode({"c0"}, {"variance(c1)"});
+
+  ASSERT_FALSE(canBeEvaluatedByCudf(*aggregationNode, queryCtx_.get()));
+}
+
+// Test global aggregation (no group by)
+TEST_F(CudfAggregationSelectionTest, globalAggregationSupported) {
+  auto aggregationNode =
+      createAggregationNode({}, {"sum(c1)", "count(c2)", "max(c3)"});
+
+  ASSERT_TRUE(canBeEvaluatedByCudf(*aggregationNode, queryCtx_.get()));
+}
+
+// Test global aggregation with unsupported functions
+TEST_F(CudfAggregationSelectionTest, globalAggregationUnsupported) {
+  auto aggregationNode = createAggregationNode({}, {"stddev(c1)"});
+
+  ASSERT_FALSE(canBeEvaluatedByCudf(*aggregationNode, queryCtx_.get()));
+}
+
+// Test complex groupby clause with expressions
+TEST_F(CudfAggregationSelectionTest, complexGroupbyClauseExpressions) {
+  auto plan =
+      PlanBuilder()
+          .values({makeRowVector({
+              makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+              makeFlatVector<int64_t>({10, 20, 30, 40, 50}),
+          })})
+          .project(
+              {"c0",
+               "c1",
+               "to_big_endian_64(c0) AS endian_c0"}) // to_big_endian_64 is
+                                                     // unsupported by CUDF
+          .aggregation(
+              {"endian_c0"},
+              {"sum(c1)"},
+              {},
+              core::AggregationNode::Step::kSingle,
+              false)
+          .planNode();
+
+  auto aggregationNode =
+      std::dynamic_pointer_cast<const core::AggregationNode>(plan);
+
+  ASSERT_FALSE(canBeEvaluatedByCudf(*aggregationNode, queryCtx_.get()));
+}
+
+// Test nested aggregation: allowed -> not allowed
+TEST_F(CudfAggregationSelectionTest, nestedAggregationAllowedToNotAllowed) {
+  auto innerPlan = PlanBuilder()
+                       .values({makeRowVector({
+                           makeFlatVector<int64_t>({1, 1, 2, 2, 3, 3}),
+                           makeFlatVector<int64_t>({10, 20, 30, 40, 50, 60}),
+                       })})
+                       .aggregation(
+                           {"c0"},
+                           {"sum(c1) AS inner_sum"},
+                           {},
+                           core::AggregationNode::Step::kSingle,
+                           false)
+                       .planNode();
+
+  auto outerPlan = PlanBuilder()
+                       .addNode([&](std::string id, core::PlanNodePtr input) {
+                         return innerPlan;
+                       })
+                       .aggregation(
+                           {},
+                           {"stddev(inner_sum) AS outer_stddev"},
+                           {},
+                           core::AggregationNode::Step::kSingle,
+                           false)
+                       .planNode();
+
+  auto outerAggregationNode =
+      std::dynamic_pointer_cast<const core::AggregationNode>(outerPlan);
+
+  ASSERT_FALSE(canBeEvaluatedByCudf(*outerAggregationNode, queryCtx_.get()));
+}
+
+// Test nested aggregation: allowed -> allowed
+TEST_F(CudfAggregationSelectionTest, nestedAggregationAllowedToAllowed) {
+  auto innerPlan = PlanBuilder()
+                       .values({makeRowVector({
+                           makeFlatVector<int64_t>({1, 1, 2, 2, 3, 3}),
+                           makeFlatVector<int64_t>({10, 20, 30, 40, 50, 60}),
+                       })})
+                       .aggregation(
+                           {"c0"},
+                           {"sum(c1) AS inner_sum"},
+                           {},
+                           core::AggregationNode::Step::kSingle,
+                           false)
+                       .planNode();
+
+  auto outerPlan = PlanBuilder()
+                       .addNode([&](std::string id, core::PlanNodePtr input) {
+                         return innerPlan;
+                       })
+                       .aggregation(
+                           {},
+                           {"sum(inner_sum) AS outer_sum"},
+                           {},
+                           core::AggregationNode::Step::kSingle,
+                           false)
+                       .planNode();
+
+  auto outerAggregationNode =
+      std::dynamic_pointer_cast<const core::AggregationNode>(outerPlan);
+
+  ASSERT_TRUE(canBeEvaluatedByCudf(*outerAggregationNode, queryCtx_.get()));
+}
+
+// Test nested aggregation: not allowed -> allowed
+TEST_F(CudfAggregationSelectionTest, nestedAggregationNotAllowedToAllowed) {
+  auto innerPlan = PlanBuilder()
+                       .values({makeRowVector({
+                           makeFlatVector<int64_t>({1, 1, 2, 2, 3, 3}),
+                           makeFlatVector<int64_t>({10, 20, 30, 40, 50, 60}),
+                       })})
+                       .aggregation(
+                           {"c0"},
+                           {"stddev(c1) AS inner_stddev"},
+                           {},
+                           core::AggregationNode::Step::kSingle,
+                           false)
+                       .planNode();
+
+  auto outerPlan = PlanBuilder()
+                       .addNode([&](std::string id, core::PlanNodePtr input) {
+                         return innerPlan;
+                       })
+                       .aggregation(
+                           {},
+                           {"sum(inner_stddev) AS outer_sum"},
+                           {},
+                           core::AggregationNode::Step::kSingle,
+                           false)
+                       .planNode();
+
+  auto outerAggregationNode =
+      std::dynamic_pointer_cast<const core::AggregationNode>(outerPlan);
+
+  // Only validates the current (outer) aggregation node
+  ASSERT_TRUE(canBeEvaluatedByCudf(*outerAggregationNode, queryCtx_.get()));
+}
+
+// Test nested aggregation: not allowed -> not allowed
+TEST_F(CudfAggregationSelectionTest, nestedAggregationNotAllowedToNotAllowed) {
+  auto innerPlan = PlanBuilder()
+                       .values({makeRowVector({
+                           makeFlatVector<int64_t>({1, 1, 2, 2, 3, 3}),
+                           makeFlatVector<int64_t>({10, 20, 30, 40, 50, 60}),
+                       })})
+                       .aggregation(
+                           {"c0"},
+                           {"stddev(c1) AS inner_stddev"},
+                           {},
+                           core::AggregationNode::Step::kSingle,
+                           false)
+                       .planNode();
+
+  auto outerPlan = PlanBuilder()
+                       .addNode([&](std::string id, core::PlanNodePtr input) {
+                         return innerPlan;
+                       })
+                       .aggregation(
+                           {},
+                           {"variance(inner_stddev) AS outer_variance"},
+                           {},
+                           core::AggregationNode::Step::kSingle,
+                           false)
+                       .planNode();
+
+  auto outerAggregationNode =
+      std::dynamic_pointer_cast<const core::AggregationNode>(outerPlan);
+
+  ASSERT_FALSE(canBeEvaluatedByCudf(*outerAggregationNode, queryCtx_.get()));
+}
+
+// Test unsupported aggregation function signatures
+TEST_F(CudfAggregationSelectionTest, unsupportedAggregationFunctionSignatures) {
+  auto varianceExpr = std::make_shared<core::CallTypedExpr>(
+      DOUBLE(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(BIGINT(), "c0")},
+      "variance");
+
+  ASSERT_FALSE(canAggregationBeEvaluatedByCudf(*varianceExpr, queryCtx_.get()));
+}
+
+// Test comprehensive type support validation - all registered CUDF aggregation
+// signatures
+TEST_F(CudfAggregationSelectionTest, comprehensiveTypeSupportValidation) {
+  // SUM signatures
+  auto sumTinyintExpr = std::make_shared<core::CallTypedExpr>(
+      BIGINT(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(TINYINT(), "c0")},
+      "sum");
+  auto sumSmallintExpr = std::make_shared<core::CallTypedExpr>(
+      BIGINT(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(SMALLINT(), "c1")},
+      "sum");
+  auto sumIntegerExpr = std::make_shared<core::CallTypedExpr>(
+      BIGINT(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c2")},
+      "sum");
+  auto sumBigintExpr = std::make_shared<core::CallTypedExpr>(
+      BIGINT(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(BIGINT(), "c0")},
+      "sum");
+  auto sumRealExpr = std::make_shared<core::CallTypedExpr>(
+      REAL(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(REAL(), "c4")},
+      "sum");
+  auto sumDoubleExpr = std::make_shared<core::CallTypedExpr>(
+      DOUBLE(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(DOUBLE(), "c3")},
+      "sum");
+
+  // COUNT signatures
+  auto countTinyintExpr = std::make_shared<core::CallTypedExpr>(
+      BIGINT(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(TINYINT(), "c0")},
+      "count");
+  auto countSmallintExpr = std::make_shared<core::CallTypedExpr>(
+      BIGINT(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(SMALLINT(), "c1")},
+      "count");
+  auto countIntegerExpr = std::make_shared<core::CallTypedExpr>(
+      BIGINT(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c2")},
+      "count");
+  auto countBigintExpr = std::make_shared<core::CallTypedExpr>(
+      BIGINT(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(BIGINT(), "c0")},
+      "count");
+  auto countRealExpr = std::make_shared<core::CallTypedExpr>(
+      BIGINT(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(REAL(), "c4")},
+      "count");
+  auto countDoubleExpr = std::make_shared<core::CallTypedExpr>(
+      BIGINT(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(DOUBLE(), "c3")},
+      "count");
+  auto countVarcharExpr = std::make_shared<core::CallTypedExpr>(
+      BIGINT(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c6")},
+      "count");
+  auto countBooleanExpr = std::make_shared<core::CallTypedExpr>(
+      BIGINT(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(BOOLEAN(), "c7")},
+      "count");
+  auto countStarExpr = std::make_shared<core::CallTypedExpr>(
+      BIGINT(), std::vector<core::TypedExprPtr>{}, "count");
+
+  // MIN signatures
+  auto minTinyintExpr = std::make_shared<core::CallTypedExpr>(
+      TINYINT(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(TINYINT(), "c0")},
+      "min");
+  auto minSmallintExpr = std::make_shared<core::CallTypedExpr>(
+      SMALLINT(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(SMALLINT(), "c1")},
+      "min");
+  auto minIntegerExpr = std::make_shared<core::CallTypedExpr>(
+      INTEGER(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c2")},
+      "min");
+  auto minBigintExpr = std::make_shared<core::CallTypedExpr>(
+      BIGINT(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(BIGINT(), "c0")},
+      "min");
+  auto minRealExpr = std::make_shared<core::CallTypedExpr>(
+      REAL(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(REAL(), "c4")},
+      "min");
+  auto minDoubleExpr = std::make_shared<core::CallTypedExpr>(
+      DOUBLE(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(DOUBLE(), "c3")},
+      "min");
+
+  // MAX signatures
+  auto maxTinyintExpr = std::make_shared<core::CallTypedExpr>(
+      TINYINT(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(TINYINT(), "c0")},
+      "max");
+  auto maxSmallintExpr = std::make_shared<core::CallTypedExpr>(
+      SMALLINT(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(SMALLINT(), "c1")},
+      "max");
+  auto maxIntegerExpr = std::make_shared<core::CallTypedExpr>(
+      INTEGER(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c2")},
+      "max");
+  auto maxBigintExpr = std::make_shared<core::CallTypedExpr>(
+      BIGINT(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(BIGINT(), "c0")},
+      "max");
+  auto maxRealExpr = std::make_shared<core::CallTypedExpr>(
+      REAL(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(REAL(), "c4")},
+      "max");
+  auto maxDoubleExpr = std::make_shared<core::CallTypedExpr>(
+      DOUBLE(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(DOUBLE(), "c3")},
+      "max");
+
+  // MIN/MAX VARCHAR signatures
+  auto minVarcharExpr = std::make_shared<core::CallTypedExpr>(
+      VARCHAR(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c6")},
+      "min");
+  auto maxVarcharExpr = std::make_shared<core::CallTypedExpr>(
+      VARCHAR(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c6")},
+      "max");
+
+  // AVG signatures
+  auto avgSmallintExpr = std::make_shared<core::CallTypedExpr>(
+      DOUBLE(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(SMALLINT(), "c1")},
+      "avg");
+  auto avgIntegerExpr = std::make_shared<core::CallTypedExpr>(
+      DOUBLE(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c2")},
+      "avg");
+  auto avgBigintExpr = std::make_shared<core::CallTypedExpr>(
+      DOUBLE(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(BIGINT(), "c0")},
+      "avg");
+  auto avgDoubleExpr = std::make_shared<core::CallTypedExpr>(
+      DOUBLE(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(DOUBLE(), "c3")},
+      "avg");
+
+  ASSERT_TRUE(
+      canAggregationBeEvaluatedByCudf(*sumTinyintExpr, queryCtx_.get()));
+  ASSERT_TRUE(
+      canAggregationBeEvaluatedByCudf(*sumSmallintExpr, queryCtx_.get()));
+  ASSERT_TRUE(
+      canAggregationBeEvaluatedByCudf(*sumIntegerExpr, queryCtx_.get()));
+  ASSERT_TRUE(canAggregationBeEvaluatedByCudf(*sumBigintExpr, queryCtx_.get()));
+  ASSERT_TRUE(canAggregationBeEvaluatedByCudf(*sumRealExpr, queryCtx_.get()));
+  ASSERT_TRUE(canAggregationBeEvaluatedByCudf(*sumDoubleExpr, queryCtx_.get()));
+
+  ASSERT_TRUE(
+      canAggregationBeEvaluatedByCudf(*countTinyintExpr, queryCtx_.get()));
+  ASSERT_TRUE(
+      canAggregationBeEvaluatedByCudf(*countSmallintExpr, queryCtx_.get()));
+  ASSERT_TRUE(
+      canAggregationBeEvaluatedByCudf(*countIntegerExpr, queryCtx_.get()));
+  ASSERT_TRUE(
+      canAggregationBeEvaluatedByCudf(*countBigintExpr, queryCtx_.get()));
+  ASSERT_TRUE(canAggregationBeEvaluatedByCudf(*countRealExpr, queryCtx_.get()));
+  ASSERT_TRUE(
+      canAggregationBeEvaluatedByCudf(*countDoubleExpr, queryCtx_.get()));
+  ASSERT_TRUE(
+      canAggregationBeEvaluatedByCudf(*countVarcharExpr, queryCtx_.get()));
+  ASSERT_TRUE(
+      canAggregationBeEvaluatedByCudf(*countBooleanExpr, queryCtx_.get()));
+  ASSERT_TRUE(canAggregationBeEvaluatedByCudf(*countStarExpr, queryCtx_.get()));
+
+  ASSERT_TRUE(
+      canAggregationBeEvaluatedByCudf(*minTinyintExpr, queryCtx_.get()));
+  ASSERT_TRUE(
+      canAggregationBeEvaluatedByCudf(*minSmallintExpr, queryCtx_.get()));
+  ASSERT_TRUE(
+      canAggregationBeEvaluatedByCudf(*minIntegerExpr, queryCtx_.get()));
+  ASSERT_TRUE(canAggregationBeEvaluatedByCudf(*minBigintExpr, queryCtx_.get()));
+  ASSERT_TRUE(canAggregationBeEvaluatedByCudf(*minRealExpr, queryCtx_.get()));
+  ASSERT_TRUE(canAggregationBeEvaluatedByCudf(*minDoubleExpr, queryCtx_.get()));
+
+  ASSERT_TRUE(
+      canAggregationBeEvaluatedByCudf(*maxTinyintExpr, queryCtx_.get()));
+  ASSERT_TRUE(
+      canAggregationBeEvaluatedByCudf(*maxSmallintExpr, queryCtx_.get()));
+  ASSERT_TRUE(
+      canAggregationBeEvaluatedByCudf(*maxIntegerExpr, queryCtx_.get()));
+  ASSERT_TRUE(canAggregationBeEvaluatedByCudf(*maxBigintExpr, queryCtx_.get()));
+  ASSERT_TRUE(canAggregationBeEvaluatedByCudf(*maxRealExpr, queryCtx_.get()));
+  ASSERT_TRUE(canAggregationBeEvaluatedByCudf(*maxDoubleExpr, queryCtx_.get()));
+
+  ASSERT_TRUE(
+      canAggregationBeEvaluatedByCudf(*minVarcharExpr, queryCtx_.get()));
+  ASSERT_TRUE(
+      canAggregationBeEvaluatedByCudf(*maxVarcharExpr, queryCtx_.get()));
+
+  ASSERT_TRUE(
+      canAggregationBeEvaluatedByCudf(*avgSmallintExpr, queryCtx_.get()));
+  ASSERT_TRUE(
+      canAggregationBeEvaluatedByCudf(*avgIntegerExpr, queryCtx_.get()));
+  ASSERT_TRUE(canAggregationBeEvaluatedByCudf(*avgBigintExpr, queryCtx_.get()));
+  ASSERT_TRUE(canAggregationBeEvaluatedByCudf(*avgDoubleExpr, queryCtx_.get()));
+}
+
+// Test invalid aggregation signatures
+TEST_F(CudfAggregationSelectionTest, invalidTypeCombinationsRejected) {
+  // avg on varchar
+  auto avgVarcharExpr = std::make_shared<core::CallTypedExpr>(
+      DOUBLE(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c6")},
+      "avg");
+
+  // sum on varchar
+  auto sumVarcharExpr = std::make_shared<core::CallTypedExpr>(
+      VARCHAR(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c6")},
+      "sum");
+
+  // max on boolean
+  auto maxBooleanExpr = std::make_shared<core::CallTypedExpr>(
+      BOOLEAN(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(BOOLEAN(), "c7")},
+      "max");
+
+  ASSERT_FALSE(
+      canAggregationBeEvaluatedByCudf(*avgVarcharExpr, queryCtx_.get()));
+  ASSERT_FALSE(
+      canAggregationBeEvaluatedByCudf(*sumVarcharExpr, queryCtx_.get()));
+  ASSERT_FALSE(
+      canAggregationBeEvaluatedByCudf(*maxBooleanExpr, queryCtx_.get()));
+}
+
+// Test `distinct` aggregations should be rejected early (otherwise the throw
+// NYI)
+TEST_F(CudfAggregationSelectionTest, distinctAggregationsRejected) {
+  auto plan = PlanBuilder()
+                  .values({makeRowVector({
+                      makeFlatVector<int64_t>({1, 1, 2, 2, 3, 3}),
+                      makeFlatVector<int64_t>({10, 20, 30, 40, 50, 60}),
+                  })})
+                  .aggregation(
+                      {"c0"},
+                      {"count(distinct c1)"},
+                      {},
+                      core::AggregationNode::Step::kSingle,
+                      false)
+                  .planNode();
+
+  auto aggregationNode =
+      std::dynamic_pointer_cast<const core::AggregationNode>(plan);
+
+  ASSERT_FALSE(canBeEvaluatedByCudf(*aggregationNode, queryCtx_.get()));
+}
+
+// Test `mask` clauses should be rejected
+TEST_F(CudfAggregationSelectionTest, filterMaskClausesRejected) {
+  auto plan = PlanBuilder()
+                  .values({makeRowVector({
+                      makeFlatVector<int64_t>({1, 2, 3}),
+                      makeFlatVector<int64_t>({10, 20, 30}),
+                      makeFlatVector<bool>({true, false, true}),
+                  })})
+                  .aggregation(
+                      {"c0"},
+                      {"sum(c1)"},
+                      {},
+                      core::AggregationNode::Step::kSingle,
+                      false)
+                  .planNode();
+
+  auto aggregationNode =
+      std::dynamic_pointer_cast<const core::AggregationNode>(plan);
+
+  ASSERT_TRUE(canBeEvaluatedByCudf(*aggregationNode, queryCtx_.get()));
+
+  // Manually create a modified aggregation with a mask
+  auto modifiedAggregates = aggregationNode->aggregates();
+  ASSERT_FALSE(modifiedAggregates.empty());
+
+  modifiedAggregates[0].mask =
+      std::make_shared<core::FieldAccessTypedExpr>(BOOLEAN(), "c2");
+
+  auto modifiedNode = core::AggregationNode::Builder(*aggregationNode)
+                          .aggregates(std::move(modifiedAggregates))
+                          .build();
+
+  ASSERT_FALSE(canBeEvaluatedByCudf(*modifiedNode, queryCtx_.get()));
+}
+
+// Test return type validation
+// DISABLED: This test demonstrates expected failure modes when return type
+// matching is enabled.
+TEST_F(
+    CudfAggregationSelectionTest,
+    DISABLED_returnTypeMismatchShouldBeRejected) {
+  // These should be rejected because the return type doesn't match the
+  // registered signature
+
+  // sum(integer) should return BIGINT, not VARCHAR
+  auto sumWrongReturnExpr = std::make_shared<core::CallTypedExpr>(
+      VARCHAR(), // Wrong return type - should be BIGINT
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c2")},
+      "sum");
+
+  // avg(integer) should return DOUBLE, not INTEGER
+  auto avgWrongReturnExpr = std::make_shared<core::CallTypedExpr>(
+      INTEGER(), // Wrong return type - should be DOUBLE
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c2")},
+      "avg");
+
+  // count(integer) should return BIGINT, not INTEGER
+  auto countWrongReturnExpr = std::make_shared<core::CallTypedExpr>(
+      INTEGER(), // Wrong return type - should be BIGINT
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c2")},
+      "count");
+
+  // min(integer) should return INTEGER, not VARCHAR
+  auto minWrongReturnExpr = std::make_shared<core::CallTypedExpr>(
+      VARCHAR(), // Wrong return type - should be INTEGER (min preserves input
+                 // type)
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c2")},
+      "min");
+
+  // Without return type validation, these would incorrectly pass
+  ASSERT_FALSE(
+      canAggregationBeEvaluatedByCudf(*sumWrongReturnExpr, queryCtx_.get()));
+  ASSERT_FALSE(
+      canAggregationBeEvaluatedByCudf(*avgWrongReturnExpr, queryCtx_.get()));
+  ASSERT_FALSE(
+      canAggregationBeEvaluatedByCudf(*countWrongReturnExpr, queryCtx_.get()));
+  ASSERT_FALSE(
+      canAggregationBeEvaluatedByCudf(*minWrongReturnExpr, queryCtx_.get()));
+}
+
+} // namespace
diff --git a/velox/experimental/cudf/tests/AggregationTest.cpp b/velox/experimental/cudf/tests/AggregationTest.cpp
index 4f5c621d938..06cd3a0efaf 100644
--- a/velox/experimental/cudf/tests/AggregationTest.cpp
+++ b/velox/experimental/cudf/tests/AggregationTest.cpp
@@ -14,6 +14,9 @@
  * limitations under the License.
  */
 
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/exec/AggregationRegistry.h"
+#include "velox/experimental/cudf/exec/PrestoAggregateFunctions.h"
 #include "velox/experimental/cudf/exec/ToCudf.h"
 
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
@@ -22,6 +25,8 @@
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 
+#include <cmath>
+
 namespace facebook::velox::exec::test {
 
 using core::QueryConfig;
@@ -29,6 +34,9 @@ using facebook::velox::test::BatchMaker;
 using namespace common::testutil;
 
 class AggregationTest : public OperatorTestBase {
+ public:
+  enum class AggSteps { kSingle, kPartialFinal, kPartialIntermediateFinal };
+
  protected:
   static void SetUpTestCase() {
     OperatorTestBase::SetUpTestCase();
@@ -38,11 +46,14 @@ class AggregationTest : public OperatorTestBase {
   void SetUp() override {
     OperatorTestBase::SetUp();
     filesystems::registerLocalFileSystem();
+    cudf_velox::CudfConfig::getInstance().allowCpuFallback = false;
     cudf_velox::registerCudf();
+    cudf_velox::registerPrestoAggregateFunctions("");
   }
 
   void TearDown() override {
     cudf_velox::unregisterCudf();
+    cudf_velox::unregisterAggregateFunctions();
     OperatorTestBase::TearDown();
   }
 
@@ -155,6 +166,52 @@ class AggregationTest : public OperatorTestBase {
     }
   }
 
+  void testAggregation(
+      const std::vector<RowVectorPtr>& data,
+      const std::vector<std::string>& groupingKeys,
+      const std::vector<std::string>& aggregates,
+      const std::string& expectedSql,
+      AggSteps steps) {
+    auto builder = PlanBuilder().values(data);
+    switch (steps) {
+      case AggSteps::kSingle:
+        builder.singleAggregation(groupingKeys, aggregates);
+        break;
+      case AggSteps::kPartialFinal:
+        builder.partialAggregation(groupingKeys, aggregates).finalAggregation();
+        break;
+      case AggSteps::kPartialIntermediateFinal:
+        builder.partialAggregation(groupingKeys, aggregates)
+            .intermediateAggregation()
+            .finalAggregation();
+        break;
+    }
+    assertQuery(builder.planNode(), expectedSql);
+  }
+
+  void testGlobalCountStarZeroColumns(AggSteps steps) {
+    auto data = makeRowVector({
+        makeFlatVector<int64_t>({1, 2, 3, 4}),
+    });
+    createDuckDbTable({data});
+
+    auto builder = PlanBuilder().values({data}).filter("c0 > 0").project({});
+    switch (steps) {
+      case AggSteps::kSingle:
+        builder.singleAggregation({}, {"count(*)"});
+        break;
+      case AggSteps::kPartialFinal:
+        builder.partialAggregation({}, {"count(*)"}).finalAggregation();
+        break;
+      case AggSteps::kPartialIntermediateFinal:
+        builder.partialAggregation({}, {"count(*)"})
+            .intermediateAggregation()
+            .finalAggregation();
+        break;
+    }
+    assertQuery(builder.planNode(), "SELECT count(*) FROM tmp WHERE c0 > 0");
+  }
+
   RowTypePtr rowType_{
       ROW({"c0", "c1", "c2", "c3", "c4", "c5", "c6"},
           {BIGINT(),
@@ -282,6 +339,37 @@ TEST_F(AggregationTest, aggregateOfNulls) {
   assertQuery(op, "SELECT sum(c1), min(c1), max(c1) FROM tmp");
 }
 
+TEST_F(AggregationTest, varcharMinMax) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+
+  // Groupby with varchar min/max.
+  auto op = PlanBuilder()
+                .values(vectors)
+                .aggregation(
+                    {"c0"},
+                    {"min(c6)", "max(c6)"},
+                    {},
+                    core::AggregationNode::Step::kPartial,
+                    false)
+                .planNode();
+
+  assertQuery(op, "SELECT c0, min(c6), max(c6) FROM tmp GROUP BY c0");
+
+  // Global aggregation with varchar min/max.
+  op = PlanBuilder()
+           .values(vectors)
+           .aggregation(
+               {},
+               {"min(c6)", "max(c6)"},
+               {},
+               core::AggregationNode::Step::kPartial,
+               false)
+           .planNode();
+
+  assertQuery(op, "SELECT min(c6), max(c6) FROM tmp");
+}
+
 TEST_F(AggregationTest, allKeyTypes) {
   // Covers different key types. Unlike the integer/string tests, the
   // hash table begins life in the generic mode, not array or
@@ -292,8 +380,9 @@ TEST_F(AggregationTest, allKeyTypes) {
 
   std::vector<RowVectorPtr> batches;
   for (auto i = 0; i < 10; ++i) {
-    batches.push_back(std::static_pointer_cast<RowVector>(
-        BatchMaker::createBatch(rowType, 100, *pool_)));
+    batches.push_back(
+        std::static_pointer_cast<RowVector>(
+            BatchMaker::createBatch(rowType, 100, *pool_)));
   }
   createDuckDbTable(batches);
   auto op =
@@ -421,64 +510,301 @@ TEST_F(AggregationTest, avgPartialFinalGlobal) {
   assertQuery(op, "SELECT avg(c1), avg(c2), avg(c4), avg(c5) FROM tmp");
 }
 
-TEST_F(AggregationTest, countSingleGroupBy) {
+TEST_F(AggregationTest, countStarGlobal) {
   auto vectors = makeVectors(rowType_, 10, 100);
+
   createDuckDbTable(vectors);
 
-  std::string keyName = "c0";
-  std::vector<std::string> aggregates = {"count(0)"};
   auto op = PlanBuilder()
                 .values(vectors)
-                .singleAggregation({keyName}, aggregates)
+                .filter("c0 > 10")
+                .project({})
+                .partialAggregation({}, {"count(*)"})
+                .finalAggregation()
                 .planNode();
 
-  assertQuery(
-      op, "SELECT " + keyName + ", count(*) FROM tmp GROUP BY " + keyName);
+  assertQuery(op, "SELECT count(*) FROM tmp WHERE c0 > 10");
 }
 
-TEST_F(AggregationTest, countPartialFinalGroupBy) {
-  auto vectors = makeVectors(rowType_, 10, 100);
-  createDuckDbTable(vectors);
+TEST_F(AggregationTest, countStarGlobalNonZeroRowsColumns) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4}),
+  });
+  createDuckDbTable({data});
 
-  std::string keyName = "c0";
-  std::vector<std::string> aggregates = {"count(0)"};
   auto op = PlanBuilder()
-                .values(vectors)
-                .partialAggregation({keyName}, aggregates)
+                .values({data})
+                .partialAggregation({}, {"count(*)"})
                 .finalAggregation()
                 .planNode();
 
-  assertQuery(
-      op, "SELECT " + keyName + ", count(*) FROM tmp GROUP BY " + keyName);
+  assertQuery(op, "SELECT count(*) FROM tmp");
 }
 
-TEST_F(AggregationTest, countSingleGlobal) {
-  auto vectors = makeVectors(rowType_, 10, 100);
-  createDuckDbTable(vectors);
+TEST_F(AggregationTest, countStarGlobalZeroRows) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4}),
+  });
+  createDuckDbTable({data});
 
-  std::vector<std::string> aggregates = {"count(0)"};
   auto op = PlanBuilder()
-                .values(vectors)
-                .singleAggregation({}, aggregates)
+                .values({data})
+                .filter("c0 > 10")
+                .partialAggregation({}, {"count(*)"})
+                .finalAggregation()
                 .planNode();
 
-  assertQuery(op, "SELECT count(*) FROM tmp");
+  assertQuery(op, "SELECT count(*) FROM tmp WHERE c0 > 10");
 }
 
-TEST_F(AggregationTest, countPartialFinalGlobal) {
+TEST_F(AggregationTest, countStarGlobalPartialFinalZeroColumnsLocalPartition) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4}),
+  });
+  createDuckDbTable({data});
+
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .filter("c0 > 0")
+                  .project({})
+                  .partialAggregation({}, {"count(*)"})
+                  .localPartitionRoundRobin()
+                  .finalAggregation()
+                  .planNode();
+
+  AssertQueryBuilder(duckDbQueryRunner_)
+      .config(core::QueryConfig::kMaxLocalExchangePartitionCount, "2")
+      .plan(plan)
+      .assertResults("SELECT count(*) FROM tmp WHERE c0 > 0");
+}
+
+TEST_F(AggregationTest, countConstantSingleGroupByNonZeroKey) {
   auto vectors = makeVectors(rowType_, 10, 100);
   createDuckDbTable(vectors);
+  testAggregation(
+      vectors,
+      {"c2"},
+      {"count(1)"},
+      "SELECT c2, count(1) FROM tmp GROUP BY c2",
+      AggSteps::kSingle);
+}
 
-  std::vector<std::string> aggregates = {"count(0)"};
-  auto op = PlanBuilder()
-                .values(vectors)
-                .partialAggregation({}, aggregates)
-                .finalAggregation()
-                .planNode();
+TEST_F(AggregationTest, countConstantPartialFinalGroupByNonZeroKey) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+  testAggregation(
+      vectors,
+      {"c2"},
+      {"count(1)"},
+      "SELECT c2, count(1) FROM tmp GROUP BY c2",
+      AggSteps::kPartialFinal);
+}
 
-  assertQuery(op, "SELECT count(*) FROM tmp");
+// Parameterized fixture that runs each count-aggregation scenario across
+// single, partial+final, and partial+intermediate+final steps.
+class CountAggregationStepsTest
+    : public AggregationTest,
+      public testing::WithParamInterface<AggregationTest::AggSteps> {};
+
+TEST_P(CountAggregationStepsTest, countStarGlobalZeroColumns) {
+  testGlobalCountStarZeroColumns(GetParam());
+}
+
+TEST_P(CountAggregationStepsTest, countStarVsCountColumnGlobalNulls) {
+  auto data = makeRowVector({
+      makeNullableFlatVector<int64_t>({1, std::nullopt, 2, std::nullopt}),
+  });
+  createDuckDbTable({data});
+  testAggregation(
+      {data},
+      {},
+      {"count(*)", "count(c0)"},
+      "SELECT count(*), count(c0) FROM tmp",
+      GetParam());
+}
+
+TEST_P(CountAggregationStepsTest, countGroupBy) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+  testAggregation(
+      vectors,
+      {"c0"},
+      {"count(0)"},
+      "SELECT c0, count(*) FROM tmp GROUP BY c0",
+      GetParam());
+}
+
+TEST_P(CountAggregationStepsTest, countConstantGroupBy) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+  testAggregation(
+      vectors,
+      {"c0"},
+      {"count(1)"},
+      "SELECT c0, count(1) FROM tmp GROUP BY c0",
+      GetParam());
+}
+
+TEST_P(CountAggregationStepsTest, countGlobal) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+  testAggregation(
+      vectors, {}, {"count(0)"}, "SELECT count(*) FROM tmp", GetParam());
+}
+
+TEST_P(CountAggregationStepsTest, countStarGlobal) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+  testAggregation(
+      vectors, {}, {"count(*)"}, "SELECT count(*) FROM tmp", GetParam());
+}
+
+TEST_P(CountAggregationStepsTest, countStarGroupBy) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+  testAggregation(
+      vectors,
+      {"c0"},
+      {"count(*)"},
+      "SELECT c0, count(*) FROM tmp GROUP BY c0",
+      GetParam());
+}
+
+TEST_P(CountAggregationStepsTest, countColumnGlobal) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+  testAggregation(
+      vectors, {}, {"count(c0)"}, "SELECT count(c0) FROM tmp", GetParam());
+}
+
+TEST_P(CountAggregationStepsTest, countColumnGlobalNulls) {
+  auto data = makeRowVector({
+      makeNullableFlatVector<int64_t>({1, std::nullopt, 2, std::nullopt}),
+  });
+  createDuckDbTable({data});
+  testAggregation(
+      {data}, {}, {"count(c0)"}, "SELECT count(c0) FROM tmp", GetParam());
+}
+
+TEST_P(CountAggregationStepsTest, countColumnGroupBy) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+  testAggregation(
+      vectors,
+      {"c0"},
+      {"count(c3)"},
+      "SELECT c0, count(c3) FROM tmp GROUP BY c0",
+      GetParam());
+}
+
+TEST_P(CountAggregationStepsTest, countColumnGroupByNulls) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 1, 2, 2, 3, 3}),
+      makeNullableFlatVector<int64_t>(
+          {10, std::nullopt, 20, std::nullopt, std::nullopt, std::nullopt}),
+  });
+  createDuckDbTable({data});
+  testAggregation(
+      {data},
+      {"c0"},
+      {"count(c1)"},
+      "SELECT c0, count(c1) FROM tmp GROUP BY c0",
+      GetParam());
+}
+
+TEST_P(CountAggregationStepsTest, countStarVsCountColumnGroupByNulls) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 1, 2, 2, 3, 3}),
+      makeNullableFlatVector<int64_t>(
+          {10, std::nullopt, 20, std::nullopt, std::nullopt, std::nullopt}),
+  });
+  createDuckDbTable({data});
+  testAggregation(
+      {data},
+      {"c0"},
+      {"count(*)", "count(c1)"},
+      "SELECT c0, count(*), count(c1) FROM tmp GROUP BY c0",
+      GetParam());
+}
+
+TEST_P(CountAggregationStepsTest, countNullConstantMarkerForIntersectShape) {
+  auto data = makeRowVector({
+      makeFlatVector<StringView>({"left_only", "left_only", "both"}),
+  });
+
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .project({
+                      "true AS left_marker",
+                      "cast(null AS boolean) AS right_marker",
+                      "c0 AS key",
+                  })
+                  .partialAggregation(
+                      {"key"}, {"count(left_marker)", "count(right_marker)"})
+                  .finalAggregation()
+                  .filter("a0 >= 1 AND a1 = 0")
+                  .project({"key", "a0"})
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeFlatVector<StringView>({"left_only", "both"}),
+      makeFlatVector<int64_t>({2, 1}),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_P(CountAggregationStepsTest, countConstantGlobalNulls) {
+  auto data = makeRowVector({
+      makeNullableFlatVector<int64_t>({1, std::nullopt, 2, std::nullopt}),
+  });
+  createDuckDbTable({data});
+  testAggregation(
+      {data}, {}, {"count(1)"}, "SELECT count(1) FROM tmp", GetParam());
 }
 
+TEST_P(CountAggregationStepsTest, countNullGlobal) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4}),
+  });
+  createDuckDbTable({data});
+  testAggregation(
+      {data}, {}, {"count(null)"}, "SELECT count(null) FROM tmp", GetParam());
+}
+
+TEST_P(CountAggregationStepsTest, countNullGroupBy) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 1, 2, 2, 3, 3}),
+      makeFlatVector<int64_t>({10, 20, 30, 40, 50, 60}),
+  });
+  createDuckDbTable({data});
+  testAggregation(
+      {data},
+      {"c0"},
+      {"count(null)"},
+      "SELECT c0, count(null) FROM tmp GROUP BY c0",
+      GetParam());
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    CountAggregation,
+    CountAggregationStepsTest,
+    testing::Values(
+        AggregationTest::AggSteps::kSingle,
+        AggregationTest::AggSteps::kPartialFinal,
+        AggregationTest::AggSteps::kPartialIntermediateFinal),
+    [](const testing::TestParamInfo<AggregationTest::AggSteps>& info)
+        -> std::string {
+      switch (info.param) {
+        case AggregationTest::AggSteps::kSingle:
+          return "Single";
+        case AggregationTest::AggSteps::kPartialFinal:
+          return "PartialFinal";
+        case AggregationTest::AggSteps::kPartialIntermediateFinal:
+          return "PartialIntermediateFinal";
+      }
+      return "Unknown";
+    });
+
 /// Tests the spark scenario of having different types of aggs in the same
 /// planNode Specific example being tested is
 /// https://github.com/facebookincubator/velox/issues/12830#issuecomment-2783340233
@@ -525,12 +851,13 @@ TEST_F(AggregationTest, partialAggregationMemoryLimit) {
   core::PlanNodeId aggNodeId;
   auto task = AssertQueryBuilder(duckDbQueryRunner_)
                   .config(QueryConfig::kMaxPartialAggregationMemory, 100)
-                  .plan(PlanBuilder()
-                            .values(vectors)
-                            .partialAggregation({"c0"}, {})
-                            .capturePlanNodeId(aggNodeId)
-                            .finalAggregation()
-                            .planNode())
+                  .plan(
+                      PlanBuilder()
+                          .values(vectors)
+                          .partialAggregation({"c0"}, {})
+                          .capturePlanNodeId(aggNodeId)
+                          .finalAggregation()
+                          .planNode())
                   .assertResults("SELECT distinct c0 FROM tmp");
 
   auto rowFlushStats = toPlanStats(task->taskStats())
@@ -542,12 +869,13 @@ TEST_F(AggregationTest, partialAggregationMemoryLimit) {
   // Count aggregation.
   task = AssertQueryBuilder(duckDbQueryRunner_)
              .config(QueryConfig::kMaxPartialAggregationMemory, 1)
-             .plan(PlanBuilder()
-                       .values(vectors)
-                       .partialAggregation({"c0"}, {"count(1)"})
-                       .capturePlanNodeId(aggNodeId)
-                       .finalAggregation()
-                       .planNode())
+             .plan(
+                 PlanBuilder()
+                     .values(vectors)
+                     .partialAggregation({"c0"}, {"count(1)"})
+                     .capturePlanNodeId(aggNodeId)
+                     .finalAggregation()
+                     .planNode())
              .assertResults("SELECT c0, count(1) FROM tmp GROUP BY 1");
 
   rowFlushStats = toPlanStats(task->taskStats())
@@ -559,12 +887,13 @@ TEST_F(AggregationTest, partialAggregationMemoryLimit) {
   // Global aggregation.
   task = AssertQueryBuilder(duckDbQueryRunner_)
              .config(QueryConfig::kMaxPartialAggregationMemory, 1)
-             .plan(PlanBuilder()
-                       .values(vectors)
-                       .partialAggregation({}, {"sum(c0)"})
-                       .capturePlanNodeId(aggNodeId)
-                       .finalAggregation()
-                       .planNode())
+             .plan(
+                 PlanBuilder()
+                     .values(vectors)
+                     .partialAggregation({}, {"sum(c0)"})
+                     .capturePlanNodeId(aggNodeId)
+                     .finalAggregation()
+                     .planNode())
              .assertResults("SELECT sum(c0) FROM tmp");
   EXPECT_EQ(
       0,
@@ -573,6 +902,88 @@ TEST_F(AggregationTest, partialAggregationMemoryLimit) {
           .customStats.count("flushRowCount"));
 }
 
+TEST_F(AggregationTest, finalAggregationStreamsOnAddInput) {
+  auto vectors = {
+      makeRowVector({makeFlatVector<int32_t>(
+          100, [](auto row) { return row; }, nullEvery(5))}),
+      makeRowVector({makeFlatVector<int32_t>(
+          110, [](auto row) { return row + 29; }, nullEvery(7))}),
+      makeRowVector({makeFlatVector<int32_t>(
+          90, [](auto row) { return row - 71; }, nullEvery(7))}),
+  };
+
+  createDuckDbTable(vectors);
+
+  // Force the final aggregation to see multiple addInput() calls by setting an
+  // artificially low limit on the amount of data to accumulate in the partial
+  // aggregation.
+  core::PlanNodeId partialAggId;
+  core::PlanNodeId finalAggId;
+  auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                  .config(QueryConfig::kMaxPartialAggregationMemory, 1)
+                  .plan(
+                      PlanBuilder()
+                          .values(vectors)
+                          .partialAggregation({"c0"}, {"sum(c0)"})
+                          .capturePlanNodeId(partialAggId)
+                          .finalAggregation()
+                          .capturePlanNodeId(finalAggId)
+                          .planNode())
+                  .assertResults("SELECT c0, sum(c0) FROM tmp GROUP BY 1");
+
+  const auto planStats = toPlanStats(task->taskStats());
+  EXPECT_GT(planStats.at(partialAggId).customStats.at("flushRowCount").sum, 0);
+  EXPECT_GT(planStats.at(finalAggId).outputRows, 0);
+}
+
+TEST_F(AggregationTest, finalAggregationStreamingMixedAggs) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+
+  core::PlanNodeId finalAggId;
+  auto task =
+      AssertQueryBuilder(duckDbQueryRunner_)
+          .config(QueryConfig::kMaxPartialAggregationMemory, 1)
+          .plan(
+              PlanBuilder()
+                  .values(vectors)
+                  .partialAggregation(
+                      {"c0"},
+                      {"sum(c2)", "count(0)", "min(c3)", "max(c5)", "avg(c4)"})
+                  .finalAggregation()
+                  .capturePlanNodeId(finalAggId)
+                  .planNode())
+          .assertResults(
+              "SELECT c0, sum(c2), count(*), min(c3), max(c5), avg(c4) FROM tmp GROUP BY c0");
+
+  const auto planStats = toPlanStats(task->taskStats());
+  EXPECT_GT(planStats.at(finalAggId).outputRows, 0);
+}
+
+TEST_F(AggregationTest, finalAggregationStreamingMultiKey) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+
+  core::PlanNodeId finalAggId;
+  auto task =
+      AssertQueryBuilder(duckDbQueryRunner_)
+          .config(QueryConfig::kMaxPartialAggregationMemory, 1)
+          .plan(
+              PlanBuilder()
+                  .values(vectors)
+                  .partialAggregation(
+                      {"c0", "c1", "c6"},
+                      {"sum(c4)", "count(0)", "avg(c5)", "max(c3)"})
+                  .finalAggregation()
+                  .capturePlanNodeId(finalAggId)
+                  .planNode())
+          .assertResults(
+              "SELECT c0, c1, c6, sum(c4), count(*), avg(c5), max(c3) FROM tmp GROUP BY c0, c1, c6");
+
+  const auto planStats = toPlanStats(task->taskStats());
+  EXPECT_GT(planStats.at(finalAggId).outputRows, 0);
+}
+
 class EmptyInputAggregationTest : public AggregationTest {
  protected:
   void SetUp() override {
@@ -695,4 +1106,512 @@ TEST_F(EmptyInputAggregationTest, globalPartialFinalAggregation) {
       "SELECT sum(c0), count(c1), max(c1), avg(c1) FROM tmp WHERE c0 > 10");
 }
 
+TEST_F(AggregationTest, singleAggregationStreamingSumMinMax) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+
+  std::string keyName = "c0";
+  std::vector<std::string> aggregates = {
+      "sum(c1)",
+      "sum(c2)",
+      "sum(c4)",
+      "sum(c5)",
+      "min(c1)",
+      "min(c2)",
+      "min(c3)",
+      "min(c4)",
+      "min(c5)",
+      "max(c1)",
+      "max(c2)",
+      "max(c3)",
+      "max(c4)",
+      "max(c5)"};
+
+  auto op = PlanBuilder()
+                .values(vectors)
+                .singleAggregation({keyName}, aggregates)
+                .planNode();
+
+  assertQuery(
+      op,
+      "SELECT " + keyName +
+          ", sum(c1), sum(c2), sum(c4), sum(c5)"
+          ", min(c1), min(c2), min(c3), min(c4), min(c5)"
+          ", max(c1), max(c2), max(c3), max(c4), max(c5)"
+          " FROM tmp GROUP BY " +
+          keyName);
+}
+
+TEST_F(AggregationTest, singleAggregationStreamingAvg) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+
+  std::string keyName = "c0";
+  std::vector<std::string> aggregates = {
+      "avg(c1)", "avg(c2)", "avg(c4)", "avg(c5)"};
+
+  auto op = PlanBuilder()
+                .values(vectors)
+                .singleAggregation({keyName}, aggregates)
+                .planNode();
+
+  assertQuery(
+      op,
+      "SELECT " + keyName + ", avg(c1), avg(c2), avg(c4), avg(c5) " +
+          "FROM tmp GROUP BY " + keyName);
+}
+
+TEST_F(AggregationTest, singleAggregationStreamingCount) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+
+  std::string keyName = "c0";
+  auto op = PlanBuilder()
+                .values(vectors)
+                .singleAggregation({keyName}, {"count(0)"})
+                .planNode();
+
+  assertQuery(
+      op, "SELECT " + keyName + ", count(*) FROM tmp GROUP BY " + keyName);
+}
+
+TEST_F(AggregationTest, singleAggregationStreamingMultiKey) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+
+  std::vector<std::string> aggregates = {
+      "sum(c4)",
+      "sum(c5)",
+      "min(c3)",
+      "min(c4)",
+      "min(c5)",
+      "max(c3)",
+      "max(c4)",
+      "max(c5)"};
+
+  auto op = PlanBuilder()
+                .values(vectors)
+                .singleAggregation({"c0", "c1", "c6"}, aggregates)
+                .planNode();
+
+  assertQuery(
+      op,
+      "SELECT c0, c1, c6, sum(c4), sum(c5), min(c3), min(c4), min(c5),"
+      " max(c3), max(c4), max(c5) FROM tmp GROUP BY c0, c1, c6");
+}
+
+TEST_F(AggregationTest, singleAggregationStreamingMixedAggs) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+
+  std::string keyName = "c0";
+  std::vector<std::string> aggregates = {
+      "sum(c2)", "count(0)", "min(c3)", "max(c5)", "avg(c4)"};
+
+  auto op = PlanBuilder()
+                .values(vectors)
+                .singleAggregation({keyName}, aggregates)
+                .planNode();
+
+  assertQuery(
+      op,
+      "SELECT " + keyName +
+          ", sum(c2), count(*), min(c3), max(c5), avg(c4)"
+          " FROM tmp GROUP BY " +
+          keyName);
+}
+
+TEST_F(AggregationTest, singleAggregationStreamingWithNulls) {
+  auto data = makeRowVector({
+      makeNullableFlatVector<int32_t>(
+          {std::nullopt, 1, std::nullopt, 2, std::nullopt, 1, 2}),
+      makeFlatVector<int32_t>({-1, 1, -2, 2, -3, 3, 4}),
+  });
+
+  createDuckDbTable({data});
+
+  auto op = PlanBuilder()
+                .values({data})
+                .singleAggregation({"c0"}, {"sum(c1)", "min(c1)", "max(c1)"})
+                .planNode();
+
+  assertQuery(op, "SELECT c0, sum(c1), min(c1), max(c1) FROM tmp GROUP BY c0");
+}
+
+TEST_F(AggregationTest, singleAggregationStreamingIgnoreNullKeys) {
+  auto data = makeRowVector({
+      makeNullableFlatVector<int32_t>(
+          {std::nullopt, 1, std::nullopt, 2, std::nullopt, 1, 2}),
+      makeFlatVector<int32_t>({-1, 1, -2, 2, -3, 3, 4}),
+  });
+
+  auto op = PlanBuilder()
+                .values({data})
+                .aggregation(
+                    {"c0"},
+                    {"sum(c1)"},
+                    {},
+                    core::AggregationNode::Step::kSingle,
+                    true)
+                .planNode();
+
+  auto expected = makeRowVector({
+      makeFlatVector<int32_t>({1, 2}),
+      makeFlatVector<int64_t>({4, 6}),
+  });
+  AssertQueryBuilder(op).assertResults(expected);
+}
+
+TEST_F(AggregationTest, singleAggregationStreamingIgnoreNullKeysAcrossBatches) {
+  auto batch1 = makeRowVector({
+      makeNullableFlatVector<int32_t>({1, 2, 1}),
+      makeFlatVector<int32_t>({10, 20, 30}),
+  });
+  auto batch2 = makeRowVector({
+      makeNullableFlatVector<int32_t>(
+          {std::nullopt, std::nullopt, std::nullopt}),
+      makeFlatVector<int32_t>({7, 8, 9}),
+  });
+  std::vector<RowVectorPtr> vectors{batch1, batch2};
+
+  createDuckDbTable(vectors);
+
+  auto op = PlanBuilder()
+                .values(vectors)
+                .aggregation(
+                    {"c0"},
+                    {"sum(c1)", "count(0)"},
+                    {},
+                    core::AggregationNode::Step::kSingle,
+                    true)
+                .planNode();
+
+  assertQuery(
+      op,
+      "SELECT c0, sum(c1), count(*) FROM tmp WHERE c0 IS NOT NULL GROUP BY c0");
+}
+
+TEST_F(AggregationTest, globalApproxDistinct) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4, 5, 1, 2, 3, 4, 5}),
+      makeFlatVector<int32_t>({10, 20, 30, 40, 50, 10, 20, 30, 40, 50}),
+  });
+
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .partialAggregation(
+                      {}, {"approx_distinct(c0)", "approx_distinct(c1)"})
+                  .finalAggregation()
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+
+  ASSERT_EQ(result->size(), 1);
+  auto c0_estimate = result->childAt(0)->as<FlatVector<int64_t>>()->valueAt(0);
+  auto c1_estimate = result->childAt(1)->as<FlatVector<int64_t>>()->valueAt(0);
+
+  EXPECT_GE(c0_estimate, 4);
+  EXPECT_LE(c0_estimate, 6);
+
+  EXPECT_GE(c1_estimate, 4);
+  EXPECT_LE(c1_estimate, 6);
+}
+
+TEST_F(AggregationTest, globalApproxDistinctWithNulls) {
+  auto data = makeRowVector({
+      makeNullableFlatVector<int64_t>({1, 2, std::nullopt, 3, 4, 5, 1, 2, 3}),
+  });
+
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .partialAggregation({}, {"approx_distinct(c0)"})
+                  .finalAggregation()
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+
+  ASSERT_EQ(result->size(), 1);
+  auto estimate = result->childAt(0)->as<FlatVector<int64_t>>()->valueAt(0);
+
+  EXPECT_GE(estimate, 4);
+  EXPECT_LE(estimate, 6);
+}
+
+TEST_F(AggregationTest, globalApproxDistinctHighCardinality) {
+  std::vector<int64_t> values;
+  for (int64_t i = 0; i < 10000; ++i) {
+    values.push_back(i);
+  }
+
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>(values),
+  });
+
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .partialAggregation({}, {"approx_distinct(c0)"})
+                  .finalAggregation()
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+
+  ASSERT_EQ(result->size(), 1);
+  auto estimate = result->childAt(0)->as<FlatVector<int64_t>>()->valueAt(0);
+
+  double error_rate =
+      std::abs(static_cast<double>(estimate) - 10000.0) / 10000.0;
+  EXPECT_LT(error_rate, 0.05);
+}
+
+TEST_F(AggregationTest, globalApproxDistinctEmpty) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>(std::vector<int64_t>{}),
+  });
+
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .partialAggregation({}, {"approx_distinct(c0)"})
+                  .finalAggregation()
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+
+  ASSERT_EQ(result->size(), 1);
+  auto estimate = result->childAt(0)->as<FlatVector<int64_t>>()->valueAt(0);
+
+  EXPECT_EQ(estimate, 0);
+}
+
+TEST_F(AggregationTest, globalApproxDistinctPartialIntermediateFinal) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4, 5, 1, 2, 3, 4, 5}),
+      makeFlatVector<int32_t>({10, 20, 30, 40, 50, 10, 20, 30, 40, 50}),
+  });
+
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .partialAggregation(
+                      {}, {"approx_distinct(c0)", "approx_distinct(c1)"})
+                  .intermediateAggregation()
+                  .finalAggregation()
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+
+  ASSERT_EQ(result->size(), 1);
+  auto c0_estimate = result->childAt(0)->as<FlatVector<int64_t>>()->valueAt(0);
+  auto c1_estimate = result->childAt(1)->as<FlatVector<int64_t>>()->valueAt(0);
+
+  EXPECT_GE(c0_estimate, 4);
+  EXPECT_LE(c0_estimate, 6);
+
+  EXPECT_GE(c1_estimate, 4);
+  EXPECT_LE(c1_estimate, 6);
+}
+
+TEST_F(AggregationTest, globalApproxDistinctWithNaN) {
+  auto data = makeRowVector({
+      makeFlatVector<double>({1.0, 2.0, std::nan(""), 4.0, std::nan(""), 1.0}),
+  });
+
+  auto planCudf = PlanBuilder()
+                      .values({data})
+                      .partialAggregation({}, {"approx_distinct(c0)"})
+                      .finalAggregation()
+                      .planNode();
+
+  auto cudfResult = AssertQueryBuilder(planCudf).copyResults(pool());
+  ASSERT_EQ(cudfResult->size(), 1);
+  auto cudfEstimate =
+      cudfResult->childAt(0)->as<FlatVector<int64_t>>()->valueAt(0);
+
+  cudf_velox::unregisterCudf();
+  auto planVelox = PlanBuilder()
+                       .values({data})
+                       .partialAggregation({}, {"approx_distinct(c0)"})
+                       .finalAggregation()
+                       .planNode();
+
+  auto veloxResult = AssertQueryBuilder(planVelox).copyResults(pool());
+  ASSERT_EQ(veloxResult->size(), 1);
+  auto veloxEstimate =
+      veloxResult->childAt(0)->as<FlatVector<int64_t>>()->valueAt(0);
+  cudf_velox::registerCudf();
+
+  EXPECT_EQ(cudfEstimate, veloxEstimate)
+      << "CUDF and Velox should produce the same result for NaN values. "
+      << "Expected distinct count: 3 (1.0, 2.0, 4.0) plus NaN as distinct. "
+      << "CUDF result: " << cudfEstimate << ", Velox result: " << veloxEstimate;
+
+  EXPECT_GE(cudfEstimate, 3);
+  EXPECT_LE(cudfEstimate, 5);
+}
+
+// Test stddev_samp with kSingle step and grouped aggregation
+TEST_F(AggregationTest, stddevSampSingleGrouped) {
+  // Hand-crafted data with known expected results
+  // Group 0: [1, 2, 3] -> stddev_samp = 1.0
+  // Group 1: [4, 6] -> stddev_samp = sqrt(2) ≈ 1.414
+  // Group 2: [10, 20, 30, 40] -> stddev_samp = sqrt(500/3) ≈ 12.909
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({0, 0, 0, 1, 1, 2, 2, 2, 2}), // c0 - key
+      makeFlatVector<int64_t>({1, 2, 3, 4, 6, 10, 20, 30, 40}), // c1 - bigint
+      makeFlatVector<double>(
+          {1.0, 2.0, 3.0, 4.0, 6.0, 10.0, 20.0, 30.0, 40.0}), // c2 - double
+  });
+  createDuckDbTable({data});
+
+  // Test with bigint input
+  auto op = PlanBuilder()
+                .values({data})
+                .singleAggregation({"c0"}, {"stddev_samp(c1)"})
+                .planNode();
+
+  assertQuery(op, "SELECT c0, stddev_samp(c1) FROM tmp GROUP BY c0");
+
+  // Test with double input
+  auto op2 = PlanBuilder()
+                 .values({data})
+                 .singleAggregation({"c0"}, {"stddev_samp(c2)"})
+                 .planNode();
+
+  assertQuery(op2, "SELECT c0, stddev_samp(c2) FROM tmp GROUP BY c0");
+}
+
+// Test stddev_samp with kPartial + kFinal (two-stage distributed)
+TEST_F(AggregationTest, stddevSampPartialFinalGrouped) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({0, 0, 0, 1, 1, 2, 2, 2, 2}),
+      makeFlatVector<int64_t>({1, 2, 3, 4, 6, 10, 20, 30, 40}),
+      makeFlatVector<double>({1.0, 2.0, 3.0, 4.0, 6.0, 10.0, 20.0, 30.0, 40.0}),
+  });
+  createDuckDbTable({data});
+
+  // Test with bigint input
+  auto op = PlanBuilder()
+                .values({data})
+                .partialAggregation({"c0"}, {"stddev_samp(c1)"})
+                .finalAggregation()
+                .planNode();
+
+  assertQuery(op, "SELECT c0, stddev_samp(c1) FROM tmp GROUP BY c0");
+
+  // Test with double input
+  auto op2 = PlanBuilder()
+                 .values({data})
+                 .partialAggregation({"c0"}, {"stddev_samp(c2)"})
+                 .finalAggregation()
+                 .planNode();
+
+  assertQuery(op2, "SELECT c0, stddev_samp(c2) FROM tmp GROUP BY c0");
+}
+
+// Test stddev_samp with kPartial + kIntermediate + kFinal (three-stage)
+TEST_F(AggregationTest, stddevSampPartialIntermediateFinalGrouped) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({0, 0, 0, 1, 1, 2, 2, 2, 2}),
+      makeFlatVector<int64_t>({1, 2, 3, 4, 6, 10, 20, 30, 40}),
+      makeFlatVector<double>({1.0, 2.0, 3.0, 4.0, 6.0, 10.0, 20.0, 30.0, 40.0}),
+  });
+  createDuckDbTable({data});
+
+  // Test with bigint input
+  auto op = PlanBuilder()
+                .values({data})
+                .partialAggregation({"c0"}, {"stddev_samp(c1)"})
+                .intermediateAggregation()
+                .finalAggregation()
+                .planNode();
+
+  assertQuery(op, "SELECT c0, stddev_samp(c1) FROM tmp GROUP BY c0");
+
+  // Test with double input
+  auto op2 = PlanBuilder()
+                 .values({data})
+                 .partialAggregation({"c0"}, {"stddev_samp(c2)"})
+                 .intermediateAggregation()
+                 .finalAggregation()
+                 .planNode();
+
+  assertQuery(op2, "SELECT c0, stddev_samp(c2) FROM tmp GROUP BY c0");
+}
+
+// Test stddev_samp with NULL values in input
+TEST_F(AggregationTest, stddevSampWithNulls) {
+  // Group 0: [1, NULL, 3] -> should compute stddev of [1, 3] = sqrt(2) ≈ 1.414
+  // Group 1: [4, 6, NULL] -> should compute stddev of [4, 6] = sqrt(2) ≈ 1.414
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({0, 0, 0, 1, 1, 1}),
+      makeNullableFlatVector<int64_t>({1, std::nullopt, 3, 4, 6, std::nullopt}),
+      makeNullableFlatVector<double>(
+          {1.0, std::nullopt, 3.0, 4.0, 6.0, std::nullopt}),
+  });
+  createDuckDbTable({data});
+
+  auto op = PlanBuilder()
+                .values({data})
+                .singleAggregation({"c0"}, {"stddev_samp(c1)"})
+                .planNode();
+
+  assertQuery(op, "SELECT c0, stddev_samp(c1) FROM tmp GROUP BY c0");
+
+  auto op2 = PlanBuilder()
+                 .values({data})
+                 .singleAggregation({"c0"}, {"stddev_samp(c2)"})
+                 .planNode();
+
+  assertQuery(op2, "SELECT c0, stddev_samp(c2) FROM tmp GROUP BY c0");
+}
+
+// Test stddev_samp with single value per group (should return NULL)
+TEST_F(AggregationTest, stddevSampSingleValueGroup) {
+  // Each group has only one value -> stddev_samp should return NULL
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({0, 1, 2}),
+      makeFlatVector<int64_t>({10, 20, 30}),
+      makeFlatVector<double>({10.0, 20.0, 30.0}),
+  });
+  createDuckDbTable({data});
+
+  auto op = PlanBuilder()
+                .values({data})
+                .singleAggregation({"c0"}, {"stddev_samp(c1)"})
+                .planNode();
+
+  assertQuery(op, "SELECT c0, stddev_samp(c1) FROM tmp GROUP BY c0");
+
+  auto op2 = PlanBuilder()
+                 .values({data})
+                 .singleAggregation({"c0"}, {"stddev_samp(c2)"})
+                 .planNode();
+
+  assertQuery(op2, "SELECT c0, stddev_samp(c2) FROM tmp GROUP BY c0");
+}
+
+// Test stddev_samp with all NULL input (should return NULL)
+TEST_F(AggregationTest, stddevSampAllNulls) {
+  // Group 0: all NULLs -> stddev_samp should return NULL
+  // Group 1: has values -> should compute normally
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({0, 0, 1, 1}),
+      makeNullableFlatVector<int64_t>({std::nullopt, std::nullopt, 1, 2}),
+      makeNullableFlatVector<double>({std::nullopt, std::nullopt, 1.0, 2.0}),
+  });
+  createDuckDbTable({data});
+
+  auto op = PlanBuilder()
+                .values({data})
+                .singleAggregation({"c0"}, {"stddev_samp(c1)"})
+                .planNode();
+
+  assertQuery(op, "SELECT c0, stddev_samp(c1) FROM tmp GROUP BY c0");
+
+  auto op2 = PlanBuilder()
+                 .values({data})
+                 .singleAggregation({"c0"}, {"stddev_samp(c2)"})
+                 .planNode();
+
+  assertQuery(op2, "SELECT c0, stddev_samp(c2) FROM tmp GROUP BY c0");
+}
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/experimental/cudf/tests/AssignUniqueIdTest.cpp b/velox/experimental/cudf/tests/AssignUniqueIdTest.cpp
new file mode 100644
index 00000000000..6d4e84ad1da
--- /dev/null
+++ b/velox/experimental/cudf/tests/AssignUniqueIdTest.cpp
@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/cudf/exec/CudfConversion.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/QueryAssertions.h"
+
+namespace facebook::velox::exec {
+
+using namespace facebook::velox::test;
+using namespace facebook::velox::exec::test;
+
+namespace {
+
+class AssignUniqueIdTest : public HiveConnectorTestBase {
+ protected:
+  void SetUp() override {
+    HiveConnectorTestBase::SetUp();
+    cudf_velox::registerCudf();
+  }
+
+  void TearDown() override {
+    cudf_velox::unregisterCudf();
+    HiveConnectorTestBase::TearDown();
+  }
+
+  void verifyUniqueId(
+      const std::shared_ptr<const core::PlanNode>& plan,
+      const std::vector<RowVectorPtr>& input) {
+    CursorParameters params;
+    params.planNode = plan;
+    params.queryConfigs.insert(
+        {cudf_velox::CudfFromVelox::kGpuBatchSizeRows, "1"});
+    auto result = readCursor(params);
+    ASSERT_EQ(result.second[0]->childrenSize(), input[0]->childrenSize() + 1);
+    verifyUniqueId(input, result.second);
+
+    auto task = result.first->task();
+    // Verify number of memory allocations. As no memory is allocated for the
+    // unique ID vector generation in GPU, the number of memory allocations
+    // should be 0. cudf can generate new columns, and cannot reuse the memory.
+    auto stats = toPlanStats(task->taskStats());
+    ASSERT_EQ(0, stats.at(uniqueNodeId_).numMemoryAllocations);
+    // check if CudfAssignUniqueId operator is executed with stats
+    ASSERT_EQ(
+        1, stats.at(uniqueNodeId_).operatorStats.count("CudfAssignUniqueId"));
+  }
+
+  void verifyUniqueId(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<facebook::velox::RowVectorPtr>& vectors) {
+    auto numColumns = vectors[0]->childrenSize();
+    ASSERT_EQ(numColumns, input[0]->childrenSize() + 1);
+
+    std::set<int64_t> ids;
+    for (int i = 0; i < numColumns; i++) {
+      for (auto batch = 0; batch < vectors.size(); ++batch) {
+        auto column = vectors[batch]->childAt(i);
+        if (i < numColumns - 1) {
+          assertEqualVectors(input[batch]->childAt(i), column);
+        } else {
+          auto idValues = column->asFlatVector<int64_t>()->rawValues();
+          std::copy(
+              idValues,
+              idValues + column->size(),
+              std::inserter(ids, ids.end()));
+        }
+      }
+    }
+
+    vector_size_t totalInputSize = 0;
+    for (const auto& vector : input) {
+      totalInputSize += vector->size();
+    }
+
+    ASSERT_EQ(totalInputSize, ids.size());
+  }
+
+  core::PlanNodeId uniqueNodeId_;
+};
+
+TEST_F(AssignUniqueIdTest, multiBatch) {
+  vector_size_t batchSize = 1000;
+  std::vector<RowVectorPtr> input;
+  input.reserve(3);
+  for (int i = 0; i < 3; ++i) {
+    input.push_back(
+        makeRowVector({makeFlatVector<int32_t>(batchSize, folly::identity)}));
+  }
+
+  auto plan = PlanBuilder()
+                  .values(input)
+                  .assignUniqueId()
+                  .capturePlanNodeId(uniqueNodeId_)
+                  .planNode();
+
+  verifyUniqueId(plan, input);
+}
+
+TEST_F(AssignUniqueIdTest, exceedRequestLimit) {
+  vector_size_t requestLimit = 1 << 20L;
+  auto input = {
+      makeRowVector(
+          {makeFlatVector<int32_t>(requestLimit - 10, folly::identity)}),
+      makeRowVector({makeFlatVector<int32_t>(100, folly::identity)}),
+      makeRowVector({makeFlatVector<int32_t>(100, folly::identity)}),
+  };
+
+  auto plan = PlanBuilder()
+                  .values(input)
+                  .assignUniqueId()
+                  .capturePlanNodeId(uniqueNodeId_)
+                  .planNode();
+
+  verifyUniqueId(plan, input);
+}
+
+TEST_F(AssignUniqueIdTest, multiThread) {
+  for (int i = 0; i < 3; i++) {
+    vector_size_t batchSize = 1000;
+    auto input = {
+        makeRowVector({makeFlatVector<int32_t>(batchSize, folly::identity)})};
+    auto plan = PlanBuilder()
+                    .values(input, true)
+                    .assignUniqueId()
+                    .capturePlanNodeId(uniqueNodeId_)
+                    .planNode();
+
+    std::shared_ptr<exec::Task> task;
+    auto result = AssertQueryBuilder(plan)
+                      .config(cudf_velox::CudfFromVelox::kGpuBatchSizeRows, "1")
+                      .maxDrivers(8)
+                      .copyResults(pool(), task);
+    ASSERT_EQ(batchSize * 8, result->size());
+
+    std::set<int64_t> ids;
+    auto idValues =
+        result->children().back()->asFlatVector<int64_t>()->rawValues();
+    std::copy(
+        idValues, idValues + result->size(), std::inserter(ids, ids.end()));
+
+    ASSERT_EQ(batchSize * 8, ids.size());
+
+    // Verify number of memory allocations. As no memory is allocated for the
+    // unique ID vector generation in GPU, the number of memory allocations
+    // should be 0. cudf can generate new columns, and cannot reuse the memory.
+    auto stats = toPlanStats(task->taskStats());
+    ASSERT_EQ(0, stats.at(uniqueNodeId_).numMemoryAllocations);
+  }
+}
+
+TEST_F(AssignUniqueIdTest, maxRowIdLimit) {
+  auto input = {makeRowVector({makeFlatVector<int32_t>({1, 2, 3})})};
+
+  auto plan = PlanBuilder().values(input).assignUniqueId().planNode();
+
+  // Increase the counter to kMaxRowId.
+  std::dynamic_pointer_cast<const core::AssignUniqueIdNode>(plan)
+      ->uniqueIdCounter()
+      ->fetch_add(1L << 40);
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan).copyResults(pool()),
+      "Ran out of unique IDs at 1099511627776");
+}
+
+TEST_F(AssignUniqueIdTest, taskUniqueIdLimit) {
+  auto input = {makeRowVector({makeFlatVector<int32_t>({1, 2, 3})})};
+
+  auto plan =
+      PlanBuilder().values(input).assignUniqueId("unique", 1L << 24).planNode();
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan).copyResults(pool()),
+      "(16777216 vs. 16777216) Unique 24-bit ID specified for AssignUniqueId exceeds the limit");
+}
+
+// TODO: Add test for barrier execution, other operators does not support
+// draining yet.
+} // namespace
+} // namespace facebook::velox::exec
diff --git a/velox/experimental/cudf/tests/BatchConcatTest.cpp b/velox/experimental/cudf/tests/BatchConcatTest.cpp
new file mode 100644
index 00000000000..ed19de4bb8e
--- /dev/null
+++ b/velox/experimental/cudf/tests/BatchConcatTest.cpp
@@ -0,0 +1,238 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+
+#include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::cudf_velox;
+
+class CudfBatchConcatTest : public OperatorTestBase {
+ protected:
+  void SetUp() override {
+    OperatorTestBase::SetUp();
+    CudfConfig::getInstance().debugEnabled = true;
+    cudf_velox::registerCudf();
+  }
+
+  void TearDown() override {
+    CudfConfig::getInstance().concatOptimizationEnabled = false;
+    cudf_velox::unregisterCudf();
+    OperatorTestBase::TearDown();
+  }
+
+  void updateCudfConfig(int32_t min, std::optional<int32_t> max) {
+    auto& config = CudfConfig::getInstance();
+    config.batchSizeMinThreshold = min;
+    config.batchSizeMaxThreshold = max;
+  }
+
+  template <typename T>
+  FlatVectorPtr<T> makeFlatSequence(T start, vector_size_t size) {
+    return makeFlatVector<T>(size, [start](auto row) { return start + row; });
+  }
+
+  // Builds fragmented input via localPartitionRoundRobin to prevent Values
+  // from coalescing small batches.
+  core::PlanNodePtr createFragmentedSource(
+      const std::vector<RowVectorPtr>& vectors,
+      std::shared_ptr<core::PlanNodeIdGenerator> generator) {
+    std::vector<core::PlanNodePtr> sources;
+    for (const auto& vec : vectors) {
+      sources.push_back(PlanBuilder(generator).values({vec}).planNode());
+    }
+    return PlanBuilder(generator).localPartitionRoundRobin(sources).planNode();
+  }
+
+  // Returns the per-operator-type stats for CudfBatchConcat within the given
+  // plan node, or nullptr if CudfBatchConcat wasn't inserted for that node.
+  const PlanNodeStats* getConcatStats(
+      const std::shared_ptr<Task>& task,
+      const core::PlanNodeId& aggNodeId) {
+    auto planStats = toPlanStats(task->taskStats());
+    auto nodeIt = planStats.find(aggNodeId);
+    if (nodeIt == planStats.end()) {
+      return nullptr;
+    }
+    auto opIt = nodeIt->second.operatorStats.find("CudfBatchConcat");
+    if (opIt == nodeIt->second.operatorStats.end()) {
+      return nullptr;
+    }
+    return opIt->second.get();
+  }
+};
+
+// Verifies that CudfBatchConcat is inserted before aggregation and reduces
+// the number of batches reaching the aggregation operator.
+TEST_F(CudfBatchConcatTest, concatReducesBatchesBeforeAggregation) {
+  // 6 batches of 10 rows each = 60 rows total.
+  // With min threshold 30, concat should accumulate ~3 batches before flushing,
+  // producing fewer output batches than the 6 it received.
+  updateCudfConfig(/*min=*/30, /*max=*/std::nullopt);
+  CudfConfig::getInstance().concatOptimizationEnabled = true;
+
+  std::vector<RowVectorPtr> vectors;
+  for (int i = 0; i < 6; ++i) {
+    vectors.push_back(makeRowVector({makeFlatSequence<int64_t>(i * 10, 10)}));
+  }
+  createDuckDbTable(vectors);
+
+  auto generator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId aggNodeId;
+
+  auto plan = PlanBuilder(generator)
+                  .addNode([&](auto id, auto pool) {
+                    return createFragmentedSource(vectors, generator);
+                  })
+                  .singleAggregation({}, {"sum(c0)"})
+                  .capturePlanNodeId(aggNodeId)
+                  .planNode();
+
+  auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                  .plan(plan)
+                  .maxDrivers(1)
+                  .assertResults("SELECT sum(c0) FROM tmp");
+
+  auto planStats = toPlanStats(task->taskStats());
+  auto& nodeStats = planStats.at(aggNodeId);
+  auto concatIt = nodeStats.operatorStats.find("CudfBatchConcat");
+  ASSERT_NE(concatIt, nodeStats.operatorStats.end())
+      << "CudfBatchConcat should be present in operator stats";
+
+  auto& concatStats = *concatIt->second;
+  EXPECT_EQ(concatStats.inputVectors, 6)
+      << "CudfBatchConcat should have received all 6 input batches";
+  EXPECT_LT(concatStats.outputVectors, concatStats.inputVectors)
+      << "CudfBatchConcat should produce fewer output batches than input";
+}
+
+// Verifies that CudfBatchConcat is not inserted when the optimization is
+// disabled, even when aggregation is present.
+TEST_F(CudfBatchConcatTest, concatNotInsertedWhenDisabled) {
+  updateCudfConfig(/*min=*/30, /*max=*/std::nullopt);
+  CudfConfig::getInstance().concatOptimizationEnabled = false;
+
+  std::vector<RowVectorPtr> vectors;
+  for (int i = 0; i < 6; ++i) {
+    vectors.push_back(makeRowVector({makeFlatSequence<int64_t>(i * 10, 10)}));
+  }
+  createDuckDbTable(vectors);
+
+  auto generator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId aggNodeId;
+
+  auto plan = PlanBuilder(generator)
+                  .addNode([&](auto id, auto pool) {
+                    return createFragmentedSource(vectors, generator);
+                  })
+                  .singleAggregation({}, {"sum(c0)"})
+                  .capturePlanNodeId(aggNodeId)
+                  .planNode();
+
+  auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                  .plan(plan)
+                  .maxDrivers(1)
+                  .assertResults("SELECT sum(c0) FROM tmp");
+
+  auto planStats = toPlanStats(task->taskStats());
+  auto& nodeStats = planStats.at(aggNodeId);
+  EXPECT_EQ(nodeStats.operatorStats.count("CudfBatchConcat"), 0)
+      << "CudfBatchConcat should not be present when optimization is disabled";
+}
+
+// When the threshold exceeds total input rows, concat accumulates all batches
+// and flushes them as a single merged batch on noMoreInput.
+TEST_F(CudfBatchConcatTest, concatMergesAllOnFlushWithHighThreshold) {
+  updateCudfConfig(/*min=*/100000, /*max=*/std::nullopt);
+  CudfConfig::getInstance().concatOptimizationEnabled = true;
+
+  std::vector<RowVectorPtr> vectors;
+  for (int i = 0; i < 6; ++i) {
+    vectors.push_back(makeRowVector({makeFlatSequence<int64_t>(i * 10, 10)}));
+  }
+  createDuckDbTable(vectors);
+
+  auto generator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId aggNodeId;
+
+  auto plan = PlanBuilder(generator)
+                  .addNode([&](auto id, auto pool) {
+                    return createFragmentedSource(vectors, generator);
+                  })
+                  .singleAggregation({}, {"sum(c0)"})
+                  .capturePlanNodeId(aggNodeId)
+                  .planNode();
+
+  auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                  .plan(plan)
+                  .maxDrivers(1)
+                  .assertResults("SELECT sum(c0) FROM tmp");
+
+  auto planStats = toPlanStats(task->taskStats());
+  auto& nodeStats = planStats.at(aggNodeId);
+  auto concatIt = nodeStats.operatorStats.find("CudfBatchConcat");
+  ASSERT_NE(concatIt, nodeStats.operatorStats.end())
+      << "CudfBatchConcat should still be inserted even with high threshold";
+
+  auto& concatStats = *concatIt->second;
+  EXPECT_EQ(concatStats.inputVectors, 6);
+  EXPECT_EQ(concatStats.outputVectors, 1)
+      << "All batches should be merged into one on noMoreInput flush";
+}
+
+// Verifies correctness with grouped aggregation (non-global) and concat.
+TEST_F(CudfBatchConcatTest, concatWithGroupedAggregation) {
+  updateCudfConfig(/*min=*/30, /*max=*/std::nullopt);
+  CudfConfig::getInstance().concatOptimizationEnabled = true;
+
+  std::vector<RowVectorPtr> vectors;
+  for (int i = 0; i < 6; ++i) {
+    vectors.push_back(makeRowVector(
+        {makeFlatVector<int64_t>(10, [](auto row) { return row % 3; }),
+         makeFlatSequence<int64_t>(i * 10, 10)}));
+  }
+  createDuckDbTable(vectors);
+
+  auto generator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId aggNodeId;
+
+  auto plan = PlanBuilder(generator)
+                  .addNode([&](auto id, auto pool) {
+                    return createFragmentedSource(vectors, generator);
+                  })
+                  .singleAggregation({"c0"}, {"sum(c1)"})
+                  .capturePlanNodeId(aggNodeId)
+                  .planNode();
+
+  auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                  .plan(plan)
+                  .maxDrivers(1)
+                  .assertResults("SELECT c0, sum(c1) FROM tmp GROUP BY c0");
+
+  auto planStats = toPlanStats(task->taskStats());
+  auto& nodeStats = planStats.at(aggNodeId);
+  auto concatIt = nodeStats.operatorStats.find("CudfBatchConcat");
+  ASSERT_NE(concatIt, nodeStats.operatorStats.end());
+  EXPECT_EQ(concatIt->second->inputVectors, 6);
+  EXPECT_LT(concatIt->second->outputVectors, 6);
+}
diff --git a/velox/experimental/cudf/tests/CMakeLists.txt b/velox/experimental/cudf/tests/CMakeLists.txt
index 96e9e4076c2..f003b0b0939 100644
--- a/velox/experimental/cudf/tests/CMakeLists.txt
+++ b/velox/experimental/cudf/tests/CMakeLists.txt
@@ -12,180 +12,220 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(velox_cudf_hash_join_test HashJoinTest.cpp Main.cpp)
-add_executable(velox_cudf_order_by_test Main.cpp OrderByTest.cpp)
-add_executable(velox_cudf_aggregation_test Main.cpp AggregationTest.cpp)
-add_executable(velox_cudf_table_scan_test Main.cpp TableScanTest.cpp)
-# Disabling writer tests until we re-add writing ability to CudfHiveConnector
-# add_executable(velox_cudf_table_write_test Main.cpp TableWriteTest.cpp)
-add_executable(velox_cudf_local_partition_test Main.cpp LocalPartitionTest.cpp)
-add_executable(velox_cudf_filter_project_test Main.cpp FilterProjectTest.cpp)
-add_executable(velox_cudf_subfield_filter_ast_test Main.cpp SubfieldFilterAstTest.cpp)
-add_executable(velox_cudf_limit_test Main.cpp LimitTest.cpp)
+# Common libraries shared by most cudf tests.
+set(CUDF_TEST_DEFAULT_LIBS velox_cudf_exec velox_exec velox_exec_test_lib velox_test_util)
+
+# Adds a cudf test target with standard boilerplate.
+#
+# Usage:
+#   velox_add_cudf_test(
+#     NAME <test_name>
+#     SOURCES <source_files...>
+#     LIBS <libraries...>
+#     [TIMEOUT <seconds>]
+#   )
+#
+# gtest and gtest_main are always appended to LIBS.
+# Default timeout: 300 seconds
+function(velox_add_cudf_test)
+  set(options "")
+  set(one_value_args NAME TIMEOUT)
+  set(multi_value_args SOURCES LIBS)
+  cmake_parse_arguments(ARG "${options}" "${one_value_args}" "${multi_value_args}" ${ARGN})
+
+  if(NOT ARG_TIMEOUT)
+    set(ARG_TIMEOUT 300)
+  endif()
+
+  add_executable(${ARG_NAME} ${ARG_SOURCES})
+  add_test(NAME ${ARG_NAME} COMMAND ${ARG_NAME} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  set_tests_properties(${ARG_NAME} PROPERTIES LABELS cuda_driver TIMEOUT ${ARG_TIMEOUT})
+  target_link_libraries(${ARG_NAME} ${ARG_LIBS} gtest gtest_main)
+endfunction()
+
+velox_add_cudf_test(
+  NAME velox_cudf_aggregation_test
+  SOURCES Main.cpp AggregationTest.cpp
+  LIBS ${CUDF_TEST_DEFAULT_LIBS} velox_vector_fuzzer
+)
+
+velox_add_cudf_test(
+  NAME velox_cudf_aggregation_selection_test
+  SOURCES Main.cpp AggregationSelectionTest.cpp
+  LIBS ${CUDF_TEST_DEFAULT_LIBS} velox_functions_spark
+)
+
+velox_add_cudf_test(
+  NAME velox_cudf_assign_unique_id_test
+  SOURCES Main.cpp AssignUniqueIdTest.cpp
+  LIBS ${CUDF_TEST_DEFAULT_LIBS}
+)
+
+velox_add_cudf_test(
+  NAME velox_cudf_batch_concat_test
+  SOURCES Main.cpp BatchConcatTest.cpp
+  LIBS ${CUDF_TEST_DEFAULT_LIBS}
+)
+
+velox_add_cudf_test(
+  NAME velox_cudf_config_test
+  SOURCES Main.cpp ConfigTest.cpp
+  LIBS velox_cudf_exec Folly::folly
+)
+
+velox_add_cudf_test(
+  NAME velox_cudf_decimal_expression_test
+  SOURCES Main.cpp DecimalExpressionTest.cpp
+  LIBS ${CUDF_TEST_DEFAULT_LIBS} velox_functions_test_lib
+  TIMEOUT 3000
+)
+
+velox_add_cudf_test(
+  NAME velox_cudf_enforce_single_row_test
+  SOURCES Main.cpp EnforceSingleRowTest.cpp
+  LIBS ${CUDF_TEST_DEFAULT_LIBS}
+)
+
+velox_add_cudf_test(
+  NAME velox_cudf_expression_selection_test
+  SOURCES Main.cpp ExpressionEvaluatorSelectionTest.cpp
+  LIBS ${CUDF_TEST_DEFAULT_LIBS} velox_functions_spark
+)
+
+velox_add_cudf_test(
+  NAME velox_cudf_adapter_operator_test
+  SOURCES Main.cpp AdapterOperatorTest.cpp
+  LIBS ${CUDF_TEST_DEFAULT_LIBS} velox_functions_test_lib
+)
+
+velox_add_cudf_test(
+  NAME velox_cudf_filter_project_test
+  SOURCES Main.cpp FilterProjectTest.cpp
+  LIBS ${CUDF_TEST_DEFAULT_LIBS} velox_functions_test_lib
+)
 
-add_test(
+velox_add_cudf_test(
+  NAME velox_cudf_function_registry_test
+  SOURCES Main.cpp FunctionRegistryTest.cpp
+  LIBS velox_cudf_expression velox_cudf_exec velox_exec velox_exec_test_lib velox_test_util
+)
+
+velox_add_cudf_test(
+  NAME velox_cudf_group_id_test
+  SOURCES Main.cpp GroupIdTest.cpp
+  LIBS ${CUDF_TEST_DEFAULT_LIBS}
+)
+
+velox_add_cudf_test(
   NAME velox_cudf_hash_join_test
-  COMMAND velox_cudf_hash_join_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+  SOURCES HashJoinTest.cpp Main.cpp
+  LIBS ${CUDF_TEST_DEFAULT_LIBS} velox_vector_fuzzer Folly::folly fmt::fmt
 )
 
-add_test(
-  NAME velox_cudf_order_by_test
-  COMMAND velox_cudf_order_by_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+velox_add_cudf_test(
+  NAME velox_cudf_interop_test
+  SOURCES Main.cpp InteropTest.cpp
+  LIBS ${CUDF_TEST_DEFAULT_LIBS}
 )
 
-add_test(
-  NAME velox_cudf_aggregation_test
-  COMMAND velox_cudf_aggregation_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+velox_add_cudf_test(
+  NAME velox_cudf_limit_test
+  SOURCES Main.cpp LimitTest.cpp
+  LIBS ${CUDF_TEST_DEFAULT_LIBS}
 )
 
-add_test(
+velox_add_cudf_test(
   NAME velox_cudf_local_partition_test
-  COMMAND velox_cudf_local_partition_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+  SOURCES Main.cpp LocalPartitionTest.cpp
+  LIBS ${CUDF_TEST_DEFAULT_LIBS} fmt::fmt
 )
 
-add_test(
-  NAME velox_cudf_table_scan_test
-  COMMAND velox_cudf_table_scan_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+velox_add_cudf_test(
+  NAME velox_cudf_mark_distinct_test
+  SOURCES Main.cpp MarkDistinctTest.cpp
+  LIBS ${CUDF_TEST_DEFAULT_LIBS}
 )
 
-# add_test(
-#   NAME velox_cudf_table_write_test
-#   COMMAND velox_cudf_table_write_test
-#   WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-# )
+velox_add_cudf_test(
+  NAME velox_cudf_nested_loop_join_test
+  SOURCES Main.cpp NestedLoopJoinTest.cpp
+  LIBS ${CUDF_TEST_DEFAULT_LIBS}
+)
 
-add_test(
-  NAME velox_cudf_filter_project_test
-  COMMAND velox_cudf_filter_project_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+velox_add_cudf_test(
+  NAME velox_cudf_order_by_test
+  SOURCES Main.cpp OrderByTest.cpp
+  LIBS ${CUDF_TEST_DEFAULT_LIBS} fmt::fmt
+)
+
+if(VELOX_ENABLE_S3)
+  velox_add_cudf_test(
+    NAME velox_cudf_s3_read_test
+    SOURCES Main.cpp S3ReadTest.cpp
+    LIBS
+      velox_cudf_exec_test_lib
+      velox_cudf_hive_connector
+      velox_exec
+      velox_exec_test_lib
+      velox_file
+      velox_s3fs
+      velox_test_util
+  )
+endif()
+
+velox_add_cudf_test(
+  NAME velox_cudf_step_aware_aggregation_registry_test
+  SOURCES Main.cpp StepAwareAggregationRegistryTest.cpp
+  LIBS ${CUDF_TEST_DEFAULT_LIBS} velox_cudf_exec_test_lib
+)
+
+velox_add_cudf_test(
+  NAME velox_cudf_string_function_test
+  SOURCES Main.cpp StringFunctionTest.cpp
+  LIBS ${CUDF_TEST_DEFAULT_LIBS} velox_functions_test_lib
 )
 
-add_test(
+velox_add_cudf_test(
   NAME velox_cudf_subfield_filter_ast_test
-  COMMAND velox_cudf_subfield_filter_ast_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+  SOURCES Main.cpp SubfieldFilterAstTest.cpp
+  LIBS ${CUDF_TEST_DEFAULT_LIBS}
 )
 
-add_test(
-  NAME velox_cudf_limit_test
-  COMMAND velox_cudf_limit_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-)
-
-set_tests_properties(velox_cudf_hash_join_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
-set_tests_properties(velox_cudf_order_by_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
-set_tests_properties(velox_cudf_aggregation_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
-set_tests_properties(velox_cudf_local_partition_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
-set_tests_properties(velox_cudf_table_scan_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
-# set_tests_properties(velox_cudf_table_write_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
-set_tests_properties(velox_cudf_filter_project_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
-set_tests_properties(velox_cudf_subfield_filter_ast_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
-set_tests_properties(velox_cudf_limit_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
-
-target_link_libraries(
-  velox_cudf_hash_join_test
-  velox_cudf_exec
-  velox_exec
-  velox_exec_test_lib
-  velox_test_util
-  velox_vector_fuzzer
-  gtest
-  gtest_main
-  Folly::folly
-  fmt::fmt
-)
-
-target_link_libraries(
-  velox_cudf_order_by_test
-  velox_cudf_exec
-  velox_exec
-  velox_exec_test_lib
-  velox_test_util
-  gtest
-  gtest_main
-  fmt::fmt
-)
-
-target_link_libraries(
-  velox_cudf_aggregation_test
-  velox_cudf_exec
-  velox_exec
-  velox_exec_test_lib
-  velox_test_util
-  velox_vector_fuzzer
-  gtest
-  gtest_main
-  fmt::fmt
-)
-
-target_link_libraries(
-  velox_cudf_local_partition_test
-  velox_cudf_exec
-  velox_exec
-  velox_exec_test_lib
-  velox_test_util
-  gtest
-  gtest_main
-  fmt::fmt
-)
-
-target_link_libraries(
-  velox_cudf_table_scan_test
-  velox_cudf_exec_test_lib
-  velox_cudf_hive_connector
-  velox_exec
-  velox_exec_test_lib
-  velox_test_util
-  gtest
-  gtest_main
-  fmt::fmt
-)
-
-# target_link_libraries(
-#   velox_cudf_table_write_test
-#   velox_cudf_exec_test_lib
-#   velox_cudf_hive_connector
-#   velox_exec
-#   velox_exec_test_lib
-#   velox_test_util
-#   gtest
-#   gtest_main
-#   fmt::fmt
+velox_add_cudf_test(
+  NAME velox_cudf_table_scan_test
+  SOURCES Main.cpp TableScanTest.cpp
+  LIBS
+    velox_cudf_exec_test_lib
+    velox_cudf_hive_connector
+    velox_exec
+    velox_exec_test_lib
+    velox_test_util
+    fmt::fmt
+)
+
+# Disabling writer tests until we re-add writing ability to CudfHiveConnector
+# velox_add_cudf_test(
+#   NAME velox_cudf_table_write_test
+#   SOURCES Main.cpp TableWriteTest.cpp
+#   LIBS
+#     velox_cudf_exec_test_lib
+#     velox_cudf_hive_connector
+#     velox_exec
+#     velox_exec_test_lib
+#     velox_test_util
+#     fmt::fmt
 # )
 
-target_link_libraries(
-  velox_cudf_filter_project_test
-  velox_cudf_exec
-  velox_exec
-  velox_exec_test_lib
-  velox_test_util
-  gtest
-  gtest_main
-)
-
-target_link_libraries(
-  velox_cudf_subfield_filter_ast_test
-  velox_cudf_exec
-  velox_exec
-  velox_exec_test_lib
-  velox_test_util
-  gtest
-  gtest_main
-)
-
-target_link_libraries(
-  velox_cudf_limit_test
-  velox_cudf_exec
-  velox_exec
-  velox_exec_test_lib
-  velox_test_util
-  gtest
-  gtest_main
+velox_add_cudf_test(
+  NAME velox_cudf_tocudf_selection_test
+  SOURCES Main.cpp ToCudfSelectionTest.cpp
+  LIBS ${CUDF_TEST_DEFAULT_LIBS} velox_vector_fuzzer
+)
+
+velox_add_cudf_test(
+  NAME velox_cudf_topn_test
+  SOURCES Main.cpp TopNTest.cpp
+  LIBS ${CUDF_TEST_DEFAULT_LIBS} fmt::fmt
 )
 
 add_subdirectory(utils)
diff --git a/velox/experimental/cudf/tests/ConfigTest.cpp b/velox/experimental/cudf/tests/ConfigTest.cpp
new file mode 100644
index 00000000000..f8344ffd709
--- /dev/null
+++ b/velox/experimental/cudf/tests/ConfigTest.cpp
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/CudfConfig.h"
+
+#include <gtest/gtest.h>
+
+namespace facebook::velox::cudf_velox::test {
+
+TEST(ConfigTest, CudfConfig) {
+  std::unordered_map<std::string, std::string> options = {
+      {CudfConfig::kCudfEnabled, "false"},
+      {CudfConfig::kCudfDebugEnabled, "true"},
+      {CudfConfig::kCudfMemoryResource, "arena"},
+      {CudfConfig::kCudfMemoryPercent, "25"},
+      {CudfConfig::kCudfFunctionNamePrefix, "presto"},
+      {CudfConfig::kCudfAllowCpuFallback, "false"}};
+
+  CudfConfig config;
+  config.initialize(std::move(options));
+  ASSERT_EQ(config.enabled, false);
+  ASSERT_EQ(config.debugEnabled, true);
+  ASSERT_EQ(config.memoryResource, "arena");
+  ASSERT_EQ(config.memoryPercent, 25);
+  ASSERT_EQ(config.functionNamePrefix, "presto");
+  ASSERT_EQ(config.allowCpuFallback, false);
+}
+} // namespace facebook::velox::cudf_velox::test
diff --git a/velox/experimental/cudf/tests/CudfFunctionBaseTest.h b/velox/experimental/cudf/tests/CudfFunctionBaseTest.h
new file mode 100644
index 00000000000..d55ae4d77da
--- /dev/null
+++ b/velox/experimental/cudf/tests/CudfFunctionBaseTest.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
+
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+
+namespace facebook::velox::cudf_velox {
+
+class CudfFunctionBaseTest : public velox::functions::test::FunctionBaseTest {
+ protected:
+  VectorPtr evaluate(
+      exec::ExprSet& exprSet,
+      const RowVectorPtr& input,
+      const std::optional<SelectivityVector>& rows = std::nullopt) override {
+    exec::EvalCtx context(&execCtx_, &exprSet, input.get());
+
+    VELOX_CHECK(!rows.has_value());
+    auto stream = cudf::get_default_stream();
+    auto cudfTable = velox::cudf_velox::with_arrow::toCudfTable(
+        input, pool_.get(), stream, cudf::get_current_device_resource_ref());
+    auto filterEvaluator =
+        createCudfExpression({exprSet.exprs()[0]}, input->rowType());
+    auto ownedColumns = cudfTable->release();
+    std::vector<cudf::column_view> inputViews;
+    inputViews.reserve(ownedColumns.size());
+    for (auto& col : ownedColumns) {
+      inputViews.push_back(col->view());
+    }
+    auto filterColumn = filterEvaluator->eval(
+        inputViews, stream, cudf::get_current_device_resource_ref());
+    auto filterColumnView = asView(filterColumn);
+    cudf::table_view resultTable({filterColumnView});
+    auto result = velox::cudf_velox::with_arrow::toVeloxColumn(
+        resultTable,
+        pool_.get(),
+        "",
+        stream,
+        cudf::get_current_device_resource_ref());
+    return result->childAt(0);
+  }
+};
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/tests/DecimalExpressionTest.cpp b/velox/experimental/cudf/tests/DecimalExpressionTest.cpp
new file mode 100644
index 00000000000..8616ae718d6
--- /dev/null
+++ b/velox/experimental/cudf/tests/DecimalExpressionTest.cpp
@@ -0,0 +1,1584 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/parse/TypeResolver.h"
+#include "velox/type/DecimalUtil.h"
+
+#include <cuda_runtime_api.h>
+
+namespace facebook::velox::cudf_velox {
+namespace {
+
+class CudfDecimalTest : public exec::test::OperatorTestBase {
+ protected:
+  void SetUp() override {
+    exec::test::OperatorTestBase::SetUp();
+    filesystems::registerLocalFileSystem();
+    parse::registerTypeResolver();
+    functions::prestosql::registerAllScalarFunctions();
+    CudfConfig::getInstance().allowCpuFallback = false;
+    // Ensure a CUDA device is selected and initialized (RMM asserts otherwise).
+    int deviceCount = 0;
+    auto status = cudaGetDeviceCount(&deviceCount);
+    if (status != cudaSuccess) {
+      GTEST_SKIP() << "cudaGetDeviceCount failed: " << static_cast<int>(status)
+                   << " (" << cudaGetErrorString(status) << ")";
+    }
+    if (deviceCount == 0) {
+      GTEST_SKIP() << "No CUDA devices visible (check CUDA_VISIBLE_DEVICES)";
+    }
+    VELOX_CHECK_EQ(0, static_cast<int>(cudaSetDevice(0)));
+    VELOX_CHECK_EQ(0, static_cast<int>(cudaFree(nullptr)));
+    registerCudf();
+  }
+
+  void TearDown() override {
+    unregisterCudf();
+    exec::test::OperatorTestBase::TearDown();
+  }
+};
+
+TEST_F(CudfDecimalTest, decimal64And128ArithmeticAndComparison) {
+  // Short decimal (64-bit) uses scale 2, long decimal (128-bit) uses scale 10.
+  auto rowType = ROW({
+      {"d64_a", DECIMAL(12, 2)},
+      {"d64_b", DECIMAL(12, 2)},
+      {"d128_a", DECIMAL(38, 10)},
+      {"d128_b", DECIMAL(38, 10)},
+  });
+
+  // Raw values are already scaled.
+  auto input = makeRowVector(
+      {"d64_a", "d64_b", "d128_a", "d128_b"},
+      {
+          makeFlatVector<int64_t>(
+              {12345, -2500, 999999},
+              DECIMAL(12, 2)), // 123.45, -25.00, 9999.99
+          makeFlatVector<int64_t>(
+              {6789, 1500, -50000}, DECIMAL(12, 2)), // 67.89, 15.00, -500.00
+          makeFlatVector<int128_t>(
+              {
+                  static_cast<int128_t>(123'456'789'012), // 12.3456789012
+                  static_cast<int128_t>(-987'654'321'098), // -98.7654321098
+                  static_cast<int128_t>(555'000'000'000), // 55.5000000000
+              },
+              DECIMAL(38, 10)),
+          makeFlatVector<int128_t>(
+              {
+                  static_cast<int128_t>(222'222'222'222), // 22.2222222222
+                  static_cast<int128_t>(333'333'333'333), // 33.3333333333
+                  static_cast<int128_t>(-111'111'111'111), // -11.1111111111
+              },
+              DECIMAL(38, 10)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+  createDuckDbTable(vectors);
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({
+                      "d64_a + d64_b AS sum64",
+                      "d64_a - d64_b AS diff64",
+                      "d64_a > d64_b AS gt64",
+                      "d128_a + d128_b AS sum128",
+                      "d128_a - d128_b AS diff128",
+                      "d128_a < d128_b AS lt128",
+                  })
+                  .planNode();
+
+  facebook::velox::exec::test::AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .assertResults(
+          "SELECT d64_a + d64_b AS sum64, "
+          "d64_a - d64_b AS diff64, "
+          "d64_a > d64_b AS gt64, "
+          "d128_a + d128_b AS sum128, "
+          "d128_a - d128_b AS diff128, "
+          "d128_a < d128_b AS lt128 "
+          "FROM tmp");
+}
+
+TEST_F(CudfDecimalTest, decimalIdentityProjection64And128) {
+  auto rowType = ROW({
+      {"d64", DECIMAL(12, 2)},
+      {"d128", DECIMAL(38, 10)},
+  });
+
+  // Max absolute raw value for DECIMAL(38,10) is 10^28 - 1 (28 integer digits).
+  const int128_t max38p10 = facebook::velox::DecimalUtil::kPowersOfTen[28] - 1;
+
+  auto input = makeRowVector(
+      {"d64", "d128"},
+      {
+          makeFlatVector<int64_t>(
+              {
+                  // Near max/min for DECIMAL(12,2): +/- 99,999,999,999.99
+                  9'999'999'999'999, // 99,999,999,999.99
+                  -9'999'999'999'999, // -99,999,999,999.99
+                                      // Mid-range values
+                  123'45, // 1,23.45
+                  -2'500, // -25.00
+                  999'999, // 9,999.99
+                  -1'000, // -10.00
+                  0,
+                  1, // 0.01
+                  -1, // -0.01
+              },
+              DECIMAL(12, 2)),
+          makeFlatVector<int128_t>(
+              {
+                  // Near max/min for DECIMAL(38,10): +/- (10^28 - 1) with scale
+                  // 10
+                  max38p10,
+                  -max38p10,
+                  // Mid-range values
+                  static_cast<int128_t>(123'456'789'012), // 12.3456789012
+                  static_cast<int128_t>(-987'654'321'098), // -98.7654321098
+                  static_cast<int128_t>(555'000'000'000), // 55.5000000000
+                  static_cast<int128_t>(44'388'888'889), // 4.4388888889
+                  static_cast<int128_t>(1), // 0.0000000001
+                  static_cast<int128_t>(-1), // -0.0000000001
+                  static_cast<int128_t>(0),
+              },
+              DECIMAL(38, 10)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+  createDuckDbTable(vectors);
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({"d64", "d128"})
+                  .planNode();
+
+  facebook::velox::exec::test::AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .assertResults("SELECT d64, d128 FROM tmp");
+}
+
+TEST_F(CudfDecimalTest, decimalAddition64And128) {
+  auto rowType = ROW({
+      {"d64_a", DECIMAL(12, 2)},
+      {"d64_b", DECIMAL(12, 2)},
+      {"d128_a", DECIMAL(38, 10)},
+      {"d128_b", DECIMAL(38, 10)},
+  });
+
+  const int128_t max38p10 = facebook::velox::DecimalUtil::kPowersOfTen[28] - 1;
+  const int128_t min38p10 = -max38p10;
+
+  auto input = makeRowVector(
+      {"d64_a", "d64_b", "d128_a", "d128_b"},
+      {
+          makeFlatVector<int64_t>(
+              {
+                  9'999'999'999'99, // 9,999,999,999.99 (near max for 12,2)
+                  -9'999'999'999'99, // -9,999,999,999.99
+                  123'45, // 1,23.45
+                  -2'500, // -25.00
+                  0,
+              },
+              DECIMAL(12, 2)),
+          makeFlatVector<int64_t>(
+              {
+                  1, // 0.01
+                  -1, // -0.01
+                  9'999, // 99.99
+                  -100, // -1.00
+                  50, // 0.50
+              },
+              DECIMAL(12, 2)),
+          makeFlatVector<int128_t>(
+              {
+                  max38p10,
+                  min38p10,
+                  static_cast<int128_t>(123'456'789'012), // 12.3456789012
+                  static_cast<int128_t>(-987'654'321'098), // -98.7654321098
+                  static_cast<int128_t>(0),
+              },
+              DECIMAL(38, 10)),
+          makeFlatVector<int128_t>(
+              {
+                  static_cast<int128_t>(1), // 0.0000000001
+                  static_cast<int128_t>(-1), // -0.0000000001
+                  static_cast<int128_t>(44'388'888'889), // 4.4388888889
+                  static_cast<int128_t>(555'000'000'000), // 55.5000000000
+                  max38p10,
+              },
+              DECIMAL(38, 10)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+  createDuckDbTable(vectors);
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({
+                      "d64_a + d64_b AS sum64",
+                      "d128_a + d128_b AS sum128",
+                  })
+                  .planNode();
+
+  facebook::velox::exec::test::AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .assertResults(
+          "SELECT d64_a + d64_b AS sum64, d128_a + d128_b AS sum128 FROM tmp");
+}
+
+TEST_F(CudfDecimalTest, decimalMultiplyPromotesToLong) {
+  // Two short decimals whose product requires long decimal precision.
+  auto rowType = ROW({
+      {"a", DECIMAL(10, 0)},
+      {"b", DECIMAL(10, 0)},
+  });
+
+  auto input = makeRowVector(
+      {"a", "b"},
+      {
+          makeFlatVector<int64_t>(
+              {9'999'999'999, 1'234'567'890, -2'000'000'000}, DECIMAL(10, 0)),
+          makeFlatVector<int64_t>({9'999'999'999, -2, 4}, DECIMAL(10, 0)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({"a * b AS prod"})
+                  .planNode();
+
+  const int128_t expected0 = static_cast<int128_t>(9'999'999'999LL) *
+      static_cast<int128_t>(9'999'999'999LL);
+  auto expected = makeRowVector(
+      {"prod"},
+      {makeFlatVector<int128_t>(
+          {expected0,
+           static_cast<int128_t>(-2'469'135'780LL),
+           static_cast<int128_t>(-8'000'000'000LL)},
+          DECIMAL(20, 0))});
+
+  // CPU (no cuDF adapter registered).
+  unregisterCudf();
+  auto cpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  registerCudf();
+
+  // GPU (enable cuDF, no fallback).
+  auto gpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+
+  // Verify promotion to long decimal and exact results on CPU/GPU.
+  ASSERT_TRUE(cpuResult->childAt(0)->type()->isLongDecimal());
+  ASSERT_TRUE(gpuResult->childAt(0)->type()->isLongDecimal());
+  facebook::velox::test::assertEqualVectors(expected, cpuResult);
+  facebook::velox::test::assertEqualVectors(expected, gpuResult);
+}
+
+TEST_F(CudfDecimalTest, decimalAddPromotesToLong) {
+  // Two short decimals whose sum requires long decimal precision.
+  auto rowType = ROW({
+      {"a", DECIMAL(18, 0)},
+      {"b", DECIMAL(18, 0)},
+  });
+
+  auto input = makeRowVector(
+      {"a", "b"},
+      {
+          makeFlatVector<int64_t>(
+              {999'999'999'999'999'999LL,
+               -900'000'000'000'000'000LL,
+               123'456'789'012'345'678LL},
+              DECIMAL(18, 0)),
+          makeFlatVector<int64_t>(
+              {999'999'999'999'999'999LL,
+               -900'000'000'000'000'000LL,
+               -123'456'789'012'345'678LL},
+              DECIMAL(18, 0)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({"a + b AS sum"})
+                  .planNode();
+
+  auto expected = makeRowVector(
+      {"sum"},
+      {makeFlatVector<int128_t>(
+          {static_cast<int128_t>(1'999'999'999'999'999'998LL),
+           static_cast<int128_t>(-1'800'000'000'000'000'000LL),
+           static_cast<int128_t>(0)},
+          DECIMAL(19, 0))});
+
+  // CPU (no cuDF adapter registered).
+  unregisterCudf();
+  auto cpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  registerCudf();
+
+  // GPU (cuDF enabled).
+  auto gpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+
+  ASSERT_TRUE(cpuResult->childAt(0)->type()->isLongDecimal());
+  ASSERT_TRUE(gpuResult->childAt(0)->type()->isLongDecimal());
+  facebook::velox::test::assertEqualVectors(expected, cpuResult);
+  facebook::velox::test::assertEqualVectors(expected, gpuResult);
+}
+
+TEST_F(CudfDecimalTest, decimalAddDifferentScales) {
+  auto rowType = ROW({
+      {"a", DECIMAL(10, 2)},
+      {"b", DECIMAL(10, 1)},
+  });
+
+  auto input = makeRowVector(
+      {"a", "b"},
+      {
+          makeFlatVector<int64_t>({12345, -2500, 100}, DECIMAL(10, 2)),
+          makeFlatVector<int64_t>({10, -25, 3}, DECIMAL(10, 1)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+  createDuckDbTable(vectors);
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({"a + b AS sum"})
+                  .planNode();
+
+  facebook::velox::exec::test::AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .assertResults("SELECT a + b AS sum FROM tmp");
+}
+
+TEST_F(CudfDecimalTest, decimalSubtractDifferentScales) {
+  auto rowType = ROW({
+      {"a", DECIMAL(10, 2)},
+      {"b", DECIMAL(10, 1)},
+  });
+
+  auto input = makeRowVector(
+      {"a", "b"},
+      {
+          makeFlatVector<int64_t>({12345, -2500, 100}, DECIMAL(10, 2)),
+          makeFlatVector<int64_t>({10, -25, 3}, DECIMAL(10, 1)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+  createDuckDbTable(vectors);
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({"a - b AS diff"})
+                  .planNode();
+
+  facebook::velox::exec::test::AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .assertResults("SELECT a - b AS diff FROM tmp");
+}
+
+TEST_F(CudfDecimalTest, decimalMultiplyDifferentScales) {
+  auto rowType = ROW({
+      {"a", DECIMAL(10, 2)},
+      {"b", DECIMAL(10, 1)},
+  });
+
+  auto input = makeRowVector(
+      {"a", "b"},
+      {
+          makeFlatVector<int64_t>({12345, -2500, 100}, DECIMAL(10, 2)),
+          makeFlatVector<int64_t>({10, -25, 3}, DECIMAL(10, 1)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+  createDuckDbTable(vectors);
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({"a * b AS prod"})
+                  .planNode();
+
+  auto expected = makeRowVector(
+      {"prod"},
+      {makeFlatVector<int128_t>(
+          {
+              static_cast<int128_t>(12345) * static_cast<int128_t>(10),
+              static_cast<int128_t>(-2500) * static_cast<int128_t>(-25),
+              static_cast<int128_t>(100) * static_cast<int128_t>(3),
+          },
+          DECIMAL(20, 3))});
+
+  auto result =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(CudfDecimalTest, decimalCompareDecimalDecimal) {
+  auto rowType = ROW({
+      {"a", DECIMAL(10, 2)},
+      {"b", DECIMAL(10, 2)},
+  });
+
+  auto input = makeRowVector(
+      {"a", "b"},
+      {
+          makeFlatVector<int64_t>({120, -250, 10}, DECIMAL(10, 2)),
+          makeFlatVector<int64_t>({110, -250, 30}, DECIMAL(10, 2)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({
+                      "a = b AS eq",
+                      "a != b AS neq",
+                      "a < b AS lt",
+                      "a <= b AS lte",
+                      "a > b AS gt",
+                      "a >= b AS gte",
+                  })
+                  .planNode();
+
+  auto expected = makeRowVector(
+      {"eq", "neq", "lt", "lte", "gt", "gte"},
+      {
+          makeNullableFlatVector<bool>({false, true, false}, BOOLEAN()),
+          makeNullableFlatVector<bool>({true, false, true}, BOOLEAN()),
+          makeNullableFlatVector<bool>({false, false, true}, BOOLEAN()),
+          makeNullableFlatVector<bool>({false, true, true}, BOOLEAN()),
+          makeNullableFlatVector<bool>({true, false, false}, BOOLEAN()),
+          makeNullableFlatVector<bool>({true, true, false}, BOOLEAN()),
+      });
+
+  auto result =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(CudfDecimalTest, decimalCompareWithLiteral) {
+  auto rowType = ROW({
+      {"a", DECIMAL(10, 2)},
+  });
+
+  auto input = makeRowVector(
+      {"a"},
+      {makeNullableFlatVector<int64_t>(
+          {120, 110, 130, std::nullopt}, DECIMAL(10, 2))});
+
+  std::vector<RowVectorPtr> vectors = {input};
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({
+                      "a = CAST('1.20' AS DECIMAL(10, 2)) AS eq_r",
+                      "a != CAST('1.20' AS DECIMAL(10, 2)) AS neq_r",
+                      "a < CAST('1.20' AS DECIMAL(10, 2)) AS lt_r",
+                      "a <= CAST('1.20' AS DECIMAL(10, 2)) AS lte_r",
+                      "a > CAST('1.20' AS DECIMAL(10, 2)) AS gt_r",
+                      "a >= CAST('1.20' AS DECIMAL(10, 2)) AS gte_r",
+                      "CAST('1.20' AS DECIMAL(10, 2)) = a AS eq_l",
+                      "CAST('1.20' AS DECIMAL(10, 2)) != a AS neq_l",
+                      "CAST('1.20' AS DECIMAL(10, 2)) < a AS lt_l",
+                      "CAST('1.20' AS DECIMAL(10, 2)) <= a AS lte_l",
+                      "CAST('1.20' AS DECIMAL(10, 2)) > a AS gt_l",
+                      "CAST('1.20' AS DECIMAL(10, 2)) >= a AS gte_l",
+                  })
+                  .planNode();
+
+  auto expected = makeRowVector(
+      {"eq_r",
+       "neq_r",
+       "lt_r",
+       "lte_r",
+       "gt_r",
+       "gte_r",
+       "eq_l",
+       "neq_l",
+       "lt_l",
+       "lte_l",
+       "gt_l",
+       "gte_l"},
+      {
+          makeNullableFlatVector<bool>(
+              {true, false, false, std::nullopt}, BOOLEAN()),
+          makeNullableFlatVector<bool>(
+              {false, true, true, std::nullopt}, BOOLEAN()),
+          makeNullableFlatVector<bool>(
+              {false, true, false, std::nullopt}, BOOLEAN()),
+          makeNullableFlatVector<bool>(
+              {true, true, false, std::nullopt}, BOOLEAN()),
+          makeNullableFlatVector<bool>(
+              {false, false, true, std::nullopt}, BOOLEAN()),
+          makeNullableFlatVector<bool>(
+              {true, false, true, std::nullopt}, BOOLEAN()),
+          makeNullableFlatVector<bool>(
+              {true, false, false, std::nullopt}, BOOLEAN()),
+          makeNullableFlatVector<bool>(
+              {false, true, true, std::nullopt}, BOOLEAN()),
+          makeNullableFlatVector<bool>(
+              {false, false, true, std::nullopt}, BOOLEAN()),
+          makeNullableFlatVector<bool>(
+              {true, false, true, std::nullopt}, BOOLEAN()),
+          makeNullableFlatVector<bool>(
+              {false, true, false, std::nullopt}, BOOLEAN()),
+          makeNullableFlatVector<bool>(
+              {true, true, false, std::nullopt}, BOOLEAN()),
+      });
+
+  auto result =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(CudfDecimalTest, decimalLogicalAndOrProject) {
+  auto rowType = ROW({
+      {"a", DECIMAL(10, 2)},
+      {"b", DECIMAL(10, 2)},
+  });
+
+  auto input = makeRowVector(
+      {"a", "b"},
+      {
+          makeFlatVector<int64_t>({100, 200, 300, 400, 500}, DECIMAL(10, 2)),
+          makeFlatVector<int64_t>({250, 150, 350, 100, 500}, DECIMAL(10, 2)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+  createDuckDbTable(vectors);
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({
+                      "(a > CAST('1.00' AS DECIMAL(10, 2)) "
+                      "AND b < CAST('2.00' AS DECIMAL(10, 2))) AS and2",
+                      "(a > CAST('1.00' AS DECIMAL(10, 2)) "
+                      "AND b < CAST('3.00' AS DECIMAL(10, 2)) "
+                      "AND a < CAST('4.00' AS DECIMAL(10, 2))) AS and3",
+                      "(a < CAST('1.00' AS DECIMAL(10, 2)) "
+                      "OR b > CAST('3.00' AS DECIMAL(10, 2)) "
+                      "OR a = CAST('2.00' AS DECIMAL(10, 2))) AS or3",
+                  })
+                  .planNode();
+
+  facebook::velox::exec::test::AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .assertResults(
+          "SELECT "
+          "(a > CAST('1.00' AS DECIMAL(10, 2)) "
+          " AND b < CAST('2.00' AS DECIMAL(10, 2))) AS and2, "
+          "(a > CAST('1.00' AS DECIMAL(10, 2)) "
+          " AND b < CAST('3.00' AS DECIMAL(10, 2)) "
+          " AND a < CAST('4.00' AS DECIMAL(10, 2))) AS and3, "
+          "(a < CAST('1.00' AS DECIMAL(10, 2)) "
+          " OR b > CAST('3.00' AS DECIMAL(10, 2)) "
+          " OR a = CAST('2.00' AS DECIMAL(10, 2))) AS or3 "
+          "FROM tmp");
+}
+
+TEST_F(CudfDecimalTest, decimalLogicalAndOrFilter) {
+  auto rowType = ROW({
+      {"a", DECIMAL(10, 2)},
+      {"b", DECIMAL(10, 2)},
+  });
+
+  auto input = makeRowVector(
+      {"a", "b"},
+      {
+          makeFlatVector<int64_t>({100, 200, 300, 400, 500}, DECIMAL(10, 2)),
+          makeFlatVector<int64_t>({250, 150, 350, 100, 500}, DECIMAL(10, 2)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+  createDuckDbTable(vectors);
+
+  const std::string filter =
+      "((a between CAST('1.50' AS DECIMAL(10, 2)) AND "
+      "CAST('3.50' AS DECIMAL(10, 2)) "
+      "AND b < CAST('3.00' AS DECIMAL(10, 2)) "
+      "AND a > CAST('1.00' AS DECIMAL(10, 2))) "
+      "OR a = CAST('4.00' AS DECIMAL(10, 2)) "
+      "OR a = CAST('5.00' AS DECIMAL(10, 2)))";
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .filter(filter)
+                  .project({"a", "b"})
+                  .planNode();
+
+  facebook::velox::exec::test::AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .assertResults(
+          "SELECT a, b FROM tmp WHERE "
+          "((a between CAST('1.50' AS DECIMAL(10, 2)) AND "
+          "CAST('3.50' AS DECIMAL(10, 2)) "
+          "AND b < CAST('3.00' AS DECIMAL(10, 2)) "
+          "AND a > CAST('1.00' AS DECIMAL(10, 2))) "
+          "OR a = CAST('4.00' AS DECIMAL(10, 2)) "
+          "OR a = CAST('5.00' AS DECIMAL(10, 2)))");
+}
+
+TEST_F(CudfDecimalTest, decimalBinaryNullPropagation) {
+  auto rowType = ROW({
+      {"a", DECIMAL(10, 2)},
+      {"b", DECIMAL(10, 2)},
+  });
+
+  auto input = makeRowVector(
+      {"a", "b"},
+      {
+          makeNullableFlatVector<int64_t>(
+              {100, std::nullopt, 300, std::nullopt}, DECIMAL(10, 2)),
+          makeNullableFlatVector<int64_t>(
+              {200, 200, std::nullopt, std::nullopt}, DECIMAL(10, 2)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({
+                      "a + b AS sum",
+                      "a / b AS div",
+                      "a = b AS eq",
+                  })
+                  .planNode();
+
+  auto expected = makeRowVector(
+      {"sum", "div", "eq"},
+      {
+          makeNullableFlatVector<int64_t>(
+              {300, std::nullopt, std::nullopt, std::nullopt}, DECIMAL(11, 2)),
+          makeNullableFlatVector<int64_t>(
+              {50, std::nullopt, std::nullopt, std::nullopt}, DECIMAL(12, 2)),
+          makeNullableFlatVector<bool>(
+              {false, std::nullopt, std::nullopt, std::nullopt}, BOOLEAN()),
+      });
+
+  auto result =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(CudfDecimalTest, decimalMultiplyDoubleCast) {
+  auto rowType = ROW({
+      {"d", DECIMAL(10, 2)},
+      {"x", DOUBLE()},
+  });
+
+  auto input = makeRowVector(
+      {"d", "x"},
+      {
+          makeFlatVector<int64_t>({125, -250, 50}, DECIMAL(10, 2)),
+          makeFlatVector<double>({2.0, -4.0, 0.0}),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+
+  auto expected =
+      makeRowVector({"prod"}, {makeFlatVector<double>({2.5, 10.0, 0.0})});
+
+  auto runAndAssert = [&](bool useCudf) {
+    if (!useCudf) {
+      unregisterCudf();
+    }
+    auto plan = exec::test::PlanBuilder()
+                    .values(vectors)
+                    .project({"cast(d as double) * x AS prod"})
+                    .planNode();
+    auto result =
+        facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(
+            pool());
+    facebook::velox::test::assertEqualVectors(expected, result);
+  };
+
+  runAndAssert(true);
+  runAndAssert(false);
+}
+
+TEST_F(CudfDecimalTest, decimalMultiplyDoubleCastRight) {
+  auto rowType = ROW({
+      {"d", DECIMAL(10, 2)},
+      {"x", DOUBLE()},
+  });
+
+  auto input = makeRowVector(
+      {"d", "x"},
+      {
+          makeFlatVector<int64_t>({125, -250, 50}, DECIMAL(10, 2)),
+          makeFlatVector<double>({2.0, -4.0, 0.0}),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+
+  auto expected =
+      makeRowVector({"prod"}, {makeFlatVector<double>({2.5, 10.0, 0.0})});
+
+  auto runAndAssert = [&](bool useCudf) {
+    if (!useCudf) {
+      unregisterCudf();
+    }
+    auto plan = exec::test::PlanBuilder()
+                    .values(vectors)
+                    .project({"x * cast(d as double) AS prod"})
+                    .planNode();
+    auto result =
+        facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(
+            pool());
+    facebook::velox::test::assertEqualVectors(expected, result);
+  };
+
+  runAndAssert(true);
+  runAndAssert(false);
+}
+
+TEST_F(CudfDecimalTest, decimalAstRecursiveMixedScaleAdd) {
+  auto rowType = ROW({
+      {"a", DECIMAL(10, 2)},
+      {"b", DECIMAL(10, 1)},
+      {"x", DOUBLE()},
+  });
+
+  auto input = makeRowVector(
+      {"a", "b", "x"},
+      {
+          makeFlatVector<int64_t>({12345, -2500, 100}, DECIMAL(10, 2)),
+          makeFlatVector<int64_t>({10, -25, 3}, DECIMAL(10, 1)),
+          makeFlatVector<double>({2.0, -4.0, 0.0}),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+
+  auto expected =
+      makeRowVector({"prod"}, {makeFlatVector<double>({126.45, -31.5, 1.3})});
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({"cast(a + b as double) + x AS prod"})
+                  .planNode();
+
+  auto result =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(CudfDecimalTest, decimalCastToDoubleProjection) {
+  auto rowType = ROW({
+      {"d", DECIMAL(10, 2)},
+  });
+
+  auto input = makeRowVector(
+      {"d"}, {makeFlatVector<int64_t>({125, -250, 50}, DECIMAL(10, 2))});
+
+  std::vector<RowVectorPtr> vectors = {input};
+
+  auto expected =
+      makeRowVector({"d_double"}, {makeFlatVector<double>({1.25, -2.5, 0.5})});
+
+  auto runAndAssert = [&](bool useCudf) {
+    if (!useCudf) {
+      unregisterCudf();
+    }
+    auto plan = exec::test::PlanBuilder()
+                    .values(vectors)
+                    .project({"cast(d as double) AS d_double"})
+                    .planNode();
+    auto result =
+        facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(
+            pool());
+    facebook::velox::test::assertEqualVectors(expected, result);
+  };
+
+  runAndAssert(true);
+  runAndAssert(false);
+}
+
+TEST_F(CudfDecimalTest, decimalCastToRealProjection) {
+  auto rowType = ROW({
+      {"d", DECIMAL(10, 2)},
+  });
+
+  auto input = makeRowVector(
+      {"d"}, {makeFlatVector<int64_t>({125, -250, 50}, DECIMAL(10, 2))});
+
+  std::vector<RowVectorPtr> vectors = {input};
+
+  auto expected =
+      makeRowVector({"d_real"}, {makeFlatVector<float>({1.25f, -2.5f, 0.5f})});
+
+  auto runAndAssert = [&](bool useCudf) {
+    if (!useCudf) {
+      unregisterCudf();
+    }
+    auto plan = exec::test::PlanBuilder()
+                    .values(vectors)
+                    .project({"cast(d as real) AS d_real"})
+                    .planNode();
+    auto result =
+        facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(
+            pool());
+    facebook::velox::test::assertEqualVectors(expected, result);
+  };
+
+  runAndAssert(true);
+  runAndAssert(false);
+}
+
+// Parameterized test that verifies cudf decimal binary ops match CPU results
+// across different precision/scale combinations
+struct DecimalBinaryParam {
+  std::string name;
+  std::string op;
+  TypePtr aType;
+  TypePtr bType;
+};
+
+class CudfDecimalBinaryTest
+    : public CudfDecimalTest,
+      public testing::WithParamInterface<DecimalBinaryParam> {};
+
+TEST_P(CudfDecimalBinaryTest, cpuGpuMatch) {
+  const auto& param = GetParam();
+
+  VectorPtr aVec;
+  VectorPtr bVec;
+  if (param.aType->equivalent(*DECIMAL(20, 4)) ||
+      param.aType->equivalent(*DECIMAL(20, 3))) {
+    aVec = makeFlatVector<int128_t>({12345, -2500, 100}, param.aType);
+    bVec = makeFlatVector<int128_t>({300, -25, 400}, param.bType);
+  } else {
+    aVec = makeFlatVector<int64_t>({12345, -2500, 100}, param.aType);
+    bVec = makeFlatVector<int64_t>({300, -25, 400}, param.bType);
+  }
+  auto input = makeRowVector({"a", "b"}, {aVec, bVec});
+  std::vector<RowVectorPtr> vectors = {input};
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({param.op + " AS result"})
+                  .planNode();
+
+  unregisterCudf();
+  auto cpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  registerCudf();
+
+  auto gpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  facebook::velox::test::assertEqualVectors(cpuResult, gpuResult);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    DecimalBinaryOps,
+    CudfDecimalBinaryTest,
+    testing::Values(
+        // Same scale, DECIMAL64.
+        DecimalBinaryParam{
+            "add_same_scale",
+            "a + b",
+            DECIMAL(10, 2),
+            DECIMAL(10, 2)},
+        DecimalBinaryParam{
+            "sub_same_scale",
+            "a - b",
+            DECIMAL(10, 2),
+            DECIMAL(10, 2)},
+        DecimalBinaryParam{
+            "mul_same_scale",
+            "a * b",
+            DECIMAL(10, 2),
+            DECIMAL(10, 2)},
+        DecimalBinaryParam{
+            "div_same_scale",
+            "a / b",
+            DECIMAL(10, 2),
+            DECIMAL(10, 2)},
+        DecimalBinaryParam{
+            "mod_same_scale",
+            "a % b",
+            DECIMAL(10, 2),
+            DECIMAL(10, 2)},
+        // Different scales, DECIMAL64.
+        DecimalBinaryParam{
+            "add_diff_scale",
+            "a + b",
+            DECIMAL(10, 2),
+            DECIMAL(10, 1)},
+        DecimalBinaryParam{
+            "sub_diff_scale",
+            "a - b",
+            DECIMAL(10, 2),
+            DECIMAL(10, 1)},
+        DecimalBinaryParam{
+            "mul_diff_scale",
+            "a * b",
+            DECIMAL(10, 2),
+            DECIMAL(10, 1)},
+        DecimalBinaryParam{
+            "div_diff_scale",
+            "a / b",
+            DECIMAL(10, 2),
+            DECIMAL(10, 1)},
+        DecimalBinaryParam{
+            "mod_diff_scale",
+            "a % b",
+            DECIMAL(10, 2),
+            DECIMAL(10, 1)},
+        // DECIMAL64 inputs, result overflows to DECIMAL128.
+        DecimalBinaryParam{
+            "add_64to128",
+            "a + b",
+            DECIMAL(10, 2),
+            DECIMAL(10, 3)},
+        DecimalBinaryParam{
+            "sub_64to128",
+            "a - b",
+            DECIMAL(10, 2),
+            DECIMAL(10, 3)},
+        DecimalBinaryParam{
+            "mul_64to128",
+            "a * b",
+            DECIMAL(10, 2),
+            DECIMAL(10, 3)},
+        DecimalBinaryParam{
+            "div_64to128",
+            "a / b",
+            DECIMAL(10, 2),
+            DECIMAL(10, 3)},
+        DecimalBinaryParam{
+            "mod_64to128",
+            "a % b",
+            DECIMAL(10, 2),
+            DECIMAL(10, 3)},
+        // Native DECIMAL128 inputs.
+        DecimalBinaryParam{"add_128", "a + b", DECIMAL(20, 4), DECIMAL(20, 4)},
+        DecimalBinaryParam{"sub_128", "a - b", DECIMAL(20, 4), DECIMAL(20, 4)},
+        DecimalBinaryParam{"mul_128", "a * b", DECIMAL(20, 4), DECIMAL(20, 4)},
+        DecimalBinaryParam{"div_128", "a / b", DECIMAL(20, 4), DECIMAL(20, 4)},
+        DecimalBinaryParam{"mod_128", "a % b", DECIMAL(20, 4), DECIMAL(20, 4)},
+        // DECIMAL128 with different scales.
+        DecimalBinaryParam{
+            "add_128_diff",
+            "a + b",
+            DECIMAL(20, 4),
+            DECIMAL(20, 3)},
+        DecimalBinaryParam{
+            "sub_128_diff",
+            "a - b",
+            DECIMAL(20, 4),
+            DECIMAL(20, 3)},
+        DecimalBinaryParam{
+            "mul_128_diff",
+            "a * b",
+            DECIMAL(20, 4),
+            DECIMAL(20, 3)},
+        DecimalBinaryParam{
+            "div_128_diff",
+            "a / b",
+            DECIMAL(20, 4),
+            DECIMAL(20, 3)},
+        DecimalBinaryParam{
+            "mod_128_diff",
+            "a % b",
+            DECIMAL(20, 4),
+            DECIMAL(20, 3)}),
+    [](const testing::TestParamInfo<DecimalBinaryParam>& info) {
+      return info.param.name;
+    });
+
+TEST_F(CudfDecimalTest, decimalDivideRounds) {
+  auto rowType = ROW({
+      {"a", DECIMAL(10, 2)},
+      {"b", DECIMAL(10, 2)},
+  });
+
+  auto input = makeRowVector(
+      {"a", "b"},
+      {
+          makeFlatVector<int64_t>({200, 100, -200}, DECIMAL(10, 2)),
+          makeFlatVector<int64_t>({300, 300, 300}, DECIMAL(10, 2)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({"a / b AS div"})
+                  .planNode();
+
+  auto computeDiv = [](int64_t a, int64_t b) {
+    __int128_t out = 0;
+    facebook::velox::DecimalUtil::
+        divideWithRoundUp<__int128_t, __int128_t, __int128_t>(
+            out,
+            static_cast<__int128_t>(a),
+            static_cast<__int128_t>(b),
+            false,
+            2,
+            0);
+    return static_cast<int64_t>(out);
+  };
+
+  auto expected = makeRowVector(
+      {"div"},
+      {makeFlatVector<int64_t>(
+          {computeDiv(200, 300), computeDiv(100, 300), computeDiv(-200, 300)},
+          DECIMAL(12, 2))});
+
+  auto result =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(CudfDecimalTest, decimalDivideByZero) {
+  auto rowType = ROW({
+      {"a", DECIMAL(10, 2)},
+      {"b", DECIMAL(10, 2)},
+  });
+
+  auto input = makeRowVector(
+      {"a", "b"},
+      {
+          makeFlatVector<int64_t>({100, 200, 300}, DECIMAL(10, 2)),
+          makeFlatVector<int64_t>({0, 50, 0}, DECIMAL(10, 2)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({"a / b AS div"})
+                  .planNode();
+
+  auto result =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+
+  // Expect null for rows where b = 0, and the division result otherwise.
+  // Input values are stored as fixed-point: 100 = 1.00, 200 = 2.00, etc.
+  // Row 0: 1.00 / 0 = null
+  // Row 1: 2.00 / 0.50 = 4.00 (stored as 400 in DECIMAL(12,2))
+  // Row 2: 3.00 / 0 = null
+  auto expectedType = DECIMAL(12, 2);
+  auto expected = makeRowVector({
+      makeNullableFlatVector<int64_t>(
+          {std::nullopt, 400, std::nullopt}, expectedType),
+  });
+
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(CudfDecimalTest, decimalModulo) {
+  auto input = makeRowVector(
+      {"a", "b"},
+      {
+          makeFlatVector<int64_t>({700, 100, -700, 0, 500}, DECIMAL(10, 2)),
+          makeFlatVector<int64_t>({300, 300, 300, 300, 200}, DECIMAL(10, 2)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({"a % b AS mod"})
+                  .planNode();
+
+  unregisterCudf();
+  auto cpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  registerCudf();
+
+  auto gpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+
+  facebook::velox::test::assertEqualVectors(cpuResult, gpuResult);
+}
+
+TEST_F(CudfDecimalTest, decimalModuloDifferentScales) {
+  auto input = makeRowVector(
+      {"a", "b"},
+      {
+          makeFlatVector<int64_t>({12345, -2500, 100}, DECIMAL(10, 2)),
+          makeFlatVector<int64_t>({10, -25, 3}, DECIMAL(10, 1)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({"a % b AS mod"})
+                  .planNode();
+
+  unregisterCudf();
+  auto cpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  registerCudf();
+
+  auto gpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+
+  facebook::velox::test::assertEqualVectors(cpuResult, gpuResult);
+}
+
+TEST_F(CudfDecimalTest, decimalSubtractPromotesToLong) {
+  auto input = makeRowVector(
+      {"a", "b"},
+      {
+          makeFlatVector<int64_t>(
+              {999'999'999'999'999'999LL,
+               -900'000'000'000'000'000LL,
+               123'456'789'012'345'678LL},
+              DECIMAL(18, 0)),
+          makeFlatVector<int64_t>(
+              {-999'999'999'999'999'999LL,
+               900'000'000'000'000'000LL,
+               123'456'789'012'345'678LL},
+              DECIMAL(18, 0)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({"a - b AS diff"})
+                  .planNode();
+
+  auto expected = makeRowVector(
+      {"diff"},
+      {makeFlatVector<int128_t>(
+          {static_cast<int128_t>(1'999'999'999'999'999'998LL),
+           static_cast<int128_t>(-1'800'000'000'000'000'000LL),
+           static_cast<int128_t>(0)},
+          DECIMAL(19, 0))});
+
+  unregisterCudf();
+  auto cpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  registerCudf();
+
+  auto gpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+
+  ASSERT_TRUE(cpuResult->childAt(0)->type()->isLongDecimal());
+  ASSERT_TRUE(gpuResult->childAt(0)->type()->isLongDecimal());
+  facebook::velox::test::assertEqualVectors(expected, cpuResult);
+  facebook::velox::test::assertEqualVectors(expected, gpuResult);
+}
+
+TEST_F(CudfDecimalTest, decimalDivideDifferentScales) {
+  auto input = makeRowVector(
+      {"a", "b"},
+      {
+          makeFlatVector<int64_t>({12345, -2500, 100}, DECIMAL(10, 2)),
+          makeFlatVector<int64_t>({10, -25, 3}, DECIMAL(10, 1)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({"a / b AS div"})
+                  .planNode();
+
+  unregisterCudf();
+  auto cpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  registerCudf();
+
+  auto gpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+
+  facebook::velox::test::assertEqualVectors(cpuResult, gpuResult);
+}
+
+TEST_F(CudfDecimalTest, decimalModuloNullPropagation) {
+  auto input = makeRowVector(
+      {"a", "b"},
+      {
+          makeNullableFlatVector<int64_t>(
+              {100, std::nullopt, 300, std::nullopt}, DECIMAL(10, 2)),
+          makeNullableFlatVector<int64_t>(
+              {200, 200, std::nullopt, std::nullopt}, DECIMAL(10, 2)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({
+                      "a % b AS mod",
+                      "a - b AS diff",
+                      "a * b AS prod",
+                  })
+                  .planNode();
+
+  unregisterCudf();
+  auto cpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  registerCudf();
+
+  auto gpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+
+  facebook::velox::test::assertEqualVectors(cpuResult, gpuResult);
+}
+
+TEST_F(CudfDecimalTest, decimalArithmeticWithScalarRight) {
+  auto input = makeRowVector(
+      {"a"},
+      {
+          makeFlatVector<int64_t>({500, -250, 100}, DECIMAL(10, 2)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({
+                      "a + CAST('1.00' AS DECIMAL(10, 2)) AS add_r",
+                      "a - CAST('1.00' AS DECIMAL(10, 2)) AS sub_r",
+                      "a * CAST('2.00' AS DECIMAL(10, 2)) AS mul_r",
+                      "a / CAST('2.00' AS DECIMAL(10, 2)) AS div_r",
+                      "a % CAST('3.00' AS DECIMAL(10, 2)) AS mod_r",
+                  })
+                  .planNode();
+
+  unregisterCudf();
+  auto cpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  registerCudf();
+
+  auto gpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+
+  facebook::velox::test::assertEqualVectors(cpuResult, gpuResult);
+}
+
+TEST_F(CudfDecimalTest, decimalArithmeticWithScalarLeft) {
+  auto input = makeRowVector(
+      {"a"},
+      {
+          makeFlatVector<int64_t>({500, -250, 100}, DECIMAL(10, 2)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({
+                      "CAST('10.00' AS DECIMAL(10, 2)) + a AS add_l",
+                      "CAST('10.00' AS DECIMAL(10, 2)) - a AS sub_l",
+                      "CAST('2.00' AS DECIMAL(10, 2)) * a AS mul_l",
+                      "CAST('10.00' AS DECIMAL(10, 2)) / a AS div_l",
+                      "CAST('10.00' AS DECIMAL(10, 2)) % a AS mod_l",
+                  })
+                  .planNode();
+
+  unregisterCudf();
+  auto cpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  registerCudf();
+
+  auto gpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+
+  facebook::velox::test::assertEqualVectors(cpuResult, gpuResult);
+}
+
+TEST_F(CudfDecimalTest, decimalDivideNullScalar) {
+  auto input = makeRowVector(
+      {"a"},
+      {
+          makeFlatVector<int64_t>({500, -250, 100}, DECIMAL(10, 2)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({
+                      "a / CAST(NULL AS DECIMAL(10, 2)) AS div_null_r",
+                      "CAST(NULL AS DECIMAL(10, 2)) / a AS div_null_l",
+                  })
+                  .planNode();
+
+  unregisterCudf();
+  auto cpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  registerCudf();
+
+  auto gpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+
+  facebook::velox::test::assertEqualVectors(cpuResult, gpuResult);
+}
+
+// Velox comparison functions require both arguments to have the same type
+// (Generic<T1>, Generic<T1>), so raw different-scale comparisons fail at the
+// type-resolution stage before cuDF evaluation.
+TEST_F(CudfDecimalTest, DISABLED_decimalCompareDifferentScales) {
+  auto input = makeRowVector(
+      {"a", "b"},
+      {
+          makeFlatVector<int64_t>({120, 150, 100}, DECIMAL(10, 2)),
+          makeFlatVector<int64_t>({12, 10, 20}, DECIMAL(10, 1)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({
+                      "a = b AS eq",
+                      "a != b AS neq",
+                      "a < b AS lt",
+                      "a <= b AS lte",
+                      "a > b AS gt",
+                      "a >= b AS gte",
+                  })
+                  .planNode();
+
+  // 1.20 == 1.2, 1.50 > 1.0, 1.00 < 2.0
+  auto expected = makeRowVector(
+      {"eq", "neq", "lt", "lte", "gt", "gte"},
+      {
+          makeNullableFlatVector<bool>({true, false, false}, BOOLEAN()),
+          makeNullableFlatVector<bool>({false, true, true}, BOOLEAN()),
+          makeNullableFlatVector<bool>({false, false, true}, BOOLEAN()),
+          makeNullableFlatVector<bool>({true, false, true}, BOOLEAN()),
+          makeNullableFlatVector<bool>({false, true, false}, BOOLEAN()),
+          makeNullableFlatVector<bool>({true, true, false}, BOOLEAN()),
+      });
+
+  auto result =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(CudfDecimalTest, decimalCompareDifferentScalesWithCast) {
+  auto input = makeRowVector(
+      {"a", "b"},
+      {
+          makeFlatVector<int64_t>({120, 150, 100}, DECIMAL(10, 2)),
+          makeFlatVector<int64_t>({12, 10, 20}, DECIMAL(10, 1)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {input};
+
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({
+                      "a = CAST(b AS DECIMAL(10, 2)) AS eq",
+                      "a != CAST(b AS DECIMAL(10, 2)) AS neq",
+                      "a < CAST(b AS DECIMAL(10, 2)) AS lt",
+                      "a <= CAST(b AS DECIMAL(10, 2)) AS lte",
+                      "a > CAST(b AS DECIMAL(10, 2)) AS gt",
+                      "a >= CAST(b AS DECIMAL(10, 2)) AS gte",
+                  })
+                  .planNode();
+
+  // 1.20 == 1.2, 1.50 > 1.0, 1.00 < 2.0
+  auto expected = makeRowVector(
+      {"eq", "neq", "lt", "lte", "gt", "gte"},
+      {
+          makeNullableFlatVector<bool>({true, false, false}, BOOLEAN()),
+          makeNullableFlatVector<bool>({false, true, true}, BOOLEAN()),
+          makeNullableFlatVector<bool>({false, false, true}, BOOLEAN()),
+          makeNullableFlatVector<bool>({true, false, true}, BOOLEAN()),
+          makeNullableFlatVector<bool>({false, true, false}, BOOLEAN()),
+          makeNullableFlatVector<bool>({true, true, false}, BOOLEAN()),
+      });
+
+  auto result =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(CudfDecimalTest, decimalGreatestLeastAllColumns) {
+  auto input = makeRowVector(
+      {"a", "b", "c"},
+      {
+          makeFlatVector<int64_t>({100, 500, -300}, DECIMAL(10, 2)),
+          makeFlatVector<int64_t>({400, 200, -100}, DECIMAL(10, 2)),
+          makeFlatVector<int64_t>({300, 300, -200}, DECIMAL(10, 2)),
+      });
+  std::vector<RowVectorPtr> vectors = {input};
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({"greatest(a, b, c) AS g", "least(a, b, c) AS l"})
+                  .planNode();
+
+  unregisterCudf();
+  auto cpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  registerCudf();
+  auto gpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  facebook::velox::test::assertEqualVectors(cpuResult, gpuResult);
+}
+
+TEST_F(CudfDecimalTest, decimalGreatestLeastMixed) {
+  auto input = makeRowVector(
+      {"a", "b"},
+      {
+          makeFlatVector<int64_t>({100, 500, -300}, DECIMAL(10, 2)),
+          makeFlatVector<int64_t>({400, 200, -100}, DECIMAL(10, 2)),
+      });
+  std::vector<RowVectorPtr> vectors = {input};
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project(
+                      {"greatest(a, CAST('5.00' AS DECIMAL(10, 2)), b) AS g",
+                       "least(a, CAST('0.00' AS DECIMAL(10, 2)), b) AS l"})
+                  .planNode();
+
+  unregisterCudf();
+  auto cpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  registerCudf();
+  auto gpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  facebook::velox::test::assertEqualVectors(cpuResult, gpuResult);
+}
+
+TEST_F(CudfDecimalTest, decimalGreatestLeastWithNulls) {
+  // The cuDF implementation uses NULL_MAX / NULL_MIN which skip nulls
+  // (returning null only when all inputs are null). This differs from
+  // Presto (which propagates null if any input is null), so we verify
+  // against manually constructed expected results.
+  auto input = makeRowVector(
+      {"a", "b", "c"},
+      {
+          makeNullableFlatVector<int64_t>(
+              {100, std::nullopt, std::nullopt}, DECIMAL(10, 2)),
+          makeNullableFlatVector<int64_t>(
+              {std::nullopt, 200, std::nullopt}, DECIMAL(10, 2)),
+          makeNullableFlatVector<int64_t>(
+              {300, std::nullopt, std::nullopt}, DECIMAL(10, 2)),
+      });
+  std::vector<RowVectorPtr> vectors = {input};
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({"greatest(a, b, c) AS g", "least(a, b, c) AS l"})
+                  .planNode();
+
+  auto expected = makeRowVector(
+      {"g", "l"},
+      {
+          makeNullableFlatVector<int64_t>(
+              {300, 200, std::nullopt}, DECIMAL(10, 2)),
+          makeNullableFlatVector<int64_t>(
+              {100, 200, std::nullopt}, DECIMAL(10, 2)),
+      });
+
+  auto result =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(CudfDecimalTest, decimalBetween) {
+  auto input = makeRowVector(
+      {"a"}, {makeFlatVector<int64_t>({-100, 50, 150, 300}, DECIMAL(10, 2))});
+  std::vector<RowVectorPtr> vectors = {input};
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({"a BETWEEN CAST('0.00' AS DECIMAL(10, 2)) "
+                            "AND CAST('2.00' AS DECIMAL(10, 2)) AS result"})
+                  .planNode();
+
+  unregisterCudf();
+  auto cpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  registerCudf();
+  auto gpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  facebook::velox::test::assertEqualVectors(cpuResult, gpuResult);
+}
+
+TEST_F(CudfDecimalTest, decimalCoalesceColumnWithLiteral) {
+  auto input = makeRowVector(
+      {"a"},
+      {makeNullableFlatVector<int64_t>(
+          {100, std::nullopt, 300, std::nullopt, 500}, DECIMAL(10, 2))});
+  std::vector<RowVectorPtr> vectors = {input};
+  auto plan =
+      exec::test::PlanBuilder()
+          .values(vectors)
+          .project({"coalesce(a, CAST('0.00' AS DECIMAL(10, 2))) AS result"})
+          .planNode();
+
+  unregisterCudf();
+  auto cpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  registerCudf();
+  auto gpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  facebook::velox::test::assertEqualVectors(cpuResult, gpuResult);
+}
+
+// Disabled: a non-null literal in the first position makes the entire coalesce
+// trivially constant. For simple types Velox folds this away before it reaches
+// cuDF, but the CAST wrapper needed for decimal literals prevents that folding,
+// causing the cuDF compiler to reject the expression.
+TEST_F(CudfDecimalTest, DISABLED_decimalCoalesceLiteralFirst) {
+  auto input = makeRowVector(
+      {"a"}, {makeFlatVector<int64_t>({100, 200, 300}, DECIMAL(10, 2))});
+  std::vector<RowVectorPtr> vectors = {input};
+  auto plan =
+      exec::test::PlanBuilder()
+          .values(vectors)
+          .project({"coalesce(CAST('5.00' AS DECIMAL(10, 2)), a) AS result"})
+          .planNode();
+
+  unregisterCudf();
+  auto cpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  registerCudf();
+  auto gpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  facebook::velox::test::assertEqualVectors(cpuResult, gpuResult);
+}
+
+TEST_F(CudfDecimalTest, decimalCoalesceStopsAtFirstLiteral) {
+  auto input = makeRowVector(
+      {"a", "b"},
+      {
+          makeNullableFlatVector<int64_t>(
+              {100, std::nullopt, 300, std::nullopt}, DECIMAL(10, 2)),
+          makeFlatVector<int64_t>({900, 800, 700, 600}, DECIMAL(10, 2)),
+      });
+  std::vector<RowVectorPtr> vectors = {input};
+  auto plan = exec::test::PlanBuilder()
+                  .values(vectors)
+                  .project({"coalesce(a, CAST('1.00' AS DECIMAL(10, 2)), b) "
+                            "AS result"})
+                  .planNode();
+
+  unregisterCudf();
+  auto cpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  registerCudf();
+  auto gpuResult =
+      facebook::velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  facebook::velox::test::assertEqualVectors(cpuResult, gpuResult);
+}
+
+} // namespace
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/tests/EnforceSingleRowTest.cpp b/velox/experimental/cudf/tests/EnforceSingleRowTest.cpp
new file mode 100644
index 00000000000..0bd7e8f0570
--- /dev/null
+++ b/velox/experimental/cudf/tests/EnforceSingleRowTest.cpp
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+class CudfEnforceSingleRowTest : public HiveConnectorTestBase {
+ protected:
+  void SetUp() override {
+    HiveConnectorTestBase::SetUp();
+    cudf_velox::CudfConfig::getInstance().allowCpuFallback = false;
+    cudf_velox::registerCudf();
+  }
+
+  void TearDown() override {
+    cudf_velox::unregisterCudf();
+    HiveConnectorTestBase::TearDown();
+  }
+};
+
+TEST_F(CudfEnforceSingleRowTest, singleRow) {
+  // Single row of input - should pass
+  auto singleRow =
+      makeRowVector({makeFlatVector<int32_t>(1, [](auto row) { return row; })});
+
+  createDuckDbTable({singleRow});
+
+  auto plan = PlanBuilder().values({singleRow}).enforceSingleRow().planNode();
+  assertQuery(plan, "SELECT * FROM tmp");
+}
+
+TEST_F(CudfEnforceSingleRowTest, twoSingleRowBatches) {
+  // Two rows of input in two separate single-row batches - should fail
+  // Note: The test framework may concatenate batches, so error may show total
+  // rows
+  auto singleRow =
+      makeRowVector({makeFlatVector<int32_t>(1, [](auto row) { return row; })});
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values({singleRow, singleRow})
+              .enforceSingleRow()
+              .planNode())
+          .copyResults(pool()),
+      "Expected single row of input");
+}
+
+TEST_F(CudfEnforceSingleRowTest, multipleRows) {
+  // Multiple rows of input in a single batch - should fail
+  auto multipleRows = makeRowVector(
+      {makeFlatVector<int32_t>(27, [](auto row) { return row; })});
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(
+          PlanBuilder().values({multipleRows}).enforceSingleRow().planNode())
+          .copyResults(pool()),
+      "Expected single row of input. Received 27 rows.");
+}
+
+TEST_F(CudfEnforceSingleRowTest, emptyInput) {
+  // Empty input - should pass and return a single row of nulls
+  auto singleRow =
+      makeRowVector({makeFlatVector<int32_t>(1, [](auto row) { return row; })});
+
+  auto plan = PlanBuilder()
+                  .values({singleRow})
+                  .filter("c0 = 12345")
+                  .enforceSingleRow()
+                  .planNode();
+  assertQuery(plan, "SELECT null");
+}
+
+TEST_F(CudfEnforceSingleRowTest, multipleColumns) {
+  // Test with multiple columns of different types
+  auto singleRow = makeRowVector({
+      makeFlatVector<int32_t>(1, [](auto /*row*/) { return 42; }),
+      makeFlatVector<int64_t>(1, [](auto /*row*/) { return 100L; }),
+      makeFlatVector<double>(1, [](auto /*row*/) { return 3.14; }),
+      makeFlatVector<std::string>(1, [](auto /*row*/) { return "test"; }),
+  });
+
+  createDuckDbTable({singleRow});
+
+  auto plan = PlanBuilder().values({singleRow}).enforceSingleRow().planNode();
+  assertQuery(plan, "SELECT * FROM tmp");
+}
+
+TEST_F(CudfEnforceSingleRowTest, withNulls) {
+  // Test with null values
+  auto singleRow = makeRowVector({
+      makeNullableFlatVector<int32_t>({std::nullopt}),
+      makeNullableFlatVector<std::string>({std::nullopt}),
+  });
+
+  createDuckDbTable({singleRow});
+
+  auto plan = PlanBuilder().values({singleRow}).enforceSingleRow().planNode();
+  assertQuery(plan, "SELECT * FROM tmp");
+}
+
+TEST_F(CudfEnforceSingleRowTest, largeBatch) {
+  // Large batch (more than 1 row) - should fail
+  auto largeRows = makeRowVector(
+      {makeFlatVector<int32_t>(1000, [](auto row) { return row; })});
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(
+          PlanBuilder().values({largeRows}).enforceSingleRow().planNode())
+          .copyResults(pool()),
+      "Expected single row of input. Received 1000 rows.");
+}
diff --git a/velox/experimental/cudf/tests/ExpressionEvaluatorSelectionTest.cpp b/velox/experimental/cudf/tests/ExpressionEvaluatorSelectionTest.cpp
new file mode 100644
index 00000000000..6ea83681e54
--- /dev/null
+++ b/velox/experimental/cudf/tests/ExpressionEvaluatorSelectionTest.cpp
@@ -0,0 +1,397 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/expression/AstExpression.h"
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
+#include "velox/experimental/cudf/expression/JitExpression.h"
+#include "velox/experimental/cudf/expression/SparkFunctions.h"
+#include "velox/experimental/cudf/tests/utils/ExpressionTestUtil.h"
+
+#include "velox/common/memory/Memory.h"
+#include "velox/core/QueryCtx.h"
+#include "velox/expression/ConstantExpr.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/functions/sparksql/registration/Register.h"
+#include "velox/type/Type.h"
+
+#include <gtest/gtest.h>
+
+using namespace facebook::velox;
+using namespace facebook::velox::cudf_velox;
+using namespace facebook::velox::cudf_velox::test_utils;
+
+namespace {
+
+class CudfExpressionSelectionTest : public ::testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+    facebook::velox::functions::sparksql::registerFunctions();
+    facebook::velox::functions::prestosql::registerAllScalarFunctions();
+  }
+
+  void SetUp() override {
+    pool_ = memory::memoryManager()->addLeafPool("", false);
+    queryCtx_ = core::QueryCtx::create();
+    execCtx_ = std::make_unique<core::ExecCtx>(pool_.get(), queryCtx_.get());
+    cudf_velox::registerCudf();
+    cudf_velox::registerSparkFunctions("");
+    rowType_ = ROW({
+        {"a", BIGINT()},
+        {"b", BIGINT()},
+        {"c", INTEGER()},
+        {"name", VARCHAR()},
+        {"date", TIMESTAMP()},
+        {"c", INTEGER()},
+    });
+
+    parse::registerTypeResolver();
+  }
+
+  void TearDown() override {
+    cudf_velox::unregisterFunctions();
+    cudf_velox::unregisterCudf();
+    execCtx_.reset();
+    queryCtx_.reset();
+    pool_.reset();
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_;
+  std::shared_ptr<core::QueryCtx> queryCtx_;
+  std::unique_ptr<core::ExecCtx> execCtx_;
+  RowTypePtr rowType_;
+};
+
+TEST_F(CudfExpressionSelectionTest, astRoot) {
+  auto prevAst = CudfConfig::getInstance().astExpressionEnabled;
+  auto prevJit = CudfConfig::getInstance().jitExpressionEnabled;
+  CudfConfig::getInstance().astExpressionEnabled = true;
+  CudfConfig::getInstance().jitExpressionEnabled = true;
+  auto expr = compileExecExpr("a + c", rowType_, execCtx_.get());
+  auto cudfExpr = createCudfExpression(expr, rowType_);
+  auto* ast = dynamic_cast<ASTExpression*>(cudfExpr.get());
+  auto* jit = dynamic_cast<JitExpression*>(cudfExpr.get());
+  ASSERT_TRUE(ast != nullptr || jit != nullptr);
+  CudfConfig::getInstance().astExpressionEnabled = prevAst;
+  CudfConfig::getInstance().jitExpressionEnabled = prevJit;
+}
+
+TEST_F(CudfExpressionSelectionTest, functionRoot) {
+  auto expr = compileExecExpr("lower(name)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(expr, /*deep=*/false));
+  auto cudfExpr = createCudfExpression(expr, rowType_);
+  auto* functionExpr = dynamic_cast<FunctionExpression*>(cudfExpr.get());
+  ASSERT_NE(functionExpr, nullptr);
+}
+
+TEST_F(CudfExpressionSelectionTest, astTopLevelWithFunctionPrecompute) {
+  auto prevAst = CudfConfig::getInstance().astExpressionEnabled;
+  auto prevJit = CudfConfig::getInstance().jitExpressionEnabled;
+  CudfConfig::getInstance().astExpressionEnabled = true;
+  CudfConfig::getInstance().jitExpressionEnabled = true;
+  auto expr = compileExecExpr(
+      "(year(date) > 2020) AND (length(name) < 10)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(expr, /*deep=*/false));
+  auto cudfExpr = createCudfExpression(expr, rowType_);
+  auto* ast = dynamic_cast<ASTExpression*>(cudfExpr.get());
+  auto* jit = dynamic_cast<JitExpression*>(cudfExpr.get());
+  ASSERT_TRUE(ast != nullptr || jit != nullptr);
+  CudfConfig::getInstance().astExpressionEnabled = prevAst;
+  CudfConfig::getInstance().jitExpressionEnabled = prevJit;
+}
+
+TEST_F(CudfExpressionSelectionTest, functionTopLevelWithNestedFunction) {
+  auto expr =
+      compileExecExpr("lower(substr(name, 1, 5))", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(expr, /*deep=*/false));
+  auto cudfExpr = createCudfExpression(expr, rowType_);
+
+  // Top level should be Function
+  auto* functionExpr = dynamic_cast<FunctionExpression*>(cudfExpr.get());
+  ASSERT_NE(functionExpr, nullptr);
+}
+
+// Disabled because this test segfaults in CI in compileExecExpr step which does
+// not use cudf code.
+TEST_F(CudfExpressionSelectionTest, DISABLED_functionTopLevelWithNestedAst) {
+  auto expr = compileExecExpr(
+      "hash_with_seed(42, add(a, b))",
+      rowType_,
+      execCtx_.get(),
+      {.parseIntegerAsBigint = false, .functionPrefix = ""});
+  auto cudfExpr = createCudfExpression(expr, rowType_);
+  auto* functionExpr = dynamic_cast<FunctionExpression*>(cudfExpr.get());
+  ASSERT_NE(functionExpr, nullptr);
+}
+
+// Disabled because this test segfaults in CI in compileExecExpr step which does
+// not use cudf code.
+TEST_F(
+    CudfExpressionSelectionTest,
+    DISABLED_signatureEnforcesConstantArgsSplit) {
+  // OK: delimiter and limit are constants
+  auto ok = compileExecExpr(
+      "split(name, ',', 3)",
+      rowType_,
+      execCtx_.get(),
+      {.parseIntegerAsBigint = false, .functionPrefix = ""});
+  ASSERT_TRUE(canBeEvaluatedByCudf(ok, /*deep=*/true));
+
+  // Bad: delimiter is not a constant
+  auto bad = compileExecExpr(
+      "split(name, name, 3)",
+      rowType_,
+      execCtx_.get(),
+      {.parseIntegerAsBigint = false, .functionPrefix = ""});
+  ASSERT_FALSE(canBeEvaluatedByCudf(bad, /*deep=*/true));
+}
+
+TEST_F(CudfExpressionSelectionTest, signatureAllowsColumnPatternLike) {
+  // OK: pattern is a constant
+  auto ok = compileExecExpr("like(name, '%abc%')", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(ok, /*deep=*/true));
+
+  // OK: pattern can also come from a column.
+  auto okColumn = compileExecExpr("like(name, name)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(okColumn, /*deep=*/true));
+
+  // OK: constant input still works when pattern comes from a column.
+  auto okConstantInput =
+      compileExecExpr("like('abc', name)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(okConstantInput, /*deep=*/true));
+
+  // OK: constant null input should also remain on the cuDF path.
+  auto okNullInput = compileExecExpr(
+      "like(cast(null as varchar), name)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(okNullInput, /*deep=*/true));
+
+  // OK: escape can be a constant too.
+  auto okWithEscape =
+      compileExecExpr("like(name, '%#_%', '#')", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(okWithEscape, /*deep=*/true));
+
+  // OK: pattern column + constant escape is supported.
+  auto okColumnWithEscape =
+      compileExecExpr("like(name, name, '#')", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(okColumnWithEscape, /*deep=*/true));
+
+  // OK: constant input + pattern column + constant escape is supported.
+  auto okConstantInputWithEscape =
+      compileExecExpr("like('a_c', name, '#')", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(okConstantInputWithEscape, /*deep=*/true));
+
+  // OK: constant null input + pattern column + constant escape is supported.
+  auto okNullInputWithEscape = compileExecExpr(
+      "like(cast(null as varchar), name, '#')", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(okNullInputWithEscape, /*deep=*/true));
+
+  // OK: null constants should remain on the cuDF path.
+  auto okNullPattern = compileExecExpr(
+      "like(name, cast(null as varchar))", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(okNullPattern, /*deep=*/true));
+
+  auto okNullEscape = compileExecExpr(
+      "like(name, '%#_%', cast(null as varchar))", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(okNullEscape, /*deep=*/true));
+
+  // Bad: escape is not a constant.
+  auto badEscape =
+      compileExecExpr("like(name, '%#_%', name)", rowType_, execCtx_.get());
+  ASSERT_FALSE(canBeEvaluatedByCudf(badEscape, /*deep=*/true));
+
+  // Bad: escape column is still unsupported when pattern comes from a column.
+  auto badColumnEscape =
+      compileExecExpr("like(name, name, name)", rowType_, execCtx_.get());
+  ASSERT_FALSE(canBeEvaluatedByCudf(badColumnEscape, /*deep=*/true));
+}
+
+TEST_F(CudfExpressionSelectionTest, signatureAllowsColumnArgsStartswith) {
+  // OK: pattern is a constant
+  auto ok = compileExecExpr("startswith(name, 'ab')", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(ok, /*deep=*/true));
+
+  // OK: null pattern is still a constant and should remain on the cuDF path.
+  auto okNull = compileExecExpr(
+      "startswith(name, cast(null as varchar))", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(okNull, /*deep=*/true));
+
+  // OK: pattern can also come from a column.
+  auto okColumn =
+      compileExecExpr("startswith(name, name)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(okColumn, /*deep=*/true));
+}
+
+TEST_F(CudfExpressionSelectionTest, signatureAllowsColumnArgsContains) {
+  // OK: pattern is a constant
+  auto ok = compileExecExpr("contains(name, 'ab')", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(ok, /*deep=*/true));
+
+  // OK: the input can also be a constant.
+  auto okConstantInput =
+      compileExecExpr("contains('ab', name)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(okConstantInput, /*deep=*/true));
+
+  // OK: null pattern is still a constant and should remain on the cuDF path.
+  auto okNull = compileExecExpr(
+      "contains(name, cast(null as varchar))", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(okNull, /*deep=*/true));
+
+  // OK: pattern can also come from a column.
+  auto okColumn =
+      compileExecExpr("contains(name, name)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(okColumn, /*deep=*/true));
+}
+
+TEST_F(CudfExpressionSelectionTest, signatureAllowsColumnArgsEndswith) {
+  // OK: pattern is a constant
+  auto ok = compileExecExpr("endswith(name, 'ab')", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(ok, /*deep=*/true));
+
+  // OK: the input can also be a constant.
+  auto okConstantInput =
+      compileExecExpr("endswith('ab', name)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(okConstantInput, /*deep=*/true));
+
+  // OK: null pattern is still a constant and should remain on the cuDF path.
+  auto okNull = compileExecExpr(
+      "endswith(name, cast(null as varchar))", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(okNull, /*deep=*/true));
+
+  // OK: pattern can also come from a column.
+  auto okColumn =
+      compileExecExpr("endswith(name, name)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(okColumn, /*deep=*/true));
+}
+
+TEST_F(CudfExpressionSelectionTest, signatureArityAndConstantsSubstr) {
+  // OK: 2-arg substr with constant start
+  auto ok2 = compileExecExpr("substr(name, 1)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(ok2, /*deep=*/true));
+
+  // OK: 3-arg substr with constant start and length
+  auto ok3 = compileExecExpr("substr(name, 1, 5)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(ok3, /*deep=*/true));
+
+  // Bad: start must be constant
+  auto badConst = compileExecExpr("substr(name, a)", rowType_, execCtx_.get());
+  ASSERT_FALSE(canBeEvaluatedByCudf(badConst, /*deep=*/true));
+}
+
+TEST_F(CudfExpressionSelectionTest, signatureCastsInDivide) {
+  // OK: numeric args are castable to double
+  auto ok = compileExecExpr("divide(a, b)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(ok, /*deep=*/true));
+}
+
+TEST_F(CudfExpressionSelectionTest, signatureVarargsHashWithSeed) {
+  facebook::velox::functions::sparksql::registerFunctions();
+
+  // TODO: Assert TRUE after https://github.com/rapidsai/cudf/issues/21720.
+  // Multi-column hash_with_seed cannot be evaluated by cudf because cudf's
+  // murmurhash3_x86_32 combines columns via hash_combine(h(col0, seed),
+  // h(col1, seed)), while Spark hashes iteratively: h(col1, h(col0, seed)).
+  // The cudf API only accepts a scalar seed, so per-row seeding is not
+  // possible without a custom CUDA kernel.
+  auto multiCol = compileExecExpr(
+      "hash_with_seed(42, a, b)",
+      rowType_,
+      execCtx_.get(),
+      {.parseIntegerAsBigint = false, .functionPrefix = ""});
+  ASSERT_FALSE(canBeEvaluatedByCudf(multiCol, /*deep=*/true));
+
+  // Single-column hash_with_seed is supported (no column combining needed).
+  auto singleCol = compileExecExpr(
+      "hash_with_seed(42, a)",
+      rowType_,
+      execCtx_.get(),
+      {.parseIntegerAsBigint = false, .functionPrefix = ""});
+  ASSERT_TRUE(canBeEvaluatedByCudf(singleCol, /*deep=*/true));
+
+  // Bad: first arg must be constant seed
+  try {
+    auto bad = compileExecExpr(
+        "hash_with_seed(c, b)",
+        rowType_,
+        execCtx_.get(),
+        {.parseIntegerAsBigint = false, .functionPrefix = ""});
+    // If compilation succeeds, the compiled check must fail.
+    ASSERT_FALSE(canBeEvaluatedByCudf(bad, /*deep=*/true));
+  } catch (const VeloxUserError&) {
+    // Treat compile-time validation failure as unsupported.
+    SUCCEED();
+  }
+}
+
+TEST_F(CudfExpressionSelectionTest, signatureTypeVariableCoalesce) {
+  // OK: same type BIGINT
+  auto ok1 = compileExecExpr("coalesce(a, b)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(ok1, /*deep=*/true));
+
+  // OK: VARCHAR with literal
+  auto ok2 = compileExecExpr("coalesce(name, 'x')", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(ok2, /*deep=*/true));
+}
+
+TEST_F(CudfExpressionSelectionTest, signatureTypeVariableSwitchIf) {
+  // OK: boolean + same type BIGINT
+  auto ok1 = compileExecExpr("if(true, a, b)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(ok1, /*deep=*/true));
+}
+
+TEST_F(CudfExpressionSelectionTest, DISABLED_castAndTryCast) {
+  // TODO (dm): This is required for passing of castAndTryCast test but breaks
+  // others. This is because ASTExpr agrees to support bad casts. remove after
+  // ASTExpr checks cast types
+  // CudfConfig::getInstance().astExpressionEnabled = false;
+
+  // OK: cast bigint -> double (supported by cuDF)
+  auto okCast = compileExecExpr("cast(a AS double)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(okCast, /*deep=*/true));
+
+  // OK: try_cast bigint -> double (supported by cuDF)
+  auto okTryCast =
+      compileExecExpr("try_cast(a AS double)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(okTryCast, /*deep=*/true));
+
+  // BAD: cast boolean -> date (expected unsupported by cuDF)
+  auto badCast = compileExecExpr(
+      "cast(length(name) < 10 AS date)", rowType_, execCtx_.get());
+  ASSERT_FALSE(canBeEvaluatedByCudf(badCast, /*deep=*/true));
+}
+
+TEST_F(CudfExpressionSelectionTest, constantFoldingStringAllocatesOnCompile) {
+  // Build a constant string expression that should be folded at compile time.
+  // This triggers creation of a ConstantExpr and allocates memory for the
+  // folded string using the ExecCtx pool.
+  auto typed =
+      parseAndInferTypedExpr("lower('ABCDEF')", rowType_, execCtx_.get());
+
+  std::vector<core::TypedExprPtr> exprs;
+  exprs.push_back(typed);
+
+  auto exprSet = exec::makeExprSetFromFlag(
+      std::move(exprs), execCtx_.get(), /*lazyDereference=*/false);
+
+  auto compiled = exprSet->expr(0);
+  auto* c = dynamic_cast<facebook::velox::exec::ConstantExpr*>(compiled.get());
+  ASSERT_NE(c, nullptr);
+  // Verify the constant vector was created using the provided ExecCtx pool.
+  ASSERT_EQ(c->value()->pool(), execCtx_->pool());
+}
+
+} // namespace
diff --git a/velox/experimental/cudf/tests/FilterProjectTest.cpp b/velox/experimental/cudf/tests/FilterProjectTest.cpp
index ea171de7b73..03d64422c5a 100644
--- a/velox/experimental/cudf/tests/FilterProjectTest.cpp
+++ b/velox/experimental/cudf/tests/FilterProjectTest.cpp
@@ -13,12 +13,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/experimental/cudf/CudfConfig.h"
 #include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/tests/CudfFunctionBaseTest.h"
 
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/parse/TypeResolver.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
@@ -38,6 +43,7 @@ class CudfFilterProjectTest : public OperatorTestBase {
   void SetUp() override {
     OperatorTestBase::SetUp();
     filesystems::registerLocalFileSystem();
+    cudf_velox::CudfConfig::getInstance().allowCpuFallback = false;
     cudf_velox::registerCudf();
     rng_.seed(123);
 
@@ -134,6 +140,71 @@ class CudfFilterProjectTest : public OperatorTestBase {
     runTest(plan, "SELECT c0 = 1 OR c1 = 2.0 AS result FROM tmp");
   }
 
+  void testLogicalShortCircuitWithLiterals(
+      const std::vector<RowVectorPtr>& input) {
+    // Constant false as first conjunct: LogicalFunction short-circuits to
+    // false.
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .project({"false AND (c0 = 1) AS result"})
+                    .planNode();
+    runTest(plan, "SELECT false AND (c0 = 1) AS result FROM tmp");
+
+    // Constant true as first disjunct: LogicalFunction short-circuits to true.
+    plan = PlanBuilder()
+               .values(input)
+               .project({"true OR (c0 = 1) AS result"})
+               .planNode();
+    runTest(plan, "SELECT true OR (c0 = 1) AS result FROM tmp");
+  }
+
+  void testLogicalAndOrLiteralsAndMixed(
+      const std::vector<RowVectorPtr>& input) {
+    // Literal-only (exercises LogicalFunction scalar/scalar and broadcast
+    // paths).
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .project({"true AND false AS r1", "true OR false AS r2"})
+                    .planNode();
+    runTest(plan, "SELECT true AND false AS r1, true OR false AS r2 FROM tmp");
+
+    plan = PlanBuilder()
+               .values(input)
+               .project(
+                   {"false AND true AS r1",
+                    "false OR true AS r2",
+                    "true AND true AS r3",
+                    "false OR false AS r4"})
+               .planNode();
+    runTest(
+        plan,
+        "SELECT false AND true AS r1, false OR true AS r2, true AND true AS r3, false OR false AS r4 FROM tmp");
+
+    // Literal on the left or right of a column predicate.
+    plan = PlanBuilder()
+               .values(input)
+               .project(
+                   {"(c0 = 1) AND true AS r1",
+                    "true AND (c0 = 1) AS r2",
+                    "(c0 = 1) OR false AS r3",
+                    "false OR (c0 = 1) AS r4"})
+               .planNode();
+    runTest(
+        plan,
+        "SELECT (c0 = 1) AND true AS r1, true AND (c0 = 1) AS r2, (c0 = 1) OR false AS r3, false OR (c0 = 1) AS r4 FROM tmp");
+
+    // Three-way mix: literals and columns interleaved.
+    plan = PlanBuilder()
+               .values(input)
+               .project(
+                   {"(c0 = 1) AND true AND (c1 = 2.0) AS r1",
+                    "false OR (c0 = 1) OR (c1 = 2.0) AS r2"})
+               .planNode();
+    runTest(
+        plan,
+        "SELECT (c0 = 1) AND true AND (c1 = 2.0) AS r1, false OR (c0 = 1) OR (c1 = 2.0) AS r2 FROM tmp");
+  }
+
   void testYearFunction(const std::vector<RowVectorPtr>& input) {
     // Create a plan with YEAR function
     auto plan =
@@ -190,52 +261,116 @@ class CudfFilterProjectTest : public OperatorTestBase {
     runTest(plan, "SELECT c2 LIKE '%test%' AS result FROM tmp");
   }
 
+  void testAddOperation(const std::vector<RowVectorPtr>& input) {
+    auto plan =
+        PlanBuilder().values(input).project({"c0 + c1 AS result"}).planNode();
+    runTest(plan, "SELECT c0 + c1 AS result FROM tmp");
+
+    plan =
+        PlanBuilder().values(input).project({"1.0 + c1 AS result"}).planNode();
+    runTest(plan, "SELECT 1.0 + c1 AS result FROM tmp");
+  }
+
+  void testSubtractOperation(const std::vector<RowVectorPtr>& input) {
+    auto plan =
+        PlanBuilder().values(input).project({"c0 - c1 AS result"}).planNode();
+    runTest(plan, "SELECT c0 - c1 AS result FROM tmp");
+
+    plan =
+        PlanBuilder().values(input).project({"c1 - 1.0 AS result"}).planNode();
+    runTest(plan, "SELECT c1 - 1.0 AS result FROM tmp");
+  }
+
+  void testMultiplyColumnColumn(const std::vector<RowVectorPtr>& input) {
+    auto plan =
+        PlanBuilder().values(input).project({"c0 * c1 AS result"}).planNode();
+    runTest(plan, "SELECT c0 * c1 AS result FROM tmp");
+
+    plan =
+        PlanBuilder().values(input).project({"c1 * 2.0 AS result"}).planNode();
+    runTest(plan, "SELECT c1 * 2.0 AS result FROM tmp");
+  }
+
+  void testDivideScalarVariants(const std::vector<RowVectorPtr>& input) {
+    auto plan =
+        PlanBuilder().values(input).project({"c1 / 2.0 AS result"}).planNode();
+    runTest(plan, "SELECT c1 / 2.0 AS result FROM tmp");
+
+    plan = PlanBuilder()
+               .values(input)
+               .project({"100.0 / c1 AS result"})
+               .planNode();
+    runTest(plan, "SELECT 100.0 / c1 AS result FROM tmp");
+  }
+
+  void testModuloOperation(const std::vector<RowVectorPtr>& input) {
+    auto plan =
+        PlanBuilder().values(input).project({"c0 % 10 AS result"}).planNode();
+    runTest(plan, "SELECT c0 % 10 AS result FROM tmp");
+  }
+
   void testLessThanOperation(const std::vector<RowVectorPtr>& input) {
-    // Create a plan with a less than operation
     auto plan =
         PlanBuilder().values(input).project({"c0 < c1 AS result"}).planNode();
-
-    // Run the test
     runTest(plan, "SELECT c0 < c1 AS result FROM tmp");
 
-    // compare against literals
     plan = PlanBuilder().values(input).project({"c0 < 1 AS result"}).planNode();
-
-    // Run the test
     runTest(plan, "SELECT c0 < 1 AS result FROM tmp");
+
+    plan = PlanBuilder().values(input).project({"1 < c0 AS result"}).planNode();
+    runTest(plan, "SELECT 1 < c0 AS result FROM tmp");
   }
 
   void testGreaterThanOperation(const std::vector<RowVectorPtr>& input) {
-    // Create a plan with a greater than operation
     auto plan =
         PlanBuilder().values(input).project({"c0 > c1 AS result"}).planNode();
-
-    // Run the test
     runTest(plan, "SELECT c0 > c1 AS result FROM tmp");
 
-    // compare against literals
     plan = PlanBuilder().values(input).project({"c0 > 1 AS result"}).planNode();
-
-    // Run the test
     runTest(plan, "SELECT c0 > 1 AS result FROM tmp");
+
+    plan = PlanBuilder().values(input).project({"1 > c0 AS result"}).planNode();
+    runTest(plan, "SELECT 1 > c0 AS result FROM tmp");
   }
 
   void testLessThanEqualOperation(const std::vector<RowVectorPtr>& input) {
-    // Create a plan with a less than equal operation
     auto plan =
         PlanBuilder().values(input).project({"c0 <= c1 AS result"}).planNode();
-
-    // Run the test
     runTest(plan, "SELECT c0 <= c1 AS result FROM tmp");
+
+    plan =
+        PlanBuilder().values(input).project({"c0 <= 1 AS result"}).planNode();
+    runTest(plan, "SELECT c0 <= 1 AS result FROM tmp");
+
+    plan =
+        PlanBuilder().values(input).project({"1 <= c0 AS result"}).planNode();
+    runTest(plan, "SELECT 1 <= c0 AS result FROM tmp");
   }
 
   void testGreaterThanEqualOperation(const std::vector<RowVectorPtr>& input) {
-    // Create a plan with a greater than equal operation
     auto plan =
         PlanBuilder().values(input).project({"c0 >= c1 AS result"}).planNode();
-
-    // Run the test
     runTest(plan, "SELECT c0 >= c1 AS result FROM tmp");
+
+    plan =
+        PlanBuilder().values(input).project({"c0 >= 1 AS result"}).planNode();
+    runTest(plan, "SELECT c0 >= 1 AS result FROM tmp");
+
+    plan =
+        PlanBuilder().values(input).project({"1 >= c0 AS result"}).planNode();
+    runTest(plan, "SELECT 1 >= c0 AS result FROM tmp");
+  }
+
+  void testEqualScalarLeft(const std::vector<RowVectorPtr>& input) {
+    auto plan =
+        PlanBuilder().values(input).project({"1 = c0 AS result"}).planNode();
+    runTest(plan, "SELECT 1 = c0 AS result FROM tmp");
+  }
+
+  void testNotEqualScalarLeft(const std::vector<RowVectorPtr>& input) {
+    auto plan =
+        PlanBuilder().values(input).project({"1 <> c0 AS result"}).planNode();
+    runTest(plan, "SELECT 1 <> c0 AS result FROM tmp");
   }
 
   void testNotOperation(const std::vector<RowVectorPtr>& input) {
@@ -389,6 +524,26 @@ class CudfFilterProjectTest : public OperatorTestBase {
     runTest(plan, "SELECT c2 = 'test_value' AS result FROM tmp");
   }
 
+  void testStringLowerOperation(const std::vector<RowVectorPtr>& input) {
+    // Test VARCHAR lower
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .project({"LOWER(c2) = 'test_value' AS result"})
+                    .planNode();
+
+    runTest(plan, "SELECT LOWER(c2) = 'test_value' AS result FROM tmp");
+  }
+
+  void testStringUpperOperation(const std::vector<RowVectorPtr>& input) {
+    // Test VARCHAR upper
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .project({"UPPER(c2) = 'TEST_VALUE' AS result"})
+                    .planNode();
+
+    runTest(plan, "SELECT UPPER(c2) = 'TEST_VALUE' AS result FROM tmp");
+  }
+
   void testMixedLiteralProjection(const std::vector<RowVectorPtr>& input) {
     // Test mixing standalone literals with expressions containing literals
     auto plan = PlanBuilder()
@@ -451,6 +606,62 @@ TEST_F(CudfFilterProjectTest, multiplyAndMinusOperation) {
   testMultiplyAndMinusOperation(vectors);
 }
 
+TEST_F(CudfFilterProjectTest, addOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testAddOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, subtractOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testSubtractOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, multiplyColumnColumn) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testMultiplyColumnColumn(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, divideScalarVariants) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testDivideScalarVariants(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, moduloOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testModuloOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, equalScalarLeft) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testEqualScalarLeft(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, notEqualScalarLeft) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testNotEqualScalarLeft(vectors);
+}
+
 TEST_F(CudfFilterProjectTest, stringEqualOperation) {
   vector_size_t batchSize = 1000;
   auto vectors = makeVectors(rowType_, 2, batchSize);
@@ -483,6 +694,22 @@ TEST_F(CudfFilterProjectTest, orOperation) {
   testOrOperation(vectors);
 }
 
+TEST_F(CudfFilterProjectTest, logicalShortCircuitWithLiterals) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testLogicalShortCircuitWithLiterals(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, logicalAndOrLiteralsAndMixed) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testLogicalAndOrLiteralsAndMixed(vectors);
+}
+
 TEST_F(CudfFilterProjectTest, lengthFunction) {
   vector_size_t batchSize = 1000;
   auto vectors = makeVectors(rowType_, 2, batchSize);
@@ -513,10 +740,10 @@ TEST_F(CudfFilterProjectTest, yearFunction) {
   testYearFunction(vectors);
 }
 
-TEST_F(CudfFilterProjectTest, DISABLED_caseWhenOperation) {
+// The result mismatches.
+TEST_F(CudfFilterProjectTest, caseWhenOperation) {
   vector_size_t batchSize = 1000;
   auto vectors = makeVectors(rowType_, 2, batchSize);
-  // failing because switch copies nulls too.
   createDuckDbTable(vectors);
 
   testCaseWhenOperation(vectors);
@@ -634,6 +861,83 @@ TEST_F(CudfFilterProjectTest, mixedInOperation) {
   testMixedInOperation(vectors);
 }
 
+TEST_F(CudfFilterProjectTest, round) {
+  auto data = makeRowVector({makeFlatVector<int64_t>({4123, 456789098})});
+  parse::ParseOptions options;
+  options.parseIntegerAsBigint = false;
+  auto plan = PlanBuilder()
+                  .setParseOptions(options)
+                  .values({data})
+                  .project({"round(c0, 2) as c1"})
+                  .planNode();
+  AssertQueryBuilder(plan).assertResults(data);
+  plan = PlanBuilder()
+             .setParseOptions(options)
+             .values({data})
+             .project({"round(c0) as c1"})
+             .planNode();
+  AssertQueryBuilder(plan).assertResults(data);
+
+  plan = PlanBuilder()
+             .setParseOptions(options)
+             .values({data})
+             .project({"round(c0, -3) as c1"})
+             .planNode();
+  auto expected = makeRowVector({makeFlatVector<int64_t>({4000, 456789000})});
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, roundDecimal) {
+  parse::ParseOptions options;
+  options.parseIntegerAsBigint = false;
+
+  // Note that the underlying cudf::round_decimal function returns
+  // a value with the specified scale, and rounds the internal integer
+  // value accordingly, e.g. rounding 41.2389 to 2 decimal places
+  // results in an internal integer value of 4124 with a scale of 2.
+  //
+  // When the specified scale is non-zero, Velox inserts extra casts
+  // to restore the original scale. However, when the specified scale
+  // is zero, Velox does NOT do that, and the result has a scale of 0.
+
+  // Input values 41.2389 and -45.6789 as DECIMAL(10, 4).
+  auto decimalData = makeRowVector(
+      {makeFlatVector<int64_t>({412389, -456789}, DECIMAL(10, 4))});
+
+  // Round to 2 decimal places.
+  // Expected values are 41.24 and -45.68 as DECIMAL(10, 4).
+  auto plan = PlanBuilder()
+                  .setParseOptions(options)
+                  .values({decimalData})
+                  .project({"round(c0, 2) as c1"})
+                  .planNode();
+  auto decimalExpected = makeRowVector(
+      {makeFlatVector<int64_t>({412400, -456800}, DECIMAL(10, 4))});
+  AssertQueryBuilder(plan).assertResults(decimalExpected);
+
+  // Round to 0 decimal places.
+  // Expected values are 41.0 and -46.0 as DECIMAL(10, 0).
+  plan = PlanBuilder()
+             .setParseOptions(options)
+             .values({decimalData})
+             .project({"round(c0) as c1"})
+             .planNode();
+  decimalExpected =
+      makeRowVector({makeFlatVector<int64_t>({41, -46}, DECIMAL(10, 0))});
+  AssertQueryBuilder(plan).assertResults(decimalExpected);
+
+  // Round to -1 decimal places.
+  // Expected values are 40.0 and -50.0 as DECIMAL(10, 4).
+  plan = PlanBuilder()
+             .setParseOptions(options)
+             .values({decimalData})
+             .project({"round(c0, -1) as c1"})
+             .planNode();
+  decimalExpected = makeRowVector(
+      {makeFlatVector<int64_t>({400000, -500000}, DECIMAL(10, 4))});
+  AssertQueryBuilder(plan).assertResults(decimalExpected);
+}
+
 TEST_F(CudfFilterProjectTest, simpleFilter) {
   vector_size_t batchSize = 1000;
   auto vectors = makeVectors(rowType_, 2, batchSize);
@@ -825,6 +1129,22 @@ TEST_F(CudfFilterProjectTest, stringLiteralInComparison) {
   testStringLiteralInComparison(vectors);
 }
 
+TEST_F(CudfFilterProjectTest, stringLowerOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testStringLowerOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, stringUpperOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testStringUpperOperation(vectors);
+}
+
 TEST_F(CudfFilterProjectTest, mixedLiteralProjection) {
   vector_size_t batchSize = 1000;
   auto vectors = makeVectors(rowType_, 2, batchSize);
@@ -833,7 +1153,13 @@ TEST_F(CudfFilterProjectTest, mixedLiteralProjection) {
   testMixedLiteralProjection(vectors);
 }
 
-TEST_F(CudfFilterProjectTest, dereference) {
+// This test checks for CudfExpression's ability to handle nested field
+// references. However, to test this, we need to disable CPU fallback, otherwise
+// the test could pass by using CPU, having not exercised the CudfExpression at
+// all. But this test relies on row_constructor to construct the nested fields,
+// which CudfExpression doesn't support. Disabling this until we have a better
+// test
+TEST_F(CudfFilterProjectTest, DISABLED_dereference) {
   auto rowType = ROW(
       {"c0", "c1", "c2", "c3"}, {BIGINT(), INTEGER(), SMALLINT(), DOUBLE()});
   auto vectors = makeVectors(rowType, 10, 100);
@@ -1048,4 +1374,350 @@ TEST_F(CudfFilterProjectTest, coalesceStopsAtFirstLiteral) {
   runTest(plan, "SELECT coalesce(c0, 100, c1) AS result FROM tmp");
 }
 
+TEST_F(CudfFilterProjectTest, switchExpr) {
+  auto data = makeRowVector(
+      {makeFlatVector<double>({45676567.78, 6789098767.90876, -2.34}),
+       makeFlatVector<double>({123.4, 124.5, 1678})});
+  auto plan =
+      PlanBuilder()
+          .values({data})
+          .project(
+              {"CASE WHEN c0 > 0.0 THEN c0 / c1 ELSE cast(null as double) END AS result"})
+          .planNode();
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<double>(
+          {45676567.78 / 123.4, 6789098767.90876 / 124.5, std::nullopt}),
+  });
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(CudfFilterProjectTest, greatestLeastAllColumns) {
+  auto data = makeRowVector({
+      makeFlatVector<double>({1.0, 5.0, -3.0}),
+      makeFlatVector<double>({4.0, 2.0, -1.0}),
+      makeFlatVector<double>({3.0, 3.0, -2.0}),
+  });
+  createDuckDbTable({data});
+  auto plan =
+      PlanBuilder()
+          .values({data})
+          .project({"greatest(c0, c1, c2) AS g", "least(c0, c1, c2) AS l"})
+          .planNode();
+  assertQuery(plan, "SELECT greatest(c0, c1, c2), least(c0, c1, c2) FROM tmp");
+}
+
+TEST_F(CudfFilterProjectTest, greatestLeastMixed) {
+  auto data = makeRowVector({
+      makeFlatVector<double>({1.0, 10.0, -3.0}),
+      makeFlatVector<double>({4.0, 2.0, -1.0}),
+  });
+  createDuckDbTable({data});
+  auto plan =
+      PlanBuilder()
+          .values({data})
+          .project({"greatest(c0, 5.0, c1) AS g", "least(c0, 0.0, c1) AS l"})
+          .planNode();
+  assertQuery(
+      plan, "SELECT greatest(c0, 5.0, c1), least(c0, 0.0, c1) FROM tmp");
+}
+
+TEST_F(CudfFilterProjectTest, greatestLeastAllLiterals) {
+  auto data = makeRowVector({makeFlatVector<double>({0.0})});
+  auto plan =
+      PlanBuilder()
+          .values({data})
+          .project(
+              {"greatest(1.0, 3.0, 2.0) AS g", "least(1.0, 3.0, 2.0) AS l"})
+          .planNode();
+  auto expected = makeRowVector({
+      makeFlatVector<double>({3.0}),
+      makeFlatVector<double>({1.0}),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, greatestLeastWithNulls) {
+  auto data = makeRowVector({
+      makeNullableFlatVector<double>({1.0, std::nullopt, std::nullopt}),
+      makeNullableFlatVector<double>({std::nullopt, 2.0, std::nullopt}),
+      makeNullableFlatVector<double>({3.0, std::nullopt, std::nullopt}),
+  });
+  createDuckDbTable({data});
+  auto plan =
+      PlanBuilder()
+          .values({data})
+          .project({"greatest(c0, c1, c2) AS g", "least(c0, c1, c2) AS l"})
+          .planNode();
+  assertQuery(plan, "SELECT greatest(c0, c1, c2), least(c0, c1, c2) FROM tmp");
+}
+
+TEST_F(CudfFilterProjectTest, betweenDouble) {
+  auto data = makeRowVector({
+      makeFlatVector<double>({-1.0, 0.5, 1.5, 3.0}),
+  });
+  createDuckDbTable({data});
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .project({"c0 BETWEEN 0.0 AND 2.0 AS result"})
+                  .planNode();
+  assertQuery(plan, "SELECT c0 BETWEEN 0.0 AND 2.0 AS result FROM tmp");
+}
+
+class CudfSimpleFilterProjectTest : public cudf_velox::CudfFunctionBaseTest {
+ protected:
+  static void SetUpTestCase() {
+    parse::registerTypeResolver();
+    functions::prestosql::registerAllScalarFunctions();
+    aggregate::prestosql::registerAllAggregateFunctions();
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+    cudf_velox::registerCudf();
+  }
+
+  static void TearDownTestCase() {
+    cudf_velox::unregisterCudf();
+  }
+
+  void assertExpressionMatchesCpu(
+      const std::string& expr,
+      const RowVectorPtr& input,
+      const RowTypePtr& rowType) {
+    auto exprSet = compileExpression(expr, rowType);
+    auto expected =
+        functions::test::FunctionBaseTest::evaluate(*exprSet, input);
+    auto actual = evaluate(*exprSet, input);
+    facebook::velox::test::assertEqualVectors(expected, actual);
+  }
+};
+
+TEST_F(CudfSimpleFilterProjectTest, castToSmallInt) {
+  auto castValue = evaluateOnce<int16_t, int32_t>("cast(c0 as smallint)", 12);
+  EXPECT_EQ(castValue, 12);
+  auto tryCast =
+      evaluateOnce<int16_t, int32_t>("try_cast(c0 as smallint)", -214);
+  EXPECT_EQ(tryCast, -214);
+}
+
+// Test unary math functions
+TEST_F(CudfSimpleFilterProjectTest, unaryMathFunctions) {
+  auto testUnaryFunction =
+      [&](std::string expr, double input, double expected) {
+        auto valueOpt = evaluateOnce<double, double>(expr, input);
+        EXPECT_DOUBLE_EQ(valueOpt.value(), expected);
+      };
+  // Trigonometric functions (use 0.0 where stable/clean)
+  testUnaryFunction("sin(c0)", 0.0, 0.0);
+  testUnaryFunction("cos(c0)", 0.0, 1.0);
+  testUnaryFunction("tan(c0)", 0.0, 0.0);
+
+  // Inverse trig (use stable inputs)
+  testUnaryFunction("asin(c0)", 0.0, 0.0);
+  testUnaryFunction("acos(c0)", 1.0, 0.0);
+  testUnaryFunction("atan(c0)", 0.0, 0.0);
+
+  // Hyperbolic functions
+  testUnaryFunction("cosh(c0)", 0.0, 1.0);
+  testUnaryFunction("tanh(c0)", 0.0, 0.0);
+
+  // Exponential / log / roots
+  testUnaryFunction("exp(c0)", 0.0, 1.0);
+  testUnaryFunction("ln(c0)", 1.0, 0.0);
+  testUnaryFunction("sqrt(c0)", 4.0, 2.0);
+  testUnaryFunction("cbrt(c0)", 8.0, 2.0);
+
+  // Absolute value
+  testUnaryFunction("abs(c0)", -5.5, 5.5);
+}
+
+TEST_F(CudfSimpleFilterProjectTest, nullLogicalAnd) {
+  const auto rowType = ROW({{"c0", BOOLEAN()}, {"c1", BOOLEAN()}});
+  // All 9 combinations of {true, false, null} x {true, false, null}.
+  auto c0 = makeNullableFlatVector<bool>({
+      true,
+      true,
+      true,
+      false,
+      false,
+      false,
+      std::nullopt,
+      std::nullopt,
+      std::nullopt,
+  });
+  auto c1 = makeNullableFlatVector<bool>({
+      true,
+      false,
+      std::nullopt,
+      true,
+      false,
+      std::nullopt,
+      true,
+      false,
+      std::nullopt,
+  });
+  auto input = makeRowVector({c0, c1});
+  assertExpressionMatchesCpu("c0 AND c1", input, rowType);
+}
+
+TEST_F(CudfSimpleFilterProjectTest, nullLogicalOr) {
+  const auto rowType = ROW({{"c0", BOOLEAN()}, {"c1", BOOLEAN()}});
+  auto c0 = makeNullableFlatVector<bool>({
+      true,
+      true,
+      true,
+      false,
+      false,
+      false,
+      std::nullopt,
+      std::nullopt,
+      std::nullopt,
+  });
+  auto c1 = makeNullableFlatVector<bool>({
+      true,
+      false,
+      std::nullopt,
+      true,
+      false,
+      std::nullopt,
+      true,
+      false,
+      std::nullopt,
+  });
+  auto input = makeRowVector({c0, c1});
+  assertExpressionMatchesCpu("c0 OR c1", input, rowType);
+}
+
+TEST_F(CudfSimpleFilterProjectTest, nullLogicalAndThreeArg) {
+  const auto rowType =
+      ROW({{"c0", BOOLEAN()}, {"c1", BOOLEAN()}, {"c2", BOOLEAN()}});
+  // (true AND null) AND false -> false; (null AND true) AND false -> false.
+  auto c0 = makeNullableFlatVector<bool>({true, std::nullopt, false});
+  auto c1 = makeNullableFlatVector<bool>({std::nullopt, true, true});
+  auto c2 = makeNullableFlatVector<bool>({false, false, true});
+  auto input = makeRowVector({c0, c1, c2});
+  assertExpressionMatchesCpu("c0 AND c1 AND c2", input, rowType);
+}
+
+TEST_F(CudfSimpleFilterProjectTest, nullLogicalOrThreeArg) {
+  const auto rowType =
+      ROW({{"c0", BOOLEAN()}, {"c1", BOOLEAN()}, {"c2", BOOLEAN()}});
+  // (false OR null) OR true -> true; (null OR false) OR true -> true.
+  auto c0 = makeNullableFlatVector<bool>({false, std::nullopt, std::nullopt});
+  auto c1 = makeNullableFlatVector<bool>({std::nullopt, false, false});
+  auto c2 = makeNullableFlatVector<bool>({true, true, true});
+  auto input = makeRowVector({c0, c1, c2});
+  assertExpressionMatchesCpu("c0 OR c1 OR c2", input, rowType);
+}
+
+TEST_F(CudfSimpleFilterProjectTest, logicalAndAllLiterals) {
+  const auto rowType = ROW({{"c0", BOOLEAN()}});
+  auto input = makeRowVector({makeFlatVector<bool>({true})});
+  for (const auto& expr :
+       {"true AND true",
+        "true AND false",
+        "false AND true",
+        "false AND false"}) {
+    assertExpressionMatchesCpu(expr, input, rowType);
+  }
+}
+
+TEST_F(CudfSimpleFilterProjectTest, logicalOrAllLiterals) {
+  const auto rowType = ROW({{"c0", BOOLEAN()}});
+  auto input = makeRowVector({makeFlatVector<bool>({true})});
+  for (const auto& expr :
+       {"true OR true", "true OR false", "false OR true", "false OR false"}) {
+    assertExpressionMatchesCpu(expr, input, rowType);
+  }
+}
+
+TEST_F(CudfSimpleFilterProjectTest, logicalAndColumnWithLiteral) {
+  const auto rowType = ROW({{"c0", BOOLEAN()}});
+  auto c0 =
+      makeNullableFlatVector<bool>({true, false, std::nullopt, std::nullopt});
+  auto input = makeRowVector({c0});
+  for (const auto& expr :
+       {"c0 AND true", "true AND c0", "c0 AND false", "false AND c0"}) {
+    assertExpressionMatchesCpu(expr, input, rowType);
+  }
+}
+
+TEST_F(CudfSimpleFilterProjectTest, logicalOrColumnWithLiteral) {
+  const auto rowType = ROW({{"c0", BOOLEAN()}});
+  auto c0 =
+      makeNullableFlatVector<bool>({true, false, std::nullopt, std::nullopt});
+  auto input = makeRowVector({c0});
+  for (const auto& expr :
+       {"c0 OR true", "true OR c0", "c0 OR false", "false OR c0"}) {
+    assertExpressionMatchesCpu(expr, input, rowType);
+  }
+}
+
+TEST_F(CudfSimpleFilterProjectTest, logicalAndThreeArgLiteralsMixed) {
+  const auto rowType = ROW({{"c0", BOOLEAN()}, {"c1", BOOLEAN()}});
+  auto c0 = makeNullableFlatVector<bool>({true, false, std::nullopt});
+  auto c1 = makeNullableFlatVector<bool>({false, true, true});
+  auto input = makeRowVector({c0, c1});
+  for (const auto& expr :
+       {"c0 AND true AND c1",
+        "true AND c0 AND c1",
+        "c0 AND c1 AND false",
+        "false AND c0 AND c1"}) {
+    assertExpressionMatchesCpu(expr, input, rowType);
+  }
+}
+
+TEST_F(CudfSimpleFilterProjectTest, logicalOrThreeArgLiteralsMixed) {
+  const auto rowType = ROW({{"c0", BOOLEAN()}, {"c1", BOOLEAN()}});
+  auto c0 = makeNullableFlatVector<bool>({false, true, std::nullopt});
+  auto c1 = makeNullableFlatVector<bool>({false, false, true});
+  auto input = makeRowVector({c0, c1});
+  for (const auto& expr :
+       {"c0 OR false OR c1",
+        "false OR c0 OR c1",
+        "c0 OR c1 OR true",
+        "true OR c0 OR c1"}) {
+    assertExpressionMatchesCpu(expr, input, rowType);
+  }
+}
+
+TEST_F(CudfFilterProjectTest, andAndAndExpr) {
+  auto data = makeRowVector(
+      {makeFlatVector<int64_t>({100, 100, 100, 100}, DECIMAL(17, 2)),
+       makeFlatVector<int64_t>({100, -100, 100, 100}, DECIMAL(17, 2)),
+       makeFlatVector<int64_t>({100, -100, -100, 100}, DECIMAL(17, 2)),
+       makeFlatVector<int64_t>({100, -100, -100, -100}, DECIMAL(17, 2))});
+  auto plan =
+      PlanBuilder()
+          .values({data})
+          .project(
+              {"(c0 > CAST(0.0 AS DECIMAL(17, 2))) AND (c1 > CAST(0.0 AS DECIMAL(17, 2))) AND (c2 > CAST(0.0 AS DECIMAL(17, 2))) AND (c3 > CAST(0.0 AS DECIMAL(17, 2))) AS result"})
+          .planNode();
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<bool>({true, false, false, false}),
+  });
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(CudfFilterProjectTest, andAndAndWithDecimalDivideBelowExpr) {
+  auto data = makeRowVector(
+      {makeFlatVector<int64_t>({100, 100, 100, 100}, DECIMAL(17, 2)),
+       makeFlatVector<int64_t>({100, -100, 100, 100}, DECIMAL(17, 2)),
+       makeFlatVector<int64_t>({100, -100, -100, 100}, DECIMAL(17, 2)),
+       makeFlatVector<int64_t>({100, -100, -100, -100}, DECIMAL(17, 2))});
+  auto plan =
+      PlanBuilder()
+          .values({data})
+          .project(
+              {"(CAST((c0 / CAST(3.0 AS DECIMAL(17,2))) AS DECIMAL(17, 2)) > CAST(0.0 AS DECIMAL(17, 2))) AND (c1 > CAST(0.0 AS DECIMAL(17, 2))) AND (c2 > CAST(0.0 AS DECIMAL(17, 2))) AND (c3 > CAST(0.0 AS DECIMAL(17, 2))) AS result"})
+          .planNode();
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<bool>({true, false, false, false}),
+  });
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
 } // namespace
diff --git a/velox/experimental/cudf/tests/FunctionRegistryTest.cpp b/velox/experimental/cudf/tests/FunctionRegistryTest.cpp
new file mode 100644
index 00000000000..1e1832dd408
--- /dev/null
+++ b/velox/experimental/cudf/tests/FunctionRegistryTest.cpp
@@ -0,0 +1,419 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
+
+#include "velox/expression/Expr.h"
+#include "velox/expression/FieldReference.h"
+#include "velox/expression/FunctionSignature.h"
+
+#include <gtest/gtest.h>
+
+using namespace facebook::velox;
+
+namespace facebook::velox::cudf_velox {
+
+namespace {
+
+// Stand-in for a real `CudfFunction` used to mock registrations in the tests
+// below. The tag is intended to identy the registration that was used, for
+// testing purposes.
+class TagFunction : public CudfFunction {
+ public:
+  explicit TagFunction(std::string tag) : tag_(std::move(tag)) {}
+
+  const std::string& tag() const {
+    return tag_;
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& /*inputColumns*/,
+      rmm::cuda_stream_view /*stream*/,
+      rmm::device_async_resource_ref /*mr*/) const override {
+    VELOX_UNREACHABLE("TagFunction::eval should not be called in these tests");
+  }
+
+ private:
+  std::string tag_;
+};
+
+CudfFunctionFactory tagFactory(std::string tag) {
+  return [tag](const std::string&, const std::shared_ptr<exec::Expr>&) {
+    return std::make_shared<TagFunction>(tag);
+  };
+}
+
+std::string tagOf(const std::shared_ptr<CudfFunction>& fn) {
+  auto* tagged = dynamic_cast<TagFunction*>(fn.get());
+  return tagged ? tagged->tag() : std::string{"<null>"};
+}
+
+// Necessary to mock `exec::Expr` call nodes successfully because the fake
+// function names used in these tests aren't registered with Velox's scalar
+// registry, so the usual `ExprSet` compilation path would reject them.
+std::shared_ptr<exec::Expr> makeCall(
+    const std::string& name,
+    const TypePtr& returnType,
+    const std::vector<TypePtr>& argTypes) {
+  std::vector<std::shared_ptr<exec::Expr>> inputs;
+  inputs.reserve(argTypes.size());
+  for (const auto& argType : argTypes) {
+    inputs.push_back(
+        std::make_shared<exec::Expr>(
+            argType,
+            std::vector<std::shared_ptr<exec::Expr>>{},
+            "field",
+            /*specialFormKind=*/std::nullopt,
+            /*supportsFlatNoNullsFastPath=*/false,
+            /*trackCpuUsage=*/false));
+  }
+  return std::make_shared<exec::Expr>(
+      returnType,
+      std::move(inputs),
+      name,
+      /*specialFormKind=*/std::nullopt,
+      /*supportsFlatNoNullsFastPath=*/false,
+      /*trackCpuUsage=*/false);
+}
+
+} // namespace
+
+class FunctionRegistryTest : public ::testing::Test {};
+
+// One function registration, test mock `TagFunction` testing infrastructure.
+TEST_F(FunctionRegistryTest, singleSignatureDispatch) {
+  const std::string name = "regtest_single";
+  registerCudfFunction(
+      name,
+      tagFactory("double"),
+      {exec::FunctionSignatureBuilder()
+           .returnType("double")
+           .argumentType("double")
+           .argumentType("double")
+           .build()});
+
+  auto expr = makeCall(name, DOUBLE(), {DOUBLE(), DOUBLE()});
+  auto fn = createCudfFunction(name, expr);
+  ASSERT_NE(fn, nullptr);
+  EXPECT_EQ(tagOf(fn), "double");
+}
+
+// Two function registrations, same name collision with different signatures.
+// Test that both can coexist.
+TEST_F(FunctionRegistryTest, multipleSignaturesDispatchByInputTypes) {
+  const std::string name = "regtest_multi";
+
+  registerCudfFunction(
+      name,
+      tagFactory("double"),
+      {exec::FunctionSignatureBuilder()
+           .returnType("double")
+           .argumentType("double")
+           .argumentType("double")
+           .build()});
+
+  registerCudfFunction(
+      name,
+      tagFactory("date_interval"),
+      {exec::FunctionSignatureBuilder()
+           .returnType("date")
+           .argumentType("date")
+           .argumentType("interval day to second")
+           .build()});
+
+  auto doubleExpr = makeCall(name, DOUBLE(), {DOUBLE(), DOUBLE()});
+  ASSERT_NE(createCudfFunction(name, doubleExpr), nullptr);
+  EXPECT_EQ(tagOf(createCudfFunction(name, doubleExpr)), "double");
+
+  auto dateExpr = makeCall(name, DATE(), {DATE(), INTERVAL_DAY_TIME()});
+  ASSERT_NE(createCudfFunction(name, dateExpr), nullptr);
+  EXPECT_EQ(tagOf(createCudfFunction(name, dateExpr)), "date_interval");
+}
+
+// Function registration whose types don't match any registered spec returns
+// nullptr.
+TEST_F(FunctionRegistryTest, noMatchingSignatureReturnsNull) {
+  const std::string name = "regtest_nomatch";
+
+  registerCudfFunction(
+      name,
+      tagFactory("double"),
+      {exec::FunctionSignatureBuilder()
+           .returnType("double")
+           .argumentType("double")
+           .argumentType("double")
+           .build()});
+
+  auto varcharExpr = makeCall(name, VARCHAR(), {VARCHAR(), VARCHAR()});
+  EXPECT_EQ(createCudfFunction(name, varcharExpr), nullptr);
+}
+
+// Empty signature list acts as a wildcard match (used by `cast`/`try_cast`).
+TEST_F(FunctionRegistryTest, emptySignaturesMatchAnyCall) {
+  const std::string name = "regtest_empty_sigs";
+
+  registerCudfFunction(name, tagFactory("dynamic"), {});
+
+  auto anyExpr = makeCall(name, DOUBLE(), {VARCHAR(), BIGINT()});
+  auto fn = createCudfFunction(name, anyExpr);
+  ASSERT_NE(fn, nullptr);
+  EXPECT_EQ(tagOf(fn), "dynamic");
+}
+
+// Typed function registered before empty spec: typed wins on exact match, empty
+// catches the rest.
+TEST_F(FunctionRegistryTest, emptySignaturesActAsFallback) {
+  const std::string name = "regtest_typed_and_fallback";
+
+  registerCudfFunction(
+      name,
+      tagFactory("typed"),
+      {exec::FunctionSignatureBuilder()
+           .returnType("double")
+           .argumentType("double")
+           .argumentType("double")
+           .build()});
+  registerCudfFunction(name, tagFactory("fallback"), {});
+
+  auto matchExpr = makeCall(name, DOUBLE(), {DOUBLE(), DOUBLE()});
+  EXPECT_EQ(tagOf(createCudfFunction(name, matchExpr)), "typed");
+
+  auto mismatchExpr = makeCall(name, VARCHAR(), {VARCHAR(), VARCHAR()});
+  EXPECT_EQ(tagOf(createCudfFunction(name, mismatchExpr)), "fallback");
+}
+
+// Two function registrations under the same name, second with
+// `overwrite=false`. Test that the second is rejected wholesale (even with a
+// non-overlapping signature) and the first remains the only callable one.
+TEST_F(FunctionRegistryTest, overwriteFalsePreservesFirstRegistration) {
+  const std::string name = "regtest_no_overwrite";
+
+  ASSERT_TRUE(registerCudfFunction(
+      name,
+      tagFactory("first"),
+      {exec::FunctionSignatureBuilder()
+           .returnType("double")
+           .argumentType("double")
+           .argumentType("double")
+           .build()}));
+  EXPECT_FALSE(registerCudfFunction(
+      name,
+      tagFactory("second"),
+      {exec::FunctionSignatureBuilder()
+           .returnType("date")
+           .argumentType("date")
+           .argumentType("interval day to second")
+           .build()},
+      /*overwrite=*/false));
+
+  auto expr = makeCall(name, DOUBLE(), {DOUBLE(), DOUBLE()});
+  EXPECT_EQ(tagOf(createCudfFunction(name, expr)), "first");
+
+  auto dateExpr = makeCall(name, DATE(), {DATE(), INTERVAL_DAY_TIME()});
+  EXPECT_EQ(createCudfFunction(name, dateExpr), nullptr);
+}
+
+// Two function registrations under the same name with different signatures.
+// Test that `canEvaluate` walks the spec list the same way `createCudfFunction`
+// does, returning true when any spec matches and false otherwise.
+TEST_F(FunctionRegistryTest, canEvaluateMultipleSignatures) {
+  const std::string name = "regtest_can_eval_multi";
+
+  registerCudfFunction(
+      name,
+      tagFactory("double"),
+      {exec::FunctionSignatureBuilder()
+           .returnType("double")
+           .argumentType("double")
+           .argumentType("double")
+           .build()});
+  registerCudfFunction(
+      name,
+      tagFactory("date_interval"),
+      {exec::FunctionSignatureBuilder()
+           .returnType("date")
+           .argumentType("date")
+           .argumentType("interval day to second")
+           .build()});
+
+  EXPECT_TRUE(
+      FunctionExpression::canEvaluate(
+          makeCall(name, DOUBLE(), {DOUBLE(), DOUBLE()})));
+  EXPECT_TRUE(
+      FunctionExpression::canEvaluate(
+          makeCall(name, DATE(), {DATE(), INTERVAL_DAY_TIME()})));
+  EXPECT_FALSE(
+      FunctionExpression::canEvaluate(
+          makeCall(name, VARCHAR(), {VARCHAR(), VARCHAR()})));
+}
+
+// `FieldReference` expression, no registry setup. Test that `canEvaluate`
+// returns true without consulting the function registry at all.
+TEST_F(FunctionRegistryTest, canEvaluateFieldReference) {
+  auto fieldExpr = std::make_shared<exec::FieldReference>(
+      DOUBLE(), std::vector<std::shared_ptr<exec::Expr>>{}, "c0");
+  EXPECT_TRUE(FunctionExpression::canEvaluate(fieldExpr));
+}
+
+// `cast` and `try_cast` calls with cudf-supported type pairs. Test that
+// `canEvaluate` dispatches these through `cudf::is_supported_cast` rather
+// than through the normal signature-matching path.
+TEST_F(FunctionRegistryTest, canEvaluateCastExpression) {
+  EXPECT_TRUE(
+      FunctionExpression::canEvaluate(makeCall("cast", BIGINT(), {DOUBLE()})));
+  EXPECT_TRUE(
+      FunctionExpression::canEvaluate(
+          makeCall("try_cast", BIGINT(), {DOUBLE()})));
+}
+
+// Two function registrations under the same name with identical signatures,
+// both using the default `overwrite=true`. Test that the second appends to the
+// registry rather than replacing the first, and the first still wins on
+// matching calls (first-registered wins ties). This is the behavior change
+// introduced when the registry moved from one entry per name to many.
+TEST_F(FunctionRegistryTest, overwriteTrueAppendsSpec) {
+  const std::string name = "regtest_overwrite_true";
+  auto sig = exec::FunctionSignatureBuilder()
+                 .returnType("double")
+                 .argumentType("double")
+                 .argumentType("double")
+                 .build();
+
+  ASSERT_TRUE(registerCudfFunction(name, tagFactory("first"), {sig}));
+  ASSERT_TRUE(registerCudfFunction(name, tagFactory("second"), {sig}));
+
+  auto expr = makeCall(name, DOUBLE(), {DOUBLE(), DOUBLE()});
+  EXPECT_EQ(tagOf(createCudfFunction(name, expr)), "first");
+}
+
+// One factory registered under two names via `registerCudfFunctions`. Test
+// that calls to either name dispatch to the same factory.
+TEST_F(FunctionRegistryTest, registerAliases) {
+  const std::string primary = "regtest_alias_primary";
+  const std::string alias = "regtest_alias_secondary";
+
+  registerCudfFunctions(
+      {primary, alias},
+      tagFactory("shared"),
+      {exec::FunctionSignatureBuilder()
+           .returnType("double")
+           .argumentType("double")
+           .argumentType("double")
+           .build()});
+
+  auto primaryExpr = makeCall(primary, DOUBLE(), {DOUBLE(), DOUBLE()});
+  EXPECT_EQ(tagOf(createCudfFunction(primary, primaryExpr)), "shared");
+
+  auto aliasExpr = makeCall(alias, DOUBLE(), {DOUBLE(), DOUBLE()});
+  EXPECT_EQ(tagOf(createCudfFunction(alias, aliasExpr)), "shared");
+}
+
+// Empty-signature (wildcard) registration added before a typed one under the
+// same name. Test that the wildcard matches first and shadows the typed one,
+// even on calls that the typed signature would bind exactly. Registration
+// order determines match priority.
+TEST_F(FunctionRegistryTest, emptySignatureRegisteredFirstShadowsTyped) {
+  const std::string name = "regtest_empty_first";
+
+  registerCudfFunction(name, tagFactory("fallback"), {});
+  registerCudfFunction(
+      name,
+      tagFactory("typed"),
+      {exec::FunctionSignatureBuilder()
+           .returnType("double")
+           .argumentType("double")
+           .argumentType("double")
+           .build()});
+
+  auto doubleExpr = makeCall(name, DOUBLE(), {DOUBLE(), DOUBLE()});
+  EXPECT_EQ(tagOf(createCudfFunction(name, doubleExpr)), "fallback");
+}
+
+// Call against a name that was never registered. Test that both
+// `createCudfFunction` returns `nullptr` and `canEvaluate` returns false.
+TEST_F(FunctionRegistryTest, unregisteredNameReturnsNullAndFalse) {
+  const std::string name = "regtest_never_registered";
+  auto expr = makeCall(name, DOUBLE(), {DOUBLE(), DOUBLE()});
+  EXPECT_EQ(createCudfFunction(name, expr), nullptr);
+  EXPECT_FALSE(FunctionExpression::canEvaluate(expr));
+}
+
+// `cast` call whose source/destination types `cudf::is_supported_cast`
+// rejects. Test that `canEvaluate` returns false instead of falling through
+// to the registry. Destination must be non-fixed-width to be rejected, since
+// cuDF's check only requires the destination to be fixed-width for non-fixed-
+// point casts.
+TEST_F(FunctionRegistryTest, canEvaluateCastUnsupportedTypes) {
+  auto unsupportedCast = makeCall("cast", ROW({DOUBLE()}), {INTEGER()});
+  EXPECT_FALSE(FunctionExpression::canEvaluate(unsupportedCast));
+}
+
+// Malformed `cast` call with no input arguments. Test that `canEvaluate`
+// returns false via its null-source-type guard rather than dereferencing a
+// missing input.
+TEST_F(FunctionRegistryTest, canEvaluateCastWithoutInputsReturnsFalse) {
+  auto zeroArgCast = makeCall("cast", INTEGER(), {});
+  EXPECT_FALSE(FunctionExpression::canEvaluate(zeroArgCast));
+}
+
+// `registerCudfFunctions` called with `overwrite=false` over a mix of an
+// already-registered name and a brand-new one. Test that each name is handled
+// independently: the existing one keeps its original factory, the new one
+// gets the new factory.
+TEST_F(FunctionRegistryTest, registerAliasesOverwriteFalse) {
+  const std::string alreadyThere = "regtest_alias_existing";
+  const std::string fresh = "regtest_alias_fresh";
+  auto sig = exec::FunctionSignatureBuilder()
+                 .returnType("double")
+                 .argumentType("double")
+                 .argumentType("double")
+                 .build();
+
+  registerCudfFunction(alreadyThere, tagFactory("original"), {sig});
+
+  registerCudfFunctions(
+      {alreadyThere, fresh},
+      tagFactory("new"),
+      {sig},
+      /*overwrite=*/false);
+
+  auto originalExpr = makeCall(alreadyThere, DOUBLE(), {DOUBLE(), DOUBLE()});
+  EXPECT_EQ(tagOf(createCudfFunction(alreadyThere, originalExpr)), "original");
+
+  auto freshExpr = makeCall(fresh, DOUBLE(), {DOUBLE(), DOUBLE()});
+  EXPECT_EQ(tagOf(createCudfFunction(fresh, freshExpr)), "new");
+}
+
+// Call made with fewer arguments than the registered signature expects.
+// Test that both `createCudfFunction` returns `nullptr` and `canEvaluate`
+// returns false on arity mismatch.
+TEST_F(FunctionRegistryTest, arityMismatchReturnsNull) {
+  const std::string name = "regtest_arity";
+  registerCudfFunction(
+      name,
+      tagFactory("two_args"),
+      {exec::FunctionSignatureBuilder()
+           .returnType("double")
+           .argumentType("double")
+           .argumentType("double")
+           .build()});
+
+  auto zeroArgExpr = makeCall(name, DOUBLE(), {});
+  EXPECT_EQ(createCudfFunction(name, zeroArgExpr), nullptr);
+  EXPECT_FALSE(FunctionExpression::canEvaluate(zeroArgExpr));
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/tests/GroupIdTest.cpp b/velox/experimental/cudf/tests/GroupIdTest.cpp
new file mode 100644
index 00000000000..406070638d5
--- /dev/null
+++ b/velox/experimental/cudf/tests/GroupIdTest.cpp
@@ -0,0 +1,507 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+class CudfGroupIdTest : public HiveConnectorTestBase {
+ protected:
+  void SetUp() override {
+    HiveConnectorTestBase::SetUp();
+    cudf_velox::CudfConfig::getInstance().allowCpuFallback = false;
+    cudf_velox::registerCudf();
+  }
+
+  void TearDown() override {
+    cudf_velox::unregisterCudf();
+    HiveConnectorTestBase::TearDown();
+  }
+};
+
+// Test matching core Velox: AggregationTest.groupingSets
+TEST_F(CudfGroupIdTest, groupingSets) {
+  vector_size_t size = 1'000;
+  auto data = makeRowVector(
+      {"k1", "k2", "a", "b"},
+      {
+          makeFlatVector<int64_t>(size, [](auto row) { return row % 11; }),
+          makeFlatVector<int64_t>(size, [](auto row) { return row % 17; }),
+          makeFlatVector<int64_t>(size, [](auto row) { return row; }),
+          makeFlatVector<std::string>(
+              size, [](auto row) { return std::string(row % 12, 'x'); }),
+      });
+
+  createDuckDbTable({data});
+
+  auto plan =
+      PlanBuilder()
+          .values({data})
+          .groupId({"k1", "k2"}, {{"k1"}, {"k2"}}, {"a", "b"})
+          .singleAggregation(
+              {"k1", "k2", "group_id"},
+              {"count(1) as count_1", "sum(a) as sum_a", "max(b) as max_b"})
+          .project({"k1", "k2", "count_1", "sum_a", "max_b"})
+          .planNode();
+
+  assertQuery(
+      plan,
+      "SELECT k1, k2, count(1), sum(a), max(b) FROM tmp GROUP BY GROUPING SETS ((k1), (k2))");
+
+  // Distinct aggregations.
+  plan = PlanBuilder()
+             .values({data})
+             .groupId({"k1", "k2"}, {{"k1"}, {"k2"}}, {})
+             .singleAggregation({"k1", "k2", "group_id"}, {})
+             .project({"k1", "k2"})
+             .planNode();
+
+  assertQuery(
+      plan, "SELECT k1, k2 FROM tmp GROUP BY GROUPING SETS ((k1), (k2))");
+
+  // Distinct aggregations with global grouping sets.
+  plan = PlanBuilder()
+             .values({data})
+             .groupId({"k1", "k2"}, {{"k1"}, {"k2"}, {}}, {})
+             .singleAggregation({"k1", "k2", "group_id"}, {})
+             .project({"k1", "k2"})
+             .planNode();
+
+  assertQuery(
+      plan, "SELECT k1, k2 FROM tmp GROUP BY GROUPING SETS ((k1), (k2), ())");
+
+  // Cube.
+  plan =
+      PlanBuilder()
+          .values({data})
+          .groupId({"k1", "k2"}, {{"k1", "k2"}, {"k1"}, {"k2"}, {}}, {"a", "b"})
+          .singleAggregation(
+              {"k1", "k2", "group_id"},
+              {"count(1) as count_1", "sum(a) as sum_a", "max(b) as max_b"})
+          .project({"k1", "k2", "count_1", "sum_a", "max_b"})
+          .planNode();
+
+  assertQuery(
+      plan,
+      "SELECT k1, k2, count(1), sum(a), max(b) FROM tmp GROUP BY CUBE (k1, k2)");
+
+  // Rollup.
+  plan = PlanBuilder()
+             .values({data})
+             .groupId({"k1", "k2"}, {{"k1", "k2"}, {"k1"}, {}}, {"a", "b"})
+             .singleAggregation(
+                 {"k1", "k2", "group_id"},
+                 {"count(1) as count_1", "sum(a) as sum_a", "max(b) as max_b"})
+             .project({"k1", "k2", "count_1", "sum_a", "max_b"})
+             .planNode();
+
+  assertQuery(
+      plan,
+      "SELECT k1, k2, count(1), sum(a), max(b) FROM tmp GROUP BY ROLLUP (k1, k2)");
+}
+
+// Test matching core Velox: AggregationTest.groupingSetsOutput
+TEST_F(CudfGroupIdTest, groupingSetsOutput) {
+  vector_size_t size = 1'000;
+  auto data = makeRowVector(
+      {"k1", "k2", "a", "b"},
+      {
+          makeFlatVector<int64_t>(size, [](auto row) { return row % 11; }),
+          makeFlatVector<int64_t>(size, [](auto row) { return row % 17; }),
+          makeFlatVector<int64_t>(size, [](auto row) { return row; }),
+          makeFlatVector<std::string>(
+              size, [](auto row) { return std::string(row % 12, 'x'); }),
+      });
+
+  createDuckDbTable({data});
+
+  core::PlanNodePtr reversedOrderGroupIdNode;
+  core::PlanNodePtr orderGroupIdNode;
+  auto reversedOrderPlan =
+      PlanBuilder()
+          .values({data})
+          .groupId({"k2", "k1"}, {{"k2", "k1"}, {}}, {"a", "b"})
+          .capturePlanNode(reversedOrderGroupIdNode)
+          .singleAggregation(
+              {"k2", "k1", "group_id"},
+              {"count(1) as count_1", "sum(a) as sum_a", "max(b) as max_b"})
+          .project({"k1", "k2", "count_1", "sum_a", "max_b"})
+          .planNode();
+
+  auto orderPlan =
+      PlanBuilder()
+          .values({data})
+          .groupId({"k1", "k2"}, {{"k1", "k2"}, {}}, {"a", "b"})
+          .capturePlanNode(orderGroupIdNode)
+          .singleAggregation(
+              {"k1", "k2", "group_id"},
+              {"count(1) as count_1", "sum(a) as sum_a", "max(b) as max_b"})
+          .project({"k1", "k2", "count_1", "sum_a", "max_b"})
+          .planNode();
+
+  auto reversedOrderExpectedRowType =
+      ROW({"k2", "k1", "a", "b", "group_id"},
+          {BIGINT(), BIGINT(), BIGINT(), VARCHAR(), BIGINT()});
+  auto orderExpectedRowType =
+      ROW({"k1", "k2", "a", "b", "group_id"},
+          {BIGINT(), BIGINT(), BIGINT(), VARCHAR(), BIGINT()});
+  ASSERT_EQ(
+      *reversedOrderGroupIdNode->outputType(), *reversedOrderExpectedRowType);
+  ASSERT_EQ(*orderGroupIdNode->outputType(), *orderExpectedRowType);
+
+  CursorParameters orderParams;
+  orderParams.planNode = orderPlan;
+  auto orderResult = readCursor(orderParams);
+
+  CursorParameters reversedOrderParams;
+  reversedOrderParams.planNode = reversedOrderPlan;
+  auto reversedOrderResult = readCursor(reversedOrderParams);
+
+  assertEqualResults(orderResult.second, reversedOrderResult.second);
+}
+
+// Test matching core Velox: AggregationTest.groupingSetsSameKey
+TEST_F(CudfGroupIdTest, groupingSetsSameKey) {
+  auto data = makeRowVector(
+      {"o_key", "o_status"},
+      {makeFlatVector<int64_t>({0, 1, 2, 3, 4}),
+       makeFlatVector<std::string>({"", "x", "xx", "xxx", "xxxx"})});
+
+  createDuckDbTable({data});
+
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .groupId(
+                      {"o_key", "o_key as o_key_1"},
+                      {{"o_key", "o_key_1"}, {"o_key"}, {"o_key_1"}, {}},
+                      {"o_status"})
+                  .singleAggregation(
+                      {"o_key", "o_key_1", "group_id"},
+                      {"max(o_status) as max_o_status"})
+                  .project({"o_key", "o_key_1", "max_o_status"})
+                  .planNode();
+
+  assertQuery(
+      plan,
+      "SELECT o_key, o_key_1, max(o_status) as max_o_status FROM ("
+      "select o_key, o_key as o_key_1, o_status FROM tmp) GROUP BY GROUPING SETS ((o_key, o_key_1), (o_key), (o_key_1), ())");
+}
+
+// Test matching core Velox: AggregationTest.groupingSetsEmptyInput
+// Note: This test uses truly empty input (empty vectors) rather than filtered
+// input, as global grouping set behavior with empty filtered input depends on
+// aggregation operator behavior which may differ between CPU and GPU.
+TEST_F(CudfGroupIdTest, groupingSetsEmptyInput) {
+  auto data = makeRowVector(
+      {"k1", "k2", "a"},
+      {
+          makeFlatVector<int64_t>({}),
+          makeFlatVector<int64_t>({}),
+          makeFlatVector<int64_t>({}),
+      });
+
+  createDuckDbTable({data});
+
+  auto plan =
+      PlanBuilder()
+          .values({data})
+          .groupId({"k1", "k2"}, {{"k1"}, {"k2"}}, {"a"})
+          .singleAggregation({"k1", "k2", "group_id"}, {"sum(a) as sum_a"})
+          .project({"k1", "k2", "sum_a"})
+          .planNode();
+
+  assertQuery(
+      plan,
+      "SELECT k1, k2, sum(a) FROM tmp GROUP BY GROUPING SETS ((k1), (k2))");
+}
+
+// Test: Verify NULL values in non-grouping columns and nulls within grouping
+// key input columns are preserved correctly.
+TEST_F(CudfGroupIdTest, nullHandling) {
+  // Input has nulls in grouping key columns: c0 has null at row 1,
+  // c1 has null at row 0.
+  auto input = makeRowVector({
+      makeNullableFlatVector<int32_t>({1, std::nullopt}),
+      makeNullableFlatVector<int32_t>({std::nullopt, 20}),
+      makeFlatVector<int64_t>({100, 200}),
+  });
+
+  // GROUPING SETS ((c0), (c1))
+  // For grouping set (c0): c1 should be NULL (synthesized), c0 preserves input
+  // nulls For grouping set (c1): c0 should be NULL (synthesized), c1 preserves
+  // input nulls
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .groupId({"c0", "c1"}, {{"c0"}, {"c1"}}, {"c2"})
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+
+  // Should have 4 rows (2 rows * 2 grouping sets)
+  ASSERT_EQ(4, result->size());
+
+  auto c0 = result->childAt(0)->asFlatVector<int32_t>();
+  auto c1 = result->childAt(1)->asFlatVector<int32_t>();
+  auto groupId = result->childAt(3)->asFlatVector<int64_t>();
+
+  // First grouping set (c0): c1 is NULL (synthesized)
+  // c0 preserves input values: row 0 has value 1, row 1 has null (from input)
+  EXPECT_EQ(0, groupId->valueAt(0));
+  EXPECT_EQ(0, groupId->valueAt(1));
+  EXPECT_FALSE(c0->isNullAt(0));
+  EXPECT_EQ(1, c0->valueAt(0));
+  EXPECT_TRUE(c0->isNullAt(1)); // Input null preserved
+  EXPECT_TRUE(c1->isNullAt(0)); // Synthesized null
+  EXPECT_TRUE(c1->isNullAt(1)); // Synthesized null
+
+  // Second grouping set (c1): c0 is NULL (synthesized)
+  // c1 preserves input values: row 0 has null (from input), row 1 has value 20
+  EXPECT_EQ(1, groupId->valueAt(2));
+  EXPECT_EQ(1, groupId->valueAt(3));
+  EXPECT_TRUE(c0->isNullAt(2)); // Synthesized null
+  EXPECT_TRUE(c0->isNullAt(3)); // Synthesized null
+  EXPECT_TRUE(c1->isNullAt(2)); // Input null preserved
+  EXPECT_FALSE(c1->isNullAt(3));
+  EXPECT_EQ(20, c1->valueAt(3));
+}
+
+// Test: Multiple batches
+TEST_F(CudfGroupIdTest, multipleBatches) {
+  auto batch1 = makeRowVector(
+      {"k1", "k2", "a"},
+      {
+          makeFlatVector<int64_t>({1, 2}),
+          makeFlatVector<int64_t>({10, 20}),
+          makeFlatVector<int64_t>({100, 200}),
+      });
+  auto batch2 = makeRowVector(
+      {"k1", "k2", "a"},
+      {
+          makeFlatVector<int64_t>({3, 4}),
+          makeFlatVector<int64_t>({30, 40}),
+          makeFlatVector<int64_t>({300, 400}),
+      });
+
+  createDuckDbTable({batch1, batch2});
+
+  auto plan =
+      PlanBuilder()
+          .values({batch1, batch2})
+          .groupId({"k1", "k2"}, {{"k1"}, {"k2"}}, {"a"})
+          .singleAggregation({"k1", "k2", "group_id"}, {"sum(a) as sum_a"})
+          .project({"k1", "k2", "sum_a"})
+          .planNode();
+
+  assertQuery(
+      plan,
+      "SELECT k1, k2, sum(a) FROM tmp GROUP BY GROUPING SETS ((k1), (k2))");
+}
+
+// Test: String type in grouping keys
+TEST_F(CudfGroupIdTest, stringKeys) {
+  auto input = makeRowVector(
+      {"k1", "k2", "a"},
+      {
+          makeFlatVector<std::string>({"a", "b", "a", "b"}),
+          makeFlatVector<int64_t>({1, 1, 2, 2}),
+          makeFlatVector<int64_t>({10, 20, 30, 40}),
+      });
+
+  createDuckDbTable({input});
+
+  auto plan =
+      PlanBuilder()
+          .values({input})
+          .groupId({"k1", "k2"}, {{"k1"}, {"k2"}}, {"a"})
+          .singleAggregation({"k1", "k2", "group_id"}, {"sum(a) as sum_a"})
+          .project({"k1", "k2", "sum_a"})
+          .planNode();
+
+  assertQuery(
+      plan,
+      "SELECT k1, k2, sum(a) FROM tmp GROUP BY GROUPING SETS ((k1), (k2))");
+}
+
+// Test: Global grouping set (empty grouping set)
+TEST_F(CudfGroupIdTest, globalGroupingSet) {
+  auto input = makeRowVector(
+      {"k1", "a"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3}),
+          makeFlatVector<int64_t>({10, 20, 30}),
+      });
+
+  createDuckDbTable({input});
+
+  // GROUPING SETS ((k1), ())
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .groupId({"k1"}, {{"k1"}, {}}, {"a"})
+                  .singleAggregation({"k1", "group_id"}, {"sum(a) as sum_a"})
+                  .project({"k1", "sum_a"})
+                  .planNode();
+
+  assertQuery(
+      plan, "SELECT k1, sum(a) FROM tmp GROUP BY GROUPING SETS ((k1), ())");
+}
+
+// Test: Column reuse across multiple grouping sets (exercises copy vs move
+// logic) When a column appears in multiple grouping sets, it must be copied for
+// earlier sets and can only be moved on the last use.
+TEST_F(CudfGroupIdTest, columnReuseAcrossGroupingSets) {
+  auto input = makeRowVector(
+      {"k1", "a"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3, 4}),
+          makeFlatVector<int64_t>({10, 20, 30, 40}),
+      });
+
+  createDuckDbTable({input});
+
+  // k1 appears in both grouping sets, so it must be copied for the first set
+  // and moved for the second set. The aggregation input 'a' also appears in
+  // both outputs, requiring similar copy/move handling.
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .groupId({"k1"}, {{"k1"}, {"k1"}}, {"a"})
+                  .singleAggregation({"k1", "group_id"}, {"sum(a) as sum_a"})
+                  .project({"k1", "sum_a"})
+                  .planNode();
+
+  // Both grouping sets include k1, so we get the same grouping twice
+  // with different group_id values (0 and 1)
+  assertQuery(
+      plan,
+      "SELECT k1, sum(a) FROM tmp GROUP BY k1 "
+      "UNION ALL "
+      "SELECT k1, sum(a) FROM tmp GROUP BY k1");
+}
+
+// Test: Same input column mapped to multiple output columns within a grouping
+// set. This exercises the case where a single input column (o_key) is aliased
+// to multiple output columns (o_key and o_key_1), and both appear in the same
+// grouping set. The column must be copied, not moved, even within a single
+// getOutput() call.
+TEST_F(CudfGroupIdTest, sameInputMultipleOutputsInGroupingSet) {
+  auto input = makeRowVector(
+      {"k1", "a"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3}),
+          makeFlatVector<int64_t>({10, 20, 30}),
+      });
+
+  createDuckDbTable({input});
+
+  // k1 is aliased to both k1 and k1_copy in the output.
+  // In grouping set 0, both k1 and k1_copy are included, meaning the same
+  // input column must be used twice in the same output row.
+  auto plan =
+      PlanBuilder()
+          .values({input})
+          .groupId(
+              {"k1", "k1 as k1_copy"},
+              {{"k1", "k1_copy"}, {"k1"}, {"k1_copy"}},
+              {"a"})
+          .singleAggregation({"k1", "k1_copy", "group_id"}, {"sum(a) as sum_a"})
+          .project({"k1", "k1_copy", "sum_a"})
+          .planNode();
+
+  assertQuery(
+      plan,
+      "SELECT k1, k1_copy, sum(a) FROM ("
+      "  SELECT k1, k1 as k1_copy, a FROM tmp"
+      ") GROUP BY GROUPING SETS ((k1, k1_copy), (k1), (k1_copy))");
+
+  // Verify the case where the duplicate-input grouping set is the LAST one.
+  // This exercises the move path in doGetOutput: the same input column must be
+  // copied (not moved) for the first output position and moved for the second.
+  plan =
+      PlanBuilder()
+          .values({input})
+          .groupId({"k1", "k1 as k1_copy"}, {{"k1"}, {"k1", "k1_copy"}}, {"a"})
+          .singleAggregation({"k1", "k1_copy", "group_id"}, {"sum(a) as sum_a"})
+          .project({"k1", "k1_copy", "sum_a"})
+          .planNode();
+
+  assertQuery(
+      plan,
+      "SELECT k1, k1_copy, sum(a) FROM ("
+      "  SELECT k1, k1 as k1_copy, a FROM tmp"
+      ") GROUP BY GROUPING SETS ((k1), (k1, k1_copy))");
+}
+
+// Test: Same input column used as both grouping key and aggregation input.
+// This exercises the case where inputColumnUsageCount > 1 because the same
+// input column appears in both groupingKeyMappings and aggregationInputs.
+// Note: We use an alias (k1 as k1_key) to avoid duplicate column names in the
+// output schema, which would cause the aggregation to reference the wrong
+// column.
+TEST_F(CudfGroupIdTest, columnUsedAsKeyAndAggregationInput) {
+  auto input = makeRowVector(
+      {"k1", "k2"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3, 1, 2}),
+          makeFlatVector<int64_t>({10, 20, 30, 40, 50}),
+      });
+
+  createDuckDbTable({input});
+
+  // k1 is used as both a grouping key (aliased to k1_key) AND an aggregation
+  // input (k1). This means the input column k1 has usage count > 1 and must be
+  // copied, not moved, for the first use and moved only on the final use.
+  auto plan =
+      PlanBuilder()
+          .values({input})
+          .groupId({"k1 as k1_key"}, {{"k1_key"}, {"k1_key"}}, {"k1", "k2"})
+          .singleAggregation(
+              {"k1_key", "group_id"},
+              {"sum(k1) as sum_k1", "sum(k2) as sum_k2"})
+          .project({"k1_key", "sum_k1", "sum_k2"})
+          .planNode();
+
+  assertQuery(
+      plan,
+      "SELECT k1, sum(k1) as sum_k1, sum(k2) as sum_k2 FROM tmp GROUP BY k1 "
+      "UNION ALL "
+      "SELECT k1, sum(k1) as sum_k1, sum(k2) as sum_k2 FROM tmp GROUP BY k1");
+
+  // Test with multiple grouping sets where k1 is used as key and agg input.
+  // For the global grouping set ({}), k1_key is NULL but k1 (agg input) retains
+  // original values.
+  plan = PlanBuilder()
+             .values({input})
+             .groupId({"k1 as k1_key"}, {{"k1_key"}, {}}, {"k1", "k2"})
+             .singleAggregation(
+                 {"k1_key", "group_id"},
+                 {"sum(k1) as sum_k1", "sum(k2) as sum_k2"})
+             .project({"k1_key", "sum_k1", "sum_k2"})
+             .planNode();
+
+  assertQuery(
+      plan,
+      "SELECT k1_key, sum(k1) as sum_k1, sum(k2) as sum_k2 FROM ("
+      "  SELECT k1 as k1_key, k1, k2 FROM tmp"
+      ") GROUP BY GROUPING SETS ((k1_key), ())");
+}
diff --git a/velox/experimental/cudf/tests/HashJoinTest.cpp b/velox/experimental/cudf/tests/HashJoinTest.cpp
index 15bf0b15a8f..3226c7befe9 100644
--- a/velox/experimental/cudf/tests/HashJoinTest.cpp
+++ b/velox/experimental/cudf/tests/HashJoinTest.cpp
@@ -14,10 +14,12 @@
  * limitations under the License.
  */
 
+#include "velox/experimental/cudf/CudfConfig.h"
 #include "velox/experimental/cudf/exec/ToCudf.h"
 
-#include "folly/experimental/EventCount.h"
+#include "folly/synchronization/EventCount.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/exec/Cursor.h"
@@ -30,8 +32,8 @@
 #include "velox/exec/tests/utils/HashJoinTestBase.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/exec/tests/utils/VectorTestUtil.h"
+#include "velox/vector/VectorPrinter.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
 #include <fmt/format.h>
@@ -54,6 +56,7 @@ class HashJoinTest : public HashJoinTestBase {
 
   void SetUp() override {
     HashJoinTestBase::SetUp();
+    cudf_velox::CudfConfig::getInstance().allowCpuFallback = false;
     cudf_velox::registerCudf();
   }
 
@@ -120,7 +123,7 @@ TEST_P(MultiThreadedHashJoinTest, joinWithCancellation) {
 }
 
 TEST_P(MultiThreadedHashJoinTest, testJoinWithSpillenabledCancellation) {
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
       .keyTypes({BIGINT()})
@@ -311,7 +314,7 @@ TEST_P(MultiThreadedHashJoinTest, filter) {
 }
 
 DEBUG_ONLY_TEST_P(MultiThreadedHashJoinTest, filterSpillOnFirstProbeInput) {
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
   std::atomic_bool injectProbeSpillOnce{true};
   SCOPED_TESTVALUE_SET(
       "facebook::velox::exec::Driver::runInternal::getOutput",
@@ -421,6 +424,7 @@ TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithLargeOutput) {
       });
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
       .numDrivers(numDrivers_)
       .probeKeys({"t0"})
       .probeVectors(std::move(probeVectors))
@@ -727,6 +731,7 @@ TEST_P(MultiThreadedHashJoinTest, leftSemiJoinFilterWithExtraFilter) {
 
 TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilter) {
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
       .numDrivers(numDrivers_)
       .probeType(probeType_)
       .probeVectors(133, 3)
@@ -826,6 +831,7 @@ TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithAllMatches) {
       });
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
       .numDrivers(numDrivers_)
       .probeKeys({"t0"})
       .probeVectors(std::move(probeVectors))
@@ -861,6 +867,7 @@ TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithExtraFilter) {
     auto testProbeVectors = probeVectors;
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .injectSpill(false)
         .numDrivers(numDrivers_)
         .probeKeys({"t0"})
         .probeVectors(std::move(testProbeVectors))
@@ -871,10 +878,6 @@ TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithExtraFilter) {
         .joinOutputLayout({"u0", "u1"})
         .referenceQuery(
             "SELECT u.* FROM u WHERE EXISTS (SELECT t0 FROM t WHERE u0 = t0 AND t1 > -1)")
-        .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-          ASSERT_EQ(
-              getOutputPositions(task, "HashProbe"), 200 * 5 * numDrivers_);
-        })
         .run();
   }
 
@@ -883,6 +886,7 @@ TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithExtraFilter) {
     auto testProbeVectors = probeVectors;
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .injectSpill(false)
         .numDrivers(numDrivers_)
         .probeKeys({"t0"})
         .probeVectors(std::move(testProbeVectors))
@@ -893,9 +897,6 @@ TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithExtraFilter) {
         .joinOutputLayout({"u0", "u1"})
         .referenceQuery(
             "SELECT u.* FROM u WHERE EXISTS (SELECT t0 FROM t WHERE u0 = t0 AND t1 > 100000)")
-        .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-          ASSERT_EQ(getOutputPositions(task, "HashProbe"), 0);
-        })
         .run();
   }
 
@@ -904,6 +905,7 @@ TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithExtraFilter) {
     auto testProbeVectors = probeVectors;
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .injectSpill(false)
         .numDrivers(numDrivers_)
         .probeKeys({"t0"})
         .probeVectors(std::move(testProbeVectors))
@@ -914,15 +916,11 @@ TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithExtraFilter) {
         .joinOutputLayout({"u0", "u1"})
         .referenceQuery(
             "SELECT u.* FROM u WHERE EXISTS (SELECT t0 FROM t WHERE u0 = t0 AND t1 % 5 = 0)")
-        .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
-          ASSERT_EQ(
-              getOutputPositions(task, "HashProbe"), 200 / 5 * 5 * numDrivers_);
-        })
         .run();
   }
 }
 
-TEST_P(MultiThreadedHashJoinTest, semiFilterOverLazyVectors) {
+TEST_P(MultiThreadedHashJoinTest, DISABLED_semiFilterOverLazyVectors) {
   auto probeVectors = makeBatches(1, [&](auto /*unused*/) {
     return makeRowVector(
         {"t0", "t1"},
@@ -970,23 +968,22 @@ TEST_P(MultiThreadedHashJoinTest, semiFilterOverLazyVectors) {
                       core::JoinType::kLeftSemiFilter)
                   .planNode();
 
-  SplitInput splitInput = {
-      {probeScanId,
-       {exec::Split(makeHiveConnectorSplit(probeFile->getPath()))}},
-      {buildScanId,
-       {exec::Split(makeHiveConnectorSplit(buildFile->getPath()))}},
+  SplitPath splitPaths = {
+      {probeScanId, {probeFile->getPath()}},
+      {buildScanId, {buildFile->getPath()}},
   };
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .planNode(plan)
-      .inputSplits(splitInput)
+      .inputSplits(splitPaths)
       .checkSpillStats(false)
       .referenceQuery("SELECT t0, t1 FROM t WHERE t0 IN (SELECT u0 FROM u)")
       .run();
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
       .planNode(flipJoinSides(plan))
-      .inputSplits(splitInput)
+      .inputSplits(splitPaths)
       .checkSpillStats(false)
       .referenceQuery("SELECT t0, t1 FROM t WHERE t0 IN (SELECT u0 FROM u)")
       .run();
@@ -1010,22 +1007,23 @@ TEST_P(MultiThreadedHashJoinTest, semiFilterOverLazyVectors) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .planNode(plan)
-      .inputSplits(splitInput)
+      .inputSplits(splitPaths)
       .checkSpillStats(false)
       .referenceQuery(
           "SELECT t0, t1 FROM t WHERE t0 IN (SELECT u0 FROM u WHERE (t1 + u1) % 3 = 0)")
       .run();
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
       .planNode(flipJoinSides(plan))
-      .inputSplits(splitInput)
+      .inputSplits(splitPaths)
       .checkSpillStats(false)
       .referenceQuery(
           "SELECT t0, t1 FROM t WHERE t0 IN (SELECT u0 FROM u WHERE (t1 + u1) % 3 = 0)")
       .run();
 }
 
-TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoin) {
+TEST_P(MultiThreadedHashJoinTest, DISABLED_nullAwareAntiJoin) {
   std::vector<RowVectorPtr> probeVectors =
       makeBatches(5, [&](uint32_t /*unused*/) {
         return makeRowVector({
@@ -1123,35 +1121,38 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilter) {
             });
       });
 
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .numDrivers(numDrivers_)
-      .probeKeys({"t0"})
-      .probeVectors(std::move(probeVectors))
-      .buildKeys({"u0"})
-      .buildVectors(std::move(buildVectors))
-      .joinType(core::JoinType::kAnti)
-      .nullAware(true)
-      .joinFilter("t1 != u1")
-      .joinOutputLayout({"t0", "t1"})
-      .referenceQuery(
-          "SELECT t.* FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE t0 = u0 AND t1 <> u1)")
-      .checkSpillStats(false)
-      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-        // Verify spilling is not triggered in case of null-aware anti-join
-        // with filter.
-        const auto statsPair = taskSpilledStats(*task);
-        ASSERT_EQ(statsPair.first.spilledRows, 0);
-        ASSERT_EQ(statsPair.first.spilledBytes, 0);
-        ASSERT_EQ(statsPair.first.spilledPartitions, 0);
-        ASSERT_EQ(statsPair.first.spilledFiles, 0);
-        ASSERT_EQ(statsPair.second.spilledRows, 0);
-        ASSERT_EQ(statsPair.second.spilledBytes, 0);
-        ASSERT_EQ(statsPair.second.spilledPartitions, 0);
-        ASSERT_EQ(statsPair.second.spilledFiles, 0);
-        verifyTaskSpilledRuntimeStats(*task, false);
-        ASSERT_EQ(maxHashBuildSpillLevel(*task), -1);
-      })
-      .run();
+  // null-anti join with filter not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .numDrivers(numDrivers_)
+          .probeKeys({"t0"})
+          .probeVectors(std::move(probeVectors))
+          .buildKeys({"u0"})
+          .buildVectors(std::move(buildVectors))
+          .joinType(core::JoinType::kAnti)
+          .nullAware(true)
+          .joinFilter("t1 != u1")
+          .joinOutputLayout({"t0", "t1"})
+          .referenceQuery(
+              "SELECT t.* FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE t0 = u0 AND t1 <> u1)")
+          .checkSpillStats(false)
+          .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+            // Verify spilling is not triggered in case of null-aware anti-join
+            // with filter.
+            const auto statsPair = taskSpilledStats(*task);
+            ASSERT_EQ(statsPair.first.spilledRows, 0);
+            ASSERT_EQ(statsPair.first.spilledBytes, 0);
+            ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+            ASSERT_EQ(statsPair.first.spilledFiles, 0);
+            ASSERT_EQ(statsPair.second.spilledRows, 0);
+            ASSERT_EQ(statsPair.second.spilledBytes, 0);
+            ASSERT_EQ(statsPair.second.spilledPartitions, 0);
+            ASSERT_EQ(statsPair.second.spilledFiles, 0);
+            verifyTaskSpilledRuntimeStats(*task, false);
+            ASSERT_EQ(maxHashBuildSpillLevel(*task), -1);
+          })
+          .run(),
+      "Replacement with cuDF operator failed");
 }
 
 TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilterAndEmptyBuild) {
@@ -1176,37 +1177,40 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilterAndEmptyBuild) {
           });
     });
 
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
-        .numDrivers(numDrivers_)
-        .probeKeys({"t0"})
-        .probeVectors(std::vector<RowVectorPtr>(probeVectors))
-        .buildKeys({"u0"})
-        .buildVectors(std::vector<RowVectorPtr>(buildVectors))
-        .buildFilter("u0 < 0")
-        .joinType(core::JoinType::kAnti)
-        .nullAware(true)
-        .joinFilter("u1 > t1")
-        .joinOutputLayout({"t0", "t1"})
-        .referenceQuery(
-            "SELECT t.* FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE u0 < 0 AND u.u0 = t.t0)")
-        .checkSpillStats(false)
-        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-          // Verify spilling is not triggered in case of null-aware anti-join
-          // with filter.
-          const auto statsPair = taskSpilledStats(*task);
-          ASSERT_EQ(statsPair.first.spilledRows, 0);
-          ASSERT_EQ(statsPair.first.spilledBytes, 0);
-          ASSERT_EQ(statsPair.first.spilledPartitions, 0);
-          ASSERT_EQ(statsPair.first.spilledFiles, 0);
-          ASSERT_EQ(statsPair.second.spilledRows, 0);
-          ASSERT_EQ(statsPair.second.spilledBytes, 0);
-          ASSERT_EQ(statsPair.second.spilledPartitions, 0);
-          ASSERT_EQ(statsPair.second.spilledFiles, 0);
-          verifyTaskSpilledRuntimeStats(*task, false);
-          ASSERT_EQ(maxHashBuildSpillLevel(*task), -1);
-        })
-        .run();
+    // null-anti join with filter not supported
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
+            .numDrivers(numDrivers_)
+            .probeKeys({"t0"})
+            .probeVectors(std::vector<RowVectorPtr>(probeVectors))
+            .buildKeys({"u0"})
+            .buildVectors(std::vector<RowVectorPtr>(buildVectors))
+            .buildFilter("u0 < 0")
+            .joinType(core::JoinType::kAnti)
+            .nullAware(true)
+            .joinFilter("u1 > t1")
+            .joinOutputLayout({"t0", "t1"})
+            .referenceQuery(
+                "SELECT t.* FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE u0 < 0 AND u.u0 = t.t0)")
+            .checkSpillStats(false)
+            .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+              // Verify spilling is not triggered in case of null-aware
+              // anti-join with filter.
+              const auto statsPair = taskSpilledStats(*task);
+              ASSERT_EQ(statsPair.first.spilledRows, 0);
+              ASSERT_EQ(statsPair.first.spilledBytes, 0);
+              ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+              ASSERT_EQ(statsPair.first.spilledFiles, 0);
+              ASSERT_EQ(statsPair.second.spilledRows, 0);
+              ASSERT_EQ(statsPair.second.spilledBytes, 0);
+              ASSERT_EQ(statsPair.second.spilledPartitions, 0);
+              ASSERT_EQ(statsPair.second.spilledFiles, 0);
+              verifyTaskSpilledRuntimeStats(*task, false);
+              ASSERT_EQ(maxHashBuildSpillLevel(*task), -1);
+            })
+            .run(),
+        "Replacement with cuDF operator failed");
   }
 }
 
@@ -1236,34 +1240,37 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilterAndNullKey) {
 
     auto testProbeVectors = probeVectors;
     auto testBuildVectors = buildVectors;
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .numDrivers(numDrivers_)
-        .probeKeys({"t0"})
-        .probeVectors(std::move(testProbeVectors))
-        .buildKeys({"u0"})
-        .buildVectors(std::move(testBuildVectors))
-        .joinType(core::JoinType::kAnti)
-        .nullAware(true)
-        .joinFilter(filter)
-        .joinOutputLayout({"t0", "t1"})
-        .referenceQuery(referenceSql)
-        .checkSpillStats(false)
-        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-          // Verify spilling is not triggered in case of null-aware anti-join
-          // with filter.
-          const auto statsPair = taskSpilledStats(*task);
-          ASSERT_EQ(statsPair.first.spilledRows, 0);
-          ASSERT_EQ(statsPair.first.spilledBytes, 0);
-          ASSERT_EQ(statsPair.first.spilledPartitions, 0);
-          ASSERT_EQ(statsPair.first.spilledFiles, 0);
-          ASSERT_EQ(statsPair.second.spilledRows, 0);
-          ASSERT_EQ(statsPair.second.spilledBytes, 0);
-          ASSERT_EQ(statsPair.second.spilledPartitions, 0);
-          ASSERT_EQ(statsPair.second.spilledFiles, 0);
-          verifyTaskSpilledRuntimeStats(*task, false);
-          ASSERT_EQ(maxHashBuildSpillLevel(*task), -1);
-        })
-        .run();
+    // null-anti join with filter not supported
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .numDrivers(numDrivers_)
+            .probeKeys({"t0"})
+            .probeVectors(std::move(testProbeVectors))
+            .buildKeys({"u0"})
+            .buildVectors(std::move(testBuildVectors))
+            .joinType(core::JoinType::kAnti)
+            .nullAware(true)
+            .joinFilter(filter)
+            .joinOutputLayout({"t0", "t1"})
+            .referenceQuery(referenceSql)
+            .checkSpillStats(false)
+            .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+              // Verify spilling is not triggered in case of null-aware
+              // anti-join with filter.
+              const auto statsPair = taskSpilledStats(*task);
+              ASSERT_EQ(statsPair.first.spilledRows, 0);
+              ASSERT_EQ(statsPair.first.spilledBytes, 0);
+              ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+              ASSERT_EQ(statsPair.first.spilledFiles, 0);
+              ASSERT_EQ(statsPair.second.spilledRows, 0);
+              ASSERT_EQ(statsPair.second.spilledBytes, 0);
+              ASSERT_EQ(statsPair.second.spilledPartitions, 0);
+              ASSERT_EQ(statsPair.second.spilledFiles, 0);
+              verifyTaskSpilledRuntimeStats(*task, false);
+              ASSERT_EQ(maxHashBuildSpillLevel(*task), -1);
+            })
+            .run(),
+        "Replacement with cuDF operator failed");
   }
 }
 
@@ -1296,19 +1303,22 @@ TEST_P(
 
     auto testProbeVectors = probeVectors;
     auto testBuildVectors = buildVectors;
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .numDrivers(numDrivers_)
-        .probeKeys({"t0"})
-        .probeVectors(std::move(testProbeVectors))
-        .buildKeys({"u0"})
-        .buildVectors(std::move(testBuildVectors))
-        .joinType(core::JoinType::kAnti)
-        .nullAware(true)
-        .joinFilter(filter)
-        .joinOutputLayout({"t0", "t1"})
-        .referenceQuery(referenceSql)
-        .checkSpillStats(false)
-        .run();
+    // null-anti join with filter not supported
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .numDrivers(numDrivers_)
+            .probeKeys({"t0"})
+            .probeVectors(std::move(testProbeVectors))
+            .buildKeys({"u0"})
+            .buildVectors(std::move(testBuildVectors))
+            .joinType(core::JoinType::kAnti)
+            .nullAware(true)
+            .joinFilter(filter)
+            .joinOutputLayout({"t0", "t1"})
+            .referenceQuery(referenceSql)
+            .checkSpillStats(false)
+            .run(),
+        "Replacement with cuDF operator failed");
   }
 }
 
@@ -1334,34 +1344,37 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilterOnNullableColumn) {
               makeFlatVector<int32_t>(234, folly::identity, nullEvery(91)),
           });
     });
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .numDrivers(numDrivers_)
-        .probeKeys({"t0"})
-        .probeVectors(std::move(probeVectors))
-        .buildKeys({"u0"})
-        .buildVectors(std::move(buildVectors))
-        .joinType(core::JoinType::kAnti)
-        .nullAware(true)
-        .joinFilter(joinFilter)
-        .joinOutputLayout({"t0", "t1"})
-        .referenceQuery(referenceSql)
-        .checkSpillStats(false)
-        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-          // Verify spilling is not triggered in case of null-aware anti-join
-          // with filter.
-          const auto statsPair = taskSpilledStats(*task);
-          ASSERT_EQ(statsPair.first.spilledRows, 0);
-          ASSERT_EQ(statsPair.first.spilledBytes, 0);
-          ASSERT_EQ(statsPair.first.spilledPartitions, 0);
-          ASSERT_EQ(statsPair.first.spilledFiles, 0);
-          ASSERT_EQ(statsPair.second.spilledRows, 0);
-          ASSERT_EQ(statsPair.second.spilledBytes, 0);
-          ASSERT_EQ(statsPair.second.spilledPartitions, 0);
-          ASSERT_EQ(statsPair.second.spilledFiles, 0);
-          verifyTaskSpilledRuntimeStats(*task, false);
-          ASSERT_EQ(maxHashBuildSpillLevel(*task), -1);
-        })
-        .run();
+    // null-anti join with filter not supported
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .numDrivers(numDrivers_)
+            .probeKeys({"t0"})
+            .probeVectors(std::move(probeVectors))
+            .buildKeys({"u0"})
+            .buildVectors(std::move(buildVectors))
+            .joinType(core::JoinType::kAnti)
+            .nullAware(true)
+            .joinFilter(joinFilter)
+            .joinOutputLayout({"t0", "t1"})
+            .referenceQuery(referenceSql)
+            .checkSpillStats(false)
+            .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+              // Verify spilling is not triggered in case of null-aware
+              // anti-join with filter.
+              const auto statsPair = taskSpilledStats(*task);
+              ASSERT_EQ(statsPair.first.spilledRows, 0);
+              ASSERT_EQ(statsPair.first.spilledBytes, 0);
+              ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+              ASSERT_EQ(statsPair.first.spilledFiles, 0);
+              ASSERT_EQ(statsPair.second.spilledRows, 0);
+              ASSERT_EQ(statsPair.second.spilledBytes, 0);
+              ASSERT_EQ(statsPair.second.spilledPartitions, 0);
+              ASSERT_EQ(statsPair.second.spilledFiles, 0);
+              verifyTaskSpilledRuntimeStats(*task, false);
+              ASSERT_EQ(maxHashBuildSpillLevel(*task), -1);
+            })
+            .run(),
+        "Replacement with cuDF operator failed");
   }
 
   {
@@ -1384,34 +1397,37 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilterOnNullableColumn) {
               makeFlatVector<int32_t>(234, folly::identity, nullEvery(37)),
           });
     });
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .numDrivers(numDrivers_)
-        .probeKeys({"t0"})
-        .probeVectors(std::move(probeVectors))
-        .buildKeys({"u0"})
-        .buildVectors(std::move(buildVectors))
-        .joinType(core::JoinType::kAnti)
-        .nullAware(true)
-        .joinFilter(joinFilter)
-        .joinOutputLayout({"t0", "t1"})
-        .referenceQuery(referenceSql)
-        .checkSpillStats(false)
-        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-          // Verify spilling is not triggered in case of null-aware anti-join
-          // with filter.
-          const auto statsPair = taskSpilledStats(*task);
-          ASSERT_EQ(statsPair.first.spilledRows, 0);
-          ASSERT_EQ(statsPair.first.spilledBytes, 0);
-          ASSERT_EQ(statsPair.first.spilledPartitions, 0);
-          ASSERT_EQ(statsPair.first.spilledFiles, 0);
-          ASSERT_EQ(statsPair.second.spilledRows, 0);
-          ASSERT_EQ(statsPair.second.spilledBytes, 0);
-          ASSERT_EQ(statsPair.second.spilledPartitions, 0);
-          ASSERT_EQ(statsPair.second.spilledFiles, 0);
-          verifyTaskSpilledRuntimeStats(*task, false);
-          ASSERT_EQ(maxHashBuildSpillLevel(*task), -1);
-        })
-        .run();
+    // null-anti join with filter not supported
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .numDrivers(numDrivers_)
+            .probeKeys({"t0"})
+            .probeVectors(std::move(probeVectors))
+            .buildKeys({"u0"})
+            .buildVectors(std::move(buildVectors))
+            .joinType(core::JoinType::kAnti)
+            .nullAware(true)
+            .joinFilter(joinFilter)
+            .joinOutputLayout({"t0", "t1"})
+            .referenceQuery(referenceSql)
+            .checkSpillStats(false)
+            .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+              // Verify spilling is not triggered in case of null-aware
+              // anti-join with filter.
+              const auto statsPair = taskSpilledStats(*task);
+              ASSERT_EQ(statsPair.first.spilledRows, 0);
+              ASSERT_EQ(statsPair.first.spilledBytes, 0);
+              ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+              ASSERT_EQ(statsPair.first.spilledFiles, 0);
+              ASSERT_EQ(statsPair.second.spilledRows, 0);
+              ASSERT_EQ(statsPair.second.spilledBytes, 0);
+              ASSERT_EQ(statsPair.second.spilledPartitions, 0);
+              ASSERT_EQ(statsPair.second.spilledFiles, 0);
+              verifyTaskSpilledRuntimeStats(*task, false);
+              ASSERT_EQ(maxHashBuildSpillLevel(*task), -1);
+            })
+            .run(),
+        "Replacement with cuDF operator failed");
   }
 }
 
@@ -1447,7 +1463,8 @@ TEST_P(MultiThreadedHashJoinTest, antiJoin) {
       .run();
 
   std::vector<std::string> filters({
-      "u1 > t1", "u1 * t1 > 0",
+      "u1 > t1",
+      "u1 * t1 > 0",
       // This filter is true on rows without a match. It should not prevent
       // the row from being returned.
       // Disabling this because coalesce is not supported in cudf.
@@ -1475,9 +1492,10 @@ TEST_P(MultiThreadedHashJoinTest, antiJoin) {
         .joinType(core::JoinType::kAnti)
         .joinFilter(filter)
         .joinOutputLayout({"t0", "t1"})
-        .referenceQuery(fmt::format(
-            "SELECT t.* FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE u.u0 = t.t0 AND {})",
-            filter))
+        .referenceQuery(
+            fmt::format(
+                "SELECT t.* FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE u.u0 = t.t0 AND {})",
+                filter))
         .run();
   }
 }
@@ -2042,6 +2060,23 @@ TEST_P(MultiThreadedHashJoinTest, rightJoin) {
       .joinOutputLayout({"c0", "c1", "u_c1"})
       .referenceQuery(
           "SELECT t.c0, t.c1, u.c1 FROM t RIGHT JOIN u ON t.c0 = u.c0")
+      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+        int nullJoinBuildKeyCount = 0;
+        int nullJoinProbeKeyCount = 0;
+
+        for (auto& pipeline : task->taskStats().pipelineStats) {
+          for (auto op : pipeline.operatorStats) {
+            if (op.operatorType == "CudfHashJoinBuild") {
+              nullJoinBuildKeyCount += op.numNullKeys;
+            }
+            if (op.operatorType == "CudfHashJoinProbe") {
+              nullJoinProbeKeyCount += op.numNullKeys;
+            }
+          }
+        }
+        ASSERT_GT(nullJoinBuildKeyCount, 0);
+        ASSERT_GT(nullJoinProbeKeyCount, 0);
+      })
       .run();
 }
 
@@ -2554,19 +2589,20 @@ TEST_F(HashJoinTest, nullAwareRightSemiProjectOverScan) {
                         true /*nullAware*/)
                     .planNode();
 
-    SplitInput splitInput = {
-        {probeScanId,
-         {exec::Split(makeHiveConnectorSplit(probeFile->getPath()))}},
-        {buildScanId,
-         {exec::Split(makeHiveConnectorSplit(buildFile->getPath()))}},
+    SplitPath splitPaths = {
+        {probeScanId, {probeFile->getPath()}},
+        {buildScanId, {buildFile->getPath()}},
     };
 
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .planNode(plan)
-        .inputSplits(splitInput)
-        .checkSpillStats(false)
-        .referenceQuery("SELECT u0, u0 IN (SELECT t0 FROM t) FROM u")
-        .run();
+    // right semi project not supported
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .planNode(plan)
+            .inputSplits(splitPaths)
+            .checkSpillStats(false)
+            .referenceQuery("SELECT u0, u0 IN (SELECT t0 FROM t) FROM u")
+            .run(),
+        "Replacement with cuDF operator failed");
   }
 }
 
@@ -2598,6 +2634,7 @@ TEST_F(HashJoinTest, duplicateJoinKeys) {
                         const std::vector<std::string>& rightKeys,
                         const std::vector<std::string>& outputLayout,
                         core::JoinType joinType,
+                        bool throwType,
                         const std::string& query) {
     auto plan = PlanBuilder(planNodeIdGenerator)
                     .values(leftVectors)
@@ -2613,12 +2650,23 @@ TEST_F(HashJoinTest, duplicateJoinKeys) {
                         outputLayout,
                         joinType)
                     .planNode();
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .planNode(plan)
-        .injectSpill(false)
-        .checkSpillStats(false)
-        .referenceQuery(query)
-        .run();
+    if (throwType) {
+      VELOX_ASSERT_THROW(
+          HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+              .planNode(plan)
+              .injectSpill(false)
+              .checkSpillStats(false)
+              .referenceQuery(query)
+              .run(),
+          "Replacement with cuDF operator failed");
+    } else {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(plan)
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .referenceQuery(query)
+          .run();
+    }
   };
 
   std::vector<std::pair<core::JoinType, std::string>> joins = {
@@ -2636,6 +2684,7 @@ TEST_F(HashJoinTest, duplicateJoinKeys) {
         {"u0", "u0"}, // rightKeys
         {"t0", "t1", "u0"}, // outputLayout
         joinType,
+        false,
         "SELECT t.c0, t.c1, u.c0 FROM t " + joinTypeSql +
             " u ON t.c0 = u.c0 and t.c1 = u.c0");
   }
@@ -2649,6 +2698,7 @@ TEST_F(HashJoinTest, duplicateJoinKeys) {
         {"u0", "u1"}, // rightKeys
         {"t0", "u0", "u1"}, // outputLayout
         joinType,
+        false,
         "SELECT t.c0, u.c0, u.c1 FROM t " + joinTypeSql +
             " u ON t.c0 = u.c0 and t.c0 = u.c1");
   }
@@ -2700,13 +2750,16 @@ TEST_F(HashJoinTest, semiProject) {
           "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0) FROM t")
       .run();
 
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .injectSpill(false)
-      .checkSpillStats(false)
-      .planNode(flipJoinSides(plan))
-      .referenceQuery(
-          "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0) FROM t")
-      .run();
+  // right semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(flipJoinSides(plan))
+          .referenceQuery(
+              "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
 
   // With extra filter.
   planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
@@ -2733,13 +2786,16 @@ TEST_F(HashJoinTest, semiProject) {
           "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0 AND t.c1 * 10 <> u.c1) FROM t")
       .run();
 
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .injectSpill(false)
-      .checkSpillStats(false)
-      .planNode(flipJoinSides(plan))
-      .referenceQuery(
-          "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0 AND t.c1 * 10 <> u.c1) FROM t")
-      .run();
+  // right semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(flipJoinSides(plan))
+          .referenceQuery(
+              "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0 AND t.c1 * 10 <> u.c1) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
 
   // Empty build side.
   planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
@@ -2769,16 +2825,19 @@ TEST_F(HashJoinTest, semiProject) {
       // build-side rows have been filtered out.
       .run();
 
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .injectSpill(false)
-      .checkSpillStats(false)
-      .planNode(flipJoinSides(plan))
-      .referenceQuery(
-          "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE u.c0 < 0 AND t.c0 = u.c0) FROM t")
-      // NOTE: there is no spilling in empty build test case as all the
-      // build-side rows have been filtered out.
-      .checkSpillStats(false)
-      .run();
+  // right semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(flipJoinSides(plan))
+          .referenceQuery(
+              "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE u.c0 < 0 AND t.c0 = u.c0) FROM t")
+          // NOTE: there is no spilling in empty build test case as all the
+          // build-side rows have been filtered out.
+          .checkSpillStats(false)
+          .run(),
+      "Replacement with cuDF operator failed");
 }
 
 TEST_F(HashJoinTest, semiProjectWithNullKeys) {
@@ -2843,16 +2902,20 @@ TEST_F(HashJoinTest, semiProjectWithNullKeys) {
           "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0) FROM t")
       .run();
 
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .injectSpill(false)
-      .checkSpillStats(false)
-      .planNode(flipJoinSides(plan))
-      .referenceQuery(
-          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0) FROM t")
-      .run();
+  // right semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(flipJoinSides(plan))
+          .referenceQuery(
+              "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
 
   plan = makePlan(true /*nullAware*/);
 
+  // null-aware left semi project now supported (without filter)
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .injectSpill(false)
       .checkSpillStats(false)
@@ -2860,12 +2923,15 @@ TEST_F(HashJoinTest, semiProjectWithNullKeys) {
       .referenceQuery("SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t")
       .run();
 
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .injectSpill(false)
-      .checkSpillStats(false)
-      .planNode(flipJoinSides(plan))
-      .referenceQuery("SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t")
-      .run();
+  // null-aware right semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(flipJoinSides(plan))
+          .referenceQuery("SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
 
   // Null join keys on build side-only.
   plan = makePlan(false /*nullAware*/, "t0 IS NOT NULL");
@@ -2878,16 +2944,20 @@ TEST_F(HashJoinTest, semiProjectWithNullKeys) {
           "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0) FROM t WHERE t0 IS NOT NULL")
       .run();
 
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .injectSpill(false)
-      .checkSpillStats(false)
-      .planNode(flipJoinSides(plan))
-      .referenceQuery(
-          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0) FROM t WHERE t0 IS NOT NULL")
-      .run();
+  // right semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(flipJoinSides(plan))
+          .referenceQuery(
+              "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0) FROM t WHERE t0 IS NOT NULL")
+          .run(),
+      "Replacement with cuDF operator failed");
 
   plan = makePlan(true /*nullAware*/, "t0 IS NOT NULL");
 
+  // null-aware left semi project now supported (without filter)
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .injectSpill(false)
       .checkSpillStats(false)
@@ -2896,13 +2966,16 @@ TEST_F(HashJoinTest, semiProjectWithNullKeys) {
           "SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t WHERE t0 IS NOT NULL")
       .run();
 
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .injectSpill(false)
-      .checkSpillStats(false)
-      .planNode(flipJoinSides(plan))
-      .referenceQuery(
-          "SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t WHERE t0 IS NOT NULL")
-      .run();
+  // null-aware right semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(flipJoinSides(plan))
+          .referenceQuery(
+              "SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t WHERE t0 IS NOT NULL")
+          .run(),
+      "Replacement with cuDF operator failed");
 
   // Null join keys on probe side-only.
   plan = makePlan(false /*nullAware*/, "", "u0 IS NOT NULL");
@@ -2915,16 +2988,20 @@ TEST_F(HashJoinTest, semiProjectWithNullKeys) {
           "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 IS NOT NULL) FROM t")
       .run();
 
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .injectSpill(false)
-      .checkSpillStats(false)
-      .planNode(flipJoinSides(plan))
-      .referenceQuery(
-          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 IS NOT NULL) FROM t")
-      .run();
+  // right semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(flipJoinSides(plan))
+          .referenceQuery(
+              "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 IS NOT NULL) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
 
   plan = makePlan(true /*nullAware*/, "", "u0 IS NOT NULL");
 
+  // null-aware left semi project now supported (without filter)
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .injectSpill(false)
       .checkSpillStats(false)
@@ -2933,13 +3010,16 @@ TEST_F(HashJoinTest, semiProjectWithNullKeys) {
           "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 IS NOT NULL) FROM t")
       .run();
 
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .injectSpill(false)
-      .checkSpillStats(false)
-      .planNode(flipJoinSides(plan))
-      .referenceQuery(
-          "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 IS NOT NULL) FROM t")
-      .run();
+  // null-aware right semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(flipJoinSides(plan))
+          .referenceQuery(
+              "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 IS NOT NULL) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
 
   // Empty build side.
   plan = makePlan(false /*nullAware*/, "", "u0 < 0");
@@ -2952,16 +3032,20 @@ TEST_F(HashJoinTest, semiProjectWithNullKeys) {
           "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 < 0) FROM t")
       .run();
 
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
-      .planNode(flipJoinSides(plan))
-      .injectSpill(false)
-      .checkSpillStats(false)
-      .referenceQuery(
-          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 < 0) FROM t")
-      .run();
+  // right semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
+          .planNode(flipJoinSides(plan))
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .referenceQuery(
+              "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 < 0) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
 
   plan = makePlan(true /*nullAware*/, "", "u0 < 0");
 
+  // null-aware left semi project now supported (without filter)
   HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
       .planNode(plan)
       .injectSpill(false)
@@ -2970,13 +3054,16 @@ TEST_F(HashJoinTest, semiProjectWithNullKeys) {
           "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 < 0) FROM t")
       .run();
 
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
-      .planNode(flipJoinSides(plan))
-      .injectSpill(false)
-      .checkSpillStats(false)
-      .referenceQuery(
-          "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 < 0) FROM t")
-      .run();
+  // null-aware right semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
+          .planNode(flipJoinSides(plan))
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .referenceQuery(
+              "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 < 0) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
 
   // Build side with all rows having null join keys.
   plan = makePlan(false /*nullAware*/, "", "u0 IS NULL");
@@ -2989,16 +3076,20 @@ TEST_F(HashJoinTest, semiProjectWithNullKeys) {
           "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 IS NULL) FROM t")
       .run();
 
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
-      .planNode(flipJoinSides(plan))
-      .injectSpill(false)
-      .checkSpillStats(false)
-      .referenceQuery(
-          "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 IS NULL) FROM t")
-      .run();
+  // right semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
+          .planNode(flipJoinSides(plan))
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .referenceQuery(
+              "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 IS NULL) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
 
   plan = makePlan(true /*nullAware*/, "", "u0 IS NULL");
 
+  // null-aware left semi project now supported (without filter)
   HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
       .planNode(plan)
       .injectSpill(false)
@@ -3007,78 +3098,440 @@ TEST_F(HashJoinTest, semiProjectWithNullKeys) {
           "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 IS NULL) FROM t")
       .run();
 
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
-      .planNode(flipJoinSides(plan))
-      .injectSpill(false)
-      .checkSpillStats(false)
-      .referenceQuery(
-          "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 IS NULL) FROM t")
-      .run();
-}
+  // null-aware right semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
+          .planNode(flipJoinSides(plan))
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .referenceQuery(
+              "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 IS NULL) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+}
+
+TEST_F(HashJoinTest, semiProjectWithFilter) {
+  auto probeVectors = makeBatches(3, [&](auto /*unused*/) {
+    return makeRowVector(
+        {"t0", "t1"},
+        {
+            makeNullableFlatVector<int32_t>({1, 2, 3, std::nullopt, 5}),
+            makeFlatVector<int64_t>({10, 20, 30, 40, 50}),
+        });
+  });
+
+  auto buildVectors = makeBatches(3, [&](auto /*unused*/) {
+    return makeRowVector(
+        {"u0", "u1"},
+        {
+            makeNullableFlatVector<int32_t>({1, 2, 3, std::nullopt}),
+            makeFlatVector<int64_t>({11, 22, 33, 44}),
+        });
+  });
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto makePlan = [&](bool nullAware, const std::string& filter) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    return PlanBuilder(planNodeIdGenerator)
+        .values(probeVectors)
+        .hashJoin(
+            {"t0"},
+            {"u0"},
+            PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode(),
+            filter,
+            {"t0", "t1", "match"},
+            core::JoinType::kLeftSemiProject,
+            nullAware)
+        .planNode();
+  };
+
+  std::vector<std::string> filters = {
+      "t1 <> u1",
+      "t1 < u1",
+      "t1 > u1",
+      "t1 is not null AND u1 is not null",
+      "t1 is null OR u1 is null",
+  };
+  for (const auto& filter : filters) {
+    auto plan = makePlan(true /*nullAware*/, filter);
+
+    // null-aware left semi project with filter now supported
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(plan)
+        .referenceQuery(
+            fmt::format(
+                "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE {}) FROM t",
+                filter))
+        .injectSpill(false)
+        .run();
+
+    plan = makePlan(false /*nullAware*/, filter);
+
+    // DuckDB Exists operator returns NULL when u0 or t0 is NULL. We exclude
+    // these values.
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(plan)
+        .referenceQuery(
+            fmt::format(
+                "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE (u0 is not null OR t0 is not null) AND u0 = t0 AND {}) FROM t",
+                filter))
+        .injectSpill(false)
+        .run();
+  }
+}
+
+// Comprehensive edge case tests for null-aware left semi project with filter
+TEST_F(HashJoinTest, nullAwareSemiProjectWithFilterEdgeCases) {
+  // Test 1: Empty build side with null-aware + filter
+  // All results should be FALSE (not NULL) since there's nothing to match
+  {
+    auto probeVectors = makeBatches(1, [&](auto) {
+      return makeRowVector(
+          {"t0", "t1"},
+          {
+              makeNullableFlatVector<int32_t>({1, 2, std::nullopt, 4}),
+              makeFlatVector<int64_t>({10, 20, 30, 40}),
+          });
+    });
+
+    auto buildVectors = makeBatches(1, [&](auto) {
+      return makeRowVector(
+          {"u0", "u1"},
+          {
+              makeNullableFlatVector<int32_t>({}),
+              makeFlatVector<int64_t>({}),
+          });
+    });
+
+    createDuckDbTable("t", probeVectors);
+    createDuckDbTable("u", buildVectors);
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(probeVectors)
+                    .hashJoin(
+                        {"t0"},
+                        {"u0"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildVectors)
+                            .planNode(),
+                        "t1 > u1",
+                        {"t0", "t1", "match"},
+                        core::JoinType::kLeftSemiProject,
+                        true /* nullAware */)
+                    .planNode();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(plan)
+        .referenceQuery(
+            "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE t1 > u1) FROM t")
+        .injectSpill(false)
+        .run();
+  }
+
+  // Test 2: All probe keys are NULL with filter
+  // Tests Type B indeterminate logic exclusively
+  {
+    auto probeVectors = makeBatches(1, [&](auto) {
+      return makeRowVector(
+          {"t0", "t1"},
+          {
+              makeNullableFlatVector<int32_t>(
+                  {std::nullopt, std::nullopt, std::nullopt}),
+              makeFlatVector<int64_t>({10, 20, 30}),
+          });
+    });
+
+    auto buildVectors = makeBatches(1, [&](auto) {
+      return makeRowVector(
+          {"u0", "u1"},
+          {
+              makeNullableFlatVector<int32_t>({1, 2, std::nullopt}),
+              makeFlatVector<int64_t>({15, 25, 35}),
+          });
+    });
+
+    createDuckDbTable("t", probeVectors);
+    createDuckDbTable("u", buildVectors);
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(probeVectors)
+                    .hashJoin(
+                        {"t0"},
+                        {"u0"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildVectors)
+                            .planNode(),
+                        "t1 < u1",
+                        {"t0", "t1", "match"},
+                        core::JoinType::kLeftSemiProject,
+                        true /* nullAware */)
+                    .planNode();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(plan)
+        .referenceQuery(
+            "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE t1 < u1) FROM t")
+        .injectSpill(false)
+        .run();
+  }
+
+  // Test 3: All build keys are NULL with filter
+  // Tests Type A indeterminate logic (non-null probe keys that don't match
+  // because build has only NULL keys, but filter passes for some pairs)
+  {
+    auto probeVectors = makeBatches(1, [&](auto) {
+      return makeRowVector(
+          {"t0", "t1"},
+          {
+              makeNullableFlatVector<int32_t>({1, 2, 3, std::nullopt}),
+              makeFlatVector<int64_t>({10, 20, 30, 5}),
+          });
+    });
+
+    auto buildVectors = makeBatches(1, [&](auto) {
+      return makeRowVector(
+          {"u0", "u1"},
+          {
+              makeNullableFlatVector<int32_t>(
+                  {std::nullopt, std::nullopt, std::nullopt}),
+              makeFlatVector<int64_t>({15, 25, 35}),
+          });
+    });
+
+    createDuckDbTable("t", probeVectors);
+    createDuckDbTable("u", buildVectors);
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(probeVectors)
+                    .hashJoin(
+                        {"t0"},
+                        {"u0"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildVectors)
+                            .planNode(),
+                        "t1 < u1",
+                        {"t0", "t1", "match"},
+                        core::JoinType::kLeftSemiProject,
+                        true /* nullAware */)
+                    .planNode();
+
+    // For this test:
+    // - Probe keys {1, 2, 3} have no key match (build has only NULL keys)
+    //   Filter t1 < u1 passes for (10<15, 20<25, 30<35), so these are
+    //   indeterminate (NULL)
+    // - Probe key NULL with t1=5: filter 5 < {15,25,35} all pass, so
+    //   indeterminate (NULL)
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(plan)
+        .referenceQuery(
+            "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE t1 < u1) FROM t")
+        .injectSpill(false)
+        .run();
+  }
+
+  // Test 4: No nulls at all with null-aware + filter
+  // Should behave like non-null-aware: all TRUE or FALSE, no NULLs
+  {
+    auto probeVectors = makeBatches(1, [&](auto) {
+      return makeRowVector(
+          {"t0", "t1"},
+          {
+              makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+              makeFlatVector<int64_t>({10, 20, 30, 40, 50}),
+          });
+    });
+
+    auto buildVectors = makeBatches(1, [&](auto) {
+      return makeRowVector(
+          {"u0", "u1"},
+          {
+              makeFlatVector<int32_t>({1, 2, 3}),
+              makeFlatVector<int64_t>({15, 25, 35}),
+          });
+    });
+
+    createDuckDbTable("t", probeVectors);
+    createDuckDbTable("u", buildVectors);
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(probeVectors)
+                    .hashJoin(
+                        {"t0"},
+                        {"u0"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildVectors)
+                            .planNode(),
+                        "t1 < u1",
+                        {"t0", "t1", "match"},
+                        core::JoinType::kLeftSemiProject,
+                        true /* nullAware */)
+                    .planNode();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(plan)
+        .referenceQuery(
+            "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE t1 < u1) FROM t")
+        .injectSpill(false)
+        .run();
+  }
+
+  // Test 5: Filter that always fails (1 = 0)
+  // All results should be FALSE (or NULL for null-key probe rows)
+  {
+    auto probeVectors = makeBatches(1, [&](auto) {
+      return makeRowVector(
+          {"t0", "t1"},
+          {
+              makeNullableFlatVector<int32_t>({1, 2, std::nullopt, 4}),
+              makeFlatVector<int64_t>({10, 20, 30, 40}),
+          });
+    });
+
+    auto buildVectors = makeBatches(1, [&](auto) {
+      return makeRowVector(
+          {"u0", "u1"},
+          {
+              makeNullableFlatVector<int32_t>({1, 2, std::nullopt}),
+              makeFlatVector<int64_t>({15, 25, 35}),
+          });
+    });
+
+    createDuckDbTable("t", probeVectors);
+    createDuckDbTable("u", buildVectors);
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(probeVectors)
+                    .hashJoin(
+                        {"t0"},
+                        {"u0"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildVectors)
+                            .planNode(),
+                        "1 = 0", // Always false filter
+                        {"t0", "t1", "match"},
+                        core::JoinType::kLeftSemiProject,
+                        true /* nullAware */)
+                    .planNode();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(plan)
+        .referenceQuery(
+            "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE 1 = 0) FROM t")
+        .injectSpill(false)
+        .run();
+  }
 
-TEST_F(HashJoinTest, semiProjectWithFilter) {
-  auto probeVectors = makeBatches(3, [&](auto /*unused*/) {
-    return makeRowVector(
-        {"t0", "t1"},
-        {
-            makeNullableFlatVector<int32_t>({1, 2, 3, std::nullopt, 5}),
-            makeFlatVector<int64_t>({10, 20, 30, 40, 50}),
-        });
-  });
+  // Test 6: Filter that always passes (1 = 1)
+  // Should behave like no filter case
+  {
+    auto probeVectors = makeBatches(1, [&](auto) {
+      return makeRowVector(
+          {"t0", "t1"},
+          {
+              makeNullableFlatVector<int32_t>({1, 2, std::nullopt, 4}),
+              makeFlatVector<int64_t>({10, 20, 30, 40}),
+          });
+    });
 
-  auto buildVectors = makeBatches(3, [&](auto /*unused*/) {
-    return makeRowVector(
-        {"u0", "u1"},
-        {
-            makeNullableFlatVector<int32_t>({1, 2, 3, std::nullopt}),
-            makeFlatVector<int64_t>({11, 22, 33, 44}),
-        });
-  });
+    auto buildVectors = makeBatches(1, [&](auto) {
+      return makeRowVector(
+          {"u0", "u1"},
+          {
+              makeNullableFlatVector<int32_t>({1, 2, std::nullopt}),
+              makeFlatVector<int64_t>({15, 25, 35}),
+          });
+    });
 
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
+    createDuckDbTable("t", probeVectors);
+    createDuckDbTable("u", buildVectors);
 
-  auto makePlan = [&](bool nullAware, const std::string& filter) {
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-    return PlanBuilder(planNodeIdGenerator)
-        .values(probeVectors)
-        .hashJoin(
-            {"t0"},
-            {"u0"},
-            PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode(),
-            filter,
-            {"t0", "t1", "match"},
-            core::JoinType::kLeftSemiProject,
-            nullAware)
-        .planNode();
-  };
-
-  std::vector<std::string> filters = {
-      "t1 <> u1",
-      "t1 < u1",
-      "t1 > u1",
-      "t1 is not null AND u1 is not null",
-      "t1 is null OR u1 is null",
-  };
-  for (const auto& filter : filters) {
-    auto plan = makePlan(true /*nullAware*/, filter);
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(probeVectors)
+                    .hashJoin(
+                        {"t0"},
+                        {"u0"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildVectors)
+                            .planNode(),
+                        "1 = 1", // Always true filter
+                        {"t0", "t1", "match"},
+                        core::JoinType::kLeftSemiProject,
+                        true /* nullAware */)
+                    .planNode();
 
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .planNode(plan)
-        .referenceQuery(fmt::format(
-            "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE {}) FROM t", filter))
+        .referenceQuery(
+            "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE 1 = 1) FROM t")
         .injectSpill(false)
         .run();
+  }
 
-    plan = makePlan(false /*nullAware*/, filter);
+  // Test 7: Multiple build batches with different null distributions
+  // Some batches have null keys, some don't
+  {
+    auto probeVectors = makeBatches(1, [&](auto) {
+      return makeRowVector(
+          {"t0", "t1"},
+          {
+              makeNullableFlatVector<int32_t>({1, 2, 3, std::nullopt, 5}),
+              makeFlatVector<int64_t>({10, 20, 30, 40, 50}),
+          });
+    });
+
+    // First batch: no nulls
+    std::vector<RowVectorPtr> buildVectors;
+    buildVectors.push_back(makeRowVector(
+        {"u0", "u1"},
+        {
+            makeFlatVector<int32_t>({1, 2}),
+            makeFlatVector<int64_t>({15, 25}),
+        }));
+    // Second batch: has nulls
+    buildVectors.push_back(makeRowVector(
+        {"u0", "u1"},
+        {
+            makeNullableFlatVector<int32_t>({3, std::nullopt}),
+            makeFlatVector<int64_t>({35, 45}),
+        }));
+    // Third batch: no nulls again
+    buildVectors.push_back(makeRowVector(
+        {"u0", "u1"},
+        {
+            makeFlatVector<int32_t>({5}),
+            makeFlatVector<int64_t>({55}),
+        }));
+
+    createDuckDbTable("t", probeVectors);
+    createDuckDbTable("u", buildVectors);
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(probeVectors)
+                    .hashJoin(
+                        {"t0"},
+                        {"u0"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildVectors)
+                            .planNode(),
+                        "t1 < u1",
+                        {"t0", "t1", "match"},
+                        core::JoinType::kLeftSemiProject,
+                        true /* nullAware */)
+                    .planNode();
 
-    // DuckDB Exists operator returns NULL when u0 or t0 is NULL. We exclude
-    // these values.
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .planNode(plan)
-        .referenceQuery(fmt::format(
-            "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE (u0 is not null OR t0 is not null) AND u0 = t0 AND {}) FROM t",
-            filter))
+        .referenceQuery(
+            "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE t1 < u1) FROM t")
         .injectSpill(false)
         .run();
   }
@@ -3130,7 +3583,8 @@ TEST_F(HashJoinTest, leftSemiJoinWithExtraOutputCapacity) {
   createDuckDbTable("u", buildVectors);
   auto runQuery = [&](const std::string& query,
                       const std::string& filter,
-                      core::JoinType joinType) {
+                      core::JoinType joinType,
+                      bool throwType) {
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
     std::vector<std::string> outputLayout = {"t0", "t1"};
     if (joinType == core::JoinType::kLeftSemiProject) {
@@ -3149,12 +3603,23 @@ TEST_F(HashJoinTest, leftSemiJoinWithExtraOutputCapacity) {
                         joinType,
                         false)
                     .planNode();
-    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-        .planNode(plan)
-        .config(core::QueryConfig::kPreferredOutputBatchRows, "5")
-        .referenceQuery(query)
-        .injectSpill(false)
-        .run();
+    if (throwType) {
+      VELOX_ASSERT_RUNTIME_THROW(
+          HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+              .planNode(plan)
+              .config(core::QueryConfig::kPreferredOutputBatchRows, "5")
+              .referenceQuery(query)
+              .injectSpill(false)
+              .run(),
+          "Replacement with cuDF operator failed");
+    } else {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(plan)
+          .config(core::QueryConfig::kPreferredOutputBatchRows, "5")
+          .referenceQuery(query)
+          .injectSpill(false)
+          .run();
+    }
   };
   {
     SCOPED_TRACE("left semi filter join");
@@ -3164,7 +3629,8 @@ TEST_F(HashJoinTest, leftSemiJoinWithExtraOutputCapacity) {
             "SELECT t0, t1 FROM t WHERE EXISTS (SELECT u0 FROM u WHERE t0 = u0 AND {})",
             filter),
         filter,
-        core::JoinType::kLeftSemiFilter);
+        core::JoinType::kLeftSemiFilter,
+        false);
   }
 
   {
@@ -3174,7 +3640,8 @@ TEST_F(HashJoinTest, leftSemiJoinWithExtraOutputCapacity) {
         fmt::format(
             "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE {}) FROM t", filter),
         filter,
-        core::JoinType::kLeftSemiProject);
+        core::JoinType::kLeftSemiProject,
+        false);
   }
 }
 
@@ -3276,26 +3743,27 @@ TEST_F(HashJoinTest, semiProjectOverLazyVectors) {
                       core::JoinType::kLeftSemiProject)
                   .planNode();
 
-  SplitInput splitInput = {
-      {probeScanId,
-       {exec::Split(makeHiveConnectorSplit(probeFile->getPath()))}},
-      {buildScanId,
-       {exec::Split(makeHiveConnectorSplit(buildFile->getPath()))}},
+  SplitPath splitPaths = {
+      {probeScanId, {probeFile->getPath()}},
+      {buildScanId, {buildFile->getPath()}},
   };
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .planNode(plan)
-      .inputSplits(splitInput)
+      .inputSplits(splitPaths)
       .checkSpillStats(false)
       .referenceQuery("SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t")
       .run();
 
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(flipJoinSides(plan))
-      .inputSplits(splitInput)
-      .checkSpillStats(false)
-      .referenceQuery("SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t")
-      .run();
+  // right semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(flipJoinSides(plan))
+          .inputSplits(splitPaths)
+          .checkSpillStats(false)
+          .referenceQuery("SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
 
   // With extra filter.
   planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
@@ -3316,18 +3784,164 @@ TEST_F(HashJoinTest, semiProjectOverLazyVectors) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .planNode(plan)
-      .inputSplits(splitInput)
+      .inputSplits(splitPaths)
       .checkSpillStats(false)
       .referenceQuery(
           "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE (t1 + u1) % 3 = 0) FROM t")
       .run();
 
+  // right semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(flipJoinSides(plan))
+          .inputSplits(splitPaths)
+          .checkSpillStats(false)
+          .referenceQuery(
+              "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE (t1 + u1) % 3 = 0) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+}
+
+// Tests for join filters that require precomputation (non-AST operations)
+TEST_P(MultiThreadedHashJoinTest, innerJoinWithMixedFilterPrecomputation) {
+  // Test combining AST-supported operations with precomputation
+  std::vector<RowVectorPtr> probeVectors = makeBatches(3, [&](int32_t batch) {
+    return makeRowVector({
+        makeFlatVector<int64_t>(100, [batch](auto row) { return row + batch; }),
+        makeFlatVector<std::string>(
+            100, [](auto row) { return row % 2 == 0 ? "ABC" : "abc"; }),
+        makeFlatVector<int64_t>(100, [](auto row) { return row * 10; }),
+    });
+  });
+
+  std::vector<RowVectorPtr> buildVectors = makeBatches(3, [&](int32_t batch) {
+    return makeRowVector({
+        makeFlatVector<int64_t>(100, [batch](auto row) { return row + batch; }),
+        makeFlatVector<std::string>(100, [](auto /*row*/) { return "ABC"; }),
+        makeFlatVector<int64_t>(100, [](auto row) { return row * 10; }),
+    });
+  });
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  // Combine string function (precomputation) with arithmetic comparison (AST)
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .planNode(flipJoinSides(plan))
-      .inputSplits(splitInput)
-      .checkSpillStats(false)
+      .injectSpill(false)
+      .numDrivers(numDrivers_)
+      .probeKeys({"t_c0"})
+      .probeVectors(std::move(probeVectors))
+      .probeProjections({"c0 AS t_c0", "c1 AS t_str", "c2 AS t_val"})
+      .buildKeys({"u_c0"})
+      .buildVectors(std::move(buildVectors))
+      .buildProjections({"c0 AS u_c0", "c1 AS u_str", "c2 AS u_val"})
+      .joinFilter("upper(t_str) = u_str AND t_val = u_val")
+      .joinOutputLayout({"t_c0", "t_str", "t_val", "u_c0", "u_str", "u_val"})
       .referenceQuery(
-          "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE (t1 + u1) % 3 = 0) FROM t")
+          "SELECT t.c0, t.c1, t.c2, u.c0, u.c1, u.c2 FROM t, u "
+          "WHERE t.c0 = u.c0 AND upper(t.c1) = u.c1 AND t.c2 = u.c2")
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, leftJoinWithStringFunctionFilter) {
+  // Create probe vectors with string data
+  std::vector<RowVectorPtr> probeVectors = makeBatches(3, [&](int32_t batch) {
+    return makeRowVector(
+        {"t0", "t1"},
+        {
+            makeFlatVector<int64_t>(
+                100, [batch](auto row) { return row + batch; }),
+            makeFlatVector<std::string>(
+                100, [](auto row) { return row % 2 == 0 ? "HELLO" : "hello"; }),
+        });
+  });
+
+  // Create build vectors with fewer rows to ensure some left rows don't match
+  std::vector<RowVectorPtr> buildVectors = makeBatches(2, [&](int32_t batch) {
+    return makeRowVector(
+        {"u0", "u1"},
+        {
+            makeFlatVector<int64_t>(
+                50, [batch](auto row) { return row * 2 + batch; }),
+            makeFlatVector<std::string>(
+                50, [](auto row) { return row % 2 == 0 ? "hello" : "HELLO"; }),
+        });
+  });
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  // Test left join with lower() function in filter - requires precomputation
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .numDrivers(numDrivers_)
+      .probeKeys({"t0"})
+      .probeVectors(std::move(probeVectors))
+      .buildKeys({"u0"})
+      .buildVectors(std::move(buildVectors))
+      .joinType(core::JoinType::kLeft)
+      .joinFilter("lower(t1) = lower(u1)")
+      .joinOutputLayout({"t0", "t1", "u0", "u1"})
+      .referenceQuery(
+          "SELECT t.t0, t.t1, u.u0, u.u1 FROM t LEFT JOIN u "
+          "ON t.t0 = u.u0 AND lower(t.t1) = lower(u.u1)")
+      .run();
+}
+
+// Test inner join with CASE WHEN filter expression that spans both sides.
+// This exercises the filterEvaluator_ path (not AST) because:
+// 1. CASE WHEN (switch) is not natively supported in cuDF AST
+// 2. The expression references columns from both probe and build sides
+TEST_P(MultiThreadedHashJoinTest, innerJoinWithCaseFilterSpanningBothSides) {
+  // Create probe vectors with positive and negative values, including nulls
+  std::vector<RowVectorPtr> probeVectors = makeBatches(3, [&](int32_t batch) {
+    return makeRowVector(
+        {"t0", "t_val"},
+        {
+            makeFlatVector<int64_t>(
+                100, [batch](auto row) { return row + batch * 100; }),
+            makeFlatVector<double>(
+                100,
+                [](auto row) { return static_cast<double>(row) - 50.0; },
+                [](auto row) { return row % 20 == 0; }),
+        });
+  });
+
+  // Create build vectors - u_val is always positive to avoid division issues,
+  // including nulls to test null propagation through apply_boolean_mask
+  std::vector<RowVectorPtr> buildVectors = makeBatches(2, [&](int32_t batch) {
+    return makeRowVector(
+        {"u0", "u_val"},
+        {
+            makeFlatVector<int64_t>(
+                50, [batch](auto row) { return row * 2 + batch * 100; }),
+            makeFlatVector<double>(
+                50,
+                [](auto row) { return static_cast<double>(row) + 1.0; },
+                [](auto row) { return row % 15 == 0; }),
+        });
+  });
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  // CASE WHEN expression spanning both sides:
+  // - CASE WHEN is not AST-supported (triggers precomputation path)
+  // - References t_val (probe) and u_val (build)
+  // - This combination triggers useAstFilter_ = false
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .numDrivers(numDrivers_)
+      .probeKeys({"t0"})
+      .probeVectors(std::move(probeVectors))
+      .buildKeys({"u0"})
+      .buildVectors(std::move(buildVectors))
+      .joinFilter("CASE WHEN t_val > 0.0 THEN t_val / u_val ELSE 0.0 END > 0.5")
+      .joinOutputLayout({"t0", "t_val", "u0", "u_val"})
+      .referenceQuery(
+          "SELECT t.t0, t.t_val, u.u0, u.u_val FROM t, u "
+          "WHERE t.t0 = u.u0 AND "
+          "CASE WHEN t.t_val > 0.0 THEN t.t_val / u.u_val ELSE 0.0 END > 0.5")
       .run();
 }
 
@@ -3376,7 +3990,7 @@ TEST_F(HashJoinTest, memory) {
   EXPECT_GT(40'000'000, params.queryCtx->pool()->stats().cumulativeBytes);
 }
 
-TEST_F(HashJoinTest, lazyVectors) {
+TEST_F(HashJoinTest, DISABLED_lazyVectors) {
   // a dataset of multiple row groups with multiple columns. We create
   // different dictionary wrappings for different columns and load the
   // rows in scope at different times.
@@ -3422,8 +4036,9 @@ TEST_F(HashJoinTest, lazyVectors) {
       }
       std::vector<exec::Split> buildSplits;
       for (int i = 0; i < buildVectors.size(); ++i) {
-        buildSplits.push_back(exec::Split(makeHiveConnectorSplit(
-            tempFiles[probeSplits.size() + i]->getPath())));
+        buildSplits.push_back(
+            exec::Split(makeHiveConnectorSplit(
+                tempFiles[probeSplits.size() + i]->getPath())));
       }
       SplitInput splits;
       splits.emplace(probeScanId, probeSplits);
@@ -3494,7 +4109,7 @@ TEST_F(HashJoinTest, lazyVectors) {
   }
 }
 
-TEST_F(HashJoinTest, lazyVectorNotLoadedInFilter) {
+TEST_F(HashJoinTest, DISABLED_lazyVectorNotLoadedInFilter) {
   // Ensure that if lazy vectors are temporarily wrapped during a filter's
   // execution and remain unloaded, the temporary wrap is promptly
   // discarded. This precaution prevents the generation of the probe's output
@@ -3512,7 +4127,7 @@ TEST_F(HashJoinTest, lazyVectorNotLoadedInFilter) {
       "SELECT t.c1, t.c2 FROM t, u WHERE t.c0 = u.c0");
 }
 
-TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterLeftJoin) {
+TEST_F(HashJoinTest, DISABLED_lazyVectorPartiallyLoadedInFilterLeftJoin) {
   // Test the case where a filter loads a subset of the rows that will be output
   // from a column on the probe side.
 
@@ -3523,10 +4138,9 @@ TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterLeftJoin) {
       "SELECT t.c1, t.c2 FROM t LEFT JOIN u ON t.c0 = u.c0 AND (c1 > 0 AND c2 > 0)");
 }
 
-TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterFullJoin) {
+TEST_F(HashJoinTest, DISABLED_lazyVectorPartiallyLoadedInFilterFullJoin) {
   // Test the case where a filter loads a subset of the rows that will be output
   // from a column on the probe side.
-
   testLazyVectorsWithFilter(
       core::JoinType::kFull,
       "c1 > 0 AND c2 > 0",
@@ -3534,18 +4148,23 @@ TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterFullJoin) {
       "SELECT t.c1, t.c2 FROM t FULL OUTER JOIN u ON t.c0 = u.c0 AND (c1 > 0 AND c2 > 0)");
 }
 
-TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterLeftSemiProject) {
+TEST_F(
+    HashJoinTest,
+    DISABLED_lazyVectorPartiallyLoadedInFilterLeftSemiProject) {
   // Test the case where a filter loads a subset of the rows that will be output
   // from a column on the probe side.
 
-  testLazyVectorsWithFilter(
-      core::JoinType::kLeftSemiProject,
-      "c1 > 0 AND c2 > 0",
-      {"c1", "c2", "match"},
-      "SELECT t.c1, t.c2, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0 AND (t.c1 > 0 AND t.c2 > 0)) FROM t");
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      testLazyVectorsWithFilter(
+          core::JoinType::kLeftSemiProject,
+          "c1 > 0 AND c2 > 0",
+          {"c1", "c2", "match"},
+          "SELECT t.c1, t.c2, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0 AND (t.c1 > 0 AND t.c2 > 0)) FROM t"),
+      "Replacement with cuDF operator failed");
 }
 
-TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterAntiJoin) {
+TEST_F(HashJoinTest, DISABLED_lazyVectorPartiallyLoadedInFilterAntiJoin) {
   // Test the case where a filter loads a subset of the rows that will be output
   // from a column on the probe side.
 
@@ -3556,7 +4175,7 @@ TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterAntiJoin) {
       "SELECT t.c1, t.c2 FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE t.c0 = u.c0 AND (t.c1 > 0 AND t.c2 > 0))");
 }
 
-TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterInnerJoin) {
+TEST_F(HashJoinTest, DISABLED_lazyVectorPartiallyLoadedInFilterInnerJoin) {
   // Test the case where a filter loads a subset of the rows that will be output
   // from a column on the probe side.
 
@@ -3567,7 +4186,7 @@ TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterInnerJoin) {
       "SELECT t.c1, t.c2 FROM t, u WHERE t.c0 = u.c0 AND NOT (c1 < 15 AND c2 >= 0)");
 }
 
-TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterLeftSemiFilter) {
+TEST_F(HashJoinTest, DISABLED_lazyVectorPartiallyLoadedInFilterLeftSemiFilter) {
   // Test the case where a filter loads a subset of the rows that will be output
   // from a column on the probe side.
 
@@ -4610,12 +5229,24 @@ TEST_F(HashJoinTest, DISABLED_dynamicFiltersAppliedToPreloadedSplits) {
     probeVectors.push_back(rowVector);
     tempFiles.push_back(TempFilePath::create());
     writeToFile(tempFiles.back()->getPath(), rowVector);
-    auto split = HiveConnectorSplitBuilder(tempFiles.back()->getPath())
-                     .partitionKey("p1", std::to_string(i))
-                     .build();
-    probeSplits.push_back(exec::Split(split));
   }
 
+  auto makeInputSplits = [&](const core::PlanNodeId& nodeId) {
+    return [&] {
+      std::vector<exec::Split> splits;
+      splits.reserve(tempFiles.size());
+      for (int32_t i = 0; i < tempFiles.size(); ++i) {
+        auto split = HiveConnectorSplitBuilder(tempFiles[i]->getPath())
+                         .partitionKey("p1", std::to_string(i))
+                         .build();
+        splits.emplace_back(exec::Split(split));
+      }
+      SplitInput inputSplits;
+      inputSplits.emplace(nodeId, splits);
+      return inputSplits;
+    };
+  };
+
   auto outputType = ROW({"p0", "p1"}, {BIGINT(), BIGINT()});
   connector::ColumnHandleMap assignments = {
       {"p0", regularColumn("p0", BIGINT())},
@@ -4656,7 +5287,7 @@ TEST_F(HashJoinTest, DISABLED_dynamicFiltersAppliedToPreloadedSplits) {
       .planNode(std::move(op))
       .config(core::QueryConfig::kMaxSplitPreloadPerDriver, "3")
       .injectSpill(false)
-      .inputSplits({{probeScanId, probeSplits}})
+      .makeInputSplits(makeInputSplits(probeScanId))
       .referenceQuery("select p.p0 from p, b where b.b0 = p.p1")
       .checkSpillStats(false)
       .verifier([&](const std::shared_ptr<Task>& task, bool /*hasSpill*/) {
@@ -4718,11 +5349,10 @@ TEST_F(HashJoinTest, DISABLED_dynamicFiltersPushDownThroughAgg) {
                 .capturePlanNodeId(joinNodeId)
                 .planNode();
 
-  SplitInput splitInput = {
-      {scanNodeId, {Split(makeHiveConnectorSplit(probeFile->getPath()))}}};
+  SplitPath splitPaths = {{scanNodeId, {probeFile->getPath()}}};
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .planNode(std::move(op))
-      .inputSplits(splitInput)
+      .inputSplits(splitPaths)
       .injectSpill(false)
       .checkSpillStats(false)
       .referenceQuery("SELECT c0, sum(c1) FROM t, u WHERE c0 = u0 group by c0")
@@ -4742,7 +5372,7 @@ TEST_F(HashJoinTest, DISABLED_dynamicFiltersPushDownThroughAgg) {
       .run();
 }
 
-TEST_F(HashJoinTest, noDynamicFiltersPushDownThroughRightJoin) {
+TEST_F(HashJoinTest, DISABLED_noDynamicFiltersPushDownThroughRightJoin) {
   std::vector<RowVectorPtr> innerBuild = {makeRowVector(
       {"a"},
       {
@@ -4974,7 +5604,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, buildReservationReleaseCheck) {
   // NOTE: the spilling setup is to trigger memory reservation code path which
   // only gets executed when spilling is enabled. We don't care about if
   // spilling is really triggered in test or not.
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
   params.spillDirectory = spillDirectory->getPath();
   params.queryCtx->testingOverrideConfigUnsafe(
       {{core::QueryConfig::kSpillEnabled, "true"},
@@ -4998,7 +5628,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, buildReservationReleaseCheck) {
   ASSERT_TRUE(waitForTaskAborted(task, 5'000'000));
 }
 
-TEST_F(HashJoinTest, dynamicFilterOnPartitionKey) {
+TEST_F(HashJoinTest, DISABLED_dynamicFilterOnPartitionKey) {
   vector_size_t size = 10;
   auto filePaths = makeFilePaths(1);
   auto rowVector = makeRowVector(
@@ -5008,10 +5638,6 @@ TEST_F(HashJoinTest, dynamicFilterOnPartitionKey) {
   std::vector<RowVectorPtr> buildVectors{
       makeRowVector({"c0"}, {makeFlatVector<int64_t>({0, 1, 2})})};
   createDuckDbTable("t", buildVectors);
-  auto split = facebook::velox::exec::test::HiveConnectorSplitBuilder(
-                   filePaths[0]->getPath())
-                   .partitionKey("k", "0")
-                   .build();
   auto outputType = ROW({"n1_0", "n1_1"}, {BIGINT(), BIGINT()});
   connector::ColumnHandleMap assignments = {
       {"n1_0", regularColumn("c0", BIGINT())},
@@ -5035,11 +5661,21 @@ TEST_F(HashJoinTest, dynamicFilterOnPartitionKey) {
               core::JoinType::kInner)
           .project({"c0"})
           .planNode();
-  SplitInput splits = {{probeScanId, {exec::Split(split)}}};
+
+  auto makeInputSplits = [&](const core::PlanNodeId& nodeId) {
+    return [&] {
+      auto split = facebook::velox::exec::test::HiveConnectorSplitBuilder(
+                       filePaths[0]->getPath())
+                       .partitionKey("k", "0")
+                       .build();
+      SplitInput splits = {{nodeId, {exec::Split(split)}}};
+      return splits;
+    };
+  };
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .planNode(std::move(op))
-      .inputSplits(splits)
+      .makeInputSplits(makeInputSplits(probeScanId))
       .referenceQuery("select t.c0 from t, u where t.c0 = 0")
       .checkSpillStats(false)
       .run();
@@ -5186,7 +5822,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringInputProcessing) {
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
 
-    auto tempDirectory = exec::test::TempDirectoryPath::create();
+    auto tempDirectory = TempDirectoryPath::create();
     auto queryPool = memory::memoryManager()->addRootPool(
         "", kMaxBytes, memory::MemoryReclaimer::create());
 
@@ -5336,7 +5972,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringReserve) {
   createDuckDbTable("t", probeVectors);
   createDuckDbTable("u", buildVectors);
 
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  auto tempDirectory = TempDirectoryPath::create();
   auto queryPool = memory::memoryManager()->addRootPool(
       "", kMaxBytes, memory::MemoryReclaimer::create());
 
@@ -5470,7 +6106,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringAllocation) {
   for (const auto enableSpilling : enableSpillings) {
     SCOPED_TRACE(fmt::format("enableSpilling {}", enableSpilling));
 
-    auto tempDirectory = exec::test::TempDirectoryPath::create();
+    auto tempDirectory = TempDirectoryPath::create();
     auto queryPool = memory::memoryManager()->addRootPool("", kMaxBytes);
 
     core::PlanNodeId probeScanId;
@@ -5600,7 +6236,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringOutputProcessing) {
   const std::vector<bool> enableSpillings = {false, true};
   for (const auto enableSpilling : enableSpillings) {
     SCOPED_TRACE(fmt::format("enableSpilling {}", enableSpilling));
-    auto tempDirectory = exec::test::TempDirectoryPath::create();
+    auto tempDirectory = TempDirectoryPath::create();
     auto queryPool = memory::memoryManager()->addRootPool(
         "", kMaxBytes, memory::MemoryReclaimer::create());
 
@@ -5730,7 +6366,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringWaitForProbe) {
   createDuckDbTable("t", probeVectors);
   createDuckDbTable("u", buildVectors);
 
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  auto tempDirectory = TempDirectoryPath::create();
   auto queryPool = memory::memoryManager()->addRootPool(
       "", kMaxBytes, memory::MemoryReclaimer::create());
 
@@ -6189,9 +6825,10 @@ TEST_F(HashJoinTest, leftJoinWithMissAtEndOfBatch) {
         .numDrivers(1)
         .config(
             core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
-        .referenceQuery(fmt::format(
-            "SELECT t_k1, u_k1 from t left join u on t_k1 = u_k1 and {}",
-            filter))
+        .referenceQuery(
+            fmt::format(
+                "SELECT t_k1, u_k1 from t left join u on t_k1 = u_k1 and {}",
+                filter))
         .run();
   };
 
@@ -6240,9 +6877,10 @@ TEST_F(HashJoinTest, leftJoinWithMissAtEndOfBatchMultipleBuildMatches) {
         .numDrivers(1)
         .config(
             core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
-        .referenceQuery(fmt::format(
-            "SELECT t_k1, u_k1 from t left join u on t_k1 = u_k1 and {}",
-            filter))
+        .referenceQuery(
+            fmt::format(
+                "SELECT t_k1, u_k1 from t left join u on t_k1 = u_k1 and {}",
+                filter))
         .run();
   };
 
@@ -6254,7 +6892,7 @@ TEST_F(HashJoinTest, leftJoinWithMissAtEndOfBatchMultipleBuildMatches) {
   test("t_k2 != 4 and t_k2 != 8");
 }
 
-TEST_F(HashJoinTest, leftJoinPreserveProbeOrder) {
+TEST_F(HashJoinTest, DISABLED_leftJoinPreserveProbeOrder) {
   const std::vector<RowVectorPtr> probeVectors = {
       makeRowVector(
           {"k1", "v1"},
@@ -6327,8 +6965,9 @@ DEBUG_ONLY_TEST_F(HashJoinTest, minSpillableMemoryReservation) {
                   .planNode();
 
   for (int32_t minSpillableReservationPct : {5, 50, 100}) {
-    SCOPED_TRACE(fmt::format(
-        "minSpillableReservationPct: {}", minSpillableReservationPct));
+    SCOPED_TRACE(
+        fmt::format(
+            "minSpillableReservationPct: {}", minSpillableReservationPct));
 
     SCOPED_TESTVALUE_SET(
         "facebook::velox::exec::HashBuild::addInput",
@@ -6342,7 +6981,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, minSpillableMemoryReservation) {
               currentUsedBytes * minSpillableReservationPct / 100);
         })));
 
-    auto tempDirectory = exec::test::TempDirectoryPath::create();
+    auto tempDirectory = TempDirectoryPath::create();
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
         .planNode(plan)
@@ -6384,9 +7023,9 @@ DEBUG_ONLY_TEST_F(HashJoinTest, exceededMaxSpillLevel) {
                       concat(probeType_->names(), buildType_->names()))
                   .planNode();
 
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  auto tempDirectory = TempDirectoryPath::create();
   const int exceededMaxSpillLevelCount =
-      common::globalSpillStats().spillMaxLevelExceededCount;
+      exec::globalSpillStats().spillMaxLevelExceededCount;
   SCOPED_TESTVALUE_SET(
       "facebook::velox::exec::HashBuild::reclaim",
       std::function<void(exec::Operator*)>(([&](exec::Operator* op) {
@@ -6419,28 +7058,28 @@ DEBUG_ONLY_TEST_F(HashJoinTest, exceededMaxSpillLevel) {
         auto opStats = toOperatorStats(task->taskStats());
         ASSERT_EQ(
             opStats.at("HashProbe")
-                .runtimeStats[Operator::kExceededMaxSpillLevel]
+                .runtimeStats[std::string(Operator::kExceededMaxSpillLevel)]
                 .sum,
             8);
         ASSERT_EQ(
             opStats.at("HashProbe")
-                .runtimeStats[Operator::kExceededMaxSpillLevel]
+                .runtimeStats[std::string(Operator::kExceededMaxSpillLevel)]
                 .count,
             1);
         ASSERT_EQ(
             opStats.at("HashBuild")
-                .runtimeStats[Operator::kExceededMaxSpillLevel]
+                .runtimeStats[std::string(Operator::kExceededMaxSpillLevel)]
                 .sum,
             8);
         ASSERT_EQ(
             opStats.at("HashBuild")
-                .runtimeStats[Operator::kExceededMaxSpillLevel]
+                .runtimeStats[std::string(Operator::kExceededMaxSpillLevel)]
                 .count,
             1);
       })
       .run();
   ASSERT_EQ(
-      common::globalSpillStats().spillMaxLevelExceededCount,
+      exec::globalSpillStats().spillMaxLevelExceededCount,
       exceededMaxSpillLevelCount + 16);
 }
 
@@ -6467,7 +7106,7 @@ TEST_F(HashJoinTest, DISABLED_maxSpillBytes) {
                       core::JoinType::kInner)
                   .planNode();
 
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
   auto queryCtx = core::QueryCtx::create(executor_.get());
 
   struct {
@@ -6524,7 +7163,7 @@ TEST_F(HashJoinTest, DISABLED_onlyHashBuildMaxSpillBytes) {
                       core::JoinType::kInner)
                   .planNode();
 
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
   auto queryCtx = core::QueryCtx::create(executor_.get());
 
   struct {
@@ -6743,7 +7382,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringTableBuild) {
         testingRunArbitration(op->pool());
       }));
 
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  auto tempDirectory = TempDirectoryPath::create();
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(4)
       .planNode(plan)
@@ -6756,7 +7395,9 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringTableBuild) {
       .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
         auto opStats = toOperatorStats(task->taskStats());
         ASSERT_GT(
-            opStats.at("HashBuild").runtimeStats[Operator::kSpillWrites].sum,
+            opStats.at("HashBuild")
+                .runtimeStats[std::string(Operator::kSpillWrites)]
+                .sum,
             0);
       })
       .run();
@@ -6812,7 +7453,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, exceptionDuringFinishJoinBuild) {
   std::vector<RowVectorPtr> probeInput = {probeSideVector};
   std::vector<RowVectorPtr> buildInput = {buildSideVector};
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  const auto spillDirectory = TempDirectoryPath::create();
 
   ASSERT_EQ(arbitrator->stats().freeCapacityBytes, expectedFreeCapacityBytes);
   VELOX_ASSERT_THROW(
@@ -6927,7 +7568,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, arbitrationTriggeredDuringParallelJoinBuild) {
   std::vector<RowVectorPtr> probeInput = {probeSideVector};
   std::vector<RowVectorPtr> buildInput = {buildSideVector};
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  const auto spillDirectory = TempDirectoryPath::create();
   AssertQueryBuilder(duckDbQueryRunner_)
       .spillDirectory(spillDirectory->getPath())
       .config(core::QueryConfig::kSpillEnabled, true)
@@ -6972,7 +7613,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, arbitrationTriggeredByEnsureJoinTableFit) {
         Operator::ReclaimableSectionGuard guard(op);
         memory::testingRunArbitration(op->pool());
       })));
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  auto tempDirectory = TempDirectoryPath::create();
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
       .injectSpill(false)
@@ -7020,7 +7661,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, joinBuildSpillError) {
       }));
 
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  const auto spillDirectory = TempDirectoryPath::create();
   auto plan = PlanBuilder(planNodeIdGenerator)
                   .values(vectors)
                   .project({"c0 AS t0", "c1 AS t1", "c2 AS t2"})
@@ -7122,7 +7763,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, probeSpillOnWaitForPeers) {
     totalVectors.insert(totalVectors.end(), vectors.begin(), vectors.end());
   }
   createDuckDbTable(totalVectors);
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   auto plan = PlanBuilder(planNodeIdGenerator)
                   .values(vectors, true)
@@ -7323,7 +7964,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpill) {
     fuzzerOpts_.vectorSize = 128;
     auto probeVectors = createVectors(10, probeType_, fuzzerOpts_);
     auto buildVectors = createVectors(20, buildType_, fuzzerOpts_);
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto spillDirectory = TempDirectoryPath::create();
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(1)
         .spillDirectory(spillDirectory->getPath())
@@ -7379,7 +8020,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillInMiddeOfLastOutputProcessing) {
   auto probeVectors = createVectors(10, probeType_, fuzzerOpts_);
   auto buildVectors = createVectors(20, buildType_, fuzzerOpts_);
 
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  const auto spillDirectory = TempDirectoryPath::create();
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(1)
       .spillDirectory(spillDirectory->getPath())
@@ -7452,7 +8093,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillInMiddeOfOutputProcessing) {
     auto probeVectors = createVectors(10, probeType_, fuzzerOpts_);
     auto buildVectors = createVectors(20, buildType_, fuzzerOpts_);
 
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto spillDirectory = TempDirectoryPath::create();
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(1)
         .spillDirectory(spillDirectory->getPath())
@@ -7510,7 +8151,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillWhenOneOfProbeFinish) {
       }));
 
   std::thread queryThread([&]() {
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto spillDirectory = TempDirectoryPath::create();
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers, true, true)
         .spillDirectory(spillDirectory->getPath())
@@ -7561,7 +8202,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillExceedLimit) {
           buildVectors[i]->childAt(buildKeyChannle);
     }
 
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto spillDirectory = TempDirectoryPath::create();
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(1)
         .spillDirectory(spillDirectory->getPath())
@@ -7593,12 +8234,12 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillExceedLimit) {
           }
           ASSERT_GT(
               opStats.at("HashProbe")
-                  .runtimeStats[Operator::kExceededMaxSpillLevel]
+                  .runtimeStats[std::string(Operator::kExceededMaxSpillLevel)]
                   .sum,
               0);
           ASSERT_GT(
               opStats.at("HashBuild")
-                  .runtimeStats[Operator::kExceededMaxSpillLevel]
+                  .runtimeStats[std::string(Operator::kExceededMaxSpillLevel)]
                   .sum,
               0);
         })
@@ -7628,7 +8269,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillUnderNonReclaimableSection) {
             numNonReclaimableAttempts + 1);
       }));
 
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  const auto spillDirectory = TempDirectoryPath::create();
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(1)
       .spillDirectory(spillDirectory->getPath())
@@ -7683,7 +8324,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, spillOutputWithRightSemiJoins) {
       joinOutputLayout = {"u_k2"};
     }
 
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto spillDirectory = TempDirectoryPath::create();
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(1)
         .spillDirectory(spillDirectory->getPath())
@@ -7801,7 +8442,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, spillCheckOnLeftSemiFilterWithDynamicFilters) {
         testingRunArbitration(op->pool());
       }));
 
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .planNode(std::move(op))
       .makeInputSplits(makeInputSplits(probeScanId))
@@ -7843,7 +8484,7 @@ DEBUG_ONLY_TEST_F(
         ASSERT_EQ(op->pool()->reservedBytes(), 0);
       })));
 
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  const auto spillDirectory = TempDirectoryPath::create();
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(1)
       .spillDirectory(spillDirectory->getPath())
@@ -7941,7 +8582,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, spillOnBlockedProbe) {
   std::vector<RowVectorPtr> vectors = createVectors(1, rowType, fuzzerOpts_);
   createDuckDbTable(vectors);
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  const auto spillDirectory = TempDirectoryPath::create();
   auto plan = PlanBuilder(planNodeIdGenerator)
                   .values(vectors)
                   .project({"c0 AS t0", "c1 AS t1"})
@@ -8007,7 +8648,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, buildReclaimedMemoryReport) {
   createDuckDbTable("t", totalProbeVectors);
   createDuckDbTable("u", totalBuildVectors);
 
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  auto tempDirectory = TempDirectoryPath::create();
   auto queryPool = memory::memoryManager()->addRootPool(
       "", kMaxBytes, memory::MemoryReclaimer::create());
 
@@ -8124,7 +8765,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, probeReclaimedMemoryReport) {
   createDuckDbTable("t", probeVectors);
   createDuckDbTable("u", buildVectors);
 
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  auto tempDirectory = TempDirectoryPath::create();
   auto queryPool = memory::memoryManager()->addRootPool(
       "", kMaxBytes, memory::MemoryReclaimer::create());
 
@@ -8249,7 +8890,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashTableCleanupAfterProbeFinish) {
                   .project({"t_k1", "t_k2", "t_v1", "u_k1", "u_k2", "u_v1"})
                   .planNode();
 
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  auto tempDirectory = TempDirectoryPath::create();
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(1)
       .planNode(plan)
@@ -8262,4 +8903,22 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashTableCleanupAfterProbeFinish) {
   ASSERT_TRUE(tableEmpty);
 }
 
+TEST_F(HashJoinTest, emptyBuildWithDebugEnabled) {
+  cudf_velox::CudfConfig::getInstance().debugEnabled = true;
+  SCOPE_EXIT {
+    cudf_velox::CudfConfig::getInstance().debugEnabled = false;
+  };
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .numDrivers(1)
+      .keyTypes({BIGINT()})
+      .probeVectors(100, 5)
+      .buildVectors(0, 5)
+      .referenceQuery(
+          "SELECT t_k0, t_data, u_k0, u_data FROM t, u WHERE t_k0 = u_k0")
+      .checkSpillStats(false)
+      .run();
+}
+
 } // namespace
diff --git a/velox/experimental/cudf/tests/InteropTest.cpp b/velox/experimental/cudf/tests/InteropTest.cpp
new file mode 100644
index 00000000000..7987d990b55
--- /dev/null
+++ b/velox/experimental/cudf/tests/InteropTest.cpp
@@ -0,0 +1,454 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+using namespace facebook::velox::cudf_velox;
+
+namespace {
+
+/// Tests the direct toCudfTable conversion (bypassing Arrow) by round-tripping
+/// Velox RowVector -> cudf table (direct) -> Velox RowVector (via Arrow) and
+/// verifying the result matches the original.
+class InteropTest : public ::testing::Test, public VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  /// Round-trips a RowVector through the direct toCudfTable and back via
+  /// with_arrow::toVeloxColumn, then asserts equality with the original.
+  void roundTrip(const RowVectorPtr& input) {
+    auto stream = cudf::get_default_stream();
+    auto mr = cudf::get_current_device_resource_ref();
+
+    // Convert Velox -> cudf using the new direct path.
+    // auto cudfTable = cudf_velox::toCudfTable(input, pool_.get(), stream, mr);
+    auto cudfTable =
+        cudf_velox::with_arrow::toCudfTable(input, pool_.get(), stream, mr);
+    ASSERT_NE(cudfTable, nullptr);
+    ASSERT_EQ(cudfTable->num_rows(), input->size());
+    ASSERT_EQ(
+        cudfTable->num_columns(),
+        static_cast<cudf::size_type>(input->childrenSize()));
+
+    // Convert cudf -> Velox using the existing Arrow path.
+    auto result = cudf_velox::with_arrow::toVeloxColumn(
+        cudfTable->view(), pool_.get(), input->type(), stream, mr);
+    stream.synchronize();
+
+    // Verify.
+    test::assertEqualVectors(input, result);
+  }
+};
+
+// ========== Integer types ==========
+
+TEST_F(InteropTest, tinyint) {
+  auto input =
+      makeRowVector({"c0"}, {makeFlatVector<int8_t>({1, -2, 3, 0, 127, -128})});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, smallint) {
+  auto input = makeRowVector(
+      {"c0"}, {makeFlatVector<int16_t>({1, -2, 300, 0, 32767, -32768})});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, integer) {
+  auto input = makeRowVector(
+      {"c0"},
+      {makeFlatVector<int32_t>({1, -2, 300, 0, 2147483647, -2147483648})});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, bigint) {
+  auto input = makeRowVector(
+      {"c0"},
+      {makeFlatVector<int64_t>({1, -2, 300, 0, 9223372036854775807LL})});
+  roundTrip(input);
+}
+
+// ========== Floating point types ==========
+
+TEST_F(InteropTest, real) {
+  auto input = makeRowVector(
+      {"c0"}, {makeFlatVector<float>({1.5f, -2.5f, 0.0f, 3.14f})});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, double_type) {
+  auto input = makeRowVector(
+      {"c0"}, {makeFlatVector<double>({1.5, -2.5, 0.0, 3.14159265358979})});
+  roundTrip(input);
+}
+
+// ========== Boolean ==========
+
+TEST_F(InteropTest, boolean) {
+  auto input = makeRowVector(
+      {"c0"}, {makeFlatVector<bool>({true, false, true, true, false})});
+  roundTrip(input);
+}
+
+// ========== String types ==========
+
+TEST_F(InteropTest, varchar) {
+  auto input = makeRowVector(
+      {"c0"},
+      {makeFlatVector<StringView>(
+          {"hello", "world", "", "a longer string value", "x"})});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, varbinary) {
+  auto input = makeRowVector(
+      {"c0"},
+      {makeFlatVector<StringView>({"binary\x00data"_sv, "more"_sv, ""_sv})});
+  roundTrip(input);
+}
+
+// ========== With nulls ==========
+
+TEST_F(InteropTest, integerWithNulls) {
+  auto input = makeRowVector(
+      {"c0"},
+      {makeNullableFlatVector<int32_t>({1, std::nullopt, 3, std::nullopt, 5})});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, booleanWithNulls) {
+  auto input = makeRowVector(
+      {"c0"},
+      {makeNullableFlatVector<bool>(
+          {true, std::nullopt, false, std::nullopt, true})});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, varcharWithNulls) {
+  auto input = makeRowVector(
+      {"c0"},
+      {makeNullableFlatVector<StringView>(
+          {"hello"_sv, std::nullopt, "world"_sv, std::nullopt})});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, doubleWithNulls) {
+  auto input = makeRowVector(
+      {"c0"},
+      {makeNullableFlatVector<double>(
+          {1.1, std::nullopt, 3.3, std::nullopt, 5.5})});
+  roundTrip(input);
+}
+
+// ========== Timestamp ==========
+
+TEST_F(InteropTest, timestamp) {
+  auto input = makeRowVector(
+      {"c0"},
+      {makeFlatVector<Timestamp>(
+          {Timestamp(0, 0),
+           Timestamp(1, 500000000),
+           Timestamp(100, 0),
+           Timestamp(1000000, 999999999)})});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, timestampWithNulls) {
+  auto input = makeRowVector(
+      {"c0"},
+      {makeNullableFlatVector<Timestamp>(
+          {Timestamp(0, 0), std::nullopt, Timestamp(100, 0), std::nullopt})});
+  roundTrip(input);
+}
+
+// ========== Multiple columns ==========
+
+TEST_F(InteropTest, multipleColumns) {
+  auto input = makeRowVector(
+      {"c0", "c1", "c2", "c3"},
+      {makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+       makeFlatVector<double>({1.1, 2.2, 3.3, 4.4, 5.5}),
+       makeFlatVector<bool>({true, false, true, false, true}),
+       makeFlatVector<StringView>({"a", "bb", "ccc", "dddd", "eeeee"})});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, multipleColumnsWithNulls) {
+  auto input = makeRowVector(
+      {"c0", "c1", "c2"},
+      {makeNullableFlatVector<int64_t>({1, std::nullopt, 3, std::nullopt, 5}),
+       makeNullableFlatVector<StringView>(
+           {"a"_sv, "b"_sv, std::nullopt, "d"_sv, std::nullopt}),
+       makeNullableFlatVector<bool>(
+           {true, std::nullopt, false, std::nullopt, true})});
+  roundTrip(input);
+}
+
+// ========== Empty input ==========
+
+TEST_F(InteropTest, emptyInput) {
+  auto input = makeRowVector(
+      {"c0", "c1"},
+      {makeFlatVector<int32_t>({}), makeFlatVector<StringView>({})});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, emptyBoolean) {
+  auto input = makeRowVector({"c0"}, {makeFlatVector<bool>({})});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, emptyDouble) {
+  auto input = makeRowVector({"c0"}, {makeFlatVector<double>({})});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, emptyTimestamp) {
+  auto input = makeRowVector({"c0"}, {makeFlatVector<Timestamp>({})});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, emptyArray) {
+  auto input = makeRowVector({"c0"}, {makeArrayVector<int32_t>({})});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, emptyStruct) {
+  auto structVector = makeRowVector(
+      {makeFlatVector<int32_t>({}), makeFlatVector<StringView>({})});
+  auto input = makeRowVector({"c0"}, {structVector});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, emptyMultipleColumns) {
+  auto input = makeRowVector(
+      {"c0", "c1", "c2", "c3"},
+      {makeFlatVector<int64_t>({}),
+       makeFlatVector<bool>({}),
+       makeFlatVector<StringView>({}),
+       makeArrayVector<int32_t>({})});
+  roundTrip(input);
+}
+
+// ========== All nulls ==========
+
+TEST_F(InteropTest, allNulls) {
+  auto input = makeRowVector(
+      {"c0"},
+      {makeNullableFlatVector<int32_t>(
+          {std::nullopt, std::nullopt, std::nullopt})});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, allNullsString) {
+  auto input = makeRowVector(
+      {"c0"},
+      {makeNullableFlatVector<StringView>(
+          {std::nullopt, std::nullopt, std::nullopt})});
+  roundTrip(input);
+}
+
+// ========== ARRAY (LIST) types ==========
+
+TEST_F(InteropTest, arrayOfIntegers) {
+  auto input = makeRowVector(
+      {"c0"},
+      {makeArrayVector<int32_t>({
+          {1, 2, 3},
+          {4, 5},
+          {6},
+          {},
+          {7, 8, 9, 10},
+      })});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, arrayOfStrings) {
+  auto input = makeRowVector(
+      {"c0"},
+      {makeArrayVector<StringView>({
+          {"hello"_sv, "world"_sv},
+          {},
+          {"foo"_sv, "bar"_sv, "baz"_sv},
+      })});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, arrayOfDoubles) {
+  auto input = makeRowVector(
+      {"c0"},
+      {makeArrayVector<double>({
+          {1.1, 2.2, 3.3},
+          {},
+          {4.4},
+      })});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, arrayWithNulls) {
+  // Array column with some null array entries.
+  auto elements =
+      makeNullableFlatVector<int32_t>({1, 2, std::nullopt, 4, 5, std::nullopt});
+  auto offsets = makeIndices({0, 3, 3, 3});
+  auto sizes = makeIndices({3, 0, 3, 0});
+  auto arrayVector = std::make_shared<ArrayVector>(
+      pool_.get(),
+      ARRAY(INTEGER()),
+      makeNulls({false, true, false, true}),
+      4,
+      offsets,
+      sizes,
+      elements);
+
+  auto input = makeRowVector({"c0"}, {arrayVector});
+  roundTrip(input);
+}
+
+// ========== ROW (STRUCT) types ==========
+
+TEST_F(InteropTest, structSimple) {
+  auto structVector = makeRowVector(
+      {makeFlatVector<int32_t>({1, 2, 3, 4}),
+       makeFlatVector<StringView>({"a"_sv, "b"_sv, "c"_sv, "d"_sv})});
+  auto input = makeRowVector({"c0"}, {structVector});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, structWithNulls) {
+  auto structVector = makeRowVector(
+      {makeNullableFlatVector<int32_t>({1, std::nullopt, 3, std::nullopt}),
+       makeNullableFlatVector<double>({1.1, 2.2, std::nullopt, 4.4})},
+      // Null the struct itself at row 1.
+      [](auto row) { return row == 1; });
+  auto input = makeRowVector({"c0"}, {structVector});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, structMultipleFields) {
+  auto structVector = makeRowVector(
+      {makeFlatVector<int64_t>({10, 20, 30}),
+       makeFlatVector<bool>({true, false, true}),
+       makeFlatVector<StringView>({"x"_sv, "y"_sv, "z"_sv})});
+  auto input = makeRowVector({"c0"}, {structVector});
+  roundTrip(input);
+}
+
+// ========== Nested complex types ==========
+
+TEST_F(InteropTest, arrayOfArrays) {
+  // Build ARRAY(ARRAY(INTEGER)).
+  auto innerArray = makeArrayVector<int32_t>({
+      {1, 2},
+      {3},
+      {4, 5, 6},
+      {},
+      {7},
+  });
+  auto outerOffsets = makeIndices({0, 2, 2, 3});
+  auto outerSizes = makeIndices({2, 0, 2, 1});
+  auto outerArray = std::make_shared<ArrayVector>(
+      pool_.get(),
+      ARRAY(ARRAY(INTEGER())),
+      nullptr,
+      4,
+      outerOffsets,
+      outerSizes,
+      innerArray);
+
+  auto input = makeRowVector({"c0"}, {outerArray});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, structWithArray) {
+  auto arrayChild = makeArrayVector<int32_t>({
+      {1, 2, 3},
+      {4, 5},
+      {6},
+  });
+  auto intChild = makeFlatVector<int64_t>({10, 20, 30});
+  auto structVector = makeRowVector({intChild, arrayChild});
+  auto input = makeRowVector({"c0"}, {structVector});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, arrayOfStructs) {
+  auto structElements = makeRowVector(
+      {makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+       makeFlatVector<StringView>({"a"_sv, "b"_sv, "c"_sv, "d"_sv, "e"_sv})});
+  auto offsets = makeIndices({0, 2, 2});
+  auto sizes = makeIndices({2, 0, 3});
+  auto arrayVector = std::make_shared<ArrayVector>(
+      pool_.get(),
+      ARRAY(ROW({INTEGER(), VARCHAR()})),
+      nullptr,
+      3,
+      offsets,
+      sizes,
+      structElements);
+
+  auto input = makeRowVector({"c0"}, {arrayVector});
+  roundTrip(input);
+}
+
+// ========== Mixed complex and scalar columns ==========
+
+TEST_F(InteropTest, mixedScalarAndArray) {
+  auto input = makeRowVector(
+      {"c0", "c1", "c2"},
+      {makeFlatVector<int32_t>({1, 2, 3}),
+       makeArrayVector<int64_t>({
+           {10, 20},
+           {30},
+           {40, 50, 60},
+       }),
+       makeFlatVector<StringView>({"a"_sv, "b"_sv, "c"_sv})});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, mixedScalarAndStruct) {
+  auto structChild = makeRowVector(
+      {makeFlatVector<int32_t>({1, 2, 3}),
+       makeFlatVector<double>({1.1, 2.2, 3.3})});
+  auto input = makeRowVector(
+      {"c0", "c1"},
+      {makeFlatVector<StringView>({"x"_sv, "y"_sv, "z"_sv}), structChild});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, dictionary) {
+  constexpr int kSize = 10;
+  auto baseValues = makeFlatVector<int64_t>({10, 20, 30, 40, 50});
+  // Create indices that map to the base values
+  auto indices = makeIndices(kSize, [](auto i) { return i % 5; });
+  auto dictionaryChild =
+      BaseVector::wrapInDictionary(nullptr, indices, kSize, baseValues);
+  auto input = makeRowVector({dictionaryChild});
+  roundTrip(input);
+}
+
+TEST_F(InteropTest, constant) {
+  auto child = makeConstant<int64_t>(10, 5);
+  auto input = makeRowVector({child});
+  roundTrip(input);
+}
+
+} // namespace
diff --git a/velox/experimental/cudf/tests/LocalPartitionTest.cpp b/velox/experimental/cudf/tests/LocalPartitionTest.cpp
index 39136cc5f7c..36efa27472b 100644
--- a/velox/experimental/cudf/tests/LocalPartitionTest.cpp
+++ b/velox/experimental/cudf/tests/LocalPartitionTest.cpp
@@ -23,6 +23,7 @@
 #include "velox/exec/tests/utils/PlanBuilder.h"
 
 namespace facebook::velox::exec::test {
+using namespace facebook::velox::common::testutil;
 namespace {
 
 class LocalPartitionTest : public HiveConnectorTestBase {
diff --git a/velox/experimental/cudf/tests/MarkDistinctTest.cpp b/velox/experimental/cudf/tests/MarkDistinctTest.cpp
new file mode 100644
index 00000000000..3c0ad767236
--- /dev/null
+++ b/velox/experimental/cudf/tests/MarkDistinctTest.cpp
@@ -0,0 +1,281 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+class CudfMarkDistinctTest : public HiveConnectorTestBase {
+ protected:
+  void SetUp() override {
+    HiveConnectorTestBase::SetUp();
+    cudf_velox::CudfConfig::getInstance().allowCpuFallback = false;
+    cudf_velox::registerCudf();
+  }
+
+  void TearDown() override {
+    cudf_velox::unregisterCudf();
+    HiveConnectorTestBase::TearDown();
+  }
+};
+
+// Test 1: Single batch, all distinct keys -> all markers true
+TEST_F(CudfMarkDistinctTest, allDistinct) {
+  auto input = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+  });
+
+  auto expectedMarkers = makeFlatVector<bool>({true, true, true, true, true});
+  auto expected = makeRowVector({input->childAt(0), expectedMarkers});
+
+  auto plan =
+      PlanBuilder().values({input}).markDistinct("m", {"c0"}).planNode();
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+  assertEqualVectors(expected, result);
+}
+
+// Test 2: Single batch, duplicate keys -> first occurrence true, rest false
+TEST_F(CudfMarkDistinctTest, duplicateKeys) {
+  // key: 1, 2, 1, 2, 3 -> first occurrences at indices 0, 1, 4
+  auto input = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 1, 2, 3}),
+      makeFlatVector<int32_t>({10, 20, 30, 40, 50}),
+  });
+
+  auto expectedMarkers = makeFlatVector<bool>({true, true, false, false, true});
+  auto expected =
+      makeRowVector({input->childAt(0), input->childAt(1), expectedMarkers});
+
+  auto plan =
+      PlanBuilder().values({input}).markDistinct("m", {"c0"}).planNode();
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+  assertEqualVectors(expected, result);
+}
+
+// Test 3: Two batches - key seen in batch 1 reappears in batch 2 -> false in
+// batch 2
+TEST_F(CudfMarkDistinctTest, multiBatch) {
+  auto batch1 = makeRowVector({makeFlatVector<int32_t>({1, 2, 3})});
+  auto batch2 = makeRowVector({makeFlatVector<int32_t>({3, 4, 1})});
+
+  // batch1: all first occurrences -> [T, T, T]
+  // batch2: 3 seen -> F, 4 new -> T, 1 seen -> F
+
+  auto plan = PlanBuilder()
+                  .values({batch1, batch2})
+                  .markDistinct("m", {"c0"})
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+
+  // Result should have 6 rows total; check markers
+  ASSERT_EQ(6, result->size());
+  auto markers = result->childAt(1)->asFlatVector<bool>();
+  ASSERT_NE(nullptr, markers);
+  EXPECT_TRUE(markers->valueAt(0)); // 1: first
+  EXPECT_TRUE(markers->valueAt(1)); // 2: first
+  EXPECT_TRUE(markers->valueAt(2)); // 3: first
+  EXPECT_FALSE(markers->valueAt(3)); // 3: duplicate
+  EXPECT_TRUE(markers->valueAt(4)); // 4: first
+  EXPECT_FALSE(markers->valueAt(5)); // 1: duplicate
+}
+
+// Test 4: BIGINT key column (matches Q16/Q28 usage)
+TEST_F(CudfMarkDistinctTest, bigintKey) {
+  auto input = makeRowVector({
+      makeFlatVector<int64_t>({100L, 200L, 100L, 300L, 200L}),
+      makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+  });
+
+  auto expectedMarkers = makeFlatVector<bool>({true, true, false, true, false});
+  auto expected =
+      makeRowVector({input->childAt(0), input->childAt(1), expectedMarkers});
+
+  auto plan =
+      PlanBuilder().values({input}).markDistinct("m", {"c0"}).planNode();
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+  assertEqualVectors(expected, result);
+}
+
+// Test 5: Composite key (two columns)
+TEST_F(CudfMarkDistinctTest, compositeKey) {
+  // (c0, c1) composite key: (1,10), (1,20), (2,10), (2,20), (1,10)
+  // First occurrences: rows 0,1,2,3 -> T; row 4 -> F (duplicate of row 0)
+  auto input = makeRowVector({
+      makeFlatVector<int32_t>({1, 1, 2, 2, 1}),
+      makeFlatVector<int32_t>({10, 20, 10, 20, 10}),
+      makeFlatVector<int32_t>({100, 200, 300, 400, 500}),
+  });
+
+  auto expectedMarkers = makeFlatVector<bool>({true, true, true, true, false});
+  auto expected = makeRowVector(
+      {input->childAt(0),
+       input->childAt(1),
+       input->childAt(2),
+       expectedMarkers});
+
+  auto plan =
+      PlanBuilder().values({input}).markDistinct("m", {"c0", "c1"}).planNode();
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+  assertEqualVectors(expected, result);
+}
+
+// Test 6: Compare GPU output with CPU MarkDistinct via assertQuery (DuckDB)
+TEST_F(CudfMarkDistinctTest, allDistinctMatchesDuckDb) {
+  // All distinct - DuckDB SQL can express this simply
+  auto input = makeRowVector({
+      makeFlatVector<int32_t>({10, 20, 30, 40}),
+      makeFlatVector<double>({1.1, 2.2, 3.3, 4.4}),
+  });
+
+  createDuckDbTable({input});
+
+  auto plan =
+      PlanBuilder().values({input}).markDistinct("m", {"c0"}).planNode();
+
+  // All keys are distinct, so all markers are true
+  assertQuery(plan, "SELECT c0, c1, true AS m FROM tmp");
+}
+
+// Test 7: Null handling in keys - nulls are treated as equal
+TEST_F(CudfMarkDistinctTest, nullKeys) {
+  auto input = makeRowVector({
+      makeNullableFlatVector<int32_t>({1, std::nullopt, 2, std::nullopt, 1}),
+      makeFlatVector<int32_t>({10, 20, 30, 40, 50}),
+  });
+
+  // First occurrences: 1 at row 0, null at row 1, 2 at row 2
+  // Duplicates: null at row 3, 1 at row 4
+  auto expectedMarkers = makeFlatVector<bool>({true, true, true, false, false});
+  auto expected =
+      makeRowVector({input->childAt(0), input->childAt(1), expectedMarkers});
+
+  auto plan =
+      PlanBuilder().values({input}).markDistinct("m", {"c0"}).planNode();
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+  assertEqualVectors(expected, result);
+}
+
+// Test 8: VARCHAR/string keys
+TEST_F(CudfMarkDistinctTest, stringKeys) {
+  auto input = makeRowVector({
+      makeFlatVector<std::string>(
+          {"apple", "banana", "apple", "cherry", "banana"}),
+      makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+  });
+
+  auto expectedMarkers = makeFlatVector<bool>({true, true, false, true, false});
+  auto expected =
+      makeRowVector({input->childAt(0), input->childAt(1), expectedMarkers});
+
+  auto plan =
+      PlanBuilder().values({input}).markDistinct("m", {"c0"}).planNode();
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+  assertEqualVectors(expected, result);
+}
+
+// Test 9: Three or more batches to verify state accumulation
+TEST_F(CudfMarkDistinctTest, threeBatches) {
+  auto batch1 = makeRowVector({makeFlatVector<int32_t>({1, 2})});
+  auto batch2 = makeRowVector({makeFlatVector<int32_t>({3, 1})});
+  auto batch3 = makeRowVector({makeFlatVector<int32_t>({2, 4, 3})});
+
+  // batch1: 1 -> T, 2 -> T
+  // batch2: 3 -> T, 1 -> F (seen in batch1)
+  // batch3: 2 -> F (seen in batch1), 4 -> T, 3 -> F (seen in batch2)
+
+  auto plan = PlanBuilder()
+                  .values({batch1, batch2, batch3})
+                  .markDistinct("m", {"c0"})
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+
+  ASSERT_EQ(7, result->size());
+  auto markers = result->childAt(1)->asFlatVector<bool>();
+  EXPECT_TRUE(markers->valueAt(0)); // 1: first
+  EXPECT_TRUE(markers->valueAt(1)); // 2: first
+  EXPECT_TRUE(markers->valueAt(2)); // 3: first
+  EXPECT_FALSE(markers->valueAt(3)); // 1: duplicate
+  EXPECT_FALSE(markers->valueAt(4)); // 2: duplicate
+  EXPECT_TRUE(markers->valueAt(5)); // 4: first
+  EXPECT_FALSE(markers->valueAt(6)); // 3: duplicate
+}
+
+// Test 10: All duplicates - every row in batch 2 is a duplicate
+TEST_F(CudfMarkDistinctTest, allDuplicates) {
+  auto batch1 = makeRowVector({makeFlatVector<int32_t>({1, 2, 3})});
+  auto batch2 = makeRowVector({makeFlatVector<int32_t>({2, 1, 3, 1})});
+
+  // batch1: all first -> [T, T, T]
+  // batch2: all duplicates -> [F, F, F, F]
+
+  auto plan = PlanBuilder()
+                  .values({batch1, batch2})
+                  .markDistinct("m", {"c0"})
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+
+  ASSERT_EQ(7, result->size());
+  auto markers = result->childAt(1)->asFlatVector<bool>();
+  EXPECT_TRUE(markers->valueAt(0)); // 1: first
+  EXPECT_TRUE(markers->valueAt(1)); // 2: first
+  EXPECT_TRUE(markers->valueAt(2)); // 3: first
+  EXPECT_FALSE(markers->valueAt(3)); // 2: duplicate
+  EXPECT_FALSE(markers->valueAt(4)); // 1: duplicate
+  EXPECT_FALSE(markers->valueAt(5)); // 3: duplicate
+  EXPECT_FALSE(markers->valueAt(6)); // 1: duplicate
+}
+
+// Test: Empty batch handling
+TEST_F(CudfMarkDistinctTest, emptyBatch) {
+  // First batch has data, second batch is empty, third has data
+  auto batch1 = makeRowVector({makeFlatVector<int32_t>({1, 2})});
+  auto emptyBatch = makeRowVector({makeFlatVector<int32_t>({})});
+  auto batch3 = makeRowVector({makeFlatVector<int32_t>({2, 3})});
+
+  auto plan = PlanBuilder()
+                  .values({batch1, emptyBatch, batch3})
+                  .markDistinct("m", {"c0"})
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+
+  // Result should have 4 rows (2 + 0 + 2)
+  ASSERT_EQ(4, result->size());
+  auto markers = result->childAt(1)->asFlatVector<bool>();
+  EXPECT_TRUE(markers->valueAt(0)); // 1: first
+  EXPECT_TRUE(markers->valueAt(1)); // 2: first
+  // Empty batch contributes nothing
+  EXPECT_FALSE(markers->valueAt(2)); // 2: duplicate
+  EXPECT_TRUE(markers->valueAt(3)); // 3: first
+}
diff --git a/velox/experimental/cudf/tests/NestedLoopJoinTest.cpp b/velox/experimental/cudf/tests/NestedLoopJoinTest.cpp
new file mode 100644
index 00000000000..d4e455c1c9c
--- /dev/null
+++ b/velox/experimental/cudf/tests/NestedLoopJoinTest.cpp
@@ -0,0 +1,1597 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/exec/ToCudf.h"
+
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+class CudfNestedLoopJoinTest : public HiveConnectorTestBase {
+ protected:
+  void SetUp() override {
+    HiveConnectorTestBase::SetUp();
+    cudf_velox::registerCudf();
+  }
+
+  void TearDown() override {
+    cudf_velox::unregisterCudf();
+    HiveConnectorTestBase::TearDown();
+  }
+
+  template <typename T>
+  VectorPtr sequence(vector_size_t size, T start = 0) {
+    return makeFlatVector<int32_t>(
+        size, [start](auto row) { return start + row; });
+  }
+};
+
+// Test 1: Simple cross join (no filter) - the simplest case
+TEST_F(CudfNestedLoopJoinTest, crossJoin) {
+  // Probe: 3 rows [0, 1, 2]
+  auto probeVectors = {makeRowVector({sequence<int32_t>(3)})};
+
+  // Build: 2 rows [0, 1]
+  auto buildVectors = {makeRowVector({sequence<int32_t>(2)})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      {"c0", "u_c0"})
+                  .planNode();
+
+  // Cross join produces 3 * 2 = 6 rows
+  assertQuery(plan, "SELECT * FROM t, u");
+}
+
+// Test 2: Cross join with empty build side
+TEST_F(CudfNestedLoopJoinTest, crossJoinEmptyBuild) {
+  auto probeVectors = {makeRowVector({sequence<int32_t>(5)})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      {"c0", "u_c0"})
+                  .planNode();
+
+  // Cross join with empty build produces 0 rows
+  assertQuery(plan, "SELECT * FROM t, u");
+}
+
+// Test 3: Cross join with empty probe side
+TEST_F(CudfNestedLoopJoinTest, crossJoinEmptyProbe) {
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({})})};
+  auto buildVectors = {makeRowVector({sequence<int32_t>(5)})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      {"c0", "u_c0"})
+                  .planNode();
+
+  // Cross join with empty probe produces 0 rows
+  assertQuery(plan, "SELECT * FROM t, u");
+}
+
+// Both probe and build sides are empty.
+TEST_F(CudfNestedLoopJoinTest, bothEmpty) {
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({})})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int64_t>({})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      {"c0", "u_c0"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT * FROM t, u");
+}
+
+// Test 4: Cross join with single row build (common pattern: scalar subquery)
+TEST_F(CudfNestedLoopJoinTest, crossJoinSingleRowBuild) {
+  auto probeVectors = {makeRowVector({sequence<int32_t>(100)})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({42})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      {"c0", "u_c0"})
+                  .planNode();
+
+  // 100 probe rows * 1 build row = 100 rows
+  assertQuery(plan, "SELECT * FROM t, u");
+}
+
+// Test 5: Inner join with filter condition
+TEST_F(CudfNestedLoopJoinTest, innerJoinWithFilter) {
+  auto probeVectors = {makeRowVector({sequence<int32_t>(10)})};
+  auto buildVectors = {makeRowVector({sequence<int32_t>(10)})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0", // Filter: probe < build (non-equi join)
+                      {"c0", "u_c0"},
+                      core::JoinType::kInner)
+                  .planNode();
+
+  assertQuery(plan, "SELECT t.c0, u.c0 FROM t INNER JOIN u ON t.c0 < u.c0");
+}
+
+// Test 6: Multiple batches (tests streaming behavior)
+TEST_F(CudfNestedLoopJoinTest, multipleBatches) {
+  std::vector<RowVectorPtr> probeVectors;
+  for (int i = 0; i < 5; ++i) {
+    probeVectors.push_back(makeRowVector({sequence<int32_t>(100, i * 100)}));
+  }
+
+  std::vector<RowVectorPtr> buildVectors;
+  for (int i = 0; i < 3; ++i) {
+    buildVectors.push_back(makeRowVector({sequence<int32_t>(50, i * 50)}));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors)
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors)
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      {"c0", "u_c0"})
+                  .planNode();
+
+  // 500 probe rows * 150 build rows = 75,000 rows
+  assertQuery(plan, "SELECT * FROM t, u");
+}
+
+// Larger cross join (100 x 50 = 5,000 rows) with per-row value verification.
+TEST_F(CudfNestedLoopJoinTest, largerCrossJoin) {
+  constexpr int32_t kProbeRows = 100;
+  constexpr int32_t kBuildRows = 50;
+
+  auto probeVectors = {makeRowVector(
+      {makeFlatVector<int32_t>(kProbeRows, [](auto row) { return row; })})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int64_t>(
+      kBuildRows, [](auto row) { return 1000 + row; })})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      {"c0", "u_c0"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT * FROM t, u");
+}
+
+// Three build batches of varying sizes, verifies build-side concatenation.
+TEST_F(CudfNestedLoopJoinTest, mergeBuildVectors) {
+  std::vector<RowVectorPtr> buildVectors = {
+      makeRowVector({makeFlatVector<int32_t>({1, 2})}),
+      makeRowVector({makeFlatVector<int32_t>({3, 4})}),
+      makeRowVector({makeFlatVector<int32_t>({5, 6, 7})}),
+  };
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({10, 20})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", buildVectors);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors)
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      {"c0", "u_c0"})
+                  .planNode();
+
+  // 2 probe rows * 7 build rows = 14 rows
+  assertQuery(plan, "SELECT * FROM t, u");
+}
+
+// Combined empty scenarios in a single test (ported from CPU
+// NestedLoopJoinTest.emptyBuildOrProbeWithoutFilter).
+TEST_F(CudfNestedLoopJoinTest, emptyBuildOrProbeWithoutFilter) {
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({1, 2, 3})})};
+  auto emptyProbe = {makeRowVector({makeFlatVector<int32_t>({})})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int64_t>({10, 20})})};
+  auto emptyBuild = {makeRowVector({makeFlatVector<int64_t>({})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto makePlan = [](const auto& probe, const auto& build) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    return PlanBuilder(planNodeIdGenerator)
+        .values({probe})
+        .nestedLoopJoin(
+            PlanBuilder(planNodeIdGenerator)
+                .values({build})
+                .project({"c0 AS u_c0"})
+                .planNode(),
+            {"c0", "u_c0"})
+        .planNode();
+  };
+
+  // probe x emptyBuild = 0 rows
+  assertQuery(
+      makePlan(probeVectors, emptyBuild), "SELECT * FROM t WHERE false");
+
+  // emptyProbe x build = 0 rows
+  assertQuery(
+      makePlan(emptyProbe, buildVectors), "SELECT * FROM t WHERE false");
+
+  // emptyProbe x emptyBuild = 0 rows
+  assertQuery(makePlan(emptyProbe, emptyBuild), "SELECT * FROM t WHERE false");
+
+  // probe x build = 6 rows
+  assertQuery(makePlan(probeVectors, buildVectors), "SELECT * FROM t, u");
+}
+
+// Test 10: Multiple column types
+TEST_F(CudfNestedLoopJoinTest, multipleColumnTypes) {
+  auto probeVectors = {makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 3}),
+      makeFlatVector<double>({1.1, 2.2, 3.3}),
+      makeFlatVector<std::string>({"a", "b", "c"}),
+  })};
+
+  auto buildVectors = {makeRowVector({
+      makeFlatVector<int64_t>({10, 20}),
+      makeFlatVector<float>({1.0f, 2.0f}),
+  })};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0", "c1 AS u_c1"})
+                          .planNode(),
+                      {"c0", "c1", "c2", "u_c0", "u_c1"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT * FROM t, u");
+}
+
+// Output column order differs from probe-first/build-second.
+// Verifies name-based column resolution handles arbitrary output layouts.
+TEST_F(CudfNestedLoopJoinTest, reorderedOutputColumns) {
+  auto probeVectors = {makeRowVector(
+      {"p0", "p1"},
+      {
+          makeFlatVector<int32_t>({1, 2}),
+          makeFlatVector<double>({1.5, 2.5}),
+      })};
+
+  auto buildVectors = {makeRowVector(
+      {"b0"},
+      {
+          makeFlatVector<int64_t>({99}),
+      })};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  // Request build column first, then probe columns in reverse order
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .planNode(),
+                      {"b0", "p1", "p0"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT u.b0, t.p1, t.p0 FROM t, u");
+}
+
+// Cross join with null-containing columns on both sides.
+TEST_F(CudfNestedLoopJoinTest, crossJoinWithNulls) {
+  auto probeVectors = {makeRowVector({
+      makeNullableFlatVector<int32_t>({1, std::nullopt, 3}),
+      makeNullableFlatVector<StringView>({"a", "b", std::nullopt}),
+  })};
+
+  auto buildVectors = {makeRowVector({
+      makeNullableFlatVector<int32_t>({std::nullopt, 20}),
+  })};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      {"c0", "c1", "u_c0"})
+                  .planNode();
+
+  // 3 * 2 = 6 rows, nulls preserved
+  assertQuery(plan, "SELECT * FROM t, u");
+}
+
+// Filtered join with null-containing columns.
+// Verifies null comparison semantics: null < X evaluates to null (non-match).
+TEST_F(CudfNestedLoopJoinTest, filteredJoinWithNulls) {
+  auto probeVectors = {makeRowVector({
+      makeNullableFlatVector<int32_t>({1, std::nullopt, 5, 3}),
+  })};
+
+  auto buildVectors = {makeRowVector({
+      makeNullableFlatVector<int32_t>({2, std::nullopt, 4}),
+  })};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "u_c0"},
+                      core::JoinType::kInner)
+                  .planNode();
+
+  // Null comparisons return null (non-match in inner join)
+  assertQuery(plan, "SELECT t.c0, u.c0 FROM t INNER JOIN u ON t.c0 < u.c0");
+}
+
+// Filtered join with empty build side.
+TEST_F(CudfNestedLoopJoinTest, filteredJoinEmptyBuild) {
+  auto probeVectors = {makeRowVector({sequence<int32_t>(5)})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "u_c0"},
+                      core::JoinType::kInner)
+                  .planNode();
+
+  assertQuery(plan, "SELECT t.c0, u.c0 FROM t INNER JOIN u ON t.c0 < u.c0");
+}
+
+// Filtered join with empty probe side.
+TEST_F(CudfNestedLoopJoinTest, filteredJoinEmptyProbe) {
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({})})};
+  auto buildVectors = {makeRowVector({sequence<int32_t>(5)})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "u_c0"},
+                      core::JoinType::kInner)
+                  .planNode();
+
+  assertQuery(plan, "SELECT t.c0, u.c0 FROM t INNER JOIN u ON t.c0 < u.c0");
+}
+
+// Multi-driver build coordination test.
+// Verifies that multiple build operators correctly coordinate via
+// allPeersFinished(). Build side uses parallelizable values (4 drivers each
+// get all vectors), probe side is non-parallelizable (1 driver reads all).
+// Build data is 4x due to driver replication.
+TEST_F(CudfNestedLoopJoinTest, multiDriverBuild) {
+  auto probeVectors = {
+      makeRowVector({sequence<int32_t>(10)}),
+      makeRowVector({sequence<int32_t>(10, 10)}),
+  };
+
+  // Build: 2 values that will be replicated 4x by 4 build drivers.
+  auto buildVectors = {
+      makeRowVector({makeFlatVector<int32_t>({100, 200})}),
+  };
+
+  // DuckDB reference table has the 1x data
+  createDuckDbTable("t", {probeVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  CursorParameters params;
+  params.maxDrivers = 4;
+  params.planNode = PlanBuilder(planNodeIdGenerator)
+                        .values({probeVectors})
+                        .nestedLoopJoin(
+                            PlanBuilder(planNodeIdGenerator)
+                                .values({buildVectors}, true)
+                                .filter("c0 = 100")
+                                .project({"c0 AS u_c0"})
+                                .planNode(),
+                            {"c0", "u_c0"})
+                        .planNode();
+
+  // Build side: 4 drivers × 1 matching row = 4 build rows (all value 100)
+  // Probe side: 1 driver × 20 rows = 20 probe rows
+  // Result: 20 * 4 = 80 rows
+  assertQuery(
+      params,
+      "SELECT * FROM t, "
+      "(SELECT * FROM UNNEST(ARRAY[100, 100, 100, 100]) AS t(c0)) u");
+}
+
+// Multi-driver with filter.
+TEST_F(CudfNestedLoopJoinTest, multiDriverWithFilter) {
+  auto probeVectors = {
+      makeRowVector({makeFlatVector<int32_t>({1, 5, 10})}),
+  };
+
+  auto buildVectors = {
+      makeRowVector({makeFlatVector<int32_t>({3, 7})}),
+  };
+
+  // DuckDB reference table has the 1x data
+  createDuckDbTable("t", {probeVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  CursorParameters params;
+  params.maxDrivers = 2;
+  params.planNode = PlanBuilder(planNodeIdGenerator)
+                        .values({probeVectors})
+                        .nestedLoopJoin(
+                            PlanBuilder(planNodeIdGenerator)
+                                .values({buildVectors}, true)
+                                .project({"c0 AS u_c0"})
+                                .planNode(),
+                            "c0 < u_c0",
+                            {"c0", "u_c0"},
+                            core::JoinType::kInner)
+                        .planNode();
+
+  // Build side: 2 drivers × {3, 7} = {3, 7, 3, 7}
+  // Probe: {1, 5, 10}
+  // Matches (c0 < u_c0): 1<3, 1<7, 5<7, 1<3, 1<7, 5<7 = 6 rows
+  assertQuery(
+      params,
+      "SELECT t.c0, u.c0 FROM t "
+      "INNER JOIN (SELECT * FROM UNNEST(ARRAY[3, 7, 3, 7]) AS t(c0)) u "
+      "ON t.c0 < u.c0");
+}
+
+// All-null columns on both sides.
+TEST_F(CudfNestedLoopJoinTest, allNullColumns) {
+  auto probeVectors = {makeRowVector({
+      makeNullableFlatVector<int32_t>(
+          {std::nullopt, std::nullopt, std::nullopt}),
+  })};
+
+  auto buildVectors = {makeRowVector({
+      makeNullableFlatVector<int32_t>({std::nullopt, std::nullopt}),
+  })};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  // Cross join: all-null columns should produce 6 rows with all nulls
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      {"c0", "u_c0"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT * FROM t, u");
+
+  // Filtered join: null < null is null (non-match), so 0 results
+  planNodeIdGenerator->reset();
+  auto filteredPlan = PlanBuilder(planNodeIdGenerator)
+                          .values({probeVectors})
+                          .nestedLoopJoin(
+                              PlanBuilder(planNodeIdGenerator)
+                                  .values({buildVectors})
+                                  .project({"c0 AS u_c0"})
+                                  .planNode(),
+                              "c0 < u_c0",
+                              {"c0", "u_c0"},
+                              core::JoinType::kInner)
+                          .planNode();
+
+  assertQuery(
+      filteredPlan, "SELECT t.c0, u.c0 FROM t INNER JOIN u ON t.c0 < u.c0");
+}
+
+// ============================================================================
+// Left Join Tests
+// ============================================================================
+
+// Left join with filter: unmatched probe rows appear with null build columns.
+TEST_F(CudfNestedLoopJoinTest, leftJoinWithFilter) {
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({1, 5, 10})})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({3, 7})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "u_c0"},
+                      core::JoinType::kLeft)
+                  .planNode();
+
+  // Probe 1 matches {3,7}; probe 5 matches {7}; probe 10 has no match → null.
+  assertQuery(plan, "SELECT t.c0, u.c0 FROM t LEFT JOIN u ON t.c0 < u.c0");
+}
+
+// Left join without filter: cross join (all combinations), no mismatches.
+TEST_F(CudfNestedLoopJoinTest, leftJoinWithoutFilter) {
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({1, 2, 3})})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({10, 20})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      {"c0", "u_c0"},
+                      core::JoinType::kLeft)
+                  .planNode();
+
+  // 3 * 2 = 6 rows, same as cross join.
+  assertQuery(plan, "SELECT * FROM t LEFT JOIN u ON true");
+}
+
+// Left join with empty build: all probe rows emitted with null build columns.
+TEST_F(CudfNestedLoopJoinTest, leftJoinEmptyBuild) {
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({1, 2, 3})})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "u_c0"},
+                      core::JoinType::kLeft)
+                  .planNode();
+
+  assertQuery(plan, "SELECT t.c0, u.c0 FROM t LEFT JOIN u ON t.c0 < u.c0");
+}
+
+// Left join with empty build and no filter.
+TEST_F(CudfNestedLoopJoinTest, leftJoinEmptyBuildNoFilter) {
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({1, 2, 3})})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      {"c0", "u_c0"},
+                      core::JoinType::kLeft)
+                  .planNode();
+
+  assertQuery(plan, "SELECT * FROM t LEFT JOIN u ON true");
+}
+
+// Left join with empty probe: no output.
+TEST_F(CudfNestedLoopJoinTest, leftJoinEmptyProbe) {
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({})})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({1, 2, 3})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "u_c0"},
+                      core::JoinType::kLeft)
+                  .planNode();
+
+  assertQuery(plan, "SELECT t.c0, u.c0 FROM t LEFT JOIN u ON t.c0 < u.c0");
+}
+
+// Left join with null values in probe and build columns.
+TEST_F(CudfNestedLoopJoinTest, leftJoinWithNulls) {
+  auto probeVectors = {makeRowVector({
+      makeNullableFlatVector<int32_t>({1, std::nullopt, 5, 3}),
+  })};
+
+  auto buildVectors = {makeRowVector({
+      makeNullableFlatVector<int32_t>({2, std::nullopt, 4}),
+  })};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "u_c0"},
+                      core::JoinType::kLeft)
+                  .planNode();
+
+  // Null comparisons produce null → unmatched (null probe rows get null build).
+  assertQuery(plan, "SELECT t.c0, u.c0 FROM t LEFT JOIN u ON t.c0 < u.c0");
+}
+
+// Left join with multiple probe and build batches.
+TEST_F(CudfNestedLoopJoinTest, leftJoinMultipleBatches) {
+  std::vector<RowVectorPtr> probeVectors = {
+      makeRowVector({makeFlatVector<int32_t>({1, 5})}),
+      makeRowVector({makeFlatVector<int32_t>({10, 20})}),
+  };
+
+  std::vector<RowVectorPtr> buildVectors = {
+      makeRowVector({makeFlatVector<int32_t>({3, 7})}),
+      makeRowVector({makeFlatVector<int32_t>({15})}),
+  };
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors)
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors)
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "u_c0"},
+                      core::JoinType::kLeft)
+                  .planNode();
+
+  assertQuery(plan, "SELECT t.c0, u.c0 FROM t LEFT JOIN u ON t.c0 < u.c0");
+}
+
+// Left join where no probe rows match any build rows.
+TEST_F(CudfNestedLoopJoinTest, leftJoinNoMatches) {
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({100, 200})})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({1, 2, 3})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "u_c0"},
+                      core::JoinType::kLeft)
+                  .planNode();
+
+  // All probe rows > all build rows, so no matches. All probe rows
+  // emitted with null build columns.
+  assertQuery(plan, "SELECT t.c0, u.c0 FROM t LEFT JOIN u ON t.c0 < u.c0");
+}
+
+// Left join with multiple column types including strings.
+TEST_F(CudfNestedLoopJoinTest, leftJoinMultipleColumnTypes) {
+  auto probeVectors = {makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 3}),
+      makeFlatVector<double>({1.1, 2.2, 3.3}),
+  })};
+
+  auto buildVectors = {makeRowVector({
+      makeFlatVector<int64_t>({10, 20}),
+  })};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c1 < cast(u_c0 as double)",
+                      {"c0", "c1", "u_c0"},
+                      core::JoinType::kLeft)
+                  .planNode();
+
+  assertQuery(
+      plan,
+      "SELECT t.c0, t.c1, u.c0 FROM t LEFT JOIN u ON t.c1 < CAST(u.c0 AS DOUBLE)");
+}
+
+// Multi-driver left join.
+TEST_F(CudfNestedLoopJoinTest, leftJoinMultiDriver) {
+  auto probeVectors = {
+      makeRowVector({makeFlatVector<int32_t>({1, 5, 10})}),
+  };
+
+  auto buildVectors = {
+      makeRowVector({makeFlatVector<int32_t>({3, 7})}),
+  };
+
+  createDuckDbTable("t", {probeVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  CursorParameters params;
+  params.maxDrivers = 2;
+  params.planNode = PlanBuilder(planNodeIdGenerator)
+                        .values({probeVectors})
+                        .nestedLoopJoin(
+                            PlanBuilder(planNodeIdGenerator)
+                                .values({buildVectors}, true)
+                                .project({"c0 AS u_c0"})
+                                .planNode(),
+                            "c0 < u_c0",
+                            {"c0", "u_c0"},
+                            core::JoinType::kLeft)
+                        .planNode();
+
+  // Build side: 2 drivers × {3, 7} = {3, 7, 3, 7}
+  assertQuery(
+      params,
+      "SELECT t.c0, u.c0 FROM t "
+      "LEFT JOIN (SELECT * FROM UNNEST(ARRAY[3, 7, 3, 7]) AS t(c0)) u "
+      "ON t.c0 < u.c0");
+}
+
+// ============================================================================
+// Right Join Tests
+// ============================================================================
+
+// Right join with filter: unmatched build rows appear with null probe columns.
+TEST_F(CudfNestedLoopJoinTest, rightJoinWithFilter) {
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({1, 5, 10})})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({3, 7, 20})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "u_c0"},
+                      core::JoinType::kRight)
+                  .planNode();
+
+  // Build row 20 has no matching probe row → emitted with null probe column.
+  assertQuery(plan, "SELECT t.c0, u.c0 FROM t RIGHT JOIN u ON t.c0 < u.c0");
+}
+
+// Right join without filter: cross join, all build rows present.
+TEST_F(CudfNestedLoopJoinTest, rightJoinWithoutFilter) {
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({1, 2})})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({10, 20, 30})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      {"c0", "u_c0"},
+                      core::JoinType::kRight)
+                  .planNode();
+
+  // 2 * 3 = 6 rows, same as cross join.
+  assertQuery(plan, "SELECT * FROM t RIGHT JOIN u ON true");
+}
+
+// Right join with empty probe: all build rows emitted with null probe columns.
+TEST_F(CudfNestedLoopJoinTest, rightJoinEmptyProbe) {
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({})})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({1, 2, 3})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "u_c0"},
+                      core::JoinType::kRight)
+                  .planNode();
+
+  assertQuery(plan, "SELECT t.c0, u.c0 FROM t RIGHT JOIN u ON t.c0 < u.c0");
+}
+
+// Right join with empty build: no output.
+TEST_F(CudfNestedLoopJoinTest, rightJoinEmptyBuild) {
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({1, 2, 3})})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "u_c0"},
+                      core::JoinType::kRight)
+                  .planNode();
+
+  assertQuery(plan, "SELECT t.c0, u.c0 FROM t RIGHT JOIN u ON t.c0 < u.c0");
+}
+
+// Right join where no probe rows match any build rows.
+TEST_F(CudfNestedLoopJoinTest, rightJoinNoMatches) {
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({100, 200})})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({1, 2, 3})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "u_c0"},
+                      core::JoinType::kRight)
+                  .planNode();
+
+  // All probe > all build with c0 < u_c0 filter → no matches.
+  // All build rows emitted with null probe columns.
+  assertQuery(plan, "SELECT t.c0, u.c0 FROM t RIGHT JOIN u ON t.c0 < u.c0");
+}
+
+// Right join with multiple probe and build batches.
+TEST_F(CudfNestedLoopJoinTest, rightJoinMultipleBatches) {
+  std::vector<RowVectorPtr> probeVectors = {
+      makeRowVector({makeFlatVector<int32_t>({1, 5})}),
+      makeRowVector({makeFlatVector<int32_t>({10, 20})}),
+  };
+
+  std::vector<RowVectorPtr> buildVectors = {
+      makeRowVector({makeFlatVector<int32_t>({3, 7})}),
+      makeRowVector({makeFlatVector<int32_t>({15})}),
+  };
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors)
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors)
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "u_c0"},
+                      core::JoinType::kRight)
+                  .planNode();
+
+  assertQuery(plan, "SELECT t.c0, u.c0 FROM t RIGHT JOIN u ON t.c0 < u.c0");
+}
+
+// Right join with null values.
+TEST_F(CudfNestedLoopJoinTest, rightJoinWithNulls) {
+  auto probeVectors = {makeRowVector({
+      makeNullableFlatVector<int32_t>({1, std::nullopt, 5}),
+  })};
+
+  auto buildVectors = {makeRowVector({
+      makeNullableFlatVector<int32_t>({2, std::nullopt, 4}),
+  })};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "u_c0"},
+                      core::JoinType::kRight)
+                  .planNode();
+
+  assertQuery(plan, "SELECT t.c0, u.c0 FROM t RIGHT JOIN u ON t.c0 < u.c0");
+}
+
+// Multi-driver right join: build mismatch flags must be merged across peers.
+TEST_F(CudfNestedLoopJoinTest, rightJoinMultiDriver) {
+  auto probeVectors = {
+      makeRowVector({makeFlatVector<int32_t>({1, 5, 10})}),
+  };
+
+  auto buildVectors = {
+      makeRowVector({makeFlatVector<int32_t>({3, 7})}),
+  };
+
+  createDuckDbTable("t", {probeVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  CursorParameters params;
+  params.maxDrivers = 2;
+  params.planNode = PlanBuilder(planNodeIdGenerator)
+                        .values({probeVectors})
+                        .nestedLoopJoin(
+                            PlanBuilder(planNodeIdGenerator)
+                                .values({buildVectors}, true)
+                                .project({"c0 AS u_c0"})
+                                .planNode(),
+                            "c0 < u_c0",
+                            {"c0", "u_c0"},
+                            core::JoinType::kRight)
+                        .planNode();
+
+  // Build side: 2 drivers × {3, 7} = {3, 7, 3, 7}
+  assertQuery(
+      params,
+      "SELECT t.c0, u.c0 FROM t "
+      "RIGHT JOIN (SELECT * FROM UNNEST(ARRAY[3, 7, 3, 7]) AS t(c0)) u "
+      "ON t.c0 < u.c0");
+}
+
+// --- Full outer join tests ---
+
+// Full join with filter: mismatches on both sides.
+TEST_F(CudfNestedLoopJoinTest, fullJoinWithFilter) {
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({1, 5, 10})})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({3, 7})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "u_c0"},
+                      core::JoinType::kFull)
+                  .planNode();
+
+  // Probe 1 matches {3,7}; probe 5 matches {7}; probe 10 has no match → null.
+  // Build 3 matches {5,10} but not 1 via < — actually build 3 is matched by
+  // probe rows 1,5 (1<3, 5>3 no). Let DuckDB compute the reference.
+  assertQuery(
+      plan, "SELECT t.c0, u.c0 FROM t FULL OUTER JOIN u ON t.c0 < u.c0");
+}
+
+// Full join without filter: cross join — all rows match, no mismatches.
+TEST_F(CudfNestedLoopJoinTest, fullJoinWithoutFilter) {
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({1, 2, 3})})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({10, 20})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      {"c0", "u_c0"},
+                      core::JoinType::kFull)
+                  .planNode();
+
+  // 3 * 2 = 6 rows, same as cross join.
+  assertQuery(plan, "SELECT * FROM t FULL OUTER JOIN u ON true");
+}
+
+// Full join with empty build: all probe rows emitted with null build columns.
+TEST_F(CudfNestedLoopJoinTest, fullJoinEmptyBuild) {
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({1, 2, 3})})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "u_c0"},
+                      core::JoinType::kFull)
+                  .planNode();
+
+  assertQuery(
+      plan, "SELECT t.c0, u.c0 FROM t FULL OUTER JOIN u ON t.c0 < u.c0");
+}
+
+// Full join with empty probe: all build rows emitted with null probe columns.
+TEST_F(CudfNestedLoopJoinTest, fullJoinEmptyProbe) {
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({})})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({10, 20, 30})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "u_c0"},
+                      core::JoinType::kFull)
+                  .planNode();
+
+  assertQuery(
+      plan, "SELECT t.c0, u.c0 FROM t FULL OUTER JOIN u ON t.c0 < u.c0");
+}
+
+// Full join where no rows match: all probe and build rows are mismatches.
+TEST_F(CudfNestedLoopJoinTest, fullJoinNoMatches) {
+  auto probeVectors = {
+      makeRowVector({makeFlatVector<int32_t>({100, 200, 300})})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({1, 2})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "u_c0"},
+                      core::JoinType::kFull)
+                  .planNode();
+
+  // probe rows all >= build rows, so c0 < u_c0 never true.
+  assertQuery(
+      plan, "SELECT t.c0, u.c0 FROM t FULL OUTER JOIN u ON t.c0 < u.c0");
+}
+
+// Full join with multiple build batches.
+TEST_F(CudfNestedLoopJoinTest, fullJoinMultipleBatches) {
+  std::vector<RowVectorPtr> probeVectors = {
+      makeRowVector({makeFlatVector<int32_t>({1, 5})}),
+      makeRowVector({makeFlatVector<int32_t>({10})}),
+  };
+  std::vector<RowVectorPtr> buildVectors = {
+      makeRowVector({makeFlatVector<int32_t>({3})}),
+      makeRowVector({makeFlatVector<int32_t>({7})}),
+  };
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "u_c0"},
+                      core::JoinType::kFull)
+                  .planNode();
+
+  assertQuery(
+      plan, "SELECT t.c0, u.c0 FROM t FULL OUTER JOIN u ON t.c0 < u.c0");
+}
+
+// Full join with nulls in data.
+TEST_F(CudfNestedLoopJoinTest, fullJoinWithNulls) {
+  auto probeVectors = {
+      makeRowVector({makeNullableFlatVector<int32_t>({1, std::nullopt, 10})})};
+  auto buildVectors = {
+      makeRowVector({makeNullableFlatVector<int32_t>({3, std::nullopt})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "u_c0"},
+                      core::JoinType::kFull)
+                  .planNode();
+
+  assertQuery(
+      plan, "SELECT t.c0, u.c0 FROM t FULL OUTER JOIN u ON t.c0 < u.c0");
+}
+
+// Multi-driver full join: build mismatch flags must be merged across peers,
+// and probe mismatch tracking works per-driver independently.
+TEST_F(CudfNestedLoopJoinTest, fullJoinMultiDriver) {
+  auto probeVectors = {
+      makeRowVector({makeFlatVector<int32_t>({1, 5, 10})}),
+  };
+
+  auto buildVectors = {
+      makeRowVector({makeFlatVector<int32_t>({3, 7})}),
+  };
+
+  createDuckDbTable("t", {probeVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  CursorParameters params;
+  params.maxDrivers = 2;
+  params.planNode = PlanBuilder(planNodeIdGenerator)
+                        .values({probeVectors})
+                        .nestedLoopJoin(
+                            PlanBuilder(planNodeIdGenerator)
+                                .values({buildVectors}, true)
+                                .project({"c0 AS u_c0"})
+                                .planNode(),
+                            "c0 < u_c0",
+                            {"c0", "u_c0"},
+                            core::JoinType::kFull)
+                        .planNode();
+
+  // Build side: 2 drivers × {3, 7} = {3, 7, 3, 7}
+  assertQuery(
+      params,
+      "SELECT t.c0, u.c0 FROM t "
+      "FULL OUTER JOIN (SELECT * FROM UNNEST(ARRAY[3, 7, 3, 7]) AS t(c0)) u "
+      "ON t.c0 < u.c0");
+}
+
+// --- LeftSemiProject join tests ---
+
+// LeftSemiProject with filter: probe rows + boolean match column.
+TEST_F(CudfNestedLoopJoinTest, leftSemiProjectWithFilter) {
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({1, 5, 10})})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({3, 7})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "match"},
+                      core::JoinType::kLeftSemiProject)
+                  .planNode();
+
+  // 1 < 3 true, 1 < 7 true → match=true; 5 < 7 true → match=true;
+  // 10 < nothing → match=false.
+  assertQuery(
+      plan, "SELECT t.c0, EXISTS (SELECT 1 FROM u WHERE t.c0 < u.c0) FROM t");
+}
+
+// LeftSemiProject without filter: non-empty build → all true.
+TEST_F(CudfNestedLoopJoinTest, leftSemiProjectWithoutFilter) {
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({1, 2, 3})})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({10, 20})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      {"c0", "match"},
+                      core::JoinType::kLeftSemiProject)
+                  .planNode();
+
+  // No filter + non-empty build → all rows match (true).
+  assertQuery(plan, "SELECT t.c0, EXISTS (SELECT 1 FROM u) FROM t");
+}
+
+// LeftSemiProject with empty build: all false.
+TEST_F(CudfNestedLoopJoinTest, leftSemiProjectEmptyBuild) {
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({1, 2, 3})})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "match"},
+                      core::JoinType::kLeftSemiProject)
+                  .planNode();
+
+  // Empty build → all false.
+  assertQuery(
+      plan, "SELECT t.c0, EXISTS (SELECT 1 FROM u WHERE t.c0 < u.c0) FROM t");
+}
+
+// LeftSemiProject with empty probe: no output.
+TEST_F(CudfNestedLoopJoinTest, leftSemiProjectEmptyProbe) {
+  auto probeVectors = {makeRowVector({makeFlatVector<int32_t>({})})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({10, 20})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "match"},
+                      core::JoinType::kLeftSemiProject)
+                  .planNode();
+
+  assertQuery(
+      plan, "SELECT t.c0, EXISTS (SELECT 1 FROM u WHERE t.c0 < u.c0) FROM t");
+}
+
+// LeftSemiProject where no rows match: all false.
+TEST_F(CudfNestedLoopJoinTest, leftSemiProjectNoMatches) {
+  auto probeVectors = {
+      makeRowVector({makeFlatVector<int32_t>({100, 200, 300})})};
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({1, 2})})};
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "match"},
+                      core::JoinType::kLeftSemiProject)
+                  .planNode();
+
+  assertQuery(
+      plan, "SELECT t.c0, EXISTS (SELECT 1 FROM u WHERE t.c0 < u.c0) FROM t");
+}
+
+// LeftSemiProject with multiple build batches.
+TEST_F(CudfNestedLoopJoinTest, leftSemiProjectMultipleBatches) {
+  std::vector<RowVectorPtr> probeVectors = {
+      makeRowVector({makeFlatVector<int32_t>({1, 5})}),
+      makeRowVector({makeFlatVector<int32_t>({10})}),
+  };
+  std::vector<RowVectorPtr> buildVectors = {
+      makeRowVector({makeFlatVector<int32_t>({3})}),
+      makeRowVector({makeFlatVector<int32_t>({7})}),
+  };
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "match"},
+                      core::JoinType::kLeftSemiProject)
+                  .planNode();
+
+  assertQuery(
+      plan, "SELECT t.c0, EXISTS (SELECT 1 FROM u WHERE t.c0 < u.c0) FROM t");
+}
+
+// LeftSemiProject with nulls in data. Velox semantics: unmatched rows
+// (including those with NULL comparisons) get match=false, not null.
+TEST_F(CudfNestedLoopJoinTest, leftSemiProjectWithNulls) {
+  auto probeVectors = {
+      makeRowVector({makeNullableFlatVector<int32_t>({1, std::nullopt, 10})})};
+  auto buildVectors = {
+      makeRowVector({makeNullableFlatVector<int32_t>({3, std::nullopt})})};
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      "c0 < u_c0",
+                      {"c0", "match"},
+                      core::JoinType::kLeftSemiProject)
+                  .planNode();
+
+  // 1 < 3 → true; null < anything → false (not null); 10 < nothing → false.
+  auto expected = makeRowVector(
+      {makeNullableFlatVector<int32_t>({1, std::nullopt, 10}),
+       makeFlatVector<bool>({true, false, false})});
+  AssertQueryBuilder builder{plan};
+  auto result = builder.copyResults(pool());
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+// Multi-driver LeftSemiProject.
+TEST_F(CudfNestedLoopJoinTest, leftSemiProjectMultiDriver) {
+  auto probeVectors = {
+      makeRowVector({makeFlatVector<int32_t>({1, 5, 10})}),
+  };
+
+  auto buildVectors = {
+      makeRowVector({makeFlatVector<int32_t>({3, 7})}),
+  };
+
+  createDuckDbTable("t", {probeVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  CursorParameters params;
+  params.maxDrivers = 2;
+  params.planNode = PlanBuilder(planNodeIdGenerator)
+                        .values({probeVectors})
+                        .nestedLoopJoin(
+                            PlanBuilder(planNodeIdGenerator)
+                                .values({buildVectors}, true)
+                                .project({"c0 AS u_c0"})
+                                .planNode(),
+                            "c0 < u_c0",
+                            {"c0", "match"},
+                            core::JoinType::kLeftSemiProject)
+                        .planNode();
+
+  // Build side: 2 drivers × {3, 7} = {3, 7, 3, 7}. Existence is the same.
+  assertQuery(
+      params,
+      "SELECT t.c0, EXISTS "
+      "(SELECT 1 FROM UNNEST(ARRAY[3, 7, 3, 7]) AS u(c0) "
+      "WHERE t.c0 < u.c0) FROM t");
+}
+
+// Test empty build always consumes probe input.
+// Verifies that probe input is consumed to prevent upstream exchange hanging,
+// matching CPU NLJ behavior (addresses PR#17113 review comment #3229357599).
+TEST_F(CudfNestedLoopJoinTest, emptyBuildConsumeInput) {
+  // Probe: 3 batches of 100 rows each = 300 total rows
+  auto probeVectors = {
+      makeRowVector({sequence<int32_t>(100, 0)}),
+      makeRowVector({sequence<int32_t>(100, 100)}),
+      makeRowVector({sequence<int32_t>(100, 200)}),
+  };
+
+  // Build: empty
+  auto buildVectors = {makeRowVector({makeFlatVector<int32_t>({})})};
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .nestedLoopJoin(
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .project({"c0 AS u_c0"})
+                          .planNode(),
+                      {"c0", "u_c0"})
+                  .planNode();
+
+  AssertQueryBuilder builder{plan, duckDbQueryRunner_};
+  auto task = builder.assertEmptyResults();
+
+  // Verify all 300 probe rows were consumed (matches CPU NLJ behavior).
+  // Pipeline 0, operator 1 is the NLJ probe (operator 0 is Values).
+  auto inputPositions =
+      task->taskStats().pipelineStats[0].operatorStats[1].inputPositions;
+  ASSERT_EQ(inputPositions, 300);
+}
+
+// TODO: Zero-column build side is not yet supported. cudf::table with zero
+// columns reports num_rows() == 0, causing the operator to treat a non-empty
+// build as empty. Fixing this requires the bridge to carry row counts
+// separately. See CPU NestedLoopJoinTest::zeroColumnBuild for the expected
+// behavior.
diff --git a/velox/experimental/cudf/tests/OrderByTest.cpp b/velox/experimental/cudf/tests/OrderByTest.cpp
index 1ee44e0fdf7..1b6f2d544a1 100644
--- a/velox/experimental/cudf/tests/OrderByTest.cpp
+++ b/velox/experimental/cudf/tests/OrderByTest.cpp
@@ -383,8 +383,9 @@ TEST_F(OrderByTest, outputBatchRows) {
     EXPECT_EQ(
         testData.expectedOutputVectors,
         toPlanStats(task->taskStats())
-            .at(orderById + "-to-velox")
-            .outputVectors);
+            .at(orderById)
+            .operatorStats.at("CudfToVelox")
+            ->outputVectors);
   }
 }
 
diff --git a/velox/experimental/cudf/tests/S3ReadTest.cpp b/velox/experimental/cudf/tests/S3ReadTest.cpp
new file mode 100644
index 00000000000..cef55e2a34e
--- /dev/null
+++ b/velox/experimental/cudf/tests/S3ReadTest.cpp
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/connectors/hive/CudfHiveConfig.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveConnector.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.h"
+
+#include "velox/common/memory/Memory.h"
+#include "velox/connectors/ConnectorRegistry.h"
+#include "velox/connectors/hive/HiveConfig.h"
+#include "velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.h"
+#include "velox/connectors/hive/storage_adapters/s3fs/tests/S3Test.h"
+#include "velox/dwio/common/tests/utils/DataFiles.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+#include <folly/init/Init.h>
+#include <gtest/gtest.h>
+
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::cudf_velox::exec::test;
+namespace {
+
+class S3ReadTest : public S3Test, public ::test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    S3Test::SetUp();
+    // Register cudf to enable the CudfDatasource creation from
+    // CudfHiveConnector
+    facebook::velox::cudf_velox::registerCudf();
+    filesystems::registerS3FileSystem();
+
+    // Register Hive connector
+    facebook::velox::cudf_velox::connector::hive::CudfHiveConnectorFactory
+        factory;
+    auto hiveConnector = factory.newConnector(
+        kCudfHiveConnectorId, minioServer_->hiveConfig(), ioExecutor_.get());
+    facebook::velox::connector::ConnectorRegistry::global().insert(
+        hiveConnector->connectorId(), hiveConnector);
+  }
+
+  void TearDown() override {
+    filesystems::finalizeS3FileSystem();
+    facebook::velox::connector::ConnectorRegistry::global().erase(
+        kCudfHiveConnectorId);
+    S3Test::TearDown();
+  }
+};
+} // namespace
+
+TEST_F(S3ReadTest, s3ReadTest) {
+  const auto sourceFile = test::getDataFilePath(
+      "velox/experimental/cudf/tests",
+      "../../../dwio/parquet/tests/examples/int.parquet");
+  const char* bucketName = "data";
+  const auto destinationFile = S3Test::localPath(bucketName) + "/int.parquet";
+  minioServer_->addBucket(bucketName);
+  std::ifstream src(sourceFile, std::ios::binary);
+  std::ofstream dest(destinationFile, std::ios::binary);
+  // Copy source file to destination bucket.
+  dest << src.rdbuf();
+  ASSERT_GT(dest.tellp(), 0) << "Unable to copy from source " << sourceFile;
+  dest.close();
+
+  // Read the parquet file via the S3 bucket.
+  auto rowType = ROW({"int", "bigint"}, {INTEGER(), BIGINT()});
+  auto tableHandle =
+      std::make_shared<facebook::velox::connector::hive::HiveTableHandle>(
+          kCudfHiveConnectorId,
+          "int_table",
+          common::SubfieldFilters{},
+          nullptr);
+  auto plan = PlanBuilder(pool())
+                  .startTableScan()
+                  .tableHandle(tableHandle)
+                  .outputType(rowType)
+                  .endTableScan()
+                  .planNode();
+  auto split = facebook::velox::connector::hive::HiveConnectorSplitBuilder(
+                   filesystems::s3URI(bucketName, "int.parquet"))
+                   .connectorId(kCudfHiveConnectorId)
+                   .fileFormat(dwio::common::FileFormat::PARQUET)
+                   .build();
+
+  auto copy = AssertQueryBuilder(plan).split(split).copyResults(pool());
+
+  // expectedResults is the data in int.parquet file.
+  const int64_t kExpectedRows = 10;
+  auto expectedResults = makeRowVector(
+      {makeFlatVector<int32_t>(
+           kExpectedRows, [](auto row) { return row + 100; }),
+       makeFlatVector<int64_t>(
+           kExpectedRows, [](auto row) { return row + 1000; })});
+  assertEqualResults({expectedResults}, {copy});
+}
diff --git a/velox/experimental/cudf/tests/StepAwareAggregationRegistryTest.cpp b/velox/experimental/cudf/tests/StepAwareAggregationRegistryTest.cpp
new file mode 100644
index 00000000000..0274feb0dd2
--- /dev/null
+++ b/velox/experimental/cudf/tests/StepAwareAggregationRegistryTest.cpp
@@ -0,0 +1,554 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/exec/AggregationRegistry.h"
+#include "velox/experimental/cudf/exec/CudfGroupby.h"
+#include "velox/experimental/cudf/exec/CudfReduce.h"
+#include "velox/experimental/cudf/exec/PrestoAggregateFunctions.h"
+#include "velox/experimental/cudf/exec/SparkAggregateFunctions.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
+
+#include "velox/core/Expressions.h"
+#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
+
+#include <gtest/gtest.h>
+
+#include <algorithm>
+
+using namespace facebook::velox;
+
+namespace facebook::velox::cudf_velox {
+
+namespace {
+
+bool hasSingleArgSignature(
+    const StepAwareAggregationRegistry& registry,
+    const std::string& name,
+    core::AggregationNode::Step step,
+    const std::string& returnType,
+    const std::string& argumentType) {
+  auto fnIt = registry.find(name);
+  if (fnIt == registry.end()) {
+    return false;
+  }
+  auto stepIt = fnIt->second.find(step);
+  if (stepIt == fnIt->second.end()) {
+    return false;
+  }
+  return std::any_of(
+      stepIt->second.begin(), stepIt->second.end(), [&](const auto& sig) {
+        return sig->returnType().baseName() == returnType &&
+            sig->argumentTypes().size() == 1 &&
+            sig->argumentTypes()[0].baseName() == argumentType;
+      });
+}
+
+} // namespace
+
+class StepAwareAggregationRegistryTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    memory::MemoryManager::testingSetInstance({});
+    registerCudf();
+    facebook::velox::aggregate::prestosql::registerAllAggregateFunctions();
+    queryCtx_ = core::QueryCtx::create();
+  }
+
+  void TearDown() override {
+    unregisterCudf();
+    unregisterAggregateFunctions();
+  }
+
+  std::shared_ptr<core::QueryCtx> queryCtx_;
+};
+
+TEST_F(StepAwareAggregationRegistryTest, allFunctionsAreRegisteredInGroupby) {
+  auto& registry = getGroupbyAggregationRegistry();
+
+  // Check that all expected groupby functions are registered
+  EXPECT_TRUE(registry.find("avg") != registry.end())
+      << "avg function should be registered in groupby registry";
+  EXPECT_TRUE(registry.find("sum") != registry.end())
+      << "sum function should be registered in groupby registry";
+  EXPECT_TRUE(registry.find("count") != registry.end())
+      << "count function should be registered in groupby registry";
+  EXPECT_TRUE(registry.find("min") != registry.end())
+      << "min function should be registered in groupby registry";
+  EXPECT_TRUE(registry.find("max") != registry.end())
+      << "max function should be registered in groupby registry";
+  // approx_distinct should NOT be in the groupby registry
+  EXPECT_TRUE(registry.find("approx_distinct") == registry.end())
+      << "approx_distinct should NOT be registered in groupby registry";
+}
+
+TEST_F(StepAwareAggregationRegistryTest, allFunctionsAreRegisteredInReduce) {
+  auto& registry = getReduceAggregationRegistry();
+
+  // Check that all expected reduce functions are registered
+  EXPECT_TRUE(registry.find("avg") != registry.end())
+      << "avg function should be registered in reduce registry";
+  EXPECT_TRUE(registry.find("sum") != registry.end())
+      << "sum function should be registered in reduce registry";
+  EXPECT_TRUE(registry.find("count") != registry.end())
+      << "count function should be registered in reduce registry";
+  EXPECT_TRUE(registry.find("min") != registry.end())
+      << "min function should be registered in reduce registry";
+  EXPECT_TRUE(registry.find("max") != registry.end())
+      << "max function should be registered in reduce registry";
+  // approx_distinct should be in the reduce registry
+  EXPECT_TRUE(registry.find("approx_distinct") != registry.end())
+      << "approx_distinct should be registered in reduce registry";
+}
+
+TEST_F(StepAwareAggregationRegistryTest, allStepsAreRegisteredForAvg) {
+  auto& registry = getGroupbyAggregationRegistry();
+
+  // Check that all steps are registered for avg
+  auto& avgSteps = registry["avg"];
+  EXPECT_TRUE(
+      avgSteps.find(core::AggregationNode::Step::kSingle) != avgSteps.end())
+      << "avg single step should be registered";
+  EXPECT_TRUE(
+      avgSteps.find(core::AggregationNode::Step::kPartial) != avgSteps.end())
+      << "avg partial step should be registered";
+  EXPECT_TRUE(
+      avgSteps.find(core::AggregationNode::Step::kFinal) != avgSteps.end())
+      << "avg final step should be registered";
+  EXPECT_TRUE(
+      avgSteps.find(core::AggregationNode::Step::kIntermediate) !=
+      avgSteps.end())
+      << "avg intermediate step should be registered";
+}
+
+TEST_F(StepAwareAggregationRegistryTest, avgHasSignaturesForAllSteps) {
+  auto& registry = getGroupbyAggregationRegistry();
+  auto& avgSteps = registry["avg"];
+
+  // Test that all steps have signatures
+  auto& singleSigs = avgSteps[core::AggregationNode::Step::kSingle];
+  auto& partialSigs = avgSteps[core::AggregationNode::Step::kPartial];
+  auto& finalSigs = avgSteps[core::AggregationNode::Step::kFinal];
+  auto& intermediateSigs = avgSteps[core::AggregationNode::Step::kIntermediate];
+
+  EXPECT_FALSE(singleSigs.empty()) << "Single step should have signatures";
+  EXPECT_FALSE(partialSigs.empty()) << "Partial step should have signatures";
+  EXPECT_FALSE(finalSigs.empty()) << "Final step should have signatures";
+  EXPECT_FALSE(intermediateSigs.empty())
+      << "Intermediate step should have signatures";
+}
+
+TEST_F(StepAwareAggregationRegistryTest, avgPartialStepHasRowReturnTypes) {
+  auto& registry = getGroupbyAggregationRegistry();
+  auto& avgSteps = registry["avg"];
+  auto& partialSigs = avgSteps[core::AggregationNode::Step::kPartial];
+
+  // Verify that partial signatures have ROW return types
+  bool foundRowReturn = false;
+  for (const auto& sig : partialSigs) {
+    if (sig->returnType().baseName().find("row") != std::string::npos) {
+      foundRowReturn = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(foundRowReturn) << "Partial step should have ROW return types";
+}
+
+TEST_F(StepAwareAggregationRegistryTest, avgFinalStepHasRowInputTypes) {
+  auto& registry = getGroupbyAggregationRegistry();
+  auto& avgSteps = registry["avg"];
+  auto& finalSigs = avgSteps[core::AggregationNode::Step::kFinal];
+
+  // Verify that final signatures have ROW input types
+  bool foundRowInput = false;
+  for (const auto& sig : finalSigs) {
+    if (!sig->argumentTypes().empty() &&
+        sig->argumentTypes()[0].baseName().find("row") != std::string::npos) {
+      foundRowInput = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(foundRowInput) << "Final step should have ROW input types";
+}
+
+TEST_F(StepAwareAggregationRegistryTest, avgSingleStepValidation) {
+  auto avgSingleCall = std::make_shared<core::CallTypedExpr>(
+      DOUBLE(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(DOUBLE(), "input")},
+      "avg");
+
+  bool groupbySupported = canGroupbyAggregationBeEvaluatedByCudf(
+      *avgSingleCall,
+      core::AggregationNode::Step::kSingle,
+      {DOUBLE()},
+      queryCtx_.get());
+
+  bool reduceSupported = canReduceAggregationBeEvaluatedByCudf(
+      *avgSingleCall,
+      core::AggregationNode::Step::kSingle,
+      {DOUBLE()},
+      queryCtx_.get());
+
+  EXPECT_TRUE(groupbySupported)
+      << "Single step avg(DOUBLE) should be supported for groupby";
+  EXPECT_TRUE(reduceSupported)
+      << "Single step avg(DOUBLE) should be supported for reduce";
+}
+
+TEST_F(StepAwareAggregationRegistryTest, avgPartialStepValidation) {
+  auto avgPartialCall = std::make_shared<core::CallTypedExpr>(
+      ROW({DOUBLE(), BIGINT()}),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(DOUBLE(), "input")},
+      "avg");
+
+  bool groupbySupported = canGroupbyAggregationBeEvaluatedByCudf(
+      *avgPartialCall,
+      core::AggregationNode::Step::kPartial,
+      {DOUBLE()},
+      queryCtx_.get());
+
+  EXPECT_TRUE(groupbySupported)
+      << "Partial step avg(DOUBLE) should be supported";
+}
+
+TEST_F(StepAwareAggregationRegistryTest, avgFinalStepValidation) {
+  auto rowType = ROW({DOUBLE(), BIGINT()});
+  auto avgFinalCall = std::make_shared<core::CallTypedExpr>(
+      DOUBLE(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(
+              rowType, "intermediate")},
+      "avg");
+
+  bool groupbySupported = canGroupbyAggregationBeEvaluatedByCudf(
+      *avgFinalCall,
+      core::AggregationNode::Step::kFinal,
+      {rowType},
+      queryCtx_.get());
+
+  EXPECT_TRUE(groupbySupported)
+      << "Final step avg(ROW(DOUBLE,BIGINT)) should be supported";
+}
+
+TEST_F(StepAwareAggregationRegistryTest, sumStepConsistency) {
+  // Sum should have the same signatures for all steps
+  auto sumCall = std::make_shared<core::CallTypedExpr>(
+      DOUBLE(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(DOUBLE(), "input")},
+      "sum");
+
+  bool sumSingle = canGroupbyAggregationBeEvaluatedByCudf(
+      *sumCall,
+      core::AggregationNode::Step::kSingle,
+      {DOUBLE()},
+      queryCtx_.get());
+  bool sumPartial = canGroupbyAggregationBeEvaluatedByCudf(
+      *sumCall,
+      core::AggregationNode::Step::kPartial,
+      {DOUBLE()},
+      queryCtx_.get());
+  bool sumFinal = canGroupbyAggregationBeEvaluatedByCudf(
+      *sumCall,
+      core::AggregationNode::Step::kFinal,
+      {DOUBLE()},
+      queryCtx_.get());
+  bool sumIntermediate = canGroupbyAggregationBeEvaluatedByCudf(
+      *sumCall,
+      core::AggregationNode::Step::kIntermediate,
+      {DOUBLE()},
+      queryCtx_.get());
+
+  EXPECT_TRUE(sumSingle) << "Sum single step should be supported";
+  EXPECT_TRUE(sumPartial) << "Sum partial step should be supported";
+  EXPECT_TRUE(sumFinal) << "Sum final step should be supported";
+  EXPECT_TRUE(sumIntermediate) << "Sum intermediate step should be supported";
+}
+
+TEST_F(StepAwareAggregationRegistryTest, countStepConsistency) {
+  // Count has raw input signatures for single/partial and bigint input for
+  // final/intermediate.
+  auto countRawCall = std::make_shared<core::CallTypedExpr>(
+      BIGINT(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(DOUBLE(), "input")},
+      "count");
+  auto countIntermediateCall = std::make_shared<core::CallTypedExpr>(
+      BIGINT(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(BIGINT(), "input")},
+      "count");
+
+  bool countSingle = canGroupbyAggregationBeEvaluatedByCudf(
+      *countRawCall,
+      core::AggregationNode::Step::kSingle,
+      {DOUBLE()},
+      queryCtx_.get());
+  bool countPartial = canGroupbyAggregationBeEvaluatedByCudf(
+      *countRawCall,
+      core::AggregationNode::Step::kPartial,
+      {DOUBLE()},
+      queryCtx_.get());
+  bool countFinal = canGroupbyAggregationBeEvaluatedByCudf(
+      *countIntermediateCall,
+      core::AggregationNode::Step::kFinal,
+      {BIGINT()},
+      queryCtx_.get());
+  bool countIntermediate = canGroupbyAggregationBeEvaluatedByCudf(
+      *countIntermediateCall,
+      core::AggregationNode::Step::kIntermediate,
+      {BIGINT()},
+      queryCtx_.get());
+
+  EXPECT_TRUE(countSingle) << "Count single step should be supported";
+  EXPECT_TRUE(countPartial) << "Count partial step should be supported";
+  EXPECT_TRUE(countFinal) << "Count final step should be supported";
+  EXPECT_TRUE(countIntermediate)
+      << "Count intermediate step should be supported";
+}
+
+TEST_F(StepAwareAggregationRegistryTest, minStepConsistency) {
+  // Min should have the same signatures for all steps
+  auto minCall = std::make_shared<core::CallTypedExpr>(
+      DOUBLE(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(DOUBLE(), "input")},
+      "min");
+
+  bool minSingle = canGroupbyAggregationBeEvaluatedByCudf(
+      *minCall,
+      core::AggregationNode::Step::kSingle,
+      {DOUBLE()},
+      queryCtx_.get());
+  bool minPartial = canGroupbyAggregationBeEvaluatedByCudf(
+      *minCall,
+      core::AggregationNode::Step::kPartial,
+      {DOUBLE()},
+      queryCtx_.get());
+  bool minFinal = canGroupbyAggregationBeEvaluatedByCudf(
+      *minCall,
+      core::AggregationNode::Step::kFinal,
+      {DOUBLE()},
+      queryCtx_.get());
+  bool minIntermediate = canGroupbyAggregationBeEvaluatedByCudf(
+      *minCall,
+      core::AggregationNode::Step::kIntermediate,
+      {DOUBLE()},
+      queryCtx_.get());
+
+  EXPECT_TRUE(minSingle) << "Min single step should be supported";
+  EXPECT_TRUE(minPartial) << "Min partial step should be supported";
+  EXPECT_TRUE(minFinal) << "Min final step should be supported";
+  EXPECT_TRUE(minIntermediate) << "Min intermediate step should be supported";
+}
+
+TEST_F(StepAwareAggregationRegistryTest, maxStepConsistency) {
+  // Max should have the same signatures for all steps
+  auto maxCall = std::make_shared<core::CallTypedExpr>(
+      DOUBLE(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(DOUBLE(), "input")},
+      "max");
+
+  bool maxSingle = canGroupbyAggregationBeEvaluatedByCudf(
+      *maxCall,
+      core::AggregationNode::Step::kSingle,
+      {DOUBLE()},
+      queryCtx_.get());
+  bool maxPartial = canGroupbyAggregationBeEvaluatedByCudf(
+      *maxCall,
+      core::AggregationNode::Step::kPartial,
+      {DOUBLE()},
+      queryCtx_.get());
+  bool maxFinal = canGroupbyAggregationBeEvaluatedByCudf(
+      *maxCall,
+      core::AggregationNode::Step::kFinal,
+      {DOUBLE()},
+      queryCtx_.get());
+  bool maxIntermediate = canGroupbyAggregationBeEvaluatedByCudf(
+      *maxCall,
+      core::AggregationNode::Step::kIntermediate,
+      {DOUBLE()},
+      queryCtx_.get());
+
+  EXPECT_TRUE(maxSingle) << "Max single step should be supported";
+  EXPECT_TRUE(maxPartial) << "Max partial step should be supported";
+  EXPECT_TRUE(maxFinal) << "Max final step should be supported";
+  EXPECT_TRUE(maxIntermediate) << "Max intermediate step should be supported";
+}
+
+TEST_F(
+    StepAwareAggregationRegistryTest,
+    prestoRegistrationPopulatesRealSignaturesInBothPhysicalRegistries) {
+  registerPrestoAggregateFunctions("");
+
+  EXPECT_TRUE(hasSingleArgSignature(
+      getGroupbyAggregationRegistry(),
+      "sum",
+      core::AggregationNode::Step::kSingle,
+      "real",
+      "real"));
+  EXPECT_TRUE(hasSingleArgSignature(
+      getReduceAggregationRegistry(),
+      "sum",
+      core::AggregationNode::Step::kSingle,
+      "real",
+      "real"));
+}
+
+TEST_F(
+    StepAwareAggregationRegistryTest,
+    sparkRegistrationReplacesPrestoSignaturesInBothPhysicalRegistries) {
+  registerPrestoAggregateFunctions("");
+  registerSparkAggregateFunctions("");
+
+  EXPECT_TRUE(hasSingleArgSignature(
+      getGroupbyAggregationRegistry(),
+      "sum",
+      core::AggregationNode::Step::kSingle,
+      "double",
+      "real"));
+  EXPECT_TRUE(hasSingleArgSignature(
+      getReduceAggregationRegistry(),
+      "sum",
+      core::AggregationNode::Step::kSingle,
+      "double",
+      "real"));
+  EXPECT_FALSE(hasSingleArgSignature(
+      getGroupbyAggregationRegistry(),
+      "sum",
+      core::AggregationNode::Step::kSingle,
+      "real",
+      "real"));
+  EXPECT_FALSE(hasSingleArgSignature(
+      getReduceAggregationRegistry(),
+      "sum",
+      core::AggregationNode::Step::kSingle,
+      "real",
+      "real"));
+}
+
+TEST_F(
+    StepAwareAggregationRegistryTest,
+    appendGroupbySignatureOnlyAffectsGroupbyRegistryAndValidation) {
+  unregisterAggregateFunctions();
+
+  appendGroupbyAggregationFunctionForStep(
+      "custom_groupby",
+      core::AggregationNode::Step::kSingle,
+      exec::FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("double")
+          .build());
+
+  auto customCall = std::make_shared<core::CallTypedExpr>(
+      DOUBLE(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(DOUBLE(), "input")},
+      "custom_groupby");
+
+  EXPECT_TRUE(hasSingleArgSignature(
+      getGroupbyAggregationRegistry(),
+      "custom_groupby",
+      core::AggregationNode::Step::kSingle,
+      "double",
+      "double"));
+  EXPECT_EQ(
+      getReduceAggregationRegistry().find("custom_groupby"),
+      getReduceAggregationRegistry().end());
+  EXPECT_TRUE(canGroupbyAggregationBeEvaluatedByCudf(
+      *customCall,
+      core::AggregationNode::Step::kSingle,
+      {DOUBLE()},
+      queryCtx_.get()));
+  EXPECT_FALSE(canReduceAggregationBeEvaluatedByCudf(
+      *customCall,
+      core::AggregationNode::Step::kSingle,
+      {DOUBLE()},
+      queryCtx_.get()));
+}
+
+TEST_F(
+    StepAwareAggregationRegistryTest,
+    appendReduceSignatureOnlyAffectsReduceRegistryAndValidation) {
+  unregisterAggregateFunctions();
+
+  appendReduceAggregationFunctionForStep(
+      "custom_reduce",
+      core::AggregationNode::Step::kSingle,
+      exec::FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("double")
+          .build());
+
+  auto customCall = std::make_shared<core::CallTypedExpr>(
+      DOUBLE(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(DOUBLE(), "input")},
+      "custom_reduce");
+
+  EXPECT_TRUE(hasSingleArgSignature(
+      getReduceAggregationRegistry(),
+      "custom_reduce",
+      core::AggregationNode::Step::kSingle,
+      "double",
+      "double"));
+  EXPECT_EQ(
+      getGroupbyAggregationRegistry().find("custom_reduce"),
+      getGroupbyAggregationRegistry().end());
+  EXPECT_TRUE(canReduceAggregationBeEvaluatedByCudf(
+      *customCall,
+      core::AggregationNode::Step::kSingle,
+      {DOUBLE()},
+      queryCtx_.get()));
+  EXPECT_FALSE(canGroupbyAggregationBeEvaluatedByCudf(
+      *customCall,
+      core::AggregationNode::Step::kSingle,
+      {DOUBLE()},
+      queryCtx_.get()));
+}
+
+TEST_F(
+    StepAwareAggregationRegistryTest,
+    customSignaturesAreDiscardedWhenEngineRegistriesAreRebuilt) {
+  appendGroupbyAggregationFunctionForStep(
+      "custom_groupby",
+      core::AggregationNode::Step::kSingle,
+      exec::FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("double")
+          .build());
+  appendReduceAggregationFunctionForStep(
+      "custom_reduce",
+      core::AggregationNode::Step::kSingle,
+      exec::FunctionSignatureBuilder()
+          .returnType("double")
+          .argumentType("double")
+          .build());
+
+  registerSparkAggregateFunctions("");
+
+  EXPECT_EQ(
+      getGroupbyAggregationRegistry().find("custom_groupby"),
+      getGroupbyAggregationRegistry().end());
+  EXPECT_EQ(
+      getReduceAggregationRegistry().find("custom_reduce"),
+      getReduceAggregationRegistry().end());
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/tests/StringFunctionTest.cpp b/velox/experimental/cudf/tests/StringFunctionTest.cpp
new file mode 100644
index 00000000000..b23fcc9b9f3
--- /dev/null
+++ b/velox/experimental/cudf/tests/StringFunctionTest.cpp
@@ -0,0 +1,611 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/tests/CudfFunctionBaseTest.h"
+
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+namespace {
+
+// ---------------------------------------------------------------------------
+// Plan-based tests: run a Velox plan through the cudf engine and verify
+// results against DuckDB.
+// ---------------------------------------------------------------------------
+class CudfStringFunctionTest : public OperatorTestBase {
+ protected:
+  void SetUp() override {
+    OperatorTestBase::SetUp();
+    filesystems::registerLocalFileSystem();
+    cudf_velox::CudfConfig::getInstance().allowCpuFallback = false;
+    cudf_velox::registerCudf();
+  }
+
+  void TearDown() override {
+    cudf_velox::unregisterCudf();
+    OperatorTestBase::TearDown();
+  }
+};
+
+// ---- LIKE tests -----------------------------------------------------------
+
+TEST_F(CudfStringFunctionTest, likeWildcard) {
+  auto input = makeRowVector(
+      {makeFlatVector<std::string>({"hello", "world", "help", "held"})});
+  createDuckDbTable({input});
+
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .project({"c0 LIKE '%el%' AS result"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT c0 LIKE '%el%' AS result FROM tmp");
+}
+
+TEST_F(CudfStringFunctionTest, likePrefixPattern) {
+  auto input = makeRowVector(
+      {makeFlatVector<std::string>({"apple", "apricot", "banana", "avocado"})});
+  createDuckDbTable({input});
+
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .project({"c0 LIKE 'ap%' AS result"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT c0 LIKE 'ap%' AS result FROM tmp");
+}
+
+TEST_F(CudfStringFunctionTest, likeSuffixPattern) {
+  auto input = makeRowVector(
+      {makeFlatVector<std::string>({"cat", "bat", "car", "hat"})});
+  createDuckDbTable({input});
+
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .project({"c0 LIKE '%at' AS result"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT c0 LIKE '%at' AS result FROM tmp");
+}
+
+TEST_F(CudfStringFunctionTest, likeSingleCharWildcard) {
+  auto input = makeRowVector(
+      {makeFlatVector<std::string>({"cat", "cut", "cot", "cart"})});
+  createDuckDbTable({input});
+
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .project({"c0 LIKE 'c_t' AS result"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT c0 LIKE 'c_t' AS result FROM tmp");
+}
+
+TEST_F(CudfStringFunctionTest, likeExactMatch) {
+  auto input = makeRowVector(
+      {makeFlatVector<std::string>({"exact", "EXACT", "exactly", "ex"})});
+  createDuckDbTable({input});
+
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .project({"c0 LIKE 'exact' AS result"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT c0 LIKE 'exact' AS result FROM tmp");
+}
+
+TEST_F(CudfStringFunctionTest, likeNoMatch) {
+  auto input =
+      makeRowVector({makeFlatVector<std::string>({"abc", "def", "ghi"})});
+  createDuckDbTable({input});
+
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .project({"c0 LIKE '%xyz%' AS result"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT c0 LIKE '%xyz%' AS result FROM tmp");
+}
+
+TEST_F(CudfStringFunctionTest, likeEmptyStrings) {
+  auto input =
+      makeRowVector({makeFlatVector<std::string>({"", "a", "", "bc"})});
+  createDuckDbTable({input});
+
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .project({"c0 LIKE '' AS result"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT c0 LIKE '' AS result FROM tmp");
+}
+
+TEST_F(CudfStringFunctionTest, likeInFilter) {
+  auto input = makeRowVector(
+      {makeFlatVector<int32_t>({1, 2, 3, 4}),
+       makeFlatVector<std::string>({"hello", "world", "help", "held"})});
+  createDuckDbTable({input});
+
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .filter("c1 LIKE 'hel%'")
+                  .project({"c0", "c1"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT c0, c1 FROM tmp WHERE c1 LIKE 'hel%'");
+}
+
+TEST_F(CudfStringFunctionTest, likeWithNulls) {
+  auto input = makeRowVector({makeNullableFlatVector<std::string>(
+      {"hello", std::nullopt, "help", std::nullopt})});
+  createDuckDbTable({input});
+
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .project({"c0 LIKE '%el%' AS result"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT c0 LIKE '%el%' AS result FROM tmp");
+}
+
+// Input: {"café", "naïve", "hello"}, pattern: '%fé'
+TEST_F(CudfStringFunctionTest, likeUnicode) {
+  auto input = makeRowVector(
+      {makeFlatVector<std::string>({"caf\xc3\xa9", "na\xc3\xafve", "hello"})});
+  createDuckDbTable({input});
+
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .project({"c0 LIKE '%f\xc3\xa9' AS result"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT c0 LIKE '%f\xc3\xa9' AS result FROM tmp");
+}
+
+// DuckDB single-char wildcard `_` behaves different from cuDF (and hence from
+// the SQL standard) with multi-byte UTF-8 characters, treating each byte as a
+// separate character. The first and third rows of this test therefore fail
+// comparison with the DuckDB result, even though they match the pattern
+// according to the SQL standard. Leaving this test disabled for now, pending
+// further investigation.
+TEST_F(CudfStringFunctionTest, DISABLED_likeUnicodeSingleCharWildcard) {
+  auto input = makeRowVector(
+      {makeFlatVector<std::string>({"caf\xc3\xa9", "cafe", "caf\xc3\xa9s"})});
+  createDuckDbTable({input});
+
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .project({"c0 LIKE 'caf_' AS result"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT c0 LIKE 'caf_' AS result FROM tmp");
+}
+
+// ---- UPPER tests ----------------------------------------------------------
+
+TEST_F(CudfStringFunctionTest, upperBasic) {
+  auto input = makeRowVector(
+      {makeFlatVector<std::string>({"hello", "World", "FOO", "bAr"})});
+  createDuckDbTable({input});
+
+  auto plan =
+      PlanBuilder().values({input}).project({"UPPER(c0) AS result"}).planNode();
+
+  assertQuery(plan, "SELECT UPPER(c0) AS result FROM tmp");
+}
+
+TEST_F(CudfStringFunctionTest, upperAlreadyUpper) {
+  auto input =
+      makeRowVector({makeFlatVector<std::string>({"ABC", "XYZ", "HELLO"})});
+  createDuckDbTable({input});
+
+  auto plan =
+      PlanBuilder().values({input}).project({"UPPER(c0) AS result"}).planNode();
+
+  assertQuery(plan, "SELECT UPPER(c0) AS result FROM tmp");
+}
+
+TEST_F(CudfStringFunctionTest, upperEmptyAndSpecial) {
+  auto input =
+      makeRowVector({makeFlatVector<std::string>({"", "123", "a1b2", "!@#"})});
+  createDuckDbTable({input});
+
+  auto plan =
+      PlanBuilder().values({input}).project({"UPPER(c0) AS result"}).planNode();
+
+  assertQuery(plan, "SELECT UPPER(c0) AS result FROM tmp");
+}
+
+TEST_F(CudfStringFunctionTest, upperWithNulls) {
+  auto input = makeRowVector({makeNullableFlatVector<std::string>(
+      {"hello", std::nullopt, "WORLD", std::nullopt})});
+  createDuckDbTable({input});
+
+  auto plan =
+      PlanBuilder().values({input}).project({"UPPER(c0) AS result"}).planNode();
+
+  assertQuery(plan, "SELECT UPPER(c0) AS result FROM tmp");
+}
+
+// Input: {"café", "naïve", "hello"}
+TEST_F(CudfStringFunctionTest, upperUnicode) {
+  auto input = makeRowVector(
+      {makeFlatVector<std::string>({"caf\xc3\xa9", "na\xc3\xafve", "hello"})});
+  createDuckDbTable({input});
+
+  auto plan =
+      PlanBuilder().values({input}).project({"UPPER(c0) AS result"}).planNode();
+
+  assertQuery(plan, "SELECT UPPER(c0) AS result FROM tmp");
+}
+
+// ---- LOWER tests ----------------------------------------------------------
+
+TEST_F(CudfStringFunctionTest, lowerBasic) {
+  auto input = makeRowVector(
+      {makeFlatVector<std::string>({"HELLO", "World", "foo", "bAr"})});
+  createDuckDbTable({input});
+
+  auto plan =
+      PlanBuilder().values({input}).project({"LOWER(c0) AS result"}).planNode();
+
+  assertQuery(plan, "SELECT LOWER(c0) AS result FROM tmp");
+}
+
+TEST_F(CudfStringFunctionTest, lowerAlreadyLower) {
+  auto input =
+      makeRowVector({makeFlatVector<std::string>({"abc", "xyz", "hello"})});
+  createDuckDbTable({input});
+
+  auto plan =
+      PlanBuilder().values({input}).project({"LOWER(c0) AS result"}).planNode();
+
+  assertQuery(plan, "SELECT LOWER(c0) AS result FROM tmp");
+}
+
+TEST_F(CudfStringFunctionTest, lowerEmptyAndSpecial) {
+  auto input =
+      makeRowVector({makeFlatVector<std::string>({"", "123", "A1B2", "!@#"})});
+  createDuckDbTable({input});
+
+  auto plan =
+      PlanBuilder().values({input}).project({"LOWER(c0) AS result"}).planNode();
+
+  assertQuery(plan, "SELECT LOWER(c0) AS result FROM tmp");
+}
+
+TEST_F(CudfStringFunctionTest, lowerWithNulls) {
+  auto input = makeRowVector({makeNullableFlatVector<std::string>(
+      {"HELLO", std::nullopt, "world", std::nullopt})});
+  createDuckDbTable({input});
+
+  auto plan =
+      PlanBuilder().values({input}).project({"LOWER(c0) AS result"}).planNode();
+
+  assertQuery(plan, "SELECT LOWER(c0) AS result FROM tmp");
+}
+
+// Input: {"CAFÉ", "NAÏVE", "HELLO"}
+TEST_F(CudfStringFunctionTest, lowerUnicode) {
+  auto input = makeRowVector(
+      {makeFlatVector<std::string>({"CAF\xc3\x89", "NA\xc3\x8fVE", "HELLO"})});
+  createDuckDbTable({input});
+
+  auto plan =
+      PlanBuilder().values({input}).project({"LOWER(c0) AS result"}).planNode();
+
+  assertQuery(plan, "SELECT LOWER(c0) AS result FROM tmp");
+}
+
+// ---- CONCAT tests ---------------------------------------------------------
+
+TEST_F(CudfStringFunctionTest, concatTwoColumns) {
+  auto input = makeRowVector(
+      {makeFlatVector<std::string>({"hello", "foo", ""}),
+       makeFlatVector<std::string>({" world", "bar", "empty"})});
+  createDuckDbTable({input});
+
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .project({"concat(c0, c1) AS result"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT concat(c0, c1) AS result FROM tmp");
+}
+
+TEST_F(CudfStringFunctionTest, concatThreeColumns) {
+  auto input = makeRowVector(
+      {makeFlatVector<std::string>({"a", "d"}),
+       makeFlatVector<std::string>({"b", "e"}),
+       makeFlatVector<std::string>({"c", "f"})});
+  createDuckDbTable({input});
+
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .project({"concat(c0, c1, c2) AS result"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT concat(c0, c1, c2) AS result FROM tmp");
+}
+
+TEST_F(CudfStringFunctionTest, concatColumnAndLiteral) {
+  auto input = makeRowVector({makeFlatVector<std::string>({"hello", "world"})});
+  createDuckDbTable({input});
+
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .project({"concat(c0, '!!!') AS result"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT concat(c0, '!!!') AS result FROM tmp");
+}
+
+TEST_F(CudfStringFunctionTest, concatLiteralAndColumn) {
+  auto input = makeRowVector({makeFlatVector<std::string>({"world", "there"})});
+  createDuckDbTable({input});
+
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .project({"concat('hello ', c0) AS result"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT concat('hello ', c0) AS result FROM tmp");
+}
+
+TEST_F(CudfStringFunctionTest, concatWithEmptyStrings) {
+  auto input = makeRowVector(
+      {makeFlatVector<std::string>({"", "a", ""}),
+       makeFlatVector<std::string>({"", "", "b"})});
+  createDuckDbTable({input});
+
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .project({"concat(c0, c1) AS result"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT concat(c0, c1) AS result FROM tmp");
+}
+
+TEST_F(CudfStringFunctionTest, concatMultipleLiterals) {
+  auto input = makeRowVector({makeFlatVector<std::string>({"mid"})});
+  createDuckDbTable({input});
+
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .project({"concat('start-', c0, '-end') AS result"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT concat('start-', c0, '-end') AS result FROM tmp");
+}
+
+TEST_F(CudfStringFunctionTest, concatWithNullColumn) {
+  auto input = makeRowVector(
+      {makeNullableFlatVector<std::string>({"hello", std::nullopt, "foo"}),
+       makeNullableFlatVector<std::string>({" world", "bar", std::nullopt})});
+  createDuckDbTable({input});
+
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .project({"concat(c0, c1) AS result"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT concat(c0, c1) AS result FROM tmp");
+}
+
+TEST_F(CudfStringFunctionTest, concatAllNulls) {
+  auto input = makeRowVector(
+      {makeNullableFlatVector<std::string>({std::nullopt, std::nullopt}),
+       makeNullableFlatVector<std::string>({std::nullopt, std::nullopt})});
+  createDuckDbTable({input});
+
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .project({"concat(c0, c1) AS result"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT concat(c0, c1) AS result FROM tmp");
+}
+
+// Input: {"hello", "München"} + {" wörld", " Straße"}
+TEST_F(CudfStringFunctionTest, concatUnicode) {
+  auto input = makeRowVector(
+      {makeFlatVector<std::string>({"hello", "M\xc3\xbcnchen"}),
+       makeFlatVector<std::string>(
+           {" w\xc3\xb6rld",
+            " Stra\xc3\x9f"
+            "e"})});
+  createDuckDbTable({input});
+
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .project({"concat(c0, c1) AS result"})
+                  .planNode();
+
+  assertQuery(plan, "SELECT concat(c0, c1) AS result FROM tmp");
+}
+
+// ---------------------------------------------------------------------------
+// Direct expression tests: exercise the cudf expression evaluator directly
+// via CudfFunctionBaseTest::evaluateOnce.
+// ---------------------------------------------------------------------------
+class CudfStringExprTest : public cudf_velox::CudfFunctionBaseTest {
+ protected:
+  static void SetUpTestCase() {
+    parse::registerTypeResolver();
+    functions::prestosql::registerAllScalarFunctions();
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+    cudf_velox::registerCudf();
+  }
+
+  static void TearDownTestCase() {
+    cudf_velox::unregisterCudf();
+  }
+};
+
+TEST_F(CudfStringExprTest, likeMatch) {
+  auto result = evaluateOnce<bool, std::string>("c0 LIKE '%ell%'", "hello");
+  EXPECT_TRUE(result.value());
+}
+
+TEST_F(CudfStringExprTest, likeNoMatch) {
+  auto result = evaluateOnce<bool, std::string>("c0 LIKE '%xyz%'", "hello");
+  EXPECT_FALSE(result.value());
+}
+
+TEST_F(CudfStringExprTest, likePrefixMatch) {
+  auto result = evaluateOnce<bool, std::string>("c0 LIKE 'hel%'", "hello");
+  EXPECT_TRUE(result.value());
+}
+
+TEST_F(CudfStringExprTest, likeSuffixMatch) {
+  auto result = evaluateOnce<bool, std::string>("c0 LIKE '%llo'", "hello");
+  EXPECT_TRUE(result.value());
+}
+
+TEST_F(CudfStringExprTest, likeExact) {
+  auto result = evaluateOnce<bool, std::string>("c0 LIKE 'hello'", "hello");
+  EXPECT_TRUE(result.value());
+}
+
+TEST_F(CudfStringExprTest, likeSingleChar) {
+  auto result = evaluateOnce<bool, std::string>("c0 LIKE 'h_llo'", "hello");
+  EXPECT_TRUE(result.value());
+}
+
+TEST_F(CudfStringExprTest, likeNullInput) {
+  auto result = evaluateOnce<bool, std::string>(
+      "c0 LIKE '%el%'", std::optional<std::string>(std::nullopt));
+  EXPECT_FALSE(result.has_value());
+}
+
+// "café" LIKE '%fé'
+TEST_F(CudfStringExprTest, likeUnicode) {
+  auto result = evaluateOnce<bool, std::string>(
+      "c0 LIKE '%f\xc3\xa9'", std::string("caf\xc3\xa9"));
+  EXPECT_TRUE(result.value());
+}
+
+// "cafe" (no accent) should NOT match '%fé'
+TEST_F(CudfStringExprTest, likeUnicodeNoMatch) {
+  auto result = evaluateOnce<bool, std::string>(
+      "c0 LIKE '%f\xc3\xa9'", std::string("cafe"));
+  EXPECT_FALSE(result.value());
+}
+
+TEST_F(CudfStringExprTest, upperBasic) {
+  auto result = evaluateOnce<std::string, std::string>("upper(c0)", "hello");
+  EXPECT_EQ(result.value(), "HELLO");
+}
+
+TEST_F(CudfStringExprTest, upperMixedCase) {
+  auto result = evaluateOnce<std::string, std::string>("upper(c0)", "HeLLo");
+  EXPECT_EQ(result.value(), "HELLO");
+}
+
+TEST_F(CudfStringExprTest, upperEmpty) {
+  auto result = evaluateOnce<std::string, std::string>("upper(c0)", "");
+  EXPECT_EQ(result.value(), "");
+}
+
+TEST_F(CudfStringExprTest, upperNullInput) {
+  auto result = evaluateOnce<std::string, std::string>(
+      "upper(c0)", std::optional<std::string>(std::nullopt));
+  EXPECT_FALSE(result.has_value());
+}
+
+// upper("café") -> "CAFÉ"
+TEST_F(CudfStringExprTest, upperUnicode) {
+  auto result = evaluateOnce<std::string, std::string>(
+      "upper(c0)", std::string("caf\xc3\xa9"));
+  EXPECT_EQ(result.value(), "CAF\xc3\x89");
+}
+
+TEST_F(CudfStringExprTest, lowerBasic) {
+  auto result = evaluateOnce<std::string, std::string>("lower(c0)", "HELLO");
+  EXPECT_EQ(result.value(), "hello");
+}
+
+TEST_F(CudfStringExprTest, lowerMixedCase) {
+  auto result = evaluateOnce<std::string, std::string>("lower(c0)", "HeLLo");
+  EXPECT_EQ(result.value(), "hello");
+}
+
+TEST_F(CudfStringExprTest, lowerEmpty) {
+  auto result = evaluateOnce<std::string, std::string>("lower(c0)", "");
+  EXPECT_EQ(result.value(), "");
+}
+
+TEST_F(CudfStringExprTest, lowerNullInput) {
+  auto result = evaluateOnce<std::string, std::string>(
+      "lower(c0)", std::optional<std::string>(std::nullopt));
+  EXPECT_FALSE(result.has_value());
+}
+
+// lower("CAFÉ") -> "café"
+TEST_F(CudfStringExprTest, lowerUnicode) {
+  auto result = evaluateOnce<std::string, std::string>(
+      "lower(c0)", std::string("CAF\xc3\x89"));
+  EXPECT_EQ(result.value(), "caf\xc3\xa9");
+}
+
+TEST_F(CudfStringExprTest, concatTwoArgs) {
+  auto result = evaluateOnce<std::string, std::string, std::string>(
+      "concat(c0, c1)", "hello", " world");
+  EXPECT_EQ(result.value(), "hello world");
+}
+
+TEST_F(CudfStringExprTest, concatWithLiteral) {
+  auto result =
+      evaluateOnce<std::string, std::string>("concat(c0, '!')", "hello");
+  EXPECT_EQ(result.value(), "hello!");
+}
+
+TEST_F(CudfStringExprTest, concatLiteralFirst) {
+  auto result =
+      evaluateOnce<std::string, std::string>("concat('hi ', c0)", "there");
+  EXPECT_EQ(result.value(), "hi there");
+}
+
+TEST_F(CudfStringExprTest, concatEmptyStrings) {
+  auto result = evaluateOnce<std::string, std::string, std::string>(
+      "concat(c0, c1)", "", "");
+  EXPECT_EQ(result.value(), "");
+}
+
+TEST_F(CudfStringExprTest, concatWithNullArg) {
+  auto result = evaluateOnce<std::string, std::string, std::string>(
+      "concat(c0, c1)",
+      std::optional<std::string>("hello"),
+      std::optional<std::string>(std::nullopt));
+  // Velox CPU, DuckDB, and cudf treat nulls as empty strings here.
+  EXPECT_EQ(result.value(), "hello");
+}
+
+// concat("hello", " wörld") -> "hello wörld"
+TEST_F(CudfStringExprTest, concatUnicode) {
+  auto result = evaluateOnce<std::string, std::string, std::string>(
+      "concat(c0, c1)", std::string("hello"), std::string(" w\xc3\xb6rld"));
+  EXPECT_EQ(result.value(), "hello w\xc3\xb6rld");
+}
+
+} // namespace
diff --git a/velox/experimental/cudf/tests/SubfieldFilterAstTest.cpp b/velox/experimental/cudf/tests/SubfieldFilterAstTest.cpp
index 928ac314c85..a2d1317f772 100644
--- a/velox/experimental/cudf/tests/SubfieldFilterAstTest.cpp
+++ b/velox/experimental/cudf/tests/SubfieldFilterAstTest.cpp
@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-#include "velox/experimental/cudf/exec/ExpressionEvaluator.h"
 #include "velox/experimental/cudf/exec/ToCudf.h"
 #include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+#include "velox/experimental/cudf/expression/SubfieldFiltersToAst.h"
 
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
@@ -67,8 +67,8 @@ class SubfieldFilterAstTest : public OperatorTestBase {
     auto mr = cudf::get_current_device_resource_ref();
 
     {
-      auto cudfTable =
-          cudf_velox::with_arrow::toCudfTable(vector, pool_.get(), stream);
+      auto cudfTable = cudf_velox::with_arrow::toCudfTable(
+          vector, pool_.get(), stream, cudf::get_current_device_resource_ref());
       ASSERT_NE(cudfTable, nullptr);
 
       auto cudfResult =
@@ -88,7 +88,11 @@ class SubfieldFilterAstTest : public OperatorTestBase {
       resultTable = std::make_unique<cudf::table>(std::move(cols));
 
       auto veloxBoolRow = cudf_velox::with_arrow::toVeloxColumn(
-          resultTable->view(), pool_.get(), "cmp_", stream);
+          resultTable->view(),
+          pool_.get(),
+          "cmp_",
+          stream,
+          cudf::get_current_device_resource_ref());
       auto boolVector = veloxBoolRow->childAt(0)->asFlatVector<bool>();
       boolVector->loadedVector();
 
@@ -138,6 +142,11 @@ class SubfieldFilterAstTest : public OperatorTestBase {
             veloxExpected = filter.testBool(v);
             break;
           }
+          case TypeKind::HUGEINT: {
+            auto v = fieldVec->asFlatVector<int128_t>()->valueAt(i);
+            veloxExpected = filter.testInt128(v);
+            break;
+          }
           case TypeKind::VARCHAR: {
             auto sv = fieldVec->asFlatVector<StringView>()->valueAt(i);
             veloxExpected = filter.testBytes(sv.data(), sv.size());
@@ -399,6 +408,73 @@ TEST_F(SubfieldFilterAstTest, Int32SingleValueOutOfRange) {
   testFilterExecution(rowType, columnName, *filter, vec, expr);
 }
 
+// Single value at the exact type boundary (INT32_MAX on INTEGER column).
+// The value is representable so the filter should match.
+TEST_F(SubfieldFilterAstTest, Int32SingleValueAtMax) {
+  const std::string columnName = "c0";
+  auto rowType = ROW({{columnName, INTEGER()}});
+  const int64_t value = std::numeric_limits<int32_t>::max();
+  auto filter = std::make_unique<common::BigintRange>(
+      value, value, /*nullAllowed*/ false);
+
+  common::Subfield subfield(columnName);
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+
+  EXPECT_GT(tree.size(), 0UL);
+  EXPECT_EQ(scalars.size(), 1UL)
+      << "Single value at INT32_MAX should create 1 scalar for equality";
+
+  auto vec = makeTestVector(rowType, 100);
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
+// Single value at the exact type boundary (INT32_MIN on INTEGER column).
+TEST_F(SubfieldFilterAstTest, Int32SingleValueAtMin) {
+  const std::string columnName = "c0";
+  auto rowType = ROW({{columnName, INTEGER()}});
+  const int64_t value = std::numeric_limits<int32_t>::min();
+  auto filter = std::make_unique<common::BigintRange>(
+      value, value, /*nullAllowed*/ false);
+
+  common::Subfield subfield(columnName);
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+
+  EXPECT_GT(tree.size(), 0UL);
+  EXPECT_EQ(scalars.size(), 1UL)
+      << "Single value at INT32_MIN should create 1 scalar for equality";
+
+  auto vec = makeTestVector(rowType, 100);
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
+// Single value at TINYINT boundary (127 on TINYINT column).
+TEST_F(SubfieldFilterAstTest, TinyIntSingleValueAtMax) {
+  const std::string columnName = "c0";
+  auto rowType = ROW({{columnName, TINYINT()}});
+  const int64_t value = std::numeric_limits<int8_t>::max();
+  auto filter = std::make_unique<common::BigintRange>(
+      value, value, /*nullAllowed*/ false);
+
+  common::Subfield subfield(columnName);
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+
+  EXPECT_GT(tree.size(), 0UL);
+  EXPECT_EQ(scalars.size(), 1UL)
+      << "Single value at INT8_MAX should create 1 scalar for equality";
+
+  auto vec = makeTestVector(rowType, 100);
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
 // Type boundary tests
 TEST_F(SubfieldFilterAstTest, IntegerOverflowBounds) {
   const std::string columnName = "c0";
@@ -471,6 +547,42 @@ TEST_F(SubfieldFilterAstTest, SmallIntTypeBounds) {
   testFilterExecution(rowType, columnName, *filter, vec, expr);
 }
 
+TEST_F(SubfieldFilterAstTest, DecimalRange) {
+  const std::string columnName = "c0";
+  auto rowType = ROW({{columnName, DECIMAL(20, 2)}});
+  // Range [1.23, 4.56] encoded as unscaled integer values.
+  auto filter = std::make_unique<common::HugeintRange>(
+      int128_t{123}, int128_t{456}, /*nullAllowed*/ false);
+
+  common::Subfield subfield(columnName);
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+
+  EXPECT_GT(tree.size(), 0UL);
+  auto vec = makeTestVector(rowType, 100);
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
+TEST_F(SubfieldFilterAstTest, DecimalInList) {
+  const std::string columnName = "c0";
+  auto rowType = ROW({{columnName, DECIMAL(20, 2)}});
+  // Values [1.23, 4.56] encoded as unscaled integer values.
+  std::vector<int128_t> values = {int128_t{123}, int128_t{456}};
+  auto filter = common::createHugeintValues(values, /*nullAllowed*/ false);
+
+  common::Subfield subfield(columnName);
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+
+  EXPECT_GT(tree.size(), 0UL);
+  auto vec = makeTestVector(rowType, 100);
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
 TEST_F(SubfieldFilterAstTest, EmptyInListHandling) {
   auto rowType = ROW({{"c0", BIGINT()}});
   std::vector<int64_t> emptyVals = {};
@@ -530,8 +642,8 @@ TEST_F(SubfieldFilterAstTest, MultipleSubfieldFilters) {
   auto stream = cudf::get_default_stream();
   auto mr = cudf::get_current_device_resource_ref();
 
-  auto cudfTable =
-      cudf_velox::with_arrow::toCudfTable(vec, pool_.get(), stream);
+  auto cudfTable = cudf_velox::with_arrow::toCudfTable(
+      vec, pool_.get(), stream, cudf::get_current_device_resource_ref());
   ASSERT_NE(cudfTable, nullptr);
   auto cudfResult =
       cudf::compute_column(cudfTable->view(), combinedExpr, stream, mr);
@@ -547,7 +659,11 @@ TEST_F(SubfieldFilterAstTest, MultipleSubfieldFilters) {
       std::move(const_cast<std::unique_ptr<cudf::column>&>(cudfResult)));
   resultTable = std::make_unique<cudf::table>(std::move(cols));
   auto veloxBoolRow = cudf_velox::with_arrow::toVeloxColumn(
-      resultTable->view(), pool_.get(), "cmp_", stream);
+      resultTable->view(),
+      pool_.get(),
+      "cmp_",
+      stream,
+      cudf::get_current_device_resource_ref());
   auto boolVector = veloxBoolRow->childAt(0)->asFlatVector<bool>();
   boolVector->loadedVector();
 
@@ -649,8 +765,7 @@ TEST_P(IntInListParamTest, InListParam) {
     }
   }
   EXPECT_EQ(scalars.size(), expectedScalars)
-      << "Scalar count mismatch for IN list with kind "
-      << mapTypeKindToName(p.kind);
+      << "Scalar count mismatch for IN list with kind " << p.kind;
 
   auto vec = makeTestVector(rowType, 100);
   testFilterExecution(rowType, columnName, *filter, vec, expr);
@@ -682,4 +797,256 @@ INSTANTIATE_TEST_SUITE_P(
       return std::string(info.param.name);
     });
 
+struct BigintMultiRangeCase {
+  TypeKind kind;
+  std::vector<std::pair<int64_t, int64_t>> ranges;
+  const char* name;
+};
+
+class BigintMultiRangeParamTest
+    : public SubfieldFilterAstTest,
+      public ::testing::WithParamInterface<BigintMultiRangeCase> {};
+
+TEST_P(BigintMultiRangeParamTest, BigintMultiRange) {
+  const auto& p = GetParam();
+  const std::string columnName = "c0";
+  auto rowType = ROW({{columnName, buildTypeForKind(p.kind)}});
+
+  std::vector<std::unique_ptr<common::BigintRange>> ranges;
+  for (const auto& [lower, upper] : p.ranges) {
+    ranges.push_back(
+        std::make_unique<common::BigintRange>(
+            lower, upper, /*nullAllowed*/ false));
+  }
+  auto filter = std::make_unique<common::BigintMultiRange>(
+      std::move(ranges), /*nullAllowed*/ false);
+
+  common::Subfield subfield(columnName);
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+
+  ASSERT_GT(tree.size(), 0UL);
+  // Each range needs 2 scalars (lower and upper bound).
+  EXPECT_EQ(scalars.size(), p.ranges.size() * 2);
+
+  auto vec = makeTestVector(rowType, 100);
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    BigintMultiRange,
+    BigintMultiRangeParamTest,
+    ::testing::Values(
+        BigintMultiRangeCase{TypeKind::BIGINT, {{1, 5}, {10, 20}}, "Bigint"},
+        BigintMultiRangeCase{TypeKind::INTEGER, {{5, 15}, {20, 30}}, "Integer"},
+        BigintMultiRangeCase{
+            TypeKind::SMALLINT,
+            {{1, 100}, {200, 300}},
+            "SmallInt"},
+        BigintMultiRangeCase{
+            TypeKind::TINYINT,
+            {{-100, -50}, {10, 50}},
+            "TinyInt"},
+        BigintMultiRangeCase{
+            TypeKind::BIGINT,
+            {{1, 10}, {20, 30}, {50, 60}},
+            "ThreeRanges"}),
+    [](const ::testing::TestParamInfo<BigintMultiRangeCase>& info) {
+      return std::string(info.param.name);
+    });
+
+// MultiRange tests (FilterKind::kMultiRange)
+// MultiRange wraps arbitrary sub-filters with OR semantics. Common use case:
+// not-equal predicates represented as (< X) OR (> X).
+TEST_F(SubfieldFilterAstTest, MultiRangeDoubleNotEqual) {
+  const std::string columnName = "c0";
+  auto rowType = ROW({{columnName, DOUBLE()}});
+
+  // Create "!= 5.0" which is represented as (< 5.0) OR (> 5.0)
+  std::vector<std::unique_ptr<common::Filter>> filters;
+  // Range: (-inf, 5.0) exclusive
+  filters.push_back(
+      std::make_unique<common::DoubleRange>(
+          std::numeric_limits<double>::lowest(),
+          /*lowerUnbounded*/ true,
+          /*lowerExclusive*/ false,
+          5.0,
+          /*upperUnbounded*/ false,
+          /*upperExclusive*/ true,
+          /*nullAllowed*/ false));
+  // Range: (5.0, +inf) exclusive
+  filters.push_back(
+      std::make_unique<common::DoubleRange>(
+          5.0,
+          /*lowerUnbounded*/ false,
+          /*lowerExclusive*/ true,
+          std::numeric_limits<double>::max(),
+          /*upperUnbounded*/ true,
+          /*upperExclusive*/ false,
+          /*nullAllowed*/ false));
+  auto filter = std::make_unique<common::MultiRange>(
+      std::move(filters), /*nullAllowed*/ false);
+
+  common::Subfield subfield(columnName);
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+
+  ASSERT_GT(tree.size(), 0UL) << "No expressions created for MultiRange";
+  // Each range has one bounded side, so 2 scalars total
+  EXPECT_EQ(scalars.size(), 2UL)
+      << "Expected 2 scalars for double != filter (< 5.0 OR > 5.0)";
+
+  auto vec = makeTestVector(rowType, 100);
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
+TEST_F(SubfieldFilterAstTest, MultiRangeBytesNotEqual) {
+  const std::string columnName = "c0";
+  auto rowType = ROW({{columnName, VARCHAR()}});
+
+  // Create "!= 'hello'" which is represented as (< 'hello') OR (> 'hello')
+  std::vector<std::unique_ptr<common::Filter>> filters;
+  // Range: (-inf, 'hello') exclusive
+  filters.push_back(
+      std::make_unique<common::BytesRange>(
+          "",
+          /*lowerUnbounded*/ true,
+          /*lowerExclusive*/ false,
+          "hello",
+          /*upperUnbounded*/ false,
+          /*upperExclusive*/ true,
+          /*nullAllowed*/ false));
+  // Range: ('hello', +inf) exclusive
+  filters.push_back(
+      std::make_unique<common::BytesRange>(
+          "hello",
+          /*lowerUnbounded*/ false,
+          /*lowerExclusive*/ true,
+          "",
+          /*upperUnbounded*/ true,
+          /*upperExclusive*/ false,
+          /*nullAllowed*/ false));
+  auto filter = std::make_unique<common::MultiRange>(
+      std::move(filters), /*nullAllowed*/ false);
+
+  common::Subfield subfield(columnName);
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+
+  ASSERT_GT(tree.size(), 0UL) << "No expressions created for BytesRange";
+  EXPECT_EQ(scalars.size(), 2UL)
+      << "Expected 2 scalars for bytes != filter (< 'hello' OR > 'hello')";
+
+  // Create test data with known values
+  auto strings = makeFlatVector<std::string>(std::vector<std::string>{
+      "alpha", "hello", "world", "hello", "zebra", "apple"});
+  auto vec = makeRowVector({columnName}, {strings});
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
+TEST_F(SubfieldFilterAstTest, MultiRangeSingleFilter) {
+  const std::string columnName = "c0";
+  auto rowType = ROW({{columnName, DOUBLE()}});
+
+  // Single filter in MultiRange: just (> 10.0)
+  std::vector<std::unique_ptr<common::Filter>> filters;
+  filters.push_back(
+      std::make_unique<common::DoubleRange>(
+          10.0,
+          /*lowerUnbounded*/ false,
+          /*lowerExclusive*/ true,
+          std::numeric_limits<double>::max(),
+          /*upperUnbounded*/ true,
+          /*upperExclusive*/ false,
+          /*nullAllowed*/ false));
+  auto filter = std::make_unique<common::MultiRange>(
+      std::move(filters), /*nullAllowed*/ false);
+
+  common::Subfield subfield(columnName);
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+
+  ASSERT_GT(tree.size(), 0UL)
+      << "No expressions created for single-filter case";
+  EXPECT_EQ(scalars.size(), 1UL)
+      << "Expected 1 scalar for single bounded range";
+
+  auto vec = makeTestVector(rowType, 100);
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
+TEST_F(SubfieldFilterAstTest, MultiRangeMixedFilters) {
+  const std::string columnName = "c0";
+  auto rowType = ROW({{columnName, REAL()}});
+
+  // Multiple float ranges: [0.0, 1.0] OR [5.0, 10.0] OR [20.0, 30.0]
+  std::vector<std::unique_ptr<common::Filter>> filters;
+  filters.push_back(
+      std::make_unique<common::FloatRange>(
+          0.0f,
+          /*lowerUnbounded*/ false,
+          /*lowerExclusive*/ false,
+          1.0f,
+          /*upperUnbounded*/ false,
+          /*upperExclusive*/ false,
+          /*nullAllowed*/ false));
+  filters.push_back(
+      std::make_unique<common::FloatRange>(
+          5.0f,
+          /*lowerUnbounded*/ false,
+          /*lowerExclusive*/ false,
+          10.0f,
+          /*upperUnbounded*/ false,
+          /*upperExclusive*/ false,
+          /*nullAllowed*/ false));
+  filters.push_back(
+      std::make_unique<common::FloatRange>(
+          20.0f,
+          /*lowerUnbounded*/ false,
+          /*lowerExclusive*/ false,
+          30.0f,
+          /*upperUnbounded*/ false,
+          /*upperExclusive*/ false,
+          /*nullAllowed*/ false));
+  auto filter = std::make_unique<common::MultiRange>(
+      std::move(filters), /*nullAllowed*/ false);
+
+  common::Subfield subfield(columnName);
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+
+  ASSERT_GT(tree.size(), 0UL) << "No expressions created for mixed filters";
+  // Each bounded range has 2 scalars, so 6 total
+  EXPECT_EQ(scalars.size(), 6UL)
+      << "Expected 6 scalars for three bounded float ranges";
+
+  auto vec = makeTestVector(rowType, 100);
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
+TEST_F(SubfieldFilterAstTest, EmptyMultiRangeThrows) {
+  auto rowType = ROW({{"c0", DOUBLE()}});
+
+  // MultiRange with empty filter list should throw.
+  auto filter = std::make_unique<common::MultiRange>(
+      std::vector<std::unique_ptr<common::Filter>>{}, /*nullAllowed*/ false);
+
+  common::Subfield subfield("c0");
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+  EXPECT_THROW(
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType),
+      VeloxException);
+}
+
 } // namespace
diff --git a/velox/experimental/cudf/tests/TableScanTest.cpp b/velox/experimental/cudf/tests/TableScanTest.cpp
index c2c5e645f59..ba44ce8bc41 100644
--- a/velox/experimental/cudf/tests/TableScanTest.cpp
+++ b/velox/experimental/cudf/tests/TableScanTest.cpp
@@ -19,15 +19,19 @@
 #include "velox/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.h"
 #include "velox/experimental/cudf/connectors/hive/CudfHiveDataSource.h"
 #include "velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.h"
+#include "velox/experimental/cudf/expression/SubfieldFiltersToAst.h"
 #include "velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.h"
 
+#include "velox/common/base/Fs.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/tests/FaultyFile.h"
 #include "velox/common/file/tests/FaultyFileSystem.h"
 #include "velox/common/memory/MemoryArbitrator.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/dwio/common/tests/utils/DataFiles.h"
 #include "velox/exec/Exchange.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/TableScan.h"
@@ -35,14 +39,16 @@
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/LocalExchangeSource.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/expression/ExprToSubfieldFilter.h"
 #include "velox/type/Type.h"
 #include "velox/type/tests/SubfieldFiltersBuilder.h"
 
+#include <cudf/io/parquet.hpp>
+
 #include <fmt/ranges.h>
 
 using namespace facebook::velox;
+using namespace facebook::velox::common::testutil;
 using namespace facebook::velox::connector;
 using namespace facebook::velox::core;
 using namespace facebook::velox::exec;
@@ -53,6 +59,37 @@ using namespace facebook::velox::cudf_velox;
 using namespace facebook::velox::cudf_velox::exec;
 using namespace facebook::velox::cudf_velox::exec::test;
 
+namespace {
+struct StatsFilterMetrics {
+  cudf::size_type inputRowGroups{0};
+  std::optional<cudf::size_type> rowGroupsAfterStats;
+  cudf::size_type outputRows{0};
+};
+
+StatsFilterMetrics readParquetWithStatsFilter(
+    const std::string& filePath,
+    const RowTypePtr& rowType,
+    const common::SubfieldFilters& filters,
+    bool useJitFilter) {
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+  auto const& expr =
+      createAstFromSubfieldFilters(filters, tree, scalars, rowType);
+
+  auto options =
+      cudf::io::parquet_reader_options::builder(cudf::io::source_info(filePath))
+          .use_jit_filter(useJitFilter)
+          .build();
+  options.set_filter(expr);
+
+  auto result = cudf::io::read_parquet(options);
+  return {
+      result.metadata.num_input_row_groups,
+      result.metadata.num_row_groups_after_stats_filter,
+      result.tbl->num_rows()};
+}
+} // namespace
+
 class TableScanTest : public virtual CudfHiveConnectorTestBase {
  protected:
   void SetUp() override {
@@ -175,10 +212,13 @@ class TableScanTest : public virtual CudfHiveConnectorTestBase {
            REAL()})};
 };
 
-TEST_F(TableScanTest, allColumns) {
+class TableScanTestParameterized : public TableScanTest,
+                                   public testing::WithParamInterface<bool> {};
+
+TEST_P(TableScanTestParameterized, allColumns) {
   auto vectors = makeVectors(10, 1'000);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->getPath(), vectors, "c");
+  writeToFile(filePath->getPath(), vectors);
 
   createDuckDbTable(vectors);
   auto plan = tableScanNode();
@@ -210,6 +250,14 @@ TEST_F(TableScanTest, allColumns) {
         // ASSERT_LT(0, it->second.customStats.at("ioWaitWallNanos").sum);
       };
 
+  const bool useBufferedInput = GetParam();
+  auto config = std::unordered_map<std::string, std::string>{
+      {facebook::velox::cudf_velox::connector::hive::CudfHiveConfig::
+           kUseBufferedInput,
+       useBufferedInput ? "true" : "false"}};
+  resetCudfHiveConnector(
+      std::make_shared<config::ConfigBase>(std::move(config)));
+
   // Test scan all columns with CudfHiveConnectorSplits
   {
     auto splits = makeCudfHiveConnectorSplits({filePath});
@@ -218,29 +266,75 @@ TEST_F(TableScanTest, allColumns) {
 
   // Test scan all columns with HiveConnectorSplits
   {
-    // Lambda to create HiveConnectorSplits from file paths
-    auto makeHiveConnectorSplits =
-        [&](const std::vector<std::shared_ptr<
-                facebook::velox::exec::test::TempFilePath>>& filePaths) {
-          std::vector<
-              std::shared_ptr<facebook::velox::connector::ConnectorSplit>>
-              splits;
-          for (const auto& filePath : filePaths) {
-            splits.push_back(
-                facebook::velox::connector::hive::HiveConnectorSplitBuilder(
-                    filePath->getPath())
-                    .connectorId(kCudfHiveConnectorId)
-                    .fileFormat(dwio::common::FileFormat::PARQUET)
-                    .build());
-          }
-          return splits;
-        };
-
-    auto splits = makeHiveConnectorSplits({filePath});
+    std::vector<std::shared_ptr<facebook::velox::connector::ConnectorSplit>>
+        splits;
+    splits.push_back(
+        facebook::velox::connector::hive::HiveConnectorSplitBuilder(
+            filePath->getPath())
+            .connectorId(kCudfHiveConnectorId)
+            .fileFormat(dwio::common::FileFormat::PARQUET)
+            .build());
     testScanAllColumns(splits);
   }
 }
 
+TEST_P(TableScanTestParameterized, allColumnsUsingExperimentalReader) {
+  auto vectors = makeVectors(10, 1'000);
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors);
+
+  createDuckDbTable(vectors);
+  const std::string duckDbSql =
+      "SELECT * FROM tmp UNION ALL "
+      "SELECT * FROM tmp UNION ALL "
+      "SELECT * FROM tmp UNION ALL "
+      "SELECT * FROM tmp UNION ALL "
+      "SELECT * FROM tmp";
+
+  auto splits = makeCudfHiveConnectorSplits(
+      {filePath, filePath, filePath, filePath, filePath});
+
+  auto useBufferedInput = GetParam();
+  auto config = std::unordered_map<std::string, std::string>{
+      {facebook::velox::cudf_velox::connector::hive::CudfHiveConfig::
+           kUseExperimentalCudfReader,
+       "true"},
+      {facebook::velox::cudf_velox::connector::hive::CudfHiveConfig::
+           kUseBufferedInput,
+       useBufferedInput ? "true" : "false"}};
+  resetCudfHiveConnector(
+      std::make_shared<config::ConfigBase>(std::move(config)));
+
+  auto plan = tableScanNode();
+  auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                  .plan(plan)
+                  .splits(splits)
+                  .assertResults(duckDbSql);
+
+  // A quick sanity check for memory usage reporting. Check that peak
+  // total memory usage for the project node is > 0.
+  auto planStats = toPlanStats(task->taskStats());
+  auto scanNodeId = plan->id();
+  auto it = planStats.find(scanNodeId);
+  ASSERT_TRUE(it != planStats.end());
+  // TODO (dm): enable this test once we start to track gpu memory
+  // ASSERT_TRUE(it->second.peakMemoryBytes > 0);
+
+  //  Verifies there is no dynamic filter stats.
+  ASSERT_TRUE(it->second.dynamicFilterStats.empty());
+
+  // TODO: We are not writing any customStats yet so disable this check
+  // ASSERT_LT(0, it->second.customStats.at("ioWaitWallNanos").sum);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    ,
+    TableScanTestParameterized,
+    testing::Bool(),
+    [](const testing::TestParamInfo<bool>& info) {
+      return info.param ? "BufferedInput" : "FileDataSource";
+    });
+
 TEST_F(TableScanTest, directBufferInputRawInputBytes) {
   constexpr int kSize = 10;
   auto vector = makeRowVector({
@@ -250,7 +344,7 @@ TEST_F(TableScanTest, directBufferInputRawInputBytes) {
   });
   auto filePath = TempFilePath::create();
   createDuckDbTable({vector});
-  writeToFile(filePath->getPath(), {vector}, "c");
+  writeToFile(filePath->getPath(), {vector});
 
   auto tableHandle = makeTableHandle();
   auto plan = PlanBuilder(pool_.get())
@@ -302,7 +396,7 @@ TEST_F(TableScanTest, directBufferInputRawInputBytes) {
 TEST_F(TableScanTest, columnAliases) {
   auto vectors = makeVectors(1, 1'000);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->getPath(), vectors, "c");
+  writeToFile(filePath->getPath(), vectors);
   createDuckDbTable(vectors);
 
   std::string tableName = "t";
@@ -341,7 +435,7 @@ TEST_F(TableScanTest, filterPushdown) {
           .build();
 
   auto tableHandle = makeTableHandle(
-      "parquet_table", rowType, true, std::move(subfieldFilters), nullptr);
+      "parquet_table", rowType, std::move(subfieldFilters), nullptr);
 
   auto assignments =
       facebook::velox::exec::test::HiveConnectorTestBase::allRegularColumns(
@@ -417,3 +511,238 @@ TEST_F(TableScanTest, filterPushdown) {
       "SELECT count(*) FROM tmp");
 #endif
 }
+
+// Disable this test and the one below for now, pending a CUDF fix.
+// simoneves 2/25/26
+// @TODO simoneves/mattgara re-enable once fixed.
+
+TEST_F(TableScanTest, DISABLED_decimalFilterPushdown) {
+  auto rowType = ROW({"c0", "c1"}, {DECIMAL(12, 2), DECIMAL(20, 2)});
+
+  auto vector = makeRowVector(
+      {"c0", "c1"},
+      {
+          makeFlatVector<int64_t>(
+              {123, 500, -250, 300, 400, 200}, DECIMAL(12, 2)),
+          makeFlatVector<int128_t>(
+              {int128_t{200},
+               int128_t{200},
+               int128_t{700},
+               int128_t{700},
+               int128_t{900},
+               int128_t{-100}},
+              DECIMAL(20, 2)),
+      });
+
+  std::vector<RowVectorPtr> vectors = {vector};
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors);
+  createDuckDbTable(vectors);
+
+  // c0 between 1.00 and 4.00 and c1 in (2.00, 7.00)
+  common::SubfieldFilters subfieldFilters =
+      common::test::SubfieldFiltersBuilder()
+          .add(
+              "c0",
+              std::make_unique<common::BigintRange>(
+                  int64_t{100}, int64_t{400}, /*nullAllowed*/ false))
+          .add(
+              "c1",
+              common::createHugeintValues(
+                  {int128_t{200}, int128_t{700}}, /*nullAllowed*/ false))
+          .build();
+
+  auto tableHandle = makeTableHandle(
+      "parquet_table", rowType, std::move(subfieldFilters), nullptr);
+
+  auto assignments =
+      facebook::velox::exec::test::HiveConnectorTestBase::allRegularColumns(
+          rowType);
+
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(rowType)
+                  .tableHandle(tableHandle)
+                  .assignments(assignments)
+                  .endTableScan()
+                  .planNode();
+
+  assertQuery(
+      plan,
+      {filePath},
+      "SELECT c0, c1 FROM tmp "
+      "WHERE c0 BETWEEN CAST('1.00' AS DECIMAL(12, 2)) "
+      "AND CAST('4.00' AS DECIMAL(12, 2)) "
+      "AND c1 IN (CAST('2.00' AS DECIMAL(20, 2)), "
+      "CAST('7.00' AS DECIMAL(20, 2)))");
+}
+
+TEST_F(TableScanTest, DISABLED_decimalStatsFilterIoPruning) {
+  auto rowType = ROW({"c0", "c1"}, {DECIMAL(12, 2), DECIMAL(20, 2)});
+  auto vec0 = makeRowVector(
+      {"c0", "c1"},
+      {makeFlatVector<int64_t>({100, 200}, DECIMAL(12, 2)),
+       makeFlatVector<int128_t>(
+           {int128_t{1000}, int128_t{2000}}, DECIMAL(20, 2))});
+  auto vec1 = makeRowVector(
+      {"c0", "c1"},
+      {makeFlatVector<int64_t>({300, 400}, DECIMAL(12, 2)),
+       makeFlatVector<int128_t>(
+           {int128_t{3000}, int128_t{4000}}, DECIMAL(20, 2))});
+  auto vec2 = makeRowVector(
+      {"c0", "c1"},
+      {makeFlatVector<int64_t>({500, 600}, DECIMAL(12, 2)),
+       makeFlatVector<int128_t>(
+           {int128_t{5000}, int128_t{6000}}, DECIMAL(20, 2))});
+
+  std::vector<RowVectorPtr> vectors = {vec0, vec1, vec2};
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors);
+
+  common::SubfieldFilters filters =
+      common::test::SubfieldFiltersBuilder()
+          .add(
+              "c0",
+              std::make_unique<common::BigintRange>(
+                  int64_t{300}, int64_t{400}, /*nullAllowed*/ false))
+          .add(
+              "c1",
+              std::make_unique<common::HugeintRange>(
+                  int128_t{3000}, int128_t{4000}, /*nullAllowed*/ false))
+          .build();
+
+  auto metrics = readParquetWithStatsFilter(
+      filePath->getPath(), rowType, filters, /*useJitFilter*/ true);
+  EXPECT_EQ(metrics.inputRowGroups, 3);
+  ASSERT_TRUE(metrics.rowGroupsAfterStats.has_value());
+  EXPECT_EQ(metrics.rowGroupsAfterStats.value(), 1);
+  EXPECT_EQ(metrics.outputRows, 2);
+}
+
+TEST_F(TableScanTest, doubleStatsFilterIoPruning) {
+  auto rowType = ROW({"c0", "c1"}, {DOUBLE(), DOUBLE()});
+  auto vec0 = makeRowVector(
+      {"c0", "c1"},
+      {makeFlatVector<double>({1.0, 2.0}),
+       makeFlatVector<double>({10.0, 20.0})});
+  auto vec1 = makeRowVector(
+      {"c0", "c1"},
+      {makeFlatVector<double>({3.0, 4.0}),
+       makeFlatVector<double>({30.0, 40.0})});
+  auto vec2 = makeRowVector(
+      {"c0", "c1"},
+      {makeFlatVector<double>({5.0, 6.0}),
+       makeFlatVector<double>({50.0, 60.0})});
+
+  std::vector<RowVectorPtr> vectors = {vec0, vec1, vec2};
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors);
+
+  common::SubfieldFilters filters =
+      common::test::SubfieldFiltersBuilder()
+          .add(
+              "c0",
+              std::make_unique<common::DoubleRange>(
+                  3.0,
+                  /*lowerUnbounded*/ false,
+                  /*lowerExclusive*/ false,
+                  4.0,
+                  /*upperUnbounded*/ false,
+                  /*upperExclusive*/ false,
+                  /*nullAllowed*/ false))
+          .add(
+              "c1",
+              std::make_unique<common::DoubleRange>(
+                  30.0,
+                  /*lowerUnbounded*/ false,
+                  /*lowerExclusive*/ false,
+                  40.0,
+                  /*upperUnbounded*/ false,
+                  /*upperExclusive*/ false,
+                  /*nullAllowed*/ false))
+          .build();
+
+  auto metrics = readParquetWithStatsFilter(
+      filePath->getPath(), rowType, filters, /*useJitFilter*/ true);
+  EXPECT_EQ(metrics.inputRowGroups, 3);
+  ASSERT_TRUE(metrics.rowGroupsAfterStats.has_value());
+  EXPECT_EQ(metrics.rowGroupsAfterStats.value(), 1);
+  EXPECT_EQ(metrics.outputRows, 2);
+}
+
+TEST_F(TableScanTest, splitOffsetAndLength) {
+  auto vectors = makeVectors(10, 1'000);
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors);
+  createDuckDbTable(vectors);
+
+  // Note that the number of row groups selected within `halfFileSize` may
+  // change in the future and this test may start failing. In such a case,
+  // just adjust the duckdb sql string accordingly.
+  const auto halfFileSize = fs::file_size(filePath->getPath()) / 2;
+
+  // First half of file - OFFSET 0 LIMIT 6000
+  assertQuery(
+      tableScanNode(),
+      makeCudfHiveConnectorSplit(filePath->getPath(), 0, halfFileSize),
+      "SELECT * FROM tmp OFFSET 0 LIMIT 6000");
+
+  // Second half of file - OFFSET 6000 LIMIT 4000
+  assertQuery(
+      tableScanNode(),
+      makeCudfHiveConnectorSplit(filePath->getPath(), halfFileSize),
+      "SELECT * FROM tmp OFFSET 6000 LIMIT 4000");
+
+  const auto fileSize = fs::file_size(filePath->getPath());
+
+  // All row groups
+  assertQuery(
+      tableScanNode(),
+      makeCudfHiveConnectorSplit(filePath->getPath(), 0, fileSize),
+      "SELECT * FROM tmp");
+
+  // No row groups
+  assertQuery(
+      tableScanNode(),
+      makeCudfHiveConnectorSplit(filePath->getPath(), fileSize),
+      "SELECT * FROM tmp LIMIT 0");
+}
+
+// Verify that extractFiltersFromRemainingFilter extracts simple single-column
+// filters from the remaining filter into subfield filters for pushdown.
+// When a filter like "c0 = 1" is fully extracted, remainingFilterExprSet_ is
+// null and totalRemainingFilterWallNanos is 0. Without extraction, the filter
+// runs post-read on the GPU and the stat is > 0.
+TEST_F(TableScanTest, remainingFilterExtraction) {
+  auto rowType = ROW({"c0", "c1", "c2"}, {BIGINT(), BIGINT(), DOUBLE()});
+  auto vectors = makeVectors(5, 1'000, rowType);
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors);
+  createDuckDbTable(vectors);
+
+  auto assignments =
+      facebook::velox::exec::test::HiveConnectorTestBase::allRegularColumns(
+          rowType);
+
+  // "c0 = 1" is a single-column equality that should be fully extracted into
+  // a subfield filter, leaving no remaining filter to evaluate post-read.
+  auto plan = PlanBuilder(pool_.get())
+                  .startTableScan()
+                  .connectorId(kCudfHiveConnectorId)
+                  .outputType(rowType)
+                  .dataColumns(rowType)
+                  .assignments(assignments)
+                  .remainingFilter("c0 = 1")
+                  .endTableScan()
+                  .planNode();
+
+  auto task = assertQuery(plan, {filePath}, "SELECT * FROM tmp WHERE c0 = 1");
+
+  // Verify the filter was fully extracted: no post-read remaining filter ran.
+  auto planStats = toPlanStats(task->taskStats());
+  const auto& scanStats = planStats.at(plan->id());
+  auto it = scanStats.customStats.find("totalRemainingFilterWallNanos");
+  ASSERT_NE(it, scanStats.customStats.end());
+  EXPECT_EQ(it->second.sum, 0)
+      << "Expected no remaining filter time when filter is fully extracted";
+}
diff --git a/velox/experimental/cudf/tests/TableWriteTest.cpp b/velox/experimental/cudf/tests/TableWriteTest.cpp
index b19e642062a..88c8deefd87 100644
--- a/velox/experimental/cudf/tests/TableWriteTest.cpp
+++ b/velox/experimental/cudf/tests/TableWriteTest.cpp
@@ -25,6 +25,7 @@
 
 #include "folly/dynamic.h"
 #include "velox/common/base/Fs.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/dwio/common/Options.h"
 #include "velox/dwio/common/WriterFactory.h"
@@ -33,8 +34,8 @@
 #include "velox/exec/tests/utils/ArbitratorTestUtil.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
+#include <gflags/gflags.h>
 #include <re2/re2.h>
 
 #include <string>
@@ -55,6 +56,8 @@ using namespace facebook::velox::cudf_velox::exec::test;
 
 constexpr uint64_t kQueryMemoryCapacity = 512 * MB;
 
+DEFINE_bool(velox_cudf_debug, false, "Enable debug printing");
+
 namespace {
 
 static core::ColumnStatsSpec generateColumnStatsSpec(
@@ -154,7 +157,7 @@ class TableWriteTest : public CudfHiveConnectorTestBase {
         commitStrategy_(testParam_.commitStrategy()),
         compressionKind_(testParam_.compressionKind()) {
     LOG(INFO) << testParam_.toString();
-    if (cudfDebugEnabled()) {
+    if (FLAGS_velox_cudf_debug) {
       std::cout << testParam_.toString() << std::endl;
     }
 
@@ -175,8 +178,9 @@ class TableWriteTest : public CudfHiveConnectorTestBase {
       bool spillEnabled = false) {
     std::vector<Split> splits;
     for (const auto& filePath : filePaths) {
-      splits.push_back(facebook::velox::exec::Split(
-          makeCudfHiveConnectorSplit(filePath->getPath())));
+      splits.push_back(
+          facebook::velox::exec::Split(
+              makeCudfHiveConnectorSplit(filePath->getPath())));
     }
     if (!spillEnabled) {
       return AssertQueryBuilder(plan, duckDbQueryRunner_)
@@ -267,8 +271,9 @@ class TableWriteTest : public CudfHiveConnectorTestBase {
 
     for (auto& path : fs::recursive_directory_iterator(directoryPath)) {
       if (path.is_regular_file()) {
-        splits.push_back(CudfHiveConnectorTestBase::makeCudfHiveConnectorSplits(
-            path.path().string(), 1)[0]);
+        splits.push_back(
+            CudfHiveConnectorTestBase::makeCudfHiveConnectorSplits(
+                path.path().string(), 1)[0]);
       }
     }
 
@@ -294,8 +299,9 @@ class TableWriteTest : public CudfHiveConnectorTestBase {
     std::vector<std::shared_ptr<facebook::velox::connector::ConnectorSplit>>
         splits;
     for (const auto& filePath : filePaths) {
-      splits.push_back(CudfHiveConnectorTestBase::makeCudfHiveConnectorSplits(
-          filePath.string(), 1)[0]);
+      splits.push_back(
+          CudfHiveConnectorTestBase::makeCudfHiveConnectorSplits(
+              filePath.string(), 1)[0]);
     }
     return splits;
   }
@@ -525,20 +531,22 @@ class TableWriteTest : public CudfHiveConnectorTestBase {
       const std::string& targetDir) {
     ASSERT_EQ(filePath.parent_path().string(), targetDir);
     if (commitStrategy_ == CommitStrategy::kNoCommit) {
-      ASSERT_TRUE(RE2::FullMatch(
-          filePath.filename().string(),
-          fmt::format(
-              "test_cursor.+_[0-{}]_{}_.+",
-              numTableWriterCount_ - 1,
-              tableWriteNodeId_)))
+      ASSERT_TRUE(
+          RE2::FullMatch(
+              filePath.filename().string(),
+              fmt::format(
+                  "test_cursor.+_[0-{}]_{}_.+",
+                  numTableWriterCount_ - 1,
+                  tableWriteNodeId_)))
           << filePath.filename().string();
     } else {
-      ASSERT_TRUE(RE2::FullMatch(
-          filePath.filename().string(),
-          fmt::format(
-              ".tmp.velox.test_cursor.+_[0-{}]_{}_.+",
-              numTableWriterCount_ - 1,
-              tableWriteNodeId_)))
+      ASSERT_TRUE(
+          RE2::FullMatch(
+              filePath.filename().string(),
+              fmt::format(
+                  ".tmp.velox.test_cursor.+_[0-{}]_{}_.+",
+                  numTableWriterCount_ - 1,
+                  tableWriteNodeId_)))
           << filePath.filename().string();
     }
   }
@@ -645,10 +653,12 @@ TEST_F(BasicTableWriteTest, roundTrip) {
              .endTableScan()
              .planNode();
 
-  auto copy = AssertQueryBuilder(plan)
-                  .split(makeCudfHiveConnectorSplit(fmt::format(
-                      "{}/{}", targetDirectoryPath->getPath(), writeFileName)))
-                  .copyResults(pool());
+  auto copy =
+      AssertQueryBuilder(plan)
+          .split(makeCudfHiveConnectorSplit(
+              fmt::format(
+                  "{}/{}", targetDirectoryPath->getPath(), writeFileName)))
+          .copyResults(pool());
   assertEqualResults({data}, {copy});
 }
 
@@ -695,20 +705,22 @@ class UnpartitionedTableWriterTest
     std::vector<uint64_t> testParams;
     const auto multiDriverOptions = std::vector<bool>{false, true};
     for (bool multiDrivers : multiDriverOptions) {
-      testParams.push_back(TestParam{
-          FileFormat::PARQUET,
-          TestMode::kUnpartitioned,
-          CommitStrategy::kNoCommit,
-          multiDrivers,
-          CompressionKind_NONE}
-                               .value);
-      testParams.push_back(TestParam{
-          FileFormat::PARQUET,
-          TestMode::kUnpartitioned,
-          CommitStrategy::kTaskCommit,
-          multiDrivers,
-          CompressionKind_NONE}
-                               .value);
+      testParams.push_back(
+          TestParam{
+              FileFormat::PARQUET,
+              TestMode::kUnpartitioned,
+              CommitStrategy::kNoCommit,
+              multiDrivers,
+              CompressionKind_NONE}
+              .value);
+      testParams.push_back(
+          TestParam{
+              FileFormat::PARQUET,
+              TestMode::kUnpartitioned,
+              CommitStrategy::kTaskCommit,
+              multiDrivers,
+              CompressionKind_NONE}
+              .value);
     }
     return testParams;
   }
diff --git a/velox/experimental/cudf/tests/ToCudfSelectionTest.cpp b/velox/experimental/cudf/tests/ToCudfSelectionTest.cpp
new file mode 100644
index 00000000000..f4ef34286a9
--- /dev/null
+++ b/velox/experimental/cudf/tests/ToCudfSelectionTest.cpp
@@ -0,0 +1,569 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+
+#include "velox/dwio/common/tests/utils/BatchMaker.h"
+#include "velox/exec/OperatorType.h"
+#include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+namespace facebook::velox::exec::test {
+
+using core::QueryConfig;
+using facebook::velox::test::BatchMaker;
+using namespace common::testutil;
+
+class ToCudfSelectionTest : public OperatorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    OperatorTestBase::SetUpTestCase();
+    TestValue::enable();
+  }
+
+  void SetUp() override {
+    OperatorTestBase::SetUp();
+    filesystems::registerLocalFileSystem();
+    cudf_velox::registerCudf();
+  }
+
+  void TearDown() override {
+    cudf_velox::unregisterCudf();
+    OperatorTestBase::TearDown();
+  }
+
+  std::vector<RowVectorPtr>
+  makeVectors(const RowTypePtr& rowType, size_t size, int numVectors) {
+    std::vector<RowVectorPtr> vectors;
+    VectorFuzzer fuzzer({.vectorSize = size}, pool());
+    for (int32_t i = 0; i < numVectors; ++i) {
+      vectors.push_back(fuzzer.fuzzInputRow(rowType));
+    }
+    return vectors;
+  }
+
+  bool wasCudfAggregationUsed(const std::shared_ptr<exec::Task>& task) {
+    auto stats = task->taskStats();
+    for (const auto& pipelineStats : stats.pipelineStats) {
+      for (const auto& operatorStats : pipelineStats.operatorStats) {
+        if (operatorStats.operatorType.starts_with("CudfAggregation") ||
+            operatorStats.operatorType.starts_with("CudfGroupby") ||
+            operatorStats.operatorType.starts_with("CudfReduce") ||
+            operatorStats.operatorType.starts_with("CudfDistinct")) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  bool wasDefaultHashAggregationUsed(const std::shared_ptr<exec::Task>& task) {
+    auto stats = task->taskStats();
+    for (const auto& pipelineStats : stats.pipelineStats) {
+      for (const auto& operatorStats : pipelineStats.operatorStats) {
+        if (operatorStats.operatorType == OperatorType::kAggregation) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  RowTypePtr rowType_{
+      ROW({"c0", "c1", "c2", "c3", "c4", "c5", "c6"},
+          {BIGINT(),
+           SMALLINT(),
+           INTEGER(),
+           BIGINT(),
+           DOUBLE(),
+           DOUBLE(),
+           VARCHAR()})};
+};
+
+// Test supported aggregation should use CUDF
+TEST_F(ToCudfSelectionTest, supportedAggregationUsesCudf) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .aggregation(
+                      {"c0"},
+                      {"sum(c1)", "count(c2)", "min(c3)", "max(c4)", "avg(c5)"},
+                      {},
+                      core::AggregationNode::Step::kSingle,
+                      false)
+                  .planNode();
+
+  auto task =
+      AssertQueryBuilder(duckDbQueryRunner_)
+          .config("cudf.enabled", true)
+          .plan(plan)
+          .assertResults(
+              "SELECT c0, sum(c1), count(c2), min(c3), max(c4), avg(c5) FROM tmp GROUP BY c0");
+
+  ASSERT_TRUE(wasCudfAggregationUsed(task));
+  ASSERT_FALSE(wasDefaultHashAggregationUsed(task));
+}
+
+// Test unsupported aggregation should fall back to CPU
+TEST_F(ToCudfSelectionTest, unsupportedAggregationFallsBack) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .aggregation(
+                      {"c0"},
+                      {"stddev(c1)", "variance(c2)"},
+                      {},
+                      core::AggregationNode::Step::kSingle,
+                      false)
+                  .planNode();
+
+  auto task =
+      AssertQueryBuilder(duckDbQueryRunner_)
+          .config("cudf.enabled", true)
+          .plan(plan)
+          .assertResults(
+              "SELECT c0, stddev(c1), variance(c2) FROM tmp GROUP BY c0");
+
+  ASSERT_FALSE(wasCudfAggregationUsed(task));
+  ASSERT_TRUE(wasDefaultHashAggregationUsed(task));
+}
+
+// Test mixed supported/unsupported should fall back
+TEST_F(ToCudfSelectionTest, mixedSupportFallsBack) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .aggregation(
+                      {"c0"},
+                      {"sum(c1)", "variance(c2)"},
+                      {},
+                      core::AggregationNode::Step::kSingle,
+                      false)
+                  .planNode();
+
+  auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                  .config("cudf.enabled", true)
+                  .plan(plan)
+                  .assertResults(
+                      "SELECT c0, sum(c1), variance(c2) FROM tmp GROUP BY c0");
+
+  ASSERT_FALSE(wasCudfAggregationUsed(task));
+  ASSERT_TRUE(wasDefaultHashAggregationUsed(task));
+}
+
+// Test supported global aggregation should use CUDF
+TEST_F(ToCudfSelectionTest, supportedGlobalAggregationUsesCudf) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .aggregation(
+                      {},
+                      {"sum(c1)", "count(c2)", "max(c3)"},
+                      {},
+                      core::AggregationNode::Step::kSingle,
+                      false)
+                  .planNode();
+
+  auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                  .config("cudf.enabled", true)
+                  .plan(plan)
+                  .assertResults("SELECT sum(c1), count(c2), max(c3) FROM tmp");
+
+  ASSERT_TRUE(wasCudfAggregationUsed(task));
+  ASSERT_FALSE(wasDefaultHashAggregationUsed(task));
+}
+
+// Test unsupported global aggregation should fall back
+TEST_F(ToCudfSelectionTest, unsupportedGlobalAggregationFallsBack) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .aggregation(
+                      {},
+                      {"stddev(c1)"},
+                      {},
+                      core::AggregationNode::Step::kSingle,
+                      false)
+                  .planNode();
+
+  auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                  .config("cudf.enabled", true)
+                  .plan(plan)
+                  .assertResults("SELECT stddev(c1) FROM tmp");
+
+  ASSERT_FALSE(wasCudfAggregationUsed(task));
+  ASSERT_TRUE(wasDefaultHashAggregationUsed(task));
+}
+
+// Test supported grouping key expressions should use CUDF
+TEST_F(ToCudfSelectionTest, supportedGroupingKeyExpressionsUsesCudf) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .project(
+                      {"c0",
+                       "c1",
+                       "c2",
+                       "c3",
+                       "c4",
+                       "c5",
+                       "c6",
+                       "c0 + c1 as key1",
+                       "length(c6) as key2"})
+                  .aggregation(
+                      {"key1", "key2"},
+                      {"sum(c2)"},
+                      {},
+                      core::AggregationNode::Step::kSingle,
+                      false)
+                  .planNode();
+
+  auto task =
+      AssertQueryBuilder(duckDbQueryRunner_)
+          .config("cudf.enabled", true)
+          .plan(plan)
+          .assertResults(
+              "SELECT c0 + c1, length(c6), sum(c2) FROM tmp GROUP BY c0 + c1, length(c6)");
+
+  ASSERT_TRUE(wasCudfAggregationUsed(task));
+  ASSERT_FALSE(wasDefaultHashAggregationUsed(task));
+}
+
+// Test unsupported aggregation functions should fall back
+TEST_F(ToCudfSelectionTest, unsupportedAggregationFunctionsFallsBack) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .aggregation(
+                      {"c0"},
+                      {"sum(c1)", "variance(c2)"},
+                      {},
+                      core::AggregationNode::Step::kSingle,
+                      false)
+                  .planNode();
+
+  auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                  .config("cudf.enabled", true)
+                  .plan(plan)
+                  .assertResults(
+                      "SELECT c0, sum(c1), variance(c2) FROM tmp GROUP BY c0");
+
+  ASSERT_FALSE(wasCudfAggregationUsed(task));
+  ASSERT_TRUE(wasDefaultHashAggregationUsed(task));
+}
+
+// Test complex grouping key expressions should fall back
+TEST_F(ToCudfSelectionTest, complexGroupingKeyExpressionsFallsBack) {
+  // Use a deterministic input vector.
+  // Input: c0=[1,2,1,2], c2=[100,200,300,400]
+  // After grouping by to_big_endian_64(c0):
+  // - Group 1 (c0=1): sum(c2) = 100 + 300 = 400
+  // - Group 2 (c0=2): sum(c2) = 200 + 400 = 600
+  auto input = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 1, 2}), // c0
+      makeFlatVector<int16_t>({10, 20, 30, 40}), // c1
+      makeFlatVector<int32_t>({100, 200, 300, 400}), // c2
+  });
+
+  auto plan =
+      PlanBuilder()
+          .values({input})
+          .project({"c0", "c1", "c2", "to_big_endian_64(c0) AS complex_key"})
+          .aggregation(
+              {"complex_key"},
+              {"sum(c2)"},
+              {},
+              core::AggregationNode::Step::kSingle,
+              false)
+          .planNode();
+
+  std::shared_ptr<Task> task;
+  AssertQueryBuilder(plan).config("cudf.enabled", true).countResults(task);
+
+  ASSERT_FALSE(wasCudfAggregationUsed(task));
+  ASSERT_TRUE(wasDefaultHashAggregationUsed(task));
+}
+
+// Test supported aggregation input expressions should use CUDF
+TEST_F(ToCudfSelectionTest, supportedAggregationInputExpressionsUsesCudf) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .aggregation(
+                      {"c0"},
+                      {"sum(c1)", "max(c2)"},
+                      {},
+                      core::AggregationNode::Step::kSingle,
+                      false)
+                  .planNode();
+
+  auto task =
+      AssertQueryBuilder(duckDbQueryRunner_)
+          .config("cudf.enabled", true)
+          .plan(plan)
+          .assertResults("SELECT c0, sum(c1), max(c2) FROM tmp GROUP BY c0");
+
+  ASSERT_TRUE(wasCudfAggregationUsed(task));
+  ASSERT_FALSE(wasDefaultHashAggregationUsed(task));
+}
+
+// Test unsupported aggregation input expressions should fall back
+TEST_F(ToCudfSelectionTest, unsupportedAggregationInputExpressionsFallsBack) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .aggregation(
+                      {"c0"},
+                      {"sum(c1)", "variance(c2)"},
+                      {},
+                      core::AggregationNode::Step::kSingle,
+                      false)
+                  .planNode();
+
+  auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                  .config("cudf.enabled", true)
+                  .plan(plan)
+                  .assertResults(
+                      "SELECT c0, sum(c1), variance(c2) FROM tmp GROUP BY c0");
+
+  ASSERT_FALSE(wasCudfAggregationUsed(task));
+  ASSERT_TRUE(wasDefaultHashAggregationUsed(task));
+}
+
+// Non-count constant aggregates are not supported by cuDF aggregation.
+TEST_F(ToCudfSelectionTest, nonCountConstantAggregationFallsBack) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+
+  auto plan =
+      PlanBuilder()
+          .values(vectors)
+          .aggregation(
+              {}, {"sum(1)"}, {}, core::AggregationNode::Step::kSingle, false)
+          .planNode();
+
+  auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                  .config("cudf.enabled", true)
+                  .plan(plan)
+                  .assertResults("SELECT sum(1) FROM tmp");
+
+  ASSERT_FALSE(wasCudfAggregationUsed(task));
+  ASSERT_TRUE(wasDefaultHashAggregationUsed(task));
+}
+
+// Test zero-column count(*) should stay on GPU.
+TEST_F(ToCudfSelectionTest, zeroColumnCountStarUsesCudf) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4}),
+  });
+  createDuckDbTable({data});
+
+  auto plan =
+      PlanBuilder()
+          .values({data})
+          .filter("c0 > 0")
+          .project({})
+          .aggregation(
+              {}, {"count(*)"}, {}, core::AggregationNode::Step::kSingle, false)
+          .planNode();
+
+  auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                  .config("cudf.enabled", true)
+                  .plan(plan)
+                  .assertResults("SELECT count(*) FROM tmp WHERE c0 > 0");
+
+  ASSERT_TRUE(wasCudfAggregationUsed(task));
+  ASSERT_FALSE(wasDefaultHashAggregationUsed(task));
+}
+
+// Test zero-column count(constant) should use cudf GPU.
+TEST_F(ToCudfSelectionTest, zeroColumnCountConstantUsesGpu) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4}),
+  });
+  createDuckDbTable({data});
+
+  auto plan =
+      PlanBuilder()
+          .values({data})
+          .filter("c0 > 0")
+          .project({})
+          .aggregation(
+              {}, {"count(1)"}, {}, core::AggregationNode::Step::kSingle, false)
+          .planNode();
+
+  auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                  .config("cudf.enabled", true)
+                  .plan(plan)
+                  .assertResults("SELECT count(1) FROM tmp WHERE c0 > 0");
+
+  ASSERT_TRUE(wasCudfAggregationUsed(task));
+  ASSERT_FALSE(wasDefaultHashAggregationUsed(task));
+}
+
+// Count-only aggregation plans (single and partial/final) should use
+// CudfAggregation.
+TEST_F(ToCudfSelectionTest, countAggregatesOnlyUsesCudf) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+
+  auto assertCountUsesCudf = [this](
+                                 const core::PlanNodePtr& plan,
+                                 const std::string& duckSql,
+                                 const char* caseLabel) {
+    SCOPED_TRACE(caseLabel);
+    auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                    .config("cudf.enabled", true)
+                    .plan(plan)
+                    .assertResults(duckSql);
+    ASSERT_TRUE(wasCudfAggregationUsed(task));
+    ASSERT_FALSE(wasDefaultHashAggregationUsed(task));
+  };
+
+  assertCountUsesCudf(
+      PlanBuilder()
+          .values(vectors)
+          .aggregation(
+              {}, {"count(*)"}, {}, core::AggregationNode::Step::kSingle, false)
+          .planNode(),
+      "SELECT count(*) FROM tmp",
+      "global count(*) kSingle");
+
+  assertCountUsesCudf(
+      PlanBuilder()
+          .values(vectors)
+          .aggregation(
+              {},
+              {"count(c0)"},
+              {},
+              core::AggregationNode::Step::kSingle,
+              false)
+          .planNode(),
+      "SELECT count(c0) FROM tmp",
+      "global count(c0) kSingle");
+
+  assertCountUsesCudf(
+      PlanBuilder()
+          .values(vectors)
+          .aggregation(
+              {"c0"},
+              {"count(c2)"},
+              {},
+              core::AggregationNode::Step::kSingle,
+              false)
+          .planNode(),
+      "SELECT c0, count(c2) FROM tmp GROUP BY c0",
+      "group by c0, count(c2) kSingle");
+
+  assertCountUsesCudf(
+      PlanBuilder()
+          .values(vectors)
+          .partialAggregation({}, {"count(*)"})
+          .finalAggregation()
+          .planNode(),
+      "SELECT count(*) FROM tmp",
+      "global count(*) partial+final");
+
+  assertCountUsesCudf(
+      PlanBuilder()
+          .values(vectors)
+          .partialAggregation({"c0"}, {"count(c2)"})
+          .finalAggregation()
+          .planNode(),
+      "SELECT c0, count(c2) FROM tmp GROUP BY c0",
+      "group by c0, count(c2) partial+final");
+
+  assertCountUsesCudf(
+      PlanBuilder()
+          .values(vectors)
+          .partialAggregation({"c0"}, {"count(*)"})
+          .finalAggregation()
+          .planNode(),
+      "SELECT c0, count(*) FROM tmp GROUP BY c0",
+      "group by c0, count(*) partial+final");
+}
+
+// Test count(NULL) runs on cudf GPU (returns 0).
+TEST_F(ToCudfSelectionTest, countNullAggregationUsesGpu) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .aggregation(
+                      {},
+                      {"count(null)"},
+                      {},
+                      core::AggregationNode::Step::kSingle,
+                      false)
+                  .planNode();
+
+  auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                  .config("cudf.enabled", true)
+                  .plan(plan)
+                  .assertResults("SELECT count(NULL) FROM tmp");
+
+  ASSERT_TRUE(wasCudfAggregationUsed(task));
+  ASSERT_FALSE(wasDefaultHashAggregationUsed(task));
+}
+
+// Test CUDF disabled should always use regular aggregation
+TEST_F(ToCudfSelectionTest, cudfDisabledUsesRegularAggregation) {
+  auto vectors = makeVectors(rowType_, 10, 100);
+  createDuckDbTable(vectors);
+
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .aggregation(
+                      {"c0"},
+                      {"sum(c1)", "count(c2)"},
+                      {},
+                      core::AggregationNode::Step::kSingle,
+                      false)
+                  .planNode();
+
+  auto task =
+      AssertQueryBuilder(duckDbQueryRunner_)
+          .config("cudf.enabled", false)
+          .plan(plan)
+          .assertResults("SELECT c0, sum(c1), count(c2) FROM tmp GROUP BY c0");
+
+  ASSERT_FALSE(wasCudfAggregationUsed(task));
+  ASSERT_TRUE(wasDefaultHashAggregationUsed(task));
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/experimental/cudf/tests/TopNTest.cpp b/velox/experimental/cudf/tests/TopNTest.cpp
new file mode 100644
index 00000000000..6441e7145dc
--- /dev/null
+++ b/velox/experimental/cudf/tests/TopNTest.cpp
@@ -0,0 +1,364 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/exec/CudfConversion.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec::test;
+
+class TopNTest : public OperatorTestBase {
+ public:
+  void SetUp() override {
+    OperatorTestBase::SetUp();
+    cudf_velox::registerCudf();
+  }
+  void TearDown() override {
+    cudf_velox::unregisterCudf();
+    OperatorTestBase::TearDown();
+  }
+
+ protected:
+  static std::vector<std::string> getSortOrderSqls() {
+    return {"NULLS LAST", "NULLS FIRST", "DESC NULLS FIRST", "DESC NULLS LAST"};
+  }
+
+  void testSingleKey(
+      const std::vector<RowVectorPtr>& input,
+      const std::string& key,
+      int32_t limit) {
+    auto keyIndex = input[0]->type()->asRow().getChildIdx(key);
+
+    auto sortOrderSqls = getSortOrderSqls();
+
+    for (const auto& sortOrderSql : sortOrderSqls) {
+      auto sql = fmt::format("{} {}", key, sortOrderSql);
+
+      auto plan =
+          PlanBuilder().values(input).topN({sql}, limit, false).planNode();
+
+      assertQueryOrdered(
+          plan,
+          fmt::format("SELECT * FROM tmp ORDER BY {} LIMIT {}", sql, limit),
+          {keyIndex});
+    }
+  }
+
+  void testSingleKey(
+      const std::vector<RowVectorPtr>& input,
+      const std::string& key,
+      const std::string& filter) {
+    auto keyIndex = input[0]->type()->asRow().getChildIdx(key);
+
+    auto sortOrderSqls = getSortOrderSqls();
+
+    for (const auto& sortOrderSql : sortOrderSqls) {
+      auto sql = fmt::format("{} {}", key, sortOrderSql);
+
+      auto plan = PlanBuilder()
+                      .values(input)
+                      .filter(filter)
+                      .topN({sql}, 10, false)
+                      .planNode();
+
+      assertQueryOrdered(
+          plan,
+          fmt::format(
+              "SELECT * FROM tmp WHERE {} ORDER BY {} LIMIT 10", filter, sql),
+          {keyIndex});
+    }
+  }
+
+  void testTwoKeys(
+      const std::vector<RowVectorPtr>& input,
+      const std::string& key1,
+      const std::string& key2,
+      int32_t limit) {
+    auto& rowType = input[0]->type()->asRow();
+    auto keyIndices = {rowType.getChildIdx(key1), rowType.getChildIdx(key2)};
+
+    auto sortOrderSqls = getSortOrderSqls();
+
+    for (const auto& sortOrderSql1 : sortOrderSqls) {
+      for (const auto& sortOrderSql2 : sortOrderSqls) {
+        auto sql1 = fmt::format("{} {}", key1, sortOrderSql1);
+        auto sql2 = fmt::format("{} {}", key2, sortOrderSql2);
+
+        auto plan = PlanBuilder()
+                        .values(input)
+                        .topN({sql1, sql2}, limit, false)
+                        .planNode();
+
+        assertQueryOrdered(
+            plan,
+            fmt::format(
+                "SELECT * FROM tmp ORDER BY {}, {} LIMIT {}",
+                sql1,
+                sql2,
+                limit),
+            keyIndices);
+      }
+    }
+  }
+};
+
+TEST_F(TopNTest, selectiveFilter) {
+  vector_size_t batchSize = 1000;
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < 3; ++i) {
+    auto c0 = makeFlatVector<int64_t>(
+        batchSize,
+        [&](vector_size_t row) { return batchSize * i + row; },
+        nullEvery(5));
+    auto c1 = makeFlatVector<int64_t>(
+        batchSize, [&](vector_size_t row) { return row; }, nullEvery(5));
+    auto c2 = makeFlatVector<double>(
+        batchSize, [](vector_size_t row) { return row * 0.1; }, nullEvery(11));
+    vectors.push_back(makeRowVector({c0, c1, c2}));
+  }
+  createDuckDbTable(vectors);
+
+  // c0 values are unique across batches
+  testSingleKey(vectors, "c0", "c0 % 333 = 0");
+
+  // c1 values are unique only within a batch
+  testSingleKey(vectors, "c1", "c1 % 333 = 0");
+}
+
+TEST_F(TopNTest, singleKey) {
+  vector_size_t batchSize = 1000;
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < 2; ++i) {
+    auto c0 = makeFlatVector<int64_t>(
+        batchSize, [&](vector_size_t row) { return row; }, nullEvery(5));
+    auto c1 = makeFlatVector<double>(
+        batchSize, [](vector_size_t row) { return row * 0.1; }, nullEvery(11));
+    vectors.push_back(makeRowVector({c0, c1}));
+  }
+  createDuckDbTable(vectors);
+
+  // DESC NULLS LAST and ASC NULLS FIRST will return all rows where c0 is null;
+  // There are 400 rows where c0 is null. Use limit greater than 400 to make the
+  // query deterministic.
+  testSingleKey(vectors, "c0", 410);
+
+  // parser doesn't support "is not null" expression, hence, using c0 % 2 >= 0
+  testSingleKey(vectors, "c0", "c0 % 2 >= 0");
+}
+
+TEST_F(TopNTest, multipleKeys) {
+  vector_size_t batchSize = 1000;
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < 2; ++i) {
+    auto c0 = makeFlatVector<int64_t>(
+        batchSize, [](vector_size_t row) { return row % 4; }, nullEvery(31, 1));
+    auto c1 = makeFlatVector<int32_t>(
+        batchSize, [](vector_size_t row) { return row; }, nullEvery(17));
+    auto c2 = makeFlatVector<double>(
+        batchSize, [](vector_size_t row) { return row * 0.1; }, nullEvery(11));
+    vectors.push_back(makeRowVector({c0, c1, c2}));
+  }
+  createDuckDbTable(vectors);
+
+  testTwoKeys(vectors, "c0", "c1", 200);
+}
+
+TEST_F(TopNTest, compaction) {
+  vector_size_t batchSize = 1000;
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < 5; ++i) {
+    auto c0 = makeFlatVector<int64_t>(
+        batchSize,
+        [&](vector_size_t row) { return batchSize * i + row; },
+        nullEvery(31));
+    auto c1 = makeFlatVector<double>(
+        batchSize, [](vector_size_t row) { return row * 0.1; }, nullEvery(11));
+    vectors.push_back(makeRowVector({c0, c1, c1, c1, c1, c1}));
+  }
+  createDuckDbTable(vectors);
+
+  // Make sure LIMIT is greater than number of rows with nulls to avoid
+  // non-deterministic results.
+  testSingleKey(vectors, "c0", 500);
+
+  testSingleKey(vectors, "c0", 900);
+}
+
+TEST_F(TopNTest, varchar) {
+  vector_size_t batchSize = 1'000;
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < 5; ++i) {
+    auto c0 = makeFlatVector<int64_t>(
+        batchSize,
+        [&](vector_size_t row) { return batchSize * i + row; },
+        nullEvery(5));
+    auto c1 = makeFlatVector<double>(
+        batchSize, [](vector_size_t row) { return row * 0.1; }, nullEvery(11));
+    auto c2 = makeFlatVector<StringView>(
+        batchSize,
+        [](vector_size_t row) {
+          return StringView::makeInline(std::to_string(row));
+        },
+        nullEvery(31));
+    auto c3 = makeFlatVector<std::string>(batchSize, [](vector_size_t row) {
+      return "non inline string " + std::to_string(row);
+    });
+    vectors.push_back(makeRowVector({c0, c1, c2, c3}));
+  }
+  createDuckDbTable(vectors);
+
+  // Make sure LIMIT is greater than number of rows with nulls to avoid
+  // non-deterministic results.
+  testSingleKey(vectors, "c2", 200);
+}
+
+TEST_F(TopNTest, multiBatch) {
+  vector_size_t batchSize = 1'000;
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < 5; ++i) {
+    auto c0 = makeFlatVector<int64_t>(
+        batchSize, [&](vector_size_t row) { return batchSize * i + row; });
+    auto c1 = makeFlatVector<double>(
+        batchSize, [](vector_size_t row) { return row * 0.1; });
+    auto c2 = makeFlatVector<StringView>(batchSize, [](vector_size_t row) {
+      return StringView::makeInline(std::to_string(row));
+    });
+    vectors.push_back(makeRowVector({c0, c1, c2}));
+  }
+  createDuckDbTable(vectors);
+
+  testSingleKey(vectors, "c0", 1'500);
+  testSingleKey(vectors, "c2", 2'500);
+}
+
+TEST_F(TopNTest, numericTopNSynchronization) {
+  constexpr vector_size_t batchSize = 132000;
+  constexpr int32_t numBatches = 6;
+  constexpr int32_t topN = 1024;
+  std::vector<RowVectorPtr> vectors;
+  vectors.reserve(numBatches);
+
+  for (int32_t batch = 0; batch < numBatches; ++batch) {
+    auto id = makeFlatVector<int64_t>(batchSize, [&](vector_size_t row) {
+      return static_cast<int64_t>(batch) * batchSize + row;
+    });
+    auto key = makeFlatVector<double>(batchSize, [&](vector_size_t row) {
+      // Repeat a small key space to force tie-breaking on c0.
+      auto bucket =
+          static_cast<int64_t>((row + batch * 13) % 10007); // A custom hash.
+      return static_cast<double>(bucket);
+    });
+    auto payload = makeFlatVector<int64_t>(batchSize, [&](vector_size_t row) {
+      return static_cast<int64_t>(row ^ (batch << 10));
+    });
+    vectors.push_back(makeRowVector(std::vector<VectorPtr>{id, key, payload}));
+  }
+
+  createDuckDbTable(vectors);
+
+  auto plan =
+      PlanBuilder()
+          .values(vectors)
+          .topN({"c1 DESC NULLS LAST", "c0 ASC NULLS LAST"}, topN, false)
+          .planNode();
+
+  // Force configuration to maximize chance of replicating a missing stream
+  // sync.
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .config(cudf_velox::CudfFromVelox::kGpuBatchSizeRows, batchSize)
+      .config(cudf_velox::CudfConfig::kCudfTopNBatchSize, 1)
+      .assertResults(
+          fmt::format(
+              "SELECT c0, c1, c2 FROM tmp ORDER BY c1 DESC, c0 LIMIT {}",
+              topN));
+}
+
+TEST_F(TopNTest, empty) {
+  vector_size_t batchSize = 1'000;
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < 5; ++i) {
+    auto c0 = makeFlatVector<int64_t>(
+        batchSize, [&](vector_size_t row) { return batchSize * i + row; });
+    auto c1 = makeFlatVector<double>(
+        batchSize, [](vector_size_t row) { return row * 0.1; });
+    auto c2 = makeFlatVector<StringView>(batchSize, [](vector_size_t row) {
+      return StringView::makeInline(std::to_string(row));
+    });
+    vectors.push_back(makeRowVector({c0, c1, c2}));
+  }
+  createDuckDbTable(vectors);
+
+  testSingleKey(vectors, "c0", "c0 < 0");
+}
+
+TEST_F(TopNTest, lowCardinality) {
+  vector_size_t size = 1'000;
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < 5; ++i) {
+    auto c0 = makeFlatVector<int64_t>(size, [](auto /*row*/) { return 0; });
+    auto c1 = makeFlatVector<int32_t>(size, [](auto /*row*/) { return 10; });
+    auto c2 = makeFlatVector<double>(size, [](auto /*row*/) { return 12.5; });
+    vectors.push_back(makeRowVector({c0, c1, c2}));
+  }
+  createDuckDbTable(vectors);
+
+  testTwoKeys(vectors, "c0", "c1", 200);
+}
+
+// All columns are sorting keys.
+TEST_F(TopNTest, onlyKeys) {
+  vector_size_t batchSize = 1000;
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < 2; ++i) {
+    auto c0 = makeFlatVector<int64_t>(
+        batchSize,
+        [](vector_size_t row) { return row % 20; },
+        nullEvery(31, 1));
+    auto c1 = makeFlatVector<int32_t>(
+        batchSize, [](vector_size_t row) { return row; }, nullEvery(17));
+    vectors.push_back(makeRowVector({c0, c1}));
+  }
+  createDuckDbTable(vectors);
+
+  testTwoKeys(vectors, "c0", "c1", 200);
+}
+
+TEST_F(TopNTest, planNodeValidation) {
+  auto data = makeRowVector(
+      ROW({"a", "b"},
+          {
+              BIGINT(),
+              BIGINT(),
+          }),
+      10);
+  auto plan = [&](const std::vector<std::string>& sortingKeys,
+                  int32_t count = 10) {
+    PlanBuilder().values({data}).topN(sortingKeys, count, false).planNode();
+  };
+
+  VELOX_ASSERT_THROW(plan({}), "TopN must specify sorting keys");
+  VELOX_ASSERT_THROW(
+      plan({"a"}, 0),
+      "TopN must specify greater than zero number of rows to keep");
+  VELOX_ASSERT_THROW(
+      plan({"a", "b", "a"}),
+      "TopN must specify unique sorting keys. Found duplicate key: a");
+}
diff --git a/velox/experimental/cudf/tests/sparksql/AggregationTest.cpp b/velox/experimental/cudf/tests/sparksql/AggregationTest.cpp
index d07390bb00f..2178254875e 100644
--- a/velox/experimental/cudf/tests/sparksql/AggregationTest.cpp
+++ b/velox/experimental/cudf/tests/sparksql/AggregationTest.cpp
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#include "velox/experimental/cudf/exec/AggregationRegistry.h"
+#include "velox/experimental/cudf/exec/SparkAggregateFunctions.h"
 #include "velox/experimental/cudf/exec/ToCudf.h"
 
 #include "velox/common/base/tests/GTestUtils.h"
@@ -36,10 +38,12 @@ class AggregationTest : public AggregationTestBase {
     // with spark_ to align with sparksql AverageAggregationTest, the
     // function name overwrite may not work well in some condition.
     cudf_velox::registerCudf();
+    cudf_velox::registerSparkAggregateFunctions("");
   }
 
   void TearDown() override {
     cudf_velox::unregisterCudf();
+    cudf_velox::unregisterAggregateFunctions();
   }
 };
 
diff --git a/velox/experimental/cudf/tests/sparksql/CMakeLists.txt b/velox/experimental/cudf/tests/sparksql/CMakeLists.txt
index 8c4d8124d6d..ee2435290ca 100644
--- a/velox/experimental/cudf/tests/sparksql/CMakeLists.txt
+++ b/velox/experimental/cudf/tests/sparksql/CMakeLists.txt
@@ -26,12 +26,37 @@ target_link_libraries(
   velox_cudf_spark_aggregates_test
   velox_cudf_exec
   velox_exec_test_lib
-  velox_vector_test_lib
   velox_functions_aggregates_test_lib
   velox_functions_spark
   velox_functions_spark_aggregates
   velox_hive_connector
   velox_vector_fuzzer
+  velox_vector_test_lib
+  gflags::gflags
+  GTest::gtest
+  GTest::gtest_main
+)
+
+add_executable(velox_cudf_spark_filter_project_test FilterProjectTest.cpp Main.cpp)
+
+add_test(
+  NAME velox_cudf_spark_filter_project_test
+  COMMAND velox_cudf_spark_filter_project_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+set_tests_properties(
+  velox_cudf_spark_filter_project_test
+  PROPERTIES LABELS cuda_driver TIMEOUT 3000
+)
+
+target_link_libraries(
+  velox_cudf_spark_filter_project_test
+  velox_cudf_exec
+  velox_exec_test_lib
+  velox_functions_spark
+  velox_vector_fuzzer
+  velox_vector_test_lib
   gflags::gflags
   GTest::gtest
   GTest::gtest_main
diff --git a/velox/experimental/cudf/tests/sparksql/FilterProjectTest.cpp b/velox/experimental/cudf/tests/sparksql/FilterProjectTest.cpp
new file mode 100644
index 00000000000..9d6751b9a67
--- /dev/null
+++ b/velox/experimental/cudf/tests/sparksql/FilterProjectTest.cpp
@@ -0,0 +1,890 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/exec/CudfFilterProject.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/expression/SparkFunctions.h"
+#include "velox/experimental/cudf/tests/CudfFunctionBaseTest.h"
+#include "velox/experimental/cudf/tests/utils/ExpressionTestUtil.h"
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/dwio/common/tests/utils/BatchMaker.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/sparksql/registration/Register.h"
+#include "velox/parse/TypeResolver.h"
+
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox;
+
+namespace facebook::velox::cudf_velox {
+namespace {
+
+class CudfFilterProjectTest : public CudfFunctionBaseTest {
+ protected:
+  static void SetUpTestCase() {
+    parse::registerTypeResolver();
+    functions::sparksql::registerFunctions("");
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+    cudf_velox::registerCudf();
+    cudf_velox::registerSparkFunctions("");
+  }
+
+  static void TearDownTestCase() {
+    cudf_velox::unregisterFunctions();
+    cudf_velox::unregisterCudf();
+  }
+
+  CudfFilterProjectTest() {
+    options_.parseIntegerAsBigint = false;
+  }
+};
+
+TEST_F(CudfFilterProjectTest, hashWithSeed) {
+  auto input = makeFlatVector<int64_t>({INT64_MAX, INT64_MIN});
+  auto data = makeRowVector({input});
+  auto hashPlan = PlanBuilder()
+                      .setParseOptions(options_)
+                      .values({data})
+                      .project({"hash_with_seed(42, c0) AS c1"})
+                      .planNode();
+  auto hashResults = AssertQueryBuilder(hashPlan).copyResults(pool());
+
+  auto expected = makeRowVector({
+      makeFlatVector<int32_t>({
+          -1604625029,
+          -853646085,
+      }),
+  });
+  facebook::velox::test::assertEqualVectors(expected, hashResults);
+}
+
+// TODO: Re-enable after https://github.com/rapidsai/cudf/issues/21720.
+// cuDF's murmurhash3_x86_32 combines columns via hash_combine(h(col0, seed),
+// h(col1, seed)), while Spark instead hashes columns iteratively:
+// h(col1, h(col0, seed)).
+// These produce different results for multi-column inputs. The cudf hashing
+// API only accepts a scalar uint32_t seed (no per-row seed column), so
+// Spark's iterative semantics cannot be replicated without a custom CUDA
+// kernel. Single-column hash_with_seed works correctly since there is no
+// combining step.
+TEST_F(CudfFilterProjectTest, DISABLED_hashWithSeedMultiColumns) {
+  auto input = makeFlatVector<int64_t>({INT64_MAX, INT64_MIN});
+  auto data = makeRowVector({input, input});
+  auto hashPlan = PlanBuilder()
+                      .setParseOptions(options_)
+                      .values({data})
+                      .project({"hash_with_seed(42, c0, c1) AS c2"})
+                      .planNode();
+  auto hashResults = AssertQueryBuilder(hashPlan).copyResults(pool());
+
+  auto expected = makeRowVector({
+      makeFlatVector<int32_t>({
+          -572895191,
+          724095561,
+      }),
+  });
+  facebook::velox::test::assertEqualVectors(expected, hashResults);
+}
+
+TEST_F(CudfFilterProjectTest, dateAdd) {
+  const auto dateAdd = [&](const std::string& dateStr, int32_t value) {
+    return evaluateOnce<int32_t>(
+        fmt::format("date_add(c0, {})", value),
+        {DATE()},
+        std::optional<int32_t>(parseDate(dateStr)));
+  };
+
+  // Check simple tests.
+  EXPECT_EQ(parseDate("2019-03-01"), dateAdd("2019-03-01", 0));
+  EXPECT_EQ(parseDate("2019-03-01"), dateAdd("2019-02-28", 1));
+
+  // Account for the last day of a year-month
+  EXPECT_EQ(parseDate("2020-02-29"), dateAdd("2019-01-30", 395));
+  EXPECT_EQ(parseDate("2020-02-29"), dateAdd("2019-01-30", 395));
+}
+
+TEST_F(CudfFilterProjectTest, likeWithEscape) {
+  auto input = makeNullableFlatVector<std::string>(
+      {"a_c", "abc", "abc_", "a%c", std::nullopt, ""});
+  auto data = makeRowVector({input});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"like(c0, '%#_%', '#') AS c1"})
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<bool>(
+          {true, false, true, false, std::nullopt, false}),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, likeConstantPattern) {
+  auto input = makeNullableFlatVector<std::string>(
+      {"abc", "zabc", std::nullopt, "ab", "", "a_c", "a%c"});
+  auto data = makeRowVector({input});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"like(c0, 'a%') AS c1"})
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<bool>(
+          {true, false, std::nullopt, true, false, true, true}),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, likeNullPattern) {
+  auto input = makeNullableFlatVector<std::string>(
+      {"a_c", "abc", "abc_", "a%c", std::nullopt, ""});
+  auto data = makeRowVector({input});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"like(c0, cast(null as varchar)) AS c1"})
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<bool>({
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+      }),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, likeNullEscape) {
+  auto input = makeNullableFlatVector<std::string>(
+      {"a_c", "abc", "abc_", "a%c", std::nullopt, ""});
+  auto data = makeRowVector({input});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"like(c0, '%#_%', cast(null as varchar)) AS c1"})
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<bool>({
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+      }),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, likeEmptyEscape) {
+  auto input = makeNullableFlatVector<std::string>({"abc", "xyz"});
+  auto data = makeRowVector({input});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"like(c0, 'abc', '') AS c1"})
+                  .planNode();
+
+  VELOX_ASSERT_USER_THROW(
+      AssertQueryBuilder(plan).copyResults(pool()),
+      "Escape string must be a single character");
+}
+
+TEST_F(CudfFilterProjectTest, likeMultiCharacterEscape) {
+  auto input = makeNullableFlatVector<std::string>({"abc", "xyz"});
+  auto data = makeRowVector({input});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"like(c0, 'abc', 'oops') AS c1"})
+                  .planNode();
+
+  VELOX_ASSERT_USER_THROW(
+      AssertQueryBuilder(plan).copyResults(pool()),
+      "Escape string must be a single character");
+}
+
+TEST_F(CudfFilterProjectTest, likeInvalidEscapeUsage) {
+  auto input = makeNullableFlatVector<std::string>({"test", "testo"});
+  auto data = makeRowVector({input});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"like(c0, 'test_o', 'o') AS c1"})
+                  .planNode();
+
+  VELOX_ASSERT_USER_THROW(
+      AssertQueryBuilder(plan).copyResults(pool()),
+      "Escape character must be followed by '%', '_' or the escape character itself");
+}
+
+TEST_F(CudfFilterProjectTest, tryLikeInvalidEscapeUsage) {
+  auto input =
+      makeNullableFlatVector<std::string>({"test", "testo", std::nullopt});
+  auto data = makeRowVector({input});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"try(like(c0, 'test_o', 'o')) AS c1"})
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<bool>({std::nullopt, std::nullopt, std::nullopt}),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, likeColumnPatternInvalidEscapeUsage) {
+  auto input = makeNullableFlatVector<std::string>({"abc"});
+  auto pattern = makeNullableFlatVector<std::string>({"a#b"});
+  auto data = makeRowVector({input, pattern});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"like(c0, c1, '#') AS c2"})
+                  .planNode();
+
+  VELOX_ASSERT_USER_THROW(
+      AssertQueryBuilder(plan).copyResults(pool()),
+      "Escape character must be followed by '%', '_' or the escape character itself");
+}
+
+TEST_F(CudfFilterProjectTest, likeColumnPattern) {
+  auto input = makeNullableFlatVector<std::string>(
+      {"abc", "zabc", std::nullopt, "ab", "", "a_c", "a%c"});
+  auto pattern = makeNullableFlatVector<std::string>(
+      {"a%", "%bc", "a%", std::nullopt, "", "a_d", "a%%"});
+  auto data = makeRowVector({input, pattern});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"like(c0, c1) AS c2"})
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<bool>(
+          {true, true, std::nullopt, std::nullopt, true, false, true}),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, likeColumnPatternWithoutPatternNulls) {
+  auto input =
+      makeNullableFlatVector<std::string>({"abc", std::nullopt, "a_c", ""});
+  auto pattern = makeNullableFlatVector<std::string>({"a%", "%", "a_d", ""});
+  auto data = makeRowVector({input, pattern});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"like(c0, c1) AS c2"})
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<bool>({true, std::nullopt, false, true}),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, likeColumnPatternWithEscape) {
+  auto input = makeNullableFlatVector<std::string>(
+      {"a_c", "abc", "abc_", "a%c", std::nullopt, "a#c"});
+  auto pattern = makeNullableFlatVector<std::string>(
+      {"%#_%", "%#_%", std::nullopt, "a#%%", "%#_%", "a##c"});
+  auto data = makeRowVector({input, pattern});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"like(c0, c1, '#') AS c2"})
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<bool>(
+          {true, false, std::nullopt, true, std::nullopt, true}),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, likeColumnPatternWithEscapeAllNullPatterns) {
+  auto input =
+      makeNullableFlatVector<std::string>({"a_c", "abc", std::nullopt, ""});
+  auto pattern = makeNullableFlatVector<std::string>(
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt});
+  auto data = makeRowVector({input, pattern});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"like(c0, c1, '#') AS c2"})
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<bool>(
+          {std::nullopt, std::nullopt, std::nullopt, std::nullopt}),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, likeConstantInputColumnPattern) {
+  auto pattern = makeNullableFlatVector<std::string>(
+      {"a%", "%b%", "", std::nullopt, "abc"});
+  auto data = makeRowVector({pattern});
+  auto typed = test_utils::parseAndInferTypedExpr(
+      "like('abc', c0)", data->rowType(), &execCtx_, options_);
+  exec::ExprSet exprSet({typed}, &execCtx_, /*enableConstantFolding*/ false);
+
+  auto result = evaluate(exprSet, data);
+  auto expected =
+      makeNullableFlatVector<bool>({true, true, false, std::nullopt, true});
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(CudfFilterProjectTest, likeConstantNullInputColumnPattern) {
+  auto pattern = makeNullableFlatVector<std::string>(
+      {"a%", "%b%", std::nullopt, "", "abc"});
+  auto data = makeRowVector({pattern});
+  auto typed = test_utils::parseAndInferTypedExpr(
+      "like(cast(null as varchar), c0)", data->rowType(), &execCtx_, options_);
+  exec::ExprSet exprSet({typed}, &execCtx_, /*enableConstantFolding*/ false);
+
+  auto result = evaluate(exprSet, data);
+  auto expected = makeNullableFlatVector<bool>(
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt});
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(CudfFilterProjectTest, likeConstantInputColumnPatternWithEscape) {
+  auto pattern = makeNullableFlatVector<std::string>(
+      {"%#_%", "a#_c", "a##c", std::nullopt, "a%"});
+  auto data = makeRowVector({pattern});
+  auto typed = test_utils::parseAndInferTypedExpr(
+      "like('a_c', c0, '#')", data->rowType(), &execCtx_, options_);
+  exec::ExprSet exprSet({typed}, &execCtx_, /*enableConstantFolding*/ false);
+
+  auto result = evaluate(exprSet, data);
+  auto expected =
+      makeNullableFlatVector<bool>({true, true, false, std::nullopt, true});
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(CudfFilterProjectTest, likeConstantNullInputColumnPatternWithEscape) {
+  auto pattern = makeNullableFlatVector<std::string>(
+      {"%#_%", "a#_c", "a##c", std::nullopt, "a%"});
+  auto data = makeRowVector({pattern});
+  auto typed = test_utils::parseAndInferTypedExpr(
+      "like(cast(null as varchar), c0, '#')",
+      data->rowType(),
+      &execCtx_,
+      options_);
+  exec::ExprSet exprSet({typed}, &execCtx_, /*enableConstantFolding*/ false);
+
+  auto result = evaluate(exprSet, data);
+  auto expected = makeNullableFlatVector<bool>(
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt});
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(CudfFilterProjectTest, startswith) {
+  auto input = makeNullableFlatVector<std::string>(
+      {"abc", "zabc", std::nullopt, "ab", "", "xyz", "abz"});
+  auto data = makeRowVector({input});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"startswith(c0, 'ab') AS c1"})
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<bool>(
+          {true, false, std::nullopt, true, false, false, true}),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, startswithNullPattern) {
+  auto input = makeNullableFlatVector<std::string>(
+      {"abc", "zabc", std::nullopt, "ab", "", "xyz", "abz"});
+  auto data = makeRowVector({input});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"startswith(c0, cast(null as varchar)) AS c1"})
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<bool>({
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+      }),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, startswithEmptyPattern) {
+  auto input = makeNullableFlatVector<std::string>(
+      {"abc", "zabc", std::nullopt, "ab", "", "xyz", "abz"});
+  auto data = makeRowVector({input});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"startswith(c0, '') AS c1"})
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<bool>(
+          {true, true, std::nullopt, true, true, true, true}),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, startswithColumnPattern) {
+  auto input = makeNullableFlatVector<std::string>(
+      {"abc", "zabc", std::nullopt, "ab", "", "xyz", "abz"});
+  auto pattern = makeNullableFlatVector<std::string>(
+      {"ab", "ab", "ab", std::nullopt, "", "yz", "zz"});
+  auto data = makeRowVector({input, pattern});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"startswith(c0, c1) AS c2"})
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<bool>(
+          {true, false, std::nullopt, std::nullopt, true, false, false}),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, startswithConstantInput) {
+  auto pattern =
+      makeNullableFlatVector<std::string>({"a", "ab", std::nullopt, "", "abc"});
+  auto data = makeRowVector({pattern});
+  auto typed = test_utils::parseAndInferTypedExpr(
+      "startswith('ab', c0)", data->rowType(), &execCtx_, options_);
+  exec::ExprSet exprSet({typed}, &execCtx_, /*enableConstantFolding*/ false);
+
+  auto result = evaluate(exprSet, data);
+  auto expected =
+      makeNullableFlatVector<bool>({true, true, std::nullopt, true, false});
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(CudfFilterProjectTest, startswithConstantNullInput) {
+  auto pattern =
+      makeNullableFlatVector<std::string>({"a", "ab", std::nullopt, "", "abc"});
+  auto data = makeRowVector({pattern});
+  auto typed = test_utils::parseAndInferTypedExpr(
+      "startswith(cast(null as varchar), c0)",
+      data->rowType(),
+      &execCtx_,
+      options_);
+  exec::ExprSet exprSet({typed}, &execCtx_, /*enableConstantFolding*/ false);
+
+  auto result = evaluate(exprSet, data);
+  auto expected = makeNullableFlatVector<bool>(
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt});
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(CudfFilterProjectTest, startswithColumnPatternNullInput) {
+  auto input = makeNullableFlatVector<std::string>({std::nullopt});
+  auto pattern = makeNullableFlatVector<std::string>({"ab"});
+  auto data = makeRowVector({input, pattern});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"startswith(c0, c1) AS c2"})
+                  .planNode();
+
+  auto expected = makeRowVector({makeNullableFlatVector<bool>({std::nullopt})});
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, startswithColumnPatternNullPattern) {
+  auto input = makeNullableFlatVector<std::string>({"ab"});
+  auto pattern = makeNullableFlatVector<std::string>({std::nullopt});
+  auto data = makeRowVector({input, pattern});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"startswith(c0, c1) AS c2"})
+                  .planNode();
+
+  auto expected = makeRowVector({makeNullableFlatVector<bool>({std::nullopt})});
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, contains) {
+  auto input = makeNullableFlatVector<std::string>(
+      {"abc", "zabc", std::nullopt, "ab", "", "xyz", "abz"});
+  auto data = makeRowVector({input});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"contains(c0, 'ab') AS c1"})
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<bool>(
+          {true, true, std::nullopt, true, false, false, true}),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, containsNullPattern) {
+  auto input = makeNullableFlatVector<std::string>(
+      {"abc", "zabc", std::nullopt, "ab", "", "xyz", "abz"});
+  auto data = makeRowVector({input});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"contains(c0, cast(null as varchar)) AS c1"})
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<bool>({
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+      }),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, containsEmptyPattern) {
+  auto input = makeNullableFlatVector<std::string>(
+      {"abc", "zabc", std::nullopt, "ab", "", "xyz", "abz"});
+  auto data = makeRowVector({input});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"contains(c0, '') AS c1"})
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<bool>(
+          {true, true, std::nullopt, true, true, true, true}),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, containsColumnPattern) {
+  auto input = makeNullableFlatVector<std::string>(
+      {"abc", "zabc", std::nullopt, "ab", "", "xyz", "abz"});
+  auto pattern = makeNullableFlatVector<std::string>(
+      {"bc", "ab", "bc", std::nullopt, "", "yz", "zz"});
+  auto data = makeRowVector({input, pattern});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"contains(c0, c1) AS c2"})
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<bool>(
+          {true, true, std::nullopt, std::nullopt, true, true, false}),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, containsConstantInput) {
+  auto pattern =
+      makeNullableFlatVector<std::string>({"b", "ab", std::nullopt, "", "abc"});
+  auto data = makeRowVector({pattern});
+  auto typed = test_utils::parseAndInferTypedExpr(
+      "contains('ab', c0)", data->rowType(), &execCtx_, options_);
+  exec::ExprSet exprSet({typed}, &execCtx_, /*enableConstantFolding*/ false);
+
+  auto result = evaluate(exprSet, data);
+  auto expected =
+      makeNullableFlatVector<bool>({true, true, std::nullopt, true, false});
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(CudfFilterProjectTest, containsConstantNullInput) {
+  auto pattern =
+      makeNullableFlatVector<std::string>({"b", "ab", std::nullopt, "", "abc"});
+  auto data = makeRowVector({pattern});
+  auto typed = test_utils::parseAndInferTypedExpr(
+      "contains(cast(null as varchar), c0)",
+      data->rowType(),
+      &execCtx_,
+      options_);
+  exec::ExprSet exprSet({typed}, &execCtx_, /*enableConstantFolding*/ false);
+
+  auto result = evaluate(exprSet, data);
+  auto expected = makeNullableFlatVector<bool>(
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt});
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(CudfFilterProjectTest, containsColumnPatternNullInput) {
+  auto input = makeNullableFlatVector<std::string>({std::nullopt});
+  auto pattern = makeNullableFlatVector<std::string>({"ab"});
+  auto data = makeRowVector({input, pattern});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"contains(c0, c1) AS c2"})
+                  .planNode();
+
+  auto expected = makeRowVector({makeNullableFlatVector<bool>({std::nullopt})});
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, containsColumnPatternNullPattern) {
+  auto input = makeNullableFlatVector<std::string>({"ab"});
+  auto pattern = makeNullableFlatVector<std::string>({std::nullopt});
+  auto data = makeRowVector({input, pattern});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"contains(c0, c1) AS c2"})
+                  .planNode();
+
+  auto expected = makeRowVector({makeNullableFlatVector<bool>({std::nullopt})});
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, endswith) {
+  auto input = makeNullableFlatVector<std::string>(
+      {"abc", "zabc", std::nullopt, "ab", "", "xyz", "abz"});
+  auto data = makeRowVector({input});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"endswith(c0, 'ab') AS c1"})
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<bool>(
+          {false, false, std::nullopt, true, false, false, false}),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, endswithNullPattern) {
+  auto input = makeNullableFlatVector<std::string>(
+      {"abc", "zabc", std::nullopt, "ab", "", "xyz", "abz"});
+  auto data = makeRowVector({input});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"endswith(c0, cast(null as varchar)) AS c1"})
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<bool>({
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+      }),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, endswithEmptyPattern) {
+  auto input = makeNullableFlatVector<std::string>(
+      {"abc", "zabc", std::nullopt, "ab", "", "xyz", "abz"});
+  auto data = makeRowVector({input});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"endswith(c0, '') AS c1"})
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<bool>(
+          {true, true, std::nullopt, true, true, true, true}),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, endswithColumnPattern) {
+  auto input = makeNullableFlatVector<std::string>(
+      {"abc", "zabc", std::nullopt, "ab", "", "xyz", "abz"});
+  auto pattern = makeNullableFlatVector<std::string>(
+      {"bc", "bc", "bc", std::nullopt, "", "yz", "zz"});
+  auto data = makeRowVector({input, pattern});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"endswith(c0, c1) AS c2"})
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<bool>(
+          {true, true, std::nullopt, std::nullopt, true, true, false}),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, endswithConstantInput) {
+  auto pattern =
+      makeNullableFlatVector<std::string>({"b", "ab", std::nullopt, "", "abc"});
+  auto data = makeRowVector({pattern});
+  auto typed = test_utils::parseAndInferTypedExpr(
+      "endswith('ab', c0)", data->rowType(), &execCtx_, options_);
+  exec::ExprSet exprSet({typed}, &execCtx_, /*enableConstantFolding*/ false);
+
+  auto result = evaluate(exprSet, data);
+  auto expected =
+      makeNullableFlatVector<bool>({true, true, std::nullopt, true, false});
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(CudfFilterProjectTest, endswithConstantNullInput) {
+  auto pattern =
+      makeNullableFlatVector<std::string>({"b", "ab", std::nullopt, "", "abc"});
+  auto data = makeRowVector({pattern});
+  auto typed = test_utils::parseAndInferTypedExpr(
+      "endswith(cast(null as varchar), c0)",
+      data->rowType(),
+      &execCtx_,
+      options_);
+  exec::ExprSet exprSet({typed}, &execCtx_, /*enableConstantFolding*/ false);
+
+  auto result = evaluate(exprSet, data);
+  auto expected = makeNullableFlatVector<bool>(
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt});
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(CudfFilterProjectTest, endswithColumnPatternNullInput) {
+  auto input = makeNullableFlatVector<std::string>({std::nullopt});
+  auto pattern = makeNullableFlatVector<std::string>({"ab"});
+  auto data = makeRowVector({input, pattern});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"endswith(c0, c1) AS c2"})
+                  .planNode();
+
+  auto expected = makeRowVector({makeNullableFlatVector<bool>({std::nullopt})});
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(CudfFilterProjectTest, endswithColumnPatternNullPattern) {
+  auto input = makeNullableFlatVector<std::string>({"ab"});
+  auto pattern = makeNullableFlatVector<std::string>({std::nullopt});
+  auto data = makeRowVector({input, pattern});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options_)
+                  .values({data})
+                  .project({"endswith(c0, c1) AS c2"})
+                  .planNode();
+
+  auto expected = makeRowVector({makeNullableFlatVector<bool>({std::nullopt})});
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+// Test unary math functions for Spark
+TEST_F(CudfFilterProjectTest, unaryMathFunctions) {
+  auto testUnaryFunction =
+      [&](std::string expr, double input, double expected) {
+        auto valueOpt = evaluateOnce<double, double>(expr, input);
+        auto value = valueOpt.value();
+        EXPECT_DOUBLE_EQ(value, expected);
+      };
+
+  auto testUnaryFunctionInt =
+      [&](std::string expr, double input, int64_t expected) {
+        auto valueOpt = evaluateOnce<int64_t, double>(expr, input);
+        auto value = valueOpt.value();
+        EXPECT_EQ(value, expected);
+      };
+
+  // Inverse trigonometric functions
+  testUnaryFunction("asin(c0)", 0.0, 0.0);
+  testUnaryFunction("acos(c0)", 1.0, 0.0);
+  testUnaryFunction("atan(c0)", 0.0, 0.0);
+
+  // Hyperbolic functions (Spark-specific)
+  testUnaryFunction("sinh(c0)", 0.0, 0.0);
+  testUnaryFunction("cosh(c0)", 0.0, 1.0);
+  testUnaryFunction("asinh(c0)", 0.0, 0.0);
+  testUnaryFunction("acosh(c0)", 1.0, 0.0);
+  testUnaryFunction("atanh(c0)", 0.0, 0.0);
+
+  // Exponential and root functions
+  testUnaryFunction("exp(c0)", 0.0, 1.0);
+  testUnaryFunction("sqrt(c0)", 4.0, 2.0);
+  testUnaryFunction("cbrt(c0)", 8.0, 2.0);
+
+  // Rounding functions (Spark-specific)
+  testUnaryFunctionInt("ceil(c0)", 3.2, 4);
+  testUnaryFunctionInt("floor(c0)", 3.8, 3);
+  testUnaryFunction("rint(c0)", 3.5, 4.0);
+
+  // Absolute value
+  testUnaryFunction("abs(c0)", -5.5, 5.5);
+}
+
+} // namespace
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/tests/utils/CMakeLists.txt b/velox/experimental/cudf/tests/utils/CMakeLists.txt
index eb1f8cb52d9..45e63b145ae 100644
--- a/velox/experimental/cudf/tests/utils/CMakeLists.txt
+++ b/velox/experimental/cudf/tests/utils/CMakeLists.txt
@@ -12,24 +12,31 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_cudf_exec_test_lib CudfHiveConnectorTestBase.cpp CudfPlanBuilder.cpp)
+add_library(
+  velox_cudf_exec_test_lib
+  CudfHiveConnectorTestBase.cpp
+  CudfPlanBuilder.cpp
+  CudfTpcdsQueryBuilder.cpp
+)
 
 set_target_properties(velox_cudf_exec_test_lib PROPERTIES CUDA_ARCHITECTURES native)
 
 target_link_libraries(
   velox_cudf_exec_test_lib
-  velox_vector_test_lib
-  velox_temp_path
-  velox_cursor
   cudf::cudf
+  velox_aggregates
+  velox_core
   velox_cudf_exec
+  velox_cudf_hive_connector
   velox_cudf_vector
-  velox_core
+  velox_cursor
+  velox_duckdb_conversion
   velox_exception
+  velox_exec_test_lib
   velox_expression
-  velox_parse_parser
-  velox_duckdb_conversion
   velox_file_test_utils
-  velox_cudf_hive_connector
-  velox_aggregates
+  velox_parse_parser
+  velox_s3fs
+  velox_test_util
+  velox_vector_test_lib
 )
diff --git a/velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.cpp b/velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.cpp
index 0105dc10119..3eed2b62ad1 100644
--- a/velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.cpp
+++ b/velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.cpp
@@ -18,15 +18,15 @@
 #include "velox/experimental/cudf/exec/ToCudf.h"
 #include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
 #include "velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.h"
-#include "velox/experimental/cudf/vector/CudfVector.h"
 
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/file/tests/FaultyFileSystem.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/hive/HiveConnector.h"
+#include "velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.h"
 #include "velox/dwio/common/FileSink.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
-#include "velox/dwio/dwrf/writer/FlushPolicy.h"
 #include "velox/exec/Driver.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 
@@ -39,26 +39,16 @@
 #include <string>
 
 namespace facebook::velox::cudf_velox::exec::test {
+using namespace facebook::velox::common::testutil;
 
 namespace {
 
 void fillColumnNames(
     cudf::io::table_input_metadata& tableMeta,
-    const std::string& prefix) {
-  // Fill unnamed columns' names in cudf table_meta
-  std::function<void(cudf::io::column_in_metadata&, std::string)>
-      addDefaultName =
-          [&](cudf::io::column_in_metadata& colMeta, std::string defaultName) {
-            if (colMeta.get_name().empty()) {
-              colMeta.set_name(defaultName);
-            }
-            for (int32_t i = 0; i < colMeta.num_children(); ++i) {
-              addDefaultName(
-                  colMeta.child(i), fmt::format("{}_{}", defaultName, i));
-            }
-          };
+    const RowTypePtr& rowType) {
+  VELOX_CHECK_EQ(tableMeta.column_metadata.size(), rowType->size());
   for (int32_t i = 0; i < tableMeta.column_metadata.size(); ++i) {
-    addDefaultName(tableMeta.column_metadata[i], prefix + std::to_string(i));
+    tableMeta.column_metadata[i].set_name(rowType->nameOf(i));
   }
 }
 
@@ -68,28 +58,26 @@ using facebook::velox::connector::hive::HiveConnectorFactory;
 
 CudfHiveConnectorTestBase::CudfHiveConnectorTestBase() {
   filesystems::registerLocalFileSystem();
+  filesystems::registerS3FileSystem();
   tests::utils::registerFaultyFileSystem();
 }
 
 void CudfHiveConnectorTestBase::SetUp() {
   OperatorTestBase::SetUp();
 
-  // Register cudf to enable the CudfHiveDataSource delegate
+  // Register cudf to enable the CudfDatasource creation from CudfHiveConnector
   facebook::velox::cudf_velox::registerCudf();
 
-  // Register Hive connector factory and connector
-  facebook::velox::connector::registerConnectorFactory(
-      std::make_shared<facebook::velox::cudf_velox::connector::hive::
-                           CudfHiveConnectorFactory>());
-  auto hiveConnector =
-      facebook::velox::connector::getConnectorFactory(
-          HiveConnectorFactory::kHiveConnectorName)
-          ->newConnector(
-              kCudfHiveConnectorId,
-              std::make_shared<facebook::velox::config::ConfigBase>(
-                  std::unordered_map<std::string, std::string>()),
-              ioExecutor_.get());
-  facebook::velox::connector::registerConnector(hiveConnector);
+  // Register Hive connector
+  facebook::velox::cudf_velox::connector::hive::CudfHiveConnectorFactory
+      factory;
+  auto config = std::unordered_map<std::string, std::string>{};
+  auto hiveConnector = factory.newConnector(
+      kCudfHiveConnectorId,
+      std::make_shared<facebook::velox::config::ConfigBase>(std::move(config)),
+      ioExecutor_.get());
+  facebook::velox::connector::ConnectorRegistry::global().insert(
+      hiveConnector->connectorId(), hiveConnector);
   dwio::common::registerFileSinks();
 }
 
@@ -97,21 +85,23 @@ void CudfHiveConnectorTestBase::TearDown() {
   // Make sure all pending loads are finished or cancelled before unregister
   // connector.
   ioExecutor_.reset();
-  facebook::velox::connector::unregisterConnector(kCudfHiveConnectorId);
-  facebook::velox::connector::unregisterConnectorFactory(
-      HiveConnectorFactory::kHiveConnectorName);
+  facebook::velox::connector::ConnectorRegistry::global().erase(
+      kCudfHiveConnectorId);
   facebook::velox::cudf_velox::unregisterCudf();
   OperatorTestBase::TearDown();
 }
 
 void CudfHiveConnectorTestBase::resetCudfHiveConnector(
     const std::shared_ptr<const facebook::velox::config::ConfigBase>& config) {
-  facebook::velox::connector::unregisterConnector(kCudfHiveConnectorId);
+  facebook::velox::connector::ConnectorRegistry::global().erase(
+      kCudfHiveConnectorId);
+
+  facebook::velox::cudf_velox::connector::hive::CudfHiveConnectorFactory
+      factory;
   auto hiveConnector =
-      facebook::velox::connector::getConnectorFactory(
-          HiveConnectorFactory::kHiveConnectorName)
-          ->newConnector(kCudfHiveConnectorId, config, ioExecutor_.get());
-  facebook::velox::connector::registerConnector(hiveConnector);
+      factory.newConnector(kCudfHiveConnectorId, config, ioExecutor_.get());
+  facebook::velox::connector::ConnectorRegistry::global().insert(
+      hiveConnector->connectorId(), hiveConnector);
 }
 
 std::vector<RowVectorPtr> CudfHiveConnectorTestBase::makeVectors(
@@ -130,8 +120,7 @@ std::vector<RowVectorPtr> CudfHiveConnectorTestBase::makeVectors(
 std::shared_ptr<facebook::velox::exec::Task>
 CudfHiveConnectorTestBase::assertQuery(
     const core::PlanNodePtr& plan,
-    const std::vector<
-        std::shared_ptr<facebook::velox::exec::test::TempFilePath>>& filePaths,
+    const std::vector<std::shared_ptr<TempFilePath>>& filePaths,
     const std::string& duckDbSql) {
   return OperatorTestBase::assertQuery(
       plan, makeCudfHiveConnectorSplits(filePaths), duckDbSql);
@@ -153,48 +142,50 @@ CudfHiveConnectorTestBase::assertQuery(
       .assertResults(duckDbSql);
 }
 
-std::vector<std::shared_ptr<facebook::velox::exec::test::TempFilePath>>
+std::vector<std::shared_ptr<TempFilePath>>
 CudfHiveConnectorTestBase::makeFilePaths(int count) {
-  std::vector<std::shared_ptr<facebook::velox::exec::test::TempFilePath>>
-      filePaths;
+  std::vector<std::shared_ptr<TempFilePath>> filePaths;
   filePaths.reserve(count);
   for (auto i = 0; i < count; ++i) {
-    filePaths.emplace_back(facebook::velox::exec::test::TempFilePath::create());
+    filePaths.emplace_back(TempFilePath::create());
   }
   return filePaths;
 }
 
 void CudfHiveConnectorTestBase::writeToFile(
     const std::string& filePath,
-    const std::vector<RowVectorPtr>& vectors,
-    std::string prefix) {
+    const std::vector<RowVectorPtr>& vectors) {
   // Convert all RowVectorPtrs to cudf tables
+  auto stream = cudf::get_default_stream();
   std::vector<std::unique_ptr<cudf::table>> cudfTables;
   cudfTables.reserve(vectors.size());
   for (const auto& vector : vectors) {
     VELOX_CHECK_NOT_NULL(vector);
     if (vector->size()) {
-      auto stream = cudf::get_default_stream();
-      auto cudfTable = with_arrow::toCudfTable(vector, vector->pool(), stream);
+      auto cudfTable = with_arrow::toCudfTable(
+          vector,
+          vector->pool(),
+          stream,
+          cudf::get_current_device_resource_ref());
       stream.synchronize();
       cudfTables.emplace_back(std::move(cudfTable));
     }
   }
   // Make sure cudfTables has at least one table
   if (cudfTables.empty()) {
-    VELOX_CHECK(not cudfTables.empty());
     return;
   }
 
   // Create a sink and writer
+  auto rowType = asRowType(vectors[0]->type());
   auto const sinkInfo = cudf::io::sink_info(filePath);
   auto tableInputMetadata =
       cudf::io::table_input_metadata(cudfTables[0]->view());
-  fillColumnNames(tableInputMetadata, prefix);
+  fillColumnNames(tableInputMetadata, rowType);
   auto options = cudf::io::chunked_parquet_writer_options::builder(sinkInfo)
                      .metadata(tableInputMetadata)
                      .build();
-  cudf::io::chunked_parquet_writer writer(options);
+  cudf::io::chunked_parquet_writer writer(options, stream);
 
   // Write all table chunks
   for (const auto& table : cudfTables) {
@@ -207,31 +198,35 @@ void CudfHiveConnectorTestBase::writeToFile(
 
 void CudfHiveConnectorTestBase::writeToFile(
     const std::string& filePath,
-    RowVectorPtr vector,
-    std::string prefix) {
-  auto const sinkInfo = cudf::io::sink_info(filePath);
+    RowVectorPtr vector) {
   VELOX_CHECK_NOT_NULL(vector);
+  auto rowType = asRowType(vector->type());
+  auto const sinkInfo = cudf::io::sink_info(filePath);
   auto stream = cudf::get_default_stream();
-  auto cudfTable = with_arrow::toCudfTable(vector, vector->pool(), stream);
+  auto cudfTable = with_arrow::toCudfTable(
+      vector, vector->pool(), stream, cudf::get_current_device_resource_ref());
   stream.synchronize();
   auto tableInputMetadata = cudf::io::table_input_metadata(cudfTable->view());
-  fillColumnNames(tableInputMetadata, prefix);
+  fillColumnNames(tableInputMetadata, rowType);
   auto options =
       cudf::io::parquet_writer_options::builder(sinkInfo, cudfTable->view())
           .metadata(tableInputMetadata)
           .build();
-  cudf::io::write_parquet(options);
+  cudf::io::write_parquet(options, stream);
 }
 
 std::vector<std::shared_ptr<facebook::velox::connector::ConnectorSplit>>
 CudfHiveConnectorTestBase::makeCudfHiveConnectorSplits(
-    const std::vector<
-        std::shared_ptr<facebook::velox::exec::test::TempFilePath>>&
-        filePaths) {
+    const std::vector<std::shared_ptr<TempFilePath>>& filePaths) {
   std::vector<std::shared_ptr<facebook::velox::connector::ConnectorSplit>>
       splits;
   for (const auto& filePath : filePaths) {
-    splits.push_back(makeCudfHiveConnectorSplit(filePath->getPath()));
+    splits.push_back(makeCudfHiveConnectorSplit(
+        filePath->getPath(),
+        filePath->fileSize(),
+        filePath->fileModifiedTime(),
+        0,
+        std::numeric_limits<uint64_t>::max()));
   }
   return splits;
 }
@@ -240,7 +235,9 @@ std::vector<
     std::shared_ptr<facebook::velox::connector::hive::HiveConnectorSplit>>
 CudfHiveConnectorTestBase::makeCudfHiveConnectorSplits(
     const std::string& filePath,
-    uint32_t splitCount) {
+    uint32_t splitCount,
+    const std::optional<std::unordered_map<std::string, std::string>>&
+        infoColumns) {
   auto file =
       filesystems::getFileSystem(filePath, nullptr)->openFileForRead(filePath);
   const int64_t fileSize = file->size();
@@ -251,12 +248,18 @@ CudfHiveConnectorTestBase::makeCudfHiveConnectorSplits(
       splits;
   // Add all the splits.
   for (int i = 0; i < splitCount; i++) {
-    auto split =
+    auto splitBuilder =
         facebook::velox::connector::hive::HiveConnectorSplitBuilder(filePath)
             .connectorId(kCudfHiveConnectorId)
             .fileFormat(facebook::velox::dwio::common::FileFormat::PARQUET)
-            .build();
-    splits.push_back(std::move(split));
+            .start(i * splitSize)
+            .length(splitSize);
+    if (infoColumns.has_value()) {
+      for (auto infoColumn : infoColumns.value()) {
+        splitBuilder.infoColumn(infoColumn.first, infoColumn.second);
+      }
+    }
+    splits.push_back(splitBuilder.build());
   }
   return splits;
 }
@@ -264,14 +267,34 @@ CudfHiveConnectorTestBase::makeCudfHiveConnectorSplits(
 std::shared_ptr<facebook::velox::connector::hive::HiveConnectorSplit>
 CudfHiveConnectorTestBase::makeCudfHiveConnectorSplit(
     const std::string& filePath,
+    uint64_t start,
+    uint64_t length,
     int64_t splitWeight) {
   return facebook::velox::connector::hive::HiveConnectorSplitBuilder(filePath)
       .connectorId(kCudfHiveConnectorId)
       .fileFormat(facebook::velox::dwio::common::FileFormat::PARQUET)
+      .start(start)
+      .length(length)
       .splitWeight(splitWeight)
       .build();
 }
 
+std::shared_ptr<facebook::velox::connector::hive::HiveConnectorSplit>
+CudfHiveConnectorTestBase::makeCudfHiveConnectorSplit(
+    const std::string& filePath,
+    int64_t fileSize,
+    int64_t fileModifiedTime,
+    uint64_t start,
+    uint64_t length) {
+  return facebook::velox::connector::hive::HiveConnectorSplitBuilder(filePath)
+      .connectorId(kCudfHiveConnectorId)
+      .fileFormat(facebook::velox::dwio::common::FileFormat::PARQUET)
+      .infoColumn("$file_size", fmt::format("{}", fileSize))
+      .infoColumn("$file_modified_time", fmt::format("{}", fileModifiedTime))
+      .start(start)
+      .length(length)
+      .build();
+}
 // static
 std::shared_ptr<connector::hive::CudfHiveInsertTableHandle>
 CudfHiveConnectorTestBase::makeCudfHiveInsertTableHandle(
@@ -289,7 +312,7 @@ CudfHiveConnectorTestBase::makeCudfHiveInsertTableHandle(
         std::make_shared<connector::hive::CudfHiveColumnHandle>(
             tableColumnNames.at(i),
             tableColumnTypes.at(i),
-            cudf::data_type{veloxToCudfTypeId(tableColumnTypes.at(i))}));
+            veloxToCudfDataType(tableColumnTypes.at(i))));
   }
 
   return std::make_shared<connector::hive::CudfHiveInsertTableHandle>(
diff --git a/velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.h b/velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.h
index d67719b1a6e..be316c32159 100644
--- a/velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.h
+++ b/velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.h
@@ -21,15 +21,17 @@
 #include "velox/experimental/cudf/connectors/hive/CudfHiveDataSink.h"
 #include "velox/experimental/cudf/connectors/hive/CudfHiveDataSource.h"
 
+#include "velox/common/testutil/TempFilePath.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
 #include "velox/connectors/hive/TableHandle.h"
 #include "velox/exec/Operator.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
-#include "velox/exec/tests/utils/TempFilePath.h"
 #include "velox/type/tests/SubfieldFiltersBuilder.h"
 
 namespace facebook::velox::cudf_velox::exec::test {
 
+using TempFilePath = common::testutil::TempFilePath;
+
 static const std::string kCudfHiveConnectorId = "test-cudf-hive";
 
 using ColumnHandleMap = std::unordered_map<
@@ -47,15 +49,11 @@ class CudfHiveConnectorTestBase
   void resetCudfHiveConnector(
       const std::shared_ptr<const facebook::velox::config::ConfigBase>& config);
 
-  void writeToFile(
-      const std::string& filePath,
-      RowVectorPtr vector,
-      std::string prefix = "c");
+  void writeToFile(const std::string& filePath, RowVectorPtr vector);
 
   void writeToFile(
       const std::string& filePath,
-      const std::vector<RowVectorPtr>& vectors,
-      std::string prefix = "c");
+      const std::vector<RowVectorPtr>& vectors);
 
   std::vector<RowVectorPtr> makeVectors(
       const RowTypePtr& rowType,
@@ -67,9 +65,7 @@ class CudfHiveConnectorTestBase
   /// Assumes plan has a single TableScan node.
   std::shared_ptr<facebook::velox::exec::Task> assertQuery(
       const facebook::velox::core::PlanNodePtr& plan,
-      const std::vector<
-          std::shared_ptr<facebook::velox::exec::test::TempFilePath>>&
-          filePaths,
+      const std::vector<std::shared_ptr<TempFilePath>>& filePaths,
       const std::string& duckDbSql);
 
   std::shared_ptr<facebook::velox::exec::Task> assertQuery(
@@ -79,36 +75,46 @@ class CudfHiveConnectorTestBase
       const std::string& duckDbSql,
       const int32_t numPrefetchSplit);
 
-  static std::vector<std::shared_ptr<facebook::velox::exec::test::TempFilePath>>
-  makeFilePaths(int count);
+  static std::vector<std::shared_ptr<TempFilePath>> makeFilePaths(int count);
 
   static std::shared_ptr<facebook::velox::connector::hive::HiveConnectorSplit>
   makeCudfHiveConnectorSplit(
       const std::string& filePath,
+      uint64_t start = 0,
+      uint64_t length =
+          static_cast<uint64_t>(std::numeric_limits<cudf::size_type>::max()),
       int64_t splitWeight = 0);
 
+  static std::shared_ptr<facebook::velox::connector::hive::HiveConnectorSplit>
+  makeCudfHiveConnectorSplit(
+      const std::string& filePath,
+      int64_t fileSize,
+      int64_t fileModifiedTime,
+      uint64_t start,
+      uint64_t length);
+
   static std::vector<
       std::shared_ptr<facebook::velox::connector::ConnectorSplit>>
   makeCudfHiveConnectorSplits(
-      const std::vector<
-          std::shared_ptr<facebook::velox::exec::test::TempFilePath>>&
-          filePaths);
+      const std::vector<std::shared_ptr<TempFilePath>>& filePaths);
 
   static std::vector<
       std::shared_ptr<facebook::velox::connector::hive::HiveConnectorSplit>>
-  makeCudfHiveConnectorSplits(const std::string& filePath, uint32_t splitCount);
+  makeCudfHiveConnectorSplits(
+      const std::string& filePath,
+      uint32_t splitCount,
+      const std::optional<std::unordered_map<std::string, std::string>>&
+          infoColumns = {});
 
   static std::shared_ptr<facebook::velox::connector::hive::HiveTableHandle>
   makeTableHandle(
       const std::string& tableName = "parquet_table",
       const RowTypePtr& dataColumns = nullptr,
-      bool filterPushdownEnabled = false,
       common::SubfieldFilters subfieldFilters = {},
       const core::TypedExprPtr& remainingFilterExpr = nullptr) {
     return std::make_shared<facebook::velox::connector::hive::HiveTableHandle>(
         kCudfHiveConnectorId,
         tableName,
-        filterPushdownEnabled,
         std::move(subfieldFilters),
         remainingFilterExpr,
         dataColumns);
@@ -121,7 +127,7 @@ class CudfHiveConnectorTestBase
   makeColumnHandle(
       const std::string& name,
       const TypePtr& type,
-      facebook::velox::connector::hive::HiveColumnHandle::ColumnType
+      facebook::velox::connector::hive::FileColumnHandle::ColumnType
           columnType = facebook::velox::connector::hive::HiveColumnHandle::
               ColumnType::kRegular,
       const std::vector<facebook::velox::common::Subfield>& requiredSubfields =
diff --git a/velox/experimental/cudf/tests/utils/CudfTpcdsQueryBuilder.cpp b/velox/experimental/cudf/tests/utils/CudfTpcdsQueryBuilder.cpp
new file mode 100644
index 00000000000..a3717144597
--- /dev/null
+++ b/velox/experimental/cudf/tests/utils/CudfTpcdsQueryBuilder.cpp
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/cudf/connectors/hive/CudfHiveConfig.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveConnector.h"
+#include "velox/experimental/cudf/tests/utils/CudfTpcdsQueryBuilder.h"
+
+#include "velox/connectors/ConnectorRegistry.h"
+#include "velox/connectors/hive/HiveConnector.h"
+
+// Forward-declare registerCudf/unregisterCudf to avoid pulling in ToCudf.h
+// which has namespace issues when included from a non-CUDA translation unit
+// inside the cudf_velox::exec::test namespace.
+namespace facebook::velox::cudf_velox {
+void registerCudf();
+void unregisterCudf();
+} // namespace facebook::velox::cudf_velox
+
+namespace facebook::velox::cudf_velox::exec::test {
+
+CudfTpcdsQueryBuilder::CudfTpcdsQueryBuilder(
+    dwio::common::FileFormat format,
+    folly::Executor* ioExecutor)
+    : TpcdsQueryBuilder(format), ioExecutor_(ioExecutor) {}
+
+void CudfTpcdsQueryBuilder::enableCudf() {
+  cudf_velox::registerCudf();
+  cudfEnabled_ = true;
+}
+
+void CudfTpcdsQueryBuilder::registerHiveConnector(
+    const std::string& connectorId,
+    folly::Executor* /*ioExecutor*/) {
+  auto configValues = std::unordered_map<std::string, std::string>();
+  configValues
+      [connector::hive::CudfHiveConfig::kAllowMismatchedCudfHiveSchemas] =
+          "true";
+  auto properties =
+      std::make_shared<const config::ConfigBase>(std::move(configValues));
+
+  connector::hive::CudfHiveConnectorFactory factory;
+  auto c = factory.newConnector(connectorId, properties, ioExecutor_);
+  ::facebook::velox::connector::ConnectorRegistry::global().insert(
+      c->connectorId(), c);
+
+  LOG(INFO) << "CudfTpcdsQueryBuilder: registered CudfHiveConnector under ID '"
+            << connectorId << "'";
+}
+
+void CudfTpcdsQueryBuilder::shutdown() {
+  if (cudfEnabled_) {
+    cudf_velox::unregisterCudf();
+    cudfEnabled_ = false;
+  }
+  // Call base to unregister the connector.
+  TpcdsQueryBuilder::shutdown();
+}
+
+} // namespace facebook::velox::cudf_velox::exec::test
diff --git a/velox/experimental/cudf/tests/utils/CudfTpcdsQueryBuilder.h b/velox/experimental/cudf/tests/utils/CudfTpcdsQueryBuilder.h
new file mode 100644
index 00000000000..0ab5cd2ebca
--- /dev/null
+++ b/velox/experimental/cudf/tests/utils/CudfTpcdsQueryBuilder.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/exec/tests/utils/TpcdsQueryBuilder.h"
+
+#include <folly/executors/IOThreadPoolExecutor.h>
+
+namespace facebook::velox::cudf_velox::exec::test {
+
+/// CuDF-enabled extension of TpcdsQueryBuilder.
+/// Registers CudfHiveConnector instead of plain HiveConnector and
+/// calls cudf_velox::registerCudf() / unregisterCudf() for GPU operator
+/// replacements.
+class CudfTpcdsQueryBuilder
+    : public facebook::velox::exec::test::TpcdsQueryBuilder {
+ public:
+  explicit CudfTpcdsQueryBuilder(
+      dwio::common::FileFormat format = dwio::common::FileFormat::PARQUET,
+      folly::Executor* ioExecutor = nullptr);
+
+  /// Enable CuDF GPU operator replacements.
+  /// Must be called before getQueryPlan().
+  void enableCudf();
+
+  /// Unregisters cuDF operators and connectors.
+  void shutdown() override;
+
+ protected:
+  /// Registers CudfHiveConnector instead of HiveConnector.
+  void registerHiveConnector(
+      const std::string& connectorId,
+      folly::Executor* ioExecutor = nullptr) override;
+
+ private:
+  bool cudfEnabled_{false};
+  folly::Executor* ioExecutor_{nullptr};
+};
+
+} // namespace facebook::velox::cudf_velox::exec::test
diff --git a/velox/experimental/cudf/tests/utils/ExpressionTestUtil.h b/velox/experimental/cudf/tests/utils/ExpressionTestUtil.h
new file mode 100644
index 00000000000..925c3b60950
--- /dev/null
+++ b/velox/experimental/cudf/tests/utils/ExpressionTestUtil.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/expression/Expr.h"
+#include "velox/expression/ExprCompiler.h"
+#include "velox/parse/ExpressionsParser.h"
+#include "velox/parse/TypeResolver.h"
+
+#include <memory>
+#include <string>
+
+namespace facebook::velox::cudf_velox::test_utils {
+
+// Parse SQL and infer types only, without compiling to exec::Expr
+inline core::TypedExprPtr parseAndInferTypedExpr(
+    const std::string& sql,
+    const RowTypePtr& rowType,
+    core::ExecCtx* execCtx,
+    const parse::ParseOptions& options = {}) {
+  auto untyped = parse::DuckSqlExpressionsParser(options).parseExpr(sql);
+  return core::Expressions::inferTypes(untyped, rowType, execCtx->pool());
+}
+
+inline std::shared_ptr<exec::Expr> compileExecExpr(
+    const std::string& sql,
+    const RowTypePtr& rowType,
+    core::ExecCtx* execCtx,
+    const parse::ParseOptions& options = {}) {
+  auto typed = parseAndInferTypedExpr(sql, rowType, execCtx, options);
+  exec::ExprSet exprSet({typed}, execCtx, /*enableConstantFolding*/ false);
+  return exprSet.expr(0);
+}
+
+} // namespace facebook::velox::cudf_velox::test_utils
diff --git a/velox/experimental/cudf/vector/CMakeLists.txt b/velox/experimental/cudf/vector/CMakeLists.txt
index 018b49cbb13..617d32b359b 100644
--- a/velox/experimental/cudf/vector/CMakeLists.txt
+++ b/velox/experimental/cudf/vector/CMakeLists.txt
@@ -16,4 +16,4 @@ add_library(velox_cudf_vector CudfVector.cpp)
 
 set_target_properties(velox_cudf_vector PROPERTIES CUDA_ARCHITECTURES native)
 
-target_link_libraries(velox_cudf_vector cudf::cudf velox_exception velox_common_base velox_vector)
+target_link_libraries(velox_cudf_vector cudf::cudf velox_common_base velox_exception velox_vector)
diff --git a/velox/experimental/cudf/vector/CudfVector.cpp b/velox/experimental/cudf/vector/CudfVector.cpp
index 93e1c22bd67..043ca691fb2 100644
--- a/velox/experimental/cudf/vector/CudfVector.cpp
+++ b/velox/experimental/cudf/vector/CudfVector.cpp
@@ -14,10 +14,12 @@
  * limitations under the License.
  */
 
+#include "velox/experimental/cudf/CudfNoDefaults.h"
 #include "velox/experimental/cudf/vector/CudfVector.h"
 
 #include "velox/buffer/Buffer.h"
 #include "velox/common/memory/MemoryPool.h"
+#include "velox/common/process/StackTrace.h"
 #include "velox/vector/TypeAliases.h"
 
 #include <cudf/column/column.hpp>
@@ -94,6 +96,17 @@ std::pair<uint64_t, std::unique_ptr<cudf::table>> getTableSize(
       totalBytes, std::make_unique<cudf::table>(std::move(columnsOut)));
 }
 
+void logDefaultStreamIfNeeded(
+    rmm::cuda_stream_view stream,
+    const char* constructorName) {
+  if (stream.value() != rmm::cuda_stream_default.value()) {
+    return;
+  }
+  LOG(WARNING) << constructorName
+               << " constructed with default CUDA stream. Backtrace:\n"
+               << process::StackTrace().toString();
+}
+
 } // namespace
 
 CudfVector::CudfVector(
@@ -109,11 +122,57 @@ CudfVector::CudfVector(
           size,
           std::vector<VectorPtr>(),
           std::nullopt),
-      table_{std::move(table)},
+      tableStorage_{std::move(table)},
       stream_{stream} {
-  auto [bytes, tableOut] = getTableSize(std::move(table_));
+  logDefaultStreamIfNeeded(stream_, "CudfVector(table)");
+  auto& tablePtr = std::get<std::unique_ptr<cudf::table>>(tableStorage_);
+  auto [bytes, tableOut] = getTableSize(std::move(tablePtr));
   flatSize_ = bytes;
-  table_ = std::move(tableOut);
+  tablePtr = std::move(tableOut);
+  tabView_ = tablePtr->view();
+}
+
+CudfVector::CudfVector(
+    velox::memory::MemoryPool* pool,
+    TypePtr type,
+    vector_size_t size,
+    std::unique_ptr<cudf::packed_table>&& packedTable,
+    rmm::cuda_stream_view stream)
+    : RowVector(
+          pool,
+          std::move(type),
+          BufferPtr(nullptr),
+          size,
+          std::vector<VectorPtr>(),
+          std::nullopt),
+      tableStorage_{std::move(packedTable)},
+      stream_{stream} {
+  logDefaultStreamIfNeeded(stream_, "CudfVector(packed_table)");
+  auto& packedPtr =
+      std::get<std::unique_ptr<cudf::packed_table>>(tableStorage_);
+  tabView_ = packedPtr->table;
+  // For packed table, flatSize is the size of the GPU data buffer
+  flatSize_ = packedPtr->data.gpu_data->size();
+}
+
+std::unique_ptr<cudf::table> CudfVector::release() {
+  flatSize_ = 0;
+  if (auto* tablePtr =
+          std::get_if<std::unique_ptr<cudf::table>>(&tableStorage_)) {
+    // Constructed from owned table - just move it out
+    return std::move(*tablePtr);
+  }
+  // Constructed from packed_table - materialize a table from the view.
+  // This copies the data since the view references the packed buffer.
+  auto& packedPtr =
+      std::get<std::unique_ptr<cudf::packed_table>>(tableStorage_);
+  // Using same memory resource as packed_table
+  auto mr = packedPtr->data.gpu_data->memory_resource();
+  auto materializedTable = std::make_unique<cudf::table>(tabView_, stream_, mr);
+  stream_.synchronize();
+  // Clear the packed table since we've materialized
+  packedPtr.reset();
+  return materializedTable;
 }
 
 uint64_t CudfVector::estimateFlatSize() const {
diff --git a/velox/experimental/cudf/vector/CudfVector.h b/velox/experimental/cudf/vector/CudfVector.h
index bb27bd4a889..2f9031d39f1 100644
--- a/velox/experimental/cudf/vector/CudfVector.h
+++ b/velox/experimental/cudf/vector/CudfVector.h
@@ -19,18 +19,25 @@
 #include "velox/vector/ComplexVector.h"
 #include "velox/vector/TypeAliases.h"
 
+#include <cudf/contiguous_split.hpp>
 #include <cudf/table/table.hpp>
 
 #include <rmm/cuda_stream_view.hpp>
 
 #include <memory>
 #include <utility>
+#include <variant>
 
 namespace facebook::velox::cudf_velox {
 
 // Vector class which holds GPU data from cuDF.
+// Can be constructed either from an owned cudf::table or from packed_table.
+// When constructed from packed_table, the data remains packed and tabView_
+// references the table view inside packed_table without copying the underlying
+// GPU data.
 class CudfVector : public RowVector {
  public:
+  /// Constructs a CudfVector from an owned cudf::table.
   CudfVector(
       velox::memory::MemoryPool* pool,
       TypePtr type,
@@ -38,23 +45,43 @@ class CudfVector : public RowVector {
       std::unique_ptr<cudf::table>&& table,
       rmm::cuda_stream_view stream);
 
+  /// Constructs a CudfVector from packed_table.
+  /// The packed data is retained and tabView_ references the table view inside
+  /// packed_table. This avoids copying the underlying GPU data.
+  CudfVector(
+      velox::memory::MemoryPool* pool,
+      TypePtr type,
+      vector_size_t size,
+      std::unique_ptr<cudf::packed_table>&& packedTable,
+      rmm::cuda_stream_view stream);
+
   rmm::cuda_stream_view stream() const {
     return stream_;
   }
 
   cudf::table_view getTableView() const {
-    return table_->view();
+    return tabView_;
   }
 
-  std::unique_ptr<cudf::table>&& release() {
-    flatSize_ = 0;
-    return std::move(table_);
-  }
+  /// Releases ownership of the underlying table.
+  /// If constructed from packed_table, materializes a table from the view
+  /// first (which copies the data).
+  std::unique_ptr<cudf::table> release();
 
   uint64_t estimateFlatSize() const override;
 
  private:
-  std::unique_ptr<cudf::table> table_;
+  // Storage for either an owned table or packed table.
+  // Only one is active at a time - using variant enforces this at compile time.
+  using TableStorage = std::variant<
+      std::unique_ptr<cudf::table>,
+      std::unique_ptr<cudf::packed_table>>;
+  TableStorage tableStorage_;
+
+  // Table view - always valid, points to either table_->view() or
+  // packedTable_->table.
+  cudf::table_view tabView_;
+
   rmm::cuda_stream_view stream_;
   uint64_t flatSize_;
 };
diff --git a/velox/experimental/cudf/vector/TableViewPrinter.h b/velox/experimental/cudf/vector/TableViewPrinter.h
new file mode 100644
index 00000000000..de116f14b4e
--- /dev/null
+++ b/velox/experimental/cudf/vector/TableViewPrinter.h
@@ -0,0 +1,371 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*
+ * A standalone table_view schema printer for cudf::table_view.
+ * Can be copied to any project that uses cudf table_view.
+ *
+ * Usage:
+ *   cudf::table_view const& table = ...;
+ *   cudf::print_table_schema(table);
+ *   // or
+ *   std::string str = cudf::table_schema_to_string(table);
+ */
+#pragma once
+
+#include <cudf/column/column_view.hpp>
+#include <cudf/table/table_view.hpp>
+#include <cudf/types.hpp>
+
+#include <iostream>
+#include <sstream>
+#include <string>
+
+namespace cudf {
+
+/**
+ * @brief Get the string representation of a cudf::type_id
+ */
+inline std::string type_id_to_string(cudf::type_id id) {
+  switch (id) {
+    case cudf::type_id::EMPTY:
+      return "EMPTY";
+    case cudf::type_id::INT8:
+      return "INT8";
+    case cudf::type_id::INT16:
+      return "INT16";
+    case cudf::type_id::INT32:
+      return "INT32";
+    case cudf::type_id::INT64:
+      return "INT64";
+    case cudf::type_id::UINT8:
+      return "UINT8";
+    case cudf::type_id::UINT16:
+      return "UINT16";
+    case cudf::type_id::UINT32:
+      return "UINT32";
+    case cudf::type_id::UINT64:
+      return "UINT64";
+    case cudf::type_id::FLOAT32:
+      return "FLOAT32";
+    case cudf::type_id::FLOAT64:
+      return "FLOAT64";
+    case cudf::type_id::BOOL8:
+      return "BOOL8";
+    case cudf::type_id::TIMESTAMP_DAYS:
+      return "TIMESTAMP_DAYS";
+    case cudf::type_id::TIMESTAMP_SECONDS:
+      return "TIMESTAMP_SECONDS";
+    case cudf::type_id::TIMESTAMP_MILLISECONDS:
+      return "TIMESTAMP_MILLISECONDS";
+    case cudf::type_id::TIMESTAMP_MICROSECONDS:
+      return "TIMESTAMP_MICROSECONDS";
+    case cudf::type_id::TIMESTAMP_NANOSECONDS:
+      return "TIMESTAMP_NANOSECONDS";
+    case cudf::type_id::DURATION_DAYS:
+      return "DURATION_DAYS";
+    case cudf::type_id::DURATION_SECONDS:
+      return "DURATION_SECONDS";
+    case cudf::type_id::DURATION_MILLISECONDS:
+      return "DURATION_MILLISECONDS";
+    case cudf::type_id::DURATION_MICROSECONDS:
+      return "DURATION_MICROSECONDS";
+    case cudf::type_id::DURATION_NANOSECONDS:
+      return "DURATION_NANOSECONDS";
+    case cudf::type_id::DICTIONARY32:
+      return "DICTIONARY32";
+    case cudf::type_id::STRING:
+      return "STRING";
+    case cudf::type_id::LIST:
+      return "LIST";
+    case cudf::type_id::DECIMAL32:
+      return "DECIMAL32";
+    case cudf::type_id::DECIMAL64:
+      return "DECIMAL64";
+    case cudf::type_id::DECIMAL128:
+      return "DECIMAL128";
+    case cudf::type_id::STRUCT:
+      return "STRUCT";
+    default:
+      return "UNKNOWN_TYPE";
+  }
+}
+
+/**
+ * @brief Recursively print column type information
+ *
+ * @param col The column view to print
+ * @param os Output stream to write to
+ * @param depth Current depth in the tree (for indentation)
+ * @param indent_str String to use for each level of indentation
+ * @param column_name Optional name for the column
+ */
+inline void print_column_type_impl(
+    column_view const& col,
+    std::ostream& os,
+    int depth,
+    std::string const& indent_str,
+    std::string const& column_name = "") {
+  // Print indentation
+  for (int i = 0; i < depth; ++i) {
+    os << indent_str;
+  }
+
+  // Print column name if provided
+  if (!column_name.empty()) {
+    os << column_name << ": ";
+  }
+
+  auto const type_id = col.type().id();
+  os << type_id_to_string(type_id);
+
+  // Print additional info for fixed-point types (scale)
+  if (type_id == cudf::type_id::DECIMAL32 ||
+      type_id == cudf::type_id::DECIMAL64 ||
+      type_id == cudf::type_id::DECIMAL128) {
+    os << "(scale=" << col.type().scale() << ")";
+  }
+
+  // Print size info
+  os << " [size=" << col.size();
+  if (col.nullable()) {
+    os << ", nulls=" << col.null_count();
+  }
+  os << "]";
+
+  // Handle nested types
+  auto const num_children = col.num_children();
+  if (num_children > 0) {
+    os << " {\n";
+
+    if (type_id == cudf::type_id::LIST) {
+      // LIST has 1 child: offsets (internal) and the actual list elements
+      // The child at index 0 is the offsets column (INT32)
+      // The child at index 1 is the element column
+      if (num_children >= 1) {
+        print_column_type_impl(
+            col.child(0), os, depth + 1, indent_str, "offsets");
+      }
+      if (num_children >= 2) {
+        print_column_type_impl(
+            col.child(1), os, depth + 1, indent_str, "elements");
+      }
+    } else if (type_id == cudf::type_id::STRING) {
+      // STRING has 2 children: offsets and chars
+      if (num_children >= 1) {
+        print_column_type_impl(
+            col.child(0), os, depth + 1, indent_str, "offsets");
+      }
+      if (num_children >= 2) {
+        print_column_type_impl(
+            col.child(1), os, depth + 1, indent_str, "chars");
+      }
+    } else if (type_id == cudf::type_id::STRUCT) {
+      // STRUCT has N children, one for each field
+      for (size_type i = 0; i < num_children; ++i) {
+        print_column_type_impl(
+            col.child(i),
+            os,
+            depth + 1,
+            indent_str,
+            "field[" + std::to_string(i) + "]");
+      }
+    } else if (type_id == cudf::type_id::DICTIONARY32) {
+      // DICTIONARY has 2 children: indices and keys
+      if (num_children >= 1) {
+        print_column_type_impl(
+            col.child(0), os, depth + 1, indent_str, "indices");
+      }
+      if (num_children >= 2) {
+        print_column_type_impl(col.child(1), os, depth + 1, indent_str, "keys");
+      }
+    } else {
+      // Generic handling for other types with children
+      for (size_type i = 0; i < num_children; ++i) {
+        print_column_type_impl(
+            col.child(i),
+            os,
+            depth + 1,
+            indent_str,
+            "child[" + std::to_string(i) + "]");
+      }
+    }
+
+    for (int i = 0; i < depth; ++i) {
+      os << indent_str;
+    }
+    os << "}\n";
+  } else {
+    os << "\n";
+  }
+}
+
+/**
+ * @brief Print the schema/type information of a table_view to an output stream
+ *
+ * Recursively prints the type hierarchy for all columns including nested types
+ * (LIST, STRUCT, STRING, DICTIONARY).
+ *
+ * @param table The table view to print
+ * @param os Output stream (defaults to std::cout)
+ * @param indent_str Indentation string for each level
+ */
+inline void print_table_schema(
+    table_view const& table,
+    std::ostream& os = std::cout,
+    std::string const& indent_str = "  ") {
+  os << "=== Table Schema ===\n";
+  os << "Columns: " << table.num_columns() << ", Rows: " << table.num_rows()
+     << "\n";
+  os << "---\n";
+
+  for (size_type i = 0; i < table.num_columns(); ++i) {
+    print_column_type_impl(
+        table.column(i),
+        os,
+        0,
+        indent_str,
+        "column[" + std::to_string(i) + "]");
+  }
+
+  os << "===================\n";
+}
+
+/**
+ * @brief Convert the schema/type information of a table_view to a string
+ *
+ * @param table The table view to convert
+ * @param indent_str Indentation string for each level
+ * @return String representation of the table schema
+ */
+inline std::string table_schema_to_string(
+    table_view const& table,
+    std::string const& indent_str = "  ") {
+  std::ostringstream oss;
+  print_table_schema(table, oss, indent_str);
+  return oss.str();
+}
+
+/**
+ * @brief Print the schema/type information of a single column_view
+ *
+ * @param col The column view to print
+ * @param os Output stream (defaults to std::cout)
+ * @param indent_str Indentation string for each level
+ * @param column_name Optional name for the column
+ */
+inline void print_column_schema(
+    column_view const& col,
+    std::ostream& os = std::cout,
+    std::string const& indent_str = "  ",
+    std::string const& column_name = "column") {
+  os << "=== Column Schema ===\n";
+  print_column_type_impl(col, os, 0, indent_str, column_name);
+  os << "====================\n";
+}
+
+/**
+ * @brief Convert the schema/type information of a column_view to a string
+ *
+ * @param col The column view to convert
+ * @param indent_str Indentation string for each level
+ * @param column_name Optional name for the column
+ * @return String representation of the column schema
+ */
+inline std::string column_schema_to_string(
+    column_view const& col,
+    std::string const& indent_str = "  ",
+    std::string const& column_name = "column") {
+  std::ostringstream oss;
+  print_column_schema(col, oss, indent_str, column_name);
+  return oss.str();
+}
+
+/**
+ * @brief Get a compact one-line type representation of a column
+ *
+ * Example outputs:
+ *   - "INT32"
+ *   - "LIST<FLOAT64>"
+ *   - "STRUCT<INT32, STRING, LIST<INT64>>"
+ *
+ * @param col The column view
+ * @return Compact type string
+ */
+inline std::string column_type_to_compact_string(column_view const& col) {
+  auto const type_id = col.type().id();
+  std::string result = type_id_to_string(type_id);
+
+  if (type_id == cudf::type_id::DECIMAL32 ||
+      type_id == cudf::type_id::DECIMAL64 ||
+      type_id == cudf::type_id::DECIMAL128) {
+    result += "(scale=" + std::to_string(col.type().scale()) + ")";
+  }
+
+  auto const num_children = col.num_children();
+
+  if (type_id == cudf::type_id::LIST && num_children >= 2) {
+    // For LIST, show element type
+    result += "<" + column_type_to_compact_string(col.child(1)) + ">";
+  } else if (type_id == cudf::type_id::STRUCT && num_children > 0) {
+    // For STRUCT, show all field types
+    result += "<";
+    for (size_type i = 0; i < num_children; ++i) {
+      if (i > 0)
+        result += ", ";
+      result += column_type_to_compact_string(col.child(i));
+    }
+    result += ">";
+  } else if (type_id == cudf::type_id::DICTIONARY32 && num_children >= 2) {
+    // For DICTIONARY, show keys type
+    result += "<keys=" + column_type_to_compact_string(col.child(1)) + ">";
+  }
+
+  return result;
+}
+
+/**
+ * @brief Get a compact one-line schema representation of a table
+ *
+ * Example output: "(INT32, STRING, LIST<FLOAT64>, STRUCT<INT32, STRING>)"
+ *
+ * @param table The table view
+ * @return Compact schema string
+ */
+inline std::string table_schema_to_compact_string(table_view const& table) {
+  std::string result = "(";
+  for (size_type i = 0; i < table.num_columns(); ++i) {
+    if (i > 0)
+      result += ", ";
+    result += column_type_to_compact_string(table.column(i));
+  }
+  result += ")";
+  return result;
+}
+
+/**
+ * @brief Print a compact one-line schema of a table
+ *
+ * @param table The table view to print
+ * @param os Output stream (defaults to std::cout)
+ */
+inline void print_table_schema_compact(
+    table_view const& table,
+    std::ostream& os = std::cout) {
+  os << "Table" << table_schema_to_compact_string(table) << " ["
+     << table.num_rows() << " rows]\n";
+}
+
+} // namespace cudf
diff --git a/velox/experimental/gpu/CudaMemMeter.cu b/velox/experimental/gpu/CudaMemMeter.cu
index c198f961ded..517b6d95fca 100644
--- a/velox/experimental/gpu/CudaMemMeter.cu
+++ b/velox/experimental/gpu/CudaMemMeter.cu
@@ -102,152 +102,153 @@ int main(int argc, char** argv) {
   std::vector<std::thread> threads;
   auto start = std::chrono::steady_clock::now();
   for (auto dev : devices) {
-    threads.push_back(std::thread([dev,
-                                   n,
-                                   start,
-                                   streamSize,
-                                   blockSize,
-                                   bytes,
-                                   streamBytes,
-                                   nRepeats,
-                                   nStreams,
-                                   oneWay,
-                                   multiplier]() {
-      checkCuda(cudaSetDevice(dev));
-      // allocate pinned host memory and device memory
-      float *a, *d_a;
-      printf("%ldKB\n", bytes / 1024);
-      checkCuda(cudaMallocHost((void**)&a, bytes)); // host pinned
-      checkCuda(cudaMalloc((void**)&d_a, bytes)); // device
+    threads.push_back(
+        std::thread([dev,
+                     n,
+                     start,
+                     streamSize,
+                     blockSize,
+                     bytes,
+                     streamBytes,
+                     nRepeats,
+                     nStreams,
+                     oneWay,
+                     multiplier]() {
+          checkCuda(cudaSetDevice(dev));
+          // allocate pinned host memory and device memory
+          float *a, *d_a;
+          printf("%ldKB\n", bytes / 1024);
+          checkCuda(cudaMallocHost((void**)&a, bytes)); // host pinned
+          checkCuda(cudaMalloc((void**)&d_a, bytes)); // device
 
-      float ms; // elapsed time in milliseconds
-      float singleMs = 0;
-      float async1Ms = 0;
-      float async2Ms = 0;
+          float ms; // elapsed time in milliseconds
+          float singleMs = 0;
+          float async1Ms = 0;
+          float async2Ms = 0;
 
-      // create events and streams
-      cudaEvent_t startEvent, stopEvent, dummyEvent;
-      cudaStream_t* stream =
-          (cudaStream_t*)malloc(nStreams * sizeof(cudaStream_t));
-      checkCuda(cudaEventCreate(&startEvent));
-      checkCuda(cudaEventCreate(&stopEvent));
-      checkCuda(cudaEventCreate(&dummyEvent));
-      for (int i = 0; i < nStreams; ++i) {
-        checkCuda(cudaStreamCreate(&stream[i]));
-      }
-      // baseline case - sequential transfer and execute
-      memset(a, 0, bytes);
-      for (int repeat = 0; repeat < nRepeats; ++repeat) {
-        checkCuda(cudaEventRecord(startEvent, 0));
-        checkCuda(cudaMemcpy(d_a, a, bytes, cudaMemcpyHostToDevice));
-        kernel<<<n / blockSize, blockSize>>>(d_a, 0);
-        checkCuda(cudaGetLastError());
-        if (!oneWay) {
-          checkCuda(cudaMemcpy(a, d_a, bytes, cudaMemcpyDeviceToHost));
-        }
-        checkCuda(cudaEventRecord(stopEvent, 0));
-        checkCuda(cudaEventSynchronize(stopEvent));
-        checkCuda(cudaEventElapsedTime(&ms, startEvent, stopEvent));
-        singleMs += ms;
-      }
-      float volume = bytes * nRepeats;
-      printf(
-          "%d at %ld: Time for sequential transfer and execute (ms): %f %f GB/s\n",
-          dev,
-          millis(start),
-          singleMs,
-          multiplier * (volume / (1 << 30)) / (singleMs / 1000));
+          // create events and streams
+          cudaEvent_t startEvent, stopEvent, dummyEvent;
+          cudaStream_t* stream =
+              (cudaStream_t*)malloc(nStreams * sizeof(cudaStream_t));
+          checkCuda(cudaEventCreate(&startEvent));
+          checkCuda(cudaEventCreate(&stopEvent));
+          checkCuda(cudaEventCreate(&dummyEvent));
+          for (int i = 0; i < nStreams; ++i) {
+            checkCuda(cudaStreamCreate(&stream[i]));
+          }
+          // baseline case - sequential transfer and execute
+          memset(a, 0, bytes);
+          for (int repeat = 0; repeat < nRepeats; ++repeat) {
+            checkCuda(cudaEventRecord(startEvent, 0));
+            checkCuda(cudaMemcpy(d_a, a, bytes, cudaMemcpyHostToDevice));
+            kernel<<<n / blockSize, blockSize>>>(d_a, 0);
+            checkCuda(cudaGetLastError());
+            if (!oneWay) {
+              checkCuda(cudaMemcpy(a, d_a, bytes, cudaMemcpyDeviceToHost));
+            }
+            checkCuda(cudaEventRecord(stopEvent, 0));
+            checkCuda(cudaEventSynchronize(stopEvent));
+            checkCuda(cudaEventElapsedTime(&ms, startEvent, stopEvent));
+            singleMs += ms;
+          }
+          float volume = bytes * nRepeats;
+          printf(
+              "%d at %ld: Time for sequential transfer and execute (ms): %f %f GB/s\n",
+              dev,
+              millis(start),
+              singleMs,
+              multiplier * (volume / (1 << 30)) / (singleMs / 1000));
 
-      // asynchronous version 1: loop over {copy, kernel, copy}
-      memset(a, 0, bytes);
-      for (int repeat = 0; repeat < nRepeats; ++repeat) {
-        checkCuda(cudaEventRecord(startEvent, 0));
-        for (int i = 0; i < nStreams; ++i) {
-          int offset = i * streamSize;
-          checkCuda(cudaMemcpyAsync(
-              &d_a[offset],
-              &a[offset],
-              streamBytes,
-              cudaMemcpyHostToDevice,
-              stream[i]));
-          kernel<<<streamSize / blockSize, blockSize, 0, stream[i]>>>(
-              d_a, offset);
-          checkCuda(cudaGetLastError());
-          if (!oneWay) {
-            checkCuda(cudaMemcpyAsync(
-                &a[offset],
-                &d_a[offset],
-                streamBytes,
-                cudaMemcpyDeviceToHost,
-                stream[i]));
+          // asynchronous version 1: loop over {copy, kernel, copy}
+          memset(a, 0, bytes);
+          for (int repeat = 0; repeat < nRepeats; ++repeat) {
+            checkCuda(cudaEventRecord(startEvent, 0));
+            for (int i = 0; i < nStreams; ++i) {
+              int offset = i * streamSize;
+              checkCuda(cudaMemcpyAsync(
+                  &d_a[offset],
+                  &a[offset],
+                  streamBytes,
+                  cudaMemcpyHostToDevice,
+                  stream[i]));
+              kernel<<<streamSize / blockSize, blockSize, 0, stream[i]>>>(
+                  d_a, offset);
+              checkCuda(cudaGetLastError());
+              if (!oneWay) {
+                checkCuda(cudaMemcpyAsync(
+                    &a[offset],
+                    &d_a[offset],
+                    streamBytes,
+                    cudaMemcpyDeviceToHost,
+                    stream[i]));
+              }
+            }
+            checkCuda(cudaEventRecord(stopEvent, 0));
+            checkCuda(cudaEventSynchronize(stopEvent));
+            checkCuda(cudaEventElapsedTime(&ms, startEvent, stopEvent));
+            async1Ms += ms;
           }
-        }
-        checkCuda(cudaEventRecord(stopEvent, 0));
-        checkCuda(cudaEventSynchronize(stopEvent));
-        checkCuda(cudaEventElapsedTime(&ms, startEvent, stopEvent));
-        async1Ms += ms;
-      }
-      volume = streamBytes * nRepeats * nStreams;
-      printf(
-          "%d at %ld: Time for asynchronous V1 transfer and execute (ms): %f %f GB/s\n",
-          dev,
-          millis(start),
-          async1Ms,
-          multiplier * (volume / (1 << 30)) / (async1Ms / 1000));
+          volume = streamBytes * nRepeats * nStreams;
+          printf(
+              "%d at %ld: Time for asynchronous V1 transfer and execute (ms): %f %f GB/s\n",
+              dev,
+              millis(start),
+              async1Ms,
+              multiplier * (volume / (1 << 30)) / (async1Ms / 1000));
 
-      // asynchronous version 2:
-      // loop over copy, loop over kernel, loop over copy
-      memset(a, 0, bytes);
-      for (int repeat = 0; repeat < nRepeats; ++repeat) {
-        checkCuda(cudaEventRecord(startEvent, 0));
-        for (int i = 0; i < nStreams; ++i) {
-          int offset = i * streamSize;
-          checkCuda(cudaMemcpyAsync(
-              &d_a[offset],
-              &a[offset],
-              streamBytes,
-              cudaMemcpyHostToDevice,
-              stream[i]));
-        }
-        for (int i = 0; i < nStreams; ++i) {
-          int offset = i * streamSize;
-          kernel<<<streamSize / blockSize, blockSize, 0, stream[i]>>>(
-              d_a, offset);
-          checkCuda(cudaGetLastError());
-        }
-        for (int i = 0; i < nStreams; ++i) {
-          int offset = i * streamSize;
-          if (!oneWay) {
-            checkCuda(cudaMemcpyAsync(
-                &a[offset],
-                &d_a[offset],
-                streamBytes,
-                cudaMemcpyDeviceToHost,
-                stream[i]));
+          // asynchronous version 2:
+          // loop over copy, loop over kernel, loop over copy
+          memset(a, 0, bytes);
+          for (int repeat = 0; repeat < nRepeats; ++repeat) {
+            checkCuda(cudaEventRecord(startEvent, 0));
+            for (int i = 0; i < nStreams; ++i) {
+              int offset = i * streamSize;
+              checkCuda(cudaMemcpyAsync(
+                  &d_a[offset],
+                  &a[offset],
+                  streamBytes,
+                  cudaMemcpyHostToDevice,
+                  stream[i]));
+            }
+            for (int i = 0; i < nStreams; ++i) {
+              int offset = i * streamSize;
+              kernel<<<streamSize / blockSize, blockSize, 0, stream[i]>>>(
+                  d_a, offset);
+              checkCuda(cudaGetLastError());
+            }
+            for (int i = 0; i < nStreams; ++i) {
+              int offset = i * streamSize;
+              if (!oneWay) {
+                checkCuda(cudaMemcpyAsync(
+                    &a[offset],
+                    &d_a[offset],
+                    streamBytes,
+                    cudaMemcpyDeviceToHost,
+                    stream[i]));
+              }
+            }
+            checkCuda(cudaEventRecord(stopEvent, 0));
+            checkCuda(cudaEventSynchronize(stopEvent));
+            checkCuda(cudaEventElapsedTime(&ms, startEvent, stopEvent));
+            async2Ms += ms;
           }
-        }
-        checkCuda(cudaEventRecord(stopEvent, 0));
-        checkCuda(cudaEventSynchronize(stopEvent));
-        checkCuda(cudaEventElapsedTime(&ms, startEvent, stopEvent));
-        async2Ms += ms;
-      }
-      volume = streamBytes * nRepeats * nStreams;
-      printf(
-          "%d at %ld: Time for asynchronous V2 transfer and execute (ms): %f %f GB/s\n",
-          dev,
-          millis(start),
-          async2Ms,
-          multiplier * (volume / (1 << 30)) / (async2Ms / 1000));
+          volume = streamBytes * nRepeats * nStreams;
+          printf(
+              "%d at %ld: Time for asynchronous V2 transfer and execute (ms): %f %f GB/s\n",
+              dev,
+              millis(start),
+              async2Ms,
+              multiplier * (volume / (1 << 30)) / (async2Ms / 1000));
 
-      // cleanup
-      checkCuda(cudaEventDestroy(startEvent));
-      checkCuda(cudaEventDestroy(stopEvent));
-      checkCuda(cudaEventDestroy(dummyEvent));
-      for (int i = 0; i < nStreams; ++i)
-        checkCuda(cudaStreamDestroy(stream[i]));
-      checkCuda(cudaFree(d_a));
-      checkCuda(cudaFreeHost(a));
-    }));
+          // cleanup
+          checkCuda(cudaEventDestroy(startEvent));
+          checkCuda(cudaEventDestroy(stopEvent));
+          checkCuda(cudaEventDestroy(dummyEvent));
+          for (int i = 0; i < nStreams; ++i)
+            checkCuda(cudaStreamDestroy(stream[i]));
+          checkCuda(cudaFree(d_a));
+          checkCuda(cudaFreeHost(a));
+        }));
   }
   for (auto& thread : threads) {
     thread.join();
diff --git a/velox/experimental/gpu/tests/CMakeLists.txt b/velox/experimental/gpu/tests/CMakeLists.txt
index fd98d6f22a0..06d86b904f6 100644
--- a/velox/experimental/gpu/tests/CMakeLists.txt
+++ b/velox/experimental/gpu/tests/CMakeLists.txt
@@ -16,6 +16,7 @@ find_package(CUB REQUIRED)
 find_package(Thrust REQUIRED)
 
 add_executable(velox_gpu_hash_table_test HashTableTest.cu)
+target_compile_options(velox_gpu_hash_table_test PRIVATE ${VELOX_CUDA_DEBUG_FLAGS})
 target_link_libraries(
   velox_gpu_hash_table_test
   Folly::folly
diff --git a/velox/experimental/gpu/tests/HashTableTest.cu b/velox/experimental/gpu/tests/HashTableTest.cu
index 059c688aa8c..d50e818ead9 100644
--- a/velox/experimental/gpu/tests/HashTableTest.cu
+++ b/velox/experimental/gpu/tests/HashTableTest.cu
@@ -415,8 +415,9 @@ void partitionKeys(
   computeHistogram<<<(size + kBlockSize - 1) / kBlockSize, kBlockSize>>>(
       keys, size, numPartitions - 1, hist);
   CUDA_CHECK_FATAL(cudaMemset(offsets, 0, sizeof(int64_t)));
-  CUDA_CHECK_FATAL(cub::DeviceScan::InclusiveSum(
-      tmp, tmpSize, hist, offsets + 1, numPartitions));
+  CUDA_CHECK_FATAL(
+      cub::DeviceScan::InclusiveSum(
+          tmp, tmpSize, hist, offsets + 1, numPartitions));
   CUDA_CHECK_FATAL(cudaMemcpy(
       hist,
       offsets,
@@ -665,8 +666,9 @@ void runPartitioned() {
   auto hist = allocateDeviceMemory<int64_t>(numPartitions);
   auto offsets = allocateDeviceMemory<int64_t>(numPartitions + 1);
   size_t tmpSize;
-  CUDA_CHECK_FATAL(cub::DeviceScan::InclusiveSum(
-      nullptr, tmpSize, hist.get(), offsets.get(), numPartitions));
+  CUDA_CHECK_FATAL(
+      cub::DeviceScan::InclusiveSum(
+          nullptr, tmpSize, hist.get(), offsets.get(), numPartitions));
   auto tmp = allocateDeviceMemory<char>(tmpSize);
   auto shuffledKeys = allocateDeviceMemory<uint64_t>(numKeys);
 
diff --git a/velox/experimental/ucx-exchange/Acceptor.cpp b/velox/experimental/ucx-exchange/Acceptor.cpp
new file mode 100644
index 00000000000..36fc57d40da
--- /dev/null
+++ b/velox/experimental/ucx-exchange/Acceptor.cpp
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/ucx-exchange/Acceptor.h"
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/ucx-exchange/Communicator.h"
+#include "velox/experimental/ucx-exchange/EndpointRef.h"
+#include "velox/experimental/ucx-exchange/UcxExchangeProtocol.h"
+#include "velox/experimental/ucx-exchange/UcxExchangeServer.h"
+#include "velox/experimental/ucx-exchange/UcxOutputQueueManager.h"
+
+namespace facebook::velox::ucx_exchange {
+
+/*static*/
+void Acceptor::cStyleAMCallback(
+    std::shared_ptr<ucxx::Request> request,
+    ucp_ep_h ep) {
+  VELOX_CHECK_NOT_NULL(request, "AMCallback called with nullptr request!");
+  VELOX_CHECK(
+      request->isCompleted(), "AMCallback called with incomplete request!");
+  auto buffer =
+      std::dynamic_pointer_cast<ucxx::Buffer>(request->getRecvBuffer());
+  VELOX_CHECK_NOT_NULL(buffer, "AMCallback: failed to get receive buffer.");
+  // Validate buffer size BEFORE casting to prevent reading past buffer bounds.
+  VELOX_CHECK_GE(
+      buffer->getSize(),
+      sizeof(HandshakeMsg),
+      "AMCallback: received buffer size ({}) is smaller than HandshakeMsg ({}). "
+      "Possible protocol mismatch or truncated message.",
+      buffer->getSize(),
+      sizeof(HandshakeMsg));
+  HandshakeMsg* handshakePtr = reinterpret_cast<HandshakeMsg*>(buffer->data());
+
+  // Create a exchangeServer based on the information received in the initial
+  // handshake.
+  std::shared_ptr<Communicator> communicator = Communicator::getInstance();
+
+  auto epRef = communicator->findEndpointRefByHandle(ep);
+  VELOX_CHECK_NOT_NULL(epRef, "Could not find endpoint reference");
+
+  const PartitionKey key = {handshakePtr->taskId, handshakePtr->destination};
+
+  // Determine if this is an intra-process transfer by comparing the source's
+  // workerId with our Communicator's workerId. A match means both source and
+  // server are in the same Communicator singleton (same process), so
+  // IntraNodeTransferRegistry (in-process std::promise/future) can be used.
+  //
+  // Previous approach used IP comparison (getLocalIpAddresses), which fails
+  // when multiple Docker containers share the same host IP address.
+  bool isIntraNodeTransfer =
+      cudf_velox::CudfConfig::getInstance().intraNodeExchange &&
+      (handshakePtr->workerId == communicator->getWorkerId());
+
+  // Disable intra-node when the task is not yet initialized (placeholder
+  // queue from sinks connecting before initializeTask) or when the task
+  // uses broadcast mode (all destination servers share the same
+  // packed_columns — the intra-node source's destructive move would
+  // corrupt it for other servers).
+  if (isIntraNodeTransfer) {
+    if (!UcxOutputQueueManager::getInstanceRef()->canUseIntraNode(key.taskId)) {
+      VLOG(2) << "[ACCEPTOR] Disabling intra-node for task " << key.taskId
+              << " (not initialized or broadcast)";
+      isIntraNodeTransfer = false;
+    }
+  }
+
+  std::string peerIp = epRef->getPeerIp();
+
+  auto exchangeServer =
+      UcxExchangeServer::create(communicator, epRef, key, isIntraNodeTransfer);
+
+  // Add this exchangeServer to the endpoint reference.
+  epRef->addCommElem(exchangeServer);
+
+  // Register exchangeServer with communicator.
+  communicator->registerCommElement(exchangeServer);
+  VLOG(2) << "[ACCEPTOR] new server: " << exchangeServer->toString()
+          << " peerIp=" << peerIp
+          << " isIntraNodeTransfer=" << isIntraNodeTransfer;
+
+  // Send HandshakeResponse back to the source to inform about intra-node
+  // transfer. This allows the source to bypass UCXX for all subsequent data
+  // transfers.
+  auto response = std::make_shared<HandshakeResponse>();
+  response->isIntraNodeTransfer = exchangeServer->isIntraNodeTransfer();
+
+  uint32_t keyHash = fnv1a_32(key.toString());
+  uint64_t responseTag = getHandshakeResponseTag(keyHash);
+
+  VLOG(3) << "Sending HandshakeResponse to " << key.toString()
+          << " isIntraNodeTransfer=" << response->isIntraNodeTransfer
+          << " tag=" << std::hex << responseTag;
+
+  // Fire-and-forget: we don't need to track this request completion
+  epRef->endpoint_->tagSend(
+      response.get(),
+      sizeof(*response),
+      ucxx::Tag{responseTag},
+      false,
+      [response, keyStr = key.toString()](
+          ucs_status_t status, std::shared_ptr<void> arg) {
+        if (status == UCS_OK) {
+          VLOG(3) << "HandshakeResponse sent successfully to " << keyStr;
+        } else {
+          VLOG(0) << "Failed to send HandshakeResponse to " << keyStr << ": "
+                  << ucs_status_string(status);
+        }
+      },
+      response);
+}
+
+// Add endpoint reference to ucp_cp -> epRef map.
+void Acceptor::registerEndpointRef(std::shared_ptr<EndpointRef> endpointRef) {
+  auto epHandle = endpointRef->endpoint_->getHandle();
+  auto res = handleToEndpointRef_.insert(std::pair{epHandle, endpointRef});
+  VELOX_CHECK(res.second, "Endpoint handle already exists!");
+}
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/Acceptor.h b/velox/experimental/ucx-exchange/Acceptor.h
new file mode 100644
index 00000000000..063532b836c
--- /dev/null
+++ b/velox/experimental/ucx-exchange/Acceptor.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <ucxx/api.h>
+#include <map>
+#include "velox/experimental/ucx-exchange/EndpointRef.h"
+
+namespace facebook::velox::ucx_exchange {
+
+/// @brief The acceptor creates a new UcxExchangeServer each time a handshake
+/// message is received. Handshakes are sent as active messages, using a
+/// worker-wide handler. The acceptor is a passive component that is used by the
+/// Communicator.
+struct Acceptor {
+  // The static callback function for incoming handshake requests.
+  static void cStyleAMCallback(
+      std::shared_ptr<ucxx::Request> request,
+      ucp_ep_h ep);
+
+  /// @brief Adds the endpoint reference to the handleToEndpointRef_ map such
+  /// that endpoint handles can be resolved
+  void registerEndpointRef(std::shared_ptr<EndpointRef> endpointRef);
+
+  // Maps the lower-layer UCP endpoint handle to an endpoint reference.
+  // Accessed only from the Communicator main loop thread: writes happen in
+  // registerEndpointRef() (called from listenerCallback during
+  // worker_->progress()), and reads happen in cStyleAMCallback (also fired
+  // during worker_->progress()). No mutex needed.
+  std::map<ucp_ep_h, std::shared_ptr<EndpointRef>> handleToEndpointRef_;
+};
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/CMakeLists.txt b/velox/experimental/ucx-exchange/CMakeLists.txt
new file mode 100644
index 00000000000..09fabb72d48
--- /dev/null
+++ b/velox/experimental/ucx-exchange/CMakeLists.txt
@@ -0,0 +1,59 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+set(
+  UCX_EXCHANGE_SOURCES
+  UcxPartitionedOutput.cpp
+  UcxOutputQueueManager.cpp
+  UcxQueues.cpp
+  UcxExchange.cpp
+  UcxExchangeProtocol.cpp
+  UcxExchangeSource.cpp
+  UcxExchangeServer.cpp
+  UcxExchangeQueue.cpp
+  UcxExchangeClient.cpp
+  Communicator.cpp
+  Acceptor.cpp
+  EndpointRef.cpp
+  NetUtil.cpp
+  IntraNodeTransferRegistry.cpp
+)
+
+# Generate a header containing the module basenames (without .cpp extension)
+# for use by Communicator to set per-file VLOG levels.
+set(UCX_EXCHANGE_MODULE_LIST "")
+foreach(src ${UCX_EXCHANGE_SOURCES})
+  string(REGEX REPLACE "\\.cpp$" "" module "${src}")
+  string(APPEND UCX_EXCHANGE_MODULE_LIST "\"${module}\",\n    ")
+endforeach()
+configure_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/UcxExchangeModules.h.in
+  ${CMAKE_CURRENT_BINARY_DIR}/UcxExchangeModules.h
+  @ONLY
+)
+
+add_library(velox_ucx_exchange OBJECT ${UCX_EXCHANGE_SOURCES})
+
+target_include_directories(velox_ucx_exchange PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+
+find_package(ucx REQUIRED)
+
+target_link_libraries(
+  velox_ucx_exchange
+  PUBLIC ucxx::ucxx ucx::ucp
+  PRIVATE cudf::cudf CUDA::cudart CUDA::cuda_driver Folly::folly velox_core ucx::ucs
+)
+
+if(VELOX_BUILD_TESTING)
+  add_subdirectory(tests)
+endif()
diff --git a/velox/experimental/ucx-exchange/CommElement.h b/velox/experimental/ucx-exchange/CommElement.h
new file mode 100644
index 00000000000..eb16a292f0d
--- /dev/null
+++ b/velox/experimental/ucx-exchange/CommElement.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <stdexcept>
+
+// The CommElement is the abstract base class of both the
+// per-client context on the exchange server side as well as the
+// exchange source side.
+namespace facebook::velox::ucx_exchange {
+
+class Communicator;
+class EndpointRef;
+
+class CommElement {
+ public:
+  CommElement(
+      const std::shared_ptr<Communicator> communicator,
+      std::shared_ptr<EndpointRef> endpointRef)
+      : communicator_{communicator}, endpointRef_{endpointRef} {}
+
+  CommElement(const std::shared_ptr<Communicator> communicator)
+      : communicator_{communicator}, endpointRef_{nullptr} {}
+
+  virtual ~CommElement() = default;
+
+  /// @brief Advance the communication by executing the communication elements
+  /// specific communication pattern.
+  virtual void process() = 0;
+
+  // Called when the underlying endpoint was closed
+  // or the communicator is finished.
+  virtual void close() = 0;
+
+ protected:
+  const std::shared_ptr<Communicator> communicator_;
+  std::shared_ptr<EndpointRef> endpointRef_;
+};
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/Communicator.cpp b/velox/experimental/ucx-exchange/Communicator.cpp
new file mode 100644
index 00000000000..7bc42993526
--- /dev/null
+++ b/velox/experimental/ucx-exchange/Communicator.cpp
@@ -0,0 +1,435 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/ucx-exchange/Communicator.h"
+#include <cuda_runtime.h>
+#include <ucxx/api.h>
+#include <ucxx/utils/ucx.h>
+#include <algorithm>
+#include <iostream>
+#include "velox/common/base/Exceptions.h"
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/ucx-exchange/CommElement.h"
+#include "velox/experimental/ucx-exchange/EndpointRef.h"
+#include "velox/experimental/ucx-exchange/UcxExchangeModules.h"
+#include "velox/experimental/ucx-exchange/UcxExchangeServer.h"
+#include "velox/experimental/ucx-exchange/UcxExchangeSource.h"
+
+#include <glog/logging.h>
+
+using namespace facebook::velox::cudf_velox;
+
+namespace facebook::velox::ucx_exchange {
+
+// static
+std::once_flag Communicator::onceFlag;
+std::shared_ptr<Communicator> Communicator::instancePtr_ = nullptr;
+
+/* static */
+std::shared_ptr<Communicator> Communicator::initAndGet(
+    uint16_t port,
+    std::string_view coordinatorURL,
+    ContinueFuture* future) {
+  if (!FLAGS_velox_ucx_exchange) {
+    return nullptr;
+  }
+  std::call_once(onceFlag, [&] {
+    instancePtr_ = std::shared_ptr<Communicator>(new Communicator());
+    instancePtr_->port_ = port;
+    instancePtr_->coordinatorURL_ = coordinatorURL;
+    // Generate a random unique worker ID for same-process detection.
+    // std::random_device reads from /dev/urandom on Linux (non-blocking).
+    // A 64-bit random value has negligible collision probability.
+    std::random_device rd;
+    std::mt19937_64 gen(rd());
+    std::uniform_int_distribution<uint64_t> dist;
+    instancePtr_->workerId_ = dist(gen);
+    LOG(INFO) << "Communicator workerId=" << instancePtr_->workerId_;
+    auto logLevel = CudfConfig::getInstance().exchangeLogLevel;
+    LOG(INFO) << "ucx-exchange VLOG level set to " << logLevel;
+    if (logLevel > 0) {
+      // Set VLOG level for all ucx-exchange source files.
+      // kUcxExchangeModules is auto-generated by CMake from the source list.
+      for (const char* module : kUcxExchangeModules) {
+        google::SetVLOGLevel(module, logLevel);
+      }
+    }
+    if (future) {
+      *future = instancePtr_->promise_.getSemiFuture();
+    }
+  });
+  VELOX_CHECK_EQ(
+      instancePtr_->port_,
+      port,
+      "Cannot initialize communicator again with different port");
+  return instancePtr_;
+}
+
+/* static */
+std::shared_ptr<Communicator> Communicator::getInstance() {
+  VELOX_CHECK_NOT_NULL(
+      instancePtr_, "Communicator not initialized. Call init(port) first.");
+  return instancePtr_;
+}
+
+/* static */ void Communicator::cStyleListenerCallback(
+    ucp_conn_request_h conn_request,
+    void* arg) {
+  // cast the argument back to our instance variable:
+  Communicator* instance = static_cast<Communicator*>(arg);
+  instance->listenerCallback(conn_request);
+}
+
+Communicator::~Communicator() {
+  listener_.reset();
+  // Note: worker_->flush() was removed - it only applies to RMA (Remote Memory
+  // Access) operations like ucp_put/ucp_get, which this code doesn't use.
+  // This code only uses tag send/recv and active messages.
+  worker_->progressWorkerEvent(100);
+  worker_.reset();
+  context_.reset();
+  VLOG(3) << "Communicator destructed";
+}
+
+/// @brief Run doesn't return until stop() is called.
+/// All operations of the communicator will be carried out in the thread
+/// that calls run.
+void Communicator::run() {
+  VLOG(3) << "Using error handling mode: "
+          << CudfConfig::getInstance().ucxxErrorHandling << std::endl;
+  VLOG(3) << "Using blocking progress mode: "
+          << CudfConfig::getInstance().ucxxBlockingPolling << std::endl;
+
+  running_.store(true);
+  // Force CUDA context creation.
+  auto cudaStatus = cudaFree(0);
+  VELOX_CHECK(
+      cudaStatus == cudaSuccess,
+      "Failed to initialize CUDA context: {}",
+      cudaGetErrorString(cudaStatus));
+
+  // create the UCXX context, worker, listener-context etc.
+  if (CudfConfig::getInstance().ucxxBlockingPolling) {
+    context_ = ucxx::createContext({}, ucxx::Context::defaultFeatureFlags);
+  } else {
+    context_ = ucxx::createContext({}, UCP_FEATURE_TAG | UCP_FEATURE_AM);
+  }
+
+  worker_ = context_->createWorker();
+
+  if (CudfConfig::getInstance().ucxxBlockingPolling) {
+    // Communicator is using blocking progress mode.
+    worker_->initBlockingProgressMode();
+  }
+
+  listener_ = worker_->createListener(
+      port_, Communicator::cStyleListenerCallback, this);
+
+  // Setup the active message callback that handles the
+  // initial handshake and creates the senders.
+  ucxx::AmReceiverCallbackInfo info(kAmCallbackOwner, kAmCallbackId);
+  worker_->registerAmReceiverCallback(info, &Acceptor::cStyleAMCallback);
+
+  promise_.setValue();
+
+  VLOG(3) << "Communicator running.";
+  const bool blockingMode = CudfConfig::getInstance().ucxxBlockingPolling;
+  while (running_) {
+    try {
+      // Periodic heartbeat for diagnostic logging.
+      auto now = std::chrono::steady_clock::now();
+      if (now - lastHeartbeat_ >= std::chrono::seconds(5)) {
+        std::lock_guard<std::mutex> lock(elemMutex_);
+
+        // GPU memory usage via CUDA runtime.
+        size_t gpuFree = 0, gpuTotal = 0;
+        auto memStatus = cudaMemGetInfo(&gpuFree, &gpuTotal);
+        if (memStatus != cudaSuccess) {
+          LOG(WARNING) << "cudaMemGetInfo failed: "
+                       << cudaGetErrorString(memStatus);
+        }
+        size_t gpuUsedMB = (gpuTotal - gpuFree) / (1024 * 1024);
+        size_t gpuFreeMB = gpuFree / (1024 * 1024);
+        size_t gpuTotalMB = gpuTotal / (1024 * 1024);
+
+        // Count ExSrv vs ExSrc elements.
+        int numServers = 0, numSources = 0;
+        for (const auto& elem : elements_) {
+          if (dynamic_cast<UcxExchangeServer*>(elem.get())) {
+            ++numServers;
+          } else if (dynamic_cast<UcxExchangeSource*>(elem.get())) {
+            ++numSources;
+          }
+        }
+
+        size_t numEndpoints;
+        {
+          std::lock_guard<std::recursive_mutex> lock(endpointsMutex_);
+          numEndpoints = endpoints_.size();
+        }
+        VLOG(2) << "[COMM-HEARTBEAT] workQueue=" << workQueue_.size()
+                << " elements=" << elements_.size()
+                << " (servers=" << numServers << " sources=" << numSources
+                << ")"
+                << " endpoints=" << numEndpoints
+                << " deferredCleanup=" << deferredEndpointCleanup_.size()
+                << " deferredRequests=" << deferredRequests_.size()
+                << " workItemsProcessed=" << workItemsProcessed_
+                << " GPU=" << gpuUsedMB << "/" << gpuTotalMB << "MB"
+                << " (free=" << gpuFreeMB << "MB)";
+        workItemsProcessed_ = 0;
+        lastHeartbeat_ = now;
+      }
+
+      // Process deferred endpoint cleanups from callbacks.
+      // UCX callbacks cannot call closeBlocking() (which progresses the
+      // worker) or iterate communicators_, so they defer cleanup to
+      // this main loop via deferEndpointCleanup().
+      while (auto ep = deferredEndpointCleanup_.pop()) {
+        VLOG(3) << "Processing deferred endpoint cleanup";
+        // First, close all communicators associated with this endpoint.
+        // This must happen before removeEndpointRef() which may destroy
+        // the endpoint.
+        ep->closeAndDrainCommunicators();
+        removeEndpointRef(ep);
+      }
+
+      // Process the work queue. Make sure that communication is progressed
+      // after each call to a comms element, otherwise we will deadlock.
+      while (auto comms = workQueue_.pop()) {
+        comms->process();
+        ++workItemsProcessed_;
+        // Progress after each work item to allow UCXX to advance
+        // its internal state (complete sends/receives, fire callbacks).
+        // Use non-blocking progress here to avoid blocking between
+        // work items -- we want to drain the queue promptly.
+        worker_->progress();
+      }
+
+      // Clean up deferred requests that UCX has fully processed.
+      // These are cancelled requests whose GPU buffers needed to stay
+      // alive until UCX finished any in-flight operations on them.
+      if (!deferredRequests_.empty()) {
+        deferredRequests_.erase(
+            std::remove_if(
+                deferredRequests_.begin(),
+                deferredRequests_.end(),
+                [](const auto& req) { return req->isCompleted(); }),
+            deferredRequests_.end());
+      }
+
+      // All queues are drained. Now wait for UCXX network events.
+      // In blocking mode, this will block until a UCXX event arrives
+      // or worker_->signal() is called (from addToWorkQueue,
+      // deferEndpointCleanup, or stop).
+      if (blockingMode) {
+        worker_->progressWorkerEvent(0);
+      } else {
+        worker_->progress();
+      }
+    } catch (ucxx::IOError& e) {
+      LOG(ERROR) << "In Communicator main loop UCXX Exception: " << e.what();
+      throw;
+    }
+  }
+  VLOG(3) << "Communicator stopping.";
+}
+
+/// @brief Stops the communicator, called from an outside thread.
+void Communicator::stop() {
+  running_.store(false);
+  signalWorker();
+  // Only log fields that are safe to read from an outside thread.
+  // endpoints_ is only accessed from the Communicator thread, so reading
+  // it here would be a data race.
+  VLOG(3) << "In Communicator::stop "
+          << " elements_.size(): " << elements_.size()
+          << " workQueue_.size(): " << workQueue_.size();
+}
+
+void Communicator::registerCommElement(std::shared_ptr<CommElement> comms) {
+  std::lock_guard<std::mutex> lock(elemMutex_);
+  auto ret = elements_.insert(comms);
+  VELOX_CHECK(ret.second, "CommElement already registered!");
+  // Also put the comms element into the work queue.
+  workQueue_.push(comms);
+  signalWorker();
+}
+
+void Communicator::signalWorker() {
+  if (worker_ && CudfConfig::getInstance().ucxxBlockingPolling) {
+    worker_->signal();
+  }
+}
+
+void Communicator::addToWorkQueue(std::shared_ptr<CommElement> comms) {
+  if (!comms) {
+    return;
+  }
+  workQueue_.push(comms);
+  signalWorker();
+}
+
+void Communicator::unregister(std::shared_ptr<CommElement> comms) {
+  std::lock_guard<std::mutex> lock(elemMutex_);
+  if (!comms) {
+    return;
+  }
+  workQueue_.erase(comms);
+  elements_.erase(comms);
+}
+
+std::shared_ptr<EndpointRef> Communicator::assocEndpointRef(
+    std::shared_ptr<CommElement> comms,
+    HostPort hostPort) {
+  std::lock_guard<std::recursive_mutex> lock(endpointsMutex_);
+  auto it = endpoints_.find(hostPort);
+  if (it != endpoints_.end()) {
+    std::shared_ptr<EndpointRef> ep = it->second;
+    ep->addCommElem(comms);
+    return ep;
+  }
+  // endpoint doesn't exist. Need to connect. Enable error handling.
+  auto ep = worker_->createEndpointFromHostname(
+      hostPort.hostname,
+      hostPort.port,
+      CudfConfig::getInstance().ucxxErrorHandling);
+  std::shared_ptr<EndpointRef> epRef = nullptr;
+  if (ep != nullptr) {
+    epRef = std::make_shared<EndpointRef>(ep);
+    epRef->addCommElem(comms);
+    if (CudfConfig::getInstance().ucxxErrorHandling) {
+      ep->setCloseCallback(EndpointRef::onClose, epRef);
+    }
+    endpoints_.insert(std::pair{hostPort, epRef});
+  }
+  return epRef;
+}
+
+void Communicator::removeEndpointRef(std::shared_ptr<EndpointRef> ep) {
+  std::lock_guard<std::recursive_mutex> lock(endpointsMutex_);
+  VLOG(3) << "In Communicator::removeEndpointRef for Communicator with port = "
+          << Communicator::getInstance()->port_;
+
+  // Close the endpoint if it's still alive.
+  // NOTE: This calls closeBlocking() which progresses the worker internally,
+  // which can fire listenerCallback() re-entrantly — hence the recursive mutex.
+  // This method must NOT be called from within a UCX callback.
+  // Use deferEndpointCleanup() from callbacks instead.
+  if (ep->endpoint_ && ep->endpoint_->isAlive()) {
+    VLOG(3) << "In Communicator::removeEndpointRef call closeBlocking";
+    ep->endpoint_->closeBlocking();
+  }
+  for (auto it = endpoints_.begin(); it != endpoints_.end();) {
+    if (it->second == ep) {
+      it = endpoints_.erase(it);
+    } else {
+      ++it;
+    }
+  }
+  VLOG(3) << "- Communicator::removeEndpointRef";
+}
+
+void Communicator::deferEndpointCleanup(std::shared_ptr<EndpointRef> ep) {
+  // This method is safe to call from UCX callbacks because it doesn't
+  // call any blocking/progress functions. The actual cleanup happens
+  // in the main run() loop.
+  VLOG(3) << "Deferring endpoint cleanup to main loop";
+  deferredEndpointCleanup_.push(ep);
+  signalWorker();
+}
+
+void Communicator::deferRequestCleanup(std::shared_ptr<ucxx::Request> request) {
+  if (request) {
+    deferredRequests_.push_back(std::move(request));
+  }
+}
+
+std::shared_ptr<EndpointRef> Communicator::findEndpointRefByHandle(
+    ucp_ep_h handle) {
+  auto it = acceptor_.handleToEndpointRef_.find(handle);
+  if (it != acceptor_.handleToEndpointRef_.end()) {
+    return it->second;
+  }
+  return nullptr;
+}
+
+const std::string& Communicator::getCoordinatorUrl() {
+  return coordinatorURL_;
+}
+
+std::string Communicator::getListenerIp() const {
+  if (listener_) {
+    return listener_->getIp();
+  }
+  return "";
+}
+
+uint16_t Communicator::getListenerPort() const {
+  if (listener_) {
+    return listener_->getPort();
+  }
+  return port_;
+}
+
+/// @brief The callback method that is invoked when a client connects.
+void Communicator::listenerCallback(ucp_conn_request_h conn_request) {
+  char ip_str[INET6_ADDRSTRLEN];
+  char port_str[INET6_ADDRSTRLEN];
+  ucp_conn_request_attr_t attr{};
+
+  attr.field_mask = UCP_CONN_REQUEST_ATTR_FIELD_CLIENT_ADDR;
+  ucxx::utils::ucsErrorThrow(ucp_conn_request_query(conn_request, &attr));
+  ucxx::utils::sockaddr_get_ip_port_str(
+      &attr.client_address, ip_str, port_str, INET6_ADDRSTRLEN);
+  VLOG(3)
+      << "Communicator received a connection request from client at address "
+      << ip_str << ":" << port_str;
+
+  // incoming endpoints are not shared. Outgoing endpoints to the same node are
+  // shared. This guarantees that between any two nodes, there will be at most 2
+  // endpoints, one per direction. For compatibility reasons, both incoming and
+  // outgoing endpoints are represented using the EndpointRef.
+  auto endpoint = listener_->createEndpointFromConnRequest(
+      conn_request, CudfConfig::getInstance().ucxxErrorHandling);
+  // Pass the peer's actual IP to EndpointRef for reliable intra-node detection.
+  auto epRef = std::make_shared<EndpointRef>(endpoint, std::string(ip_str));
+  if (CudfConfig::getInstance().ucxxErrorHandling) {
+    endpoint->setCloseCallback(EndpointRef::onClose, epRef);
+  }
+  // Add this endpoint reference to the list of endpoints.
+  // NOTE: This runs inside a UCX listener callback (during worker progress),
+  // so we must not throw — throwing from a UCX callback is undefined behavior.
+  unsigned long val = std::strtoul(port_str, nullptr, 10);
+  if (val > static_cast<unsigned long>(std::numeric_limits<uint16_t>::max())) {
+    LOG(ERROR) << "listenerCallback: port out of range for uint16_t: " << val;
+    return;
+  }
+
+  uint16_t port = static_cast<uint16_t>(val);
+  HostPort hp(ip_str, port);
+  {
+    std::lock_guard<std::recursive_mutex> lock(endpointsMutex_);
+    auto res = endpoints_.insert(std::pair{hp, epRef});
+    if (!res.second) {
+      LOG(ERROR) << "listenerCallback: endpoint already exists for " << ip_str
+                 << ":" << port;
+      return;
+    }
+  }
+  acceptor_.registerEndpointRef(epRef);
+}
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/Communicator.h b/velox/experimental/ucx-exchange/Communicator.h
new file mode 100644
index 00000000000..671d3086b22
--- /dev/null
+++ b/velox/experimental/ucx-exchange/Communicator.h
@@ -0,0 +1,238 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <ucxx/api.h>
+#include <chrono>
+#include <cstdint>
+#include <random>
+#include <string>
+#include <string_view>
+#include "velox/common/future/VeloxPromise.h"
+#include "velox/experimental/ucx-exchange/Acceptor.h"
+#include "velox/experimental/ucx-exchange/CommElement.h"
+#include "velox/experimental/ucx-exchange/WorkQueue.h"
+
+#include <gflags/gflags.h>
+
+DECLARE_bool(velox_ucx_exchange);
+
+namespace facebook::velox::ucx_exchange {
+
+struct HostPort {
+  std::string hostname;
+  uint16_t port = 0;
+
+  // Default and parameterized constructors
+  HostPort() = default;
+  HostPort(std::string h, uint16_t p) : hostname(std::move(h)), port(p) {}
+
+  // Strict weak ordering for std::map
+  bool operator<(HostPort const& other) const noexcept {
+    if (hostname < other.hostname)
+      return true;
+    if (other.hostname < hostname)
+      return false;
+    return port < other.port;
+  }
+};
+
+class Communicator {
+ public:
+  const ucxx::AmReceiverCallbackOwnerType kAmCallbackOwner = "velox";
+  const ucxx::AmReceiverCallbackIdType kAmCallbackId = 123;
+
+  /// @brief Method to initialize the communicator and get a reference to it.
+  /// @param port The port to listen on.
+  /// @param coordinatorURL The URL of the coordinator
+  /// @param future An optional future that will be set when the communicator
+  /// is running and ready to accept connections.
+  [[nodiscard]] static std::shared_ptr<Communicator> initAndGet(
+      uint16_t port,
+      std::string_view coordinatorURL,
+      ContinueFuture* future = nullptr);
+
+  /// @brief Method to get the Communicator reference
+  static std::shared_ptr<Communicator> getInstance();
+
+  /// @brief Destructor.
+  ~Communicator();
+
+  /// @brief Starts the Communicator
+  void run();
+
+  /// @brief Stops the Communicator
+  void stop();
+
+  /// @brief Registers a communication element with the communicator.
+  /// This also automatically puts the element into the work queue.
+  /// @param comms The element to register.
+  void registerCommElement(std::shared_ptr<CommElement> comms);
+
+  /// @brief Adds an already registered communication element to the work queue
+  /// such that "process" will be called on it.
+  /// @param comms The element to be added to the work queue.
+  void addToWorkQueue(std::shared_ptr<CommElement> comms);
+
+  /// @brief Unregisters a communication element
+  /// @brief comms The communication element.
+  void unregister(std::shared_ptr<CommElement> comms);
+
+  /// @brief Associates a CommElement with an endpoint that connects to the
+  /// given host and port. If no endpoint exists, then a new connected endpoint
+  /// is created.
+  /// @param commElement The commElement that will be associated with the
+  /// endpoint reference on success.
+  /// @param hostPort Identifies and existing endpoint or is used to create a
+  /// new endpoint if none exists for this host and port.
+  /// @returns The endpoint reference or null if no connection was possible.
+  [[nodiscard]] std::shared_ptr<EndpointRef> assocEndpointRef(
+      std::shared_ptr<CommElement> commElement,
+      HostPort hostPort);
+
+  /// @brief Removes an endpoint from the communicator. This is required when
+  /// the endpoint has become stale since the other side has disappeared.
+  /// NOTE: This should NOT be called from within a UCX callback. Use
+  /// deferEndpointCleanup() instead.
+  void removeEndpointRef(std::shared_ptr<EndpointRef> ep);
+
+  /// @brief Defers endpoint cleanup to the main progress loop.
+  /// This MUST be used instead of removeEndpointRef when called from
+  /// within a UCX callback, because UCX callbacks cannot call progress
+  /// functions (which closeBlocking() does internally).
+  /// @param ep The endpoint to be cleaned up later.
+  void deferEndpointCleanup(std::shared_ptr<EndpointRef> ep);
+
+  /// @brief Defers cleanup of a cancelled UCXX request to the main loop.
+  /// The request (and the GPU buffers it references via its arg) will be
+  /// held alive until UCX has fully processed the cancellation.
+  /// Must only be called from the Communicator thread.
+  void deferRequestCleanup(std::shared_ptr<ucxx::Request> request);
+
+  /// Returns the URL of the coordinator.
+  [[nodiscard]] const std::string& getCoordinatorUrl();
+
+  /// @brief Get the listener's bound IP address.
+  /// Used for same-node detection in intra-node transfer optimization.
+  /// @returns The IP address string from the UCXX listener, or empty if not
+  /// initialized.
+  [[nodiscard]] std::string getListenerIp() const;
+
+  /// @brief Get the listener's bound port.
+  /// Used for same-node detection in intra-node transfer optimization.
+  /// @returns The port number from the UCXX listener.
+  [[nodiscard]] uint16_t getListenerPort() const;
+
+  /// @brief Get the unique worker ID for this Communicator instance.
+  /// Used for intra-process detection: if two endpoints share the same
+  /// workerId, they are in the same process and can use
+  /// IntraNodeTransferRegistry instead of UCXX.
+  uint64_t getWorkerId() const {
+    return workerId_;
+  }
+
+  /// Looks up the EndpointRef associated with a raw UCP endpoint handle.
+  /// Used by the Acceptor's active-message callback to resolve the endpoint
+  /// that received a handshake request.
+  /// @returns The EndpointRef or nullptr if no mapping exists for the handle.
+  [[nodiscard]] std::shared_ptr<EndpointRef> findEndpointRefByHandle(
+      ucp_ep_h handle);
+
+ private:
+  Communicator() =
+      default; // Private constructor to prevent direct instantiation
+  // delete some methods to make the Communicator a singleton.
+  Communicator(const Communicator&) = delete; // Prevent copying
+  Communicator& operator=(const Communicator&) = delete; // Prevent assignment
+
+  // Invoked when a client connects to the listener.
+  void listenerCallback(ucp_conn_request_h conn_request);
+
+  // Wrapper to map the C-style callback to the listener method.
+  static void cStyleListenerCallback(
+      ucp_conn_request_h conn_request,
+      void* arg);
+
+  static std::once_flag onceFlag; // Flag for thread-safe initialization
+  static std::shared_ptr<Communicator> instancePtr_;
+
+  std::shared_ptr<ucxx::Context> context_;
+  std::shared_ptr<ucxx::Worker> worker_;
+  std::shared_ptr<ucxx::Listener> listener_;
+  uint16_t port_;
+  std::string coordinatorURL_;
+  std::atomic<bool> running_;
+  Acceptor acceptor_;
+  ContinuePromise promise_{"Communicator::run"};
+
+  // the set of elements known to the communicator.
+  // The elements_ set makes sure that there exists a shared_ptr to
+  // the senders and receivers as long as they are active and not unregistered.
+
+  // Comparator that compares the stored raw pointers
+  struct PtrAddressLess {
+    bool operator()(
+        std::shared_ptr<CommElement> const& a,
+        std::shared_ptr<CommElement> const& b) const noexcept {
+      return a.get() < b.get();
+    }
+  };
+  // Comparison function is the raw pointer, not the shared pointer.
+  std::set<std::shared_ptr<CommElement>, PtrAddressLess> elements_;
+  // protect elements_ by a mutex. Needs to be mutable if called from a const
+  // function.
+  std::mutex elemMutex_;
+
+  // The work queue for communication elements that need to do things on
+  // the communicator thread.
+  WorkQueue<CommElement> workQueue_;
+
+  // Protects endpoints_. Must be recursive because removeEndpointRef() holds
+  // the lock and calls closeBlocking(), which progresses the worker and can
+  // fire listenerCallback() re-entrantly — that callback also locks this mutex.
+  std::recursive_mutex endpointsMutex_;
+
+  // Shared endpoints keyed by remote host:port.
+  std::map<HostPort, std::shared_ptr<EndpointRef>> endpoints_;
+
+  // Signals the UCXX worker to wake up from a blocking
+  // progressWorkerEvent() call. Thread-safe. No-op if worker_ is null
+  // or if not in blocking progress mode.
+  void signalWorker();
+
+  // A random unique identifier for this Communicator instance (process).
+  // Generated once at initialization. Used by the Acceptor to determine
+  // if a connecting source is in the same process (intra-node transfer).
+  uint64_t workerId_{0};
+
+  // Queue of endpoints that need cleanup, populated by callbacks.
+  // UCX callbacks cannot call progress functions (like closeBlocking),
+  // so they defer cleanup to the main loop via this queue.
+  WorkQueue<EndpointRef> deferredEndpointCleanup_;
+
+  // Cancelled UCXX requests whose GPU buffers may still be referenced by
+  // UCX internals. Held alive here until isCompleted() returns true,
+  // ensuring the GPU buffers (owned via the request's arg shared_ptr)
+  // are not freed prematurely.
+  std::vector<std::shared_ptr<ucxx::Request>> deferredRequests_;
+
+  // Heartbeat state for diagnostic logging.
+  std::chrono::steady_clock::time_point lastHeartbeat_{
+      std::chrono::steady_clock::now()};
+  uint64_t workItemsProcessed_{0};
+};
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/EndpointRef.cpp b/velox/experimental/ucx-exchange/EndpointRef.cpp
new file mode 100644
index 00000000000..447d449e86a
--- /dev/null
+++ b/velox/experimental/ucx-exchange/EndpointRef.cpp
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/ucx-exchange/EndpointRef.h"
+#include "velox/experimental/ucx-exchange/Communicator.h"
+
+namespace facebook::velox::ucx_exchange {
+
+/* static */
+void EndpointRef::onClose(ucs_status_t status, std::shared_ptr<void> arg) {
+  // NOTE: This callback is called from within the UCX progress thread.
+  // We must NOT call any blocking operations, progress functions, or
+  // iterate communicators_ here. All work is deferred to the main
+  // Communicator loop via deferEndpointCleanup().
+
+  std::shared_ptr<EndpointRef> ep = std::static_pointer_cast<EndpointRef>(arg);
+
+  // Defer ALL cleanup to the main progress loop.
+  // The main loop will:
+  //   1. Close all communicators registered with this endpoint
+  //   2. Clean up the endpoint itself (closeBlocking, etc.)
+  auto c = Communicator::getInstance();
+  c->deferEndpointCleanup(ep);
+}
+
+bool EndpointRef::addCommElem(std::shared_ptr<CommElement> commElem) {
+  if (!commElem) {
+    return false; // nothing to do, no commElem.
+  }
+  std::lock_guard<std::mutex> lock(commMutex_);
+  cleanup();
+  auto ret = communicators_.insert(commElem);
+  return ret.second;
+}
+
+void EndpointRef::removeCommElem(std::shared_ptr<CommElement> commElem) {
+  if (!commElem) {
+    return;
+  }
+  std::lock_guard<std::mutex> lock(commMutex_);
+  communicators_.erase(commElem);
+}
+
+void EndpointRef::closeAndDrainCommunicators() {
+  // Swap communicators_ to a local copy under the lock, then iterate
+  // the local copy without holding the lock. This prevents:
+  // - Data races with concurrent addCommElem/removeCommElem
+  // - Re-entrancy: close() may eventually trigger removeCommElem on
+  //   this same EndpointRef, but communicators_ is already empty
+  //   so removeCommElem will be a no-op.
+  std::set<
+      std::weak_ptr<CommElement>,
+      std::owner_less<std::weak_ptr<CommElement>>>
+      localCopy;
+  {
+    std::lock_guard<std::mutex> lock(commMutex_);
+    localCopy.swap(communicators_);
+  }
+
+  // Now iterate the local copy -- no lock held, no contention.
+  for (auto& weakElem : localCopy) {
+    if (std::shared_ptr<CommElement> spt = weakElem.lock()) {
+      spt->close();
+    }
+  }
+  // localCopy is destroyed here, releasing all weak_ptrs.
+}
+
+bool EndpointRef::operator<(EndpointRef const& other) {
+  if (endpoint_ == other.endpoint_) {
+    return false; // covers the case where both are nullptr
+  }
+  if (endpoint_ == nullptr) {
+    return true; // nullptr comes before anything else.
+  }
+  if (other.endpoint_ == nullptr) {
+    return false;
+  }
+  return endpoint_->getHandle() < other.endpoint_->getHandle();
+}
+
+void EndpointRef::cleanup() {
+  for (auto it = communicators_.begin(); it != communicators_.end();) {
+    if (it->expired()) {
+      it = communicators_.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/EndpointRef.h b/velox/experimental/ucx-exchange/EndpointRef.h
new file mode 100644
index 00000000000..55726396b13
--- /dev/null
+++ b/velox/experimental/ucx-exchange/EndpointRef.h
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <ucxx/api.h>
+#include <memory>
+#include <mutex>
+#include <set>
+
+#include "velox/experimental/ucx-exchange/CommElement.h"
+
+namespace facebook::velox::ucx_exchange {
+
+/// @brief The endpoint reference keeps track of the communication elements that
+/// use a given UCXX endpoint. When this endpoint is closed, the elements
+/// (UcxExchangeSources and UcxExchangeServers) are notified. When an element
+/// is done, it notifies the endpoint. Access to the communicators_ set is
+/// protected by commMutex_. The onClose callback defers all work to the
+/// Communicator main loop thread via deferEndpointCleanup().
+class EndpointRef : public std::enable_shared_from_this<EndpointRef> {
+ public:
+  EndpointRef(
+      const std::shared_ptr<ucxx::Endpoint> endpoint,
+      std::string peerIp = "")
+      : endpoint_{endpoint}, peerIp_{std::move(peerIp)}, communicators_{} {}
+
+  /// @brief Static method that is called when the underlying UCXX system closes
+  /// the endpoint. In this case, all communication elements are informed that
+  /// the endpoint has been closed.
+  /// @param status The status (reason) why the endpoint has been closed.
+  /// @param arg A reference to the EndpointRef (since this is a static method)
+  static void onClose(ucs_status_t status, std::shared_ptr<void> arg);
+
+  /// @brief Adds a new CommElement that is using this endpoint.
+  /// @param commElem A shared pointer to the UcxExchangeSource or
+  /// UcxExchangeServer.
+  /// @return True, if commElem could be added.
+  bool addCommElem(std::shared_ptr<CommElement> commElem);
+
+  /// @brief Removes a CommElement from this endpoint again.
+  /// @param commElem A shared pointer to the UcxExchangeSource or
+  /// UcxExchangeServer.
+  void removeCommElem(std::shared_ptr<CommElement> commElem);
+
+  /// @brief Closes all registered communicators and drains the set.
+  /// Uses swap-and-drain pattern: swaps communicators_ into a local copy
+  /// under the lock, then iterates the copy without the lock.
+  /// Must be called from the Communicator main loop thread ONLY.
+  void closeAndDrainCommunicators();
+
+  /// implement < operator such that this endpoint can be used in a
+  /// std::map
+  bool operator<(EndpointRef const& other);
+
+  /// @brief Get the peer's IP address as seen from the connection.
+  /// Used for reliable intra-node detection.
+  const std::string& getPeerIp() const {
+    return peerIp_;
+  }
+
+  const std::shared_ptr<ucxx::Endpoint> endpoint_;
+
+ private:
+  /// The peer's actual IP address extracted from the connection request.
+  /// Used for server-side intra-node detection instead of client-reported IPs.
+  std::string peerIp_;
+  void cleanup(); // cleans up expired communication elements.
+
+  std::set<
+      std::weak_ptr<CommElement>,
+      std::owner_less<std::weak_ptr<CommElement>>>
+      communicators_;
+  std::mutex commMutex_; // Protects communicators_
+};
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/IntraNodeTransferRegistry.cpp b/velox/experimental/ucx-exchange/IntraNodeTransferRegistry.cpp
new file mode 100644
index 00000000000..a45a0d6a958
--- /dev/null
+++ b/velox/experimental/ucx-exchange/IntraNodeTransferRegistry.cpp
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/ucx-exchange/IntraNodeTransferRegistry.h"
+#include <glog/logging.h>
+
+namespace facebook::velox::ucx_exchange {
+
+/* static */
+std::shared_ptr<IntraNodeTransferRegistry>
+IntraNodeTransferRegistry::getInstance() {
+  // In C++11, the static local variable is guaranteed to only be initialized
+  // once even in a multi-threaded context.
+  static std::shared_ptr<IntraNodeTransferRegistry> instance =
+      std::shared_ptr<IntraNodeTransferRegistry>(
+          new IntraNodeTransferRegistry());
+  return instance;
+}
+
+std::future<void> IntraNodeTransferRegistry::publish(
+    const IntraNodeTransferKey& key,
+    std::shared_ptr<cudf::packed_columns> data,
+    bool atEnd) {
+  std::shared_ptr<IntraNodeTransferEntry> entry;
+  std::future<void> future;
+  bool entryExisted;
+  size_t registrySize;
+
+  bool cancelled = false;
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    // If the task was already cancelled (removeTask was called), don't create
+    // a registry entry. Return an already-fulfilled future so the server
+    // doesn't block waiting for a source that will never come.
+    if (cancelledTasks_.count(key.taskId)) {
+      cancelled = true;
+    } else {
+      // Check if entry already exists (source may have started waiting)
+      auto it = registry_.find(key);
+      entryExisted = (it != registry_.end());
+      if (entryExisted) {
+        entry = it->second;
+      } else {
+        entry = std::make_shared<IntraNodeTransferEntry>();
+        registry_[key] = entry;
+      }
+      registrySize = registry_.size();
+    }
+  }
+
+  if (cancelled) {
+    VLOG(2) << "[INTRA-REG] publish skipped (task cancelled): task="
+            << key.taskId << " dest=" << key.destination
+            << " seq=" << key.sequenceNumber;
+    std::promise<void> p;
+    p.set_value();
+    return p.get_future();
+  }
+
+  // Update the entry with data (under entry's own mutex)
+  {
+    std::lock_guard<std::mutex> entryLock(entry->entryMutex);
+    entry->data = std::move(data);
+    entry->atEnd = atEnd;
+    entry->ready = true;
+    // Get the future while holding the lock to avoid race with consumer
+    future = entry->retrievedPromise.get_future();
+  }
+
+  VLOG(2) << "[INTRA-REG] publish: task=" << key.taskId
+          << " dest=" << key.destination << " seq=" << key.sequenceNumber
+          << " atEnd=" << atEnd << " entryExisted=" << entryExisted
+          << " registrySize=" << registrySize;
+
+  return future;
+}
+
+std::optional<IntraNodeTransferResult> IntraNodeTransferRegistry::poll(
+    const IntraNodeTransferKey& key) {
+  std::shared_ptr<IntraNodeTransferEntry> entry;
+
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    // Check if this task has been cancelled (producer removed).
+    if (cancelledTasks_.count(key.taskId)) {
+      VLOG(2) << "[INTRA-REG] poll cancelled: task=" << key.taskId
+              << " dest=" << key.destination << " seq=" << key.sequenceNumber;
+      return IntraNodeTransferResult{nullptr, true};
+    }
+
+    auto it = registry_.find(key);
+    if (it == registry_.end()) {
+      // No entry yet - server hasn't published
+      VLOG(3) << "[INTRA-REG] poll miss (no entry): task=" << key.taskId
+              << " dest=" << key.destination << " seq=" << key.sequenceNumber
+              << " registrySize=" << registry_.size();
+      return std::nullopt;
+    }
+    entry = it->second;
+  }
+
+  // FIX: Hold the entry lock for the entire retrieval operation to prevent
+  // race conditions. Previously, the lock was released before accessing
+  // entry->data, entry->atEnd, and entry->retrievedPromise.
+  IntraNodeTransferResult result;
+  {
+    std::lock_guard<std::mutex> entryLock(entry->entryMutex);
+    if (!entry->ready) {
+      // Entry exists but data not ready yet
+      VLOG(3) << "[INTRA-REG] poll miss (not ready): task=" << key.taskId
+              << " dest=" << key.destination << " seq=" << key.sequenceNumber;
+      return std::nullopt;
+    }
+
+    // Data is ready, retrieve it while holding the lock
+    result.data = std::move(entry->data);
+    result.atEnd = entry->atEnd;
+
+    // Fulfill the promise to notify the server while still holding entry lock
+    entry->retrievedPromise.set_value();
+  }
+
+  // Remove entry from registry (after releasing entry lock but before
+  // returning)
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    registry_.erase(key);
+  }
+
+  VLOG(2) << "[INTRA-REG] poll hit: task=" << key.taskId
+          << " dest=" << key.destination << " seq=" << key.sequenceNumber
+          << " atEnd=" << result.atEnd;
+
+  return result;
+}
+
+void IntraNodeTransferRegistry::cancelTask(std::string_view taskId) {
+  std::vector<std::shared_ptr<IntraNodeTransferEntry>> entriesToFulfill;
+
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    cancelledTasks_.insert(std::string{taskId});
+
+    // Clean up any existing registry entries for this task so servers
+    // waiting on the retrieved-promise don't hang.
+    for (auto it = registry_.begin(); it != registry_.end();) {
+      if (it->first.taskId == taskId) {
+        entriesToFulfill.push_back(it->second);
+        it = registry_.erase(it);
+      } else {
+        ++it;
+      }
+    }
+  }
+
+  // Fulfill promises outside the lock to avoid potential deadlocks.
+  for (auto& entry : entriesToFulfill) {
+    std::lock_guard<std::mutex> entryLock(entry->entryMutex);
+    if (!entry->ready) {
+      entry->ready = true;
+      entry->atEnd = true;
+    }
+    try {
+      entry->retrievedPromise.set_value();
+    } catch (const std::future_error&) {
+      // Promise already satisfied — safe to ignore.
+    }
+  }
+
+  VLOG(2) << "[INTRA-REG] cancelTask: task=" << taskId
+          << " entriesCleaned=" << entriesToFulfill.size();
+}
+
+void IntraNodeTransferRegistry::clearCancelledTask(std::string_view taskId) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  cancelledTasks_.erase(std::string{taskId});
+}
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/IntraNodeTransferRegistry.h b/velox/experimental/ucx-exchange/IntraNodeTransferRegistry.h
new file mode 100644
index 00000000000..44ec9e74c16
--- /dev/null
+++ b/velox/experimental/ucx-exchange/IntraNodeTransferRegistry.h
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cudf/contiguous_split.hpp>
+#include <future>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <unordered_set>
+
+namespace facebook::velox::ucx_exchange {
+
+/// @brief Key for identifying intra-node transfer entries in the registry.
+/// Used when UcxExchangeServer and UcxExchangeSource are on the same node.
+struct IntraNodeTransferKey {
+  std::string taskId;
+  uint32_t destination;
+  uint32_t sequenceNumber;
+
+  bool operator<(const IntraNodeTransferKey& other) const {
+    if (taskId != other.taskId)
+      return taskId < other.taskId;
+    if (destination != other.destination)
+      return destination < other.destination;
+    return sequenceNumber < other.sequenceNumber;
+  }
+};
+
+/// @brief Result from intra-node transfer containing data and end marker.
+struct IntraNodeTransferResult {
+  std::shared_ptr<cudf::packed_columns> data;
+  bool atEnd{false}; // True if this is the end-of-stream marker
+};
+
+/// @brief Entry in the intra-node transfer registry containing the data and
+/// synchronization primitives. The server publishes data via publish() and
+/// waits on retrievedPromise; the source polls via poll() and fulfils the
+/// promise on retrieval.
+struct IntraNodeTransferEntry {
+  std::shared_ptr<cudf::packed_columns> data;
+  bool atEnd{false}; // True if this is the end-of-stream marker
+  std::promise<void> retrievedPromise; // Server waits on this after publishing
+  std::mutex entryMutex;
+  bool ready{false}; // True when data is ready to retrieve
+};
+
+/// @brief Singleton registry for intra-node data transfers.
+///
+/// When UcxExchangeServer and UcxExchangeSource are on the same node
+/// (same Communicator instance), this registry enables direct data sharing
+/// without going through UCXX network transfers.
+///
+/// The server publishes packed_columns data to the registry, and the source
+/// polls for it. Synchronization is handled via futures/promises.
+class IntraNodeTransferRegistry {
+ public:
+  /// @brief Get the singleton instance of the registry.
+  static std::shared_ptr<IntraNodeTransferRegistry> getInstance();
+
+  // Prevent copying
+  IntraNodeTransferRegistry(const IntraNodeTransferRegistry&) = delete;
+  IntraNodeTransferRegistry& operator=(const IntraNodeTransferRegistry&) =
+      delete;
+
+  /// @brief Publish data for intra-node transfer with condition variable
+  /// signaling. Server calls this to make data available to the source.
+  /// The producer must synchronize its CUDA stream before calling publish()
+  /// so that the GPU data is ready when the consumer reads it.
+  /// @param key The unique key identifying this transfer (taskId, dest, seq)
+  /// @param data The packed_columns data to share (nullptr for atEnd)
+  /// @param atEnd True if this is the end-of-stream marker
+  /// @return A future that completes when source has retrieved the data
+  [[nodiscard]] std::future<void> publish(
+      const IntraNodeTransferKey& key,
+      std::shared_ptr<cudf::packed_columns> data,
+      bool atEnd);
+
+  /// @brief Non-blocking poll for intra-node transfer data.
+  /// Returns immediately whether data is available or not.
+  /// @param key The unique key identifying this transfer
+  /// @return nullopt if not ready, or IntraNodeTransferResult if ready.
+  ///         Data is nullptr when atEnd is true.
+  [[nodiscard]] std::optional<IntraNodeTransferResult> poll(
+      const IntraNodeTransferKey& key);
+
+  /// @brief Cancel all pending transfers for a task.
+  /// Called when a producing task is removed. Subsequent poll() calls for
+  /// this taskId will return an atEnd result instead of nullopt.
+  /// @param taskId The task to cancel
+  void cancelTask(std::string_view taskId);
+
+  /// @brief Remove a task from the cancelled set.
+  /// Called when a task ID is (re)initialized, so that the cancelledTasks_
+  /// set does not grow unboundedly across queries.
+  /// @param taskId The task to clear from the cancelled set
+  void clearCancelledTask(std::string_view taskId);
+
+ private:
+  IntraNodeTransferRegistry() = default;
+
+  std::map<IntraNodeTransferKey, std::shared_ptr<IntraNodeTransferEntry>>
+      registry_;
+  std::unordered_set<std::string> cancelledTasks_;
+  std::mutex mutex_;
+};
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/NetUtil.cpp b/velox/experimental/ucx-exchange/NetUtil.cpp
new file mode 100644
index 00000000000..08548b5f29c
--- /dev/null
+++ b/velox/experimental/ucx-exchange/NetUtil.cpp
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <arpa/inet.h>
+#include <ifaddrs.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <cstring>
+#include <set>
+#include <sstream>
+#include <string>
+#include <string_view>
+#include <unordered_set>
+
+#include <glog/logging.h>
+
+// Helper: resolve a hostname/IP string into a set of stringified addresses
+static std::set<std::string> resolveHost(std::string_view host) {
+  std::set<std::string> results;
+  addrinfo hints{}, *res, *p;
+
+  hints.ai_family = AF_UNSPEC; // Allow both IPv4 and IPv6
+  hints.ai_socktype = SOCK_STREAM; // Any type is fine
+  hints.ai_flags = AI_ADDRCONFIG; // Use configured address families
+
+  std::string hostStr{host};
+  int status = getaddrinfo(hostStr.c_str(), nullptr, &hints, &res);
+  if (status != 0) {
+    // Could not resolve
+    return results;
+  }
+
+  for (p = res; p != nullptr; p = p->ai_next) {
+    char ipstr[INET6_ADDRSTRLEN];
+    void* addr = nullptr;
+
+    if (p->ai_family == AF_INET) { // IPv4
+      sockaddr_in* ipv4 = reinterpret_cast<sockaddr_in*>(p->ai_addr);
+      addr = &(ipv4->sin_addr);
+      inet_ntop(AF_INET, addr, ipstr, sizeof(ipstr));
+      results.insert(ipstr);
+    } else if (p->ai_family == AF_INET6) { // IPv6
+      sockaddr_in6* ipv6 = reinterpret_cast<sockaddr_in6*>(p->ai_addr);
+      addr = &(ipv6->sin6_addr);
+      inet_ntop(AF_INET6, addr, ipstr, sizeof(ipstr));
+      results.insert(ipstr);
+    }
+  }
+
+  freeaddrinfo(res);
+  return results;
+}
+
+// Main function: check if two hosts resolve to a common address
+bool isSameHost(std::string_view h1, std::string_view h2) {
+  auto set1 = resolveHost(h1);
+  auto set2 = resolveHost(h2);
+
+  for (const auto& addr : set1) {
+    if (set2.find(addr) != set2.end()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Get all IP addresses assigned to local network interfaces.
+// Used for server-side intra-node detection.
+std::unordered_set<std::string> getLocalIpAddresses() {
+  std::unordered_set<std::string> localIps;
+  struct ifaddrs* ifaddr = nullptr;
+  struct ifaddrs* ifa = nullptr;
+
+  if (getifaddrs(&ifaddr) == -1) {
+    LOG(WARNING) << "[EXCHANGE_DEBUG] getLocalIpAddresses: getifaddrs() failed";
+    return localIps;
+  }
+
+  for (ifa = ifaddr; ifa != nullptr; ifa = ifa->ifa_next) {
+    if (ifa->ifa_addr == nullptr) {
+      continue;
+    }
+
+    char ipstr[INET6_ADDRSTRLEN];
+    if (ifa->ifa_addr->sa_family == AF_INET) {
+      // IPv4
+      sockaddr_in* ipv4 = reinterpret_cast<sockaddr_in*>(ifa->ifa_addr);
+      inet_ntop(AF_INET, &ipv4->sin_addr, ipstr, sizeof(ipstr));
+      localIps.insert(ipstr);
+    } else if (ifa->ifa_addr->sa_family == AF_INET6) {
+      // IPv6
+      sockaddr_in6* ipv6 = reinterpret_cast<sockaddr_in6*>(ifa->ifa_addr);
+      inet_ntop(AF_INET6, &ipv6->sin6_addr, ipstr, sizeof(ipstr));
+      localIps.insert(ipstr);
+    }
+  }
+
+  // CRITICAL: Use freeifaddrs(), not freeaddrinfo()
+  freeifaddrs(ifaddr);
+
+  // Log all local IPs for debugging
+  std::ostringstream oss;
+  oss << "{";
+  bool first = true;
+  for (const auto& ip : localIps) {
+    if (!first)
+      oss << ", ";
+    oss << ip;
+    first = false;
+  }
+  oss << "}";
+  LOG(INFO) << "[EXCHANGE_DEBUG] getLocalIpAddresses: " << localIps.size()
+            << " addresses: " << oss.str();
+
+  return localIps;
+}
diff --git a/velox/experimental/ucx-exchange/NetUtil.h b/velox/experimental/ucx-exchange/NetUtil.h
new file mode 100644
index 00000000000..bdb64c8e983
--- /dev/null
+++ b/velox/experimental/ucx-exchange/NetUtil.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <string>
+#include <string_view>
+#include <unordered_set>
+
+/// @brief Utility function that checks whether two
+/// hostnames resolve to the same underlying host.
+// The hostnames can be domain names, IPv4 or IPv6 addresses.
+bool isSameHost(std::string_view h1, std::string_view h2);
+
+/// @brief Get all IP addresses assigned to local network interfaces.
+/// Used for server-side intra-node detection by checking if a peer's IP
+/// is in this set. Includes both IPv4 and IPv6 addresses, as well as
+/// loopback addresses (127.0.0.1, ::1).
+/// @return Set of IP address strings for all local interfaces.
+std::unordered_set<std::string> getLocalIpAddresses();
diff --git a/velox/experimental/ucx-exchange/PartitionKey.h b/velox/experimental/ucx-exchange/PartitionKey.h
new file mode 100644
index 00000000000..d39c62abb3a
--- /dev/null
+++ b/velox/experimental/ucx-exchange/PartitionKey.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <sstream>
+#include <string>
+#include <tuple>
+
+namespace facebook::velox::ucx_exchange {
+
+/// @brief A client asks for a partition. The partition is uniquely identified
+/// by the taskId and the destination (=partition) number. The partition key
+/// implements the C++'s compare requirements
+struct PartitionKey {
+  std::string taskId;
+  uint32_t destination;
+
+  // Less-than operator
+  bool operator<(const PartitionKey& other) const {
+    return std::tie(taskId, destination) <
+        std::tie(other.taskId, other.destination);
+  }
+
+  std::string toString() const {
+    std::stringstream out;
+    out << taskId << "/" << std::to_string(destination);
+    return out.str();
+  }
+};
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/README.md b/velox/experimental/ucx-exchange/README.md
new file mode 100644
index 00000000000..096048031c3
--- /dev/null
+++ b/velox/experimental/ucx-exchange/README.md
@@ -0,0 +1,73 @@
+# UCX Exchange
+
+The UCX Exchange is a replacement for the inter-worker velox exchange that happens between tasks ending in a partitioned output operator and tasks having an exchange operator as source node. In Velox, this exchange is partially implemented; both the exchange server and the actual exchange source object implementations are outside the scope of Velox.
+
+The velox UCX exchange implements all the necessary components to efficiently transfer cudf-vectors between tasks. At the core is a UCXX based transfer that directly copies the raw vector data from GPU memory to GPU memory.
+
+## CMake Configuration
+
+When building for the first time, this error occurs:
+
+```
+CMake Error at _build/release/_deps/geos-src/CMakeLists.txt:396 (add_custom_target):
+  add_custom_target cannot create target "uninstall" because another target
+  with the same name already exists.  The existing target is a custom target
+  created in source directory
+  "/gpfs/zc2/u/dnb/rapidsai-velox/_build/release/_deps/zstd-src/build/cmake/lib".
+  See documentation for policy CMP0002 for more details.
+```
+
+Edit the file _build/release/_deps/geos-src/CMakeLists.txt, line 396 and change the target name from `uninstall` to `uninstall_geos`.
+
+```
+CUDA_ARCHITECTURES="80" EXTRA_CMAKE_FLAGS="-DVELOX_ENABLE_ARROW=ON -DVELOX_ENABLE_PARQUET=ON -DVELOX_ENABLE_BENCHMARKS=OFF -DVELOX_ENABLE_BENCHMARKS_BASIC=OFF" make cudf
+```
+
+In order to build the UCX exchange tests, add `-DVELOX_BUILD_TESTING=ON` to EXTRA_CMAKE_FLAGS above. To build only the exchange and exchange tests, run:
+`cmake --build _build/release -j --target=ucx_exchange_test`.
+
+Then for example to run tests:
+`_build/release/velox/experimental/ucx-exchange/tests/ucx_exchange_test`
+
+
+To build the UCXX tests:
+
+```
+cmake --build _build/release -j --target=exchange_client_tst
+cmake --build _build/release -j --target=exchange_srv_tst
+
+_build/release/velox/experimental/ucx-exchange/tests/exchange_srv_tst -logtostdout -v=3 -port <PORT>
+_build/release/velox/experimental/ucx-exchange/tests/exchange_client_tst -logtostdout -v=3 -port <PORT>
+```
+
+
+```
+To build the velox test:
+
+cmake --build _build/release -j --target=1brc_server
+cmake --build _build/release -j --target=1brc_client
+
+
+
+CUDA_VISIBLE_DEVICES=4  UCX_TLS=^ib _build/release/velox/experimental/ucx-exchange/tests/1brc_server -inputfile /gpfs/zc2/zoltan/1brc/measurements.parquet  -logtostdout -v=3 -velox_cudf_enabled=true -velox_cudf_table_scan=true -velox_cudf_debug=true  -velox_cudf_memory_resource=pool -port <PORT> -cuda_device=0 cudfChunkSizeGB=1
+
+CUDA_VISIBLE_DEVICES=5 UCX_LOG_LEVEL=error UCX_TCP_KEEPINTVL=1ms UCX_KEEPALIVE_INTERVAL=1ms  UCX_TLS=^ib _build/release/velox/experimental/ucx-exchange/tests/1brc_client -logtostdout -v=3 -velox_cudf_enabled=true -velox_cudf_table_scan=true -velox_cudf_debug=true  -velox_cudf_memory_resource=pool -port <PORT> -cuda_device=0
+
+```
+
+There's a common target called `exchange_tests` that builds all of the above:
+```
+cmake --build _build/release -j --target=exchange_tests
+```
+
+## Code Formatting
+
+We use the same code formating as velox.
+The pre-commit hook needs to be activate once. Then formatting happens on every commit. These are the steps:
+
+ -   Install the Python pre-commit package locally: pip install pre-commit
+ -   Change to the velox directory where the velox repository is checked out, e.g. cd ~/velox
+ -   Install the pre-commit hook in that directory: ~/.local/bin/pre-commit install
+    Optionally, run the pre-commit hook "offline" to format some files, e.g.: ~/.local/bin/pre-commit run --files ./velox/experimental/ucx-exchange/*
+
+When a file is ready to commit, the pre-commit hook runs and stops the commit whenever it has re-formatted the file, then the file can be re-viewed or directly added again and committed.
diff --git a/velox/experimental/ucx-exchange/UcxExchange.cpp b/velox/experimental/ucx-exchange/UcxExchange.cpp
new file mode 100644
index 00000000000..b7fbc3898fa
--- /dev/null
+++ b/velox/experimental/ucx-exchange/UcxExchange.cpp
@@ -0,0 +1,248 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/ucx-exchange/UcxExchange.h"
+#include "velox/experimental/cudf/vector/CudfVector.h"
+
+using facebook::velox::exec::Operator;
+using facebook::velox::exec::RemoteConnectorSplit;
+// Required by VELOX_NVTX_OPERATOR_FUNC_RANGE macro in NvtxHelper.h which
+// references extractClassAndFunction and VeloxDomain unqualified.
+using namespace facebook::velox::cudf_velox; // NOLINT
+
+namespace facebook::velox::ucx_exchange {
+
+// --- Implementation of the UcxExchange operator.
+
+UcxExchange::UcxExchange(
+    int32_t operatorId,
+    DriverCtx* driverCtx,
+    const std::shared_ptr<const core::PlanNode>& planNode,
+    std::shared_ptr<UcxExchangeClient> ucxExchangeClient,
+    std::string_view operatorType)
+    : SourceOperator(
+          driverCtx,
+          planNode->outputType(),
+          operatorId,
+          planNode->id(),
+          operatorType),
+      NvtxHelper(
+          nvtx3::rgb{0, 191, 255},
+          operatorId,
+          fmt::format("[{}]", planNode->id())),
+      preferredOutputBatchBytes_{
+          driverCtx->queryConfig().preferredOutputBatchBytes()},
+      processSplits_{driverCtx->driverId == 0},
+      pipelineId_{driverCtx->pipelineId},
+      driverId_{driverCtx->driverId} {
+  if (ucxExchangeClient) {
+    // UcxExchangeClient is provided externally when this is a "plain"
+    // UcxExchange.
+    exchangeClient_ = std::move(ucxExchangeClient);
+  } else {
+    // UcxExchangeClient is nullptr when this UcxExchange is used to
+    // implement a MergeExchange. Create a new UCX exchange client.
+    auto task = operatorCtx_->task();
+    exchangeClient_ = std::make_shared<UcxExchangeClient>(
+        task->taskId(),
+        task->destination(),
+        1 // number of consumers, is always 1.
+    );
+  }
+}
+
+UcxExchange::~UcxExchange() {
+  close();
+}
+
+void UcxExchange::addRemoteTaskIds(std::vector<std::string>& remoteTaskIds) {
+  std::shuffle(std::begin(remoteTaskIds), std::end(remoteTaskIds), rng_);
+  for (const std::string& remoteTaskId : remoteTaskIds) {
+    exchangeClient_->addRemoteTaskId(remoteTaskId);
+  }
+  stats_.wlock()->numSplits += remoteTaskIds.size();
+}
+
+void UcxExchange::getSplits(ContinueFuture* future) {
+  VLOG(3) << "@" << taskId() << "#" << pipelineId_ << "/" << driverId_
+          << " getSplits called for task: " << taskId();
+  if (!processSplits_) {
+    VLOG(3) << "@" << taskId() << "#" << pipelineId_ << "/" << driverId_
+            << " getSplits: Not allowed to process splits for task: "
+            << taskId();
+    return;
+  }
+  if (noMoreSplits_) {
+    VLOG(3) << "@" << taskId() << "#" << pipelineId_ << "/" << driverId_
+            << " getSplits: No more splits for task: " << taskId();
+    return;
+  }
+  std::vector<std::string> remoteTaskIds;
+  // loop until we get an end marker.
+  for (;;) {
+    exec::Split split;
+    auto reason = operatorCtx_->task()->getSplitOrFuture(
+        operatorCtx_->driverCtx()->driverId,
+        operatorCtx_->driverCtx()->splitGroupId,
+        planNodeId(),
+        /*maxPreloadSplits=*/0,
+        /*preload=*/nullptr,
+        split,
+        *future);
+    if (reason != BlockingReason::kNotBlocked) {
+      // we are blocked. Add the splits collected so far (if any) and return.
+      addRemoteTaskIds(remoteTaskIds);
+      return;
+    }
+
+    if (split.hasConnectorSplit()) {
+      auto remoteSplit =
+          std::dynamic_pointer_cast<RemoteConnectorSplit>(split.connectorSplit);
+      VELOX_CHECK_NOT_NULL(remoteSplit, "Wrong type of split");
+      remoteTaskIds.push_back(remoteSplit->taskId);
+      // check for more splits.
+      continue;
+    }
+
+    // not blocked but also no connector split.
+    // we've reached the end.
+    addRemoteTaskIds(remoteTaskIds);
+    exchangeClient_->noMoreRemoteTasks();
+    noMoreSplits_ = true;
+    if (atEnd_) {
+      operatorCtx_->task()->multipleSplitsFinished(
+          false, stats_.rlock()->numSplits, 0);
+      recordExchangeClientStats();
+    }
+    return;
+  }
+}
+
+BlockingReason UcxExchange::isBlocked(ContinueFuture* future) {
+  VELOX_NVTX_OPERATOR_FUNC_RANGE();
+  if (currentData_ || atEnd_) {
+    return BlockingReason::kNotBlocked;
+  }
+
+  // Get splits from the task if no splits are outstanding.
+  if (!splitFuture_.valid()) {
+    getSplits(&splitFuture_);
+  }
+
+  ContinueFuture dataFuture = ContinueFuture::makeEmpty();
+  currentData_ = exchangeClient_->next(driverId_, &atEnd_, &dataFuture);
+  if (currentData_ || atEnd_) {
+    // got some data or reached the end.
+    if (atEnd_ && noMoreSplits_) {
+      const auto numSplits = stats_.rlock()->numSplits;
+      operatorCtx_->task()->multipleSplitsFinished(false, numSplits, 0);
+    }
+    recordExchangeClientStats();
+    return BlockingReason::kNotBlocked;
+  }
+
+  if (splitFuture_.valid()) {
+    // Combine the futures and block until data becomes available or more splits
+    // arrive.
+    std::vector<ContinueFuture> futures;
+    futures.push_back(std::move(splitFuture_));
+    futures.push_back(std::move(dataFuture));
+    *future = folly::collectAny(futures).unit();
+    return BlockingReason::kWaitForSplit;
+  }
+
+  // Block until data becomes available.
+  *future = std::move(dataFuture);
+  return BlockingReason::kWaitForProducer;
+}
+
+bool UcxExchange::isFinished() {
+  return atEnd_ && !currentData_;
+}
+
+RowVectorPtr UcxExchange::getOutputFromPackedTable() {
+  if (!currentData_) {
+    return nullptr;
+  }
+
+  // Get the packed_table and stream from the PackedTableWithStream
+  PackedTableWithStream& data = *currentData_;
+  auto numRows = data.packedTable->table.num_rows();
+  auto gpuDataSize = data.gpuDataSize();
+
+  // Use the stream that was allocated in UcxExchangeSource::onMetadata
+  // and the packed_table constructor of CudfVector to avoid copying data.
+  auto result = std::make_shared<cudf_velox::CudfVector>(
+      pool(), outputType_, numRows, std::move(data.packedTable), data.stream);
+
+  recordInputStats(gpuDataSize, result);
+  // free the memory owned by PackedTableWithStream and set it to nullptr;
+  currentData_.reset();
+
+  return result;
+}
+
+RowVectorPtr UcxExchange::getOutput() {
+  VELOX_NVTX_OPERATOR_FUNC_RANGE();
+  return getOutputFromPackedTable();
+}
+
+void UcxExchange::recordInputStats(
+    uint64_t rawInputBytes,
+    const RowVectorPtr& result) {
+  auto lockedStats = stats_.wlock();
+  lockedStats->rawInputBytes += rawInputBytes;
+  lockedStats->rawInputPositions += result->size();
+  lockedStats->addInputVector(result->estimateFlatSize(), result->size());
+}
+
+void UcxExchange::close() {
+  if (closed_) {
+    return;
+  }
+  closed_ = true;
+  SourceOperator::close();
+  currentData_.reset();
+  if (exchangeClient_) {
+    recordExchangeClientStats();
+    exchangeClient_->close();
+  }
+  exchangeClient_ = nullptr;
+}
+
+void UcxExchange::recordExchangeClientStats() {
+  if (!processSplits_) {
+    return;
+  }
+
+  auto lockedStats = stats_.wlock();
+  const auto exchangeClientStats = exchangeClient_->stats();
+  for (const auto& [name, value] : exchangeClientStats) {
+    lockedStats->runtimeStats.erase(name);
+    lockedStats->runtimeStats.insert({name, value});
+  }
+
+  const auto iter = exchangeClientStats.find(Operator::kBackgroundCpuTimeNanos);
+  if (iter != exchangeClientStats.end()) {
+    const CpuWallTiming backgroundTiming{
+        static_cast<uint64_t>(iter->second.count),
+        0,
+        static_cast<uint64_t>(iter->second.sum)};
+    lockedStats->backgroundTiming.clear();
+    lockedStats->backgroundTiming.add(backgroundTiming);
+  }
+}
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/UcxExchange.h b/velox/experimental/ucx-exchange/UcxExchange.h
new file mode 100644
index 00000000000..216824ddd80
--- /dev/null
+++ b/velox/experimental/ucx-exchange/UcxExchange.h
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <random>
+#include "velox/exec/Operator.h"
+#include "velox/exec/Task.h"
+#include "velox/experimental/cudf/exec/NvtxHelper.h"
+#include "velox/experimental/ucx-exchange/UcxExchangeClient.h"
+#include "velox/experimental/ucx-exchange/UcxQueues.h"
+
+namespace facebook::velox::ucx_exchange {
+
+using exec::BlockingReason;
+using exec::DriverCtx;
+using exec::SourceOperator;
+
+/// @brief The UCX exchange operator receives data from upstream tasks via
+/// UcxExchangeClient. It is used as a replacement for the Velox Exchange
+/// operator when the plan node's transport type is UCX. The operator receives
+/// cudf::packed_columns from remote tasks and wraps them as CudfVectors.
+class UcxExchange : public SourceOperator, public cudf_velox::NvtxHelper {
+ public:
+  UcxExchange(
+      int32_t operatorId,
+      DriverCtx* driverCtx,
+      const std::shared_ptr<const core::PlanNode>& planNode,
+      std::shared_ptr<UcxExchangeClient> ucxExchangeClient,
+      std::string_view operatorType = "UcxExchange");
+
+  ~UcxExchange() override;
+
+  [[nodiscard]] BlockingReason isBlocked(ContinueFuture* future) override;
+
+  [[nodiscard]] bool isFinished() override;
+
+  [[nodiscard]] RowVectorPtr getOutput() override;
+
+  void close() override;
+
+ private:
+  // Invoked to create exchange client for remote tasks. The function shuffles
+  // the source task ids first to randomize the source tasks we fetch data from.
+  // This helps to avoid different tasks fetching from the same source task in a
+  // distributed system.
+  void addRemoteTaskIds(std::vector<std::string>& remoteTaskIds);
+
+  // This is a no-op except when called from driver 0.
+  // Fetches splits from the task until there are no more splits or task returns
+  // a future that will be complete when more splits arrive. Adds splits to
+  // exchangeClient_. Sets "noMoreSplits_" if the task returns not blocked
+  // without a split, this is the end-of-splits signal.
+  void getSplits(ContinueFuture* future);
+
+  // Converts the cudf packed table into a CudfVector.
+  RowVectorPtr getOutputFromPackedTable();
+
+  // Fetches runtime stats from ExchangeClient and replaces these in this
+  // operator's stats.
+  void recordExchangeClientStats();
+
+  void recordInputStats(uint64_t rawInputBytes, const RowVectorPtr& result);
+
+  std::shared_ptr<UcxExchangeClient> exchangeClient_;
+
+  const uint64_t preferredOutputBatchBytes_;
+
+  /// True if this operator is responsible for fetching splits from the Task
+  /// and passing these to ExchangeClient. When running with multile drivers,
+  /// this is done by the exchange running on driver 0.
+  const bool processSplits_;
+  const int pipelineId_;
+  const int driverId_;
+  bool noMoreSplits_ = false;
+
+  // A future received from Task::getSplitOrFuture(). It will be complete when
+  // there are more splits available or no-more-splits signal has arrived.
+  ContinueFuture splitFuture_{ContinueFuture::makeEmpty()};
+
+  // Data returned from exchangeClient_->next().
+  PackedTableWithStreamPtr currentData_;
+
+  // Reusable result vector.
+  RowVectorPtr result_;
+
+  bool atEnd_{false};
+  bool closed_{false};
+  std::default_random_engine rng_{std::random_device{}()};
+};
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/UcxExchangeClient.cpp b/velox/experimental/ucx-exchange/UcxExchangeClient.cpp
new file mode 100644
index 00000000000..bf5cb2c6c05
--- /dev/null
+++ b/velox/experimental/ucx-exchange/UcxExchangeClient.cpp
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/ucx-exchange/UcxExchangeClient.h"
+
+#include "velox/common/base/Counters.h"
+#include "velox/common/base/StatsReporter.h"
+
+namespace facebook::velox::ucx_exchange {
+
+void UcxExchangeClient::addRemoteTaskId(std::string_view remoteTaskId) {
+  std::shared_ptr<UcxExchangeSource> toClose;
+  {
+    std::lock_guard<std::mutex> l(queue_->mutex());
+
+    bool duplicate = !remoteTaskIds_.insert(std::string{remoteTaskId}).second;
+    if (duplicate) {
+      // Do not add sources twice. Presto protocol may add duplicate sources
+      // and the task updates have no guarantees of arriving in order.
+      return;
+    }
+
+    std::shared_ptr<UcxExchangeSource> source;
+    source = UcxExchangeSource::create(taskId_, remoteTaskId, queue_);
+
+    if (closed_) {
+      toClose = std::move(source);
+    } else {
+      sources_.push_back(source);
+      queue_->addSourceLocked();
+      source->setRegistered();
+      VLOG(3) << "@" << taskId_
+              << " Added remote split for task: " << remoteTaskId;
+    }
+  }
+
+  // Outside of lock.
+  if (toClose) {
+    toClose->close();
+  }
+}
+
+void UcxExchangeClient::noMoreRemoteTasks() {
+  VLOG(3) << "@" << taskId_ << " UcxExchangeClient::noMoreRemoteTasks called.";
+  queue_->noMoreSources();
+}
+
+void UcxExchangeClient::close() {
+  std::vector<std::shared_ptr<UcxExchangeSource>> sources;
+  {
+    std::lock_guard<std::mutex> l(queue_->mutex());
+    if (closed_) {
+      return;
+    }
+    closed_ = true;
+    sources = std::move(sources_);
+  }
+
+  // Outside of mutex.
+  for (auto& source : sources) {
+    source->close();
+  }
+  queue_->close();
+}
+
+folly::F14FastMap<std::string, RuntimeMetric> UcxExchangeClient::stats() const {
+  // TODO: Implement stats collection.
+  folly::F14FastMap<std::string, RuntimeMetric> stats;
+  return stats;
+}
+
+PackedTableWithStreamPtr
+UcxExchangeClient::next(int consumerId, bool* atEnd, ContinueFuture* future) {
+  VLOG(3) << "@" << taskId_ << " UcxExchangeClient::next called for consumerId "
+          << consumerId;
+  PackedTableWithStreamPtr data;
+  ContinuePromise stalePromise = ContinuePromise::makeEmpty();
+  std::vector<std::shared_ptr<UcxExchangeSource>> sourcesToResume;
+  {
+    std::lock_guard<std::mutex> l(queue_->mutex());
+    if (closed_) {
+      *atEnd = true;
+      return data;
+    }
+
+    // not closed, get packed table from the queue.
+    *atEnd = false;
+    data = queue_->dequeueLocked(consumerId, atEnd, future, &stalePromise);
+    if (*atEnd) {
+      // queue is closed!
+      return data;
+    }
+
+    // TODO: Review this primitive form of flow control.
+    // Maybe need to inspect the #bytes rather than the #tables?
+    // Don't request more data when queue size exceeds the configured limit.
+    // NOTE: This check is currently a no-op because the UCX exchange is
+    // push-based — there is no mechanism to "request" or "not request" more
+    // data. The server pushes unconditionally. Real backpressure is
+    // implemented in UcxExchangeSource::process() (ReadyToReceive state).
+    if (data != nullptr && queue_->size() > maxQueuedColumns_) {
+      if (!inFlowControl_) {
+        inFlowControl_ = true;
+        VLOG(1) << "[FLOW-CTRL] @" << taskId_ << " consumer=" << consumerId
+                << " entering flow control"
+                << " queueSize=" << queue_->size()
+                << " maxQueued=" << maxQueuedColumns_;
+      }
+      return data;
+    } else if (inFlowControl_ && data != nullptr) {
+      inFlowControl_ = false;
+      VLOG(1) << "[FLOW-CTRL] @" << taskId_ << " consumer=" << consumerId
+              << " leaving flow control"
+              << " queueSize=" << queue_->size()
+              << " maxQueued=" << maxQueuedColumns_;
+    }
+
+    // Per-stage progress counters.
+    if (data != nullptr) {
+      ++totalDequeued_;
+      if (totalDequeued_ % 1000 == 0) {
+        VLOG(1) << "[PROGRESS] @" << taskId_ << " consumer=" << consumerId
+                << " dequeued=" << totalDequeued_
+                << " queueSize=" << queue_->size()
+                << " queueBytes=" << queue_->totalBytes();
+      }
+    }
+
+    // Collect sources that need resuming while holding the lock.
+    // We call resumeFromBackpressure() outside the lock to avoid a
+    // lock-ordering hazard: it acquires WorkQueue::mutex_ via
+    // addToWorkQueue(), and holding queue_->mutex_ here would impose
+    // queue_->mutex_ → WorkQueue::mutex_ ordering.
+    if (data != nullptr &&
+        queue_->size() <= UcxExchangeSource::kBackpressureLowWaterMark) {
+      sourcesToResume.assign(sources_.begin(), sources_.end());
+    }
+  }
+
+  // Outside of lock: resume backpressured sources and fulfill stale promise.
+  for (auto& source : sourcesToResume) {
+    source->resumeFromBackpressure();
+  }
+  if (stalePromise.valid()) {
+    stalePromise.setValue();
+  }
+  return data;
+}
+
+UcxExchangeClient::~UcxExchangeClient() {
+  close();
+}
+
+std::string UcxExchangeClient::toString() const {
+  std::stringstream out;
+  {
+    std::lock_guard<std::mutex> l(queue_->mutex());
+    for (auto& source : sources_) {
+      out << source->toString() << std::endl;
+    }
+  }
+  return out.str();
+}
+
+folly::dynamic UcxExchangeClient::toJson() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["taskId"] = taskId_;
+  obj["closed"] = closed_;
+  folly::dynamic clientsObj = folly::dynamic::object;
+  int index = 0;
+  {
+    std::lock_guard<std::mutex> l(queue_->mutex());
+    for (auto& source : sources_) {
+      clientsObj[std::to_string(index++)] = source->toJson();
+    }
+  }
+  obj["clients"] = clientsObj;
+  return obj;
+}
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/UcxExchangeClient.h b/velox/experimental/ucx-exchange/UcxExchangeClient.h
new file mode 100644
index 00000000000..f43e31f0533
--- /dev/null
+++ b/velox/experimental/ucx-exchange/UcxExchangeClient.h
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/experimental/ucx-exchange/UcxExchangeQueue.h"
+#include "velox/experimental/ucx-exchange/UcxExchangeSource.h"
+
+namespace facebook::velox::ucx_exchange {
+
+// Handle for a set of producers. This may be shared by multiple UcxExchanges,
+// one per consumer thread.
+class UcxExchangeClient
+    : public std::enable_shared_from_this<UcxExchangeClient> {
+ public:
+  // used for some primitive type of flow control, limits the size of elements
+  // in the UcxExchangeQueue
+  static constexpr int32_t kDefaultMaxQueuedColumns = 32;
+  static constexpr std::chrono::milliseconds kRequestDataMaxWait{100};
+
+  UcxExchangeClient(
+      std::string taskId,
+      int destination,
+      int32_t numberOfConsumers,
+      int32_t requestDataSizesMaxWaitSec = 10)
+      : taskId_{std::move(taskId)},
+        destination_(destination),
+        maxQueuedColumns_(kDefaultMaxQueuedColumns),
+        kRequestDataSizesMaxWaitSec_(requestDataSizesMaxWaitSec),
+        queue_(std::make_shared<UcxExchangeQueue>(numberOfConsumers)) {
+    VELOX_CHECK_GE(
+        destination, 0, "Exchange client destination must not be negative");
+  }
+
+  ~UcxExchangeClient();
+
+  // Creates a UCX exchange source and starts fetching data from the specified
+  // upstream task. If 'close' has been called already, creates an exchange
+  // source and immediately closes it to notify the upstream task that data is
+  // no longer needed. Repeated calls with the same 'taskId' are ignored.
+  void addRemoteTaskId(std::string_view remoteTaskId);
+
+  void noMoreRemoteTasks();
+
+  // Closes all exchange sources.
+  void close();
+
+  // Returns runtime statistics aggregated across all of the exchange sources.
+  // ExchangeClient is expected to report background CPU time by including a
+  // runtime metric named Operator::kBackgroundCpuTimeNanos.
+  folly::F14FastMap<std::string, RuntimeMetric> stats() const;
+
+  const std::shared_ptr<UcxExchangeQueue>& queue() const {
+    return queue_;
+  }
+
+  /// Returns a PackedTableWithStream object from the queue or null.
+  ///
+  /// If no data is available returns a nullptr and sets 'atEnd' to true if no
+  /// more data is expected. If data is still expected, sets 'atEnd' to false
+  /// and sets 'future' to a Future that will complete when data arrives.
+  ///
+  PackedTableWithStreamPtr
+  next(int consumerId, bool* atEnd, ContinueFuture* future);
+
+  std::string toString() const;
+
+  folly::dynamic toJson() const;
+
+  std::chrono::seconds requestDataSizesMaxWaitSec() const {
+    return kRequestDataSizesMaxWaitSec_;
+  }
+
+  const std::unordered_set<std::string>& getRemoteTaskIdList() const {
+    return remoteTaskIds_;
+  }
+
+ private:
+  // Handy for ad-hoc logging.
+  const std::string taskId_;
+  const int destination_;
+  const int32_t maxQueuedColumns_;
+  const std::chrono::seconds kRequestDataSizesMaxWaitSec_;
+
+  const std::shared_ptr<UcxExchangeQueue> queue_;
+
+  std::unordered_set<std::string> remoteTaskIds_;
+  std::vector<std::shared_ptr<UcxExchangeSource>> sources_;
+  bool closed_{false};
+
+  // Total number of packed_clumns in flight.
+  int64_t totalPendingColumns_{0};
+
+  // Diagnostic counters for progress and flow control.
+  int64_t totalDequeued_{0};
+  bool inFlowControl_{false};
+};
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/UcxExchangeModules.h.in b/velox/experimental/ucx-exchange/UcxExchangeModules.h.in
new file mode 100644
index 00000000000..19a82e701af
--- /dev/null
+++ b/velox/experimental/ucx-exchange/UcxExchangeModules.h.in
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Auto-generated by CMake from UcxExchangeModules.h.in — do not edit.
+#pragma once
+
+namespace facebook::velox::ucx_exchange {
+
+/// Module basenames for ucx-exchange source files, used by
+/// Communicator to set per-file VLOG levels via google::SetVLOGLevel().
+inline constexpr const char* kUcxExchangeModules[] = {
+    @UCX_EXCHANGE_MODULE_LIST@};
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/UcxExchangeProtocol.cpp b/velox/experimental/ucx-exchange/UcxExchangeProtocol.cpp
new file mode 100644
index 00000000000..556c072edde
--- /dev/null
+++ b/velox/experimental/ucx-exchange/UcxExchangeProtocol.cpp
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/ucx-exchange/UcxExchangeProtocol.h"
+
+#include <cstring>
+#include <stdexcept>
+#include "velox/common/base/Exceptions.h"
+
+namespace facebook::velox::ucx_exchange {
+
+uint32_t fnv1a_32(std::string_view s) {
+  uint32_t hash = 0x811C9DC5u; // FNV offset basis
+  for (unsigned char c : s) {
+    hash ^= c;
+    hash *= 0x01000193u; // FNV prime
+  }
+  return hash;
+}
+
+std::pair<std::shared_ptr<uint8_t>, size_t> MetadataMsg::serialize() {
+  uint32_t totalSize = getSerializedSize();
+
+  VELOX_CHECK_LE(
+      totalSize,
+      kMaxMetaBufSize,
+      "Metadata serialized size ({}) exceeds maximum buffer size ({}). "
+      "This can happen with extremely wide tables. "
+      "Consider reducing table width or increasing kMaxMetaBufSize.",
+      totalSize,
+      kMaxMetaBufSize);
+
+  auto deleter = [](uint8_t* p) { delete[] p; };
+  std::shared_ptr<uint8_t> buffer(new uint8_t[totalSize], deleter);
+
+  uint8_t* ptr = buffer.get();
+
+  std::memcpy(ptr, &kMagicNumber, sizeof(kMagicNumber));
+  ptr += sizeof(kMagicNumber);
+
+  std::memcpy(ptr, &totalSize, sizeof(totalSize));
+  ptr += sizeof(totalSize);
+
+  WireLengthType cudfSize = cudfMetadata ? cudfMetadata->size() : 0;
+  std::memcpy(ptr, &cudfSize, sizeof(cudfSize));
+  ptr += sizeof(cudfSize);
+
+  if (cudfSize > 0) {
+    std::memcpy(ptr, cudfMetadata->data(), cudfSize);
+    ptr += cudfSize;
+  }
+
+  std::memcpy(ptr, &dataSizeBytes, sizeof(dataSizeBytes));
+  ptr += sizeof(dataSizeBytes);
+
+  WireLengthType numRemaining = remainingBytes.size();
+  std::memcpy(ptr, &numRemaining, sizeof(numRemaining));
+  ptr += sizeof(numRemaining);
+
+  if (numRemaining > 0) {
+    auto bytesSize = numRemaining * sizeof(remainingBytes[0]);
+    std::memcpy(ptr, remainingBytes.data(), bytesSize);
+    ptr += bytesSize;
+  }
+
+  uint8_t atEndByte = atEnd ? 1 : 0;
+  *ptr = atEndByte;
+
+  return std::make_pair<std::shared_ptr<uint8_t>, size_t>(
+      std::move(buffer), totalSize);
+}
+
+MetadataMsg MetadataMsg::deserializeMetadataMsg(const uint8_t* buffer) {
+  const uint8_t* ptr = buffer;
+
+  MetadataMsg record;
+
+  uint32_t magicNumber = 0;
+  std::memcpy(&magicNumber, ptr, sizeof(magicNumber));
+  VELOX_CHECK_EQ(magicNumber, kMagicNumber);
+  ptr += sizeof(magicNumber);
+
+  uint32_t totalSize = 0;
+  std::memcpy(&totalSize, ptr, sizeof(totalSize));
+  ptr += sizeof(totalSize);
+
+  const uint8_t* endPtr = buffer + totalSize;
+
+  WireLengthType metaSize = 0;
+  if (ptr + sizeof(metaSize) > endPtr)
+    throw std::runtime_error("Insufficient data for cudfMetadata size");
+  std::memcpy(&metaSize, ptr, sizeof(metaSize));
+  ptr += sizeof(metaSize);
+
+  record.cudfMetadata = std::make_unique<std::vector<uint8_t>>(metaSize);
+  if (metaSize > 0) {
+    if (ptr + metaSize > endPtr)
+      throw std::runtime_error("Insufficient data for cudfMetadata bytes");
+    std::memcpy(record.cudfMetadata->data(), ptr, metaSize);
+    ptr += metaSize;
+  }
+
+  if (ptr + sizeof(record.dataSizeBytes) > endPtr)
+    throw std::runtime_error("Insufficient data for dataSizeBytes");
+  std::memcpy(&record.dataSizeBytes, ptr, sizeof(record.dataSizeBytes));
+  ptr += sizeof(record.dataSizeBytes);
+
+  WireLengthType numRemaining = 0;
+  if (ptr + sizeof(numRemaining) > endPtr)
+    throw std::runtime_error("Insufficient data for remainingBytes count");
+  std::memcpy(&numRemaining, ptr, sizeof(numRemaining));
+  ptr += sizeof(numRemaining);
+
+  record.remainingBytes.resize(numRemaining);
+  if (numRemaining > 0) {
+    auto bytesSize = numRemaining * sizeof(record.remainingBytes[0]);
+    if (ptr + bytesSize > endPtr)
+      throw std::runtime_error("Insufficient data for remainingBytes values");
+    std::memcpy(record.remainingBytes.data(), ptr, bytesSize);
+    ptr += bytesSize;
+  }
+
+  if (ptr + 1 > endPtr) {
+    throw std::runtime_error("Insufficient data for atEnd flag");
+  }
+  record.atEnd = (*ptr != 0);
+
+  return record;
+}
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/UcxExchangeProtocol.h b/velox/experimental/ucx-exchange/UcxExchangeProtocol.h
new file mode 100644
index 00000000000..f4c7cd3e4f3
--- /dev/null
+++ b/velox/experimental/ucx-exchange/UcxExchangeProtocol.h
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cinttypes>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <vector>
+
+/// Definitions needed for the Ucx exchange protocol.
+///
+/// Byte order: all multi-byte fields are serialized with std::memcpy, which
+/// preserves host byte order. The protocol assumes matching endianness between
+/// peers (little-endian on x86 and ARM). Cross-endian transfers are not
+/// supported.
+
+namespace facebook::velox::ucx_exchange {
+
+// Data and metadata tags are a uint64_t split into 3 fields, most-significant
+// first:
+// - Bits 63..32 (4 bytes): FNV-1a hash of the producing taskId, which is
+//   unique within a cluster.
+// - Bits 31..24 (1 byte): Operation type (metadata, data, or handshake
+//   response).
+// - Bits 23..0  (3 bytes): Sequence number of the chunk exchanged between 2
+//   tasks.
+
+// Definition of the operations.
+constexpr uint64_t METADATA_TAG = 0x02000000;
+constexpr uint64_t DATA_TAG = 0x03000000;
+constexpr uint64_t HANDSHAKE_RESPONSE_TAG = 0x04000000;
+
+// Implementation of the fowler-noll-vo hash function for 32 bits.
+uint32_t fnv1a_32(std::string_view s);
+
+// Gets the tag used for metadata communication
+// Note: taskHash and sequenceNumber are implicitly converted to 64 bits.
+inline uint64_t getMetadataTag(uint64_t taskHash, uint64_t sequenceNumber) {
+  return (taskHash << 32) | METADATA_TAG | sequenceNumber;
+}
+
+// Gets the tag used for data communication
+// Note: taskHash and sequenceNumber are implicitly converted to 64 bits.
+inline uint64_t getDataTag(uint64_t taskHash, uint64_t sequenceNumber) {
+  return (taskHash << 32) | DATA_TAG | sequenceNumber;
+}
+
+// Gets the tag used for handshake response communication.
+// Note: taskHash is implicitly converted to 64 bits.
+inline uint64_t getHandshakeResponseTag(uint64_t taskHash) {
+  return (taskHash << 32) | HANDSHAKE_RESPONSE_TAG;
+}
+
+/// @brief Request that is sent from the client (UcxExchangeSource) to the
+/// server (UcxExchangeServer) after connection.
+///
+/// The handshake establishes the partition key for data exchange.
+/// The workerId identifies the source's Communicator instance (process).
+/// If the server's workerId matches, both are in the same process, enabling
+/// intra-node transfer via IntraNodeTransferRegistry instead of UCXX.
+struct HandshakeMsg {
+  char taskId[256];
+  uint32_t destination;
+  /// Unique identifier for the source's Communicator instance.
+  /// Generated randomly at Communicator startup. The server compares this
+  /// against its own workerId to detect same-process (intra-node) transfers.
+  uint64_t workerId{0};
+};
+
+/// @brief Response sent from server to source after handshake.
+/// Informs the source whether intra-node transfer optimization is available,
+/// allowing the source to bypass UCXX for all subsequent data transfers.
+struct HandshakeResponse {
+  /// True if server and source are on the same node (same Communicator).
+  /// When true, source should use IntraNodeTransferRegistry instead of UCXX.
+  bool isIntraNodeTransfer{false};
+  /// Padding for alignment
+  uint8_t padding[7]{};
+};
+
+constexpr uint32_t kMagicNumber = 0x12345678;
+/// Maximum metadata buffer size for receiving. This should be large enough
+/// to handle tables with many columns. 1MB allows for ~10,000+ columns.
+/// The sender allocates exact size needed; receiver pre-allocates this max.
+constexpr uint32_t kMaxMetaBufSize = 1024 * 1024; // 1MB
+
+/// Minimum header size needed to read the totalSize field.
+/// Format: [magic (4 bytes)][totalSize (4 bytes)]
+constexpr uint32_t kMetaHeaderSize = sizeof(kMagicNumber) + sizeof(uint32_t);
+
+/// Wire-format types for MetadataMsg serialization. Using shared type aliases
+/// ensures serialize() and deserializeMetadataMsg() agree on field widths.
+using WireLengthType = uint64_t;
+using WireDataSizeType = int64_t;
+using WireRemainingElementType = int64_t;
+
+struct MetadataMsg {
+  std::unique_ptr<std::vector<uint8_t>> cudfMetadata;
+  WireDataSizeType dataSizeBytes;
+  std::vector<WireRemainingElementType> remainingBytes;
+  bool atEnd;
+
+  uint32_t getSerializedSize() const {
+    // The header: the magic number and the metadata length.
+    uint32_t totalSize = sizeof(kMagicNumber) + sizeof(totalSize);
+    // cudfMetadata: length info and then the data.
+    WireLengthType cudfSize = cudfMetadata ? cudfMetadata->size() : 0;
+    totalSize += sizeof(cudfSize);
+    totalSize += cudfSize;
+    // dataSizeBytes
+    totalSize += sizeof(dataSizeBytes);
+    // remainingBytes: length and then the data.
+    totalSize += sizeof(WireLengthType); // for numRemaining count
+    totalSize += remainingBytes.size() * sizeof(remainingBytes[0]);
+    // atEnd, encoded in a byte.
+    totalSize += sizeof(uint8_t);
+
+    return totalSize;
+  }
+
+  /// Serializes this metadata record into a newly allocated buffer.
+  std::pair<std::shared_ptr<uint8_t>, size_t> serialize();
+
+  /// Deserializes a MetadataMsg from a buffer produced by serialize().
+  static MetadataMsg deserializeMetadataMsg(const uint8_t* buffer);
+};
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/UcxExchangeQueue.cpp b/velox/experimental/ucx-exchange/UcxExchangeQueue.cpp
new file mode 100644
index 00000000000..76b06a97cc3
--- /dev/null
+++ b/velox/experimental/ucx-exchange/UcxExchangeQueue.cpp
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/ucx-exchange/UcxExchangeQueue.h"
+
+namespace facebook::velox::ucx_exchange {
+
+void UcxExchangeQueue::noMoreSources() {
+  std::vector<ContinuePromise> promises;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    noMoreSources_ = true;
+    promises = checkCompleteLocked();
+  }
+  clearPromises(promises);
+}
+
+void UcxExchangeQueue::close() {
+  std::vector<ContinuePromise> promises;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    promises = closeLocked();
+  }
+  clearPromises(promises);
+}
+
+void UcxExchangeQueue::enqueueLocked(
+    PackedTableWithStreamPtr&& data,
+    std::vector<ContinuePromise>& promises) {
+  if (data == nullptr) {
+    ++numCompleted_;
+    VLOG(2) << "[EX-QUEUE] source completed (null enqueued)"
+            << " numCompleted=" << numCompleted_
+            << " numSources=" << numSources_
+            << " noMoreSources=" << noMoreSources_;
+    auto completedPromises = checkCompleteLocked();
+    promises.reserve(promises.size() + completedPromises.size());
+    for (auto& promise : completedPromises) {
+      promises.push_back(std::move(promise));
+    }
+    return;
+  }
+
+  auto dataSize = data->gpuDataSize();
+  totalBytes_ += dataSize;
+  if (peakBytes_ < totalBytes_) {
+    peakBytes_ = totalBytes_;
+  }
+
+  ++receivedTables_;
+  receivedBytes_ += dataSize;
+
+  queue_.push_back(std::move(data));
+
+  // High-water-mark alerts: log when queue size crosses thresholds.
+  auto newSize = static_cast<int64_t>(queue_.size());
+  if (newSize > peakSize_) {
+    if ((peakSize_ < 100 && newSize >= 100) ||
+        (peakSize_ < 1000 && newSize >= 1000) ||
+        (peakSize_ < 10000 && newSize >= 10000)) {
+      VLOG(1) << "[EX-QUEUE] high water mark: queueSize=" << newSize
+              << " peakBytes=" << peakBytes_
+              << " receivedTables=" << receivedTables_;
+    }
+    peakSize_ = newSize;
+  }
+
+  size_t wokenConsumers = 0;
+  while (!promises_.empty()) {
+    VELOX_CHECK_LE(promises_.size(), numberOfConsumers_);
+    const int32_t unblockedConsumers = numberOfConsumers_ - promises_.size();
+    const int64_t unassignedTables = queue_.size() - unblockedConsumers;
+    if (unassignedTables <= 0) {
+      break;
+    }
+    // Resume one of the waiting drivers.
+    auto it = promises_.begin();
+    promises.push_back(std::move(it->second));
+    promises_.erase(it);
+    ++wokenConsumers;
+  }
+  if (wokenConsumers > 0) {
+    VLOG(2) << "[EX-QUEUE] waking " << wokenConsumers << " consumers"
+            << " queueSize=" << queue_.size();
+  }
+}
+
+void UcxExchangeQueue::addPromiseLocked(
+    int consumerId,
+    ContinueFuture* future,
+    ContinuePromise* stalePromise) {
+  ContinuePromise promise{"UcxExchangeQueue::dequeue"};
+  *future = promise.getSemiFuture();
+  auto it = promises_.find(consumerId);
+  if (it != promises_.end()) {
+    // resolve stale promises outside the lock to avoid broken promises
+    *stalePromise = std::move(it->second);
+    it->second = std::move(promise);
+  } else {
+    promises_[consumerId] = std::move(promise);
+  }
+  VELOX_CHECK_LE(promises_.size(), numberOfConsumers_);
+}
+
+PackedTableWithStreamPtr UcxExchangeQueue::dequeueLocked(
+    int consumerId,
+    bool* atEnd,
+    ContinueFuture* future,
+    ContinuePromise* stalePromise) {
+  VELOX_CHECK_NOT_NULL(future);
+  if (!error_.empty()) {
+    *atEnd = true;
+    VELOX_FAIL(error_);
+  }
+
+  *atEnd = false;
+
+  // check whether the queue is empty.
+  PackedTableWithStreamPtr data = nullptr;
+  if (queue_.empty()) {
+    if (atEnd_) {
+      *atEnd = true;
+    } else {
+      VLOG(2) << "[EX-QUEUE] consumer=" << consumerId
+              << " blocked (empty queue, waiting for data)"
+              << " numSources=" << numSources_
+              << " numCompleted=" << numCompleted_
+              << " waitingConsumers=" << (promises_.size() + 1);
+      addPromiseLocked(consumerId, future, stalePromise);
+    }
+    return data;
+  }
+
+  data = std::move(queue_.front());
+  queue_.pop_front();
+  totalBytes_ -= data->gpuDataSize();
+
+  return data;
+}
+
+void UcxExchangeQueue::setError(std::string_view error) {
+  std::vector<ContinuePromise> promises;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    if (!error_.empty()) {
+      return;
+    }
+    error_ = error;
+    atEnd_ = true;
+    // NOTE: clear the serialized page queue as we won't consume from an
+    // errored queue.
+    queue_.clear();
+    promises = clearAllPromisesLocked();
+  }
+  clearPromises(promises);
+}
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/UcxExchangeQueue.h b/velox/experimental/ucx-exchange/UcxExchangeQueue.h
new file mode 100644
index 00000000000..baf3d17c5ae
--- /dev/null
+++ b/velox/experimental/ucx-exchange/UcxExchangeQueue.h
@@ -0,0 +1,207 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cudf/contiguous_split.hpp>
+#include <rmm/cuda_stream_view.hpp>
+#include <cinttypes>
+#include <memory>
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/future/VeloxPromise.h"
+
+namespace facebook::velox::ucx_exchange {
+
+/// Struct that bundles a packed_table with the CUDA stream that was used
+/// to allocate its memory. This allows the receiver to reuse the same stream
+/// for subsequent operations on the data.
+struct PackedTableWithStream {
+  std::unique_ptr<cudf::packed_table> packedTable;
+  rmm::cuda_stream_view stream;
+
+  PackedTableWithStream() = default;
+  PackedTableWithStream(
+      std::unique_ptr<cudf::packed_table>&& table,
+      rmm::cuda_stream_view s)
+      : packedTable(std::move(table)), stream(s) {}
+
+  /// Returns the size of the GPU data buffer, or 0 if packedTable is null.
+  size_t gpuDataSize() const {
+    return packedTable ? packedTable->data.gpu_data->size() : 0;
+  }
+};
+
+using PackedTableWithStreamPtr = std::unique_ptr<PackedTableWithStream>;
+
+class UcxExchangeQueue {
+ public:
+  explicit UcxExchangeQueue(int32_t numberOfConsumers)
+      : numberOfConsumers_{numberOfConsumers} {
+    VELOX_CHECK_GE(numberOfConsumers, 1);
+  }
+
+  ~UcxExchangeQueue() {
+    clearAllPromises();
+  }
+
+  std::mutex& mutex() {
+    return mutex_;
+  }
+
+  bool empty() const {
+    return queue_.empty();
+  }
+
+  /// Enqueues 'data' to the queue. One random promise(top of promise queue)
+  /// associated with the future that is waiting for the data from the queue
+  /// is returned in 'promises' if 'data' is not nullptr. When 'data' is
+  /// nullptr and the queue is completed serving data, all left over promises
+  /// will be returned in 'promises'. When 'data' is nullptr and the queue is
+  /// not completed serving data, no 'promises' will be added and returned.
+  void enqueueLocked(
+      PackedTableWithStreamPtr&& data,
+      std::vector<ContinuePromise>& promises);
+
+  /// If data is permanently not available, e.g. the source cannot be
+  /// contacted, this registers an error message and causes the reading
+  /// Exchanges to throw with the message.
+  void setError(std::string_view error);
+
+  bool isInError() {
+    return !error_.empty();
+  }
+  /// Returns a PackedTableWithStream object.
+  ///
+  /// Returns a nullptr if no data is available. If data is still expected,
+  /// sets 'atEnd' to false and 'future' to a Future that will complete when
+  /// data arrives. If no more data is expected, sets 'atEnd' to true. Returns
+  /// one PackedTableWithStream if data is available.
+  /// It's possible that the same consumer is already waiting for data. In this
+  /// case, a stalePromise is returned which needs to be cleaned up.
+  PackedTableWithStreamPtr dequeueLocked(
+      int consumerId,
+      bool* atEnd,
+      ContinueFuture* future,
+      ContinuePromise* stalePromise);
+
+  int32_t size() const {
+    return queue_.size();
+  }
+
+  /// Returns the total bytes held by packed tables in 'this'.
+  int64_t totalBytes() const {
+    return totalBytes_;
+  }
+
+  /// Returns the maximum value of total bytes.
+  uint64_t peakBytes() const {
+    return peakBytes_;
+  }
+
+  /// Returns total number of packed tables received from all sources.
+  uint64_t receivedTables() const {
+    return receivedTables_;
+  }
+
+  /// Returns an average size of tables. Returns 0 if hasn't received
+  /// any tables yet.
+  uint64_t averageReceivedTablesBytes() const {
+    return receivedTables_ > 0 ? receivedBytes_ / receivedTables_ : 0;
+  }
+
+  void addSourceLocked() {
+    VELOX_CHECK(!noMoreSources_, "addSource called after noMoreSources");
+    numSources_++;
+  }
+
+  void noMoreSources();
+
+  void close();
+
+ private:
+  std::vector<ContinuePromise> closeLocked() {
+    queue_.clear();
+    return clearAllPromisesLocked();
+  }
+
+  std::vector<ContinuePromise> checkCompleteLocked() {
+    if (noMoreSources_ && numCompleted_ == numSources_) {
+      atEnd_ = true;
+      return clearAllPromisesLocked();
+    }
+    return {};
+  }
+
+  void addPromiseLocked(
+      int consumerId,
+      ContinueFuture* future,
+      ContinuePromise* stalePromise);
+
+  void clearAllPromises() {
+    std::vector<ContinuePromise> promises;
+    {
+      std::lock_guard<std::mutex> l(mutex_);
+      promises = clearAllPromisesLocked();
+    }
+    clearPromises(promises);
+  }
+
+  std::vector<ContinuePromise> clearAllPromisesLocked() {
+    std::vector<ContinuePromise> promises;
+    promises.reserve(promises_.size());
+    auto it = promises_.begin();
+    while (it != promises_.end()) {
+      promises.push_back(std::move(it->second));
+      it = promises_.erase(it);
+    }
+    VELOX_CHECK(promises_.empty());
+    return promises;
+  }
+
+  static void clearPromises(std::vector<ContinuePromise>& promises) {
+    for (auto& promise : promises) {
+      promise.setValue();
+    }
+  }
+
+  const int32_t numberOfConsumers_;
+
+  int numCompleted_{0};
+  int numSources_{0};
+  bool noMoreSources_{false};
+  bool atEnd_{false};
+
+  std::mutex mutex_;
+  std::deque<PackedTableWithStreamPtr> queue_;
+  // The map from consumer id to the waiting promise
+  folly::F14FastMap<int, ContinuePromise> promises_;
+
+  // When set, all promises will be realized and the next dequeue will
+  // throw an exception with this message.
+  std::string error_;
+  // Total size of packed tables in queue.
+  int64_t totalBytes_{0};
+  // Number of packed tables received.
+  int64_t receivedTables_{0};
+  // Total size of packed tables received. Used to calculate an average
+  // expected size.
+  int64_t receivedBytes_{0};
+  // Maximum value of totalBytes_.
+  int64_t peakBytes_{0};
+  // Peak queue size (number of items). Used for high-water-mark alerts.
+  int64_t peakSize_{0};
+};
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/UcxExchangeServer.cpp b/velox/experimental/ucx-exchange/UcxExchangeServer.cpp
new file mode 100644
index 00000000000..8a6307b1de2
--- /dev/null
+++ b/velox/experimental/ucx-exchange/UcxExchangeServer.cpp
@@ -0,0 +1,524 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/ucx-exchange/UcxExchangeServer.h"
+#include <glog/logging.h>
+#include <rmm/cuda_stream_view.hpp>
+#include "cuda_runtime.h"
+#include "velox/experimental/cudf/exec/Utilities.h"
+#include "velox/experimental/ucx-exchange/Communicator.h"
+#include "velox/experimental/ucx-exchange/IntraNodeTransferRegistry.h"
+#include "velox/experimental/ucx-exchange/UcxExchangeProtocol.h"
+
+namespace facebook::velox::ucx_exchange {
+
+namespace {
+const folly::F14FastMap<UcxExchangeServer::ServerState, std::string_view>&
+serverStateNames() {
+  static const folly::
+      F14FastMap<UcxExchangeServer::ServerState, std::string_view>
+          kNames = {
+              {UcxExchangeServer::ServerState::Created, "Created"},
+              {UcxExchangeServer::ServerState::ReadyToTransfer,
+               "ReadyToTransfer"},
+              {UcxExchangeServer::ServerState::WaitingForDataFromQueue,
+               "WaitingForDataFromQueue"},
+              {UcxExchangeServer::ServerState::DataReady, "DataReady"},
+              {UcxExchangeServer::ServerState::WaitingForSendComplete,
+               "WaitingForSendComplete"},
+              {UcxExchangeServer::ServerState::WaitingForIntraNodeRetrieve,
+               "WaitingForIntraNodeRetrieve"},
+              {UcxExchangeServer::ServerState::Done, "Done"},
+          };
+  return kNames;
+}
+} // namespace
+
+VELOX_DEFINE_EMBEDDED_ENUM_NAME(
+    UcxExchangeServer,
+    ServerState,
+    serverStateNames)
+
+// Context wrappers for UCXX tagSend callbackData. These decouple the
+// ucxx::Request lifetime (which must survive for UCP wireup replay) from
+// the buffer lifetime (which should be freed promptly after DMA completes).
+//
+// The Request holds a shared_ptr to the context via callbackData. The
+// context holds a shared_ptr to the actual buffer. When the send completion
+// callback fires, it moves the buffer out of the context, releasing the GPU
+// (or CPU) memory. The context remains alive as an empty shell for the
+// lifetime of the Request, which is safe and costs negligible memory.
+struct MetaSendContext {
+  std::shared_ptr<uint8_t> metadata;
+};
+
+struct DataSendContext {
+  std::shared_ptr<cudf::packed_columns> data;
+};
+
+void UcxExchangeServer::setState(ServerState newState) {
+  auto oldState = state_.exchange(newState, std::memory_order_seq_cst);
+  VLOG(2) << (isIntraNodeTransfer_ ? "[INTRA]" : "[REMOTE]") << " [ExSrv "
+          << partitionKey_.toString() << " seq=" << sequenceNumber_ << "] "
+          << toName(oldState) << " -> " << toName(newState);
+}
+
+// This constructor is private
+UcxExchangeServer::UcxExchangeServer(
+    const std::shared_ptr<Communicator> communicator,
+    std::shared_ptr<EndpointRef> endpointRef,
+    const PartitionKey& key,
+    bool isIntraNodeTransfer)
+    : CommElement(communicator, endpointRef),
+      partitionKey_(key),
+      partitionKeyHash_(fnv1a_32(partitionKey_.toString())),
+      isIntraNodeTransfer_(isIntraNodeTransfer),
+      queueMgr_(UcxOutputQueueManager::getInstanceRef()) {
+  setState(ServerState::Created);
+
+  if (isIntraNodeTransfer_) {
+    VLOG(3) << "@" << partitionKey_.taskId
+            << " Detected same-node source (intra-node transfer) for "
+            << partitionKey_.toString();
+  }
+}
+
+// static
+std::shared_ptr<UcxExchangeServer> UcxExchangeServer::create(
+    const std::shared_ptr<Communicator> communicator,
+    std::shared_ptr<EndpointRef> endpointRef,
+    const PartitionKey& key,
+    bool isIntraNodeTransfer) {
+  auto ptr = std::shared_ptr<UcxExchangeServer>(new UcxExchangeServer(
+      communicator, endpointRef, key, isIntraNodeTransfer));
+  return ptr;
+}
+
+void UcxExchangeServer::process() {
+  // Check if close() was called - avoid processing if we're shutting down
+  if (closed_.load(std::memory_order_acquire)) {
+    return;
+  }
+  switch (state_) {
+    case ServerState::Created:
+      setState(ServerState::ReadyToTransfer);
+      communicator_->addToWorkQueue(getSelfPtr());
+      break;
+    case ServerState::ReadyToTransfer: {
+      // Fetch the data from UcxQueueManager and store it in the dataPtr_;
+      setState(ServerState::WaitingForDataFromQueue);
+      // Register the callback with the destination queue to get data.
+      // If the queue doesn't exist yet, getData will create an empty
+      // queue and the callback will be triggered once the corresponding
+      // source task has initialized the queue and added data to it.
+      // Use weak_ptr to prevent use-after-free if close() is called during
+      // callback
+      std::weak_ptr<UcxExchangeServer> weakQueue = weak_from_this();
+      queueMgr_->getData(
+          partitionKey_.taskId,
+          partitionKey_.destination,
+          [weakQueue](
+              std::shared_ptr<cudf::packed_columns> data,
+              std::vector<int64_t> remainingBytes) {
+            auto self = weakQueue.lock();
+            if (!self) {
+              return; // Object was destroyed, safe to ignore
+            }
+            // Check if close() was called - avoid processing if we're shutting
+            // down
+            if (self->closed_.load(std::memory_order_acquire)) {
+              VLOG(3) << "@" << self->partitionKey_.taskId
+                      << " getData callback called after close, ignoring";
+              return;
+            }
+            // This upcall may be called from another thread than the
+            // communicator thread. It is called
+            // when data on the queue becomes available.
+            VLOG(3) << "@" << self->partitionKey_.taskId
+                    << " Found data for client: "
+                    << self->partitionKey_.toString();
+            std::lock_guard<std::recursive_mutex> lock(self->dataMutex_);
+            VELOX_CHECK_NULL(
+                self->dataPtr_, "Data pointer exists: Illegal state!");
+            self->dataPtr_ = std::move(data);
+            self->setState(ServerState::DataReady);
+            self->communicator_->addToWorkQueue(self);
+          });
+      this->communicator_->addToWorkQueue(getSelfPtr());
+    } break;
+    case ServerState::WaitingForDataFromQueue:
+      // Waiting for data is handled by an upcall from the data queue. Nothing
+      // to do
+      break;
+    case ServerState::DataReady:
+      sendData();
+      break;
+    case ServerState::WaitingForSendComplete:
+      // Waiting for send complete is handled by an upcall from UCXX. Nothing to
+      // do
+      break;
+    case ServerState::WaitingForIntraNodeRetrieve:
+      // Intra-node transfer: check if the source has retrieved the data
+      if (intraNodeRetrieveFuture_.valid()) {
+        auto status =
+            intraNodeRetrieveFuture_.wait_for(std::chrono::milliseconds(0));
+        if (status == std::future_status::ready) {
+          intraNodeRetrieveFuture_.get(); // Clear the future
+          intraNodePollCount_ = 0;
+          onIntraNodeRetrieveComplete();
+        } else {
+          // Not ready yet, re-queue to check later
+          ++intraNodePollCount_;
+          if (intraNodePollCount_ % 100 == 0) {
+            VLOG(2) << "[INTRA] [ExSrv " << partitionKey_.toString()
+                    << " seq=" << sequenceNumber_
+                    << "] still waiting for source retrieval, polls="
+                    << intraNodePollCount_;
+          }
+          communicator_->addToWorkQueue(getSelfPtr());
+        }
+      }
+      break;
+    case ServerState::Done:
+      close();
+      if (endpointRef_) {
+        endpointRef_->removeCommElem(getSelfPtr());
+        endpointRef_ = nullptr;
+      }
+      break;
+  };
+}
+
+void UcxExchangeServer::close() {
+  // Use memory_order_acq_rel to ensure proper synchronization with callbacks
+  // that check closed_ with memory_order_acquire.
+  bool expected = false;
+  bool desired = true;
+  if (!closed_.compare_exchange_strong(
+          expected, desired, std::memory_order_acq_rel)) {
+    return; // already closed.
+  }
+  VLOG(3) << "@" << partitionKey_.taskId
+          << " Close UcxExchangeServer to remote " << partitionKey_.toString();
+
+  // Cancel any outstanding requests. With weak_ptr callbacks, the callbacks
+  // will safely no-op if we're destroyed before they complete.
+  if (metaRequest_ && !metaRequest_->isCompleted()) {
+    metaRequest_->cancel();
+  }
+  if (dataRequest_ && !dataRequest_->isCompleted()) {
+    dataRequest_->cancel();
+  }
+
+  // Move all requests to the Communicator's deferred list so the GPU
+  // buffers they reference (via their arg shared_ptr) stay alive until
+  // UCX has fully processed any in-flight operations.
+  if (communicator_) {
+    if (metaRequest_) {
+      communicator_->deferRequestCleanup(std::move(metaRequest_));
+    }
+    if (dataRequest_) {
+      communicator_->deferRequestCleanup(std::move(dataRequest_));
+    }
+    for (auto& req : completedRequests_) {
+      communicator_->deferRequestCleanup(std::move(req));
+    }
+    completedRequests_.clear();
+  }
+
+  communicator_->unregister(getSelfPtr());
+}
+
+std::string UcxExchangeServer::toString() {
+  std::stringstream out;
+  out << "[ExSrv " << partitionKey_.toString() << " - " << sequenceNumber_
+      << "]";
+  return out.str();
+}
+
+// ------ private methods ---------
+
+std::shared_ptr<UcxExchangeServer> UcxExchangeServer::getSelfPtr() {
+  return shared_from_this();
+}
+
+void UcxExchangeServer::sendData() {
+  std::lock_guard<std::recursive_mutex> lock(dataMutex_);
+
+  VLOG(2) << (isIntraNodeTransfer_ ? "[INTRA]" : "[REMOTE]") << " [ExSrv "
+          << partitionKey_.toString() << " seq=" << sequenceNumber_
+          << "] sendData hasData=" << (dataPtr_ != nullptr)
+          << (dataPtr_ && dataPtr_->gpu_data
+                  ? " size=" + std::to_string(dataPtr_->gpu_data->size())
+                  : "");
+
+  if (isIntraNodeTransfer_) {
+    // INTRA-NODE TRANSFER PATH: Use registry for all communication, no UCXX
+    // needed
+    sendStart_ = std::chrono::high_resolution_clock::now();
+
+    if (dataPtr_) {
+      bytes_ = dataPtr_->gpu_data->size();
+
+      VLOG(3) << "@" << partitionKey_.taskId
+              << " Intra-node transfer: publishing data for sequence "
+              << sequenceNumber_ << " of size " << bytes_;
+
+      IntraNodeTransferKey key{
+          partitionKey_.taskId, partitionKey_.destination, sequenceNumber_};
+      // dataPtr_ is already a shared_ptr, pass directly to share ownership.
+      intraNodeRetrieveFuture_ =
+          IntraNodeTransferRegistry::getInstance()->publish(
+              key, dataPtr_, /*atEnd=*/false);
+      dataPtr_.reset();
+      intraNodeAtEndPublished_ = false;
+
+      // Transition to WaitingForIntraNodeRetrieve state
+      setState(ServerState::WaitingForIntraNodeRetrieve);
+      communicator_->addToWorkQueue(getSelfPtr());
+    } else {
+      // Data pointer is null, so no more data will be coming.
+      // Publish atEnd marker to registry
+      VLOG(3) << "@" << partitionKey_.taskId
+              << " Intra-node transfer: publishing atEnd for sequence "
+              << sequenceNumber_;
+
+      IntraNodeTransferKey key{
+          partitionKey_.taskId, partitionKey_.destination, sequenceNumber_};
+      intraNodeRetrieveFuture_ =
+          IntraNodeTransferRegistry::getInstance()->publish(
+              key, nullptr, /*atEnd=*/true);
+      intraNodeAtEndPublished_ = true;
+
+      queueMgr_->deleteResults(partitionKey_.taskId, partitionKey_.destination);
+
+      // Wait for source to acknowledge atEnd before finishing
+      setState(ServerState::WaitingForIntraNodeRetrieve);
+      communicator_->addToWorkQueue(getSelfPtr());
+    }
+  } else {
+    // REMOTE EXCHANGE PATH: Use UCXX for metadata and data transfer
+    std::shared_ptr<MetadataMsg> metadataMsg = std::make_shared<MetadataMsg>();
+
+    if (dataPtr_) {
+      // Copy metadata (not move) because in broadcast mode, the same
+      // packed_columns may be shared across multiple destination queues.
+      // Metadata is small (CPU-side), so copying is negligible.
+      metadataMsg->cudfMetadata =
+          std::make_unique<std::vector<uint8_t>>(*dataPtr_->metadata);
+      metadataMsg->dataSizeBytes = dataPtr_->gpu_data->size();
+      metadataMsg->remainingBytes = {};
+      metadataMsg->atEnd = false;
+    } else {
+      VLOG(3) << "@" << partitionKey_.taskId << " Final exchange for "
+              << partitionKey_.toString();
+      metadataMsg->cudfMetadata = nullptr;
+      metadataMsg->dataSizeBytes = 0;
+      metadataMsg->remainingBytes = {};
+      metadataMsg->atEnd = true;
+    }
+
+    auto [serializedMetadata, serMetaSize] = metadataMsg->serialize();
+
+    // send metadata.
+    uint64_t metadataTag =
+        getMetadataTag(this->partitionKeyHash_, this->sequenceNumber_);
+    // Use weak_ptr to prevent use-after-free if close() is called during
+    // callback
+    std::weak_ptr<UcxExchangeServer> weakMeta = weak_from_this();
+    if (metaRequest_) {
+      completedRequests_.push_back(std::move(metaRequest_));
+    }
+
+    // Wrap the serialized metadata in a context so the callback can release
+    // it after the send completes, while the Request (and context shell)
+    // stays alive for UCP wireup replay.
+    auto metaCtx = std::make_shared<MetaSendContext>();
+    metaCtx->metadata = serializedMetadata;
+
+    metaRequest_ = endpointRef_->endpoint_->tagSend(
+        metaCtx->metadata.get(),
+        serMetaSize,
+        ucxx::Tag{metadataTag},
+        false,
+        [tid = partitionKey_.toString(), metadataTag, weakMeta](
+            ucs_status_t status, std::shared_ptr<void> arg) {
+          // Release the metadata buffer from the context. The context
+          // shell stays alive with the Request; only the payload is freed.
+          auto ctx = std::static_pointer_cast<MetaSendContext>(arg);
+          auto metaHolder = std::move(ctx->metadata); // release CPU buffer
+
+          auto self = weakMeta.lock();
+          if (!self) {
+            return; // Object was destroyed, safe to ignore
+          }
+          // Check if close() was called
+          if (self->closed_.load(std::memory_order_acquire)) {
+            VLOG(3) << "@" << self->partitionKey_.taskId
+                    << " metadata send callback called after close, ignoring";
+            return;
+          }
+          if (status == UCS_OK) {
+            VLOG(3) << "@" << self->partitionKey_.taskId
+                    << " metadata successfully sent to " << tid
+                    << " with tag: " << std::hex << metadataTag;
+          } else {
+            VLOG(0) << "@" << self->partitionKey_.taskId
+                    << " Error in sendData, send metadata "
+                    << ucs_status_string(status) << " failed for task: " << tid;
+            self->setState(ServerState::Done);
+            self->communicator_->addToWorkQueue(self);
+          }
+        },
+        metaCtx);
+
+    // send the data chunk (if any)
+    if (dataPtr_) {
+      sendStart_ = std::chrono::high_resolution_clock::now();
+      bytes_ = dataPtr_->gpu_data->size();
+
+      VLOG(3) << "@" << partitionKey_.taskId
+              << " Sending rmm::buffer: " << std::hex
+              << dataPtr_->gpu_data.get()
+              << " pointing to device memory: " << std::hex
+              << dataPtr_->gpu_data->data() << std::dec << " to task "
+              << partitionKey_.toString() << ":" << this->sequenceNumber_
+              << std::dec << " of size " << bytes_;
+
+      setState(ServerState::WaitingForSendComplete);
+      uint64_t dataTag =
+          getDataTag(this->partitionKeyHash_, this->sequenceNumber_);
+      // Use weak_ptr to prevent use-after-free if close() is called during
+      // callback
+      std::weak_ptr<UcxExchangeServer> weakData = weak_from_this();
+      if (dataRequest_) {
+        completedRequests_.push_back(std::move(dataRequest_));
+      }
+
+      // Wrap the GPU data buffer in a context so the callback can release
+      // it after the DMA completes, while the Request (and context shell)
+      // stays alive for UCP wireup replay.
+      auto dataCtx = std::make_shared<DataSendContext>();
+      dataCtx->data = dataPtr_;
+
+      dataRequest_ = endpointRef_->endpoint_->tagSend(
+          dataCtx->data->gpu_data->data(),
+          dataCtx->data->gpu_data->size(),
+          ucxx::Tag{dataTag},
+          false,
+          [weakData](ucs_status_t status, std::shared_ptr<void> arg) {
+            // Release the GPU data buffer from the context. The DMA has
+            // completed by the time this callback fires, so the buffer is
+            // safe to free. The context shell stays alive with the Request.
+            auto ctx = std::static_pointer_cast<DataSendContext>(arg);
+            auto dataHolder = std::move(ctx->data);
+
+            if (auto self = weakData.lock()) {
+              self->sendComplete(status, arg);
+            }
+            // dataHolder is destroyed here, releasing the GPU buffer if
+            // sendComplete() already reset the server's dataPtr_.
+          },
+          dataCtx);
+    } else {
+      // Data pointer is null, so no more data will be coming.
+      VLOG(3) << "@" << partitionKey_.taskId
+              << " Finished transferring partition for task "
+              << partitionKey_.toString();
+      queueMgr_->deleteResults(partitionKey_.taskId, partitionKey_.destination);
+      setState(ServerState::Done);
+      communicator_->addToWorkQueue(getSelfPtr());
+    }
+  }
+}
+
+void UcxExchangeServer::sendComplete(
+    ucs_status_t status,
+    std::shared_ptr<void> arg) {
+  // Check if close() was called - avoid processing if we're shutting down
+  if (closed_.load(std::memory_order_acquire)) {
+    VLOG(3) << "@" << partitionKey_.taskId
+            << " sendComplete called after close, ignoring";
+    return;
+  }
+  if (status == UCS_OK) {
+    std::lock_guard<std::recursive_mutex> lock(dataMutex_);
+    VELOX_CHECK_NOT_NULL(dataPtr_, "dataPtr_ is null");
+
+    auto end = std::chrono::high_resolution_clock::now();
+    auto duration = end - sendStart_;
+    auto micros =
+        std::chrono::duration_cast<std::chrono::microseconds>(duration).count();
+    auto throughput = bytes_ / micros;
+
+    VLOG(3) << "@" << partitionKey_.taskId << " duration: "
+            << std::chrono::duration_cast<std::chrono::milliseconds>(duration)
+                   .count()
+            << " ms ";
+    VLOG(3) << "@" << partitionKey_.taskId << " throughput: " << throughput
+            << " MByte/s";
+
+    this->sequenceNumber_++;
+    dataPtr_.reset(); // release memory.
+    VLOG(3) << "@" << partitionKey_.taskId
+            << " Releasing dataPtr_ in sendComplete.";
+    setState(ServerState::ReadyToTransfer);
+  } else {
+    VLOG(3) << "@" << partitionKey_.taskId
+            << " Error in sendComplete, send complete "
+            << ucs_status_string(status);
+    setState(ServerState::Done);
+  }
+  communicator_->addToWorkQueue(getSelfPtr());
+}
+
+void UcxExchangeServer::onIntraNodeRetrieveComplete() {
+  // Check if close() was called - avoid processing if we're shutting down
+  if (closed_.load(std::memory_order_acquire)) {
+    VLOG(3) << "@" << partitionKey_.taskId
+            << " onIntraNodeRetrieveComplete called after close, ignoring";
+    return;
+  }
+
+  auto end = std::chrono::high_resolution_clock::now();
+  auto duration = end - sendStart_;
+  auto micros =
+      std::chrono::duration_cast<std::chrono::microseconds>(duration).count();
+  auto throughput = (micros > 0) ? (bytes_ / micros) : 0;
+
+  VLOG(3)
+      << "@" << partitionKey_.taskId << " Intra-node transfer duration: "
+      << std::chrono::duration_cast<std::chrono::milliseconds>(duration).count()
+      << " ms ";
+  VLOG(3) << "@" << partitionKey_.taskId
+          << " Intra-node transfer throughput: " << throughput << " MByte/s";
+
+  VLOG(3) << "@" << partitionKey_.taskId
+          << " Intra-node transfer complete for sequence " << sequenceNumber_;
+
+  if (intraNodeAtEndPublished_) {
+    // This was the final atEnd marker, we're done
+    VLOG(3) << "@" << partitionKey_.taskId
+            << " Intra-node transfer: atEnd acknowledged, finishing";
+    setState(ServerState::Done);
+  } else {
+    // More data may be coming, continue transfer loop
+    this->sequenceNumber_++;
+    setState(ServerState::ReadyToTransfer);
+  }
+  communicator_->addToWorkQueue(getSelfPtr());
+}
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/UcxExchangeServer.h b/velox/experimental/ucx-exchange/UcxExchangeServer.h
new file mode 100644
index 00000000000..8e333d8bb19
--- /dev/null
+++ b/velox/experimental/ucx-exchange/UcxExchangeServer.h
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cudf/contiguous_split.hpp>
+#include <folly/Synchronized.h>
+#include <ucxx/api.h>
+#include <ucxx/utils/ucx.h>
+#include <velox/exec/Task.h>
+#include <velox/experimental/ucx-exchange/UcxOutputQueueManager.h>
+#include <chrono>
+#include <future>
+#include <memory>
+#include <tuple>
+#include "velox/common/Enums.h"
+#include "velox/experimental/ucx-exchange/CommElement.h"
+#include "velox/experimental/ucx-exchange/EndpointRef.h"
+#include "velox/experimental/ucx-exchange/PartitionKey.h"
+
+namespace facebook::velox::ucx_exchange {
+
+class UcxExchangeServer
+    : public CommElement,
+      public std::enable_shared_from_this<UcxExchangeServer> {
+ public:
+  // Public for logging and the VELOX_DEFINE_EMBEDDED_ENUM_NAME names map.
+  enum class ServerState : uint32_t {
+    Created,
+    ReadyToTransfer,
+    WaitingForDataFromQueue,
+    DataReady,
+    WaitingForSendComplete,
+    WaitingForIntraNodeRetrieve,
+    Done,
+  };
+
+  VELOX_DECLARE_EMBEDDED_ENUM_NAME(ServerState);
+
+  /// @brief Factory method to create a UcxExchangeServer.
+  /// @param communicator The Communicator instance.
+  /// @param endpointRef The endpoint reference for UCXX communication.
+  /// @param key The partition key identifying the data to serve.
+  /// @param isIntraNodeTransfer True if the source is on the same node,
+  ///        determined by checking if the peer's IP is in the local IP set.
+  static std::shared_ptr<UcxExchangeServer> create(
+      const std::shared_ptr<Communicator> communicator,
+      std::shared_ptr<EndpointRef> endpointRef,
+      const PartitionKey& key,
+      bool isIntraNodeTransfer);
+
+  void process() override;
+
+  void close() override;
+
+  std::string toString();
+
+  const PartitionKey& getPartitionKey() const {
+    return partitionKey_;
+  }
+
+  /// @brief Returns true if this server detected same-node with the source.
+  bool isIntraNodeTransfer() const {
+    return isIntraNodeTransfer_;
+  }
+
+ private:
+  explicit UcxExchangeServer(
+      const std::shared_ptr<Communicator> communicator,
+      std::shared_ptr<EndpointRef> endpointRef,
+      const PartitionKey& key,
+      bool isIntraNodeTransfer);
+
+  /// @return A shared pointer to itself.
+  std::shared_ptr<UcxExchangeServer> getSelfPtr();
+
+  /// @brief Sends metadata and data to the connected receiver.
+  void sendData();
+
+  /// @brief Completion handler after data has been sent.
+  void sendComplete(ucs_status_t status, std::shared_ptr<void> arg);
+
+  /// @brief Completion handler for intra-node transfer after source retrieves
+  /// data.
+  void onIntraNodeRetrieveComplete();
+
+  /// @brief Sets the new state of this exchange server using
+  /// sequential consistency. Logs transitions at VLOG(2).
+  /// @param newState the new state of the UcxExchangeServer.
+  void setState(ServerState newState);
+
+  /// @brief Returns the state.
+  ServerState getState() {
+    return state_.load(std::memory_order_seq_cst);
+  }
+
+  const PartitionKey partitionKey_;
+  const uint32_t
+      partitionKeyHash_; // A hash of above, used to create unique tags.
+
+  /// True if server and source are on the same node (determined by checking
+  /// if peer's actual IP is in the local IP set). When true, data is passed
+  /// via IntraNodeTransferRegistry instead of UCXX transfer.
+  bool isIntraNodeTransfer_{false};
+
+  std::atomic<ServerState> state_;
+  std::shared_ptr<cudf::packed_columns> dataPtr_{nullptr};
+  /// Protects dataPtr_. Must be recursive because sendData() holds the lock
+  /// when calling tagSend(), and for small messages UCX completes inline via
+  /// its fast-completion path, firing the sendComplete() callback on the same
+  /// thread while the lock is still held.
+  std::recursive_mutex dataMutex_;
+  std::atomic<bool> closed_{false};
+
+  /// Future for intra-node transfer - signaled when source retrieves data.
+  std::future<void> intraNodeRetrieveFuture_;
+
+  /// For intra-node transfer: true if the last published entry was atEnd.
+  bool intraNodeAtEndPublished_{false};
+
+  uint32_t sequenceNumber_{0};
+  uint32_t intraNodePollCount_{0};
+
+  // The outstanding requests - there can only be one outstanding request
+  // of each type at any point in time.
+  // NOTE: The request owns/holds references to the upcall function
+  // and must therefore exist until the upcall is done.
+  std::shared_ptr<ucxx::Request> metaRequest_{nullptr};
+  std::shared_ptr<ucxx::Request> dataRequest_{nullptr};
+
+  // Completed UCXX requests are kept alive here to prevent use-after-free.
+  // UCP's ucp_wireup_replay_pending_requests can fire callbacks on already-
+  // completed requests; if the ucxx::Request has been freed, the callback
+  // lambda is in freed memory and crashes. Retaining them here ensures the
+  // Request (and its callback lambda) stays valid for the lifetime of this
+  // server.
+  std::vector<std::shared_ptr<ucxx::Request>> completedRequests_;
+
+  std::chrono::time_point<std::chrono::high_resolution_clock> sendStart_;
+  std::size_t bytes_;
+
+  std::shared_ptr<UcxOutputQueueManager> queueMgr_;
+};
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/UcxExchangeSource.cpp b/velox/experimental/ucx-exchange/UcxExchangeSource.cpp
new file mode 100644
index 00000000000..d3507b2ce14
--- /dev/null
+++ b/velox/experimental/ucx-exchange/UcxExchangeSource.cpp
@@ -0,0 +1,818 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <thread>
+
+#include <cudf/contiguous_split.hpp>
+#include <folly/String.h>
+#include <folly/Uri.h>
+#include "velox/experimental/cudf/exec/GpuResources.h"
+#include "velox/experimental/cudf/exec/Utilities.h"
+#include "velox/experimental/ucx-exchange/IntraNodeTransferRegistry.h"
+#include "velox/experimental/ucx-exchange/UcxExchangeSource.h"
+
+using namespace facebook::velox::exec;
+namespace facebook::velox::ucx_exchange {
+
+namespace {
+const folly::F14FastMap<UcxExchangeSource::ReceiverState, std::string_view>&
+receiverStateNames() {
+  static const folly::F14FastMap<
+      UcxExchangeSource::ReceiverState,
+      std::string_view>
+      kNames = {
+          {UcxExchangeSource::ReceiverState::Created, "Created"},
+          {UcxExchangeSource::ReceiverState::WaitingForHandshakeComplete,
+           "WaitingForHandshakeComplete"},
+          {UcxExchangeSource::ReceiverState::WaitingForHandshakeResponse,
+           "WaitingForHandshakeResponse"},
+          {UcxExchangeSource::ReceiverState::ReadyToReceive, "ReadyToReceive"},
+          {UcxExchangeSource::ReceiverState::WaitingForMetadata,
+           "WaitingForMetadata"},
+          {UcxExchangeSource::ReceiverState::WaitingForData, "WaitingForData"},
+          {UcxExchangeSource::ReceiverState::WaitingForIntraNodeData,
+           "WaitingForIntraNodeData"},
+          {UcxExchangeSource::ReceiverState::Done, "Done"},
+      };
+  return kNames;
+}
+} // namespace
+
+VELOX_DEFINE_EMBEDDED_ENUM_NAME(
+    UcxExchangeSource,
+    ReceiverState,
+    receiverStateNames)
+
+void UcxExchangeSource::setState(ReceiverState newState) {
+  auto oldState = state_.exchange(newState, std::memory_order_seq_cst);
+  VLOG(2) << (isIntraNodeTransfer_ ? "[INTRA]" : "[REMOTE]") << " [ExSrc "
+          << toString() << " seq=" << sequenceNumber_ << "] "
+          << toName(oldState) << " -> " << toName(newState);
+}
+
+// This constructor is private.
+UcxExchangeSource::UcxExchangeSource(
+    const std::shared_ptr<Communicator> communicator,
+    std::string_view taskId,
+    std::string_view host,
+    uint16_t port,
+    const PartitionKey& partitionKey,
+    const std::shared_ptr<UcxExchangeQueue> queue)
+    : CommElement(communicator),
+      host_(host),
+      port_(port),
+      taskId_(taskId),
+      partitionKey_(partitionKey),
+      partitionKeyHash_(fnv1a_32(partitionKey_.toString())),
+      queue_(std::move(queue)) {
+  setState(ReceiverState::Created);
+}
+
+/*static*/
+std::shared_ptr<UcxExchangeSource> UcxExchangeSource::create(
+    std::string_view taskId,
+    std::string_view url,
+    const std::shared_ptr<UcxExchangeQueue>& queue) {
+  folly::Uri uri(url);
+  // Note that there is no distinct schema for the UCXX exchange.
+  // The approach is to ignore the schema and not check for HTTP or HTTPS.
+  // FIXME: Can't use the HTTP port as this conflicts with Prestissimo!
+  // For the time being, there's an ugly hack that just increases the port by 3.
+  const std::string host = uri.host();
+  int port = uri.port() + 3;
+  std::shared_ptr<Communicator> communicator = Communicator::getInstance();
+  auto key = extractTaskAndDestinationId(uri.path());
+  auto source = std::shared_ptr<UcxExchangeSource>(
+      new UcxExchangeSource(communicator, taskId, host, port, key, queue));
+  // register the exchange source with the communicator. This makes sure that
+  // "progress" is called.
+  communicator->registerCommElement(source);
+  VLOG(3) << source->toString()
+          << " creating UcxExchangeSource for url: " << url;
+  return source;
+}
+
+void UcxExchangeSource::process() {
+  if (closed_) {
+    // Driver thread called closed
+    cleanUp();
+    return;
+  }
+
+  switch (state_) {
+    case ReceiverState::Created: {
+      // Get the endpoint.
+      HostPort hp{host_, port_};
+      std::shared_ptr<UcxExchangeSource> selfPtr = getSelfPtr();
+      auto epRef = communicator_->assocEndpointRef(selfPtr, hp);
+      if (epRef) {
+        setEndpoint(epRef);
+        setStateIf(
+            ReceiverState::Created, ReceiverState::WaitingForHandshakeComplete);
+        sendHandshake();
+      } else {
+        // connection failed.
+        VLOG(0) << toString() << " Failed to connect to " << host_ << ":"
+                << std::to_string(port_);
+        deliverEndMarker();
+        setState(ReceiverState::Done);
+      }
+      communicator_->addToWorkQueue(getSelfPtr());
+    } break;
+    case ReceiverState::WaitingForHandshakeComplete:
+      // Waiting for handshake send completion is handled by callback.
+      break;
+    case ReceiverState::WaitingForHandshakeResponse:
+      // Waiting for HandshakeResponse is handled by callback.
+      break;
+    case ReceiverState::ReadyToReceive: {
+      // Backpressure: don't post the next receive if the consumer queue is
+      // overloaded. The source goes dormant (not in work queue) and will be
+      // woken by UcxExchangeClient::next() calling resumeFromBackpressure()
+      // when the queue drains below the low water mark.
+      //
+      // This creates natural backpressure: the server's tagSend for data
+      // will block at rendezvous until we post a matching tagRecv. For
+      // intra-node: the server's publish future won't resolve until we poll.
+      int32_t queueSize = queue_->size();
+      if (queueSize > kBackpressureHighWaterMark) {
+        if (!backpressureActive_.exchange(true, std::memory_order_acq_rel)) {
+          VLOG(1) << "[BACKPRESSURE] [ExSrc " << toString()
+                  << "] pausing, queueSize=" << queueSize
+                  << " > highWater=" << kBackpressureHighWaterMark;
+        }
+        // Go dormant — do NOT re-enqueue into work queue.
+        // UcxExchangeClient::next() will call resumeFromBackpressure().
+        break;
+      }
+
+      if (isIntraNodeTransfer_) {
+        // INTRA-NODE TRANSFER: Use registry instead of UCXX
+        setStateIf(
+            ReceiverState::ReadyToReceive,
+            ReceiverState::WaitingForIntraNodeData);
+        waitForIntraNodeData();
+      } else {
+        // REMOTE EXCHANGE: Use UCXX for metadata and data
+        setStateIf(
+            ReceiverState::ReadyToReceive, ReceiverState::WaitingForMetadata);
+        getMetadata();
+      }
+    } break;
+    case ReceiverState::WaitingForMetadata:
+      // Waiting for metadata is handled by an upcall from UCXX. Nothing to do
+      break;
+    case ReceiverState::WaitingForData:
+      // Waiting for data is handled by an upcall from UCXX. Nothing to do.
+      break;
+    case ReceiverState::WaitingForIntraNodeData:
+      // Poll for intra-node transfer data
+      waitForIntraNodeData();
+      break;
+    case ReceiverState::Done:
+      // We need to call clean-up in this thread to remove any state
+      cleanUp();
+      break;
+  }
+}
+
+void UcxExchangeSource::cleanUp() {
+  uint32_t value = static_cast<uint32_t>(getState());
+  if (value != static_cast<uint32_t>(ReceiverState::Done)) {
+    // Unexpected cleanup
+    VLOG(3) << toString()
+            << " In UcxExchangeSource::cleanUp state == " << value;
+  }
+
+  // Cancel any outstanding request. With weak_ptr callbacks, the callback
+  // will safely no-op if we're destroyed before it completes.
+  if (request_ && !request_->isCompleted()) {
+    // The Task has failed and we may need to cancel outstanding requests
+    request_->cancel();
+  }
+
+  // Move all requests to the Communicator's deferred list so the GPU
+  // buffers they reference (via their arg shared_ptr) stay alive until
+  // UCX has fully processed any in-flight operations.
+  if (communicator_) {
+    if (request_) {
+      communicator_->deferRequestCleanup(std::move(request_));
+    }
+    for (auto& req : completedRequests_) {
+      communicator_->deferRequestCleanup(std::move(req));
+    }
+    completedRequests_.clear();
+  }
+
+  if (endpointRef_) {
+    endpointRef_->removeCommElem(getSelfPtr());
+    endpointRef_ = nullptr;
+  }
+  if (communicator_) {
+    communicator_->unregister(getSelfPtr());
+  }
+}
+
+void UcxExchangeSource::close() {
+  // This is called by the driver thread so we need to be careful to
+  // indicate to the process thread that we are closing and
+  // let it do the actual cleaning up.
+
+  // Use memory_order_acq_rel to ensure proper synchronization with callbacks
+  // that check closed_ with memory_order_acquire.
+  bool expected = false;
+  bool desired = true;
+  if (!closed_.compare_exchange_strong(
+          expected, desired, std::memory_order_acq_rel)) {
+    return; // already closed.
+  }
+
+  VLOG(1) << toString() << " UcxExchangeSource::close called.";
+
+  // Guarantee the end marker is delivered before transitioning to Done.
+  deliverEndMarker();
+
+  // Let the Communicator progress thread do the actual clean-up.
+  setState(ReceiverState::Done);
+  communicator_->addToWorkQueue(getSelfPtr());
+}
+
+void UcxExchangeSource::resumeFromBackpressure() {
+  bool expected = true;
+  if (backpressureActive_.compare_exchange_strong(
+          expected, false, std::memory_order_acq_rel)) {
+    VLOG(1) << "[BACKPRESSURE] [ExSrc " << toString()
+            << "] resumed by consumer, queueSize=" << queue_->size();
+    communicator_->addToWorkQueue(getSelfPtr());
+  }
+}
+
+folly::F14FastMap<std::string, int64_t> UcxExchangeSource::stats() const {
+  VELOX_UNREACHABLE();
+}
+
+folly::F14FastMap<std::string, RuntimeMetric> UcxExchangeSource::metrics()
+    const {
+  folly::F14FastMap<std::string, RuntimeMetric> map;
+
+  // these metrics will be aggregated over all exchange sources of the same
+  // exchange client.
+  map["ucxExchangeSource.numPackedColumns"] = metrics_.numPackedColumns_;
+  map["ucxExchangeSource.totalBytes"] = metrics_.totalBytes_;
+  map["ucxExchangeSource.rttPerRequest"] = metrics_.rttPerRequest_;
+  return map;
+}
+
+// private methods ---
+PartitionKey UcxExchangeSource::extractTaskAndDestinationId(
+    std::string_view path) {
+  // The URL path has the form: /v1/task/<taskId>/results/<destinationId>"
+  std::vector<folly::StringPiece> components;
+  folly::split('/', path, components, true);
+
+  VELOX_CHECK_EQ(components[0], "v1");
+  VELOX_CHECK_EQ(components[1], "task");
+  VELOX_CHECK_EQ(components[3], "results");
+
+  uint32_t destinationId;
+  try {
+    destinationId = static_cast<uint32_t>(std::stoul(components[4].str()));
+  } catch (const std::exception& e) {
+    VELOX_UNSUPPORTED("Illegal destination in task URL: {}", path);
+  }
+
+  return PartitionKey{components[2].str(), destinationId};
+}
+
+std::shared_ptr<UcxExchangeSource> UcxExchangeSource::getSelfPtr() {
+  std::shared_ptr<UcxExchangeSource> ptr;
+  try {
+    ptr = shared_from_this();
+  } catch (std::bad_weak_ptr& exp) {
+    ptr = nullptr;
+  }
+  return ptr;
+}
+
+void UcxExchangeSource::enqueue(PackedTableWithStreamPtr data) {
+  std::vector<velox::ContinuePromise> queuePromises;
+  {
+    std::lock_guard<std::mutex> l(queue_->mutex());
+
+    queue_->enqueueLocked(std::move(data), queuePromises);
+  }
+  // wake up consumers of the UcxExchangeQueue
+  for (auto& promise : queuePromises) {
+    promise.setValue();
+  }
+}
+
+void UcxExchangeSource::deliverEndMarker() {
+  if (!registered_.load(std::memory_order_acquire)) {
+    // Never registered with queue -- don't deliver end marker to avoid
+    // spurious numCompleted_ increments.
+    return;
+  }
+  bool expected = false;
+  if (!endMarkerDelivered_.compare_exchange_strong(
+          expected, true, std::memory_order_acq_rel)) {
+    // Already delivered by another thread/path.
+    return;
+  }
+  VLOG(3) << toString() << " delivering end-of-stream marker to queue";
+  enqueue(nullptr);
+}
+
+void UcxExchangeSource::setEndpoint(std::shared_ptr<EndpointRef> endpointRef) {
+  endpointRef_ = std::move(endpointRef);
+}
+
+void UcxExchangeSource::sendHandshake() {
+  std::shared_ptr<HandshakeMsg> handshakeReq = std::make_shared<HandshakeMsg>();
+  handshakeReq->destination = partitionKey_.destination;
+  // Use sizeof(...) - 1 and explicitly null-terminate to prevent buffer
+  // overread if taskId is longer than the destination buffer.
+  strncpy(
+      handshakeReq->taskId,
+      partitionKey_.taskId.c_str(),
+      sizeof(handshakeReq->taskId) - 1);
+  handshakeReq->taskId[sizeof(handshakeReq->taskId) - 1] = '\0';
+  handshakeReq->workerId = communicator_->getWorkerId();
+
+  VLOG(3) << toString() << " Sending handshake with initial value: "
+          << partitionKey_.toString() << " to server";
+
+  // Create the handshake which will register client's existence with the server
+  ucxx::AmReceiverCallbackInfo info(
+      communicator_->kAmCallbackOwner, communicator_->kAmCallbackId);
+  // Use weak_ptr to prevent use-after-free if close() is called during callback
+  std::weak_ptr<UcxExchangeSource> weak = weak_from_this();
+  if (request_) {
+    completedRequests_.push_back(std::move(request_));
+  }
+  // Pass handshakeReq as the callback arg to keep the send buffer alive until
+  // the async amSend completes. UCXX stores it as shared_ptr<void> but the
+  // type-erased deleter still calls ~HandshakeMsg correctly.
+  request_ = endpointRef_->endpoint_->amSend(
+      handshakeReq.get(),
+      sizeof(*handshakeReq),
+      UCS_MEMORY_TYPE_HOST,
+      info,
+      false,
+      [weak](ucs_status_t status, std::shared_ptr<void> arg) {
+        if (auto self = weak.lock()) {
+          self->onHandshake(status, arg);
+        }
+      },
+      handshakeReq);
+}
+
+void UcxExchangeSource::onHandshake(
+    ucs_status_t status,
+    std::shared_ptr<void> /*arg*/) {
+  // arg holds the HandshakeMsg that was sent — it is unused here because this
+  // is a send completion callback (the outgoing data has already been
+  // transmitted). The parameter exists only because UCXX uses it as a lifetime
+  // handle; letting it go out of scope releases the send buffer.
+
+  // Check if close() was called - avoid processing if we're shutting down
+  if (closed_.load(std::memory_order_acquire)) {
+    VLOG(3) << toString() << " onHandshake called after close, ignoring";
+    deliverEndMarker();
+    return;
+  }
+  // Guard against replayed callbacks from UCP wireup replay.
+  if (getState() != ReceiverState::WaitingForHandshakeComplete) {
+    VLOG(2) << toString() << " onHandshake called in state "
+            << toName(getState()) << ", ignoring (possible UCXX replay)";
+    return;
+  }
+  if (status != UCS_OK) {
+    std::string errorMsg = fmt::format(
+        "Failed to send handshake to host {}:{}, task {}: {}",
+        host_,
+        port_,
+        partitionKey_.toString(),
+        ucs_status_string(status));
+    VLOG(0) << errorMsg;
+    queue_->setError(errorMsg);
+    deliverEndMarker();
+    setState(ReceiverState::Done);
+    communicator_->addToWorkQueue(getSelfPtr());
+  } else {
+    VLOG(3) << toString() << "+ onHandshake " << ucs_status_string(status);
+    // Now wait for the HandshakeResponse from the server
+    setStateIf(
+        ReceiverState::WaitingForHandshakeComplete,
+        ReceiverState::WaitingForHandshakeResponse);
+    receiveHandshakeResponse();
+  }
+}
+
+void UcxExchangeSource::getMetadata() {
+  // Use kMaxMetaBufSize to support tables with many columns.
+  // The sender allocates exact size needed; receiver pre-allocates max.
+  auto metadataReq = std::make_shared<std::vector<uint8_t>>(kMaxMetaBufSize);
+  uint64_t metadataTag = getMetadataTag(partitionKeyHash_, sequenceNumber_);
+
+  VLOG(3) << toString()
+          << " waiting for metadata for chunk: " << sequenceNumber_
+          << " using tag: " << std::hex << metadataTag << std::dec;
+
+  // Use weak_ptr to prevent use-after-free if close() is called during callback
+  std::weak_ptr<UcxExchangeSource> weak = weak_from_this();
+  if (request_) {
+    completedRequests_.push_back(std::move(request_));
+  }
+  request_ = endpointRef_->endpoint_->tagRecv(
+      reinterpret_cast<void*>(metadataReq->data()),
+      kMaxMetaBufSize,
+      ucxx::Tag{metadataTag},
+      ucxx::TagMaskFull,
+      false,
+      [weak](ucs_status_t status, std::shared_ptr<void> arg) {
+        if (auto self = weak.lock()) {
+          self->onMetadata(status, arg);
+        }
+      },
+      metadataReq);
+}
+
+void UcxExchangeSource::onMetadata(
+    ucs_status_t status,
+    std::shared_ptr<void> arg) {
+  // Check if close() was called - avoid processing if we're shutting down
+  if (closed_.load(std::memory_order_acquire)) {
+    VLOG(3) << toString() << " onMetadata called after close, ignoring";
+    deliverEndMarker();
+    return;
+  }
+  // Guard against replayed callbacks from UCP wireup replay.
+  if (getState() != ReceiverState::WaitingForMetadata) {
+    VLOG(2) << toString() << " onMetadata called in state "
+            << toName(getState()) << ", ignoring (possible UCXX replay)";
+    return;
+  }
+  VLOG(3) << toString() << " + onMetadata " << ucs_status_string(status);
+
+  if (status != UCS_OK) {
+    std::string errorMsg = fmt::format(
+        "Failed to receive metadata from host {}:{}, task {}: {}",
+        host_,
+        port_,
+        partitionKey_.toString(),
+        ucs_status_string(status));
+    VLOG(0) << errorMsg;
+    queue_->setError(errorMsg);
+    deliverEndMarker();
+    setState(ReceiverState::Done);
+    communicator_->addToWorkQueue(getSelfPtr());
+  } else {
+    VELOX_CHECK_NOT_NULL(arg, "Didn't get metadata");
+
+    // arg contains the actual serialized metadata, deserialize the metadata
+    std::shared_ptr<std::vector<uint8_t>> metadataMsg =
+        std::static_pointer_cast<std::vector<uint8_t>>(arg);
+
+    auto ptr = std::make_shared<DataAndMetadata>();
+
+    ptr->metadata =
+        std::move(MetadataMsg::deserializeMetadataMsg(metadataMsg->data()));
+
+    VLOG(3) << toString()
+            << " Datasize bytes == " << ptr->metadata.dataSizeBytes;
+
+    if (ptr->metadata.atEnd) {
+      // It seems that all data has been transferred
+      atEnd_ = true;
+      // enqueue a nullpointer to mark the end for this source.
+      VLOG(3) << "There is no more data to transfer for " << toString();
+      deliverEndMarker();
+      setStateIf(ReceiverState::WaitingForMetadata, ReceiverState::Done);
+      communicator_->addToWorkQueue(getSelfPtr());
+      // jump out of this function.
+      return;
+    }
+
+    // REMOTE EXCHANGE PATH: Allocate buffer and receive via UCXX
+    // Get a stream from the global stream pool
+    auto stream =
+        facebook::velox::cudf_velox::cudfGlobalStreamPool().get_stream();
+    // Store the stream in the DataAndMetadata struct so it can be used later
+    // in onData() when creating the PackedTableWithStream.
+    ptr->stream = stream;
+    try {
+      ptr->dataBuf = std::make_unique<rmm::device_buffer>(
+          ptr->metadata.dataSizeBytes, stream);
+    } catch (const rmm::bad_alloc& e) {
+      VLOG(0) << toString() << " *** RMM  failed to allocate: " << e.what();
+      queue_->setError("Failed to alloc GPU memory"); // Let the operator know
+                                                      // via the queue
+      deliverEndMarker();
+      setState(ReceiverState::Done);
+      communicator_->addToWorkQueue(getSelfPtr());
+      return;
+    }
+
+    // sync after allocating.
+    stream.synchronize();
+
+    VLOG(3) << toString() << " Allocated " << ptr->metadata.dataSizeBytes
+            << " bytes of device memory";
+
+    // Initiate the transfer of the actual data from GPU-2-GPU
+    uint64_t dataTag = getDataTag(partitionKeyHash_, sequenceNumber_);
+    VLOG(3) << toString() << " waiting for data for chunk: " << sequenceNumber_
+            << " using tag: " << std::hex << dataTag << std::dec;
+
+    if (!setStateIf(
+            ReceiverState::WaitingForMetadata, ReceiverState::WaitingForData)) {
+      VLOG(1) << toString() << " onMetadata Invalid previous state ";
+      return;
+    }
+    // Use weak_ptr to prevent use-after-free if close() is called during
+    // callback
+    std::weak_ptr<UcxExchangeSource> weak = weak_from_this();
+    if (request_) {
+      completedRequests_.push_back(std::move(request_));
+    }
+    request_ = endpointRef_->endpoint_->tagRecv(
+        ptr->dataBuf->data(),
+        ptr->metadata.dataSizeBytes,
+        ucxx::Tag{dataTag},
+        ucxx::TagMaskFull,
+        false,
+        [weak](ucs_status_t status, std::shared_ptr<void> arg) {
+          if (auto self = weak.lock()) {
+            self->onData(status, arg);
+          }
+        },
+        ptr // DataAndMetadata
+    );
+  }
+}
+
+void UcxExchangeSource::onData(ucs_status_t status, std::shared_ptr<void> arg) {
+  // Check if close() was called - avoid processing if we're shutting down
+  if (closed_.load(std::memory_order_acquire)) {
+    VLOG(3) << toString() << " onData called after close, ignoring";
+    deliverEndMarker();
+    return;
+  }
+  // Guard against replayed callbacks from UCP wireup replay.
+  if (getState() != ReceiverState::WaitingForData) {
+    VLOG(2) << toString() << " onData called in state " << toName(getState())
+            << ", ignoring (possible UCXX replay)";
+    return;
+  }
+  VLOG(3) << toString() << " + onData " << ucs_status_string(status);
+
+  if (status != UCS_OK) {
+    std::string errorMsg = fmt::format(
+        "Failed to receive data from host {}:{}, task {}: {}",
+        host_,
+        port_,
+        partitionKey_.toString(),
+        ucs_status_string(status));
+    VLOG(0) << toString() << errorMsg;
+    queue_->setError(errorMsg);
+    deliverEndMarker();
+    setState(ReceiverState::Done);
+  } else {
+    VLOG(3) << toString() << "+ onData " << ucs_status_string(status)
+            << " got chunk: " << sequenceNumber_;
+
+    this->sequenceNumber_++;
+
+    std::shared_ptr<DataAndMetadata> ptr =
+        std::static_pointer_cast<DataAndMetadata>(arg);
+
+    metrics_.numPackedColumns_.addValue(1);
+    metrics_.totalBytes_.addValue(ptr->metadata.dataSizeBytes);
+
+    // Create packed_columns from the received metadata and data buffer
+    cudf::packed_columns packedCols(
+        std::move(ptr->metadata.cudfMetadata), std::move(ptr->dataBuf));
+
+    // Unpack to get the table_view and create a packed_table
+    cudf::table_view tableView = cudf::unpack(packedCols);
+    auto packedTable = std::make_unique<cudf::packed_table>(
+        cudf::packed_table{tableView, std::move(packedCols)});
+
+    // Bundle the packed_table with the stream that was used for allocation
+    auto data = std::make_unique<PackedTableWithStream>(
+        std::move(packedTable), ptr->stream);
+
+    enqueue(std::move(data));
+    setStateIf(ReceiverState::WaitingForData, ReceiverState::ReadyToReceive);
+  }
+  communicator_->addToWorkQueue(getSelfPtr());
+}
+
+void UcxExchangeSource::receiveHandshakeResponse() {
+  auto responseBuffer = std::make_shared<HandshakeResponse>();
+  uint64_t responseTag = getHandshakeResponseTag(partitionKeyHash_);
+
+  VLOG(3) << toString()
+          << " waiting for HandshakeResponse with tag: " << std::hex
+          << responseTag << std::dec;
+
+  // Use weak_ptr to prevent use-after-free if close() is called during callback
+  std::weak_ptr<UcxExchangeSource> weak = weak_from_this();
+  if (request_) {
+    completedRequests_.push_back(std::move(request_));
+  }
+  request_ = endpointRef_->endpoint_->tagRecv(
+      responseBuffer.get(),
+      sizeof(*responseBuffer),
+      ucxx::Tag{responseTag},
+      ucxx::TagMaskFull,
+      false,
+      [weak](ucs_status_t status, std::shared_ptr<void> arg) {
+        if (auto self = weak.lock()) {
+          self->onHandshakeResponse(status, arg);
+        }
+      },
+      responseBuffer);
+}
+
+void UcxExchangeSource::onHandshakeResponse(
+    ucs_status_t status,
+    std::shared_ptr<void> arg) {
+  // Check if close() was called - avoid processing if we're shutting down
+  if (closed_.load(std::memory_order_acquire)) {
+    VLOG(3) << toString()
+            << " onHandshakeResponse called after close, ignoring";
+    deliverEndMarker();
+    return;
+  }
+  // Guard against replayed callbacks from UCP wireup replay.
+  if (getState() != ReceiverState::WaitingForHandshakeResponse) {
+    VLOG(2) << toString() << " onHandshakeResponse called in state "
+            << toName(getState()) << ", ignoring (possible UCXX replay)";
+    return;
+  }
+
+  if (status != UCS_OK) {
+    std::string errorMsg = fmt::format(
+        "Failed to receive HandshakeResponse from host {}:{}, task {}: {}",
+        host_,
+        port_,
+        partitionKey_.toString(),
+        ucs_status_string(status));
+    VLOG(0) << errorMsg;
+    queue_->setError(errorMsg);
+    deliverEndMarker();
+    setState(ReceiverState::Done);
+    communicator_->addToWorkQueue(getSelfPtr());
+    return;
+  }
+
+  std::shared_ptr<HandshakeResponse> response =
+      std::static_pointer_cast<HandshakeResponse>(arg);
+
+  isIntraNodeTransfer_ = response->isIntraNodeTransfer;
+
+  VLOG(3) << toString() << " + onHandshakeResponse isIntraNodeTransfer="
+          << isIntraNodeTransfer_;
+
+  setStateIf(
+      ReceiverState::WaitingForHandshakeResponse,
+      ReceiverState::ReadyToReceive);
+  communicator_->addToWorkQueue(getSelfPtr());
+}
+
+void UcxExchangeSource::waitForIntraNodeData() {
+  // Check if close() was called
+  if (closed_.load(std::memory_order_acquire)) {
+    VLOG(3) << toString()
+            << " waitForIntraNodeData called after close, ignoring";
+    deliverEndMarker();
+    return;
+  }
+
+  IntraNodeTransferKey key{
+      partitionKey_.taskId, partitionKey_.destination, sequenceNumber_};
+
+  auto result = IntraNodeTransferRegistry::getInstance()->poll(key);
+
+  if (!result.has_value()) {
+    // Data not ready yet, re-queue to try again
+    ++intraNodePollCount_;
+    if (intraNodePollCount_ % 100 == 0) {
+      VLOG(2) << "[INTRA] [ExSrc " << toString() << " seq=" << sequenceNumber_
+              << "] still polling for data, polls=" << intraNodePollCount_;
+    }
+    communicator_->addToWorkQueue(getSelfPtr());
+    return;
+  }
+
+  intraNodePollCount_ = 0;
+  onIntraNodeData(std::move(result->data), result->atEnd);
+}
+
+void UcxExchangeSource::onIntraNodeData(
+    std::shared_ptr<cudf::packed_columns> data,
+    bool atEnd) {
+  // Check if close() was called
+  if (closed_.load(std::memory_order_acquire)) {
+    VLOG(3) << toString() << " onIntraNodeData called after close, ignoring";
+    deliverEndMarker();
+    return;
+  }
+
+  if (atEnd) {
+    // End of stream
+    atEnd_ = true;
+    VLOG(3) << toString() << " Intra-node transfer: end of stream";
+    deliverEndMarker();
+    setState(ReceiverState::Done);
+
+    communicator_->addToWorkQueue(getSelfPtr());
+    return;
+  }
+
+  if (!data) {
+    // Error - should not happen if atEnd is false
+    std::string errorMsg = fmt::format(
+        "Intra-node transfer data is null for task {}, dest {}, seq {}",
+        partitionKey_.taskId,
+        partitionKey_.destination,
+        sequenceNumber_);
+    VLOG(0) << toString() << " " << errorMsg;
+    queue_->setError(errorMsg);
+    deliverEndMarker();
+    setState(ReceiverState::Done);
+    communicator_->addToWorkQueue(getSelfPtr());
+    return;
+  }
+
+  VLOG(3) << toString()
+          << " Intra-node transfer: received data for seq=" << sequenceNumber_
+          << " size=" << data->gpu_data->size();
+
+  metrics_.numPackedColumns_.addValue(1);
+  metrics_.totalBytes_.addValue(data->gpu_data->size());
+
+  // Convert packed_columns to PackedTableWithStream for the queue.
+  // Create packed_columns from the shared data.
+  cudf::packed_columns packedCols(
+      std::move(data->metadata), std::move(data->gpu_data));
+
+  // Unpack to get the table_view and create a packed_table
+  cudf::table_view tableView = cudf::unpack(packedCols);
+  auto packedTable = std::make_unique<cudf::packed_table>(
+      cudf::packed_table{tableView, std::move(packedCols)});
+
+  // Get a stream from the pool so downstream cuDF operations on this data
+  // run on a dedicated stream, not the default stream. The producer already
+  // synchronized before enqueuing, so the GPU data is ready. This matches
+  // the inter-node (UCX) receive path which also allocates a pool stream.
+  auto stream =
+      facebook::velox::cudf_velox::cudfGlobalStreamPool().get_stream();
+  auto tableWithStream =
+      std::make_unique<PackedTableWithStream>(std::move(packedTable), stream);
+
+  enqueue(std::move(tableWithStream));
+
+  this->sequenceNumber_++;
+  setStateIf(
+      ReceiverState::WaitingForIntraNodeData, ReceiverState::ReadyToReceive);
+  communicator_->addToWorkQueue(getSelfPtr());
+}
+
+bool UcxExchangeSource::setStateIf(
+    UcxExchangeSource::ReceiverState expected,
+    UcxExchangeSource::ReceiverState desired) {
+  ReceiverState exp = expected;
+  // since spurious failures can happen even if state_ == expected, we need
+  // to do this in a loop.
+  while (!state_.compare_exchange_strong(
+      exp, desired, std::memory_order_acq_rel, std::memory_order_relaxed)) {
+    if (exp != expected) {
+      // no spurious failure, state isn't what we've expected.
+      return false;
+    }
+    // spurious failure.
+    exp = expected; // reset for the next try
+  }
+  VLOG(2) << (isIntraNodeTransfer_ ? "[INTRA]" : "[REMOTE]") << " [ExSrc "
+          << toString() << " seq=" << sequenceNumber_ << "] "
+          << toName(expected) << " -> " << toName(desired);
+  return true;
+}
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/UcxExchangeSource.h b/velox/experimental/ucx-exchange/UcxExchangeSource.h
new file mode 100644
index 00000000000..0c9d0a80046
--- /dev/null
+++ b/velox/experimental/ucx-exchange/UcxExchangeSource.h
@@ -0,0 +1,305 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/common/Enums.h"
+#include "velox/common/base/RuntimeMetrics.h"
+#include "velox/exec/Exchange.h"
+#include "velox/experimental/ucx-exchange/CommElement.h"
+#include "velox/experimental/ucx-exchange/Communicator.h"
+#include "velox/experimental/ucx-exchange/EndpointRef.h"
+#include "velox/experimental/ucx-exchange/PartitionKey.h"
+#include "velox/experimental/ucx-exchange/UcxExchangeProtocol.h"
+#include "velox/experimental/ucx-exchange/UcxExchangeQueue.h"
+
+#include <cuda.h>
+#include <cuda_runtime.h>
+#include <ucxx/api.h>
+#include <ucxx/utils/ucx.h>
+
+#include <rmm/cuda_stream_pool.hpp>
+#include <rmm/cuda_stream_view.hpp>
+#include <rmm/mr/cuda_memory_resource.hpp>
+#include <rmm/mr/device_memory_resource.hpp>
+#include <rmm/mr/pool_memory_resource.hpp>
+
+namespace facebook::velox::ucx_exchange {
+
+struct UcxExchangeMetrics {
+  UcxExchangeMetrics()
+      : numPackedColumns_(RuntimeMetric(RuntimeCounter::Unit::kNone)),
+        totalBytes_(RuntimeCounter::Unit::kBytes),
+        rttPerRequest_(RuntimeMetric(RuntimeCounter::Unit::kNanos)) {}
+  RuntimeMetric numPackedColumns_; // total number of packed columns received.
+  RuntimeMetric totalBytes_; // total number of bytes received
+  RuntimeMetric rttPerRequest_;
+};
+
+/// The UcxExchangeSource is the client that communicates with the remote
+/// UcxExchangeServer. There is a distinct instance for every remoteTask. It
+/// encapsulates the client side of the transport layer initiating communication
+/// and handling callbacks.
+/// The higher layer  initiates the transfer of a single via calling request
+/// CudfVector by calling UcxExchangeSource::request. The transfer of one
+/// CudfVector involves two transport exchanges
+/// - tx the metadata
+/// - tx the data
+/// The higher layer needs to call for each transfer
+
+class UcxExchangeSource
+    : public CommElement,
+      public std::enable_shared_from_this<UcxExchangeSource> {
+ public:
+  // Public for logging and the VELOX_DEFINE_EMBEDDED_ENUM_NAME names map.
+  enum class ReceiverState : uint32_t {
+    Created,
+    WaitingForHandshakeComplete,
+    WaitingForHandshakeResponse,
+    ReadyToReceive,
+    WaitingForMetadata,
+    WaitingForData,
+    WaitingForIntraNodeData,
+    Done,
+  };
+
+  VELOX_DECLARE_EMBEDDED_ENUM_NAME(ReceiverState);
+
+  virtual ~UcxExchangeSource() = default;
+
+  // factory method to create a UCX exchange source.
+  static std::shared_ptr<UcxExchangeSource> create(
+      std::string_view taskId,
+      std::string_view url,
+      const std::shared_ptr<UcxExchangeQueue>& queue);
+
+  bool supportsMetrics() const {
+    return true;
+  }
+
+  /// @brief Advances the UCXX communication that was started by issuing
+  /// "request"
+  void process() override;
+
+  /// Close the exchange source. May be called before all data
+  /// has been received and processed. This can happen in case
+  /// of an error or an operator like Limit aborting the query
+  /// once it received enough data.
+  void close();
+
+  /// @brief Marks this source as registered with the exchange queue.
+  /// Must be called after addSourceLocked() increments numSources_ for this
+  /// source. Without this, deliverEndMarker() will not enqueue the nullptr
+  /// (preventing spurious numCompleted_ increments for unregistered sources).
+  void setRegistered() {
+    registered_.store(true, std::memory_order_release);
+  }
+
+  /// @brief Called by UcxExchangeClient::next() on the consumer (driver)
+  /// thread to wake up this source after it went dormant due to backpressure.
+  /// Uses CAS to ensure exactly one wake-up per dormant period.
+  void resumeFromBackpressure();
+
+  // Backpressure thresholds. Public so UcxExchangeClient can use them.
+  static constexpr int32_t kBackpressureHighWaterMark = 32;
+  static constexpr int32_t kBackpressureLowWaterMark = 16;
+
+  // Returns runtime statistics. ExchangeSource is expected to report
+  // background CPU time by including a runtime metric named
+  // ExchangeClient::kBackgroundCpuTimeMs.
+  folly::F14FastMap<std::string, int64_t> stats() const;
+
+  /// Returns runtime statistics. ExchangeSource is expected to report
+  /// Specify units of individual counters in ExchangeSource.
+  /// for an example: 'totalBytes ：count: 9, sum: 11.17GB, max: 1.39GB,
+  /// min:  1.16GB'
+  folly::F14FastMap<std::string, RuntimeMetric> metrics() const;
+
+  std::string toString() const {
+    std::stringstream out;
+    out << "@" << taskId_ << " - @" << partitionKey_.toString();
+    return out.str();
+  }
+
+  folly::dynamic toJson() const {
+    folly::dynamic obj = folly::dynamic::object;
+    obj["remoteTaskId"] = partitionKey_.taskId;
+    obj["destination"] = partitionKey_.destination;
+    obj["closed"] = std::to_string(closed_);
+    return obj;
+  }
+
+ private:
+  struct DataAndMetadata {
+    MetadataMsg metadata;
+    std::unique_ptr<rmm::device_buffer> dataBuf;
+    rmm::cuda_stream_view stream; // The stream used to allocate dataBuf
+  };
+
+  /// @brief The constructor is private in order to ensure that exchange sources
+  /// are always generated through a shared pointer. This ensures that
+  /// shared_from_this works properly.
+  /// @param taskId The local task identifier
+  /// @param host The hostname of the upstream UcxExchangeServer
+  /// @param port The portnumber of the upstream UcxExchangeServer
+  /// @param partitionKey the partition identifier that the remote task is
+  /// writing to
+  /// @param queue the queue of packed tables that we write to when data is
+  /// available
+  explicit UcxExchangeSource(
+      const std::shared_ptr<Communicator> communicator,
+      std::string_view taskId,
+      std::string_view host,
+      uint16_t port,
+      const PartitionKey& partitionKey,
+      const std::shared_ptr<UcxExchangeQueue> queue);
+
+  // Extracts taskId and destinationId from the path part of the task URL
+  static PartitionKey extractTaskAndDestinationId(std::string_view path);
+
+  /// @return A shared pointer to itself.
+  std::shared_ptr<UcxExchangeSource> getSelfPtr();
+
+  // Put the received data into the exchange queue.
+  void enqueue(PackedTableWithStreamPtr data);
+
+  /// @brief Sets the endpoint for this receiver.
+  void setEndpoint(std::shared_ptr<EndpointRef> endpointRef);
+
+  /// @brief Sends a handshake request to the server. The endpoint must exist.
+  void sendHandshake();
+
+  /// @brief Called by the transport layer when handshake is completed
+  /// @param status indication by transport layer of transfer status
+  /// @param arg NOT USED at the moment
+  void onHandshake(ucs_status_t status, std::shared_ptr<void> arg);
+
+  /// @brief Waits for metadata and installs the onMetadata callback.
+  void getMetadata();
+
+  /// @brief Called by the transport layer when data is available
+  /// @param status indication by transport layer of transfer status
+  /// @param arg the serialized form of the metadata
+  void onMetadata(ucs_status_t status, std::shared_ptr<void> arg);
+
+  /// @brief Called by the transport layer when data is available
+  /// @param status indication by transport layer of transfer status
+  /// @param arg
+  void onData(ucs_status_t status, std::shared_ptr<void> arg);
+
+  /// @brief Initiates receiving the HandshakeResponse from server.
+  void receiveHandshakeResponse();
+
+  /// @brief Called when HandshakeResponse is received from server.
+  /// @param status indication by transport layer of transfer status
+  /// @param arg The HandshakeResponse data
+  void onHandshakeResponse(ucs_status_t status, std::shared_ptr<void> arg);
+
+  /// @brief For intra-node transfer: initiates waiting for data from registry.
+  void waitForIntraNodeData();
+
+  /// @brief For intra-node transfer: handles data retrieved from registry.
+  /// @param data The packed_columns from registry (nullptr if atEnd or error)
+  /// @param atEnd True if this is end-of-stream
+  void onIntraNodeData(std::shared_ptr<cudf::packed_columns> data, bool atEnd);
+
+  /// @brief Sets the new state of this exchange source using
+  /// sequential consistency. Logs transitions at VLOG(2).
+  /// @param newState the new state of the UcxExchangeSource.
+  void setState(ReceiverState newState);
+
+  /// @brief Returns the state.
+  ReceiverState getState() {
+    return state_.load(std::memory_order_seq_cst);
+  }
+
+  // Removes the state associated with the source, called by the state-machine.
+  void cleanUp();
+
+  /// @brief Delivers the nullptr end-of-stream marker to the queue exactly
+  /// once. Safe to call from any thread. Uses atomic CAS on
+  /// endMarkerDelivered_ to guarantee at-most-once delivery.
+  /// Returns early without enqueuing if the source was never registered
+  /// with the queue (i.e., registered_ is false).
+  void deliverEndMarker();
+
+  /// @brief Sets the state to "desired" if and only if the current
+  /// state is "expected".
+  /// @param expected The expected state
+  /// @param desired The desired state
+  /// @return Returns true if state was changed, false otherwise.
+  bool setStateIf(ReceiverState expected, ReceiverState desired);
+
+  // The connection parameters
+  const std::string host_;
+  uint16_t port_;
+  const std::string taskId_;
+
+  const PartitionKey partitionKey_;
+  const uint32_t
+      partitionKeyHash_; // A hash of above, used to create unique tags.
+
+  std::atomic<ReceiverState> state_;
+
+  uint32_t sequenceNumber_{0};
+  uint32_t intraNodePollCount_{0};
+
+  // The shared queue of packed tables that all UcxExchangeSources write to
+  const std::shared_ptr<UcxExchangeQueue> queue_{nullptr};
+  std::atomic<bool> closed_{false};
+  bool atEnd_{false}; // set when "atEnd" is being received.
+
+  /// @brief Guards exactly-once delivery of the nullptr end-of-stream marker.
+  /// Only one thread can win the CAS and call enqueue(nullptr).
+  std::atomic<bool> endMarkerDelivered_{false};
+
+  /// @brief True only after addSourceLocked() has been called for this source.
+  /// Prevents deliverEndMarker() from incrementing numCompleted_ for sources
+  /// that were never registered with the queue (e.g., created after client
+  /// close). Atomic because setRegistered() is called on the driver thread
+  /// while deliverEndMarker() reads it on the Communicator thread.
+  std::atomic<bool> registered_{false};
+
+  /// True if the server detected that this source is on the same node.
+  /// Set from the isIntraNodeTransfer flag in HandshakeResponse, which the
+  /// server determines by comparing this source's listener address (sent in
+  /// HandshakeMsg) with its own Communicator's listener address.
+  /// When true, intra-node transfer optimizations bypass UCXX transfers.
+  bool isIntraNodeTransfer_{false};
+
+  // Backpressure: when queue exceeds kBackpressureHighWaterMark, the source
+  // goes dormant. The consumer thread wakes it via resumeFromBackpressure()
+  // when the queue drains to kBackpressureLowWaterMark.
+  std::atomic<bool> backpressureActive_{false};
+
+  // Some metrics/counters:
+  UcxExchangeMetrics metrics_;
+
+  // The outstanding request - there can only be one outstanding request
+  // at any point in time. Used for handshake, metadata and data.
+  // NOTE: The request owns/holds a reference to the upcall function
+  // and must therefore exist until the upcall is done.
+  std::shared_ptr<ucxx::Request> request_{nullptr};
+
+  // Completed UCXX requests are kept alive here to prevent use-after-free.
+  // UCP's ucp_wireup_replay_pending_requests can fire callbacks on already-
+  // completed requests; if the ucxx::Request has been freed, the callback
+  // lambda is in freed memory and crashes. Retaining them here ensures the
+  // Request (and its callback lambda) stays valid for the lifetime of this
+  // source.
+  std::vector<std::shared_ptr<ucxx::Request>> completedRequests_;
+};
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/UcxOutputQueueManager.cpp b/velox/experimental/ucx-exchange/UcxOutputQueueManager.cpp
new file mode 100644
index 00000000000..e81471a5b4f
--- /dev/null
+++ b/velox/experimental/ucx-exchange/UcxOutputQueueManager.cpp
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Assisted by watsonx Code Assistant
+#include "velox/experimental/ucx-exchange/UcxOutputQueueManager.h"
+#include <cudf/detail/nvtx/ranges.hpp>
+#include <cudf/io/types.hpp>
+#include <cudf/table/table.hpp>
+#include <rmm/cuda_stream_view.hpp>
+#include <rmm/exec_policy.hpp>
+#include "velox/experimental/ucx-exchange/IntraNodeTransferRegistry.h"
+
+namespace facebook::velox::ucx_exchange {
+
+/* static */
+std::shared_ptr<UcxOutputQueueManager> UcxOutputQueueManager::getInstanceRef() {
+  // In C++11, the static local variable is guaranteed to only be initialized
+  // once even in a multi-threaded context.
+  static std::shared_ptr<UcxOutputQueueManager> instance =
+      std::make_shared<UcxOutputQueueManager>();
+  return instance;
+}
+
+void UcxOutputQueueManager::initializeTask(
+    std::shared_ptr<exec::Task> task,
+    core::PartitionedOutputNode::Kind kind,
+    int numDestinations,
+    int numDrivers) {
+  const auto& taskId = task->taskId();
+  queues_.withLock([&](auto& queues) {
+    auto it = queues.find(taskId);
+    if (it == queues.end()) {
+      queues[taskId] = std::make_shared<UcxOutputQueue>(
+          std::move(task), numDestinations, numDrivers, kind);
+    } else {
+      if (!it->second->initialize(task, numDestinations, numDrivers, kind)) {
+        VELOX_FAIL(
+            "Registering a cudf output queue for pre-existing taskId {}",
+            taskId);
+      }
+    }
+  });
+  // Clear any stale "removed" state so that getData() calls after this
+  // initializeTask() create proper placeholder queues if needed.
+  removedTasks_.withLock([&](auto& removed) { removed.erase(taskId); });
+  // Clear any stale "cancelled" state in the intra-node registry so
+  // that the cancelledTasks_ set doesn't grow unboundedly across queries.
+  IntraNodeTransferRegistry::getInstance()->clearCancelledTask(taskId);
+}
+
+void UcxOutputQueueManager::updateOutputBuffers(
+    std::string_view taskId,
+    int numBuffers,
+    bool noMoreBuffers) {
+  getQueue(taskId)->updateOutputBuffers(numBuffers, noMoreBuffers);
+}
+
+void UcxOutputQueueManager::enqueue(
+    std::string_view taskId,
+    int destination,
+    std::unique_ptr<cudf::packed_columns> txData,
+    int numRows) {
+  getQueue(taskId)->enqueue(destination, std::move(txData), numRows);
+}
+
+bool UcxOutputQueueManager::checkBlocked(
+    std::string_view taskId,
+    ContinueFuture* future) {
+  return getQueue(taskId)->checkBlocked(future);
+}
+
+void UcxOutputQueueManager::noMoreData(std::string_view taskId) {
+  getQueue(taskId)->noMoreData();
+}
+
+bool UcxOutputQueueManager::isFinished(std::string_view taskId) {
+  return getQueue(taskId)->isFinished();
+}
+
+void UcxOutputQueueManager::deleteResults(
+    std::string_view taskId,
+    int destination) {
+  if (auto queue = getQueueIfExists(taskId)) {
+    queue->deleteResults(destination);
+  }
+}
+
+void UcxOutputQueueManager::getData(
+    std::string_view taskId,
+    int destination,
+    UcxDataAvailableCallback notify) {
+  std::shared_ptr<UcxOutputQueue> outputQueue;
+  bool taskRemoved = false;
+  std::string taskIdStr{taskId};
+  queues_.withLock([&](auto& queues) {
+    auto it = queues.find(taskIdStr);
+    if (it == queues.end()) {
+      // Check if the task was already removed. If so, don't re-create a
+      // placeholder — the task is dead and any server calling getData() is a
+      // stale leftover. Re-creating would produce an undersized queue that
+      // crashes when deleteResults() is called for other destinations.
+      if (removedTasks_.withLock(
+              [&](auto& removed) { return removed.count(taskIdStr) > 0; })) {
+        VLOG(2) << "[QUEUE-MGR] task=" << taskId << " dest=" << destination
+                << " getData ignored (task already removed)";
+        taskRemoved = true;
+        return;
+      }
+      // create the queue structures such that the notify callback can be
+      // stored. It will be later initialized once the task is being created.
+      VLOG(2)
+          << "[QUEUE-MGR] task=" << taskId << " dest=" << destination
+          << " creating placeholder queue (server arrived before task init)";
+      outputQueue = std::make_shared<UcxOutputQueue>(nullptr, destination, 0);
+      queues[taskIdStr] = outputQueue;
+    } else {
+      // queue exists.
+      outputQueue = it->second;
+    }
+  });
+  if (taskRemoved) {
+    // Fire callback immediately with nullptr to signal end-of-stream.
+    notify(nullptr, {});
+    return;
+  }
+  // outside of lock. Queue must exist.
+  // get the data or install the notify callback.
+  outputQueue->getData(destination, notify);
+}
+
+bool UcxOutputQueueManager::canUseIntraNode(std::string_view taskId) {
+  auto queue = getQueueIfExists(taskId);
+  return queue && queue->isInitialized() &&
+      queue->kind() != core::PartitionedOutputNode::Kind::kBroadcast;
+}
+
+void UcxOutputQueueManager::removeTask(std::string_view taskId) {
+  std::string taskIdStr{taskId};
+  auto queue =
+      queues_.withLock([&](auto& queues) -> std::shared_ptr<UcxOutputQueue> {
+        auto it = queues.find(taskIdStr);
+        if (it == queues.end()) {
+          // Already removed. Clear any stale "removed" state so the task ID
+          // can be reused.
+          removedTasks_.withLock(
+              [&](auto& removed) { removed.erase(taskIdStr); });
+          return nullptr;
+        }
+        auto taskQueue = it->second;
+        queues.erase(it);
+        // Insert into removedTasks_ while still holding the queues_ lock
+        // to prevent getData() from seeing a gap between erase and insert,
+        // which would cause it to create a zombie placeholder queue.
+        removedTasks_.withLock(
+            [&](auto& removed) { removed.insert(taskIdStr); });
+        return taskQueue;
+      });
+  VLOG(2) << "[QUEUE-MGR] removeTask=" << taskId
+          << " queueExists=" << (queue != nullptr);
+  if (queue != nullptr) {
+    queue->terminate();
+  }
+  // Notify the intra-node registry so that any sources polling for this
+  // task get an atEnd result instead of spinning forever.
+  IntraNodeTransferRegistry::getInstance()->cancelTask(taskId);
+}
+
+std::shared_ptr<UcxOutputQueue> UcxOutputQueueManager::getQueueIfExists(
+    std::string_view taskId) {
+  std::string taskIdStr{taskId};
+  return queues_.withLock([&](auto& queues) {
+    auto it = queues.find(taskIdStr);
+    return it == queues.end() ? nullptr : it->second;
+  });
+}
+
+std::shared_ptr<UcxOutputQueue> UcxOutputQueueManager::getQueue(
+    std::string_view taskId) {
+  std::string taskIdStr{taskId};
+  return queues_.withLock([&](auto& queues) {
+    auto it = queues.find(taskIdStr);
+    VELOX_CHECK(
+        it != queues.end(), "Output cudf queue for task not found: {}", taskId);
+    return it->second;
+  });
+}
+
+std::optional<exec::OutputBuffer::Stats> UcxOutputQueueManager::stats(
+    std::string_view taskId) {
+  auto queue = getQueueIfExists(taskId);
+  if (queue != nullptr) {
+    return queue->stats();
+  }
+  return std::nullopt;
+}
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/UcxOutputQueueManager.h b/velox/experimental/ucx-exchange/UcxOutputQueueManager.h
new file mode 100644
index 00000000000..6bee37c7186
--- /dev/null
+++ b/velox/experimental/ucx-exchange/UcxOutputQueueManager.h
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cudf/contiguous_split.hpp>
+#include <velox/exec/Task.h>
+#include <functional>
+#include <string_view>
+#include <unordered_set>
+#include "velox/experimental/ucx-exchange/UcxQueues.h"
+
+namespace facebook::velox::ucx_exchange {
+
+class UcxOutputQueueManager {
+ public:
+  /// Factory method to retrieve a reference to the output queue manager.
+  static std::shared_ptr<UcxOutputQueueManager> getInstanceRef();
+
+  // no constructor to prevent direct instantiation.
+  UcxOutputQueueManager() = default;
+  // no copy constructor.
+  UcxOutputQueueManager(const UcxOutputQueueManager&) = delete;
+  // no copy assignment.
+  UcxOutputQueueManager& operator=(const UcxOutputQueueManager&) = delete;
+
+  /// @brief Initializes a task and creates the corresponding output queues that
+  /// are associated with this task.
+  /// @param task The task.
+  /// @param kind The output mode (partitioned, broadcast, etc.)
+  /// @param numDestinations The number of queues (destinations or partitions)
+  /// associated with this task.
+  /// @param numDrivers The number of drivers that contribute data to these
+  /// queues. Used to recognize when the queues are complete.
+  void initializeTask(
+      std::shared_ptr<exec::Task> task,
+      core::PartitionedOutputNode::Kind kind,
+      int numDestinations,
+      int numDrivers);
+
+  /// @brief Updates the number of destination buffers for a task.
+  /// For broadcast mode, new destinations are backfilled with previously
+  /// broadcast data.
+  void updateOutputBuffers(
+      std::string_view taskId,
+      int numBuffers,
+      bool noMoreBuffers);
+
+  /// @brief Enqueues a cudf packed column into the queue.
+  /// @param taskId The unique task Id.
+  /// @param destination The destination (partition, queue number) into which
+  /// the data is queued.
+  /// @param txData The data to enqueue.
+  /// @param numRows The number of rows in the data.
+  void enqueue(
+      std::string_view taskId,
+      int destination,
+      std::unique_ptr<cudf::packed_columns> txData,
+      int32_t numRows);
+
+  /// @brief Checks if the queue for a task is over capacity.
+  /// Should be called after enqueueing all partitions for a batch.
+  /// @param taskId The unique task Id.
+  /// @param future Output parameter - populated with a future if blocked.
+  /// @return True if blocked (queue over capacity), false otherwise.
+  bool checkBlocked(std::string_view taskId, ContinueFuture* future);
+
+  /// @brief Indicates that no more data will be coming for this task.
+  void noMoreData(std::string_view taskId);
+
+  /// @returns true if noMoreData has been called and all the accumulated data
+  /// have been fetched and acknowledged.
+  bool isFinished(std::string_view taskId);
+
+  /// @brief
+  void deleteResults(std::string_view taskId, int destination);
+
+  /// @brief Asynchronously returns the head of the queue. If data is available,
+  /// the callback function is triggered immediately and true is returned.
+  /// Otherwise, the callback function is registered and called once data is
+  /// available. If the queue is closed and no more data is available, then the
+  /// callback function is called immediately with a nullptr. If the destination
+  /// doesn't exist, then additional queues will be added for this task.
+  /// @param taskId The unique taskId.
+  /// @param destination The destination.
+  /// @param notify The callback function.
+  void getData(
+      std::string_view taskId,
+      int destination,
+      UcxDataAvailableCallback notify);
+
+  /// Returns true if the given task can use intra-node transfer.
+  /// Returns false if the task is not yet initialized (placeholder queue
+  /// from early sink connections) or if the task uses broadcast mode
+  /// (broadcast shares packed_columns across destinations — the intra-node
+  /// source's destructive move would corrupt data for other servers).
+  bool canUseIntraNode(std::string_view taskId);
+
+  /// @brief Removes the queue for the given task from the queue manager.
+  /// Calls "terminate" on the queue to awake waiting producers.
+  void removeTask(std::string_view taskId);
+
+  /// @brief Returns the queue statistics of the queue associated with the given
+  /// task. Returns nullopt when the specified output queue doesn't exist.
+  std::optional<exec::OutputBuffer::Stats> stats(std::string_view taskId);
+
+ private:
+  // Retrieves the queue for a task if it exists.
+  // Returns NULL if task not found.
+  std::shared_ptr<UcxOutputQueue> getQueueIfExists(std::string_view taskId);
+
+  // Throws an exception if queue doesn't exist.
+  std::shared_ptr<UcxOutputQueue> getQueue(std::string_view taskId);
+
+  folly::Synchronized<
+      std::unordered_map<std::string, std::shared_ptr<UcxOutputQueue>>,
+      std::mutex>
+      queues_;
+
+  // Tasks that have been removed via removeTask(). Prevents getData() from
+  // re-creating placeholder queues for tasks that are already dead, which
+  // would cause crashes when deleteResults() is called with destinations
+  // that exceed the placeholder's undersized queues_ vector.
+  folly::Synchronized<std::unordered_set<std::string>, std::mutex>
+      removedTasks_;
+};
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/UcxPartitionedOutput.cpp b/velox/experimental/ucx-exchange/UcxPartitionedOutput.cpp
new file mode 100644
index 00000000000..4cc191c0635
--- /dev/null
+++ b/velox/experimental/ucx-exchange/UcxPartitionedOutput.cpp
@@ -0,0 +1,361 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/ucx-exchange/UcxPartitionedOutput.h"
+#include <fmt/format.h>
+#include "velox/core/PlanNode.h"
+#include "velox/core/QueryConfig.h"
+#include "velox/exec/Driver.h"
+#include "velox/exec/Operator.h"
+#include "velox/experimental/cudf/vector/CudfVector.h"
+
+#include <cudf/concatenate.hpp>
+#include <cudf/contiguous_split.hpp>
+#include <cudf/copying.hpp>
+#include <cudf/partitioning.hpp>
+
+using namespace facebook::velox::cudf_velox;
+using facebook::velox::exec::Task;
+namespace facebook::velox::ucx_exchange {
+
+// Computes a mapping from names in n2 to names in n1
+// and returns that mapping in remap.
+// Names in n2 must occurs in n1.
+static void getRemapping(
+    const std::vector<std::string>& n1,
+    const std::vector<std::string>& n2,
+    std::vector<uint32_t>& remap) {
+  std::unordered_map<std::string, uint32_t> lookup;
+  for (uint32_t i = 0; i < n1.size(); ++i) {
+    lookup[n1[i]] = i;
+  }
+
+  remap.clear();
+  remap.reserve(n2.size());
+  for (const auto& key : n2) {
+    remap.push_back(lookup.at(key));
+  }
+}
+
+UcxPartitionedOutput::UcxPartitionedOutput(
+    int32_t operatorId,
+    exec::DriverCtx* ctx,
+    const std::shared_ptr<const core::PartitionedOutputNode>& planNode,
+    bool eagerFlush)
+    : Operator(
+          ctx,
+          planNode->outputType(),
+          operatorId,
+          planNode->id(),
+          "cudfPartitionedOutput"),
+      NvtxHelper(
+          nvtx3::rgb{255, 215, 0}, // Gold
+          operatorId,
+          fmt::format("[{}]", planNode->id())),
+      queueManager_(UcxOutputQueueManager::getInstanceRef()),
+      numPartitions_(planNode->numPartitions()),
+      pipelineId_(ctx->pipelineId),
+      driverId_(ctx->driverId),
+      targetRowsPerChunk_(ctx->queryConfig().ucxPartitionedOutputBatchRows()) {
+  this->initPartitionKeys(planNode);
+  auto sources = planNode->sources();
+  std::vector<std::string> inNames, outNames;
+  inNames.reserve(planNode->inputType()->size());
+  for (int i = 0; i < planNode->inputType()->size(); ++i) {
+    inNames.push_back(planNode->inputType()->nameOf(i));
+  }
+  outNames.reserve(planNode->outputType()->size());
+  for (int i = 0; i < planNode->outputType()->size(); ++i) {
+    outNames.push_back(planNode->outputType()->nameOf(i));
+  }
+  if (inNames != outNames) {
+    getRemapping(inNames, outNames, remap_);
+  }
+}
+
+void UcxPartitionedOutput::addInput(RowVectorPtr input) {
+  VLOG(3) << "@" << taskId() << "#" << pipelineId_ << "/" << driverId_
+          << " addInput";
+  VELOX_NVTX_OPERATOR_FUNC_RANGE();
+  auto cudfVector = std::dynamic_pointer_cast<CudfVector>(input);
+  VELOX_CHECK_NOT_NULL(cudfVector, "Input must be a CudfVector");
+  VELOX_CHECK(
+      !future_.valid() || future_.hasValue(),
+      "addInput with outstanding future!");
+
+  // Record stats per-input (before buffering).
+  {
+    auto lockedStats = stats_.wlock();
+    lockedStats->addOutputVector(input->estimateFlatSize(), input->size());
+  }
+
+  pendingRows_ += cudfVector->getTableView().num_rows();
+  pendingInputs_.push_back(std::move(cudfVector));
+
+  if (targetRowsPerChunk_ <= 0 || pendingRows_ >= targetRowsPerChunk_) {
+    flushPending();
+  }
+}
+
+void UcxPartitionedOutput::flushPending() {
+  if (pendingInputs_.empty()) {
+    return;
+  }
+
+  try {
+    cudf::table_view tableView;
+    rmm::cuda_stream_view stream = pendingInputs_.back()->stream();
+    // Keeps the merged table alive while tableView references it.
+    std::unique_ptr<cudf::table> mergedTable;
+
+    if (pendingInputs_.size() == 1) {
+      // Fast path: use the single input's view directly (no GPU alloc).
+      auto& cv = pendingInputs_[0];
+      stream = cv->stream();
+      tableView = remap_.empty()
+          ? cv->getTableView()
+          : cv->getTableView().select(remap_.begin(), remap_.end());
+    } else {
+      // Sync all input streams so their GPU data is ready to read.
+      for (auto& v : pendingInputs_) {
+        v->stream().synchronize();
+      }
+
+      // Collect (remapped) table views.
+      std::vector<cudf::table_view> views;
+      views.reserve(pendingInputs_.size());
+      for (auto& v : pendingInputs_) {
+        views.push_back(
+            remap_.empty()
+                ? v->getTableView()
+                : v->getTableView().select(remap_.begin(), remap_.end()));
+      }
+
+      mergedTable = cudf::concatenate(
+          views, stream, cudf::get_current_device_resource_ref());
+
+      // Free input GPU memory before partitioning (peak = 2x -> 1x).
+      pendingInputs_.clear();
+
+      tableView = mergedTable->view();
+    }
+
+    // Partition + enqueue (identical to previous addInput logic).
+    auto queueManager = sharedQueueManager();
+    if (numPartitions_ > 1) {
+      if (partitionKeyIndices_.size() > 0 || spec_ == "gather") {
+        hashPartition(tableView, stream);
+      } else {
+        equalPartition(tableView, stream);
+      }
+    } else {
+      auto packedCols = cudf::pack(tableView, stream);
+      stream.synchronize();
+      auto packedColsPtr = std::make_unique<cudf::packed_columns>(
+          std::move(packedCols.metadata), std::move(packedCols.gpu_data));
+      queueManager->enqueue(
+          this->taskId(), 0, std::move(packedColsPtr), tableView.num_rows());
+    }
+
+    // Check backpressure after enqueue.
+    auto blocked = queueManager->checkBlocked(this->taskId(), &future_);
+    if (blocked) {
+      VLOG(3) << "@" << taskId() << "#" << pipelineId_ << "/" << driverId_
+              << " is blocked, can no longer write to output!";
+    }
+    blockingReason_ = blocked ? exec::BlockingReason::kWaitForConsumer
+                              : exec::BlockingReason::kNotBlocked;
+
+    pendingInputs_.clear();
+    pendingRows_ = 0;
+
+  } catch (const rmm::bad_alloc& e) {
+    VLOG(1)
+        << "@" << taskId() << "#" << pipelineId_ << "/" << driverId_
+        << " caught memory alloc error, removing all memory in output queues";
+    pendingInputs_.clear();
+    pendingRows_ = 0;
+    for (int i = 0; i < numPartitions_; i++) {
+      sharedQueueManager()->deleteResults(this->taskId(), i);
+    }
+    throw;
+  }
+}
+
+exec::BlockingReason UcxPartitionedOutput::isBlocked(ContinueFuture* future) {
+  if (blockingReason_ != exec::BlockingReason::kNotBlocked) {
+    *future = std::move(future_);
+    blockingReason_ = exec::BlockingReason::kNotBlocked;
+    return exec::BlockingReason::kWaitForConsumer;
+  }
+  return exec::BlockingReason::kNotBlocked;
+}
+
+RowVectorPtr UcxPartitionedOutput::getOutput() {
+  VELOX_NVTX_OPERATOR_FUNC_RANGE();
+  if (finished_) {
+    return nullptr;
+  }
+  if (noMoreInput_) {
+    flushPending(); // drain any remaining buffered inputs
+    sharedQueueManager()->noMoreData(this->taskId());
+    finished_ = true;
+  }
+  return nullptr;
+}
+
+bool UcxPartitionedOutput::isFinished() {
+  return finished_;
+}
+
+std::shared_ptr<facebook::velox::ucx_exchange::UcxOutputQueueManager>
+UcxPartitionedOutput::sharedQueueManager() {
+  auto shared_queueManager = queueManager_.lock();
+  VELOX_CHECK_NOT_NULL(
+      shared_queueManager, "OutputQueueManager was already destructed");
+  return shared_queueManager;
+}
+
+void UcxPartitionedOutput::initPartitionKeys(
+    const std::shared_ptr<const core::PartitionedOutputNode>& planNode) {
+  // Following Logic copied direcly from CudLocalPartition (!)
+
+  // Following is IMO a hacky way to get the partition key indices. It is to
+  // workaround the fact that the partition spec constructs the hash function
+  // directly and has no public methods to get the partition key indices.
+
+  // When the operator is of type kRepartition, the partition spec is a string
+  // in the format "HASH(key1, key2, ...)"
+  // We're going to extract the keys between HASH( and ) and find their indices
+  // in the output row type.
+
+  // When operator is of type kGather, we don't need to store any partition key
+  // indices because we're going to merge all the incoming streams together.
+
+  // Get partition function specification string
+  spec_ = planNode->partitionFunctionSpec().toString();
+
+  // Only parse keys if it's a hash function
+  if (spec_.find("HASH(") != std::string::npos) {
+    // Extract keys between HASH( and )
+    size_t start = spec_.find("HASH(") + 5;
+    size_t end = spec_.find(")", start);
+    if (start != std::string::npos && end != std::string::npos) {
+      std::string keysStr = spec_.substr(start, end - start);
+
+      // Split by comma to get individual keys.
+      std::vector<std::string> keys;
+      size_t pos = 0;
+      while ((pos = keysStr.find(",")) != std::string::npos) {
+        std::string key = keysStr.substr(0, pos);
+        keys.push_back(key);
+        keysStr.erase(0, pos + 1);
+      }
+      keys.push_back(keysStr); // Add the last key.
+
+      // Find field indices for each key.
+      const auto& rowType = planNode->outputType();
+      for (const auto& key : keys) {
+        auto trimmedKey = key;
+        // Trim whitespace
+        trimmedKey.erase(0, trimmedKey.find_first_not_of(" "));
+        trimmedKey.erase(trimmedKey.find_last_not_of(" ") + 1);
+
+        auto fieldIndex = rowType->getChildIdx(trimmedKey);
+        partitionKeyIndices_.push_back(fieldIndex);
+      }
+    }
+  }
+}
+
+void UcxPartitionedOutput::hashPartition(
+    cudf::table_view tableView,
+    rmm::cuda_stream_view stream) {
+  VLOG(3) << "@" << taskId() << "#" << pipelineId_ << "/" << driverId_
+          << " Hashing and partitioning into " << numPartitions_ << " chunks";
+
+  // Use cudf hash partitioning
+  std::vector<cudf::size_type> partitionKeyIndices;
+  for (const auto& idx : partitionKeyIndices_) {
+    partitionKeyIndices.push_back(static_cast<cudf::size_type>(idx));
+  }
+
+  auto [partitionedTable, partitionOffsets] = cudf::hash_partition(
+      tableView,
+      partitionKeyIndices,
+      numPartitions_,
+      cudf::hash_id::HASH_MURMUR3,
+      cudf::DEFAULT_HASH_SEED,
+      stream);
+
+  VELOX_CHECK_EQ(partitionOffsets.size(), numPartitions_ + 1);
+  VELOX_CHECK_EQ(partitionOffsets[0], 0);
+
+  // Erase first element since it's always 0 and we don't need it.
+  partitionOffsets.erase(partitionOffsets.begin());
+  partitionOffsets.pop_back();
+
+  splitAndEnqueue(partitionedTable->view(), partitionOffsets, stream);
+}
+
+void UcxPartitionedOutput::equalPartition(
+    cudf::table_view tableView,
+    rmm::cuda_stream_view stream) {
+  VLOG(3) << "@" << taskId() << "#" << pipelineId_ << "/" << driverId_
+          << " Splitting into " << numPartitions_ << " chunks";
+  std::vector<cudf::size_type> offsets;
+  cudf::size_type size = tableView.num_rows();
+  for (int i = 1; i < numPartitions_; ++i) {
+    cudf::size_type idx = size * i / numPartitions_;
+    offsets.push_back(idx);
+  }
+  splitAndEnqueue(tableView, offsets, stream);
+}
+
+void UcxPartitionedOutput::splitAndEnqueue(
+    cudf::table_view tableView,
+    std::vector<cudf::size_type> offsets,
+    rmm::cuda_stream_view stream) {
+  auto contiguousTables = cudf::contiguous_split(tableView, offsets, stream);
+
+  // Synchronize the stream to ensure CUDA operations complete before enqueuing.
+  // UCXX/UCX is not stream-aware, so without syncing, data could be sent before
+  // the GPU kernels have finished writing to the buffers.
+  stream.synchronize();
+
+  VELOX_CHECK_EQ(
+      offsets.size() + 1, numPartitions_, "mismatch in numPartitions_");
+  auto queueManager = sharedQueueManager();
+  for (int i = 0; i < numPartitions_; ++i) {
+    auto const& partitionTable = contiguousTables[i];
+    if (partitionTable.table.num_rows() == 0) {
+      // Skip empty partitions.
+      continue;
+    }
+
+    auto packedColsPtr = std::make_unique<cudf::packed_columns>(
+        std::move(contiguousTables[i].data.metadata),
+        std::move(contiguousTables[i].data.gpu_data));
+
+    // enqueue partition data on Ucx Output Buffer
+    queueManager->enqueue(
+        this->taskId(),
+        i,
+        std::move(packedColsPtr),
+        partitionTable.table.num_rows());
+  }
+}
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/UcxPartitionedOutput.h b/velox/experimental/ucx-exchange/UcxPartitionedOutput.h
new file mode 100644
index 00000000000..fce2ce6ec1a
--- /dev/null
+++ b/velox/experimental/ucx-exchange/UcxPartitionedOutput.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/exec/Operator.h"
+#include "velox/experimental/cudf/exec/NvtxHelper.h"
+#include "velox/experimental/cudf/vector/CudfVector.h"
+#include "velox/experimental/ucx-exchange/UcxOutputQueueManager.h"
+
+namespace facebook::velox::ucx_exchange {
+
+/// This is the cudf equivalent of the PartitionedOutput operator for cudf.
+/// Instead of serializing and segmenting the partitioned data into an
+/// OutputBuffer, the UcxPartitionedOutput operator transfers entire
+/// cudf::packed_columns corresponding to CudfVectors to other workers.
+class UcxPartitionedOutput : public exec::Operator,
+                             public cudf_velox::NvtxHelper {
+ public:
+  // Default minimum rows to accumulate before flushing. Matches HTTP
+  // PartitionedOutput's ~10,000 row target. Overridable via
+  // QueryConfig::kUcxPartitionedOutputBatchRows.
+  static constexpr int64_t kDefaultTargetRowsPerChunk = 10'000;
+
+  UcxPartitionedOutput(
+      int32_t operatorId,
+      exec::DriverCtx* ctx,
+      const std::shared_ptr<const core::PartitionedOutputNode>& planNode,
+      bool eagerFlush);
+
+  void addInput(RowVectorPtr input) override;
+
+  /// Always returns nullptr. The action is to further process
+  /// unprocessed input. If all input has been processed, 'this' is in
+  /// a non-blocked state, otherwise blocked.
+  RowVectorPtr getOutput() override;
+
+  /// always true but the caller will check isBlocked before adding input, hence
+  /// the blocked state does not accumulate input.
+  bool needsInput() const override {
+    return true;
+  }
+
+  // the operator is blocked if the queues are full, we are ignoring this so
+  // always return kNotBlocked
+  exec::BlockingReason isBlocked(ContinueFuture* future) override;
+
+  // The operaor is finished when the queue manager say the queues have all been
+  // drained ?
+  bool isFinished() override;
+
+ private:
+  std::shared_ptr<facebook::velox::ucx_exchange::UcxOutputQueueManager>
+  sharedQueueManager();
+
+  // Heuristic method to derive the partition keys from the PartitionNode
+  // specification.
+  void initPartitionKeys(
+      const std::shared_ptr<const core::PartitionedOutputNode>& planNode);
+
+  // Partitions the cudf table view using the partition keys and a hash
+  // function using the given stream.
+  void hashPartition(cudf::table_view tableView, rmm::cuda_stream_view stream);
+
+  // Splits the cudf table view into equal sizes. This is used when
+  // RoundRobin partitioning is requested but round robin on a
+  // row-by-row basis is not meaningful for UCX exchange.
+  void equalPartition(cudf::table_view tableView, rmm::cuda_stream_view stream);
+
+  // Splits the table along the given offsets and enqueues each offset
+  // to the corresponding partition, i.e. first split to the partition 0,
+  // second split to partition 1 etc.
+  void splitAndEnqueue(
+      cudf::table_view tableView,
+      std::vector<cudf::size_type> offsets,
+      rmm::cuda_stream_view stream);
+
+  const std::weak_ptr<UcxOutputQueueManager> queueManager_;
+  std::vector<column_index_t> partitionKeyIndices_;
+  const size_t numPartitions_;
+
+  const int pipelineId_;
+  const int driverId_;
+
+  exec::BlockingReason blockingReason_;
+  ContinueFuture future_;
+
+  bool finished_{false};
+  std::string spec_;
+
+  // Used for switching columns when column order differs between input and
+  // output.
+  std::vector<uint32_t> remap_;
+
+  /// Concatenates pending inputs and partitions/enqueues the merged result.
+  void flushPending();
+
+  /// Accumulated CudfVectors awaiting flush.
+  std::vector<cudf_velox::CudfVectorPtr> pendingInputs_;
+  /// Total rows across pendingInputs_.
+  int64_t pendingRows_{0};
+  /// Configured row threshold for flushing (from QueryConfig).
+  const int64_t targetRowsPerChunk_;
+};
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/UcxQueues.cpp b/velox/experimental/ucx-exchange/UcxQueues.cpp
new file mode 100644
index 00000000000..f014d3c95af
--- /dev/null
+++ b/velox/experimental/ucx-exchange/UcxQueues.cpp
@@ -0,0 +1,631 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/ucx-exchange/UcxQueues.h"
+
+#include <atomic>
+
+namespace facebook::velox::ucx_exchange {
+
+void UcxDestinationQueue::Stats::recordEnqueue(
+    const cudf::packed_columns* data) {
+  if (data != nullptr) {
+    bytesQueued += data->gpu_data->size();
+    packedColumnsQueued++;
+  }
+}
+
+void UcxDestinationQueue::Stats::recordDequeue(
+    const cudf::packed_columns* data) {
+  if (data != nullptr) {
+    const int64_t size = data->gpu_data->size();
+
+    bytesQueued -= size;
+    VELOX_DCHECK_GE(bytesQueued, 0, "bytesQueued must be non-negative");
+    --packedColumnsQueued;
+    VELOX_DCHECK_GE(
+        packedColumnsQueued, 0, "packedColumnsQueued must be non-negative");
+
+    bytesSent += size;
+    packedColumnsSent++;
+  }
+}
+
+void UcxDestinationQueue::enqueueBack(
+    std::shared_ptr<cudf::packed_columns> data) {
+  // drop duplicate end markers.
+  if (data == nullptr && !queue_.empty() && queue_.back() == nullptr) {
+    return;
+  }
+
+  if (data != nullptr) {
+    stats_.recordEnqueue(data.get());
+  }
+  queue_.push_back(std::move(data));
+}
+
+void UcxDestinationQueue::enqueueFront(
+    std::shared_ptr<cudf::packed_columns> data) {
+  // ignore nullptr.
+  if (data == nullptr) {
+    return;
+  }
+
+  // insert at the front.
+  queue_.push_front(std::move(data));
+}
+
+UcxDestinationQueue::Data UcxDestinationQueue::getData(
+    UcxDataAvailableCallback notify) {
+  if (queue_.empty()) {
+    // delay notification.
+    notify_ = std::move(notify);
+    return {};
+  }
+
+  // queue is not empty.
+  auto data = std::move(queue_.front());
+  queue_.pop_front();
+  stats_.recordDequeue(data.get());
+
+  std::vector<int64_t> remainingBytes;
+  remainingBytes.reserve(queue_.size());
+  // fill in the remainingbytes vector.
+  for (std::size_t i = 0; i < queue_.size(); ++i) {
+    if (queue_[i] == nullptr) {
+      VELOX_CHECK_EQ(i, queue_.size() - 1, "null marker found in the middle");
+      break;
+    }
+    remainingBytes.push_back(queue_[i]->gpu_data->size());
+  }
+  return {std::move(data), std::move(remainingBytes), true};
+}
+
+void UcxDestinationQueue::deleteResults() {
+  for (auto i = 0; i < queue_.size(); ++i) {
+    if (queue_[i] == nullptr) {
+      VELOX_CHECK_EQ(i, queue_.size() - 1, "null marker found in the middle");
+      break;
+    }
+  }
+  queue_.clear();
+}
+
+UcxDataAvailable UcxDestinationQueue::getAndClearNotify() {
+  if (notify_ == nullptr) {
+    return UcxDataAvailable();
+  }
+  UcxDataAvailable result;
+  result.callback = notify_;
+  auto data = getData(nullptr);
+  result.data = std::move(data.data);
+  result.remainingBytes = std::move(data.remainingBytes);
+  clearNotify();
+  return result;
+}
+
+void UcxDestinationQueue::clearNotify() {
+  notify_ = nullptr;
+}
+
+void UcxDestinationQueue::finish() {
+  VELOX_CHECK_NULL(notify_, "notify must be cleared before finish");
+  VELOX_CHECK(queue_.empty(), "data must be fetched before finish");
+}
+
+UcxDestinationQueue::Stats UcxDestinationQueue::stats() const {
+  return stats_;
+}
+
+std::string UcxDestinationQueue::toString() {
+  std::stringstream out;
+  out << "[available: " << queue_.size() << ", "
+      << (notify_ ? "notify registered, " : "") << this << "]";
+  return out.str();
+}
+
+// ---------- UcxOutputQueue ----------
+
+UcxOutputQueue::UcxOutputQueue(
+    std::shared_ptr<exec::Task> task,
+    uint32_t numDestinations,
+    uint32_t numDrivers,
+    core::PartitionedOutputNode::Kind kind)
+    : task_(task), kind_(kind), numDrivers_(numDrivers) {
+  if (task_) {
+    maxSize_ = task_->queryCtx()->queryConfig().maxOutputBufferSize();
+    continueSize_ = (maxSize_ * kContinuePct) / 100;
+  } // else: maxSize_ and continueSize_ will be set once the task is created and
+    // initialize called.
+  // create a queue for each destination.
+  queues_.reserve(numDestinations);
+  for (int i = 0; i < numDestinations; ++i) {
+    // create the destination queues inside the vector using emplace_back.
+    queues_.emplace_back(std::make_unique<UcxDestinationQueue>());
+  }
+}
+
+bool UcxOutputQueue::initialize(
+    std::shared_ptr<exec::Task> task,
+    uint32_t numDestinations,
+    uint32_t numDrivers,
+    core::PartitionedOutputNode::Kind kind) {
+  std::lock_guard<std::mutex> l(mutex_);
+  if (task_) {
+    // already initialized!
+    return false;
+  }
+  kind_ = kind;
+  numDrivers_ = numDrivers;
+  task_ = task;
+  maxSize_ = task_->queryCtx()->queryConfig().maxOutputBufferSize();
+  continueSize_ = (maxSize_ * kContinuePct) / 100;
+  // create additional queues if there are more destinations.
+  for (int i = queues_.size(); i < numDestinations; ++i) {
+    // create the destination queues inside the vector using emplace_back.
+    queues_.emplace_back(std::make_unique<UcxDestinationQueue>());
+  }
+  // Publish the initialized flag last with release semantics. Lock-free
+  // readers (canUseIntraNode → isInitialized) use an acquire load, so
+  // all writes above (kind_, task_, queues_, etc.) are guaranteed visible
+  // once they observe initialized_ == true.
+  initialized_.store(true, std::memory_order_release);
+  return true;
+}
+
+void UcxOutputQueue::updateNumDrivers(uint32_t newNumDrivers) {
+  bool isNoMoreDrivers{false};
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    numDrivers_ = newNumDrivers;
+    // If we finished all drivers, ensure we register that we are 'done'.
+    if (numDrivers_ == numFinished_) {
+      isNoMoreDrivers = true;
+    }
+  }
+  if (isNoMoreDrivers) {
+    noMoreDrivers();
+  }
+}
+
+void UcxOutputQueue::enqueue(
+    int destination,
+    std::unique_ptr<cudf::packed_columns> data,
+    int32_t numRows) {
+  VELOX_CHECK_NOT_NULL(data);
+  VELOX_CHECK_NOT_NULL(task_);
+  VELOX_CHECK(
+      task_->isRunning(), "Task is terminated, cannot add data to output.");
+  std::vector<UcxDataAvailable> dataAvailableCallbacks;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    auto numBytes = data->gpu_data->size();
+    auto sharedData = std::shared_ptr<cudf::packed_columns>(std::move(data));
+
+    bool success = false;
+    if (kind_ == core::PartitionedOutputNode::Kind::kBroadcast) {
+      VELOX_CHECK_EQ(destination, 0, "Broadcast uses destination 0");
+      enqueueBroadcastOutputLocked(
+          std::move(sharedData), dataAvailableCallbacks);
+      // For broadcast, count queuedBytes_ once per active destination so
+      // that each destination's dequeue symmetrically decrements it. The
+      // total sent stats count the logical data once.
+      int numActive = 0;
+      for (auto& q : queues_) {
+        if (q != nullptr) {
+          numActive++;
+        }
+      }
+      updateTotalQueuedBytesMsLocked();
+      queuedBytes_ += numBytes * numActive;
+      queuedPackedColumns_ += numActive;
+      totalBytesSent_ += numBytes;
+      totalRowsSent_ += numRows;
+      totalPackedColumnsSent_++;
+      success = true;
+    } else {
+      VELOX_CHECK_LT(destination, queues_.size());
+      success = enqueuePartitionedOutputLocked(
+          destination, std::move(sharedData), dataAvailableCallbacks);
+      if (success) {
+        updateStatsWithEnqueuedLocked(numBytes, numRows);
+      }
+    }
+  }
+  // Now that data is enqueued, notify blocked readers (outside of mutex.)
+  for (auto& callback : dataAvailableCallbacks) {
+    callback.notify();
+  }
+}
+
+bool UcxOutputQueue::checkBlocked(ContinueFuture* future) {
+  std::lock_guard<std::mutex> l(mutex_);
+  if (queuedBytes_ >= maxSize_ && future) {
+    VLOG(2) << "[BACKPRESSURE] task=" << (task_ ? task_->taskId() : "n/a")
+            << " BLOCKED queuedBytes=" << queuedBytes_
+            << " maxSize=" << maxSize_
+            << " waitingProducers=" << (promises_.size() + 1);
+    promises_.emplace_back("UcxOutputQueue::checkBlocked");
+    *future = promises_.back().getSemiFuture();
+    return true;
+  }
+  return false;
+}
+
+void UcxOutputQueue::getData(int destination, UcxDataAvailableCallback notify) {
+  UcxDestinationQueue::Data data;
+  std::vector<ContinuePromise> promises;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    // If the queue doesn't exist yet, create an empty queue to store
+    // the notify callback. The queue will eventually be initialized when
+    // the task is being created.
+    for (int i = queues_.size(); i <= destination; ++i) {
+      // create the destination queues inside the vector using emplace_back.
+      queues_.emplace_back(std::make_unique<UcxDestinationQueue>());
+    }
+    auto* queue = queues_[destination].get();
+    // queue can be nullptr here if the task has terminated and results
+    // have been removed. In this case, no data is returned.
+    if (queue) {
+      // Capture weak_ptr instead of raw `this` to prevent use-after-free.
+      // The callback fires outside the lock (from enqueue() or terminate()),
+      // and concurrent removeTask() can destroy the UcxOutputQueue while
+      // the callback is still executing.
+      std::weak_ptr<UcxOutputQueue> weakSelf = shared_from_this();
+      data = queue->getData([notify, weakSelf](
+                                std::shared_ptr<cudf::packed_columns> data,
+                                std::vector<int64_t> remainingBytes) {
+        std::vector<ContinuePromise> promises;
+        int64_t bytes = data ? data->gpu_data->size() : -1L;
+        notify(std::move(data), std::move(remainingBytes));
+        if (bytes >= 0L) {
+          auto self = weakSelf.lock();
+          if (!self) {
+            // Queue was destroyed by removeTask(), safe to skip stats update.
+            return;
+          }
+          std::lock_guard<std::mutex> l(self->mutex_);
+          self->updateStatsWithFreedLocked(bytes, 1L, promises);
+        }
+        // outside of lock:
+        // wake up any producers that are waiting for queue to become less full.
+        for (auto& promise : promises) {
+          promise.setValue();
+        }
+      });
+      if (data.data) {
+        // This implies data.immediate and no notify upcall will be done.
+        // Need to update the stats here.
+        updateStatsWithFreedLocked(data.data->gpu_data->size(), 1L, promises);
+      }
+    } else {
+      data = UcxDestinationQueue::Data{nullptr, {}, true};
+    }
+  }
+  // outside lock: If we have data, then return it immediately.
+  if (data.immediate) {
+    notify(std::move(data.data), std::move(data.remainingBytes));
+  } else {
+    VLOG(2) << "[QUEUE] task=" << (task_ ? task_->taskId() : "n/a")
+            << " dest=" << destination
+            << " server waiting for data (callback installed)";
+  }
+  // wake up any producers that are waiting for queue to become less full.
+  for (auto& promise : promises) {
+    promise.setValue();
+  }
+}
+
+void UcxOutputQueue::noMoreData() {
+  // Increment number of finished drivers.
+  checkIfDone(true);
+}
+
+void UcxOutputQueue::noMoreDrivers() {
+  // Do not increment number of finished drivers.
+  checkIfDone(false);
+}
+
+void UcxOutputQueue::checkIfDone(bool oneDriverFinished) {
+  std::vector<UcxDataAvailable> finished;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    if (oneDriverFinished) {
+      ++numFinished_;
+    }
+    VELOX_CHECK_LE(
+        numFinished_,
+        numDrivers_,
+        "Each driver should call noMoreData exactly once");
+    atEnd_ = numFinished_ == numDrivers_;
+    if (!atEnd_) {
+      return;
+    }
+    {
+      int64_t avgRows = totalPackedColumnsSent_ > 0
+          ? totalRowsSent_ / totalPackedColumnsSent_
+          : 0;
+      VLOG(1) << "[OUTPUT-STATS] task=" << (task_ ? task_->taskId() : "n/a")
+              << " totalRows=" << totalRowsSent_
+              << " chunks=" << totalPackedColumnsSent_
+              << " avgRowsPerChunk=" << avgRows
+              << " totalBytes=" << totalBytesSent_;
+    }
+    for (auto& queue : queues_) {
+      if (queue != nullptr) {
+        queue->enqueueBack(nullptr);
+        finished.push_back(queue->getAndClearNotify());
+      }
+    }
+  }
+  // Notify outside of mutex.
+  for (auto& notification : finished) {
+    notification.notify();
+  }
+}
+
+bool UcxOutputQueue::enqueuePartitionedOutputLocked(
+    int destination,
+    std::shared_ptr<cudf::packed_columns> data,
+    std::vector<UcxDataAvailable>& dataAvailableCbs) {
+  VELOX_DCHECK(dataAvailableCbs.empty());
+  VELOX_CHECK_LT(destination, queues_.size());
+  bool success = false;
+  auto* queue = queues_[destination].get();
+  if (queue != nullptr) {
+    queue->enqueueBack(std::move(data));
+    dataAvailableCbs.emplace_back(queue->getAndClearNotify());
+    success = true;
+  }
+  return success;
+}
+
+void UcxOutputQueue::enqueueBroadcastOutputLocked(
+    std::shared_ptr<cudf::packed_columns> data,
+    std::vector<UcxDataAvailable>& dataAvailableCbs) {
+  VELOX_DCHECK(dataAvailableCbs.empty());
+
+  for (auto& queue : queues_) {
+    if (queue != nullptr) {
+      queue->enqueueBack(data);
+      dataAvailableCbs.emplace_back(queue->getAndClearNotify());
+    }
+  }
+
+  // Store for late-arriving destinations (backfill).
+  if (!noMoreQueues_) {
+    dataToBroadcast_.emplace_back(std::move(data));
+  }
+}
+
+bool UcxOutputQueue::isFinished() {
+  std::lock_guard<std::mutex> l(mutex_);
+  return isFinishedLocked();
+}
+
+bool UcxOutputQueue::isFinishedLocked() {
+  // For broadcast, we can only be finished after receiving the no more
+  // (destination) buffers signal, matching OutputBuffer::isFinishedLocked().
+  if (kind_ == core::PartitionedOutputNode::Kind::kBroadcast &&
+      !noMoreQueues_) {
+    return false;
+  }
+  for (auto& queue : queues_) {
+    if (queue != nullptr) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void UcxOutputQueue::updateOutputBuffers(int numBuffers, bool noMoreBuffers) {
+  using Kind = core::PartitionedOutputNode::Kind;
+  if (kind_ == Kind::kPartitioned) {
+    std::lock_guard<std::mutex> l(mutex_);
+    VELOX_CHECK_EQ(queues_.size(), numBuffers);
+    VELOX_CHECK(noMoreBuffers);
+    noMoreQueues_ = true;
+    return;
+  }
+
+  VELOX_CHECK_EQ(kind_, Kind::kBroadcast);
+  bool isFinished;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+
+    if (numBuffers > queues_.size()) {
+      // Add new destination queues and backfill with broadcast data.
+      int32_t numNewBuffers = numBuffers - queues_.size();
+      queues_.reserve(numBuffers);
+      for (int32_t i = 0; i < numNewBuffers; ++i) {
+        auto buffer = std::make_unique<UcxDestinationQueue>();
+        for (const auto& data : dataToBroadcast_) {
+          buffer->enqueueBack(data);
+          // Account for backfilled data in queuedBytes_ so that dequeue
+          // decrements don't drive it negative.
+          queuedBytes_ += data->gpu_data->size();
+          queuedPackedColumns_++;
+        }
+        if (atEnd_) {
+          buffer->enqueueBack(nullptr);
+        }
+        queues_.emplace_back(std::move(buffer));
+      }
+    }
+
+    if (!noMoreBuffers) {
+      return;
+    }
+
+    noMoreQueues_ = true;
+    dataToBroadcast_.clear();
+    isFinished = isFinishedLocked();
+  }
+
+  if (isFinished && task_) {
+    task_->setAllOutputConsumed();
+  }
+}
+
+void UcxOutputQueue::deleteResults(int destination) {
+  bool isFinished;
+  UcxDataAvailable dataAvailable;
+  std::vector<ContinuePromise> promises;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    if (destination >= queues_.size()) {
+      VLOG(1) << "deleteResults: destination " << destination
+              << " out of range (size=" << queues_.size() << "), ignoring";
+      return;
+    }
+    auto* queue = queues_[destination].get();
+    if (queue == nullptr) {
+      VLOG(1) << "Extra delete received for destination " << destination;
+      return;
+    }
+    // remember destination queue fill stats
+    int64_t bytes = queue->stats().bytesQueued;
+    int64_t packedCols = queue->stats().packedColumnsQueued;
+    queue->deleteResults();
+    dataAvailable = queue->getAndClearNotify();
+    queue->finish();
+    queues_[destination] = nullptr;
+    isFinished = isFinishedLocked();
+    // update UcxOutputQueue stats
+    updateStatsWithFreedLocked(bytes, packedCols, promises);
+  }
+
+  // Outside of mutex.
+  dataAvailable.notify();
+  // wake up any producers that are waiting for queue to become less full.
+  for (auto& promise : promises) {
+    promise.setValue();
+  }
+
+  if (isFinished && task_) {
+    task_->setAllOutputConsumed();
+  }
+}
+
+void UcxOutputQueue::terminate() {
+  std::vector<UcxDataAvailable> pendingCallbacks;
+  std::vector<ContinuePromise> promises;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    if (task_ && task_->isRunning()) {
+      LOG(WARNING) << "UcxOutputQueue::terminate() called while task "
+                   << task_->taskId() << " is still running";
+    }
+    // Fire all pending getData callbacks with nullptr to signal end-of-stream.
+    // This handles the case where a producer task fails or is cancelled before
+    // noMoreData() is called, preventing consumers from being orphaned.
+    for (auto& queue : queues_) {
+      if (queue != nullptr) {
+        queue->enqueueBack(nullptr);
+        pendingCallbacks.push_back(queue->getAndClearNotify());
+      }
+    }
+    // Release any outstanding producer-side promises (blocked on queue-full).
+    promises = std::move(promises_);
+  }
+
+  // Fire callbacks outside of mutex to avoid potential deadlocks.
+  for (auto& callback : pendingCallbacks) {
+    callback.notify();
+  }
+  // Unblock any blocked producers.
+  for (auto& promise : promises) {
+    promise.setValue();
+  }
+}
+
+exec::OutputBuffer::Stats UcxOutputQueue::stats() {
+  std::lock_guard<std::mutex> l(mutex_);
+  std::vector<UcxDestinationQueue::Stats> queueStats;
+
+  updateTotalQueuedBytesMsLocked();
+
+  auto stats = exec::OutputBuffer::Stats(
+      kind(),
+      noMoreQueues_,
+      atEnd_,
+      isFinishedLocked(),
+      queuedBytes_,
+      queuedPackedColumns_,
+      totalBytesSent_,
+      totalRowsSent_,
+      totalPackedColumnsSent_,
+      getAverageQueueTimeMsLocked(),
+      0 /* FIXME: compute num top buffers. */,
+      {/* FIXME: transition queueStats to exec::DestinationBuffer::Stats */});
+  return stats;
+}
+
+void UcxOutputQueue::updateStatsWithEnqueuedLocked(
+    int64_t bytes,
+    int64_t rows) {
+  updateTotalQueuedBytesMsLocked();
+
+  queuedBytes_ += bytes;
+  queuedPackedColumns_++;
+
+  totalBytesSent_ += bytes;
+  totalRowsSent_ += rows;
+  totalPackedColumnsSent_++;
+}
+
+void UcxOutputQueue::updateStatsWithFreedLocked(
+    int64_t bytes,
+    int64_t numPackedCols,
+    std::vector<ContinuePromise>& promises) {
+  updateTotalQueuedBytesMsLocked();
+
+  queuedBytes_ -= bytes;
+  queuedPackedColumns_ -= numPackedCols;
+
+  VELOX_CHECK_GE(queuedBytes_, 0);
+  VELOX_CHECK_GE(queuedPackedColumns_, 0);
+
+  // Check whether queue is below low-water mark and return outstanding
+  // promises
+  if (queuedBytes_ <= continueSize_ && !promises_.empty()) {
+    VLOG(2) << "[BACKPRESSURE] task=" << (task_ ? task_->taskId() : "n/a")
+            << " UNBLOCKING " << promises_.size() << " producers"
+            << " queuedBytes=" << queuedBytes_
+            << " continueSize=" << continueSize_;
+    promises = std::move(promises_);
+  }
+}
+
+void UcxOutputQueue::updateTotalQueuedBytesMsLocked() {
+  const auto nowMs = getCurrentTimeMs();
+  if (queuedBytes_ > 0) {
+    const auto deltaMs = nowMs - queueStartMs_;
+    totalQueuedBytesMs_ += queuedBytes_ * deltaMs;
+  }
+
+  queueStartMs_ = nowMs;
+}
+
+int64_t UcxOutputQueue::getAverageQueueTimeMsLocked() const {
+  if (totalBytesSent_ > 0) {
+    return totalQueuedBytesMs_ / totalBytesSent_;
+  }
+
+  return 0;
+}
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/UcxQueues.h b/velox/experimental/ucx-exchange/UcxQueues.h
new file mode 100644
index 00000000000..6e1984082e7
--- /dev/null
+++ b/velox/experimental/ucx-exchange/UcxQueues.h
@@ -0,0 +1,333 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cudf/contiguous_split.hpp>
+#include <atomic>
+#include <deque>
+#include <functional>
+#include <memory>
+#include <vector>
+#include "velox/core/PlanNode.h"
+#include "velox/exec/OutputBuffer.h" // for the Stats structure
+#include "velox/exec/Task.h"
+
+namespace facebook::velox::ucx_exchange {
+
+/// @brief  Callback function for getting data from the queues.
+/// A nullptr indicates that there is no more data.
+/// The remainingBytes vector contains the sizes for the
+/// packed_columns elements remaining in the queue.
+/// Uses shared_ptr to support broadcast mode where the same GPU data
+/// is shared across multiple destination queues without copying.
+using UcxDataAvailableCallback = std::function<void(
+    std::shared_ptr<cudf::packed_columns> data,
+    std::vector<int64_t> remainingBytes)>;
+
+struct UcxDataAvailable {
+  UcxDataAvailableCallback callback{nullptr};
+  std::shared_ptr<cudf::packed_columns> data;
+  std::vector<int64_t> remainingBytes;
+
+  void notify() {
+    if (callback) {
+      callback(std::move(data), remainingBytes);
+    }
+  }
+};
+
+/// @brief The UcxDestinationQueue stores cudf::packed_columns for a single
+/// downstream task. The data is enqueued by one or more parallel
+/// UcxPartitionedOutput operators and dequeued again by the
+/// UcxExchangeServer. The UcxDestinationQueue corresponds to the
+/// DestinationBuffer of Velox. In Ucx, no serialization/deserialization is
+/// needed, only packing of data nor is the data segmented and re-assembled.
+class UcxDestinationQueue {
+ public:
+  struct Stats {
+    void recordEnqueue(const cudf::packed_columns* data);
+
+    void recordDequeue(const cudf::packed_columns* data);
+
+    // what has been queued
+    int64_t bytesQueued{0};
+    int64_t packedColumnsQueued{0};
+
+    // what has been dequeued
+    int64_t bytesSent{0};
+    int64_t packedColumnsSent{0};
+  };
+
+  /// @brief Enqueues the data to the back of the queue.
+  /// @param data Corresponds to a RowVector
+  void enqueueBack(std::shared_ptr<cudf::packed_columns> data);
+
+  /// @brief Enqueues the data to the front of the queue. This is needed when
+  /// a transfer fails.
+  /// @param data
+  void enqueueFront(std::shared_ptr<cudf::packed_columns> data);
+
+  struct Data {
+    std::shared_ptr<cudf::packed_columns> data;
+    std::vector<int64_t> remainingBytes;
+    /// Whether the result is returned immediately without invoking the `notify'
+    /// callback.
+    bool immediate{false};
+  };
+
+  /// @brief Removes the data from the front of the queue and transfers
+  /// ownership to the caller. If there is no data, 'notify' is installed and it
+  /// will be called when data becomes available. In this case, a nullptr is
+  /// returned.
+  [[nodiscard]] Data getData(UcxDataAvailableCallback notify);
+
+  /// Removes all remaining data from the queue.
+  void deleteResults();
+
+  /// Returns and clears the notify callback, if any, along with arguments for
+  /// the callback.
+  UcxDataAvailable getAndClearNotify();
+
+  /// Finishes this destination buffer, set finished stats.
+  void finish();
+
+  /// Returns the stats of this buffer.
+  Stats stats() const;
+
+  std::string toString();
+
+ private:
+  void clearNotify();
+
+  std::deque<std::shared_ptr<cudf::packed_columns>> queue_;
+  UcxDataAvailableCallback notify_{nullptr};
+  Stats stats_;
+};
+
+/// @brief The UcxOutputQueue manages all data coming from a single task that
+/// are destined to one or more downstream sink tasks. The UcxOutputQueue uses
+/// a vector of DestinationQueues, one for each destination. The UcxOutputQueue
+/// is also responsible for tracking the number of drivers that produce data.
+/// The number of drivers may change dynamically, so tracking this happens at
+/// two levels:
+/// - updateNumDrivers is used to track the number of drivers.
+/// - noMoreData is called by each driver when the driver is done and has no
+/// more data will be added.
+class UcxOutputQueue : public std::enable_shared_from_this<UcxOutputQueue> {
+ public:
+  /// @brief Creates a new output queue for a data-producing task.
+  /// @param taskId The id of the source task that produces the data
+  /// @param numDestinations The number of destinations, i.e. the partitions.
+  /// @param numDrivers The initial number of drivers.
+  /// @param kind The output mode (partitioned, broadcast, etc.)
+  UcxOutputQueue(
+      std::shared_ptr<exec::Task> task,
+      uint32_t numDestinations,
+      uint32_t numDrivers,
+      core::PartitionedOutputNode::Kind kind =
+          core::PartitionedOutputNode::Kind::kPartitioned);
+
+  /// @brief initializes an unitialized queue. This is needed in order to
+  /// support delayed construction, i.e. if a "getData" arrives before the queue
+  /// exists, the queue manager can create an unitialized queue just for the
+  /// sake of storing the callback notification. The queue is then initialized
+  /// later properly, and eventually the callback fires.
+  /// @return True, if initialization was successful, i.e. the queue wasn't
+  /// already initialized.
+  bool initialize(
+      std::shared_ptr<exec::Task> task,
+      uint32_t numDestinations,
+      uint32_t numDrivers,
+      core::PartitionedOutputNode::Kind kind =
+          core::PartitionedOutputNode::Kind::kPartitioned);
+
+  core::PartitionedOutputNode::Kind kind() const {
+    return kind_;
+  }
+
+  /// Returns true if this queue has been initialized via initializeTask()
+  /// (not just a placeholder created by early getData() calls).
+  /// Uses an acquire load so that all fields written before the release
+  /// store in initialize() (kind_, numDrivers_, task_, etc.) are visible
+  /// to the caller. This makes lock-free reads from canUseIntraNode()
+  /// safe across threads.
+  bool isInitialized() const {
+    return initialized_.load(std::memory_order_acquire);
+  }
+
+  /// @brief When we understand the final number of split groups (for grouped
+  /// execution only), we need to update the number of producing drivers here.
+  void updateNumDrivers(uint32_t newNumDrivers);
+
+  /// @brief Enqueues the data for the given destination. Currently, only
+  /// partitioned output mode is supported where the number of destinations is
+  /// fixed. Is is an error to provide a destination larger than the initial
+  /// number of destinations. This will change in the future and if destination
+  /// > numDestinations, then this will be dynamically adapted like it is done
+  /// in OutputQueue.
+  /// @param destination The destination, must be < numDestinations.
+  /// @param data The data.
+  /// @param numRows The number of rows in the data.
+  void enqueue(
+      int destination,
+      std::unique_ptr<cudf::packed_columns> data,
+      int32_t numRows);
+
+  /// @brief Checks if the queue is over capacity and returns a future if so.
+  /// This should be called after enqueueing all partitions for a batch.
+  /// @param future Output parameter - populated with a future if blocked.
+  /// @return True if blocked (queue over capacity), false otherwise.
+  bool checkBlocked(ContinueFuture* future);
+
+  /// @brief Returns the data for the given destination through the callback
+  /// function. If data is available, notify will be called immediately. If
+  /// there is no data, 'notify' is installed and it will be called when data
+  /// becomes available.
+  void getData(int destination, UcxDataAvailableCallback notify);
+
+  /// @brief Indicates that a driver is done and won't enqueue any more data.
+  void noMoreData();
+
+  /// @brief Updates the number of destination buffers. For broadcast mode,
+  /// new destinations are backfilled with previously broadcast data.
+  /// Modeled on OutputBuffer::updateOutputBuffers().
+  void updateOutputBuffers(int numBuffers, bool noMoreBuffers);
+
+  /// @brief Returns true if the OutputQueue is finished. Thread-safe.
+  bool isFinished();
+
+  /// @brief Same as isFinished but must only be called when owning the lock.
+  bool isFinishedLocked();
+
+  /// @brief Deletes all queued data and makes all subsequent getData requests
+  /// for 'destination' return empty results.
+  void deleteResults(int destination);
+
+  /// Continues any possibly waiting producers. Called when the producer task
+  /// has an error or is cancelled.
+  void terminate();
+
+  std::string toString();
+
+  /// @brief The stats of this output queue are shoe-horned into the stats
+  /// object of OutputBuffer. Since the OutputBuffer's stat object is part of
+  /// the Task stats and eventually processed at the Presto layer, this is the
+  /// least intrusive way to convey stats information. The stats info from the
+  /// UcxDestinationQueue are omitted since also the DestinationBuffer's stats
+  /// are never processed by Presto.
+  exec::OutputBuffer::Stats stats();
+
+ private:
+  // Percentage of maxSize below which a blocked producer should
+  // be unblocked.
+  static constexpr int32_t kContinuePct = 90;
+
+  // Methods that update the statistics.
+  void updateStatsWithEnqueuedLocked(int64_t bytes, int64_t rows);
+
+  // updates the counters and returns promises if the queuedBytes_ counter falls
+  // below the continueSize_ low water mark. These promises then need to be
+  // realized outside the lock.
+  void updateStatsWithFreedLocked(
+      int64_t bytes,
+      int64_t numPackedCols,
+      std::vector<ContinuePromise>& promises);
+
+  void updateTotalQueuedBytesMsLocked();
+
+  int64_t getAverageQueueTimeMsLocked() const;
+
+  // internal function that is called when all drivers are done.
+  void noMoreDrivers();
+
+  // If this is called due to a driver processed all its data (no more data),
+  // we increment the number of finished drivers. If it is called due to us
+  // updating the total number of drivers, we don't.
+  void checkIfDone(bool oneDriverFinished);
+
+  bool enqueuePartitionedOutputLocked(
+      int destination,
+      std::shared_ptr<cudf::packed_columns> data,
+      std::vector<UcxDataAvailable>& dataAvailableCbs);
+
+  void enqueueBroadcastOutputLocked(
+      std::shared_ptr<cudf::packed_columns> data,
+      std::vector<UcxDataAvailable>& dataAvailableCbs);
+
+  // Reference to the task that owns this UcxQueue.
+  std::shared_ptr<exec::Task> task_{nullptr};
+
+  // The output mode (partitioned, broadcast, etc.)
+  core::PartitionedOutputNode::Kind kind_{
+      core::PartitionedOutputNode::Kind::kPartitioned};
+
+  // Set to true at the end of initialize() with memory_order_release.
+  // Lock-free readers (canUseIntraNode) load with memory_order_acquire
+  // so that all fields written before the store are visible.
+  std::atomic<bool> initialized_{false};
+
+  // For broadcast: stores data for late-arriving destinations that need
+  // backfill. Cleared once noMoreQueues_ is set.
+  std::vector<std::shared_ptr<cudf::packed_columns>> dataToBroadcast_;
+
+  /// If 'queuedBytes_' > 'maxSize_', each producer is blocked after adding
+  /// data.
+  uint64_t maxSize_{0};
+  // When 'queuedBytes_' goes below 'continueSize_', blocked producers are
+  // resumed.
+  uint64_t continueSize_{0};
+
+  // Total number of drivers expected to produce results. This number will
+  // decrease in the end of grouped execution, when we understand the real
+  // number of producer drivers (depending on the number of split groups).
+  uint32_t numDrivers_{0};
+
+  // If true, then we don't allow to add new destination buffers. This only
+  // applies for non-partitioned output buffer type.
+  bool noMoreQueues_{false};
+
+  // For governing multi-threaded access.
+  std::mutex mutex_;
+
+  // One buffer per destination.
+  std::vector<std::unique_ptr<UcxDestinationQueue>> queues_;
+
+  // keep track of the number of drivers that have finished.
+  uint32_t numFinished_{0};
+
+  bool atEnd_ = false;
+
+  // promises when buffer reached capacity and blocked further enqueueing.
+  std::vector<ContinuePromise> promises_;
+
+  // actual data in 'queues_'
+  int64_t queuedBytes_{0};
+  int64_t queuedPackedColumns_{0};
+
+  // The total number of bytes/rows/packedColumns sent via this output queue.
+  int64_t totalBytesSent_{0};
+  int64_t totalRowsSent_{0};
+  int64_t totalPackedColumnsSent_{0};
+
+  // Time since last change in queuedBytes_. Used to compute total time data
+  // is queued. Ignored if queuedBytes_ is zero.
+  uint64_t queueStartMs_;
+
+  // Total time data is queued as bytes * time.
+  double totalQueuedBytesMs_;
+};
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/WorkQueue.h b/velox/experimental/ucx-exchange/WorkQueue.h
new file mode 100644
index 00000000000..3350b0754a9
--- /dev/null
+++ b/velox/experimental/ucx-exchange/WorkQueue.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <list>
+#include <memory>
+#include <mutex>
+
+template <typename T>
+class WorkQueue {
+ public:
+  WorkQueue() = default;
+  ~WorkQueue() = default;
+
+  // non-copyable
+  WorkQueue(const WorkQueue&) = delete;
+  WorkQueue& operator=(const WorkQueue&) = delete;
+
+  // push always succeeds; never blocks
+  void push(std::shared_ptr<T> item) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    queue_.emplace_back(std::move(item));
+  }
+
+  // pop never blocks; returns nullptr if empty
+  std::shared_ptr<T> pop() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if (queue_.empty()) {
+      return nullptr;
+    }
+
+    auto item = std::move(queue_.front());
+    queue_.pop_front();
+    return item;
+  }
+
+  // remove an element from the queue.
+  bool erase(std::shared_ptr<T> item) {
+    bool erased = false;
+    std::lock_guard<std::mutex> lock(mutex_);
+    auto it = std::find(queue_.begin(), queue_.end(), item);
+    if (it != queue_.end()) {
+      queue_.erase(it);
+      erased = true;
+    }
+    return erased;
+  }
+
+  // helpers
+  bool empty() const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return queue_.empty();
+  }
+
+  size_t size() const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return queue_.size();
+  }
+
+ private:
+  mutable std::mutex mutex_;
+  std::list<std::shared_ptr<T>> queue_;
+};
diff --git a/velox/experimental/ucx-exchange/tests/CMakeLists.txt b/velox/experimental/ucx-exchange/tests/CMakeLists.txt
new file mode 100644
index 00000000000..2275984faf8
--- /dev/null
+++ b/velox/experimental/ucx-exchange/tests/CMakeLists.txt
@@ -0,0 +1,48 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_executable(
+  ucx_exchange_test
+  UcxOutputQueueManagerTest.cpp
+  UcxExchangeTest.cpp
+  Main.cpp
+  UcxTestHelpers.cpp
+  UcxTestData.cpp
+  UcxPartitionedOutputMock.cpp
+  SinkDriverMock.cpp
+  SourceDriverMock.cpp
+)
+
+add_test(
+  NAME ucx_exchange_test
+  COMMAND ucx_exchange_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+set_tests_properties(ucx_exchange_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
+
+target_link_libraries(
+  ucx_exchange_test
+  velox_ucx_exchange
+  velox_cudf_exec
+  velox_exec
+  velox_exec_test_lib
+  velox_test_util
+  velox_vector_fuzzer
+  gtest
+  gtest_main
+  Folly::folly
+  fmt::fmt
+  ucxx::ucxx
+)
diff --git a/velox/experimental/ucx-exchange/tests/Main.cpp b/velox/experimental/ucx-exchange/tests/Main.cpp
new file mode 100644
index 00000000000..d5501cd3bd5
--- /dev/null
+++ b/velox/experimental/ucx-exchange/tests/Main.cpp
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/process/ThreadDebugInfo.h"
+#include "velox/experimental/cudf/CudfConfig.h"
+
+#include <folly/Unit.h>
+#include <folly/init/Init.h>
+#include <gflags/gflags.h>
+#include <gtest/gtest.h>
+
+DEFINE_int32(
+    exchange_log_level,
+    0,
+    "VLOG level for ucx-exchange modules (0=silent, 1-3=increasing verbosity)");
+
+// This main is needed for some tests on linux.
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  // Signal handler required for ThreadDebugInfoTest
+  facebook::velox::process::addDefaultFatalSignalHandler();
+  folly::Init init(&argc, &argv, false);
+  facebook::velox::cudf_velox::CudfConfig::getInstance().exchangeLogLevel =
+      FLAGS_exchange_log_level;
+  return RUN_ALL_TESTS();
+}
diff --git a/velox/experimental/ucx-exchange/tests/SinkDriverMock.cpp b/velox/experimental/ucx-exchange/tests/SinkDriverMock.cpp
new file mode 100644
index 00000000000..6c2cce149d2
--- /dev/null
+++ b/velox/experimental/ucx-exchange/tests/SinkDriverMock.cpp
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/ucx-exchange/tests/SinkDriverMock.h"
+
+#include <cudf/binaryop.hpp>
+#include <cudf/column/column_factories.hpp>
+#include <cudf/column/column_view.hpp>
+#include <cudf/concatenate.hpp>
+#include <cudf/strings/strings_column_view.hpp>
+#include <cudf/table/table_view.hpp>
+#include <cudf/unary.hpp>
+
+using namespace facebook::velox::exec;
+
+namespace facebook::velox::ucx_exchange {
+
+constexpr int kPipelineId = 0;
+constexpr uint32_t kPartitionId = 0; // not used in tests.
+
+SinkDriverMock::SinkDriverMock(
+    std::shared_ptr<facebook::velox::exec::Task> task,
+    uint32_t numDrivers,
+    std::shared_ptr<BaseTableGenerator> referenceData)
+    : task_{std::move(task)},
+      numDrivers_{numDrivers},
+      numRows_{0},
+      numBytes_{0},
+      referenceData_(referenceData) {
+  // Create a UcxExchangeClient shared across all exchange operators.
+  exchangeClient_ = std::make_shared<UcxExchangeClient>(
+      task_->taskId(), task_->destination(), numDrivers_);
+  uint32_t operatorId = 0;
+  auto planNode = task_->planFragment().planNode;
+  // create the set of exchange operators.
+  for (uint32_t driverId = 0; driverId < numDrivers; ++driverId) {
+    driverCtxs_.emplace_back(
+        std::make_shared<DriverCtx>(
+            task_, driverId, kPipelineId, kUngroupedGroupId, kPartitionId));
+    hybridExchanges_.emplace_back(
+        std::make_unique<UcxExchange>(
+            operatorId, driverCtxs_.back().get(), planNode, exchangeClient_));
+  }
+}
+
+void SinkDriverMock::updateDataValidity(const cudf::table_view& tab) {
+  if (!referenceData_) {
+    return; // No reference data to check against
+  }
+
+  auto stream = rmm::cuda_stream_default;
+
+  // Use the polymorphic verifyTable method
+  // Note: For chunk-based verification, we use startRow=0 since each chunk
+  // contains rows that should match the reference data from the beginning.
+  // This assumes the test sends the same data pattern in each chunk.
+  bool valid = referenceData_->verifyTable(tab, 0, tab.num_rows(), stream);
+
+  if (!valid) {
+    dataValidFlag_ = false;
+  }
+}
+
+void SinkDriverMock::run() {
+  threads_.clear();
+  for (int32_t driver = 0; driver < numDrivers_; ++driver) {
+    threads_.emplace_back(
+        &SinkDriverMock::receiveAllData, this, hybridExchanges_[driver].get());
+  }
+}
+
+void SinkDriverMock::receiveAllData(UcxExchange* hybridExchange) {
+  while (true) {
+    ContinueFuture future;
+    auto blocked = hybridExchange->isBlocked(&future);
+    if (blocked != BlockingReason::kNotBlocked) {
+      future.wait();
+    } else {
+      // not blocked.
+      RowVectorPtr res = hybridExchange->getOutput();
+      if (res) {
+        facebook::velox::cudf_velox::CudfVectorPtr cudfRes =
+            std::dynamic_pointer_cast<facebook::velox::cudf_velox::CudfVector>(
+                res);
+        numBytes_.fetch_add(cudfRes->estimateFlatSize());
+        numRows_ += cudfRes->getTableView().num_rows();
+        numChunksReceived_.fetch_add(1);
+        // If we have Reference data check the received data is the same
+        if (referenceData_)
+          updateDataValidity(cudfRes->getTableView());
+      }
+    }
+    if (hybridExchange->isFinished()) {
+      break;
+    }
+  }
+  hybridExchange->close();
+}
+
+void SinkDriverMock::joinThreads() {
+  for (auto& thread : threads_) {
+    thread.join();
+  }
+  threads_.clear();
+}
+
+void SinkDriverMock::addSplits(
+    std::vector<facebook::velox::exec::Split>& splits) {
+  auto planNode = task_->planFragment().planNode;
+  for (auto& split : splits) {
+    VLOG(3) << "Adding split to planNode: " << planNode->id()
+            << " to sink driver for task " << task_->taskId();
+    task_->addSplit(planNode->id(), std::move(split));
+  }
+  task_->noMoreSplits(planNode->id());
+}
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/tests/SinkDriverMock.h b/velox/experimental/ucx-exchange/tests/SinkDriverMock.h
new file mode 100644
index 00000000000..aea346e7f1e
--- /dev/null
+++ b/velox/experimental/ucx-exchange/tests/SinkDriverMock.h
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/exec/Driver.h"
+#include "velox/experimental/ucx-exchange/UcxExchange.h"
+#include "velox/experimental/ucx-exchange/tests/UcxTestData.h"
+#include "velox/experimental/ucx-exchange/tests/UcxTestHelpers.h"
+
+namespace facebook::velox::ucx_exchange {
+
+using exec::DriverCtx;
+
+/// @class SinkTaskMock
+/// @brief A mock class that receives data through an exchange from one or more
+/// upstream remote tasks. This class mocks the setup and execution of a plan
+/// fragment with a single UcxExchange operator.
+
+class SinkDriverMock {
+ public:
+  /// @brief Mocks the driver to execute a pipeline with a single exchange
+  /// operator. One or more of these drivers may be used to driver multiple
+  /// exchange operator instances in the same task. The driver will create the
+  /// exchange operator instance and drive it until is is finished or an error
+  /// occurs.
+  /// @param task A pointer to the sink task.
+  /// @param numDrivers The number of drivers used in running the exchange
+  /// operators
+  /// @param referenceData Table generator for reference data to check against,
+  /// if should not check send null
+
+  SinkDriverMock(
+      std::shared_ptr<facebook::velox::exec::Task> task,
+      uint32_t numDrivers = 1,
+      std::shared_ptr<BaseTableGenerator> referenceData = nullptr);
+
+  /// @brief Executes the exchange operator until it finishes receiving all data
+  /// from the upstream.
+  void run();
+
+  /// @brief Waits until all threads executing the exchange operators have
+  /// terminated.
+  void joinThreads();
+
+  /// @brief Adds the set of splits to the task, from where they will be picked
+  /// up by the exchange operator to initiate connections to the upstream task.
+  /// @param splits A vector containing remote splits.
+  void addSplits(std::vector<facebook::velox::exec::Split>& splits);
+
+  /// @brief Returns the number of rows read by "run".
+  uint64_t numRows() const {
+    return numRows_;
+  }
+
+  /// @brief Returns the number of bytes read by "run".
+  uint64_t numBytes() const {
+    return numBytes_.load();
+  }
+
+  /// @brief Returns the number of chunks (non-null getOutput calls) received.
+  uint64_t numChunksReceived() const {
+    return numChunksReceived_.load();
+  }
+
+  bool dataIsValid() {
+    return dataValidFlag_;
+  }
+
+ private:
+  // Drives a single hybrid exchange operator until all data has been received.
+  void receiveAllData(UcxExchange* hybridExchange);
+
+  /// @brief checks if the received table corresponds to that sent, sets
+  /// dataValidFlag_=false if not
+  /// @param tab
+  void updateDataValidity(const cudf::table_view& tab);
+
+  std::atomic<bool> dataValidFlag_{true};
+  std::shared_ptr<facebook::velox::exec::Task> task_;
+  std::shared_ptr<UcxExchangeClient> exchangeClient_;
+
+  std::vector<std::shared_ptr<DriverCtx>> driverCtxs_;
+  std::vector<std::unique_ptr<UcxExchange>> hybridExchanges_;
+  uint32_t numDrivers_;
+  std::atomic<uint64_t> numRows_;
+  std::atomic<uint64_t> numBytes_{0};
+  std::atomic<uint64_t> numChunksReceived_{0};
+
+  const std::shared_ptr<BaseTableGenerator> referenceData_;
+  std::vector<std::thread> threads_;
+};
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/tests/SourceDriverMock.cpp b/velox/experimental/ucx-exchange/tests/SourceDriverMock.cpp
new file mode 100644
index 00000000000..9b119774982
--- /dev/null
+++ b/velox/experimental/ucx-exchange/tests/SourceDriverMock.cpp
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/ucx-exchange/tests/SourceDriverMock.h"
+#include <cudf/utilities/default_stream.hpp>
+#include "velox/experimental/cudf/exec/Utilities.h"
+#include "velox/experimental/ucx-exchange/tests/UcxTestHelpers.h"
+
+namespace facebook::velox::ucx_exchange {
+
+constexpr int kPipelineId = 0;
+constexpr uint32_t kPartitionId = 0;
+
+SourceDriverMock::SourceDriverMock(
+    std::shared_ptr<facebook::velox::exec::Task> task,
+    uint32_t numDrivers,
+    uint32_t numChunks,
+    size_t numRowsPerChunk,
+    std::shared_ptr<BaseTableGenerator> tableGenerator)
+    : task_{std::move(task)},
+      numDrivers_{numDrivers},
+      numChunks_{numChunks},
+      numRowsPerChunk_{numRowsPerChunk},
+      tableGenerator_(tableGenerator) {
+  // Get the plan node - should be a PartitionedOutputNode
+  auto planNode = task_->planFragment().planNode;
+  auto partitionedOutputNode =
+      std::dynamic_pointer_cast<const core::PartitionedOutputNode>(planNode);
+  VELOX_CHECK_NOT_NULL(
+      partitionedOutputNode, "Plan node must be a PartitionedOutputNode");
+
+  uint32_t operatorId = 0;
+
+  // Create the set of UcxPartitionedOutput operators, one per driver.
+  for (uint32_t driverId = 0; driverId < numDrivers; ++driverId) {
+    driverCtxs_.emplace_back(
+        std::make_shared<exec::DriverCtx>(
+            task_,
+            driverId,
+            kPipelineId,
+            exec::kUngroupedGroupId,
+            kPartitionId));
+
+    partitionedOutputs_.emplace_back(
+        std::make_unique<UcxPartitionedOutput>(
+            operatorId,
+            driverCtxs_.back().get(),
+            partitionedOutputNode,
+            false /* eagerFlush */));
+  }
+}
+
+void SourceDriverMock::run() {
+  threads_.clear();
+  for (uint32_t driver = 0; driver < numDrivers_; ++driver) {
+    threads_.emplace_back(
+        &SourceDriverMock::sendAllData,
+        this,
+        partitionedOutputs_[driver].get());
+  }
+}
+
+void SourceDriverMock::sendAllData(UcxPartitionedOutput* partitionedOutput) {
+  auto stream = cudf::get_default_stream();
+  // Use tableGenerator's rowType if available, otherwise get from task
+  auto rowType = tableGenerator_ ? tableGenerator_->getRowType()
+                                 : task_->planFragment().planNode->outputType();
+
+  // Get memory pool from the operator
+  auto* pool = partitionedOutput->pool();
+
+  for (uint32_t chunk = 0; chunk < numChunks_; ++chunk) {
+    // 1. Create CudfVector with test data using makeCudfVector helper
+    auto cudfVector = makeCudfVector(
+        pool, numRowsPerChunk_, rowType, tableGenerator_, stream);
+
+    // 2. Check isBlocked() - if blocked, wait on future
+    while (true) {
+      ContinueFuture future;
+      auto blocked = partitionedOutput->isBlocked(&future);
+      if (blocked == exec::BlockingReason::kNotBlocked) {
+        break;
+      }
+      // Wait for the operator to become unblocked
+      future.wait();
+    }
+
+    // 3. Call addInput() now that we're not blocked
+    partitionedOutput->addInput(cudfVector);
+
+    // 4. Call getOutput() to advance operator state
+    partitionedOutput->getOutput();
+
+    VLOG(3) << "SourceDriverMock: sent chunk " << chunk << " of " << numChunks_;
+  }
+
+  // Signal no more input and finalize
+  partitionedOutput->noMoreInput();
+
+  // Continue calling getOutput() until finished
+  while (!partitionedOutput->isFinished()) {
+    ContinueFuture future;
+    auto blocked = partitionedOutput->isBlocked(&future);
+    if (blocked != exec::BlockingReason::kNotBlocked) {
+      future.wait();
+    }
+    partitionedOutput->getOutput();
+  }
+
+  VLOG(3) << "SourceDriverMock: driver finished";
+}
+
+void SourceDriverMock::joinThreads() {
+  for (auto& thread : threads_) {
+    thread.join();
+  }
+  threads_.clear();
+}
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/tests/SourceDriverMock.h b/velox/experimental/ucx-exchange/tests/SourceDriverMock.h
new file mode 100644
index 00000000000..7ed2215d910
--- /dev/null
+++ b/velox/experimental/ucx-exchange/tests/SourceDriverMock.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/exec/Driver.h"
+#include "velox/experimental/ucx-exchange/UcxPartitionedOutput.h"
+#include "velox/experimental/ucx-exchange/tests/UcxTestData.h"
+
+namespace facebook::velox::ucx_exchange {
+
+/// @class SourceDriverMock
+/// @brief A mock class that drives real UcxPartitionedOutput operators to send
+/// data to downstream tasks via the UcxOutputQueueManager. This class properly
+/// instantiates and drives UcxPartitionedOutput operators, unlike
+/// UcxPartitionedOutputMock which bypasses the operator entirely.
+class SourceDriverMock {
+ public:
+  /// @brief Creates a mock driver to execute a pipeline with
+  /// UcxPartitionedOutput operators.
+  /// @param task A pointer to the source task with a PartitionedOutput plan
+  /// node.
+  /// @param numDrivers The number of drivers (parallel operator instances).
+  /// @param numChunks The number of data chunks each driver will send.
+  /// @param numRowsPerChunk The number of rows per chunk.
+  /// @param tableGenerator Optional table generator for test data (for
+  /// integrity testing).
+  SourceDriverMock(
+      std::shared_ptr<facebook::velox::exec::Task> task,
+      uint32_t numDrivers,
+      uint32_t numChunks,
+      size_t numRowsPerChunk,
+      std::shared_ptr<BaseTableGenerator> tableGenerator = nullptr);
+
+  /// @brief Starts the driver threads to send data through
+  /// UcxPartitionedOutput.
+  void run();
+
+  /// @brief Waits until all threads have terminated.
+  void joinThreads();
+
+ private:
+  /// @brief Driver loop that sends all data chunks through the operator.
+  /// Follows the standard Velox operator driver pattern:
+  /// 1. Create CudfVector with test data
+  /// 2. Check isBlocked() - if blocked, wait on future
+  /// 3. When not blocked, call addInput(cudfVector)
+  /// 4. Call getOutput() to advance operator state
+  /// @param partitionedOutput The UcxPartitionedOutput operator to drive.
+  void sendAllData(UcxPartitionedOutput* partitionedOutput);
+
+  std::shared_ptr<facebook::velox::exec::Task> task_;
+  std::vector<std::shared_ptr<exec::DriverCtx>> driverCtxs_;
+  std::vector<std::unique_ptr<UcxPartitionedOutput>> partitionedOutputs_;
+
+  const uint32_t numDrivers_;
+  const uint32_t numChunks_;
+  const size_t numRowsPerChunk_;
+  const std::shared_ptr<BaseTableGenerator> tableGenerator_;
+
+  std::vector<std::thread> threads_;
+};
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/tests/UcxExchangeTest.cpp b/velox/experimental/ucx-exchange/tests/UcxExchangeTest.cpp
new file mode 100644
index 00000000000..632d419c329
--- /dev/null
+++ b/velox/experimental/ucx-exchange/tests/UcxExchangeTest.cpp
@@ -0,0 +1,1484 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <cudf/column/column_factories.hpp>
+#include <cudf/contiguous_split.hpp>
+#include <cudf/copying.hpp>
+#include <cudf/partitioning.hpp>
+#include <cudf/strings/strings_column_view.hpp>
+#include <cudf/structs/structs_column_view.hpp>
+#include <cudf/table/table.hpp>
+#include <cudf/types.hpp>
+#include <folly/Executor.h>
+#include <folly/synchronization/EventCount.h>
+#include <gtest/gtest-param-test.h>
+#include <gtest/gtest.h>
+#include <rmm/device_buffer.hpp>
+#include <chrono>
+#include <future>
+#include <memory>
+#include <sstream>
+#include <vector>
+#include "velox/common/memory/MemoryPool.h"
+#include "velox/core/QueryConfig.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/ucx-exchange/Communicator.h"
+#include "velox/experimental/ucx-exchange/UcxExchangeProtocol.h"
+#include "velox/experimental/ucx-exchange/UcxOutputQueueManager.h"
+#include "velox/experimental/ucx-exchange/tests/SinkDriverMock.h"
+#include "velox/experimental/ucx-exchange/tests/SourceDriverMock.h"
+#include "velox/experimental/ucx-exchange/tests/UcxPartitionedOutputMock.h"
+#include "velox/experimental/ucx-exchange/tests/UcxTestData.h"
+#include "velox/experimental/ucx-exchange/tests/UcxTestHelpers.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::core;
+
+namespace facebook::velox::ucx_exchange {
+
+struct ExchangeTestParams {
+  int numSrcDrivers;
+  int numDstDrivers;
+  int numPartitions;
+  int numChunks;
+  int numRowsPerChunk;
+  int numUpstreamTasks;
+  TableType tableType = TableType::NARROW; // Default to narrow table
+};
+
+// Helper function to generate test parameters with different numUpstreamTasks
+static std::vector<ExchangeTestParams> generateTestParams() {
+  std::vector<ExchangeTestParams> params;
+
+  // Base configurations
+  struct BaseConfig {
+    const char* description;
+    int numSrcDrivers;
+    int numDstDrivers;
+    int numPartitions;
+    int numChunks;
+    int numRowsPerChunk;
+    TableType tableType;
+  };
+
+  std::vector<BaseConfig> baseConfigs = {
+      // Test to check end-2-end connectivity
+      {"Simple", 1, 1, 1, 100, 1000 * 1000, TableType::NARROW},
+      // Test to check parallelism at source
+      {"SourceDrivers", 10, 1, 1, 10, 1000 * 1000, TableType::NARROW},
+      // Test to check parallelism at source and sink
+      {"SourceSinkDrivers", 10, 10, 1, 10, 1000, TableType::NARROW},
+      // Test with multiple partitions (hash partitioning)
+      {"MultiPartition", 1, 1, 4, 100, 1000, TableType::NARROW},
+      // Test with multiple partitions and multiple drivers
+      {"MultiPartitionDrivers", 4, 4, 4, 25, 1000, TableType::NARROW},
+      // Wide table tests with all data types including STRUCT
+      // Single partition wide table (no hash partitioning)
+      {"WideTableSingle", 1, 1, 1, 100, 1000, TableType::WIDE},
+      // Multi-partition wide table (uses hash partitioning)
+      {"WideTableMulti", 1, 1, 4, 10, 1000 * 10000, TableType::WIDE}};
+
+  // Generate variants with different number of upstream tasks.
+  std::vector<int> upstreamTaskCounts = {1, 10};
+
+  for (const auto& base : baseConfigs) {
+    for (int numUpstream : upstreamTaskCounts) {
+      params.push_back(
+          {.numSrcDrivers = base.numSrcDrivers,
+           .numDstDrivers = base.numDstDrivers,
+           .numPartitions = base.numPartitions,
+           .numChunks = base.numChunks,
+           .numRowsPerChunk = base.numRowsPerChunk,
+           .numUpstreamTasks = numUpstream,
+           .tableType = base.tableType});
+    }
+  }
+
+  return params;
+}
+
+// Custom parameter name generator for readable test names
+struct ExchangeTestParamsPrinter {
+  std::string operator()(
+      const ::testing::TestParamInfo<ExchangeTestParams>& info) const {
+    const auto& p = info.param;
+    std::ostringstream oss;
+    oss << "Src" << p.numSrcDrivers << "_Dst" << p.numDstDrivers << "_Part"
+        << p.numPartitions << "_Chunks" << p.numChunks << "_RowsPer"
+        << p.numRowsPerChunk << "_Upstream" << p.numUpstreamTasks << "_"
+        << (p.tableType == TableType::WIDE ? "Wide" : "Narrow");
+    return oss.str();
+  }
+};
+
+class UcxExchangeTest : public testing::TestWithParam<ExchangeTestParams> {
+ protected:
+  static constexpr uint16_t kCommunicatorPort = 21346;
+  static constexpr auto kUnusedCoordinatorUrl =
+      std::string_view("http://localhost:12345/bla");
+
+  static std::shared_ptr<UcxOutputQueueManager> queueManager_;
+  static std::shared_ptr<std::thread> communicatorThread_;
+  static std::shared_ptr<Communicator> communicator_;
+  static std::atomic<uint32_t> testCounter_;
+
+  // Generate a unique task ID prefix for this test run to avoid collisions
+  // between parametrized tests
+  std::string getUniqueTaskPrefix() {
+    return "t" + std::to_string(testCounter_.fetch_add(1)) + "_";
+  }
+
+  // Get the row type based on the table type from test params
+  facebook::velox::RowTypePtr getRowType(TableType tableType) {
+    if (tableType == TableType::WIDE) {
+      return WideTestTable::kRowType;
+    }
+    return UcxTestData::kTestRowType;
+  }
+
+  // Check if we should skip this test for wide table configurations
+  // Some tests are not yet compatible with WideTestTable
+  bool shouldSkipWideTable() {
+    ExchangeTestParams p = GetParam();
+    return p.tableType == TableType::WIDE;
+  }
+
+  static void SetUpTestCase() {
+    VLOG(0) << "setup test case, creating queue manager, communicator, etc..";
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+
+    queueManager_ = UcxOutputQueueManager::getInstanceRef();
+    ContinueFuture future;
+    communicator_ = facebook::velox::ucx_exchange::Communicator::initAndGet(
+        kCommunicatorPort, std::string(kUnusedCoordinatorUrl), &future);
+    if (communicator_) {
+      communicatorThread_ = std::make_shared<std::thread>(
+          &facebook::velox::ucx_exchange::Communicator::run,
+          communicator_.get());
+    } else {
+      ADD_FAILURE() << "Communicator initialization failed";
+    }
+    future.wait();
+  }
+
+  static void TearDownTestCase() {
+    communicator_->stop();
+    communicator_.reset();
+    communicatorThread_->join();
+    communicatorThread_.reset();
+  }
+
+  void SetUp() override {
+    VLOG(0) << "creating pool";
+    pool_ = facebook::velox::memory::memoryManager()->addLeafPool(
+        "UcxTestMemoryPool");
+  }
+
+  exec::Split remoteSplit(std::string_view taskId, int partitionId) {
+    std::string remoteUrl = fmt::format(
+        "http://127.0.0.1:{}/v1/task/{}/results/{}",
+        kCommunicatorPort - 3,
+        taskId,
+        partitionId);
+    return exec::Split(
+        std::make_shared<facebook::velox::exec::RemoteConnectorSplit>(
+            remoteUrl));
+  }
+
+  std::shared_ptr<facebook::velox::memory::MemoryPool> pool_;
+};
+
+INSTANTIATE_TEST_SUITE_P(
+    UcxExchangeTest,
+    UcxExchangeTest,
+    ::testing::ValuesIn(generateTestParams()),
+    ExchangeTestParamsPrinter());
+
+TEST_P(UcxExchangeTest, basicTest) {
+  VLOG(3) << "+ UcxExchangeTest::basicTest";
+  ExchangeTestParams p = GetParam();
+
+  // Skip wide table tests - UcxPartitionedOutputMock only supports narrow
+  // tables
+  if (shouldSkipWideTable()) {
+    GTEST_SKIP()
+        << "basicTest skipped for WideTable - uses UcxPartitionedOutputMock";
+  }
+
+  int numUpstreamTasks = p.numUpstreamTasks;
+
+  // Use unique task prefix to avoid collisions between parametrized tests
+  const std::string taskPrefix = getUniqueTaskPrefix();
+  std::vector<std::string> srcTaskIds;
+
+  std::vector<std::shared_ptr<UcxPartitionedOutputMock>> sourceMocks;
+
+  // Create n upstream tasks.
+  for (int i = 0; i < numUpstreamTasks; i++) {
+    const std::string srcTaskId = taskPrefix + "sourceTask" + std::to_string(i);
+    srcTaskIds.push_back(srcTaskId);
+    auto srcTask =
+        createSourceTask(srcTaskId, pool_, UcxTestData::kTestRowType);
+
+    // tell the queue manager that a new source task exists.
+    queueManager_->initializeTask(
+        srcTask,
+        core::PartitionedOutputNode::Kind::kPartitioned,
+        p.numPartitions,
+        p.numSrcDrivers);
+
+    sourceMocks.emplace_back(
+        std::make_shared<UcxPartitionedOutputMock>(
+            srcTaskId,
+            p.numSrcDrivers,
+            p.numPartitions,
+            p.numChunks,
+            p.numRowsPerChunk));
+  }
+
+  // Create one sink task per partition to receive data from each partition
+  std::vector<std::shared_ptr<SinkDriverMock>> sinkDrivers;
+  for (int partitionId = 0; partitionId < p.numPartitions; ++partitionId) {
+    const std::string sinkTaskId =
+        taskPrefix + "sinkTask" + std::to_string(partitionId);
+    core::PlanNodeId exchangeNodeId;
+    auto sinkTask = createExchangeTask(
+        sinkTaskId, UcxTestData::kTestRowType, partitionId, exchangeNodeId);
+
+    auto sinkDriver =
+        std::make_shared<SinkDriverMock>(sinkTask, p.numDstDrivers);
+
+    // Add remote splits for all upstream tasks to this partition
+    std::vector<facebook::velox::exec::Split> splits;
+    for (int i = 0; i < numUpstreamTasks; i++) {
+      splits.emplace_back(remoteSplit(srcTaskIds[i], partitionId));
+    }
+    sinkDriver->addSplits(splits);
+
+    sinkDrivers.push_back(sinkDriver);
+  }
+
+  // Start the mocks.
+  VLOG(3) << "Starting source tasks";
+  for (int i = 0; i < numUpstreamTasks; i++) {
+    sourceMocks[i]->run();
+  }
+  VLOG(3) << "Starting " << p.numPartitions << " sink tasks";
+  for (auto& sinkDriver : sinkDrivers) {
+    sinkDriver->run();
+  }
+
+  for (int i = 0; i < numUpstreamTasks; i++) {
+    sourceMocks[i]->joinThreads();
+  }
+  VLOG(3) << "Source tasks done.";
+  for (auto& sinkDriver : sinkDrivers) {
+    sinkDriver->joinThreads();
+  }
+  VLOG(3) << "All sink tasks done.";
+
+  // Total rows received across all partitions should equal total rows sent.
+  // UcxPartitionedOutputMock sends numChunks * numRowsPerChunk to EACH
+  // partition, so total rows = chunks * rowsPerChunk * partitions *
+  // upstreamTasks * srcDrivers
+  size_t expectedRows = static_cast<size_t>(p.numChunks) * p.numRowsPerChunk *
+      p.numPartitions * numUpstreamTasks * p.numSrcDrivers;
+  size_t totalReceivedRows = 0;
+  for (auto& sinkDriver : sinkDrivers) {
+    totalReceivedRows += sinkDriver->numRows();
+  }
+
+  GTEST_ASSERT_EQ(expectedRows, totalReceivedRows);
+
+  // Remove the srcTasks from the queue manager, so queue get freed
+  for (const auto& srcTaskId : srcTaskIds) {
+    queueManager_->removeTask(srcTaskId);
+  }
+
+  VLOG(3) << "- UcxExchangeTest::basicTest";
+}
+
+TEST_P(UcxExchangeTest, dataIntegrityTest) {
+  VLOG(3) << "+ UcxExchangeTest::dataIntegrityTest";
+  ExchangeTestParams p = GetParam();
+
+  // Skip wide table tests - UcxPartitionedOutputMock only supports narrow
+  // tables
+  if (shouldSkipWideTable()) {
+    GTEST_SKIP()
+        << "dataIntegrityTest skipped for WideTable - uses UcxPartitionedOutputMock";
+  }
+
+  int numUpstreamTasks = p.numUpstreamTasks;
+
+  // Use unique task prefix to avoid collisions between parametrized tests
+  const std::string taskPrefix = getUniqueTaskPrefix();
+  std::vector<std::string> srcTaskIds;
+
+  // Create some reference data to send which we will check against at the
+  // receiver
+  std::shared_ptr<UcxTestData> dataToSend = std::make_shared<UcxTestData>();
+  dataToSend->initialize(p.numRowsPerChunk);
+
+  std::vector<std::shared_ptr<UcxPartitionedOutputMock>> sourceMocks;
+
+  // Create n upstream tasks.
+  for (int i = 0; i < numUpstreamTasks; i++) {
+    const std::string srcTaskId = taskPrefix + "sourceTask" + std::to_string(i);
+    srcTaskIds.push_back(srcTaskId);
+    auto srcTask =
+        createSourceTask(srcTaskId, pool_, UcxTestData::kTestRowType);
+
+    // tell the queue manager that a new source task exists.
+    queueManager_->initializeTask(
+        srcTask,
+        core::PartitionedOutputNode::Kind::kPartitioned,
+        p.numPartitions,
+        p.numSrcDrivers);
+
+    // Mock the UcxPartitionedOutput operator, it will produce numChunks of
+    // data each containing numRowsPerChunk of data copied from the UcxTestData
+    // object data
+    sourceMocks.emplace_back(
+        std::make_shared<UcxPartitionedOutputMock>(
+            srcTaskId,
+            p.numSrcDrivers,
+            p.numPartitions,
+            p.numChunks,
+            p.numRowsPerChunk,
+            dataToSend));
+  }
+
+  // Create one sink task per partition to receive data from each partition
+  std::vector<std::shared_ptr<SinkDriverMock>> sinkDrivers;
+  for (int partitionId = 0; partitionId < p.numPartitions; ++partitionId) {
+    const std::string sinkTaskId =
+        taskPrefix + "sinkTask" + std::to_string(partitionId);
+    core::PlanNodeId exchangeNodeId;
+    auto sinkTask = createExchangeTask(
+        sinkTaskId, UcxTestData::kTestRowType, partitionId, exchangeNodeId);
+
+    auto sinkDriver =
+        std::make_shared<SinkDriverMock>(sinkTask, p.numDstDrivers, dataToSend);
+
+    // Add remote splits for all upstream tasks to this partition
+    std::vector<facebook::velox::exec::Split> splits;
+    for (int i = 0; i < numUpstreamTasks; i++) {
+      splits.emplace_back(remoteSplit(srcTaskIds[i], partitionId));
+    }
+    sinkDriver->addSplits(splits);
+
+    sinkDrivers.push_back(sinkDriver);
+  }
+
+  // Start the mocks.
+  VLOG(3) << "Starting source tasks";
+  for (int i = 0; i < numUpstreamTasks; i++) {
+    sourceMocks[i]->run();
+  }
+
+  VLOG(3) << "Starting " << p.numPartitions << " sink tasks";
+  for (auto& sinkDriver : sinkDrivers) {
+    sinkDriver->run();
+  }
+
+  for (int i = 0; i < numUpstreamTasks; i++) {
+    sourceMocks[i]->joinThreads();
+  }
+  VLOG(3) << "Source tasks done.";
+
+  for (auto& sinkDriver : sinkDrivers) {
+    sinkDriver->joinThreads();
+  }
+  VLOG(3) << "All sink tasks done.";
+
+  // Remove the srcTasks from the queue manager, so queue get freed
+  for (const auto& srcTaskId : srcTaskIds) {
+    queueManager_->removeTask(srcTaskId);
+  }
+
+  // Check data integrity across all partitions
+  bool allDataValid = true;
+  for (auto& sinkDriver : sinkDrivers) {
+    if (!sinkDriver->dataIsValid()) {
+      allDataValid = false;
+      break;
+    }
+  }
+
+  VLOG(3) << "- UcxExchangeTest::dataIntegrityTest";
+  GTEST_ASSERT_EQ(allDataValid, true);
+}
+
+TEST_P(UcxExchangeTest, bandwidthTest) {
+  // Test to measure the bandwidth at the Velox level
+
+  // Skip by default, enable with environment variable
+  if (!std::getenv("RUN_BANDWIDTH_TEST")) {
+    GTEST_SKIP()
+        << "Bandwidth test skipped. Set RUN_BANDWIDTH_TEST=1 to enable.";
+  }
+
+  // Skip wide table tests - UcxPartitionedOutputMock only supports narrow
+  // tables
+  if (shouldSkipWideTable()) {
+    GTEST_SKIP()
+        << "bandwidthTest skipped for WideTable - uses UcxPartitionedOutputMock";
+  }
+
+  VLOG(3) << "+ UcxExchangeTest::bandwidthTest";
+  ExchangeTestParams p = GetParam();
+  int numUpstreamTasks = p.numUpstreamTasks;
+
+  // Use unique task prefix to avoid collisions between parametrized tests
+  const std::string taskPrefix = getUniqueTaskPrefix();
+  std::vector<std::string> srcTaskIds;
+
+  // Create some reference data to send which we will check against at the
+  // receiver
+  std::shared_ptr<UcxTestData> dataToSend = std::make_shared<UcxTestData>();
+  dataToSend->initialize(p.numRowsPerChunk);
+
+  std::vector<std::shared_ptr<UcxPartitionedOutputMock>> sourceMocks;
+
+  // Create n upstream tasks.
+  for (int i = 0; i < numUpstreamTasks; i++) {
+    const std::string srcTaskId = taskPrefix + "sourceTask" + std::to_string(i);
+    srcTaskIds.push_back(srcTaskId);
+
+    // Create a source task with a large maximum queue size so that we don't
+    // block sending
+    auto srcTask = createSourceTask(
+        srcTaskId, pool_, UcxTestData::kTestRowType, FOUR_GBYTES * 10);
+    queueManager_->initializeTask(
+        srcTask,
+        core::PartitionedOutputNode::Kind::kPartitioned,
+        p.numPartitions,
+        p.numSrcDrivers);
+
+    // Mock the UcxPartitionedOutput operator, it will produce numChunks of
+    // data each containing numRowsPerChunk of data copied from the UcxTestData
+    // object data
+    sourceMocks.emplace_back(
+        std::make_shared<UcxPartitionedOutputMock>(
+            srcTaskId,
+            p.numSrcDrivers,
+            p.numPartitions,
+            p.numChunks,
+            p.numRowsPerChunk,
+            dataToSend));
+  }
+
+  const std::string sinkTaskId = taskPrefix + "sinkTask";
+  int partitionId = 0;
+  core::PlanNodeId exchangeNodeId;
+  auto sinkTask = createExchangeTask(
+      sinkTaskId, UcxTestData::kTestRowType, partitionId, exchangeNodeId);
+
+  SinkDriverMock sinkDriver(
+      sinkTask, p.numDstDrivers, nullptr /* Don't check data too slow*/);
+
+  // create n remote splits and add it to the sink driver mock.
+  std::vector<facebook::velox::exec::Split> splits;
+  for (int i = 0; i < numUpstreamTasks; i++) {
+    splits.emplace_back(remoteSplit(srcTaskIds[i], partitionId));
+  }
+  sinkDriver.addSplits(splits);
+
+  // Start the mocks.
+  VLOG(3) << "Starting source tasks";
+  for (int i = 0; i < numUpstreamTasks; i++) {
+    sourceMocks[i]->run();
+  }
+  for (int i = 0; i < numUpstreamTasks; i++) {
+    sourceMocks[i]->joinThreads();
+  }
+  VLOG(3) << "Source tasks done.";
+
+  // Only starting receiving when sender is done, note this can be dangeous
+  // if the total data send is larger than the queue as the source thread
+  // will block and we will never arrive here
+
+  VLOG(3) << "Starting sink task";
+  std::chrono::time_point<std::chrono::high_resolution_clock> send_start =
+      std::chrono::high_resolution_clock::now();
+
+  sinkDriver.run();
+  sinkDriver.joinThreads();
+  std::chrono::time_point<std::chrono::high_resolution_clock> send_end =
+      std::chrono::high_resolution_clock::now();
+
+  auto rx_bytes = sinkDriver.numBytes();
+  auto duration = send_end - send_start;
+  auto micros =
+      std::chrono::duration_cast<std::chrono::microseconds>(duration).count();
+  auto throughput = (float)rx_bytes / (float)micros;
+  VLOG(3)
+      << "*** duration: "
+      << std::chrono::duration_cast<std::chrono::milliseconds>(duration).count()
+      << " ms ";
+  VLOG(3) << "*** MBytes " << (float)rx_bytes / (float)(1024 * 1024);
+  VLOG(0) << "*** throughput: " << throughput << " MByte/s";
+
+  VLOG(3) << "Sink task done.";
+
+  // Remove the srcTasks from the queue manager, so queue get freed
+  for (const auto& srcTaskId : srcTaskIds) {
+    queueManager_->removeTask(srcTaskId);
+  }
+
+  VLOG(3) << "- UcxExchangeTest::bandwidth";
+  GTEST_ASSERT_EQ(sinkDriver.dataIsValid(), true);
+}
+
+// Test using real UcxPartitionedOutput operator via SourceDriverMock
+TEST_P(UcxExchangeTest, realPartitionedOutputTest) {
+  VLOG(3) << "+ UcxExchangeTest::realPartitionedOutputTest";
+  ExchangeTestParams p = GetParam();
+
+  // Wide table multi-partition tests work by using
+  // structs_column_view::get_sliced_child() in
+  // UcxExchangeServer/UcxExchangeProtocol to get STRUCT children with the
+  // parent's offset/size applied after cudf::split.
+
+  // Use unique task prefix to avoid collisions between parametrized tests
+  const std::string taskPrefix = getUniqueTaskPrefix();
+
+  // For this test, we use a single upstream task to keep it simple
+  const int numUpstreamTasks = 1;
+  const std::string srcTaskId = taskPrefix + "sourceTask0";
+
+  // Get the row type based on the table type
+  auto rowType = getRowType(p.tableType);
+
+  // Specify partition keys when numPartitions > 1 to enable hash partitioning.
+  // Use "c0" for narrow tables (INTEGER column) or "int32_col" for wide tables.
+  std::vector<std::string> partitionKeys;
+  if (p.numPartitions > 1) {
+    partitionKeys = {p.tableType == TableType::WIDE ? "int32_col" : "c0"};
+  }
+
+  // Create source task with PartitionedOutput plan node
+  auto srcTask = createPartitionedOutputTask(
+      srcTaskId, pool_, rowType, p.numPartitions, partitionKeys);
+
+  // Tell the queue manager that a new source task exists
+  queueManager_->initializeTask(
+      srcTask,
+      core::PartitionedOutputNode::Kind::kPartitioned,
+      p.numPartitions,
+      p.numSrcDrivers);
+
+  // Create table generator for wide tables, nullptr for narrow tables
+  std::shared_ptr<BaseTableGenerator> tableGenerator;
+  if (p.tableType == TableType::WIDE) {
+    auto wideTable = std::make_shared<WideTestTable>();
+    wideTable->initialize(p.numRowsPerChunk);
+    tableGenerator = wideTable;
+  }
+
+  // Create SourceDriverMock to drive real UcxPartitionedOutput operators
+  auto sourceDriver = std::make_shared<SourceDriverMock>(
+      srcTask, p.numSrcDrivers, p.numChunks, p.numRowsPerChunk, tableGenerator);
+
+  // Create one sink task per partition to receive data from each partition
+  std::vector<std::shared_ptr<SinkDriverMock>> sinkDrivers;
+  for (int partitionId = 0; partitionId < p.numPartitions; ++partitionId) {
+    const std::string sinkTaskId =
+        taskPrefix + "sinkTask" + std::to_string(partitionId);
+    core::PlanNodeId exchangeNodeId;
+    auto sinkTask =
+        createExchangeTask(sinkTaskId, rowType, partitionId, exchangeNodeId);
+
+    auto sinkDriver =
+        std::make_shared<SinkDriverMock>(sinkTask, p.numDstDrivers);
+
+    // Add remote split for this partition
+    std::vector<facebook::velox::exec::Split> splits;
+    splits.emplace_back(remoteSplit(srcTaskId, partitionId));
+    sinkDriver->addSplits(splits);
+
+    sinkDrivers.push_back(sinkDriver);
+  }
+
+  // Start the drivers
+  VLOG(3) << "Starting source task with real UcxPartitionedOutput";
+  sourceDriver->run();
+
+  VLOG(3) << "Starting " << p.numPartitions << " sink tasks";
+  for (auto& sinkDriver : sinkDrivers) {
+    sinkDriver->run();
+  }
+
+  sourceDriver->joinThreads();
+  VLOG(3) << "Source task done.";
+
+  for (auto& sinkDriver : sinkDrivers) {
+    sinkDriver->joinThreads();
+  }
+  VLOG(3) << "All sink tasks done.";
+
+  // Total rows received across all partitions should equal total rows sent
+  size_t expectedRows = p.numChunks * p.numRowsPerChunk * p.numSrcDrivers;
+  size_t totalReceivedRows = 0;
+  for (auto& sinkDriver : sinkDrivers) {
+    totalReceivedRows += sinkDriver->numRows();
+  }
+
+  VLOG(3) << "Expected rows: " << expectedRows
+          << ", received rows: " << totalReceivedRows;
+  GTEST_ASSERT_EQ(expectedRows, totalReceivedRows);
+
+  // Cleanup
+  queueManager_->removeTask(srcTaskId);
+
+  VLOG(3) << "- UcxExchangeTest::realPartitionedOutputTest";
+}
+
+// Test using real UcxPartitionedOutput with data integrity verification.
+// This test:
+// 1. Creates reference data (UcxTestData or WideTestTable) - same as
+// dataIntegrityTest
+// 2. For narrow tables with multi-partition: partitions that data using
+// cudf::hash_partition
+//    (same algorithm as UcxPartitionedOutput) to create per-partition
+//    reference data
+// 3. Sends data through SourceDriverMock (which uses UcxPartitionedOutput)
+// 4. Each SinkDriverMock verifies received data against its partition's
+//    expected data using row-by-row comparison
+TEST_P(UcxExchangeTest, realPartitionedOutputDataIntegrityTest) {
+  VLOG(3) << "+ UcxExchangeTest::realPartitionedOutputDataIntegrityTest";
+  ExchangeTestParams p = GetParam();
+
+  // Wide table multi-partition tests work by using
+  // structs_column_view::get_sliced_child() in
+  // UcxExchangeServer/UcxExchangeProtocol to get STRUCT children with the
+  // parent's offset/size applied after cudf::split.
+
+  // Use unique task prefix to avoid collisions between parametrized tests
+  const std::string taskPrefix = getUniqueTaskPrefix();
+
+  // For this test, use a single upstream task and single driver for simplicity
+  // This allows deterministic data verification
+  const int numUpstreamTasks = 1;
+  const int numSrcDrivers = 1;
+  const std::string srcTaskId = taskPrefix + "sourceTask0";
+
+  // Get the row type based on the table type
+  auto rowType = getRowType(p.tableType);
+
+  // Create reference data that will be sent - UcxTestData for narrow,
+  // WideTestTable for wide
+  std::shared_ptr<BaseTableGenerator> tableGenerator;
+  if (p.tableType == TableType::WIDE) {
+    auto wideTable = std::make_shared<WideTestTable>();
+    wideTable->initialize(p.numRowsPerChunk);
+    tableGenerator = wideTable;
+  } else {
+    auto dataToSend = std::make_shared<UcxTestData>();
+    dataToSend->initialize(p.numRowsPerChunk);
+    tableGenerator = dataToSend;
+  }
+
+  // Specify partition keys when numPartitions > 1 to enable hash partitioning.
+  // Use "c0" for narrow tables (column index 0) or "int32_col" for wide tables
+  // (column index 2).
+  std::vector<std::string> partitionKeys;
+  std::vector<cudf::size_type> partitionKeyIndices;
+  if (p.numPartitions > 1) {
+    if (p.tableType == TableType::WIDE) {
+      partitionKeys = {"int32_col"};
+      partitionKeyIndices = {2}; // int32_col is column 2 in wide table
+    } else {
+      partitionKeys = {"c0"};
+      partitionKeyIndices = {0}; // c0 is column 0 in narrow table
+    }
+  }
+
+  // Create per-partition reference data by applying cudf::hash_partition
+  // to the source data - same algorithm as UcxPartitionedOutput uses
+  auto stream = rmm::cuda_stream_default;
+  std::vector<std::shared_ptr<BaseTableGenerator>> partitionedDataToVerify(
+      p.numPartitions);
+
+  // For narrow tables with multi-partition, we can compute per-partition
+  // reference data For wide tables or single partition, we use the
+  // tableGenerator directly
+  bool canVerifyDataIntegrity = true;
+
+  if (p.numPartitions > 1 && !partitionKeyIndices.empty()) {
+    // Multi-partition: skip data integrity verification.
+    // cudf::hash_partition does not guarantee deterministic row ordering within
+    // partitions, so the reference data created here may have different row
+    // order than the data sent through UcxPartitionedOutput::hashPartition(),
+    // even though both use the same input data and hash function. Row count
+    // verification still confirms all data is transferred correctly.
+    canVerifyDataIntegrity = false;
+    VLOG(3) << "Multi-partition test: skipping data integrity verification "
+            << "(hash_partition row order is not deterministic)";
+  } else {
+    // Single partition: all data goes to partition 0, use tableGenerator
+    // directly
+    partitionedDataToVerify[0] = tableGenerator;
+  }
+
+  // Create source task with PartitionedOutput plan node
+  auto srcTask = createPartitionedOutputTask(
+      srcTaskId, pool_, rowType, p.numPartitions, partitionKeys);
+
+  // Tell the queue manager that a new source task exists
+  queueManager_->initializeTask(
+      srcTask,
+      core::PartitionedOutputNode::Kind::kPartitioned,
+      p.numPartitions,
+      numSrcDrivers);
+
+  // Create SourceDriverMock with the tableGenerator
+  auto sourceDriver = std::make_shared<SourceDriverMock>(
+      srcTask, numSrcDrivers, p.numChunks, p.numRowsPerChunk, tableGenerator);
+
+  // Create one SinkDriverMock per partition, each with its partition's
+  // expected data for row-by-row verification (if available)
+  std::vector<std::shared_ptr<SinkDriverMock>> sinkDrivers;
+  for (int partitionId = 0; partitionId < p.numPartitions; ++partitionId) {
+    const std::string sinkTaskId =
+        taskPrefix + "sinkTask" + std::to_string(partitionId);
+    core::PlanNodeId exchangeNodeId;
+    auto sinkTask =
+        createExchangeTask(sinkTaskId, rowType, partitionId, exchangeNodeId);
+
+    // Pass the partitioned reference data for this partition (may be nullptr
+    // for wide multi-partition)
+    auto sinkDriver = std::make_shared<SinkDriverMock>(
+        sinkTask,
+        p.numDstDrivers,
+        canVerifyDataIntegrity ? partitionedDataToVerify[partitionId]
+                               : nullptr);
+
+    std::vector<facebook::velox::exec::Split> splits;
+    splits.emplace_back(remoteSplit(srcTaskId, partitionId));
+    sinkDriver->addSplits(splits);
+
+    sinkDrivers.push_back(sinkDriver);
+  }
+
+  // Start the drivers
+  VLOG(3) << "Starting source task with real UcxPartitionedOutput";
+  sourceDriver->run();
+
+  VLOG(3) << "Starting " << p.numPartitions << " sink tasks";
+  for (auto& sinkDriver : sinkDrivers) {
+    sinkDriver->run();
+  }
+
+  sourceDriver->joinThreads();
+  VLOG(3) << "Source task done.";
+
+  for (auto& sinkDriver : sinkDrivers) {
+    sinkDriver->joinThreads();
+  }
+  VLOG(3) << "All sink tasks done.";
+
+  // Verify total row count
+  size_t expectedTotalRows = p.numChunks * p.numRowsPerChunk * numSrcDrivers;
+  size_t totalReceivedRows = 0;
+  for (auto& sinkDriver : sinkDrivers) {
+    totalReceivedRows += sinkDriver->numRows();
+  }
+  GTEST_ASSERT_EQ(expectedTotalRows, totalReceivedRows);
+
+  // Verify data integrity - SinkDriverMock sets dataIsValid() to false
+  // if any row doesn't match the reference data
+  if (canVerifyDataIntegrity) {
+    bool allDataValid = true;
+    for (int partId = 0; partId < p.numPartitions; ++partId) {
+      if (!sinkDrivers[partId]->dataIsValid()) {
+        VLOG(0) << "Partition " << partId << ": data validation failed";
+        allDataValid = false;
+      } else {
+        VLOG(3) << "Partition " << partId << ": data validated successfully";
+      }
+    }
+
+    GTEST_ASSERT_EQ(allDataValid, true);
+  } else {
+    VLOG(3)
+        << "Data integrity verification skipped for wide table with multi-partition";
+  }
+
+  // Cleanup
+  queueManager_->removeTask(srcTaskId);
+
+  VLOG(3) << "- UcxExchangeTest::realPartitionedOutputDataIntegrityTest";
+}
+
+// Test that verifies intra-node exchange does not livelock when a producing
+// task is removed while the consumer is polling IntraNodeTransferRegistry.
+// Before the fix: test times out (livelock). After the fix: test passes.
+TEST_P(UcxExchangeTest, intraNodeTaskRemovalLivelock) {
+  // This test doesn't use parameters — run only for the first param set.
+  {
+    ExchangeTestParams p = GetParam();
+    if (p.numSrcDrivers != 1 || p.numDstDrivers != 1 || p.numPartitions != 1 ||
+        p.numChunks != 100 || p.numUpstreamTasks != 1 ||
+        p.tableType != TableType::NARROW) {
+      GTEST_SKIP() << "intraNodeTaskRemovalLivelock: runs only once";
+    }
+  }
+
+  const std::string taskPrefix = getUniqueTaskPrefix();
+  const std::string srcTaskId = taskPrefix + "srcProducerNeverSends";
+  const std::string sinkTaskId = taskPrefix + "sinkConsumer";
+  const int numPartitions = 1;
+  const int partitionId = 0;
+
+  // 1. Create and initialize source task but never enqueue any data.
+  //    This simulates a producer that gets cancelled before producing.
+  auto srcTask = createSourceTask(srcTaskId, pool_, UcxTestData::kTestRowType);
+  queueManager_->initializeTask(
+      srcTask,
+      core::PartitionedOutputNode::Kind::kPartitioned,
+      numPartitions,
+      /*numDrivers=*/1);
+
+  // 2. Create sink task with exchange plan node.
+  core::PlanNodeId exchangeNodeId;
+  auto sinkTask = createExchangeTask(
+      sinkTaskId, UcxTestData::kTestRowType, partitionId, exchangeNodeId);
+  auto sinkDriver =
+      std::make_shared<SinkDriverMock>(sinkTask, /*numDrivers=*/1);
+
+  // Add split pointing to source task. Since we use a single Communicator,
+  // the handshake will resolve to intra-node (same listener IP:port).
+  std::vector<exec::Split> splits;
+  splits.emplace_back(remoteSplit(srcTaskId, partitionId));
+  sinkDriver->addSplits(splits);
+
+  // 3. Start sink driver on background threads — it will begin polling
+  //    IntraNodeTransferRegistry for data that never arrives.
+  sinkDriver->run();
+
+  // 4. Wait for the UcxExchangeSource to complete handshake and start polling.
+  std::this_thread::sleep_for(std::chrono::seconds(1));
+
+  // 5. Premature task cancellation — abort the source task then remove it.
+  //    This mirrors the production flow where the task is aborted before
+  //    removal. After the fix, the consumer should detect this and stop
+  //    polling.
+  srcTask->requestAbort();
+  queueManager_->removeTask(srcTaskId);
+
+  // 6. Wait for sink to complete with a timeout.
+  auto future =
+      std::async(std::launch::async, [&]() { sinkDriver->joinThreads(); });
+  auto status = future.wait_for(std::chrono::seconds(10));
+
+  // 7. Verify that the sink completed (no livelock).
+  if (status != std::future_status::ready) {
+    // Abort the sink task to prevent the test from hanging indefinitely.
+    sinkTask->requestAbort();
+    future.wait();
+    FAIL() << "Sink driver did not complete within 10s after removeTask()"
+           << " — intra-node livelock: source stuck polling "
+           << "IntraNodeTransferRegistry for cancelled task";
+  }
+  // If we get here, the source correctly detected the cancelled task.
+}
+
+// Regression test for broadcast + intra-node SIGSEGV.
+// Before the fix in Acceptor.cpp, broadcast tasks using intra-node transfer
+// would crash because the intra-node source destructively moves gpu_data from
+// a shared packed_columns object, corrupting it for other servers.
+// The fix disables intra-node at handshake time for broadcast tasks, falling
+// back to UCXX. This test verifies that broadcast with intra-node enabled
+// completes without crash and delivers correct data.
+TEST_P(UcxExchangeTest, broadcastIntraNodeFallback) {
+  // This test doesn't use parameters — run only for the first param set.
+  {
+    ExchangeTestParams p = GetParam();
+    if (p.numSrcDrivers != 1 || p.numDstDrivers != 1 || p.numPartitions != 1 ||
+        p.numChunks != 100 || p.numUpstreamTasks != 1 ||
+        p.tableType != TableType::NARROW) {
+      GTEST_SKIP() << "broadcastIntraNodeFallback: runs only once";
+    }
+  }
+
+  // Enable intra-node exchange so the Acceptor's broadcast guard is exercised.
+  auto& config = cudf_velox::CudfConfig::getInstance();
+  const bool origIntraNode = config.intraNodeExchange;
+  config.intraNodeExchange = true;
+
+  const std::string taskPrefix = getUniqueTaskPrefix();
+  const std::string srcTaskId = taskPrefix + "broadcastSrc";
+  const int numDestinations = 3;
+  const int numDrivers = 1;
+  const int numChunks = 5;
+  const int numRowsPerChunk = 1000;
+
+  // Create source task with broadcast mode.
+  auto srcTask = createSourceTask(srcTaskId, pool_, UcxTestData::kTestRowType);
+  queueManager_->initializeTask(
+      srcTask,
+      core::PartitionedOutputNode::Kind::kBroadcast,
+      numDestinations,
+      numDrivers);
+  // Finalize destinations for broadcast.
+  queueManager_->updateOutputBuffers(srcTaskId, numDestinations, true);
+
+  // Create one sink per destination. Each connects to its own destination
+  // index.
+  std::vector<std::shared_ptr<SinkDriverMock>> sinkDrivers;
+  for (int destId = 0; destId < numDestinations; ++destId) {
+    const std::string sinkTaskId =
+        taskPrefix + "broadcastSink" + std::to_string(destId);
+    core::PlanNodeId exchangeNodeId;
+    auto sinkTask = createExchangeTask(
+        sinkTaskId, UcxTestData::kTestRowType, destId, exchangeNodeId);
+    auto sinkDriver =
+        std::make_shared<SinkDriverMock>(sinkTask, /*numDrivers=*/1);
+
+    std::vector<exec::Split> splits;
+    splits.emplace_back(remoteSplit(srcTaskId, destId));
+    sinkDriver->addSplits(splits);
+
+    sinkDrivers.push_back(sinkDriver);
+  }
+
+  // Producer sends to 1 partition (destination 0); broadcast replicates to all.
+  auto sourceMock = std::make_shared<UcxPartitionedOutputMock>(
+      srcTaskId, numDrivers, /*numPartitions=*/1, numChunks, numRowsPerChunk);
+
+  // Start source and sinks.
+  sourceMock->run();
+  for (auto& sink : sinkDrivers) {
+    sink->run();
+  }
+
+  // Wait for completion.
+  sourceMock->joinThreads();
+  for (auto& sink : sinkDrivers) {
+    sink->joinThreads();
+  }
+
+  // Each sink should receive all chunks: 5 * 1000 = 5000 rows.
+  const size_t expectedRowsPerSink =
+      static_cast<size_t>(numChunks) * numRowsPerChunk;
+  for (int i = 0; i < numDestinations; ++i) {
+    EXPECT_EQ(sinkDrivers[i]->numRows(), expectedRowsPerSink)
+        << "Sink " << i << " row count mismatch";
+  }
+
+  // Cleanup.
+  queueManager_->removeTask(srcTaskId);
+  config.intraNodeExchange = origIntraNode;
+}
+
+// Regression test for broadcast + intra-node placeholder race condition.
+// When sinks connect BEFORE initializeTask() is called, the Acceptor creates
+// a placeholder UcxOutputQueue. If initializeTask() later upgrades that
+// placeholder to broadcast mode, the intra-node flag may be incorrectly set
+// because the broadcast guard in Acceptor only runs at handshake time — but
+// the placeholder was already created with intra-node enabled.
+// Without a fix, this causes a SIGSEGV when the intra-node source
+// destructively moves gpu_data from the shared packed_columns object.
+TEST_P(UcxExchangeTest, broadcastIntraNodePlaceholderRace) {
+  // This test doesn't use parameters — run only for the first param set.
+  {
+    ExchangeTestParams p = GetParam();
+    if (p.numSrcDrivers != 1 || p.numDstDrivers != 1 || p.numPartitions != 1 ||
+        p.numChunks != 100 || p.numUpstreamTasks != 1 ||
+        p.tableType != TableType::NARROW) {
+      GTEST_SKIP() << "broadcastIntraNodePlaceholderRace: runs only once";
+    }
+  }
+
+  // Enable intra-node exchange so the race condition can manifest.
+  auto& config = cudf_velox::CudfConfig::getInstance();
+  const bool origIntraNode = config.intraNodeExchange;
+  config.intraNodeExchange = true;
+
+  const std::string taskPrefix = getUniqueTaskPrefix();
+  const std::string srcTaskId = taskPrefix + "broadcastPlaceholderSrc";
+  const int numDestinations = 3;
+  const int numDrivers = 1;
+  const int numChunks = 5;
+  const int numRowsPerChunk = 1000;
+
+  // Step 1: Create sink tasks and start them BEFORE initializeTask().
+  // This triggers handshakes that create a placeholder queue in
+  // UcxOutputQueueManager with intra-node potentially enabled.
+  std::vector<std::shared_ptr<SinkDriverMock>> sinkDrivers;
+  for (int destId = 0; destId < numDestinations; ++destId) {
+    const std::string sinkTaskId =
+        taskPrefix + "broadcastPlaceholderSink" + std::to_string(destId);
+    core::PlanNodeId exchangeNodeId;
+    auto sinkTask = createExchangeTask(
+        sinkTaskId, UcxTestData::kTestRowType, destId, exchangeNodeId);
+    auto sinkDriver =
+        std::make_shared<SinkDriverMock>(sinkTask, /*numDrivers=*/1);
+
+    std::vector<exec::Split> splits;
+    splits.emplace_back(remoteSplit(srcTaskId, destId));
+    sinkDriver->addSplits(splits);
+
+    sinkDrivers.push_back(sinkDriver);
+  }
+
+  // Start sinks — they will handshake and create placeholder queues.
+  for (auto& sink : sinkDrivers) {
+    sink->run();
+  }
+
+  // Step 2: Wait for handshakes to be processed.
+  std::this_thread::sleep_for(std::chrono::seconds(1));
+
+  // Step 3: NOW initialize the task with broadcast mode.
+  // This upgrades the placeholder queue to broadcast.
+  auto srcTask = createSourceTask(srcTaskId, pool_, UcxTestData::kTestRowType);
+  queueManager_->initializeTask(
+      srcTask,
+      core::PartitionedOutputNode::Kind::kBroadcast,
+      numDestinations,
+      numDrivers);
+
+  // Step 4: Finalize destinations for broadcast.
+  queueManager_->updateOutputBuffers(srcTaskId, numDestinations, true);
+
+  // Step 5: Create and run the producer.
+  auto sourceMock = std::make_shared<UcxPartitionedOutputMock>(
+      srcTaskId, numDrivers, /*numPartitions=*/1, numChunks, numRowsPerChunk);
+  sourceMock->run();
+
+  // Step 6: Wait for completion — without a fix this crashes (SIGSEGV).
+  sourceMock->joinThreads();
+  for (auto& sink : sinkDrivers) {
+    sink->joinThreads();
+  }
+
+  // Step 7: Verify all sinks received correct row counts.
+  const size_t expectedRowsPerSink =
+      static_cast<size_t>(numChunks) * numRowsPerChunk;
+  for (int i = 0; i < numDestinations; ++i) {
+    EXPECT_EQ(sinkDrivers[i]->numRows(), expectedRowsPerSink)
+        << "Sink " << i << " row count mismatch";
+  }
+
+  // Cleanup.
+  queueManager_->removeTask(srcTaskId);
+  config.intraNodeExchange = origIntraNode;
+}
+
+// Test that UcxPartitionedOutput's batch accumulation correctly merges many
+// small input chunks into fewer, larger output chunks while preserving all rows
+// and data integrity.
+TEST_P(UcxExchangeTest, batchAccumulationTest) {
+  // This test doesn't use parameters — run only for the first param set.
+  {
+    ExchangeTestParams p = GetParam();
+    if (p.numSrcDrivers != 1 || p.numDstDrivers != 1 || p.numPartitions != 1 ||
+        p.numChunks != 100 || p.numUpstreamTasks != 1 ||
+        p.tableType != TableType::NARROW) {
+      GTEST_SKIP() << "batchAccumulationTest: runs only once";
+    }
+  }
+
+  const int kTargetRows = UcxPartitionedOutput::kDefaultTargetRowsPerChunk;
+
+  // --- Scenario 1: Small chunks that SHOULD be accumulated ---
+  // 500 chunks × 100 rows = 50,000 total rows.
+  // With kTargetRowsPerChunk = 10,000 and 100 rows/chunk, we need 100 chunks
+  // to reach the threshold → expect 5 flushes (500/100 = 5), 0 remainder.
+  {
+    const int numChunks = 500;
+    const int numRowsPerChunk = 100;
+    const int numPartitions = 1;
+    const int numDrivers = 1;
+    const std::string taskPrefix = getUniqueTaskPrefix();
+    const std::string srcTaskId = taskPrefix + "sourceTask0";
+
+    auto rowType = UcxTestData::kTestRowType;
+
+    // Create reference data for integrity verification.
+    auto dataToSend = std::make_shared<UcxTestData>();
+    dataToSend->initialize(numRowsPerChunk);
+
+    auto srcTask =
+        createPartitionedOutputTask(srcTaskId, pool_, rowType, numPartitions);
+    queueManager_->initializeTask(
+        srcTask,
+        core::PartitionedOutputNode::Kind::kPartitioned,
+        numPartitions,
+        numDrivers);
+
+    auto sourceDriver = std::make_shared<SourceDriverMock>(
+        srcTask, numDrivers, numChunks, numRowsPerChunk, dataToSend);
+
+    const std::string sinkTaskId = taskPrefix + "sinkTask0";
+    core::PlanNodeId exchangeNodeId;
+    auto sinkTask = createExchangeTask(sinkTaskId, rowType, 0, exchangeNodeId);
+    auto sinkDriver =
+        std::make_shared<SinkDriverMock>(sinkTask, numDrivers, dataToSend);
+
+    std::vector<exec::Split> splits;
+    splits.emplace_back(remoteSplit(srcTaskId, 0));
+    sinkDriver->addSplits(splits);
+
+    sourceDriver->run();
+    sinkDriver->run();
+    sourceDriver->joinThreads();
+    sinkDriver->joinThreads();
+
+    size_t expectedTotalRows = static_cast<size_t>(numChunks) * numRowsPerChunk;
+
+    // Verify all rows arrived.
+    EXPECT_EQ(sinkDriver->numRows(), expectedTotalRows)
+        << "Accumulation must not lose rows";
+
+    // Verify data integrity.
+    EXPECT_TRUE(sinkDriver->dataIsValid())
+        << "Accumulated data must match reference";
+
+    // Verify chunk reduction. Compute expected output chunks:
+    // chunksPerFlush = ceil(kTargetRows / numRowsPerChunk)
+    // outputChunks = ceil(numChunks / chunksPerFlush)
+    size_t chunksPerFlush =
+        (kTargetRows + numRowsPerChunk - 1) / numRowsPerChunk;
+    size_t expectedOutputChunks =
+        (numChunks + chunksPerFlush - 1) / chunksPerFlush;
+
+    VLOG(0) << "batchAccumulationTest scenario 1: sent " << numChunks
+            << " chunks of " << numRowsPerChunk << " rows, received "
+            << sinkDriver->numChunksReceived() << " chunks (expected "
+            << expectedOutputChunks << ")";
+
+    EXPECT_EQ(sinkDriver->numChunksReceived(), expectedOutputChunks)
+        << "Small chunks should be accumulated into fewer output chunks";
+
+    // Sanity: output chunks must be strictly fewer than input chunks.
+    EXPECT_LT(sinkDriver->numChunksReceived(), static_cast<uint64_t>(numChunks))
+        << "Accumulation should reduce chunk count";
+
+    queueManager_->removeTask(srcTaskId);
+  }
+
+  // --- Scenario 2: Small chunks with a remainder (not evenly divisible) ---
+  // 150 chunks × 100 rows = 15,000 total rows.
+  // 100 chunks → first flush (10,000 rows), 50 remaining → partial flush.
+  // Expected: 2 output chunks.
+  {
+    const int numChunks = 150;
+    const int numRowsPerChunk = 100;
+    const int numPartitions = 1;
+    const int numDrivers = 1;
+    const std::string taskPrefix = getUniqueTaskPrefix();
+    const std::string srcTaskId = taskPrefix + "sourceTask0";
+
+    auto rowType = UcxTestData::kTestRowType;
+
+    auto dataToSend = std::make_shared<UcxTestData>();
+    dataToSend->initialize(numRowsPerChunk);
+
+    auto srcTask =
+        createPartitionedOutputTask(srcTaskId, pool_, rowType, numPartitions);
+    queueManager_->initializeTask(
+        srcTask,
+        core::PartitionedOutputNode::Kind::kPartitioned,
+        numPartitions,
+        numDrivers);
+
+    auto sourceDriver = std::make_shared<SourceDriverMock>(
+        srcTask, numDrivers, numChunks, numRowsPerChunk, dataToSend);
+
+    const std::string sinkTaskId = taskPrefix + "sinkTask0";
+    core::PlanNodeId exchangeNodeId;
+    auto sinkTask = createExchangeTask(sinkTaskId, rowType, 0, exchangeNodeId);
+    auto sinkDriver =
+        std::make_shared<SinkDriverMock>(sinkTask, numDrivers, dataToSend);
+
+    std::vector<exec::Split> splits;
+    splits.emplace_back(remoteSplit(srcTaskId, 0));
+    sinkDriver->addSplits(splits);
+
+    sourceDriver->run();
+    sinkDriver->run();
+    sourceDriver->joinThreads();
+    sinkDriver->joinThreads();
+
+    size_t expectedTotalRows = static_cast<size_t>(numChunks) * numRowsPerChunk;
+
+    EXPECT_EQ(sinkDriver->numRows(), expectedTotalRows)
+        << "Remainder scenario must not lose rows";
+
+    EXPECT_TRUE(sinkDriver->dataIsValid())
+        << "Remainder scenario data must match reference";
+
+    size_t chunksPerFlush =
+        (kTargetRows + numRowsPerChunk - 1) / numRowsPerChunk;
+    size_t expectedOutputChunks =
+        (numChunks + chunksPerFlush - 1) / chunksPerFlush;
+
+    VLOG(0) << "batchAccumulationTest scenario 2: sent " << numChunks
+            << " chunks of " << numRowsPerChunk << " rows, received "
+            << sinkDriver->numChunksReceived() << " chunks (expected "
+            << expectedOutputChunks << ")";
+
+    EXPECT_EQ(sinkDriver->numChunksReceived(), expectedOutputChunks)
+        << "Remainder chunks should be flushed on noMoreInput";
+
+    queueManager_->removeTask(srcTaskId);
+  }
+
+  // --- Scenario 3: Large chunks (>= threshold) should NOT be accumulated ---
+  // 5 chunks × 20,000 rows = 100,000 total rows.
+  // Each chunk exceeds kTargetRowsPerChunk, so each addInput triggers an
+  // immediate flush via the single-input fast path. Expected: 5 output chunks.
+  {
+    const int numChunks = 5;
+    const int numRowsPerChunk = 20000;
+    const int numPartitions = 1;
+    const int numDrivers = 1;
+    const std::string taskPrefix = getUniqueTaskPrefix();
+    const std::string srcTaskId = taskPrefix + "sourceTask0";
+
+    auto rowType = UcxTestData::kTestRowType;
+
+    auto dataToSend = std::make_shared<UcxTestData>();
+    dataToSend->initialize(numRowsPerChunk);
+
+    auto srcTask =
+        createPartitionedOutputTask(srcTaskId, pool_, rowType, numPartitions);
+    queueManager_->initializeTask(
+        srcTask,
+        core::PartitionedOutputNode::Kind::kPartitioned,
+        numPartitions,
+        numDrivers);
+
+    auto sourceDriver = std::make_shared<SourceDriverMock>(
+        srcTask, numDrivers, numChunks, numRowsPerChunk, dataToSend);
+
+    const std::string sinkTaskId = taskPrefix + "sinkTask0";
+    core::PlanNodeId exchangeNodeId;
+    auto sinkTask = createExchangeTask(sinkTaskId, rowType, 0, exchangeNodeId);
+    auto sinkDriver =
+        std::make_shared<SinkDriverMock>(sinkTask, numDrivers, dataToSend);
+
+    std::vector<exec::Split> splits;
+    splits.emplace_back(remoteSplit(srcTaskId, 0));
+    sinkDriver->addSplits(splits);
+
+    sourceDriver->run();
+    sinkDriver->run();
+    sourceDriver->joinThreads();
+    sinkDriver->joinThreads();
+
+    size_t expectedTotalRows = static_cast<size_t>(numChunks) * numRowsPerChunk;
+
+    EXPECT_EQ(sinkDriver->numRows(), expectedTotalRows)
+        << "Large-chunk scenario must not lose rows";
+
+    EXPECT_TRUE(sinkDriver->dataIsValid())
+        << "Large-chunk scenario data must match reference";
+
+    VLOG(0) << "batchAccumulationTest scenario 3: sent " << numChunks
+            << " chunks of " << numRowsPerChunk << " rows, received "
+            << sinkDriver->numChunksReceived() << " chunks (expected "
+            << numChunks << ")";
+
+    // Large chunks should pass through without accumulation — each addInput
+    // immediately flushes because pendingRows >= kTargetRowsPerChunk.
+    EXPECT_EQ(sinkDriver->numChunksReceived(), static_cast<uint64_t>(numChunks))
+        << "Large chunks should not be accumulated";
+
+    queueManager_->removeTask(srcTaskId);
+  }
+
+  // --- Scenario 4: Custom threshold via QueryConfig ---
+  // 50 chunks × 100 rows = 5,000 total rows with a custom threshold of 500.
+  // chunksPerFlush = ceil(500/100) = 5
+  // outputChunks = ceil(50/5) = 10
+  {
+    const int numChunks = 50;
+    const int numRowsPerChunk = 100;
+    const int64_t customThreshold = 500;
+    const int numPartitions = 1;
+    const int numDrivers = 1;
+    const std::string taskPrefix = getUniqueTaskPrefix();
+    const std::string srcTaskId = taskPrefix + "sourceTask0";
+
+    auto rowType = UcxTestData::kTestRowType;
+
+    auto dataToSend = std::make_shared<UcxTestData>();
+    dataToSend->initialize(numRowsPerChunk);
+
+    // Pass custom threshold via QueryConfig.
+    std::unordered_map<std::string, std::string> extraConfig{
+        {core::QueryConfig::kUcxPartitionedOutputBatchRows,
+         std::to_string(customThreshold)}};
+
+    auto srcTask = createPartitionedOutputTask(
+        srcTaskId, pool_, rowType, numPartitions, {}, FOUR_GBYTES, extraConfig);
+    queueManager_->initializeTask(
+        srcTask,
+        core::PartitionedOutputNode::Kind::kPartitioned,
+        numPartitions,
+        numDrivers);
+
+    auto sourceDriver = std::make_shared<SourceDriverMock>(
+        srcTask, numDrivers, numChunks, numRowsPerChunk, dataToSend);
+
+    const std::string sinkTaskId = taskPrefix + "sinkTask0";
+    core::PlanNodeId exchangeNodeId;
+    auto sinkTask = createExchangeTask(sinkTaskId, rowType, 0, exchangeNodeId);
+    auto sinkDriver =
+        std::make_shared<SinkDriverMock>(sinkTask, numDrivers, dataToSend);
+
+    std::vector<exec::Split> splits;
+    splits.emplace_back(remoteSplit(srcTaskId, 0));
+    sinkDriver->addSplits(splits);
+
+    sourceDriver->run();
+    sinkDriver->run();
+    sourceDriver->joinThreads();
+    sinkDriver->joinThreads();
+
+    size_t expectedTotalRows = static_cast<size_t>(numChunks) * numRowsPerChunk;
+
+    EXPECT_EQ(sinkDriver->numRows(), expectedTotalRows)
+        << "Custom threshold scenario must not lose rows";
+
+    EXPECT_TRUE(sinkDriver->dataIsValid())
+        << "Custom threshold scenario data must match reference";
+
+    size_t chunksPerFlush =
+        (customThreshold + numRowsPerChunk - 1) / numRowsPerChunk;
+    size_t expectedOutputChunks =
+        (numChunks + chunksPerFlush - 1) / chunksPerFlush;
+
+    VLOG(0) << "batchAccumulationTest scenario 4: sent " << numChunks
+            << " chunks of " << numRowsPerChunk
+            << " rows with custom threshold=" << customThreshold
+            << ", received " << sinkDriver->numChunksReceived()
+            << " chunks (expected " << expectedOutputChunks << ")";
+
+    EXPECT_EQ(sinkDriver->numChunksReceived(), expectedOutputChunks)
+        << "Custom threshold should control accumulation granularity";
+
+    queueManager_->removeTask(srcTaskId);
+  }
+}
+
+// Regression test: aborting a source task while UCXX tagRecv requests are
+// in-flight must not crash.  Before the deferred-request-cleanup fix,
+// UcxExchangeSource::cleanUp() would destroy the request (and its GPU
+// buffer) while UCX was still using it, causing cudaErrorIllegalAddress in
+// ucp_mem_type_unpack.  The fix moves outstanding requests to
+// Communicator::deferredRequests_ so buffers stay alive until UCX finishes.
+TEST_P(UcxExchangeTest, deferredRequestCleanupOnTaskAbort) {
+  // This test doesn't use parameters — run only for the first param set.
+  {
+    ExchangeTestParams p = GetParam();
+    if (p.numSrcDrivers != 1 || p.numDstDrivers != 1 || p.numPartitions != 1 ||
+        p.numChunks != 100 || p.numUpstreamTasks != 1 ||
+        p.tableType != TableType::NARROW) {
+      GTEST_SKIP() << "deferredRequestCleanupOnTaskAbort: runs only once";
+    }
+  }
+
+  // Ensure intra-node is disabled so we exercise the UCXX path (tagRecv).
+  auto& config = cudf_velox::CudfConfig::getInstance();
+  const bool origIntraNode = config.intraNodeExchange;
+  config.intraNodeExchange = false;
+
+  const std::string taskPrefix = getUniqueTaskPrefix();
+  const std::string srcTaskId = taskPrefix + "srcActiveTransfer";
+  const std::string sinkTaskId = taskPrefix + "sinkAborted";
+  const int numPartitions = 1;
+  const int partitionId = 0;
+  const int numDrivers = 1;
+  // Enough data to keep UCXX transfers actively in-flight when we abort.
+  const int numChunks = 50;
+  const int numRowsPerChunk = 100000;
+
+  auto rowType = UcxTestData::kTestRowType;
+
+  // 1. Create and initialize source task with data to send.
+  auto srcTask = createSourceTask(srcTaskId, pool_, rowType);
+  queueManager_->initializeTask(
+      srcTask,
+      core::PartitionedOutputNode::Kind::kPartitioned,
+      numPartitions,
+      numDrivers);
+
+  auto sourceMock = std::make_shared<UcxPartitionedOutputMock>(
+      srcTaskId, numDrivers, numPartitions, numChunks, numRowsPerChunk);
+
+  // 2. Create sink task with exchange plan node.
+  core::PlanNodeId exchangeNodeId;
+  auto sinkTask =
+      createExchangeTask(sinkTaskId, rowType, partitionId, exchangeNodeId);
+  auto sinkDriver =
+      std::make_shared<SinkDriverMock>(sinkTask, /*numDrivers=*/1);
+
+  std::vector<exec::Split> splits;
+  splits.emplace_back(remoteSplit(srcTaskId, partitionId));
+  sinkDriver->addSplits(splits);
+
+  // 3. Start source (enqueues data) and sink (begins receiving via UCXX).
+  sourceMock->run();
+  sinkDriver->run();
+
+  // 4. Wait for UCXX transfers to be actively in-flight.
+  std::this_thread::sleep_for(std::chrono::milliseconds(200));
+
+  // 5. Abort the source task while transfers are in-flight.
+  //    This triggers UcxExchangeServer::close() which cancels tagSend,
+  //    and eventually UcxExchangeSource::cleanUp() which must defer
+  //    the request (with its GPU buffer) to Communicator::deferredRequests_.
+  srcTask->requestAbort();
+  queueManager_->removeTask(srcTaskId);
+
+  // 6. Wait for the sink driver to complete (it should detect the abort
+  //    and finish, not crash with cudaErrorIllegalAddress).
+  auto future =
+      std::async(std::launch::async, [&]() { sinkDriver->joinThreads(); });
+  auto status = future.wait_for(std::chrono::seconds(15));
+
+  if (status != std::future_status::ready) {
+    sinkTask->requestAbort();
+    future.wait();
+    FAIL() << "Sink driver did not complete within 15s after source abort"
+           << " — possible hang in UCXX request cleanup";
+  }
+
+  // 7. Join source mock threads.
+  sourceMock->joinThreads();
+
+  // 8. Allow Communicator's event loop to sweep deferred requests.
+  std::this_thread::sleep_for(std::chrono::milliseconds(500));
+
+  // If we reach here without crashing, the deferred cleanup is working.
+  VLOG(0) << "deferredRequestCleanupOnTaskAbort: completed without crash";
+
+  config.intraNodeExchange = origIntraNode;
+}
+
+std::shared_ptr<UcxOutputQueueManager> UcxExchangeTest::queueManager_;
+std::shared_ptr<std::thread> UcxExchangeTest::communicatorThread_;
+std::shared_ptr<Communicator> UcxExchangeTest::communicator_;
+std::atomic<uint32_t> UcxExchangeTest::testCounter_{0};
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/tests/UcxOutputQueueManagerTest.cpp b/velox/experimental/ucx-exchange/tests/UcxOutputQueueManagerTest.cpp
new file mode 100644
index 00000000000..c392811620e
--- /dev/null
+++ b/velox/experimental/ucx-exchange/tests/UcxOutputQueueManagerTest.cpp
@@ -0,0 +1,672 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/ucx-exchange/UcxOutputQueueManager.h"
+#include <cudf/column/column_factories.hpp>
+#include <cudf/contiguous_split.hpp>
+#include <cudf/table/table.hpp>
+#include <cudf/types.hpp>
+#include <folly/Executor.h>
+#include <folly/synchronization/EventCount.h>
+#include <gtest/gtest.h>
+#include <rmm/device_buffer.hpp>
+#include <memory>
+#include <vector>
+#include "velox/common/memory/MemoryPool.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/experimental/ucx-exchange/tests/UcxTestHelpers.h"
+
+using namespace facebook::velox::ucx_exchange;
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::core;
+
+class UcxOutputQueueManagerTest : public testing::Test {
+ protected:
+  UcxOutputQueueManagerTest() {}
+
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    pool_ = facebook::velox::memory::memoryManager()->addLeafPool();
+    queueManager_ = UcxOutputQueueManager::getInstanceRef();
+  }
+
+  std::shared_ptr<Task> initializeTask(
+      std::string_view taskId,
+      int numDestinations,
+      int numDrivers,
+      bool cleanup = true,
+      core::PartitionedOutputNode::Kind kind =
+          core::PartitionedOutputNode::Kind::kPartitioned) {
+    if (cleanup) {
+      queueManager_->removeTask(taskId);
+    }
+
+    auto task = createSourceTask(taskId, pool_, UcxTestData::kTestRowType);
+
+    queueManager_->initializeTask(task, kind, numDestinations, numDrivers);
+    return task;
+  }
+
+  std::unique_ptr<cudf::packed_columns> makePackedColumns(std::size_t numRows) {
+    rmm::cuda_stream_view stream = rmm::cuda_stream_default;
+    // Create table directly without going through pack/unpack
+    auto table = facebook::velox::ucx_exchange::makeTable(
+        numRows, UcxTestData::kTestRowType, stream);
+    auto cols = std::make_unique<cudf::packed_columns>(
+        cudf::pack(table->view(), stream));
+    stream.synchronize();
+    return cols;
+  }
+
+  void enqueue(std::string_view taskId, vector_size_t size) {
+    enqueue(taskId, 0, size);
+  }
+
+  // Returns the enqueued page byte size.
+  void enqueue(std::string_view taskId, int destination, vector_size_t size) {
+    auto data = makePackedColumns(size);
+    queueManager_->enqueue(taskId, destination, std::move(data), size);
+  }
+
+  void noMoreData(std::string_view taskId) {
+    queueManager_->noMoreData(taskId);
+  }
+
+  void fetch(
+      std::string_view taskId,
+      int destination,
+      bool expectedEndMarker = false) {
+    bool receivedData = false;
+    queueManager_->getData(
+        taskId,
+        destination,
+        [destination, expectedEndMarker, &receivedData](
+            std::shared_ptr<cudf::packed_columns> data,
+            std::vector<int64_t> remainingBytes) {
+          ASSERT_EQ(expectedEndMarker, data == nullptr)
+              << "for destination " << destination;
+          receivedData = true;
+        });
+    ASSERT_TRUE(receivedData) << "for destination " << destination;
+  }
+
+  UcxDataAvailableCallback receiveEndMarker(
+      int destination,
+      bool& receivedEndMarker) {
+    return [destination, &receivedEndMarker](
+               std::shared_ptr<cudf::packed_columns> data,
+               std::vector<int64_t> remainingBytes) {
+      EXPECT_FALSE(receivedEndMarker) << "for destination " << destination;
+      EXPECT_TRUE(data == nullptr) << "for destination " << destination;
+      EXPECT_TRUE(remainingBytes.empty());
+      receivedEndMarker = true;
+    };
+  }
+
+  void fetchEndMarker(std::string_view taskId, int destination) {
+    bool receivedData = false;
+    queueManager_->getData(
+        taskId, destination, receiveEndMarker(destination, receivedData));
+    EXPECT_TRUE(receivedData) << "for destination " << destination;
+    queueManager_->deleteResults(taskId, destination);
+  }
+
+  void deleteResults(std::string_view taskId, int destination) {
+    queueManager_->deleteResults(taskId, destination);
+  }
+
+  void registerForEndMarker(
+      std::string_view taskId,
+      int destination,
+      bool& receivedEndMarker) {
+    receivedEndMarker = false;
+    queueManager_->getData(
+        taskId, destination, receiveEndMarker(destination, receivedEndMarker));
+    EXPECT_FALSE(receivedEndMarker) << "for destination " << destination;
+  }
+
+  UcxDataAvailableCallback receiveData(int destination, bool& receivedData) {
+    receivedData = false;
+    return [destination, &receivedData](
+               std::shared_ptr<cudf::packed_columns> data,
+               std::vector<int64_t> /*remainingBytes*/) {
+      EXPECT_FALSE(receivedData) << "for destination " << destination;
+      EXPECT_TRUE(data != nullptr) << "for destination " << destination;
+      receivedData = true;
+    };
+  }
+
+  void registerForData(
+      std::string_view taskId,
+      int destination,
+      bool& receivedData) {
+    receivedData = false;
+    queueManager_->getData(
+        taskId, destination, receiveData(destination, receivedData));
+    EXPECT_FALSE(receivedData) << "for destination " << destination;
+  }
+
+  void dataFetcher(
+      std::string_view taskId,
+      int destination,
+      int64_t& fetchedPackedColumns,
+      bool earlyTermination) {
+    int64_t received{0};
+    folly::Random::DefaultGenerator rng;
+    rng.seed(destination);
+    while (true) {
+      if (earlyTermination && folly::Random().oneIn(200)) {
+        queueManager_->deleteResults(taskId, destination);
+        return;
+      }
+      bool atEnd{false};
+      folly::EventCount dataWait;
+      auto dataWaitKey = dataWait.prepareWait();
+      queueManager_->getData(
+          taskId,
+          destination,
+          [&](std::shared_ptr<cudf::packed_columns> data,
+              std::vector<int64_t> /*remainingBytes*/) {
+            if (data == nullptr) {
+              atEnd = true;
+            } else {
+              received++;
+            }
+            dataWait.notify();
+          });
+      dataWait.wait(dataWaitKey);
+      if (atEnd) {
+        break;
+      }
+    }
+    queueManager_->deleteResults(taskId, destination);
+    // out of order requests are allowed (fetch after delete)
+    {
+      struct Response {
+        std::shared_ptr<cudf::packed_columns> data;
+        std::vector<int64_t> remainingBytes;
+      };
+      folly::Promise<Response> promise;
+      auto future = promise.getSemiFuture();
+      queueManager_->getData(
+          taskId,
+          destination,
+          [&promise](
+              std::shared_ptr<cudf::packed_columns> data,
+              std::vector<int64_t> remainingBytes) {
+            promise.setValue(
+                Response{std::move(data), std::move(remainingBytes)});
+          });
+      future.wait();
+      ASSERT_TRUE(future.isReady());
+      auto& response = future.value();
+      ASSERT_EQ(response.remainingBytes.size(), 0);
+      ASSERT_EQ(response.data, nullptr);
+    }
+
+    fetchedPackedColumns = received;
+  }
+
+  std::shared_ptr<facebook::velox::memory::MemoryPool> pool_;
+  std::shared_ptr<UcxOutputQueueManager> queueManager_;
+};
+
+TEST_F(UcxOutputQueueManagerTest, basicPartitioned) {
+  vector_size_t size = 100;
+  std::string taskId = "t0";
+  auto task = initializeTask(taskId, 5 /* numDestinations*/, 1 /*numDrivers*/);
+
+  ASSERT_FALSE(queueManager_->isFinished(taskId));
+
+  // - enqueue one group per destination
+  // - fetch and ask one group per destination
+  // - enqueue one more group for destinations 0-2
+  // - fetch and ask one group for destinations 0-2
+  // - register end-marker callback for destination 3 and data callback for 4
+  // - enqueue data for 4 and assert callback was called
+  // - enqueue end marker for all destinations
+  // - assert callback was called for destination 3
+  // - fetch end markers for destinations 0-2 and 4
+
+  for (int destination = 0; destination < 5; ++destination) {
+    enqueue(taskId, destination, size);
+  }
+  EXPECT_FALSE(queueManager_->isFinished(taskId));
+
+  for (int destination = 0; destination < 5; destination++) {
+    fetch(taskId, destination);
+  }
+
+  EXPECT_FALSE(queueManager_->isFinished(taskId));
+
+  for (int destination = 0; destination < 3; destination++) {
+    enqueue(taskId, destination, size);
+  }
+
+  for (int destination = 0; destination < 3; destination++) {
+    fetch(taskId, destination);
+  }
+
+  // destinations 0-2 received 2 packed_columns each
+  // destinations 3-4 received 1 packed_columns each
+
+  bool receivedEndMarker3;
+  registerForEndMarker(taskId, 3, receivedEndMarker3);
+
+  bool receivedData4;
+  registerForData(taskId, 4, receivedData4);
+
+  enqueue(taskId, 4, size);
+  EXPECT_TRUE(receivedData4);
+
+  noMoreData(taskId);
+  EXPECT_TRUE(receivedEndMarker3);
+  EXPECT_FALSE(queueManager_->isFinished(taskId));
+
+  for (int destination = 0; destination < 3; destination++) {
+    fetchEndMarker(taskId, destination);
+  }
+
+  EXPECT_TRUE(task->isRunning());
+
+  deleteResults(taskId, 3);
+  fetchEndMarker(taskId, 4);
+  EXPECT_TRUE(queueManager_->isFinished(taskId));
+
+  queueManager_->removeTask(taskId);
+  EXPECT_TRUE(task->isFinished());
+}
+
+TEST_F(UcxOutputQueueManagerTest, basicAsyncFetch) {
+  const vector_size_t size = 10;
+  const std::string taskId = "t0";
+  int numPartitions = 1;
+  bool earlyTermination = false;
+
+  initializeTask(taskId, numPartitions, 1);
+
+  // asynchronously fetch data.
+  int64_t fetchedPackedColumns = 0;
+  std::thread thread([&]() {
+    dataFetcher(taskId, 0, fetchedPackedColumns, earlyTermination);
+  });
+  const int totalPackedColumns = 100;
+  int64_t producedPackedColumns = 0;
+
+  for (int i = 0; i < totalPackedColumns; ++i) {
+    const int partition = 0;
+    try {
+      enqueue(taskId, partition, size);
+    } catch (...) {
+      // Early termination might cause the task to fail early.
+      ASSERT_TRUE(earlyTermination);
+      break;
+    }
+    ++producedPackedColumns;
+    if (folly::Random().oneIn(4)) {
+      std::this_thread::sleep_for(std::chrono::microseconds(5)); // NOLINT
+    }
+  }
+  noMoreData(taskId);
+
+  thread.join();
+
+  if (!earlyTermination) {
+    ASSERT_EQ(fetchedPackedColumns, producedPackedColumns);
+  }
+  queueManager_->removeTask(taskId);
+}
+
+TEST_F(UcxOutputQueueManagerTest, lateTaskCreation) {
+  const vector_size_t size = 10;
+  const std::string taskId = "t0";
+  int numPartitions = 1;
+  bool earlyTermination = false;
+  int destination = 0;
+
+  // Clear stale state from prior tests (removeTask on a non-existing queue
+  // clears the removedTasks_ set, allowing getData to create a placeholder).
+  queueManager_->removeTask(taskId);
+
+  // Fetch data from a non-existing task.
+  struct Response {
+    std::shared_ptr<cudf::packed_columns> data;
+    std::vector<int64_t> remainingBytes;
+  };
+  folly::Promise<Response> promise;
+  auto future = promise.getSemiFuture();
+  queueManager_->getData(
+      taskId,
+      destination,
+      [&promise](
+          std::shared_ptr<cudf::packed_columns> data,
+          std::vector<int64_t> remainingBytes) {
+        promise.setValue(Response{std::move(data), std::move(remainingBytes)});
+      });
+  // initialize task.
+  auto task = initializeTask(taskId, numPartitions, 1, false);
+  // enqueue some data.
+  enqueue(taskId, destination, size);
+  noMoreData(taskId);
+  uint32_t i = 0;
+  while (true) {
+    ++i;
+    future.wait();
+    ASSERT_TRUE(future.isReady());
+    Response& response = future.value();
+    if (!response.data) {
+      // nullptr -> end of transmission.
+      break;
+    }
+    folly::Promise<Response> promise;
+    future = promise.getSemiFuture();
+    queueManager_->getData(
+        taskId,
+        destination,
+        [&promise](
+            std::shared_ptr<cudf::packed_columns> data,
+            std::vector<int64_t> remainingBytes) {
+          promise.setValue(
+              Response{std::move(data), std::move(remainingBytes)});
+        });
+  }
+  ASSERT_EQ(i, 2);
+
+  queueManager_->deleteResults(taskId, destination);
+  queueManager_->removeTask(taskId);
+  EXPECT_TRUE(task->isFinished());
+}
+
+TEST_F(UcxOutputQueueManagerTest, multiFetchers) {
+  const std::vector<bool> earlyTerminations = {false, true};
+  for (const auto earlyTermination : earlyTerminations) {
+    SCOPED_TRACE(fmt::format("earlyTermination {}", earlyTermination));
+
+    const vector_size_t size = 10;
+    const std::string taskId = "t0";
+    int numPartitions = 10;
+    initializeTask(taskId, numPartitions, 1);
+
+    // create one thread per partition to asynchronously fetch data.
+    std::vector<std::thread> threads;
+    std::vector<int64_t> fetchedPackedColumns(numPartitions, 0);
+
+    for (size_t i = 0; i < numPartitions; ++i) {
+      threads.emplace_back([&, i]() {
+        dataFetcher(taskId, i, fetchedPackedColumns.at(i), earlyTermination);
+      });
+    }
+
+    // enqueue packed columns.
+    folly::Random::DefaultGenerator rng;
+    rng.seed(1234);
+    const int totalPackedColumns = 1000;
+    std::vector<int64_t> producedPackedColumns(numPartitions, 0);
+    for (int i = 0; i < totalPackedColumns; ++i) {
+      // randomly chose a partition.
+      const int partition = folly::Random().rand32(rng) % numPartitions;
+      try {
+        enqueue(taskId, partition, size);
+      } catch (...) {
+        // Early termination might cause the task to fail early.
+        ASSERT_TRUE(earlyTermination);
+        break;
+      }
+      ++producedPackedColumns[partition];
+      if (folly::Random().oneIn(4)) {
+        std::this_thread::sleep_for(std::chrono::microseconds(5)); // NOLINT
+      }
+    }
+    noMoreData(taskId);
+
+    for (int i = 0; i < threads.size(); ++i) {
+      threads[i].join();
+    }
+
+    if (!earlyTermination) {
+      for (int i = 0; i < numPartitions; ++i) {
+        ASSERT_EQ(fetchedPackedColumns[i], producedPackedColumns[i]);
+      }
+    }
+    queueManager_->removeTask(taskId);
+  }
+}
+
+// Test BUG B scenario (a): Producer never starts / never calls
+// initializeTask(). getData() creates a stub queue, then removeTask() is
+// called without initializeTask() ever being called. The pending callback
+// must fire with nullptr to unblock the consumer.
+TEST_F(UcxOutputQueueManagerTest, callbackFiredOnTerminateBeforeInit) {
+  const std::string taskId = "orphanTest";
+  queueManager_->removeTask(taskId); // ensure clean state
+
+  bool callbackFired = false;
+  bool receivedNullptr = false;
+  queueManager_->getData(
+      taskId,
+      0, // destination
+      [&callbackFired, &receivedNullptr](
+          std::shared_ptr<cudf::packed_columns> data,
+          std::vector<int64_t> remainingBytes) {
+        callbackFired = true;
+        receivedNullptr = (data == nullptr);
+      });
+
+  // Callback should NOT have fired yet (queue is empty, no data).
+  EXPECT_FALSE(callbackFired);
+
+  // Now simulate the producer failing: removeTask fires terminate().
+  // The stub queue has task_ == nullptr so the isRunning() check is skipped.
+  queueManager_->removeTask(taskId);
+
+  // Callback must have been fired with nullptr.
+  EXPECT_TRUE(callbackFired);
+  EXPECT_TRUE(receivedNullptr);
+}
+
+// Test BUG B scenario (b): Producer starts but crashes before noMoreData().
+// initializeTask() was called but noMoreData() was never called.
+// removeTask() must fire pending callbacks with nullptr.
+TEST_F(UcxOutputQueueManagerTest, callbackFiredOnTerminateAfterInit) {
+  const std::string taskId = "crashTest";
+  queueManager_->removeTask(taskId); // ensure clean state
+
+  auto task =
+      initializeTask(taskId, 2 /* numDestinations */, 1 /* numDrivers */);
+
+  // Register callbacks on both destinations.
+  bool callback0Fired = false;
+  bool callback0Nullptr = false;
+  bool callback1Fired = false;
+  bool callback1Nullptr = false;
+  queueManager_->getData(
+      taskId,
+      0,
+      [&callback0Fired, &callback0Nullptr](
+          std::shared_ptr<cudf::packed_columns> data,
+          std::vector<int64_t> remainingBytes) {
+        callback0Fired = true;
+        callback0Nullptr = (data == nullptr);
+      });
+  queueManager_->getData(
+      taskId,
+      1,
+      [&callback1Fired, &callback1Nullptr](
+          std::shared_ptr<cudf::packed_columns> data,
+          std::vector<int64_t> remainingBytes) {
+        callback1Fired = true;
+        callback1Nullptr = (data == nullptr);
+      });
+
+  // Neither callback should fire yet.
+  EXPECT_FALSE(callback0Fired);
+  EXPECT_FALSE(callback1Fired);
+
+  // Simulate task failure: abort the task so isRunning() returns false,
+  // which is required by terminate()'s VELOX_CHECK.
+  task->requestAbort().wait();
+
+  queueManager_->removeTask(taskId);
+
+  EXPECT_TRUE(callback0Fired);
+  EXPECT_TRUE(callback0Nullptr);
+  EXPECT_TRUE(callback1Fired);
+  EXPECT_TRUE(callback1Nullptr);
+}
+
+// --- Broadcast tests ---
+
+// Basic broadcast: enqueue data, all destinations receive the same data.
+TEST_F(UcxOutputQueueManagerTest, broadcastBasic) {
+  const vector_size_t size = 100;
+  const std::string taskId = "broadcast0";
+  const int numDestinations = 3;
+
+  auto task = initializeTask(
+      taskId,
+      numDestinations,
+      1 /* numDrivers */,
+      true /* cleanup */,
+      core::PartitionedOutputNode::Kind::kBroadcast);
+
+  // Broadcast must not be finished before noMoreQueues.
+  EXPECT_FALSE(queueManager_->isFinished(taskId));
+
+  // Tell the queue manager the final number of destinations.
+  queueManager_->updateOutputBuffers(taskId, numDestinations, true);
+
+  // Enqueue one batch (broadcast always uses destination 0).
+  enqueue(taskId, 0, size);
+
+  // All destinations should receive the data.
+  for (int dest = 0; dest < numDestinations; ++dest) {
+    fetch(taskId, dest);
+  }
+
+  // Signal no more data.
+  noMoreData(taskId);
+
+  // Fetch end markers from all destinations.
+  for (int dest = 0; dest < numDestinations; ++dest) {
+    fetchEndMarker(taskId, dest);
+  }
+
+  EXPECT_TRUE(queueManager_->isFinished(taskId));
+  queueManager_->removeTask(taskId);
+}
+
+// Broadcast: late destination receives backfilled data.
+TEST_F(UcxOutputQueueManagerTest, broadcastLateDestination) {
+  const vector_size_t size = 50;
+  const std::string taskId = "broadcast1";
+
+  // Start with 2 destinations.
+  auto task = initializeTask(
+      taskId,
+      2 /* numDestinations */,
+      1 /* numDrivers */,
+      true /* cleanup */,
+      core::PartitionedOutputNode::Kind::kBroadcast);
+
+  // Enqueue 2 batches before the 3rd destination arrives.
+  enqueue(taskId, 0, size);
+  enqueue(taskId, 0, size);
+
+  // Fetch from existing destinations to verify data is there.
+  fetch(taskId, 0);
+  fetch(taskId, 1);
+
+  // Now add a 3rd destination (late arrival). It should be backfilled.
+  queueManager_->updateOutputBuffers(taskId, 3, false);
+
+  // The new destination should have both batches.
+  fetch(taskId, 2);
+  fetch(taskId, 2);
+
+  // Finalize destinations and data.
+  queueManager_->updateOutputBuffers(taskId, 3, true);
+  noMoreData(taskId);
+
+  // Fetch remaining data + end markers.
+  fetch(taskId, 0);
+  fetchEndMarker(taskId, 0);
+  fetch(taskId, 1);
+  fetchEndMarker(taskId, 1);
+  fetchEndMarker(taskId, 2);
+
+  EXPECT_TRUE(queueManager_->isFinished(taskId));
+  queueManager_->removeTask(taskId);
+}
+
+// Broadcast: isFinished requires noMoreQueues.
+TEST_F(UcxOutputQueueManagerTest, broadcastNotFinishedWithoutNoMoreQueues) {
+  const std::string taskId = "broadcast2";
+
+  auto task = initializeTask(
+      taskId,
+      2 /* numDestinations */,
+      1 /* numDrivers */,
+      true /* cleanup */,
+      core::PartitionedOutputNode::Kind::kBroadcast);
+
+  // Signal no more data.
+  noMoreData(taskId);
+
+  // Fetch end markers and delete results from all destinations.
+  fetchEndMarker(taskId, 0);
+  fetchEndMarker(taskId, 1);
+
+  // Still not finished because noMoreQueues hasn't been signaled.
+  EXPECT_FALSE(queueManager_->isFinished(taskId));
+
+  // Signal no more queues.
+  queueManager_->updateOutputBuffers(taskId, 2, true);
+
+  EXPECT_TRUE(queueManager_->isFinished(taskId));
+  queueManager_->removeTask(taskId);
+}
+
+// Broadcast: end marker propagated to late-arriving destinations.
+TEST_F(UcxOutputQueueManagerTest, broadcastEndMarkerToLateDestination) {
+  const std::string taskId = "broadcast3";
+
+  auto task = initializeTask(
+      taskId,
+      1 /* numDestinations */,
+      1 /* numDrivers */,
+      true /* cleanup */,
+      core::PartitionedOutputNode::Kind::kBroadcast);
+
+  enqueue(taskId, 0, 10);
+  noMoreData(taskId);
+
+  // Add a late destination after end marker was set.
+  queueManager_->updateOutputBuffers(taskId, 2, true);
+
+  // Destination 0: data + end marker.
+  fetch(taskId, 0);
+  fetchEndMarker(taskId, 0);
+
+  // Destination 1 (late): backfilled data + end marker.
+  fetch(taskId, 1);
+  fetchEndMarker(taskId, 1);
+
+  EXPECT_TRUE(queueManager_->isFinished(taskId));
+  queueManager_->removeTask(taskId);
+}
diff --git a/velox/experimental/ucx-exchange/tests/UcxPartitionedOutputMock.cpp b/velox/experimental/ucx-exchange/tests/UcxPartitionedOutputMock.cpp
new file mode 100644
index 00000000000..6696822ea50
--- /dev/null
+++ b/velox/experimental/ucx-exchange/tests/UcxPartitionedOutputMock.cpp
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/ucx-exchange/tests/UcxPartitionedOutputMock.h"
+#include "velox/experimental/ucx-exchange/UcxExchangeProtocol.h"
+#include "velox/experimental/ucx-exchange/UcxQueues.h"
+#include "velox/experimental/ucx-exchange/tests/UcxTestHelpers.h"
+
+namespace facebook::velox::ucx_exchange {
+
+UcxPartitionedOutputMock::UcxPartitionedOutputMock(
+    std::string_view taskId,
+    const uint32_t numDrivers,
+    const size_t numPartitions,
+    const uint32_t numDataChunks,
+    const size_t numRowsPerChunk,
+    std::shared_ptr<BaseTableGenerator> tableGenerator)
+    : queueManager_(UcxOutputQueueManager::getInstanceRef()),
+      taskId_(taskId),
+      numDrivers_(numDrivers),
+      numPartitions_(numPartitions),
+      numDataChunks_(numDataChunks),
+      numRowsPerChunk_(numRowsPerChunk),
+      tableGenerator_(tableGenerator) {}
+
+void UcxPartitionedOutputMock::run() {
+  threads_.clear();
+  for (int32_t driver = 0; driver < numDrivers_; ++driver) {
+    threads_.emplace_back(&UcxPartitionedOutputMock::publishDataChunks, this);
+  }
+}
+
+void UcxPartitionedOutputMock::joinThreads() {
+  for (auto& thread : threads_) {
+    thread.join();
+  }
+  threads_.clear();
+}
+
+void UcxPartitionedOutputMock::publishDataChunks() {
+  // create numPartitions_ x numDataChunks_ data chunks and
+  // push it into the destination queues identified by the taskId.
+  auto stream = rmm::cuda_stream_default;
+  for (size_t partition = 0; partition < numPartitions_; ++partition) {
+    for (uint32_t dataChunk = 0; dataChunk < numDataChunks_; ++dataChunk) {
+      VLOG(3)
+          << "In UcxPartitionedOutputMock::publishDataChunks writing to partition "
+          << partition << " chunk " << dataChunk;
+      // create a data chunk with numRowsPerChunk_ rows
+      // and push it into the destination queue identified by the taskId.
+
+      std::unique_ptr<cudf::table> table;
+      if (tableGenerator_ == nullptr) {
+        table = makeTable(numRowsPerChunk_, UcxTestData::kTestRowType, stream);
+      } else {
+        table = tableGenerator_->makeTable(stream);
+      }
+      auto packedCols = std::make_unique<cudf::packed_columns>(
+          cudf::pack(table->view(), stream));
+      // Sync the stream since UCXX/UCX is not stream oriented and without
+      // syncing, data could get lost. Syncing here is  easy but not the most
+      // efficient. A better approach is to create an event and pass it along
+      // the data through the queue and synchronize on the event before calling
+      // into UCXX.
+      stream.synchronize();
+      queueManager_->enqueue(
+          taskId_, partition, std::move(packedCols), numRowsPerChunk_);
+    }
+  }
+  // tell the queue manager that we are done.
+  queueManager_->noMoreData(taskId_);
+}
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/tests/UcxPartitionedOutputMock.h b/velox/experimental/ucx-exchange/tests/UcxPartitionedOutputMock.h
new file mode 100644
index 00000000000..94764b2e3cb
--- /dev/null
+++ b/velox/experimental/ucx-exchange/tests/UcxPartitionedOutputMock.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/experimental/ucx-exchange/UcxOutputQueueManager.h"
+#include "velox/experimental/ucx-exchange/tests/UcxTestData.h"
+
+namespace facebook::velox::ucx_exchange {
+
+/// @brief Mocks one or more cudf partitioned output operators. Each
+/// operator pushes data into a set of partitions.
+/// The operators run in separate threads, one thread per driver.
+class UcxPartitionedOutputMock {
+ public:
+  UcxPartitionedOutputMock(
+      std::string_view taskId,
+      const uint32_t numDrivers,
+      const size_t numPartitions,
+      const uint32_t numDataChunks,
+      const size_t numRowsPerChunk,
+      std::shared_ptr<BaseTableGenerator> tableGenerator = nullptr);
+
+  /// @brief Created the driver threads and pushes data into the task's output
+  /// queue.
+  void run();
+
+  /// @brief Wait for all threads to complete.
+  void joinThreads();
+
+ private:
+  // creates numPartitions_ x numDataChunks_ data chunks and
+  // pushes it into the destination queues identified by the taskId.
+  void publishDataChunks();
+
+  const std::shared_ptr<UcxOutputQueueManager> queueManager_;
+  const std::string taskId_;
+  const uint32_t numDrivers_;
+  const size_t numPartitions_;
+  const uint32_t numDataChunks_;
+  const size_t numRowsPerChunk_;
+  const std::shared_ptr<BaseTableGenerator> tableGenerator_;
+  std::vector<std::thread> threads_;
+};
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/tests/UcxTestData.cpp b/velox/experimental/ucx-exchange/tests/UcxTestData.cpp
new file mode 100644
index 00000000000..5181a841de8
--- /dev/null
+++ b/velox/experimental/ucx-exchange/tests/UcxTestData.cpp
@@ -0,0 +1,568 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/ucx-exchange/tests/UcxTestData.h"
+
+#include <cudf/column/column_factories.hpp>
+#include <cudf/detail/utilities/vector_factories.hpp>
+#include <cudf/strings/strings_column_view.hpp>
+#include <cudf/structs/structs_column_view.hpp>
+#include <rmm/device_buffer.hpp>
+
+#include <functional>
+#include <random>
+
+namespace facebook::velox::ucx_exchange {
+
+static const char alphanum[] =
+    "0123456789"
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    "abcdefghijklmnopqrstuvwxyz";
+
+// ----- BaseTableGenerator static helper methods -----
+
+std::string BaseTableGenerator::genRandomStr(size_t len) {
+  thread_local std::mt19937 gen{std::random_device{}()};
+  std::uniform_int_distribution<size_t> dist(0, sizeof(alphanum) - 2);
+  std::string rStr;
+  rStr.reserve(len);
+  for (size_t i = 0; i < len; ++i) {
+    rStr += alphanum[dist(gen)];
+  }
+  return rStr;
+}
+
+template <typename T>
+std::unique_ptr<cudf::column> BaseTableGenerator::makeNumericColumn(
+    const std::vector<T>& hostValues,
+    rmm::cuda_stream_view stream) {
+  size_t numRows = hostValues.size();
+
+  // Allocate a device buffer of the correct size
+  rmm::device_buffer data(
+      numRows * sizeof(T), stream, rmm::mr::get_current_device_resource());
+
+  // Copy host -> device
+  cudaMemcpyAsync(
+      data.data(),
+      hostValues.data(),
+      numRows * sizeof(T),
+      cudaMemcpyHostToDevice,
+      stream.value());
+
+  // Build the cudf::column from the device buffer
+  return std::make_unique<cudf::column>(
+      cudf::data_type{cudf::type_to_id<T>()},
+      numRows,
+      std::move(data),
+      rmm::device_buffer{}, // no null mask
+      0); // no nulls
+}
+
+// Explicit template instantiations
+template std::unique_ptr<cudf::column> BaseTableGenerator::makeNumericColumn(
+    const std::vector<int8_t>& hostValues,
+    rmm::cuda_stream_view stream);
+template std::unique_ptr<cudf::column> BaseTableGenerator::makeNumericColumn(
+    const std::vector<int16_t>& hostValues,
+    rmm::cuda_stream_view stream);
+template std::unique_ptr<cudf::column> BaseTableGenerator::makeNumericColumn(
+    const std::vector<int32_t>& hostValues,
+    rmm::cuda_stream_view stream);
+template std::unique_ptr<cudf::column> BaseTableGenerator::makeNumericColumn(
+    const std::vector<int64_t>& hostValues,
+    rmm::cuda_stream_view stream);
+template std::unique_ptr<cudf::column> BaseTableGenerator::makeNumericColumn(
+    const std::vector<uint8_t>& hostValues,
+    rmm::cuda_stream_view stream);
+template std::unique_ptr<cudf::column> BaseTableGenerator::makeNumericColumn(
+    const std::vector<uint16_t>& hostValues,
+    rmm::cuda_stream_view stream);
+template std::unique_ptr<cudf::column> BaseTableGenerator::makeNumericColumn(
+    const std::vector<uint32_t>& hostValues,
+    rmm::cuda_stream_view stream);
+template std::unique_ptr<cudf::column> BaseTableGenerator::makeNumericColumn(
+    const std::vector<uint64_t>& hostValues,
+    rmm::cuda_stream_view stream);
+template std::unique_ptr<cudf::column> BaseTableGenerator::makeNumericColumn(
+    const std::vector<float>& hostValues,
+    rmm::cuda_stream_view stream);
+template std::unique_ptr<cudf::column> BaseTableGenerator::makeNumericColumn(
+    const std::vector<double>& hostValues,
+    rmm::cuda_stream_view stream);
+
+std::unique_ptr<cudf::column> BaseTableGenerator::makeStringsColumn(
+    const std::vector<std::string>& hostStrings) {
+  auto numRows = hostStrings.size();
+
+  // --- Create offsets array ---
+  std::vector<int32_t> hOffsets(numRows + 1);
+  hOffsets[0] = 0;
+  for (size_t i = 0; i < numRows; ++i) {
+    hOffsets[i + 1] = hOffsets[i] + static_cast<int32_t>(hostStrings[i].size());
+  }
+
+  // Copy offsets to device
+  auto offsetsCol = cudf::make_numeric_column(
+      cudf::data_type{cudf::type_id::INT32},
+      numRows + 1,
+      cudf::mask_state::UNALLOCATED);
+
+  cudaMemcpy(
+      offsetsCol->mutable_view().data<int32_t>(),
+      hOffsets.data(),
+      sizeof(int32_t) * (numRows + 1),
+      cudaMemcpyHostToDevice);
+
+  // --- Create chars buffer ---
+  size_t totalBytes = 0;
+  for (auto const& s : hostStrings)
+    totalBytes += s.size();
+
+  rmm::device_buffer charsBuffer(
+      totalBytes,
+      cudf::get_default_stream(),
+      rmm::mr::get_current_device_resource());
+
+  std::vector<char> hostConcat;
+  hostConcat.reserve(totalBytes);
+  for (auto const& s : hostStrings)
+    hostConcat.insert(hostConcat.end(), s.begin(), s.end());
+
+  cudaMemcpy(
+      charsBuffer.data(),
+      hostConcat.data(),
+      totalBytes,
+      cudaMemcpyHostToDevice);
+
+  // --- Build strings column ---
+  return cudf::make_strings_column(
+      numRows,
+      std::move(offsetsCol),
+      std::move(charsBuffer),
+      0, // null_count
+      rmm::device_buffer{}); // null mask
+}
+
+std::unique_ptr<cudf::column> BaseTableGenerator::makeStructColumn(
+    std::vector<std::unique_ptr<cudf::column>> children,
+    cudf::size_type numRows) {
+  return cudf::make_structs_column(
+      numRows,
+      std::move(children),
+      0, // null_count
+      rmm::device_buffer{}); // null_mask
+}
+
+template <typename T>
+std::vector<T> BaseTableGenerator::getColVector(
+    const cudf::column_view& columnView,
+    cudf::size_type maxRows,
+    rmm::cuda_stream_view stream) {
+  maxRows = columnView.size() < maxRows ? columnView.size() : maxRows;
+  const T* ptrData = columnView.data<T>();
+  auto hostVec = cudf::detail::make_host_vector_async(
+      cudf::device_span<T const>(ptrData, maxRows), stream);
+  std::vector<T> vec(maxRows);
+  std::copy(hostVec.begin(), hostVec.end(), vec.begin());
+  return vec;
+}
+
+// Explicit template instantiations for getColVector
+template std::vector<int8_t> BaseTableGenerator::getColVector(
+    const cudf::column_view& columnView,
+    cudf::size_type maxRows,
+    rmm::cuda_stream_view stream);
+template std::vector<int16_t> BaseTableGenerator::getColVector(
+    const cudf::column_view& columnView,
+    cudf::size_type maxRows,
+    rmm::cuda_stream_view stream);
+template std::vector<int32_t> BaseTableGenerator::getColVector(
+    const cudf::column_view& columnView,
+    cudf::size_type maxRows,
+    rmm::cuda_stream_view stream);
+template std::vector<int64_t> BaseTableGenerator::getColVector(
+    const cudf::column_view& columnView,
+    cudf::size_type maxRows,
+    rmm::cuda_stream_view stream);
+template std::vector<uint8_t> BaseTableGenerator::getColVector(
+    const cudf::column_view& columnView,
+    cudf::size_type maxRows,
+    rmm::cuda_stream_view stream);
+template std::vector<uint16_t> BaseTableGenerator::getColVector(
+    const cudf::column_view& columnView,
+    cudf::size_type maxRows,
+    rmm::cuda_stream_view stream);
+template std::vector<uint32_t> BaseTableGenerator::getColVector(
+    const cudf::column_view& columnView,
+    cudf::size_type maxRows,
+    rmm::cuda_stream_view stream);
+template std::vector<uint64_t> BaseTableGenerator::getColVector(
+    const cudf::column_view& columnView,
+    cudf::size_type maxRows,
+    rmm::cuda_stream_view stream);
+template std::vector<float> BaseTableGenerator::getColVector(
+    const cudf::column_view& columnView,
+    cudf::size_type maxRows,
+    rmm::cuda_stream_view stream);
+template std::vector<double> BaseTableGenerator::getColVector(
+    const cudf::column_view& columnView,
+    cudf::size_type maxRows,
+    rmm::cuda_stream_view stream);
+
+std::vector<std::string> BaseTableGenerator::getStringCol(
+    const cudf::column_view& columnView,
+    cudf::size_type maxRows,
+    rmm::cuda_stream_view stream) {
+  cudf::strings_column_view strColView{columnView};
+  maxRows = strColView.size() < maxRows ? strColView.size() : maxRows;
+
+  auto offsetView = strColView.offsets();
+  const cudf::size_type* ptrOffsetsData = offsetView.data<cudf::size_type>();
+  auto const hOffsets = cudf::detail::make_host_vector_async(
+      cudf::device_span<cudf::size_type const>(ptrOffsetsData, maxRows + 1),
+      stream);
+  const cudf::size_type* hostOffsets = hOffsets.data();
+
+  auto const totalNumBytes = std::distance(
+      strColView.chars_begin(stream), strColView.chars_end(stream));
+  char const* ptrAllBytes = strColView.chars_begin(stream);
+  auto const hBytes = cudf::detail::make_host_vector_async(
+      cudf::device_span<char const>(ptrAllBytes, totalNumBytes), stream);
+  const char* strPtr = hBytes.data();
+
+  std::vector<std::string> strVec;
+  for (cudf::size_type i = 0; i < maxRows; ++i) {
+    std::string str(strPtr + hostOffsets[i], strPtr + hostOffsets[i + 1]);
+    strVec.push_back(str);
+  }
+  return strVec;
+}
+
+// ----- UcxTestData implementation -----
+
+void UcxTestData::initialize(
+    size_t numRows,
+    size_t minStringLength,
+    size_t maxStringLength) {
+  VLOG(3) << "+ UcxTestData::initialize numRows:" << numRows
+          << " stringLength:[" << minStringLength << ".." << maxStringLength
+          << "]";
+  numRows_ = numRows;
+  strings_ = std::make_shared<std::vector<std::string>>();
+  integers_ = std::make_shared<std::vector<uint32_t>>();
+  floats_ = std::make_shared<std::vector<float>>();
+
+  std::random_device rd;
+  std::mt19937 gen(rd());
+  std::uniform_int_distribution<> dist(minStringLength, maxStringLength);
+  std::hash<std::string> hasher;
+
+  for (size_t i = 0; i < numRows_; i++) {
+    int strLength = dist(gen);
+    std::string str = genRandomStr(strLength);
+    double hashValue = hasher(str);
+
+    strings_->push_back(str);
+    integers_->push_back(strLength);
+    floats_->push_back(hashValue);
+  }
+
+  for (size_t i = 0; i < numRows; i++) {
+    VLOG(4) << "In dataTest Generated data String: " << strings_->at(i)
+            << " Integer: " << integers_->at(i) << " Float: " << floats_->at(i);
+  }
+
+  VLOG(3) << "- UcxTestData::initialize";
+}
+
+std::unique_ptr<cudf::table> UcxTestData::makeTable(
+    rmm::cuda_stream_view stream) {
+  std::vector<std::unique_ptr<cudf::column>> columns;
+
+  // Column 0: INT32 (integers)
+  columns.push_back(makeNumericColumn(*integers_, stream));
+
+  // Column 1: FLOAT32
+  columns.push_back(makeNumericColumn(*floats_, stream));
+
+  // Column 2: STRING
+  columns.push_back(makeStringsColumn(*strings_));
+
+  return std::make_unique<cudf::table>(std::move(columns));
+}
+
+bool UcxTestData::verifyTable(
+    const cudf::table_view& table,
+    size_t startRow,
+    size_t numRows,
+    rmm::cuda_stream_view stream) {
+  if (table.num_columns() != 3) {
+    VLOG(0) << "UcxTestData::verifyTable: expected 3 columns, got "
+            << table.num_columns();
+    return false;
+  }
+
+  // Get the data from the received table
+  auto receivedInts = getColVector<uint32_t>(table.column(0), numRows, stream);
+  auto receivedDoubles = getColVector<float>(table.column(1), numRows, stream);
+  auto receivedStrings = getStringCol(table.column(2), numRows, stream);
+
+  // Compare with expected data. Use modular indexing because batch
+  // accumulation in UcxPartitionedOutput may concatenate multiple identical
+  // chunks into one larger table, causing srcIdx to exceed the reference size.
+  for (size_t i = 0; i < numRows; ++i) {
+    size_t srcIdx = (startRow + i) % integers_->size();
+
+    if (receivedInts[i] != (*integers_)[srcIdx]) {
+      VLOG(0) << "UcxTestData::verifyTable: int mismatch at row " << i
+              << ": expected " << (*integers_)[srcIdx] << ", got "
+              << receivedInts[i];
+      return false;
+    }
+
+    if (receivedDoubles[i] != (*floats_)[srcIdx]) {
+      VLOG(0) << "UcxTestData::verifyTable: float mismatch at row " << i
+              << ": expected " << (*floats_)[srcIdx] << ", got "
+              << receivedDoubles[i];
+      return false;
+    }
+
+    if (receivedStrings[i] != (*strings_)[srcIdx]) {
+      VLOG(0) << "UcxTestData::verifyTable: string mismatch at row " << i
+              << ": expected '" << (*strings_)[srcIdx] << "', got '"
+              << receivedStrings[i] << "'";
+      return false;
+    }
+  }
+
+  return true;
+}
+
+// ----- WideTestTable implementation -----
+// Contains only numeric columns (no STRING or STRUCT)
+
+void WideTestTable::initialize(size_t numRows) {
+  VLOG(3) << "+ WideTestTable::initialize numRows:" << numRows;
+  numRows_ = numRows;
+
+  std::random_device rd;
+  std::mt19937 gen(rd());
+  std::uniform_int_distribution<int64_t> intDist(-1000000, 1000000);
+  std::uniform_real_distribution<double> doubleDist(-1000.0, 1000.0);
+  std::uniform_int_distribution<> boolDist(0, 1);
+
+  int8Data_.resize(numRows);
+  int16Data_.resize(numRows);
+  int32Data_.resize(numRows);
+  int64Data_.resize(numRows);
+  uint8Data_.resize(numRows);
+  uint16Data_.resize(numRows);
+  uint32Data_.resize(numRows);
+  uint64Data_.resize(numRows);
+  float32Data_.resize(numRows);
+  float64Data_.resize(numRows);
+  boolData_.resize(numRows);
+
+  for (size_t i = 0; i < numRows; ++i) {
+    int64_t randInt = intDist(gen);
+    double randDouble = doubleDist(gen);
+
+    int8Data_[i] = static_cast<int8_t>(randInt % 128);
+    int16Data_[i] = static_cast<int16_t>(randInt % 32768);
+    int32Data_[i] = static_cast<int32_t>(randInt);
+    int64Data_[i] = randInt;
+    uint8Data_[i] = static_cast<uint8_t>(std::abs(randInt) % 256);
+    uint16Data_[i] = static_cast<uint16_t>(std::abs(randInt) % 65536);
+    uint32Data_[i] = static_cast<uint32_t>(std::abs(randInt));
+    uint64Data_[i] = static_cast<uint64_t>(std::abs(randInt));
+    float32Data_[i] = static_cast<float>(randDouble);
+    float64Data_[i] = randDouble;
+    boolData_[i] = boolDist(gen);
+  }
+
+  VLOG(3) << "- WideTestTable::initialize";
+}
+
+void WideTestTable::addNumericColumns(
+    std::vector<std::unique_ptr<cudf::column>>& columns,
+    rmm::cuda_stream_view stream) {
+  columns.push_back(makeNumericColumn(int8Data_, stream));
+  columns.push_back(makeNumericColumn(int16Data_, stream));
+  columns.push_back(makeNumericColumn(int32Data_, stream));
+  columns.push_back(makeNumericColumn(int64Data_, stream));
+  columns.push_back(makeNumericColumn(uint8Data_, stream));
+  columns.push_back(makeNumericColumn(uint16Data_, stream));
+  columns.push_back(makeNumericColumn(uint32Data_, stream));
+  columns.push_back(makeNumericColumn(uint64Data_, stream));
+  columns.push_back(makeNumericColumn(float32Data_, stream));
+  columns.push_back(makeNumericColumn(float64Data_, stream));
+  columns.push_back(makeNumericColumn(boolData_, stream));
+}
+
+std::unique_ptr<cudf::table> WideTestTable::makeTable(
+    rmm::cuda_stream_view stream) {
+  std::vector<std::unique_ptr<cudf::column>> columns;
+  addNumericColumns(columns, stream);
+  return std::make_unique<cudf::table>(std::move(columns));
+}
+
+bool WideTestTable::verifyNumericColumns(
+    const cudf::table_view& table,
+    size_t startRow,
+    size_t numRows,
+    rmm::cuda_stream_view stream) {
+  // Verify numeric columns (columns 0-10)
+  auto rxInt8 = getColVector<int8_t>(table.column(0), numRows, stream);
+  auto rxInt16 = getColVector<int16_t>(table.column(1), numRows, stream);
+  auto rxInt32 = getColVector<int32_t>(table.column(2), numRows, stream);
+  auto rxInt64 = getColVector<int64_t>(table.column(3), numRows, stream);
+  auto rxUint8 = getColVector<uint8_t>(table.column(4), numRows, stream);
+  auto rxUint16 = getColVector<uint16_t>(table.column(5), numRows, stream);
+  auto rxUint32 = getColVector<uint32_t>(table.column(6), numRows, stream);
+  auto rxUint64 = getColVector<uint64_t>(table.column(7), numRows, stream);
+  auto rxFloat32 = getColVector<float>(table.column(8), numRows, stream);
+  auto rxFloat64 = getColVector<double>(table.column(9), numRows, stream);
+  auto rxBool = getColVector<int8_t>(table.column(10), numRows, stream);
+
+  // Use modular indexing because batch accumulation in UcxPartitionedOutput
+  // may concatenate multiple identical chunks into one larger table, causing
+  // srcIdx to exceed the reference size.
+  for (size_t i = 0; i < numRows; ++i) {
+    size_t srcIdx = (startRow + i) % numRows_;
+
+    if (rxInt8[i] != int8Data_[srcIdx] || rxInt16[i] != int16Data_[srcIdx] ||
+        rxInt32[i] != int32Data_[srcIdx] || rxInt64[i] != int64Data_[srcIdx] ||
+        rxUint8[i] != uint8Data_[srcIdx] ||
+        rxUint16[i] != uint16Data_[srcIdx] ||
+        rxUint32[i] != uint32Data_[srcIdx] ||
+        rxUint64[i] != uint64Data_[srcIdx] ||
+        rxFloat32[i] != float32Data_[srcIdx] ||
+        rxFloat64[i] != float64Data_[srcIdx] ||
+        rxBool[i] != boolData_[srcIdx]) {
+      VLOG(0) << "verifyNumericColumns: data mismatch at row " << i;
+      return false;
+    }
+  }
+  return true;
+}
+
+bool WideTestTable::verifyTable(
+    const cudf::table_view& table,
+    size_t startRow,
+    size_t numRows,
+    rmm::cuda_stream_view stream) {
+  if (table.num_columns() != 11) {
+    VLOG(0) << "WideTestTable::verifyTable: expected 11 columns, got "
+            << table.num_columns();
+    return false;
+  }
+  return verifyNumericColumns(table, startRow, numRows, stream);
+}
+
+// ----- WideComplexTestTable implementation -----
+// Extends WideTestTable with STRING and STRUCT columns
+
+void WideComplexTestTable::initialize(size_t numRows) {
+  // First initialize the base class (numeric columns)
+  WideTestTable::initialize(numRows);
+
+  VLOG(3) << "+ WideComplexTestTable::initialize (adding complex columns)";
+
+  std::random_device rd;
+  std::mt19937 gen(rd());
+  std::uniform_int_distribution<int64_t> intDist(-1000000, 1000000);
+  std::uniform_real_distribution<double> doubleDist(-1000.0, 1000.0);
+  std::uniform_int_distribution<> strLenDist(1, 20);
+
+  stringData_.resize(numRows);
+  structField1Data_.resize(numRows);
+  structField2Data_.resize(numRows);
+
+  for (size_t i = 0; i < numRows; ++i) {
+    int64_t randInt = intDist(gen);
+    double randDouble = doubleDist(gen);
+
+    stringData_[i] = genRandomStr(strLenDist(gen));
+    structField1Data_[i] = randInt * 2;
+    structField2Data_[i] = randDouble * 2.0;
+  }
+
+  VLOG(3) << "- WideComplexTestTable::initialize";
+}
+
+std::unique_ptr<cudf::table> WideComplexTestTable::makeTable(
+    rmm::cuda_stream_view stream) {
+  std::vector<std::unique_ptr<cudf::column>> columns;
+
+  // Add numeric columns from base class
+  addNumericColumns(columns, stream);
+
+  // Add string column
+  columns.push_back(makeStringsColumn(stringData_));
+
+  // Add struct column
+  std::vector<std::unique_ptr<cudf::column>> structChildren;
+  structChildren.push_back(makeNumericColumn(structField1Data_, stream));
+  structChildren.push_back(makeNumericColumn(structField2Data_, stream));
+  columns.push_back(makeStructColumn(
+      std::move(structChildren), static_cast<cudf::size_type>(numRows_)));
+
+  return std::make_unique<cudf::table>(std::move(columns));
+}
+
+bool WideComplexTestTable::verifyTable(
+    const cudf::table_view& table,
+    size_t startRow,
+    size_t numRows,
+    rmm::cuda_stream_view stream) {
+  if (table.num_columns() != 13) {
+    VLOG(0) << "WideComplexTestTable::verifyTable: expected 13 columns, got "
+            << table.num_columns();
+    return false;
+  }
+
+  // First verify numeric columns using base class helper
+  if (!verifyNumericColumns(table, startRow, numRows, stream)) {
+    return false;
+  }
+
+  // Verify string column (column 11)
+  auto rxStrings = getStringCol(table.column(11), numRows, stream);
+
+  // Verify struct column children (column 12)
+  cudf::structs_column_view structView{table.column(12)};
+  auto rxStructField1 =
+      getColVector<int64_t>(structView.child(0), numRows, stream);
+  auto rxStructField2 =
+      getColVector<double>(structView.child(1), numRows, stream);
+
+  for (size_t i = 0; i < numRows; ++i) {
+    size_t srcIdx = (startRow + i) % numRows_;
+    if (rxStrings[i] != stringData_[srcIdx] ||
+        rxStructField1[i] != structField1Data_[srcIdx] ||
+        rxStructField2[i] != structField2Data_[srcIdx]) {
+      VLOG(0)
+          << "WideComplexTestTable::verifyTable: complex column mismatch at row "
+          << i;
+      return false;
+    }
+  }
+
+  return true;
+}
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/tests/UcxTestData.h b/velox/experimental/ucx-exchange/tests/UcxTestData.h
new file mode 100644
index 00000000000..356ca0aa98f
--- /dev/null
+++ b/velox/experimental/ucx-exchange/tests/UcxTestData.h
@@ -0,0 +1,354 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cudf/column/column.hpp>
+#include <cudf/table/table.hpp>
+#include <rmm/cuda_stream_view.hpp>
+#include <stddef.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+#include "velox/type/Type.h"
+
+namespace facebook::velox::ucx_exchange {
+
+/// @brief Enum to identify different table types for testing
+enum class TableType {
+  NARROW, // Original UcxTestData structure (INT32, FLOAT64, VARCHAR)
+  WIDE, // Numeric types only (no STRING or STRUCT)
+  WIDE_COMPLEX // All cudf data types including STRING and STRUCT
+};
+
+/// @brief Abstract base class for generating test tables with cudf data.
+/// Provides common helper methods for creating cudf columns and tables.
+class BaseTableGenerator {
+ public:
+  // Make a constant to avoid too many variables
+  static const int STRING_LENGTH = 4;
+
+  BaseTableGenerator() = default;
+  virtual ~BaseTableGenerator() = default;
+
+  /// @brief Initialize the test data with the specified number of rows.
+  virtual void initialize(size_t numRows) = 0;
+
+  /// @brief Get the row type for this table generator.
+  virtual facebook::velox::RowTypePtr getRowType() const = 0;
+
+  /// @brief Get the number of rows in the generated data.
+  virtual size_t getNumRows() const = 0;
+
+  /// @brief Create a cudf table from the generated data.
+  /// @param stream The CUDA stream to use.
+  /// @return A unique pointer to the created cudf table.
+  virtual std::unique_ptr<cudf::table> makeTable(
+      rmm::cuda_stream_view stream) = 0;
+
+  /// @brief Verify that the received table matches the generated data.
+  /// @param table The table to verify.
+  /// @param startRow The starting row index in the generated data.
+  /// @param numRows The number of rows to verify.
+  /// @param stream The CUDA stream to use.
+  /// @return True if the data matches, false otherwise.
+  virtual bool verifyTable(
+      const cudf::table_view& table,
+      size_t startRow,
+      size_t numRows,
+      rmm::cuda_stream_view stream) = 0;
+
+  // ----- Helper methods for creating cudf columns -----
+
+  /// @brief Generate a random string of the specified length.
+  static std::string genRandomStr(size_t len);
+
+  /// @brief Create a numeric column from a vector of values.
+  template <typename T>
+  static std::unique_ptr<cudf::column> makeNumericColumn(
+      const std::vector<T>& hostValues,
+      rmm::cuda_stream_view stream);
+
+  /// @brief Create a strings column from a vector of host strings.
+  static std::unique_ptr<cudf::column> makeStringsColumn(
+      const std::vector<std::string>& hostStrings);
+
+  /// @brief Create a struct column from child columns.
+  static std::unique_ptr<cudf::column> makeStructColumn(
+      std::vector<std::unique_ptr<cudf::column>> children,
+      cudf::size_type numRows);
+
+  /// @brief Retrieve values from a numeric column to host memory.
+  template <typename T>
+  static std::vector<T> getColVector(
+      const cudf::column_view& columnView,
+      cudf::size_type maxRows,
+      rmm::cuda_stream_view stream);
+
+  /// @brief Retrieve strings from a strings column to host memory.
+  static std::vector<std::string> getStringCol(
+      const cudf::column_view& columnView,
+      cudf::size_type maxRows,
+      rmm::cuda_stream_view stream);
+};
+
+/// @brief Original test data structure with narrow schema (INT32, FLOAT64,
+/// VARCHAR). Preserves compatibility with existing tests.
+class UcxTestData : public BaseTableGenerator {
+ public:
+  inline static const std::vector<std::string> kTestColumnNames = {
+      "c0",
+      "c1",
+      "c2"};
+  inline const static std::vector<TypePtr> kTestColumnTypes = {
+      INTEGER(),
+      DOUBLE(),
+      VARCHAR()};
+  inline const static facebook::velox::RowTypePtr kTestRowType =
+      ROW(kTestColumnNames, kTestColumnTypes);
+
+  UcxTestData() = default;
+
+  void initialize(size_t numRows) override {
+    initialize(numRows, STRING_LENGTH, STRING_LENGTH);
+  }
+
+  void
+  initialize(size_t numRows, size_t minStringLength, size_t maxStringLength);
+
+  facebook::velox::RowTypePtr getRowType() const override {
+    return kTestRowType;
+  }
+
+  size_t getNumRows() const override {
+    return numRows_;
+  }
+
+  std::unique_ptr<cudf::table> makeTable(rmm::cuda_stream_view stream) override;
+
+  bool verifyTable(
+      const cudf::table_view& table,
+      size_t startRow,
+      size_t numRows,
+      rmm::cuda_stream_view stream) override;
+
+  // Legacy accessors for backward compatibility with existing tests
+  std::shared_ptr<std::vector<std::string>> getStrings() {
+    return strings_;
+  }
+
+  std::shared_ptr<std::vector<uint32_t>> getIntegers() {
+    return integers_;
+  }
+
+  std::shared_ptr<std::vector<float>> getFloats() {
+    return floats_;
+  }
+
+  /// @brief Sets the data directly (used for creating partitioned test data).
+  void setData(
+      std::shared_ptr<std::vector<uint32_t>> integers,
+      std::shared_ptr<std::vector<float>> floats,
+      std::shared_ptr<std::vector<std::string>> strings) {
+    integers_ = std::move(integers);
+    floats_ = std::move(floats);
+    strings_ = std::move(strings);
+    numRows_ = integers_->size();
+  }
+
+ protected:
+  std::shared_ptr<std::vector<std::string>> strings_;
+  std::shared_ptr<std::vector<uint32_t>> integers_;
+  std::shared_ptr<std::vector<float>> floats_;
+  size_t numRows_ = 0;
+};
+
+/// @brief Wide table generator with numeric cudf data types only.
+/// Used to test that numeric column types transfer correctly through the
+/// exchange. Does NOT include STRING or STRUCT columns - use
+/// WideComplexTestTable for those.
+class WideTestTable : public BaseTableGenerator {
+ public:
+  // Column names for the wide table (numeric types only)
+  inline static const std::vector<std::string> kColumnNames = {
+      "int8_col", // INT8
+      "int16_col", // INT16
+      "int32_col", // INT32
+      "int64_col", // INT64
+      "uint8_col", // UINT8
+      "uint16_col", // UINT16
+      "uint32_col", // UINT32
+      "uint64_col", // UINT64
+      "float32_col", // FLOAT32
+      "float64_col", // FLOAT64
+      "bool_col" // BOOL8
+  };
+
+  // Column types for Velox (numeric types only)
+  inline static const std::vector<TypePtr> kColumnTypes = {
+      TINYINT(), // INT8
+      SMALLINT(), // INT16
+      INTEGER(), // INT32
+      BIGINT(), // INT64
+      TINYINT(), // UINT8 (mapped to TINYINT)
+      SMALLINT(), // UINT16 (mapped to SMALLINT)
+      INTEGER(), // UINT32 (mapped to INTEGER)
+      BIGINT(), // UINT64 (mapped to BIGINT)
+      REAL(), // FLOAT32
+      DOUBLE(), // FLOAT64
+      BOOLEAN()}; // BOOL8
+
+  inline static const facebook::velox::RowTypePtr kRowType =
+      ROW(kColumnNames, kColumnTypes);
+
+  WideTestTable() = default;
+
+  void initialize(size_t numRows) override;
+
+  facebook::velox::RowTypePtr getRowType() const override {
+    return kRowType;
+  }
+
+  size_t getNumRows() const override {
+    return numRows_;
+  }
+
+  std::unique_ptr<cudf::table> makeTable(rmm::cuda_stream_view stream) override;
+
+  bool verifyTable(
+      const cudf::table_view& table,
+      size_t startRow,
+      size_t numRows,
+      rmm::cuda_stream_view stream) override;
+
+ protected:
+  /// @brief Helper to add numeric columns to a column vector.
+  /// Can be used by derived classes to build tables with additional columns.
+  void addNumericColumns(
+      std::vector<std::unique_ptr<cudf::column>>& columns,
+      rmm::cuda_stream_view stream);
+
+  /// @brief Helper to verify numeric columns in a table.
+  /// @param table The table view to verify.
+  /// @param startRow Starting row in the reference data.
+  /// @param numRows Number of rows to verify.
+  /// @param stream CUDA stream.
+  /// @return True if all numeric columns match, false otherwise.
+  bool verifyNumericColumns(
+      const cudf::table_view& table,
+      size_t startRow,
+      size_t numRows,
+      rmm::cuda_stream_view stream);
+
+  // Data storage for numeric column types
+  std::vector<int8_t> int8Data_;
+  std::vector<int16_t> int16Data_;
+  std::vector<int32_t> int32Data_;
+  std::vector<int64_t> int64Data_;
+  std::vector<uint8_t> uint8Data_;
+  std::vector<uint16_t> uint16Data_;
+  std::vector<uint32_t> uint32Data_;
+  std::vector<uint64_t> uint64Data_;
+  std::vector<float> float32Data_;
+  std::vector<double> float64Data_;
+  std::vector<int8_t> boolData_; // stored as int8_t for BOOL8
+
+  size_t numRows_ = 0;
+};
+
+/// @brief Wide table generator that extends WideTestTable with STRING and
+/// STRUCT columns. Used to test that all column types including complex types
+/// transfer correctly.
+class WideComplexTestTable : public WideTestTable {
+ public:
+  // Column names: base numeric columns + string + struct
+  inline static const std::vector<std::string> kColumnNames = {
+      "int8_col", // INT8
+      "int16_col", // INT16
+      "int32_col", // INT32
+      "int64_col", // INT64
+      "uint8_col", // UINT8
+      "uint16_col", // UINT16
+      "uint32_col", // UINT32
+      "uint64_col", // UINT64
+      "float32_col", // FLOAT32
+      "float64_col", // FLOAT64
+      "bool_col", // BOOL8
+      "string_col", // STRING
+      "struct_col" // STRUCT<int64, float64>
+  };
+
+  // Column types for Velox: base numeric types + string + struct
+  inline static const std::vector<TypePtr> kColumnTypes = {
+      TINYINT(), // INT8
+      SMALLINT(), // INT16
+      INTEGER(), // INT32
+      BIGINT(), // INT64
+      TINYINT(), // UINT8 (mapped to TINYINT)
+      SMALLINT(), // UINT16 (mapped to SMALLINT)
+      INTEGER(), // UINT32 (mapped to INTEGER)
+      BIGINT(), // UINT64 (mapped to BIGINT)
+      REAL(), // FLOAT32
+      DOUBLE(), // FLOAT64
+      BOOLEAN(), // BOOL8
+      VARCHAR(), // STRING
+      ROW({"field1", "field2"}, // STRUCT
+          {BIGINT(), DOUBLE()})};
+
+  inline static const facebook::velox::RowTypePtr kRowType =
+      ROW(kColumnNames, kColumnTypes);
+
+  WideComplexTestTable() = default;
+
+  void initialize(size_t numRows) override;
+
+  facebook::velox::RowTypePtr getRowType() const override {
+    return kRowType;
+  }
+
+  std::unique_ptr<cudf::table> makeTable(rmm::cuda_stream_view stream) override;
+
+  bool verifyTable(
+      const cudf::table_view& table,
+      size_t startRow,
+      size_t numRows,
+      rmm::cuda_stream_view stream) override;
+
+ protected:
+  // Additional data storage for complex column types
+  std::vector<std::string> stringData_;
+  // Struct children data
+  std::vector<int64_t> structField1Data_;
+  std::vector<double> structField2Data_;
+};
+
+/// @brief Factory function to create a table generator based on TableType.
+inline std::shared_ptr<BaseTableGenerator> createTableGenerator(
+    TableType type) {
+  switch (type) {
+    case TableType::NARROW:
+      return std::make_shared<UcxTestData>();
+    case TableType::WIDE:
+      return std::make_shared<WideTestTable>();
+    case TableType::WIDE_COMPLEX:
+      return std::make_shared<WideComplexTestTable>();
+    default:
+      return std::make_shared<UcxTestData>();
+  }
+}
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/tests/UcxTestHelpers.cpp b/velox/experimental/ucx-exchange/tests/UcxTestHelpers.cpp
new file mode 100644
index 00000000000..86927c46223
--- /dev/null
+++ b/velox/experimental/ucx-exchange/tests/UcxTestHelpers.cpp
@@ -0,0 +1,348 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/experimental/ucx-exchange/tests/UcxTestHelpers.h"
+
+#include <cudf/column/column.hpp>
+#include <cudf/column/column_factories.hpp>
+#include <cudf/strings/detail/utilities.hpp>
+#include <cudf/strings/strings_column_view.hpp>
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::core;
+
+namespace facebook::velox::ucx_exchange {
+
+std::shared_ptr<Task> createSourceTask(
+    std::string_view taskId,
+    std::shared_ptr<memory::MemoryPool> pool,
+    RowTypePtr rowType,
+    uint64_t kMaxOutputBufferSize) {
+  VLOG(3) << "Testing SourceTask";
+  const size_t vectorSize = 10;
+
+  auto typeParams = rowType->parameters();
+  std::vector<VectorPtr> vecPtrs;
+  for (auto& typeParam : typeParams) {
+    vecPtrs.emplace_back(
+        BaseVector::create(typeParam.type, vectorSize, pool.get()));
+  }
+
+  // Wrap the vector (column) in a RowVector.
+  auto rowVector = std::make_shared<RowVector>(
+      pool.get(), // pool where allocations will be made.
+      rowType, // input row type.
+      BufferPtr(nullptr), // no nulls on this example.
+      vectorSize, // length of the vectors.
+      vecPtrs); // the input vector data.
+
+  auto planFragment =
+      exec::test::PlanBuilder().values({rowVector}).planFragment();
+
+  std::shared_ptr<folly::Executor> executor(
+      std::make_shared<folly::CPUThreadPoolExecutor>(
+          std::thread::hardware_concurrency()));
+
+  std::unordered_map<std::string, std::string> configSettings{
+      {velox::core::QueryConfig::kMaxOutputBufferSize,
+       std::to_string(kMaxOutputBufferSize)}};
+
+  auto queryCtx = core::QueryCtx::create(
+      executor.get(), core::QueryConfig(std::move(configSettings)));
+
+  auto task = Task::create(
+      std::string{taskId},
+      std::move(planFragment),
+      0, // partition number, irrelevant here; will be set by the test.
+      std::move(queryCtx),
+      Task::ExecutionMode::kParallel);
+
+  return task;
+}
+
+std::shared_ptr<facebook::velox::exec::Task> createExchangeTask(
+    std::string_view taskId,
+    facebook::velox::RowTypePtr rowType,
+    int partitionId,
+    core::PlanNodeId& exchangeNodeId) {
+  auto planFragment =
+      exec::test::PlanBuilder()
+          .exchange(
+              rowType, VectorSerde::kindName(VectorSerde::Kind::kCompactRow))
+          .capturePlanNodeId(exchangeNodeId)
+          .planFragment();
+
+  std::unordered_map<std::string, std::string> configSettings;
+  auto queryCtx = core::QueryCtx::create(
+      nullptr, core::QueryConfig(std::move(configSettings)));
+
+  auto task = Task::create(
+      std::string{taskId},
+      std::move(planFragment),
+      partitionId,
+      std::move(queryCtx),
+      Task::ExecutionMode::kParallel);
+  return task;
+}
+
+std::shared_ptr<Task> createPartitionedOutputTask(
+    std::string_view taskId,
+    std::shared_ptr<memory::MemoryPool> pool,
+    RowTypePtr rowType,
+    int numPartitions,
+    const std::vector<std::string>& partitionKeys,
+    uint64_t kMaxOutputBufferSize,
+    const std::unordered_map<std::string, std::string>& extraConfig) {
+  VLOG(3) << "Creating PartitionedOutput task with " << numPartitions
+          << " partitions";
+
+  const size_t vectorSize = 10;
+
+  // Create a dummy row vector for the Values node (required by PlanBuilder)
+  auto typeParams = rowType->parameters();
+  std::vector<VectorPtr> vecPtrs;
+  for (auto& typeParam : typeParams) {
+    vecPtrs.emplace_back(
+        BaseVector::create(typeParam.type, vectorSize, pool.get()));
+  }
+
+  auto rowVector = std::make_shared<RowVector>(
+      pool.get(), rowType, BufferPtr(nullptr), vectorSize, vecPtrs);
+
+  // Build the plan: Values -> PartitionedOutput
+  auto planFragment = exec::test::PlanBuilder()
+                          .values({rowVector})
+                          .partitionedOutput(partitionKeys, numPartitions)
+                          .planFragment();
+
+  std::shared_ptr<folly::Executor> executor(
+      std::make_shared<folly::CPUThreadPoolExecutor>(
+          std::thread::hardware_concurrency()));
+
+  std::unordered_map<std::string, std::string> configSettings{
+      {velox::core::QueryConfig::kMaxOutputBufferSize,
+       std::to_string(kMaxOutputBufferSize)}};
+  configSettings.insert(extraConfig.begin(), extraConfig.end());
+
+  auto queryCtx = core::QueryCtx::create(
+      executor.get(), core::QueryConfig(std::move(configSettings)));
+
+  auto task = Task::create(
+      std::string{taskId},
+      std::move(planFragment),
+      0, // partition number
+      std::move(queryCtx),
+      Task::ExecutionMode::kParallel);
+
+  return task;
+}
+
+std::shared_ptr<cudf_velox::CudfVector> makeCudfVector(
+    memory::MemoryPool* pool,
+    size_t numRows,
+    RowTypePtr rowType,
+    std::shared_ptr<BaseTableGenerator> tableGenerator,
+    rmm::cuda_stream_view stream) {
+  // Create table using either makeTable or tableGenerator->makeTable()
+  std::unique_ptr<cudf::table> table;
+  if (tableGenerator == nullptr) {
+    table = makeTable(numRows, rowType, stream);
+  } else {
+    table = tableGenerator->makeTable(stream);
+  }
+
+  // Sync the stream before creating CudfVector
+  stream.synchronize();
+
+  // Create and return CudfVector
+  return std::make_shared<cudf_velox::CudfVector>(
+      pool,
+      rowType,
+      static_cast<vector_size_t>(numRows),
+      std::move(table),
+      stream);
+}
+
+template <typename T>
+std::unique_ptr<cudf::column> make_numeric_column_from_vector(
+    const std::vector<T>& host_values,
+    rmm::cuda_stream_view stream = cudf::get_default_stream(),
+    rmm::mr::device_memory_resource* mr =
+        rmm::mr::get_current_device_resource()) {
+  size_t num_rows = host_values.size();
+
+  // Allocate a device buffer of the correct size
+  rmm::device_buffer data(num_rows * sizeof(T), stream, mr);
+
+  // Copy host -> device
+  cudaMemcpyAsync(
+      data.data(),
+      host_values.data(),
+      num_rows * sizeof(T),
+      cudaMemcpyHostToDevice,
+      stream.value());
+
+  // Build the cudf::column from the device buffer
+  return std::make_unique<cudf::column>(
+      cudf::data_type{cudf::type_to_id<T>()}, // e.g. cudf::type_id::FLOAT64
+      num_rows,
+      std::move(data),
+      rmm::device_buffer{}, // no null mask
+      0); // no nulls
+}
+
+// Creates device buffer with concatenated string bytes from host vector
+rmm::device_buffer make_chars_buffer_from_host(
+    const std::vector<std::string>& host_strings,
+    rmm::cuda_stream_view stream = cudf::get_default_stream(),
+    rmm::mr::device_memory_resource* mr =
+        rmm::mr::get_current_device_resource()) {
+  // Compute total bytes needed
+  size_t total_bytes = 0;
+  for (auto const& s : host_strings)
+    total_bytes += s.size();
+
+  // Allocate device buffer of appropriate size
+  rmm::device_buffer chars_buffer(total_bytes, stream, mr);
+
+  // Copy host string data into one contiguous host buffer first
+  std::vector<char> host_concat;
+  host_concat.reserve(total_bytes);
+  for (auto const& s : host_strings)
+    host_concat.insert(host_concat.end(), s.begin(), s.end());
+
+  // Copy host -> device
+  cudaMemcpyAsync(
+      chars_buffer.data(),
+      host_concat.data(),
+      total_bytes,
+      cudaMemcpyHostToDevice,
+      stream.value());
+
+  return chars_buffer;
+}
+
+std::unique_ptr<cudf::column> make_strings_column_from_host(
+    const std::vector<std::string>& host_strings) {
+  auto num_rows = host_strings.size();
+
+  // --- Create offsets array ---
+  std::vector<int32_t> h_offsets(num_rows + 1);
+  h_offsets[0] = 0;
+  for (size_t i = 0; i < num_rows; ++i)
+    h_offsets[i + 1] =
+        h_offsets[i] + static_cast<int32_t>(host_strings[i].size());
+
+  // Copy offsets to device
+  auto offsets_col = cudf::make_numeric_column(
+      cudf::data_type{cudf::type_id::INT32},
+      num_rows + 1,
+      cudf::mask_state::UNALLOCATED);
+
+  cudaMemcpy(
+      offsets_col->mutable_view().data<int32_t>(),
+      h_offsets.data(),
+      sizeof(int32_t) * (num_rows + 1),
+      cudaMemcpyHostToDevice);
+
+  // --- Create chars buffer ---
+  auto chars_buffer = make_chars_buffer_from_host(host_strings);
+
+  // --- Build strings column ---
+  return cudf::make_strings_column(
+      num_rows,
+      std::move(offsets_col),
+      std::move(chars_buffer),
+      0, // null_count
+      rmm::device_buffer{}); // null mask
+}
+
+std::unique_ptr<cudf::table> makeTable(
+    std::size_t numRows,
+    facebook::velox::RowTypePtr rowType,
+    rmm::cuda_stream_view stream) {
+  // Create table with default values
+  std::vector<std::unique_ptr<cudf::column>> columns;
+
+  for (size_t i = 0; i < rowType->size(); ++i) {
+    const std::string& name = rowType->nameOf(i);
+    const auto& type = rowType->childAt(i);
+
+    cudf::type_id cudfType;
+    std::unique_ptr<cudf::column> col;
+
+    switch (type->kind()) {
+      case TypeKind::INTEGER: {
+        cudfType = cudf::type_id::INT32;
+        std::vector<uint32_t> values(numRows);
+        col = make_numeric_column_from_vector(values);
+        break;
+      }
+      case TypeKind::DOUBLE: {
+        cudfType = cudf::type_id::FLOAT64;
+        std::vector<float> values(numRows);
+        col = make_numeric_column_from_vector(values);
+
+        break;
+      }
+      case TypeKind::VARCHAR: {
+        std::vector<std::string> myStrings(numRows);
+        col = make_strings_column_from_host(myStrings);
+        break;
+      }
+      default:
+        VLOG(0) << "Unhandled type " << type->kind();
+        break;
+    }
+
+    columns.push_back(std::move(col));
+  }
+
+  return std::make_unique<cudf::table>(std::move(columns));
+}
+
+std::vector<std::string> getStringCol(
+    const cudf::strings_column_view& str_column_view,
+    cudf::size_type max_rows,
+    rmm::cuda_stream_view stream) {
+  max_rows =
+      str_column_view.size() < max_rows ? str_column_view.size() : max_rows;
+  auto offset_view = str_column_view.offsets();
+  const cudf::size_type* ptr_offsets_data =
+      offset_view.template data<cudf::size_type>();
+  auto const h_offsets = cudf::detail::make_host_vector_async(
+      cudf::device_span<cudf::size_type const>(ptr_offsets_data, max_rows + 1),
+      stream);
+  const cudf::size_type* host_offsets = h_offsets.data();
+
+  auto const total_num_bytes = std::distance(
+      str_column_view.chars_begin(stream), str_column_view.chars_end(stream));
+  char const* ptr_all_bytes = str_column_view.chars_begin(stream);
+  // copy the bytes to host
+  auto const h_bytes = cudf::detail::make_host_vector_async(
+      cudf::device_span<char const>(ptr_all_bytes, total_num_bytes), stream);
+  const char* str_ptr = h_bytes.data();
+
+  std::vector<std::string> str_vec;
+  for (cudf::size_type i = 0; i < max_rows; ++i) {
+    std::string str(str_ptr + host_offsets[i], str_ptr + host_offsets[i + 1]);
+    str_vec.push_back(str);
+  }
+  return str_vec; // rely on the compiler's Return-Value-Optimization to avoid a
+                  // vector copy.
+}
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/ucx-exchange/tests/UcxTestHelpers.h b/velox/experimental/ucx-exchange/tests/UcxTestHelpers.h
new file mode 100644
index 00000000000..329f1ac4382
--- /dev/null
+++ b/velox/experimental/ucx-exchange/tests/UcxTestHelpers.h
@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cudf/column/column_factories.hpp>
+#include <cudf/contiguous_split.hpp>
+#include <cudf/table/table.hpp>
+#include <cudf/types.hpp>
+#include <folly/Executor.h>
+#include <memory>
+#include <string_view>
+#include <vector>
+#include "velox/common/memory/MemoryPool.h"
+#include "velox/core/QueryCtx.h"
+#include "velox/exec/Task.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/experimental/cudf/vector/CudfVector.h"
+#include "velox/experimental/ucx-exchange/tests/UcxTestData.h"
+
+#include <cudf/binaryop.hpp>
+#include <cudf/strings/strings_column_view.hpp>
+
+namespace facebook::velox::ucx_exchange {
+
+static const uint64_t FOUR_GBYTES = 4294967296;
+
+/*const std::vector<std::string> kTestColumnNames = {"c0", "c1","c2"};
+const std::vector<TypePtr> kTestColumnTypes = {INTEGER(), DOUBLE(),VARCHAR()};
+const facebook::velox::RowTypePtr kTestRowType =
+    ROW(kTestColumnNames, kTestColumnTypes);*/
+
+/// @brief Helper function to create a source Task for testing purposes.
+/// Creates a simple task associated with a plan fragment that consists of a
+/// single value node. The output type is the given row type. Memory pool is
+/// only needed to initialize a value node in the plan fragment.
+///
+/// @param taskId The unique identifier for the task
+/// @param pool Shared pointer to the memory pool to use by the value source
+/// node.
+/// @param rowType The row type to use for the task
+/// @return Shared pointer to the created Task
+std::shared_ptr<facebook::velox::exec::Task> createSourceTask(
+    std::string_view taskId,
+    std::shared_ptr<facebook::velox::memory::MemoryPool> pool,
+    facebook::velox::RowTypePtr rowType,
+    uint64_t kMaxOutputBufferSize = FOUR_GBYTES);
+
+/// @brief Helper function to create a sink task for testing.
+/// Creates a simple task associated with a plan fragment that consists fo a
+/// single exchange node. The input type is the given row type.
+/// @param taskId The unique identifier for the task
+/// @param rowType The row type to use for the task
+/// @param partitionId The partition that this task is retrieving from upstream
+/// task(s).
+/// @param exchangeNodeId Reference parameter that returns the id of the
+/// exchange node in this task's plan fragment.
+/// @return Shared pointer to the created Task
+std::shared_ptr<facebook::velox::exec::Task> createExchangeTask(
+    std::string_view taskId,
+    facebook::velox::RowTypePtr rowType,
+    int partitionId,
+    core::PlanNodeId& exchangeNodeId);
+
+/// @brief Helper function to create a source task with PartitionedOutput for
+/// testing. Creates a task with a plan fragment: Values -> PartitionedOutput.
+/// This is used by SourceDriverMock to drive real UcxPartitionedOutput
+/// operators.
+/// @param taskId The unique identifier for the task
+/// @param pool Shared pointer to the memory pool
+/// @param rowType The row type to use for the task
+/// @param numPartitions The number of output partitions
+/// @param partitionKeys The keys to use for hash partitioning (empty for
+/// round-robin)
+/// @param kMaxOutputBufferSize Maximum output buffer size
+/// @return Shared pointer to the created Task
+std::shared_ptr<facebook::velox::exec::Task> createPartitionedOutputTask(
+    std::string_view taskId,
+    std::shared_ptr<facebook::velox::memory::MemoryPool> pool,
+    facebook::velox::RowTypePtr rowType,
+    int numPartitions,
+    const std::vector<std::string>& partitionKeys = {},
+    uint64_t kMaxOutputBufferSize = FOUR_GBYTES,
+    const std::unordered_map<std::string, std::string>& extraConfig = {});
+
+/// @brief Helper function to create a CudfVector for testing.
+/// Uses makeTable when tableGenerator is null, or tableGenerator->makeTable()
+/// when provided.
+/// @param pool The memory pool to use for the CudfVector
+/// @param numRows Number of rows to create
+/// @param rowType The row type for the vector
+/// @param tableGenerator Optional table generator to create the table data
+/// @param stream The CUDA stream to use
+/// @return Shared pointer to the created CudfVector
+std::shared_ptr<facebook::velox::cudf_velox::CudfVector> makeCudfVector(
+    facebook::velox::memory::MemoryPool* pool,
+    size_t numRows,
+    facebook::velox::RowTypePtr rowType,
+    std::shared_ptr<BaseTableGenerator> tableGenerator,
+    rmm::cuda_stream_view stream);
+
+/// Helper function to create cudf::table for testing.
+/// Creates a table with columns based on the given rowType.
+///
+/// @param numRows Number of rows to create in the table
+/// @param rowType The row type specifying the columns
+/// @param stream The CUDA stream to use
+/// @return Unique pointer to the created table
+///
+std::unique_ptr<cudf::table> makeTable(
+    std::size_t numRows,
+    facebook::velox::RowTypePtr rowType,
+    rmm::cuda_stream_view stream);
+
+/// @brief testing utility for dumping the contents of a string column.
+/// @param str_column_view The string column view to be dumped.
+/// @param stream The cuda stream.
+std::vector<std::string> getStringCol(
+    const cudf::strings_column_view& str_column_view,
+    cudf::size_type max_rows,
+    rmm::cuda_stream_view stream);
+
+/// @brief Helper function to create a strings column from a vector of host
+/// strings.
+/// @param host_strings The vector of strings to use for creating the column.
+/// @return A unique pointer to the created strings column.
+std::unique_ptr<cudf::column> make_strings_column_from_host(
+    const std::vector<std::string>& host_strings);
+
+/// @brief Template function for retrieving the contents of a fixed-size column.
+/// @param column_view The column view to be dumped.
+/// @param max_rows The maximum number of rows to be retrieved.
+/// @param stream The cude stream.
+
+template <typename T>
+std::vector<T> getColVector(
+    const cudf::column_view& column_view,
+    cudf::size_type max_rows,
+    rmm::cuda_stream_view stream) {
+  max_rows = column_view.size() < max_rows ? column_view.size() : max_rows;
+  const T* ptr_data = column_view.template data<T>();
+  auto host_vec = cudf::detail::make_host_vector_async(
+      cudf::device_span<T const>(ptr_data, max_rows), stream);
+  std::vector<T> vec(max_rows);
+  std::copy(host_vec.begin(), host_vec.end(), vec.begin());
+  return vec;
+}
+
+} // namespace facebook::velox::ucx_exchange
diff --git a/velox/experimental/wave/common/CMakeLists.txt b/velox/experimental/wave/common/CMakeLists.txt
index 04dbb708224..b6b16f224ac 100644
--- a/velox/experimental/wave/common/CMakeLists.txt
+++ b/velox/experimental/wave/common/CMakeLists.txt
@@ -20,10 +20,13 @@ add_library(
   Cuda.cu
   Exception.cpp
   KernelCache.cpp
+  KernelFsCache.cpp
   Type.cpp
   ResultStaging.cpp
 )
 
+target_compile_options(velox_wave_common PRIVATE ${VELOX_CUDA_DEBUG_FLAGS})
+
 target_link_libraries(
   velox_wave_common
   velox_exception
diff --git a/velox/experimental/wave/common/Compile.cu b/velox/experimental/wave/common/Compile.cu
index b07f55c95af..128a425e41c 100644
--- a/velox/experimental/wave/common/Compile.cu
+++ b/velox/experimental/wave/common/Compile.cu
@@ -17,6 +17,7 @@
 #include <fmt/format.h>
 #include <gflags/gflags.h>
 #include <nvrtc.h>
+#include <chrono>
 #include "velox/experimental/wave/common/Cuda.h"
 #include "velox/experimental/wave/common/CudaUtil.cuh"
 #include "velox/experimental/wave/common/Exception.h"
@@ -38,6 +39,8 @@ DEFINE_int32(
     ,
     "-O level for NVRTC");
 
+DEFINE_bool(cuda_ptx, false, "Compile to ptx instead of cubin");
+
 #ifndef VELOX_OSS_BUILD
 #include "velox/facebook/NvrtcUtil.h"
 #endif
@@ -52,8 +55,11 @@ void nvrtcCheck(nvrtcResult result) {
 
 class CompiledModuleImpl : public CompiledModule {
  public:
-  CompiledModuleImpl(CUmodule module, std::vector<CUfunction> kernels)
-      : module_(module), kernels_(std::move(kernels)) {}
+  CompiledModuleImpl(
+      CUmodule module,
+      std::vector<CUfunction> kernels,
+      int64_t compileMs)
+      : module_(module), kernels_(std::move(kernels)), compileMs_(compileMs) {}
 
   ~CompiledModuleImpl() {
     auto result = cuModuleUnload(module_);
@@ -70,11 +76,20 @@ class CompiledModuleImpl : public CompiledModule {
       Stream* stream,
       void** args) override;
 
+  void launchCooperative(
+      int32_t kernelIdx,
+      int32_t numBlocks,
+      int32_t numThreads,
+      int32_t shared,
+      Stream* stream,
+      void** args) override;
+
   KernelInfo info(int32_t kernelIdx) override;
 
  private:
   CUmodule module_;
   std::vector<CUfunction> kernels_;
+  int64_t compileMs_;
 };
 
 namespace {
@@ -164,8 +179,9 @@ void saveSystemHeaders(std::map<std::string, std::string>& map) {
         << pair.second;
   }
   out.close();
-  system(fmt::format(" mv /tmp/h.{} /tmp/wavesystemheaders.txt", getpid())
-             .c_str());
+  system(
+      fmt::format(" mv /tmp/h.{} /tmp/wavesystemheaders.txt", getpid())
+          .c_str());
 }
 
 // Adds a trailing zero to make the string.data() a C char*.
@@ -253,8 +269,10 @@ void ensureInit() {
     }
   }
   if (!hasArch) {
-    waveNvrtcFlags.push_back(fmt::format(
-        "--gpu-architecture=compute_{}{}", device->major, device->minor));
+    std::string arch = FLAGS_cuda_ptx ? "compute" : "sm";
+    waveNvrtcFlags.push_back(
+        fmt::format(
+            "--gpu-architecture={}_{}{}", arch, device->major, device->minor));
   }
   ::jitify::detail::detect_and_add_cuda_arch(waveNvrtcFlags);
   std::map<std::string, std::string> headers;
@@ -286,7 +304,7 @@ void CompiledModule::initialize() {
   ensureInit();
 }
 
-std::shared_ptr<CompiledModule> CompiledModule::create(const KernelSpec& spec) {
+std::shared_ptr<CompiledModule> CompiledModule::create(KernelSpec& spec) {
   ensureInit();
   const char** headers = waveHeaderTextString.data();
   const char** headerNames = waveHeaderNameString.data();
@@ -306,6 +324,14 @@ std::shared_ptr<CompiledModule> CompiledModule::create(const KernelSpec& spec) {
     numHeaders += spec.numHeaders;
   }
   nvrtcProgram prog;
+  std::string entryNames;
+  for (auto& name : spec.entryPoints) {
+    if (!entryNames.empty()) {
+      entryNames += ", ";
+    }
+    entryNames += name;
+  }
+  auto nvrtcStart = std::chrono::steady_clock::now();
   nvrtcCreateProgram(
       &prog,
       spec.code.c_str(), // buffer
@@ -331,20 +357,51 @@ std::shared_ptr<CompiledModule> CompiledModule::create(const KernelSpec& spec) {
 
   if (compileResult != NVRTC_SUCCESS) {
     nvrtcDestroyProgram(&prog);
-    waveError(std::string("Cuda compilation error: ") + log);
+    auto errorMs = std::chrono::duration_cast<std::chrono::milliseconds>(
+                       std::chrono::steady_clock::now() - nvrtcStart)
+                       .count();
+    waveError(fmt::format("Cuda compilation error ({}ms): {}", errorMs, log));
+  }
+  auto elapsedMs = std::chrono::duration_cast<std::chrono::milliseconds>(
+                       std::chrono::steady_clock::now() - nvrtcStart)
+                       .count();
+  // Obtain PTX or CUBIN from the program.
+  size_t codeSize;
+  std::string code;
+  if (FLAGS_cuda_ptx) {
+    nvrtcCheck(nvrtcGetPTXSize(prog, &codeSize));
+    code.resize(codeSize);
+    nvrtcCheck(nvrtcGetPTX(prog, code.data()));
+  } else {
+    nvrtcCheck(nvrtcGetCUBINSize(prog, &codeSize));
+    code.resize(codeSize);
+    nvrtcCheck(nvrtcGetCUBIN(prog, code.data()));
   }
-  // Obtain PTX from the program.
-  size_t ptxSize;
-  nvrtcCheck(nvrtcGetPTXSize(prog, &ptxSize));
-  std::string ptx;
-  ptx.resize(ptxSize);
-  nvrtcCheck(nvrtcGetPTX(prog, ptx.data()));
   std::vector<std::string> loweredNames;
   for (auto& entry : spec.entryPoints) {
     const char* temp;
     nvrtcCheck(nvrtcGetLoweredName(prog, entry.c_str(), &temp));
     loweredNames.push_back(std::string(temp));
   }
+  spec.loweredNames = loweredNames;
+  if (!spec.cubinPath.empty()) {
+    std::string cubin;
+    if (FLAGS_cuda_ptx) {
+      size_t cubinSize;
+      nvrtcCheck(nvrtcGetCUBINSize(prog, &cubinSize));
+      cubin.resize(cubinSize);
+      nvrtcCheck(nvrtcGetCUBIN(prog, cubin.data()));
+    } else {
+      cubin = code;
+    }
+    std::ofstream out(spec.cubinPath, std::ios::binary);
+    out.write(cubin.data(), cubin.size());
+    // Write lowered names so fromCubin can resolve entry points.
+    std::ofstream namesOut(spec.cubinPath + ".names");
+    for (auto& name : loweredNames) {
+      namesOut << name << "\n";
+    }
+  }
 
   nvrtcDestroyProgram(&prog);
   CUjit_option options[] = {
@@ -360,7 +417,7 @@ std::shared_ptr<CompiledModule> CompiledModule::create(const KernelSpec& spec) {
 
   CUmodule module;
   auto loadResult = cuModuleLoadDataEx(
-      &module, ptx.data(), sizeof(values) / sizeof(void*), options, values);
+      &module, code.data(), sizeof(values) / sizeof(void*), options, values);
   if (loadResult != CUDA_SUCCESS) {
     LOG(ERROR) << "Load error " << errorSize << " " << infoSize;
     waveError(fmt::format("Error in load module: {} {}", info, error));
@@ -370,7 +427,33 @@ std::shared_ptr<CompiledModule> CompiledModule::create(const KernelSpec& spec) {
     funcs.emplace_back();
     CU_CHECK(cuModuleGetFunction(&funcs.back(), module, name.c_str()));
   }
-  return std::make_shared<CompiledModuleImpl>(module, std::move(funcs));
+  return std::make_shared<CompiledModuleImpl>(
+      module, std::move(funcs), elapsedMs);
+}
+
+// static
+std::shared_ptr<CompiledModule> CompiledModule::fromCubin(
+    const std::string& cubinPath,
+    const KernelSpec& spec) {
+  auto loadStart = std::chrono::steady_clock::now();
+  CUmodule module;
+  auto loadResult = cuModuleLoad(&module, cubinPath.c_str());
+  if (loadResult != CUDA_SUCCESS) {
+    const char* errStr;
+    cuGetErrorString(loadResult, &errStr);
+    waveError(
+        fmt::format("Error loading CUBIN from {}: {}", cubinPath, errStr));
+  }
+  std::vector<CUfunction> funcs;
+  for (auto& name : spec.loweredNames) {
+    funcs.emplace_back();
+    CU_CHECK(cuModuleGetFunction(&funcs.back(), module, name.c_str()));
+  }
+  auto elapsedMs = std::chrono::duration_cast<std::chrono::milliseconds>(
+                       std::chrono::steady_clock::now() - loadStart)
+                       .count();
+  return std::make_shared<CompiledModuleImpl>(
+      module, std::move(funcs), elapsedMs);
 }
 
 void CompiledModuleImpl::launch(
@@ -395,6 +478,27 @@ void CompiledModuleImpl::launch(
   CU_CHECK(result);
 };
 
+void CompiledModuleImpl::launchCooperative(
+    int32_t kernelIdx,
+    int32_t numBlocks,
+    int32_t numThreads,
+    int32_t shared,
+    Stream* stream,
+    void** args) {
+  auto result = cuLaunchCooperativeKernel(
+      kernels_[kernelIdx],
+      numBlocks,
+      1,
+      1, // grid dim
+      numThreads,
+      1,
+      1, // block dim
+      shared,
+      reinterpret_cast<CUstream>(stream->stream()->stream),
+      args);
+  CU_CHECK(result);
+};
+
 KernelInfo CompiledModuleImpl::info(int32_t kernelIdx) {
   KernelInfo info;
   auto f = kernels_[kernelIdx];
@@ -409,6 +513,7 @@ KernelInfo CompiledModuleImpl::info(int32_t kernelIdx) {
   info.maxOccupancy0 = max;
   cuOccupancyMaxActiveBlocksPerMultiprocessor(&max, f, 256, 256 * 32);
   info.maxOccupancy32 = max;
+  info.compileMs = compileMs_;
   return info;
 }
 
diff --git a/velox/experimental/wave/common/Cuda.cu b/velox/experimental/wave/common/Cuda.cu
index beb58f60a9b..0679c1a391f 100644
--- a/velox/experimental/wave/common/Cuda.cu
+++ b/velox/experimental/wave/common/Cuda.cu
@@ -23,6 +23,7 @@
 #include "velox/experimental/wave/common/HashTable.h"
 
 #include <assert.h>
+#include <atomic>
 #include <mutex>
 #include <sstream>
 
@@ -69,7 +70,7 @@ std::string Device::toString() const {
 
 namespace {
 std::mutex ctxMutex;
-bool driverInited = false;
+std::atomic<bool> driverInited{false};
 
 // A context for each device. Each is initialized on first use and made the
 // primary context for the device.
@@ -78,8 +79,8 @@ std::vector<CUcontext> contexts;
 std::vector<std::unique_ptr<Device>> devices;
 
 Device* setDriverDevice(int32_t deviceId) {
+  std::lock_guard<std::mutex> l(ctxMutex);
   if (!driverInited) {
-    std::lock_guard<std::mutex> l(ctxMutex);
     CU_CHECK(cuInit(0));
     int32_t cnt;
     CU_CHECK(cuDeviceGetCount(&cnt));
@@ -97,24 +98,21 @@ Device* setDriverDevice(int32_t deviceId) {
     cuCtxSetCurrent(contexts[deviceId]);
     return devices[deviceId].get();
   }
-  {
-    std::lock_guard<std::mutex> l(ctxMutex);
-    CUdevice dev;
-    CU_CHECK(cuDeviceGet(&dev, deviceId));
-    CU_CHECK(cuDevicePrimaryCtxRetain(&contexts[deviceId], dev));
-    devices[deviceId] = std::make_unique<Device>(deviceId);
-    cudaDeviceProp prop;
-    CUDA_CHECK(cudaGetDeviceProperties(&prop, deviceId));
-    auto& device = devices[deviceId];
-    device->model = prop.name;
-    device->major = prop.major;
-    device->minor = prop.minor;
-    device->globalMB = prop.totalGlobalMem >> 20;
-    device->numSM = prop.multiProcessorCount;
-    device->sharedMemPerSM = prop.sharedMemPerMultiprocessor;
-    device->L2Size = prop.l2CacheSize;
-    device->persistingL2MaxSize = prop.persistingL2CacheMaxSize;
-  }
+  CUdevice dev;
+  CU_CHECK(cuDeviceGet(&dev, deviceId));
+  CU_CHECK(cuDevicePrimaryCtxRetain(&contexts[deviceId], dev));
+  devices[deviceId] = std::make_unique<Device>(deviceId);
+  cudaDeviceProp prop;
+  CUDA_CHECK(cudaGetDeviceProperties(&prop, deviceId));
+  auto& device = devices[deviceId];
+  device->model = prop.name;
+  device->major = prop.major;
+  device->minor = prop.minor;
+  device->globalMB = prop.totalGlobalMem >> 20;
+  device->numSM = prop.multiProcessorCount;
+  device->sharedMemPerSM = prop.sharedMemPerMultiprocessor;
+  device->L2Size = prop.l2CacheSize;
+  device->persistingL2MaxSize = prop.persistingL2CacheMaxSize;
   CU_CHECK(cuCtxSetCurrent(contexts[deviceId]));
   return devices[deviceId].get();
 }
@@ -123,16 +121,15 @@ Device* setDriverDevice(int32_t deviceId) {
 
 Device* currentDevice() {
   CUcontext ctx;
-  CU_CHECK(cuCtxGetCurrent(&ctx));
-  if (!ctx) {
+  if (CUDA_SUCCESS != cuCtxGetCurrent(&ctx) || ctx == nullptr) {
     return nullptr;
   }
+  std::lock_guard<std::mutex> l(ctxMutex);
   for (auto i = 0; i < contexts.size(); ++i) {
     if (contexts[i] == ctx) {
       return devices[i].get();
     }
   }
-  waveError("Device context not found. Inconsistent state.");
   return nullptr;
 }
 
@@ -283,7 +280,7 @@ void Stream::deviceConstantToHostAsync(
 namespace {
 struct CallbackData {
   CallbackData(std::function<void()> callback)
-      : callback(std::move(callback)){};
+      : callback(std::move(callback)) {};
   std::function<void()> callback;
 };
 
@@ -441,7 +438,7 @@ std::string KernelInfo::toString() const {
   out << "NumRegs=" << numRegs << " maxThreadsPerBlock= " << maxThreadsPerBlock
       << " sharedMemory=" << sharedMemory << " localMemory=" << localMemory
       << " occupancy 256,  0=" << maxOccupancy0
-      << " occupancy 256,32=" << maxOccupancy32;
+      << " occupancy 256,32=" << maxOccupancy32 << " compileMs=" << compileMs;
   return out.str();
 }
 
diff --git a/velox/experimental/wave/common/Cuda.h b/velox/experimental/wave/common/Cuda.h
index 15bf9e27004..be55cd0ae14 100644
--- a/velox/experimental/wave/common/Cuda.h
+++ b/velox/experimental/wave/common/Cuda.h
@@ -240,6 +240,8 @@ struct KernelInfo {
   int32_t localMemory{0};
   int32_t maxOccupancy0{0};
   int32_t maxOccupancy32{0};
+  /// NVRTC compilation time in milliseconds.
+  int64_t compileMs{0};
 
   std::string toString() const;
 };
@@ -250,8 +252,20 @@ struct KernelSpec {
   std::vector<std::string> entryPoints;
   std::string filePath;
   int32_t numHeaders{0};
-  const char** headers;
+  const char** headers{nullptr};
   const char** headerNames{nullptr};
+  /// If non-empty, the compiled CUBIN is written to this path.
+  std::string cubinPath;
+  /// Mangled entry point names. Populated by create() after compilation.
+  /// Must be set when using fromCubinPath.
+  std::vector<std::string> loweredNames;
+  /// If non-empty, loads a pre-compiled CUBIN from this path instead of
+  /// compiling. loweredNames must be populated.
+  std::string fromCubinPath;
+  /// Called after compilation (or failure), before the kernel is added to the
+  /// cache. On success, error is nullptr and loweredNames is populated. On
+  /// failure, error holds the exception.
+  std::function<void(KernelSpec& spec, std::exception_ptr error)> postCompile;
 };
 
 /// Represents the result of compilation. Wrapped accessed through
@@ -261,8 +275,14 @@ struct CompiledModule {
 
   static void initialize();
 
-  /// Compiles 'spec' and returns the result.
-  static std::shared_ptr<CompiledModule> create(const KernelSpec& spec);
+  /// Compiles 'spec' and returns the result. Populates spec.loweredNames.
+  static std::shared_ptr<CompiledModule> create(KernelSpec& spec);
+
+  /// Loads a pre-compiled CUBIN from 'cubinPath' using the mangled entry point
+  /// names in 'spec.loweredNames'.
+  static std::shared_ptr<CompiledModule> fromCubin(
+      const std::string& cubinPath,
+      const KernelSpec& spec);
 
   virtual void launch(
       int32_t kernelIdx,
@@ -272,6 +292,16 @@ struct CompiledModule {
       Stream* stream,
       void** args) = 0;
 
+  /// Launches the kernel as a cooperative grid. All blocks are guaranteed
+  /// to be resident simultaneously.
+  virtual void launchCooperative(
+      int32_t kernelIdx,
+      int32_t numBlocks,
+      int32_t numThreads,
+      int32_t shared,
+      Stream* stream,
+      void** args) = 0;
+
   /// Returns resource utilization for 'kernelIdx'th entry point.
   virtual KernelInfo info(int32_t kernelIdx) = 0;
 };
@@ -297,6 +327,9 @@ class CompiledKernel {
       const std::string& key,
       KernelGenFunc func);
 
+  /// Clears all entries from the kernel cache.
+  static void clearCache();
+
   virtual void launch(
       int32_t idx,
       int32_t numBlocks,
@@ -305,6 +338,14 @@ class CompiledKernel {
       Stream* stream,
       void** args) = 0;
 
+  virtual void launchCooperative(
+      int32_t idx,
+      int32_t numBlocks,
+      int32_t numThreads,
+      int32_t shared,
+      Stream* stream,
+      void** args) = 0;
+
   virtual KernelInfo info(int32_t kernelIdx) = 0;
 };
 
diff --git a/velox/experimental/wave/common/HashTable.h b/velox/experimental/wave/common/HashTable.h
index 619ad10eb76..1927288cc00 100644
--- a/velox/experimental/wave/common/HashTable.h
+++ b/velox/experimental/wave/common/HashTable.h
@@ -81,7 +81,7 @@ struct AllocationRange {
         firstRowOffset(roundUp64(capacity / rowSize) / 8),
         rowOffset(firstRowOffset),
         stringOffset(capacity) {
-    ::memset(reinterpret_cast<char*>(base), 0, firstRowOffset);
+    ::memset(reinterpret_cast<uint8_t*>(base), 0, firstRowOffset);
   }
 
   AllocationRange(AllocationRange&& other) {
@@ -92,7 +92,7 @@ struct AllocationRange {
 
   void operator=(AllocationRange&& other) {
     *this = other;
-    memset(&other, 0, sizeof(AllocationRange));
+    memset(reinterpret_cast<uint8_t*>(&other), 0, sizeof(AllocationRange));
   }
 
   int64_t availableFixed() {
diff --git a/velox/experimental/wave/common/KernelCache.cpp b/velox/experimental/wave/common/KernelCache.cpp
index 7f8f6702fd9..8d6e1635cd1 100644
--- a/velox/experimental/wave/common/KernelCache.cpp
+++ b/velox/experimental/wave/common/KernelCache.cpp
@@ -16,6 +16,7 @@
 
 #include "velox/common/caching/CachedFactory.h"
 #include "velox/experimental/wave/common/Cuda.h"
+#include "velox/experimental/wave/common/Exception.h"
 
 #include <folly/executors/CPUThreadPoolExecutor.h>
 #include <folly/futures/Future.h>
@@ -47,6 +48,18 @@ class FutureCompiledModule : public CompiledModule {
     module_->launch(kernelIdx, numBlocks, numThreads, shared, stream, args);
   }
 
+  void launchCooperative(
+      int32_t kernelIdx,
+      int32_t numBlocks,
+      int32_t numThreads,
+      int32_t shared,
+      Stream* stream,
+      void** args) override {
+    ensureReady();
+    module_->launchCooperative(
+        kernelIdx, numBlocks, numThreads, shared, stream, args);
+  }
+
   KernelInfo info(int32_t kernelIdx) override {
     ensureReady();
     return module_->info(kernelIdx);
@@ -84,6 +97,17 @@ class AsyncCompiledKernel : public CompiledKernel {
     (*ptr_)->launch(kernelIdx, numBlocks, numThreads, shared, stream, args);
   }
 
+  void launchCooperative(
+      int32_t kernelIdx,
+      int32_t numBlocks,
+      int32_t numThreads,
+      int32_t shared,
+      Stream* stream,
+      void** args) override {
+    (*ptr_)->launchCooperative(
+        kernelIdx, numBlocks, numThreads, shared, stream, args);
+  }
+
   KernelInfo info(int32_t kernelIdx) override {
     return (*ptr_)->info(kernelIdx);
   }
@@ -107,7 +131,25 @@ class KernelGenerator {
     compilerExecutor()->add([genCopy = *gen, holder, device]() {
       setDevice(device);
       auto spec = genCopy();
-      auto module = CompiledModule::create(spec);
+      ModulePtr module;
+      try {
+        if (!spec.fromCubinPath.empty()) {
+          if (spec.loweredNames.empty()) {
+            waveError("loweredNames must be set when using fromCubinPath");
+          }
+          module = CompiledModule::fromCubin(spec.fromCubinPath, spec);
+        } else {
+          module = CompiledModule::create(spec);
+        }
+        if (spec.postCompile) {
+          spec.postCompile(spec, nullptr);
+        }
+      } catch (...) {
+        if (spec.postCompile) {
+          spec.postCompile(spec, std::current_exception());
+        }
+        throw;
+      }
       holder->promise.setValue(module);
     });
     ModulePtr result =
@@ -145,4 +187,9 @@ std::unique_ptr<CompiledKernel> CompiledKernel::getKernel(
   return std::make_unique<AsyncCompiledKernel>(std::move(ptr));
 }
 
+// static
+void CompiledKernel::clearCache() {
+  kernelCache().clearCache();
+}
+
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/KernelFsCache.cpp b/velox/experimental/wave/common/KernelFsCache.cpp
new file mode 100644
index 00000000000..dcd8421bebf
--- /dev/null
+++ b/velox/experimental/wave/common/KernelFsCache.cpp
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/wave/common/KernelFsCache.h"
+
+#include <fmt/format.h>
+#include <unistd.h>
+#include <chrono>
+#include <filesystem>
+#include <fstream>
+#include <functional>
+
+namespace fs = std::filesystem;
+
+namespace facebook::velox::wave {
+
+namespace {
+
+std::string readFile(const std::string& path) {
+  std::ifstream in(path);
+  if (!in.good()) {
+    return {};
+  }
+  return {std::istreambuf_iterator<char>(in), std::istreambuf_iterator<char>()};
+}
+
+std::vector<std::string> readNames(const std::string& path) {
+  std::vector<std::string> result;
+  std::ifstream in(path);
+  std::string line;
+  while (std::getline(in, line)) {
+    if (!line.empty()) {
+      result.push_back(line);
+    }
+  }
+  return result;
+}
+
+} // namespace
+
+KernelFsCache::KernelFsCache(const std::string& cacheDir)
+    : cacheDir_(cacheDir) {}
+
+std::string KernelFsCache::cuPath(int32_t ordinal) const {
+  return fmt::format("{}/{}.cu", cacheDir_, ordinal);
+}
+
+std::string KernelFsCache::cubinPath(int32_t ordinal) const {
+  return fmt::format("{}/{}.cubin", cacheDir_, ordinal);
+}
+
+std::string KernelFsCache::namesPath(int32_t ordinal) const {
+  return fmt::format("{}/{}.cubin.names", cacheDir_, ordinal);
+}
+
+void KernelFsCache::init() {
+  if (initialized_) {
+    return;
+  }
+  initialized_ = true;
+
+  if (!fs::exists(cacheDir_)) {
+    fs::create_directories(cacheDir_);
+    return;
+  }
+
+  for (auto& entry : fs::directory_iterator(cacheDir_)) {
+    if (entry.path().extension() != ".cu") {
+      continue;
+    }
+    auto stem = entry.path().stem().string();
+    int32_t ordinal;
+    try {
+      ordinal = std::stoi(stem);
+    } catch (...) {
+      continue;
+    }
+    auto cubinFile = cubinPath(ordinal);
+    auto namesFile = namesPath(ordinal);
+    if (!fs::exists(cubinFile) || fs::file_size(cubinFile) == 0 ||
+        !fs::exists(namesFile)) {
+      continue;
+    }
+    auto text = readFile(entry.path().string());
+    if (text.empty()) {
+      continue;
+    }
+    auto hash = std::hash<std::string>{}(text);
+    hashToEntries_[hash].push_back({ordinal});
+    ++numEntries_;
+    if (ordinal >= nextOrdinal_) {
+      nextOrdinal_ = ordinal + 1;
+    }
+  }
+}
+
+std::unique_ptr<CompiledKernel> KernelFsCache::getKernel(
+    const std::string& key,
+    KernelGenFunc genFunc) {
+  auto hash = std::hash<std::string>{}(key);
+  auto assignedOrdinal = std::make_shared<std::atomic<int32_t>>(-1);
+
+  auto wrappedGen = [this,
+                     keyCopy = key,
+                     hash,
+                     genFuncCopy = std::move(genFunc),
+                     assignedOrdinal]() -> KernelSpec {
+    std::unique_lock lock(mutex_);
+    init();
+
+    auto it = hashToEntries_.find(hash);
+    if (it != hashToEntries_.end()) {
+      for (auto& entry : it->second) {
+        auto text = readFile(cuPath(entry.ordinal));
+        if (text != keyCopy) {
+          continue;
+        }
+        auto cubinFilePath = cubinPath(entry.ordinal);
+        auto namesFilePath = namesPath(entry.ordinal);
+        if (!fs::exists(cubinFilePath) || fs::file_size(cubinFilePath) == 0 ||
+            !fs::exists(namesFilePath)) {
+          continue;
+        }
+        auto lowered = readNames(namesFilePath);
+        lock.unlock();
+        ++hits_;
+
+        KernelSpec loadSpec;
+        loadSpec.loweredNames = std::move(lowered);
+        loadSpec.fromCubinPath = std::move(cubinFilePath);
+        return loadSpec;
+      }
+    }
+
+    lock.unlock();
+    auto spec = genFuncCopy();
+    lock.lock();
+
+    auto ordinal = nextOrdinal_++;
+    assignedOrdinal->store(ordinal);
+    spec.cubinPath = cubinPath(ordinal);
+
+    spec.postCompile = [this, ordinal, hash, keyCopy](
+                           KernelSpec& /*compiled*/, std::exception_ptr error) {
+      std::unique_lock lock(mutex_);
+      if (error) {
+        std::error_code removeError;
+        fs::remove(cubinPath(ordinal), removeError);
+        fs::remove(cubinPath(ordinal) + ".names", removeError);
+        return;
+      }
+      {
+        std::ofstream out(cuPath(ordinal));
+        out << keyCopy;
+      }
+      hashToEntries_[hash].push_back({ordinal});
+      ++numEntries_;
+    };
+
+    ++misses_;
+    lock.unlock();
+
+    return spec;
+  };
+
+  try {
+    return CompiledKernel::getKernel(key, std::move(wrappedGen));
+  } catch (...) {
+    std::unique_lock lock(mutex_);
+    auto ordinal = assignedOrdinal->load();
+    if (ordinal >= 0) {
+      std::error_code removeError;
+      fs::remove(cuPath(ordinal), removeError);
+      fs::remove(cubinPath(ordinal), removeError);
+      fs::remove(namesPath(ordinal), removeError);
+      auto it = hashToEntries_.find(hash);
+      if (it != hashToEntries_.end()) {
+        auto& entries = it->second;
+        entries.erase(
+            std::remove_if(
+                entries.begin(),
+                entries.end(),
+                [&](const CacheEntry& entry) {
+                  return entry.ordinal == ordinal;
+                }),
+            entries.end());
+        if (entries.empty()) {
+          hashToEntries_.erase(it);
+        }
+      }
+    }
+    throw;
+  }
+}
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/KernelFsCache.h b/velox/experimental/wave/common/KernelFsCache.h
new file mode 100644
index 00000000000..6eddb4a58d3
--- /dev/null
+++ b/velox/experimental/wave/common/KernelFsCache.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <atomic>
+#include <mutex>
+#include <unordered_map>
+#include <vector>
+#include "velox/experimental/wave/common/Cuda.h"
+
+namespace facebook::velox::wave {
+
+/// Caches compiled CUDA kernels on the filesystem, keyed by source hash.
+/// Stores .cu source, .cubin binaries, and .names (mangled entry points)
+/// in a directory. On lookup, hashes the source text and compares against
+/// cached entries to avoid recompilation across runs.
+class KernelFsCache {
+ public:
+  explicit KernelFsCache(const std::string& cacheDir);
+
+  /// Returns a compiled kernel for the given key. If a matching source is
+  /// found in the cache directory, loads the pre-compiled CUBIN. Otherwise
+  /// compiles via wave and stores the result for future runs.
+  std::unique_ptr<CompiledKernel> getKernel(
+      const std::string& key,
+      KernelGenFunc genFunc);
+
+  /// Returns the number of cache hits since construction.
+  int64_t hits() const {
+    return hits_;
+  }
+
+  /// Returns the number of cache misses since construction.
+  int64_t misses() const {
+    return misses_;
+  }
+
+  /// Returns the number of distinct successfully cached entries.
+  int32_t size() const {
+    return numEntries_.load();
+  }
+
+ private:
+  struct CacheEntry {
+    int32_t ordinal;
+  };
+
+  /// Scans the cache directory and populates hashToEntries_ on first call.
+  void init();
+
+  /// Returns the path for the .cu source file at the given cache ordinal.
+  std::string cuPath(int32_t ordinal) const;
+  /// Returns the path for the .cubin binary at the given cache ordinal.
+  std::string cubinPath(int32_t ordinal) const;
+  /// Returns the path for the .cubin.names sidecar at the given cache ordinal.
+  std::string namesPath(int32_t ordinal) const;
+
+  // Directory holding the cached .cu, .cubin, and .cubin.names files.
+  std::string cacheDir_;
+  // True after the first call to init().
+  bool initialized_{false};
+  // Protects hashToEntries_, nextOrdinal_, and initialized_.
+  std::mutex mutex_;
+  // Maps source-text hash to cache entries sharing that hash.
+  // Using unordered_map because adding folly::F14FastMap as a dependency
+  // causes dependency count regressions across all downstream wave targets.
+  std::unordered_map<size_t, std::vector<CacheEntry>> hashToEntries_;
+  // Next ordinal for new cache files.
+  std::atomic<int32_t> nextOrdinal_{0};
+  // Serial number for compile operations.
+  std::atomic<int32_t> compileSerial_{0};
+  // Number of distinct cached entries.
+  std::atomic<int32_t> numEntries_{0};
+  std::atomic<int64_t> hits_{0};
+  std::atomic<int64_t> misses_{0};
+};
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/tests/AtomicTest.cu b/velox/experimental/wave/common/tests/AtomicTest.cu
index 4eb0eab6cc4..72d124139a2 100644
--- a/velox/experimental/wave/common/tests/AtomicTest.cu
+++ b/velox/experimental/wave/common/tests/AtomicTest.cu
@@ -51,19 +51,6 @@ struct AtomicTestType {
   static const MemoryOrder memory_order = Order;
 };
 
-struct AtomicTestNameGenerator {
-  template <typename T>
-  static std::string GetName(int) {
-    if constexpr (T::memory_order == MemoryOrder::kRelaxed)
-      return "relaxed";
-    if constexpr (T::memory_order == MemoryOrder::kAcquire)
-      return "acquire";
-    if constexpr (T::memory_order == MemoryOrder::kRelease)
-      return "release";
-    return "?";
-  }
-};
-
 template <typename TypeParam>
 class AtomicLoadTest : public testing::Test {};
 
@@ -71,7 +58,7 @@ using AtomicLoadTestTypes = ::testing::Types<
     AtomicTestType<MemoryOrder::kRelaxed>,
     AtomicTestType<MemoryOrder::kAcquire>>;
 
-TYPED_TEST_SUITE(AtomicLoadTest, AtomicLoadTestTypes, AtomicTestNameGenerator);
+TYPED_TEST_SUITE(AtomicLoadTest, AtomicLoadTestTypes);
 
 TYPED_TEST(AtomicLoadTest, load) {
   auto* allocator = getAllocator(getDevice());
@@ -91,10 +78,7 @@ using AtomicStoreTestTypes = ::testing::Types<
     AtomicTestType<MemoryOrder::kRelaxed>,
     AtomicTestType<MemoryOrder::kRelease>>;
 
-TYPED_TEST_SUITE(
-    AtomicStoreTest,
-    AtomicStoreTestTypes,
-    AtomicTestNameGenerator);
+TYPED_TEST_SUITE(AtomicStoreTest, AtomicStoreTestTypes);
 
 TYPED_TEST(AtomicStoreTest, store) {
   auto* allocator = getAllocator(getDevice());
@@ -113,10 +97,7 @@ using AtomicCompareExchangeTestTypes = ::testing::Types<
     AtomicTestType<MemoryOrder::kAcquire>,
     AtomicTestType<MemoryOrder::kRelease>>;
 
-TYPED_TEST_SUITE(
-    AtomicCompareExchangeTest,
-    AtomicCompareExchangeTestTypes,
-    AtomicTestNameGenerator);
+TYPED_TEST_SUITE(AtomicCompareExchangeTest, AtomicCompareExchangeTestTypes);
 
 TYPED_TEST(AtomicCompareExchangeTest, compare_exchange) {
   auto* allocator = getAllocator(getDevice());
diff --git a/velox/experimental/wave/common/tests/CMakeLists.txt b/velox/experimental/wave/common/tests/CMakeLists.txt
index c509056fc0b..e5203bea1fb 100644
--- a/velox/experimental/wave/common/tests/CMakeLists.txt
+++ b/velox/experimental/wave/common/tests/CMakeLists.txt
@@ -29,6 +29,8 @@ add_executable(
 add_test(velox_wave_common_test velox_wave_common_test)
 set_tests_properties(velox_wave_common_test PROPERTIES LABELS cuda_driver)
 
+target_compile_options(velox_wave_common_test PRIVATE ${VELOX_CUDA_DEBUG_FLAGS})
+
 if(VELOX_SKIP_WAVE_BRANCH_KERNEL_TEST)
   target_compile_definitions(velox_wave_common_test PRIVATE VELOX_SKIP_WAVE_BRANCH_KERNEL_TEST=1)
 endif()
diff --git a/velox/experimental/wave/common/tests/CompileTest.cu b/velox/experimental/wave/common/tests/CompileTest.cu
index 5c463853d48..2c232398bbd 100644
--- a/velox/experimental/wave/common/tests/CompileTest.cu
+++ b/velox/experimental/wave/common/tests/CompileTest.cu
@@ -17,13 +17,18 @@
 #include <cuda.h>
 #include <cuda_runtime.h>
 
+#include <folly/ScopeGuard.h>
 #include <gtest/gtest.h>
 #include "velox/experimental/wave/common/Buffer.h"
 #include "velox/experimental/wave/common/CudaUtil.cuh"
 #include "velox/experimental/wave/common/Exception.h"
 #include "velox/experimental/wave/common/GpuArena.h"
+#include "velox/experimental/wave/common/KernelFsCache.h"
 #include "velox/experimental/wave/common/tests/BlockTest.h"
 
+#include <unistd.h>
+#include <filesystem>
+#include <fstream>
 #include <iostream>
 
 namespace facebook::velox::wave {
@@ -229,4 +234,179 @@ TEST_F(CompileTest, reduce) {
   EXPECT_EQ(sum, ptr2[0]);
 }
 
+TEST_F(CompileTest, cubinCache) {
+  const char* text =
+      "#include \"velox/experimental/wave/common/Scan.cuh\"\n"
+      "namespace facebook::velox::wave {\n"
+      "__global__ void scanKernel32(int32_t* ints) {\n"
+      "  using Scan = WarpScan<uint32_t>;\n"
+      "uint32_t out;\n"
+      " Scan().exclusiveSum(ints[threadIdx.x], out);\n"
+      "ints[threadIdx.x] = out;\n"
+      "__syncthreads();\n"
+      "}\n"
+      "}\n";
+
+  std::string cubinPath =
+      "/tmp/compile_test_scan_" + std::to_string(getpid()) + ".cubin";
+
+  // Phase 1: compile via getKernel with cubinPath and postCompile set.
+  bool postCompileCalled = false;
+  std::vector<std::string> savedLoweredNames;
+
+  auto kernel = CompiledKernel::getKernel("scanCubinTest", [&]() -> KernelSpec {
+    KernelSpec spec;
+    spec.code = text;
+    spec.entryPoints = {"facebook::velox::wave::scanKernel32"};
+    spec.filePath = "scan_cubin.cu";
+    spec.cubinPath = cubinPath;
+    spec.postCompile = [&](KernelSpec& compiled, std::exception_ptr error) {
+      EXPECT_EQ(error, nullptr);
+      postCompileCalled = true;
+      savedLoweredNames = compiled.loweredNames;
+    };
+    return spec;
+  });
+
+  // Verify postCompile was called and loweredNames were populated.
+  auto info = kernel->info(0);
+  EXPECT_GT(info.numRegs, 0);
+  EXPECT_TRUE(postCompileCalled);
+  ASSERT_EQ(savedLoweredNames.size(), 1);
+
+  // Launch and verify result.
+  auto runAndCheck = [&](CompiledKernel& kernel) {
+    WaveBufferPtr ints = arena_->allocate<uint32_t>(32);
+    for (auto i = 0; i < 32; ++i) {
+      ints->as<uint32_t>()[i] = i;
+    }
+    auto rawInts = ints->as<int32_t>();
+    void* params = &rawInts;
+    auto stream = std::make_unique<Stream>();
+    kernel.launch(0, 1, 32, 0, stream.get(), &params);
+    stream->wait();
+    int32_t sum = 0;
+    for (auto i = 0; i < 32; ++i) {
+      EXPECT_EQ(rawInts[i], sum);
+      sum += i;
+    }
+  };
+  runAndCheck(*kernel);
+
+  // Phase 2: clear cache and load from CUBIN via getKernel with
+  // fromCubinPath.
+  CompiledKernel::clearCache();
+  auto kernel2 =
+      CompiledKernel::getKernel("scanCubinTest2", [&]() -> KernelSpec {
+        KernelSpec spec;
+        spec.entryPoints = {"facebook::velox::wave::scanKernel32"};
+        spec.fromCubinPath = cubinPath;
+        spec.loweredNames = savedLoweredNames;
+        return spec;
+      });
+  runAndCheck(*kernel2);
+}
+
+TEST_F(CompileTest, fsCache) {
+  const char* scanText =
+      "#include \"velox/experimental/wave/common/Scan.cuh\"\n"
+      "namespace facebook::velox::wave {\n"
+      "__global__ void scanKernel32(int32_t* ints) {\n"
+      "  using Scan = WarpScan<uint32_t>;\n"
+      "uint32_t out;\n"
+      " Scan().exclusiveSum(ints[threadIdx.x], out);\n"
+      "ints[threadIdx.x] = out;\n"
+      "__syncthreads();\n"
+      "}\n"
+      "}\n";
+
+  auto cachePath = "/tmp/compile_test_fscache_" + std::to_string(getpid());
+  std::error_code ec;
+  std::filesystem::remove_all(cachePath, ec);
+  SCOPE_EXIT {
+    std::filesystem::remove_all(cachePath, ec);
+  };
+
+  auto runAndCheck = [&](CompiledKernel& kernel) {
+    WaveBufferPtr ints = arena_->allocate<uint32_t>(32);
+    for (auto i = 0; i < 32; ++i) {
+      ints->as<uint32_t>()[i] = i;
+    }
+    auto rawInts = ints->as<int32_t>();
+    void* params = &rawInts;
+    auto stream = std::make_unique<Stream>();
+    kernel.launch(0, 1, 32, 0, stream.get(), &params);
+    stream->wait();
+    int32_t sum = 0;
+    for (auto i = 0; i < 32; ++i) {
+      EXPECT_EQ(rawInts[i], sum);
+      sum += i;
+    }
+  };
+
+  auto makeGenFunc = [&]() -> KernelGenFunc {
+    return [&]() -> KernelSpec {
+      KernelSpec spec;
+      spec.code = scanText;
+      spec.entryPoints = {"facebook::velox::wave::scanKernel32"};
+      spec.filePath = "scan_fs.cu";
+      return spec;
+    };
+  };
+
+  {
+    KernelFsCache cache(cachePath);
+
+    // First call: expect miss.
+    {
+      auto kernel = cache.getKernel(scanText, makeGenFunc());
+      runAndCheck(*kernel);
+    }
+    EXPECT_EQ(cache.misses(), 1);
+    EXPECT_EQ(cache.hits(), 0);
+    EXPECT_EQ(cache.size(), 1);
+
+    // Second call after clearing RAM cache: expect fs cache hit.
+    CompiledKernel::clearCache();
+    {
+      auto kernel2 = cache.getKernel(scanText, makeGenFunc());
+      runAndCheck(*kernel2);
+    }
+    EXPECT_EQ(cache.hits(), 1);
+    EXPECT_EQ(cache.misses(), 1);
+    EXPECT_EQ(cache.size(), 1);
+  }
+
+  // Destroy the fs cache and RAM cache, then recreate from the same path.
+  CompiledKernel::clearCache();
+  {
+    KernelFsCache cache2(cachePath);
+    auto kernel3 = cache2.getKernel(scanText, makeGenFunc());
+    runAndCheck(*kernel3);
+    EXPECT_EQ(cache2.hits(), 1);
+    EXPECT_EQ(cache2.misses(), 0);
+    EXPECT_EQ(cache2.size(), 1);
+
+    // Make a broken kernel text that will fail to compile.
+    auto badText = std::string(scanText) + "#error intentional\n";
+    auto sizeBefore = cache2.size();
+    bool threw = false;
+    try {
+      auto badKernel = cache2.getKernel(badText, [&]() -> KernelSpec {
+        KernelSpec spec;
+        spec.code = badText;
+        spec.entryPoints = {"facebook::velox::wave::scanKernel32"};
+        spec.filePath = "scan_bad.cu";
+        return spec;
+      });
+      // Access info to force the deferred compilation to complete.
+      badKernel->info(0);
+    } catch (...) {
+      threw = true;
+    }
+    EXPECT_TRUE(threw);
+    EXPECT_EQ(cache2.size(), sizeBefore);
+  }
+}
+
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/tests/CudaTest.cpp b/velox/experimental/wave/common/tests/CudaTest.cpp
index 2f8f6efb148..5baa0e1d99a 100644
--- a/velox/experimental/wave/common/tests/CudaTest.cpp
+++ b/velox/experimental/wave/common/tests/CudaTest.cpp
@@ -1112,8 +1112,9 @@ class CudaTest : public testing::Test {
     auto start = getCurrentTimeMicro();
     for (auto i = 0; i < numStreams; ++i) {
       streams.push_back(std::make_unique<TestStream>());
-      ints.push_back(reinterpret_cast<int32_t*>(
-          allocator_->allocate(opSize * sizeof(int32_t))));
+      ints.push_back(
+          reinterpret_cast<int32_t*>(
+              allocator_->allocate(opSize * sizeof(int32_t))));
       auto last = ints.back();
       auto data = initVector;
       for (auto i = 0; i < opSize; i += kBatch) {
@@ -1380,8 +1381,9 @@ class CudaTest : public testing::Test {
           runs.push_back(std::make_unique<RoundtripThread>(0, arenas.get()));
         }
         for (int32_t i = 0; i < numThreads; ++i) {
-          threads.push_back(std::thread(
-              [i, &runs, &threadStats]() { runs[i]->run(threadStats[i]); }));
+          threads.push_back(std::thread([i, &runs, &threadStats]() {
+            runs[i]->run(threadStats[i]);
+          }));
         }
         for (auto i = 0; i < numThreads; ++i) {
           threads[i].join();
diff --git a/velox/experimental/wave/common/tests/HashTableTest.cpp b/velox/experimental/wave/common/tests/HashTableTest.cpp
index 602a05d3499..d22aafb4ef7 100644
--- a/velox/experimental/wave/common/tests/HashTableTest.cpp
+++ b/velox/experimental/wave/common/tests/HashTableTest.cpp
@@ -232,13 +232,10 @@ class HashTableTest : public testing::Test {
 
   void updateJitMtxCoa(TestingRow* rows, HashRun& run, TestingRow* reference) {
     std::cout << "updateJitMtxCoa" << std::endl;
-    KernelSpec spec = {
-        jitMtxCoa,
-        {"facebook::velox::wave::jitSumMtxCoalesce"},
-        "sum1Jit.cu",
-        0,
-        nullptr,
-        nullptr};
+    KernelSpec spec;
+    spec.code = jitMtxCoa;
+    spec.entryPoints = {"facebook::velox::wave::jitSumMtxCoalesce"};
+    spec.filePath = "sum1Jit.cu";
     auto kernel = CompiledModule::create(spec);
     uint64_t micros = 0;
     {
diff --git a/velox/experimental/wave/dwio/ColumnReader.h b/velox/experimental/wave/dwio/ColumnReader.h
index d3a123b0f90..97acac1c260 100644
--- a/velox/experimental/wave/dwio/ColumnReader.h
+++ b/velox/experimental/wave/dwio/ColumnReader.h
@@ -122,7 +122,7 @@ class ReadStream : public Executable {
   ReadStream(
       StructColumnReader* columnReader,
       WaveStream& waveStream,
-      velox::io::IoStatistics* ioStats,
+      velox::io::IoStatistics* ioStatistics,
       FileInfo& fileInfo,
       const OperandSet* firstColumns = nullptr);
 
diff --git a/velox/experimental/wave/dwio/ReadStream.cpp b/velox/experimental/wave/dwio/ReadStream.cpp
index ce866f86fb6..e997b99884b 100644
--- a/velox/experimental/wave/dwio/ReadStream.cpp
+++ b/velox/experimental/wave/dwio/ReadStream.cpp
@@ -47,10 +47,10 @@ void allOperands(
 ReadStream::ReadStream(
     StructColumnReader* columnReader,
     WaveStream& _waveStream,
-    io::IoStatistics* ioStats,
+    io::IoStatistics* ioStatistics,
     FileInfo& fileInfo,
     const OperandSet* firstColumns)
-    : Executable(), ioStats_(ioStats), fileInfo_(fileInfo) {
+    : Executable(), ioStats_(ioStatistics), fileInfo_(fileInfo) {
   VELOX_CHECK_EQ(
       0,
       FLAGS_wave_reader_rows_per_tb & 1023,
diff --git a/velox/experimental/wave/dwio/decode/CMakeLists.txt b/velox/experimental/wave/dwio/decode/CMakeLists.txt
index a04ae9655c5..2f88c3ed80a 100644
--- a/velox/experimental/wave/dwio/decode/CMakeLists.txt
+++ b/velox/experimental/wave/dwio/decode/CMakeLists.txt
@@ -17,4 +17,6 @@ endif()
 
 add_library(velox_wave_decode GpuDecoder.cu)
 
+target_compile_options(velox_wave_decode PRIVATE ${VELOX_CUDA_DEBUG_FLAGS})
+
 target_link_libraries(velox_wave_decode velox_wave_common CUDA::cudart breeze_cuda)
diff --git a/velox/experimental/wave/dwio/decode/tests/CMakeLists.txt b/velox/experimental/wave/dwio/decode/tests/CMakeLists.txt
index d93e34c7ab2..2132927fa48 100644
--- a/velox/experimental/wave/dwio/decode/tests/CMakeLists.txt
+++ b/velox/experimental/wave/dwio/decode/tests/CMakeLists.txt
@@ -14,6 +14,8 @@
 
 add_executable(velox_wave_decode_test GpuDecoderTest.cu)
 
+target_compile_options(velox_wave_decode_test PRIVATE ${VELOX_CUDA_DEBUG_FLAGS})
+
 add_test(velox_wave_decode_test velox_wave_decode_test)
 set_tests_properties(velox_wave_decode_test PROPERTIES LABELS cuda_driver)
 
diff --git a/velox/experimental/wave/dwio/nimble/EncodingIdentifier.h b/velox/experimental/wave/dwio/nimble/EncodingIdentifier.h
deleted file mode 100644
index 19e169ac03e..00000000000
--- a/velox/experimental/wave/dwio/nimble/EncodingIdentifier.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <cstdint>
-
-namespace facebook::wave::nimble {
-
-// When encoding contains nested encodings, each nested encoding has its
-// own identifier.
-using NestedEncodingIdentifier = uint8_t;
-
-struct EncodingIdentifiers {
-  struct Dictionary {
-    static constexpr NestedEncodingIdentifier Alphabet = 0;
-    static constexpr NestedEncodingIdentifier Indices = 1;
-  };
-
-  struct MainlyConstant {
-    static constexpr NestedEncodingIdentifier IsCommon = 0;
-    static constexpr NestedEncodingIdentifier OtherValues = 1;
-  };
-
-  struct Nullable {
-    static constexpr NestedEncodingIdentifier Data = 0;
-    static constexpr NestedEncodingIdentifier Nulls = 1;
-  };
-
-  struct RunLength {
-    static constexpr NestedEncodingIdentifier RunLengths = 0;
-    static constexpr NestedEncodingIdentifier RunValues = 1;
-  };
-
-  struct SparseBool {
-    static constexpr NestedEncodingIdentifier Indices = 0;
-  };
-
-  struct Trivial {
-    static constexpr NestedEncodingIdentifier Lengths = 0;
-  };
-};
-
-} // namespace facebook::wave::nimble
diff --git a/velox/experimental/wave/dwio/nimble/EncodingPrimitives.h b/velox/experimental/wave/dwio/nimble/EncodingPrimitives.h
deleted file mode 100644
index 500d7943e8e..00000000000
--- a/velox/experimental/wave/dwio/nimble/EncodingPrimitives.h
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <cstring>
-#include <string_view>
-
-#include "folly/io/IOBuf.h"
-
-// Primitives for reading and writing to a stream of bytes.
-
-namespace facebook::wave::nimble::encoding {
-
-// The write functions serialize a datum into a buffer, advancing the
-// buffer pointer appropriately.
-
-// Write a type in native format for numeric types, via WriteString
-// for string types.
-template <typename T>
-inline void write(T value, char*& pos) {
-  *reinterpret_cast<T*>(pos) = value;
-  pos += sizeof(T);
-}
-
-inline void writeChar(char value, char*& pos) {
-  write<char>(value, pos);
-}
-
-inline void writeUint32(uint32_t value, char*& pos) {
-  write<uint32_t>(value, pos);
-}
-
-inline void writeUint64(uint64_t value, char*& pos) {
-  write<uint64_t>(value, pos);
-}
-
-// Just the chars, no leading length.
-inline void writeBytes(std::string_view value, char*& pos) {
-  std::copy(value.cbegin(), value.cend(), pos);
-  pos += value.size();
-}
-
-// Just the buffers, no leading length.
-inline void writeBuffers(const folly::IOBuf& buffers, char*& pos) {
-  for (const auto buffer : buffers) {
-    std::copy(buffer.cbegin(), buffer.cend(), pos);
-    pos += buffer.size();
-  }
-}
-
-// 4 byte length followed by chars.
-inline void writeString(std::string_view value, char*& pos) {
-  writeUint32(value.size(), pos);
-  writeBytes(value, pos);
-}
-
-template <>
-inline void write(std::string_view value, char*& pos) {
-  writeString(value, pos);
-}
-
-template <>
-inline void write(const std::string& value, char*& pos) {
-  writeString({value.data(), value.size()}, pos);
-}
-
-// The read functions extract a datum from the buffer (stored in the
-// format output by the Write functions), advancing the buffer
-// pointer appropriately.
-
-// Reads a type written via Write.
-template <typename T, typename TReturn = T>
-inline TReturn read(const char*& pos) {
-  const T value = *reinterpret_cast<const T*>(pos);
-  pos += sizeof(T);
-  return static_cast<TReturn>(value);
-}
-
-inline char readChar(const char*& pos) {
-  return read<char>(pos);
-}
-
-inline uint32_t readUint32(const char*& pos) {
-  return read<uint32_t>(pos);
-}
-
-inline uint64_t readUint64(const char*& pos) {
-  return read<uint64_t>(pos);
-}
-
-inline std::string_view readString(const char*& pos) {
-  const uint32_t size = readUint32(pos);
-  std::string_view result(pos, size);
-  pos += size;
-  return result;
-}
-
-inline std::string readOwnedString(const char*& pos) {
-  const uint32_t size = readUint32(pos);
-  std::string result(pos, size);
-  pos += size;
-  return result;
-}
-
-template <>
-inline std::string_view read<std::string_view, std::string_view>(
-    const char*& pos) {
-  return readString(pos);
-}
-
-template <>
-inline std::string read<std::string, std::string>(const char*& pos) {
-  return readOwnedString(pos);
-}
-
-template <typename T, typename TReturn = T>
-inline TReturn peek(const char* pos) {
-  return static_cast<TReturn>(*reinterpret_cast<const T*>(pos));
-}
-
-} // namespace facebook::wave::nimble::encoding
diff --git a/velox/experimental/wave/dwio/nimble/NimbleFileFormat.cpp b/velox/experimental/wave/dwio/nimble/NimbleFileFormat.cpp
deleted file mode 100644
index d09a462eba1..00000000000
--- a/velox/experimental/wave/dwio/nimble/NimbleFileFormat.cpp
+++ /dev/null
@@ -1,853 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/wave/dwio/nimble/NimbleFileFormat.h"
-#include "velox/experimental/wave/dwio/ColumnReader.h"
-#include "velox/experimental/wave/dwio/nimble/Encoding.h"
-#include "velox/experimental/wave/dwio/nimble/EncodingIdentifier.h"
-#include "velox/experimental/wave/dwio/nimble/EncodingPrimitives.h"
-#include "velox/experimental/wave/dwio/nimble/Types.h"
-
-using namespace facebook::wave::nimble;
-
-DECLARE_int32(wave_reader_rows_per_tb);
-
-namespace facebook::velox::wave {
-
-/// NimbleEncoding implementation
-NimbleEncoding::NimbleEncoding(std::string_view encodingData, bool encodeNulls)
-    : encodingData_(encodingData), encodeNulls_(encodeNulls) {
-  encodingType_ = encoding::peek<uint8_t, EncodingType>(encodingData_.data());
-  dataType_ = encoding::peek<uint8_t, DataType>(
-      encodingData_.data() + Encoding::kDataTypeOffset);
-  numValues_ = encoding::peek<uint32_t>(
-      encodingData_.data() + Encoding::kRowCountOffset);
-}
-
-NimbleEncoding::NimbleEncoding(
-    facebook::wave::nimble::EncodingType encodingType,
-    facebook::wave::nimble::DataType dataType,
-    uint32_t numValues)
-    : encodingData_{},
-      encodingType_(encodingType),
-      dataType_(dataType),
-      numValues_(numValues),
-      encodeNulls_(false) {}
-
-uint8_t NimbleEncoding::childrenCount() const {
-  const auto encodingType = this->encodingType();
-  switch (encodingType) {
-    case EncodingType::Trivial: {
-      if (dataType() == DataType::String) {
-        VELOX_NYI("Unsupported encoding type");
-      }
-      return 0;
-    }
-    case EncodingType::Dictionary:
-    case EncodingType::Nullable: {
-      return 2;
-    }
-    case EncodingType::RLE: {
-      if (dataType() == DataType::Bool) {
-        VELOX_NYI("Unsupported encoding type");
-      }
-      return 2;
-    }
-    default:
-      VELOX_NYI(
-          "Unsupported encoding type: {}", static_cast<int>(encodingType));
-  }
-}
-
-facebook::velox::TypePtr NimbleEncoding::nimbleDataTypeToVeloxType(
-    DataType nimbleDataType) const {
-  switch (nimbleDataType) {
-    case DataType::Int8:
-      return facebook::velox::ScalarType<
-          facebook::velox::TypeKind::TINYINT>::create();
-    case DataType::Uint8:
-      // Velox doesn't have unsigned types, map to signed equivalent
-      return facebook::velox::ScalarType<
-          facebook::velox::TypeKind::TINYINT>::create();
-    case DataType::Int16:
-      return facebook::velox::ScalarType<
-          facebook::velox::TypeKind::SMALLINT>::create();
-    case DataType::Uint16:
-      // Velox doesn't have unsigned types, map to signed equivalent
-      return facebook::velox::ScalarType<
-          facebook::velox::TypeKind::SMALLINT>::create();
-    case DataType::Int32:
-      return facebook::velox::ScalarType<
-          facebook::velox::TypeKind::INTEGER>::create();
-    case DataType::Uint32:
-      // Velox doesn't have unsigned types, map to signed equivalent
-      return facebook::velox::ScalarType<
-          facebook::velox::TypeKind::INTEGER>::create();
-    case DataType::Int64:
-      return facebook::velox::ScalarType<
-          facebook::velox::TypeKind::BIGINT>::create();
-    case DataType::Uint64:
-      // Velox doesn't have unsigned types, map to signed equivalent
-      return facebook::velox::ScalarType<
-          facebook::velox::TypeKind::BIGINT>::create();
-    case DataType::Float:
-      return facebook::velox::ScalarType<
-          facebook::velox::TypeKind::REAL>::create();
-    case DataType::Double:
-      return facebook::velox::ScalarType<
-          facebook::velox::TypeKind::DOUBLE>::create();
-    case DataType::Bool:
-      return facebook::velox::ScalarType<
-          facebook::velox::TypeKind::BOOLEAN>::create();
-    case DataType::String:
-      return facebook::velox::ScalarType<
-          facebook::velox::TypeKind::VARCHAR>::create();
-    case DataType::Undefined:
-    default:
-      return facebook::velox::ScalarType<
-          facebook::velox::TypeKind::UNKNOWN>::create();
-  }
-}
-
-facebook::velox::TypePtr NimbleEncoding::veloxType() const {
-  return nimbleDataTypeToVeloxType(dataType());
-}
-
-facebook::velox::TypeKind NimbleEncoding::typeKind() const {
-  return veloxType()->kind();
-}
-
-NimbleEncoding* NimbleEncoding::childAt(uint8_t childIndex) {
-  VELOX_CHECK_LT(childIndex, childrenCount(), "Child index out of range");
-  return (childIndex >= children_.size())
-      ? createChildEncodingByIndex(childIndex)
-      : children_[childIndex].get();
-}
-
-NimbleEncoding* NimbleEncoding::createChildEncodingByIndex(uint8_t childIndex) {
-  VELOX_CHECK_LT(childIndex, childrenCount(), "Child index out of range");
-
-  const auto encodingType = this->encodingType();
-  const auto dataType = this->dataType();
-  const char* pos = encodedDataPtr();
-
-  std::string_view childEncodingData;
-  bool encodeNulls = false;
-
-  switch (encodingType) {
-    case EncodingType::Dictionary: {
-      if (childIndex == 0) {
-        const uint32_t alphabetBytes = encoding::readUint32(pos);
-        childEncodingData = std::string_view(pos, alphabetBytes);
-      } else if (childIndex == 1) {
-        const uint32_t alphabetBytes = encoding::readUint32(pos);
-        pos += alphabetBytes;
-        const size_t indicesBytes =
-            encodingData_.size() - (pos - encodingData_.data());
-        childEncodingData = std::string_view(pos, indicesBytes);
-      }
-      break;
-    }
-
-    case EncodingType::RLE: {
-      if (childIndex == 0) {
-        const uint32_t runLengthBytes = encoding::readUint32(pos);
-        childEncodingData = std::string_view(pos, runLengthBytes);
-      } else if (childIndex == 1 && dataType != DataType::Bool) {
-        const uint32_t runLengthBytes = encoding::readUint32(pos);
-        pos += runLengthBytes;
-        const size_t runValuesBytes =
-            encodingData_.size() - (pos - encodingData_.data());
-        childEncodingData = std::string_view(pos, runValuesBytes);
-      }
-      break;
-    }
-
-    case EncodingType::Nullable: {
-      if (childIndex == 0) {
-        const uint32_t dataBytes = encoding::readUint32(pos);
-        childEncodingData = std::string_view(pos, dataBytes);
-      } else if (childIndex == 1) {
-        const uint32_t dataBytes = encoding::readUint32(pos);
-        pos += dataBytes;
-        const size_t nullsBytes =
-            encodingData_.size() - (pos - encodingData_.data());
-        childEncodingData = std::string_view(pos, nullsBytes);
-        encodeNulls = true;
-      }
-      break;
-    }
-
-    default:
-      VELOX_NYI("Encoding type does not support child streams");
-  }
-
-  if (childEncodingData.empty()) {
-    VELOX_NYI("Invalid child index for this encoding type");
-  }
-
-  auto child = create(childEncodingData, encodeNulls);
-  NimbleEncoding* childPtr = child.get();
-  children_.push_back(std::move(child));
-  return childPtr;
-}
-
-#define DEFINE_ENCODING_ACCESSOR(methodName)     \
-  NimbleEncoding* NimbleEncoding::methodName() { \
-    return nullptr;                              \
-  }
-
-DEFINE_ENCODING_ACCESSOR(alphabetEncoding)
-DEFINE_ENCODING_ACCESSOR(indicesEncoding)
-DEFINE_ENCODING_ACCESSOR(lengthsEncoding)
-DEFINE_ENCODING_ACCESSOR(runLengthsEncoding)
-DEFINE_ENCODING_ACCESSOR(runValuesEncoding)
-DEFINE_ENCODING_ACCESSOR(nullsEncoding)
-DEFINE_ENCODING_ACCESSOR(nonNullsEncoding)
-
-bool NimbleEncoding::isReadyToDecode() const {
-  for (auto& child : children_) {
-    if (!child->isDecoded()) {
-      return false;
-    }
-  }
-  return true;
-}
-
-#define NIMBLE_ENCODING_FACTORY_CASE(type, className) \
-  case EncodingType::type:                            \
-    return std::make_unique<className>(encodingData, encodeNulls);
-
-std::unique_ptr<NimbleEncoding> NimbleEncoding::create(
-    std::string_view encodingData,
-    bool encodeNulls) {
-  EncodingType encodingType =
-      encoding::peek<uint8_t, EncodingType>(encodingData.data());
-
-  switch (encodingType) {
-    NIMBLE_ENCODING_FACTORY_CASE(Trivial, NimbleTrivialEncoding)
-    NIMBLE_ENCODING_FACTORY_CASE(RLE, NimbleRLEEncoding)
-    NIMBLE_ENCODING_FACTORY_CASE(Dictionary, NimbleDictionaryEncoding)
-    NIMBLE_ENCODING_FACTORY_CASE(Nullable, NimbleNullableEncoding)
-    default:
-      VELOX_NYI("Unsupported encoding type");
-  }
-}
-
-#undef NIMBLE_ENCODING_FACTORY_CASE
-
-namespace {
-void setFilter(GpuDecode* step, ColumnReader* reader) {
-  auto* veloxFilter = reader->scanSpec().filter();
-  if (!veloxFilter) {
-    step->filterKind = WaveFilterKind::kAlwaysTrue;
-    return;
-  }
-  switch (veloxFilter->kind()) {
-    case common::FilterKind::kBigintRange: {
-      step->filterKind = WaveFilterKind::kBigintRange;
-      step->nullsAllowed = veloxFilter->testNull();
-      step->filter._.int64Range[0] =
-          reinterpret_cast<const common::BigintRange*>(veloxFilter)->lower();
-      step->filter._.int64Range[1] =
-          reinterpret_cast<const common::BigintRange*>(veloxFilter)->upper();
-      break;
-    }
-
-    default:
-      VELOX_UNSUPPORTED(
-          "Unsupported filter kind", static_cast<int32_t>(veloxFilter->kind()));
-  }
-}
-} // namespace
-
-std::unique_ptr<GpuDecode> NimbleEncoding::makeStepCommon(
-    ColumnOp& op,
-    const ColumnOp* previousFilter,
-    ReadStream& stream,
-    ResultStaging& deviceStaging,
-    int32_t blockIdx,
-    bool isRoot,
-    bool processFilter,
-    int32_t resultOffset) {
-  auto rowsPerBlock = FLAGS_wave_reader_rows_per_tb;
-  auto maxRowsPerThread = (rowsPerBlock / kBlockSize);
-  [[maybe_unused]] int32_t numBlocks =
-      bits::roundUp(numValues(), rowsPerBlock) / rowsPerBlock;
-  auto rowsInBlock =
-      std::min<int32_t>(rowsPerBlock, numValues() - (blockIdx * rowsPerBlock));
-
-  auto step = std::make_unique<GpuDecode>();
-  step->numRowsPerThread = bits::roundUp(rowsInBlock, kBlockSize) / kBlockSize;
-  step->gridNumRowsPerThread = maxRowsPerThread;
-  step->nthBlock = blockIdx;
-  step->baseRow = rowsPerBlock * blockIdx;
-  if (processFilter && previousFilter) {
-    step->maxRow = GpuDecode::kFilterHits;
-  } else {
-    step->maxRow = (blockIdx * rowsPerBlock) + rowsInBlock;
-  }
-
-  // if the encoding is not a root, we ignore the previous filter when decoding
-  bool dense = (previousFilter == nullptr || !processFilter) &&
-      simd::isDense(op.rows.data(), op.rows.size());
-  bool nullable = isRoot && isNullableEncoding();
-  step->nullMode = dense
-      ? (nullable ? NullMode::kDenseNullable : NullMode::kDenseNonNull)
-      : (nullable ? NullMode::kSparseNullable : NullMode::kSparseNonNull);
-
-  // intermediate decoding steps don't need to worry about filters
-  if (processFilter) {
-    setFilter(step.get(), op.reader);
-  }
-
-  if (step->filterKind != WaveFilterKind::kAlwaysTrue && op.waveVector) {
-    /// Filtres get to record an extra copy of their passing rows if they make
-    /// values.
-    if (blockIdx == 0) {
-      op.extraRowCountId = deviceStaging.reserve(
-          numBlocks * step->numRowsPerThread * sizeof(int32_t));
-      deviceStaging.registerPointer(
-          op.extraRowCountId, &step->filterRowCount, true);
-      deviceStaging.registerPointer(
-          op.extraRowCountId, &op.extraRowCount, true);
-    } else {
-      step->filterRowCount = reinterpret_cast<int32_t*>(
-          blockIdx * sizeof(int32_t) * maxRowsPerThread);
-      deviceStaging.registerPointer(
-          op.extraRowCountId, &step->filterRowCount, false);
-    }
-  }
-
-  if (processFilter && previousFilter) {
-    if (previousFilter->deviceResult) {
-      // This is when the previous filter is in the previous kernel and its
-      // device side result is allocated.
-      step->rows = previousFilter->deviceResult + blockIdx * rowsPerBlock;
-    } else {
-      step->rows =
-          reinterpret_cast<int32_t*>(blockIdx * rowsPerBlock * sizeof(int32_t));
-      deviceStaging.registerPointer(
-          previousFilter->deviceResultId, &step->rows, false);
-    }
-  }
-
-  if (processFilter && op.reader->scanSpec().filter()) {
-    if (blockIdx == 0) {
-      op.deviceResultId =
-          deviceStaging.reserve(op.rows.size() * sizeof(int32_t));
-      deviceStaging.registerPointer(op.deviceResultId, &step->resultRows, true);
-      deviceStaging.registerPointer(op.deviceResultId, &op.deviceResult, true);
-    } else {
-      step->resultRows =
-          reinterpret_cast<int32_t*>(blockIdx * rowsPerBlock * sizeof(int32_t));
-      deviceStaging.registerPointer(
-          op.deviceResultId, &step->resultRows, false);
-    }
-  }
-
-  auto columnKind = static_cast<WaveTypeKind>(typeKind());
-  step->dataType = columnKind;
-  auto kindSize = waveTypeKindSize(columnKind);
-
-  if (isRoot) {
-    step->result = op.waveVector->values<char>();
-  } else {
-    if (decodedResultBuffer_ == nullptr) {
-      decodedResultBuffer_ = stream.waveStream->deviceArena().allocate<char>(
-          kindSize * numValues());
-    }
-    step->result = decodedResultBuffer_->as<char>();
-  }
-  step->resultNulls = nullptr;
-
-  return step;
-}
-
-void NimbleEncoding::getDeviceEncodingInput(
-    SplitStaging& staging,
-    BufferId bufferId,
-    const NimbleEncoding& rootEncoding,
-    const void* hostPtr,
-    const void** devicePtr) {
-  auto* hostBasePtr = rootEncoding.encodedDataPtr();
-  void* deviceBasePtr = rootEncoding.deviceEncodedDataPtr();
-  std::ptrdiff_t offset = static_cast<const char*>(hostPtr) - hostBasePtr;
-  if (deviceBasePtr != nullptr) {
-    *devicePtr = static_cast<char*>(deviceBasePtr) + offset;
-  } else { // the root encoding is not transferred to the device yet
-    *devicePtr = reinterpret_cast<void*>(offset);
-    staging.registerPointer(bufferId, devicePtr, false);
-  }
-}
-
-// NimbleDictionaryEncoding implementation
-NimbleDictionaryEncoding::NimbleDictionaryEncoding(
-    std::string_view encodingData,
-    bool encodeNulls)
-    : NimbleEncoding(encodingData, encodeNulls) {
-  if (encodeNulls) {
-    VELOX_NYI("Dictionary-encoded null is not supported for decoding yet.");
-  }
-}
-
-NimbleEncoding* NimbleDictionaryEncoding::alphabetEncoding() {
-  return childAt(EncodingIdentifiers::Dictionary::Alphabet);
-}
-
-NimbleEncoding* NimbleDictionaryEncoding::indicesEncoding() {
-  return childAt(EncodingIdentifiers::Dictionary::Indices);
-}
-
-std::unique_ptr<GpuDecode> NimbleDictionaryEncoding::makeStep(
-    ColumnOp& op,
-    const ColumnOp* previousFilter,
-    ReadStream& stream,
-    SplitStaging& staging,
-    ResultStaging& deviceStaging,
-    BufferId bufferId,
-    const NimbleEncoding& rootEncoding,
-    int32_t blockIdx,
-    int32_t resultOffset) {
-  VELOX_NYI("Dicionary encoding is not supported yet.");
-}
-
-// NimbleTrivialEncoding implementation
-NimbleTrivialEncoding::NimbleTrivialEncoding(
-    std::string_view encodingData,
-    bool encodeNulls)
-    : NimbleEncoding(encodingData, encodeNulls) {}
-
-NimbleEncoding* NimbleTrivialEncoding::lengthsEncoding() {
-  VELOX_NYI("Trivial encoding does not support strings yet");
-}
-
-std::unique_ptr<GpuDecode> NimbleTrivialEncoding::makeStep(
-    ColumnOp& op,
-    const ColumnOp* previousFilter,
-    ReadStream& stream,
-    SplitStaging& splitStaging,
-    ResultStaging& deviceStaging,
-    BufferId bufferId,
-    const NimbleEncoding& rootEncoding,
-    int32_t blockIdx,
-    int32_t resultOffset) {
-  auto hostPtr = encodedDataPtr();
-  auto compressionType =
-      static_cast<CompressionType>(encoding::readChar(hostPtr));
-  if (compressionType != CompressionType::Uncompressed) {
-    VELOX_NYI("Trivial encoding does not support compression yet");
-  }
-
-  if (encodeNulls_) {
-    return makeStepNulls(
-        op,
-        stream,
-        splitStaging,
-        deviceStaging,
-        bufferId,
-        rootEncoding,
-        blockIdx,
-        resultOffset);
-  }
-  bool isRoot = (this == &rootEncoding);
-
-  // True if we process the filter in this step.
-  bool processFilter = isRoot && !op.hasMultiChunks &&
-      (previousFilter || op.reader->scanSpec().filter());
-
-  auto step = makeStepCommon(
-      op,
-      previousFilter,
-      stream,
-      deviceStaging,
-      blockIdx,
-      isRoot,
-      processFilter,
-      resultOffset);
-  auto kindSize = waveTypeKindSize(step->dataType);
-
-  // True if it is a single-chunk, filter or non-filter column
-  bool singleChunkFilter = isRoot && !op.hasMultiChunks &&
-      (previousFilter || op.reader->scanSpec().filter());
-
-  if (singleChunkFilter) {
-    if (kindSize != 4 && kindSize != 8) {
-      VELOX_NYI(
-          "Unsupported data type for nullable encoding. The data type must be either 4 or 8 bytes.");
-    }
-    step->step =
-        kindSize == 4 ? DecodeStep::kSelective32 : DecodeStep::kSelective64;
-    step->encoding = DecodeStep::kDictionaryOnBitpack;
-    step->dictMode = DictMode::kNone;
-    step->data.dictionaryOnBitpack.dataType = step->dataType;
-    step->data.dictionaryOnBitpack.alphabet = nullptr;
-    step->data.dictionaryOnBitpack.scatter = nullptr;
-    step->data.dictionaryOnBitpack.bitWidth = 8 * kindSize;
-
-    // Input is exclusive to a chunk and does not need to be specified the chunk
-    // offset. TB offset is also not needed if we set baseRow and maxRow
-    // correctly.
-    getDeviceEncodingInput(
-        splitStaging,
-        bufferId,
-        rootEncoding,
-        hostPtr,
-        reinterpret_cast<const void**>(
-            &step->data.dictionaryOnBitpack.indices));
-
-    // Output is shared across chunks and must be specified the chunk offset and
-    // the TB offset.
-    step->result = step->data.dictionaryOnBitpack.result =
-        static_cast<char*>(step->result) + resultOffset * kindSize +
-        step->baseRow * kindSize;
-
-    return step;
-  }
-
-  // True if it is a multi-chunk, non-filter column
-  bool multiChunkFiltered = isRoot && previousFilter && op.hasMultiChunks &&
-      !op.reader->scanSpec().filter();
-  if (multiChunkFiltered) {
-    step->step = kindSize == 4 ? DecodeStep::kSelective32Chunked
-                               : DecodeStep::kSelective64Chunked;
-    step->rows = previousFilter->deviceResult;
-    step->filterRowCount = previousFilter->extraRowCount;
-    step->result = op.waveVector->values<char>();
-    step->data.selectiveChunked.chunkStart = resultOffset;
-    getDeviceEncodingInput(
-        splitStaging,
-        bufferId,
-        rootEncoding,
-        hostPtr,
-        reinterpret_cast<const void**>(&step->data.selectiveChunked.input));
-    return step;
-  }
-
-  step->step = DecodeStep::kTrivial;
-  step->data.trivial.dataType = step->dataType;
-  step->data.trivial.result = static_cast<char*>(step->result) +
-      kindSize * resultOffset + kindSize * step->baseRow;
-  step->data.trivial.begin = 0;
-  step->data.trivial.end = step->maxRow - step->baseRow;
-  step->data.trivial.scatter = nullptr;
-  getDeviceEncodingInput(
-      splitStaging,
-      bufferId,
-      rootEncoding,
-      hostPtr + step->baseRow * waveTypeKindSize(step->dataType),
-      &step->data.trivial.input);
-  return step;
-}
-
-std::unique_ptr<GpuDecode> NimbleTrivialEncoding::makeStepNulls(
-    ColumnOp& op,
-    ReadStream& stream,
-    SplitStaging& splitStaging,
-    ResultStaging& deviceStaging,
-    BufferId bufferId,
-    const NimbleEncoding& rootEncoding,
-    int32_t blockIdx,
-    int32_t offset) {
-  constexpr int32_t kCountStride = 1024;
-
-  if (stagedNulls_) {
-    return nullptr;
-  }
-  stagedNulls_ = true;
-
-  // For bools, we don't need to decode the data, just transfer the data
-  // we do not transfer the nulls with the root encoding because we want to
-  // make sure the null encodings are aligned.
-  Staging staging(
-      encodedDataPtr() + 1, // skip the compression type
-      bits::nwords(numValues()) * sizeof(uint64_t),
-      common::Region{0, 0});
-  auto nullStageId = splitStaging.add(staging);
-  splitStaging.registerPointer(nullStageId, &nulls_, true);
-
-  auto rowsPerBlock = FLAGS_wave_reader_rows_per_tb;
-  auto numBlocks = bits::roundUp(numValues(), rowsPerBlock) / rowsPerBlock;
-
-  // A single thread block is enough to decode the nulls
-  if (numBlocks == 1) {
-    return nullptr;
-  }
-
-  auto count = std::make_unique<GpuDecode>();
-  splitStaging.registerPointer(nullStageId, &count->data.countBits.bits, true);
-  auto numStrides = bits::roundUp(numValues(), kCountStride) / kCountStride;
-  auto resultId = deviceStaging.reserve(sizeof(int32_t) * numStrides);
-  deviceStaging.registerPointer(resultId, &count->result, true);
-  deviceStaging.registerPointer(resultId, &numNonNull_, true);
-  count->step = DecodeStep::kCountBits;
-  count->data.countBits.numBits = numValues();
-  count->data.countBits.resultStride = kCountStride;
-
-  return count;
-}
-
-// NimbleRLEEncoding implementation
-NimbleRLEEncoding::NimbleRLEEncoding(
-    std::string_view encodingData,
-    bool encodeNulls)
-    : NimbleEncoding(encodingData, encodeNulls) {
-  if (encodeNulls) {
-    VELOX_NYI("RLE-encoded null is not supported for decoding yet.");
-  }
-}
-
-NimbleEncoding* NimbleRLEEncoding::runLengthsEncoding() {
-  return childAt(EncodingIdentifiers::RunLength::RunLengths);
-}
-
-NimbleEncoding* NimbleRLEEncoding::runValuesEncoding() {
-  if (dataType() != DataType::Bool) {
-    return childAt(EncodingIdentifiers::RunLength::RunValues);
-  }
-  VELOX_NYI("RLE encoding does not support bools yet");
-}
-
-std::unique_ptr<GpuDecode> NimbleRLEEncoding::makeStep(
-    ColumnOp& op,
-    const ColumnOp* previousFilter,
-    ReadStream& stream,
-    SplitStaging& staging,
-    ResultStaging& deviceStaging,
-
-    BufferId bufferId,
-    const NimbleEncoding& rootEncoding,
-    int32_t blockIdx,
-    int32_t resultOffset) {
-  VELOX_NYI("RLE encoding is not supported yet.");
-}
-
-// NimbleNullableEncoding implementation
-NimbleNullableEncoding::NimbleNullableEncoding(
-    std::string_view encodingData,
-    bool encodeNulls)
-    : NimbleEncoding(encodingData, encodeNulls) {
-  VELOX_CHECK(!encodeNulls, "Nullable encoding cannot be used to encode nulls");
-}
-
-NimbleEncoding* NimbleNullableEncoding::nullsEncoding() {
-  return childAt(EncodingIdentifiers::Nullable::Nulls);
-}
-
-NimbleEncoding* NimbleNullableEncoding::nonNullsEncoding() {
-  return childAt(EncodingIdentifiers::Nullable::Data);
-}
-
-std::unique_ptr<GpuDecode> NimbleNullableEncoding::makeStep(
-    ColumnOp& op,
-    const ColumnOp* previousFilter,
-    ReadStream& stream,
-    SplitStaging& staging,
-    ResultStaging& deviceStaging,
-    BufferId bufferId,
-    const NimbleEncoding& rootEncoding,
-    int32_t blockIdx,
-    int32_t resultOffset) {
-  VELOX_CHECK(
-      this == &rootEncoding,
-      "Only root encoding can be decoded for nullable encoding");
-  bool isRoot = (this == &rootEncoding);
-  bool processFilter = isRoot && !op.hasMultiChunks &&
-      (previousFilter || op.reader->scanSpec().filter());
-  auto step = makeStepCommon(
-      op,
-      previousFilter,
-      stream,
-      deviceStaging,
-      blockIdx,
-      isRoot,
-      processFilter,
-      resultOffset);
-  auto kindSize = waveTypeKindSize(step->dataType);
-  if (kindSize != 4 && kindSize != 8) {
-    VELOX_NYI(
-        "Unsupported data type for nullable encoding. The data type must be either 4 or 8 bytes.");
-  }
-  auto dataBufferPtr =
-      childAt(EncodingIdentifiers::Nullable::Data)->decodedResultBuffer();
-
-  bool multiChunkFiltered = isRoot && previousFilter && op.hasMultiChunks &&
-      !op.reader->scanSpec().filter();
-  if (multiChunkFiltered) {
-    step->step = kindSize == 4 ? DecodeStep::kSelective32Chunked
-                               : DecodeStep::kSelective64Chunked;
-    step->rows = previousFilter->deviceResult;
-    step->filterRowCount = previousFilter->extraRowCount;
-    step->result = op.waveVector->values<char>();
-    step->nulls =
-        childAt(EncodingIdentifiers::Nullable::Nulls)->nulls(); // chunk local
-    step->nonNullBases =
-        childAt(EncodingIdentifiers::Nullable::Nulls)->numNonNull();
-
-    step->resultNulls = op.waveVector->nulls();
-    step->result = op.waveVector->values<void>();
-
-    step->data.selectiveChunked.chunkStart = resultOffset;
-    step->data.selectiveChunked.input =
-        dataBufferPtr ? dataBufferPtr->as<void>() : nullptr;
-    return step;
-  }
-
-  step->step =
-      kindSize == 4 ? DecodeStep::kSelective32 : DecodeStep::kSelective64;
-  step->encoding = DecodeStep::kDictionaryOnBitpack;
-  step->dictMode = DictMode::kNone;
-  step->data.dictionaryOnBitpack.dataType = step->dataType;
-  step->data.dictionaryOnBitpack.alphabet = nullptr;
-  step->data.dictionaryOnBitpack.scatter = nullptr;
-  step->data.dictionaryOnBitpack.bitWidth = 8 * kindSize;
-
-  // Input is exclusive to a chunk and does not need to be specified the chunk
-  // offset. TB offset is also not needed if we set baseRow and maxRow
-  // correctly.
-  step->data.dictionaryOnBitpack.indices =
-      dataBufferPtr ? dataBufferPtr->as<uint64_t>() : nullptr;
-  step->nulls =
-      childAt(EncodingIdentifiers::Nullable::Nulls)->nulls(); // chunk local
-  step->nonNullBases =
-      childAt(EncodingIdentifiers::Nullable::Nulls)->numNonNull();
-
-  // Output is shared across chunks and must be specified the chunk offset and
-  // the TB offset.
-  step->resultNulls = op.waveVector->nulls() + resultOffset +
-      step->baseRow; // shared across chunks
-  step->result = step->data.dictionaryOnBitpack.result =
-      static_cast<char*>(step->result) + resultOffset * kindSize +
-      step->baseRow * kindSize;
-
-  return step;
-}
-
-NimbleFilterEncoding::NimbleFilterEncoding(
-    facebook::wave::nimble::DataType dataType,
-    uint32_t numValues,
-    bool hasNulls)
-    : NimbleEncoding(
-          hasNulls ? EncodingType::Nullable : EncodingType::Trivial,
-          dataType,
-          numValues) {}
-
-std::unique_ptr<GpuDecode> NimbleFilterEncoding::makeStep(
-    ColumnOp& op,
-    const ColumnOp* previousFilter,
-    ReadStream& stream,
-    SplitStaging& staging,
-    ResultStaging& deviceStaging,
-    BufferId bufferId,
-    const NimbleEncoding& rootEncoding,
-    int32_t blockIdx,
-    int32_t resultOffset) {
-  auto step = makeStepCommon(
-      op,
-      previousFilter,
-      stream,
-      deviceStaging,
-      blockIdx,
-      true,
-      true,
-      resultOffset);
-
-  auto columnKind = static_cast<WaveTypeKind>(typeKind());
-  step->dataType = columnKind;
-  auto kindSize = waveTypeKindSize(columnKind);
-  if (kindSize != 4 && kindSize != 8) {
-    VELOX_NYI(
-        "Unsupported data type for filters. The data type must be either 4 or 8 bytes.");
-  }
-  step->step =
-      kindSize == 4 ? DecodeStep::kSelective32 : DecodeStep::kSelective64;
-  step->encoding = DecodeStep::kDictionaryOnBitpack;
-  step->dictMode = DictMode::kNone;
-  step->data.dictionaryOnBitpack.dataType = step->dataType;
-  step->data.dictionaryOnBitpack.alphabet = nullptr;
-  step->data.dictionaryOnBitpack.scatter = nullptr;
-  step->data.dictionaryOnBitpack.bitWidth = 8 * kindSize;
-  step->data.dictionaryOnBitpack.indices = op.waveVector->values<uint64_t>();
-  step->nulls = reinterpret_cast<char*>(op.waveVector->nulls());
-  step->isNullsBitmap = false;
-  step->result = step->data.dictionaryOnBitpack.result =
-      op.waveVector->values<char>() + step->baseRow * kindSize;
-  step->resultNulls = op.waveVector->nulls() + step->baseRow;
-
-  return step;
-}
-
-/// NimbleChunk implementation
-NimbleChunk::NimbleChunk(std::string_view chunkData) : chunkData_(chunkData) {}
-
-std::unique_ptr<NimbleEncoding> NimbleChunk::parseEncodingFromChunk(
-    std::string_view chunkData) {
-  VELOX_CHECK(
-      chunkData.size() >= sizeof(uint32_t) + sizeof(char),
-      "Chunk data too small to contain header");
-
-  const char* pos = chunkData.data();
-
-  auto encodingDataLength = encoding::readUint32(pos);
-
-  const size_t headerSize = sizeof(uint32_t) + sizeof(char);
-  VELOX_CHECK(
-      chunkData.size() >= headerSize + encodingDataLength,
-      "Chunk data size does not match header length");
-
-  std::string_view encodingData =
-      chunkData.substr(headerSize, encodingDataLength);
-
-  return NimbleEncoding::create(encodingData, false);
-}
-
-/// NimbleChunkedStream implementation
-NimbleChunkedStream::NimbleChunkedStream(
-    velox::memory::MemoryPool& memoryPool,
-    std::string_view streamData)
-    : streamData_(streamData), pos_(streamData.data()) {}
-
-bool NimbleChunkedStream::hasNext() {
-  return pos_ - streamData_.data() < streamData_.size();
-}
-
-NimbleChunk NimbleChunkedStream::nextChunk() {
-  VELOX_CHECK(
-      sizeof(uint32_t) + sizeof(char) <=
-          streamData_.size() - (pos_ - streamData_.data()),
-      "Read beyond end of stream");
-
-  // Read the chunk header to get length and compression type
-  const char* headerPos = pos_;
-  auto length = encoding::readUint32(pos_);
-  [[maybe_unused]] auto compressionType =
-      static_cast<CompressionType>(encoding::readChar(pos_));
-
-  VELOX_CHECK(
-      length <= streamData_.size() - (pos_ - streamData_.data()),
-      "Read beyond end of stream");
-
-  const size_t headerSize = sizeof(uint32_t) + sizeof(char);
-  const size_t totalChunkSize = headerSize + length;
-
-  std::string_view chunkData;
-  chunkData = std::string_view(headerPos, totalChunkSize);
-
-  pos_ += length;
-
-  return NimbleChunk(chunkData);
-}
-} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/nimble/NimbleFileFormat.h b/velox/experimental/wave/dwio/nimble/NimbleFileFormat.h
deleted file mode 100644
index e16753680b8..00000000000
--- a/velox/experimental/wave/dwio/nimble/NimbleFileFormat.h
+++ /dev/null
@@ -1,372 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <string_view>
-#include <vector>
-#include "velox/experimental/wave/common/Buffer.h"
-#include "velox/experimental/wave/dwio/FormatData.h"
-#include "velox/experimental/wave/dwio/decode/DecodeStep.h"
-#include "velox/experimental/wave/dwio/nimble/Encoding.h"
-#include "velox/experimental/wave/dwio/nimble/Types.h"
-#include "velox/type/Type.h"
-
-namespace facebook::velox::wave {
-
-// Base class for all Nimble encodings
-class NimbleEncoding {
- public:
-  explicit NimbleEncoding(std::string_view encodingData, bool encodeNulls);
-  explicit NimbleEncoding(
-      facebook::wave::nimble::EncodingType encodingType,
-      facebook::wave::nimble::DataType dataType,
-      uint32_t numValues);
-
-  virtual ~NimbleEncoding() = default;
-
-  std::string_view encodingData() const {
-    return encodingData_;
-  }
-
-  facebook::wave::nimble::EncodingType encodingType() const {
-    return encodingType_;
-  }
-
-  // Get a string_view of just the encoded data region (excluding prefix)
-  std::string_view encodedData() const {
-    return encodingData_.substr(facebook::wave::nimble::Encoding::kPrefixSize);
-  }
-
-  // Get pointer to the encoded data region (after the 6-byte prefix)
-  const char* encodedDataPtr() const {
-    return encodedData().data();
-  }
-
-  facebook::wave::nimble::DataType dataType() const {
-    return dataType_;
-  }
-
-  uint32_t numValues() const {
-    return numValues_;
-  }
-
-  facebook::velox::TypePtr veloxType() const;
-  facebook::velox::TypeKind typeKind() const;
-
-  uint8_t childrenCount() const;
-  NimbleEncoding* childAt(uint8_t childIndex);
-
-#define NIMBLE_ENCODING_TYPE_CHECK(name, type)                          \
-  bool is##name##Encoding() const {                                     \
-    return encodingType_ == facebook::wave::nimble::EncodingType::type; \
-  }
-
-  NIMBLE_ENCODING_TYPE_CHECK(Trivial, Trivial)
-  NIMBLE_ENCODING_TYPE_CHECK(RLE, RLE)
-  NIMBLE_ENCODING_TYPE_CHECK(Dictionary, Dictionary)
-  NIMBLE_ENCODING_TYPE_CHECK(Nullable, Nullable)
-
-#undef NIMBLE_ENCODING_TYPE_CHECK
-
-  // return nullptr if not applicable for this encoding type
-  // Dictionary
-  virtual NimbleEncoding* alphabetEncoding();
-  virtual NimbleEncoding* indicesEncoding();
-  // Trivial
-  virtual NimbleEncoding* lengthsEncoding();
-  // RLE
-  virtual NimbleEncoding* runLengthsEncoding();
-  virtual NimbleEncoding* runValuesEncoding();
-  // Nullable
-  virtual NimbleEncoding* nullsEncoding();
-  virtual NimbleEncoding* nonNullsEncoding();
-
-  static std::unique_ptr<NimbleEncoding> create(
-      std::string_view encodingData,
-      bool encodeNulls);
-
-  // Check if the encoding is ready to be decoded
-  bool isDecoded() const {
-    return decoded_;
-  }
-  void setDecoded() {
-    decoded_ = true;
-  }
-  bool isReadyToDecode() const;
-
-  // Populates the encoding-specific members and does necessary preparation
-  // required by decoding.
-  virtual std::unique_ptr<GpuDecode> makeStep(
-      ColumnOp& op,
-      const ColumnOp* previousFilter,
-      ReadStream& stream,
-      SplitStaging& staging,
-      ResultStaging& deviceStaging,
-      BufferId bufferId,
-      const NimbleEncoding& rootEncoding,
-      int32_t blockIdx,
-      int32_t resultOffset) = 0;
-
-  // Specially used for dealing with the null bitmasks. If an encoding
-  // (currently only trivial, but may be more in the future) encodes null
-  // bitmask rather than regular values, it needs to call this function.
-  virtual std::unique_ptr<GpuDecode> makeStepNulls(
-      ColumnOp& op,
-      ReadStream& stream,
-      SplitStaging& staging,
-      ResultStaging& deviceStaging,
-      BufferId bufferId,
-      const NimbleEncoding& rootEncoding,
-      int32_t blockIdx,
-      int32_t offset = 0) {
-    return nullptr;
-  }
-
-  void* deviceEncodedDataPtr() const {
-    return deviceEncodedData_;
-  }
-
-  void** deviceEncodedDataPtrPtr() {
-    return &deviceEncodedData_;
-  }
-
-  facebook::velox::wave::WaveBufferPtr decodedResultBuffer() const {
-    return decodedResultBuffer_;
-  }
-
-  char* nulls() const {
-    return nulls_;
-  }
-
-  int32_t* numNonNull() const {
-    return numNonNull_;
-  }
-
- protected:
-  facebook::velox::TypePtr nimbleDataTypeToVeloxType(
-      facebook::wave::nimble::DataType nimbleDataType) const;
-
-  // Populates the shared members of GpuDecode of different encodings.
-  std::unique_ptr<GpuDecode> makeStepCommon(
-      ColumnOp& op,
-      const ColumnOp* previousFilter,
-      ReadStream& stream,
-      ResultStaging& deviceStaging,
-      int32_t blockIdx,
-      bool isRoot,
-      bool processFilter,
-      int32_t resultOffset);
-  void getDeviceEncodingInput(
-      SplitStaging& staging,
-      BufferId bufferId,
-      const NimbleEncoding& rootEncoding,
-      const void* hostPtr,
-      const void** devicePtr);
-
- protected:
-  std::string_view encodingData_;
-  facebook::wave::nimble::EncodingType encodingType_;
-  facebook::wave::nimble::DataType dataType_;
-  uint32_t numValues_;
-  std::vector<std::unique_ptr<NimbleEncoding>> children_;
-  void* deviceEncodedData_{nullptr};
-  facebook::velox::wave::WaveBufferPtr decodedResultBuffer_;
-  bool decoded_{false};
-  char* nulls_{nullptr};
-  bool stagedNulls_{false};
-  int32_t* numNonNull_{nullptr};
-
-  // true if this encoding encodes the null bitmask from Nullable
-  bool encodeNulls_{false};
-
- private:
-  NimbleEncoding* createChildEncodingByIndex(uint8_t childIndex);
-};
-
-// Dictionary encoding subclass
-class NimbleDictionaryEncoding : public NimbleEncoding {
- public:
-  explicit NimbleDictionaryEncoding(
-      std::string_view encodingData,
-      bool encodeNulls);
-
-  NimbleEncoding* alphabetEncoding() override;
-  NimbleEncoding* indicesEncoding() override;
-  std::unique_ptr<GpuDecode> makeStep(
-      ColumnOp& op,
-      const ColumnOp* previousFilter,
-      ReadStream& stream,
-      SplitStaging& staging,
-      ResultStaging& deviceStaging,
-      BufferId bufferId,
-      const NimbleEncoding& rootEncoding,
-      int32_t blockIdx,
-      int32_t resultOffset) override;
-};
-
-// Trivial encoding subclass
-class NimbleTrivialEncoding : public NimbleEncoding {
- public:
-  explicit NimbleTrivialEncoding(
-      std::string_view encodingData,
-      bool encodeNulls);
-
-  NimbleEncoding* lengthsEncoding() override;
-  std::unique_ptr<GpuDecode> makeStep(
-      ColumnOp& op,
-      const ColumnOp* previousFilter,
-      ReadStream& stream,
-      SplitStaging& staging,
-      ResultStaging& deviceStaging,
-      BufferId bufferId,
-      const NimbleEncoding& rootEncoding,
-      int32_t blockIdx,
-      int32_t offset = 0) override;
-  std::unique_ptr<GpuDecode> makeStepNulls(
-      ColumnOp& op,
-      ReadStream& stream,
-      SplitStaging& staging,
-      ResultStaging& deviceStaging,
-      BufferId bufferId,
-      const NimbleEncoding& rootEncoding,
-      int32_t blockIdx,
-      int32_t resultOffset) override;
-};
-
-// RLE encoding subclass
-class NimbleRLEEncoding : public NimbleEncoding {
- public:
-  explicit NimbleRLEEncoding(std::string_view encodingData, bool encodeNulls);
-
-  NimbleEncoding* runLengthsEncoding() override;
-  NimbleEncoding* runValuesEncoding() override;
-  std::unique_ptr<GpuDecode> makeStep(
-      ColumnOp& op,
-      const ColumnOp* previousFilter,
-      ReadStream& stream,
-      SplitStaging& staging,
-      ResultStaging& deviceStaging,
-      BufferId bufferId,
-      const NimbleEncoding& rootEncoding,
-      int32_t blockIdx,
-      int32_t resultOffset) override;
-};
-
-// Nullable encoding subclass
-class NimbleNullableEncoding : public NimbleEncoding {
- public:
-  explicit NimbleNullableEncoding(
-      std::string_view encodingData,
-      bool encodeNulls);
-
-  NimbleEncoding* nullsEncoding() override;
-  NimbleEncoding* nonNullsEncoding() override;
-  std::unique_ptr<GpuDecode> makeStep(
-      ColumnOp& op,
-      const ColumnOp* previousFilter,
-      ReadStream& stream,
-      SplitStaging& staging,
-      ResultStaging& deviceStaging,
-      BufferId bufferId,
-      const NimbleEncoding& rootEncoding,
-      int32_t blockIdx,
-      int32_t resultOffset) override;
-};
-
-class NimbleFilterEncoding : public NimbleEncoding {
- public:
-  explicit NimbleFilterEncoding(
-      facebook::wave::nimble::DataType dataType,
-      uint32_t numValues,
-      bool hasNulls);
-
-  std::unique_ptr<GpuDecode> makeStep(
-      ColumnOp& op,
-      const ColumnOp* previousFilter,
-      ReadStream& stream,
-      SplitStaging& staging,
-      ResultStaging& deviceStaging,
-      BufferId bufferId,
-      const NimbleEncoding& rootEncoding,
-      int32_t blockIdx,
-      int32_t resultOffset) override;
-};
-
-class NimbleChunk {
- public:
-  // Chunk layout: length + compression type + encoding data
-  explicit NimbleChunk(std::string_view chunkData);
-
-  // Get the raw chunk data including header
-  std::string_view chunkData() const {
-    return chunkData_;
-  }
-
-  static std::unique_ptr<NimbleEncoding> parseEncodingFromChunk(
-      std::string_view chunkData);
-
- private:
-  std::string_view chunkData_;
-};
-
-class NimbleChunkedStream {
- public:
-  NimbleChunkedStream(
-      velox::memory::MemoryPool& memoryPool,
-      std::string_view streamData);
-
-  bool hasNext();
-
-  NimbleChunk nextChunk();
-
- private:
-  std::string_view streamData_;
-  const char* pos_;
-};
-
-class NimbleStripe {
- public:
-  NimbleStripe(
-      std::vector<std::unique_ptr<NimbleChunkedStream>>&& in,
-      const std::shared_ptr<const dwio::common::TypeWithId>& type,
-      int32_t totalRows)
-      : typeWithId_(type), streams_(std::move(in)), totalRows_(totalRows) {}
-
-  NimbleChunkedStream* findStream(const dwio::common::TypeWithId& child) const {
-    for (auto i = 0; i < typeWithId_->size(); ++i) {
-      if (typeWithId_->childAt(i)->id() == child.id()) {
-        return streams_[i].get();
-      }
-    }
-    VELOX_FAIL("No such column {}", child.id());
-  }
-
-  int32_t numStreams() const {
-    return streams_.size();
-  }
-
-  int32_t totalRows() const {
-    return totalRows_;
-  }
-
- private:
-  std::shared_ptr<const dwio::common::TypeWithId> typeWithId_;
-  std::vector<std::unique_ptr<NimbleChunkedStream>> streams_;
-  int32_t totalRows_;
-};
-
-} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/nimble/NimbleFormatData.cpp b/velox/experimental/wave/dwio/nimble/NimbleFormatData.cpp
deleted file mode 100644
index 03082d943dd..00000000000
--- a/velox/experimental/wave/dwio/nimble/NimbleFormatData.cpp
+++ /dev/null
@@ -1,257 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/wave/dwio/nimble/NimbleFormatData.h"
-
-DECLARE_int32(wave_reader_rows_per_tb);
-
-namespace facebook::velox::wave {
-std::unique_ptr<FormatData> NimbleFormatParams::toFormatData(
-    const std::shared_ptr<const dwio::common::TypeWithId>& type,
-    const velox::common::ScanSpec& scanSpec,
-    OperandId operand) {
-  std::vector<NimbleChunkDecodePipeline> pipelines;
-  if (type->type()->kind() == TypeKind::ROW) {
-    return std::make_unique<NimbleFormatData>(
-        operand, stripe_.totalRows(), std::move(pipelines));
-  }
-  auto* stream = getChunkedStream(*type);
-  VELOX_CHECK_NOT_NULL(stream, "NimbleChunkedStream is null.");
-  while (stream->hasNext()) {
-    auto chunk = stream->nextChunk();
-    pipelines.emplace_back(
-        NimbleChunk::parseEncodingFromChunk(chunk.chunkData()));
-  }
-  int32_t totalRows = 0;
-  for (auto& pipeline : pipelines) {
-    totalRows += pipeline[pipeline.size() - 1].numValues();
-  }
-
-  VELOX_CHECK_EQ(totalRows, stripe_.totalRows());
-  return std::make_unique<NimbleFormatData>(
-      operand, totalRows, std::move(pipelines));
-}
-
-BufferId NimbleFormatData::stageNulls(
-    ResultStaging& deviceStaging,
-    SplitStaging& splitStaging) {
-  if (!hasNulls()) {
-    nullsStaged_ = true;
-    return kNotRegistered;
-  } else {
-    VELOX_NYI("Nulls are not supported yet");
-  }
-}
-
-void NimbleFormatData::griddize(
-    ColumnOp& op,
-    int32_t blockSize,
-    int32_t numBlocks,
-    ResultStaging& deviceStaging,
-    ResultStaging& resultStaging,
-    SplitStaging& staging,
-    DecodePrograms& programs,
-    ReadStream& stream) {
-  griddized_ = true;
-  return;
-}
-
-int32_t NimbleFormatData::maxDecodeLevel() const {
-  int32_t maxLevel = 0;
-  for (auto& pipeline : pipelines_) {
-    maxLevel = std::max(maxLevel, pipeline.maxLevel());
-  }
-  return maxLevel;
-}
-
-bool NimbleFormatData::hasMultiChunks() const {
-  return pipelines_.size() > 1;
-}
-
-void NimbleFormatData::startOp(
-    ColumnOp& op,
-    const ColumnOp* previousFilter,
-    ResultStaging& deviceStaging,
-    ResultStaging& resultStaging,
-    SplitStaging& splitStaging,
-    DecodePrograms& program,
-    ReadStream& stream) {
-  auto rowsPerBlock = FLAGS_wave_reader_rows_per_tb;
-  op.isFinal = true;
-
-  bool newSteps = false;
-  for (size_t i = 0; i < pipelines_.size(); ++i) {
-    auto& pipeline = pipelines_[i];
-    auto& rootEncoding = pipeline.rootEncoding();
-    BufferId id = kNoBufferId;
-    if (!streamStaged_) {
-      Staging staging(
-          rootEncoding.encodedDataPtr(),
-          rootEncoding.encodedData().size(),
-          common::Region{0, 0}); // TODO(bowenwu): revisit the
-                                 // region construction here
-      id = splitStaging.add(staging);
-      lastStagingId_ = splitStaging.id();
-      splitStaging.registerPointer(
-          id, rootEncoding.deviceEncodedDataPtrPtr(), true);
-    } else {
-      VELOX_CHECK_NOT_NULL(rootEncoding.deviceEncodedDataPtr());
-    }
-
-    while (auto encoding = pipeline.next(op.decodeLevel)) {
-      auto offset = encoding == &rootEncoding ? offsets_[i] : 0;
-      int32_t numBlocks =
-          bits::roundUp(encoding->numValues(), rowsPerBlock) / rowsPerBlock;
-      if (numBlocks > 1) {
-        VELOX_CHECK(griddized_);
-      }
-      VELOX_CHECK_LT(numBlocks, 256 * 256, "Overflow 16 bit block number");
-      for (auto blockIdx = 0; blockIdx < numBlocks; ++blockIdx) {
-        auto step = encoding->makeStep(
-            op,
-            previousFilter,
-            stream,
-            splitStaging,
-            deviceStaging,
-            id,
-            rootEncoding,
-            blockIdx,
-            offset);
-        if (!step) {
-          continue;
-        }
-        newSteps = true;
-        bool processFilter = step->filterKind != WaveFilterKind::kAlwaysTrue;
-        // To process filters in a cascading way, we must make sure the same
-        // thread block always process the same set of rows.
-        bool serialDispatch = processFilter && previousFilter;
-        if (serialDispatch) {
-          program.programs[blockIdx].push_back(std::move(step));
-        } else {
-          program.programs.emplace_back();
-          program.programs.back().push_back(std::move(step));
-        }
-      }
-    }
-    op.isFinal &= pipeline.finished();
-  }
-
-  auto readyForMultiChunkFiltering = [&]() {
-    // if this column does not have a filter or there is only one chunk, we can
-    // do the filtering in the same kernel as decoding
-    if (!op.reader->scanSpec().filter() || !op.hasMultiChunks) {
-      return false;
-    }
-
-    // Wait for all chunks to be decoded, which is indicated by no new decode
-    // steps are created
-    if (newSteps || !op.isFinal) {
-      op.isFinal = false;
-      return false;
-    }
-
-    return true;
-  };
-
-  // if this column has a filter or the table has a filter and has multiple
-  // chunks, we need to do the filter in a separate kernel launch
-  if (readyForMultiChunkFiltering()) {
-    auto numBlocks = bits::roundUp(totalRows_, rowsPerBlock) / rowsPerBlock;
-    VELOX_CHECK_LT(numBlocks, 256 * 256, "Overflow 16 bit block number");
-
-    program.programs.resize(numBlocks);
-
-    NimbleFilterEncoding filterEncoding(
-        pipelines_[0].rootEncoding().dataType(), totalRows_, hasNulls());
-
-    for (auto blockIdx = 0; blockIdx < numBlocks; ++blockIdx) {
-      auto step = filterEncoding.makeStep(
-          op,
-          previousFilter,
-          stream,
-          splitStaging,
-          deviceStaging,
-          -1,
-          filterEncoding,
-          blockIdx,
-          0);
-      // Multiple filters may be processed together in a cascading way, so we
-      // must make sure the same physical thread block always process the same
-      // set of rows across all columns that bear a filter in order to avoid
-      // dependency between thread blocks.
-      program.programs[blockIdx].push_back(std::move(step));
-    }
-  }
-
-  streamStaged_ = true;
-}
-
-// NimbleChunkDecodePipeline implementation
-NimbleChunkDecodePipeline::NimbleChunkDecodePipeline(
-    std::unique_ptr<NimbleEncoding> encoding)
-    : encoding_(std::move(encoding)) {
-  if (!encoding_) {
-    return;
-  }
-
-  std::queue<std::pair<NimbleEncoding*, int32_t>> queue;
-  queue.push({encoding_.get(), 0});
-
-  while (!queue.empty()) {
-    auto [node, level] = queue.front();
-    queue.pop();
-    pipeline_.push_back({node, level});
-    maxLevel_ = std::max(maxLevel_, level);
-
-    for (uint8_t i = 0; i < node->childrenCount(); ++i) {
-      queue.push({node->childAt(i), level + 1});
-    }
-  }
-
-  // currentLevel_ = maxLevel_;
-
-  std::reverse(pipeline_.begin(), pipeline_.end());
-
-  // Reorder pipeline to ensure all leaves come first
-  std::stable_partition(pipeline_.begin(), pipeline_.end(), [](auto& node) {
-    return node.first->childrenCount() == 0;
-  });
-
-  currentEncoding_ = pipeline_.begin();
-}
-
-NimbleEncoding* NimbleChunkDecodePipeline::next(int32_t level) {
-  if (finished() || !(currentEncoding_->first->isReadyToDecode())) {
-    for (auto it = currentEncoding_ - 1;
-         it >= pipeline_.begin() && !it->first->isDecoded();
-         --it) {
-      it->first->setDecoded();
-    }
-    return nullptr;
-  }
-
-  if (level != kAnyLevel && currentEncoding_->second != level) {
-    return nullptr;
-  }
-
-  return (currentEncoding_++)->first;
-}
-
-bool NimbleChunkDecodePipeline::finished() const {
-  return currentEncoding_ == pipeline_.end();
-}
-
-} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/nimble/NimbleFormatData.h b/velox/experimental/wave/dwio/nimble/NimbleFormatData.h
deleted file mode 100644
index b9f7a26c160..00000000000
--- a/velox/experimental/wave/dwio/nimble/NimbleFormatData.h
+++ /dev/null
@@ -1,161 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include "velox/dwio/common/ScanSpec.h"
-#include "velox/dwio/common/Statistics.h"
-#include "velox/dwio/common/TypeWithId.h"
-#include "velox/experimental/wave/dwio/ColumnReader.h"
-#include "velox/experimental/wave/dwio/FormatData.h"
-#include "velox/experimental/wave/dwio/decode/DecodeStep.h"
-#include "velox/experimental/wave/dwio/nimble/NimbleFileFormat.h"
-#include "velox/experimental/wave/vector/Operand.h"
-
-namespace facebook::velox::wave {
-
-class NimbleChunkDecodePipeline {
-  constexpr static int32_t kAnyLevel = -1;
-
- public:
-  NimbleChunkDecodePipeline(std::unique_ptr<NimbleEncoding> encoding);
-  NimbleChunkDecodePipeline(NimbleChunk const& chunk);
-  NimbleEncoding* next(int32_t level = kAnyLevel);
-  bool finished() const;
-  uint32_t size() const {
-    return pipeline_.size();
-  }
-  NimbleEncoding& operator[](uint32_t index) {
-    return *(pipeline_[index].first);
-  }
-  NimbleEncoding& rootEncoding() const {
-    return *encoding_;
-  }
-  int32_t maxLevel() const {
-    return maxLevel_;
-  }
-
- private:
-  std::unique_ptr<NimbleEncoding> encoding_;
-  std::vector<std::pair<NimbleEncoding*, int32_t>> pipeline_;
-  typename decltype(pipeline_)::iterator currentEncoding_;
-  int32_t maxLevel_{0};
-  // int32_t currentLevel_{0};
-};
-
-class NimbleFormatData : public wave::FormatData {
- public:
-  static constexpr int32_t kNotRegistered = -1;
-
-  NimbleFormatData(
-      OperandId operand,
-      int32_t totalRows,
-      std::vector<NimbleChunkDecodePipeline>&& pipelines)
-      : operand_(operand),
-        totalRows_(totalRows),
-        pipelines_(std::move(pipelines)) {
-    offsets_.resize(pipelines_.size());
-    int32_t sum = 0;
-    for (size_t i = 0; i < pipelines_.size(); ++i) {
-      offsets_[i] = sum;
-      sum += pipelines_[i].rootEncoding().numValues();
-    }
-  }
-
-  bool hasNulls() const override {
-    for (int i = 0; i < pipelines_.size(); i++) {
-      auto& pipeline = pipelines_[i];
-      if (pipeline.rootEncoding().isNullableEncoding()) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  int32_t totalRows() const override {
-    return totalRows_;
-  }
-
-  void newBatch(int32_t startRow) override {
-    currentRow_ = startRow;
-    queued_ = false;
-  }
-
-  int32_t maxDecodeLevel() const override;
-  bool hasMultiChunks() const override;
-
-  void griddize(
-      ColumnOp& op,
-      int32_t blockSize,
-      int32_t numBlocks,
-      ResultStaging& deviceStaging,
-      ResultStaging& resultStaging,
-      SplitStaging& staging,
-      DecodePrograms& programs,
-      ReadStream& stream) override;
-
-  void startOp(
-      ColumnOp& op,
-      const ColumnOp* previousFilter,
-      ResultStaging& deviceStaging,
-      ResultStaging& resultStaging,
-      SplitStaging& staging,
-      DecodePrograms& program,
-      ReadStream& stream) override;
-
- private:
-  // Stages movement of nulls to device if any. Returns the id of the buffer or
-  // kNotRegisterd.
-  int32_t stageNulls(ResultStaging& deviceStaging, SplitStaging& splitStaging);
-
-  const OperandId operand_;
-  bool queued_{false};
-  int32_t totalRows_{0};
-  bool nullsStaged_{false};
-  bool streamStaged_{false};
-
-  const NimbleEncoding* encoding_;
-  std::vector<NimbleChunkDecodePipeline> pipelines_;
-  std::vector<int32_t> offsets_;
-};
-
-class NimbleFormatParams : public wave::FormatParams {
- public:
-  NimbleFormatParams(
-      memory::MemoryPool& pool,
-      dwio::common::ColumnReaderStatistics& stats,
-      NimbleStripe& stripe)
-      : FormatParams(pool, stats), stripe_(stripe) {}
-
-  std::unique_ptr<FormatData> toFormatData(
-      const std::shared_ptr<const dwio::common::TypeWithId>& type,
-      const velox::common::ScanSpec& scanSpec,
-      OperandId operand) override;
-
-  NimbleChunkedStream* getChunkedStream(
-      const dwio::common::TypeWithId& child) const {
-    return stripe_.findStream(child);
-  }
-
-  NimbleStripe& stripe() {
-    return stripe_;
-  }
-
- private:
-  NimbleStripe& stripe_;
-};
-
-} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/nimble/SelectiveStructColumnReader.cpp b/velox/experimental/wave/dwio/nimble/SelectiveStructColumnReader.cpp
deleted file mode 100644
index ee59792249c..00000000000
--- a/velox/experimental/wave/dwio/nimble/SelectiveStructColumnReader.cpp
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/wave/dwio/nimble/SelectiveStructColumnReader.h"
-#include "velox/experimental/wave/dwio/ColumnReader.h"
-#include "velox/experimental/wave/dwio/StructColumnReader.h"
-#include "velox/experimental/wave/dwio/nimble/NimbleFormatData.h"
-
-namespace facebook::velox::wave::nimble {
-
-SelectiveStructColumnReader::SelectiveStructColumnReader(
-    const TypePtr& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
-    NimbleFormatParams& params,
-    common::ScanSpec& scanSpec,
-    std::vector<std::unique_ptr<AbstractOperand>>&& operands,
-    bool isRoot)
-    : StructColumnReader(
-          requestedType,
-          fileType,
-          operands[0].get(),
-          params,
-          scanSpec,
-          isRoot),
-      operands_(std::move(operands)) {
-  // A reader tree may be constructed while the ScanSpec is being used
-  // for another read. This happens when the next stripe is being
-  // prepared while the previous one is reading.
-  auto& childSpecs = scanSpec.stableChildren();
-  for (auto i = 0; i < childSpecs.size(); ++i) {
-    auto childSpec = childSpecs[i];
-    if (isChildConstant(*childSpec)) {
-      VELOX_NYI();
-      continue;
-    }
-    auto childFileType = fileType_->childByName(childSpec->fieldName());
-    auto childRequestedType = requestedType_->as<TypeKind::ROW>().findChild(
-        folly::StringPiece(childSpec->fieldName()));
-    auto childParams = NimbleFormatParams(
-        params.pool(), params.runtimeStatistics(), params.stripe());
-
-    auto childOperand = std::make_unique<AbstractOperand>(
-        i + 1, childRequestedType, "c" + std::to_string(i));
-
-    addChild(NimbleFormatReader::build(
-        childRequestedType,
-        childFileType,
-        params,
-        *childSpec /*, path, defines*/,
-        childOperand.get()));
-    childSpec->setSubscript(children_.size() - 1);
-    operands_.push_back(std::move(childOperand));
-  }
-}
-
-// static
-std::unique_ptr<ColumnReader> NimbleFormatReader::build(
-    const TypePtr& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
-    NimbleFormatParams& params,
-    common::ScanSpec& scanSpec,
-    AbstractOperand* operand,
-    bool isRoot) {
-  VELOX_CHECK(isRoot || operand != nullptr, "Operand is null.");
-  std::vector<std::unique_ptr<AbstractOperand>> operands;
-  operands.push_back(nullptr); // root does not need an operand
-  switch (fileType->type()->kind()) {
-    case TypeKind::INTEGER:
-    case TypeKind::BIGINT:
-    case TypeKind::DOUBLE:
-    case TypeKind::REAL:
-      return std::make_unique<ColumnReader>(
-          requestedType, fileType, operand, params, scanSpec);
-
-    case TypeKind::ROW:
-      return std::make_unique<SelectiveStructColumnReader>(
-          requestedType,
-          fileType,
-          params,
-          scanSpec,
-          std::move(operands),
-          isRoot);
-    default:
-      VELOX_UNREACHABLE();
-  }
-}
-} // namespace facebook::velox::wave::nimble
diff --git a/velox/experimental/wave/dwio/nimble/SelectiveStructColumnReader.h b/velox/experimental/wave/dwio/nimble/SelectiveStructColumnReader.h
deleted file mode 100644
index ca917a5bad0..00000000000
--- a/velox/experimental/wave/dwio/nimble/SelectiveStructColumnReader.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include "velox/experimental/wave/dwio/ColumnReader.h"
-#include "velox/experimental/wave/dwio/StructColumnReader.h"
-#include "velox/experimental/wave/dwio/nimble/NimbleFormatData.h"
-
-namespace facebook::velox::wave::nimble {
-
-class SelectiveStructColumnReader : public StructColumnReader {
- public:
-  SelectiveStructColumnReader(
-      const TypePtr& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
-      NimbleFormatParams& params,
-      common::ScanSpec& scanSpec,
-      std::vector<std::unique_ptr<AbstractOperand>>&& operands,
-      bool isRoot);
-
-  const std::vector<std::unique_ptr<AbstractOperand>>* getOperands() const {
-    return &operands_;
-  }
-
- private:
-  std::vector<std::unique_ptr<AbstractOperand>> operands_;
-};
-
-class NimbleFormatReader {
- public:
-  static std::unique_ptr<ColumnReader> build(
-      const TypePtr& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
-      NimbleFormatParams& params,
-      common::ScanSpec& scanSpec,
-      AbstractOperand* operand,
-      bool isRoot = false);
-};
-
-} // namespace facebook::velox::wave::nimble
diff --git a/velox/experimental/wave/dwio/nimble/Types.h b/velox/experimental/wave/dwio/nimble/Types.h
deleted file mode 100644
index 971fa22d14c..00000000000
--- a/velox/experimental/wave/dwio/nimble/Types.h
+++ /dev/null
@@ -1,312 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <memory>
-#include <string>
-#include <string_view>
-#include <variant>
-
-// Single file containing all the types and enums in nimble, as well as some
-// templates for mapping between those types and C++ types.
-//
-// A note on types: For all of our enum classes, we assume the number of
-// types will stay small, so that each one is representable by a single byte.
-// Don't violate this!
-
-namespace facebook::wave::nimble {
-
-using VariantType = std::variant<
-    int8_t,
-    uint8_t,
-    int16_t,
-    uint16_t,
-    int32_t,
-    uint32_t,
-    int64_t,
-    uint64_t,
-    float,
-    double,
-    bool,
-    std::string>;
-
-template <typename T>
-class Variant {
- public:
-  static void set(VariantType& target, T source) {
-    target = source;
-  }
-
-  static T get(VariantType& source) {
-    return std::get<T>(source);
-  }
-};
-
-template <>
-void Variant<std::string_view>::set(
-    VariantType& target,
-    std::string_view source);
-
-template <>
-std::string_view Variant<std::string_view>::get(VariantType& source);
-
-enum class EncodingType {
-  // Native encoding for numerics, simple packed chars with offsets for strings,
-  // bitpacked for bools. All data types supported.
-  Trivial = 0,
-  // Run length encoded data. The runs lengths are bit packed, and the run
-  // values are encoded like the trivial encoding. All data types supported.
-  RLE = 1,
-  // Data with the uniques encoded in a dictionary and the indices into that
-  // dictionary. All data types except bools supported.
-  Dictionary = 2,
-  // Stores integer types packed into a fixed number of bits (namely, the
-  // smallest required to represent the largest element). Currently only
-  // works with non-negative values, we may add ZigZag encoding later.
-  FixedBitWidth = 3,
-  // Stores nullable data using a 'sentinel' value to represent nulls in a
-  // single non-nullable encoding.
-  Sentinel = 4,
-  // Stores nullable data by wrapping one subencoding representing the non-nulls
-  // with another subencoding marking which rows are null.
-  Nullable = 5,
-  // Stores indices to set (or unset) bits. Useful for storing sparse data, such
-  // as when only a few rows in a encoding are non-null.
-  SparseBool = 6,
-  // Stores integer types via varint encoding. Currently only
-  // works with non-negative values, we may add ZigZag encoding later.
-  Varint = 7,
-  // Stores integer types with a delta encoding. Currently only supports
-  // positive deltas.
-  Delta = 8,
-  // Stores constant (i.e. only 1 unique value) data.
-  Constant = 9,
-  // Stores 'mainly constant' data, i.e. treats one particular value as special,
-  // using a bool child vector to store whether each row is that special value,
-  // and stores the non-special values as a separate encoding.
-  MainlyConstant = 10,
-};
-std::string toString(EncodingType encodingType);
-std::ostream& operator<<(std::ostream& out, EncodingType encodingType);
-
-enum class DataType : uint8_t {
-  Undefined = 0,
-  Int8 = 1,
-  Uint8 = 2,
-  Int16 = 3,
-  Uint16 = 4,
-  Int32 = 5,
-  Uint32 = 6,
-  Int64 = 7,
-  Uint64 = 8,
-  Float = 9,
-  Double = 10,
-  Bool = 11,
-  String = 12,
-};
-
-std::string toString(DataType dataType);
-std::ostream& operator<<(std::ostream& out, DataType dataType);
-
-// General string compression. Make sure values here match those in the footer
-// specification
-enum class CompressionType : uint8_t {
-  Uncompressed = 0,
-  // Zstd doesn't require us to externally store level or any other info.
-  Zstd = 1,
-  MetaInternal = 2,
-};
-
-std::string toString(CompressionType compressionType);
-std::ostream& operator<<(std::ostream& out, CompressionType compressionType);
-
-enum class ChecksumType : uint8_t { XXH3_64 = 0 };
-
-std::string toString(ChecksumType type);
-
-// A CompresionType and any type-specific configuration params.
-struct CompressionParams {
-  CompressionType type;
-
-  // For zstd.
-  int zstdLevel = 1;
-};
-
-// Parameters controlling the search for the optimal encoding on a data set.
-struct OptimalSearchParams {
-  // Whether recursive structures are allowed. E.g. a encoding may use another
-  // encoding as a subencoding, and may use the encoding factory to find the
-  // best subencoding. We must terminate the recursion at some depth. With the
-  // default of 1 allowed recursion the top level encoding may use recursive
-  // encodings, but its subencodings may not.
-  int allowedRecursions = 1;
-
-  // Whether to log debug info during the search (such as estimated sizes of
-  // each encoding considered, etc.);
-  bool logSearch = false;
-
-  // Helps align log messages when log_search=true to help distinguish
-  // subencoding log messages from higher-level ones.
-  int logDepth = 0;
-
-  // Entropy encodings, such as HuffmanEncoding, can be much more compact than
-  // others, but are quite a bit slower. However, compared to applying a general
-  // string compression on top of another encoding they are relatively fast.
-  // In general the entropy encodings will also be smaller than GSC on top of
-  // a non-entropy encoding.
-  bool enableEntropyEncodings = true;
-
-  // For some dimension encodings that will frequently be grouped by, we may
-  // want to force dictionary enabled encodings so grouping by that can will be
-  // fast.
-  bool requireDictionaryEnabled = false;
-};
-
-template <typename T>
-struct TypeTraits {};
-
-template <>
-struct TypeTraits<int8_t> {
-  using physicalType = uint8_t;
-  using sumType = int64_t;
-  static constexpr DataType dataType = DataType::Int8;
-};
-
-template <>
-struct TypeTraits<uint8_t> {
-  using physicalType = uint8_t;
-  using sumType = uint64_t;
-  static constexpr DataType dataType = DataType::Uint8;
-};
-
-template <>
-struct TypeTraits<int16_t> {
-  using physicalType = uint16_t;
-  using sumType = int64_t;
-  static constexpr DataType dataType = DataType::Int16;
-};
-
-template <>
-struct TypeTraits<uint16_t> {
-  using physicalType = uint16_t;
-  using sumType = uint64_t;
-  static constexpr DataType dataType = DataType::Uint16;
-};
-
-template <>
-struct TypeTraits<int32_t> {
-  using physicalType = uint32_t;
-  using sumType = int64_t;
-  static constexpr DataType dataType = DataType::Int32;
-};
-
-template <>
-struct TypeTraits<uint32_t> {
-  using physicalType = uint32_t;
-  using sumType = uint64_t;
-  static constexpr DataType dataType = DataType::Uint32;
-};
-
-template <>
-struct TypeTraits<int64_t> {
-  using physicalType = uint64_t;
-  using sumType = int64_t;
-  static constexpr DataType dataType = DataType::Int64;
-};
-
-template <>
-struct TypeTraits<uint64_t> {
-  using physicalType = uint64_t;
-  using sumType = uint64_t;
-  static constexpr DataType dataType = DataType::Uint64;
-};
-
-template <>
-struct TypeTraits<float> {
-  using physicalType = uint32_t;
-  using sumType = double;
-  static constexpr DataType dataType = DataType::Float;
-};
-
-template <>
-struct TypeTraits<double> {
-  using physicalType = uint64_t;
-  using sumType = double;
-  static constexpr DataType dataType = DataType::Double;
-};
-
-template <>
-struct TypeTraits<bool> {
-  using physicalType = bool;
-  static constexpr DataType dataType = DataType::Bool;
-};
-
-template <>
-struct TypeTraits<std::string> {
-  using physicalType = std::string;
-  static constexpr DataType dataType = DataType::String;
-};
-
-template <>
-struct TypeTraits<std::string_view> {
-  using physicalType = std::string_view;
-  static constexpr DataType dataType = DataType::String;
-};
-
-template <typename T>
-constexpr bool isFourByteIntegralType() {
-  return std::is_same_v<T, int32_t> || std::is_same_v<T, uint32_t>;
-}
-
-template <typename T>
-constexpr bool isSignedIntegralType() {
-  return std::is_same_v<T, int32_t> || std::is_same_v<T, int64_t> ||
-      std::is_same_v<T, int8_t> || std::is_same_v<T, int16_t>;
-}
-
-template <typename T>
-constexpr bool isUnsignedIntegralType() {
-  return std::is_same_v<T, uint32_t> || std::is_same_v<T, uint64_t> ||
-      std::is_same_v<T, uint8_t> || std::is_same_v<T, uint16_t>;
-}
-
-template <typename T>
-constexpr bool isIntegralType() {
-  return isSignedIntegralType<T>() || isUnsignedIntegralType<T>();
-}
-
-template <typename T>
-constexpr bool isFloatingPointType() {
-  return std::is_same_v<T, float> || std::is_same_v<T, double>;
-}
-
-template <typename T>
-constexpr bool isNumericType() {
-  return isIntegralType<T>() || isFloatingPointType<T>();
-}
-
-template <typename T>
-constexpr bool isStringType() {
-  return std::is_same_v<T, std::string_view> || std::is_same_v<T, std::string>;
-}
-
-template <typename T>
-constexpr bool isBoolType() {
-  return std::is_same_v<T, bool>;
-}
-
-} // namespace facebook::wave::nimble
diff --git a/velox/experimental/wave/dwio/nimble/fuzzer/NimbleReaderFuzzer.cpp b/velox/experimental/wave/dwio/nimble/fuzzer/NimbleReaderFuzzer.cpp
deleted file mode 100644
index 37ed8f75cc6..00000000000
--- a/velox/experimental/wave/dwio/nimble/fuzzer/NimbleReaderFuzzer.cpp
+++ /dev/null
@@ -1,402 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/wave/dwio/nimble/fuzzer/NimbleReaderFuzzer.h"
-#include <cstddef>
-#include "dwio/nimble/encodings/EncodingSelectionPolicy.h"
-#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
-#include "velox/experimental/wave/dwio/nimble/tests/NimbleReaderTestUtil.h"
-#include "velox/type/Filter.h"
-
-DEFINE_int32(steps, 10, "Number of plans to generate and test.");
-
-DEFINE_int32(
-    duration_sec,
-    0,
-    "For how long it should run (in seconds). If zero, "
-    "it executes exactly --steps iterations and exits.");
-
-namespace facebook::velox::wave {
-namespace {
-using namespace facebook::nimble;
-
-struct ChunkSpec {
-  TypePtr type;
-  int32_t numValues;
-  double nullRatio;
-};
-
-struct StreamSpec {
-  std::string name;
-  std::vector<ChunkSpec> chunks;
-  double nullRatio;
-
-  vector_size_t numValues() const {
-    vector_size_t numValues = 0;
-    for (const auto& chunk : chunks) {
-      numValues += chunk.numValues;
-    }
-    return numValues;
-  }
-
-  TypePtr type() const {
-    return chunks.empty() ? nullptr : chunks[0].type;
-  }
-};
-
-struct StripeSpec {
-  std::vector<StreamSpec> streams;
-  std::vector<FilterSpec> filters;
-
-  void check() const {
-    for (const auto& stream : streams) {
-      VELOX_CHECK_EQ(stream.numValues(), numValues());
-    }
-  }
-
-  vector_size_t numValues() const {
-    return streams.empty() ? 0 : streams[0].numValues();
-  }
-};
-
-class NimbleReaderFuzzer {
- public:
-  NimbleReaderFuzzer(
-      size_t initialSeed,
-      NimbleReaderFuzzerOptions opts,
-      std::unique_ptr<exec::test::ReferenceQueryRunner> referenceQueryRunner);
-
-  void go();
-
-  void setOptions(const NimbleReaderFuzzerOptions& options) {
-    opts_ = options;
-  }
-
-  const NimbleReaderFuzzerOptions& getOptions() {
-    return opts_;
-  }
-
-  NimbleReaderFuzzerOptions& getMutableOptions() {
-    return opts_;
-  }
-
- private:
-  static VectorFuzzer::Options getFuzzerOptions() {
-    VectorFuzzer::Options opts;
-    opts.allowSlice = false;
-    opts.allowConstantVector = false;
-    opts.allowDictionaryVector = false;
-    return opts;
-  }
-
-  void seed(size_t seed) {
-    currentSeed_ = seed;
-    vectorFuzzer_.reSeed(seed);
-    rng_.seed(currentSeed_);
-  }
-
-  void reSeed() {
-    seed(rng_());
-  }
-
-  void run();
-
-  VectorPtr makeChunk(const ChunkSpec& spec);
-  std::vector<VectorPtr> makeStream(const StreamSpec& spec);
-  std::vector<std::vector<VectorPtr>> makeStripe(const StripeSpec& spec);
-  StripeSpec generateStripeSpec();
-  template <typename T>
-  std::shared_ptr<common::Filter> generateOneFilter(VectorPtr input);
-  std::vector<FilterSpec> generateFilters(RowVectorPtr input);
-  std::vector<std::pair<EncodingType, float>> generateReadFactors();
-
-  int32_t randInt(int32_t min, int32_t max) {
-    return boost::random::uniform_int_distribution<int32_t>(min, max)(rng_);
-  }
-
-  double randDouble01() {
-    return boost::random::uniform_01<double>()(rng_);
-  }
-
-  FuzzerGenerator rng_;
-  size_t currentSeed_{0};
-
-  std::shared_ptr<memory::MemoryPool> rootPool_{
-      memory::memoryManager()->addRootPool(
-          "nimbleReaderFuzzer",
-          memory::kMaxMemory,
-          memory::MemoryReclaimer::create())};
-  std::shared_ptr<memory::MemoryPool> pool_{rootPool_->addLeafChild(
-      "nimbleReaderFuzzerLeaf",
-      true,
-      memory::MemoryReclaimer::create())};
-
-  VectorFuzzer vectorFuzzer_;
-  NimbleReaderVerifier verifier_;
-
-  struct Stats {
-    // The total number of iterations tested.
-    size_t numIterations{0};
-
-    size_t numStreams{0};
-    size_t numNullables{0};
-    size_t numChunks{0};
-    size_t numFilters{0};
-    size_t numFiltersKeepValues{0};
-    size_t numFiltersWithNullsAllowed{0};
-    double selectivity{0.0};
-
-    std::string toString() const {
-      return fmt::format(
-          "\nTotal iterations tested: {}\n"
-          "Avg. number of streams: {}\n"
-          "Avg. number of nullables: {}\n"
-          "Avg. number of chunks: {}\n"
-          "Avg. number of filters: {}\n"
-          "Avg. number of filters with keep values: {}\n"
-          "Avg. number of filters with nulls allowed: {}\n"
-          "Avg. selectivity: {}\n",
-          numIterations,
-          numStreams / (double)numIterations,
-          numNullables / (double)numIterations,
-          numChunks / (double)numIterations,
-          numFilters / (double)numIterations,
-          numFiltersKeepValues / (double)numIterations,
-          numFiltersWithNullsAllowed / (double)numIterations,
-          selectivity / numIterations);
-    }
-
-    void add(
-        const StripeSpec& stripe,
-        const std::vector<FilterSpec>& filters,
-        RowVectorPtr output) {
-      numStreams += stripe.streams.size();
-      std::for_each(
-          stripe.streams.begin(),
-          stripe.streams.end(),
-          [&](const auto& stream) {
-            numNullables += stream.nullRatio > 0 ? 1 : 0;
-            numChunks += stream.chunks.size();
-          });
-
-      numFilters += filters.size();
-      std::for_each(filters.begin(), filters.end(), [&](const auto& filter) {
-        numFiltersKeepValues += filter.keepValues ? 1 : 0;
-        numFiltersWithNullsAllowed += filter.filter->nullAllowed() ? 1 : 0;
-      });
-
-      if (output) {
-        selectivity += output->size() / (double)stripe.numValues();
-      }
-    }
-  };
-
-  Stats stats_;
-  NimbleReaderFuzzerOptions opts_;
-};
-
-bool isDone(
-    size_t i,
-    std::chrono::time_point<std::chrono::system_clock> startTime) {
-  if (FLAGS_duration_sec > 0) {
-    std::chrono::duration<double> elapsed =
-        std::chrono::system_clock::now() - startTime;
-    return elapsed.count() >= FLAGS_duration_sec;
-  }
-  return i >= FLAGS_steps;
-}
-
-NimbleReaderFuzzer::NimbleReaderFuzzer(
-    size_t initialSeed,
-    NimbleReaderFuzzerOptions opts,
-    std::unique_ptr<exec::test::ReferenceQueryRunner> referenceQueryRunner)
-    : vectorFuzzer_{getFuzzerOptions(), pool_.get()},
-      verifier_{std::move(referenceQueryRunner)},
-      opts_(opts) {
-  seed(initialSeed);
-}
-
-void NimbleReaderFuzzer::go() {
-  VELOX_USER_CHECK(
-      FLAGS_steps > 0 || FLAGS_duration_sec > 0,
-      "Either --steps or --duration_sec needs to be greater than zero.");
-
-  const auto startTime = std::chrono::system_clock::now();
-
-  while (!isDone(stats_.numIterations, startTime)) {
-    LOG(INFO) << "==============================> Started iteration "
-              << stats_.numIterations << " (seed: " << currentSeed_ << ")";
-
-    run();
-
-    LOG(INFO) << "==============================> Done with iteration "
-              << stats_.numIterations;
-
-    reSeed();
-    ++stats_.numIterations;
-  }
-  LOG(INFO) << stats_.toString();
-}
-
-VectorPtr NimbleReaderFuzzer::makeChunk(const ChunkSpec& spec) {
-  auto& option = vectorFuzzer_.getMutableOptions();
-  option.vectorSize = spec.numValues;
-  option.nullRatio = spec.nullRatio;
-  auto vector = vectorFuzzer_.fuzzFlat(spec.type);
-  auto tempType = vector->type();
-  return std::make_shared<RowVector>(
-      vector->pool(),
-      ROW({""}, {tempType}),
-      BufferPtr{nullptr},
-      vector->size(),
-      std::vector<VectorPtr>{vector});
-}
-
-std::vector<VectorPtr> NimbleReaderFuzzer::makeStream(const StreamSpec& spec) {
-  std::vector<VectorPtr> chunkVectors;
-  for (const auto& chunkSpec : spec.chunks) {
-    chunkVectors.push_back(makeChunk(chunkSpec));
-  }
-  return chunkVectors;
-}
-
-std::vector<std::vector<VectorPtr>> NimbleReaderFuzzer::makeStripe(
-    const StripeSpec& spec) {
-  std::vector<std::vector<VectorPtr>> chunkVectorGroups;
-  for (const auto& streamSpec : spec.streams) {
-    chunkVectorGroups.push_back(makeStream(streamSpec));
-  }
-  return chunkVectorGroups;
-}
-
-template <typename T>
-std::shared_ptr<common::Filter> NimbleReaderFuzzer::generateOneFilter(
-    VectorPtr input) {
-  vector_size_t endPointIdx1 = randInt(0, input->size() - 1);
-  vector_size_t endPointIdx2 = randInt(0, input->size() - 1);
-  bool nullAllowed = vectorFuzzer_.coinToss(opts_.nullAllowedProbability);
-  auto endPoint1 = input->as<SimpleVector<T>>()->valueAt(endPointIdx1);
-  auto endPoint2 = input->as<SimpleVector<T>>()->valueAt(endPointIdx2);
-  auto lower = std::min(endPoint1, endPoint2);
-  auto upper = std::max(endPoint1, endPoint2);
-  return std::make_shared<common::BigintRange>(lower, upper, nullAllowed);
-}
-
-std::vector<FilterSpec> NimbleReaderFuzzer::generateFilters(
-    RowVectorPtr input) {
-  std::vector<FilterSpec> filters;
-  bool hasFilter = vectorFuzzer_.coinToss(opts_.hasFilterProbability);
-  if (!hasFilter) {
-    return filters;
-  }
-  for (int i = 0; i < input->childrenSize(); i++) {
-    if (!vectorFuzzer_.coinToss(opts_.isFilterProbability)) {
-      continue;
-    }
-    auto kind = input->childAt(i)->typeKind();
-    if (kind != TypeKind::BIGINT) {
-      continue;
-    }
-    filters.emplace_back();
-    auto& filterSpec = filters.back();
-    filterSpec.name = input->type()->asRow().nameOf(i);
-    filterSpec.keepValues =
-        vectorFuzzer_.coinToss(opts_.filterKeepValuesProbability);
-    switch (kind) {
-      case TypeKind::BIGINT:
-        filterSpec.filter = generateOneFilter<int64_t>(input->childAt(i));
-        break;
-      case TypeKind::INTEGER:
-        filterSpec.filter = generateOneFilter<int32_t>(input->childAt(i));
-        break;
-      default:
-        VELOX_UNREACHABLE();
-    }
-  }
-
-  return filters;
-}
-
-StripeSpec NimbleReaderFuzzer::generateStripeSpec() {
-  StripeSpec spec;
-  const auto numStreams = randInt(opts_.minNumStreams, opts_.maxNumStreams);
-  const auto numValues = randInt(opts_.minNumValues, opts_.maxNumValues);
-  spec.streams.resize(numStreams);
-  for (size_t i = 0; i < numStreams; i++) {
-    auto& stream = spec.streams[i];
-    stream.name = "c" + std::to_string(i);
-    auto type = vectorFuzzer_.randType(opts_.types, 1);
-    auto numChunks = randInt(opts_.minNumChunks, opts_.maxNumChunks);
-    stream.chunks.resize(numChunks);
-    bool hasNulls = vectorFuzzer_.coinToss(opts_.hasNullProbability);
-    stream.nullRatio = hasNulls ? randDouble01() : 0;
-
-    size_t numValuesLeft = numValues;
-    for (size_t nthChunk = 0; nthChunk < numChunks; nthChunk++) {
-      auto& chunk = stream.chunks[nthChunk];
-      chunk.type = type;
-      chunk.nullRatio = stream.nullRatio;
-
-      if (nthChunk == numChunks - 1) {
-        chunk.numValues = numValuesLeft;
-      } else {
-        chunk.numValues = randInt(
-            opts_.minChunkSize,
-            numValuesLeft - (numChunks - nthChunk - 1) * opts_.minChunkSize);
-      }
-      numValuesLeft -= chunk.numValues;
-    }
-  }
-
-  spec.check();
-  return spec;
-}
-
-std::vector<std::pair<EncodingType, float>>
-NimbleReaderFuzzer::generateReadFactors() {
-  return {
-      {EncodingType::Nullable, 1.0}, // This enables both nullable and trivial
-  };
-}
-
-void NimbleReaderFuzzer::run() {
-  auto stripeSpec = generateStripeSpec();
-  auto stripe = makeStripe(stripeSpec);
-
-  auto streamLoaders = writeToNimbleAndGetStreamLoaders(
-      pool_.get(),
-      stripe,
-      generateReadFactors(),
-      CompressionOptions{.compressionAcceptRatio = 0.0});
-
-  auto input = createInputFromChunkVectorGroups(stripe);
-  auto filterSpecs = generateFilters(input);
-
-  TestNimbleReader reader(pool_.get(), input, streamLoaders, filterSpecs);
-  auto testResult = reader.read();
-
-  stats_.add(stripeSpec, filterSpecs, testResult);
-  verifier_.verify(input, filterSpecs, testResult);
-}
-} // namespace
-
-void nimbleReaderFuzzer(
-    size_t seed,
-    NimbleReaderFuzzerOptions opts,
-    std::unique_ptr<exec::test::ReferenceQueryRunner> referenceQueryRunner) {
-  NimbleReaderFuzzer(seed, opts, std::move(referenceQueryRunner)).go();
-}
-} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/nimble/fuzzer/NimbleReaderFuzzerRunner.cpp b/velox/experimental/wave/dwio/nimble/fuzzer/NimbleReaderFuzzerRunner.cpp
deleted file mode 100644
index 0991804e832..00000000000
--- a/velox/experimental/wave/dwio/nimble/fuzzer/NimbleReaderFuzzerRunner.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <folly/init/Init.h>
-#include <gflags/gflags.h>
-#include "velox/exec/fuzzer/FuzzerUtil.h"
-#include "velox/experimental/wave/dwio/nimble/fuzzer/NimbleReaderFuzzer.h"
-
-DEFINE_int64(
-    seed,
-    0,
-    "Initial seed for random number generator used to reproduce previous "
-    "results (0 means start with random seed).");
-
-DECLARE_int32(steps);
-DECLARE_int32(duration_sec);
-
-DEFINE_int64(allocator_capacity, 8L << 30, "Allocator capacity in bytes.");
-
-DEFINE_int64(arbitrator_capacity, 6L << 30, "Arbitrator capacity in bytes.");
-
-using namespace facebook::velox::exec;
-
-int main(int argc, char** argv) {
-  folly::Init init(&argc, &argv);
-  test::setupMemory(FLAGS_allocator_capacity, FLAGS_arbitrator_capacity);
-  const size_t initialSeed = FLAGS_seed == 0 ? std::time(nullptr) : FLAGS_seed;
-  facebook::velox::wave::NimbleReaderFuzzerOptions options;
-  facebook::velox::wave::nimbleReaderFuzzer(initialSeed, options, nullptr);
-}
diff --git a/velox/experimental/wave/dwio/nimble/tests/NimbleReaderFuzzerTest.cpp b/velox/experimental/wave/dwio/nimble/tests/NimbleReaderFuzzerTest.cpp
deleted file mode 100644
index 50a9acb876f..00000000000
--- a/velox/experimental/wave/dwio/nimble/tests/NimbleReaderFuzzerTest.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <cuda_runtime.h> // @manual
-
-#include "velox/common/base/tests/GTestUtils.h"
-#include "velox/experimental/wave/dwio/nimble/fuzzer/NimbleReaderFuzzer.h"
-
-DECLARE_int32(steps);
-DECLARE_int32(duration_sec);
-
-namespace facebook::velox::wave {
-struct NimbleReaderFuzzerParam {
-  int64_t seed{0};
-  NimbleReaderFuzzerOptions options{};
-};
-std::vector<NimbleReaderFuzzerParam> NimbleReaderFuzzerParams() {
-  return {
-      {.seed = 42, .options = {}},
-      {.seed = 56, .options = {}},
-      {.seed = 189, .options = {}},
-      {.seed = 331, .options = {}},
-  };
-}
-class NimbleReaderFuzzerTest
-    : public testing::Test,
-      public testing::WithParamInterface<NimbleReaderFuzzerParam> {
- protected:
-  static void SetUpTestCase() {
-    memory::initializeMemoryManager(velox::memory::MemoryManager::Options{});
-  }
-  void SetUp() override {
-    if (int device; cudaGetDevice(&device) != cudaSuccess) {
-      GTEST_SKIP() << "No CUDA detected, skipping all tests";
-    }
-    auto param = GetParam();
-    seed_ = param.seed;
-    opts_ = param.options;
-  }
-
-  int64_t seed_{0};
-  NimbleReaderFuzzerOptions opts_{};
-};
-
-TEST_P(NimbleReaderFuzzerTest, basic) {
-  facebook::velox::wave::nimbleReaderFuzzer(seed_, opts_, nullptr);
-}
-
-VELOX_INSTANTIATE_TEST_SUITE_P(
-    NimbleReaderFuzzerTests,
-    NimbleReaderFuzzerTest,
-    testing::ValuesIn(NimbleReaderFuzzerParams()));
-} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/nimble/tests/NimbleReaderTest.cpp b/velox/experimental/wave/dwio/nimble/tests/NimbleReaderTest.cpp
deleted file mode 100644
index dc80719944f..00000000000
--- a/velox/experimental/wave/dwio/nimble/tests/NimbleReaderTest.cpp
+++ /dev/null
@@ -1,920 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <cuda_runtime.h> // @manual
-#include <fmt/format.h>
-#include <gflags/gflags.h>
-#include <gtest/gtest.h>
-
-#include "dwio/nimble/encodings/EncodingLayout.h"
-#include "dwio/nimble/encodings/EncodingLayoutCapture.h"
-#include "dwio/nimble/encodings/EncodingSelectionPolicy.h"
-#include "dwio/nimble/tablet/TabletReader.h"
-#include "velox/experimental/wave/dwio/nimble/NimbleFileFormat.h"
-#include "velox/experimental/wave/dwio/nimble/NimbleFormatData.h"
-#include "velox/experimental/wave/dwio/nimble/tests/NimbleReaderTestUtil.h"
-#include "velox/type/Filter.h"
-#include "velox/vector/tests/utils/VectorTestBase.h"
-
-namespace facebook::velox::wave {
-using namespace facebook::nimble;
-
-namespace {
-using namespace facebook::velox;
-
-class NimbleReaderTest : public ::testing::Test,
-                         public velox::test::VectorTestBase {
- protected:
-  static void SetUpTestCase() {
-    memory::initializeMemoryManager(velox::memory::MemoryManager::Options{});
-  }
-
-  void SetUp() override {
-    if (int device; cudaGetDevice(&device) != cudaSuccess) {
-      GTEST_SKIP() << "No CUDA detected, skipping all tests";
-    }
-  }
-
-  memory::MemoryPool* leafPool() {
-    return pool_.get();
-  }
-
-  // Helper function to decode a vector with specified read factors and
-  // compression options
-  void test(
-      const std::vector<std::vector<VectorPtr>>& chunkVectorGroups,
-      const std::vector<std::pair<EncodingType, float>>& readFactors,
-      const CompressionOptions& compressionOptions =
-          {.compressionAcceptRatio = 0.0},
-      const std::vector<FilterSpec>& filters = {}) {
-    auto streamLoaders = writeToNimbleAndGetStreamLoaders(
-        leafPool(), chunkVectorGroups, readFactors, compressionOptions);
-
-    auto input = createInputFromChunkVectorGroups(chunkVectorGroups);
-
-    TestNimbleReader reader(leafPool(), input, streamLoaders, filters);
-    auto testResult = reader.read();
-
-    verifier_.verify(input, filters, testResult);
-  }
-
- private:
-  NimbleReaderVerifier verifier_{};
-};
-
-#define ENCODING_TYPE_EXPECT_EQ(type1, type2) \
-  EXPECT_EQ(static_cast<int>(type1), static_cast<int>(type2));
-
-#define ENCODING_TYPE_ASSERT_EQ(type1, type2) \
-  ASSERT_EQ(static_cast<int>(type1), static_cast<int>(type2));
-
-void compareEncodingTree(
-    NimbleEncoding& encoding,
-    EncodingLayout const& layout) {
-  SCOPED_TRACE(fmt::format(
-      "Encoding: {}, #children: {}",
-      toString(layout.encodingType()),
-      encoding.childrenCount()));
-  EXPECT_EQ(encoding.childrenCount(), layout.childrenCount());
-  ENCODING_TYPE_EXPECT_EQ(encoding.encodingType(), layout.encodingType());
-  for (int i = 0; i < encoding.childrenCount(); i++) {
-    compareEncodingTree(*encoding.childAt(i), layout.child(i).value());
-  }
-}
-} // namespace
-
-TEST_F(NimbleReaderTest, rootTrivialEncoding) {
-  using namespace facebook::nimble;
-
-  auto c0 = makeRowVector({
-      makeFlatVector<int16_t>(10, folly::identity),
-  });
-  auto pool = leafPool();
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Trivial, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  auto streamLoaders = writeToNimbleAndGetStreamLoaders(
-      pool, {{c0}}, readFactors, compressionOptions);
-
-  ASSERT_EQ(streamLoaders.size(), 1);
-  ASSERT_NE(streamLoaders[0], nullptr);
-  NimbleChunkedStream stream(*pool, streamLoaders[0]->getStream());
-
-  ASSERT_TRUE(stream.hasNext());
-
-  auto chunk = stream.nextChunk();
-  auto encoding = NimbleChunk::parseEncodingFromChunk(chunk.chunkData());
-  auto layout = EncodingLayoutCapture::capture(encoding->encodingData());
-
-  ASSERT_EQ(layout.encodingType(), EncodingType::Trivial);
-
-  EXPECT_EQ(encoding->numValues(), c0->childAt(0)->size());
-
-  compareEncodingTree(*encoding, layout);
-}
-
-TEST_F(NimbleReaderTest, rootNullableEncoding) {
-  using namespace facebook::nimble;
-
-  const int nullFreq = 10;
-  auto c0 = makeRowVector({
-      makeFlatVector<int16_t>(100, folly::identity, nullEvery(nullFreq)),
-  });
-  auto pool = leafPool();
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Nullable, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  auto streamLoaders = writeToNimbleAndGetStreamLoaders(
-      pool, {{c0}}, readFactors, compressionOptions);
-
-  ASSERT_EQ(streamLoaders.size(), 1);
-  ASSERT_NE(streamLoaders[0], nullptr);
-  NimbleChunkedStream stream(*pool, streamLoaders[0]->getStream());
-
-  ASSERT_TRUE(stream.hasNext());
-
-  auto chunk = stream.nextChunk();
-  auto encoding = NimbleChunk::parseEncodingFromChunk(chunk.chunkData());
-
-  ENCODING_TYPE_ASSERT_EQ(encoding->encodingType(), EncodingType::Nullable);
-
-  EXPECT_EQ(encoding->numValues(), c0->childAt(0)->size());
-
-  EXPECT_EQ(encoding->childrenCount(), 2);
-  EXPECT_EQ(
-      encoding->childAt(0)->numValues(),
-      c0->size() - c0->size() / nullFreq); // non-nulls
-  EXPECT_EQ(encoding->childAt(1)->numValues(), c0->size()); // nulls
-}
-
-TEST_F(NimbleReaderTest, rootDictionaryEncoding) {
-  using namespace facebook::nimble;
-
-  auto c0 = makeRowVector({
-      makeFlatVector<int16_t>({3, 3, 4, 4, 5, 5, 6, 6, 7, 7}),
-  });
-  auto pool = leafPool();
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Dictionary, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  auto streamLoaders = writeToNimbleAndGetStreamLoaders(
-      pool, {{c0}}, readFactors, compressionOptions);
-
-  ASSERT_EQ(streamLoaders.size(), 1);
-  ASSERT_NE(streamLoaders[0], nullptr);
-  NimbleChunkedStream stream(*pool, streamLoaders[0]->getStream());
-
-  ASSERT_TRUE(stream.hasNext());
-
-  auto chunk = stream.nextChunk();
-  auto encoding = NimbleChunk::parseEncodingFromChunk(chunk.chunkData());
-  auto layout = EncodingLayoutCapture::capture(encoding->encodingData());
-
-  ASSERT_EQ(layout.encodingType(), EncodingType::Dictionary);
-
-  EXPECT_EQ(encoding->numValues(), c0->childAt(0)->size());
-
-  compareEncodingTree(*encoding, layout);
-  EXPECT_EQ(encoding->childrenCount(), layout.childrenCount());
-  EXPECT_EQ(encoding->childAt(0)->numValues(), 5); // unique values
-  EXPECT_EQ(encoding->childAt(1)->numValues(), encoding->numValues());
-}
-
-TEST_F(NimbleReaderTest, rootRLEEncoding) {
-  using namespace facebook::nimble;
-
-  auto c0 = makeRowVector({
-      makeFlatVector<int16_t>({1, 1, 1, 1, 2, 2, 2, 3, 3, 3}),
-  });
-  auto pool = leafPool();
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::RLE, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  auto streamLoaders = writeToNimbleAndGetStreamLoaders(
-      pool, {{c0}}, readFactors, compressionOptions);
-
-  ASSERT_EQ(streamLoaders.size(), 1);
-  ASSERT_NE(streamLoaders[0], nullptr);
-  NimbleChunkedStream stream(*pool, streamLoaders[0]->getStream());
-
-  ASSERT_TRUE(stream.hasNext());
-
-  auto chunk = stream.nextChunk();
-  auto encoding = NimbleChunk::parseEncodingFromChunk(chunk.chunkData());
-  auto layout = EncodingLayoutCapture::capture(encoding->encodingData());
-
-  ASSERT_EQ(layout.encodingType(), EncodingType::RLE);
-
-  EXPECT_EQ(encoding->numValues(), c0->childAt(0)->size());
-
-  compareEncodingTree(*encoding, layout);
-  EXPECT_EQ(encoding->childAt(0)->numValues(), 3);
-  EXPECT_EQ(encoding->childAt(1)->numValues(), 3);
-}
-
-TEST_F(NimbleReaderTest, decodePipeline) {
-  using namespace facebook::nimble;
-
-  auto c0 = makeRowVector({
-      makeFlatVector<int16_t>({1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 3, 3, 3, 3}),
-  });
-  auto pool = leafPool();
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::RLE, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  auto streamLoaders = writeToNimbleAndGetStreamLoaders(
-      pool, {{c0}}, readFactors, compressionOptions);
-
-  ASSERT_EQ(streamLoaders.size(), 1);
-  ASSERT_NE(streamLoaders[0], nullptr);
-  NimbleChunkedStream stream(*pool, streamLoaders[0]->getStream());
-
-  ASSERT_TRUE(stream.hasNext());
-
-  auto chunk = stream.nextChunk();
-  auto encoding = NimbleChunk::parseEncodingFromChunk(chunk.chunkData());
-  auto layout = EncodingLayoutCapture::capture(encoding->encodingData());
-
-  ASSERT_EQ(layout.encodingType(), EncodingType::RLE);
-  ASSERT_EQ(encoding->childrenCount(), 2);
-
-  NimbleChunkDecodePipeline pipeline(std::move(encoding));
-
-  // rle(trivial(lengths), trivial(values))
-  ASSERT_EQ(pipeline.size(), 3);
-  auto encodingNode = pipeline.next();
-  ENCODING_TYPE_EXPECT_EQ(encodingNode->encodingType(), EncodingType::Trivial);
-  encodingNode = pipeline.next();
-  ENCODING_TYPE_EXPECT_EQ(encodingNode->encodingType(), EncodingType::Trivial);
-  // This encoding depends on the previous and therefore is not ready yet
-  encodingNode = pipeline.next();
-  EXPECT_EQ(encodingNode, nullptr);
-  ENCODING_TYPE_EXPECT_EQ(pipeline[2].encodingType(), EncodingType::RLE);
-  EXPECT_TRUE(pipeline[0].isDecoded());
-  EXPECT_TRUE(pipeline[1].isDecoded());
-  EXPECT_EQ(pipeline.finished(), false);
-}
-
-TEST_F(NimbleReaderTest, decodeTrivialSingleLevelInteger) {
-  using namespace facebook::nimble;
-
-  auto c0 =
-      makeFlatVector<int32_t>({1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 3, 3, 3, 3});
-  auto input = makeRowVector({c0});
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Trivial, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  test({{input}}, readFactors, compressionOptions);
-}
-
-TEST_F(NimbleReaderTest, decodeTrivialSingleLevelFloat) {
-  using namespace facebook::nimble;
-
-  auto c0 = makeFlatVector<double>(1893, [](auto row) { return row * 1.1; });
-  auto input = makeRowVector({c0});
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Trivial, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  test({{input}}, readFactors, compressionOptions);
-}
-
-TEST_F(NimbleReaderTest, TrivialWithCompressionShouldFail) {
-  using namespace facebook::nimble;
-
-  auto c0 = makeFlatVector<double>(17, [](auto row) { return row * 1.1; });
-  auto input = makeRowVector({c0});
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Trivial, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 1.0};
-  try {
-    test({{input}}, readFactors, compressionOptions);
-    FAIL() << "Expected exception for decoding trivial with compression";
-  } catch (const VeloxRuntimeError& e) {
-    EXPECT_NE(
-        e.message().find("Trivial encoding does not support compression yet"),
-        std::string::npos);
-  } catch (...) {
-    FAIL() << "unexpected exception thrown";
-  }
-}
-
-TEST_F(NimbleReaderTest, loadMultiChunks) {
-  using namespace facebook::nimble;
-
-  auto pool = leafPool();
-
-  auto chunk0 = makeRowVector({
-      makeFlatVector<double>(17, folly::identity),
-  });
-  auto chunk1 = makeRowVector({
-      makeFlatVector<double>(26, folly::identity),
-  });
-  auto chunk2 = makeRowVector({
-      makeFlatVector<double>(34, folly::identity),
-  });
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Trivial, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  auto streamLoaders = writeToNimbleAndGetStreamLoaders(
-      pool, {{chunk0, chunk1, chunk2}}, readFactors, compressionOptions);
-
-  ASSERT_EQ(streamLoaders.size(), 1);
-  ASSERT_NE(streamLoaders[0], nullptr);
-  NimbleChunkedStream stream(*pool, streamLoaders[0]->getStream());
-
-  std::vector<RowVectorPtr> chunks{chunk0, chunk1, chunk2};
-  for (int i = 0; i < 3; i++) {
-    SCOPED_TRACE(fmt::format("i: {}", i));
-    ASSERT_TRUE(stream.hasNext());
-    auto chunk = stream.nextChunk();
-    auto encoding = NimbleChunk::parseEncodingFromChunk(chunk.chunkData());
-    auto layout = EncodingLayoutCapture::capture(encoding->encodingData());
-
-    ASSERT_EQ(layout.encodingType(), EncodingType::Trivial);
-    EXPECT_EQ(encoding->numValues(), chunks[i]->childAt(0)->size());
-    compareEncodingTree(*encoding, layout);
-  }
-  ASSERT_FALSE(stream.hasNext());
-}
-
-TEST_F(NimbleReaderTest, decodeTrivialMultiChunksFloat) {
-  using namespace facebook::nimble;
-
-  auto chunk1 = makeRowVector(
-      {makeFlatVector<double>(1893, [](auto row) { return row + 1.1; })});
-  auto chunk2 = makeRowVector(
-      {makeFlatVector<double>(267, [](auto row) { return row + 2.2; })});
-  auto chunk3 = makeRowVector(
-      {makeFlatVector<double>(449, [](auto row) { return row + 3.3; })});
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Trivial, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  test({{chunk1, chunk2, chunk3}}, readFactors, compressionOptions);
-}
-
-TEST_F(NimbleReaderTest, decodeTrivialMultiChunksMultiStreams) {
-  using namespace facebook::nimble;
-
-  auto chunk1 = makeRowVector(
-      {makeFlatVector<double>(513, [](auto row) { return row + 1.1; }),
-       makeFlatVector<int32_t>(513, folly::identity),
-       makeFlatVector<int64_t>(513, folly::identity)});
-  auto chunk2 = makeRowVector(
-      {makeFlatVector<double>(267, [](auto row) { return row + 2.2; }),
-       makeFlatVector<int32_t>(267, folly::identity),
-       makeFlatVector<int64_t>(267, folly::identity)});
-  auto chunk3 = makeRowVector(
-      {makeFlatVector<double>(449, [](auto row) { return row + 3.3; }),
-       makeFlatVector<int32_t>(449, folly::identity),
-       makeFlatVector<int64_t>(449, folly::identity)});
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Trivial, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  test({{chunk1, chunk2, chunk3}}, readFactors, compressionOptions);
-}
-
-TEST_F(NimbleReaderTest, decodeNullableFloat) {
-  using namespace facebook::nimble;
-
-  auto c0 = makeFlatVector<double>(
-      1025, [](auto row) { return row + 0.1; }, nullEvery(3));
-  auto input = makeRowVector({c0});
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Nullable, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  test({{input}}, readFactors, compressionOptions);
-}
-
-TEST_F(NimbleReaderTest, decodeAllNulls) {
-  using namespace facebook::nimble;
-
-  auto c0 = makeFlatVector<double>(
-      1893, [](auto row) { return row * 1.1; }, nullEvery(1));
-  auto c1 = makeFlatVector<double>(
-      1893, [](auto row) { return row * 1.1; }, nullEvery(2));
-  auto input = makeRowVector({c0, c1});
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Nullable, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  test({{input}}, readFactors, compressionOptions);
-}
-
-TEST_F(NimbleReaderTest, decodeNullableMultiChunks) {
-  using namespace facebook::nimble;
-
-  auto c0 = makeRowVector({makeFlatVector<double>(
-      1893, [](auto row) { return row + 1.1; }, nullEvery(3))});
-  auto c1 = makeRowVector(
-      {makeFlatVector<double>(2156, [](auto row) { return row + 1.2; })});
-  auto c2 = makeRowVector({makeFlatVector<double>(
-      4790, [](auto row) { return row + 1.3; }, nullEvery(19))});
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Nullable, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  test({{c0, c1, c2}}, readFactors, compressionOptions);
-}
-
-TEST_F(NimbleReaderTest, decodeNullableMultiChunksMultiStreams) {
-  using namespace facebook::nimble;
-
-  auto c0 = makeRowVector(
-      {makeFlatVector<double>(1893, [](auto row) { return row + 1.1; }),
-       makeFlatVector<int32_t>(1893, folly::identity, nullEvery(5))});
-  auto c1 = makeRowVector(
-      {makeFlatVector<double>(
-           2156, [](auto row) { return row + 1.2; }, nullEvery(13)),
-       makeFlatVector<int32_t>(2156, folly::identity)});
-  auto c2 = makeRowVector(
-      {makeFlatVector<double>(4790, [](auto row) { return row + 1.3; }),
-       makeFlatVector<int32_t>(4790, folly::identity)});
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Nullable, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  test({{c0, c1, c2}}, readFactors, compressionOptions);
-}
-
-TEST_F(NimbleReaderTest, NullableWithOneFilterKeepValues) {
-  using namespace facebook::nimble;
-
-  auto input = makeRowVector({makeFlatVector<int32_t>(
-      1893, [](auto row) { return row; }, nullEvery(3))});
-
-  auto filter = std::make_shared<common::BigintRange>(1022, 1025, false);
-  std::vector<FilterSpec> filters = {{"c0", filter, true}};
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Nullable, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  test({{input}}, readFactors, compressionOptions, filters);
-}
-
-TEST_F(NimbleReaderTest, NullableWithMoreFiltersKeepValues) {
-  using namespace facebook::nimble;
-
-  auto input = makeRowVector(
-      {makeFlatVector<int32_t>(
-           1893, [](auto row) { return row; }, nullEvery(3)),
-       makeFlatVector<int32_t>(
-           1893, [](auto row) { return row; }, nullEvery(3))});
-
-  auto c0Filter = std::make_shared<common::BigintRange>(1022, 1025, false);
-  auto c1Filter = std::make_shared<common::BigintRange>(1022, 1024, false);
-  std::vector<FilterSpec> filters = {
-      {"c0", c0Filter, true}, {"c1", c1Filter, true}};
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Nullable, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  test({{input}}, readFactors, compressionOptions, filters);
-}
-
-TEST_F(NimbleReaderTest, NullableWithOneFilterOneNonFilterKeepValues) {
-  using namespace facebook::nimble;
-
-  auto input = makeRowVector(
-      {makeFlatVector<int32_t>(
-           1893, [](auto row) { return row; }, nullEvery(3)),
-       makeFlatVector<int32_t>(
-           1893, [](auto row) { return row; }, nullEvery(3))});
-
-  auto c0Filter = std::make_shared<common::BigintRange>(1022, 1025, false);
-  std::vector<FilterSpec> filters = {{"c0", c0Filter, true}};
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Nullable, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  test({{input}}, readFactors, compressionOptions, filters);
-}
-
-TEST_F(NimbleReaderTest, NullableWithMoreFiltersMoreNonFiltersKeepValues) {
-  using namespace facebook::nimble;
-
-  auto input = makeRowVector(
-      {makeFlatVector<int32_t>(
-           1893, [](auto row) { return row; }, nullEvery(3)),
-       makeFlatVector<int32_t>(
-           1893, [](auto row) { return row; }, nullEvery(3)),
-       makeFlatVector<int32_t>(
-           1893, [](auto row) { return row; }, nullEvery(2)),
-       makeFlatVector<int32_t>(
-           1893, [](auto row) { return row; }, nullEvery(2))});
-
-  auto c0Filter = std::make_shared<common::BigintRange>(1022, 1025, false);
-  auto c1Filter = std::make_shared<common::BigintRange>(1022, 1024, false);
-  std::vector<FilterSpec> filters = {
-      {"c0", c0Filter, true}, {"c1", c1Filter, true}};
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Nullable, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  test({{input}}, readFactors, compressionOptions, filters);
-}
-
-TEST_F(NimbleReaderTest, NullableFilterNoResults) {
-  using namespace facebook::nimble;
-
-  auto input = makeRowVector(
-      {makeFlatVector<int32_t>(
-           1893, [](auto row) { return row; }, nullEvery(3)),
-       makeFlatVector<int32_t>(
-           1893, [](auto row) { return row; }, nullEvery(3)),
-       makeFlatVector<int32_t>(
-           1893, [](auto row) { return row; }, nullEvery(2)),
-       makeFlatVector<int32_t>(
-           1893, [](auto row) { return row; }, nullEvery(2))});
-
-  auto c0Filter = std::make_shared<common::BigintRange>(1893, 1944, false);
-  auto c1Filter = std::make_shared<common::BigintRange>(1022, 1024, false);
-  std::vector<FilterSpec> filters = {
-      {"c0", c0Filter, true}, {"c1", c1Filter, true}};
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Nullable, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  test({{input}}, readFactors, compressionOptions, filters);
-}
-
-TEST_F(NimbleReaderTest, TrivialWithOneFilterKeepValues) {
-  using namespace facebook::nimble;
-
-  auto input = makeRowVector(
-      {makeFlatVector<int32_t>(2000, [](auto row) { return row; })});
-
-  auto c0Filter = std::make_shared<common::BigintRange>(1022, 1025, false);
-  std::vector<FilterSpec> filters = {{"c0", c0Filter, true}};
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Trivial, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  test({{input}}, readFactors, compressionOptions, filters);
-}
-
-TEST_F(NimbleReaderTest, TrivialWithMoreFiltersMoreNonFiltersKeepValues) {
-  using namespace facebook::nimble;
-
-  auto input = makeRowVector(
-      {makeFlatVector<int32_t>(1893, [](auto row) { return row; }),
-       makeFlatVector<int64_t>(1893, [](auto row) { return row; }),
-       makeFlatVector<int32_t>(1893, [](auto row) { return row; }),
-       makeFlatVector<int64_t>(1893, [](auto row) { return row; })});
-
-  auto c0Filter = std::make_shared<common::BigintRange>(1022, 1025, false);
-  auto c1Filter = std::make_shared<common::BigintRange>(1022, 1024, false);
-  std::vector<FilterSpec> filters = {
-      {"c0", c0Filter, true}, {"c1", c1Filter, true}};
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Trivial, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  test({{input}}, readFactors, compressionOptions, filters);
-}
-
-TEST_F(NimbleReaderTest, TrivialChunksOneFilterKeepValues) {
-  using namespace facebook::nimble;
-
-  auto chunk0 = makeRowVector(
-      {makeFlatVector<int32_t>(1200, [](auto row) { return row; })});
-  auto chunk1 = makeRowVector({makeFlatVector<int32_t>(
-      1800, [&](auto row) { return row + chunk0->size(); })});
-
-  int64_t lower = 1020, upper = 1202;
-  auto c0Filter = std::make_shared<common::BigintRange>(lower, upper, false);
-  std::vector<FilterSpec> filters = {{"c0", c0Filter, true}};
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Trivial, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  test({{chunk0, chunk1}}, readFactors, compressionOptions, filters);
-}
-
-TEST_F(NimbleReaderTest, NullableChunksOneFilterKeepValues) {
-  using namespace facebook::nimble;
-
-  auto chunk0 = makeRowVector({makeFlatVector<int32_t>(
-      1200, [](auto row) { return row; }, nullEvery(2))});
-  auto chunk1 = makeRowVector({makeFlatVector<int32_t>(
-      1800, [&](auto row) { return row + chunk0->size(); }, nullEvery(2))});
-
-  int64_t lower = 1198, upper = 1202;
-  auto c0Filter = std::make_shared<common::BigintRange>(lower, upper, false);
-  std::vector<FilterSpec> filters = {{"c0", c0Filter, true}};
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Nullable, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  test({{chunk0, chunk1}}, readFactors, compressionOptions, filters);
-}
-
-TEST_F(NimbleReaderTest, NullableChunksFiltersKeepValues) {
-  using namespace facebook::nimble;
-
-  auto chunk0 = makeRowVector(
-      {makeFlatVector<int32_t>(
-           1200, [](auto row) { return row; }, nullEvery(2)),
-       makeFlatVector<int32_t>(
-           1200, [](auto row) { return row; }, nullEvery(2))});
-  auto chunk1 = makeRowVector(
-      {makeFlatVector<int32_t>(
-           1800, [&](auto row) { return row + chunk0->size(); }, nullEvery(2)),
-       makeFlatVector<int32_t>(
-           1800,
-           [&](auto row) { return row + chunk0->size(); },
-           nullEvery(2))});
-
-  int64_t lower = 1198, upper = 1202;
-  auto c0Filter = std::make_shared<common::BigintRange>(lower, upper, false);
-  auto c1filter =
-      std::make_shared<common::BigintRange>(lower - 2, upper + 2, false);
-  std::vector<FilterSpec> filters = {
-      {"c0", c0Filter, true}, {"c1", c0Filter, true}};
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Nullable, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  test({{chunk0, chunk1}}, readFactors, compressionOptions, filters);
-}
-
-TEST_F(NimbleReaderTest, NullableChunksFiltersNonFiltersKeepValues) {
-  using namespace facebook::nimble;
-
-  auto vector = [&](int32_t numValues, int32_t offset = 0) {
-    return makeFlatVector<int32_t>(
-        numValues, [&](auto row) { return row + offset; }, nullEvery(2));
-  };
-  auto chunk0 = makeRowVector({
-      vector(1200),
-      vector(1200),
-      vector(1200),
-      vector(1200),
-  });
-  auto chunk1 = makeRowVector({
-      vector(1800, chunk0->size()),
-      vector(1800, chunk0->size()),
-      vector(1800, chunk0->size()),
-      vector(1800, chunk0->size()),
-  });
-
-  int64_t lower = 1198, upper = 1202;
-  auto c0Filter = std::make_shared<common::BigintRange>(lower, upper, false);
-  auto c1Filter =
-      std::make_shared<common::BigintRange>(lower - 2, upper + 2, false);
-  std::vector<FilterSpec> filters = {
-      {"c0", c0Filter, true}, {"c1", c1Filter, true}};
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Nullable, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  test({{chunk0, chunk1}}, readFactors, compressionOptions, filters);
-}
-
-TEST_F(NimbleReaderTest, TrivialChunksFiltersKeepValues) {
-  using namespace facebook::nimble;
-
-  auto chunk0 = makeRowVector(
-      {makeFlatVector<int32_t>(1200, [](auto row) { return row; }),
-       makeFlatVector<int32_t>(1200, [](auto row) { return row; })});
-  auto chunk1 = makeRowVector(
-      {makeFlatVector<int32_t>(
-           1800, [&](auto row) { return row + chunk0->size(); }),
-       makeFlatVector<int32_t>(
-           1800, [&](auto row) { return row + chunk0->size(); })});
-
-  int64_t lower = 1020, upper = 1202;
-  auto c0Filter = std::make_shared<common::BigintRange>(lower, upper, false);
-  auto c1filter =
-      std::make_shared<common::BigintRange>(lower - 2, upper + 2, false);
-  std::vector<FilterSpec> filters = {
-      {"c0", c0Filter, true}, {"c1", c0Filter, true}};
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Trivial, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  test({{chunk0, chunk1}}, readFactors, compressionOptions, filters);
-}
-
-TEST_F(NimbleReaderTest, TrivialChunksFiltersNonFiltersKeepValues) {
-  using namespace facebook::nimble;
-
-  auto vector = [&](int32_t numValues, int32_t offset = 0) {
-    return makeFlatVector<int32_t>(
-        numValues, [&](auto row) { return row + offset; });
-  };
-  auto chunk0 = makeRowVector({
-      vector(1200),
-      vector(1200),
-      vector(1200),
-      vector(1200),
-  });
-  auto chunk1 = makeRowVector({
-      vector(1800, chunk0->size()),
-      vector(1800, chunk0->size()),
-      vector(1800, chunk0->size()),
-      vector(1800, chunk0->size()),
-  });
-
-  int64_t lower = 1020, upper = 1202;
-  auto c0Filter = std::make_shared<common::BigintRange>(lower, upper, false);
-  auto c1Filter =
-      std::make_shared<common::BigintRange>(lower - 2, upper + 2, false);
-  std::vector<FilterSpec> filters = {
-      {"c0", c0Filter, true}, {"c1", c1Filter, true}};
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Trivial, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  test({{chunk0, chunk1}}, readFactors, compressionOptions, filters);
-}
-
-TEST_F(NimbleReaderTest, TrivialUnalignedChunks) {
-  using namespace facebook::nimble;
-
-  auto vector = [&](int32_t numValues, int32_t offset = 0) {
-    return makeFlatVector<int32_t>(
-        numValues, [&](auto row) { return row + offset; });
-  };
-  int32_t offset = 0;
-
-  // Group 1
-  auto chunk0 = makeRowVector({
-      vector(1200),
-      vector(1200),
-  });
-  offset = chunk0->size();
-  auto chunk1 = makeRowVector({
-      vector(1800, offset),
-      vector(1800, offset),
-  });
-
-  // Group 2
-  auto chunk2 = makeRowVector({
-      vector(500),
-      vector(500),
-  });
-  offset = chunk2->size();
-  auto chunk3 = makeRowVector({
-      vector(1200, offset),
-      vector(1200, offset),
-  });
-  offset += chunk3->size();
-  auto chunk4 = makeRowVector({
-      vector(1300, offset),
-      vector(1300, offset),
-  });
-
-  int64_t lower = 1020, upper = 1202;
-  auto c0Filter = std::make_shared<common::BigintRange>(lower, upper, false);
-  auto c2Filter =
-      std::make_shared<common::BigintRange>(lower - 2, upper + 2, false);
-  std::vector<FilterSpec> filters = {
-      {"c0", c0Filter, true}, {"c2", c2Filter, true}};
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Trivial, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  test(
-      {{chunk0, chunk1}, {chunk2, chunk3, chunk4}},
-      readFactors,
-      compressionOptions,
-      filters);
-}
-
-TEST_F(NimbleReaderTest, NullablelUnalignedChunks) {
-  using namespace facebook::nimble;
-
-  auto vector = [&](int32_t numValues, int32_t nullFreq, int32_t offset = 0) {
-    return makeFlatVector<int32_t>(
-        numValues, [&](auto row) { return row + offset; }, nullEvery(nullFreq));
-  };
-  int32_t offset = 0;
-
-  // Group 1
-  auto chunk0 = makeRowVector({
-      vector(1200, 3),
-      vector(1200, 3),
-  });
-  offset = chunk0->size();
-  auto chunk1 = makeRowVector({
-      vector(1800, 3, offset),
-      vector(1800, 3, offset),
-  });
-
-  // Group 2
-  auto chunk2 = makeRowVector({
-      vector(600, 3),
-      vector(600, 3),
-  });
-  offset = chunk2->size();
-  auto chunk3 = makeRowVector({
-      vector(1200, 3, offset),
-      vector(1200, 3, offset),
-  });
-  offset += chunk3->size();
-  auto chunk4 = makeRowVector({
-      vector(1200, 3, offset),
-      vector(1200, 3, offset),
-  });
-
-  int64_t lower = 1020, upper = 1202;
-  auto c0Filter = std::make_shared<common::BigintRange>(lower, upper, false);
-  auto c2Filter =
-      std::make_shared<common::BigintRange>(lower - 2, upper + 2, false);
-  std::vector<FilterSpec> filters = {
-      {"c0", c0Filter, true}, {"c2", c2Filter, true}};
-
-  std::vector<std::pair<EncodingType, float>> readFactors = {
-      {EncodingType::Nullable, 1.0},
-  };
-  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
-
-  test(
-      {{chunk0, chunk1}, {chunk2, chunk3, chunk4}},
-      readFactors,
-      compressionOptions,
-      filters);
-}
-} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/nimble/tests/NimbleReaderTestUtil.cpp b/velox/experimental/wave/dwio/nimble/tests/NimbleReaderTestUtil.cpp
deleted file mode 100644
index 72c87b36715..00000000000
--- a/velox/experimental/wave/dwio/nimble/tests/NimbleReaderTestUtil.cpp
+++ /dev/null
@@ -1,382 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/wave/dwio/nimble/tests/NimbleReaderTestUtil.h"
-#include <numeric>
-#include "dwio/nimble/common/tests/NimbleFileWriter.h"
-#include "dwio/nimble/encodings/EncodingSelectionPolicy.h"
-#include "dwio/nimble/tablet/TabletReader.h"
-#include "dwio/nimble/velox/VeloxWriterOptions.h"
-#include "velox/common/file/File.h"
-#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
-#include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/QueryAssertions.h"
-#include "velox/experimental/wave/dwio/ColumnReader.h"
-#include "velox/experimental/wave/dwio/StructColumnReader.h"
-#include "velox/experimental/wave/dwio/nimble/NimbleFileFormat.h"
-#include "velox/experimental/wave/dwio/nimble/NimbleFormatData.h"
-#include "velox/experimental/wave/dwio/nimble/SelectiveStructColumnReader.h"
-
-namespace facebook::velox::wave {
-TestNimbleReader::TestNimbleReader(
-    memory::MemoryPool* pool,
-    RowVectorPtr input,
-    std::vector<std::unique_ptr<StreamLoader>>& streamLoaders,
-    const std::vector<FilterSpec>& filters)
-    : pool_(pool), input_(input) {
-  deviceArena_ = std::make_unique<GpuArena>(
-      100000000, getDeviceAllocator(getDevice()), 400000000);
-
-  std::vector<std::unique_ptr<NimbleChunkedStream>> chunkedStreams;
-  for (int i = 0; i < streamLoaders.size(); i++) {
-    auto& streamLoader = streamLoaders[i];
-    if (streamLoader == nullptr) { // this is a null stream
-      continue;
-    }
-    nonNullOutputChildrenIds_.push_back(i);
-    auto chunkedStream =
-        std::make_unique<NimbleChunkedStream>(*pool, streamLoader->getStream());
-    VELOX_CHECK(chunkedStream->hasNext());
-    chunkedStreams.emplace_back(std::move(chunkedStream));
-  }
-
-  if (chunkedStreams.empty()) { // only contain null streams
-    return;
-  }
-
-  // Create non-null type and scan spec that only include non-null streams
-  std::vector<std::string> nonNullNames;
-  std::vector<TypePtr> nonNullTypes;
-  const auto& inputRowType = input->type()->asRow();
-  for (int32_t childId : nonNullOutputChildrenIds_) {
-    nonNullNames.push_back(inputRowType.nameOf(childId));
-    nonNullTypes.push_back(inputRowType.childAt(childId));
-  }
-  auto nonNullRowType = ROW(std::move(nonNullNames), std::move(nonNullTypes));
-
-  // Set up scan spec and format parameters
-  scanSpec_ = std::make_shared<common::ScanSpec>("root");
-  scanSpec_->addAllChildFields(*nonNullRowType);
-
-  // Apply filters to specific children if provided
-  for (const auto& [childName, filter, keepValues] : filters) {
-    auto* childSpec = scanSpec_->childByName(childName);
-    if (childSpec != nullptr) {
-      childSpec->setFilter(filter);
-      childSpec->setProjectOut(keepValues);
-    } else if (!filter->nullAllowed()) {
-      earlyStop_ = true;
-      return;
-    }
-  }
-  auto requestedType = nonNullRowType;
-  auto fileType = dwio::common::TypeWithId::create(requestedType);
-  std::shared_ptr<dwio::common::TypeWithId> fileTypeShared =
-      std::move(fileType);
-
-  stripe_ = std::make_unique<NimbleStripe>(
-      std::move(chunkedStreams), fileTypeShared, input->size());
-
-  formatParams_ = std::make_unique<NimbleFormatParams>(*pool, stats_, *stripe_);
-  reader_ = nimble::NimbleFormatReader::build(
-      requestedType, fileTypeShared, *formatParams_, *scanSpec_, nullptr, true);
-
-  // Set up wave stream and read stream
-  auto arena = std::make_unique<GpuArena>(100000000, getAllocator(getDevice()));
-  InstructionStatus instructionStatus;
-  waveStream_ = std::make_unique<WaveStream>(
-      std::move(arena),
-      deviceArena(),
-      reinterpret_cast<nimble::SelectiveStructColumnReader*>(reader_.get())
-          ->getOperands(),
-      &operandStateMap_,
-      instructionStatus,
-      0);
-
-  readStream_ = std::make_unique<ReadStream>(
-      reinterpret_cast<StructColumnReader*>(reader_.get()),
-      *waveStream_,
-      &ioStats_,
-      fileInfo_);
-}
-
-RowVectorPtr TestNimbleReader::read() {
-  if (earlyStop_) {
-    return RowVector::createEmpty(input_->type(), pool_);
-  }
-  std::vector<int32_t> rowIds;
-  rowIds.resize(input_->size());
-  std::iota(rowIds.begin(), rowIds.end(), 0);
-  RowSet rows(rowIds.data(), rowIds.size());
-  ReadStream::launch(std::move(readStream_), 0, rows);
-
-  std::vector<OperandId> operandIds;
-  operandIds.resize(nonNullOutputChildrenIds_.size());
-  std::iota(operandIds.begin(), operandIds.end(), 1);
-  folly::Range<const int32_t*> operandIdRange(
-      operandIds.data(), operandIds.size());
-  std::vector<VectorPtr> nonNullOutputChildren;
-  nonNullOutputChildren.resize(nonNullOutputChildrenIds_.size());
-  auto numOutputValues = waveStream_->getOutput(
-      0, *pool_, operandIdRange, nonNullOutputChildren.data());
-
-  auto output = std::make_shared<RowVector>(
-      input_->pool(),
-      input_->type(),
-      BufferPtr(nullptr),
-      numOutputValues,
-      std::vector<VectorPtr>(input_->childrenSize()));
-
-  for (int i = 0; i < nonNullOutputChildrenIds_.size(); i++) {
-    output->childAt(nonNullOutputChildrenIds_[i]) =
-        std::move(nonNullOutputChildren[i]);
-  }
-
-  for (int i = 0; i < input_->childrenSize(); i++) {
-    if (output->childAt(i) == nullptr) { // populate the null children
-      output->childAt(i) = BaseVector::createNullConstant(
-          input_->childAt(i)->type(), numOutputValues, pool_);
-    }
-  }
-
-  return output;
-}
-
-void NimbleReaderVerifier::verifyWithQueryRunner(
-    RowVectorPtr input,
-    const std::vector<FilterSpec>& filters,
-    RowVectorPtr actual) {
-  std::string whereClause;
-  for (int32_t i = 0; i < filters.size(); i++) {
-    whereClause += filters[i].toString();
-    if (i < filters.size() - 1) {
-      whereClause += " AND ";
-    }
-  }
-
-  auto plan =
-      exec::test::PlanBuilder().values({input}).filter(whereClause).planNode();
-  auto result = referenceQueryRunner_->execute(plan);
-  VELOX_CHECK_NE(
-      result.second, exec::test::ReferenceQueryErrorCode::kReferenceQueryFail);
-  VELOX_CHECK(
-      exec::test::assertEqualResults(
-          result.first.value(), plan->outputType(), {actual}),
-      "Velox and Reference results don't match");
-}
-
-void NimbleReaderVerifier::verify(
-    RowVectorPtr input,
-    const std::vector<FilterSpec>& filters,
-    RowVectorPtr actual) {
-  if (referenceQueryRunner_ != nullptr) {
-    verifyWithQueryRunner(input, filters, actual);
-  }
-
-  if (filters.empty()) {
-    VELOX_CHECK(
-        exec::test::assertEqualResults({input}, {actual}),
-        "Input and actual results don't match when no filters are applied");
-    return;
-  }
-
-  // Create a ScanSpec for the root
-  auto scanSpec = std::make_shared<common::ScanSpec>("root");
-  scanSpec->addAllChildFields(*input->type());
-
-  // Apply filters to the appropriate columns
-  for (const auto& filterSpec : filters) {
-    auto* childSpec = scanSpec->childByName(filterSpec.name);
-    if (childSpec != nullptr) {
-      childSpec->setFilter(filterSpec.filter);
-      childSpec->setProjectOut(filterSpec.keepValues);
-    } else {
-      VELOX_FAIL("Column '{}' not found in input schema", filterSpec.name);
-    }
-  }
-  // Apply filters to get a bitmask of passing rows
-  auto size = input->size();
-  // Initialize result buffer with enough bits for all rows
-  auto resultSize = bits::nwords(size);
-  std::vector<uint64_t> resultBuffer(resultSize, ~0ULL);
-  uint64_t* result = resultBuffer.data();
-  scanSpec->applyFilter(*input, size, result);
-
-  // Count selected rows
-  vector_size_t selectedCount = 0;
-  for (int i = 0; i < size; i++) {
-    if (bits::isBitSet(result, i)) {
-      selectedCount++;
-    }
-  }
-
-  // Create expected output based on filter results
-  RowVectorPtr expected;
-  if (selectedCount == 0) {
-    // No rows passed the filter, so create empty vector with same schema
-    std::vector<VectorPtr> emptyChildren;
-    emptyChildren.reserve(input->childrenSize());
-    for (int i = 0; i < input->childrenSize(); i++) {
-      emptyChildren.push_back(
-          BaseVector::create(input->childAt(i)->type(), 0, input->pool()));
-    }
-    expected = std::make_shared<RowVector>(
-        input->pool(),
-        input->type(),
-        BufferPtr(nullptr),
-        0,
-        std::move(emptyChildren));
-  } else if (selectedCount == size) {
-    // All rows passed the filter
-    expected = input;
-  } else {
-    BufferPtr indices = allocateIndices(selectedCount, input->pool());
-    auto* rawIndices = indices->asMutable<vector_size_t>();
-    int idx = 0;
-    for (int i = 0; i < size; i++) {
-      if (bits::isBitSet(result, i)) {
-        rawIndices[idx++] = i;
-      }
-    }
-
-    // Create filtered children vectors
-    std::vector<VectorPtr> filteredChildren;
-    for (int i = 0; i < input->childrenSize(); i++) {
-      auto* childSpec = scanSpec->childByName(input->type()->asRow().nameOf(i));
-
-      if (childSpec && childSpec->projectOut()) {
-        // This column should be projected out - wrap with dictionary
-        filteredChildren.push_back(BaseVector::wrapInDictionary(
-            nullptr, indices, selectedCount, input->childAt(i)));
-      } else {
-        // This column is not projected out - create null constant
-        filteredChildren.push_back(BaseVector::createNullConstant(
-            input->childAt(i)->type(), selectedCount, input->pool()));
-      }
-    }
-
-    expected = std::make_shared<RowVector>(
-        input->pool(),
-        input->type(),
-        BufferPtr(nullptr),
-        selectedCount,
-        std::move(filteredChildren));
-  }
-
-  VELOX_CHECK(
-      exec::test::assertEqualResults({expected}, {actual}),
-      "Expected and actual results don't match after applying filters");
-}
-
-RowVectorPtr createInputFromChunkVectorGroups(
-    const std::vector<std::vector<VectorPtr>>& chunkVectorGroups) {
-  std::vector<RowVectorPtr> groupVectors;
-  for (const auto& chunkVectors : chunkVectorGroups) {
-    if (chunkVectors.empty()) {
-      continue;
-    }
-
-    auto groupVector = std::dynamic_pointer_cast<RowVector>(chunkVectors[0]);
-    for (int i = 1; i < chunkVectors.size(); i++) {
-      groupVector->append(chunkVectors[i].get());
-    }
-    groupVectors.push_back(groupVector);
-  }
-
-  if (groupVectors.empty()) {
-    return nullptr; // No valid groups
-  }
-
-  if (groupVectors.size() == 1) {
-    return groupVectors[0];
-  } else {
-    std::vector<std::string> allNames;
-    std::vector<TypePtr> allTypes;
-    std::vector<VectorPtr> allChildren;
-
-    int32_t childId = 0;
-    for (const auto& groupVector : groupVectors) {
-      const auto& rowType = groupVector->type()->asRow();
-      for (int i = 0; i < groupVector->childrenSize(); i++, childId++) {
-        allNames.push_back("c" + std::to_string(childId));
-        allTypes.push_back(rowType.childAt(i));
-        allChildren.push_back(groupVector->childAt(i));
-      }
-    }
-
-    auto combinedType = ROW(std::move(allNames), std::move(allTypes));
-    return std::make_shared<RowVector>(
-        groupVectors[0]->pool(),
-        combinedType,
-        BufferPtr(nullptr),
-        groupVectors[0]->size(),
-        std::move(allChildren));
-  }
-}
-
-std::vector<std::unique_ptr<StreamLoader>> writeToNimbleAndGetStreamLoaders(
-    memory::MemoryPool* pool,
-    const std::vector<std::vector<VectorPtr>>& chunkVectorGroups,
-    const std::vector<std::pair<EncodingType, float>>& readFactors,
-    const CompressionOptions& compressionOptions) {
-  using namespace facebook::nimble;
-
-  // Configure writer options with the specified read factors and compression
-  // options
-  VeloxWriterOptions writerOptions;
-  ManualEncodingSelectionPolicyFactory encodingFactory(
-      readFactors, compressionOptions);
-  writerOptions.encodingSelectionPolicyFactory = [&](DataType dataType) {
-    return encodingFactory.createPolicy(dataType);
-  };
-  writerOptions.enableChunking = true;
-  writerOptions.minStreamChunkRawSize = 0;
-  writerOptions.flushPolicyFactory = [] {
-    return std::make_unique<LambdaFlushPolicy>(
-        [](const StripeProgress&) { return FlushDecision::Chunk; });
-  };
-
-  std::vector<std::unique_ptr<StreamLoader>> allStreamLoaders;
-
-  for (const auto& chunkVectors : chunkVectorGroups) {
-    if (chunkVectors.empty()) {
-      continue;
-    }
-
-    auto file = facebook::nimble::test::createNimbleFile(
-        *pool, chunkVectors, writerOptions, false);
-
-    auto numChildren = chunkVectors[0]->as<RowVector>()->childrenSize();
-
-    auto readFile = std::make_unique<InMemoryReadFile>(file);
-    TabletReader tablet(*pool, std::move(readFile));
-    auto stripeIdentifier = tablet.getStripeIdentifier(0);
-    // VELOX_CHECK_EQ(numChildren + 1, tablet.streamCount(stripeIdentifier));
-
-    std::vector<uint32_t> streamIds;
-    streamIds.resize(numChildren);
-    std::iota(streamIds.begin(), streamIds.end(), 1);
-    auto streamLoaders =
-        tablet.load(stripeIdentifier, std::span<const uint32_t>(streamIds));
-
-    for (auto& loader : streamLoaders) {
-      allStreamLoaders.push_back(std::move(loader));
-    }
-  }
-
-  return allStreamLoaders;
-}
-} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/nimble/tests/NimbleReaderTestUtil.h b/velox/experimental/wave/dwio/nimble/tests/NimbleReaderTestUtil.h
deleted file mode 100644
index a3cb2230f82..00000000000
--- a/velox/experimental/wave/dwio/nimble/tests/NimbleReaderTestUtil.h
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <cuda_runtime.h> // @manual
-#include <fmt/format.h>
-#include <gflags/gflags.h>
-#include <gtest/gtest.h>
-
-#include "dwio/nimble/encodings/EncodingSelectionPolicy.h"
-#include "dwio/nimble/tablet/TabletReader.h"
-#include "velox/dwio/common/Statistics.h"
-#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
-#include "velox/experimental/wave/dwio/ColumnReader.h"
-#include "velox/experimental/wave/dwio/nimble/NimbleFileFormat.h"
-#include "velox/experimental/wave/dwio/nimble/NimbleFormatData.h"
-#include "velox/type/Filter.h"
-
-namespace facebook::velox::wave {
-using nimble::CompressionOptions;
-using nimble::EncodingType;
-using nimble::StreamLoader;
-struct FilterSpec {
-  std::string name;
-  std::shared_ptr<common::Filter> filter;
-  bool keepValues;
-
-  std::string toString() const {
-    switch (filter->kind()) {
-      case common::FilterKind::kBigintRange: {
-        auto bigIntRangeFilter =
-            std::dynamic_pointer_cast<common::BigintRange>(this->filter);
-        return fmt::format(
-            "{} BETWEEN {} AND {}",
-            name,
-            bigIntRangeFilter->lower(),
-            bigIntRangeFilter->upper());
-      }
-      default:
-        VELOX_NYI("Not supported filter type");
-    }
-  }
-};
-
-class TestNimbleReader {
- public:
-  TestNimbleReader(
-      memory::MemoryPool* pool,
-      RowVectorPtr input,
-      std::vector<std::unique_ptr<StreamLoader>>& streamLoaders,
-      const std::vector<FilterSpec>& filters);
-  RowVectorPtr read();
-
- private:
-  memory::MemoryPool* pool_{nullptr};
-  RowVectorPtr input_{nullptr};
-  std::unique_ptr<GpuArena> deviceArena_{nullptr};
-  std::shared_ptr<common::ScanSpec> scanSpec_{nullptr};
-  std::unique_ptr<NimbleStripe> stripe_{nullptr};
-  std::unique_ptr<NimbleFormatParams> formatParams_{nullptr};
-  std::unique_ptr<ColumnReader> reader_{nullptr};
-  dwio::common::ColumnReaderStatistics stats_;
-  io::IoStatistics ioStats_;
-  FileInfo fileInfo_;
-  OperatorStateMap operandStateMap_;
-  std::unique_ptr<WaveStream> waveStream_{nullptr};
-  std::unique_ptr<ReadStream> readStream_{nullptr};
-  std::vector<int32_t> nonNullOutputChildrenIds_;
-  bool earlyStop_{false};
-
-  GpuArena& deviceArena() {
-    return *deviceArena_;
-  }
-};
-
-class NimbleReaderVerifier {
- public:
-  explicit NimbleReaderVerifier(
-      std::unique_ptr<exec::test::ReferenceQueryRunner> referenceQueryRunner =
-          nullptr)
-      : referenceQueryRunner_{std::move(referenceQueryRunner)} {}
-
-  void verify(
-      RowVectorPtr input,
-      const std::vector<FilterSpec>& filters,
-      RowVectorPtr actual);
-
- private:
-  std::unique_ptr<exec::test::ReferenceQueryRunner> referenceQueryRunner_;
-  void verifyWithQueryRunner(
-      RowVectorPtr input,
-      const std::vector<FilterSpec>& filters,
-      RowVectorPtr actual);
-};
-
-// Helper function to create input by combining chunk vector groups
-RowVectorPtr createInputFromChunkVectorGroups(
-    const std::vector<std::vector<VectorPtr>>& chunkVectorGroups);
-
-// Helper function to write multiple vectors to nimble files and get back all
-// streamLoaders. A chunk vector group contains several chunked vectors
-// (mapping to chunked streams in Nimble) that share the same chunk
-// boundaries.
-std::vector<std::unique_ptr<StreamLoader>> writeToNimbleAndGetStreamLoaders(
-    memory::MemoryPool* pool,
-    const std::vector<std::vector<VectorPtr>>& chunkVectorGroups,
-    const std::vector<std::pair<EncodingType, float>>& readFactors,
-    const CompressionOptions& compressionOptions);
-} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/CMakeLists.txt b/velox/experimental/wave/exec/CMakeLists.txt
index fbb9b06d998..d7041d51719 100644
--- a/velox/experimental/wave/exec/CMakeLists.txt
+++ b/velox/experimental/wave/exec/CMakeLists.txt
@@ -40,6 +40,8 @@ add_library(
   WaveSplitReader.cpp
 )
 
+target_compile_options(velox_wave_exec PRIVATE ${VELOX_CUDA_DEBUG_FLAGS})
+
 target_link_libraries(
   velox_wave_exec
   velox_wave_vector
diff --git a/velox/experimental/wave/exec/TableScan.cpp b/velox/experimental/wave/exec/TableScan.cpp
index 6f09865a76a..6e7b3da339d 100644
--- a/velox/experimental/wave/exec/TableScan.cpp
+++ b/velox/experimental/wave/exec/TableScan.cpp
@@ -90,15 +90,39 @@ void TableScan::updateStats(
   }
 }
 
+void TableScan::updateStats(
+    std::unordered_map<std::string, RuntimeMetric> connectorStats,
+    WaveSplitReader* splitReader) {
+  auto lockedStats = stats().wlock();
+  if (splitReader) {
+    lockedStats->rawInputPositions = splitReader->getCompletedRows();
+    lockedStats->rawInputBytes = splitReader->getCompletedBytes();
+  }
+  for (const auto& [name, metric] : connectorStats) {
+    if (name == "ioWaitNanos") {
+      ioWaitNanos_ += metric.sum - lastIoWaitNanos_;
+      lastIoWaitNanos_ = metric.sum;
+    }
+    if (UNLIKELY(lockedStats->runtimeStats.count(name) == 0)) {
+      lockedStats->runtimeStats.insert(
+          std::make_pair(name, RuntimeMetric(metric.unit)));
+    } else {
+      VELOX_CHECK_EQ(lockedStats->runtimeStats.at(name).unit, metric.unit);
+    }
+    lockedStats->runtimeStats.at(name).merge(metric);
+  }
+}
+
 BlockingReason TableScan::nextSplit(ContinueFuture* future) {
   exec::Split split;
   blockingReason_ = driverCtx_->task->getSplitOrFuture(
+      driverCtx_->driverId,
       driverCtx_->splitGroupId,
       planNodeId_,
-      split,
-      blockingFuture_,
       maxPreloadedSplits_,
-      splitPreloader_);
+      splitPreloader_,
+      split,
+      blockingFuture_);
   if (blockingReason_ != BlockingReason::kNotBlocked) {
     return blockingReason_;
   }
@@ -106,7 +130,7 @@ BlockingReason TableScan::nextSplit(ContinueFuture* future) {
   if (!split.hasConnectorSplit()) {
     noMoreSplits_ = true;
     if (dataSource_) {
-      updateStats(dataSource_->runtimeStats());
+      updateStats(dataSource_->getRuntimeStats());
     }
     return BlockingReason::kNotBlocked;
   }
diff --git a/velox/experimental/wave/exec/TableScan.h b/velox/experimental/wave/exec/TableScan.h
index e2481573223..e09ac720ebe 100644
--- a/velox/experimental/wave/exec/TableScan.h
+++ b/velox/experimental/wave/exec/TableScan.h
@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/experimental/wave/exec/WaveOperator.h"
 
 #include "velox/common/time/Timer.h"
@@ -49,7 +50,8 @@ class TableScan : public WaveSourceOperator {
                            ->queryConfig()
                            .preferredOutputBatchRows()) {
     defines_ = std::move(defines);
-    connector_ = connector::getConnector(tableHandle_->connectorId());
+    connector_ =
+        connector::ConnectorRegistry::tryGet(tableHandle_->connectorId());
   }
 
   std::vector<AdvanceResult> canAdvance(WaveStream& stream) override;
@@ -96,6 +98,9 @@ class TableScan : public WaveSourceOperator {
   void updateStats(
       std::unordered_map<std::string, RuntimeCounter> stats,
       WaveSplitReader* splitReader = nullptr);
+  void updateStats(
+      std::unordered_map<std::string, RuntimeMetric> stats,
+      WaveSplitReader* splitReader = nullptr);
 
   // Process-wide IO wait time.
   static std::atomic<uint64_t> ioWaitNanos_;
diff --git a/velox/experimental/wave/exec/WaveDataSource.h b/velox/experimental/wave/exec/WaveDataSource.h
index caf7c28f250..be0cf309cd9 100644
--- a/velox/experimental/wave/exec/WaveDataSource.h
+++ b/velox/experimental/wave/exec/WaveDataSource.h
@@ -56,7 +56,7 @@ class WaveDataSource : public std::enable_shared_from_this<WaveDataSource> {
 
   virtual uint64_t getCompletedRows() = 0;
 
-  virtual std::unordered_map<std::string, RuntimeCounter> runtimeStats() = 0;
+  virtual std::unordered_map<std::string, RuntimeMetric> getRuntimeStats() = 0;
 
   virtual void setFromDataSource(std::shared_ptr<WaveDataSource> source) {
     VELOX_UNSUPPORTED();
diff --git a/velox/experimental/wave/exec/WaveGen.cpp b/velox/experimental/wave/exec/WaveGen.cpp
index 7807909df68..5d1b5f9391b 100644
--- a/velox/experimental/wave/exec/WaveGen.cpp
+++ b/velox/experimental/wave/exec/WaveGen.cpp
@@ -1039,11 +1039,12 @@ void CompileState::generatePrograms() {
     auto firstOperatorIdx = operators_.size();
     if (firstStep->kind() == StepKind::kTableScan) {
       auto& scanStep = firstStep->as<TableScanStep>();
-      operators_.push_back(std::make_unique<TableScan>(
-          *this,
-          operators_.size(),
-          *scanStep.node,
-          std::move(scanStep.defines)));
+      operators_.push_back(
+          std::make_unique<TableScan>(
+              *this,
+              operators_.size(),
+              *scanStep.node,
+              std::move(scanStep.defines)));
       start = 1;
     }
     instructionStatus_ = InstructionStatus();
@@ -1085,10 +1086,11 @@ void CompileState::generatePrograms() {
       levels.back().push_back(std::move(program));
     }
     if (!levels.empty()) {
-      operators_.push_back(std::make_unique<Project>(
-          *this,
-          selectedPipelines_[pipelineIdx_].outputType,
-          std::move(levels)));
+      operators_.push_back(
+          std::make_unique<Project>(
+              *this,
+              selectedPipelines_[pipelineIdx_].outputType,
+              std::move(levels)));
       currentCandidate_->setOutputIds(
           this,
           operators_.back().get(),
diff --git a/velox/experimental/wave/exec/WaveHiveDataSource.cpp b/velox/experimental/wave/exec/WaveHiveDataSource.cpp
index 5bbbfcdc1b8..906989b1706 100644
--- a/velox/experimental/wave/exec/WaveHiveDataSource.cpp
+++ b/velox/experimental/wave/exec/WaveHiveDataSource.cpp
@@ -15,6 +15,8 @@
  */
 
 #include "velox/experimental/wave/exec/WaveHiveDataSource.h"
+#include "velox/connectors/ConnectorRegistry.h"
+#include "velox/connectors/hive/HiveDataSource.h"
 
 namespace facebook::velox::wave {
 
@@ -29,7 +31,7 @@ WaveHiveDataSource::WaveHiveDataSource(
     folly::Executor* executor,
     const connector::ConnectorQueryCtx* connectorQueryCtx,
     const std::shared_ptr<HiveConfig>& hiveConfig,
-    const std::shared_ptr<io::IoStatistics>& ioStats,
+    const std::shared_ptr<io::IoStatistics>& ioStatistics,
     const exec::ExprSet* remainingFilter,
     std::shared_ptr<common::MetadataFilter> metadataFilter) {
   params_.hiveTableHandle = hiveTableHandle;
@@ -40,7 +42,7 @@ WaveHiveDataSource::WaveHiveDataSource(
   params_.executor = executor;
   params_.connectorQueryCtx = connectorQueryCtx;
   params_.hiveConfig = hiveConfig;
-  params_.ioStats = ioStats;
+  params_.ioStatistics = ioStatistics;
   remainingFilter_ = remainingFilter ? remainingFilter->exprs().at(0) : nullptr;
   metadataFilter_ = metadataFilter;
 }
@@ -68,8 +70,8 @@ void WaveHiveDataSource::setFromDataSource(
   splitReader_ = std::move(source->splitReader_);
   // New io will be accounted on the stats of 'source'. Add the existing
   // balance to that.
-  source->params_.ioStats->merge(*params_.ioStats);
-  params_.ioStats = std::move(source->params_.ioStats);
+  source->params_.ioStatistics->merge(*params_.ioStatistics);
+  params_.ioStatistics = std::move(source->params_.ioStatistics);
 }
 
 void WaveHiveDataSource::addSplit(
@@ -77,7 +79,7 @@ void WaveHiveDataSource::addSplit(
   VELOX_CHECK(
       split_ == nullptr,
       "Previous split has not been processed yet. Call next to process the split.");
-  split_ = std::dynamic_pointer_cast<HiveConnectorSplit>(split);
+  split_ = split;
   VELOX_CHECK(split_, "Wrong type of split");
 
   VLOG(1) << "Adding split " << split_->toString();
@@ -123,8 +125,9 @@ bool WaveHiveDataSource::isFinished() {
       if (it == splitReaderStats_.end()) {
         splitReaderStats_.insert(std::make_pair(name, counter));
       } else {
-        splitReaderStats_.insert(std::make_pair(
-            name, RuntimeCounter(it->second.value, counter.unit)));
+        splitReaderStats_.insert(
+            std::make_pair(
+                name, RuntimeCounter(it->second.value, counter.unit)));
       }
     }
     return true;
@@ -140,11 +143,12 @@ uint64_t WaveHiveDataSource::getCompletedRows() {
   return completedRows_;
 }
 
-std::unordered_map<std::string, RuntimeCounter>
-WaveHiveDataSource::runtimeStats() {
-  auto map = runtimeStats_.toMap();
+std::unordered_map<std::string, RuntimeMetric>
+WaveHiveDataSource::getRuntimeStats() {
+  auto map = runtimeStats_.toRuntimeMetricMap();
   for (const auto& [name, counter] : splitReaderStats_) {
-    map.insert(std::make_pair(name, counter));
+    map.insert(
+        std::make_pair(name, RuntimeMetric(counter.value, counter.unit)));
   }
   return map;
 }
@@ -162,29 +166,34 @@ void WaveHiveDataSource::registerConnector() {
   // Create hive connector with config...
   connector::hive::HiveConnectorFactory factory;
   auto hiveConnector = factory.newConnector("wavemock", config, nullptr);
-  connector::registerConnector(hiveConnector);
+  connector::ConnectorRegistry::global().insert(
+      hiveConnector->connectorId(), hiveConnector);
   connector::hive::HiveDataSource::registerWaveDelegateHook(
       [](const HiveTableHandlePtr& hiveTableHandle,
          const std::shared_ptr<common::ScanSpec>& scanSpec,
          const RowTypePtr& readerOutputType,
-         std::unordered_map<std::string, HiveColumnHandlePtr>* partitionKeys,
+         std::unordered_map<std::string, FileColumnHandlePtr>* partitionKeys,
          FileHandleFactory* fileHandleFactory,
          folly::Executor* executor,
          const connector::ConnectorQueryCtx* connectorQueryCtx,
          const std::shared_ptr<HiveConfig>& hiveConfig,
-         const std::shared_ptr<io::IoStatistics>& ioStats,
+         const std::shared_ptr<io::IoStatistics>& ioStatistics,
          const exec::ExprSet* remainingFilter,
          std::shared_ptr<common::MetadataFilter> metadataFilter) {
+        // HiveColumnHandle extends FileColumnHandle, so this cast is safe.
+        auto* hivePartitionKeys = reinterpret_cast<
+            std::unordered_map<std::string, HiveColumnHandlePtr>*>(
+            partitionKeys);
         return std::make_shared<WaveHiveDataSource>(
             hiveTableHandle,
             scanSpec,
             readerOutputType,
-            partitionKeys,
+            hivePartitionKeys,
             fileHandleFactory,
             executor,
             connectorQueryCtx,
             hiveConfig,
-            ioStats,
+            ioStatistics,
             remainingFilter,
             metadataFilter);
       });
diff --git a/velox/experimental/wave/exec/WaveHiveDataSource.h b/velox/experimental/wave/exec/WaveHiveDataSource.h
index 9f994d459cc..d41f430ed56 100644
--- a/velox/experimental/wave/exec/WaveHiveDataSource.h
+++ b/velox/experimental/wave/exec/WaveHiveDataSource.h
@@ -33,7 +33,7 @@ class WaveHiveDataSource : public WaveDataSource {
       folly::Executor* executor,
       const connector::ConnectorQueryCtx* connectorQueryCtx,
       const std::shared_ptr<connector::hive::HiveConfig>& hiveConfig,
-      const std::shared_ptr<io::IoStatistics>& ioStats,
+      const std::shared_ptr<io::IoStatistics>& ioStatistics,
       const exec::ExprSet* remainingFilter,
       std::shared_ptr<common::MetadataFilter> metadataFilter);
 
@@ -59,7 +59,7 @@ class WaveHiveDataSource : public WaveDataSource {
 
   uint64_t getCompletedRows() override;
 
-  std::unordered_map<std::string, RuntimeCounter> runtimeStats() override;
+  std::unordered_map<std::string, RuntimeMetric> getRuntimeStats() override;
 
   static void registerConnector();
 
diff --git a/velox/experimental/wave/exec/WavePlan.cpp b/velox/experimental/wave/exec/WavePlan.cpp
index 30eddd9f9b1..002501033dd 100644
--- a/velox/experimental/wave/exec/WavePlan.cpp
+++ b/velox/experimental/wave/exec/WavePlan.cpp
@@ -848,8 +848,7 @@ void CompileState::planSegment(
       } else if (dynamic_cast<const core::ValuesNode*>(node)) {
         candidate.currentBox->steps.push_back(segment.steps[0]);
         needNewKernel = true;
-      } else if (
-          auto* read = dynamic_cast<const core::AggregationNode*>(node)) {
+      } else if (dynamic_cast<const core::AggregationNode*>(node)) {
         auto* step = segment.steps[0];
         candidate.currentBox->steps.push_back(step);
       }
diff --git a/velox/experimental/wave/exec/WaveSplitReader.h b/velox/experimental/wave/exec/WaveSplitReader.h
index 7d99d0b938e..eb0ea670fb2 100644
--- a/velox/experimental/wave/exec/WaveSplitReader.h
+++ b/velox/experimental/wave/exec/WaveSplitReader.h
@@ -39,7 +39,7 @@ struct SplitReaderParams {
   folly::Executor* executor;
   const connector::ConnectorQueryCtx* connectorQueryCtx;
   std::shared_ptr<connector::hive::HiveConfig> hiveConfig;
-  std::shared_ptr<io::IoStatistics> ioStats;
+  std::shared_ptr<io::IoStatistics> ioStatistics;
 };
 
 class WaveSplitReaderFactory;
diff --git a/velox/experimental/wave/exec/tests/WaveBenchmark.cpp b/velox/experimental/wave/exec/tests/WaveBenchmark.cpp
index 0aff8006b1a..a425c75640b 100644
--- a/velox/experimental/wave/exec/tests/WaveBenchmark.cpp
+++ b/velox/experimental/wave/exec/tests/WaveBenchmark.cpp
@@ -17,6 +17,7 @@
 #include "velox/benchmarks/QueryBenchmarkBase.h"
 #include "velox/dwio/dwrf/writer/Writer.h"
 #include "velox/dwio/parquet/writer/Writer.h"
+#include "velox/exec/OperatorType.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/experimental/wave/common/Cuda.h"
 #include "velox/experimental/wave/exec/ToWave.h"
@@ -219,7 +220,7 @@ class WaveBenchmark : public QueryBenchmarkBase {
       facebook::velox::parquet::WriterOptions options;
       options.memoryPool = childPool.get();
       int32_t flushCounter = 0;
-      options.encoding = parquet::arrow::Encoding::type::BIT_PACKED;
+      options.encoding = parquet::arrow::Encoding::type::kBitPacked;
       options.flushPolicyFactory = [&]() {
         return std::make_unique<facebook::velox::parquet::LambdaFlushPolicy>(
             1000000, 1000000000, [&]() { return (++flushCounter % 1 == 0); });
@@ -257,8 +258,11 @@ class WaveBenchmark : public QueryBenchmarkBase {
         float passRatio = FLAGS_filter_pass_pct / 100.0;
         std::vector<std::string> scanFilters;
         for (auto i = 0; i < FLAGS_num_column_filters; ++i) {
-          scanFilters.push_back(fmt::format(
-              "c{} < {}", i, static_cast<int64_t>(specs_[i].mod * passRatio)));
+          scanFilters.push_back(
+              fmt::format(
+                  "c{} < {}",
+                  i,
+                  static_cast<int64_t>(specs_[i].mod * passRatio)));
         }
         auto builder =
             PlanBuilder(leafPool_.get()).tableScan(type_, scanFilters);
@@ -266,10 +270,11 @@ class WaveBenchmark : public QueryBenchmarkBase {
         for (auto i = FLAGS_num_column_filters;
              i < FLAGS_num_column_filters + FLAGS_num_expr_filters;
              ++i) {
-          builder = builder.filter(fmt::format(
-              "c{} + 1 < {}",
-              i,
-              static_cast<int64_t>(specs_[i].mod * passRatio)));
+          builder = builder.filter(
+              fmt::format(
+                  "c{} + 1 < {}",
+                  i,
+                  static_cast<int64_t>(specs_[i].mod * passRatio)));
         }
 
         std::vector<std::string> aggInputs;
@@ -277,12 +282,13 @@ class WaveBenchmark : public QueryBenchmarkBase {
         std::vector<std::string> keys;
         for (auto i = 0; i < type_->size(); ++i) {
           if (i < FLAGS_num_keys) {
-            keyProjections.push_back(fmt::format(
-                "(c{} / {}) % {} as c{}",
-                i,
-                specs_[i].roundUp,
-                FLAGS_key_mod,
-                i));
+            keyProjections.push_back(
+                fmt::format(
+                    "(c{} / {}) % {} as c{}",
+                    i,
+                    specs_[i].roundUp,
+                    FLAGS_key_mod,
+                    i));
             keys.push_back(fmt::format("c{}", i));
           } else {
             keyProjections.push_back(fmt::format("c{}", i));
@@ -408,7 +414,8 @@ class WaveBenchmark : public QueryBenchmarkBase {
       int64_t rawInputBytes = 0;
       for (auto& pipeline : stats.pipelineStats) {
         auto& first = pipeline.operatorStats[0];
-        if (first.operatorType == "TableScan" || first.operatorType == "Wave") {
+        if (first.operatorType == OperatorType::kTableScan ||
+            first.operatorType == "Wave") {
           rawInputBytes += first.rawInputBytes;
         }
       }
diff --git a/velox/experimental/wave/exec/tests/utils/FileFormat.cpp b/velox/experimental/wave/exec/tests/utils/FileFormat.cpp
index 1c944c94b5a..2673934d3ad 100644
--- a/velox/experimental/wave/exec/tests/utils/FileFormat.cpp
+++ b/velox/experimental/wave/exec/tests/utils/FileFormat.cpp
@@ -383,8 +383,11 @@ void Writer::finishStripe() {
     columns.push_back(encoder->toColumn());
   }
   int32_t numRows = columns[0]->numValues;
-  stripes_.push_back(std::make_unique<Stripe>(
-      std::move(columns), dwio::common::TypeWithId::create(type_), numRows));
+  stripes_.push_back(
+      std::make_unique<Stripe>(
+          std::move(columns),
+          dwio::common::TypeWithId::create(type_),
+          numRows));
   encoders_.clear();
   rowsInStripe_ = 0;
 }
@@ -617,8 +620,9 @@ void Table::fromFile(
       int32_t numRows;
       readNumber(footerStream, numRows);
       auto columns = readColumns(footerStream);
-      stripes.push_back(std::make_unique<Stripe>(
-          std::move(columns), typeWithId, numRows, path));
+      stripes.push_back(
+          std::make_unique<Stripe>(
+              std::move(columns), typeWithId, numRows, path));
     }
   }
   addStripes(std::move(stripes), nullptr);
diff --git a/velox/experimental/wave/exec/tests/utils/FileFormat.h b/velox/experimental/wave/exec/tests/utils/FileFormat.h
index 58e837d6bee..05da39cdacb 100644
--- a/velox/experimental/wave/exec/tests/utils/FileFormat.h
+++ b/velox/experimental/wave/exec/tests/utils/FileFormat.h
@@ -285,8 +285,9 @@ class Table {
     SplitVector result;
     std::lock_guard<std::mutex> l(mutex_);
     for (auto& stripe : stripes_) {
-      result.push_back(std::make_shared<connector::hive::HiveConnectorSplit>(
-          "test-hive", stripe->name, dwio::common::FileFormat::UNKNOWN));
+      result.push_back(
+          std::make_shared<connector::hive::HiveConnectorSplit>(
+              "test-hive", stripe->name, dwio::common::FileFormat::UNKNOWN));
     }
     return result;
   }
diff --git a/velox/experimental/wave/exec/tests/utils/TestFormatReader.cpp b/velox/experimental/wave/exec/tests/utils/TestFormatReader.cpp
index e6032a27e41..b4b9f28d0a2 100644
--- a/velox/experimental/wave/exec/tests/utils/TestFormatReader.cpp
+++ b/velox/experimental/wave/exec/tests/utils/TestFormatReader.cpp
@@ -289,15 +289,17 @@ class TestStructColumnReader : public StructColumnReader {
       auto childParams = TestFormatParams(
           params.pool(), params.runtimeStatistics(), params.stripe());
 
-      path.push_back(std::make_unique<common::Subfield::NestedField>(
-          childSpec->fieldName()));
-      addChild(TestFormatReader::build(
-          childRequestedType,
-          childFileType,
-          params,
-          *childSpec,
-          path,
-          defines));
+      path.push_back(
+          std::make_unique<common::Subfield::NestedField>(
+              childSpec->fieldName()));
+      addChild(
+          TestFormatReader::build(
+              childRequestedType,
+              childFileType,
+              params,
+              *childSpec,
+              path,
+              defines));
       path.pop_back();
       childSpec->setSubscript(children_.size() - 1);
     }
diff --git a/velox/experimental/wave/exec/tests/utils/WaveTestSplitReader.cpp b/velox/experimental/wave/exec/tests/utils/WaveTestSplitReader.cpp
index 6c116695e19..1dfbe7038e6 100644
--- a/velox/experimental/wave/exec/tests/utils/WaveTestSplitReader.cpp
+++ b/velox/experimental/wave/exec/tests/utils/WaveTestSplitReader.cpp
@@ -81,8 +81,9 @@ void WaveTestSplitReader::schedule(WaveStream& waveStream, int32_t maxRows) {
   auto numRows = std::min<int32_t>(maxRows, available());
   scheduledRows_ = numRows;
   auto rowSet = folly::Range<const int32_t*>(iota(numRows, rows_), numRows);
-  std::unique_ptr<ReadStream> exe(reinterpret_cast<ReadStream*>(
-      waveStream.recycleExecutable(nullptr, 0).release()));
+  std::unique_ptr<ReadStream> exe(
+      reinterpret_cast<ReadStream*>(
+          waveStream.recycleExecutable(nullptr, 0).release()));
   if (exe) {
     VELOX_DCHECK_NOT_NULL(
         dynamic_cast<ReadStream*>(reinterpret_cast<Executable*>(exe.get())));
@@ -95,7 +96,7 @@ void WaveTestSplitReader::schedule(WaveStream& waveStream, int32_t maxRows) {
     exe = std::make_unique<ReadStream>(
         reinterpret_cast<StructColumnReader*>(columnReader_.get()),
         waveStream,
-        params_.ioStats.get(),
+        params_.ioStatistics.get(),
         fileInfo_);
   }
   ReadStream::launch(std::move(exe), nextRow_, rowSet);
diff --git a/velox/experimental/wave/exec/tests/utils/WaveTestSplitReader.h b/velox/experimental/wave/exec/tests/utils/WaveTestSplitReader.h
index 320c8a08784..59a3c19743c 100644
--- a/velox/experimental/wave/exec/tests/utils/WaveTestSplitReader.h
+++ b/velox/experimental/wave/exec/tests/utils/WaveTestSplitReader.h
@@ -43,7 +43,7 @@ class WaveTestSplitReader : public WaveSplitReader {
   bool isFinished() const override;
 
   uint64_t getCompletedBytes() override {
-    return params_.ioStats->rawBytesRead();
+    return params_.ioStatistics->rawBytesRead();
   }
 
   uint64_t getCompletedRows() override {
diff --git a/velox/experimental/wave/vector/WaveVector.cpp b/velox/experimental/wave/vector/WaveVector.cpp
index e2b34835ed8..85d3ca2d23c 100644
--- a/velox/experimental/wave/vector/WaveVector.cpp
+++ b/velox/experimental/wave/vector/WaveVector.cpp
@@ -29,7 +29,7 @@ static int32_t kindSize() {
 
 int32_t waveTypeKindSize(WaveTypeKind waveKind) {
   TypeKind kind = static_cast<TypeKind>(waveKind);
-  if (kind == TypeKind::VARCHAR || kind == TypeKind::VARBINARY) {
+  if (is_string_kind(kind)) {
     // Wave StringView is 8, not 16 bytes.
     return sizeof(StringView);
   }
diff --git a/velox/experimental/wave/vector/tests/CMakeLists.txt b/velox/experimental/wave/vector/tests/CMakeLists.txt
index dade3ca1dcd..1dc7377ee4d 100644
--- a/velox/experimental/wave/vector/tests/CMakeLists.txt
+++ b/velox/experimental/wave/vector/tests/CMakeLists.txt
@@ -26,7 +26,6 @@ target_link_libraries(
   Boost::date_time
   Boost::filesystem
   Boost::program_options
-  Boost::regex
   Boost::thread
   Boost::system
   GTest::gtest
diff --git a/velox/expression/CMakeLists.txt b/velox/expression/CMakeLists.txt
index bf2b0d33880..6fc9e8bfef2 100644
--- a/velox/expression/CMakeLists.txt
+++ b/velox/expression/CMakeLists.txt
@@ -12,15 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_type_signature OBJECT TypeSignature.cpp)
+velox_add_library(velox_type_signature OBJECT TypeSignature.cpp HEADERS TypeSignature.h)
 
 velox_link_libraries(velox_type_signature velox_common_base)
 
 velox_add_library(
   velox_expression_functions
   FunctionSignature.cpp
-  SignatureBinder.cpp
   ReverseSignatureBinder.cpp
+  SignatureBinder.cpp
+  VectorFunctionListener.cpp
+  HEADERS
+  FunctionMetadata.h
+  FunctionSignature.h
+  ReverseSignatureBinder.h
+  SignatureBinder.h
+  VectorFunctionListener.h
 )
 
 velox_link_libraries(
@@ -42,21 +49,73 @@ velox_add_library(
   EvalCtx.cpp
   Expr.cpp
   ExprCompiler.cpp
+  ExprRewriteRegistry.cpp
+  ExprOptimizer.cpp
   ExprToSubfieldFilter.cpp
   ExprUtils.cpp
   FieldReference.cpp
   FunctionCallToSpecialForm.cpp
   GenericWriter.cpp
   LambdaExpr.cpp
+  NullIfExpr.cpp
   PeeledEncoding.cpp
   PrestoCastHooks.cpp
   RegisterSpecialForm.cpp
   RowConstructor.cpp
   SimpleFunctionRegistry.cpp
   SpecialFormRegistry.cpp
+  CoalesceRewrite.cpp
+  ConjunctRewrite.cpp
   SwitchExpr.cpp
+  SwitchRewrite.cpp
   TryExpr.cpp
   VectorFunction.cpp
+  HEADERS
+  BooleanMix.h
+  CastExpr-inl.h
+  CastExpr.h
+  CastHooks.h
+  CastTypeChecker.h
+  CoalesceExpr.h
+  CoalesceRewrite.h
+  ComplexViewTypes.h
+  ComplexWriterTypes.h
+  ConjunctExpr.h
+  ConjunctRewrite.h
+  ConstantExpr.h
+  DecodedArgs.h
+  EvalCtx.h
+  Expr.h
+  ExprCompiler.h
+  ExprConstants.h
+  ExprOptimizer.h
+  ExprRewriteRegistry.h
+  ExprStats.h
+  ExprToSubfieldFilter.h
+  ExprUtils.h
+  FieldReference.h
+  FunctionCallToSpecialForm.h
+  KindToSimpleType.h
+  LambdaExpr.h
+  NullIfExpr.h
+  PeeledEncoding.h
+  PrestoCastHooks.h
+  RegisterSpecialForm.h
+  RowConstructor.h
+  ScopedVarSetter.h
+  SimpleFunctionAdapter.h
+  SimpleFunctionRegistry.h
+  SpecialForm.h
+  SpecialFormRegistry.h
+  StringWriter.h
+  SwitchExpr.h
+  SwitchRewrite.h
+  TryExpr.h
+  UdfTypeResolver.h
+  VariadicView.h
+  VectorFunction.h
+  VectorReaders.h
+  VectorWriters.h
 )
 
 velox_link_libraries(
@@ -66,11 +125,13 @@ velox_link_libraries(
   velox_common_base
   velox_expression_functions
   velox_functions_util
+  velox_trace
   velox_type_tz
   double-conversion::double-conversion
   Folly::folly
 )
 
+add_subdirectory(rpc)
 add_subdirectory(type_calculation)
 add_subdirectory(signature_parser)
 
diff --git a/velox/expression/CastExpr-inl.h b/velox/expression/CastExpr-inl.h
index d0b7b2ecded..331ad4a5d10 100644
--- a/velox/expression/CastExpr-inl.h
+++ b/velox/expression/CastExpr-inl.h
@@ -15,10 +15,13 @@
  */
 #pragma once
 
+#include <string_view>
+
 #include "velox/common/base/CountBits.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/core/CoreTypeSystem.h"
 #include "velox/expression/StringWriter.h"
+#include "velox/functions/lib/string/StringCore.h"
 #include "velox/type/Type.h"
 #include "velox/vector/SelectivityVector.h"
 
@@ -29,7 +32,7 @@ inline std::string makeErrorMessage(
     const BaseVector& input,
     vector_size_t row,
     const TypePtr& toType,
-    const std::string& details = "") {
+    std::string_view details = "") {
   return fmt::format(
       "Cannot cast {} '{}' to {}. {}",
       input.type()->toString(),
@@ -49,6 +52,36 @@ inline std::exception_ptr makeBadCastException(
       false));
 }
 
+// Returns true if casting from 'fromType' to 'toType' is a supported fast
+// upcast.
+bool isSupportedFastUpcast(const TypePtr& fromType, const TypePtr& toType) {
+  auto isIntegralType = [](const TypePtr& type) {
+    return type == TINYINT() || type == SMALLINT() || type == INTEGER() ||
+        type == BIGINT();
+  };
+
+  auto isBasicNumericType = [&isIntegralType](const TypePtr& type) {
+    return isIntegralType(type) || type == REAL() || type == DOUBLE();
+  };
+
+  if (isIntegralType(fromType) && isBasicNumericType(toType)) {
+    if (fromType->cppSizeInBytes() < toType->cppSizeInBytes()) {
+      return true;
+    }
+    if (fromType == INTEGER() && toType == REAL()) {
+      return true;
+    }
+    if (fromType == BIGINT() && (toType == REAL() || toType == DOUBLE())) {
+      return true;
+    }
+  }
+
+  if (fromType == REAL() && toType == DOUBLE()) {
+    return true;
+  }
+  return false;
+}
+
 } // namespace
 
 template <typename Func>
@@ -101,7 +134,7 @@ void CastExpr::applyCastKernel(
     const SimpleVector<typename TypeTraits<FromKind>::NativeType>* input,
     FlatVector<typename TypeTraits<ToKind>::NativeType>* result) {
   bool wrapException = true;
-  auto setError = [&](const std::string& details) INLINE_LAMBDA {
+  auto setError = [&](std::string_view details) INLINE_LAMBDA {
     if (setNullInResultAtError()) {
       result->setNull(row, true);
     } else {
@@ -175,8 +208,7 @@ void CastExpr::applyCastKernel(
     }
 
     // Optimize empty input strings casting by avoiding throwing exceptions.
-    if constexpr (
-        FromKind == TypeKind::VARCHAR || FromKind == TypeKind::VARBINARY) {
+    if constexpr (is_string_kind(FromKind)) {
       if constexpr (
           TypeTraits<ToKind>::isPrimitiveType &&
           TypeTraits<ToKind>::isFixedWidth) {
@@ -223,10 +255,9 @@ void CastExpr::applyCastKernel(
       return;
     }
 
-    const auto output = castResult.value();
+    const auto& output = castResult.value();
 
-    if constexpr (
-        ToKind == TypeKind::VARCHAR || ToKind == TypeKind::VARBINARY) {
+    if constexpr (is_string_kind(ToKind)) {
       // Write the result output to the output vector
       auto writer = exec::StringWriter(result, row);
       writer.copy_from(output);
@@ -389,12 +420,27 @@ VectorPtr CastExpr::applyDecimalToFloatCast(
   const auto simpleInput = input.as<SimpleVector<FromNativeType>>();
   const auto scaleFactor = DecimalUtil::kPowersOfTen[precisionScale.second];
   applyToSelectedNoThrowLocal(context, rows, result, [&](int row) {
-    const auto output =
-        util::Converter<ToKind>::tryCast(simpleInput->valueAt(row))
-            .thenOrThrow(folly::identity, [&](const Status& status) {
-              VELOX_USER_FAIL("{}", status.message());
-            });
-    resultBuffer[row] = output / scaleFactor;
+    const auto unscaledValue = simpleInput->valueAt(row);
+    // Avoid precision loss: float has ~7 significant digits; casting unscaled
+    // int128 to float first loses precision for values with 8+ digits (e.g.
+    // 113751964). Divide in double then cast to float so result is correct.
+    To finalValue;
+    if constexpr (ToKind == TypeKind::REAL) {
+      const auto output =
+          util::Converter<TypeKind::DOUBLE>::tryCast(unscaledValue)
+              .thenOrThrow(folly::identity, [&](const Status& status) {
+                VELOX_USER_FAIL("{}", status.message());
+              });
+      finalValue = static_cast<To>(output / scaleFactor);
+    } else {
+      const auto output =
+          util::Converter<ToKind>::tryCast(unscaledValue)
+              .thenOrThrow(folly::identity, [&](const Status& status) {
+                VELOX_USER_FAIL("{}", status.message());
+              });
+      finalValue = output / scaleFactor;
+    }
+    resultBuffer[row] = finalValue;
   });
   return result;
 }
@@ -490,7 +536,11 @@ VectorPtr CastExpr::applyDecimalToVarcharCast(
     char inlined[StringView::kInlineSize];
     applyToSelectedNoThrowLocal(context, rows, result, [&](vector_size_t row) {
       auto actualSize = DecimalUtil::castToString<FromNativeType>(
-          simpleInput->valueAt(row), scale, rowSize, inlined);
+          simpleInput->valueAt(row),
+          scale,
+          rowSize,
+          inlined,
+          hooks_->isScientific());
       flatResult->setNoCopy(row, StringView(inlined, actualSize));
     });
     return result;
@@ -502,7 +552,11 @@ VectorPtr CastExpr::applyDecimalToVarcharCast(
 
   applyToSelectedNoThrowLocal(context, rows, result, [&](vector_size_t row) {
     auto actualSize = DecimalUtil::castToString<FromNativeType>(
-        simpleInput->valueAt(row), scale, rowSize, rawBuffer);
+        simpleInput->valueAt(row),
+        scale,
+        rowSize,
+        rawBuffer,
+        hooks_->isScientific());
     flatResult->setNoCopy(row, StringView(rawBuffer, actualSize));
     if (!StringView::isInline(actualSize)) {
       // If string view is inline, corresponding bytes on the raw string buffer
@@ -593,6 +647,61 @@ void CastExpr::applyCastPrimitives(
   }
 }
 
+template <TypeKind ToKind, TypeKind FromKind>
+void CastExpr::applyNumericUpcast(
+    const SelectivityVector& rows,
+    const TypePtr& toType,
+    exec::EvalCtx& context,
+    const BaseVector& input,
+    VectorPtr& result) {
+  constexpr auto isNumericTypeKind = [](TypeKind kind) constexpr {
+    return kind == TypeKind::TINYINT || kind == TypeKind::SMALLINT ||
+        kind == TypeKind::INTEGER || kind == TypeKind::BIGINT ||
+        kind == TypeKind::REAL || kind == TypeKind::DOUBLE;
+  };
+
+  if constexpr (isNumericTypeKind(ToKind) && isNumericTypeKind(FromKind)) {
+    using ToNativeType = typename TypeTraits<ToKind>::NativeType;
+    using FromNativeType = typename TypeTraits<FromKind>::NativeType;
+
+    if (input.isConstantEncoding()) {
+      auto constantInput = input.as<ConstantVector<FromNativeType>>();
+      if (constantInput->isNullAt(0)) {
+        result =
+            BaseVector::createNullConstant(toType, rows.end(), context.pool());
+        return;
+      }
+      auto constantValue = static_cast<ToNativeType>(constantInput->valueAt(0));
+      result = std::make_shared<ConstantVector<ToNativeType>>(
+          context.pool(),
+          rows.end(),
+          /*isNull=*/false,
+          toType,
+          std::move(constantValue));
+      return;
+    }
+
+    if (input.isFlatEncoding()) {
+      const auto simpleInput = input.asFlatVector<FromNativeType>();
+      auto flatResult = result->asFlatVector<ToNativeType>();
+
+      const FromNativeType* in =
+          simpleInput->template rawValues<FromNativeType>();
+      ToNativeType* out = flatResult->template mutableRawValues<ToNativeType>();
+
+      rows.applyToSelected([&](auto row) {
+        // Converting large bigint values to float/double directly may lose
+        // precision, but it's consistent with the implementation in
+        // velox/type/Conversions.h.
+        out[row] = static_cast<ToNativeType>(in[row]);
+      });
+      return;
+    }
+  }
+  VELOX_UNSUPPORTED(
+      "Cannot upcast from {} to {}", input.type(), toType->toString());
+}
+
 template <TypeKind ToKind>
 void CastExpr::applyCastPrimitivesDispatch(
     const TypePtr& fromType,
@@ -603,6 +712,19 @@ void CastExpr::applyCastPrimitivesDispatch(
     VectorPtr& result) {
   context.ensureWritable(rows, toType, result);
 
+  if (isSupportedFastUpcast(fromType, toType)) {
+    VELOX_DYNAMIC_SCALAR_TEMPLATE_TYPE_DISPATCH(
+        applyNumericUpcast,
+        ToKind,
+        fromType->kind(),
+        rows,
+        toType,
+        context,
+        input,
+        result);
+    return;
+  }
+
   // This already excludes complex types, hugeint and unknown from type kinds.
   VELOX_DYNAMIC_SCALAR_TEMPLATE_TYPE_DISPATCH(
       applyCastPrimitives,
diff --git a/velox/expression/CastExpr.cpp b/velox/expression/CastExpr.cpp
index 99d3b300589..1fa4dd7e14c 100644
--- a/velox/expression/CastExpr.cpp
+++ b/velox/expression/CastExpr.cpp
@@ -24,7 +24,9 @@
 #include "velox/expression/PeeledEncoding.h"
 #include "velox/expression/PrestoCastHooks.h"
 #include "velox/expression/ScopedVarSetter.h"
+#include "velox/external/tzdb/time_zone.h"
 #include "velox/functions/lib/RowsTranslationUtil.h"
+#include "velox/type/CastRegistry.h"
 #include "velox/type/Type.h"
 #include "velox/type/tz/TimeZoneMap.h"
 #include "velox/vector/ComplexVector.h"
@@ -213,6 +215,196 @@ VectorPtr CastExpr::castFromIntervalDayTime(
   }
 }
 
+VectorPtr CastExpr::castFromTime(
+    const SelectivityVector& rows,
+    const BaseVector& input,
+    exec::EvalCtx& context,
+    const TypePtr& toType) {
+  VectorPtr castResult;
+  context.ensureWritable(rows, toType, castResult);
+  (*castResult).clearNulls(rows);
+
+  auto* inputFlatVector = input.as<SimpleVector<int64_t>>();
+  switch (toType->kind()) {
+    case TypeKind::VARCHAR: {
+      // Get session timezone
+      const auto* timeZone =
+          getTimeZoneFromConfig(context.execCtx()->queryCtx()->queryConfig());
+      // Get session start time
+      const auto startTimeMs =
+          context.execCtx()->queryCtx()->queryConfig().sessionStartTimeMs();
+      auto systemDay = std::chrono::milliseconds{startTimeMs} / kMillisInDay;
+
+      auto* resultFlatVector = castResult->as<FlatVector<StringView>>();
+
+      Buffer* buffer = resultFlatVector->getBufferWithSpace(
+          rows.countSelected() * TIME()->timeToVarcharRowSize(),
+          true /*exactSize*/);
+      char* rawBuffer = buffer->asMutable<char>() + buffer->size();
+
+      applyToSelectedNoThrowLocal(context, rows, castResult, [&](int row) {
+        try {
+          // Use timezone-aware conversion
+          auto systemTime =
+              systemDay.count() * kMillisInDay + inputFlatVector->valueAt(row);
+
+          int64_t adjustedTime{0};
+          if (timeZone) {
+            adjustedTime =
+                (timeZone->to_local(std::chrono::milliseconds{systemTime}) %
+                 kMillisInDay)
+                    .count();
+          } else {
+            adjustedTime = systemTime % kMillisInDay;
+          }
+
+          if (adjustedTime < 0) {
+            adjustedTime += kMillisInDay;
+          }
+
+          auto output = TIME()->valueToString(adjustedTime, rawBuffer);
+          resultFlatVector->setNoCopy(row, output);
+          rawBuffer += output.size();
+        } catch (const VeloxException& ue) {
+          if (!ue.isUserError()) {
+            throw;
+          }
+          VELOX_USER_FAIL(
+              makeErrorMessage(input, row, toType) + " " + ue.message());
+        } catch (const std::exception& e) {
+          VELOX_USER_FAIL(
+              makeErrorMessage(input, row, toType) + " " + e.what());
+        }
+      });
+
+      buffer->setSize(rawBuffer - buffer->asMutable<char>());
+      return castResult;
+    }
+    case TypeKind::BIGINT: {
+      // if input is constant, create a constant output vector
+      if (input.isConstantEncoding()) {
+        auto constantInput = input.as<ConstantVector<int64_t>>();
+        if (constantInput->isNullAt(0)) {
+          return BaseVector::createNullConstant(
+              toType, rows.end(), context.pool());
+        } else {
+          auto constantValue = constantInput->valueAt(0);
+          return std::make_shared<ConstantVector<int64_t>>(
+              context.pool(),
+              rows.end(),
+              false, // isNull
+              toType,
+              std::move(constantValue));
+        }
+      }
+
+      // fallback to element-wise copy for non-constant inputs
+      auto* resultFlatVector = castResult->as<FlatVector<int64_t>>();
+      applyToSelectedNoThrowLocal(context, rows, castResult, [&](int row) {
+        resultFlatVector->set(row, inputFlatVector->valueAt(row));
+      });
+      return castResult;
+    }
+    case TypeKind::TIMESTAMP: {
+      // if input is constant, create a constant output vector
+      if (input.isConstantEncoding()) {
+        auto constantInput = input.as<ConstantVector<int64_t>>();
+        if (constantInput->isNullAt(0)) {
+          return BaseVector::createNullConstant(
+              toType, rows.end(), context.pool());
+        } else {
+          auto timeMillis = constantInput->valueAt(0);
+          return std::make_shared<ConstantVector<Timestamp>>(
+              context.pool(),
+              rows.end(),
+              false, // isNull
+              toType,
+              Timestamp::fromMillis(timeMillis));
+        }
+      }
+
+      // fallback to element-wise copy for non-constant inputs
+      auto* resultFlatVector = castResult->as<FlatVector<Timestamp>>();
+      applyToSelectedNoThrowLocal(context, rows, castResult, [&](int row) {
+        auto timeMillis = inputFlatVector->valueAt(row);
+        resultFlatVector->set(row, Timestamp::fromMillis(timeMillis));
+      });
+      return castResult;
+    }
+    default:
+      VELOX_UNSUPPORTED(
+          "Cast from TIME to {} is not supported", toType->toString());
+  }
+}
+
+VectorPtr CastExpr::castToTime(
+    const SelectivityVector& rows,
+    const BaseVector& input,
+    exec::EvalCtx& context,
+    const TypePtr& fromType) {
+  switch (fromType->kind()) {
+    case TypeKind::VARCHAR: {
+      VectorPtr castResult;
+      context.ensureWritable(rows, TIME(), castResult);
+      (*castResult).clearNulls(rows);
+
+      // Get session timezone and start time for timezone conversions
+      const auto* timeZone =
+          getTimeZoneFromConfig(context.execCtx()->queryCtx()->queryConfig());
+      const auto sessionStartTimeMs =
+          context.execCtx()->queryCtx()->queryConfig().sessionStartTimeMs();
+
+      auto* inputVector = input.as<SimpleVector<StringView>>();
+      auto* resultFlatVector = castResult->as<FlatVector<int64_t>>();
+
+      applyToSelectedNoThrowLocal(context, rows, castResult, [&](int row) {
+        try {
+          const auto inputString = inputVector->valueAt(row);
+          int64_t result =
+              TIME()->valueToTime(inputString, timeZone, sessionStartTimeMs);
+          resultFlatVector->set(row, result);
+        } catch (const VeloxException& ue) {
+          if (!ue.isUserError()) {
+            throw;
+          }
+          VELOX_USER_FAIL(
+              makeErrorMessage(input, row, TIME()) + " " + ue.message());
+        } catch (const std::exception& e) {
+          VELOX_USER_FAIL(
+              makeErrorMessage(input, row, TIME()) + " " + e.what());
+        }
+      });
+
+      return castResult;
+    }
+    case TypeKind::TIMESTAMP: {
+      VectorPtr castResult;
+      context.ensureWritable(rows, TIME(), castResult);
+      (*castResult).clearNulls(rows);
+
+      auto* inputVector = input.as<SimpleVector<Timestamp>>();
+      auto* resultFlatVector = castResult->as<FlatVector<int64_t>>();
+
+      // Cast from TIMESTAMP to TIME extracts the time-of-day component
+      // (milliseconds since midnight) from the timestamp
+      applyToSelectedNoThrowLocal(context, rows, castResult, [&](int row) {
+        const auto timestamp = inputVector->valueAt(row);
+        // Extract time-of-day using std::chrono.
+        // floor() also rounds towards negative infinity, so this correctly
+        // handles negative timestamps.
+        auto millis = std::chrono::milliseconds{timestamp.toMillis()};
+        auto timeOfDay = millis - std::chrono::floor<std::chrono::days>(millis);
+        resultFlatVector->set(row, timeOfDay.count());
+      });
+
+      return castResult;
+    }
+    default:
+      VELOX_UNSUPPORTED(
+          "Cast from {} to TIME is not supported", fromType->toString());
+  }
+}
+
 namespace {
 void propagateErrorsOrSetNulls(
     bool setNullInResultAtError,
@@ -220,11 +412,11 @@ void propagateErrorsOrSetNulls(
     const SelectivityVector& nestedRows,
     const BufferPtr& elementToTopLevelRows,
     VectorPtr& result,
-    EvalErrorsPtr& oldErrors) {
+    exec::EvalErrorsPtr& oldErrors) {
   if (context.errors()) {
     if (setNullInResultAtError) {
-      // Errors in context.errors() should be translated to nulls in the top
-      // level rows.
+      // Errors in context.errors() should be translated to nulls in
+      // the top level rows.
       context.convertElementErrorsToTopLevelNulls(
           nestedRows, elementToTopLevelRows, result);
     } else {
@@ -251,8 +443,8 @@ VectorPtr CastExpr::applyMap(
     exec::EvalCtx& context,
     const MapType& fromType,
     const MapType& toType) {
-  // Cast input keys/values vector to output keys/values vector using their
-  // element selectivity vector
+  // Cast input keys/values vector to output keys/values vector using
+  // their element selectivity vector
 
   // Initialize nested rows
   auto mapKeys = input->mapKeys();
@@ -304,8 +496,8 @@ VectorPtr CastExpr::applyMap(
     }
   }
 
-  // Returned map vector should be addressable for every element, even those
-  // that are not selected.
+  // Returned map vector should be addressable for every element, even
+  // those that are not selected.
   BufferPtr sizes = input->sizes();
   if (newMapKeys->isConstantEncoding() && newMapValues->isConstantEncoding()) {
     // We extends size since that is cheap.
@@ -353,8 +545,8 @@ VectorPtr CastExpr::applyArray(
     exec::EvalCtx& context,
     const ArrayType& fromType,
     const ArrayType& toType) {
-  // Cast input array elements to output array elements based on their types
-  // using their linear selectivity vector
+  // Cast input array elements to output array elements based on their
+  // types using their linear selectivity vector
   auto arrayElements = input->elements();
 
   auto nestedRows =
@@ -377,8 +569,8 @@ VectorPtr CastExpr::applyArray(
         newElements);
   }
 
-  // Returned array vector should be addressable for every element, even those
-  // that are not selected.
+  // Returned array vector should be addressable for every element,
+  // even those that are not selected.
   BufferPtr sizes = input->sizes();
   if (newElements->isConstantEncoding()) {
     // If the newElements we extends its size since that is cheap.
@@ -423,8 +615,8 @@ VectorPtr CastExpr::applyRow(
   int numInputChildren = input->children().size();
   int numOutputChildren = toRowType.size();
 
-  // Extract the flag indicating matching of children must be done by name or
-  // position
+  // Extract the flag indicating matching of children must be done by
+  // name or position
   auto matchByName =
       context.execCtx()->queryCtx()->queryConfig().isMatchStructByName();
 
@@ -434,14 +626,16 @@ VectorPtr CastExpr::applyRow(
 
   EvalErrorsPtr oldErrors;
   if (setNullInResultAtError()) {
-    // We need to isolate errors that happen during the cast from previous
-    // errors since those translate to nulls, unlike exisiting errors.
+    // We need to isolate errors that happen during the cast from
+    // previous errors since those translate to nulls, unlike
+    // exisiting errors.
     context.swapErrors(oldErrors);
   }
 
   for (auto toChildrenIndex = 0; toChildrenIndex < numOutputChildren;
        toChildrenIndex++) {
-    // For each child, find the corresponding column index in the output
+    // For each child, find the corresponding column index in the
+    // output
     const auto& toFieldName = toRowType.nameOf(toChildrenIndex);
     bool matchNotFound = false;
 
@@ -589,13 +783,12 @@ void CastExpr::applyPeeled(
     const TypePtr& toType,
     VectorPtr& result) {
   auto castFromOperator = getCastOperator(fromType);
-  if (castFromOperator && !castFromOperator->isSupportedToType(toType)) {
-    VELOX_USER_FAIL(
-        "Cannot cast {} to {}.", fromType->toString(), toType->toString());
-  }
-
   auto castToOperator = getCastOperator(toType);
-  if (castToOperator && !castToOperator->isSupportedFromType(fromType)) {
+
+  // CastRulesRegistry is the source of truth for all custom type cast
+  // validation, including container types (e.g., ARRAY<T> → JSON).
+  if ((castFromOperator || castToOperator) &&
+      !CastRulesRegistry::instance().canCast(fromType, toType)) {
     VELOX_USER_FAIL(
         "Cannot cast {} to {}.", fromType->toString(), toType->toString());
   }
@@ -615,8 +808,8 @@ void CastExpr::applyPeeled(
     };
 
     if (setNullInResultAtError()) {
-      // This can be optimized by passing setNullInResultAtError() to castTo and
-      // castFrom operations.
+      // This can be optimized by passing setNullInResultAtError() to
+      // castTo and castFrom operations.
 
       EvalErrorsPtr oldErrors;
       context.swapErrors(oldErrors);
@@ -650,6 +843,12 @@ void CastExpr::applyPeeled(
         "Cast from {} to {} is not supported",
         fromType->toString(),
         toType->toString());
+  } else if (fromType->isTime()) {
+    VELOX_DCHECK(fromType->equivalent(*TIME()));
+    result = castFromTime(rows, input, context, toType);
+  } else if (toType->isTime()) {
+    VELOX_DCHECK(toType->equivalent(*TIME()));
+    result = castToTime(rows, input, context, fromType);
   } else if (toType->isShortDecimal()) {
     result = applyDecimal<int64_t>(rows, input, context, fromType, toType);
   } else if (toType->isLongDecimal()) {
@@ -769,8 +968,8 @@ VectorPtr CastExpr::applyTimestampToVarcharCast(
     const auto stringView =
         Timestamp::tsToStringView(inputValue, options, rawBuffer);
     flatResult->setNoCopy(row, stringView);
-    // The result of both Presto and Spark contains more than 12 digits even
-    // when 'zeroPaddingYear' is disabled.
+    // The result of both Presto and Spark contains more than 12
+    // digits even when 'zeroPaddingYear' is disabled.
     VELOX_DCHECK(!stringView.isInline());
     rawBuffer += stringView.size();
   });
@@ -867,8 +1066,8 @@ void CastExpr::apply(
   context.moveOrCopyResult(localResult, *remainingRows, result);
   context.releaseVector(localResult);
 
-  // If there are nulls or rows that encountered errors in the input, add nulls
-  // to the result at the same rows.
+  // If there are nulls or rows that encountered errors in the input,
+  // add nulls to the result at the same rows.
   VELOX_CHECK_NOT_NULL(result);
   if (rawNulls || context.errors()) {
     EvalCtx::addNulls(
@@ -897,7 +1096,8 @@ void CastExpr::evalSpecialForm(
   } else {
     apply(rows, input, context, fromType, toType, result);
   }
-  // Return 'input' back to the vector pool in 'context' so it can be reused.
+  // Return 'input' back to the vector pool in 'context' so it can be
+  // reused.
   context.releaseVector(input);
 }
 
diff --git a/velox/expression/CastExpr.h b/velox/expression/CastExpr.h
index 5ae6d952018..9a08ceaba41 100644
--- a/velox/expression/CastExpr.h
+++ b/velox/expression/CastExpr.h
@@ -28,14 +28,6 @@ class CastOperator {
  public:
   virtual ~CastOperator() = default;
 
-  /// Determines whether the cast operator supports casting to the custom type
-  /// from the other type.
-  virtual bool isSupportedFromType(const TypePtr& other) const = 0;
-
-  /// Determines whether the cast operator supports casting from the custom type
-  /// to the other type.
-  virtual bool isSupportedToType(const TypePtr& other) const = 0;
-
   /// Casts an input vector to the custom type. This function should not throw
   /// when processing input rows, but report errors via context.setError().
   /// @param input The flat or constant input vector
@@ -106,14 +98,7 @@ class CastExpr : public SpecialForm {
 
   std::string toSql(std::vector<VectorPtr>*) const override;
 
- private:
-  /// Apply the cast after generating the input vectors
-  /// @param rows The list of rows being processed
-  /// @param input The input vector to be casted
-  /// @param context The context
-  /// @param fromType the input type
-  /// @param toType the target type
-  /// @param result The result vector
+  /// Casts 'input' from 'fromType' to 'toType' for selected 'rows'.
   void apply(
       const SelectivityVector& rows,
       const VectorPtr& input,
@@ -122,6 +107,7 @@ class CastExpr : public SpecialForm {
       const TypePtr& toType,
       VectorPtr& result);
 
+ private:
   VectorPtr applyMap(
       const SelectivityVector& rows,
       const MapVector* input,
@@ -204,6 +190,18 @@ class CastExpr : public SpecialForm {
       exec::EvalCtx& context,
       const TypePtr& toType);
 
+  VectorPtr castFromTime(
+      const SelectivityVector& rows,
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const TypePtr& toType);
+
+  VectorPtr castToTime(
+      const SelectivityVector& rows,
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const TypePtr& fromType);
+
   template <typename TInput, typename TOutput>
   void applyDecimalCastKernel(
       const SelectivityVector& rows,
@@ -302,6 +300,15 @@ class CastExpr : public SpecialForm {
       exec::EvalCtx& context,
       const BaseVector& input);
 
+  // Casts basic numeric types to wider types.
+  template <TypeKind ToKind, TypeKind FromKind>
+  void applyNumericUpcast(
+      const SelectivityVector& rows,
+      const TypePtr& toType,
+      exec::EvalCtx& context,
+      const BaseVector& input,
+      VectorPtr& result);
+
   bool isTryCast() const {
     return isTryCast_;
   }
diff --git a/velox/expression/CastHooks.h b/velox/expression/CastHooks.h
index f51ce56ed9d..7b1a1fba75b 100644
--- a/velox/expression/CastHooks.h
+++ b/velox/expression/CastHooks.h
@@ -76,5 +76,11 @@ class CastHooks {
 
   /// Converts boolean to timestamp type.
   virtual Expected<Timestamp> castBooleanToTimestamp(bool seconds) const = 0;
+
+  /// Returns whether to format small magnitude decimals using scientific
+  /// notation. Example: with scale 20 and value 1, the output is
+  /// "1E-20" when isScientific() is true, and "0.00000000000000000001" when
+  /// false.
+  virtual bool isScientific() const = 0;
 };
 } // namespace facebook::velox::exec
diff --git a/velox/expression/CoalesceExpr.cpp b/velox/expression/CoalesceExpr.cpp
index deb9badb8a8..464cfa01308 100644
--- a/velox/expression/CoalesceExpr.cpp
+++ b/velox/expression/CoalesceExpr.cpp
@@ -14,11 +14,66 @@
  * limitations under the License.
  */
 #include "velox/expression/CoalesceExpr.h"
-
 #include "velox/expression/ExprConstants.h"
+#include "velox/type/TypeCoercer.h"
 
 namespace facebook::velox::exec {
 
+namespace {
+
+TypePtr resolveTypeInt(
+    const std::vector<TypePtr>& argTypes,
+    bool allowedCoercions,
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer) {
+  VELOX_CHECK_GT(
+      argTypes.size(),
+      0,
+      "COALESCE statements expect to receive at least 1 argument, but did not receive any.");
+
+  const auto numArgs = argTypes.size();
+
+  if (allowedCoercions) {
+    coercions.clear();
+    coercions.resize(numArgs);
+  }
+
+  auto resultType = argTypes[0];
+
+  for (auto i = 1; i < numArgs; i++) {
+    if (*resultType == *argTypes[i]) {
+      continue;
+    }
+
+    if (allowedCoercions && coercer.coercible(argTypes[i], resultType)) {
+      coercions[i] = resultType;
+      continue;
+    }
+
+    if (allowedCoercions && coercer.coercible(resultType, argTypes[i])) {
+      resultType = argTypes[i];
+      for (auto j = 0; j < i; j++) {
+        coercions[j] = resultType;
+      }
+      continue;
+    }
+
+    VELOX_USER_CHECK(
+        *argTypes[0] == *argTypes[i],
+        "Inputs to coalesce must have the same type. Expected {}, but got {}.",
+        argTypes[0]->toString(),
+        argTypes[i]->toString());
+  }
+
+  return resultType;
+}
+
+TypePtr resolveTypeInt(const std::vector<TypePtr>& argTypes) {
+  std::vector<TypePtr> coercions;
+  return resolveTypeInt(argTypes, false, coercions, TypeCoercer::defaults());
+}
+} // namespace
+
 CoalesceExpr::CoalesceExpr(
     TypePtr type,
     std::vector<ExprPtr>&& inputs,
@@ -39,7 +94,7 @@ CoalesceExpr::CoalesceExpr(
       [](const ExprPtr& expr) { return expr->type(); });
 
   // Apply type checks.
-  auto expectedType = resolveType(inputTypes);
+  auto expectedType = resolveTypeInt(inputTypes);
   VELOX_CHECK(
       *expectedType == *this->type(),
       "Coalesce expression type different than its inputs. Expected {}, but got {}.",
@@ -88,26 +143,16 @@ void CoalesceExpr::evalSpecialForm(
   }
 }
 
-// static
-TypePtr CoalesceExpr::resolveType(const std::vector<TypePtr>& argTypes) {
-  VELOX_CHECK_GT(
-      argTypes.size(),
-      0,
-      "COALESCE statements expect to receive at least 1 argument, but did not receive any.");
-  for (auto i = 1; i < argTypes.size(); i++) {
-    VELOX_USER_CHECK(
-        *argTypes[0] == *argTypes[i],
-        "Inputs to coalesce must have the same type. Expected {}, but got {}.",
-        argTypes[0]->toString(),
-        argTypes[i]->toString());
-  }
-
-  return argTypes[0];
-}
-
 TypePtr CoalesceCallToSpecialForm::resolveType(
     const std::vector<TypePtr>& argTypes) {
-  return CoalesceExpr::resolveType(argTypes);
+  return resolveTypeInt(argTypes);
+}
+
+TypePtr CoalesceCallToSpecialForm::resolveTypeWithCoercions(
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer) {
+  return resolveTypeInt(argTypes, true, coercions, coercer);
 }
 
 ExprPtr CoalesceCallToSpecialForm::constructSpecialForm(
diff --git a/velox/expression/CoalesceExpr.h b/velox/expression/CoalesceExpr.h
index e451a390a89..aa97be01aa7 100644
--- a/velox/expression/CoalesceExpr.h
+++ b/velox/expression/CoalesceExpr.h
@@ -37,15 +37,20 @@ class CoalesceExpr : public SpecialForm {
     propagatesNulls_ = false;
   }
 
-  static TypePtr resolveType(const std::vector<TypePtr>& argTypes);
-
   friend class CoalesceCallToSpecialForm;
 };
 
 class CoalesceCallToSpecialForm : public FunctionCallToSpecialForm {
  public:
+  /// Returns the type of the 1st argument. Throws if 'argTypes' is empty or not
+  /// argument types are the same.
   TypePtr resolveType(const std::vector<TypePtr>& argTypes) override;
 
+  TypePtr resolveTypeWithCoercions(
+      const std::vector<TypePtr>& argTypes,
+      std::vector<TypePtr>& coercions,
+      const TypeCoercer& coercer) override;
+
   ExprPtr constructSpecialForm(
       const TypePtr& type,
       std::vector<ExprPtr>&& compiledChildren,
diff --git a/velox/expression/CoalesceRewrite.cpp b/velox/expression/CoalesceRewrite.cpp
new file mode 100644
index 00000000000..96a7f35dedc
--- /dev/null
+++ b/velox/expression/CoalesceRewrite.cpp
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <set>
+
+#include "velox/expression/CoalesceRewrite.h"
+#include "velox/expression/ExprConstants.h"
+#include "velox/expression/ExprRewriteRegistry.h"
+#include "velox/expression/ExprUtils.h"
+
+namespace facebook::velox::expression {
+
+core::TypedExprPtr CoalesceRewrite::rewrite(const core::TypedExprPtr& expr) {
+  if (!expr->isCallKind()) {
+    return nullptr;
+  }
+  const auto* callExpr = expr->asUnchecked<core::CallTypedExpr>();
+  if (callExpr->name() != kCoalesce) {
+    return nullptr;
+  }
+
+  // Deduplicate inputs to COALESCE and remove NULL inputs.
+  std::vector<core::TypedExprPtr> flat;
+  utils::flattenInput(expr, kCoalesce, flat);
+  folly::F14FastSet<
+      const core::ITypedExpr*,
+      core::ITypedExprHasher,
+      core::ITypedExprComparer>
+      uniqueInputs;
+  std::vector<core::TypedExprPtr> deduplicatedInputs;
+
+  for (const auto& input : flat) {
+    if (input->isConstantKind()) {
+      const auto* constantExpr = input->asUnchecked<core::ConstantTypedExpr>();
+      if (constantExpr->isNull()) {
+        // Drop NULL constant.
+        continue;
+      }
+
+      if (uniqueInputs.empty()) {
+        // Return first non-NULL constant input.
+        return input;
+      }
+
+      // Drop inputs after non-NULL constant input.
+      uniqueInputs.insert(input.get());
+      deduplicatedInputs.push_back(input);
+      break;
+    } else {
+      if (uniqueInputs.emplace(input.get()).second) {
+        deduplicatedInputs.push_back(input);
+      }
+    }
+  }
+
+  // Return NULL if all inputs to COALESCE are NULL.
+  if (uniqueInputs.empty()) {
+    return flat.front();
+  }
+  // If there is a single input to COALESCE, return this expression.
+  if (uniqueInputs.size() == 1) {
+    return deduplicatedInputs.front();
+  }
+
+  return std::make_shared<core::CallTypedExpr>(
+      expr->type(), std::move(deduplicatedInputs), kCoalesce);
+}
+
+void CoalesceRewrite::registerRewrite() {
+  expression::ExprRewriteRegistry::instance().registerRewrite(
+      expression::CoalesceRewrite::rewrite);
+}
+
+} // namespace facebook::velox::expression
diff --git a/velox/expression/CoalesceRewrite.h b/velox/expression/CoalesceRewrite.h
new file mode 100644
index 00000000000..9954fd34709
--- /dev/null
+++ b/velox/expression/CoalesceRewrite.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/core/Expressions.h"
+
+namespace facebook::velox::expression {
+
+class CoalesceRewrite {
+ public:
+  /// Rewrites COALESCE special form expression. Nested COALESCE expressions are
+  /// first flattened in a recursive manner, eg: COALESCE(a, COALESCE(b, c)) ->
+  /// COALESCE(a, b, c). The inputs to COALESCE are then traversed in order and:
+  ///  1. If the input is constant:
+  ///     a. and it is NULL, the input is removed.
+  ///     b. and if there are no inputs before this, the COALESCE expression is
+  ///        simplified to this constant input.
+  ///     c. otherwise, all subsequent inputs after this are removed.
+  ///  2. Otherwise, if the same input is seen before, it is removed i.e non
+  ///     constant inputs to COALESCE are deduplicated.
+  /// If there is a single input to COALESCE after pruning inputs, COALESCE is
+  /// simplified to this expression. Otherwise, returns an optimized COALESCE
+  /// expression with pruned inputs.
+  static core::TypedExprPtr rewrite(const core::TypedExprPtr& expr);
+
+  static void registerRewrite();
+};
+
+} // namespace facebook::velox::expression
diff --git a/velox/expression/ComplexViewTypes.h b/velox/expression/ComplexViewTypes.h
index be7888ba36d..549b7fc865d 100644
--- a/velox/expression/ComplexViewTypes.h
+++ b/velox/expression/ComplexViewTypes.h
@@ -599,6 +599,7 @@ class ArrayView {
 
   materialize_t materialize() const {
     materialize_t result;
+    result.reserve(size_);
 
     for (const auto& element : *this) {
       if constexpr (returnsOptionalValues) {
@@ -814,6 +815,7 @@ class MapView {
 
   materialize_t materialize() const {
     materialize_t result;
+    result.reserve(size());
     for (const auto& [key, value] : *this) {
       if constexpr (returnsOptionalValues) {
         if (value.has_value()) {
diff --git a/velox/expression/ComplexWriterTypes.h b/velox/expression/ComplexWriterTypes.h
index bd04399e5e0..88f4cf40631 100644
--- a/velox/expression/ComplexWriterTypes.h
+++ b/velox/expression/ComplexWriterTypes.h
@@ -125,8 +125,14 @@ class ArrayWriter {
     auto currentSize = size + valuesOffset_;
 
     if (UNLIKELY(currentSize > elementsVectorCapacity_)) {
-      elementsVectorCapacity_ = std::pow(2, std::ceil(std::log2(currentSize)));
-      childWriter_->ensureSize(elementsVectorCapacity_);
+      const vector_size_t childCapacity =
+          std::pow(2, std::ceil(std::log2(currentSize)));
+      childWriter_->ensureSize(childCapacity);
+
+      // Only update capacity_ after the writer has been successfully resized
+      // to ensure it accurately reflects the size of the elements even in the
+      // presence of failures.
+      elementsVectorCapacity_ = childCapacity;
     }
   }
 
@@ -605,10 +611,16 @@ class MapWriter {
     auto currentSize = size + innerOffset_;
 
     if (UNLIKELY(currentSize > capacity_)) {
-      capacity_ = std::pow(2, std::ceil(std::log2(currentSize)));
+      const vector_size_t childCapacity =
+          std::pow(2, std::ceil(std::log2(currentSize)));
 
-      keysWriter_->ensureSize(capacity_);
-      valuesWriter_->ensureSize(capacity_);
+      keysWriter_->ensureSize(childCapacity);
+      valuesWriter_->ensureSize(childCapacity);
+
+      // Only update capacity_ after the writers have been successfully resized
+      // to ensure it accurately reflects the minimum size of keys and values
+      // even in the presence of failures.
+      capacity_ = childCapacity;
     }
   }
 
diff --git a/velox/expression/ConjunctRewrite.cpp b/velox/expression/ConjunctRewrite.cpp
new file mode 100644
index 00000000000..cb0ed3873b2
--- /dev/null
+++ b/velox/expression/ConjunctRewrite.cpp
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <set>
+
+#include "velox/expression/ConjunctRewrite.h"
+#include "velox/expression/ExprConstants.h"
+#include "velox/expression/ExprRewriteRegistry.h"
+#include "velox/expression/ExprUtils.h"
+
+namespace facebook::velox::expression {
+
+core::TypedExprPtr ConjunctRewrite::rewrite(const core::TypedExprPtr& expr) {
+  if (!expr->isCallKind()) {
+    return nullptr;
+  }
+
+  const auto* callExpr = expr->asUnchecked<core::CallTypedExpr>();
+  const bool conjunct = callExpr->name() == kAnd;
+  const bool disjunct = callExpr->name() == kOr;
+  if (!conjunct && !disjunct) {
+    return nullptr;
+  }
+
+  std::vector<core::TypedExprPtr> flat;
+  utils::flattenInput(expr, callExpr->name(), flat);
+  std::vector<core::TypedExprPtr> optimizedInputs;
+  bool nullInput = false;
+
+  for (const auto& input : flat) {
+    if (input->isConstantKind()) {
+      const auto* constInput = input->asUnchecked<core::ConstantTypedExpr>();
+      if (auto boolInput = constInput->toBool()) {
+        if (!boolInput.value() && conjunct) {
+          return input;
+        }
+        if (boolInput.value() && disjunct) {
+          return input;
+        }
+      } else if (!nullInput) {
+        nullInput = true;
+        optimizedInputs.push_back(input);
+      }
+    } else {
+      optimizedInputs.push_back(input);
+    }
+  }
+
+  // optimizedInputs can be empty for expressions like `true OR true`, returns
+  // the first input in this case.
+  if (optimizedInputs.empty()) {
+    return expr->inputs().front();
+  }
+  if (optimizedInputs.size() == 1) {
+    return optimizedInputs.front();
+  }
+  return std::make_shared<core::CallTypedExpr>(
+      expr->type(), std::move(optimizedInputs), callExpr->name());
+}
+
+void ConjunctRewrite::registerRewrite() {
+  expression::ExprRewriteRegistry::instance().registerRewrite(
+      expression::ConjunctRewrite::rewrite);
+}
+
+} // namespace facebook::velox::expression
diff --git a/velox/expression/ConjunctRewrite.h b/velox/expression/ConjunctRewrite.h
new file mode 100644
index 00000000000..163c7eb51be
--- /dev/null
+++ b/velox/expression/ConjunctRewrite.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/core/Expressions.h"
+
+namespace facebook::velox::expression {
+
+class ConjunctRewrite {
+ public:
+  /// Rewrites special forms AND and OR. First, nested AND, OR special forms
+  /// are flattened recursively, eg: a AND (b AND (c AND d)) -> AND(a, b, c, d).
+  /// Then, tries to short circuit expression evaluation by rewriting AND and OR
+  /// special forms to `false` and `true` respectively if this is one of
+  /// the inputs. If expression could not be short-circuited, inputs to AND and
+  /// OR conjuncts that are `true` and `false` respectively are pruned. If there
+  /// is only one input to the conjunct after its inputs are pruned, rewrites
+  /// the conjunct expression to this input. Otherwise, returns an optimized
+  /// conjunct expression with pruned inputs.
+  static core::TypedExprPtr rewrite(const core::TypedExprPtr& expr);
+
+  static void registerRewrite();
+};
+
+} // namespace facebook::velox::expression
diff --git a/velox/expression/DecodedArgs.h b/velox/expression/DecodedArgs.h
index cfe791293ee..ff44765b702 100644
--- a/velox/expression/DecodedArgs.h
+++ b/velox/expression/DecodedArgs.h
@@ -36,6 +36,7 @@ class DecodedArgs {
       const SelectivityVector& rows,
       const std::vector<VectorPtr>& args,
       exec::EvalCtx& context) {
+    holders_.reserve(args.size());
     for (auto& arg : args) {
       holders_.emplace_back(context, *arg, rows);
     }
diff --git a/velox/expression/EvalCtx.cpp b/velox/expression/EvalCtx.cpp
index 8a2ac21fae5..ef7e18f0b47 100644
--- a/velox/expression/EvalCtx.cpp
+++ b/velox/expression/EvalCtx.cpp
@@ -39,14 +39,39 @@ EvalCtx::EvalCtx(
   VELOX_CHECK_NOT_NULL(exprSet);
   VELOX_CHECK_NOT_NULL(row);
 
-  inputFlatNoNulls_ = true;
-  for (const auto& child : row->children()) {
+  inputFlatNoNulls_ = computeInputFlatNoNulls(*row);
+}
+
+EvalCtx::EvalCtx(
+    core::ExecCtx* execCtx,
+    ExprSet* exprSet,
+    const RowVector* row,
+    bool inputFlatNoNulls,
+    bool lazyDereference)
+    : execCtx_(execCtx),
+      exprSet_(exprSet),
+      row_(row),
+      lazyDereference_(lazyDereference),
+      inputFlatNoNulls_(inputFlatNoNulls) {
+  VELOX_CHECK_NOT_NULL(execCtx);
+  VELOX_CHECK_NOT_NULL(exprSet);
+  VELOX_CHECK_NOT_NULL(row);
+  VELOX_DCHECK_EQ(
+      inputFlatNoNulls,
+      computeInputFlatNoNulls(*row),
+      "Pre-computed inputFlatNoNulls does not match actual RowVector state");
+}
+
+// static
+bool EvalCtx::computeInputFlatNoNulls(const RowVector& row) {
+  for (const auto& child : row.children()) {
     VELOX_CHECK_NOT_NULL(child);
     if ((!child->isFlatEncoding() && !child->isConstantEncoding()) ||
         child->mayHaveNulls()) {
-      inputFlatNoNulls_ = false;
+      return false;
     }
   }
+  return true;
 }
 
 EvalCtx::EvalCtx(core::ExecCtx* execCtx)
@@ -192,6 +217,25 @@ void EvalCtx::setStatus(vector_size_t index, const Status& status) {
   }
 }
 
+void EvalCtx::setStatuses(const SelectivityVector& rows, const Status& status) {
+  VELOX_CHECK(!status.ok(), "Status must be an error");
+  if (status.isUserError()) {
+    if (throwOnError_) {
+      VELOX_USER_FAIL(status.message());
+    }
+
+    if (captureErrorDetails_) {
+      auto veloxException = toVeloxUserError(status.message());
+      rows.applyToSelected(
+          [&](auto row) { addError(row, veloxException, errors_); });
+    } else {
+      rows.applyToSelected([&](auto row) { addError(row, errors_); });
+    }
+  } else {
+    VELOX_FAIL(status.message());
+  }
+}
+
 void EvalCtx::setError(
     vector_size_t index,
     const std::exception_ptr& exceptionPtr) {
diff --git a/velox/expression/EvalCtx.h b/velox/expression/EvalCtx.h
index cab284626d1..0f53e819969 100644
--- a/velox/expression/EvalCtx.h
+++ b/velox/expression/EvalCtx.h
@@ -224,6 +224,22 @@ class EvalCtx {
       const RowVector* row,
       bool lazyDereference = false);
 
+  /// Creates an EvalCtx with a pre-computed inputFlatNoNulls flag, skipping
+  /// the per-column loop when the caller has already computed the flag via
+  /// computeInputFlatNoNulls(). Intended for multi-threaded use cases where
+  /// the same RowVector is evaluated across many EvalCtx instances (each bound
+  /// to a different ExprSet), so the flag can be computed once and shared.
+  EvalCtx(
+      core::ExecCtx* execCtx,
+      ExprSet* exprSet,
+      const RowVector* row,
+      bool inputFlatNoNulls,
+      bool lazyDereference);
+
+  /// Computes the inputFlatNoNulls flag for a RowVector. Returns true if all
+  /// children are flat or constant encoded and have no nulls.
+  static bool computeInputFlatNoNulls(const RowVector& row);
+
   /// For testing only.
   explicit EvalCtx(core::ExecCtx* execCtx);
 
@@ -266,6 +282,7 @@ class EvalCtx {
 
   // @param status Must indicate an error. Cannot be "ok".
   void setStatus(vector_size_t index, const Status& status);
+  void setStatuses(const SelectivityVector& rows, const Status& status);
 
   // If exceptionPtr is known to be a VeloxException use setVeloxExceptionError
   // instead.
@@ -428,8 +445,8 @@ class EvalCtx {
     return &isFinalSelection_;
   }
 
-  const SelectivityVector* FOLLY_NULLABLE* FOLLY_NONNULL
-  mutableFinalSelection() {
+  const SelectivityVector * FOLLY_NULLABLE *
+      FOLLY_NONNULL mutableFinalSelection() {
     return &finalSelection_;
   }
 
@@ -538,15 +555,50 @@ class EvalCtx {
     return execCtx_->optimizationParams().dictionaryMemoizationEnabled;
   }
 
+  /// Returns true if adaptive per-function CPU sampling is enabled.
+  bool adaptiveCpuSamplingEnabled() const {
+    return adaptiveCpuSamplingEnabled_;
+  }
+
+  void setAdaptiveCpuSamplingEnabled(bool enabled) {
+    adaptiveCpuSamplingEnabled_ = enabled;
+  }
+
+  /// Returns the maximum acceptable overhead pct for adaptive sampling.
+  double adaptiveCpuSamplingMaxOverheadPct() const {
+    return adaptiveCpuSamplingMaxOverheadPct_;
+  }
+
+  void setAdaptiveCpuSamplingMaxOverheadPct(double pct) {
+    adaptiveCpuSamplingMaxOverheadPct_ = pct;
+  }
+
+  /// Returns the measured CpuWallTimer overhead in nanoseconds (per
+  /// invocation). Measured once per ExprSet and shared across all Expr nodes.
+  uint64_t timerOverheadNanos() const {
+    return timerOverheadNanos_;
+  }
+
+  void setTimerOverheadNanos(uint64_t nanos) {
+    timerOverheadNanos_ = nanos;
+  }
+
   /// Returns the maximum number of distinct inputs to cache results for in a
   /// given shared subexpression.
   uint32_t maxSharedSubexprResultsCached() const {
     return execCtx_->optimizationParams().maxSharedSubexprResultsCached;
   }
 
-  /// Returns true if peeling is enabled.
-  bool peelingEnabled() const {
-    return execCtx_->optimizationParams().peelingEnabled;
+  /// Returns true if peeling is enabled for the given rows. Peeling is
+  /// disabled globally via OptimizationParams::peelingEnabled, or suppressed
+  /// for small batches when the number of selected rows is below
+  /// OptimizationParams::minRowsForPeeling, since for small batches the cost
+  /// of wrapping inputs in dictionary vectors and materializing them outweighs
+  /// the benefit of peeling.
+  bool peelingEnabled(const SelectivityVector& rows) const {
+    const auto& params = execCtx_->optimizationParams();
+    return params.peelingEnabled &&
+        rows.countSelected() >= params.minRowsForPeeling;
   }
 
   /// Returns true if shared subexpression reuse is enabled.
@@ -603,12 +655,21 @@ class EvalCtx {
 
   // If isFinalSelection_ is false, the set of rows for the upper-most IF or
   // OR. Used to determine the set of rows for loading lazy vectors.
-  const SelectivityVector* finalSelection_;
+  const SelectivityVector* finalSelection_{nullptr};
 
   // Stores exceptions encountered during expression evaluation.
   // If 'captureErrorDetails()' is false, stores flags indicating which rows had
   // errors without storing actual exceptions.
   EvalErrorsPtr errors_;
+
+  // Whether adaptive per-function CPU sampling is enabled.
+  bool adaptiveCpuSamplingEnabled_{false};
+
+  // Maximum acceptable overhead percentage for adaptive CPU sampling.
+  double adaptiveCpuSamplingMaxOverheadPct_{1.0};
+
+  // Measured CpuWallTimer overhead (nanos per invocation), shared across Exprs.
+  uint64_t timerOverheadNanos_{0};
 };
 
 /// Utility wrapper struct that is used to temporarily reset the value of the
@@ -782,40 +843,40 @@ class LocalSelectivityVector {
 
 class LocalDecodedVector {
  public:
-  explicit LocalDecodedVector(core::ExecCtx& context) : context_(context) {}
+  explicit LocalDecodedVector(core::ExecCtx& context) : context_(&context) {}
 
-  explicit LocalDecodedVector(EvalCtx& context)
-      : context_(*context.execCtx()) {}
+  explicit LocalDecodedVector(EvalCtx& evalCtx) : context_(evalCtx.execCtx()) {}
 
-  explicit LocalDecodedVector(EvalCtx* context)
-      : LocalDecodedVector(*context) {}
+  explicit LocalDecodedVector(EvalCtx* evalCtx)
+      : context_(evalCtx ? evalCtx->execCtx() : nullptr) {}
 
   LocalDecodedVector(
       const EvalCtx& context,
       const BaseVector& vector,
       const SelectivityVector& rows,
       bool loadLazy = true)
-      : context_(*context.execCtx()) {
+      : context_(context.execCtx()) {
     get()->decode(vector, rows, loadLazy);
   }
 
   LocalDecodedVector(LocalDecodedVector&& other) noexcept
       : context_{other.context_}, vector_{std::move(other.vector_)} {}
 
-  void operator=(LocalDecodedVector&& other) {
+  void operator=(LocalDecodedVector&& other) noexcept {
     context_ = other.context_;
     vector_ = std::move(other.vector_);
   }
 
   ~LocalDecodedVector() {
-    if (vector_) {
-      context_.get().releaseDecodedVector(std::move(vector_));
+    if (vector_ && context_) {
+      context_->releaseDecodedVector(std::move(vector_));
     }
   }
 
   DecodedVector* get() {
     if (!vector_) {
-      vector_ = context_.get().getDecodedVector();
+      vector_ = context_ ? context_->getDecodedVector()
+                         : std::make_unique<DecodedVector>();
     }
     return vector_.get();
   }
@@ -842,7 +903,7 @@ class LocalDecodedVector {
   }
 
  private:
-  std::reference_wrapper<core::ExecCtx> context_;
+  core::ExecCtx* context_;
   std::unique_ptr<DecodedVector> vector_;
 };
 
diff --git a/velox/expression/Expr.cpp b/velox/expression/Expr.cpp
index 9a4b348d600..b4d7a94c013 100644
--- a/velox/expression/Expr.cpp
+++ b/velox/expression/Expr.cpp
@@ -16,13 +16,19 @@
 #include <boost/lexical_cast.hpp>
 #include <boost/uuid/uuid_generators.hpp>
 #include <boost/uuid/uuid_io.hpp>
+#include <cmath>
+
+#include <folly/GLog.h>
 
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/Fs.h"
 #include "velox/common/base/SuccinctPrinter.h"
 #include "velox/common/process/ThreadDebugInfo.h"
 #include "velox/common/testutil/TestValue.h"
+#include "velox/exec/trace/TraceCtx.h"
 #include "velox/expression/CastExpr.h"
+
+#include "velox/common/EnumDefine.h"
 #include "velox/expression/ConstantExpr.h"
 #include "velox/expression/Expr.h"
 #include "velox/expression/ExprCompiler.h"
@@ -136,7 +142,8 @@ Expr::Expr(
     std::shared_ptr<VectorFunction> vectorFunction,
     VectorFunctionMetadata metadata,
     std::string name,
-    bool trackCpuUsage)
+    bool trackCpuUsage,
+    std::vector<VectorFunctionListeners> listeners)
     : type_(std::move(type)),
       inputs_(std::move(inputs)),
       name_(std::move(name)),
@@ -147,9 +154,11 @@ Expr::Expr(
           vectorFunction_->supportsFlatNoNullsFastPath() &&
           type_->isPrimitiveType() && type_->isFixedWidth() &&
           allSupportFlatNoNullsFastPath(inputs_)},
-      trackCpuUsage_{trackCpuUsage} {
+      trackCpuUsage_{trackCpuUsage},
+      listeners_(std::move(listeners)) {
   constantInputs_.reserve(inputs_.size());
   inputIsConstant_.reserve(inputs_.size());
+  inputValues_.reserve(inputs_.size());
   for (auto& expr : inputs_) {
     if (auto constantExpr = expr->as<ConstantExpr>()) {
       constantInputs_.emplace_back(constantExpr->value());
@@ -534,17 +543,12 @@ void Expr::evalSimplifiedImpl(
   }
 
   // Apply the actual function.
-  try {
-    vectorFunction_->apply(
-        remainingRows.rows(), inputValues_, type(), context, result);
-  } catch (const VeloxException&) {
-    throw;
-  } catch (const std::exception& e) {
-    VELOX_USER_FAIL(e.what());
-  }
+  invokeApplyWithListeners(remainingRows.rows(), context, result);
 
   // Make sure the returned vector has its null bitmap properly set.
   addNulls(rows, remainingRows.rows().asRange().bits(), context, result);
+
+  traceOutput(result);
 }
 
 namespace {
@@ -695,16 +699,35 @@ std::string onTopLevelException(VeloxException::Type exceptionType, void* arg) {
   if (strlen(basePath) == 0 && exceptionType == VeloxException::Type::kSystem) {
     basePath = FLAGS_velox_save_input_on_expression_system_failure_path.c_str();
   }
+
+  const auto& owner = context->expr()->vectorFunctionMetadata().owner;
   if (strlen(basePath) == 0) {
-    return fmt::format("Top-level Expression: {}", context->expr()->toString());
+    if (owner.empty()) {
+      return fmt::format(
+          "Top-level Expression: {}", context->expr()->toString());
+    }
+    return fmt::format(
+        "Owner: {}. Top-level Expression: {}",
+        owner,
+        context->expr()->toString());
   }
 
   // Save input vector to a file.
   context->persistDataAndSql(basePath);
 
+  if (owner.empty()) {
+    return fmt::format(
+        "Top-level Expression: {}. Input data: {}. SQL expression: {}."
+        " All SQL expressions: {}. ",
+        context->expr()->toString(),
+        context->dataPath(),
+        context->sqlPath(),
+        context->allExprSqlPath());
+  }
   return fmt::format(
-      "Top-level Expression: {}. Input data: {}. SQL expression: {}."
+      "Owner: {}. Top-level Expression: {}. Input data: {}. SQL expression: {}."
       " All SQL expressions: {}. ",
+      owner,
       context->expr()->toString(),
       context->dataPath(),
       context->sqlPath(),
@@ -715,7 +738,12 @@ std::string onTopLevelException(VeloxException::Type exceptionType, void* arg) {
 /// sub-expression. Returns the output of Expr::toString() for the
 /// sub-expression.
 std::string onException(VeloxException::Type /*exceptionType*/, void* arg) {
-  return static_cast<Expr*>(arg)->toString();
+  auto* expr = static_cast<Expr*>(arg);
+  const auto& owner = expr->vectorFunctionMetadata().owner;
+  if (owner.empty()) {
+    return static_cast<Expr*>(arg)->toString();
+  }
+  return fmt::format("Owner: {}. Expression: {}", owner, expr->toString());
 }
 } // namespace
 
@@ -790,7 +818,8 @@ void Expr::eval(
     VectorPtr& result,
     const ExprSet* parentExprSet) {
   if (supportsFlatNoNullsFastPath_ && context.throwOnError() &&
-      context.inputFlatNoNulls() && rows.countSelected() < 1'000) {
+      context.inputFlatNoNulls() &&
+      context.execCtx()->queryCtx()->queryConfig().exprEvalFlatNoNulls()) {
     evalFlatNoNulls(rows, context, result, parentExprSet);
     checkResultInternalState(result);
     return;
@@ -1073,7 +1102,7 @@ void Expr::evalEncodings(
     EvalCtx& context,
     VectorPtr& result) {
   if (deterministic_ && !skipFieldDependentOptimizations() &&
-      context.peelingEnabled()) {
+      context.peelingEnabled(rows)) {
     bool hasFlat = false;
     for (auto* field : distinctFields_) {
       if (isFlat(*context.getField(field->index(context)))) {
@@ -1507,15 +1536,39 @@ bool Expr::applyFunctionWithPeeling(
     VectorPtr& result) {
   LocalDecodedVector localDecoded(context);
   LocalSelectivityVector newRowsHolder(context);
-  if (!context.peelingEnabled()) {
-    if (distinctFields_.size() < 2) {
-      // If we have a single input, velox needs to ensure that the
-      // vectorFunction would receive a flat or constant input.
-      for (int i = 0; i < inputValues_.size(); ++i) {
-        if (inputValues_[i]->encoding() == VectorEncoding::Simple::DICTIONARY) {
-          BaseVector::flattenVector(inputValues_[i]);
+  // When peeling was always enabled, VectorFunctions would implicitly always
+  // receive flat or constant inputs. Now that peeling can be suppressed for
+  // small batches, we must preserve that guarantee for three cases:
+  //
+  // 1. Single constant input (e.g. map_from_entries({null, ...}),
+  //    array_sort(constant_array)): fall through to the peeling path since
+  //    constant peeling is cheap.
+  //
+  // 2. Single dictionary-encoded argument: flatten the dictionary before
+  //    calling applyFunction.
+  //
+  // 3. Single dictionary-encoded argument with all other arguments being
+  //    constants (e.g. in-predicate: dict_wrap(c0) in (40, 42)): flatten the
+  //    dictionary — the constants pass through unchanged.
+  if (!context.peelingEnabled(applyRows) &&
+      !(inputValues_.size() == 1 &&
+        inputValues_[0]->encoding() == VectorEncoding::Simple::CONSTANT)) {
+    int dictIndex = -1;
+    bool canFlatten = true;
+
+    for (int i = 0; i < inputValues_.size(); ++i) {
+      auto encoding = inputValues_[i]->encoding();
+      if (encoding == VectorEncoding::Simple::DICTIONARY) {
+        if (dictIndex != -1) {
+          // More than one dictionary-encoded input.
+          canFlatten = false;
+          break;
         }
+        dictIndex = i;
       }
+    }
+    if (canFlatten && dictIndex != -1) {
+      BaseVector::flattenVector(inputValues_[dictIndex]);
       applyFunction(applyRows, context, result);
       return true;
     }
@@ -1562,26 +1615,156 @@ bool Expr::applyFunctionWithPeeling(
   return true;
 }
 
+std::unique_ptr<CpuWallTimer> Expr::cpuWallTimer(const EvalCtx& context) {
+  // 1. Compile-time tracking (set via trackCpuUsage_) always wins.
+  if (trackCpuUsage_) {
+    return std::make_unique<CpuWallTimer>(stats_.timing);
+  }
+
+  // 2. Adaptive per-function sampling.
+  if (context.adaptiveCpuSamplingEnabled()) {
+    switch (adaptiveState_) {
+      case AdaptiveCpuSamplingState::kWarmup:
+        // Warmup batch: just run the function, no timing.
+        return nullptr;
+      case AdaptiveCpuSamplingState::kCalibrating: {
+        // Measure function execution time (without CpuWallTimer).
+        // Timer overhead is measured once per ExprSet and shared via EvalCtx.
+        calibrationStopWatch_.emplace();
+        return nullptr;
+      }
+      case AdaptiveCpuSamplingState::kAlwaysTrack:
+        return std::make_unique<CpuWallTimer>(stats_.timing);
+      case AdaptiveCpuSamplingState::kSampling:
+        if (++adaptiveSamplingCounter_ % adaptiveSamplingRate_ == 0) {
+          return std::make_unique<CpuWallTimer>(stats_.timing);
+        }
+        return nullptr;
+    }
+  }
+
+  return nullptr;
+}
+
+void Expr::finalizeAdaptiveCalibration(
+    double maxOverheadPct,
+    uint64_t timerOverheadNanos) {
+  switch (adaptiveState_) {
+    case AdaptiveCpuSamplingState::kWarmup: {
+      adaptiveState_ = AdaptiveCpuSamplingState::kCalibrating;
+      break;
+    }
+    case AdaptiveCpuSamplingState::kCalibrating: {
+      calibrationFunctionWallNanos_ +=
+          calibrationStopWatch_->elapsed().wallNanos;
+      calibrationStopWatch_.reset();
+
+      if (++calibrationBatchCount_ < kCalibrationBatches) {
+        break;
+      }
+
+      // Use the shared timer overhead measurement, scaled by calibration
+      // batch count. The overhead per invocation is a platform constant
+      // measured once per ExprSet.
+      auto totalTimerOverhead = timerOverheadNanos * calibrationBatchCount_;
+
+      if (calibrationFunctionWallNanos_ > 0 && maxOverheadPct > 0) {
+        double overheadPct = 100.0 * static_cast<double>(totalTimerOverhead) /
+            static_cast<double>(calibrationFunctionWallNanos_);
+
+        if (overheadPct > maxOverheadPct) {
+          adaptiveSamplingRate_ =
+              static_cast<uint32_t>(std::ceil(overheadPct / maxOverheadPct));
+          // Start counter at rate-1 so the first post-calibration batch is
+          // always timed (++counter hits rate, which passes % rate == 0).
+          adaptiveSamplingCounter_ = adaptiveSamplingRate_ - 1;
+          adaptiveState_ = AdaptiveCpuSamplingState::kSampling;
+        } else {
+          adaptiveState_ = AdaptiveCpuSamplingState::kAlwaysTrack;
+        }
+      } else {
+        // Function ~0ns — timer dominates. Aggressive sampling.
+        adaptiveSamplingRate_ = 100;
+        adaptiveSamplingCounter_ = adaptiveSamplingRate_ - 1;
+        adaptiveState_ = AdaptiveCpuSamplingState::kSampling;
+      }
+      break;
+    }
+    default:
+      VELOX_UNREACHABLE(
+          "Unexpected adaptive sampling state in finalizeAdaptiveCalibration");
+  }
+}
+
+void Expr::invokeApplyWithListeners(
+    const SelectivityVector& rows,
+    EvalCtx& context,
+    VectorPtr& result) {
+  bool hasPostListeners = false;
+  for (const auto& listener : listeners_) {
+    if (listener.pre) {
+      (*listener.pre)(name_, rows, inputValues_, type(), context);
+    }
+    hasPostListeners |= (listener.post != nullptr);
+  }
+
+  if (!hasPostListeners) {
+    try {
+      vectorFunction_->apply(rows, inputValues_, type(), context, result);
+    } catch (const VeloxException&) {
+      throw;
+    } catch (const std::exception& e) {
+      VELOX_USER_FAIL(e.what());
+    }
+    return;
+  }
+
+  std::exception_ptr applyError;
+  try {
+    vectorFunction_->apply(rows, inputValues_, type(), context, result);
+  } catch (const VeloxException&) {
+    applyError = std::current_exception();
+  } catch (const std::exception& e) {
+    try {
+      VELOX_USER_FAIL(e.what());
+    } catch (...) {
+      applyError = std::current_exception();
+    }
+  }
+
+  for (const auto& listener : listeners_) {
+    if (listener.post) {
+      try {
+        (*listener.post)(
+            name_, rows, inputValues_, type(), context, result, applyError);
+      } catch (const std::exception& e) {
+        FB_LOG_EVERY_MS(ERROR, 5000)
+            << "Post-apply listener threw for function '" << name_
+            << "': " << e.what();
+      }
+    }
+  }
+  if (applyError) {
+    std::rethrow_exception(applyError);
+  }
+}
+
 void Expr::applyFunction(
     const SelectivityVector& rows,
     EvalCtx& context,
     VectorPtr& result) {
   stats_.numProcessedVectors += 1;
   stats_.numProcessedRows += rows.countSelected();
-  auto timer = cpuWallTimer();
+  auto timer = cpuWallTimer(context);
 
   computeIsAsciiForInputs(vectorFunction_.get(), inputValues_, rows);
   auto isAscii = type()->isVarchar()
       ? computeIsAsciiForResult(vectorFunction_.get(), inputValues_, rows)
       : std::nullopt;
 
-  try {
-    vectorFunction_->apply(rows, inputValues_, type(), context, result);
-  } catch (const VeloxException&) {
-    throw;
-  } catch (const std::exception& e) {
-    VELOX_USER_FAIL(e.what());
-  }
+  invokeApplyWithListeners(rows, context, result);
+
+  traceOutput(result);
 
   if (!result) {
     MutableRemainingRows remainingRows(rows, context);
@@ -1608,6 +1791,14 @@ void Expr::applyFunction(
     result->asUnchecked<SimpleVector<StringView>>()->setIsAscii(
         isAscii.value(), rows);
   }
+
+  // Only do Adaptive Calibration if the adaptive sampling is on and we are in
+  // warmup or calibrating state.
+  if (context.adaptiveCpuSamplingEnabled() && isCalibrating()) {
+    finalizeAdaptiveCalibration(
+        context.adaptiveCpuSamplingMaxOverheadPct(),
+        context.timerOverheadNanos());
+  }
 }
 
 void Expr::evalSpecialFormWithStats(
@@ -1616,9 +1807,17 @@ void Expr::evalSpecialFormWithStats(
     VectorPtr& result) {
   stats_.numProcessedVectors += 1;
   stats_.numProcessedRows += rows.countSelected();
-  auto timer = cpuWallTimer();
+  auto timer = cpuWallTimer(context);
 
   evalSpecialForm(rows, context, result);
+
+  // Only do Adaptive Calibration if the adaptive sampling is on and we are in
+  // warmup or calibrating state.
+  if (context.adaptiveCpuSamplingEnabled() && isCalibrating()) {
+    finalizeAdaptiveCalibration(
+        context.adaptiveCpuSamplingMaxOverheadPct(),
+        context.timerOverheadNanos());
+  }
 }
 
 namespace {
@@ -1749,24 +1948,29 @@ common::Subfield extractSubfield(
     }
     switch (index->value()->typeKind()) {
       case TypeKind::TINYINT:
-        path.push_back(std::make_unique<common::Subfield::LongSubscript>(
-            index->value()->as<ConstantVector<int8_t>>()->value()));
+        path.push_back(
+            std::make_unique<common::Subfield::LongSubscript>(
+                index->value()->as<ConstantVector<int8_t>>()->value()));
         break;
       case TypeKind::SMALLINT:
-        path.push_back(std::make_unique<common::Subfield::LongSubscript>(
-            index->value()->as<ConstantVector<int16_t>>()->value()));
+        path.push_back(
+            std::make_unique<common::Subfield::LongSubscript>(
+                index->value()->as<ConstantVector<int16_t>>()->value()));
         break;
       case TypeKind::INTEGER:
-        path.push_back(std::make_unique<common::Subfield::LongSubscript>(
-            index->value()->as<ConstantVector<int32_t>>()->value()));
+        path.push_back(
+            std::make_unique<common::Subfield::LongSubscript>(
+                index->value()->as<ConstantVector<int32_t>>()->value()));
         break;
       case TypeKind::BIGINT:
-        path.push_back(std::make_unique<common::Subfield::LongSubscript>(
-            index->value()->as<ConstantVector<int64_t>>()->value()));
+        path.push_back(
+            std::make_unique<common::Subfield::LongSubscript>(
+                index->value()->as<ConstantVector<int64_t>>()->value()));
         break;
       case TypeKind::VARCHAR:
-        path.push_back(std::make_unique<common::Subfield::StringSubscript>(
-            index->value()->as<ConstantVector<StringView>>()->value()));
+        path.push_back(
+            std::make_unique<common::Subfield::StringSubscript>(std::string(
+                index->value()->as<ConstantVector<StringView>>()->value())));
         break;
       default:
         return {};
@@ -1843,7 +2047,14 @@ ExprSet::ExprSet(
     core::ExecCtx* execCtx,
     bool enableConstantFolding,
     bool lazyDereference)
-    : execCtx_(execCtx), lazyDereference_(lazyDereference) {
+    : execCtx_(execCtx),
+      lazyDereference_(lazyDereference),
+      adaptiveCpuSampling_(
+          execCtx->queryCtx()->queryConfig().exprAdaptiveCpuSampling()),
+      adaptiveCpuSamplingMaxOverheadPct_(
+          execCtx->queryCtx()
+              ->queryConfig()
+              .exprAdaptiveCpuSamplingMaxOverheadPct()) {
   exprs_ = compileExpressions(sources, execCtx, this, enableConstantFolding);
   if (lazyDereference_) {
     validateLazyDereference(exprs_);
@@ -1855,26 +2066,109 @@ ExprSet::ExprSet(
   }
 }
 
+void ExprSet::maybeSetupTracers(
+    const Operator& op,
+    const trace::TraceCtx& traceCtx) {
+  exprTracingEnabled_ = true;
+  std::unordered_set<Expr*> visited;
+  std::unordered_map<std::string, int> instanceCounts;
+  for (auto& expr : exprs_) {
+    expr->maybeSetupTracer(op, traceCtx, visited, instanceCounts);
+  }
+}
+
+void Expr::maybeSetupTracer(
+    const Operator& op,
+    const trace::TraceCtx& traceCtx,
+    std::unordered_set<Expr*>& visited,
+    std::unordered_map<std::string, int>& instanceCounts) {
+  if (!visited.insert(this).second) {
+    return;
+  }
+  if (traceCtx.shouldTraceExpr(name_)) {
+    const int index = instanceCounts[name_]++;
+    try {
+      outputTracer_ = traceCtx.createExprOutputTracer(op, name_, index);
+    } catch (const std::exception& e) {
+      LOG(ERROR) << "Failed to create expression output tracer: " << e.what();
+    }
+  }
+  for (auto& input : inputs_) {
+    input->maybeSetupTracer(op, traceCtx, visited, instanceCounts);
+  }
+}
+
+void ExprSet::finishTracers() {
+  if (!exprTracingEnabled_) {
+    return;
+  }
+  std::unordered_set<Expr*> visited;
+  for (auto& expr : exprs_) {
+    expr->finishTracer(visited);
+  }
+}
+
+void Expr::finishTracer(std::unordered_set<Expr*>& visited) {
+  if (!visited.insert(this).second) {
+    return;
+  }
+  if (outputTracer_) {
+    try {
+      outputTracer_->finish();
+    } catch (const std::exception& e) {
+      LOG(ERROR) << "Failed to finish expression output tracer: " << e.what();
+    }
+  }
+  for (auto& input : inputs_) {
+    input->finishTracer(visited);
+  }
+}
+
+FOLLY_ALWAYS_INLINE void Expr::traceOutput(const VectorPtr& result) {
+  if (FOLLY_UNLIKELY(outputTracer_ != nullptr) && result) {
+    try {
+      outputTracer_->write(result);
+    } catch (const std::exception& e) {
+      LOG(ERROR) << "Failed to trace expression output: " << e.what();
+    }
+  }
+}
+
 namespace {
+
+/// If the expression is in adaptive sampling mode, extrapolate timing stats
+/// to approximate full-population values. Otherwise, return raw stats.
+exec::ExprStats adjustStats(const exec::Expr& expr) {
+  if (expr.isAdaptiveSampling() && expr.stats().timing.count > 0) {
+    exec::ExprStats adjusted = expr.stats();
+    double ratio = static_cast<double>(adjusted.numProcessedVectors) /
+        static_cast<double>(adjusted.timing.count);
+    adjusted.timing.cpuNanos = static_cast<uint64_t>(
+        static_cast<double>(adjusted.timing.cpuNanos) * ratio);
+    adjusted.timing.wallNanos = static_cast<uint64_t>(
+        static_cast<double>(adjusted.timing.wallNanos) * ratio);
+    adjusted.timing.count = adjusted.numProcessedVectors;
+    return adjusted;
+  }
+  return expr.stats();
+}
+
 void addStats(
     const exec::Expr& expr,
     std::unordered_map<std::string, exec::ExprStats>& stats,
     std::unordered_set<const exec::Expr*>& uniqueExprs,
     bool excludeSpecialForm) {
-  auto it = uniqueExprs.find(&expr);
-  if (it != uniqueExprs.end()) {
+  if (!uniqueExprs.insert(&expr).second) {
     // Common sub-expression. Skip to avoid double counting.
     return;
   }
 
-  uniqueExprs.insert(&expr);
-
   bool excludeSplFormExpr = excludeSpecialForm && expr.isSpecialForm();
   // Do not aggregate empty stats.
   bool emptyStats =
       !expr.stats().numProcessedRows && !expr.stats().defaultNullRowsSkipped;
   if (!emptyStats && !excludeSplFormExpr) {
-    stats[expr.name()].add(expr.stats());
+    stats[expr.name()].add(adjustStats(expr));
   }
 
   for (const auto& input : expr.inputs()) {
@@ -1986,6 +2280,24 @@ void printInputAndExprs(
 }
 } // namespace
 
+void ExprSet::initializeAdaptiveCpuSampling(EvalCtx& context) {
+  context.setAdaptiveCpuSamplingEnabled(true);
+  context.setAdaptiveCpuSamplingMaxOverheadPct(
+      adaptiveCpuSamplingMaxOverheadPct_);
+
+  // Measure CpuWallTimer overhead once per ExprSet (platform constant).
+  if (!timerOverheadMeasured_) {
+    CpuWallTiming dummyTiming;
+    DeltaCpuWallTimeStopWatch overheadWatch;
+    {
+      auto dummy = std::make_unique<CpuWallTimer>(dummyTiming);
+    }
+    timerOverheadNanos_ = overheadWatch.elapsed().wallNanos;
+    timerOverheadMeasured_ = true;
+  }
+  context.setTimerOverheadNanos(timerOverheadNanos_);
+}
+
 void ExprSet::eval(
     int32_t begin,
     int32_t end,
@@ -1999,6 +2311,11 @@ void ExprSet::eval(
     clearSharedSubexprs();
   }
 
+  // Apply adaptive per-function CPU sampling if configured.
+  if (adaptiveCpuSampling_) {
+    initializeAdaptiveCpuSampling(context);
+  }
+
   if (!lazyDereference_) {
     // Make sure LazyVectors, referenced by multiple expressions, are loaded for
     // all the "rows".
@@ -2123,13 +2440,16 @@ core::ExecCtx* SimpleExpressionEvaluator::ensureExecCtx() {
   return execCtx_.get();
 }
 
-VectorPtr tryEvaluateConstantExpression(
+namespace {
+VectorPtr tryEvaluateConstantExpressionInternal(
     const core::TypedExprPtr& expr,
     memory::MemoryPool* pool,
-    const std::shared_ptr<core::QueryCtx>& queryCtx,
+    core::ExecCtx* execCtx,
     bool suppressEvaluationFailures) {
-  velox::core::ExecCtx execCtx{pool, queryCtx.get()};
-  velox::exec::ExprSet exprSet({expr}, &execCtx);
+  // Disable constant folding to avoid an infinite loop between ExprOptimizer
+  // and ExprCompiler.
+  velox::exec::ExprSet exprSet(
+      {expr}, execCtx, /*enableConstantFolding*/ false);
 
   // The construction of ExprSet involves compiling and constant folding the
   // expression. If constant folding succeeded, then we get a ConstantExpr.
@@ -2142,7 +2462,7 @@ VectorPtr tryEvaluateConstantExpression(
 
   if (doEvaluate) {
     auto data = BaseVector::create<RowVector>(ROW({}), 1, pool);
-    velox::exec::EvalCtx evalCtx(&execCtx, &exprSet, data.get());
+    velox::exec::EvalCtx evalCtx(execCtx, &exprSet, data.get());
     velox::SelectivityVector singleRow(1);
     std::vector<velox::VectorPtr> results(1);
     exprSet.eval(singleRow, evalCtx, results);
@@ -2151,5 +2471,26 @@ VectorPtr tryEvaluateConstantExpression(
 
   return nullptr;
 }
+} // namespace
+
+VectorPtr tryEvaluateConstantExpression(
+    const core::TypedExprPtr& expr,
+    memory::MemoryPool* pool,
+    const std::shared_ptr<core::QueryCtx>& queryCtx,
+    bool suppressEvaluationFailures) {
+  velox::core::ExecCtx execCtx{pool, queryCtx.get()};
+  return tryEvaluateConstantExpressionInternal(
+      expr, pool, &execCtx, suppressEvaluationFailures);
+}
+
+VectorPtr tryEvaluateConstantExpression(
+    const core::TypedExprPtr& expr,
+    memory::MemoryPool* pool,
+    core::QueryCtx* queryCtx,
+    bool suppressEvaluationFailures) {
+  velox::core::ExecCtx execCtx{pool, queryCtx};
+  return tryEvaluateConstantExpressionInternal(
+      expr, pool, &execCtx, suppressEvaluationFailures);
+}
 
 } // namespace facebook::velox::exec
diff --git a/velox/expression/Expr.h b/velox/expression/Expr.h
index 3707cd322ba..95c0e23afbf 100644
--- a/velox/expression/Expr.h
+++ b/velox/expression/Expr.h
@@ -16,22 +16,30 @@
 
 #pragma once
 
+#include <optional>
 #include <vector>
 
 #include <folly/container/F14Map.h>
 
 #include "velox/common/time/CpuWallTimer.h"
 #include "velox/core/ExpressionEvaluator.h"
+#include "velox/exec/trace/TraceWriter.h"
 #include "velox/expression/EvalCtx.h"
 #include "velox/expression/ExprStats.h"
 #include "velox/expression/VectorFunction.h"
+#include "velox/expression/VectorFunctionListener.h"
 #include "velox/type/Subfield.h"
 #include "velox/vector/SimpleVector.h"
 
+namespace facebook::velox::exec::trace {
+class TraceCtx;
+} // namespace facebook::velox::exec::trace
+
 namespace facebook::velox::exec {
 
 class ExprSet;
 class FieldReference;
+class Operator;
 class VectorFunction;
 
 /// Maintains a set of rows for evaluation and removes rows with
@@ -114,6 +122,7 @@ enum class SpecialFormKind : int32_t {
   kTry = 6,
   kAnd = 7,
   kOr = 8,
+  kNullIf = 9,
   kCustom = 999,
 };
 
@@ -143,7 +152,8 @@ class Expr {
       std::shared_ptr<VectorFunction> vectorFunction,
       VectorFunctionMetadata metadata,
       std::string name,
-      bool trackCpuUsage);
+      bool trackCpuUsage,
+      std::vector<VectorFunctionListeners> listeners = {});
 
   virtual ~Expr() = default;
 
@@ -406,6 +416,16 @@ class Expr {
     return stats_;
   }
 
+  /// Returns true if this expression is in adaptive sampling mode.
+  bool isAdaptiveSampling() const {
+    return adaptiveState_ == AdaptiveCpuSamplingState::kSampling;
+  }
+
+  /// Returns the adaptive sampling rate (0 = always track, N = sample 1/N).
+  uint32_t adaptiveSamplingRate() const {
+    return adaptiveSamplingRate_;
+  }
+
   void addNulls(
       const SelectivityVector& rows,
       const uint64_t* rawNulls,
@@ -424,6 +444,21 @@ class Expr {
     return inputValues_;
   }
 
+  /// Sets up expression-level output tracer if the given TraceCtx indicates
+  /// this expression should be traced. Called once during operator
+  /// initialization. Uses a visited set to avoid redundant traversal of
+  /// shared CSE nodes.
+  void maybeSetupTracer(
+      const Operator& op,
+      const trace::TraceCtx& traceCtx,
+      std::unordered_set<Expr*>& visited,
+      std::unordered_map<std::string, int>& instanceCounts);
+
+  /// Finishes expression-level output tracing by calling finish() on the
+  /// cached tracer. Uses a visited set to avoid redundant traversal of
+  /// shared CSE nodes.
+  void finishTracer(std::unordered_set<Expr*>& visited);
+
   void setAllNulls(
       const SelectivityVector& rows,
       EvalCtx& context,
@@ -506,6 +541,16 @@ class Expr {
       EvalCtx& context,
       VectorPtr& result);
 
+  // Invokes vectorFunction_->apply() with registered listeners and exception
+  // wrapping. Post-listeners always run (even if apply throws).
+  void invokeApplyWithListeners(
+      const SelectivityVector& rows,
+      EvalCtx& context,
+      VectorPtr& result);
+
+  // Traces expression output if a tracer is configured.
+  FOLLY_ALWAYS_INLINE void traceOutput(const VectorPtr& result);
+
   // Returns true if values in 'distinctFields_' have nulls that are
   // worth skipping. If so, the rows in 'rows' with at least one sure
   // null are deselected in 'nullHolder->get()'.
@@ -592,11 +637,26 @@ class Expr {
       EvalCtx& context,
       VectorPtr& result);
 
-  /// Returns an instance of CpuWallTimer if cpu usage tracking is enabled. Null
-  /// otherwise.
-  std::unique_ptr<CpuWallTimer> cpuWallTimer() {
-    return trackCpuUsage_ ? std::make_unique<CpuWallTimer>(stats_.timing)
-                          : nullptr;
+  /// Returns an instance of CpuWallTimer based on the tracking mode:
+  /// 1. trackCpuUsage_ (set via QueryConfig) — always creates timer
+  /// 2. Adaptive per-function sampling — creates timer based on calibration
+  ///    state and per-function overhead
+  std::unique_ptr<CpuWallTimer> cpuWallTimer(const EvalCtx& context);
+
+  /// Finalizes adaptive calibration after function execution. Called from
+  /// applyFunction() and evalSpecialFormWithStats() when adaptive sampling
+  /// is enabled. Transitions the per-function state machine based on
+  /// measured overhead.
+  void finalizeAdaptiveCalibration(
+      double maxOverheadPct,
+      uint64_t timerOverheadNanos);
+
+  /// Returns true if adaptive calibration is still in progress (warmup or
+  /// calibrating). Used to skip the finalizeAdaptiveCalibration() call on
+  /// the hot path once calibration is complete.
+  bool isCalibrating() const {
+    return adaptiveState_ == AdaptiveCpuSamplingState::kWarmup ||
+        adaptiveState_ == AdaptiveCpuSamplingState::kCalibrating;
   }
 
   // Should be called only after computeMetadata() has been called on 'inputs_'.
@@ -612,6 +672,10 @@ class Expr {
   const std::optional<SpecialFormKind> specialFormKind_;
   const bool supportsFlatNoNullsFastPath_;
   const bool trackCpuUsage_;
+  // Listeners invoked around vectorFunction_->apply() in both applyFunction()
+  // and evalSimplifiedImpl(). Collected from the global listener factory
+  // registry during expression compilation.
+  const std::vector<VectorFunctionListeners> listeners_;
 
   std::vector<VectorPtr> constantInputs_;
   std::vector<bool> inputIsConstant_;
@@ -710,6 +774,34 @@ class Expr {
   /// Runtime statistics. CPU time, wall time and number of processed rows.
   ExprStats stats_;
 
+  /// Per-function adaptive CPU sampling state machine.
+  enum class AdaptiveCpuSamplingState : uint8_t {
+    /// First batch: warm up caches, discard timing.
+    kWarmup,
+    /// Next N batches: measure CpuWallTimer overhead and function cost.
+    kCalibrating,
+    /// Calibration complete: overhead is acceptable, always track.
+    kAlwaysTrack,
+    /// Calibration complete: overhead is too high, sample at computed rate.
+    kSampling,
+  };
+
+  /// Number of calibration batches (more batches = less noise).
+  static constexpr uint32_t kCalibrationBatches = 5;
+
+  AdaptiveCpuSamplingState adaptiveState_{AdaptiveCpuSamplingState::kWarmup};
+
+  /// Stopwatch for measuring function execution wall time during calibration.
+  std::optional<DeltaCpuWallTimeStopWatch> calibrationStopWatch_;
+  /// Accumulated function wall time (without timer) during calibration.
+  uint64_t calibrationFunctionWallNanos_{0};
+  /// Counter for calibration batches.
+  uint32_t calibrationBatchCount_{0};
+  /// Computed sampling rate: 0 = always track, N = track every N-th batch.
+  uint32_t adaptiveSamplingRate_{0};
+  /// Counter for sampling cadence.
+  uint32_t adaptiveSamplingCounter_{0};
+
   // If true computeMetaData returns, otherwise meta data is computed and the
   // flag is set to true.
   bool metaDataComputed_ = false;
@@ -717,6 +809,9 @@ class Expr {
   // True if distinctFields_ are identical to at least one of the parent
   // expression's distinct fields.
   bool sameAsParentDistinctFields_ = false;
+
+  // Cached output tracer set up during expression initialization.
+  std::unique_ptr<trace::TraceExprWriter> outputTracer_;
 };
 
 /// Generate a selectivity vector of a single row.
@@ -803,6 +898,13 @@ class ExprSet {
     memoizingExprs_.insert(expr);
   }
 
+  /// Sets up expression-level tracers on all expressions in this set.
+  void maybeSetupTracers(const Operator& op, const trace::TraceCtx& traceCtx);
+
+  /// Finishes expression-level tracers on all expressions in this set.
+  /// Called during operator close.
+  void finishTracers();
+
   /// Returns text representation of the expression set.
   /// @param compact If true, uses one-line representation for each expression.
   /// Otherwise, prints a tree of expressions one node per line.
@@ -819,6 +921,11 @@ class ExprSet {
  protected:
   void clearSharedSubexprs();
 
+  /// Initializes adaptive CPU sampling state on the EvalCtx. Sets
+  /// sampling flags, max overhead percentage, and measures CpuWallTimer
+  /// overhead once per ExprSet.
+  void initializeAdaptiveCpuSampling(EvalCtx& context);
+
   std::vector<std::shared_ptr<Expr>> exprs_;
 
   // The distinct references to input columns among all expressions in ExprSet.
@@ -835,6 +942,20 @@ class ExprSet {
   std::unordered_set<Expr*> memoizingExprs_;
   core::ExecCtx* const execCtx_;
   const bool lazyDereference_;
+
+  // Set to true when expression-level tracers are configured for this ExprSet.
+  // Cached to avoid re-querying TraceCtx at close time.
+  bool exprTracingEnabled_{false};
+
+  // Cached from QueryConfig at construction time to avoid repeated map lookups.
+  const bool adaptiveCpuSampling_;
+  const double adaptiveCpuSamplingMaxOverheadPct_;
+
+  // Measured CpuWallTimer overhead (nanos per invocation). Measured once on
+  // the first eval() call and shared across all Expr nodes via EvalCtx.
+  // This is a platform constant — does not vary by expression or data.
+  uint64_t timerOverheadNanos_{0};
+  bool timerOverheadMeasured_{false};
 };
 
 class ExprSetSimplified : public ExprSet {
@@ -884,6 +1005,14 @@ VectorPtr tryEvaluateConstantExpression(
     const std::shared_ptr<core::QueryCtx>& queryCtx,
     bool suppressEvaluationFailures = false);
 
+/// Variant of `tryEvaluateConstantExpression` with a raw pointer to QueryCtx
+/// instead of a shared_ptr, used by `ExprOptimizer`.
+VectorPtr tryEvaluateConstantExpression(
+    const core::TypedExprPtr& expr,
+    memory::MemoryPool* pool,
+    core::QueryCtx* queryCtx,
+    bool suppressEvaluationFailures);
+
 /// Returns a string representation of the expression trees annotated with
 /// runtime statistics. Expected to be called after calling ExprSet::eval one or
 /// more times. If called before ExprSet::eval runtime statistics will be all
diff --git a/velox/expression/ExprCompiler.cpp b/velox/expression/ExprCompiler.cpp
index b214261933e..160be3fb72c 100644
--- a/velox/expression/ExprCompiler.cpp
+++ b/velox/expression/ExprCompiler.cpp
@@ -16,15 +16,16 @@
 
 #include "velox/expression/ExprCompiler.h"
 #include "velox/expression/ConstantExpr.h"
-#include "velox/expression/Expr.h"
 #include "velox/expression/ExprConstants.h"
+#include "velox/expression/ExprOptimizer.h"
+#include "velox/expression/ExprRewriteRegistry.h"
 #include "velox/expression/ExprUtils.h"
 #include "velox/expression/FieldReference.h"
 #include "velox/expression/LambdaExpr.h"
+#include "velox/expression/NullIfExpr.h"
 #include "velox/expression/RowConstructor.h"
 #include "velox/expression/SimpleFunctionRegistry.h"
 #include "velox/expression/SpecialFormRegistry.h"
-#include "velox/expression/VectorFunction.h"
 
 namespace facebook::velox::exec {
 
@@ -33,24 +34,47 @@ namespace {
 using core::ITypedExpr;
 using core::TypedExprPtr;
 
-struct ITypedExprHasher {
-  size_t operator()(const ITypedExpr* expr) const {
-    return expr->hash();
-  }
-};
-
-struct ITypedExprComparer {
-  bool operator()(const ITypedExpr* lhs, const ITypedExpr* rhs) const {
-    return *lhs == *rhs;
+/// Parses a comma-separated list of function names that should turn on CPU
+/// tracking.
+std::unordered_set<std::string> fetchCallExprNamesForCpuTracking(
+    const core::QueryConfig& queryConfig) {
+  std::vector<std::string> nameList;
+  folly::split(
+      ',', queryConfig.exprTrackCpuUsageForFunctions(), nameList, true);
+
+  std::unordered_set<std::string> result;
+  for (auto& name : nameList) {
+    // Sanitize function names.
+    folly::toLowerAscii(name);
+    if (!name.empty()) {
+      result.insert(std::move(name));
+    }
   }
-};
+  return result;
+}
 
 // Map for deduplicating ITypedExpr trees.
 using ExprDedupMap = folly::F14FastMap<
     const ITypedExpr*,
     std::shared_ptr<Expr>,
-    ITypedExprHasher,
-    ITypedExprComparer>;
+    core::ITypedExprHasher,
+    core::ITypedExprComparer>;
+
+struct CompilerCtx {
+  core::QueryCtx* queryCtx;
+  memory::MemoryPool* pool;
+
+  /// Whether to enable constant folding.
+  bool enableConstantFolding;
+
+  /// Names of simple or vector functions within the expression tree being
+  /// compiled that support flattening.
+  std::unordered_set<std::string> flatteningCandidates;
+
+  /// List of call expression names whose CPU usage should be tracked.
+  /// Extracted from the query config.
+  std::unordered_set<std::string> cpuUsageTrackingCandidates;
+};
 
 /// Represents a lexical scope. A top level scope corresponds to a top
 /// level Expr and is shared among the Exprs of the ExprSet. Each
@@ -105,28 +129,32 @@ std::optional<std::string> shouldFlatten(
   return std::nullopt;
 }
 
-ExprPtr getAlreadyCompiled(const ITypedExpr* expr, ExprDedupMap* visited) {
+ExprPtr getAlreadyCompiled(
+    const ITypedExpr* expr,
+    const core::QueryConfig& config,
+    ExprDedupMap* visited) {
   auto iter = visited->find(expr);
-  return iter == visited->end() ? nullptr : iter->second;
+  if (iter == visited->end()) {
+    return nullptr;
+  }
+
+  const ExprPtr& alreadyCompiled = iter->second;
+  if (alreadyCompiled->isDeterministic()) {
+    return alreadyCompiled;
+  }
+
+  return config.exprDedupNonDeterministic() ? alreadyCompiled : nullptr;
 }
 
 ExprPtr compileExpression(
     const TypedExprPtr& expr,
     Scope* scope,
-    const core::QueryConfig& config,
-    memory::MemoryPool* pool,
-    const std::unordered_set<std::string>& flatteningCandidates,
-    bool enableConstantFolding);
+    const CompilerCtx& ctx);
 
-std::vector<ExprPtr> compileInputs(
-    const TypedExprPtr& expr,
-    Scope* scope,
-    const core::QueryConfig& config,
-    memory::MemoryPool* pool,
-    const std::unordered_set<std::string>& flatteningCandidates,
-    bool enableConstantFolding) {
+std::vector<ExprPtr>
+compileInputs(const TypedExprPtr& expr, Scope* scope, const CompilerCtx& ctx) {
   std::vector<ExprPtr> compiledInputs;
-  auto flattenIf = shouldFlatten(expr, flatteningCandidates);
+  auto flattenIf = shouldFlatten(expr, ctx.flatteningCandidates);
   for (auto& input : expr->inputs()) {
     if (input->isInputKind()) {
       VELOX_CHECK(
@@ -137,22 +165,10 @@ std::vector<ExprPtr> compileInputs(
         std::vector<TypedExprPtr> flat;
         expression::utils::flattenInput(input, flattenIf.value(), flat);
         for (auto& input_2 : flat) {
-          compiledInputs.push_back(compileExpression(
-              input_2,
-              scope,
-              config,
-              pool,
-              flatteningCandidates,
-              enableConstantFolding));
+          compiledInputs.push_back(compileExpression(input_2, scope, ctx));
         }
       } else {
-        compiledInputs.push_back(compileExpression(
-            input,
-            scope,
-            config,
-            pool,
-            flatteningCandidates,
-            enableConstantFolding));
+        compiledInputs.push_back(compileExpression(input, scope, ctx));
       }
     }
   }
@@ -205,20 +221,11 @@ void captureFieldReference(
 std::shared_ptr<Expr> compileLambda(
     const core::LambdaTypedExpr* lambda,
     Scope* scope,
-    const core::QueryConfig& config,
-    memory::MemoryPool* pool,
-    const std::unordered_set<std::string>& flatteningCandidates,
-    bool enableConstantFolding) {
+    const CompilerCtx& ctx) {
   auto signature = lambda->signature();
   auto parameterNames = signature->names();
   Scope lambdaScope(std::move(parameterNames), scope, scope->exprSet);
-  auto body = compileExpression(
-      lambda->body(),
-      &lambdaScope,
-      config,
-      pool,
-      flatteningCandidates,
-      enableConstantFolding);
+  auto body = compileExpression(lambda->body(), &lambdaScope, ctx);
 
   // The lambda depends on the captures. For a lambda caller to be
   // able to peel off encodings, the captures too must be peelable.
@@ -226,7 +233,8 @@ std::shared_ptr<Expr> compileLambda(
   captureReferences.reserve(lambdaScope.capture.size());
   for (auto i = 0; i < lambdaScope.capture.size(); ++i) {
     auto expr = lambdaScope.captureFieldAccesses[i];
-    auto reference = getAlreadyCompiled(expr, &scope->visited);
+    auto reference =
+        getAlreadyCompiled(expr, ctx.queryCtx->queryConfig(), &scope->visited);
     if (!reference) {
       auto inner = lambdaScope.captureReferences[i];
       reference = std::make_shared<FieldReference>(
@@ -244,48 +252,7 @@ std::shared_ptr<Expr> compileLambda(
       std::move(signature),
       std::move(captureReferences),
       std::move(body),
-      config.exprTrackCpuUsage());
-}
-
-ExprPtr tryFoldIfConstant(const ExprPtr& expr, Scope* scope) {
-  if (expr->isConstantExpr() && scope->exprSet->execCtx()) {
-    try {
-      auto rowType = ROW({}, {});
-      auto execCtx = scope->exprSet->execCtx();
-      auto row = BaseVector::create<RowVector>(rowType, 1, execCtx->pool());
-      EvalCtx context(execCtx, scope->exprSet, row.get());
-      VectorPtr result;
-      SelectivityVector rows(1);
-      expr->eval(rows, context, result);
-      auto constantVector = BaseVector::wrapInConstant(1, 0, std::move(result));
-
-      auto resultExpr = std::make_shared<ConstantExpr>(constantVector);
-      if (expr->stats().defaultNullRowsSkipped ||
-          std::any_of(
-              expr->inputs().begin(),
-              expr->inputs().end(),
-              [](const ExprPtr& input) {
-                return input->stats().defaultNullRowsSkipped;
-              })) {
-        resultExpr->setDefaultNullRowsSkipped(true);
-      }
-      return resultExpr;
-    }
-    // Constant folding has a subtle gotcha: if folding a constant expression
-    // deterministically throws, we can't throw at expression compilation time
-    // yet because we can't guarantee that this expression would actually need
-    // to be evaluated.
-    //
-    // So, here, if folding an expression throws an exception, we just ignore it
-    // and leave the expression as-is. If this expression is hit at execution
-    // time and needs to be evaluated, it will throw and fail the query anyway.
-    // If not, in case this expression is never hit at execution time (for
-    // instance, if other arguments are all null in a function with default null
-    // behavior), the query won't fail.
-    catch (const VeloxUserError&) {
-    }
-  }
-  return expr;
+      ctx.queryCtx->queryConfig().exprTrackCpuUsage());
 }
 
 /// Returns a vector aligned with exprs vector where elements that correspond to
@@ -305,42 +272,39 @@ std::vector<VectorPtr> getConstantInputs(const std::vector<ExprPtr>& exprs) {
   return constants;
 }
 
-core::TypedExprPtr rewriteExpression(const core::TypedExprPtr& expr) {
-  for (auto& rewrite : expressionRewrites()) {
-    if (auto rewritten = rewrite(expr)) {
-      return rewritten;
-    }
-  }
-  return expr;
-}
-
 ExprPtr compileCall(
     const TypedExprPtr& expr,
     std::vector<ExprPtr> inputs,
     bool trackCpuUsage,
-    const core::QueryConfig& config) {
+    const CompilerCtx& ctx) {
   const auto* call = expr->asUnchecked<core::CallTypedExpr>();
+  // Determine if CPU tracking should be enabled for this specific expression.
+  if (!trackCpuUsage && !ctx.cpuUsageTrackingCandidates.empty()) {
+    trackCpuUsage = ctx.cpuUsageTrackingCandidates.count(call->name()) > 0;
+  }
   const auto& resultType = expr->type();
-
   const auto inputTypes = getTypes(inputs);
 
   if (auto specialForm = specialFormRegistry().getSpecialForm(call->name())) {
     return specialForm->constructSpecialForm(
-        resultType, std::move(inputs), trackCpuUsage, config);
-  }
-
-  if (auto functionWithMetadata = getVectorFunctionWithMetadata(
-          call->name(), inputTypes, getConstantInputs(inputs), config)) {
-    return std::make_shared<Expr>(
         resultType,
         std::move(inputs),
-        functionWithMetadata->first,
-        functionWithMetadata->second,
-        call->name(),
-        trackCpuUsage);
+        trackCpuUsage,
+        ctx.queryCtx->queryConfig());
   }
 
-  if (auto simpleFunctionEntry =
+  std::shared_ptr<VectorFunction> vectorFunction;
+  VectorFunctionMetadata metadata;
+
+  if (auto functionWithMetadata = getVectorFunctionWithMetadata(
+          call->name(),
+          inputTypes,
+          getConstantInputs(inputs),
+          ctx.queryCtx->queryConfig())) {
+    vectorFunction = functionWithMetadata->first;
+    metadata = functionWithMetadata->second;
+  } else if (
+      auto simpleFunctionEntry =
           simpleFunctions().resolveFunction(call->name(), inputTypes)) {
     VELOX_USER_CHECK(
         resultType->equivalent(*simpleFunctionEntry->type().get()),
@@ -351,46 +315,56 @@ ExprPtr compileCall(
         resultType,
         folly::join(", ", inputTypes));
 
-    auto func = simpleFunctionEntry->createFunction()->createVectorFunction(
-        inputTypes, getConstantInputs(inputs), config);
-    return std::make_shared<Expr>(
-        resultType,
-        std::move(inputs),
-        std::move(func),
-        simpleFunctionEntry->metadata(),
-        call->name(),
-        trackCpuUsage);
-  }
-
-  const auto& functionName = call->name();
-  auto vectorFunctionSignatures = getVectorFunctionSignatures(functionName);
-  auto simpleFunctionSignatures =
-      simpleFunctions().getFunctionSignatures(functionName);
-  std::vector<std::string> signatures;
+    vectorFunction =
+        simpleFunctionEntry->createFunction()->createVectorFunction(
+            inputTypes,
+            getConstantInputs(inputs),
+            ctx.queryCtx->queryConfig(),
+            ctx.pool);
+    metadata = simpleFunctionEntry->metadata();
+  } else {
+    const auto& functionName = call->name();
+    auto vectorFunctionSignatures = getVectorFunctionSignatures(functionName);
+    auto simpleFunctionSignatures =
+        simpleFunctions().getFunctionSignatures(functionName);
+    std::vector<std::string> signatures;
+
+    if (vectorFunctionSignatures.has_value()) {
+      for (const auto& signature : vectorFunctionSignatures.value()) {
+        signatures.push_back(fmt::format("({})", signature->toString()));
+      }
+    }
 
-  if (vectorFunctionSignatures.has_value()) {
-    for (const auto& signature : vectorFunctionSignatures.value()) {
+    for (const auto& signature : simpleFunctionSignatures) {
       signatures.push_back(fmt::format("({})", signature->toString()));
     }
-  }
 
-  for (const auto& signature : simpleFunctionSignatures) {
-    signatures.push_back(fmt::format("({})", signature->toString()));
+    if (signatures.empty()) {
+      VELOX_USER_FAIL(
+          "Scalar function name not registered: {}, called with arguments: ({}).",
+          call->name(),
+          folly::join(", ", inputTypes));
+    } else {
+      VELOX_USER_FAIL(
+          "Scalar function {} not registered with arguments: ({}). "
+          "Found function registered with the following signatures:\n{}",
+          call->name(),
+          folly::join(", ", inputTypes),
+          folly::join("\n", signatures));
+    }
   }
 
-  if (signatures.empty()) {
-    VELOX_USER_FAIL(
-        "Scalar function name not registered: {}, called with arguments: ({}).",
-        call->name(),
-        folly::join(", ", inputTypes));
-  } else {
-    VELOX_USER_FAIL(
-        "Scalar function {} not registered with arguments: ({}). "
-        "Found function registered with the following signatures:\n{}",
-        call->name(),
-        folly::join(", ", inputTypes),
-        folly::join("\n", signatures));
-  }
+  auto listeners = createVectorFunctionListeners(
+      call->name(), metadata, ctx.queryCtx->queryConfig());
+
+  return std::make_shared<Expr>(
+      resultType,
+      std::move(inputs),
+      std::move(vectorFunction),
+      metadata,
+      call->name(),
+      trackCpuUsage,
+      std::move(listeners));
 }
 
 ExprPtr compileCast(
@@ -418,11 +392,9 @@ ExprPtr compileCast(
 ExprPtr compileRewrittenExpression(
     const TypedExprPtr& expr,
     Scope* scope,
-    const core::QueryConfig& config,
-    memory::MemoryPool* pool,
-    const std::unordered_set<std::string>& flatteningCandidates,
-    bool enableConstantFolding) {
-  ExprPtr alreadyCompiled = getAlreadyCompiled(expr.get(), &scope->visited);
+    const CompilerCtx& ctx) {
+  ExprPtr alreadyCompiled = getAlreadyCompiled(
+      expr.get(), ctx.queryCtx->queryConfig(), &scope->visited);
   if (alreadyCompiled) {
     if (!alreadyCompiled->isMultiplyReferenced()) {
       scope->exprSet->addToReset(alreadyCompiled);
@@ -435,29 +407,38 @@ ExprPtr compileRewrittenExpression(
     return alreadyCompiled;
   }
 
-  const bool trackCpuUsage = config.exprTrackCpuUsage();
+  const bool trackCpuUsage = ctx.queryCtx->queryConfig().exprTrackCpuUsage();
 
   const auto& resultType = expr->type();
-  auto compiledInputs = compileInputs(
-      expr, scope, config, pool, flatteningCandidates, enableConstantFolding);
+  auto compiledInputs = compileInputs(expr, scope, ctx);
 
   ExprPtr result;
   switch (expr->kind()) {
     case core::ExprKind::kConcat: {
       result = getSpecialForm(
-          config,
-          RowConstructorCallToSpecialForm::kRowConstructor,
+          ctx.queryCtx->queryConfig(),
+          expression::kRowConstructor,
           resultType,
           std::move(compiledInputs),
           trackCpuUsage);
       break;
     }
     case core::ExprKind::kCast: {
-      result = compileCast(expr, compiledInputs, trackCpuUsage, config);
+      result = compileCast(
+          expr, compiledInputs, trackCpuUsage, ctx.queryCtx->queryConfig());
+      break;
+    }
+    case core::ExprKind::kNullIf: {
+      const auto* nullIf = expr->asUnchecked<core::NullIfTypedExpr>();
+      result = NullIfExpr::create(
+          std::move(compiledInputs),
+          nullIf->commonType(),
+          trackCpuUsage,
+          ctx.queryCtx->queryConfig());
       break;
     }
     case core::ExprKind::kCall: {
-      result = compileCall(expr, compiledInputs, trackCpuUsage, config);
+      result = compileCall(expr, compiledInputs, trackCpuUsage, ctx);
       break;
     }
     case core::ExprKind::kFieldAccess: {
@@ -483,17 +464,13 @@ ExprPtr compileRewrittenExpression(
     }
     case core::ExprKind::kConstant: {
       const auto* constant = expr->asUnchecked<core::ConstantTypedExpr>();
-      result = std::make_shared<ConstantExpr>(constant->toConstantVector(pool));
+      result =
+          std::make_shared<ConstantExpr>(constant->toConstantVector(ctx.pool));
       break;
     }
     case core::ExprKind::kLambda: {
-      result = compileLambda(
-          expr->asUnchecked<core::LambdaTypedExpr>(),
-          scope,
-          config,
-          pool,
-          flatteningCandidates,
-          enableConstantFolding);
+      result =
+          compileLambda(expr->asUnchecked<core::LambdaTypedExpr>(), scope, ctx);
       break;
     }
     default: {
@@ -502,42 +479,22 @@ ExprPtr compileRewrittenExpression(
   }
 
   result->computeMetadata();
-
-  ExprPtr compiled;
-  // If the expression is constant folding it is redundant.
-  if (enableConstantFolding && !result->isConstant()) {
-    compiled = tryFoldIfConstant(result, scope);
-    // Constant folding uses an uninitialized ExprSet for eval. This breaks the
-    // invariant that 'memoizingExprs_' relies on, which is that the Expr
-    // pointers will be alive for the lifetime of the ExprSet. Clear the
-    // execution state of the ExprSet to avoid this.
-    scope->exprSet->clear();
-  } else {
-    compiled = result;
-  }
-
-  scope->visited[expr.get()] = compiled;
-  return compiled;
+  scope->visited[expr.get()] = result;
+  return result;
 }
 
 ExprPtr compileExpression(
     const TypedExprPtr& expr,
     Scope* scope,
-    const core::QueryConfig& config,
-    memory::MemoryPool* pool,
-    const std::unordered_set<std::string>& flatteningCandidates,
-    bool enableConstantFolding) {
-  auto rewritten = rewriteExpression(expr);
+    const CompilerCtx& ctx) {
+  auto rewritten = ctx.enableConstantFolding
+      ? expression::optimize(expr, ctx.queryCtx, ctx.pool)
+      : expr;
   if (rewritten.get() != expr.get()) {
     scope->rewrittenExpressions.push_back(rewritten);
   }
   return compileRewrittenExpression(
-      rewritten == nullptr ? expr : rewritten,
-      scope,
-      config,
-      pool,
-      flatteningCandidates,
-      enableConstantFolding);
+      rewritten == nullptr ? expr : rewritten, scope, ctx);
 }
 
 /// Walk expression tree and collect names of functions used in CallTypedExpr
@@ -587,18 +544,18 @@ std::vector<std::shared_ptr<Expr>> compileExpressions(
   std::vector<std::shared_ptr<Expr>> exprs;
   exprs.reserve(sources.size());
 
-  // Precompute a set of function calls that support flattening. This allows to
-  // lock function registry once vs. locking for each function call.
-  auto flatteningCandidates = collectFlatteningCandidates(sources);
+  CompilerCtx ctx{
+      .queryCtx = execCtx->queryCtx(),
+      .pool = execCtx->pool(),
+      .enableConstantFolding = enableConstantFolding,
+      // Precompute a set of function calls that support flattening. This allows
+      // to lock function registry once vs. locking for each function call.
+      .flatteningCandidates = collectFlatteningCandidates(sources),
+      .cpuUsageTrackingCandidates =
+          fetchCallExprNamesForCpuTracking(execCtx->queryCtx()->queryConfig())};
 
   for (auto& source : sources) {
-    exprs.push_back(compileExpression(
-        source,
-        &scope,
-        execCtx->queryCtx()->queryConfig(),
-        execCtx->pool(),
-        flatteningCandidates,
-        enableConstantFolding));
+    exprs.push_back(compileExpression(source, &scope, ctx));
   }
   return exprs;
 }
diff --git a/velox/expression/ExprConstants.h b/velox/expression/ExprConstants.h
index 7cdf322d93d..cc399bb1860 100644
--- a/velox/expression/ExprConstants.h
+++ b/velox/expression/ExprConstants.h
@@ -17,14 +17,15 @@
 
 namespace facebook::velox::expression {
 
-constexpr const char* kAnd = "and";
-constexpr const char* kOr = "or";
-constexpr const char* kSwitch = "switch";
-constexpr const char* kIf = "if";
-constexpr const char* kFail = "fail";
-constexpr const char* kCoalesce = "coalesce";
-constexpr const char* kCast = "cast";
-constexpr const char* kTryCast = "try_cast";
-constexpr const char* kTry = "try";
+inline constexpr const char* kAnd = "and";
+inline constexpr const char* kOr = "or";
+inline constexpr const char* kSwitch = "switch";
+inline constexpr const char* kIf = "if";
+inline constexpr const char* kCoalesce = "coalesce";
+inline constexpr const char* kCast = "cast";
+inline constexpr const char* kTryCast = "try_cast";
+inline constexpr const char* kTry = "try";
+inline constexpr const char* kRowConstructor = "row_constructor";
+inline constexpr const char* kNullIf = "nullif";
 
 } // namespace facebook::velox::expression
diff --git a/velox/expression/ExprOptimizer.cpp b/velox/expression/ExprOptimizer.cpp
new file mode 100644
index 00000000000..3711a4fb861
--- /dev/null
+++ b/velox/expression/ExprOptimizer.cpp
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/expression/ExprOptimizer.h"
+#include "velox/core/Expressions.h"
+#include "velox/expression/Expr.h"
+#include "velox/expression/ExprRewriteRegistry.h"
+
+namespace facebook::velox::expression {
+
+namespace {
+
+// Tries constant folding input `expr` with `tryEvaluateConstantExpression` API
+// and returns the evaluated expression if constant folding succeeds. If
+// `tryEvaluateConstantExpression` throws a `VeloxUserError`, returns the
+// result of applying `makeFailExpr` to `expr`, otherwise returns `expr`.
+core::TypedExprPtr tryConstantFold(
+    const core::TypedExprPtr& expr,
+    core::QueryCtx* queryCtx,
+    memory::MemoryPool* pool,
+    const MakeFailExpr& makeFailExpr) {
+  try {
+    if (auto results =
+            exec::tryEvaluateConstantExpression(expr, pool, queryCtx, false)) {
+      return std::make_shared<core::ConstantTypedExpr>(results);
+    }
+  } catch (VeloxUserError& e) {
+    if (makeFailExpr != nullptr) {
+      const auto result = makeFailExpr(e.message(), expr->type());
+      VELOX_USER_CHECK(
+          *result->type() == *expr->type(),
+          "makeFailExpr returned expression: {} of type: {}, which does not match type: {} of failing expression: {}",
+          result->toString(),
+          result->type()->toString(),
+          expr->type()->toString(),
+          expr->toString());
+      return result;
+    }
+  }
+  // Return the expression unmodified.
+  return expr;
+}
+
+// Optimizes all inputs to expr and returns an expression that is of the same
+// kind as expr but with optimized inputs.
+core::TypedExprPtr optimizeInputs(
+    const core::TypedExprPtr& expr,
+    core::QueryCtx* queryCtx,
+    memory::MemoryPool* pool,
+    const MakeFailExpr& makeFailExpr) {
+  if (expr->isCallKind() || expr->isNullIfKind()) {
+    std::vector<core::TypedExprPtr> optimizedInputs;
+    optimizedInputs.reserve(expr->inputs().size());
+    for (const auto& input : expr->inputs()) {
+      optimizedInputs.push_back(optimize(input, queryCtx, pool, makeFailExpr));
+    }
+
+    if (expr->isCallKind()) {
+      const auto* callExpr = expr->asUnchecked<core::CallTypedExpr>();
+      return std::make_shared<core::CallTypedExpr>(
+          callExpr->type(), optimizedInputs, callExpr->name());
+    }
+
+    const auto* nullIfExpr = expr->asUnchecked<core::NullIfTypedExpr>();
+    return std::make_shared<core::NullIfTypedExpr>(
+        optimizedInputs[0], optimizedInputs[1], nullIfExpr->commonType());
+  }
+
+  if (expr->isCastKind()) {
+    const auto optimizedInput =
+        optimize(expr->inputs().at(0), queryCtx, pool, makeFailExpr);
+    const auto* castExpr = expr->asUnchecked<core::CastTypedExpr>();
+    return std::make_shared<core::CastTypedExpr>(
+        expr->type(), optimizedInput, castExpr->isTryCast());
+  }
+
+  if (expr->isLambdaKind()) {
+    const auto* lambdaExpr = expr->asUnchecked<core::LambdaTypedExpr>();
+    const auto foldedBody =
+        optimize(lambdaExpr->body(), queryCtx, pool, makeFailExpr);
+    return std::make_shared<core::LambdaTypedExpr>(
+        lambdaExpr->signature(), foldedBody);
+  }
+
+  return expr;
+}
+} // namespace
+
+core::TypedExprPtr optimize(
+    const core::TypedExprPtr& expr,
+    core::QueryCtx* queryCtx,
+    memory::MemoryPool* pool,
+    const MakeFailExpr& makeFailExpr) {
+  auto result = expr;
+  // cast(1 AS BIGINT) -> 1.
+  // cast(a AS BIGINT) -> a ; when type(a) == BIGINT.
+  // cast(concat(a, 'test') AS VARCHAR) -> concat(a, 'test') ; when type(a) ==
+  //  VARCHAR.
+  if (result->isCastKind() &&
+      *result->type() == *result->inputs().at(0)->type()) {
+    result = result->inputs().at(0);
+  }
+  // 1 -> 1, a -> a.
+  if (result->isConstantKind() || result->isFieldAccessKind()) {
+    return result;
+  }
+
+  result = optimizeInputs(result, queryCtx, pool, makeFailExpr);
+  bool allInputsConstant = true;
+  for (const auto& input : result->inputs()) {
+    if (!input->isConstantKind()) {
+      allInputsConstant = false;
+      break;
+    }
+  }
+
+  if (allInputsConstant) {
+    return tryConstantFold(result, queryCtx, pool, makeFailExpr);
+  }
+  return ExprRewriteRegistry::instance().rewrite(result);
+}
+
+} // namespace facebook::velox::expression
diff --git a/velox/expression/ExprOptimizer.h b/velox/expression/ExprOptimizer.h
new file mode 100644
index 00000000000..6448ce99b99
--- /dev/null
+++ b/velox/expression/ExprOptimizer.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/core/Expressions.h"
+#include "velox/core/QueryCtx.h"
+
+namespace facebook::velox::expression {
+
+/// A callback invoked if execution failure is encountered during constant
+/// folding. The callback receives an error message and the result type of the
+/// expression that fails. The callback is expected to produce a replacement
+/// expression with the same result type. For example, Presto returns
+/// `cast(fail(errorMessage) as resultType)`.
+using MakeFailExpr = std::function<core::TypedExprPtr(
+    const std::string& errorMessage,
+    const TypePtr& resultType)>;
+
+/// Optimizes expression through a combination of constant folding and rewrites;
+/// all possible subtrees of the expression are constant folded first in a
+/// bottom up manner, then the folded expression is rewritten. If an exception
+/// (i.e VeloxUserError) is encountered during constant folding of any subtree
+/// of the expression and the function `makeFailExpr` is provided, the failing
+/// subexpression is replaced by the result of applying `makeFailExpr`, allowing
+/// users to define custom logic for handling constant folding errors during
+/// expression optimization. When `makeFailExpr` is not provided, exceptions
+/// encountered while constant folding subexpressions are ignored and failing
+/// subexpressions are left unchanged in the expression tree.
+core::TypedExprPtr optimize(
+    const core::TypedExprPtr& expr,
+    core::QueryCtx* queryCtx,
+    memory::MemoryPool* pool,
+    const MakeFailExpr& makeFailExpr = nullptr);
+} // namespace facebook::velox::expression
diff --git a/velox/expression/ExprRewriteRegistry.cpp b/velox/expression/ExprRewriteRegistry.cpp
new file mode 100644
index 00000000000..5f144e0376d
--- /dev/null
+++ b/velox/expression/ExprRewriteRegistry.cpp
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/expression/ExprRewriteRegistry.h"
+#include "velox/expression/FunctionSignature.h"
+
+namespace facebook::velox::expression {
+
+void ExprRewriteRegistry::registerRewrite(ExpressionRewrite rewrite) {
+  registry_.withWLock([&](auto& list) { list.push_back(std::move(rewrite)); });
+}
+
+void ExprRewriteRegistry::clear() {
+  registry_.withWLock([&](auto& list) { list.clear(); });
+}
+
+core::TypedExprPtr ExprRewriteRegistry::rewrite(
+    const core::TypedExprPtr& expr) {
+  const auto& inputs = expr->inputs();
+  VELOX_CHECK(
+      std::any_of(
+          inputs.begin(),
+          inputs.end(),
+          [](const core::TypedExprPtr& input) {
+            return !input->isConstantKind();
+          }),
+      "Expression should have at least one non-constant input.");
+
+  core::TypedExprPtr result = expr;
+  registry_.withRLock([&](const auto& list) {
+    for (const auto& rewrite : list) {
+      VELOX_CHECK_NOT_NULL(rewrite);
+      if (auto rewritten = (rewrite)(expr)) {
+        result = rewritten;
+        break;
+      }
+    }
+  });
+
+  return result;
+}
+} // namespace facebook::velox::expression
diff --git a/velox/expression/ExprRewriteRegistry.h b/velox/expression/ExprRewriteRegistry.h
new file mode 100644
index 00000000000..7e39dd67dea
--- /dev/null
+++ b/velox/expression/ExprRewriteRegistry.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <folly/Synchronized.h>
+#include "velox/core/Expressions.h"
+
+namespace facebook::velox::expression {
+
+/// An expression re-writer that takes an expression and returns an equivalent
+/// expression or nullptr if re-write is not possible.
+using ExpressionRewrite =
+    std::function<core::TypedExprPtr(const core::TypedExprPtr)>;
+
+class ExprRewriteRegistry {
+ public:
+  /// Appends a 'rewrite' to 'expressionRewrites'.
+  ///
+  /// The logic that applies re-writes is very simple and assumes that all
+  /// rewrites are independent. For each expression, rewrites are applied in the
+  /// order they were registered. The first rewrite that returns non-null result
+  /// terminates the re-write for that particular expression.
+  void registerRewrite(ExpressionRewrite rewrite);
+
+  /// Clears the registry to remove all registered rewrites.
+  void clear();
+
+  /// Rewrites input expression to an equivalent expression. Throws if the
+  /// expression only has constant inputs.
+  core::TypedExprPtr rewrite(const core::TypedExprPtr& expr);
+
+  static ExprRewriteRegistry& instance() {
+    static ExprRewriteRegistry kInstance;
+    return kInstance;
+  }
+
+ private:
+  folly::Synchronized<std::vector<ExpressionRewrite>> registry_;
+};
+} // namespace facebook::velox::expression
diff --git a/velox/expression/ExprStats.h b/velox/expression/ExprStats.h
index 2d285b33ac1..532925cbff2 100644
--- a/velox/expression/ExprStats.h
+++ b/velox/expression/ExprStats.h
@@ -35,6 +35,8 @@ struct ExprStats {
   /// evaluation of rows.
   bool defaultNullRowsSkipped{false};
 
+  auto operator<=>(const ExprStats&) const = default;
+
   void add(const ExprStats& other) {
     timing.add(other.timing);
     numProcessedRows += other.numProcessedRows;
diff --git a/velox/expression/ExprToSubfieldFilter.cpp b/velox/expression/ExprToSubfieldFilter.cpp
index e2e7d3ef796..44ab7d5ef69 100644
--- a/velox/expression/ExprToSubfieldFilter.cpp
+++ b/velox/expression/ExprToSubfieldFilter.cpp
@@ -50,17 +50,28 @@ T singleValue(const VectorPtr& vector) {
   return simpleVector->valueAt(0);
 }
 
-const core::CallTypedExpr* asCall(const core::ITypedExpr* expr) {
-  return dynamic_cast<const core::CallTypedExpr*>(expr);
+bool isBigintRange(const std::unique_ptr<common::Filter>& filter) {
+  return filter->is(common::FilterKind::kBigintRange);
 }
 
-common::BigintRange* asBigintRange(std::unique_ptr<common::Filter>& filter) {
-  return dynamic_cast<common::BigintRange*>(filter.get());
+bool isBigintMultiRange(const std::unique_ptr<common::Filter>& filter) {
+  return filter->is(common::FilterKind::kBigintMultiRange);
 }
 
-common::BigintMultiRange* asBigintMultiRange(
-    std::unique_ptr<common::Filter>& filter) {
-  return dynamic_cast<common::BigintMultiRange*>(filter.get());
+bool isBytesValues(const std::unique_ptr<common::Filter>& filter) {
+  return filter->is(common::FilterKind::kBytesValues);
+}
+
+bool isBytesRange(const std::unique_ptr<common::Filter>& filter) {
+  return filter->is(common::FilterKind::kBytesRange);
+}
+
+bool isSingleValueBytesRange(const std::unique_ptr<common::Filter>& filter) {
+  if (!isBytesRange(filter)) {
+    return false;
+  }
+  const auto* bytesRange = filter->as<common::BytesRange>();
+  return bytesRange->isSingleValue();
 }
 
 template <typename T, typename U>
@@ -68,58 +79,110 @@ std::unique_ptr<T> asUniquePtr(std::unique_ptr<U> ptr) {
   return std::unique_ptr<T>(static_cast<T*>(ptr.release()));
 }
 
-std::unique_ptr<common::Filter> makeOrFilter(
-    std::unique_ptr<common::Filter> a,
-    std::unique_ptr<common::Filter> b) {
-  if (asBigintRange(a) && asBigintRange(b)) {
-    return bigintOr(
-        asUniquePtr<common::BigintRange>(std::move(a)),
-        asUniquePtr<common::BigintRange>(std::move(b)));
-  }
+std::unique_ptr<common::BigintRange> asBigintRange(
+    std::unique_ptr<common::Filter>& ptr) {
+  return asUniquePtr<common::BigintRange>(std::move(ptr));
+}
 
-  if (asBigintRange(a) && asBigintMultiRange(b)) {
-    const auto& ranges = asBigintMultiRange(b)->ranges();
-    std::vector<std::unique_ptr<common::BigintRange>> newRanges;
-    newRanges.emplace_back(asUniquePtr<common::BigintRange>(std::move(a)));
-    for (const auto& range : ranges) {
-      newRanges.emplace_back(asUniquePtr<common::BigintRange>(range->clone()));
+template <typename T>
+std::unique_ptr<common::Filter> toInt64In(
+    const VectorPtr& vector,
+    vector_size_t start,
+    vector_size_t size,
+    bool negated) {
+  auto ints = vector->as<SimpleVector<T>>();
+  std::vector<int64_t> values;
+  values.reserve(size);
+  bool hasNull = false;
+  if (!ints->mayHaveNulls()) {
+    for (auto i = 0; i < size; i++) {
+      values.push_back(ints->valueAt(start + i));
+    }
+  } else {
+    for (auto i = 0; i < size; i++) {
+      if (!ints->isNullAt(start + i)) {
+        values.push_back(ints->valueAt(start + i));
+      } else if (!hasNull) {
+        hasNull = true;
+      }
     }
-
-    std::sort(
-        newRanges.begin(), newRanges.end(), [](const auto& a, const auto& b) {
-          return a->lower() < b->lower();
-        });
-
-    return std::make_unique<common::BigintMultiRange>(
-        std::move(newRanges), false);
   }
 
-  if (asBigintMultiRange(a) && asBigintRange(b)) {
-    return makeOrFilter(std::move(b), std::move(a));
+  if (negated) {
+    if (hasNull) {
+      // If values contain NULL, the input cannot pass the filter, e.g. '1
+      // not in (2, NULL)' evaluates to NULL.
+      return std::make_unique<common::AlwaysFalse>();
+    }
+    return notIn(values);
   }
 
-  return orFilter(std::move(a), std::move(b));
+  return in(values);
 }
 
-template <typename T>
-std::vector<int64_t>
-toInt64List(const VectorPtr& vector, vector_size_t start, vector_size_t size) {
-  auto ints = vector->as<SimpleVector<T>>();
-  std::vector<int64_t> values;
-  for (auto i = 0; i < size; i++) {
-    values.push_back(ints->valueAt(start + i));
+} // namespace
+
+namespace {
+std::unique_ptr<common::Filter> bigintOrImpl(
+    std::vector<std::unique_ptr<common::Filter>> inputs,
+    bool nullAllowed) {
+  std::vector<std::unique_ptr<common::BigintRange>> ranges;
+  for (auto& input : inputs) {
+    if (input->kind() == common::FilterKind::kIsNull) {
+      nullAllowed = true;
+    } else if (input->kind() != common::FilterKind::kAlwaysFalse) {
+      VELOX_CHECK(
+          isBigintRange(input),
+          "Expected BigintRange filter, got: {}",
+          input->toString());
+      ranges.emplace_back(asBigintRange(input));
+    }
+  }
+  if (ranges.empty()) {
+    if (nullAllowed) {
+      return std::make_unique<common::IsNull>();
+    }
+    return std::make_unique<common::AlwaysFalse>();
+  }
+  if (ranges.size() == 1) {
+    if (nullAllowed) {
+      return std::make_unique<common::BigintRange>(
+          ranges[0]->lower(), ranges[0]->upper(), true);
+    }
+    return std::move(ranges[0]);
   }
-  return values;
+  return std::make_unique<common::BigintMultiRange>(
+      std::move(ranges), nullAllowed);
 }
+} // namespace
 
-static std::shared_ptr<ExprToSubfieldFilterParser> defaultParser =
-    std::make_shared<PrestoExprToSubfieldFilterParser>();
+std::unique_ptr<common::Filter> bigintOr(
+    std::unique_ptr<common::Filter> a,
+    std::unique_ptr<common::Filter> b,
+    bool nullAllowed) {
+  std::vector<std::unique_ptr<common::Filter>> inputs;
+  inputs.emplace_back(std::move(a));
+  inputs.emplace_back(std::move(b));
+  return bigintOrImpl(std::move(inputs), nullAllowed);
+}
 
-} // namespace
+std::unique_ptr<common::Filter> bigintOr(
+    std::unique_ptr<common::Filter> a,
+    std::unique_ptr<common::Filter> b,
+    std::unique_ptr<common::Filter> c,
+    bool nullAllowed) {
+  std::vector<std::unique_ptr<common::Filter>> inputs;
+  inputs.emplace_back(std::move(a));
+  inputs.emplace_back(std::move(b));
+  inputs.emplace_back(std::move(c));
+  return bigintOrImpl(std::move(inputs), nullAllowed);
+}
 
-std::function<std::shared_ptr<ExprToSubfieldFilterParser>()>
-    ExprToSubfieldFilterParser::parserFactory_ = [] { return defaultParser; };
+std::shared_ptr<ExprToSubfieldFilterParser>
+    ExprToSubfieldFilterParser::parser_ =
+        std::make_shared<PrestoExprToSubfieldFilterParser>();
 
+// static
 bool ExprToSubfieldFilterParser::toSubfield(
     const core::ITypedExpr* field,
     common::Subfield& subfield) {
@@ -161,6 +224,7 @@ bool ExprToSubfieldFilterParser::toSubfield(
   return true;
 }
 
+// static
 std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeNotEqualFilter(
     const core::TypedExprPtr& valueExpr,
     core::ExpressionEvaluator* evaluator) {
@@ -168,46 +232,60 @@ std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeNotEqualFilter(
   if (!value) {
     return nullptr;
   }
+  if (value->isNullAt(0)) {
+    return std::make_unique<common::AlwaysFalse>();
+  }
 
-  std::unique_ptr<common::Filter> lessThanFilter =
-      makeLessThanFilter(valueExpr, evaluator);
+  auto lessThanFilter = makeLessThanFilter(valueExpr, evaluator);
   if (!lessThanFilter) {
     return nullptr;
   }
-  std::unique_ptr<common::Filter> greaterThanFilter =
-      makeGreaterThanFilter(valueExpr, evaluator);
+
+  auto greaterThanFilter = makeGreaterThanFilter(valueExpr, evaluator);
   if (!greaterThanFilter) {
     return nullptr;
   }
 
-  if (value->typeKind() == TypeKind::TINYINT ||
-      value->typeKind() == TypeKind::SMALLINT ||
-      value->typeKind() == TypeKind::INTEGER ||
-      value->typeKind() == TypeKind::BIGINT) {
-    // Cast lessThanFilter and greaterThanFilter to
-    // std::unique_ptr<common::BigintRange>.
-    std::vector<std::unique_ptr<common::BigintRange>> ranges;
-    auto lessRange =
-        dynamic_cast<common::BigintRange*>(lessThanFilter.release());
-    VELOX_CHECK_NOT_NULL(lessRange, "Less-than range is null");
-    ranges.emplace_back(std::unique_ptr<common::BigintRange>(lessRange));
-
-    auto greaterRange =
-        dynamic_cast<common::BigintRange*>(greaterThanFilter.release());
-    VELOX_CHECK_NOT_NULL(greaterRange, "Greater-than range is null");
-    ranges.emplace_back(std::unique_ptr<common::BigintRange>(greaterRange));
-
-    return std::make_unique<common::BigintMultiRange>(std::move(ranges), false);
-  } else if (value->typeKind() == TypeKind::HUGEINT) {
+  const auto typeKind = value->typeKind();
+
+  if (typeKind == TypeKind::TINYINT || typeKind == TypeKind::SMALLINT ||
+      typeKind == TypeKind::INTEGER || typeKind == TypeKind::BIGINT) {
+    if (lessThanFilter->kind() == common::FilterKind::kAlwaysFalse) {
+      return greaterThanFilter;
+    }
+    if (greaterThanFilter->kind() == common::FilterKind::kAlwaysFalse) {
+      return lessThanFilter;
+    }
+    VELOX_CHECK(isBigintRange(lessThanFilter));
+    VELOX_CHECK(isBigintRange(greaterThanFilter));
+
+    std::vector<std::unique_ptr<common::BigintRange>> filters;
+    filters.emplace_back(asBigintRange(lessThanFilter));
+    filters.emplace_back(asBigintRange(greaterThanFilter));
+    return std::make_unique<common::BigintMultiRange>(
+        std::move(filters), false);
+  }
+
+  if (typeKind == TypeKind::HUGEINT) {
     VELOX_NYI();
   } else {
+    if (lessThanFilter->kind() == common::FilterKind::kAlwaysFalse ||
+        lessThanFilter->kind() == common::FilterKind::kIsNull) {
+      return greaterThanFilter;
+    }
+    if (greaterThanFilter->kind() == common::FilterKind::kAlwaysFalse ||
+        greaterThanFilter->kind() == common::FilterKind::kIsNull) {
+      return lessThanFilter;
+    }
     std::vector<std::unique_ptr<common::Filter>> filters;
     filters.emplace_back(std::move(lessThanFilter));
     filters.emplace_back(std::move(greaterThanFilter));
+
     return std::make_unique<common::MultiRange>(std::move(filters), false);
   }
 }
 
+// static
 std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeEqualFilter(
     const core::TypedExprPtr& valueExpr,
     core::ExpressionEvaluator* evaluator) {
@@ -215,6 +293,9 @@ std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeEqualFilter(
   if (!value) {
     return nullptr;
   }
+  if (value->isNullAt(0)) {
+    return std::make_unique<common::AlwaysFalse>();
+  }
   switch (value->typeKind()) {
     case TypeKind::BOOLEAN:
       return boolEqual(singleValue<bool>(value));
@@ -229,7 +310,7 @@ std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeEqualFilter(
     case TypeKind::HUGEINT:
       return equalHugeint(singleValue<int128_t>(value));
     case TypeKind::VARCHAR:
-      return equal(singleValue<StringView>(value));
+      return equal(std::string(singleValue<StringView>(value)));
     case TypeKind::TIMESTAMP:
       return equal(singleValue<Timestamp>(value));
     default:
@@ -237,6 +318,7 @@ std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeEqualFilter(
   }
 }
 
+// static
 std::unique_ptr<common::Filter>
 ExprToSubfieldFilterParser::makeGreaterThanFilter(
     const core::TypedExprPtr& lowerExpr,
@@ -245,6 +327,9 @@ ExprToSubfieldFilterParser::makeGreaterThanFilter(
   if (!lower) {
     return nullptr;
   }
+  if (lower->isNullAt(0)) {
+    return std::make_unique<common::AlwaysFalse>();
+  }
   switch (lower->typeKind()) {
     case TypeKind::TINYINT:
       return greaterThan(singleValue<int8_t>(lower));
@@ -261,7 +346,7 @@ ExprToSubfieldFilterParser::makeGreaterThanFilter(
     case TypeKind::REAL:
       return greaterThanFloat(singleValue<float>(lower));
     case TypeKind::VARCHAR:
-      return greaterThan(singleValue<StringView>(lower));
+      return greaterThan(std::string(singleValue<StringView>(lower)));
     case TypeKind::TIMESTAMP:
       return greaterThan(singleValue<Timestamp>(lower));
     default:
@@ -269,6 +354,7 @@ ExprToSubfieldFilterParser::makeGreaterThanFilter(
   }
 }
 
+// static
 std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeLessThanFilter(
     const core::TypedExprPtr& upperExpr,
     core::ExpressionEvaluator* evaluator) {
@@ -276,6 +362,9 @@ std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeLessThanFilter(
   if (!upper) {
     return nullptr;
   }
+  if (upper->isNullAt(0)) {
+    return std::make_unique<common::AlwaysFalse>();
+  }
   switch (upper->typeKind()) {
     case TypeKind::TINYINT:
       return lessThan(singleValue<int8_t>(upper));
@@ -292,7 +381,7 @@ std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeLessThanFilter(
     case TypeKind::REAL:
       return lessThanFloat(singleValue<float>(upper));
     case TypeKind::VARCHAR:
-      return lessThan(singleValue<StringView>(upper));
+      return lessThan(std::string(singleValue<StringView>(upper)));
     case TypeKind::TIMESTAMP:
       return lessThan(singleValue<Timestamp>(upper));
     default:
@@ -300,6 +389,7 @@ std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeLessThanFilter(
   }
 }
 
+// static
 std::unique_ptr<common::Filter>
 ExprToSubfieldFilterParser::makeLessThanOrEqualFilter(
     const core::TypedExprPtr& upperExpr,
@@ -308,6 +398,9 @@ ExprToSubfieldFilterParser::makeLessThanOrEqualFilter(
   if (!upper) {
     return nullptr;
   }
+  if (upper->isNullAt(0)) {
+    return std::make_unique<common::AlwaysFalse>();
+  }
   switch (upper->typeKind()) {
     case TypeKind::TINYINT:
       return lessThanOrEqual(singleValue<int8_t>(upper));
@@ -324,7 +417,7 @@ ExprToSubfieldFilterParser::makeLessThanOrEqualFilter(
     case TypeKind::REAL:
       return lessThanOrEqualFloat(singleValue<float>(upper));
     case TypeKind::VARCHAR:
-      return lessThanOrEqual(singleValue<StringView>(upper));
+      return lessThanOrEqual(std::string(singleValue<StringView>(upper)));
     case TypeKind::TIMESTAMP:
       return lessThanOrEqual(singleValue<Timestamp>(upper));
     default:
@@ -332,6 +425,7 @@ ExprToSubfieldFilterParser::makeLessThanOrEqualFilter(
   }
 }
 
+// static
 std::unique_ptr<common::Filter>
 ExprToSubfieldFilterParser::makeGreaterThanOrEqualFilter(
     const core::TypedExprPtr& lowerExpr,
@@ -340,6 +434,9 @@ ExprToSubfieldFilterParser::makeGreaterThanOrEqualFilter(
   if (!lower) {
     return nullptr;
   }
+  if (lower->isNullAt(0)) {
+    return std::make_unique<common::AlwaysFalse>();
+  }
   switch (lower->typeKind()) {
     case TypeKind::TINYINT:
       return greaterThanOrEqual(singleValue<int8_t>(lower));
@@ -356,7 +453,7 @@ ExprToSubfieldFilterParser::makeGreaterThanOrEqualFilter(
     case TypeKind::REAL:
       return greaterThanOrEqualFloat(singleValue<float>(lower));
     case TypeKind::VARCHAR:
-      return greaterThanOrEqual(singleValue<StringView>(lower));
+      return greaterThanOrEqual(std::string(singleValue<StringView>(lower)));
     case TypeKind::TIMESTAMP:
       return greaterThanOrEqual(singleValue<Timestamp>(lower));
     default:
@@ -364,6 +461,7 @@ ExprToSubfieldFilterParser::makeGreaterThanOrEqualFilter(
   }
 }
 
+// static
 std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeInFilter(
     const core::TypedExprPtr& expr,
     core::ExpressionEvaluator* evaluator,
@@ -381,29 +479,39 @@ std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeInFilter(
 
   auto elementType = arrayVector->type()->asArray().elementType();
   switch (elementType->kind()) {
-    case TypeKind::TINYINT: {
-      auto values = toInt64List<int8_t>(elements, offset, size);
-      return negated ? notIn(values) : in(values);
-    }
-    case TypeKind::SMALLINT: {
-      auto values = toInt64List<int16_t>(elements, offset, size);
-      return negated ? notIn(values) : in(values);
-    }
-    case TypeKind::INTEGER: {
-      auto values = toInt64List<int32_t>(elements, offset, size);
-      return negated ? notIn(values) : in(values);
-    }
-    case TypeKind::BIGINT: {
-      auto values = toInt64List<int64_t>(elements, offset, size);
-      return negated ? notIn(values) : in(values);
-    }
+    case TypeKind::TINYINT:
+      return toInt64In<int8_t>(elements, offset, size, negated);
+    case TypeKind::SMALLINT:
+      return toInt64In<int16_t>(elements, offset, size, negated);
+    case TypeKind::INTEGER:
+      return toInt64In<int32_t>(elements, offset, size, negated);
+    case TypeKind::BIGINT:
+      return toInt64In<int64_t>(elements, offset, size, negated);
     case TypeKind::VARCHAR: {
       auto stringElements = elements->as<SimpleVector<StringView>>();
       std::vector<std::string> values;
-      for (auto i = 0; i < size; i++) {
-        values.push_back(stringElements->valueAt(offset + i).str());
+      values.reserve(size);
+      bool hasNull = false;
+      if (!stringElements->mayHaveNulls()) {
+        for (auto i = 0; i < size; i++) {
+          values.push_back(std::string(stringElements->valueAt(offset + i)));
+        }
+      } else {
+        for (auto i = 0; i < size; i++) {
+          if (!stringElements->isNullAt(offset + i)) {
+            values.push_back(std::string(stringElements->valueAt(offset + i)));
+          } else if (!hasNull) {
+            hasNull = true;
+          }
+        }
       }
+
       if (negated) {
+        if (hasNull) {
+          // If values contain NULL, the input cannot pass the filter, e.g. 'a'
+          // not in ('b', NULL) evaluates to NULL.
+          return std::make_unique<common::AlwaysFalse>();
+        }
         return notIn(values);
       }
       return in(values);
@@ -413,6 +521,7 @@ std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeInFilter(
   }
 }
 
+// static
 std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeBetweenFilter(
     const core::TypedExprPtr& lowerExpr,
     const core::TypedExprPtr& upperExpr,
@@ -451,10 +560,12 @@ std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeBetweenFilter(
     case TypeKind::VARCHAR:
       if (negated) {
         return notBetween(
-            singleValue<StringView>(lower), singleValue<StringView>(upper));
+            std::string(singleValue<StringView>(lower)),
+            std::string(singleValue<StringView>(upper)));
       }
       return between(
-          singleValue<StringView>(lower), singleValue<StringView>(upper));
+          std::string(singleValue<StringView>(lower)),
+          std::string(singleValue<StringView>(upper)));
     case TypeKind::TIMESTAMP:
       return negated
           ? nullptr
@@ -465,100 +576,362 @@ std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeBetweenFilter(
   }
 }
 
-std::unique_ptr<common::Filter>
+namespace {
+
+bool isNullAllowed(
+    const std::vector<std::unique_ptr<common::Filter>>& disjuncts) {
+  return std::any_of(
+      disjuncts.begin(), disjuncts.end(), [](const auto& filter) {
+        return filter->nullAllowed();
+      });
+}
+
+// Combines overlapping ranges into one using OR semantic. Returns nullptr if
+// ranges do not overlap. Ignores nullAllowed flag.
+// @pre a.lower() <= b.lower()
+std::unique_ptr<common::BigintRange> tryMergeOverlappingRanges(
+    const common::BigintRange& a,
+    const common::BigintRange& b,
+    bool& alwaysTrue) {
+  static constexpr auto kMax = std::numeric_limits<int64_t>::max();
+  static constexpr auto kMin = std::numeric_limits<int64_t>::min();
+
+  if (a.upper() == kMax || a.upper() + 1 >= b.lower()) {
+    if (a.lower() == kMin && (a.upper() == kMax || b.upper() == kMax)) {
+      alwaysTrue = true;
+      return nullptr;
+    }
+
+    return std::make_unique<common::BigintRange>(
+        a.lower(), std::max(a.upper(), b.upper()), /*nullAllowed=*/false);
+  }
+  return nullptr;
+}
+
+// Returns a single range that represents "a OR b" or nullptr if no such range
+// exists.
+// @pre a.lower() <= b.lower()
+template <typename T>
+std::unique_ptr<common::FloatingPointRange<T>> tryMergeOverlappingRanges(
+    const common::FloatingPointRange<T>& a,
+    const common::FloatingPointRange<T>& b,
+    bool& alwaysTrue) {
+  if (!a.upperUnbounded() && !b.lowerUnbounded() &&
+      (a.upper() < b.lower() ||
+       (a.upper() == b.lower() && a.upperExclusive() && b.lowerExclusive()))) {
+    return nullptr;
+  }
+
+  const bool lowerUnbounded = a.lowerUnbounded() || b.lowerUnbounded();
+  const bool upperUnbounded = a.upperUnbounded() || b.upperUnbounded();
+
+  const T lower = lowerUnbounded ? std::numeric_limits<T>::lowest()
+                                 : std::min(a.lower(), b.lower());
+
+  bool lowerExclusive = lowerUnbounded;
+  if (!lowerUnbounded) {
+    if (a.lower() < b.lower()) {
+      lowerExclusive = a.lowerExclusive();
+    } else {
+      lowerExclusive = a.lowerExclusive() && b.lowerExclusive();
+    }
+  }
+
+  const T upper = upperUnbounded ? std::numeric_limits<T>::max()
+                                 : std::max(a.upper(), b.upper());
+
+  bool upperExclusive = upperUnbounded;
+  if (!upperUnbounded) {
+    if (a.upper() > b.upper()) {
+      upperExclusive = a.upperExclusive();
+    } else if (a.upper() < b.upper()) {
+      upperExclusive = b.upperExclusive();
+    } else {
+      upperExclusive = a.upperExclusive() && b.upperExclusive();
+    }
+  }
+
+  if (lowerUnbounded && upperUnbounded) {
+    alwaysTrue = true;
+    return nullptr;
+  }
+
+  return std::make_unique<common::FloatingPointRange<T>>(
+      lower,
+      lowerUnbounded,
+      lowerExclusive,
+      upper,
+      upperUnbounded,
+      upperExclusive,
+      /*nullAllowed=*/false);
+}
+
+template <typename T, typename TToMultiRange>
+std::unique_ptr<common::Filter> mergeOverlappingDisjuncts(
+    std::vector<std::unique_ptr<T>>& ranges,
+    bool nullAllowed,
+    const TToMultiRange& toMultiRange) {
+  std::vector<std::unique_ptr<T>> newRanges;
+  newRanges.emplace_back(asUniquePtr<T>(ranges.front()->clone(nullAllowed)));
+
+  for (auto i = 1; i < ranges.size(); i++) {
+    bool alwaysTrue = false;
+    if (auto merged = tryMergeOverlappingRanges(
+            *newRanges.back(), *ranges[i], alwaysTrue)) {
+      newRanges.back() = std::move(merged);
+    } else {
+      if (alwaysTrue) {
+        if (nullAllowed) {
+          return std::make_unique<common::AlwaysTrue>();
+        }
+        return isNotNull();
+      }
+      newRanges.emplace_back(std::move(ranges[i]));
+    }
+  }
+
+  if (newRanges.size() == 1) {
+    return std::move(newRanges.front());
+  }
+
+  return toMultiRange(newRanges, nullAllowed);
+}
+
+std::unique_ptr<common::Filter> tryMergeBigintRanges(
+    std::vector<std::unique_ptr<common::Filter>>& disjuncts) {
+  // Check if all filters are single-value equalities: a = 5. Convert these to
+  // an IN list.
+  if (std::all_of(disjuncts.begin(), disjuncts.end(), [](const auto& filter) {
+        return isBigintRange(filter) &&
+            filter->template as<common::BigintRange>()->isSingleValue();
+      })) {
+    std::vector<int64_t> values;
+    values.reserve(disjuncts.size());
+
+    for (auto& filter : disjuncts) {
+      values.emplace_back(filter->as<common::BigintRange>()->lower());
+    }
+
+    return common::createBigintValues(values, isNullAllowed(disjuncts));
+  }
+
+  if (!std::all_of(disjuncts.begin(), disjuncts.end(), [](const auto& filter) {
+        return isBigintRange(filter) || isBigintMultiRange(filter);
+      })) {
+    return nullptr;
+  }
+
+  const bool nullAllowed = isNullAllowed(disjuncts);
+
+  std::vector<std::unique_ptr<common::BigintRange>> ranges;
+  for (auto& filter : disjuncts) {
+    if (isBigintRange(filter)) {
+      ranges.emplace_back(asBigintRange(filter));
+    } else {
+      for (const auto& range :
+           filter->as<common::BigintMultiRange>()->ranges()) {
+        ranges.emplace_back(std::make_unique<common::BigintRange>(*range));
+      }
+    }
+  }
+
+  std::sort(ranges.begin(), ranges.end(), [](const auto& a, const auto& b) {
+    return a->lower() < b->lower();
+  });
+
+  return mergeOverlappingDisjuncts(
+      ranges, nullAllowed, [](auto& newRanges, bool nullAllowed) {
+        return std::make_unique<common::BigintMultiRange>(
+            std::move(newRanges), nullAllowed);
+      });
+}
+
+template <typename T>
+std::unique_ptr<common::Filter> tryMergeFloatingPointRanges(
+    std::vector<std::unique_ptr<common::Filter>>& disjuncts) {
+  constexpr auto filterKind = std::is_same_v<T, double>
+      ? common::FilterKind::kDoubleRange
+      : common::FilterKind::kFloatRange;
+
+  if (!std::all_of(disjuncts.begin(), disjuncts.end(), [](const auto& filter) {
+        return filter->is(filterKind);
+      })) {
+    return nullptr;
+  }
+
+  const bool nullAllowed = isNullAllowed(disjuncts);
+
+  std::vector<std::unique_ptr<common::FloatingPointRange<T>>> ranges;
+  ranges.reserve(disjuncts.size());
+  for (auto& filter : disjuncts) {
+    ranges.emplace_back(
+        asUniquePtr<common::FloatingPointRange<T>>(std::move(filter)));
+  }
+
+  std::sort(ranges.begin(), ranges.end(), [](const auto& a, const auto& b) {
+    if (a->lowerUnbounded() && b->lowerUnbounded()) {
+      return false;
+    }
+
+    if (a->lowerUnbounded()) {
+      return true;
+    }
+
+    if (b->lowerUnbounded()) {
+      return false;
+    }
+
+    return a->lower() < b->lower();
+  });
+
+  return mergeOverlappingDisjuncts(
+      ranges, nullAllowed, [](auto& newRanges, bool nullAllowed) {
+        std::vector<std::unique_ptr<common::Filter>> filters;
+        filters.reserve(newRanges.size());
+        for (auto& range : newRanges) {
+          filters.emplace_back(std::move(range));
+        }
+        return std::make_unique<common::MultiRange>(
+            std::move(filters), nullAllowed);
+      });
+}
+
+std::unique_ptr<common::Filter> tryMergeBytesValues(
+    std::vector<std::unique_ptr<common::Filter>>& disjuncts) {
+  if (!std::all_of(disjuncts.begin(), disjuncts.end(), [](const auto& filter) {
+        return isBytesValues(filter) || isSingleValueBytesRange(filter);
+      })) {
+    return nullptr;
+  }
+
+  const bool nullAllowed = isNullAllowed(disjuncts);
+
+  std::vector<std::string> values;
+  for (auto& filter : disjuncts) {
+    if (isBytesValues(filter)) {
+      const auto* bytesValues = filter->as<common::BytesValues>();
+      for (const auto& value : bytesValues->values()) {
+        values.push_back(value);
+      }
+    } else {
+      const auto* bytesRange = filter->as<common::BytesRange>();
+      values.push_back(bytesRange->lower());
+    }
+  }
+
+  return std::make_unique<common::BytesValues>(values, nullAllowed);
+}
+
+} // namespace
+
+// static
+std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeOrFilter(
+    std::vector<std::unique_ptr<common::Filter>> disjuncts) {
+  VELOX_CHECK_GE(disjuncts.size(), 2);
+
+  if (auto merged = tryMergeBigintRanges(disjuncts)) {
+    return merged;
+  }
+
+  if (auto merged = tryMergeFloatingPointRanges<double>(disjuncts)) {
+    return merged;
+  }
+
+  if (auto merged = tryMergeFloatingPointRanges<float>(disjuncts)) {
+    return merged;
+  }
+
+  if (auto merged = tryMergeBytesValues(disjuncts)) {
+    return merged;
+  }
+
+  return nullptr;
+}
+
+namespace {
+std::optional<std::pair<common::Subfield, std::unique_ptr<common::Filter>>>
+combine(common::Subfield& subfield, std::unique_ptr<common::Filter>& filter) {
+  if (filter != nullptr) {
+    return std::make_pair(std::move(subfield), std::move(filter));
+  }
+
+  return std::nullopt;
+}
+} // namespace
+
+std::optional<std::pair<common::Subfield, std::unique_ptr<common::Filter>>>
 PrestoExprToSubfieldFilterParser::leafCallToSubfieldFilter(
     const core::CallTypedExpr& call,
-    common::Subfield& subfield,
     core::ExpressionEvaluator* evaluator,
     bool negated) {
   if (call.inputs().empty()) {
-    return nullptr;
+    return std::nullopt;
   }
 
   const auto* leftSide = call.inputs()[0].get();
 
+  common::Subfield subfield;
   if (call.name() == "eq") {
     if (toSubfield(leftSide, subfield)) {
-      return negated ? makeNotEqualFilter(call.inputs()[1], evaluator)
-                     : makeEqualFilter(call.inputs()[1], evaluator);
+      auto filter = negated ? makeNotEqualFilter(call.inputs()[1], evaluator)
+                            : makeEqualFilter(call.inputs()[1], evaluator);
+
+      return combine(subfield, filter);
     }
   } else if (call.name() == "neq") {
     if (toSubfield(leftSide, subfield)) {
-      return negated ? makeEqualFilter(call.inputs()[1], evaluator)
-                     : makeNotEqualFilter(call.inputs()[1], evaluator);
+      auto filter = negated ? makeEqualFilter(call.inputs()[1], evaluator)
+                            : makeNotEqualFilter(call.inputs()[1], evaluator);
+      return combine(subfield, filter);
     }
   } else if (call.name() == "lte") {
     if (toSubfield(leftSide, subfield)) {
-      return negated ? makeGreaterThanFilter(call.inputs()[1], evaluator)
-                     : makeLessThanOrEqualFilter(call.inputs()[1], evaluator);
+      auto filter = negated
+          ? makeGreaterThanFilter(call.inputs()[1], evaluator)
+          : makeLessThanOrEqualFilter(call.inputs()[1], evaluator);
+      return combine(subfield, filter);
     }
   } else if (call.name() == "lt") {
     if (toSubfield(leftSide, subfield)) {
-      return negated ? makeGreaterThanOrEqualFilter(call.inputs()[1], evaluator)
-                     : makeLessThanFilter(call.inputs()[1], evaluator);
+      auto filter = negated
+          ? makeGreaterThanOrEqualFilter(call.inputs()[1], evaluator)
+          : makeLessThanFilter(call.inputs()[1], evaluator);
+      return combine(subfield, filter);
     }
   } else if (call.name() == "gte") {
     if (toSubfield(leftSide, subfield)) {
-      return negated
+      auto filter = negated
           ? makeLessThanFilter(call.inputs()[1], evaluator)
           : makeGreaterThanOrEqualFilter(call.inputs()[1], evaluator);
+      return combine(subfield, filter);
     }
   } else if (call.name() == "gt") {
     if (toSubfield(leftSide, subfield)) {
-      return negated ? makeLessThanOrEqualFilter(call.inputs()[1], evaluator)
-                     : makeGreaterThanFilter(call.inputs()[1], evaluator);
+      auto filter = negated
+          ? makeLessThanOrEqualFilter(call.inputs()[1], evaluator)
+          : makeGreaterThanFilter(call.inputs()[1], evaluator);
+      return combine(subfield, filter);
     }
   } else if (call.name() == "between") {
     if (toSubfield(leftSide, subfield)) {
-      return makeBetweenFilter(
+      auto filter = makeBetweenFilter(
           call.inputs()[1], call.inputs()[2], evaluator, negated);
+      return combine(subfield, filter);
     }
   } else if (call.name() == "in") {
     if (toSubfield(leftSide, subfield)) {
-      return makeInFilter(call.inputs()[1], evaluator, negated);
+      auto filter = makeInFilter(call.inputs()[1], evaluator, negated);
+      return combine(subfield, filter);
     }
   } else if (call.name() == "is_null") {
     if (toSubfield(leftSide, subfield)) {
       if (negated) {
-        return isNotNull();
+        return std::make_pair(std::move(subfield), isNotNull());
       }
-      return isNull();
-    }
-  }
-  return nullptr;
-}
-
-std::pair<common::Subfield, std::unique_ptr<common::Filter>> toSubfieldFilter(
-    const core::TypedExprPtr& expr,
-    core::ExpressionEvaluator* evaluator) {
-  if (auto call = asCall(expr.get())) {
-    if (call->name() == "or") {
-      auto left = toSubfieldFilter(call->inputs()[0], evaluator);
-      auto right = toSubfieldFilter(call->inputs()[1], evaluator);
-      VELOX_CHECK(left.first == right.first);
-      return {
-          std::move(left.first),
-          makeOrFilter(std::move(left.second), std::move(right.second))};
-    }
-    common::Subfield subfield;
-    std::unique_ptr<common::Filter> filter;
-    if (call->name() == "not") {
-      if (auto* inner = asCall(call->inputs()[0].get())) {
-        filter =
-            ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-                *inner, subfield, evaluator, true);
-      }
-    } else {
-      filter =
-          ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-              *call, subfield, evaluator, false);
-    }
-    if (filter) {
-      return std::make_pair(std::move(subfield), std::move(filter));
+      return std::make_pair(std::move(subfield), isNull());
     }
   }
-  VELOX_UNSUPPORTED(
-      "Unsupported expression for range filter: {}", expr->toString());
+  return std::nullopt;
 }
 
 } // namespace facebook::velox::exec
diff --git a/velox/expression/ExprToSubfieldFilter.h b/velox/expression/ExprToSubfieldFilter.h
index 12ea9b4c263..9dd7eb98c29 100644
--- a/velox/expression/ExprToSubfieldFilter.h
+++ b/velox/expression/ExprToSubfieldFilter.h
@@ -23,9 +23,15 @@
 
 namespace facebook::velox::exec {
 
-inline std::unique_ptr<common::BigintRange> lessThan(
+inline std::unique_ptr<common::Filter> lessThan(
     int64_t max,
     bool nullAllowed = false) {
+  if (max == std::numeric_limits<int64_t>::min()) {
+    if (nullAllowed) {
+      return std::make_unique<common::IsNull>();
+    }
+    return std::make_unique<common::AlwaysFalse>();
+  }
   return std::make_unique<common::BigintRange>(
       std::numeric_limits<int64_t>::min(), max - 1, nullAllowed);
 }
@@ -37,9 +43,15 @@ inline std::unique_ptr<common::BigintRange> lessThanOrEqual(
       std::numeric_limits<int64_t>::min(), max, nullAllowed);
 }
 
-inline std::unique_ptr<common::BigintRange> greaterThan(
+inline std::unique_ptr<common::Filter> greaterThan(
     int64_t min,
     bool nullAllowed = false) {
+  if (min == std::numeric_limits<int64_t>::max()) {
+    if (nullAllowed) {
+      return std::make_unique<common::IsNull>();
+    }
+    return std::make_unique<common::AlwaysFalse>();
+  }
   return std::make_unique<common::BigintRange>(
       min + 1, std::numeric_limits<int64_t>::max(), nullAllowed);
 }
@@ -52,9 +64,10 @@ inline std::unique_ptr<common::BigintRange> greaterThanOrEqual(
 }
 
 inline std::unique_ptr<common::NegatedBigintRange> notEqual(
-    int64_t val,
+    int64_t value,
     bool nullAllowed = false) {
-  return std::make_unique<common::NegatedBigintRange>(val, val, nullAllowed);
+  return std::make_unique<common::NegatedBigintRange>(
+      value, value, nullAllowed);
 }
 
 inline std::unique_ptr<common::NegatedBigintRange>
@@ -184,29 +197,16 @@ between(int64_t min, int64_t max, bool nullAllowed = false) {
   return std::make_unique<common::BigintRange>(min, max, nullAllowed);
 }
 
-inline std::unique_ptr<common::BigintMultiRange> bigintOr(
-    std::unique_ptr<common::BigintRange> a,
-    std::unique_ptr<common::BigintRange> b,
-    bool nullAllowed = false) {
-  std::vector<std::unique_ptr<common::BigintRange>> filters;
-  filters.emplace_back(std::move(a));
-  filters.emplace_back(std::move(b));
-  return std::make_unique<common::BigintMultiRange>(
-      std::move(filters), nullAllowed);
-}
+std::unique_ptr<common::Filter> bigintOr(
+    std::unique_ptr<common::Filter> a,
+    std::unique_ptr<common::Filter> b,
+    bool nullAllowed = false);
 
-inline std::unique_ptr<common::BigintMultiRange> bigintOr(
-    std::unique_ptr<common::BigintRange> a,
-    std::unique_ptr<common::BigintRange> b,
-    std::unique_ptr<common::BigintRange> c,
-    bool nullAllowed = false) {
-  std::vector<std::unique_ptr<common::BigintRange>> filters;
-  filters.emplace_back(std::move(a));
-  filters.emplace_back(std::move(b));
-  filters.emplace_back(std::move(c));
-  return std::make_unique<common::BigintMultiRange>(
-      std::move(filters), nullAllowed);
-}
+std::unique_ptr<common::Filter> bigintOr(
+    std::unique_ptr<common::Filter> a,
+    std::unique_ptr<common::Filter> b,
+    std::unique_ptr<common::Filter> c,
+    bool nullAllowed = false);
 
 inline std::unique_ptr<common::BytesValues> equal(
     const std::string& value,
@@ -221,64 +221,58 @@ inline std::unique_ptr<common::BigintRange> equal(
   return std::make_unique<common::BigintRange>(value, value, nullAllowed);
 }
 
-inline std::unique_ptr<common::BytesRange> between(
-    const std::string& min,
-    const std::string& max,
-    bool nullAllowed = false) {
+inline std::unique_ptr<common::BytesRange>
+between(std::string min, std::string max, bool nullAllowed = false) {
   return std::make_unique<common::BytesRange>(
-      min, false, false, max, false, false, nullAllowed);
+      std::move(min), false, false, std::move(max), false, false, nullAllowed);
 }
 
-inline std::unique_ptr<common::BytesRange> betweenExclusive(
-    const std::string& min,
-    const std::string& max,
-    bool nullAllowed = false) {
+inline std::unique_ptr<common::BytesRange>
+betweenExclusive(std::string min, std::string max, bool nullAllowed = false) {
   return std::make_unique<common::BytesRange>(
-      min, false, true, max, false, true, nullAllowed);
+      std::move(min), false, true, std::move(max), false, true, nullAllowed);
 }
 
-inline std::unique_ptr<common::NegatedBytesRange> notBetween(
-    const std::string& min,
-    const std::string& max,
-    bool nullAllowed = false) {
+inline std::unique_ptr<common::NegatedBytesRange>
+notBetween(std::string min, std::string max, bool nullAllowed = false) {
   return std::make_unique<common::NegatedBytesRange>(
-      min, false, false, max, false, false, nullAllowed);
+      std::move(min), false, false, std::move(max), false, false, nullAllowed);
 }
 
 inline std::unique_ptr<common::NegatedBytesRange> notBetweenExclusive(
-    const std::string& min,
-    const std::string& max,
+    std::string min,
+    std::string max,
     bool nullAllowed = false) {
   return std::make_unique<common::NegatedBytesRange>(
-      min, false, true, max, false, true, nullAllowed);
+      std::move(min), false, true, std::move(max), false, true, nullAllowed);
 }
 
 inline std::unique_ptr<common::BytesRange> lessThanOrEqual(
-    const std::string& max,
+    std::string max,
     bool nullAllowed = false) {
   return std::make_unique<common::BytesRange>(
-      "", true, false, max, false, false, nullAllowed);
+      "", true, false, std::move(max), false, false, nullAllowed);
 }
 
 inline std::unique_ptr<common::BytesRange> lessThan(
-    const std::string& max,
+    std::string max,
     bool nullAllowed = false) {
   return std::make_unique<common::BytesRange>(
-      "", true, false, max, false, true, nullAllowed);
+      "", true, false, std::move(max), false, true, nullAllowed);
 }
 
 inline std::unique_ptr<common::BytesRange> greaterThanOrEqual(
-    const std::string& min,
+    std::string min,
     bool nullAllowed = false) {
   return std::make_unique<common::BytesRange>(
-      min, false, false, "", true, false, nullAllowed);
+      std::move(min), false, false, "", true, false, nullAllowed);
 }
 
 inline std::unique_ptr<common::BytesRange> greaterThan(
-    const std::string& min,
+    std::string min,
     bool nullAllowed = false) {
   return std::make_unique<common::BytesRange>(
-      min, false, true, "", true, false, nullAllowed);
+      std::move(min), false, true, "", true, false, nullAllowed);
 }
 
 inline std::unique_ptr<common::Filter> in(
@@ -287,24 +281,48 @@ inline std::unique_ptr<common::Filter> in(
   return common::createBigintValues(values, nullAllowed);
 }
 
+inline std::unique_ptr<common::Filter> in(
+    std::initializer_list<int64_t> values,
+    bool nullAllowed = false) {
+  return in(std::vector<int64_t>(values), nullAllowed);
+}
+
 inline std::unique_ptr<common::Filter> notIn(
     const std::vector<int64_t>& values,
     bool nullAllowed = false) {
   return common::createNegatedBigintValues(values, nullAllowed);
 }
 
+inline std::unique_ptr<common::Filter> notIn(
+    std::initializer_list<int64_t> values,
+    bool nullAllowed = false) {
+  return notIn(std::vector<int64_t>(values), nullAllowed);
+}
+
 inline std::unique_ptr<common::BytesValues> in(
     const std::vector<std::string>& values,
     bool nullAllowed = false) {
   return std::make_unique<common::BytesValues>(values, nullAllowed);
 }
 
+inline std::unique_ptr<common::BytesValues> in(
+    std::initializer_list<std::string> values,
+    bool nullAllowed = false) {
+  return in(std::vector<std::string>(values), nullAllowed);
+}
+
 inline std::unique_ptr<common::NegatedBytesValues> notIn(
     const std::vector<std::string>& values,
     bool nullAllowed = false) {
   return std::make_unique<common::NegatedBytesValues>(values, nullAllowed);
 }
 
+inline std::unique_ptr<common::NegatedBytesValues> notIn(
+    std::initializer_list<std::string> values,
+    bool nullAllowed = false) {
+  return notIn(std::vector<std::string>(values), nullAllowed);
+}
+
 inline std::unique_ptr<common::BoolValue> boolEqual(
     bool value,
     bool nullAllowed = false) {
@@ -319,6 +337,10 @@ inline std::unique_ptr<common::IsNotNull> isNotNull() {
   return std::make_unique<common::IsNotNull>();
 }
 
+inline std::unique_ptr<common::AlwaysTrue> alwaysTrue() {
+  return std::make_unique<common::AlwaysTrue>();
+}
+
 template <typename T>
 std::unique_ptr<common::MultiRange>
 orFilter(std::unique_ptr<T> a, std::unique_ptr<T> b, bool nullAllowed = false) {
@@ -328,9 +350,15 @@ orFilter(std::unique_ptr<T> a, std::unique_ptr<T> b, bool nullAllowed = false) {
   return std::make_unique<common::MultiRange>(std::move(filters), nullAllowed);
 }
 
-inline std::unique_ptr<common::HugeintRange> lessThanHugeint(
+inline std::unique_ptr<common::Filter> lessThanHugeint(
     int128_t max,
     bool nullAllowed = false) {
+  if (max == std::numeric_limits<int128_t>::min()) {
+    if (nullAllowed) {
+      return std::make_unique<common::IsNull>();
+    }
+    return std::make_unique<common::AlwaysFalse>();
+  }
   return std::make_unique<common::HugeintRange>(
       std::numeric_limits<int128_t>::min(), max - 1, nullAllowed);
 }
@@ -342,9 +370,15 @@ inline std::unique_ptr<common::HugeintRange> lessThanOrEqualHugeint(
       std::numeric_limits<int128_t>::min(), max, nullAllowed);
 }
 
-inline std::unique_ptr<common::HugeintRange> greaterThanHugeint(
+inline std::unique_ptr<common::Filter> greaterThanHugeint(
     int128_t min,
     bool nullAllowed = false) {
+  if (min == std::numeric_limits<int128_t>::max()) {
+    if (nullAllowed) {
+      return std::make_unique<common::IsNull>();
+    }
+    return std::make_unique<common::AlwaysFalse>();
+  }
   return std::make_unique<common::HugeintRange>(
       min + 1, std::numeric_limits<int128_t>::max(), nullAllowed);
 }
@@ -367,10 +401,6 @@ betweenHugeint(int128_t min, int128_t max, bool nullAllowed = false) {
   return std::make_unique<common::HugeintRange>(min, max, nullAllowed);
 }
 
-std::pair<common::Subfield, std::unique_ptr<common::Filter>> toSubfieldFilter(
-    const core::TypedExprPtr& expr,
-    core::ExpressionEvaluator*);
-
 inline std::unique_ptr<common::TimestampRange> equal(
     const Timestamp& value,
     bool nullAllowed = false) {
@@ -382,9 +412,15 @@ between(const Timestamp& min, const Timestamp& max, bool nullAllowed = false) {
   return std::make_unique<common::TimestampRange>(min, max, nullAllowed);
 }
 
-inline std::unique_ptr<common::TimestampRange> lessThan(
+inline std::unique_ptr<common::Filter> lessThan(
     Timestamp max,
     bool nullAllowed = false) {
+  if (max == std::numeric_limits<Timestamp>::min()) {
+    if (nullAllowed) {
+      return std::make_unique<common::IsNull>();
+    }
+    return std::make_unique<common::AlwaysFalse>();
+  }
   --max;
   return std::make_unique<common::TimestampRange>(
       std::numeric_limits<Timestamp>::min(), max, nullAllowed);
@@ -397,9 +433,15 @@ inline std::unique_ptr<common::TimestampRange> lessThanOrEqual(
       std::numeric_limits<Timestamp>::min(), max, nullAllowed);
 }
 
-inline std::unique_ptr<common::TimestampRange> greaterThan(
+inline std::unique_ptr<common::Filter> greaterThan(
     Timestamp min,
     bool nullAllowed = false) {
+  if (min == std::numeric_limits<Timestamp>::max()) {
+    if (nullAllowed) {
+      return std::make_unique<common::IsNull>();
+    }
+    return std::make_unique<common::AlwaysFalse>();
+  }
   ++min;
   return std::make_unique<common::TimestampRange>(
       min, std::numeric_limits<Timestamp>::max(), nullAllowed);
@@ -412,96 +454,119 @@ inline std::unique_ptr<common::TimestampRange> greaterThanOrEqual(
       min, std::numeric_limits<Timestamp>::max(), nullAllowed);
 }
 
-/// Provides the instance and helper functions to convert a leaf call
-/// expression to subfield filter. Allows the registration of custom parser.
+/// Language-specific translator of generic expressions into subfield filters.
+/// Default language is Presto. A different language can be supported by
+/// registering language-specific implementation using 'registerParser' API.
 class ExprToSubfieldFilterParser {
  public:
   virtual ~ExprToSubfieldFilterParser() = default;
 
-  static std::shared_ptr<ExprToSubfieldFilterParser> getInstance() {
-    return parserFactory_();
+  /// Returns a parser provided to an earlier 'registerParser' call. Not thread
+  /// safe.
+  static const std::shared_ptr<ExprToSubfieldFilterParser>& getInstance() {
+    VELOX_CHECK_NOT_NULL(parser_, "Parser is not registered");
+    return parser_;
   }
 
-  /// Registers a custom parser factory. The factory is called to create a
-  /// parser instance.
-  static void registerParserFactory(
-      std::function<std::shared_ptr<ExprToSubfieldFilterParser>()>
-          parserFactory) {
-    parserFactory_ = std::move(parserFactory);
+  /// Registers a parser. Silently overwrites previously registered parser if
+  /// any. Not thread safe.
+  static void registerParser(
+      std::shared_ptr<ExprToSubfieldFilterParser> parser) {
+    VELOX_CHECK_NOT_NULL(parser);
+    parser_ = std::move(parser);
   }
 
-  /// Converts a leaf call expression (no conjunction like AND/OR) to subfield
-  /// and filter. Return nullptr if not supported for pushdown. This is needed
-  /// because this conversion is frequently applied when extracting filters from
-  /// remaining filter in readers. Frequent throw clutters logs and slows down
-  /// execution.
-  virtual std::unique_ptr<common::Filter> leafCallToSubfieldFilter(
+  /// Analyzes 'call' expression to determine if it can be expressed as a
+  /// subfield filter. Returns the subfield and filter if so. Otherwise, returns
+  /// std::nullopt. If 'negated' is true, considers the negation of 'call'
+  /// expressions (not(call)). It is possible that 'call' expression can be
+  /// represented as subfield filter, but its negation cannot.
+  virtual std::optional<
+      std::pair<common::Subfield, std::unique_ptr<common::Filter>>>
+  leafCallToSubfieldFilter(
       const core::CallTypedExpr& call,
-      common::Subfield& subfield,
       core::ExpressionEvaluator* evaluator,
       bool negated = false) = 0;
 
+  /// Combines 2 or more filters with an OR.
+  /// Detects overlapping ranges of bigint and floating point values.
+  /// Detects a list of single-value bigint filters and combines them into a
+  /// single IN list.
+  /// Returns nullptr if no combination has been made.
+  static std::unique_ptr<common::Filter> makeOrFilter(
+      std::vector<std::unique_ptr<common::Filter>> disjuncts);
+
+  template <typename... Disjuncts>
+  static std::unique_ptr<common::Filter> makeOrFilter(
+      Disjuncts&&... disjuncts) {
+    std::vector<std::unique_ptr<common::Filter>> filters;
+    filters.reserve(sizeof...(Disjuncts));
+    (filters.emplace_back(std::forward<Disjuncts>(disjuncts)), ...);
+    return makeOrFilter(std::move(filters));
+  }
+
  protected:
-  // Converts an expression into a subfield. Returns false if the expression is
-  // not a valid field expression.
-  bool toSubfield(const core::ITypedExpr* field, common::Subfield& subfield);
+  // Converts an expression into a subfield. Returns false if the expression
+  // is not a valid field expression.
+  static bool toSubfield(
+      const core::ITypedExpr* field,
+      common::Subfield& subfield);
 
   // Creates a non-equal subfield filter against the given constant.
-  std::unique_ptr<common::Filter> makeNotEqualFilter(
+  static std::unique_ptr<common::Filter> makeNotEqualFilter(
       const core::TypedExprPtr& valueExpr,
       core::ExpressionEvaluator* evaluator);
 
   // Creates an equal subfield filter against the given constant.
-  std::unique_ptr<common::Filter> makeEqualFilter(
+  static std::unique_ptr<common::Filter> makeEqualFilter(
       const core::TypedExprPtr& valueExpr,
       core::ExpressionEvaluator* evaluator);
 
   // Creates a greater-than subfield filter against the given constant.
-  std::unique_ptr<common::Filter> makeGreaterThanFilter(
+  static std::unique_ptr<common::Filter> makeGreaterThanFilter(
       const core::TypedExprPtr& lowerExpr,
       core::ExpressionEvaluator* evaluator);
 
   // Creates a less-than subfield filter against the given constant.
-  std::unique_ptr<common::Filter> makeLessThanFilter(
+  static std::unique_ptr<common::Filter> makeLessThanFilter(
       const core::TypedExprPtr& upperExpr,
       core::ExpressionEvaluator* evaluator);
 
   // Creates a less-than-or-equal subfield filter against the given constant.
-  std::unique_ptr<common::Filter> makeLessThanOrEqualFilter(
+  static std::unique_ptr<common::Filter> makeLessThanOrEqualFilter(
       const core::TypedExprPtr& upperExpr,
       core::ExpressionEvaluator* evaluator);
 
   // Creates a greater-than-or-equal subfield filter against the given constant.
-  std::unique_ptr<common::Filter> makeGreaterThanOrEqualFilter(
+  static std::unique_ptr<common::Filter> makeGreaterThanOrEqualFilter(
       const core::TypedExprPtr& lowerExpr,
       core::ExpressionEvaluator* evaluator);
 
   // Creates an in subfield filter against the given vector.
-  std::unique_ptr<common::Filter> makeInFilter(
+  static std::unique_ptr<common::Filter> makeInFilter(
       const core::TypedExprPtr& expr,
       core::ExpressionEvaluator* evaluator,
       bool negated);
 
   // Creates a between subfield filter against the given lower and upper
   // bounds.
-  std::unique_ptr<common::Filter> makeBetweenFilter(
+  static std::unique_ptr<common::Filter> makeBetweenFilter(
       const core::TypedExprPtr& lowerExpr,
       const core::TypedExprPtr& upperExpr,
       core::ExpressionEvaluator* evaluator,
       bool negated);
 
  private:
-  // Factory method to create a parser instance.
-  static std::function<std::shared_ptr<ExprToSubfieldFilterParser>()>
-      parserFactory_;
+  // Singleton parser instance.
+  static std::shared_ptr<ExprToSubfieldFilterParser> parser_;
 };
 
 // Parser for Presto expressions.
 class PrestoExprToSubfieldFilterParser : public ExprToSubfieldFilterParser {
  public:
-  std::unique_ptr<common::Filter> leafCallToSubfieldFilter(
+  std::optional<std::pair<common::Subfield, std::unique_ptr<common::Filter>>>
+  leafCallToSubfieldFilter(
       const core::CallTypedExpr& call,
-      common::Subfield& subfield,
       core::ExpressionEvaluator* evaluator,
       bool negated = false) override;
 };
diff --git a/velox/expression/FunctionCallToSpecialForm.cpp b/velox/expression/FunctionCallToSpecialForm.cpp
index 86135ba134e..cbf1a25cd25 100644
--- a/velox/expression/FunctionCallToSpecialForm.cpp
+++ b/velox/expression/FunctionCallToSpecialForm.cpp
@@ -31,6 +31,19 @@ TypePtr resolveTypeForSpecialForm(
   return specialForm->resolveType(argTypes);
 }
 
+TypePtr resolveTypeForSpecialFormWithCoercions(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer) {
+  auto specialForm = specialFormRegistry().getSpecialForm(functionName);
+  if (specialForm == nullptr) {
+    return nullptr;
+  }
+
+  return specialForm->resolveTypeWithCoercions(argTypes, coercions, coercer);
+}
+
 ExprPtr constructSpecialForm(
     const std::string& functionName,
     const TypePtr& type,
diff --git a/velox/expression/FunctionCallToSpecialForm.h b/velox/expression/FunctionCallToSpecialForm.h
index 5f6b0db8e92..39c5838316e 100644
--- a/velox/expression/FunctionCallToSpecialForm.h
+++ b/velox/expression/FunctionCallToSpecialForm.h
@@ -18,6 +18,7 @@
 
 #include "velox/expression/Expr.h"
 #include "velox/type/Type.h"
+#include "velox/type/TypeCoercer.h"
 
 namespace facebook::velox::exec {
 class FunctionCallToSpecialForm {
@@ -30,6 +31,18 @@ class FunctionCallToSpecialForm {
   /// arguments, e.g. Try.
   virtual TypePtr resolveType(const std::vector<TypePtr>& argTypes) = 0;
 
+  /// Like 'resolveType', but with support for applying type conversions if a
+  /// special form signature doesn't match 'argTypes' exactly. Support varies
+  /// from special form to special form. By default, no coersions are attempted.
+  virtual TypePtr resolveTypeWithCoercions(
+      const std::vector<TypePtr>& argTypes,
+      [[maybe_unused]] std::vector<TypePtr>& coercions,
+      [[maybe_unused]] const TypeCoercer& coercer) {
+    coercions.clear();
+    coercions.resize(argTypes.size());
+    return resolveType(argTypes);
+  }
+
   /// Given the output Type, the child expresssions, and whether or not to track
   /// CPU usage, returns the SpecialForm.
   virtual ExprPtr constructSpecialForm(
@@ -47,6 +60,12 @@ TypePtr resolveTypeForSpecialForm(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes);
 
+TypePtr resolveTypeForSpecialFormWithCoercions(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer);
+
 /// Returns the SpeicalForm associated with the functionName.  If functionName
 /// is not the name of a known SpecialForm, returns nulltpr.
 ExprPtr constructSpecialForm(
diff --git a/velox/expression/FunctionMetadata.h b/velox/expression/FunctionMetadata.h
index d8d743f9b2f..6c26e63c386 100644
--- a/velox/expression/FunctionMetadata.h
+++ b/velox/expression/FunctionMetadata.h
@@ -15,6 +15,8 @@
  */
 #pragma once
 
+#include <string_view>
+
 namespace facebook::velox::exec {
 
 struct VectorFunctionMetadata {
@@ -43,6 +45,10 @@ struct VectorFunctionMetadata {
 
   /// Indicates if this is a companion function.
   bool companionFunction{false};
+
+  /// The owner/team responsible for this function. Used for logging and
+  /// attribution.
+  std::string_view owner{""};
 };
 
 class VectorFunctionMetadataBuilder {
@@ -67,6 +73,11 @@ class VectorFunctionMetadataBuilder {
     return *this;
   }
 
+  VectorFunctionMetadataBuilder& owner(std::string_view owner) {
+    metadata_.owner = owner;
+    return *this;
+  }
+
   const VectorFunctionMetadata& build() const {
     return metadata_;
   }
diff --git a/velox/expression/FunctionSignature.cpp b/velox/expression/FunctionSignature.cpp
index ff223cdabbc..0db906d4ef7 100644
--- a/velox/expression/FunctionSignature.cpp
+++ b/velox/expression/FunctionSignature.cpp
@@ -22,7 +22,7 @@
 
 namespace facebook::velox::exec {
 
-std::string sanitizeName(const std::string& name) {
+std::string sanitizeName(std::string_view name) {
   std::string sanitizedName;
   sanitizedName.resize(name.size());
   std::transform(
@@ -106,6 +106,12 @@ void validateBaseTypeAndCollectTypeParams(
     const TypeSignature& arg,
     std::unordered_set<std::string>& collectedTypeVariables,
     bool isReturnType) {
+  if (isReturnType) {
+    VELOX_USER_CHECK(
+        !arg.isHomogeneousRow(),
+        "Homogeneous row cannot appear in return type");
+  }
+
   if (!variables.count(arg.baseName())) {
     auto typeName = boost::algorithm::to_upper_copy(arg.baseName());
 
@@ -146,18 +152,26 @@ void validate(
     const TypeSignature& returnType,
     const std::vector<TypeSignature>& argumentTypes,
     const std::vector<bool>& constantArguments,
+    bool variableArity,
     const std::vector<TypeSignature>& additionalTypes = {}) {
   std::unordered_set<std::string> usedVariables;
   // Validate the additional types, and collect the used variables.
   for (const auto& type : additionalTypes) {
     validateBaseTypeAndCollectTypeParams(variables, type, usedVariables, false);
   }
+
   // Validate the argument types.
   for (const auto& arg : argumentTypes) {
     // Is base type a type parameter or a built in type ?
     validateBaseTypeAndCollectTypeParams(variables, arg, usedVariables, false);
   }
 
+  if (variableArity) {
+    VELOX_USER_CHECK(
+        !argumentTypes.empty(),
+        "Variable arity requires at least one argument");
+  }
+
   // All type variables should apear in the inputs arguments.
   for (auto& [name, variable] : variables) {
     if (variable.isTypeParameter()) {
@@ -207,6 +221,26 @@ SignatureVariable::SignatureVariable(
       "Type variables cannot have constraints");
 }
 
+bool SignatureVariable::isEligibleType(const Type& type) const {
+  if (!isTypeParameter()) {
+    return false;
+  }
+
+  if (knownTypesOnly_ && type.isUnknown()) {
+    return false;
+  }
+
+  if (orderableTypesOnly_ && !type.isOrderable()) {
+    return false;
+  }
+
+  if (comparableTypesOnly_ && !type.isComparable()) {
+    return false;
+  }
+
+  return true;
+}
+
 FunctionSignature::FunctionSignature(
     std::unordered_map<std::string, SignatureVariable> variables,
     TypeSignature returnType,
@@ -218,7 +252,12 @@ FunctionSignature::FunctionSignature(
       argumentTypes_{std::move(argumentTypes)},
       constantArguments_{std::move(constantArguments)},
       variableArity_{variableArity} {
-  validate(variables_, returnType_, argumentTypes_, constantArguments_);
+  validate(
+      variables_,
+      returnType_,
+      argumentTypes_,
+      constantArguments_,
+      variableArity_);
 }
 
 FunctionSignature::FunctionSignature(
@@ -238,6 +277,7 @@ FunctionSignature::FunctionSignature(
       returnType_,
       argumentTypes_,
       constantArguments_,
+      variableArity_,
       additionalTypes);
 }
 
diff --git a/velox/expression/FunctionSignature.h b/velox/expression/FunctionSignature.h
index 68c3e1b9a6e..250a20167d6 100644
--- a/velox/expression/FunctionSignature.h
+++ b/velox/expression/FunctionSignature.h
@@ -19,6 +19,7 @@
 #include <memory>
 #include <optional>
 #include <string>
+#include <string_view>
 #include <unordered_map>
 #include <vector>
 
@@ -29,7 +30,7 @@
 
 namespace facebook::velox::exec {
 
-std::string sanitizeName(const std::string& name);
+std::string sanitizeName(std::string_view name);
 
 /// Return a list of primitive type names.
 const std::vector<std::string> primitiveTypeNames();
@@ -53,7 +54,7 @@ enum class FunctionCanonicalName {
 /// a_precision + b_precision" in decimals).
 class SignatureVariable {
  public:
-  explicit SignatureVariable(
+  SignatureVariable(
       std::string name,
       std::optional<std::string> constraint,
       ParameterType type,
@@ -84,6 +85,10 @@ class SignatureVariable {
     return comparableTypesOnly_;
   }
 
+  /// Return true if this variable describes a type and the specified type
+  /// satisfies the constraints.
+  bool isEligibleType(const Type& type) const;
+
   bool isTypeParameter() const {
     return type_ == ParameterType::kTypeParameter;
   }
@@ -332,21 +337,22 @@ class FunctionSignatureBuilder {
   }
 
   FunctionSignatureBuilder& argumentType(const std::string& type) {
-    argumentTypes_.emplace_back(parseTypeSignature(type));
-    constantArguments_.push_back(false);
-    return *this;
+    return addArgument(type, /*constant=*/false, /*variableArity=*/false);
   }
 
   FunctionSignatureBuilder& constantArgumentType(const std::string& type) {
-    argumentTypes_.emplace_back(parseTypeSignature(type));
-    constantArguments_.push_back(true);
-    return *this;
+    return addArgument(type, /*constant=*/true, /*variableArity=*/false);
   }
 
   /// Variable arity arguments can appear only at the end of the argument list
   /// and their types must match the type specified in the last entry of
   /// 'argumentTypes'. Variable arity arguments can appear zero or more times.
   FunctionSignatureBuilder& variableArity() {
+    VELOX_USER_CHECK(
+        !variableArity_, "Only one variable arity argument is allowed.");
+    VELOX_USER_CHECK(
+        !argumentTypes_.empty(),
+        "Variable arity requires at least one argument");
     variableArity_ = true;
     return *this;
   }
@@ -354,24 +360,33 @@ class FunctionSignatureBuilder {
   /// Variable arity arguments can appear only at the end of the argument list
   /// and can appear zero or more times.
   FunctionSignatureBuilder& variableArity(const std::string& type) {
-    argumentTypes_.emplace_back(parseTypeSignature(type));
-    constantArguments_.push_back(false);
-    variableArity_ = true;
-    return *this;
+    return addArgument(type, /*constant=*/false, /*variableArity=*/true);
   }
 
   /// Variable arity arguments can appear only at the end of the argument list
   /// and can appear zero or more times.
   FunctionSignatureBuilder& constantVariableArity(const std::string& type) {
-    argumentTypes_.emplace_back(parseTypeSignature(type));
-    constantArguments_.push_back(true);
-    variableArity_ = true;
-    return *this;
+    return addArgument(type, /*constant=*/true, /*variableArity=*/true);
   }
 
   FunctionSignaturePtr build();
 
  private:
+  FunctionSignatureBuilder&
+  addArgument(const std::string& type, bool constant, bool variableArity) {
+    VELOX_USER_CHECK(
+        !variableArity_, "Cannot add arguments after variable arity argument");
+
+    argumentTypes_.emplace_back(parseTypeSignature(type));
+    constantArguments_.push_back(constant);
+
+    if (variableArity) {
+      this->variableArity();
+    }
+
+    return *this;
+  }
+
   std::unordered_map<std::string, SignatureVariable> variables_;
   std::optional<TypeSignature> returnType_;
   std::vector<TypeSignature> argumentTypes_;
diff --git a/velox/expression/NullIfExpr.cpp b/velox/expression/NullIfExpr.cpp
new file mode 100644
index 00000000000..c259a5b480f
--- /dev/null
+++ b/velox/expression/NullIfExpr.cpp
@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/expression/NullIfExpr.h"
+#include "velox/expression/ExprConstants.h"
+
+namespace facebook::velox::exec {
+
+NullIfExpr::NullIfExpr(
+    std::vector<ExprPtr>&& inputs,
+    std::shared_ptr<CastExpr> castExpr,
+    bool trackCpuUsage)
+    : SpecialForm(
+          SpecialFormKind::kNullIf,
+          inputs[0]->type(),
+          inputs,
+          expression::kNullIf,
+          /*supportsFlatNoNullsFastPath=*/false,
+          trackCpuUsage),
+      castExpr_(std::move(castExpr)),
+      needsCastA_(
+          castExpr_ && !inputs_[0]->type()->equivalent(*castExpr_->type())),
+      needsCastB_(
+          castExpr_ && !inputs_[1]->type()->equivalent(*castExpr_->type())) {
+  VELOX_CHECK_EQ(inputs_.size(), 2, "NULLIF requires exactly 2 inputs");
+  if (castExpr_ == nullptr) {
+    const auto& a = inputs_[0]->type();
+    const auto& b = inputs_[1]->type();
+    VELOX_CHECK(
+        a->equivalent(*b),
+        "NULLIF inputs must have the same type when castExpr is not provided: {} vs {}",
+        a->toString(),
+        b->toString());
+  }
+}
+
+void NullIfExpr::evalSpecialForm(
+    const SelectivityVector& rows,
+    EvalCtx& context,
+    VectorPtr& result) {
+  // Evaluate both inputs.
+  VectorPtr aResult;
+  inputs_[0]->eval(rows, context, aResult);
+
+  VectorPtr bResult;
+  inputs_[1]->eval(rows, context, bResult);
+
+  // Cast to common type for comparison if needed.
+  VectorPtr castA;
+  VectorPtr castB;
+  if (needsCastA_) {
+    castExpr_->apply(
+        rows, aResult, context, inputs_[0]->type(), castExpr_->type(), castA);
+  }
+  if (needsCastB_) {
+    castExpr_->apply(
+        rows, bResult, context, inputs_[1]->type(), castExpr_->type(), castB);
+  }
+
+  const auto& compareA = castA ? castA : aResult;
+  const auto& compareB = castB ? castB : bResult;
+
+  // Find rows where a does not equal b. These rows return a's value.
+  // Rows where a equals b return NULL. Rows where either is null are
+  // indeterminate and return a's value (which may itself be null).
+  LocalSelectivityVector nonNullRows(context, rows);
+
+  // TODO: Spark uses kNullAsValue which produces different results for complex
+  // types with nested nulls, e.g. NULLIF(ARRAY[1, NULL], ARRAY[1, NULL]).
+  rows.applyToSelected([&](auto row) {
+    auto equal = compareA->equalValueAt(
+        compareB.get(),
+        row,
+        row,
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+    if (equal.has_value() && equal.value()) {
+      nonNullRows->setValid(row, false);
+    }
+  });
+  nonNullRows->updateBounds();
+
+  if (nonNullRows->isSubset(rows) && rows.isSubset(*nonNullRows)) {
+    // No matches — return a as is.
+    context.moveOrCopyResult(aResult, rows, result);
+    return;
+  }
+
+  if (!nonNullRows->hasSelections()) {
+    // All rows match — return constant null.
+    result = BaseVector::createNullConstant(type(), rows.end(), context.pool());
+    return;
+  }
+
+  // Some rows match — copy only non-null rows from a, set remaining to null.
+  BaseVector::ensureWritable(rows, type(), context.pool(), result);
+  result->copy(aResult.get(), *nonNullRows, /*toSourceRow=*/nullptr);
+
+  LocalSelectivityVector nullRows(context, rows);
+  nullRows->deselect(*nonNullRows);
+  result->addNulls(*nullRows);
+}
+
+// static
+ExprPtr NullIfExpr::create(
+    std::vector<ExprPtr>&& inputs,
+    const TypePtr& commonType,
+    bool trackCpuUsage,
+    const core::QueryConfig& config) {
+  VELOX_USER_CHECK_EQ(
+      inputs.size(),
+      2,
+      "NULLIF requires exactly 2 arguments, received {}.",
+      inputs.size());
+
+  // Create a CastExpr for casting evaluated vectors to commonType. The child
+  // expression passed here is not used — we call apply() directly with
+  // pre-evaluated vectors. We use CastCallToSpecialForm to get proper hooks.
+  std::shared_ptr<CastExpr> castExpr;
+  if (*inputs[0]->type() != *commonType || *inputs[1]->type() != *commonType) {
+    CastCallToSpecialForm castFactory;
+    std::vector<ExprPtr> castInputs = {inputs[0]};
+    castExpr =
+        std::dynamic_pointer_cast<CastExpr>(castFactory.constructSpecialForm(
+            commonType,
+            std::move(castInputs),
+            /*trackCpuUsage=*/false,
+            config));
+  }
+
+  return std::make_shared<NullIfExpr>(
+      std::move(inputs), std::move(castExpr), trackCpuUsage);
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/expression/NullIfExpr.h b/velox/expression/NullIfExpr.h
new file mode 100644
index 00000000000..1e3268644fa
--- /dev/null
+++ b/velox/expression/NullIfExpr.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/CastExpr.h"
+#include "velox/expression/SpecialForm.h"
+
+namespace facebook::velox::exec {
+
+/// NULLIF(a, b): returns NULL if a equals b, otherwise returns a.
+///
+/// The comparison casts both inputs to 'commonType' internally. The return type
+/// is a's original type. Evaluates each input exactly once.
+class NullIfExpr : public SpecialForm {
+ public:
+  /// @param inputs Exactly two inputs: the value and the comparand.
+  /// @param castExpr Optional. Used to cast inputs to a common type for
+  /// comparison. Must be provided when input types differ. When null, inputs
+  /// must have the same type and are compared directly.
+  NullIfExpr(
+      std::vector<ExprPtr>&& inputs,
+      std::shared_ptr<CastExpr> castExpr,
+      bool trackCpuUsage);
+
+  /// Creates a NullIfExpr, building a CastExpr with proper hooks when input
+  /// types differ from commonType.
+  static ExprPtr create(
+      std::vector<ExprPtr>&& inputs,
+      const TypePtr& commonType,
+      bool trackCpuUsage,
+      const core::QueryConfig& config);
+
+  void evalSpecialForm(
+      const SelectivityVector& rows,
+      EvalCtx& context,
+      VectorPtr& result) override;
+
+ private:
+  // NULLIF does not propagate nulls: NULLIF(NULL, x) returns NULL (from the
+  // first argument), but NULLIF(x, NULL) returns x, not NULL.
+  void computePropagatesNulls() override {
+    propagatesNulls_ = false;
+  }
+
+  // Casts evaluated vectors to the common type for comparison. Null when both
+  // input types already match (no casting needed).
+  std::shared_ptr<CastExpr> castExpr_;
+
+  // Whether each input needs to be cast to the common type for comparison.
+  const bool needsCastA_;
+  const bool needsCastB_;
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/expression/PrestoCastHooks.h b/velox/expression/PrestoCastHooks.h
index b4156ac792f..2db12466fc9 100644
--- a/velox/expression/PrestoCastHooks.h
+++ b/velox/expression/PrestoCastHooks.h
@@ -67,6 +67,10 @@ class PrestoCastHooks : public CastHooks {
 
   PolicyType getPolicy() const override;
 
+  bool isScientific() const override {
+    return false;
+  }
+
  private:
   const bool legacyCast_;
   TimestampToStringOptions options_ = {
diff --git a/velox/expression/RegisterSpecialForm.cpp b/velox/expression/RegisterSpecialForm.cpp
index bc20675c63d..960be6a17f8 100644
--- a/velox/expression/RegisterSpecialForm.cpp
+++ b/velox/expression/RegisterSpecialForm.cpp
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) Facebook, Inc. and its affiliates.
  *
@@ -19,15 +18,17 @@
 
 #include "velox/expression/CastExpr.h"
 #include "velox/expression/CoalesceExpr.h"
+#include "velox/expression/CoalesceRewrite.h"
 #include "velox/expression/ConjunctExpr.h"
-#include "velox/expression/ExprConstants.h"
-#include "velox/expression/FunctionCallToSpecialForm.h"
+#include "velox/expression/ConjunctRewrite.h"
 #include "velox/expression/RowConstructor.h"
 #include "velox/expression/SpecialFormRegistry.h"
 #include "velox/expression/SwitchExpr.h"
+#include "velox/expression/SwitchRewrite.h"
 #include "velox/expression/TryExpr.h"
 
 namespace facebook::velox::exec {
+
 void registerFunctionCallToSpecialForms() {
   registerFunctionCallToSpecialForm(
       expression::kAnd,
@@ -48,7 +49,11 @@ void registerFunctionCallToSpecialForms() {
   registerFunctionCallToSpecialForm(
       expression::kTry, std::make_unique<TryCallToSpecialForm>());
   registerFunctionCallToSpecialForm(
-      RowConstructorCallToSpecialForm::kRowConstructor,
+      expression::kRowConstructor,
       std::make_unique<RowConstructorCallToSpecialForm>());
+
+  expression::CoalesceRewrite::registerRewrite();
+  expression::ConjunctRewrite::registerRewrite();
+  expression::SwitchRewrite::registerRewrite();
 }
 } // namespace facebook::velox::exec
diff --git a/velox/expression/RegisterSpecialForm.h b/velox/expression/RegisterSpecialForm.h
index bd71ac53b83..90e57dee3e9 100644
--- a/velox/expression/RegisterSpecialForm.h
+++ b/velox/expression/RegisterSpecialForm.h
@@ -17,5 +17,7 @@
 #pragma once
 
 namespace facebook::velox::exec {
+
 void registerFunctionCallToSpecialForms();
-}
+
+} // namespace facebook::velox::exec
diff --git a/velox/expression/ReverseSignatureBinder.h b/velox/expression/ReverseSignatureBinder.h
index 44b99232d6e..44e02c7575b 100644
--- a/velox/expression/ReverseSignatureBinder.h
+++ b/velox/expression/ReverseSignatureBinder.h
@@ -30,7 +30,8 @@ class ReverseSignatureBinder : private SignatureBinderBase {
   ReverseSignatureBinder(
       const exec::FunctionSignature& signature,
       const TypePtr& returnType)
-      : SignatureBinderBase{signature}, returnType_{returnType} {}
+      : SignatureBinderBase{signature, TypeCoercer::defaults()},
+        returnType_{returnType} {}
 
   /// Try bind returnType_ to the return type of the function signature. Return
   /// true if the binding succeeds, or false otherwise.
diff --git a/velox/expression/RowConstructor.cpp b/velox/expression/RowConstructor.cpp
index 59f3f2b4270..323acac2366 100644
--- a/velox/expression/RowConstructor.cpp
+++ b/velox/expression/RowConstructor.cpp
@@ -15,20 +15,15 @@
  */
 
 #include "velox/expression/RowConstructor.h"
+#include "velox/expression/ExprConstants.h"
 #include "velox/expression/VectorFunction.h"
 
 namespace facebook::velox::exec {
 
 TypePtr RowConstructorCallToSpecialForm::resolveType(
     const std::vector<TypePtr>& argTypes) {
-  auto numInput = argTypes.size();
-  std::vector<std::string> names(numInput);
-  std::vector<TypePtr> types(numInput);
-  for (auto i = 0; i < numInput; i++) {
-    types[i] = argTypes[i];
-    names[i] = fmt::format("c{}", i + 1);
-  }
-  return ROW(std::move(names), std::move(types));
+  std::vector<std::string> names(argTypes.size(), "");
+  return ROW(std::move(names), folly::copy(argTypes));
 }
 
 ExprPtr RowConstructorCallToSpecialForm::constructSpecialForm(
@@ -40,13 +35,15 @@ ExprPtr RowConstructorCallToSpecialForm::constructSpecialForm(
       [&config](auto& functionMap) -> std::pair<
                                        std::shared_ptr<VectorFunction>,
                                        VectorFunctionMetadata> {
-        auto functionIterator = functionMap.find(kRowConstructor);
+        auto functionIterator = functionMap.find(expression::kRowConstructor);
         if (functionIterator != functionMap.end()) {
           return {
-              functionIterator->second.factory(kRowConstructor, {}, config),
+              functionIterator->second.factory(
+                  expression::kRowConstructor, {}, config),
               functionIterator->second.metadata};
         } else {
-          VELOX_FAIL("Function {} is not registered.", kRowConstructor);
+          VELOX_FAIL(
+              "Function {} is not registered.", expression::kRowConstructor);
         }
       });
 
@@ -55,7 +52,7 @@ ExprPtr RowConstructorCallToSpecialForm::constructSpecialForm(
       std::move(compiledChildren),
       function,
       metadata,
-      kRowConstructor,
+      expression::kRowConstructor,
       trackCpuUsage);
 }
 } // namespace facebook::velox::exec
diff --git a/velox/expression/RowConstructor.h b/velox/expression/RowConstructor.h
index 9e29208536c..dd84d26ca97 100644
--- a/velox/expression/RowConstructor.h
+++ b/velox/expression/RowConstructor.h
@@ -28,7 +28,5 @@ class RowConstructorCallToSpecialForm : public FunctionCallToSpecialForm {
       std::vector<ExprPtr>&& compiledChildren,
       bool trackCpuUsage,
       const core::QueryConfig& config) override;
-
-  static constexpr const char* kRowConstructor = "row_constructor";
 };
 } // namespace facebook::velox::exec
diff --git a/velox/expression/SignatureBinder.cpp b/velox/expression/SignatureBinder.cpp
index c73b75c00d7..b616721b21a 100644
--- a/velox/expression/SignatureBinder.cpp
+++ b/velox/expression/SignatureBinder.cpp
@@ -19,6 +19,7 @@
 #include "velox/expression/SignatureBinder.h"
 #include "velox/expression/type_calculation/TypeCalculation.h"
 #include "velox/type/Type.h"
+#include "velox/type/TypeUtil.h"
 
 namespace facebook::velox::exec {
 namespace {
@@ -46,8 +47,11 @@ std::optional<int> tryResolveLongLiteral(
     return atoi(variable.c_str());
   };
 
-  if (integerVariablesBindings.count(variable)) {
-    return integerVariablesBindings.at(variable);
+  {
+    auto integerIt = integerVariablesBindings.find(variable);
+    if (integerIt != integerVariablesBindings.end()) {
+      return integerIt->second;
+    }
   }
 
   auto it = variables.find(variable);
@@ -56,7 +60,6 @@ std::optional<int> tryResolveLongLiteral(
   }
 
   const auto& constraints = it->second.constraint();
-
   if (constraints.empty()) {
     return std::nullopt;
   }
@@ -65,11 +68,13 @@ std::optional<int> tryResolveLongLiteral(
   // Check constraints and evaluate.
   const auto calculation = fmt::format("{}={}", variable, constraints);
   expression::calculation::evaluate(calculation, integerVariablesBindings);
+
+  auto integerIt = integerVariablesBindings.find(variable);
   VELOX_CHECK(
-      integerVariablesBindings.count(variable),
-      "Variable {} calculation failed.",
+      integerIt != integerVariablesBindings.end(),
+      "Variable calculation failed: {}",
       variable);
-  return integerVariablesBindings.at(variable);
+  return integerIt->second;
 }
 
 std::optional<LongEnumParameter> tryResolveLongEnumLiteral(
@@ -124,37 +129,40 @@ bool SignatureBinder::tryBind() {
 bool SignatureBinder::tryBind(
     bool allowCoercions,
     std::vector<Coercion>& coercions) {
+  const auto numActualTypes = actualTypes_.size();
+
   if (allowCoercions) {
     coercions.clear();
-    coercions.resize(actualTypes_.size());
+    coercions.resize(numActualTypes);
   }
 
   const auto& formalArgs = signature_.argumentTypes();
-  const auto formalArgsCnt = formalArgs.size();
+  const auto numFormalArgs = formalArgs.size();
 
   if (signature_.variableArity()) {
-    if (actualTypes_.size() < formalArgsCnt - 1) {
+    if (numActualTypes < numFormalArgs - 1) {
       return false;
     }
+  } else {
+    if (numFormalArgs != numActualTypes) {
+      return false;
+    }
+  }
 
-    if (!isAny(signature_.argumentTypes().back())) {
-      if (actualTypes_.size() > formalArgsCnt) {
-        auto& type = actualTypes_[formalArgsCnt - 1];
-        for (auto i = formalArgsCnt; i < actualTypes_.size(); i++) {
-          if (!type->equivalent(*actualTypes_[i]) &&
-              actualTypes_[i]->kind() != TypeKind::UNKNOWN) {
-            return false;
-          }
+  if (allowCoercions && !variables().empty()) {
+    for (auto i = 0; i < numActualTypes; i++) {
+      if (actualTypes_[i]) {
+        const auto& typeSignature =
+            i < numFormalArgs ? formalArgs[i] : formalArgs[numFormalArgs - 1];
+
+        if (!tryBindVariablesWithCoercion(typeSignature, actualTypes_[i])) {
+          return false;
         }
       }
     }
-  } else {
-    if (formalArgsCnt != actualTypes_.size()) {
-      return false;
-    }
   }
 
-  for (auto i = 0; i < formalArgsCnt && i < actualTypes_.size(); i++) {
+  for (auto i = 0; i < numFormalArgs && i < numActualTypes; i++) {
     if (actualTypes_[i]) {
       if (allowCoercions) {
         if (!SignatureBinderBase::tryBindWithCoercion(
@@ -171,6 +179,37 @@ bool SignatureBinder::tryBind(
     }
   }
 
+  if (signature_.variableArity()) {
+    if (!isAny(signature_.argumentTypes().back())) {
+      if (numActualTypes > numFormalArgs) {
+        if (allowCoercions) {
+          auto firstType = actualTypes_[numFormalArgs - 1];
+          if (coercions[numFormalArgs - 1].type != nullptr) {
+            firstType = coercions[numFormalArgs - 1].type;
+          }
+
+          for (auto i = numFormalArgs; i < numActualTypes; i++) {
+            if (auto cost = coercer_.coercible(actualTypes_[i], firstType)) {
+              if (cost.value() > 0) {
+                coercions[i] = Coercion{firstType, cost.value()};
+              }
+            } else {
+              return false;
+            }
+          }
+
+        } else {
+          const auto& firstType = actualTypes_[numFormalArgs - 1];
+          for (auto i = numFormalArgs; i < numActualTypes; i++) {
+            if (!firstType->equivalent(*actualTypes_[i])) {
+              return false;
+            }
+          }
+        }
+      }
+    }
+  }
+
   return true;
 }
 
@@ -206,7 +245,7 @@ bool SignatureBinderBase::checkOrSetIntegerParameter(
   if (isPositiveInteger(parameterName)) {
     return atoi(parameterName.c_str()) == value;
   }
-  if (!variables().count(parameterName)) {
+  if (!variables().contains(parameterName)) {
     // Return false if the parameter is not found in the signature.
     return false;
   }
@@ -217,17 +256,67 @@ bool SignatureBinderBase::checkOrSetIntegerParameter(
     return false;
   }
 
-  if (integerVariablesBindings_.count(parameterName)) {
+  auto integerIt = integerVariablesBindings_.find(parameterName);
+  if (integerIt != integerVariablesBindings_.end()) {
     // Return false if the parameter is found with a different value.
-    if (integerVariablesBindings_[parameterName] != value) {
+    if (integerIt->second != value) {
       return false;
     }
   }
+
   // Bind the variable.
   integerVariablesBindings_[parameterName] = value;
   return true;
 }
 
+std::optional<bool> SignatureBinderBase::checkSetTypeVariable(
+    const exec::TypeSignature& typeSignature,
+    const TypePtr& actualType,
+    bool allowCoercion,
+    Coercion& coercion) {
+  const auto& baseName = typeSignature.baseName();
+
+  auto variableIt = variables().find(baseName);
+  if (variableIt == variables().end()) {
+    return std::nullopt;
+  }
+
+  if (allowCoercion) {
+    // Variables must be already set.
+    auto bindingIt = typeVariablesBindings_.find(baseName);
+    VELOX_CHECK(bindingIt != typeVariablesBindings_.end());
+
+    const auto& boundType = bindingIt->second;
+    const auto cost = coercer_.coercible(actualType, boundType);
+    VELOX_CHECK(cost.has_value());
+
+    if (cost.value() > 0) {
+      coercion.type = boundType;
+      coercion.cost = cost.value();
+    }
+    return true;
+  }
+
+  // Variables cannot have further parameters.
+  VELOX_CHECK(
+      typeSignature.parameters().empty(),
+      "Variables with parameters are not supported");
+  const auto& variable = variableIt->second;
+  VELOX_CHECK(variable.isTypeParameter(), "Not expecting integer variable");
+
+  auto bindingIt = typeVariablesBindings_.find(baseName);
+  if (bindingIt != typeVariablesBindings_.end()) {
+    return bindingIt->second->equivalent(*actualType);
+  }
+
+  if (!variable.isEligibleType(*actualType)) {
+    return false;
+  }
+
+  typeVariablesBindings_[baseName] = actualType;
+  return true;
+}
+
 bool SignatureBinderBase::tryBindWithCoercion(
     const exec::TypeSignature& typeSignature,
     const TypePtr& actualType,
@@ -242,57 +331,87 @@ bool SignatureBinderBase::tryBind(
   return tryBind(typeSignature, actualType, false, coercion);
 }
 
-bool SignatureBinderBase::tryBind(
+bool SignatureBinder::tryBindVariablesWithCoercion(
     const exec::TypeSignature& typeSignature,
-    const TypePtr& actualType,
-    bool allowCoercion,
-    Coercion& coercion) {
-  coercion.reset();
-  if (isAny(typeSignature)) {
-    return true;
-  }
-
+    const TypePtr& actualType) {
   const auto& baseName = typeSignature.baseName();
 
-  if (variables().count(baseName)) {
+  auto variableIt = variables().find(baseName);
+  if (variableIt != variables().end()) {
     // Variables cannot have further parameters.
     VELOX_CHECK(
         typeSignature.parameters().empty(),
         "Variables with parameters are not supported");
-    auto& variable = variables().at(baseName);
-    VELOX_CHECK(variable.isTypeParameter(), "Not expecting integer variable");
-
-    if (typeVariablesBindings_.count(baseName)) {
-      // If the the variable type is already mapped to a concrete type, make
-      // sure the mapped type is equivalent to the actual type.
-      return typeVariablesBindings_[baseName]->equivalent(*actualType);
+    const auto& variable = variableIt->second;
+    if (!variable.isTypeParameter()) {
+      // Integer variables (e.g. decimal precision and scale) are bound
+      // later by tryBind. Skip them here.
+      return true;
     }
 
-    if (actualType->isUnKnown() && variable.knownTypesOnly()) {
+    if (!variable.isEligibleType(*actualType)) {
       return false;
     }
 
-    if (variable.orderableTypesOnly() && !actualType->isOrderable()) {
-      return false;
+    auto bindingIt = typeVariablesBindings_.find(baseName);
+    if (bindingIt == typeVariablesBindings_.end()) {
+      typeVariablesBindings_[baseName] = actualType;
+      return true;
     }
 
-    if (variable.comparableTypesOnly() && !actualType->isComparable()) {
-      return false;
+    if (auto superType =
+            coercer_.leastCommonSuperType(actualType, bindingIt->second)) {
+      typeVariablesBindings_[baseName] = superType;
+      return true;
+    }
+
+    return false;
+  }
+
+  if (typeSignature.isHomogeneousRow()) {
+    // TODO Add coercion support.
+    return true;
+  }
+
+  const auto& params = typeSignature.parameters();
+  if (params.size() != actualType->parameters().size()) {
+    return false;
+  }
+
+  for (auto i = 0; i < params.size(); i++) {
+    const auto& actualParameter = actualType->parameters()[i];
+    if (actualParameter.kind == TypeParameterKind::kType) {
+      if (!tryBindVariablesWithCoercion(params[i], actualParameter.type)) {
+        return false;
+      }
     }
+  }
+
+  return true;
+}
 
-    typeVariablesBindings_[baseName] = actualType;
+bool SignatureBinderBase::tryBind(
+    const exec::TypeSignature& typeSignature,
+    const TypePtr& actualType,
+    bool allowCoercion,
+    Coercion& coercion) {
+  coercion.reset();
+  if (isAny(typeSignature)) {
     return true;
   }
 
+  if (auto result = checkSetTypeVariable(
+          typeSignature, actualType, allowCoercion, coercion)) {
+    return result.value();
+  }
+
   // Type is not a variable.
+  const auto& baseName = typeSignature.baseName();
   auto typeName = boost::algorithm::to_upper_copy(baseName);
-  auto actualTypeName =
-      boost::algorithm::to_upper_copy(std::string(actualType->name()));
-
-  if (typeName != actualTypeName) {
-    if (allowCoercion) {
+  if (!boost::algorithm::iequals(typeName, actualType->name())) {
+    if (allowCoercion && typeSignature.parameters().empty()) {
       if (auto availableCoercion =
-              TypeCoercer::coerceTypeBase(actualType, typeName)) {
+              coercer_.coerceTypeBase(actualType, typeName)) {
         coercion = availableCoercion.value();
         return true;
       }
@@ -301,11 +420,50 @@ bool SignatureBinderBase::tryBind(
   }
 
   const auto& params = typeSignature.parameters();
+
+  // Handle homogeneous row case: row(T, ...)
+  if (typeSignature.isHomogeneousRow()) {
+    VELOX_CHECK_EQ(
+        params.size(), 1, "Homogeneous row must have exactly one parameter");
+
+    if (actualType->kind() != TypeKind::ROW) {
+      return false;
+    }
+
+    if (actualType->size() == 0) {
+      // Empty row is always compatible with homogeneous row.
+      return true;
+    }
+
+    // All children must unify to the same type variable T
+    const auto& typeParam = params[0];
+
+    // First, check and extract the common child type if homogeneous.
+    const auto actualChildType =
+        velox::type::tryGetHomogeneousRowChild(actualType);
+    if (!actualChildType) {
+      return false;
+    }
+
+    // TODO Add coercion support.
+    if (auto result = checkSetTypeVariable(
+            typeParam, actualChildType, /*allowCoercion=*/false, coercion)) {
+      return result.value();
+    }
+
+    return tryBind(typeParam, actualChildType);
+  }
+
   // Type Parameters can recurse.
   if (params.size() != actualType->parameters().size()) {
     return false;
   }
 
+  std::vector<Coercion> paramCoercions;
+  if (allowCoercion) {
+    paramCoercions.resize(params.size());
+  }
+
   for (auto i = 0; i < params.size(); i++) {
     const auto& actualParameter = actualType->parameters()[i];
     switch (actualParameter.kind) {
@@ -334,13 +492,42 @@ bool SignatureBinderBase::tryBind(
           return false;
         }
 
-        if (!tryBind(params[i], actualParameter.type)) {
-          // TODO Allow coercions for complex types.
+        if (allowCoercion) {
+          if (!tryBindWithCoercion(
+                  params[i], actualParameter.type, paramCoercions[i])) {
+            return false;
+          }
+
+        } else if (!tryBind(params[i], actualParameter.type)) {
           return false;
         }
+
         break;
     }
   }
+
+  if (allowCoercion) {
+    const bool hasCoercion = std::ranges::any_of(
+        paramCoercions,
+        [](const auto& coercion) { return coercion.type != nullptr; });
+
+    if (hasCoercion) {
+      std::vector<TypeParameter> newParams;
+      newParams.reserve(params.size());
+      for (auto i = 0; i < params.size(); i++) {
+        if (paramCoercions[i].type != nullptr) {
+          newParams.push_back(
+              TypeParameter(paramCoercions[i].type, params[i].rowFieldName()));
+          coercion.cost += paramCoercions[i].cost;
+        } else {
+          newParams.push_back(actualType->parameters()[i]);
+        }
+      }
+
+      coercion.type = getType(typeName, newParams);
+    }
+  }
+
   return true;
 }
 
@@ -355,7 +542,7 @@ TypePtr SignatureBinder::tryResolveType(
         varcharEnumParameterVariableBindings) {
   const auto& baseName = typeSignature.baseName();
 
-  if (variables.count(baseName)) {
+  if (variables.contains(baseName)) {
     auto it = typeVariablesBindings.find(baseName);
     if (it == typeVariablesBindings.end()) {
       return nullptr;
@@ -424,4 +611,43 @@ TypePtr SignatureBinder::tryResolveType(
       return nullptr;
   }
 }
+TypePtr tryResolveReturnTypeWithCoercions(
+    const std::vector<FunctionSignaturePtr>& signatures,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer) {
+  std::vector<std::pair<std::vector<Coercion>, TypePtr>> candidates;
+  for (const auto& signature : signatures) {
+    SignatureBinder binder(*signature, argTypes, coercer);
+    std::vector<Coercion> requiredCoercions;
+    if (binder.tryBindWithCoercions(requiredCoercions)) {
+      auto type = binder.tryResolveReturnType();
+      bool needsCoercion = false;
+      for (const auto& c : requiredCoercions) {
+        if (c.type != nullptr) {
+          needsCoercion = true;
+          break;
+        }
+      }
+      if (!needsCoercion) {
+        // Exact match. No coercions needed.
+        coercions.resize(argTypes.size(), nullptr);
+        return type;
+      }
+      candidates.emplace_back(std::move(requiredCoercions), type);
+    }
+  }
+
+  if (auto index = Coercion::pickLowestCost(candidates)) {
+    const auto& requiredCoercions = candidates[index.value()].first;
+    coercions.reserve(requiredCoercions.size());
+    for (const auto& coercion : requiredCoercions) {
+      coercions.push_back(coercion.type);
+    }
+    return candidates[index.value()].second;
+  }
+
+  return nullptr;
+}
+
 } // namespace facebook::velox::exec
diff --git a/velox/expression/SignatureBinder.h b/velox/expression/SignatureBinder.h
index 0dd7527de4e..b9c12f1d155 100644
--- a/velox/expression/SignatureBinder.h
+++ b/velox/expression/SignatureBinder.h
@@ -23,22 +23,24 @@ namespace facebook::velox::exec {
 
 class SignatureBinderBase {
  protected:
-  explicit SignatureBinderBase(const exec::FunctionSignature& signature)
-      : signature_{signature} {}
+  SignatureBinderBase(
+      const exec::FunctionSignature& signature,
+      const TypeCoercer& coercer)
+      : signature_{signature}, coercer_{coercer} {}
 
-  /// Return true if actualType can bind to typeSignature and update bindings_
-  /// accordingly. The number of parameters in typeSignature and actualType
-  /// must match. Return false otherwise.
+  // Return true if actualType can bind to typeSignature and update bindings_
+  // accordingly. The number of parameters in typeSignature and actualType
+  // must match. Return false otherwise.
   bool tryBind(
       const exec::TypeSignature& typeSignature,
       const TypePtr& actualType);
 
-  /// Like 'tryBind', but allows implicit type conversion if actualType
-  /// doesn't match typeSignature exactly.
-  ///
-  /// @param coercion Type coercion necessary to bind actualType to
-  /// typeSignature if there is no exact match. 'coercion.type' is null if
-  /// there is exact match.
+  // Like 'tryBind', but allows implicit type conversion if actualType
+  // doesn't match typeSignature exactly.
+  //
+  // @param coercion Type coercion necessary to bind actualType to
+  // typeSignature if there is no exact match. 'coercion.type' is null if
+  // there is exact match.
   bool tryBindWithCoercion(
       const exec::TypeSignature& typeSignature,
       const TypePtr& actualType,
@@ -49,38 +51,48 @@ class SignatureBinderBase {
     return signature_.variables();
   }
 
-  /// The function signature we are trying to bind.
+  // The function signature we are trying to bind.
   const exec::FunctionSignature& signature_;
 
-  /// Record concrete types that are bound to type variables.
+  // Coercion rules used for implicit type conversion. Defaults to
+  // TypeCoercer::defaults() when no dialect-specific coercer is supplied.
+  const TypeCoercer& coercer_;
+
+  // Record concrete types that are bound to type variables.
   std::unordered_map<std::string, TypePtr> typeVariablesBindings_;
 
-  /// Record concrete values that are bound to integer variables.
+  // Record concrete values that are bound to integer variables.
   std::unordered_map<std::string, int> integerVariablesBindings_;
 
-  /// Record concrete values that are bound to LongEnumParameter variables.
+  // Record concrete values that are bound to LongEnumParameter variables.
   std::unordered_map<std::string, LongEnumParameter> longEnumVariablesBindings_;
 
-  /// Record concrete values that are bound to VarcharEnumParameter variables.
+  // Record concrete values that are bound to VarcharEnumParameter variables.
   std::unordered_map<std::string, VarcharEnumParameter>
       varcharEnumVariablesBindings_;
 
  private:
-  /// If the integer parameter is set, then it must match with value.
-  /// Returns false if values do not match or the parameter does not exist.
+  // If the integer parameter is set, then it must match with value.
+  // Returns false if values do not match or the parameter does not exist.
   bool checkOrSetIntegerParameter(const std::string& parameterName, int value);
 
-  /// Try to bind the LongEnumParameter from the actualType.
+  // Try to bind the LongEnumParameter from the actualType.
   bool checkOrSetLongEnumParameter(
       const std::string& parameterName,
       const LongEnumParameter& params);
 
-  /// Try to bind the VarcharEnumParameter from the actualType.
+  // Try to bind the VarcharEnumParameter from the actualType.
   bool checkOrSetVarcharEnumParameter(
       const std::string& parameterName,
       const VarcharEnumParameter& params);
 
-  /// Try to bind the integer parameter from the actualType.
+  std::optional<bool> checkSetTypeVariable(
+      const exec::TypeSignature& typeSignature,
+      const TypePtr& actualType,
+      bool allowCoercion,
+      Coercion& coercion);
+
+  // Try to bind the integer parameter from the actualType.
   bool tryBindIntegerParameters(
       const std::vector<exec::TypeSignature>& parameters,
       const TypePtr& actualType);
@@ -102,11 +114,12 @@ class SignatureBinderBase {
 /// corresponding to lambda inputs).
 class SignatureBinder : private SignatureBinderBase {
  public:
-  // Requires that signature and actualTypes are not r-values.
+  /// Requires that signature and actualTypes are not r-values.
   SignatureBinder(
       const exec::FunctionSignature& signature,
-      const std::vector<TypePtr>& actualTypes)
-      : SignatureBinderBase{signature}, actualTypes_{actualTypes} {}
+      const std::vector<TypePtr>& actualTypes,
+      const TypeCoercer& coercer)
+      : SignatureBinderBase{signature, coercer}, actualTypes_{actualTypes} {}
 
   /// Returns true if successfully resolved all generic type names.
   bool tryBind();
@@ -123,8 +136,8 @@ class SignatureBinder : private SignatureBinderBase {
     return tryResolveType(signature_.returnType());
   }
 
-  // Try resolve type for the specified signature. Return nullptr if cannot
-  // resolve.
+  /// Try resolve type for the specified signature. Return nullptr if cannot
+  /// resolve.
   TypePtr tryResolveType(const exec::TypeSignature& typeSignature) {
     return tryResolveType(
         typeSignature,
@@ -135,8 +148,8 @@ class SignatureBinder : private SignatureBinderBase {
         varcharEnumVariablesBindings_);
   }
 
-  // Try resolve types for all specified signatures. Return empty list if some
-  // signatures cannot be resolved.
+  /// Try resolve types for all specified signatures. Return empty list if some
+  /// signatures cannot be resolved.
   std::vector<TypePtr> tryResolveTypes(
       const folly::Range<const TypeSignature*>& typeSignatures) {
     std::vector<TypePtr> types;
@@ -152,8 +165,8 @@ class SignatureBinder : private SignatureBinderBase {
     return types;
   }
 
-  // Given a pre-computed binding for type variables resolve typeSignature if
-  // possible.
+  /// Given a pre-computed binding for type variables resolve typeSignature if
+  /// possible.
   static TypePtr tryResolveType(
       const exec::TypeSignature& typeSignature,
       const std::unordered_map<std::string, SignatureVariable>& variables,
@@ -170,9 +183,9 @@ class SignatureBinder : private SignatureBinderBase {
         dummyEmpty3);
   }
 
-  // Given a pre-computed binding for type variables and integer variables,
-  // resolve typeSignature if possible. integerVariablesBindings might will be
-  // updated with the bound value.
+  /// Given a pre-computed binding for type variables and integer variables,
+  /// resolve typeSignature if possible. integerVariablesBindings might will be
+  /// updated with the bound value.
   static TypePtr tryResolveType(
       const exec::TypeSignature& typeSignature,
       const std::unordered_map<std::string, SignatureVariable>& variables,
@@ -186,7 +199,28 @@ class SignatureBinder : private SignatureBinderBase {
  private:
   bool tryBind(bool allowCoercions, std::vector<Coercion>& coercions);
 
+  // Pre-binds type variables to their least common super type across all
+  // arguments. Runs before the main binding loop. Only binds type variables,
+  // not integer variables (e.g. decimal precision/scale) -- those are bound
+  // later by tryBind. Does not check base type name match since coercion may
+  // change the base type. Returns false if a type variable conflict is found
+  // that would prevent binding; true otherwise.
+  bool tryBindVariablesWithCoercion(
+      const exec::TypeSignature& typeSignature,
+      const TypePtr& actualType);
+
   const std::vector<TypePtr>& actualTypes_;
 };
 
+/// Try to resolve the return type from a list of function signatures with
+/// coercion support. Returns the resolved return type if a matching signature
+/// is found, nullptr otherwise. On success, 'coercions' contains one entry per
+/// argument: nullptr if no coercion needed, or the target type if coercion is
+/// required. Exact matches (no coercions) are preferred over coerced matches.
+TypePtr tryResolveReturnTypeWithCoercions(
+    const std::vector<FunctionSignaturePtr>& signatures,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer);
+
 } // namespace facebook::velox::exec
diff --git a/velox/expression/SimpleFunctionAdapter.h b/velox/expression/SimpleFunctionAdapter.h
index aa19c249291..e257cf2f704 100644
--- a/velox/expression/SimpleFunctionAdapter.h
+++ b/velox/expression/SimpleFunctionAdapter.h
@@ -216,14 +216,15 @@ class SimpleFunctionAdapter : public VectorFunction {
     bool mayHaveNullsRecursive{false};
   };
 
-  template <int32_t POSITION, typename... Values>
+  template <size_t POSITION, typename... Values>
   void unpackInitialize(
       const std::vector<TypePtr>& inputTypes,
       const core::QueryConfig& config,
+      memory::MemoryPool* memoryPool,
       const std::vector<VectorPtr>& packed,
       const Values*... values) const {
     if constexpr (POSITION == FUNC::num_args) {
-      return (*fn_).initialize(inputTypes, config, values...);
+      return (*fn_).initialize(inputTypes, config, memoryPool, values...);
     } else {
       if (packed.at(POSITION) != nullptr) {
         SelectivityVector rows(1);
@@ -232,11 +233,16 @@ class SimpleFunctionAdapter : public VectorFunction {
         auto oneValue = oneReader[0];
 
         unpackInitialize<POSITION + 1>(
-            inputTypes, config, packed, values..., &oneValue);
+            inputTypes, config, memoryPool, packed, values..., &oneValue);
       } else {
         using temp_type = exec_arg_at<POSITION>;
         unpackInitialize<POSITION + 1>(
-            inputTypes, config, packed, values..., (const temp_type*)nullptr);
+            inputTypes,
+            config,
+            memoryPool,
+            packed,
+            values...,
+            (const temp_type*)nullptr);
       }
     }
   }
@@ -245,11 +251,12 @@ class SimpleFunctionAdapter : public VectorFunction {
   SimpleFunctionAdapter(
       const std::vector<TypePtr>& inputTypes,
       const core::QueryConfig& config,
-      const std::vector<VectorPtr>& constantInputs)
+      const std::vector<VectorPtr>& constantInputs,
+      memory::MemoryPool* memoryPool = nullptr)
       : fn_{std::make_unique<FUNC>()} {
     if constexpr (FUNC::udf_has_initialize) {
       try {
-        unpackInitialize<0>(inputTypes, config, constantInputs);
+        unpackInitialize<0>(inputTypes, config, memoryPool, constantInputs);
       } catch (const VeloxRuntimeError&) {
         throw;
       } catch (const std::exception&) {
@@ -970,9 +977,10 @@ class SimpleFunctionAdapterFactoryImpl : public SimpleFunctionAdapterFactory {
   std::unique_ptr<VectorFunction> createVectorFunction(
       const std::vector<TypePtr>& inputTypes,
       const std::vector<VectorPtr>& constantInputs,
-      const core::QueryConfig& config) const override {
+      const core::QueryConfig& config,
+      memory::MemoryPool* memoryPool = nullptr) const override {
     return std::make_unique<SimpleFunctionAdapter<UDFHolder>>(
-        inputTypes, config, constantInputs);
+        inputTypes, config, constantInputs, memoryPool);
   }
 };
 
diff --git a/velox/expression/SimpleFunctionRegistry.cpp b/velox/expression/SimpleFunctionRegistry.cpp
index c159a60b534..5f25ad4ba15 100644
--- a/velox/expression/SimpleFunctionRegistry.cpp
+++ b/velox/expression/SimpleFunctionRegistry.cpp
@@ -129,9 +129,12 @@ SimpleFunctionRegistry::getFunctionSignaturesAndMetadata(
       result.reserve(signatureMap->size());
       for (const auto& [signature, functions] : *signatureMap) {
         VectorFunctionMetadata metadata{
-            false,
-            functions[0]->getMetadata().isDeterministic(),
-            functions[0]->getMetadata().defaultNullBehavior()};
+            .supportsFlattening = false,
+            .deterministic = functions[0]->getMetadata().isDeterministic(),
+            .defaultNullBehavior =
+                functions[0]->getMetadata().defaultNullBehavior(),
+            .companionFunction = false,
+            .owner = functions[0]->getMetadata().owner()};
         result.emplace_back(
             std::pair<VectorFunctionMetadata, const FunctionSignature*>{
                 metadata, &signature});
@@ -145,7 +148,7 @@ namespace {
 
 // Same as Type::kindEquals, but matches UNKNOWN in 'physicalType' to any type.
 bool physicalTypeMatches(const TypePtr& type, const TypePtr& physicalType) {
-  if (physicalType->isUnKnown()) {
+  if (physicalType->isUnknown()) {
     return true;
   }
 
@@ -173,7 +176,8 @@ SimpleFunctionRegistry::resolveFunction(
     const std::string& name,
     const std::vector<TypePtr>& argTypes,
     bool allowCoercion,
-    std::vector<TypePtr>& coercions) const {
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer) const {
   using Candidate = std::pair<const FunctionEntry*, TypePtr>;
 
   std::optional<Candidate> selectedCandidate;
@@ -183,7 +187,7 @@ SimpleFunctionRegistry::resolveFunction(
       std::optional<uint32_t> priority;
 
       for (const auto& [candidateSignature, functionEntry] : *signatureMap) {
-        SignatureBinder binder(candidateSignature, argTypes);
+        SignatureBinder binder(candidateSignature, argTypes, coercer);
 
         std::vector<Coercion> requiredCoercions;
 
diff --git a/velox/expression/SimpleFunctionRegistry.h b/velox/expression/SimpleFunctionRegistry.h
index 7244d35beb1..b49dfbc2d54 100644
--- a/velox/expression/SimpleFunctionRegistry.h
+++ b/velox/expression/SimpleFunctionRegistry.h
@@ -145,7 +145,9 @@ class SimpleFunctionRegistry {
       return VectorFunctionMetadata{
           false,
           functionEntry_.getMetadata().isDeterministic(),
-          functionEntry_.getMetadata().defaultNullBehavior()};
+          functionEntry_.getMetadata().defaultNullBehavior(),
+          false,
+          functionEntry_.getMetadata().owner()};
     }
 
    private:
@@ -157,14 +159,16 @@ class SimpleFunctionRegistry {
       const std::string& name,
       const std::vector<TypePtr>& argTypes) const {
     std::vector<TypePtr> coercions;
-    return resolveFunction(name, argTypes, false, coercions);
+    return resolveFunction(
+        name, argTypes, false, coercions, TypeCoercer::defaults());
   }
 
   std::optional<ResolvedSimpleFunction> resolveFunctionWithCoercions(
       const std::string& name,
       const std::vector<TypePtr>& argTypes,
-      std::vector<TypePtr>& coercions) const {
-    return resolveFunction(name, argTypes, true, coercions);
+      std::vector<TypePtr>& coercions,
+      const TypeCoercer& coercer) const {
+    return resolveFunction(name, argTypes, true, coercions, coercer);
   }
 
  private:
@@ -172,7 +176,8 @@ class SimpleFunctionRegistry {
       const std::string& name,
       const std::vector<TypePtr>& argTypes,
       bool allowCoercion,
-      std::vector<TypePtr>& coercions) const;
+      std::vector<TypePtr>& coercions,
+      const TypeCoercer& coercer) const;
 
   /// Registers a function with the given name and metadata. If an entry with
   /// the name already exists and 'overwrite' is true, the existing entry is
diff --git a/velox/expression/SwitchExpr.cpp b/velox/expression/SwitchExpr.cpp
index 835092cf4b5..f7f78e171a8 100644
--- a/velox/expression/SwitchExpr.cpp
+++ b/velox/expression/SwitchExpr.cpp
@@ -15,9 +15,9 @@
  */
 #include "velox/expression/SwitchExpr.h"
 #include "velox/expression/BooleanMix.h"
-#include "velox/expression/ConstantExpr.h"
+#include "velox/expression/ExprConstants.h"
 #include "velox/expression/FieldReference.h"
-#include "velox/expression/ScopedVarSetter.h"
+#include "velox/type/TypeCoercer.h"
 
 namespace facebook::velox::exec {
 
@@ -25,6 +25,17 @@ namespace {
 bool hasElseClause(const std::vector<ExprPtr>& inputs) {
   return inputs.size() % 2 == 1;
 }
+
+TypePtr resolveTypeInt(
+    const std::vector<TypePtr>& argTypes,
+    bool allowedCoercions,
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer);
+
+TypePtr resolveTypeInt(const std::vector<TypePtr>& argTypes) {
+  std::vector<TypePtr> coercions;
+  return resolveTypeInt(argTypes, false, coercions, TypeCoercer::defaults());
+};
 } // namespace
 
 SwitchExpr::SwitchExpr(
@@ -35,7 +46,7 @@ SwitchExpr::SwitchExpr(
           SpecialFormKind::kSwitch,
           std::move(type),
           inputs,
-          "switch",
+          expression::kSwitch,
           hasElseClause(inputs) && inputsSupportFlatNoNullsFastPath,
           false /* trackCpuUsage */),
       numCases_{inputs_.size() / 2},
@@ -49,7 +60,7 @@ SwitchExpr::SwitchExpr(
       [](const ExprPtr& expr) { return expr->type(); });
 
   // Apply type checking.
-  auto typeExpected = resolveType(inputTypes);
+  auto typeExpected = resolveTypeInt(inputTypes);
   VELOX_CHECK(
       *typeExpected == *this->type(),
       "Switch expression type different than then clause. Expected {}, but got {}.",
@@ -182,8 +193,8 @@ void SwitchExpr::computePropagatesNulls() {
   // - All "then" clauses and optional "else" clause use the same inputs.
   // - All "condition" clauses use a subset of "then"/"else" inputs.
 
-  for (auto i = 0; i < numCases_; i += 2) {
-    if (!inputs_[i + 1]->propagatesNulls()) {
+  for (auto i = 0; i < numCases_; ++i) {
+    if (!inputs_[i * 2 + 1]->propagatesNulls()) {
       propagatesNulls_ = false;
       return;
     }
@@ -219,58 +230,93 @@ void SwitchExpr::computePropagatesNulls() {
   propagatesNulls_ = true;
 }
 
-// static
-TypePtr SwitchExpr::resolveType(const std::vector<TypePtr>& argTypes) {
+namespace {
+TypePtr resolveTypeInt(
+    const std::vector<TypePtr>& argTypes,
+    bool allowedCoercions,
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer) {
   VELOX_CHECK_GT(
       argTypes.size(),
       1,
       "Switch statements expect at least 2 arguments, received {}",
       argTypes.size());
-  // Type structure is [cond1Type, then1Type, cond2Type, then2Type, ...
-  // elseType*]
 
-  // Make sure all 'condition' expressions hae type BOOLEAN and all 'then' and
-  // an optional 'else' clause have the same type.
-  int numCases = argTypes.size() / 2;
+  const size_t numArgs = argTypes.size();
+  const size_t numCases = numArgs / 2;
+
+  TypePtr resultType = argTypes[1];
 
-  auto& expressionType = argTypes[1];
+  if (allowedCoercions) {
+    coercions.clear();
+    coercions.resize(numArgs);
+  }
+
+  auto setCoercionsUpTo = [&](int index, const TypePtr& type) {
+    for (auto i = 1; i <= index; i += 2) {
+      coercions[i] = type;
+    }
+  };
 
   for (auto i = 0; i < numCases; i++) {
-    auto& conditionType = argTypes[i * 2];
-    auto& thenType = argTypes[i * 2 + 1];
+    const auto& conditionType = argTypes[i * 2];
+    const auto& thenType = argTypes[i * 2 + 1];
 
     VELOX_CHECK_EQ(
         conditionType->kind(),
         TypeKind::BOOLEAN,
         "Condition of  SWITCH statement is not bool");
 
-    VELOX_CHECK(
-        *thenType == *expressionType,
-        "All then clauses of a SWITCH statement must have the same type. "
-        "Expected {}, but got {}.",
-        expressionType->toString(),
-        thenType->toString());
+    if (*thenType != *resultType) {
+      if (allowedCoercions && coercer.coercible(thenType, resultType)) {
+        coercions[i * 2 + 1] = resultType;
+      } else if (allowedCoercions && coercer.coercible(resultType, thenType)) {
+        resultType = thenType;
+        setCoercionsUpTo(i * 2 - 1, resultType);
+      } else {
+        VELOX_FAIL(
+            "All then clauses of a SWITCH statement must have the same type. "
+            "Expected {}, but got {}.",
+            resultType->toString(),
+            thenType->toString());
+      }
+    }
   }
 
-  bool hasElse = argTypes.size() % 2 == 1;
-
+  const bool hasElse = argTypes.size() % 2 == 1;
   if (hasElse) {
-    auto& elseClauseType = argTypes.back();
-
-    VELOX_CHECK(
-        *elseClauseType == *expressionType,
-        "Else clause of a SWITCH statement must have the same type as 'then' clauses. "
-        "Expected {}, but got {}.",
-        expressionType->toString(),
-        elseClauseType->toString());
+    const auto& elseType = argTypes.back();
+
+    if (*elseType != *resultType) {
+      if (allowedCoercions && coercer.coercible(elseType, resultType)) {
+        coercions.back() = resultType;
+      } else if (allowedCoercions && coercer.coercible(resultType, elseType)) {
+        resultType = elseType;
+        setCoercionsUpTo(numArgs - 2, resultType);
+      } else {
+        VELOX_FAIL(
+            "Else clause of a SWITCH statement must have the same type as 'then' clauses. "
+            "Expected {}, but got {}.",
+            resultType->toString(),
+            elseType->toString());
+      }
+    }
   }
 
-  return expressionType;
+  return resultType;
 }
+} // namespace
 
 TypePtr SwitchCallToSpecialForm::resolveType(
     const std::vector<TypePtr>& argTypes) {
-  return SwitchExpr::resolveType(argTypes);
+  return resolveTypeInt(argTypes);
+}
+
+TypePtr SwitchCallToSpecialForm::resolveTypeWithCoercions(
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer) {
+  return resolveTypeInt(argTypes, true, coercions, coercer);
 }
 
 ExprPtr SwitchCallToSpecialForm::constructSpecialForm(
@@ -286,10 +332,21 @@ ExprPtr SwitchCallToSpecialForm::constructSpecialForm(
 
 TypePtr IfCallToSpecialForm::resolveType(const std::vector<TypePtr>& argTypes) {
   VELOX_CHECK(
-      argTypes.size() == 3,
-      "An IF statement must have 3 clauses, the if clause, the then clause, and the else clause. Expected 3, but got {}.",
-      argTypes.size());
+      argTypes.size() == 2 || argTypes.size() == 3,
+      "An IF statement must have 2 or 3 clauses: 'if', 'then', and optional 'else'.");
+
+  return resolveTypeInt(argTypes);
+}
+
+TypePtr IfCallToSpecialForm::resolveTypeWithCoercions(
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer) {
+  VELOX_CHECK_EQ(
+      argTypes.size(),
+      3,
+      "An IF statement must have 3 clauses: 'if', 'then', and 'else'.");
 
-  return SwitchCallToSpecialForm::resolveType(argTypes);
+  return resolveTypeInt(argTypes, true, coercions, coercer);
 }
 } // namespace facebook::velox::exec
diff --git a/velox/expression/SwitchExpr.h b/velox/expression/SwitchExpr.h
index cddbcbce64b..e61824369f2 100644
--- a/velox/expression/SwitchExpr.h
+++ b/velox/expression/SwitchExpr.h
@@ -58,21 +58,26 @@ class SwitchExpr : public SpecialForm {
   }
 
  private:
-  static TypePtr resolveType(const std::vector<TypePtr>& argTypes);
-
   void computePropagatesNulls() override;
 
   const size_t numCases_;
   const bool hasElseClause_;
   BufferPtr tempValues_;
-
-  friend class SwitchCallToSpecialForm;
 };
 
 class SwitchCallToSpecialForm : public FunctionCallToSpecialForm {
  public:
+  /// Returns the type of the 2nd argument. Throws if types of even arguments
+  /// (conditions) are not BOOLEAN or if types of odd arguments (then and else
+  /// branches) don't match.
   TypePtr resolveType(const std::vector<TypePtr>& argTypes) override;
 
+  /// Supports coercions for odd arguments (then and else branches).
+  TypePtr resolveTypeWithCoercions(
+      const std::vector<TypePtr>& argTypes,
+      std::vector<TypePtr>& coercions,
+      const TypeCoercer& coercer) override;
+
   ExprPtr constructSpecialForm(
       const TypePtr& type,
       std::vector<ExprPtr>&& compiledChildren,
@@ -82,6 +87,16 @@ class SwitchCallToSpecialForm : public FunctionCallToSpecialForm {
 
 class IfCallToSpecialForm : public SwitchCallToSpecialForm {
  public:
+  /// Returns the type of the 2nd argument. Throws if number of arguments is not
+  /// 3 or types, type of 1st argument (condition) is not BOOLEAN, or types of
+  /// 2nd (then) and 3rd (else) arguments don't match.
   TypePtr resolveType(const std::vector<TypePtr>& argTypes) override;
+
+  /// Supports coercions for 2nd and 3rd arguments (then and else branches).
+  TypePtr resolveTypeWithCoercions(
+      const std::vector<TypePtr>& argTypes,
+      std::vector<TypePtr>& coercions,
+      const TypeCoercer& coercer) override;
 };
+
 } // namespace facebook::velox::exec
diff --git a/velox/expression/SwitchRewrite.cpp b/velox/expression/SwitchRewrite.cpp
new file mode 100644
index 00000000000..ce46a94ab77
--- /dev/null
+++ b/velox/expression/SwitchRewrite.cpp
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <set>
+
+#include "velox/expression/ExprConstants.h"
+#include "velox/expression/ExprRewriteRegistry.h"
+#include "velox/expression/ExprUtils.h"
+#include "velox/expression/SwitchRewrite.h"
+
+namespace facebook::velox::expression {
+
+core::TypedExprPtr SwitchRewrite::rewrite(const core::TypedExprPtr& expr) {
+  if (!expr->isCallKind()) {
+    return nullptr;
+  }
+  const auto* callExpr = expr->asUnchecked<core::CallTypedExpr>();
+  if (!(callExpr->name() == kSwitch) && !(callExpr->name() == kIf)) {
+    return nullptr;
+  }
+
+  const auto& inputs = expr->inputs();
+  const auto numInputs = inputs.size();
+  std::vector<core::TypedExprPtr> optimizedInputs;
+
+  // Iterate over all `(condition, value)` pairs. Handle `else` value at the
+  // end.
+  for (auto i = 0; i < numInputs - 1; i += 2) {
+    const auto& condition = inputs.at(i);
+    const auto& value = inputs.at(i + 1);
+
+    if (condition->isConstantKind()) {
+      const auto* constCondition =
+          condition->asUnchecked<core::ConstantTypedExpr>();
+      if (auto boolCondition = constCondition->toBool()) {
+        if (boolCondition.value()) {
+          // If this condition is true and all conditions before this are false,
+          // simplify `switch` expression to the corresponding `value`.
+          if (optimizedInputs.empty()) {
+            return value;
+          }
+          // If this condition is true and all conditions before this can only
+          // be evaluated at runtime, make this the new `else` value and stop
+          // checking further conditions.
+          optimizedInputs.push_back(value);
+          break;
+        } else {
+          // Skip false conditions.
+          continue;
+        }
+      } else {
+        // Skip NULL conditions.
+        continue;
+      }
+    } else {
+      optimizedInputs.push_back(condition);
+      optimizedInputs.push_back(value);
+    }
+  }
+
+  // Handle `else` value if present.
+  if (optimizedInputs.size() % 2 == 0 && numInputs % 2 == 1) {
+    const auto elseValue = inputs.at(numInputs - 1);
+    // Return `else` value if there are no conditions.
+    if (optimizedInputs.empty()) {
+      return elseValue;
+    }
+    optimizedInputs.emplace_back(elseValue);
+  }
+  // Return NULL if there are no conditions and `else` value is not present.
+  if (optimizedInputs.empty()) {
+    return core::ConstantTypedExpr::makeNull(expr->type());
+  }
+
+  return std::make_shared<core::CallTypedExpr>(
+      expr->type(), std::move(optimizedInputs), callExpr->name());
+}
+
+void SwitchRewrite::registerRewrite() {
+  expression::ExprRewriteRegistry::instance().registerRewrite(
+      expression::SwitchRewrite::rewrite);
+}
+
+} // namespace facebook::velox::expression
diff --git a/velox/expression/SwitchRewrite.h b/velox/expression/SwitchRewrite.h
new file mode 100644
index 00000000000..31e1df96beb
--- /dev/null
+++ b/velox/expression/SwitchRewrite.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/core/Expressions.h"
+
+namespace facebook::velox::expression {
+
+class SwitchRewrite {
+ public:
+  /// Rewrites SWITCH and IF special form expressions which have the shape
+  /// `SWITCH(condition1, value1, condition2, value2, .., conditionN, valueN, ..
+  /// .., optional<elseValue>)`, and `IF(condition, trueValue, falseValue)`
+  /// respectively. IF expression is rewritten to `trueValue` or `falseValue`
+  /// if `condition` is either true or false respectively. The conditions of
+  /// SWITCH expression are traversed in order and if the condition is:
+  ///  1. false, it is removed from the inputs along with its corresponding
+  ///     value.
+  ///  2. true: If there are no inputs before this, the corresponding value
+  ///     is returned. Otherwise, the corresponding value is the new else value
+  ///     and all subsequent inputs are ignored.
+  ///  3. not a constant boolean and it cannot be evaluated without input data,
+  ///     the condition and its corresponding value are retained in the inputs.
+  /// If there are no conditions in the expression now, the else value is
+  /// returned if it is present; otherwise NULL is returned. The else value is
+  /// added to the inputs otherwise and the optimized SWITCH expression with
+  /// pruned inputs is returned.
+  static core::TypedExprPtr rewrite(const core::TypedExprPtr& expr);
+
+  static void registerRewrite();
+};
+
+} // namespace facebook::velox::expression
diff --git a/velox/expression/TypeSignature.cpp b/velox/expression/TypeSignature.cpp
index ba5385fb914..422e3b68d8e 100644
--- a/velox/expression/TypeSignature.cpp
+++ b/velox/expression/TypeSignature.cpp
@@ -30,7 +30,11 @@ std::string TypeSignature::toString() const {
   }
   out << baseName_;
   if (!parameters_.empty()) {
-    out << "(" << folly::join(",", parameters_) << ")";
+    if (isHomogeneousRow()) {
+      out << "(" << parameters_[0].toString() << ", ..." << ")";
+    } else {
+      out << "(" << folly::join(",", parameters_) << ")";
+    }
   }
   return out.str();
 }
diff --git a/velox/expression/TypeSignature.h b/velox/expression/TypeSignature.h
index a8f66eb41fe..13ae2bfad49 100644
--- a/velox/expression/TypeSignature.h
+++ b/velox/expression/TypeSignature.h
@@ -33,13 +33,16 @@ class TypeSignature {
   /// @param rowFieldName if this type signature is a field of another parent
   /// row type, it can optionally have a name. E.g. `row(id bigint)` would have
   /// "id" set as rowFieldName in the "bigint" parameter.
+  /// @param variableArity indicates if the last parameter is variadic.
   TypeSignature(
       std::string baseName,
       std::vector<TypeSignature> parameters,
-      std::optional<std::string> rowFieldName = std::nullopt)
+      std::optional<std::string> rowFieldName = std::nullopt,
+      bool variableArity = false)
       : baseName_{std::move(baseName)},
         parameters_{std::move(parameters)},
-        rowFieldName_(std::move(rowFieldName)) {}
+        rowFieldName_(std::move(rowFieldName)),
+        variableArity_{variableArity} {}
 
   const std::string& baseName() const {
     return baseName_;
@@ -53,11 +56,20 @@ class TypeSignature {
     return rowFieldName_;
   }
 
+  bool variableArity() const {
+    return variableArity_;
+  }
+
+  bool isHomogeneousRow() const {
+    return baseName_ == "row" && parameters_.size() == 1 && variableArity_;
+  }
+
   std::string toString() const;
 
   bool operator==(const TypeSignature& rhs) const {
     return baseName_ == rhs.baseName_ && parameters_ == rhs.parameters_ &&
-        rowFieldName_ == rhs.rowFieldName_;
+        rowFieldName_ == rhs.rowFieldName_ &&
+        variableArity_ == rhs.variableArity_;
   }
 
  private:
@@ -67,6 +79,9 @@ class TypeSignature {
   // If this object is a field of another parent row type, it can optionally
   // have a name, e.g, `row(id bigint)`
   const std::optional<std::string> rowFieldName_;
+
+  // Indicates if the parameter is variadic.
+  const bool variableArity_;
 };
 
 using TypeSignaturePtr = std::shared_ptr<TypeSignature>;
diff --git a/velox/expression/UdfTypeResolver.h b/velox/expression/UdfTypeResolver.h
index b27c197dbdb..7d26f4d7ce1 100644
--- a/velox/expression/UdfTypeResolver.h
+++ b/velox/expression/UdfTypeResolver.h
@@ -150,6 +150,20 @@ struct resolver<IntervalYearMonth> {
   using out_type = int32_t;
 };
 
+template <>
+struct resolver<Time> {
+  using in_type = int64_t;
+  using null_free_in_type = in_type;
+  using out_type = int64_t;
+};
+
+template <>
+struct resolver<TimeMicroUtc> {
+  using in_type = int64_t;
+  using null_free_in_type = in_type;
+  using out_type = int64_t;
+};
+
 template <typename T>
 struct resolver<std::shared_ptr<T>> {
   using in_type = std::shared_ptr<T>;
diff --git a/velox/expression/VectorFunction.cpp b/velox/expression/VectorFunction.cpp
index 79ca2c6051b..d4f37ac0092 100644
--- a/velox/expression/VectorFunction.cpp
+++ b/velox/expression/VectorFunction.cpp
@@ -101,21 +101,56 @@ bool hasCoercion(const std::vector<Coercion>& coercions) {
 TypePtr resolveVectorFunctionWithCoercions(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes,
-    std::vector<TypePtr>& coercions) {
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer) {
+  if (auto result = resolveVectorFunctionWithMetadataWithCoercions(
+          functionName, argTypes, coercions, coercer)) {
+    return result->first;
+  }
+
+  return nullptr;
+}
+
+std::optional<std::pair<TypePtr, VectorFunctionMetadata>>
+resolveVectorFunctionWithMetadata(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes) {
+  return applyToVectorFunctionEntry<std::pair<TypePtr, VectorFunctionMetadata>>(
+      functionName,
+      [&](const auto& /*name*/, const auto& entry)
+          -> std::optional<std::pair<TypePtr, VectorFunctionMetadata>> {
+        for (const auto& signature : entry.signatures) {
+          exec::SignatureBinder binder(
+              *signature, argTypes, TypeCoercer::defaults());
+          if (binder.tryBind()) {
+            return {{binder.tryResolveReturnType(), entry.metadata}};
+          }
+        }
+        return std::nullopt;
+      });
+}
+
+std::optional<std::pair<TypePtr, VectorFunctionMetadata>>
+resolveVectorFunctionWithMetadataWithCoercions(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer) {
   coercions.clear();
 
-  auto optionalType = applyToVectorFunctionEntry<TypePtr>(
+  return applyToVectorFunctionEntry<std::pair<TypePtr, VectorFunctionMetadata>>(
       functionName,
-      [&](const auto& /*name*/, const auto& entry) -> std::optional<TypePtr> {
+      [&](const auto& /*name*/, const auto& entry)
+          -> std::optional<std::pair<TypePtr, VectorFunctionMetadata>> {
         std::vector<std::pair<std::vector<Coercion>, TypePtr>> candidates;
         for (const auto& signature : entry.signatures) {
-          exec::SignatureBinder binder(*signature, argTypes);
+          exec::SignatureBinder binder(*signature, argTypes, coercer);
           std::vector<Coercion> requiredCoercions;
           if (binder.tryBindWithCoercions(requiredCoercions)) {
             auto type = binder.tryResolveReturnType();
             if (!hasCoercion(requiredCoercions)) {
               coercions.resize(argTypes.size(), nullptr);
-              return type;
+              return {{type, entry.metadata}};
             }
 
             candidates.emplace_back(requiredCoercions, type);
@@ -129,31 +164,11 @@ TypePtr resolveVectorFunctionWithCoercions(
             coercions.push_back(coercion.type);
           }
 
-          return candidates[index.value()].second;
+          return {{candidates[index.value()].second, entry.metadata}};
         }
 
         return std::nullopt;
       });
-
-  return optionalType.value_or(nullptr);
-}
-
-std::optional<std::pair<TypePtr, VectorFunctionMetadata>>
-resolveVectorFunctionWithMetadata(
-    const std::string& functionName,
-    const std::vector<TypePtr>& argTypes) {
-  return applyToVectorFunctionEntry<std::pair<TypePtr, VectorFunctionMetadata>>(
-      functionName,
-      [&](const auto& /*name*/, const auto& entry)
-          -> std::optional<std::pair<TypePtr, VectorFunctionMetadata>> {
-        for (const auto& signature : entry.signatures) {
-          exec::SignatureBinder binder(*signature, argTypes);
-          if (binder.tryBind()) {
-            return {{binder.tryResolveReturnType(), entry.metadata}};
-          }
-        }
-        return std::nullopt;
-      });
 }
 
 std::shared_ptr<VectorFunction> getVectorFunction(
@@ -188,7 +203,8 @@ getVectorFunctionWithMetadata(
               std::shared_ptr<VectorFunction>,
               VectorFunctionMetadata>> {
         for (const auto& signature : entry.signatures) {
-          exec::SignatureBinder binder(*signature, inputTypes);
+          exec::SignatureBinder binder(
+              *signature, inputTypes, TypeCoercer::defaults());
           if (binder.tryBind()) {
             auto inputArgs = toVectorFunctionArgs(inputTypes, constantInputs);
 
@@ -205,7 +221,7 @@ getVectorFunctionWithMetadata(
 /// with the given name will be replaced.
 /// Returns true iff an insertion actually happened
 bool registerStatefulVectorFunction(
-    const std::string& name,
+    std::string_view name,
     std::vector<FunctionSignaturePtr> signatures,
     VectorFunctionFactory factory,
     VectorFunctionMetadata metadata,
@@ -231,7 +247,7 @@ bool registerStatefulVectorFunction(
 
 // Returns true iff an insertion actually happened
 bool registerVectorFunction(
-    const std::string& name,
+    std::string_view name,
     std::vector<FunctionSignaturePtr> signatures,
     std::unique_ptr<VectorFunction> func,
     VectorFunctionMetadata metadata,
@@ -245,13 +261,4 @@ bool registerVectorFunction(
       name, signatures, factory, metadata, overwrite);
 }
 
-std::vector<ExpressionRewrite>& expressionRewrites() {
-  static std::vector<ExpressionRewrite> rewrites;
-  return rewrites;
-}
-
-void registerExpressionRewrite(ExpressionRewrite rewrite) {
-  expressionRewrites().emplace_back(rewrite);
-}
-
 } // namespace facebook::velox::exec
diff --git a/velox/expression/VectorFunction.h b/velox/expression/VectorFunction.h
index 1e3e4c4476f..00daea23c73 100644
--- a/velox/expression/VectorFunction.h
+++ b/velox/expression/VectorFunction.h
@@ -16,11 +16,13 @@
 
 #pragma once
 
+#include <string_view>
 #include <vector>
 #include "velox/core/ITypedExpr.h"
 #include "velox/expression/EvalCtx.h"
 #include "velox/expression/FunctionMetadata.h"
 #include "velox/expression/FunctionSignature.h"
+#include "velox/type/TypeCoercer.h"
 #include "velox/vector/SelectivityVector.h"
 #include "velox/vector/SimpleVector.h"
 
@@ -166,7 +168,8 @@ class SimpleFunctionAdapterFactory {
   virtual std::unique_ptr<VectorFunction> createVectorFunction(
       const std::vector<TypePtr>& inputTypes,
       const std::vector<VectorPtr>& constantInputs,
-      const core::QueryConfig& config) const = 0;
+      const core::QueryConfig& config,
+      memory::MemoryPool* memoryPool = nullptr) const = 0;
   virtual ~SimpleFunctionAdapterFactory() = default;
 };
 
@@ -190,13 +193,28 @@ TypePtr resolveVectorFunction(
 TypePtr resolveVectorFunctionWithCoercions(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes,
-    std::vector<TypePtr>& coercions);
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer);
 
 std::optional<std::pair<TypePtr, VectorFunctionMetadata>>
 resolveVectorFunctionWithMetadata(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes);
 
+/// Like 'resolveVectorFunctionWithMetadata', but with support for applying type
+/// coercions if no signature matches 'argTypes' exactly.
+///
+/// @param coercions A list of optional type coercions that were applied to
+/// resolve the function successfully. Contains one entry per argument. The
+/// entry is null if no coercion is required for that argument. The entry is not
+/// null if coercion is necessary.
+std::optional<std::pair<TypePtr, VectorFunctionMetadata>>
+resolveVectorFunctionWithMetadataWithCoercions(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer);
+
 /// Returns an instance of VectorFunction for the given name, input types and
 /// optionally constant input values.
 /// constantInputs should be empty if there are no constant inputs.
@@ -221,7 +239,7 @@ getVectorFunctionWithMetadata(
 /// expressions.
 /// Returns true iff an new function is inserted
 bool registerVectorFunction(
-    const std::string& name,
+    std::string_view name,
     std::vector<FunctionSignaturePtr> signatures,
     std::unique_ptr<VectorFunction> func,
     VectorFunctionMetadata metadata = {},
@@ -273,28 +291,12 @@ VectorFunctionFactory makeVectorFunctionFactory() {
 // name is replaced.
 // Returns true iff the function was inserted
 bool registerStatefulVectorFunction(
-    const std::string& name,
+    std::string_view name,
     std::vector<FunctionSignaturePtr> signatures,
     VectorFunctionFactory factory,
     VectorFunctionMetadata metadata = {},
     bool overwrite = true);
 
-/// An expression re-writer that takes an expression and returns an equivalent
-/// expression or nullptr if re-write is not possible.
-using ExpressionRewrite = std::function<core::TypedExprPtr(core::TypedExprPtr)>;
-
-/// Returns a list of registered re-writes.
-std::vector<ExpressionRewrite>& expressionRewrites();
-
-/// Appends a 'rewrite' to 'expressionRewrites'.
-///
-/// The logic that applies re-writes is very simple and assumes that all
-/// rewrites are independent. Re-writes are applied to all expressions starting
-/// at the root and going down the hierarchy. For each expression, rewrites are
-/// applied in the order they were registered. The first rewrite that returns
-/// non-null result terminates the re-write for this particular expression.
-void registerExpressionRewrite(ExpressionRewrite rewrite);
-
 } // namespace facebook::velox::exec
 
 // Private. Return the external function name given a UDF tag.
@@ -302,36 +304,36 @@ void registerExpressionRewrite(ExpressionRewrite rewrite);
 
 // Declares a vectorized UDF function given a tag. Goes into the UDF .cpp file.
 #define VELOX_DECLARE_VECTOR_FUNCTION(tag, signatures, function) \
-  void _VELOX_REGISTER_FUNC_NAME(tag)(const std::string& name) { \
+  void _VELOX_REGISTER_FUNC_NAME(tag)(std::string_view name) {   \
     facebook::velox::exec::registerVectorFunction(               \
         (name), (signatures), (function));                       \
   }
 
-#define VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(             \
-    tag, signatures, metadata, function)                         \
-  void _VELOX_REGISTER_FUNC_NAME(tag)(const std::string& name) { \
-    facebook::velox::exec::registerVectorFunction(               \
-        (name), (signatures), (function), (metadata));           \
+#define VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(           \
+    tag, signatures, metadata, function)                       \
+  void _VELOX_REGISTER_FUNC_NAME(tag)(std::string_view name) { \
+    facebook::velox::exec::registerVectorFunction(             \
+        (name), (signatures), (function), (metadata));         \
   }
 
 // Declares a stateful vectorized UDF.
 #define VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(tag, signatures, function) \
-  void _VELOX_REGISTER_FUNC_NAME(tag)(const std::string& name) {          \
+  void _VELOX_REGISTER_FUNC_NAME(tag)(std::string_view name) {            \
     facebook::velox::exec::registerStatefulVectorFunction(                \
         (name), (signatures), (function));                                \
   }
 
-#define VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION_WITH_METADATA(    \
-    tag, signatures, metadata, function)                         \
-  void _VELOX_REGISTER_FUNC_NAME(tag)(const std::string& name) { \
-    facebook::velox::exec::registerStatefulVectorFunction(       \
-        (name), (signatures), (function), (metadata));           \
+#define VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION_WITH_METADATA(  \
+    tag, signatures, metadata, function)                       \
+  void _VELOX_REGISTER_FUNC_NAME(tag)(std::string_view name) { \
+    facebook::velox::exec::registerStatefulVectorFunction(     \
+        (name), (signatures), (function), (metadata));         \
   }
 
 // Registers a vectorized UDF associated with a given tag.
 // This should be used in the same namespace the declare macro is used in.
-#define VELOX_REGISTER_VECTOR_FUNCTION(tag, name)                   \
-  {                                                                 \
-    extern void _VELOX_REGISTER_FUNC_NAME(tag)(const std::string&); \
-    _VELOX_REGISTER_FUNC_NAME(tag)(name);                           \
+#define VELOX_REGISTER_VECTOR_FUNCTION(tag, name)                 \
+  {                                                               \
+    extern void _VELOX_REGISTER_FUNC_NAME(tag)(std::string_view); \
+    _VELOX_REGISTER_FUNC_NAME(tag)(name);                         \
   }
diff --git a/velox/expression/VectorFunctionListener.cpp b/velox/expression/VectorFunctionListener.cpp
new file mode 100644
index 00000000000..d69ab88b774
--- /dev/null
+++ b/velox/expression/VectorFunctionListener.cpp
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/expression/VectorFunctionListener.h"
+
+#include <folly/Synchronized.h>
+
+namespace facebook::velox::exec {
+
+namespace {
+
+folly::Synchronized<
+    std::vector<std::shared_ptr<VectorFunctionListenerFactory>>>&
+listenerFactories() {
+  static folly::Synchronized<
+      std::vector<std::shared_ptr<VectorFunctionListenerFactory>>>
+      kFactories;
+  return kFactories;
+}
+
+} // namespace
+
+bool registerVectorFunctionListenerFactory(
+    std::shared_ptr<VectorFunctionListenerFactory> factory) {
+  return listenerFactories().withWLock([&](auto& factories) {
+    for (const auto& existing : factories) {
+      if (existing == factory) {
+        return false;
+      }
+    }
+    factories.emplace_back(std::move(factory));
+    return true;
+  });
+}
+
+bool unregisterVectorFunctionListenerFactory(
+    const std::shared_ptr<VectorFunctionListenerFactory>& factory) {
+  return listenerFactories().withWLock([&](auto& factories) {
+    for (auto it = factories.begin(); it != factories.end(); ++it) {
+      if (*it == factory) {
+        factories.erase(it);
+        return true;
+      }
+    }
+    return false;
+  });
+}
+
+std::vector<VectorFunctionListeners> createVectorFunctionListeners(
+    std::string_view name,
+    const VectorFunctionMetadata& metadata,
+    const core::QueryConfig& queryConfig) {
+  std::vector<VectorFunctionListeners> listeners;
+  listenerFactories().withRLock([&](const auto& factories) {
+    for (const auto& factory : factories) {
+      if (auto result = factory->create(name, metadata, queryConfig)) {
+        listeners.push_back(std::move(*result));
+      }
+    }
+  });
+  return listeners;
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/expression/VectorFunctionListener.h b/velox/expression/VectorFunctionListener.h
new file mode 100644
index 00000000000..0a7fb20d7f1
--- /dev/null
+++ b/velox/expression/VectorFunctionListener.h
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string_view>
+#include <vector>
+
+#include "velox/expression/FunctionMetadata.h"
+
+namespace facebook::velox {
+class BaseVector;
+class Type;
+class SelectivityVector;
+} // namespace facebook::velox
+
+namespace facebook::velox::core {
+class QueryConfig;
+} // namespace facebook::velox::core
+
+/// Listener infrastructure for observing VectorFunction::apply calls during
+/// expression evaluation.
+///
+/// Listeners are registered globally via registerVectorFunctionListenerFactory.
+/// During expression compilation, ExprCompiler iterates all registered
+/// factories, calling create() once per resolved scalar function with the
+/// function name, metadata, and QueryConfig. Each factory may return a
+/// VectorFunctionListeners struct containing pre and/or post listeners, or
+/// std::nullopt to skip that function. Returned listeners are stored on the
+/// Expr node and invoked around every VectorFunction::apply call in both the
+/// standard (applyFunction) and simplified (evalSimplifiedImpl) evaluation
+/// paths. Special forms (AND, OR, CAST, etc.) are not subject to listening.
+///
+/// Multiple factories can be registered independently, each observing
+/// different concerns (monitoring, access control, auditing, etc.) without
+/// coordination.
+
+namespace facebook::velox::exec {
+
+class EvalCtx;
+
+/// Callback invoked before VectorFunction::apply.
+using PreApplyListener = std::function<void(
+    std::string_view functionName,
+    const SelectivityVector& rows,
+    const std::vector<std::shared_ptr<BaseVector>>& args,
+    const std::shared_ptr<const Type>& outputType,
+    const EvalCtx& context)>;
+
+/// Callback invoked after VectorFunction::apply, regardless of whether apply
+/// succeeded or threw. When apply throws, 'error' holds the exception;
+/// otherwise it is nullptr. The 'error' exception is always rethrown by the
+/// framework after all post-listeners have executed. If a post-listener itself
+/// throws, the exception is caught, logged periodically, and remaining
+/// post-listeners still execute.
+using PostApplyListener = std::function<void(
+    std::string_view functionName,
+    const SelectivityVector& rows,
+    const std::vector<std::shared_ptr<BaseVector>>& args,
+    const std::shared_ptr<const Type>& outputType,
+    const EvalCtx& context,
+    const std::shared_ptr<BaseVector>& result,
+    std::exception_ptr error)>;
+
+/// Pre/post listeners returned by VectorFunctionListenerFactory. Stored as
+/// shared_ptrs so multiple Expr instances can reference the same listener
+/// without copying.
+struct VectorFunctionListeners {
+  /// Called before vectorFunction_->apply(); may be null.
+  std::shared_ptr<const PreApplyListener> pre;
+  /// Called after vectorFunction_->apply() regardless of outcome; may be null.
+  std::shared_ptr<const PostApplyListener> post;
+};
+
+/// Factory that optionally creates pre/post listeners for a given function.
+/// Called once per function during expression compilation. Returns
+/// std::nullopt to skip listening for that function.
+class VectorFunctionListenerFactory {
+ public:
+  virtual ~VectorFunctionListenerFactory() = default;
+
+  virtual std::optional<VectorFunctionListeners> create(
+      std::string_view name,
+      const VectorFunctionMetadata& metadata,
+      const core::QueryConfig& queryConfig) = 0;
+};
+
+/// Registers a listener factory globally. Returns true if the factory was
+/// newly added, false if it was already registered.
+bool registerVectorFunctionListenerFactory(
+    std::shared_ptr<VectorFunctionListenerFactory> factory);
+
+/// Unregisters a previously registered listener factory. Returns true if the
+/// factory was found and removed.
+bool unregisterVectorFunctionListenerFactory(
+    const std::shared_ptr<VectorFunctionListenerFactory>& factory);
+
+/// Iterates all registered factories and collects listeners for the given
+/// function. Called by ExprCompiler during expression compilation.
+std::vector<VectorFunctionListeners> createVectorFunctionListeners(
+    std::string_view name,
+    const VectorFunctionMetadata& metadata,
+    const core::QueryConfig& queryConfig);
+
+} // namespace facebook::velox::exec
diff --git a/velox/expression/VectorReaders.h b/velox/expression/VectorReaders.h
index b042b04c3a3..bf8cc6150f4 100644
--- a/velox/expression/VectorReaders.h
+++ b/velox/expression/VectorReaders.h
@@ -115,7 +115,7 @@ struct ConstantVectorReader {
 
   std::optional<exec_in_t> value;
 
-  explicit ConstantVectorReader<T>(ConstantVector<exec_in_t>& vector) {
+  explicit ConstantVectorReader(ConstantVector<exec_in_t>& vector) {
     if (!vector.isNullAt(0)) {
       value = *vector.rawValues();
     }
@@ -160,7 +160,7 @@ struct FlatVectorReader {
   const exec_in_t* values;
   FlatVector<exec_in_t>* vector;
 
-  explicit FlatVectorReader<T>(FlatVector<exec_in_t>& baseVector)
+  explicit FlatVectorReader(FlatVector<exec_in_t>& baseVector)
       : values(baseVector.rawValues()), vector(&baseVector) {}
 
   exec_in_t operator[](vector_size_t offset) const {
@@ -560,6 +560,11 @@ struct VectorReader<Variadic<T>> {
       int32_t startPosition)
       : childReaders_{prepareChildReaders(decodedArgs, startPosition)} {}
 
+  explicit VectorReader(
+      const std::vector<DecodedVector>& decodedVecs,
+      int32_t startPosition)
+      : childReaders_{prepareChildReaders(decodedVecs, startPosition)} {}
+
   exec_in_t operator[](vector_size_t offset) const {
     return {&childReaders_, offset};
   }
@@ -574,6 +579,18 @@ struct VectorReader<Variadic<T>> {
     return true;
   }
 
+  // Returns true if any immediate variadic element is null at the given row.
+  // Unlike containsNull(), this checks only the top-level nullity of each
+  // element, not recursive nulls within complex types.
+  bool hasTopLevelNull(vector_size_t index) const {
+    for (const auto& childReader : childReaders_) {
+      if (!childReader->isSet(index)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   bool containsNull(vector_size_t index) const {
     for (const auto& childReader : childReaders_) {
       if (childReader->containsNull(index)) {
@@ -634,6 +651,18 @@ struct VectorReader<Variadic<T>> {
     return childReaders;
   }
 
+  auto prepareChildReaders(
+      const std::vector<DecodedVector>& decodedArgs,
+      int32_t startPosition) {
+    std::vector<std::unique_ptr<VectorReader<T>>> childReaders;
+    childReaders.reserve(decodedArgs.size());
+    for (int i = startPosition; i < decodedArgs.size(); ++i) {
+      childReaders.emplace_back(
+          std::make_unique<VectorReader<T>>(&decodedArgs[i]));
+    }
+    return childReaders;
+  }
+
   std::vector<std::unique_ptr<VectorReader<T>>> childReaders_;
 };
 
@@ -733,8 +762,9 @@ struct VectorReader<DynamicRow> {
         vector_(detail::getDecoded<in_vector_t>(decoded_)),
         childrenDecoders_{vector_.childrenSize()} {
     for (int i = 0; i < vector_.childrenSize(); i++) {
-      childReaders_.push_back(std::make_unique<VectorReader<Any>>(
-          detail::decode(childrenDecoders_[i], *vector_.childAt(i))));
+      childReaders_.push_back(
+          std::make_unique<VectorReader<Any>>(
+              detail::decode(childrenDecoders_[i], *vector_.childAt(i))));
     }
   }
 
diff --git a/velox/expression/VectorWriters.h b/velox/expression/VectorWriters.h
index a045b2cf1df..da5d19fb77d 100644
--- a/velox/expression/VectorWriters.h
+++ b/velox/expression/VectorWriters.h
@@ -340,8 +340,9 @@ struct VectorWriter<Row<T...>> : public VectorWriterBase {
     } else {
       using type = std::tuple_element_t<I, children_types>;
       std::get<I>(writer_.childrenWriters_)
-          .init(static_cast<typename TypeToFlatVector<type>::type&>(
-              *rowVector_->childAt(I).get()));
+          .init(
+              static_cast<typename TypeToFlatVector<type>::type&>(
+                  *rowVector_->childAt(I).get()));
 
       initVectorWriters<I + 1>();
     }
diff --git a/velox/expression/benchmarks/CallNullFreeBenchmark.cpp b/velox/expression/benchmarks/CallNullFreeBenchmark.cpp
index a1498b87806..e9380930e4c 100644
--- a/velox/expression/benchmarks/CallNullFreeBenchmark.cpp
+++ b/velox/expression/benchmarks/CallNullFreeBenchmark.cpp
@@ -23,8 +23,13 @@
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 
 // These macros should be set, defined in command line.
-// #define WITH_NULL_ARRAYS false
-// #define WITH_NULL_VALUES false
+#ifndef WITH_NULL_ARRAYS
+#define WITH_NULL_ARRAYS false
+#endif
+
+#ifndef WITH_NULL_ELEMENTS
+#define WITH_NULL_ELEMENTS false
+#endif
 
 // Benchmark a function that returns the minimum value in an array.
 // The function returns NULL if the array or any of its elements are NULL.
@@ -283,7 +288,7 @@ class CallNullFreeBenchmark : public functions::test::FunctionBenchmarkBase {
       auto other =
           compileExpression(fmt::format("{}(c0)", name), input->type());
       if (!hasSameResults(fastResult, other, input)) {
-        VELOX_UNREACHABLE(fmt::format("testing failed at function {}", name));
+        VELOX_UNREACHABLE("Testing failed at function: {}", name);
       }
     }
   }
diff --git a/velox/expression/benchmarks/CpuTimeTrackingBenchmark.cpp b/velox/expression/benchmarks/CpuTimeTrackingBenchmark.cpp
new file mode 100644
index 00000000000..c7bad3a1b57
--- /dev/null
+++ b/velox/expression/benchmarks/CpuTimeTrackingBenchmark.cpp
@@ -0,0 +1,425 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/// Microbenchmark to measure the overhead of CPU time tracking
+/// (expression.track_cpu_usage) and adaptive per-function sampling
+/// (expression.adaptive_cpu_sampling) on simple scalar function evaluation.
+///
+/// CPU time tracking uses clock_gettime(CLOCK_THREAD_CPUTIME_ID) on every
+/// function invocation, which can be expensive relative to the function body
+/// for cheap functions like multiply. Adaptive sampling calibrates per-function
+/// overhead and applies variable sampling rates to keep overhead bounded.
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+#include <gflags/gflags.h>
+
+#include "velox/functions/Macros.h"
+#include "velox/functions/Registerer.h"
+#include "velox/functions/lib/benchmarks/FunctionBenchmarkBase.h"
+#include "velox/functions/prestosql/ArithmeticImpl.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+DEFINE_int64(
+    fuzzer_seed,
+    99'887'766,
+    "Seed for random input dataset generator");
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+
+namespace {
+
+template <typename T>
+struct MultiplyFunction {
+  template <typename TInput>
+  FOLLY_ALWAYS_INLINE void
+  call(TInput& result, const TInput& a, const TInput& b) {
+    result = functions::multiply(a, b);
+  }
+};
+
+/// Element-wise >= comparison on two int64 arrays. Mirrors the core logic of
+/// array_gte UDF — a representative "expensive" function because it
+/// iterates over array elements, allocates an output array, and touches more
+/// memory per row than a simple scalar op like multiply.
+template <typename T>
+struct ArrayGteFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void callNullFree(
+      out_type<Array<bool>>& out,
+      const null_free_arg_type<Array<int64_t>>& lhs,
+      const null_free_arg_type<Array<int64_t>>& rhs) {
+    auto size = std::min(lhs.size(), rhs.size());
+    out.reserve(size);
+    for (auto i = 0; i < size; ++i) {
+      out.push_back(lhs[i] >= rhs[i]);
+    }
+  }
+};
+
+class CpuTimeTrackingBenchmark : public functions::test::FunctionBenchmarkBase {
+ public:
+  CpuTimeTrackingBenchmark() : FunctionBenchmarkBase() {
+    registerFunction<MultiplyFunction, double, double, double>({"multiply"});
+
+    inputType_ = ROW({{"a", DOUBLE()}, {"b", DOUBLE()}});
+
+    smallRowVector_ = makeRowVector(100);
+    mediumRowVector_ = makeRowVector(1'000);
+    largeRowVector_ = makeRowVector(10'000);
+
+    // Compile with CPU tracking OFF (default).
+    exprSetNoTracking_ = compileWithConfig({
+        {core::QueryConfig::kExprTrackCpuUsage, "false"},
+    });
+
+    // Compile with CPU tracking ON.
+    exprSetWithTracking_ = compileWithConfig({
+        {core::QueryConfig::kExprTrackCpuUsage, "true"},
+    });
+
+    // Compile with adaptive CPU sampling (1% max overhead).
+    exprSetAdaptive1Pct_ = compileWithConfig({
+        {core::QueryConfig::kExprTrackCpuUsage, "false"},
+        {core::QueryConfig::kExprAdaptiveCpuSampling, "true"},
+        {core::QueryConfig::kExprAdaptiveCpuSamplingMaxOverheadPct, "1.0"},
+    });
+
+    // Compile with adaptive CPU sampling (0.5% max overhead).
+    exprSetAdaptiveHalfPct_ = compileWithConfig({
+        {core::QueryConfig::kExprTrackCpuUsage, "false"},
+        {core::QueryConfig::kExprAdaptiveCpuSampling, "true"},
+        {core::QueryConfig::kExprAdaptiveCpuSamplingMaxOverheadPct, "0.5"},
+    });
+  }
+
+  void runNoTracking(const RowVectorPtr& input, size_t iterations) {
+    run(*exprSetNoTracking_, input, iterations);
+  }
+
+  void runWithTracking(const RowVectorPtr& input, size_t iterations) {
+    run(*exprSetWithTracking_, input, iterations);
+  }
+
+  void runAdaptive1Pct(const RowVectorPtr& input, size_t iterations) {
+    run(*exprSetAdaptive1Pct_, input, iterations);
+  }
+
+  void runAdaptiveHalfPct(const RowVectorPtr& input, size_t iterations) {
+    run(*exprSetAdaptiveHalfPct_, input, iterations);
+  }
+
+  RowVectorPtr smallRowVector_;
+  RowVectorPtr mediumRowVector_;
+  RowVectorPtr largeRowVector_;
+
+ private:
+  RowVectorPtr makeRowVector(vector_size_t size) {
+    VectorFuzzer::Options opts;
+    opts.vectorSize = size;
+    opts.nullRatio = 0;
+    VectorFuzzer fuzzer(opts, pool(), FLAGS_fuzzer_seed);
+
+    std::vector<VectorPtr> children;
+    children.emplace_back(fuzzer.fuzzFlat(DOUBLE()));
+    children.emplace_back(fuzzer.fuzzFlat(DOUBLE()));
+    return std::make_shared<RowVector>(
+        pool(), inputType_, nullptr, size, std::move(children));
+  }
+
+  std::unique_ptr<ExprSet> compileWithConfig(
+      std::unordered_map<std::string, std::string> config) {
+    queryCtx_->testingOverrideConfigUnsafe(std::move(config));
+    return std::make_unique<ExprSet>(
+        compileExpression("multiply(a, b)", inputType_));
+  }
+
+  void run(ExprSet& exprSet, const RowVectorPtr& input, size_t iterations) {
+    folly::BenchmarkSuspender suspender;
+    SelectivityVector rows(input->size());
+    suspender.dismiss();
+
+    std::vector<VectorPtr> results(1);
+    size_t count{0};
+    for (size_t i = 0; i < iterations; ++i) {
+      EvalCtx evalCtx(&execCtx_, &exprSet, input.get());
+      exprSet.eval(rows, evalCtx, results);
+      count += results[0]->size();
+      results[0]->prepareForReuse();
+    }
+    folly::doNotOptimizeAway(count);
+  }
+
+  TypePtr inputType_;
+  std::unique_ptr<ExprSet> exprSetNoTracking_;
+  std::unique_ptr<ExprSet> exprSetWithTracking_;
+  std::unique_ptr<ExprSet> exprSetAdaptive1Pct_;
+  std::unique_ptr<ExprSet> exprSetAdaptiveHalfPct_;
+};
+
+/// Benchmark for array_gte — an expensive UDF that iterates over array
+/// elements. Measures CPU tracking and adaptive sampling overhead on a function
+/// whose per-row cost is much higher than a simple scalar op.
+class ArrayGteBenchmark : public functions::test::FunctionBenchmarkBase {
+ public:
+  ArrayGteBenchmark() : FunctionBenchmarkBase() {
+    registerFunction<
+        ArrayGteFunction,
+        Array<bool>,
+        Array<int64_t>,
+        Array<int64_t>>({"array_gte"});
+
+    inputType_ = ROW({{"a", ARRAY(BIGINT())}, {"b", ARRAY(BIGINT())}});
+
+    smallRowVector_ = makeRowVector(100);
+    mediumRowVector_ = makeRowVector(1'000);
+    largeRowVector_ = makeRowVector(10'000);
+
+    exprSetNoTracking_ = compileWithConfig({
+        {core::QueryConfig::kExprTrackCpuUsage, "false"},
+    });
+    exprSetWithTracking_ = compileWithConfig({
+        {core::QueryConfig::kExprTrackCpuUsage, "true"},
+    });
+    exprSetAdaptive1Pct_ = compileWithConfig({
+        {core::QueryConfig::kExprTrackCpuUsage, "false"},
+        {core::QueryConfig::kExprAdaptiveCpuSampling, "true"},
+        {core::QueryConfig::kExprAdaptiveCpuSamplingMaxOverheadPct, "1.0"},
+    });
+    exprSetAdaptiveHalfPct_ = compileWithConfig({
+        {core::QueryConfig::kExprTrackCpuUsage, "false"},
+        {core::QueryConfig::kExprAdaptiveCpuSampling, "true"},
+        {core::QueryConfig::kExprAdaptiveCpuSamplingMaxOverheadPct, "0.5"},
+    });
+  }
+
+  void runNoTracking(const RowVectorPtr& input, size_t iterations) {
+    run(*exprSetNoTracking_, input, iterations);
+  }
+
+  void runWithTracking(const RowVectorPtr& input, size_t iterations) {
+    run(*exprSetWithTracking_, input, iterations);
+  }
+
+  void runAdaptive1Pct(const RowVectorPtr& input, size_t iterations) {
+    run(*exprSetAdaptive1Pct_, input, iterations);
+  }
+
+  void runAdaptiveHalfPct(const RowVectorPtr& input, size_t iterations) {
+    run(*exprSetAdaptiveHalfPct_, input, iterations);
+  }
+
+  RowVectorPtr smallRowVector_;
+  RowVectorPtr mediumRowVector_;
+  RowVectorPtr largeRowVector_;
+
+ private:
+  RowVectorPtr makeRowVector(vector_size_t size) {
+    VectorFuzzer::Options opts;
+    opts.vectorSize = size;
+    opts.nullRatio = 0;
+    opts.containerLength = 50;
+    VectorFuzzer fuzzer(opts, pool(), FLAGS_fuzzer_seed);
+
+    std::vector<VectorPtr> children;
+    children.emplace_back(fuzzer.fuzzFlat(ARRAY(BIGINT())));
+    children.emplace_back(fuzzer.fuzzFlat(ARRAY(BIGINT())));
+    return std::make_shared<RowVector>(
+        pool(), inputType_, nullptr, size, std::move(children));
+  }
+
+  std::unique_ptr<ExprSet> compileWithConfig(
+      std::unordered_map<std::string, std::string> config) {
+    queryCtx_->testingOverrideConfigUnsafe(std::move(config));
+    return std::make_unique<ExprSet>(
+        compileExpression("array_gte(a, b)", inputType_));
+  }
+
+  void run(ExprSet& exprSet, const RowVectorPtr& input, size_t iterations) {
+    folly::BenchmarkSuspender suspender;
+    SelectivityVector rows(input->size());
+    suspender.dismiss();
+
+    std::vector<VectorPtr> results(1);
+    size_t count{0};
+    for (size_t i = 0; i < iterations; ++i) {
+      EvalCtx evalCtx(&execCtx_, &exprSet, input.get());
+      exprSet.eval(rows, evalCtx, results);
+      count += results[0]->size();
+      results[0]->prepareForReuse();
+    }
+    folly::doNotOptimizeAway(count);
+  }
+
+  TypePtr inputType_;
+  std::unique_ptr<ExprSet> exprSetNoTracking_;
+  std::unique_ptr<ExprSet> exprSetWithTracking_;
+  std::unique_ptr<ExprSet> exprSetAdaptive1Pct_;
+  std::unique_ptr<ExprSet> exprSetAdaptiveHalfPct_;
+};
+
+constexpr size_t kIterationsSmall{10'000};
+constexpr size_t kIterationsMedium{1'000};
+constexpr size_t kIterationsLarge{100};
+
+std::unique_ptr<CpuTimeTrackingBenchmark> benchmark;
+std::unique_ptr<ArrayGteBenchmark> arrayBenchmark;
+
+// --- Batch size 100 ---
+
+BENCHMARK(noTrackingSmall) {
+  benchmark->runNoTracking(benchmark->smallRowVector_, kIterationsSmall);
+}
+
+BENCHMARK_RELATIVE(withTrackingSmall) {
+  benchmark->runWithTracking(benchmark->smallRowVector_, kIterationsSmall);
+}
+
+BENCHMARK_RELATIVE(adaptive1PctSmall) {
+  benchmark->runAdaptive1Pct(benchmark->smallRowVector_, kIterationsSmall);
+}
+
+BENCHMARK_RELATIVE(adaptiveHalfPctSmall) {
+  benchmark->runAdaptiveHalfPct(benchmark->smallRowVector_, kIterationsSmall);
+}
+
+BENCHMARK_DRAW_LINE();
+
+// --- Batch size 1,000 ---
+
+BENCHMARK(noTrackingMedium) {
+  benchmark->runNoTracking(benchmark->mediumRowVector_, kIterationsMedium);
+}
+
+BENCHMARK_RELATIVE(withTrackingMedium) {
+  benchmark->runWithTracking(benchmark->mediumRowVector_, kIterationsMedium);
+}
+
+BENCHMARK_RELATIVE(adaptive1PctMedium) {
+  benchmark->runAdaptive1Pct(benchmark->mediumRowVector_, kIterationsMedium);
+}
+
+BENCHMARK_RELATIVE(adaptiveHalfPctMedium) {
+  benchmark->runAdaptiveHalfPct(benchmark->mediumRowVector_, kIterationsMedium);
+}
+
+BENCHMARK_DRAW_LINE();
+
+// --- Batch size 10,000 ---
+
+BENCHMARK(noTrackingLarge) {
+  benchmark->runNoTracking(benchmark->largeRowVector_, kIterationsLarge);
+}
+
+BENCHMARK_RELATIVE(withTrackingLarge) {
+  benchmark->runWithTracking(benchmark->largeRowVector_, kIterationsLarge);
+}
+
+BENCHMARK_RELATIVE(adaptive1PctLarge) {
+  benchmark->runAdaptive1Pct(benchmark->largeRowVector_, kIterationsLarge);
+}
+
+BENCHMARK_RELATIVE(adaptiveHalfPctLarge) {
+  benchmark->runAdaptiveHalfPct(benchmark->largeRowVector_, kIterationsLarge);
+}
+
+BENCHMARK_DRAW_LINE();
+
+// --- array_gte: Batch size 100, 50-element arrays ---
+
+BENCHMARK(arrayGteNoTrackingSmall) {
+  arrayBenchmark->runNoTracking(
+      arrayBenchmark->smallRowVector_, kIterationsSmall);
+}
+
+BENCHMARK_RELATIVE(arrayGteWithTrackingSmall) {
+  arrayBenchmark->runWithTracking(
+      arrayBenchmark->smallRowVector_, kIterationsSmall);
+}
+
+BENCHMARK_RELATIVE(arrayGteAdaptive1PctSmall) {
+  arrayBenchmark->runAdaptive1Pct(
+      arrayBenchmark->smallRowVector_, kIterationsSmall);
+}
+
+BENCHMARK_RELATIVE(arrayGteAdaptiveHalfPctSmall) {
+  arrayBenchmark->runAdaptiveHalfPct(
+      arrayBenchmark->smallRowVector_, kIterationsSmall);
+}
+
+BENCHMARK_DRAW_LINE();
+
+// --- array_gte: Batch size 1,000, 50-element arrays ---
+
+BENCHMARK(arrayGteNoTrackingMedium) {
+  arrayBenchmark->runNoTracking(
+      arrayBenchmark->mediumRowVector_, kIterationsMedium);
+}
+
+BENCHMARK_RELATIVE(arrayGteWithTrackingMedium) {
+  arrayBenchmark->runWithTracking(
+      arrayBenchmark->mediumRowVector_, kIterationsMedium);
+}
+
+BENCHMARK_RELATIVE(arrayGteAdaptive1PctMedium) {
+  arrayBenchmark->runAdaptive1Pct(
+      arrayBenchmark->mediumRowVector_, kIterationsMedium);
+}
+
+BENCHMARK_RELATIVE(arrayGteAdaptiveHalfPctMedium) {
+  arrayBenchmark->runAdaptiveHalfPct(
+      arrayBenchmark->mediumRowVector_, kIterationsMedium);
+}
+
+BENCHMARK_DRAW_LINE();
+
+// --- array_gte: Batch size 10,000, 50-element arrays ---
+
+BENCHMARK(arrayGteNoTrackingLarge) {
+  arrayBenchmark->runNoTracking(
+      arrayBenchmark->largeRowVector_, kIterationsLarge);
+}
+
+BENCHMARK_RELATIVE(arrayGteWithTrackingLarge) {
+  arrayBenchmark->runWithTracking(
+      arrayBenchmark->largeRowVector_, kIterationsLarge);
+}
+
+BENCHMARK_RELATIVE(arrayGteAdaptive1PctLarge) {
+  arrayBenchmark->runAdaptive1Pct(
+      arrayBenchmark->largeRowVector_, kIterationsLarge);
+}
+
+BENCHMARK_RELATIVE(arrayGteAdaptiveHalfPctLarge) {
+  arrayBenchmark->runAdaptiveHalfPct(
+      arrayBenchmark->largeRowVector_, kIterationsLarge);
+}
+
+} // namespace
+
+int main(int argc, char* argv[]) {
+  folly::Init init{&argc, &argv};
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+  memory::MemoryManager::initialize(memory::MemoryManager::Options{});
+  benchmark = std::make_unique<CpuTimeTrackingBenchmark>();
+  arrayBenchmark = std::make_unique<ArrayGteBenchmark>();
+  folly::runBenchmarks();
+  benchmark.reset();
+  arrayBenchmark.reset();
+  return 0;
+}
diff --git a/velox/expression/benchmarks/VariadicBenchmark.cpp b/velox/expression/benchmarks/VariadicBenchmark.cpp
index 11c5443b666..8b92e286898 100644
--- a/velox/expression/benchmarks/VariadicBenchmark.cpp
+++ b/velox/expression/benchmarks/VariadicBenchmark.cpp
@@ -160,7 +160,7 @@ class VariadicBenchmark : public functions::test::FunctionBenchmarkBase {
       auto other = compileExpression(
           fmt::format("{}(c0, c1, c2, c3, c4)", name), input->type());
       if (!hasSameResults(exprSetRef, other, input)) {
-        VELOX_UNREACHABLE(fmt::format("testing failed at function {}", name));
+        VELOX_UNREACHABLE("Testing failed at function: {}", name);
       }
     }
   }
diff --git a/velox/expression/fuzzer/ArgValuesGenerators.cpp b/velox/expression/fuzzer/ArgValuesGenerators.cpp
index afe5d2d0a93..a93d86cecb6 100644
--- a/velox/expression/fuzzer/ArgValuesGenerators.cpp
+++ b/velox/expression/fuzzer/ArgValuesGenerators.cpp
@@ -19,6 +19,7 @@
 #include "velox/common/fuzzer/ConstrainedGenerators.h"
 #include "velox/common/fuzzer/Utils.h"
 #include "velox/core/Expressions.h"
+#include "velox/functions/prestosql/S2CellOperations.h"
 #include "velox/functions/prestosql/types/JsonType.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
@@ -137,11 +138,12 @@ std::vector<core::TypedExprPtr> PhoneNumberArgValuesGenerator::generate(
             seed, signature.args[0], nullRatio));
 
     VELOX_CHECK_GE(state.inputRowNames_.size(), 1);
-    inputExpressions.emplace_back(std::make_shared<core::FieldAccessTypedExpr>(
-        signature.args[0],
-        signature.args.size() == 1
-            ? state.inputRowNames_.back()
-            : state.inputRowNames_[state.inputRowNames_.size() - 2]));
+    inputExpressions.emplace_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            signature.args[0],
+            signature.args.size() == 1
+                ? state.inputRowNames_.back()
+                : state.inputRowNames_[state.inputRowNames_.size() - 2]));
 
     //  Populate state.customInputGenerators_ and inputExpressions with nullptr
     //  for inputs that do not require custom input generators
@@ -158,12 +160,13 @@ std::vector<core::TypedExprPtr> PhoneNumberArgValuesGenerator::generate(
             seed, signature.args[0], nullRatio));
 
     VELOX_CHECK_GE(state.inputRowNames_.size(), signature.args.size());
-    inputExpressions.emplace_back(std::make_shared<core::FieldAccessTypedExpr>(
-        signature.args[0],
-        signature.args.size() == 1
-            ? state.inputRowNames_.back()
-            : state.inputRowNames_
-                  [state.inputRowNames_.size() - signature.args.size()]));
+    inputExpressions.emplace_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            signature.args[0],
+            signature.args.size() == 1
+                ? state.inputRowNames_.back()
+                : state.inputRowNames_
+                      [state.inputRowNames_.size() - signature.args.size()]));
 
     for (int i = 1; i < signature.args.size(); i++) {
       if (i == 1) {
@@ -218,8 +221,9 @@ std::vector<core::TypedExprPtr> JsonExtractArgValuesGenerator::generate(
     state.inputRowTypes_.emplace_back(signature.args[i]);
     state.inputRowNames_.emplace_back(
         fmt::format("c{}", state.inputRowTypes_.size() - 1));
-    inputExpressions.push_back(std::make_shared<core::FieldAccessTypedExpr>(
-        signature.args[i], state.inputRowNames_.back()));
+    inputExpressions.push_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            signature.args[i], state.inputRowNames_.back()));
   }
 
   const auto nullRatio = options.nullRatio;
@@ -304,8 +308,9 @@ std::vector<core::TypedExprPtr> CastVarcharAndJsonArgValuesGenerator::generate(
     }
 
     VELOX_CHECK_GE(signature.args.size(), 1);
-    inputExpressions.emplace_back(std::make_shared<core::FieldAccessTypedExpr>(
-        signature.args[0], state.inputRowNames_.back()));
+    inputExpressions.emplace_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            signature.args[0], state.inputRowNames_.back()));
   }
 
   return inputExpressions;
@@ -349,21 +354,23 @@ std::vector<core::TypedExprPtr> QDigestArgValuesGenerator::generate(
       std::make_shared<fuzzer::QDigestInputGenerator>(
           seed, signature.args[0], nullRatio, qDigestType()));
   VELOX_CHECK_GE(state.inputRowNames_.size(), signature.args.size());
-  inputExpressions.emplace_back(std::make_shared<core::FieldAccessTypedExpr>(
-      signature.args[0],
-      signature.args.size() == 1
-          ? state.inputRowNames_.back()
-          : state.inputRowNames_
-                [state.inputRowNames_.size() - signature.args.size()]));
+  inputExpressions.emplace_back(
+      std::make_shared<core::FieldAccessTypedExpr>(
+          signature.args[0],
+          signature.args.size() == 1
+              ? state.inputRowNames_.back()
+              : state.inputRowNames_
+                    [state.inputRowNames_.size() - signature.args.size()]));
 
   // Add null generators for remaining arguments
   for (size_t i = 1; i < signature.args.size(); i++) {
     state.customInputGenerators_.emplace_back(nullptr);
     VELOX_CHECK_GE(state.inputRowNames_.size(), signature.args.size() - i);
-    inputExpressions.emplace_back(std::make_shared<core::FieldAccessTypedExpr>(
-        signature.args[i],
-        state.inputRowNames_
-            [state.inputRowNames_.size() + i - signature.args.size()]));
+    inputExpressions.emplace_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            signature.args[i],
+            state.inputRowNames_
+                [state.inputRowNames_.size() + i - signature.args.size()]));
   }
   return inputExpressions;
 }
@@ -400,17 +407,19 @@ std::vector<core::TypedExprPtr> URLArgValuesGenerator::generate(
                "url_extract_host"})));
 
   VELOX_CHECK_GE(signature.args.size(), 1);
-  inputExpressions.emplace_back(std::make_shared<core::FieldAccessTypedExpr>(
-      signature.args[0], state.inputRowNames_.back()));
+  inputExpressions.emplace_back(
+      std::make_shared<core::FieldAccessTypedExpr>(
+          signature.args[0], state.inputRowNames_.back()));
 
   // Add null generators for remaining arguments
   for (size_t i = 1; i < signature.args.size(); i++) {
     state.customInputGenerators_.emplace_back(nullptr);
     VELOX_CHECK_GE(state.inputRowNames_.size(), signature.args.size() - i);
-    inputExpressions.emplace_back(std::make_shared<core::FieldAccessTypedExpr>(
-        signature.args[i],
-        state.inputRowNames_
-            [state.inputRowNames_.size() + i - signature.args.size()]));
+    inputExpressions.emplace_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            signature.args[i],
+            state.inputRowNames_
+                [state.inputRowNames_.size() + i - signature.args.size()]));
   }
 
   return inputExpressions;
@@ -441,12 +450,13 @@ std::vector<core::TypedExprPtr> TDigestArgValuesGenerator::generate(
         std::make_shared<fuzzer::TDigestInputGenerator>(
             seed, signature.args[0], nullRatio));
     VELOX_CHECK_GE(state.inputRowNames_.size(), signature.args.size());
-    inputExpressions.emplace_back(std::make_shared<core::FieldAccessTypedExpr>(
-        signature.args[0],
-        signature.args.size() == 1
-            ? state.inputRowNames_.back()
-            : state.inputRowNames_
-                  [state.inputRowNames_.size() - signature.args.size()]));
+    inputExpressions.emplace_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            signature.args[0],
+            signature.args.size() == 1
+                ? state.inputRowNames_.back()
+                : state.inputRowNames_
+                      [state.inputRowNames_.size() - signature.args.size()]));
     // Add null generators for remaining arguments
     for (size_t i = 1; i < signature.args.size(); i++) {
       state.customInputGenerators_.emplace_back(nullptr);
@@ -479,4 +489,218 @@ std::vector<core::TypedExprPtr> UnifiedDigestArgValuesGenerator::generate(
   VELOX_UNREACHABLE("Unsupported digest type");
 }
 
+std::vector<core::TypedExprPtr>
+FbDedupNormalizeTextArgValuesGenerator::generate(
+    const CallableSignature& signature,
+    const VectorFuzzer::Options& options,
+    FuzzerGenerator& rng,
+    ExpressionFuzzerState& state) {
+  VELOX_CHECK_LE(signature.args.size(), 2);
+  populateInputTypesAndNames(signature, state);
+
+  const auto seed = static_cast<size_t>(rand<uint32_t>(rng));
+  const auto nullRatio = options.nullRatio;
+
+  // Add custom input generator for the first argument (text)
+  state.customInputGenerators_.emplace_back(
+      std::make_shared<RandomInputGenerator<StringView>>(
+          seed,
+          signature.args[0],
+          nullRatio,
+          20,
+          std::vector<UTF8CharList>{
+              UTF8CharList::ASCII,
+              UTF8CharList::UNICODE_CASE_SENSITIVE,
+              UTF8CharList::EXTENDED_UNICODE,
+              UTF8CharList::MATHEMATICAL_SYMBOLS},
+          RandomStrVariationOptions{
+              /*controlCharacterProbability=*/0.5,
+              /*escapeStringProbability=*/0.5,
+              /*truncateProbability=*/0.2,
+          }));
+
+  // Populate inputExpressions_ for the argument that requires custom
+  // generation. A nullptr should be added at inputExpressions[i] if the i-th
+  // argument does not require custom input generation.
+  std::vector<core::TypedExprPtr> inputExpressions{
+      signature.args.size(), nullptr};
+
+  // First argument (text) - use FieldAccessTypedExpr
+  inputExpressions[0] = std::make_shared<core::FieldAccessTypedExpr>(
+      signature.args[0], state.inputRowNames_.back());
+
+  // Second argument (normalization form) - Add an INVALID form
+  if (signature.args.size() > 1) {
+    // Add null generator for second argument if it exists
+    state.customInputGenerators_.emplace_back(nullptr);
+
+    static const std::vector<std::string> testForms = {
+        "NFC", "NFD", "NFKC", "NFKD", "INVALID"};
+
+    auto index = rand<uint64_t>(rng, 0, testForms.size() - 1);
+    inputExpressions[1] = std::make_shared<core::ConstantTypedExpr>(
+        VARCHAR(), variant(testForms[index]));
+  }
+
+  return inputExpressions;
+}
+
+std::vector<core::TypedExprPtr> AtTimezoneArgValuesGenerator::generate(
+    const CallableSignature& signature,
+    const VectorFuzzer::Options& options,
+    FuzzerGenerator& rng,
+    ExpressionFuzzerState& state) {
+  VELOX_CHECK_EQ(signature.args.size(), 2);
+  populateInputTypesAndNames(signature, state);
+
+  std::vector<core::TypedExprPtr> inputExpressions{
+      signature.args.size(), nullptr};
+
+  // First argument - use default generation (TIME WITH TIME ZONE or TIMESTAMP
+  // WITH TIME ZONE)
+  state.customInputGenerators_.emplace_back(nullptr);
+  inputExpressions[0] = std::make_shared<core::FieldAccessTypedExpr>(
+      signature.args[0], state.inputRowNames_[state.inputRowNames_.size() - 2]);
+
+  // Second argument - constrain to valid timezone offset formats
+  // Valid formats: "+HH:mm" or "-HH:mm" (Presto-compatible)
+  // Offset range: -14:00 to +14:00
+  // Uses shared timezone generation utility (25% frequently used, 75% random)
+  state.customInputGenerators_.emplace_back(nullptr);
+
+  // Generate random timezone offset and convert to string
+  int16_t offsetMinutes = generateRandomTimezoneOffset(rng);
+  std::string timezoneString = timezoneOffsetToString(offsetMinutes);
+  inputExpressions[1] = std::make_shared<core::ConstantTypedExpr>(
+      VARCHAR(), variant(timezoneString));
+
+  return inputExpressions;
+}
+
+std::vector<core::TypedExprPtr> SetDigestArgValuesGenerator::generate(
+    const CallableSignature& signature,
+    const VectorFuzzer::Options& options,
+    FuzzerGenerator& rng,
+    ExpressionFuzzerState& state) {
+  populateInputTypesAndNames(signature, state);
+  const auto seed = rand<uint32_t>(rng);
+  const auto nullRatio = options.nullRatio;
+  std::vector<core::TypedExprPtr> inputExpressions;
+
+  VELOX_CHECK_GE(signature.args.size(), 1);
+  VELOX_CHECK_LE(signature.args.size(), 2);
+
+  const std::vector<std::string> singleArgFunctions = {
+      "hash_counts", "cardinality"};
+  const std::vector<std::string> twoArgFunctions = {
+      "jaccard_index", "intersection_cardinality"};
+
+  if (std::find(
+          singleArgFunctions.begin(),
+          singleArgFunctions.end(),
+          functionName_) != singleArgFunctions.end()) {
+    // Functions with one SetDigest input
+    VELOX_CHECK_EQ(signature.args.size(), 1);
+
+    state.customInputGenerators_.emplace_back(
+        std::make_shared<fuzzer::SetDigestInputGenerator>(
+            seed, signature.args[0], nullRatio));
+
+    VELOX_CHECK_GE(state.inputRowNames_.size(), 1);
+    inputExpressions.emplace_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            signature.args[0], state.inputRowNames_.back()));
+  } else if (
+      std::find(
+          twoArgFunctions.begin(), twoArgFunctions.end(), functionName_) !=
+      twoArgFunctions.end()) {
+    // Functions with two SetDigest inputs
+    VELOX_CHECK_EQ(signature.args.size(), 2);
+
+    // First SetDigest input
+    state.customInputGenerators_.emplace_back(
+        std::make_shared<fuzzer::SetDigestInputGenerator>(
+            seed, signature.args[0], nullRatio));
+
+    VELOX_CHECK_GE(state.inputRowNames_.size(), 2);
+    inputExpressions.emplace_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            signature.args[0],
+            state.inputRowNames_[state.inputRowNames_.size() - 2]));
+
+    // Second SetDigest input
+    state.customInputGenerators_.emplace_back(
+        std::make_shared<fuzzer::SetDigestInputGenerator>(
+            seed + 1, signature.args[1], nullRatio));
+
+    inputExpressions.emplace_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            signature.args[1],
+            state.inputRowNames_[state.inputRowNames_.size() - 1]));
+  }
+  return inputExpressions;
+}
+namespace {
+
+// Generates a random valid S2 cell ID.
+// Picks random face (0-5), level (0-30), and Hilbert curve position.
+// S2CellId::FromFacePosLevel clamps the position, so any uint64_t is safe.
+int64_t randomS2CellId(FuzzerGenerator& rng) {
+  auto face = static_cast<int>(rand<uint64_t>(rng, 0, 5));
+  auto level = static_cast<int>(rand<uint64_t>(rng, 0, 30));
+  auto position = rand<uint64_t>(rng);
+  return functions::S2CellOp::cellIdFromFacePositionLevel(
+      face, position, level);
+}
+
+} // namespace
+
+std::vector<core::TypedExprPtr> S2CellIdArgValuesGenerator::generate(
+    const CallableSignature& signature,
+    const VectorFuzzer::Options& /*options*/,
+    FuzzerGenerator& rng,
+    ExpressionFuzzerState& state) {
+  VELOX_CHECK_GE(signature.args.size(), 1);
+  populateInputTypesAndNames(signature, state);
+
+  std::vector<core::TypedExprPtr> inputExpressions{
+      signature.args.size(), nullptr};
+  VELOX_CHECK(!inputExpressions.empty());
+
+  // Generate valid constants for each argument based on type:
+  // BIGINT arguments are cell IDs, INTEGER arguments are levels (0-30).
+  for (size_t i = 0; i < inputExpressions.size(); ++i) {
+    state.customInputGenerators_.emplace_back(nullptr);
+    if (signature.args.at(i)->kind() == TypeKind::BIGINT) {
+      inputExpressions[i] = std::make_shared<core::ConstantTypedExpr>(
+          BIGINT(), variant(randomS2CellId(rng)));
+    } else if (signature.args.at(i)->kind() == TypeKind::INTEGER) {
+      auto level = static_cast<int32_t>(rand<uint64_t>(rng, 0, 30));
+      inputExpressions[i] =
+          std::make_shared<core::ConstantTypedExpr>(INTEGER(), variant(level));
+    }
+  }
+
+  return inputExpressions;
+}
+
+std::vector<core::TypedExprPtr> S2CellTokenArgValuesGenerator::generate(
+    const CallableSignature& signature,
+    const VectorFuzzer::Options& /*options*/,
+    FuzzerGenerator& rng,
+    ExpressionFuzzerState& state) {
+  VELOX_CHECK_EQ(signature.args.size(), 1);
+  populateInputTypesAndNames(signature, state);
+
+  std::vector<core::TypedExprPtr> inputExpressions{1, nullptr};
+
+  // Generate a random valid cell ID, then convert to token.
+  auto token = functions::S2CellOp::toToken(randomS2CellId(rng));
+  state.customInputGenerators_.emplace_back(nullptr);
+  inputExpressions[0] =
+      std::make_shared<core::ConstantTypedExpr>(VARCHAR(), variant(token));
+
+  return inputExpressions;
+}
+
 } // namespace facebook::velox::fuzzer
diff --git a/velox/expression/fuzzer/ArgValuesGenerators.h b/velox/expression/fuzzer/ArgValuesGenerators.h
index c67e839557c..4cf0795343c 100644
--- a/velox/expression/fuzzer/ArgValuesGenerators.h
+++ b/velox/expression/fuzzer/ArgValuesGenerators.h
@@ -65,7 +65,7 @@ class PhoneNumberArgValuesGenerator : public ArgValuesGenerator {
 // 2. the size of all container types in the JSON argument do not exceed a
 // randomly generated maxContainerSize.
 // 1. either all map keys in all maps in the JSON argument are VARCHAR or they
-// are BIGINT, and all map-key values are choosen from a randomly generated
+// are BIGINT, and all map-key values are chosen from a randomly generated
 // candidate set. The size of the candidate map-key set is slightly larger than
 // maxContainerSize, so that access into maps by keys has matches and misses.
 //
@@ -158,4 +158,79 @@ class UnifiedDigestArgValuesGenerator : public ArgValuesGenerator {
   TDigestArgValuesGenerator tdigestGenerator_;
   QDigestArgValuesGenerator qdigestGenerator_;
 };
+
+/// Generates arguments for fb_dedup_normalize_text function.
+/// For the two-parameter version, constrains the second parameter to valid
+/// normalization forms: NFC, NFD, NFKC, NFKD.
+class FbDedupNormalizeTextArgValuesGenerator : public ArgValuesGenerator {
+ public:
+  FbDedupNormalizeTextArgValuesGenerator() = default;
+  ~FbDedupNormalizeTextArgValuesGenerator() override = default;
+
+  std::vector<core::TypedExprPtr> generate(
+      const CallableSignature& signature,
+      const VectorFuzzer::Options& options,
+      FuzzerGenerator& rng,
+      ExpressionFuzzerState& state) override;
+};
+
+/// Generates arguments for at_timezone function.
+/// Constrains the second parameter (timezone) to valid timezone offset formats
+/// (e.g., "+HH:MM", "-HH:MM", "+HH", etc.) instead of random strings.
+class AtTimezoneArgValuesGenerator : public ArgValuesGenerator {
+ public:
+  AtTimezoneArgValuesGenerator() = default;
+  ~AtTimezoneArgValuesGenerator() override = default;
+
+  std::vector<core::TypedExprPtr> generate(
+      const CallableSignature& signature,
+      const VectorFuzzer::Options& options,
+      FuzzerGenerator& rng,
+      ExpressionFuzzerState& state) override;
+};
+
+class SetDigestArgValuesGenerator : public ArgValuesGenerator {
+ public:
+  explicit SetDigestArgValuesGenerator(std::string functionName) {
+    functionName_ = std::move(functionName);
+  }
+  ~SetDigestArgValuesGenerator() override = default;
+
+  std::vector<core::TypedExprPtr> generate(
+      const CallableSignature& signature,
+      const VectorFuzzer::Options& options,
+      FuzzerGenerator& rng,
+      ExpressionFuzzerState& state) override;
+
+ private:
+  std::string functionName_;
+};
+/// Generates valid S2 cell ID arguments for s2_cell_* functions.
+/// Picks random face, position, and level to construct valid cell IDs via
+/// S2CellOp::cellIdFromFacePositionLevel. Also constrains the level
+/// argument to [0, 30] when present.
+class S2CellIdArgValuesGenerator : public ArgValuesGenerator {
+ public:
+  ~S2CellIdArgValuesGenerator() override = default;
+
+  std::vector<core::TypedExprPtr> generate(
+      const CallableSignature& signature,
+      const VectorFuzzer::Options& options,
+      FuzzerGenerator& rng,
+      ExpressionFuzzerState& state) override;
+};
+
+/// Generates valid hex token arguments for s2_cell_from_token.
+/// Constructs a random valid cell ID, then converts it to a token string.
+class S2CellTokenArgValuesGenerator : public ArgValuesGenerator {
+ public:
+  ~S2CellTokenArgValuesGenerator() override = default;
+
+  std::vector<core::TypedExprPtr> generate(
+      const CallableSignature& signature,
+      const VectorFuzzer::Options& options,
+      FuzzerGenerator& rng,
+      ExpressionFuzzerState& state) override;
+};
+
 } // namespace facebook::velox::fuzzer
diff --git a/velox/expression/fuzzer/CMakeLists.txt b/velox/expression/fuzzer/CMakeLists.txt
index a4ddb2641a7..34dc14420b5 100644
--- a/velox/expression/fuzzer/CMakeLists.txt
+++ b/velox/expression/fuzzer/CMakeLists.txt
@@ -13,6 +13,13 @@
 # limitations under the License.
 
 add_library(velox_expression_test_utility ArgumentTypeFuzzer.cpp FuzzerToolkit.cpp)
+velox_add_test_headers(
+  velox_expression_test_utility
+  ArgTypesGenerator.h
+  ArgumentTypeFuzzer.h
+  DecimalArgTypesGeneratorBase.h
+  FuzzerToolkit.h
+)
 
 target_link_libraries(
   velox_expression_test_utility
@@ -33,6 +40,14 @@ add_library(
   FuzzerRunner.cpp
   SpecialFormSignatureGenerator.cpp
 )
+velox_add_test_headers(
+  velox_expression_fuzzer
+  ArgValuesGenerators.h
+  ExpressionFuzzer.h
+  ExpressionFuzzerVerifier.h
+  FuzzerRunner.h
+  SpecialFormSignatureGenerator.h
+)
 
 target_link_libraries(
   velox_expression_fuzzer
@@ -54,6 +69,7 @@ add_executable(velox_expression_fuzzer_test ExpressionFuzzerTest.cpp)
 target_link_libraries(
   velox_expression_fuzzer_test
   velox_expression_fuzzer
+  velox_core
   velox_functions_prestosql
   velox_fuzzer_util
   velox_hive_connector
@@ -66,6 +82,7 @@ add_executable(
   SparkExpressionFuzzerTest.cpp
   SparkSpecialFormSignatureGenerator.cpp
 )
+velox_add_test_headers(spark_expression_fuzzer_test SparkSpecialFormSignatureGenerator.h)
 
 target_link_libraries(
   spark_expression_fuzzer_test
diff --git a/velox/expression/fuzzer/ExpressionFuzzer.cpp b/velox/expression/fuzzer/ExpressionFuzzer.cpp
index 12fdd935cdf..4d1d688e148 100644
--- a/velox/expression/fuzzer/ExpressionFuzzer.cpp
+++ b/velox/expression/fuzzer/ExpressionFuzzer.cpp
@@ -46,7 +46,7 @@ class FullSignatureBinder : public SignatureBinderBase {
       const exec::FunctionSignature& signature,
       const std::vector<TypePtr>& argTypes,
       const TypePtr& returnType)
-      : SignatureBinderBase(signature) {
+      : SignatureBinderBase(signature, TypeCoercer::defaults()) {
     if (signature_.argumentTypes().size() != argTypes.size()) {
       return;
     }
@@ -329,8 +329,9 @@ ExpressionFuzzer::ExpressionFuzzer(
         }
         atLeastOneSupported = true;
         ++supportedFunctionSignatures;
-        signatureTemplates_.emplace_back(SignatureTemplate{
-            function.first, signature, std::move(typeVariables)});
+        signatureTemplates_.emplace_back(
+            SignatureTemplate{
+                function.first, signature, std::move(typeVariables)});
       } else {
         // Determine a list of concrete argument types that can bind to the
         // signature. For non-parameterized signatures, these argument types
@@ -638,8 +639,9 @@ core::TypedExprPtr ExpressionFuzzer::generateArgFunction(const TypePtr& arg) {
   for (auto i = 0; i < arg->size() - 1; ++i) {
     args.push_back(arg->childAt(i));
     names.push_back(fmt::format("__a{}", i));
-    inputs.push_back(std::make_shared<core::FieldAccessTypedExpr>(
-        args.back(), names.back()));
+    inputs.push_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            args.back(), names.back()));
   }
 
   const auto& returnType = functionType.children().back();
@@ -652,9 +654,8 @@ core::TypedExprPtr ExpressionFuzzer::generateArgFunction(const TypePtr& arg) {
   for (const auto& functionName : baseList) {
     if (findConcreteSignature(args, returnType, functionName)) {
       eligible.push_back(functionName);
-    } else if (
-        auto* signatureTemplate =
-            findSignatureTemplate(args, returnType, baseType, functionName)) {
+    } else if (findSignatureTemplate(
+                   args, returnType, baseType, functionName)) {
       eligible.push_back(functionName);
     }
   }
@@ -1044,22 +1045,23 @@ core::TypedExprPtr ExpressionFuzzer::generateExpressionFromSignatureTemplate(
       chosenSignature, returnType, rng_, supportedScalarTypes_};
 
   std::vector<TypePtr> argumentTypes;
-  if (fuzzer.fuzzArgumentTypes(options_.maxNumVarArgs)) {
-    // Use the argument fuzzer to generate argument types.
+  // Check if a custom argument type generator exists for this function.
+  // Custom argument type generators are prioritized over ArgumentTypeFuzzer
+  // because they can enforce function-specific semantic constraints that the
+  // generic fuzzer cannot know about.
+  auto it = argTypesGenerators_.find(functionName);
+  if (it != argTypesGenerators_.end()) {
+    argumentTypes = it->second->generateArgs(chosenSignature, returnType, rng_);
+    if (argumentTypes.empty()) {
+      return nullptr;
+    }
+  } else if (fuzzer.fuzzArgumentTypes(options_.maxNumVarArgs)) {
     argumentTypes = fuzzer.argumentTypes();
   } else {
-    auto it = argTypesGenerators_.find(functionName);
-    // Since the argument type fuzzer cannot produce argument types, argument
-    // generators should be provided.
-    VELOX_CHECK(
-        it != argTypesGenerators_.end(),
+    VELOX_FAIL(
         "Cannot generate argument types for {} with return type {}.",
         functionName,
         returnType->toString());
-    argumentTypes = it->second->generateArgs(chosenSignature, returnType, rng_);
-    if (argumentTypes.empty()) {
-      return nullptr;
-    }
   }
 
   auto constantArguments = chosenSignature.constantArguments();
diff --git a/velox/expression/fuzzer/ExpressionFuzzer.h b/velox/expression/fuzzer/ExpressionFuzzer.h
index b93fc893028..955c5e0c5cf 100644
--- a/velox/expression/fuzzer/ExpressionFuzzer.h
+++ b/velox/expression/fuzzer/ExpressionFuzzer.h
@@ -98,7 +98,7 @@ class ExpressionFuzzer {
     // testing. Use function signature to exclude only a specific signature.
     // ex skipFunctions{
     //   "width_bucket",
-    //   "array_sort(array(T),constant function(T,T,bigint)) -> array(T)"}
+    //   "array_sort(array(T),constant function(T,T,integer)) -> array(T)"}
     std::unordered_set<std::string> skipFunctions;
 
     std::unordered_map<std::string, std::shared_ptr<ExprTransformer>>
diff --git a/velox/expression/fuzzer/ExpressionFuzzerTest.cpp b/velox/expression/fuzzer/ExpressionFuzzerTest.cpp
index 5019ed02045..e049b15be4d 100644
--- a/velox/expression/fuzzer/ExpressionFuzzerTest.cpp
+++ b/velox/expression/fuzzer/ExpressionFuzzerTest.cpp
@@ -17,6 +17,7 @@
 #include <folly/init/Init.h>
 #include <unordered_set>
 
+#include "velox/core/QueryConfig.h"
 #include "velox/exec/fuzzer/PrestoQueryRunner.h"
 #include "velox/expression/fuzzer/ArgTypesGenerator.h"
 #include "velox/expression/fuzzer/ArgValuesGenerators.h"
@@ -24,10 +25,11 @@
 #include "velox/expression/fuzzer/FuzzerRunner.h"
 #include "velox/expression/fuzzer/SpecialFormSignatureGenerator.h"
 #include "velox/functions/prestosql/fuzzer/DivideArgTypesGenerator.h"
-#include "velox/functions/prestosql/fuzzer/FloorAndRoundArgTypesGenerator.h"
+#include "velox/functions/prestosql/fuzzer/FloorCeilRoundArgTypesGenerator.h"
 #include "velox/functions/prestosql/fuzzer/ModulusArgTypesGenerator.h"
 #include "velox/functions/prestosql/fuzzer/MultiplyArgTypesGenerator.h"
 #include "velox/functions/prestosql/fuzzer/PlusMinusArgTypesGenerator.h"
+#include "velox/functions/prestosql/fuzzer/SkipIPAddressArgTypesGenerator.h"
 
 #include "velox/functions/prestosql/fuzzer/SortArrayTransformer.h"
 #include "velox/functions/prestosql/fuzzer/TruncateArgTypesGenerator.h"
@@ -56,12 +58,16 @@ using namespace facebook::velox::exec::test;
 using facebook::velox::exec::test::PrestoQueryRunner;
 using facebook::velox::fuzzer::ArgTypesGenerator;
 using facebook::velox::fuzzer::ArgValuesGenerator;
+using facebook::velox::fuzzer::AtTimezoneArgValuesGenerator;
 using facebook::velox::fuzzer::CastVarcharAndJsonArgValuesGenerator;
 using facebook::velox::fuzzer::ExpressionFuzzer;
 using facebook::velox::fuzzer::FuzzerRunner;
 using facebook::velox::fuzzer::JsonExtractArgValuesGenerator;
 using facebook::velox::fuzzer::JsonParseArgValuesGenerator;
 using facebook::velox::fuzzer::QDigestArgValuesGenerator;
+using facebook::velox::fuzzer::S2CellIdArgValuesGenerator;
+using facebook::velox::fuzzer::S2CellTokenArgValuesGenerator;
+using facebook::velox::fuzzer::SetDigestArgValuesGenerator;
 using facebook::velox::fuzzer::TDigestArgValuesGenerator;
 using facebook::velox::fuzzer::UnifiedDigestArgValuesGenerator;
 using facebook::velox::fuzzer::URLArgValuesGenerator;
@@ -73,10 +79,16 @@ std::unordered_map<std::string, std::shared_ptr<ArgTypesGenerator>>
         {"minus", std::make_shared<PlusMinusArgTypesGenerator>()},
         {"multiply", std::make_shared<MultiplyArgTypesGenerator>()},
         {"divide", std::make_shared<DivideArgTypesGenerator>()},
-        {"floor", std::make_shared<FloorAndRoundArgTypesGenerator>()},
-        {"round", std::make_shared<FloorAndRoundArgTypesGenerator>()},
+        {"floor", std::make_shared<FloorCeilRoundArgTypesGenerator>()},
+        {"ceil", std::make_shared<FloorCeilRoundArgTypesGenerator>()},
+        {"round", std::make_shared<FloorCeilRoundArgTypesGenerator>()},
         {"mod", std::make_shared<ModulusArgTypesGenerator>()},
-        {"truncate", std::make_shared<TruncateArgTypesGenerator>()}};
+        {"truncate", std::make_shared<TruncateArgTypesGenerator>()},
+        // Block IPADDRESS in containers for functions whose hash-based
+        // deduplication calls compareTo() on Int128ArrayBlock, which is not
+        // implemented. See: https://github.com/prestodb/presto/issues/26836
+        {"distinct_from", std::make_shared<SkipIPAddressArgTypesGenerator>()},
+        {"array_union", std::make_shared<SkipIPAddressArgTypesGenerator>()}};
 
 std::unordered_map<std::string, std::shared_ptr<ExprTransformer>>
     exprTransformers = {
@@ -89,6 +101,7 @@ std::unordered_map<std::string, std::shared_ptr<ExprTransformer>>
 
 std::unordered_map<std::string, std::shared_ptr<ArgValuesGenerator>>
     argValuesGenerators = {
+        {"at_timezone", std::make_shared<AtTimezoneArgValuesGenerator>()},
         {"cast", std::make_shared<CastVarcharAndJsonArgValuesGenerator>()},
         {"json_parse", std::make_shared<JsonParseArgValuesGenerator>()},
         {"json_extract", std::make_shared<JsonExtractArgValuesGenerator>()},
@@ -117,7 +130,25 @@ std::unordered_map<std::string, std::shared_ptr<ArgValuesGenerator>>
         {"destructure_tdigest",
          std::make_shared<TDigestArgValuesGenerator>("destructure_tdigest")},
         {"trimmed_mean",
-         std::make_shared<TDigestArgValuesGenerator>("trimmed_mean")}};
+         std::make_shared<TDigestArgValuesGenerator>("trimmed_mean")},
+        {"winsorized_mean",
+         std::make_shared<TDigestArgValuesGenerator>("winsorized_mean")},
+        {"hash_counts",
+         std::make_shared<SetDigestArgValuesGenerator>("hash_counts")},
+        {"cardinality",
+         std::make_shared<SetDigestArgValuesGenerator>("cardinality")},
+        {"jaccard_index",
+         std::make_shared<SetDigestArgValuesGenerator>("jaccard_index")},
+        {"intersection_cardinality",
+         std::make_shared<SetDigestArgValuesGenerator>(
+             "intersection_cardinality")},
+        {"s2_cell_area_sq_km", std::make_shared<S2CellIdArgValuesGenerator>()},
+        {"s2_cell_contains", std::make_shared<S2CellIdArgValuesGenerator>()},
+        {"s2_cell_level", std::make_shared<S2CellIdArgValuesGenerator>()},
+        {"s2_cell_parent", std::make_shared<S2CellIdArgValuesGenerator>()},
+        {"s2_cell_to_token", std::make_shared<S2CellIdArgValuesGenerator>()},
+        {"s2_cell_from_token",
+         std::make_shared<S2CellTokenArgValuesGenerator>()}};
 
 // TODO: List of the functions that at some point crash or fail and need to
 // be fixed before we can enable.
@@ -126,9 +157,14 @@ std::unordered_map<std::string, std::shared_ptr<ArgValuesGenerator>>
 // testing. Use function signature to exclude only a specific signature.
 std::unordered_set<std::string> skipFunctions = {
     "noisy_empty_approx_set_sfm", // Non-deterministic because of privacy.
+    "current_timestamp", // Non-deterministic: returns the current timestamp at
+                         // query execution time, so results differ across runs
+    "now", // alias for current_timestamp
     "merge_sfm", // Fuzzer can generate sketches of different sizes.
     "element_at",
     "width_bucket",
+    // Varbinary output can't be compared exactly with Java.
+    "merge_hll",
     // Fuzzer and the underlying engine are confused about TDigest functions
     // (since TDigest is a user defined type), and tries to pass a
     // VARBINARY (since TDigest's implementation uses an
@@ -141,8 +177,22 @@ std::unordered_set<std::string> skipFunctions = {
     "construct_tdigest",
     "destructure_tdigest",
     "trimmed_mean",
+    "winsorized_mean",
+    // Fuzzer and the underlying engine are confused about SetDigest functions
+    // (since KHLL is a user defined type), and tries to pass a
+    // VARBINARY (since KHLL's implementation uses an
+    // alias to VARBINARY).
+    "cardinality(hyperloglog) -> bigint", // Skip HLL version, only test
+                                          // setdigest
+    "cardinality(khyperloglog) -> bigint",
+    "intersection_cardinality(khyperloglog,khyperloglog) -> bigint",
+    "jaccard_index(khyperloglog,khyperloglog) -> double",
+    "reidentification_potential(khyperloglog,bigint) -> double",
+    "uniqueness_distribution(khyperloglog) -> map(bigint,double)",
+    "uniqueness_distribution(khyperloglog,bigint) -> map(bigint,double)",
+    "merge_khll(array(khyperloglog)) -> khyperloglog",
     // Fuzzer cannot generate valid 'comparator' lambda.
-    "array_sort(array(T),constant function(T,T,bigint)) -> array(T)",
+    "array_sort(array(T),constant function(T,T,integer)) -> array(T)",
     "array_sort(array(T),constant function(T,U)) -> array(T)",
     "array_sort_desc(array(T),constant function(T,U)) -> array(T)",
     "split_to_map(varchar,varchar,varchar,function(varchar,varchar,varchar,varchar)) -> map(varchar,varchar)",
@@ -234,6 +284,9 @@ std::unordered_set<std::string> skipFunctions = {
     "st_envelope",
     "ST_EnvelopeAsPts",
     "st_buffer",
+    "st_linestring",
+    "st_linefromtext",
+    "st_multipoint",
     "geometry_invalid_reason",
     "geometry_nearest_points",
     "simplify_geometry",
@@ -250,9 +303,35 @@ std::unordered_set<std::string> skipFunctions = {
     "geometry_from_geojson",
     "great_circle_distance",
     "geometry_to_bing_tiles",
+    "geometry_to_dissolved_bing_tiles",
+    "geometry_union",
+    "to_geometry",
+    "to_spherical_geography",
+    "convex_hull_agg",
+    "geometry_union_agg",
+    "localtime",
+    "s2_cells",
 };
 
 std::unordered_set<std::string> skipFunctionsSOT = {
+    "l2_norm", // Velox-only function, not available in Presto
+    "t_cdf", // New function, not yet widely deployed in Presto instances
+    "inverse_t_cdf", // New function, not yet widely deployed in Presto
+                     // instances
+    "array_subset", // Velox-only function, not available in Presto
+    "map_values_in_range", // Velox-only function, not available in Presto
+    "map_values_all_match", // Velox-only function, not available in Presto
+    "map_values_any_match", // Velox-only function, not available in Presto
+    "map_values_none_match", // Velox-only function, not available in Presto
+    "transform_with_index", // Velox-only function, not available in Presto
+    "dot_product", // Velox-only function, not available in Presto
+    "remap_keys", // Velox-only function, not available in Presto
+    "map_intersect", // Velox-only function, not available in Presto
+    "map_keys_overlap", // Velox-only function, not available in Presto
+    "map_append", // Velox-only function, not available in Presto
+    "map_update", // Velox-only function, not available in Presto
+    "map_trim_values", // Velox-only function, not available in Presto
+    "map_subset_key_in_range", // Velox-only function, not available in Presto
     "noisy_empty_approx_set_sfm", // non-deterministic because of privacy.
     // https://github.com/facebookincubator/velox/issues/11034
     "cast(real) -> varchar",
@@ -263,6 +342,9 @@ std::unordered_set<std::string> skipFunctionsSOT = {
     "cast(array(real)) -> array(varchar)",
     "cast(map(varchar,double)) -> map(varchar,varchar)",
     "cast(map(varchar,real)) -> map(varchar,varchar)",
+    // Velox and Presto may not match with regards to sparse vs. dense HLL
+    "cast(hyperloglog) -> p4hyperloglog",
+    "cast(p4hyperloglog) -> hyperloglog",
     "round", // https://github.com/facebookincubator/velox/issues/10634
     "bitwise_right_shift_arithmetic", // https://github.com/facebookincubator/velox/issues/10841
     "map_size_with", // https://github.com/facebookincubator/velox/issues/10964
@@ -293,6 +375,7 @@ std::unordered_set<std::string> skipFunctionsSOT = {
     "inverse_cauchy_cdf", // https://github.com/facebookincubator/velox/issues/10840
     "array_position", // https://github.com/facebookincubator/velox/issues/10580
     "chi_squared_cdf", // https://github.com/facebookincubator/velox/issues/12327
+    "map_except",
     "bitwise_left_shift", // https://github.com/facebookincubator/velox/issues/12330
     "log2", // https://github.com/facebookincubator/velox/issues/12338
     "bitwise_right_shift", // https://github.com/facebookincubator/velox/issues/12339
@@ -323,6 +406,7 @@ std::unordered_set<std::string> skipFunctionsSOT = {
     "escape", // https://github.com/facebookincubator/velox/issues/12558
     "from_base64url", // https://github.com/facebookincubator/velox/issues/12562
     "array_top_n", // https://github.com/prestodb/presto/issues/24700
+    "array_subset",
     "codepoint", // https://github.com/facebookincubator/velox/issues/12598
     "in", // https://github.com/facebookincubator/velox/issues/12597
     "multimap_from_entries", // https://github.com/facebookincubator/velox/issues/12628
@@ -394,8 +478,38 @@ std::unordered_set<std::string> skipFunctionsSOT = {
     // https://github.com/prestodb/presto/pull/25521
     "xxhash64(varbinary,bigint) -> varbinary",
     "map_keys_by_top_n_values", // https://github.com/facebookincubator/velox/issues/14374
+    "$internal$split_to_map",
     "$internal$canonicalize",
     "$internal$contains",
+    "current_time", // current_time cannot be called with parenthesis
+    "localtime", // localtime cannot be called with parenthesis:
+                 // https://github.com/facebookincubator/velox/issues/14937,
+    "localtimestamp", // localtimestamp cannot be called with parenthesis
+    "jarowinkler_similarity", // https://github.com/facebookincubator/velox/issues/15736
+    // Fuzzer and the underlying engine are confused about SetDigest functions
+    // (since KHLL is a user defined type), and tries to pass a
+    // VARBINARY (since KHLL's implementation uses an
+    // alias to VARBINARY).
+    "cardinality(hyperloglog) -> bigint", // Skip HLL version, only test
+                                          // setdigest
+    // Same with KHyperLogLog functions
+    "cardinality(khyperloglog) -> bigint",
+    "intersection_cardinality(khyperloglog,khyperloglog) -> bigint",
+    "jaccard_index(khyperloglog,khyperloglog) -> double",
+    "reidentification_potential(khyperloglog,bigint) -> double",
+    "uniqueness_distribution(khyperloglog) -> map(bigint,double)",
+    "uniqueness_distribution(khyperloglog,bigint) -> map(bigint,double)",
+    "merge_khll(array(khyperloglog)) -> khyperloglog",
+    "pmod", // Not available in Presto
+    // S2 functions are not registered in the Presto instance used for fuzzing.
+    "s2_cell_area_sq_km",
+    "s2_cell_contains",
+    "s2_cell_from_token",
+    "s2_cell_level",
+    "s2_cell_parent",
+    "s2_cell_to_token",
+    "ip_version", // New function, pending Presto Java implementation
+    "ip_prefix_masklen", // New function, pending Presto Java implementation
 };
 
 int main(int argc, char** argv) {
@@ -434,8 +548,10 @@ int main(int argc, char** argv) {
       initialSeed,
       skipFunctions,
       exprTransformers,
-      {{"session_timezone", "America/Los_Angeles"},
-       {"adjust_timestamp_to_session_timezone", "true"}},
+      {{facebook::velox::core::QueryConfig::kSessionTimezone,
+        "America/Los_Angeles"},
+       {facebook::velox::core::QueryConfig::kAdjustTimestampToTimezone, "true"},
+       {facebook::velox::core::QueryConfig::kMinRowsForPeeling, "50"}},
       argTypesGenerators,
       argValuesGenerators,
       referenceQueryRunner,
diff --git a/velox/expression/fuzzer/ExpressionFuzzerVerifier.cpp b/velox/expression/fuzzer/ExpressionFuzzerVerifier.cpp
index ab837099c52..9c72ff8b7a2 100644
--- a/velox/expression/fuzzer/ExpressionFuzzerVerifier.cpp
+++ b/velox/expression/fuzzer/ExpressionFuzzerVerifier.cpp
@@ -62,9 +62,10 @@ ExpressionFuzzerVerifier::ExpressionFuzzerVerifier(
     const std::unordered_map<std::string, std::shared_ptr<ArgValuesGenerator>>&
         argValuesGenerators)
     : options_(options),
-      queryCtx_(core::QueryCtx::create(
-          nullptr,
-          core::QueryConfig(options_.queryConfigs))),
+      queryCtx_(
+          core::QueryCtx::create(
+              nullptr,
+              core::QueryConfig(options_.queryConfigs))),
       execCtx_({pool_.get(), queryCtx_.get()}),
       verifier_(
           &execCtx_,
@@ -72,9 +73,10 @@ ExpressionFuzzerVerifier::ExpressionFuzzerVerifier(
            options_.reproPersistPath,
            options_.persistAndRunOnce},
           options_.expressionFuzzerOptions.referenceQueryRunner),
-      vectorFuzzer_(std::make_shared<VectorFuzzer>(
-          options_.vectorFuzzerOptions,
-          execCtx_.pool())),
+      vectorFuzzer_(
+          std::make_shared<VectorFuzzer>(
+              options_.vectorFuzzerOptions,
+              execCtx_.pool())),
       expressionFuzzer_(
           signatureMap,
           initialSeed,
@@ -175,7 +177,19 @@ ExpressionFuzzerVerifier::generateInput(
 
     // Finally create the input row.
     RowVectorPtr rowVector = vectorMaker.rowVector(names, children);
-    inputs.push_back({rowVector, SelectivityVector(vecSize)});
+    // Randomly deselect rows to exercise code paths that depend on the
+    // number of selected rows, such as the minRowsForPeeling threshold
+    // that suppresses expression peeling for small batches.
+    SelectivityVector activeRows(vecSize);
+    if (vectorFuzzer.coinToss(0.3)) {
+      for (vector_size_t i = 0; i < vecSize; ++i) {
+        if (vectorFuzzer.coinToss(0.5)) {
+          activeRows.setValid(i, false);
+        }
+      }
+      activeRows.updateBounds();
+    }
+    inputs.push_back({rowVector, activeRows});
   }
   // Return the input rows and the metadata.
   return {inputs, metadata};
@@ -327,7 +341,11 @@ void ExpressionFuzzerVerifier::retryWithTry(
     }
     // Re-evaluate the original expression on rows that didn't produce an
     // error (i.e. returned non-NULL results when evaluated with TRY).
-    inputsToRetry[i].activeRows = extractNonNullRows(tryResult.result);
+    // Intersect with the original activeRows to avoid including rows that
+    // were never evaluated (whose result values are uninitialized).
+    auto nonNullRows = extractNonNullRows(tryResult.result);
+    nonNullRows.intersect(inputsToRetry[i].activeRows);
+    inputsToRetry[i].activeRows = nonNullRows;
     if (inputsToRetry[i].activeRows.hasSelections()) {
       inputsToRetryWithoutErrors.push_back(std::move(inputsToRetry[i]));
     }
diff --git a/velox/expression/fuzzer/FuzzerRunner.cpp b/velox/expression/fuzzer/FuzzerRunner.cpp
index bc00c4fc504..ece25c8930d 100644
--- a/velox/expression/fuzzer/FuzzerRunner.cpp
+++ b/velox/expression/fuzzer/FuzzerRunner.cpp
@@ -171,6 +171,7 @@ VectorFuzzer::Options getVectorFuzzerOptions() {
   opts.stringVariableLength = true;
   opts.stringLength = 100;
   opts.nullRatio = FLAGS_null_ratio;
+  opts.useRandomNullPattern = true;
   opts.timestampPrecision =
       VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
   return opts;
diff --git a/velox/expression/fuzzer/FuzzerToolkit.h b/velox/expression/fuzzer/FuzzerToolkit.h
index e24ebabcfcd..26e5d4f6746 100644
--- a/velox/expression/fuzzer/FuzzerToolkit.h
+++ b/velox/expression/fuzzer/FuzzerToolkit.h
@@ -87,7 +87,7 @@ SignatureMapType filterSignatures(
   SignatureMapType output;
   if (!onlyFunctions.empty()) {
     // Parse, lower case and trim it.
-    std::vector<folly::StringPiece> nameList;
+    std::vector<std::string_view> nameList;
     folly::split(',', onlyFunctions, nameList);
     std::unordered_set<std::string> nameSet;
     for (const auto& it : nameList) {
diff --git a/velox/expression/fuzzer/SparkExpressionFuzzerTest.cpp b/velox/expression/fuzzer/SparkExpressionFuzzerTest.cpp
index 063e8c89fbd..c7e01bdc2e0 100644
--- a/velox/expression/fuzzer/SparkExpressionFuzzerTest.cpp
+++ b/velox/expression/fuzzer/SparkExpressionFuzzerTest.cpp
@@ -25,7 +25,7 @@
 #include "velox/exec/fuzzer/ReferenceQueryRunner.h"
 #include "velox/expression/fuzzer/FuzzerRunner.h"
 #include "velox/expression/fuzzer/SparkSpecialFormSignatureGenerator.h"
-#include "velox/functions/prestosql/fuzzer/FloorAndRoundArgTypesGenerator.h"
+#include "velox/functions/prestosql/fuzzer/FloorCeilRoundArgTypesGenerator.h"
 #include "velox/functions/sparksql/fuzzer/AddSubtractArgTypesGenerator.h"
 #include "velox/functions/sparksql/fuzzer/DivideArgTypesGenerator.h"
 #include "velox/functions/sparksql/fuzzer/MakeTimestampArgTypesGenerator.h"
@@ -88,21 +88,32 @@ int main(int argc, char** argv) {
           {"add", std::make_shared<AddSubtractArgTypesGenerator>(true)},
           {"add_deny_precision_loss",
            std::make_shared<AddSubtractArgTypesGenerator>(false)},
+          {"checked_add", std::make_shared<AddSubtractArgTypesGenerator>(true)},
+          {"checked_add_deny_precision_loss",
+           std::make_shared<AddSubtractArgTypesGenerator>(false)},
           {"subtract", std::make_shared<AddSubtractArgTypesGenerator>(true)},
           {"subtract_deny_precision_loss",
            std::make_shared<AddSubtractArgTypesGenerator>(false)},
+          {"checked_subtract",
+           std::make_shared<AddSubtractArgTypesGenerator>(true)},
+          {"checked_subtract_deny_precision_loss",
+           std::make_shared<AddSubtractArgTypesGenerator>(false)},
           {"multiply", std::make_shared<MultiplyArgTypesGenerator>(true)},
           {"multiply_deny_precision_loss",
            std::make_shared<MultiplyArgTypesGenerator>(false)},
+          {"checked_multiply",
+           std::make_shared<MultiplyArgTypesGenerator>(true)},
+          {"checked_multiply_deny_precision_loss",
+           std::make_shared<MultiplyArgTypesGenerator>(false)},
           {"divide", std::make_shared<DivideArgTypesGenerator>(true)},
           {"divide_deny_precision_loss",
            std::make_shared<DivideArgTypesGenerator>(false)},
           {"ceil",
            std::make_shared<
-               facebook::velox::exec::test::FloorAndRoundArgTypesGenerator>()},
+               facebook::velox::exec::test::FloorCeilRoundArgTypesGenerator>()},
           {"floor",
            std::make_shared<
-               facebook::velox::exec::test::FloorAndRoundArgTypesGenerator>()},
+               facebook::velox::exec::test::FloorCeilRoundArgTypesGenerator>()},
           {"unscaled_value",
            std::make_shared<UnscaledValueArgTypesGenerator>()},
           {"make_timestamp",
diff --git a/velox/expression/fuzzer/SparkSpecialFormSignatureGenerator.cpp b/velox/expression/fuzzer/SparkSpecialFormSignatureGenerator.cpp
index 0c1cef30722..f76652e2a51 100644
--- a/velox/expression/fuzzer/SparkSpecialFormSignatureGenerator.cpp
+++ b/velox/expression/fuzzer/SparkSpecialFormSignatureGenerator.cpp
@@ -20,17 +20,53 @@ namespace facebook::velox::fuzzer {
 std::vector<exec::FunctionSignaturePtr>
 SparkSpecialFormSignatureGenerator::getSignaturesForCast() const {
   std::vector<exec::FunctionSignaturePtr> signatures =
-      SpecialFormSignatureGenerator::getSignaturesForCast();
+      getCommonSignaturesForCast();
 
-  // Cast tinyint/smallint/integer/bigint as varbinary is supported in Spark.
+  // Cast integer types as varbinary is supported in Spark.
   for (auto fromType : {"tinyint", "smallint", "integer", "bigint"}) {
     signatures.push_back(makeCastSignature(fromType, "varbinary"));
   }
 
-  // Cast tinyint/smallint/integer/bigint as timestamp is supported in Spark.
-  for (auto fromType : {"tinyint", "smallint", "integer", "bigint"}) {
+  // Cast the below types as timestamp is supported in Spark.
+  for (auto fromType :
+       {"boolean",
+        "tinyint",
+        "smallint",
+        "integer",
+        "bigint",
+        "real",
+        "double"}) {
     signatures.push_back(makeCastSignature(fromType, "timestamp"));
   }
+
+  // For each supported translation pair T --> U, add signatures of array(T) -->
+  // array(U), map(varchar, T) --> map(varchar, U), row(T) --> row(U).
+  auto size = signatures.size();
+  for (auto i = 0; i < size; ++i) {
+    auto from = signatures[i]->argumentTypes()[0].baseName();
+    auto to = signatures[i]->returnType().baseName();
+
+    // Signature parsing of nested decimal type is not supported.
+    if (from == "DECIMAL" || to == "DECIMAL") {
+      continue;
+    }
+
+    signatures.push_back(makeCastSignature(
+        fmt::format("array({})", from), fmt::format("array({})", to)));
+
+    signatures.push_back(makeCastSignature(
+        fmt::format("map(varchar, {})", from),
+        fmt::format("map(varchar, {})", to)));
+
+    signatures.push_back(makeCastSignature(
+        fmt::format("row({})", from), fmt::format("row({})", to)));
+  }
+
+  // Cast timestamp as integer types is supported in Spark.
+  for (auto toType : {"tinyint", "smallint", "integer", "bigint"}) {
+    signatures.push_back(makeCastSignature("timestamp", toType));
+  }
+
   return signatures;
 }
 
diff --git a/velox/expression/fuzzer/SpecialFormSignatureGenerator.cpp b/velox/expression/fuzzer/SpecialFormSignatureGenerator.cpp
index 0428e613422..a799ffcbb42 100644
--- a/velox/expression/fuzzer/SpecialFormSignatureGenerator.cpp
+++ b/velox/expression/fuzzer/SpecialFormSignatureGenerator.cpp
@@ -51,6 +51,14 @@ void SpecialFormSignatureGenerator::addCastFromFloatingPointSignatures(
   }
 }
 
+void SpecialFormSignatureGenerator::addCastFromDecimalSignatures(
+    const std::string& toType,
+    std::vector<exec::FunctionSignaturePtr>& signatures) const {
+  for (const auto& fromType : kDecimalTypes_) {
+    signatures.push_back(makeCastSignature(fromType, toType));
+  }
+}
+
 void SpecialFormSignatureGenerator::addCastFromVarcharSignature(
     const std::string& toType,
     std::vector<exec::FunctionSignaturePtr>& signatures) const {
@@ -63,6 +71,12 @@ void SpecialFormSignatureGenerator::addCastFromTimestampSignature(
   signatures.push_back(makeCastSignature("timestamp", toType));
 }
 
+void SpecialFormSignatureGenerator::addCastFromTimeSignature(
+    const std::string& toType,
+    std::vector<exec::FunctionSignaturePtr>& signatures) const {
+  signatures.push_back(makeCastSignature("time", toType));
+}
+
 void SpecialFormSignatureGenerator::addCastFromDateSignature(
     const std::string& toType,
     std::vector<exec::FunctionSignaturePtr>& signatures) const {
@@ -156,13 +170,14 @@ SpecialFormSignatureGenerator::getSignaturesForSwitch() const {
 }
 
 std::vector<exec::FunctionSignaturePtr>
-SpecialFormSignatureGenerator::getSignaturesForCast() const {
+SpecialFormSignatureGenerator::getCommonSignaturesForCast() const {
   std::vector<exec::FunctionSignaturePtr> signatures;
 
   // To integral types.
   for (const auto& toType : kIntegralTypes_) {
     addCastFromIntegralSignatures(toType, signatures);
     addCastFromFloatingPointSignatures(toType, signatures);
+    addCastFromDecimalSignatures(toType, signatures);
     addCastFromVarcharSignature(toType, signatures);
   }
 
@@ -170,24 +185,50 @@ SpecialFormSignatureGenerator::getSignaturesForCast() const {
   for (const auto& toType : kFloatingPointTypes_) {
     addCastFromIntegralSignatures(toType, signatures);
     addCastFromFloatingPointSignatures(toType, signatures);
+    addCastFromDecimalSignatures(toType, signatures);
+    addCastFromVarcharSignature(toType, signatures);
+  }
+
+  // To decimal type.
+  for (const auto& toType : kDecimalTypes_) {
+    addCastFromIntegralSignatures(toType, signatures);
+    addCastFromFloatingPointSignatures(toType, signatures);
+    addCastFromDecimalSignatures(toType, signatures);
     addCastFromVarcharSignature(toType, signatures);
   }
 
   // To varchar type.
   addCastFromIntegralSignatures("varchar", signatures);
   addCastFromFloatingPointSignatures("varchar", signatures);
+  addCastFromDecimalSignatures("varchar", signatures);
   addCastFromVarcharSignature("varchar", signatures);
   addCastFromDateSignature("varchar", signatures);
   addCastFromTimestampSignature("varchar", signatures);
+  addCastFromTimeSignature("varchar", signatures);
 
   // To timestamp type.
   addCastFromVarcharSignature("timestamp", signatures);
   addCastFromDateSignature("timestamp", signatures);
 
+  // To time type.
+  addCastFromVarcharSignature("time", signatures);
+
   // To date type.
   addCastFromVarcharSignature("date", signatures);
   addCastFromTimestampSignature("date", signatures);
 
+  return signatures;
+}
+
+std::vector<exec::FunctionSignaturePtr>
+SpecialFormSignatureGenerator::getSignaturesForCast() const {
+  std::vector<exec::FunctionSignaturePtr> signatures =
+      getCommonSignaturesForCast();
+
+  // P4HyperLogLog <-> HyperLogLog casts
+  signatures.push_back(makeCastSignature("hyperloglog", "p4hyperloglog"));
+  signatures.push_back(makeCastSignature("p4hyperloglog", "hyperloglog"));
+
   // For each supported translation pair T --> U, add signatures of array(T) -->
   // array(U), map(varchar, T) --> map(varchar, U), row(T) --> row(U).
   auto size = signatures.size();
@@ -195,6 +236,11 @@ SpecialFormSignatureGenerator::getSignaturesForCast() const {
     auto from = signatures[i]->argumentTypes()[0].baseName();
     auto to = signatures[i]->returnType().baseName();
 
+    // Signature parsing of nested decimal type is not supported.
+    if (from == "DECIMAL" || to == "DECIMAL") {
+      continue;
+    }
+
     signatures.push_back(makeCastSignature(
         fmt::format("array({})", from), fmt::format("array({})", to)));
 
diff --git a/velox/expression/fuzzer/SpecialFormSignatureGenerator.h b/velox/expression/fuzzer/SpecialFormSignatureGenerator.h
index 2b986872c77..40e9c697857 100644
--- a/velox/expression/fuzzer/SpecialFormSignatureGenerator.h
+++ b/velox/expression/fuzzer/SpecialFormSignatureGenerator.h
@@ -45,8 +45,14 @@ class SpecialFormSignatureGenerator {
       const std::string& toType,
       std::vector<exec::FunctionSignaturePtr>& signatures) const;
 
-  /// Generates signatures for cast from varchar to the given type and adds them
-  /// to signatures.
+  /// Generates signatures for cast from decimal types to the given type
+  /// and adds them to signatures.
+  void addCastFromDecimalSignatures(
+      const std::string& toType,
+      std::vector<exec::FunctionSignaturePtr>& signatures) const;
+
+  /// Generates signatures for cast from varchar to the given type and adds
+  /// them to signatures.
   void addCastFromVarcharSignature(
       const std::string& toType,
       std::vector<exec::FunctionSignaturePtr>& signatures) const;
@@ -57,6 +63,12 @@ class SpecialFormSignatureGenerator {
       const std::string& toType,
       std::vector<exec::FunctionSignaturePtr>& signatures) const;
 
+  /// Generates signatures for cast from time to the given type and adds
+  /// them to signatures.
+  void addCastFromTimeSignature(
+      const std::string& toType,
+      std::vector<exec::FunctionSignaturePtr>& signatures) const;
+
   /// Generates signatures for cast from date to the given type and adds them to
   /// signatures.
   void addCastFromDateSignature(
@@ -85,6 +97,9 @@ class SpecialFormSignatureGenerator {
   virtual std::vector<exec::FunctionSignaturePtr> getSignaturesForSwitch()
       const;
 
+  // Returns the common signatures for the 'cast' special form.
+  std::vector<exec::FunctionSignaturePtr> getCommonSignaturesForCast() const;
+
   // Returns the signatures for the 'cast' special form.
   virtual std::vector<exec::FunctionSignaturePtr> getSignaturesForCast() const;
 
@@ -101,6 +116,12 @@ class SpecialFormSignatureGenerator {
       "boolean"};
 
   const std::vector<std::string> kFloatingPointTypes_{"real", "double"};
+
+  const std::vector<std::string> kDecimalTypes_{
+      "DECIMAL(6, 0)",
+      "DECIMAL(18, 6)",
+      "DECIMAL(38, 18)",
+      "DECIMAL(38, 38)"};
 };
 
 } // namespace facebook::velox::fuzzer
diff --git a/velox/expression/fuzzer/tests/ArgTypesGeneratorTestUtils.cpp b/velox/expression/fuzzer/tests/ArgTypesGeneratorTestUtils.cpp
index 65669c017eb..5fb81dfeaba 100644
--- a/velox/expression/fuzzer/tests/ArgTypesGeneratorTestUtils.cpp
+++ b/velox/expression/fuzzer/tests/ArgTypesGeneratorTestUtils.cpp
@@ -28,7 +28,7 @@ void assertReturnType(
   const auto argTypes = generator->generateArgs(signature, returnType, seed);
 
   // Resolve return type from argument types for the given signature.
-  exec::SignatureBinder binder(signature, argTypes);
+  exec::SignatureBinder binder(signature, argTypes, TypeCoercer::defaults());
   VELOX_CHECK(
       binder.tryBind(),
       "Failed to resolve {} from argument types.",
diff --git a/velox/expression/fuzzer/tests/ArgumentTypeFuzzerTest.cpp b/velox/expression/fuzzer/tests/ArgumentTypeFuzzerTest.cpp
index 307d86ed4c3..eaaf62c8166 100644
--- a/velox/expression/fuzzer/tests/ArgumentTypeFuzzerTest.cpp
+++ b/velox/expression/fuzzer/tests/ArgumentTypeFuzzerTest.cpp
@@ -20,6 +20,8 @@
 
 #include "velox/functions/prestosql/types/QDigestRegistration.h"
 #include "velox/functions/prestosql/types/QDigestType.h"
+#include "velox/functions/prestosql/types/SetDigestRegistration.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
 #include "velox/functions/prestosql/types/TDigestRegistration.h"
 #include "velox/functions/prestosql/types/TDigestType.h"
 #include "velox/type/Type.h"
@@ -736,4 +738,20 @@ TEST_F(ArgumentTypeFuzzerTest, qdigestType) {
   testFuzzingSuccess(signature, QDIGEST(REAL()), {DOUBLE()});
 }
 
+TEST_F(ArgumentTypeFuzzerTest, setdigestType) {
+  registerSetDigestType();
+  auto signature = exec::FunctionSignatureBuilder()
+                       .returnType("setdigest")
+                       .argumentType("bigint")
+                       .build();
+  testFuzzingSuccess(signature, SETDIGEST(), {BIGINT()});
+
+  signature = exec::FunctionSignatureBuilder()
+                  .returnType("setdigest")
+                  .argumentType("varchar")
+                  .build();
+  testFuzzingSuccess(signature, SETDIGEST(), {VARCHAR()});
+  testFuzzingSuccess(signature, SETDIGEST(), {VARCHAR()});
+}
+
 } // namespace facebook::velox::fuzzer::test
diff --git a/velox/expression/fuzzer/tests/CMakeLists.txt b/velox/expression/fuzzer/tests/CMakeLists.txt
index eed2e9ff329..6d769c105ad 100644
--- a/velox/expression/fuzzer/tests/CMakeLists.txt
+++ b/velox/expression/fuzzer/tests/CMakeLists.txt
@@ -13,6 +13,7 @@
 # limitations under the License.
 
 add_library(velox_expression_fuzzer_test_utility ArgTypesGeneratorTestUtils.cpp)
+velox_add_test_headers(velox_expression_fuzzer_test_utility ArgTypesGeneratorTestUtils.h)
 target_link_libraries(
   velox_expression_fuzzer_test_utility
   velox_expression_functions
diff --git a/velox/expression/fuzzer/tests/ExpressionFuzzerUnitTest.cpp b/velox/expression/fuzzer/tests/ExpressionFuzzerUnitTest.cpp
index 534d42482c3..12240cf813f 100644
--- a/velox/expression/fuzzer/tests/ExpressionFuzzerUnitTest.cpp
+++ b/velox/expression/fuzzer/tests/ExpressionFuzzerUnitTest.cpp
@@ -20,6 +20,8 @@
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 #include "velox/functions/prestosql/types/QDigestRegistration.h"
 #include "velox/functions/prestosql/types/QDigestType.h"
+#include "velox/functions/prestosql/types/SetDigestRegistration.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
 #include "velox/functions/prestosql/types/TDigestRegistration.h"
 #include "velox/functions/prestosql/types/TDigestType.h"
 
@@ -29,6 +31,7 @@ class ExpressionFuzzerUnitTest : public testing::Test {
   static void SetUpTestCase() {
     registerTDigestType();
     registerQDigestType();
+    registerSetDigestType();
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   }
 
@@ -60,7 +63,8 @@ class ExpressionFuzzerUnitTest : public testing::Test {
         TDIGEST(DOUBLE()),
         QDIGEST(DOUBLE()),
         QDIGEST(BIGINT()),
-        QDIGEST(REAL())};
+        QDIGEST(REAL()),
+        SETDIGEST()};
     auto index = folly::Random::rand32(kSupportedTypes.size(), seed);
     return kSupportedTypes[index];
   }
diff --git a/velox/expression/fuzzer/tests/FuzzerToolkitTest.cpp b/velox/expression/fuzzer/tests/FuzzerToolkitTest.cpp
index a54f91a11dc..deab107ec94 100644
--- a/velox/expression/fuzzer/tests/FuzzerToolkitTest.cpp
+++ b/velox/expression/fuzzer/tests/FuzzerToolkitTest.cpp
@@ -17,10 +17,12 @@
 #include "velox/expression/fuzzer/FuzzerToolkit.h"
 
 #include <gtest/gtest.h>
-#include "velox/exec/tests/utils/TempFilePath.h"
+#include "velox/common/testutil/TempFilePath.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
 namespace facebook::velox::fuzzer::test {
+using namespace facebook::velox::common::testutil;
+
 class FuzzerToolKitTest : public testing::Test,
                           public facebook::velox::test::VectorTestBase {
  protected:
@@ -51,7 +53,7 @@ TEST_F(FuzzerToolKitTest, inputRowMetadataRoundTrip) {
   metadata.columnsToWrapInCommonDictionary = {1, 2, 3, 4, 5};
 
   {
-    auto path = exec::test::TempFilePath::create();
+    auto path = TempFilePath::create();
     metadata.saveToFile(path->getPath().c_str());
     auto copy =
         InputRowMetadata::restoreFromFile(path->getPath().c_str(), pool());
diff --git a/velox/expression/rpc/AsyncRPCFunction.h b/velox/expression/rpc/AsyncRPCFunction.h
new file mode 100644
index 00000000000..06783d51b36
--- /dev/null
+++ b/velox/expression/rpc/AsyncRPCFunction.h
@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <folly/futures/Future.h>
+
+#include "velox/common/rpc/RPCTypes.h"
+#include "velox/core/QueryConfig.h"
+#include "velox/type/Type.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/FlatVector.h"
+#include "velox/vector/SelectivityVector.h"
+
+namespace facebook::velox::exec::rpc {
+
+// Import core RPC types from velox/common/rpc into this namespace so that
+// existing code in velox/expression/rpc can use them unqualified.
+using velox::rpc::RPCRequest;
+using velox::rpc::RPCResponse;
+using velox::rpc::RPCStreamingMode;
+
+/// Base interface for async RPC functions (business logic layer).
+///
+/// Lives in velox/expression/rpc/ because it is a function interface — it
+/// defines what an RPC function is (signature, dispatch, response format),
+/// analogous to VectorFunction in velox/expression/. Transport-layer types
+/// (IRPCClient, RPCRequest, RPCResponse) live in velox/common/rpc/.
+/// The execution operator (RPCOperator) that drives async dispatch lives
+/// in velox/exec/rpc/.
+///
+/// AsyncRPCFunction owns the domain-specific logic: how to dispatch RPCs
+/// from input rows (dispatchPerRow / accumulateBatch+flushBatch) and how
+/// to interpret responses back into Velox vectors (buildOutput). The
+/// function creates and holds its own transport/client internally.
+///
+/// Subclasses implement domain-specific dispatch and response handling
+/// (e.g., LLM inference, embedding calls). The RPCOperator handles async
+/// coordination: rate limiting, timeout wrapping, rowId assignment,
+/// RPCState wiring, and passthrough columns.
+///
+/// Lifecycle (called by RPCOperator):
+///   1. initialize(queryConfig, inputTypes, constantInputs) — create/cache
+///      transport and RPC clients, inspect constant values (called once
+///      during operator init).
+///   2. dispatchPerRow(rows, args) — dispatch individual RPCs per row
+///      OR accumulateBatch(rows, args) + flushBatch() — accumulate and
+///      dispatch as a batch.
+///   3. buildOutput() — convert RPC responses to output vectors.
+class AsyncRPCFunction {
+ public:
+  virtual ~AsyncRPCFunction() = default;
+
+  /// Initialize the RPC function with query configuration and constant
+  /// arguments.
+  /// Called by RPCOperator during initialize(), before any dispatch.
+  /// Use this to create/cache RPC clients, read session properties, and
+  /// inspect constant argument values (e.g., model name, options JSON).
+  ///
+  /// @param queryConfig Query configuration with session properties.
+  /// @param inputTypes Types of each argument expression.
+  /// @param constantInputs Constant values aligned with inputTypes.
+  ///        Non-constant arguments are nullptr. Constant arguments are
+  ///        single-element ConstantVectors.
+  virtual void initialize(
+      const core::QueryConfig& /*queryConfig*/,
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const std::vector<VectorPtr>& /*constantInputs*/) {}
+
+  /// Return the name of this RPC function.
+  virtual std::string name() const = 0;
+
+  /// Return the Velox type of the result column.
+  virtual TypePtr resultType() const = 0;
+
+  /// Return the service tier key for rate limiting.
+  /// Empty string means "no tier configured — uses global default limit."
+  virtual std::string tierKey() const {
+    return "";
+  }
+
+  // ── PER_ROW mode ──────────────────────────────────────────────
+
+  /// Dispatch individual RPCs for each active row.
+  /// Returns one future per active row, keyed by originalRowIndex.
+  ///
+  /// The function:
+  ///   1. Unpacks argument vectors (typed)
+  ///   2. Builds typed requests directly
+  ///   3. Dispatches via transport
+  ///   4. Returns the futures
+  ///
+  /// Null-input rows: return an immediate RPCResponse with
+  /// error="null_input".
+  virtual std::vector<std::pair<vector_size_t, folly::SemiFuture<RPCResponse>>>
+  dispatchPerRow(
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args) = 0;
+
+  // ── BATCH mode ────────────────────────────────────────────────
+
+  /// Accumulate rows for batch dispatch.
+  /// Called by the operator on each addInput(). The function unpacks typed
+  /// data from (rows, args) and stores it internally.
+  ///
+  /// Returns the original row indices for ALL processed rows (null and
+  /// non-null). For null rows, the function stores a null marker
+  /// internally. For non-null rows, the function stores typed data.
+  ///
+  /// The operator uses these indices for:
+  /// 1. storeInputBatch(flattenedColumns, rowCount)
+  /// 2. batchRowLocations_ — one entry per accumulated row
+  /// 3. batchRowIds_ — assign one rowId per accumulated row
+  virtual std::vector<vector_size_t> accumulateBatch(
+      const SelectivityVector& /*rows*/,
+      const std::vector<VectorPtr>& /*args*/) {
+    VELOX_UNSUPPORTED(
+        "accumulateBatch() not implemented for function '{}'", name());
+  }
+
+  /// Dispatch accumulated batch.
+  /// Called by the operator at flush time (noMoreInput or threshold).
+  /// The function builds the typed batch request from its internal
+  /// accumulated state and dispatches it.
+  ///
+  /// @param maxRows Maximum number of rows to flush. 0 means flush all.
+  /// Returns responses for the flushed rows. Null rows get
+  /// RPCResponse{.error = "null_input"}. This keeps the operator
+  /// completely agnostic to null handling in batch mode.
+  virtual folly::SemiFuture<std::vector<RPCResponse>> flushBatch(
+      int32_t /*maxRows*/) {
+    VELOX_UNSUPPORTED("flushBatch() not implemented for function '{}'", name());
+  }
+
+  /// Convenience overload: flush all accumulated rows.
+  virtual folly::SemiFuture<std::vector<RPCResponse>> flushBatch() {
+    return flushBatch(0);
+  }
+
+  /// Number of rows accumulated so far (for threshold checks).
+  /// Batch-capable functions MUST override this; the operator uses
+  /// function_->pendingBatchSize() >= dispatchBatchSize_ to decide
+  /// when to flush.
+  virtual int32_t pendingBatchSize() const {
+    return 0;
+  }
+
+  // ── Output ────────────────────────────────────────────────────
+
+  /// Build output vector from completed responses.
+  /// Default: VARCHAR FlatVector (errors → SQL NULL, success → string
+  /// value). Override for non-VARCHAR return types (e.g., ARRAY(REAL)
+  /// for embeddings) or custom result processing.
+  virtual VectorPtr buildOutput(
+      const std::vector<RPCResponse>& responses,
+      memory::MemoryPool* pool) const {
+    const auto numRows = static_cast<vector_size_t>(responses.size());
+    auto result =
+        BaseVector::create<FlatVector<StringView>>(VARCHAR(), numRows, pool);
+    for (vector_size_t i = 0; i < numRows; ++i) {
+      if (responses[i].hasError()) {
+        result->setNull(i, true);
+      } else {
+        result->set(i, StringView(responses[i].result));
+      }
+    }
+    return result;
+  }
+
+  // ── Congestion Control ───────────────────────────────────────
+
+  /// Signal returned by evaluateCongestion() to indicate batch health.
+  enum class CongestionSignal {
+    /// Batch completed successfully — increase concurrency window.
+    kSuccess,
+    /// Batch had errors — decrease concurrency window.
+    kError,
+    /// No congestion evaluation — skip window adjustment.
+    kNone,
+  };
+
+  /// Evaluate batch congestion from completed responses.
+  /// Called by RPCOperator after a BATCH-mode batch completes.
+  /// The function inspects responses and returns a signal that the
+  /// operator maps to window adjustments (additive increase on
+  /// kSuccess, multiplicative decrease on kError).
+  /// Default: kNone (no congestion control).
+  virtual CongestionSignal evaluateCongestion(
+      const std::vector<RPCResponse>& /*responses*/) const {
+    return CongestionSignal::kNone;
+  }
+
+  /// How much to increase the concurrency window on kSuccess.
+  /// Override to tune recovery speed per client. Default: 2.
+  virtual int64_t congestionRecoveryIncrement() const {
+    return 2;
+  }
+};
+
+} // namespace facebook::velox::exec::rpc
diff --git a/velox/expression/rpc/AsyncRPCFunctionRegistry.cpp b/velox/expression/rpc/AsyncRPCFunctionRegistry.cpp
new file mode 100644
index 00000000000..b079d8a73cc
--- /dev/null
+++ b/velox/expression/rpc/AsyncRPCFunctionRegistry.cpp
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/expression/rpc/AsyncRPCFunctionRegistry.h"
+
+#include <glog/logging.h>
+
+#include "velox/expression/rpc/RPCFunctionStubs.h"
+
+namespace facebook::velox::exec::rpc {
+
+std::mutex& AsyncRPCFunctionRegistry::mutex() {
+  static std::mutex instance;
+  return instance;
+}
+
+std::unordered_map<std::string, AsyncRPCFunctionRegistry::Factory>&
+AsyncRPCFunctionRegistry::factories() {
+  static std::unordered_map<std::string, Factory> instance;
+  return instance;
+}
+
+std::unordered_map<std::string, AsyncRPCFunctionRegistry::Signatures>&
+AsyncRPCFunctionRegistry::signatureStore() {
+  static std::unordered_map<std::string, Signatures> instance;
+  return instance;
+}
+
+bool AsyncRPCFunctionRegistry::registerFunction(
+    const std::string& name,
+    Factory factory) {
+  std::lock_guard<std::mutex> lock(mutex());
+  return registerEntryLocked(name, std::move(factory), {});
+}
+
+bool AsyncRPCFunctionRegistry::registerFunction(
+    const std::string& name,
+    Factory factory,
+    Signatures signatures) {
+  std::lock_guard<std::mutex> lock(mutex());
+  return registerEntryLocked(name, std::move(factory), std::move(signatures));
+}
+
+bool AsyncRPCFunctionRegistry::registerEntryLocked(
+    const std::string& name,
+    Factory factory,
+    Signatures signatures) {
+  auto& registry = factories();
+  if (registry.count(name) > 0) {
+    return false; // Already registered
+  }
+  registry[name] = std::move(factory);
+  if (!signatures.empty()) {
+    signatureStore()[name] = std::move(signatures);
+  }
+  // Note: Do NOT use LOG() here as this function is called during static
+  // initialization, before glog is initialized. Using LOG() would cause
+  // a SIGSEGV crash (Static Initialization Order Fiasco).
+  return true;
+}
+
+void AsyncRPCFunctionRegistry::registerStubs(
+    const std::string& namespacePrefix) {
+  std::unordered_map<std::string, Signatures> sigsCopy;
+  {
+    std::lock_guard<std::mutex> lock(mutex());
+    for (const auto& [name, sigs] : signatureStore()) {
+      if (!sigs.empty()) {
+        sigsCopy[name] = sigs;
+      }
+    }
+  }
+  LOG(INFO) << "[RPC] registerStubs: namespacePrefix='" << namespacePrefix
+            << "', found " << sigsCopy.size() << " function(s) with signatures";
+  for (auto& [name, sigs] : sigsCopy) {
+    std::string stubName = namespacePrefix + name;
+    LOG(INFO) << "[RPC] registerStubs: registering stub '" << stubName
+              << "' with " << sigs.size() << " signature(s)";
+    registerRPCFunctionStub(stubName, std::move(sigs));
+  }
+  LOG(INFO) << "[RPC] registerStubs: completed, registered " << sigsCopy.size()
+            << " stub(s)";
+}
+
+std::shared_ptr<AsyncRPCFunction> AsyncRPCFunctionRegistry::create(
+    const std::string& name) {
+  std::lock_guard<std::mutex> lock(mutex());
+  auto& registry = factories();
+  auto it = registry.find(name);
+  if (it == registry.end()) {
+    return nullptr;
+  }
+  return it->second();
+}
+
+bool AsyncRPCFunctionRegistry::isRegistered(const std::string& name) {
+  std::lock_guard<std::mutex> lock(mutex());
+  return factories().count(name) > 0;
+}
+
+std::unordered_set<std::string>
+AsyncRPCFunctionRegistry::registeredFunctions() {
+  std::lock_guard<std::mutex> lock(mutex());
+  std::unordered_set<std::string> result;
+  for (const auto& [name, _] : factories()) {
+    result.insert(name);
+  }
+  return result;
+}
+
+void AsyncRPCFunctionRegistry::testingClear() {
+  std::lock_guard<std::mutex> lock(mutex());
+  factories().clear();
+  signatureStore().clear();
+}
+
+} // namespace facebook::velox::exec::rpc
diff --git a/velox/expression/rpc/AsyncRPCFunctionRegistry.h b/velox/expression/rpc/AsyncRPCFunctionRegistry.h
new file mode 100644
index 00000000000..89002dca085
--- /dev/null
+++ b/velox/expression/rpc/AsyncRPCFunctionRegistry.h
@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "velox/expression/FunctionSignature.h"
+#include "velox/expression/rpc/AsyncRPCFunction.h"
+
+namespace facebook::velox::exec::rpc {
+
+/// Registry for AsyncRPCFunction implementations.
+///
+/// == Why a separate registry (not the VectorFunction registry)? ==
+///
+/// AsyncRPCFunctions execute via RPCOperator, completely outside the
+/// expression evaluation framework. The Velox VectorFunction registry
+/// (vectorFunctionFactories()) is designed for synchronous, expression-level
+/// functions resolved by ExprCompiler with SignatureBinder type matching.
+/// RPC functions differ in several ways:
+///
+///   1. **Execution model**: VectorFunctions run synchronously inside
+///      Expr::eval(). AsyncRPCFunctions run asynchronously via RPCOperator
+///      with futures, rate limiting, and backpressure — not part of the
+///      expression tree at all.
+///
+///   2. **No type resolution needed**: VectorFunctions need SignatureBinder
+///      because the same name can have multiple overloads (e.g., concat for
+///      varchar vs array). RPC functions have fixed signatures — the Java
+///      planner already resolved types before creating the RPCNode.
+///
+///   3. **Factory signature mismatch**: VectorFunctionFactory takes
+///      (name, inputArgs, config) and returns shared_ptr<VectorFunction>.
+///      Our factory returns shared_ptr<AsyncRPCFunction> with no args;
+///      initialization happens separately via initialize().
+///
+///   4. **Stub bridge for discovery**: We register lightweight stubs in the
+///      VectorFunction registry purely for sidecar /v1/functions discovery.
+///      The stubs throw on direct execution — actual execution goes through
+///      RPCNode → RPCOperator → AsyncRPCFunction.
+///
+/// Usage (in function's .cpp file):
+///   // For a complete example, see velox/exec/rpc/tests/DemoRPCFunction*.
+///
+///   #include "velox/expression/rpc/AsyncRPCFunctionRegistry.h"
+///   VELOX_REGISTER_RPC_FUNCTION(my_function, MyAsyncRPCFunction);
+///
+/// Lookup (in RPCOperator::initialize()):
+///   auto func = AsyncRPCFunctionRegistry::create("my_function");
+class AsyncRPCFunctionRegistry {
+ public:
+  /// Factory function type that creates an AsyncRPCFunction instance.
+  using Factory = std::function<std::shared_ptr<AsyncRPCFunction>()>;
+
+  /// Signature list type for stub registration.
+  using Signatures = std::vector<std::shared_ptr<exec::FunctionSignature>>;
+
+  /// Registers an AsyncRPCFunction factory for the given function name.
+  /// Thread-safe. Safe to call during static initialization.
+  ///
+  /// @param name Function name (e.g., "my_rpc_function")
+  /// @param factory Function that creates instances of the AsyncRPCFunction
+  /// @return true if registration succeeded, false if name already registered
+  static bool registerFunction(const std::string& name, Factory factory);
+
+  /// Registers a function factory AND its signatures for stub registration.
+  /// The factory is registered immediately. The signatures are stored and
+  /// registered as stub Velox functions later via registerStubs().
+  /// Thread-safe. Safe to call during static initialization.
+  static bool registerFunction(
+      const std::string& name,
+      Factory factory,
+      Signatures signatures);
+
+  /// Registers stub Velox functions for all functions that provided signatures.
+  /// Must be called during server startup (after config is available).
+  ///
+  /// For each registered function with signatures, registers a stub using
+  /// the given namespace prefix: namespacePrefix + functionName
+  /// e.g., "presto.default.fb_llm_inference"
+  ///
+  /// @param namespacePrefix The catalog.schema with trailing dot (e.g.,
+  /// "presto.default.")
+  static void registerStubs(const std::string& namespacePrefix);
+
+  /// Creates an AsyncRPCFunction instance for the given function name.
+  /// Thread-safe.
+  ///
+  /// @param name Function name to look up
+  /// @return AsyncRPCFunction instance, or nullptr if not registered
+  static std::shared_ptr<AsyncRPCFunction> create(const std::string& name);
+
+  /// Checks if a function name is registered.
+  /// Thread-safe.
+  ///
+  /// @param name Function name to check
+  /// @return true if the function is registered
+  static bool isRegistered(const std::string& name);
+
+  /// Returns all registered function names.
+  /// Thread-safe.
+  ///
+  /// @return Set of registered function names
+  static std::unordered_set<std::string> registeredFunctions();
+
+  /// Clears all registered functions.
+  /// Intended ONLY for unit tests to avoid test contamination.
+  /// WARNING: Do NOT call this in production code.
+  static void testingClear();
+
+ private:
+  static std::mutex& mutex();
+  static std::unordered_map<std::string, Factory>& factories();
+  static std::unordered_map<std::string, Signatures>& signatureStore();
+
+  /// Registers an entry under the lock. Caller must hold mutex().
+  static bool registerEntryLocked(
+      const std::string& name,
+      Factory factory,
+      Signatures signatures);
+};
+
+/// Helper class for static registration of AsyncRPCFunction implementations.
+///
+/// Two-argument form: registers the factory only (for RPCOperator lookup).
+/// Three-argument form: also stores signatures for deferred stub registration
+/// via registerStubs(), enabling automatic sidecar discovery.
+class AsyncRPCFunctionRegistrar {
+ public:
+  AsyncRPCFunctionRegistrar(
+      const std::string& name,
+      AsyncRPCFunctionRegistry::Factory factory) {
+    AsyncRPCFunctionRegistry::registerFunction(name, std::move(factory));
+  }
+
+  AsyncRPCFunctionRegistrar(
+      const std::string& name,
+      AsyncRPCFunctionRegistry::Factory factory,
+      AsyncRPCFunctionRegistry::Signatures signatures) {
+    AsyncRPCFunctionRegistry::registerFunction(
+        name, std::move(factory), std::move(signatures));
+  }
+};
+
+/// Convenience macros for registering AsyncRPCFunction implementations.
+/// Place in the function's .cpp file (at namespace scope).
+///
+/// The ClassName must provide:
+///   - A default constructor (or be constructible via std::make_shared)
+///   - A static signatures() method returning
+///     std::vector<std::shared_ptr<exec::FunctionSignature>>
+///
+/// BUCK target must set link_whole = True to prevent linker stripping.
+
+// Internal helper — generates a unique variable name per line.
+#define _VELOX_RPC_REGISTRAR_VAR(name, line) __velox_rpc_reg_##name##_##line
+#define _VELOX_RPC_REGISTRAR_VAR2(name, line) \
+  _VELOX_RPC_REGISTRAR_VAR(name, line)
+
+/// Register an RPC function with default make_shared factory + signatures().
+/// Usage: VELOX_REGISTER_RPC_FUNCTION(my_rpc, MyAsyncRPCFunction);
+// NOLINTNEXTLINE(facebook-avoid-non-const-global-variables)
+#define VELOX_REGISTER_RPC_FUNCTION(name, ClassName)                           \
+  static ::facebook::velox::exec::rpc::AsyncRPCFunctionRegistrar               \
+  _VELOX_RPC_REGISTRAR_VAR2(name, __LINE__)(                                   \
+      #name,                                                                   \
+      []()                                                                     \
+          -> std::shared_ptr<::facebook::velox::exec::rpc::AsyncRPCFunction> { \
+            return std::make_shared<ClassName>();                              \
+          },                                                                   \
+      ClassName::signatures())
+
+/// Register an RPC function with a custom factory and explicit signatures.
+/// Usage: VELOX_REGISTER_RPC_FUNCTION_CUSTOM_FACTORY(
+///            my_rpc, myFactoryFn, MyClass::signatures());
+// NOLINTNEXTLINE(facebook-avoid-non-const-global-variables)
+#define VELOX_REGISTER_RPC_FUNCTION_CUSTOM_FACTORY(name, factory, sigs) \
+  static ::facebook::velox::exec::rpc::AsyncRPCFunctionRegistrar        \
+  _VELOX_RPC_REGISTRAR_VAR2(name, __LINE__)(#name, (factory), (sigs))
+
+} // namespace facebook::velox::exec::rpc
diff --git a/velox/expression/rpc/CMakeLists.txt b/velox/expression/rpc/CMakeLists.txt
new file mode 100644
index 00000000000..4710f1e89cf
--- /dev/null
+++ b/velox/expression/rpc/CMakeLists.txt
@@ -0,0 +1,48 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+velox_install_library_headers()
+
+velox_add_library(velox_async_rpc_function INTERFACE AsyncRPCFunction.h)
+
+velox_link_libraries(
+  velox_async_rpc_function
+  INTERFACE velox_rpc_types velox_core velox_type velox_vector Folly::folly
+)
+
+velox_add_library(velox_rpc_function_stubs RPCFunctionStubs.cpp HEADERS RPCFunctionStubs.h)
+
+velox_link_libraries(
+  velox_rpc_function_stubs
+  velox_expression_functions
+  velox_expression
+  glog::glog
+)
+
+velox_add_library(
+  velox_async_rpc_function_registry
+  AsyncRPCFunctionRegistry.cpp
+  HEADERS
+  AsyncRPCFunctionRegistry.h
+)
+
+velox_link_libraries(
+  velox_async_rpc_function_registry
+  velox_async_rpc_function
+  velox_rpc_function_stubs
+  velox_common_base
+  velox_exception
+  velox_expression_functions
+  glog::glog
+)
diff --git a/velox/expression/rpc/RPCFunctionStubs.cpp b/velox/expression/rpc/RPCFunctionStubs.cpp
new file mode 100644
index 00000000000..038c1726702
--- /dev/null
+++ b/velox/expression/rpc/RPCFunctionStubs.cpp
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/expression/rpc/RPCFunctionStubs.h"
+
+#include <glog/logging.h>
+
+#include "velox/expression/VectorFunction.h"
+
+namespace facebook::velox::exec::rpc {
+namespace {
+
+/// A stub VectorFunction that throws on execution.
+/// This exists only to register the function's signature with the Velox
+/// function registry so the sidecar can discover it via /v1/functions.
+/// The Java planner rewrites RPC function calls to RPCNode before they
+/// reach the executor, so this stub should never actually be invoked.
+class RPCStubFunction : public exec::VectorFunction {
+ public:
+  explicit RPCStubFunction(const std::string& name) : name_(name) {}
+
+  void apply(
+      const SelectivityVector& /*rows*/,
+      std::vector<VectorPtr>& /*args*/,
+      const TypePtr& /*outputType*/,
+      exec::EvalCtx& /*context*/,
+      VectorPtr& /*result*/) const override {
+    VELOX_FAIL(
+        "RPC function '{}' should not be called directly. "
+        "The query plan should have been rewritten by RpcFunctionOptimizer "
+        "to use RPCNode/RPCOperator.",
+        name_);
+  }
+
+ private:
+  std::string name_;
+};
+
+} // namespace
+
+void registerRPCFunctionStub(
+    const std::string& name,
+    std::vector<std::shared_ptr<exec::FunctionSignature>> signatures) {
+  LOG(INFO) << "[RPC] registerRPCFunctionStub: registering Velox stub '" << name
+            << "' with " << signatures.size() << " signature(s)";
+  exec::registerStatefulVectorFunction(
+      name,
+      std::move(signatures),
+      [name](
+          const std::string& /*name*/,
+          const std::vector<exec::VectorFunctionArg>& /*inputArgs*/,
+          const core::QueryConfig& /*config*/) {
+        return std::make_shared<RPCStubFunction>(name);
+      });
+  LOG(INFO) << "[RPC] registerRPCFunctionStub: successfully registered '"
+            << name << "' in Velox function registry";
+}
+
+} // namespace facebook::velox::exec::rpc
diff --git a/velox/expression/rpc/RPCFunctionStubs.h b/velox/expression/rpc/RPCFunctionStubs.h
new file mode 100644
index 00000000000..6996a726848
--- /dev/null
+++ b/velox/expression/rpc/RPCFunctionStubs.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "velox/expression/FunctionSignature.h"
+
+namespace facebook::velox::exec::rpc {
+
+/// Registers a stub Velox vector function for an RPC function.
+/// The stub has the correct signature but throws on direct execution.
+/// This makes the function discoverable via the /v1/functions sidecar endpoint.
+///
+/// @param name Full 3-part Velox name (e.g., "native.rpc.fb_llm_inference")
+/// @param signatures Function signatures (arg types, return type)
+void registerRPCFunctionStub(
+    const std::string& name,
+    std::vector<std::shared_ptr<exec::FunctionSignature>> signatures);
+
+} // namespace facebook::velox::exec::rpc
diff --git a/velox/expression/signature_parser/CMakeLists.txt b/velox/expression/signature_parser/CMakeLists.txt
index 58377ba206d..9b4fb52737f 100644
--- a/velox/expression/signature_parser/CMakeLists.txt
+++ b/velox/expression/signature_parser/CMakeLists.txt
@@ -48,5 +48,9 @@ velox_add_library(
   ${BISON_SignatureParser_OUTPUTS}
   ${FLEX_SignatureParserScanner_OUTPUTS}
   ParseUtil.cpp
+  HEADERS
+  ParseUtil.h
+  Scanner.h
+  SignatureParser.h
 )
 velox_link_libraries(velox_signature_parser velox_common_base velox_type)
diff --git a/velox/expression/signature_parser/Scanner.h b/velox/expression/signature_parser/Scanner.h
index 9733cf079c3..f7cf41f3dec 100644
--- a/velox/expression/signature_parser/Scanner.h
+++ b/velox/expression/signature_parser/Scanner.h
@@ -36,6 +36,9 @@ class Scanner : public yyFlexLexer {
       : yyFlexLexer(&arg_yyin, &arg_yyout),
         outputType_(outputType),
         input_(input) {}
+
+  ~Scanner() = default;
+
   int lex(Parser::semantic_type* yylval);
 
   void setTypeSignature(TypeSignaturePtr type) {
diff --git a/velox/expression/signature_parser/SignatureParser.ll b/velox/expression/signature_parser/SignatureParser.ll
index 6ba5006b2da..17950877f4d 100644
--- a/velox/expression/signature_parser/SignatureParser.ll
+++ b/velox/expression/signature_parser/SignatureParser.ll
@@ -1,3 +1,4 @@
+%option 8bit
 %{
 #include <vector>
 #include <memory>
@@ -31,7 +32,7 @@ std::string unescape_doublequote(const char* yytext) {
 }
 %}
 
-%option c++ noyywrap noyylineno nodefault caseless
+%option c++ noyywrap noyylineno nodefault caseless 8bit
 
 A   [A|a]
 B   [B|b]
@@ -66,6 +67,7 @@ ROW               (ROW|STRUCT)
 "("                return Parser::token::LPAREN;
 ")"                return Parser::token::RPAREN;
 ","                return Parser::token::COMMA;
+"..."              return Parser::token::ELLIPSIS;
 (ARRAY)            return Parser::token::ARRAY;
 (MAP)              return Parser::token::MAP;
 (FUNCTION)         return Parser::token::FUNCTION;
diff --git a/velox/expression/signature_parser/SignatureParser.yy b/velox/expression/signature_parser/SignatureParser.yy
index 5453d2fc794..c79067e96ce 100644
--- a/velox/expression/signature_parser/SignatureParser.yy
+++ b/velox/expression/signature_parser/SignatureParser.yy
@@ -27,13 +27,15 @@
     #define yylex(x) scanner->lex(x)
 }
 
-%token               LPAREN RPAREN COMMA ARRAY MAP ROW FUNCTION
+%token               LPAREN RPAREN COMMA ARRAY MAP ROW FUNCTION ELLIPSIS
 %token <std::string> WORD VARIABLE QUOTED_ID DECIMAL
 %token YYEOF         0
 
+%expect 0
+
 %nterm <std::shared_ptr<exec::TypeSignature>> special_type function_type decimal_type row_type array_type map_type
-%nterm <std::shared_ptr<exec::TypeSignature>> type named_type
-%nterm <std::vector<exec::TypeSignature>> type_list type_list_opt_names
+%nterm <std::shared_ptr<exec::TypeSignature>> type named_type row_field
+%nterm <std::vector<exec::TypeSignature>> type_list row_field_list
 %nterm <std::vector<std::string>> type_with_spaces
 
 %%
@@ -71,14 +73,24 @@ type_list : type                   { $$.push_back(*($1)); }
           | type_list COMMA type   { $1.push_back(*($3)); $$ = std::move($1); }
           ;
 
-type_list_opt_names : named_type                           { $$.push_back(*($1)); }
-                    | type_list_opt_names COMMA named_type { $1.push_back(*($3)); $$ = std::move($1); }
-                    | type                                 { $$.push_back(*($1)); }
-                    | type_list_opt_names COMMA type       { $1.push_back(*($3)); $$ = std::move($1); }
-                    ;
+row_field : named_type { $$ = $1; }
+          | type       { $$ = $1; }
+          ;
 
-row_type : ROW LPAREN type_list_opt_names RPAREN  { $$ = std::make_shared<exec::TypeSignature>("row", $3); }
-         ;
+row_field_list : row_field { $$.push_back(*($1)); }
+               | row_field_list COMMA row_field { $1.push_back(*($3)); $$ = std::move($1); }
+               ;
+
+row_type
+    : ROW LPAREN row_field RPAREN
+        { std::vector<exec::TypeSignature> params; params.push_back(*($3)); $$ = std::make_shared<exec::TypeSignature>("row", params); }
+    | ROW LPAREN row_field COMMA ELLIPSIS RPAREN
+        { if ($3->rowFieldName().has_value()) { VELOX_FAIL("Homogeneous row cannot have a field name"); } std::vector<exec::TypeSignature> params; params.push_back(*($3)); $$ = std::make_shared<exec::TypeSignature>("row", params, std::nullopt, true); }
+    | ROW LPAREN row_field COMMA row_field_list RPAREN
+        { std::vector<exec::TypeSignature> params; params.push_back(*($3)); for (auto& f : $5) { params.push_back(f); } $$ = std::make_shared<exec::TypeSignature>("row", params); }
+    ;
+
+// Homogeneous rows use only the explicit pattern: row(T, ...)
 
 array_type : ARRAY LPAREN type RPAREN             { $$ = std::make_shared<exec::TypeSignature>(exec::TypeSignature("array", { *($3) })); }
            | ARRAY LPAREN type_with_spaces RPAREN { $$ = std::make_shared<exec::TypeSignature>(exec::TypeSignature("array", { *inferTypeWithSpaces($3) })); }
diff --git a/velox/expression/signature_parser/tests/ParseTypeSignatureTest.cpp b/velox/expression/signature_parser/tests/ParseTypeSignatureTest.cpp
index 811c2077a93..0de3f5f9bf0 100644
--- a/velox/expression/signature_parser/tests/ParseTypeSignatureTest.cpp
+++ b/velox/expression/signature_parser/tests/ParseTypeSignatureTest.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 #include <gtest/gtest.h>
-
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/expression/signature_parser/SignatureParser.h"
 
 using namespace facebook::velox::exec;
@@ -191,7 +191,7 @@ TEST_F(ParseTypeSignatureTest, row) {
     ASSERT_EQ(signature.parameters().size(), 1);
   }
 
-  // test quoted row fields.
+  // Test quoted row fields.
   {
     auto signature = parseTypeSignature("row(\"12col0\" v, l)");
     ASSERT_EQ(signature.baseName(), "row");
@@ -261,6 +261,53 @@ TEST_F(ParseTypeSignatureTest, row) {
   EXPECT_THROW(parseTypeSignature("row(\"a\"b\" INTEGER)"), VeloxRuntimeError);
 }
 
+TEST_F(ParseTypeSignatureTest, homogeneousRow) {
+  {
+    auto signature = parseTypeSignature("row(varchar, ...)");
+    ASSERT_TRUE(signature.isHomogeneousRow());
+    ASSERT_EQ(signature.toString(), "row(varchar, ...)");
+
+    ASSERT_EQ(signature.baseName(), "row");
+    ASSERT_EQ(signature.parameters().size(), 1);
+    auto field = signature.parameters()[0];
+    ASSERT_EQ(field.baseName(), "varchar");
+    ASSERT_FALSE(field.variableArity());
+  }
+
+  {
+    auto signature = parseTypeSignature("row(T, ...)");
+    ASSERT_TRUE(signature.isHomogeneousRow());
+    ASSERT_EQ(signature.toString(), "row(T, ...)");
+
+    ASSERT_EQ(signature.baseName(), "row");
+    ASSERT_EQ(signature.parameters().size(), 1);
+    auto field = signature.parameters()[0];
+    ASSERT_EQ(field.baseName(), "T");
+    ASSERT_FALSE(field.variableArity());
+  }
+
+  {
+    auto signature = parseTypeSignature("row(array(bigint), ...)");
+    ASSERT_TRUE(signature.isHomogeneousRow());
+    ASSERT_EQ(signature.toString(), "row(array(bigint), ...)");
+
+    ASSERT_EQ(signature.baseName(), "row");
+    ASSERT_EQ(signature.parameters().size(), 1);
+    auto field = signature.parameters()[0];
+    ASSERT_EQ(field.baseName(), "array");
+    ASSERT_FALSE(field.variableArity());
+  }
+
+  VELOX_ASSERT_RUNTIME_THROW(
+      parseTypeSignature("row(integer, boolean, ...)"),
+      "Failed to parse type signature [row(integer, boolean, ...)]: syntax error, unexpected ELLIPSIS");
+
+  // Homogeneous row with named field is not allowed.
+  VELOX_ASSERT_RUNTIME_THROW(
+      parseTypeSignature("row(name varchar, ...)"),
+      "Homogeneous row cannot have a field name");
+}
+
 TEST_F(ParseTypeSignatureTest, tdigest) {
   auto signature = parseTypeSignature("tdigest(double)");
   ASSERT_EQ(signature.baseName(), "tdigest");
@@ -281,10 +328,15 @@ TEST_F(ParseTypeSignatureTest, roundTrip) {
 
   ASSERT_EQ(roundTrip("function(S,R)"), "function(S,R)");
 
-  // Test a complex type as the second field in a row
+  // Test a complex type as the second field in a row.
   ASSERT_EQ(
       roundTrip("row(map(K,V),map(bigint,array(double)))"),
       "row(map(K,V),map(bigint,array(double)))");
+
+  // Test homogeneous row round-trip parsing.
+  ASSERT_EQ(roundTrip("row(T, ...)"), "row(T, ...)");
+  ASSERT_EQ(roundTrip("row(varchar, ...)"), "row(varchar, ...)");
+  ASSERT_EQ(roundTrip("row(bigint, ...)"), "row(bigint, ...)");
 }
 
 TEST_F(ParseTypeSignatureTest, invalidSignatures) {
diff --git a/velox/expression/tests/ArrayViewTest.cpp b/velox/expression/tests/ArrayViewTest.cpp
index 27e6e9781d9..2ee9d67de65 100644
--- a/velox/expression/tests/ArrayViewTest.cpp
+++ b/velox/expression/tests/ArrayViewTest.cpp
@@ -494,7 +494,7 @@ TEST_F(NullFreeArrayViewTest, materialize) {
 
 TEST_F(NullableArrayViewTest, materialize) {
   auto result = evaluate(
-      "array_constructor(1, 2, NULL, 4, NULL)",
+      "array_constructor(1, 2, null::bigint, 4, null::bigint)",
       makeRowVector({makeFlatVector<int64_t>(1)}));
 
   DecodedVector decoded;
@@ -508,7 +508,7 @@ TEST_F(NullableArrayViewTest, materialize) {
 
 TEST_F(NullableArrayViewTest, materializeNested) {
   auto result = evaluate(
-      "array_constructor(array_constructor(1), array_constructor(1, NULL), NULL)",
+      "array_constructor(array_constructor(1), array_constructor(1, null::bigint), null::bigint[])",
       makeRowVector({makeFlatVector<int64_t>(1)}));
 
   DecodedVector decoded;
@@ -534,7 +534,7 @@ TEST_F(NullableArrayViewTest, materializeArrayWithOpaque) {
   registerFunction<MakeOpaqueFunc, std::shared_ptr<int64_t>>({"make_opaque"});
 
   auto result = evaluate(
-      "array_constructor(make_opaque(), null)",
+      "array_constructor(make_opaque(), null::\"OPAQUE<void>\")",
       makeRowVector({makeFlatVector<int64_t>(1)}));
 
   DecodedVector decoded;
@@ -579,7 +579,7 @@ TEST_F(NullableArrayViewTest, materializeArrayOfCustomTypes) {
   registerFunction<MakeUDTFunc, UDTTypeRegistrar::SimpleType>({"make_udt"});
 
   auto result = evaluate(
-      "array_constructor(make_udt(), null, make_udt(), make_udt())",
+      "array_constructor(make_udt(), null::materializeTestUDT, make_udt(), make_udt())",
       makeRowVector({makeFlatVector<int64_t>(1)}));
 
   DecodedVector decoded;
diff --git a/velox/expression/tests/ArrayWriterTest.cpp b/velox/expression/tests/ArrayWriterTest.cpp
index f62f5fbdf5d..3594b7d02e8 100644
--- a/velox/expression/tests/ArrayWriterTest.cpp
+++ b/velox/expression/tests/ArrayWriterTest.cpp
@@ -20,7 +20,9 @@
 #include <cstdint>
 #include <memory>
 
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/testutil/OptionalEmpty.h"
+#include "velox/common/testutil/TestValue.h"
 #include "velox/expression/VectorWriters.h"
 #include "velox/functions/Udf.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
@@ -122,6 +124,12 @@ class ArrayWriterTest : public functions::test::FunctionBaseTest {
     writer.writer->setOffset(0);
     return writer;
   }
+
+ protected:
+  static void SetUpTestCase() {
+    FunctionBaseTest::SetUpTestCase();
+    common::testutil::TestValue::enable();
+  }
 };
 
 TEST_F(ArrayWriterTest, addNull) {
@@ -681,7 +689,7 @@ TEST_F(ArrayWriterTest, copyFromNullableArrayView) {
       {"copy_from_nullable"});
 
   auto result = evaluate(
-      "copy_from_nullable(array_constructor(1, null, 3, null, 5))",
+      "copy_from_nullable(array_constructor(1, null::bigint, 3, null::bigint, 5))",
       makeRowVector({makeFlatVector<int64_t>(1)}));
 
   // Test results.
@@ -704,7 +712,7 @@ TEST_F(ArrayWriterTest, copyFromNestedNullableArrayView) {
       Array<Array<int64_t>>>({"copy_from_nullable_nested"});
 
   auto result = evaluate(
-      "copy_from_nullable_nested(array_constructor(array_constructor(1), array_constructor(3, null, 5)))",
+      "copy_from_nullable_nested(array_constructor(array_constructor(1), array_constructor(3, null::bigint, 5)))",
       makeRowVector({makeFlatVector<int64_t>(1)}));
 
   // Test results.
@@ -761,7 +769,7 @@ TEST_F(ArrayWriterTest, addItems) {
   {
     // call path.
     auto result = evaluate(
-        "add_items_test(array_constructor(10, null))",
+        "add_items_test(array_constructor(10, null::bigint))",
         makeRowVector({makeFlatVector<int64_t>(1)}));
 
     // Test results.
@@ -1102,5 +1110,36 @@ TEST_F(ArrayWriterTest, errorHandlingE2E) {
            "null"}));
 }
 
+DEBUG_ONLY_TEST_F(ArrayWriterTest, resizeErrorHandling) {
+  // When resizing the element Vector it's possible that an error is thrown,
+  // e.g. due to running out of memory or the Driver shutting down, ensure the
+  // Writer does not end up in an inconsistent state when this happens.
+  auto [result, vectorWriter] = makeTestWriter();
+  const auto elementsVector = vectorWriter->vector().elements();
+
+  vectorWriter->setOffset(0);
+  auto& arrayWriter = vectorWriter->current();
+  arrayWriter.add_item() = 100;
+
+  // Simulate an error growing the Values Buffer in the element's Vector.
+  {
+    const std::string errorMessage = "Simulated failure in memory allocation";
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::FlatVector::resizeValues",
+        std::function<void(FlatVector<int64_t>*)>(
+            [&](FlatVector<int64_t>*) { VELOX_FAIL(errorMessage); }));
+    VELOX_ASSERT_THROW(arrayWriter.add_item(), errorMessage);
+  }
+
+  // The elements Vector should not have been resized due to the error.
+  VELOX_CHECK_EQ(elementsVector->size(), 1);
+
+  // If we call add_item again it should resize the elements Vector to
+  // accommodate the new element. If the ArrayWriter is in an invalid state it
+  // will think the elements has already been resized.
+  arrayWriter.add_item() = 200;
+  VELOX_CHECK_EQ(elementsVector->size(), 2);
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/expression/tests/CMakeLists.txt b/velox/expression/tests/CMakeLists.txt
index e4ed15686f2..41ba185f317 100644
--- a/velox/expression/tests/CMakeLists.txt
+++ b/velox/expression/tests/CMakeLists.txt
@@ -23,6 +23,8 @@ add_executable(
   CustomTypeTest.cpp
   ExprCompilerTest.cpp
   ExprEncodingsTest.cpp
+  ExprOptimizerTest.cpp
+  ExprRewriteRegistryTest.cpp
   ExprStatsTest.cpp
   ExprTest.cpp
   ExprToSubfieldFilterTest.cpp
@@ -35,6 +37,7 @@ add_executable(
   Main.cpp
   MapViewTest.cpp
   MapWriterTest.cpp
+  NullIfExprTest.cpp
   PeeledEncodingTest.cpp
   ReverseSignatureBinderTest.cpp
   RowViewTest.cpp
@@ -44,11 +47,16 @@ add_executable(
   SimpleFunctionInitTest.cpp
   SimpleFunctionPresetNullsTest.cpp
   SimpleFunctionTest.cpp
+  SpecialFormRewriteTestBase.cpp
+  SwitchRewriteTest.cpp
+  CoalesceRewriteTest.cpp
+  ConjunctRewriteTest.cpp
   StringWriterTest.cpp
   TryExprTest.cpp
   VariadicViewTest.cpp
   VectorReaderTest.cpp
 )
+velox_add_test_headers(velox_expression_test SpecialFormRewriteTestBase.h)
 if(VELOX_ENABLE_GEO)
   target_compile_definitions(velox_expression_test PRIVATE VELOX_ENABLE_GEO)
 endif()
@@ -87,6 +95,7 @@ target_link_libraries(
 )
 
 add_library(velox_expression_verifier ExpressionVerifier.cpp)
+velox_add_test_headers(velox_expression_verifier ExpressionVerifier.h)
 
 target_link_libraries(
   velox_expression_verifier
@@ -98,6 +107,7 @@ target_link_libraries(
 )
 
 add_library(velox_expression_runner ExpressionRunner.cpp)
+velox_add_test_headers(velox_expression_runner ExpressionRunner.h)
 target_link_libraries(
   velox_expression_runner
   velox_expression_verifier
@@ -127,7 +137,7 @@ target_link_libraries(
   velox_expression_verifier_unit_test
   velox_expression_verifier
   velox_file
-  velox_temp_path
+  velox_test_util
   velox_parse_expression
   velox_parse_parser
   velox_parse_utils
@@ -146,7 +156,7 @@ target_link_libraries(
   velox_expression_fuzzer
   velox_expression_verifier
   velox_function_registry
-  velox_temp_path
+  velox_test_util
   velox_exec_test_lib
   velox_vector_test_lib
   GTest::gtest
diff --git a/velox/expression/tests/CastExprTest.cpp b/velox/expression/tests/CastExprTest.cpp
index ddcce34de30..a22922e0636 100644
--- a/velox/expression/tests/CastExprTest.cpp
+++ b/velox/expression/tests/CastExprTest.cpp
@@ -27,6 +27,7 @@
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/type/Type.h"
 #include "velox/type/tests/utils/CustomTypesForTesting.h"
+#include "velox/type/tz/TimeZoneMap.h"
 #include "velox/vector/BaseVector.h"
 #include "velox/vector/TypeAliases.h"
 
@@ -1709,6 +1710,19 @@ TEST_F(CastExprTest, decimalToFloat) {
   testDecimalToFloatCasts<double>();
 }
 
+// Test for precision loss fix: DECIMAL(18,4) to REAL. Float has ~7 significant
+// digits; casting unscaled int128/int64 to float first loses precision for
+// values with 8+ digits. The fix divides in double then casts to float.
+TEST_F(CastExprTest, decimalToFloatNoPrecisionLoss) {
+  const int64_t unscaledSum = 113751964; // 11375.1964 with scale 4
+  auto decimalVector = makeFlatVector<int64_t>({unscaledSum}, DECIMAL(18, 4));
+  auto result = evaluateCast(
+      DECIMAL(18, 4), REAL(), makeRowVector({decimalVector}), false);
+  auto floatResult = result->as<FlatVector<float>>()->valueAt(0);
+  EXPECT_NEAR(floatResult, 11375.196f, 0.0005f)
+      << "cast(DECIMAL(18,4) 11375.1964 as REAL) should be ~11375.196, not 11375.197";
+}
+
 TEST_F(CastExprTest, decimalToBool) {
   auto shortFlat = makeNullableFlatVector<int64_t>(
       {DecimalUtil::kShortDecimalMin, 0, std::nullopt}, DECIMAL(18, 18));
@@ -2838,14 +2852,6 @@ class BigintTypeWithCustomComparisonCastOperator final
     return {std::shared_ptr<const CastOperator>{}, &kInstance};
   }
 
-  bool isSupportedFromType(const TypePtr& other) const override {
-    return true;
-  }
-
-  bool isSupportedToType(const TypePtr& other) const override {
-    return true;
-  }
-
   void castTo(
       const BaseVector& input,
       exec::EvalCtx& context,
@@ -2975,5 +2981,1217 @@ TEST_F(CastExprTest, skipUnnecessaryChildrenOfComplexTypes) {
     testCast(mapVector, expectedMapVector);
   }
 }
+
+TEST_F(CastExprTest, timeToVarcharCast) {
+  {
+    // Test casting TIME to VARCHAR
+
+    // Test various TIME values (milliseconds since midnight)
+    // 0 = 00:00:00.000
+    // 3661000 = 01:01:01.000
+    // 43200000 = 12:00:00.000 (noon)
+    // 86399999 = 23:59:59.999
+    auto timeVector =
+        makeFlatVector<int64_t>({0, 3661000, 43200000, 86399999}, TIME());
+
+    auto result = evaluate<FlatVector<StringView>>(
+        "cast(c0 as varchar)", makeRowVector({timeVector}));
+
+    auto expected = makeFlatVector<StringView>(
+        {"00:00:00.000", "01:01:01.000", "12:00:00.000", "23:59:59.999"});
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test casting TIME to VARCHAR with nulls
+    auto timeVector = makeNullableFlatVector<int64_t>(
+        {0, std::nullopt, 43200000, std::nullopt}, TIME());
+
+    auto result = evaluate<FlatVector<StringView>>(
+        "cast(c0 as varchar)", makeRowVector({timeVector}));
+
+    auto expected = makeNullableFlatVector<StringView>(
+        {"00:00:00.000", std::nullopt, "12:00:00.000", std::nullopt});
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test try_cast for TIME to VARCHAR
+    auto timeVector = makeFlatVector<int64_t>({0, 43200000}, TIME());
+
+    auto result = evaluate<FlatVector<StringView>>(
+        "try_cast(c0 as varchar)", makeRowVector({timeVector}));
+
+    auto expected =
+        makeFlatVector<StringView>({"00:00:00.000", "12:00:00.000"});
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test across different time zones with America/Los_Angeles timezone
+
+    // Test various TIME values (milliseconds since midnight)
+    // Los Angeles is UTC-8 (standard time) or UTC-7 (daylight saving time)
+    auto timeVector = makeFlatVector<int64_t>(
+        {
+            0, // 00:00:00.000 UTC -> should adjust for timezone
+            3661000, // 01:01:01.000 UTC -> should adjust for timezone
+            43200000, // 12:00:00.000 UTC -> should adjust for timezone
+            86399999, // 23:59:59.999 UTC -> should adjust for timezone
+            25200000, // 07:00:00.000 UTC -> should adjust for timezone
+            72000000 // 20:00:00.000 UTC -> should adjust for timezone
+        },
+        TIME());
+
+    // With timezone displacement, the times should be adjusted
+    // Note: The exact expected values depend on the timezone implementation
+    // This test verifies that timezone-aware casting is working
+
+    {
+      // In Daylight savings time at session start time below.
+      setSessionStartTimeAndTimeZone(
+          1756710000000, "America/Los_Angeles"); // 2025-09-01T00:00:00.000
+
+      auto result = evaluate<FlatVector<StringView>>(
+          "cast(c0 as varchar)", makeRowVector({timeVector}));
+
+      auto expected = makeFlatVector<StringView>({
+          "17:00:00.000", // 00:00:00.000 - 7 hours = 17:00:00.000 (previous
+                          // day)
+          "18:01:01.000", // 01:01:01.000 - 7 hours = 18:01:01.000 (previous
+                          // day)
+          "05:00:00.000", // 12:00:00.000 - 7 hours = 05:00:00.000
+          "16:59:59.999", // 23:59:59.999 - 7 hours = 16:59:59.999
+          "00:00:00.000", // 07:00:00.000 - 7 hours = 00:00:00.000 (mid night)
+          "13:00:00.000" // 20:00:00.000 - 7 hours = 12:00:00.000
+      });
+
+      assertEqualVectors(expected, result);
+    }
+
+    {
+      // Not In Daylight savings time at session start time below.
+      setSessionStartTimeAndTimeZone(
+          1762761600000, "America/Los_Angeles"); // 025-11-10T00:00:00.000
+
+      auto result = evaluate<FlatVector<StringView>>(
+          "cast(c0 as varchar)", makeRowVector({timeVector}));
+
+      auto expected = makeFlatVector<StringView>({
+          "16:00:00.000", // 00:00:00.000 - 8 hours = 16:00:00.000 (previous
+                          // day)
+          "17:01:01.000", // 01:01:01.000 - 8 hours = 17:01:01.000 (previous
+                          // day)
+          "04:00:00.000", // 12:00:00.000 - 8 hours = 04:00:00.000
+          "15:59:59.999", // 23:59:59.999 - 8 hours = 15:59:59.999
+          "23:00:00.000", // 07:00:00.000 - 8 hours = 23:00:00.000 (previous
+                          // day)
+          "12:00:00.000" // 20:00:00.000 - 8 hours = 12:00:00.000
+      });
+
+      assertEqualVectors(expected, result);
+    }
+
+    {
+      // Try this again with a different timezone
+      setTimezone("Australia/Perth");
+
+      auto result = evaluate<FlatVector<StringView>>(
+          "cast(c0 as varchar)", makeRowVector({timeVector}));
+
+      // Perth is always UTC+8 (no daylight saving time)
+      auto expected = makeFlatVector<StringView>({
+          "08:00:00.000", // 00:00:00.000 + 8 hours
+          "09:01:01.000", // 01:01:01.000 + 8 hours
+          "20:00:00.000", // 12:00:00.000 + 8 hours
+          "07:59:59.999", // 23:59:59.999 + 8 hours (wraps around)
+          "15:00:00.000", // 07:00:00.000 + 8 hours
+          "04:00:00.000" // 20:00:00.000 + 8 hours (wraps around)
+      });
+
+      assertEqualVectors(expected, result);
+    }
+  }
+
+  {
+    // Test during daylight saving time , March 10, 2024 09:00:00 AM UTC
+    // Spring forward. The clock jumps forward 1 hour, from 2:00 AM to 3:00 AM.
+    setSessionStartTimeAndTimeZone(1710061200000, "America/Los_Angeles");
+
+    auto timeVector = makeFlatVector<int64_t>(
+        {
+            0, // 00:00:00.000 UTC -> should adjust for timezone
+            3661000, // 01:01:01.000 UTC -> should adjust for timezone
+            43200000, // 12:00:00.000 UTC -> should adjust for timezone
+            86399999, // 23:59:59.999 UTC -> should adjust for timezone
+            25200000, // 07:00:00.000 UTC -> should adjust for timezone
+            72000000 // 20:00:00.000 UTC -> should adjust for timezone
+        },
+        TIME());
+
+    auto result = evaluate<FlatVector<StringView>>(
+        "cast(c0 as varchar)", makeRowVector({timeVector}));
+
+    auto expected = makeFlatVector<StringView>({
+        "16:00:00.000", // 00:00:00.000 - 8 hours = 16:00:00.000 (previous
+                        // day)
+        "17:01:01.000", // 01:01:01.000 - 8 hours = 17:01:01.000 (previous
+                        // day)
+        "05:00:00.000", // 12:00:00.000 - 7 hours = 05:00:00.000
+        "16:59:59.999", // 23:59:59.999 - 7 hours = 16:59:59.999
+        "23:00:00.000", // 07:00:00.000 - 8 hours = 23:00:00.000 (previous
+                        // day)
+        "13:00:00.000" // 20:00:00.000 - 7 hours = 13:00:00.000
+    });
+
+    assertEqualVectors(expected, result);
+
+    // Fall Back. The clock jumps back 1 hour, from 2:00 AM to 1:00 AM.
+    setSessionStartTimeAndTimeZone(1730620800000, "America/Los_Angeles");
+
+    result = evaluate<FlatVector<StringView>>(
+        "cast(c0 as varchar)", makeRowVector({timeVector}));
+
+    expected = makeFlatVector<StringView>({
+        "17:00:00.000", // 00:00:00.000 - 7 hours = 17:00:00.000 (previous
+                        // day)
+        "18:01:01.000", // 01:01:01.000 - 7 hours = 18:01:01.000 (previous
+                        // day)
+        "04:00:00.000", // 12:00:00.000 - 8 hours = 04:00:00.000
+        "15:59:59.999", // 23:59:59.999 - 8 hours = 15:59:59.999
+        "00:00:00.000", // 07:00:00.000 - 7 hours = 00:00:00.000 (previous
+                        // day)
+        "12:00:00.000" // 20:00:00.000 - 8 hours = 12:00:00.000
+    });
+
+    assertEqualVectors(expected, result);
+  }
+}
+
+TEST_F(CastExprTest, timeToBigintCast) {
+  {
+    // Test casting TIME to BIGINT
+
+    // Test various TIME values (milliseconds since midnight)
+    // 0 = 00:00:00.000
+    // 3661000 = 01:01:01.000
+    // 43200000 = 12:00:00.000 (noon)
+    // 86399999 = 23:59:59.999
+    auto timeVector =
+        makeFlatVector<int64_t>({0, 3661000, 43200000, 86399999}, TIME());
+
+    auto result = evaluate<FlatVector<int64_t>>(
+        "cast(c0 as bigint)", makeRowVector({timeVector}));
+
+    // Should return the same values since TIME is already stored as int64_t
+    // milliseconds
+    auto expected = makeFlatVector<int64_t>({0, 3661000, 43200000, 86399999});
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test casting TIME to BIGINT with nulls
+    auto timeVector = makeNullableFlatVector<int64_t>(
+        {0, std::nullopt, 43200000, std::nullopt}, TIME());
+
+    auto result = evaluate<FlatVector<int64_t>>(
+        "cast(c0 as bigint)", makeRowVector({timeVector}));
+
+    auto expected = makeNullableFlatVector<int64_t>(
+        {0, std::nullopt, 43200000, std::nullopt});
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test try_cast for TIME to BIGINT
+    auto timeVector = makeFlatVector<int64_t>({0, 43200000}, TIME());
+
+    auto result = evaluate<FlatVector<int64_t>>(
+        "try_cast(c0 as bigint)", makeRowVector({timeVector}));
+
+    auto expected = makeFlatVector<int64_t>({0, 43200000});
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test constant TIME vector cast to BIGINT (non-null)
+    // This tests the optimization path for constant vectors
+    auto constantTimeVector = BaseVector::wrapInConstant(
+        1000, 0, makeFlatVector<int64_t>({43200000}, TIME()));
+
+    auto result =
+        evaluate("cast(c0 as bigint)", makeRowVector({constantTimeVector}));
+
+    // Should return a constant vector with the same value
+    auto expected = BaseVector::wrapInConstant(
+        1000, 0, makeFlatVector<int64_t>({43200000}));
+
+    assertEqualVectors(expected, result);
+    // Verify the result is actually constant-encoded (optimization worked)
+    ASSERT_TRUE(result->isConstantEncoding());
+  }
+
+  {
+    // Test constant TIME vector cast to BIGINT (null)
+    // This tests the optimization path for null constant vectors
+    auto nullTimeVector = BaseVector::createNullConstant(TIME(), 500, pool());
+
+    auto result =
+        evaluate("cast(c0 as bigint)", makeRowVector({nullTimeVector}));
+
+    // Should return a null constant vector
+    auto expected = BaseVector::createNullConstant(BIGINT(), 500, pool());
+
+    assertEqualVectors(expected, result);
+    // Verify the result is actually constant-encoded (optimization worked)
+    ASSERT_TRUE(result->isConstantEncoding());
+    ASSERT_TRUE(result->isNullAt(0));
+  }
+
+  {
+    // Test constant TIME vector cast to BIGINT with different sizes
+    // This ensures the optimization correctly handles different vector sizes
+    for (auto size : {1, 10, 100, 1000}) {
+      auto constantTimeVector = BaseVector::wrapInConstant(
+          size, 0, makeFlatVector<int64_t>({86399999}, TIME()));
+
+      auto result =
+          evaluate("cast(c0 as bigint)", makeRowVector({constantTimeVector}));
+
+      auto expected = BaseVector::wrapInConstant(
+          size, 0, makeFlatVector<int64_t>({86399999}));
+
+      assertEqualVectors(expected, result);
+      ASSERT_TRUE(result->isConstantEncoding());
+      ASSERT_EQ(result->size(), size);
+    }
+  }
+}
+
+TEST_F(CastExprTest, varcharToTimeCast) {
+  // Set session time zone to UTC before running the tests
+  setTimezone("UTC");
+
+  {
+    // Test casting VARCHAR to TIME with valid time strings
+    auto varcharVector = makeFlatVector<StringView>(
+        {"00:00:00.000",
+         "01:01:01.000",
+         "12:00:00.000",
+         "23:59:59.999",
+         "09:30:15.123",
+         "18:45:30.500"});
+
+    // Use makeCastExpr directly to avoid DuckDB parser issues
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+    auto result = evaluate(castExpr, makeRowVector({varcharVector}));
+
+    // TIME is milliseconds since midnight
+    auto expected = makeFlatVector<int64_t>(
+        {
+            0, // 00:00:00.000
+            3661000, // 01:01:01.000 = 3600*1000 + 60*1000 + 1*1000
+            43200000, // 12:00:00.000 = 12*3600*1000
+            86399999, // 23:59:59.999 = 23*3600*1000 + 59*60*1000 + 59*1000 +
+                      // 999
+            34215123, // 09:30:15.123 = 9*3600*1000 + 30*60*1000 + 15*1000 + 123
+            67530500 // 18:45:30.500 = 18*3600*1000 + 45*60*1000 + 30*1000 + 500
+        },
+        TIME());
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test casting VARCHAR to TIME with nulls
+    auto varcharVector = makeNullableFlatVector<StringView>(
+        {"00:00:00.000", std::nullopt, "12:00:00.000", std::nullopt});
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+    auto result = evaluate(castExpr, makeRowVector({varcharVector}));
+
+    auto expected = makeNullableFlatVector<int64_t>(
+        {0, std::nullopt, 43200000, std::nullopt}, TIME());
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test time formats without seconds and milliseconds
+    auto varcharVector = makeFlatVector<StringView>(
+        {"00:00:00", "12:30:45", "23:59:59", "12:30"});
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+    auto result = evaluate(castExpr, makeRowVector({varcharVector}));
+
+    auto expected = makeFlatVector<int64_t>(
+        {
+            0, // 00:00:00
+            45045000, // 12:30:45 = 12*3600*1000 + 30*60*1000 + 45*1000
+            86399000, // 23:59:59 = 23*3600*1000 + 59*60*1000 + 59*1000
+            45000000, // 12:30 = 12*3600*1000 + 30*60*1000
+        },
+        TIME());
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test try_cast with invalid formats
+    auto varcharVector = makeFlatVector<StringView>({
+        "00:00:00.000", // valid
+        "25:00:00.000", // invalid hour
+        "12:60:00.000", // invalid minute
+        "12:30:60.000", // invalid second
+        "invalid" // completely invalid
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto tryCastExpr = makeCastExpr(inputField, TIME(), true);
+    auto result = evaluate(tryCastExpr, makeRowVector({varcharVector}));
+
+    auto expected = makeNullableFlatVector<int64_t>(
+        {
+            0, // valid
+            std::nullopt, // invalid hour
+            std::nullopt, // invalid minute
+            std::nullopt, // invalid second
+            std::nullopt // completely invalid
+        },
+        TIME());
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test edge cases with leading/trailing spaces (should NOT be handled -
+    // should fail like Presto)
+    auto varcharVector = makeFlatVector<StringView>({
+        " 12:30:45.123 ", // spaces should cause failure
+        "12:30:45.123", // no spaces - should succeed
+        " 09:15:30.456", // leading space - should fail
+        "14:22:33.789 ", // trailing space - should fail
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto tryCastExpr = makeCastExpr(inputField, TIME(), true);
+    auto result = evaluate(tryCastExpr, makeRowVector({varcharVector}));
+
+    auto expected = makeNullableFlatVector<int64_t>(
+        {
+            std::nullopt, // spaces cause failure
+            45045123, // 12:30:45.123 without spaces succeeds
+            std::nullopt, // leading space causes failure
+            std::nullopt, // trailing space causes failure
+        },
+        TIME());
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test that Unicode digits are rejected (not converted)
+    auto varcharVector = makeFlatVector<StringView>({
+        "1٢:30:45.123", // Arabic digit in hour should throw error
+        "12:٣٠:45.123", // Arabic digits in minute should throw error
+        "12:30:٤٥.123", // Arabic digits in second should throw error
+        "12:30:45.١٢٣", // Arabic digits in millisecond should throw error
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+
+    // Should throw error for Unicode digits
+    VELOX_ASSERT_THROW(
+        evaluate(castExpr, makeRowVector({varcharVector})),
+        "Invalid time format: expected ':' after hour");
+
+    // Test with try_cast - should return null for Unicode digits
+    auto tryCastExpr = makeCastExpr(inputField, TIME(), true);
+    auto result = evaluate(tryCastExpr, makeRowVector({varcharVector}));
+
+    auto expected = makeNullableFlatVector<int64_t>(
+        {std::nullopt, std::nullopt, std::nullopt, std::nullopt}, TIME());
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test that microsecond precision should throw an error (not truncate)
+    auto varcharVector = makeFlatVector<StringView>({
+        "12:30:45.123456", // microseconds should throw error
+        "12:30:45.123999", // microseconds should throw error
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+
+    // Should throw error for microseconds
+    VELOX_ASSERT_THROW(
+        evaluate(castExpr, makeRowVector({varcharVector})),
+        "Microsecond precision not supported");
+
+    // Test with try_cast - should return null for microseconds
+    auto tryCastExpr = makeCastExpr(inputField, TIME(), true);
+    auto result = evaluate(tryCastExpr, makeRowVector({varcharVector}));
+
+    auto expected =
+        makeNullableFlatVector<int64_t>({std::nullopt, std::nullopt}, TIME());
+
+    assertEqualVectors(expected, result);
+
+    // Test that exact milliseconds still work
+    auto validVector = makeFlatVector<StringView>({"12:30:45.123"});
+    auto validResult = evaluate(
+        makeCastExpr(
+            std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0"),
+            TIME(),
+            false),
+        makeRowVector({validVector}));
+
+    auto validExpected = makeFlatVector<int64_t>({45045123}, TIME());
+    assertEqualVectors(validExpected, validResult);
+  }
+
+  {
+    // Test timezone-aware VARCHAR to TIME casting with America/Los_Angeles
+    // timezone When casting VARCHAR to TIME, the string is interpreted as local
+    // time and converted to UTC (the reverse of TIME to VARCHAR)
+    setSessionStartTimeAndTimeZone(
+        1756710000000, "America/Los_Angeles"); // 2025-09-01T00:00:00.000 (DST)
+
+    auto varcharVector = makeFlatVector<StringView>({
+        "00:00:00.000", // Midnight local time
+        "07:00:00.000", // 7 AM local time
+        "12:00:00.000", // Noon local time
+        "23:59:59.999" // Just before midnight local time
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+    auto result = evaluate(castExpr, makeRowVector({varcharVector}));
+
+    // During DST, LA is UTC-7, so local times are converted to UTC by adding 7
+    // hours
+    auto expected = makeFlatVector<int64_t>(
+        {
+            25200000, // 00:00:00.000 + 7 hours = 07:00:00.000 UTC
+            50400000, // 07:00:00.000 + 7 hours = 14:00:00.000 UTC
+            68400000, // 12:00:00.000 + 7 hours = 19:00:00.000 UTC
+            25199999, // 23:59:59.999 + 7 hours = 06:59:59.999 UTC (next day)
+        },
+        TIME());
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test with different timezone settings - during standard time (not DST)
+    setSessionStartTimeAndTimeZone(
+        1762761600000,
+        "America/Los_Angeles"); // 2025-11-10T00:00:00.000 (Standard Time)
+
+    auto varcharVector = makeFlatVector<StringView>({
+        "00:00:00.000", // Midnight local time
+        "08:00:00.000", // 8 AM local time
+        "12:00:00.000", // Noon local time
+        "23:59:59.999" // Just before midnight local time
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+    auto result = evaluate(castExpr, makeRowVector({varcharVector}));
+
+    // During standard time, LA is UTC-8, so local times are converted to UTC by
+    // adding 8 hours
+    auto expected = makeFlatVector<int64_t>(
+        {
+            28800000, // 00:00:00.000 + 8 hours = 08:00:00.000 UTC
+            57600000, // 08:00:00.000 + 8 hours = 16:00:00.000 UTC
+            72000000, // 12:00:00.000 + 8 hours = 20:00:00.000 UTC
+            28799999, // 23:59:59.999 + 8 hours = 07:59:59.999 UTC (next day)
+        },
+        TIME());
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test with Australia/Perth timezone
+    setTimezone("Australia/Perth");
+
+    auto varcharVector = makeFlatVector<StringView>({
+        "00:00:00.000", // Midnight local time
+        "06:00:00.000", // 6 AM local time
+        "12:00:00.000", // Noon local time
+        "18:00:00.000" // 6 PM local time
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+    auto result = evaluate(castExpr, makeRowVector({varcharVector}));
+
+    // Perth is UTC+8, so local times are converted to UTC by subtracting 8
+    // hours
+    auto expected = makeFlatVector<int64_t>(
+        {
+            57600000, // 00:00:00.000 - 8 hours = 16:00:00.000 UTC (previous
+                      // day)
+            79200000, // 06:00:00.000 - 8 hours = 22:00:00.000 UTC (previous
+                      // day)
+            14400000, // 12:00:00.000 - 8 hours = 04:00:00.000 UTC
+            36000000 // 18:00:00.000 - 8 hours = 10:00:00.000 UTC
+        },
+        TIME());
+
+    assertEqualVectors(expected, result);
+  }
+}
+
+TEST_F(CastExprTest, varcharToTimeDSTGapHandling) {
+  // Test DST gap handling for VARCHAR to TIME conversion during spring-forward
+  // transition in America/Los_Angeles on March 10, 2024
+  setSessionStartTimeAndTimeZone(
+      1710064800000, "America/Los_Angeles"); // March 10, 2024 01:00:00 UTC
+
+  {
+    // Test normal times outside DST gaps work correctly
+    auto varcharVector = makeFlatVector<StringView>({
+        "01:30:00.000", // Before DST gap
+        "03:30:00.000", // After DST gap
+        "05:00:00.000", // Well after DST gap
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+    auto timeResult = evaluate(castExpr, makeRowVector({varcharVector}));
+
+    ASSERT_TRUE(timeResult != nullptr);
+    ASSERT_EQ(timeResult->size(), 3);
+
+    for (int i = 0; i < 3; i++) {
+      EXPECT_FALSE(timeResult->isNullAt(i))
+          << "Valid time at index " << i << " should not be null";
+    }
+  }
+
+  {
+    // Test round-trip conversion for valid times
+    auto varcharVector = makeFlatVector<StringView>({
+        "01:30:00.000", // Before DST gap
+        "03:30:00.000", // After DST gap
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+    auto timeResult = evaluate(castExpr, makeRowVector({varcharVector}));
+
+    auto timeToVarcharExpr = makeCastExpr(
+        std::make_shared<core::FieldAccessTypedExpr>(TIME(), "c0"),
+        VARCHAR(),
+        false);
+    auto varcharResult =
+        evaluate(timeToVarcharExpr, makeRowVector({timeResult}));
+
+    auto result =
+        std::dynamic_pointer_cast<FlatVector<StringView>>(varcharResult);
+    ASSERT_TRUE(result != nullptr);
+
+    // Times outside the DST gap should round-trip correctly
+    EXPECT_EQ(result->valueAt(0), "01:30:00.000");
+    EXPECT_EQ(result->valueAt(1), "03:30:00.000");
+  }
+
+  {
+    // Test DST gap times with try_cast - gap times should return null
+    auto varcharVector = makeFlatVector<StringView>({
+        "01:30:00.000", // Before gap - should work
+        "02:01:00.000", // In the gap - should return null
+        "02:30:00.000", // In the gap - should return null
+        "03:30:00.000", // After gap - should work
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto tryCastExpr = makeCastExpr(inputField, TIME(), true);
+    auto result = evaluate(tryCastExpr, makeRowVector({varcharVector}));
+
+    ASSERT_TRUE(result != nullptr);
+    ASSERT_EQ(result->size(), 4);
+
+    // Times before and after the gap should work
+    EXPECT_FALSE(result->isNullAt(0)) << "Time before DST gap should work";
+    EXPECT_FALSE(result->isNullAt(3)) << "Time after DST gap should work";
+
+    // Gap times should return null
+    EXPECT_TRUE(result->isNullAt(1)) << "Gap time 02:01:00 should return null";
+    EXPECT_TRUE(result->isNullAt(2)) << "Gap time 02:30:00 should return null";
+  }
+
+  {
+    // Test DST fall-back transition (November - when times are ambiguous)
+    setSessionStartTimeAndTimeZone(
+        1730620800000, "America/Los_Angeles"); // November 3, 2024 DST end
+
+    auto ambiguousTimeVector = makeFlatVector<StringView>({
+        "00:30:00.000", // Before fall-back - should work
+        "01:30:00.000", // Ambiguous time - occurs twice during fall-back
+        "02:30:00.000", // After fall-back - should work
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto tryCastExpr = makeCastExpr(inputField, TIME(), true);
+    auto result = evaluate(tryCastExpr, makeRowVector({ambiguousTimeVector}));
+
+    ASSERT_TRUE(result != nullptr);
+    ASSERT_EQ(result->size(), 3);
+
+    // All times should work during fall-back (no gaps, just ambiguity)
+    EXPECT_FALSE(result->isNullAt(0)) << "Time before fall-back should work";
+    EXPECT_FALSE(result->isNullAt(2)) << "Time after fall-back should work";
+  }
+
+  {
+    // Test that ambiguous times during DST fall-back pick the earlier
+    // occurrence (like Presto does). During fall-back, clocks go from 2:00 AM
+    // to 1:00 AM, so times like 1:30 AM occur twice - we should pick the first
+    // occurrence.
+    setSessionStartTimeAndTimeZone(
+        1730620800000, "America/Los_Angeles"); // November 3, 2024 DST end
+
+    auto ambiguousTimeVector = makeFlatVector<StringView>({
+        "01:00:00.000", // Occurs twice: once before fall-back, once after
+        "01:15:00.000", // Occurs twice during the ambiguous hour
+        "01:30:00.000", // Occurs twice during the ambiguous hour
+        "01:45:00.000", // Occurs twice during the ambiguous hour
+        "01:59:59.999", // Last ambiguous time before 2:00 AM
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+    auto result = evaluate(castExpr, makeRowVector({ambiguousTimeVector}));
+
+    // Convert back to VARCHAR to see which time was chosen
+    auto timeToVarcharExpr = makeCastExpr(
+        std::make_shared<core::FieldAccessTypedExpr>(TIME(), "c0"),
+        VARCHAR(),
+        false);
+    auto varcharResult = evaluate(timeToVarcharExpr, makeRowVector({result}));
+
+    auto resultVector =
+        std::dynamic_pointer_cast<FlatVector<StringView>>(varcharResult);
+    ASSERT_TRUE(resultVector != nullptr);
+
+    // During fall-back in LA, we expect the earlier occurrence to be chosen.
+    // The earlier occurrence is when LA is still in PDT (UTC-7).
+    // Times should round-trip correctly since we picked a valid occurrence.
+    EXPECT_EQ(resultVector->valueAt(0), "01:00:00.000");
+    EXPECT_EQ(resultVector->valueAt(1), "01:15:00.000");
+    EXPECT_EQ(resultVector->valueAt(2), "01:30:00.000");
+    EXPECT_EQ(resultVector->valueAt(3), "01:45:00.000");
+    EXPECT_EQ(resultVector->valueAt(4), "01:59:59.999");
+
+    // Verify that we get consistent behavior: casting the same ambiguous time
+    // multiple times should always give the same result (earlier occurrence)
+    auto singleAmbiguousTime = makeFlatVector<StringView>({"01:30:00.000"});
+    auto result1 = evaluate(castExpr, makeRowVector({singleAmbiguousTime}));
+    auto result2 = evaluate(castExpr, makeRowVector({singleAmbiguousTime}));
+
+    // Both results should be identical (picking the same occurrence)
+    assertEqualVectors(result1, result2);
+
+    // Convert both results back to varchar to verify consistency
+    auto varchar1 = evaluate(timeToVarcharExpr, makeRowVector({result1}));
+    auto varchar2 = evaluate(timeToVarcharExpr, makeRowVector({result2}));
+    assertEqualVectors(varchar1, varchar2);
+  }
+
+  {
+    // Test ambiguous time behavior across different DST transitions
+    // to ensure consistent "pick earlier occurrence" behavior
+
+    // Test with a different year's fall-back transition
+    setSessionStartTimeAndTimeZone(
+        1699761600000, "America/Los_Angeles"); // November 5, 2023 DST end
+
+    auto ambiguousTime2023 = makeFlatVector<StringView>({"01:30:00.000"});
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+    auto result2023 = evaluate(castExpr, makeRowVector({ambiguousTime2023}));
+
+    // Convert back to verify round-trip
+    auto timeToVarcharExpr = makeCastExpr(
+        std::make_shared<core::FieldAccessTypedExpr>(TIME(), "c0"),
+        VARCHAR(),
+        false);
+    auto varchar2023 = evaluate(timeToVarcharExpr, makeRowVector({result2023}));
+
+    auto resultVector2023 =
+        std::dynamic_pointer_cast<FlatVector<StringView>>(varchar2023);
+    ASSERT_TRUE(resultVector2023 != nullptr);
+
+    // Should round-trip correctly, confirming we picked a valid occurrence
+    EXPECT_EQ(resultVector2023->valueAt(0), "01:30:00.000");
+
+    // Test with 2025 fall-back transition
+    setSessionStartTimeAndTimeZone(
+        1762160400000, "America/Los_Angeles"); // November 2, 2025 DST end
+
+    auto ambiguousTime2025 = makeFlatVector<StringView>({"01:30:00.000"});
+    auto result2025 = evaluate(castExpr, makeRowVector({ambiguousTime2025}));
+    auto varchar2025 = evaluate(timeToVarcharExpr, makeRowVector({result2025}));
+
+    auto resultVector2025 =
+        std::dynamic_pointer_cast<FlatVector<StringView>>(varchar2025);
+    ASSERT_TRUE(resultVector2025 != nullptr);
+
+    // Should round-trip correctly across different years
+    EXPECT_EQ(resultVector2025->valueAt(0), "01:30:00.000");
+  }
+
+  {
+    // Test that gap times don't round-trip to original values
+    setSessionStartTimeAndTimeZone(
+        1710064800000, "America/Los_Angeles"); // Back to March 10, 2024
+
+    auto gapTimeVector = makeFlatVector<StringView>({
+        "02:01:00.000", // Gap time example
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto tryCastExpr = makeCastExpr(inputField, TIME(), true);
+    auto timeResult = evaluate(tryCastExpr, makeRowVector({gapTimeVector}));
+
+    // Gap time should return null, confirming it doesn't round-trip
+    EXPECT_TRUE(timeResult->isNullAt(0))
+        << "Gap time 02:01:00 should return null during DST spring-forward";
+  }
+
+  {
+    // Test that regular cast (not try_cast) throws exceptions for gap times
+    setSessionStartTimeAndTimeZone(
+        1710064800000, "America/Los_Angeles"); // March 10, 2024 DST transition
+
+    auto gapTimeVector = makeFlatVector<StringView>({
+        "02:01:00.000", // Gap time - should throw exception
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr =
+        makeCastExpr(inputField, TIME(), false); // regular cast, not try_cast
+
+    // Regular cast should throw exception for gap times
+    VELOX_ASSERT_THROW(
+        evaluate(castExpr, makeRowVector({gapTimeVector})),
+        "Cannot cast VARCHAR '02:01:00.000' to TIME. Time does not exist due to DST gap");
+  }
+
+  {
+    // Test multiple gap times all throw exceptions
+    setSessionStartTimeAndTimeZone(
+        1710064800000, "America/Los_Angeles"); // March 10, 2024 DST transition
+
+    // Test different gap times individually since one exception will stop
+    // evaluation
+    std::vector<std::string> gapTimes = {
+        "02:00:00.000", // Start of gap
+        "02:15:00.000", // Middle of gap
+        "02:30:00.000", // Middle of gap
+        "02:45:00.000", // Near end of gap
+        "02:59:59.999", // End of gap
+    };
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+
+    for (const auto& gapTime : gapTimes) {
+      auto gapTimeVector = makeFlatVector<StringView>({StringView(gapTime)});
+
+      // Each gap time should throw an exception
+      VELOX_ASSERT_THROW(
+          evaluate(castExpr, makeRowVector({gapTimeVector})),
+          "Cannot cast VARCHAR '" + gapTime +
+              "' to TIME. Time does not exist due to DST gap");
+    }
+  }
+
+  {
+    // Test that times right before and after gap work with regular cast
+    setSessionStartTimeAndTimeZone(
+        1710064800000, "America/Los_Angeles"); // March 10, 2024 DST transition
+
+    auto validTimeVector = makeFlatVector<StringView>({
+        "01:59:59.999", // Just before gap - should work
+        "03:00:00.000", // Just after gap - should work
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+
+    // These should not throw exceptions
+    ASSERT_NO_THROW(evaluate(castExpr, makeRowVector({validTimeVector})));
+  }
+
+  {
+    // Test exception throwing during fall-back transition (November)
+    // Fall-back doesn't have gaps, so all times should work
+    setSessionStartTimeAndTimeZone(
+        1730620800000, "America/Los_Angeles"); // November 3, 2024 DST end
+
+    auto ambiguousTimeVector = makeFlatVector<StringView>({
+        "01:30:00.000", // Ambiguous time - occurs twice during fall-back
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+
+    // Fall-back times should not throw exceptions (just ambiguous, not gaps)
+    ASSERT_NO_THROW(evaluate(castExpr, makeRowVector({ambiguousTimeVector})));
+  }
+}
+
+TEST_F(CastExprTest, timeToTimestampCast) {
+  {
+    // Test casting TIME to TIMESTAMP
+    // TIME values represent milliseconds since midnight
+    // When cast to TIMESTAMP, they should become milliseconds since epoch
+
+    // Test various TIME values (milliseconds since midnight)
+    // 0 = 00:00:00.000
+    // 3661000 = 01:01:01.000
+    // 43200000 = 12:00:00.000 (noon)
+    // 86399999 = 23:59:59.999
+    auto timeVector =
+        makeFlatVector<int64_t>({0, 3661000, 43200000, 86399999}, TIME());
+
+    auto result = evaluate<FlatVector<Timestamp>>(
+        "cast(c0 as timestamp)", makeRowVector({timeVector}));
+
+    auto expected = makeFlatVector<Timestamp>({
+        Timestamp::fromMillis(0),
+        Timestamp::fromMillis(3661000),
+        Timestamp::fromMillis(43200000),
+        Timestamp::fromMillis(86399999),
+    });
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test casting TIME to TIMESTAMP with nulls
+    auto timeVector = makeNullableFlatVector<int64_t>(
+        {0, std::nullopt, 43200000, std::nullopt}, TIME());
+
+    auto result = evaluate<FlatVector<Timestamp>>(
+        "cast(c0 as timestamp)", makeRowVector({timeVector}));
+
+    auto expected = makeNullableFlatVector<Timestamp>({
+        Timestamp::fromMillis(0),
+        std::nullopt,
+        Timestamp::fromMillis(43200000),
+        std::nullopt,
+    });
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test try_cast for TIME to TIMESTAMP
+    auto timeVector = makeFlatVector<int64_t>({0, 43200000}, TIME());
+
+    auto result = evaluate<FlatVector<Timestamp>>(
+        "try_cast(c0 as timestamp)", makeRowVector({timeVector}));
+
+    auto expected = makeFlatVector<Timestamp>({
+        Timestamp::fromMillis(0),
+        Timestamp::fromMillis(43200000),
+    });
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test constant TIME vector cast to TIMESTAMP (non-null)
+    auto constantTimeVector = BaseVector::wrapInConstant(
+        1000, 0, makeFlatVector<int64_t>({43200000}, TIME()));
+
+    auto result =
+        evaluate("cast(c0 as timestamp)", makeRowVector({constantTimeVector}));
+
+    // Should return a constant vector with the same value
+    auto expected = BaseVector::wrapInConstant(
+        1000, 0, makeFlatVector<Timestamp>({Timestamp::fromMillis(43200000)}));
+
+    assertEqualVectors(expected, result);
+    // Verify the result is actually constant-encoded - optimization
+    ASSERT_TRUE(result->isConstantEncoding());
+  }
+
+  {
+    // Test constant TIME vector cast to TIMESTAMP (null)
+    auto nullTimeVector = BaseVector::createNullConstant(TIME(), 500, pool());
+
+    auto result =
+        evaluate("cast(c0 as timestamp)", makeRowVector({nullTimeVector}));
+
+    // Should return a null constant vector
+    auto expected = BaseVector::createNullConstant(TIMESTAMP(), 500, pool());
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test TIME to TIMESTAMP cast with various edge cases
+    auto timeVector = makeFlatVector<int64_t>(
+        {
+            1, // 1 millisecond after midnight
+            1000, // 1 second after midnight
+            60000, // 1 minute after midnight
+            3600000, // 1 hour after midnight
+            86399000, // 1 second before midnight
+            86399990, // 10 milliseconds before midnight
+        },
+        TIME());
+
+    auto result = evaluate<FlatVector<Timestamp>>(
+        "cast(c0 as timestamp)", makeRowVector({timeVector}));
+
+    auto expected = makeFlatVector<Timestamp>({
+        Timestamp::fromMillis(1),
+        Timestamp::fromMillis(1000),
+        Timestamp::fromMillis(60000),
+        Timestamp::fromMillis(3600000),
+        Timestamp::fromMillis(86399000),
+        Timestamp::fromMillis(86399990),
+    });
+
+    assertEqualVectors(expected, result);
+  }
+}
+
+TEST_F(CastExprTest, timestampToTimeCast) {
+  // Test casting TIMESTAMP to TIME
+  // TIME values represent milliseconds since midnight (time-of-day)
+  // TIMESTAMP to TIME extracts the time-of-day component
+  // This matches Presto's behavior (see TestTimestampBase.java:185-188)
+
+  std::vector<std::optional<Timestamp>> inputTimestamps = {
+      Timestamp::fromMillis(0), // 00:00:00.000
+      Timestamp::fromMillis(3661000), // 01:01:01.000
+      Timestamp::fromMillis(43200000), // 12:00:00.000
+      Timestamp::fromMillis(86399999), // 23:59:59.999
+      Timestamp::fromMillis(86400000), // Next day 00:00:00.000
+      Timestamp::fromMillis(86400000 + 3661000), // Next day 01:01:01.000
+      Timestamp::fromMillis(2 * 86400000 + 43200000), // Two days later
+                                                      // 12:00:00.000
+      std::nullopt};
+
+  std::vector<std::optional<int64_t>> expectedTime = {
+      0, // 00:00:00.000
+      3661000, // 01:01:01.000
+      43200000, // 12:00:00.000
+      86399999, // 23:59:59.999
+      0, // 00:00:00.000 (wraps to midnight)
+      3661000, // 01:01:01.000
+      43200000, // 12:00:00.000
+      std::nullopt};
+
+  testCast(TIMESTAMP(), TIME(), inputTimestamps, expectedTime);
+
+  // Test with negative timestamps (before epoch)
+  // Negative timestamps should correctly wrap around to positive time-of-day
+  std::vector<std::optional<Timestamp>> negativeTimestamps = {
+      Timestamp::fromMillis(-1), // 1ms before epoch -> 23:59:59.999
+      Timestamp::fromMillis(-3600000), // 1 hour before epoch -> 23:00:00.000
+      Timestamp::fromMillis(-86400000), // Exactly 1 day before epoch ->
+                                        // 00:00:00.000
+      Timestamp::fromMillis(-86400000 - 3661000), // 1 day + 1:01:01 before
+                                                  // epoch -> 22:58:59.000
+  };
+
+  std::vector<std::optional<int64_t>> expectedNegativeTime = {
+      86399999, // 23:59:59.999
+      82800000, // 23:00:00.000 (86400000 - 3600000)
+      0, // 00:00:00.000
+      82739000, // 22:58:59.000
+  };
+
+  testCast(TIMESTAMP(), TIME(), negativeTimestamps, expectedNegativeTime);
+
+  // Test specific timestamps that span multiple days
+  std::vector<std::optional<Timestamp>> realTimestamps = {
+      parseTimestamp("2023-05-15 14:30:45.123"),
+      parseTimestamp("1990-01-01 08:15:30.500"),
+      parseTimestamp("2050-12-31 23:59:59.999"),
+  };
+
+  std::vector<std::optional<int64_t>> expectedRealTime = {
+      14 * 3600000 + 30 * 60000 + 45 * 1000 + 123, // 14:30:45.123
+      8 * 3600000 + 15 * 60000 + 30 * 1000 + 500, // 08:15:30.500
+      23 * 3600000 + 59 * 60000 + 59 * 1000 + 999, // 23:59:59.999
+  };
+
+  testCast(TIMESTAMP(), TIME(), realTimestamps, expectedRealTime);
+}
+
+TEST_F(CastExprTest, numericUpcast) {
+  auto testNumericUpcast =
+      [&](std::function<bool(vector_size_t /*row*/)> isNullAt = nullptr) {
+        auto vectorSize = 1'000;
+        // Cast from TINYINT to SMALLINT.
+        const auto tinyintVector = makeFlatVector<int8_t>(
+            vectorSize,
+            [](auto i) { return i % std::numeric_limits<int8_t>::max(); },
+            isNullAt);
+        testCast(
+            tinyintVector,
+            makeFlatVector<int16_t>(
+                vectorSize,
+                [](auto i) { return i % std::numeric_limits<int8_t>::max(); },
+                isNullAt));
+
+        // Cast from TINYINT to INTEGER.
+        testCast(
+            tinyintVector,
+            makeFlatVector<int32_t>(
+                vectorSize,
+                [](auto i) { return i % std::numeric_limits<int8_t>::max(); },
+                isNullAt));
+
+        // Cast from TINYINT to BIGINT.
+        testCast(
+            tinyintVector,
+            makeFlatVector<int64_t>(
+                vectorSize,
+                [](auto i) { return i % std::numeric_limits<int8_t>::max(); },
+                isNullAt));
+
+        // Cast from TINYINT to REAL.
+        testCast(
+            tinyintVector,
+            makeFlatVector<float>(
+                vectorSize,
+                [](auto i) {
+                  return static_cast<float>(
+                      i % std::numeric_limits<int8_t>::max());
+                },
+                isNullAt));
+
+        // Cast from TINYINT to DOUBLE.
+        testCast(
+            tinyintVector,
+            makeFlatVector<double>(
+                vectorSize,
+                [](auto i) {
+                  return static_cast<double>(
+                      i % std::numeric_limits<int8_t>::max());
+                },
+                isNullAt));
+
+        // Cast from SMALLINT to INTEGER.
+        const auto smallintVector = makeFlatVector<int16_t>(
+            vectorSize, [](auto i) { return 1 + 2 * i; }, isNullAt);
+        testCast(
+            smallintVector,
+            makeFlatVector<int32_t>(
+                vectorSize, [](auto i) { return 1 + 2 * i; }, isNullAt));
+
+        // Cast from SMALLINT to BIGINT.
+        testCast(
+            smallintVector,
+            makeFlatVector<int64_t>(
+                vectorSize, [](auto i) { return 1 + 2 * i; }, isNullAt));
+
+        // Cast from SMALLINT to REAL.
+        testCast(
+            smallintVector,
+            makeFlatVector<float>(
+                vectorSize,
+                [](auto i) { return static_cast<float>(1 + 2 * i); },
+                isNullAt));
+
+        // Cast from SMALLINT to DOUBLE.
+        testCast(
+            smallintVector,
+            makeFlatVector<double>(
+                vectorSize,
+                [](auto i) { return static_cast<double>(1 + 2 * i); },
+                isNullAt));
+
+        // Cast from INTEGER to BIGINT.
+        const auto integerVector = makeFlatVector<int32_t>(
+            vectorSize, [](auto i) { return 1 + 2 * i; }, isNullAt);
+        testCast(
+            integerVector,
+            makeFlatVector<int64_t>(
+                vectorSize, [](auto i) { return 1 + 2 * i; }, isNullAt));
+
+        // Cast from INTEGER to REAL.
+        testCast(
+            integerVector,
+            makeFlatVector<float>(
+                vectorSize, [](auto i) { return 1 + 2 * i; }, isNullAt));
+
+        // Cast from INTEGER to DOUBLE.
+        testCast(
+            integerVector,
+            makeFlatVector<double>(
+                vectorSize, [](auto i) { return 1 + 2 * i; }, isNullAt));
+
+        // Cast from BIGINT to REAL.
+        testCast(
+            makeFlatVector<int64_t>(
+                vectorSize, [](auto i) { return 1 + 2 * i; }, isNullAt),
+            makeFlatVector<float>(
+                vectorSize, [](auto i) { return 1 + 2 * i; }, isNullAt));
+
+        // Cast from BIGINT to DOUBLE.
+        testCast(
+            makeFlatVector<int64_t>(
+                vectorSize, [](auto i) { return 1 + 2 * i; }, isNullAt),
+            makeFlatVector<double>(
+                vectorSize, [](auto i) { return 1 + 2 * i; }, isNullAt));
+
+        // Cast from REAL to DOUBLE.
+        testCast(
+            makeFlatVector<float>(
+                vectorSize, [](auto i) { return 1.5f + 2 * i; }, isNullAt),
+            makeFlatVector<double>(
+                vectorSize, [](auto i) { return 1.5 + 2 * i; }, isNullAt));
+      };
+
+  testNumericUpcast();
+  testNumericUpcast([](vector_size_t row) { return row % 7 == 0; });
+}
+
 } // namespace
 } // namespace facebook::velox::test
diff --git a/velox/expression/tests/CoalesceRewriteTest.cpp b/velox/expression/tests/CoalesceRewriteTest.cpp
new file mode 100644
index 00000000000..40ade8887b0
--- /dev/null
+++ b/velox/expression/tests/CoalesceRewriteTest.cpp
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "velox/expression/tests/SpecialFormRewriteTestBase.h"
+
+namespace facebook::velox::expression {
+namespace {
+
+class CoalesceRewriteTest
+    : public expression::test::SpecialFormRewriteTestBase {};
+
+TEST_F(CoalesceRewriteTest, basic) {
+  auto type = ROW({"a", "b"}, {BIGINT(), BIGINT()});
+  testRewrite("coalesce(null::bigint, 1, a)", "1", type);
+  testRewrite(
+      "coalesce(null::bigint, 6 * a, 5 * b, 1, null::bigint)",
+      "coalesce(6 * a, 5 * b, 1)",
+      type);
+  testRewrite(
+      "coalesce(null::bigint, coalesce(null::bigint, a, coalesce(1, b)))",
+      "coalesce(a, 1)",
+      type);
+  testRewrite("coalesce(a, null::bigint, a)", "a", type);
+  testRewrite(
+      "coalesce(a, b, a, coalesce(coalesce(b, a), b))", "coalesce(a, b)", type);
+  testRewrite(
+      "coalesce(a, coalesce(2, coalesce(b, a)), b)", "coalesce(a, 2)", type);
+}
+
+} // namespace
+} // namespace facebook::velox::expression
diff --git a/velox/expression/tests/ConjunctRewriteTest.cpp b/velox/expression/tests/ConjunctRewriteTest.cpp
new file mode 100644
index 00000000000..6c288ded873
--- /dev/null
+++ b/velox/expression/tests/ConjunctRewriteTest.cpp
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "velox/expression/tests/SpecialFormRewriteTestBase.h"
+
+namespace facebook::velox::expression {
+namespace {
+
+class ConjunctRewriteTest
+    : public expression::test::SpecialFormRewriteTestBase {};
+
+TEST_F(ConjunctRewriteTest, basic) {
+  const auto type = ROW({"a", "b"}, {VARCHAR(), BIGINT()});
+  testRewrite(
+      "null::boolean and a = 'z' and true", "null::boolean and a = 'z'", type);
+  testRewrite(
+      "a = 'z' or null::boolean or false", "a = 'z' or null::boolean", type);
+  testRewrite("true and a = 'z' and true", "a = 'z'", type);
+  testRewrite("false or a = 'z' or false", "a = 'z'", type);
+  testRewrite("a = 'z' and b = 2 and false", "false", type);
+  testRewrite("((a = 'z' and b = 2) and false)", "false", type);
+  testRewrite("a = 'z' or b = 2 or true", "true", type);
+  testRewrite("(a = 'z' or (b = 2 or true))", "true", type);
+}
+
+} // namespace
+} // namespace facebook::velox::expression
diff --git a/velox/expression/tests/ConjunctTest.cpp b/velox/expression/tests/ConjunctTest.cpp
index 280180664c2..08084aa1eb6 100644
--- a/velox/expression/tests/ConjunctTest.cpp
+++ b/velox/expression/tests/ConjunctTest.cpp
@@ -19,7 +19,6 @@
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/parse/Expressions.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
@@ -103,3 +102,18 @@ TEST_F(ConjunctTest, constant) {
         plan, "select c0, c1, c2, if (c0 < 9, c1 and c2, c1 or c2) from tmp");
   }
 }
+
+TEST_F(ConjunctTest, notOperator) {
+  auto data = makeRowVector(
+      {makeFlatVector<int32_t>(10, [](auto row) { return row; }),
+       makeFlatVector<bool>(
+           10,
+           [](auto row) { return row % 2 == 0; },
+           [](auto row) { return row == 5; })});
+
+  auto plan =
+      PlanBuilder().values({data}).project({"c0", "c1", "not c1"}).planNode();
+  createDuckDbTable({data});
+
+  assertQuery(plan, "select c0, c1, not c1 from tmp");
+}
diff --git a/velox/expression/tests/CustomTypeTest.cpp b/velox/expression/tests/CustomTypeTest.cpp
index a7ae09ef09d..c4a712aa415 100644
--- a/velox/expression/tests/CustomTypeTest.cpp
+++ b/velox/expression/tests/CustomTypeTest.cpp
@@ -21,6 +21,7 @@
 #include "velox/functions/Registerer.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/functions/prestosql/types/SfmSketchRegistration.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
 #include "velox/type/OpaqueCustomTypes.h"
 
 namespace facebook::velox::test {
@@ -228,6 +229,7 @@ TEST_F(CustomTypeTest, getCustomTypeNames) {
   auto expectedTypes = std::unordered_set<std::string>{
       "JSON",
       "HYPERLOGLOG",
+      "KHYPERLOGLOG",
       "TIMESTAMP WITH TIME ZONE",
       "UUID",
       "IPADDRESS",
@@ -235,13 +237,15 @@ TEST_F(CustomTypeTest, getCustomTypeNames) {
       "BINGTILE",
       "TDIGEST",
       "QDIGEST",
+      "SETDIGEST",
       "SFMSKETCH",
       "BIGINT_ENUM",
       "VARCHAR_ENUM",
       "P4HYPERLOGLOG",
-  };
+      "TIME WITH TIME ZONE"};
 #ifdef VELOX_ENABLE_GEO
   expectedTypes.insert("GEOMETRY");
+  expectedTypes.insert("SPHERICALGEOGRAPHY");
 #endif
   ASSERT_EQ(expectedTypes, getCustomTypeNames());
 
@@ -400,4 +404,62 @@ TEST_F(CustomTypeTest, testOpaqueCustomTypeAutoCreation) {
           "reduce_tuple(make_tuple_untyped(c0, c0))", makeRowVector({data})),
       "");
 }
+
+template <typename T>
+struct TimeWithTimezonePlusOneFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  void call(
+      out_type<TimeWithTimezone>& out,
+      const arg_type<TimeWithTimezone>& input) {
+    out = *input + 1;
+  }
+};
+
+template <typename T>
+struct ArrayTimeWithTimezoneFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  void call(
+      out_type<Array<TimeWithTimezone>>& out,
+      const arg_type<Array<TimeWithTimezone>>& input) {
+    for (int i = 0; i < input.size(); i++) {
+      if (input[i].has_value()) {
+        out.push_back(*input[i].value());
+      }
+    }
+  }
+};
+
+TEST_F(CustomTypeTest, timeWithTimezoneTypeTest) {
+  registerFunction<
+      TimeWithTimezonePlusOneFunction,
+      TimeWithTimezone,
+      TimeWithTimezone>({"time_with_timezone_plus_one"});
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1000, 2000, 3000}, TIME_WITH_TIME_ZONE()),
+  });
+  auto result = evaluate("time_with_timezone_plus_one(c0)", data);
+  auto expected =
+      makeFlatVector<int64_t>({1001, 2001, 3001}, TIME_WITH_TIME_ZONE());
+  assertEqualVectors(expected, result);
+
+  // Test out TimeWithTimezone in complex type.
+  {
+    registerFunction<
+        ArrayTimeWithTimezoneFunction,
+        Array<TimeWithTimezone>,
+        Array<TimeWithTimezone>>({"array_time_with_timezone"});
+
+    auto data = makeRowVector({
+        makeArrayVector<int64_t>(
+            {{1000, 2000, 3000}, {4000, 5000, 6000}}, TIME_WITH_TIME_ZONE()),
+    });
+
+    auto result = evaluate("array_time_with_timezone(c0)", data);
+    auto expected = makeArrayVector<int64_t>(
+        {{1000, 2000, 3000}, {4000, 5000, 6000}}, TIME_WITH_TIME_ZONE());
+    assertEqualVectors(expected, result);
+  }
+}
 } // namespace facebook::velox::test
diff --git a/velox/expression/tests/EvalCtxTest.cpp b/velox/expression/tests/EvalCtxTest.cpp
index 5c21e2af5f6..3e3420d306d 100644
--- a/velox/expression/tests/EvalCtxTest.cpp
+++ b/velox/expression/tests/EvalCtxTest.cpp
@@ -96,13 +96,17 @@ TEST_F(EvalCtxTest, vectorRecycler) {
   auto newVector = context.getVector(BIGINT(), 1'00);
   ASSERT_EQ(newVector.get(), vectorPtr);
   vector.reset();
-  { VectorRecycler vectorRecycler(vector, context.vectorPool()); }
+  {
+    VectorRecycler vectorRecycler(vector, context.vectorPool());
+  }
 
   // Hold the allocated vector on scoped vector destruction.
   vector = context.getVector(BIGINT(), 1'00);
   ASSERT_NE(vector.get(), newVector.get());
   newVector = vector;
-  { VectorRecycler vectorRecycler(vector, context.vectorPool()); }
+  {
+    VectorRecycler vectorRecycler(vector, context.vectorPool());
+  }
   vector = context.getVector(BIGINT(), 1'00);
   ASSERT_NE(vector.get(), newVector.get());
 }
@@ -233,3 +237,34 @@ TEST_F(EvalCtxTest, inputFlatNoNulls) {
   EvalCtx context(&execCtx_);
   ASSERT_FALSE(context.inputFlatNoNulls());
 }
+
+TEST_F(EvalCtxTest, computeInputFlatNoNulls) {
+  // All flat, no nulls -> true.
+  auto flat = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      makeFlatVector<int64_t>({4, 5, 6}),
+  });
+  ASSERT_TRUE(EvalCtx::computeInputFlatNoNulls(*flat));
+
+  // Flat with nulls -> false.
+  auto withNulls = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      makeNullableFlatVector<int64_t>({1, std::nullopt, 3}),
+  });
+  ASSERT_FALSE(EvalCtx::computeInputFlatNoNulls(*withNulls));
+
+  // Constant encoding, no nulls -> true.
+  auto withConstant = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      makeConstant<int64_t>(42, 3),
+  });
+  ASSERT_TRUE(EvalCtx::computeInputFlatNoNulls(*withConstant));
+
+  // Dictionary encoding -> false.
+  auto indices = makeIndices({0, 1, 2});
+  auto withDict = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      wrapInDictionary(indices, makeFlatVector<int64_t>({4, 5, 6})),
+  });
+  ASSERT_FALSE(EvalCtx::computeInputFlatNoNulls(*withDict));
+}
diff --git a/velox/expression/tests/ExprCompilerTest.cpp b/velox/expression/tests/ExprCompilerTest.cpp
index 568eb753b9c..70deae1243b 100644
--- a/velox/expression/tests/ExprCompilerTest.cpp
+++ b/velox/expression/tests/ExprCompilerTest.cpp
@@ -18,6 +18,7 @@
 #include "velox/core/Expressions.h"
 #include "velox/expression/Expr.h"
 #include "velox/expression/FieldReference.h"
+#include "velox/expression/VectorFunctionListener.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 #include "velox/functions/prestosql/types/JsonType.h"
 #include "velox/parse/ExpressionsParser.h"
@@ -42,7 +43,7 @@ class ExprCompilerTest : public testing::Test,
   core::TypedExprPtr makeTypedExpr(
       const std::string& text,
       const RowTypePtr& rowType) {
-    auto untyped = parse::parseExpr(text, {});
+    auto untyped = parse::DuckSqlExpressionsParser().parseExpr(text);
     return core::Expressions::inferTypes(untyped, rowType, execCtx_->pool());
   }
 
@@ -87,6 +88,10 @@ class ExprCompilerTest : public testing::Test,
     return std::make_shared<core::ConstantTypedExpr>(VARCHAR(), variant(value));
   }
 
+  core::TypedExprPtr double_(double value) {
+    return std::make_shared<core::ConstantTypedExpr>(DOUBLE(), value);
+  }
+
   std::function<core::TypedExprPtr(const std::string& name)> makeField(
       const RowTypePtr& rowType) {
     return [&](const std::string& name) -> core::TypedExprPtr {
@@ -193,12 +198,10 @@ TEST_F(ExprCompilerTest, concatStringFlattening) {
       {field("a"), concatCall({field("b"), field("c")}), field("d")});
   ASSERT_EQ("concat(a, b, c, d)", compile(expression)->toString());
 
-  // Constant folding happens after flattening.
+  // Inner concatCall is constant folded during expression compilation.
   expression = concatCall(
       {field("a"), concatCall({varchar("---"), varchar("...")}), field("b")});
-  ASSERT_EQ(
-      "concat(a, ---:VARCHAR, ...:VARCHAR, b)",
-      compile(expression)->toString());
+  ASSERT_EQ("concat(a, ---...:VARCHAR, b)", compile(expression)->toString());
 }
 
 TEST_F(ExprCompilerTest, concatArrayFlattening) {
@@ -288,14 +291,15 @@ TEST_F(ExprCompilerTest, customTypeConstant) {
 TEST_F(ExprCompilerTest, rewrites) {
   auto rowType = ROW({"c0", "c1"}, {ARRAY(VARCHAR()), BIGINT()});
   auto arraySortSql =
-      "array_sort(c0, (x, y) -> if(length(x) < length(y), -1, if(length(x) > length(y), 1, 0)))";
+      "array_sort(c0, (x, y) -> if(length(x) < length(y), (-1)::integer, if(length(x) > length(y), 1::integer, 0::integer)))";
 
-  ASSERT_NO_THROW(std::make_unique<ExprSet>(
-      std::vector<core::TypedExprPtr>{
-          makeTypedExpr(arraySortSql, rowType),
-          makeTypedExpr("c1 + 5", rowType),
-      },
-      execCtx_.get()));
+  ASSERT_NO_THROW(
+      std::make_unique<ExprSet>(
+          std::vector<core::TypedExprPtr>{
+              makeTypedExpr(arraySortSql, rowType),
+              makeTypedExpr("c1 + 5", rowType),
+          },
+          execCtx_.get()));
 
   auto exprSet = compile(makeTypedExpr(
       "reduce(c0, 1, (s, x) -> s + x * 2, s -> s)",
@@ -351,4 +355,451 @@ TEST_F(ExprCompilerTest, lambdaExpr) {
   ASSERT_EQ(distinctFields.size(), 2);
 }
 
+TEST_F(ExprCompilerTest, exprDeduplication) {
+  auto testExprDedup = [&](const core::TypedExprPtr& expression,
+                           bool shouldDedup,
+                           bool expectDedup,
+                           const std::string& description) {
+    std::unordered_map<std::string, std::string> configData(
+        {{core::QueryConfig::kExprDedupNonDeterministic,
+          shouldDedup ? "true" : "false"}});
+    auto queryCtx = velox::core::QueryCtx::create(
+        nullptr, core::QueryConfig(std::move(configData)));
+    auto execCtx = std::make_unique<core::ExecCtx>(pool_.get(), queryCtx.get());
+
+    auto exprSet = std::make_unique<ExprSet>(
+        std::vector<core::TypedExprPtr>{expression}, execCtx.get());
+
+    ASSERT_EQ(exprSet->size(), 1);
+    auto& expr = exprSet->expr(0);
+    auto& leftInput = expr->inputs()[0];
+    auto& rightInput = expr->inputs()[1];
+
+    if (expectDedup) {
+      EXPECT_EQ(leftInput.get(), rightInput.get()) << description;
+    } else {
+      EXPECT_NE(leftInput.get(), rightInput.get()) << description;
+    }
+  };
+
+  // Test deterministic expressions - should always be deduplicated regardless
+  // of config
+  auto rowType = ROW({"c0"}, {BIGINT()});
+  auto deterministicExpr = call(
+      "plus",
+      {call("plus", {makeField(rowType)("c0"), bigint(1)}),
+       call("plus", {makeField(rowType)("c0"), bigint(1)})});
+
+  testExprDedup(
+      deterministicExpr,
+      true,
+      true,
+      "Deterministic expressions should be deduplicated when config is true");
+  testExprDedup(
+      deterministicExpr,
+      false,
+      true,
+      "Deterministic expressions should always be deduplicated regardless of config");
+
+  // Test non-deterministic expressions - behavior depends on config
+  auto nonDeterministicExpr =
+      call("plus", {call("rand", {}), call("rand", {})});
+
+  testExprDedup(
+      nonDeterministicExpr,
+      true,
+      true,
+      "Non-deterministic expressions should be deduplicated when config is true");
+  testExprDedup(
+      nonDeterministicExpr,
+      false,
+      false,
+      "Non-deterministic expressions should NOT be deduplicated when config is false");
+}
+
+TEST_F(ExprCompilerTest, simpleFunctionMemoryPool) {
+  // Test that MemoryPool is correctly passed through ExprCompiler to
+  // SimpleFunctions that have initialize() with memoryPool parameter.
+  // empty_approx_set() creates an HLL sketch.
+  auto expression = call("empty_approx_set", {});
+  auto exprSet = compile(expression);
+  ASSERT_EQ(exprSet->size(), 1);
+
+  auto input = makeRowVector(ROW({}, {}), 1);
+  SelectivityVector rows(1);
+  EvalCtx evalCtx(execCtx_.get(), exprSet.get(), input.get());
+  std::vector<VectorPtr> results(1);
+  exprSet->eval(rows, evalCtx, results);
+
+  // Verify result - eval should create the vector
+  ASSERT_TRUE(results[0] != nullptr) << "Result vector was not created";
+  ASSERT_EQ(results[0]->size(), 1) << "Result vector has wrong size";
+  ASSERT_FALSE(results[0]->isNullAt(0));
+
+  // empty_approx_set() returns a constant.
+  DecodedVector decoded(*results[0], rows);
+  ASSERT_FALSE(decoded.isNullAt(0)) << "Decoded result is null";
+
+  auto stringView = decoded.valueAt<StringView>(0);
+  ASSERT_GT(stringView.size(), 0) << "HLL sketch is empty";
+}
+
+class TrackingListenerFactory : public VectorFunctionListenerFactory {
+ public:
+  std::optional<VectorFunctionListeners> create(
+      std::string_view name,
+      const VectorFunctionMetadata& /*metadata*/,
+      const core::QueryConfig& /*queryConfig*/) override {
+    trackedNames.emplace_back(name);
+    return std::nullopt;
+  }
+
+  std::vector<std::string> trackedNames;
+};
+
+class CountingListenerFactory : public VectorFunctionListenerFactory {
+ public:
+  CountingListenerFactory()
+      : preCount(std::make_shared<std::atomic<int>>(0)),
+        postCount(std::make_shared<std::atomic<int>>(0)) {}
+
+  std::optional<VectorFunctionListeners> create(
+      std::string_view /*functionName*/,
+      const VectorFunctionMetadata& /*metadata*/,
+      const core::QueryConfig& /*queryConfig*/) override {
+    return VectorFunctionListeners{
+        std::make_shared<PreApplyListener>(
+            [counter = preCount](
+                std::string_view /*functionName*/,
+                const SelectivityVector& /*rows*/,
+                const std::vector<VectorPtr>& /*args*/,
+                const TypePtr& /*outputType*/,
+                const EvalCtx& /*context*/) { ++(*counter); }),
+        std::make_shared<PostApplyListener>(
+            [counter = postCount](
+                std::string_view /*functionName*/,
+                const SelectivityVector& /*rows*/,
+                const std::vector<VectorPtr>& /*args*/,
+                const TypePtr& /*outputType*/,
+                const EvalCtx& /*context*/,
+                const VectorPtr& /*result*/,
+                std::exception_ptr /*error*/) { ++(*counter); }),
+    };
+  }
+
+  std::shared_ptr<std::atomic<int>> preCount;
+  std::shared_ptr<std::atomic<int>> postCount;
+};
+
+class SelectiveListenerFactory : public VectorFunctionListenerFactory {
+ public:
+  explicit SelectiveListenerFactory(
+      std::string targetName,
+      std::shared_ptr<std::atomic<int>> counter)
+      : targetName_(std::move(targetName)), counter_(std::move(counter)) {}
+
+  std::optional<VectorFunctionListeners> create(
+      std::string_view name,
+      const VectorFunctionMetadata& /*metadata*/,
+      const core::QueryConfig& /*queryConfig*/) override {
+    if (name != targetName_) {
+      return std::nullopt;
+    }
+    return VectorFunctionListeners{
+        std::make_shared<PreApplyListener>(
+            [counter = counter_](
+                std::string_view /*functionName*/,
+                const SelectivityVector& /*rows*/,
+                const std::vector<VectorPtr>& /*args*/,
+                const TypePtr& /*outputType*/,
+                const EvalCtx& /*context*/) { ++(*counter); }),
+        nullptr,
+    };
+  }
+
+ private:
+  std::string targetName_;
+  std::shared_ptr<std::atomic<int>> counter_;
+};
+
+TEST_F(ExprCompilerTest, listenerFactory) {
+  auto factory = std::make_shared<TrackingListenerFactory>();
+  registerVectorFunctionListenerFactory(factory);
+
+  auto rowType = ROW({"a"}, {BIGINT()});
+  auto field = makeField(rowType);
+  auto expression = call("plus", {field("a"), bigint(1)});
+  auto exprSet = compile(expression);
+  ASSERT_EQ(factory->trackedNames.size(), 1);
+  EXPECT_EQ(factory->trackedNames[0], "plus");
+
+  auto input = makeRowVector({"a"}, {makeFlatVector<int64_t>({1, 2, 3})});
+  SelectivityVector rows(3);
+  EvalCtx evalCtx(execCtx_.get(), exprSet.get(), input.get());
+  std::vector<VectorPtr> results(1);
+  exprSet->eval(rows, evalCtx, results);
+
+  auto expected = makeFlatVector<int64_t>({2, 3, 4});
+  velox::test::assertEqualVectors(expected, results[0]);
+  unregisterVectorFunctionListenerFactory(factory);
+}
+
+TEST_F(ExprCompilerTest, listenerNotCalledForSpecialForms) {
+  auto factory = std::make_shared<TrackingListenerFactory>();
+  registerVectorFunctionListenerFactory(factory);
+
+  auto rowType = ROW({"a", "b"}, {BOOLEAN(), BOOLEAN()});
+  auto field = makeField(rowType);
+  auto expression = andCall(field("a"), field("b"));
+  compile(expression);
+
+  EXPECT_TRUE(factory->trackedNames.empty());
+  unregisterVectorFunctionListenerFactory(factory);
+}
+
+TEST_F(ExprCompilerTest, listenerPrePostCallbacks) {
+  auto factory = std::make_shared<CountingListenerFactory>();
+  registerVectorFunctionListenerFactory(factory);
+
+  auto rowType = ROW({"a"}, {BIGINT()});
+  auto field = makeField(rowType);
+  auto expression = call("plus", {field("a"), bigint(1)});
+  auto exprSet = compile(expression);
+
+  auto input = makeRowVector({"a"}, {makeFlatVector<int64_t>({1, 2, 3})});
+  SelectivityVector rows(3);
+  EvalCtx evalCtx(execCtx_.get(), exprSet.get(), input.get());
+  std::vector<VectorPtr> results(1);
+  exprSet->eval(rows, evalCtx, results);
+
+  EXPECT_EQ(factory->preCount->load(), 1);
+  EXPECT_EQ(factory->postCount->load(), 1);
+  auto expected = makeFlatVector<int64_t>({2, 3, 4});
+  velox::test::assertEqualVectors(expected, results[0]);
+  unregisterVectorFunctionListenerFactory(factory);
+}
+
+TEST_F(ExprCompilerTest, listenerSelectiveHooking) {
+  auto hookCount = std::make_shared<std::atomic<int>>(0);
+  auto factory = std::make_shared<SelectiveListenerFactory>("plus", hookCount);
+  registerVectorFunctionListenerFactory(factory);
+
+  auto rowType = ROW({"a"}, {BIGINT()});
+  auto field = makeField(rowType);
+  auto expression =
+      call("plus", {call("multiply", {field("a"), bigint(2)}), bigint(1)});
+  auto exprSet = compile(expression);
+
+  auto input = makeRowVector({"a"}, {makeFlatVector<int64_t>({1, 2, 3})});
+  SelectivityVector rows(3);
+  EvalCtx evalCtx(execCtx_.get(), exprSet.get(), input.get());
+  std::vector<VectorPtr> results(1);
+  exprSet->eval(rows, evalCtx, results);
+
+  EXPECT_EQ(hookCount->load(), 1);
+  auto expected = makeFlatVector<int64_t>({3, 5, 7});
+  velox::test::assertEqualVectors(expected, results[0]);
+  unregisterVectorFunctionListenerFactory(factory);
+}
+
+TEST_F(ExprCompilerTest, listenerPreThrows) {
+  class ThrowingPreFactory : public VectorFunctionListenerFactory {
+   public:
+    std::optional<VectorFunctionListeners> create(
+        std::string_view /*functionName*/,
+        const VectorFunctionMetadata& /*metadata*/,
+        const core::QueryConfig& /*queryConfig*/) override {
+      return VectorFunctionListeners{
+          std::make_shared<PreApplyListener>(
+              [](std::string_view /*functionName*/,
+                 const SelectivityVector& /*rows*/,
+                 const std::vector<VectorPtr>& /*args*/,
+                 const TypePtr& /*outputType*/,
+                 const EvalCtx& /*context*/) {
+                VELOX_USER_FAIL("pre-listener error");
+              }),
+          nullptr,
+      };
+    }
+  };
+
+  auto factory = std::make_shared<ThrowingPreFactory>();
+  registerVectorFunctionListenerFactory(factory);
+
+  auto rowType = ROW({"a"}, {BIGINT()});
+  auto field = makeField(rowType);
+  auto expression = call("plus", {field("a"), bigint(1)});
+  auto exprSet = compile(expression);
+
+  auto input = makeRowVector({"a"}, {makeFlatVector<int64_t>({1, 2, 3})});
+  SelectivityVector rows(3);
+  EvalCtx evalCtx(execCtx_.get(), exprSet.get(), input.get());
+  std::vector<VectorPtr> results(1);
+  VELOX_ASSERT_THROW(
+      exprSet->eval(rows, evalCtx, results), "pre-listener error");
+  unregisterVectorFunctionListenerFactory(factory);
+}
+
+TEST_F(ExprCompilerTest, listenerPostThrowsIsSwallowed) {
+  auto secondPostCalled = std::make_shared<bool>(false);
+
+  class ThrowingPostFactory : public VectorFunctionListenerFactory {
+   public:
+    std::optional<VectorFunctionListeners> create(
+        std::string_view /*functionName*/,
+        const VectorFunctionMetadata& /*metadata*/,
+        const core::QueryConfig& /*queryConfig*/) override {
+      return VectorFunctionListeners{
+          nullptr,
+          std::make_shared<PostApplyListener>(
+              [](std::string_view /*functionName*/,
+                 const SelectivityVector& /*rows*/,
+                 const std::vector<VectorPtr>& /*args*/,
+                 const TypePtr& /*outputType*/,
+                 const EvalCtx& /*context*/,
+                 const VectorPtr& /*result*/,
+                 std::exception_ptr /*error*/) {
+                VELOX_USER_FAIL("post-listener error");
+              }),
+      };
+    }
+  };
+
+  class CheckingPostFactory : public VectorFunctionListenerFactory {
+   public:
+    explicit CheckingPostFactory(std::shared_ptr<bool> called)
+        : called_(std::move(called)) {}
+
+    std::optional<VectorFunctionListeners> create(
+        std::string_view /*functionName*/,
+        const VectorFunctionMetadata& /*metadata*/,
+        const core::QueryConfig& /*queryConfig*/) override {
+      return VectorFunctionListeners{
+          nullptr,
+          std::make_shared<PostApplyListener>(
+              [called = called_](
+                  std::string_view /*functionName*/,
+                  const SelectivityVector& /*rows*/,
+                  const std::vector<VectorPtr>& /*args*/,
+                  const TypePtr& /*outputType*/,
+                  const EvalCtx& /*context*/,
+                  const VectorPtr& /*result*/,
+                  std::exception_ptr /*error*/) { *called = true; }),
+      };
+    }
+
+   private:
+    std::shared_ptr<bool> called_;
+  };
+
+  auto throwingFactory = std::make_shared<ThrowingPostFactory>();
+  auto checkingFactory =
+      std::make_shared<CheckingPostFactory>(secondPostCalled);
+  registerVectorFunctionListenerFactory(throwingFactory);
+  registerVectorFunctionListenerFactory(checkingFactory);
+
+  auto rowType = ROW({"a"}, {BIGINT()});
+  auto field = makeField(rowType);
+  auto expression = call("plus", {field("a"), bigint(1)});
+  auto exprSet = compile(expression);
+
+  auto input = makeRowVector({"a"}, {makeFlatVector<int64_t>({1, 2, 3})});
+  SelectivityVector rows(3);
+  EvalCtx evalCtx(execCtx_.get(), exprSet.get(), input.get());
+  std::vector<VectorPtr> results(1);
+  exprSet->eval(rows, evalCtx, results);
+
+  auto expected = makeFlatVector<int64_t>({2, 3, 4});
+  velox::test::assertEqualVectors(expected, results[0]);
+  EXPECT_TRUE(*secondPostCalled);
+  unregisterVectorFunctionListenerFactory(throwingFactory);
+  unregisterVectorFunctionListenerFactory(checkingFactory);
+}
+
+TEST_F(ExprCompilerTest, listenerPostReceivesApplyError) {
+  auto postCalled = std::make_shared<std::atomic<bool>>(false);
+  auto receivedError = std::make_shared<std::atomic<bool>>(false);
+
+  class ErrorCapturingFactory : public VectorFunctionListenerFactory {
+   public:
+    ErrorCapturingFactory(
+        std::shared_ptr<std::atomic<bool>> postCalled,
+        std::shared_ptr<std::atomic<bool>> receivedError)
+        : postCalled_(std::move(postCalled)),
+          receivedError_(std::move(receivedError)) {}
+
+    std::optional<VectorFunctionListeners> create(
+        std::string_view /*functionName*/,
+        const VectorFunctionMetadata& /*metadata*/,
+        const core::QueryConfig& /*queryConfig*/) override {
+      return VectorFunctionListeners{
+          nullptr,
+          std::make_shared<PostApplyListener>(
+              [postCalled = postCalled_, receivedError = receivedError_](
+                  std::string_view /*functionName*/,
+                  const SelectivityVector& /*rows*/,
+                  const std::vector<VectorPtr>& /*args*/,
+                  const TypePtr& /*outputType*/,
+                  const EvalCtx& /*context*/,
+                  const VectorPtr& /*result*/,
+                  std::exception_ptr error) {
+                postCalled->store(true);
+                receivedError->store(error != nullptr);
+              }),
+      };
+    }
+
+   private:
+    std::shared_ptr<std::atomic<bool>> postCalled_;
+    std::shared_ptr<std::atomic<bool>> receivedError_;
+  };
+
+  auto factory =
+      std::make_shared<ErrorCapturingFactory>(postCalled, receivedError);
+  registerVectorFunctionListenerFactory(factory);
+
+  auto rowType = ROW({"a"}, {BIGINT()});
+  auto field = makeField(rowType);
+  auto expression = call("divide", {field("a"), bigint(0)});
+  auto exprSet = compile(expression);
+
+  auto input = makeRowVector({"a"}, {makeFlatVector<int64_t>({1, 2, 3})});
+  SelectivityVector rows(3);
+  EvalCtx evalCtx(execCtx_.get(), exprSet.get(), input.get());
+  std::vector<VectorPtr> results(1);
+  EXPECT_THROW(exprSet->eval(rows, evalCtx, results), VeloxException);
+
+  EXPECT_TRUE(postCalled->load());
+  EXPECT_TRUE(receivedError->load());
+  unregisterVectorFunctionListenerFactory(factory);
+}
+
+TEST_F(ExprCompilerTest, multipleListenerFactories) {
+  auto factoryA = std::make_shared<CountingListenerFactory>();
+  auto factoryB = std::make_shared<CountingListenerFactory>();
+  registerVectorFunctionListenerFactory(factoryA);
+  registerVectorFunctionListenerFactory(factoryB);
+
+  auto rowType = ROW({"a"}, {BIGINT()});
+  auto field = makeField(rowType);
+  auto expression = call("plus", {field("a"), bigint(1)});
+  auto exprSet = compile(expression);
+
+  auto input = makeRowVector({"a"}, {makeFlatVector<int64_t>({1, 2, 3})});
+  SelectivityVector rows(3);
+  EvalCtx evalCtx(execCtx_.get(), exprSet.get(), input.get());
+  std::vector<VectorPtr> results(1);
+  exprSet->eval(rows, evalCtx, results);
+
+  EXPECT_EQ(factoryA->preCount->load(), 1);
+  EXPECT_EQ(factoryA->postCount->load(), 1);
+  EXPECT_EQ(factoryB->preCount->load(), 1);
+  EXPECT_EQ(factoryB->postCount->load(), 1);
+
+  auto expected = makeFlatVector<int64_t>({2, 3, 4});
+  velox::test::assertEqualVectors(expected, results[0]);
+  unregisterVectorFunctionListenerFactory(factoryA);
+  unregisterVectorFunctionListenerFactory(factoryB);
+}
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/expression/tests/ExprEncodingsTest.cpp b/velox/expression/tests/ExprEncodingsTest.cpp
index cb582282929..67a778c9816 100644
--- a/velox/expression/tests/ExprEncodingsTest.cpp
+++ b/velox/expression/tests/ExprEncodingsTest.cpp
@@ -19,7 +19,6 @@
 #include "velox/common/base/Exceptions.h"
 #include "velox/expression/ConstantExpr.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
-#include "velox/parse/Expressions.h"
 #include "velox/parse/ExpressionsParser.h"
 #include "velox/parse/TypeResolver.h"
 #include "velox/vector/VectorEncoding.h"
@@ -177,7 +176,7 @@ class ExprEncodingsTest
   core::TypedExprPtr parseExpression(
       const std::string& text,
       const RowTypePtr& rowType) {
-    auto untyped = parse::parseExpr(text, options_);
+    auto untyped = parse::DuckSqlExpressionsParser(options_).parseExpr(text);
     return core::Expressions::inferTypes(untyped, rowType, execCtx_->pool());
   }
 
diff --git a/velox/expression/tests/ExprOptimizerTest.cpp b/velox/expression/tests/ExprOptimizerTest.cpp
new file mode 100644
index 00000000000..02b155aa9d9
--- /dev/null
+++ b/velox/expression/tests/ExprOptimizerTest.cpp
@@ -0,0 +1,552 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/core/Expressions.h"
+#include "velox/expression/ExprOptimizer.h"
+#include "velox/expression/ExprRewriteRegistry.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/functions/prestosql/types/JsonType.h"
+#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+
+namespace facebook::velox::expression {
+namespace {
+
+class ExprOptimizerTest : public functions::test::FunctionBaseTest {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    functions::prestosql::registerAllScalarFunctions("");
+    parse::registerTypeResolver();
+    options_.parseDecimalAsDouble = false;
+  }
+
+  void TearDown() override {
+    expression::ExprRewriteRegistry::instance().clear();
+  }
+
+  /// Validates expression::optimize API. The input expression is optimized and
+  /// then evaluated with a randomly generated input vector.
+  /// @param input String representation of input SQL expression to be
+  /// optimized.
+  /// @param expected String representation of expected SQL expression after
+  /// optimization of `input`.
+  /// @param type Type of `input` and `expected`.
+  /// @param makeFailExpr Callback that returns an expression to replace any
+  /// failing subexpression(s) during optimization of `input`.
+  /// @param evalError Expected error message upon evaluating optimized `input`.
+  /// Should be used iff `makeFailExpr` returns an expression that throws upon
+  /// evaluation (eg: Presto `fail` function).
+  void testExpression(
+      const std::string& input,
+      const std::string& expected,
+      const RowTypePtr& type = ROW({}),
+      const MakeFailExpr& makeFailExpr = nullptr,
+      const std::string& evalError = "") {
+    const auto typedExpr = makeTypedExpr(input, type);
+    auto optimized =
+        expression::optimize(typedExpr, queryCtx_.get(), pool(), makeFailExpr);
+    const auto expectedTypedExpr = makeTypedExpr(expected, type);
+    SCOPED_TRACE(
+        fmt::format(
+            "Input: {}\nOptimized: {}\nExpected: {}",
+            typedExpr->toString(),
+            optimized->toString(),
+            expectedTypedExpr->toString()));
+    ASSERT_TRUE(*optimized == *expectedTypedExpr);
+
+    // Generate random values with fuzzer to validate evaluation of optimized
+    // expression.
+    const auto data = fuzzFlat(type);
+    if (makeFailExpr != nullptr && !evalError.empty()) {
+      VELOX_ASSERT_THROW(evaluate(optimized, data), evalError);
+    } else {
+      const auto optimizedResult = evaluate(optimized, data);
+      const auto expectedResult = evaluate(expectedTypedExpr, data);
+      test::assertEqualVectors(optimizedResult, expectedResult);
+    }
+  }
+
+  void testExpression(
+      const core::TypedExprPtr& typedExpr,
+      const core::TypedExprPtr& expectedTypedExpr,
+      const RowTypePtr& type = ROW({}),
+      const MakeFailExpr& makeFailExpr = nullptr,
+      const std::string& evalError = "") {
+    auto optimized =
+        expression::optimize(typedExpr, queryCtx_.get(), pool(), makeFailExpr);
+    SCOPED_TRACE(
+        fmt::format(
+            "Input: {}\nOptimized: {}\nExpected: {}",
+            typedExpr->toString(),
+            optimized->toString(),
+            expectedTypedExpr->toString()));
+    ASSERT_TRUE(*optimized == *expectedTypedExpr);
+
+    const auto data = fuzzFlat(type);
+    if (makeFailExpr != nullptr && !evalError.empty()) {
+      VELOX_ASSERT_THROW(evaluate(optimized, data), evalError);
+    } else {
+      const auto optimizedResult = evaluate(optimized, data);
+      const auto expectedResult = evaluate(expectedTypedExpr, data);
+      test::assertEqualVectors(optimizedResult, expectedResult);
+    }
+  }
+
+  void setQueryTimeZone(const std::string& timeZone) {
+    queryCtx_->testingOverrideConfigUnsafe(
+        {{core::QueryConfig::kSessionTimezone, timeZone},
+         {core::QueryConfig::kAdjustTimestampToTimezone, "true"}});
+  }
+
+ private:
+  RowVectorPtr fuzzFlat(const RowTypePtr& rowType) {
+    VectorFuzzer::Options options;
+    options.vectorSize = 100;
+    VectorFuzzer fuzzer(options, pool());
+    return fuzzer.fuzzInputFlatRow(rowType);
+  }
+
+  std::shared_ptr<core::QueryCtx> queryCtx_{core::QueryCtx::create()};
+  std::unique_ptr<core::ExecCtx> execCtx_{
+      std::make_unique<core::ExecCtx>(pool_.get(), queryCtx_.get())};
+  parse::ParseOptions options_;
+};
+
+TEST_F(ExprOptimizerTest, constantFolding) {
+  // comparison.
+  testExpression("'a' = substr('abc', 1, 1)", "true");
+  testExpression("'a' = cast(null as varchar)", "cast(null AS BOOLEAN)");
+  testExpression(
+      "cast((12345678901234567890.000 + 0.123) AS DECIMAL(23, 3)) = cast(12345678901234567890.123 AS DECIMAL(23, 3))",
+      "true");
+  testExpression("'0ab01c' LIKE '%ab%c%'", "true");
+  testExpression("3 between (4 - 2) and 2 * 2", "true");
+  testExpression(
+      "3 between cast(null AS BIGINT) and 4", "cast(null AS BOOLEAN)");
+  testExpression("IF(2 = 2, 3, 4)", "3");
+  testExpression("IF(cast(null AS BOOLEAN), 3, 4)", "4");
+  testExpression("IF('hello' = 'foo', cast(null AS BIGINT), 4)", "4");
+  testExpression(
+      "IF('hello' = 'hello', cast(null AS BIGINT), 4)", "cast(null AS BIGINT)");
+  testExpression("random() = random()", "random() = random()");
+  testExpression("current_date() = current_date()", "true");
+
+  // cast.
+  testExpression("cast('-123' as BIGINT)", "-123");
+  testExpression("cast(DECIMAL '1234567890.123' as BIGINT)", "1234567890");
+  testExpression("cast('t' as BOOLEAN)", "true");
+  testExpression("cast('f' as BOOLEAN)", "false");
+  testExpression("cast('1' as BOOLEAN)", "true");
+  testExpression("cast('0' as BOOLEAN)", "false");
+  testExpression("cast(-123.456E0 as VARCHAR)", "'-123.456'");
+  testExpression("cast(cast('abcxyz' as VARCHAR) as VARCHAR)", "'abcxyz'");
+
+  // Partial constant folding in expression tree.
+  testExpression(
+      "1234 between a and 2000 + 1",
+      "1234 between a and 2001",
+      ROW({"a"}, {BIGINT()}));
+  testExpression(
+      "concat(substr(a, 1 + 5 - 2), substr(b, 2 * 3))",
+      "concat(substr(a, 4), substr(b, 6))",
+      ROW({"a", "b"}, {VARCHAR(), VARCHAR()}));
+  testExpression(
+      "a = 'z' and b = (1 + 1) or c = (5 - 1) * 3",
+      "a = 'z' and b = 2 or c = 12",
+      ROW({"a", "b", "c"}, {VARCHAR(), BIGINT(), INTEGER()}));
+}
+
+TEST_F(ExprOptimizerTest, specialFormConstantFolding) {
+  // AND, OR.
+  testExpression("true and true", "true");
+  testExpression("false or false", "false");
+  testExpression("null::boolean and false", "false");
+  testExpression("true or null::boolean", "true");
+  testExpression(
+      "null::boolean and null::boolean and null::boolean", "null::boolean");
+  testExpression(
+      "null::boolean or null::boolean or null::boolean", "null::boolean");
+  testExpression("null::boolean and true", "null::boolean");
+  testExpression("false or null::boolean", "null::boolean");
+
+  // IF, SWITCH.
+  testExpression("if(true, 'hello', 'world')", "'hello'");
+  testExpression("case when false then 1 when true then 3 end", "3");
+  testExpression(
+      "case when false then 1 when false then 3 end", "null::bigint");
+  testExpression("case when false then 1 when false then 3 else 2 end", "2");
+  testExpression(
+      "case when false then 'hello' when false then 'world' when true then 'foo' else 'bar' end",
+      "'foo'");
+}
+
+TEST_F(ExprOptimizerTest, lambdas) {
+  auto type = ROW({"a"}, {ARRAY(BIGINT())});
+  testExpression(
+      "filter(a, (x) -> abs(x + (1 + 2)) = (6 / 2))",
+      "filter(a, (x) -> abs(x + 3) = 3)",
+      type);
+  testExpression(
+      "filter(a, (x) -> 1 * (4 / 2) = abs(-4 * 3))",
+      "filter(a, (x) -> false)",
+      type);
+  type = ROW({"a"}, {ARRAY(VARCHAR())});
+  testExpression(
+      "filter(a, (x) -> length(x) + (3 - 2) = 4 / 2)",
+      "filter(a, (x) -> length(x) + 1 = 2)",
+      type);
+  testExpression(
+      "array_sort(a, x -> length(x) * abs(-1 * 3 * 2))",
+      "array_sort(a, x -> length(x) * 6)",
+      type);
+  testExpression(
+      "reduce(c0, (89.0E0 + 11.0E0), (s, x) -> s + x * (0.2E0 - 0.1E0), s -> (s < (100.0E0 + 1.0E0)))",
+      "reduce(c0, 100.0E0, (s, x) -> s + x * 0.1E0, s -> (s < 101.0E0))",
+      ROW({"c0"}, {ARRAY(DOUBLE())}));
+  testExpression(
+      "reduce(c0, 1 - 1, (s, x) -> s + x, s -> coalesce(s, abs(2 - 10)) * (5 * 2))",
+      "reduce(c0, 0, (s, x) -> s + x, s -> coalesce(s, 8) * 10)",
+      ROW({"c0"}, {ARRAY(SMALLINT())}));
+}
+
+TEST_F(ExprOptimizerTest, rewritesWithConstantFolding) {
+  auto type = ROW({"c0"}, {ARRAY(VARCHAR())});
+  testExpression(
+      "array_sort(c0, (x, y) -> if(length(x) < length(y), (-1 * 1)::integer, if(length(x) = length(y), abs(0)::integer, (2 / 2)::integer)))",
+      "array_sort(c0, x -> length(x))",
+      type);
+  testExpression(
+      "array_sort(c0, (x, y) -> if(length(x) < length(y), abs(-1)::integer, if(length(x) > length(y), (-4 / 3)::integer, (0 / 3)::integer)))",
+      "array_sort_desc(c0, x -> length(x))",
+      type);
+
+  testExpression(
+      "reduce(c0, 8 / 2, (s, x) -> if(x % 2 = 0, s + 1, s), s -> s)",
+      "4 + cast(array_sum_propagate_element_null(transform(c0, x -> if(x % 2 = 0, 1, 0))) AS BIGINT)",
+      ROW({"c0"}, {ARRAY(INTEGER())}));
+  testExpression(
+      "reduce(c0, length(concat('abc', 'xyz')) * 3, (s, x) -> s + (abs(-2) + (5 - 4)) - x, s -> s)",
+      "18 + cast(array_sum_propagate_element_null(transform(c0, x -> 3 - x)) AS BIGINT)",
+      ROW({"c0"}, {ARRAY(TINYINT())}));
+
+  // Conjunct rewrites with constant folding.
+  type = ROW({"a"}, {ARRAY(BIGINT())});
+  testExpression("if(array_position(a, 1) > 10 and false, 0, 1)", "1", type);
+  testExpression("if(cardinality(a) > 10 or true, 0, 1)", "0", type);
+  testExpression(
+      "filter(a, x -> (2 * 3) = x and abs(-4) = (3 - 1))",
+      "filter(a, x -> false)",
+      type);
+  testExpression(
+      "filter(a, x -> (2 * 3) = x or (8 / 2) = (3 + 1))",
+      "filter(a, x -> true)",
+      type);
+
+  // Switch rewrite with constant folding.
+  testExpression(
+      "case when ARRAY[abs(-1)] = ARRAY[2] then 'not_matched' when ARRAY[1] = ARRAY[2 - 1] then 'matched' else 'default' end",
+      "'matched'");
+  testExpression(
+      "case when 10 + a = 100 / 2 then 10 - 2 when a / (2 + 1) = abs(-5) then 10 * 10 when (123 * 10) + 4 = abs(-1234) then 11 * 3 else a end",
+      "case when 10 + a = 50 then 8 when a / 3 = 5 then 100 else 33 end",
+      ROW({"a"}, {BIGINT()}));
+
+  // Coalesce rewrite with constant folding.
+  type = ROW({"a", "b"}, {BIGINT(), BIGINT()});
+  testExpression(
+      "coalesce(a - (4 / 2), a - (1 * 2), null::bigint, 1 - 1, b, null::bigint)",
+      "coalesce(a - 2, 0)",
+      type);
+  testExpression(
+      "coalesce(null::bigint, a / abs(-2 * 3), coalesce(coalesce(b, 8 / 2), a * b), b)",
+      "coalesce(a / 6, b, 4)",
+      type);
+}
+
+/// Test to ensure session queryCtx is used during expression optimization.
+TEST_F(ExprOptimizerTest, queryCtx) {
+  auto testFromUnixtime = [&](const std::string& function,
+                              const std::string& timezone,
+                              const std::string& expected) {
+    setQueryTimeZone(timezone);
+    testExpression(
+        fmt::format("{}(from_unixtime(9.98489045321E8))", function), expected);
+  };
+
+  testFromUnixtime("hour", "Pacific/Apia", "3");
+  testFromUnixtime("hour", "America/Los_Angeles", "7");
+  testFromUnixtime("minute", "Pacific/Apia", "4");
+  testFromUnixtime("minute", "America/Los_Angeles", "4");
+}
+
+/// Test cast optimization that avoids expression evaluation when input to
+/// cast is same as the type of cast expression.
+TEST_F(ExprOptimizerTest, castExpr) {
+  auto testCast = [&](const TypePtr& type, const std::string& typeString = "") {
+    const auto rowType = ROW({"a"}, {type});
+    if (type->isPrimitiveType()) {
+      testExpression(
+          fmt::format("cast(a as {})", type->toString()), "a", rowType);
+    } else {
+      testExpression(fmt::format("cast(a as {})", typeString), "a", rowType);
+    }
+  };
+
+  // Primitive types.
+  std::vector<TypePtr> primitiveTypes = {
+      TINYINT(),
+      SMALLINT(),
+      INTEGER(),
+      BIGINT(),
+      DOUBLE(),
+      REAL(),
+      VARBINARY(),
+      VARCHAR(),
+      DECIMAL(5, 2),
+      DECIMAL(25, 10),
+      DATE(),
+      TIMESTAMP_WITH_TIME_ZONE()};
+  for (const auto& type : primitiveTypes) {
+    testCast(type);
+  }
+
+  // Complex types.
+  testCast(ARRAY(DATE()), "DATE[]");
+  testCast(MAP(DOUBLE(), VARCHAR()), "map(DOUBLE, VARCHAR)");
+  testCast(
+      ROW({"c0", "c1", "c2"},
+          {BIGINT(), DECIMAL(5, 2), TIMESTAMP_WITH_TIME_ZONE()}),
+      "struct(c0 BIGINT, c1 DECIMAL(5, 2), c2 TIMESTAMP WITH TIME ZONE)");
+
+  // Functions.
+  auto type = ROW({"a"}, {VARCHAR()});
+  testExpression(
+      "cast(concat(a, 'test') as VARCHAR)", "concat(a, 'test')", type);
+  testExpression(
+      "cast(substr(a, abs(-2) * (3 / 1)) as VARCHAR)", "substr(a, 6)", type);
+  testExpression(
+      "cast((a = (5 / 1) * abs(-3)) as BOOLEAN) and cast((b = concat('hello', 'world')) as BOOLEAN)",
+      "a = 15 and b = 'helloworld'",
+      ROW({"a", "b"}, {BIGINT(), VARCHAR()}));
+}
+
+/// Test to validate `makeFailExpr` returns an expression that replaces all
+/// failing subexpressions in the expression tree.
+TEST_F(ExprOptimizerTest, makeFailExpr) {
+  const auto divideByZeroError = "division by zero";
+  auto assertPrestoFailExpr = [&](const std::string& expression,
+                                  const std::string& expected,
+                                  const RowTypePtr& type) {
+    const static MakeFailExpr prestoFailExpr =
+        [&](const std::string& error,
+            const TypePtr& type) -> core::TypedExprPtr {
+      return makeTypedExpr(
+          fmt::format("cast(fail('{}') AS {})", error, type->toString()),
+          ROW({}));
+    };
+    testExpression(
+        expression, expected, type, prestoFailExpr, divideByZeroError);
+  };
+  auto prestoFailCall = [&]() {
+    return fmt::format("cast(fail('{}') AS BIGINT)", divideByZeroError);
+  };
+
+  // Primitive types.
+  assertPrestoFailExpr("0 / 0", prestoFailCall(), ROW({}));
+  assertPrestoFailExpr(
+      "if(a = 2 * 2, a / abs(-1 * 3), 0 / 0)",
+      fmt::format("if(a = 4, a / 3, {})", prestoFailCall()),
+      ROW({"a"}, {BIGINT()}));
+  assertPrestoFailExpr(
+      "json_extract(a, substr(b, 1 / 0))",
+      fmt::format("json_extract(a, substr(b, {}))", prestoFailCall()),
+      ROW({"a", "b"}, {JSON(), VARCHAR()}));
+
+  // Complex types.
+  assertPrestoFailExpr(
+      "filter(a, x -> (1 / 0) > 1)",
+      fmt::format("filter(a, x -> {} > 1)", prestoFailCall()),
+      ROW({"a"}, {ARRAY(BIGINT())}));
+  assertPrestoFailExpr(
+      "map_top_n(a, 1 / 0)",
+      fmt::format("map_top_n(a, {})", prestoFailCall()),
+      ROW({"a"}, {MAP(VARCHAR(), BIGINT())}));
+
+  // Special form expressions.
+  assertPrestoFailExpr(
+      "coalesce(0 / 0 > 1, a, 0 / 0 = 0)",
+      fmt::format(
+          "coalesce({} > 1, a, {} = 0)", prestoFailCall(), prestoFailCall()),
+      ROW({"a"}, {BOOLEAN()}));
+  assertPrestoFailExpr(
+      "CASE abs(-1234) WHEN a + (2 + 3) THEN 2 / 1 WHEN 0 / 0 THEN abs(-2) ELSE length('abc') END",
+      fmt::format(
+          "CASE 1234 WHEN a + 5 THEN 2 WHEN {} THEN 2 ELSE 3 END",
+          prestoFailCall()),
+      ROW({"a"}, {BIGINT()}));
+}
+
+TEST_F(ExprOptimizerTest, nullIfConstantFolding) {
+  auto emptyRow = ROW({});
+
+  auto makeNull = [&](const TypePtr& type) {
+    return std::make_shared<core::ConstantTypedExpr>(
+        BaseVector::createNullConstant(type, 1, pool()));
+  };
+
+  auto makeCast = [](const TypePtr& toType, const core::TypedExprPtr& input) {
+    return std::make_shared<core::CastTypedExpr>(toType, input, false);
+  };
+
+  auto constTrue = makeTypedExpr("true", emptyRow);
+  auto constFalse = makeTypedExpr("false", emptyRow);
+  auto constA = makeTypedExpr("'a'", emptyRow);
+  auto constB = makeTypedExpr("'b'", emptyRow);
+  auto constOne = makeTypedExpr("1", emptyRow);
+  auto constTwo = makeTypedExpr("2", emptyRow);
+
+  // Boolean cases.
+  testExpression(
+      std::make_shared<core::NullIfTypedExpr>(constTrue, constTrue, BOOLEAN()),
+      makeNull(BOOLEAN()));
+  testExpression(
+      std::make_shared<core::NullIfTypedExpr>(constTrue, constFalse, BOOLEAN()),
+      constTrue);
+  testExpression(
+      std::make_shared<core::NullIfTypedExpr>(
+          makeCast(BOOLEAN(), makeNull(UNKNOWN())), constFalse, BOOLEAN()),
+      makeNull(BOOLEAN()));
+  testExpression(
+      std::make_shared<core::NullIfTypedExpr>(
+          constTrue, makeCast(BOOLEAN(), makeNull(UNKNOWN())), BOOLEAN()),
+      constTrue);
+
+  // VARCHAR cases.
+  testExpression(
+      std::make_shared<core::NullIfTypedExpr>(constA, constA, VARCHAR()),
+      makeNull(VARCHAR()));
+  testExpression(
+      std::make_shared<core::NullIfTypedExpr>(constA, constB, VARCHAR()),
+      constA);
+  testExpression(
+      std::make_shared<core::NullIfTypedExpr>(
+          makeCast(VARCHAR(), makeNull(UNKNOWN())), constB, VARCHAR()),
+      makeNull(VARCHAR()));
+  testExpression(
+      std::make_shared<core::NullIfTypedExpr>(
+          constA, makeCast(VARCHAR(), makeNull(UNKNOWN())), VARCHAR()),
+      constA);
+
+  // Integer cases.
+  testExpression(
+      std::make_shared<core::NullIfTypedExpr>(
+          constOne, constOne, constOne->type()),
+      makeNull(constOne->type()));
+  testExpression(
+      std::make_shared<core::NullIfTypedExpr>(
+          constOne, constTwo, constOne->type()),
+      constOne);
+
+  // Cross-type with cast.
+  testExpression(
+      std::make_shared<core::NullIfTypedExpr>(
+          constOne, makeCast(BIGINT(), constTwo), BIGINT()),
+      constOne);
+
+  // Double with cast.
+  {
+    auto constOneDouble = makeTypedExpr("1.0E0", emptyRow);
+    testExpression(
+        std::make_shared<core::NullIfTypedExpr>(
+            constOneDouble, makeCast(DOUBLE(), constOne), DOUBLE()),
+        makeNull(DOUBLE()));
+  }
+  {
+    auto constOneOneDouble = makeTypedExpr("1.1E0", emptyRow);
+    testExpression(
+        std::make_shared<core::NullIfTypedExpr>(
+            constOneOneDouble, makeCast(DOUBLE(), constOne), DOUBLE()),
+        constOneOneDouble);
+  }
+  {
+    auto constOneOneDouble = makeTypedExpr("1.1E0", emptyRow);
+    testExpression(
+        std::make_shared<core::NullIfTypedExpr>(
+            constOneOneDouble, constOneOneDouble, DOUBLE()),
+        makeNull(DOUBLE()));
+  }
+
+  // Arithmetic subexpression.
+  testExpression(
+      std::make_shared<core::NullIfTypedExpr>(
+          constOne, makeTypedExpr("2 - 1", emptyRow), constOne->type()),
+      makeNull(constOne->type()));
+
+  // Null pairs.
+  testExpression(
+      std::make_shared<core::NullIfTypedExpr>(
+          makeNull(BIGINT()), makeNull(BIGINT()), BIGINT()),
+      makeNull(BIGINT()));
+  testExpression(
+      std::make_shared<core::NullIfTypedExpr>(
+          constOne, makeNull(constOne->type()), constOne->type()),
+      constOne);
+
+  // Decimal cases.
+  {
+    auto d11 = makeTypedExpr("1.1", emptyRow);
+    auto d12 = makeTypedExpr("1.2", emptyRow);
+    testExpression(
+        std::make_shared<core::NullIfTypedExpr>(d11, d12, d11->type()), d11);
+  }
+  {
+    auto dLong = makeTypedExpr("9876543210.9874561203", emptyRow);
+    testExpression(
+        std::make_shared<core::NullIfTypedExpr>(dLong, dLong, dLong->type()),
+        makeNull(dLong->type()));
+  }
+
+  // Array.
+  {
+    auto arr = makeTypedExpr("array[1::bigint]", emptyRow);
+    testExpression(
+        std::make_shared<core::NullIfTypedExpr>(arr, arr, arr->type()),
+        makeNull(arr->type()));
+  }
+
+  // Variable input: partial folding of subexpressions.
+  {
+    auto rowType = ROW({"a", "b"}, {BIGINT(), BIGINT()});
+    auto aField = std::make_shared<core::FieldAccessTypedExpr>(BIGINT(), "a");
+    auto addExpr = makeTypedExpr("b + (1 + 1)", rowType);
+    auto expectedExpr = std::make_shared<core::NullIfTypedExpr>(
+        aField, makeTypedExpr("b + 2", rowType), BIGINT());
+    testExpression(
+        std::make_shared<core::NullIfTypedExpr>(aField, addExpr, BIGINT()),
+        expectedExpr,
+        rowType);
+  }
+}
+
+} // namespace
+} // namespace facebook::velox::expression
diff --git a/velox/expression/tests/ExprRewriteRegistryTest.cpp b/velox/expression/tests/ExprRewriteRegistryTest.cpp
new file mode 100644
index 00000000000..2581a006696
--- /dev/null
+++ b/velox/expression/tests/ExprRewriteRegistryTest.cpp
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/expression/ExprRewriteRegistry.h"
+#include "gtest/gtest.h"
+
+namespace facebook::velox::expression {
+
+namespace {
+
+class ExprRewriteRegistryTest : public testing::Test {};
+
+TEST_F(ExprRewriteRegistryTest, basic) {
+  expression::ExprRewriteRegistry registry;
+  expression::ExpressionRewrite testRewrite =
+      [&](const core::TypedExprPtr& input) {
+        return std::make_shared<core::CallTypedExpr>(
+            input->type(), "rewritten_expr", input, input);
+      };
+  registry.registerRewrite(testRewrite);
+
+  auto input = std::make_shared<core::CallTypedExpr>(
+      BIGINT(),
+      "original_expr",
+      std::make_shared<core::FieldAccessTypedExpr>(BIGINT(), "a"));
+  const auto rewritten = registry.rewrite(input);
+  ASSERT_TRUE(rewritten->isCallKind());
+  ASSERT_TRUE(rewritten->type()->isBigint());
+  const auto rewrittenCall = rewritten->asUnchecked<core::CallTypedExpr>();
+  ASSERT_EQ(rewrittenCall->inputs().size(), 2);
+  ASSERT_EQ(rewrittenCall->name(), "rewritten_expr");
+
+  registry.clear();
+  const auto rewriteAfterClear = registry.rewrite(input);
+  ASSERT_TRUE(*rewriteAfterClear == *input);
+}
+
+} // namespace
+} // namespace facebook::velox::expression
diff --git a/velox/expression/tests/ExprStatsTest.cpp b/velox/expression/tests/ExprStatsTest.cpp
index 70394b4ce91..1f9ba945155 100644
--- a/velox/expression/tests/ExprStatsTest.cpp
+++ b/velox/expression/tests/ExprStatsTest.cpp
@@ -18,15 +18,30 @@
 #include "velox/core/Expressions.h"
 #include "velox/expression/EvalCtx.h"
 #include "velox/expression/Expr.h"
+#include "velox/functions/Registerer.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
-#include "velox/parse/Expressions.h"
 #include "velox/parse/ExpressionsParser.h"
 #include "velox/parse/TypeResolver.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::test;
 
+/// A deliberately expensive scalar function used to test adaptive CPU sampling.
+/// The loop makes the per-row cost high enough that clock_gettime overhead is
+/// negligible. volatile prevents the compiler from optimizing away the loop.
+template <typename T>
+struct SlowAddFunction {
+  template <typename TInput>
+  void call(TInput& result, const TInput& a, const TInput& b) {
+    result = a + b;
+    volatile TInput sink = result;
+    for (int i = 0; i < 50'000; ++i) {
+      sink = sink + 1;
+    }
+  }
+};
+
 class ExprStatsTest : public functions::test::FunctionBaseTest {
  protected:
   void SetUp() override {
@@ -423,3 +438,306 @@ TEST_F(ExprStatsTest, complexConstants) {
 
   ASSERT_TRUE(exec::unregisterExprSetListener(listener));
 }
+TEST_F(ExprStatsTest, selectiveCpuTrackingForUdfs) {
+  // Test selective CPU tracking for specific UDFs using
+  // kExprTrackCpuUsageUdfs config.
+  vector_size_t inputSize = 10;
+
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>(inputSize, [](auto row) { return row; }),
+      makeFlatVector<int32_t>(inputSize, [](auto row) { return row % 7; }),
+  });
+
+  auto rowType = asRowType(data->type());
+
+  // Helper to test selective CPU tracking with specified configuration.
+  auto testCpuTracking =
+      [&](bool enableGlobalTracking,
+          const std::string& funcList,
+          const std::vector<std::string>& expressions,
+          const std::unordered_set<std::string>& expectedFuncsWithNonZeroCpu) {
+        queryCtx_->testingOverrideConfigUnsafe({
+            {core::QueryConfig::kExprTrackCpuUsage,
+             enableGlobalTracking ? "true" : "false"},
+            {core::QueryConfig::kExprTrackCpuUsageForFunctions, funcList},
+        });
+
+        std::vector<Event> events;
+        auto listener = std::make_shared<TestListener>(events);
+        ASSERT_TRUE(exec::registerExprSetListener(listener));
+
+        {
+          auto exprSet = compileExpressions(expressions, rowType);
+          evaluate(*exprSet, data);
+        }
+
+        // Ensure listener is unregistered before accessing events.
+        ASSERT_TRUE(exec::unregisterExprSetListener(listener));
+
+        ASSERT_EQ(1, events.size());
+        auto stats = events.back().stats;
+
+        // Verify selective CPU tracking for the specified functions.
+        for (const auto& [funcName, funcStats] : stats) {
+          if (expectedFuncsWithNonZeroCpu.count(funcName)) {
+            ASSERT_GT(funcStats.timing.cpuNanos, 0) << funcName;
+          } else {
+            ASSERT_EQ(funcStats.timing.cpuNanos, 0) << funcName;
+          }
+        }
+      };
+
+  // Test with empty config - should work same as before.
+  testCpuTracking(false, "", {"c0 + c1", "c0 * c1"}, {});
+
+  // Test with single function name.
+  testCpuTracking(false, "plus", {"c0 + c1", "c0 * c1"}, {"plus"});
+
+  // Test with multiple function names.
+  testCpuTracking(
+      false, "plus,mod", {"c0 + c1", "c0 * c1", "c0 % 5"}, {"plus", "mod"});
+
+  // Test with mixed case function names (should be normalized to lowercase).
+  testCpuTracking(
+      false,
+      "PLUS,Multiply",
+      {"c0 + c1", "c0 * c1", "c0 % 5"},
+      {"plus", "multiply"});
+
+  // Test with extra commas and empty entries (should be handled gracefully).
+  testCpuTracking(
+      false, "plus,,multiply,", {"c0 + c1", "c0 * c1"}, {"plus", "multiply"});
+
+  // Test with larger expression trees.
+  testCpuTracking(
+      false,
+      "plus,pow",
+      {"(c0 + c1) * c1", "pow(c0 + c1, 2)"},
+      {"plus", "pow"});
+
+  // Test with global CPU tracking enabled.
+  testCpuTracking(
+      true,
+      "plus,pow",
+      {"(c0 + c1) * c1", "pow(c0 + c1, 2)"},
+      {"plus", "pow", "multiply", "cast"});
+}
+
+TEST_F(ExprStatsTest, adaptiveCpuSampling) {
+  // Test that adaptive CPU sampling calibrates per-function and produces
+  // timing data after calibration completes.
+  constexpr vector_size_t kInputSize{100};
+  // Need 1 warmup + 5 calibration + enough steady-state batches.
+  constexpr int kNumBatches{50};
+
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>(kInputSize, [](auto row) { return row; }),
+      makeFlatVector<int32_t>(kInputSize, [](auto row) { return row % 7; }),
+  });
+
+  auto rowType = asRowType(data->type());
+
+  // Enable adaptive CPU sampling with 5% max overhead threshold.
+  queryCtx_->testingOverrideConfigUnsafe({
+      {core::QueryConfig::kExprTrackCpuUsage, "false"},
+      {core::QueryConfig::kExprAdaptiveCpuSampling, "true"},
+      {core::QueryConfig::kExprAdaptiveCpuSamplingMaxOverheadPct, "5.0"},
+  });
+
+  auto exprSet = compileExpressions({"c0 + c1", "c0 * c1"}, rowType);
+  SelectivityVector rows(data->size());
+
+  for (int i = 0; i < kNumBatches; ++i) {
+    exec::EvalCtx evalCtx(&execCtx_, exprSet.get(), data.get());
+    std::vector<VectorPtr> results(exprSet->size());
+    exprSet->eval(rows, evalCtx, results);
+  }
+
+  auto stats = exprSet->stats();
+
+  // All batches should be counted in numProcessedVectors.
+  ASSERT_TRUE(stats.count("plus"));
+  ASSERT_EQ(stats["plus"].numProcessedVectors, kNumBatches);
+
+  // After calibration (1 warmup + 5 calibration), the function should have
+  // timing data from steady-state batches (either always-track or sampled).
+  // With 50 batches and 6 calibration, 44 steady-state batches remain.
+  // Even with sampling, stats adjustment extrapolates timing.count.
+  ASSERT_GT(stats["plus"].timing.count, 0u);
+
+  // If the function was classified as needing sampling (likely for cheap
+  // builtins), timing.count should be less than numProcessedVectors.
+  // If classified as always-track, timing.count == numProcessedVectors.
+  // Either way, stats should have been adjusted, so cpuNanos > 0.
+  ASSERT_GT(stats["plus"].timing.cpuNanos, 0u);
+}
+
+TEST_F(ExprStatsTest, adaptiveCpuSamplingDisabledByDefault) {
+  constexpr vector_size_t kInputSize{100};
+  constexpr int kNumBatches{10};
+
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>(kInputSize, [](auto row) { return row; }),
+      makeFlatVector<int32_t>(kInputSize, [](auto row) { return row % 7; }),
+  });
+
+  auto rowType = asRowType(data->type());
+
+  // Disable everything — no tracking, no sampling, no adaptive.
+  queryCtx_->testingOverrideConfigUnsafe({
+      {core::QueryConfig::kExprTrackCpuUsage, "false"},
+  });
+
+  auto exprSet = compileExpressions({"c0 + c1"}, rowType);
+  SelectivityVector rows(data->size());
+
+  for (int i = 0; i < kNumBatches; ++i) {
+    exec::EvalCtx evalCtx(&execCtx_, exprSet.get(), data.get());
+    std::vector<VectorPtr> results(exprSet->size());
+    exprSet->eval(rows, evalCtx, results);
+  }
+
+  auto stats = exprSet->stats();
+
+  // All batches processed but no CPU timing recorded (adaptive is off).
+  ASSERT_TRUE(stats.count("plus"));
+  ASSERT_EQ(stats["plus"].numProcessedVectors, kNumBatches);
+  ASSERT_EQ(stats["plus"].timing.count, 0u);
+  ASSERT_EQ(stats["plus"].timing.cpuNanos, 0u);
+}
+
+TEST_F(ExprStatsTest, adaptiveCpuSamplingStatsAdjustment) {
+  // Test that stats are properly adjusted (extrapolated) for functions
+  // in sampling mode.
+  constexpr vector_size_t kInputSize{100};
+  // Need enough batches: 6 calibration + enough steady-state for sampling.
+  constexpr int kNumBatches{50};
+
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>(kInputSize, [](auto row) { return row; }),
+      makeFlatVector<int32_t>(kInputSize, [](auto row) { return row % 7; }),
+  });
+
+  auto rowType = asRowType(data->type());
+
+  // Use 5% overhead threshold. Built-in plus (~13% overhead in ASAN) will be
+  // classified as needing sampling, and stats should be extrapolated.
+  queryCtx_->testingOverrideConfigUnsafe({
+      {core::QueryConfig::kExprTrackCpuUsage, "false"},
+      {core::QueryConfig::kExprAdaptiveCpuSampling, "true"},
+      {core::QueryConfig::kExprAdaptiveCpuSamplingMaxOverheadPct, "5.0"},
+  });
+
+  std::vector<Event> events;
+  auto listener = std::make_shared<TestListener>(events);
+  ASSERT_TRUE(exec::registerExprSetListener(listener));
+
+  {
+    auto exprSet = compileExpressions({"c0 + c1"}, rowType);
+    SelectivityVector rows(data->size());
+
+    for (int i = 0; i < kNumBatches; ++i) {
+      exec::EvalCtx evalCtx(&execCtx_, exprSet.get(), data.get());
+      std::vector<VectorPtr> results(exprSet->size());
+      exprSet->eval(rows, evalCtx, results);
+    }
+
+    auto stats = exprSet->stats();
+    ASSERT_TRUE(stats.count("plus"));
+
+    // If function is being sampled, the adjusted stats should have
+    // timing.count == numProcessedVectors (extrapolated to full count).
+    if (stats["plus"].timing.count == stats["plus"].numProcessedVectors) {
+      // Stats were adjusted. cpuNanos should be extrapolated.
+      ASSERT_GT(stats["plus"].timing.cpuNanos, 0u);
+    }
+  }
+
+  // Listener should also receive adjusted stats.
+  ASSERT_EQ(1, events.size());
+  auto listenerStats = events.back().stats;
+  ASSERT_TRUE(listenerStats.count("plus"));
+  ASSERT_GT(listenerStats["plus"].timing.cpuNanos, 0u);
+
+  ASSERT_TRUE(exec::unregisterExprSetListener(listener));
+}
+
+TEST_F(ExprStatsTest, adaptiveCpuSamplingPerFunctionRates) {
+  // Test that adaptive sampling assigns different rates to cheap vs expensive
+  // functions. A cheap built-in (plus) should get sampling while an expensive
+  // UDF (slow_add) should always track.
+  //
+  // Use a small batch so that clock_gettime overhead is significant relative
+  // to the cheap function (plus) but negligible relative to the expensive one
+  // (slow_add with 50k volatile iterations per row).
+  constexpr vector_size_t kInputSize{10};
+  constexpr int kNumBatches{2'000};
+
+  registerFunction<SlowAddFunction, int32_t, int32_t, int32_t>({"slow_add"});
+
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>(kInputSize, [](auto row) { return row; }),
+      makeFlatVector<int32_t>(kInputSize, [](auto row) { return row % 7; }),
+  });
+
+  auto rowType = asRowType(data->type());
+
+  // Enable adaptive CPU sampling with 5% max overhead. For cheap functions
+  // like plus on 10 rows, clock_gettime overhead is very significant (>>5%).
+  // For slow_add (50k iterations/row), the overhead is negligible (<<5%).
+  queryCtx_->testingOverrideConfigUnsafe({
+      {core::QueryConfig::kExprTrackCpuUsage, "false"},
+      {core::QueryConfig::kExprAdaptiveCpuSampling, "true"},
+      {core::QueryConfig::kExprAdaptiveCpuSamplingMaxOverheadPct, "5.0"},
+  });
+
+  auto exprSet = compileExpressions({"c0 + c1", "slow_add(c0, c1)"}, rowType);
+  SelectivityVector rows(data->size());
+
+  for (int i = 0; i < kNumBatches; ++i) {
+    exec::EvalCtx evalCtx(&execCtx_, exprSet.get(), data.get());
+    std::vector<VectorPtr> results(exprSet->size());
+    exprSet->eval(rows, evalCtx, results);
+  }
+
+  // Traverse the expression tree to find the plus and slow_add Expr nodes.
+  const exec::Expr* plusExpr = nullptr;
+  const exec::Expr* slowAddExpr = nullptr;
+
+  std::function<void(const exec::Expr*)> findExprs =
+      [&](const exec::Expr* expr) {
+        if (expr->name() == "plus") {
+          plusExpr = expr;
+        } else if (expr->name() == "slow_add") {
+          slowAddExpr = expr;
+        }
+        for (const auto& input : expr->inputs()) {
+          findExprs(input.get());
+        }
+      };
+
+  for (const auto& expr : exprSet->exprs()) {
+    findExprs(expr.get());
+  }
+
+  ASSERT_NE(plusExpr, nullptr) << "Failed to find 'plus' expression";
+  ASSERT_NE(slowAddExpr, nullptr) << "Failed to find 'slow_add' expression";
+
+  /// The expensive function (slow_add) should have a lower or equal sampling
+  /// rate compared to the cheap function (plus).
+  ASSERT_LE(
+      slowAddExpr->adaptiveSamplingRate(), plusExpr->adaptiveSamplingRate())
+      << "Expected expensive function to have lower or equal sampling rate "
+      << "than cheap function. slow_add rate: "
+      << slowAddExpr->adaptiveSamplingRate()
+      << ", plus rate: " << plusExpr->adaptiveSamplingRate();
+
+  // Both functions should have timing data.
+  auto stats = exprSet->stats();
+  ASSERT_GT(stats["plus"].timing.cpuNanos, 0u);
+  ASSERT_GT(stats["slow_add"].timing.cpuNanos, 0u);
+
+  LOG(INFO) << "plus sampling rate: " << plusExpr->adaptiveSamplingRate()
+            << ", slow_add sampling rate: "
+            << slowAddExpr->adaptiveSamplingRate();
+}
diff --git a/velox/expression/tests/ExprTest.cpp b/velox/expression/tests/ExprTest.cpp
index 53c2df82791..22aea08d5b5 100644
--- a/velox/expression/tests/ExprTest.cpp
+++ b/velox/expression/tests/ExprTest.cpp
@@ -23,9 +23,9 @@
 #include "gtest/gtest.h"
 
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/core/Expressions.h"
 #include "velox/exec/tests/utils/QueryAssertions.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/expression/CoalesceExpr.h"
 #include "velox/expression/ConjunctExpr.h"
 #include "velox/expression/ConstantExpr.h"
@@ -36,8 +36,8 @@
 #include "velox/functions/prestosql/types/JsonType.h"
 #include "velox/parse/ExpressionsParser.h"
 #include "velox/parse/TypeResolver.h"
+#include "velox/vector/BaseVector.h"
 #include "velox/vector/SelectivityVector.h"
-#include "velox/vector/VariantToVector.h"
 #include "velox/vector/VectorSaver.h"
 #include "velox/vector/tests/TestingAlwaysThrowsFunction.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
@@ -45,6 +45,8 @@
 DECLARE_string(velox_save_input_on_expression_any_failure_path);
 DECLARE_string(velox_save_input_on_expression_system_failure_path);
 
+using namespace facebook::velox::common::testutil;
+
 namespace facebook::velox::test {
 namespace {
 class ExprTest : public testing::Test, public VectorTestBase {
@@ -69,7 +71,7 @@ class ExprTest : public testing::Test, public VectorTestBase {
       const std::string& text,
       const RowTypePtr& rowType,
       const VectorPtr& complexConstants = nullptr) {
-    auto untyped = parse::parseExpr(text, options_);
+    auto untyped = parse::DuckSqlExpressionsParser(options_).parseExpr(text);
     return core::Expressions::inferTypes(
         untyped, rowType, execCtx_->pool(), complexConstants);
   }
@@ -78,7 +80,7 @@ class ExprTest : public testing::Test, public VectorTestBase {
       const std::string& text,
       const RowTypePtr& rowType,
       const std::vector<TypePtr>& lambdaInputTypes) {
-    auto untyped = parse::parseExpr(text, options_);
+    auto untyped = parse::DuckSqlExpressionsParser(options_).parseExpr(text);
     return core::Expressions::inferTypes(
         untyped, rowType, lambdaInputTypes, execCtx_->pool(), nullptr);
   }
@@ -86,13 +88,15 @@ class ExprTest : public testing::Test, public VectorTestBase {
   std::vector<core::TypedExprPtr> parseMultipleExpression(
       const std::string& text,
       const RowTypePtr& rowType) {
-    auto untyped = parse::parseMultipleExpressions(text, options_);
-    std::vector<core::TypedExprPtr> parsed;
-    for (auto& iExpr : untyped) {
-      parsed.push_back(
-          core::Expressions::inferTypes(iExpr, rowType, execCtx_->pool()));
+    auto untypedExprs =
+        parse::DuckSqlExpressionsParser(options_).parseExprs(text);
+    std::vector<core::TypedExprPtr> typedExprs;
+    typedExprs.reserve(untypedExprs.size());
+    for (const auto& expr : untypedExprs) {
+      typedExprs.push_back(
+          core::Expressions::inferTypes(expr, rowType, execCtx_->pool()));
     }
-    return parsed;
+    return typedExprs;
   }
 
   // T can be ExprSet or ExprSetSimplified.
@@ -237,8 +241,7 @@ class ExprTest : public testing::Test, public VectorTestBase {
       const RowVectorPtr& input,
       VectorPtr& result,
       const VectorPtr& expected) {
-    parse::ParseOptions options;
-    auto untyped = parse::parseExpr(expr, options);
+    auto untyped = parse::DuckSqlExpressionsParser().parseExpr(expr);
     auto typedExpr = core::Expressions::inferTypes(
         untyped, asRowType(input->type()), pool());
 
@@ -423,13 +426,27 @@ class ExprTest : public testing::Test, public VectorTestBase {
   parse::ParseOptions options_;
 };
 
-class ParameterizedExprTest : public ExprTest,
-                              public testing::WithParamInterface<bool> {
+struct ExprTestParams {
+  bool cacheEnabled;
+  int32_t minRowsForPeeling;
+
+  friend std::ostream& operator<<(std::ostream& os, const ExprTestParams& p) {
+    return os << "cacheEnabled=" << p.cacheEnabled
+              << ", minRowsForPeeling=" << p.minRowsForPeeling;
+  }
+};
+
+class ParameterizedExprTest
+    : public ExprTest,
+      public testing::WithParamInterface<ExprTestParams> {
  public:
   ParameterizedExprTest() {
+    const auto& params = GetParam();
     std::unordered_map<std::string, std::string> configData(
         {{core::QueryConfig::kEnableExpressionEvaluationCache,
-          GetParam() ? "true" : "false"}});
+          params.cacheEnabled ? "true" : "false"},
+         {core::QueryConfig::kMinRowsForPeeling,
+          std::to_string(params.minRowsForPeeling)}});
     queryCtx_ = velox::core::QueryCtx::create(
         nullptr, core::QueryConfig(std::move(configData)));
     execCtx_ = std::make_unique<core::ExecCtx>(pool_.get(), queryCtx_.get());
@@ -455,7 +472,13 @@ TEST_P(ParameterizedExprTest, moreEncodings) {
 
   auto result =
       evaluate("if(c1 = 'grapes', c0 + 10, c0)", makeRowVector({a, b}));
-  ASSERT_EQ(VectorEncoding::Simple::DICTIONARY, result->encoding());
+  // When peeling is active, the result is wrapped back in the original
+  // dictionary encoding. When peeling is suppressed (minRowsForPeeling >
+  // number of rows), the result is flat.
+  auto expectedOutputEncoding = GetParam().minRowsForPeeling <= size / 2
+      ? VectorEncoding::Simple::DICTIONARY
+      : VectorEncoding::Simple::FLAT;
+  ASSERT_EQ(expectedOutputEncoding, result->encoding());
   ASSERT_EQ(size / 2, result->size());
 
   auto expected = makeFlatVector<int64_t>(size / 2, [&fruits](auto row) {
@@ -1773,6 +1796,36 @@ TEST_P(ParameterizedExprTest, switchExprWithNull) {
   assertEqualVectors(expected, result);
 }
 
+// Verify that computePropagatesNulls iterates over all then-clauses when
+// checking null propagation. Uses a 3-WHEN CASE where the 3rd then-clause
+// (coalesce) does not propagate nulls. Null rows matching that clause must
+// return the coalesce result (0), not NULL.
+TEST_P(ParameterizedExprTest, switchPropagatesNullsAllThenClauses) {
+  auto c0 = makeNullableFlatVector<int64_t>({1, 2, std::nullopt, std::nullopt});
+  auto input = makeRowVector({c0});
+
+  // The 3rd then-clause uses coalesce, which does not propagate nulls. When
+  // c0 is null, cond1 and cond2 are false, cond3 (IS NULL) is true, and the
+  // result should be coalesce(null, 0) = 0.
+  auto result = evaluate(
+      "case when c0 = 1 then c0 + 10 "
+      "when c0 = 2 then c0 + 20 "
+      "when c0 is null then coalesce(c0, cast(0 as bigint)) end",
+      input);
+
+  auto expected = makeNullableFlatVector<int64_t>({11, 22, 0, 0});
+  assertEqualVectors(expected, result);
+
+  // Verify propagatesNulls is false since the 3rd then-clause (coalesce) does
+  // not propagate nulls.
+  auto typedExpr = parseExpression(
+      "case when c0 = 1 then c0 + 10 "
+      "when c0 = 2 then c0 + 20 "
+      "when c0 is null then coalesce(c0, cast(0 as bigint)) end",
+      ROW({"c0"}, {BIGINT()}));
+  EXPECT_FALSE(propagatesNulls(typedExpr));
+}
+
 TEST_P(ParameterizedExprTest, ifWithConstant) {
   vector_size_t size = 4;
 
@@ -1929,8 +1982,43 @@ class TestingSingleArgDeterministicFunction : public exec::VectorFunction {
   }
 };
 
+// Single-argument deterministic function that takes an array and asserts it
+// receives a flat-encoded (ARRAY) or constant-encoded input. Used to verify
+// that constant peeling continues to work when peeling is disabled.
+class TestingSingleArgArrayFunction : public exec::VectorFunction {
+ public:
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& outputType,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    auto& arg = args[0];
+    VELOX_CHECK(
+        arg->encoding() == VectorEncoding::Simple::ARRAY ||
+            arg->encoding() == VectorEncoding::Simple::CONSTANT,
+        "Expected ARRAY or CONSTANT encoding, got {}",
+        arg->encoding());
+    BaseVector::ensureWritable(rows, outputType, context.pool(), result);
+    result->copy(arg.get(), rows, nullptr);
+  }
+
+  static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
+    return {exec::FunctionSignatureBuilder()
+                .typeVariable("T")
+                .returnType("array(T)")
+                .argumentType("array(T)")
+                .build()};
+  }
+};
+
 } // namespace
 
+VELOX_DECLARE_VECTOR_FUNCTION(
+    udf_testing_single_arg_array,
+    TestingSingleArgArrayFunction::signatures(),
+    std::make_unique<TestingSingleArgArrayFunction>());
+
 VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_testing_constant,
     TestingConstantFunction::signatures(),
@@ -2403,6 +2491,40 @@ struct ThrowRuntimeError {
     VELOX_FAIL();
   }
 };
+
+// Simple function with custom owner that always throws.
+template <typename T>
+struct AlwaysThrowsWithCustomOwner {
+  static constexpr std::string_view owner = "custom-owner-team";
+
+  template <typename TResult, typename TInput>
+  FOLLY_ALWAYS_INLINE void call(TResult&, const TInput&) {
+    VELOX_USER_FAIL("Expected error from custom owner function");
+  }
+};
+
+// Vector function with custom owner that always throws.
+class AlwaysThrowsVectorFunctionWithCustomOwner : public exec::VectorFunction {
+ public:
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& /* args */,
+      const TypePtr& /* outputType */,
+      exec::EvalCtx& context,
+      VectorPtr& /* result */) const override {
+    auto error = std::make_exception_ptr(
+        std::invalid_argument(
+            "Expected error from custom owner vector function"));
+    context.setErrors(rows, error);
+  }
+
+  static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
+    return {exec::FunctionSignatureBuilder()
+                .returnType("integer")
+                .argumentType("integer")
+                .build()};
+  }
+};
 } // namespace
 
 TEST_P(ParameterizedExprTest, exceptionContext) {
@@ -2449,7 +2571,7 @@ TEST_P(ParameterizedExprTest, exceptionContext) {
   }
 
   // Enable saving vector and expression SQL for system errors only.
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  auto tempDirectory = TempDirectoryPath::create();
   FLAGS_velox_save_input_on_expression_system_failure_path =
       tempDirectory->getPath();
 
@@ -2535,6 +2657,50 @@ TEST_P(ParameterizedExprTest, exceptionContext) {
   }
 }
 
+// Test that custom owner is included in exception context.
+TEST_P(ParameterizedExprTest, exceptionContextWithCustomOwner) {
+  auto data = makeFlatVector<int32_t>({1, 2, 3});
+
+  // Register test simple function.
+  registerFunction<AlwaysThrowsWithCustomOwner, int32_t, int32_t>(
+      {"always_throws_custom_owner"});
+
+  assertError(
+      "always_throws_custom_owner(c0)",
+      data,
+      "Owner: custom-owner-team. Top-level Expression: always_throws_custom_owner(c0)",
+      "",
+      "Expected error from custom owner function");
+
+  assertError(
+      "always_throws_custom_owner(c0) + 1",
+      data,
+      "Owner: custom-owner-team. Expression: always_throws_custom_owner(c0)",
+      "Top-level Expression: plus(cast((always_throws_custom_owner(c0)) as BIGINT), 1:BIGINT)",
+      "Expected error from custom owner function");
+
+  // Register and test vector function.
+  exec::registerVectorFunction(
+      "always_throws_vector_custom_owner",
+      AlwaysThrowsVectorFunctionWithCustomOwner::signatures(),
+      std::make_unique<AlwaysThrowsVectorFunctionWithCustomOwner>(),
+      exec::VectorFunctionMetadataBuilder().owner("vector-owner-team").build());
+
+  assertError(
+      "always_throws_vector_custom_owner(c0)",
+      data,
+      "Owner: vector-owner-team. Top-level Expression: always_throws_vector_custom_owner(c0)",
+      "",
+      "Expected error from custom owner vector function");
+
+  assertError(
+      "always_throws_vector_custom_owner(c0) + 1",
+      data,
+      "Owner: vector-owner-team. Expression: always_throws_vector_custom_owner(c0)",
+      "Top-level Expression: plus(cast((always_throws_vector_custom_owner(c0)) as BIGINT), 1:BIGINT)",
+      "Expected error from custom owner vector function");
+}
+
 namespace {
 
 template <typename T>
@@ -2595,8 +2761,8 @@ TEST_P(ParameterizedExprTest, constantToString) {
 
 TEST_F(ExprTest, constantEqualsNullConsistency) {
   // Constant expr created using variant
-  auto nullVariantToExpr =
-      std::make_shared<core::ConstantTypedExpr>(VARCHAR(), Variant{});
+  auto nullVariantToExpr = std::make_shared<core::ConstantTypedExpr>(
+      VARCHAR(), variant::null(TypeKind::VARCHAR));
   auto nonNullVariantToExpr =
       std::make_shared<core::ConstantTypedExpr>(VARCHAR(), Variant{"test"});
 
@@ -2617,13 +2783,14 @@ TEST_F(ExprTest, constantEqualsNullConsistency) {
 // of a Vector.
 TEST_F(ExprTest, constantToStringEqualsHashConsistency) {
   auto testValue = [&](const TypePtr& type, const Variant& value) {
-    SCOPED_TRACE(fmt::format(
-        "Type: {}, Value: {}", type->toString(), value.toJson(type)));
+    SCOPED_TRACE(
+        fmt::format(
+            "Type: {}, Value: {}", type->toString(), value.toJson(type)));
 
     auto a = std::make_shared<core::ConstantTypedExpr>(type, value);
 
     auto b = std::make_shared<core::ConstantTypedExpr>(
-        variantToVector(type, value, pool()));
+        BaseVector::createConstant(type, value, 1, pool()));
 
     EXPECT_EQ(a->toString(), b->toString());
 
@@ -2818,9 +2985,10 @@ TEST_P(ParameterizedExprTest, constantToSql) {
   ASSERT_EQ(toSql(variant::null(TypeKind::ARRAY)), "NULL");
 
   ASSERT_EQ(
-      toSqlComplex(makeMapVector<int32_t, int32_t>({
-          {{1, 10}, {2, 20}, {3, 30}},
-      })),
+      toSqlComplex(
+          makeMapVector<int32_t, int32_t>({
+              {{1, 10}, {2, 20}, {3, 30}},
+          })),
       "map(ARRAY['1'::INTEGER, '2'::INTEGER, '3'::INTEGER], ARRAY['10'::INTEGER, '20'::INTEGER, '30'::INTEGER])");
   ASSERT_EQ(
       toSqlComplex(
@@ -2831,8 +2999,9 @@ TEST_P(ParameterizedExprTest, constantToSql) {
           1),
       "map(ARRAY['1'::INTEGER, '2'::INTEGER, '3'::INTEGER], ARRAY['10'::INTEGER, '20'::INTEGER, '30'::INTEGER])");
   ASSERT_EQ(
-      toSqlComplex(BaseVector::createNullConstant(
-          MAP(INTEGER(), VARCHAR()), 10, pool())),
+      toSqlComplex(
+          BaseVector::createNullConstant(
+              MAP(INTEGER(), VARCHAR()), 10, pool())),
       "NULL::MAP(INTEGER, VARCHAR)");
 
   ASSERT_EQ(
@@ -2842,14 +3011,17 @@ TEST_P(ParameterizedExprTest, constantToSql) {
       })),
       "row_constructor('1'::INTEGER, TRUE)");
   ASSERT_EQ(
-      toSqlComplex(BaseVector::createNullConstant(
-          ROW({"a", "b"}, {BOOLEAN(), DOUBLE()}), 10, pool())),
+      toSqlComplex(
+          BaseVector::createNullConstant(
+              ROW({"a", "b"}, {BOOLEAN(), DOUBLE()}), 10, pool())),
       "NULL::STRUCT(a BOOLEAN, b DOUBLE)");
   ASSERT_EQ(
-      toSqlComplex(BaseVector::createNullConstant(
-          ROW({"a", "b"}, {BOOLEAN(), ROW({"c", "d"}, {DOUBLE(), VARCHAR()})}),
-          10,
-          pool())),
+      toSqlComplex(
+          BaseVector::createNullConstant(
+              ROW({"a", "b"},
+                  {BOOLEAN(), ROW({"c", "d"}, {DOUBLE(), VARCHAR()})}),
+              10,
+              pool())),
       "NULL::STRUCT(a BOOLEAN, b STRUCT(c DOUBLE, d VARCHAR))");
 }
 
@@ -3256,6 +3428,30 @@ TEST_P(ParameterizedExprTest, flatNoNullsFastPath) {
   ASSERT_FALSE(exprSet->exprs()[0]->supportsFlatNoNullsFastPath());
 }
 
+TEST_P(ParameterizedExprTest, flatNoNullsFastPathDisabledByConfig) {
+  auto data = makeRowVector(
+      {"a", "b"},
+      {
+          makeFlatVector<int32_t>({1, 2, 3}),
+          makeFlatVector<int32_t>({10, 20, 30}),
+      });
+
+  // Evaluate with fast path enabled (default).
+  auto result = evaluate("a + b", data);
+  auto expected = makeFlatVector<int32_t>({11, 22, 33});
+  assertEqualVectors(expected, result);
+
+  // Evaluate with fast path disabled via config.
+  std::unordered_map<std::string, std::string> configData(
+      {{core::QueryConfig::kExprEvalFlatNoNulls, "false"}});
+  auto queryCtx = velox::core::QueryCtx::create(
+      nullptr, core::QueryConfig(std::move(configData)));
+  auto execCtx = std::make_unique<core::ExecCtx>(pool_.get(), queryCtx.get());
+
+  result = evaluateMultiple({"a + b"}, data, std::nullopt, execCtx.get())[0];
+  assertEqualVectors(expected, result);
+}
+
 TEST_P(ParameterizedExprTest, commonSubExpressionWithEncodedInput) {
   // This test case does a sanity check of the code path that re-uses
   // precomputed results for common sub-expressions.
@@ -3651,10 +3847,10 @@ TEST_P(ParameterizedExprTest, applyFunctionNoResult) {
   // not.  Conjuncts have the nice property that they set throwOnError to
   // false and don't check if the result VectorPtr is nullptr.
   assertError(
-      "always_throws_vector_function(c0) AND true",
+      "always_throws_vector_function(c0) AND (c0 = 1)",
       makeFlatVector<int32_t>({1, 2, 3}),
       "always_throws_vector_function(c0)",
-      "Top-level Expression: and(always_throws_vector_function(c0), true:BOOLEAN)",
+      "Top-level Expression: and(always_throws_vector_function(c0), eq(cast((c0) as BIGINT), 1:BIGINT))",
       TestingAlwaysThrowsVectorFunction::kVeloxErrorMessage);
 
   exec::registerVectorFunction(
@@ -3663,10 +3859,10 @@ TEST_P(ParameterizedExprTest, applyFunctionNoResult) {
       std::make_unique<NoOpVectorFunction>());
 
   assertError(
-      "no_op(c0) AND true",
+      "no_op(c0) AND (c0 = 2)",
       makeFlatVector<int32_t>({1, 2, 3}),
       "no_op(c0)",
-      "Top-level Expression: and(no_op(c0), true:BOOLEAN)",
+      "Top-level Expression: and(no_op(c0), eq(cast((c0) as BIGINT), 2:BIGINT))",
       "Function neither returned results nor threw exception.");
 }
 
@@ -3903,7 +4099,7 @@ TEST_P(ParameterizedExprTest, cseUnderTryWithIf) {
   // errors when combined with TRY. In this case a VectorFunction sizes the
   // result based on rows.end(), can throw user exceptions, and doesn't resize
   // the result Vector to include rows that produced exceptions. If that
-  // funciton is evaluated as part of CSE, e.g. on both sides of an if
+  // function is evaluated as part of CSE, e.g. on both sides of an if
   // statement, and the last row produces an exception, the result Vector will
   // be smaller than rows.size(). This test validates that in CSE we can
   // tolerate this and does not rely on the fact the result Vector is at least
@@ -4421,8 +4617,9 @@ TEST_F(ExprTest, commonSubExpressionWithPeeling) {
       // is evaluated twice.
       auto queryCtx = velox::core::QueryCtx::create(
           nullptr,
-          core::QueryConfig(std::unordered_map<std::string, std::string>{
-              {core::QueryConfig::kMaxSharedSubexprResultsCached, "1"}}));
+          core::QueryConfig(
+              std::unordered_map<std::string, std::string>{
+                  {core::QueryConfig::kMaxSharedSubexprResultsCached, "1"}}));
       core::ExecCtx execCtx(pool_.get(), queryCtx.get());
       auto results = makeRowVector(evaluateMultiple(
           {expr1, expr2, expr1, expr2}, data, std::nullopt, &execCtx));
@@ -4908,7 +5105,12 @@ TEST_P(ParameterizedExprTest, evaluatesArgumentsOnNonIncreasingSelection) {
 VELOX_INSTANTIATE_TEST_SUITE_P(
     ExprTest,
     ParameterizedExprTest,
-    testing::ValuesIn({false, true}));
+    testing::ValuesIn(
+        std::vector<ExprTestParams>{
+            {false, 0},
+            {false, 2000},
+            {true, 0},
+            {true, 2000}}));
 
 TEST_F(ExprTest, disablePeeling) {
   // Verify that peeling is disabled when the config is set by checking whether
@@ -4979,6 +5181,18 @@ TEST_F(ExprTest, disablePeeling) {
       makeRowVector({flatInput}),
       {},
       execCtx.get()));
+
+  // Ensure functions that receive a single constant-encoded complex input
+  // continue to peel even when peeling is disabled.
+  VELOX_REGISTER_VECTOR_FUNCTION(
+      udf_testing_single_arg_array, "testing_single_arg_array");
+  auto constantArray = BaseVector::wrapInConstant(
+      dictSize, 0, makeArrayVector<int64_t>({{1, 2, 3}}));
+  ASSERT_NO_THROW(evaluateMultiple(
+      {"testing_single_arg_array(c0)"},
+      makeRowVector({constantArray}),
+      {},
+      execCtx.get()));
 }
 
 TEST_F(ExprTest, disableSharedSubExpressionReuse) {
@@ -5107,9 +5321,8 @@ TEST_F(ExprTest, evaluateConstantExpression) {
       makeArrayVectorFromJson<int64_t>({"[2, 2, 2]"}));
 
   assertEqualVectors(
-      eval(
-          "try(coalesce(array_min_by(array[1, 2, 3], x -> x / 0), 0::INTEGER))"),
-      makeNullConstant(TypeKind::INTEGER, 1));
+      eval("try(coalesce(array_min_by(array[1, 2, 3], x -> x / 0), 0))"),
+      makeNullConstant(TypeKind::BIGINT, 1));
 
   // Verify that constant folding takes into account query config.
   setQueryTimeZone("America/Los_Angeles");
@@ -5128,7 +5341,9 @@ TEST_F(ExprTest, evaluateConstantExpression) {
 
   EXPECT_TRUE(eval("transform(array[1, 2, 3], x -> (x * 2) + a)") == nullptr);
 
-  EXPECT_TRUE(eval("transform(array[1, 2, 3], x -> x + rand())") == nullptr);
+  EXPECT_TRUE(
+      eval("transform(array[1, 2, 3], x -> cast(x as double) + rand())") ==
+      nullptr);
 
   VELOX_ASSERT_THROW(eval("5 / 0"), "division by zero");
   EXPECT_TRUE(evalNoThrow("5 / 0") == nullptr);
@@ -5176,17 +5391,11 @@ TEST_F(ExprTest, peelingOnDeterministicFunctionInNonDeterministicExpr) {
 }
 
 TEST_F(ExprTest, lambdaConstantFolded) {
-  const auto makeTypedExpr =
-      [this](const std::string& text, const RowTypePtr& rowType) {
-        auto untyped = parse::parseExpr(text, {});
-        return core::Expressions::inferTypes(untyped, rowType, pool());
-      };
-
   // Test the resource clear of lambda constant folding which relies on an
   // uninitialized ExprSet for eval.
   std::string expression =
       "reduce(regexp_split('a,b,c,d,e,f,g,h',','), array[array['']], (acc, x) -> array[array[x]], (id) -> id)";
-  auto typedExpr = makeTypedExpr(expression, ROW({"c0"}, {INTEGER()}));
+  auto typedExpr = parseExpression(expression, ROW({"c0"}, {INTEGER()}));
   exec::ExprSet exprSet({typedExpr}, execCtx_.get());
   exprSet.clear();
 }
diff --git a/velox/expression/tests/ExprToSubfieldFilterTest.cpp b/velox/expression/tests/ExprToSubfieldFilterTest.cpp
index bad3d53b303..e68223b5d7f 100644
--- a/velox/expression/tests/ExprToSubfieldFilterTest.cpp
+++ b/velox/expression/tests/ExprToSubfieldFilterTest.cpp
@@ -16,19 +16,20 @@
 
 #include "velox/expression/ExprToSubfieldFilter.h"
 #include <gtest/gtest.h>
-#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/expression/Expr.h"
-#include "velox/functions/lib/IsNull.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
-#include "velox/parse/Expressions.h"
 #include "velox/parse/ExpressionsParser.h"
 #include "velox/parse/TypeResolver.h"
 
+using facebook::velox::common::Subfield;
+
+#define VELOX_ASSERT_FILTER(expected, actual)   \
+  ASSERT_TRUE(expected->testingEquals(*actual)) \
+      << expected->toString() << " vs " << actual->toString();
+
 namespace facebook::velox::exec {
 namespace {
 
-using namespace facebook::velox::common;
-
 void validateSubfield(
     const Subfield& subfield,
     const std::vector<std::string>& expectedPath) {
@@ -51,7 +52,7 @@ class ExprToSubfieldFilterTest : public testing::Test {
       const std::string& expr,
       const RowTypePtr& type) {
     return core::Expressions::inferTypes(
-        parse::parseExpr(expr, {}), type, pool_.get());
+        parse::DuckSqlExpressionsParser().parseExpr(expr), type, pool_.get());
   }
 
   core::CallTypedExprPtr parseCallExpr(
@@ -67,6 +68,19 @@ class ExprToSubfieldFilterTest : public testing::Test {
     return &evaluator_;
   }
 
+  std::pair<common::Subfield, std::unique_ptr<common::Filter>>
+  leafCallToSubfieldFilter(
+      const core::CallTypedExprPtr& call,
+      bool negated = false) {
+    if (auto result =
+            ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
+                *call, evaluator(), negated)) {
+      return std::move(result.value());
+    }
+
+    return std::make_pair(common::Subfield(), nullptr);
+  }
+
  private:
   std::shared_ptr<memory::MemoryPool> pool_ =
       memory::memoryManager()->addLeafPool();
@@ -75,189 +89,193 @@ class ExprToSubfieldFilterTest : public testing::Test {
 };
 
 TEST_F(ExprToSubfieldFilterTest, eq) {
-  auto call = parseCallExpr("a = 42", ROW({{"a", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a = 42", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a"});
-  auto bigintRange = dynamic_cast<BigintRange*>(filter.get());
-  ASSERT_TRUE(bigintRange);
-  ASSERT_EQ(bigintRange->lower(), 42);
-  ASSERT_EQ(bigintRange->upper(), 42);
-  ASSERT_FALSE(bigintRange->testNull());
+
+  VELOX_ASSERT_FILTER(equal(42), filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, eqExpr) {
-  auto call = parseCallExpr("a = 21 * 2", ROW({{"a", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a = 21 * 2", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a"});
-  auto bigintRange = dynamic_cast<BigintRange*>(filter.get());
-  ASSERT_TRUE(bigintRange);
-  ASSERT_EQ(bigintRange->lower(), 42);
-  ASSERT_EQ(bigintRange->upper(), 42);
-  ASSERT_FALSE(bigintRange->testNull());
+
+  VELOX_ASSERT_FILTER(equal(42), filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, eqSubfield) {
-  auto call = parseCallExpr("a.b = 42", ROW({{"a", ROW({{"b", BIGINT()}})}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a.b = 42", ROW("a", ROW("b", BIGINT())));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a", "b"});
-  auto bigintRange = dynamic_cast<BigintRange*>(filter.get());
-  ASSERT_TRUE(bigintRange);
-  ASSERT_EQ(bigintRange->lower(), 42);
-  ASSERT_EQ(bigintRange->upper(), 42);
-  ASSERT_FALSE(bigintRange->testNull());
+
+  VELOX_ASSERT_FILTER(equal(42), filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, neq) {
-  auto call = parseCallExpr("a <> 42", ROW({{"a", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a <> 42", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a"});
-  ASSERT_TRUE(filter->testInt64(41));
-  ASSERT_FALSE(filter->testInt64(42));
-  ASSERT_TRUE(filter->testInt64(43));
+
+  // TODO Optimize to notEqual(42).
+  VELOX_ASSERT_FILTER(bigintOr(lessThan(42), greaterThan(42)), filter);
+}
+
+TEST_F(ExprToSubfieldFilterTest, neqBoundary) {
+  {
+    auto call = parseCallExpr("a <> 9223372036854775807", ROW("a", BIGINT()));
+    auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+    ASSERT_TRUE(filter);
+    validateSubfield(subfield, {"a"});
+
+    VELOX_ASSERT_FILTER(lessThan(std::numeric_limits<int64_t>::max()), filter);
+  }
+
+  {
+    auto call =
+        parseCallExpr("a <> -9223372036854775807 - 1", ROW("a", BIGINT()));
+    auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+    ASSERT_TRUE(filter);
+    validateSubfield(subfield, {"a"});
+
+    VELOX_ASSERT_FILTER(
+        greaterThan(std::numeric_limits<int64_t>::min()), filter);
+  }
 }
 
 TEST_F(ExprToSubfieldFilterTest, lte) {
-  auto call = parseCallExpr("a <= 42", ROW({{"a", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a <= 42", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a"});
-  ASSERT_TRUE(filter->testInt64(41));
-  ASSERT_TRUE(filter->testInt64(42));
-  ASSERT_FALSE(filter->testInt64(43));
+
+  VELOX_ASSERT_FILTER(lessThanOrEqual(42), filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, lt) {
-  auto call = parseCallExpr("a < 42", ROW({{"a", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a < 42", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a"});
-  ASSERT_TRUE(filter->testInt64(41));
-  ASSERT_FALSE(filter->testInt64(42));
-  ASSERT_FALSE(filter->testInt64(43));
+
+  VELOX_ASSERT_FILTER(lessThan(42), filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, gte) {
-  auto call = parseCallExpr("a >= 42", ROW({{"a", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a >= 42", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a"});
-  ASSERT_FALSE(filter->testInt64(41));
-  ASSERT_TRUE(filter->testInt64(42));
-  ASSERT_TRUE(filter->testInt64(43));
+
+  VELOX_ASSERT_FILTER(greaterThanOrEqual(42), filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, gt) {
-  auto call = parseCallExpr("a > 42", ROW({{"a", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a > 42", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a"});
-  ASSERT_FALSE(filter->testInt64(41));
-  ASSERT_FALSE(filter->testInt64(42));
-  ASSERT_TRUE(filter->testInt64(43));
+
+  VELOX_ASSERT_FILTER(greaterThan(42), filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, between) {
-  auto call = parseCallExpr("a between 40 and 42", ROW({{"a", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a between 40 and 42", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a"});
-  for (int i = 39; i <= 43; ++i) {
-    ASSERT_EQ(filter->testInt64(i), 40 <= i && i <= 42);
-  }
+
+  VELOX_ASSERT_FILTER(between(40, 42), filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, in) {
-  auto call = parseCallExpr("a in (40, 42)", ROW({{"a", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
-  ASSERT_TRUE(filter);
-  validateSubfield(subfield, {"a"});
-  for (int i = 39; i <= 43; ++i) {
-    ASSERT_EQ(filter->testInt64(i), i == 40 || i == 42);
+  {
+    auto call = parseCallExpr("a in (40, 42)", ROW("a", BIGINT()));
+    auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+    ASSERT_TRUE(filter);
+    validateSubfield(subfield, {"a"});
+
+    VELOX_ASSERT_FILTER(in({40, 42}), filter);
+  }
+
+  {
+    auto call = parseCallExpr("a in (40, 42, null)", ROW("a", BIGINT()));
+    auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+    ASSERT_TRUE(filter);
+    validateSubfield(subfield, {"a"});
+
+    VELOX_ASSERT_FILTER(in({40, 42}), filter);
   }
 }
 
-TEST_F(ExprToSubfieldFilterTest, isNull) {
-  auto call = parseCallExpr("a is null", ROW({{"a", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
-  ASSERT_TRUE(filter);
-  validateSubfield(subfield, {"a"});
-  ASSERT_FALSE(filter->testInt64(0));
-  ASSERT_FALSE(filter->testInt64(42));
-  ASSERT_TRUE(filter->testNull());
+TEST_F(ExprToSubfieldFilterTest, notIn) {
+  {
+    auto call = parseCallExpr("a in (40, 42)", ROW("a", BIGINT()));
+    auto [subfield, filter] = leafCallToSubfieldFilter(call, true);
+
+    ASSERT_TRUE(filter);
+    validateSubfield(subfield, {"a"});
+
+    VELOX_ASSERT_FILTER(notIn({40, 42}), filter);
+  }
+
+  {
+    auto call = parseCallExpr("a in (40, 42, null)", ROW("a", BIGINT()));
+    auto [subfield, filter] = leafCallToSubfieldFilter(call, true);
+
+    ASSERT_TRUE(filter);
+    validateSubfield(subfield, {"a"});
+
+    auto expected = std::make_unique<common::AlwaysFalse>();
+    VELOX_ASSERT_FILTER(expected, filter);
+  }
 }
 
-TEST_F(ExprToSubfieldFilterTest, isNotNull) {
-  auto call = parseCallExpr("a is not null", ROW({{"a", BIGINT()}}));
-  auto [subfield, filter] = toSubfieldFilter(call, evaluator());
+TEST_F(ExprToSubfieldFilterTest, isNull) {
+  auto call = parseCallExpr("a is null", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a"});
-  ASSERT_TRUE(filter->testInt64(0));
-  ASSERT_TRUE(filter->testInt64(42));
-  ASSERT_FALSE(filter->testNull());
+
+  VELOX_ASSERT_FILTER(isNull(), filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, like) {
-  auto call = parseCallExpr("a like 'foo%'", ROW({{"a", VARCHAR()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a like 'foo%'", ROW("a", VARCHAR()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_FALSE(filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, nonConstant) {
-  auto call =
-      parseCallExpr("a = b + 1", ROW({{"a", BIGINT()}, {"b", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a = b + 1", ROW({"a", "b"}, BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_FALSE(filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, userError) {
-  auto call = parseCallExpr("a = 1 / 0", ROW({{"a", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a = 1 / 0", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_FALSE(filter);
 }
 
@@ -268,94 +286,382 @@ TEST_F(ExprToSubfieldFilterTest, dereferenceWithEmptyField) {
       std::make_shared<core::DereferenceTypedExpr>(
           REAL(),
           std::make_shared<core::FieldAccessTypedExpr>(
-              ROW({{"", DOUBLE()}, {"", REAL()}, {"", BIGINT()}}),
-              std::make_shared<core::InputTypedExpr>(ROW(
-                  {{"c0",
-                    ROW({{"", DOUBLE()}, {"", REAL()}, {"", BIGINT()}})}})),
+              ROW({DOUBLE(), REAL(), BIGINT()}),
+              std::make_shared<core::InputTypedExpr>(
+                  ROW("c0", ROW({DOUBLE(), REAL(), BIGINT()}))),
               "c0"),
           1));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_FALSE(filter);
 }
 
-class CustomExprToSubfieldFilterParser : public ExprToSubfieldFilterParser {
- public:
-  std::unique_ptr<common::Filter> leafCallToSubfieldFilter(
-      const core::CallTypedExpr& call,
-      common::Subfield& subfield,
-      core::ExpressionEvaluator* evaluator,
-      bool negated) override {
-    if (call.inputs().empty()) {
-      return nullptr;
-    }
+template <typename... Disjuncts>
+static std::unique_ptr<common::Filter> makeOr(Disjuncts&&... disjuncts) {
+  return ExprToSubfieldFilterParser::makeOrFilter(
+      std::forward<Disjuncts>(disjuncts)...);
+}
 
-    const auto* leftSide = call.inputs()[0].get();
-
-    if (call.name() == "custom_eq") {
-      if (toSubfield(leftSide, subfield)) {
-        return negated ? makeNotEqualFilter(call.inputs()[1], evaluator)
-                       : makeEqualFilter(call.inputs()[1], evaluator);
-      }
-    } else if (call.name() == "is_null") {
-      if (toSubfield(call.inputs()[0].get(), subfield)) {
-        if (negated) {
-          return isNotNull();
-        }
-        return isNull();
-      }
-    }
-    return nullptr;
+TEST_F(ExprToSubfieldFilterTest, makeOrFilterBigint) {
+  // a = 1 or a = 5
+  {
+    auto expected = in({1, 5});
+    VELOX_ASSERT_FILTER(expected, makeOr(equal(1), equal(5)));
+    VELOX_ASSERT_FILTER(expected, makeOr(equal(5), equal(1)));
   }
-};
 
-class CustomExprToSubfieldFilterTest : public ExprToSubfieldFilterTest {
- public:
-  static void SetUpTestSuite() {
-    functions::prestosql::registerAllScalarFunctions("custom_");
-    functions::registerIsNullFunction("is_null");
-    parse::registerTypeResolver();
-    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
-    ExprToSubfieldFilterParser::registerParserFactory(
-        []() { return std::make_unique<CustomExprToSubfieldFilterParser>(); });
+  // a = 1 or a = 2 ==> a between 1 and 2
+  {
+    auto expected = between(1, 2);
+    VELOX_ASSERT_FILTER(expected, makeOr(equal(1), equal(2)));
+    VELOX_ASSERT_FILTER(expected, makeOr(equal(2), equal(1)));
+    VELOX_ASSERT_FILTER(expected, makeOr(between(1, 2), equal(1)));
+    VELOX_ASSERT_FILTER(expected, makeOr(equal(2), between(1, 2)));
   }
 
-  static void TearDownTestSuite() {
-    ExprToSubfieldFilterParser::registerParserFactory(
-        []() { return std::make_unique<PrestoExprToSubfieldFilterParser>(); });
+  // a = 1 or a between 5 and 10 or a = 11 ==> a = 1 or a between 5 and 11
+  {
+    auto expected = bigintOr(equal(1), between(5, 11));
+
+    VELOX_ASSERT_FILTER(expected, makeOr(equal(1), between(5, 10), equal(11)));
+    VELOX_ASSERT_FILTER(expected, makeOr(equal(1), equal(11), between(5, 10)));
+    VELOX_ASSERT_FILTER(expected, makeOr(between(5, 10), equal(11), equal(1)));
   }
-};
 
-TEST_F(CustomExprToSubfieldFilterTest, isNull) {
-  auto call = parseCallExpr("a is null", ROW({{"a", BIGINT()}}));
-  auto [subfield, filter] = toSubfieldFilter(call, evaluator());
+  // a < 10 or a > 0
+  {
+    VELOX_ASSERT_FILTER(isNotNull(), makeOr(lessThan(10), greaterThan(0)));
+    VELOX_ASSERT_FILTER(
+        alwaysTrue(),
+        makeOr(lessThan(10), greaterThan(0, /*nullAllowed=*/true)));
+  }
+
+  // a > 10 or a between 12 and 100
+  {
+    auto expected = greaterThanOrEqual(11);
+    VELOX_ASSERT_FILTER(expected, makeOr(greaterThan(10), between(12, 100)));
+    VELOX_ASSERT_FILTER(expected, makeOr(between(12, 100), greaterThan(10)));
+  }
+}
+
+TEST_F(ExprToSubfieldFilterTest, makeOrFilterDouble) {
+  // a < 1.5 or a > 1.0 ==> not null
+  {
+    VELOX_ASSERT_FILTER(
+        isNotNull(), makeOr(lessThanDouble(1.5), greaterThanDouble(1.0)));
+
+    VELOX_ASSERT_FILTER(
+        alwaysTrue(),
+        makeOr(
+            lessThanDouble(1.5, /*nullAllowed=*/true), greaterThanDouble(1.0)));
+  }
+
+  // a < 10.1 or a between 9.0 and 12.0 or a between 11.0 and 15.0 ==> a <= 15.0
+  {
+    auto expected = lessThanOrEqualDouble(15.0);
+    VELOX_ASSERT_FILTER(
+        expected,
+        makeOr(
+            lessThanDouble(10.1),
+            betweenDouble(9.0, 12.0),
+            betweenDouble(11.0, 15.0)));
+  }
+
+  // a < 0.0 or a > 4.5
+  {
+    auto expected = orFilter(lessThanDouble(0.0), greaterThanDouble(4.5));
+    VELOX_ASSERT_FILTER(
+        expected, makeOr(lessThanDouble(0.0), greaterThanDouble(4.5)));
+  }
+}
+
+TEST_F(ExprToSubfieldFilterTest, makeOrFilterFloat) {
+  // a < 1.5 or a > 1.0 ==> not null
+  {
+    VELOX_ASSERT_FILTER(
+        isNotNull(), makeOr(lessThanFloat(1.5), greaterThanFloat(1.0)));
+
+    VELOX_ASSERT_FILTER(
+        alwaysTrue(),
+        makeOr(
+            lessThanFloat(1.5, /*nullAllowed=*/true), greaterThanFloat(1.0)));
+  }
+
+  // a < 10.1 or a between 9.0 and 12.0 or a between 11.0 and 15.0 ==> a <= 15.0
+  {
+    auto expected = lessThanOrEqualFloat(15.0);
+    VELOX_ASSERT_FILTER(
+        expected,
+        makeOr(
+            lessThanFloat(10.1),
+            betweenFloat(9.0, 12.0),
+            betweenFloat(11.0, 15.0)));
+  }
+
+  // a < 0.0 or a > 4.5
+  {
+    auto expected = orFilter(lessThanFloat(0.0), greaterThanFloat(4.5));
+    VELOX_ASSERT_FILTER(
+        expected, makeOr(lessThanFloat(0.0), greaterThanFloat(4.5)));
+  }
+
+  // a < 1 or a > 1
+  {
+    auto expected = orFilter(lessThanFloat(1.0), greaterThanFloat(1.0));
+    VELOX_ASSERT_FILTER(
+        expected, makeOr(lessThanFloat(1.0), greaterThanFloat(1.0)));
+    VELOX_ASSERT_FILTER(
+        expected, makeOr(greaterThanFloat(1.0), lessThanFloat(1.0)));
+  }
+}
+
+TEST_F(ExprToSubfieldFilterTest, makeOrFilterBytesValues) {
+  // a = 'FRANCE' or a = 'JAPAN' ==> a in ('FRANCE', 'JAPAN')
+  // Note: equal(string) generates BytesValues filter
+  {
+    auto expected = in({"FRANCE", "JAPAN"});
+    VELOX_ASSERT_FILTER(expected, makeOr(equal("FRANCE"), equal("JAPAN")));
+    VELOX_ASSERT_FILTER(expected, makeOr(equal("JAPAN"), equal("FRANCE")));
+  }
+
+  // a = 'FRANCE' or a = 'GERMANY' or a = 'JAPAN'
+  // ==> a in ('FRANCE', 'GERMANY', 'JAPAN')
+  {
+    auto expected = in({"FRANCE", "GERMANY", "JAPAN"});
+    VELOX_ASSERT_FILTER(
+        expected, makeOr(equal("FRANCE"), equal("GERMANY"), equal("JAPAN")));
+  }
+
+  // a in ('FRANCE', 'JAPAN') or a = 'GERMANY'
+  // ==> a in ('FRANCE', 'JAPAN', 'GERMANY')
+  {
+    auto expected = in({"FRANCE", "JAPAN", "GERMANY"});
+    VELOX_ASSERT_FILTER(
+        expected, makeOr(in({"FRANCE", "JAPAN"}), equal("GERMANY")));
+  }
+
+  // a in ('FRANCE', 'JAPAN') or a in ('GERMANY', 'ITALY')
+  // ==> a in ('FRANCE', 'JAPAN', 'GERMANY', 'ITALY')
+  {
+    auto expected = in({"FRANCE", "JAPAN", "GERMANY", "ITALY"});
+    VELOX_ASSERT_FILTER(
+        expected, makeOr(in({"FRANCE", "JAPAN"}), in({"GERMANY", "ITALY"})));
+  }
+
+  // Test with nullAllowed
+  {
+    auto expected = std::make_unique<common::BytesValues>(
+        std::vector<std::string>{"FRANCE", "JAPAN"}, /*nullAllowed=*/true);
+    VELOX_ASSERT_FILTER(
+        expected,
+        makeOr(
+            equal("FRANCE"),
+            std::make_unique<common::BytesValues>(
+                std::vector<std::string>{"JAPAN"}, /*nullAllowed=*/true)));
+  }
+}
+
+TEST_F(ExprToSubfieldFilterTest, makeOrFilterBytesRange) {
+  // Test BytesRange with single value (singleValue_ = true)
+  // between("FRANCE", "FRANCE") creates a BytesRange with singleValue_ = true
+  {
+    auto expected = in({"FRANCE", "JAPAN"});
+    VELOX_ASSERT_FILTER(
+        expected,
+        makeOr(between("FRANCE", "FRANCE"), between("JAPAN", "JAPAN")));
+  }
+
+  // Test mixing BytesRange (single value) with BytesValues
+  {
+    auto expected = in({"FRANCE", "JAPAN", "GERMANY"});
+    VELOX_ASSERT_FILTER(
+        expected,
+        makeOr(between("FRANCE", "FRANCE"), in({"JAPAN", "GERMANY"})));
+    VELOX_ASSERT_FILTER(
+        expected,
+        makeOr(in({"JAPAN", "GERMANY"}), between("FRANCE", "FRANCE")));
+  }
+
+  // Test BytesRange with single value combined with equal() (BytesValues)
+  {
+    auto expected = in({"FRANCE", "JAPAN"});
+    VELOX_ASSERT_FILTER(
+        expected, makeOr(between("FRANCE", "FRANCE"), equal("JAPAN")));
+    VELOX_ASSERT_FILTER(
+        expected, makeOr(equal("JAPAN"), between("FRANCE", "FRANCE")));
+  }
+
+  // Test multiple BytesRange with single values
+  {
+    auto expected = in({"FRANCE", "GERMANY", "JAPAN"});
+    VELOX_ASSERT_FILTER(
+        expected,
+        makeOr(
+            between("FRANCE", "FRANCE"),
+            between("GERMANY", "GERMANY"),
+            between("JAPAN", "JAPAN")));
+  }
+}
+
+// Test NULL comparison handling - comparisons with NULL should return
+// AlwaysFalse as per SQL three-valued logic
+TEST_F(ExprToSubfieldFilterTest, eqNull) {
+  auto call = parseCallExpr("a = cast(null as bigint)", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
+}
+
+TEST_F(ExprToSubfieldFilterTest, eqNullVarchar) {
+  auto call = parseCallExpr("a = cast(null as varchar)", ROW("a", VARCHAR()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
+}
+
+TEST_F(ExprToSubfieldFilterTest, eqNullTimestamp) {
+  auto call =
+      parseCallExpr("a = cast(null as timestamp)", ROW("a", TIMESTAMP()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
+}
+
+TEST_F(ExprToSubfieldFilterTest, neqNull) {
+  auto call = parseCallExpr("a <> cast(null as bigint)", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
+}
+
+TEST_F(ExprToSubfieldFilterTest, ltNull) {
+  auto call = parseCallExpr("a < cast(null as bigint)", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
+}
+
+TEST_F(ExprToSubfieldFilterTest, ltNullDouble) {
+  auto call = parseCallExpr("a < cast(null as double)", ROW("a", DOUBLE()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
+}
+
+TEST_F(ExprToSubfieldFilterTest, ltNullVarchar) {
+  auto call = parseCallExpr("a < cast(null as varchar)", ROW("a", VARCHAR()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
+}
+
+TEST_F(ExprToSubfieldFilterTest, lteNull) {
+  auto call = parseCallExpr("a <= cast(null as bigint)", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
+}
+
+TEST_F(ExprToSubfieldFilterTest, lteNullReal) {
+  auto call = parseCallExpr("a <= cast(null as real)", ROW("a", REAL()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
+}
+
+TEST_F(ExprToSubfieldFilterTest, gtNull) {
+  auto call = parseCallExpr("a > cast(null as bigint)", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
+}
+
+TEST_F(ExprToSubfieldFilterTest, gtNullInteger) {
+  auto call = parseCallExpr("a > cast(null as integer)", ROW("a", INTEGER()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
+}
+
+TEST_F(ExprToSubfieldFilterTest, gteNull) {
+  auto call = parseCallExpr("a >= cast(null as bigint)", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a"});
-  ASSERT_FALSE(filter->testInt64(0));
-  ASSERT_FALSE(filter->testInt64(42));
-  ASSERT_TRUE(filter->testNull());
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
 }
 
-TEST_F(CustomExprToSubfieldFilterTest, eq) {
-  auto call = parseCallExpr("custom_eq(a, 42)", ROW({{"a", BIGINT()}}));
-  auto [subfield, filter] = toSubfieldFilter(call, evaluator());
+TEST_F(ExprToSubfieldFilterTest, gteNullSmallint) {
+  auto call =
+      parseCallExpr("a >= cast(null as smallint)", ROW("a", SMALLINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a"});
-  auto bigintRange = dynamic_cast<BigintRange*>(filter.get());
-  ASSERT_TRUE(bigintRange);
-  ASSERT_EQ(bigintRange->lower(), 42);
-  ASSERT_EQ(bigintRange->upper(), 42);
-  ASSERT_FALSE(bigintRange->testNull());
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
 }
 
-TEST_F(CustomExprToSubfieldFilterTest, unsupported) {
-  auto call = parseCallExpr("custom_neq(a, 42)", ROW({{"a", BIGINT()}}));
-  VELOX_ASSERT_USER_THROW(
-      toSubfieldFilter(call, evaluator()),
-      "Unsupported expression for range filter");
+TEST_F(ExprToSubfieldFilterTest, gteNullTinyint) {
+  auto call = parseCallExpr("a >= cast(null as tinyint)", ROW("a", TINYINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
 }
 
 } // namespace
 } // namespace facebook::velox::exec
+
+#undef VELOX_ASSERT_FILTER
diff --git a/velox/expression/tests/ExpressionRunner.cpp b/velox/expression/tests/ExpressionRunner.cpp
index ae9b572f919..06f2d8afc9b 100644
--- a/velox/expression/tests/ExpressionRunner.cpp
+++ b/velox/expression/tests/ExpressionRunner.cpp
@@ -24,7 +24,6 @@
 #include "velox/expression/fuzzer/FuzzerToolkit.h"
 #include "velox/expression/tests/ExpressionRunner.h"
 #include "velox/expression/tests/ExpressionVerifier.h"
-#include "velox/parse/Expressions.h"
 #include "velox/parse/ExpressionsParser.h"
 #include "velox/parse/QueryPlanner.h"
 #include "velox/parse/TypeResolver.h"
@@ -32,6 +31,7 @@
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
 namespace facebook::velox::test {
+using namespace facebook::velox::common::testutil;
 
 namespace {
 /// Creates a RowVector from a list of child vectors. Uses _col0, _col1,..
@@ -111,7 +111,7 @@ std::vector<core::TypedExprPtr> ExpressionRunner::parseSql(
     const TypePtr& inputType,
     memory::MemoryPool* pool,
     const VectorPtr& complexConstants) {
-  auto exprs = parse::parseMultipleExpressions(sql, {});
+  auto exprs = parse::DuckSqlExpressionsParser().parseExprs(sql);
 
   std::vector<core::TypedExprPtr> typedExprs;
   typedExprs.reserve(exprs.size());
@@ -168,21 +168,6 @@ RowVectorPtr replicateCommonDictionaryLayer(
       children);
 }
 
-// Applies modifications to the input test cases based on the input row
-// metadata, which includes making sure specific columns are wrapped in common
-// dictionary and/or wrapped in a lazy shim layer.
-void applyModificationsToInput(
-    std::vector<fuzzer::InputTestCase>& inputTestCases,
-    const InputRowMetadata& inputRowMetadata) {
-  for (auto& testCase : inputTestCases) {
-    auto& inputVector = testCase.inputVector;
-    inputVector = replicateCommonDictionaryLayer(
-        inputVector, inputRowMetadata.columnsToWrapInCommonDictionary);
-    inputVector = VectorFuzzer::fuzzRowChildrenToLazy(
-        inputVector, inputRowMetadata.columnsToWrapInLazy);
-  }
-}
-
 void ExpressionRunner::run(
     const std::string& inputPaths,
     const std::string& inputSelectivityVectorPaths,
@@ -198,7 +183,14 @@ void ExpressionRunner::run(
     bool useSeperatePoolForInput) {
   VELOX_CHECK(!sql.empty());
   auto memoryManager = memory::memoryManager();
-  auto queryCtx = core::QueryCtx::create();
+  auto queryCtx = core::QueryCtx::create(
+      nullptr,
+      core::QueryConfig(
+          {{facebook::velox::core::QueryConfig::kSessionTimezone,
+            "America/Los_Angeles"},
+           {facebook::velox::core::QueryConfig::kAdjustTimestampToTimezone,
+            "true"},
+           {facebook::velox::core::QueryConfig::kMinRowsForPeeling, "50"}}));
   std::shared_ptr<memory::MemoryPool> deserializerPool{
       memoryManager->addLeafPool()};
   std::shared_ptr<memory::MemoryPool> pool = useSeperatePoolForInput
@@ -235,7 +227,10 @@ void ExpressionRunner::run(
           "Input vector is not a RowVector: {}",
           vector->toString());
       VELOX_CHECK_GT(inputVector->size(), 0, "Input vector must not be empty.");
-      if (inputSelectivityPaths.size() > i) {
+      inputVector = replicateCommonDictionaryLayer(
+          inputVector, inputRowMetadata.columnsToWrapInCommonDictionary);
+      if (inputSelectivityPaths.size() > i &&
+          !inputSelectivityPaths[i].empty()) {
         inputTestCases.push_back(
             {inputVector,
              restoreSelectivityVectorFromFile(
@@ -245,7 +240,6 @@ void ExpressionRunner::run(
             {inputVector, SelectivityVector(inputVector->size(), true)});
       }
     }
-    applyModificationsToInput(inputTestCases, inputRowMetadata);
   }
 
   VELOX_CHECK(inputTestCases.size() > 0);
@@ -317,6 +311,11 @@ void ExpressionRunner::run(
     }
 
   } else if (mode == "common" || mode == "simplified") {
+    for (auto& testCase : inputTestCases) {
+      auto& inputVector = testCase.inputVector;
+      inputVector = VectorFuzzer::fuzzRowChildrenToLazy(
+          inputVector, inputRowMetadata.columnsToWrapInLazy);
+    }
     std::shared_ptr<exec::ExprSet> exprSet = mode == "common"
         ? std::make_shared<exec::ExprSet>(typedExprs, &execCtx)
         : std::make_shared<exec::ExprSetSimplified>(typedExprs, &execCtx);
diff --git a/velox/expression/tests/ExpressionRunner.h b/velox/expression/tests/ExpressionRunner.h
index 482ce8f43b4..a2740d6aa2a 100644
--- a/velox/expression/tests/ExpressionRunner.h
+++ b/velox/expression/tests/ExpressionRunner.h
@@ -16,7 +16,6 @@
 
 #include <string>
 #include "velox/exec/fuzzer/ReferenceQueryRunner.h"
-#include "velox/parse/Expressions.h"
 #include "velox/vector/TypeAliases.h"
 
 namespace facebook::velox::test {
diff --git a/velox/expression/tests/ExpressionRunnerUnitTest.cpp b/velox/expression/tests/ExpressionRunnerUnitTest.cpp
index f8abfe45336..7b7469588bb 100644
--- a/velox/expression/tests/ExpressionRunnerUnitTest.cpp
+++ b/velox/expression/tests/ExpressionRunnerUnitTest.cpp
@@ -15,8 +15,8 @@
  */
 
 #include <gtest/gtest.h>
+#include "velox/common/testutil/TempFilePath.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
-#include "velox/exec/tests/utils/TempFilePath.h"
 #include "velox/expression/Expr.h"
 #include "velox/expression/SignatureBinder.h"
 #include "velox/expression/fuzzer/ExpressionFuzzer.h"
@@ -27,6 +27,7 @@
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
 namespace facebook::velox::test {
+using namespace facebook::velox::common::testutil;
 
 class ExpressionRunnerUnitTest : public testing::Test, public VectorTestBase {
  public:
@@ -46,9 +47,9 @@ class ExpressionRunnerUnitTest : public testing::Test, public VectorTestBase {
 };
 
 TEST_F(ExpressionRunnerUnitTest, run) {
-  auto inputFile = exec::test::TempFilePath::create();
-  auto selectivityVectorFile = exec::test::TempFilePath::create();
-  auto resultFile = exec::test::TempFilePath::create();
+  auto inputFile = TempFilePath::create();
+  auto selectivityVectorFile = TempFilePath::create();
+  auto resultFile = TempFilePath::create();
   const auto inputPathStr = inputFile->getPath();
   const auto resultPathStr = resultFile->getPath();
   const auto selectivityVectorPathStr = selectivityVectorFile->getPath();
@@ -70,19 +71,20 @@ TEST_F(ExpressionRunnerUnitTest, run) {
 
   for (bool useSeperatePoolForInput : {true, false}) {
     LOG(INFO) << "Using useSeperatePoolForInput: " << useSeperatePoolForInput;
-    EXPECT_NO_THROW(ExpressionRunner::run(
-        inputPathStr.data(),
-        selectivityVectorPathStr.data(),
-        "length(c0)",
-        "",
-        resultPathStr.data(),
-        "verify",
-        0,
-        "",
-        "",
-        nullptr,
-        false,
-        useSeperatePoolForInput));
+    EXPECT_NO_THROW(
+        ExpressionRunner::run(
+            inputPathStr.data(),
+            selectivityVectorPathStr.data(),
+            "length(c0)",
+            "",
+            resultPathStr.data(),
+            "verify",
+            0,
+            "",
+            "",
+            nullptr,
+            false,
+            useSeperatePoolForInput));
   }
 }
 
@@ -112,8 +114,8 @@ TEST_F(ExpressionRunnerUnitTest, persistAndReproComplexSql) {
   auto rowVector = makeRowVector(complexConstants);
 
   // Emulate a reproduce from complex constant SQL
-  auto sqlFile = exec::test::TempFilePath::create();
-  auto complexConstantsFile = exec::test::TempFilePath::create();
+  auto sqlFile = TempFilePath::create();
+  auto complexConstantsFile = TempFilePath::create();
   const auto complexConstantsFilePathStr = complexConstantsFile->getPath();
   auto sqlPathStr = sqlFile->getPath();
   auto sqlPath = sqlPathStr.c_str();
diff --git a/velox/expression/tests/ExpressionVerifier.cpp b/velox/expression/tests/ExpressionVerifier.cpp
index d7b44dd60c3..f096cd9c3dd 100644
--- a/velox/expression/tests/ExpressionVerifier.cpp
+++ b/velox/expression/tests/ExpressionVerifier.cpp
@@ -194,12 +194,14 @@ void transformInputTestCases(
   const auto [transformedInputs, transformProjections] =
       referenceQueryRunner->inputProjections(input);
   for (const auto& expr : transformProjections) {
-    transformPlans.push_back(core::Expressions::inferTypes(
-        expr, transformedInputs[0]->type(), pool));
+    transformPlans.push_back(
+        core::Expressions::inferTypes(
+            expr, transformedInputs[0]->type(), pool));
   }
   for (int i = 0; i < transformedInputs.size(); ++i) {
-    transformedInputTestCases.push_back(fuzzer::InputTestCase{
-        transformedInputs[i], inputTestCases[i].activeRows});
+    transformedInputTestCases.push_back(
+        fuzzer::InputTestCase{
+            transformedInputs[i], inputTestCases[i].activeRows});
   }
 }
 
@@ -432,6 +434,7 @@ ExpressionVerifier::verify(
             // Throws in case only one evaluation path throws exception.
             // Otherwise, return false to signal that the expression failed.
             if (exceptionCommonPtr && exceptionReference) {
+              LOG(INFO) << "Both paths threw exception.";
               verificationStates.push_back(VerificationState::kBothPathsThrow);
             } else {
               verificationStates.push_back(
diff --git a/velox/expression/tests/ExpressionVerifierUnitTest.cpp b/velox/expression/tests/ExpressionVerifierUnitTest.cpp
index b35a2c677e7..7e9f2f333be 100644
--- a/velox/expression/tests/ExpressionVerifierUnitTest.cpp
+++ b/velox/expression/tests/ExpressionVerifierUnitTest.cpp
@@ -21,14 +21,15 @@
 
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/FileSystems.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/functions/Registerer.h"
-#include "velox/parse/Expressions.h"
 #include "velox/parse/ExpressionsParser.h"
 #include "velox/parse/TypeResolver.h"
 #include "velox/type/Type.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
+using namespace facebook::velox::common::testutil;
+
 namespace facebook::velox::test {
 
 namespace {
@@ -84,8 +85,7 @@ class ExpressionVerifierUnitTest : public testing::Test, public VectorTestBase {
   core::TypedExprPtr parseExpression(
       const std::string& text,
       const RowTypePtr& rowType) {
-    parse::ParseOptions options;
-    auto untyped = parse::parseExpr(text, options);
+    auto untyped = parse::DuckSqlExpressionsParser().parseExpr(text);
     return core::Expressions::inferTypes(untyped, rowType, pool_.get());
   }
 
@@ -97,7 +97,7 @@ class ExpressionVerifierUnitTest : public testing::Test, public VectorTestBase {
 
 TEST_F(ExpressionVerifierUnitTest, persistReproInfo) {
   filesystems::registerLocalFileSystem();
-  auto reproFolder = exec::test::TempDirectoryPath::create();
+  auto reproFolder = TempDirectoryPath::create();
   const auto reproPath = reproFolder->getPath();
   auto localFs = filesystems::getFileSystem(reproPath, nullptr);
 
diff --git a/velox/expression/tests/MapViewTest.cpp b/velox/expression/tests/MapViewTest.cpp
index 570897f9171..df92232797f 100644
--- a/velox/expression/tests/MapViewTest.cpp
+++ b/velox/expression/tests/MapViewTest.cpp
@@ -775,7 +775,7 @@ TEST_F(NullFreeMapViewTest, materialize) {
 
 TEST_F(NullableMapViewTest, materialize) {
   auto result = evaluate(
-      "map(array_constructor(1, 2),array_constructor(1, NULL))",
+      "map(array_constructor(1, 2),array_constructor(1, null::bigint))",
       makeRowVector({makeFlatVector<int64_t>(1)}));
 
   DecodedVector decoded;
@@ -789,7 +789,7 @@ TEST_F(NullableMapViewTest, materialize) {
 
 TEST_F(NullableMapViewTest, materializeNested) {
   auto result = evaluate(
-      "map(array_constructor(1, 2), array_constructor(array_constructor(1, null), null))",
+      "map(array_constructor(1, 2), array_constructor(array_constructor(1, null::bigint), null::bigint[]))",
       makeRowVector({makeFlatVector<int64_t>(1)}));
 
   DecodedVector decoded;
diff --git a/velox/expression/tests/MapWriterTest.cpp b/velox/expression/tests/MapWriterTest.cpp
index 3394ed96568..d793ea83767 100644
--- a/velox/expression/tests/MapWriterTest.cpp
+++ b/velox/expression/tests/MapWriterTest.cpp
@@ -20,16 +20,18 @@
 #include <optional>
 #include <tuple>
 
-#include <velox/expression/VectorReaders.h>
-#include <velox/vector/ComplexVector.h>
-#include <velox/vector/DecodedVector.h>
-#include <velox/vector/SelectivityVector.h>
 #include "folly/container/F14Map.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TestValue.h"
+#include "velox/expression/VectorReaders.h"
 #include "velox/expression/VectorWriters.h"
 #include "velox/functions/Udf.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/type/StringView.h"
 #include "velox/type/Type.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/DecodedVector.h"
+#include "velox/vector/SelectivityVector.h"
 namespace facebook::velox {
 namespace {
 
@@ -138,6 +140,12 @@ class MapWriterTest : public functions::test::FunctionBaseTest {
     writer.writer->setOffset(0);
     return writer;
   }
+
+ protected:
+  static void SetUpTestCase() {
+    FunctionBaseTest::SetUpTestCase();
+    common::testutil::TestValue::enable();
+  }
 };
 
 TEST_F(MapWriterTest, addNull) {
@@ -556,7 +564,7 @@ TEST_F(MapWriterTest, copyFromNullableMapView) {
       Map<int64_t, int64_t>>({"copy_from_nullable_map_view"});
 
   auto result = evaluate(
-      "copy_from_nullable_map_view(map(array_constructor(1,2,3),array_constructor(4,null,6)))",
+      "copy_from_nullable_map_view(map(array_constructor(1,2,3),array_constructor(4,null::bigint,6)))",
       makeRowVector({makeFlatVector<int64_t>(1)}));
 
   // Test results.
@@ -802,5 +810,69 @@ TEST_F(MapWriterTest, errorHandlingE2E) {
   assertEqualVectors(result, expected);
 }
 
+DEBUG_ONLY_TEST_F(MapWriterTest, resizeErrorHandling) {
+  // When resizing the child Vectors it's possible that an error is thrown, e.g.
+  // due to running out of memory or the Driver shutting down, ensure the Writer
+  // does not end up in an inconsistent state when this happens.
+  auto [result, vectorWriter] = makeTestWriter();
+  const auto keysVector = vectorWriter->vector().mapKeys();
+  const auto valuesVector = vectorWriter->vector().mapValues();
+
+  vectorWriter->setOffset(0);
+  auto& mapWriter = vectorWriter->current();
+  mapWriter.add_item() = std::make_tuple(100, 100);
+
+  // Simulate an error growing the Values Buffer in the key's Vector.
+  {
+    const std::string errorMessage = "Simulated failure in memory allocation";
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::FlatVector::resizeValues",
+        std::function<void(FlatVector<int64_t>*)>(
+            [&](FlatVector<int64_t>*) { VELOX_FAIL(errorMessage); }));
+    VELOX_ASSERT_THROW(mapWriter.add_item(), errorMessage);
+  }
+
+  // The child Vectors should not have been resized due to the error.
+  VELOX_CHECK_EQ(keysVector->size(), 1);
+  VELOX_CHECK_EQ(valuesVector->size(), 1);
+
+  // If we call add_item again it should resize the child Vectors to accommodate
+  // the new entry. If the MapWriter is in an invalid state it will think the
+  // children have already been resized.
+  mapWriter.add_item() = std::make_tuple(200, 200);
+  VELOX_CHECK_EQ(keysVector->size(), 2);
+  VELOX_CHECK_EQ(valuesVector->size(), 2);
+
+  // Simulate an error growing the Values Buffer in the value's Vector.
+  {
+    const std::string errorMessage = "Simulated failure in memory allocation";
+    // Fail on the second call since the first call will be for the key's
+    // Vector.
+    size_t callCount = 0;
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::FlatVector::resizeValues",
+        std::function<void(FlatVector<int64_t>*)>([&](FlatVector<int64_t>*) {
+          callCount++;
+
+          if (callCount == 2) {
+            VELOX_FAIL(errorMessage);
+          }
+        }));
+    VELOX_ASSERT_THROW(mapWriter.add_item(), errorMessage);
+  }
+
+  // The key Vector should have been resized by the value Vector should not have
+  // been due to the error.
+  VELOX_CHECK_EQ(keysVector->size(), 4);
+  VELOX_CHECK_EQ(valuesVector->size(), 2);
+
+  // If we call add_item again it should resize the value Vector to accommodate
+  // the new entry. If the MapWriter is in an invalid state it will think the
+  // children have already been resized.
+  mapWriter.add_item() = std::make_tuple(300, 300);
+  VELOX_CHECK_EQ(keysVector->size(), 4);
+  VELOX_CHECK_EQ(valuesVector->size(), 4);
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/expression/tests/NullIfExprTest.cpp b/velox/expression/tests/NullIfExprTest.cpp
new file mode 100644
index 00000000000..808c0c8e042
--- /dev/null
+++ b/velox/expression/tests/NullIfExprTest.cpp
@@ -0,0 +1,260 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "velox/core/Expressions.h"
+#include "velox/expression/Expr.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/parse/ExpressionsParser.h"
+#include "velox/parse/TypeResolver.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::exec::test {
+namespace {
+
+class NullIfExprTest : public testing::Test, public VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  void SetUp() override {
+    functions::prestosql::registerAllScalarFunctions();
+    parse::registerTypeResolver();
+  }
+
+  // Parses a SQL expression string into a TypedExprPtr.
+  core::TypedExprPtr parseExpr(
+      const std::string& sql,
+      const RowTypePtr& rowType) {
+    parse::ParseOptions options;
+    auto iExpr = parse::DuckSqlExpressionsParser(options).parseExpr(sql);
+    return core::Expressions::inferTypes(iExpr, rowType, pool());
+  }
+
+  // Evaluates NULLIF(a, b). Common type defaults to a's type.
+  VectorPtr evaluateNullIf(
+      const core::TypedExprPtr& aExpr,
+      const core::TypedExprPtr& bExpr,
+      const RowVectorPtr& input,
+      const TypePtr& commonType = nullptr) {
+    auto nullIfExpr = std::make_shared<core::NullIfTypedExpr>(
+        aExpr, bExpr, commonType ? commonType : aExpr->type());
+
+    ExprSet exprSet({nullIfExpr}, execCtx_.get());
+    EvalCtx context(execCtx_.get(), &exprSet, input.get());
+
+    std::vector<VectorPtr> result(1);
+    SelectivityVector rows(input->size());
+    exprSet.eval(rows, context, result);
+    return result[0];
+  }
+
+  // Evaluates NULLIF(a, b) using column references.
+  VectorPtr evaluateNullIf(
+      const VectorPtr& a,
+      const VectorPtr& b,
+      const TypePtr& commonType = nullptr) {
+    auto aField = std::make_shared<core::FieldAccessTypedExpr>(a->type(), "a");
+    auto bField = std::make_shared<core::FieldAccessTypedExpr>(b->type(), "b");
+    return evaluateNullIf(
+        aField, bField, makeRowVector({"a", "b"}, {a, b}), commonType);
+  }
+
+  std::shared_ptr<core::QueryCtx> queryCtx_{core::QueryCtx::create()};
+  std::unique_ptr<core::ExecCtx> execCtx_{
+      std::make_unique<core::ExecCtx>(pool_.get(), queryCtx_.get())};
+};
+
+// Same-type inputs, some equal, some not.
+TEST_F(NullIfExprTest, sameType) {
+  auto a = makeFlatVector<int32_t>({1, 2, 3, 4, 5});
+  auto b = makeFlatVector<int32_t>({1, 0, 3, 0, 5});
+
+  auto result = evaluateNullIf(a, b);
+
+  auto expected = makeNullableFlatVector<int32_t>(
+      {std::nullopt, 2, std::nullopt, 4, std::nullopt});
+  assertEqualVectors(expected, result);
+}
+
+// All rows equal — should return constant null.
+TEST_F(NullIfExprTest, allEqual) {
+  auto a = makeFlatVector<int32_t>({1, 2, 3});
+  auto b = makeFlatVector<int32_t>({1, 2, 3});
+
+  auto result = evaluateNullIf(a, b);
+
+  auto expected = makeNullableFlatVector<int32_t>(
+      {std::nullopt, std::nullopt, std::nullopt});
+  assertEqualVectors(expected, result);
+}
+
+// No rows equal — should return a as is.
+TEST_F(NullIfExprTest, noneEqual) {
+  auto a = makeFlatVector<int32_t>({1, 2, 3});
+  auto b = makeFlatVector<int32_t>({4, 5, 6});
+
+  auto result = evaluateNullIf(a, b);
+  assertEqualVectors(a, result);
+}
+
+// Null in first argument.
+TEST_F(NullIfExprTest, nullInFirst) {
+  auto a = makeNullableFlatVector<int32_t>({std::nullopt, 2, std::nullopt});
+  auto b = makeFlatVector<int32_t>({1, 2, 3});
+
+  auto result = evaluateNullIf(a, b);
+
+  // NULLIF(NULL, x) returns NULL (the first argument).
+  auto expected = makeNullableFlatVector<int32_t>(
+      {std::nullopt, std::nullopt, std::nullopt});
+  assertEqualVectors(expected, result);
+}
+
+// Null in second argument.
+TEST_F(NullIfExprTest, nullInSecond) {
+  auto a = makeFlatVector<int32_t>({1, 2, 3});
+  auto b = makeNullableFlatVector<int32_t>(
+      {std::nullopt, std::nullopt, std::nullopt});
+
+  auto result = evaluateNullIf(a, b);
+
+  // NULLIF(x, NULL) returns x (comparison is indeterminate).
+  assertEqualVectors(a, result);
+}
+
+// Both arguments null.
+TEST_F(NullIfExprTest, bothNull) {
+  auto a = makeNullableFlatVector<int32_t>({std::nullopt, std::nullopt});
+  auto b = makeNullableFlatVector<int32_t>({std::nullopt, std::nullopt});
+
+  auto result = evaluateNullIf(a, b);
+
+  // NULLIF(NULL, NULL) returns NULL (first argument).
+  auto expected = makeNullableFlatVector<int32_t>({std::nullopt, std::nullopt});
+  assertEqualVectors(expected, result);
+}
+
+// Different types with common supertype.
+TEST_F(NullIfExprTest, differentTypes) {
+  auto a = makeFlatVector<int16_t>({1, 2, 3, 4});
+  auto b = makeFlatVector<int64_t>({1, 0, 3, 0});
+
+  auto result = evaluateNullIf(a, b, BIGINT());
+
+  // Return type is SMALLINT (first argument's type).
+  EXPECT_EQ(result->type()->kind(), TypeKind::SMALLINT);
+  auto expected =
+      makeNullableFlatVector<int16_t>({std::nullopt, 2, std::nullopt, 4});
+  assertEqualVectors(expected, result);
+}
+
+// Arrays with nested nulls. With kNullAsIndeterminate, ARRAY[1, NULL] is not
+// equal to ARRAY[1, NULL] (comparison is indeterminate), so NULLIF returns the
+// first array unchanged.
+TEST_F(NullIfExprTest, arrayWithNestedNulls) {
+  auto a = makeArrayVectorFromJson<int32_t>({
+      "[1, null, 3]",
+      "[4, 5]",
+      "[null]",
+      "[1, 2, null]",
+  });
+  auto b = makeArrayVectorFromJson<int32_t>({
+      "[1, null, 3]",
+      "[4, 5]",
+      "[null]",
+      "[1, 1, null]",
+  });
+
+  auto result = evaluateNullIf(a, b);
+
+  // Row 0: [1, null, 3] vs [1, null, 3] — indeterminate, returns a.
+  // Row 1: [4, 5] vs [4, 5] — equal, returns NULL.
+  // Row 2: [null] vs [null] — indeterminate, returns a ([null]).
+  // Row 3: [1, 2, null] vs [1, 1, null] — not equal, returns a.
+  auto expected = makeArrayVectorFromJson<int32_t>({
+      "[1, null, 3]",
+      "null",
+      "[null]",
+      "[1, 2, null]",
+  });
+  assertEqualVectors(expected, result);
+}
+
+// Asserts the result has at least one null and returns the set of unique
+// non-null values.
+template <typename T>
+std::unordered_set<T> uniqueNonNullValues(const VectorPtr& result) {
+  auto* values = result->as<SimpleVector<T>>();
+  VELOX_CHECK_NOT_NULL(values);
+
+  std::unordered_set<T> unique;
+  bool hasNull = false;
+  for (vector_size_t row = 0; row < result->size(); ++row) {
+    if (result->isNullAt(row)) {
+      hasNull = true;
+    } else {
+      unique.insert(values->valueAt(row));
+    }
+  }
+
+  EXPECT_TRUE(hasNull) << "Expected some null rows";
+  EXPECT_FALSE(unique.empty()) << "Expected some non-null rows";
+  return unique;
+}
+
+// Non-deterministic expression evaluated once. NULLIF(rand() < 0.5, true)
+// should produce only NULL and false, never true. If the expression is
+// evaluated twice, the condition and return value can diverge, producing true.
+TEST_F(NullIfExprTest, nonDeterministic) {
+  auto input = makeRowVector(ROW({}), 1'000);
+
+  auto aExpr = parseExpr("rand() < 0.5", input->rowType());
+  auto bExpr = parseExpr("true", input->rowType());
+
+  auto result = evaluateNullIf(aExpr, bExpr, input);
+
+  // Only 'false' should appear as a non-null value.
+  EXPECT_THAT(uniqueNonNullValues<bool>(result), testing::ElementsAre(false));
+}
+
+// Same as nonDeterministic but with different input types to exercise the cast
+// path. NULLIF(cast(rand() * 10 as smallint), 5::bigint) returns NULL when the
+// cast result is 5, else returns the smallint value. Value 5 should never
+// appear in the output. The return type must be SMALLINT.
+TEST_F(NullIfExprTest, nonDeterministicWithCast) {
+  auto input = makeRowVector(ROW({}), 1'000);
+
+  auto aExpr = parseExpr("cast(rand() * 5.0 as smallint)", input->rowType());
+  auto bExpr = parseExpr("3::bigint", input->rowType());
+
+  auto result = evaluateNullIf(aExpr, bExpr, input, BIGINT());
+
+  EXPECT_EQ(result->type()->kind(), TypeKind::SMALLINT);
+
+  // All values 0-5 except 3 (which is nulled out).
+  EXPECT_THAT(
+      uniqueNonNullValues<int16_t>(result),
+      testing::UnorderedElementsAre(0, 1, 2, 4, 5));
+}
+
+} // namespace
+} // namespace facebook::velox::exec::test
diff --git a/velox/expression/tests/RowViewTest.cpp b/velox/expression/tests/RowViewTest.cpp
index 58864c9f753..992c521c58c 100644
--- a/velox/expression/tests/RowViewTest.cpp
+++ b/velox/expression/tests/RowViewTest.cpp
@@ -23,11 +23,10 @@
 #include "velox/functions/prestosql/Comparisons.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 
+namespace facebook::velox::functions::test {
 namespace {
 
-using namespace facebook::velox;
-using namespace facebook::velox::functions;
-using namespace facebook::velox::test;
+using velox::test::assertEqualVectors;
 
 DecodedVector* decode(DecodedVector& decoder, const BaseVector& vector) {
   SelectivityVector rows(vector.size());
@@ -397,7 +396,7 @@ TEST_F(NullFreeRowViewTest, e2eCompare) {
 
 TEST_F(NullableRowViewTest, materialize) {
   auto result = evaluate(
-      "row_constructor(1, 'hi', array_constructor(1, 2, null))",
+      "row_constructor(1, 'hi', array_constructor(1, 2, null::bigint))",
       makeRowVector({makeFlatVector<int64_t>(1)}));
 
   DecodedVector decoded;
@@ -406,7 +405,7 @@ TEST_F(NullableRowViewTest, materialize) {
 
   std::tuple<
       std::optional<int64_t>,
-      std::optional<std::string>,
+      std::optional<StringView>,
       std::optional<std::vector<std::optional<int64_t>>>>
       expected{1, "hi", {{1, 2, std::nullopt}}};
   ASSERT_EQ(reader[0].materialize(), expected);
@@ -517,4 +516,6 @@ TEST_F(DynamicRowViewTest, castToDynamicRowInFunction) {
     assertEqualVectors(makeFlatVector<int64_t>({2, 2}), result);
   }
 }
+
 } // namespace
+} // namespace facebook::velox::functions::test
diff --git a/velox/expression/tests/SignatureBinderTest.cpp b/velox/expression/tests/SignatureBinderTest.cpp
index 7cb9fe29855..a82ff9efd03 100644
--- a/velox/expression/tests/SignatureBinderTest.cpp
+++ b/velox/expression/tests/SignatureBinderTest.cpp
@@ -15,51 +15,143 @@
  */
 #include "velox/expression/SignatureBinder.h"
 #include <gtest/gtest.h>
-#include <velox/type/HugeInt.h>
 #include <vector>
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/prestosql/types/BigintEnumRegistration.h"
 #include "velox/functions/prestosql/types/BigintEnumType.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneRegistration.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/type/HugeInt.h"
 #include "velox/type/OpaqueCustomTypes.h"
 
 namespace facebook::velox::exec::test {
 namespace {
 
+std::vector<TypePtr> nullTypes(size_t n) {
+  return std::vector<TypePtr>(n, nullptr);
+}
+
+std::string toString(const std::vector<TypePtr>& types) {
+  std::stringstream out;
+
+  for (auto i = 0; i < types.size(); ++i) {
+    if (i > 0) {
+      out << ", ";
+    }
+    out << (types[i] ? types[i]->toString() : "null");
+  }
+
+  return out.str();
+}
+
+std::vector<TypePtr> extractCoercionTypes(
+    const std::vector<Coercion>& coercions) {
+  std::vector<TypePtr> types;
+  types.reserve(coercions.size());
+  for (const auto& c : coercions) {
+    types.push_back(c.type);
+  }
+  return types;
+}
+
 void testSignatureBinder(
     const std::shared_ptr<exec::FunctionSignature>& signature,
     const std::vector<TypePtr>& actualTypes,
     const TypePtr& expectedReturnType) {
-  exec::SignatureBinder binder(*signature, actualTypes);
-  ASSERT_TRUE(binder.tryBind());
+  SCOPED_TRACE(fmt::format("Signature: {}", signature->toString()));
+  SCOPED_TRACE(fmt::format("Actual types: {}", toString(actualTypes)));
 
+  {
+    exec::SignatureBinder binder(
+        *signature, actualTypes, TypeCoercer::defaults());
+    ASSERT_TRUE(binder.tryBind());
+  }
+
+  exec::SignatureBinder binder(
+      *signature, actualTypes, TypeCoercer::defaults());
   std::vector<Coercion> coercions;
   ASSERT_TRUE(binder.tryBindWithCoercions(coercions));
 
-  ASSERT_EQ(coercions.size(), actualTypes.size());
-  for (const auto& coercion : coercions) {
-    ASSERT_TRUE(coercion.type == nullptr);
-  }
+  ASSERT_EQ(extractCoercionTypes(coercions), nullTypes(actualTypes.size()));
 
   auto returnType = binder.tryResolveReturnType();
   ASSERT_TRUE(returnType != nullptr);
   ASSERT_EQ(*expectedReturnType, *returnType);
 }
 
-void assertCannotResolve(
+void assertCannotBind(
     const std::shared_ptr<exec::FunctionSignature>& signature,
     const std::vector<TypePtr>& actualTypes,
     bool allowCoercion = false) {
-  exec::SignatureBinder binder(*signature, actualTypes);
-  ASSERT_FALSE(binder.tryBind());
+  SCOPED_TRACE(fmt::format("Signature: {}", signature->toString()));
+  SCOPED_TRACE(fmt::format("Actual types: {}", toString(actualTypes)));
+
+  {
+    exec::SignatureBinder binder(
+        *signature, actualTypes, TypeCoercer::defaults());
+    ASSERT_FALSE(binder.tryBind());
+  }
 
   if (allowCoercion) {
+    exec::SignatureBinder binder(
+        *signature, actualTypes, TypeCoercer::defaults());
     std::vector<Coercion> coercions;
     ASSERT_FALSE(binder.tryBindWithCoercions(coercions));
   }
 }
 
+void assertCannotResolve(
+    const std::shared_ptr<exec::FunctionSignature>& signature,
+    const std::vector<TypePtr>& actualTypes) {
+  SCOPED_TRACE(fmt::format("Signature: {}", signature->toString()));
+  SCOPED_TRACE(fmt::format("Actual types: {}", toString(actualTypes)));
+
+  {
+    exec::SignatureBinder binder(
+        *signature, actualTypes, TypeCoercer::defaults());
+    ASSERT_TRUE(binder.tryBind());
+  }
+
+  exec::SignatureBinder binder(
+      *signature, actualTypes, TypeCoercer::defaults());
+  std::vector<Coercion> coercions;
+  ASSERT_TRUE(binder.tryBindWithCoercions(coercions));
+
+  ASSERT_EQ(extractCoercionTypes(coercions), nullTypes(actualTypes.size()));
+
+  auto returnType = binder.tryResolveReturnType();
+  ASSERT_TRUE(returnType == nullptr);
+}
+
+TEST(SignatureBinderTest, unknown) {
+  {
+    // (T, T) -> array(T)
+    auto signature = exec::FunctionSignatureBuilder()
+                         .typeVariable("T")
+                         .returnType("array(T)")
+                         .argumentType("T")
+                         .argumentType("T")
+                         .build();
+
+    testSignatureBinder(signature, {INTEGER(), INTEGER()}, ARRAY(INTEGER()));
+    assertCannotBind(signature, {INTEGER(), UNKNOWN()});
+    assertCannotBind(signature, {UNKNOWN(), INTEGER()});
+  }
+
+  {
+    // (T...) -> array(T)
+    auto signature = exec::FunctionSignatureBuilder()
+                         .typeVariable("T")
+                         .returnType("array(T)")
+                         .variableArity("T")
+                         .build();
+
+    testSignatureBinder(signature, {INTEGER(), INTEGER()}, ARRAY(INTEGER()));
+    assertCannotBind(signature, {INTEGER(), UNKNOWN()});
+    assertCannotBind(signature, {UNKNOWN(), INTEGER()});
+  }
+}
+
 TEST(SignatureBinderTest, decimals) {
   // Decimal Add/Subtract.
   {
@@ -159,7 +251,8 @@ TEST(SignatureBinderTest, decimals) {
                          .build();
 
     const std::vector<TypePtr> actualTypes{DECIMAL(10, 4)};
-    exec::SignatureBinder binder(*signature, actualTypes);
+    exec::SignatureBinder binder(
+        *signature, actualTypes, TypeCoercer::defaults());
     ASSERT_TRUE(binder.tryBind());
 
     auto intermediateType =
@@ -184,7 +277,7 @@ TEST(SignatureBinderTest, decimals) {
                          .argumentType("DECIMAL(b_precision, b_scale)")
                          .build();
     const std::vector<TypePtr> argTypes{DECIMAL(11, 5), DECIMAL(10, 6)};
-    exec::SignatureBinder binder(*signature, argTypes);
+    exec::SignatureBinder binder(*signature, argTypes, TypeCoercer::defaults());
     ASSERT_TRUE(binder.tryBind());
     ASSERT_TRUE(binder.tryResolveReturnType() == nullptr);
   }
@@ -199,7 +292,8 @@ TEST(SignatureBinderTest, decimals) {
                          .build();
     {
       const std::vector<TypePtr> argTypes{DECIMAL(11, 5), DECIMAL(11, 5)};
-      exec::SignatureBinder binder(*signature, argTypes);
+      exec::SignatureBinder binder(
+          *signature, argTypes, TypeCoercer::defaults());
       ASSERT_TRUE(binder.tryBind());
       auto returnType = binder.tryResolveReturnType();
       ASSERT_TRUE(returnType != nullptr);
@@ -208,7 +302,8 @@ TEST(SignatureBinderTest, decimals) {
 
     {
       const std::vector<TypePtr> argTypes{DECIMAL(28, 5), DECIMAL(28, 5)};
-      exec::SignatureBinder binder(*signature, argTypes);
+      exec::SignatureBinder binder(
+          *signature, argTypes, TypeCoercer::defaults());
       ASSERT_TRUE(binder.tryBind());
       auto returnType = binder.tryResolveReturnType();
       ASSERT_TRUE(returnType != nullptr);
@@ -218,15 +313,28 @@ TEST(SignatureBinderTest, decimals) {
     // Decimal scalar function signature with precision/scale mismatch.
     {
       const std::vector<TypePtr> argTypes{DECIMAL(28, 5), DECIMAL(29, 5)};
-      exec::SignatureBinder binder(*signature, argTypes);
+      exec::SignatureBinder binder(
+          *signature, argTypes, TypeCoercer::defaults());
       ASSERT_FALSE(binder.tryBind());
 
       const std::vector<TypePtr> argTypes1{DECIMAL(28, 7), DECIMAL(28, 5)};
-      exec::SignatureBinder binder1(*signature, argTypes1);
+      exec::SignatureBinder binder1(
+          *signature, argTypes1, TypeCoercer::defaults());
 
       ASSERT_FALSE(binder1.tryBind());
     }
 
+    // Non-decimal arguments with the same number of type parameters as
+    // DECIMAL (e.g. MAP has 2 type parameters).
+    {
+      const std::vector<TypePtr> argTypes{
+          MAP(VARCHAR(), BIGINT()), MAP(VARCHAR(), BIGINT())};
+      exec::SignatureBinder binder(
+          *signature, argTypes, TypeCoercer::defaults());
+      std::vector<Coercion> coercions;
+      ASSERT_FALSE(binder.tryBindWithCoercions(coercions));
+    }
+
     // Resolving invalid ShortDecimal/LongDecimal arguments returns nullptr.
     {
       // Missing constraints.
@@ -267,7 +375,7 @@ TEST(SignatureBinderTest, decimals) {
                            .argumentType("DECIMAL(precision, 6)")
                            .build();
       testSignatureBinder(signature, {DECIMAL(11, 6)}, BOOLEAN());
-      assertCannotResolve(signature, {DECIMAL(11, 8)});
+      assertCannotBind(signature, {DECIMAL(11, 8)});
     }
     {
       auto signature = exec::FunctionSignatureBuilder()
@@ -279,8 +387,8 @@ TEST(SignatureBinderTest, decimals) {
                            .build();
       testSignatureBinder(
           signature, {DECIMAL(11, 6), DECIMAL(18, 4)}, DECIMAL(11, 4));
-      assertCannotResolve(signature, {DECIMAL(11, 6), DECIMAL(20, 4)});
-      assertCannotResolve(signature, {DECIMAL(11, 8), DECIMAL(18, 4)});
+      assertCannotBind(signature, {DECIMAL(11, 6), DECIMAL(20, 4)});
+      assertCannotBind(signature, {DECIMAL(11, 8), DECIMAL(18, 4)});
     }
   }
 
@@ -294,7 +402,7 @@ TEST(SignatureBinderTest, decimals) {
                          .build();
 
     testSignatureBinder(signature, {DECIMAL(38, 0)}, VARCHAR());
-    assertCannotResolve(signature, {DECIMAL(18, 6)});
+    assertCannotBind(signature, {DECIMAL(18, 6)});
   }
 }
 
@@ -424,13 +532,15 @@ TEST(SignatureBinderTest, knownOnly) {
                        .build();
   {
     auto actualTypes = std::vector<TypePtr>{MAP(UNKNOWN(), UNKNOWN())};
-    exec::SignatureBinder binder(*signature, actualTypes);
+    exec::SignatureBinder binder(
+        *signature, actualTypes, TypeCoercer::defaults());
     ASSERT_FALSE(binder.tryBind());
   }
 
   {
     auto actualTypes = std::vector<TypePtr>{MAP(INTEGER(), UNKNOWN())};
-    exec::SignatureBinder binder(*signature, actualTypes);
+    exec::SignatureBinder binder(
+        *signature, actualTypes, TypeCoercer::defaults());
     ASSERT_TRUE(binder.tryBind());
   }
 }
@@ -443,13 +553,15 @@ TEST(SignatureBinderTest, orderableComparable) {
                        .build();
   {
     auto actualTypes = std::vector<TypePtr>{ARRAY(BIGINT())};
-    exec::SignatureBinder binder(*signature, actualTypes);
+    exec::SignatureBinder binder(
+        *signature, actualTypes, TypeCoercer::defaults());
     ASSERT_TRUE(binder.tryBind());
   }
 
   {
     auto actualTypes = std::vector<TypePtr>{ARRAY(MAP(BIGINT(), BIGINT()))};
-    exec::SignatureBinder binder(*signature, actualTypes);
+    exec::SignatureBinder binder(
+        *signature, actualTypes, TypeCoercer::defaults());
     ASSERT_FALSE(binder.tryBind());
   }
 
@@ -461,21 +573,24 @@ TEST(SignatureBinderTest, orderableComparable) {
                   .build();
   {
     auto actualTypes = std::vector<TypePtr>{ROW({BIGINT(), ARRAY(DOUBLE())})};
-    exec::SignatureBinder binder(*signature, actualTypes);
+    exec::SignatureBinder binder(
+        *signature, actualTypes, TypeCoercer::defaults());
     ASSERT_TRUE(binder.tryBind());
   }
 
   {
     auto actualTypes =
         std::vector<TypePtr>{ROW({MAP(VARCHAR(), BIGINT()), ARRAY(DOUBLE())})};
-    exec::SignatureBinder binder(*signature, actualTypes);
+    exec::SignatureBinder binder(
+        *signature, actualTypes, TypeCoercer::defaults());
     ASSERT_TRUE(binder.tryBind());
   }
 
   {
     auto actualTypes =
         std::vector<TypePtr>{ROW({BIGINT(), MAP(VARCHAR(), BIGINT())})};
-    exec::SignatureBinder binder(*signature, actualTypes);
+    exec::SignatureBinder binder(
+        *signature, actualTypes, TypeCoercer::defaults());
     ASSERT_FALSE(binder.tryBind());
   }
 }
@@ -489,7 +604,8 @@ TEST(SignatureBinderTest, orderableComparableAggregate) {
                        .build();
   {
     auto actualTypes = std::vector<TypePtr>{ARRAY(MAP(BIGINT(), BIGINT()))};
-    exec::SignatureBinder binder(*signature, actualTypes);
+    exec::SignatureBinder binder(
+        *signature, actualTypes, TypeCoercer::defaults());
     ASSERT_TRUE(binder.tryBind());
   }
 
@@ -502,7 +618,8 @@ TEST(SignatureBinderTest, orderableComparableAggregate) {
   {
     auto actualTypes =
         std::vector<TypePtr>{ROW({MAP(VARCHAR(), BIGINT()), ARRAY(DOUBLE())})};
-    exec::SignatureBinder binder(*signature, actualTypes);
+    exec::SignatureBinder binder(
+        *signature, actualTypes, TypeCoercer::defaults());
     ASSERT_TRUE(binder.tryBind());
   }
 
@@ -515,13 +632,15 @@ TEST(SignatureBinderTest, orderableComparableAggregate) {
   {
     auto actualTypes =
         std::vector<TypePtr>{ROW({MAP(VARCHAR(), BIGINT()), ARRAY(DOUBLE())})};
-    exec::SignatureBinder binder(*signature, actualTypes);
+    exec::SignatureBinder binder(
+        *signature, actualTypes, TypeCoercer::defaults());
     ASSERT_FALSE(binder.tryBind());
   }
 
   {
     auto actualTypes = std::vector<TypePtr>{ROW({BIGINT(), ARRAY(DOUBLE())})};
-    exec::SignatureBinder binder(*signature, actualTypes);
+    exec::SignatureBinder binder(
+        *signature, actualTypes, TypeCoercer::defaults());
     ASSERT_TRUE(binder.tryBind());
   }
 
@@ -536,14 +655,16 @@ TEST(SignatureBinderTest, orderableComparableAggregate) {
   {
     auto actualTypes =
         std::vector<TypePtr>{MAP(VARCHAR(), BIGINT()), ARRAY(DOUBLE())};
-    exec::SignatureBinder binder(*signature, actualTypes);
+    exec::SignatureBinder binder(
+        *signature, actualTypes, TypeCoercer::defaults());
     ASSERT_TRUE(binder.tryBind());
   }
 
   {
     auto actualTypes =
         std::vector<TypePtr>{ARRAY(DOUBLE()), MAP(VARCHAR(), BIGINT())};
-    exec::SignatureBinder binder(*signature, actualTypes);
+    exec::SignatureBinder binder(
+        *signature, actualTypes, TypeCoercer::defaults());
     ASSERT_FALSE(binder.tryBind());
   }
 }
@@ -561,7 +682,7 @@ TEST(SignatureBinderTest, generics) {
     testSignatureBinder(signature, {ARRAY(BIGINT()), BIGINT()}, BOOLEAN());
     testSignatureBinder(
         signature, {ARRAY(DECIMAL(20, 3)), DECIMAL(20, 3)}, BOOLEAN());
-    assertCannotResolve(signature, {ARRAY(DECIMAL(20, 3)), DECIMAL(20, 4)});
+    assertCannotBind(signature, {ARRAY(DECIMAL(20, 3)), DECIMAL(20, 4)});
   }
 
   // array(array(T)), array(T) -> boolean
@@ -682,11 +803,11 @@ TEST(SignatureBinderTest, unresolvable) {
                          .build();
 
     // wrong type
-    assertCannotResolve(signature, {BIGINT()});
+    assertCannotBind(signature, {BIGINT()});
 
     // wrong number of arguments
-    assertCannotResolve(signature, {});
-    assertCannotResolve(signature, {INTEGER(), DOUBLE()});
+    assertCannotBind(signature, {});
+    assertCannotBind(signature, {INTEGER(), DOUBLE()});
   }
 
   // integer, double -> varchar
@@ -698,12 +819,12 @@ TEST(SignatureBinderTest, unresolvable) {
                          .build();
 
     // wrong type
-    assertCannotResolve(signature, {BIGINT()});
-    assertCannotResolve(signature, {INTEGER(), INTEGER()});
-    assertCannotResolve(signature, {INTEGER(), DOUBLE(), INTEGER()});
+    assertCannotBind(signature, {BIGINT()});
+    assertCannotBind(signature, {INTEGER(), INTEGER()});
+    assertCannotBind(signature, {INTEGER(), DOUBLE(), INTEGER()});
 
     // wrong number of arguments
-    assertCannotResolve(signature, {});
+    assertCannotBind(signature, {});
   }
 
   // integer... -> varchar
@@ -714,8 +835,8 @@ TEST(SignatureBinderTest, unresolvable) {
                          .build();
 
     // wrong type
-    assertCannotResolve(signature, {BIGINT()});
-    assertCannotResolve(signature, {INTEGER(), BIGINT()});
+    assertCannotBind(signature, {BIGINT()});
+    assertCannotBind(signature, {INTEGER(), BIGINT()});
   }
 
   // row(bigint, varchar) -> bigint
@@ -728,8 +849,8 @@ TEST(SignatureBinderTest, unresolvable) {
     testSignatureBinder(signature, {ROW({BIGINT(), VARCHAR()})}, BIGINT());
 
     // wrong type
-    assertCannotResolve(signature, {ROW({BIGINT()})});
-    assertCannotResolve(signature, {ROW({BIGINT(), VARCHAR(), BOOLEAN()})});
+    assertCannotBind(signature, {ROW({BIGINT()})});
+    assertCannotBind(signature, {ROW({BIGINT(), VARCHAR(), BOOLEAN()})});
   }
 
   // array(row(boolean)) -> bigint
@@ -742,8 +863,8 @@ TEST(SignatureBinderTest, unresolvable) {
     testSignatureBinder(signature, {ARRAY(ROW({BOOLEAN()}))}, BIGINT());
 
     // wrong type
-    assertCannotResolve(signature, {ARRAY(ROW({BOOLEAN(), BIGINT()}))});
-    assertCannotResolve(signature, {ARRAY(ROW({BIGINT()}))});
+    assertCannotBind(signature, {ARRAY(ROW({BOOLEAN(), BIGINT()}))});
+    assertCannotBind(signature, {ARRAY(ROW({BIGINT()}))});
   }
 }
 
@@ -776,7 +897,7 @@ TEST(SignatureBinderTest, lambda) {
                        .build();
 
   std::vector<TypePtr> inputTypes{ARRAY(BIGINT()), DOUBLE(), nullptr, nullptr};
-  exec::SignatureBinder binder(*signature, inputTypes);
+  exec::SignatureBinder binder(*signature, inputTypes, TypeCoercer::defaults());
   ASSERT_FALSE(binder.tryBind());
 
   // Resolve inputs for function(S,T,S). We resolve first 2 arguments, since
@@ -952,7 +1073,7 @@ TEST(SignatureBinderTest, namedRows) {
     testSignatureBinder(signature, {ROW({{"bla", VARCHAR()}})}, VARCHAR());
 
     // Cannot bind if field doesn't have the same name set.
-    assertCannotResolve(signature, {ROW({{VARCHAR()}})});
+    assertCannotBind(signature, {ROW({{VARCHAR()}})});
   }
 
   // Multiple named row field.
@@ -973,7 +1094,7 @@ TEST(SignatureBinderTest, namedRows) {
         VARCHAR());
 
     // But not if one of the named fields is not.
-    assertCannotResolve(
+    assertCannotBind(
         signature,
         {ROW({{"foo", VARCHAR()}, {"fighters", BIGINT()}, {"bla", DOUBLE()}})});
   }
@@ -1025,19 +1146,6 @@ TEST(SignatureBinderTest, namedRows) {
   }
 }
 
-std::string toString(const std::vector<TypePtr>& types) {
-  std::stringstream out;
-
-  for (auto i = 0; i < types.size(); ++i) {
-    if (i > 0) {
-      out << ", ";
-    }
-    out << types.at(i)->toString();
-  }
-
-  return out.str();
-}
-
 void testCoercions(
     const exec::FunctionSignaturePtr& signature,
     const std::vector<TypePtr>& actualTypes,
@@ -1046,25 +1154,25 @@ void testCoercions(
   SCOPED_TRACE(fmt::format("Signature: {}", signature->toString()));
   SCOPED_TRACE(fmt::format("Actual types: {}", toString(actualTypes)));
 
-  exec::SignatureBinder binder(*signature, actualTypes);
+  {
+    exec::SignatureBinder binder(
+        *signature, actualTypes, TypeCoercer::defaults());
+    ASSERT_FALSE(binder.tryBind());
+  }
 
-  ASSERT_FALSE(binder.tryBind());
+  exec::SignatureBinder binder(
+      *signature, actualTypes, TypeCoercer::defaults());
 
   std::vector<Coercion> coercions;
   ASSERT_TRUE(binder.tryBindWithCoercions(coercions));
 
   ASSERT_EQ(expectedCoercions.size(), coercions.size());
   for (auto i = 0; i < expectedCoercions.size(); ++i) {
-    if (expectedCoercions[i] == nullptr) {
-      ASSERT_TRUE(coercions[i].type == nullptr);
-    } else {
-      ASSERT_EQ(*coercions[i].type, *expectedCoercions[i]);
-    }
+    VELOX_ASSERT_EQ_TYPES(coercions[i].type, expectedCoercions[i]);
   }
 
   auto returnType = binder.tryResolveReturnType();
-  ASSERT_TRUE(returnType != nullptr);
-  ASSERT_EQ(*expectedReturnType, *returnType);
+  VELOX_ASSERT_EQ_TYPES(returnType, expectedReturnType);
 }
 
 void testNoCoercions(
@@ -1075,7 +1183,8 @@ void testNoCoercions(
   SCOPED_TRACE(fmt::format("Actual types: {}", toString(actualTypes)));
 
   {
-    exec::SignatureBinder binder(*signature, actualTypes);
+    exec::SignatureBinder binder(
+        *signature, actualTypes, TypeCoercer::defaults());
     ASSERT_TRUE(binder.tryBind());
 
     auto returnType = binder.tryResolveReturnType();
@@ -1084,7 +1193,8 @@ void testNoCoercions(
   }
 
   {
-    exec::SignatureBinder binder(*signature, actualTypes);
+    exec::SignatureBinder binder(
+        *signature, actualTypes, TypeCoercer::defaults());
 
     std::vector<Coercion> coercions;
     ASSERT_TRUE(binder.tryBindWithCoercions(coercions));
@@ -1093,49 +1203,571 @@ void testNoCoercions(
     ASSERT_TRUE(returnType != nullptr);
     ASSERT_EQ(*expectedReturnType, *returnType);
 
-    ASSERT_EQ(actualTypes.size(), coercions.size());
-    for (auto i = 0; i < actualTypes.size(); ++i) {
-      ASSERT_TRUE(coercions[i].type == nullptr);
-    }
+    ASSERT_EQ(extractCoercionTypes(coercions), nullTypes(actualTypes.size()));
   }
 }
 
 TEST(SignatureBinderTest, coercions) {
-  auto signature = exec::FunctionSignatureBuilder()
-                       .returnType("boolean")
-                       .argumentType("smallint")
-                       .argumentType("integer")
-                       .argumentType("bigint")
-                       .argumentType("real")
-                       .argumentType("double")
-                       .build();
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("boolean")
+                         .argumentType("smallint")
+                         .argumentType("integer")
+                         .argumentType("bigint")
+                         .argumentType("real")
+                         .argumentType("double")
+                         .build();
+
+    testCoercions(
+        signature,
+        {TINYINT(), TINYINT(), TINYINT(), TINYINT(), TINYINT()},
+        {SMALLINT(), INTEGER(), BIGINT(), REAL(), DOUBLE()},
+        BOOLEAN());
+
+    testCoercions(
+        signature,
+        {SMALLINT(), SMALLINT(), SMALLINT(), REAL(), REAL()},
+        {nullptr, INTEGER(), BIGINT(), nullptr, DOUBLE()},
+        BOOLEAN());
+
+    testNoCoercions(
+        signature,
+        {SMALLINT(), INTEGER(), BIGINT(), REAL(), DOUBLE()},
+        BOOLEAN());
+
+    assertCannotBind(
+        signature,
+        {INTEGER(), INTEGER(), INTEGER(), INTEGER(), INTEGER()},
+        /*allowCoercion*/ true);
+
+    assertCannotBind(
+        signature,
+        {SMALLINT(), INTEGER(), VARCHAR(), INTEGER(), INTEGER()},
+        /*allowCoercion*/ true);
+  }
+
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("boolean")
+                         .argumentType("smallint")
+                         .variableArity("integer")
+                         .build();
+
+    testCoercions(
+        signature,
+        {TINYINT(), TINYINT(), TINYINT()},
+        {SMALLINT(), INTEGER(), INTEGER()},
+        BOOLEAN());
+
+    testCoercions(
+        signature,
+        {TINYINT(), INTEGER(), TINYINT()},
+        {SMALLINT(), nullptr, INTEGER()},
+        BOOLEAN());
+
+    testCoercions(
+        signature,
+        {SMALLINT(), TINYINT(), INTEGER()},
+        {nullptr, INTEGER(), nullptr},
+        BOOLEAN());
+
+    testNoCoercions(signature, {SMALLINT(), INTEGER()}, BOOLEAN());
+    testNoCoercions(signature, {SMALLINT(), INTEGER(), INTEGER()}, BOOLEAN());
+
+    assertCannotBind(
+        signature,
+        {SMALLINT(), INTEGER(), VARCHAR(), INTEGER(), INTEGER()},
+        /*allowCoercion*/ true);
+
+    assertCannotBind(
+        signature,
+        {SMALLINT(), INTEGER(), BIGINT(), INTEGER(), INTEGER()},
+        /*allowCoercion*/ true);
+  }
+}
+
+TEST(SignatureBinderTest, complexTypeCoercions) {
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("boolean")
+                         .argumentType("array(bigint)")
+                         .argumentType("map(bigint, double)")
+                         .argumentType("row(integer, bigint, double)")
+                         .argumentType("row(a integer,b bigint,c double)")
+                         .build();
+    testCoercions(
+        signature,
+        {
+            ARRAY(INTEGER()),
+            MAP(INTEGER(), REAL()),
+            ROW({TINYINT(), SMALLINT(), REAL()}),
+            ROW({"a", "b", "c"}, {TINYINT(), SMALLINT(), REAL()}),
+        },
+        {
+            ARRAY(BIGINT()),
+            MAP(BIGINT(), DOUBLE()),
+            ROW({INTEGER(), BIGINT(), DOUBLE()}),
+            ROW({"a", "b", "c"}, {INTEGER(), BIGINT(), DOUBLE()}),
+        },
+        BOOLEAN());
+
+    testNoCoercions(
+        signature,
+        {
+            ARRAY(BIGINT()),
+            MAP(BIGINT(), DOUBLE()),
+            ROW({INTEGER(), BIGINT(), DOUBLE()}),
+            ROW({"a", "b", "c"}, {INTEGER(), BIGINT(), DOUBLE()}),
+        },
+        BOOLEAN());
+
+    // Wrong array type.
+    assertCannotBind(
+        signature,
+        {
+            ARRAY(VARCHAR()),
+            MAP(BIGINT(), DOUBLE()),
+            ROW({INTEGER(), BIGINT(), DOUBLE()}),
+            ROW({"a", "b", "c"}, {INTEGER(), BIGINT(), DOUBLE()}),
+        },
+        /*allowCoercion*/ true);
+
+    // Wrong map value type.
+    assertCannotBind(
+        signature,
+        {
+            ARRAY(BIGINT()),
+            MAP(BIGINT(), VARCHAR()),
+            ROW({INTEGER(), BIGINT(), DOUBLE()}),
+            ROW({"a", "b", "c"}, {INTEGER(), BIGINT(), DOUBLE()}),
+        },
+        /*allowCoercion*/ true);
+
+    // Wrong struct field type.
+    assertCannotBind(
+        signature,
+        {
+            ARRAY(BIGINT()),
+            MAP(BIGINT(), DOUBLE()),
+            ROW({INTEGER(), VARCHAR(), DOUBLE()}),
+            ROW({"a", "b", "c"}, {INTEGER(), BIGINT(), DOUBLE()}),
+        },
+        /*allowCoercion*/ true);
+
+    // Wrong struct field name.
+    assertCannotBind(
+        signature,
+        {
+            ARRAY(BIGINT()),
+            MAP(BIGINT(), DOUBLE()),
+            ROW({INTEGER(), BIGINT(), DOUBLE()}),
+            ROW({"A", "b", "c"}, {INTEGER(), BIGINT(), DOUBLE()}),
+        },
+        /*allowCoercion*/ true);
+  }
+}
+
+TEST(SignatureBinderTest, genericCoercions) {
+  // (T,..) -> boolean
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("boolean")
+                         .typeVariable("T")
+                         .argumentType("T")
+                         .variableArity("T")
+                         .build();
+
+    testCoercions(
+        signature,
+        {TINYINT(), SMALLINT(), INTEGER()},
+        {INTEGER(), INTEGER(), nullptr},
+        BOOLEAN());
+
+    testCoercions(
+        signature,
+        {INTEGER(), SMALLINT(), TINYINT()},
+        {nullptr, INTEGER(), INTEGER()},
+        BOOLEAN());
+
+    testCoercions(
+        signature,
+        {ARRAY(TINYINT()), ARRAY(INTEGER())},
+        {ARRAY(INTEGER()), nullptr},
+        BOOLEAN());
+
+    testCoercions(
+        signature,
+        {MAP(TINYINT(), DOUBLE()), MAP(INTEGER(), REAL())},
+        {MAP(INTEGER(), DOUBLE()), MAP(INTEGER(), DOUBLE())},
+        BOOLEAN());
+
+    testNoCoercions(signature, {INTEGER(), INTEGER()}, BOOLEAN());
+
+    assertCannotBind(signature, {INTEGER(), VARCHAR()}, /*allowCoercion*/ true);
+  }
+
+  // (T, array(T)) -> boolean
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("boolean")
+                         .typeVariable("T")
+                         .argumentType("T")
+                         .argumentType("array(T)")
+                         .build();
+
+    testCoercions(
+        signature,
+        {TINYINT(), ARRAY(INTEGER())},
+        {INTEGER(), nullptr},
+        BOOLEAN());
+
+    testNoCoercions(signature, {INTEGER(), ARRAY(INTEGER())}, BOOLEAN());
 
-  testCoercions(
-      signature,
-      {TINYINT(), TINYINT(), TINYINT(), TINYINT(), TINYINT()},
-      {SMALLINT(), INTEGER(), BIGINT(), REAL(), DOUBLE()},
-      BOOLEAN());
-
-  testCoercions(
-      signature,
-      {SMALLINT(), SMALLINT(), SMALLINT(), REAL(), REAL()},
-      {nullptr, INTEGER(), BIGINT(), nullptr, DOUBLE()},
-      BOOLEAN());
-
-  testNoCoercions(
-      signature,
-      {SMALLINT(), INTEGER(), BIGINT(), REAL(), DOUBLE()},
-      BOOLEAN());
-
-  assertCannotResolve(
-      signature,
-      {INTEGER(), INTEGER(), INTEGER(), INTEGER(), INTEGER()},
-      /*allowCoercion*/ true);
-
-  assertCannotResolve(
-      signature,
-      {SMALLINT(), INTEGER(), VARCHAR(), INTEGER(), INTEGER()},
-      /*allowCoercion*/ true);
+    assertCannotBind(
+        signature, {INTEGER(), ARRAY(VARCHAR())}, /*allowCoercion=*/true);
+    assertCannotBind(
+        signature, {VARCHAR(), ARRAY(INTEGER())}, /*allowCoercion=*/true);
+  }
+}
+
+TEST(SignatureBinderTest, homogeneousRow) {
+  // row(T, ...) -> boolean
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .typeVariable("T")
+                         .returnType("boolean")
+                         .argumentType("row(T, ...)")
+                         .build();
+
+    testSignatureBinder(signature, {ROW({BIGINT()})}, BOOLEAN());
+
+    testSignatureBinder(
+        signature, {ROW({BIGINT(), BIGINT(), BIGINT()})}, BOOLEAN());
+
+    testSignatureBinder(signature, {ROW({VARCHAR(), VARCHAR()})}, BOOLEAN());
+
+    testSignatureBinder(
+        signature,
+        {ROW({MAP(INTEGER(), REAL()), MAP(INTEGER(), REAL())})},
+        BOOLEAN());
+
+    // Named row fields should also bind when types are homogeneous.
+    testSignatureBinder(
+        signature,
+        {ROW({{"first", VARCHAR()}, {"second", VARCHAR()}})},
+        BOOLEAN());
+
+    // Mixed named-row element types should fail to bind.
+    assertCannotBind(signature, {ROW({{"x", BIGINT()}, {"y", VARCHAR()}})});
+
+    testSignatureBinder(signature, {ROW({})}, BOOLEAN());
+
+    assertCannotBind(signature, {ROW({BIGINT(), VARCHAR()})});
+
+    assertCannotBind(signature, {BIGINT()});
+    assertCannotBind(signature, {ARRAY(BIGINT())});
+  }
+
+  // row(T:orderable, ...) -> boolean
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .orderableTypeVariable("T")
+                         .returnType("boolean")
+                         .argumentType("row(T, ...)")
+                         .build();
+
+    testSignatureBinder(signature, {ROW({BIGINT()})}, BOOLEAN());
+
+    // MAP type is not orderable.
+    assertCannotBind(signature, {ROW({MAP(INTEGER(), REAL())})});
+  }
+
+  // (row(T, ...), row(T, ...)) -> T
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .typeVariable("T")
+                         .returnType("T")
+                         .argumentType("row(T, ...)")
+                         .argumentType("row(T, ...)")
+                         .build();
+
+    testSignatureBinder(
+        signature,
+        {ROW({BIGINT(), BIGINT()}), ROW({BIGINT(), BIGINT(), BIGINT()})},
+        BIGINT());
+
+    testSignatureBinder(
+        signature, {ROW({}), ROW({BIGINT(), BIGINT(), BIGINT()})}, BIGINT());
+
+    assertCannotResolve(signature, {ROW({}), ROW({})});
+    assertCannotBind(
+        signature, {ROW({BIGINT(), BIGINT()}), ROW({VARCHAR(), VARCHAR()})});
+  }
+
+  // (row(T,...), row(U,...)) -> map(T,U)
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .typeVariable("T")
+                         .typeVariable("U")
+                         .returnType("map(T,U)")
+                         .argumentType("row(T, ...)")
+                         .argumentType("row(U, ...)")
+                         .build();
+
+    testSignatureBinder(
+        signature,
+        {ROW({BIGINT(), BIGINT()}), ROW({VARCHAR(), VARCHAR(), VARCHAR()})},
+        MAP(BIGINT(), VARCHAR()));
+
+    assertCannotResolve(signature, {ROW({BIGINT(), BIGINT()}), ROW({})});
+    assertCannotBind(
+        signature, {ROW({BIGINT(), BIGINT()}), ROW({BIGINT(), VARCHAR()})});
+  }
+
+  // row(array(bigint), ...) -> bigint
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("bigint")
+                         .argumentType("row(array(bigint), ...)")
+                         .build();
+
+    testSignatureBinder(signature, {ROW({})}, BIGINT());
+    testSignatureBinder(signature, {ROW({ARRAY(BIGINT())})}, BIGINT());
+    testSignatureBinder(
+        signature, {ROW({ARRAY(BIGINT()), ARRAY(BIGINT())})}, BIGINT());
+  }
+
+  // array(row(T, ...)) -> array(T)
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .typeVariable("T")
+                         .returnType("array(T)")
+                         .argumentType("array(row(T, ...))")
+                         .build();
+
+    testSignatureBinder(signature, {ARRAY(ROW({INTEGER()}))}, ARRAY(INTEGER()));
+    testSignatureBinder(
+        signature, {ARRAY(ROW({"a", "b"}, REAL()))}, ARRAY(REAL()));
+
+    assertCannotResolve(signature, {ARRAY(ROW({}))});
+  }
+}
+
+TEST(SignatureBinderTest, unknownCoercions) {
+  // UNKNOWN can be coerced to any type with zero cost.
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("boolean")
+                         .argumentType("bigint")
+                         .build();
+
+    testCoercions(signature, {UNKNOWN()}, {BIGINT()}, BOOLEAN());
+  }
+
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("boolean")
+                         .argumentType("varchar")
+                         .build();
+
+    testCoercions(signature, {UNKNOWN()}, {VARCHAR()}, BOOLEAN());
+  }
+
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("boolean")
+                         .argumentType("double")
+                         .build();
+
+    testCoercions(signature, {UNKNOWN()}, {DOUBLE()}, BOOLEAN());
+  }
+
+  // Multiple UNKNOWN arguments coerced to different types.
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("boolean")
+                         .argumentType("bigint")
+                         .argumentType("varchar")
+                         .argumentType("double")
+                         .build();
+
+    testCoercions(
+        signature,
+        {UNKNOWN(), UNKNOWN(), UNKNOWN()},
+        {BIGINT(), VARCHAR(), DOUBLE()},
+        BOOLEAN());
+  }
+
+  // UNKNOWN mixed with regular types requiring coercion.
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("boolean")
+                         .argumentType("bigint")
+                         .argumentType("double")
+                         .build();
+
+    testCoercions(
+        signature, {UNKNOWN(), REAL()}, {BIGINT(), DOUBLE()}, BOOLEAN());
+
+    testCoercions(
+        signature, {INTEGER(), UNKNOWN()}, {BIGINT(), DOUBLE()}, BOOLEAN());
+  }
+}
+
+TEST(SignatureBinderTest, unknownInComplexTypes) {
+  // UNKNOWN in array.
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("boolean")
+                         .argumentType("array(bigint)")
+                         .build();
+
+    testCoercions(signature, {ARRAY(UNKNOWN())}, {ARRAY(BIGINT())}, BOOLEAN());
+  }
+
+  // UNKNOWN in map.
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("boolean")
+                         .argumentType("map(bigint, varchar)")
+                         .build();
+
+    testCoercions(
+        signature,
+        {MAP(UNKNOWN(), UNKNOWN())},
+        {MAP(BIGINT(), VARCHAR())},
+        BOOLEAN());
+
+    testCoercions(
+        signature,
+        {MAP(INTEGER(), UNKNOWN())},
+        {MAP(BIGINT(), VARCHAR())},
+        BOOLEAN());
+  }
+
+  // UNKNOWN in row.
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("boolean")
+                         .argumentType("row(bigint, varchar, double)")
+                         .build();
+
+    testCoercions(
+        signature,
+        {ROW({UNKNOWN(), UNKNOWN(), UNKNOWN()})},
+        {ROW({BIGINT(), VARCHAR(), DOUBLE()})},
+        BOOLEAN());
+
+    testCoercions(
+        signature,
+        {ROW({INTEGER(), UNKNOWN(), REAL()})},
+        {ROW({BIGINT(), VARCHAR(), DOUBLE()})},
+        BOOLEAN());
+  }
+
+  // Nested complex types with UNKNOWN.
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("boolean")
+                         .argumentType("array(map(bigint, varchar))")
+                         .build();
+
+    testCoercions(
+        signature,
+        {ARRAY(MAP(UNKNOWN(), UNKNOWN()))},
+        {ARRAY(MAP(BIGINT(), VARCHAR()))},
+        BOOLEAN());
+  }
+}
+
+TEST(SignatureBinderTest, tryResolveReturnTypeWithCoercions) {
+  auto makeSignature = [](const std::string& returnType,
+                          const std::vector<std::string>& argTypes) {
+    exec::FunctionSignatureBuilder builder;
+    builder.returnType(returnType);
+    for (const auto& argType : argTypes) {
+      builder.argumentType(argType);
+    }
+    return builder.build();
+  };
+
+  // No signatures returns nullptr.
+  {
+    std::vector<TypePtr> coercions;
+    auto type = exec::tryResolveReturnTypeWithCoercions(
+        {}, {BIGINT()}, coercions, TypeCoercer::defaults());
+    ASSERT_EQ(type, nullptr);
+  }
+
+  // Exact match: no coercions.
+  {
+    std::vector<exec::FunctionSignaturePtr> signatures{
+        makeSignature("bigint", {"bigint", "bigint"}),
+    };
+    std::vector<TypePtr> coercions;
+    auto type = exec::tryResolveReturnTypeWithCoercions(
+        signatures, {BIGINT(), BIGINT()}, coercions, TypeCoercer::defaults());
+    VELOX_ASSERT_EQ_TYPES(type, BIGINT());
+    ASSERT_EQ(coercions.size(), 2);
+    ASSERT_EQ(coercions[0], nullptr);
+    ASSERT_EQ(coercions[1], nullptr);
+  }
+
+  // No matching signature returns nullptr.
+  {
+    std::vector<exec::FunctionSignaturePtr> signatures{
+        makeSignature("bigint", {"bigint", "bigint"}),
+    };
+    std::vector<TypePtr> coercions;
+    auto type = exec::tryResolveReturnTypeWithCoercions(
+        signatures, {VARCHAR(), BIGINT()}, coercions, TypeCoercer::defaults());
+    ASSERT_EQ(type, nullptr);
+  }
+
+  // Exact match preferred over coerced match.
+  {
+    std::vector<exec::FunctionSignaturePtr> signatures{
+        makeSignature("integer", {"integer", "integer"}),
+        makeSignature("bigint", {"bigint", "bigint"}),
+    };
+    std::vector<TypePtr> coercions;
+    auto type = exec::tryResolveReturnTypeWithCoercions(
+        signatures, {BIGINT(), BIGINT()}, coercions, TypeCoercer::defaults());
+    VELOX_ASSERT_EQ_TYPES(type, BIGINT());
+    ASSERT_EQ(coercions.size(), 2);
+    ASSERT_EQ(coercions[0], nullptr);
+    ASSERT_EQ(coercions[1], nullptr);
+  }
+
+  // Coercion: lowest cost selected.
+  {
+    std::vector<exec::FunctionSignaturePtr> signatures{
+        makeSignature("integer", {"integer", "integer"}),
+        makeSignature("bigint", {"bigint", "bigint"}),
+    };
+    std::vector<TypePtr> coercions;
+    auto type = exec::tryResolveReturnTypeWithCoercions(
+        signatures, {TINYINT(), TINYINT()}, coercions, TypeCoercer::defaults());
+    // integer(integer, integer) is lower cost than bigint(bigint, bigint).
+    VELOX_ASSERT_EQ_TYPES(type, INTEGER());
+    ASSERT_EQ(coercions.size(), 2);
+    VELOX_ASSERT_EQ_TYPES(coercions[0], INTEGER());
+    VELOX_ASSERT_EQ_TYPES(coercions[1], INTEGER());
+  }
+
+  // Partial coercion: one arg needs coercion, the other doesn't.
+  {
+    std::vector<exec::FunctionSignaturePtr> signatures{
+        makeSignature("bigint", {"bigint", "bigint"}),
+    };
+    std::vector<TypePtr> coercions;
+    auto type = exec::tryResolveReturnTypeWithCoercions(
+        signatures, {TINYINT(), BIGINT()}, coercions, TypeCoercer::defaults());
+    VELOX_ASSERT_EQ_TYPES(type, BIGINT());
+    ASSERT_EQ(coercions.size(), 2);
+    VELOX_ASSERT_EQ_TYPES(coercions[0], BIGINT());
+    ASSERT_EQ(coercions[1], nullptr);
+  }
 }
 
 } // namespace
diff --git a/velox/expression/tests/SimpleFunctionInitTest.cpp b/velox/expression/tests/SimpleFunctionInitTest.cpp
index 8fe707d3b35..05452a74b32 100644
--- a/velox/expression/tests/SimpleFunctionInitTest.cpp
+++ b/velox/expression/tests/SimpleFunctionInitTest.cpp
@@ -99,8 +99,9 @@ TEST_F(SimpleFunctionInitTest, initializationArray) {
 
         auto rhsArrayVector = makeNullableArrayVector(
             std::vector<std::vector<std::optional<int32_t>>>{second});
-        args.push_back(std::make_shared<core::ConstantTypedExpr>(
-            BaseVector::wrapInConstant(1, 0, rhsArrayVector)));
+        args.push_back(
+            std::make_shared<core::ConstantTypedExpr>(
+                BaseVector::wrapInConstant(1, 0, rhsArrayVector)));
         exec::ExprSet expr(
             {std::make_shared<core::CallTypedExpr>(
                 ARRAY(INTEGER()), args, "non_default_behavior_with_init")},
@@ -181,8 +182,9 @@ TEST_F(SimpleFunctionInitTest, initializationMap) {
   std::vector<core::TypedExprPtr> args;
   args.push_back(std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"));
 
-  args.push_back(std::make_shared<core::ConstantTypedExpr>(
-      BaseVector::wrapInConstant(1, 0, mapVectorPtr)));
+  args.push_back(
+      std::make_shared<core::ConstantTypedExpr>(
+          BaseVector::wrapInConstant(1, 0, mapVectorPtr)));
   exec::ExprSet expr(
       {std::make_shared<core::CallTypedExpr>(
           BIGINT(), args, "non_default_behavior_with_map_init")},
diff --git a/velox/expression/tests/SimpleFunctionTest.cpp b/velox/expression/tests/SimpleFunctionTest.cpp
index 6549e789120..f0030aa1466 100644
--- a/velox/expression/tests/SimpleFunctionTest.cpp
+++ b/velox/expression/tests/SimpleFunctionTest.cpp
@@ -98,6 +98,19 @@ class SimpleFunctionTest : public functions::test::FunctionBaseTest {
               .supportsFlatNoNullsFastPath());
     }
   }
+
+  std::vector<Timestamp> stringToTimestamp(
+      std::vector<std::string_view> views) {
+    std::vector<Timestamp> values;
+    values.reserve(views.size());
+    for (auto view : views) {
+      values.emplace_back(
+          util::fromTimestampString(
+              view.data(), view.size(), util::TimestampParseMode::kPrestoCast)
+              .value());
+    }
+    return values;
+  }
 };
 
 template <typename T>
@@ -574,8 +587,9 @@ TEST_F(SimpleFunctionTest, defaultNullBehavior) {
 
   // Check that default null behavior functions don't get called on a null
   // input.
-  EXPECT_NO_THROW(evaluate<SimpleVector<bool>>(
-      "default_null_behavior(c0)", makeRowVector({flatVector})));
+  EXPECT_NO_THROW(
+      evaluate<SimpleVector<bool>>(
+          "default_null_behavior(c0)", makeRowVector({flatVector})));
 }
 
 // Test that function with non-default null behavior receives parameters as
@@ -1141,8 +1155,9 @@ TEST_F(SimpleFunctionTest, callAscii) {
   registerFunction<StringInputIntOutputFunction, int32_t, Varchar>(
       {"get_input_size"});
   auto asciiInput = makeFlatVector<std::string>({"abc123", "10% #\0"});
-  EXPECT_NO_THROW(evaluate<SimpleVector<int32_t>>(
-      "get_input_size(c0)", makeRowVector({asciiInput})));
+  EXPECT_NO_THROW(
+      evaluate<SimpleVector<int32_t>>(
+          "get_input_size(c0)", makeRowVector({asciiInput})));
 }
 
 // Return false always.
@@ -1655,4 +1670,249 @@ TEST_F(SimpleFunctionTest, toDebugString) {
       "Priority: 999997\nDefaultNullBehavior: true");
 }
 
+template <typename T, typename TimeType>
+struct TimePlusOneFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  void call(out_type<TimeType>& out, const arg_type<TimeType>& input) {
+    if constexpr (std::is_same_v<TimeType, Time>) {
+      out = input + 1;
+    } else if constexpr (std::is_same_v<TimeType, TimeMicroUtc>) {
+      out = input / 1000 + 1;
+    }
+  }
+};
+
+template <typename T>
+struct ArrayTimeFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  void call(out_type<Array<Time>>& out, const arg_type<Array<Time>>& input) {
+    for (int i = 0; i < input.size(); i++) {
+      if (input[i].has_value()) {
+        out.push_back(input[i].value());
+      }
+    }
+  }
+
+  void call(
+      out_type<Array<TimeMicroUtc>>& out,
+      const arg_type<Array<TimeMicroUtc>>& input) {
+    for (int i = 0; i < input.size(); i++) {
+      if (input[i].has_value()) {
+        out.push_back(input[i].value() + 1);
+      }
+    }
+  }
+};
+
+TEST_F(SimpleFunctionTest, timeTypeTest) {
+  {
+    registerFunction<ParameterBinder<TimePlusOneFunction, Time>, Time, Time>(
+        {"time_plus_one"});
+    auto data = makeRowVector({
+        makeFlatVector<int64_t>({1000, 2000, 3000}, TIME()),
+    });
+    auto result = evaluate("time_plus_one(c0)", data);
+    auto expected = makeFlatVector<int64_t>({1001, 2001, 3001}, TIME());
+    assertEqualVectors(expected, result);
+  }
+
+  // Test out Time in complex type.
+  {
+    registerFunction<ArrayTimeFunction, Array<Time>, Array<Time>>(
+        {"array_time"});
+
+    auto data = makeRowVector({
+        makeArrayVector<int64_t>({{1, 2, 3}, {4, 5, 6}}, TIME()),
+    });
+
+    auto result = evaluate("array_time(c0)", data);
+    auto expected = makeArrayVector<int64_t>({{1, 2, 3}, {4, 5, 6}}, TIME());
+    assertEqualVectors(expected, result);
+  }
+}
+
+TEST_F(SimpleFunctionTest, timeMicroUtcTypeTest) {
+  {
+    registerFunction<
+        ParameterBinder<TimePlusOneFunction, TimeMicroUtc>,
+        TimeMicroUtc,
+        TimeMicroUtc>({"time_micro_utc_plus_one"});
+    auto data = makeRowVector({
+        makeFlatVector<int64_t>({1000, 2000, 3000}, TIME_MICRO_UTC()),
+    });
+    auto result = evaluate("time_micro_utc_plus_one(c0)", data);
+    auto expected = makeFlatVector<int64_t>({2, 3, 4}, TIME_MICRO_UTC());
+    assertEqualVectors(expected, result);
+  }
+
+  // Test out TimeMicroUtc in complex type.
+  {
+    registerFunction<
+        ArrayTimeFunction,
+        Array<TimeMicroUtc>,
+        Array<TimeMicroUtc>>({"array_time_micro_utc"});
+
+    auto data = makeRowVector({
+        makeArrayVector<int64_t>({{1, 2, 3}, {4, 5, 6}}, TIME_MICRO_UTC()),
+    });
+
+    auto result = evaluate("array_time_micro_utc(c0)", data);
+    auto expected =
+        makeArrayVector<int64_t>({{2, 3, 4}, {5, 6, 7}}, TIME_MICRO_UTC());
+    assertEqualVectors(expected, result);
+  }
+}
+
+template <typename T, typename TTimestamp>
+struct TimestampPlusOneFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  void call(out_type<Timestamp>& out, const arg_type<Timestamp>& input) {
+    if constexpr (std::is_same_v<TTimestamp, Timestamp>) {
+      out = Timestamp::fromMillis(input.toMillis() + 1);
+    } else if constexpr (std::is_same_v<TTimestamp, TimestampUtc>) {
+      out = Timestamp::fromMicros(input.toMicros() + 1);
+    }
+  }
+};
+
+template <typename T>
+struct ArrayTimestampFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  void call(
+      out_type<Array<Timestamp>>& out,
+      const arg_type<Array<Timestamp>>& input) {
+    for (int i = 0; i < input.size(); i++) {
+      if (input[i].has_value()) {
+        out.push_back(Timestamp::fromMillis(input[i].value().toMillis() + 1));
+      }
+    }
+  }
+
+  void call(
+      out_type<Array<TimestampUtc>>& out,
+      const arg_type<Array<TimestampUtc>>& input) {
+    for (int i = 0; i < input.size(); i++) {
+      if (input[i].has_value()) {
+        out.push_back(Timestamp::fromMicros(input[i].value().toMicros() + 1));
+      }
+    }
+  }
+};
+
+TEST_F(SimpleFunctionTest, timestampTypeTest) {
+  std::vector<Timestamp> input = stringToTimestamp({
+      "2015-06-01 19:34:56.007",
+      "2015-06-02 19:34:56.12306",
+      "2001-02-03 03:34:06.056",
+      "1998-03-01 08:01:06.996669",
+      "2022-12-23 03:56:01",
+      "1980-01-24 00:23:07",
+      "1999-12-08 13:39:26.123456",
+      "2023-04-21 09:09:34.5",
+      "2000-09-12 22:36:29",
+      "2007-12-12 04:27:56.999",
+  });
+  std::vector<Timestamp> expected = stringToTimestamp({
+      "2015-06-01 19:34:56.008",
+      "2015-06-02 19:34:56.124",
+      "2001-02-03 03:34:06.057",
+      "1998-03-01 08:01:06.997",
+      "2022-12-23 03:56:01.001",
+      "1980-01-24 00:23:07.001",
+      "1999-12-08 13:39:26.124",
+      "2023-04-21 09:09:34.501",
+      "2000-09-12 22:36:29.001",
+      "2007-12-12 04:27:57.000",
+  });
+
+  {
+    registerFunction<
+        ParameterBinder<TimestampPlusOneFunction, Timestamp>,
+        Timestamp,
+        Timestamp>({"timestamp_plus_one"});
+    auto result = evaluate(
+        "timestamp_plus_one(c0)",
+        makeRowVector({
+            makeFlatVector<Timestamp>(input),
+        }));
+    assertEqualVectors(makeFlatVector<Timestamp>(expected), result);
+  }
+
+  // Test out Timestamp in complex type.
+  {
+    registerFunction<
+        ArrayTimestampFunction,
+        Array<Timestamp>,
+        Array<Timestamp>>({"array_timestamp"});
+
+    auto data = makeRowVector({
+        makeArrayVector<Timestamp>({{input}}),
+    });
+
+    auto result = evaluate("array_timestamp(c0)", data);
+    assertEqualVectors(makeArrayVector<Timestamp>({{expected}}), result);
+  }
+}
+
+TEST_F(SimpleFunctionTest, timestampUtcTypeTest) {
+  std::vector<Timestamp> input = stringToTimestamp({
+      "2015-06-01 19:34:56.007",
+      "2015-06-02 19:34:56.12306",
+      "2001-02-03 03:34:06.056",
+      "1998-03-01 08:01:06.996669",
+      "2022-12-23 03:56:01",
+      "1980-01-24 00:23:07",
+      "1999-12-08 13:39:26.123456",
+      "2023-04-21 09:09:34.5",
+      "2000-09-12 22:36:29",
+      "2007-12-12 04:27:56.999",
+  });
+  std::vector<Timestamp> expected = stringToTimestamp({
+      "2015-06-01 19:34:56.007001",
+      "2015-06-02 19:34:56.123061",
+      "2001-02-03 03:34:06.056001",
+      "1998-03-01 08:01:06.996670",
+      "2022-12-23 03:56:01.000001",
+      "1980-01-24 00:23:07.000001",
+      "1999-12-08 13:39:26.123457",
+      "2023-04-21 09:09:34.500001",
+      "2000-09-12 22:36:29.000001",
+      "2007-12-12 04:27:56.999001",
+  });
+
+  {
+    registerFunction<
+        ParameterBinder<TimestampPlusOneFunction, TimestampUtc>,
+        TimestampUtc,
+        TimestampUtc>({"timestamp_utc_plus_one"});
+    auto result = evaluate(
+        "timestamp_utc_plus_one(c0)",
+        makeRowVector({
+            makeFlatVector<Timestamp>(input, TIMESTAMP_UTC()),
+        }));
+    assertEqualVectors(
+        makeFlatVector<Timestamp>(expected, TIMESTAMP_UTC()), result);
+  }
+
+  // Test out TimestampUtc in complex type.
+  {
+    registerFunction<
+        ArrayTimestampFunction,
+        Array<TimestampUtc>,
+        Array<TimestampUtc>>({"array_timestamp_utc"});
+
+    auto data = makeRowVector({
+        makeArrayVector<Timestamp>({{input}}, TIMESTAMP_UTC()),
+    });
+
+    auto result = evaluate("array_timestamp_utc(c0)", data);
+    assertEqualVectors(
+        makeArrayVector<Timestamp>({{expected}}, TIMESTAMP_UTC()), result);
+  }
+}
+
 } // namespace
diff --git a/velox/expression/tests/SpecialFormRewriteTestBase.cpp b/velox/expression/tests/SpecialFormRewriteTestBase.cpp
new file mode 100644
index 00000000000..279280e0b02
--- /dev/null
+++ b/velox/expression/tests/SpecialFormRewriteTestBase.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/expression/tests/SpecialFormRewriteTestBase.h"
+#include "velox/expression/ExprRewriteRegistry.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+
+namespace facebook::velox::expression::test {
+
+void SpecialFormRewriteTestBase::SetUpTestCase() {
+  memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+}
+
+void SpecialFormRewriteTestBase::SetUp() {
+  functions::prestosql::registerAllScalarFunctions("");
+  parse::registerTypeResolver();
+}
+
+void SpecialFormRewriteTestBase::TearDown() {
+  expression::ExprRewriteRegistry::instance().clear();
+}
+
+void SpecialFormRewriteTestBase::testRewrite(
+    const std::string& expr,
+    const std::string& expected,
+    const RowTypePtr& type) {
+  const auto typedExpr = makeTypedExpr(expr, type);
+  const auto rewritten =
+      expression::ExprRewriteRegistry::instance().rewrite(typedExpr);
+  const auto expectedExpr = makeTypedExpr(expected, type);
+  if (*rewritten != *expectedExpr) {
+    SCOPED_TRACE(fmt::format("Input: {}", typedExpr->toString()));
+    SCOPED_TRACE(fmt::format("Rewritten: {}", rewritten->toString()));
+    SCOPED_TRACE(fmt::format("Expected: {}", expectedExpr->toString()));
+  }
+
+  ASSERT_TRUE(*rewritten == *expectedExpr);
+}
+
+} // namespace facebook::velox::expression::test
diff --git a/velox/expression/tests/SpecialFormRewriteTestBase.h b/velox/expression/tests/SpecialFormRewriteTestBase.h
new file mode 100644
index 00000000000..c792398d6c5
--- /dev/null
+++ b/velox/expression/tests/SpecialFormRewriteTestBase.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+
+namespace facebook::velox::expression::test {
+
+class SpecialFormRewriteTestBase : public functions::test::FunctionBaseTest {
+ protected:
+  static void SetUpTestCase();
+
+  void SetUp() override;
+
+  void TearDown() override;
+
+  /// Validates special form expression rewrites that can short circuit
+  /// expression evaluation.
+  /// @param expr Input SQL expression to be rewritten.
+  /// @param expected Expected SQL expression after rewriting `expr`.
+  /// @param type Row type containing input fields referenced by `expr`.
+  void testRewrite(
+      const std::string& expr,
+      const std::string& expected,
+      const RowTypePtr& type = ROW({}));
+};
+
+} // namespace facebook::velox::expression::test
diff --git a/velox/expression/tests/SwitchRewriteTest.cpp b/velox/expression/tests/SwitchRewriteTest.cpp
new file mode 100644
index 00000000000..c3f955c40e8
--- /dev/null
+++ b/velox/expression/tests/SwitchRewriteTest.cpp
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "velox/expression/tests/SpecialFormRewriteTestBase.h"
+
+namespace facebook::velox::expression {
+namespace {
+
+class SwitchRewriteTest : public expression::test::SpecialFormRewriteTestBase {
+};
+
+TEST_F(SwitchRewriteTest, basic) {
+  const auto type = ROW({"a"}, {BIGINT()});
+  testRewrite("case when false then 1234 when true then a end", "a", type);
+  testRewrite(
+      "case when false then 1234 when false then 3456 else a end", "a", type);
+  testRewrite(
+      "case when false then 100 when a > 2 then 200 when a > 4 then 300 else 5678 end",
+      "case when a > 2 then 200 when a > 4 then 300 else 5678 end",
+      type);
+  testRewrite(
+      "case when a < 5 then 1234 when a > 10 then 3456 when true then 6789 else 0 end",
+      "case when a < 5 then 1234 when a > 10 then 3456 else 6789 end",
+      type);
+}
+
+} // namespace
+} // namespace facebook::velox::expression
diff --git a/velox/expression/tests/VariadicViewTest.cpp b/velox/expression/tests/VariadicViewTest.cpp
index 346da8a43fd..715044d1e63 100644
--- a/velox/expression/tests/VariadicViewTest.cpp
+++ b/velox/expression/tests/VariadicViewTest.cpp
@@ -293,8 +293,9 @@ TEST_F(NullableVariadicViewTest, variadicIntMoreArgs) {
       {makeNullableFlatVector(std::vector<std::optional<int64_t>>{-1, -2, -3}),
        makeNullableFlatVector(
            std::vector<std::optional<int64_t>>{-4, std::nullopt, -6}),
-       makeNullableFlatVector(std::vector<std::optional<int64_t>>{
-           std::nullopt, std::nullopt, std::nullopt})});
+       makeNullableFlatVector(
+           std::vector<std::optional<int64_t>>{
+               std::nullopt, std::nullopt, std::nullopt})});
 }
 
 TEST_F(NullableVariadicViewTest, notNullContainer) {
@@ -351,8 +352,9 @@ TEST_F(NullFreeVariadicViewTest, variadicIntMoreArgs) {
       {makeNullableFlatVector(std::vector<std::optional<int64_t>>{-1, -2, -3}),
        makeNullableFlatVector(
            std::vector<std::optional<int64_t>>{-4, std::nullopt, -6}),
-       makeNullableFlatVector(std::vector<std::optional<int64_t>>{
-           std::nullopt, std::nullopt, std::nullopt})});
+       makeNullableFlatVector(
+           std::vector<std::optional<int64_t>>{
+               std::nullopt, std::nullopt, std::nullopt})});
 }
 
 TEST_F(NullFreeVariadicViewTest, iteratorDifference) {
diff --git a/velox/expression/tests/VectorReaderTest.cpp b/velox/expression/tests/VectorReaderTest.cpp
index 1cf4653ac4e..159a2ad1ede 100644
--- a/velox/expression/tests/VectorReaderTest.cpp
+++ b/velox/expression/tests/VectorReaderTest.cpp
@@ -486,6 +486,64 @@ TEST_F(VectorReaderTest, variadicContainsNull) {
   ASSERT_TRUE(reader.containsNull(3, 6));
 }
 
+TEST_F(VectorReaderTest, variadicHasTopLevelNull) {
+  // Test with scalar types: 2 variadic int32_t fields, 4 rows.
+  // [
+  //   [NULL, 0],   row 0: field1 null
+  //   [1, 1],      row 1: no nulls
+  //   [2, NULL],   row 2: field2 null
+  //   [3, 3],      row 3: no nulls
+  // ]
+  vector_size_t size = 4;
+  auto field1 = makeFlatVector<int32_t>(
+      size,
+      [](vector_size_t row) { return row; },
+      [](vector_size_t row) { return row == 0; });
+  auto field2 = makeFlatVector<int32_t>(
+      size,
+      [](vector_size_t row) { return row; },
+      [](vector_size_t row) { return row == 2; });
+  SelectivityVector rows(size);
+  exec::EvalCtx ctx(&execCtx_);
+  std::vector<std::optional<LocalDecodedVector>> args;
+  for (const auto& vector : {field1, field2}) {
+    args.emplace_back(LocalDecodedVector(ctx, *vector, rows));
+  }
+  exec::VectorReader<Variadic<int32_t>> reader(args, 0);
+
+  ASSERT_TRUE(reader.hasTopLevelNull(0));
+  ASSERT_FALSE(reader.hasTopLevelNull(1));
+  ASSERT_TRUE(reader.hasTopLevelNull(2));
+  ASSERT_FALSE(reader.hasTopLevelNull(3));
+}
+
+TEST_F(VectorReaderTest, variadicHasTopLevelNullComplexType) {
+  // Test with complex types (Array<int32_t>) to verify hasTopLevelNull only
+  // checks top-level nullity.
+  // 2 variadic Array<int32_t> fields, 4 rows:
+  //   row 0: field1=[1,2],     field2=[3,4]
+  //   row 1: field1=NULL,      field2=[5,6]
+  //   row 2: field1=[7,NULL],  field2=[9,10]
+  //   row 3: field1=[11,12],   field2=NULL
+  auto field1 = makeNullableArrayVector<int32_t>(
+      {{{1, 2}}, std::nullopt, {{7, std::nullopt}}, {{11, 12}}});
+  auto field2 = makeNullableArrayVector<int32_t>(
+      {{{3, 4}}, {{5, 6}}, {{9, 10}}, std::nullopt});
+  SelectivityVector rows(4);
+  exec::EvalCtx ctx(&execCtx_);
+  std::vector<std::optional<LocalDecodedVector>> args;
+  for (const auto& vector : {field1, field2}) {
+    args.emplace_back(LocalDecodedVector(ctx, *vector, rows));
+  }
+  exec::VectorReader<Variadic<Array<int32_t>>> reader(args, 0);
+  reader.setChildrenMayHaveNulls();
+
+  ASSERT_FALSE(reader.hasTopLevelNull(0));
+  ASSERT_TRUE(reader.hasTopLevelNull(1));
+  ASSERT_FALSE(reader.hasTopLevelNull(2));
+  ASSERT_TRUE(reader.hasTopLevelNull(3));
+}
+
 TEST_F(VectorReaderTest, dictionaryEncodedVariadicContainsNull) {
   // Vector is:
   // [
diff --git a/velox/external/date/date.h b/velox/external/date/date.h
index b0ae226e29a..75f32444841 100644
--- a/velox/external/date/date.h
+++ b/velox/external/date/date.h
@@ -973,8 +973,8 @@ operator<<(std::basic_ostream<CharT, Traits>& os, const year_month_weekday_last&
 inline namespace literals
 {
 
-CONSTCD11 date::day  operator "" _d(unsigned long long d) NOEXCEPT;
-CONSTCD11 date::year operator "" _y(unsigned long long y) NOEXCEPT;
+CONSTCD11 date::day  operator ""_d(unsigned long long d) NOEXCEPT;
+CONSTCD11 date::year operator ""_y(unsigned long long y) NOEXCEPT;
 
 }  // inline namespace literals
 #endif // !defined(_MSC_VER) || (_MSC_VER >= 1900)
@@ -1883,7 +1883,7 @@ inline namespace literals
 CONSTCD11
 inline
 date::day
-operator "" _d(unsigned long long d) NOEXCEPT
+operator ""_d(unsigned long long d) NOEXCEPT
 {
     return date::day{static_cast<unsigned>(d)};
 }
@@ -1891,7 +1891,7 @@ operator "" _d(unsigned long long d) NOEXCEPT
 CONSTCD11
 inline
 date::year
-operator "" _y(unsigned long long y) NOEXCEPT
+operator ""_y(unsigned long long y) NOEXCEPT
 {
     return date::year(static_cast<int>(y));
 }
diff --git a/velox/external/date/iso_week.h b/velox/external/date/iso_week.h
index e5572b8e419..f1c266616a4 100644
--- a/velox/external/date/iso_week.h
+++ b/velox/external/date/iso_week.h
@@ -343,7 +343,7 @@ inline namespace literals
 CONSTCD11
 inline
 date::year
-operator "" _y(unsigned long long y) NOEXCEPT
+operator ""_y(unsigned long long y) NOEXCEPT
 {
     return date::year(static_cast<int64_t>(y));
 }
@@ -351,7 +351,7 @@ operator "" _y(unsigned long long y) NOEXCEPT
 CONSTCD11
 inline
 iso_week::weeknum
-operator "" _w(unsigned long long wn) NOEXCEPT
+operator ""_w(unsigned long long wn) NOEXCEPT
 {
     return iso_week::weeknum(static_cast<unsigned>(wn));
 }
diff --git a/velox/external/hdfs/ArrowHdfsInternal.cpp b/velox/external/hdfs/ArrowHdfsInternal.cpp
index c9a0c7dd81f..dc22b64ce30 100644
--- a/velox/external/hdfs/ArrowHdfsInternal.cpp
+++ b/velox/external/hdfs/ArrowHdfsInternal.cpp
@@ -62,7 +62,6 @@ namespace {
 
 void* GetLibrarySymbol(LibraryHandle handle, const char* symbol) {
   if (handle == NULL) {
-    printf("handle is null\n");
     return NULL;
   }
 
@@ -72,7 +71,6 @@ void* GetLibrarySymbol(LibraryHandle handle, const char* symbol) {
 
   void* ret = reinterpret_cast<void*>(GetProcAddress(, symbol));
   if (ret == NULL) {
-    printf("ret  is null\n");
     // logstream(LOG_INFO) << "GetProcAddress error: "
     //                     << get_last_err_str(GetLastError()) << std::endl;
   }
diff --git a/velox/external/perfetto/sdk/perfetto.cc b/velox/external/perfetto/sdk/perfetto.cc
index 7e06b05ede2..2ccd11f7b83 100644
--- a/velox/external/perfetto/sdk/perfetto.cc
+++ b/velox/external/perfetto/sdk/perfetto.cc
@@ -115,6 +115,8 @@ void AfterMaybeBlockingSyscall() {}
 #ifndef INCLUDE_PERFETTO_EXT_BASE_ANDROID_UTILS_H_
 #define INCLUDE_PERFETTO_EXT_BASE_ANDROID_UTILS_H_
 
+#include <cstdint>
+#include <optional>
 #include <string>
 
 // gen_amalgamated expanded: #include "perfetto/base/build_config.h"
@@ -131,975 +133,50 @@ std::string GetAndroidProp(const char* name);
 
 #endif  // PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
 
-}  // namespace base
-}  // namespace perfetto
-
-#endif  // INCLUDE_PERFETTO_EXT_BASE_ANDROID_UTILS_H_
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// gen_amalgamated expanded: #include "perfetto/ext/base/android_utils.h"
-
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
-
-#include <string>
-
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-#include <sys/system_properties.h>
-#endif
-
-// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-
-namespace perfetto {
-namespace base {
-
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-
-std::string GetAndroidProp(const char* name) {
-  std::string ret;
-#if __ANDROID_API__ >= 26
-  const prop_info* pi = __system_property_find(name);
-  if (!pi) {
-    return ret;
-  }
-  __system_property_read_callback(
-      pi,
-      [](void* dst_void, const char*, const char* value, uint32_t) {
-        std::string& dst = *static_cast<std::string*>(dst_void);
-        dst = value;
-      },
-      &ret);
-#else  // __ANDROID_API__ < 26
-  char value_buf[PROP_VALUE_MAX];
-  int len = __system_property_get(name, value_buf);
-  if (len > 0 && static_cast<size_t>(len) < sizeof(value_buf)) {
-    ret = std::string(value_buf, static_cast<size_t>(len));
-  }
-#endif
-  return ret;
-}
-
-#endif  // PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-
-}  // namespace base
-}  // namespace perfetto
-// gen_amalgamated begin source: src/base/base64.cc
-// gen_amalgamated begin header: include/perfetto/ext/base/base64.h
-// gen_amalgamated begin header: include/perfetto/ext/base/optional.h
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef INCLUDE_PERFETTO_EXT_BASE_OPTIONAL_H_
-#define INCLUDE_PERFETTO_EXT_BASE_OPTIONAL_H_
-
-#include <functional>
-#include <type_traits>
-#include <utility>
-
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-
-namespace perfetto {
-namespace base {
-
-// Specification:
-// http://en.cppreference.com/w/cpp/utility/optional/in_place_t
-struct in_place_t {};
-
-// Specification:
-// http://en.cppreference.com/w/cpp/utility/optional/nullopt_t
-struct nullopt_t {
-  constexpr explicit nullopt_t(int) {}
-};
-
-// Specification:
-// http://en.cppreference.com/w/cpp/utility/optional/in_place
-constexpr in_place_t in_place = {};
-
-// Specification:
-// http://en.cppreference.com/w/cpp/utility/optional/nullopt
-constexpr nullopt_t nullopt(0);
-
-// Forward declaration, which is referred by following helpers.
-template <typename T>
-class Optional;
-
-namespace internal {
-
-template <typename T, bool = std::is_trivially_destructible<T>::value>
-struct OptionalStorageBase {
-  // Initializing |empty_| here instead of using default member initializing
-  // to avoid errors in g++ 4.8.
-  constexpr OptionalStorageBase() : empty_('\0') {}
-
-  template <class... Args>
-  constexpr explicit OptionalStorageBase(in_place_t, Args&&... args)
-      : is_populated_(true), value_(std::forward<Args>(args)...) {}
-
-  // When T is not trivially destructible we must call its
-  // destructor before deallocating its memory.
-  // Note that this hides the (implicitly declared) move constructor, which
-  // would be used for constexpr move constructor in OptionalStorage<T>.
-  // It is needed iff T is trivially move constructible. However, the current
-  // is_trivially_{copy,move}_constructible implementation requires
-  // is_trivially_destructible (which looks a bug, cf:
-  // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51452 and
-  // http://cplusplus.github.io/LWG/lwg-active.html#2116), so it is not
-  // necessary for this case at the moment. Please see also the destructor
-  // comment in "is_trivially_destructible = true" specialization below.
-  ~OptionalStorageBase() {
-    if (is_populated_)
-      value_.~T();
-  }
-
-  template <class... Args>
-  void Init(Args&&... args) {
-    PERFETTO_DCHECK(!is_populated_);
-    ::new (&value_) T(std::forward<Args>(args)...);
-    is_populated_ = true;
-  }
-
-  bool is_populated_ = false;
-  union {
-    // |empty_| exists so that the union will always be initialized, even when
-    // it doesn't contain a value. Union members must be initialized for the
-    // constructor to be 'constexpr'.
-    char empty_;
-    T value_;
-  };
-};
-
-template <typename T>
-struct OptionalStorageBase<T, true /* trivially destructible */> {
-  // Initializing |empty_| here instead of using default member initializing
-  // to avoid errors in g++ 4.8.
-  constexpr OptionalStorageBase() : empty_('\0') {}
-
-  template <class... Args>
-  constexpr explicit OptionalStorageBase(in_place_t, Args&&... args)
-      : is_populated_(true), value_(std::forward<Args>(args)...) {}
-
-  // When T is trivially destructible (i.e. its destructor does nothing) there
-  // is no need to call it. Implicitly defined destructor is trivial, because
-  // both members (bool and union containing only variants which are trivially
-  // destructible) are trivially destructible.
-  // Explicitly-defaulted destructor is also trivial, but do not use it here,
-  // because it hides the implicit move constructor. It is needed to implement
-  // constexpr move constructor in OptionalStorage iff T is trivially move
-  // constructible. Note that, if T is trivially move constructible, the move
-  // constructor of OptionalStorageBase<T> is also implicitly defined and it is
-  // trivially move constructor. If T is not trivially move constructible,
-  // "not declaring move constructor without destructor declaration" here means
-  // "delete move constructor", which works because any move constructor of
-  // OptionalStorage will not refer to it in that case.
-
-  template <class... Args>
-  void Init(Args&&... args) {
-    PERFETTO_DCHECK(!is_populated_);
-    ::new (&value_) T(std::forward<Args>(args)...);
-    is_populated_ = true;
-  }
-
-  bool is_populated_ = false;
-  union {
-    // |empty_| exists so that the union will always be initialized, even when
-    // it doesn't contain a value. Union members must be initialized for the
-    // constructor to be 'constexpr'.
-    char empty_;
-    T value_;
-  };
-};
-
-// Implement conditional constexpr copy and move constructors. These are
-// constexpr if is_trivially_{copy,move}_constructible<T>::value is true
-// respectively. If each is true, the corresponding constructor is defined as
-// "= default;", which generates a constexpr constructor (In this case,
-// the condition of constexpr-ness is satisfied because the base class also has
-// compiler generated constexpr {copy,move} constructors). Note that
-// placement-new is prohibited in constexpr.
-template <typename T, bool = std::is_trivially_copy_constructible<T>::value>
-struct OptionalStorage : OptionalStorageBase<T> {
-  // This is no trivially {copy,move} constructible case. Other cases are
-  // defined below as specializations.
-
-  // Accessing the members of template base class requires explicit
-  // declaration.
-  using OptionalStorageBase<T>::is_populated_;
-  using OptionalStorageBase<T>::value_;
-  using OptionalStorageBase<T>::Init;
-
-  // Inherit constructors (specifically, the in_place constructor).
-  using OptionalStorageBase<T>::OptionalStorageBase;
-
-  // User defined constructor deletes the default constructor.
-  // Define it explicitly.
-  OptionalStorage() = default;
-
-  OptionalStorage(const OptionalStorage& other) : OptionalStorageBase<T>() {
-    if (other.is_populated_)
-      Init(other.value_);
-  }
-
-  OptionalStorage(OptionalStorage&& other) noexcept(
-      std::is_nothrow_move_constructible<T>::value) {
-    if (other.is_populated_)
-      Init(std::move(other.value_));
-  }
-};
-
-template <typename T>
-struct OptionalStorage<T, true /* trivially copy constructible */>
-    : OptionalStorageBase<T> {
-  using OptionalStorageBase<T>::is_populated_;
-  using OptionalStorageBase<T>::value_;
-  using OptionalStorageBase<T>::Init;
-  using OptionalStorageBase<T>::OptionalStorageBase;
-
-  OptionalStorage() = default;
-  OptionalStorage(const OptionalStorage& other) = default;
-
-  OptionalStorage(OptionalStorage&& other) noexcept(
-      std::is_nothrow_move_constructible<T>::value) {
-    if (other.is_populated_)
-      Init(std::move(other.value_));
-  }
-};
-
-// Base class to support conditionally usable copy-/move- constructors
-// and assign operators.
-template <typename T>
-class OptionalBase {
-  // This class provides implementation rather than public API, so everything
-  // should be hidden. Often we use composition, but we cannot in this case
-  // because of C++ language restriction.
- protected:
-  constexpr OptionalBase() = default;
-  constexpr OptionalBase(const OptionalBase& other) = default;
-  constexpr OptionalBase(OptionalBase&& other) = default;
-
-  template <class... Args>
-  constexpr explicit OptionalBase(in_place_t, Args&&... args)
-      : storage_(in_place, std::forward<Args>(args)...) {}
-
-  // Implementation of converting constructors.
-  template <typename U>
-  explicit OptionalBase(const OptionalBase<U>& other) {
-    if (other.storage_.is_populated_)
-      storage_.Init(other.storage_.value_);
-  }
-
-  template <typename U>
-  explicit OptionalBase(OptionalBase<U>&& other) {
-    if (other.storage_.is_populated_)
-      storage_.Init(std::move(other.storage_.value_));
-  }
-
-  ~OptionalBase() = default;
-
-  OptionalBase& operator=(const OptionalBase& other) {
-    CopyAssign(other);
-    return *this;
-  }
-
-  OptionalBase& operator=(OptionalBase&& other) noexcept(
-      std::is_nothrow_move_assignable<T>::value&&
-          std::is_nothrow_move_constructible<T>::value) {
-    MoveAssign(std::move(other));
-    return *this;
-  }
-
-  template <typename U>
-  void CopyAssign(const OptionalBase<U>& other) {
-    if (other.storage_.is_populated_)
-      InitOrAssign(other.storage_.value_);
-    else
-      FreeIfNeeded();
-  }
-
-  template <typename U>
-  void MoveAssign(OptionalBase<U>&& other) {
-    if (other.storage_.is_populated_)
-      InitOrAssign(std::move(other.storage_.value_));
-    else
-      FreeIfNeeded();
-  }
-
-  template <typename U>
-  void InitOrAssign(U&& value) {
-    if (storage_.is_populated_)
-      storage_.value_ = std::forward<U>(value);
-    else
-      storage_.Init(std::forward<U>(value));
-  }
-
-  void FreeIfNeeded() {
-    if (!storage_.is_populated_)
-      return;
-    storage_.value_.~T();
-    storage_.is_populated_ = false;
-  }
-
-  // For implementing conversion, allow access to other typed OptionalBase
-  // class.
-  template <typename U>
-  friend class OptionalBase;
-
-  OptionalStorage<T> storage_;
-};
-
-// The following {Copy,Move}{Constructible,Assignable} structs are helpers to
-// implement constructor/assign-operator overloading. Specifically, if T is
-// is not movable but copyable, Optional<T>'s move constructor should not
-// participate in overload resolution. This inheritance trick implements that.
-template <bool is_copy_constructible>
-struct CopyConstructible {};
-
-template <>
-struct CopyConstructible<false> {
-  constexpr CopyConstructible() = default;
-  constexpr CopyConstructible(const CopyConstructible&) = delete;
-  constexpr CopyConstructible(CopyConstructible&&) = default;
-  CopyConstructible& operator=(const CopyConstructible&) = default;
-  CopyConstructible& operator=(CopyConstructible&&) = default;
-};
-
-template <bool is_move_constructible>
-struct MoveConstructible {};
-
-template <>
-struct MoveConstructible<false> {
-  constexpr MoveConstructible() = default;
-  constexpr MoveConstructible(const MoveConstructible&) = default;
-  constexpr MoveConstructible(MoveConstructible&&) = delete;
-  MoveConstructible& operator=(const MoveConstructible&) = default;
-  MoveConstructible& operator=(MoveConstructible&&) = default;
-};
-
-template <bool is_copy_assignable>
-struct CopyAssignable {};
-
-template <>
-struct CopyAssignable<false> {
-  constexpr CopyAssignable() = default;
-  constexpr CopyAssignable(const CopyAssignable&) = default;
-  constexpr CopyAssignable(CopyAssignable&&) = default;
-  CopyAssignable& operator=(const CopyAssignable&) = delete;
-  CopyAssignable& operator=(CopyAssignable&&) = default;
-};
-
-template <bool is_move_assignable>
-struct MoveAssignable {};
-
-template <>
-struct MoveAssignable<false> {
-  constexpr MoveAssignable() = default;
-  constexpr MoveAssignable(const MoveAssignable&) = default;
-  constexpr MoveAssignable(MoveAssignable&&) = default;
-  MoveAssignable& operator=(const MoveAssignable&) = default;
-  MoveAssignable& operator=(MoveAssignable&&) = delete;
-};
-
-// Helper to conditionally enable converting constructors and assign operators.
-template <typename T, typename U>
-struct IsConvertibleFromOptional
-    : std::integral_constant<
-          bool,
-          std::is_constructible<T, Optional<U>&>::value ||
-              std::is_constructible<T, const Optional<U>&>::value ||
-              std::is_constructible<T, Optional<U>&&>::value ||
-              std::is_constructible<T, const Optional<U>&&>::value ||
-              std::is_convertible<Optional<U>&, T>::value ||
-              std::is_convertible<const Optional<U>&, T>::value ||
-              std::is_convertible<Optional<U>&&, T>::value ||
-              std::is_convertible<const Optional<U>&&, T>::value> {};
-
-template <typename T, typename U>
-struct IsAssignableFromOptional
-    : std::integral_constant<
-          bool,
-          IsConvertibleFromOptional<T, U>::value ||
-              std::is_assignable<T&, Optional<U>&>::value ||
-              std::is_assignable<T&, const Optional<U>&>::value ||
-              std::is_assignable<T&, Optional<U>&&>::value ||
-              std::is_assignable<T&, const Optional<U>&&>::value> {};
-
-// Forward compatibility for C++17.
-// Introduce one more deeper nested namespace to avoid leaking using std::swap.
-namespace swappable_impl {
-using std::swap;
-
-struct IsSwappableImpl {
-  // Tests if swap can be called. Check<T&>(0) returns true_type iff swap is
-  // available for T. Otherwise, Check's overload resolution falls back to
-  // Check(...) declared below thanks to SFINAE, so returns false_type.
-  template <typename T>
-  static auto Check(int)
-      -> decltype(swap(std::declval<T>(), std::declval<T>()), std::true_type());
-
-  template <typename T>
-  static std::false_type Check(...);
+struct Utsname {
+  std::string sysname;
+  std::string version;
+  std::string machine;
+  std::string release;
 };
-}  // namespace swappable_impl
-
-template <typename T>
-struct IsSwappable : decltype(swappable_impl::IsSwappableImpl::Check<T&>(0)) {};
-
-// Forward compatibility for C++20.
-template <typename T>
-using RemoveCvRefT =
-    typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-
-}  // namespace internal
-
-// On Windows, by default, empty-base class optimization does not work,
-// which means even if the base class is empty struct, it still consumes one
-// byte for its body. __declspec(empty_bases) enables the optimization.
-// cf)
-// https://blogs.msdn.microsoft.com/vcblog/2016/03/30/optimizing-the-layout-of-empty-base-classes-in-vs2015-update-2-3/
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) && \
-    !PERFETTO_BUILDFLAG(PERFETTO_COMPILER_GCC)
-#define OPTIONAL_DECLSPEC_EMPTY_BASES __declspec(empty_bases)
-#else
-#define OPTIONAL_DECLSPEC_EMPTY_BASES
-#endif
-
-// base::Optional is a Chromium version of the C++17 optional class:
-// std::optional documentation:
-// http://en.cppreference.com/w/cpp/utility/optional
-// Chromium documentation:
-// https://chromium.googlesource.com/chromium/src/+/master/docs/optional.md
-//
-// These are the differences between the specification and the implementation:
-// - Constructors do not use 'constexpr' as it is a C++14 extension.
-// - 'constexpr' might be missing in some places for reasons specified locally.
-// - No exceptions are thrown, because they are banned from Chromium.
-//   Marked noexcept for only move constructor and move assign operators.
-// - All the non-members are in the 'base' namespace instead of 'std'.
-//
-// Note that T cannot have a constructor T(Optional<T>) etc. Optional<T>
-// PERFETTO_CHECKs T's constructor (specifically via IsConvertibleFromOptional),
-// and in the PERFETTO_CHECK whether T can be constructible from Optional<T>,
-// which is recursive so it does not work. As of Feb 2018, std::optional C++17
-// implementation in both clang and gcc has same limitation. MSVC SFINAE looks
-// to have different behavior, but anyway it reports an error, too.
-//
-// This file is a modified version of optional.h from Chromium at revision
-// 5e71bd454e60511c1293c0c686544aaa76094424. The changes remove C++14/C++17
-// specific code and replace with C++11 counterparts.
-template <typename T>
-class OPTIONAL_DECLSPEC_EMPTY_BASES Optional
-    : public internal::OptionalBase<T>,
-      public internal::CopyConstructible<std::is_copy_constructible<T>::value>,
-      public internal::MoveConstructible<std::is_move_constructible<T>::value>,
-      public internal::CopyAssignable<std::is_copy_constructible<T>::value &&
-                                      std::is_copy_assignable<T>::value>,
-      public internal::MoveAssignable<std::is_move_constructible<T>::value &&
-                                      std::is_move_assignable<T>::value> {
- public:
-#undef OPTIONAL_DECLSPEC_EMPTY_BASES
-  using value_type = T;
-
-  // Defer default/copy/move constructor implementation to OptionalBase.
-  constexpr Optional() = default;
-  constexpr Optional(const Optional& other) = default;
-  constexpr Optional(Optional&& other) noexcept(
-      std::is_nothrow_move_constructible<T>::value) = default;
-
-  constexpr Optional(nullopt_t) {}  // NOLINT(runtime/explicit)
-
-  // Converting copy constructor. "explicit" only if
-  // std::is_convertible<const U&, T>::value is false. It is implemented by
-  // declaring two almost same constructors, but that condition in enable_if_t
-  // is different, so that either one is chosen, thanks to SFINAE.
-  template <typename U,
-            typename std::enable_if<
-                std::is_constructible<T, const U&>::value &&
-                    !internal::IsConvertibleFromOptional<T, U>::value &&
-                    std::is_convertible<const U&, T>::value,
-                bool>::type = false>
-  Optional(const Optional<U>& other) : internal::OptionalBase<T>(other) {}
-
-  template <typename U,
-            typename std::enable_if<
-                std::is_constructible<T, const U&>::value &&
-                    !internal::IsConvertibleFromOptional<T, U>::value &&
-                    !std::is_convertible<const U&, T>::value,
-                bool>::type = false>
-  explicit Optional(const Optional<U>& other)
-      : internal::OptionalBase<T>(other) {}
-
-  // Converting move constructor. Similar to converting copy constructor,
-  // declaring two (explicit and non-explicit) constructors.
-  template <typename U,
-            typename std::enable_if<
-                std::is_constructible<T, U&&>::value &&
-                    !internal::IsConvertibleFromOptional<T, U>::value &&
-                    std::is_convertible<U&&, T>::value,
-                bool>::type = false>
-  Optional(Optional<U>&& other) : internal::OptionalBase<T>(std::move(other)) {}
-
-  template <typename U,
-            typename std::enable_if<
-                std::is_constructible<T, U&&>::value &&
-                    !internal::IsConvertibleFromOptional<T, U>::value &&
-                    !std::is_convertible<U&&, T>::value,
-                bool>::type = false>
-  explicit Optional(Optional<U>&& other)
-      : internal::OptionalBase<T>(std::move(other)) {}
-
-  template <class... Args>
-  constexpr explicit Optional(in_place_t, Args&&... args)
-      : internal::OptionalBase<T>(in_place, std::forward<Args>(args)...) {}
-
-  template <class U,
-            class... Args,
-            class = typename std::enable_if<
-                std::is_constructible<value_type,
-                                      std::initializer_list<U>&,
-                                      Args...>::value>::type>
-  constexpr explicit Optional(in_place_t,
-                              std::initializer_list<U> il,
-                              Args&&... args)
-      : internal::OptionalBase<T>(in_place, il, std::forward<Args>(args)...) {}
-
-  // Forward value constructor. Similar to converting constructors,
-  // conditionally explicit.
-  template <
-      typename U = value_type,
-      typename std::enable_if<
-          std::is_constructible<T, U&&>::value &&
-              !std::is_same<internal::RemoveCvRefT<U>, in_place_t>::value &&
-              !std::is_same<internal::RemoveCvRefT<U>, Optional<T>>::value &&
-              std::is_convertible<U&&, T>::value,
-          bool>::type = false>
-  constexpr Optional(U&& value)
-      : internal::OptionalBase<T>(in_place, std::forward<U>(value)) {}
-
-  template <
-      typename U = value_type,
-      typename std::enable_if<
-          std::is_constructible<T, U&&>::value &&
-              !std::is_same<internal::RemoveCvRefT<U>, in_place_t>::value &&
-              !std::is_same<internal::RemoveCvRefT<U>, Optional<T>>::value &&
-              !std::is_convertible<U&&, T>::value,
-          bool>::type = false>
-  constexpr explicit Optional(U&& value)
-      : internal::OptionalBase<T>(in_place, std::forward<U>(value)) {}
-
-  ~Optional() = default;
-
-  // Defer copy-/move- assign operator implementation to OptionalBase.
-  Optional& operator=(const Optional& other) = default;
-  Optional& operator=(Optional&& other) noexcept(
-      std::is_nothrow_move_assignable<T>::value&&
-          std::is_nothrow_move_constructible<T>::value) = default;
-
-  Optional& operator=(nullopt_t) {
-    FreeIfNeeded();
-    return *this;
-  }
-
-  // Perfect-forwarded assignment.
-  template <typename U>
-  typename std::enable_if<
-      !std::is_same<internal::RemoveCvRefT<U>, Optional<T>>::value &&
-          std::is_constructible<T, U>::value &&
-          std::is_assignable<T&, U>::value &&
-          (!std::is_scalar<T>::value ||
-           !std::is_same<typename std::decay<U>::type, T>::value),
-      Optional&>::type
-  operator=(U&& value) {
-    InitOrAssign(std::forward<U>(value));
-    return *this;
-  }
-
-  // Copy assign the state of other.
-  template <typename U>
-  typename std::enable_if<!internal::IsAssignableFromOptional<T, U>::value &&
-                              std::is_constructible<T, const U&>::value &&
-                              std::is_assignable<T&, const U&>::value,
-                          Optional&>::type
-  operator=(const Optional<U>& other) {
-    CopyAssign(other);
-    return *this;
-  }
-
-  // Move assign the state of other.
-  template <typename U>
-  typename std::enable_if<!internal::IsAssignableFromOptional<T, U>::value &&
-                              std::is_constructible<T, U>::value &&
-                              std::is_assignable<T&, U>::value,
-                          Optional&>::type
-  operator=(Optional<U>&& other) {
-    MoveAssign(std::move(other));
-    return *this;
-  }
-
-  const T* operator->() const {
-    PERFETTO_DCHECK(storage_.is_populated_);
-    return &storage_.value_;
-  }
-
-  T* operator->() {
-    PERFETTO_DCHECK(storage_.is_populated_);
-    return &storage_.value_;
-  }
-
-  const T& operator*() const& {
-    PERFETTO_DCHECK(storage_.is_populated_);
-    return storage_.value_;
-  }
-
-  T& operator*() & {
-    PERFETTO_DCHECK(storage_.is_populated_);
-    return storage_.value_;
-  }
-
-  const T&& operator*() const&& {
-    PERFETTO_DCHECK(storage_.is_populated_);
-    return std::move(storage_.value_);
-  }
-
-  T&& operator*() && {
-    PERFETTO_DCHECK(storage_.is_populated_);
-    return std::move(storage_.value_);
-  }
-
-  constexpr explicit operator bool() const { return storage_.is_populated_; }
-
-  constexpr bool has_value() const { return storage_.is_populated_; }
-
-  T& value() & {
-    PERFETTO_CHECK(storage_.is_populated_);
-    return storage_.value_;
-  }
-
-  const T& value() const& {
-    PERFETTO_CHECK(storage_.is_populated_);
-    return storage_.value_;
-  }
-
-  T&& value() && {
-    PERFETTO_CHECK(storage_.is_populated_);
-    return std::move(storage_.value_);
-  }
-
-  const T&& value() const&& {
-    PERFETTO_CHECK(storage_.is_populated_);
-    return std::move(storage_.value_);
-  }
-
-  template <class U>
-  constexpr T value_or(U&& default_value) const& {
-    static_assert(std::is_convertible<U, T>::value,
-                  "U must be convertible to T");
-    return storage_.is_populated_
-               ? storage_.value_
-               : static_cast<T>(std::forward<U>(default_value));
-  }
-
-  template <class U>
-  T value_or(U&& default_value) && {
-    static_assert(std::is_convertible<U, T>::value,
-                  "U must be convertible to T");
-    return storage_.is_populated_
-               ? std::move(storage_.value_)
-               : static_cast<T>(std::forward<U>(default_value));
-  }
-
-  void swap(Optional& other) {
-    if (!storage_.is_populated_ && !other.storage_.is_populated_)
-      return;
-
-    if (storage_.is_populated_ != other.storage_.is_populated_) {
-      if (storage_.is_populated_) {
-        other.storage_.Init(std::move(storage_.value_));
-        FreeIfNeeded();
-      } else {
-        storage_.Init(std::move(other.storage_.value_));
-        other.FreeIfNeeded();
-      }
-      return;
-    }
-
-    PERFETTO_DCHECK(storage_.is_populated_ && other.storage_.is_populated_);
-    using std::swap;
-    swap(**this, *other);
-  }
-
-  void reset() { FreeIfNeeded(); }
-
-  template <class... Args>
-  T& emplace(Args&&... args) {
-    FreeIfNeeded();
-    storage_.Init(std::forward<Args>(args)...);
-    return storage_.value_;
-  }
-
-  template <class U, class... Args>
-  typename std::enable_if<
-      std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value,
-      T&>::type
-  emplace(std::initializer_list<U> il, Args&&... args) {
-    FreeIfNeeded();
-    storage_.Init(il, std::forward<Args>(args)...);
-    return storage_.value_;
-  }
 
- private:
-  // Accessing template base class's protected member needs explicit
-  // declaration to do so.
-  using internal::OptionalBase<T>::CopyAssign;
-  using internal::OptionalBase<T>::FreeIfNeeded;
-  using internal::OptionalBase<T>::InitOrAssign;
-  using internal::OptionalBase<T>::MoveAssign;
-  using internal::OptionalBase<T>::storage_;
+struct SystemInfo {
+  std::optional<int32_t> timezone_off_mins;
+  std::optional<Utsname> utsname_info;
+  std::optional<uint32_t> page_size;
+  std::optional<uint32_t> num_cpus;
+  std::optional<uint64_t> system_ram_bytes;
+  std::string android_build_fingerprint;
+  std::string android_device_manufacturer;
+  std::optional<uint64_t> android_sdk_version;
+  std::string android_soc_model;
+  std::string android_guest_soc_model;
+  std::string android_hardware_revision;
+  std::string android_storage_model;
+  std::string android_ram_model;
+  std::string android_serial_console;
 };
 
-// Here after defines comparation operators. The definition follows
-// http://en.cppreference.com/w/cpp/utility/optional/operator_cmp
-// while bool() casting is replaced by has_value() to meet the chromium
-// style guide.
-template <class T, class U>
-bool operator==(const Optional<T>& lhs, const Optional<U>& rhs) {
-  if (lhs.has_value() != rhs.has_value())
-    return false;
-  if (!lhs.has_value())
-    return true;
-  return *lhs == *rhs;
-}
-
-template <class T, class U>
-bool operator!=(const Optional<T>& lhs, const Optional<U>& rhs) {
-  if (lhs.has_value() != rhs.has_value())
-    return true;
-  if (!lhs.has_value())
-    return false;
-  return *lhs != *rhs;
-}
-
-template <class T, class U>
-bool operator<(const Optional<T>& lhs, const Optional<U>& rhs) {
-  if (!rhs.has_value())
-    return false;
-  if (!lhs.has_value())
-    return true;
-  return *lhs < *rhs;
-}
-
-template <class T, class U>
-bool operator<=(const Optional<T>& lhs, const Optional<U>& rhs) {
-  if (!lhs.has_value())
-    return true;
-  if (!rhs.has_value())
-    return false;
-  return *lhs <= *rhs;
-}
-
-template <class T, class U>
-bool operator>(const Optional<T>& lhs, const Optional<U>& rhs) {
-  if (!lhs.has_value())
-    return false;
-  if (!rhs.has_value())
-    return true;
-  return *lhs > *rhs;
-}
-
-template <class T, class U>
-bool operator>=(const Optional<T>& lhs, const Optional<U>& rhs) {
-  if (!rhs.has_value())
-    return true;
-  if (!lhs.has_value())
-    return false;
-  return *lhs >= *rhs;
-}
-
-template <class T>
-constexpr bool operator==(const Optional<T>& opt, nullopt_t) {
-  return !opt;
-}
-
-template <class T>
-constexpr bool operator==(nullopt_t, const Optional<T>& opt) {
-  return !opt;
-}
-
-template <class T>
-constexpr bool operator!=(const Optional<T>& opt, nullopt_t) {
-  return opt.has_value();
-}
-
-template <class T>
-constexpr bool operator!=(nullopt_t, const Optional<T>& opt) {
-  return opt.has_value();
-}
-
-template <class T>
-constexpr bool operator<(const Optional<T>&, nullopt_t) {
-  return false;
-}
-
-template <class T>
-constexpr bool operator<(nullopt_t, const Optional<T>& opt) {
-  return opt.has_value();
-}
-
-template <class T>
-constexpr bool operator<=(const Optional<T>& opt, nullopt_t) {
-  return !opt;
-}
-
-template <class T>
-constexpr bool operator<=(nullopt_t, const Optional<T>&) {
-  return true;
-}
-
-template <class T>
-constexpr bool operator>(const Optional<T>& opt, nullopt_t) {
-  return opt.has_value();
-}
-
-template <class T>
-constexpr bool operator>(nullopt_t, const Optional<T>&) {
-  return false;
-}
-
-template <class T>
-constexpr bool operator>=(const Optional<T>&, nullopt_t) {
-  return true;
-}
-
-template <class T>
-constexpr bool operator>=(nullopt_t, const Optional<T>& opt) {
-  return !opt;
-}
-
-template <class T, class U>
-constexpr bool operator==(const Optional<T>& opt, const U& value) {
-  return opt.has_value() ? *opt == value : false;
-}
-
-template <class T, class U>
-constexpr bool operator==(const U& value, const Optional<T>& opt) {
-  return opt.has_value() ? value == *opt : false;
-}
-
-template <class T, class U>
-constexpr bool operator!=(const Optional<T>& opt, const U& value) {
-  return opt.has_value() ? *opt != value : true;
-}
-
-template <class T, class U>
-constexpr bool operator!=(const U& value, const Optional<T>& opt) {
-  return opt.has_value() ? value != *opt : true;
-}
-
-template <class T, class U>
-constexpr bool operator<(const Optional<T>& opt, const U& value) {
-  return opt.has_value() ? *opt < value : true;
-}
-
-template <class T, class U>
-constexpr bool operator<(const U& value, const Optional<T>& opt) {
-  return opt.has_value() ? value < *opt : false;
-}
-
-template <class T, class U>
-constexpr bool operator<=(const Optional<T>& opt, const U& value) {
-  return opt.has_value() ? *opt <= value : true;
-}
-
-template <class T, class U>
-constexpr bool operator<=(const U& value, const Optional<T>& opt) {
-  return opt.has_value() ? value <= *opt : false;
-}
-
-template <class T, class U>
-constexpr bool operator>(const Optional<T>& opt, const U& value) {
-  return opt.has_value() ? *opt > value : false;
-}
-
-template <class T, class U>
-constexpr bool operator>(const U& value, const Optional<T>& opt) {
-  return opt.has_value() ? value > *opt : true;
-}
-
-template <class T, class U>
-constexpr bool operator>=(const Optional<T>& opt, const U& value) {
-  return opt.has_value() ? *opt >= value : false;
-}
-
-template <class T, class U>
-constexpr bool operator>=(const U& value, const Optional<T>& opt) {
-  return opt.has_value() ? value >= *opt : true;
-}
-
-template <class T>
-constexpr Optional<typename std::decay<T>::type> make_optional(T&& value) {
-  return Optional<typename std::decay<T>::type>(std::forward<T>(value));
-}
+// Returns the device's utsname information.
+Utsname GetUtsname();
 
-template <class T, class... Args>
-constexpr Optional<T> make_optional(Args&&... args) {
-  return Optional<T>(in_place, std::forward<Args>(args)...);
-}
-
-template <class T, class U, class... Args>
-constexpr Optional<T> make_optional(std::initializer_list<U> il,
-                                    Args&&... args) {
-  return Optional<T>(in_place, il, std::forward<Args>(args)...);
-}
+// Returns the device's system information.
+SystemInfo GetSystemInfo();
 
-// Partial specialization for a function template is not allowed. Also, it is
-// not allowed to add overload function to std namespace, while it is allowed
-// to specialize the template in std. Thus, swap() (kind of) overloading is
-// defined in base namespace, instead.
-template <class T>
-typename std::enable_if<std::is_move_constructible<T>::value &&
-                        internal::IsSwappable<T>::value>::type
-swap(Optional<T>& lhs, Optional<T>& rhs) {
-  lhs.swap(rhs);
-}
+// Returns the perfetto machine name. The PERFETTO_MACHINE_NAME env variable
+// has the highest precedence in setting the machine name. In Android systems,
+// if the env variable isn't set then the traced.machine_name system property
+// is used. If no value is externally set, then the OS system name
+// (see `uname -s`) is used as the default machine name.
+std::string GetPerfettoMachineName();
 
 }  // namespace base
 }  // namespace perfetto
 
-template <class T>
-struct std::hash<perfetto::base::Optional<T>> {
-  size_t operator()(const perfetto::base::Optional<T>& opt) const {
-    return opt == perfetto::base::nullopt ? 0 : std::hash<T>()(*opt);
-  }
-};
-
-#endif  // INCLUDE_PERFETTO_EXT_BASE_OPTIONAL_H_
+#endif  // INCLUDE_PERFETTO_EXT_BASE_ANDROID_UTILS_H_
+// gen_amalgamated begin header: include/perfetto/ext/base/string_utils.h
 // gen_amalgamated begin header: include/perfetto/ext/base/string_view.h
-// gen_amalgamated begin header: include/perfetto/ext/base/hash.h
+// gen_amalgamated begin header: include/perfetto/ext/base/fnv_hash.h
 /*
  * Copyright (C) 2019 The Android Open Source Project
  *
@@ -1116,26 +193,25 @@ struct std::hash<perfetto::base::Optional<T>> {
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_EXT_BASE_HASH_H_
-#define INCLUDE_PERFETTO_EXT_BASE_HASH_H_
+#ifndef INCLUDE_PERFETTO_EXT_BASE_FNV_HASH_H_
+#define INCLUDE_PERFETTO_EXT_BASE_FNV_HASH_H_
 
 #include <stddef.h>
 #include <stdint.h>
-#include <string>
+#include <string_view>
 #include <type_traits>
 #include <utility>
 
-namespace perfetto {
-namespace base {
+namespace perfetto::base {
 
 // A helper class which computes a 64-bit hash of the input data.
 // The algorithm used is FNV-1a as it is fast and easy to implement and has
 // relatively few collisions.
 // WARNING: This hash function should not be used for any cryptographic purpose.
-class Hasher {
+class FnvHasher {
  public:
   // Creates an empty hash object
-  Hasher() {}
+  constexpr FnvHasher() = default;
 
   // Hashes a numeric value.
   template <
@@ -1145,14 +221,16 @@ class Hasher {
     Update(reinterpret_cast<const char*>(&data), sizeof(data));
   }
 
+  constexpr void Update(char c) { return Update(&c, 1); }
+
   // Using the loop instead of "Update(str, strlen(str))" to avoid looping twice
-  void Update(const char* str) {
+  constexpr void Update(const char* str) {
     for (const auto* p = str; *p; ++p)
       Update(*p);
   }
 
   // Hashes a byte array.
-  void Update(const char* data, size_t size) {
+  constexpr void Update(const char* data, size_t size) {
     for (size_t i = 0; i < size; i++) {
       result_ ^= static_cast<uint8_t>(data[i]);
       // Note: Arithmetic overflow of unsigned integers is well defined in C++
@@ -1162,32 +240,48 @@ class Hasher {
     }
   }
 
-  // Allow hashing anything that has a |data| field, a |size| field,
-  // and has the kHashable trait (e.g., base::StringView).
-  template <typename T, typename = std::enable_if<T::kHashable>>
-  void Update(const T& t) {
-    Update(t.data(), t.size());
+  // Allow hashing anything that has `data` and `size` and has the kHashable
+  // trait (e.g., base::StringView).
+  template <typename T, typename = std::enable_if_t<T::kHashable>>
+  constexpr void Update(const T& t) {
+    if constexpr (std::is_member_function_pointer_v<decltype(&T::data)>) {
+      Update(t.data(), t.size());
+    } else {
+      Update(t.data, t.size);
+    }
   }
 
-  void Update(const std::string& s) { Update(s.data(), s.size()); }
+  constexpr void Update(std::string_view s) { Update(s.data(), s.size()); }
 
-  uint64_t digest() const { return result_; }
+  constexpr uint64_t digest() const { return result_; }
 
   // Usage:
-  // uint64_t hashed_value = Hash::Combine(33, false, "ABC", 458L, 3u, 'x');
+  // uint64_t hashed_value =
+  //    FnvHasher::Combine(33, false, "ABC", 458L, 3u, 'x');
   template <typename... Ts>
-  static uint64_t Combine(Ts&&... args) {
-    Hasher hasher;
+  static constexpr uint64_t Combine(Ts&&... args) {
+    FnvHasher hasher;
     hasher.UpdateAll(std::forward<Ts>(args)...);
     return hasher.digest();
   }
 
+  // Creates a hasher with `args` already hashed.
+  //
+  // Usage:
+  // FnvHasher partial = FnvHasher::CreatePartial(33, false, "ABC", 458L);
+  template <typename... Ts>
+  static constexpr FnvHasher CreatePartial(Ts&&... args) {
+    FnvHasher hasher;
+    hasher.UpdateAll(std::forward<Ts>(args)...);
+    return hasher;
+  }
+
   // `hasher.UpdateAll(33, false, "ABC")` is shorthand for:
   // `hasher.Update(33); hasher.Update(false); hasher.Update("ABC");`
-  void UpdateAll() {}
+  constexpr void UpdateAll() {}
 
   template <typename T, typename... Ts>
-  void UpdateAll(T&& arg, Ts&&... args) {
+  constexpr void UpdateAll(T&& arg, Ts&&... args) {
     Update(arg);
     UpdateAll(std::forward<Ts>(args)...);
   }
@@ -1199,29 +293,19 @@ class Hasher {
   uint64_t result_ = kFnv1a64OffsetBasis;
 };
 
-// This is for using already-hashed key into std::unordered_map and avoid the
-// cost of re-hashing. Example:
-// unordered_map<uint64_t, Value, AlreadyHashed> my_map.
-template <typename T>
-struct AlreadyHashed {
-  size_t operator()(const T& x) const { return static_cast<size_t>(x); }
-};
-
-// base::Hash uses base::Hasher for integer values and falls base to std::hash
-// for other types. This is needed as std::hash for integers is just the
-// identity function and Perfetto uses open-addressing hash table, which are
+// base::FnvHash uses base::FnvHasher for integer values and falls back to
+// std::hash for other types. This is needed as std::hash for integers is just
+// the identity function and Perfetto uses open-addressing hash table, which are
 // very sensitive to hash quality and are known to degrade in performance
 // when using std::hash.
 template <typename T>
-struct Hash {
-  // Version for ints, using base::Hasher.
+struct FnvHash {
+  // Version for ints, using base::FnvHasher.
   template <typename U = T>
   auto operator()(const U& x) ->
       typename std::enable_if<std::is_arithmetic<U>::value, size_t>::type
       const {
-    Hasher hash;
-    hash.Update(x);
-    return static_cast<size_t>(hash.digest());
+    return FnvHasher::Combine(x);
   }
 
   // Version for non-ints, falling back to std::hash.
@@ -1233,10 +317,9 @@ struct Hash {
   }
 };
 
-}  // namespace base
-}  // namespace perfetto
+}  // namespace perfetto::base
 
-#endif  // INCLUDE_PERFETTO_EXT_BASE_HASH_H_
+#endif  // INCLUDE_PERFETTO_EXT_BASE_FNV_HASH_H_
 /*
  * Copyright (C) 2018 The Android Open Source Project
  *
@@ -1260,10 +343,11 @@ struct Hash {
 
 #include <algorithm>
 #include <string>
+#include <vector>
 
 // gen_amalgamated expanded: #include "perfetto/base/build_config.h"
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/hash.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/fnv_hash.h"
 
 namespace perfetto {
 namespace base {
@@ -1272,7 +356,7 @@ namespace base {
 // Strings are internally NOT null terminated.
 class StringView {
  public:
-  // Allow hashing with base::Hash.
+  // Allow hashing with base::FnvHash.
   static constexpr bool kHashable = true;
   static constexpr size_t npos = static_cast<size_t>(-1);
 
@@ -1296,6 +380,8 @@ class StringView {
     PERFETTO_DCHECK(cstr != nullptr);
   }
 
+  StringView(std::string_view str) : data_(str.data()), size_(str.size()) {}
+
   // This instead has to be explicit, as creating a StringView out of a
   // std::string can be subtle.
   explicit StringView(const std::string& str)
@@ -1359,6 +445,15 @@ class StringView {
 #endif
   }
 
+  bool CaseInsensitiveOneOf(const std::vector<StringView>& others) const {
+    for (const StringView& other : others) {
+      if (CaseInsensitiveEq(other)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   bool StartsWith(const StringView& other) const {
     if (other.size() == 0)
       return true;
@@ -1385,7 +480,7 @@ class StringView {
   }
 
   uint64_t Hash() const {
-    base::Hasher hasher;
+    base::FnvHasher hasher;
     hasher.Update(data_, size_);
     return hasher.digest();
   }
@@ -1438,10 +533,8 @@ struct std::hash<::perfetto::base::StringView> {
 };
 
 #endif  // INCLUDE_PERFETTO_EXT_BASE_STRING_VIEW_H_
-// gen_amalgamated begin header: include/perfetto/ext/base/utils.h
-// gen_amalgamated begin header: include/perfetto/ext/base/sys_types.h
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -1456,107 +549,649 @@ struct std::hash<::perfetto::base::StringView> {
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_EXT_BASE_SYS_TYPES_H_
-#define INCLUDE_PERFETTO_EXT_BASE_SYS_TYPES_H_
-
-// This headers deals with sys types commonly used in the codebase that are
-// missing on Windows.
-
-#include <sys/types.h>
-
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
-
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+#ifndef INCLUDE_PERFETTO_EXT_BASE_STRING_UTILS_H_
+#define INCLUDE_PERFETTO_EXT_BASE_STRING_UTILS_H_
 
-#if !PERFETTO_BUILDFLAG(PERFETTO_COMPILER_GCC)
-// MinGW has these. clang-cl and MSVC, which use just the Windows SDK, don't.
-using uid_t = unsigned int;
-using pid_t = int;
-#endif  // !GCC
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
 
-#if defined(_WIN64)
-using ssize_t = int64_t;
-#else
-using ssize_t = long;
-#endif  // _WIN64
+#include <charconv>
+#include <cinttypes>
+#include <optional>
+#include <string>
+#include <system_error>
+#include <vector>
 
-#endif  // OS_WIN
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_view.h"
 
 namespace perfetto {
 namespace base {
 
-constexpr uid_t kInvalidUid = static_cast<uid_t>(-1);
-constexpr pid_t kInvalidPid = static_cast<pid_t>(-1);
+inline char Lowercase(char c) {
+  return ('A' <= c && c <= 'Z') ? static_cast<char>(c - ('A' - 'a')) : c;
+}
 
-}  // namespace base
-}  // namespace perfetto
+inline char Uppercase(char c) {
+  return ('a' <= c && c <= 'z') ? static_cast<char>(c + ('A' - 'a')) : c;
+}
 
-#endif  // INCLUDE_PERFETTO_EXT_BASE_SYS_TYPES_H_
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+// Returns true if the character is an ASCII whitespace character.
+// This is a locale-independent version that only considers ASCII whitespace:
+// space (0x20), tab (0x09), newline (0x0A), vertical tab (0x0B),
+// form feed (0x0C), and carriage return (0x0D).
+inline bool IsSpace(char c) {
+  return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' ||
+         c == '\r';
+}
 
-#ifndef INCLUDE_PERFETTO_EXT_BASE_UTILS_H_
-#define INCLUDE_PERFETTO_EXT_BASE_UTILS_H_
+inline std::optional<uint32_t> CStringToUInt32(const char* s, int base = 10) {
+  char* endptr = nullptr;
+  auto value = static_cast<uint32_t>(strtoul(s, &endptr, base));
+  return (*s && !*endptr) ? std::make_optional(value) : std::nullopt;
+}
 
-#include <errno.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
+inline std::optional<int32_t> CStringToInt32(const char* s, int base = 10) {
+  char* endptr = nullptr;
+  auto value = static_cast<int32_t>(strtol(s, &endptr, base));
+  return (*s && !*endptr) ? std::make_optional(value) : std::nullopt;
+}
 
-#include <atomic>
-#include <functional>
-#include <memory>
-#include <string>
+// Note: it saturates to 7fffffffffffffff if parsing a hex number >= 0x8000...
+inline std::optional<int64_t> CStringToInt64(const char* s, int base = 10) {
+  char* endptr = nullptr;
+  auto value = static_cast<int64_t>(strtoll(s, &endptr, base));
+  return (*s && !*endptr) ? std::make_optional(value) : std::nullopt;
+}
 
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
-// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/sys_types.h"
+inline std::optional<uint64_t> CStringToUInt64(const char* s, int base = 10) {
+  char* endptr = nullptr;
+  auto value = static_cast<uint64_t>(strtoull(s, &endptr, base));
+  return (*s && !*endptr) ? std::make_optional(value) : std::nullopt;
+}
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-// Even if Windows has errno.h, the all syscall-restart behavior does not apply.
-// Trying to handle EINTR can cause more harm than good if errno is left stale.
-// Chromium does the same.
-#define PERFETTO_EINTR(x) (x)
-#else
-#define PERFETTO_EINTR(x)                                   \
-  ([&] {                                                    \
-    decltype(x) eintr_wrapper_result;                       \
-    do {                                                    \
-      eintr_wrapper_result = (x);                           \
-    } while (eintr_wrapper_result == -1 && errno == EINTR); \
-    return eintr_wrapper_result;                            \
-  }())
-#endif
+double StrToD(const char* nptr, char** endptr);
 
-namespace perfetto {
-namespace base {
+inline std::optional<double> CStringToDouble(const char* s) {
+  char* endptr = nullptr;
+  double value = StrToD(s, &endptr);
+  std::optional<double> result(std::nullopt);
+  if (*s != '\0' && *endptr == '\0')
+    result = value;
+  return result;
+}
 
-// Do not add new usages of kPageSize, consider using GetSysPageSize() below.
-// TODO(primiano): over time the semantic of kPageSize became too ambiguous.
-// Strictly speaking, this constant is incorrect on some new devices where the
-// page size can be 16K (e.g., crbug.com/1116576). Unfortunately too much code
-// ended up depending on kPageSize for purposes that are not strictly related
-// with the kernel's mm subsystem.
-constexpr size_t kPageSize = 4096;
+inline std::optional<uint32_t> StringToUInt32(const std::string& s,
+                                              int base = 10) {
+  return CStringToUInt32(s.c_str(), base);
+}
 
-// Returns the system's page size. Use this when dealing with mmap, madvise and
-// similar mm-related syscalls.
-uint32_t GetSysPageSize();
+inline std::optional<int32_t> StringToInt32(const std::string& s,
+                                            int base = 10) {
+  return CStringToInt32(s.c_str(), base);
+}
 
-template <typename T, size_t TSize>
+inline std::optional<uint64_t> StringToUInt64(const std::string& s,
+                                              int base = 10) {
+  return CStringToUInt64(s.c_str(), base);
+}
+
+inline std::optional<int64_t> StringToInt64(const std::string& s,
+                                            int base = 10) {
+  return CStringToInt64(s.c_str(), base);
+}
+
+inline std::optional<double> StringToDouble(const std::string& s) {
+  return CStringToDouble(s.c_str());
+}
+
+template <typename T>
+inline std::optional<T> StringViewToNumber(const base::StringView& sv,
+                                           int base = 10) {
+  // std::from_chars() does not regonize the leading '+' character and only
+  // recognizes '-' so remove the '+' if it exists to avoid errors and match
+  // the behavior of the other string conversion utilities above.
+  size_t start_offset = !sv.empty() && sv.at(0) == '+' ? 1 : 0;
+  T value;
+  auto result =
+      std::from_chars(sv.begin() + start_offset, sv.end(), value, base);
+  if (result.ec == std::errc() && result.ptr == sv.end()) {
+    return value;
+  } else {
+    return std::nullopt;
+  }
+}
+
+inline std::optional<uint32_t> StringViewToUInt32(const base::StringView& sv,
+                                                  int base = 10) {
+  // std::from_chars() does not recognize the leading '-' character for
+  // unsigned conversions, but strtol does. To Mimic the behavior of strtol,
+  // attempt a signed converion if we see a leading '-', and then cast the
+  // result back to unsigned.
+  if (sv.size() > 0 && sv.at(0) == '-') {
+    return static_cast<std::optional<uint32_t> >(
+        StringViewToNumber<int32_t>(sv, base));
+  } else {
+    return StringViewToNumber<uint32_t>(sv, base);
+  }
+}
+
+inline std::optional<int32_t> StringViewToInt32(const base::StringView& sv,
+                                                int base = 10) {
+  return StringViewToNumber<int32_t>(sv, base);
+}
+
+inline std::optional<uint64_t> StringViewToUInt64(const base::StringView& sv,
+                                                  int base = 10) {
+  // std::from_chars() does not recognize the leading '-' character for
+  // unsigned conversions, but strtol does. To Mimic the behavior of strtol,
+  // attempt a signed converion if we see a leading '-', and then cast the
+  // result back to unsigned.
+  if (sv.size() > 0 && sv.at(0) == '-') {
+    return static_cast<std::optional<uint64_t> >(
+        StringViewToNumber<int64_t>(sv, base));
+  } else {
+    return StringViewToNumber<uint64_t>(sv, base);
+  }
+}
+
+inline std::optional<int64_t> StringViewToInt64(const base::StringView& sv,
+                                                int base = 10) {
+  return StringViewToNumber<int64_t>(sv, base);
+}
+
+// TODO: As of Clang 19.0 std::from_chars is unimplemented for type double
+// despite being part of C++17 standard, and already being supported by GCC and
+// MSVC. Enable this once we have double support in Clang.
+// inline std::optional<double> StringViewToDouble(const base::StringView& sv) {
+//   return StringViewToNumber<double>(sv);
+// }
+
+bool StartsWith(const std::string& str, const std::string& prefix);
+bool EndsWith(const std::string& str, const std::string& suffix);
+bool StartsWithAny(const std::string& str,
+                   const std::vector<std::string>& prefixes);
+bool Contains(const std::string& haystack, const std::string& needle);
+bool Contains(const std::string& haystack, char needle);
+bool Contains(const std::vector<std::string>& haystack,
+              const std::string& needle);
+size_t Find(const StringView& needle, const StringView& haystack);
+bool CaseInsensitiveEqual(const std::string& first, const std::string& second);
+std::string Join(const std::vector<std::string>& parts,
+                 const std::string& delim);
+std::vector<std::string> SplitString(const std::string& text,
+                                     const std::string& delimiter);
+std::string StripPrefix(const std::string& str, const std::string& prefix);
+std::string StripSuffix(const std::string& str, const std::string& suffix);
+std::string TrimWhitespace(const std::string& str);
+std::string ToLower(const std::string& str);
+std::string ToUpper(const std::string& str);
+std::string StripChars(const std::string& str,
+                       const std::string& chars,
+                       char replacement);
+std::string ToHex(const char* data, size_t size);
+inline std::string ToHex(const std::string& s) {
+  return ToHex(s.c_str(), s.size());
+}
+std::string IntToHexString(uint32_t number);
+std::string Uint64ToHexString(uint64_t number);
+std::string Uint64ToHexStringNoPrefix(uint64_t number);
+std::string ReplaceAll(std::string str,
+                       const std::string& to_replace,
+                       const std::string& replacement);
+
+// Checks if all characters in the input string view `str` are ASCII.
+//
+// If so, the function returns true and `output` is not modified.
+// If `str` contains non-ASCII characters, the function returns false,
+// removes invalid UTF-8 characters from `str`, and stores the result in
+// `output`.
+bool CheckAsciiAndRemoveInvalidUTF8(base::StringView str, std::string& output);
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+bool WideToUTF8(const std::wstring& source, std::string& output);
+bool UTF8ToWide(const std::string& source, std::wstring& output);
+#endif  // PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+
+// A BSD-style strlcpy without the return value.
+// Copies at most |dst_size|-1 characters. Unlike strncpy, it always \0
+// terminates |dst|, as long as |dst_size| is not 0.
+// Unlike strncpy and like strlcpy it does not zero-pad the rest of |dst|.
+// Returns nothing. The BSD strlcpy returns the size of |src|, which might
+// be > |dst_size|. Anecdotal experience suggests people assume the return value
+// is the number of bytes written in |dst|. That assumption can lead to
+// dangerous bugs.
+// In order to avoid being subtly uncompliant with strlcpy AND avoid misuse,
+// the choice here is to return nothing.
+inline void StringCopy(char* dst, const char* src, size_t dst_size) {
+  for (size_t i = 0; i < dst_size; ++i) {
+    if ((dst[i] = src[i]) == '\0') {
+      return;  // We hit and copied the null terminator.
+    }
+  }
+
+  // We were left off at dst_size. We over copied 1 byte. Null terminate.
+  if (PERFETTO_LIKELY(dst_size > 0))
+    dst[dst_size - 1] = 0;
+}
+
+// Like snprintf() but returns the number of chars *actually* written (without
+// counting the null terminator) NOT "the number of chars which would have been
+// written to the final string if enough  space had been available".
+// This should be used in almost all cases when the caller uses the return value
+// of snprintf(). If the return value is not used, there is no benefit in using
+// this wrapper, as this just calls snprintf() and mangles the return value.
+// It always null-terminates |dst| (even in case of errors), unless
+// |dst_size| == 0.
+// Examples:
+//   SprintfTrunc(x, 4, "123whatever"): returns 3 and writes "123\0".
+//   SprintfTrunc(x, 4, "123"): returns 3 and writes "123\0".
+//   SprintfTrunc(x, 3, "123"): returns 2 and writes "12\0".
+//   SprintfTrunc(x, 2, "123"): returns 1 and writes "1\0".
+//   SprintfTrunc(x, 1, "123"): returns 0 and writes "\0".
+//   SprintfTrunc(x, 0, "123"): returns 0 and writes nothing.
+// NOTE: This means that the caller has no way to tell when truncation happens
+//   vs the edge case of *just* fitting in the buffer.
+size_t SprintfTrunc(char* dst, size_t dst_size, const char* fmt, ...)
+    PERFETTO_PRINTF_FORMAT(3, 4);
+
+// Line number starts from 1
+struct LineWithOffset {
+  base::StringView line;
+  uint32_t line_offset;
+  uint32_t line_num;
+};
+
+// For given string and offset Pfinds a line with character for
+// which offset points, what number is this line (starts from 1), and the offset
+// inside this line. returns std::nullopt if the offset points to
+// line break character or exceeds string length.
+std::optional<LineWithOffset> FindLineWithOffset(base::StringView str,
+                                                 uint32_t offset);
+
+// A helper class to facilitate construction and usage of write-once stack
+// strings.
+// Example usage:
+//   StackString<32> x("format %d %s", 42, string_arg);
+//   TakeString(x.c_str() | x.string_view() | x.ToStdString());
+// Rather than char x[32] + sprintf.
+// Advantages:
+// - Avoids useless zero-fills caused by people doing `char buf[32] {}` (mainly
+//   by fearing unknown snprintf failure modes).
+// - Makes the code more robust in case of snprintf truncations (len() and
+//  string_view() will return the truncated length, unlike snprintf).
+template <size_t N>
+class StackString {
+ public:
+  explicit PERFETTO_PRINTF_FORMAT(/* 1=this */ 2, 3)
+      StackString(const char* fmt, ...) {
+    buf_[0] = '\0';
+    va_list args;
+    va_start(args, fmt);
+    int res = vsnprintf(buf_, sizeof(buf_), fmt, args);
+    va_end(args);
+    buf_[sizeof(buf_) - 1] = '\0';
+    len_ = res < 0 ? 0 : std::min(static_cast<size_t>(res), sizeof(buf_) - 1);
+  }
+
+  StringView string_view() const { return StringView(buf_, len_); }
+  std::string ToStdString() const { return std::string(buf_, len_); }
+  const char* c_str() const { return buf_; }
+  size_t len() const { return len_; }
+  char* mutable_data() { return buf_; }
+
+ private:
+  char buf_[N];
+  size_t len_ = 0;  // Does not include the \0.
+};
+
+}  // namespace base
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_STRING_UTILS_H_
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "perfetto/ext/base/android_utils.h"
+
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+
+#include <string>
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+#include <sys/system_properties.h>
+#endif
+
+// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/base/time.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
+
+#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) &&  \
+    !PERFETTO_BUILDFLAG(PERFETTO_OS_NACL) && \
+    !PERFETTO_BUILDFLAG(PERFETTO_OS_WASM)
+#include <sys/utsname.h>
+#include <unistd.h>
+#endif
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX_BUT_NOT_QNX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+#include <sys/sysinfo.h>
+#endif
+
+namespace perfetto {
+namespace base {
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+
+std::string GetAndroidProp(const char* name) {
+  std::string ret;
+#if __ANDROID_API__ >= 26
+  const prop_info* pi = __system_property_find(name);
+  if (!pi) {
+    return ret;
+  }
+  __system_property_read_callback(
+      pi,
+      [](void* dst_void, const char*, const char* value, uint32_t) {
+        std::string& dst = *static_cast<std::string*>(dst_void);
+        dst = value;
+      },
+      &ret);
+#else  // __ANDROID_API__ < 26
+  char value_buf[PROP_VALUE_MAX];
+  int len = __system_property_get(name, value_buf);
+  if (len > 0 && static_cast<size_t>(len) < sizeof(value_buf)) {
+    ret = std::string(value_buf, static_cast<size_t>(len));
+  }
+#endif
+  return ret;
+}
+
+#endif  // PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+
+Utsname GetUtsname() {
+  Utsname utsname_info;
+#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) &&  \
+    !PERFETTO_BUILDFLAG(PERFETTO_OS_NACL) && \
+    !PERFETTO_BUILDFLAG(PERFETTO_OS_WASM)
+  struct utsname uname_info;
+  if (uname(&uname_info) == 0) {
+    utsname_info.sysname = uname_info.sysname;
+    utsname_info.version = uname_info.version;
+    utsname_info.machine = uname_info.machine;
+    utsname_info.release = uname_info.release;
+  } else {
+    PERFETTO_ELOG("Unable to read Utsname information");
+  }
+#endif  // !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  return utsname_info;
+}
+
+SystemInfo GetSystemInfo() {
+  SystemInfo info;
+
+  info.timezone_off_mins = GetTimezoneOffsetMins();
+
+#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) &&  \
+    !PERFETTO_BUILDFLAG(PERFETTO_OS_NACL) && \
+    !PERFETTO_BUILDFLAG(PERFETTO_OS_WASM)
+
+  info.utsname_info = GetUtsname();
+  info.page_size = static_cast<uint32_t>(sysconf(_SC_PAGESIZE));
+  info.num_cpus = static_cast<uint32_t>(sysconf(_SC_NPROCESSORS_CONF));
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX_BUT_NOT_QNX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+  // Use the Linux-specific sysinfo() system call on Linux and Android.
+  // https://man7.org/linux/man-pages/man2/sysinfo.2.html
+  struct sysinfo sys_info;
+  if (sysinfo(&sys_info) == 0) {
+    info.system_ram_bytes =
+        static_cast<uint64_t>(sys_info.totalram) * sys_info.mem_unit;
+  }
+#else
+  // POSIX Fallback (macOS, BSD, etc.): Use sysconf() to get physical pages.
+  long pages = sysconf(_SC_PHYS_PAGES);
+  if (pages > 0 && info.page_size.has_value()) {
+    info.system_ram_bytes = static_cast<uint64_t>(pages) * (*info.page_size);
+  }
+#endif
+#endif  // !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+  info.android_build_fingerprint = GetAndroidProp("ro.build.fingerprint");
+  if (info.android_build_fingerprint.empty()) {
+    PERFETTO_ELOG("Unable to read ro.build.fingerprint");
+  }
+
+  info.android_device_manufacturer = GetAndroidProp("ro.product.manufacturer");
+  if (info.android_device_manufacturer.empty()) {
+    PERFETTO_ELOG("Unable to read ro.product.manufacturer");
+  }
+
+  std::string sdk_str_value = GetAndroidProp("ro.build.version.sdk");
+  info.android_sdk_version = StringToUInt64(sdk_str_value);
+  if (!info.android_sdk_version.has_value()) {
+    PERFETTO_ELOG("Unable to read ro.build.version.sdk");
+  }
+
+  info.android_soc_model = GetAndroidProp("ro.soc.model");
+  if (info.android_soc_model.empty()) {
+    PERFETTO_ELOG("Unable to read ro.soc.model");
+  }
+
+  // guest_soc model is not always present
+  info.android_guest_soc_model = GetAndroidProp("ro.boot.guest_soc.model");
+
+  info.android_hardware_revision = GetAndroidProp("ro.boot.hardware.revision");
+  if (info.android_hardware_revision.empty()) {
+    PERFETTO_ELOG("Unable to read ro.boot.hardware.revision");
+  }
+
+  info.android_storage_model = GetAndroidProp("ro.boot.hardware.ufs");
+  if (info.android_storage_model.empty()) {
+    PERFETTO_ELOG("Unable to read ro.boot.hardware.ufs");
+  }
+
+  info.android_ram_model = GetAndroidProp("ro.boot.hardware.ddr");
+  if (info.android_ram_model.empty()) {
+    PERFETTO_ELOG("Unable to read ro.boot.hardware.ddr");
+  }
+
+  info.android_serial_console = GetAndroidProp("init.svc.console");
+  if (info.android_serial_console.empty()) {
+    PERFETTO_ELOG("Unable to read init.svc.console");
+  }
+#endif  // PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+
+  return info;
+}
+
+std::string GetPerfettoMachineName() {
+  const char* env_name = getenv("PERFETTO_MACHINE_NAME");
+  if (env_name) {
+    return env_name;
+  }
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+  std::string name = base::GetAndroidProp("traced.machine_name");
+  if (name.empty()) {
+    name = GetUtsname().sysname;
+  }
+  return name;
+#else
+  return GetUtsname().sysname;
+#endif
+}
+
+}  // namespace base
+}  // namespace perfetto
+// gen_amalgamated begin source: src/base/base64.cc
+// gen_amalgamated begin header: include/perfetto/ext/base/base64.h
+// gen_amalgamated begin header: include/perfetto/ext/base/utils.h
+// gen_amalgamated begin header: include/perfetto/ext/base/sys_types.h
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_EXT_BASE_SYS_TYPES_H_
+#define INCLUDE_PERFETTO_EXT_BASE_SYS_TYPES_H_
+
+// This headers deals with sys types commonly used in the codebase that are
+// missing on Windows.
+
+#include <sys/types.h>  // IWYU pragma: export
+#include <cstdint>
+
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+
+#ifdef __MINGW32__
+
+using uid_t = int;
+using gid_t = int;
+
+#else
+
+#if !PERFETTO_BUILDFLAG(PERFETTO_COMPILER_GCC)
+// MinGW has these. clang-cl and MSVC, which use just the Windows SDK, don't.
+using uid_t = int;
+using gid_t = int;
+using pid_t = int;
+#endif  // !GCC
+
+#if defined(_WIN64)
+using ssize_t = int64_t;
+#else
+using ssize_t = long;
+#endif  // _WIN64
+
+#endif  // __MINGW32__
+
+#endif  // OS_WIN
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+// From libcutils' android_filesystem_config.h
+#ifndef AID_ROOT
+#define AID_ROOT 0
+#endif
+#ifndef AID_STATSD
+#define AID_STATSD 1066
+#endif
+#ifndef AID_SHELL
+#define AID_SHELL 2000
+#endif
+#endif
+
+namespace perfetto {
+namespace base {
+
+// The machine ID used in the tracing core.
+using MachineID = uint32_t;
+// The default value reserved for the host trace.
+constexpr MachineID kDefaultMachineID = 0;
+
+constexpr uid_t kInvalidUid = static_cast<uid_t>(-1);
+constexpr pid_t kInvalidPid = static_cast<pid_t>(-1);
+
+}  // namespace base
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_SYS_TYPES_H_
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_EXT_BASE_UTILS_H_
+#define INCLUDE_PERFETTO_EXT_BASE_UTILS_H_
+
+#include <errno.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <string>
+
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/sys_types.h"
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+// Even if Windows has errno.h, the all syscall-restart behavior does not apply.
+// Trying to handle EINTR can cause more harm than good if errno is left stale.
+// Chromium does the same.
+#define PERFETTO_EINTR(x) (x)
+#else
+#define PERFETTO_EINTR(x)                                   \
+  ([&] {                                                    \
+    decltype(x) eintr_wrapper_result;                       \
+    do {                                                    \
+      eintr_wrapper_result = (x);                           \
+    } while (eintr_wrapper_result == -1 && errno == EINTR); \
+    return eintr_wrapper_result;                            \
+  }())
+#endif
+
+namespace perfetto {
+namespace base {
+
+namespace internal {
+extern std::atomic<uint32_t> g_cached_page_size;
+uint32_t GetSysPageSizeSlowpath();
+}  // namespace internal
+
+// Returns the system's page size. Use this when dealing with mmap, madvise and
+// similar mm-related syscalls.
+// This function might be called in hot paths. Avoid calling getpagesize() all
+// the times, in many implementations getpagesize() calls sysconf() which is
+// not cheap.
+inline uint32_t GetSysPageSize() {
+  const uint32_t page_size =
+      internal::g_cached_page_size.load(std::memory_order_relaxed);
+  return page_size != 0 ? page_size : internal::GetSysPageSizeSlowpath();
+}
+
+template <typename T, size_t TSize>
 constexpr size_t ArraySize(const T (&)[TSize]) {
   return TSize;
 }
@@ -1579,10 +1214,16 @@ constexpr T AssumeLittleEndian(T value) {
 }
 
 // Round up |size| to a multiple of |alignment| (must be a power of two).
+inline constexpr size_t AlignUp(size_t size, size_t alignment) {
+  return (size + alignment - 1) & ~(alignment - 1);
+}
+
+// TODO(primiano): clean this up and move all existing usages to the constexpr
+// version above.
 template <size_t alignment>
 constexpr size_t AlignUp(size_t size) {
   static_assert((alignment & (alignment - 1)) == 0, "alignment must be a pow2");
-  return (size + alignment - 1) & ~(alignment - 1);
+  return AlignUp(size, alignment);
 }
 
 inline bool IsAgain(int err) {
@@ -1623,6 +1264,10 @@ std::string GetCurExecutableDir();
 void* AlignedAlloc(size_t alignment, size_t size);
 void AlignedFree(void*);
 
+// Detects Sync-mode MTE (currently being tested in some Android builds).
+// This is known to use extra memory for the stack history buffer.
+bool IsSyncMemoryTaggingEnabled();
+
 // A RAII version of the above, which takes care of pairing Aligned{Alloc,Free}.
 template <typename T>
 struct AlignedDeleter {
@@ -1697,9 +1342,9 @@ inline std::string HexDump(const std::string& data,
 #ifndef INCLUDE_PERFETTO_EXT_BASE_BASE64_H_
 #define INCLUDE_PERFETTO_EXT_BASE_BASE64_H_
 
+#include <optional>
 #include <string>
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/optional.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/string_view.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"  // For ssize_t.
 
@@ -1736,9 +1381,9 @@ ssize_t Base64Decode(const char* src,
                      uint8_t* dst,
                      size_t dst_size);
 
-Optional<std::string> Base64Decode(const char* src, size_t src_size);
+std::optional<std::string> Base64Decode(const char* src, size_t src_size);
 
-inline Optional<std::string> Base64Decode(StringView sv) {
+inline std::optional<std::string> Base64Decode(StringView sv) {
   return Base64Decode(sv.data(), sv.size());
 }
 
@@ -1884,17 +1529,17 @@ ssize_t Base64Decode(const char* src,
   return static_cast<ssize_t>(wr_size);
 }
 
-Optional<std::string> Base64Decode(const char* src, size_t src_size) {
+std::optional<std::string> Base64Decode(const char* src, size_t src_size) {
   std::string dst;
   dst.resize(Base64DecSize(src_size));
   auto res = Base64Decode(src, src_size, reinterpret_cast<uint8_t*>(&dst[0]),
                           dst.size());
   if (res < 0)
-    return nullopt;  // Decoding error.
+    return std::nullopt;  // Decoding error.
 
   PERFETTO_CHECK(res <= static_cast<ssize_t>(dst.size()));
   dst.resize(static_cast<size_t>(res));
-  return base::make_optional(dst);
+  return std::make_optional(dst);
 }
 
 }  // namespace base
@@ -2063,9 +1708,8 @@ void UnregisterAllCrashKeysForTesting();
 }  // namespace perfetto
 
 #endif  // INCLUDE_PERFETTO_EXT_BASE_CRASH_KEYS_H_
-// gen_amalgamated begin header: include/perfetto/ext/base/string_utils.h
 /*
- * Copyright (C) 2018 The Android Open Source Project
+ * Copyright (C) 2021 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -2080,307 +1724,83 @@ void UnregisterAllCrashKeysForTesting();
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_EXT_BASE_STRING_UTILS_H_
-#define INCLUDE_PERFETTO_EXT_BASE_STRING_UTILS_H_
+// gen_amalgamated expanded: #include "perfetto/ext/base/crash_keys.h"
 
-#include <stdarg.h>
-#include <stdlib.h>
 #include <string.h>
 
+#include <atomic>
 #include <cinttypes>
-#include <string>
-#include <vector>
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/optional.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/string_view.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
 
 namespace perfetto {
 namespace base {
 
-inline char Lowercase(char c) {
-  return ('A' <= c && c <= 'Z') ? static_cast<char>(c - ('A' - 'a')) : c;
-}
-
-inline char Uppercase(char c) {
-  return ('a' <= c && c <= 'z') ? static_cast<char>(c + ('A' - 'a')) : c;
-}
-
-inline Optional<uint32_t> CStringToUInt32(const char* s, int base = 10) {
-  char* endptr = nullptr;
-  auto value = static_cast<uint32_t>(strtoul(s, &endptr, base));
-  return (*s && !*endptr) ? base::make_optional(value) : base::nullopt;
-}
+namespace {
 
-inline Optional<int32_t> CStringToInt32(const char* s, int base = 10) {
-  char* endptr = nullptr;
-  auto value = static_cast<int32_t>(strtol(s, &endptr, base));
-  return (*s && !*endptr) ? base::make_optional(value) : base::nullopt;
-}
+constexpr size_t kMaxKeys = 32;
 
-// Note: it saturates to 7fffffffffffffff if parsing a hex number >= 0x8000...
-inline Optional<int64_t> CStringToInt64(const char* s, int base = 10) {
-  char* endptr = nullptr;
-  auto value = static_cast<int64_t>(strtoll(s, &endptr, base));
-  return (*s && !*endptr) ? base::make_optional(value) : base::nullopt;
-}
+std::atomic<CrashKey*> g_keys[kMaxKeys]{};
+std::atomic<uint32_t> g_num_keys{};
+}  // namespace
 
-inline Optional<uint64_t> CStringToUInt64(const char* s, int base = 10) {
-  char* endptr = nullptr;
-  auto value = static_cast<uint64_t>(strtoull(s, &endptr, base));
-  return (*s && !*endptr) ? base::make_optional(value) : base::nullopt;
-}
+void CrashKey::Register() {
+  // If doesn't matter if we fail below. If there are no slots left, don't
+  // keep trying re-registering on every Set(), the outcome won't change.
 
-double StrToD(const char* nptr, char** endptr);
+  // If two threads raced on the Register(), avoid registering the key twice.
+  if (registered_.exchange(true))
+    return;
 
-inline Optional<double> CStringToDouble(const char* s) {
-  char* endptr = nullptr;
-  double value = StrToD(s, &endptr);
-  Optional<double> result(base::nullopt);
-  if (*s != '\0' && *endptr == '\0')
-    result = value;
-  return result;
+  uint32_t slot = g_num_keys.fetch_add(1);
+  if (slot >= kMaxKeys) {
+    PERFETTO_LOG("Too many crash keys registered");
+    return;
+  }
+  g_keys[slot].store(this);
 }
 
-inline Optional<uint32_t> StringToUInt32(const std::string& s, int base = 10) {
-  return CStringToUInt32(s.c_str(), base);
-}
+// Returns the number of chars written, without counting the \0.
+size_t CrashKey::ToString(char* dst, size_t len) {
+  if (len > 0)
+    *dst = '\0';
+  switch (type_.load(std::memory_order_relaxed)) {
+    case Type::kUnset:
+      break;
+    case Type::kInt:
+      return SprintfTrunc(dst, len, "%s: %" PRId64 "\n", name_,
+                          int_value_.load(std::memory_order_relaxed));
+    case Type::kStr:
+      char buf[sizeof(str_value_)];
+      for (size_t i = 0; i < sizeof(str_value_); i++)
+        buf[i] = str_value_[i].load(std::memory_order_relaxed);
 
-inline Optional<int32_t> StringToInt32(const std::string& s, int base = 10) {
-  return CStringToInt32(s.c_str(), base);
+      // Don't assume |str_value_| is properly null-terminated.
+      return SprintfTrunc(dst, len, "%s: %.*s\n", name_, int(sizeof(buf)), buf);
+  }
+  return 0;
 }
 
-inline Optional<uint64_t> StringToUInt64(const std::string& s, int base = 10) {
-  return CStringToUInt64(s.c_str(), base);
+void UnregisterAllCrashKeysForTesting() {
+  g_num_keys.store(0);
+  for (auto& key : g_keys)
+    key.store(nullptr);
 }
 
-inline Optional<int64_t> StringToInt64(const std::string& s, int base = 10) {
-  return CStringToInt64(s.c_str(), base);
-}
-
-inline Optional<double> StringToDouble(const std::string& s) {
-  return CStringToDouble(s.c_str());
-}
-
-bool StartsWith(const std::string& str, const std::string& prefix);
-bool EndsWith(const std::string& str, const std::string& suffix);
-bool StartsWithAny(const std::string& str,
-                   const std::vector<std::string>& prefixes);
-bool Contains(const std::string& haystack, const std::string& needle);
-bool Contains(const std::string& haystack, char needle);
-size_t Find(const StringView& needle, const StringView& haystack);
-bool CaseInsensitiveEqual(const std::string& first, const std::string& second);
-std::string Join(const std::vector<std::string>& parts,
-                 const std::string& delim);
-std::vector<std::string> SplitString(const std::string& text,
-                                     const std::string& delimiter);
-std::string StripPrefix(const std::string& str, const std::string& prefix);
-std::string StripSuffix(const std::string& str, const std::string& suffix);
-std::string TrimWhitespace(const std::string& str);
-std::string ToLower(const std::string& str);
-std::string ToUpper(const std::string& str);
-std::string StripChars(const std::string& str,
-                       const std::string& chars,
-                       char replacement);
-std::string ToHex(const char* data, size_t size);
-inline std::string ToHex(const std::string& s) {
-  return ToHex(s.c_str(), s.size());
-}
-std::string IntToHexString(uint32_t number);
-std::string Uint64ToHexString(uint64_t number);
-std::string Uint64ToHexStringNoPrefix(uint64_t number);
-std::string ReplaceAll(std::string str,
-                       const std::string& to_replace,
-                       const std::string& replacement);
-
-// A BSD-style strlcpy without the return value.
-// Copies at most |dst_size|-1 characters. Unlike strncpy, it always \0
-// terminates |dst|, as long as |dst_size| is not 0.
-// Unlike strncpy and like strlcpy it does not zero-pad the rest of |dst|.
-// Returns nothing. The BSD strlcpy returns the size of |src|, which might
-// be > |dst_size|. Anecdotal experience suggests people assume the return value
-// is the number of bytes written in |dst|. That assumption can lead to
-// dangerous bugs.
-// In order to avoid being subtly uncompliant with strlcpy AND avoid misuse,
-// the choice here is to return nothing.
-inline void StringCopy(char* dst, const char* src, size_t dst_size) {
-  for (size_t i = 0; i < dst_size; ++i) {
-    if ((dst[i] = src[i]) == '\0') {
-      return;  // We hit and copied the null terminator.
-    }
-  }
-
-  // We were left off at dst_size. We over copied 1 byte. Null terminate.
-  if (PERFETTO_LIKELY(dst_size > 0))
-    dst[dst_size - 1] = 0;
-}
-
-// Like snprintf() but returns the number of chars *actually* written (without
-// counting the null terminator) NOT "the number of chars which would have been
-// written to the final string if enough  space had been available".
-// This should be used in almost all cases when the caller uses the return value
-// of snprintf(). If the return value is not used, there is no benefit in using
-// this wrapper, as this just calls snprintf() and mangles the return value.
-// It always null-terminates |dst| (even in case of errors), unless
-// |dst_size| == 0.
-// Examples:
-//   SprintfTrunc(x, 4, "123whatever"): returns 3 and writes "123\0".
-//   SprintfTrunc(x, 4, "123"): returns 3 and writes "123\0".
-//   SprintfTrunc(x, 3, "123"): returns 2 and writes "12\0".
-//   SprintfTrunc(x, 2, "123"): returns 1 and writes "1\0".
-//   SprintfTrunc(x, 1, "123"): returns 0 and writes "\0".
-//   SprintfTrunc(x, 0, "123"): returns 0 and writes nothing.
-// NOTE: This means that the caller has no way to tell when truncation happens
-//   vs the edge case of *just* fitting in the buffer.
-size_t SprintfTrunc(char* dst, size_t dst_size, const char* fmt, ...)
-    PERFETTO_PRINTF_FORMAT(3, 4);
-
-// Line number starts from 1
-struct LineWithOffset {
-  base::StringView line;
-  uint32_t line_offset;
-  uint32_t line_num;
-};
-
-// For given string and offset Pfinds a line with character for
-// which offset points, what number is this line (starts from 1), and the offset
-// inside this line. returns nullopt if the offset points to
-// line break character or exceeds string length.
-base::Optional<LineWithOffset> FindLineWithOffset(base::StringView str,
-                                                  uint32_t offset);
-
-// A helper class to facilitate construction and usage of write-once stack
-// strings.
-// Example usage:
-//   StackString<32> x("format %d %s", 42, string_arg);
-//   TakeString(x.c_str() | x.string_view() | x.ToStdString());
-// Rather than char x[32] + sprintf.
-// Advantages:
-// - Avoids useless zero-fills caused by people doing `char buf[32] {}` (mainly
-//   by fearing unknown snprintf failure modes).
-// - Makes the code more robust in case of snprintf truncations (len() and
-//  string_view() will return the truncated length, unlike snprintf).
-template <size_t N>
-class StackString {
- public:
-  explicit PERFETTO_PRINTF_FORMAT(/* 1=this */ 2, 3)
-      StackString(const char* fmt, ...) {
-    buf_[0] = '\0';
-    va_list args;
-    va_start(args, fmt);
-    int res = vsnprintf(buf_, sizeof(buf_), fmt, args);
-    va_end(args);
-    buf_[sizeof(buf_) - 1] = '\0';
-    len_ = res < 0 ? 0 : std::min(static_cast<size_t>(res), sizeof(buf_) - 1);
-  }
-
-  StringView string_view() const { return StringView(buf_, len_); }
-  std::string ToStdString() const { return std::string(buf_, len_); }
-  const char* c_str() const { return buf_; }
-  size_t len() const { return len_; }
-  char* mutable_data() { return buf_; }
-
- private:
-  char buf_[N];
-  size_t len_ = 0;  // Does not include the \0.
-};
-
-}  // namespace base
-}  // namespace perfetto
-
-#endif  // INCLUDE_PERFETTO_EXT_BASE_STRING_UTILS_H_
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// gen_amalgamated expanded: #include "perfetto/ext/base/crash_keys.h"
-
-#include <string.h>
-
-#include <atomic>
-#include <cinttypes>
-
-// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
-
-namespace perfetto {
-namespace base {
-
-namespace {
-
-constexpr size_t kMaxKeys = 32;
-
-std::atomic<CrashKey*> g_keys[kMaxKeys]{};
-std::atomic<uint32_t> g_num_keys{};
-}  // namespace
-
-void CrashKey::Register() {
-  // If doesn't matter if we fail below. If there are no slots left, don't
-  // keep trying re-registering on every Set(), the outcome won't change.
-
-  // If two threads raced on the Register(), avoid registering the key twice.
-  if (registered_.exchange(true))
-    return;
-
-  uint32_t slot = g_num_keys.fetch_add(1);
-  if (slot >= kMaxKeys) {
-    PERFETTO_LOG("Too many crash keys registered");
-    return;
-  }
-  g_keys[slot].store(this);
-}
-
-// Returns the number of chars written, without counting the \0.
-size_t CrashKey::ToString(char* dst, size_t len) {
-  if (len > 0)
-    *dst = '\0';
-  switch (type_.load(std::memory_order_relaxed)) {
-    case Type::kUnset:
-      break;
-    case Type::kInt:
-      return SprintfTrunc(dst, len, "%s: %" PRId64 "\n", name_,
-                          int_value_.load(std::memory_order_relaxed));
-    case Type::kStr:
-      char buf[sizeof(str_value_)];
-      for (size_t i = 0; i < sizeof(str_value_); i++)
-        buf[i] = str_value_[i].load(std::memory_order_relaxed);
-
-      // Don't assume |str_value_| is properly null-terminated.
-      return SprintfTrunc(dst, len, "%s: %.*s\n", name_, int(sizeof(buf)), buf);
-  }
-  return 0;
-}
-
-void UnregisterAllCrashKeysForTesting() {
-  g_num_keys.store(0);
-  for (auto& key : g_keys)
-    key.store(nullptr);
-}
-
-size_t SerializeCrashKeys(char* dst, size_t len) {
-  size_t written = 0;
-  uint32_t num_keys = g_num_keys.load();
-  if (len > 0)
-    *dst = '\0';
-  for (uint32_t i = 0; i < num_keys && written < len; i++) {
-    CrashKey* key = g_keys[i].load();
-    if (!key)
-      continue;  // Can happen if we hit this between the add and the store.
-    written += key->ToString(dst + written, len - written);
-  }
-  PERFETTO_DCHECK(written <= len);
-  PERFETTO_DCHECK(len == 0 || dst[written] == '\0');
-  return written;
+size_t SerializeCrashKeys(char* dst, size_t len) {
+  size_t written = 0;
+  uint32_t num_keys = g_num_keys.load();
+  if (len > 0)
+    *dst = '\0';
+  for (uint32_t i = 0; i < num_keys && written < len; i++) {
+    CrashKey* key = g_keys[i].load();
+    if (!key)
+      continue;  // Can happen if we hit this between the add and the store.
+    written += key->ToString(dst + written, len - written);
+  }
+  PERFETTO_DCHECK(written <= len);
+  PERFETTO_DCHECK(len == 0 || dst[written] == '\0');
+  return written;
 }
 
 }  // namespace base
@@ -2442,7 +1862,8 @@ void InstallCtrlCHandler(CtrlCHandlerFunction);
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
 
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-#include <Windows.h>
+#include <windows.h>
+
 #include <io.h>
 #else
 #include <signal.h>
@@ -2454,26 +1875,29 @@ namespace base {
 
 namespace {
 CtrlCHandlerFunction g_handler = nullptr;
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+BOOL WINAPI Trampoline(DWORD type) {
+  if (type == CTRL_C_EVENT) {
+    g_handler();
+    return TRUE;
+  }
+  return FALSE;
 }
+#endif
+}  // namespace
 
 void InstallCtrlCHandler(CtrlCHandlerFunction handler) {
   PERFETTO_CHECK(g_handler == nullptr);
   g_handler = handler;
 
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-  auto trampoline = [](DWORD type) -> int {
-    if (type == CTRL_C_EVENT) {
-      g_handler();
-      return true;
-    }
-    return false;
-  };
-  ::SetConsoleCtrlHandler(trampoline, true);
+  ::SetConsoleCtrlHandler(Trampoline, true);
 #elif PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
     PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
     PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
   // Setup signal handler.
-  struct sigaction sa {};
+  struct sigaction sa{};
 
 // Glibc headers for sa_sigaction trigger this.
 #pragma GCC diagnostic push
@@ -2481,7 +1905,11 @@ void InstallCtrlCHandler(CtrlCHandlerFunction handler) {
 #pragma GCC diagnostic ignored "-Wdisabled-macro-expansion"
 #endif
   sa.sa_handler = [](int) { g_handler(); };
+#if !PERFETTO_BUILDFLAG(PERFETTO_OS_QNX)
   sa.sa_flags = static_cast<decltype(sa.sa_flags)>(SA_RESETHAND | SA_RESTART);
+#else  // POSIX-compliant
+  sa.sa_flags = static_cast<decltype(sa.sa_flags)>(SA_RESETHAND);
+#endif
 #pragma GCC diagnostic pop
   sigaction(SIGINT, &sa, nullptr);
   sigaction(SIGTERM, &sa, nullptr);
@@ -2495,68 +1923,6 @@ void InstallCtrlCHandler(CtrlCHandlerFunction handler) {
 }  // namespace perfetto
 // gen_amalgamated begin source: src/base/event_fd.cc
 // gen_amalgamated begin header: include/perfetto/ext/base/event_fd.h
-// gen_amalgamated begin header: include/perfetto/base/platform_handle.h
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef INCLUDE_PERFETTO_BASE_PLATFORM_HANDLE_H_
-#define INCLUDE_PERFETTO_BASE_PLATFORM_HANDLE_H_
-
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
-
-namespace perfetto {
-namespace base {
-
-// PlatformHandle should be used only for types that are HANDLE(s) in Windows.
-// It should NOT be used to blanket-replace "int fd" in the codebase.
-// Windows has two types of "handles", which, in UNIX-land, both map to int:
-// 1. File handles returned by the posix-compatibility API like _open().
-//    These are just int(s) and should stay such, because all the posix-like API
-//    in Windows.h take an int, not a HANDLE.
-// 2. Handles returned by old-school WINAPI like CreateFile, CreateEvent etc.
-//    These are proper HANDLE(s). PlatformHandle should be used here.
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-// Windows.h typedefs HANDLE to void*. We use void* here to avoid leaking
-// Windows.h through our headers.
-using PlatformHandle = void*;
-
-// On Windows both nullptr and 0xffff... (INVALID_HANDLE_VALUE) are invalid.
-struct PlatformHandleChecker {
-  static inline bool IsValid(PlatformHandle h) {
-    return h && h != reinterpret_cast<PlatformHandle>(-1);
-  }
-};
-#else
-using PlatformHandle = int;
-struct PlatformHandleChecker {
-  static inline bool IsValid(PlatformHandle h) { return h >= 0; }
-};
-#endif
-
-// The definition of this lives in base/file_utils.cc (to avoid creating an
-// extra build edge for a one liner). This is really an alias for close() (UNIX)
-// CloseHandle() (Windows). THe indirection layer is just to avoid leaking
-// system headers like Windows.h through perfetto headers.
-// Thre return value is always UNIX-style: 0 on success, -1 on failure.
-int ClosePlatformHandle(PlatformHandle);
-
-}  // namespace base
-}  // namespace perfetto
-
-#endif  // INCLUDE_PERFETTO_BASE_PLATFORM_HANDLE_H_
 // gen_amalgamated begin header: include/perfetto/ext/base/scoped_file.h
 /*
  * Copyright (C) 2017 The Android Open Source Project
@@ -2617,8 +1983,7 @@ class ScopedResource {
   static constexpr T kInvalid = InvalidValue;
 
   explicit ScopedResource(T t = InvalidValue) : t_(t) {}
-  ScopedResource(ScopedResource&& other) noexcept {
-    t_ = other.t_;
+  ScopedResource(ScopedResource&& other) noexcept : t_(other.t_) {
     other.t_ = InvalidValue;
   }
   ScopedResource& operator=(ScopedResource&& other) {
@@ -2731,8 +2096,11 @@ class EventFd {
   // the pipe for fallback mode.
   ScopedPlatformHandle event_handle_;
 
-#if !PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) &&   \
-    !PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) && \
+// QNX is specified because it is a non-Linux UNIX platform but it
+// still sets the PERFETTO_OS_LINUX flag to be as compatible as possible
+// with the Linux build.
+#if !PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX_BUT_NOT_QNX) && \
+    !PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) &&           \
     !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
   // On Mac and other non-Linux UNIX platforms a pipe-based fallback is used.
   // The write end of the wakeup pipe.
@@ -2817,8 +2185,11 @@ class Pipe {
 #include <stdint.h>
 
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-#include <Windows.h>
+#include <windows.h>
+
 #include <synchapi.h>
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_QNX)
+#include <unistd.h>
 #elif PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
     PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
 #include <sys/eventfd.h>
@@ -2854,7 +2225,7 @@ void EventFd::Clear() {
     PERFETTO_DFATAL("EventFd::Clear()");
 }
 
-#elif PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX_BUT_NOT_QNX) || \
     PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
 
 EventFd::EventFd() {
@@ -2929,7 +2300,10 @@ void EventFd::Clear() {
 #ifndef INCLUDE_PERFETTO_BASE_STATUS_H_
 #define INCLUDE_PERFETTO_BASE_STATUS_H_
 
+#include <optional>
 #include <string>
+#include <string_view>
+#include <vector>
 
 // gen_amalgamated expanded: #include "perfetto/base/compiler.h"
 // gen_amalgamated expanded: #include "perfetto/base/export.h"
@@ -2942,6 +2316,10 @@ namespace base {
 // This can used as the return type of functions which would usually return an
 // bool for success or int for errno but also wants to add some string context
 // (ususally for logging).
+//
+// Similar to absl::Status, an optional "payload" can also be included with more
+// context about the error. This allows passing additional metadata about the
+// error (e.g. location of errors, potential mitigations etc).
 class PERFETTO_EXPORT_COMPONENT Status {
  public:
   Status() : ok_(true) {}
@@ -2964,9 +2342,49 @@ class PERFETTO_EXPORT_COMPONENT Status {
   const std::string& message() const { return message_; }
   const char* c_message() const { return message_.c_str(); }
 
+  //////////////////////////////////////////////////////////////////////////////
+  // Payload Management APIs
+  //////////////////////////////////////////////////////////////////////////////
+
+  // Payloads can be attached to error statuses to provide additional context.
+  //
+  // Payloads are (key, value) pairs, where the key is a string acting as a
+  // unique "type URL" and the value is an opaque string. The "type URL" should
+  // be unique, follow the format of a URL and, ideally, documentation on how to
+  // interpret its associated data should be available.
+  //
+  // To attach a payload to a status object, call `Status::SetPayload()`.
+  // Similarly, to extract the payload from a status, call
+  // `Status::GetPayload()`.
+  //
+  // Note: the payload APIs are only meaningful to call when the status is an
+  // error. Otherwise, all methods are noops.
+
+  // Gets the payload for the given |type_url| if one exists.
+  //
+  // Will always return std::nullopt if |ok()|.
+  std::optional<std::string_view> GetPayload(std::string_view type_url) const;
+
+  // Sets the payload for the given key. The key should
+  //
+  // Will always do nothing if |ok()|.
+  void SetPayload(std::string_view type_url, std::string value);
+
+  // Erases the payload for the given string and returns true if the payload
+  // existed and was erased.
+  //
+  // Will always do nothing if |ok()|.
+  bool ErasePayload(std::string_view type_url);
+
  private:
+  struct Payload {
+    std::string type_url;
+    std::string payload;
+  };
+
   bool ok_ = false;
   std::string message_;
+  std::vector<Payload> payloads_;
 };
 
 // Returns a status object which represents the Ok status.
@@ -2974,7 +2392,7 @@ inline Status OkStatus() {
   return Status();
 }
 
-PERFETTO_PRINTF_FORMAT(1, 2) Status ErrStatus(const char* format, ...);
+Status ErrStatus(const char* format, ...) PERFETTO_PRINTF_FORMAT(1, 2);
 
 }  // namespace base
 }  // namespace perfetto
@@ -3002,6 +2420,9 @@ PERFETTO_PRINTF_FORMAT(1, 2) Status ErrStatus(const char* format, ...);
 #include <fcntl.h>  // For mode_t & O_RDONLY/RDWR. Exists also on Windows.
 #include <stddef.h>
 
+#include <functional>
+#include <memory>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -3009,15 +2430,21 @@ PERFETTO_PRINTF_FORMAT(1, 2) Status ErrStatus(const char* format, ...);
 // gen_amalgamated expanded: #include "perfetto/base/export.h"
 // gen_amalgamated expanded: #include "perfetto/base/status.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/sys_types.h"
 
 namespace perfetto {
 namespace base {
 
+class TaskRunner;
+
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
 using FileOpenMode = int;
+inline constexpr char kDevNull[] = "NUL";
+inline constexpr char kFopenReadFlag[] = "r";
 #else
 using FileOpenMode = mode_t;
+inline constexpr char kDevNull[] = "/dev/null";
+inline constexpr char kFopenReadFlag[] = "re";
 #endif
 
 constexpr FileOpenMode kFileModeInvalid = static_cast<FileOpenMode>(-1);
@@ -3040,14 +2467,19 @@ ssize_t Read(int fd, void* dst, size_t dst_size);
 //   succeeds, and returns the number of bytes written.
 ssize_t WriteAll(int fd, const void* buf, size_t count);
 
+// Copies all data from |fd_in| to |fd_out|. Saves the offset of |fd_in|,
+// rewinds it to the beginning, copies the content, and restores the offset.
+// |fd_in| can't be a pipe, socket of FIFO.
+base::Status CopyFileContents(int fd_in, int fd_out);
+
 ssize_t WriteAllHandle(PlatformHandle, const void* buf, size_t count);
 
 ScopedFile OpenFile(const std::string& path,
                     int flags,
                     FileOpenMode = kFileModeInvalid);
-ScopedFstream OpenFstream(const char* path, const char* mode);
+ScopedFstream OpenFstream(const std::string& path, const std::string& mode);
 
-// This is an alias for close(). It's to avoid leaking Windows.h in headers.
+// This is an alias for close(). It's to avoid leaking windows.h in headers.
 // Exported because ScopedFile is used in the /include/ext API by Chromium
 // component builds.
 int PERFETTO_EXPORT_COMPONENT CloseFile(int fd);
@@ -3068,6 +2500,30 @@ bool FileExists(const std::string& path);
 // extension.
 std::string GetFileExtension(const std::string& filename);
 
+// Returns the basename component of a path (the final component after the last
+// directory separator). Behaves like man 2 basename, but works with both '/'
+// and '\' separators for cross-platform compatibility.
+// Examples:
+//   Basename("/usr/bin/ls") => "ls"
+//   Basename("/usr/bin/") => "bin"
+//   Basename("/") => "/"
+//   Basename("foo") => "foo"
+//   Basename("") => "."
+//   Basename("C:\\Windows\\System32") => "System32"
+std::string Basename(const std::string& path);
+
+// Returns the directory component of a path (everything up to but not
+// including the final component). Behaves like man 2 dirname, but works with
+// both '/' and '\' separators for cross-platform compatibility.
+// Examples:
+//   Dirname("/usr/bin/ls") => "/usr/bin"
+//   Dirname("/usr/bin") => "/usr"
+//   Dirname("/") => "/"
+//   Dirname("foo") => "."
+//   Dirname("") => "."
+//   Dirname("C:\\Windows\\System32") => "C:\\Windows"
+std::string Dirname(const std::string& path);
+
 // Puts the path to all files under |dir_path| in |output|, recursively walking
 // subdirectories. File paths are relative to |dir_path|. Only files are
 // included, not directories. Path separator is always '/', even on windows (not
@@ -3075,10 +2531,329 @@ std::string GetFileExtension(const std::string& filename);
 base::Status ListFilesRecursive(const std::string& dir_path,
                                 std::vector<std::string>& output);
 
+// Lists immediate subdirectories in |dir_path| (non-recursive). Directory names
+// are relative to |dir_path| and do not include the path separator. Returns
+// only directories, not files. Works on both Unix and Windows.
+base::Status ListDirectories(const std::string& dir_path,
+                             std::vector<std::string>& output);
+
+// Sets |path|'s owner group to |group_name| and permission mode bits to
+// |mode_bits|.
+base::Status SetFilePermissions(const std::string& path,
+                                const std::string& group_name,
+                                const std::string& mode_bits);
+
+// Returns the size of the file located at |path|, or nullopt in case of error.
+std::optional<uint64_t> GetFileSize(const std::string& path);
+
+// Returns the size of the open file |fd|, or nullopt in case of error.
+std::optional<uint64_t> GetFileSize(PlatformHandle fd);
+
+// This class uses inotify (on Linux/Android) to watch for the creation of
+// files in the filesystem. When the specified file is created, it triggers a
+// callback function.
+// Destroying the returned unique_ptr will automatically unregister the watch.
+//
+// Note: This only works with filesystem paths (not abstract sockets or other
+// special file types).
+// It's only supported on Linux and Android, it's a no-op (returns nullptr) on
+// other platforms.
+//
+// Usage:
+//   auto watch = LinuxFileWatch::WatchFileCreation(
+//       task_runner, "/tmp/my_file", []() {
+//         // Called when /tmp/my_file is created
+//       });
+class LinuxFileWatch {
+ public:
+  // Creates a watcher for file creation. Returns nullptr if the path is not a
+  // valid filesystem path or if the platform doesn't support inotify. The
+  // callback will be invoked on the provided TaskRunner when the file is
+  // created.
+  static std::unique_ptr<LinuxFileWatch> WatchFileCreation(
+      TaskRunner*,
+      const char* path,
+      std::function<void()> callback);
+
+  virtual ~LinuxFileWatch();
+
+ protected:
+  LinuxFileWatch() = default;
+};
+
 }  // namespace base
 }  // namespace perfetto
 
 #endif  // INCLUDE_PERFETTO_EXT_BASE_FILE_UTILS_H_
+// gen_amalgamated begin header: include/perfetto/base/task_runner.h
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_BASE_TASK_RUNNER_H_
+#define INCLUDE_PERFETTO_BASE_TASK_RUNNER_H_
+
+#include <stdint.h>
+
+#include <functional>
+
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/base/platform_handle.h"
+
+namespace perfetto {
+namespace base {
+
+// A generic interface to allow the library clients to interleave the execution
+// of the tracing internals in their runtime environment.
+// The expectation is that all tasks, which are queued either via PostTask() or
+// AddFileDescriptorWatch(), are executed on the same sequence (either on the
+// same thread, or on a thread pool that gives sequencing guarantees).
+//
+// Tasks are never executed synchronously inside PostTask and there is a full
+// memory barrier between tasks.
+//
+// All methods of this interface can be called from any thread.
+class PERFETTO_EXPORT_COMPONENT TaskRunner {
+ public:
+  virtual ~TaskRunner();
+
+  // Schedule a task for immediate execution. Immediate tasks are always
+  // executed in the order they are posted. Can be called from any thread.
+  virtual void PostTask(std::function<void()>) = 0;
+
+  // Schedule a task for execution after |delay_ms|. Note that there is no
+  // strict ordering guarantee between immediate and delayed tasks. Can be
+  // called from any thread.
+  virtual void PostDelayedTask(std::function<void()>, uint32_t delay_ms) = 0;
+
+  // Schedule a task to run when the handle becomes readable. The same handle
+  // can only be monitored by one function. Note that this function only needs
+  // to be implemented on platforms where the built-in ipc framework is used.
+  // Can be called from any thread.
+  // TODO(skyostil): Refactor this out of the shared interface.
+  virtual void AddFileDescriptorWatch(PlatformHandle,
+                                      std::function<void()>) = 0;
+
+  // Remove a previously scheduled watch for the handle. If this is run on the
+  // target thread of this TaskRunner, guarantees that the task registered to
+  // this handle will not be executed after this function call.
+  // Can be called from any thread.
+  virtual void RemoveFileDescriptorWatch(PlatformHandle) = 0;
+
+  // Checks if the current thread is the same thread where the TaskRunner's task
+  // run. This allows single threaded task runners (like the ones used in
+  // perfetto) to inform the caller that anything posted will run on the same
+  // thread/sequence. This can allow some callers to skip PostTask and instead
+  // directly execute the code. Can be called from any thread.
+  virtual bool RunsTasksOnCurrentThread() const = 0;
+};
+
+}  // namespace base
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_BASE_TASK_RUNNER_H_
+// gen_amalgamated begin header: include/perfetto/ext/base/weak_ptr.h
+// gen_amalgamated begin header: include/perfetto/ext/base/thread_checker.h
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_EXT_BASE_THREAD_CHECKER_H_
+#define INCLUDE_PERFETTO_EXT_BASE_THREAD_CHECKER_H_
+
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+
+#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+#include <pthread.h>
+#endif
+#include <atomic>
+
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
+
+namespace perfetto {
+namespace base {
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+using ThreadID = unsigned long;
+#else
+using ThreadID = pthread_t;
+#endif
+
+class PERFETTO_EXPORT_COMPONENT ThreadChecker {
+ public:
+  ThreadChecker();
+  ~ThreadChecker();
+  ThreadChecker(const ThreadChecker&);
+  ThreadChecker& operator=(const ThreadChecker&);
+  bool CalledOnValidThread() const PERFETTO_WARN_UNUSED_RESULT;
+  void DetachFromThread();
+
+ private:
+  mutable std::atomic<ThreadID> thread_id_;
+};
+
+#if PERFETTO_DCHECK_IS_ON() && !PERFETTO_BUILDFLAG(PERFETTO_CHROMIUM_BUILD)
+// TODO(primiano) Use Chromium's thread checker in Chromium.
+#define PERFETTO_THREAD_CHECKER(name) base::ThreadChecker name;
+#define PERFETTO_DCHECK_THREAD(name) \
+  PERFETTO_DCHECK((name).CalledOnValidThread())
+#define PERFETTO_DETACH_FROM_THREAD(name) (name).DetachFromThread()
+#else
+#define PERFETTO_THREAD_CHECKER(name)
+#define PERFETTO_DCHECK_THREAD(name)
+#define PERFETTO_DETACH_FROM_THREAD(name)
+#endif  // PERFETTO_DCHECK_IS_ON()
+
+}  // namespace base
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_THREAD_CHECKER_H_
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_EXT_BASE_WEAK_PTR_H_
+#define INCLUDE_PERFETTO_EXT_BASE_WEAK_PTR_H_
+
+// gen_amalgamated expanded: #include "perfetto/ext/base/thread_checker.h"
+
+#include <memory>
+
+namespace perfetto {
+namespace base {
+
+// A simple WeakPtr for single-threaded cases.
+// Generally keep the WeakPtrFactory as last fields in classes: it makes the
+// WeakPtr(s) invalidate as first thing in the class dtor.
+// Usage:
+// class MyClass {
+//  MyClass() : weak_factory_(this) {}
+//  WeakPtr<MyClass> GetWeakPtr() { return weak_factory_.GetWeakPtr(); }
+//
+// private:
+//  WeakPtrFactory<MyClass> weak_factory_;
+// }
+//
+// int main() {
+//  std::unique_ptr<MyClass> foo(new MyClass);
+//  auto wptr = foo.GetWeakPtr();
+//  ASSERT_TRUE(wptr);
+//  ASSERT_EQ(foo.get(), wptr->get());
+//  foo.reset();
+//  ASSERT_FALSE(wptr);
+//  ASSERT_EQ(nullptr, wptr->get());
+// }
+
+template <typename T>
+class WeakPtrFactory;  // Forward declaration, defined below.
+
+template <typename T>
+class WeakPtr {
+ public:
+  WeakPtr() {}
+  WeakPtr(const WeakPtr&) = default;
+  WeakPtr& operator=(const WeakPtr&) = default;
+  WeakPtr(WeakPtr&&) = default;
+  WeakPtr& operator=(WeakPtr&&) = default;
+
+  T* get() const {
+    PERFETTO_DCHECK_THREAD(thread_checker);
+    return handle_ ? *handle_.get() : nullptr;
+  }
+  T* operator->() const { return get(); }
+  T& operator*() const { return *get(); }
+
+  explicit operator bool() const { return !!get(); }
+
+ private:
+  friend class WeakPtrFactory<T>;
+  explicit WeakPtr(const std::shared_ptr<T*>& handle) : handle_(handle) {}
+
+  std::shared_ptr<T*> handle_;
+  PERFETTO_THREAD_CHECKER(thread_checker)
+};
+
+template <typename T>
+class WeakPtrFactory {
+ public:
+  explicit WeakPtrFactory(T* owner) : weak_ptr_(std::make_shared<T*>(owner)) {
+    PERFETTO_DCHECK_THREAD(thread_checker);
+  }
+
+  ~WeakPtrFactory() {
+    PERFETTO_DCHECK_THREAD(thread_checker);
+    *(weak_ptr_.handle_.get()) = nullptr;
+  }
+
+  // Can be safely called on any thread, since it simply copies |weak_ptr_|.
+  // Note that any accesses to the returned pointer need to be made on the
+  // thread that created/reset the factory.
+  WeakPtr<T> GetWeakPtr() const { return weak_ptr_; }
+
+  // Reset the factory to a new owner & thread. May only be called before any
+  // weak pointers were passed out. Future weak pointers will be valid on the
+  // calling thread.
+  void Reset(T* owner) {
+    // Reset thread checker to current thread.
+    PERFETTO_DETACH_FROM_THREAD(thread_checker);
+    PERFETTO_DCHECK_THREAD(thread_checker);
+
+    // We should not have passed out any weak pointers yet at this point.
+    PERFETTO_DCHECK(weak_ptr_.handle_.use_count() == 1);
+
+    weak_ptr_ = WeakPtr<T>(std::make_shared<T*>(owner));
+  }
+
+ private:
+  WeakPtrFactory(const WeakPtrFactory&) = delete;
+  WeakPtrFactory& operator=(const WeakPtrFactory&) = delete;
+
+  WeakPtr<T> weak_ptr_;
+  PERFETTO_THREAD_CHECKER(thread_checker)
+};
+
+}  // namespace base
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_WEAK_PTR_H_
 /*
  * Copyright (C) 2018 The Android Open Source Project
  *
@@ -3102,20 +2877,25 @@ base::Status ListFilesRecursive(const std::string& dir_path,
 
 #include <algorithm>
 #include <deque>
+#include <optional>
 #include <string>
 #include <vector>
 
 // gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
 // gen_amalgamated expanded: #include "perfetto/base/platform_handle.h"
 // gen_amalgamated expanded: #include "perfetto/base/status.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/optional.h"
+// gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/platform.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/weak_ptr.h"
 
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-#include <Windows.h>
+#include <windows.h>
+
 #include <direct.h>
 #include <io.h>
 #include <stringapiset.h>
@@ -3124,6 +2904,24 @@ base::Status ListFilesRecursive(const std::string& dir_path,
 #include <unistd.h>
 #endif
 
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+#define PERFETTO_SET_FILE_PERMISSIONS
+#include <fcntl.h>
+#include <grp.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#endif
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX_BUT_NOT_QNX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+// For inotify. QNX doesn't have full support for inotify_init1().
+#include <sys/inotify.h>
+#endif
+
 namespace perfetto {
 namespace base {
 namespace {
@@ -3135,11 +2933,11 @@ int CloseFindHandle(HANDLE h) {
   return FindClose(h) ? 0 : -1;
 }
 
-Optional<std::wstring> ToUtf16(const std::string str) {
+std::optional<std::wstring> ToUtf16(const std::string& str) {
   int len = MultiByteToWideChar(CP_UTF8, 0, str.data(),
                                 static_cast<int>(str.size()), nullptr, 0);
   if (len < 0) {
-    return base::nullopt;
+    return std::nullopt;
   }
   std::vector<wchar_t> tmp;
   tmp.resize(static_cast<std::vector<wchar_t>::size_type>(len));
@@ -3147,7 +2945,7 @@ Optional<std::wstring> ToUtf16(const std::string str) {
       MultiByteToWideChar(CP_UTF8, 0, str.data(), static_cast<int>(str.size()),
                           tmp.data(), static_cast<int>(tmp.size()));
   if (len < 0) {
-    return base::nullopt;
+    return std::nullopt;
   }
   PERFETTO_CHECK(static_cast<std::vector<wchar_t>::size_type>(len) ==
                  tmp.size());
@@ -3174,7 +2972,7 @@ bool ReadFileDescriptor(int fd, std::string* out) {
   // Do not override existing data in string.
   size_t i = out->size();
 
-  struct stat buf {};
+  struct stat buf{};
   if (fstat(fd, &buf) != -1) {
     if (buf.st_size > 0)
       out->resize(i + static_cast<size_t>(buf.st_size));
@@ -3211,7 +3009,7 @@ bool ReadPlatformHandle(PlatformHandle h, std::string* out) {
       out->resize(i);
       const bool is_eof = res && bytes_read == 0;
       auto err = res ? 0 : GetLastError();
-      // The "Broken pipe" error on Windows is slighly different than Unix:
+      // The "Broken pipe" error on Windows is slightly different than Unix:
       // On Unix: a "broken pipe" error can happen only on the writer side. On
       // the reader there is no broken pipe, just a EOF.
       // On windows: the reader also sees a broken pipe error.
@@ -3255,6 +3053,49 @@ ssize_t WriteAll(int fd, const void* buf, size_t count) {
   return static_cast<ssize_t>(written);
 }
 
+base::Status CopyFileContents(int fd_in, int fd_out) {
+  off_t original_offset = lseek(fd_in, 0, SEEK_CUR);
+  if (original_offset == -1) {
+    return base::ErrStatus(
+        "Can't get offset in 'fd_in', lseek error: %s (errno: %d)",
+        strerror(errno), errno);
+  }
+
+  if (lseek(fd_in, 0, SEEK_SET) == -1) {
+    return base::ErrStatus(
+        "Can't change the offset in 'fd_in', lseek error: %s (errno: %d)",
+        strerror(errno), errno);
+  }
+
+  auto restore_offset_on_exit = OnScopeExit([fd_in, original_offset] {
+    // 'lseek' should never fail here, but if it fails, we crash, to prevent
+    // possible data loss/overwrite in the 'fd_in'.
+    PERFETTO_CHECK(lseek(fd_in, original_offset, SEEK_SET) >= 0);
+  });
+
+  // Use bigger buffer when copy files.
+  constexpr size_t kCopyFileBufSize = 32 * 1024;  // 32KB.
+  static_assert(kCopyFileBufSize > kBufSize);
+  // Don't allocate that much memory on stack.
+  std::vector<char> buffer(kCopyFileBufSize);
+  for (;;) {
+    ssize_t bytes_read = Read(fd_in, buffer.data(), buffer.size());
+    if (bytes_read == 0)
+      break;
+    if (bytes_read < 0) {
+      return base::ErrStatus("Read failed: %s (errno: %d)", strerror(errno),
+                             errno);
+    }
+    ssize_t written =
+        WriteAll(fd_out, buffer.data(), static_cast<size_t>(bytes_read));
+    if (written != bytes_read) {
+      return base::ErrStatus("Write failed: %s (errno: %d)", strerror(errno),
+                             errno);
+    }
+  }
+  return base::OkStatus();
+}
+
 ssize_t WriteAllHandle(PlatformHandle h, const void* buf, size_t count) {
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
   DWORD wsize = 0;
@@ -3314,19 +3155,33 @@ ScopedFile OpenFile(const std::string& path, int flags, FileOpenMode mode) {
   return fd;
 }
 
-ScopedFstream OpenFstream(const char* path, const char* mode) {
+ScopedFstream OpenFstream(const std::string& path, const std::string& mode) {
   ScopedFstream file;
-// On Windows fopen interprets filename using the ANSI or OEM codepage but
-// sqlite3_value_text returns a UTF-8 string. To make sure we interpret the
-// filename correctly we use _wfopen and a UTF-16 string on windows.
+  // On Windows fopen interprets filename using the ANSI or OEM codepage but
+  // sqlite3_value_text returns a UTF-8 string. To make sure we interpret the
+  // filename correctly we use _wfopen and a UTF-16 string on windows.
+  //
+  // On Windows fopen also open files in the text mode by default, but we want
+  // to open them in the binary mode, to avoid silly EOL translations (and to be
+  // consistent with base::OpenFile). So we check the mode first and append 'b'
+  // mode only when it makes sense.
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  std::string s_mode(mode);
+  // Windows supports non-standard mode extension that sets encoding in text
+  // mode. If you need to open a FILE* in text mode, use the fopen API directly.
+  bool is_text_mode = Contains(s_mode, "ccs=") || Contains(s_mode, "t");
+  PERFETTO_CHECK(!is_text_mode);
+  bool is_binary_mode = Contains(s_mode, 'b');
+  if (!is_binary_mode)
+    s_mode += 'b';
+
   auto w_path = ToUtf16(path);
-  auto w_mode = ToUtf16(mode);
+  auto w_mode = ToUtf16(s_mode);
   if (w_path && w_mode) {
     file.reset(_wfopen(w_path->c_str(), w_mode->c_str()));
   }
 #else
-  file.reset(fopen(path, mode));
+  file.reset(fopen(path.c_str(), mode.c_str()));
 #endif
   return file;
 }
@@ -3407,10 +3262,12 @@ base::Status ListFilesRecursive(const std::string& dir_path,
           strcmp(dirent->d_name, "..") == 0) {
         continue;
       }
-      if (dirent->d_type == DT_DIR) {
-        dir_queue.push_back(cur_dir + dirent->d_name + '/');
-      } else if (dirent->d_type == DT_REG) {
-        const std::string full_path = cur_dir + dirent->d_name;
+      struct stat dirstat;
+      std::string full_path = cur_dir + dirent->d_name;
+      PERFETTO_CHECK(stat(full_path.c_str(), &dirstat) == 0);
+      if (S_ISDIR(dirstat.st_mode)) {
+        dir_queue.push_back(full_path + '/');
+      } else if (S_ISREG(dirstat.st_mode)) {
         PERFETTO_CHECK(full_path.length() > root_dir_path.length());
         output.push_back(full_path.substr(root_dir_path.length()));
       }
@@ -3420,6 +3277,59 @@ base::Status ListFilesRecursive(const std::string& dir_path,
   return base::OkStatus();
 }
 
+base::Status ListDirectories(const std::string& dir_path,
+                             std::vector<std::string>& output) {
+  std::string normalized_path = dir_path;
+  if (!normalized_path.empty() && normalized_path.back() != '/' &&
+      normalized_path.back() != '\\') {
+    normalized_path.push_back('/');
+  }
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_NACL)
+  return base::ErrStatus("ListDirectories not supported yet");
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  std::string glob_path = normalized_path + "*";
+  if (glob_path.length() + 1 > MAX_PATH) {
+    return base::ErrStatus("Directory path %s is too long", dir_path.c_str());
+  }
+  WIN32_FIND_DATAA ffd;
+
+  base::ScopedResource<HANDLE, CloseFindHandle, nullptr, false,
+                       base::PlatformHandleChecker>
+      hFind(FindFirstFileA(glob_path.c_str(), &ffd));
+  if (!hFind) {
+    return base::ErrStatus("Failed to open directory %s",
+                           normalized_path.c_str());
+  }
+  do {
+    if (strcmp(ffd.cFileName, ".") == 0 || strcmp(ffd.cFileName, "..") == 0) {
+      continue;
+    }
+    if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+      output.push_back(ffd.cFileName);
+    }
+  } while (FindNextFileA(*hFind, &ffd));
+#else
+  ScopedDir dir = ScopedDir(opendir(normalized_path.c_str()));
+  if (!dir) {
+    return base::ErrStatus("Failed to open directory %s",
+                           normalized_path.c_str());
+  }
+  for (auto* dirent = readdir(dir.get()); dirent != nullptr;
+       dirent = readdir(dir.get())) {
+    if (strcmp(dirent->d_name, ".") == 0 || strcmp(dirent->d_name, "..") == 0) {
+      continue;
+    }
+    std::string full_path = normalized_path + dirent->d_name;
+    struct stat dirstat;
+    if (stat(full_path.c_str(), &dirstat) == 0 && S_ISDIR(dirstat.st_mode)) {
+      output.push_back(dirent->d_name);
+    }
+  }
+#endif
+  return base::OkStatus();
+}
+
 std::string GetFileExtension(const std::string& filename) {
   auto ext_idx = filename.rfind('.');
   if (ext_idx == std::string::npos)
@@ -3427,83 +3337,271 @@ std::string GetFileExtension(const std::string& filename) {
   return filename.substr(ext_idx);
 }
 
-}  // namespace base
-}  // namespace perfetto
-// gen_amalgamated begin source: src/base/getopt_compat.cc
-// gen_amalgamated begin header: include/perfetto/ext/base/getopt_compat.h
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+std::string Basename(const std::string& path) {
+  // Handle empty path
+  if (path.empty())
+    return ".";
 
-#ifndef INCLUDE_PERFETTO_EXT_BASE_GETOPT_COMPAT_H_
-#define INCLUDE_PERFETTO_EXT_BASE_GETOPT_COMPAT_H_
+  // Make a copy to work with
+  std::string p = path;
 
-#include <cstddef>  // For std::nullptr_t
+  // Strip trailing slashes (both / and \)
+  while (p.size() > 1 && (p.back() == '/' || p.back() == '\\')) {
+    p.pop_back();
+  }
 
-// No translation units other than base/getopt.h and getopt_compat_unittest.cc
-// should directly include this file. Use base/getopt.h instead.
+  // If the path is now empty or just a single slash, return it
+  if (p.empty() || p == "/" || p == "\\")
+    return p.empty() ? "/" : p;
 
-namespace perfetto {
-namespace base {
-namespace getopt_compat {
+  // Find the last directory separator (either / or \)
+  size_t last_sep = p.find_last_of("/\\");
 
-// A tiny getopt() replacement for Windows, which doesn't have <getopt.h>.
-// This implementation is based on the subset of features that we use in the
-// Perfetto codebase. It doesn't even try to deal with the full surface of GNU's
-// getopt().
-// Limitations:
-// - getopt_long_only() is not supported.
-// - optional_argument is not supported. That is extremely subtle and caused us
-//   problems in the past with GNU's getopt.
-// - It does not reorder non-option arguments. It behaves like MacOS getopt, or
-//   GNU's when POSIXLY_CORRECT=1.
-// - Doesn't expose optopt or opterr.
-// - option.flag and longindex are not supported and must be nullptr.
+  if (last_sep == std::string::npos) {
+    // No separator found, the whole path is the basename
+    return p;
+  }
 
-enum {
-  no_argument = 0,
-  required_argument = 1,
-};
+  // Return everything after the last separator
+  return p.substr(last_sep + 1);
+}
 
-struct option {
-  const char* name;
-  int has_arg;
-  std::nullptr_t flag;  // Only nullptr is supported.
-  int val;
+std::string Dirname(const std::string& path) {
+  // Handle empty path
+  if (path.empty())
+    return ".";
+
+  // Make a copy to work with
+  std::string p = path;
+
+  // Strip trailing slashes (both / and \)
+  while (p.size() > 1 && (p.back() == '/' || p.back() == '\\')) {
+    p.pop_back();
+  }
+
+  // If the path is now just a single slash, return it
+  if (p == "/" || p == "\\")
+    return p;
+
+  // Find the last directory separator (either / or \)
+  size_t last_sep = p.find_last_of("/\\");
+
+  if (last_sep == std::string::npos) {
+    // No separator found, return "."
+    return ".";
+  }
+
+  // If the separator is at position 0, return the root
+  if (last_sep == 0)
+    return p.substr(0, 1);  // Return "/" or "\"
+
+  // Strip trailing slashes from the dirname part
+  while (last_sep > 0 && (p[last_sep - 1] == '/' || p[last_sep - 1] == '\\')) {
+    --last_sep;
+  }
+
+  // If we've consumed all characters, return the root
+  if (last_sep == 0)
+    return p.substr(0, 1);
+
+  // Return everything up to (but not including) the last separator
+  return p.substr(0, last_sep);
+}
+
+base::Status SetFilePermissions(const std::string& file_path,
+                                const std::string& group_name_or_id,
+                                const std::string& mode_bits) {
+#ifdef PERFETTO_SET_FILE_PERMISSIONS
+  PERFETTO_CHECK(!file_path.empty());
+  PERFETTO_CHECK(!group_name_or_id.empty());
+
+  // Default |group_id| to -1 for not changing the group ownership.
+  gid_t group_id = static_cast<gid_t>(-1);
+  auto maybe_group_id = base::StringToUInt32(group_name_or_id);
+  if (maybe_group_id) {  // A numerical group ID.
+    group_id = *maybe_group_id;
+  } else {  // A group name.
+    struct group* file_group = nullptr;
+    // Query the group ID of |group|.
+    do {
+      file_group = getgrnam(group_name_or_id.c_str());
+    } while (file_group == nullptr && errno == EINTR);
+    if (file_group == nullptr) {
+      return base::ErrStatus("Failed to get group information of %s ",
+                             group_name_or_id.c_str());
+    }
+    group_id = file_group->gr_gid;
+  }
+
+  if (PERFETTO_EINTR(chown(file_path.c_str(), geteuid(), group_id))) {
+    return base::ErrStatus("Failed to chown %s ", file_path.c_str());
+  }
+
+  // |mode| accepts values like "0660" as "rw-rw----" mode bits.
+  auto mode_value = base::StringToInt32(mode_bits, 8);
+  if (!(mode_bits.size() == 4 && mode_value.has_value())) {
+    return base::ErrStatus(
+        "The chmod mode bits must be a 4-digit octal number, e.g. 0660");
+  }
+  if (PERFETTO_EINTR(
+          chmod(file_path.c_str(), static_cast<mode_t>(mode_value.value())))) {
+    return base::ErrStatus("Failed to chmod %s", file_path.c_str());
+  }
+  return base::OkStatus();
+#else
+  base::ignore_result(file_path);
+  base::ignore_result(group_name_or_id);
+  base::ignore_result(mode_bits);
+  return base::ErrStatus(
+      "Setting file permissions is not supported on this platform");
+#endif
+}
+
+std::optional<uint64_t> GetFileSize(const std::string& file_path) {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  // This does not use base::OpenFile to avoid getting an exclusive lock.
+  base::ScopedPlatformHandle fd(
+      CreateFileA(file_path.c_str(), FILE_READ_ATTRIBUTES, FILE_SHARE_READ,
+                  nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr));
+#else
+  base::ScopedFile fd(base::OpenFile(file_path, O_RDONLY | O_CLOEXEC));
+#endif
+  if (!fd) {
+    return std::nullopt;
+  }
+  return GetFileSize(*fd);
+}
+
+std::optional<uint64_t> GetFileSize(PlatformHandle fd) {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  LARGE_INTEGER file_size;
+  file_size.QuadPart = 0;
+  if (!GetFileSizeEx(fd, &file_size)) {
+    return std::nullopt;
+  }
+  static_assert(sizeof(decltype(file_size.QuadPart)) <= sizeof(uint64_t));
+  return static_cast<uint64_t>(file_size.QuadPart);
+#else
+  struct stat buf{};
+  if (fstat(fd, &buf) == -1) {
+    return std::nullopt;
+  }
+  static_assert(sizeof(decltype(buf.st_size)) <= sizeof(uint64_t));
+  return static_cast<uint64_t>(buf.st_size);
+#endif
+}
+
+// LinuxFileWatch
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX_BUT_NOT_QNX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+
+namespace {
+
+// Implementation class extends LinuxFileWatch
+class FileWatchImpl : public LinuxFileWatch {
+ public:
+  FileWatchImpl(TaskRunner* tr,
+                std::string fn,
+                ScopedFile ifd,
+                std::function<void()> cb)
+      : task_runner_(tr),
+        file_base_name_(std::move(fn)),
+        inotify_fd_(std::move(ifd)),
+        callback_(std::move(cb)),
+        weak_ptr_factory_(this) {
+    task_runner_->AddFileDescriptorWatch(
+        *inotify_fd_, [weak_handle = weak_ptr_factory_.GetWeakPtr()] {
+          if (!weak_handle)
+            return;
+          alignas(struct inotify_event) char buf[4096];
+          ssize_t rsize =
+              base::Read(*weak_handle->inotify_fd_, buf, sizeof(buf));
+          if (rsize <= 0)
+            return;
+          for (ssize_t i = 0; i < rsize;) {
+            auto* evt = reinterpret_cast<struct inotify_event*>(&buf[i]);
+            i += static_cast<ssize_t>(sizeof(inotify_event) + evt->len);
+            if (evt->len > 0 && (evt->mask & IN_CREATE)) {
+              if (weak_handle->file_base_name_ == evt->name) {
+                weak_handle->task_runner_->PostTask(weak_handle->callback_);
+                return;
+              }
+            }
+          }  // for(evt);
+        });
+  }
+
+  ~FileWatchImpl() override {
+    if (!inotify_fd_)
+      return;
+    task_runner_->RemoveFileDescriptorWatch(*inotify_fd_);
+    inotify_fd_.reset();
+  }
+
+ private:
+  TaskRunner* task_runner_ = nullptr;
+  std::string file_base_name_;  // Only the name without the path.
+  ScopedFile inotify_fd_;
+  std::function<void()> callback_;
+  WeakPtrFactory<FileWatchImpl> weak_ptr_factory_;  // Keep last.
 };
 
-extern char* optarg;
-extern int optind;
-extern int optopt;
-extern int opterr;
+}  // namespace
 
-int getopt_long(int argc,
-                char** argv,
-                const char* shortopts,
-                const option* longopts,
-                std::nullptr_t /*longindex is not supported*/);
+std::unique_ptr<LinuxFileWatch> LinuxFileWatch::WatchFileCreation(
+    TaskRunner* task_runner,
+    const char* path,
+    std::function<void()> callback) {
+  if (!path || path[0] == '\0') {
+    // We can add a inotify watch only for valid filesystem paths.
+    return nullptr;
+  }
 
-int getopt(int argc, char** argv, const char* shortopts);
+  ScopedFile inotify_fd(inotify_init1(IN_CLOEXEC | IN_NONBLOCK));
+  if (!inotify_fd) {
+    PERFETTO_DLOG("inotify_init() failed");
+    return nullptr;
+  }
+
+  // Here we watch the parent dir, not the file itself. We cannot watch for
+  // a file that doesn't exist yet, because the kernel internally attaches the
+  // watch to an inode, and a non-existing file doesn't have inodes.
+  // We are not interested in IN_MOVED_TO because we don't mv files.
+  std::string file_dir = Dirname(path);
+  if (inotify_add_watch(*inotify_fd, file_dir.c_str(), IN_CREATE) < 0) {
+    PERFETTO_DLOG("inotify_add_watch(%s) failed", file_dir.c_str());
+    return nullptr;
+  }
+
+  std::string file_base_name = Basename(path);
+
+  return std::unique_ptr<LinuxFileWatch>(
+      new FileWatchImpl(task_runner, std::move(file_base_name),
+                        std::move(inotify_fd), std::move(callback)));
+}
+
+LinuxFileWatch::~LinuxFileWatch() = default;
+
+#else
+
+std::unique_ptr<LinuxFileWatch> LinuxFileWatch::WatchFileCreation(
+    TaskRunner*,
+    const char*,
+    std::function<void()>) {
+  return nullptr;  // Not supported on other platforms.
+}
+
+LinuxFileWatch::~LinuxFileWatch() = default;
+
+#endif  // OS_LINUX || OS_ANDROID
 
-}  // namespace getopt_compat
 }  // namespace base
 }  // namespace perfetto
-
-#endif  // INCLUDE_PERFETTO_EXT_BASE_GETOPT_COMPAT_H_
+// gen_amalgamated begin source: src/base/fixed_string_writer.cc
+// gen_amalgamated begin header: include/perfetto/ext/base/fixed_string_writer.h
 /*
- * Copyright (C) 2021 The Android Open Source Project
+ * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -3518,40 +3616,380 @@ int getopt(int argc, char** argv, const char* shortopts);
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/getopt_compat.h"
+#ifndef INCLUDE_PERFETTO_EXT_BASE_FIXED_STRING_WRITER_H_
+#define INCLUDE_PERFETTO_EXT_BASE_FIXED_STRING_WRITER_H_
 
-#include <stdio.h>
-#include <stdlib.h>
 #include <string.h>
 
-#include <vector>
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstdlib>
+#include <limits>
+#include <type_traits>
 
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_view.h"
 
 namespace perfetto {
 namespace base {
-namespace getopt_compat {
 
-char* optarg = nullptr;
-int optind = 0;
-int optopt = 0;
-int opterr = 1;
+// A helper class which writes formatted data to a string buffer.
+// This is used in the trace processor where we write O(GBs) of strings and
+// sprintf is too slow.
+class FixedStringWriter {
+ public:
+  // Creates a string buffer from a char buffer and length.
+  FixedStringWriter(char* buffer, size_t size) : buffer_(buffer), size_(size) {}
 
-namespace {
+  // Appends n instances of a char to the buffer.
+  void AppendChar(char in, size_t n = 1) {
+    PERFETTO_DCHECK(pos_ + n <= size_);
+    memset(&buffer_[pos_], in, n);
+    pos_ += n;
+  }
 
-char* nextchar = nullptr;
+  // Appends a length delimited string to the buffer.
+  void AppendString(const char* in, size_t n) {
+    PERFETTO_DCHECK(pos_ + n <= size_);
+    memcpy(&buffer_[pos_], in, n);
+    pos_ += n;
+  }
 
-const option* LookupLongOpt(const std::vector<option>& opts,
-                            const char* name,
-                            size_t len) {
-  for (const option& opt : opts) {
-    if (strncmp(opt.name, name, len) == 0 && strlen(opt.name) == len)
-      return &opt;
+  void AppendStringView(StringView sv) { AppendString(sv.data(), sv.size()); }
+
+  // Appends a null-terminated string literal to the buffer.
+  template <size_t N>
+  inline void AppendLiteral(const char (&in)[N]) {
+    AppendString(in, N - 1);
   }
-  return nullptr;
-}
 
-const option* LookupShortOpt(const std::vector<option>& opts, char c) {
+  // Appends a StringView to the buffer.
+  void AppendString(StringView data) { AppendString(data.data(), data.size()); }
+
+  // Appends an integer to the buffer.
+  void AppendInt(int64_t value) { AppendPaddedInt<'0', 0>(value); }
+
+  // Appends an integer to the buffer, padding with |padchar| if the number of
+  // digits of the integer is less than |padding|.
+  template <char padchar, uint64_t padding>
+  void AppendPaddedInt(int64_t sign_value) {
+    const bool negate = std::signbit(static_cast<double>(sign_value));
+    uint64_t absolute_value;
+    if (sign_value == std::numeric_limits<int64_t>::min()) {
+      absolute_value =
+          static_cast<uint64_t>(std::numeric_limits<int64_t>::max()) + 1;
+    } else {
+      absolute_value = static_cast<uint64_t>(std::abs(sign_value));
+    }
+    AppendPaddedInt<padchar, padding>(absolute_value, negate);
+  }
+
+  void AppendUnsignedInt(uint64_t value) {
+    AppendPaddedUnsignedInt<'0', 0>(value);
+  }
+
+  // Appends an unsigned integer to the buffer, padding with |padchar| if the
+  // number of digits of the integer is less than |padding|.
+  template <char padchar, uint64_t padding>
+  void AppendPaddedUnsignedInt(uint64_t value) {
+    AppendPaddedInt<padchar, padding>(value, false);
+  }
+
+  template <typename IntType>
+  void AppendPaddedHexInt(IntType value, char padchar, uint64_t padding) {
+    using UnsignedType = std::make_unsigned_t<IntType>;
+    constexpr size_t kMaxHexDigits = sizeof(IntType) * 2;
+    // 32 bytes is more than enough for any integer type (max 16 hex digits for
+    // 64-bit)
+    constexpr size_t kBufferSize = 32;
+    auto size_needed =
+        kMaxHexDigits > padding ? kMaxHexDigits : static_cast<size_t>(padding);
+    PERFETTO_DCHECK(size_needed <= kBufferSize);
+    PERFETTO_DCHECK(pos_ + size_needed <= size_);
+
+    std::array<char, kBufferSize> data;
+    constexpr char hex_asc[] = "0123456789abcdef";
+
+    size_t idx = size_needed - 1;
+    auto uvalue = static_cast<UnsignedType>(value);
+    do {
+      data[idx--] = hex_asc[uvalue & 0xF];
+      uvalue >>= 4;
+    } while (uvalue != 0);
+
+    if (padding > 0) {
+      const auto num_digits = static_cast<uint64_t>(size_needed - 1 - idx);
+      // std::max() needed to work around GCC not being able to tell that
+      // padding > 0.
+      for (auto i = num_digits; i < std::max(uint64_t{1u}, padding); i++) {
+        data[idx--] = padchar;
+      }
+    }
+    AppendString(&data[idx + 1], size_needed - idx - 1);
+  }
+
+  // Appends a hex integer to the buffer.
+  template <typename IntType>
+  void AppendHexInt(IntType value) {
+    AppendPaddedHexInt(value, '0', 0);
+  }
+
+  // Appends a hex string to the buffer.
+  void AppendHexString(const uint8_t* data, size_t size, char separator);
+
+  void AppendHexString(StringView data, char separator) {
+    AppendHexString(reinterpret_cast<const uint8_t*>(data.data()), data.size(),
+                    separator);
+  }
+
+  // Appends a double to the buffer.
+  void AppendDouble(double value) {
+    // TODO(lalitm): trying to optimize this is premature given we almost never
+    // print doubles. Reevaluate this in the future if we do print them more.
+    size_t res = base::SprintfTrunc(buffer_ + pos_, size_ - pos_, "%lf", value);
+    PERFETTO_DCHECK(pos_ + res <= size_);
+    pos_ += res;
+  }
+
+  void AppendBool(bool value) {
+    if (value) {
+      AppendLiteral("true");
+      return;
+    }
+    AppendLiteral("false");
+  }
+
+  StringView GetStringView() {
+    PERFETTO_DCHECK(pos_ <= size_);
+    return StringView(buffer_, pos_);
+  }
+
+  char* CreateStringCopy() {
+    char* dup = reinterpret_cast<char*>(malloc(pos_ + 1));
+    if (dup) {
+      memcpy(dup, buffer_, pos_);
+      dup[pos_] = '\0';
+    }
+    return dup;
+  }
+
+  size_t pos() const { return pos_; }
+  size_t size() const { return size_; }
+  void reset() { pos_ = 0; }
+
+ private:
+  template <char padchar, uint64_t padding>
+  void AppendPaddedInt(uint64_t absolute_value, bool negate) {
+    // Need to add 2 to the number of digits to account for minus sign and
+    // rounding down of digits10.
+    constexpr auto kMaxDigits = std::numeric_limits<uint64_t>::digits10 + 2;
+    constexpr auto kSizeNeeded = kMaxDigits > padding ? kMaxDigits : padding;
+    PERFETTO_DCHECK(pos_ + kSizeNeeded <= size_);
+
+    char data[kSizeNeeded];
+
+    size_t idx;
+    for (idx = kSizeNeeded - 1; absolute_value >= 10;) {
+      char digit = absolute_value % 10;
+      absolute_value /= 10;
+      data[idx--] = digit + '0';
+    }
+    data[idx--] = static_cast<char>(absolute_value) + '0';
+
+    if (padding > 0) {
+      size_t num_digits = kSizeNeeded - 1 - idx;
+      // std::max() needed to work around GCC not being able to tell that
+      // padding > 0.
+      for (size_t i = num_digits; i < std::max(uint64_t{1u}, padding); i++) {
+        data[idx--] = padchar;
+      }
+    }
+
+    if (negate)
+      buffer_[pos_++] = '-';
+    AppendString(&data[idx + 1], kSizeNeeded - idx - 1);
+  }
+
+  char* buffer_ = nullptr;
+  size_t size_ = 0;
+  size_t pos_ = 0;
+};
+
+}  // namespace base
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_FIXED_STRING_WRITER_H_
+/*
+ * Copyright (C) 2026 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "perfetto/ext/base/fixed_string_writer.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+
+namespace perfetto {
+namespace base {
+
+void FixedStringWriter::AppendHexString(const uint8_t* data,
+                                        size_t size,
+                                        char separator) {
+  // Truncate to 64 bytes, as this is the maximum supported by the Linux
+  // kernel's vsnprintf implementation.
+  size_t printed_size = std::min<size_t>(size, size_t{64});
+  // Remove trailing separator from calculation if printed_size > 0.
+  size_t max_chars = printed_size * 3 - (printed_size > 0 ? 1 : 0);
+  PERFETTO_DCHECK(pos_ + max_chars <= size_);
+
+  if (printed_size) {
+    AppendPaddedHexInt(data[0], '0', 2);
+  }
+  for (size_t pos = 1; pos < printed_size; pos++) {
+    AppendChar(separator);
+    AppendPaddedHexInt(data[pos], '0', 2);
+  }
+}
+
+}  // namespace base
+}  // namespace perfetto
+// gen_amalgamated begin source: src/base/getopt_compat.cc
+// gen_amalgamated begin header: include/perfetto/ext/base/getopt_compat.h
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_EXT_BASE_GETOPT_COMPAT_H_
+#define INCLUDE_PERFETTO_EXT_BASE_GETOPT_COMPAT_H_
+
+#include <cstddef>  // For std::nullptr_t
+
+// No translation units other than base/getopt.h and getopt_compat_unittest.cc
+// should directly include this file. Use base/getopt.h instead.
+
+namespace perfetto {
+namespace base {
+namespace getopt_compat {
+
+// A tiny getopt() replacement for Windows, which doesn't have <getopt.h>.
+// This implementation is based on the subset of features that we use in the
+// Perfetto codebase. It doesn't even try to deal with the full surface of GNU's
+// getopt().
+// Limitations:
+// - getopt_long_only() is not supported.
+// - optional_argument is not supported. That is extremely subtle and caused us
+//   problems in the past with GNU's getopt.
+// - It does not reorder non-option arguments. It behaves like MacOS getopt, or
+//   GNU's when POSIXLY_CORRECT=1.
+// - Doesn't expose optopt or opterr.
+// - option.flag and longindex are not supported and must be nullptr.
+
+enum {
+  no_argument = 0,
+  required_argument = 1,
+};
+
+struct option {
+  const char* name;
+  int has_arg;
+  std::nullptr_t flag;  // Only nullptr is supported.
+  int val;
+};
+
+extern char* optarg;
+extern int optind;
+extern int optopt;
+extern int opterr;
+
+int getopt_long(int argc,
+                char** argv,
+                const char* shortopts,
+                const option* longopts,
+                std::nullptr_t /*longindex is not supported*/);
+
+int getopt(int argc, char** argv, const char* shortopts);
+
+}  // namespace getopt_compat
+}  // namespace base
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_GETOPT_COMPAT_H_
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "perfetto/ext/base/getopt_compat.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <vector>
+
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+
+namespace perfetto {
+namespace base {
+namespace getopt_compat {
+
+char* optarg = nullptr;
+int optind = 0;
+int optopt = 0;
+int opterr = 1;
+
+namespace {
+
+char* nextchar = nullptr;
+
+const option* LookupLongOpt(const std::vector<option>& opts,
+                            const char* name,
+                            size_t len) {
+  for (const option& opt : opts) {
+    if (strncmp(opt.name, name, len) == 0 && strlen(opt.name) == len)
+      return &opt;
+  }
+  return nullptr;
+}
+
+const option* LookupShortOpt(const std::vector<option>& opts, char c) {
   for (const option& opt : opts) {
     if (!*opt.name && opt.val == c)
       return &opt;
@@ -3736,6 +4174,769 @@ int getopt(int argc, char** argv, const char* shortopts) {
 }  // namespace getopt_compat
 }  // namespace base
 }  // namespace perfetto
+// gen_amalgamated begin source: src/base/intrusive_list.cc
+// gen_amalgamated begin header: include/perfetto/ext/base/intrusive_list.h
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_EXT_BASE_INTRUSIVE_LIST_H_
+#define INCLUDE_PERFETTO_EXT_BASE_INTRUSIVE_LIST_H_
+
+#include <cstddef>
+#include <cstdint>
+
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+
+// An intrusive (doubly linked) list implementation.
+// Unlike std::list<>, the entries being inserted into the list need to
+// explicitly declare an IntrusiveListNode structure (one for each list they are
+// part of). The user must specify a Traits struct for each list the entry is
+// part of. The traits struct defines how to get to the IntrusiveListNode from
+// the outer object.
+//
+// Usage example:
+// class Person {
+//  public:
+//   struct ListTraits {
+//     static constexpr size_t node_offset() { return offsetof(Person, node); }
+//   };
+//   std::string name;
+//   IntrusiveListNode node{};
+// }
+//
+// IntrusiveList<Person, Person::ListTraits> list;
+// Person person;
+// list.PushBack(person);
+// ...
+
+namespace perfetto::base {
+
+namespace internal {
+
+struct ListNode {
+  ListNode* prev;
+  ListNode* next;
+};
+
+// IntrusiveList's Base class to factor out type-independent code (avoid binary
+// bloat)
+class ListOps {
+ public:
+  void PushFront(ListNode* node);
+  void PopFront();
+  void Erase(ListNode* node);
+
+  ListNode* front_{nullptr};
+  size_t size_{0};
+};
+
+}  // namespace internal
+
+using IntrusiveListNode = internal::ListNode;
+
+// T is the class that has one or more IntrusiveListNode as fields.
+// Traits defines getter and offset between node and T.
+// Traits is separate to allow the same T to be part of different lists (which
+// necessitate a different Traits, at very least for the offset).
+template <typename T, typename ListTraits>
+class IntrusiveList : private internal::ListOps {
+ public:
+  class Iterator {
+   public:
+    Iterator() = default;
+    explicit Iterator(IntrusiveListNode* node) : node_(node) {}
+    ~Iterator() = default;
+    Iterator(const Iterator&) = default;
+    Iterator& operator=(const Iterator&) = default;
+    Iterator(Iterator&&) noexcept = default;
+    Iterator& operator=(Iterator&&) noexcept = default;
+
+    bool operator==(const Iterator& other) const {
+      return node_ == other.node_;
+    }
+    bool operator!=(const Iterator& other) const { return !(*this == other); }
+    T* operator->() { return const_cast<T*>(entryof(node_)); }
+    T& operator*() {
+      PERFETTO_DCHECK(node_);
+      return *operator->();
+    }
+    explicit operator bool() const { return node_ != nullptr; }
+
+    Iterator& operator++() {
+      PERFETTO_DCHECK(node_);
+      node_ = node_->next;
+      return *this;
+    }
+
+   private:
+    IntrusiveListNode* node_{nullptr};
+  };
+
+  using value_type = T;
+  using const_pointer = const T*;
+
+  void PushFront(T& entry) { internal::ListOps::PushFront(nodeof(&entry)); }
+
+  void PopFront() { internal::ListOps::PopFront(); }
+
+  T& front() {
+    PERFETTO_DCHECK(front_);
+    return const_cast<T&>(*entryof(front_));
+  }
+
+  void Erase(T& entry) { internal::ListOps::Erase(nodeof(&entry)); }
+
+  bool empty() const { return size_ == 0; }
+
+  size_t size() const { return size_; }
+
+  Iterator begin() { return Iterator{front_}; }
+
+  Iterator end() { return Iterator{nullptr}; }
+
+ private:
+  static constexpr size_t kNodeOffset = ListTraits::node_offset();
+
+  static constexpr IntrusiveListNode* nodeof(T* entry) {
+    return reinterpret_cast<IntrusiveListNode*>(
+        reinterpret_cast<uintptr_t>(entry) + kNodeOffset);
+  }
+
+  static constexpr const T* entryof(IntrusiveListNode* node) {
+    return reinterpret_cast<T*>(reinterpret_cast<uintptr_t>(node) -
+                                kNodeOffset);
+  }
+};
+
+}  // namespace perfetto::base
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_INTRUSIVE_LIST_H_
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "perfetto/ext/base/intrusive_list.h"
+
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+
+namespace perfetto::base::internal {
+
+void ListOps::PushFront(IntrusiveListNode* node) {
+  node->prev = nullptr;
+  node->next = front_;
+
+  if (front_) {
+    front_->prev = node;
+  }
+
+  front_ = node;
+  ++size_;
+}
+
+void ListOps::PopFront() {
+  PERFETTO_DCHECK(front_);
+  front_ = front_->next;
+
+  if (front_) {
+    front_->prev = nullptr;
+  }
+
+  PERFETTO_DCHECK(size_ > 0);
+  --size_;
+}
+
+void ListOps::Erase(IntrusiveListNode* node) {
+  auto* prev = node->prev;
+  auto* next = node->next;
+
+  if (node == front_) {
+    front_ = next;
+  }
+
+  if (prev) {
+    prev->next = next;
+  }
+
+  if (next) {
+    next->prev = prev;
+  }
+
+  PERFETTO_DCHECK(size_ > 0);
+  --size_;
+}
+
+}  // namespace perfetto::base::internal
+// gen_amalgamated begin source: src/base/intrusive_tree.cc
+// gen_amalgamated begin header: include/perfetto/ext/base/intrusive_tree.h
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_EXT_BASE_INTRUSIVE_TREE_H_
+#define INCLUDE_PERFETTO_EXT_BASE_INTRUSIVE_TREE_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+
+// An intrusive tree implementation, inspired from BSD kernel's tree.h
+// Unlike std::set<>, the nodes being inserted into the tree need to explicitly
+// declare a RBNode structure (one for each tree they are part of).
+// The user must specify a TreeTraits for each tree the struct is part of.
+// The traits struct defines the type of the key and how to get to the node
+// entry from the outer object.
+// Usage example:
+// class Person {
+//  public:
+//   struct Traits {
+//     using KeyType = std::string;
+//     static const KeyType& GetKey(const Person& p) { return p->unique_id; }
+//     static constexpr size_t NodeOffset() { return offsetof(Person, node); }
+//   };
+//   std::string unique_id;
+//   std::string name;
+//   std::string surname;
+//   IntrusiveTreeNode node{};
+// }
+//  IntrusiveTree<Person, Person::Traits> tree;
+//  tree.insert(&person1);
+//  ...
+
+namespace perfetto::base {
+
+namespace internal {
+
+enum RBColor : uint8_t {
+  BLACK = 0,
+  RED = 1,
+};
+
+struct RBNode {
+  RBNode* left = nullptr;
+  RBNode* right = nullptr;
+  RBNode* parent = nullptr;
+  RBColor color = RBColor::BLACK;
+};
+
+void RBInsertColor(RBNode** root, RBNode* elm);
+void RBRemove(RBNode** root, RBNode* elm);
+
+// Returns nullptr after reaching the last leaf (the max element).
+const RBNode* RBNext(const RBNode* node);
+
+// KeyCompare tries first to use the CompareKey function in Traits, if present.
+// The signature of that function is int(const KeyType&, const KeyType&).
+// If the comparator function doesn't exist, falls backk on std::less<KeyType>.
+template <
+    class Traits,
+    class = std::enable_if_t<std::is_function_v<typename Traits::CompareKey>,
+                             void> >
+int KeyCompare(const typename Traits::KeyType& k1,
+               const typename Traits::KeyType& k2) {
+  return Traits::CompareKey(k1, k2);
+}
+
+// SFINAE fallback on std::less<KeyType>
+template <class Traits>
+int KeyCompare(const typename Traits::KeyType& k1,
+               const typename Traits::KeyType& k2) {
+  std::less<typename Traits::KeyType> less_cmp;
+  return less_cmp(k1, k2) ? -1 : (less_cmp(k2, k1) ? 1 : 0);
+}
+
+}  // namespace internal
+
+using IntrusiveTreeNode = internal::RBNode;
+
+// T is the class that has one or more IntrusiveTreeNode as fiels.
+// Traits defines the key type, getter and offset between node and T.
+// Traits is separate to allow the same T to be part of different trees (which
+// necessitate a different Traits, at very least for the offset).
+template <typename T, typename Traits>
+class IntrusiveTree {
+ public:
+  using Key = typename Traits::KeyType;
+
+  class Iterator {
+   public:
+    Iterator() = default;
+    explicit Iterator(const internal::RBNode* node) : node_(node) {}
+    ~Iterator() = default;
+    Iterator(const Iterator&) = default;
+    Iterator& operator=(const Iterator&) = default;
+    Iterator(Iterator&&) noexcept = default;
+    Iterator& operator=(Iterator&&) noexcept = default;
+
+    bool operator==(const Iterator& o) const { return node_ == o.node_; }
+    bool operator!=(const Iterator& o) const { return !(*this == o); }
+    const T* operator->() const { return entryof(node_); }
+    const T& operator*() const {
+      PERFETTO_DCHECK(node_ != nullptr);
+      return *operator->();
+    }
+    T* operator->() { return const_cast<T*>(entryof(node_)); }
+    T& operator*() {
+      PERFETTO_DCHECK(node_ != nullptr);
+      return *operator->();
+    }
+    explicit operator bool() const { return node_ != nullptr; }
+
+    Iterator& operator++() {
+      node_ = internal::RBNext(node_);
+      return *this;
+    }
+
+   private:
+    const internal::RBNode* node_ = nullptr;
+  };  // Iterator
+
+  using value_type = T;
+  using const_pointer = const T*;
+  using const_iterator = Iterator;
+
+  std::pair<Iterator, bool> Insert(T& entry) {
+    // The insertion preamble is inlined because it's few instructions and
+    // out-lining it would require std::function indirections for getting the
+    // key and the comparator.
+    int comp = 0;
+    internal::RBNode* tmp = root_;
+    internal::RBNode* parent = nullptr;
+    internal::RBNode* const entry_node = nodeof(&entry);
+    while (tmp) {
+      parent = tmp;
+      comp = key_compare(entry_node, parent);
+      if (comp < 0) {
+        tmp = tmp->left;
+      } else if (comp > 0) {
+        tmp = tmp->right;
+      } else {
+        return {Iterator(tmp), false};  // The key exists already.
+      }
+    }  // while(tmp)
+    entry_node->left = entry_node->right = nullptr;
+    entry_node->parent = parent;
+    entry_node->color = internal::RBColor::RED;
+    if (parent) {
+      if (comp < 0) {
+        PERFETTO_DCHECK(parent->left == nullptr);
+        parent->left = entry_node;
+      } else {
+        PERFETTO_DCHECK(parent->right == nullptr);
+        parent->right = entry_node;
+      }
+    } else {
+      root_ = entry_node;
+    }
+    internal::RBInsertColor(&root_, entry_node);
+    ++size_;
+    return {Iterator(entry_node), true};
+  }
+
+  Iterator Find(const Key& key) const {
+    internal::RBNode* tmp = root_;
+    while (tmp) {
+      int comp =
+          internal::KeyCompare<Traits>(key, Traits::GetKey(*entryof(tmp)));
+      if (comp < 0) {
+        tmp = tmp->left;
+      } else if (comp > 0) {
+        tmp = tmp->right;
+      } else {
+        return Iterator(tmp);
+      }
+    }
+    return Iterator(nullptr);
+  }
+
+  bool Remove(const Key& key) {
+    Iterator it = Find(key);
+    if (!it)
+      return false;
+    internal::RBRemove(&root_, nodeof(std::addressof(*it)));
+    --size_;
+    return true;
+  }
+
+  Iterator Remove(T& entry) { return Remove(Iterator(nodeof(&entry))); }
+
+  Iterator Remove(Iterator it) {
+    Iterator next = it;
+    ++next;
+    internal::RBRemove(&root_, nodeof(std::addressof(*it)));
+    --size_;
+    return next;
+  }
+
+  size_t Size() const { return size_; }
+
+  Iterator begin() const {
+    const internal::RBNode* node = root_;
+    while (node && node->left)
+      node = node->left;
+    return Iterator(node);
+  }
+
+  Iterator end() const { return Iterator(nullptr); }
+
+ private:
+  static constexpr size_t off_ = Traits::NodeOffset();
+  static internal::RBNode* nodeof(T* t) {
+    PERFETTO_DCHECK(t != nullptr);
+    return reinterpret_cast<internal::RBNode*>(reinterpret_cast<uintptr_t>(t) +
+                                               off_);
+  }
+  static const T* entryof(const internal::RBNode* n) {
+    PERFETTO_DCHECK(n != nullptr);
+    return reinterpret_cast<T*>(reinterpret_cast<uintptr_t>(n) - off_);
+  }
+  static int key_compare(const internal::RBNode* node_a,
+                         const internal::RBNode* node_b) {
+    auto* a = entryof(node_a);
+    auto* b = entryof(node_b);
+    return internal::KeyCompare<Traits>(Traits::GetKey(*a), Traits::GetKey(*b));
+  }
+
+  internal::RBNode* root_ = nullptr;
+  size_t size_ = 0;
+};
+
+}  // namespace perfetto::base
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_INTRUSIVE_TREE_H_
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* Part of this work is inspired by the original OpenBSD's tree.h */
+/* $OpenBSD: tree.h,v 1.31 2023/03/08 04:43:09 guenther Exp $ */
+/*
+ * Copyright 2002 Niels Provos <provos@citi.umich.edu>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// gen_amalgamated expanded: #include "perfetto/ext/base/intrusive_tree.h"
+
+namespace perfetto::base::internal {
+
+namespace {
+
+void RBSetBlackRed(RBNode* black, RBNode* red) {
+  black->color = RBColor::BLACK;
+  red->color = RBColor::RED;
+}
+
+void RBRotateLeft(RBNode** root, RBNode* elm, RBNode* tmp) {
+  tmp = elm->right;
+  if ((elm->right = tmp->left)) {
+    tmp->left->parent = elm;
+  }
+  // RB_AUGMENT(elm);
+  if ((tmp->parent = elm->parent)) {
+    if (elm == elm->parent->left)
+      elm->parent->left = tmp;
+    else
+      elm->parent->right = tmp;
+  } else
+    *root = tmp;
+  tmp->left = elm;
+  elm->parent = tmp;
+  // RB_AUGMENT(tmp);
+  // if ((tmp->parent))
+  // RB_AUGMENT(tmp->parent);
+}
+
+void RBRotateRight(RBNode** root, RBNode* elm, RBNode* tmp) {
+  tmp = elm->left;
+  if ((elm->left = tmp->right)) {
+    tmp->right->parent = elm;
+  }
+  // RB_AUGMENT(elm);
+  if ((tmp->parent = elm->parent)) {
+    if (elm == elm->parent->left)
+      elm->parent->left = tmp;
+    else
+      elm->parent->right = tmp;
+  } else
+    *root = tmp;
+  tmp->right = elm;
+  elm->parent = tmp;
+  // RB_AUGMENT(tmp);
+  // if ((tmp->parent))
+  // RB_AUGMENT(tmp->parent);
+}
+
+void RBRemoveColor(RBNode** root, RBNode* parent, RBNode* elm) {
+  RBNode* tmp;
+  while ((elm == nullptr || elm->color == RBColor::BLACK) && elm != *root) {
+    if (parent->left == elm) {
+      tmp = parent->right;
+      if (tmp->color == RBColor::RED) {
+        RBSetBlackRed(tmp, parent);
+        RBRotateLeft(root, parent, tmp);
+        tmp = parent->right;
+      }
+      if ((tmp->left == nullptr || tmp->left->color == RBColor::BLACK) &&
+          (tmp->right == nullptr || tmp->right->color == RBColor::BLACK)) {
+        tmp->color = RBColor::RED;
+        elm = parent;
+        parent = elm->parent;
+      } else {
+        if (tmp->right == nullptr || tmp->right->color == RBColor::BLACK) {
+          RBNode* oleft;
+          if ((oleft = tmp->left))
+            oleft->color = RBColor::BLACK;
+          tmp->color = RBColor::RED;
+          RBRotateRight(root, tmp, oleft);
+          tmp = parent->right;
+        }
+        tmp->color = parent->color;
+        parent->color = RBColor::BLACK;
+        if (tmp->right)
+          tmp->right->color = RBColor::BLACK;
+        RBRotateLeft(root, parent, tmp);
+        elm = *root;
+        break;
+      }
+    } else {
+      tmp = parent->left;
+      if (tmp->color == RBColor::RED) {
+        RBSetBlackRed(tmp, parent);
+        RBRotateRight(root, parent, tmp);
+        tmp = parent->left;
+      }
+      if ((tmp->left == nullptr || tmp->left->color == RBColor::BLACK) &&
+          (tmp->right == nullptr || tmp->right->color == RBColor::BLACK)) {
+        tmp->color = RBColor::RED;
+        elm = parent;
+        parent = elm->parent;
+      } else {
+        if (tmp->left == nullptr || tmp->left->color == RBColor::BLACK) {
+          RBNode* oright;
+          if ((oright = tmp->right))
+            oright->color = RBColor::BLACK;
+          tmp->color = RBColor::RED;
+          RBRotateLeft(root, tmp, oright);
+          tmp = parent->left;
+        }
+        tmp->color = parent->color;
+        parent->color = RBColor::BLACK;
+        if (tmp->left)
+          tmp->left->color = RBColor::BLACK;
+        RBRotateRight(root, parent, tmp);
+        elm = *root;
+        break;
+      }
+    }
+  }
+  if (elm)
+    elm->color = RBColor::BLACK;
+}
+
+}  // namespace
+
+void RBInsertColor(RBNode** root, RBNode* elm) {
+  RBNode *parent, *gparent, *tmp;
+  while ((parent = elm->parent) && parent->color == RBColor::RED) {
+    gparent = parent->parent;
+    if (parent == gparent->left) {
+      tmp = gparent->right;
+      if (tmp && tmp->color == RBColor::RED) {
+        tmp->color = RBColor::BLACK;
+        RBSetBlackRed(parent, gparent);
+        elm = gparent;
+        continue;
+      }
+      if (parent->right == elm) {
+        RBRotateLeft(root, parent, tmp);
+        tmp = parent;
+        parent = elm;
+        elm = tmp;
+      }
+      RBSetBlackRed(parent, gparent);
+      RBRotateRight(root, gparent, tmp);
+    } else {
+      tmp = gparent->left;
+      if (tmp && tmp->color == RBColor::RED) {
+        tmp->color = RBColor::BLACK;
+        RBSetBlackRed(parent, gparent);
+        elm = gparent;
+        continue;
+      }
+      if (parent->left == elm) {
+        RBRotateRight(root, parent, tmp);
+        tmp = parent;
+        parent = elm;
+        elm = tmp;
+      }
+      RBSetBlackRed(parent, gparent);
+      RBRotateLeft(root, gparent, tmp);
+    }
+  }
+  (*root)->color = RBColor::BLACK;
+}
+
+void RBRemove(RBNode** root, RBNode* elm) {
+  RBNode* child = elm;
+  RBNode* parent = elm;
+  RBNode* old = elm;
+  RBColor color;
+
+  if (elm->left == nullptr)
+    child = elm->right;
+  else if (elm->right == nullptr)
+    child = elm->left;
+  else {
+    RBNode* left;
+    elm = elm->right;
+    while ((left = elm->left))
+      elm = left;
+    child = elm->right;
+    parent = elm->parent;
+    color = elm->color;
+    if (child)
+      child->parent = parent;
+    if (parent) {
+      if (parent->left == elm) {
+        parent->left = child;
+      } else {
+        parent->right = child;
+      }
+      // RB_AUGMENT(parent);
+    } else {
+      *root = child;
+    }
+    if (elm->parent == old)
+      parent = elm;
+    *elm = *old;
+    if (old->parent) {
+      if (old->parent->left == old) {
+        old->parent->left = elm;
+      } else {
+        old->parent->right = elm;
+      }
+      // RB_AUGMENT(old->parent);
+    } else {
+      *root = elm;
+    }
+    old->left->parent = elm;
+    if (old->right)
+      old->right->parent = elm;
+    if (parent) {
+      left = parent;
+      // do {
+      //   RB_AUGMENT(left);
+      // } while ((left = left->parent));
+    }
+    goto color;
+  }
+  parent = elm->parent;
+  color = elm->color;
+  if (child)
+    child->parent = parent;
+  if (parent) {
+    if (parent->left == elm)
+      parent->left = child;
+    else
+      parent->right = child;
+    // RB_AUGMENT(parent);
+  } else {
+    *root = child;
+  }
+color:
+  if (color == RBColor::BLACK)
+    RBRemoveColor(root, parent, child);
+}
+
+// Returns nullptr after reaching the last leaf (the max element).
+const RBNode* RBNext(const RBNode* node) {
+  if (node->right) {
+    node = node->right;
+    while (node->left)
+      node = node->left;
+  } else {
+    if (node->parent && node == node->parent->left) {
+      node = node->parent;
+    } else {
+      while (node->parent && node == node->parent->right) {
+        node = node->parent;
+      }
+      node = node->parent;
+    }
+  }
+  return node;
+}
+
+}  // namespace perfetto::base::internal
 // gen_amalgamated begin source: src/base/logging.cc
 // gen_amalgamated begin header: src/base/log_ring_buffer.h
 // gen_amalgamated begin header: include/perfetto/ext/base/thread_annotations.h
@@ -3765,15 +4966,13 @@ int getopt(int argc, char** argv, const char* shortopts) {
 extern "C" {
 void AnnotateBenignRaceSized(const char* file,
                              int line,
-                             unsigned long address,
-                             unsigned long size,
+                             const volatile void* address,
+                             size_t size,
                              const char* description);
 }
 
-#define PERFETTO_ANNOTATE_BENIGN_RACE_SIZED(pointer, size, description)   \
-  AnnotateBenignRaceSized(__FILE__, __LINE__,                             \
-                          reinterpret_cast<unsigned long>(pointer), size, \
-                          description);
+#define PERFETTO_ANNOTATE_BENIGN_RACE_SIZED(pointer, size, description) \
+  AnnotateBenignRaceSized(__FILE__, __LINE__, pointer, size, description);
 #else  // defined(ADDRESS_SANITIZER)
 #define PERFETTO_ANNOTATE_BENIGN_RACE_SIZED(pointer, size, description)
 #endif  // defined(ADDRESS_SANITIZER)
@@ -3828,7 +5027,7 @@ constexpr size_t kLogRingBufMsgLen = 256;
 // - The Append() method can be called concurrently by several threads, unless
 //   there are > kLogRingBufEntries concurrent threads. Even if that happens,
 //   case some events will contain a mix of strings but the behavior of
-//   futher Append() and Read() is still defined.
+//   further Append() and Read() is still defined.
 // - The Read() method is not thread safe but it's fine in practice. Even if
 //   it's called concurrently with other Append(), it only causes some partial
 //   events to be emitted in output.
@@ -4111,7 +5310,7 @@ void LogMessage(LogLev level,
 
   // When printing on stderr, print also the timestamp. We don't really care
   // about the actual time. We just need some reference clock that can be used
-  // to correlated events across differrent processses (e.g. traced and
+  // to correlated events across different processes (e.g. traced and
   // traced_probes). The wall time % 1000 is good enough.
   uint32_t t_ms = static_cast<uint32_t>(GetWallTimeMs().count());
   uint32_t t_sec = t_ms / 1000;
@@ -4230,7 +5429,7 @@ enum Tags : uint32_t {
   F(FTRACE_CPU_WAIT_CMD), /*unused*/ \
   F(FTRACE_CPU_RUN_CYCLE), /*unused*/ \
   F(FTRACE_CPU_FLUSH), \
-  F(FTRACE_CPU_DRAIN), /*unused*/ \
+  F(FTRACE_CPU_BUFFER_WATERMARK), \
   F(READ_SYS_STATS), \
   F(PS_WRITE_ALL_PROCESSES), \
   F(PS_ON_PIDS), \
@@ -4612,85 +5811,6 @@ class ScopedEvent {
 }  // namespace perfetto
 
 #endif  // INCLUDE_PERFETTO_EXT_BASE_METATRACE_H_
-// gen_amalgamated begin header: include/perfetto/base/task_runner.h
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef INCLUDE_PERFETTO_BASE_TASK_RUNNER_H_
-#define INCLUDE_PERFETTO_BASE_TASK_RUNNER_H_
-
-#include <stdint.h>
-
-#include <functional>
-
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-// gen_amalgamated expanded: #include "perfetto/base/platform_handle.h"
-
-namespace perfetto {
-namespace base {
-
-// A generic interface to allow the library clients to interleave the execution
-// of the tracing internals in their runtime environment.
-// The expectation is that all tasks, which are queued either via PostTask() or
-// AddFileDescriptorWatch(), are executed on the same sequence (either on the
-// same thread, or on a thread pool that gives sequencing guarantees).
-//
-// Tasks are never executed synchronously inside PostTask and there is a full
-// memory barrier between tasks.
-//
-// All methods of this interface can be called from any thread.
-class PERFETTO_EXPORT_COMPONENT TaskRunner {
- public:
-  virtual ~TaskRunner();
-
-  // Schedule a task for immediate execution. Immediate tasks are always
-  // executed in the order they are posted. Can be called from any thread.
-  virtual void PostTask(std::function<void()>) = 0;
-
-  // Schedule a task for execution after |delay_ms|. Note that there is no
-  // strict ordering guarantee between immediate and delayed tasks. Can be
-  // called from any thread.
-  virtual void PostDelayedTask(std::function<void()>, uint32_t delay_ms) = 0;
-
-  // Schedule a task to run when the handle becomes readable. The same handle
-  // can only be monitored by one function. Note that this function only needs
-  // to be implemented on platforms where the built-in ipc framework is used.
-  // Can be called from any thread.
-  // TODO(skyostil): Refactor this out of the shared interface.
-  virtual void AddFileDescriptorWatch(PlatformHandle,
-                                      std::function<void()>) = 0;
-
-  // Remove a previously scheduled watch for the handle. If this is run on the
-  // target thread of this TaskRunner, guarantees that the task registered to
-  // this handle will not be executed after this function call.
-  // Can be called from any thread.
-  virtual void RemoveFileDescriptorWatch(PlatformHandle) = 0;
-
-  // Checks if the current thread is the same thread where the TaskRunner's task
-  // run. This allows single threaded task runners (like the ones used in
-  // perfetto) to inform the caller that anything posted will run on the same
-  // thread/sequence. This can allow some callers to skip PostTask and instead
-  // directly execute the code. Can be called from any thread.
-  virtual bool RunsTasksOnCurrentThread() const = 0;
-};
-
-}  // namespace base
-}  // namespace perfetto
-
-#endif  // INCLUDE_PERFETTO_BASE_TASK_RUNNER_H_
 /*
  * Copyright (C) 2018 The Android Open Source Project
  *
@@ -4729,13 +5849,6 @@ std::atomic<uint64_t> RingBuffer::rd_index_;
 std::atomic<bool> RingBuffer::has_overruns_;
 Record RingBuffer::bankruptcy_record_;
 
-#if !PERFETTO_IS_AT_LEAST_CPP17()
-constexpr size_t RingBuffer::kCapacity;
-constexpr uint16_t Record::kTypeMask;
-constexpr uint16_t Record::kTypeCounter;
-constexpr uint16_t Record::kTypeEvent;
-#endif
-
 namespace {
 
 // std::function<> is not trivially de/constructible. This struct wraps it in a
@@ -4920,6 +6033,7 @@ bool RingBuffer::IsOnValidTaskRunner() {
 #ifndef INCLUDE_PERFETTO_EXT_BASE_PAGED_MEMORY_H_
 #define INCLUDE_PERFETTO_EXT_BASE_PAGED_MEMORY_H_
 
+#include <cstddef>
 #include <memory>
 
 // gen_amalgamated expanded: #include "perfetto/base/build_config.h"
@@ -5025,9 +6139,10 @@ class PagedMemory {
 
 #include <algorithm>
 #include <cmath>
+#include <cstddef>
 
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-#include <Windows.h>
+#include <windows.h>
 #else  // PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
 #include <sys/mman.h>
 #endif  // PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
@@ -5132,6 +6247,10 @@ bool PagedMemory::AdviseDontNeed(void* p, size_t size) {
   // Discarding pages on Windows has more CPU cost than is justified for the
   // possible memory savings.
   return false;
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_QNX)
+  int res = posix_madvise(p, size, POSIX_MADV_DISCARD_NP);
+  PERFETTO_DCHECK(res == 0);
+  return true;
 #else   // PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) ||
         // PERFETTO_BUILDFLAG(PERFETTO_OS_NACL)
   // http://man7.org/linux/man-pages/man2/madvise.2.html
@@ -5144,7 +6263,6 @@ bool PagedMemory::AdviseDontNeed(void* p, size_t size) {
 
 #if TRACK_COMMITTED_SIZE()
 void PagedMemory::EnsureCommitted(size_t committed_size) {
-  PERFETTO_DCHECK(committed_size > 0u);
   PERFETTO_DCHECK(committed_size <= size_);
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
   if (committed_size_ >= committed_size)
@@ -5176,197 +6294,6 @@ void PagedMemory::EnsureCommitted(size_t committed_size) {
 }  // namespace perfetto
 // gen_amalgamated begin source: src/base/periodic_task.cc
 // gen_amalgamated begin header: include/perfetto/ext/base/periodic_task.h
-// gen_amalgamated begin header: include/perfetto/ext/base/thread_checker.h
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef INCLUDE_PERFETTO_EXT_BASE_THREAD_CHECKER_H_
-#define INCLUDE_PERFETTO_EXT_BASE_THREAD_CHECKER_H_
-
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
-
-#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-#include <pthread.h>
-#endif
-#include <atomic>
-
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
-
-namespace perfetto {
-namespace base {
-
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-using ThreadID = unsigned long;
-#else
-using ThreadID = pthread_t;
-#endif
-
-class PERFETTO_EXPORT_COMPONENT ThreadChecker {
- public:
-  ThreadChecker();
-  ~ThreadChecker();
-  ThreadChecker(const ThreadChecker&);
-  ThreadChecker& operator=(const ThreadChecker&);
-  bool CalledOnValidThread() const PERFETTO_WARN_UNUSED_RESULT;
-  void DetachFromThread();
-
- private:
-  mutable std::atomic<ThreadID> thread_id_;
-};
-
-#if PERFETTO_DCHECK_IS_ON() && !PERFETTO_BUILDFLAG(PERFETTO_CHROMIUM_BUILD)
-// TODO(primiano) Use Chromium's thread checker in Chromium.
-#define PERFETTO_THREAD_CHECKER(name) base::ThreadChecker name;
-#define PERFETTO_DCHECK_THREAD(name) \
-  PERFETTO_DCHECK((name).CalledOnValidThread())
-#define PERFETTO_DETACH_FROM_THREAD(name) (name).DetachFromThread()
-#else
-#define PERFETTO_THREAD_CHECKER(name)
-#define PERFETTO_DCHECK_THREAD(name)
-#define PERFETTO_DETACH_FROM_THREAD(name)
-#endif  // PERFETTO_DCHECK_IS_ON()
-
-}  // namespace base
-}  // namespace perfetto
-
-#endif  // INCLUDE_PERFETTO_EXT_BASE_THREAD_CHECKER_H_
-// gen_amalgamated begin header: include/perfetto/ext/base/weak_ptr.h
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef INCLUDE_PERFETTO_EXT_BASE_WEAK_PTR_H_
-#define INCLUDE_PERFETTO_EXT_BASE_WEAK_PTR_H_
-
-// gen_amalgamated expanded: #include "perfetto/ext/base/thread_checker.h"
-
-#include <memory>
-
-namespace perfetto {
-namespace base {
-
-// A simple WeakPtr for single-threaded cases.
-// Generally keep the WeakPtrFactory as last fields in classes: it makes the
-// WeakPtr(s) invalidate as first thing in the class dtor.
-// Usage:
-// class MyClass {
-//  MyClass() : weak_factory_(this) {}
-//  WeakPtr<MyClass> GetWeakPtr() { return weak_factory_.GetWeakPtr(); }
-//
-// private:
-//  WeakPtrFactory<MyClass> weak_factory_;
-// }
-//
-// int main() {
-//  std::unique_ptr<MyClass> foo(new MyClass);
-//  auto wptr = foo.GetWeakPtr();
-//  ASSERT_TRUE(wptr);
-//  ASSERT_EQ(foo.get(), wptr->get());
-//  foo.reset();
-//  ASSERT_FALSE(wptr);
-//  ASSERT_EQ(nullptr, wptr->get());
-// }
-
-template <typename T>
-class WeakPtrFactory;  // Forward declaration, defined below.
-
-template <typename T>
-class WeakPtr {
- public:
-  WeakPtr() {}
-  WeakPtr(const WeakPtr&) = default;
-  WeakPtr& operator=(const WeakPtr&) = default;
-  WeakPtr(WeakPtr&&) = default;
-  WeakPtr& operator=(WeakPtr&&) = default;
-
-  T* get() const {
-    PERFETTO_DCHECK_THREAD(thread_checker);
-    return handle_ ? *handle_.get() : nullptr;
-  }
-  T* operator->() const { return get(); }
-  T& operator*() const { return *get(); }
-
-  explicit operator bool() const { return !!get(); }
-
- private:
-  friend class WeakPtrFactory<T>;
-  explicit WeakPtr(const std::shared_ptr<T*>& handle) : handle_(handle) {}
-
-  std::shared_ptr<T*> handle_;
-  PERFETTO_THREAD_CHECKER(thread_checker)
-};
-
-template <typename T>
-class WeakPtrFactory {
- public:
-  explicit WeakPtrFactory(T* owner)
-      : weak_ptr_(std::shared_ptr<T*>(new T* {owner})) {
-    PERFETTO_DCHECK_THREAD(thread_checker);
-  }
-
-  ~WeakPtrFactory() {
-    PERFETTO_DCHECK_THREAD(thread_checker);
-    *(weak_ptr_.handle_.get()) = nullptr;
-  }
-
-  // Can be safely called on any thread, since it simply copies |weak_ptr_|.
-  // Note that any accesses to the returned pointer need to be made on the
-  // thread that created/reset the factory.
-  WeakPtr<T> GetWeakPtr() const { return weak_ptr_; }
-
-  // Reset the factory to a new owner & thread. May only be called before any
-  // weak pointers were passed out. Future weak pointers will be valid on the
-  // calling thread.
-  void Reset(T* owner) {
-    // Reset thread checker to current thread.
-    PERFETTO_DETACH_FROM_THREAD(thread_checker);
-    PERFETTO_DCHECK_THREAD(thread_checker);
-
-    // We should not have passed out any weak pointers yet at this point.
-    PERFETTO_DCHECK(weak_ptr_.handle_.use_count() == 1);
-
-    weak_ptr_ = WeakPtr<T>(std::shared_ptr<T*>(new T* {owner}));
-  }
-
- private:
-  WeakPtrFactory(const WeakPtrFactory&) = delete;
-  WeakPtrFactory& operator=(const WeakPtrFactory&) = delete;
-
-  WeakPtr<T> weak_ptr_;
-  PERFETTO_THREAD_CHECKER(thread_checker)
-};
-
-}  // namespace base
-}  // namespace perfetto
-
-#endif  // INCLUDE_PERFETTO_EXT_BASE_WEAK_PTR_H_
 /*
  * Copyright (C) 2021 The Android Open Source Project
  *
@@ -5483,7 +6410,8 @@ class PeriodicTask {
 // gen_amalgamated expanded: #include "perfetto/base/time.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/file_utils.h"
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX_BUT_NOT_QNX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) ||           \
     (PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) && __ANDROID_API__ >= 19)
 #include <sys/timerfd.h>
 #endif
@@ -5503,13 +6431,14 @@ uint32_t GetNextDelayMs(const TimeMillis& now_ms,
 }
 
 ScopedPlatformHandle CreateTimerFd(const PeriodicTask::Args& args) {
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX_BUT_NOT_QNX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) ||           \
     (PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) && __ANDROID_API__ >= 19)
   ScopedPlatformHandle tfd(
       timerfd_create(CLOCK_BOOTTIME, TFD_CLOEXEC | TFD_NONBLOCK));
   uint32_t phase_ms = GetNextDelayMs(GetBootTimeMs(), args);
 
-  struct itimerspec its {};
+  struct itimerspec its{};
   // The "1 +" is to make sure that we never pass a zero it_value in the
   // unlikely case of phase_ms being 0. That would cause the timer to be
   // considered disarmed by timerfd_settime.
@@ -5666,7 +6595,8 @@ void PeriodicTask::ResetTimerFd() {
 #include <fcntl.h>  // For O_BINARY (Windows) and F_SETxx (UNIX)
 
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-#include <Windows.h>
+#include <windows.h>
+
 #include <namedpipeapi.h>
 #else
 #include <sys/types.h>
@@ -5716,9 +6646,11 @@ Pipe Pipe::Create(Flags flags) {
 
 }  // namespace base
 }  // namespace perfetto
-// gen_amalgamated begin source: src/base/status.cc
+// gen_amalgamated begin source: src/base/rt_mutex.cc
+// gen_amalgamated begin header: include/perfetto/ext/base/rt_mutex.h
+// gen_amalgamated begin header: include/perfetto/ext/base/flags.h
 /*
- * Copyright (C) 2020 The Android Open Source Project
+ * Copyright (C) 2025 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -5733,29 +6665,36 @@ Pipe Pipe::Create(Flags flags) {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/base/status.h"
-
-#include <stdarg.h>
-
-namespace perfetto {
-namespace base {
+#ifndef INCLUDE_PERFETTO_EXT_BASE_FLAGS_H_
+#define INCLUDE_PERFETTO_EXT_BASE_FLAGS_H_
 
-Status ErrStatus(const char* format, ...) {
-  char buffer[1024];
-  va_list ap;
-  va_start(ap, format);
-  vsnprintf(buffer, sizeof(buffer), format, ap);
-  va_end(ap);
-  Status status(buffer);
-  return status;
-}
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
 
-}  // namespace base
-}  // namespace perfetto
-// gen_amalgamated begin source: src/base/string_splitter.cc
-// gen_amalgamated begin header: include/perfetto/ext/base/string_splitter.h
+#if PERFETTO_BUILDFLAG(PERFETTO_ANDROID_BUILD) && \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+// Android: aconfig generates PERFETTO_FLAGS_* macros in perfetto_flags.h
+#include <perfetto_flags.h>
+#else
+// Non-Android: Define fallback PERFETTO_FLAGS_* macros
+// These match the pattern from Android's aconfig codegen
+#define PERFETTO_FLAGS(FLAG) PERFETTO_FLAGS_##FLAG
+
+#define PERFETTO_FLAGS_TEST_READ_ONLY_FLAG false
+#define PERFETTO_FLAGS_USE_LOCKFREE_TASKRUNNER \
+  PERFETTO_BUILDFLAG(PERFETTO_ENABLE_LOCKFREE_TASKRUNNER)
+#define PERFETTO_FLAGS_USE_RT_MUTEX false
+#define PERFETTO_FLAGS_USE_RT_FUTEX false
+#define PERFETTO_FLAGS_BUFFER_CLONE_PRESERVE_READ_ITER true
+#define PERFETTO_FLAGS_SMA_PREVENT_DUPLICATE_IMMEDIATE_FLUSHES true
+#define PERFETTO_FLAGS_USE_UNIX_SOCKET_INOTIFY \
+  PERFETTO_BUILDFLAG(PERFETTO_ENABLE_SOCK_INOTIFY)
+#define PERFETTO_FLAGS_TRACK_EVENT_INCREMENTAL_STATE_CLEAR_NOT_DESTROY true
+
+#endif  // PERFETTO_BUILDFLAG(PERFETTO_ANDROID_BUILD) && ...
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_FLAGS_H_
 /*
- * Copyright (C) 2018 The Android Open Source Project
+ * Copyright (C) 2025 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -5770,80 +6709,202 @@ Status ErrStatus(const char* format, ...) {
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_EXT_BASE_STRING_SPLITTER_H_
-#define INCLUDE_PERFETTO_EXT_BASE_STRING_SPLITTER_H_
+#ifndef INCLUDE_PERFETTO_EXT_BASE_RT_MUTEX_H_
+#define INCLUDE_PERFETTO_EXT_BASE_RT_MUTEX_H_
+
+// This header introduces the RtMutex class for priority-inheritance mutexes.
+// RtMutex is NOT a blanket replacement for std::mutex and should be used only
+// in cases where we know we are expect to be used on a RT thread.
+// In the contended case RtMutex is generally slower than a std::mutex (or any
+// non-RT implementation).
+// Under the hoods this class does the following:
+// - Android: it uses PI futexes.
+// - Linux/MacOS/iOS: it uses pthread_mutex with PTHREAD_PRIO_INHERIT.
+// - Other platforms: falls back on a standard std::mutex. On Windows 11+
+//   std::mutex has effectively PI semantics due to AutoBoost
+//   https://github.com/MicrosoftDocs/win32/commit/a43cb3b5039c5cfc53642bfcea174003a2f1168f
 
-#include <string>
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+// gen_amalgamated expanded: #include "perfetto/base/thread_annotations.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/flags.h"
+// gen_amalgamated expanded: #include "perfetto/public/compiler.h"
 
-namespace perfetto {
-namespace base {
+#define _PERFETTO_MUTEX_MODE_STD 0
+#define _PERFETTO_MUTEX_MODE_RT_FUTEX 1
+#define _PERFETTO_MUTEX_MODE_RT_MUTEX 2
 
-// C++ version of strtok(). Splits a string without making copies or any heap
-// allocations. Destructs the original string passed in input.
-// Supports the special case of using \0 as a delimiter.
-// The token returned in output are valid as long as the input string is valid.
-class StringSplitter {
- public:
-  // Whether an empty string (two delimiters side-to-side) is a valid token.
-  enum class EmptyTokenMode {
-    DISALLOW_EMPTY_TOKENS,
-    ALLOW_EMPTY_TOKENS,
+// The logic below determines which mutex implementation to use.
+// For Android platform builds, the choice is controlled by aconfig flags.
+// For other builds, it's determined by OS support and GN build arguments.
+//
+// Rationale for platform-specific choices:
+// 1. `RtFutex` is enabled only on Android because it relies on `gettid()` being
+//    a cheap thread-local storage access provided by Bionic. On Linux with
+//    glibc, `gettid()` is a full syscall, making the pthread-based
+//    implementation faster.
+// 2. The pthread-based `RtPosixMutex` is not viable on all Android versions, as
+//    `pthread_mutexattr_setprotocol` was introduced in API level 28. Using
+//    `dlsym` to backport it can lead to deadlocks with the loader lock if
+//    tracing is initialized from a static constructor (see b/443178555).
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) && \
+    PERFETTO_BUILDFLAG(PERFETTO_ANDROID_BUILD)
+#if PERFETTO_FLAGS_USE_RT_FUTEX
+#define _PERFETTO_MUTEX_MODE _PERFETTO_MUTEX_MODE_RT_FUTEX
+#elif PERFETTO_FLAGS_USE_RT_MUTEX
+#define _PERFETTO_MUTEX_MODE _PERFETTO_MUTEX_MODE_RT_MUTEX
+#endif
+#elif PERFETTO_BUILDFLAG(PERFETTO_ENABLE_RT_MUTEX)
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+#define _PERFETTO_MUTEX_MODE _PERFETTO_MUTEX_MODE_RT_FUTEX
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+#define _PERFETTO_MUTEX_MODE _PERFETTO_MUTEX_MODE_RT_MUTEX
+#endif
+#endif
 
-    DEFAULT = DISALLOW_EMPTY_TOKENS,
-  };
+// If no RT implementation was selected, default to std::mutex.
+#ifndef _PERFETTO_MUTEX_MODE
+#define _PERFETTO_MUTEX_MODE _PERFETTO_MUTEX_MODE_STD
+#endif
 
-  // Can take ownership of the string if passed via std::move(), e.g.:
-  // StringSplitter(std::move(str), '\n');
-  StringSplitter(std::string,
-                 char delimiter,
-                 EmptyTokenMode empty_token_mode = EmptyTokenMode::DEFAULT);
+// Public macros for conditional compilation based on the selected mutex type.
+#define PERFETTO_HAS_POSIX_RT_MUTEX() \
+  (_PERFETTO_MUTEX_MODE == _PERFETTO_MUTEX_MODE_RT_MUTEX)
+#define PERFETTO_HAS_RT_FUTEX() \
+  (_PERFETTO_MUTEX_MODE == _PERFETTO_MUTEX_MODE_RT_FUTEX)
 
-  // Splits a C-string. The input string will be forcefully null-terminated (so
-  // str[size - 1] should be == '\0' or the last char will be truncated).
-  StringSplitter(char* str,
-                 size_t size,
-                 char delimiter,
-                 EmptyTokenMode empty_token_mode = EmptyTokenMode::DEFAULT);
+#include <atomic>
+#include <mutex>
+#include <type_traits>
 
-  // Splits the current token from an outer StringSplitter instance. This is to
-  // chain splitters as follows:
-  // for (base::StringSplitter lines(x, '\n'); ss.Next();)
-  //   for (base::StringSplitter words(&lines, ' '); words.Next();)
-  StringSplitter(StringSplitter*,
-                 char delimiter,
-                 EmptyTokenMode empty_token_mode = EmptyTokenMode::DEFAULT);
+#if PERFETTO_HAS_POSIX_RT_MUTEX()
+#include <pthread.h>
+#endif
 
-  // Returns true if a token is found (in which case it will be stored in
-  // cur_token()), false if no more tokens are found.
-  bool Next();
+#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+#include <unistd.h>  // For gettid().
+#endif
 
-  // Returns the current token iff last call to Next() returned true. In this
-  // case it guarantees that the returned string is always null terminated.
-  // In all other cases (before the 1st call to Next() and after Next() returns
-  // false) returns nullptr.
-  char* cur_token() { return cur_; }
+namespace perfetto::base {
 
-  // Returns the length of the current token (excluding the null terminator).
-  size_t cur_token_size() const { return cur_size_; }
+namespace internal {
+
+#if PERFETTO_HAS_RT_FUTEX()
+// A wrapper around PI Futexes. A futex is a wrapper around an atomic integer
+// with an ABI shared with the kernel to handle the slowpath in the cases when
+// the mutex is held, or we find out that there are waiters queued when we
+// unlock. The operating principle is the following:
+// - In the no-contention case, a futex boils down to an atomic
+//   compare-and-exchange, without involving the kernel.
+// - If a lock is contented at acquire time, we have to enter the kernel to
+//   suspend our execution and join a wait chain.
+// - It could still happen that we acquire the mutex via the fastpath (without
+//   involving the kernel) but other waiters might queue up while we hold the
+//   mutex. In that case the kernel will add a bit to the atomic int. That bit
+//   will cause the unlock() compare-and-exchange to fail (because it no longer
+//   matches our tid) which in turn will signal us to do a syscall to notify the
+//   waiters.
+class PERFETTO_LOCKABLE RtFutex {
+ public:
+  RtFutex() { PERFETTO_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static); }
+  ~RtFutex() { PERFETTO_TSAN_MUTEX_DESTROY(this, __tsan_mutex_not_static); }
+
+  // Disable copy or move. Copy doesn't make sense. Move isn't feasible because
+  // the pointer to the atomic integer is the handle used by the kernel to setup
+  // the wait chain. A movable futex would require the atomic integer to be heap
+  // allocated, but that would create an indirection layer that is not needed in
+  // most cases. If you really need a movable RtMutex, wrap it in a unique_ptr.
+  RtFutex(const RtFutex&) = delete;
+  RtFutex& operator=(const RtFutex&) = delete;
+  RtFutex(RtFutex&&) = delete;
+  RtFutex& operator=(RtFutex&&) = delete;
+
+  inline bool TryLockFastpath() noexcept {
+    int expected = 0;
+    return lock_.compare_exchange_strong(expected, ::gettid(),
+                                         std::memory_order_acquire,
+                                         std::memory_order_relaxed);
+  }
+
+  bool try_lock() noexcept PERFETTO_EXCLUSIVE_TRYLOCK_FUNCTION(true) {
+    PERFETTO_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_try_lock);
+    if (PERFETTO_LIKELY(TryLockFastpath()) || TryLockSlowpath()) {
+      PERFETTO_TSAN_MUTEX_POST_LOCK(this, __tsan_mutex_try_lock, 0);
+      return true;
+    }
+    PERFETTO_TSAN_MUTEX_POST_LOCK(
+        this, __tsan_mutex_try_lock | __tsan_mutex_try_lock_failed, 0);
+    return false;
+  }
+
+  void lock() PERFETTO_EXCLUSIVE_LOCK_FUNCTION() {
+    PERFETTO_TSAN_MUTEX_PRE_LOCK(this, 0);
+    if (!PERFETTO_LIKELY(TryLockFastpath())) {
+      LockSlowpath();
+    }
+    PERFETTO_TSAN_MUTEX_POST_LOCK(this, 0, 0);
+  }
+
+  void unlock() noexcept PERFETTO_UNLOCK_FUNCTION() {
+    PERFETTO_TSAN_MUTEX_PRE_UNLOCK(this, 0);
+    int expected = ::gettid();
+    // If the current value is our tid, we can unlock without a syscall since
+    // there are no current waiters.
+    if (!PERFETTO_LIKELY(lock_.compare_exchange_strong(
+            expected, 0, std::memory_order_release,
+            std::memory_order_relaxed))) {
+      // The tid doesn't match because the kernel appended the FUTEX_WAITERS
+      // bit. There are waiters, tell the kernel to notify them and unlock.
+      UnlockSlowpath();
+    }
+    PERFETTO_TSAN_MUTEX_POST_UNLOCK(this, 0);
+  }
 
  private:
-  StringSplitter(const StringSplitter&) = delete;
-  StringSplitter& operator=(const StringSplitter&) = delete;
-  void Initialize(char* str, size_t size);
+  std::atomic<int> lock_{};
 
-  std::string str_;
-  char* cur_;
-  size_t cur_size_;
-  char* next_;
-  char* end_;  // STL-style, points one past the last char.
-  const char delimiter_;
-  const EmptyTokenMode empty_token_mode_;
+  void LockSlowpath();
+  bool TryLockSlowpath();
+  void UnlockSlowpath();
 };
 
-}  // namespace base
-}  // namespace perfetto
+#endif  // PERFETTO_HAS_RT_FUTEX
 
-#endif  // INCLUDE_PERFETTO_EXT_BASE_STRING_SPLITTER_H_
+#if PERFETTO_HAS_POSIX_RT_MUTEX()
+class PERFETTO_LOCKABLE RtPosixMutex {
+ public:
+  RtPosixMutex() noexcept;
+  ~RtPosixMutex() noexcept;
+
+  RtPosixMutex(const RtPosixMutex&) = delete;
+  RtPosixMutex& operator=(const RtPosixMutex&) = delete;
+  RtPosixMutex(RtPosixMutex&&) = delete;
+  RtPosixMutex& operator=(RtPosixMutex&&) = delete;
+
+  bool try_lock() noexcept PERFETTO_EXCLUSIVE_TRYLOCK_FUNCTION(true);
+  void lock() noexcept PERFETTO_EXCLUSIVE_LOCK_FUNCTION();
+  void unlock() noexcept PERFETTO_UNLOCK_FUNCTION();
+
+ private:
+  pthread_mutex_t mutex_;
+};
+
+#endif  // PERFETTO_HAS_POSIX_RT_MUTEX
+}  // namespace internal
+
+// Select the best real-time mutex implementation for the target platform, or
+// fall back to std::mutex if none is available.
+#if PERFETTO_HAS_RT_FUTEX()
+using MaybeRtMutex = internal::RtFutex;
+#elif PERFETTO_HAS_POSIX_RT_MUTEX()
+using MaybeRtMutex = internal::RtPosixMutex;
+#else
+using MaybeRtMutex = std::mutex;
+#endif
+
+}  // namespace perfetto::base
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_RT_MUTEX_H_
 /*
  * Copyright (C) 2018 The Android Open Source Project
  *
@@ -5860,85 +6921,94 @@ class StringSplitter {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/string_splitter.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/rt_mutex.h"
 
-#include <utility>
+#include <errno.h>
 
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
 
-namespace perfetto {
-namespace base {
+#if PERFETTO_HAS_RT_FUTEX()
+#include <linux/futex.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+#endif
 
-StringSplitter::StringSplitter(std::string str,
-                               char delimiter,
-                               EmptyTokenMode empty_token_mode)
-    : str_(std::move(str)),
-      delimiter_(delimiter),
-      empty_token_mode_(empty_token_mode) {
-  // It's legal to access str[str.size()] in C++11 (it always returns \0),
-  // hence the +1 (which becomes just size() after the -1 in Initialize()).
-  Initialize(&str_[0], str_.size() + 1);
+namespace perfetto::base {
+
+namespace internal {
+
+#if PERFETTO_HAS_RT_FUTEX()
+
+void RtFutex::LockSlowpath() {
+  auto res = PERFETTO_EINTR(
+      syscall(SYS_futex, &lock_, FUTEX_LOCK_PI_PRIVATE, 0, nullptr));
+  PERFETTO_CHECK(res == 0);
 }
 
-StringSplitter::StringSplitter(char* str,
-                               size_t size,
-                               char delimiter,
-                               EmptyTokenMode empty_token_mode)
-    : delimiter_(delimiter), empty_token_mode_(empty_token_mode) {
-  Initialize(str, size);
+bool RtFutex::TryLockSlowpath() {
+  auto res = PERFETTO_EINTR(
+      syscall(SYS_futex, &lock_, FUTEX_TRYLOCK_PI_PRIVATE, 0, nullptr));
+  if (res == 0)
+    return true;
+  if (errno == EBUSY || errno == EDEADLK)
+    return false;
+  PERFETTO_FATAL("FUTEX_TRYLOCK_PI_PRIVATE failed");
 }
 
-StringSplitter::StringSplitter(StringSplitter* outer,
-                               char delimiter,
-                               EmptyTokenMode empty_token_mode)
-    : delimiter_(delimiter), empty_token_mode_(empty_token_mode) {
-  Initialize(outer->cur_token(), outer->cur_token_size() + 1);
+void RtFutex::UnlockSlowpath() {
+  auto res = PERFETTO_EINTR(
+      syscall(SYS_futex, &lock_, FUTEX_UNLOCK_PI_PRIVATE, 0, nullptr));
+  PERFETTO_CHECK(res == 0);
 }
 
-void StringSplitter::Initialize(char* str, size_t size) {
-  PERFETTO_DCHECK(!size || str);
-  next_ = str;
-  end_ = str + size;
-  cur_ = nullptr;
-  cur_size_ = 0;
-  if (size)
-    next_[size - 1] = '\0';
+#endif  // PERFETTO_HAS_RT_FUTEX
+
+#if PERFETTO_HAS_POSIX_RT_MUTEX()
+
+RtPosixMutex::RtPosixMutex() noexcept {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) && __ANDROID_API__ < 28
+  // pthread_mutexattr_setprotocol is only available on API 28.
+#error \
+    "Priority-inheritance RtMutex is not available in this version of Android."
+#endif
+  pthread_mutexattr_t at{};
+  PERFETTO_CHECK(pthread_mutexattr_init(&at) == 0);
+  PERFETTO_CHECK(pthread_mutexattr_setprotocol(&at, PTHREAD_PRIO_INHERIT) == 0);
+  PERFETTO_CHECK(pthread_mutex_init(&mutex_, &at) == 0);
 }
 
-bool StringSplitter::Next() {
-  for (; next_ < end_; next_++) {
-    if (*next_ == delimiter_ &&
-        empty_token_mode_ == EmptyTokenMode::DISALLOW_EMPTY_TOKENS) {
-      // If empty tokens are disallowed, find fist non-delimiter character.
-      continue;
-    }
-    cur_ = next_;
-    for (;; next_++) {
-      if (*next_ == delimiter_) {
-        cur_size_ = static_cast<size_t>(next_ - cur_);
-        *(next_++) = '\0';
-        break;
-      }
-      if (*next_ == '\0') {
-        cur_size_ = static_cast<size_t>(next_ - cur_);
-        next_ = end_;
-        break;
-      }
-    }
-    if (*cur_ || empty_token_mode_ == EmptyTokenMode::ALLOW_EMPTY_TOKENS)
-      return true;
-    break;
-  }
-  cur_ = nullptr;
-  cur_size_ = 0;
-  return false;
+RtPosixMutex::~RtPosixMutex() noexcept {
+  pthread_mutex_destroy(&mutex_);
 }
 
-}  // namespace base
-}  // namespace perfetto
-// gen_amalgamated begin source: src/base/string_utils.cc
+bool RtPosixMutex::try_lock() noexcept {
+  int res = pthread_mutex_trylock(&mutex_);
+  if (res == 0)
+    return true;
+  // NOTE: Unlike most Linux APIs, pthread_mutex_trylock "returns" the error
+  // code, it does NOT use errno.
+  if (res == EBUSY)
+    return false;
+  PERFETTO_FATAL("pthread_mutex_trylock() failed");
+}
+
+void RtPosixMutex::lock() noexcept {
+  PERFETTO_CHECK(pthread_mutex_lock(&mutex_) == 0);
+}
+
+void RtPosixMutex::unlock() noexcept {
+  PERFETTO_CHECK(pthread_mutex_unlock(&mutex_) == 0);
+}
+
+#endif  // PERFETTO_HAS_POSIX_RT_MUTEX
+
+}  // namespace internal
+}  // namespace perfetto::base
+// gen_amalgamated begin source: src/base/scoped_mmap.cc
+// gen_amalgamated begin header: include/perfetto/ext/base/scoped_mmap.h
 /*
- * Copyright (C) 2018 The Android Open Source Project
+ * Copyright (C) 2024 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -5953,265 +7023,258 @@ bool StringSplitter::Next() {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
+#ifndef INCLUDE_PERFETTO_EXT_BASE_SCOPED_MMAP_H_
+#define INCLUDE_PERFETTO_EXT_BASE_SCOPED_MMAP_H_
 
-#include <locale.h>
-#include <stdarg.h>
-#include <string.h>
+#include <cstddef>
 
-#include <algorithm>
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
-#include <xlocale.h>
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) ||   \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+#define PERFETTO_HAS_MMAP() 1
+#else
+#define PERFETTO_HAS_MMAP() 0
 #endif
 
-#include <cinttypes>
+namespace perfetto::base {
 
-// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// RAII wrapper that holds ownership of an mmap()d area and of a file. Calls
+// unmap() and close() on destruction.
+class ScopedMmap {
+ public:
+  // Creates a memory mapping for the first `length` bytes of `file`.
+  static ScopedMmap FromHandle(base::ScopedPlatformHandle file, size_t length);
 
-namespace perfetto {
-namespace base {
+  ScopedMmap() {}
+  ~ScopedMmap();
+  ScopedMmap(ScopedMmap&& other) noexcept;
 
-// Locale-independant as possible version of strtod.
-double StrToD(const char* nptr, char** endptr) {
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
-  static auto c_locale = newlocale(LC_ALL, "C", nullptr);
-  return strtod_l(nptr, endptr, c_locale);
-#else
-  return strtod(nptr, endptr);
-#endif
-}
+  ScopedMmap& operator=(ScopedMmap&& other) noexcept;
 
-bool StartsWith(const std::string& str, const std::string& prefix) {
-  return str.compare(0, prefix.length(), prefix) == 0;
-}
+  // Returns a pointer to the mapped memory area. Only valid if `IsValid()` is
+  // true.
+  void* data() const { return ptr_; }
 
-bool StartsWithAny(const std::string& str,
-                   const std::vector<std::string>& prefixes) {
-  return std::any_of(
-      prefixes.begin(), prefixes.end(),
-      [&str](const std::string& prefix) { return StartsWith(str, prefix); });
-}
+  // Returns true if this object contains a successfully mapped area.
+  bool IsValid() const { return ptr_ != nullptr; }
 
-bool EndsWith(const std::string& str, const std::string& suffix) {
-  if (suffix.size() > str.size())
-    return false;
-  return str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
-}
+  // Returns the length of the mapped area.
+  size_t length() const { return length_; }
 
-bool Contains(const std::string& haystack, const std::string& needle) {
-  return haystack.find(needle) != std::string::npos;
-}
+  // Unmaps the area and closes the file. Returns false if this held a mmap()d
+  // area and unmapping failed. In any case, after this method, `IsValid()` will
+  // return false.
+  bool reset() noexcept;
 
-bool Contains(const std::string& haystack, const char needle) {
-  return haystack.find(needle) != std::string::npos;
-}
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+  // Takes ownership of an mmap()d area that starts at `data`, `size` bytes
+  // long. `data` should not be MAP_FAILED.
+  static ScopedMmap InheritMmappedRange(void* data, size_t size);
+#endif
 
-size_t Find(const StringView& needle, const StringView& haystack) {
-  if (needle.empty())
-    return 0;
-  if (needle.size() > haystack.size())
-    return std::string::npos;
-  for (size_t i = 0; i < haystack.size() - (needle.size() - 1); ++i) {
-    if (strncmp(haystack.data() + i, needle.data(), needle.size()) == 0)
-      return i;
-  }
-  return std::string::npos;
-}
+ private:
+  ScopedMmap(const ScopedMmap&) = delete;
+  ScopedMmap& operator=(const ScopedMmap&) = delete;
 
-bool CaseInsensitiveEqual(const std::string& first, const std::string& second) {
-  return first.size() == second.size() &&
-         std::equal(
-             first.begin(), first.end(), second.begin(),
-             [](char a, char b) { return Lowercase(a) == Lowercase(b); });
-}
+  size_t length_ = 0;
+  void* ptr_ = nullptr;
+  ScopedPlatformHandle file_;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  ScopedPlatformHandle map_;
+#endif
+};
 
-std::string Join(const std::vector<std::string>& parts,
-                 const std::string& delim) {
-  std::string acc;
-  for (size_t i = 0; i < parts.size(); ++i) {
-    acc += parts[i];
-    if (i + 1 != parts.size()) {
-      acc += delim;
-    }
-  }
-  return acc;
-}
+// Tries to open `file_path` and maps its first `length` bytes in memory.
+ScopedMmap ReadMmapFilePart(const std::string& file_path, size_t length);
 
-std::vector<std::string> SplitString(const std::string& text,
-                                     const std::string& delimiter) {
-  PERFETTO_CHECK(!delimiter.empty());
+// Tries to open `file_path` and maps the whole file into memory.
+ScopedMmap ReadMmapWholeFile(const std::string& file_path);
 
-  std::vector<std::string> output;
-  size_t start = 0;
-  size_t next;
-  for (;;) {
-    next = std::min(text.find(delimiter, start), text.size());
-    if (next > start)
-      output.emplace_back(&text[start], next - start);
-    start = next + delimiter.size();
-    if (start >= text.size())
-      break;
-  }
-  return output;
-}
+}  // namespace perfetto::base
 
-std::string TrimWhitespace(const std::string& str) {
-  std::string whitespaces = "\t\n ";
+#endif  // INCLUDE_PERFETTO_EXT_BASE_SCOPED_MMAP_H_
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-  size_t front_idx = str.find_first_not_of(whitespaces);
-  std::string front_trimmed =
-      front_idx == std::string::npos ? "" : str.substr(front_idx);
+// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_mmap.h"
 
-  size_t end_idx = front_trimmed.find_last_not_of(whitespaces);
-  return end_idx == std::string::npos ? ""
-                                      : front_trimmed.substr(0, end_idx + 1);
-}
+#include <utility>
 
-std::string StripPrefix(const std::string& str, const std::string& prefix) {
-  return StartsWith(str, prefix) ? str.substr(prefix.size()) : str;
-}
+// gen_amalgamated expanded: #include "perfetto/ext/base/file_utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
 
-std::string StripSuffix(const std::string& str, const std::string& suffix) {
-  return EndsWith(str, suffix) ? str.substr(0, str.size() - suffix.size())
-                               : str;
-}
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+#include <sys/mman.h>
+#include <unistd.h>
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+#include <windows.h>
+#endif
 
-std::string ToUpper(const std::string& str) {
-  // Don't use toupper(), it depends on the locale.
-  std::string res(str);
-  auto end = res.end();
-  for (auto c = res.begin(); c != end; ++c)
-    *c = Uppercase(*c);
-  return res;
-}
+namespace perfetto::base {
+namespace {
 
-std::string ToLower(const std::string& str) {
-  // Don't use tolower(), it depends on the locale.
-  std::string res(str);
-  auto end = res.end();
-  for (auto c = res.begin(); c != end; ++c)
-    *c = Lowercase(*c);
-  return res;
+ScopedPlatformHandle OpenFileForMmap(const std::string& file_path) {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+  return OpenFile(file_path, O_RDONLY);
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  // This does not use base::OpenFile to avoid getting an exclusive lock.
+  return ScopedPlatformHandle(
+      CreateFileA(file_path.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr,
+                  OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr));
+#else
+  // mmap is not supported. Do not even open the file.
+  base::ignore_result(file_path);
+  return ScopedPlatformHandle();
+#endif
 }
 
-std::string ToHex(const char* data, size_t size) {
-  std::string hex(2 * size + 1, 'x');
-  for (size_t i = 0; i < size; ++i) {
-    // snprintf prints 3 characters, the two hex digits and a null byte. As we
-    // write left to right, we keep overwriting the nullbytes, except for the
-    // last call to snprintf.
-    snprintf(&(hex[2 * i]), 3, "%02hhx", data[i]);
-  }
-  // Remove the trailing nullbyte produced by the last snprintf.
-  hex.resize(2 * size);
-  return hex;
-}
+}  // namespace
 
-std::string IntToHexString(uint32_t number) {
-  size_t max_size = 11;  // Max uint32 is 0xFFFFFFFF + 1 for null byte.
-  std::string buf;
-  buf.resize(max_size);
-  size_t final_len = SprintfTrunc(&buf[0], max_size, "0x%02x", number);
-  buf.resize(static_cast<size_t>(final_len));  // Cuts off the final null byte.
-  return buf;
+ScopedMmap::ScopedMmap(ScopedMmap&& other) noexcept {
+  *this = std::move(other);
 }
 
-std::string Uint64ToHexString(uint64_t number) {
-  return "0x" + Uint64ToHexStringNoPrefix(number);
+ScopedMmap& ScopedMmap::operator=(ScopedMmap&& other) noexcept {
+  if (this == &other) {
+    return *this;
+  }
+  reset();
+  std::swap(ptr_, other.ptr_);
+  std::swap(length_, other.length_);
+  std::swap(file_, other.file_);
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  std::swap(map_, other.map_);
+#endif
+  return *this;
 }
 
-std::string Uint64ToHexStringNoPrefix(uint64_t number) {
-  size_t max_size = 17;  // Max uint64 is FFFFFFFFFFFFFFFF + 1 for null byte.
-  std::string buf;
-  buf.resize(max_size);
-  size_t final_len = SprintfTrunc(&buf[0], max_size, "%" PRIx64 "", number);
-  buf.resize(static_cast<size_t>(final_len));  // Cuts off the final null byte.
-  return buf;
+ScopedMmap::~ScopedMmap() {
+  reset();
 }
 
-std::string StripChars(const std::string& str,
-                       const std::string& chars,
-                       char replacement) {
-  std::string res(str);
-  const char* start = res.c_str();
-  const char* remove = chars.c_str();
-  for (const char* c = strpbrk(start, remove); c; c = strpbrk(c + 1, remove))
-    res[static_cast<uintptr_t>(c - start)] = replacement;
-  return res;
+// static
+ScopedMmap ScopedMmap::FromHandle(base::ScopedPlatformHandle file,
+                                  size_t length) {
+  ScopedMmap ret;
+  if (!file) {
+    return ret;
+  }
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+  void* ptr = mmap(nullptr, length, PROT_READ, MAP_PRIVATE, *file, 0);
+  if (ptr != MAP_FAILED) {
+    ret.ptr_ = ptr;
+    ret.length_ = length;
+    ret.file_ = std::move(file);
+  }
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  ScopedPlatformHandle map(
+      CreateFileMapping(*file, nullptr, PAGE_READONLY, 0, 0, nullptr));
+  if (!map) {
+    return ret;
+  }
+  void* ptr = MapViewOfFile(*map, FILE_MAP_READ, 0, 0, length);
+  if (ptr != nullptr) {
+    ret.ptr_ = ptr;
+    ret.length_ = length;
+    ret.file_ = std::move(file);
+    ret.map_ = std::move(map);
+  }
+#else
+  base::ignore_result(length);
+#endif
+  return ret;
 }
 
-std::string ReplaceAll(std::string str,
-                       const std::string& to_replace,
-                       const std::string& replacement) {
-  PERFETTO_CHECK(!to_replace.empty());
-  size_t pos = 0;
-  while ((pos = str.find(to_replace, pos)) != std::string::npos) {
-    str.replace(pos, to_replace.length(), replacement);
-    pos += replacement.length();
+bool ScopedMmap::reset() noexcept {
+  bool ret = true;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+  if (ptr_ != nullptr) {
+    ret = munmap(ptr_, length_) == 0;
   }
-  return str;
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  if (ptr_ != nullptr) {
+    ret = UnmapViewOfFile(ptr_);
+  }
+  map_.reset();
+#endif
+  ptr_ = nullptr;
+  length_ = 0;
+  file_.reset();
+  return ret;
 }
 
-size_t SprintfTrunc(char* dst, size_t dst_size, const char* fmt, ...) {
-  if (PERFETTO_UNLIKELY(dst_size) == 0)
-    return 0;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+// static
+ScopedMmap ScopedMmap::InheritMmappedRange(void* data, size_t size) {
+  ScopedMmap ret;
+  ret.ptr_ = data;
+  ret.length_ = size;
+  return ret;
+}
+#endif
 
-  va_list args;
-  va_start(args, fmt);
-  int src_size = vsnprintf(dst, dst_size, fmt, args);
-  va_end(args);
+ScopedMmap ReadMmapFilePart(const std::string& fname, size_t length) {
+  return ScopedMmap::FromHandle(OpenFileForMmap(fname), length);
+}
 
-  if (PERFETTO_UNLIKELY(src_size) <= 0) {
-    dst[0] = '\0';
-    return 0;
+ScopedMmap ReadMmapWholeFile(const std::string& fname) {
+  ScopedPlatformHandle file = OpenFileForMmap(fname);
+  if (!file) {
+    return ScopedMmap();
   }
-
-  size_t res;
-  if (PERFETTO_LIKELY(src_size < static_cast<int>(dst_size))) {
-    // Most common case.
-    res = static_cast<size_t>(src_size);
-  } else {
-    // Truncation case.
-    res = dst_size - 1;
+  std::optional<uint64_t> file_size = GetFileSize(file.get());
+  if (!file_size.has_value()) {
+    return ScopedMmap();
   }
-
-  PERFETTO_DCHECK(res < dst_size);
-  PERFETTO_DCHECK(dst[res] == '\0');
-  return res;
-}
-
-base::Optional<LineWithOffset> FindLineWithOffset(base::StringView str,
-                                                  uint32_t offset) {
-  static constexpr char kNewLine = '\n';
-  uint32_t line_offset = 0;
-  uint32_t line_count = 1;
-  for (uint32_t i = 0; i < str.size(); ++i) {
-    if (str.at(i) == kNewLine) {
-      line_offset = i + 1;
-      line_count++;
-      continue;
-    }
-    if (i == offset) {
-      size_t end_offset = str.find(kNewLine, i);
-      if (end_offset == std::string::npos) {
-        end_offset = str.size();
-      }
-      base::StringView line = str.substr(line_offset, end_offset - line_offset);
-      return LineWithOffset{line, offset - line_offset, line_count};
-    }
+  size_t size = static_cast<size_t>(*file_size);
+  if (static_cast<uint64_t>(size) != *file_size) {
+    return ScopedMmap();
   }
-  return base::nullopt;
+  return ScopedMmap::FromHandle(std::move(file), size);
 }
 
-}  // namespace base
-}  // namespace perfetto
-// gen_amalgamated begin source: src/base/string_view.cc
+}  // namespace perfetto::base
+// gen_amalgamated begin source: src/base/scoped_sched_boost.cc
+// gen_amalgamated begin header: include/perfetto/ext/base/scoped_sched_boost.h
+// gen_amalgamated begin header: include/perfetto/ext/base/status_or.h
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2022 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -6226,33 +7289,75 @@ base::Optional<LineWithOffset> FindLineWithOffset(base::StringView str,
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/string_view.h"
+#ifndef INCLUDE_PERFETTO_EXT_BASE_STATUS_OR_H_
+#define INCLUDE_PERFETTO_EXT_BASE_STATUS_OR_H_
+
+#include <optional>
+
+// gen_amalgamated expanded: #include "perfetto/base/status.h"
 
 namespace perfetto {
 namespace base {
 
-// Without ignoring this warning we get the message:
-//   error: out-of-line definition of constexpr static data member is redundant
-//   in C++17 and is deprecated
-// when using clang-cl in Windows.
-#if defined(__GNUC__)  // GCC & clang
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated"
-#endif  // __GNUC__
+// Union of a object of type |T| with a |base::Status|. Useful for cases where
+// a |T| indicates a successful result of an operation and |base::Status|
+// represents an error.
+//
+// This class is modelled closely on absl::Status and should essentially 1:1
+// match it's API.
+template <typename T>
+class StatusOr {
+ public:
+  // Matches naming of declarations in similar types e.g. std::optional,
+  // std::variant.
+  using value_type = T;
 
-// static
-constexpr size_t StringView::npos;
+  // Intentionally implicit to allow idomatic usage (e.g. returning value/status
+  // from base::StatusOr returning function).
+  StatusOr(base::Status status) : StatusOr(std::move(status), std::nullopt) {
+    if (status_.ok()) {
+      // Matches what Abseil's approach towards OkStatus being passed to
+      // absl::StatusOr<T>.
+      PERFETTO_FATAL("base::OkStatus passed to StatusOr: this is not allowed");
+    }
+  }
+  StatusOr(T value) : StatusOr(base::OkStatus(), std::move(value)) {}
 
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif
+  bool ok() const { return status_.ok(); }
+  const base::Status& status() const { return status_; }
+
+  T& value() {
+    PERFETTO_DCHECK(status_.ok());
+    return *value_;
+  }
+  const T& value() const { return *value_; }
+
+  T& operator*() { return value(); }
+  const T& operator*() const { return value(); }
+
+  T* operator->() { return &value(); }
+  const T* operator->() const { return &value(); }
+
+ private:
+  StatusOr(base::Status status, std::optional<T> value)
+      : status_(std::move(status)), value_(std::move(value)) {
+    PERFETTO_DCHECK(!status_.ok() || value_.has_value());
+  }
+
+  base::Status status_;
+  std::optional<T> value_;
+};
+
+// Deduction guide to make returning StatusOr less verbose.
+template <typename T>
+StatusOr(T) -> StatusOr<T>;
 
 }  // namespace base
 }  // namespace perfetto
-// gen_amalgamated begin source: src/base/temp_file.cc
-// gen_amalgamated begin header: include/perfetto/ext/base/temp_file.h
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_STATUS_OR_H_
 /*
- * Copyright (C) 2018 The Android Open Source Project
+ * Copyright (C) 2025 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -6267,70 +7372,132 @@ constexpr size_t StringView::npos;
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_EXT_BASE_TEMP_FILE_H_
-#define INCLUDE_PERFETTO_EXT_BASE_TEMP_FILE_H_
-
-#include <string>
+#ifndef INCLUDE_PERFETTO_EXT_BASE_SCOPED_SCHED_BOOST_H_
+#define INCLUDE_PERFETTO_EXT_BASE_SCOPED_SCHED_BOOST_H_
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
-
-namespace perfetto {
-namespace base {
+// gen_amalgamated expanded: #include "perfetto/ext/base/status_or.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/thread_checker.h"
 
-std::string GetSysTempDir();
+namespace perfetto::base {
 
-class TempFile {
- public:
-  static TempFile CreateUnlinked();
-  static TempFile Create();
+// kSchedOther: it's the default policy (e.g., CFS on Linux). Range: 0-20.
+//              prio is interpreted as -(nice), i.e., 1 is slightly higher prio
+//              than default 0, 20 is the highest priority.
+//              Note that this is the opposite semantic of the cmdline nice, and
+//              is done for consistency with kSchedFifo, so higher
+//              number == higher prio.
+// kSchedFifo: real-time priority. Range: 1-99. 1 is the lowest priority, 99 the
+//             highest.
+struct SchedPolicyAndPrio {
+  enum class Policy {
+    kSchedOther,
+    kSchedFifo
+  };  // Order matters for operator<().
 
-  TempFile(TempFile&&) noexcept;
-  TempFile& operator=(TempFile&&);
-  ~TempFile();
+  bool operator<(const SchedPolicyAndPrio& other) const {
+    return std::tie(policy, prio) < std::tie(other.policy, other.prio);
+  }
 
-  const std::string& path() const { return path_; }
-  int fd() const { return *fd_; }
-  int operator*() const { return *fd_; }
+  bool operator==(const SchedPolicyAndPrio& other) const {
+    return policy == other.policy && prio == other.prio;
+  }
 
-  // Unlinks the file from the filesystem but keeps the fd() open.
-  // It is safe to call this multiple times.
-  void Unlink();
+  bool operator!=(const SchedPolicyAndPrio& other) const {
+    return !(*this == other);
+  }
 
-  // Releases the underlying file descriptor. Will unlink the file from the
-  // filesystem if it was created via CreateUnlinked().
-  ScopedFile ReleaseFD();
+  Policy policy = Policy::kSchedOther;
+  uint32_t prio = 0;
+};
 
- private:
-  TempFile();
-  TempFile(const TempFile&) = delete;
-  TempFile& operator=(const TempFile&) = delete;
+// Used to mock Linux scheduling policy and parameters API in tests.
+// In production code calls the Linux API, the class is stateless.
+class SchedOsHooks {
+ public:
+  struct SchedOsConfig {
+    int policy;
+    int rt_prio;
+    int nice;
+  };
 
-  ScopedFile fd_;
-  std::string path_;
+  virtual ~SchedOsHooks() = default;
+  static SchedOsHooks* GetInstance();
+  // virtual for testing
+  virtual Status SetSchedConfig(const SchedOsConfig& arg);
+  // virtual for testing
+  virtual StatusOr<SchedOsConfig> GetCurrentSchedConfig() const;
 };
 
-class TempDir {
+// RAII helper to temporarily boost the scheduler priority of the current
+// thread. The priority is reverted to the original value when the object goes
+// out of scope.
+// It is supported only on Linux/Android, fails on other platforms.
+class ScopedSchedBoost {
  public:
-  static TempDir Create();
+  static StatusOr<ScopedSchedBoost> Boost(SchedPolicyAndPrio);
+  ScopedSchedBoost(ScopedSchedBoost&&) noexcept;
+  ScopedSchedBoost& operator=(ScopedSchedBoost&&) noexcept;
+  ~ScopedSchedBoost();
 
-  TempDir(TempDir&&) noexcept;
-  TempDir& operator=(TempDir&&);
-  ~TempDir();
+  // No copy constructors.
+  ScopedSchedBoost(const ScopedSchedBoost&) = delete;
+  ScopedSchedBoost& operator=(const ScopedSchedBoost&) = delete;
 
-  const std::string& path() const { return path_; }
+  static void ResetForTesting(SchedOsHooks*);
 
  private:
-  TempDir();
-  TempDir(const TempDir&) = delete;
-  TempDir& operator=(const TempDir&) = delete;
+  explicit ScopedSchedBoost(SchedPolicyAndPrio p) : policy_and_prio_(p) {}
 
-  std::string path_;
+  std::optional<SchedPolicyAndPrio> policy_and_prio_;
+  ThreadChecker thread_checker_;
 };
+}  // namespace perfetto::base
 
-}  // namespace base
-}  // namespace perfetto
+#endif  // INCLUDE_PERFETTO_EXT_BASE_SCOPED_SCHED_BOOST_H_
+// gen_amalgamated begin header: include/perfetto/ext/base/status_macros.h
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-#endif  // INCLUDE_PERFETTO_EXT_BASE_TEMP_FILE_H_
+#ifndef INCLUDE_PERFETTO_EXT_BASE_STATUS_MACROS_H_
+#define INCLUDE_PERFETTO_EXT_BASE_STATUS_MACROS_H_
+
+// gen_amalgamated expanded: #include "perfetto/base/status.h"
+
+// Evaluates |expr|, which should return a base::Status. If the status is an
+// error status, returns the status from the current function.
+#define RETURN_IF_ERROR(expr)                                       \
+  do {                                                              \
+    ::perfetto::base::Status status_macro_internal_status = (expr); \
+    if (!status_macro_internal_status.ok())                         \
+      return status_macro_internal_status;                          \
+  } while (0)
+
+#define PERFETTO_INTERNAL_CONCAT_IMPL(x, y) x##y
+#define PERFETTO_INTERNAL_MACRO_CONCAT(x, y) PERFETTO_INTERNAL_CONCAT_IMPL(x, y)
+
+// Evalues |rhs| which should return a base::StatusOr<T> and assigns this
+// to |lhs|. If the status is an error status, returns the status from the
+// current function.
+#define ASSIGN_OR_RETURN(lhs, rhs)                                   \
+  PERFETTO_INTERNAL_MACRO_CONCAT(auto status_or, __LINE__) = rhs;    \
+  RETURN_IF_ERROR(                                                   \
+      PERFETTO_INTERNAL_MACRO_CONCAT(status_or, __LINE__).status()); \
+  lhs = std::move(PERFETTO_INTERNAL_MACRO_CONCAT(status_or, __LINE__).value())
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_STATUS_MACROS_H_
 /*
  * Copyright (C) 2018 The Android Open Source Project
  *
@@ -6347,218 +7514,249 @@ class TempDir {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/temp_file.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_sched_boost.h"
 
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/status_macros.h"
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+#include <sched.h>         // for 'SCHED_' macros and 'sched_' functions
+#include <sys/resource.h>  // for 'setpriority', 'getpriority', 'PRIO_PROCESS'
+#include <sys/types.h>     // for 'pid_t'
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-#include <Windows.h>
-#include <direct.h>
-#include <fileapi.h>
-#include <io.h>
-#else
-#include <unistd.h>
-#endif
+#include <algorithm>
+#include <vector>
 
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/file_utils.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
+#endif  // PERFETTO_OS_LINUX || PERFETTO_OS_ANDROID
+
+namespace perfetto::base {
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
 namespace {
-std::string GetTempName() {
-  char name[] = "perfetto-XXXXXX";
-  PERFETTO_CHECK(_mktemp_s(name, sizeof(name)) == 0);
-  return name;
-}
-}  // namespace
-#endif
+constexpr pid_t kCurrentPid = 0;
 
-namespace perfetto {
-namespace base {
+class ThreadMgr {
+ public:
+  // In this class we manage the boost state for the whole process.
+  // If we want to use it for each single thread, this needs to become
+  // 'GetInstanceForThread()'.
+  static ThreadMgr* GetInstance();
 
-std::string GetSysTempDir() {
-  const char* tmpdir = nullptr;
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-  if ((tmpdir = getenv("TMP")))
-    return tmpdir;
-  if ((tmpdir = getenv("TEMP")))
-    return tmpdir;
-  return "C:\\TEMP";
-#else
-  if ((tmpdir = getenv("TMPDIR")))
-    return base::StripSuffix(tmpdir, "/");
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-  return "/data/local/tmp";
-#else
-  return "/tmp";
-#endif  // !OS_ANDROID
-#endif  // !OS_WIN
-}
+  explicit ThreadMgr(SchedOsHooks*);
 
-// static
-TempFile TempFile::Create() {
-  TempFile temp_file;
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-  temp_file.path_ = GetSysTempDir() + "\\" + GetTempName();
-  // Several tests want to read-back the temp file while still open. On Windows,
-  // that requires FILE_SHARE_READ. FILE_SHARE_READ is NOT settable when using
-  // the POSIX-compat equivalent function _open(). Hence the CreateFileA +
-  // _open_osfhandle dance here.
-  HANDLE h =
-      ::CreateFileA(temp_file.path_.c_str(), GENERIC_READ | GENERIC_WRITE,
-                    FILE_SHARE_DELETE | FILE_SHARE_READ, nullptr, CREATE_ALWAYS,
-                    FILE_ATTRIBUTE_TEMPORARY, nullptr);
-  PERFETTO_CHECK(PlatformHandleChecker::IsValid(h));
-  // According to MSDN, when using _open_osfhandle the caller must not call
-  // CloseHandle(). Ownership is moved to the file descriptor, which then needs
-  // to be closed with just with _close().
-  temp_file.fd_.reset(_open_osfhandle(reinterpret_cast<intptr_t>(h), 0));
-#else
-  temp_file.path_ = GetSysTempDir() + "/perfetto-XXXXXXXX";
-  temp_file.fd_.reset(mkstemp(&temp_file.path_[0]));
-#endif
-  if (PERFETTO_UNLIKELY(!temp_file.fd_)) {
-    PERFETTO_FATAL("Could not create temp file %s", temp_file.path_.c_str());
-  }
-  return temp_file;
-}
+  Status Add(SchedPolicyAndPrio);
+  void Remove(SchedPolicyAndPrio);
+  Status RecalcAndUpdatePrio();
 
-// static
-TempFile TempFile::CreateUnlinked() {
-  TempFile temp_file = TempFile::Create();
-  temp_file.Unlink();
-  return temp_file;
-}
+  ThreadMgr(const ThreadMgr&) = delete;
+  ThreadMgr& operator=(const ThreadMgr&) = delete;
+  ThreadMgr(ThreadMgr&&) = delete;
+  ThreadMgr& operator=(ThreadMgr&&) = delete;
 
-TempFile::TempFile() = default;
+  void ResetForTesting(SchedOsHooks*);
 
-TempFile::~TempFile() {
-  Unlink();
+ private:
+  SchedOsHooks* os_hooks_;
+  SchedOsHooks::SchedOsConfig initial_config_{};
+  std::vector<SchedPolicyAndPrio> prios_;
+};
+
+ThreadMgr* ThreadMgr::GetInstance() {
+  static auto* instance = new ThreadMgr(SchedOsHooks::GetInstance());
+  return instance;
+}
+ThreadMgr::ThreadMgr(SchedOsHooks* os_hooks) : os_hooks_(os_hooks) {
+  auto res = os_hooks_->GetCurrentSchedConfig();
+  if (!res.ok()) {
+    // Should never fail: even without CAP_SYS_NICE we can always get our own
+    // policy and prio. If something goes very wrong, log an error and use
+    // SCHED_OTHER as initial config.
+    PERFETTO_DFATAL_OR_ELOG("Failed to get default sched config: %s",
+                            res.status().c_message());
+    initial_config_ = SchedOsHooks::SchedOsConfig{SCHED_OTHER, 0, 0};
+  } else {
+    initial_config_ = res.value();
+  }
 }
 
-ScopedFile TempFile::ReleaseFD() {
-  Unlink();
-  return std::move(fd_);
+Status ThreadMgr::Add(SchedPolicyAndPrio spp) {
+  prios_.push_back(spp);
+  return RecalcAndUpdatePrio();
 }
 
-void TempFile::Unlink() {
-  if (path_.empty())
-    return;
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-  // If the FD is still open DeleteFile will mark the file as pending deletion
-  // and delete it only when the process exists.
-  PERFETTO_CHECK(DeleteFileA(path_.c_str()));
-#else
-  PERFETTO_CHECK(unlink(path_.c_str()) == 0);
-#endif
-  path_.clear();
+void ThreadMgr::Remove(SchedPolicyAndPrio spp) {
+  auto it = std::find(prios_.begin(), prios_.end(), spp);
+  if (it != prios_.end()) {
+    prios_.erase(it);
+  }
+  // It is possible that we previously added the wrongly configured policy,
+  // that wasn't the max policy. In that case the policy will be validated now,
+  // in 'RecalcAndUpdatePrio'.
+  // This for loop makes us ignore all wrongly configured policies and fallback
+  // to the first correct (or the initial one).
+  for (;;) {
+    if (auto res = RecalcAndUpdatePrio(); !res.ok()) {
+      PERFETTO_ELOG("%s", res.c_message());
+    } else {
+      break;
+    }
+  }
 }
 
-TempFile::TempFile(TempFile&&) noexcept = default;
-TempFile& TempFile::operator=(TempFile&&) = default;
+Status ThreadMgr::RecalcAndUpdatePrio() {
+  if (prios_.empty()) {
+    return os_hooks_->SetSchedConfig(initial_config_);
+  }
+  // TODO(ktimofeev): Check previously set prio to skip unnecessary syscall?
+  auto max_prio = std::max_element(prios_.begin(), prios_.end());
+  SchedOsHooks::SchedOsConfig os_config{};
+  switch (max_prio->policy) {
+    case SchedPolicyAndPrio::Policy::kSchedOther:
+      os_config = SchedOsHooks::SchedOsConfig{
+          SCHED_OTHER, 0, -1 * static_cast<int>(max_prio->prio)};
+      break;
+    case SchedPolicyAndPrio::Policy::kSchedFifo:
+      os_config = SchedOsHooks::SchedOsConfig{
+          SCHED_FIFO, static_cast<int>(max_prio->prio), 0};
+      break;
+  }
+  Status res = os_hooks_->SetSchedConfig(os_config);
+  if (!res.ok()) {
+    prios_.erase(max_prio);
+    return res;
+  }
+  return OkStatus();
+}
 
-// static
-TempDir TempDir::Create() {
-  TempDir temp_dir;
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-  temp_dir.path_ = GetSysTempDir() + "\\" + GetTempName();
-  PERFETTO_CHECK(_mkdir(temp_dir.path_.c_str()) == 0);
-#else
-  temp_dir.path_ = GetSysTempDir() + "/perfetto-XXXXXXXX";
-  PERFETTO_CHECK(mkdtemp(&temp_dir.path_[0]));
-#endif
-  return temp_dir;
+void ThreadMgr::ResetForTesting(SchedOsHooks* os_hooks) {
+  os_hooks_ = os_hooks;
+  initial_config_ = os_hooks_->GetCurrentSchedConfig().value();
+  prios_.clear();
 }
 
-TempDir::TempDir() = default;
-TempDir::TempDir(TempDir&&) noexcept = default;
-TempDir& TempDir::operator=(TempDir&&) = default;
+}  // namespace
 
-TempDir::~TempDir() {
-  if (path_.empty())
-    return;  // For objects that get std::move()d.
-  PERFETTO_CHECK(Rmdir(path_));
+SchedOsHooks* SchedOsHooks::GetInstance() {
+  static auto* instance = new SchedOsHooks();
+  return instance;
 }
 
-}  // namespace base
-}  // namespace perfetto
-// gen_amalgamated begin source: src/base/thread_checker.cc
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+Status SchedOsHooks::SetSchedConfig(const SchedOsConfig& arg) {
+  sched_param param{};
+  param.sched_priority = arg.rt_prio;
+  int ret = sched_setscheduler(kCurrentPid, arg.policy, &param);
+  if (ret == -1) {
+    return ErrStatus("sched_setscheduler(%d, %d) failed (errno: %d, %s)",
+                     arg.policy, arg.rt_prio, errno, strerror(errno));
+  }
+  // For the real-time policies the 'arg.rt_prio' value is >= 1.
+  // The userspace policies (SCHED_OTHER, SCHED_BATCH, SCHED_IDLE) use the nice
+  // value.
+  if (arg.rt_prio == 0) {
+    ret = setpriority(PRIO_PROCESS, kCurrentPid, arg.nice);
+    if (ret == -1) {
+      return ErrStatus("setpriority(%d) failed (errno: %d, %s)", arg.nice,
+                       errno, strerror(errno));
+    }
+  }
+  return OkStatus();
+}
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/thread_checker.h"
+StatusOr<SchedOsHooks::SchedOsConfig> SchedOsHooks::GetCurrentSchedConfig()
+    const {
+  int policy = sched_getscheduler(kCurrentPid);
+  if (policy == -1) {
+    return ErrStatus("sched_getscheduler failed (errno: %d, %s)", errno,
+                     strerror(errno));
+  }
+  sched_param param{};
+  if (sched_getparam(kCurrentPid, &param) == -1) {
+    return ErrStatus("sched_getparam failed (errno: %d, %s)", errno,
+                     strerror(errno));
+  }
+  int nice = 0;
+  // For the real-time policies the 'param.sched_priority' value is >= 1.
+  // The userspace policies (SCHED_OTHER, SCHED_BATCH, SCHED_IDLE) use the nice
+  // value.
+  if (param.sched_priority == 0) {
+    errno = 0;
+    nice = getpriority(PRIO_PROCESS, kCurrentPid);
+    if (nice == -1 && errno != 0) {
+      return ErrStatus("getpriority failed (errno: %d, %s)", errno,
+                       strerror(errno));
+    }
+  }
+  return SchedOsConfig{policy, param.sched_priority, nice};
+}
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-#include <Windows.h>
-#endif
+// static
+StatusOr<ScopedSchedBoost> ScopedSchedBoost::Boost(SchedPolicyAndPrio spp) {
+  auto res = ThreadMgr::GetInstance()->Add(spp);
+  RETURN_IF_ERROR(res);
+  return ScopedSchedBoost(spp);
+}
 
-namespace perfetto {
-namespace base {
+ScopedSchedBoost::ScopedSchedBoost(ScopedSchedBoost&& other) noexcept {
+  this->policy_and_prio_ = other.policy_and_prio_;
+  other.policy_and_prio_ = std::nullopt;
+}
 
-namespace {
-constexpr ThreadID kDetached{};
+ScopedSchedBoost& ScopedSchedBoost::operator=(
+    ScopedSchedBoost&& other) noexcept {
+  if (this != &other) {
+    this->~ScopedSchedBoost();
+    new (this) ScopedSchedBoost(std::move(other));
+  }
+  return *this;
+}
 
-ThreadID CurrentThreadId() {
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-  return ::GetCurrentThreadId();
-#else
-  return pthread_self();
-#endif
+ScopedSchedBoost::~ScopedSchedBoost() {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  if (!policy_and_prio_.has_value())
+    return;
+  ThreadMgr::GetInstance()->Remove(*policy_and_prio_);
+  policy_and_prio_ = std::nullopt;
 }
-}  // namespace
 
-ThreadChecker::ThreadChecker() {
-  thread_id_.store(CurrentThreadId());
+// static
+void ScopedSchedBoost::ResetForTesting(SchedOsHooks* os_manager) {
+  ThreadMgr::GetInstance()->ResetForTesting(os_manager);
 }
 
-ThreadChecker::~ThreadChecker() = default;
+#else
 
-ThreadChecker::ThreadChecker(const ThreadChecker& other) {
-  thread_id_ = other.thread_id_.load();
+// static
+SchedOsHooks* SchedOsHooks::GetInstance() {
+  return nullptr;
 }
 
-ThreadChecker& ThreadChecker::operator=(const ThreadChecker& other) {
-  thread_id_ = other.thread_id_.load();
-  return *this;
+Status SchedOsHooks::SetSchedConfig(const SchedOsHooks::SchedOsConfig&) {
+  return ErrStatus("SchedOsHooks is supported only on Linux/Android");
 }
 
-bool ThreadChecker::CalledOnValidThread() const {
-  auto self = CurrentThreadId();
-
-  // Will re-attach if previously detached using DetachFromThread().
-  auto prev_value = kDetached;
-  if (thread_id_.compare_exchange_strong(prev_value, self))
-    return true;
-  return prev_value == self;
+StatusOr<SchedOsHooks::SchedOsConfig> SchedOsHooks::GetCurrentSchedConfig()
+    const {
+  return ErrStatus("SchedOsHooks is supported only on Linux/Android");
 }
 
-void ThreadChecker::DetachFromThread() {
-  thread_id_.store(kDetached);
+// static
+StatusOr<ScopedSchedBoost> ScopedSchedBoost::Boost(SchedPolicyAndPrio) {
+  return ErrStatus("ScopedSchedBoost is supported only on Linux/Android");
 }
 
-}  // namespace base
-}  // namespace perfetto
-// gen_amalgamated begin source: src/base/thread_utils.cc
+ScopedSchedBoost::ScopedSchedBoost(ScopedSchedBoost&&) noexcept = default;
+ScopedSchedBoost& ScopedSchedBoost::operator=(ScopedSchedBoost&&) noexcept =
+    default;
+ScopedSchedBoost::~ScopedSchedBoost() = default;
+
+#endif  // PERFETTO_OS_LINUX || PERFETTO_OS_ANDROID
+
+}  // namespace perfetto::base
+// gen_amalgamated begin source: src/base/status.cc
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2020 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -6573,36 +7771,98 @@ void ThreadChecker::DetachFromThread() {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/base/thread_utils.h"
+// gen_amalgamated expanded: #include "perfetto/base/status.h"
 
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+#include <algorithm>
+#include <cstdarg>
+#include <cstdio>
+#include <string>
+#include <utility>
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA)
-#include <zircon/process.h>
-#include <zircon/syscalls.h>
-#include <zircon/types.h>
-#endif  // PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA)
+namespace perfetto::base {
 
-namespace perfetto {
-namespace base {
+Status ErrStatus(const char* format, ...) {
+  std::string buf;
+  buf.resize(1024);
+  for (;;) {
+    va_list ap;
+    va_start(ap, format);
+    int N = vsnprintf(buf.data(), buf.size() - 1, format, ap);
+    va_end(ap);
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA)
-static PlatformThreadId ResolveThreadId() {
-  zx_info_handle_basic_t basic;
-  return (zx_object_get_info(zx_thread_self(), ZX_INFO_HANDLE_BASIC, &basic,
-                             sizeof(basic), nullptr, nullptr) == ZX_OK)
-             ? basic.koid
-             : ZX_KOID_INVALID;
+    if (N <= 0) {
+      buf = "[printf format error]";
+      break;
+    }
+
+    auto sN = static_cast<size_t>(N);
+    if (sN > buf.size() - 1) {
+      // Indicates that the string was truncated and sN is the "number of
+      // non-null bytes which would be needed to fit the result". This is the
+      // C99 standard behaviour in the case of truncation. In that case, resize
+      // the buffer to match the returned value (with + 1 for the null
+      // terminator) and try again.
+      buf.resize(sN + 1);
+      continue;
+    }
+    if (sN == buf.size() - 1) {
+      // Indicates that the string was likely truncated and sN is just the
+      // number of bytes written into the string. This is the behaviour of
+      // non-standard compilers (MSVC) etc. In that case, just double the
+      // storage and try again.
+      buf.resize(sN * 2);
+      continue;
+    }
+
+    // Otherwise, indicates the string was written successfully: we need to
+    // resize to match the number of non-null bytes and return.
+    buf.resize(sN);
+    break;
+  }
+  return Status(std::move(buf));
 }
-PlatformThreadId GetThreadId() {
-  thread_local static PlatformThreadId thread_id = ResolveThreadId();
-  return thread_id;
+
+std::optional<std::string_view> Status::GetPayload(
+    std::string_view type_url) const {
+  if (ok()) {
+    return std::nullopt;
+  }
+  for (const auto& kv : payloads_) {
+    if (kv.type_url == type_url) {
+      return kv.payload;
+    }
+  }
+  return std::nullopt;
 }
-#endif  // PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA)
 
-}  // namespace base
-}  // namespace perfetto
-// gen_amalgamated begin source: src/base/time.cc
+void Status::SetPayload(std::string_view type_url, std::string value) {
+  if (ok()) {
+    return;
+  }
+  for (auto& kv : payloads_) {
+    if (kv.type_url == type_url) {
+      kv.payload = value;
+      return;
+    }
+  }
+  payloads_.push_back(Payload{std::string(type_url), std::move(value)});
+}
+
+bool Status::ErasePayload(std::string_view type_url) {
+  if (ok()) {
+    return false;
+  }
+  auto it = std::remove_if(
+      payloads_.begin(), payloads_.end(),
+      [type_url](const Payload& p) { return p.type_url == type_url; });
+  bool erased = it != payloads_.end();
+  payloads_.erase(it, payloads_.end());
+  return erased;
+}
+
+}  // namespace perfetto::base
+// gen_amalgamated begin source: src/base/string_splitter.cc
+// gen_amalgamated begin header: include/perfetto/ext/base/string_splitter.h
 /*
  * Copyright (C) 2018 The Android Open Source Project
  *
@@ -6619,75 +7879,93 @@ PlatformThreadId GetThreadId() {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/base/time.h"
-
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+#ifndef INCLUDE_PERFETTO_EXT_BASE_STRING_SPLITTER_H_
+#define INCLUDE_PERFETTO_EXT_BASE_STRING_SPLITTER_H_
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-#include <Windows.h>
-#else
-#include <unistd.h>
-#endif
+#include <string>
 
 namespace perfetto {
 namespace base {
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+// C++ version of strtok(). Splits a string without making copies or any heap
+// allocations. Destructs the original string passed in input.
+// Supports the special case of using \0 as a delimiter.
+// The token returned in output are valid as long as the input string is valid.
+class StringSplitter {
+ public:
+  // Whether an empty string (two delimiters side-to-side) is a valid token.
+  enum class EmptyTokenMode {
+    DISALLOW_EMPTY_TOKENS,
+    ALLOW_EMPTY_TOKENS,
 
-TimeNanos GetWallTimeNs() {
-  LARGE_INTEGER freq;
-  ::QueryPerformanceFrequency(&freq);
-  LARGE_INTEGER counter;
-  ::QueryPerformanceCounter(&counter);
-  double elapsed_nanoseconds = (1e9 * static_cast<double>(counter.QuadPart)) /
-                               static_cast<double>(freq.QuadPart);
-  return TimeNanos(static_cast<uint64_t>(elapsed_nanoseconds));
-}
+    DEFAULT = DISALLOW_EMPTY_TOKENS,
+  };
 
-TimeNanos GetThreadCPUTimeNs() {
-  FILETIME dummy, kernel_ftime, user_ftime;
-  ::GetThreadTimes(GetCurrentThread(), &dummy, &dummy, &kernel_ftime,
-                   &user_ftime);
-  uint64_t kernel_time =
-      kernel_ftime.dwHighDateTime * 0x100000000 + kernel_ftime.dwLowDateTime;
-  uint64_t user_time =
-      user_ftime.dwHighDateTime * 0x100000000 + user_ftime.dwLowDateTime;
+  // Can take ownership of the string if passed via std::move(), e.g.:
+  // StringSplitter(std::move(str), '\n');
+  StringSplitter(std::string,
+                 char delimiter,
+                 EmptyTokenMode empty_token_mode = EmptyTokenMode::DEFAULT);
 
-  return TimeNanos((kernel_time + user_time) * 100);
-}
+  // Splits a C-string. The input string will be forcefully null-terminated (so
+  // str[size - 1] should be == '\0' or the last char will be truncated).
+  StringSplitter(char* str,
+                 size_t size,
+                 char delimiter,
+                 EmptyTokenMode empty_token_mode = EmptyTokenMode::DEFAULT);
 
-void SleepMicroseconds(unsigned interval_us) {
-  // The Windows Sleep function takes a millisecond count. Round up so that
-  // short sleeps don't turn into a busy wait. Note that the sleep granularity
-  // on Windows can dynamically vary from 1 ms to ~16 ms, so don't count on this
-  // being a short sleep.
-  ::Sleep(static_cast<DWORD>((interval_us + 999) / 1000));
-}
+  // Splits the current token from an outer StringSplitter instance. This is to
+  // chain splitters as follows:
+  // for (base::StringSplitter lines(x, '\n'); ss.Next();)
+  //   for (base::StringSplitter words(&lines, ' '); words.Next();)
+  StringSplitter(StringSplitter*,
+                 char delimiter,
+                 EmptyTokenMode empty_token_mode = EmptyTokenMode::DEFAULT);
 
-#else  // PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  // Returns true if a token is found (in which case it will be stored in
+  // cur_token()), false if no more tokens are found.
+  bool Next();
 
-void SleepMicroseconds(unsigned interval_us) {
-  ::usleep(static_cast<useconds_t>(interval_us));
-}
+  // Returns the next token if found (in which case it will be stored in
+  // cur_token()), nullptr if no more tokens are found.
+  char* NextToken() { return Next() ? cur_token() : nullptr; }
 
-#endif  // PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  // Returns the current token iff last call to Next() returned true. In this
+  // case it guarantees that the returned string is always null terminated.
+  // In all other cases (before the 1st call to Next() and after Next() returns
+  // false) returns nullptr.
+  char* cur_token() { return cur_; }
 
-std::string GetTimeFmt(const std::string& fmt) {
-  time_t raw_time;
-  time(&raw_time);
-  struct tm* local_tm;
-  local_tm = localtime(&raw_time);
-  char buf[128];
-  PERFETTO_CHECK(strftime(buf, 80, fmt.c_str(), local_tm) > 0);
-  return buf;
-}
+  // Returns the length of the current token (excluding the null terminator).
+  size_t cur_token_size() const { return cur_size_; }
+
+  // Return the untokenized remainder of the input string that occurs after the
+  // current token.
+  char* remainder() { return next_; }
+
+  // Returns the size of the untokenized input
+  size_t remainder_size() { return static_cast<size_t>(end_ - next_); }
+
+ private:
+  StringSplitter(const StringSplitter&) = delete;
+  StringSplitter& operator=(const StringSplitter&) = delete;
+  void Initialize(char* str, size_t size);
+
+  std::string str_;
+  char* cur_;
+  size_t cur_size_;
+  char* next_;
+  char* end_;  // STL-style, points one past the last char.
+  const char delimiter_;
+  const EmptyTokenMode empty_token_mode_;
+};
 
 }  // namespace base
 }  // namespace perfetto
-// gen_amalgamated begin source: src/base/utils.cc
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_STRING_SPLITTER_H_
 /*
- * Copyright (C) 2020 The Android Open Source Project
+ * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -6702,325 +7980,85 @@ std::string GetTimeFmt(const std::string& fmt) {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_splitter.h"
 
-#include <string>
+#include <utility>
 
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/file_utils.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/pipe.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
-
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) ||   \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA)
-#include <limits.h>
-#include <stdlib.h>  // For _exit()
-#include <unistd.h>  // For getpagesize() and geteuid() & fork()
-#endif
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
-#include <mach-o/dyld.h>
-#include <mach/vm_page_size.h>
-#endif
+namespace perfetto {
+namespace base {
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-#include <Windows.h>
-#include <io.h>
-#include <malloc.h>  // For _aligned_malloc().
-#endif
-
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-#include <dlfcn.h>
-#include <malloc.h>
-
-#ifdef M_PURGE
-#define PERFETTO_M_PURGE M_PURGE
-#else
-// Only available in in-tree builds and on newer SDKs.
-#define PERFETTO_M_PURGE -101
-#endif  // M_PURGE
-
-namespace {
-extern "C" {
-using MalloptType = void (*)(int, int);
-}
-}  // namespace
-#endif  // OS_ANDROID
-
-namespace {
-
-#if PERFETTO_BUILDFLAG(PERFETTO_X64_CPU_OPT)
-
-// Preserve the %rbx register via %rdi to work around a clang bug
-// https://bugs.llvm.org/show_bug.cgi?id=17907 (%rbx in an output constraint
-// is not considered a clobbered register).
-#define PERFETTO_GETCPUID(a, b, c, d, a_inp, c_inp) \
-  asm("mov %%rbx, %%rdi\n"                          \
-      "cpuid\n"                                     \
-      "xchg %%rdi, %%rbx\n"                         \
-      : "=a"(a), "=D"(b), "=c"(c), "=d"(d)          \
-      : "a"(a_inp), "2"(c_inp))
-
-uint32_t GetXCR0EAX() {
-  uint32_t eax = 0, edx = 0;
-  asm("xgetbv" : "=a"(eax), "=d"(edx) : "c"(0));
-  return eax;
-}
-
-// If we are building with -msse4 check that the CPU actually supports it.
-// This file must be kept in sync with gn/standalone/BUILD.gn.
-void PERFETTO_EXPORT_COMPONENT __attribute__((constructor))
-CheckCpuOptimizations() {
-  uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0;
-  PERFETTO_GETCPUID(eax, ebx, ecx, edx, 1, 0);
-
-  static constexpr uint64_t xcr0_xmm_mask = 0x2;
-  static constexpr uint64_t xcr0_ymm_mask = 0x4;
-  static constexpr uint64_t xcr0_avx_mask = xcr0_xmm_mask | xcr0_ymm_mask;
-
-  const bool have_popcnt = ecx & (1u << 23);
-  const bool have_sse4_2 = ecx & (1u << 20);
-  const bool have_avx =
-      // Does the OS save/restore XMM and YMM state?
-      (ecx & (1u << 27)) &&  // OS support XGETBV.
-      (ecx & (1u << 28)) &&  // AVX supported in hardware
-      ((GetXCR0EAX() & xcr0_avx_mask) == xcr0_avx_mask);
-
-  // Get level 7 features (eax = 7 and ecx= 0), to check for AVX2 support.
-  // (See Intel 64 and IA-32 Architectures Software Developer's Manual
-  //  Volume 2A: Instruction Set Reference, A-M CPUID).
-  PERFETTO_GETCPUID(eax, ebx, ecx, edx, 7, 0);
-  const bool have_avx2 = have_avx && ((ebx >> 5) & 0x1);
-  const bool have_bmi = (ebx >> 3) & 0x1;
-  const bool have_bmi2 = (ebx >> 8) & 0x1;
-
-  if (!have_sse4_2 || !have_popcnt || !have_avx2 || !have_bmi || !have_bmi2) {
-    fprintf(
-        stderr,
-        "This executable requires a x86_64 cpu that supports SSE4.2, BMI2 and "
-        "AVX2.\n"
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
-        "On MacOS, this might be caused by running x86_64 binaries on arm64.\n"
-        "See https://github.com/google/perfetto/issues/294 for more.\n"
-#endif
-        "Rebuild with enable_perfetto_x64_cpu_opt=false.\n");
-    _exit(126);
-  }
-}
-#endif
-
-}  // namespace
-
-namespace perfetto {
-namespace base {
-
-void MaybeReleaseAllocatorMemToOS() {
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-  // mallopt() on Android requires SDK level 26. Many targets and embedders
-  // still depend on a lower SDK level. Given mallopt() is a quite simple API,
-  // use reflection to do this rather than bumping the SDK level for all
-  // embedders. This keeps the behavior of standalone builds aligned with
-  // in-tree builds.
-  static MalloptType mallopt_fn =
-      reinterpret_cast<MalloptType>(dlsym(RTLD_DEFAULT, "mallopt"));
-  if (!mallopt_fn)
-    return;
-  mallopt_fn(PERFETTO_M_PURGE, 0);
-#endif
-}
-
-uint32_t GetSysPageSize() {
-  ignore_result(kPageSize);  // Just to keep the amalgamated build happy.
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-  static std::atomic<uint32_t> page_size{0};
-  // This function might be called in hot paths. Avoid calling getpagesize() all
-  // the times, in many implementations getpagesize() calls sysconf() which is
-  // not cheap.
-  uint32_t cached_value = page_size.load(std::memory_order_relaxed);
-  if (PERFETTO_UNLIKELY(cached_value == 0)) {
-    cached_value = static_cast<uint32_t>(getpagesize());
-    page_size.store(cached_value, std::memory_order_relaxed);
-  }
-  return cached_value;
-#elif PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
-  return static_cast<uint32_t>(vm_page_size);
-#else
-  return 4096;
-#endif
-}
-
-uid_t GetCurrentUserId() {
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
-  return geteuid();
-#else
-  // TODO(primiano): On Windows we could hash the current user SID and derive a
-  // numeric user id [1]. It is not clear whether we need that. Right now that
-  // would not bring any benefit. Returning 0 unil we can prove we need it.
-  // [1]:https://android-review.googlesource.com/c/platform/external/perfetto/+/1513879/25/src/base/utils.cc
-  return 0;
-#endif
-}
-
-void SetEnv(const std::string& key, const std::string& value) {
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-  PERFETTO_CHECK(::_putenv_s(key.c_str(), value.c_str()) == 0);
-#else
-  PERFETTO_CHECK(::setenv(key.c_str(), value.c_str(), /*overwrite=*/true) == 0);
-#endif
-}
-
-void UnsetEnv(const std::string& key) {
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-  PERFETTO_CHECK(::_putenv_s(key.c_str(), "") == 0);
-#else
-  PERFETTO_CHECK(::unsetenv(key.c_str()) == 0);
-#endif
-}
-
-void Daemonize(std::function<int()> parent_cb) {
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
-  Pipe pipe = Pipe::Create(Pipe::kBothBlock);
-  pid_t pid;
-  switch (pid = fork()) {
-    case -1:
-      PERFETTO_FATAL("fork");
-    case 0: {
-      PERFETTO_CHECK(setsid() != -1);
-      base::ignore_result(chdir("/"));
-      base::ScopedFile null = base::OpenFile("/dev/null", O_RDONLY);
-      PERFETTO_CHECK(null);
-      PERFETTO_CHECK(dup2(*null, STDIN_FILENO) != -1);
-      PERFETTO_CHECK(dup2(*null, STDOUT_FILENO) != -1);
-      PERFETTO_CHECK(dup2(*null, STDERR_FILENO) != -1);
-      // Do not accidentally close stdin/stdout/stderr.
-      if (*null <= 2)
-        null.release();
-      WriteAll(*pipe.wr, "1", 1);
-      break;
-    }
-    default: {
-      // Wait for the child process to have reached the setsid() call. This is
-      // to avoid that 'adb shell perfetto -D' destroys the terminal (hence
-      // sending a SIGHUP to the child) before the child has detached from the
-      // terminal (see b/238644870).
-
-      // This is to unblock the read() below (with EOF, which will fail the
-      // CHECK) in the unlikely case of the child crashing before WriteAll("1").
-      pipe.wr.reset();
-      char one = '\0';
-      PERFETTO_CHECK(Read(*pipe.rd, &one, sizeof(one)) == 1 && one == '1');
-      printf("%d\n", pid);
-      int err = parent_cb();
-      exit(err);
-    }
-  }
-#else
-  // Avoid -Wunreachable warnings.
-  if (reinterpret_cast<intptr_t>(&Daemonize) != 16)
-    PERFETTO_FATAL("--background is only supported on Linux/Android/Mac");
-  ignore_result(parent_cb);
-#endif  // OS_WIN
-}
-
-std::string GetCurExecutablePath() {
-  std::string self_path;
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA)
-  char buf[PATH_MAX];
-  ssize_t size = readlink("/proc/self/exe", buf, sizeof(buf));
-  PERFETTO_CHECK(size != -1);
-  // readlink does not null terminate.
-  self_path = std::string(buf, static_cast<size_t>(size));
-#elif PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
-  uint32_t size = 0;
-  PERFETTO_CHECK(_NSGetExecutablePath(nullptr, &size));
-  self_path.resize(size);
-  PERFETTO_CHECK(_NSGetExecutablePath(&self_path[0], &size) == 0);
-#elif PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-  char buf[MAX_PATH];
-  auto len = ::GetModuleFileNameA(nullptr /*current*/, buf, sizeof(buf));
-  self_path = std::string(buf, len);
-#else
-  PERFETTO_FATAL(
-      "GetCurExecutableDir() not implemented on the current platform");
-#endif
-  return self_path;
+StringSplitter::StringSplitter(std::string str,
+                               char delimiter,
+                               EmptyTokenMode empty_token_mode)
+    : str_(std::move(str)),
+      delimiter_(delimiter),
+      empty_token_mode_(empty_token_mode) {
+  // It's legal to access str[str.size()] in C++11 (it always returns \0),
+  // hence the +1 (which becomes just size() after the -1 in Initialize()).
+  Initialize(&str_[0], str_.size() + 1);
 }
 
-std::string GetCurExecutableDir() {
-  auto path = GetCurExecutablePath();
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-  // Paths in Windows can have both kinds of slashes (mingw vs msvc).
-  path = path.substr(0, path.find_last_of('\\'));
-#endif
-  path = path.substr(0, path.find_last_of('/'));
-  return path;
+StringSplitter::StringSplitter(char* str,
+                               size_t size,
+                               char delimiter,
+                               EmptyTokenMode empty_token_mode)
+    : delimiter_(delimiter), empty_token_mode_(empty_token_mode) {
+  Initialize(str, size);
 }
 
-void* AlignedAlloc(size_t alignment, size_t size) {
-  void* res = nullptr;
-  alignment = AlignUp<sizeof(void*)>(alignment);  // At least pointer size.
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-  // Window's _aligned_malloc() has a nearly identically signature to Unix's
-  // aligned_alloc() but its arguments are obviously swapped.
-  res = _aligned_malloc(size, alignment);
-#else
-  // aligned_alloc() has been introduced in Android only in API 28.
-  // Also NaCl and Fuchsia seems to have only posix_memalign().
-  ignore_result(posix_memalign(&res, alignment, size));
-#endif
-  PERFETTO_CHECK(res);
-  return res;
+StringSplitter::StringSplitter(StringSplitter* outer,
+                               char delimiter,
+                               EmptyTokenMode empty_token_mode)
+    : delimiter_(delimiter), empty_token_mode_(empty_token_mode) {
+  Initialize(outer->cur_token(), outer->cur_token_size() + 1);
 }
 
-void AlignedFree(void* ptr) {
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-  _aligned_free(ptr);  // MSDN says it is fine to pass nullptr.
-#else
-  free(ptr);
-#endif
+void StringSplitter::Initialize(char* str, size_t size) {
+  PERFETTO_DCHECK(!size || str);
+  next_ = str;
+  end_ = str + size;
+  cur_ = nullptr;
+  cur_size_ = 0;
+  if (size)
+    next_[size - 1] = '\0';
 }
 
-std::string HexDump(const void* data_void, size_t len, size_t bytes_per_line) {
-  const char* data = reinterpret_cast<const char*>(data_void);
-  std::string res;
-  static const size_t kPadding = bytes_per_line * 3 + 12;
-  std::unique_ptr<char[]> line(new char[bytes_per_line * 4 + 128]);
-  for (size_t i = 0; i < len; i += bytes_per_line) {
-    char* wptr = line.get();
-    wptr += base::SprintfTrunc(wptr, 19, "%08zX: ", i);
-    for (size_t j = i; j < i + bytes_per_line && j < len; j++) {
-      wptr += base::SprintfTrunc(wptr, 4, "%02X ",
-                                 static_cast<unsigned>(data[j]) & 0xFF);
+bool StringSplitter::Next() {
+  for (; next_ < end_; next_++) {
+    if (*next_ == delimiter_ &&
+        empty_token_mode_ == EmptyTokenMode::DISALLOW_EMPTY_TOKENS) {
+      // If empty tokens are disallowed, find fist non-delimiter character.
+      continue;
     }
-    for (size_t j = static_cast<size_t>(wptr - line.get()); j < kPadding; ++j)
-      *(wptr++) = ' ';
-    for (size_t j = i; j < i + bytes_per_line && j < len; j++) {
-      char c = data[j];
-      *(wptr++) = (c >= 32 && c < 127) ? c : '.';
+    cur_ = next_;
+    for (;; next_++) {
+      if (*next_ == delimiter_) {
+        cur_size_ = static_cast<size_t>(next_ - cur_);
+        *(next_++) = '\0';
+        break;
+      }
+      if (*next_ == '\0') {
+        cur_size_ = static_cast<size_t>(next_ - cur_);
+        next_ = end_;
+        break;
+      }
     }
-    *(wptr++) = '\n';
-    *(wptr++) = '\0';
-    res.append(line.get());
+    if (*cur_ || empty_token_mode_ == EmptyTokenMode::ALLOW_EMPTY_TOKENS)
+      return true;
+    break;
   }
-  return res;
+  cur_ = nullptr;
+  cur_size_ = 0;
+  return false;
 }
 
 }  // namespace base
 }  // namespace perfetto
-// gen_amalgamated begin source: src/base/uuid.cc
-// gen_amalgamated begin header: include/perfetto/ext/base/uuid.h
+// gen_amalgamated begin source: src/base/string_utils.cc
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -7035,144 +8073,386 @@ std::string HexDump(const void* data_void, size_t len, size_t bytes_per_line) {
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_EXT_BASE_UUID_H_
-#define INCLUDE_PERFETTO_EXT_BASE_UUID_H_
-
-#include <array>
-#include <string>
-
-// gen_amalgamated expanded: #include "perfetto/ext/base/optional.h"
-
-namespace perfetto {
-namespace base {
-
-class Uuid {
- public:
-  explicit Uuid(const std::string& s);
-  explicit Uuid(int64_t lsb, int64_t msb);
-  Uuid();
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
 
-  std::array<uint8_t, 16>* data() { return &data_; }
-  const std::array<uint8_t, 16>* data() const { return &data_; }
+#include <locale.h>
+#include <stdarg.h>
+#include <string.h>
 
-  bool operator==(const Uuid& other) const { return data_ == other.data_; }
+#include <algorithm>
 
-  bool operator!=(const Uuid& other) const { return !(*this == other); }
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+#include <xlocale.h>
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+#include <windows.h>
+#endif
 
-  explicit operator bool() const { return *this != Uuid(); }
+#include <cinttypes>
 
-  int64_t msb() const {
-    int64_t result;
-    memcpy(&result, data_.data() + 8, 8);
-    return result;
-  }
+// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
 
-  int64_t lsb() const {
-    int64_t result;
-    memcpy(&result, data_.data(), 8);
-    return result;
-  }
+namespace perfetto {
+namespace base {
 
-  void set_lsb_msb(int64_t lsb, int64_t msb) {
-    set_lsb(lsb);
-    set_msb(msb);
-  }
-  void set_msb(int64_t msb) { memcpy(data_.data() + 8, &msb, 8); }
-  void set_lsb(int64_t lsb) { memcpy(data_.data(), &lsb, 8); }
+// Locale-independent as possible version of strtod.
+double StrToD(const char* nptr, char** endptr) {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) ||           \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX_BUT_NOT_QNX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+  static auto c_locale = newlocale(LC_ALL, "C", nullptr);
+  return strtod_l(nptr, endptr, c_locale);
+#else
+  return strtod(nptr, endptr);
+#endif
+}
 
-  std::string ToString() const;
-  std::string ToPrettyString() const;
+bool StartsWith(const std::string& str, const std::string& prefix) {
+  return str.compare(0, prefix.length(), prefix) == 0;
+}
 
- private:
-  std::array<uint8_t, 16> data_{};
-};
+bool StartsWithAny(const std::string& str,
+                   const std::vector<std::string>& prefixes) {
+  return std::any_of(
+      prefixes.begin(), prefixes.end(),
+      [&str](const std::string& prefix) { return StartsWith(str, prefix); });
+}
 
-Uuid Uuidv4();
+bool EndsWith(const std::string& str, const std::string& suffix) {
+  if (suffix.size() > str.size())
+    return false;
+  return str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
+}
 
-}  // namespace base
-}  // namespace perfetto
+bool Contains(const std::string& haystack, const std::string& needle) {
+  return haystack.find(needle) != std::string::npos;
+}
 
-#endif  // INCLUDE_PERFETTO_EXT_BASE_UUID_H_
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+bool Contains(const std::string& haystack, const char needle) {
+  return haystack.find(needle) != std::string::npos;
+}
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/uuid.h"
+bool Contains(const std::vector<std::string>& haystack,
+              const std::string& needle) {
+  return std::find(haystack.begin(), haystack.end(), needle) != haystack.end();
+}
 
-#include <random>
+size_t Find(const StringView& needle, const StringView& haystack) {
+  if (needle.empty())
+    return 0;
+  if (needle.size() > haystack.size())
+    return std::string::npos;
+  for (size_t i = 0; i < haystack.size() - (needle.size() - 1); ++i) {
+    if (strncmp(haystack.data() + i, needle.data(), needle.size()) == 0)
+      return i;
+  }
+  return std::string::npos;
+}
 
-// gen_amalgamated expanded: #include "perfetto/base/time.h"
+bool CaseInsensitiveEqual(const std::string& first, const std::string& second) {
+  return first.size() == second.size() &&
+         std::equal(
+             first.begin(), first.end(), second.begin(),
+             [](char a, char b) { return Lowercase(a) == Lowercase(b); });
+}
 
-namespace perfetto {
-namespace base {
-namespace {
+std::string Join(const std::vector<std::string>& parts,
+                 const std::string& delim) {
+  std::string acc;
+  for (size_t i = 0; i < parts.size(); ++i) {
+    acc += parts[i];
+    if (i + 1 != parts.size()) {
+      acc += delim;
+    }
+  }
+  return acc;
+}
 
-constexpr char kHexmap[] = {'0', '1', '2', '3', '4', '5', '6', '7',
-                            '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
-}  // namespace
+std::vector<std::string> SplitString(const std::string& text,
+                                     const std::string& delimiter) {
+  PERFETTO_CHECK(!delimiter.empty());
 
-// See https://www.ietf.org/rfc/rfc4122.txt
-Uuid Uuidv4() {
-  static std::minstd_rand rng(static_cast<uint32_t>(GetBootTimeNs().count()));
-  Uuid uuid;
-  auto& data = *uuid.data();
+  std::vector<std::string> output;
+  size_t start = 0;
+  size_t next;
+  for (;;) {
+    next = std::min(text.find(delimiter, start), text.size());
+    if (next > start)
+      output.emplace_back(&text[start], next - start);
+    start = next + delimiter.size();
+    if (start >= text.size())
+      break;
+  }
+  return output;
+}
 
-  for (size_t i = 0; i < 16; ++i)
-    data[i] = static_cast<uint8_t>(rng());
+std::string TrimWhitespace(const std::string& str) {
+  std::string whitespaces = "\t\n ";
 
-  // version:
-  data[6] = (data[6] & 0x0f) | 0x40;
-  // clock_seq_hi_and_reserved:
-  data[8] = (data[8] & 0x3f) | 0x80;
+  size_t front_idx = str.find_first_not_of(whitespaces);
+  std::string front_trimmed =
+      front_idx == std::string::npos ? "" : str.substr(front_idx);
 
-  return uuid;
+  size_t end_idx = front_trimmed.find_last_not_of(whitespaces);
+  return end_idx == std::string::npos ? ""
+                                      : front_trimmed.substr(0, end_idx + 1);
 }
 
-Uuid::Uuid() {}
+std::string StripPrefix(const std::string& str, const std::string& prefix) {
+  return StartsWith(str, prefix) ? str.substr(prefix.size()) : str;
+}
 
-Uuid::Uuid(const std::string& s) {
-  PERFETTO_CHECK(s.size() == data_.size());
-  memcpy(data_.data(), s.data(), s.size());
+std::string StripSuffix(const std::string& str, const std::string& suffix) {
+  return EndsWith(str, suffix) ? str.substr(0, str.size() - suffix.size())
+                               : str;
 }
 
-Uuid::Uuid(int64_t lsb, int64_t msb) {
-  set_lsb_msb(lsb, msb);
+std::string ToUpper(const std::string& str) {
+  // Don't use toupper(), it depends on the locale.
+  std::string res(str);
+  auto end = res.end();
+  for (auto c = res.begin(); c != end; ++c)
+    *c = Uppercase(*c);
+  return res;
 }
 
-std::string Uuid::ToString() const {
-  return std::string(reinterpret_cast<const char*>(data_.data()), data_.size());
+std::string ToLower(const std::string& str) {
+  // Don't use tolower(), it depends on the locale.
+  std::string res(str);
+  auto end = res.end();
+  for (auto c = res.begin(); c != end; ++c)
+    *c = Lowercase(*c);
+  return res;
 }
 
-std::string Uuid::ToPrettyString() const {
-  std::string s(data_.size() * 2 + 4, '-');
-  // Format is 123e4567-e89b-12d3-a456-426655443322.
-  size_t j = 0;
-  for (size_t i = 0; i < data_.size(); ++i) {
-    if (i == 4 || i == 6 || i == 8 || i == 10)
-      j++;
-    s[2 * i + j] = kHexmap[(data_[data_.size() - i - 1] & 0xf0) >> 4];
-    s[2 * i + 1 + j] = kHexmap[(data_[data_.size() - i - 1] & 0x0f)];
+std::string ToHex(const char* data, size_t size) {
+  std::string hex(2 * size + 1, 'x');
+  for (size_t i = 0; i < size; ++i) {
+    // snprintf prints 3 characters, the two hex digits and a null byte. As we
+    // write left to right, we keep overwriting the nullbytes, except for the
+    // last call to snprintf.
+    snprintf(&(hex[2 * i]), 3, "%02hhx", data[i]);
   }
-  return s;
+  // Remove the trailing nullbyte produced by the last snprintf.
+  hex.resize(2 * size);
+  return hex;
+}
+
+std::string IntToHexString(uint32_t number) {
+  size_t max_size = 11;  // Max uint32 is 0xFFFFFFFF + 1 for null byte.
+  std::string buf;
+  buf.resize(max_size);
+  size_t final_len = SprintfTrunc(&buf[0], max_size, "0x%02x", number);
+  buf.resize(static_cast<size_t>(final_len));  // Cuts off the final null byte.
+  return buf;
+}
+
+std::string Uint64ToHexString(uint64_t number) {
+  return "0x" + Uint64ToHexStringNoPrefix(number);
+}
+
+std::string Uint64ToHexStringNoPrefix(uint64_t number) {
+  size_t max_size = 17;  // Max uint64 is FFFFFFFFFFFFFFFF + 1 for null byte.
+  std::string buf;
+  buf.resize(max_size);
+  size_t final_len = SprintfTrunc(&buf[0], max_size, "%" PRIx64 "", number);
+  buf.resize(static_cast<size_t>(final_len));  // Cuts off the final null byte.
+  return buf;
+}
+
+std::string StripChars(const std::string& str,
+                       const std::string& chars,
+                       char replacement) {
+  std::string res(str);
+  const char* start = res.c_str();
+  const char* remove = chars.c_str();
+  for (const char* c = strpbrk(start, remove); c; c = strpbrk(c + 1, remove))
+    res[static_cast<uintptr_t>(c - start)] = replacement;
+  return res;
+}
+
+std::string ReplaceAll(std::string str,
+                       const std::string& to_replace,
+                       const std::string& replacement) {
+  PERFETTO_CHECK(!to_replace.empty());
+  size_t pos = 0;
+  while ((pos = str.find(to_replace, pos)) != std::string::npos) {
+    str.replace(pos, to_replace.length(), replacement);
+    pos += replacement.length();
+  }
+  return str;
+}
+
+bool CheckAsciiAndRemoveInvalidUTF8(base::StringView str, std::string& output) {
+  bool is_ascii = std::all_of(str.begin(), str.end(), [](char c) {
+    return (static_cast<unsigned char>(c) & 0b10000000) == 0b00000000;
+  });
+  if (is_ascii) {
+    return true;
+  }
+
+  // https://www.rfc-editor.org/rfc/rfc3629.txt
+  output.clear();
+  output.reserve(str.size());
+  for (size_t i = 0; i < str.size();) {
+    unsigned char c = static_cast<unsigned char>(str.data()[i]);
+    size_t num_bytes = 0;
+    bool valid_sequence = true;
+
+    if ((c & 0b10000000) == 0b00000000) {
+      num_bytes = 1;
+    } else if ((c & 0b11100000) == 0b11000000) {
+      num_bytes = 2;
+    } else if ((c & 0b11110000) == 0b11100000) {
+      num_bytes = 3;
+    } else if ((c & 0b11111000) == 0b11110000) {
+      num_bytes = 4;
+    } else {
+      valid_sequence = false;
+      // Skip this byte
+      num_bytes = 1;
+    }
+
+    if (valid_sequence) {
+      // Check if enough bytes are available in the string
+      if (i + num_bytes > str.size()) {
+        valid_sequence = false;
+        num_bytes = 1;  // Treat as a single invalid byte for advancement
+      } else {
+        // Check for overlong encodings, surrogates, and out-of-range
+        if (num_bytes == 2 && c < 0b11000010) {  // 0xC2
+          valid_sequence = false;                // Overlong
+        } else if (num_bytes == 3) {
+          unsigned char byte2 = static_cast<unsigned char>(str.data()[i + 1]);
+          if ((c == 0b11100000 && byte2 < 0b10100000) ||   // Overlong E0
+              (c == 0b11101101 && byte2 >= 0b10100000)) {  // Surrogate ED
+            valid_sequence = false;
+          }
+        } else if (num_bytes == 4) {
+          unsigned char byte2 = static_cast<unsigned char>(str.data()[i + 1]);
+          if ((c == 0b11110000 && byte2 < 0b10010000) ||  // Overlong F0
+              (c == 0b11110100 && byte2 > 0b10001111)) {  // Out of range F4
+            valid_sequence = false;
+          }
+        }
+
+        if (valid_sequence && num_bytes > 1) {
+          for (size_t j = 1; j < num_bytes; ++j) {
+            unsigned char continuation_byte =
+                static_cast<unsigned char>(str.data()[i + j]);
+            if ((continuation_byte & 0b11000000) != 0b10000000) {
+              valid_sequence = false;
+              break;
+            }
+          }
+        }
+      }
+    }
+
+    if (valid_sequence) {
+      for (size_t j = 0; j < num_bytes; ++j) {
+        output.push_back(str.data()[i + j]);
+      }
+    }
+
+    i += num_bytes;
+  }
+  return false;
+}
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+bool WideToUTF8(const std::wstring& source, std::string& output) {
+  if (source.empty() ||
+      source.size() > static_cast<size_t>(std::numeric_limits<int>::max())) {
+    return false;
+  }
+  int size = ::WideCharToMultiByte(CP_UTF8, 0, &source[0],
+                                   static_cast<int>(source.size()), nullptr, 0,
+                                   nullptr, nullptr);
+  output.assign(static_cast<size_t>(size), '\0');
+  if (::WideCharToMultiByte(CP_UTF8, 0, &source[0],
+                            static_cast<int>(source.size()), &output[0], size,
+                            nullptr, nullptr) != size) {
+    return false;
+  }
+  return true;
+}
+#endif  // PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+bool UTF8ToWide(const std::string& source, std::wstring& output) {
+  if (source.empty() ||
+      source.size() > static_cast<size_t>(std::numeric_limits<int>::max())) {
+    return false;
+  }
+  int size = ::MultiByteToWideChar(CP_UTF8, 0, &source[0],
+                                   static_cast<int>(source.size()), nullptr, 0);
+  output.assign(static_cast<size_t>(size), L'\0');
+  if (::MultiByteToWideChar(CP_UTF8, 0, &source[0],
+                            static_cast<int>(source.size()), &output[0],
+                            size) != size) {
+    return false;
+  }
+  return true;
+}
+#endif  // PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+
+size_t SprintfTrunc(char* dst, size_t dst_size, const char* fmt, ...) {
+  if (PERFETTO_UNLIKELY(dst_size == 0))
+    return 0;
+
+  va_list args;
+  va_start(args, fmt);
+  int src_size = vsnprintf(dst, dst_size, fmt, args);
+  va_end(args);
+
+  if (PERFETTO_UNLIKELY(src_size <= 0)) {
+    dst[0] = '\0';
+    return 0;
+  }
+
+  size_t res;
+  if (PERFETTO_LIKELY(src_size < static_cast<int>(dst_size))) {
+    // Most common case.
+    res = static_cast<size_t>(src_size);
+  } else {
+    // Truncation case.
+    res = dst_size - 1;
+  }
+
+  PERFETTO_DCHECK(res < dst_size);
+  PERFETTO_DCHECK(dst[res] == '\0');
+  return res;
+}
+
+std::optional<LineWithOffset> FindLineWithOffset(base::StringView str,
+                                                 uint32_t offset) {
+  static constexpr char kNewLine = '\n';
+  uint32_t line_offset = 0;
+  uint32_t line_count = 1;
+  for (uint32_t i = 0; i < str.size(); ++i) {
+    if (str.at(i) == kNewLine) {
+      line_offset = i + 1;
+      line_count++;
+      continue;
+    }
+    if (i == offset) {
+      size_t end_offset = str.find(kNewLine, i);
+      if (end_offset == std::string::npos) {
+        end_offset = str.size();
+      }
+      base::StringView line = str.substr(line_offset, end_offset - line_offset);
+      return LineWithOffset{line, offset - line_offset, line_count};
+    }
+  }
+  return std::nullopt;
 }
 
 }  // namespace base
 }  // namespace perfetto
-// gen_amalgamated begin source: src/base/virtual_destructors.cc
+// gen_amalgamated begin source: src/base/string_view.cc
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -7187,24 +8467,33 @@ std::string Uuid::ToPrettyString() const {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
-
-// This translation unit contains the definitions for the destructor of pure
-// virtual interfaces for the current build target. The alternative would be
-// introducing a one-liner .cc file for each pure virtual interface, which is
-// overkill. This is for compliance with -Wweak-vtables.
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_view.h"
 
 namespace perfetto {
 namespace base {
 
-TaskRunner::~TaskRunner() = default;
+// Without ignoring this warning we get the message:
+//   error: out-of-line definition of constexpr static data member is redundant
+//   in C++17 and is deprecated
+// when using clang-cl in Windows.
+#if defined(__GNUC__)  // GCC & clang
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated"
+#endif  // __GNUC__
+
+// static
+constexpr size_t StringView::npos;
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
 
 }  // namespace base
 }  // namespace perfetto
-// gen_amalgamated begin source: src/base/waitable_event.cc
-// gen_amalgamated begin header: include/perfetto/ext/base/waitable_event.h
+// gen_amalgamated begin source: src/base/string_view_splitter.cc
+// gen_amalgamated begin header: include/perfetto/ext/base/string_view_splitter.h
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2024 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -7219,42 +8508,77 @@ TaskRunner::~TaskRunner() = default;
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_EXT_BASE_WAITABLE_EVENT_H_
-#define INCLUDE_PERFETTO_EXT_BASE_WAITABLE_EVENT_H_
+#ifndef INCLUDE_PERFETTO_EXT_BASE_STRING_VIEW_SPLITTER_H_
+#define INCLUDE_PERFETTO_EXT_BASE_STRING_VIEW_SPLITTER_H_
 
-#include <condition_variable>
-#include <mutex>
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_view.h"
 
 namespace perfetto {
 namespace base {
 
-// A waitable event for cross-thread synchronization.
-// All methods on this class can be called from any thread.
-class WaitableEvent {
+// C++ version of strtok(). Splits a StringView without making copies or any
+// heap allocations. Supports the special case of using \0 as a delimiter.
+// The token returned in output are valid as long as the input string is valid.
+class StringViewSplitter {
  public:
-  WaitableEvent();
-  ~WaitableEvent();
-  WaitableEvent(const WaitableEvent&) = delete;
-  WaitableEvent operator=(const WaitableEvent&) = delete;
+  // Whether an empty string (two delimiters side-to-side) is a valid token.
+  enum class EmptyTokenMode {
+    DISALLOW_EMPTY_TOKENS,
+    ALLOW_EMPTY_TOKENS,
+
+    DEFAULT = DISALLOW_EMPTY_TOKENS,
+  };
 
-  // Synchronously block until the event is notified.
-  void Wait();
+  // Can take ownership of the string if passed via std::move(), e.g.:
+  // StringViewSplitter(std::move(str), '\n');
+  StringViewSplitter(base::StringView,
+                     char delimiter,
+                     EmptyTokenMode empty_token_mode = EmptyTokenMode::DEFAULT);
+
+  // Splits the current token from an outer StringViewSplitter instance. This is
+  // to chain splitters as follows: for (base::StringViewSplitter lines(x,
+  // '\n'); ss.Next();)
+  //   for (base::StringViewSplitter words(&lines, ' '); words.Next();)
+  StringViewSplitter(StringViewSplitter*,
+                     char delimiter,
+                     EmptyTokenMode empty_token_mode = EmptyTokenMode::DEFAULT);
 
-  // Signal the event, waking up blocked waiters.
-  void Notify();
+  // Returns true if a token is found (in which case it will be stored in
+  // cur_token()), false if no more tokens are found.
+  bool Next();
+
+  // Returns the next token if, found (in which case it will be stored in
+  // cur_token()), and the empty string if no more tokens are found.
+  base::StringView NextToken() { return Next() ? cur_token() : ""; }
+
+  // Returns the current token iff last call to Next() returned true.
+  // In all other cases (before the 1st call to Next() and after Next() returns
+  // false) returns the empty string.
+  base::StringView cur_token() { return cur_; }
+
+  // Returns the remainder of the current input string that has not yet been
+  // tokenized.
+  base::StringView remainder() { return next_; }
 
  private:
-  std::mutex mutex_;
-  std::condition_variable event_;
-  bool notified_ = false;
+  StringViewSplitter(const StringViewSplitter&) = delete;
+  StringViewSplitter& operator=(const StringViewSplitter&) = delete;
+  void Initialize(base::StringView);
+
+  base::StringView str_;
+  base::StringView cur_;
+  base::StringView next_;
+  bool end_of_input_;
+  const char delimiter_;
+  const EmptyTokenMode empty_token_mode_;
 };
 
 }  // namespace base
 }  // namespace perfetto
 
-#endif  // INCLUDE_PERFETTO_EXT_BASE_WAITABLE_EVENT_H_
+#endif  // INCLUDE_PERFETTO_EXT_BASE_STRING_VIEW_SPLITTER_H_
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2024 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -7269,30 +8593,90 @@ class WaitableEvent {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/waitable_event.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_view_splitter.h"
+
+#include <utility>
+
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
 
 namespace perfetto {
 namespace base {
 
-WaitableEvent::WaitableEvent() = default;
-WaitableEvent::~WaitableEvent() = default;
+StringViewSplitter::StringViewSplitter(base::StringView str,
+                                       char delimiter,
+                                       EmptyTokenMode empty_token_mode)
+    : str_(std::move(str)),
+      delimiter_(delimiter),
+      empty_token_mode_(empty_token_mode) {
+  Initialize(str);
+}
 
-void WaitableEvent::Wait() {
-  std::unique_lock<std::mutex> lock(mutex_);
-  return event_.wait(lock, [this] { return notified_; });
+StringViewSplitter::StringViewSplitter(StringViewSplitter* outer,
+                                       char delimiter,
+                                       EmptyTokenMode empty_token_mode)
+    : delimiter_(delimiter), empty_token_mode_(empty_token_mode) {
+  Initialize(outer->cur_token());
 }
 
-void WaitableEvent::Notify() {
-  std::unique_lock<std::mutex> lock(mutex_);
-  notified_ = true;
-  event_.notify_all();
+void StringViewSplitter::Initialize(base::StringView str) {
+  next_ = str;
+  cur_ = "";
+  end_of_input_ = false;
+}
+
+bool StringViewSplitter::Next() {
+  if (end_of_input_) {
+    cur_ = next_ = "";
+    return false;
+  }
+
+  size_t substr_start = 0;
+  if (empty_token_mode_ == EmptyTokenMode::DISALLOW_EMPTY_TOKENS) {
+    while (substr_start < next_.size() &&
+           next_.at(substr_start) == delimiter_) {
+      substr_start++;
+    }
+  }
+
+  if (substr_start >= next_.size()) {
+    end_of_input_ = true;
+    cur_ = next_ = "";
+    return !cur_.empty() ||
+           empty_token_mode_ == EmptyTokenMode::ALLOW_EMPTY_TOKENS;
+  }
+
+  size_t delimiter_start = next_.find(delimiter_, substr_start);
+  if (delimiter_start == base::StringView::npos) {
+    cur_ = next_.substr(substr_start);
+    next_ = "";
+    end_of_input_ = true;
+    return !cur_.empty() ||
+           empty_token_mode_ == EmptyTokenMode::ALLOW_EMPTY_TOKENS;
+  }
+
+  size_t delimiter_end = delimiter_start + 1;
+
+  if (empty_token_mode_ == EmptyTokenMode::DISALLOW_EMPTY_TOKENS) {
+    while (delimiter_end < next_.size() &&
+           next_.at(delimiter_end) == delimiter_) {
+      delimiter_end++;
+    }
+    if (delimiter_end >= next_.size()) {
+      end_of_input_ = true;
+    }
+  }
+
+  cur_ = next_.substr(substr_start, delimiter_start - substr_start);
+  next_ = next_.substr(delimiter_end);
+
+  return !cur_.empty() ||
+         empty_token_mode_ == EmptyTokenMode::ALLOW_EMPTY_TOKENS;
 }
 
 }  // namespace base
 }  // namespace perfetto
-// gen_amalgamated begin source: src/base/watchdog_posix.cc
-// gen_amalgamated begin header: include/perfetto/ext/base/watchdog.h
-// gen_amalgamated begin header: include/perfetto/ext/base/watchdog_noop.h
+// gen_amalgamated begin source: src/base/temp_file.cc
+// gen_amalgamated begin header: include/perfetto/ext/base/temp_file.h
 /*
  * Copyright (C) 2018 The Android Open Source Project
  *
@@ -7309,41 +8693,70 @@ void WaitableEvent::Notify() {
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_EXT_BASE_WATCHDOG_NOOP_H_
-#define INCLUDE_PERFETTO_EXT_BASE_WATCHDOG_NOOP_H_
+#ifndef INCLUDE_PERFETTO_EXT_BASE_TEMP_FILE_H_
+#define INCLUDE_PERFETTO_EXT_BASE_TEMP_FILE_H_
 
-#include <stdint.h>
+#include <string>
+
+// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
 
 namespace perfetto {
 namespace base {
 
-enum class WatchdogCrashReason;  // Defined in watchdog.h.
+std::string GetSysTempDir();
 
-class Watchdog {
+class TempFile {
  public:
-  class Timer {
-   public:
-    // Define an empty dtor to avoid "unused variable" errors on the call site.
-    Timer() {}
-    Timer(const Timer&) {}
-    ~Timer() {}
-  };
-  static Watchdog* GetInstance() {
-    static Watchdog* watchdog = new Watchdog();
-    return watchdog;
-  }
-  Timer CreateFatalTimer(uint32_t /*ms*/, WatchdogCrashReason) {
-    return Timer();
-  }
-  void Start() {}
-  void SetMemoryLimit(uint64_t /*bytes*/, uint32_t /*window_ms*/) {}
-  void SetCpuLimit(uint32_t /*percentage*/, uint32_t /*window_ms*/) {}
+  static TempFile CreateUnlinked();
+  static TempFile Create();
+
+  TempFile(TempFile&&) noexcept;
+  TempFile& operator=(TempFile&&);
+  ~TempFile();
+
+  const std::string& path() const { return path_; }
+  int fd() const { return *fd_; }
+  int operator*() const { return *fd_; }
+
+  // Unlinks the file from the filesystem but keeps the fd() open.
+  // It is safe to call this multiple times.
+  void Unlink();
+
+  // Releases the underlying file descriptor. Will unlink the file from the
+  // filesystem if it was created via CreateUnlinked().
+  ScopedFile ReleaseFD();
+
+ private:
+  TempFile();
+  TempFile(const TempFile&) = delete;
+  TempFile& operator=(const TempFile&) = delete;
+
+  ScopedFile fd_;
+  std::string path_;
+};
+
+class TempDir {
+ public:
+  static TempDir Create();
+
+  TempDir(TempDir&&) noexcept;
+  TempDir& operator=(TempDir&&);
+  ~TempDir();
+
+  const std::string& path() const { return path_; }
+
+ private:
+  TempDir();
+  TempDir(const TempDir&) = delete;
+  TempDir& operator=(const TempDir&) = delete;
+
+  std::string path_;
 };
 
 }  // namespace base
 }  // namespace perfetto
 
-#endif  // INCLUDE_PERFETTO_EXT_BASE_WATCHDOG_NOOP_H_
+#endif  // INCLUDE_PERFETTO_EXT_BASE_TEMP_FILE_H_
 /*
  * Copyright (C) 2018 The Android Open Source Project
  *
@@ -7360,71 +8773,151 @@ class Watchdog {
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_EXT_BASE_WATCHDOG_H_
-#define INCLUDE_PERFETTO_EXT_BASE_WATCHDOG_H_
-
-#include <functional>
+// gen_amalgamated expanded: #include "perfetto/ext/base/temp_file.h"
 
 // gen_amalgamated expanded: #include "perfetto/base/build_config.h"
 
-// The POSIX watchdog is only supported on Linux and Android in non-embedder
-// builds.
-#if PERFETTO_BUILDFLAG(PERFETTO_WATCHDOG)
-// gen_amalgamated expanded: #include "perfetto/ext/base/watchdog_posix.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+#include <windows.h>
+
+#include <direct.h>
+#include <fileapi.h>
+#include <io.h>
 #else
-// gen_amalgamated expanded: #include "perfetto/ext/base/watchdog_noop.h"
+#include <unistd.h>
 #endif
 
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/file_utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
+
 namespace perfetto {
 namespace base {
 
-// Used only to add more details to crash reporting.
-enum class WatchdogCrashReason {
-  kUnspecified = 0,
-  kCpuGuardrail = 1,
-  kMemGuardrail = 2,
-  kTaskRunnerHung = 3,
-  kTraceDidntStop = 4,
-};
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+namespace {
+std::string GetTempFilePathWin() {
+  std::string tmplt = GetSysTempDir() + "\\perfetto-XXXXXX";
+  StackString<255> name("%s\\perfetto-XXXXXX", GetSysTempDir().c_str());
+  PERFETTO_CHECK(_mktemp_s(name.mutable_data(), name.len() + 1) == 0);
+  return name.ToStdString();
+}
+}  // namespace
+#endif
 
-// Make the limits more relaxed on desktop, where multi-GB traces are likely.
-// Multi-GB traces can take bursts of cpu time to write into disk at the end of
-// the trace.
+std::string GetSysTempDir() {
+  const char* tmpdir = nullptr;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  if ((tmpdir = getenv("TMP")))
+    return tmpdir;
+  if ((tmpdir = getenv("TEMP")))
+    return tmpdir;
+  return "C:\\TEMP";
+#else
+  if ((tmpdir = getenv("TMPDIR")))
+    return base::StripSuffix(tmpdir, "/");
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-constexpr uint32_t kWatchdogDefaultCpuLimit = 75;
-constexpr uint32_t kWatchdogDefaultCpuWindow = 5 * 60 * 1000;  // 5 minutes.
+  return "/data/local/tmp";
 #else
-constexpr uint32_t kWatchdogDefaultCpuLimit = 90;
-constexpr uint32_t kWatchdogDefaultCpuWindow = 10 * 60 * 1000;  // 10 minutes.
+  return "/tmp";
+#endif  // !OS_ANDROID
+#endif  // !OS_WIN
+}
+
+// static
+TempFile TempFile::Create() {
+  TempFile temp_file;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  temp_file.path_ = GetTempFilePathWin();
+  // Several tests want to read-back the temp file while still open. On Windows,
+  // that requires FILE_SHARE_READ. FILE_SHARE_READ is NOT settable when using
+  // the POSIX-compat equivalent function _open(). Hence the CreateFileA +
+  // _open_osfhandle dance here.
+  HANDLE h =
+      ::CreateFileA(temp_file.path_.c_str(), GENERIC_READ | GENERIC_WRITE,
+                    FILE_SHARE_DELETE | FILE_SHARE_READ, nullptr, CREATE_ALWAYS,
+                    FILE_ATTRIBUTE_TEMPORARY, nullptr);
+  PERFETTO_CHECK(PlatformHandleChecker::IsValid(h));
+  // According to MSDN, when using _open_osfhandle the caller must not call
+  // CloseHandle(). Ownership is moved to the file descriptor, which then needs
+  // to be closed with just with _close().
+  temp_file.fd_.reset(_open_osfhandle(reinterpret_cast<intptr_t>(h), 0));
+#else
+  temp_file.path_ = GetSysTempDir() + "/perfetto-XXXXXXXX";
+  temp_file.fd_.reset(mkstemp(&temp_file.path_[0]));
 #endif
+  if (PERFETTO_UNLIKELY(!temp_file.fd_)) {
+    PERFETTO_FATAL("Could not create temp file %s", temp_file.path_.c_str());
+  }
+  return temp_file;
+}
 
-// The default memory margin we give to our processes. This is used as as a
-// constant to put on top of the trace buffers.
-constexpr uint64_t kWatchdogDefaultMemorySlack = 32 * 1024 * 1024;  // 32 MiB.
-constexpr uint32_t kWatchdogDefaultMemoryWindow = 30 * 1000;  // 30 seconds.
+// static
+TempFile TempFile::CreateUnlinked() {
+  TempFile temp_file = TempFile::Create();
+  temp_file.Unlink();
+  return temp_file;
+}
 
-inline void RunTaskWithWatchdogGuard(const std::function<void()>& task) {
-  // Maximum time a single task can take in a TaskRunner before the
-  // program suicides.
-  constexpr int64_t kWatchdogMillis = 30000;  // 30s
+TempFile::TempFile() = default;
 
-  Watchdog::Timer handle = base::Watchdog::GetInstance()->CreateFatalTimer(
-      kWatchdogMillis, WatchdogCrashReason::kTaskRunnerHung);
-  task();
+TempFile::~TempFile() {
+  Unlink();
+}
 
-  // Suppress unused variable warnings in the client library amalgamated build.
-  (void)kWatchdogDefaultCpuLimit;
-  (void)kWatchdogDefaultCpuWindow;
-  (void)kWatchdogDefaultMemorySlack;
-  (void)kWatchdogDefaultMemoryWindow;
+ScopedFile TempFile::ReleaseFD() {
+  Unlink();
+  return std::move(fd_);
+}
+
+void TempFile::Unlink() {
+  if (path_.empty())
+    return;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  // If the FD is still open DeleteFile will mark the file as pending deletion
+  // and delete it only when the process exists.
+  PERFETTO_CHECK(DeleteFileA(path_.c_str()));
+#else
+  PERFETTO_CHECK(unlink(path_.c_str()) == 0);
+#endif
+  path_.clear();
+}
+
+TempFile::TempFile(TempFile&&) noexcept = default;
+TempFile& TempFile::operator=(TempFile&&) = default;
+
+// static
+TempDir TempDir::Create() {
+  TempDir temp_dir;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  temp_dir.path_ = GetTempFilePathWin();
+  PERFETTO_CHECK(_mkdir(temp_dir.path_.c_str()) == 0);
+#else
+  temp_dir.path_ = GetSysTempDir() + "/perfetto-XXXXXXXX";
+  PERFETTO_CHECK(mkdtemp(&temp_dir.path_[0]));
+#endif
+  return temp_dir;
+}
+
+TempDir::TempDir() = default;
+TempDir::TempDir(TempDir&&) noexcept = default;
+TempDir& TempDir::operator=(TempDir&&) = default;
+
+TempDir::~TempDir() {
+  if (path_.empty())
+    return;  // For objects that get std::move()d.
+  PERFETTO_CHECK(Rmdir(path_));
 }
 
 }  // namespace base
 }  // namespace perfetto
-
-#endif  // INCLUDE_PERFETTO_EXT_BASE_WATCHDOG_H_
+// gen_amalgamated begin source: src/base/thread_checker.cc
 /*
- * Copyright (C) 2018 The Android Open Source Project
+ * Copyright (C) 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -7439,431 +8932,248 @@ inline void RunTaskWithWatchdogGuard(const std::function<void()>& task) {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/platform.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/watchdog.h"
-
-#if PERFETTO_BUILDFLAG(PERFETTO_WATCHDOG)
-
-#include <fcntl.h>
-#include <poll.h>
-#include <signal.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <sys/syscall.h>
-#include <sys/timerfd.h>
-#include <unistd.h>
-
-#include <algorithm>
-#include <cinttypes>
-#include <fstream>
-#include <thread>
+// gen_amalgamated expanded: #include "perfetto/ext/base/thread_checker.h"
 
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/base/thread_utils.h"
-// gen_amalgamated expanded: #include "perfetto/base/time.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/crash_keys.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/file_utils.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+#include <windows.h>
+#endif
 
 namespace perfetto {
 namespace base {
 
 namespace {
+constexpr ThreadID kDetached{};
 
-constexpr uint32_t kDefaultPollingInterval = 30 * 1000;
-
-base::CrashKey g_crash_key_reason("wdog_reason");
-
-bool IsMultipleOf(uint32_t number, uint32_t divisor) {
-  return number >= divisor && number % divisor == 0;
-}
-
-double MeanForArray(const uint64_t array[], size_t size) {
-  uint64_t total = 0;
-  for (size_t i = 0; i < size; i++) {
-    total += array[i];
-  }
-  return static_cast<double>(total / size);
+ThreadID CurrentThreadId() {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  return ::GetCurrentThreadId();
+#else
+  return pthread_self();
+#endif
 }
+}  // namespace
 
-}  //  namespace
-
-bool ReadProcStat(int fd, ProcStat* out) {
-  char c[512];
-  size_t c_pos = 0;
-  while (c_pos < sizeof(c) - 1) {
-    ssize_t rd = PERFETTO_EINTR(read(fd, c + c_pos, sizeof(c) - c_pos));
-    if (rd < 0) {
-      PERFETTO_ELOG("Failed to read stat file to enforce resource limits.");
-      return false;
-    }
-    if (rd == 0)
-      break;
-    c_pos += static_cast<size_t>(rd);
-  }
-  PERFETTO_CHECK(c_pos < sizeof(c));
-  c[c_pos] = '\0';
-
-  if (sscanf(c,
-             "%*d %*s %*c %*d %*d %*d %*d %*d %*u %*u %*u %*u %*u %lu "
-             "%lu %*d %*d %*d %*d %*d %*d %*u %*u %ld",
-             &out->utime, &out->stime, &out->rss_pages) != 3) {
-    PERFETTO_ELOG("Invalid stat format: %s", c);
-    return false;
-  }
-  return true;
+ThreadChecker::ThreadChecker() {
+  thread_id_.store(CurrentThreadId());
 }
 
-Watchdog::Watchdog(uint32_t polling_interval_ms)
-    : polling_interval_ms_(polling_interval_ms) {}
-
-Watchdog::~Watchdog() {
-  if (!thread_.joinable()) {
-    PERFETTO_DCHECK(!enabled_);
-    return;
-  }
-  PERFETTO_DCHECK(enabled_);
-  enabled_ = false;
-
-  // Rearm the timer to 1ns from now. This will cause the watchdog thread to
-  // wakeup from the poll() and see |enabled_| == false.
-  // This code path is used only in tests. In production code the watchdog is
-  // a singleton and is never destroyed.
-  struct itimerspec ts {};
-  ts.it_value.tv_sec = 0;
-  ts.it_value.tv_nsec = 1;
-  timerfd_settime(*timer_fd_, /*flags=*/0, &ts, nullptr);
+ThreadChecker::~ThreadChecker() = default;
 
-  thread_.join();
-}
+ThreadChecker::ThreadChecker(const ThreadChecker& other)
+    : thread_id_(other.thread_id_.load()) {}
 
-Watchdog* Watchdog::GetInstance() {
-  static Watchdog* watchdog = new Watchdog(kDefaultPollingInterval);
-  return watchdog;
+ThreadChecker& ThreadChecker::operator=(const ThreadChecker& other) {
+  thread_id_ = other.thread_id_.load();
+  return *this;
 }
 
-// Can be called from any thread.
-Watchdog::Timer Watchdog::CreateFatalTimer(uint32_t ms,
-                                           WatchdogCrashReason crash_reason) {
-  if (!enabled_.load(std::memory_order_relaxed))
-    return Watchdog::Timer(this, 0, crash_reason);
+bool ThreadChecker::CalledOnValidThread() const {
+  auto self = CurrentThreadId();
 
-  return Watchdog::Timer(this, ms, crash_reason);
+  // Will re-attach if previously detached using DetachFromThread().
+  auto prev_value = kDetached;
+  if (thread_id_.compare_exchange_strong(prev_value, self))
+    return true;
+  return prev_value == self;
 }
 
-// Can be called from any thread.
-void Watchdog::AddFatalTimer(TimerData timer) {
-  std::lock_guard<std::mutex> guard(mutex_);
-  timers_.emplace_back(std::move(timer));
-  RearmTimerFd_Locked();
+void ThreadChecker::DetachFromThread() {
+  thread_id_.store(kDetached);
 }
 
-// Can be called from any thread.
-void Watchdog::RemoveFatalTimer(TimerData timer) {
-  std::lock_guard<std::mutex> guard(mutex_);
-  for (auto it = timers_.begin(); it != timers_.end(); it++) {
-    if (*it == timer) {
-      timers_.erase(it);
-      break;  // Remove only one. Doesn't matter which one.
-    }
-  }
-  RearmTimerFd_Locked();
-}
+}  // namespace base
+}  // namespace perfetto
+// gen_amalgamated begin source: src/base/thread_utils.cc
+// gen_amalgamated begin header: include/perfetto/ext/base/thread_utils.h
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-void Watchdog::RearmTimerFd_Locked() {
-  if (!enabled_)
-    return;
-  auto it = std::min_element(timers_.begin(), timers_.end());
+#ifndef INCLUDE_PERFETTO_EXT_BASE_THREAD_UTILS_H_
+#define INCLUDE_PERFETTO_EXT_BASE_THREAD_UTILS_H_
 
-  // We use one timerfd to handle all the oustanding |timers_|. Keep it armed
-  // to the task expiring soonest.
-  struct itimerspec ts {};
-  if (it != timers_.end()) {
-    ts.it_value = ToPosixTimespec(it->deadline);
-  }
-  // If |timers_| is empty (it == end()) |ts.it_value| will remain
-  // zero-initialized and that will disarm the timer in the call below.
-  int res = timerfd_settime(*timer_fd_, TFD_TIMER_ABSTIME, &ts, nullptr);
-  PERFETTO_DCHECK(res == 0);
-}
+#include <string>
 
-void Watchdog::Start() {
-  std::lock_guard<std::mutex> guard(mutex_);
-  if (thread_.joinable()) {
-    PERFETTO_DCHECK(enabled_);
-  } else {
-    PERFETTO_DCHECK(!enabled_);
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-    // Kick the thread to start running but only on Android or Linux.
-    timer_fd_.reset(
-        timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK));
-    if (!timer_fd_) {
-      PERFETTO_PLOG(
-          "timerfd_create failed, the Perfetto watchdog is not available");
-      return;
-    }
-    enabled_ = true;
-    RearmTimerFd_Locked();  // Deal with timers created before Start().
-    thread_ = std::thread(&Watchdog::ThreadMain, this);
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+#include <pthread.h>
+#include <string.h>
+#include <algorithm>
 #endif
-  }
-}
-
-void Watchdog::SetMemoryLimit(uint64_t bytes, uint32_t window_ms) {
-  // Update the fields under the lock.
-  std::lock_guard<std::mutex> guard(mutex_);
 
-  PERFETTO_CHECK(IsMultipleOf(window_ms, polling_interval_ms_) || bytes == 0);
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+#include <sys/prctl.h>
+#endif
 
-  size_t size = bytes == 0 ? 0 : window_ms / polling_interval_ms_ + 1;
-  memory_window_bytes_.Reset(size);
-  memory_limit_bytes_ = bytes;
-}
+// Internal implementation utils that aren't as widely useful/supported as
+// base/thread_utils.h.
 
-void Watchdog::SetCpuLimit(uint32_t percentage, uint32_t window_ms) {
-  std::lock_guard<std::mutex> guard(mutex_);
+namespace perfetto {
+namespace base {
 
-  PERFETTO_CHECK(percentage <= 100);
-  PERFETTO_CHECK(IsMultipleOf(window_ms, polling_interval_ms_) ||
-                 percentage == 0);
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+// Sets the "comm" of the calling thread to the first 15 chars of the given
+// string.
+inline bool MaybeSetThreadName(const std::string& name) {
+  char buf[16] = {};
+  StringCopy(buf, name.c_str(), sizeof(buf));
 
-  size_t size = percentage == 0 ? 0 : window_ms / polling_interval_ms_ + 1;
-  cpu_window_time_ticks_.Reset(size);
-  cpu_limit_percentage_ = percentage;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+  return pthread_setname_np(buf) == 0;
+#else
+  return pthread_setname_np(pthread_self(), buf) == 0;
+#endif
 }
 
-void Watchdog::ThreadMain() {
-  // Register crash keys explicitly to avoid running out of slots at crash time.
-  g_crash_key_reason.Register();
-
-  base::ScopedFile stat_fd(base::OpenFile("/proc/self/stat", O_RDONLY));
-  if (!stat_fd) {
-    PERFETTO_ELOG("Failed to open stat file to enforce resource limits.");
-    return;
-  }
+inline bool GetThreadName(std::string& out_result) {
+  char buf[16] = {};
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+  if (prctl(PR_GET_NAME, buf) != 0)
+    return false;
+#else
+  if (pthread_getname_np(pthread_self(), buf, sizeof(buf)) != 0)
+    return false;
+#endif
+  out_result = std::string(buf);
+  return true;
+}
 
-  PERFETTO_DCHECK(timer_fd_);
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
 
-  constexpr uint8_t kFdCount = 1;
-  struct pollfd fds[kFdCount]{};
-  fds[0].fd = *timer_fd_;
-  fds[0].events = POLLIN;
+PERFETTO_EXPORT_COMPONENT bool MaybeSetThreadName(const std::string& name);
+PERFETTO_EXPORT_COMPONENT bool GetThreadName(std::string& out_result);
 
-  for (;;) {
-    // We use the poll() timeout to drive the periodic ticks for the cpu/memory
-    // checks. The only other case when the poll() unblocks is when we crash
-    // (or have to quit via enabled_ == false, but that happens only in tests).
-    platform::BeforeMaybeBlockingSyscall();
-    auto ret = poll(fds, kFdCount, static_cast<int>(polling_interval_ms_));
-    platform::AfterMaybeBlockingSyscall();
-    if (!enabled_)
-      return;
-    if (ret < 0) {
-      if (errno == ENOMEM || errno == EINTR) {
-        // Should happen extremely rarely.
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-        continue;
-      }
-      PERFETTO_FATAL("watchdog poll() failed");
-    }
+#else
+inline bool MaybeSetThreadName(const std::string&) {
+  return false;
+}
+inline bool GetThreadName(std::string&) {
+  return false;
+}
+#endif
 
-    // If we get here either:
-    // 1. poll() timed out, in which case we should process cpu/mem guardrails.
-    // 2. A timer expired, in which case we shall crash.
+}  // namespace base
+}  // namespace perfetto
 
-    uint64_t expired = 0;  // Must be exactly 8 bytes.
-    auto res = PERFETTO_EINTR(read(*timer_fd_, &expired, sizeof(expired)));
-    PERFETTO_DCHECK((res < 0 && (errno == EAGAIN)) ||
-                    (res == sizeof(expired) && expired > 0));
-    const auto now = GetWallTimeMs();
+#endif  // INCLUDE_PERFETTO_EXT_BASE_THREAD_UTILS_H_
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-    // Check if any of the timers expired.
-    int tid_to_kill = 0;
-    WatchdogCrashReason crash_reason{};
-    std::unique_lock<std::mutex> guard(mutex_);
-    for (const auto& timer : timers_) {
-      if (now >= timer.deadline) {
-        tid_to_kill = timer.thread_id;
-        crash_reason = timer.crash_reason;
-        break;
-      }
-    }
-    guard.unlock();
+// gen_amalgamated expanded: #include "perfetto/base/thread_utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/thread_utils.h"
 
-    if (tid_to_kill)
-      SerializeLogsAndKillThread(tid_to_kill, crash_reason);
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
 
-    // Check CPU and memory guardrails (if enabled).
-    lseek(stat_fd.get(), 0, SEEK_SET);
-    ProcStat stat;
-    if (!ReadProcStat(stat_fd.get(), &stat))
-      continue;
-    uint64_t cpu_time = stat.utime + stat.stime;
-    uint64_t rss_bytes =
-        static_cast<uint64_t>(stat.rss_pages) * base::GetSysPageSize();
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA)
+#include <zircon/process.h>
+#include <zircon/syscalls.h>
+#include <zircon/types.h>
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+#include <windows.h>
+#endif
 
-    bool threshold_exceeded = false;
-    guard.lock();
-    if (CheckMemory_Locked(rss_bytes)) {
-      threshold_exceeded = true;
-      crash_reason = WatchdogCrashReason::kMemGuardrail;
-    } else if (CheckCpu_Locked(cpu_time)) {
-      threshold_exceeded = true;
-      crash_reason = WatchdogCrashReason::kCpuGuardrail;
-    }
-    guard.unlock();
+namespace perfetto {
+namespace base {
 
-    if (threshold_exceeded)
-      SerializeLogsAndKillThread(getpid(), crash_reason);
-  }
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA)
+static PlatformThreadId ResolveThreadId() {
+  zx_info_handle_basic_t basic;
+  return (zx_object_get_info(zx_thread_self(), ZX_INFO_HANDLE_BASIC, &basic,
+                             sizeof(basic), nullptr, nullptr) == ZX_OK)
+             ? basic.koid
+             : ZX_KOID_INVALID;
+}
+PlatformThreadId GetThreadId() {
+  thread_local static PlatformThreadId thread_id = ResolveThreadId();
+  return thread_id;
 }
 
-void Watchdog::SerializeLogsAndKillThread(int tid,
-                                          WatchdogCrashReason crash_reason) {
-  g_crash_key_reason.Set(static_cast<int>(crash_reason));
-
-  // We are about to die. Serialize the logs into the crash buffer so the
-  // debuggerd crash handler picks them up and attaches to the bugreport.
-  // In the case of a PERFETTO_CHECK/PERFETTO_FATAL this is done in logging.h.
-  // But in the watchdog case, we don't hit that codepath and must do ourselves.
-  MaybeSerializeLastLogsForCrashReporting();
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
 
-  // Send a SIGABRT to the thread that armed the timer. This is to see the
-  // callstack of the thread that is stuck in a long task rather than the
-  // watchdog thread.
-  if (syscall(__NR_tgkill, getpid(), tid, SIGABRT) < 0) {
-    // At this point the process must die. If for any reason the tgkill doesn't
-    // work (e.g. the thread has disappeared), force a crash from here.
-    abort();
+// The SetThreadDescription API was brought in version 1607 of Windows 10.
+typedef HRESULT(WINAPI* SetThreadDescription)(HANDLE hThread,
+                                              PCWSTR lpThreadDescription);
+
+// The SetThreadDescription API was brought in version 1607 of Windows 10.
+typedef HRESULT(WINAPI* GetThreadDescription)(HANDLE hThread,
+                                              PWSTR* ppszThreadDescription);
+
+bool MaybeSetThreadName(const std::string& name) {
+  // The SetThreadDescription API works even if no debugger is attached.
+  static auto set_thread_description_func =
+      reinterpret_cast<SetThreadDescription>(
+          reinterpret_cast<void*>(::GetProcAddress(
+              ::GetModuleHandleA("Kernel32.dll"), "SetThreadDescription")));
+  if (!set_thread_description_func) {
+    return false;
   }
-
-  if (disable_kill_failsafe_for_testing_)
-    return;
-
-  // The tgkill() above will take some milliseconds to cause a crash, as it
-  // involves the kernel to queue the SIGABRT on the target thread (often the
-  // main thread, which is != watchdog thread) and do a scheduling round.
-  // If something goes wrong though (the target thread has signals masked or
-  // is stuck in an uninterruptible+wakekill syscall) force quit from this
-  // thread.
-  std::this_thread::sleep_for(std::chrono::seconds(10));
-  abort();
-}
-
-bool Watchdog::CheckMemory_Locked(uint64_t rss_bytes) {
-  if (memory_limit_bytes_ == 0)
+  std::wstring wide_thread_name;
+  if (!UTF8ToWide(name, wide_thread_name)) {
     return false;
-
-  // Add the current stat value to the ring buffer and check that the mean
-  // remains under our threshold.
-  if (memory_window_bytes_.Push(rss_bytes)) {
-    if (memory_window_bytes_.Mean() >
-        static_cast<double>(memory_limit_bytes_)) {
-      PERFETTO_ELOG(
-          "Memory watchdog trigger. Memory window of %f bytes is above the "
-          "%" PRIu64 " bytes limit.",
-          memory_window_bytes_.Mean(), memory_limit_bytes_);
-      return true;
-    }
   }
-  return false;
+  HRESULT result = set_thread_description_func(::GetCurrentThread(),
+                                               wide_thread_name.c_str());
+  return !FAILED(result);
 }
 
-bool Watchdog::CheckCpu_Locked(uint64_t cpu_time) {
-  if (cpu_limit_percentage_ == 0)
+bool GetThreadName(std::string& out_result) {
+  static auto get_thread_description_func =
+      reinterpret_cast<GetThreadDescription>(
+          reinterpret_cast<void*>(::GetProcAddress(
+              ::GetModuleHandleA("Kernel32.dll"), "GetThreadDescription")));
+  if (!get_thread_description_func) {
     return false;
-
-  // Add the cpu time to the ring buffer.
-  if (cpu_window_time_ticks_.Push(cpu_time)) {
-    // Compute the percentage over the whole window and check that it remains
-    // under the threshold.
-    uint64_t difference_ticks = cpu_window_time_ticks_.NewestWhenFull() -
-                                cpu_window_time_ticks_.OldestWhenFull();
-    double window_interval_ticks =
-        (static_cast<double>(WindowTimeForRingBuffer(cpu_window_time_ticks_)) /
-         1000.0) *
-        static_cast<double>(sysconf(_SC_CLK_TCK));
-    double percentage = static_cast<double>(difference_ticks) /
-                        static_cast<double>(window_interval_ticks) * 100;
-    if (percentage > cpu_limit_percentage_) {
-      PERFETTO_ELOG("CPU watchdog trigger. %f%% CPU use is above the %" PRIu32
-                    "%% CPU limit.",
-                    percentage, cpu_limit_percentage_);
-      return true;
-    }
+  }
+  wchar_t* wide_thread_name;
+  HRESULT result =
+      get_thread_description_func(::GetCurrentThread(), &wide_thread_name);
+  if (SUCCEEDED(result)) {
+    bool success = WideToUTF8(std::wstring(wide_thread_name), out_result);
+    LocalFree(wide_thread_name);
+    return success;
   }
   return false;
 }
 
-uint32_t Watchdog::WindowTimeForRingBuffer(const WindowedInterval& window) {
-  return static_cast<uint32_t>(window.size() - 1) * polling_interval_ms_;
-}
-
-bool Watchdog::WindowedInterval::Push(uint64_t sample) {
-  // Add the sample to the current position in the ring buffer.
-  buffer_[position_] = sample;
-
-  // Update the position with next one circularily.
-  position_ = (position_ + 1) % size_;
-
-  // Set the filled flag the first time we wrap.
-  filled_ = filled_ || position_ == 0;
-  return filled_;
-}
-
-double Watchdog::WindowedInterval::Mean() const {
-  return MeanForArray(buffer_.get(), size_);
-}
-
-void Watchdog::WindowedInterval::Clear() {
-  position_ = 0;
-  buffer_.reset(new uint64_t[size_]());
-}
-
-void Watchdog::WindowedInterval::Reset(size_t new_size) {
-  position_ = 0;
-  size_ = new_size;
-  buffer_.reset(new_size == 0 ? nullptr : new uint64_t[new_size]());
-}
-
-Watchdog::Timer::Timer(Watchdog* watchdog,
-                       uint32_t ms,
-                       WatchdogCrashReason crash_reason)
-    : watchdog_(watchdog) {
-  if (!ms)
-    return;  // No-op timer created when the watchdog is disabled.
-  timer_data_.deadline = GetWallTimeMs() + std::chrono::milliseconds(ms);
-  timer_data_.thread_id = GetThreadId();
-  timer_data_.crash_reason = crash_reason;
-  PERFETTO_DCHECK(watchdog_);
-  watchdog_->AddFatalTimer(timer_data_);
-}
-
-Watchdog::Timer::~Timer() {
-  if (timer_data_.deadline.count())
-    watchdog_->RemoveFatalTimer(timer_data_);
-}
-
-Watchdog::Timer::Timer(Timer&& other) noexcept {
-  watchdog_ = std::move(other.watchdog_);
-  other.watchdog_ = nullptr;
-  timer_data_ = std::move(other.timer_data_);
-  other.timer_data_ = TimerData();
-}
+#endif  // PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA)
 
 }  // namespace base
 }  // namespace perfetto
-
-#endif  // PERFETTO_BUILDFLAG(PERFETTO_WATCHDOG)
-// gen_amalgamated begin source: src/base/thread_task_runner.cc
-// gen_amalgamated begin header: include/perfetto/ext/base/thread_task_runner.h
-// gen_amalgamated begin header: include/perfetto/ext/base/unix_task_runner.h
+// gen_amalgamated begin source: src/base/time.cc
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -7878,125 +9188,209 @@ Watchdog::Timer::Timer(Timer&& other) noexcept {
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_EXT_BASE_UNIX_TASK_RUNNER_H_
-#define INCLUDE_PERFETTO_EXT_BASE_UNIX_TASK_RUNNER_H_
+#include <atomic>
 
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
-// gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
-// gen_amalgamated expanded: #include "perfetto/base/thread_utils.h"
 // gen_amalgamated expanded: #include "perfetto/base/time.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/event_fd.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/thread_checker.h"
 
-#include <chrono>
-#include <deque>
-#include <map>
-#include <mutex>
-#include <vector>
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
 
-#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-#include <poll.h>
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+#include <windows.h>
+#else
+#include <unistd.h>
 #endif
 
 namespace perfetto {
 namespace base {
 
-// Runs a task runner on the current thread.
-//
-// Implementation note: we currently assume (and enforce in debug builds) that
-// Run() is called from the thread that constructed the UnixTaskRunner. This is
-// not strictly necessary, and we could instead track the thread that invokes
-// Run(). However, a related property that *might* be important to enforce is
-// that the destructor runs on the task-running thread. Otherwise, if there are
-// still-pending tasks at the time of destruction, we would destroy those
-// outside of the task thread (which might be unexpected to the caller). On the
-// other hand, the std::function task interface discourages use of any
-// resource-owning tasks (as the callable needs to be copyable), so this might
-// not be important in practice.
-//
-// TODO(rsavitski): consider adding a thread-check in the destructor, after
-// auditing existing usages.
-// TODO(primiano): rename this to TaskRunnerImpl. The "Unix" part is misleading
-// now as it supports also Windows.
-class UnixTaskRunner : public TaskRunner {
- public:
-  UnixTaskRunner();
-  ~UnixTaskRunner() override;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+#if !PERFETTO_BUILDFLAG(PERFETTO_ARCH_CPU_ARM64)
+namespace {
 
-  // Start executing tasks. Doesn't return until Quit() is called. Run() may be
-  // called multiple times on the same task runner.
-  void Run();
-  void Quit();
+// Returns the current value of the performance counter.
+int64_t QPCNowRaw() {
+  LARGE_INTEGER perf_counter_now = {};
+  // According to the MSDN documentation for QueryPerformanceCounter(), this
+  // will never fail on systems that run XP or later.
+  // https://msdn.microsoft.com/library/windows/desktop/ms644904.aspx
+  ::QueryPerformanceCounter(&perf_counter_now);
+  return perf_counter_now.QuadPart;
+}
+
+double TSCTicksPerSecond() {
+  // The value returned by QueryPerformanceFrequency() cannot be used as the TSC
+  // frequency, because there is no guarantee that the TSC frequency is equal to
+  // the performance counter frequency.
+  // The TSC frequency is cached in a static variable because it takes some time
+  // to compute it.
+  static std::atomic<double> tsc_ticks_per_second = 0;
+  double value = tsc_ticks_per_second.load(std::memory_order_relaxed);
+  if (value != 0)
+    return value;
+
+  // Increase the thread priority to reduces the chances of having a context
+  // switch during a reading of the TSC and the performance counter.
+  const int previous_priority = ::GetThreadPriority(::GetCurrentThread());
+  ::SetThreadPriority(::GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
+
+  // The first time that this function is called, make an initial reading of the
+  // TSC and the performance counter. Initialization of static variable is
+  // thread-safe. Threads can race initializing tsc_initial vs
+  // perf_counter_initial, although they should be storing very similar values.
+
+  static const uint64_t tsc_initial = __rdtsc();
+  static const int64_t perf_counter_initial = QPCNowRaw();
+
+  // Make a another reading of the TSC and the performance counter every time
+  // that this function is called.
+  const uint64_t tsc_now = __rdtsc();
+  const int64_t perf_counter_now = QPCNowRaw();
+
+  // Reset the thread priority.
+  ::SetThreadPriority(::GetCurrentThread(), previous_priority);
+
+  // Make sure that at least 50 ms elapsed between the 2 readings. The first
+  // time that this function is called, we don't expect this to be the case.
+  // Note: The longer the elapsed time between the 2 readings is, the more
+  //   accurate the computed TSC frequency will be. The 50 ms value was
+  //   chosen because local benchmarks show that it allows us to get a
+  //   stddev of less than 1 tick/us between multiple runs.
+  // Note: According to the MSDN documentation for QueryPerformanceFrequency(),
+  //   this will never fail on systems that run XP or later.
+  //   https://msdn.microsoft.com/library/windows/desktop/ms644905.aspx
+  LARGE_INTEGER perf_counter_frequency = {};
+  ::QueryPerformanceFrequency(&perf_counter_frequency);
+  PERFETTO_CHECK(perf_counter_now >= perf_counter_initial);
+  const int64_t perf_counter_ticks = perf_counter_now - perf_counter_initial;
+  const double elapsed_time_seconds =
+      static_cast<double>(perf_counter_ticks) /
+      static_cast<double>(perf_counter_frequency.QuadPart);
+
+  constexpr double kMinimumEvaluationPeriodSeconds = 0.05;
+  if (elapsed_time_seconds < kMinimumEvaluationPeriodSeconds)
+    return 0;
 
-  // Checks whether there are any pending immediate tasks to run. Note that
-  // delayed tasks don't count even if they are due to run.
-  bool IsIdleForTesting();
+  // Compute the frequency of the TSC.
+  PERFETTO_CHECK(tsc_now >= tsc_initial);
+  const uint64_t tsc_ticks = tsc_now - tsc_initial;
+  // Racing with another thread to write |tsc_ticks_per_second| is benign
+  // because both threads will write a valid result.
+  tsc_ticks_per_second.store(
+      static_cast<double>(tsc_ticks) / elapsed_time_seconds,
+      std::memory_order_relaxed);
 
-  // TaskRunner implementation:
-  void PostTask(std::function<void()>) override;
-  void PostDelayedTask(std::function<void()>, uint32_t delay_ms) override;
-  void AddFileDescriptorWatch(PlatformHandle, std::function<void()>) override;
-  void RemoveFileDescriptorWatch(PlatformHandle) override;
-  bool RunsTasksOnCurrentThread() const override;
+  return tsc_ticks_per_second.load(std::memory_order_relaxed);
+}
 
-  // Returns true if the task runner is quitting, or has quit and hasn't been
-  // restarted since. Exposed primarily for ThreadTaskRunner, not necessary for
-  // normal use of this class.
-  bool QuitCalled();
+}  // namespace
+#endif  // !PERFETTO_BUILDFLAG(PERFETTO_ARCH_CPU_ARM64)
 
- private:
-  void WakeUp();
-  void UpdateWatchTasksLocked();
-  int GetDelayMsToNextTaskLocked() const;
-  void RunImmediateAndDelayedTask();
-  void PostFileDescriptorWatches(uint64_t windows_wait_result);
-  void RunFileDescriptorWatch(PlatformHandle);
+TimeNanos GetWallTimeNs() {
+  LARGE_INTEGER freq;
+  ::QueryPerformanceFrequency(&freq);
+  LARGE_INTEGER counter;
+  ::QueryPerformanceCounter(&counter);
+  double elapsed_nanoseconds = (1e9 * static_cast<double>(counter.QuadPart)) /
+                               static_cast<double>(freq.QuadPart);
+  return TimeNanos(static_cast<uint64_t>(elapsed_nanoseconds));
+}
 
-  ThreadChecker thread_checker_;
-  PlatformThreadId created_thread_id_ = GetThreadId();
+TimeNanos GetThreadCPUTimeNs() {
+#if PERFETTO_BUILDFLAG(PERFETTO_ARCH_CPU_ARM64)
+  // QueryThreadCycleTime versus TSCTicksPerSecond doesn't have much relation to
+  // actual elapsed time on Windows on Arm, because QueryThreadCycleTime is
+  // backed by the actual number of CPU cycles executed, rather than a
+  // constant-rate timer like Intel. To work around this, use GetThreadTimes
+  // (which isn't as accurate but is meaningful as a measure of elapsed
+  // per-thread time).
+  FILETIME dummy, kernel_ftime, user_ftime;
+  ::GetThreadTimes(GetCurrentThread(), &dummy, &dummy, &kernel_ftime,
+                   &user_ftime);
+  uint64_t kernel_time =
+      kernel_ftime.dwHighDateTime * 0x100000000 + kernel_ftime.dwLowDateTime;
+  uint64_t user_time =
+      user_ftime.dwHighDateTime * 0x100000000 + user_ftime.dwLowDateTime;
 
-  EventFd event_;
+  return TimeNanos((kernel_time + user_time) * 100);
+#else   // !PERFETTO_BUILDFLAG(PERFETTO_ARCH_CPU_ARM64)
+  // Get the number of TSC ticks used by the current thread.
+  ULONG64 thread_cycle_time = 0;
+  ::QueryThreadCycleTime(GetCurrentThread(), &thread_cycle_time);
 
-// The array of fds/handles passed to poll(2) / WaitForMultipleObjects().
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-  std::vector<PlatformHandle> poll_fds_;
-#else
-  std::vector<struct pollfd> poll_fds_;
-#endif
+  // Get the frequency of the TSC.
+  const double tsc_ticks_per_second = TSCTicksPerSecond();
+  if (tsc_ticks_per_second == 0)
+    return TimeNanos();
 
-  // --- Begin lock-protected members ---
+  // Return the CPU time of the current thread.
+  const double thread_time_seconds =
+      static_cast<double>(thread_cycle_time) / tsc_ticks_per_second;
+  constexpr int64_t kNanosecondsPerSecond = 1000 * 1000 * 1000;
+  return TimeNanos(
+      static_cast<int64_t>(thread_time_seconds * kNanosecondsPerSecond));
+#endif  // !PERFETTO_BUILDFLAG(PERFETTO_ARCH_CPU_ARM64)
+}
+
+void SleepMicroseconds(unsigned interval_us) {
+  // The Windows Sleep function takes a millisecond count. Round up so that
+  // short sleeps don't turn into a busy wait. Note that the sleep granularity
+  // on Windows can dynamically vary from 1 ms to ~16 ms, so don't count on this
+  // being a short sleep.
+  ::Sleep(static_cast<DWORD>((interval_us + 999) / 1000));
+}
 
-  std::mutex lock_;
+void InitializeTime() {
+#if !PERFETTO_BUILDFLAG(PERFETTO_ARCH_CPU_ARM64)
+  // Make an early first call to TSCTicksPerSecond() to start 50 ms elapsed time
+  // (see comment in TSCTicksPerSecond()).
+  TSCTicksPerSecond();
+#endif  // !PERFETTO_BUILDFLAG(PERFETTO_ARCH_CPU_ARM64)
+}
 
-  std::deque<std::function<void()>> immediate_tasks_;
-  std::multimap<TimeMillis, std::function<void()>> delayed_tasks_;
-  bool quit_ = false;
+#else  // PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
 
-  struct WatchTask {
-    std::function<void()> callback;
+void SleepMicroseconds(unsigned interval_us) {
+  ::usleep(static_cast<useconds_t>(interval_us));
+}
+
+void InitializeTime() {}
+
+#endif  // PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+
+std::string GetTimeFmt(const std::string& fmt) {
+  time_t raw_time;
+  time(&raw_time);
+  struct tm local_tm;
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-    // On UNIX systems we make the FD number negative in |poll_fds_| to avoid
-    // polling it again until the queued task runs. On Windows we can't do that.
-    // Instead we keep track of its state here.
-    bool pending = false;
+  PERFETTO_CHECK(localtime_s(&local_tm, &raw_time) == 0);
 #else
-    size_t poll_fd_index;  // Index into |poll_fds_|.
+  tzset();
+  PERFETTO_CHECK(localtime_r(&raw_time, &local_tm) != nullptr);
 #endif
-  };
-
-  std::map<PlatformHandle, WatchTask> watch_tasks_;
-  bool watch_tasks_changed_ = false;
+  char buf[128];
+  PERFETTO_CHECK(strftime(buf, 80, fmt.c_str(), &local_tm) > 0);
+  return buf;
+}
 
-  // --- End lock-protected members ---
-};
+std::optional<int32_t> GetTimezoneOffsetMins() {
+  std::string tz = GetTimeFmt("%z");
+  if (tz.size() != 5 || (tz[0] != '+' && tz[0] != '-'))
+    return std::nullopt;
+  char sign = '\0';
+  int32_t hh = 0;
+  int32_t mm = 0;
+  if (sscanf(tz.c_str(), "%c%2d%2d", &sign, &hh, &mm) != 3)
+    return std::nullopt;
+  return (hh * 60 + mm) * (sign == '-' ? -1 : 1);
+}
 
 }  // namespace base
 }  // namespace perfetto
-
-#endif  // INCLUDE_PERFETTO_EXT_BASE_UNIX_TASK_RUNNER_H_
+// gen_amalgamated begin source: src/base/utils.cc
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2020 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -8011,160 +9405,402 @@ class UnixTaskRunner : public TaskRunner {
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_EXT_BASE_THREAD_TASK_RUNNER_H_
-#define INCLUDE_PERFETTO_EXT_BASE_THREAD_TASK_RUNNER_H_
+// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
 
-#include <functional>
-#include <thread>
+#include <string>
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/unix_task_runner.h"
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/file_utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/pipe.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
 
-namespace perfetto {
-namespace base {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) ||   \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA)
+#include <limits.h>
+#include <stdlib.h>  // For _exit()
+#include <unistd.h>  // For getpagesize() and geteuid() & fork() & sysconf()
+#endif
 
-// A UnixTaskRunner backed by a dedicated task thread. Shuts down the runner and
-// joins the thread upon destruction. Can be moved to transfer ownership.
-//
-// Guarantees that:
-// * the UnixTaskRunner will be constructed and destructed on the task thread.
-// * the task thread will live for the lifetime of the UnixTaskRunner.
-//
-class PERFETTO_EXPORT_COMPONENT ThreadTaskRunner : public TaskRunner {
- public:
-  static ThreadTaskRunner CreateAndStart(const std::string& name = "") {
-    return ThreadTaskRunner(name);
-  }
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+#include <mach-o/dyld.h>
+#include <mach/vm_page_size.h>
+#endif
 
-  ThreadTaskRunner(const ThreadTaskRunner&) = delete;
-  ThreadTaskRunner& operator=(const ThreadTaskRunner&) = delete;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD)
+#include <sys/sysctl.h>
+#endif
 
-  ThreadTaskRunner(ThreadTaskRunner&&) noexcept;
-  ThreadTaskRunner& operator=(ThreadTaskRunner&&);
-  ~ThreadTaskRunner() override;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX_BUT_NOT_QNX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+#include <sys/prctl.h>
 
-  // Executes the given function on the task runner thread and blocks the caller
-  // thread until the function has run.
-  void PostTaskAndWaitForTesting(std::function<void()>);
+#ifndef PR_GET_TAGGED_ADDR_CTRL
+#define PR_GET_TAGGED_ADDR_CTRL 56
+#endif
 
-  // Can be called from another thread to get the CPU time of the thread the
-  // task-runner is executing on.
-  uint64_t GetThreadCPUTimeNsForTesting();
+#ifndef PR_TAGGED_ADDR_ENABLE
+#define PR_TAGGED_ADDR_ENABLE (1UL << 0)
+#endif
 
-  // Returns a pointer to the UnixTaskRunner, which is valid for the lifetime of
-  // this ThreadTaskRunner object (unless this object is moved-from, in which
-  // case the pointer remains valid for the lifetime of the new owning
-  // ThreadTaskRunner).
-  //
-  // Warning: do not call Quit() on the returned runner pointer, the termination
-  // should be handled exclusively by this class' destructor.
-  UnixTaskRunner* get() const { return task_runner_; }
+#ifndef PR_MTE_TCF_SYNC
+#define PR_MTE_TCF_SYNC (1UL << 1)
+#endif
 
-  // TaskRunner implementation.
-  // These methods just proxy to the underlying task_runner_.
-  void PostTask(std::function<void()>) override;
-  void PostDelayedTask(std::function<void()>, uint32_t delay_ms) override;
-  void AddFileDescriptorWatch(PlatformHandle, std::function<void()>) override;
-  void RemoveFileDescriptorWatch(PlatformHandle) override;
-  bool RunsTasksOnCurrentThread() const override;
+#endif  // OS_LINUX | OS_ANDROID
 
- private:
-  explicit ThreadTaskRunner(const std::string& name);
-  void RunTaskThread(std::function<void(UnixTaskRunner*)> initializer);
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+#include <windows.h>
 
-  std::thread thread_;
-  std::string name_;
-  UnixTaskRunner* task_runner_ = nullptr;
-};
+#include <io.h>
+#include <malloc.h>  // For _aligned_malloc().
+#endif
 
-}  // namespace base
-}  // namespace perfetto
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+#include <dlfcn.h>
+#include <malloc.h>
 
-#endif  // INCLUDE_PERFETTO_EXT_BASE_THREAD_TASK_RUNNER_H_
-// gen_amalgamated begin header: include/perfetto/ext/base/thread_utils.h
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+#ifdef M_PURGE
+#define PERFETTO_M_PURGE M_PURGE
+#else
+// Only available in in-tree builds and on newer SDKs.
+#define PERFETTO_M_PURGE -101
+#endif  // M_PURGE
 
-#ifndef INCLUDE_PERFETTO_EXT_BASE_THREAD_UTILS_H_
-#define INCLUDE_PERFETTO_EXT_BASE_THREAD_UTILS_H_
+#ifdef M_PURGE_ALL
+#define PERFETTO_M_PURGE_ALL M_PURGE_ALL
+#else
+// Only available in in-tree builds and on newer SDKs.
+#define PERFETTO_M_PURGE_ALL -104
+#endif  // M_PURGE
 
-#include <string>
+namespace {
+extern "C" {
+using MalloptType = int (*)(int, int);
+}
+}  // namespace
+#endif  // OS_ANDROID
 
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
+namespace {
+
+#if PERFETTO_BUILDFLAG(PERFETTO_X64_CPU_OPT)
+
+// Preserve the %rbx register via %rdi to work around a clang bug
+// https://bugs.llvm.org/show_bug.cgi?id=17907 (%rbx in an output constraint
+// is not considered a clobbered register).
+#define PERFETTO_GETCPUID(a, b, c, d, a_inp, c_inp) \
+  asm("mov %%rbx, %%rdi\n"                          \
+      "cpuid\n"                                     \
+      "xchg %%rdi, %%rbx\n"                         \
+      : "=a"(a), "=D"(b), "=c"(c), "=d"(d)          \
+      : "a"(a_inp), "2"(c_inp))
+
+uint32_t GetXCR0EAX() {
+  uint32_t eax = 0, edx = 0;
+  asm("xgetbv" : "=a"(eax), "=d"(edx) : "c"(0));
+  return eax;
+}
+
+// If we are building with -msse4 check that the CPU actually supports it.
+// This file must be kept in sync with gn/standalone/BUILD.gn.
+void PERFETTO_EXPORT_COMPONENT __attribute__((constructor))
+CheckCpuOptimizations() {
+  uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0;
+  PERFETTO_GETCPUID(eax, ebx, ecx, edx, 1, 0);
+
+  static constexpr uint64_t xcr0_xmm_mask = 0x2;
+  static constexpr uint64_t xcr0_ymm_mask = 0x4;
+  static constexpr uint64_t xcr0_avx_mask = xcr0_xmm_mask | xcr0_ymm_mask;
+
+  const bool have_popcnt = ecx & (1u << 23);
+  const bool have_sse4_2 = ecx & (1u << 20);
+  const bool have_avx =
+      // Does the OS save/restore XMM and YMM state?
+      (ecx & (1u << 27)) &&  // OS support XGETBV.
+      (ecx & (1u << 28)) &&  // AVX supported in hardware
+      ((GetXCR0EAX() & xcr0_avx_mask) == xcr0_avx_mask);
+
+  // Get level 7 features (eax = 7 and ecx= 0), to check for AVX2 support.
+  // (See Intel 64 and IA-32 Architectures Software Developer's Manual
+  //  Volume 2A: Instruction Set Reference, A-M CPUID).
+  PERFETTO_GETCPUID(eax, ebx, ecx, edx, 7, 0);
+  const bool have_avx2 = have_avx && ((ebx >> 5) & 0x1);
+  const bool have_bmi = (ebx >> 3) & 0x1;
+  const bool have_bmi2 = (ebx >> 8) & 0x1;
+
+  // Get extended features for LZCNT.
+  PERFETTO_GETCPUID(eax, ebx, ecx, edx, 0x80000001, 0);
+  const bool have_lzcnt = ecx & (1u << 5);
+
+  if (!have_sse4_2 || !have_popcnt || !have_avx2 || !have_bmi || !have_bmi2 ||
+      !have_lzcnt) {
+    fprintf(
+        stderr,
+        "This executable requires a x86_64 cpu that supports SSE4.2, BMI2, "
+        "AVX2 and LZCNT.\n"
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+        "On MacOS, this might be caused by running x86_64 binaries on arm64.\n"
+        "See https://github.com/google/perfetto/issues/294 for more.\n"
+#endif
+        "Rebuild with enable_perfetto_x64_cpu_opt=false.\n");
+    _exit(126);
+  }
+}
+#endif
+
+}  // namespace
+
+namespace perfetto {
+namespace base {
+
+namespace internal {
+
+std::atomic<uint32_t> g_cached_page_size{0};
+
+uint32_t GetSysPageSizeSlowpath() {
+  uint32_t page_size = 0;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+  const int page_size_int = getpagesize();
+  // If sysconf() fails for obscure reasons (e.g. SELinux denial) assume the
+  // page size is 4KB. This is to avoid regressing subtle SDK usages, as old
+  // versions of this code had a static constant baked in.
+  page_size = static_cast<uint32_t>(page_size_int > 0 ? page_size_int : 4096);
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+  page_size = static_cast<uint32_t>(vm_page_size);
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD)
+  page_size = static_cast<uint32_t>(sysconf(_SC_PAGESIZE));
+#else
+  page_size = 4096;
+#endif
+
+  PERFETTO_CHECK(page_size > 0 && page_size % 4096 == 0);
+
+  // Races here are fine because any thread will write the same value.
+  g_cached_page_size.store(page_size, std::memory_order_relaxed);
+  return page_size;
+}
+
+}  // namespace internal
+
+void MaybeReleaseAllocatorMemToOS() {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+  // mallopt() on Android requires SDK level 26. Many targets and embedders
+  // still depend on a lower SDK level. Given mallopt() is a quite simple API,
+  // use reflection to do this rather than bumping the SDK level for all
+  // embedders. This keeps the behavior of standalone builds aligned with
+  // in-tree builds.
+  static MalloptType mallopt_fn =
+      reinterpret_cast<MalloptType>(dlsym(RTLD_DEFAULT, "mallopt"));
+  if (!mallopt_fn)
+    return;
+  if (mallopt_fn(PERFETTO_M_PURGE_ALL, 0) == 0) {
+    mallopt_fn(PERFETTO_M_PURGE, 0);
+  }
+#endif
+}
 
+uid_t GetCurrentUserId() {
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
     PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) || \
     PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
-#include <pthread.h>
-#include <string.h>
-#include <algorithm>
+  return geteuid();
+#else
+  // TODO(primiano): On Windows we could hash the current user SID and derive a
+  // numeric user id [1]. It is not clear whether we need that. Right now that
+  // would not bring any benefit. Returning 0 unil we can prove we need it.
+  // [1]:https://android-review.googlesource.com/c/platform/external/perfetto/+/1513879/25/src/base/utils.cc
+  return 0;
 #endif
+}
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-#include <sys/prctl.h>
+void SetEnv(const std::string& key, const std::string& value) {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  PERFETTO_CHECK(::_putenv_s(key.c_str(), value.c_str()) == 0);
+#else
+  PERFETTO_CHECK(::setenv(key.c_str(), value.c_str(), /*overwrite=*/true) == 0);
 #endif
+}
 
-// Internal implementation utils that aren't as widely useful/supported as
-// base/thread_utils.h.
+void UnsetEnv(const std::string& key) {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  PERFETTO_CHECK(::_putenv_s(key.c_str(), "") == 0);
+#else
+  PERFETTO_CHECK(::unsetenv(key.c_str()) == 0);
+#endif
+}
 
-namespace perfetto {
-namespace base {
+void Daemonize(std::function<int()> parent_cb) {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) || \
+    (PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) &&  \
+     !PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE_TVOS))
+  Pipe pipe = Pipe::Create(Pipe::kBothBlock);
+  pid_t pid;
+  switch (pid = fork()) {
+    case -1:
+      PERFETTO_FATAL("fork");
+    case 0: {
+      PERFETTO_CHECK(setsid() != -1);
+      base::ignore_result(chdir("/"));
+      base::ScopedFile null = base::OpenFile("/dev/null", O_RDONLY);
+      PERFETTO_CHECK(null);
+      PERFETTO_CHECK(dup2(*null, STDIN_FILENO) != -1);
+      PERFETTO_CHECK(dup2(*null, STDOUT_FILENO) != -1);
+      PERFETTO_CHECK(dup2(*null, STDERR_FILENO) != -1);
+      // Do not accidentally close stdin/stdout/stderr.
+      if (*null <= 2)
+        null.release();
+      WriteAll(*pipe.wr, "1", 1);
+      break;
+    }
+    default: {
+      // Wait for the child process to have reached the setsid() call. This is
+      // to avoid that 'adb shell perfetto -D' destroys the terminal (hence
+      // sending a SIGHUP to the child) before the child has detached from the
+      // terminal (see b/238644870).
+
+      // This is to unblock the read() below (with EOF, which will fail the
+      // CHECK) in the unlikely case of the child crashing before WriteAll("1").
+      pipe.wr.reset();
+      char one = '\0';
+      PERFETTO_CHECK(Read(*pipe.rd, &one, sizeof(one)) == 1 && one == '1');
+      printf("%d\n", pid);
+      int err = parent_cb();
+      exit(err);
+    }
+  }
+#else
+  // Avoid -Wunreachable warnings.
+  if (reinterpret_cast<intptr_t>(&Daemonize) != 16)
+    PERFETTO_FATAL("--background is only supported on Linux/Android/Mac");
+  ignore_result(parent_cb);
+#endif  // OS_WIN
+}
 
+std::string GetCurExecutablePath() {
+  std::string self_path;
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
     PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
-// Sets the "comm" of the calling thread to the first 15 chars of the given
-// string.
-inline bool MaybeSetThreadName(const std::string& name) {
-  char buf[16] = {};
-  StringCopy(buf, name.c_str(), sizeof(buf));
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA)
+  char buf[PATH_MAX];
+  ssize_t size = readlink("/proc/self/exe", buf, sizeof(buf));
+  PERFETTO_CHECK(size != -1);
+  // readlink does not null terminate.
+  self_path = std::string(buf, static_cast<size_t>(size));
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+  uint32_t size = 0;
+  PERFETTO_CHECK(_NSGetExecutablePath(nullptr, &size));
+  self_path.resize(size);
+  PERFETTO_CHECK(_NSGetExecutablePath(&self_path[0], &size) == 0);
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  char buf[MAX_PATH];
+  auto len = ::GetModuleFileNameA(nullptr /*current*/, buf, sizeof(buf));
+  self_path = std::string(buf, len);
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD)
+  char buf[PATH_MAX];
+  int mib[4], ret;
+  size_t len = sizeof(buf);
+  mib[0] = CTL_KERN;
+  mib[1] = KERN_PROC;
+  mib[2] = KERN_PROC_PATHNAME;
+  mib[3] = -1;
+  ret = sysctl(mib, 4, buf, &len, NULL, 0);
+  PERFETTO_CHECK(ret == 0);
+  // This returns the full path; need to trim the executable
+  self_path = std::string(buf);
+#else
+  PERFETTO_FATAL(
+      "GetCurExecutableDir() not implemented on the current platform");
+#endif
+  return self_path;
+}
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
-  return pthread_setname_np(buf) == 0;
+std::string GetCurExecutableDir() {
+  auto path = GetCurExecutablePath();
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  // Paths in Windows can have both kinds of slashes (mingw vs msvc).
+  path = path.substr(0, path.find_last_of('\\'));
+#endif
+  path = path.substr(0, path.find_last_of('/'));
+  return path;
+}
+
+void* AlignedAlloc(size_t alignment, size_t size) {
+  void* res = nullptr;
+  alignment = AlignUp<sizeof(void*)>(alignment);  // At least pointer size.
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  // Window's _aligned_malloc() has a nearly identically signature to Unix's
+  // aligned_alloc() but its arguments are obviously swapped.
+  res = _aligned_malloc(size, alignment);
 #else
-  return pthread_setname_np(pthread_self(), buf) == 0;
+  // aligned_alloc() has been introduced in Android only in API 28.
+  // Also NaCl and Fuchsia seems to have only posix_memalign().
+  ignore_result(posix_memalign(&res, alignment, size));
 #endif
+  PERFETTO_CHECK(res);
+  return res;
 }
 
-inline bool GetThreadName(std::string& out_result) {
-  char buf[16] = {};
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-  if (prctl(PR_GET_NAME, buf) != 0)
-    return false;
+void AlignedFree(void* ptr) {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  _aligned_free(ptr);  // MSDN says it is fine to pass nullptr.
 #else
-  if (pthread_getname_np(pthread_self(), buf, sizeof(buf)) != 0)
-    return false;
+  free(ptr);
 #endif
-  out_result = std::string(buf);
-  return true;
 }
 
+bool IsSyncMemoryTaggingEnabled() {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX_BUT_NOT_QNX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+  // Compute only once per lifetime of the process.
+  static bool cached_value = [] {
+    const int res = prctl(PR_GET_TAGGED_ADDR_CTRL, 0, 0, 0, 0);
+    if (res < 0)
+      return false;
+    const uint32_t actl = static_cast<uint32_t>(res);
+    return (actl & PR_TAGGED_ADDR_ENABLE) && (actl & PR_MTE_TCF_SYNC);
+  }();
+  return cached_value;
 #else
-inline bool MaybeSetThreadName(const std::string&) {
   return false;
+#endif
 }
-inline bool GetThreadName(std::string&) {
-  return false;
+
+std::string HexDump(const void* data_void, size_t len, size_t bytes_per_line) {
+  const char* data = reinterpret_cast<const char*>(data_void);
+  std::string res;
+  static const size_t kPadding = bytes_per_line * 3 + 12;
+  std::unique_ptr<char[]> line(new char[bytes_per_line * 4 + 128]);
+  for (size_t i = 0; i < len; i += bytes_per_line) {
+    char* wptr = line.get();
+    wptr += base::SprintfTrunc(wptr, 19, "%08zX: ", i);
+    for (size_t j = i; j < i + bytes_per_line && j < len; j++) {
+      wptr += base::SprintfTrunc(wptr, 4, "%02X ",
+                                 static_cast<unsigned>(data[j]) & 0xFF);
+    }
+    for (size_t j = static_cast<size_t>(wptr - line.get()); j < kPadding; ++j)
+      *(wptr++) = ' ';
+    for (size_t j = i; j < i + bytes_per_line && j < len; j++) {
+      char c = data[j];
+      *(wptr++) = (c >= 32 && c < 127) ? c : '.';
+    }
+    *(wptr++) = '\n';
+    *(wptr++) = '\0';
+    res.append(line.get());
+  }
+  return res;
 }
-#endif
 
 }  // namespace base
 }  // namespace perfetto
-
-#endif  // INCLUDE_PERFETTO_EXT_BASE_THREAD_UTILS_H_
+// gen_amalgamated begin source: src/base/uuid.cc
+// gen_amalgamated begin header: include/perfetto/ext/base/uuid.h
 /*
  * Copyright (C) 2019 The Android Open Source Project
  *
@@ -8181,132 +9817,170 @@ inline bool GetThreadName(std::string&) {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
-
-// gen_amalgamated expanded: #include "perfetto/ext/base/thread_task_runner.h"
-
-#include <condition_variable>
-#include <functional>
-#include <mutex>
-#include <thread>
+#ifndef INCLUDE_PERFETTO_EXT_BASE_UUID_H_
+#define INCLUDE_PERFETTO_EXT_BASE_UUID_H_
 
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/thread_utils.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/unix_task_runner.h"
+#include <string.h>
+#include <array>
+#include <cstdint>
+#include <string>
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-#include <sys/prctl.h>
-#endif
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
 namespace perfetto {
 namespace base {
 
-ThreadTaskRunner::ThreadTaskRunner(ThreadTaskRunner&& other) noexcept
-    : thread_(std::move(other.thread_)), task_runner_(other.task_runner_) {
-  other.task_runner_ = nullptr;
-}
+class PERFETTO_EXPORT_COMPONENT Uuid {
+ public:
+  explicit Uuid(const std::string& s);
+  explicit Uuid(int64_t lsb, int64_t msb);
+  Uuid();
 
-ThreadTaskRunner& ThreadTaskRunner::operator=(ThreadTaskRunner&& other) {
-  this->~ThreadTaskRunner();
-  new (this) ThreadTaskRunner(std::move(other));
-  return *this;
-}
+  std::array<uint8_t, 16>* data() { return &data_; }
+  const std::array<uint8_t, 16>* data() const { return &data_; }
 
-ThreadTaskRunner::~ThreadTaskRunner() {
-  if (task_runner_) {
-    PERFETTO_CHECK(!task_runner_->QuitCalled());
-    task_runner_->Quit();
+  bool operator==(const Uuid& other) const { return data_ == other.data_; }
 
-    PERFETTO_DCHECK(thread_.joinable());
+  bool operator!=(const Uuid& other) const { return !(*this == other); }
+
+  explicit operator bool() const { return *this != Uuid(); }
+
+  int64_t msb() const {
+    int64_t result;
+    memcpy(&result, data_.data() + 8, 8);
+    return result;
   }
-  if (thread_.joinable())
-    thread_.join();
-}
 
-ThreadTaskRunner::ThreadTaskRunner(const std::string& name) : name_(name) {
-  std::mutex init_lock;
-  std::condition_variable init_cv;
+  int64_t lsb() const {
+    int64_t result;
+    memcpy(&result, data_.data(), 8);
+    return result;
+  }
 
-  std::function<void(UnixTaskRunner*)> initializer =
-      [this, &init_lock, &init_cv](UnixTaskRunner* task_runner) {
-        std::lock_guard<std::mutex> lock(init_lock);
-        task_runner_ = task_runner;
-        // Notify while still holding the lock, as init_cv ceases to exist as
-        // soon as the main thread observes a non-null task_runner_, and it can
-        // wake up spuriously (i.e. before the notify if we had unlocked before
-        // notifying).
-        init_cv.notify_one();
-      };
+  void set_lsb_msb(int64_t lsb, int64_t msb) {
+    set_lsb(lsb);
+    set_msb(msb);
+  }
+  void set_msb(int64_t msb) { memcpy(data_.data() + 8, &msb, 8); }
+  void set_lsb(int64_t lsb) { memcpy(data_.data(), &lsb, 8); }
 
-  thread_ = std::thread(&ThreadTaskRunner::RunTaskThread, this,
-                        std::move(initializer));
+  std::string ToString() const;
+  std::string ToPrettyString() const;
 
-  std::unique_lock<std::mutex> lock(init_lock);
-  init_cv.wait(lock, [this] { return !!task_runner_; });
-}
+ private:
+  std::array<uint8_t, 16> data_{};
+};
 
-void ThreadTaskRunner::RunTaskThread(
-    std::function<void(UnixTaskRunner*)> initializer) {
-  if (!name_.empty()) {
-    base::MaybeSetThreadName(name_);
-  }
+Uuid Uuidv4();
 
-  UnixTaskRunner task_runner;
-  task_runner.PostTask(std::bind(std::move(initializer), &task_runner));
-  task_runner.Run();
-}
+}  // namespace base
+}  // namespace perfetto
 
-void ThreadTaskRunner::PostTaskAndWaitForTesting(std::function<void()> fn) {
-  std::mutex mutex;
-  std::condition_variable cv;
+#endif  // INCLUDE_PERFETTO_EXT_BASE_UUID_H_
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-  std::unique_lock<std::mutex> lock(mutex);
-  bool done = false;
-  task_runner_->PostTask([&mutex, &cv, &done, &fn] {
-    fn();
+// gen_amalgamated expanded: #include "perfetto/ext/base/uuid.h"
 
-    std::lock_guard<std::mutex> inner_lock(mutex);
-    done = true;
-    cv.notify_one();
-  });
-  cv.wait(lock, [&done] { return done; });
-}
+#include <random>
 
-uint64_t ThreadTaskRunner::GetThreadCPUTimeNsForTesting() {
-  uint64_t thread_time_ns = 0;
-  PostTaskAndWaitForTesting([&thread_time_ns] {
-    thread_time_ns = static_cast<uint64_t>(base::GetThreadCPUTimeNs().count());
-  });
-  return thread_time_ns;
-}
+// gen_amalgamated expanded: #include "perfetto/base/time.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
 
-void ThreadTaskRunner::PostTask(std::function<void()> task) {
-  task_runner_->PostTask(std::move(task));
+namespace perfetto {
+namespace base {
+namespace {
+
+constexpr char kHexmap[] = {'0', '1', '2', '3', '4', '5', '6', '7',
+                            '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+
+}  // namespace
+
+// A globally unique 128-bit number.
+// In the early days of perfetto we were (sorta) respecting rfc4122. Later we
+// started replacing the LSB of the UUID with the statsd subscription ID in
+// other parts of the codebase (see perfetto_cmd.cc) for the convenience of
+// trace lookups, so rfc4122 made no sense as it just reduced entropy.
+Uuid Uuidv4() {
+  // Mix different sources of entropy to reduce the chances of collisions.
+  // Only using boot time is not enough. Under the assumption that most traces
+  // are started around the same time at boot, within a 1s window, the birthday
+  // paradox gives a chance of 90% collisions with 70k traces over a 1e9 space
+  // (Number of ns in a 1s window).
+  // We deliberately don't use /dev/urandom as that might block for
+  // unpredictable time if the system is idle (and is not portable).
+  // The UUID does NOT need to be cryptographically secure, but random enough
+  // to avoid collisions across a large number of devices.
+  uint64_t boot_ns = static_cast<uint64_t>(GetBootTimeNs().count());
+  uint64_t epoch_ns = static_cast<uint64_t>(GetWallTimeNs().count());
+
+  // Use code ASLR as entropy source.
+  uint32_t code_ptr =
+      static_cast<uint32_t>(reinterpret_cast<uint64_t>(&Uuidv4) >> 12);
+
+  // Use stack ASLR as a further entropy source.
+  uint32_t stack_ptr =
+      static_cast<uint32_t>(reinterpret_cast<uint64_t>(&code_ptr) >> 12);
+
+  uint32_t entropy[] = {static_cast<uint32_t>(boot_ns >> 32),
+                        static_cast<uint32_t>(boot_ns),
+                        static_cast<uint32_t>(epoch_ns >> 32),
+                        static_cast<uint32_t>(epoch_ns),
+                        code_ptr,
+                        stack_ptr};
+  std::seed_seq entropy_seq(entropy, entropy + ArraySize(entropy));
+
+  auto words = std::array<uint32_t, 4>();
+  entropy_seq.generate(words.begin(), words.end());
+  uint64_t msb = static_cast<uint64_t>(words[0]) << 32u | words[1];
+  uint64_t lsb = static_cast<uint64_t>(words[2]) << 32u | words[3];
+  return Uuid(static_cast<int64_t>(lsb), static_cast<int64_t>(msb));
 }
 
-void ThreadTaskRunner::PostDelayedTask(std::function<void()> task,
-                                       uint32_t delay_ms) {
-  task_runner_->PostDelayedTask(std::move(task), delay_ms);
+Uuid::Uuid() {}
+
+Uuid::Uuid(const std::string& s) {
+  PERFETTO_CHECK(s.size() == data_.size());
+  memcpy(data_.data(), s.data(), s.size());
 }
 
-void ThreadTaskRunner::AddFileDescriptorWatch(
-    PlatformHandle handle,
-    std::function<void()> watch_task) {
-  task_runner_->AddFileDescriptorWatch(handle, std::move(watch_task));
+Uuid::Uuid(int64_t lsb, int64_t msb) {
+  set_lsb_msb(lsb, msb);
 }
 
-void ThreadTaskRunner::RemoveFileDescriptorWatch(PlatformHandle handle) {
-  task_runner_->RemoveFileDescriptorWatch(handle);
+std::string Uuid::ToString() const {
+  return std::string(reinterpret_cast<const char*>(data_.data()), data_.size());
 }
 
-bool ThreadTaskRunner::RunsTasksOnCurrentThread() const {
-  return task_runner_->RunsTasksOnCurrentThread();
+std::string Uuid::ToPrettyString() const {
+  std::string s(data_.size() * 2 + 4, '-');
+  // Format is 123e4567-e89b-12d3-a456-426655443322.
+  size_t j = 0;
+  for (size_t i = 0; i < data_.size(); ++i) {
+    if (i == 4 || i == 6 || i == 8 || i == 10)
+      j++;
+    s[2 * i + j] = kHexmap[(data_[data_.size() - i - 1] & 0xf0) >> 4];
+    s[2 * i + 1 + j] = kHexmap[(data_[data_.size() - i - 1] & 0x0f)];
+  }
+  return s;
 }
 
 }  // namespace base
 }  // namespace perfetto
-// gen_amalgamated begin source: src/base/unix_task_runner.cc
+// gen_amalgamated begin source: src/base/virtual_destructors.cc
 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
@@ -8323,300 +9997,124 @@ bool ThreadTaskRunner::RunsTasksOnCurrentThread() const {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
-
-// gen_amalgamated expanded: #include "perfetto/ext/base/platform.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/unix_task_runner.h"
-
-#include <errno.h>
-#include <stdlib.h>
-
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-#include <Windows.h>
-#include <synchapi.h>
-#else
-#include <unistd.h>
-#endif
-
-#include <algorithm>
-#include <limits>
+// gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/watchdog.h"
+// This translation unit contains the definitions for the destructor of pure
+// virtual interfaces for the current build target. The alternative would be
+// introducing a one-liner .cc file for each pure virtual interface, which is
+// overkill. This is for compliance with -Wweak-vtables.
 
 namespace perfetto {
 namespace base {
 
-UnixTaskRunner::UnixTaskRunner() {
-  AddFileDescriptorWatch(event_.fd(), [] {
-    // Not reached -- see PostFileDescriptorWatches().
-    PERFETTO_DFATAL("Should be unreachable.");
-  });
-}
-
-UnixTaskRunner::~UnixTaskRunner() = default;
-
-void UnixTaskRunner::WakeUp() {
-  event_.Notify();
-}
-
-void UnixTaskRunner::Run() {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  created_thread_id_ = GetThreadId();
-  quit_ = false;
-  for (;;) {
-    int poll_timeout_ms;
-    {
-      std::lock_guard<std::mutex> lock(lock_);
-      if (quit_)
-        return;
-      poll_timeout_ms = GetDelayMsToNextTaskLocked();
-      UpdateWatchTasksLocked();
-    }
-
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-    DWORD timeout =
-        poll_timeout_ms >= 0 ? static_cast<DWORD>(poll_timeout_ms) : INFINITE;
-    DWORD ret =
-        WaitForMultipleObjects(static_cast<DWORD>(poll_fds_.size()),
-                               &poll_fds_[0], /*bWaitAll=*/false, timeout);
-    // Unlike poll(2), WaitForMultipleObjects() returns only *one* handle in the
-    // set, even when >1 is signalled. In order to avoid starvation,
-    // PostFileDescriptorWatches() will WaitForSingleObject() each other handle
-    // to ensure fairness. |ret| here is passed just to avoid an extra
-    // WaitForSingleObject() for the one handle that WaitForMultipleObject()
-    // returned.
-    PostFileDescriptorWatches(ret);
-#else
-    platform::BeforeMaybeBlockingSyscall();
-    int ret = PERFETTO_EINTR(poll(
-        &poll_fds_[0], static_cast<nfds_t>(poll_fds_.size()), poll_timeout_ms));
-    platform::AfterMaybeBlockingSyscall();
-    PERFETTO_CHECK(ret >= 0);
-    PostFileDescriptorWatches(0 /*ignored*/);
-#endif
-
-    // To avoid starvation we always interleave all types of tasks -- immediate,
-    // delayed and file descriptor watches.
-    RunImmediateAndDelayedTask();
-  }
-}
-
-void UnixTaskRunner::Quit() {
-  std::lock_guard<std::mutex> lock(lock_);
-  quit_ = true;
-  WakeUp();
-}
-
-bool UnixTaskRunner::QuitCalled() {
-  std::lock_guard<std::mutex> lock(lock_);
-  return quit_;
-}
+TaskRunner::~TaskRunner() = default;
 
-bool UnixTaskRunner::IsIdleForTesting() {
-  std::lock_guard<std::mutex> lock(lock_);
-  return immediate_tasks_.empty();
-}
+}  // namespace base
+}  // namespace perfetto
+// gen_amalgamated begin source: src/base/waitable_event.cc
+// gen_amalgamated begin header: include/perfetto/ext/base/waitable_event.h
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-void UnixTaskRunner::UpdateWatchTasksLocked() {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-  if (!watch_tasks_changed_)
-    return;
-  watch_tasks_changed_ = false;
-#endif
-  poll_fds_.clear();
-  for (auto& it : watch_tasks_) {
-    PlatformHandle handle = it.first;
-    WatchTask& watch_task = it.second;
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-    if (!watch_task.pending)
-      poll_fds_.push_back(handle);
-#else
-    watch_task.poll_fd_index = poll_fds_.size();
-    poll_fds_.push_back({handle, POLLIN | POLLHUP, 0});
-#endif
-  }
-}
+#ifndef INCLUDE_PERFETTO_EXT_BASE_WAITABLE_EVENT_H_
+#define INCLUDE_PERFETTO_EXT_BASE_WAITABLE_EVENT_H_
 
-void UnixTaskRunner::RunImmediateAndDelayedTask() {
-  // If locking overhead becomes an issue, add a separate work queue.
-  std::function<void()> immediate_task;
-  std::function<void()> delayed_task;
-  TimeMillis now = GetWallTimeMs();
-  {
-    std::lock_guard<std::mutex> lock(lock_);
-    if (!immediate_tasks_.empty()) {
-      immediate_task = std::move(immediate_tasks_.front());
-      immediate_tasks_.pop_front();
-    }
-    if (!delayed_tasks_.empty()) {
-      auto it = delayed_tasks_.begin();
-      if (now >= it->first) {
-        delayed_task = std::move(it->second);
-        delayed_tasks_.erase(it);
-      }
-    }
-  }
+// gen_amalgamated expanded: #include "perfetto/base/thread_annotations.h"
 
-  errno = 0;
-  if (immediate_task)
-    RunTaskWithWatchdogGuard(immediate_task);
-  errno = 0;
-  if (delayed_task)
-    RunTaskWithWatchdogGuard(delayed_task);
-}
+#include <stdint.h>
 
-void UnixTaskRunner::PostFileDescriptorWatches(uint64_t windows_wait_result) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  for (size_t i = 0; i < poll_fds_.size(); i++) {
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-    const PlatformHandle handle = poll_fds_[i];
-    // |windows_wait_result| is the result of WaitForMultipleObjects() call. If
-    // one of the objects was signalled, it will have a value between
-    // [0, poll_fds_.size()].
-    if (i != windows_wait_result &&
-        WaitForSingleObject(handle, 0) != WAIT_OBJECT_0) {
-      continue;
-    }
-#else
-    base::ignore_result(windows_wait_result);
-    const PlatformHandle handle = poll_fds_[i].fd;
-    if (!(poll_fds_[i].revents & (POLLIN | POLLHUP)))
-      continue;
-    poll_fds_[i].revents = 0;
-#endif
+#include <condition_variable>
+#include <mutex>
 
-    // The wake-up event is handled inline to avoid an infinite recursion of
-    // posted tasks.
-    if (handle == event_.fd()) {
-      event_.Clear();
-      continue;
-    }
+namespace perfetto {
+namespace base {
 
-    // Binding to |this| is safe since we are the only object executing the
-    // task.
-    PostTask(std::bind(&UnixTaskRunner::RunFileDescriptorWatch, this, handle));
+// A waitable event for cross-thread synchronization.
+// All methods on this class can be called from any thread.
+class WaitableEvent {
+ public:
+  WaitableEvent();
+  ~WaitableEvent();
+  WaitableEvent(const WaitableEvent&) = delete;
+  WaitableEvent operator=(const WaitableEvent&) = delete;
 
-    // Flag the task as pending.
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-    // On Windows this is done by marking the WatchTask entry as pending. This
-    // is more expensive than Linux as requires rebuilding the |poll_fds_|
-    // vector on each call. There doesn't seem to be a good alternative though.
-    auto it = watch_tasks_.find(handle);
-    PERFETTO_CHECK(it != watch_tasks_.end());
-    PERFETTO_DCHECK(!it->second.pending);
-    it->second.pending = true;
-#else
-    // On UNIX systems instead, we just make the fd negative while its task is
-    // pending. This makes poll(2) ignore the fd.
-    PERFETTO_DCHECK(poll_fds_[i].fd >= 0);
-    poll_fds_[i].fd = -poll_fds_[i].fd;
-#endif
-  }
-}
+  // Synchronously block until the event is notified `notification` times.
+  void Wait(uint64_t notifications = 1);
 
-void UnixTaskRunner::RunFileDescriptorWatch(PlatformHandle fd) {
-  std::function<void()> task;
-  {
-    std::lock_guard<std::mutex> lock(lock_);
-    auto it = watch_tasks_.find(fd);
-    if (it == watch_tasks_.end())
-      return;
-    WatchTask& watch_task = it->second;
+  // Signal the event, waking up blocked waiters.
+  void Notify();
 
-    // Make poll(2) pay attention to the fd again. Since another thread may have
-    // updated this watch we need to refresh the set first.
-    UpdateWatchTasksLocked();
+ private:
+  std::mutex mutex_;
+  std::condition_variable event_ PERFETTO_GUARDED_BY(mutex_);
+  uint64_t notifications_ PERFETTO_GUARDED_BY(mutex_) = 0;
+};
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-    // On Windows we manually track the presence of outstanding tasks for the
-    // watch. The UpdateWatchTasksLocked() in the Run() loop will re-add the
-    // task to the |poll_fds_| vector.
-    PERFETTO_DCHECK(watch_task.pending);
-    watch_task.pending = false;
-#else
-    size_t fd_index = watch_task.poll_fd_index;
-    PERFETTO_DCHECK(fd_index < poll_fds_.size());
-    PERFETTO_DCHECK(::abs(poll_fds_[fd_index].fd) == fd);
-    poll_fds_[fd_index].fd = fd;
-#endif
-    task = watch_task.callback;
-  }
-  errno = 0;
-  RunTaskWithWatchdogGuard(task);
-}
+}  // namespace base
+}  // namespace perfetto
 
-int UnixTaskRunner::GetDelayMsToNextTaskLocked() const {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  if (!immediate_tasks_.empty())
-    return 0;
-  if (!delayed_tasks_.empty()) {
-    TimeMillis diff = delayed_tasks_.begin()->first - GetWallTimeMs();
-    return std::max(0, static_cast<int>(diff.count()));
-  }
-  return -1;
-}
+#endif  // INCLUDE_PERFETTO_EXT_BASE_WAITABLE_EVENT_H_
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-void UnixTaskRunner::PostTask(std::function<void()> task) {
-  bool was_empty;
-  {
-    std::lock_guard<std::mutex> lock(lock_);
-    was_empty = immediate_tasks_.empty();
-    immediate_tasks_.push_back(std::move(task));
-  }
-  if (was_empty)
-    WakeUp();
-}
+// gen_amalgamated expanded: #include "perfetto/ext/base/waitable_event.h"
 
-void UnixTaskRunner::PostDelayedTask(std::function<void()> task,
-                                     uint32_t delay_ms) {
-  TimeMillis runtime = GetWallTimeMs() + TimeMillis(delay_ms);
-  {
-    std::lock_guard<std::mutex> lock(lock_);
-    delayed_tasks_.insert(std::make_pair(runtime, std::move(task)));
-  }
-  WakeUp();
-}
+namespace perfetto {
+namespace base {
 
-void UnixTaskRunner::AddFileDescriptorWatch(PlatformHandle fd,
-                                            std::function<void()> task) {
-  PERFETTO_DCHECK(PlatformHandleChecker::IsValid(fd));
-  {
-    std::lock_guard<std::mutex> lock(lock_);
-    PERFETTO_DCHECK(!watch_tasks_.count(fd));
-    WatchTask& watch_task = watch_tasks_[fd];
-    watch_task.callback = std::move(task);
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-    watch_task.pending = false;
-#else
-    watch_task.poll_fd_index = SIZE_MAX;
-#endif
-    watch_tasks_changed_ = true;
-  }
-  WakeUp();
-}
+WaitableEvent::WaitableEvent() = default;
+WaitableEvent::~WaitableEvent() = default;
 
-void UnixTaskRunner::RemoveFileDescriptorWatch(PlatformHandle fd) {
-  PERFETTO_DCHECK(PlatformHandleChecker::IsValid(fd));
-  {
-    std::lock_guard<std::mutex> lock(lock_);
-    PERFETTO_DCHECK(watch_tasks_.count(fd));
-    watch_tasks_.erase(fd);
-    watch_tasks_changed_ = true;
-  }
-  // No need to schedule a wake-up for this.
+void WaitableEvent::Wait(uint64_t notifications)
+    PERFETTO_NO_THREAD_SAFETY_ANALYSIS {
+  // 'std::unique_lock' lock doesn't work well with thread annotations
+  // (see https://github.com/llvm/llvm-project/issues/63239),
+  // so we suppress thread safety static analysis for this method.
+  std::unique_lock<std::mutex> lock(mutex_);
+  return event_.wait(lock, [&]() PERFETTO_EXCLUSIVE_LOCKS_REQUIRED(mutex_) {
+    return notifications_ >= notifications;
+  });
 }
 
-bool UnixTaskRunner::RunsTasksOnCurrentThread() const {
-  return GetThreadId() == created_thread_id_;
+void WaitableEvent::Notify() {
+  std::lock_guard<std::mutex> lock(mutex_);
+  ++notifications_;
+  event_.notify_all();
 }
 
 }  // namespace base
 }  // namespace perfetto
-// gen_amalgamated begin source: src/base/subprocess.cc
-// gen_amalgamated begin header: include/perfetto/ext/base/subprocess.h
+// gen_amalgamated begin source: src/base/watchdog_posix.cc
+// gen_amalgamated begin header: include/perfetto/ext/base/watchdog.h
+// gen_amalgamated begin header: include/perfetto/ext/base/watchdog_noop.h
 /*
- * Copyright (C) 2020 The Android Open Source Project
+ * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -8631,274 +10129,43 @@ bool UnixTaskRunner::RunsTasksOnCurrentThread() const {
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_EXT_BASE_SUBPROCESS_H_
-#define INCLUDE_PERFETTO_EXT_BASE_SUBPROCESS_H_
-
-#include <condition_variable>
-#include <functional>
-#include <initializer_list>
-#include <mutex>
-#include <string>
-#include <thread>
-#include <vector>
+#ifndef INCLUDE_PERFETTO_EXT_BASE_WATCHDOG_NOOP_H_
+#define INCLUDE_PERFETTO_EXT_BASE_WATCHDOG_NOOP_H_
 
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/base/platform_handle.h"
-// gen_amalgamated expanded: #include "perfetto/base/proc_utils.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/event_fd.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/optional.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/pipe.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
+#include <stdint.h>
 
 namespace perfetto {
 namespace base {
 
-// Handles creation and lifecycle management of subprocesses, taking care of
-// all subtleties involved in handling processes on UNIX.
-// This class allows to deal with macro two use-cases:
-// 1) fork() + exec() equivalent: for spawning a brand new process image.
-//    This happens when |args.exec_cmd| is not empty.
-//    This is safe to use even in a multi-threaded environment.
-// 2) fork(): for spawning a process and running a function.
-//    This happens when |args.posix_entrypoint_for_testing| is not empty.
-//    This is intended only for tests as it is extremely subtle.
-//    This mode must be used with extreme care. Before the entrypoint is
-//    invoked all file descriptors other than stdin/out/err and the ones
-//    specified in |args.preserve_fds| will be closed, to avoid each process
-//    retaining a dupe of other subprocesses pipes. This however means that
-//    any non trivial calls (including logging) must be avoided as they might
-//    refer to FDs that are now closed. The entrypoint should really be used
-//    just to signal a pipe or similar for synchronizing sequencing in tests.
+enum class WatchdogCrashReason;  // Defined in watchdog.h.
 
-//
-// This class allows to control stdin/out/err pipe redirection and takes care
-// of keeping all the pipes pumped (stdin) / drained (stdout/err), in a similar
-// fashion of python's subprocess.Communicate()
-// stdin: is always piped and closed once the |args.input| buffer is written.
-// stdout/err can be either:
-//   - dup()ed onto the parent process stdout/err.
-//   - redirected onto /dev/null.
-//   - piped onto a buffer (see output() method). There is only one output
-//     buffer in total. If both stdout and stderr are set to kBuffer mode, they
-//     will be merged onto the same. There doesn't seem any use case where they
-//     are needed distinctly.
-//
-// Some caveats worth mentioning:
-// - It always waitpid()s, to avoid leaving zombies around. If the process is
-//   not terminated by the time the destructor is reached, the dtor will
-//   send a SIGKILL and wait for the termination.
-// - After fork()-ing it will close all file descriptors, preserving only
-//   stdin/out/err and the fds listed in |args.preserve_fds|.
-// - On Linux/Android, the child process will be SIGKILL-ed if the calling
-//   thread exists, even if the Subprocess is std::move()-d onto another thread.
-//   This happens by virtue PR_SET_PDEATHSIG, which is used to avoid that
-//   child processes are leaked in the case of a crash of the parent (frequent
-//   in tests). However, the child process might still be leaked if execing
-//   a setuid/setgid binary (see man 2 prctl).
-//
-// Usage:
-// base::Subprocess p({"/bin/cat", "-"});
-// (or equivalently:
-//     base::Subprocess p;
-//     p.args.exec_cmd.push_back("/bin/cat");
-//     p.args.exec_cmd.push_back("-");
-//  )
-// p.args.stdout_mode = base::Subprocess::kBuffer;
-// p.args.stderr_mode = base::Subprocess::kInherit;
-// p.args.input = "stdin contents";
-// p.Call();
-// (or equivalently:
-//     p.Start();
-//     p.Wait();
-// )
-// EXPECT_EQ(p.status(), base::Subprocess::kTerminated);
-// EXPECT_EQ(p.returncode(), 0);
-class Subprocess {
+class Watchdog {
  public:
-  enum Status {
-    kNotStarted = 0,  // Before calling Start() or Call().
-    kRunning,         // After calling Start(), before Wait().
-    kTerminated,      // The subprocess terminated, either successfully or not.
-                      // This includes crashes or other signals on UNIX.
-  };
-
-  enum class OutputMode {
-    kInherit = 0,  // Inherit's the caller process stdout/stderr.
-    kDevNull,      // dup() onto /dev/null.
-    kBuffer,       // dup() onto a pipe and move it into the output() buffer.
-    kFd,           // dup() onto the passed args.fd.
-  };
-
-  enum class InputMode {
-    kBuffer = 0,  // dup() onto a pipe and write args.input on it.
-    kDevNull,     // dup() onto /dev/null.
-  };
-
-  // Input arguments for configuring the subprocess behavior.
-  struct Args {
-    Args(std::initializer_list<std::string> _cmd = {}) : exec_cmd(_cmd) {}
-    Args(Args&&) noexcept;
-    Args& operator=(Args&&);
-    // If non-empty this will cause an exec() when Start()/Call() are called.
-    std::vector<std::string> exec_cmd;
-
-#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-    // If non-empty, it changes the argv[0] argument passed to exec. If
-    // unset, argv[0] == exec_cmd[0]. This is to handle cases like:
-    // exec_cmd = {"/proc/self/exec"}, argv0: "my_custom_test_override".
-    std::string posix_argv0_override_for_testing;
-
-    // If non-empty this will be invoked on the fork()-ed child process, after
-    // stdin/out/err has been redirected and all other file descriptor are
-    // closed. It is valid to specify both |exec_cmd| AND
-    // |posix_entrypoint_for_testing|. In this case the latter will be invoked
-    // just before the exec() call, but after having closed all fds % stdin/o/e.
-    // This is for synchronization barriers in tests.
-    std::function<void()> posix_entrypoint_for_testing;
-
-    // When set, will will move the process to the given process group. If set
-    // and zero, it will create a new process group. Effectively this calls
-    // setpgid(0 /*self_pid*/, posix_proc_group_id).
-    // This can be used to avoid that subprocesses receive CTRL-C from the
-    // terminal, while still living in the same session.
-    base::Optional<pid_t> posix_proc_group_id{};
-#endif
-
-    // If non-empty, replaces the environment passed to exec().
-    std::vector<std::string> env;
-
-    // The file descriptors in this list will not be closed.
-    std::vector<int> preserve_fds;
-
-    // The data to push in the child process stdin, if input_mode ==
-    // InputMode::kBuffer.
-    std::string input;
-
-    InputMode stdin_mode = InputMode::kBuffer;
-    OutputMode stdout_mode = OutputMode::kInherit;
-    OutputMode stderr_mode = OutputMode::kInherit;
-
-    base::ScopedPlatformHandle out_fd;
-
-    // Returns " ".join(exec_cmd), quoting arguments.
-    std::string GetCmdString() const;
-  };
-
-  struct ResourceUsage {
-    uint32_t cpu_utime_ms = 0;
-    uint32_t cpu_stime_ms = 0;
-    uint32_t max_rss_kb = 0;
-    uint32_t min_page_faults = 0;
-    uint32_t maj_page_faults = 0;
-    uint32_t vol_ctx_switch = 0;
-    uint32_t invol_ctx_switch = 0;
-
-    uint32_t cpu_time_ms() const { return cpu_utime_ms + cpu_stime_ms; }
-  };
-
-  explicit Subprocess(std::initializer_list<std::string> exec_cmd = {});
-  Subprocess(Subprocess&&) noexcept;
-  Subprocess& operator=(Subprocess&&);
-  ~Subprocess();  // It will KillAndWaitForTermination() if still alive.
-
-  // Starts the subprocess but doesn't wait for its termination. The caller
-  // is expected to either call Wait() or Poll() after this call.
-  void Start();
-
-  // Wait for process termination. Can be called more than once.
-  // Args:
-  //   |timeout_ms| = 0: wait indefinitely.
-  //   |timeout_ms| > 0: wait for at most |timeout_ms|.
-  // Returns:
-  //  True: The process terminated. See status() and returncode().
-  //  False: Timeout reached, the process is still running. In this case the
-  //         process will be left in the kRunning state.
-  bool Wait(int timeout_ms = 0);
-
-  // Equivalent of Start() + Wait();
-  // Returns true if the process exited cleanly with return code 0. False in
-  // any othe case.
-  bool Call(int timeout_ms = 0);
-
-  Status Poll();
-
-  // Sends a signal (SIGKILL if not specified) and wait for process termination.
-  void KillAndWaitForTermination(int sig_num = 0);
-
-  PlatformProcessId pid() const { return s_->pid; }
-
-  // The accessors below are updated only after a call to Poll(), Wait() or
-  // KillAndWaitForTermination().
-  // In most cases you want to call Poll() rather than these accessors.
-
-  Status status() const { return s_->status; }
-  int returncode() const { return s_->returncode; }
-  bool timed_out() const { return s_->timed_out; }
-
-  // This contains both stdout and stderr (if the corresponding _mode ==
-  // OutputMode::kBuffer). It's non-const so the caller can std::move() it.
-  std::string& output() { return s_->output; }
-  const std::string& output() const { return s_->output; }
-
-  const ResourceUsage& posix_rusage() const { return *s_->rusage; }
-
-  Args args;
-
- private:
-  // The signal/exit code used when killing the process in case of a timeout.
-  static const int kTimeoutSignal;
-
-  Subprocess(const Subprocess&) = delete;
-  Subprocess& operator=(const Subprocess&) = delete;
-
-  // This is to deal robustly with the move operators, without having to
-  // manually maintain member-wise move instructions.
-  struct MovableState {
-    base::Pipe stdin_pipe;
-    base::Pipe stdouterr_pipe;
-    PlatformProcessId pid;
-    Status status = kNotStarted;
-    int returncode = -1;
-    std::string output;  // Stdin+stderr. Only when OutputMode::kBuffer.
-    std::unique_ptr<ResourceUsage> rusage{new ResourceUsage()};
-    bool timed_out = false;
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-    std::thread stdouterr_thread;
-    std::thread stdin_thread;
-    ScopedPlatformHandle win_proc_handle;
-    ScopedPlatformHandle win_thread_handle;
-
-    base::EventFd stdouterr_done_event;
-    std::mutex mutex;  // Protects locked_outerr_buf and the two pipes.
-    std::string locked_outerr_buf;
-#else
-    base::Pipe exit_status_pipe;
-    size_t input_written = 0;
-    std::thread waitpid_thread;
-#endif
+  class Timer {
+   public:
+    // Define an empty dtor to avoid "unused variable" errors on the call site.
+    Timer() {}
+    Timer(const Timer&) {}
+    ~Timer() {}
   };
-
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-  static void StdinThread(MovableState*, std::string input);
-  static void StdoutErrThread(MovableState*);
-#else
-  void TryPushStdin();
-  void TryReadStdoutAndErr();
-  void TryReadExitStatus();
-  void KillAtMostOnce();
-  bool PollInternal(int poll_timeout_ms);
-#endif
-
-  std::unique_ptr<MovableState> s_;
+  static Watchdog* GetInstance() {
+    static Watchdog* watchdog = new Watchdog();
+    return watchdog;
+  }
+  Timer CreateFatalTimer(uint32_t /*ms*/, WatchdogCrashReason) {
+    return Timer();
+  }
+  void Start() {}
+  void SetMemoryLimit(uint64_t /*bytes*/, uint32_t /*window_ms*/) {}
+  void SetCpuLimit(uint32_t /*percentage*/, uint32_t /*window_ms*/) {}
 };
 
 }  // namespace base
 }  // namespace perfetto
 
-#endif  // INCLUDE_PERFETTO_EXT_BASE_SUBPROCESS_H_
+#endif  // INCLUDE_PERFETTO_EXT_BASE_WATCHDOG_NOOP_H_
 /*
- * Copyright (C) 2020 The Android Open Source Project
+ * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -8913,73 +10180,71 @@ class Subprocess {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/subprocess.h"
+#ifndef INCLUDE_PERFETTO_EXT_BASE_WATCHDOG_H_
+#define INCLUDE_PERFETTO_EXT_BASE_WATCHDOG_H_
 
-#include <tuple>
+#include <functional>
 
-// This file contains only the common bits (ctors / dtors / move operators).
-// The rest lives in subprocess_posix.cc and subprocess_windows.cc.
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+
+// The POSIX watchdog is only supported on Linux and Android in non-embedder
+// builds.
+#if PERFETTO_BUILDFLAG(PERFETTO_WATCHDOG)
+// gen_amalgamated expanded: #include "perfetto/ext/base/watchdog_posix.h"
+#else
+// gen_amalgamated expanded: #include "perfetto/ext/base/watchdog_noop.h"
+#endif
 
 namespace perfetto {
 namespace base {
 
-Subprocess::Args::Args(Args&&) noexcept = default;
-Subprocess::Args& Subprocess::Args::operator=(Args&&) = default;
-
-Subprocess::Subprocess(std::initializer_list<std::string> a)
-    : args(a), s_(new MovableState()) {}
-
-Subprocess::Subprocess(Subprocess&& other) noexcept {
-  static_assert(sizeof(Subprocess) ==
-                    sizeof(std::tuple<std::unique_ptr<MovableState>, Args>),
-                "base::Subprocess' move ctor needs updating");
-  s_ = std::move(other.s_);
-  args = std::move(other.args);
-
-  // Reset the state of the moved-from object.
-  other.s_.reset(new MovableState());
-  other.~Subprocess();
-  new (&other) Subprocess();
-}
+// Used only to add more details to crash reporting.
+enum class WatchdogCrashReason {
+  kUnspecified = 0,
+  kCpuGuardrail = 1,
+  kMemGuardrail = 2,
+  kTaskRunnerHung = 3,
+  kTraceDidntStop = 4,
+};
 
-Subprocess& Subprocess::operator=(Subprocess&& other) {
-  this->~Subprocess();
-  new (this) Subprocess(std::move(other));
-  return *this;
-}
+// Make the limits more relaxed on desktop, where multi-GB traces are likely.
+// Multi-GB traces can take bursts of cpu time to write into disk at the end of
+// the trace.
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+constexpr uint32_t kWatchdogDefaultCpuLimit = 75;
+constexpr uint32_t kWatchdogDefaultCpuWindow = 5 * 60 * 1000;  // 5 minutes.
+#else
+constexpr uint32_t kWatchdogDefaultCpuLimit = 90;
+constexpr uint32_t kWatchdogDefaultCpuWindow = 10 * 60 * 1000;  // 10 minutes.
+#endif
 
-Subprocess::~Subprocess() {
-  if (s_->status == kRunning)
-    KillAndWaitForTermination();
-}
+// The default memory margin we give to our processes. This is used as as a
+// constant to put on top of the trace buffers.
+constexpr uint64_t kWatchdogDefaultMemorySlack = 32 * 1024 * 1024;  // 32 MiB.
+constexpr uint32_t kWatchdogDefaultMemoryWindow = 30 * 1000;  // 30 seconds.
 
-bool Subprocess::Call(int timeout_ms) {
-  PERFETTO_CHECK(s_->status == kNotStarted);
-  Start();
+inline void RunTaskWithWatchdogGuard(const std::function<void()>& task) {
+  // The longest duration allowed for a single task within the TaskRunner.
+  // Exceeding this limit will trigger program termination.
+  constexpr int64_t kWatchdogMillis = 180000;  // 180s
 
-  if (!Wait(timeout_ms)) {
-    s_->timed_out = true;
-    KillAndWaitForTermination(kTimeoutSignal);
-  }
-  PERFETTO_DCHECK(s_->status != kRunning);
-  return s_->status == kTerminated && s_->returncode == 0;
-}
+  Watchdog::Timer handle = base::Watchdog::GetInstance()->CreateFatalTimer(
+      kWatchdogMillis, WatchdogCrashReason::kTaskRunnerHung);
+  task();
 
-std::string Subprocess::Args::GetCmdString() const {
-  std::string str;
-  for (size_t i = 0; i < exec_cmd.size(); i++) {
-    str += i > 0 ? " \"" : "";
-    str += exec_cmd[i];
-    str += i > 0 ? "\"" : "";
-  }
-  return str;
+  // Suppress unused variable warnings in the client library amalgamated build.
+  (void)kWatchdogDefaultCpuLimit;
+  (void)kWatchdogDefaultCpuWindow;
+  (void)kWatchdogDefaultMemorySlack;
+  (void)kWatchdogDefaultMemoryWindow;
 }
 
 }  // namespace base
 }  // namespace perfetto
-// gen_amalgamated begin source: src/base/subprocess_posix.cc
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_WATCHDOG_H_
 /*
- * Copyright (C) 2020 The Android Open Source Project
+ * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -8994,446 +10259,432 @@ std::string Subprocess::Args::GetCmdString() const {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/subprocess.h"
-
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/platform.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/watchdog.h"
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+#if PERFETTO_BUILDFLAG(PERFETTO_WATCHDOG)
 
 #include <fcntl.h>
 #include <poll.h>
 #include <signal.h>
-#include <stdio.h>
-#include <sys/resource.h>
-#include <sys/types.h>
-#include <sys/wait.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <sys/syscall.h>
+#include <sys/timerfd.h>
 #include <unistd.h>
 
 #include <algorithm>
+#include <cinttypes>
+#include <fstream>
 #include <thread>
-#include <tuple>
-
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-#include <sys/prctl.h>
-#endif
 
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/base/thread_utils.h"
 // gen_amalgamated expanded: #include "perfetto/base/time.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/crash_keys.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/file_utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
 
-// In MacOS this is not defined in any header.
-extern "C" char** environ;
-
 namespace perfetto {
 namespace base {
 
 namespace {
 
-struct ChildProcessArgs {
-  Subprocess::Args* create_args;
-  const char* exec_cmd = nullptr;
-  std::vector<char*> argv;
-  std::vector<char*> env;
-  int stdin_pipe_rd = -1;
-  int stdouterr_pipe_wr = -1;
-};
+constexpr uint32_t kDefaultPollingInterval = 30 * 1000;
 
-// Don't add any dynamic allocation in this function. This will be invoked
-// under a fork(), potentially in a state where the allocator lock is held.
-void __attribute__((noreturn)) ChildProcess(ChildProcessArgs* args) {
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-  // In no case we want a child process to outlive its parent process. This is
-  // relevant for tests, so that a test failure/crash doesn't leave child
-  // processes around that get reparented to init.
-  prctl(PR_SET_PDEATHSIG, SIGKILL);
-#endif
+base::CrashKey g_crash_key_reason("wdog_reason");
 
-  auto die = [args](const char* err) __attribute__((noreturn)) {
-    base::ignore_result(write(args->stdouterr_pipe_wr, err, strlen(err)));
-    base::ignore_result(write(args->stdouterr_pipe_wr, "\n", 1));
-    // From https://www.gnu.org/software/libc/manual/html_node/Exit-Status.html
-    // "In particular, the value 128 is used to indicate failure to execute
-    // another program in a subprocess. This convention is not universally
-    // obeyed, but it is a good idea to follow it in your programs."
-    _exit(128);
-  };
+bool IsMultipleOf(uint32_t number, uint32_t divisor) {
+  return number >= divisor && number % divisor == 0;
+}
 
-  if (args->create_args->posix_proc_group_id.has_value()) {
-    if (setpgid(0 /*self*/, args->create_args->posix_proc_group_id.value())) {
-      die("setpgid() failed");
-    }
+double MeanForArray(const uint64_t array[], size_t size) {
+  uint64_t total = 0;
+  for (size_t i = 0; i < size; i++) {
+    total += array[i];
   }
+  return static_cast<double>(total / size);
+}
 
-  auto set_fd_close_on_exec = [&die](int fd, bool close_on_exec) {
-    int flags = fcntl(fd, F_GETFD, 0);
-    if (flags < 0)
-      die("fcntl(F_GETFD) failed");
-    flags = close_on_exec ? (flags | FD_CLOEXEC) : (flags & ~FD_CLOEXEC);
-    if (fcntl(fd, F_SETFD, flags) < 0)
-      die("fcntl(F_SETFD) failed");
-  };
-
-  if (getppid() == 1)
-    die("terminating because parent process died");
-
-  switch (args->create_args->stdin_mode) {
-    case Subprocess::InputMode::kBuffer:
-      if (dup2(args->stdin_pipe_rd, STDIN_FILENO) == -1)
-        die("Failed to dup2(STDIN)");
-      close(args->stdin_pipe_rd);
-      break;
-    case Subprocess::InputMode::kDevNull:
-      if (dup2(open("/dev/null", O_RDONLY), STDIN_FILENO) == -1)
-        die("Failed to dup2(STDOUT)");
-      break;
-  }
+}  //  namespace
 
-  switch (args->create_args->stdout_mode) {
-    case Subprocess::OutputMode::kInherit:
-      break;
-    case Subprocess::OutputMode::kDevNull: {
-      if (dup2(open("/dev/null", O_RDWR), STDOUT_FILENO) == -1)
-        die("Failed to dup2(STDOUT)");
-      break;
+bool ReadProcStat(int fd, ProcStat* out) {
+  char c[512];
+  size_t c_pos = 0;
+  while (c_pos < sizeof(c) - 1) {
+    ssize_t rd = PERFETTO_EINTR(read(fd, c + c_pos, sizeof(c) - c_pos));
+    if (rd < 0) {
+      PERFETTO_ELOG("Failed to read stat file to enforce resource limits.");
+      return false;
     }
-    case Subprocess::OutputMode::kBuffer:
-      if (dup2(args->stdouterr_pipe_wr, STDOUT_FILENO) == -1)
-        die("Failed to dup2(STDOUT)");
-      break;
-    case Subprocess::OutputMode::kFd:
-      if (dup2(*args->create_args->out_fd, STDOUT_FILENO) == -1)
-        die("Failed to dup2(STDOUT)");
+    if (rd == 0)
       break;
+    c_pos += static_cast<size_t>(rd);
   }
+  PERFETTO_CHECK(c_pos < sizeof(c));
+  c[c_pos] = '\0';
 
-  switch (args->create_args->stderr_mode) {
-    case Subprocess::OutputMode::kInherit:
-      break;
-    case Subprocess::OutputMode::kDevNull: {
-      if (dup2(open("/dev/null", O_RDWR), STDERR_FILENO) == -1)
-        die("Failed to dup2(STDERR)");
-      break;
-    }
-    case Subprocess::OutputMode::kBuffer:
-      if (dup2(args->stdouterr_pipe_wr, STDERR_FILENO) == -1)
-        die("Failed to dup2(STDERR)");
-      break;
-    case Subprocess::OutputMode::kFd:
-      if (dup2(*args->create_args->out_fd, STDERR_FILENO) == -1)
-        die("Failed to dup2(STDERR)");
-      break;
+  if (sscanf(c,
+             "%*d %*s %*c %*d %*d %*d %*d %*d %*u %*u %*u %*u %*u %lu "
+             "%lu %*d %*d %*d %*d %*d %*d %*u %*u %ld",
+             &out->utime, &out->stime, &out->rss_pages) != 3) {
+    PERFETTO_ELOG("Invalid stat format: %s", c);
+    return false;
   }
+  return true;
+}
 
-  // Close all FDs % stdin/out/err and the ones that the client explicitly
-  // asked to retain. The reason for this is twofold:
-  // 1. For exec-only (i.e. entrypoint == empty) cases: it avoids leaking FDs
-  //    that didn't get marked as O_CLOEXEC by accident.
-  // 2. In fork() mode (entrypoint not empty) avoids retaining a dup of eventfds
-  //    that would prevent the parent process to receive EOFs (tests usually use
-  //    pipes as a synchronization mechanism between subprocesses).
-  const auto& preserve_fds = args->create_args->preserve_fds;
-  for (int i = 0; i < 512; i++) {
-    if (i != STDIN_FILENO && i != STDERR_FILENO && i != STDOUT_FILENO &&
-        i != args->stdouterr_pipe_wr &&
-        !std::count(preserve_fds.begin(), preserve_fds.end(), i)) {
-      close(i);
-    }
+Watchdog::Watchdog(uint32_t polling_interval_ms)
+    : polling_interval_ms_(polling_interval_ms) {}
+
+Watchdog::~Watchdog() {
+  if (!thread_.joinable()) {
+    PERFETTO_DCHECK(!enabled_);
+    return;
   }
+  PERFETTO_DCHECK(enabled_);
+  enabled_ = false;
 
-  // Clears O_CLOEXEC from stdin/out/err and the |preserve_fds| list. These are
-  // the only FDs that we want to be preserved after the exec().
-  set_fd_close_on_exec(STDIN_FILENO, false);
-  set_fd_close_on_exec(STDOUT_FILENO, false);
-  set_fd_close_on_exec(STDERR_FILENO, false);
+  // Rearm the timer to 1ns from now. This will cause the watchdog thread to
+  // wakeup from the poll() and see |enabled_| == false.
+  // This code path is used only in tests. In production code the watchdog is
+  // a singleton and is never destroyed.
+  struct itimerspec ts{};
+  ts.it_value.tv_sec = 0;
+  ts.it_value.tv_nsec = 1;
+  timerfd_settime(*timer_fd_, /*flags=*/0, &ts, nullptr);
 
-  for (auto fd : preserve_fds)
-    set_fd_close_on_exec(fd, false);
+  thread_.join();
+}
 
-  // If the caller specified a std::function entrypoint, run that first.
-  if (args->create_args->posix_entrypoint_for_testing)
-    args->create_args->posix_entrypoint_for_testing();
+Watchdog* Watchdog::GetInstance() {
+  static Watchdog* watchdog = new Watchdog(kDefaultPollingInterval);
+  return watchdog;
+}
 
-  // If the caller specified only an entrypoint, without any args, exit now.
-  // Otherwise proceed with the exec() below.
-  if (!args->exec_cmd)
-    _exit(0);
+// Can be called from any thread.
+Watchdog::Timer Watchdog::CreateFatalTimer(uint32_t ms,
+                                           WatchdogCrashReason crash_reason) {
+  if (!enabled_.load(std::memory_order_relaxed))
+    return Watchdog::Timer(this, 0, crash_reason);
 
-  // If |args[0]| is a path use execv() (which takes a path), othewise use
-  // exevp(), which uses the shell and follows PATH.
-  if (strchr(args->exec_cmd, '/')) {
-    char** env = args->env.empty() ? environ : args->env.data();
-    execve(args->exec_cmd, args->argv.data(), env);
-  } else {
-    // There is no execvpe() on Mac.
-    if (!args->env.empty())
-      die("A full path is required for |exec_cmd| when setting |env|");
-    execvp(args->exec_cmd, args->argv.data());
-  }
+  return Watchdog::Timer(this, ms, crash_reason);
+}
 
-  // Reached only if execv fails.
-  die("execve() failed");
+// Can be called from any thread.
+void Watchdog::AddFatalTimer(TimerData timer) {
+  std::lock_guard<std::mutex> guard(mutex_);
+  timers_.emplace_back(std::move(timer));
+  RearmTimerFd_Locked();
 }
 
-}  // namespace
+// Can be called from any thread.
+void Watchdog::RemoveFatalTimer(TimerData timer) {
+  std::lock_guard<std::mutex> guard(mutex_);
+  for (auto it = timers_.begin(); it != timers_.end(); it++) {
+    if (*it == timer) {
+      timers_.erase(it);
+      break;  // Remove only one. Doesn't matter which one.
+    }
+  }
+  RearmTimerFd_Locked();
+}
 
-// static
-const int Subprocess::kTimeoutSignal = SIGKILL;
+void Watchdog::RearmTimerFd_Locked() {
+  if (!enabled_)
+    return;
+  auto it = std::min_element(timers_.begin(), timers_.end());
 
-void Subprocess::Start() {
-  ChildProcessArgs proc_args;
-  proc_args.create_args = &args;
+  // We use one timerfd to handle all the outstanding |timers_|. Keep it armed
+  // to the task expiring soonest.
+  struct itimerspec ts{};
+  if (it != timers_.end()) {
+    ts.it_value = ToPosixTimespec(it->deadline);
+  }
+  // If |timers_| is empty (it == end()) |ts.it_value| will remain
+  // zero-initialized and that will disarm the timer in the call below.
+  int res = timerfd_settime(*timer_fd_, TFD_TIMER_ABSTIME, &ts, nullptr);
+  PERFETTO_DCHECK(res == 0);
+}
 
-  // Setup argv.
-  if (!args.exec_cmd.empty()) {
-    proc_args.exec_cmd = args.exec_cmd[0].c_str();
-    for (const std::string& arg : args.exec_cmd)
-      proc_args.argv.push_back(const_cast<char*>(arg.c_str()));
-    proc_args.argv.push_back(nullptr);
+void Watchdog::Start() {
+  std::lock_guard<std::mutex> guard(mutex_);
+  if (thread_.joinable()) {
+    PERFETTO_DCHECK(enabled_);
+  } else {
+    PERFETTO_DCHECK(!enabled_);
 
-    if (!args.posix_argv0_override_for_testing.empty()) {
-      proc_args.argv[0] =
-          const_cast<char*>(args.posix_argv0_override_for_testing.c_str());
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+    // Kick the thread to start running but only on Android or Linux.
+    timer_fd_.reset(
+        timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK));
+    if (!timer_fd_) {
+      PERFETTO_PLOG(
+          "timerfd_create failed, the Perfetto watchdog is not available");
+      return;
     }
+    enabled_ = true;
+    RearmTimerFd_Locked();  // Deal with timers created before Start().
+    thread_ = std::thread(&Watchdog::ThreadMain, this);
+#endif
   }
+}
 
-  // Setup env.
-  if (!args.env.empty()) {
-    for (const std::string& str : args.env)
-      proc_args.env.push_back(const_cast<char*>(str.c_str()));
-    proc_args.env.push_back(nullptr);
-  }
+void Watchdog::SetMemoryLimit(uint64_t bytes, uint32_t window_ms) {
+  // Update the fields under the lock.
+  std::lock_guard<std::mutex> guard(mutex_);
 
-  // Setup the pipes for stdin/err redirection.
-  if (args.stdin_mode == InputMode::kBuffer) {
-    s_->stdin_pipe = base::Pipe::Create(base::Pipe::kWrNonBlock);
-    proc_args.stdin_pipe_rd = *s_->stdin_pipe.rd;
-  }
-  s_->stdouterr_pipe = base::Pipe::Create(base::Pipe::kRdNonBlock);
-  proc_args.stdouterr_pipe_wr = *s_->stdouterr_pipe.wr;
+  PERFETTO_CHECK(IsMultipleOf(window_ms, polling_interval_ms_) || bytes == 0);
 
-  // Spawn the child process that will exec().
-  s_->pid = fork();
-  PERFETTO_CHECK(s_->pid >= 0);
-  if (s_->pid == 0) {
-    // Close the parent-ends of the pipes.
-    s_->stdin_pipe.wr.reset();
-    s_->stdouterr_pipe.rd.reset();
-    ChildProcess(&proc_args);
-    // ChildProcess() doesn't return, not even in case of failures.
-    PERFETTO_FATAL("not reached");
+  size_t size = bytes == 0 ? 0 : window_ms / polling_interval_ms_ + 1;
+  memory_window_bytes_.Reset(size);
+  memory_limit_bytes_ = bytes;
+}
+
+void Watchdog::SetCpuLimit(uint32_t percentage, uint32_t window_ms) {
+  std::lock_guard<std::mutex> guard(mutex_);
+
+  PERFETTO_CHECK(percentage <= 100);
+  PERFETTO_CHECK(IsMultipleOf(window_ms, polling_interval_ms_) ||
+                 percentage == 0);
+
+  size_t size = percentage == 0 ? 0 : window_ms / polling_interval_ms_ + 1;
+  cpu_window_time_ticks_.Reset(size);
+  cpu_limit_percentage_ = percentage;
+}
+
+void Watchdog::ThreadMain() {
+  // Register crash keys explicitly to avoid running out of slots at crash time.
+  g_crash_key_reason.Register();
+
+  base::ScopedFile stat_fd(base::OpenFile("/proc/self/stat", O_RDONLY));
+  if (!stat_fd) {
+    PERFETTO_ELOG("Failed to open stat file to enforce resource limits.");
+    return;
   }
 
-  s_->status = kRunning;
+  PERFETTO_DCHECK(timer_fd_);
 
-  // Close the child-end of the pipes.
-  // Deliberately NOT closing the s_->stdin_pipe.rd. This is to avoid crashing
-  // with a SIGPIPE if the process exits without consuming its stdin, while
-  // the parent tries to write() on the other end of the stdin pipe.
-  s_->stdouterr_pipe.wr.reset();
-  proc_args.create_args->out_fd.reset();
+  constexpr uint8_t kFdCount = 1;
+  struct pollfd fds[kFdCount]{};
+  fds[0].fd = *timer_fd_;
+  fds[0].events = POLLIN;
 
-  // Spawn a thread that is blocked on waitpid() and writes the termination
-  // status onto a pipe. The problem here is that waipid() doesn't have a
-  // timeout option and can't be passed to poll(). The alternative would be
-  // using a SIGCHLD handler, but anecdotally signal handlers introduce more
-  // problems than what they solve.
-  s_->exit_status_pipe = base::Pipe::Create(base::Pipe::kRdNonBlock);
+  for (;;) {
+    // We use the poll() timeout to drive the periodic ticks for the cpu/memory
+    // checks. The only other case when the poll() unblocks is when we crash
+    // (or have to quit via enabled_ == false, but that happens only in tests).
+    platform::BeforeMaybeBlockingSyscall();
+    auto ret = poll(fds, kFdCount, static_cast<int>(polling_interval_ms_));
+    platform::AfterMaybeBlockingSyscall();
+    if (!enabled_)
+      return;
+    if (ret < 0) {
+      if (errno == ENOMEM || errno == EINTR) {
+        // Should happen extremely rarely.
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+        continue;
+      }
+      PERFETTO_FATAL("watchdog poll() failed");
+    }
 
-  // Both ends of the pipe are closed after the thread.join().
-  int pid = s_->pid;
-  int exit_status_pipe_wr = s_->exit_status_pipe.wr.release();
-  auto* rusage = s_->rusage.get();
-  s_->waitpid_thread = std::thread([pid, exit_status_pipe_wr, rusage] {
-    int pid_stat = -1;
-    struct rusage usg {};
-    int wait_res = PERFETTO_EINTR(wait4(pid, &pid_stat, 0, &usg));
-    PERFETTO_CHECK(wait_res == pid);
+    // If we get here either:
+    // 1. poll() timed out, in which case we should process cpu/mem guardrails.
+    // 2. A timer expired, in which case we shall crash.
 
-    auto tv_to_ms = [](const struct timeval& tv) {
-      return static_cast<uint32_t>(tv.tv_sec * 1000 + tv.tv_usec / 1000);
-    };
-    rusage->cpu_utime_ms = tv_to_ms(usg.ru_utime);
-    rusage->cpu_stime_ms = tv_to_ms(usg.ru_stime);
-    rusage->max_rss_kb = static_cast<uint32_t>(usg.ru_maxrss) / 1000;
-    rusage->min_page_faults = static_cast<uint32_t>(usg.ru_minflt);
-    rusage->maj_page_faults = static_cast<uint32_t>(usg.ru_majflt);
-    rusage->vol_ctx_switch = static_cast<uint32_t>(usg.ru_nvcsw);
-    rusage->invol_ctx_switch = static_cast<uint32_t>(usg.ru_nivcsw);
+    uint64_t expired = 0;  // Must be exactly 8 bytes.
+    auto res = PERFETTO_EINTR(read(*timer_fd_, &expired, sizeof(expired)));
+    PERFETTO_DCHECK((res < 0 && (errno == EAGAIN)) ||
+                    (res == sizeof(expired) && expired > 0));
+    const auto now = GetWallTimeMs();
 
-    base::ignore_result(PERFETTO_EINTR(
-        write(exit_status_pipe_wr, &pid_stat, sizeof(pid_stat))));
-    PERFETTO_CHECK(close(exit_status_pipe_wr) == 0 || errno == EINTR);
-  });
-}
+    // Check if any of the timers expired.
+    int tid_to_kill = 0;
+    WatchdogCrashReason crash_reason{};
+    {
+      std::lock_guard<std::mutex> guard(mutex_);
+      for (const auto& timer : timers_) {
+        if (now >= timer.deadline) {
+          tid_to_kill = timer.thread_id;
+          crash_reason = timer.crash_reason;
+          break;
+        }
+      }
+    }
 
-Subprocess::Status Subprocess::Poll() {
-  if (s_->status != kRunning)
-    return s_->status;  // Nothing to poll.
-  while (PollInternal(0 /* don't block*/)) {
+    if (tid_to_kill)
+      SerializeLogsAndKillThread(tid_to_kill, crash_reason);
+
+    // Check CPU and memory guardrails (if enabled).
+    lseek(stat_fd.get(), 0, SEEK_SET);
+    ProcStat stat;
+    if (!ReadProcStat(stat_fd.get(), &stat))
+      continue;
+    uint64_t cpu_time = stat.utime + stat.stime;
+    uint64_t rss_bytes =
+        static_cast<uint64_t>(stat.rss_pages) * base::GetSysPageSize();
+
+    bool threshold_exceeded = false;
+    {
+      std::lock_guard<std::mutex> guard(mutex_);
+      if (CheckMemory_Locked(rss_bytes) && !IsSyncMemoryTaggingEnabled()) {
+        threshold_exceeded = true;
+        crash_reason = WatchdogCrashReason::kMemGuardrail;
+      } else if (CheckCpu_Locked(cpu_time)) {
+        threshold_exceeded = true;
+        crash_reason = WatchdogCrashReason::kCpuGuardrail;
+      }
+    }
+
+    if (threshold_exceeded)
+      SerializeLogsAndKillThread(getpid(), crash_reason);
   }
-  return s_->status;
 }
 
-// |timeout_ms| semantic:
-//   -1: Block indefinitely.
-//    0: Don't block, return immediately.
-//   >0: Block for at most X ms.
-// Returns:
-//  True: Read at least one fd (so there might be more queued).
-//  False: if all fds reached quiescent (no data to read/write).
-bool Subprocess::PollInternal(int poll_timeout_ms) {
-  struct pollfd fds[3]{};
-  size_t num_fds = 0;
-  if (s_->exit_status_pipe.rd) {
-    fds[num_fds].fd = *s_->exit_status_pipe.rd;
-    fds[num_fds].events = POLLIN;
-    num_fds++;
-  }
-  if (s_->stdouterr_pipe.rd) {
-    fds[num_fds].fd = *s_->stdouterr_pipe.rd;
-    fds[num_fds].events = POLLIN;
-    num_fds++;
-  }
-  if (s_->stdin_pipe.wr) {
-    fds[num_fds].fd = *s_->stdin_pipe.wr;
-    fds[num_fds].events = POLLOUT;
-    num_fds++;
-  }
+void Watchdog::SerializeLogsAndKillThread(int tid,
+                                          WatchdogCrashReason crash_reason) {
+  g_crash_key_reason.Set(static_cast<int>(crash_reason));
 
-  if (num_fds == 0)
-    return false;
+  // We are about to die. Serialize the logs into the crash buffer so the
+  // debuggerd crash handler picks them up and attaches to the bugreport.
+  // In the case of a PERFETTO_CHECK/PERFETTO_FATAL this is done in logging.h.
+  // But in the watchdog case, we don't hit that codepath and must do ourselves.
+  MaybeSerializeLastLogsForCrashReporting();
 
-  auto nfds = static_cast<nfds_t>(num_fds);
-  int poll_res = PERFETTO_EINTR(poll(fds, nfds, poll_timeout_ms));
-  PERFETTO_CHECK(poll_res >= 0);
+  // Send a SIGABRT to the thread that armed the timer. This is to see the
+  // callstack of the thread that is stuck in a long task rather than the
+  // watchdog thread.
+  if (syscall(__NR_tgkill, getpid(), tid, SIGABRT) < 0) {
+    // At this point the process must die. If for any reason the tgkill doesn't
+    // work (e.g. the thread has disappeared), force a crash from here.
+    abort();
+  }
 
-  TryReadStdoutAndErr();
-  TryPushStdin();
-  TryReadExitStatus();
+  if (disable_kill_failsafe_for_testing_)
+    return;
 
-  return poll_res > 0;
+  // The tgkill() above will take some milliseconds to cause a crash, as it
+  // involves the kernel to queue the SIGABRT on the target thread (often the
+  // main thread, which is != watchdog thread) and do a scheduling round.
+  // If something goes wrong though (the target thread has signals masked or
+  // is stuck in an uninterruptible+wakekill syscall) force quit from this
+  // thread.
+  std::this_thread::sleep_for(std::chrono::seconds(10));
+  abort();
 }
 
-bool Subprocess::Wait(int timeout_ms) {
-  PERFETTO_CHECK(s_->status != kNotStarted);
+bool Watchdog::CheckMemory_Locked(uint64_t rss_bytes) {
+  if (memory_limit_bytes_ == 0)
+    return false;
 
-  // Break out of the loop only after both conditions are satisfied:
-  // - All stdout/stderr data has been read (if kBuffer).
-  // - The process exited.
-  // Note that the two events can happen arbitrary order. After the process
-  // exits, there might be still data in the pipe buffer, which we want to
-  // read fully.
-  //
-  // Instead, don't wait on the stdin to be fully written. The child process
-  // might exit prematurely (or crash). If that happens, we can end up in a
-  // state where the write(stdin_pipe_.wr) will never unblock.
+  // Add the current stat value to the ring buffer and check that the mean
+  // remains under our threshold.
+  if (memory_window_bytes_.Push(rss_bytes)) {
+    if (memory_window_bytes_.Mean() >
+        static_cast<double>(memory_limit_bytes_)) {
+      PERFETTO_ELOG(
+          "Memory watchdog trigger. Memory window of %f bytes is above the "
+          "%" PRIu64 " bytes limit.",
+          memory_window_bytes_.Mean(), memory_limit_bytes_);
+      return true;
+    }
+  }
+  return false;
+}
 
-  const int64_t t_start = base::GetWallTimeMs().count();
-  while (s_->exit_status_pipe.rd || s_->stdouterr_pipe.rd) {
-    int poll_timeout_ms = -1;  // Block until a FD is ready.
-    if (timeout_ms > 0) {
-      const int64_t now = GetWallTimeMs().count();
-      poll_timeout_ms = timeout_ms - static_cast<int>(now - t_start);
-      if (poll_timeout_ms <= 0)
-        return false;
+bool Watchdog::CheckCpu_Locked(uint64_t cpu_time) {
+  if (cpu_limit_percentage_ == 0)
+    return false;
+
+  // Add the cpu time to the ring buffer.
+  if (cpu_window_time_ticks_.Push(cpu_time)) {
+    // Compute the percentage over the whole window and check that it remains
+    // under the threshold.
+    uint64_t difference_ticks = cpu_window_time_ticks_.NewestWhenFull() -
+                                cpu_window_time_ticks_.OldestWhenFull();
+    double window_interval_ticks =
+        (static_cast<double>(WindowTimeForRingBuffer(cpu_window_time_ticks_)) /
+         1000.0) *
+        static_cast<double>(sysconf(_SC_CLK_TCK));
+    double percentage = static_cast<double>(difference_ticks) /
+                        static_cast<double>(window_interval_ticks) * 100;
+    if (percentage > cpu_limit_percentage_) {
+      PERFETTO_ELOG("CPU watchdog trigger. %f%% CPU use is above the %" PRIu32
+                    "%% CPU limit.",
+                    percentage, cpu_limit_percentage_);
+      return true;
     }
-    PollInternal(poll_timeout_ms);
-  }  // while(...)
-  return true;
+  }
+  return false;
 }
 
-void Subprocess::TryReadExitStatus() {
-  if (!s_->exit_status_pipe.rd)
-    return;
+uint32_t Watchdog::WindowTimeForRingBuffer(const WindowedInterval& window) {
+  return static_cast<uint32_t>(window.size() - 1) * polling_interval_ms_;
+}
 
-  int pid_stat = -1;
-  int64_t rsize = PERFETTO_EINTR(
-      read(*s_->exit_status_pipe.rd, &pid_stat, sizeof(pid_stat)));
-  if (rsize < 0 && errno == EAGAIN)
-    return;
+bool Watchdog::WindowedInterval::Push(uint64_t sample) {
+  // Add the sample to the current position in the ring buffer.
+  buffer_[position_] = sample;
 
-  if (rsize > 0) {
-    PERFETTO_CHECK(rsize == sizeof(pid_stat));
-  } else if (rsize < 0) {
-    PERFETTO_PLOG("Subprocess read(s_->exit_status_pipe) failed");
-  }
-  s_->waitpid_thread.join();
-  s_->exit_status_pipe.rd.reset();
+  // Update the position with next one circularily.
+  position_ = (position_ + 1) % size_;
 
-  s_->status = kTerminated;
-  if (WIFEXITED(pid_stat)) {
-    s_->returncode = WEXITSTATUS(pid_stat);
-  } else if (WIFSIGNALED(pid_stat)) {
-    s_->returncode = 128 + WTERMSIG(pid_stat);  // Follow bash convention.
-  } else {
-    PERFETTO_FATAL("waitpid() returned an unexpected value (0x%x)", pid_stat);
-  }
+  // Set the filled flag the first time we wrap.
+  filled_ = filled_ || position_ == 0;
+  return filled_;
 }
 
-// If the stidn pipe is still open, push input data and close it at the end.
-void Subprocess::TryPushStdin() {
-  if (!s_->stdin_pipe.wr)
-    return;
+double Watchdog::WindowedInterval::Mean() const {
+  return MeanForArray(buffer_.get(), size_);
+}
 
-  PERFETTO_DCHECK(args.input.empty() || s_->input_written < args.input.size());
-  if (!args.input.empty()) {
-    int64_t wsize =
-        PERFETTO_EINTR(write(*s_->stdin_pipe.wr, &args.input[s_->input_written],
-                             args.input.size() - s_->input_written));
-    if (wsize < 0 && errno == EAGAIN)
-      return;
+void Watchdog::WindowedInterval::Clear() {
+  position_ = 0;
+  buffer_.reset(new uint64_t[size_]());
+}
 
-    if (wsize >= 0) {
-      // Whether write() can return 0 is one of the greatest mysteries of UNIX.
-      // Just ignore it.
-      s_->input_written += static_cast<size_t>(wsize);
-    } else {
-      PERFETTO_PLOG("Subprocess write(stdin) failed");
-      s_->stdin_pipe.wr.reset();
-    }
-  }
-  PERFETTO_DCHECK(s_->input_written <= args.input.size());
-  if (s_->input_written == args.input.size())
-    s_->stdin_pipe.wr.reset();  // Close stdin.
+void Watchdog::WindowedInterval::Reset(size_t new_size) {
+  position_ = 0;
+  size_ = new_size;
+  buffer_.reset(new_size == 0 ? nullptr : new uint64_t[new_size]());
 }
 
-void Subprocess::TryReadStdoutAndErr() {
-  if (!s_->stdouterr_pipe.rd)
-    return;
-  char buf[4096];
-  int64_t rsize =
-      PERFETTO_EINTR(read(*s_->stdouterr_pipe.rd, buf, sizeof(buf)));
-  if (rsize < 0 && errno == EAGAIN)
-    return;
+Watchdog::Timer::Timer(Watchdog* watchdog,
+                       uint32_t ms,
+                       WatchdogCrashReason crash_reason)
+    : watchdog_(watchdog) {
+  if (!ms)
+    return;  // No-op timer created when the watchdog is disabled.
+  timer_data_.deadline = GetWallTimeMs() + std::chrono::milliseconds(ms);
+  timer_data_.thread_id = GetThreadId();
+  timer_data_.crash_reason = crash_reason;
+  PERFETTO_DCHECK(watchdog_);
+  watchdog_->AddFatalTimer(timer_data_);
+}
 
-  if (rsize > 0) {
-    s_->output.append(buf, static_cast<size_t>(rsize));
-  } else if (rsize == 0 /* EOF */) {
-    s_->stdouterr_pipe.rd.reset();
-  } else {
-    PERFETTO_PLOG("Subprocess read(stdout/err) failed");
-    s_->stdouterr_pipe.rd.reset();
-  }
+Watchdog::Timer::~Timer() {
+  if (timer_data_.deadline.count())
+    watchdog_->RemoveFatalTimer(timer_data_);
 }
 
-void Subprocess::KillAndWaitForTermination(int sig_num) {
-  kill(s_->pid, sig_num ? sig_num : SIGKILL);
-  Wait();
-  // TryReadExitStatus must have joined the thread.
-  PERFETTO_DCHECK(!s_->waitpid_thread.joinable());
+Watchdog::Timer::Timer(Timer&& other) noexcept {
+  watchdog_ = std::move(other.watchdog_);
+  other.watchdog_ = nullptr;
+  timer_data_ = std::move(other.timer_data_);
+  other.timer_data_ = TimerData();
 }
 
 }  // namespace base
 }  // namespace perfetto
 
-#endif  // PERFETTO_OS_LINUX || PERFETTO_OS_ANDROID || PERFETTO_OS_APPLE
-// gen_amalgamated begin source: src/base/subprocess_windows.cc
+#endif  // PERFETTO_BUILDFLAG(PERFETTO_WATCHDOG)
+// gen_amalgamated begin source: src/base/weak_runner.cc
+// gen_amalgamated begin header: include/perfetto/ext/base/weak_runner.h
 /*
- * Copyright (C) 2020 The Android Open Source Project
+ * Copyright (C) 2024 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -9448,331 +10699,54 @@ void Subprocess::KillAndWaitForTermination(int sig_num) {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/subprocess.h"
+#ifndef INCLUDE_PERFETTO_EXT_BASE_WEAK_RUNNER_H_
+#define INCLUDE_PERFETTO_EXT_BASE_WEAK_RUNNER_H_
 
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+#include <stdint.h>
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+#include <functional>
+#include <memory>
 
-#include <stdio.h>
+namespace perfetto::base {
 
-#include <algorithm>
-#include <mutex>
-#include <tuple>
+class TaskRunner;
 
-#include <Windows.h>
+// This is a wrapper around a `base::TaskRunner*`. It is intended to be used by
+// classes that want to post tasks on themselves. When the object is destroyed,
+// all posted tasks become noops.
+//
+// A class that embeds a WeakRunner can safely capture `this` on the posted
+// tasks.
+class WeakRunner {
+ public:
+  explicit WeakRunner(base::TaskRunner* task_runner);
+  ~WeakRunner();
+  base::TaskRunner* task_runner() const { return task_runner_; }
 
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/base/time.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/pipe.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
+  // Schedules `f` for immediate execution. `f` will not be executed is `*this`
+  // is destroyed.
+  //
+  // Can be called from any thread, but the caller needs to make sure that
+  // `*this` is alive while `PostTask` is running: this is not obvious when
+  // multiple threads are involved.
+  void PostTask(std::function<void()> f) const;
 
-namespace perfetto {
-namespace base {
+  // Schedules `f` for execution after |delay_ms|.
+  // Can be called from any thread, but the caller needs to make sure that
+  // `*this` is alive while `PostDelayedTask` is running: this is not obvious
+  // when multiple threads are involved.
+  void PostDelayedTask(std::function<void()> f, uint32_t delay_ms) const;
 
-// static
-const int Subprocess::kTimeoutSignal = static_cast<int>(STATUS_TIMEOUT);
+ private:
+  base::TaskRunner* const task_runner_;
+  std::shared_ptr<bool> destroyed_;
+};
 
-void Subprocess::Start() {
-  if (args.exec_cmd.empty()) {
-    PERFETTO_ELOG("Subprocess.exec_cmd cannot be empty on Windows");
-    return;
-  }
-
-  // Quote arguments but only when ambiguous. When quoting, CreateProcess()
-  // assumes that the command is an absolute path and does not search in the
-  // %PATH%. If non quoted, instead, CreateProcess() tries both. This is to
-  // allow Subprocess("cmd.exe", "/c", "shell command").
-  std::string cmd;
-  for (const auto& part : args.exec_cmd) {
-    if (part.find(" ") != std::string::npos) {
-      cmd += "\"" + part + "\" ";
-    } else {
-      cmd += part + " ";
-    }
-  }
-  // Remove trailing space.
-  if (!cmd.empty())
-    cmd.resize(cmd.size() - 1);
-
-  if (args.stdin_mode == InputMode::kBuffer) {
-    s_->stdin_pipe = Pipe::Create();
-    // Allow the child process to inherit the other end of the pipe.
-    PERFETTO_CHECK(
-        ::SetHandleInformation(*s_->stdin_pipe.rd, HANDLE_FLAG_INHERIT, 1));
-  }
-
-  if (args.stderr_mode == OutputMode::kBuffer ||
-      args.stdout_mode == OutputMode::kBuffer) {
-    s_->stdouterr_pipe = Pipe::Create();
-    PERFETTO_CHECK(
-        ::SetHandleInformation(*s_->stdouterr_pipe.wr, HANDLE_FLAG_INHERIT, 1));
-  }
-
-  ScopedPlatformHandle nul_handle;
-  if (args.stderr_mode == OutputMode::kDevNull ||
-      args.stdout_mode == OutputMode::kDevNull) {
-    nul_handle.reset(::CreateFileA(
-        "NUL", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
-        nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr));
-    PERFETTO_CHECK(::SetHandleInformation(*nul_handle, HANDLE_FLAG_INHERIT, 1));
-  }
-
-  PROCESS_INFORMATION proc_info{};
-  STARTUPINFOA start_info{};
-  start_info.cb = sizeof(STARTUPINFOA);
-
-  if (args.stderr_mode == OutputMode::kInherit) {
-    start_info.hStdError = ::GetStdHandle(STD_ERROR_HANDLE);
-  } else if (args.stderr_mode == OutputMode::kBuffer) {
-    start_info.hStdError = *s_->stdouterr_pipe.wr;
-  } else if (args.stderr_mode == OutputMode::kDevNull) {
-    start_info.hStdError = *nul_handle;
-  } else if (args.stderr_mode == OutputMode::kFd) {
-    PERFETTO_CHECK(
-        ::SetHandleInformation(*args.out_fd, HANDLE_FLAG_INHERIT, 1));
-    start_info.hStdError = *args.out_fd;
-  } else {
-    PERFETTO_CHECK(false);
-  }
-
-  if (args.stdout_mode == OutputMode::kInherit) {
-    start_info.hStdOutput = ::GetStdHandle(STD_OUTPUT_HANDLE);
-  } else if (args.stdout_mode == OutputMode::kBuffer) {
-    start_info.hStdOutput = *s_->stdouterr_pipe.wr;
-  } else if (args.stdout_mode == OutputMode::kDevNull) {
-    start_info.hStdOutput = *nul_handle;
-  } else if (args.stdout_mode == OutputMode::kFd) {
-    PERFETTO_CHECK(
-        ::SetHandleInformation(*args.out_fd, HANDLE_FLAG_INHERIT, 1));
-    start_info.hStdOutput = *args.out_fd;
-  } else {
-    PERFETTO_CHECK(false);
-  }
-
-  if (args.stdin_mode == InputMode::kBuffer) {
-    start_info.hStdInput = *s_->stdin_pipe.rd;
-  } else if (args.stdin_mode == InputMode::kDevNull) {
-    start_info.hStdInput = *nul_handle;
-  }
-
-  start_info.dwFlags |= STARTF_USESTDHANDLES;
-
-  // Create the child process.
-  bool success =
-      ::CreateProcessA(nullptr,      // App name. Needs to be null to use PATH.
-                       &cmd[0],      // Command line.
-                       nullptr,      // Process security attributes.
-                       nullptr,      // Primary thread security attributes.
-                       true,         // Handles are inherited.
-                       0,            // Flags.
-                       nullptr,      // Use parent's environment.
-                       nullptr,      // Use parent's current directory.
-                       &start_info,  // STARTUPINFO pointer.
-                       &proc_info);  // Receives PROCESS_INFORMATION.
-
-  // Close on our side the pipe ends that we passed to the child process.
-  s_->stdin_pipe.rd.reset();
-  s_->stdouterr_pipe.wr.reset();
-  args.out_fd.reset();
-
-  if (!success) {
-    s_->returncode = ERROR_FILE_NOT_FOUND;
-    s_->status = kTerminated;
-    s_->stdin_pipe.wr.reset();
-    s_->stdouterr_pipe.rd.reset();
-    PERFETTO_ELOG("CreateProcess failed: %lx, cmd: %s", GetLastError(),
-                  &cmd[0]);
-    return;
-  }
-
-  s_->pid = proc_info.dwProcessId;
-  s_->win_proc_handle = ScopedPlatformHandle(proc_info.hProcess);
-  s_->win_thread_handle = ScopedPlatformHandle(proc_info.hThread);
-  s_->status = kRunning;
-
-  MovableState* s = s_.get();
-  if (args.stdin_mode == InputMode::kBuffer) {
-    s_->stdin_thread = std::thread(&Subprocess::StdinThread, s, args.input);
-  }
-
-  if (args.stderr_mode == OutputMode::kBuffer ||
-      args.stdout_mode == OutputMode::kBuffer) {
-    PERFETTO_DCHECK(s_->stdouterr_pipe.rd);
-    s_->stdouterr_thread = std::thread(&Subprocess::StdoutErrThread, s);
-  }
-}
-
-// static
-void Subprocess::StdinThread(MovableState* s, std::string input) {
-  size_t input_written = 0;
-  while (input_written < input.size()) {
-    DWORD wsize = 0;
-    if (::WriteFile(*s->stdin_pipe.wr, input.data() + input_written,
-                    static_cast<DWORD>(input.size() - input_written), &wsize,
-                    nullptr)) {
-      input_written += wsize;
-    } else {
-      // ERROR_BROKEN_PIPE is WAI when the child just closes stdin and stops
-      // accepting input.
-      auto err = ::GetLastError();
-      if (err != ERROR_BROKEN_PIPE)
-        PERFETTO_PLOG("Subprocess WriteFile(stdin) failed %lx", err);
-      break;
-    }
-  }  // while(...)
-  std::unique_lock<std::mutex> lock(s->mutex);
-  s->stdin_pipe.wr.reset();
-}
-
-// static
-void Subprocess::StdoutErrThread(MovableState* s) {
-  char buf[4096];
-  for (;;) {
-    DWORD rsize = 0;
-    bool res =
-        ::ReadFile(*s->stdouterr_pipe.rd, buf, sizeof(buf), &rsize, nullptr);
-    if (!res) {
-      auto err = GetLastError();
-      if (err != ERROR_BROKEN_PIPE)
-        PERFETTO_PLOG("Subprocess ReadFile(stdouterr) failed %ld", err);
-    }
-
-    if (rsize > 0) {
-      std::unique_lock<std::mutex> lock(s->mutex);
-      s->locked_outerr_buf.append(buf, static_cast<size_t>(rsize));
-    } else {  // EOF or some error.
-      break;
-    }
-  }  // For(..)
-
-  // Close the stdouterr_pipe. The main loop looks at the pipe closure to
-  // determine whether the stdout/err thread has completed.
-  {
-    std::unique_lock<std::mutex> lock(s->mutex);
-    s->stdouterr_pipe.rd.reset();
-  }
-  s->stdouterr_done_event.Notify();
-}
-
-Subprocess::Status Subprocess::Poll() {
-  if (s_->status != kRunning)
-    return s_->status;  // Nothing to poll.
-  Wait(1 /*ms*/);
-  return s_->status;
-}
-
-bool Subprocess::Wait(int timeout_ms) {
-  PERFETTO_CHECK(s_->status != kNotStarted);
-  const bool wait_forever = timeout_ms == 0;
-  const int64_t wait_start_ms = base::GetWallTimeMs().count();
-
-  // Break out of the loop only after both conditions are satisfied:
-  // - All stdout/stderr data has been read (if OutputMode::kBuffer).
-  // - The process exited.
-  // Note that the two events can happen arbitrary order. After the process
-  // exits, there might be still data in the pipe buffer, which we want to
-  // read fully.
-  // Note also that stdout/err might be "complete" before starting, if neither
-  // is operating in OutputMode::kBuffer mode. In that case we just want to wait
-  // for the process termination.
-  //
-  // Instead, don't wait on the stdin to be fully written. The child process
-  // might exit prematurely (or crash). If that happens, we can end up in a
-  // state where the write(stdin_pipe_.wr) will never unblock.
-  bool stdouterr_complete = false;
-  for (;;) {
-    HANDLE wait_handles[2]{};
-    DWORD num_handles = 0;
-
-    // Check if the process exited.
-    bool process_exited = !s_->win_proc_handle;
-    if (!process_exited) {
-      DWORD exit_code = STILL_ACTIVE;
-      PERFETTO_CHECK(::GetExitCodeProcess(*s_->win_proc_handle, &exit_code));
-      if (exit_code != STILL_ACTIVE) {
-        s_->returncode = static_cast<int>(exit_code);
-        s_->status = kTerminated;
-        s_->win_proc_handle.reset();
-        s_->win_thread_handle.reset();
-        process_exited = true;
-      }
-    } else {
-      PERFETTO_DCHECK(s_->status != kRunning);
-    }
-    if (!process_exited) {
-      wait_handles[num_handles++] = *s_->win_proc_handle;
-    }
-
-    // Check if there is more output and if the stdout/err pipe has been closed.
-    {
-      std::unique_lock<std::mutex> lock(s_->mutex);
-      // Move the output from the internal buffer shared with the
-      // stdouterr_thread to the final buffer exposed to the client.
-      if (!s_->locked_outerr_buf.empty()) {
-        s_->output.append(std::move(s_->locked_outerr_buf));
-        s_->locked_outerr_buf.clear();
-      }
-      stdouterr_complete = !s_->stdouterr_pipe.rd;
-      if (!stdouterr_complete) {
-        wait_handles[num_handles++] = s_->stdouterr_done_event.fd();
-      }
-    }  // lock(s_->mutex)
-
-    if (num_handles == 0) {
-      PERFETTO_DCHECK(process_exited && stdouterr_complete);
-      break;
-    }
-
-    DWORD wait_ms;  // Note: DWORD is unsigned.
-    if (wait_forever) {
-      wait_ms = INFINITE;
-    } else {
-      const int64_t now = GetWallTimeMs().count();
-      const int64_t wait_left_ms = timeout_ms - (now - wait_start_ms);
-      if (wait_left_ms <= 0)
-        return false;  // Timed out
-      wait_ms = static_cast<DWORD>(wait_left_ms);
-    }
-
-    auto wait_res =
-        ::WaitForMultipleObjects(num_handles, wait_handles, false, wait_ms);
-    PERFETTO_CHECK(wait_res != WAIT_FAILED);
-  }
-
-  PERFETTO_DCHECK(!s_->win_proc_handle);
-  PERFETTO_DCHECK(!s_->win_thread_handle);
-
-  if (s_->stdin_thread.joinable())  // Might not exist if CreateProcess failed.
-    s_->stdin_thread.join();
-  if (s_->stdouterr_thread.joinable())
-    s_->stdouterr_thread.join();
-
-  // The stdin pipe is closed by the dedicated stdin thread. However if that is
-  // not started (e.g. because of no redirection) force close it now. Needs to
-  // happen after the join() to be thread safe.
-  s_->stdin_pipe.wr.reset();
-  s_->stdouterr_pipe.rd.reset();
-
-  return true;
-}
-
-void Subprocess::KillAndWaitForTermination(int exit_code) {
-  auto code = exit_code ? static_cast<DWORD>(exit_code) : STATUS_CONTROL_C_EXIT;
-  ::TerminateProcess(*s_->win_proc_handle, code);
-  Wait();
-  // TryReadExitStatus must have joined the threads.
-  PERFETTO_DCHECK(!s_->stdin_thread.joinable());
-  PERFETTO_DCHECK(!s_->stdouterr_thread.joinable());
-}
+}  // namespace perfetto::base
 
-}  // namespace base
-}  // namespace perfetto
-
-#endif  // PERFETTO_OS_WIN
-// gen_amalgamated begin source: src/protozero/field.cc
+#endif  // INCLUDE_PERFETTO_EXT_BASE_WEAK_RUNNER_H_
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2024 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -9787,75 +10761,46 @@ void Subprocess::KillAndWaitForTermination(int exit_code) {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/weak_runner.h"
 
-// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
 
-#if !PERFETTO_IS_LITTLE_ENDIAN()
-// The memcpy() for fixed32/64 below needs to be adjusted if we want to
-// support big endian CPUs. There doesn't seem to be a compelling need today.
-#error Unimplemented for big endian archs.
-#endif
+namespace perfetto::base {
 
-namespace protozero {
+WeakRunner::WeakRunner(base::TaskRunner* task_runner)
+    : task_runner_(task_runner), destroyed_(std::make_shared<bool>(false)) {}
 
-template <typename Container>
-void Field::SerializeAndAppendToInternal(Container* dst) const {
-  namespace pu = proto_utils;
-  size_t initial_size = dst->size();
-  dst->resize(initial_size + pu::kMaxSimpleFieldEncodedSize + size_);
-  uint8_t* start = reinterpret_cast<uint8_t*>(&(*dst)[initial_size]);
-  uint8_t* wptr = start;
-  switch (type_) {
-    case static_cast<int>(pu::ProtoWireType::kVarInt): {
-      wptr = pu::WriteVarInt(pu::MakeTagVarInt(id_), wptr);
-      wptr = pu::WriteVarInt(int_value_, wptr);
-      break;
-    }
-    case static_cast<int>(pu::ProtoWireType::kFixed32): {
-      wptr = pu::WriteVarInt(pu::MakeTagFixed<uint32_t>(id_), wptr);
-      uint32_t value32 = static_cast<uint32_t>(int_value_);
-      memcpy(wptr, &value32, sizeof(value32));
-      wptr += sizeof(uint32_t);
-      break;
-    }
-    case static_cast<int>(pu::ProtoWireType::kFixed64): {
-      wptr = pu::WriteVarInt(pu::MakeTagFixed<uint64_t>(id_), wptr);
-      memcpy(wptr, &int_value_, sizeof(int_value_));
-      wptr += sizeof(uint64_t);
-      break;
-    }
-    case static_cast<int>(pu::ProtoWireType::kLengthDelimited): {
-      ConstBytes payload = as_bytes();
-      wptr = pu::WriteVarInt(pu::MakeTagLengthDelimited(id_), wptr);
-      wptr = pu::WriteVarInt(payload.size, wptr);
-      memcpy(wptr, payload.data, payload.size);
-      wptr += payload.size;
-      break;
-    }
-    default:
-      PERFETTO_FATAL("Unknown field type %u", type_);
-  }
-  size_t written_size = static_cast<size_t>(wptr - start);
-  PERFETTO_DCHECK(written_size > 0 && written_size < pu::kMaxMessageLength);
-  PERFETTO_DCHECK(initial_size + written_size <= dst->size());
-  dst->resize(initial_size + written_size);
+WeakRunner::~WeakRunner() {
+  *destroyed_ = true;
 }
 
-void Field::SerializeAndAppendTo(std::string* dst) const {
-  SerializeAndAppendToInternal(dst);
+void WeakRunner::PostTask(std::function<void()> f) const {
+  task_runner_->PostTask([destroyed = destroyed_, f = std::move(f)]() {
+    if (*destroyed) {
+      return;
+    }
+    f();
+  });
 }
 
-void Field::SerializeAndAppendTo(std::vector<uint8_t>* dst) const {
-  SerializeAndAppendToInternal(dst);
+void WeakRunner::PostDelayedTask(std::function<void()> f,
+                                 uint32_t delay_ms) const {
+  task_runner_->PostDelayedTask(
+      [destroyed = destroyed_, f = std::move(f)]() {
+        if (*destroyed) {
+          return;
+        }
+        f();
+      },
+      delay_ms);
 }
 
-}  // namespace protozero
-// gen_amalgamated begin source: src/protozero/gen_field_helpers.cc
-// gen_amalgamated begin header: include/perfetto/protozero/gen_field_helpers.h
+}  // namespace perfetto::base
+// gen_amalgamated begin source: src/base/lock_free_task_runner.cc
+// gen_amalgamated begin header: include/perfetto/ext/base/lock_free_task_runner.h
+// gen_amalgamated begin header: include/perfetto/ext/base/unix_task_runner.h
 /*
- * Copyright (C) 2023 The Android Open Source Project
+ * Copyright (C) 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -9870,144 +10815,131 @@ void Field::SerializeAndAppendTo(std::vector<uint8_t>* dst) const {
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_PROTOZERO_GEN_FIELD_HELPERS_H_
-#define INCLUDE_PERFETTO_PROTOZERO_GEN_FIELD_HELPERS_H_
-
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-
-namespace protozero {
-namespace internal {
-namespace gen_helpers {
-
-// This file implements some helpers used by the protobuf generated code in the
-// .gen.cc files.
-//
-// The .gen.cc generated protobuf implementation (as opposed to the .pbzero.h
-// implementation) is not zero-copy and is not supposed to be used in fast
-// paths, so most of these helpers are designed to reduce binary size.
-
-void DeserializeString(const protozero::Field& field, std::string* dst);
-
-// Read packed repeated elements (serialized as `wire_type`) from `field` into
-// the `*dst` vector. Returns false if some bytes of `field` could not be
-// interpreted correctly as `wire_type`.
-template <proto_utils::ProtoWireType wire_type, typename CppType>
-bool DeserializePackedRepeated(const protozero::Field& field,
-                               std::vector<CppType>* dst) {
-  bool parse_error = false;
-  for (::protozero::PackedRepeatedFieldIterator<wire_type, CppType> rep(
-           field.data(), field.size(), &parse_error);
-       rep; ++rep) {
-    dst->emplace_back(*rep);
-  }
-  return !parse_error;
-}
-
-extern template bool
-DeserializePackedRepeated<proto_utils::ProtoWireType::kVarInt, uint64_t>(
-    const protozero::Field& field,
-    std::vector<uint64_t>* dst);
-
-extern template bool
-DeserializePackedRepeated<proto_utils::ProtoWireType::kVarInt, int64_t>(
-    const protozero::Field& field,
-    std::vector<int64_t>* dst);
-
-extern template bool
-DeserializePackedRepeated<proto_utils::ProtoWireType::kVarInt, uint32_t>(
-    const protozero::Field& field,
-    std::vector<uint32_t>* dst);
-
-extern template bool
-DeserializePackedRepeated<proto_utils::ProtoWireType::kVarInt, int32_t>(
-    const protozero::Field& field,
-    std::vector<int32_t>* dst);
-
-// Serializers for different type of fields
+#ifndef INCLUDE_PERFETTO_EXT_BASE_UNIX_TASK_RUNNER_H_
+#define INCLUDE_PERFETTO_EXT_BASE_UNIX_TASK_RUNNER_H_
 
-void SerializeTinyVarInt(uint32_t field_id, bool value, Message* msg);
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+// gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
+// gen_amalgamated expanded: #include "perfetto/base/thread_annotations.h"
+// gen_amalgamated expanded: #include "perfetto/base/thread_utils.h"
+// gen_amalgamated expanded: #include "perfetto/base/time.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/event_fd.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/rt_mutex.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/thread_checker.h"
 
-template <typename T>
-void SerializeExtendedVarInt(uint32_t field_id, T value, Message* msg) {
-  msg->AppendVarInt(field_id, value);
-}
+#include <chrono>
+#include <deque>
+#include <map>
+#include <mutex>
+#include <vector>
 
-extern template void SerializeExtendedVarInt<uint64_t>(uint32_t field_id,
-                                                       uint64_t value,
-                                                       Message* msg);
+#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+#include <poll.h>
+#endif
 
-extern template void SerializeExtendedVarInt<uint32_t>(uint32_t field_id,
-                                                       uint32_t value,
-                                                       Message* msg);
+namespace perfetto {
+namespace base {
 
-template <typename T>
-void SerializeVarInt(uint32_t field_id, T value, Message* msg) {
-  SerializeExtendedVarInt(
-      field_id, proto_utils::ExtendValueForVarIntSerialization(value), msg);
-}
+// Runs a task runner on the current thread.
+//
+// Implementation note: we currently assume (and enforce in debug builds) that
+// Run() is called from the thread that constructed the UnixTaskRunner. This is
+// not strictly necessary, and we could instead track the thread that invokes
+// Run(). However, a related property that *might* be important to enforce is
+// that the destructor runs on the task-running thread. Otherwise, if there are
+// still-pending tasks at the time of destruction, we would destroy those
+// outside of the task thread (which might be unexpected to the caller). On the
+// other hand, the std::function task interface discourages use of any
+// resource-owning tasks (as the callable needs to be copyable), so this might
+// not be important in practice.
+//
+// TODO(rsavitski): consider adding a thread-check in the destructor, after
+// auditing existing usages.
+// TODO(primiano): rename this to TaskRunnerImpl. The "Unix" part is misleading
+// now as it supports also Windows.
+class UnixTaskRunner : public TaskRunner {
+ public:
+  UnixTaskRunner();
+  ~UnixTaskRunner() override;
 
-template <typename T>
-void SerializeSignedVarInt(uint32_t field_id, T value, Message* msg) {
-  SerializeVarInt(field_id, proto_utils::ZigZagEncode(value), msg);
-}
+  // Start executing tasks. Doesn't return until Quit() is called. Run() may be
+  // called multiple times on the same task runner.
+  void Run();
+  void Quit();
 
-template <typename T>
-void SerializeFixed(uint32_t field_id, T value, Message* msg) {
-  msg->AppendFixed(field_id, value);
-}
+  // Checks whether there are any pending immediate tasks to run. Note that
+  // delayed tasks don't count even if they are due to run.
+  bool IsIdleForTesting();
 
-extern template void SerializeFixed<double>(uint32_t field_id,
-                                            double value,
-                                            Message* msg);
+  // Pretends (for the purposes of running delayed tasks) that time advanced by
+  // `ms`.
+  void AdvanceTimeForTesting(uint32_t ms);
 
-extern template void SerializeFixed<float>(uint32_t field_id,
-                                           float value,
-                                           Message* msg);
+  // TaskRunner implementation:
+  void PostTask(std::function<void()>) override;
+  void PostDelayedTask(std::function<void()>, uint32_t delay_ms) override;
+  void AddFileDescriptorWatch(PlatformHandle, std::function<void()>) override;
+  void RemoveFileDescriptorWatch(PlatformHandle) override;
+  bool RunsTasksOnCurrentThread() const override;
 
-extern template void SerializeFixed<uint64_t>(uint32_t field_id,
-                                              uint64_t value,
-                                              Message* msg);
+  // Returns true if the task runner is quitting, or has quit and hasn't been
+  // restarted since. Exposed primarily for ThreadTaskRunner, not necessary for
+  // normal use of this class.
+  bool QuitCalled();
 
-extern template void SerializeFixed<int64_t>(uint32_t field_id,
-                                             int64_t value,
-                                             Message* msg);
+ private:
+  void WakeUp();
+  void UpdateWatchTasksLocked() PERFETTO_EXCLUSIVE_LOCKS_REQUIRED(lock_);
+  int GetDelayMsToNextTaskLocked() const
+      PERFETTO_EXCLUSIVE_LOCKS_REQUIRED(lock_);
+  void RunImmediateAndDelayedTask();
+  void PostFileDescriptorWatches(uint64_t windows_wait_result);
+  void RunFileDescriptorWatch(PlatformHandle);
 
-extern template void SerializeFixed<uint32_t>(uint32_t field_id,
-                                              uint32_t value,
-                                              Message* msg);
+  ThreadChecker thread_checker_;
+  std::atomic<PlatformThreadId> created_thread_id_ = GetThreadId();
 
-extern template void SerializeFixed<int32_t>(uint32_t field_id,
-                                             int32_t value,
-                                             Message* msg);
+  EventFd event_;
 
-void SerializeString(uint32_t field_id, const std::string& value, Message* msg);
+// The array of fds/handles passed to poll(2) / WaitForMultipleObjects().
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  std::vector<PlatformHandle> poll_fds_;
+#else
+  std::vector<struct pollfd> poll_fds_;
+#endif
 
-void SerializeUnknownFields(const std::string& unknown_fields, Message* msg);
+  base::MaybeRtMutex lock_;
 
-// Wrapper around HeapBuffered that avoids inlining.
-class MessageSerializer {
- public:
-  MessageSerializer();
-  ~MessageSerializer();
+  std::deque<std::function<void()>> immediate_tasks_ PERFETTO_GUARDED_BY(lock_);
+  std::multimap<TimeMillis, std::function<void()>> delayed_tasks_
+      PERFETTO_GUARDED_BY(lock_);
+  bool quit_ PERFETTO_GUARDED_BY(lock_) = false;
+  TimeMillis advanced_time_for_testing_ PERFETTO_GUARDED_BY(lock_) =
+      TimeMillis(0);
 
-  Message* get() { return msg_.get(); }
-  std::vector<uint8_t> SerializeAsArray();
-  std::string SerializeAsString();
+  struct WatchTask {
+    std::function<void()> callback;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+    // On UNIX systems we make the FD number negative in |poll_fds_| to avoid
+    // polling it again until the queued task runs. On Windows we can't do that.
+    // Instead we keep track of its state here.
+    bool pending = false;
+#else
+    size_t poll_fd_index;  // Index into |poll_fds_|.
+#endif
+  };
 
- private:
-  HeapBuffered<Message> msg_;
+  std::map<PlatformHandle, WatchTask> watch_tasks_ PERFETTO_GUARDED_BY(lock_);
+  bool watch_tasks_changed_ PERFETTO_GUARDED_BY(lock_) = false;
 };
 
-}  // namespace gen_helpers
-}  // namespace internal
-}  // namespace protozero
+}  // namespace base
+}  // namespace perfetto
 
-#endif  // INCLUDE_PERFETTO_PROTOZERO_GEN_FIELD_HELPERS_H_
+#endif  // INCLUDE_PERFETTO_EXT_BASE_UNIX_TASK_RUNNER_H_
 /*
- * Copyright (C) 2023 The Android Open Source Project
+ * Copyright (C) 2025 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -10022,96 +10954,272 @@ class MessageSerializer {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+#ifndef INCLUDE_PERFETTO_EXT_BASE_LOCK_FREE_TASK_RUNNER_H_
+#define INCLUDE_PERFETTO_EXT_BASE_LOCK_FREE_TASK_RUNNER_H_
 
-namespace protozero {
-namespace internal {
-namespace gen_helpers {
+// gen_amalgamated expanded: #include "perfetto/base/flat_set.h"
+// gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
+// gen_amalgamated expanded: #include "perfetto/base/thread_annotations.h"
+// gen_amalgamated expanded: #include "perfetto/base/time.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/event_fd.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/flags.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/unix_task_runner.h"
 
-void DeserializeString(const protozero::Field& field, std::string* dst) {
-  field.get(dst);
-}
+#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+#include <poll.h>
+#endif
 
-template bool DeserializePackedRepeated<proto_utils::ProtoWireType::kVarInt,
-                                        uint64_t>(const protozero::Field& field,
-                                                  std::vector<uint64_t>* dst);
+#include <array>
+#include <atomic>
+#include <thread>
+#include <unordered_map>
 
-template bool DeserializePackedRepeated<proto_utils::ProtoWireType::kVarInt,
-                                        int64_t>(const protozero::Field& field,
-                                                 std::vector<int64_t>* dst);
+namespace perfetto {
+namespace base {
 
-template bool DeserializePackedRepeated<proto_utils::ProtoWireType::kVarInt,
-                                        uint32_t>(const protozero::Field& field,
-                                                  std::vector<uint32_t>* dst);
+namespace task_runner_internal {
+class ScopedRefcount;
+struct Slab;
 
-template bool DeserializePackedRepeated<proto_utils::ProtoWireType::kVarInt,
-                                        int32_t>(const protozero::Field& field,
-                                                 std::vector<int32_t>* dst);
+// Exposed for testing
+constexpr uint32_t kNumRefcountBuckets = 32;
+constexpr size_t kSlabSize = 512;
 
-void SerializeTinyVarInt(uint32_t field_id, bool value, Message* msg) {
-  msg->AppendTinyVarInt(field_id, value);
-}
+}  // namespace task_runner_internal
 
-template void SerializeExtendedVarInt<uint64_t>(uint32_t field_id,
-                                                uint64_t value,
-                                                Message* msg);
+template <typename T>
+class TaskRunnerTest;
 
-template void SerializeExtendedVarInt<uint32_t>(uint32_t field_id,
-                                                uint32_t value,
-                                                Message* msg);
+// This class implements a lock-less multi-producer single-consumer task runner.
+// This is achieved by using a linked list of "slabs". Each slab is a fixed-size
+// array of tasks.
+// See /docs/design-docs/lock-free-task-runner.md for more details
+class PERFETTO_EXPORT_COMPONENT LockFreeTaskRunner : public TaskRunner {
+ public:
+  LockFreeTaskRunner();
+  ~LockFreeTaskRunner() override;
 
-template void SerializeFixed<double>(uint32_t field_id,
-                                     double value,
-                                     Message* msg);
+  void Run();
+  void Quit();
 
-template void SerializeFixed<float>(uint32_t field_id,
-                                    float value,
-                                    Message* msg);
+  // Checks whether there are any pending immediate tasks to run. Note that
+  // delayed tasks don't count even if they are due to run.
+  bool IsIdleForTesting();
 
-template void SerializeFixed<uint64_t>(uint32_t field_id,
-                                       uint64_t value,
-                                       Message* msg);
+  // TaskRunner implementation:
+  void PostTask(std::function<void()>) override;
+  void PostDelayedTask(std::function<void()>, uint32_t delay_ms) override;
+  void AddFileDescriptorWatch(PlatformHandle, std::function<void()>) override;
+  void RemoveFileDescriptorWatch(PlatformHandle) override;
+  bool RunsTasksOnCurrentThread() const override;
 
-template void SerializeFixed<int64_t>(uint32_t field_id,
-                                      int64_t value,
-                                      Message* msg);
+  // Pretends (for the purposes of running delayed tasks) that time advanced by
+  // `ms`.
+  void AdvanceTimeForTesting(uint32_t ms);
 
-template void SerializeFixed<uint32_t>(uint32_t field_id,
-                                       uint32_t value,
-                                       Message* msg);
+  // Stats for testing.
+  size_t slabs_allocated() const {
+    return slabs_allocated_.load(std::memory_order_relaxed);
+  }
+  size_t slabs_freed() const {
+    return slabs_freed_.load(std::memory_order_relaxed);
+  }
 
-template void SerializeFixed<int32_t>(uint32_t field_id,
-                                      int32_t value,
-                                      Message* msg);
+ private:
+  using Slab = task_runner_internal::Slab;
+  using ScopedRefcount = task_runner_internal::ScopedRefcount;
+  friend class task_runner_internal::ScopedRefcount;
+
+  struct DelayedTask {
+    TimeMillis time;
+    uint64_t seq;
+    std::function<void()> task;
+
+    // Note that the < operator keeps the DelayedTasks sorted in reverse order
+    // (the latest one is first, the earliest one is last). This is so we can
+    // have a FIFO queue using a vector by just doing an O(1) pop_back().
+    bool operator<(const DelayedTask& other) const {
+      if (time != other.time)
+        return time > other.time;
+      return seq > other.seq;
+    }
+    bool operator==(const DelayedTask& other) const {
+      return time == other.time && seq == other.seq;
+    }
+  };
 
-void SerializeString(uint32_t field_id,
-                     const std::string& value,
-                     Message* msg) {
-  msg->AppendString(field_id, value);
-}
+  PERFETTO_ALWAYS_INLINE std::function<void()> PopNextImmediateTask();
+  std::function<void()> PopTaskRecursive(Slab*, Slab* next_slab);
+  std::function<void()> PopNextExpiredDelayedTask();
+  int GetDelayMsToNextTask() const;
+  void WakeUp() { wakeup_event_.Notify(); }
+  Slab* AllocNewSlab();
+  void DeleteSlab(Slab*);
+  void PostFileDescriptorWatches(uint64_t windows_wait_result);
+  void RunFileDescriptorWatch(PlatformHandle);
+  void UpdateWatchTasks();
 
-void SerializeUnknownFields(const std::string& unknown_fields, Message* msg) {
-  msg->AppendRawProtoBytes(unknown_fields.data(), unknown_fields.size());
-}
+  // These two are semantically a unique_ptr, but are accessed from different
+  // threads.
+  std::atomic<Slab*> tail_{};  // This is never null.
+  std::atomic<Slab*> free_slab_{};
 
-MessageSerializer::MessageSerializer() = default;
+  EventFd wakeup_event_;
+  bool quit_ = false;
+  std::thread::id run_task_thread_id_;
 
-MessageSerializer::~MessageSerializer() = default;
+  // Delayed tasks, accessed only by the main thread. Items are stored in
+  // reverse temporal order, see comment in the operator<.
+  FlatSet<DelayedTask> delayed_tasks_;
+  uint64_t next_delayed_task_seq_ = 0;
+  std::atomic<uint32_t> advanced_time_for_testing_{};
 
-std::vector<uint8_t> MessageSerializer::SerializeAsArray() {
-  return msg_.SerializeAsArray();
-}
+  // The array of fds/handles passed to poll(2) / WaitForMultipleObjects().
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  std::vector<PlatformHandle> poll_fds_;
+#else
+  std::vector<struct pollfd> poll_fds_;
+#endif
 
-std::string MessageSerializer::SerializeAsString() {
-  return msg_.SerializeAsString();
+  struct WatchTask {
+    std::function<void()> callback;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+    // On UNIX systems we make the FD number negative in |poll_fds_| to avoid
+    // polling it again until the queued task runs. On Windows we can't do that.
+    // Instead we keep track of its state here.
+    bool pending = false;
+#else
+    size_t poll_fd_index;  // Index into |poll_fds_|.
+#endif
+  };
+
+  // Accessed only from the main thread.
+  std::unordered_map<PlatformHandle, WatchTask> watch_tasks_;
+  bool watch_tasks_changed_ = false;
+
+  // An array of 32 refcount buckets. Every Slab* maps to a bucket via a hash
+  // function. Every PostTask() thread increases the refcount before accessing
+  // a slab, and decreases it when done.
+  // This allows the Run() main thread to tell if any thread has possibly been
+  // able to observe the Slab through the tail_ before deleting it.
+  std::array<std::atomic<int32_t>, task_runner_internal::kNumRefcountBuckets>
+      refcounts_{};
+
+  // Stats for testing.
+  std::atomic<size_t> slabs_allocated_{};
+  std::atomic<size_t> slabs_freed_{};
+};
+
+namespace task_runner_internal {
+
+// Returns the index of the refcount_ bucket for the passed Slab pointer.
+static uint32_t HashSlabPtr(Slab* slab) {
+  // This is a SplitMix64 hash, which is very fast and effective with pointers
+  // (See the test LockFreeTaskRunnerTest.HashSpreading).
+  uint64_t u = reinterpret_cast<uintptr_t>(slab);
+  u &= 0x00FFFFFFFFFFFFFFull;  // Clear asan/MTE top byte for tagged pointers.
+  u += 0x9E3779B97F4A7C15ull;
+  u = (u ^ (u >> 30)) * 0xBF58476D1CE4E5B9ull;
+  u = (u ^ (u >> 27)) * 0x94D049BB133111EBull;
+  return static_cast<uint32_t>((u ^ (u >> 31)) % kNumRefcountBuckets);
 }
 
-}  // namespace gen_helpers
-}  // namespace internal
-}  // namespace protozero
-// gen_amalgamated begin source: src/protozero/message.cc
+// A slab is a fixed-size array of tasks. The lifecycle of a task slot
+// within a slab goes through three phases:
+//
+// 1. Reservation: A writer thread atomically increments `next_task_slot` to
+//    reserve a slot in the `tasks` array. This reservation establishes the
+//    implicit order in which the consumer will attempt to read tasks (but
+//    only if they are published in the bitmap, see below).
+//
+// 2. Publishing: After writing the task into its reserved slot, the writer
+//    thread atomically sets the corresponding bit in the `tasks_written`
+//    bitmask. This acts as a memory barrier and makes the task visible to
+//    the consumer (main) thread.
+//
+// 3. Consumption: The main thread acquire-reads the `tasks_written` bitmask.
+//    For each bit that is set, it processes the task and then sets the
+//    corresponding bit in its private `tasks_read` bitmask to prevent
+//    reading the same task again.
+struct Slab {
+  Slab();
+  ~Slab();
+
+  std::atomic<size_t> next_task_slot{0};
+
+  // `tasks` and `next_task_slot` are accessed by writer threads only.
+  // The main thread can access `tasks[i]` but only after ensuring that the
+  // corresponding bit in `tasks_written` is set.
+  std::array<std::function<void()>, kSlabSize> tasks{};
+
+  // A bitmask indicating which tasks in the `tasks` array have been written
+  // and are ready to be read by the main thread.
+  // This is atomically updated by writer threads and read by the main thread.
+  using BitWord = size_t;
+  static constexpr size_t kBitsPerWord = sizeof(BitWord) * 8;
+  static constexpr size_t kNumWords = kSlabSize / kBitsPerWord;
+  std::array<std::atomic<BitWord>, kNumWords> tasks_written{};
+
+  // A bitmask indicating which tasks have been read by the main thread.
+  // This is accessed only by the main thread, so no atomicity is required.
+  std::array<BitWord, kNumWords> tasks_read{};
+
+  // The link to the previous slab.
+  // This is written by writer threads when they create a new slab and link it
+  // to the previous tail. But they do so when nobody else can see the Slab,
+  // so there is no need for an atomic ptr. After the initial creation,
+  // this is accessed only by the main thread when:
+  // 1. draining tasks (to walk back to the oldest slab)
+  // 2. deleting slabs, setting it to nullptr, when they are fully consumed.
+  Slab* prev = nullptr;
+};
+
+class ScopedRefcount {
+ public:
+  ScopedRefcount(LockFreeTaskRunner* tr, LockFreeTaskRunner::Slab* slab) {
+    bucket_ = &tr->refcounts_[HashSlabPtr(slab)];
+    auto prev_value = bucket_->fetch_add(1);
+    PERFETTO_DCHECK(prev_value >= 0);
+  }
+
+  ~ScopedRefcount() {
+    if (bucket_) {
+      auto prev_value = bucket_->fetch_sub(1);
+      PERFETTO_DCHECK(prev_value > 0);
+    }
+  }
+
+  ScopedRefcount(ScopedRefcount&& other) noexcept {
+    bucket_ = other.bucket_;
+    other.bucket_ = nullptr;
+  }
+
+  ScopedRefcount& operator=(ScopedRefcount&& other) noexcept {
+    this->~ScopedRefcount();
+    new (this) ScopedRefcount(std::move(other));
+    return *this;
+  }
+
+  ScopedRefcount(const ScopedRefcount&) = delete;
+  ScopedRefcount& operator=(const ScopedRefcount&) = delete;
+
+  std::atomic<int32_t>* bucket_{};
+};
+}  // namespace task_runner_internal
+
+using MaybeLockFreeTaskRunner =
+    std::conditional_t<PERFETTO_FLAGS(USE_LOCKFREE_TASKRUNNER),
+                       LockFreeTaskRunner,
+                       UnixTaskRunner>;
+
+}  // namespace base
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_LOCK_FREE_TASK_RUNNER_H_
+// gen_amalgamated begin header: include/perfetto/ext/base/bits.h
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2025 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -10126,305 +11234,629 @@ std::string MessageSerializer::SerializeAsString() {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+#ifndef INCLUDE_PERFETTO_EXT_BASE_BITS_H_
+#define INCLUDE_PERFETTO_EXT_BASE_BITS_H_
 
-#include <atomic>
-#include <type_traits>
+#include <cstddef>
+#include <cstdint>
 
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
 // gen_amalgamated expanded: #include "perfetto/base/compiler.h"
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message_arena.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message_handle.h"
 
-#if !PERFETTO_IS_LITTLE_ENDIAN()
-// The memcpy() for float and double below needs to be adjusted if we want to
-// support big endian CPUs. There doesn't seem to be a compelling need today.
-#error Unimplemented for big endian archs.
+#if PERFETTO_BUILDFLAG(PERFETTO_X64_CPU_OPT)
+#include <immintrin.h>
 #endif
 
-namespace protozero {
-
-namespace {
+namespace perfetto {
+namespace base {
 
-#if PERFETTO_DCHECK_IS_ON()
-std::atomic<uint32_t> g_generation;
+inline PERFETTO_ALWAYS_INLINE uint32_t CountLeadZeros32(uint32_t value) {
+#if PERFETTO_BUILDFLAG(PERFETTO_X64_CPU_OPT)
+  return static_cast<uint32_t>(_lzcnt_u32(value));
+#elif defined(__GNUC__) || defined(__clang__)
+  return value ? static_cast<uint32_t>(__builtin_clz(value)) : 32u;
+#else
+  unsigned long out;
+  return _BitScanReverse(&out, value) ? 31 - out : 32u;
 #endif
+}
 
-}  // namespace
+inline PERFETTO_ALWAYS_INLINE uint32_t CountLeadZeros64(uint64_t value) {
+#if PERFETTO_BUILDFLAG(PERFETTO_X64_CPU_OPT)
+  return static_cast<uint32_t>(_lzcnt_u64(value));
+#elif defined(__GNUC__) || defined(__clang__)
+  return value ? static_cast<uint32_t>(__builtin_clzll(value)) : 64u;
+#else
+  unsigned long out;
+  return _BitScanReverse64(&out, value) ? 63 - out : 64u;
+#endif
+}
 
-// Do NOT put any code in the constructor or use default initialization.
-// Use the Reset() method below instead.
+template <typename T>
+uint32_t CountLeadZeros(T value) {
+  if constexpr (sizeof(T) == 8)
+    return CountLeadZeros64(static_cast<uint64_t>(value));
+  return CountLeadZeros32(static_cast<uint32_t>(value));
+}
 
-// This method is called to initialize both root and nested messages.
-void Message::Reset(ScatteredStreamWriter* stream_writer, MessageArena* arena) {
-// Older versions of libstdcxx don't have is_trivially_constructible.
-#if !defined(__GLIBCXX__) || __GLIBCXX__ >= 20170516
-  static_assert(std::is_trivially_constructible<Message>::value,
-                "Message must be trivially constructible");
+inline PERFETTO_ALWAYS_INLINE uint32_t CountTrailZeros64(uint64_t value) {
+#if PERFETTO_BUILDFLAG(PERFETTO_X64_CPU_OPT)
+  return static_cast<uint32_t>(_tzcnt_u64(value));
+#elif defined(__GNUC__) || defined(__clang__)
+  return value ? static_cast<uint32_t>(__builtin_ctzll(value)) : 64u;
+#else
+  unsigned long out;
+  return _BitScanForward64(&out, value) ? static_cast<uint32_t>(out) : 64u;
 #endif
+}
 
-  static_assert(std::is_trivially_destructible<Message>::value,
-                "Message must be trivially destructible");
-  stream_writer_ = stream_writer;
-  arena_ = arena;
-  size_ = 0;
-  size_field_ = nullptr;
-  size_already_written_ = 0;
-  nested_message_ = nullptr;
-  finalized_ = false;
-#if PERFETTO_DCHECK_IS_ON()
-  handle_ = nullptr;
-  generation_ = g_generation.fetch_add(1, std::memory_order_relaxed);
+inline PERFETTO_ALWAYS_INLINE uint32_t CountTrailZeros32(uint32_t value) {
+#if PERFETTO_BUILDFLAG(PERFETTO_X64_CPU_OPT)
+  return _tzcnt_u32(value);
+#elif defined(__GNUC__) || defined(__clang__)
+  return value ? static_cast<uint32_t>(__builtin_ctz(value)) : 32u;
+#else
+  unsigned long out;
+  return _BitScanForward(&out, value) ? out : 32u;
 #endif
 }
 
-void Message::AppendString(uint32_t field_id, const char* str) {
-  AppendBytes(field_id, str, strlen(str));
+template <typename T>
+inline PERFETTO_ALWAYS_INLINE uint32_t CountTrailZeros(T value) {
+  if (sizeof(T) == 8) {
+    return CountTrailZeros64(static_cast<uint64_t>(value));
+  }
+  return CountTrailZeros32(static_cast<uint32_t>(value));
 }
 
-void Message::AppendBytes(uint32_t field_id, const void* src, size_t size) {
-  if (nested_message_)
-    EndNestedMessage();
+template <typename T>
+constexpr bool AllBitsSet(T v) {
+  return v == static_cast<T>(-1);
+}
 
-  PERFETTO_DCHECK(size < proto_utils::kMaxMessageLength);
-  // Write the proto preamble (field id, type and length of the field).
-  uint8_t buffer[proto_utils::kMaxSimpleFieldEncodedSize];
-  uint8_t* pos = buffer;
-  pos = proto_utils::WriteVarInt(proto_utils::MakeTagLengthDelimited(field_id),
-                                 pos);
-  pos = proto_utils::WriteVarInt(static_cast<uint32_t>(size), pos);
-  WriteToStream(buffer, pos);
+}  // namespace base
+}  // namespace perfetto
 
-  const uint8_t* src_u8 = reinterpret_cast<const uint8_t*>(src);
-  WriteToStream(src_u8, src_u8 + size);
-}
+#endif  // INCLUDE_PERFETTO_EXT_BASE_BITS_H_
 
-size_t Message::AppendScatteredBytes(uint32_t field_id,
-                                     ContiguousMemoryRange* ranges,
-                                     size_t num_ranges) {
-  size_t size = 0;
-  for (size_t i = 0; i < num_ranges; ++i) {
-    size += ranges[i].size();
-  }
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law of an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-  PERFETTO_DCHECK(size < proto_utils::kMaxMessageLength);
+// gen_amalgamated expanded: #include "perfetto/ext/base/lock_free_task_runner.h"
 
-  uint8_t buffer[proto_utils::kMaxSimpleFieldEncodedSize];
-  uint8_t* pos = buffer;
-  pos = proto_utils::WriteVarInt(proto_utils::MakeTagLengthDelimited(field_id),
-                                 pos);
-  pos = proto_utils::WriteVarInt(static_cast<uint32_t>(size), pos);
-  WriteToStream(buffer, pos);
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
 
-  for (size_t i = 0; i < num_ranges; ++i) {
-    auto& range = ranges[i];
-    WriteToStream(range.begin, range.end);
-  }
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+#include <windows.h>
 
-  return size;
-}
+// Keep the \n before to prevent clang-format reordering.
+#include <synchapi.h>
+#else
+#include <poll.h>
+#include <unistd.h>
+#endif
 
-uint32_t Message::Finalize() {
-  if (finalized_)
-    return size_;
+#include <thread>
 
-  if (nested_message_)
-    EndNestedMessage();
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/base/time.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/bits.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/platform.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/watchdog.h"
 
-  // Write the length of the nested message a posteriori, using a leading-zero
-  // redundant varint encoding.
-  if (size_field_) {
-    PERFETTO_DCHECK(!finalized_);
-    PERFETTO_DCHECK(size_ < proto_utils::kMaxMessageLength);
-    PERFETTO_DCHECK(size_ >= size_already_written_);
-    proto_utils::WriteRedundantVarInt(size_ - size_already_written_,
-                                      size_field_);
-    size_field_ = nullptr;
-  }
+namespace perfetto {
+namespace base {
 
-  finalized_ = true;
-#if PERFETTO_DCHECK_IS_ON()
-  if (handle_)
-    handle_->reset_message();
-#endif
+namespace task_runner_internal {
+Slab::Slab() = default;
+Slab::~Slab() {
+  PERFETTO_DCHECK(!prev);  // We should never delete linked slabs.
+}
+}  // namespace task_runner_internal
 
-  return size_;
+namespace {
+static constexpr auto kSlabSize = task_runner_internal::kSlabSize;
 }
 
-Message* Message::BeginNestedMessageInternal(uint32_t field_id) {
-  if (nested_message_)
-    EndNestedMessage();
+LockFreeTaskRunner::LockFreeTaskRunner()
+    : run_task_thread_id_(std::this_thread::get_id()) {
+  static_assert((kSlabSize & (kSlabSize - 1)) == 0, "kSlabSize must be a pow2");
+  static_assert(kSlabSize >= Slab::kBitsPerWord);
 
-  // Write the proto preamble for the nested message.
-  uint8_t data[proto_utils::kMaxTagEncodedSize];
-  uint8_t* data_end = proto_utils::WriteVarInt(
-      proto_utils::MakeTagLengthDelimited(field_id), data);
-  WriteToStream(data, data_end);
+  // Populate both the tail and the freelist, to minimize the chance of
+  // allocations at runtime.
+  tail_.store(AllocNewSlab());
+  free_slab_.store(AllocNewSlab());
 
-  Message* message = arena_->NewMessage();
-  message->Reset(stream_writer_, arena_);
+  AddFileDescriptorWatch(wakeup_event_.fd(), [] {
+    // Not reached -- see PostFileDescriptorWatches().
+    PERFETTO_DFATAL("Should be unreachable.");
+  });
+}
 
-  // The length of the nested message cannot be known upfront. So right now
-  // just reserve the bytes to encode the size after the nested message is done.
-  message->set_size_field(
-      stream_writer_->ReserveBytes(proto_utils::kMessageLengthFieldSize));
-  size_ += proto_utils::kMessageLengthFieldSize;
+LockFreeTaskRunner::~LockFreeTaskRunner() {
+  PERFETTO_DCHECK(RunsTasksOnCurrentThread());
 
-  nested_message_ = message;
-  return message;
+  for (Slab* slab = tail_.exchange(nullptr); slab;) {
+    Slab* prev = slab->prev;
+    slab->prev = nullptr;
+    delete slab;
+    slab = prev;
+  }
+  delete free_slab_.exchange(nullptr);
 }
 
-void Message::EndNestedMessage() {
-  size_ += nested_message_->Finalize();
-  arena_->DeleteLastMessage(nested_message_);
-  nested_message_ = nullptr;
+void LockFreeTaskRunner::PostTask(std::function<void()> closure) {
+  // We use nullity of std::function in PopTaskRecursive() to determine exit
+  // criteria. Posting a null task would break that logic. Also a null task
+  // would cause an abort when trying to run it later on.
+  PERFETTO_CHECK(PERFETTO_LIKELY(closure));
+  using BitWord = Slab::BitWord;
+  for (;;) {
+    Slab* slab = tail_.load();
+    PERFETTO_DCHECK(slab);  // The tail_ must be always valid.
+    ScopedRefcount scoped_refcount(this, slab);
+
+    // Now that we have a slab, try appending a task to it (if there is space).
+    // We have 3 cases:
+    // 1. slot < kSlabSize: the nominal case. Append the task and return.
+    // 2. slot == kSlabSize: the common overflow case: The slab was full and we
+    //    tried to allocate the N+1 th element. We have to allocate a new Slab.
+    // 3. slot > kSlabSize: like 2, but but two (or more) threads raced on it.
+    //    One thread will win the race and alloc a new slab, the other one will
+    //    repeat.
+    size_t slot = slab->next_task_slot.fetch_add(1, std::memory_order_relaxed);
+
+    if (slot >= kSlabSize) {  // Cases 2,3
+      Slab* new_slab = AllocNewSlab();
+      new_slab->prev = slab;
+      new_slab->next_task_slot.store(1, std::memory_order_relaxed);
+      slot = 0;
+      if (PERFETTO_UNLIKELY(!tail_.compare_exchange_strong(slab, new_slab))) {
+        // If the cmpxcgh fails, another thread tried to allocate a new tail
+        // slab and won the race. Do another round, we'll observe the new slab.
+        // We have to release the prev pointer as at this point we found out
+        // another thread also has it.
+        new_slab->prev = nullptr;
+        DeleteSlab(new_slab);
+        continue;
+      }
+
+      slab = new_slab;
+      scoped_refcount = ScopedRefcount(this, new_slab);
+    }
+
+    // Nominal case: publish the task and return.
+    PERFETTO_DCHECK(!slab->tasks[slot]);
+    slab->tasks[slot] = std::move(closure);
+    size_t s_word = slot / Slab::kBitsPerWord;
+    size_t s_bit = slot % Slab::kBitsPerWord;
+    BitWord s_mask = BitWord(1) << s_bit;
+    PERFETTO_DCHECK(
+        (slab->tasks_written[s_word].load(std::memory_order_relaxed) &
+         s_mask) == 0);
+    slab->tasks_written[s_word].fetch_or(s_mask, std::memory_order_release);
+
+    if (!RunsTasksOnCurrentThread()) {
+      // We don't need any clever logic to avoid spurious wake ups from other
+      // threads. Most PostTask()s in our codebase are done by the main thread.
+      // In the rare cases of a PostTask() coming from another thread, the odds
+      // of the main thread being woken up at the same time are tiny.
+      WakeUp();
+    }
+    return;
+  }
 }
 
-}  // namespace protozero
-// gen_amalgamated begin source: src/protozero/message_arena.cc
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+void LockFreeTaskRunner::Run() {
+  PERFETTO_CHECK(run_task_thread_id_ == std::this_thread::get_id());
+  quit_ = false;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/message_arena.h"
+  while (!quit_) {
+    // Pop one immediate and one delayed task, for fairness.
+    std::function<void()> immediate_task = PopNextImmediateTask();
+    std::function<void()> delayed_task = PopNextExpiredDelayedTask();
+    bool has_task = immediate_task || delayed_task;
+    int poll_timeout_ms = has_task ? 0 : GetDelayMsToNextTask();
+
+    // run the poll(). We need it for two different reasons:
+    // 1. Blocks until the next event on the horizon, which:
+    //    - If we pulled a task, poll in non-blocking mode (0 delay). There
+    //      might be other tasks ready and we want to run them soon after.
+    //    - If there is a delayed task, compute the time remaining for it.
+    //    - Otherwise polls indefinitely, waiting for a PostTask() or a Quit()
+    //      call from another thread.
+    // 2. Regardless of timing, we need to read the FD watches.
+    //    We want to do this even if we know already that we have an immediate
+    //    task (when poll_timeout_ms = 0) to ensure fairness.
+
+    //    TODO(primiano): we could optimize this and avoid a syscall for each
+    //    task when we have bursts of tasks (with some saturation, e.g. do still
+    //    a poll() every 10 tasks). Unfortunately, however, some users of
+    //    TestTaskRunner.RunUntilIdle() rely on the fact that FD watches are
+    //    polled before the current task is ran, so that the task can tell if
+    //    there are more tasks upcoming or it has reached quiescence.
+    //    TL;DR RunUntilIdle() was a mistake as it has ill-defined semantics but
+    //    now tests rely on those subtle semantics.
+
+    // Recompute the list of FDs to watch.
+    UpdateWatchTasks();
+
+    uint64_t windows_wait_res = 0;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+    // Unlike poll(2), WaitForMultipleObjects() returns only *one* handle in the
+    // set, even when >1 is signalled. In order to avoid starvation,
+    // PostFileDescriptorWatches() will WaitForSingleObject() each other handle
+    // to ensure fairness. |windows_wait_res| is passed just to avoid an extra
+    // WaitForSingleObject() for the one handle that WaitForMultipleObject()
+    // returned.
+    DWORD timeout =
+        poll_timeout_ms >= 0 ? static_cast<DWORD>(poll_timeout_ms) : INFINITE;
+    windows_wait_res =
+        WaitForMultipleObjects(static_cast<DWORD>(poll_fds_.size()),
+                               &poll_fds_[0], /*bWaitAll=*/false, timeout);
+#else
+    platform::BeforeMaybeBlockingSyscall();
+    int ret = PERFETTO_EINTR(poll(
+        &poll_fds_[0], static_cast<nfds_t>(poll_fds_.size()), poll_timeout_ms));
+    platform::AfterMaybeBlockingSyscall();
+    PERFETTO_CHECK(ret >= 0);
+#endif
+    PostFileDescriptorWatches(windows_wait_res);
 
-#include <atomic>
-#include <type_traits>
+    if (immediate_task) {
+      errno = 0;
+      RunTaskWithWatchdogGuard(std::move(immediate_task));
+    }
 
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message_handle.h"
+    if (delayed_task) {
+      errno = 0;
+      RunTaskWithWatchdogGuard(std::move(delayed_task));
+    }
+  }
 
-namespace protozero {
+  // Wait for all other threads to have finished the Quit's PostTask().
+  // This is to prevent the following race in tests:
+  // - Thread1 (!= main thread) invokes Quit, which in turn becomes a PostTask.
+  // - This function sees quit_=true and returns from Run().
+  // - The owner of the LFTR at that point is entitled to destroy LFTR.
+  // - Thread1 is still executing the epilogue of the PostTask, decrementing the
+  //   refcount, and ends up operating on invalid memory.
+  while (
+      std::any_of(refcounts_.begin(), refcounts_.end(),
+                  [](std::atomic<int32_t>& bucket) { return bucket.load(); })) {
+    std::this_thread::yield();
+  }
+}
 
-MessageArena::MessageArena() {
-  // The code below assumes that there is always at least one block.
-  blocks_.emplace_front();
-  static_assert(
-      std::alignment_of<decltype(blocks_.front().storage[0])>::value >=
-          alignof(Message),
-      "MessageArea's storage is not properly aligned");
+std::function<void()> LockFreeTaskRunner::PopNextImmediateTask() {
+  return PopTaskRecursive(tail_.load(), nullptr);
 }
 
-MessageArena::~MessageArena() = default;
+std::function<void()> LockFreeTaskRunner::PopTaskRecursive(Slab* slab,
+                                                           Slab* next_slab) {
+  PERFETTO_DCHECK(RunsTasksOnCurrentThread());
+  Slab* prev = slab->prev;
+  if (PERFETTO_UNLIKELY(prev)) {
+    // In practice it's extemely unlikely that a slab has >1 predecessors.
+    // In nominal conditions it is going to have 0 predecessors most of the
+    // times and 1 predecessors 1 every kSlabSize times.
+    auto task = PopTaskRecursive(prev, slab);
+    if (task)
+      return task;
+  }
 
-Message* MessageArena::NewMessage() {
-  PERFETTO_DCHECK(!blocks_.empty());  // Should never become empty.
+  size_t words_fully_consumed = 0;
+  for (size_t w = 0; w < Slab::kNumWords; ++w) {
+    using BitWord = Slab::BitWord;
+    BitWord wr_word = slab->tasks_written[w].load(std::memory_order_acquire);
+    BitWord rd_word = slab->tasks_read[w];
+    words_fully_consumed += base::AllBitsSet(rd_word) ? 1 : 0;
+    BitWord unread_word = wr_word & ~rd_word;
 
-  Block* block = &blocks_.front();
-  if (PERFETTO_UNLIKELY(block->entries >= Block::kCapacity)) {
-    blocks_.emplace_front();
-    block = &blocks_.front();
+    if (unread_word == 0)
+      continue;
+
+    // Find the first unread task in the word.
+    uint32_t bit = base::CountTrailZeros(unread_word);
+    BitWord bit_mask = BitWord(1) << bit;
+    size_t slot = w * Slab::kBitsPerWord + bit;
+    std::function<void()> task = std::move(slab->tasks[slot]);
+    slab->tasks[slot] = nullptr;
+    slab->tasks_read[w] |= bit_mask;
+    return task;
+  }  // for(word in tasks_written)
+
+  // There are no unconsumed tasks in this Slab. Reached this point, this
+  // invocation will return null. However, before doing so, if the slab is fully
+  // written (are no slots left) and fully consumed delete it.
+  // We never delete the latest slab (the one pointed to by tail_) because
+  // we want the tail_ to always point to a valid slab.
+  // In principle, we only delete non-tail slabs, and PostTask() threads only
+  // access the tail, never walk back on the list, which sounds safe. However
+  // there is a potential race we have to guard against:
+  // A PostTask() thread could observe Slab 1 (e.g., the only slab), then
+  // another PostTask thread() could append (and replace tail_ with) a new
+  // Slab 2 (because Slab 1 was full).
+  // If Run() comes along and sees the Slab 1 full it will delete it, without
+  // realizing that the first thread is still accessing it, thinking it was the
+  // tail.
+  // Essentially, it is safe to delete non-tail slabs as long as we can
+  // guarrantee that no other thread observed that slab through the `tail_` at
+  // some point in the recent past. In order to do so, we use a refcount
+  // mechanism. If the refcount is 0 we know that no other PostTask thread
+  // has loaded the tail, and hence we can safely delete any non-tail slab.
+  // If a PostTask thread comes immediately after our check they will observe
+  // the new tail (we never delete the tail slab, only the predecessors).
+
+  bool slab_fully_consumed = words_fully_consumed == Slab::kNumWords;
+
+  const uint32_t bucket = HashSlabPtr(slab);
+  if (slab_fully_consumed && next_slab && refcounts_[bucket].load() == 0) {
+    // NOTE: only the main thread follows the `prev` linked list, writers never
+    // look at `prev`. The only contention entrypoint is the `tail_` pointer,
+    // which can be modified both by us and by writers.
+    PERFETTO_DCHECK(next_slab->prev == slab);
+    next_slab->prev = slab->prev;
+    slab->prev = nullptr;
+    DeleteSlab(slab);
   }
-  const auto idx = block->entries++;
-  void* storage = &block->storage[idx];
-  PERFETTO_ASAN_UNPOISON(storage, sizeof(Message));
-  return new (storage) Message();
+
+  return nullptr;
 }
 
-void MessageArena::DeleteLastMessageInternal() {
-  PERFETTO_DCHECK(!blocks_.empty());  // Should never be empty, see below.
-  Block* block = &blocks_.front();
-  PERFETTO_DCHECK(block->entries > 0);
+void LockFreeTaskRunner::Quit() {
+  // We have to post the writing of the quit if we are not on the right thread.
+  // The alternative would be writing quit_ + WakeUp(), but that is racy:
+  // - We write quit_=true from another thread
+  // - The main thread sees it immediately (it just happens to be iterating)
+  //   and destroys itself.
+  // - We try to call WakeUp() while the main thread is being destroyed.
+  if (!RunsTasksOnCurrentThread()) {
+    PostTask([this] { this->Quit(); });
+    return;
+  }
+  quit_ = true;
+}
 
-  // This is the reason why there is no ~Message() call here.
-  // MessageArea::Reset() (see header) also relies on dtor being trivial.
-  static_assert(std::is_trivially_destructible<Message>::value,
-                "Message must be trivially destructible");
+bool LockFreeTaskRunner::IsIdleForTesting() {
+  PERFETTO_DCHECK(RunsTasksOnCurrentThread());
+  for (Slab* slab = tail_; slab; slab = slab->prev) {
+    for (size_t i = 0; i < Slab::kNumWords; ++i) {
+      if (slab->tasks_written[i] & ~slab->tasks_read[i]) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
 
-  --block->entries;
-  PERFETTO_ASAN_POISON(&block->storage[block->entries], sizeof(Message));
+std::function<void()> LockFreeTaskRunner::PopNextExpiredDelayedTask() {
+  PERFETTO_DCHECK(RunsTasksOnCurrentThread());
+  TimeMillis now =
+      GetWallTimeMs() +
+      TimeMillis(advanced_time_for_testing_.load(std::memory_order_relaxed));
+  if (!delayed_tasks_.empty() && delayed_tasks_.back().time <= now) {
+    auto task = std::move(delayed_tasks_.back().task);
+    delayed_tasks_.pop_back();
+    return task;
+  }
+  return nullptr;
+}
 
-  // Don't remove the first block to avoid malloc/free calls when the root
-  // message is reset. Hitting the allocator all the times is a waste of time.
-  if (block->entries == 0 && std::next(blocks_.cbegin()) != blocks_.cend()) {
-    blocks_.pop_front();
+int LockFreeTaskRunner::GetDelayMsToNextTask() const {
+  PERFETTO_DCHECK(RunsTasksOnCurrentThread());
+  if (delayed_tasks_.empty()) {
+    return -1;  // Forever.
+  }
+  TimeMillis now =
+      GetWallTimeMs() +
+      TimeMillis(advanced_time_for_testing_.load(std::memory_order_relaxed));
+  TimeMillis deadline = delayed_tasks_.back().time;
+  if (deadline <= now) {
+    return 0;
   }
+  return static_cast<int>((deadline - now).count());
 }
 
-}  // namespace protozero
-// gen_amalgamated begin source: src/protozero/message_handle.cc
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+LockFreeTaskRunner::Slab* LockFreeTaskRunner::AllocNewSlab() {
+  Slab* free_slab = free_slab_.exchange(nullptr);
+  if (free_slab) {
+    free_slab->~Slab();
+    new (free_slab) Slab();
+    return free_slab;
+  }
+  slabs_allocated_.fetch_add(1, std::memory_order_relaxed);
+  return new Slab();
+}
 
-// gen_amalgamated expanded: #include "perfetto/protozero/message_handle.h"
+void LockFreeTaskRunner::DeleteSlab(Slab* slab) {
+  PERFETTO_DCHECK(!slab->prev);  // We should never delete a linked slab.
+  Slab* null_slab = nullptr;
+  if (!free_slab_.compare_exchange_strong(null_slab, slab)) {
+    slabs_freed_.fetch_add(1, std::memory_order_relaxed);
+    delete slab;
+  }
+}
 
-#include <utility>
+void LockFreeTaskRunner::PostDelayedTask(std::function<void()> task,
+                                         uint32_t delay_ms) {
+  if (!RunsTasksOnCurrentThread()) {
+    PostTask([this, task = std::move(task), delay_ms] {
+      this->PostDelayedTask(std::move(task), delay_ms);
+    });
+    return;
+  }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+  TimeMillis runtime =
+      GetWallTimeMs() + TimeMillis(delay_ms) +
+      TimeMillis(advanced_time_for_testing_.load(std::memory_order_relaxed));
+  delayed_tasks_.insert(
+      DelayedTask{runtime, next_delayed_task_seq_++, std::move(task)});
+}
 
-namespace protozero {
+void LockFreeTaskRunner::AdvanceTimeForTesting(uint32_t ms) {
+  advanced_time_for_testing_.fetch_add(ms);
+  WakeUp();
+}
 
-MessageHandleBase::MessageHandleBase(Message* message) : message_(message) {
-#if PERFETTO_DCHECK_IS_ON()
-  generation_ = message_ ? message->generation_ : 0;
-  if (message_)
-    message_->set_handle(this);
+void LockFreeTaskRunner::PostFileDescriptorWatches(
+    uint64_t windows_wait_result) {
+  PERFETTO_DCHECK(RunsTasksOnCurrentThread());
+  for (size_t i = 0; i < poll_fds_.size(); i++) {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+    const PlatformHandle handle = poll_fds_[i];
+    // |windows_wait_result| is the result of WaitForMultipleObjects() call. If
+    // one of the objects was signalled, it will have a value between
+    // [0, poll_fds_.size()].
+    if (i != windows_wait_result &&
+        WaitForSingleObject(handle, 0) != WAIT_OBJECT_0) {
+      continue;
+    }
+#else
+    base::ignore_result(windows_wait_result);
+    const PlatformHandle handle = poll_fds_[i].fd;
+    if (!(poll_fds_[i].revents & (POLLIN | POLLHUP)))
+      continue;
+    poll_fds_[i].revents = 0;
 #endif
-}
 
-MessageHandleBase::~MessageHandleBase() {
-  if (message_) {
-#if PERFETTO_DCHECK_IS_ON()
-    PERFETTO_DCHECK(generation_ == message_->generation_);
+    // The wake-up event is handled inline to avoid an infinite recursion of
+    // posted tasks.
+    if (handle == wakeup_event_.fd()) {
+      wakeup_event_.Clear();
+      continue;
+    }
+
+    // Binding to |this| is safe since we are the only object executing the
+    // task.
+    PostTask([this, handle] { this->RunFileDescriptorWatch(handle); });
+
+    // Flag the task as pending.
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+    // On Windows this is done by marking the WatchTask entry as pending. This
+    // is more expensive than Linux as requires rebuilding the |poll_fds_|
+    // vector on each call. There doesn't seem to be a good alternative though.
+    auto it = watch_tasks_.find(handle);
+    PERFETTO_CHECK(it != watch_tasks_.end());
+    PERFETTO_DCHECK(!it->second.pending);
+    it->second.pending = true;
+#else
+    // On UNIX systems instead, we just make the fd negative while its task is
+    // pending. This makes poll(2) ignore the fd.
+    PERFETTO_DCHECK(poll_fds_[i].fd >= 0);
+    poll_fds_[i].fd = -poll_fds_[i].fd;
 #endif
-    FinalizeMessage();
   }
 }
 
-MessageHandleBase::MessageHandleBase(MessageHandleBase&& other) noexcept {
-  Move(std::move(other));
+void LockFreeTaskRunner::RunFileDescriptorWatch(PlatformHandle fd) {
+  PERFETTO_DCHECK(RunsTasksOnCurrentThread());
+
+  std::function<void()> task;
+  auto it = watch_tasks_.find(fd);
+  if (it == watch_tasks_.end())
+    return;
+  WatchTask& watch_task = it->second;
+
+  // Make poll(2) pay attention to the fd again. Since another thread may have
+  // updated this watch we need to refresh the set first.
+  UpdateWatchTasks();
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  // On Windows we manually track the presence of outstanding tasks for the
+  // watch. The UpdateWatchTasksLocked() in the Run() loop will re-add the
+  // task to the |poll_fds_| vector.
+  PERFETTO_DCHECK(watch_task.pending);
+  watch_task.pending = false;
+#else
+  size_t fd_index = watch_task.poll_fd_index;
+  PERFETTO_DCHECK(fd_index < poll_fds_.size());
+  PERFETTO_DCHECK(::abs(poll_fds_[fd_index].fd) == fd);
+  poll_fds_[fd_index].fd = fd;
+#endif
+  task = watch_task.callback;
+  errno = 0;
+  RunTaskWithWatchdogGuard(task);
 }
 
-MessageHandleBase& MessageHandleBase::operator=(MessageHandleBase&& other) {
-  // If the current handle was pointing to a message and is being reset to a new
-  // one, finalize the old message. However, if the other message is the same as
-  // the one we point to, don't finalize.
-  if (message_ && message_ != other.message_)
-    FinalizeMessage();
-  Move(std::move(other));
-  return *this;
+void LockFreeTaskRunner::UpdateWatchTasks() {
+  PERFETTO_DCHECK(RunsTasksOnCurrentThread());
+#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  if (!watch_tasks_changed_)
+    return;
+  watch_tasks_changed_ = false;
+#endif
+  poll_fds_.clear();
+  for (auto& it : watch_tasks_) {
+    PlatformHandle handle = it.first;
+    WatchTask& watch_task = it.second;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+    if (!watch_task.pending)
+      poll_fds_.push_back(handle);
+#else
+    watch_task.poll_fd_index = poll_fds_.size();
+    poll_fds_.push_back({handle, POLLIN | POLLHUP, 0});
+#endif
+  }
 }
 
-void MessageHandleBase::Move(MessageHandleBase&& other) {
-  message_ = other.message_;
-  other.message_ = nullptr;
-#if PERFETTO_DCHECK_IS_ON()
-  if (message_) {
-    generation_ = message_->generation_;
-    message_->set_handle(this);
+void LockFreeTaskRunner::AddFileDescriptorWatch(PlatformHandle fd,
+                                                std::function<void()> task) {
+  PERFETTO_DCHECK(PlatformHandleChecker::IsValid(fd));
+
+  if (!RunsTasksOnCurrentThread()) {
+    PostTask([this, task = std::move(task), fd] {
+      this->AddFileDescriptorWatch(fd, std::move(task));
+    });
+    return;
   }
+
+  PERFETTO_DCHECK(!watch_tasks_.count(fd));
+  WatchTask& watch_task = watch_tasks_[fd];
+  watch_task.callback = std::move(task);
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  watch_task.pending = false;
+#else
+  watch_task.poll_fd_index = SIZE_MAX;
 #endif
+  watch_tasks_changed_ = true;
 }
 
-}  // namespace protozero
-// gen_amalgamated begin source: src/protozero/packed_repeated_fields.cc
+void LockFreeTaskRunner::RemoveFileDescriptorWatch(PlatformHandle fd) {
+  if (!RunsTasksOnCurrentThread()) {
+    PostTask([this, fd] { this->RemoveFileDescriptorWatch(fd); });
+    return;
+  }
+
+  PERFETTO_DCHECK(watch_tasks_.count(fd));
+  watch_tasks_.erase(fd);
+  watch_tasks_changed_ = true;
+}
+
+bool LockFreeTaskRunner::RunsTasksOnCurrentThread() const {
+  return run_task_thread_id_ == std::this_thread::get_id();
+}
+
+}  // namespace base
+}  // namespace perfetto
+// gen_amalgamated begin source: src/base/thread_task_runner.cc
+// gen_amalgamated begin header: include/perfetto/ext/base/thread_task_runner.h
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -10439,41 +11871,81 @@ void MessageHandleBase::Move(MessageHandleBase&& other) {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+#ifndef INCLUDE_PERFETTO_EXT_BASE_THREAD_TASK_RUNNER_H_
+#define INCLUDE_PERFETTO_EXT_BASE_THREAD_TASK_RUNNER_H_
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
+#include <functional>
+#include <thread>
 
-namespace protozero {
+// gen_amalgamated expanded: #include "perfetto/ext/base/lock_free_task_runner.h"
 
-#if !PERFETTO_IS_AT_LEAST_CPP17()
-// static
-constexpr size_t PackedBufferBase::kOnStackStorageSize;
-#endif
+namespace perfetto {
+namespace base {
 
-void PackedBufferBase::GrowSlowpath() {
-  size_t write_off = static_cast<size_t>(write_ptr_ - storage_begin_);
-  size_t old_size = static_cast<size_t>(storage_end_ - storage_begin_);
-  size_t new_size = old_size < 65536 ? (old_size * 2) : (old_size * 3 / 2);
-  new_size = perfetto::base::AlignUp<4096>(new_size);
-  std::unique_ptr<uint8_t[]> new_buf(new uint8_t[new_size]);
-  memcpy(new_buf.get(), storage_begin_, old_size);
-  heap_buf_ = std::move(new_buf);
-  storage_begin_ = heap_buf_.get();
-  storage_end_ = storage_begin_ + new_size;
-  write_ptr_ = storage_begin_ + write_off;
-}
+// A MaybeLockFreeTaskRunner backed by a dedicated task thread. Shuts down the
+// runner and joins the thread upon destruction. Can be moved to transfer
+// ownership.
+//
+// Guarantees that:
+// * the MaybeLockFreeTaskRunner will be constructed and destructed on the task
+// thread.
+// * the task thread will live for the lifetime of the MaybeLockFreeTaskRunner.
+//
+class PERFETTO_EXPORT_COMPONENT ThreadTaskRunner : public TaskRunner {
+ public:
+  static ThreadTaskRunner CreateAndStart(const std::string& name = "") {
+    return ThreadTaskRunner(name);
+  }
 
-void PackedBufferBase::Reset() {
-  heap_buf_.reset();
-  storage_begin_ = reinterpret_cast<uint8_t*>(&stack_buf_[0]);
-  storage_end_ = reinterpret_cast<uint8_t*>(&stack_buf_[kOnStackStorageSize]);
-  write_ptr_ = storage_begin_;
-}
+  ThreadTaskRunner(const ThreadTaskRunner&) = delete;
+  ThreadTaskRunner& operator=(const ThreadTaskRunner&) = delete;
 
-}  // namespace protozero
-// gen_amalgamated begin source: src/protozero/proto_decoder.cc
+  ThreadTaskRunner(ThreadTaskRunner&&) noexcept;
+  ThreadTaskRunner& operator=(ThreadTaskRunner&&);
+  ~ThreadTaskRunner() override;
+
+  // Executes the given function on the task runner thread and blocks the caller
+  // thread until the function has run.
+  void PostTaskAndWaitForTesting(std::function<void()>);
+
+  // Can be called from another thread to get the CPU time of the thread the
+  // task-runner is executing on.
+  uint64_t GetThreadCPUTimeNsForTesting();
+
+  PlatformThreadId GetThreadIdForTesting();
+
+  // Returns a pointer to the MaybeLockFreeTaskRunner, which is valid for the
+  // lifetime of this ThreadTaskRunner object (unless this object is moved-from,
+  // in which case the pointer remains valid for the lifetime of the new owning
+  // ThreadTaskRunner).
+  //
+  // Warning: do not call Quit() on the returned runner pointer, the termination
+  // should be handled exclusively by this class' destructor.
+  MaybeLockFreeTaskRunner* get() const { return task_runner_; }
+
+  // TaskRunner implementation.
+  // These methods just proxy to the underlying task_runner_.
+  void PostTask(std::function<void()>) override;
+  void PostDelayedTask(std::function<void()>, uint32_t delay_ms) override;
+  void AddFileDescriptorWatch(PlatformHandle, std::function<void()>) override;
+  void RemoveFileDescriptorWatch(PlatformHandle) override;
+  bool RunsTasksOnCurrentThread() const override;
+
+ private:
+  explicit ThreadTaskRunner(const std::string& name);
+  void RunTaskThread(std::function<void(MaybeLockFreeTaskRunner*)> initializer);
+
+  std::thread thread_;
+  std::string name_;
+  MaybeLockFreeTaskRunner* task_runner_ = nullptr;
+};
+
+}  // namespace base
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_THREAD_TASK_RUNNER_H_
 /*
- * Copyright (C) 2018 The Android Open Source Project
+ * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -10488,255 +11960,136 @@ void PackedBufferBase::Reset() {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
 
-#include <string.h>
+// gen_amalgamated expanded: #include "perfetto/ext/base/thread_task_runner.h"
 
-#include <cinttypes>
-#include <limits>
-#include <memory>
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+#include <thread>
 
-// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace protozero {
-
-using namespace proto_utils;
+// gen_amalgamated expanded: #include "perfetto/ext/base/lock_free_task_runner.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/thread_utils.h"
 
-#if !PERFETTO_IS_LITTLE_ENDIAN()
-#error Unimplemented for big endian archs.
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX_BUT_NOT_QNX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+#include <sys/prctl.h>
 #endif
 
-namespace {
-
-struct ParseFieldResult {
-  enum ParseResult { kAbort, kSkip, kOk };
-  ParseResult parse_res;
-  const uint8_t* next;
-  Field field;
-};
+namespace perfetto {
+namespace base {
 
-// Parses one field and returns the field itself and a pointer to the next
-// field to parse. If parsing fails, the returned |next| == |buffer|.
-ParseFieldResult ParseOneField(const uint8_t* const buffer,
-                               const uint8_t* const end) {
-  ParseFieldResult res{ParseFieldResult::kAbort, buffer, Field{}};
+ThreadTaskRunner::ThreadTaskRunner(ThreadTaskRunner&& other) noexcept
+    : thread_(std::move(other.thread_)), task_runner_(other.task_runner_) {
+  other.task_runner_ = nullptr;
+}
 
-  // The first byte of a proto field is structured as follows:
-  // The least 3 significant bits determine the field type.
-  // The most 5 significant bits determine the field id. If MSB == 1, the
-  // field id continues on the next bytes following the VarInt encoding.
-  const uint8_t kFieldTypeNumBits = 3;
-  const uint64_t kFieldTypeMask = (1 << kFieldTypeNumBits) - 1;  // 0000 0111;
-  const uint8_t* pos = buffer;
+ThreadTaskRunner& ThreadTaskRunner::operator=(ThreadTaskRunner&& other) {
+  this->~ThreadTaskRunner();
+  new (this) ThreadTaskRunner(std::move(other));
+  return *this;
+}
 
-  // If we've already hit the end, just return an invalid field.
-  if (PERFETTO_UNLIKELY(pos >= end))
-    return res;
+ThreadTaskRunner::~ThreadTaskRunner() {
+  if (task_runner_) {
+    task_runner_->Quit();
 
-  uint64_t preamble = 0;
-  if (PERFETTO_LIKELY(*pos < 0x80)) {  // Fastpath for fields with ID < 16.
-    preamble = *(pos++);
-  } else {
-    const uint8_t* next = ParseVarInt(pos, end, &preamble);
-    if (PERFETTO_UNLIKELY(pos == next))
-      return res;
-    pos = next;
+    PERFETTO_DCHECK(thread_.joinable());
   }
+  if (thread_.joinable())
+    thread_.join();
+}
 
-  uint32_t field_id = static_cast<uint32_t>(preamble >> kFieldTypeNumBits);
-  if (field_id == 0 || pos >= end)
-    return res;
-
-  auto field_type = static_cast<uint8_t>(preamble & kFieldTypeMask);
-  const uint8_t* new_pos = pos;
-  uint64_t int_value = 0;
-  uint64_t size = 0;
-
-  switch (field_type) {
-    case static_cast<uint8_t>(ProtoWireType::kVarInt): {
-      new_pos = ParseVarInt(pos, end, &int_value);
-
-      // new_pos not being greater than pos means ParseVarInt could not fully
-      // parse the number. This is because we are out of space in the buffer.
-      // Set the id to zero and return but don't update the offset so a future
-      // read can read this field.
-      if (PERFETTO_UNLIKELY(new_pos == pos))
-        return res;
-
-      break;
-    }
-
-    case static_cast<uint8_t>(ProtoWireType::kLengthDelimited): {
-      uint64_t payload_length;
-      new_pos = ParseVarInt(pos, end, &payload_length);
-      if (PERFETTO_UNLIKELY(new_pos == pos))
-        return res;
-
-      // ParseVarInt guarantees that |new_pos| <= |end| when it succeeds;
-      if (payload_length > static_cast<uint64_t>(end - new_pos))
-        return res;
+ThreadTaskRunner::ThreadTaskRunner(const std::string& name) : name_(name) {
+  std::mutex init_lock;
+  std::condition_variable init_cv;
 
-      const uintptr_t payload_start = reinterpret_cast<uintptr_t>(new_pos);
-      int_value = payload_start;
-      size = payload_length;
-      new_pos += payload_length;
-      break;
-    }
+  std::function<void(MaybeLockFreeTaskRunner*)> initializer =
+      [this, &init_lock, &init_cv](MaybeLockFreeTaskRunner* task_runner) {
+        std::lock_guard<std::mutex> lock(init_lock);
+        task_runner_ = task_runner;
+        // Notify while still holding the lock, as init_cv ceases to exist as
+        // soon as the main thread observes a non-null task_runner_, and it can
+        // wake up spuriously (i.e. before the notify if we had unlocked before
+        // notifying).
+        init_cv.notify_one();
+      };
 
-    case static_cast<uint8_t>(ProtoWireType::kFixed64): {
-      new_pos = pos + sizeof(uint64_t);
-      if (PERFETTO_UNLIKELY(new_pos > end))
-        return res;
-      memcpy(&int_value, pos, sizeof(uint64_t));
-      break;
-    }
+  thread_ = std::thread(&ThreadTaskRunner::RunTaskThread, this,
+                        std::move(initializer));
 
-    case static_cast<uint8_t>(ProtoWireType::kFixed32): {
-      new_pos = pos + sizeof(uint32_t);
-      if (PERFETTO_UNLIKELY(new_pos > end))
-        return res;
-      memcpy(&int_value, pos, sizeof(uint32_t));
-      break;
-    }
+  std::unique_lock<std::mutex> lock(init_lock);
+  init_cv.wait(lock, [this] { return !!task_runner_; });
+}
 
-    default:
-      PERFETTO_DLOG("Invalid proto field type: %u", field_type);
-      return res;
+void ThreadTaskRunner::RunTaskThread(
+    std::function<void(MaybeLockFreeTaskRunner*)> initializer) {
+  if (!name_.empty()) {
+    base::MaybeSetThreadName(name_);
   }
 
-  res.next = new_pos;
+  MaybeLockFreeTaskRunner task_runner;
+  task_runner.PostTask(std::bind(std::move(initializer), &task_runner));
+  task_runner.Run();
+}
 
-  if (PERFETTO_UNLIKELY(field_id > std::numeric_limits<uint16_t>::max())) {
-    PERFETTO_DLOG("Skipping field %" PRIu32 " because its id > 0xFFFF",
-                  field_id);
-    res.parse_res = ParseFieldResult::kSkip;
-    return res;
-  }
+void ThreadTaskRunner::PostTaskAndWaitForTesting(std::function<void()> fn) {
+  std::mutex mutex;
+  std::condition_variable cv;
 
-  if (PERFETTO_UNLIKELY(size > proto_utils::kMaxMessageLength)) {
-    PERFETTO_DLOG("Skipping field %" PRIu32 " because it's too big (%" PRIu64
-                  " KB)",
-                  field_id, size / 1024);
-    res.parse_res = ParseFieldResult::kSkip;
-    return res;
-  }
+  std::unique_lock<std::mutex> lock(mutex);
+  bool done = false;
+  task_runner_->PostTask([&mutex, &cv, &done, &fn] {
+    fn();
 
-  res.parse_res = ParseFieldResult::kOk;
-  res.field.initialize(static_cast<uint16_t>(field_id), field_type, int_value,
-                       static_cast<uint32_t>(size));
-  return res;
+    std::lock_guard<std::mutex> inner_lock(mutex);
+    done = true;
+    cv.notify_one();
+  });
+  cv.wait(lock, [&done] { return done; });
 }
 
-}  // namespace
-
-Field ProtoDecoder::FindField(uint32_t field_id) {
-  Field res{};
-  auto old_position = read_ptr_;
-  read_ptr_ = begin_;
-  for (auto f = ReadField(); f.valid(); f = ReadField()) {
-    if (f.id() == field_id) {
-      res = f;
-      break;
-    }
-  }
-  read_ptr_ = old_position;
-  return res;
+uint64_t ThreadTaskRunner::GetThreadCPUTimeNsForTesting() {
+  uint64_t thread_time_ns = 0;
+  PostTaskAndWaitForTesting([&thread_time_ns] {
+    thread_time_ns = static_cast<uint64_t>(base::GetThreadCPUTimeNs().count());
+  });
+  return thread_time_ns;
 }
-
-Field ProtoDecoder::ReadField() {
-  ParseFieldResult res;
-  do {
-    res = ParseOneField(read_ptr_, end_);
-    read_ptr_ = res.next;
-  } while (PERFETTO_UNLIKELY(res.parse_res == ParseFieldResult::kSkip));
-  return res.field;
+PlatformThreadId ThreadTaskRunner::GetThreadIdForTesting() {
+  PlatformThreadId thread_id = static_cast<PlatformThreadId>(-1);
+  PostTaskAndWaitForTesting([&thread_id] { thread_id = GetThreadId(); });
+  return thread_id;
 }
 
-void TypedProtoDecoderBase::ParseAllFields() {
-  const uint8_t* cur = begin_;
-  ParseFieldResult res;
-  for (;;) {
-    res = ParseOneField(cur, end_);
-    PERFETTO_DCHECK(res.parse_res != ParseFieldResult::kOk || res.next != cur);
-    cur = res.next;
-    if (PERFETTO_UNLIKELY(res.parse_res == ParseFieldResult::kSkip))
-      continue;
-    if (PERFETTO_UNLIKELY(res.parse_res == ParseFieldResult::kAbort))
-      break;
-
-    PERFETTO_DCHECK(res.parse_res == ParseFieldResult::kOk);
-    PERFETTO_DCHECK(res.field.valid());
-    auto field_id = res.field.id();
-    if (PERFETTO_UNLIKELY(field_id >= num_fields_))
-      continue;
-
-    // There are two reasons why we might want to expand the heap capacity:
-    // 1. We are writing a non-repeated field, which has an id >
-    //    INITIAL_STACK_CAPACITY. In this case ExpandHeapStorage() ensures to
-    //    allocate at least (num_fields_ + 1) slots.
-    // 2. We are writing a repeated field but ran out of capacity.
-    if (PERFETTO_UNLIKELY(field_id >= size_ || size_ >= capacity_))
-      ExpandHeapStorage();
-
-    PERFETTO_DCHECK(field_id < size_);
-    Field* fld = &fields_[field_id];
-    if (PERFETTO_LIKELY(!fld->valid())) {
-      // This is the first time we see this field.
-      *fld = std::move(res.field);
-    } else {
-      // Repeated field case.
-      // In this case we need to:
-      // 1. Append the last value of the field to end of the repeated field
-      //    storage.
-      // 2. Replace the default instance at offset |field_id| with the current
-      //    value. This is because in case of repeated field a call to Get(X) is
-      //    supposed to return the last value of X, not the first one.
-      // This is so that the RepeatedFieldIterator will iterate in the right
-      // order, see comments on RepeatedFieldIterator.
-      PERFETTO_DCHECK(size_ < capacity_);
-      fields_[size_++] = *fld;
-      *fld = std::move(res.field);
-    }
-  }
-  read_ptr_ = res.next;
+void ThreadTaskRunner::PostTask(std::function<void()> task) {
+  task_runner_->PostTask(std::move(task));
 }
 
-void TypedProtoDecoderBase::ExpandHeapStorage() {
-  // When we expand the heap we must ensure that we have at very last capacity
-  // to deal with all known fields plus at least one repeated field. We go +2048
-  // here based on observations on a large 4GB android trace. This is to avoid
-  // trivial re-allocations when dealing with repeated fields of a message that
-  // has > INITIAL_STACK_CAPACITY fields.
-  const uint32_t min_capacity = num_fields_ + 2048;  // Any num >= +1 will do.
-  const uint32_t new_capacity = std::max(capacity_ * 2, min_capacity);
-  PERFETTO_CHECK(new_capacity > size_ && new_capacity > num_fields_);
-  std::unique_ptr<Field[]> new_storage(new Field[new_capacity]);
-
-  static_assert(std::is_trivially_constructible<Field>::value,
-                "Field must be trivially constructible");
-  static_assert(std::is_trivially_copyable<Field>::value,
-                "Field must be trivially copyable");
+void ThreadTaskRunner::PostDelayedTask(std::function<void()> task,
+                                       uint32_t delay_ms) {
+  task_runner_->PostDelayedTask(std::move(task), delay_ms);
+}
 
-  // Zero-initialize the slots for known field IDs slots, as they can be
-  // randomly accessed. Instead, there is no need to initialize the repeated
-  // slots, because they are written linearly with no gaps and are always
-  // initialized before incrementing |size_|.
-  const uint32_t new_size = std::max(size_, num_fields_);
-  memset(&new_storage[size_], 0, sizeof(Field) * (new_size - size_));
+void ThreadTaskRunner::AddFileDescriptorWatch(
+    PlatformHandle handle,
+    std::function<void()> watch_task) {
+  task_runner_->AddFileDescriptorWatch(handle, std::move(watch_task));
+}
 
-  memcpy(&new_storage[0], fields_, sizeof(Field) * size_);
+void ThreadTaskRunner::RemoveFileDescriptorWatch(PlatformHandle handle) {
+  task_runner_->RemoveFileDescriptorWatch(handle);
+}
 
-  heap_storage_ = std::move(new_storage);
-  fields_ = &heap_storage_[0];
-  capacity_ = new_capacity;
-  size_ = new_size;
+bool ThreadTaskRunner::RunsTasksOnCurrentThread() const {
+  return task_runner_->RunsTasksOnCurrentThread();
 }
 
-}  // namespace protozero
-// gen_amalgamated begin source: src/protozero/scattered_heap_buffer.cc
+}  // namespace base
+}  // namespace perfetto
+// gen_amalgamated begin source: src/base/unix_task_runner.cc
 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
@@ -10753,293 +12106,311 @@ void TypedProtoDecoderBase::ExpandHeapStorage() {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-
-#include <algorithm>
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
 
-namespace protozero {
+// gen_amalgamated expanded: #include "perfetto/ext/base/platform.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/unix_task_runner.h"
 
-ScatteredHeapBuffer::Slice::Slice()
-    : buffer_(nullptr), size_(0u), unused_bytes_(0u) {}
+#include <errno.h>
+#include <stdlib.h>
 
-ScatteredHeapBuffer::Slice::Slice(size_t size)
-    : buffer_(std::unique_ptr<uint8_t[]>(new uint8_t[size])),
-      size_(size),
-      unused_bytes_(size) {
-  PERFETTO_DCHECK(size);
-  Clear();
-}
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+#include <windows.h>
 
-ScatteredHeapBuffer::Slice::Slice(Slice&& slice) noexcept = default;
+#include <synchapi.h>
+#else
+#include <unistd.h>
+#endif
 
-ScatteredHeapBuffer::Slice::~Slice() = default;
+#include <algorithm>
+#include <limits>
 
-ScatteredHeapBuffer::Slice& ScatteredHeapBuffer::Slice::operator=(Slice&&) =
-    default;
+// gen_amalgamated expanded: #include "perfetto/ext/base/watchdog.h"
 
-void ScatteredHeapBuffer::Slice::Clear() {
-  unused_bytes_ = size_;
-#if PERFETTO_DCHECK_IS_ON()
-  memset(start(), 0xff, size_);
-#endif  // PERFETTO_DCHECK_IS_ON()
-}
+namespace perfetto {
+namespace base {
 
-ScatteredHeapBuffer::ScatteredHeapBuffer(size_t initial_slice_size_bytes,
-                                         size_t maximum_slice_size_bytes)
-    : next_slice_size_(initial_slice_size_bytes),
-      maximum_slice_size_(maximum_slice_size_bytes) {
-  PERFETTO_DCHECK(next_slice_size_ && maximum_slice_size_);
-  PERFETTO_DCHECK(maximum_slice_size_ >= initial_slice_size_bytes);
+UnixTaskRunner::UnixTaskRunner() {
+  AddFileDescriptorWatch(event_.fd(), [] {
+    // Not reached -- see PostFileDescriptorWatches().
+    PERFETTO_DFATAL("Should be unreachable.");
+  });
 }
 
-ScatteredHeapBuffer::~ScatteredHeapBuffer() = default;
-
-protozero::ContiguousMemoryRange ScatteredHeapBuffer::GetNewBuffer() {
-  PERFETTO_CHECK(writer_);
-  AdjustUsedSizeOfCurrentSlice();
+UnixTaskRunner::~UnixTaskRunner() = default;
 
-  if (cached_slice_.start()) {
-    slices_.push_back(std::move(cached_slice_));
-    PERFETTO_DCHECK(!cached_slice_.start());
-  } else {
-    slices_.emplace_back(next_slice_size_);
-  }
-  next_slice_size_ = std::min(maximum_slice_size_, next_slice_size_ * 2);
-  return slices_.back().GetTotalRange();
+void UnixTaskRunner::WakeUp() {
+  event_.Notify();
 }
 
-const std::vector<ScatteredHeapBuffer::Slice>&
-ScatteredHeapBuffer::GetSlices() {
-  AdjustUsedSizeOfCurrentSlice();
-  return slices_;
-}
+void UnixTaskRunner::Run() {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  created_thread_id_.store(GetThreadId(), std::memory_order_relaxed);
+  {
+    std::lock_guard<base::MaybeRtMutex> lock(lock_);
+    quit_ = false;
+  }
+  for (;;) {
+    int poll_timeout_ms;
+    {
+      std::lock_guard<base::MaybeRtMutex> lock(lock_);
+      if (quit_)
+        return;
+      poll_timeout_ms = GetDelayMsToNextTaskLocked();
+      UpdateWatchTasksLocked();
+    }
 
-std::vector<uint8_t> ScatteredHeapBuffer::StitchSlices() {
-  size_t stitched_size = 0u;
-  const auto& slices = GetSlices();
-  for (const auto& slice : slices)
-    stitched_size += slice.size() - slice.unused_bytes();
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+    DWORD timeout =
+        poll_timeout_ms >= 0 ? static_cast<DWORD>(poll_timeout_ms) : INFINITE;
+    DWORD ret =
+        WaitForMultipleObjects(static_cast<DWORD>(poll_fds_.size()),
+                               &poll_fds_[0], /*bWaitAll=*/false, timeout);
+    // Unlike poll(2), WaitForMultipleObjects() returns only *one* handle in the
+    // set, even when >1 is signalled. In order to avoid starvation,
+    // PostFileDescriptorWatches() will WaitForSingleObject() each other handle
+    // to ensure fairness. |ret| here is passed just to avoid an extra
+    // WaitForSingleObject() for the one handle that WaitForMultipleObject()
+    // returned.
+    PostFileDescriptorWatches(ret);
+#else
+    platform::BeforeMaybeBlockingSyscall();
+    int ret = PERFETTO_EINTR(poll(
+        &poll_fds_[0], static_cast<nfds_t>(poll_fds_.size()), poll_timeout_ms));
+    platform::AfterMaybeBlockingSyscall();
+    PERFETTO_CHECK(ret >= 0);
+    PostFileDescriptorWatches(0 /*ignored*/);
+#endif
 
-  std::vector<uint8_t> buffer;
-  buffer.reserve(stitched_size);
-  for (const auto& slice : slices) {
-    auto used_range = slice.GetUsedRange();
-    buffer.insert(buffer.end(), used_range.begin, used_range.end);
+    // To avoid starvation we always interleave all types of tasks -- immediate,
+    // delayed and file descriptor watches.
+    RunImmediateAndDelayedTask();
   }
-  return buffer;
 }
 
-std::vector<protozero::ContiguousMemoryRange> ScatteredHeapBuffer::GetRanges() {
-  std::vector<protozero::ContiguousMemoryRange> ranges;
-  for (const auto& slice : GetSlices())
-    ranges.push_back(slice.GetUsedRange());
-  return ranges;
+void UnixTaskRunner::Quit() {
+  std::lock_guard<base::MaybeRtMutex> lock(lock_);
+  quit_ = true;
+  WakeUp();
 }
 
-void ScatteredHeapBuffer::AdjustUsedSizeOfCurrentSlice() {
-  if (!slices_.empty())
-    slices_.back().set_unused_bytes(writer_->bytes_available());
+bool UnixTaskRunner::QuitCalled() {
+  std::lock_guard<base::MaybeRtMutex> lock(lock_);
+  return quit_;
 }
 
-size_t ScatteredHeapBuffer::GetTotalSize() {
-  size_t total_size = 0;
-  for (auto& slice : slices_) {
-    total_size += slice.size();
-  }
-  return total_size;
+bool UnixTaskRunner::IsIdleForTesting() {
+  std::lock_guard<base::MaybeRtMutex> lock(lock_);
+  return immediate_tasks_.empty();
 }
 
-void ScatteredHeapBuffer::Reset() {
-  if (slices_.empty())
-    return;
-  cached_slice_ = std::move(slices_.front());
-  cached_slice_.Clear();
-  slices_.clear();
+void UnixTaskRunner::AdvanceTimeForTesting(uint32_t ms) {
+  std::lock_guard<base::MaybeRtMutex> lock(lock_);
+  advanced_time_for_testing_ += TimeMillis(ms);
 }
 
-}  // namespace protozero
-// gen_amalgamated begin source: src/protozero/scattered_stream_null_delegate.cc
-// gen_amalgamated begin header: include/perfetto/protozero/scattered_stream_null_delegate.h
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef INCLUDE_PERFETTO_PROTOZERO_SCATTERED_STREAM_NULL_DELEGATE_H_
-#define INCLUDE_PERFETTO_PROTOZERO_SCATTERED_STREAM_NULL_DELEGATE_H_
-
-#include <memory>
-#include <vector>
-
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/contiguous_memory_range.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_stream_writer.h"
-
-namespace protozero {
-
-class PERFETTO_EXPORT_COMPONENT ScatteredStreamWriterNullDelegate
-    : public ScatteredStreamWriter::Delegate {
- public:
-  explicit ScatteredStreamWriterNullDelegate(size_t chunk_size);
-  ~ScatteredStreamWriterNullDelegate() override;
-
-  // protozero::ScatteredStreamWriter::Delegate implementation.
-  ContiguousMemoryRange GetNewBuffer() override;
-
- private:
-  const size_t chunk_size_;
-  std::unique_ptr<uint8_t[]> chunk_;
-};
-
-}  // namespace protozero
-
-#endif  // INCLUDE_PERFETTO_PROTOZERO_SCATTERED_STREAM_NULL_DELEGATE_H_
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_stream_null_delegate.h"
-
-namespace protozero {
-
-// An implementation of ScatteredStreamWriter::Delegate which always returns
-// the same piece of memory.
-// This is used when we need to no-op the writers (e.g. during teardown or in
-// case of resource exhaustion), avoiding that the clients have to deal with
-// nullptr checks.
-ScatteredStreamWriterNullDelegate::ScatteredStreamWriterNullDelegate(
-    size_t chunk_size)
-    : chunk_size_(chunk_size),
-      chunk_(std::unique_ptr<uint8_t[]>(new uint8_t[chunk_size_])) {}
+void UnixTaskRunner::UpdateWatchTasksLocked() {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  if (!watch_tasks_changed_)
+    return;
+  watch_tasks_changed_ = false;
+#endif
+  poll_fds_.clear();
+  for (auto& it : watch_tasks_) {
+    PlatformHandle handle = it.first;
+    WatchTask& watch_task = it.second;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+    if (!watch_task.pending)
+      poll_fds_.push_back(handle);
+#else
+    watch_task.poll_fd_index = poll_fds_.size();
+    poll_fds_.push_back({handle, POLLIN | POLLHUP, 0});
+#endif
+  }
+}
 
-ScatteredStreamWriterNullDelegate::~ScatteredStreamWriterNullDelegate() {}
+void UnixTaskRunner::RunImmediateAndDelayedTask() {
+  // If locking overhead becomes an issue, add a separate work queue.
+  std::function<void()> immediate_task;
+  std::function<void()> delayed_task;
+  TimeMillis now = GetWallTimeMs();
+  {
+    std::lock_guard<base::MaybeRtMutex> lock(lock_);
+    if (!immediate_tasks_.empty()) {
+      immediate_task = std::move(immediate_tasks_.front());
+      immediate_tasks_.pop_front();
+    }
+    if (!delayed_tasks_.empty()) {
+      auto it = delayed_tasks_.begin();
+      if (now + advanced_time_for_testing_ >= it->first) {
+        delayed_task = std::move(it->second);
+        delayed_tasks_.erase(it);
+      }
+    }
+  }
 
-ContiguousMemoryRange ScatteredStreamWriterNullDelegate::GetNewBuffer() {
-  return {chunk_.get(), chunk_.get() + chunk_size_};
+  errno = 0;
+  if (immediate_task)
+    RunTaskWithWatchdogGuard(immediate_task);
+  errno = 0;
+  if (delayed_task)
+    RunTaskWithWatchdogGuard(delayed_task);
 }
 
-}  // namespace protozero
-// gen_amalgamated begin source: src/protozero/scattered_stream_writer.cc
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+void UnixTaskRunner::PostFileDescriptorWatches(uint64_t windows_wait_result) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  for (size_t i = 0; i < poll_fds_.size(); i++) {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+    const PlatformHandle handle = poll_fds_[i];
+    // |windows_wait_result| is the result of WaitForMultipleObjects() call. If
+    // one of the objects was signalled, it will have a value between
+    // [0, poll_fds_.size()].
+    if (i != windows_wait_result &&
+        WaitForSingleObject(handle, 0) != WAIT_OBJECT_0) {
+      continue;
+    }
+#else
+    base::ignore_result(windows_wait_result);
+    const PlatformHandle handle = poll_fds_[i].fd;
+    if (!(poll_fds_[i].revents & (POLLIN | POLLHUP)))
+      continue;
+    poll_fds_[i].revents = 0;
+#endif
 
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_stream_writer.h"
+    // The wake-up event is handled inline to avoid an infinite recursion of
+    // posted tasks.
+    if (handle == event_.fd()) {
+      event_.Clear();
+      continue;
+    }
 
-#include <algorithm>
+    // Binding to |this| is safe since we are the only object executing the
+    // task.
+    PostTask(std::bind(&UnixTaskRunner::RunFileDescriptorWatch, this, handle));
 
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+    // Flag the task as pending.
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+    // On Windows this is done by marking the WatchTask entry as pending. This
+    // is more expensive than Linux as requires rebuilding the |poll_fds_|
+    // vector on each call. There doesn't seem to be a good alternative though.
+    auto it = watch_tasks_.find(handle);
+    PERFETTO_CHECK(it != watch_tasks_.end());
+    PERFETTO_DCHECK(!it->second.pending);
+    it->second.pending = true;
+#else
+    // On UNIX systems instead, we just make the fd negative while its task is
+    // pending. This makes poll(2) ignore the fd.
+    PERFETTO_DCHECK(poll_fds_[i].fd >= 0);
+    poll_fds_[i].fd = -poll_fds_[i].fd;
+#endif
+  }
+}
 
-namespace protozero {
+void UnixTaskRunner::RunFileDescriptorWatch(PlatformHandle fd) {
+  std::function<void()> task;
+  {
+    std::lock_guard<base::MaybeRtMutex> lock(lock_);
+    auto it = watch_tasks_.find(fd);
+    if (it == watch_tasks_.end())
+      return;
+    WatchTask& watch_task = it->second;
 
-ScatteredStreamWriter::Delegate::~Delegate() {}
+    // Make poll(2) pay attention to the fd again. Since another thread may have
+    // updated this watch we need to refresh the set first.
+    UpdateWatchTasksLocked();
 
-uint8_t* ScatteredStreamWriter::Delegate::AnnotatePatch(uint8_t* patch_addr) {
-  // In most cases, a patch is transparent. The caller can write directly into
-  // `to_patch`, because its memory is not going away. TraceWriterImpl, however,
-  // requires a more complicated logic, because the chunks might be copied
-  // earlier.
-  return patch_addr;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+    // On Windows we manually track the presence of outstanding tasks for the
+    // watch. The UpdateWatchTasksLocked() in the Run() loop will re-add the
+    // task to the |poll_fds_| vector.
+    PERFETTO_DCHECK(watch_task.pending);
+    watch_task.pending = false;
+#else
+    size_t fd_index = watch_task.poll_fd_index;
+    PERFETTO_DCHECK(fd_index < poll_fds_.size());
+    PERFETTO_DCHECK(::abs(poll_fds_[fd_index].fd) == fd);
+    poll_fds_[fd_index].fd = fd;
+#endif
+    task = watch_task.callback;
+  }
+  errno = 0;
+  RunTaskWithWatchdogGuard(task);
 }
 
-ScatteredStreamWriter::ScatteredStreamWriter(Delegate* delegate)
-    : delegate_(delegate),
-      cur_range_({nullptr, nullptr}),
-      write_ptr_(nullptr) {}
-
-ScatteredStreamWriter::~ScatteredStreamWriter() {}
+int UnixTaskRunner::GetDelayMsToNextTaskLocked() const {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  if (!immediate_tasks_.empty())
+    return 0;
+  if (!delayed_tasks_.empty()) {
+    TimeMillis diff = delayed_tasks_.begin()->first - GetWallTimeMs() -
+                      advanced_time_for_testing_;
+    return std::max(0, static_cast<int>(diff.count()));
+  }
+  return -1;
+}
 
-void ScatteredStreamWriter::Reset(ContiguousMemoryRange range) {
-  written_previously_ += static_cast<uint64_t>(write_ptr_ - cur_range_.begin);
-  cur_range_ = range;
-  write_ptr_ = range.begin;
-  PERFETTO_DCHECK(!write_ptr_ || write_ptr_ < cur_range_.end);
+void UnixTaskRunner::PostTask(std::function<void()> task) {
+  bool was_empty;
+  {
+    std::lock_guard<base::MaybeRtMutex> lock(lock_);
+    was_empty = immediate_tasks_.empty();
+    immediate_tasks_.push_back(std::move(task));
+  }
+  if (was_empty)
+    WakeUp();
 }
 
-void ScatteredStreamWriter::Extend() {
-  Reset(delegate_->GetNewBuffer());
+void UnixTaskRunner::PostDelayedTask(std::function<void()> task,
+                                     uint32_t delay_ms) {
+  TimeMillis runtime = GetWallTimeMs() + TimeMillis(delay_ms);
+  {
+    std::lock_guard<base::MaybeRtMutex> lock(lock_);
+    delayed_tasks_.insert(
+        std::make_pair(runtime + advanced_time_for_testing_, std::move(task)));
+  }
+  WakeUp();
 }
 
-void ScatteredStreamWriter::WriteBytesSlowPath(const uint8_t* src,
-                                               size_t size) {
-  size_t bytes_left = size;
-  while (bytes_left > 0) {
-    if (write_ptr_ >= cur_range_.end)
-      Extend();
-    const size_t burst_size = std::min(bytes_available(), bytes_left);
-    WriteBytesUnsafe(src, burst_size);
-    bytes_left -= burst_size;
-    src += burst_size;
+void UnixTaskRunner::AddFileDescriptorWatch(PlatformHandle fd,
+                                            std::function<void()> task) {
+  PERFETTO_DCHECK(PlatformHandleChecker::IsValid(fd));
+  {
+    std::lock_guard<base::MaybeRtMutex> lock(lock_);
+    PERFETTO_DCHECK(!watch_tasks_.count(fd));
+    WatchTask& watch_task = watch_tasks_[fd];
+    watch_task.callback = std::move(task);
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+    watch_task.pending = false;
+#else
+    watch_task.poll_fd_index = SIZE_MAX;
+#endif
+    watch_tasks_changed_ = true;
   }
+  WakeUp();
 }
 
-// TODO(primiano): perf optimization: I suspect that at the end this will always
-// be called with |size| == 4, in which case we might just hardcode it.
-uint8_t* ScatteredStreamWriter::ReserveBytes(size_t size) {
-  if (write_ptr_ + size > cur_range_.end) {
-    // Assume the reservations are always < Delegate::GetNewBuffer().size(),
-    // so that one single call to Extend() will definitely give enough headroom.
-    Extend();
-    PERFETTO_DCHECK(write_ptr_ + size <= cur_range_.end);
+void UnixTaskRunner::RemoveFileDescriptorWatch(PlatformHandle fd) {
+  PERFETTO_DCHECK(PlatformHandleChecker::IsValid(fd));
+  {
+    std::lock_guard<base::MaybeRtMutex> lock(lock_);
+    PERFETTO_DCHECK(watch_tasks_.count(fd));
+    watch_tasks_.erase(fd);
+    watch_tasks_changed_ = true;
   }
-  uint8_t* begin = write_ptr_;
-  write_ptr_ += size;
-#if PERFETTO_DCHECK_IS_ON()
-  // In the past, the service had a matching DCHECK in
-  // TraceBuffer::TryPatchChunkContents, which was assuming that service and all
-  // producers are built with matching DCHECK levels. This turned out to be a
-  // source of problems and was removed in b/197340286. This memset is useless
-  // these days and is here only to maintain ABI compatibility between producers
-  // that use a v20+ SDK and older versions of the service that were built in
-  // debug mode. At some point around 2023 it should be safe to remove it.
-  // (running a debug version of traced in production seems a bad idea
-  // regardless).
-  memset(begin, 0, size);
-#endif
-  return begin;
+  // No need to schedule a wake-up for this.
 }
 
-}  // namespace protozero
-// gen_amalgamated begin source: src/protozero/static_buffer.cc
-// gen_amalgamated begin header: include/perfetto/protozero/static_buffer.h
+bool UnixTaskRunner::RunsTasksOnCurrentThread() const {
+  return GetThreadId() == created_thread_id_.load(std::memory_order_relaxed);
+}
+
+}  // namespace base
+}  // namespace perfetto
+// gen_amalgamated begin source: src/base/subprocess.cc
+// gen_amalgamated begin header: include/perfetto/ext/base/subprocess.h
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2020 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -11054,133 +12425,277 @@ uint8_t* ScatteredStreamWriter::ReserveBytes(size_t size) {
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_PROTOZERO_STATIC_BUFFER_H_
-#define INCLUDE_PERFETTO_PROTOZERO_STATIC_BUFFER_H_
+#ifndef INCLUDE_PERFETTO_EXT_BASE_SUBPROCESS_H_
+#define INCLUDE_PERFETTO_EXT_BASE_SUBPROCESS_H_
 
+#include <condition_variable>
+#include <functional>
+#include <initializer_list>
 #include <memory>
+#include <mutex>
+#include <optional>
 #include <string>
+#include <thread>
 #include <vector>
 
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/root_message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_stream_writer.h"
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/base/platform_handle.h"
+// gen_amalgamated expanded: #include "perfetto/base/proc_utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/event_fd.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/pipe.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
 
-namespace protozero {
+namespace perfetto {
+namespace base {
 
-class Message;
+// Handles creation and lifecycle management of subprocesses, taking care of
+// all subtleties involved in handling processes on UNIX.
+// This class allows to deal with macro two use-cases:
+// 1) fork() + exec() equivalent: for spawning a brand new process image.
+//    This happens when |args.exec_cmd| is not empty.
+//    This is safe to use even in a multi-threaded environment.
+// 2) fork(): for spawning a process and running a function.
+//    This happens when |args.posix_entrypoint_for_testing| is not empty.
+//    This is intended only for tests as it is extremely subtle.
+//    This mode must be used with extreme care. Before the entrypoint is
+//    invoked all file descriptors other than stdin/out/err and the ones
+//    specified in |args.preserve_fds| will be closed, to avoid each process
+//    retaining a dupe of other subprocesses pipes. This however means that
+//    any non trivial calls (including logging) must be avoided as they might
+//    refer to FDs that are now closed. The entrypoint should really be used
+//    just to signal a pipe or similar for synchronizing sequencing in tests.
 
-// A simple implementation of ScatteredStreamWriter::Delegate backed by a
-// fixed-size buffer. It doesn't support expansion. The caller needs to ensure
-// to never write more than the size of the buffer. Will CHECK() otherwise.
-class PERFETTO_EXPORT_COMPONENT StaticBufferDelegate
-    : public ScatteredStreamWriter::Delegate {
+//
+// This class allows to control stdin/out/err pipe redirection and takes care
+// of keeping all the pipes pumped (stdin) / drained (stdout/err), in a similar
+// fashion of python's subprocess.Communicate()
+// stdin: is always piped and closed once the |args.input| buffer is written.
+// stdout/err can be either:
+//   - dup()ed onto the parent process stdout/err.
+//   - redirected onto /dev/null.
+//   - piped onto a buffer (see output() method). There is only one output
+//     buffer in total. If both stdout and stderr are set to kBuffer mode, they
+//     will be merged onto the same. There doesn't seem any use case where they
+//     are needed distinctly.
+//
+// Some caveats worth mentioning:
+// - It always waitpid()s, to avoid leaving zombies around. If the process is
+//   not terminated by the time the destructor is reached, the dtor will
+//   send a SIGKILL and wait for the termination.
+// - After fork()-ing it will close all file descriptors, preserving only
+//   stdin/out/err and the fds listed in |args.preserve_fds|.
+// - On Linux/Android, the child process will be SIGKILL-ed if the calling
+//   thread exists, even if the Subprocess is std::move()-d onto another thread.
+//   This happens by virtue PR_SET_PDEATHSIG, which is used to avoid that
+//   child processes are leaked in the case of a crash of the parent (frequent
+//   in tests). However, the child process might still be leaked if execing
+//   a setuid/setgid binary (see man 2 prctl).
+//
+// Usage:
+// base::Subprocess p({"/bin/cat", "-"});
+// (or equivalently:
+//     base::Subprocess p;
+//     p.args.exec_cmd.push_back("/bin/cat");
+//     p.args.exec_cmd.push_back("-");
+//  )
+// p.args.stdout_mode = base::Subprocess::kBuffer;
+// p.args.stderr_mode = base::Subprocess::kInherit;
+// p.args.input = "stdin contents";
+// p.Call();
+// (or equivalently:
+//     p.Start();
+//     p.Wait();
+// )
+// EXPECT_EQ(p.status(), base::Subprocess::kTerminated);
+// EXPECT_EQ(p.returncode(), 0);
+class Subprocess {
  public:
-  StaticBufferDelegate(uint8_t* buf, size_t len) : range_{buf, buf + len} {}
-  ~StaticBufferDelegate() override;
+  enum Status {
+    kNotStarted = 0,  // Before calling Start() or Call().
+    kRunning,         // After calling Start(), before Wait().
+    kTerminated,      // The subprocess terminated, either successfully or not.
+                      // This includes crashes or other signals on UNIX.
+  };
 
-  // ScatteredStreamWriter::Delegate implementation.
-  ContiguousMemoryRange GetNewBuffer() override;
+  enum class OutputMode {
+    kInherit = 0,  // Inherit's the caller process stdout/stderr.
+    kDevNull,      // dup() onto /dev/null.
+    kBuffer,       // dup() onto a pipe and move it into the output() buffer.
+    kFd,           // dup() onto the passed args.fd.
+  };
 
-  ContiguousMemoryRange const range_;
-  bool get_new_buffer_called_once_ = false;
-};
+  enum class InputMode {
+    kBuffer = 0,  // dup() onto a pipe and write args.input on it.
+    kDevNull,     // dup() onto /dev/null.
+  };
 
-// Helper function to create protozero messages backed by a fixed-size buffer
-// in one line. You can write:
-//   protozero::Static<protozero::MyMessage> msg(buf.data(), buf.size());
-//   msg->set_stuff(...);
-//   size_t bytes_encoded = msg.Finalize();
-template <typename T /* protozero::Message */>
-class StaticBuffered {
- public:
-  StaticBuffered(void* buf, size_t len)
-      : delegate_(reinterpret_cast<uint8_t*>(buf), len), writer_(&delegate_) {
-    msg_.Reset(&writer_);
-  }
+  // Input arguments for configuring the subprocess behavior.
+  struct Args {
+    Args(std::initializer_list<std::string> _cmd = {}) : exec_cmd(_cmd) {}
+    Args(Args&&) noexcept;
+    Args& operator=(Args&&);
+    // If non-empty this will cause an exec() when Start()/Call() are called.
+    std::vector<std::string> exec_cmd;
 
-  // This can't be neither copied nor moved because Message hands out pointers
-  // to itself when creating submessages.
-  StaticBuffered(const StaticBuffered&) = delete;
-  StaticBuffered& operator=(const StaticBuffered&) = delete;
-  StaticBuffered(StaticBuffered&&) = delete;
-  StaticBuffered& operator=(StaticBuffered&&) = delete;
+#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+    // If non-empty, it changes the argv[0] argument passed to exec. If
+    // unset, argv[0] == exec_cmd[0]. This is to handle cases like:
+    // exec_cmd = {"/proc/self/exec"}, argv0: "my_custom_test_override".
+    std::string posix_argv0_override_for_testing;
 
-  T* get() { return &msg_; }
-  T* operator->() { return &msg_; }
+    // If non-empty this will be invoked on the fork()-ed child process, after
+    // stdin/out/err has been redirected and all other file descriptor are
+    // closed. It is valid to specify both |exec_cmd| AND
+    // |posix_entrypoint_for_testing|. In this case the latter will be invoked
+    // just before the exec() call, but after having closed all fds % stdin/o/e.
+    // This is for synchronization barriers in tests.
+    std::function<void()> posix_entrypoint_for_testing;
 
-  // The lack of a size() method is deliberate. It's to prevent that one
-  // accidentally calls size() before Finalize().
+    // When set, will will move the process to the given process group. If set
+    // and zero, it will create a new process group. Effectively this calls
+    // setpgid(0 /*self_pid*/, posix_proc_group_id).
+    // This can be used to avoid that subprocesses receive CTRL-C from the
+    // terminal, while still living in the same session.
+    std::optional<pid_t> posix_proc_group_id{};
+#endif
 
-  // Returns the number of encoded bytes (<= the size passed in the ctor).
-  size_t Finalize() {
-    msg_.Finalize();
-    return static_cast<size_t>(writer_.write_ptr() - delegate_.range_.begin);
-  }
+    // If non-empty, replaces the environment passed to exec().
+    std::vector<std::string> env;
 
- private:
-  StaticBufferDelegate delegate_;
-  ScatteredStreamWriter writer_;
-  RootMessage<T> msg_;
-};
+    // The file descriptors in this list will not be closed.
+    std::vector<int> preserve_fds;
 
-// Helper function to create stack-based protozero messages in one line.
-// You can write:
-//   protozero::StackBuffered<protozero::MyMessage, 16> msg;
-//   msg->set_stuff(...);
-//   size_t bytes_encoded = msg.Finalize();
-template <typename T /* protozero::Message */, size_t N>
-class StackBuffered : public StaticBuffered<T> {
- public:
-  StackBuffered() : StaticBuffered<T>(&buf_[0], N) {}
+    // The data to push in the child process stdin, if input_mode ==
+    // InputMode::kBuffer.
+    std::string input;
 
- private:
-  uint8_t buf_[N];  // Deliberately not initialized.
-};
+    InputMode stdin_mode = InputMode::kBuffer;
+    OutputMode stdout_mode = OutputMode::kInherit;
+    OutputMode stderr_mode = OutputMode::kInherit;
 
-}  // namespace protozero
+    base::ScopedPlatformHandle out_fd;
 
-#endif  // INCLUDE_PERFETTO_PROTOZERO_STATIC_BUFFER_H_
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+    // Returns " ".join(exec_cmd), quoting arguments.
+    std::string GetCmdString() const;
+  };
 
-// gen_amalgamated expanded: #include "perfetto/protozero/static_buffer.h"
+  struct ResourceUsage {
+    uint32_t cpu_utime_ms = 0;
+    uint32_t cpu_stime_ms = 0;
+    uint32_t max_rss_kb = 0;
+    uint32_t min_page_faults = 0;
+    uint32_t maj_page_faults = 0;
+    uint32_t vol_ctx_switch = 0;
+    uint32_t invol_ctx_switch = 0;
 
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+    uint32_t cpu_time_ms() const { return cpu_utime_ms + cpu_stime_ms; }
+  };
 
-namespace protozero {
+  explicit Subprocess(std::initializer_list<std::string> exec_cmd = {});
+  Subprocess(Subprocess&&) noexcept;
+  Subprocess& operator=(Subprocess&&);
+  ~Subprocess();  // It will KillAndWaitForTermination() if still alive.
 
-StaticBufferDelegate::~StaticBufferDelegate() = default;
+  // Starts the subprocess but doesn't wait for its termination. The caller
+  // is expected to either call Wait() or Poll() after this call.
+  void Start();
 
-ContiguousMemoryRange StaticBufferDelegate::GetNewBuffer() {
-  if (get_new_buffer_called_once_) {
-    // This is the 2nd time GetNewBuffer is called. The estimate is wrong. We
-    // shouldn't try to grow the buffer after the initial call.
-    PERFETTO_FATAL("Static buffer too small");
-  }
-  get_new_buffer_called_once_ = true;
-  return range_;
-}
+  // Wait for process termination. Can be called more than once.
+  // Args:
+  //   |timeout_ms| = 0: wait indefinitely.
+  //   |timeout_ms| > 0: wait for at most |timeout_ms|.
+  // Returns:
+  //  True: The process terminated. See status() and returncode().
+  //  False: Timeout reached, the process is still running. In this case the
+  //         process will be left in the kRunning state.
+  bool Wait(int timeout_ms = 0);
 
-}  // namespace protozero
-// gen_amalgamated begin source: src/protozero/virtual_destructors.cc
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
+  // Equivalent of Start() + Wait();
+  // Returns true if the process exited cleanly with return code 0. False in
+  // any othe case.
+  bool Call(int timeout_ms = 0);
+
+  Status Poll();
+
+  // Sends a signal (SIGKILL if not specified) and wait for process termination.
+  void KillAndWaitForTermination(int sig_num = 0);
+
+  PlatformProcessId pid() const { return s_->pid; }
+
+  // The accessors below are updated only after a call to Poll(), Wait() or
+  // KillAndWaitForTermination().
+  // In most cases you want to call Poll() rather than these accessors.
+
+  Status status() const { return s_->status; }
+  int returncode() const { return s_->returncode; }
+  bool timed_out() const { return s_->timed_out; }
+
+  // This contains both stdout and stderr (if the corresponding _mode ==
+  // OutputMode::kBuffer). It's non-const so the caller can std::move() it.
+  std::string& output() { return s_->output; }
+  const std::string& output() const { return s_->output; }
+
+  const ResourceUsage& posix_rusage() const { return *s_->rusage; }
+
+  Args args;
+
+ private:
+  // The signal/exit code used when killing the process in case of a timeout.
+  static const int kTimeoutSignal;
+
+  Subprocess(const Subprocess&) = delete;
+  Subprocess& operator=(const Subprocess&) = delete;
+
+  // This is to deal robustly with the move operators, without having to
+  // manually maintain member-wise move instructions.
+  struct MovableState {
+    base::Pipe stdin_pipe;
+    base::Pipe stdouterr_pipe;
+    PlatformProcessId pid;
+    Status status = kNotStarted;
+    int returncode = -1;
+    std::string output;  // Stdin+stderr. Only when OutputMode::kBuffer.
+    std::unique_ptr<ResourceUsage> rusage{new ResourceUsage()};
+    bool timed_out = false;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+    std::thread stdouterr_thread;
+    std::thread stdin_thread;
+    ScopedPlatformHandle win_proc_handle;
+    ScopedPlatformHandle win_thread_handle;
+
+    base::EventFd stdouterr_done_event;
+    std::mutex mutex;  // Protects locked_outerr_buf and the two pipes.
+    std::string locked_outerr_buf;
+#else
+    base::Pipe exit_status_pipe;
+    size_t input_written = 0;
+    std::thread waitpid_thread;
+#endif
+  };
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  static void StdinThread(MovableState*, const std::string& input);
+  static void StdoutErrThread(MovableState*);
+#else
+  void TryPushStdin();
+  void TryReadStdoutAndErr();
+  void TryReadExitStatus();
+  bool PollInternal(int poll_timeout_ms);
+#endif
+
+  std::unique_ptr<MovableState> s_;
+};
+
+}  // namespace base
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_SUBPROCESS_H_
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
@@ -11192,1797 +12707,2016 @@ ContiguousMemoryRange StaticBufferDelegate::GetNewBuffer() {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/subprocess.h"
 
-namespace protozero {
+#include <tuple>
 
-CppMessageObj::~CppMessageObj() = default;
+// This file contains only the common bits (ctors / dtors / move operators).
+// The rest lives in subprocess_posix.cc and subprocess_windows.cc.
 
-}  // namespace protozero
-// gen_amalgamated begin source: gen/protos/perfetto/common/android_energy_consumer_descriptor.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/common/android_energy_consumer_descriptor.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_ANDROID_ENERGY_CONSUMER_DESCRIPTOR_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_ANDROID_ENERGY_CONSUMER_DESCRIPTOR_PROTO_CPP_H_
+namespace perfetto {
+namespace base {
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+Subprocess::Args::Args(Args&&) noexcept = default;
+Subprocess::Args& Subprocess::Args::operator=(Args&&) = default;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+Subprocess::Subprocess(std::initializer_list<std::string> a)
+    : args(a), s_(new MovableState()) {}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class AndroidEnergyConsumerDescriptor;
-class AndroidEnergyConsumer;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+Subprocess::Subprocess(Subprocess&& other) noexcept {
+  static_assert(sizeof(Subprocess) ==
+                    sizeof(std::tuple<std::unique_ptr<MovableState>, Args>),
+                "base::Subprocess' move ctor needs updating");
+  s_ = std::move(other.s_);
+  args = std::move(other.args);
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  // Reset the state of the moved-from object.
+  other.s_.reset(new MovableState());
+  other.~Subprocess();
+  new (&other) Subprocess();
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+Subprocess& Subprocess::operator=(Subprocess&& other) {
+  this->~Subprocess();
+  new (this) Subprocess(std::move(other));
+  return *this;
+}
 
-class PERFETTO_EXPORT_COMPONENT AndroidEnergyConsumerDescriptor : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kEnergyConsumersFieldNumber = 1,
-  };
+Subprocess::~Subprocess() {
+  if (s_->status == kRunning)
+    KillAndWaitForTermination();
+}
 
-  AndroidEnergyConsumerDescriptor();
-  ~AndroidEnergyConsumerDescriptor() override;
-  AndroidEnergyConsumerDescriptor(AndroidEnergyConsumerDescriptor&&) noexcept;
-  AndroidEnergyConsumerDescriptor& operator=(AndroidEnergyConsumerDescriptor&&);
-  AndroidEnergyConsumerDescriptor(const AndroidEnergyConsumerDescriptor&);
-  AndroidEnergyConsumerDescriptor& operator=(const AndroidEnergyConsumerDescriptor&);
-  bool operator==(const AndroidEnergyConsumerDescriptor&) const;
-  bool operator!=(const AndroidEnergyConsumerDescriptor& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<AndroidEnergyConsumer>& energy_consumers() const { return energy_consumers_; }
-  std::vector<AndroidEnergyConsumer>* mutable_energy_consumers() { return &energy_consumers_; }
-  int energy_consumers_size() const;
-  void clear_energy_consumers();
-  AndroidEnergyConsumer* add_energy_consumers();
+bool Subprocess::Call(int timeout_ms) {
+  PERFETTO_CHECK(s_->status == kNotStarted);
+  Start();
 
- private:
-  std::vector<AndroidEnergyConsumer> energy_consumers_;
+  if (!Wait(timeout_ms)) {
+    s_->timed_out = true;
+    KillAndWaitForTermination(kTimeoutSignal);
+  }
+  PERFETTO_DCHECK(s_->status != kRunning);
+  return s_->status == kTerminated && s_->returncode == 0;
+}
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+std::string Subprocess::Args::GetCmdString() const {
+  std::string str;
+  for (size_t i = 0; i < exec_cmd.size(); i++) {
+    str += i > 0 ? " \"" : "";
+    str += exec_cmd[i];
+    str += i > 0 ? "\"" : "";
+  }
+  return str;
+}
 
-  std::bitset<2> _has_field_{};
-};
+}  // namespace base
+}  // namespace perfetto
+// gen_amalgamated begin source: src/base/subprocess_posix.cc
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
+// gen_amalgamated expanded: #include "perfetto/ext/base/subprocess.h"
 
-class PERFETTO_EXPORT_COMPONENT AndroidEnergyConsumer : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kEnergyConsumerIdFieldNumber = 1,
-    kOrdinalFieldNumber = 2,
-    kTypeFieldNumber = 3,
-    kNameFieldNumber = 4,
-  };
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
 
-  AndroidEnergyConsumer();
-  ~AndroidEnergyConsumer() override;
-  AndroidEnergyConsumer(AndroidEnergyConsumer&&) noexcept;
-  AndroidEnergyConsumer& operator=(AndroidEnergyConsumer&&);
-  AndroidEnergyConsumer(const AndroidEnergyConsumer&);
-  AndroidEnergyConsumer& operator=(const AndroidEnergyConsumer&);
-  bool operator==(const AndroidEnergyConsumer&) const;
-  bool operator!=(const AndroidEnergyConsumer& other) const { return !(*this == other); }
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+#include <fcntl.h>
+#include <poll.h>
+#include <signal.h>
+#include <stdio.h>
+#include <sys/resource.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
 
-  bool has_energy_consumer_id() const { return _has_field_[1]; }
-  int32_t energy_consumer_id() const { return energy_consumer_id_; }
-  void set_energy_consumer_id(int32_t value) { energy_consumer_id_ = value; _has_field_.set(1); }
+#include <algorithm>
+#include <thread>
+#include <tuple>
 
-  bool has_ordinal() const { return _has_field_[2]; }
-  int32_t ordinal() const { return ordinal_; }
-  void set_ordinal(int32_t value) { ordinal_ = value; _has_field_.set(2); }
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX_BUT_NOT_QNX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+#include <sys/prctl.h>
+#endif
 
-  bool has_type() const { return _has_field_[3]; }
-  const std::string& type() const { return type_; }
-  void set_type(const std::string& value) { type_ = value; _has_field_.set(3); }
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/base/time.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
 
-  bool has_name() const { return _has_field_[4]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(4); }
+// In MacOS this is not defined in any header.
+extern "C" char** environ;
 
- private:
-  int32_t energy_consumer_id_{};
-  int32_t ordinal_{};
-  std::string type_{};
-  std::string name_{};
+namespace perfetto {
+namespace base {
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+namespace {
 
-  std::bitset<5> _has_field_{};
+struct ChildProcessArgs {
+  Subprocess::Args* create_args;
+  const char* exec_cmd = nullptr;
+  std::vector<char*> argv;
+  std::vector<char*> env;
+  int stdin_pipe_rd = -1;
+  int stdouterr_pipe_wr = -1;
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_ANDROID_ENERGY_CONSUMER_DESCRIPTOR_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
+// Don't add any dynamic allocation in this function. This will be invoked
+// under a fork(), potentially in a state where the allocator lock is held.
+void __attribute__((noreturn)) ChildProcess(ChildProcessArgs* args) {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX_BUT_NOT_QNX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+  // In no case we want a child process to outlive its parent process. This is
+  // relevant for tests, so that a test failure/crash doesn't leave child
+  // processes around that get reparented to init.
+  prctl(PR_SET_PDEATHSIG, SIGKILL);
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/common/android_energy_consumer_descriptor.gen.h"
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+  auto die = [args](const char* err) __attribute__((noreturn)) {
+    base::ignore_result(write(args->stdouterr_pipe_wr, err, strlen(err)));
+    base::ignore_result(write(args->stdouterr_pipe_wr, "\n", 1));
+    // From https://www.gnu.org/software/libc/manual/html_node/Exit-Status.html
+    // "In particular, the value 128 is used to indicate failure to execute
+    // another program in a subprocess. This convention is not universally
+    // obeyed, but it is a good idea to follow it in your programs."
+    _exit(128);
+  };
 
-AndroidEnergyConsumerDescriptor::AndroidEnergyConsumerDescriptor() = default;
-AndroidEnergyConsumerDescriptor::~AndroidEnergyConsumerDescriptor() = default;
-AndroidEnergyConsumerDescriptor::AndroidEnergyConsumerDescriptor(const AndroidEnergyConsumerDescriptor&) = default;
-AndroidEnergyConsumerDescriptor& AndroidEnergyConsumerDescriptor::operator=(const AndroidEnergyConsumerDescriptor&) = default;
-AndroidEnergyConsumerDescriptor::AndroidEnergyConsumerDescriptor(AndroidEnergyConsumerDescriptor&&) noexcept = default;
-AndroidEnergyConsumerDescriptor& AndroidEnergyConsumerDescriptor::operator=(AndroidEnergyConsumerDescriptor&&) = default;
+  if (args->create_args->posix_proc_group_id.has_value()) {
+    if (setpgid(0 /*self*/, args->create_args->posix_proc_group_id.value())) {
+      die("setpgid() failed");
+    }
+  }
 
-bool AndroidEnergyConsumerDescriptor::operator==(const AndroidEnergyConsumerDescriptor& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && energy_consumers_ == other.energy_consumers_;
-}
+  auto set_fd_close_on_exec = [&die](int fd, bool close_on_exec) {
+    int flags = fcntl(fd, F_GETFD, 0);
+    if (flags < 0)
+      die("fcntl(F_GETFD) failed");
+    flags = close_on_exec ? (flags | FD_CLOEXEC) : (flags & ~FD_CLOEXEC);
+    if (fcntl(fd, F_SETFD, flags) < 0)
+      die("fcntl(F_SETFD) failed");
+  };
 
-int AndroidEnergyConsumerDescriptor::energy_consumers_size() const { return static_cast<int>(energy_consumers_.size()); }
-void AndroidEnergyConsumerDescriptor::clear_energy_consumers() { energy_consumers_.clear(); }
-AndroidEnergyConsumer* AndroidEnergyConsumerDescriptor::add_energy_consumers() { energy_consumers_.emplace_back(); return &energy_consumers_.back(); }
-bool AndroidEnergyConsumerDescriptor::ParseFromArray(const void* raw, size_t size) {
-  energy_consumers_.clear();
-  unknown_fields_.clear();
-  bool packed_error = false;
+  if (getppid() == 1)
+    die("terminating because parent process died");
 
-  ::protozero::ProtoDecoder dec(raw, size);
-  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
-    if (field.id() < _has_field_.size()) {
-      _has_field_.set(field.id());
+  switch (args->create_args->stdin_mode) {
+    case Subprocess::InputMode::kBuffer:
+      if (dup2(args->stdin_pipe_rd, STDIN_FILENO) == -1)
+        die("Failed to dup2(STDIN)");
+      close(args->stdin_pipe_rd);
+      break;
+    case Subprocess::InputMode::kDevNull:
+      if (dup2(open("/dev/null", O_RDONLY), STDIN_FILENO) == -1)
+        die("Failed to dup2(STDOUT)");
+      break;
+  }
+
+  switch (args->create_args->stdout_mode) {
+    case Subprocess::OutputMode::kInherit:
+      break;
+    case Subprocess::OutputMode::kDevNull: {
+      if (dup2(open("/dev/null", O_RDWR), STDOUT_FILENO) == -1)
+        die("Failed to dup2(STDOUT)");
+      break;
     }
-    switch (field.id()) {
-      case 1 /* energy_consumers */:
-        energy_consumers_.emplace_back();
-        energy_consumers_.back().ParseFromArray(field.data(), field.size());
-        break;
-      default:
-        field.SerializeAndAppendTo(&unknown_fields_);
-        break;
+    case Subprocess::OutputMode::kBuffer:
+      if (dup2(args->stdouterr_pipe_wr, STDOUT_FILENO) == -1)
+        die("Failed to dup2(STDOUT)");
+      break;
+    case Subprocess::OutputMode::kFd:
+      if (dup2(*args->create_args->out_fd, STDOUT_FILENO) == -1)
+        die("Failed to dup2(STDOUT)");
+      break;
+  }
+
+  switch (args->create_args->stderr_mode) {
+    case Subprocess::OutputMode::kInherit:
+      break;
+    case Subprocess::OutputMode::kDevNull: {
+      if (dup2(open("/dev/null", O_RDWR), STDERR_FILENO) == -1)
+        die("Failed to dup2(STDERR)");
+      break;
     }
+    case Subprocess::OutputMode::kBuffer:
+      if (dup2(args->stdouterr_pipe_wr, STDERR_FILENO) == -1)
+        die("Failed to dup2(STDERR)");
+      break;
+    case Subprocess::OutputMode::kFd:
+      if (dup2(*args->create_args->out_fd, STDERR_FILENO) == -1)
+        die("Failed to dup2(STDERR)");
+      break;
   }
-  return !packed_error && !dec.bytes_left();
-}
 
-std::string AndroidEnergyConsumerDescriptor::SerializeAsString() const {
-  ::protozero::internal::gen_helpers::MessageSerializer msg;
-  Serialize(msg.get());
-  return msg.SerializeAsString();
-}
+  // Close all FDs % stdin/out/err and the ones that the client explicitly
+  // asked to retain. The reason for this is twofold:
+  // 1. For exec-only (i.e. entrypoint == empty) cases: it avoids leaking FDs
+  //    that didn't get marked as O_CLOEXEC by accident.
+  // 2. In fork() mode (entrypoint not empty) avoids retaining a dup of eventfds
+  //    that would prevent the parent process to receive EOFs (tests usually use
+  //    pipes as a synchronization mechanism between subprocesses).
+  const auto& preserve_fds = args->create_args->preserve_fds;
+  for (int i = 0; i < 512; i++) {
+    if (i != STDIN_FILENO && i != STDERR_FILENO && i != STDOUT_FILENO &&
+        i != args->stdouterr_pipe_wr &&
+        !std::count(preserve_fds.begin(), preserve_fds.end(), i)) {
+      close(i);
+    }
+  }
 
-std::vector<uint8_t> AndroidEnergyConsumerDescriptor::SerializeAsArray() const {
-  ::protozero::internal::gen_helpers::MessageSerializer msg;
-  Serialize(msg.get());
-  return msg.SerializeAsArray();
-}
+  // Clears O_CLOEXEC from stdin/out/err and the |preserve_fds| list. These are
+  // the only FDs that we want to be preserved after the exec().
+  set_fd_close_on_exec(STDIN_FILENO, false);
+  set_fd_close_on_exec(STDOUT_FILENO, false);
+  set_fd_close_on_exec(STDERR_FILENO, false);
 
-void AndroidEnergyConsumerDescriptor::Serialize(::protozero::Message* msg) const {
-  // Field 1: energy_consumers
-  for (auto& it : energy_consumers_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
-  }
+  for (auto fd : preserve_fds)
+    set_fd_close_on_exec(fd, false);
 
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
-}
+  // If the caller specified a std::function entrypoint, run that first.
+  if (args->create_args->posix_entrypoint_for_testing)
+    args->create_args->posix_entrypoint_for_testing();
 
+  // If the caller specified only an entrypoint, without any args, exit now.
+  // Otherwise proceed with the exec() below.
+  if (!args->exec_cmd)
+    _exit(0);
 
-AndroidEnergyConsumer::AndroidEnergyConsumer() = default;
-AndroidEnergyConsumer::~AndroidEnergyConsumer() = default;
-AndroidEnergyConsumer::AndroidEnergyConsumer(const AndroidEnergyConsumer&) = default;
-AndroidEnergyConsumer& AndroidEnergyConsumer::operator=(const AndroidEnergyConsumer&) = default;
-AndroidEnergyConsumer::AndroidEnergyConsumer(AndroidEnergyConsumer&&) noexcept = default;
-AndroidEnergyConsumer& AndroidEnergyConsumer::operator=(AndroidEnergyConsumer&&) = default;
+  // If |args[0]| is a path use execv() (which takes a path), otherwise use
+  // exevp(), which uses the shell and follows PATH.
+  if (strchr(args->exec_cmd, '/')) {
+    char** env = args->env.empty() ? environ : args->env.data();
+    execve(args->exec_cmd, args->argv.data(), env);
+  } else {
+    // There is no execvpe() on Mac.
+    if (!args->env.empty())
+      die("A full path is required for |exec_cmd| when setting |env|");
+    execvp(args->exec_cmd, args->argv.data());
+  }
 
-bool AndroidEnergyConsumer::operator==(const AndroidEnergyConsumer& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && energy_consumer_id_ == other.energy_consumer_id_
-   && ordinal_ == other.ordinal_
-   && type_ == other.type_
-   && name_ == other.name_;
+  // Reached only if execv fails.
+  die("execve() failed");
 }
 
-bool AndroidEnergyConsumer::ParseFromArray(const void* raw, size_t size) {
-  unknown_fields_.clear();
-  bool packed_error = false;
+}  // namespace
 
-  ::protozero::ProtoDecoder dec(raw, size);
-  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
-    if (field.id() < _has_field_.size()) {
-      _has_field_.set(field.id());
-    }
-    switch (field.id()) {
-      case 1 /* energy_consumer_id */:
-        field.get(&energy_consumer_id_);
-        break;
-      case 2 /* ordinal */:
-        field.get(&ordinal_);
-        break;
-      case 3 /* type */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &type_);
-        break;
-      case 4 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
-        break;
-      default:
-        field.SerializeAndAppendTo(&unknown_fields_);
-        break;
-    }
-  }
-  return !packed_error && !dec.bytes_left();
-}
+// static
+const int Subprocess::kTimeoutSignal = SIGKILL;
 
-std::string AndroidEnergyConsumer::SerializeAsString() const {
-  ::protozero::internal::gen_helpers::MessageSerializer msg;
-  Serialize(msg.get());
-  return msg.SerializeAsString();
-}
+void Subprocess::Start() {
+  ChildProcessArgs proc_args;
+  proc_args.create_args = &args;
 
-std::vector<uint8_t> AndroidEnergyConsumer::SerializeAsArray() const {
-  ::protozero::internal::gen_helpers::MessageSerializer msg;
-  Serialize(msg.get());
-  return msg.SerializeAsArray();
-}
+  // Setup argv.
+  if (!args.exec_cmd.empty()) {
+    proc_args.exec_cmd = args.exec_cmd[0].c_str();
+    for (const std::string& arg : args.exec_cmd)
+      proc_args.argv.push_back(const_cast<char*>(arg.c_str()));
+    proc_args.argv.push_back(nullptr);
 
-void AndroidEnergyConsumer::Serialize(::protozero::Message* msg) const {
-  // Field 1: energy_consumer_id
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, energy_consumer_id_, msg);
+    if (!args.posix_argv0_override_for_testing.empty()) {
+      proc_args.argv[0] =
+          const_cast<char*>(args.posix_argv0_override_for_testing.c_str());
+    }
   }
 
-  // Field 2: ordinal
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, ordinal_, msg);
+  // Setup env.
+  if (!args.env.empty()) {
+    for (const std::string& str : args.env)
+      proc_args.env.push_back(const_cast<char*>(str.c_str()));
+    proc_args.env.push_back(nullptr);
   }
 
-  // Field 3: type
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeString(3, type_, msg);
+  // Setup the pipes for stdin/err redirection.
+  if (args.stdin_mode == InputMode::kBuffer) {
+    s_->stdin_pipe = base::Pipe::Create(base::Pipe::kWrNonBlock);
+    proc_args.stdin_pipe_rd = *s_->stdin_pipe.rd;
   }
+  s_->stdouterr_pipe = base::Pipe::Create(base::Pipe::kRdNonBlock);
+  proc_args.stdouterr_pipe_wr = *s_->stdouterr_pipe.wr;
 
-  // Field 4: name
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeString(4, name_, msg);
+  // Spawn the child process that will exec().
+  s_->pid = fork();
+  PERFETTO_CHECK(s_->pid >= 0);
+  if (s_->pid == 0) {
+    // Close the parent-ends of the pipes.
+    s_->stdin_pipe.wr.reset();
+    s_->stdouterr_pipe.rd.reset();
+    ChildProcess(&proc_args);
+    // ChildProcess() doesn't return, not even in case of failures.
+    PERFETTO_FATAL("not reached");
   }
 
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
-}
+  s_->status = kRunning;
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/common/android_log_constants.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/common/android_log_constants.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_ANDROID_LOG_CONSTANTS_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_ANDROID_LOG_CONSTANTS_PROTO_CPP_H_
+  // Close the child-end of the pipes.
+  // Deliberately NOT closing the s_->stdin_pipe.rd. This is to avoid crashing
+  // with a SIGPIPE if the process exits without consuming its stdin, while
+  // the parent tries to write() on the other end of the stdin pipe.
+  s_->stdouterr_pipe.wr.reset();
+  proc_args.create_args->out_fd.reset();
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  // Spawn a thread that is blocked on waitpid() and writes the termination
+  // status onto a pipe. The problem here is that waipid() doesn't have a
+  // timeout option and can't be passed to poll(). The alternative would be
+  // using a SIGCHLD handler, but anecdotally signal handlers introduce more
+  // problems than what they solve.
+  s_->exit_status_pipe = base::Pipe::Create(base::Pipe::kRdNonBlock);
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum AndroidLogId : int;
-enum AndroidLogPriority : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  // Both ends of the pipe are closed after the thread.join().
+  int pid = s_->pid;
+  int exit_status_pipe_wr = s_->exit_status_pipe.wr.release();
+  auto* rusage = s_->rusage.get();
+  s_->waitpid_thread = std::thread([pid, exit_status_pipe_wr, rusage] {
+    int pid_stat = -1;
+    struct rusage usg{};
+    int wait_res = PERFETTO_EINTR(wait4(pid, &pid_stat, 0, &usg));
+    PERFETTO_CHECK(wait_res == pid);
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+    auto tv_to_ms = [](const struct timeval& tv) {
+      return static_cast<uint32_t>(tv.tv_sec * 1000 + tv.tv_usec / 1000);
+    };
+    rusage->cpu_utime_ms = tv_to_ms(usg.ru_utime);
+    rusage->cpu_stime_ms = tv_to_ms(usg.ru_stime);
+    rusage->max_rss_kb = static_cast<uint32_t>(usg.ru_maxrss) / 1000;
+    rusage->min_page_faults = static_cast<uint32_t>(usg.ru_minflt);
+    rusage->maj_page_faults = static_cast<uint32_t>(usg.ru_majflt);
+    rusage->vol_ctx_switch = static_cast<uint32_t>(usg.ru_nvcsw);
+    rusage->invol_ctx_switch = static_cast<uint32_t>(usg.ru_nivcsw);
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum AndroidLogId : int {
-  LID_DEFAULT = 0,
-  LID_RADIO = 1,
-  LID_EVENTS = 2,
-  LID_SYSTEM = 3,
-  LID_CRASH = 4,
-  LID_STATS = 5,
-  LID_SECURITY = 6,
-  LID_KERNEL = 7,
-};
-enum AndroidLogPriority : int {
-  PRIO_UNSPECIFIED = 0,
-  PRIO_UNUSED = 1,
-  PRIO_VERBOSE = 2,
-  PRIO_DEBUG = 3,
-  PRIO_INFO = 4,
-  PRIO_WARN = 5,
-  PRIO_ERROR = 6,
-  PRIO_FATAL = 7,
-};
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+    base::ignore_result(PERFETTO_EINTR(
+        write(exit_status_pipe_wr, &pid_stat, sizeof(pid_stat))));
+    PERFETTO_CHECK(close(exit_status_pipe_wr) == 0 || errno == EINTR);
+  });
+}
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_ANDROID_LOG_CONSTANTS_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/common/android_log_constants.gen.h"
+Subprocess::Status Subprocess::Poll() {
+  if (s_->status != kRunning)
+    return s_->status;  // Nothing to poll.
+  while (PollInternal(0 /* don't block*/)) {
+  }
+  return s_->status;
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/common/builtin_clock.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/common/builtin_clock.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_BUILTIN_CLOCK_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_BUILTIN_CLOCK_PROTO_CPP_H_
+// |timeout_ms| semantic:
+//   -1: Block indefinitely.
+//    0: Don't block, return immediately.
+//   >0: Block for at most X ms.
+// Returns:
+//  True: Read at least one fd (so there might be more queued).
+//  False: if all fds reached quiescent (no data to read/write).
+bool Subprocess::PollInternal(int poll_timeout_ms) {
+  struct pollfd fds[3]{};
+  size_t num_fds = 0;
+  if (s_->exit_status_pipe.rd) {
+    fds[num_fds].fd = *s_->exit_status_pipe.rd;
+    fds[num_fds].events = POLLIN;
+    num_fds++;
+  }
+  if (s_->stdouterr_pipe.rd) {
+    fds[num_fds].fd = *s_->stdouterr_pipe.rd;
+    fds[num_fds].events = POLLIN;
+    num_fds++;
+  }
+  if (s_->stdin_pipe.wr) {
+    fds[num_fds].fd = *s_->stdin_pipe.wr;
+    fds[num_fds].events = POLLOUT;
+    num_fds++;
+  }
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  if (num_fds == 0)
+    return false;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  auto nfds = static_cast<nfds_t>(num_fds);
+  int poll_res = PERFETTO_EINTR(poll(fds, nfds, poll_timeout_ms));
+  PERFETTO_CHECK(poll_res >= 0);
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum BuiltinClock : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  TryReadStdoutAndErr();
+  TryPushStdin();
+  TryReadExitStatus();
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  return poll_res > 0;
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum BuiltinClock : int {
-  BUILTIN_CLOCK_UNKNOWN = 0,
-  BUILTIN_CLOCK_REALTIME = 1,
-  BUILTIN_CLOCK_REALTIME_COARSE = 2,
-  BUILTIN_CLOCK_MONOTONIC = 3,
-  BUILTIN_CLOCK_MONOTONIC_COARSE = 4,
-  BUILTIN_CLOCK_MONOTONIC_RAW = 5,
-  BUILTIN_CLOCK_BOOTTIME = 6,
-  BUILTIN_CLOCK_MAX_ID = 63,
-};
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+bool Subprocess::Wait(int timeout_ms) {
+  PERFETTO_CHECK(s_->status != kNotStarted);
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_BUILTIN_CLOCK_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/common/builtin_clock.gen.h"
+  // Break out of the loop only after both conditions are satisfied:
+  // - All stdout/stderr data has been read (if kBuffer).
+  // - The process exited.
+  // Note that the two events can happen arbitrary order. After the process
+  // exits, there might be still data in the pipe buffer, which we want to
+  // read fully.
+  //
+  // Instead, don't wait on the stdin to be fully written. The child process
+  // might exit prematurely (or crash). If that happens, we can end up in a
+  // state where the write(stdin_pipe_.wr) will never unblock.
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/common/commit_data_request.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/common/commit_data_request.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_COMMIT_DATA_REQUEST_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_COMMIT_DATA_REQUEST_PROTO_CPP_H_
+  const int64_t t_start = base::GetWallTimeMs().count();
+  while (s_->exit_status_pipe.rd || s_->stdouterr_pipe.rd) {
+    int poll_timeout_ms = -1;  // Block until a FD is ready.
+    if (timeout_ms > 0) {
+      const int64_t now = GetWallTimeMs().count();
+      poll_timeout_ms = timeout_ms - static_cast<int>(now - t_start);
+      if (poll_timeout_ms <= 0)
+        return false;
+    }
+    PollInternal(poll_timeout_ms);
+  }  // while(...)
+  return true;
+}
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+void Subprocess::TryReadExitStatus() {
+  if (!s_->exit_status_pipe.rd)
+    return;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  int pid_stat = -1;
+  int64_t rsize = PERFETTO_EINTR(
+      read(*s_->exit_status_pipe.rd, &pid_stat, sizeof(pid_stat)));
+  if (rsize < 0 && errno == EAGAIN)
+    return;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class CommitDataRequest;
-class CommitDataRequest_ChunkToPatch;
-class CommitDataRequest_ChunkToPatch_Patch;
-class CommitDataRequest_ChunksToMove;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  if (rsize > 0) {
+    PERFETTO_CHECK(rsize == sizeof(pid_stat));
+  } else if (rsize < 0) {
+    PERFETTO_PLOG("Subprocess read(s_->exit_status_pipe) failed");
+  }
+  s_->waitpid_thread.join();
+  s_->exit_status_pipe.rd.reset();
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  s_->status = kTerminated;
+  if (WIFEXITED(pid_stat)) {
+    s_->returncode = WEXITSTATUS(pid_stat);
+  } else if (WIFSIGNALED(pid_stat)) {
+    s_->returncode = 128 + WTERMSIG(pid_stat);  // Follow bash convention.
+  } else {
+    PERFETTO_FATAL("waitpid() returned an unexpected value (%d)", pid_stat);
+  }
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+// If the stidn pipe is still open, push input data and close it at the end.
+void Subprocess::TryPushStdin() {
+  if (!s_->stdin_pipe.wr)
+    return;
 
-class PERFETTO_EXPORT_COMPONENT CommitDataRequest : public ::protozero::CppMessageObj {
- public:
-  using ChunksToMove = CommitDataRequest_ChunksToMove;
-  using ChunkToPatch = CommitDataRequest_ChunkToPatch;
-  enum FieldNumbers {
-    kChunksToMoveFieldNumber = 1,
-    kChunksToPatchFieldNumber = 2,
-    kFlushRequestIdFieldNumber = 3,
-  };
+  PERFETTO_DCHECK(args.input.empty() || s_->input_written < args.input.size());
+  if (!args.input.empty()) {
+    int64_t wsize =
+        PERFETTO_EINTR(write(*s_->stdin_pipe.wr, &args.input[s_->input_written],
+                             args.input.size() - s_->input_written));
+    if (wsize < 0 && errno == EAGAIN)
+      return;
 
-  CommitDataRequest();
-  ~CommitDataRequest() override;
-  CommitDataRequest(CommitDataRequest&&) noexcept;
-  CommitDataRequest& operator=(CommitDataRequest&&);
-  CommitDataRequest(const CommitDataRequest&);
-  CommitDataRequest& operator=(const CommitDataRequest&);
-  bool operator==(const CommitDataRequest&) const;
-  bool operator!=(const CommitDataRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<CommitDataRequest_ChunksToMove>& chunks_to_move() const { return chunks_to_move_; }
-  std::vector<CommitDataRequest_ChunksToMove>* mutable_chunks_to_move() { return &chunks_to_move_; }
-  int chunks_to_move_size() const;
-  void clear_chunks_to_move();
-  CommitDataRequest_ChunksToMove* add_chunks_to_move();
-
-  const std::vector<CommitDataRequest_ChunkToPatch>& chunks_to_patch() const { return chunks_to_patch_; }
-  std::vector<CommitDataRequest_ChunkToPatch>* mutable_chunks_to_patch() { return &chunks_to_patch_; }
-  int chunks_to_patch_size() const;
-  void clear_chunks_to_patch();
-  CommitDataRequest_ChunkToPatch* add_chunks_to_patch();
-
-  bool has_flush_request_id() const { return _has_field_[3]; }
-  uint64_t flush_request_id() const { return flush_request_id_; }
-  void set_flush_request_id(uint64_t value) { flush_request_id_ = value; _has_field_.set(3); }
+    if (wsize >= 0) {
+      // Whether write() can return 0 is one of the greatest mysteries of UNIX.
+      // Just ignore it.
+      s_->input_written += static_cast<size_t>(wsize);
+    } else {
+      PERFETTO_PLOG("Subprocess write(stdin) failed");
+      s_->stdin_pipe.wr.reset();
+    }
+  }
+  PERFETTO_DCHECK(s_->input_written <= args.input.size());
+  if (s_->input_written == args.input.size())
+    s_->stdin_pipe.wr.reset();  // Close stdin.
+}
 
- private:
-  std::vector<CommitDataRequest_ChunksToMove> chunks_to_move_;
-  std::vector<CommitDataRequest_ChunkToPatch> chunks_to_patch_;
-  uint64_t flush_request_id_{};
+void Subprocess::TryReadStdoutAndErr() {
+  if (!s_->stdouterr_pipe.rd)
+    return;
+  char buf[4096];
+  int64_t rsize =
+      PERFETTO_EINTR(read(*s_->stdouterr_pipe.rd, buf, sizeof(buf)));
+  if (rsize < 0 && errno == EAGAIN)
+    return;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  if (rsize > 0) {
+    s_->output.append(buf, static_cast<size_t>(rsize));
+  } else if (rsize == 0 /* EOF */) {
+    s_->stdouterr_pipe.rd.reset();
+  } else {
+    PERFETTO_PLOG("Subprocess read(stdout/err) failed");
+    s_->stdouterr_pipe.rd.reset();
+  }
+}
 
-  std::bitset<4> _has_field_{};
-};
+void Subprocess::KillAndWaitForTermination(int sig_num) {
+  kill(s_->pid, sig_num ? sig_num : SIGKILL);
+  Wait();
+  // TryReadExitStatus must have joined the thread.
+  PERFETTO_DCHECK(!s_->waitpid_thread.joinable());
+}
 
+}  // namespace base
+}  // namespace perfetto
 
-class PERFETTO_EXPORT_COMPONENT CommitDataRequest_ChunkToPatch : public ::protozero::CppMessageObj {
- public:
-  using Patch = CommitDataRequest_ChunkToPatch_Patch;
-  enum FieldNumbers {
-    kTargetBufferFieldNumber = 1,
-    kWriterIdFieldNumber = 2,
-    kChunkIdFieldNumber = 3,
-    kPatchesFieldNumber = 4,
-    kHasMorePatchesFieldNumber = 5,
-  };
+#endif  // PERFETTO_OS_LINUX || PERFETTO_OS_ANDROID || PERFETTO_OS_APPLE
+// gen_amalgamated begin source: src/base/subprocess_windows.cc
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-  CommitDataRequest_ChunkToPatch();
-  ~CommitDataRequest_ChunkToPatch() override;
-  CommitDataRequest_ChunkToPatch(CommitDataRequest_ChunkToPatch&&) noexcept;
-  CommitDataRequest_ChunkToPatch& operator=(CommitDataRequest_ChunkToPatch&&);
-  CommitDataRequest_ChunkToPatch(const CommitDataRequest_ChunkToPatch&);
-  CommitDataRequest_ChunkToPatch& operator=(const CommitDataRequest_ChunkToPatch&);
-  bool operator==(const CommitDataRequest_ChunkToPatch&) const;
-  bool operator!=(const CommitDataRequest_ChunkToPatch& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_target_buffer() const { return _has_field_[1]; }
-  uint32_t target_buffer() const { return target_buffer_; }
-  void set_target_buffer(uint32_t value) { target_buffer_ = value; _has_field_.set(1); }
-
-  bool has_writer_id() const { return _has_field_[2]; }
-  uint32_t writer_id() const { return writer_id_; }
-  void set_writer_id(uint32_t value) { writer_id_ = value; _has_field_.set(2); }
-
-  bool has_chunk_id() const { return _has_field_[3]; }
-  uint32_t chunk_id() const { return chunk_id_; }
-  void set_chunk_id(uint32_t value) { chunk_id_ = value; _has_field_.set(3); }
-
-  const std::vector<CommitDataRequest_ChunkToPatch_Patch>& patches() const { return patches_; }
-  std::vector<CommitDataRequest_ChunkToPatch_Patch>* mutable_patches() { return &patches_; }
-  int patches_size() const;
-  void clear_patches();
-  CommitDataRequest_ChunkToPatch_Patch* add_patches();
-
-  bool has_has_more_patches() const { return _has_field_[5]; }
-  bool has_more_patches() const { return has_more_patches_; }
-  void set_has_more_patches(bool value) { has_more_patches_ = value; _has_field_.set(5); }
+// gen_amalgamated expanded: #include "perfetto/ext/base/subprocess.h"
 
- private:
-  uint32_t target_buffer_{};
-  uint32_t writer_id_{};
-  uint32_t chunk_id_{};
-  std::vector<CommitDataRequest_ChunkToPatch_Patch> patches_;
-  bool has_more_patches_{};
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
 
-  std::bitset<6> _has_field_{};
-};
+#include <stdio.h>
 
+#include <algorithm>
+#include <mutex>
+#include <tuple>
 
-class PERFETTO_EXPORT_COMPONENT CommitDataRequest_ChunkToPatch_Patch : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kOffsetFieldNumber = 1,
-    kDataFieldNumber = 2,
-  };
+#include <windows.h>
 
-  CommitDataRequest_ChunkToPatch_Patch();
-  ~CommitDataRequest_ChunkToPatch_Patch() override;
-  CommitDataRequest_ChunkToPatch_Patch(CommitDataRequest_ChunkToPatch_Patch&&) noexcept;
-  CommitDataRequest_ChunkToPatch_Patch& operator=(CommitDataRequest_ChunkToPatch_Patch&&);
-  CommitDataRequest_ChunkToPatch_Patch(const CommitDataRequest_ChunkToPatch_Patch&);
-  CommitDataRequest_ChunkToPatch_Patch& operator=(const CommitDataRequest_ChunkToPatch_Patch&);
-  bool operator==(const CommitDataRequest_ChunkToPatch_Patch&) const;
-  bool operator!=(const CommitDataRequest_ChunkToPatch_Patch& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_offset() const { return _has_field_[1]; }
-  uint32_t offset() const { return offset_; }
-  void set_offset(uint32_t value) { offset_ = value; _has_field_.set(1); }
-
-  bool has_data() const { return _has_field_[2]; }
-  const std::string& data() const { return data_; }
-  void set_data(const std::string& value) { data_ = value; _has_field_.set(2); }
-  void set_data(const void* p, size_t s) { data_.assign(reinterpret_cast<const char*>(p), s); _has_field_.set(2); }
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/base/time.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/pipe.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
 
- private:
-  uint32_t offset_{};
-  std::string data_{};
+namespace perfetto {
+namespace base {
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+// static
+const int Subprocess::kTimeoutSignal = static_cast<int>(STATUS_TIMEOUT);
 
-  std::bitset<3> _has_field_{};
-};
+void Subprocess::Start() {
+  if (args.exec_cmd.empty()) {
+    PERFETTO_ELOG("Subprocess.exec_cmd cannot be empty on Windows");
+    return;
+  }
 
+  // Quote arguments but only when ambiguous. When quoting, CreateProcess()
+  // assumes that the command is an absolute path and does not search in the
+  // %PATH%. If non quoted, instead, CreateProcess() tries both. This is to
+  // allow Subprocess("cmd.exe", "/c", "shell command").
+  std::string cmd;
+  for (const auto& part : args.exec_cmd) {
+    if (part.find(" ") != std::string::npos) {
+      cmd += "\"" + part + "\" ";
+    } else {
+      cmd += part + " ";
+    }
+  }
+  // Remove trailing space.
+  if (!cmd.empty())
+    cmd.resize(cmd.size() - 1);
 
-class PERFETTO_EXPORT_COMPONENT CommitDataRequest_ChunksToMove : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kPageFieldNumber = 1,
-    kChunkFieldNumber = 2,
-    kTargetBufferFieldNumber = 3,
-  };
+  if (args.stdin_mode == InputMode::kBuffer) {
+    s_->stdin_pipe = Pipe::Create();
+    // Allow the child process to inherit the other end of the pipe.
+    PERFETTO_CHECK(
+        ::SetHandleInformation(*s_->stdin_pipe.rd, HANDLE_FLAG_INHERIT, 1));
+  }
 
-  CommitDataRequest_ChunksToMove();
-  ~CommitDataRequest_ChunksToMove() override;
-  CommitDataRequest_ChunksToMove(CommitDataRequest_ChunksToMove&&) noexcept;
-  CommitDataRequest_ChunksToMove& operator=(CommitDataRequest_ChunksToMove&&);
-  CommitDataRequest_ChunksToMove(const CommitDataRequest_ChunksToMove&);
-  CommitDataRequest_ChunksToMove& operator=(const CommitDataRequest_ChunksToMove&);
-  bool operator==(const CommitDataRequest_ChunksToMove&) const;
-  bool operator!=(const CommitDataRequest_ChunksToMove& other) const { return !(*this == other); }
+  if (args.stderr_mode == OutputMode::kBuffer ||
+      args.stdout_mode == OutputMode::kBuffer) {
+    s_->stdouterr_pipe = Pipe::Create();
+    PERFETTO_CHECK(
+        ::SetHandleInformation(*s_->stdouterr_pipe.wr, HANDLE_FLAG_INHERIT, 1));
+  }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  ScopedPlatformHandle nul_handle;
+  if (args.stderr_mode == OutputMode::kDevNull ||
+      args.stdout_mode == OutputMode::kDevNull) {
+    nul_handle.reset(::CreateFileA(
+        "NUL", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
+        nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr));
+    PERFETTO_CHECK(::SetHandleInformation(*nul_handle, HANDLE_FLAG_INHERIT, 1));
+  }
 
-  bool has_page() const { return _has_field_[1]; }
-  uint32_t page() const { return page_; }
-  void set_page(uint32_t value) { page_ = value; _has_field_.set(1); }
+  PROCESS_INFORMATION proc_info{};
+  STARTUPINFOA start_info{};
+  start_info.cb = sizeof(STARTUPINFOA);
 
-  bool has_chunk() const { return _has_field_[2]; }
-  uint32_t chunk() const { return chunk_; }
-  void set_chunk(uint32_t value) { chunk_ = value; _has_field_.set(2); }
+  if (args.stderr_mode == OutputMode::kInherit) {
+    start_info.hStdError = ::GetStdHandle(STD_ERROR_HANDLE);
+  } else if (args.stderr_mode == OutputMode::kBuffer) {
+    start_info.hStdError = *s_->stdouterr_pipe.wr;
+  } else if (args.stderr_mode == OutputMode::kDevNull) {
+    start_info.hStdError = *nul_handle;
+  } else if (args.stderr_mode == OutputMode::kFd) {
+    PERFETTO_CHECK(
+        ::SetHandleInformation(*args.out_fd, HANDLE_FLAG_INHERIT, 1));
+    start_info.hStdError = *args.out_fd;
+  } else {
+    PERFETTO_CHECK(false);
+  }
 
-  bool has_target_buffer() const { return _has_field_[3]; }
-  uint32_t target_buffer() const { return target_buffer_; }
-  void set_target_buffer(uint32_t value) { target_buffer_ = value; _has_field_.set(3); }
+  if (args.stdout_mode == OutputMode::kInherit) {
+    start_info.hStdOutput = ::GetStdHandle(STD_OUTPUT_HANDLE);
+  } else if (args.stdout_mode == OutputMode::kBuffer) {
+    start_info.hStdOutput = *s_->stdouterr_pipe.wr;
+  } else if (args.stdout_mode == OutputMode::kDevNull) {
+    start_info.hStdOutput = *nul_handle;
+  } else if (args.stdout_mode == OutputMode::kFd) {
+    PERFETTO_CHECK(
+        ::SetHandleInformation(*args.out_fd, HANDLE_FLAG_INHERIT, 1));
+    start_info.hStdOutput = *args.out_fd;
+  } else {
+    PERFETTO_CHECK(false);
+  }
 
- private:
-  uint32_t page_{};
-  uint32_t chunk_{};
-  uint32_t target_buffer_{};
+  if (args.stdin_mode == InputMode::kBuffer) {
+    start_info.hStdInput = *s_->stdin_pipe.rd;
+  } else if (args.stdin_mode == InputMode::kDevNull) {
+    start_info.hStdInput = *nul_handle;
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  start_info.dwFlags |= STARTF_USESTDHANDLES;
 
-  std::bitset<4> _has_field_{};
-};
+  // Create the child process.
+  bool success =
+      ::CreateProcessA(nullptr,      // App name. Needs to be null to use PATH.
+                       &cmd[0],      // Command line.
+                       nullptr,      // Process security attributes.
+                       nullptr,      // Primary thread security attributes.
+                       true,         // Handles are inherited.
+                       0,            // Flags.
+                       nullptr,      // Use parent's environment.
+                       nullptr,      // Use parent's current directory.
+                       &start_info,  // STARTUPINFO pointer.
+                       &proc_info);  // Receives PROCESS_INFORMATION.
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  // Close on our side the pipe ends that we passed to the child process.
+  s_->stdin_pipe.rd.reset();
+  s_->stdouterr_pipe.wr.reset();
+  args.out_fd.reset();
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_COMMIT_DATA_REQUEST_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/common/commit_data_request.gen.h"
+  if (!success) {
+    s_->returncode = ERROR_FILE_NOT_FOUND;
+    s_->status = kTerminated;
+    s_->stdin_pipe.wr.reset();
+    s_->stdouterr_pipe.rd.reset();
+    PERFETTO_ELOG("CreateProcess failed: %lx, cmd: %s", GetLastError(),
+                  &cmd[0]);
+    return;
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+  s_->pid = proc_info.dwProcessId;
+  s_->win_proc_handle = ScopedPlatformHandle(proc_info.hProcess);
+  s_->win_thread_handle = ScopedPlatformHandle(proc_info.hThread);
+  s_->status = kRunning;
 
-CommitDataRequest::CommitDataRequest() = default;
-CommitDataRequest::~CommitDataRequest() = default;
-CommitDataRequest::CommitDataRequest(const CommitDataRequest&) = default;
-CommitDataRequest& CommitDataRequest::operator=(const CommitDataRequest&) = default;
-CommitDataRequest::CommitDataRequest(CommitDataRequest&&) noexcept = default;
-CommitDataRequest& CommitDataRequest::operator=(CommitDataRequest&&) = default;
+  MovableState* s = s_.get();
+  if (args.stdin_mode == InputMode::kBuffer) {
+    s_->stdin_thread = std::thread(&Subprocess::StdinThread, s, args.input);
+  }
 
-bool CommitDataRequest::operator==(const CommitDataRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && chunks_to_move_ == other.chunks_to_move_
-   && chunks_to_patch_ == other.chunks_to_patch_
-   && flush_request_id_ == other.flush_request_id_;
+  if (args.stderr_mode == OutputMode::kBuffer ||
+      args.stdout_mode == OutputMode::kBuffer) {
+    PERFETTO_DCHECK(s_->stdouterr_pipe.rd);
+    s_->stdouterr_thread = std::thread(&Subprocess::StdoutErrThread, s);
+  }
 }
 
-int CommitDataRequest::chunks_to_move_size() const { return static_cast<int>(chunks_to_move_.size()); }
-void CommitDataRequest::clear_chunks_to_move() { chunks_to_move_.clear(); }
-CommitDataRequest_ChunksToMove* CommitDataRequest::add_chunks_to_move() { chunks_to_move_.emplace_back(); return &chunks_to_move_.back(); }
-int CommitDataRequest::chunks_to_patch_size() const { return static_cast<int>(chunks_to_patch_.size()); }
-void CommitDataRequest::clear_chunks_to_patch() { chunks_to_patch_.clear(); }
-CommitDataRequest_ChunkToPatch* CommitDataRequest::add_chunks_to_patch() { chunks_to_patch_.emplace_back(); return &chunks_to_patch_.back(); }
-bool CommitDataRequest::ParseFromArray(const void* raw, size_t size) {
-  chunks_to_move_.clear();
-  chunks_to_patch_.clear();
-  unknown_fields_.clear();
-  bool packed_error = false;
-
-  ::protozero::ProtoDecoder dec(raw, size);
-  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
-    if (field.id() < _has_field_.size()) {
-      _has_field_.set(field.id());
-    }
-    switch (field.id()) {
-      case 1 /* chunks_to_move */:
-        chunks_to_move_.emplace_back();
-        chunks_to_move_.back().ParseFromArray(field.data(), field.size());
-        break;
-      case 2 /* chunks_to_patch */:
-        chunks_to_patch_.emplace_back();
-        chunks_to_patch_.back().ParseFromArray(field.data(), field.size());
-        break;
-      case 3 /* flush_request_id */:
-        field.get(&flush_request_id_);
-        break;
-      default:
-        field.SerializeAndAppendTo(&unknown_fields_);
-        break;
+// static
+void Subprocess::StdinThread(MovableState* s, const std::string& input) {
+  size_t input_written = 0;
+  while (input_written < input.size()) {
+    DWORD wsize = 0;
+    if (::WriteFile(*s->stdin_pipe.wr, input.data() + input_written,
+                    static_cast<DWORD>(input.size() - input_written), &wsize,
+                    nullptr)) {
+      input_written += wsize;
+    } else {
+      // ERROR_BROKEN_PIPE is WAI when the child just closes stdin and stops
+      // accepting input.
+      auto err = ::GetLastError();
+      if (err != ERROR_BROKEN_PIPE)
+        PERFETTO_PLOG("Subprocess WriteFile(stdin) failed %lx", err);
+      break;
     }
-  }
-  return !packed_error && !dec.bytes_left();
+  }  // while(...)
+  std::unique_lock<std::mutex> lock(s->mutex);
+  s->stdin_pipe.wr.reset();
 }
 
-std::string CommitDataRequest::SerializeAsString() const {
-  ::protozero::internal::gen_helpers::MessageSerializer msg;
-  Serialize(msg.get());
-  return msg.SerializeAsString();
-}
-
-std::vector<uint8_t> CommitDataRequest::SerializeAsArray() const {
-  ::protozero::internal::gen_helpers::MessageSerializer msg;
-  Serialize(msg.get());
-  return msg.SerializeAsArray();
-}
-
-void CommitDataRequest::Serialize(::protozero::Message* msg) const {
-  // Field 1: chunks_to_move
-  for (auto& it : chunks_to_move_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
-  }
+// static
+void Subprocess::StdoutErrThread(MovableState* s) {
+  char buf[4096];
+  for (;;) {
+    DWORD rsize = 0;
+    bool res =
+        ::ReadFile(*s->stdouterr_pipe.rd, buf, sizeof(buf), &rsize, nullptr);
+    if (!res) {
+      auto err = GetLastError();
+      if (err != ERROR_BROKEN_PIPE)
+        PERFETTO_PLOG("Subprocess ReadFile(stdouterr) failed %ld", err);
+    }
 
-  // Field 2: chunks_to_patch
-  for (auto& it : chunks_to_patch_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
-  }
+    if (rsize > 0) {
+      std::unique_lock<std::mutex> lock(s->mutex);
+      s->locked_outerr_buf.append(buf, static_cast<size_t>(rsize));
+    } else {  // EOF or some error.
+      break;
+    }
+  }  // For(..)
 
-  // Field 3: flush_request_id
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, flush_request_id_, msg);
+  // Close the stdouterr_pipe. The main loop looks at the pipe closure to
+  // determine whether the stdout/err thread has completed.
+  {
+    std::unique_lock<std::mutex> lock(s->mutex);
+    s->stdouterr_pipe.rd.reset();
   }
-
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+  s->stdouterr_done_event.Notify();
 }
 
-
-CommitDataRequest_ChunkToPatch::CommitDataRequest_ChunkToPatch() = default;
-CommitDataRequest_ChunkToPatch::~CommitDataRequest_ChunkToPatch() = default;
-CommitDataRequest_ChunkToPatch::CommitDataRequest_ChunkToPatch(const CommitDataRequest_ChunkToPatch&) = default;
-CommitDataRequest_ChunkToPatch& CommitDataRequest_ChunkToPatch::operator=(const CommitDataRequest_ChunkToPatch&) = default;
-CommitDataRequest_ChunkToPatch::CommitDataRequest_ChunkToPatch(CommitDataRequest_ChunkToPatch&&) noexcept = default;
-CommitDataRequest_ChunkToPatch& CommitDataRequest_ChunkToPatch::operator=(CommitDataRequest_ChunkToPatch&&) = default;
-
-bool CommitDataRequest_ChunkToPatch::operator==(const CommitDataRequest_ChunkToPatch& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && target_buffer_ == other.target_buffer_
-   && writer_id_ == other.writer_id_
-   && chunk_id_ == other.chunk_id_
-   && patches_ == other.patches_
-   && has_more_patches_ == other.has_more_patches_;
+Subprocess::Status Subprocess::Poll() {
+  if (s_->status != kRunning)
+    return s_->status;  // Nothing to poll.
+  Wait(1 /*ms*/);
+  return s_->status;
 }
 
-int CommitDataRequest_ChunkToPatch::patches_size() const { return static_cast<int>(patches_.size()); }
-void CommitDataRequest_ChunkToPatch::clear_patches() { patches_.clear(); }
-CommitDataRequest_ChunkToPatch_Patch* CommitDataRequest_ChunkToPatch::add_patches() { patches_.emplace_back(); return &patches_.back(); }
-bool CommitDataRequest_ChunkToPatch::ParseFromArray(const void* raw, size_t size) {
-  patches_.clear();
-  unknown_fields_.clear();
-  bool packed_error = false;
+bool Subprocess::Wait(int timeout_ms) {
+  PERFETTO_CHECK(s_->status != kNotStarted);
+  const bool wait_forever = timeout_ms == 0;
+  const int64_t wait_start_ms = base::GetWallTimeMs().count();
 
-  ::protozero::ProtoDecoder dec(raw, size);
-  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
-    if (field.id() < _has_field_.size()) {
-      _has_field_.set(field.id());
+  // Break out of the loop only after both conditions are satisfied:
+  // - All stdout/stderr data has been read (if OutputMode::kBuffer).
+  // - The process exited.
+  // Note that the two events can happen arbitrary order. After the process
+  // exits, there might be still data in the pipe buffer, which we want to
+  // read fully.
+  // Note also that stdout/err might be "complete" before starting, if neither
+  // is operating in OutputMode::kBuffer mode. In that case we just want to wait
+  // for the process termination.
+  //
+  // Instead, don't wait on the stdin to be fully written. The child process
+  // might exit prematurely (or crash). If that happens, we can end up in a
+  // state where the write(stdin_pipe_.wr) will never unblock.
+  bool stdouterr_complete = false;
+  for (;;) {
+    HANDLE wait_handles[2]{};
+    DWORD num_handles = 0;
+
+    // Check if the process exited.
+    bool process_exited = !s_->win_proc_handle;
+    if (!process_exited) {
+      DWORD exit_code = STILL_ACTIVE;
+      PERFETTO_CHECK(::GetExitCodeProcess(*s_->win_proc_handle, &exit_code));
+      if (exit_code != STILL_ACTIVE) {
+        s_->returncode = static_cast<int>(exit_code);
+        s_->status = kTerminated;
+        s_->win_proc_handle.reset();
+        s_->win_thread_handle.reset();
+        process_exited = true;
+      }
+    } else {
+      PERFETTO_DCHECK(s_->status != kRunning);
     }
-    switch (field.id()) {
-      case 1 /* target_buffer */:
-        field.get(&target_buffer_);
-        break;
-      case 2 /* writer_id */:
-        field.get(&writer_id_);
-        break;
-      case 3 /* chunk_id */:
-        field.get(&chunk_id_);
-        break;
-      case 4 /* patches */:
-        patches_.emplace_back();
-        patches_.back().ParseFromArray(field.data(), field.size());
-        break;
-      case 5 /* has_more_patches */:
-        field.get(&has_more_patches_);
-        break;
-      default:
-        field.SerializeAndAppendTo(&unknown_fields_);
-        break;
+    if (!process_exited) {
+      wait_handles[num_handles++] = *s_->win_proc_handle;
     }
-  }
-  return !packed_error && !dec.bytes_left();
-}
 
-std::string CommitDataRequest_ChunkToPatch::SerializeAsString() const {
-  ::protozero::internal::gen_helpers::MessageSerializer msg;
-  Serialize(msg.get());
-  return msg.SerializeAsString();
-}
+    // Check if there is more output and if the stdout/err pipe has been closed.
+    {
+      std::unique_lock<std::mutex> lock(s_->mutex);
+      // Move the output from the internal buffer shared with the
+      // stdouterr_thread to the final buffer exposed to the client.
+      if (!s_->locked_outerr_buf.empty()) {
+        s_->output.append(std::move(s_->locked_outerr_buf));
+        s_->locked_outerr_buf.clear();
+      }
+      stdouterr_complete = !s_->stdouterr_pipe.rd;
+      if (!stdouterr_complete) {
+        wait_handles[num_handles++] = s_->stdouterr_done_event.fd();
+      }
+    }  // lock(s_->mutex)
 
-std::vector<uint8_t> CommitDataRequest_ChunkToPatch::SerializeAsArray() const {
-  ::protozero::internal::gen_helpers::MessageSerializer msg;
-  Serialize(msg.get());
-  return msg.SerializeAsArray();
-}
+    if (num_handles == 0) {
+      PERFETTO_DCHECK(process_exited && stdouterr_complete);
+      break;
+    }
 
-void CommitDataRequest_ChunkToPatch::Serialize(::protozero::Message* msg) const {
-  // Field 1: target_buffer
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, target_buffer_, msg);
-  }
+    DWORD wait_ms;  // Note: DWORD is unsigned.
+    if (wait_forever) {
+      wait_ms = INFINITE;
+    } else {
+      const int64_t now = GetWallTimeMs().count();
+      const int64_t wait_left_ms = timeout_ms - (now - wait_start_ms);
+      if (wait_left_ms <= 0)
+        return false;  // Timed out
+      wait_ms = static_cast<DWORD>(wait_left_ms);
+    }
 
-  // Field 2: writer_id
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, writer_id_, msg);
+    auto wait_res =
+        ::WaitForMultipleObjects(num_handles, wait_handles, false, wait_ms);
+    PERFETTO_CHECK(wait_res != WAIT_FAILED);
   }
 
-  // Field 3: chunk_id
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, chunk_id_, msg);
-  }
+  PERFETTO_DCHECK(!s_->win_proc_handle);
+  PERFETTO_DCHECK(!s_->win_thread_handle);
 
-  // Field 4: patches
-  for (auto& it : patches_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(4));
-  }
+  if (s_->stdin_thread.joinable())  // Might not exist if CreateProcess failed.
+    s_->stdin_thread.join();
+  if (s_->stdouterr_thread.joinable())
+    s_->stdouterr_thread.join();
 
-  // Field 5: has_more_patches
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, has_more_patches_, msg);
-  }
+  // The stdin pipe is closed by the dedicated stdin thread. However if that is
+  // not started (e.g. because of no redirection) force close it now. Needs to
+  // happen after the join() to be thread safe.
+  s_->stdin_pipe.wr.reset();
+  s_->stdouterr_pipe.rd.reset();
 
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+  return true;
 }
 
+void Subprocess::KillAndWaitForTermination(int exit_code) {
+  auto code = exit_code ? static_cast<DWORD>(exit_code) : STATUS_CONTROL_C_EXIT;
+  ::TerminateProcess(*s_->win_proc_handle, code);
+  Wait();
+  // TryReadExitStatus must have joined the threads.
+  PERFETTO_DCHECK(!s_->stdin_thread.joinable());
+  PERFETTO_DCHECK(!s_->stdouterr_thread.joinable());
+}
 
-CommitDataRequest_ChunkToPatch_Patch::CommitDataRequest_ChunkToPatch_Patch() = default;
-CommitDataRequest_ChunkToPatch_Patch::~CommitDataRequest_ChunkToPatch_Patch() = default;
-CommitDataRequest_ChunkToPatch_Patch::CommitDataRequest_ChunkToPatch_Patch(const CommitDataRequest_ChunkToPatch_Patch&) = default;
-CommitDataRequest_ChunkToPatch_Patch& CommitDataRequest_ChunkToPatch_Patch::operator=(const CommitDataRequest_ChunkToPatch_Patch&) = default;
-CommitDataRequest_ChunkToPatch_Patch::CommitDataRequest_ChunkToPatch_Patch(CommitDataRequest_ChunkToPatch_Patch&&) noexcept = default;
-CommitDataRequest_ChunkToPatch_Patch& CommitDataRequest_ChunkToPatch_Patch::operator=(CommitDataRequest_ChunkToPatch_Patch&&) = default;
+}  // namespace base
+}  // namespace perfetto
 
-bool CommitDataRequest_ChunkToPatch_Patch::operator==(const CommitDataRequest_ChunkToPatch_Patch& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && offset_ == other.offset_
-   && data_ == other.data_;
-}
+#endif  // PERFETTO_OS_WIN
+// gen_amalgamated begin source: src/protozero/field.cc
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-bool CommitDataRequest_ChunkToPatch_Patch::ParseFromArray(const void* raw, size_t size) {
-  unknown_fields_.clear();
-  bool packed_error = false;
+// gen_amalgamated expanded: #include "perfetto/protozero/field.h"
 
-  ::protozero::ProtoDecoder dec(raw, size);
-  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
-    if (field.id() < _has_field_.size()) {
-      _has_field_.set(field.id());
+// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+
+#if !PERFETTO_IS_LITTLE_ENDIAN()
+// The memcpy() for fixed32/64 below needs to be adjusted if we want to
+// support big endian CPUs. There doesn't seem to be a compelling need today.
+#error Unimplemented for big endian archs.
+#endif
+
+namespace protozero {
+
+template <typename Container>
+void Field::SerializeAndAppendToInternal(Container* dst) const {
+  namespace pu = proto_utils;
+  size_t initial_size = dst->size();
+  dst->resize(initial_size + pu::kMaxSimpleFieldEncodedSize + size_);
+  uint8_t* start = reinterpret_cast<uint8_t*>(&(*dst)[initial_size]);
+  uint8_t* wptr = start;
+  switch (type_) {
+    case static_cast<int>(pu::ProtoWireType::kVarInt): {
+      wptr = pu::WriteVarInt(pu::MakeTagVarInt(id_), wptr);
+      wptr = pu::WriteVarInt(int_value_, wptr);
+      break;
     }
-    switch (field.id()) {
-      case 1 /* offset */:
-        field.get(&offset_);
-        break;
-      case 2 /* data */:
-        field.get(&data_);
-        break;
-      default:
-        field.SerializeAndAppendTo(&unknown_fields_);
-        break;
+    case static_cast<int>(pu::ProtoWireType::kFixed32): {
+      wptr = pu::WriteVarInt(pu::MakeTagFixed<uint32_t>(id_), wptr);
+      uint32_t value32 = static_cast<uint32_t>(int_value_);
+      memcpy(wptr, &value32, sizeof(value32));
+      wptr += sizeof(uint32_t);
+      break;
+    }
+    case static_cast<int>(pu::ProtoWireType::kFixed64): {
+      wptr = pu::WriteVarInt(pu::MakeTagFixed<uint64_t>(id_), wptr);
+      memcpy(wptr, &int_value_, sizeof(int_value_));
+      wptr += sizeof(uint64_t);
+      break;
+    }
+    case static_cast<int>(pu::ProtoWireType::kLengthDelimited): {
+      ConstBytes payload = as_bytes();
+      wptr = pu::WriteVarInt(pu::MakeTagLengthDelimited(id_), wptr);
+      wptr = pu::WriteVarInt(payload.size, wptr);
+      memcpy(wptr, payload.data, payload.size);
+      wptr += payload.size;
+      break;
     }
+    default:
+      PERFETTO_FATAL("Unknown field type %d", type_);
   }
-  return !packed_error && !dec.bytes_left();
+  size_t written_size = static_cast<size_t>(wptr - start);
+  PERFETTO_DCHECK(written_size > 0 && written_size < pu::kMaxMessageLength);
+  PERFETTO_DCHECK(initial_size + written_size <= dst->size());
+  dst->resize(initial_size + written_size);
 }
 
-std::string CommitDataRequest_ChunkToPatch_Patch::SerializeAsString() const {
-  ::protozero::internal::gen_helpers::MessageSerializer msg;
-  Serialize(msg.get());
-  return msg.SerializeAsString();
+void Field::SerializeAndAppendTo(std::string* dst) const {
+  SerializeAndAppendToInternal(dst);
 }
 
-std::vector<uint8_t> CommitDataRequest_ChunkToPatch_Patch::SerializeAsArray() const {
-  ::protozero::internal::gen_helpers::MessageSerializer msg;
-  Serialize(msg.get());
-  return msg.SerializeAsArray();
+void Field::SerializeAndAppendTo(std::vector<uint8_t>* dst) const {
+  SerializeAndAppendToInternal(dst);
 }
 
-void CommitDataRequest_ChunkToPatch_Patch::Serialize(::protozero::Message* msg) const {
-  // Field 1: offset
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, offset_, msg);
-  }
+}  // namespace protozero
+// gen_amalgamated begin source: src/protozero/gen_field_helpers.cc
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-  // Field 2: data
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeString(2, data_, msg);
-  }
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+namespace protozero {
+namespace internal {
+namespace gen_helpers {
+
+void DeserializeString(const protozero::Field& field, std::string* dst) {
+  field.get(dst);
 }
 
+template bool DeserializePackedRepeated<proto_utils::ProtoWireType::kVarInt,
+                                        uint64_t>(const protozero::Field& field,
+                                                  std::vector<uint64_t>* dst);
 
-CommitDataRequest_ChunksToMove::CommitDataRequest_ChunksToMove() = default;
-CommitDataRequest_ChunksToMove::~CommitDataRequest_ChunksToMove() = default;
-CommitDataRequest_ChunksToMove::CommitDataRequest_ChunksToMove(const CommitDataRequest_ChunksToMove&) = default;
-CommitDataRequest_ChunksToMove& CommitDataRequest_ChunksToMove::operator=(const CommitDataRequest_ChunksToMove&) = default;
-CommitDataRequest_ChunksToMove::CommitDataRequest_ChunksToMove(CommitDataRequest_ChunksToMove&&) noexcept = default;
-CommitDataRequest_ChunksToMove& CommitDataRequest_ChunksToMove::operator=(CommitDataRequest_ChunksToMove&&) = default;
+template bool DeserializePackedRepeated<proto_utils::ProtoWireType::kVarInt,
+                                        int64_t>(const protozero::Field& field,
+                                                 std::vector<int64_t>* dst);
 
-bool CommitDataRequest_ChunksToMove::operator==(const CommitDataRequest_ChunksToMove& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && page_ == other.page_
-   && chunk_ == other.chunk_
-   && target_buffer_ == other.target_buffer_;
-}
+template bool DeserializePackedRepeated<proto_utils::ProtoWireType::kVarInt,
+                                        uint32_t>(const protozero::Field& field,
+                                                  std::vector<uint32_t>* dst);
 
-bool CommitDataRequest_ChunksToMove::ParseFromArray(const void* raw, size_t size) {
-  unknown_fields_.clear();
-  bool packed_error = false;
+template bool DeserializePackedRepeated<proto_utils::ProtoWireType::kVarInt,
+                                        int32_t>(const protozero::Field& field,
+                                                 std::vector<int32_t>* dst);
 
-  ::protozero::ProtoDecoder dec(raw, size);
-  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
-    if (field.id() < _has_field_.size()) {
-      _has_field_.set(field.id());
-    }
-    switch (field.id()) {
-      case 1 /* page */:
-        field.get(&page_);
-        break;
-      case 2 /* chunk */:
-        field.get(&chunk_);
-        break;
-      case 3 /* target_buffer */:
-        field.get(&target_buffer_);
-        break;
-      default:
-        field.SerializeAndAppendTo(&unknown_fields_);
-        break;
-    }
-  }
-  return !packed_error && !dec.bytes_left();
+void SerializeTinyVarInt(uint32_t field_id, bool value, Message* msg) {
+  msg->AppendTinyVarInt(field_id, value);
 }
 
-std::string CommitDataRequest_ChunksToMove::SerializeAsString() const {
-  ::protozero::internal::gen_helpers::MessageSerializer msg;
-  Serialize(msg.get());
-  return msg.SerializeAsString();
-}
+template void SerializeExtendedVarInt<uint64_t>(uint32_t field_id,
+                                                uint64_t value,
+                                                Message* msg);
 
-std::vector<uint8_t> CommitDataRequest_ChunksToMove::SerializeAsArray() const {
-  ::protozero::internal::gen_helpers::MessageSerializer msg;
-  Serialize(msg.get());
-  return msg.SerializeAsArray();
-}
+template void SerializeExtendedVarInt<uint32_t>(uint32_t field_id,
+                                                uint32_t value,
+                                                Message* msg);
 
-void CommitDataRequest_ChunksToMove::Serialize(::protozero::Message* msg) const {
-  // Field 1: page
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, page_, msg);
-  }
+template void SerializeFixed<double>(uint32_t field_id,
+                                     double value,
+                                     Message* msg);
 
-  // Field 2: chunk
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, chunk_, msg);
-  }
+template void SerializeFixed<float>(uint32_t field_id,
+                                    float value,
+                                    Message* msg);
 
-  // Field 3: target_buffer
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, target_buffer_, msg);
-  }
+template void SerializeFixed<uint64_t>(uint32_t field_id,
+                                       uint64_t value,
+                                       Message* msg);
 
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+template void SerializeFixed<int64_t>(uint32_t field_id,
+                                      int64_t value,
+                                      Message* msg);
+
+template void SerializeFixed<uint32_t>(uint32_t field_id,
+                                       uint32_t value,
+                                       Message* msg);
+
+template void SerializeFixed<int32_t>(uint32_t field_id,
+                                      int32_t value,
+                                      Message* msg);
+
+void SerializeString(uint32_t field_id,
+                     const std::string& value,
+                     Message* msg) {
+  msg->AppendString(field_id, value);
 }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/common/data_source_descriptor.gen.cc
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/common/data_source_descriptor.gen.h"
+void SerializeUnknownFields(const std::string& unknown_fields, Message* msg) {
+  msg->AppendRawProtoBytes(unknown_fields.data(), unknown_fields.size());
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+MessageSerializer::MessageSerializer() = default;
 
-DataSourceDescriptor::DataSourceDescriptor() = default;
-DataSourceDescriptor::~DataSourceDescriptor() = default;
-DataSourceDescriptor::DataSourceDescriptor(const DataSourceDescriptor&) = default;
-DataSourceDescriptor& DataSourceDescriptor::operator=(const DataSourceDescriptor&) = default;
-DataSourceDescriptor::DataSourceDescriptor(DataSourceDescriptor&&) noexcept = default;
-DataSourceDescriptor& DataSourceDescriptor::operator=(DataSourceDescriptor&&) = default;
+MessageSerializer::~MessageSerializer() = default;
 
-bool DataSourceDescriptor::operator==(const DataSourceDescriptor& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && name_ == other.name_
-   && id_ == other.id_
-   && will_notify_on_stop_ == other.will_notify_on_stop_
-   && will_notify_on_start_ == other.will_notify_on_start_
-   && handles_incremental_state_clear_ == other.handles_incremental_state_clear_
-   && gpu_counter_descriptor_ == other.gpu_counter_descriptor_
-   && track_event_descriptor_ == other.track_event_descriptor_
-   && ftrace_descriptor_ == other.ftrace_descriptor_;
+std::vector<uint8_t> MessageSerializer::SerializeAsArray() {
+  return msg_.SerializeAsArray();
 }
 
-bool DataSourceDescriptor::ParseFromArray(const void* raw, size_t size) {
-  unknown_fields_.clear();
-  bool packed_error = false;
+std::string MessageSerializer::SerializeAsString() {
+  return msg_.SerializeAsString();
+}
 
-  ::protozero::ProtoDecoder dec(raw, size);
-  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
-    if (field.id() < _has_field_.size()) {
-      _has_field_.set(field.id());
-    }
-    switch (field.id()) {
-      case 1 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
-        break;
-      case 7 /* id */:
-        field.get(&id_);
-        break;
-      case 2 /* will_notify_on_stop */:
-        field.get(&will_notify_on_stop_);
-        break;
-      case 3 /* will_notify_on_start */:
-        field.get(&will_notify_on_start_);
-        break;
-      case 4 /* handles_incremental_state_clear */:
-        field.get(&handles_incremental_state_clear_);
-        break;
-      case 5 /* gpu_counter_descriptor */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &gpu_counter_descriptor_);
-        break;
-      case 6 /* track_event_descriptor */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &track_event_descriptor_);
-        break;
-      case 8 /* ftrace_descriptor */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &ftrace_descriptor_);
-        break;
-      default:
-        field.SerializeAndAppendTo(&unknown_fields_);
-        break;
-    }
-  }
-  return !packed_error && !dec.bytes_left();
-}
+template bool EqualsField<std::string>(const std::string&, const std::string&);
 
-std::string DataSourceDescriptor::SerializeAsString() const {
-  ::protozero::internal::gen_helpers::MessageSerializer msg;
-  Serialize(msg.get());
-  return msg.SerializeAsString();
-}
+}  // namespace gen_helpers
+}  // namespace internal
+}  // namespace protozero
+// gen_amalgamated begin source: src/protozero/message.cc
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-std::vector<uint8_t> DataSourceDescriptor::SerializeAsArray() const {
-  ::protozero::internal::gen_helpers::MessageSerializer msg;
-  Serialize(msg.get());
-  return msg.SerializeAsArray();
-}
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 
-void DataSourceDescriptor::Serialize(::protozero::Message* msg) const {
-  // Field 1: name
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
-  }
+#include <atomic>
+#include <type_traits>
 
-  // Field 7: id
-  if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(7, id_, msg);
-  }
+// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message_arena.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message_handle.h"
 
-  // Field 2: will_notify_on_stop
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, will_notify_on_stop_, msg);
-  }
+#if !PERFETTO_IS_LITTLE_ENDIAN()
+// The memcpy() for float and double below needs to be adjusted if we want to
+// support big endian CPUs. There doesn't seem to be a compelling need today.
+#error Unimplemented for big endian archs.
+#endif
 
-  // Field 3: will_notify_on_start
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, will_notify_on_start_, msg);
-  }
+namespace protozero {
 
-  // Field 4: handles_incremental_state_clear
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(4, handles_incremental_state_clear_, msg);
-  }
+namespace {
 
-  // Field 5: gpu_counter_descriptor
-  if (_has_field_[5]) {
-    msg->AppendString(5, gpu_counter_descriptor_);
-  }
+constexpr int kBytesToCompact = proto_utils::kMessageLengthFieldSize - 1u;
 
-  // Field 6: track_event_descriptor
-  if (_has_field_[6]) {
-    msg->AppendString(6, track_event_descriptor_);
-  }
+#if PERFETTO_DCHECK_IS_ON()
+std::atomic<uint32_t> g_generation;
+#endif
 
-  // Field 8: ftrace_descriptor
-  if (_has_field_[8]) {
-    msg->AppendString(8, ftrace_descriptor_);
-  }
+}  // namespace
 
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
-}
+// Do NOT put any code in the constructor or use default initialization.
+// Use the Reset() method below instead.
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
+// This method is called to initialize both root and nested messages.
+void Message::Reset(ScatteredStreamWriter* stream_writer, MessageArena* arena) {
+// Older versions of libstdcxx don't have is_trivially_constructible.
+#if !defined(__GLIBCXX__) || __GLIBCXX__ >= 20170516
+  static_assert(std::is_trivially_constructible<Message>::value,
+                "Message must be trivially constructible");
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/common/descriptor.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/common/descriptor.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_DESCRIPTOR_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_DESCRIPTOR_PROTO_CPP_H_
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  static_assert(std::is_trivially_destructible<Message>::value,
+                "Message must be trivially destructible");
+  stream_writer_ = stream_writer;
+  arena_ = arena;
+  size_ = 0;
+  size_field_ = nullptr;
+  nested_message_ = nullptr;
+  message_state_ = MessageState::kNotFinalized;
+#if PERFETTO_DCHECK_IS_ON()
+  handle_ = nullptr;
+  generation_ = g_generation.fetch_add(1, std::memory_order_relaxed);
+#endif
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class OneofOptions;
-class EnumValueDescriptorProto;
-class EnumDescriptorProto;
-class OneofDescriptorProto;
-class FieldDescriptorProto;
-class DescriptorProto;
-class DescriptorProto_ReservedRange;
-class FileDescriptorProto;
-class FileDescriptorSet;
-enum FieldDescriptorProto_Type : int;
-enum FieldDescriptorProto_Label : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+void Message::AppendString(uint32_t field_id, const char* str) {
+  AppendBytes(field_id, str, strlen(str));
+}
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+void Message::AppendBytes(uint32_t field_id, const void* src, size_t size) {
+  PERFETTO_DCHECK(field_id);
+  if (nested_message_)
+    EndNestedMessage();
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum FieldDescriptorProto_Type : int {
-  FieldDescriptorProto_Type_TYPE_DOUBLE = 1,
-  FieldDescriptorProto_Type_TYPE_FLOAT = 2,
-  FieldDescriptorProto_Type_TYPE_INT64 = 3,
-  FieldDescriptorProto_Type_TYPE_UINT64 = 4,
-  FieldDescriptorProto_Type_TYPE_INT32 = 5,
-  FieldDescriptorProto_Type_TYPE_FIXED64 = 6,
-  FieldDescriptorProto_Type_TYPE_FIXED32 = 7,
-  FieldDescriptorProto_Type_TYPE_BOOL = 8,
-  FieldDescriptorProto_Type_TYPE_STRING = 9,
-  FieldDescriptorProto_Type_TYPE_GROUP = 10,
-  FieldDescriptorProto_Type_TYPE_MESSAGE = 11,
-  FieldDescriptorProto_Type_TYPE_BYTES = 12,
-  FieldDescriptorProto_Type_TYPE_UINT32 = 13,
-  FieldDescriptorProto_Type_TYPE_ENUM = 14,
-  FieldDescriptorProto_Type_TYPE_SFIXED32 = 15,
-  FieldDescriptorProto_Type_TYPE_SFIXED64 = 16,
-  FieldDescriptorProto_Type_TYPE_SINT32 = 17,
-  FieldDescriptorProto_Type_TYPE_SINT64 = 18,
-};
-enum FieldDescriptorProto_Label : int {
-  FieldDescriptorProto_Label_LABEL_OPTIONAL = 1,
-  FieldDescriptorProto_Label_LABEL_REQUIRED = 2,
-  FieldDescriptorProto_Label_LABEL_REPEATED = 3,
-};
+  PERFETTO_DCHECK(size < proto_utils::kMaxMessageLength);
+  // Write the proto preamble (field id, type and length of the field).
+  uint8_t buffer[proto_utils::kMaxSimpleFieldEncodedSize];
+  uint8_t* pos = buffer;
+  pos = proto_utils::WriteVarInt(proto_utils::MakeTagLengthDelimited(field_id),
+                                 pos);
+  pos = proto_utils::WriteVarInt(static_cast<uint32_t>(size), pos);
+  WriteToStream(buffer, pos);
 
-class PERFETTO_EXPORT_COMPONENT OneofOptions : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
+  const uint8_t* src_u8 = reinterpret_cast<const uint8_t*>(src);
+  WriteToStream(src_u8, src_u8 + size);
+}
 
-  OneofOptions();
-  ~OneofOptions() override;
-  OneofOptions(OneofOptions&&) noexcept;
-  OneofOptions& operator=(OneofOptions&&);
-  OneofOptions(const OneofOptions&);
-  OneofOptions& operator=(const OneofOptions&);
-  bool operator==(const OneofOptions&) const;
-  bool operator!=(const OneofOptions& other) const { return !(*this == other); }
+size_t Message::AppendScatteredBytes(uint32_t field_id,
+                                     ContiguousMemoryRange* ranges,
+                                     size_t num_ranges) {
+  PERFETTO_DCHECK(field_id);
+  if (nested_message_)
+    EndNestedMessage();
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  size_t size = 0;
+  for (size_t i = 0; i < num_ranges; ++i) {
+    size += ranges[i].size();
+  }
 
- private:
+  PERFETTO_DCHECK(size < proto_utils::kMaxMessageLength);
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  uint8_t buffer[proto_utils::kMaxSimpleFieldEncodedSize];
+  uint8_t* pos = buffer;
+  pos = proto_utils::WriteVarInt(proto_utils::MakeTagLengthDelimited(field_id),
+                                 pos);
+  pos = proto_utils::WriteVarInt(static_cast<uint32_t>(size), pos);
+  WriteToStream(buffer, pos);
 
-  std::bitset<2> _has_field_{};
-};
+  for (size_t i = 0; i < num_ranges; ++i) {
+    auto& range = ranges[i];
+    WriteToStream(range.begin, range.end);
+  }
 
+  return size;
+}
 
-class PERFETTO_EXPORT_COMPONENT EnumValueDescriptorProto : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kNameFieldNumber = 1,
-    kNumberFieldNumber = 2,
-  };
+uint32_t Message::Finalize() {
+  if (is_finalized())
+    return size_;
 
-  EnumValueDescriptorProto();
-  ~EnumValueDescriptorProto() override;
-  EnumValueDescriptorProto(EnumValueDescriptorProto&&) noexcept;
-  EnumValueDescriptorProto& operator=(EnumValueDescriptorProto&&);
-  EnumValueDescriptorProto(const EnumValueDescriptorProto&);
-  EnumValueDescriptorProto& operator=(const EnumValueDescriptorProto&);
-  bool operator==(const EnumValueDescriptorProto&) const;
-  bool operator!=(const EnumValueDescriptorProto& other) const { return !(*this == other); }
+  if (nested_message_)
+    EndNestedMessage();
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  // Write the length of the nested message a posteriori, using a leading-zero
+  // redundant varint encoding. This can be nullptr for the root message, among
+  // many reasons, because the TraceWriterImpl delegate is keeping track of the
+  // root fragment size independently.
+  if (size_field_) {
+    PERFETTO_DCHECK(!is_finalized());
+    PERFETTO_DCHECK(size_ < proto_utils::kMaxMessageLength);
+    //
+    // Normally the size of a protozero message is written with 4 bytes just
+    // before the contents of the message itself:
+    //
+    //    size          message data
+    //   [aa bb cc dd] [01 23 45 67 ...]
+    //
+    // We always reserve 4 bytes for the size, because the real size of the
+    // message isn't known until the call to Finalize(). This is possible
+    // because we can use leading zero redundant varint coding to expand any
+    // size smaller than 256 MiB to 4 bytes.
+    //
+    // However this is wasteful for short, frequently written messages, so the
+    // code below uses a 1 byte size field when possible. This is done by
+    // shifting the already-written data (which should still be in the cache)
+    // back by 3 bytes, resulting in this layout:
+    //
+    //   size  message data
+    //   [aa] [01 23 45 67 ...]
+    //
+    // We can only do this optimization if the message is contained in a single
+    // chunk (since we can't modify previously committed chunks). We can check
+    // this by verifying that the size field is immediately before the message
+    // in memory and is fully contained by the current chunk.
+    //
+    if (PERFETTO_LIKELY(size_ <= proto_utils::kMaxOneByteMessageLength &&
+                        size_field_ ==
+                            stream_writer_->write_ptr() - size_ -
+                                proto_utils::kMessageLengthFieldSize &&
+                        size_field_ >= stream_writer_->cur_range().begin)) {
+      stream_writer_->Rewind(size_, kBytesToCompact);
+      PERFETTO_DCHECK(size_field_ == stream_writer_->write_ptr() - size_ - 1u);
+      *size_field_ = static_cast<uint8_t>(size_);
+      message_state_ = MessageState::kFinalizedWithCompaction;
+    } else {
+      proto_utils::WriteRedundantVarInt(size_, size_field_);
+      message_state_ = MessageState::kFinalized;
+    }
+    size_field_ = nullptr;
+  } else {
+    message_state_ = MessageState::kFinalized;
+  }
 
-  bool has_name() const { return _has_field_[1]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
+#if PERFETTO_DCHECK_IS_ON()
+  if (handle_)
+    handle_->reset_message();
+#endif
 
-  bool has_number() const { return _has_field_[2]; }
-  int32_t number() const { return number_; }
-  void set_number(int32_t value) { number_ = value; _has_field_.set(2); }
+  return size_;
+}
 
- private:
-  std::string name_{};
-  int32_t number_{};
+Message* Message::BeginNestedMessageInternal(uint32_t field_id) {
+  PERFETTO_DCHECK(field_id);
+  if (nested_message_)
+    EndNestedMessage();
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  // Write the proto preamble for the nested message.
+  uint8_t data[proto_utils::kMaxTagEncodedSize];
+  uint8_t* data_end = proto_utils::WriteVarInt(
+      proto_utils::MakeTagLengthDelimited(field_id), data);
+  WriteToStream(data, data_end);
 
-  std::bitset<3> _has_field_{};
-};
+  Message* message = arena_->NewMessage();
+  message->Reset(stream_writer_, arena_);
 
+  // The length of the nested message cannot be known upfront. So right now
+  // just reserve the bytes to encode the size after the nested message is done.
+  message->set_size_field(
+      stream_writer_->ReserveBytes(proto_utils::kMessageLengthFieldSize));
+  size_ += proto_utils::kMessageLengthFieldSize;
 
-class PERFETTO_EXPORT_COMPONENT EnumDescriptorProto : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kNameFieldNumber = 1,
-    kValueFieldNumber = 2,
-    kReservedNameFieldNumber = 5,
-  };
+  nested_message_ = message;
+  return message;
+}
 
-  EnumDescriptorProto();
-  ~EnumDescriptorProto() override;
-  EnumDescriptorProto(EnumDescriptorProto&&) noexcept;
-  EnumDescriptorProto& operator=(EnumDescriptorProto&&);
-  EnumDescriptorProto(const EnumDescriptorProto&);
-  EnumDescriptorProto& operator=(const EnumDescriptorProto&);
-  bool operator==(const EnumDescriptorProto&) const;
-  bool operator!=(const EnumDescriptorProto& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_name() const { return _has_field_[1]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
-
-  const std::vector<EnumValueDescriptorProto>& value() const { return value_; }
-  std::vector<EnumValueDescriptorProto>* mutable_value() { return &value_; }
-  int value_size() const;
-  void clear_value();
-  EnumValueDescriptorProto* add_value();
-
-  const std::vector<std::string>& reserved_name() const { return reserved_name_; }
-  std::vector<std::string>* mutable_reserved_name() { return &reserved_name_; }
-  int reserved_name_size() const { return static_cast<int>(reserved_name_.size()); }
-  void clear_reserved_name() { reserved_name_.clear(); }
-  void add_reserved_name(std::string value) { reserved_name_.emplace_back(value); }
-  std::string* add_reserved_name() { reserved_name_.emplace_back(); return &reserved_name_.back(); }
+void Message::EndNestedMessage() {
+  size_ += nested_message_->Finalize();
+  if (nested_message_->message_state_ ==
+      MessageState::kFinalizedWithCompaction) {
+    size_ -= kBytesToCompact;
+  }
+  arena_->DeleteLastMessage(nested_message_);
+  nested_message_ = nullptr;
+}
 
- private:
-  std::string name_{};
-  std::vector<EnumValueDescriptorProto> value_;
-  std::vector<std::string> reserved_name_;
+}  // namespace protozero
+// gen_amalgamated begin source: src/protozero/message_arena.cc
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+// gen_amalgamated expanded: #include "perfetto/protozero/message_arena.h"
 
-  std::bitset<6> _has_field_{};
-};
+#include <atomic>
+#include <type_traits>
 
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message_handle.h"
 
-class PERFETTO_EXPORT_COMPONENT OneofDescriptorProto : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kNameFieldNumber = 1,
-    kOptionsFieldNumber = 2,
-  };
+namespace protozero {
 
-  OneofDescriptorProto();
-  ~OneofDescriptorProto() override;
-  OneofDescriptorProto(OneofDescriptorProto&&) noexcept;
-  OneofDescriptorProto& operator=(OneofDescriptorProto&&);
-  OneofDescriptorProto(const OneofDescriptorProto&);
-  OneofDescriptorProto& operator=(const OneofDescriptorProto&);
-  bool operator==(const OneofDescriptorProto&) const;
-  bool operator!=(const OneofDescriptorProto& other) const { return !(*this == other); }
+MessageArena::MessageArena() {
+  // The code below assumes that there is always at least one block.
+  blocks_.emplace_front();
+}
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+MessageArena::~MessageArena() = default;
 
-  bool has_name() const { return _has_field_[1]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
+Message* MessageArena::NewMessage() {
+  PERFETTO_DCHECK(!blocks_.empty());  // Should never become empty.
 
-  bool has_options() const { return _has_field_[2]; }
-  const OneofOptions& options() const { return *options_; }
-  OneofOptions* mutable_options() { _has_field_.set(2); return options_.get(); }
+  Block* block = &blocks_.front();
+  if (PERFETTO_UNLIKELY(block->entries >= Block::kCapacity)) {
+    blocks_.emplace_front();
+    block = &blocks_.front();
+  }
+  const auto idx = block->entries++;
+  void* storage = block->storage[idx];
+  PERFETTO_ASAN_UNPOISON(storage, sizeof(Message));
+  return new (storage) Message();
+}
 
- private:
-  std::string name_{};
-  ::protozero::CopyablePtr<OneofOptions> options_;
+void MessageArena::DeleteLastMessageInternal() {
+  PERFETTO_DCHECK(!blocks_.empty());  // Should never be empty, see below.
+  Block* block = &blocks_.front();
+  PERFETTO_DCHECK(block->entries > 0);
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  // This is the reason why there is no ~Message() call here.
+  // MessageArea::Reset() (see header) also relies on dtor being trivial.
+  static_assert(std::is_trivially_destructible<Message>::value,
+                "Message must be trivially destructible");
 
-  std::bitset<3> _has_field_{};
-};
+  --block->entries;
+  PERFETTO_ASAN_POISON(&block->storage[block->entries], sizeof(Message));
 
+  // Don't remove the first block to avoid malloc/free calls when the root
+  // message is reset. Hitting the allocator all the times is a waste of time.
+  if (block->entries == 0 && std::next(blocks_.cbegin()) != blocks_.cend()) {
+    blocks_.pop_front();
+  }
+}
 
-class PERFETTO_EXPORT_COMPONENT FieldDescriptorProto : public ::protozero::CppMessageObj {
- public:
-  using Type = FieldDescriptorProto_Type;
-  static constexpr auto TYPE_DOUBLE = FieldDescriptorProto_Type_TYPE_DOUBLE;
-  static constexpr auto TYPE_FLOAT = FieldDescriptorProto_Type_TYPE_FLOAT;
-  static constexpr auto TYPE_INT64 = FieldDescriptorProto_Type_TYPE_INT64;
-  static constexpr auto TYPE_UINT64 = FieldDescriptorProto_Type_TYPE_UINT64;
-  static constexpr auto TYPE_INT32 = FieldDescriptorProto_Type_TYPE_INT32;
-  static constexpr auto TYPE_FIXED64 = FieldDescriptorProto_Type_TYPE_FIXED64;
-  static constexpr auto TYPE_FIXED32 = FieldDescriptorProto_Type_TYPE_FIXED32;
-  static constexpr auto TYPE_BOOL = FieldDescriptorProto_Type_TYPE_BOOL;
-  static constexpr auto TYPE_STRING = FieldDescriptorProto_Type_TYPE_STRING;
-  static constexpr auto TYPE_GROUP = FieldDescriptorProto_Type_TYPE_GROUP;
-  static constexpr auto TYPE_MESSAGE = FieldDescriptorProto_Type_TYPE_MESSAGE;
-  static constexpr auto TYPE_BYTES = FieldDescriptorProto_Type_TYPE_BYTES;
-  static constexpr auto TYPE_UINT32 = FieldDescriptorProto_Type_TYPE_UINT32;
-  static constexpr auto TYPE_ENUM = FieldDescriptorProto_Type_TYPE_ENUM;
-  static constexpr auto TYPE_SFIXED32 = FieldDescriptorProto_Type_TYPE_SFIXED32;
-  static constexpr auto TYPE_SFIXED64 = FieldDescriptorProto_Type_TYPE_SFIXED64;
-  static constexpr auto TYPE_SINT32 = FieldDescriptorProto_Type_TYPE_SINT32;
-  static constexpr auto TYPE_SINT64 = FieldDescriptorProto_Type_TYPE_SINT64;
-  static constexpr auto Type_MIN = FieldDescriptorProto_Type_TYPE_DOUBLE;
-  static constexpr auto Type_MAX = FieldDescriptorProto_Type_TYPE_SINT64;
-  using Label = FieldDescriptorProto_Label;
-  static constexpr auto LABEL_OPTIONAL = FieldDescriptorProto_Label_LABEL_OPTIONAL;
-  static constexpr auto LABEL_REQUIRED = FieldDescriptorProto_Label_LABEL_REQUIRED;
-  static constexpr auto LABEL_REPEATED = FieldDescriptorProto_Label_LABEL_REPEATED;
-  static constexpr auto Label_MIN = FieldDescriptorProto_Label_LABEL_OPTIONAL;
-  static constexpr auto Label_MAX = FieldDescriptorProto_Label_LABEL_REPEATED;
-  enum FieldNumbers {
-    kNameFieldNumber = 1,
-    kNumberFieldNumber = 3,
-    kLabelFieldNumber = 4,
-    kTypeFieldNumber = 5,
-    kTypeNameFieldNumber = 6,
-    kExtendeeFieldNumber = 2,
-    kDefaultValueFieldNumber = 7,
-    kOneofIndexFieldNumber = 9,
-  };
+}  // namespace protozero
+// gen_amalgamated begin source: src/protozero/packed_repeated_fields.cc
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-  FieldDescriptorProto();
-  ~FieldDescriptorProto() override;
-  FieldDescriptorProto(FieldDescriptorProto&&) noexcept;
-  FieldDescriptorProto& operator=(FieldDescriptorProto&&);
-  FieldDescriptorProto(const FieldDescriptorProto&);
-  FieldDescriptorProto& operator=(const FieldDescriptorProto&);
-  bool operator==(const FieldDescriptorProto&) const;
-  bool operator!=(const FieldDescriptorProto& other) const { return !(*this == other); }
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
 
-  bool has_name() const { return _has_field_[1]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
+namespace protozero {
 
-  bool has_number() const { return _has_field_[3]; }
-  int32_t number() const { return number_; }
-  void set_number(int32_t value) { number_ = value; _has_field_.set(3); }
+void PackedBufferBase::GrowSlowpath() {
+  size_t write_off = static_cast<size_t>(write_ptr_ - storage_begin_);
+  size_t old_size = static_cast<size_t>(storage_end_ - storage_begin_);
+  size_t new_size = old_size < 65536 ? (old_size * 2) : (old_size * 3 / 2);
+  new_size = perfetto::base::AlignUp<4096>(new_size);
+  std::unique_ptr<uint8_t[]> new_buf(new uint8_t[new_size]);
+  memcpy(new_buf.get(), storage_begin_, old_size);
+  heap_buf_ = std::move(new_buf);
+  storage_begin_ = heap_buf_.get();
+  storage_end_ = storage_begin_ + new_size;
+  write_ptr_ = storage_begin_ + write_off;
+}
 
-  bool has_label() const { return _has_field_[4]; }
-  FieldDescriptorProto_Label label() const { return label_; }
-  void set_label(FieldDescriptorProto_Label value) { label_ = value; _has_field_.set(4); }
+void PackedBufferBase::Reset() {
+  heap_buf_.reset();
+  storage_begin_ = reinterpret_cast<uint8_t*>(&stack_buf_[0]);
+  storage_end_ = reinterpret_cast<uint8_t*>(&stack_buf_[kOnStackStorageSize]);
+  write_ptr_ = storage_begin_;
+}
 
-  bool has_type() const { return _has_field_[5]; }
-  FieldDescriptorProto_Type type() const { return type_; }
-  void set_type(FieldDescriptorProto_Type value) { type_ = value; _has_field_.set(5); }
+}  // namespace protozero
+// gen_amalgamated begin source: src/protozero/proto_decoder.cc
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-  bool has_type_name() const { return _has_field_[6]; }
-  const std::string& type_name() const { return type_name_; }
-  void set_type_name(const std::string& value) { type_name_ = value; _has_field_.set(6); }
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 
-  bool has_extendee() const { return _has_field_[2]; }
-  const std::string& extendee() const { return extendee_; }
-  void set_extendee(const std::string& value) { extendee_ = value; _has_field_.set(2); }
+#include <string.h>
 
-  bool has_default_value() const { return _has_field_[7]; }
-  const std::string& default_value() const { return default_value_; }
-  void set_default_value(const std::string& value) { default_value_ = value; _has_field_.set(7); }
+#include <cinttypes>
+#include <limits>
+#include <memory>
 
-  bool has_oneof_index() const { return _has_field_[9]; }
-  int32_t oneof_index() const { return oneof_index_; }
-  void set_oneof_index(int32_t value) { oneof_index_ = value; _has_field_.set(9); }
+// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
- private:
-  std::string name_{};
-  int32_t number_{};
-  FieldDescriptorProto_Label label_{};
-  FieldDescriptorProto_Type type_{};
-  std::string type_name_{};
-  std::string extendee_{};
-  std::string default_value_{};
-  int32_t oneof_index_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<10> _has_field_{};
-};
+namespace protozero {
 
+using namespace proto_utils;
 
-class PERFETTO_EXPORT_COMPONENT DescriptorProto : public ::protozero::CppMessageObj {
- public:
-  using ReservedRange = DescriptorProto_ReservedRange;
-  enum FieldNumbers {
-    kNameFieldNumber = 1,
-    kFieldFieldNumber = 2,
-    kExtensionFieldNumber = 6,
-    kNestedTypeFieldNumber = 3,
-    kEnumTypeFieldNumber = 4,
-    kOneofDeclFieldNumber = 8,
-    kReservedRangeFieldNumber = 9,
-    kReservedNameFieldNumber = 10,
-  };
+#if !PERFETTO_IS_LITTLE_ENDIAN()
+#error Unimplemented for big endian archs.
+#endif
 
-  DescriptorProto();
-  ~DescriptorProto() override;
-  DescriptorProto(DescriptorProto&&) noexcept;
-  DescriptorProto& operator=(DescriptorProto&&);
-  DescriptorProto(const DescriptorProto&);
-  DescriptorProto& operator=(const DescriptorProto&);
-  bool operator==(const DescriptorProto&) const;
-  bool operator!=(const DescriptorProto& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_name() const { return _has_field_[1]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
-
-  const std::vector<FieldDescriptorProto>& field() const { return field_; }
-  std::vector<FieldDescriptorProto>* mutable_field() { return &field_; }
-  int field_size() const;
-  void clear_field();
-  FieldDescriptorProto* add_field();
-
-  const std::vector<FieldDescriptorProto>& extension() const { return extension_; }
-  std::vector<FieldDescriptorProto>* mutable_extension() { return &extension_; }
-  int extension_size() const;
-  void clear_extension();
-  FieldDescriptorProto* add_extension();
-
-  const std::vector<DescriptorProto>& nested_type() const { return nested_type_; }
-  std::vector<DescriptorProto>* mutable_nested_type() { return &nested_type_; }
-  int nested_type_size() const;
-  void clear_nested_type();
-  DescriptorProto* add_nested_type();
-
-  const std::vector<EnumDescriptorProto>& enum_type() const { return enum_type_; }
-  std::vector<EnumDescriptorProto>* mutable_enum_type() { return &enum_type_; }
-  int enum_type_size() const;
-  void clear_enum_type();
-  EnumDescriptorProto* add_enum_type();
-
-  const std::vector<OneofDescriptorProto>& oneof_decl() const { return oneof_decl_; }
-  std::vector<OneofDescriptorProto>* mutable_oneof_decl() { return &oneof_decl_; }
-  int oneof_decl_size() const;
-  void clear_oneof_decl();
-  OneofDescriptorProto* add_oneof_decl();
-
-  const std::vector<DescriptorProto_ReservedRange>& reserved_range() const { return reserved_range_; }
-  std::vector<DescriptorProto_ReservedRange>* mutable_reserved_range() { return &reserved_range_; }
-  int reserved_range_size() const;
-  void clear_reserved_range();
-  DescriptorProto_ReservedRange* add_reserved_range();
-
-  const std::vector<std::string>& reserved_name() const { return reserved_name_; }
-  std::vector<std::string>* mutable_reserved_name() { return &reserved_name_; }
-  int reserved_name_size() const { return static_cast<int>(reserved_name_.size()); }
-  void clear_reserved_name() { reserved_name_.clear(); }
-  void add_reserved_name(std::string value) { reserved_name_.emplace_back(value); }
-  std::string* add_reserved_name() { reserved_name_.emplace_back(); return &reserved_name_.back(); }
+namespace {
 
- private:
-  std::string name_{};
-  std::vector<FieldDescriptorProto> field_;
-  std::vector<FieldDescriptorProto> extension_;
-  std::vector<DescriptorProto> nested_type_;
-  std::vector<EnumDescriptorProto> enum_type_;
-  std::vector<OneofDescriptorProto> oneof_decl_;
-  std::vector<DescriptorProto_ReservedRange> reserved_range_;
-  std::vector<std::string> reserved_name_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<11> _has_field_{};
+struct ParseFieldResult {
+  enum ParseResult { kAbort, kSkip, kOk };
+  ParseResult parse_res;
+  const uint8_t* next;
+  Field field;
 };
 
+// Parses one field and returns the field itself and a pointer to the next
+// field to parse. If parsing fails, the returned |next| == |buffer|.
+ParseFieldResult ParseOneField(const uint8_t* const buffer,
+                               const uint8_t* const end) {
+  ParseFieldResult res{ParseFieldResult::kAbort, buffer, Field{}};
 
-class PERFETTO_EXPORT_COMPONENT DescriptorProto_ReservedRange : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kStartFieldNumber = 1,
-    kEndFieldNumber = 2,
-  };
-
-  DescriptorProto_ReservedRange();
-  ~DescriptorProto_ReservedRange() override;
-  DescriptorProto_ReservedRange(DescriptorProto_ReservedRange&&) noexcept;
-  DescriptorProto_ReservedRange& operator=(DescriptorProto_ReservedRange&&);
-  DescriptorProto_ReservedRange(const DescriptorProto_ReservedRange&);
-  DescriptorProto_ReservedRange& operator=(const DescriptorProto_ReservedRange&);
-  bool operator==(const DescriptorProto_ReservedRange&) const;
-  bool operator!=(const DescriptorProto_ReservedRange& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  const uint8_t* pos = buffer;
 
-  bool has_start() const { return _has_field_[1]; }
-  int32_t start() const { return start_; }
-  void set_start(int32_t value) { start_ = value; _has_field_.set(1); }
+  // If we've already hit the end, just return an invalid field.
+  if (PERFETTO_UNLIKELY(pos >= end))
+    return res;
 
-  bool has_end() const { return _has_field_[2]; }
-  int32_t end() const { return end_; }
-  void set_end(int32_t value) { end_ = value; _has_field_.set(2); }
+  uint64_t preamble = 0;
+  if (PERFETTO_LIKELY(*pos < 0x80)) {  // Fastpath for fields with ID < 16.
+    preamble = *(pos++);
+  } else {
+    const uint8_t* next = ParseVarInt(pos, end, &preamble);
+    if (PERFETTO_UNLIKELY(pos == next))
+      return res;
+    pos = next;
+  }
 
- private:
-  int32_t start_{};
-  int32_t end_{};
+  uint32_t field_id =
+      static_cast<uint32_t>(proto_utils::GetTagFieldId(preamble));
+  if (field_id == 0 || pos >= end)
+    return res;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  auto field_type =
+      static_cast<uint8_t>(proto_utils::GetTagFieldType(preamble));
+  const uint8_t* new_pos = pos;
+  uint64_t int_value = 0;
+  uint64_t size = 0;
 
-  std::bitset<3> _has_field_{};
-};
+  switch (field_type) {
+    case static_cast<uint8_t>(ProtoWireType::kVarInt): {
+      new_pos = ParseVarInt(pos, end, &int_value);
 
+      // new_pos not being greater than pos means ParseVarInt could not fully
+      // parse the number. This is because we are out of space in the buffer.
+      // Set the id to zero and return but don't update the offset so a future
+      // read can read this field.
+      if (PERFETTO_UNLIKELY(new_pos == pos))
+        return res;
 
-class PERFETTO_EXPORT_COMPONENT FileDescriptorProto : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kNameFieldNumber = 1,
-    kPackageFieldNumber = 2,
-    kDependencyFieldNumber = 3,
-    kPublicDependencyFieldNumber = 10,
-    kWeakDependencyFieldNumber = 11,
-    kMessageTypeFieldNumber = 4,
-    kEnumTypeFieldNumber = 5,
-    kExtensionFieldNumber = 7,
-  };
+      break;
+    }
 
-  FileDescriptorProto();
-  ~FileDescriptorProto() override;
-  FileDescriptorProto(FileDescriptorProto&&) noexcept;
-  FileDescriptorProto& operator=(FileDescriptorProto&&);
-  FileDescriptorProto(const FileDescriptorProto&);
-  FileDescriptorProto& operator=(const FileDescriptorProto&);
-  bool operator==(const FileDescriptorProto&) const;
-  bool operator!=(const FileDescriptorProto& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_name() const { return _has_field_[1]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
-
-  bool has_package() const { return _has_field_[2]; }
-  const std::string& package() const { return package_; }
-  void set_package(const std::string& value) { package_ = value; _has_field_.set(2); }
-
-  const std::vector<std::string>& dependency() const { return dependency_; }
-  std::vector<std::string>* mutable_dependency() { return &dependency_; }
-  int dependency_size() const { return static_cast<int>(dependency_.size()); }
-  void clear_dependency() { dependency_.clear(); }
-  void add_dependency(std::string value) { dependency_.emplace_back(value); }
-  std::string* add_dependency() { dependency_.emplace_back(); return &dependency_.back(); }
-
-  const std::vector<int32_t>& public_dependency() const { return public_dependency_; }
-  std::vector<int32_t>* mutable_public_dependency() { return &public_dependency_; }
-  int public_dependency_size() const { return static_cast<int>(public_dependency_.size()); }
-  void clear_public_dependency() { public_dependency_.clear(); }
-  void add_public_dependency(int32_t value) { public_dependency_.emplace_back(value); }
-  int32_t* add_public_dependency() { public_dependency_.emplace_back(); return &public_dependency_.back(); }
-
-  const std::vector<int32_t>& weak_dependency() const { return weak_dependency_; }
-  std::vector<int32_t>* mutable_weak_dependency() { return &weak_dependency_; }
-  int weak_dependency_size() const { return static_cast<int>(weak_dependency_.size()); }
-  void clear_weak_dependency() { weak_dependency_.clear(); }
-  void add_weak_dependency(int32_t value) { weak_dependency_.emplace_back(value); }
-  int32_t* add_weak_dependency() { weak_dependency_.emplace_back(); return &weak_dependency_.back(); }
-
-  const std::vector<DescriptorProto>& message_type() const { return message_type_; }
-  std::vector<DescriptorProto>* mutable_message_type() { return &message_type_; }
-  int message_type_size() const;
-  void clear_message_type();
-  DescriptorProto* add_message_type();
-
-  const std::vector<EnumDescriptorProto>& enum_type() const { return enum_type_; }
-  std::vector<EnumDescriptorProto>* mutable_enum_type() { return &enum_type_; }
-  int enum_type_size() const;
-  void clear_enum_type();
-  EnumDescriptorProto* add_enum_type();
-
-  const std::vector<FieldDescriptorProto>& extension() const { return extension_; }
-  std::vector<FieldDescriptorProto>* mutable_extension() { return &extension_; }
-  int extension_size() const;
-  void clear_extension();
-  FieldDescriptorProto* add_extension();
+    case static_cast<uint8_t>(ProtoWireType::kLengthDelimited): {
+      uint64_t payload_length;
+      new_pos = ParseVarInt(pos, end, &payload_length);
+      if (PERFETTO_UNLIKELY(new_pos == pos))
+        return res;
 
- private:
-  std::string name_{};
-  std::string package_{};
-  std::vector<std::string> dependency_;
-  std::vector<int32_t> public_dependency_;
-  std::vector<int32_t> weak_dependency_;
-  std::vector<DescriptorProto> message_type_;
-  std::vector<EnumDescriptorProto> enum_type_;
-  std::vector<FieldDescriptorProto> extension_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<12> _has_field_{};
-};
+      // ParseVarInt guarantees that |new_pos| <= |end| when it succeeds;
+      if (payload_length > static_cast<uint64_t>(end - new_pos))
+        return res;
 
+      const uintptr_t payload_start = reinterpret_cast<uintptr_t>(new_pos);
+      int_value = payload_start;
+      size = payload_length;
+      new_pos += payload_length;
+      break;
+    }
 
-class PERFETTO_EXPORT_COMPONENT FileDescriptorSet : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kFileFieldNumber = 1,
-  };
+    case static_cast<uint8_t>(ProtoWireType::kFixed64): {
+      new_pos = pos + sizeof(uint64_t);
+      if (PERFETTO_UNLIKELY(new_pos > end))
+        return res;
+      memcpy(&int_value, pos, sizeof(uint64_t));
+      break;
+    }
 
-  FileDescriptorSet();
-  ~FileDescriptorSet() override;
-  FileDescriptorSet(FileDescriptorSet&&) noexcept;
-  FileDescriptorSet& operator=(FileDescriptorSet&&);
-  FileDescriptorSet(const FileDescriptorSet&);
-  FileDescriptorSet& operator=(const FileDescriptorSet&);
-  bool operator==(const FileDescriptorSet&) const;
-  bool operator!=(const FileDescriptorSet& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<FileDescriptorProto>& file() const { return file_; }
-  std::vector<FileDescriptorProto>* mutable_file() { return &file_; }
-  int file_size() const;
-  void clear_file();
-  FileDescriptorProto* add_file();
+    case static_cast<uint8_t>(ProtoWireType::kFixed32): {
+      new_pos = pos + sizeof(uint32_t);
+      if (PERFETTO_UNLIKELY(new_pos > end))
+        return res;
+      memcpy(&int_value, pos, sizeof(uint32_t));
+      break;
+    }
 
- private:
-  std::vector<FileDescriptorProto> file_;
+    default:
+      PERFETTO_DLOG("Invalid proto field type: %u", field_type);
+      return res;
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  res.next = new_pos;
 
-  std::bitset<2> _has_field_{};
-};
+  if (PERFETTO_UNLIKELY(field_id > Field::kMaxId)) {
+    PERFETTO_DLOG("Skipping field %" PRIu32 " because its id > %" PRIu32,
+                  field_id, Field::kMaxId);
+    res.parse_res = ParseFieldResult::kSkip;
+    return res;
+  }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  if (PERFETTO_UNLIKELY(size > proto_utils::kMaxMessageLength)) {
+    PERFETTO_DLOG("Skipping field %" PRIu32 " because it's too big (%" PRIu64
+                  " KB)",
+                  field_id, size / 1024);
+    res.parse_res = ParseFieldResult::kSkip;
+    return res;
+  }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_DESCRIPTOR_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/common/descriptor.gen.h"
+  res.parse_res = ParseFieldResult::kOk;
+  res.field.initialize(field_id, field_type, int_value,
+                       static_cast<uint32_t>(size));
+  return res;
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+}  // namespace
 
-OneofOptions::OneofOptions() = default;
-OneofOptions::~OneofOptions() = default;
-OneofOptions::OneofOptions(const OneofOptions&) = default;
-OneofOptions& OneofOptions::operator=(const OneofOptions&) = default;
-OneofOptions::OneofOptions(OneofOptions&&) noexcept = default;
-OneofOptions& OneofOptions::operator=(OneofOptions&&) = default;
+Field ProtoDecoder::FindField(uint32_t field_id) {
+  Field res{};
+  auto old_position = read_ptr_;
+  read_ptr_ = begin_;
+  for (auto f = ReadField(); f.valid(); f = ReadField()) {
+    if (f.id() == field_id) {
+      res = f;
+      break;
+    }
+  }
+  read_ptr_ = old_position;
+  return res;
+}
 
-bool OneofOptions::operator==(const OneofOptions& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+Field ProtoDecoder::ReadField() {
+  ParseFieldResult res;
+  do {
+    res = ParseOneField(read_ptr_, end_);
+    read_ptr_ = res.next;
+  } while (PERFETTO_UNLIKELY(res.parse_res == ParseFieldResult::kSkip));
+  return res.field;
 }
 
-bool OneofOptions::ParseFromArray(const void* raw, size_t size) {
+void TypedProtoDecoderBase::ParseAllFields() {
+  const uint8_t* cur = begin_;
+  ParseFieldResult res;
+  for (;;) {
+    res = ParseOneField(cur, end_);
+    PERFETTO_DCHECK(res.parse_res != ParseFieldResult::kOk || res.next != cur);
+    cur = res.next;
+    if (PERFETTO_UNLIKELY(res.parse_res == ParseFieldResult::kSkip))
+      continue;
+    if (PERFETTO_UNLIKELY(res.parse_res == ParseFieldResult::kAbort))
+      break;
+
+    PERFETTO_DCHECK(res.parse_res == ParseFieldResult::kOk);
+    PERFETTO_DCHECK(res.field.valid());
+    auto field_id = res.field.id();
+    if (PERFETTO_UNLIKELY(field_id >= num_fields_))
+      continue;
+
+    // There are two reasons why we might want to expand the heap capacity:
+    // 1. We are writing a non-repeated field, which has an id >
+    //    INITIAL_STACK_CAPACITY. In this case ExpandHeapStorage() ensures to
+    //    allocate at least (num_fields_ + 1) slots.
+    // 2. We are writing a repeated field but ran out of capacity.
+    if (PERFETTO_UNLIKELY(field_id >= size_ || size_ >= capacity_))
+      ExpandHeapStorage();
+
+    PERFETTO_DCHECK(field_id < size_);
+    Field* fld = &fields_[field_id];
+    if (PERFETTO_LIKELY(!fld->valid())) {
+      // This is the first time we see this field.
+      *fld = std::move(res.field);
+    } else {
+      // Repeated field case.
+      // In this case we need to:
+      // 1. Append the last value of the field to end of the repeated field
+      //    storage.
+      // 2. Replace the default instance at offset |field_id| with the current
+      //    value. This is because in case of repeated field a call to Get(X) is
+      //    supposed to return the last value of X, not the first one.
+      // This is so that the RepeatedFieldIterator will iterate in the right
+      // order, see comments on RepeatedFieldIterator.
+      if (num_fields_ > size_) {
+        ExpandHeapStorage();
+        fld = &fields_[field_id];
+      }
+
+      PERFETTO_DCHECK(size_ < capacity_);
+      fields_[size_++] = *fld;
+      *fld = std::move(res.field);
+    }
+  }
+  read_ptr_ = res.next;
+}
+
+void TypedProtoDecoderBase::ExpandHeapStorage() {
+  // When we expand the heap we must ensure that we have at very last capacity
+  // to deal with all known fields plus at least one repeated field. We go +2048
+  // here based on observations on a large 4GB android trace. This is to avoid
+  // trivial re-allocations when dealing with repeated fields of a message that
+  // has > INITIAL_STACK_CAPACITY fields.
+  const uint32_t min_capacity = num_fields_ + 2048;  // Any num >= +1 will do.
+  const uint32_t new_capacity = std::max(capacity_ * 2, min_capacity);
+  PERFETTO_CHECK(new_capacity > size_ && new_capacity > num_fields_);
+  std::unique_ptr<Field[]> new_storage(new Field[new_capacity]);
+
+  static_assert(std::is_trivially_constructible<Field>::value,
+                "Field must be trivially constructible");
+  static_assert(std::is_trivially_copyable<Field>::value,
+                "Field must be trivially copyable");
+
+  // Zero-initialize the slots for known field IDs slots, as they can be
+  // randomly accessed. Instead, there is no need to initialize the repeated
+  // slots, because they are written linearly with no gaps and are always
+  // initialized before incrementing |size_|.
+  const uint32_t new_size = std::max(size_, num_fields_);
+  memset(&new_storage[size_], 0, sizeof(Field) * (new_size - size_));
+
+  memcpy(&new_storage[0], fields_, sizeof(Field) * size_);
+
+  heap_storage_ = std::move(new_storage);
+  fields_ = &heap_storage_[0];
+  capacity_ = new_capacity;
+  size_ = new_size;
+}
+
+}  // namespace protozero
+// gen_amalgamated begin source: src/protozero/scattered_heap_buffer.cc
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+
+#include <algorithm>
+
+namespace protozero {
+
+ScatteredHeapBuffer::Slice::Slice()
+    : buffer_(nullptr), size_(0u), unused_bytes_(0u) {}
+
+ScatteredHeapBuffer::Slice::Slice(size_t size)
+    : buffer_(std::unique_ptr<uint8_t[]>(new uint8_t[size])),
+      size_(size),
+      unused_bytes_(size) {
+  PERFETTO_DCHECK(size);
+  Clear();
+}
+
+ScatteredHeapBuffer::Slice::Slice(Slice&& slice) noexcept = default;
+
+ScatteredHeapBuffer::Slice::~Slice() = default;
+
+ScatteredHeapBuffer::Slice& ScatteredHeapBuffer::Slice::operator=(Slice&&) =
+    default;
+
+void ScatteredHeapBuffer::Slice::Clear() {
+  unused_bytes_ = size_;
+#if PERFETTO_DCHECK_IS_ON()
+  memset(start(), 0xff, size_);
+#endif  // PERFETTO_DCHECK_IS_ON()
+}
+
+ScatteredHeapBuffer::ScatteredHeapBuffer(size_t initial_slice_size_bytes,
+                                         size_t maximum_slice_size_bytes)
+    : next_slice_size_(initial_slice_size_bytes),
+      maximum_slice_size_(maximum_slice_size_bytes) {
+  PERFETTO_DCHECK(next_slice_size_ && maximum_slice_size_);
+  PERFETTO_DCHECK(maximum_slice_size_ >= initial_slice_size_bytes);
+}
+
+ScatteredHeapBuffer::~ScatteredHeapBuffer() = default;
+
+protozero::ContiguousMemoryRange ScatteredHeapBuffer::GetNewBuffer() {
+  PERFETTO_CHECK(writer_);
+  AdjustUsedSizeOfCurrentSlice();
+
+  if (cached_slice_.start()) {
+    slices_.push_back(std::move(cached_slice_));
+    PERFETTO_DCHECK(!cached_slice_.start());
+  } else {
+    slices_.emplace_back(next_slice_size_);
+  }
+  next_slice_size_ = std::min(maximum_slice_size_, next_slice_size_ * 2);
+  return slices_.back().GetTotalRange();
+}
+
+const std::vector<ScatteredHeapBuffer::Slice>&
+ScatteredHeapBuffer::GetSlices() {
+  AdjustUsedSizeOfCurrentSlice();
+  return slices_;
+}
+
+std::vector<uint8_t> ScatteredHeapBuffer::StitchSlices() {
+  size_t stitched_size = 0u;
+  const auto& slices = GetSlices();
+  for (const auto& slice : slices)
+    stitched_size += slice.size() - slice.unused_bytes();
+
+  std::vector<uint8_t> buffer;
+  buffer.reserve(stitched_size);
+  for (const auto& slice : slices) {
+    auto used_range = slice.GetUsedRange();
+    buffer.insert(buffer.end(), used_range.begin, used_range.end);
+  }
+  return buffer;
+}
+
+std::pair<std::unique_ptr<uint8_t[]>, size_t>
+ScatteredHeapBuffer::StitchAsUniquePtr() {
+  size_t stitched_size = 0u;
+  const auto& slices = GetSlices();
+  for (const auto& slice : slices)
+    stitched_size += slice.size() - slice.unused_bytes();
+
+  std::unique_ptr<uint8_t[]> buffer(new uint8_t[stitched_size]);
+  uint8_t* ptr = buffer.get();
+  for (const auto& slice : slices) {
+    auto used_range = slice.GetUsedRange();
+    memcpy(ptr, used_range.begin, used_range.size());
+    ptr += used_range.size();
+  }
+
+  return std::make_pair(std::move(buffer), stitched_size);
+}
+
+std::vector<protozero::ContiguousMemoryRange> ScatteredHeapBuffer::GetRanges() {
+  std::vector<protozero::ContiguousMemoryRange> ranges;
+  for (const auto& slice : GetSlices())
+    ranges.push_back(slice.GetUsedRange());
+  return ranges;
+}
+
+void ScatteredHeapBuffer::AdjustUsedSizeOfCurrentSlice() {
+  if (!slices_.empty())
+    slices_.back().set_unused_bytes(writer_->bytes_available());
+}
+
+size_t ScatteredHeapBuffer::GetTotalSize() {
+  size_t total_size = 0;
+  for (auto& slice : slices_) {
+    total_size += slice.size();
+  }
+  return total_size;
+}
+
+void ScatteredHeapBuffer::Reset() {
+  if (slices_.empty())
+    return;
+  cached_slice_ = std::move(slices_.front());
+  cached_slice_.Clear();
+  slices_.clear();
+}
+
+}  // namespace protozero
+// gen_amalgamated begin source: src/protozero/scattered_stream_null_delegate.cc
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_stream_null_delegate.h"
+
+namespace protozero {
+
+// An implementation of ScatteredStreamWriter::Delegate which always returns
+// the same piece of memory.
+// This is used when we need to no-op the writers (e.g. during teardown or in
+// case of resource exhaustion), avoiding that the clients have to deal with
+// nullptr checks.
+ScatteredStreamWriterNullDelegate::ScatteredStreamWriterNullDelegate(
+    size_t chunk_size)
+    : chunk_size_(chunk_size),
+      chunk_(std::unique_ptr<uint8_t[]>(new uint8_t[chunk_size_])) {}
+
+ScatteredStreamWriterNullDelegate::~ScatteredStreamWriterNullDelegate() {}
+
+ContiguousMemoryRange ScatteredStreamWriterNullDelegate::GetNewBuffer() {
+  return {chunk_.get(), chunk_.get() + chunk_size_};
+}
+
+}  // namespace protozero
+// gen_amalgamated begin source: src/protozero/scattered_stream_writer.cc
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_stream_writer.h"
+
+#include <algorithm>
+
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+
+namespace protozero {
+
+ScatteredStreamWriter::Delegate::~Delegate() {}
+
+uint8_t* ScatteredStreamWriter::Delegate::AnnotatePatch(uint8_t* patch_addr) {
+  // In most cases, a patch is transparent. The caller can write directly into
+  // `to_patch`, because its memory is not going away. TraceWriterImpl, however,
+  // requires a more complicated logic, because the chunks might be copied
+  // earlier.
+  return patch_addr;
+}
+
+ScatteredStreamWriter::ScatteredStreamWriter(Delegate* delegate)
+    : delegate_(delegate),
+      cur_range_({nullptr, nullptr}),
+      write_ptr_(nullptr) {}
+
+ScatteredStreamWriter::~ScatteredStreamWriter() {}
+
+void ScatteredStreamWriter::Reset(ContiguousMemoryRange range) {
+  written_previously_ += static_cast<uint64_t>(write_ptr_ - cur_range_.begin);
+  cur_range_ = range;
+  write_ptr_ = range.begin;
+  PERFETTO_DCHECK(!write_ptr_ || write_ptr_ < cur_range_.end);
+}
+
+void ScatteredStreamWriter::Extend() {
+  Reset(delegate_->GetNewBuffer());
+}
+
+void ScatteredStreamWriter::WriteBytesSlowPath(const uint8_t* src,
+                                               size_t size) {
+  size_t bytes_left = size;
+  while (bytes_left > 0) {
+    if (write_ptr_ >= cur_range_.end)
+      Extend();
+    const size_t burst_size = std::min(bytes_available(), bytes_left);
+    WriteBytesUnsafe(src, burst_size);
+    bytes_left -= burst_size;
+    src += burst_size;
+  }
+}
+
+// TODO(primiano): perf optimization: I suspect that at the end this will always
+// be called with |size| == 4, in which case we might just hardcode it.
+uint8_t* ScatteredStreamWriter::ReserveBytes(size_t size) {
+  PERFETTO_DCHECK(write_ptr_ <= cur_range_.end);
+  if (size > static_cast<size_t>(cur_range_.end - write_ptr_)) {
+    // Assume the reservations are always < Delegate::GetNewBuffer().size(),
+    // so that one single call to Extend() will definitely give enough headroom.
+    Extend();
+    PERFETTO_DCHECK(write_ptr_ <= cur_range_.end);
+    PERFETTO_DCHECK(size <= static_cast<size_t>(cur_range_.end - write_ptr_));
+  }
+  uint8_t* begin = write_ptr_;
+  write_ptr_ += size;
+#if PERFETTO_DCHECK_IS_ON()
+  // In the past, the service had a matching DCHECK in
+  // TraceBuffer::TryPatchChunkContents, which was assuming that service and all
+  // producers are built with matching DCHECK levels. This turned out to be a
+  // source of problems and was removed in b/197340286. This memset is useless
+  // these days and is here only to maintain ABI compatibility between producers
+  // that use a v20+ SDK and older versions of the service that were built in
+  // debug mode. At some point around 2023 it should be safe to remove it.
+  // (running a debug version of traced in production seems a bad idea
+  // regardless).
+  memset(begin, 0, size);
+#endif
+  return begin;
+}
+
+}  // namespace protozero
+// gen_amalgamated begin source: src/protozero/static_buffer.cc
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "perfetto/protozero/static_buffer.h"
+
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+
+namespace protozero {
+
+StaticBufferDelegate::~StaticBufferDelegate() = default;
+
+ContiguousMemoryRange StaticBufferDelegate::GetNewBuffer() {
+  if (get_new_buffer_called_once_) {
+    // This is the 2nd time GetNewBuffer is called. The estimate is wrong. We
+    // shouldn't try to grow the buffer after the initial call.
+    PERFETTO_FATAL("Static buffer too small");
+  }
+  get_new_buffer_called_once_ = true;
+  return range_;
+}
+
+}  // namespace protozero
+// gen_amalgamated begin source: src/protozero/virtual_destructors.cc
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message_handle.h"
+
+namespace protozero {
+
+CppMessageObj::~CppMessageObj() = default;
+MessageFinalizationListener::~MessageFinalizationListener() = default;
+
+}  // namespace protozero
+// gen_amalgamated begin source: gen/protos/perfetto/protovm/vm_program.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/protovm/vm_program.gen.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+
+VmOpDel::VmOpDel() = default;
+VmOpDel::~VmOpDel() = default;
+VmOpDel::VmOpDel(const VmOpDel&) = default;
+VmOpDel& VmOpDel::operator=(const VmOpDel&) = default;
+VmOpDel::VmOpDel(VmOpDel&&) noexcept = default;
+VmOpDel& VmOpDel::operator=(VmOpDel&&) = default;
+
+bool VmOpDel::operator==(const VmOpDel& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
+}
+
+bool VmOpDel::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -13000,37 +14734,35 @@ bool OneofOptions::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string OneofOptions::SerializeAsString() const {
+std::string VmOpDel::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> OneofOptions::SerializeAsArray() const {
+std::vector<uint8_t> VmOpDel::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void OneofOptions::Serialize(::protozero::Message* msg) const {
+void VmOpDel::Serialize(::protozero::Message* msg) const {
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-EnumValueDescriptorProto::EnumValueDescriptorProto() = default;
-EnumValueDescriptorProto::~EnumValueDescriptorProto() = default;
-EnumValueDescriptorProto::EnumValueDescriptorProto(const EnumValueDescriptorProto&) = default;
-EnumValueDescriptorProto& EnumValueDescriptorProto::operator=(const EnumValueDescriptorProto&) = default;
-EnumValueDescriptorProto::EnumValueDescriptorProto(EnumValueDescriptorProto&&) noexcept = default;
-EnumValueDescriptorProto& EnumValueDescriptorProto::operator=(EnumValueDescriptorProto&&) = default;
+VmOpSet::VmOpSet() = default;
+VmOpSet::~VmOpSet() = default;
+VmOpSet::VmOpSet(const VmOpSet&) = default;
+VmOpSet& VmOpSet::operator=(const VmOpSet&) = default;
+VmOpSet::VmOpSet(VmOpSet&&) noexcept = default;
+VmOpSet& VmOpSet::operator=(VmOpSet&&) = default;
 
-bool EnumValueDescriptorProto::operator==(const EnumValueDescriptorProto& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && name_ == other.name_
-   && number_ == other.number_;
+bool VmOpSet::operator==(const VmOpSet& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
-bool EnumValueDescriptorProto::ParseFromArray(const void* raw, size_t size) {
+bool VmOpSet::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -13040,12 +14772,6 @@ bool EnumValueDescriptorProto::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
-        break;
-      case 2 /* number */:
-        field.get(&number_);
-        break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
         break;
@@ -13054,53 +14780,35 @@ bool EnumValueDescriptorProto::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string EnumValueDescriptorProto::SerializeAsString() const {
+std::string VmOpSet::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> EnumValueDescriptorProto::SerializeAsArray() const {
+std::vector<uint8_t> VmOpSet::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void EnumValueDescriptorProto::Serialize(::protozero::Message* msg) const {
-  // Field 1: name
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
-  }
-
-  // Field 2: number
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, number_, msg);
-  }
-
+void VmOpSet::Serialize(::protozero::Message* msg) const {
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-EnumDescriptorProto::EnumDescriptorProto() = default;
-EnumDescriptorProto::~EnumDescriptorProto() = default;
-EnumDescriptorProto::EnumDescriptorProto(const EnumDescriptorProto&) = default;
-EnumDescriptorProto& EnumDescriptorProto::operator=(const EnumDescriptorProto&) = default;
-EnumDescriptorProto::EnumDescriptorProto(EnumDescriptorProto&&) noexcept = default;
-EnumDescriptorProto& EnumDescriptorProto::operator=(EnumDescriptorProto&&) = default;
+VmOpMerge::VmOpMerge() = default;
+VmOpMerge::~VmOpMerge() = default;
+VmOpMerge::VmOpMerge(const VmOpMerge&) = default;
+VmOpMerge& VmOpMerge::operator=(const VmOpMerge&) = default;
+VmOpMerge::VmOpMerge(VmOpMerge&&) noexcept = default;
+VmOpMerge& VmOpMerge::operator=(VmOpMerge&&) = default;
 
-bool EnumDescriptorProto::operator==(const EnumDescriptorProto& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && name_ == other.name_
-   && value_ == other.value_
-   && reserved_name_ == other.reserved_name_;
+bool VmOpMerge::operator==(const VmOpMerge& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
-int EnumDescriptorProto::value_size() const { return static_cast<int>(value_.size()); }
-void EnumDescriptorProto::clear_value() { value_.clear(); }
-EnumValueDescriptorProto* EnumDescriptorProto::add_value() { value_.emplace_back(); return &value_.back(); }
-bool EnumDescriptorProto::ParseFromArray(const void* raw, size_t size) {
-  value_.clear();
-  reserved_name_.clear();
+bool VmOpMerge::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -13110,17 +14818,6 @@ bool EnumDescriptorProto::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
-        break;
-      case 2 /* value */:
-        value_.emplace_back();
-        value_.back().ParseFromArray(field.data(), field.size());
-        break;
-      case 5 /* reserved_name */:
-        reserved_name_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &reserved_name_.back());
-        break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
         break;
@@ -13129,52 +14826,37 @@ bool EnumDescriptorProto::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string EnumDescriptorProto::SerializeAsString() const {
+std::string VmOpMerge::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> EnumDescriptorProto::SerializeAsArray() const {
+std::vector<uint8_t> VmOpMerge::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void EnumDescriptorProto::Serialize(::protozero::Message* msg) const {
-  // Field 1: name
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
-  }
+void VmOpMerge::Serialize(::protozero::Message* msg) const {
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  // Field 2: value
-  for (auto& it : value_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
-  }
-
-  // Field 5: reserved_name
-  for (auto& it : reserved_name_) {
-    ::protozero::internal::gen_helpers::SerializeString(5, it, msg);
-  }
-
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
-}
 
+VmOpRegLoad::VmOpRegLoad() = default;
+VmOpRegLoad::~VmOpRegLoad() = default;
+VmOpRegLoad::VmOpRegLoad(const VmOpRegLoad&) = default;
+VmOpRegLoad& VmOpRegLoad::operator=(const VmOpRegLoad&) = default;
+VmOpRegLoad::VmOpRegLoad(VmOpRegLoad&&) noexcept = default;
+VmOpRegLoad& VmOpRegLoad::operator=(VmOpRegLoad&&) = default;
 
-OneofDescriptorProto::OneofDescriptorProto() = default;
-OneofDescriptorProto::~OneofDescriptorProto() = default;
-OneofDescriptorProto::OneofDescriptorProto(const OneofDescriptorProto&) = default;
-OneofDescriptorProto& OneofDescriptorProto::operator=(const OneofDescriptorProto&) = default;
-OneofDescriptorProto::OneofDescriptorProto(OneofDescriptorProto&&) noexcept = default;
-OneofDescriptorProto& OneofDescriptorProto::operator=(OneofDescriptorProto&&) = default;
-
-bool OneofDescriptorProto::operator==(const OneofDescriptorProto& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && name_ == other.name_
-   && options_ == other.options_;
+bool VmOpRegLoad::operator==(const VmOpRegLoad& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(cursor_, other.cursor_)
+   && ::protozero::internal::gen_helpers::EqualsField(dst_register_, other.dst_register_);
 }
 
-bool OneofDescriptorProto::ParseFromArray(const void* raw, size_t size) {
+bool VmOpRegLoad::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -13184,11 +14866,11 @@ bool OneofDescriptorProto::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+      case 1 /* cursor */:
+        field.get(&cursor_);
         break;
-      case 2 /* options */:
-        (*options_).ParseFromArray(field.data(), field.size());
+      case 2 /* dst_register */:
+        field.get(&dst_register_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -13198,53 +14880,52 @@ bool OneofDescriptorProto::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string OneofDescriptorProto::SerializeAsString() const {
+std::string VmOpRegLoad::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> OneofDescriptorProto::SerializeAsArray() const {
+std::vector<uint8_t> VmOpRegLoad::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void OneofDescriptorProto::Serialize(::protozero::Message* msg) const {
-  // Field 1: name
+void VmOpRegLoad::Serialize(::protozero::Message* msg) const {
+  // Field 1: cursor
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, cursor_, msg);
   }
 
-  // Field 2: options
+  // Field 2: dst_register
   if (_has_field_[2]) {
-    (*options_).Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, dst_register_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-FieldDescriptorProto::FieldDescriptorProto() = default;
-FieldDescriptorProto::~FieldDescriptorProto() = default;
-FieldDescriptorProto::FieldDescriptorProto(const FieldDescriptorProto&) = default;
-FieldDescriptorProto& FieldDescriptorProto::operator=(const FieldDescriptorProto&) = default;
-FieldDescriptorProto::FieldDescriptorProto(FieldDescriptorProto&&) noexcept = default;
-FieldDescriptorProto& FieldDescriptorProto::operator=(FieldDescriptorProto&&) = default;
+VmOpSelect::VmOpSelect() = default;
+VmOpSelect::~VmOpSelect() = default;
+VmOpSelect::VmOpSelect(const VmOpSelect&) = default;
+VmOpSelect& VmOpSelect::operator=(const VmOpSelect&) = default;
+VmOpSelect::VmOpSelect(VmOpSelect&&) noexcept = default;
+VmOpSelect& VmOpSelect::operator=(VmOpSelect&&) = default;
 
-bool FieldDescriptorProto::operator==(const FieldDescriptorProto& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && name_ == other.name_
-   && number_ == other.number_
-   && label_ == other.label_
-   && type_ == other.type_
-   && type_name_ == other.type_name_
-   && extendee_ == other.extendee_
-   && default_value_ == other.default_value_
-   && oneof_index_ == other.oneof_index_;
+bool VmOpSelect::operator==(const VmOpSelect& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(cursor_, other.cursor_)
+   && ::protozero::internal::gen_helpers::EqualsField(relative_path_, other.relative_path_)
+   && ::protozero::internal::gen_helpers::EqualsField(create_if_not_exist_, other.create_if_not_exist_);
 }
 
-bool FieldDescriptorProto::ParseFromArray(const void* raw, size_t size) {
+int VmOpSelect::relative_path_size() const { return static_cast<int>(relative_path_.size()); }
+void VmOpSelect::clear_relative_path() { relative_path_.clear(); }
+VmOpSelect_PathComponent* VmOpSelect::add_relative_path() { relative_path_.emplace_back(); return &relative_path_.back(); }
+bool VmOpSelect::ParseFromArray(const void* raw, size_t size) {
+  relative_path_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -13254,29 +14935,15 @@ bool FieldDescriptorProto::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
-        break;
-      case 3 /* number */:
-        field.get(&number_);
-        break;
-      case 4 /* label */:
-        field.get(&label_);
-        break;
-      case 5 /* type */:
-        field.get(&type_);
-        break;
-      case 6 /* type_name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &type_name_);
+      case 1 /* cursor */:
+        field.get(&cursor_);
         break;
-      case 2 /* extendee */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &extendee_);
-        break;
-      case 7 /* default_value */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &default_value_);
+      case 2 /* relative_path */:
+        relative_path_.emplace_back();
+        relative_path_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 9 /* oneof_index */:
-        field.get(&oneof_index_);
+      case 3 /* create_if_not_exist */:
+        field.get(&create_if_not_exist_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -13286,108 +14953,56 @@ bool FieldDescriptorProto::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string FieldDescriptorProto::SerializeAsString() const {
+std::string VmOpSelect::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> FieldDescriptorProto::SerializeAsArray() const {
+std::vector<uint8_t> VmOpSelect::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void FieldDescriptorProto::Serialize(::protozero::Message* msg) const {
-  // Field 1: name
+void VmOpSelect::Serialize(::protozero::Message* msg) const {
+  // Field 1: cursor
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, cursor_, msg);
   }
 
-  // Field 3: number
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, number_, msg);
-  }
-
-  // Field 4: label
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, label_, msg);
-  }
-
-  // Field 5: type
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(5, type_, msg);
-  }
-
-  // Field 6: type_name
-  if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeString(6, type_name_, msg);
-  }
-
-  // Field 2: extendee
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeString(2, extendee_, msg);
-  }
-
-  // Field 7: default_value
-  if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeString(7, default_value_, msg);
+  // Field 2: relative_path
+  for (auto& it : relative_path_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
   }
 
-  // Field 9: oneof_index
-  if (_has_field_[9]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(9, oneof_index_, msg);
+  // Field 3: create_if_not_exist
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, create_if_not_exist_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-DescriptorProto::DescriptorProto() = default;
-DescriptorProto::~DescriptorProto() = default;
-DescriptorProto::DescriptorProto(const DescriptorProto&) = default;
-DescriptorProto& DescriptorProto::operator=(const DescriptorProto&) = default;
-DescriptorProto::DescriptorProto(DescriptorProto&&) noexcept = default;
-DescriptorProto& DescriptorProto::operator=(DescriptorProto&&) = default;
+VmOpSelect_PathComponent::VmOpSelect_PathComponent() = default;
+VmOpSelect_PathComponent::~VmOpSelect_PathComponent() = default;
+VmOpSelect_PathComponent::VmOpSelect_PathComponent(const VmOpSelect_PathComponent&) = default;
+VmOpSelect_PathComponent& VmOpSelect_PathComponent::operator=(const VmOpSelect_PathComponent&) = default;
+VmOpSelect_PathComponent::VmOpSelect_PathComponent(VmOpSelect_PathComponent&&) noexcept = default;
+VmOpSelect_PathComponent& VmOpSelect_PathComponent::operator=(VmOpSelect_PathComponent&&) = default;
 
-bool DescriptorProto::operator==(const DescriptorProto& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && name_ == other.name_
-   && field_ == other.field_
-   && extension_ == other.extension_
-   && nested_type_ == other.nested_type_
-   && enum_type_ == other.enum_type_
-   && oneof_decl_ == other.oneof_decl_
-   && reserved_range_ == other.reserved_range_
-   && reserved_name_ == other.reserved_name_;
+bool VmOpSelect_PathComponent::operator==(const VmOpSelect_PathComponent& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(field_id_, other.field_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(array_index_, other.array_index_)
+   && ::protozero::internal::gen_helpers::EqualsField(map_key_field_id_, other.map_key_field_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(is_repeated_, other.is_repeated_)
+   && ::protozero::internal::gen_helpers::EqualsField(register_to_match_, other.register_to_match_)
+   && ::protozero::internal::gen_helpers::EqualsField(store_foreach_index_into_register_, other.store_foreach_index_into_register_);
 }
 
-int DescriptorProto::field_size() const { return static_cast<int>(field_.size()); }
-void DescriptorProto::clear_field() { field_.clear(); }
-FieldDescriptorProto* DescriptorProto::add_field() { field_.emplace_back(); return &field_.back(); }
-int DescriptorProto::extension_size() const { return static_cast<int>(extension_.size()); }
-void DescriptorProto::clear_extension() { extension_.clear(); }
-FieldDescriptorProto* DescriptorProto::add_extension() { extension_.emplace_back(); return &extension_.back(); }
-int DescriptorProto::nested_type_size() const { return static_cast<int>(nested_type_.size()); }
-void DescriptorProto::clear_nested_type() { nested_type_.clear(); }
-DescriptorProto* DescriptorProto::add_nested_type() { nested_type_.emplace_back(); return &nested_type_.back(); }
-int DescriptorProto::enum_type_size() const { return static_cast<int>(enum_type_.size()); }
-void DescriptorProto::clear_enum_type() { enum_type_.clear(); }
-EnumDescriptorProto* DescriptorProto::add_enum_type() { enum_type_.emplace_back(); return &enum_type_.back(); }
-int DescriptorProto::oneof_decl_size() const { return static_cast<int>(oneof_decl_.size()); }
-void DescriptorProto::clear_oneof_decl() { oneof_decl_.clear(); }
-OneofDescriptorProto* DescriptorProto::add_oneof_decl() { oneof_decl_.emplace_back(); return &oneof_decl_.back(); }
-int DescriptorProto::reserved_range_size() const { return static_cast<int>(reserved_range_.size()); }
-void DescriptorProto::clear_reserved_range() { reserved_range_.clear(); }
-DescriptorProto_ReservedRange* DescriptorProto::add_reserved_range() { reserved_range_.emplace_back(); return &reserved_range_.back(); }
-bool DescriptorProto::ParseFromArray(const void* raw, size_t size) {
-  field_.clear();
-  extension_.clear();
-  nested_type_.clear();
-  enum_type_.clear();
-  oneof_decl_.clear();
-  reserved_range_.clear();
-  reserved_name_.clear();
+bool VmOpSelect_PathComponent::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -13397,36 +15012,23 @@ bool DescriptorProto::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
-        break;
-      case 2 /* field */:
-        field_.emplace_back();
-        field_.back().ParseFromArray(field.data(), field.size());
+      case 1 /* field_id */:
+        field.get(&field_id_);
         break;
-      case 6 /* extension */:
-        extension_.emplace_back();
-        extension_.back().ParseFromArray(field.data(), field.size());
-        break;
-      case 3 /* nested_type */:
-        nested_type_.emplace_back();
-        nested_type_.back().ParseFromArray(field.data(), field.size());
+      case 2 /* array_index */:
+        field.get(&array_index_);
         break;
-      case 4 /* enum_type */:
-        enum_type_.emplace_back();
-        enum_type_.back().ParseFromArray(field.data(), field.size());
+      case 3 /* map_key_field_id */:
+        field.get(&map_key_field_id_);
         break;
-      case 8 /* oneof_decl */:
-        oneof_decl_.emplace_back();
-        oneof_decl_.back().ParseFromArray(field.data(), field.size());
+      case 5 /* is_repeated */:
+        field.get(&is_repeated_);
         break;
-      case 9 /* reserved_range */:
-        reserved_range_.emplace_back();
-        reserved_range_.back().ParseFromArray(field.data(), field.size());
+      case 6 /* register_to_match */:
+        field.get(&register_to_match_);
         break;
-      case 10 /* reserved_name */:
-        reserved_name_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &reserved_name_.back());
+      case 7 /* store_foreach_index_into_register */:
+        field.get(&store_foreach_index_into_register_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -13436,162 +15038,76 @@ bool DescriptorProto::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string DescriptorProto::SerializeAsString() const {
+std::string VmOpSelect_PathComponent::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> DescriptorProto::SerializeAsArray() const {
+std::vector<uint8_t> VmOpSelect_PathComponent::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void DescriptorProto::Serialize(::protozero::Message* msg) const {
-  // Field 1: name
+void VmOpSelect_PathComponent::Serialize(::protozero::Message* msg) const {
+  // Field 1: field_id
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, field_id_, msg);
   }
 
-  // Field 2: field
-  for (auto& it : field_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
-  }
-
-  // Field 6: extension
-  for (auto& it : extension_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(6));
-  }
-
-  // Field 3: nested_type
-  for (auto& it : nested_type_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(3));
-  }
-
-  // Field 4: enum_type
-  for (auto& it : enum_type_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(4));
-  }
-
-  // Field 8: oneof_decl
-  for (auto& it : oneof_decl_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(8));
-  }
-
-  // Field 9: reserved_range
-  for (auto& it : reserved_range_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(9));
+  // Field 2: array_index
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, array_index_, msg);
   }
 
-  // Field 10: reserved_name
-  for (auto& it : reserved_name_) {
-    ::protozero::internal::gen_helpers::SerializeString(10, it, msg);
+  // Field 3: map_key_field_id
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, map_key_field_id_, msg);
   }
 
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
-}
-
-
-DescriptorProto_ReservedRange::DescriptorProto_ReservedRange() = default;
-DescriptorProto_ReservedRange::~DescriptorProto_ReservedRange() = default;
-DescriptorProto_ReservedRange::DescriptorProto_ReservedRange(const DescriptorProto_ReservedRange&) = default;
-DescriptorProto_ReservedRange& DescriptorProto_ReservedRange::operator=(const DescriptorProto_ReservedRange&) = default;
-DescriptorProto_ReservedRange::DescriptorProto_ReservedRange(DescriptorProto_ReservedRange&&) noexcept = default;
-DescriptorProto_ReservedRange& DescriptorProto_ReservedRange::operator=(DescriptorProto_ReservedRange&&) = default;
-
-bool DescriptorProto_ReservedRange::operator==(const DescriptorProto_ReservedRange& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && start_ == other.start_
-   && end_ == other.end_;
-}
-
-bool DescriptorProto_ReservedRange::ParseFromArray(const void* raw, size_t size) {
-  unknown_fields_.clear();
-  bool packed_error = false;
-
-  ::protozero::ProtoDecoder dec(raw, size);
-  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
-    if (field.id() < _has_field_.size()) {
-      _has_field_.set(field.id());
-    }
-    switch (field.id()) {
-      case 1 /* start */:
-        field.get(&start_);
-        break;
-      case 2 /* end */:
-        field.get(&end_);
-        break;
-      default:
-        field.SerializeAndAppendTo(&unknown_fields_);
-        break;
-    }
+  // Field 5: is_repeated
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, is_repeated_, msg);
   }
-  return !packed_error && !dec.bytes_left();
-}
-
-std::string DescriptorProto_ReservedRange::SerializeAsString() const {
-  ::protozero::internal::gen_helpers::MessageSerializer msg;
-  Serialize(msg.get());
-  return msg.SerializeAsString();
-}
-
-std::vector<uint8_t> DescriptorProto_ReservedRange::SerializeAsArray() const {
-  ::protozero::internal::gen_helpers::MessageSerializer msg;
-  Serialize(msg.get());
-  return msg.SerializeAsArray();
-}
 
-void DescriptorProto_ReservedRange::Serialize(::protozero::Message* msg) const {
-  // Field 1: start
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, start_, msg);
+  // Field 6: register_to_match
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, register_to_match_, msg);
   }
 
-  // Field 2: end
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, end_, msg);
+  // Field 7: store_foreach_index_into_register
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(7, store_foreach_index_into_register_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-FileDescriptorProto::FileDescriptorProto() = default;
-FileDescriptorProto::~FileDescriptorProto() = default;
-FileDescriptorProto::FileDescriptorProto(const FileDescriptorProto&) = default;
-FileDescriptorProto& FileDescriptorProto::operator=(const FileDescriptorProto&) = default;
-FileDescriptorProto::FileDescriptorProto(FileDescriptorProto&&) noexcept = default;
-FileDescriptorProto& FileDescriptorProto::operator=(FileDescriptorProto&&) = default;
+VmInstruction::VmInstruction() = default;
+VmInstruction::~VmInstruction() = default;
+VmInstruction::VmInstruction(const VmInstruction&) = default;
+VmInstruction& VmInstruction::operator=(const VmInstruction&) = default;
+VmInstruction::VmInstruction(VmInstruction&&) noexcept = default;
+VmInstruction& VmInstruction::operator=(VmInstruction&&) = default;
 
-bool FileDescriptorProto::operator==(const FileDescriptorProto& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && name_ == other.name_
-   && package_ == other.package_
-   && dependency_ == other.dependency_
-   && public_dependency_ == other.public_dependency_
-   && weak_dependency_ == other.weak_dependency_
-   && message_type_ == other.message_type_
-   && enum_type_ == other.enum_type_
-   && extension_ == other.extension_;
+bool VmInstruction::operator==(const VmInstruction& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(select_, other.select_)
+   && ::protozero::internal::gen_helpers::EqualsField(reg_load_, other.reg_load_)
+   && ::protozero::internal::gen_helpers::EqualsField(merge_, other.merge_)
+   && ::protozero::internal::gen_helpers::EqualsField(set_, other.set_)
+   && ::protozero::internal::gen_helpers::EqualsField(del_, other.del_)
+   && ::protozero::internal::gen_helpers::EqualsField(abort_level_, other.abort_level_)
+   && ::protozero::internal::gen_helpers::EqualsField(nested_instructions_, other.nested_instructions_);
 }
 
-int FileDescriptorProto::message_type_size() const { return static_cast<int>(message_type_.size()); }
-void FileDescriptorProto::clear_message_type() { message_type_.clear(); }
-DescriptorProto* FileDescriptorProto::add_message_type() { message_type_.emplace_back(); return &message_type_.back(); }
-int FileDescriptorProto::enum_type_size() const { return static_cast<int>(enum_type_.size()); }
-void FileDescriptorProto::clear_enum_type() { enum_type_.clear(); }
-EnumDescriptorProto* FileDescriptorProto::add_enum_type() { enum_type_.emplace_back(); return &enum_type_.back(); }
-int FileDescriptorProto::extension_size() const { return static_cast<int>(extension_.size()); }
-void FileDescriptorProto::clear_extension() { extension_.clear(); }
-FieldDescriptorProto* FileDescriptorProto::add_extension() { extension_.emplace_back(); return &extension_.back(); }
-bool FileDescriptorProto::ParseFromArray(const void* raw, size_t size) {
-  dependency_.clear();
-  public_dependency_.clear();
-  weak_dependency_.clear();
-  message_type_.clear();
-  enum_type_.clear();
-  extension_.clear();
+int VmInstruction::nested_instructions_size() const { return static_cast<int>(nested_instructions_.size()); }
+void VmInstruction::clear_nested_instructions() { nested_instructions_.clear(); }
+VmInstruction* VmInstruction::add_nested_instructions() { nested_instructions_.emplace_back(); return &nested_instructions_.back(); }
+bool VmInstruction::ParseFromArray(const void* raw, size_t size) {
+  nested_instructions_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -13601,35 +15117,27 @@ bool FileDescriptorProto::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+      case 1 /* select */:
+        (*select_).ParseFromArray(field.data(), field.size());
         break;
-      case 2 /* package */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &package_);
-        break;
-      case 3 /* dependency */:
-        dependency_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &dependency_.back());
+      case 2 /* reg_load */:
+        (*reg_load_).ParseFromArray(field.data(), field.size());
         break;
-      case 10 /* public_dependency */:
-        public_dependency_.emplace_back();
-        field.get(&public_dependency_.back());
+      case 3 /* merge */:
+        (*merge_).ParseFromArray(field.data(), field.size());
         break;
-      case 11 /* weak_dependency */:
-        weak_dependency_.emplace_back();
-        field.get(&weak_dependency_.back());
+      case 4 /* set */:
+        (*set_).ParseFromArray(field.data(), field.size());
         break;
-      case 4 /* message_type */:
-        message_type_.emplace_back();
-        message_type_.back().ParseFromArray(field.data(), field.size());
+      case 5 /* del */:
+        (*del_).ParseFromArray(field.data(), field.size());
         break;
-      case 5 /* enum_type */:
-        enum_type_.emplace_back();
-        enum_type_.back().ParseFromArray(field.data(), field.size());
+      case 6 /* abort_level */:
+        field.get(&abort_level_);
         break;
-      case 7 /* extension */:
-        extension_.emplace_back();
-        extension_.back().ParseFromArray(field.data(), field.size());
+      case 7 /* nested_instructions */:
+        nested_instructions_.emplace_back();
+        nested_instructions_.back().ParseFromArray(field.data(), field.size());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -13639,56 +15147,51 @@ bool FileDescriptorProto::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string FileDescriptorProto::SerializeAsString() const {
+std::string VmInstruction::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> FileDescriptorProto::SerializeAsArray() const {
+std::vector<uint8_t> VmInstruction::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void FileDescriptorProto::Serialize(::protozero::Message* msg) const {
-  // Field 1: name
+void VmInstruction::Serialize(::protozero::Message* msg) const {
+  // Field 1: select
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
+    (*select_).Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
   }
 
-  // Field 2: package
+  // Field 2: reg_load
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeString(2, package_, msg);
+    (*reg_load_).Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
   }
 
-  // Field 3: dependency
-  for (auto& it : dependency_) {
-    ::protozero::internal::gen_helpers::SerializeString(3, it, msg);
-  }
-
-  // Field 10: public_dependency
-  for (auto& it : public_dependency_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(10, it, msg);
+  // Field 3: merge
+  if (_has_field_[3]) {
+    (*merge_).Serialize(msg->BeginNestedMessage<::protozero::Message>(3));
   }
 
-  // Field 11: weak_dependency
-  for (auto& it : weak_dependency_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(11, it, msg);
+  // Field 4: set
+  if (_has_field_[4]) {
+    (*set_).Serialize(msg->BeginNestedMessage<::protozero::Message>(4));
   }
 
-  // Field 4: message_type
-  for (auto& it : message_type_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(4));
+  // Field 5: del
+  if (_has_field_[5]) {
+    (*del_).Serialize(msg->BeginNestedMessage<::protozero::Message>(5));
   }
 
-  // Field 5: enum_type
-  for (auto& it : enum_type_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(5));
+  // Field 6: abort_level
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, abort_level_, msg);
   }
 
-  // Field 7: extension
-  for (auto& it : extension_) {
+  // Field 7: nested_instructions
+  for (auto& it : nested_instructions_) {
     it.Serialize(msg->BeginNestedMessage<::protozero::Message>(7));
   }
 
@@ -13696,23 +15199,24 @@ void FileDescriptorProto::Serialize(::protozero::Message* msg) const {
 }
 
 
-FileDescriptorSet::FileDescriptorSet() = default;
-FileDescriptorSet::~FileDescriptorSet() = default;
-FileDescriptorSet::FileDescriptorSet(const FileDescriptorSet&) = default;
-FileDescriptorSet& FileDescriptorSet::operator=(const FileDescriptorSet&) = default;
-FileDescriptorSet::FileDescriptorSet(FileDescriptorSet&&) noexcept = default;
-FileDescriptorSet& FileDescriptorSet::operator=(FileDescriptorSet&&) = default;
+VmProgram::VmProgram() = default;
+VmProgram::~VmProgram() = default;
+VmProgram::VmProgram(const VmProgram&) = default;
+VmProgram& VmProgram::operator=(const VmProgram&) = default;
+VmProgram::VmProgram(VmProgram&&) noexcept = default;
+VmProgram& VmProgram::operator=(VmProgram&&) = default;
 
-bool FileDescriptorSet::operator==(const FileDescriptorSet& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && file_ == other.file_;
+bool VmProgram::operator==(const VmProgram& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(version_, other.version_)
+   && ::protozero::internal::gen_helpers::EqualsField(instructions_, other.instructions_);
 }
 
-int FileDescriptorSet::file_size() const { return static_cast<int>(file_.size()); }
-void FileDescriptorSet::clear_file() { file_.clear(); }
-FileDescriptorProto* FileDescriptorSet::add_file() { file_.emplace_back(); return &file_.back(); }
-bool FileDescriptorSet::ParseFromArray(const void* raw, size_t size) {
-  file_.clear();
+int VmProgram::instructions_size() const { return static_cast<int>(instructions_.size()); }
+void VmProgram::clear_instructions() { instructions_.clear(); }
+VmInstruction* VmProgram::add_instructions() { instructions_.emplace_back(); return &instructions_.back(); }
+bool VmProgram::ParseFromArray(const void* raw, size_t size) {
+  instructions_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -13722,9 +15226,12 @@ bool FileDescriptorSet::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* file */:
-        file_.emplace_back();
-        file_.back().ParseFromArray(field.data(), field.size());
+      case 1 /* version */:
+        field.get(&version_);
+        break;
+      case 2 /* instructions */:
+        instructions_.emplace_back();
+        instructions_.back().ParseFromArray(field.data(), field.size());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -13734,22 +15241,27 @@ bool FileDescriptorSet::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string FileDescriptorSet::SerializeAsString() const {
+std::string VmProgram::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> FileDescriptorSet::SerializeAsArray() const {
+std::vector<uint8_t> VmProgram::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void FileDescriptorSet::Serialize(::protozero::Message* msg) const {
-  // Field 1: file
-  for (auto& it : file_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
+void VmProgram::Serialize(::protozero::Message* msg) const {
+  // Field 1: version
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, version_, msg);
+  }
+
+  // Field 2: instructions
+  for (auto& it : instructions_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -13761,122 +15273,7 @@ void FileDescriptorSet::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/common/ftrace_descriptor.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/common/ftrace_descriptor.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_FTRACE_DESCRIPTOR_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_FTRACE_DESCRIPTOR_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class FtraceDescriptor;
-class FtraceDescriptor_AtraceCategory;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT FtraceDescriptor : public ::protozero::CppMessageObj {
- public:
-  using AtraceCategory = FtraceDescriptor_AtraceCategory;
-  enum FieldNumbers {
-    kAtraceCategoriesFieldNumber = 1,
-  };
-
-  FtraceDescriptor();
-  ~FtraceDescriptor() override;
-  FtraceDescriptor(FtraceDescriptor&&) noexcept;
-  FtraceDescriptor& operator=(FtraceDescriptor&&);
-  FtraceDescriptor(const FtraceDescriptor&);
-  FtraceDescriptor& operator=(const FtraceDescriptor&);
-  bool operator==(const FtraceDescriptor&) const;
-  bool operator!=(const FtraceDescriptor& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<FtraceDescriptor_AtraceCategory>& atrace_categories() const { return atrace_categories_; }
-  std::vector<FtraceDescriptor_AtraceCategory>* mutable_atrace_categories() { return &atrace_categories_; }
-  int atrace_categories_size() const;
-  void clear_atrace_categories();
-  FtraceDescriptor_AtraceCategory* add_atrace_categories();
-
- private:
-  std::vector<FtraceDescriptor_AtraceCategory> atrace_categories_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT FtraceDescriptor_AtraceCategory : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kNameFieldNumber = 1,
-    kDescriptionFieldNumber = 2,
-  };
-
-  FtraceDescriptor_AtraceCategory();
-  ~FtraceDescriptor_AtraceCategory() override;
-  FtraceDescriptor_AtraceCategory(FtraceDescriptor_AtraceCategory&&) noexcept;
-  FtraceDescriptor_AtraceCategory& operator=(FtraceDescriptor_AtraceCategory&&);
-  FtraceDescriptor_AtraceCategory(const FtraceDescriptor_AtraceCategory&);
-  FtraceDescriptor_AtraceCategory& operator=(const FtraceDescriptor_AtraceCategory&);
-  bool operator==(const FtraceDescriptor_AtraceCategory&) const;
-  bool operator!=(const FtraceDescriptor_AtraceCategory& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_name() const { return _has_field_[1]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
-
-  bool has_description() const { return _has_field_[2]; }
-  const std::string& description() const { return description_; }
-  void set_description(const std::string& value) { description_ = value; _has_field_.set(2); }
-
- private:
-  std::string name_{};
-  std::string description_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_FTRACE_DESCRIPTOR_PROTO_CPP_H_
+// gen_amalgamated begin source: gen/protos/perfetto/common/android_energy_consumer_descriptor.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -13887,29 +15284,29 @@ class PERFETTO_EXPORT_COMPONENT FtraceDescriptor_AtraceCategory : public ::proto
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/common/ftrace_descriptor.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/android_energy_consumer_descriptor.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-FtraceDescriptor::FtraceDescriptor() = default;
-FtraceDescriptor::~FtraceDescriptor() = default;
-FtraceDescriptor::FtraceDescriptor(const FtraceDescriptor&) = default;
-FtraceDescriptor& FtraceDescriptor::operator=(const FtraceDescriptor&) = default;
-FtraceDescriptor::FtraceDescriptor(FtraceDescriptor&&) noexcept = default;
-FtraceDescriptor& FtraceDescriptor::operator=(FtraceDescriptor&&) = default;
+AndroidEnergyConsumerDescriptor::AndroidEnergyConsumerDescriptor() = default;
+AndroidEnergyConsumerDescriptor::~AndroidEnergyConsumerDescriptor() = default;
+AndroidEnergyConsumerDescriptor::AndroidEnergyConsumerDescriptor(const AndroidEnergyConsumerDescriptor&) = default;
+AndroidEnergyConsumerDescriptor& AndroidEnergyConsumerDescriptor::operator=(const AndroidEnergyConsumerDescriptor&) = default;
+AndroidEnergyConsumerDescriptor::AndroidEnergyConsumerDescriptor(AndroidEnergyConsumerDescriptor&&) noexcept = default;
+AndroidEnergyConsumerDescriptor& AndroidEnergyConsumerDescriptor::operator=(AndroidEnergyConsumerDescriptor&&) = default;
 
-bool FtraceDescriptor::operator==(const FtraceDescriptor& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && atrace_categories_ == other.atrace_categories_;
+bool AndroidEnergyConsumerDescriptor::operator==(const AndroidEnergyConsumerDescriptor& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(energy_consumers_, other.energy_consumers_);
 }
 
-int FtraceDescriptor::atrace_categories_size() const { return static_cast<int>(atrace_categories_.size()); }
-void FtraceDescriptor::clear_atrace_categories() { atrace_categories_.clear(); }
-FtraceDescriptor_AtraceCategory* FtraceDescriptor::add_atrace_categories() { atrace_categories_.emplace_back(); return &atrace_categories_.back(); }
-bool FtraceDescriptor::ParseFromArray(const void* raw, size_t size) {
-  atrace_categories_.clear();
+int AndroidEnergyConsumerDescriptor::energy_consumers_size() const { return static_cast<int>(energy_consumers_.size()); }
+void AndroidEnergyConsumerDescriptor::clear_energy_consumers() { energy_consumers_.clear(); }
+AndroidEnergyConsumer* AndroidEnergyConsumerDescriptor::add_energy_consumers() { energy_consumers_.emplace_back(); return &energy_consumers_.back(); }
+bool AndroidEnergyConsumerDescriptor::ParseFromArray(const void* raw, size_t size) {
+  energy_consumers_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -13919,9 +15316,9 @@ bool FtraceDescriptor::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* atrace_categories */:
-        atrace_categories_.emplace_back();
-        atrace_categories_.back().ParseFromArray(field.data(), field.size());
+      case 1 /* energy_consumers */:
+        energy_consumers_.emplace_back();
+        energy_consumers_.back().ParseFromArray(field.data(), field.size());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -13931,21 +15328,21 @@ bool FtraceDescriptor::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string FtraceDescriptor::SerializeAsString() const {
+std::string AndroidEnergyConsumerDescriptor::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> FtraceDescriptor::SerializeAsArray() const {
+std::vector<uint8_t> AndroidEnergyConsumerDescriptor::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void FtraceDescriptor::Serialize(::protozero::Message* msg) const {
-  // Field 1: atrace_categories
-  for (auto& it : atrace_categories_) {
+void AndroidEnergyConsumerDescriptor::Serialize(::protozero::Message* msg) const {
+  // Field 1: energy_consumers
+  for (auto& it : energy_consumers_) {
     it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
   }
 
@@ -13953,20 +15350,22 @@ void FtraceDescriptor::Serialize(::protozero::Message* msg) const {
 }
 
 
-FtraceDescriptor_AtraceCategory::FtraceDescriptor_AtraceCategory() = default;
-FtraceDescriptor_AtraceCategory::~FtraceDescriptor_AtraceCategory() = default;
-FtraceDescriptor_AtraceCategory::FtraceDescriptor_AtraceCategory(const FtraceDescriptor_AtraceCategory&) = default;
-FtraceDescriptor_AtraceCategory& FtraceDescriptor_AtraceCategory::operator=(const FtraceDescriptor_AtraceCategory&) = default;
-FtraceDescriptor_AtraceCategory::FtraceDescriptor_AtraceCategory(FtraceDescriptor_AtraceCategory&&) noexcept = default;
-FtraceDescriptor_AtraceCategory& FtraceDescriptor_AtraceCategory::operator=(FtraceDescriptor_AtraceCategory&&) = default;
+AndroidEnergyConsumer::AndroidEnergyConsumer() = default;
+AndroidEnergyConsumer::~AndroidEnergyConsumer() = default;
+AndroidEnergyConsumer::AndroidEnergyConsumer(const AndroidEnergyConsumer&) = default;
+AndroidEnergyConsumer& AndroidEnergyConsumer::operator=(const AndroidEnergyConsumer&) = default;
+AndroidEnergyConsumer::AndroidEnergyConsumer(AndroidEnergyConsumer&&) noexcept = default;
+AndroidEnergyConsumer& AndroidEnergyConsumer::operator=(AndroidEnergyConsumer&&) = default;
 
-bool FtraceDescriptor_AtraceCategory::operator==(const FtraceDescriptor_AtraceCategory& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && name_ == other.name_
-   && description_ == other.description_;
+bool AndroidEnergyConsumer::operator==(const AndroidEnergyConsumer& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(energy_consumer_id_, other.energy_consumer_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(ordinal_, other.ordinal_)
+   && ::protozero::internal::gen_helpers::EqualsField(type_, other.type_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_);
 }
 
-bool FtraceDescriptor_AtraceCategory::ParseFromArray(const void* raw, size_t size) {
+bool AndroidEnergyConsumer::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -13976,11 +15375,17 @@ bool FtraceDescriptor_AtraceCategory::ParseFromArray(const void* raw, size_t siz
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+      case 1 /* energy_consumer_id */:
+        field.get(&energy_consumer_id_);
         break;
-      case 2 /* description */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &description_);
+      case 2 /* ordinal */:
+        field.get(&ordinal_);
+        break;
+      case 3 /* type */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &type_);
+        break;
+      case 4 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -13990,27 +15395,37 @@ bool FtraceDescriptor_AtraceCategory::ParseFromArray(const void* raw, size_t siz
   return !packed_error && !dec.bytes_left();
 }
 
-std::string FtraceDescriptor_AtraceCategory::SerializeAsString() const {
+std::string AndroidEnergyConsumer::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> FtraceDescriptor_AtraceCategory::SerializeAsArray() const {
+std::vector<uint8_t> AndroidEnergyConsumer::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void FtraceDescriptor_AtraceCategory::Serialize(::protozero::Message* msg) const {
-  // Field 1: name
+void AndroidEnergyConsumer::Serialize(::protozero::Message* msg) const {
+  // Field 1: energy_consumer_id
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, energy_consumer_id_, msg);
   }
 
-  // Field 2: description
+  // Field 2: ordinal
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeString(2, description_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, ordinal_, msg);
+  }
+
+  // Field 3: type
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeString(3, type_, msg);
+  }
+
+  // Field 4: name
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeString(4, name_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -14022,371 +15437,51 @@ void FtraceDescriptor_AtraceCategory::Serialize(::protozero::Message* msg) const
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/common/gpu_counter_descriptor.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/common/gpu_counter_descriptor.gen.h
+// gen_amalgamated begin source: gen/protos/perfetto/common/android_log_constants.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_GPU_COUNTER_DESCRIPTOR_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_GPU_COUNTER_DESCRIPTOR_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/common/android_log_constants.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
-class GpuCounterDescriptor;
-class GpuCounterDescriptor_GpuCounterBlock;
-class GpuCounterDescriptor_GpuCounterSpec;
-enum GpuCounterDescriptor_GpuCounterGroup : int;
-enum GpuCounterDescriptor_MeasureUnit : int;
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/common/builtin_clock.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/common/builtin_clock.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
-enum GpuCounterDescriptor_GpuCounterGroup : int {
-  GpuCounterDescriptor_GpuCounterGroup_UNCLASSIFIED = 0,
-  GpuCounterDescriptor_GpuCounterGroup_SYSTEM = 1,
-  GpuCounterDescriptor_GpuCounterGroup_VERTICES = 2,
-  GpuCounterDescriptor_GpuCounterGroup_FRAGMENTS = 3,
-  GpuCounterDescriptor_GpuCounterGroup_PRIMITIVES = 4,
-  GpuCounterDescriptor_GpuCounterGroup_MEMORY = 5,
-  GpuCounterDescriptor_GpuCounterGroup_COMPUTE = 6,
-};
-enum GpuCounterDescriptor_MeasureUnit : int {
-  GpuCounterDescriptor_MeasureUnit_NONE = 0,
-  GpuCounterDescriptor_MeasureUnit_BIT = 1,
-  GpuCounterDescriptor_MeasureUnit_KILOBIT = 2,
-  GpuCounterDescriptor_MeasureUnit_MEGABIT = 3,
-  GpuCounterDescriptor_MeasureUnit_GIGABIT = 4,
-  GpuCounterDescriptor_MeasureUnit_TERABIT = 5,
-  GpuCounterDescriptor_MeasureUnit_PETABIT = 6,
-  GpuCounterDescriptor_MeasureUnit_BYTE = 7,
-  GpuCounterDescriptor_MeasureUnit_KILOBYTE = 8,
-  GpuCounterDescriptor_MeasureUnit_MEGABYTE = 9,
-  GpuCounterDescriptor_MeasureUnit_GIGABYTE = 10,
-  GpuCounterDescriptor_MeasureUnit_TERABYTE = 11,
-  GpuCounterDescriptor_MeasureUnit_PETABYTE = 12,
-  GpuCounterDescriptor_MeasureUnit_HERTZ = 13,
-  GpuCounterDescriptor_MeasureUnit_KILOHERTZ = 14,
-  GpuCounterDescriptor_MeasureUnit_MEGAHERTZ = 15,
-  GpuCounterDescriptor_MeasureUnit_GIGAHERTZ = 16,
-  GpuCounterDescriptor_MeasureUnit_TERAHERTZ = 17,
-  GpuCounterDescriptor_MeasureUnit_PETAHERTZ = 18,
-  GpuCounterDescriptor_MeasureUnit_NANOSECOND = 19,
-  GpuCounterDescriptor_MeasureUnit_MICROSECOND = 20,
-  GpuCounterDescriptor_MeasureUnit_MILLISECOND = 21,
-  GpuCounterDescriptor_MeasureUnit_SECOND = 22,
-  GpuCounterDescriptor_MeasureUnit_MINUTE = 23,
-  GpuCounterDescriptor_MeasureUnit_HOUR = 24,
-  GpuCounterDescriptor_MeasureUnit_VERTEX = 25,
-  GpuCounterDescriptor_MeasureUnit_PIXEL = 26,
-  GpuCounterDescriptor_MeasureUnit_TRIANGLE = 27,
-  GpuCounterDescriptor_MeasureUnit_PRIMITIVE = 38,
-  GpuCounterDescriptor_MeasureUnit_FRAGMENT = 39,
-  GpuCounterDescriptor_MeasureUnit_MILLIWATT = 28,
-  GpuCounterDescriptor_MeasureUnit_WATT = 29,
-  GpuCounterDescriptor_MeasureUnit_KILOWATT = 30,
-  GpuCounterDescriptor_MeasureUnit_JOULE = 31,
-  GpuCounterDescriptor_MeasureUnit_VOLT = 32,
-  GpuCounterDescriptor_MeasureUnit_AMPERE = 33,
-  GpuCounterDescriptor_MeasureUnit_CELSIUS = 34,
-  GpuCounterDescriptor_MeasureUnit_FAHRENHEIT = 35,
-  GpuCounterDescriptor_MeasureUnit_KELVIN = 36,
-  GpuCounterDescriptor_MeasureUnit_PERCENT = 37,
-  GpuCounterDescriptor_MeasureUnit_INSTRUCTION = 40,
-};
-
-class PERFETTO_EXPORT_COMPONENT GpuCounterDescriptor : public ::protozero::CppMessageObj {
- public:
-  using GpuCounterSpec = GpuCounterDescriptor_GpuCounterSpec;
-  using GpuCounterBlock = GpuCounterDescriptor_GpuCounterBlock;
-  using GpuCounterGroup = GpuCounterDescriptor_GpuCounterGroup;
-  static constexpr auto UNCLASSIFIED = GpuCounterDescriptor_GpuCounterGroup_UNCLASSIFIED;
-  static constexpr auto SYSTEM = GpuCounterDescriptor_GpuCounterGroup_SYSTEM;
-  static constexpr auto VERTICES = GpuCounterDescriptor_GpuCounterGroup_VERTICES;
-  static constexpr auto FRAGMENTS = GpuCounterDescriptor_GpuCounterGroup_FRAGMENTS;
-  static constexpr auto PRIMITIVES = GpuCounterDescriptor_GpuCounterGroup_PRIMITIVES;
-  static constexpr auto MEMORY = GpuCounterDescriptor_GpuCounterGroup_MEMORY;
-  static constexpr auto COMPUTE = GpuCounterDescriptor_GpuCounterGroup_COMPUTE;
-  static constexpr auto GpuCounterGroup_MIN = GpuCounterDescriptor_GpuCounterGroup_UNCLASSIFIED;
-  static constexpr auto GpuCounterGroup_MAX = GpuCounterDescriptor_GpuCounterGroup_COMPUTE;
-  using MeasureUnit = GpuCounterDescriptor_MeasureUnit;
-  static constexpr auto NONE = GpuCounterDescriptor_MeasureUnit_NONE;
-  static constexpr auto BIT = GpuCounterDescriptor_MeasureUnit_BIT;
-  static constexpr auto KILOBIT = GpuCounterDescriptor_MeasureUnit_KILOBIT;
-  static constexpr auto MEGABIT = GpuCounterDescriptor_MeasureUnit_MEGABIT;
-  static constexpr auto GIGABIT = GpuCounterDescriptor_MeasureUnit_GIGABIT;
-  static constexpr auto TERABIT = GpuCounterDescriptor_MeasureUnit_TERABIT;
-  static constexpr auto PETABIT = GpuCounterDescriptor_MeasureUnit_PETABIT;
-  static constexpr auto BYTE = GpuCounterDescriptor_MeasureUnit_BYTE;
-  static constexpr auto KILOBYTE = GpuCounterDescriptor_MeasureUnit_KILOBYTE;
-  static constexpr auto MEGABYTE = GpuCounterDescriptor_MeasureUnit_MEGABYTE;
-  static constexpr auto GIGABYTE = GpuCounterDescriptor_MeasureUnit_GIGABYTE;
-  static constexpr auto TERABYTE = GpuCounterDescriptor_MeasureUnit_TERABYTE;
-  static constexpr auto PETABYTE = GpuCounterDescriptor_MeasureUnit_PETABYTE;
-  static constexpr auto HERTZ = GpuCounterDescriptor_MeasureUnit_HERTZ;
-  static constexpr auto KILOHERTZ = GpuCounterDescriptor_MeasureUnit_KILOHERTZ;
-  static constexpr auto MEGAHERTZ = GpuCounterDescriptor_MeasureUnit_MEGAHERTZ;
-  static constexpr auto GIGAHERTZ = GpuCounterDescriptor_MeasureUnit_GIGAHERTZ;
-  static constexpr auto TERAHERTZ = GpuCounterDescriptor_MeasureUnit_TERAHERTZ;
-  static constexpr auto PETAHERTZ = GpuCounterDescriptor_MeasureUnit_PETAHERTZ;
-  static constexpr auto NANOSECOND = GpuCounterDescriptor_MeasureUnit_NANOSECOND;
-  static constexpr auto MICROSECOND = GpuCounterDescriptor_MeasureUnit_MICROSECOND;
-  static constexpr auto MILLISECOND = GpuCounterDescriptor_MeasureUnit_MILLISECOND;
-  static constexpr auto SECOND = GpuCounterDescriptor_MeasureUnit_SECOND;
-  static constexpr auto MINUTE = GpuCounterDescriptor_MeasureUnit_MINUTE;
-  static constexpr auto HOUR = GpuCounterDescriptor_MeasureUnit_HOUR;
-  static constexpr auto VERTEX = GpuCounterDescriptor_MeasureUnit_VERTEX;
-  static constexpr auto PIXEL = GpuCounterDescriptor_MeasureUnit_PIXEL;
-  static constexpr auto TRIANGLE = GpuCounterDescriptor_MeasureUnit_TRIANGLE;
-  static constexpr auto PRIMITIVE = GpuCounterDescriptor_MeasureUnit_PRIMITIVE;
-  static constexpr auto FRAGMENT = GpuCounterDescriptor_MeasureUnit_FRAGMENT;
-  static constexpr auto MILLIWATT = GpuCounterDescriptor_MeasureUnit_MILLIWATT;
-  static constexpr auto WATT = GpuCounterDescriptor_MeasureUnit_WATT;
-  static constexpr auto KILOWATT = GpuCounterDescriptor_MeasureUnit_KILOWATT;
-  static constexpr auto JOULE = GpuCounterDescriptor_MeasureUnit_JOULE;
-  static constexpr auto VOLT = GpuCounterDescriptor_MeasureUnit_VOLT;
-  static constexpr auto AMPERE = GpuCounterDescriptor_MeasureUnit_AMPERE;
-  static constexpr auto CELSIUS = GpuCounterDescriptor_MeasureUnit_CELSIUS;
-  static constexpr auto FAHRENHEIT = GpuCounterDescriptor_MeasureUnit_FAHRENHEIT;
-  static constexpr auto KELVIN = GpuCounterDescriptor_MeasureUnit_KELVIN;
-  static constexpr auto PERCENT = GpuCounterDescriptor_MeasureUnit_PERCENT;
-  static constexpr auto INSTRUCTION = GpuCounterDescriptor_MeasureUnit_INSTRUCTION;
-  static constexpr auto MeasureUnit_MIN = GpuCounterDescriptor_MeasureUnit_NONE;
-  static constexpr auto MeasureUnit_MAX = GpuCounterDescriptor_MeasureUnit_INSTRUCTION;
-  enum FieldNumbers {
-    kSpecsFieldNumber = 1,
-    kBlocksFieldNumber = 2,
-    kMinSamplingPeriodNsFieldNumber = 3,
-    kMaxSamplingPeriodNsFieldNumber = 4,
-    kSupportsInstrumentedSamplingFieldNumber = 5,
-  };
-
-  GpuCounterDescriptor();
-  ~GpuCounterDescriptor() override;
-  GpuCounterDescriptor(GpuCounterDescriptor&&) noexcept;
-  GpuCounterDescriptor& operator=(GpuCounterDescriptor&&);
-  GpuCounterDescriptor(const GpuCounterDescriptor&);
-  GpuCounterDescriptor& operator=(const GpuCounterDescriptor&);
-  bool operator==(const GpuCounterDescriptor&) const;
-  bool operator!=(const GpuCounterDescriptor& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<GpuCounterDescriptor_GpuCounterSpec>& specs() const { return specs_; }
-  std::vector<GpuCounterDescriptor_GpuCounterSpec>* mutable_specs() { return &specs_; }
-  int specs_size() const;
-  void clear_specs();
-  GpuCounterDescriptor_GpuCounterSpec* add_specs();
-
-  const std::vector<GpuCounterDescriptor_GpuCounterBlock>& blocks() const { return blocks_; }
-  std::vector<GpuCounterDescriptor_GpuCounterBlock>* mutable_blocks() { return &blocks_; }
-  int blocks_size() const;
-  void clear_blocks();
-  GpuCounterDescriptor_GpuCounterBlock* add_blocks();
-
-  bool has_min_sampling_period_ns() const { return _has_field_[3]; }
-  uint64_t min_sampling_period_ns() const { return min_sampling_period_ns_; }
-  void set_min_sampling_period_ns(uint64_t value) { min_sampling_period_ns_ = value; _has_field_.set(3); }
-
-  bool has_max_sampling_period_ns() const { return _has_field_[4]; }
-  uint64_t max_sampling_period_ns() const { return max_sampling_period_ns_; }
-  void set_max_sampling_period_ns(uint64_t value) { max_sampling_period_ns_ = value; _has_field_.set(4); }
-
-  bool has_supports_instrumented_sampling() const { return _has_field_[5]; }
-  bool supports_instrumented_sampling() const { return supports_instrumented_sampling_; }
-  void set_supports_instrumented_sampling(bool value) { supports_instrumented_sampling_ = value; _has_field_.set(5); }
-
- private:
-  std::vector<GpuCounterDescriptor_GpuCounterSpec> specs_;
-  std::vector<GpuCounterDescriptor_GpuCounterBlock> blocks_;
-  uint64_t min_sampling_period_ns_{};
-  uint64_t max_sampling_period_ns_{};
-  bool supports_instrumented_sampling_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<6> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT GpuCounterDescriptor_GpuCounterBlock : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kBlockIdFieldNumber = 1,
-    kBlockCapacityFieldNumber = 2,
-    kNameFieldNumber = 3,
-    kDescriptionFieldNumber = 4,
-    kCounterIdsFieldNumber = 5,
-  };
-
-  GpuCounterDescriptor_GpuCounterBlock();
-  ~GpuCounterDescriptor_GpuCounterBlock() override;
-  GpuCounterDescriptor_GpuCounterBlock(GpuCounterDescriptor_GpuCounterBlock&&) noexcept;
-  GpuCounterDescriptor_GpuCounterBlock& operator=(GpuCounterDescriptor_GpuCounterBlock&&);
-  GpuCounterDescriptor_GpuCounterBlock(const GpuCounterDescriptor_GpuCounterBlock&);
-  GpuCounterDescriptor_GpuCounterBlock& operator=(const GpuCounterDescriptor_GpuCounterBlock&);
-  bool operator==(const GpuCounterDescriptor_GpuCounterBlock&) const;
-  bool operator!=(const GpuCounterDescriptor_GpuCounterBlock& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_block_id() const { return _has_field_[1]; }
-  uint32_t block_id() const { return block_id_; }
-  void set_block_id(uint32_t value) { block_id_ = value; _has_field_.set(1); }
-
-  bool has_block_capacity() const { return _has_field_[2]; }
-  uint32_t block_capacity() const { return block_capacity_; }
-  void set_block_capacity(uint32_t value) { block_capacity_ = value; _has_field_.set(2); }
-
-  bool has_name() const { return _has_field_[3]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(3); }
-
-  bool has_description() const { return _has_field_[4]; }
-  const std::string& description() const { return description_; }
-  void set_description(const std::string& value) { description_ = value; _has_field_.set(4); }
-
-  const std::vector<uint32_t>& counter_ids() const { return counter_ids_; }
-  std::vector<uint32_t>* mutable_counter_ids() { return &counter_ids_; }
-  int counter_ids_size() const { return static_cast<int>(counter_ids_.size()); }
-  void clear_counter_ids() { counter_ids_.clear(); }
-  void add_counter_ids(uint32_t value) { counter_ids_.emplace_back(value); }
-  uint32_t* add_counter_ids() { counter_ids_.emplace_back(); return &counter_ids_.back(); }
-
- private:
-  uint32_t block_id_{};
-  uint32_t block_capacity_{};
-  std::string name_{};
-  std::string description_{};
-  std::vector<uint32_t> counter_ids_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<6> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT GpuCounterDescriptor_GpuCounterSpec : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kCounterIdFieldNumber = 1,
-    kNameFieldNumber = 2,
-    kDescriptionFieldNumber = 3,
-    kIntPeakValueFieldNumber = 5,
-    kDoublePeakValueFieldNumber = 6,
-    kNumeratorUnitsFieldNumber = 7,
-    kDenominatorUnitsFieldNumber = 8,
-    kSelectByDefaultFieldNumber = 9,
-    kGroupsFieldNumber = 10,
-  };
-
-  GpuCounterDescriptor_GpuCounterSpec();
-  ~GpuCounterDescriptor_GpuCounterSpec() override;
-  GpuCounterDescriptor_GpuCounterSpec(GpuCounterDescriptor_GpuCounterSpec&&) noexcept;
-  GpuCounterDescriptor_GpuCounterSpec& operator=(GpuCounterDescriptor_GpuCounterSpec&&);
-  GpuCounterDescriptor_GpuCounterSpec(const GpuCounterDescriptor_GpuCounterSpec&);
-  GpuCounterDescriptor_GpuCounterSpec& operator=(const GpuCounterDescriptor_GpuCounterSpec&);
-  bool operator==(const GpuCounterDescriptor_GpuCounterSpec&) const;
-  bool operator!=(const GpuCounterDescriptor_GpuCounterSpec& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_counter_id() const { return _has_field_[1]; }
-  uint32_t counter_id() const { return counter_id_; }
-  void set_counter_id(uint32_t value) { counter_id_ = value; _has_field_.set(1); }
-
-  bool has_name() const { return _has_field_[2]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
-
-  bool has_description() const { return _has_field_[3]; }
-  const std::string& description() const { return description_; }
-  void set_description(const std::string& value) { description_ = value; _has_field_.set(3); }
-
-  bool has_int_peak_value() const { return _has_field_[5]; }
-  int64_t int_peak_value() const { return int_peak_value_; }
-  void set_int_peak_value(int64_t value) { int_peak_value_ = value; _has_field_.set(5); }
-
-  bool has_double_peak_value() const { return _has_field_[6]; }
-  double double_peak_value() const { return double_peak_value_; }
-  void set_double_peak_value(double value) { double_peak_value_ = value; _has_field_.set(6); }
-
-  const std::vector<GpuCounterDescriptor_MeasureUnit>& numerator_units() const { return numerator_units_; }
-  std::vector<GpuCounterDescriptor_MeasureUnit>* mutable_numerator_units() { return &numerator_units_; }
-  int numerator_units_size() const { return static_cast<int>(numerator_units_.size()); }
-  void clear_numerator_units() { numerator_units_.clear(); }
-  void add_numerator_units(GpuCounterDescriptor_MeasureUnit value) { numerator_units_.emplace_back(value); }
-  GpuCounterDescriptor_MeasureUnit* add_numerator_units() { numerator_units_.emplace_back(); return &numerator_units_.back(); }
-
-  const std::vector<GpuCounterDescriptor_MeasureUnit>& denominator_units() const { return denominator_units_; }
-  std::vector<GpuCounterDescriptor_MeasureUnit>* mutable_denominator_units() { return &denominator_units_; }
-  int denominator_units_size() const { return static_cast<int>(denominator_units_.size()); }
-  void clear_denominator_units() { denominator_units_.clear(); }
-  void add_denominator_units(GpuCounterDescriptor_MeasureUnit value) { denominator_units_.emplace_back(value); }
-  GpuCounterDescriptor_MeasureUnit* add_denominator_units() { denominator_units_.emplace_back(); return &denominator_units_.back(); }
-
-  bool has_select_by_default() const { return _has_field_[9]; }
-  bool select_by_default() const { return select_by_default_; }
-  void set_select_by_default(bool value) { select_by_default_ = value; _has_field_.set(9); }
-
-  const std::vector<GpuCounterDescriptor_GpuCounterGroup>& groups() const { return groups_; }
-  std::vector<GpuCounterDescriptor_GpuCounterGroup>* mutable_groups() { return &groups_; }
-  int groups_size() const { return static_cast<int>(groups_.size()); }
-  void clear_groups() { groups_.clear(); }
-  void add_groups(GpuCounterDescriptor_GpuCounterGroup value) { groups_.emplace_back(value); }
-  GpuCounterDescriptor_GpuCounterGroup* add_groups() { groups_.emplace_back(); return &groups_.back(); }
-
- private:
-  uint32_t counter_id_{};
-  std::string name_{};
-  std::string description_{};
-  int64_t int_peak_value_{};
-  double double_peak_value_{};
-  std::vector<GpuCounterDescriptor_MeasureUnit> numerator_units_;
-  std::vector<GpuCounterDescriptor_MeasureUnit> denominator_units_;
-  bool select_by_default_{};
-  std::vector<GpuCounterDescriptor_GpuCounterGroup> groups_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<11> _has_field_{};
-};
-
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_GPU_COUNTER_DESCRIPTOR_PROTO_CPP_H_
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/common/commit_data_request.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -14397,37 +15492,35 @@ class PERFETTO_EXPORT_COMPONENT GpuCounterDescriptor_GpuCounterSpec : public ::p
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/common/gpu_counter_descriptor.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/commit_data_request.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-GpuCounterDescriptor::GpuCounterDescriptor() = default;
-GpuCounterDescriptor::~GpuCounterDescriptor() = default;
-GpuCounterDescriptor::GpuCounterDescriptor(const GpuCounterDescriptor&) = default;
-GpuCounterDescriptor& GpuCounterDescriptor::operator=(const GpuCounterDescriptor&) = default;
-GpuCounterDescriptor::GpuCounterDescriptor(GpuCounterDescriptor&&) noexcept = default;
-GpuCounterDescriptor& GpuCounterDescriptor::operator=(GpuCounterDescriptor&&) = default;
+CommitDataRequest::CommitDataRequest() = default;
+CommitDataRequest::~CommitDataRequest() = default;
+CommitDataRequest::CommitDataRequest(const CommitDataRequest&) = default;
+CommitDataRequest& CommitDataRequest::operator=(const CommitDataRequest&) = default;
+CommitDataRequest::CommitDataRequest(CommitDataRequest&&) noexcept = default;
+CommitDataRequest& CommitDataRequest::operator=(CommitDataRequest&&) = default;
 
-bool GpuCounterDescriptor::operator==(const GpuCounterDescriptor& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && specs_ == other.specs_
-   && blocks_ == other.blocks_
-   && min_sampling_period_ns_ == other.min_sampling_period_ns_
-   && max_sampling_period_ns_ == other.max_sampling_period_ns_
-   && supports_instrumented_sampling_ == other.supports_instrumented_sampling_;
+bool CommitDataRequest::operator==(const CommitDataRequest& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(chunks_to_move_, other.chunks_to_move_)
+   && ::protozero::internal::gen_helpers::EqualsField(chunks_to_patch_, other.chunks_to_patch_)
+   && ::protozero::internal::gen_helpers::EqualsField(flush_request_id_, other.flush_request_id_);
 }
 
-int GpuCounterDescriptor::specs_size() const { return static_cast<int>(specs_.size()); }
-void GpuCounterDescriptor::clear_specs() { specs_.clear(); }
-GpuCounterDescriptor_GpuCounterSpec* GpuCounterDescriptor::add_specs() { specs_.emplace_back(); return &specs_.back(); }
-int GpuCounterDescriptor::blocks_size() const { return static_cast<int>(blocks_.size()); }
-void GpuCounterDescriptor::clear_blocks() { blocks_.clear(); }
-GpuCounterDescriptor_GpuCounterBlock* GpuCounterDescriptor::add_blocks() { blocks_.emplace_back(); return &blocks_.back(); }
-bool GpuCounterDescriptor::ParseFromArray(const void* raw, size_t size) {
-  specs_.clear();
-  blocks_.clear();
+int CommitDataRequest::chunks_to_move_size() const { return static_cast<int>(chunks_to_move_.size()); }
+void CommitDataRequest::clear_chunks_to_move() { chunks_to_move_.clear(); }
+CommitDataRequest_ChunksToMove* CommitDataRequest::add_chunks_to_move() { chunks_to_move_.emplace_back(); return &chunks_to_move_.back(); }
+int CommitDataRequest::chunks_to_patch_size() const { return static_cast<int>(chunks_to_patch_.size()); }
+void CommitDataRequest::clear_chunks_to_patch() { chunks_to_patch_.clear(); }
+CommitDataRequest_ChunkToPatch* CommitDataRequest::add_chunks_to_patch() { chunks_to_patch_.emplace_back(); return &chunks_to_patch_.back(); }
+bool CommitDataRequest::ParseFromArray(const void* raw, size_t size) {
+  chunks_to_move_.clear();
+  chunks_to_patch_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -14437,22 +15530,16 @@ bool GpuCounterDescriptor::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* specs */:
-        specs_.emplace_back();
-        specs_.back().ParseFromArray(field.data(), field.size());
-        break;
-      case 2 /* blocks */:
-        blocks_.emplace_back();
-        blocks_.back().ParseFromArray(field.data(), field.size());
-        break;
-      case 3 /* min_sampling_period_ns */:
-        field.get(&min_sampling_period_ns_);
+      case 1 /* chunks_to_move */:
+        chunks_to_move_.emplace_back();
+        chunks_to_move_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 4 /* max_sampling_period_ns */:
-        field.get(&max_sampling_period_ns_);
+      case 2 /* chunks_to_patch */:
+        chunks_to_patch_.emplace_back();
+        chunks_to_patch_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 5 /* supports_instrumented_sampling */:
-        field.get(&supports_instrumented_sampling_);
+      case 3 /* flush_request_id */:
+        field.get(&flush_request_id_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -14462,66 +15549,59 @@ bool GpuCounterDescriptor::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string GpuCounterDescriptor::SerializeAsString() const {
+std::string CommitDataRequest::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> GpuCounterDescriptor::SerializeAsArray() const {
+std::vector<uint8_t> CommitDataRequest::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void GpuCounterDescriptor::Serialize(::protozero::Message* msg) const {
-  // Field 1: specs
-  for (auto& it : specs_) {
+void CommitDataRequest::Serialize(::protozero::Message* msg) const {
+  // Field 1: chunks_to_move
+  for (auto& it : chunks_to_move_) {
     it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
   }
 
-  // Field 2: blocks
-  for (auto& it : blocks_) {
+  // Field 2: chunks_to_patch
+  for (auto& it : chunks_to_patch_) {
     it.Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
   }
 
-  // Field 3: min_sampling_period_ns
+  // Field 3: flush_request_id
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, min_sampling_period_ns_, msg);
-  }
-
-  // Field 4: max_sampling_period_ns
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, max_sampling_period_ns_, msg);
-  }
-
-  // Field 5: supports_instrumented_sampling
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, supports_instrumented_sampling_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, flush_request_id_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-GpuCounterDescriptor_GpuCounterBlock::GpuCounterDescriptor_GpuCounterBlock() = default;
-GpuCounterDescriptor_GpuCounterBlock::~GpuCounterDescriptor_GpuCounterBlock() = default;
-GpuCounterDescriptor_GpuCounterBlock::GpuCounterDescriptor_GpuCounterBlock(const GpuCounterDescriptor_GpuCounterBlock&) = default;
-GpuCounterDescriptor_GpuCounterBlock& GpuCounterDescriptor_GpuCounterBlock::operator=(const GpuCounterDescriptor_GpuCounterBlock&) = default;
-GpuCounterDescriptor_GpuCounterBlock::GpuCounterDescriptor_GpuCounterBlock(GpuCounterDescriptor_GpuCounterBlock&&) noexcept = default;
-GpuCounterDescriptor_GpuCounterBlock& GpuCounterDescriptor_GpuCounterBlock::operator=(GpuCounterDescriptor_GpuCounterBlock&&) = default;
+CommitDataRequest_ChunkToPatch::CommitDataRequest_ChunkToPatch() = default;
+CommitDataRequest_ChunkToPatch::~CommitDataRequest_ChunkToPatch() = default;
+CommitDataRequest_ChunkToPatch::CommitDataRequest_ChunkToPatch(const CommitDataRequest_ChunkToPatch&) = default;
+CommitDataRequest_ChunkToPatch& CommitDataRequest_ChunkToPatch::operator=(const CommitDataRequest_ChunkToPatch&) = default;
+CommitDataRequest_ChunkToPatch::CommitDataRequest_ChunkToPatch(CommitDataRequest_ChunkToPatch&&) noexcept = default;
+CommitDataRequest_ChunkToPatch& CommitDataRequest_ChunkToPatch::operator=(CommitDataRequest_ChunkToPatch&&) = default;
 
-bool GpuCounterDescriptor_GpuCounterBlock::operator==(const GpuCounterDescriptor_GpuCounterBlock& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && block_id_ == other.block_id_
-   && block_capacity_ == other.block_capacity_
-   && name_ == other.name_
-   && description_ == other.description_
-   && counter_ids_ == other.counter_ids_;
+bool CommitDataRequest_ChunkToPatch::operator==(const CommitDataRequest_ChunkToPatch& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(target_buffer_, other.target_buffer_)
+   && ::protozero::internal::gen_helpers::EqualsField(writer_id_, other.writer_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(chunk_id_, other.chunk_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(patches_, other.patches_)
+   && ::protozero::internal::gen_helpers::EqualsField(has_more_patches_, other.has_more_patches_);
 }
 
-bool GpuCounterDescriptor_GpuCounterBlock::ParseFromArray(const void* raw, size_t size) {
-  counter_ids_.clear();
+int CommitDataRequest_ChunkToPatch::patches_size() const { return static_cast<int>(patches_.size()); }
+void CommitDataRequest_ChunkToPatch::clear_patches() { patches_.clear(); }
+CommitDataRequest_ChunkToPatch_Patch* CommitDataRequest_ChunkToPatch::add_patches() { patches_.emplace_back(); return &patches_.back(); }
+bool CommitDataRequest_ChunkToPatch::ParseFromArray(const void* raw, size_t size) {
+  patches_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -14531,21 +15611,21 @@ bool GpuCounterDescriptor_GpuCounterBlock::ParseFromArray(const void* raw, size_
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* block_id */:
-        field.get(&block_id_);
+      case 1 /* target_buffer */:
+        field.get(&target_buffer_);
         break;
-      case 2 /* block_capacity */:
-        field.get(&block_capacity_);
+      case 2 /* writer_id */:
+        field.get(&writer_id_);
         break;
-      case 3 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+      case 3 /* chunk_id */:
+        field.get(&chunk_id_);
         break;
-      case 4 /* description */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &description_);
+      case 4 /* patches */:
+        patches_.emplace_back();
+        patches_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 5 /* counter_ids */:
-        counter_ids_.emplace_back();
-        field.get(&counter_ids_.back());
+      case 5 /* has_more_patches */:
+        field.get(&has_more_patches_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -14555,72 +15635,62 @@ bool GpuCounterDescriptor_GpuCounterBlock::ParseFromArray(const void* raw, size_
   return !packed_error && !dec.bytes_left();
 }
 
-std::string GpuCounterDescriptor_GpuCounterBlock::SerializeAsString() const {
+std::string CommitDataRequest_ChunkToPatch::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> GpuCounterDescriptor_GpuCounterBlock::SerializeAsArray() const {
+std::vector<uint8_t> CommitDataRequest_ChunkToPatch::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void GpuCounterDescriptor_GpuCounterBlock::Serialize(::protozero::Message* msg) const {
-  // Field 1: block_id
+void CommitDataRequest_ChunkToPatch::Serialize(::protozero::Message* msg) const {
+  // Field 1: target_buffer
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, block_id_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, target_buffer_, msg);
   }
 
-  // Field 2: block_capacity
+  // Field 2: writer_id
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, block_capacity_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, writer_id_, msg);
   }
 
-  // Field 3: name
+  // Field 3: chunk_id
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeString(3, name_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, chunk_id_, msg);
   }
 
-  // Field 4: description
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeString(4, description_, msg);
+  // Field 4: patches
+  for (auto& it : patches_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(4));
   }
 
-  // Field 5: counter_ids
-  for (auto& it : counter_ids_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(5, it, msg);
+  // Field 5: has_more_patches
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, has_more_patches_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-GpuCounterDescriptor_GpuCounterSpec::GpuCounterDescriptor_GpuCounterSpec() = default;
-GpuCounterDescriptor_GpuCounterSpec::~GpuCounterDescriptor_GpuCounterSpec() = default;
-GpuCounterDescriptor_GpuCounterSpec::GpuCounterDescriptor_GpuCounterSpec(const GpuCounterDescriptor_GpuCounterSpec&) = default;
-GpuCounterDescriptor_GpuCounterSpec& GpuCounterDescriptor_GpuCounterSpec::operator=(const GpuCounterDescriptor_GpuCounterSpec&) = default;
-GpuCounterDescriptor_GpuCounterSpec::GpuCounterDescriptor_GpuCounterSpec(GpuCounterDescriptor_GpuCounterSpec&&) noexcept = default;
-GpuCounterDescriptor_GpuCounterSpec& GpuCounterDescriptor_GpuCounterSpec::operator=(GpuCounterDescriptor_GpuCounterSpec&&) = default;
+CommitDataRequest_ChunkToPatch_Patch::CommitDataRequest_ChunkToPatch_Patch() = default;
+CommitDataRequest_ChunkToPatch_Patch::~CommitDataRequest_ChunkToPatch_Patch() = default;
+CommitDataRequest_ChunkToPatch_Patch::CommitDataRequest_ChunkToPatch_Patch(const CommitDataRequest_ChunkToPatch_Patch&) = default;
+CommitDataRequest_ChunkToPatch_Patch& CommitDataRequest_ChunkToPatch_Patch::operator=(const CommitDataRequest_ChunkToPatch_Patch&) = default;
+CommitDataRequest_ChunkToPatch_Patch::CommitDataRequest_ChunkToPatch_Patch(CommitDataRequest_ChunkToPatch_Patch&&) noexcept = default;
+CommitDataRequest_ChunkToPatch_Patch& CommitDataRequest_ChunkToPatch_Patch::operator=(CommitDataRequest_ChunkToPatch_Patch&&) = default;
 
-bool GpuCounterDescriptor_GpuCounterSpec::operator==(const GpuCounterDescriptor_GpuCounterSpec& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && counter_id_ == other.counter_id_
-   && name_ == other.name_
-   && description_ == other.description_
-   && int_peak_value_ == other.int_peak_value_
-   && double_peak_value_ == other.double_peak_value_
-   && numerator_units_ == other.numerator_units_
-   && denominator_units_ == other.denominator_units_
-   && select_by_default_ == other.select_by_default_
-   && groups_ == other.groups_;
+bool CommitDataRequest_ChunkToPatch_Patch::operator==(const CommitDataRequest_ChunkToPatch_Patch& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(offset_, other.offset_)
+   && ::protozero::internal::gen_helpers::EqualsField(data_, other.data_);
 }
 
-bool GpuCounterDescriptor_GpuCounterSpec::ParseFromArray(const void* raw, size_t size) {
-  numerator_units_.clear();
-  denominator_units_.clear();
-  groups_.clear();
+bool CommitDataRequest_ChunkToPatch_Patch::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -14630,35 +15700,11 @@ bool GpuCounterDescriptor_GpuCounterSpec::ParseFromArray(const void* raw, size_t
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* counter_id */:
-        field.get(&counter_id_);
-        break;
-      case 2 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
-        break;
-      case 3 /* description */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &description_);
-        break;
-      case 5 /* int_peak_value */:
-        field.get(&int_peak_value_);
-        break;
-      case 6 /* double_peak_value */:
-        field.get(&double_peak_value_);
-        break;
-      case 7 /* numerator_units */:
-        numerator_units_.emplace_back();
-        field.get(&numerator_units_.back());
-        break;
-      case 8 /* denominator_units */:
-        denominator_units_.emplace_back();
-        field.get(&denominator_units_.back());
-        break;
-      case 9 /* select_by_default */:
-        field.get(&select_by_default_);
+      case 1 /* offset */:
+        field.get(&offset_);
         break;
-      case 10 /* groups */:
-        groups_.emplace_back();
-        field.get(&groups_.back());
+      case 2 /* data */:
+        field.get(&data_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -14668,62 +15714,118 @@ bool GpuCounterDescriptor_GpuCounterSpec::ParseFromArray(const void* raw, size_t
   return !packed_error && !dec.bytes_left();
 }
 
-std::string GpuCounterDescriptor_GpuCounterSpec::SerializeAsString() const {
+std::string CommitDataRequest_ChunkToPatch_Patch::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> GpuCounterDescriptor_GpuCounterSpec::SerializeAsArray() const {
+std::vector<uint8_t> CommitDataRequest_ChunkToPatch_Patch::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void GpuCounterDescriptor_GpuCounterSpec::Serialize(::protozero::Message* msg) const {
-  // Field 1: counter_id
+void CommitDataRequest_ChunkToPatch_Patch::Serialize(::protozero::Message* msg) const {
+  // Field 1: offset
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, counter_id_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, offset_, msg);
   }
 
-  // Field 2: name
+  // Field 2: data
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeString(2, name_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(2, data_, msg);
   }
 
-  // Field 3: description
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeString(3, description_, msg);
-  }
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  // Field 5: int_peak_value
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(5, int_peak_value_, msg);
+
+CommitDataRequest_ChunksToMove::CommitDataRequest_ChunksToMove() = default;
+CommitDataRequest_ChunksToMove::~CommitDataRequest_ChunksToMove() = default;
+CommitDataRequest_ChunksToMove::CommitDataRequest_ChunksToMove(const CommitDataRequest_ChunksToMove&) = default;
+CommitDataRequest_ChunksToMove& CommitDataRequest_ChunksToMove::operator=(const CommitDataRequest_ChunksToMove&) = default;
+CommitDataRequest_ChunksToMove::CommitDataRequest_ChunksToMove(CommitDataRequest_ChunksToMove&&) noexcept = default;
+CommitDataRequest_ChunksToMove& CommitDataRequest_ChunksToMove::operator=(CommitDataRequest_ChunksToMove&&) = default;
+
+bool CommitDataRequest_ChunksToMove::operator==(const CommitDataRequest_ChunksToMove& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(page_, other.page_)
+   && ::protozero::internal::gen_helpers::EqualsField(chunk_, other.chunk_)
+   && ::protozero::internal::gen_helpers::EqualsField(target_buffer_, other.target_buffer_)
+   && ::protozero::internal::gen_helpers::EqualsField(data_, other.data_)
+   && ::protozero::internal::gen_helpers::EqualsField(chunk_incomplete_, other.chunk_incomplete_);
+}
+
+bool CommitDataRequest_ChunksToMove::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* page */:
+        field.get(&page_);
+        break;
+      case 2 /* chunk */:
+        field.get(&chunk_);
+        break;
+      case 3 /* target_buffer */:
+        field.get(&target_buffer_);
+        break;
+      case 4 /* data */:
+        field.get(&data_);
+        break;
+      case 5 /* chunk_incomplete */:
+        field.get(&chunk_incomplete_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
   }
+  return !packed_error && !dec.bytes_left();
+}
 
-  // Field 6: double_peak_value
-  if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeFixed(6, double_peak_value_, msg);
+std::string CommitDataRequest_ChunksToMove::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> CommitDataRequest_ChunksToMove::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void CommitDataRequest_ChunksToMove::Serialize(::protozero::Message* msg) const {
+  // Field 1: page
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, page_, msg);
   }
 
-  // Field 7: numerator_units
-  for (auto& it : numerator_units_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(7, it, msg);
+  // Field 2: chunk
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, chunk_, msg);
   }
 
-  // Field 8: denominator_units
-  for (auto& it : denominator_units_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(8, it, msg);
+  // Field 3: target_buffer
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, target_buffer_, msg);
   }
 
-  // Field 9: select_by_default
-  if (_has_field_[9]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(9, select_by_default_, msg);
+  // Field 4: data
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeString(4, data_, msg);
   }
 
-  // Field 10: groups
-  for (auto& it : groups_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(10, it, msg);
+  // Field 5: chunk_incomplete
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, chunk_incomplete_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -14735,77 +15837,7 @@ void GpuCounterDescriptor_GpuCounterSpec::Serialize(::protozero::Message* msg) c
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/common/interceptor_descriptor.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/common/interceptor_descriptor.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_INTERCEPTOR_DESCRIPTOR_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_INTERCEPTOR_DESCRIPTOR_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class InterceptorDescriptor;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT InterceptorDescriptor : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kNameFieldNumber = 1,
-  };
-
-  InterceptorDescriptor();
-  ~InterceptorDescriptor() override;
-  InterceptorDescriptor(InterceptorDescriptor&&) noexcept;
-  InterceptorDescriptor& operator=(InterceptorDescriptor&&);
-  InterceptorDescriptor(const InterceptorDescriptor&);
-  InterceptorDescriptor& operator=(const InterceptorDescriptor&);
-  bool operator==(const InterceptorDescriptor&) const;
-  bool operator!=(const InterceptorDescriptor& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_name() const { return _has_field_[1]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
-
- private:
-  std::string name_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_INTERCEPTOR_DESCRIPTOR_PROTO_CPP_H_
+// gen_amalgamated begin source: gen/protos/perfetto/common/data_source_descriptor.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -14816,25 +15848,35 @@ class PERFETTO_EXPORT_COMPONENT InterceptorDescriptor : public ::protozero::CppM
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/common/interceptor_descriptor.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/data_source_descriptor.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/protovm/vm_program.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-InterceptorDescriptor::InterceptorDescriptor() = default;
-InterceptorDescriptor::~InterceptorDescriptor() = default;
-InterceptorDescriptor::InterceptorDescriptor(const InterceptorDescriptor&) = default;
-InterceptorDescriptor& InterceptorDescriptor::operator=(const InterceptorDescriptor&) = default;
-InterceptorDescriptor::InterceptorDescriptor(InterceptorDescriptor&&) noexcept = default;
-InterceptorDescriptor& InterceptorDescriptor::operator=(InterceptorDescriptor&&) = default;
+DataSourceDescriptor::DataSourceDescriptor() = default;
+DataSourceDescriptor::~DataSourceDescriptor() = default;
+DataSourceDescriptor::DataSourceDescriptor(const DataSourceDescriptor&) = default;
+DataSourceDescriptor& DataSourceDescriptor::operator=(const DataSourceDescriptor&) = default;
+DataSourceDescriptor::DataSourceDescriptor(DataSourceDescriptor&&) noexcept = default;
+DataSourceDescriptor& DataSourceDescriptor::operator=(DataSourceDescriptor&&) = default;
 
-bool InterceptorDescriptor::operator==(const InterceptorDescriptor& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && name_ == other.name_;
+bool DataSourceDescriptor::operator==(const DataSourceDescriptor& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(id_, other.id_)
+   && ::protozero::internal::gen_helpers::EqualsField(will_notify_on_stop_, other.will_notify_on_stop_)
+   && ::protozero::internal::gen_helpers::EqualsField(will_notify_on_start_, other.will_notify_on_start_)
+   && ::protozero::internal::gen_helpers::EqualsField(handles_incremental_state_clear_, other.handles_incremental_state_clear_)
+   && ::protozero::internal::gen_helpers::EqualsField(no_flush_, other.no_flush_)
+   && ::protozero::internal::gen_helpers::EqualsField(protovm_program_, other.protovm_program_)
+   && ::protozero::internal::gen_helpers::EqualsField(gpu_counter_descriptor_, other.gpu_counter_descriptor_)
+   && ::protozero::internal::gen_helpers::EqualsField(track_event_descriptor_, other.track_event_descriptor_)
+   && ::protozero::internal::gen_helpers::EqualsField(ftrace_descriptor_, other.ftrace_descriptor_);
 }
 
-bool InterceptorDescriptor::ParseFromArray(const void* raw, size_t size) {
+bool DataSourceDescriptor::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -14847,6 +15889,33 @@ bool InterceptorDescriptor::ParseFromArray(const void* raw, size_t size) {
       case 1 /* name */:
         ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
         break;
+      case 7 /* id */:
+        field.get(&id_);
+        break;
+      case 2 /* will_notify_on_stop */:
+        field.get(&will_notify_on_stop_);
+        break;
+      case 3 /* will_notify_on_start */:
+        field.get(&will_notify_on_start_);
+        break;
+      case 4 /* handles_incremental_state_clear */:
+        field.get(&handles_incremental_state_clear_);
+        break;
+      case 9 /* no_flush */:
+        field.get(&no_flush_);
+        break;
+      case 10 /* protovm_program */:
+        (*protovm_program_).ParseFromArray(field.data(), field.size());
+        break;
+      case 5 /* gpu_counter_descriptor */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &gpu_counter_descriptor_);
+        break;
+      case 6 /* track_event_descriptor */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &track_event_descriptor_);
+        break;
+      case 8 /* ftrace_descriptor */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &ftrace_descriptor_);
+        break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
         break;
@@ -14855,24 +15924,69 @@ bool InterceptorDescriptor::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string InterceptorDescriptor::SerializeAsString() const {
+std::string DataSourceDescriptor::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> InterceptorDescriptor::SerializeAsArray() const {
+std::vector<uint8_t> DataSourceDescriptor::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void InterceptorDescriptor::Serialize(::protozero::Message* msg) const {
+void DataSourceDescriptor::Serialize(::protozero::Message* msg) const {
   // Field 1: name
   if (_has_field_[1]) {
     ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
   }
 
+  // Field 7: id
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(7, id_, msg);
+  }
+
+  // Field 2: will_notify_on_stop
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, will_notify_on_stop_, msg);
+  }
+
+  // Field 3: will_notify_on_start
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, will_notify_on_start_, msg);
+  }
+
+  // Field 4: handles_incremental_state_clear
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(4, handles_incremental_state_clear_, msg);
+  }
+
+  // Field 9: no_flush
+  if (_has_field_[9]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(9, no_flush_, msg);
+  }
+
+  // Field 10: protovm_program
+  if (_has_field_[10]) {
+    (*protovm_program_).Serialize(msg->BeginNestedMessage<::protozero::Message>(10));
+  }
+
+  // Field 5: gpu_counter_descriptor
+  if (_has_field_[5]) {
+    msg->AppendString(5, gpu_counter_descriptor_);
+  }
+
+  // Field 6: track_event_descriptor
+  if (_has_field_[6]) {
+    msg->AppendString(6, track_event_descriptor_);
+  }
+
+  // Field 8: ftrace_descriptor
+  if (_has_field_[8]) {
+    msg->AppendString(8, ftrace_descriptor_);
+  }
+
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
@@ -14882,190 +15996,83 @@ void InterceptorDescriptor::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/common/observable_events.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/common/observable_events.gen.h
+// gen_amalgamated begin source: gen/protos/perfetto/common/descriptor.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_OBSERVABLE_EVENTS_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_OBSERVABLE_EVENTS_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ObservableEvents;
-class ObservableEvents_DataSourceInstanceStateChange;
-enum ObservableEvents_Type : int;
-enum ObservableEvents_DataSourceInstanceState : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/common/descriptor.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
-enum ObservableEvents_Type : int {
-  ObservableEvents_Type_TYPE_UNSPECIFIED = 0,
-  ObservableEvents_Type_TYPE_DATA_SOURCES_INSTANCES = 1,
-  ObservableEvents_Type_TYPE_ALL_DATA_SOURCES_STARTED = 2,
-};
-enum ObservableEvents_DataSourceInstanceState : int {
-  ObservableEvents_DataSourceInstanceState_DATA_SOURCE_INSTANCE_STATE_STOPPED = 1,
-  ObservableEvents_DataSourceInstanceState_DATA_SOURCE_INSTANCE_STATE_STARTED = 2,
-};
-
-class PERFETTO_EXPORT_COMPONENT ObservableEvents : public ::protozero::CppMessageObj {
- public:
-  using DataSourceInstanceStateChange = ObservableEvents_DataSourceInstanceStateChange;
-  using Type = ObservableEvents_Type;
-  static constexpr auto TYPE_UNSPECIFIED = ObservableEvents_Type_TYPE_UNSPECIFIED;
-  static constexpr auto TYPE_DATA_SOURCES_INSTANCES = ObservableEvents_Type_TYPE_DATA_SOURCES_INSTANCES;
-  static constexpr auto TYPE_ALL_DATA_SOURCES_STARTED = ObservableEvents_Type_TYPE_ALL_DATA_SOURCES_STARTED;
-  static constexpr auto Type_MIN = ObservableEvents_Type_TYPE_UNSPECIFIED;
-  static constexpr auto Type_MAX = ObservableEvents_Type_TYPE_ALL_DATA_SOURCES_STARTED;
-  using DataSourceInstanceState = ObservableEvents_DataSourceInstanceState;
-  static constexpr auto DATA_SOURCE_INSTANCE_STATE_STOPPED = ObservableEvents_DataSourceInstanceState_DATA_SOURCE_INSTANCE_STATE_STOPPED;
-  static constexpr auto DATA_SOURCE_INSTANCE_STATE_STARTED = ObservableEvents_DataSourceInstanceState_DATA_SOURCE_INSTANCE_STATE_STARTED;
-  static constexpr auto DataSourceInstanceState_MIN = ObservableEvents_DataSourceInstanceState_DATA_SOURCE_INSTANCE_STATE_STOPPED;
-  static constexpr auto DataSourceInstanceState_MAX = ObservableEvents_DataSourceInstanceState_DATA_SOURCE_INSTANCE_STATE_STARTED;
-  enum FieldNumbers {
-    kInstanceStateChangesFieldNumber = 1,
-    kAllDataSourcesStartedFieldNumber = 2,
-  };
-
-  ObservableEvents();
-  ~ObservableEvents() override;
-  ObservableEvents(ObservableEvents&&) noexcept;
-  ObservableEvents& operator=(ObservableEvents&&);
-  ObservableEvents(const ObservableEvents&);
-  ObservableEvents& operator=(const ObservableEvents&);
-  bool operator==(const ObservableEvents&) const;
-  bool operator!=(const ObservableEvents& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<ObservableEvents_DataSourceInstanceStateChange>& instance_state_changes() const { return instance_state_changes_; }
-  std::vector<ObservableEvents_DataSourceInstanceStateChange>* mutable_instance_state_changes() { return &instance_state_changes_; }
-  int instance_state_changes_size() const;
-  void clear_instance_state_changes();
-  ObservableEvents_DataSourceInstanceStateChange* add_instance_state_changes();
-
-  bool has_all_data_sources_started() const { return _has_field_[2]; }
-  bool all_data_sources_started() const { return all_data_sources_started_; }
-  void set_all_data_sources_started(bool value) { all_data_sources_started_ = value; _has_field_.set(2); }
-
- private:
-  std::vector<ObservableEvents_DataSourceInstanceStateChange> instance_state_changes_;
-  bool all_data_sources_started_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT ObservableEvents_DataSourceInstanceStateChange : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kProducerNameFieldNumber = 1,
-    kDataSourceNameFieldNumber = 2,
-    kStateFieldNumber = 3,
-  };
-
-  ObservableEvents_DataSourceInstanceStateChange();
-  ~ObservableEvents_DataSourceInstanceStateChange() override;
-  ObservableEvents_DataSourceInstanceStateChange(ObservableEvents_DataSourceInstanceStateChange&&) noexcept;
-  ObservableEvents_DataSourceInstanceStateChange& operator=(ObservableEvents_DataSourceInstanceStateChange&&);
-  ObservableEvents_DataSourceInstanceStateChange(const ObservableEvents_DataSourceInstanceStateChange&);
-  ObservableEvents_DataSourceInstanceStateChange& operator=(const ObservableEvents_DataSourceInstanceStateChange&);
-  bool operator==(const ObservableEvents_DataSourceInstanceStateChange&) const;
-  bool operator!=(const ObservableEvents_DataSourceInstanceStateChange& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_producer_name() const { return _has_field_[1]; }
-  const std::string& producer_name() const { return producer_name_; }
-  void set_producer_name(const std::string& value) { producer_name_ = value; _has_field_.set(1); }
 
-  bool has_data_source_name() const { return _has_field_[2]; }
-  const std::string& data_source_name() const { return data_source_name_; }
-  void set_data_source_name(const std::string& value) { data_source_name_ = value; _has_field_.set(2); }
+OneofOptions::OneofOptions() = default;
+OneofOptions::~OneofOptions() = default;
+OneofOptions::OneofOptions(const OneofOptions&) = default;
+OneofOptions& OneofOptions::operator=(const OneofOptions&) = default;
+OneofOptions::OneofOptions(OneofOptions&&) noexcept = default;
+OneofOptions& OneofOptions::operator=(OneofOptions&&) = default;
 
-  bool has_state() const { return _has_field_[3]; }
-  ObservableEvents_DataSourceInstanceState state() const { return state_; }
-  void set_state(ObservableEvents_DataSourceInstanceState value) { state_ = value; _has_field_.set(3); }
+bool OneofOptions::operator==(const OneofOptions& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
+}
 
- private:
-  std::string producer_name_{};
-  std::string data_source_name_{};
-  ObservableEvents_DataSourceInstanceState state_{};
+bool OneofOptions::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-  std::bitset<4> _has_field_{};
-};
+std::string OneofOptions::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+std::vector<uint8_t> OneofOptions::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_OBSERVABLE_EVENTS_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/common/observable_events.gen.h"
+void OneofOptions::Serialize(::protozero::Message* msg) const {
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
 
-ObservableEvents::ObservableEvents() = default;
-ObservableEvents::~ObservableEvents() = default;
-ObservableEvents::ObservableEvents(const ObservableEvents&) = default;
-ObservableEvents& ObservableEvents::operator=(const ObservableEvents&) = default;
-ObservableEvents::ObservableEvents(ObservableEvents&&) noexcept = default;
-ObservableEvents& ObservableEvents::operator=(ObservableEvents&&) = default;
+EnumValueDescriptorProto::EnumValueDescriptorProto() = default;
+EnumValueDescriptorProto::~EnumValueDescriptorProto() = default;
+EnumValueDescriptorProto::EnumValueDescriptorProto(const EnumValueDescriptorProto&) = default;
+EnumValueDescriptorProto& EnumValueDescriptorProto::operator=(const EnumValueDescriptorProto&) = default;
+EnumValueDescriptorProto::EnumValueDescriptorProto(EnumValueDescriptorProto&&) noexcept = default;
+EnumValueDescriptorProto& EnumValueDescriptorProto::operator=(EnumValueDescriptorProto&&) = default;
 
-bool ObservableEvents::operator==(const ObservableEvents& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && instance_state_changes_ == other.instance_state_changes_
-   && all_data_sources_started_ == other.all_data_sources_started_;
+bool EnumValueDescriptorProto::operator==(const EnumValueDescriptorProto& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(number_, other.number_);
 }
 
-int ObservableEvents::instance_state_changes_size() const { return static_cast<int>(instance_state_changes_.size()); }
-void ObservableEvents::clear_instance_state_changes() { instance_state_changes_.clear(); }
-ObservableEvents_DataSourceInstanceStateChange* ObservableEvents::add_instance_state_changes() { instance_state_changes_.emplace_back(); return &instance_state_changes_.back(); }
-bool ObservableEvents::ParseFromArray(const void* raw, size_t size) {
-  instance_state_changes_.clear();
+bool EnumValueDescriptorProto::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -15075,12 +16082,11 @@ bool ObservableEvents::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* instance_state_changes */:
-        instance_state_changes_.emplace_back();
-        instance_state_changes_.back().ParseFromArray(field.data(), field.size());
+      case 1 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
         break;
-      case 2 /* all_data_sources_started */:
-        field.get(&all_data_sources_started_);
+      case 2 /* number */:
+        field.get(&number_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -15090,48 +16096,53 @@ bool ObservableEvents::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ObservableEvents::SerializeAsString() const {
+std::string EnumValueDescriptorProto::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ObservableEvents::SerializeAsArray() const {
+std::vector<uint8_t> EnumValueDescriptorProto::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ObservableEvents::Serialize(::protozero::Message* msg) const {
-  // Field 1: instance_state_changes
-  for (auto& it : instance_state_changes_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
+void EnumValueDescriptorProto::Serialize(::protozero::Message* msg) const {
+  // Field 1: name
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
   }
 
-  // Field 2: all_data_sources_started
+  // Field 2: number
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, all_data_sources_started_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, number_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-ObservableEvents_DataSourceInstanceStateChange::ObservableEvents_DataSourceInstanceStateChange() = default;
-ObservableEvents_DataSourceInstanceStateChange::~ObservableEvents_DataSourceInstanceStateChange() = default;
-ObservableEvents_DataSourceInstanceStateChange::ObservableEvents_DataSourceInstanceStateChange(const ObservableEvents_DataSourceInstanceStateChange&) = default;
-ObservableEvents_DataSourceInstanceStateChange& ObservableEvents_DataSourceInstanceStateChange::operator=(const ObservableEvents_DataSourceInstanceStateChange&) = default;
-ObservableEvents_DataSourceInstanceStateChange::ObservableEvents_DataSourceInstanceStateChange(ObservableEvents_DataSourceInstanceStateChange&&) noexcept = default;
-ObservableEvents_DataSourceInstanceStateChange& ObservableEvents_DataSourceInstanceStateChange::operator=(ObservableEvents_DataSourceInstanceStateChange&&) = default;
+EnumDescriptorProto::EnumDescriptorProto() = default;
+EnumDescriptorProto::~EnumDescriptorProto() = default;
+EnumDescriptorProto::EnumDescriptorProto(const EnumDescriptorProto&) = default;
+EnumDescriptorProto& EnumDescriptorProto::operator=(const EnumDescriptorProto&) = default;
+EnumDescriptorProto::EnumDescriptorProto(EnumDescriptorProto&&) noexcept = default;
+EnumDescriptorProto& EnumDescriptorProto::operator=(EnumDescriptorProto&&) = default;
 
-bool ObservableEvents_DataSourceInstanceStateChange::operator==(const ObservableEvents_DataSourceInstanceStateChange& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && producer_name_ == other.producer_name_
-   && data_source_name_ == other.data_source_name_
-   && state_ == other.state_;
+bool EnumDescriptorProto::operator==(const EnumDescriptorProto& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(value_, other.value_)
+   && ::protozero::internal::gen_helpers::EqualsField(reserved_name_, other.reserved_name_);
 }
 
-bool ObservableEvents_DataSourceInstanceStateChange::ParseFromArray(const void* raw, size_t size) {
+int EnumDescriptorProto::value_size() const { return static_cast<int>(value_.size()); }
+void EnumDescriptorProto::clear_value() { value_.clear(); }
+EnumValueDescriptorProto* EnumDescriptorProto::add_value() { value_.emplace_back(); return &value_.back(); }
+bool EnumDescriptorProto::ParseFromArray(const void* raw, size_t size) {
+  value_.clear();
+  reserved_name_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -15141,14 +16152,16 @@ bool ObservableEvents_DataSourceInstanceStateChange::ParseFromArray(const void*
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* producer_name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &producer_name_);
+      case 1 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
         break;
-      case 2 /* data_source_name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &data_source_name_);
+      case 2 /* value */:
+        value_.emplace_back();
+        value_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 3 /* state */:
-        field.get(&state_);
+      case 5 /* reserved_name */:
+        reserved_name_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &reserved_name_.back());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -15158,371 +16171,52 @@ bool ObservableEvents_DataSourceInstanceStateChange::ParseFromArray(const void*
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ObservableEvents_DataSourceInstanceStateChange::SerializeAsString() const {
+std::string EnumDescriptorProto::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ObservableEvents_DataSourceInstanceStateChange::SerializeAsArray() const {
+std::vector<uint8_t> EnumDescriptorProto::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ObservableEvents_DataSourceInstanceStateChange::Serialize(::protozero::Message* msg) const {
-  // Field 1: producer_name
+void EnumDescriptorProto::Serialize(::protozero::Message* msg) const {
+  // Field 1: name
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeString(1, producer_name_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
   }
 
-  // Field 2: data_source_name
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeString(2, data_source_name_, msg);
+  // Field 2: value
+  for (auto& it : value_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
   }
 
-  // Field 3: state
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, state_, msg);
+  // Field 5: reserved_name
+  for (auto& it : reserved_name_) {
+    ::protozero::internal::gen_helpers::SerializeString(5, it, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/common/perf_events.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/common/perf_events.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_PERF_EVENTS_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_PERF_EVENTS_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class PerfEvents;
-class PerfEvents_RawEvent;
-class PerfEvents_Tracepoint;
-class PerfEvents_Timebase;
-enum PerfEvents_Counter : int;
-enum PerfEvents_PerfClock : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum PerfEvents_Counter : int {
-  PerfEvents_Counter_UNKNOWN_COUNTER = 0,
-  PerfEvents_Counter_SW_CPU_CLOCK = 1,
-  PerfEvents_Counter_SW_PAGE_FAULTS = 2,
-  PerfEvents_Counter_SW_TASK_CLOCK = 3,
-  PerfEvents_Counter_SW_CONTEXT_SWITCHES = 4,
-  PerfEvents_Counter_SW_CPU_MIGRATIONS = 5,
-  PerfEvents_Counter_SW_PAGE_FAULTS_MIN = 6,
-  PerfEvents_Counter_SW_PAGE_FAULTS_MAJ = 7,
-  PerfEvents_Counter_SW_ALIGNMENT_FAULTS = 8,
-  PerfEvents_Counter_SW_EMULATION_FAULTS = 9,
-  PerfEvents_Counter_SW_DUMMY = 20,
-  PerfEvents_Counter_HW_CPU_CYCLES = 10,
-  PerfEvents_Counter_HW_INSTRUCTIONS = 11,
-  PerfEvents_Counter_HW_CACHE_REFERENCES = 12,
-  PerfEvents_Counter_HW_CACHE_MISSES = 13,
-  PerfEvents_Counter_HW_BRANCH_INSTRUCTIONS = 14,
-  PerfEvents_Counter_HW_BRANCH_MISSES = 15,
-  PerfEvents_Counter_HW_BUS_CYCLES = 16,
-  PerfEvents_Counter_HW_STALLED_CYCLES_FRONTEND = 17,
-  PerfEvents_Counter_HW_STALLED_CYCLES_BACKEND = 18,
-  PerfEvents_Counter_HW_REF_CPU_CYCLES = 19,
-};
-enum PerfEvents_PerfClock : int {
-  PerfEvents_PerfClock_UNKNOWN_PERF_CLOCK = 0,
-  PerfEvents_PerfClock_PERF_CLOCK_REALTIME = 1,
-  PerfEvents_PerfClock_PERF_CLOCK_MONOTONIC = 2,
-  PerfEvents_PerfClock_PERF_CLOCK_MONOTONIC_RAW = 3,
-  PerfEvents_PerfClock_PERF_CLOCK_BOOTTIME = 4,
-};
-
-class PERFETTO_EXPORT_COMPONENT PerfEvents : public ::protozero::CppMessageObj {
- public:
-  using Timebase = PerfEvents_Timebase;
-  using Tracepoint = PerfEvents_Tracepoint;
-  using RawEvent = PerfEvents_RawEvent;
-  using Counter = PerfEvents_Counter;
-  static constexpr auto UNKNOWN_COUNTER = PerfEvents_Counter_UNKNOWN_COUNTER;
-  static constexpr auto SW_CPU_CLOCK = PerfEvents_Counter_SW_CPU_CLOCK;
-  static constexpr auto SW_PAGE_FAULTS = PerfEvents_Counter_SW_PAGE_FAULTS;
-  static constexpr auto SW_TASK_CLOCK = PerfEvents_Counter_SW_TASK_CLOCK;
-  static constexpr auto SW_CONTEXT_SWITCHES = PerfEvents_Counter_SW_CONTEXT_SWITCHES;
-  static constexpr auto SW_CPU_MIGRATIONS = PerfEvents_Counter_SW_CPU_MIGRATIONS;
-  static constexpr auto SW_PAGE_FAULTS_MIN = PerfEvents_Counter_SW_PAGE_FAULTS_MIN;
-  static constexpr auto SW_PAGE_FAULTS_MAJ = PerfEvents_Counter_SW_PAGE_FAULTS_MAJ;
-  static constexpr auto SW_ALIGNMENT_FAULTS = PerfEvents_Counter_SW_ALIGNMENT_FAULTS;
-  static constexpr auto SW_EMULATION_FAULTS = PerfEvents_Counter_SW_EMULATION_FAULTS;
-  static constexpr auto SW_DUMMY = PerfEvents_Counter_SW_DUMMY;
-  static constexpr auto HW_CPU_CYCLES = PerfEvents_Counter_HW_CPU_CYCLES;
-  static constexpr auto HW_INSTRUCTIONS = PerfEvents_Counter_HW_INSTRUCTIONS;
-  static constexpr auto HW_CACHE_REFERENCES = PerfEvents_Counter_HW_CACHE_REFERENCES;
-  static constexpr auto HW_CACHE_MISSES = PerfEvents_Counter_HW_CACHE_MISSES;
-  static constexpr auto HW_BRANCH_INSTRUCTIONS = PerfEvents_Counter_HW_BRANCH_INSTRUCTIONS;
-  static constexpr auto HW_BRANCH_MISSES = PerfEvents_Counter_HW_BRANCH_MISSES;
-  static constexpr auto HW_BUS_CYCLES = PerfEvents_Counter_HW_BUS_CYCLES;
-  static constexpr auto HW_STALLED_CYCLES_FRONTEND = PerfEvents_Counter_HW_STALLED_CYCLES_FRONTEND;
-  static constexpr auto HW_STALLED_CYCLES_BACKEND = PerfEvents_Counter_HW_STALLED_CYCLES_BACKEND;
-  static constexpr auto HW_REF_CPU_CYCLES = PerfEvents_Counter_HW_REF_CPU_CYCLES;
-  static constexpr auto Counter_MIN = PerfEvents_Counter_UNKNOWN_COUNTER;
-  static constexpr auto Counter_MAX = PerfEvents_Counter_SW_DUMMY;
-  using PerfClock = PerfEvents_PerfClock;
-  static constexpr auto UNKNOWN_PERF_CLOCK = PerfEvents_PerfClock_UNKNOWN_PERF_CLOCK;
-  static constexpr auto PERF_CLOCK_REALTIME = PerfEvents_PerfClock_PERF_CLOCK_REALTIME;
-  static constexpr auto PERF_CLOCK_MONOTONIC = PerfEvents_PerfClock_PERF_CLOCK_MONOTONIC;
-  static constexpr auto PERF_CLOCK_MONOTONIC_RAW = PerfEvents_PerfClock_PERF_CLOCK_MONOTONIC_RAW;
-  static constexpr auto PERF_CLOCK_BOOTTIME = PerfEvents_PerfClock_PERF_CLOCK_BOOTTIME;
-  static constexpr auto PerfClock_MIN = PerfEvents_PerfClock_UNKNOWN_PERF_CLOCK;
-  static constexpr auto PerfClock_MAX = PerfEvents_PerfClock_PERF_CLOCK_BOOTTIME;
-  enum FieldNumbers {
-  };
-
-  PerfEvents();
-  ~PerfEvents() override;
-  PerfEvents(PerfEvents&&) noexcept;
-  PerfEvents& operator=(PerfEvents&&);
-  PerfEvents(const PerfEvents&);
-  PerfEvents& operator=(const PerfEvents&);
-  bool operator==(const PerfEvents&) const;
-  bool operator!=(const PerfEvents& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT PerfEvents_RawEvent : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kTypeFieldNumber = 1,
-    kConfigFieldNumber = 2,
-    kConfig1FieldNumber = 3,
-    kConfig2FieldNumber = 4,
-  };
-
-  PerfEvents_RawEvent();
-  ~PerfEvents_RawEvent() override;
-  PerfEvents_RawEvent(PerfEvents_RawEvent&&) noexcept;
-  PerfEvents_RawEvent& operator=(PerfEvents_RawEvent&&);
-  PerfEvents_RawEvent(const PerfEvents_RawEvent&);
-  PerfEvents_RawEvent& operator=(const PerfEvents_RawEvent&);
-  bool operator==(const PerfEvents_RawEvent&) const;
-  bool operator!=(const PerfEvents_RawEvent& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_type() const { return _has_field_[1]; }
-  uint32_t type() const { return type_; }
-  void set_type(uint32_t value) { type_ = value; _has_field_.set(1); }
-
-  bool has_config() const { return _has_field_[2]; }
-  uint64_t config() const { return config_; }
-  void set_config(uint64_t value) { config_ = value; _has_field_.set(2); }
-
-  bool has_config1() const { return _has_field_[3]; }
-  uint64_t config1() const { return config1_; }
-  void set_config1(uint64_t value) { config1_ = value; _has_field_.set(3); }
-
-  bool has_config2() const { return _has_field_[4]; }
-  uint64_t config2() const { return config2_; }
-  void set_config2(uint64_t value) { config2_ = value; _has_field_.set(4); }
-
- private:
-  uint32_t type_{};
-  uint64_t config_{};
-  uint64_t config1_{};
-  uint64_t config2_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<5> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT PerfEvents_Tracepoint : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kNameFieldNumber = 1,
-    kFilterFieldNumber = 2,
-  };
-
-  PerfEvents_Tracepoint();
-  ~PerfEvents_Tracepoint() override;
-  PerfEvents_Tracepoint(PerfEvents_Tracepoint&&) noexcept;
-  PerfEvents_Tracepoint& operator=(PerfEvents_Tracepoint&&);
-  PerfEvents_Tracepoint(const PerfEvents_Tracepoint&);
-  PerfEvents_Tracepoint& operator=(const PerfEvents_Tracepoint&);
-  bool operator==(const PerfEvents_Tracepoint&) const;
-  bool operator!=(const PerfEvents_Tracepoint& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_name() const { return _has_field_[1]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
-
-  bool has_filter() const { return _has_field_[2]; }
-  const std::string& filter() const { return filter_; }
-  void set_filter(const std::string& value) { filter_ = value; _has_field_.set(2); }
-
- private:
-  std::string name_{};
-  std::string filter_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT PerfEvents_Timebase : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kFrequencyFieldNumber = 2,
-    kPeriodFieldNumber = 1,
-    kCounterFieldNumber = 4,
-    kTracepointFieldNumber = 3,
-    kRawEventFieldNumber = 5,
-    kTimestampClockFieldNumber = 11,
-    kNameFieldNumber = 10,
-  };
-
-  PerfEvents_Timebase();
-  ~PerfEvents_Timebase() override;
-  PerfEvents_Timebase(PerfEvents_Timebase&&) noexcept;
-  PerfEvents_Timebase& operator=(PerfEvents_Timebase&&);
-  PerfEvents_Timebase(const PerfEvents_Timebase&);
-  PerfEvents_Timebase& operator=(const PerfEvents_Timebase&);
-  bool operator==(const PerfEvents_Timebase&) const;
-  bool operator!=(const PerfEvents_Timebase& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_frequency() const { return _has_field_[2]; }
-  uint64_t frequency() const { return frequency_; }
-  void set_frequency(uint64_t value) { frequency_ = value; _has_field_.set(2); }
-
-  bool has_period() const { return _has_field_[1]; }
-  uint64_t period() const { return period_; }
-  void set_period(uint64_t value) { period_ = value; _has_field_.set(1); }
-
-  bool has_counter() const { return _has_field_[4]; }
-  PerfEvents_Counter counter() const { return counter_; }
-  void set_counter(PerfEvents_Counter value) { counter_ = value; _has_field_.set(4); }
-
-  bool has_tracepoint() const { return _has_field_[3]; }
-  const PerfEvents_Tracepoint& tracepoint() const { return *tracepoint_; }
-  PerfEvents_Tracepoint* mutable_tracepoint() { _has_field_.set(3); return tracepoint_.get(); }
-
-  bool has_raw_event() const { return _has_field_[5]; }
-  const PerfEvents_RawEvent& raw_event() const { return *raw_event_; }
-  PerfEvents_RawEvent* mutable_raw_event() { _has_field_.set(5); return raw_event_.get(); }
-
-  bool has_timestamp_clock() const { return _has_field_[11]; }
-  PerfEvents_PerfClock timestamp_clock() const { return timestamp_clock_; }
-  void set_timestamp_clock(PerfEvents_PerfClock value) { timestamp_clock_ = value; _has_field_.set(11); }
-
-  bool has_name() const { return _has_field_[10]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(10); }
-
- private:
-  uint64_t frequency_{};
-  uint64_t period_{};
-  PerfEvents_Counter counter_{};
-  ::protozero::CopyablePtr<PerfEvents_Tracepoint> tracepoint_;
-  ::protozero::CopyablePtr<PerfEvents_RawEvent> raw_event_;
-  PerfEvents_PerfClock timestamp_clock_{};
-  std::string name_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<12> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_PERF_EVENTS_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/common/perf_events.gen.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
 
-PerfEvents::PerfEvents() = default;
-PerfEvents::~PerfEvents() = default;
-PerfEvents::PerfEvents(const PerfEvents&) = default;
-PerfEvents& PerfEvents::operator=(const PerfEvents&) = default;
-PerfEvents::PerfEvents(PerfEvents&&) noexcept = default;
-PerfEvents& PerfEvents::operator=(PerfEvents&&) = default;
+OneofDescriptorProto::OneofDescriptorProto() = default;
+OneofDescriptorProto::~OneofDescriptorProto() = default;
+OneofDescriptorProto::OneofDescriptorProto(const OneofDescriptorProto&) = default;
+OneofDescriptorProto& OneofDescriptorProto::operator=(const OneofDescriptorProto&) = default;
+OneofDescriptorProto::OneofDescriptorProto(OneofDescriptorProto&&) noexcept = default;
+OneofDescriptorProto& OneofDescriptorProto::operator=(OneofDescriptorProto&&) = default;
 
-bool PerfEvents::operator==(const PerfEvents& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+bool OneofDescriptorProto::operator==(const OneofDescriptorProto& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(options_, other.options_);
 }
 
-bool PerfEvents::ParseFromArray(const void* raw, size_t size) {
+bool OneofDescriptorProto::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -15532,6 +16226,12 @@ bool PerfEvents::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
+      case 1 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+        break;
+      case 2 /* options */:
+        (*options_).ParseFromArray(field.data(), field.size());
+        break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
         break;
@@ -15540,39 +16240,54 @@ bool PerfEvents::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string PerfEvents::SerializeAsString() const {
+std::string OneofDescriptorProto::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> PerfEvents::SerializeAsArray() const {
+std::vector<uint8_t> OneofDescriptorProto::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void PerfEvents::Serialize(::protozero::Message* msg) const {
+void OneofDescriptorProto::Serialize(::protozero::Message* msg) const {
+  // Field 1: name
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
+  }
+
+  // Field 2: options
+  if (_has_field_[2]) {
+    (*options_).Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
+  }
+
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-PerfEvents_RawEvent::PerfEvents_RawEvent() = default;
-PerfEvents_RawEvent::~PerfEvents_RawEvent() = default;
-PerfEvents_RawEvent::PerfEvents_RawEvent(const PerfEvents_RawEvent&) = default;
-PerfEvents_RawEvent& PerfEvents_RawEvent::operator=(const PerfEvents_RawEvent&) = default;
-PerfEvents_RawEvent::PerfEvents_RawEvent(PerfEvents_RawEvent&&) noexcept = default;
-PerfEvents_RawEvent& PerfEvents_RawEvent::operator=(PerfEvents_RawEvent&&) = default;
+FieldDescriptorProto::FieldDescriptorProto() = default;
+FieldDescriptorProto::~FieldDescriptorProto() = default;
+FieldDescriptorProto::FieldDescriptorProto(const FieldDescriptorProto&) = default;
+FieldDescriptorProto& FieldDescriptorProto::operator=(const FieldDescriptorProto&) = default;
+FieldDescriptorProto::FieldDescriptorProto(FieldDescriptorProto&&) noexcept = default;
+FieldDescriptorProto& FieldDescriptorProto::operator=(FieldDescriptorProto&&) = default;
 
-bool PerfEvents_RawEvent::operator==(const PerfEvents_RawEvent& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && type_ == other.type_
-   && config_ == other.config_
-   && config1_ == other.config1_
-   && config2_ == other.config2_;
+bool FieldDescriptorProto::operator==(const FieldDescriptorProto& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(number_, other.number_)
+   && ::protozero::internal::gen_helpers::EqualsField(label_, other.label_)
+   && ::protozero::internal::gen_helpers::EqualsField(type_, other.type_)
+   && ::protozero::internal::gen_helpers::EqualsField(type_name_, other.type_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(extendee_, other.extendee_)
+   && ::protozero::internal::gen_helpers::EqualsField(default_value_, other.default_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(options_, other.options_)
+   && ::protozero::internal::gen_helpers::EqualsField(oneof_index_, other.oneof_index_);
 }
 
-bool PerfEvents_RawEvent::ParseFromArray(const void* raw, size_t size) {
+bool FieldDescriptorProto::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -15582,17 +16297,32 @@ bool PerfEvents_RawEvent::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* type */:
+      case 1 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+        break;
+      case 3 /* number */:
+        field.get(&number_);
+        break;
+      case 4 /* label */:
+        field.get(&label_);
+        break;
+      case 5 /* type */:
         field.get(&type_);
         break;
-      case 2 /* config */:
-        field.get(&config_);
+      case 6 /* type_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &type_name_);
         break;
-      case 3 /* config1 */:
-        field.get(&config1_);
+      case 2 /* extendee */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &extendee_);
         break;
-      case 4 /* config2 */:
-        field.get(&config2_);
+      case 7 /* default_value */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &default_value_);
+        break;
+      case 8 /* options */:
+        (*options_).ParseFromArray(field.data(), field.size());
+        break;
+      case 9 /* oneof_index */:
+        field.get(&oneof_index_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -15602,57 +16332,86 @@ bool PerfEvents_RawEvent::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string PerfEvents_RawEvent::SerializeAsString() const {
+std::string FieldDescriptorProto::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> PerfEvents_RawEvent::SerializeAsArray() const {
+std::vector<uint8_t> FieldDescriptorProto::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void PerfEvents_RawEvent::Serialize(::protozero::Message* msg) const {
-  // Field 1: type
+void FieldDescriptorProto::Serialize(::protozero::Message* msg) const {
+  // Field 1: name
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, type_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
   }
 
-  // Field 2: config
+  // Field 3: number
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, number_, msg);
+  }
+
+  // Field 4: label
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, label_, msg);
+  }
+
+  // Field 5: type
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, type_, msg);
+  }
+
+  // Field 6: type_name
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeString(6, type_name_, msg);
+  }
+
+  // Field 2: extendee
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, config_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(2, extendee_, msg);
   }
 
-  // Field 3: config1
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, config1_, msg);
+  // Field 7: default_value
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeString(7, default_value_, msg);
   }
 
-  // Field 4: config2
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, config2_, msg);
+  // Field 8: options
+  if (_has_field_[8]) {
+    (*options_).Serialize(msg->BeginNestedMessage<::protozero::Message>(8));
+  }
+
+  // Field 9: oneof_index
+  if (_has_field_[9]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(9, oneof_index_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-PerfEvents_Tracepoint::PerfEvents_Tracepoint() = default;
-PerfEvents_Tracepoint::~PerfEvents_Tracepoint() = default;
-PerfEvents_Tracepoint::PerfEvents_Tracepoint(const PerfEvents_Tracepoint&) = default;
-PerfEvents_Tracepoint& PerfEvents_Tracepoint::operator=(const PerfEvents_Tracepoint&) = default;
-PerfEvents_Tracepoint::PerfEvents_Tracepoint(PerfEvents_Tracepoint&&) noexcept = default;
-PerfEvents_Tracepoint& PerfEvents_Tracepoint::operator=(PerfEvents_Tracepoint&&) = default;
+FieldOptions::FieldOptions() = default;
+FieldOptions::~FieldOptions() = default;
+FieldOptions::FieldOptions(const FieldOptions&) = default;
+FieldOptions& FieldOptions::operator=(const FieldOptions&) = default;
+FieldOptions::FieldOptions(FieldOptions&&) noexcept = default;
+FieldOptions& FieldOptions::operator=(FieldOptions&&) = default;
 
-bool PerfEvents_Tracepoint::operator==(const PerfEvents_Tracepoint& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && name_ == other.name_
-   && filter_ == other.filter_;
+bool FieldOptions::operator==(const FieldOptions& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(packed_, other.packed_)
+   && ::protozero::internal::gen_helpers::EqualsField(uninterpreted_option_, other.uninterpreted_option_);
 }
 
-bool PerfEvents_Tracepoint::ParseFromArray(const void* raw, size_t size) {
+int FieldOptions::uninterpreted_option_size() const { return static_cast<int>(uninterpreted_option_.size()); }
+void FieldOptions::clear_uninterpreted_option() { uninterpreted_option_.clear(); }
+UninterpretedOption* FieldOptions::add_uninterpreted_option() { uninterpreted_option_.emplace_back(); return &uninterpreted_option_.back(); }
+bool FieldOptions::ParseFromArray(const void* raw, size_t size) {
+  uninterpreted_option_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -15662,11 +16421,12 @@ bool PerfEvents_Tracepoint::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+      case 2 /* packed */:
+        field.get(&packed_);
         break;
-      case 2 /* filter */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &filter_);
+      case 999 /* uninterpreted_option */:
+        uninterpreted_option_.emplace_back();
+        uninterpreted_option_.back().ParseFromArray(field.data(), field.size());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -15676,52 +16436,56 @@ bool PerfEvents_Tracepoint::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string PerfEvents_Tracepoint::SerializeAsString() const {
+std::string FieldOptions::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> PerfEvents_Tracepoint::SerializeAsArray() const {
+std::vector<uint8_t> FieldOptions::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void PerfEvents_Tracepoint::Serialize(::protozero::Message* msg) const {
-  // Field 1: name
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
+void FieldOptions::Serialize(::protozero::Message* msg) const {
+  // Field 2: packed
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, packed_, msg);
   }
 
-  // Field 2: filter
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeString(2, filter_, msg);
+  // Field 999: uninterpreted_option
+  for (auto& it : uninterpreted_option_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(999));
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-PerfEvents_Timebase::PerfEvents_Timebase() = default;
-PerfEvents_Timebase::~PerfEvents_Timebase() = default;
-PerfEvents_Timebase::PerfEvents_Timebase(const PerfEvents_Timebase&) = default;
-PerfEvents_Timebase& PerfEvents_Timebase::operator=(const PerfEvents_Timebase&) = default;
-PerfEvents_Timebase::PerfEvents_Timebase(PerfEvents_Timebase&&) noexcept = default;
-PerfEvents_Timebase& PerfEvents_Timebase::operator=(PerfEvents_Timebase&&) = default;
+UninterpretedOption::UninterpretedOption() = default;
+UninterpretedOption::~UninterpretedOption() = default;
+UninterpretedOption::UninterpretedOption(const UninterpretedOption&) = default;
+UninterpretedOption& UninterpretedOption::operator=(const UninterpretedOption&) = default;
+UninterpretedOption::UninterpretedOption(UninterpretedOption&&) noexcept = default;
+UninterpretedOption& UninterpretedOption::operator=(UninterpretedOption&&) = default;
 
-bool PerfEvents_Timebase::operator==(const PerfEvents_Timebase& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && frequency_ == other.frequency_
-   && period_ == other.period_
-   && counter_ == other.counter_
-   && tracepoint_ == other.tracepoint_
-   && raw_event_ == other.raw_event_
-   && timestamp_clock_ == other.timestamp_clock_
-   && name_ == other.name_;
+bool UninterpretedOption::operator==(const UninterpretedOption& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(identifier_value_, other.identifier_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(positive_int_value_, other.positive_int_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(negative_int_value_, other.negative_int_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(double_value_, other.double_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(string_value_, other.string_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(aggregate_value_, other.aggregate_value_);
 }
 
-bool PerfEvents_Timebase::ParseFromArray(const void* raw, size_t size) {
+int UninterpretedOption::name_size() const { return static_cast<int>(name_.size()); }
+void UninterpretedOption::clear_name() { name_.clear(); }
+UninterpretedOption_NamePart* UninterpretedOption::add_name() { name_.emplace_back(); return &name_.back(); }
+bool UninterpretedOption::ParseFromArray(const void* raw, size_t size) {
+  name_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -15731,26 +16495,27 @@ bool PerfEvents_Timebase::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 2 /* frequency */:
-        field.get(&frequency_);
+      case 2 /* name */:
+        name_.emplace_back();
+        name_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 1 /* period */:
-        field.get(&period_);
+      case 3 /* identifier_value */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &identifier_value_);
         break;
-      case 4 /* counter */:
-        field.get(&counter_);
+      case 4 /* positive_int_value */:
+        field.get(&positive_int_value_);
         break;
-      case 3 /* tracepoint */:
-        (*tracepoint_).ParseFromArray(field.data(), field.size());
+      case 5 /* negative_int_value */:
+        field.get(&negative_int_value_);
         break;
-      case 5 /* raw_event */:
-        (*raw_event_).ParseFromArray(field.data(), field.size());
+      case 6 /* double_value */:
+        field.get(&double_value_);
         break;
-      case 11 /* timestamp_clock */:
-        field.get(&timestamp_clock_);
+      case 7 /* string_value */:
+        field.get(&string_value_);
         break;
-      case 10 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+      case 8 /* aggregate_value */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &aggregate_value_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -15760,704 +16525,167 @@ bool PerfEvents_Timebase::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string PerfEvents_Timebase::SerializeAsString() const {
+std::string UninterpretedOption::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> PerfEvents_Timebase::SerializeAsArray() const {
+std::vector<uint8_t> UninterpretedOption::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void PerfEvents_Timebase::Serialize(::protozero::Message* msg) const {
-  // Field 2: frequency
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, frequency_, msg);
+void UninterpretedOption::Serialize(::protozero::Message* msg) const {
+  // Field 2: name
+  for (auto& it : name_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
   }
 
-  // Field 1: period
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, period_, msg);
+  // Field 3: identifier_value
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeString(3, identifier_value_, msg);
   }
 
-  // Field 4: counter
+  // Field 4: positive_int_value
   if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, counter_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, positive_int_value_, msg);
   }
 
-  // Field 3: tracepoint
-  if (_has_field_[3]) {
-    (*tracepoint_).Serialize(msg->BeginNestedMessage<::protozero::Message>(3));
+  // Field 5: negative_int_value
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, negative_int_value_, msg);
   }
 
-  // Field 5: raw_event
-  if (_has_field_[5]) {
-    (*raw_event_).Serialize(msg->BeginNestedMessage<::protozero::Message>(5));
+  // Field 6: double_value
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeFixed(6, double_value_, msg);
   }
 
-  // Field 11: timestamp_clock
-  if (_has_field_[11]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(11, timestamp_clock_, msg);
+  // Field 7: string_value
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeString(7, string_value_, msg);
   }
 
-  // Field 10: name
-  if (_has_field_[10]) {
-    ::protozero::internal::gen_helpers::SerializeString(10, name_, msg);
+  // Field 8: aggregate_value
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeString(8, aggregate_value_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/common/sys_stats_counters.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/common/sys_stats_counters.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_SYS_STATS_COUNTERS_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_SYS_STATS_COUNTERS_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum MeminfoCounters : int;
-enum VmstatCounters : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum MeminfoCounters : int {
-  MEMINFO_UNSPECIFIED = 0,
-  MEMINFO_MEM_TOTAL = 1,
-  MEMINFO_MEM_FREE = 2,
-  MEMINFO_MEM_AVAILABLE = 3,
-  MEMINFO_BUFFERS = 4,
-  MEMINFO_CACHED = 5,
-  MEMINFO_SWAP_CACHED = 6,
-  MEMINFO_ACTIVE = 7,
-  MEMINFO_INACTIVE = 8,
-  MEMINFO_ACTIVE_ANON = 9,
-  MEMINFO_INACTIVE_ANON = 10,
-  MEMINFO_ACTIVE_FILE = 11,
-  MEMINFO_INACTIVE_FILE = 12,
-  MEMINFO_UNEVICTABLE = 13,
-  MEMINFO_MLOCKED = 14,
-  MEMINFO_SWAP_TOTAL = 15,
-  MEMINFO_SWAP_FREE = 16,
-  MEMINFO_DIRTY = 17,
-  MEMINFO_WRITEBACK = 18,
-  MEMINFO_ANON_PAGES = 19,
-  MEMINFO_MAPPED = 20,
-  MEMINFO_SHMEM = 21,
-  MEMINFO_SLAB = 22,
-  MEMINFO_SLAB_RECLAIMABLE = 23,
-  MEMINFO_SLAB_UNRECLAIMABLE = 24,
-  MEMINFO_KERNEL_STACK = 25,
-  MEMINFO_PAGE_TABLES = 26,
-  MEMINFO_COMMIT_LIMIT = 27,
-  MEMINFO_COMMITED_AS = 28,
-  MEMINFO_VMALLOC_TOTAL = 29,
-  MEMINFO_VMALLOC_USED = 30,
-  MEMINFO_VMALLOC_CHUNK = 31,
-  MEMINFO_CMA_TOTAL = 32,
-  MEMINFO_CMA_FREE = 33,
-};
-enum VmstatCounters : int {
-  VMSTAT_UNSPECIFIED = 0,
-  VMSTAT_NR_FREE_PAGES = 1,
-  VMSTAT_NR_ALLOC_BATCH = 2,
-  VMSTAT_NR_INACTIVE_ANON = 3,
-  VMSTAT_NR_ACTIVE_ANON = 4,
-  VMSTAT_NR_INACTIVE_FILE = 5,
-  VMSTAT_NR_ACTIVE_FILE = 6,
-  VMSTAT_NR_UNEVICTABLE = 7,
-  VMSTAT_NR_MLOCK = 8,
-  VMSTAT_NR_ANON_PAGES = 9,
-  VMSTAT_NR_MAPPED = 10,
-  VMSTAT_NR_FILE_PAGES = 11,
-  VMSTAT_NR_DIRTY = 12,
-  VMSTAT_NR_WRITEBACK = 13,
-  VMSTAT_NR_SLAB_RECLAIMABLE = 14,
-  VMSTAT_NR_SLAB_UNRECLAIMABLE = 15,
-  VMSTAT_NR_PAGE_TABLE_PAGES = 16,
-  VMSTAT_NR_KERNEL_STACK = 17,
-  VMSTAT_NR_OVERHEAD = 18,
-  VMSTAT_NR_UNSTABLE = 19,
-  VMSTAT_NR_BOUNCE = 20,
-  VMSTAT_NR_VMSCAN_WRITE = 21,
-  VMSTAT_NR_VMSCAN_IMMEDIATE_RECLAIM = 22,
-  VMSTAT_NR_WRITEBACK_TEMP = 23,
-  VMSTAT_NR_ISOLATED_ANON = 24,
-  VMSTAT_NR_ISOLATED_FILE = 25,
-  VMSTAT_NR_SHMEM = 26,
-  VMSTAT_NR_DIRTIED = 27,
-  VMSTAT_NR_WRITTEN = 28,
-  VMSTAT_NR_PAGES_SCANNED = 29,
-  VMSTAT_WORKINGSET_REFAULT = 30,
-  VMSTAT_WORKINGSET_ACTIVATE = 31,
-  VMSTAT_WORKINGSET_NODERECLAIM = 32,
-  VMSTAT_NR_ANON_TRANSPARENT_HUGEPAGES = 33,
-  VMSTAT_NR_FREE_CMA = 34,
-  VMSTAT_NR_SWAPCACHE = 35,
-  VMSTAT_NR_DIRTY_THRESHOLD = 36,
-  VMSTAT_NR_DIRTY_BACKGROUND_THRESHOLD = 37,
-  VMSTAT_PGPGIN = 38,
-  VMSTAT_PGPGOUT = 39,
-  VMSTAT_PGPGOUTCLEAN = 40,
-  VMSTAT_PSWPIN = 41,
-  VMSTAT_PSWPOUT = 42,
-  VMSTAT_PGALLOC_DMA = 43,
-  VMSTAT_PGALLOC_NORMAL = 44,
-  VMSTAT_PGALLOC_MOVABLE = 45,
-  VMSTAT_PGFREE = 46,
-  VMSTAT_PGACTIVATE = 47,
-  VMSTAT_PGDEACTIVATE = 48,
-  VMSTAT_PGFAULT = 49,
-  VMSTAT_PGMAJFAULT = 50,
-  VMSTAT_PGREFILL_DMA = 51,
-  VMSTAT_PGREFILL_NORMAL = 52,
-  VMSTAT_PGREFILL_MOVABLE = 53,
-  VMSTAT_PGSTEAL_KSWAPD_DMA = 54,
-  VMSTAT_PGSTEAL_KSWAPD_NORMAL = 55,
-  VMSTAT_PGSTEAL_KSWAPD_MOVABLE = 56,
-  VMSTAT_PGSTEAL_DIRECT_DMA = 57,
-  VMSTAT_PGSTEAL_DIRECT_NORMAL = 58,
-  VMSTAT_PGSTEAL_DIRECT_MOVABLE = 59,
-  VMSTAT_PGSCAN_KSWAPD_DMA = 60,
-  VMSTAT_PGSCAN_KSWAPD_NORMAL = 61,
-  VMSTAT_PGSCAN_KSWAPD_MOVABLE = 62,
-  VMSTAT_PGSCAN_DIRECT_DMA = 63,
-  VMSTAT_PGSCAN_DIRECT_NORMAL = 64,
-  VMSTAT_PGSCAN_DIRECT_MOVABLE = 65,
-  VMSTAT_PGSCAN_DIRECT_THROTTLE = 66,
-  VMSTAT_PGINODESTEAL = 67,
-  VMSTAT_SLABS_SCANNED = 68,
-  VMSTAT_KSWAPD_INODESTEAL = 69,
-  VMSTAT_KSWAPD_LOW_WMARK_HIT_QUICKLY = 70,
-  VMSTAT_KSWAPD_HIGH_WMARK_HIT_QUICKLY = 71,
-  VMSTAT_PAGEOUTRUN = 72,
-  VMSTAT_ALLOCSTALL = 73,
-  VMSTAT_PGROTATED = 74,
-  VMSTAT_DROP_PAGECACHE = 75,
-  VMSTAT_DROP_SLAB = 76,
-  VMSTAT_PGMIGRATE_SUCCESS = 77,
-  VMSTAT_PGMIGRATE_FAIL = 78,
-  VMSTAT_COMPACT_MIGRATE_SCANNED = 79,
-  VMSTAT_COMPACT_FREE_SCANNED = 80,
-  VMSTAT_COMPACT_ISOLATED = 81,
-  VMSTAT_COMPACT_STALL = 82,
-  VMSTAT_COMPACT_FAIL = 83,
-  VMSTAT_COMPACT_SUCCESS = 84,
-  VMSTAT_COMPACT_DAEMON_WAKE = 85,
-  VMSTAT_UNEVICTABLE_PGS_CULLED = 86,
-  VMSTAT_UNEVICTABLE_PGS_SCANNED = 87,
-  VMSTAT_UNEVICTABLE_PGS_RESCUED = 88,
-  VMSTAT_UNEVICTABLE_PGS_MLOCKED = 89,
-  VMSTAT_UNEVICTABLE_PGS_MUNLOCKED = 90,
-  VMSTAT_UNEVICTABLE_PGS_CLEARED = 91,
-  VMSTAT_UNEVICTABLE_PGS_STRANDED = 92,
-  VMSTAT_NR_ZSPAGES = 93,
-  VMSTAT_NR_ION_HEAP = 94,
-  VMSTAT_NR_GPU_HEAP = 95,
-  VMSTAT_ALLOCSTALL_DMA = 96,
-  VMSTAT_ALLOCSTALL_MOVABLE = 97,
-  VMSTAT_ALLOCSTALL_NORMAL = 98,
-  VMSTAT_COMPACT_DAEMON_FREE_SCANNED = 99,
-  VMSTAT_COMPACT_DAEMON_MIGRATE_SCANNED = 100,
-  VMSTAT_NR_FASTRPC = 101,
-  VMSTAT_NR_INDIRECTLY_RECLAIMABLE = 102,
-  VMSTAT_NR_ION_HEAP_POOL = 103,
-  VMSTAT_NR_KERNEL_MISC_RECLAIMABLE = 104,
-  VMSTAT_NR_SHADOW_CALL_STACK_BYTES = 105,
-  VMSTAT_NR_SHMEM_HUGEPAGES = 106,
-  VMSTAT_NR_SHMEM_PMDMAPPED = 107,
-  VMSTAT_NR_UNRECLAIMABLE_PAGES = 108,
-  VMSTAT_NR_ZONE_ACTIVE_ANON = 109,
-  VMSTAT_NR_ZONE_ACTIVE_FILE = 110,
-  VMSTAT_NR_ZONE_INACTIVE_ANON = 111,
-  VMSTAT_NR_ZONE_INACTIVE_FILE = 112,
-  VMSTAT_NR_ZONE_UNEVICTABLE = 113,
-  VMSTAT_NR_ZONE_WRITE_PENDING = 114,
-  VMSTAT_OOM_KILL = 115,
-  VMSTAT_PGLAZYFREE = 116,
-  VMSTAT_PGLAZYFREED = 117,
-  VMSTAT_PGREFILL = 118,
-  VMSTAT_PGSCAN_DIRECT = 119,
-  VMSTAT_PGSCAN_KSWAPD = 120,
-  VMSTAT_PGSKIP_DMA = 121,
-  VMSTAT_PGSKIP_MOVABLE = 122,
-  VMSTAT_PGSKIP_NORMAL = 123,
-  VMSTAT_PGSTEAL_DIRECT = 124,
-  VMSTAT_PGSTEAL_KSWAPD = 125,
-  VMSTAT_SWAP_RA = 126,
-  VMSTAT_SWAP_RA_HIT = 127,
-  VMSTAT_WORKINGSET_RESTORE = 128,
-};
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_SYS_STATS_COUNTERS_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/common/sys_stats_counters.gen.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/common/trace_stats.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/common/trace_stats.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_TRACE_STATS_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_TRACE_STATS_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class TraceStats;
-class TraceStats_FilterStats;
-class TraceStats_BufferStats;
-enum TraceStats_FinalFlushOutcome : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum TraceStats_FinalFlushOutcome : int {
-  TraceStats_FinalFlushOutcome_FINAL_FLUSH_UNSPECIFIED = 0,
-  TraceStats_FinalFlushOutcome_FINAL_FLUSH_SUCCEEDED = 1,
-  TraceStats_FinalFlushOutcome_FINAL_FLUSH_FAILED = 2,
-};
-
-class PERFETTO_EXPORT_COMPONENT TraceStats : public ::protozero::CppMessageObj {
- public:
-  using BufferStats = TraceStats_BufferStats;
-  using FilterStats = TraceStats_FilterStats;
-  using FinalFlushOutcome = TraceStats_FinalFlushOutcome;
-  static constexpr auto FINAL_FLUSH_UNSPECIFIED = TraceStats_FinalFlushOutcome_FINAL_FLUSH_UNSPECIFIED;
-  static constexpr auto FINAL_FLUSH_SUCCEEDED = TraceStats_FinalFlushOutcome_FINAL_FLUSH_SUCCEEDED;
-  static constexpr auto FINAL_FLUSH_FAILED = TraceStats_FinalFlushOutcome_FINAL_FLUSH_FAILED;
-  static constexpr auto FinalFlushOutcome_MIN = TraceStats_FinalFlushOutcome_FINAL_FLUSH_UNSPECIFIED;
-  static constexpr auto FinalFlushOutcome_MAX = TraceStats_FinalFlushOutcome_FINAL_FLUSH_FAILED;
-  enum FieldNumbers {
-    kBufferStatsFieldNumber = 1,
-    kProducersConnectedFieldNumber = 2,
-    kProducersSeenFieldNumber = 3,
-    kDataSourcesRegisteredFieldNumber = 4,
-    kDataSourcesSeenFieldNumber = 5,
-    kTracingSessionsFieldNumber = 6,
-    kTotalBuffersFieldNumber = 7,
-    kChunksDiscardedFieldNumber = 8,
-    kPatchesDiscardedFieldNumber = 9,
-    kInvalidPacketsFieldNumber = 10,
-    kFilterStatsFieldNumber = 11,
-    kFlushesRequestedFieldNumber = 12,
-    kFlushesSucceededFieldNumber = 13,
-    kFlushesFailedFieldNumber = 14,
-    kFinalFlushOutcomeFieldNumber = 15,
-  };
-
-  TraceStats();
-  ~TraceStats() override;
-  TraceStats(TraceStats&&) noexcept;
-  TraceStats& operator=(TraceStats&&);
-  TraceStats(const TraceStats&);
-  TraceStats& operator=(const TraceStats&);
-  bool operator==(const TraceStats&) const;
-  bool operator!=(const TraceStats& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<TraceStats_BufferStats>& buffer_stats() const { return buffer_stats_; }
-  std::vector<TraceStats_BufferStats>* mutable_buffer_stats() { return &buffer_stats_; }
-  int buffer_stats_size() const;
-  void clear_buffer_stats();
-  TraceStats_BufferStats* add_buffer_stats();
-
-  bool has_producers_connected() const { return _has_field_[2]; }
-  uint32_t producers_connected() const { return producers_connected_; }
-  void set_producers_connected(uint32_t value) { producers_connected_ = value; _has_field_.set(2); }
-
-  bool has_producers_seen() const { return _has_field_[3]; }
-  uint64_t producers_seen() const { return producers_seen_; }
-  void set_producers_seen(uint64_t value) { producers_seen_ = value; _has_field_.set(3); }
-
-  bool has_data_sources_registered() const { return _has_field_[4]; }
-  uint32_t data_sources_registered() const { return data_sources_registered_; }
-  void set_data_sources_registered(uint32_t value) { data_sources_registered_ = value; _has_field_.set(4); }
-
-  bool has_data_sources_seen() const { return _has_field_[5]; }
-  uint64_t data_sources_seen() const { return data_sources_seen_; }
-  void set_data_sources_seen(uint64_t value) { data_sources_seen_ = value; _has_field_.set(5); }
-
-  bool has_tracing_sessions() const { return _has_field_[6]; }
-  uint32_t tracing_sessions() const { return tracing_sessions_; }
-  void set_tracing_sessions(uint32_t value) { tracing_sessions_ = value; _has_field_.set(6); }
-
-  bool has_total_buffers() const { return _has_field_[7]; }
-  uint32_t total_buffers() const { return total_buffers_; }
-  void set_total_buffers(uint32_t value) { total_buffers_ = value; _has_field_.set(7); }
-
-  bool has_chunks_discarded() const { return _has_field_[8]; }
-  uint64_t chunks_discarded() const { return chunks_discarded_; }
-  void set_chunks_discarded(uint64_t value) { chunks_discarded_ = value; _has_field_.set(8); }
-
-  bool has_patches_discarded() const { return _has_field_[9]; }
-  uint64_t patches_discarded() const { return patches_discarded_; }
-  void set_patches_discarded(uint64_t value) { patches_discarded_ = value; _has_field_.set(9); }
-
-  bool has_invalid_packets() const { return _has_field_[10]; }
-  uint64_t invalid_packets() const { return invalid_packets_; }
-  void set_invalid_packets(uint64_t value) { invalid_packets_ = value; _has_field_.set(10); }
-
-  bool has_filter_stats() const { return _has_field_[11]; }
-  const TraceStats_FilterStats& filter_stats() const { return *filter_stats_; }
-  TraceStats_FilterStats* mutable_filter_stats() { _has_field_.set(11); return filter_stats_.get(); }
-
-  bool has_flushes_requested() const { return _has_field_[12]; }
-  uint64_t flushes_requested() const { return flushes_requested_; }
-  void set_flushes_requested(uint64_t value) { flushes_requested_ = value; _has_field_.set(12); }
-
-  bool has_flushes_succeeded() const { return _has_field_[13]; }
-  uint64_t flushes_succeeded() const { return flushes_succeeded_; }
-  void set_flushes_succeeded(uint64_t value) { flushes_succeeded_ = value; _has_field_.set(13); }
-
-  bool has_flushes_failed() const { return _has_field_[14]; }
-  uint64_t flushes_failed() const { return flushes_failed_; }
-  void set_flushes_failed(uint64_t value) { flushes_failed_ = value; _has_field_.set(14); }
-
-  bool has_final_flush_outcome() const { return _has_field_[15]; }
-  TraceStats_FinalFlushOutcome final_flush_outcome() const { return final_flush_outcome_; }
-  void set_final_flush_outcome(TraceStats_FinalFlushOutcome value) { final_flush_outcome_ = value; _has_field_.set(15); }
-
- private:
-  std::vector<TraceStats_BufferStats> buffer_stats_;
-  uint32_t producers_connected_{};
-  uint64_t producers_seen_{};
-  uint32_t data_sources_registered_{};
-  uint64_t data_sources_seen_{};
-  uint32_t tracing_sessions_{};
-  uint32_t total_buffers_{};
-  uint64_t chunks_discarded_{};
-  uint64_t patches_discarded_{};
-  uint64_t invalid_packets_{};
-  ::protozero::CopyablePtr<TraceStats_FilterStats> filter_stats_;
-  uint64_t flushes_requested_{};
-  uint64_t flushes_succeeded_{};
-  uint64_t flushes_failed_{};
-  TraceStats_FinalFlushOutcome final_flush_outcome_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<16> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT TraceStats_FilterStats : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kInputPacketsFieldNumber = 1,
-    kInputBytesFieldNumber = 2,
-    kOutputBytesFieldNumber = 3,
-    kErrorsFieldNumber = 4,
-  };
-
-  TraceStats_FilterStats();
-  ~TraceStats_FilterStats() override;
-  TraceStats_FilterStats(TraceStats_FilterStats&&) noexcept;
-  TraceStats_FilterStats& operator=(TraceStats_FilterStats&&);
-  TraceStats_FilterStats(const TraceStats_FilterStats&);
-  TraceStats_FilterStats& operator=(const TraceStats_FilterStats&);
-  bool operator==(const TraceStats_FilterStats&) const;
-  bool operator!=(const TraceStats_FilterStats& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_input_packets() const { return _has_field_[1]; }
-  uint64_t input_packets() const { return input_packets_; }
-  void set_input_packets(uint64_t value) { input_packets_ = value; _has_field_.set(1); }
-
-  bool has_input_bytes() const { return _has_field_[2]; }
-  uint64_t input_bytes() const { return input_bytes_; }
-  void set_input_bytes(uint64_t value) { input_bytes_ = value; _has_field_.set(2); }
-
-  bool has_output_bytes() const { return _has_field_[3]; }
-  uint64_t output_bytes() const { return output_bytes_; }
-  void set_output_bytes(uint64_t value) { output_bytes_ = value; _has_field_.set(3); }
-
-  bool has_errors() const { return _has_field_[4]; }
-  uint64_t errors() const { return errors_; }
-  void set_errors(uint64_t value) { errors_ = value; _has_field_.set(4); }
-
- private:
-  uint64_t input_packets_{};
-  uint64_t input_bytes_{};
-  uint64_t output_bytes_{};
-  uint64_t errors_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<5> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT TraceStats_BufferStats : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kBufferSizeFieldNumber = 12,
-    kBytesWrittenFieldNumber = 1,
-    kBytesOverwrittenFieldNumber = 13,
-    kBytesReadFieldNumber = 14,
-    kPaddingBytesWrittenFieldNumber = 15,
-    kPaddingBytesClearedFieldNumber = 16,
-    kChunksWrittenFieldNumber = 2,
-    kChunksRewrittenFieldNumber = 10,
-    kChunksOverwrittenFieldNumber = 3,
-    kChunksDiscardedFieldNumber = 18,
-    kChunksReadFieldNumber = 17,
-    kChunksCommittedOutOfOrderFieldNumber = 11,
-    kWriteWrapCountFieldNumber = 4,
-    kPatchesSucceededFieldNumber = 5,
-    kPatchesFailedFieldNumber = 6,
-    kReadaheadsSucceededFieldNumber = 7,
-    kReadaheadsFailedFieldNumber = 8,
-    kAbiViolationsFieldNumber = 9,
-    kTraceWriterPacketLossFieldNumber = 19,
-  };
-
-  TraceStats_BufferStats();
-  ~TraceStats_BufferStats() override;
-  TraceStats_BufferStats(TraceStats_BufferStats&&) noexcept;
-  TraceStats_BufferStats& operator=(TraceStats_BufferStats&&);
-  TraceStats_BufferStats(const TraceStats_BufferStats&);
-  TraceStats_BufferStats& operator=(const TraceStats_BufferStats&);
-  bool operator==(const TraceStats_BufferStats&) const;
-  bool operator!=(const TraceStats_BufferStats& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_buffer_size() const { return _has_field_[12]; }
-  uint64_t buffer_size() const { return buffer_size_; }
-  void set_buffer_size(uint64_t value) { buffer_size_ = value; _has_field_.set(12); }
-
-  bool has_bytes_written() const { return _has_field_[1]; }
-  uint64_t bytes_written() const { return bytes_written_; }
-  void set_bytes_written(uint64_t value) { bytes_written_ = value; _has_field_.set(1); }
-
-  bool has_bytes_overwritten() const { return _has_field_[13]; }
-  uint64_t bytes_overwritten() const { return bytes_overwritten_; }
-  void set_bytes_overwritten(uint64_t value) { bytes_overwritten_ = value; _has_field_.set(13); }
-
-  bool has_bytes_read() const { return _has_field_[14]; }
-  uint64_t bytes_read() const { return bytes_read_; }
-  void set_bytes_read(uint64_t value) { bytes_read_ = value; _has_field_.set(14); }
-
-  bool has_padding_bytes_written() const { return _has_field_[15]; }
-  uint64_t padding_bytes_written() const { return padding_bytes_written_; }
-  void set_padding_bytes_written(uint64_t value) { padding_bytes_written_ = value; _has_field_.set(15); }
-
-  bool has_padding_bytes_cleared() const { return _has_field_[16]; }
-  uint64_t padding_bytes_cleared() const { return padding_bytes_cleared_; }
-  void set_padding_bytes_cleared(uint64_t value) { padding_bytes_cleared_ = value; _has_field_.set(16); }
-
-  bool has_chunks_written() const { return _has_field_[2]; }
-  uint64_t chunks_written() const { return chunks_written_; }
-  void set_chunks_written(uint64_t value) { chunks_written_ = value; _has_field_.set(2); }
-
-  bool has_chunks_rewritten() const { return _has_field_[10]; }
-  uint64_t chunks_rewritten() const { return chunks_rewritten_; }
-  void set_chunks_rewritten(uint64_t value) { chunks_rewritten_ = value; _has_field_.set(10); }
-
-  bool has_chunks_overwritten() const { return _has_field_[3]; }
-  uint64_t chunks_overwritten() const { return chunks_overwritten_; }
-  void set_chunks_overwritten(uint64_t value) { chunks_overwritten_ = value; _has_field_.set(3); }
-
-  bool has_chunks_discarded() const { return _has_field_[18]; }
-  uint64_t chunks_discarded() const { return chunks_discarded_; }
-  void set_chunks_discarded(uint64_t value) { chunks_discarded_ = value; _has_field_.set(18); }
-
-  bool has_chunks_read() const { return _has_field_[17]; }
-  uint64_t chunks_read() const { return chunks_read_; }
-  void set_chunks_read(uint64_t value) { chunks_read_ = value; _has_field_.set(17); }
-
-  bool has_chunks_committed_out_of_order() const { return _has_field_[11]; }
-  uint64_t chunks_committed_out_of_order() const { return chunks_committed_out_of_order_; }
-  void set_chunks_committed_out_of_order(uint64_t value) { chunks_committed_out_of_order_ = value; _has_field_.set(11); }
 
-  bool has_write_wrap_count() const { return _has_field_[4]; }
-  uint64_t write_wrap_count() const { return write_wrap_count_; }
-  void set_write_wrap_count(uint64_t value) { write_wrap_count_ = value; _has_field_.set(4); }
+UninterpretedOption_NamePart::UninterpretedOption_NamePart() = default;
+UninterpretedOption_NamePart::~UninterpretedOption_NamePart() = default;
+UninterpretedOption_NamePart::UninterpretedOption_NamePart(const UninterpretedOption_NamePart&) = default;
+UninterpretedOption_NamePart& UninterpretedOption_NamePart::operator=(const UninterpretedOption_NamePart&) = default;
+UninterpretedOption_NamePart::UninterpretedOption_NamePart(UninterpretedOption_NamePart&&) noexcept = default;
+UninterpretedOption_NamePart& UninterpretedOption_NamePart::operator=(UninterpretedOption_NamePart&&) = default;
 
-  bool has_patches_succeeded() const { return _has_field_[5]; }
-  uint64_t patches_succeeded() const { return patches_succeeded_; }
-  void set_patches_succeeded(uint64_t value) { patches_succeeded_ = value; _has_field_.set(5); }
-
-  bool has_patches_failed() const { return _has_field_[6]; }
-  uint64_t patches_failed() const { return patches_failed_; }
-  void set_patches_failed(uint64_t value) { patches_failed_ = value; _has_field_.set(6); }
+bool UninterpretedOption_NamePart::operator==(const UninterpretedOption_NamePart& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_part_, other.name_part_)
+   && ::protozero::internal::gen_helpers::EqualsField(is_extension_, other.is_extension_);
+}
 
-  bool has_readaheads_succeeded() const { return _has_field_[7]; }
-  uint64_t readaheads_succeeded() const { return readaheads_succeeded_; }
-  void set_readaheads_succeeded(uint64_t value) { readaheads_succeeded_ = value; _has_field_.set(7); }
+bool UninterpretedOption_NamePart::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  bool has_readaheads_failed() const { return _has_field_[8]; }
-  uint64_t readaheads_failed() const { return readaheads_failed_; }
-  void set_readaheads_failed(uint64_t value) { readaheads_failed_ = value; _has_field_.set(8); }
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* name_part */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_part_);
+        break;
+      case 2 /* is_extension */:
+        field.get(&is_extension_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-  bool has_abi_violations() const { return _has_field_[9]; }
-  uint64_t abi_violations() const { return abi_violations_; }
-  void set_abi_violations(uint64_t value) { abi_violations_ = value; _has_field_.set(9); }
+std::string UninterpretedOption_NamePart::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  bool has_trace_writer_packet_loss() const { return _has_field_[19]; }
-  uint64_t trace_writer_packet_loss() const { return trace_writer_packet_loss_; }
-  void set_trace_writer_packet_loss(uint64_t value) { trace_writer_packet_loss_ = value; _has_field_.set(19); }
+std::vector<uint8_t> UninterpretedOption_NamePart::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
- private:
-  uint64_t buffer_size_{};
-  uint64_t bytes_written_{};
-  uint64_t bytes_overwritten_{};
-  uint64_t bytes_read_{};
-  uint64_t padding_bytes_written_{};
-  uint64_t padding_bytes_cleared_{};
-  uint64_t chunks_written_{};
-  uint64_t chunks_rewritten_{};
-  uint64_t chunks_overwritten_{};
-  uint64_t chunks_discarded_{};
-  uint64_t chunks_read_{};
-  uint64_t chunks_committed_out_of_order_{};
-  uint64_t write_wrap_count_{};
-  uint64_t patches_succeeded_{};
-  uint64_t patches_failed_{};
-  uint64_t readaheads_succeeded_{};
-  uint64_t readaheads_failed_{};
-  uint64_t abi_violations_{};
-  uint64_t trace_writer_packet_loss_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<20> _has_field_{};
-};
+void UninterpretedOption_NamePart::Serialize(::protozero::Message* msg) const {
+  // Field 1: name_part
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeString(1, name_part_, msg);
+  }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  // Field 2: is_extension
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, is_extension_, msg);
+  }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_TRACE_STATS_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/common/trace_stats.gen.h"
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
 
-TraceStats::TraceStats() = default;
-TraceStats::~TraceStats() = default;
-TraceStats::TraceStats(const TraceStats&) = default;
-TraceStats& TraceStats::operator=(const TraceStats&) = default;
-TraceStats::TraceStats(TraceStats&&) noexcept = default;
-TraceStats& TraceStats::operator=(TraceStats&&) = default;
+DescriptorProto::DescriptorProto() = default;
+DescriptorProto::~DescriptorProto() = default;
+DescriptorProto::DescriptorProto(const DescriptorProto&) = default;
+DescriptorProto& DescriptorProto::operator=(const DescriptorProto&) = default;
+DescriptorProto::DescriptorProto(DescriptorProto&&) noexcept = default;
+DescriptorProto& DescriptorProto::operator=(DescriptorProto&&) = default;
 
-bool TraceStats::operator==(const TraceStats& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && buffer_stats_ == other.buffer_stats_
-   && producers_connected_ == other.producers_connected_
-   && producers_seen_ == other.producers_seen_
-   && data_sources_registered_ == other.data_sources_registered_
-   && data_sources_seen_ == other.data_sources_seen_
-   && tracing_sessions_ == other.tracing_sessions_
-   && total_buffers_ == other.total_buffers_
-   && chunks_discarded_ == other.chunks_discarded_
-   && patches_discarded_ == other.patches_discarded_
-   && invalid_packets_ == other.invalid_packets_
-   && filter_stats_ == other.filter_stats_
-   && flushes_requested_ == other.flushes_requested_
-   && flushes_succeeded_ == other.flushes_succeeded_
-   && flushes_failed_ == other.flushes_failed_
-   && final_flush_outcome_ == other.final_flush_outcome_;
+bool DescriptorProto::operator==(const DescriptorProto& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(field_, other.field_)
+   && ::protozero::internal::gen_helpers::EqualsField(extension_, other.extension_)
+   && ::protozero::internal::gen_helpers::EqualsField(nested_type_, other.nested_type_)
+   && ::protozero::internal::gen_helpers::EqualsField(enum_type_, other.enum_type_)
+   && ::protozero::internal::gen_helpers::EqualsField(oneof_decl_, other.oneof_decl_)
+   && ::protozero::internal::gen_helpers::EqualsField(reserved_range_, other.reserved_range_)
+   && ::protozero::internal::gen_helpers::EqualsField(reserved_name_, other.reserved_name_);
 }
 
-int TraceStats::buffer_stats_size() const { return static_cast<int>(buffer_stats_.size()); }
-void TraceStats::clear_buffer_stats() { buffer_stats_.clear(); }
-TraceStats_BufferStats* TraceStats::add_buffer_stats() { buffer_stats_.emplace_back(); return &buffer_stats_.back(); }
-bool TraceStats::ParseFromArray(const void* raw, size_t size) {
-  buffer_stats_.clear();
+int DescriptorProto::field_size() const { return static_cast<int>(field_.size()); }
+void DescriptorProto::clear_field() { field_.clear(); }
+FieldDescriptorProto* DescriptorProto::add_field() { field_.emplace_back(); return &field_.back(); }
+int DescriptorProto::extension_size() const { return static_cast<int>(extension_.size()); }
+void DescriptorProto::clear_extension() { extension_.clear(); }
+FieldDescriptorProto* DescriptorProto::add_extension() { extension_.emplace_back(); return &extension_.back(); }
+int DescriptorProto::nested_type_size() const { return static_cast<int>(nested_type_.size()); }
+void DescriptorProto::clear_nested_type() { nested_type_.clear(); }
+DescriptorProto* DescriptorProto::add_nested_type() { nested_type_.emplace_back(); return &nested_type_.back(); }
+int DescriptorProto::enum_type_size() const { return static_cast<int>(enum_type_.size()); }
+void DescriptorProto::clear_enum_type() { enum_type_.clear(); }
+EnumDescriptorProto* DescriptorProto::add_enum_type() { enum_type_.emplace_back(); return &enum_type_.back(); }
+int DescriptorProto::oneof_decl_size() const { return static_cast<int>(oneof_decl_.size()); }
+void DescriptorProto::clear_oneof_decl() { oneof_decl_.clear(); }
+OneofDescriptorProto* DescriptorProto::add_oneof_decl() { oneof_decl_.emplace_back(); return &oneof_decl_.back(); }
+int DescriptorProto::reserved_range_size() const { return static_cast<int>(reserved_range_.size()); }
+void DescriptorProto::clear_reserved_range() { reserved_range_.clear(); }
+DescriptorProto_ReservedRange* DescriptorProto::add_reserved_range() { reserved_range_.emplace_back(); return &reserved_range_.back(); }
+bool DescriptorProto::ParseFromArray(const void* raw, size_t size) {
+  field_.clear();
+  extension_.clear();
+  nested_type_.clear();
+  enum_type_.clear();
+  oneof_decl_.clear();
+  reserved_range_.clear();
+  reserved_name_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -16467,51 +16695,36 @@ bool TraceStats::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* buffer_stats */:
-        buffer_stats_.emplace_back();
-        buffer_stats_.back().ParseFromArray(field.data(), field.size());
-        break;
-      case 2 /* producers_connected */:
-        field.get(&producers_connected_);
-        break;
-      case 3 /* producers_seen */:
-        field.get(&producers_seen_);
-        break;
-      case 4 /* data_sources_registered */:
-        field.get(&data_sources_registered_);
-        break;
-      case 5 /* data_sources_seen */:
-        field.get(&data_sources_seen_);
-        break;
-      case 6 /* tracing_sessions */:
-        field.get(&tracing_sessions_);
-        break;
-      case 7 /* total_buffers */:
-        field.get(&total_buffers_);
-        break;
-      case 8 /* chunks_discarded */:
-        field.get(&chunks_discarded_);
+      case 1 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
         break;
-      case 9 /* patches_discarded */:
-        field.get(&patches_discarded_);
+      case 2 /* field */:
+        field_.emplace_back();
+        field_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 10 /* invalid_packets */:
-        field.get(&invalid_packets_);
+      case 6 /* extension */:
+        extension_.emplace_back();
+        extension_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 11 /* filter_stats */:
-        (*filter_stats_).ParseFromArray(field.data(), field.size());
+      case 3 /* nested_type */:
+        nested_type_.emplace_back();
+        nested_type_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 12 /* flushes_requested */:
-        field.get(&flushes_requested_);
+      case 4 /* enum_type */:
+        enum_type_.emplace_back();
+        enum_type_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 13 /* flushes_succeeded */:
-        field.get(&flushes_succeeded_);
+      case 8 /* oneof_decl */:
+        oneof_decl_.emplace_back();
+        oneof_decl_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 14 /* flushes_failed */:
-        field.get(&flushes_failed_);
+      case 9 /* reserved_range */:
+        reserved_range_.emplace_back();
+        reserved_range_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 15 /* final_flush_outcome */:
-        field.get(&final_flush_outcome_);
+      case 10 /* reserved_name */:
+        reserved_name_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &reserved_name_.back());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -16521,114 +16734,77 @@ bool TraceStats::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TraceStats::SerializeAsString() const {
+std::string DescriptorProto::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TraceStats::SerializeAsArray() const {
+std::vector<uint8_t> DescriptorProto::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TraceStats::Serialize(::protozero::Message* msg) const {
-  // Field 1: buffer_stats
-  for (auto& it : buffer_stats_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
-  }
-
-  // Field 2: producers_connected
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, producers_connected_, msg);
-  }
-
-  // Field 3: producers_seen
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, producers_seen_, msg);
-  }
-
-  // Field 4: data_sources_registered
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, data_sources_registered_, msg);
-  }
-
-  // Field 5: data_sources_seen
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(5, data_sources_seen_, msg);
-  }
-
-  // Field 6: tracing_sessions
-  if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(6, tracing_sessions_, msg);
-  }
-
-  // Field 7: total_buffers
-  if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(7, total_buffers_, msg);
-  }
-
-  // Field 8: chunks_discarded
-  if (_has_field_[8]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(8, chunks_discarded_, msg);
+void DescriptorProto::Serialize(::protozero::Message* msg) const {
+  // Field 1: name
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
   }
 
-  // Field 9: patches_discarded
-  if (_has_field_[9]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(9, patches_discarded_, msg);
+  // Field 2: field
+  for (auto& it : field_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
   }
 
-  // Field 10: invalid_packets
-  if (_has_field_[10]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(10, invalid_packets_, msg);
+  // Field 6: extension
+  for (auto& it : extension_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(6));
   }
 
-  // Field 11: filter_stats
-  if (_has_field_[11]) {
-    (*filter_stats_).Serialize(msg->BeginNestedMessage<::protozero::Message>(11));
+  // Field 3: nested_type
+  for (auto& it : nested_type_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(3));
   }
 
-  // Field 12: flushes_requested
-  if (_has_field_[12]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(12, flushes_requested_, msg);
+  // Field 4: enum_type
+  for (auto& it : enum_type_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(4));
   }
 
-  // Field 13: flushes_succeeded
-  if (_has_field_[13]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(13, flushes_succeeded_, msg);
+  // Field 8: oneof_decl
+  for (auto& it : oneof_decl_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(8));
   }
 
-  // Field 14: flushes_failed
-  if (_has_field_[14]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(14, flushes_failed_, msg);
+  // Field 9: reserved_range
+  for (auto& it : reserved_range_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(9));
   }
 
-  // Field 15: final_flush_outcome
-  if (_has_field_[15]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(15, final_flush_outcome_, msg);
+  // Field 10: reserved_name
+  for (auto& it : reserved_name_) {
+    ::protozero::internal::gen_helpers::SerializeString(10, it, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-TraceStats_FilterStats::TraceStats_FilterStats() = default;
-TraceStats_FilterStats::~TraceStats_FilterStats() = default;
-TraceStats_FilterStats::TraceStats_FilterStats(const TraceStats_FilterStats&) = default;
-TraceStats_FilterStats& TraceStats_FilterStats::operator=(const TraceStats_FilterStats&) = default;
-TraceStats_FilterStats::TraceStats_FilterStats(TraceStats_FilterStats&&) noexcept = default;
-TraceStats_FilterStats& TraceStats_FilterStats::operator=(TraceStats_FilterStats&&) = default;
+DescriptorProto_ReservedRange::DescriptorProto_ReservedRange() = default;
+DescriptorProto_ReservedRange::~DescriptorProto_ReservedRange() = default;
+DescriptorProto_ReservedRange::DescriptorProto_ReservedRange(const DescriptorProto_ReservedRange&) = default;
+DescriptorProto_ReservedRange& DescriptorProto_ReservedRange::operator=(const DescriptorProto_ReservedRange&) = default;
+DescriptorProto_ReservedRange::DescriptorProto_ReservedRange(DescriptorProto_ReservedRange&&) noexcept = default;
+DescriptorProto_ReservedRange& DescriptorProto_ReservedRange::operator=(DescriptorProto_ReservedRange&&) = default;
 
-bool TraceStats_FilterStats::operator==(const TraceStats_FilterStats& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && input_packets_ == other.input_packets_
-   && input_bytes_ == other.input_bytes_
-   && output_bytes_ == other.output_bytes_
-   && errors_ == other.errors_;
+bool DescriptorProto_ReservedRange::operator==(const DescriptorProto_ReservedRange& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(start_, other.start_)
+   && ::protozero::internal::gen_helpers::EqualsField(end_, other.end_);
 }
 
-bool TraceStats_FilterStats::ParseFromArray(const void* raw, size_t size) {
+bool DescriptorProto_ReservedRange::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -16638,17 +16814,11 @@ bool TraceStats_FilterStats::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* input_packets */:
-        field.get(&input_packets_);
-        break;
-      case 2 /* input_bytes */:
-        field.get(&input_bytes_);
-        break;
-      case 3 /* output_bytes */:
-        field.get(&output_bytes_);
+      case 1 /* start */:
+        field.get(&start_);
         break;
-      case 4 /* errors */:
-        field.get(&errors_);
+      case 2 /* end */:
+        field.get(&end_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -16658,74 +16828,68 @@ bool TraceStats_FilterStats::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TraceStats_FilterStats::SerializeAsString() const {
+std::string DescriptorProto_ReservedRange::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TraceStats_FilterStats::SerializeAsArray() const {
+std::vector<uint8_t> DescriptorProto_ReservedRange::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TraceStats_FilterStats::Serialize(::protozero::Message* msg) const {
-  // Field 1: input_packets
+void DescriptorProto_ReservedRange::Serialize(::protozero::Message* msg) const {
+  // Field 1: start
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, input_packets_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, start_, msg);
   }
 
-  // Field 2: input_bytes
+  // Field 2: end
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, input_bytes_, msg);
-  }
-
-  // Field 3: output_bytes
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, output_bytes_, msg);
-  }
-
-  // Field 4: errors
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, errors_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, end_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-TraceStats_BufferStats::TraceStats_BufferStats() = default;
-TraceStats_BufferStats::~TraceStats_BufferStats() = default;
-TraceStats_BufferStats::TraceStats_BufferStats(const TraceStats_BufferStats&) = default;
-TraceStats_BufferStats& TraceStats_BufferStats::operator=(const TraceStats_BufferStats&) = default;
-TraceStats_BufferStats::TraceStats_BufferStats(TraceStats_BufferStats&&) noexcept = default;
-TraceStats_BufferStats& TraceStats_BufferStats::operator=(TraceStats_BufferStats&&) = default;
+FileDescriptorProto::FileDescriptorProto() = default;
+FileDescriptorProto::~FileDescriptorProto() = default;
+FileDescriptorProto::FileDescriptorProto(const FileDescriptorProto&) = default;
+FileDescriptorProto& FileDescriptorProto::operator=(const FileDescriptorProto&) = default;
+FileDescriptorProto::FileDescriptorProto(FileDescriptorProto&&) noexcept = default;
+FileDescriptorProto& FileDescriptorProto::operator=(FileDescriptorProto&&) = default;
 
-bool TraceStats_BufferStats::operator==(const TraceStats_BufferStats& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && buffer_size_ == other.buffer_size_
-   && bytes_written_ == other.bytes_written_
-   && bytes_overwritten_ == other.bytes_overwritten_
-   && bytes_read_ == other.bytes_read_
-   && padding_bytes_written_ == other.padding_bytes_written_
-   && padding_bytes_cleared_ == other.padding_bytes_cleared_
-   && chunks_written_ == other.chunks_written_
-   && chunks_rewritten_ == other.chunks_rewritten_
-   && chunks_overwritten_ == other.chunks_overwritten_
-   && chunks_discarded_ == other.chunks_discarded_
-   && chunks_read_ == other.chunks_read_
-   && chunks_committed_out_of_order_ == other.chunks_committed_out_of_order_
-   && write_wrap_count_ == other.write_wrap_count_
-   && patches_succeeded_ == other.patches_succeeded_
-   && patches_failed_ == other.patches_failed_
-   && readaheads_succeeded_ == other.readaheads_succeeded_
-   && readaheads_failed_ == other.readaheads_failed_
-   && abi_violations_ == other.abi_violations_
-   && trace_writer_packet_loss_ == other.trace_writer_packet_loss_;
+bool FileDescriptorProto::operator==(const FileDescriptorProto& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(package_, other.package_)
+   && ::protozero::internal::gen_helpers::EqualsField(dependency_, other.dependency_)
+   && ::protozero::internal::gen_helpers::EqualsField(public_dependency_, other.public_dependency_)
+   && ::protozero::internal::gen_helpers::EqualsField(weak_dependency_, other.weak_dependency_)
+   && ::protozero::internal::gen_helpers::EqualsField(message_type_, other.message_type_)
+   && ::protozero::internal::gen_helpers::EqualsField(enum_type_, other.enum_type_)
+   && ::protozero::internal::gen_helpers::EqualsField(extension_, other.extension_);
 }
 
-bool TraceStats_BufferStats::ParseFromArray(const void* raw, size_t size) {
+int FileDescriptorProto::message_type_size() const { return static_cast<int>(message_type_.size()); }
+void FileDescriptorProto::clear_message_type() { message_type_.clear(); }
+DescriptorProto* FileDescriptorProto::add_message_type() { message_type_.emplace_back(); return &message_type_.back(); }
+int FileDescriptorProto::enum_type_size() const { return static_cast<int>(enum_type_.size()); }
+void FileDescriptorProto::clear_enum_type() { enum_type_.clear(); }
+EnumDescriptorProto* FileDescriptorProto::add_enum_type() { enum_type_.emplace_back(); return &enum_type_.back(); }
+int FileDescriptorProto::extension_size() const { return static_cast<int>(extension_.size()); }
+void FileDescriptorProto::clear_extension() { extension_.clear(); }
+FieldDescriptorProto* FileDescriptorProto::add_extension() { extension_.emplace_back(); return &extension_.back(); }
+bool FileDescriptorProto::ParseFromArray(const void* raw, size_t size) {
+  dependency_.clear();
+  public_dependency_.clear();
+  weak_dependency_.clear();
+  message_type_.clear();
+  enum_type_.clear();
+  extension_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -16735,177 +16899,155 @@ bool TraceStats_BufferStats::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 12 /* buffer_size */:
-        field.get(&buffer_size_);
-        break;
-      case 1 /* bytes_written */:
-        field.get(&bytes_written_);
-        break;
-      case 13 /* bytes_overwritten */:
-        field.get(&bytes_overwritten_);
-        break;
-      case 14 /* bytes_read */:
-        field.get(&bytes_read_);
+      case 1 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
         break;
-      case 15 /* padding_bytes_written */:
-        field.get(&padding_bytes_written_);
+      case 2 /* package */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &package_);
         break;
-      case 16 /* padding_bytes_cleared */:
-        field.get(&padding_bytes_cleared_);
+      case 3 /* dependency */:
+        dependency_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &dependency_.back());
         break;
-      case 2 /* chunks_written */:
-        field.get(&chunks_written_);
+      case 10 /* public_dependency */:
+        public_dependency_.emplace_back();
+        field.get(&public_dependency_.back());
         break;
-      case 10 /* chunks_rewritten */:
-        field.get(&chunks_rewritten_);
+      case 11 /* weak_dependency */:
+        weak_dependency_.emplace_back();
+        field.get(&weak_dependency_.back());
         break;
-      case 3 /* chunks_overwritten */:
-        field.get(&chunks_overwritten_);
+      case 4 /* message_type */:
+        message_type_.emplace_back();
+        message_type_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 18 /* chunks_discarded */:
-        field.get(&chunks_discarded_);
+      case 5 /* enum_type */:
+        enum_type_.emplace_back();
+        enum_type_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 17 /* chunks_read */:
-        field.get(&chunks_read_);
+      case 7 /* extension */:
+        extension_.emplace_back();
+        extension_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 11 /* chunks_committed_out_of_order */:
-        field.get(&chunks_committed_out_of_order_);
-        break;
-      case 4 /* write_wrap_count */:
-        field.get(&write_wrap_count_);
-        break;
-      case 5 /* patches_succeeded */:
-        field.get(&patches_succeeded_);
-        break;
-      case 6 /* patches_failed */:
-        field.get(&patches_failed_);
-        break;
-      case 7 /* readaheads_succeeded */:
-        field.get(&readaheads_succeeded_);
-        break;
-      case 8 /* readaheads_failed */:
-        field.get(&readaheads_failed_);
-        break;
-      case 9 /* abi_violations */:
-        field.get(&abi_violations_);
-        break;
-      case 19 /* trace_writer_packet_loss */:
-        field.get(&trace_writer_packet_loss_);
-        break;
-      default:
-        field.SerializeAndAppendTo(&unknown_fields_);
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
         break;
     }
   }
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TraceStats_BufferStats::SerializeAsString() const {
+std::string FileDescriptorProto::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TraceStats_BufferStats::SerializeAsArray() const {
+std::vector<uint8_t> FileDescriptorProto::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TraceStats_BufferStats::Serialize(::protozero::Message* msg) const {
-  // Field 12: buffer_size
-  if (_has_field_[12]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(12, buffer_size_, msg);
-  }
-
-  // Field 1: bytes_written
+void FileDescriptorProto::Serialize(::protozero::Message* msg) const {
+  // Field 1: name
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, bytes_written_, msg);
-  }
-
-  // Field 13: bytes_overwritten
-  if (_has_field_[13]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(13, bytes_overwritten_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
   }
 
-  // Field 14: bytes_read
-  if (_has_field_[14]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(14, bytes_read_, msg);
+  // Field 2: package
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeString(2, package_, msg);
   }
 
-  // Field 15: padding_bytes_written
-  if (_has_field_[15]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(15, padding_bytes_written_, msg);
+  // Field 3: dependency
+  for (auto& it : dependency_) {
+    ::protozero::internal::gen_helpers::SerializeString(3, it, msg);
   }
 
-  // Field 16: padding_bytes_cleared
-  if (_has_field_[16]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(16, padding_bytes_cleared_, msg);
+  // Field 10: public_dependency
+  for (auto& it : public_dependency_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(10, it, msg);
   }
 
-  // Field 2: chunks_written
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, chunks_written_, msg);
+  // Field 11: weak_dependency
+  for (auto& it : weak_dependency_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(11, it, msg);
   }
 
-  // Field 10: chunks_rewritten
-  if (_has_field_[10]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(10, chunks_rewritten_, msg);
+  // Field 4: message_type
+  for (auto& it : message_type_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(4));
   }
 
-  // Field 3: chunks_overwritten
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, chunks_overwritten_, msg);
+  // Field 5: enum_type
+  for (auto& it : enum_type_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(5));
   }
 
-  // Field 18: chunks_discarded
-  if (_has_field_[18]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(18, chunks_discarded_, msg);
+  // Field 7: extension
+  for (auto& it : extension_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(7));
   }
 
-  // Field 17: chunks_read
-  if (_has_field_[17]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(17, chunks_read_, msg);
-  }
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  // Field 11: chunks_committed_out_of_order
-  if (_has_field_[11]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(11, chunks_committed_out_of_order_, msg);
-  }
 
-  // Field 4: write_wrap_count
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, write_wrap_count_, msg);
-  }
+FileDescriptorSet::FileDescriptorSet() = default;
+FileDescriptorSet::~FileDescriptorSet() = default;
+FileDescriptorSet::FileDescriptorSet(const FileDescriptorSet&) = default;
+FileDescriptorSet& FileDescriptorSet::operator=(const FileDescriptorSet&) = default;
+FileDescriptorSet::FileDescriptorSet(FileDescriptorSet&&) noexcept = default;
+FileDescriptorSet& FileDescriptorSet::operator=(FileDescriptorSet&&) = default;
 
-  // Field 5: patches_succeeded
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(5, patches_succeeded_, msg);
-  }
+bool FileDescriptorSet::operator==(const FileDescriptorSet& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(file_, other.file_);
+}
 
-  // Field 6: patches_failed
-  if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(6, patches_failed_, msg);
-  }
+int FileDescriptorSet::file_size() const { return static_cast<int>(file_.size()); }
+void FileDescriptorSet::clear_file() { file_.clear(); }
+FileDescriptorProto* FileDescriptorSet::add_file() { file_.emplace_back(); return &file_.back(); }
+bool FileDescriptorSet::ParseFromArray(const void* raw, size_t size) {
+  file_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  // Field 7: readaheads_succeeded
-  if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(7, readaheads_succeeded_, msg);
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* file */:
+        file_.emplace_back();
+        file_.back().ParseFromArray(field.data(), field.size());
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
   }
+  return !packed_error && !dec.bytes_left();
+}
 
-  // Field 8: readaheads_failed
-  if (_has_field_[8]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(8, readaheads_failed_, msg);
-  }
+std::string FileDescriptorSet::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  // Field 9: abi_violations
-  if (_has_field_[9]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(9, abi_violations_, msg);
-  }
+std::vector<uint8_t> FileDescriptorSet::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  // Field 19: trace_writer_packet_loss
-  if (_has_field_[19]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(19, trace_writer_packet_loss_, msg);
+void FileDescriptorSet::Serialize(::protozero::Message* msg) const {
+  // Field 1: file
+  for (auto& it : file_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -16917,93 +17059,7 @@ void TraceStats_BufferStats::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/common/tracing_service_capabilities.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/common/tracing_service_capabilities.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_TRACING_SERVICE_CAPABILITIES_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_TRACING_SERVICE_CAPABILITIES_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class TracingServiceCapabilities;
-enum ObservableEvents_Type : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT TracingServiceCapabilities : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kHasQueryCapabilitiesFieldNumber = 1,
-    kObservableEventsFieldNumber = 2,
-    kHasTraceConfigOutputPathFieldNumber = 3,
-  };
-
-  TracingServiceCapabilities();
-  ~TracingServiceCapabilities() override;
-  TracingServiceCapabilities(TracingServiceCapabilities&&) noexcept;
-  TracingServiceCapabilities& operator=(TracingServiceCapabilities&&);
-  TracingServiceCapabilities(const TracingServiceCapabilities&);
-  TracingServiceCapabilities& operator=(const TracingServiceCapabilities&);
-  bool operator==(const TracingServiceCapabilities&) const;
-  bool operator!=(const TracingServiceCapabilities& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_has_query_capabilities() const { return _has_field_[1]; }
-  bool has_query_capabilities() const { return has_query_capabilities_; }
-  void set_has_query_capabilities(bool value) { has_query_capabilities_ = value; _has_field_.set(1); }
-
-  const std::vector<ObservableEvents_Type>& observable_events() const { return observable_events_; }
-  std::vector<ObservableEvents_Type>* mutable_observable_events() { return &observable_events_; }
-  int observable_events_size() const { return static_cast<int>(observable_events_.size()); }
-  void clear_observable_events() { observable_events_.clear(); }
-  void add_observable_events(ObservableEvents_Type value) { observable_events_.emplace_back(value); }
-  ObservableEvents_Type* add_observable_events() { observable_events_.emplace_back(); return &observable_events_.back(); }
-
-  bool has_has_trace_config_output_path() const { return _has_field_[3]; }
-  bool has_trace_config_output_path() const { return has_trace_config_output_path_; }
-  void set_has_trace_config_output_path(bool value) { has_trace_config_output_path_ = value; _has_field_.set(3); }
-
- private:
-  bool has_query_capabilities_{};
-  std::vector<ObservableEvents_Type> observable_events_;
-  bool has_trace_config_output_path_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<4> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_TRACING_SERVICE_CAPABILITIES_PROTO_CPP_H_
+// gen_amalgamated begin source: gen/protos/perfetto/common/ftrace_descriptor.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -17014,29 +17070,29 @@ class PERFETTO_EXPORT_COMPONENT TracingServiceCapabilities : public ::protozero:
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/common/tracing_service_capabilities.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/common/observable_events.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/ftrace_descriptor.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-TracingServiceCapabilities::TracingServiceCapabilities() = default;
-TracingServiceCapabilities::~TracingServiceCapabilities() = default;
-TracingServiceCapabilities::TracingServiceCapabilities(const TracingServiceCapabilities&) = default;
-TracingServiceCapabilities& TracingServiceCapabilities::operator=(const TracingServiceCapabilities&) = default;
-TracingServiceCapabilities::TracingServiceCapabilities(TracingServiceCapabilities&&) noexcept = default;
-TracingServiceCapabilities& TracingServiceCapabilities::operator=(TracingServiceCapabilities&&) = default;
+FtraceDescriptor::FtraceDescriptor() = default;
+FtraceDescriptor::~FtraceDescriptor() = default;
+FtraceDescriptor::FtraceDescriptor(const FtraceDescriptor&) = default;
+FtraceDescriptor& FtraceDescriptor::operator=(const FtraceDescriptor&) = default;
+FtraceDescriptor::FtraceDescriptor(FtraceDescriptor&&) noexcept = default;
+FtraceDescriptor& FtraceDescriptor::operator=(FtraceDescriptor&&) = default;
 
-bool TracingServiceCapabilities::operator==(const TracingServiceCapabilities& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && has_query_capabilities_ == other.has_query_capabilities_
-   && observable_events_ == other.observable_events_
-   && has_trace_config_output_path_ == other.has_trace_config_output_path_;
+bool FtraceDescriptor::operator==(const FtraceDescriptor& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(atrace_categories_, other.atrace_categories_);
 }
 
-bool TracingServiceCapabilities::ParseFromArray(const void* raw, size_t size) {
-  observable_events_.clear();
+int FtraceDescriptor::atrace_categories_size() const { return static_cast<int>(atrace_categories_.size()); }
+void FtraceDescriptor::clear_atrace_categories() { atrace_categories_.clear(); }
+FtraceDescriptor_AtraceCategory* FtraceDescriptor::add_atrace_categories() { atrace_categories_.emplace_back(); return &atrace_categories_.back(); }
+bool FtraceDescriptor::ParseFromArray(const void* raw, size_t size) {
+  atrace_categories_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -17046,15 +17102,9 @@ bool TracingServiceCapabilities::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* has_query_capabilities */:
-        field.get(&has_query_capabilities_);
-        break;
-      case 2 /* observable_events */:
-        observable_events_.emplace_back();
-        field.get(&observable_events_.back());
-        break;
-      case 3 /* has_trace_config_output_path */:
-        field.get(&has_trace_config_output_path_);
+      case 1 /* atrace_categories */:
+        atrace_categories_.emplace_back();
+        atrace_categories_.back().ParseFromArray(field.data(), field.size());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -17064,466 +17114,98 @@ bool TracingServiceCapabilities::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TracingServiceCapabilities::SerializeAsString() const {
+std::string FtraceDescriptor::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TracingServiceCapabilities::SerializeAsArray() const {
+std::vector<uint8_t> FtraceDescriptor::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TracingServiceCapabilities::Serialize(::protozero::Message* msg) const {
-  // Field 1: has_query_capabilities
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(1, has_query_capabilities_, msg);
-  }
-
-  // Field 2: observable_events
-  for (auto& it : observable_events_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, it, msg);
-  }
-
-  // Field 3: has_trace_config_output_path
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, has_trace_config_output_path_, msg);
+void FtraceDescriptor::Serialize(::protozero::Message* msg) const {
+  // Field 1: atrace_categories
+  for (auto& it : atrace_categories_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/common/tracing_service_state.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/common/tracing_service_state.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_TRACING_SERVICE_STATE_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_TRACING_SERVICE_STATE_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class TracingServiceState;
-class TracingServiceState_TracingSession;
-class TracingServiceState_DataSource;
-class DataSourceDescriptor;
-class TracingServiceState_Producer;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT TracingServiceState : public ::protozero::CppMessageObj {
- public:
-  using Producer = TracingServiceState_Producer;
-  using DataSource = TracingServiceState_DataSource;
-  using TracingSession = TracingServiceState_TracingSession;
-  enum FieldNumbers {
-    kProducersFieldNumber = 1,
-    kDataSourcesFieldNumber = 2,
-    kTracingSessionsFieldNumber = 6,
-    kSupportsTracingSessionsFieldNumber = 7,
-    kNumSessionsFieldNumber = 3,
-    kNumSessionsStartedFieldNumber = 4,
-    kTracingServiceVersionFieldNumber = 5,
-  };
-
-  TracingServiceState();
-  ~TracingServiceState() override;
-  TracingServiceState(TracingServiceState&&) noexcept;
-  TracingServiceState& operator=(TracingServiceState&&);
-  TracingServiceState(const TracingServiceState&);
-  TracingServiceState& operator=(const TracingServiceState&);
-  bool operator==(const TracingServiceState&) const;
-  bool operator!=(const TracingServiceState& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<TracingServiceState_Producer>& producers() const { return producers_; }
-  std::vector<TracingServiceState_Producer>* mutable_producers() { return &producers_; }
-  int producers_size() const;
-  void clear_producers();
-  TracingServiceState_Producer* add_producers();
-
-  const std::vector<TracingServiceState_DataSource>& data_sources() const { return data_sources_; }
-  std::vector<TracingServiceState_DataSource>* mutable_data_sources() { return &data_sources_; }
-  int data_sources_size() const;
-  void clear_data_sources();
-  TracingServiceState_DataSource* add_data_sources();
-
-  const std::vector<TracingServiceState_TracingSession>& tracing_sessions() const { return tracing_sessions_; }
-  std::vector<TracingServiceState_TracingSession>* mutable_tracing_sessions() { return &tracing_sessions_; }
-  int tracing_sessions_size() const;
-  void clear_tracing_sessions();
-  TracingServiceState_TracingSession* add_tracing_sessions();
-
-  bool has_supports_tracing_sessions() const { return _has_field_[7]; }
-  bool supports_tracing_sessions() const { return supports_tracing_sessions_; }
-  void set_supports_tracing_sessions(bool value) { supports_tracing_sessions_ = value; _has_field_.set(7); }
-
-  bool has_num_sessions() const { return _has_field_[3]; }
-  int32_t num_sessions() const { return num_sessions_; }
-  void set_num_sessions(int32_t value) { num_sessions_ = value; _has_field_.set(3); }
-
-  bool has_num_sessions_started() const { return _has_field_[4]; }
-  int32_t num_sessions_started() const { return num_sessions_started_; }
-  void set_num_sessions_started(int32_t value) { num_sessions_started_ = value; _has_field_.set(4); }
-
-  bool has_tracing_service_version() const { return _has_field_[5]; }
-  const std::string& tracing_service_version() const { return tracing_service_version_; }
-  void set_tracing_service_version(const std::string& value) { tracing_service_version_ = value; _has_field_.set(5); }
-
- private:
-  std::vector<TracingServiceState_Producer> producers_;
-  std::vector<TracingServiceState_DataSource> data_sources_;
-  std::vector<TracingServiceState_TracingSession> tracing_sessions_;
-  bool supports_tracing_sessions_{};
-  int32_t num_sessions_{};
-  int32_t num_sessions_started_{};
-  std::string tracing_service_version_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<8> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT TracingServiceState_TracingSession : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kIdFieldNumber = 1,
-    kConsumerUidFieldNumber = 2,
-    kStateFieldNumber = 3,
-    kUniqueSessionNameFieldNumber = 4,
-    kBufferSizeKbFieldNumber = 5,
-    kDurationMsFieldNumber = 6,
-    kNumDataSourcesFieldNumber = 7,
-    kStartRealtimeNsFieldNumber = 8,
-  };
-
-  TracingServiceState_TracingSession();
-  ~TracingServiceState_TracingSession() override;
-  TracingServiceState_TracingSession(TracingServiceState_TracingSession&&) noexcept;
-  TracingServiceState_TracingSession& operator=(TracingServiceState_TracingSession&&);
-  TracingServiceState_TracingSession(const TracingServiceState_TracingSession&);
-  TracingServiceState_TracingSession& operator=(const TracingServiceState_TracingSession&);
-  bool operator==(const TracingServiceState_TracingSession&) const;
-  bool operator!=(const TracingServiceState_TracingSession& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_id() const { return _has_field_[1]; }
-  uint64_t id() const { return id_; }
-  void set_id(uint64_t value) { id_ = value; _has_field_.set(1); }
-
-  bool has_consumer_uid() const { return _has_field_[2]; }
-  int32_t consumer_uid() const { return consumer_uid_; }
-  void set_consumer_uid(int32_t value) { consumer_uid_ = value; _has_field_.set(2); }
-
-  bool has_state() const { return _has_field_[3]; }
-  const std::string& state() const { return state_; }
-  void set_state(const std::string& value) { state_ = value; _has_field_.set(3); }
-
-  bool has_unique_session_name() const { return _has_field_[4]; }
-  const std::string& unique_session_name() const { return unique_session_name_; }
-  void set_unique_session_name(const std::string& value) { unique_session_name_ = value; _has_field_.set(4); }
-
-  const std::vector<uint32_t>& buffer_size_kb() const { return buffer_size_kb_; }
-  std::vector<uint32_t>* mutable_buffer_size_kb() { return &buffer_size_kb_; }
-  int buffer_size_kb_size() const { return static_cast<int>(buffer_size_kb_.size()); }
-  void clear_buffer_size_kb() { buffer_size_kb_.clear(); }
-  void add_buffer_size_kb(uint32_t value) { buffer_size_kb_.emplace_back(value); }
-  uint32_t* add_buffer_size_kb() { buffer_size_kb_.emplace_back(); return &buffer_size_kb_.back(); }
-
-  bool has_duration_ms() const { return _has_field_[6]; }
-  uint32_t duration_ms() const { return duration_ms_; }
-  void set_duration_ms(uint32_t value) { duration_ms_ = value; _has_field_.set(6); }
-
-  bool has_num_data_sources() const { return _has_field_[7]; }
-  uint32_t num_data_sources() const { return num_data_sources_; }
-  void set_num_data_sources(uint32_t value) { num_data_sources_ = value; _has_field_.set(7); }
-
-  bool has_start_realtime_ns() const { return _has_field_[8]; }
-  int64_t start_realtime_ns() const { return start_realtime_ns_; }
-  void set_start_realtime_ns(int64_t value) { start_realtime_ns_ = value; _has_field_.set(8); }
-
- private:
-  uint64_t id_{};
-  int32_t consumer_uid_{};
-  std::string state_{};
-  std::string unique_session_name_{};
-  std::vector<uint32_t> buffer_size_kb_;
-  uint32_t duration_ms_{};
-  uint32_t num_data_sources_{};
-  int64_t start_realtime_ns_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<9> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT TracingServiceState_DataSource : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kDsDescriptorFieldNumber = 1,
-    kProducerIdFieldNumber = 2,
-  };
-
-  TracingServiceState_DataSource();
-  ~TracingServiceState_DataSource() override;
-  TracingServiceState_DataSource(TracingServiceState_DataSource&&) noexcept;
-  TracingServiceState_DataSource& operator=(TracingServiceState_DataSource&&);
-  TracingServiceState_DataSource(const TracingServiceState_DataSource&);
-  TracingServiceState_DataSource& operator=(const TracingServiceState_DataSource&);
-  bool operator==(const TracingServiceState_DataSource&) const;
-  bool operator!=(const TracingServiceState_DataSource& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_ds_descriptor() const { return _has_field_[1]; }
-  const DataSourceDescriptor& ds_descriptor() const { return *ds_descriptor_; }
-  DataSourceDescriptor* mutable_ds_descriptor() { _has_field_.set(1); return ds_descriptor_.get(); }
-
-  bool has_producer_id() const { return _has_field_[2]; }
-  int32_t producer_id() const { return producer_id_; }
-  void set_producer_id(int32_t value) { producer_id_ = value; _has_field_.set(2); }
-
- private:
-  ::protozero::CopyablePtr<DataSourceDescriptor> ds_descriptor_;
-  int32_t producer_id_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT TracingServiceState_Producer : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kIdFieldNumber = 1,
-    kNameFieldNumber = 2,
-    kPidFieldNumber = 5,
-    kUidFieldNumber = 3,
-    kSdkVersionFieldNumber = 4,
-  };
-
-  TracingServiceState_Producer();
-  ~TracingServiceState_Producer() override;
-  TracingServiceState_Producer(TracingServiceState_Producer&&) noexcept;
-  TracingServiceState_Producer& operator=(TracingServiceState_Producer&&);
-  TracingServiceState_Producer(const TracingServiceState_Producer&);
-  TracingServiceState_Producer& operator=(const TracingServiceState_Producer&);
-  bool operator==(const TracingServiceState_Producer&) const;
-  bool operator!=(const TracingServiceState_Producer& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_id() const { return _has_field_[1]; }
-  int32_t id() const { return id_; }
-  void set_id(int32_t value) { id_ = value; _has_field_.set(1); }
-
-  bool has_name() const { return _has_field_[2]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
-
-  bool has_pid() const { return _has_field_[5]; }
-  int32_t pid() const { return pid_; }
-  void set_pid(int32_t value) { pid_ = value; _has_field_.set(5); }
-
-  bool has_uid() const { return _has_field_[3]; }
-  int32_t uid() const { return uid_; }
-  void set_uid(int32_t value) { uid_ = value; _has_field_.set(3); }
-
-  bool has_sdk_version() const { return _has_field_[4]; }
-  const std::string& sdk_version() const { return sdk_version_; }
-  void set_sdk_version(const std::string& value) { sdk_version_ = value; _has_field_.set(4); }
-
- private:
-  int32_t id_{};
-  std::string name_{};
-  int32_t pid_{};
-  int32_t uid_{};
-  std::string sdk_version_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<6> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_TRACING_SERVICE_STATE_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/common/track_event_descriptor.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_TRACK_EVENT_DESCRIPTOR_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_TRACK_EVENT_DESCRIPTOR_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class TrackEventDescriptor;
-class TrackEventCategory;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT TrackEventDescriptor : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kAvailableCategoriesFieldNumber = 1,
-  };
 
-  TrackEventDescriptor();
-  ~TrackEventDescriptor() override;
-  TrackEventDescriptor(TrackEventDescriptor&&) noexcept;
-  TrackEventDescriptor& operator=(TrackEventDescriptor&&);
-  TrackEventDescriptor(const TrackEventDescriptor&);
-  TrackEventDescriptor& operator=(const TrackEventDescriptor&);
-  bool operator==(const TrackEventDescriptor&) const;
-  bool operator!=(const TrackEventDescriptor& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<TrackEventCategory>& available_categories() const { return available_categories_; }
-  std::vector<TrackEventCategory>* mutable_available_categories() { return &available_categories_; }
-  int available_categories_size() const;
-  void clear_available_categories();
-  TrackEventCategory* add_available_categories();
-
- private:
-  std::vector<TrackEventCategory> available_categories_;
+FtraceDescriptor_AtraceCategory::FtraceDescriptor_AtraceCategory() = default;
+FtraceDescriptor_AtraceCategory::~FtraceDescriptor_AtraceCategory() = default;
+FtraceDescriptor_AtraceCategory::FtraceDescriptor_AtraceCategory(const FtraceDescriptor_AtraceCategory&) = default;
+FtraceDescriptor_AtraceCategory& FtraceDescriptor_AtraceCategory::operator=(const FtraceDescriptor_AtraceCategory&) = default;
+FtraceDescriptor_AtraceCategory::FtraceDescriptor_AtraceCategory(FtraceDescriptor_AtraceCategory&&) noexcept = default;
+FtraceDescriptor_AtraceCategory& FtraceDescriptor_AtraceCategory::operator=(FtraceDescriptor_AtraceCategory&&) = default;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+bool FtraceDescriptor_AtraceCategory::operator==(const FtraceDescriptor_AtraceCategory& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(description_, other.description_);
+}
 
-  std::bitset<2> _has_field_{};
-};
+bool FtraceDescriptor_AtraceCategory::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+        break;
+      case 2 /* description */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &description_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-class PERFETTO_EXPORT_COMPONENT TrackEventCategory : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kNameFieldNumber = 1,
-    kDescriptionFieldNumber = 2,
-    kTagsFieldNumber = 3,
-  };
+std::string FtraceDescriptor_AtraceCategory::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  TrackEventCategory();
-  ~TrackEventCategory() override;
-  TrackEventCategory(TrackEventCategory&&) noexcept;
-  TrackEventCategory& operator=(TrackEventCategory&&);
-  TrackEventCategory(const TrackEventCategory&);
-  TrackEventCategory& operator=(const TrackEventCategory&);
-  bool operator==(const TrackEventCategory&) const;
-  bool operator!=(const TrackEventCategory& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_name() const { return _has_field_[1]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
-
-  bool has_description() const { return _has_field_[2]; }
-  const std::string& description() const { return description_; }
-  void set_description(const std::string& value) { description_ = value; _has_field_.set(2); }
-
-  const std::vector<std::string>& tags() const { return tags_; }
-  std::vector<std::string>* mutable_tags() { return &tags_; }
-  int tags_size() const { return static_cast<int>(tags_.size()); }
-  void clear_tags() { tags_.clear(); }
-  void add_tags(std::string value) { tags_.emplace_back(value); }
-  std::string* add_tags() { tags_.emplace_back(); return &tags_.back(); }
+std::vector<uint8_t> FtraceDescriptor_AtraceCategory::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
- private:
-  std::string name_{};
-  std::string description_{};
-  std::vector<std::string> tags_;
+void FtraceDescriptor_AtraceCategory::Serialize(::protozero::Message* msg) const {
+  // Field 1: name
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  // Field 2: description
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeString(2, description_, msg);
+  }
 
-  std::bitset<4> _has_field_{};
-};
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_TRACK_EVENT_DESCRIPTOR_PROTO_CPP_H_
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/common/gpu_counter_descriptor.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -17534,47 +17216,37 @@ class PERFETTO_EXPORT_COMPONENT TrackEventCategory : public ::protozero::CppMess
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/common/tracing_service_state.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/common/data_source_descriptor.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/common/track_event_descriptor.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/common/gpu_counter_descriptor.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/common/ftrace_descriptor.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-TracingServiceState::TracingServiceState() = default;
-TracingServiceState::~TracingServiceState() = default;
-TracingServiceState::TracingServiceState(const TracingServiceState&) = default;
-TracingServiceState& TracingServiceState::operator=(const TracingServiceState&) = default;
-TracingServiceState::TracingServiceState(TracingServiceState&&) noexcept = default;
-TracingServiceState& TracingServiceState::operator=(TracingServiceState&&) = default;
+GpuCounterDescriptor::GpuCounterDescriptor() = default;
+GpuCounterDescriptor::~GpuCounterDescriptor() = default;
+GpuCounterDescriptor::GpuCounterDescriptor(const GpuCounterDescriptor&) = default;
+GpuCounterDescriptor& GpuCounterDescriptor::operator=(const GpuCounterDescriptor&) = default;
+GpuCounterDescriptor::GpuCounterDescriptor(GpuCounterDescriptor&&) noexcept = default;
+GpuCounterDescriptor& GpuCounterDescriptor::operator=(GpuCounterDescriptor&&) = default;
 
-bool TracingServiceState::operator==(const TracingServiceState& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && producers_ == other.producers_
-   && data_sources_ == other.data_sources_
-   && tracing_sessions_ == other.tracing_sessions_
-   && supports_tracing_sessions_ == other.supports_tracing_sessions_
-   && num_sessions_ == other.num_sessions_
-   && num_sessions_started_ == other.num_sessions_started_
-   && tracing_service_version_ == other.tracing_service_version_;
+bool GpuCounterDescriptor::operator==(const GpuCounterDescriptor& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(specs_, other.specs_)
+   && ::protozero::internal::gen_helpers::EqualsField(blocks_, other.blocks_)
+   && ::protozero::internal::gen_helpers::EqualsField(min_sampling_period_ns_, other.min_sampling_period_ns_)
+   && ::protozero::internal::gen_helpers::EqualsField(max_sampling_period_ns_, other.max_sampling_period_ns_)
+   && ::protozero::internal::gen_helpers::EqualsField(supports_instrumented_sampling_, other.supports_instrumented_sampling_);
 }
 
-int TracingServiceState::producers_size() const { return static_cast<int>(producers_.size()); }
-void TracingServiceState::clear_producers() { producers_.clear(); }
-TracingServiceState_Producer* TracingServiceState::add_producers() { producers_.emplace_back(); return &producers_.back(); }
-int TracingServiceState::data_sources_size() const { return static_cast<int>(data_sources_.size()); }
-void TracingServiceState::clear_data_sources() { data_sources_.clear(); }
-TracingServiceState_DataSource* TracingServiceState::add_data_sources() { data_sources_.emplace_back(); return &data_sources_.back(); }
-int TracingServiceState::tracing_sessions_size() const { return static_cast<int>(tracing_sessions_.size()); }
-void TracingServiceState::clear_tracing_sessions() { tracing_sessions_.clear(); }
-TracingServiceState_TracingSession* TracingServiceState::add_tracing_sessions() { tracing_sessions_.emplace_back(); return &tracing_sessions_.back(); }
-bool TracingServiceState::ParseFromArray(const void* raw, size_t size) {
-  producers_.clear();
-  data_sources_.clear();
-  tracing_sessions_.clear();
+int GpuCounterDescriptor::specs_size() const { return static_cast<int>(specs_.size()); }
+void GpuCounterDescriptor::clear_specs() { specs_.clear(); }
+GpuCounterDescriptor_GpuCounterSpec* GpuCounterDescriptor::add_specs() { specs_.emplace_back(); return &specs_.back(); }
+int GpuCounterDescriptor::blocks_size() const { return static_cast<int>(blocks_.size()); }
+void GpuCounterDescriptor::clear_blocks() { blocks_.clear(); }
+GpuCounterDescriptor_GpuCounterBlock* GpuCounterDescriptor::add_blocks() { blocks_.emplace_back(); return &blocks_.back(); }
+bool GpuCounterDescriptor::ParseFromArray(const void* raw, size_t size) {
+  specs_.clear();
+  blocks_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -17584,29 +17256,22 @@ bool TracingServiceState::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* producers */:
-        producers_.emplace_back();
-        producers_.back().ParseFromArray(field.data(), field.size());
-        break;
-      case 2 /* data_sources */:
-        data_sources_.emplace_back();
-        data_sources_.back().ParseFromArray(field.data(), field.size());
-        break;
-      case 6 /* tracing_sessions */:
-        tracing_sessions_.emplace_back();
-        tracing_sessions_.back().ParseFromArray(field.data(), field.size());
+      case 1 /* specs */:
+        specs_.emplace_back();
+        specs_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 7 /* supports_tracing_sessions */:
-        field.get(&supports_tracing_sessions_);
+      case 2 /* blocks */:
+        blocks_.emplace_back();
+        blocks_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 3 /* num_sessions */:
-        field.get(&num_sessions_);
+      case 3 /* min_sampling_period_ns */:
+        field.get(&min_sampling_period_ns_);
         break;
-      case 4 /* num_sessions_started */:
-        field.get(&num_sessions_started_);
+      case 4 /* max_sampling_period_ns */:
+        field.get(&max_sampling_period_ns_);
         break;
-      case 5 /* tracing_service_version */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &tracing_service_version_);
+      case 5 /* supports_instrumented_sampling */:
+        field.get(&supports_instrumented_sampling_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -17616,79 +17281,66 @@ bool TracingServiceState::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TracingServiceState::SerializeAsString() const {
+std::string GpuCounterDescriptor::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TracingServiceState::SerializeAsArray() const {
+std::vector<uint8_t> GpuCounterDescriptor::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TracingServiceState::Serialize(::protozero::Message* msg) const {
-  // Field 1: producers
-  for (auto& it : producers_) {
+void GpuCounterDescriptor::Serialize(::protozero::Message* msg) const {
+  // Field 1: specs
+  for (auto& it : specs_) {
     it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
   }
 
-  // Field 2: data_sources
-  for (auto& it : data_sources_) {
+  // Field 2: blocks
+  for (auto& it : blocks_) {
     it.Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
   }
 
-  // Field 6: tracing_sessions
-  for (auto& it : tracing_sessions_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(6));
-  }
-
-  // Field 7: supports_tracing_sessions
-  if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(7, supports_tracing_sessions_, msg);
-  }
-
-  // Field 3: num_sessions
+  // Field 3: min_sampling_period_ns
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, num_sessions_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, min_sampling_period_ns_, msg);
   }
 
-  // Field 4: num_sessions_started
+  // Field 4: max_sampling_period_ns
   if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, num_sessions_started_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, max_sampling_period_ns_, msg);
   }
 
-  // Field 5: tracing_service_version
+  // Field 5: supports_instrumented_sampling
   if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeString(5, tracing_service_version_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, supports_instrumented_sampling_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-TracingServiceState_TracingSession::TracingServiceState_TracingSession() = default;
-TracingServiceState_TracingSession::~TracingServiceState_TracingSession() = default;
-TracingServiceState_TracingSession::TracingServiceState_TracingSession(const TracingServiceState_TracingSession&) = default;
-TracingServiceState_TracingSession& TracingServiceState_TracingSession::operator=(const TracingServiceState_TracingSession&) = default;
-TracingServiceState_TracingSession::TracingServiceState_TracingSession(TracingServiceState_TracingSession&&) noexcept = default;
-TracingServiceState_TracingSession& TracingServiceState_TracingSession::operator=(TracingServiceState_TracingSession&&) = default;
+GpuCounterDescriptor_GpuCounterBlock::GpuCounterDescriptor_GpuCounterBlock() = default;
+GpuCounterDescriptor_GpuCounterBlock::~GpuCounterDescriptor_GpuCounterBlock() = default;
+GpuCounterDescriptor_GpuCounterBlock::GpuCounterDescriptor_GpuCounterBlock(const GpuCounterDescriptor_GpuCounterBlock&) = default;
+GpuCounterDescriptor_GpuCounterBlock& GpuCounterDescriptor_GpuCounterBlock::operator=(const GpuCounterDescriptor_GpuCounterBlock&) = default;
+GpuCounterDescriptor_GpuCounterBlock::GpuCounterDescriptor_GpuCounterBlock(GpuCounterDescriptor_GpuCounterBlock&&) noexcept = default;
+GpuCounterDescriptor_GpuCounterBlock& GpuCounterDescriptor_GpuCounterBlock::operator=(GpuCounterDescriptor_GpuCounterBlock&&) = default;
 
-bool TracingServiceState_TracingSession::operator==(const TracingServiceState_TracingSession& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && id_ == other.id_
-   && consumer_uid_ == other.consumer_uid_
-   && state_ == other.state_
-   && unique_session_name_ == other.unique_session_name_
-   && buffer_size_kb_ == other.buffer_size_kb_
-   && duration_ms_ == other.duration_ms_
-   && num_data_sources_ == other.num_data_sources_
-   && start_realtime_ns_ == other.start_realtime_ns_;
+bool GpuCounterDescriptor_GpuCounterBlock::operator==(const GpuCounterDescriptor_GpuCounterBlock& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(block_id_, other.block_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(block_capacity_, other.block_capacity_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(description_, other.description_)
+   && ::protozero::internal::gen_helpers::EqualsField(counter_ids_, other.counter_ids_);
 }
 
-bool TracingServiceState_TracingSession::ParseFromArray(const void* raw, size_t size) {
-  buffer_size_kb_.clear();
+bool GpuCounterDescriptor_GpuCounterBlock::ParseFromArray(const void* raw, size_t size) {
+  counter_ids_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -17698,30 +17350,21 @@ bool TracingServiceState_TracingSession::ParseFromArray(const void* raw, size_t
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* id */:
-        field.get(&id_);
-        break;
-      case 2 /* consumer_uid */:
-        field.get(&consumer_uid_);
-        break;
-      case 3 /* state */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &state_);
-        break;
-      case 4 /* unique_session_name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &unique_session_name_);
+      case 1 /* block_id */:
+        field.get(&block_id_);
         break;
-      case 5 /* buffer_size_kb */:
-        buffer_size_kb_.emplace_back();
-        field.get(&buffer_size_kb_.back());
+      case 2 /* block_capacity */:
+        field.get(&block_capacity_);
         break;
-      case 6 /* duration_ms */:
-        field.get(&duration_ms_);
+      case 3 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
         break;
-      case 7 /* num_data_sources */:
-        field.get(&num_data_sources_);
+      case 4 /* description */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &description_);
         break;
-      case 8 /* start_realtime_ns */:
-        field.get(&start_realtime_ns_);
+      case 5 /* counter_ids */:
+        counter_ids_.emplace_back();
+        field.get(&counter_ids_.back());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -17731,77 +17374,72 @@ bool TracingServiceState_TracingSession::ParseFromArray(const void* raw, size_t
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TracingServiceState_TracingSession::SerializeAsString() const {
+std::string GpuCounterDescriptor_GpuCounterBlock::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TracingServiceState_TracingSession::SerializeAsArray() const {
+std::vector<uint8_t> GpuCounterDescriptor_GpuCounterBlock::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TracingServiceState_TracingSession::Serialize(::protozero::Message* msg) const {
-  // Field 1: id
+void GpuCounterDescriptor_GpuCounterBlock::Serialize(::protozero::Message* msg) const {
+  // Field 1: block_id
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, id_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, block_id_, msg);
   }
 
-  // Field 2: consumer_uid
+  // Field 2: block_capacity
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, consumer_uid_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, block_capacity_, msg);
   }
 
-  // Field 3: state
+  // Field 3: name
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeString(3, state_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(3, name_, msg);
   }
 
-  // Field 4: unique_session_name
+  // Field 4: description
   if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeString(4, unique_session_name_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(4, description_, msg);
   }
 
-  // Field 5: buffer_size_kb
-  for (auto& it : buffer_size_kb_) {
+  // Field 5: counter_ids
+  for (auto& it : counter_ids_) {
     ::protozero::internal::gen_helpers::SerializeVarInt(5, it, msg);
   }
 
-  // Field 6: duration_ms
-  if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(6, duration_ms_, msg);
-  }
-
-  // Field 7: num_data_sources
-  if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(7, num_data_sources_, msg);
-  }
-
-  // Field 8: start_realtime_ns
-  if (_has_field_[8]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(8, start_realtime_ns_, msg);
-  }
-
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-TracingServiceState_DataSource::TracingServiceState_DataSource() = default;
-TracingServiceState_DataSource::~TracingServiceState_DataSource() = default;
-TracingServiceState_DataSource::TracingServiceState_DataSource(const TracingServiceState_DataSource&) = default;
-TracingServiceState_DataSource& TracingServiceState_DataSource::operator=(const TracingServiceState_DataSource&) = default;
-TracingServiceState_DataSource::TracingServiceState_DataSource(TracingServiceState_DataSource&&) noexcept = default;
-TracingServiceState_DataSource& TracingServiceState_DataSource::operator=(TracingServiceState_DataSource&&) = default;
+GpuCounterDescriptor_GpuCounterSpec::GpuCounterDescriptor_GpuCounterSpec() = default;
+GpuCounterDescriptor_GpuCounterSpec::~GpuCounterDescriptor_GpuCounterSpec() = default;
+GpuCounterDescriptor_GpuCounterSpec::GpuCounterDescriptor_GpuCounterSpec(const GpuCounterDescriptor_GpuCounterSpec&) = default;
+GpuCounterDescriptor_GpuCounterSpec& GpuCounterDescriptor_GpuCounterSpec::operator=(const GpuCounterDescriptor_GpuCounterSpec&) = default;
+GpuCounterDescriptor_GpuCounterSpec::GpuCounterDescriptor_GpuCounterSpec(GpuCounterDescriptor_GpuCounterSpec&&) noexcept = default;
+GpuCounterDescriptor_GpuCounterSpec& GpuCounterDescriptor_GpuCounterSpec::operator=(GpuCounterDescriptor_GpuCounterSpec&&) = default;
 
-bool TracingServiceState_DataSource::operator==(const TracingServiceState_DataSource& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && ds_descriptor_ == other.ds_descriptor_
-   && producer_id_ == other.producer_id_;
+bool GpuCounterDescriptor_GpuCounterSpec::operator==(const GpuCounterDescriptor_GpuCounterSpec& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(counter_id_, other.counter_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(description_, other.description_)
+   && ::protozero::internal::gen_helpers::EqualsField(int_peak_value_, other.int_peak_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(double_peak_value_, other.double_peak_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(numerator_units_, other.numerator_units_)
+   && ::protozero::internal::gen_helpers::EqualsField(denominator_units_, other.denominator_units_)
+   && ::protozero::internal::gen_helpers::EqualsField(select_by_default_, other.select_by_default_)
+   && ::protozero::internal::gen_helpers::EqualsField(groups_, other.groups_);
 }
 
-bool TracingServiceState_DataSource::ParseFromArray(const void* raw, size_t size) {
+bool GpuCounterDescriptor_GpuCounterSpec::ParseFromArray(const void* raw, size_t size) {
+  numerator_units_.clear();
+  denominator_units_.clear();
+  groups_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -17811,11 +17449,35 @@ bool TracingServiceState_DataSource::ParseFromArray(const void* raw, size_t size
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* ds_descriptor */:
-        (*ds_descriptor_).ParseFromArray(field.data(), field.size());
+      case 1 /* counter_id */:
+        field.get(&counter_id_);
         break;
-      case 2 /* producer_id */:
-        field.get(&producer_id_);
+      case 2 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+        break;
+      case 3 /* description */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &description_);
+        break;
+      case 5 /* int_peak_value */:
+        field.get(&int_peak_value_);
+        break;
+      case 6 /* double_peak_value */:
+        field.get(&double_peak_value_);
+        break;
+      case 7 /* numerator_units */:
+        numerator_units_.emplace_back();
+        field.get(&numerator_units_.back());
+        break;
+      case 8 /* denominator_units */:
+        denominator_units_.emplace_back();
+        field.get(&denominator_units_.back());
+        break;
+      case 9 /* select_by_default */:
+        field.get(&select_by_default_);
+        break;
+      case 10 /* groups */:
+        groups_.emplace_back();
+        field.get(&groups_.back());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -17825,50 +17487,103 @@ bool TracingServiceState_DataSource::ParseFromArray(const void* raw, size_t size
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TracingServiceState_DataSource::SerializeAsString() const {
+std::string GpuCounterDescriptor_GpuCounterSpec::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TracingServiceState_DataSource::SerializeAsArray() const {
+std::vector<uint8_t> GpuCounterDescriptor_GpuCounterSpec::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TracingServiceState_DataSource::Serialize(::protozero::Message* msg) const {
-  // Field 1: ds_descriptor
+void GpuCounterDescriptor_GpuCounterSpec::Serialize(::protozero::Message* msg) const {
+  // Field 1: counter_id
   if (_has_field_[1]) {
-    (*ds_descriptor_).Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, counter_id_, msg);
   }
 
-  // Field 2: producer_id
+  // Field 2: name
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, producer_id_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(2, name_, msg);
+  }
+
+  // Field 3: description
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeString(3, description_, msg);
+  }
+
+  // Field 5: int_peak_value
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, int_peak_value_, msg);
+  }
+
+  // Field 6: double_peak_value
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeFixed(6, double_peak_value_, msg);
+  }
+
+  // Field 7: numerator_units
+  for (auto& it : numerator_units_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(7, it, msg);
+  }
+
+  // Field 8: denominator_units
+  for (auto& it : denominator_units_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(8, it, msg);
+  }
+
+  // Field 9: select_by_default
+  if (_has_field_[9]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(9, select_by_default_, msg);
+  }
+
+  // Field 10: groups
+  for (auto& it : groups_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(10, it, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/common/interceptor_descriptor.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/common/interceptor_descriptor.gen.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-TracingServiceState_Producer::TracingServiceState_Producer() = default;
-TracingServiceState_Producer::~TracingServiceState_Producer() = default;
-TracingServiceState_Producer::TracingServiceState_Producer(const TracingServiceState_Producer&) = default;
-TracingServiceState_Producer& TracingServiceState_Producer::operator=(const TracingServiceState_Producer&) = default;
-TracingServiceState_Producer::TracingServiceState_Producer(TracingServiceState_Producer&&) noexcept = default;
-TracingServiceState_Producer& TracingServiceState_Producer::operator=(TracingServiceState_Producer&&) = default;
+InterceptorDescriptor::InterceptorDescriptor() = default;
+InterceptorDescriptor::~InterceptorDescriptor() = default;
+InterceptorDescriptor::InterceptorDescriptor(const InterceptorDescriptor&) = default;
+InterceptorDescriptor& InterceptorDescriptor::operator=(const InterceptorDescriptor&) = default;
+InterceptorDescriptor::InterceptorDescriptor(InterceptorDescriptor&&) noexcept = default;
+InterceptorDescriptor& InterceptorDescriptor::operator=(InterceptorDescriptor&&) = default;
 
-bool TracingServiceState_Producer::operator==(const TracingServiceState_Producer& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && id_ == other.id_
-   && name_ == other.name_
-   && pid_ == other.pid_
-   && uid_ == other.uid_
-   && sdk_version_ == other.sdk_version_;
+bool InterceptorDescriptor::operator==(const InterceptorDescriptor& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_);
 }
 
-bool TracingServiceState_Producer::ParseFromArray(const void* raw, size_t size) {
+bool InterceptorDescriptor::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -17878,21 +17593,9 @@ bool TracingServiceState_Producer::ParseFromArray(const void* raw, size_t size)
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* id */:
-        field.get(&id_);
-        break;
-      case 2 /* name */:
+      case 1 /* name */:
         ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
         break;
-      case 5 /* pid */:
-        field.get(&pid_);
-        break;
-      case 3 /* uid */:
-        field.get(&uid_);
-        break;
-      case 4 /* sdk_version */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &sdk_version_);
-        break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
         break;
@@ -17901,42 +17604,22 @@ bool TracingServiceState_Producer::ParseFromArray(const void* raw, size_t size)
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TracingServiceState_Producer::SerializeAsString() const {
+std::string InterceptorDescriptor::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TracingServiceState_Producer::SerializeAsArray() const {
+std::vector<uint8_t> InterceptorDescriptor::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TracingServiceState_Producer::Serialize(::protozero::Message* msg) const {
-  // Field 1: id
+void InterceptorDescriptor::Serialize(::protozero::Message* msg) const {
+  // Field 1: name
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, id_, msg);
-  }
-
-  // Field 2: name
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeString(2, name_, msg);
-  }
-
-  // Field 5: pid
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(5, pid_, msg);
-  }
-
-  // Field 3: uid
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, uid_, msg);
-  }
-
-  // Field 4: sdk_version
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeString(4, sdk_version_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -17948,7 +17631,7 @@ void TracingServiceState_Producer::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/common/track_event_descriptor.gen.cc
+// gen_amalgamated begin source: gen/protos/perfetto/common/observable_events.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -17959,29 +17642,31 @@ void TracingServiceState_Producer::Serialize(::protozero::Message* msg) const {
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/common/track_event_descriptor.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/observable_events.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-TrackEventDescriptor::TrackEventDescriptor() = default;
-TrackEventDescriptor::~TrackEventDescriptor() = default;
-TrackEventDescriptor::TrackEventDescriptor(const TrackEventDescriptor&) = default;
-TrackEventDescriptor& TrackEventDescriptor::operator=(const TrackEventDescriptor&) = default;
-TrackEventDescriptor::TrackEventDescriptor(TrackEventDescriptor&&) noexcept = default;
-TrackEventDescriptor& TrackEventDescriptor::operator=(TrackEventDescriptor&&) = default;
+ObservableEvents::ObservableEvents() = default;
+ObservableEvents::~ObservableEvents() = default;
+ObservableEvents::ObservableEvents(const ObservableEvents&) = default;
+ObservableEvents& ObservableEvents::operator=(const ObservableEvents&) = default;
+ObservableEvents::ObservableEvents(ObservableEvents&&) noexcept = default;
+ObservableEvents& ObservableEvents::operator=(ObservableEvents&&) = default;
 
-bool TrackEventDescriptor::operator==(const TrackEventDescriptor& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && available_categories_ == other.available_categories_;
+bool ObservableEvents::operator==(const ObservableEvents& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(instance_state_changes_, other.instance_state_changes_)
+   && ::protozero::internal::gen_helpers::EqualsField(all_data_sources_started_, other.all_data_sources_started_)
+   && ::protozero::internal::gen_helpers::EqualsField(clone_trigger_hit_, other.clone_trigger_hit_);
 }
 
-int TrackEventDescriptor::available_categories_size() const { return static_cast<int>(available_categories_.size()); }
-void TrackEventDescriptor::clear_available_categories() { available_categories_.clear(); }
-TrackEventCategory* TrackEventDescriptor::add_available_categories() { available_categories_.emplace_back(); return &available_categories_.back(); }
-bool TrackEventDescriptor::ParseFromArray(const void* raw, size_t size) {
-  available_categories_.clear();
+int ObservableEvents::instance_state_changes_size() const { return static_cast<int>(instance_state_changes_.size()); }
+void ObservableEvents::clear_instance_state_changes() { instance_state_changes_.clear(); }
+ObservableEvents_DataSourceInstanceStateChange* ObservableEvents::add_instance_state_changes() { instance_state_changes_.emplace_back(); return &instance_state_changes_.back(); }
+bool ObservableEvents::ParseFromArray(const void* raw, size_t size) {
+  instance_state_changes_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -17991,9 +17676,15 @@ bool TrackEventDescriptor::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* available_categories */:
-        available_categories_.emplace_back();
-        available_categories_.back().ParseFromArray(field.data(), field.size());
+      case 1 /* instance_state_changes */:
+        instance_state_changes_.emplace_back();
+        instance_state_changes_.back().ParseFromArray(field.data(), field.size());
+        break;
+      case 2 /* all_data_sources_started */:
+        field.get(&all_data_sources_started_);
+        break;
+      case 3 /* clone_trigger_hit */:
+        (*clone_trigger_hit_).ParseFromArray(field.data(), field.size());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -18003,44 +17694,56 @@ bool TrackEventDescriptor::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TrackEventDescriptor::SerializeAsString() const {
+std::string ObservableEvents::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TrackEventDescriptor::SerializeAsArray() const {
+std::vector<uint8_t> ObservableEvents::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TrackEventDescriptor::Serialize(::protozero::Message* msg) const {
-  // Field 1: available_categories
-  for (auto& it : available_categories_) {
+void ObservableEvents::Serialize(::protozero::Message* msg) const {
+  // Field 1: instance_state_changes
+  for (auto& it : instance_state_changes_) {
     it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
   }
 
+  // Field 2: all_data_sources_started
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, all_data_sources_started_, msg);
+  }
+
+  // Field 3: clone_trigger_hit
+  if (_has_field_[3]) {
+    (*clone_trigger_hit_).Serialize(msg->BeginNestedMessage<::protozero::Message>(3));
+  }
+
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-TrackEventCategory::TrackEventCategory() = default;
-TrackEventCategory::~TrackEventCategory() = default;
-TrackEventCategory::TrackEventCategory(const TrackEventCategory&) = default;
-TrackEventCategory& TrackEventCategory::operator=(const TrackEventCategory&) = default;
-TrackEventCategory::TrackEventCategory(TrackEventCategory&&) noexcept = default;
-TrackEventCategory& TrackEventCategory::operator=(TrackEventCategory&&) = default;
+ObservableEvents_CloneTriggerHit::ObservableEvents_CloneTriggerHit() = default;
+ObservableEvents_CloneTriggerHit::~ObservableEvents_CloneTriggerHit() = default;
+ObservableEvents_CloneTriggerHit::ObservableEvents_CloneTriggerHit(const ObservableEvents_CloneTriggerHit&) = default;
+ObservableEvents_CloneTriggerHit& ObservableEvents_CloneTriggerHit::operator=(const ObservableEvents_CloneTriggerHit&) = default;
+ObservableEvents_CloneTriggerHit::ObservableEvents_CloneTriggerHit(ObservableEvents_CloneTriggerHit&&) noexcept = default;
+ObservableEvents_CloneTriggerHit& ObservableEvents_CloneTriggerHit::operator=(ObservableEvents_CloneTriggerHit&&) = default;
 
-bool TrackEventCategory::operator==(const TrackEventCategory& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && name_ == other.name_
-   && description_ == other.description_
-   && tags_ == other.tags_;
+bool ObservableEvents_CloneTriggerHit::operator==(const ObservableEvents_CloneTriggerHit& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(tracing_session_id_, other.tracing_session_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(trigger_name_, other.trigger_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(producer_name_, other.producer_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(producer_uid_, other.producer_uid_)
+   && ::protozero::internal::gen_helpers::EqualsField(boot_time_ns_, other.boot_time_ns_)
+   && ::protozero::internal::gen_helpers::EqualsField(trigger_delay_ms_, other.trigger_delay_ms_);
 }
 
-bool TrackEventCategory::ParseFromArray(const void* raw, size_t size) {
-  tags_.clear();
+bool ObservableEvents_CloneTriggerHit::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -18050,15 +17753,23 @@ bool TrackEventCategory::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+      case 1 /* tracing_session_id */:
+        field.get(&tracing_session_id_);
         break;
-      case 2 /* description */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &description_);
+      case 2 /* trigger_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &trigger_name_);
         break;
-      case 3 /* tags */:
-        tags_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &tags_.back());
+      case 3 /* producer_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &producer_name_);
+        break;
+      case 4 /* producer_uid */:
+        field.get(&producer_uid_);
+        break;
+      case 5 /* boot_time_ns */:
+        field.get(&boot_time_ns_);
+        break;
+      case 6 /* trigger_delay_ms */:
+        field.get(&trigger_delay_ms_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -18068,147 +17779,68 @@ bool TrackEventCategory::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TrackEventCategory::SerializeAsString() const {
+std::string ObservableEvents_CloneTriggerHit::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TrackEventCategory::SerializeAsArray() const {
+std::vector<uint8_t> ObservableEvents_CloneTriggerHit::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TrackEventCategory::Serialize(::protozero::Message* msg) const {
-  // Field 1: name
+void ObservableEvents_CloneTriggerHit::Serialize(::protozero::Message* msg) const {
+  // Field 1: tracing_session_id
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, tracing_session_id_, msg);
   }
 
-  // Field 2: description
+  // Field 2: trigger_name
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeString(2, description_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(2, trigger_name_, msg);
   }
 
-  // Field 3: tags
-  for (auto& it : tags_) {
-    ::protozero::internal::gen_helpers::SerializeString(3, it, msg);
+  // Field 3: producer_name
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeString(3, producer_name_, msg);
   }
 
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
-}
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/android/android_game_intervention_list_config.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_game_intervention_list_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_GAME_INTERVENTION_LIST_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_GAME_INTERVENTION_LIST_CONFIG_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class AndroidGameInterventionListConfig;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT AndroidGameInterventionListConfig : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kPackageNameFilterFieldNumber = 1,
-  };
-
-  AndroidGameInterventionListConfig();
-  ~AndroidGameInterventionListConfig() override;
-  AndroidGameInterventionListConfig(AndroidGameInterventionListConfig&&) noexcept;
-  AndroidGameInterventionListConfig& operator=(AndroidGameInterventionListConfig&&);
-  AndroidGameInterventionListConfig(const AndroidGameInterventionListConfig&);
-  AndroidGameInterventionListConfig& operator=(const AndroidGameInterventionListConfig&);
-  bool operator==(const AndroidGameInterventionListConfig&) const;
-  bool operator!=(const AndroidGameInterventionListConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<std::string>& package_name_filter() const { return package_name_filter_; }
-  std::vector<std::string>* mutable_package_name_filter() { return &package_name_filter_; }
-  int package_name_filter_size() const { return static_cast<int>(package_name_filter_.size()); }
-  void clear_package_name_filter() { package_name_filter_.clear(); }
-  void add_package_name_filter(std::string value) { package_name_filter_.emplace_back(value); }
-  std::string* add_package_name_filter() { package_name_filter_.emplace_back(); return &package_name_filter_.back(); }
-
- private:
-  std::vector<std::string> package_name_filter_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  // Field 4: producer_uid
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, producer_uid_, msg);
+  }
 
-  std::bitset<2> _has_field_{};
-};
+  // Field 5: boot_time_ns
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, boot_time_ns_, msg);
+  }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  // Field 6: trigger_delay_ms
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, trigger_delay_ms_, msg);
+  }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_GAME_INTERVENTION_LIST_CONFIG_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_game_intervention_list_config.gen.h"
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
 
-AndroidGameInterventionListConfig::AndroidGameInterventionListConfig() = default;
-AndroidGameInterventionListConfig::~AndroidGameInterventionListConfig() = default;
-AndroidGameInterventionListConfig::AndroidGameInterventionListConfig(const AndroidGameInterventionListConfig&) = default;
-AndroidGameInterventionListConfig& AndroidGameInterventionListConfig::operator=(const AndroidGameInterventionListConfig&) = default;
-AndroidGameInterventionListConfig::AndroidGameInterventionListConfig(AndroidGameInterventionListConfig&&) noexcept = default;
-AndroidGameInterventionListConfig& AndroidGameInterventionListConfig::operator=(AndroidGameInterventionListConfig&&) = default;
+ObservableEvents_DataSourceInstanceStateChange::ObservableEvents_DataSourceInstanceStateChange() = default;
+ObservableEvents_DataSourceInstanceStateChange::~ObservableEvents_DataSourceInstanceStateChange() = default;
+ObservableEvents_DataSourceInstanceStateChange::ObservableEvents_DataSourceInstanceStateChange(const ObservableEvents_DataSourceInstanceStateChange&) = default;
+ObservableEvents_DataSourceInstanceStateChange& ObservableEvents_DataSourceInstanceStateChange::operator=(const ObservableEvents_DataSourceInstanceStateChange&) = default;
+ObservableEvents_DataSourceInstanceStateChange::ObservableEvents_DataSourceInstanceStateChange(ObservableEvents_DataSourceInstanceStateChange&&) noexcept = default;
+ObservableEvents_DataSourceInstanceStateChange& ObservableEvents_DataSourceInstanceStateChange::operator=(ObservableEvents_DataSourceInstanceStateChange&&) = default;
 
-bool AndroidGameInterventionListConfig::operator==(const AndroidGameInterventionListConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && package_name_filter_ == other.package_name_filter_;
+bool ObservableEvents_DataSourceInstanceStateChange::operator==(const ObservableEvents_DataSourceInstanceStateChange& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(producer_name_, other.producer_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(data_source_name_, other.data_source_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(state_, other.state_);
 }
 
-bool AndroidGameInterventionListConfig::ParseFromArray(const void* raw, size_t size) {
-  package_name_filter_.clear();
+bool ObservableEvents_DataSourceInstanceStateChange::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -18218,9 +17850,14 @@ bool AndroidGameInterventionListConfig::ParseFromArray(const void* raw, size_t s
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* package_name_filter */:
-        package_name_filter_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &package_name_filter_.back());
+      case 1 /* producer_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &producer_name_);
+        break;
+      case 2 /* data_source_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &data_source_name_);
+        break;
+      case 3 /* state */:
+        field.get(&state_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -18230,22 +17867,32 @@ bool AndroidGameInterventionListConfig::ParseFromArray(const void* raw, size_t s
   return !packed_error && !dec.bytes_left();
 }
 
-std::string AndroidGameInterventionListConfig::SerializeAsString() const {
+std::string ObservableEvents_DataSourceInstanceStateChange::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> AndroidGameInterventionListConfig::SerializeAsArray() const {
+std::vector<uint8_t> ObservableEvents_DataSourceInstanceStateChange::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void AndroidGameInterventionListConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: package_name_filter
-  for (auto& it : package_name_filter_) {
-    ::protozero::internal::gen_helpers::SerializeString(1, it, msg);
+void ObservableEvents_DataSourceInstanceStateChange::Serialize(::protozero::Message* msg) const {
+  // Field 1: producer_name
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeString(1, producer_name_, msg);
+  }
+
+  // Field 2: data_source_name
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeString(2, data_source_name_, msg);
+  }
+
+  // Field 3: state
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, state_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -18257,97 +17904,7 @@ void AndroidGameInterventionListConfig::Serialize(::protozero::Message* msg) con
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/android/android_log_config.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_log_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_LOG_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_LOG_CONFIG_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class AndroidLogConfig;
-enum AndroidLogId : int;
-enum AndroidLogPriority : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT AndroidLogConfig : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kLogIdsFieldNumber = 1,
-    kMinPrioFieldNumber = 3,
-    kFilterTagsFieldNumber = 4,
-  };
-
-  AndroidLogConfig();
-  ~AndroidLogConfig() override;
-  AndroidLogConfig(AndroidLogConfig&&) noexcept;
-  AndroidLogConfig& operator=(AndroidLogConfig&&);
-  AndroidLogConfig(const AndroidLogConfig&);
-  AndroidLogConfig& operator=(const AndroidLogConfig&);
-  bool operator==(const AndroidLogConfig&) const;
-  bool operator!=(const AndroidLogConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<AndroidLogId>& log_ids() const { return log_ids_; }
-  std::vector<AndroidLogId>* mutable_log_ids() { return &log_ids_; }
-  int log_ids_size() const { return static_cast<int>(log_ids_.size()); }
-  void clear_log_ids() { log_ids_.clear(); }
-  void add_log_ids(AndroidLogId value) { log_ids_.emplace_back(value); }
-  AndroidLogId* add_log_ids() { log_ids_.emplace_back(); return &log_ids_.back(); }
-
-  bool has_min_prio() const { return _has_field_[3]; }
-  AndroidLogPriority min_prio() const { return min_prio_; }
-  void set_min_prio(AndroidLogPriority value) { min_prio_ = value; _has_field_.set(3); }
-
-  const std::vector<std::string>& filter_tags() const { return filter_tags_; }
-  std::vector<std::string>* mutable_filter_tags() { return &filter_tags_; }
-  int filter_tags_size() const { return static_cast<int>(filter_tags_.size()); }
-  void clear_filter_tags() { filter_tags_.clear(); }
-  void add_filter_tags(std::string value) { filter_tags_.emplace_back(value); }
-  std::string* add_filter_tags() { filter_tags_.emplace_back(); return &filter_tags_.back(); }
-
- private:
-  std::vector<AndroidLogId> log_ids_;
-  AndroidLogPriority min_prio_{};
-  std::vector<std::string> filter_tags_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<5> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_LOG_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin source: gen/protos/perfetto/common/perf_events.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -18358,30 +17915,30 @@ class PERFETTO_EXPORT_COMPONENT AndroidLogConfig : public ::protozero::CppMessag
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_log_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/common/android_log_constants.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/perf_events.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-AndroidLogConfig::AndroidLogConfig() = default;
-AndroidLogConfig::~AndroidLogConfig() = default;
-AndroidLogConfig::AndroidLogConfig(const AndroidLogConfig&) = default;
-AndroidLogConfig& AndroidLogConfig::operator=(const AndroidLogConfig&) = default;
-AndroidLogConfig::AndroidLogConfig(AndroidLogConfig&&) noexcept = default;
-AndroidLogConfig& AndroidLogConfig::operator=(AndroidLogConfig&&) = default;
+FollowerEvent::FollowerEvent() = default;
+FollowerEvent::~FollowerEvent() = default;
+FollowerEvent::FollowerEvent(const FollowerEvent&) = default;
+FollowerEvent& FollowerEvent::operator=(const FollowerEvent&) = default;
+FollowerEvent::FollowerEvent(FollowerEvent&&) noexcept = default;
+FollowerEvent& FollowerEvent::operator=(FollowerEvent&&) = default;
 
-bool AndroidLogConfig::operator==(const AndroidLogConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && log_ids_ == other.log_ids_
-   && min_prio_ == other.min_prio_
-   && filter_tags_ == other.filter_tags_;
+bool FollowerEvent::operator==(const FollowerEvent& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(counter_, other.counter_)
+   && ::protozero::internal::gen_helpers::EqualsField(tracepoint_, other.tracepoint_)
+   && ::protozero::internal::gen_helpers::EqualsField(raw_event_, other.raw_event_)
+   && ::protozero::internal::gen_helpers::EqualsField(modifiers_, other.modifiers_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_);
 }
 
-bool AndroidLogConfig::ParseFromArray(const void* raw, size_t size) {
-  log_ids_.clear();
-  filter_tags_.clear();
+bool FollowerEvent::ParseFromArray(const void* raw, size_t size) {
+  modifiers_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -18391,16 +17948,21 @@ bool AndroidLogConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* log_ids */:
-        log_ids_.emplace_back();
-        field.get(&log_ids_.back());
+      case 1 /* counter */:
+        field.get(&counter_);
         break;
-      case 3 /* min_prio */:
-        field.get(&min_prio_);
+      case 2 /* tracepoint */:
+        (*tracepoint_).ParseFromArray(field.data(), field.size());
         break;
-      case 4 /* filter_tags */:
-        filter_tags_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &filter_tags_.back());
+      case 3 /* raw_event */:
+        (*raw_event_).ParseFromArray(field.data(), field.size());
+        break;
+      case 5 /* modifiers */:
+        modifiers_.emplace_back();
+        field.get(&modifiers_.back());
+        break;
+      case 4 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -18410,143 +17972,144 @@ bool AndroidLogConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string AndroidLogConfig::SerializeAsString() const {
+std::string FollowerEvent::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> AndroidLogConfig::SerializeAsArray() const {
+std::vector<uint8_t> FollowerEvent::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void AndroidLogConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: log_ids
-  for (auto& it : log_ids_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, it, msg);
+void FollowerEvent::Serialize(::protozero::Message* msg) const {
+  // Field 1: counter
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, counter_, msg);
   }
 
-  // Field 3: min_prio
+  // Field 2: tracepoint
+  if (_has_field_[2]) {
+    (*tracepoint_).Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
+  }
+
+  // Field 3: raw_event
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, min_prio_, msg);
+    (*raw_event_).Serialize(msg->BeginNestedMessage<::protozero::Message>(3));
   }
 
-  // Field 4: filter_tags
-  for (auto& it : filter_tags_) {
-    ::protozero::internal::gen_helpers::SerializeString(4, it, msg);
+  // Field 5: modifiers
+  for (auto& it : modifiers_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, it, msg);
+  }
+
+  // Field 4: name
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeString(4, name_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/android/android_polled_state_config.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_polled_state_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_POLLED_STATE_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_POLLED_STATE_CONFIG_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class AndroidPolledStateConfig;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+PerfEvents_RawEvent::PerfEvents_RawEvent() = default;
+PerfEvents_RawEvent::~PerfEvents_RawEvent() = default;
+PerfEvents_RawEvent::PerfEvents_RawEvent(const PerfEvents_RawEvent&) = default;
+PerfEvents_RawEvent& PerfEvents_RawEvent::operator=(const PerfEvents_RawEvent&) = default;
+PerfEvents_RawEvent::PerfEvents_RawEvent(PerfEvents_RawEvent&&) noexcept = default;
+PerfEvents_RawEvent& PerfEvents_RawEvent::operator=(PerfEvents_RawEvent&&) = default;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+bool PerfEvents_RawEvent::operator==(const PerfEvents_RawEvent& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(type_, other.type_)
+   && ::protozero::internal::gen_helpers::EqualsField(config_, other.config_)
+   && ::protozero::internal::gen_helpers::EqualsField(config1_, other.config1_)
+   && ::protozero::internal::gen_helpers::EqualsField(config2_, other.config2_);
+}
 
-class PERFETTO_EXPORT_COMPONENT AndroidPolledStateConfig : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kPollMsFieldNumber = 1,
-  };
+bool PerfEvents_RawEvent::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  AndroidPolledStateConfig();
-  ~AndroidPolledStateConfig() override;
-  AndroidPolledStateConfig(AndroidPolledStateConfig&&) noexcept;
-  AndroidPolledStateConfig& operator=(AndroidPolledStateConfig&&);
-  AndroidPolledStateConfig(const AndroidPolledStateConfig&);
-  AndroidPolledStateConfig& operator=(const AndroidPolledStateConfig&);
-  bool operator==(const AndroidPolledStateConfig&) const;
-  bool operator!=(const AndroidPolledStateConfig& other) const { return !(*this == other); }
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* type */:
+        field.get(&type_);
+        break;
+      case 2 /* config */:
+        field.get(&config_);
+        break;
+      case 3 /* config1 */:
+        field.get(&config1_);
+        break;
+      case 4 /* config2 */:
+        field.get(&config2_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+std::string PerfEvents_RawEvent::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  bool has_poll_ms() const { return _has_field_[1]; }
-  uint32_t poll_ms() const { return poll_ms_; }
-  void set_poll_ms(uint32_t value) { poll_ms_ = value; _has_field_.set(1); }
+std::vector<uint8_t> PerfEvents_RawEvent::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
- private:
-  uint32_t poll_ms_{};
+void PerfEvents_RawEvent::Serialize(::protozero::Message* msg) const {
+  // Field 1: type
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, type_, msg);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  // Field 2: config
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, config_, msg);
+  }
 
-  std::bitset<2> _has_field_{};
-};
+  // Field 3: config1
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, config1_, msg);
+  }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  // Field 4: config2
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, config2_, msg);
+  }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_POLLED_STATE_CONFIG_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_polled_state_config.gen.h"
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
 
-AndroidPolledStateConfig::AndroidPolledStateConfig() = default;
-AndroidPolledStateConfig::~AndroidPolledStateConfig() = default;
-AndroidPolledStateConfig::AndroidPolledStateConfig(const AndroidPolledStateConfig&) = default;
-AndroidPolledStateConfig& AndroidPolledStateConfig::operator=(const AndroidPolledStateConfig&) = default;
-AndroidPolledStateConfig::AndroidPolledStateConfig(AndroidPolledStateConfig&&) noexcept = default;
-AndroidPolledStateConfig& AndroidPolledStateConfig::operator=(AndroidPolledStateConfig&&) = default;
+PerfEvents_Tracepoint::PerfEvents_Tracepoint() = default;
+PerfEvents_Tracepoint::~PerfEvents_Tracepoint() = default;
+PerfEvents_Tracepoint::PerfEvents_Tracepoint(const PerfEvents_Tracepoint&) = default;
+PerfEvents_Tracepoint& PerfEvents_Tracepoint::operator=(const PerfEvents_Tracepoint&) = default;
+PerfEvents_Tracepoint::PerfEvents_Tracepoint(PerfEvents_Tracepoint&&) noexcept = default;
+PerfEvents_Tracepoint& PerfEvents_Tracepoint::operator=(PerfEvents_Tracepoint&&) = default;
 
-bool AndroidPolledStateConfig::operator==(const AndroidPolledStateConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && poll_ms_ == other.poll_ms_;
+bool PerfEvents_Tracepoint::operator==(const PerfEvents_Tracepoint& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(filter_, other.filter_);
 }
 
-bool AndroidPolledStateConfig::ParseFromArray(const void* raw, size_t size) {
+bool PerfEvents_Tracepoint::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -18556,8 +18119,11 @@ bool AndroidPolledStateConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* poll_ms */:
-        field.get(&poll_ms_);
+      case 1 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+        break;
+      case 2 /* filter */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &filter_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -18567,144 +18133,101 @@ bool AndroidPolledStateConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string AndroidPolledStateConfig::SerializeAsString() const {
+std::string PerfEvents_Tracepoint::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> AndroidPolledStateConfig::SerializeAsArray() const {
+std::vector<uint8_t> PerfEvents_Tracepoint::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void AndroidPolledStateConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: poll_ms
+void PerfEvents_Tracepoint::Serialize(::protozero::Message* msg) const {
+  // Field 1: name
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, poll_ms_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
+  }
+
+  // Field 2: filter
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeString(2, filter_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/android/android_system_property_config.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_system_property_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_SYSTEM_PROPERTY_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_SYSTEM_PROPERTY_CONFIG_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class AndroidSystemPropertyConfig;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
 
-class PERFETTO_EXPORT_COMPONENT AndroidSystemPropertyConfig : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kPollMsFieldNumber = 1,
-    kPropertyNameFieldNumber = 2,
-  };
+PerfEvents::PerfEvents() = default;
+PerfEvents::~PerfEvents() = default;
+PerfEvents::PerfEvents(const PerfEvents&) = default;
+PerfEvents& PerfEvents::operator=(const PerfEvents&) = default;
+PerfEvents::PerfEvents(PerfEvents&&) noexcept = default;
+PerfEvents& PerfEvents::operator=(PerfEvents&&) = default;
 
-  AndroidSystemPropertyConfig();
-  ~AndroidSystemPropertyConfig() override;
-  AndroidSystemPropertyConfig(AndroidSystemPropertyConfig&&) noexcept;
-  AndroidSystemPropertyConfig& operator=(AndroidSystemPropertyConfig&&);
-  AndroidSystemPropertyConfig(const AndroidSystemPropertyConfig&);
-  AndroidSystemPropertyConfig& operator=(const AndroidSystemPropertyConfig&);
-  bool operator==(const AndroidSystemPropertyConfig&) const;
-  bool operator!=(const AndroidSystemPropertyConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_poll_ms() const { return _has_field_[1]; }
-  uint32_t poll_ms() const { return poll_ms_; }
-  void set_poll_ms(uint32_t value) { poll_ms_ = value; _has_field_.set(1); }
-
-  const std::vector<std::string>& property_name() const { return property_name_; }
-  std::vector<std::string>* mutable_property_name() { return &property_name_; }
-  int property_name_size() const { return static_cast<int>(property_name_.size()); }
-  void clear_property_name() { property_name_.clear(); }
-  void add_property_name(std::string value) { property_name_.emplace_back(value); }
-  std::string* add_property_name() { property_name_.emplace_back(); return &property_name_.back(); }
+bool PerfEvents::operator==(const PerfEvents& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
+}
 
- private:
-  uint32_t poll_ms_{};
-  std::vector<std::string> property_name_;
+bool PerfEvents::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-  std::bitset<3> _has_field_{};
-};
+std::string PerfEvents::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+std::vector<uint8_t> PerfEvents::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_SYSTEM_PROPERTY_CONFIG_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_system_property_config.gen.h"
+void PerfEvents::Serialize(::protozero::Message* msg) const {
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
 
-AndroidSystemPropertyConfig::AndroidSystemPropertyConfig() = default;
-AndroidSystemPropertyConfig::~AndroidSystemPropertyConfig() = default;
-AndroidSystemPropertyConfig::AndroidSystemPropertyConfig(const AndroidSystemPropertyConfig&) = default;
-AndroidSystemPropertyConfig& AndroidSystemPropertyConfig::operator=(const AndroidSystemPropertyConfig&) = default;
-AndroidSystemPropertyConfig::AndroidSystemPropertyConfig(AndroidSystemPropertyConfig&&) noexcept = default;
-AndroidSystemPropertyConfig& AndroidSystemPropertyConfig::operator=(AndroidSystemPropertyConfig&&) = default;
+PerfEvents_Timebase::PerfEvents_Timebase() = default;
+PerfEvents_Timebase::~PerfEvents_Timebase() = default;
+PerfEvents_Timebase::PerfEvents_Timebase(const PerfEvents_Timebase&) = default;
+PerfEvents_Timebase& PerfEvents_Timebase::operator=(const PerfEvents_Timebase&) = default;
+PerfEvents_Timebase::PerfEvents_Timebase(PerfEvents_Timebase&&) noexcept = default;
+PerfEvents_Timebase& PerfEvents_Timebase::operator=(PerfEvents_Timebase&&) = default;
 
-bool AndroidSystemPropertyConfig::operator==(const AndroidSystemPropertyConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && poll_ms_ == other.poll_ms_
-   && property_name_ == other.property_name_;
+bool PerfEvents_Timebase::operator==(const PerfEvents_Timebase& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(frequency_, other.frequency_)
+   && ::protozero::internal::gen_helpers::EqualsField(period_, other.period_)
+   && ::protozero::internal::gen_helpers::EqualsField(poll_period_ms_, other.poll_period_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(counter_, other.counter_)
+   && ::protozero::internal::gen_helpers::EqualsField(tracepoint_, other.tracepoint_)
+   && ::protozero::internal::gen_helpers::EqualsField(raw_event_, other.raw_event_)
+   && ::protozero::internal::gen_helpers::EqualsField(modifiers_, other.modifiers_)
+   && ::protozero::internal::gen_helpers::EqualsField(timestamp_clock_, other.timestamp_clock_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_);
 }
 
-bool AndroidSystemPropertyConfig::ParseFromArray(const void* raw, size_t size) {
-  property_name_.clear();
+bool PerfEvents_Timebase::ParseFromArray(const void* raw, size_t size) {
+  modifiers_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -18714,12 +18237,33 @@ bool AndroidSystemPropertyConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* poll_ms */:
-        field.get(&poll_ms_);
+      case 2 /* frequency */:
+        field.get(&frequency_);
         break;
-      case 2 /* property_name */:
-        property_name_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &property_name_.back());
+      case 1 /* period */:
+        field.get(&period_);
+        break;
+      case 6 /* poll_period_ms */:
+        field.get(&poll_period_ms_);
+        break;
+      case 4 /* counter */:
+        field.get(&counter_);
+        break;
+      case 3 /* tracepoint */:
+        (*tracepoint_).ParseFromArray(field.data(), field.size());
+        break;
+      case 5 /* raw_event */:
+        (*raw_event_).ParseFromArray(field.data(), field.size());
+        break;
+      case 12 /* modifiers */:
+        modifiers_.emplace_back();
+        field.get(&modifiers_.back());
+        break;
+      case 11 /* timestamp_clock */:
+        field.get(&timestamp_clock_);
+        break;
+      case 10 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -18729,27 +18273,62 @@ bool AndroidSystemPropertyConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string AndroidSystemPropertyConfig::SerializeAsString() const {
+std::string PerfEvents_Timebase::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> AndroidSystemPropertyConfig::SerializeAsArray() const {
+std::vector<uint8_t> PerfEvents_Timebase::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void AndroidSystemPropertyConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: poll_ms
+void PerfEvents_Timebase::Serialize(::protozero::Message* msg) const {
+  // Field 2: frequency
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, frequency_, msg);
+  }
+
+  // Field 1: period
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, poll_ms_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, period_, msg);
   }
 
-  // Field 2: property_name
-  for (auto& it : property_name_) {
-    ::protozero::internal::gen_helpers::SerializeString(2, it, msg);
+  // Field 6: poll_period_ms
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, poll_period_ms_, msg);
+  }
+
+  // Field 4: counter
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, counter_, msg);
+  }
+
+  // Field 3: tracepoint
+  if (_has_field_[3]) {
+    (*tracepoint_).Serialize(msg->BeginNestedMessage<::protozero::Message>(3));
+  }
+
+  // Field 5: raw_event
+  if (_has_field_[5]) {
+    (*raw_event_).Serialize(msg->BeginNestedMessage<::protozero::Message>(5));
+  }
+
+  // Field 12: modifiers
+  for (auto& it : modifiers_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(12, it, msg);
+  }
+
+  // Field 11: timestamp_clock
+  if (_has_field_[11]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(11, timestamp_clock_, msg);
+  }
+
+  // Field 10: name
+  if (_has_field_[10]) {
+    ::protozero::internal::gen_helpers::SerializeString(10, name_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -18761,77 +18340,51 @@ void AndroidSystemPropertyConfig::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/android/network_trace_config.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/android/network_trace_config.gen.h
+// gen_amalgamated begin source: gen/protos/perfetto/common/protolog_common.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_NETWORK_TRACE_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_NETWORK_TRACE_CONFIG_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/common/protolog_common.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
-class NetworkPacketTraceConfig;
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/common/sys_stats_counters.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/common/sys_stats_counters.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT NetworkPacketTraceConfig : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kPollMsFieldNumber = 1,
-  };
-
-  NetworkPacketTraceConfig();
-  ~NetworkPacketTraceConfig() override;
-  NetworkPacketTraceConfig(NetworkPacketTraceConfig&&) noexcept;
-  NetworkPacketTraceConfig& operator=(NetworkPacketTraceConfig&&);
-  NetworkPacketTraceConfig(const NetworkPacketTraceConfig&);
-  NetworkPacketTraceConfig& operator=(const NetworkPacketTraceConfig&);
-  bool operator==(const NetworkPacketTraceConfig&) const;
-  bool operator!=(const NetworkPacketTraceConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_poll_ms() const { return _has_field_[1]; }
-  uint32_t poll_ms() const { return poll_ms_; }
-  void set_poll_ms(uint32_t value) { poll_ms_ = value; _has_field_.set(1); }
-
- private:
-  uint32_t poll_ms_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_NETWORK_TRACE_CONFIG_PROTO_CPP_H_
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/common/system_info.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -18842,25 +18395,40 @@ class PERFETTO_EXPORT_COMPONENT NetworkPacketTraceConfig : public ::protozero::C
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/android/network_trace_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/system_info.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-NetworkPacketTraceConfig::NetworkPacketTraceConfig() = default;
-NetworkPacketTraceConfig::~NetworkPacketTraceConfig() = default;
-NetworkPacketTraceConfig::NetworkPacketTraceConfig(const NetworkPacketTraceConfig&) = default;
-NetworkPacketTraceConfig& NetworkPacketTraceConfig::operator=(const NetworkPacketTraceConfig&) = default;
-NetworkPacketTraceConfig::NetworkPacketTraceConfig(NetworkPacketTraceConfig&&) noexcept = default;
-NetworkPacketTraceConfig& NetworkPacketTraceConfig::operator=(NetworkPacketTraceConfig&&) = default;
-
-bool NetworkPacketTraceConfig::operator==(const NetworkPacketTraceConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && poll_ms_ == other.poll_ms_;
-}
-
-bool NetworkPacketTraceConfig::ParseFromArray(const void* raw, size_t size) {
+SystemInfo::SystemInfo() = default;
+SystemInfo::~SystemInfo() = default;
+SystemInfo::SystemInfo(const SystemInfo&) = default;
+SystemInfo& SystemInfo::operator=(const SystemInfo&) = default;
+SystemInfo::SystemInfo(SystemInfo&&) noexcept = default;
+SystemInfo& SystemInfo::operator=(SystemInfo&&) = default;
+
+bool SystemInfo::operator==(const SystemInfo& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(utsname_, other.utsname_)
+   && ::protozero::internal::gen_helpers::EqualsField(android_build_fingerprint_, other.android_build_fingerprint_)
+   && ::protozero::internal::gen_helpers::EqualsField(android_device_manufacturer_, other.android_device_manufacturer_)
+   && ::protozero::internal::gen_helpers::EqualsField(android_soc_model_, other.android_soc_model_)
+   && ::protozero::internal::gen_helpers::EqualsField(android_guest_soc_model_, other.android_guest_soc_model_)
+   && ::protozero::internal::gen_helpers::EqualsField(android_hardware_revision_, other.android_hardware_revision_)
+   && ::protozero::internal::gen_helpers::EqualsField(android_storage_model_, other.android_storage_model_)
+   && ::protozero::internal::gen_helpers::EqualsField(android_ram_model_, other.android_ram_model_)
+   && ::protozero::internal::gen_helpers::EqualsField(android_serial_console_, other.android_serial_console_)
+   && ::protozero::internal::gen_helpers::EqualsField(tracing_service_version_, other.tracing_service_version_)
+   && ::protozero::internal::gen_helpers::EqualsField(android_sdk_version_, other.android_sdk_version_)
+   && ::protozero::internal::gen_helpers::EqualsField(page_size_, other.page_size_)
+   && ::protozero::internal::gen_helpers::EqualsField(num_cpus_, other.num_cpus_)
+   && ::protozero::internal::gen_helpers::EqualsField(timezone_off_mins_, other.timezone_off_mins_)
+   && ::protozero::internal::gen_helpers::EqualsField(hz_, other.hz_)
+   && ::protozero::internal::gen_helpers::EqualsField(system_ram_bytes_, other.system_ram_bytes_);
+}
+
+bool SystemInfo::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -18870,8 +18438,53 @@ bool NetworkPacketTraceConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* poll_ms */:
-        field.get(&poll_ms_);
+      case 1 /* utsname */:
+        (*utsname_).ParseFromArray(field.data(), field.size());
+        break;
+      case 2 /* android_build_fingerprint */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &android_build_fingerprint_);
+        break;
+      case 14 /* android_device_manufacturer */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &android_device_manufacturer_);
+        break;
+      case 9 /* android_soc_model */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &android_soc_model_);
+        break;
+      case 13 /* android_guest_soc_model */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &android_guest_soc_model_);
+        break;
+      case 10 /* android_hardware_revision */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &android_hardware_revision_);
+        break;
+      case 11 /* android_storage_model */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &android_storage_model_);
+        break;
+      case 12 /* android_ram_model */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &android_ram_model_);
+        break;
+      case 15 /* android_serial_console */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &android_serial_console_);
+        break;
+      case 4 /* tracing_service_version */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &tracing_service_version_);
+        break;
+      case 5 /* android_sdk_version */:
+        field.get(&android_sdk_version_);
+        break;
+      case 6 /* page_size */:
+        field.get(&page_size_);
+        break;
+      case 8 /* num_cpus */:
+        field.get(&num_cpus_);
+        break;
+      case 7 /* timezone_off_mins */:
+        field.get(&timezone_off_mins_);
+        break;
+      case 3 /* hz */:
+        field.get(&hz_);
+        break;
+      case 16 /* system_ram_bytes */:
+        field.get(&system_ram_bytes_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -18881,137 +18494,119 @@ bool NetworkPacketTraceConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string NetworkPacketTraceConfig::SerializeAsString() const {
+std::string SystemInfo::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> NetworkPacketTraceConfig::SerializeAsArray() const {
+std::vector<uint8_t> SystemInfo::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void NetworkPacketTraceConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: poll_ms
+void SystemInfo::Serialize(::protozero::Message* msg) const {
+  // Field 1: utsname
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, poll_ms_, msg);
+    (*utsname_).Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
   }
 
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
-}
+  // Field 2: android_build_fingerprint
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeString(2, android_build_fingerprint_, msg);
+  }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/android/packages_list_config.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/android/packages_list_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PACKAGES_LIST_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PACKAGES_LIST_CONFIG_PROTO_CPP_H_
+  // Field 14: android_device_manufacturer
+  if (_has_field_[14]) {
+    ::protozero::internal::gen_helpers::SerializeString(14, android_device_manufacturer_, msg);
+  }
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  // Field 9: android_soc_model
+  if (_has_field_[9]) {
+    ::protozero::internal::gen_helpers::SerializeString(9, android_soc_model_, msg);
+  }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  // Field 13: android_guest_soc_model
+  if (_has_field_[13]) {
+    ::protozero::internal::gen_helpers::SerializeString(13, android_guest_soc_model_, msg);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class PackagesListConfig;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  // Field 10: android_hardware_revision
+  if (_has_field_[10]) {
+    ::protozero::internal::gen_helpers::SerializeString(10, android_hardware_revision_, msg);
+  }
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  // Field 11: android_storage_model
+  if (_has_field_[11]) {
+    ::protozero::internal::gen_helpers::SerializeString(11, android_storage_model_, msg);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+  // Field 12: android_ram_model
+  if (_has_field_[12]) {
+    ::protozero::internal::gen_helpers::SerializeString(12, android_ram_model_, msg);
+  }
 
-class PERFETTO_EXPORT_COMPONENT PackagesListConfig : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kPackageNameFilterFieldNumber = 1,
-  };
+  // Field 15: android_serial_console
+  if (_has_field_[15]) {
+    ::protozero::internal::gen_helpers::SerializeString(15, android_serial_console_, msg);
+  }
 
-  PackagesListConfig();
-  ~PackagesListConfig() override;
-  PackagesListConfig(PackagesListConfig&&) noexcept;
-  PackagesListConfig& operator=(PackagesListConfig&&);
-  PackagesListConfig(const PackagesListConfig&);
-  PackagesListConfig& operator=(const PackagesListConfig&);
-  bool operator==(const PackagesListConfig&) const;
-  bool operator!=(const PackagesListConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<std::string>& package_name_filter() const { return package_name_filter_; }
-  std::vector<std::string>* mutable_package_name_filter() { return &package_name_filter_; }
-  int package_name_filter_size() const { return static_cast<int>(package_name_filter_.size()); }
-  void clear_package_name_filter() { package_name_filter_.clear(); }
-  void add_package_name_filter(std::string value) { package_name_filter_.emplace_back(value); }
-  std::string* add_package_name_filter() { package_name_filter_.emplace_back(); return &package_name_filter_.back(); }
+  // Field 4: tracing_service_version
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeString(4, tracing_service_version_, msg);
+  }
 
- private:
-  std::vector<std::string> package_name_filter_;
+  // Field 5: android_sdk_version
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, android_sdk_version_, msg);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  // Field 6: page_size
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, page_size_, msg);
+  }
 
-  std::bitset<2> _has_field_{};
-};
+  // Field 8: num_cpus
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(8, num_cpus_, msg);
+  }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  // Field 7: timezone_off_mins
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(7, timezone_off_mins_, msg);
+  }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PACKAGES_LIST_CONFIG_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/android/packages_list_config.gen.h"
+  // Field 3: hz
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, hz_, msg);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+  // Field 16: system_ram_bytes
+  if (_has_field_[16]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(16, system_ram_bytes_, msg);
+  }
 
-PackagesListConfig::PackagesListConfig() = default;
-PackagesListConfig::~PackagesListConfig() = default;
-PackagesListConfig::PackagesListConfig(const PackagesListConfig&) = default;
-PackagesListConfig& PackagesListConfig::operator=(const PackagesListConfig&) = default;
-PackagesListConfig::PackagesListConfig(PackagesListConfig&&) noexcept = default;
-PackagesListConfig& PackagesListConfig::operator=(PackagesListConfig&&) = default;
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-bool PackagesListConfig::operator==(const PackagesListConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && package_name_filter_ == other.package_name_filter_;
+
+Utsname::Utsname() = default;
+Utsname::~Utsname() = default;
+Utsname::Utsname(const Utsname&) = default;
+Utsname& Utsname::operator=(const Utsname&) = default;
+Utsname::Utsname(Utsname&&) noexcept = default;
+Utsname& Utsname::operator=(Utsname&&) = default;
+
+bool Utsname::operator==(const Utsname& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(sysname_, other.sysname_)
+   && ::protozero::internal::gen_helpers::EqualsField(version_, other.version_)
+   && ::protozero::internal::gen_helpers::EqualsField(release_, other.release_)
+   && ::protozero::internal::gen_helpers::EqualsField(machine_, other.machine_);
 }
 
-bool PackagesListConfig::ParseFromArray(const void* raw, size_t size) {
-  package_name_filter_.clear();
+bool Utsname::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -19021,9 +18616,17 @@ bool PackagesListConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* package_name_filter */:
-        package_name_filter_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &package_name_filter_.back());
+      case 1 /* sysname */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &sysname_);
+        break;
+      case 2 /* version */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &version_);
+        break;
+      case 3 /* release */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &release_);
+        break;
+      case 4 /* machine */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &machine_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -19033,22 +18636,37 @@ bool PackagesListConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string PackagesListConfig::SerializeAsString() const {
+std::string Utsname::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> PackagesListConfig::SerializeAsArray() const {
+std::vector<uint8_t> Utsname::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void PackagesListConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: package_name_filter
-  for (auto& it : package_name_filter_) {
-    ::protozero::internal::gen_helpers::SerializeString(1, it, msg);
+void Utsname::Serialize(::protozero::Message* msg) const {
+  // Field 1: sysname
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeString(1, sysname_, msg);
+  }
+
+  // Field 2: version
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeString(2, version_, msg);
+  }
+
+  // Field 3: release
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeString(3, release_, msg);
+  }
+
+  // Field 4: machine
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeString(4, machine_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -19060,377 +18678,7 @@ void PackagesListConfig::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/ftrace/ftrace_config.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/ftrace/ftrace_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_FTRACE_FTRACE_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_FTRACE_FTRACE_CONFIG_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class FtraceConfig;
-class FtraceConfig_PrintFilter;
-class FtraceConfig_PrintFilter_Rule;
-class FtraceConfig_PrintFilter_Rule_AtraceMessage;
-class FtraceConfig_CompactSchedConfig;
-enum FtraceConfig_KsymsMemPolicy : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum FtraceConfig_KsymsMemPolicy : int {
-  FtraceConfig_KsymsMemPolicy_KSYMS_UNSPECIFIED = 0,
-  FtraceConfig_KsymsMemPolicy_KSYMS_CLEANUP_ON_STOP = 1,
-  FtraceConfig_KsymsMemPolicy_KSYMS_RETAIN = 2,
-};
-
-class PERFETTO_EXPORT_COMPONENT FtraceConfig : public ::protozero::CppMessageObj {
- public:
-  using CompactSchedConfig = FtraceConfig_CompactSchedConfig;
-  using PrintFilter = FtraceConfig_PrintFilter;
-  using KsymsMemPolicy = FtraceConfig_KsymsMemPolicy;
-  static constexpr auto KSYMS_UNSPECIFIED = FtraceConfig_KsymsMemPolicy_KSYMS_UNSPECIFIED;
-  static constexpr auto KSYMS_CLEANUP_ON_STOP = FtraceConfig_KsymsMemPolicy_KSYMS_CLEANUP_ON_STOP;
-  static constexpr auto KSYMS_RETAIN = FtraceConfig_KsymsMemPolicy_KSYMS_RETAIN;
-  static constexpr auto KsymsMemPolicy_MIN = FtraceConfig_KsymsMemPolicy_KSYMS_UNSPECIFIED;
-  static constexpr auto KsymsMemPolicy_MAX = FtraceConfig_KsymsMemPolicy_KSYMS_RETAIN;
-  enum FieldNumbers {
-    kFtraceEventsFieldNumber = 1,
-    kAtraceCategoriesFieldNumber = 2,
-    kAtraceAppsFieldNumber = 3,
-    kBufferSizeKbFieldNumber = 10,
-    kDrainPeriodMsFieldNumber = 11,
-    kCompactSchedFieldNumber = 12,
-    kPrintFilterFieldNumber = 22,
-    kSymbolizeKsymsFieldNumber = 13,
-    kKsymsMemPolicyFieldNumber = 17,
-    kInitializeKsymsSynchronouslyForTestingFieldNumber = 14,
-    kThrottleRssStatFieldNumber = 15,
-    kDisableGenericEventsFieldNumber = 16,
-    kSyscallEventsFieldNumber = 18,
-    kEnableFunctionGraphFieldNumber = 19,
-    kFunctionFiltersFieldNumber = 20,
-    kFunctionGraphRootsFieldNumber = 21,
-    kPreserveFtraceBufferFieldNumber = 23,
-    kUseMonotonicRawClockFieldNumber = 24,
-  };
-
-  FtraceConfig();
-  ~FtraceConfig() override;
-  FtraceConfig(FtraceConfig&&) noexcept;
-  FtraceConfig& operator=(FtraceConfig&&);
-  FtraceConfig(const FtraceConfig&);
-  FtraceConfig& operator=(const FtraceConfig&);
-  bool operator==(const FtraceConfig&) const;
-  bool operator!=(const FtraceConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<std::string>& ftrace_events() const { return ftrace_events_; }
-  std::vector<std::string>* mutable_ftrace_events() { return &ftrace_events_; }
-  int ftrace_events_size() const { return static_cast<int>(ftrace_events_.size()); }
-  void clear_ftrace_events() { ftrace_events_.clear(); }
-  void add_ftrace_events(std::string value) { ftrace_events_.emplace_back(value); }
-  std::string* add_ftrace_events() { ftrace_events_.emplace_back(); return &ftrace_events_.back(); }
-
-  const std::vector<std::string>& atrace_categories() const { return atrace_categories_; }
-  std::vector<std::string>* mutable_atrace_categories() { return &atrace_categories_; }
-  int atrace_categories_size() const { return static_cast<int>(atrace_categories_.size()); }
-  void clear_atrace_categories() { atrace_categories_.clear(); }
-  void add_atrace_categories(std::string value) { atrace_categories_.emplace_back(value); }
-  std::string* add_atrace_categories() { atrace_categories_.emplace_back(); return &atrace_categories_.back(); }
-
-  const std::vector<std::string>& atrace_apps() const { return atrace_apps_; }
-  std::vector<std::string>* mutable_atrace_apps() { return &atrace_apps_; }
-  int atrace_apps_size() const { return static_cast<int>(atrace_apps_.size()); }
-  void clear_atrace_apps() { atrace_apps_.clear(); }
-  void add_atrace_apps(std::string value) { atrace_apps_.emplace_back(value); }
-  std::string* add_atrace_apps() { atrace_apps_.emplace_back(); return &atrace_apps_.back(); }
-
-  bool has_buffer_size_kb() const { return _has_field_[10]; }
-  uint32_t buffer_size_kb() const { return buffer_size_kb_; }
-  void set_buffer_size_kb(uint32_t value) { buffer_size_kb_ = value; _has_field_.set(10); }
-
-  bool has_drain_period_ms() const { return _has_field_[11]; }
-  uint32_t drain_period_ms() const { return drain_period_ms_; }
-  void set_drain_period_ms(uint32_t value) { drain_period_ms_ = value; _has_field_.set(11); }
-
-  bool has_compact_sched() const { return _has_field_[12]; }
-  const FtraceConfig_CompactSchedConfig& compact_sched() const { return *compact_sched_; }
-  FtraceConfig_CompactSchedConfig* mutable_compact_sched() { _has_field_.set(12); return compact_sched_.get(); }
-
-  bool has_print_filter() const { return _has_field_[22]; }
-  const FtraceConfig_PrintFilter& print_filter() const { return *print_filter_; }
-  FtraceConfig_PrintFilter* mutable_print_filter() { _has_field_.set(22); return print_filter_.get(); }
-
-  bool has_symbolize_ksyms() const { return _has_field_[13]; }
-  bool symbolize_ksyms() const { return symbolize_ksyms_; }
-  void set_symbolize_ksyms(bool value) { symbolize_ksyms_ = value; _has_field_.set(13); }
-
-  bool has_ksyms_mem_policy() const { return _has_field_[17]; }
-  FtraceConfig_KsymsMemPolicy ksyms_mem_policy() const { return ksyms_mem_policy_; }
-  void set_ksyms_mem_policy(FtraceConfig_KsymsMemPolicy value) { ksyms_mem_policy_ = value; _has_field_.set(17); }
-
-  bool has_initialize_ksyms_synchronously_for_testing() const { return _has_field_[14]; }
-  bool initialize_ksyms_synchronously_for_testing() const { return initialize_ksyms_synchronously_for_testing_; }
-  void set_initialize_ksyms_synchronously_for_testing(bool value) { initialize_ksyms_synchronously_for_testing_ = value; _has_field_.set(14); }
-
-  bool has_throttle_rss_stat() const { return _has_field_[15]; }
-  bool throttle_rss_stat() const { return throttle_rss_stat_; }
-  void set_throttle_rss_stat(bool value) { throttle_rss_stat_ = value; _has_field_.set(15); }
-
-  bool has_disable_generic_events() const { return _has_field_[16]; }
-  bool disable_generic_events() const { return disable_generic_events_; }
-  void set_disable_generic_events(bool value) { disable_generic_events_ = value; _has_field_.set(16); }
-
-  const std::vector<std::string>& syscall_events() const { return syscall_events_; }
-  std::vector<std::string>* mutable_syscall_events() { return &syscall_events_; }
-  int syscall_events_size() const { return static_cast<int>(syscall_events_.size()); }
-  void clear_syscall_events() { syscall_events_.clear(); }
-  void add_syscall_events(std::string value) { syscall_events_.emplace_back(value); }
-  std::string* add_syscall_events() { syscall_events_.emplace_back(); return &syscall_events_.back(); }
-
-  bool has_enable_function_graph() const { return _has_field_[19]; }
-  bool enable_function_graph() const { return enable_function_graph_; }
-  void set_enable_function_graph(bool value) { enable_function_graph_ = value; _has_field_.set(19); }
-
-  const std::vector<std::string>& function_filters() const { return function_filters_; }
-  std::vector<std::string>* mutable_function_filters() { return &function_filters_; }
-  int function_filters_size() const { return static_cast<int>(function_filters_.size()); }
-  void clear_function_filters() { function_filters_.clear(); }
-  void add_function_filters(std::string value) { function_filters_.emplace_back(value); }
-  std::string* add_function_filters() { function_filters_.emplace_back(); return &function_filters_.back(); }
-
-  const std::vector<std::string>& function_graph_roots() const { return function_graph_roots_; }
-  std::vector<std::string>* mutable_function_graph_roots() { return &function_graph_roots_; }
-  int function_graph_roots_size() const { return static_cast<int>(function_graph_roots_.size()); }
-  void clear_function_graph_roots() { function_graph_roots_.clear(); }
-  void add_function_graph_roots(std::string value) { function_graph_roots_.emplace_back(value); }
-  std::string* add_function_graph_roots() { function_graph_roots_.emplace_back(); return &function_graph_roots_.back(); }
-
-  bool has_preserve_ftrace_buffer() const { return _has_field_[23]; }
-  bool preserve_ftrace_buffer() const { return preserve_ftrace_buffer_; }
-  void set_preserve_ftrace_buffer(bool value) { preserve_ftrace_buffer_ = value; _has_field_.set(23); }
-
-  bool has_use_monotonic_raw_clock() const { return _has_field_[24]; }
-  bool use_monotonic_raw_clock() const { return use_monotonic_raw_clock_; }
-  void set_use_monotonic_raw_clock(bool value) { use_monotonic_raw_clock_ = value; _has_field_.set(24); }
-
- private:
-  std::vector<std::string> ftrace_events_;
-  std::vector<std::string> atrace_categories_;
-  std::vector<std::string> atrace_apps_;
-  uint32_t buffer_size_kb_{};
-  uint32_t drain_period_ms_{};
-  ::protozero::CopyablePtr<FtraceConfig_CompactSchedConfig> compact_sched_;
-  ::protozero::CopyablePtr<FtraceConfig_PrintFilter> print_filter_;
-  bool symbolize_ksyms_{};
-  FtraceConfig_KsymsMemPolicy ksyms_mem_policy_{};
-  bool initialize_ksyms_synchronously_for_testing_{};
-  bool throttle_rss_stat_{};
-  bool disable_generic_events_{};
-  std::vector<std::string> syscall_events_;
-  bool enable_function_graph_{};
-  std::vector<std::string> function_filters_;
-  std::vector<std::string> function_graph_roots_;
-  bool preserve_ftrace_buffer_{};
-  bool use_monotonic_raw_clock_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<25> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT FtraceConfig_PrintFilter : public ::protozero::CppMessageObj {
- public:
-  using Rule = FtraceConfig_PrintFilter_Rule;
-  enum FieldNumbers {
-    kRulesFieldNumber = 1,
-  };
-
-  FtraceConfig_PrintFilter();
-  ~FtraceConfig_PrintFilter() override;
-  FtraceConfig_PrintFilter(FtraceConfig_PrintFilter&&) noexcept;
-  FtraceConfig_PrintFilter& operator=(FtraceConfig_PrintFilter&&);
-  FtraceConfig_PrintFilter(const FtraceConfig_PrintFilter&);
-  FtraceConfig_PrintFilter& operator=(const FtraceConfig_PrintFilter&);
-  bool operator==(const FtraceConfig_PrintFilter&) const;
-  bool operator!=(const FtraceConfig_PrintFilter& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<FtraceConfig_PrintFilter_Rule>& rules() const { return rules_; }
-  std::vector<FtraceConfig_PrintFilter_Rule>* mutable_rules() { return &rules_; }
-  int rules_size() const;
-  void clear_rules();
-  FtraceConfig_PrintFilter_Rule* add_rules();
-
- private:
-  std::vector<FtraceConfig_PrintFilter_Rule> rules_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT FtraceConfig_PrintFilter_Rule : public ::protozero::CppMessageObj {
- public:
-  using AtraceMessage = FtraceConfig_PrintFilter_Rule_AtraceMessage;
-  enum FieldNumbers {
-    kPrefixFieldNumber = 1,
-    kAtraceMsgFieldNumber = 3,
-    kAllowFieldNumber = 2,
-  };
-
-  FtraceConfig_PrintFilter_Rule();
-  ~FtraceConfig_PrintFilter_Rule() override;
-  FtraceConfig_PrintFilter_Rule(FtraceConfig_PrintFilter_Rule&&) noexcept;
-  FtraceConfig_PrintFilter_Rule& operator=(FtraceConfig_PrintFilter_Rule&&);
-  FtraceConfig_PrintFilter_Rule(const FtraceConfig_PrintFilter_Rule&);
-  FtraceConfig_PrintFilter_Rule& operator=(const FtraceConfig_PrintFilter_Rule&);
-  bool operator==(const FtraceConfig_PrintFilter_Rule&) const;
-  bool operator!=(const FtraceConfig_PrintFilter_Rule& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_prefix() const { return _has_field_[1]; }
-  const std::string& prefix() const { return prefix_; }
-  void set_prefix(const std::string& value) { prefix_ = value; _has_field_.set(1); }
-
-  bool has_atrace_msg() const { return _has_field_[3]; }
-  const FtraceConfig_PrintFilter_Rule_AtraceMessage& atrace_msg() const { return *atrace_msg_; }
-  FtraceConfig_PrintFilter_Rule_AtraceMessage* mutable_atrace_msg() { _has_field_.set(3); return atrace_msg_.get(); }
-
-  bool has_allow() const { return _has_field_[2]; }
-  bool allow() const { return allow_; }
-  void set_allow(bool value) { allow_ = value; _has_field_.set(2); }
-
- private:
-  std::string prefix_{};
-  ::protozero::CopyablePtr<FtraceConfig_PrintFilter_Rule_AtraceMessage> atrace_msg_;
-  bool allow_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<4> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT FtraceConfig_PrintFilter_Rule_AtraceMessage : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kTypeFieldNumber = 1,
-    kPrefixFieldNumber = 2,
-  };
-
-  FtraceConfig_PrintFilter_Rule_AtraceMessage();
-  ~FtraceConfig_PrintFilter_Rule_AtraceMessage() override;
-  FtraceConfig_PrintFilter_Rule_AtraceMessage(FtraceConfig_PrintFilter_Rule_AtraceMessage&&) noexcept;
-  FtraceConfig_PrintFilter_Rule_AtraceMessage& operator=(FtraceConfig_PrintFilter_Rule_AtraceMessage&&);
-  FtraceConfig_PrintFilter_Rule_AtraceMessage(const FtraceConfig_PrintFilter_Rule_AtraceMessage&);
-  FtraceConfig_PrintFilter_Rule_AtraceMessage& operator=(const FtraceConfig_PrintFilter_Rule_AtraceMessage&);
-  bool operator==(const FtraceConfig_PrintFilter_Rule_AtraceMessage&) const;
-  bool operator!=(const FtraceConfig_PrintFilter_Rule_AtraceMessage& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_type() const { return _has_field_[1]; }
-  const std::string& type() const { return type_; }
-  void set_type(const std::string& value) { type_ = value; _has_field_.set(1); }
-
-  bool has_prefix() const { return _has_field_[2]; }
-  const std::string& prefix() const { return prefix_; }
-  void set_prefix(const std::string& value) { prefix_ = value; _has_field_.set(2); }
-
- private:
-  std::string type_{};
-  std::string prefix_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT FtraceConfig_CompactSchedConfig : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kEnabledFieldNumber = 1,
-  };
-
-  FtraceConfig_CompactSchedConfig();
-  ~FtraceConfig_CompactSchedConfig() override;
-  FtraceConfig_CompactSchedConfig(FtraceConfig_CompactSchedConfig&&) noexcept;
-  FtraceConfig_CompactSchedConfig& operator=(FtraceConfig_CompactSchedConfig&&);
-  FtraceConfig_CompactSchedConfig(const FtraceConfig_CompactSchedConfig&);
-  FtraceConfig_CompactSchedConfig& operator=(const FtraceConfig_CompactSchedConfig&);
-  bool operator==(const FtraceConfig_CompactSchedConfig&) const;
-  bool operator!=(const FtraceConfig_CompactSchedConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_enabled() const { return _has_field_[1]; }
-  bool enabled() const { return enabled_; }
-  void set_enabled(bool value) { enabled_ = value; _has_field_.set(1); }
-
- private:
-  bool enabled_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_FTRACE_FTRACE_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin source: gen/protos/perfetto/common/trace_stats.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -19441,48 +18689,50 @@ class PERFETTO_EXPORT_COMPONENT FtraceConfig_CompactSchedConfig : public ::proto
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/ftrace/ftrace_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/trace_stats.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-FtraceConfig::FtraceConfig() = default;
-FtraceConfig::~FtraceConfig() = default;
-FtraceConfig::FtraceConfig(const FtraceConfig&) = default;
-FtraceConfig& FtraceConfig::operator=(const FtraceConfig&) = default;
-FtraceConfig::FtraceConfig(FtraceConfig&&) noexcept = default;
-FtraceConfig& FtraceConfig::operator=(FtraceConfig&&) = default;
+TraceStats::TraceStats() = default;
+TraceStats::~TraceStats() = default;
+TraceStats::TraceStats(const TraceStats&) = default;
+TraceStats& TraceStats::operator=(const TraceStats&) = default;
+TraceStats::TraceStats(TraceStats&&) noexcept = default;
+TraceStats& TraceStats::operator=(TraceStats&&) = default;
 
-bool FtraceConfig::operator==(const FtraceConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && ftrace_events_ == other.ftrace_events_
-   && atrace_categories_ == other.atrace_categories_
-   && atrace_apps_ == other.atrace_apps_
-   && buffer_size_kb_ == other.buffer_size_kb_
-   && drain_period_ms_ == other.drain_period_ms_
-   && compact_sched_ == other.compact_sched_
-   && print_filter_ == other.print_filter_
-   && symbolize_ksyms_ == other.symbolize_ksyms_
-   && ksyms_mem_policy_ == other.ksyms_mem_policy_
-   && initialize_ksyms_synchronously_for_testing_ == other.initialize_ksyms_synchronously_for_testing_
-   && throttle_rss_stat_ == other.throttle_rss_stat_
-   && disable_generic_events_ == other.disable_generic_events_
-   && syscall_events_ == other.syscall_events_
-   && enable_function_graph_ == other.enable_function_graph_
-   && function_filters_ == other.function_filters_
-   && function_graph_roots_ == other.function_graph_roots_
-   && preserve_ftrace_buffer_ == other.preserve_ftrace_buffer_
-   && use_monotonic_raw_clock_ == other.use_monotonic_raw_clock_;
+bool TraceStats::operator==(const TraceStats& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(buffer_stats_, other.buffer_stats_)
+   && ::protozero::internal::gen_helpers::EqualsField(chunk_payload_histogram_def_, other.chunk_payload_histogram_def_)
+   && ::protozero::internal::gen_helpers::EqualsField(writer_stats_, other.writer_stats_)
+   && ::protozero::internal::gen_helpers::EqualsField(producers_connected_, other.producers_connected_)
+   && ::protozero::internal::gen_helpers::EqualsField(producers_seen_, other.producers_seen_)
+   && ::protozero::internal::gen_helpers::EqualsField(data_sources_registered_, other.data_sources_registered_)
+   && ::protozero::internal::gen_helpers::EqualsField(data_sources_seen_, other.data_sources_seen_)
+   && ::protozero::internal::gen_helpers::EqualsField(tracing_sessions_, other.tracing_sessions_)
+   && ::protozero::internal::gen_helpers::EqualsField(total_buffers_, other.total_buffers_)
+   && ::protozero::internal::gen_helpers::EqualsField(chunks_discarded_, other.chunks_discarded_)
+   && ::protozero::internal::gen_helpers::EqualsField(patches_discarded_, other.patches_discarded_)
+   && ::protozero::internal::gen_helpers::EqualsField(invalid_packets_, other.invalid_packets_)
+   && ::protozero::internal::gen_helpers::EqualsField(filter_stats_, other.filter_stats_)
+   && ::protozero::internal::gen_helpers::EqualsField(flushes_requested_, other.flushes_requested_)
+   && ::protozero::internal::gen_helpers::EqualsField(flushes_succeeded_, other.flushes_succeeded_)
+   && ::protozero::internal::gen_helpers::EqualsField(flushes_failed_, other.flushes_failed_)
+   && ::protozero::internal::gen_helpers::EqualsField(final_flush_outcome_, other.final_flush_outcome_);
 }
 
-bool FtraceConfig::ParseFromArray(const void* raw, size_t size) {
-  ftrace_events_.clear();
-  atrace_categories_.clear();
-  atrace_apps_.clear();
-  syscall_events_.clear();
-  function_filters_.clear();
-  function_graph_roots_.clear();
+int TraceStats::buffer_stats_size() const { return static_cast<int>(buffer_stats_.size()); }
+void TraceStats::clear_buffer_stats() { buffer_stats_.clear(); }
+TraceStats_BufferStats* TraceStats::add_buffer_stats() { buffer_stats_.emplace_back(); return &buffer_stats_.back(); }
+int TraceStats::writer_stats_size() const { return static_cast<int>(writer_stats_.size()); }
+void TraceStats::clear_writer_stats() { writer_stats_.clear(); }
+TraceStats_WriterStats* TraceStats::add_writer_stats() { writer_stats_.emplace_back(); return &writer_stats_.back(); }
+bool TraceStats::ParseFromArray(const void* raw, size_t size) {
+  buffer_stats_.clear();
+  chunk_payload_histogram_def_.clear();
+  writer_stats_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -19492,65 +18742,59 @@ bool FtraceConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* ftrace_events */:
-        ftrace_events_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &ftrace_events_.back());
-        break;
-      case 2 /* atrace_categories */:
-        atrace_categories_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &atrace_categories_.back());
+      case 1 /* buffer_stats */:
+        buffer_stats_.emplace_back();
+        buffer_stats_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 3 /* atrace_apps */:
-        atrace_apps_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &atrace_apps_.back());
+      case 17 /* chunk_payload_histogram_def */:
+        chunk_payload_histogram_def_.emplace_back();
+        field.get(&chunk_payload_histogram_def_.back());
         break;
-      case 10 /* buffer_size_kb */:
-        field.get(&buffer_size_kb_);
+      case 18 /* writer_stats */:
+        writer_stats_.emplace_back();
+        writer_stats_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 11 /* drain_period_ms */:
-        field.get(&drain_period_ms_);
+      case 2 /* producers_connected */:
+        field.get(&producers_connected_);
         break;
-      case 12 /* compact_sched */:
-        (*compact_sched_).ParseFromArray(field.data(), field.size());
+      case 3 /* producers_seen */:
+        field.get(&producers_seen_);
         break;
-      case 22 /* print_filter */:
-        (*print_filter_).ParseFromArray(field.data(), field.size());
+      case 4 /* data_sources_registered */:
+        field.get(&data_sources_registered_);
         break;
-      case 13 /* symbolize_ksyms */:
-        field.get(&symbolize_ksyms_);
+      case 5 /* data_sources_seen */:
+        field.get(&data_sources_seen_);
         break;
-      case 17 /* ksyms_mem_policy */:
-        field.get(&ksyms_mem_policy_);
+      case 6 /* tracing_sessions */:
+        field.get(&tracing_sessions_);
         break;
-      case 14 /* initialize_ksyms_synchronously_for_testing */:
-        field.get(&initialize_ksyms_synchronously_for_testing_);
+      case 7 /* total_buffers */:
+        field.get(&total_buffers_);
         break;
-      case 15 /* throttle_rss_stat */:
-        field.get(&throttle_rss_stat_);
+      case 8 /* chunks_discarded */:
+        field.get(&chunks_discarded_);
         break;
-      case 16 /* disable_generic_events */:
-        field.get(&disable_generic_events_);
+      case 9 /* patches_discarded */:
+        field.get(&patches_discarded_);
         break;
-      case 18 /* syscall_events */:
-        syscall_events_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &syscall_events_.back());
+      case 10 /* invalid_packets */:
+        field.get(&invalid_packets_);
         break;
-      case 19 /* enable_function_graph */:
-        field.get(&enable_function_graph_);
+      case 11 /* filter_stats */:
+        (*filter_stats_).ParseFromArray(field.data(), field.size());
         break;
-      case 20 /* function_filters */:
-        function_filters_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &function_filters_.back());
+      case 12 /* flushes_requested */:
+        field.get(&flushes_requested_);
         break;
-      case 21 /* function_graph_roots */:
-        function_graph_roots_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &function_graph_roots_.back());
+      case 13 /* flushes_succeeded */:
+        field.get(&flushes_succeeded_);
         break;
-      case 23 /* preserve_ftrace_buffer */:
-        field.get(&preserve_ftrace_buffer_);
+      case 14 /* flushes_failed */:
+        field.get(&flushes_failed_);
         break;
-      case 24 /* use_monotonic_raw_clock */:
-        field.get(&use_monotonic_raw_clock_);
+      case 15 /* final_flush_outcome */:
+        field.get(&final_flush_outcome_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -19560,130 +18804,127 @@ bool FtraceConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string FtraceConfig::SerializeAsString() const {
+std::string TraceStats::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> FtraceConfig::SerializeAsArray() const {
+std::vector<uint8_t> TraceStats::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void FtraceConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: ftrace_events
-  for (auto& it : ftrace_events_) {
-    ::protozero::internal::gen_helpers::SerializeString(1, it, msg);
-  }
-
-  // Field 2: atrace_categories
-  for (auto& it : atrace_categories_) {
-    ::protozero::internal::gen_helpers::SerializeString(2, it, msg);
+void TraceStats::Serialize(::protozero::Message* msg) const {
+  // Field 1: buffer_stats
+  for (auto& it : buffer_stats_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
   }
 
-  // Field 3: atrace_apps
-  for (auto& it : atrace_apps_) {
-    ::protozero::internal::gen_helpers::SerializeString(3, it, msg);
+  // Field 17: chunk_payload_histogram_def
+  for (auto& it : chunk_payload_histogram_def_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(17, it, msg);
   }
 
-  // Field 10: buffer_size_kb
-  if (_has_field_[10]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(10, buffer_size_kb_, msg);
+  // Field 18: writer_stats
+  for (auto& it : writer_stats_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(18));
   }
 
-  // Field 11: drain_period_ms
-  if (_has_field_[11]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(11, drain_period_ms_, msg);
+  // Field 2: producers_connected
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, producers_connected_, msg);
   }
 
-  // Field 12: compact_sched
-  if (_has_field_[12]) {
-    (*compact_sched_).Serialize(msg->BeginNestedMessage<::protozero::Message>(12));
+  // Field 3: producers_seen
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, producers_seen_, msg);
   }
 
-  // Field 22: print_filter
-  if (_has_field_[22]) {
-    (*print_filter_).Serialize(msg->BeginNestedMessage<::protozero::Message>(22));
+  // Field 4: data_sources_registered
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, data_sources_registered_, msg);
   }
 
-  // Field 13: symbolize_ksyms
-  if (_has_field_[13]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(13, symbolize_ksyms_, msg);
+  // Field 5: data_sources_seen
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, data_sources_seen_, msg);
   }
 
-  // Field 17: ksyms_mem_policy
-  if (_has_field_[17]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(17, ksyms_mem_policy_, msg);
+  // Field 6: tracing_sessions
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, tracing_sessions_, msg);
   }
 
-  // Field 14: initialize_ksyms_synchronously_for_testing
-  if (_has_field_[14]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(14, initialize_ksyms_synchronously_for_testing_, msg);
+  // Field 7: total_buffers
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(7, total_buffers_, msg);
   }
 
-  // Field 15: throttle_rss_stat
-  if (_has_field_[15]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(15, throttle_rss_stat_, msg);
+  // Field 8: chunks_discarded
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(8, chunks_discarded_, msg);
   }
 
-  // Field 16: disable_generic_events
-  if (_has_field_[16]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(16, disable_generic_events_, msg);
+  // Field 9: patches_discarded
+  if (_has_field_[9]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(9, patches_discarded_, msg);
   }
 
-  // Field 18: syscall_events
-  for (auto& it : syscall_events_) {
-    ::protozero::internal::gen_helpers::SerializeString(18, it, msg);
+  // Field 10: invalid_packets
+  if (_has_field_[10]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(10, invalid_packets_, msg);
   }
 
-  // Field 19: enable_function_graph
-  if (_has_field_[19]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(19, enable_function_graph_, msg);
+  // Field 11: filter_stats
+  if (_has_field_[11]) {
+    (*filter_stats_).Serialize(msg->BeginNestedMessage<::protozero::Message>(11));
   }
 
-  // Field 20: function_filters
-  for (auto& it : function_filters_) {
-    ::protozero::internal::gen_helpers::SerializeString(20, it, msg);
+  // Field 12: flushes_requested
+  if (_has_field_[12]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(12, flushes_requested_, msg);
   }
 
-  // Field 21: function_graph_roots
-  for (auto& it : function_graph_roots_) {
-    ::protozero::internal::gen_helpers::SerializeString(21, it, msg);
+  // Field 13: flushes_succeeded
+  if (_has_field_[13]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(13, flushes_succeeded_, msg);
   }
 
-  // Field 23: preserve_ftrace_buffer
-  if (_has_field_[23]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(23, preserve_ftrace_buffer_, msg);
+  // Field 14: flushes_failed
+  if (_has_field_[14]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(14, flushes_failed_, msg);
   }
 
-  // Field 24: use_monotonic_raw_clock
-  if (_has_field_[24]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(24, use_monotonic_raw_clock_, msg);
+  // Field 15: final_flush_outcome
+  if (_has_field_[15]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(15, final_flush_outcome_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-FtraceConfig_PrintFilter::FtraceConfig_PrintFilter() = default;
-FtraceConfig_PrintFilter::~FtraceConfig_PrintFilter() = default;
-FtraceConfig_PrintFilter::FtraceConfig_PrintFilter(const FtraceConfig_PrintFilter&) = default;
-FtraceConfig_PrintFilter& FtraceConfig_PrintFilter::operator=(const FtraceConfig_PrintFilter&) = default;
-FtraceConfig_PrintFilter::FtraceConfig_PrintFilter(FtraceConfig_PrintFilter&&) noexcept = default;
-FtraceConfig_PrintFilter& FtraceConfig_PrintFilter::operator=(FtraceConfig_PrintFilter&&) = default;
+TraceStats_FilterStats::TraceStats_FilterStats() = default;
+TraceStats_FilterStats::~TraceStats_FilterStats() = default;
+TraceStats_FilterStats::TraceStats_FilterStats(const TraceStats_FilterStats&) = default;
+TraceStats_FilterStats& TraceStats_FilterStats::operator=(const TraceStats_FilterStats&) = default;
+TraceStats_FilterStats::TraceStats_FilterStats(TraceStats_FilterStats&&) noexcept = default;
+TraceStats_FilterStats& TraceStats_FilterStats::operator=(TraceStats_FilterStats&&) = default;
 
-bool FtraceConfig_PrintFilter::operator==(const FtraceConfig_PrintFilter& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && rules_ == other.rules_;
+bool TraceStats_FilterStats::operator==(const TraceStats_FilterStats& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(input_packets_, other.input_packets_)
+   && ::protozero::internal::gen_helpers::EqualsField(input_bytes_, other.input_bytes_)
+   && ::protozero::internal::gen_helpers::EqualsField(output_bytes_, other.output_bytes_)
+   && ::protozero::internal::gen_helpers::EqualsField(errors_, other.errors_)
+   && ::protozero::internal::gen_helpers::EqualsField(time_taken_ns_, other.time_taken_ns_)
+   && ::protozero::internal::gen_helpers::EqualsField(bytes_discarded_per_buffer_, other.bytes_discarded_per_buffer_);
 }
 
-int FtraceConfig_PrintFilter::rules_size() const { return static_cast<int>(rules_.size()); }
-void FtraceConfig_PrintFilter::clear_rules() { rules_.clear(); }
-FtraceConfig_PrintFilter_Rule* FtraceConfig_PrintFilter::add_rules() { rules_.emplace_back(); return &rules_.back(); }
-bool FtraceConfig_PrintFilter::ParseFromArray(const void* raw, size_t size) {
-  rules_.clear();
+bool TraceStats_FilterStats::ParseFromArray(const void* raw, size_t size) {
+  bytes_discarded_per_buffer_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -19693,9 +18934,24 @@ bool FtraceConfig_PrintFilter::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* rules */:
-        rules_.emplace_back();
-        rules_.back().ParseFromArray(field.data(), field.size());
+      case 1 /* input_packets */:
+        field.get(&input_packets_);
+        break;
+      case 2 /* input_bytes */:
+        field.get(&input_bytes_);
+        break;
+      case 3 /* output_bytes */:
+        field.get(&output_bytes_);
+        break;
+      case 4 /* errors */:
+        field.get(&errors_);
+        break;
+      case 5 /* time_taken_ns */:
+        field.get(&time_taken_ns_);
+        break;
+      case 20 /* bytes_discarded_per_buffer */:
+        bytes_discarded_per_buffer_.emplace_back();
+        field.get(&bytes_discarded_per_buffer_.back());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -19705,43 +18961,71 @@ bool FtraceConfig_PrintFilter::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string FtraceConfig_PrintFilter::SerializeAsString() const {
+std::string TraceStats_FilterStats::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> FtraceConfig_PrintFilter::SerializeAsArray() const {
+std::vector<uint8_t> TraceStats_FilterStats::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void FtraceConfig_PrintFilter::Serialize(::protozero::Message* msg) const {
-  // Field 1: rules
-  for (auto& it : rules_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
+void TraceStats_FilterStats::Serialize(::protozero::Message* msg) const {
+  // Field 1: input_packets
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, input_packets_, msg);
+  }
+
+  // Field 2: input_bytes
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, input_bytes_, msg);
+  }
+
+  // Field 3: output_bytes
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, output_bytes_, msg);
+  }
+
+  // Field 4: errors
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, errors_, msg);
+  }
+
+  // Field 5: time_taken_ns
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, time_taken_ns_, msg);
+  }
+
+  // Field 20: bytes_discarded_per_buffer
+  for (auto& it : bytes_discarded_per_buffer_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(20, it, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-FtraceConfig_PrintFilter_Rule::FtraceConfig_PrintFilter_Rule() = default;
-FtraceConfig_PrintFilter_Rule::~FtraceConfig_PrintFilter_Rule() = default;
-FtraceConfig_PrintFilter_Rule::FtraceConfig_PrintFilter_Rule(const FtraceConfig_PrintFilter_Rule&) = default;
-FtraceConfig_PrintFilter_Rule& FtraceConfig_PrintFilter_Rule::operator=(const FtraceConfig_PrintFilter_Rule&) = default;
-FtraceConfig_PrintFilter_Rule::FtraceConfig_PrintFilter_Rule(FtraceConfig_PrintFilter_Rule&&) noexcept = default;
-FtraceConfig_PrintFilter_Rule& FtraceConfig_PrintFilter_Rule::operator=(FtraceConfig_PrintFilter_Rule&&) = default;
+TraceStats_WriterStats::TraceStats_WriterStats() = default;
+TraceStats_WriterStats::~TraceStats_WriterStats() = default;
+TraceStats_WriterStats::TraceStats_WriterStats(const TraceStats_WriterStats&) = default;
+TraceStats_WriterStats& TraceStats_WriterStats::operator=(const TraceStats_WriterStats&) = default;
+TraceStats_WriterStats::TraceStats_WriterStats(TraceStats_WriterStats&&) noexcept = default;
+TraceStats_WriterStats& TraceStats_WriterStats::operator=(TraceStats_WriterStats&&) = default;
 
-bool FtraceConfig_PrintFilter_Rule::operator==(const FtraceConfig_PrintFilter_Rule& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && prefix_ == other.prefix_
-   && atrace_msg_ == other.atrace_msg_
-   && allow_ == other.allow_;
+bool TraceStats_WriterStats::operator==(const TraceStats_WriterStats& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(sequence_id_, other.sequence_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(buffer_, other.buffer_)
+   && ::protozero::internal::gen_helpers::EqualsField(chunk_payload_histogram_counts_, other.chunk_payload_histogram_counts_)
+   && ::protozero::internal::gen_helpers::EqualsField(chunk_payload_histogram_sum_, other.chunk_payload_histogram_sum_);
 }
 
-bool FtraceConfig_PrintFilter_Rule::ParseFromArray(const void* raw, size_t size) {
+bool TraceStats_WriterStats::ParseFromArray(const void* raw, size_t size) {
+  chunk_payload_histogram_counts_.clear();
+  chunk_payload_histogram_sum_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -19751,14 +19035,19 @@ bool FtraceConfig_PrintFilter_Rule::ParseFromArray(const void* raw, size_t size)
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* prefix */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &prefix_);
+      case 1 /* sequence_id */:
+        field.get(&sequence_id_);
         break;
-      case 3 /* atrace_msg */:
-        (*atrace_msg_).ParseFromArray(field.data(), field.size());
+      case 4 /* buffer */:
+        field.get(&buffer_);
         break;
-      case 2 /* allow */:
-        field.get(&allow_);
+      case 2 /* chunk_payload_histogram_counts */:
+        if (!::protozero::internal::gen_helpers::DeserializePackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(field, &chunk_payload_histogram_counts_)) {
+          packed_error = true;}
+        break;
+      case 3 /* chunk_payload_histogram_sum */:
+        if (!::protozero::internal::gen_helpers::DeserializePackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, int64_t>(field, &chunk_payload_histogram_sum_)) {
+          packed_error = true;}
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -19768,52 +19057,81 @@ bool FtraceConfig_PrintFilter_Rule::ParseFromArray(const void* raw, size_t size)
   return !packed_error && !dec.bytes_left();
 }
 
-std::string FtraceConfig_PrintFilter_Rule::SerializeAsString() const {
+std::string TraceStats_WriterStats::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> FtraceConfig_PrintFilter_Rule::SerializeAsArray() const {
+std::vector<uint8_t> TraceStats_WriterStats::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void FtraceConfig_PrintFilter_Rule::Serialize(::protozero::Message* msg) const {
-  // Field 1: prefix
+void TraceStats_WriterStats::Serialize(::protozero::Message* msg) const {
+  // Field 1: sequence_id
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeString(1, prefix_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, sequence_id_, msg);
   }
 
-  // Field 3: atrace_msg
-  if (_has_field_[3]) {
-    (*atrace_msg_).Serialize(msg->BeginNestedMessage<::protozero::Message>(3));
+  // Field 4: buffer
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, buffer_, msg);
   }
 
-  // Field 2: allow
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, allow_, msg);
+  // Field 2: chunk_payload_histogram_counts
+  {
+    ::protozero::PackedVarInt pack;
+    for (auto& it : chunk_payload_histogram_counts_)
+      pack.Append(it);
+    msg->AppendBytes(2, pack.data(), pack.size());
+  }
+
+  // Field 3: chunk_payload_histogram_sum
+  {
+    ::protozero::PackedVarInt pack;
+    for (auto& it : chunk_payload_histogram_sum_)
+      pack.Append(it);
+    msg->AppendBytes(3, pack.data(), pack.size());
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-FtraceConfig_PrintFilter_Rule_AtraceMessage::FtraceConfig_PrintFilter_Rule_AtraceMessage() = default;
-FtraceConfig_PrintFilter_Rule_AtraceMessage::~FtraceConfig_PrintFilter_Rule_AtraceMessage() = default;
-FtraceConfig_PrintFilter_Rule_AtraceMessage::FtraceConfig_PrintFilter_Rule_AtraceMessage(const FtraceConfig_PrintFilter_Rule_AtraceMessage&) = default;
-FtraceConfig_PrintFilter_Rule_AtraceMessage& FtraceConfig_PrintFilter_Rule_AtraceMessage::operator=(const FtraceConfig_PrintFilter_Rule_AtraceMessage&) = default;
-FtraceConfig_PrintFilter_Rule_AtraceMessage::FtraceConfig_PrintFilter_Rule_AtraceMessage(FtraceConfig_PrintFilter_Rule_AtraceMessage&&) noexcept = default;
-FtraceConfig_PrintFilter_Rule_AtraceMessage& FtraceConfig_PrintFilter_Rule_AtraceMessage::operator=(FtraceConfig_PrintFilter_Rule_AtraceMessage&&) = default;
-
-bool FtraceConfig_PrintFilter_Rule_AtraceMessage::operator==(const FtraceConfig_PrintFilter_Rule_AtraceMessage& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && type_ == other.type_
-   && prefix_ == other.prefix_;
-}
-
-bool FtraceConfig_PrintFilter_Rule_AtraceMessage::ParseFromArray(const void* raw, size_t size) {
+TraceStats_BufferStats::TraceStats_BufferStats() = default;
+TraceStats_BufferStats::~TraceStats_BufferStats() = default;
+TraceStats_BufferStats::TraceStats_BufferStats(const TraceStats_BufferStats&) = default;
+TraceStats_BufferStats& TraceStats_BufferStats::operator=(const TraceStats_BufferStats&) = default;
+TraceStats_BufferStats::TraceStats_BufferStats(TraceStats_BufferStats&&) noexcept = default;
+TraceStats_BufferStats& TraceStats_BufferStats::operator=(TraceStats_BufferStats&&) = default;
+
+bool TraceStats_BufferStats::operator==(const TraceStats_BufferStats& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(buffer_size_, other.buffer_size_)
+   && ::protozero::internal::gen_helpers::EqualsField(bytes_written_, other.bytes_written_)
+   && ::protozero::internal::gen_helpers::EqualsField(bytes_overwritten_, other.bytes_overwritten_)
+   && ::protozero::internal::gen_helpers::EqualsField(bytes_read_, other.bytes_read_)
+   && ::protozero::internal::gen_helpers::EqualsField(padding_bytes_written_, other.padding_bytes_written_)
+   && ::protozero::internal::gen_helpers::EqualsField(padding_bytes_cleared_, other.padding_bytes_cleared_)
+   && ::protozero::internal::gen_helpers::EqualsField(chunks_written_, other.chunks_written_)
+   && ::protozero::internal::gen_helpers::EqualsField(chunks_rewritten_, other.chunks_rewritten_)
+   && ::protozero::internal::gen_helpers::EqualsField(chunks_overwritten_, other.chunks_overwritten_)
+   && ::protozero::internal::gen_helpers::EqualsField(chunks_discarded_, other.chunks_discarded_)
+   && ::protozero::internal::gen_helpers::EqualsField(chunks_read_, other.chunks_read_)
+   && ::protozero::internal::gen_helpers::EqualsField(chunks_committed_out_of_order_, other.chunks_committed_out_of_order_)
+   && ::protozero::internal::gen_helpers::EqualsField(write_wrap_count_, other.write_wrap_count_)
+   && ::protozero::internal::gen_helpers::EqualsField(patches_succeeded_, other.patches_succeeded_)
+   && ::protozero::internal::gen_helpers::EqualsField(patches_failed_, other.patches_failed_)
+   && ::protozero::internal::gen_helpers::EqualsField(readaheads_succeeded_, other.readaheads_succeeded_)
+   && ::protozero::internal::gen_helpers::EqualsField(readaheads_failed_, other.readaheads_failed_)
+   && ::protozero::internal::gen_helpers::EqualsField(abi_violations_, other.abi_violations_)
+   && ::protozero::internal::gen_helpers::EqualsField(trace_writer_packet_loss_, other.trace_writer_packet_loss_)
+   && ::protozero::internal::gen_helpers::EqualsField(shadow_buffer_stats_, other.shadow_buffer_stats_);
+}
+
+bool TraceStats_BufferStats::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -19823,11 +19141,65 @@ bool FtraceConfig_PrintFilter_Rule_AtraceMessage::ParseFromArray(const void* raw
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* type */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &type_);
+      case 12 /* buffer_size */:
+        field.get(&buffer_size_);
         break;
-      case 2 /* prefix */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &prefix_);
+      case 1 /* bytes_written */:
+        field.get(&bytes_written_);
+        break;
+      case 13 /* bytes_overwritten */:
+        field.get(&bytes_overwritten_);
+        break;
+      case 14 /* bytes_read */:
+        field.get(&bytes_read_);
+        break;
+      case 15 /* padding_bytes_written */:
+        field.get(&padding_bytes_written_);
+        break;
+      case 16 /* padding_bytes_cleared */:
+        field.get(&padding_bytes_cleared_);
+        break;
+      case 2 /* chunks_written */:
+        field.get(&chunks_written_);
+        break;
+      case 10 /* chunks_rewritten */:
+        field.get(&chunks_rewritten_);
+        break;
+      case 3 /* chunks_overwritten */:
+        field.get(&chunks_overwritten_);
+        break;
+      case 18 /* chunks_discarded */:
+        field.get(&chunks_discarded_);
+        break;
+      case 17 /* chunks_read */:
+        field.get(&chunks_read_);
+        break;
+      case 11 /* chunks_committed_out_of_order */:
+        field.get(&chunks_committed_out_of_order_);
+        break;
+      case 4 /* write_wrap_count */:
+        field.get(&write_wrap_count_);
+        break;
+      case 5 /* patches_succeeded */:
+        field.get(&patches_succeeded_);
+        break;
+      case 6 /* patches_failed */:
+        field.get(&patches_failed_);
+        break;
+      case 7 /* readaheads_succeeded */:
+        field.get(&readaheads_succeeded_);
+        break;
+      case 8 /* readaheads_failed */:
+        field.get(&readaheads_failed_);
+        break;
+      case 9 /* abi_violations */:
+        field.get(&abi_violations_);
+        break;
+      case 19 /* trace_writer_packet_loss */:
+        field.get(&trace_writer_packet_loss_);
+        break;
+      case 21 /* shadow_buffer_stats */:
+        (*shadow_buffer_stats_).ParseFromArray(field.data(), field.size());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -19837,46 +19209,143 @@ bool FtraceConfig_PrintFilter_Rule_AtraceMessage::ParseFromArray(const void* raw
   return !packed_error && !dec.bytes_left();
 }
 
-std::string FtraceConfig_PrintFilter_Rule_AtraceMessage::SerializeAsString() const {
+std::string TraceStats_BufferStats::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> FtraceConfig_PrintFilter_Rule_AtraceMessage::SerializeAsArray() const {
+std::vector<uint8_t> TraceStats_BufferStats::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void FtraceConfig_PrintFilter_Rule_AtraceMessage::Serialize(::protozero::Message* msg) const {
-  // Field 1: type
+void TraceStats_BufferStats::Serialize(::protozero::Message* msg) const {
+  // Field 12: buffer_size
+  if (_has_field_[12]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(12, buffer_size_, msg);
+  }
+
+  // Field 1: bytes_written
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeString(1, type_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, bytes_written_, msg);
   }
 
-  // Field 2: prefix
+  // Field 13: bytes_overwritten
+  if (_has_field_[13]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(13, bytes_overwritten_, msg);
+  }
+
+  // Field 14: bytes_read
+  if (_has_field_[14]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(14, bytes_read_, msg);
+  }
+
+  // Field 15: padding_bytes_written
+  if (_has_field_[15]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(15, padding_bytes_written_, msg);
+  }
+
+  // Field 16: padding_bytes_cleared
+  if (_has_field_[16]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(16, padding_bytes_cleared_, msg);
+  }
+
+  // Field 2: chunks_written
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeString(2, prefix_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, chunks_written_, msg);
+  }
+
+  // Field 10: chunks_rewritten
+  if (_has_field_[10]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(10, chunks_rewritten_, msg);
+  }
+
+  // Field 3: chunks_overwritten
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, chunks_overwritten_, msg);
+  }
+
+  // Field 18: chunks_discarded
+  if (_has_field_[18]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(18, chunks_discarded_, msg);
+  }
+
+  // Field 17: chunks_read
+  if (_has_field_[17]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(17, chunks_read_, msg);
+  }
+
+  // Field 11: chunks_committed_out_of_order
+  if (_has_field_[11]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(11, chunks_committed_out_of_order_, msg);
+  }
+
+  // Field 4: write_wrap_count
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, write_wrap_count_, msg);
+  }
+
+  // Field 5: patches_succeeded
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, patches_succeeded_, msg);
+  }
+
+  // Field 6: patches_failed
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, patches_failed_, msg);
+  }
+
+  // Field 7: readaheads_succeeded
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(7, readaheads_succeeded_, msg);
+  }
+
+  // Field 8: readaheads_failed
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(8, readaheads_failed_, msg);
+  }
+
+  // Field 9: abi_violations
+  if (_has_field_[9]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(9, abi_violations_, msg);
+  }
+
+  // Field 19: trace_writer_packet_loss
+  if (_has_field_[19]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(19, trace_writer_packet_loss_, msg);
+  }
+
+  // Field 21: shadow_buffer_stats
+  if (_has_field_[21]) {
+    (*shadow_buffer_stats_).Serialize(msg->BeginNestedMessage<::protozero::Message>(21));
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-FtraceConfig_CompactSchedConfig::FtraceConfig_CompactSchedConfig() = default;
-FtraceConfig_CompactSchedConfig::~FtraceConfig_CompactSchedConfig() = default;
-FtraceConfig_CompactSchedConfig::FtraceConfig_CompactSchedConfig(const FtraceConfig_CompactSchedConfig&) = default;
-FtraceConfig_CompactSchedConfig& FtraceConfig_CompactSchedConfig::operator=(const FtraceConfig_CompactSchedConfig&) = default;
-FtraceConfig_CompactSchedConfig::FtraceConfig_CompactSchedConfig(FtraceConfig_CompactSchedConfig&&) noexcept = default;
-FtraceConfig_CompactSchedConfig& FtraceConfig_CompactSchedConfig::operator=(FtraceConfig_CompactSchedConfig&&) = default;
+TraceStats_BufferStats_ShadowBufferStats::TraceStats_BufferStats_ShadowBufferStats() = default;
+TraceStats_BufferStats_ShadowBufferStats::~TraceStats_BufferStats_ShadowBufferStats() = default;
+TraceStats_BufferStats_ShadowBufferStats::TraceStats_BufferStats_ShadowBufferStats(const TraceStats_BufferStats_ShadowBufferStats&) = default;
+TraceStats_BufferStats_ShadowBufferStats& TraceStats_BufferStats_ShadowBufferStats::operator=(const TraceStats_BufferStats_ShadowBufferStats&) = default;
+TraceStats_BufferStats_ShadowBufferStats::TraceStats_BufferStats_ShadowBufferStats(TraceStats_BufferStats_ShadowBufferStats&&) noexcept = default;
+TraceStats_BufferStats_ShadowBufferStats& TraceStats_BufferStats_ShadowBufferStats::operator=(TraceStats_BufferStats_ShadowBufferStats&&) = default;
 
-bool FtraceConfig_CompactSchedConfig::operator==(const FtraceConfig_CompactSchedConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && enabled_ == other.enabled_;
+bool TraceStats_BufferStats_ShadowBufferStats::operator==(const TraceStats_BufferStats_ShadowBufferStats& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(packets_seen_, other.packets_seen_)
+   && ::protozero::internal::gen_helpers::EqualsField(packets_in_both_, other.packets_in_both_)
+   && ::protozero::internal::gen_helpers::EqualsField(packets_only_v1_, other.packets_only_v1_)
+   && ::protozero::internal::gen_helpers::EqualsField(packets_only_v2_, other.packets_only_v2_)
+   && ::protozero::internal::gen_helpers::EqualsField(patches_attempted_, other.patches_attempted_)
+   && ::protozero::internal::gen_helpers::EqualsField(v1_patches_succeeded_, other.v1_patches_succeeded_)
+   && ::protozero::internal::gen_helpers::EqualsField(v2_patches_succeeded_, other.v2_patches_succeeded_)
+   && ::protozero::internal::gen_helpers::EqualsField(stats_version_, other.stats_version_);
 }
 
-bool FtraceConfig_CompactSchedConfig::ParseFromArray(const void* raw, size_t size) {
+bool TraceStats_BufferStats_ShadowBufferStats::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -19886,8 +19355,29 @@ bool FtraceConfig_CompactSchedConfig::ParseFromArray(const void* raw, size_t siz
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* enabled */:
-        field.get(&enabled_);
+      case 1 /* packets_seen */:
+        field.get(&packets_seen_);
+        break;
+      case 2 /* packets_in_both */:
+        field.get(&packets_in_both_);
+        break;
+      case 3 /* packets_only_v1 */:
+        field.get(&packets_only_v1_);
+        break;
+      case 4 /* packets_only_v2 */:
+        field.get(&packets_only_v2_);
+        break;
+      case 5 /* patches_attempted */:
+        field.get(&patches_attempted_);
+        break;
+      case 6 /* v1_patches_succeeded */:
+        field.get(&v1_patches_succeeded_);
+        break;
+      case 7 /* v2_patches_succeeded */:
+        field.get(&v2_patches_succeeded_);
+        break;
+      case 8 /* stats_version */:
+        field.get(&stats_version_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -19897,125 +19387,69 @@ bool FtraceConfig_CompactSchedConfig::ParseFromArray(const void* raw, size_t siz
   return !packed_error && !dec.bytes_left();
 }
 
-std::string FtraceConfig_CompactSchedConfig::SerializeAsString() const {
+std::string TraceStats_BufferStats_ShadowBufferStats::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> FtraceConfig_CompactSchedConfig::SerializeAsArray() const {
+std::vector<uint8_t> TraceStats_BufferStats_ShadowBufferStats::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void FtraceConfig_CompactSchedConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: enabled
+void TraceStats_BufferStats_ShadowBufferStats::Serialize(::protozero::Message* msg) const {
+  // Field 1: packets_seen
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(1, enabled_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, packets_seen_, msg);
   }
 
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
-}
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/gpu/gpu_counter_config.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/gpu/gpu_counter_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_GPU_COUNTER_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_GPU_COUNTER_CONFIG_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class GpuCounterConfig;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  // Field 2: packets_in_both
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, packets_in_both_, msg);
+  }
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  // Field 3: packets_only_v1
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, packets_only_v1_, msg);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+  // Field 4: packets_only_v2
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, packets_only_v2_, msg);
+  }
 
-class PERFETTO_EXPORT_COMPONENT GpuCounterConfig : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kCounterPeriodNsFieldNumber = 1,
-    kCounterIdsFieldNumber = 2,
-    kInstrumentedSamplingFieldNumber = 3,
-    kFixGpuClockFieldNumber = 4,
-  };
+  // Field 5: patches_attempted
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, patches_attempted_, msg);
+  }
 
-  GpuCounterConfig();
-  ~GpuCounterConfig() override;
-  GpuCounterConfig(GpuCounterConfig&&) noexcept;
-  GpuCounterConfig& operator=(GpuCounterConfig&&);
-  GpuCounterConfig(const GpuCounterConfig&);
-  GpuCounterConfig& operator=(const GpuCounterConfig&);
-  bool operator==(const GpuCounterConfig&) const;
-  bool operator!=(const GpuCounterConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_counter_period_ns() const { return _has_field_[1]; }
-  uint64_t counter_period_ns() const { return counter_period_ns_; }
-  void set_counter_period_ns(uint64_t value) { counter_period_ns_ = value; _has_field_.set(1); }
-
-  const std::vector<uint32_t>& counter_ids() const { return counter_ids_; }
-  std::vector<uint32_t>* mutable_counter_ids() { return &counter_ids_; }
-  int counter_ids_size() const { return static_cast<int>(counter_ids_.size()); }
-  void clear_counter_ids() { counter_ids_.clear(); }
-  void add_counter_ids(uint32_t value) { counter_ids_.emplace_back(value); }
-  uint32_t* add_counter_ids() { counter_ids_.emplace_back(); return &counter_ids_.back(); }
-
-  bool has_instrumented_sampling() const { return _has_field_[3]; }
-  bool instrumented_sampling() const { return instrumented_sampling_; }
-  void set_instrumented_sampling(bool value) { instrumented_sampling_ = value; _has_field_.set(3); }
-
-  bool has_fix_gpu_clock() const { return _has_field_[4]; }
-  bool fix_gpu_clock() const { return fix_gpu_clock_; }
-  void set_fix_gpu_clock(bool value) { fix_gpu_clock_ = value; _has_field_.set(4); }
+  // Field 6: v1_patches_succeeded
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, v1_patches_succeeded_, msg);
+  }
 
- private:
-  uint64_t counter_period_ns_{};
-  std::vector<uint32_t> counter_ids_;
-  bool instrumented_sampling_{};
-  bool fix_gpu_clock_{};
+  // Field 7: v2_patches_succeeded
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(7, v2_patches_succeeded_, msg);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  // Field 8: stats_version
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(8, stats_version_, msg);
+  }
 
-  std::bitset<5> _has_field_{};
-};
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_GPU_COUNTER_CONFIG_PROTO_CPP_H_
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/common/tracing_service_capabilities.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -20026,29 +19460,30 @@ class PERFETTO_EXPORT_COMPONENT GpuCounterConfig : public ::protozero::CppMessag
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/gpu/gpu_counter_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/tracing_service_capabilities.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/observable_events.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-GpuCounterConfig::GpuCounterConfig() = default;
-GpuCounterConfig::~GpuCounterConfig() = default;
-GpuCounterConfig::GpuCounterConfig(const GpuCounterConfig&) = default;
-GpuCounterConfig& GpuCounterConfig::operator=(const GpuCounterConfig&) = default;
-GpuCounterConfig::GpuCounterConfig(GpuCounterConfig&&) noexcept = default;
-GpuCounterConfig& GpuCounterConfig::operator=(GpuCounterConfig&&) = default;
+TracingServiceCapabilities::TracingServiceCapabilities() = default;
+TracingServiceCapabilities::~TracingServiceCapabilities() = default;
+TracingServiceCapabilities::TracingServiceCapabilities(const TracingServiceCapabilities&) = default;
+TracingServiceCapabilities& TracingServiceCapabilities::operator=(const TracingServiceCapabilities&) = default;
+TracingServiceCapabilities::TracingServiceCapabilities(TracingServiceCapabilities&&) noexcept = default;
+TracingServiceCapabilities& TracingServiceCapabilities::operator=(TracingServiceCapabilities&&) = default;
 
-bool GpuCounterConfig::operator==(const GpuCounterConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && counter_period_ns_ == other.counter_period_ns_
-   && counter_ids_ == other.counter_ids_
-   && instrumented_sampling_ == other.instrumented_sampling_
-   && fix_gpu_clock_ == other.fix_gpu_clock_;
+bool TracingServiceCapabilities::operator==(const TracingServiceCapabilities& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(has_query_capabilities_, other.has_query_capabilities_)
+   && ::protozero::internal::gen_helpers::EqualsField(observable_events_, other.observable_events_)
+   && ::protozero::internal::gen_helpers::EqualsField(has_trace_config_output_path_, other.has_trace_config_output_path_)
+   && ::protozero::internal::gen_helpers::EqualsField(has_clone_session_, other.has_clone_session_);
 }
 
-bool GpuCounterConfig::ParseFromArray(const void* raw, size_t size) {
-  counter_ids_.clear();
+bool TracingServiceCapabilities::ParseFromArray(const void* raw, size_t size) {
+  observable_events_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -20058,18 +19493,18 @@ bool GpuCounterConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* counter_period_ns */:
-        field.get(&counter_period_ns_);
+      case 1 /* has_query_capabilities */:
+        field.get(&has_query_capabilities_);
         break;
-      case 2 /* counter_ids */:
-        counter_ids_.emplace_back();
-        field.get(&counter_ids_.back());
+      case 2 /* observable_events */:
+        observable_events_.emplace_back();
+        field.get(&observable_events_.back());
         break;
-      case 3 /* instrumented_sampling */:
-        field.get(&instrumented_sampling_);
+      case 3 /* has_trace_config_output_path */:
+        field.get(&has_trace_config_output_path_);
         break;
-      case 4 /* fix_gpu_clock */:
-        field.get(&fix_gpu_clock_);
+      case 4 /* has_clone_session */:
+        field.get(&has_clone_session_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -20079,37 +19514,37 @@ bool GpuCounterConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string GpuCounterConfig::SerializeAsString() const {
+std::string TracingServiceCapabilities::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> GpuCounterConfig::SerializeAsArray() const {
+std::vector<uint8_t> TracingServiceCapabilities::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void GpuCounterConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: counter_period_ns
+void TracingServiceCapabilities::Serialize(::protozero::Message* msg) const {
+  // Field 1: has_query_capabilities
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, counter_period_ns_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(1, has_query_capabilities_, msg);
   }
 
-  // Field 2: counter_ids
-  for (auto& it : counter_ids_) {
+  // Field 2: observable_events
+  for (auto& it : observable_events_) {
     ::protozero::internal::gen_helpers::SerializeVarInt(2, it, msg);
   }
 
-  // Field 3: instrumented_sampling
+  // Field 3: has_trace_config_output_path
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, instrumented_sampling_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, has_trace_config_output_path_, msg);
   }
 
-  // Field 4: fix_gpu_clock
+  // Field 4: has_clone_session
   if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(4, fix_gpu_clock_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(4, has_clone_session_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -20121,83 +19556,7 @@ void GpuCounterConfig::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/gpu/vulkan_memory_config.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/gpu/vulkan_memory_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_VULKAN_MEMORY_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_VULKAN_MEMORY_CONFIG_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class VulkanMemoryConfig;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT VulkanMemoryConfig : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kTrackDriverMemoryUsageFieldNumber = 1,
-    kTrackDeviceMemoryUsageFieldNumber = 2,
-  };
-
-  VulkanMemoryConfig();
-  ~VulkanMemoryConfig() override;
-  VulkanMemoryConfig(VulkanMemoryConfig&&) noexcept;
-  VulkanMemoryConfig& operator=(VulkanMemoryConfig&&);
-  VulkanMemoryConfig(const VulkanMemoryConfig&);
-  VulkanMemoryConfig& operator=(const VulkanMemoryConfig&);
-  bool operator==(const VulkanMemoryConfig&) const;
-  bool operator!=(const VulkanMemoryConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_track_driver_memory_usage() const { return _has_field_[1]; }
-  bool track_driver_memory_usage() const { return track_driver_memory_usage_; }
-  void set_track_driver_memory_usage(bool value) { track_driver_memory_usage_ = value; _has_field_.set(1); }
-
-  bool has_track_device_memory_usage() const { return _has_field_[2]; }
-  bool track_device_memory_usage() const { return track_device_memory_usage_; }
-  void set_track_device_memory_usage(bool value) { track_device_memory_usage_ = value; _has_field_.set(2); }
-
- private:
-  bool track_driver_memory_usage_{};
-  bool track_device_memory_usage_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_VULKAN_MEMORY_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin source: gen/protos/perfetto/common/tracing_service_state.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -20208,26 +19567,48 @@ class PERFETTO_EXPORT_COMPONENT VulkanMemoryConfig : public ::protozero::CppMess
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/gpu/vulkan_memory_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/tracing_service_state.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/data_source_descriptor.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/protovm/vm_program.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/track_event_descriptor.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/gpu_counter_descriptor.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/ftrace_descriptor.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-VulkanMemoryConfig::VulkanMemoryConfig() = default;
-VulkanMemoryConfig::~VulkanMemoryConfig() = default;
-VulkanMemoryConfig::VulkanMemoryConfig(const VulkanMemoryConfig&) = default;
-VulkanMemoryConfig& VulkanMemoryConfig::operator=(const VulkanMemoryConfig&) = default;
-VulkanMemoryConfig::VulkanMemoryConfig(VulkanMemoryConfig&&) noexcept = default;
-VulkanMemoryConfig& VulkanMemoryConfig::operator=(VulkanMemoryConfig&&) = default;
+TracingServiceState::TracingServiceState() = default;
+TracingServiceState::~TracingServiceState() = default;
+TracingServiceState::TracingServiceState(const TracingServiceState&) = default;
+TracingServiceState& TracingServiceState::operator=(const TracingServiceState&) = default;
+TracingServiceState::TracingServiceState(TracingServiceState&&) noexcept = default;
+TracingServiceState& TracingServiceState::operator=(TracingServiceState&&) = default;
 
-bool VulkanMemoryConfig::operator==(const VulkanMemoryConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && track_driver_memory_usage_ == other.track_driver_memory_usage_
-   && track_device_memory_usage_ == other.track_device_memory_usage_;
+bool TracingServiceState::operator==(const TracingServiceState& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(producers_, other.producers_)
+   && ::protozero::internal::gen_helpers::EqualsField(data_sources_, other.data_sources_)
+   && ::protozero::internal::gen_helpers::EqualsField(tracing_sessions_, other.tracing_sessions_)
+   && ::protozero::internal::gen_helpers::EqualsField(supports_tracing_sessions_, other.supports_tracing_sessions_)
+   && ::protozero::internal::gen_helpers::EqualsField(num_sessions_, other.num_sessions_)
+   && ::protozero::internal::gen_helpers::EqualsField(num_sessions_started_, other.num_sessions_started_)
+   && ::protozero::internal::gen_helpers::EqualsField(tracing_service_version_, other.tracing_service_version_);
 }
 
-bool VulkanMemoryConfig::ParseFromArray(const void* raw, size_t size) {
+int TracingServiceState::producers_size() const { return static_cast<int>(producers_.size()); }
+void TracingServiceState::clear_producers() { producers_.clear(); }
+TracingServiceState_Producer* TracingServiceState::add_producers() { producers_.emplace_back(); return &producers_.back(); }
+int TracingServiceState::data_sources_size() const { return static_cast<int>(data_sources_.size()); }
+void TracingServiceState::clear_data_sources() { data_sources_.clear(); }
+TracingServiceState_DataSource* TracingServiceState::add_data_sources() { data_sources_.emplace_back(); return &data_sources_.back(); }
+int TracingServiceState::tracing_sessions_size() const { return static_cast<int>(tracing_sessions_.size()); }
+void TracingServiceState::clear_tracing_sessions() { tracing_sessions_.clear(); }
+TracingServiceState_TracingSession* TracingServiceState::add_tracing_sessions() { tracing_sessions_.emplace_back(); return &tracing_sessions_.back(); }
+bool TracingServiceState::ParseFromArray(const void* raw, size_t size) {
+  producers_.clear();
+  data_sources_.clear();
+  tracing_sessions_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -20237,11 +19618,29 @@ bool VulkanMemoryConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* track_driver_memory_usage */:
-        field.get(&track_driver_memory_usage_);
+      case 1 /* producers */:
+        producers_.emplace_back();
+        producers_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 2 /* track_device_memory_usage */:
-        field.get(&track_device_memory_usage_);
+      case 2 /* data_sources */:
+        data_sources_.emplace_back();
+        data_sources_.back().ParseFromArray(field.data(), field.size());
+        break;
+      case 6 /* tracing_sessions */:
+        tracing_sessions_.emplace_back();
+        tracing_sessions_.back().ParseFromArray(field.data(), field.size());
+        break;
+      case 7 /* supports_tracing_sessions */:
+        field.get(&supports_tracing_sessions_);
+        break;
+      case 3 /* num_sessions */:
+        field.get(&num_sessions_);
+        break;
+      case 4 /* num_sessions_started */:
+        field.get(&num_sessions_started_);
+        break;
+      case 5 /* tracing_service_version */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &tracing_service_version_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -20251,231 +19650,84 @@ bool VulkanMemoryConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string VulkanMemoryConfig::SerializeAsString() const {
+std::string TracingServiceState::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> VulkanMemoryConfig::SerializeAsArray() const {
+std::vector<uint8_t> TracingServiceState::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void VulkanMemoryConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: track_driver_memory_usage
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(1, track_driver_memory_usage_, msg);
+void TracingServiceState::Serialize(::protozero::Message* msg) const {
+  // Field 1: producers
+  for (auto& it : producers_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
   }
 
-  // Field 2: track_device_memory_usage
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, track_device_memory_usage_, msg);
+  // Field 2: data_sources
+  for (auto& it : data_sources_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
   }
 
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
-}
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/inode_file/inode_file_config.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/inode_file/inode_file_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INODE_FILE_INODE_FILE_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INODE_FILE_INODE_FILE_CONFIG_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class InodeFileConfig;
-class InodeFileConfig_MountPointMappingEntry;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT InodeFileConfig : public ::protozero::CppMessageObj {
- public:
-  using MountPointMappingEntry = InodeFileConfig_MountPointMappingEntry;
-  enum FieldNumbers {
-    kScanIntervalMsFieldNumber = 1,
-    kScanDelayMsFieldNumber = 2,
-    kScanBatchSizeFieldNumber = 3,
-    kDoNotScanFieldNumber = 4,
-    kScanMountPointsFieldNumber = 5,
-    kMountPointMappingFieldNumber = 6,
-  };
+  // Field 6: tracing_sessions
+  for (auto& it : tracing_sessions_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(6));
+  }
 
-  InodeFileConfig();
-  ~InodeFileConfig() override;
-  InodeFileConfig(InodeFileConfig&&) noexcept;
-  InodeFileConfig& operator=(InodeFileConfig&&);
-  InodeFileConfig(const InodeFileConfig&);
-  InodeFileConfig& operator=(const InodeFileConfig&);
-  bool operator==(const InodeFileConfig&) const;
-  bool operator!=(const InodeFileConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_scan_interval_ms() const { return _has_field_[1]; }
-  uint32_t scan_interval_ms() const { return scan_interval_ms_; }
-  void set_scan_interval_ms(uint32_t value) { scan_interval_ms_ = value; _has_field_.set(1); }
-
-  bool has_scan_delay_ms() const { return _has_field_[2]; }
-  uint32_t scan_delay_ms() const { return scan_delay_ms_; }
-  void set_scan_delay_ms(uint32_t value) { scan_delay_ms_ = value; _has_field_.set(2); }
-
-  bool has_scan_batch_size() const { return _has_field_[3]; }
-  uint32_t scan_batch_size() const { return scan_batch_size_; }
-  void set_scan_batch_size(uint32_t value) { scan_batch_size_ = value; _has_field_.set(3); }
-
-  bool has_do_not_scan() const { return _has_field_[4]; }
-  bool do_not_scan() const { return do_not_scan_; }
-  void set_do_not_scan(bool value) { do_not_scan_ = value; _has_field_.set(4); }
-
-  const std::vector<std::string>& scan_mount_points() const { return scan_mount_points_; }
-  std::vector<std::string>* mutable_scan_mount_points() { return &scan_mount_points_; }
-  int scan_mount_points_size() const { return static_cast<int>(scan_mount_points_.size()); }
-  void clear_scan_mount_points() { scan_mount_points_.clear(); }
-  void add_scan_mount_points(std::string value) { scan_mount_points_.emplace_back(value); }
-  std::string* add_scan_mount_points() { scan_mount_points_.emplace_back(); return &scan_mount_points_.back(); }
-
-  const std::vector<InodeFileConfig_MountPointMappingEntry>& mount_point_mapping() const { return mount_point_mapping_; }
-  std::vector<InodeFileConfig_MountPointMappingEntry>* mutable_mount_point_mapping() { return &mount_point_mapping_; }
-  int mount_point_mapping_size() const;
-  void clear_mount_point_mapping();
-  InodeFileConfig_MountPointMappingEntry* add_mount_point_mapping();
+  // Field 7: supports_tracing_sessions
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(7, supports_tracing_sessions_, msg);
+  }
 
- private:
-  uint32_t scan_interval_ms_{};
-  uint32_t scan_delay_ms_{};
-  uint32_t scan_batch_size_{};
-  bool do_not_scan_{};
-  std::vector<std::string> scan_mount_points_;
-  std::vector<InodeFileConfig_MountPointMappingEntry> mount_point_mapping_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<7> _has_field_{};
-};
+  // Field 3: num_sessions
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, num_sessions_, msg);
+  }
 
+  // Field 4: num_sessions_started
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, num_sessions_started_, msg);
+  }
 
-class PERFETTO_EXPORT_COMPONENT InodeFileConfig_MountPointMappingEntry : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kMountpointFieldNumber = 1,
-    kScanRootsFieldNumber = 2,
-  };
+  // Field 5: tracing_service_version
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeString(5, tracing_service_version_, msg);
+  }
 
-  InodeFileConfig_MountPointMappingEntry();
-  ~InodeFileConfig_MountPointMappingEntry() override;
-  InodeFileConfig_MountPointMappingEntry(InodeFileConfig_MountPointMappingEntry&&) noexcept;
-  InodeFileConfig_MountPointMappingEntry& operator=(InodeFileConfig_MountPointMappingEntry&&);
-  InodeFileConfig_MountPointMappingEntry(const InodeFileConfig_MountPointMappingEntry&);
-  InodeFileConfig_MountPointMappingEntry& operator=(const InodeFileConfig_MountPointMappingEntry&);
-  bool operator==(const InodeFileConfig_MountPointMappingEntry&) const;
-  bool operator!=(const InodeFileConfig_MountPointMappingEntry& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_mountpoint() const { return _has_field_[1]; }
-  const std::string& mountpoint() const { return mountpoint_; }
-  void set_mountpoint(const std::string& value) { mountpoint_ = value; _has_field_.set(1); }
-
-  const std::vector<std::string>& scan_roots() const { return scan_roots_; }
-  std::vector<std::string>* mutable_scan_roots() { return &scan_roots_; }
-  int scan_roots_size() const { return static_cast<int>(scan_roots_.size()); }
-  void clear_scan_roots() { scan_roots_.clear(); }
-  void add_scan_roots(std::string value) { scan_roots_.emplace_back(value); }
-  std::string* add_scan_roots() { scan_roots_.emplace_back(); return &scan_roots_.back(); }
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
- private:
-  std::string mountpoint_{};
-  std::vector<std::string> scan_roots_;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+TracingServiceState_TracingSession::TracingServiceState_TracingSession() = default;
+TracingServiceState_TracingSession::~TracingServiceState_TracingSession() = default;
+TracingServiceState_TracingSession::TracingServiceState_TracingSession(const TracingServiceState_TracingSession&) = default;
+TracingServiceState_TracingSession& TracingServiceState_TracingSession::operator=(const TracingServiceState_TracingSession&) = default;
+TracingServiceState_TracingSession::TracingServiceState_TracingSession(TracingServiceState_TracingSession&&) noexcept = default;
+TracingServiceState_TracingSession& TracingServiceState_TracingSession::operator=(TracingServiceState_TracingSession&&) = default;
 
-  std::bitset<3> _has_field_{};
-};
+bool TracingServiceState_TracingSession::operator==(const TracingServiceState_TracingSession& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(id_, other.id_)
+   && ::protozero::internal::gen_helpers::EqualsField(consumer_uid_, other.consumer_uid_)
+   && ::protozero::internal::gen_helpers::EqualsField(state_, other.state_)
+   && ::protozero::internal::gen_helpers::EqualsField(unique_session_name_, other.unique_session_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(buffer_size_kb_, other.buffer_size_kb_)
+   && ::protozero::internal::gen_helpers::EqualsField(duration_ms_, other.duration_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(num_data_sources_, other.num_data_sources_)
+   && ::protozero::internal::gen_helpers::EqualsField(start_realtime_ns_, other.start_realtime_ns_)
+   && ::protozero::internal::gen_helpers::EqualsField(bugreport_score_, other.bugreport_score_)
+   && ::protozero::internal::gen_helpers::EqualsField(bugreport_filename_, other.bugreport_filename_)
+   && ::protozero::internal::gen_helpers::EqualsField(is_started_, other.is_started_);
+}
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INODE_FILE_INODE_FILE_CONFIG_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/inode_file/inode_file_config.gen.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-InodeFileConfig::InodeFileConfig() = default;
-InodeFileConfig::~InodeFileConfig() = default;
-InodeFileConfig::InodeFileConfig(const InodeFileConfig&) = default;
-InodeFileConfig& InodeFileConfig::operator=(const InodeFileConfig&) = default;
-InodeFileConfig::InodeFileConfig(InodeFileConfig&&) noexcept = default;
-InodeFileConfig& InodeFileConfig::operator=(InodeFileConfig&&) = default;
-
-bool InodeFileConfig::operator==(const InodeFileConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && scan_interval_ms_ == other.scan_interval_ms_
-   && scan_delay_ms_ == other.scan_delay_ms_
-   && scan_batch_size_ == other.scan_batch_size_
-   && do_not_scan_ == other.do_not_scan_
-   && scan_mount_points_ == other.scan_mount_points_
-   && mount_point_mapping_ == other.mount_point_mapping_;
-}
-
-int InodeFileConfig::mount_point_mapping_size() const { return static_cast<int>(mount_point_mapping_.size()); }
-void InodeFileConfig::clear_mount_point_mapping() { mount_point_mapping_.clear(); }
-InodeFileConfig_MountPointMappingEntry* InodeFileConfig::add_mount_point_mapping() { mount_point_mapping_.emplace_back(); return &mount_point_mapping_.back(); }
-bool InodeFileConfig::ParseFromArray(const void* raw, size_t size) {
-  scan_mount_points_.clear();
-  mount_point_mapping_.clear();
-  unknown_fields_.clear();
-  bool packed_error = false;
+bool TracingServiceState_TracingSession::ParseFromArray(const void* raw, size_t size) {
+  buffer_size_kb_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
 
   ::protozero::ProtoDecoder dec(raw, size);
   for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
@@ -20483,25 +19735,39 @@ bool InodeFileConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* scan_interval_ms */:
-        field.get(&scan_interval_ms_);
+      case 1 /* id */:
+        field.get(&id_);
         break;
-      case 2 /* scan_delay_ms */:
-        field.get(&scan_delay_ms_);
+      case 2 /* consumer_uid */:
+        field.get(&consumer_uid_);
         break;
-      case 3 /* scan_batch_size */:
-        field.get(&scan_batch_size_);
+      case 3 /* state */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &state_);
         break;
-      case 4 /* do_not_scan */:
-        field.get(&do_not_scan_);
+      case 4 /* unique_session_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &unique_session_name_);
         break;
-      case 5 /* scan_mount_points */:
-        scan_mount_points_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &scan_mount_points_.back());
+      case 5 /* buffer_size_kb */:
+        buffer_size_kb_.emplace_back();
+        field.get(&buffer_size_kb_.back());
         break;
-      case 6 /* mount_point_mapping */:
-        mount_point_mapping_.emplace_back();
-        mount_point_mapping_.back().ParseFromArray(field.data(), field.size());
+      case 6 /* duration_ms */:
+        field.get(&duration_ms_);
+        break;
+      case 7 /* num_data_sources */:
+        field.get(&num_data_sources_);
+        break;
+      case 8 /* start_realtime_ns */:
+        field.get(&start_realtime_ns_);
+        break;
+      case 9 /* bugreport_score */:
+        field.get(&bugreport_score_);
+        break;
+      case 10 /* bugreport_filename */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &bugreport_filename_);
+        break;
+      case 11 /* is_started */:
+        field.get(&is_started_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -20511,68 +19777,92 @@ bool InodeFileConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string InodeFileConfig::SerializeAsString() const {
+std::string TracingServiceState_TracingSession::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> InodeFileConfig::SerializeAsArray() const {
+std::vector<uint8_t> TracingServiceState_TracingSession::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void InodeFileConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: scan_interval_ms
+void TracingServiceState_TracingSession::Serialize(::protozero::Message* msg) const {
+  // Field 1: id
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, scan_interval_ms_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, id_, msg);
   }
 
-  // Field 2: scan_delay_ms
+  // Field 2: consumer_uid
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, scan_delay_ms_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, consumer_uid_, msg);
   }
 
-  // Field 3: scan_batch_size
+  // Field 3: state
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, scan_batch_size_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(3, state_, msg);
   }
 
-  // Field 4: do_not_scan
+  // Field 4: unique_session_name
   if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(4, do_not_scan_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(4, unique_session_name_, msg);
   }
 
-  // Field 5: scan_mount_points
-  for (auto& it : scan_mount_points_) {
-    ::protozero::internal::gen_helpers::SerializeString(5, it, msg);
+  // Field 5: buffer_size_kb
+  for (auto& it : buffer_size_kb_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, it, msg);
   }
 
-  // Field 6: mount_point_mapping
-  for (auto& it : mount_point_mapping_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(6));
+  // Field 6: duration_ms
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, duration_ms_, msg);
+  }
+
+  // Field 7: num_data_sources
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(7, num_data_sources_, msg);
+  }
+
+  // Field 8: start_realtime_ns
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(8, start_realtime_ns_, msg);
+  }
+
+  // Field 9: bugreport_score
+  if (_has_field_[9]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(9, bugreport_score_, msg);
+  }
+
+  // Field 10: bugreport_filename
+  if (_has_field_[10]) {
+    ::protozero::internal::gen_helpers::SerializeString(10, bugreport_filename_, msg);
+  }
+
+  // Field 11: is_started
+  if (_has_field_[11]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(11, is_started_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-InodeFileConfig_MountPointMappingEntry::InodeFileConfig_MountPointMappingEntry() = default;
-InodeFileConfig_MountPointMappingEntry::~InodeFileConfig_MountPointMappingEntry() = default;
-InodeFileConfig_MountPointMappingEntry::InodeFileConfig_MountPointMappingEntry(const InodeFileConfig_MountPointMappingEntry&) = default;
-InodeFileConfig_MountPointMappingEntry& InodeFileConfig_MountPointMappingEntry::operator=(const InodeFileConfig_MountPointMappingEntry&) = default;
-InodeFileConfig_MountPointMappingEntry::InodeFileConfig_MountPointMappingEntry(InodeFileConfig_MountPointMappingEntry&&) noexcept = default;
-InodeFileConfig_MountPointMappingEntry& InodeFileConfig_MountPointMappingEntry::operator=(InodeFileConfig_MountPointMappingEntry&&) = default;
+TracingServiceState_DataSource::TracingServiceState_DataSource() = default;
+TracingServiceState_DataSource::~TracingServiceState_DataSource() = default;
+TracingServiceState_DataSource::TracingServiceState_DataSource(const TracingServiceState_DataSource&) = default;
+TracingServiceState_DataSource& TracingServiceState_DataSource::operator=(const TracingServiceState_DataSource&) = default;
+TracingServiceState_DataSource::TracingServiceState_DataSource(TracingServiceState_DataSource&&) noexcept = default;
+TracingServiceState_DataSource& TracingServiceState_DataSource::operator=(TracingServiceState_DataSource&&) = default;
 
-bool InodeFileConfig_MountPointMappingEntry::operator==(const InodeFileConfig_MountPointMappingEntry& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && mountpoint_ == other.mountpoint_
-   && scan_roots_ == other.scan_roots_;
+bool TracingServiceState_DataSource::operator==(const TracingServiceState_DataSource& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(ds_descriptor_, other.ds_descriptor_)
+   && ::protozero::internal::gen_helpers::EqualsField(producer_id_, other.producer_id_);
 }
 
-bool InodeFileConfig_MountPointMappingEntry::ParseFromArray(const void* raw, size_t size) {
-  scan_roots_.clear();
+bool TracingServiceState_DataSource::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -20582,12 +19872,11 @@ bool InodeFileConfig_MountPointMappingEntry::ParseFromArray(const void* raw, siz
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* mountpoint */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &mountpoint_);
+      case 1 /* ds_descriptor */:
+        (*ds_descriptor_).ParseFromArray(field.data(), field.size());
         break;
-      case 2 /* scan_roots */:
-        scan_roots_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &scan_roots_.back());
+      case 2 /* producer_id */:
+        field.get(&producer_id_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -20597,127 +19886,139 @@ bool InodeFileConfig_MountPointMappingEntry::ParseFromArray(const void* raw, siz
   return !packed_error && !dec.bytes_left();
 }
 
-std::string InodeFileConfig_MountPointMappingEntry::SerializeAsString() const {
+std::string TracingServiceState_DataSource::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> InodeFileConfig_MountPointMappingEntry::SerializeAsArray() const {
+std::vector<uint8_t> TracingServiceState_DataSource::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void InodeFileConfig_MountPointMappingEntry::Serialize(::protozero::Message* msg) const {
-  // Field 1: mountpoint
+void TracingServiceState_DataSource::Serialize(::protozero::Message* msg) const {
+  // Field 1: ds_descriptor
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeString(1, mountpoint_, msg);
+    (*ds_descriptor_).Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
   }
 
-  // Field 2: scan_roots
-  for (auto& it : scan_roots_) {
-    ::protozero::internal::gen_helpers::SerializeString(2, it, msg);
+  // Field 2: producer_id
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, producer_id_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/interceptors/console_config.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/interceptors/console_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTORS_CONSOLE_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTORS_CONSOLE_CONFIG_PROTO_CPP_H_
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+TracingServiceState_Producer::TracingServiceState_Producer() = default;
+TracingServiceState_Producer::~TracingServiceState_Producer() = default;
+TracingServiceState_Producer::TracingServiceState_Producer(const TracingServiceState_Producer&) = default;
+TracingServiceState_Producer& TracingServiceState_Producer::operator=(const TracingServiceState_Producer&) = default;
+TracingServiceState_Producer::TracingServiceState_Producer(TracingServiceState_Producer&&) noexcept = default;
+TracingServiceState_Producer& TracingServiceState_Producer::operator=(TracingServiceState_Producer&&) = default;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+bool TracingServiceState_Producer::operator==(const TracingServiceState_Producer& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(id_, other.id_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(pid_, other.pid_)
+   && ::protozero::internal::gen_helpers::EqualsField(uid_, other.uid_)
+   && ::protozero::internal::gen_helpers::EqualsField(sdk_version_, other.sdk_version_)
+   && ::protozero::internal::gen_helpers::EqualsField(frozen_, other.frozen_);
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ConsoleConfig;
-enum ConsoleConfig_Output : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+bool TracingServiceState_Producer::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* id */:
+        field.get(&id_);
+        break;
+      case 2 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+        break;
+      case 5 /* pid */:
+        field.get(&pid_);
+        break;
+      case 3 /* uid */:
+        field.get(&uid_);
+        break;
+      case 4 /* sdk_version */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &sdk_version_);
+        break;
+      case 6 /* frozen */:
+        field.get(&frozen_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum ConsoleConfig_Output : int {
-  ConsoleConfig_Output_OUTPUT_UNSPECIFIED = 0,
-  ConsoleConfig_Output_OUTPUT_STDOUT = 1,
-  ConsoleConfig_Output_OUTPUT_STDERR = 2,
-};
+std::string TracingServiceState_Producer::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-class PERFETTO_EXPORT_COMPONENT ConsoleConfig : public ::protozero::CppMessageObj {
- public:
-  using Output = ConsoleConfig_Output;
-  static constexpr auto OUTPUT_UNSPECIFIED = ConsoleConfig_Output_OUTPUT_UNSPECIFIED;
-  static constexpr auto OUTPUT_STDOUT = ConsoleConfig_Output_OUTPUT_STDOUT;
-  static constexpr auto OUTPUT_STDERR = ConsoleConfig_Output_OUTPUT_STDERR;
-  static constexpr auto Output_MIN = ConsoleConfig_Output_OUTPUT_UNSPECIFIED;
-  static constexpr auto Output_MAX = ConsoleConfig_Output_OUTPUT_STDERR;
-  enum FieldNumbers {
-    kOutputFieldNumber = 1,
-    kEnableColorsFieldNumber = 2,
-  };
+std::vector<uint8_t> TracingServiceState_Producer::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  ConsoleConfig();
-  ~ConsoleConfig() override;
-  ConsoleConfig(ConsoleConfig&&) noexcept;
-  ConsoleConfig& operator=(ConsoleConfig&&);
-  ConsoleConfig(const ConsoleConfig&);
-  ConsoleConfig& operator=(const ConsoleConfig&);
-  bool operator==(const ConsoleConfig&) const;
-  bool operator!=(const ConsoleConfig& other) const { return !(*this == other); }
+void TracingServiceState_Producer::Serialize(::protozero::Message* msg) const {
+  // Field 1: id
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, id_, msg);
+  }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  // Field 2: name
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeString(2, name_, msg);
+  }
 
-  bool has_output() const { return _has_field_[1]; }
-  ConsoleConfig_Output output() const { return output_; }
-  void set_output(ConsoleConfig_Output value) { output_ = value; _has_field_.set(1); }
+  // Field 5: pid
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, pid_, msg);
+  }
 
-  bool has_enable_colors() const { return _has_field_[2]; }
-  bool enable_colors() const { return enable_colors_; }
-  void set_enable_colors(bool value) { enable_colors_ = value; _has_field_.set(2); }
+  // Field 3: uid
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, uid_, msg);
+  }
 
- private:
-  ConsoleConfig_Output output_{};
-  bool enable_colors_{};
+  // Field 4: sdk_version
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeString(4, sdk_version_, msg);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  // Field 6: frozen
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(6, frozen_, msg);
+  }
 
-  std::bitset<3> _has_field_{};
-};
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTORS_CONSOLE_CONFIG_PROTO_CPP_H_
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/common/track_event_descriptor.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -20728,26 +20029,29 @@ class PERFETTO_EXPORT_COMPONENT ConsoleConfig : public ::protozero::CppMessageOb
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/interceptors/console_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/track_event_descriptor.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-ConsoleConfig::ConsoleConfig() = default;
-ConsoleConfig::~ConsoleConfig() = default;
-ConsoleConfig::ConsoleConfig(const ConsoleConfig&) = default;
-ConsoleConfig& ConsoleConfig::operator=(const ConsoleConfig&) = default;
-ConsoleConfig::ConsoleConfig(ConsoleConfig&&) noexcept = default;
-ConsoleConfig& ConsoleConfig::operator=(ConsoleConfig&&) = default;
+TrackEventDescriptor::TrackEventDescriptor() = default;
+TrackEventDescriptor::~TrackEventDescriptor() = default;
+TrackEventDescriptor::TrackEventDescriptor(const TrackEventDescriptor&) = default;
+TrackEventDescriptor& TrackEventDescriptor::operator=(const TrackEventDescriptor&) = default;
+TrackEventDescriptor::TrackEventDescriptor(TrackEventDescriptor&&) noexcept = default;
+TrackEventDescriptor& TrackEventDescriptor::operator=(TrackEventDescriptor&&) = default;
 
-bool ConsoleConfig::operator==(const ConsoleConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && output_ == other.output_
-   && enable_colors_ == other.enable_colors_;
+bool TrackEventDescriptor::operator==(const TrackEventDescriptor& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(available_categories_, other.available_categories_);
 }
 
-bool ConsoleConfig::ParseFromArray(const void* raw, size_t size) {
+int TrackEventDescriptor::available_categories_size() const { return static_cast<int>(available_categories_.size()); }
+void TrackEventDescriptor::clear_available_categories() { available_categories_.clear(); }
+TrackEventCategory* TrackEventDescriptor::add_available_categories() { available_categories_.emplace_back(); return &available_categories_.back(); }
+bool TrackEventDescriptor::ParseFromArray(const void* raw, size_t size) {
+  available_categories_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -20757,11 +20061,74 @@ bool ConsoleConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* output */:
-        field.get(&output_);
+      case 1 /* available_categories */:
+        available_categories_.emplace_back();
+        available_categories_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 2 /* enable_colors */:
-        field.get(&enable_colors_);
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
+
+std::string TrackEventDescriptor::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> TrackEventDescriptor::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void TrackEventDescriptor::Serialize(::protozero::Message* msg) const {
+  // Field 1: available_categories
+  for (auto& it : available_categories_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
+
+
+TrackEventCategory::TrackEventCategory() = default;
+TrackEventCategory::~TrackEventCategory() = default;
+TrackEventCategory::TrackEventCategory(const TrackEventCategory&) = default;
+TrackEventCategory& TrackEventCategory::operator=(const TrackEventCategory&) = default;
+TrackEventCategory::TrackEventCategory(TrackEventCategory&&) noexcept = default;
+TrackEventCategory& TrackEventCategory::operator=(TrackEventCategory&&) = default;
+
+bool TrackEventCategory::operator==(const TrackEventCategory& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(description_, other.description_)
+   && ::protozero::internal::gen_helpers::EqualsField(tags_, other.tags_);
+}
+
+bool TrackEventCategory::ParseFromArray(const void* raw, size_t size) {
+  tags_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+        break;
+      case 2 /* description */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &description_);
+        break;
+      case 3 /* tags */:
+        tags_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &tags_.back());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -20771,27 +20138,32 @@ bool ConsoleConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ConsoleConfig::SerializeAsString() const {
+std::string TrackEventCategory::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ConsoleConfig::SerializeAsArray() const {
+std::vector<uint8_t> TrackEventCategory::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ConsoleConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: output
+void TrackEventCategory::Serialize(::protozero::Message* msg) const {
+  // Field 1: name
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, output_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
   }
 
-  // Field 2: enable_colors
+  // Field 2: description
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, enable_colors_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(2, description_, msg);
+  }
+
+  // Field 3: tags
+  for (auto& it : tags_) {
+    ::protozero::internal::gen_helpers::SerializeString(3, it, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -20803,120 +20175,108 @@ void ConsoleConfig::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/power/android_power_config.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/power/android_power_config.gen.h
+// gen_amalgamated begin source: gen/protos/perfetto/common/semantic_type.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_POWER_ANDROID_POWER_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_POWER_ANDROID_POWER_CONFIG_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/common/semantic_type.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
-class AndroidPowerConfig;
-enum AndroidPowerConfig_BatteryCounters : int;
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/android_game_intervention_list_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_game_intervention_list_config.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
-enum AndroidPowerConfig_BatteryCounters : int {
-  AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_UNSPECIFIED = 0,
-  AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CHARGE = 1,
-  AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CAPACITY_PERCENT = 2,
-  AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CURRENT = 3,
-  AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CURRENT_AVG = 4,
-};
 
-class PERFETTO_EXPORT_COMPONENT AndroidPowerConfig : public ::protozero::CppMessageObj {
- public:
-  using BatteryCounters = AndroidPowerConfig_BatteryCounters;
-  static constexpr auto BATTERY_COUNTER_UNSPECIFIED = AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_UNSPECIFIED;
-  static constexpr auto BATTERY_COUNTER_CHARGE = AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CHARGE;
-  static constexpr auto BATTERY_COUNTER_CAPACITY_PERCENT = AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CAPACITY_PERCENT;
-  static constexpr auto BATTERY_COUNTER_CURRENT = AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CURRENT;
-  static constexpr auto BATTERY_COUNTER_CURRENT_AVG = AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CURRENT_AVG;
-  static constexpr auto BatteryCounters_MIN = AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_UNSPECIFIED;
-  static constexpr auto BatteryCounters_MAX = AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CURRENT_AVG;
-  enum FieldNumbers {
-    kBatteryPollMsFieldNumber = 1,
-    kBatteryCountersFieldNumber = 2,
-    kCollectPowerRailsFieldNumber = 3,
-    kCollectEnergyEstimationBreakdownFieldNumber = 4,
-    kCollectEntityStateResidencyFieldNumber = 5,
-  };
+AndroidGameInterventionListConfig::AndroidGameInterventionListConfig() = default;
+AndroidGameInterventionListConfig::~AndroidGameInterventionListConfig() = default;
+AndroidGameInterventionListConfig::AndroidGameInterventionListConfig(const AndroidGameInterventionListConfig&) = default;
+AndroidGameInterventionListConfig& AndroidGameInterventionListConfig::operator=(const AndroidGameInterventionListConfig&) = default;
+AndroidGameInterventionListConfig::AndroidGameInterventionListConfig(AndroidGameInterventionListConfig&&) noexcept = default;
+AndroidGameInterventionListConfig& AndroidGameInterventionListConfig::operator=(AndroidGameInterventionListConfig&&) = default;
+
+bool AndroidGameInterventionListConfig::operator==(const AndroidGameInterventionListConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(package_name_filter_, other.package_name_filter_);
+}
 
-  AndroidPowerConfig();
-  ~AndroidPowerConfig() override;
-  AndroidPowerConfig(AndroidPowerConfig&&) noexcept;
-  AndroidPowerConfig& operator=(AndroidPowerConfig&&);
-  AndroidPowerConfig(const AndroidPowerConfig&);
-  AndroidPowerConfig& operator=(const AndroidPowerConfig&);
-  bool operator==(const AndroidPowerConfig&) const;
-  bool operator!=(const AndroidPowerConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_battery_poll_ms() const { return _has_field_[1]; }
-  uint32_t battery_poll_ms() const { return battery_poll_ms_; }
-  void set_battery_poll_ms(uint32_t value) { battery_poll_ms_ = value; _has_field_.set(1); }
-
-  const std::vector<AndroidPowerConfig_BatteryCounters>& battery_counters() const { return battery_counters_; }
-  std::vector<AndroidPowerConfig_BatteryCounters>* mutable_battery_counters() { return &battery_counters_; }
-  int battery_counters_size() const { return static_cast<int>(battery_counters_.size()); }
-  void clear_battery_counters() { battery_counters_.clear(); }
-  void add_battery_counters(AndroidPowerConfig_BatteryCounters value) { battery_counters_.emplace_back(value); }
-  AndroidPowerConfig_BatteryCounters* add_battery_counters() { battery_counters_.emplace_back(); return &battery_counters_.back(); }
-
-  bool has_collect_power_rails() const { return _has_field_[3]; }
-  bool collect_power_rails() const { return collect_power_rails_; }
-  void set_collect_power_rails(bool value) { collect_power_rails_ = value; _has_field_.set(3); }
-
-  bool has_collect_energy_estimation_breakdown() const { return _has_field_[4]; }
-  bool collect_energy_estimation_breakdown() const { return collect_energy_estimation_breakdown_; }
-  void set_collect_energy_estimation_breakdown(bool value) { collect_energy_estimation_breakdown_ = value; _has_field_.set(4); }
-
-  bool has_collect_entity_state_residency() const { return _has_field_[5]; }
-  bool collect_entity_state_residency() const { return collect_entity_state_residency_; }
-  void set_collect_entity_state_residency(bool value) { collect_entity_state_residency_ = value; _has_field_.set(5); }
+bool AndroidGameInterventionListConfig::ParseFromArray(const void* raw, size_t size) {
+  package_name_filter_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
 
- private:
-  uint32_t battery_poll_ms_{};
-  std::vector<AndroidPowerConfig_BatteryCounters> battery_counters_;
-  bool collect_power_rails_{};
-  bool collect_energy_estimation_breakdown_{};
-  bool collect_entity_state_residency_{};
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* package_name_filter */:
+        package_name_filter_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &package_name_filter_.back());
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+std::string AndroidGameInterventionListConfig::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  std::bitset<6> _has_field_{};
-};
+std::vector<uint8_t> AndroidGameInterventionListConfig::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void AndroidGameInterventionListConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: package_name_filter
+  for (auto& it : package_name_filter_) {
+    ::protozero::internal::gen_helpers::SerializeString(1, it, msg);
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_POWER_ANDROID_POWER_CONFIG_PROTO_CPP_H_
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/android_input_event_config.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -20927,30 +20287,32 @@ class PERFETTO_EXPORT_COMPONENT AndroidPowerConfig : public ::protozero::CppMess
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/power/android_power_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_input_event_config.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-AndroidPowerConfig::AndroidPowerConfig() = default;
-AndroidPowerConfig::~AndroidPowerConfig() = default;
-AndroidPowerConfig::AndroidPowerConfig(const AndroidPowerConfig&) = default;
-AndroidPowerConfig& AndroidPowerConfig::operator=(const AndroidPowerConfig&) = default;
-AndroidPowerConfig::AndroidPowerConfig(AndroidPowerConfig&&) noexcept = default;
-AndroidPowerConfig& AndroidPowerConfig::operator=(AndroidPowerConfig&&) = default;
-
-bool AndroidPowerConfig::operator==(const AndroidPowerConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && battery_poll_ms_ == other.battery_poll_ms_
-   && battery_counters_ == other.battery_counters_
-   && collect_power_rails_ == other.collect_power_rails_
-   && collect_energy_estimation_breakdown_ == other.collect_energy_estimation_breakdown_
-   && collect_entity_state_residency_ == other.collect_entity_state_residency_;
-}
-
-bool AndroidPowerConfig::ParseFromArray(const void* raw, size_t size) {
-  battery_counters_.clear();
+AndroidInputEventConfig::AndroidInputEventConfig() = default;
+AndroidInputEventConfig::~AndroidInputEventConfig() = default;
+AndroidInputEventConfig::AndroidInputEventConfig(const AndroidInputEventConfig&) = default;
+AndroidInputEventConfig& AndroidInputEventConfig::operator=(const AndroidInputEventConfig&) = default;
+AndroidInputEventConfig::AndroidInputEventConfig(AndroidInputEventConfig&&) noexcept = default;
+AndroidInputEventConfig& AndroidInputEventConfig::operator=(AndroidInputEventConfig&&) = default;
+
+bool AndroidInputEventConfig::operator==(const AndroidInputEventConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(mode_, other.mode_)
+   && ::protozero::internal::gen_helpers::EqualsField(rules_, other.rules_)
+   && ::protozero::internal::gen_helpers::EqualsField(trace_dispatcher_input_events_, other.trace_dispatcher_input_events_)
+   && ::protozero::internal::gen_helpers::EqualsField(trace_dispatcher_window_dispatch_, other.trace_dispatcher_window_dispatch_);
+}
+
+int AndroidInputEventConfig::rules_size() const { return static_cast<int>(rules_.size()); }
+void AndroidInputEventConfig::clear_rules() { rules_.clear(); }
+AndroidInputEventConfig_TraceRule* AndroidInputEventConfig::add_rules() { rules_.emplace_back(); return &rules_.back(); }
+bool AndroidInputEventConfig::ParseFromArray(const void* raw, size_t size) {
+  rules_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -20960,21 +20322,18 @@ bool AndroidPowerConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* battery_poll_ms */:
-        field.get(&battery_poll_ms_);
-        break;
-      case 2 /* battery_counters */:
-        battery_counters_.emplace_back();
-        field.get(&battery_counters_.back());
+      case 1 /* mode */:
+        field.get(&mode_);
         break;
-      case 3 /* collect_power_rails */:
-        field.get(&collect_power_rails_);
+      case 2 /* rules */:
+        rules_.emplace_back();
+        rules_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 4 /* collect_energy_estimation_breakdown */:
-        field.get(&collect_energy_estimation_breakdown_);
+      case 3 /* trace_dispatcher_input_events */:
+        field.get(&trace_dispatcher_input_events_);
         break;
-      case 5 /* collect_entity_state_residency */:
-        field.get(&collect_entity_state_residency_);
+      case 4 /* trace_dispatcher_window_dispatch */:
+        field.get(&trace_dispatcher_window_dispatch_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -20984,169 +20343,144 @@ bool AndroidPowerConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string AndroidPowerConfig::SerializeAsString() const {
+std::string AndroidInputEventConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> AndroidPowerConfig::SerializeAsArray() const {
+std::vector<uint8_t> AndroidInputEventConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void AndroidPowerConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: battery_poll_ms
+void AndroidInputEventConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: mode
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, battery_poll_ms_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, mode_, msg);
   }
 
-  // Field 2: battery_counters
-  for (auto& it : battery_counters_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, it, msg);
+  // Field 2: rules
+  for (auto& it : rules_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
   }
 
-  // Field 3: collect_power_rails
+  // Field 3: trace_dispatcher_input_events
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, collect_power_rails_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, trace_dispatcher_input_events_, msg);
   }
 
-  // Field 4: collect_energy_estimation_breakdown
+  // Field 4: trace_dispatcher_window_dispatch
   if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(4, collect_energy_estimation_breakdown_, msg);
-  }
-
-  // Field 5: collect_entity_state_residency
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, collect_entity_state_residency_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(4, trace_dispatcher_window_dispatch_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/process_stats/process_stats_config.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/process_stats/process_stats_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROCESS_STATS_PROCESS_STATS_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROCESS_STATS_PROCESS_STATS_CONFIG_PROTO_CPP_H_
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+AndroidInputEventConfig_TraceRule::AndroidInputEventConfig_TraceRule() = default;
+AndroidInputEventConfig_TraceRule::~AndroidInputEventConfig_TraceRule() = default;
+AndroidInputEventConfig_TraceRule::AndroidInputEventConfig_TraceRule(const AndroidInputEventConfig_TraceRule&) = default;
+AndroidInputEventConfig_TraceRule& AndroidInputEventConfig_TraceRule::operator=(const AndroidInputEventConfig_TraceRule&) = default;
+AndroidInputEventConfig_TraceRule::AndroidInputEventConfig_TraceRule(AndroidInputEventConfig_TraceRule&&) noexcept = default;
+AndroidInputEventConfig_TraceRule& AndroidInputEventConfig_TraceRule::operator=(AndroidInputEventConfig_TraceRule&&) = default;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+bool AndroidInputEventConfig_TraceRule::operator==(const AndroidInputEventConfig_TraceRule& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(trace_level_, other.trace_level_)
+   && ::protozero::internal::gen_helpers::EqualsField(match_all_packages_, other.match_all_packages_)
+   && ::protozero::internal::gen_helpers::EqualsField(match_any_packages_, other.match_any_packages_)
+   && ::protozero::internal::gen_helpers::EqualsField(match_secure_, other.match_secure_)
+   && ::protozero::internal::gen_helpers::EqualsField(match_ime_connection_active_, other.match_ime_connection_active_);
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ProcessStatsConfig;
-enum ProcessStatsConfig_Quirks : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+bool AndroidInputEventConfig_TraceRule::ParseFromArray(const void* raw, size_t size) {
+  match_all_packages_.clear();
+  match_any_packages_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* trace_level */:
+        field.get(&trace_level_);
+        break;
+      case 2 /* match_all_packages */:
+        match_all_packages_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &match_all_packages_.back());
+        break;
+      case 3 /* match_any_packages */:
+        match_any_packages_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &match_any_packages_.back());
+        break;
+      case 4 /* match_secure */:
+        field.get(&match_secure_);
+        break;
+      case 5 /* match_ime_connection_active */:
+        field.get(&match_ime_connection_active_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum ProcessStatsConfig_Quirks : int {
-  ProcessStatsConfig_Quirks_QUIRKS_UNSPECIFIED = 0,
-  ProcessStatsConfig_Quirks_DISABLE_INITIAL_DUMP = 1,
-  ProcessStatsConfig_Quirks_DISABLE_ON_DEMAND = 2,
-};
+std::string AndroidInputEventConfig_TraceRule::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-class PERFETTO_EXPORT_COMPONENT ProcessStatsConfig : public ::protozero::CppMessageObj {
- public:
-  using Quirks = ProcessStatsConfig_Quirks;
-  static constexpr auto QUIRKS_UNSPECIFIED = ProcessStatsConfig_Quirks_QUIRKS_UNSPECIFIED;
-  static constexpr auto DISABLE_INITIAL_DUMP = ProcessStatsConfig_Quirks_DISABLE_INITIAL_DUMP;
-  static constexpr auto DISABLE_ON_DEMAND = ProcessStatsConfig_Quirks_DISABLE_ON_DEMAND;
-  static constexpr auto Quirks_MIN = ProcessStatsConfig_Quirks_QUIRKS_UNSPECIFIED;
-  static constexpr auto Quirks_MAX = ProcessStatsConfig_Quirks_DISABLE_ON_DEMAND;
-  enum FieldNumbers {
-    kQuirksFieldNumber = 1,
-    kScanAllProcessesOnStartFieldNumber = 2,
-    kRecordThreadNamesFieldNumber = 3,
-    kProcStatsPollMsFieldNumber = 4,
-    kProcStatsCacheTtlMsFieldNumber = 6,
-    kResolveProcessFdsFieldNumber = 9,
-  };
+std::vector<uint8_t> AndroidInputEventConfig_TraceRule::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  ProcessStatsConfig();
-  ~ProcessStatsConfig() override;
-  ProcessStatsConfig(ProcessStatsConfig&&) noexcept;
-  ProcessStatsConfig& operator=(ProcessStatsConfig&&);
-  ProcessStatsConfig(const ProcessStatsConfig&);
-  ProcessStatsConfig& operator=(const ProcessStatsConfig&);
-  bool operator==(const ProcessStatsConfig&) const;
-  bool operator!=(const ProcessStatsConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<ProcessStatsConfig_Quirks>& quirks() const { return quirks_; }
-  std::vector<ProcessStatsConfig_Quirks>* mutable_quirks() { return &quirks_; }
-  int quirks_size() const { return static_cast<int>(quirks_.size()); }
-  void clear_quirks() { quirks_.clear(); }
-  void add_quirks(ProcessStatsConfig_Quirks value) { quirks_.emplace_back(value); }
-  ProcessStatsConfig_Quirks* add_quirks() { quirks_.emplace_back(); return &quirks_.back(); }
-
-  bool has_scan_all_processes_on_start() const { return _has_field_[2]; }
-  bool scan_all_processes_on_start() const { return scan_all_processes_on_start_; }
-  void set_scan_all_processes_on_start(bool value) { scan_all_processes_on_start_ = value; _has_field_.set(2); }
-
-  bool has_record_thread_names() const { return _has_field_[3]; }
-  bool record_thread_names() const { return record_thread_names_; }
-  void set_record_thread_names(bool value) { record_thread_names_ = value; _has_field_.set(3); }
-
-  bool has_proc_stats_poll_ms() const { return _has_field_[4]; }
-  uint32_t proc_stats_poll_ms() const { return proc_stats_poll_ms_; }
-  void set_proc_stats_poll_ms(uint32_t value) { proc_stats_poll_ms_ = value; _has_field_.set(4); }
-
-  bool has_proc_stats_cache_ttl_ms() const { return _has_field_[6]; }
-  uint32_t proc_stats_cache_ttl_ms() const { return proc_stats_cache_ttl_ms_; }
-  void set_proc_stats_cache_ttl_ms(uint32_t value) { proc_stats_cache_ttl_ms_ = value; _has_field_.set(6); }
-
-  bool has_resolve_process_fds() const { return _has_field_[9]; }
-  bool resolve_process_fds() const { return resolve_process_fds_; }
-  void set_resolve_process_fds(bool value) { resolve_process_fds_ = value; _has_field_.set(9); }
+void AndroidInputEventConfig_TraceRule::Serialize(::protozero::Message* msg) const {
+  // Field 1: trace_level
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, trace_level_, msg);
+  }
 
- private:
-  std::vector<ProcessStatsConfig_Quirks> quirks_;
-  bool scan_all_processes_on_start_{};
-  bool record_thread_names_{};
-  uint32_t proc_stats_poll_ms_{};
-  uint32_t proc_stats_cache_ttl_ms_{};
-  bool resolve_process_fds_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<10> _has_field_{};
-};
+  // Field 2: match_all_packages
+  for (auto& it : match_all_packages_) {
+    ::protozero::internal::gen_helpers::SerializeString(2, it, msg);
+  }
+
+  // Field 3: match_any_packages
+  for (auto& it : match_any_packages_) {
+    ::protozero::internal::gen_helpers::SerializeString(3, it, msg);
+  }
+
+  // Field 4: match_secure
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(4, match_secure_, msg);
+  }
+
+  // Field 5: match_ime_connection_active
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, match_ime_connection_active_, msg);
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROCESS_STATS_PROCESS_STATS_CONFIG_PROTO_CPP_H_
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/android_log_config.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -21157,31 +20491,31 @@ class PERFETTO_EXPORT_COMPONENT ProcessStatsConfig : public ::protozero::CppMess
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/process_stats/process_stats_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_log_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/android_log_constants.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-ProcessStatsConfig::ProcessStatsConfig() = default;
-ProcessStatsConfig::~ProcessStatsConfig() = default;
-ProcessStatsConfig::ProcessStatsConfig(const ProcessStatsConfig&) = default;
-ProcessStatsConfig& ProcessStatsConfig::operator=(const ProcessStatsConfig&) = default;
-ProcessStatsConfig::ProcessStatsConfig(ProcessStatsConfig&&) noexcept = default;
-ProcessStatsConfig& ProcessStatsConfig::operator=(ProcessStatsConfig&&) = default;
+AndroidLogConfig::AndroidLogConfig() = default;
+AndroidLogConfig::~AndroidLogConfig() = default;
+AndroidLogConfig::AndroidLogConfig(const AndroidLogConfig&) = default;
+AndroidLogConfig& AndroidLogConfig::operator=(const AndroidLogConfig&) = default;
+AndroidLogConfig::AndroidLogConfig(AndroidLogConfig&&) noexcept = default;
+AndroidLogConfig& AndroidLogConfig::operator=(AndroidLogConfig&&) = default;
 
-bool ProcessStatsConfig::operator==(const ProcessStatsConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && quirks_ == other.quirks_
-   && scan_all_processes_on_start_ == other.scan_all_processes_on_start_
-   && record_thread_names_ == other.record_thread_names_
-   && proc_stats_poll_ms_ == other.proc_stats_poll_ms_
-   && proc_stats_cache_ttl_ms_ == other.proc_stats_cache_ttl_ms_
-   && resolve_process_fds_ == other.resolve_process_fds_;
+bool AndroidLogConfig::operator==(const AndroidLogConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(log_ids_, other.log_ids_)
+   && ::protozero::internal::gen_helpers::EqualsField(min_prio_, other.min_prio_)
+   && ::protozero::internal::gen_helpers::EqualsField(filter_tags_, other.filter_tags_)
+   && ::protozero::internal::gen_helpers::EqualsField(preserve_log_buffer_, other.preserve_log_buffer_);
 }
 
-bool ProcessStatsConfig::ParseFromArray(const void* raw, size_t size) {
-  quirks_.clear();
+bool AndroidLogConfig::ParseFromArray(const void* raw, size_t size) {
+  log_ids_.clear();
+  filter_tags_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -21191,24 +20525,19 @@ bool ProcessStatsConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* quirks */:
-        quirks_.emplace_back();
-        field.get(&quirks_.back());
-        break;
-      case 2 /* scan_all_processes_on_start */:
-        field.get(&scan_all_processes_on_start_);
-        break;
-      case 3 /* record_thread_names */:
-        field.get(&record_thread_names_);
+      case 1 /* log_ids */:
+        log_ids_.emplace_back();
+        field.get(&log_ids_.back());
         break;
-      case 4 /* proc_stats_poll_ms */:
-        field.get(&proc_stats_poll_ms_);
+      case 3 /* min_prio */:
+        field.get(&min_prio_);
         break;
-      case 6 /* proc_stats_cache_ttl_ms */:
-        field.get(&proc_stats_cache_ttl_ms_);
+      case 4 /* filter_tags */:
+        filter_tags_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &filter_tags_.back());
         break;
-      case 9 /* resolve_process_fds */:
-        field.get(&resolve_process_fds_);
+      case 5 /* preserve_log_buffer */:
+        field.get(&preserve_log_buffer_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -21218,47 +20547,37 @@ bool ProcessStatsConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ProcessStatsConfig::SerializeAsString() const {
+std::string AndroidLogConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ProcessStatsConfig::SerializeAsArray() const {
+std::vector<uint8_t> AndroidLogConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ProcessStatsConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: quirks
-  for (auto& it : quirks_) {
+void AndroidLogConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: log_ids
+  for (auto& it : log_ids_) {
     ::protozero::internal::gen_helpers::SerializeVarInt(1, it, msg);
   }
 
-  // Field 2: scan_all_processes_on_start
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, scan_all_processes_on_start_, msg);
-  }
-
-  // Field 3: record_thread_names
+  // Field 3: min_prio
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, record_thread_names_, msg);
-  }
-
-  // Field 4: proc_stats_poll_ms
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, proc_stats_poll_ms_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, min_prio_, msg);
   }
 
-  // Field 6: proc_stats_cache_ttl_ms
-  if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(6, proc_stats_cache_ttl_ms_, msg);
+  // Field 4: filter_tags
+  for (auto& it : filter_tags_) {
+    ::protozero::internal::gen_helpers::SerializeString(4, it, msg);
   }
 
-  // Field 9: resolve_process_fds
-  if (_has_field_[9]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(9, resolve_process_fds_, msg);
+  // Field 5: preserve_log_buffer
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, preserve_log_buffer_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -21270,285 +20589,7 @@ void ProcessStatsConfig::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/profiling/heapprofd_config.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/profiling/heapprofd_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_HEAPPROFD_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_HEAPPROFD_CONFIG_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class HeapprofdConfig;
-class HeapprofdConfig_ContinuousDumpConfig;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT HeapprofdConfig : public ::protozero::CppMessageObj {
- public:
-  using ContinuousDumpConfig = HeapprofdConfig_ContinuousDumpConfig;
-  enum FieldNumbers {
-    kSamplingIntervalBytesFieldNumber = 1,
-    kAdaptiveSamplingShmemThresholdFieldNumber = 24,
-    kAdaptiveSamplingMaxSamplingIntervalBytesFieldNumber = 25,
-    kProcessCmdlineFieldNumber = 2,
-    kPidFieldNumber = 4,
-    kTargetInstalledByFieldNumber = 26,
-    kHeapsFieldNumber = 20,
-    kExcludeHeapsFieldNumber = 27,
-    kStreamAllocationsFieldNumber = 23,
-    kHeapSamplingIntervalsFieldNumber = 22,
-    kAllHeapsFieldNumber = 21,
-    kAllFieldNumber = 5,
-    kMinAnonymousMemoryKbFieldNumber = 15,
-    kMaxHeapprofdMemoryKbFieldNumber = 16,
-    kMaxHeapprofdCpuSecsFieldNumber = 17,
-    kSkipSymbolPrefixFieldNumber = 7,
-    kContinuousDumpConfigFieldNumber = 6,
-    kShmemSizeBytesFieldNumber = 8,
-    kBlockClientFieldNumber = 9,
-    kBlockClientTimeoutUsFieldNumber = 14,
-    kNoStartupFieldNumber = 10,
-    kNoRunningFieldNumber = 11,
-    kDumpAtMaxFieldNumber = 13,
-    kDisableForkTeardownFieldNumber = 18,
-    kDisableVforkDetectionFieldNumber = 19,
-  };
-
-  HeapprofdConfig();
-  ~HeapprofdConfig() override;
-  HeapprofdConfig(HeapprofdConfig&&) noexcept;
-  HeapprofdConfig& operator=(HeapprofdConfig&&);
-  HeapprofdConfig(const HeapprofdConfig&);
-  HeapprofdConfig& operator=(const HeapprofdConfig&);
-  bool operator==(const HeapprofdConfig&) const;
-  bool operator!=(const HeapprofdConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_sampling_interval_bytes() const { return _has_field_[1]; }
-  uint64_t sampling_interval_bytes() const { return sampling_interval_bytes_; }
-  void set_sampling_interval_bytes(uint64_t value) { sampling_interval_bytes_ = value; _has_field_.set(1); }
-
-  bool has_adaptive_sampling_shmem_threshold() const { return _has_field_[24]; }
-  uint64_t adaptive_sampling_shmem_threshold() const { return adaptive_sampling_shmem_threshold_; }
-  void set_adaptive_sampling_shmem_threshold(uint64_t value) { adaptive_sampling_shmem_threshold_ = value; _has_field_.set(24); }
-
-  bool has_adaptive_sampling_max_sampling_interval_bytes() const { return _has_field_[25]; }
-  uint64_t adaptive_sampling_max_sampling_interval_bytes() const { return adaptive_sampling_max_sampling_interval_bytes_; }
-  void set_adaptive_sampling_max_sampling_interval_bytes(uint64_t value) { adaptive_sampling_max_sampling_interval_bytes_ = value; _has_field_.set(25); }
-
-  const std::vector<std::string>& process_cmdline() const { return process_cmdline_; }
-  std::vector<std::string>* mutable_process_cmdline() { return &process_cmdline_; }
-  int process_cmdline_size() const { return static_cast<int>(process_cmdline_.size()); }
-  void clear_process_cmdline() { process_cmdline_.clear(); }
-  void add_process_cmdline(std::string value) { process_cmdline_.emplace_back(value); }
-  std::string* add_process_cmdline() { process_cmdline_.emplace_back(); return &process_cmdline_.back(); }
-
-  const std::vector<uint64_t>& pid() const { return pid_; }
-  std::vector<uint64_t>* mutable_pid() { return &pid_; }
-  int pid_size() const { return static_cast<int>(pid_.size()); }
-  void clear_pid() { pid_.clear(); }
-  void add_pid(uint64_t value) { pid_.emplace_back(value); }
-  uint64_t* add_pid() { pid_.emplace_back(); return &pid_.back(); }
-
-  const std::vector<std::string>& target_installed_by() const { return target_installed_by_; }
-  std::vector<std::string>* mutable_target_installed_by() { return &target_installed_by_; }
-  int target_installed_by_size() const { return static_cast<int>(target_installed_by_.size()); }
-  void clear_target_installed_by() { target_installed_by_.clear(); }
-  void add_target_installed_by(std::string value) { target_installed_by_.emplace_back(value); }
-  std::string* add_target_installed_by() { target_installed_by_.emplace_back(); return &target_installed_by_.back(); }
-
-  const std::vector<std::string>& heaps() const { return heaps_; }
-  std::vector<std::string>* mutable_heaps() { return &heaps_; }
-  int heaps_size() const { return static_cast<int>(heaps_.size()); }
-  void clear_heaps() { heaps_.clear(); }
-  void add_heaps(std::string value) { heaps_.emplace_back(value); }
-  std::string* add_heaps() { heaps_.emplace_back(); return &heaps_.back(); }
-
-  const std::vector<std::string>& exclude_heaps() const { return exclude_heaps_; }
-  std::vector<std::string>* mutable_exclude_heaps() { return &exclude_heaps_; }
-  int exclude_heaps_size() const { return static_cast<int>(exclude_heaps_.size()); }
-  void clear_exclude_heaps() { exclude_heaps_.clear(); }
-  void add_exclude_heaps(std::string value) { exclude_heaps_.emplace_back(value); }
-  std::string* add_exclude_heaps() { exclude_heaps_.emplace_back(); return &exclude_heaps_.back(); }
-
-  bool has_stream_allocations() const { return _has_field_[23]; }
-  bool stream_allocations() const { return stream_allocations_; }
-  void set_stream_allocations(bool value) { stream_allocations_ = value; _has_field_.set(23); }
-
-  const std::vector<uint64_t>& heap_sampling_intervals() const { return heap_sampling_intervals_; }
-  std::vector<uint64_t>* mutable_heap_sampling_intervals() { return &heap_sampling_intervals_; }
-  int heap_sampling_intervals_size() const { return static_cast<int>(heap_sampling_intervals_.size()); }
-  void clear_heap_sampling_intervals() { heap_sampling_intervals_.clear(); }
-  void add_heap_sampling_intervals(uint64_t value) { heap_sampling_intervals_.emplace_back(value); }
-  uint64_t* add_heap_sampling_intervals() { heap_sampling_intervals_.emplace_back(); return &heap_sampling_intervals_.back(); }
-
-  bool has_all_heaps() const { return _has_field_[21]; }
-  bool all_heaps() const { return all_heaps_; }
-  void set_all_heaps(bool value) { all_heaps_ = value; _has_field_.set(21); }
-
-  bool has_all() const { return _has_field_[5]; }
-  bool all() const { return all_; }
-  void set_all(bool value) { all_ = value; _has_field_.set(5); }
-
-  bool has_min_anonymous_memory_kb() const { return _has_field_[15]; }
-  uint32_t min_anonymous_memory_kb() const { return min_anonymous_memory_kb_; }
-  void set_min_anonymous_memory_kb(uint32_t value) { min_anonymous_memory_kb_ = value; _has_field_.set(15); }
-
-  bool has_max_heapprofd_memory_kb() const { return _has_field_[16]; }
-  uint32_t max_heapprofd_memory_kb() const { return max_heapprofd_memory_kb_; }
-  void set_max_heapprofd_memory_kb(uint32_t value) { max_heapprofd_memory_kb_ = value; _has_field_.set(16); }
-
-  bool has_max_heapprofd_cpu_secs() const { return _has_field_[17]; }
-  uint64_t max_heapprofd_cpu_secs() const { return max_heapprofd_cpu_secs_; }
-  void set_max_heapprofd_cpu_secs(uint64_t value) { max_heapprofd_cpu_secs_ = value; _has_field_.set(17); }
-
-  const std::vector<std::string>& skip_symbol_prefix() const { return skip_symbol_prefix_; }
-  std::vector<std::string>* mutable_skip_symbol_prefix() { return &skip_symbol_prefix_; }
-  int skip_symbol_prefix_size() const { return static_cast<int>(skip_symbol_prefix_.size()); }
-  void clear_skip_symbol_prefix() { skip_symbol_prefix_.clear(); }
-  void add_skip_symbol_prefix(std::string value) { skip_symbol_prefix_.emplace_back(value); }
-  std::string* add_skip_symbol_prefix() { skip_symbol_prefix_.emplace_back(); return &skip_symbol_prefix_.back(); }
-
-  bool has_continuous_dump_config() const { return _has_field_[6]; }
-  const HeapprofdConfig_ContinuousDumpConfig& continuous_dump_config() const { return *continuous_dump_config_; }
-  HeapprofdConfig_ContinuousDumpConfig* mutable_continuous_dump_config() { _has_field_.set(6); return continuous_dump_config_.get(); }
-
-  bool has_shmem_size_bytes() const { return _has_field_[8]; }
-  uint64_t shmem_size_bytes() const { return shmem_size_bytes_; }
-  void set_shmem_size_bytes(uint64_t value) { shmem_size_bytes_ = value; _has_field_.set(8); }
-
-  bool has_block_client() const { return _has_field_[9]; }
-  bool block_client() const { return block_client_; }
-  void set_block_client(bool value) { block_client_ = value; _has_field_.set(9); }
-
-  bool has_block_client_timeout_us() const { return _has_field_[14]; }
-  uint32_t block_client_timeout_us() const { return block_client_timeout_us_; }
-  void set_block_client_timeout_us(uint32_t value) { block_client_timeout_us_ = value; _has_field_.set(14); }
-
-  bool has_no_startup() const { return _has_field_[10]; }
-  bool no_startup() const { return no_startup_; }
-  void set_no_startup(bool value) { no_startup_ = value; _has_field_.set(10); }
-
-  bool has_no_running() const { return _has_field_[11]; }
-  bool no_running() const { return no_running_; }
-  void set_no_running(bool value) { no_running_ = value; _has_field_.set(11); }
-
-  bool has_dump_at_max() const { return _has_field_[13]; }
-  bool dump_at_max() const { return dump_at_max_; }
-  void set_dump_at_max(bool value) { dump_at_max_ = value; _has_field_.set(13); }
-
-  bool has_disable_fork_teardown() const { return _has_field_[18]; }
-  bool disable_fork_teardown() const { return disable_fork_teardown_; }
-  void set_disable_fork_teardown(bool value) { disable_fork_teardown_ = value; _has_field_.set(18); }
-
-  bool has_disable_vfork_detection() const { return _has_field_[19]; }
-  bool disable_vfork_detection() const { return disable_vfork_detection_; }
-  void set_disable_vfork_detection(bool value) { disable_vfork_detection_ = value; _has_field_.set(19); }
-
- private:
-  uint64_t sampling_interval_bytes_{};
-  uint64_t adaptive_sampling_shmem_threshold_{};
-  uint64_t adaptive_sampling_max_sampling_interval_bytes_{};
-  std::vector<std::string> process_cmdline_;
-  std::vector<uint64_t> pid_;
-  std::vector<std::string> target_installed_by_;
-  std::vector<std::string> heaps_;
-  std::vector<std::string> exclude_heaps_;
-  bool stream_allocations_{};
-  std::vector<uint64_t> heap_sampling_intervals_;
-  bool all_heaps_{};
-  bool all_{};
-  uint32_t min_anonymous_memory_kb_{};
-  uint32_t max_heapprofd_memory_kb_{};
-  uint64_t max_heapprofd_cpu_secs_{};
-  std::vector<std::string> skip_symbol_prefix_;
-  ::protozero::CopyablePtr<HeapprofdConfig_ContinuousDumpConfig> continuous_dump_config_;
-  uint64_t shmem_size_bytes_{};
-  bool block_client_{};
-  uint32_t block_client_timeout_us_{};
-  bool no_startup_{};
-  bool no_running_{};
-  bool dump_at_max_{};
-  bool disable_fork_teardown_{};
-  bool disable_vfork_detection_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<28> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT HeapprofdConfig_ContinuousDumpConfig : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kDumpPhaseMsFieldNumber = 5,
-    kDumpIntervalMsFieldNumber = 6,
-  };
-
-  HeapprofdConfig_ContinuousDumpConfig();
-  ~HeapprofdConfig_ContinuousDumpConfig() override;
-  HeapprofdConfig_ContinuousDumpConfig(HeapprofdConfig_ContinuousDumpConfig&&) noexcept;
-  HeapprofdConfig_ContinuousDumpConfig& operator=(HeapprofdConfig_ContinuousDumpConfig&&);
-  HeapprofdConfig_ContinuousDumpConfig(const HeapprofdConfig_ContinuousDumpConfig&);
-  HeapprofdConfig_ContinuousDumpConfig& operator=(const HeapprofdConfig_ContinuousDumpConfig&);
-  bool operator==(const HeapprofdConfig_ContinuousDumpConfig&) const;
-  bool operator!=(const HeapprofdConfig_ContinuousDumpConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_dump_phase_ms() const { return _has_field_[5]; }
-  uint32_t dump_phase_ms() const { return dump_phase_ms_; }
-  void set_dump_phase_ms(uint32_t value) { dump_phase_ms_ = value; _has_field_.set(5); }
-
-  bool has_dump_interval_ms() const { return _has_field_[6]; }
-  uint32_t dump_interval_ms() const { return dump_interval_ms_; }
-  void set_dump_interval_ms(uint32_t value) { dump_interval_ms_ = value; _has_field_.set(6); }
-
- private:
-  uint32_t dump_phase_ms_{};
-  uint32_t dump_interval_ms_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<7> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_HEAPPROFD_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/android_polled_state_config.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -21559,56 +20600,25 @@ class PERFETTO_EXPORT_COMPONENT HeapprofdConfig_ContinuousDumpConfig : public ::
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/heapprofd_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_polled_state_config.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-HeapprofdConfig::HeapprofdConfig() = default;
-HeapprofdConfig::~HeapprofdConfig() = default;
-HeapprofdConfig::HeapprofdConfig(const HeapprofdConfig&) = default;
-HeapprofdConfig& HeapprofdConfig::operator=(const HeapprofdConfig&) = default;
-HeapprofdConfig::HeapprofdConfig(HeapprofdConfig&&) noexcept = default;
-HeapprofdConfig& HeapprofdConfig::operator=(HeapprofdConfig&&) = default;
+AndroidPolledStateConfig::AndroidPolledStateConfig() = default;
+AndroidPolledStateConfig::~AndroidPolledStateConfig() = default;
+AndroidPolledStateConfig::AndroidPolledStateConfig(const AndroidPolledStateConfig&) = default;
+AndroidPolledStateConfig& AndroidPolledStateConfig::operator=(const AndroidPolledStateConfig&) = default;
+AndroidPolledStateConfig::AndroidPolledStateConfig(AndroidPolledStateConfig&&) noexcept = default;
+AndroidPolledStateConfig& AndroidPolledStateConfig::operator=(AndroidPolledStateConfig&&) = default;
 
-bool HeapprofdConfig::operator==(const HeapprofdConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && sampling_interval_bytes_ == other.sampling_interval_bytes_
-   && adaptive_sampling_shmem_threshold_ == other.adaptive_sampling_shmem_threshold_
-   && adaptive_sampling_max_sampling_interval_bytes_ == other.adaptive_sampling_max_sampling_interval_bytes_
-   && process_cmdline_ == other.process_cmdline_
-   && pid_ == other.pid_
-   && target_installed_by_ == other.target_installed_by_
-   && heaps_ == other.heaps_
-   && exclude_heaps_ == other.exclude_heaps_
-   && stream_allocations_ == other.stream_allocations_
-   && heap_sampling_intervals_ == other.heap_sampling_intervals_
-   && all_heaps_ == other.all_heaps_
-   && all_ == other.all_
-   && min_anonymous_memory_kb_ == other.min_anonymous_memory_kb_
-   && max_heapprofd_memory_kb_ == other.max_heapprofd_memory_kb_
-   && max_heapprofd_cpu_secs_ == other.max_heapprofd_cpu_secs_
-   && skip_symbol_prefix_ == other.skip_symbol_prefix_
-   && continuous_dump_config_ == other.continuous_dump_config_
-   && shmem_size_bytes_ == other.shmem_size_bytes_
-   && block_client_ == other.block_client_
-   && block_client_timeout_us_ == other.block_client_timeout_us_
-   && no_startup_ == other.no_startup_
-   && no_running_ == other.no_running_
-   && dump_at_max_ == other.dump_at_max_
-   && disable_fork_teardown_ == other.disable_fork_teardown_
-   && disable_vfork_detection_ == other.disable_vfork_detection_;
+bool AndroidPolledStateConfig::operator==(const AndroidPolledStateConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(poll_ms_, other.poll_ms_);
 }
 
-bool HeapprofdConfig::ParseFromArray(const void* raw, size_t size) {
-  process_cmdline_.clear();
-  pid_.clear();
-  target_installed_by_.clear();
-  heaps_.clear();
-  exclude_heaps_.clear();
-  heap_sampling_intervals_.clear();
-  skip_symbol_prefix_.clear();
+bool AndroidPolledStateConfig::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -21618,87 +20628,8 @@ bool HeapprofdConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* sampling_interval_bytes */:
-        field.get(&sampling_interval_bytes_);
-        break;
-      case 24 /* adaptive_sampling_shmem_threshold */:
-        field.get(&adaptive_sampling_shmem_threshold_);
-        break;
-      case 25 /* adaptive_sampling_max_sampling_interval_bytes */:
-        field.get(&adaptive_sampling_max_sampling_interval_bytes_);
-        break;
-      case 2 /* process_cmdline */:
-        process_cmdline_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &process_cmdline_.back());
-        break;
-      case 4 /* pid */:
-        pid_.emplace_back();
-        field.get(&pid_.back());
-        break;
-      case 26 /* target_installed_by */:
-        target_installed_by_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &target_installed_by_.back());
-        break;
-      case 20 /* heaps */:
-        heaps_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &heaps_.back());
-        break;
-      case 27 /* exclude_heaps */:
-        exclude_heaps_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &exclude_heaps_.back());
-        break;
-      case 23 /* stream_allocations */:
-        field.get(&stream_allocations_);
-        break;
-      case 22 /* heap_sampling_intervals */:
-        heap_sampling_intervals_.emplace_back();
-        field.get(&heap_sampling_intervals_.back());
-        break;
-      case 21 /* all_heaps */:
-        field.get(&all_heaps_);
-        break;
-      case 5 /* all */:
-        field.get(&all_);
-        break;
-      case 15 /* min_anonymous_memory_kb */:
-        field.get(&min_anonymous_memory_kb_);
-        break;
-      case 16 /* max_heapprofd_memory_kb */:
-        field.get(&max_heapprofd_memory_kb_);
-        break;
-      case 17 /* max_heapprofd_cpu_secs */:
-        field.get(&max_heapprofd_cpu_secs_);
-        break;
-      case 7 /* skip_symbol_prefix */:
-        skip_symbol_prefix_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &skip_symbol_prefix_.back());
-        break;
-      case 6 /* continuous_dump_config */:
-        (*continuous_dump_config_).ParseFromArray(field.data(), field.size());
-        break;
-      case 8 /* shmem_size_bytes */:
-        field.get(&shmem_size_bytes_);
-        break;
-      case 9 /* block_client */:
-        field.get(&block_client_);
-        break;
-      case 14 /* block_client_timeout_us */:
-        field.get(&block_client_timeout_us_);
-        break;
-      case 10 /* no_startup */:
-        field.get(&no_startup_);
-        break;
-      case 11 /* no_running */:
-        field.get(&no_running_);
-        break;
-      case 13 /* dump_at_max */:
-        field.get(&dump_at_max_);
-        break;
-      case 18 /* disable_fork_teardown */:
-        field.get(&disable_fork_teardown_);
-        break;
-      case 19 /* disable_vfork_detection */:
-        field.get(&disable_vfork_detection_);
+      case 1 /* poll_ms */:
+        field.get(&poll_ms_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -21708,162 +20639,66 @@ bool HeapprofdConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string HeapprofdConfig::SerializeAsString() const {
+std::string AndroidPolledStateConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> HeapprofdConfig::SerializeAsArray() const {
+std::vector<uint8_t> AndroidPolledStateConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void HeapprofdConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: sampling_interval_bytes
+void AndroidPolledStateConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: poll_ms
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, sampling_interval_bytes_, msg);
-  }
-
-  // Field 24: adaptive_sampling_shmem_threshold
-  if (_has_field_[24]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(24, adaptive_sampling_shmem_threshold_, msg);
-  }
-
-  // Field 25: adaptive_sampling_max_sampling_interval_bytes
-  if (_has_field_[25]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(25, adaptive_sampling_max_sampling_interval_bytes_, msg);
-  }
-
-  // Field 2: process_cmdline
-  for (auto& it : process_cmdline_) {
-    ::protozero::internal::gen_helpers::SerializeString(2, it, msg);
-  }
-
-  // Field 4: pid
-  for (auto& it : pid_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, it, msg);
-  }
-
-  // Field 26: target_installed_by
-  for (auto& it : target_installed_by_) {
-    ::protozero::internal::gen_helpers::SerializeString(26, it, msg);
-  }
-
-  // Field 20: heaps
-  for (auto& it : heaps_) {
-    ::protozero::internal::gen_helpers::SerializeString(20, it, msg);
-  }
-
-  // Field 27: exclude_heaps
-  for (auto& it : exclude_heaps_) {
-    ::protozero::internal::gen_helpers::SerializeString(27, it, msg);
-  }
-
-  // Field 23: stream_allocations
-  if (_has_field_[23]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(23, stream_allocations_, msg);
-  }
-
-  // Field 22: heap_sampling_intervals
-  for (auto& it : heap_sampling_intervals_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(22, it, msg);
-  }
-
-  // Field 21: all_heaps
-  if (_has_field_[21]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(21, all_heaps_, msg);
-  }
-
-  // Field 5: all
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, all_, msg);
-  }
-
-  // Field 15: min_anonymous_memory_kb
-  if (_has_field_[15]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(15, min_anonymous_memory_kb_, msg);
-  }
-
-  // Field 16: max_heapprofd_memory_kb
-  if (_has_field_[16]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(16, max_heapprofd_memory_kb_, msg);
-  }
-
-  // Field 17: max_heapprofd_cpu_secs
-  if (_has_field_[17]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(17, max_heapprofd_cpu_secs_, msg);
-  }
-
-  // Field 7: skip_symbol_prefix
-  for (auto& it : skip_symbol_prefix_) {
-    ::protozero::internal::gen_helpers::SerializeString(7, it, msg);
-  }
-
-  // Field 6: continuous_dump_config
-  if (_has_field_[6]) {
-    (*continuous_dump_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(6));
-  }
-
-  // Field 8: shmem_size_bytes
-  if (_has_field_[8]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(8, shmem_size_bytes_, msg);
-  }
-
-  // Field 9: block_client
-  if (_has_field_[9]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(9, block_client_, msg);
-  }
-
-  // Field 14: block_client_timeout_us
-  if (_has_field_[14]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(14, block_client_timeout_us_, msg);
-  }
-
-  // Field 10: no_startup
-  if (_has_field_[10]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(10, no_startup_, msg);
-  }
-
-  // Field 11: no_running
-  if (_has_field_[11]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(11, no_running_, msg);
-  }
-
-  // Field 13: dump_at_max
-  if (_has_field_[13]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(13, dump_at_max_, msg);
-  }
-
-  // Field 18: disable_fork_teardown
-  if (_has_field_[18]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(18, disable_fork_teardown_, msg);
-  }
-
-  // Field 19: disable_vfork_detection
-  if (_has_field_[19]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(19, disable_vfork_detection_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, poll_ms_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/android_sdk_sysprop_guard_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_sdk_sysprop_guard_config.gen.h"
 
-HeapprofdConfig_ContinuousDumpConfig::HeapprofdConfig_ContinuousDumpConfig() = default;
-HeapprofdConfig_ContinuousDumpConfig::~HeapprofdConfig_ContinuousDumpConfig() = default;
-HeapprofdConfig_ContinuousDumpConfig::HeapprofdConfig_ContinuousDumpConfig(const HeapprofdConfig_ContinuousDumpConfig&) = default;
-HeapprofdConfig_ContinuousDumpConfig& HeapprofdConfig_ContinuousDumpConfig::operator=(const HeapprofdConfig_ContinuousDumpConfig&) = default;
-HeapprofdConfig_ContinuousDumpConfig::HeapprofdConfig_ContinuousDumpConfig(HeapprofdConfig_ContinuousDumpConfig&&) noexcept = default;
-HeapprofdConfig_ContinuousDumpConfig& HeapprofdConfig_ContinuousDumpConfig::operator=(HeapprofdConfig_ContinuousDumpConfig&&) = default;
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-bool HeapprofdConfig_ContinuousDumpConfig::operator==(const HeapprofdConfig_ContinuousDumpConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && dump_phase_ms_ == other.dump_phase_ms_
-   && dump_interval_ms_ == other.dump_interval_ms_;
+AndroidSdkSyspropGuardConfig::AndroidSdkSyspropGuardConfig() = default;
+AndroidSdkSyspropGuardConfig::~AndroidSdkSyspropGuardConfig() = default;
+AndroidSdkSyspropGuardConfig::AndroidSdkSyspropGuardConfig(const AndroidSdkSyspropGuardConfig&) = default;
+AndroidSdkSyspropGuardConfig& AndroidSdkSyspropGuardConfig::operator=(const AndroidSdkSyspropGuardConfig&) = default;
+AndroidSdkSyspropGuardConfig::AndroidSdkSyspropGuardConfig(AndroidSdkSyspropGuardConfig&&) noexcept = default;
+AndroidSdkSyspropGuardConfig& AndroidSdkSyspropGuardConfig::operator=(AndroidSdkSyspropGuardConfig&&) = default;
+
+bool AndroidSdkSyspropGuardConfig::operator==(const AndroidSdkSyspropGuardConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(surfaceflinger_skia_track_events_, other.surfaceflinger_skia_track_events_)
+   && ::protozero::internal::gen_helpers::EqualsField(hwui_skia_track_events_, other.hwui_skia_track_events_)
+   && ::protozero::internal::gen_helpers::EqualsField(hwui_package_name_filter_, other.hwui_package_name_filter_);
 }
 
-bool HeapprofdConfig_ContinuousDumpConfig::ParseFromArray(const void* raw, size_t size) {
+bool AndroidSdkSyspropGuardConfig::ParseFromArray(const void* raw, size_t size) {
+  hwui_package_name_filter_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -21873,11 +20708,15 @@ bool HeapprofdConfig_ContinuousDumpConfig::ParseFromArray(const void* raw, size_
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 5 /* dump_phase_ms */:
-        field.get(&dump_phase_ms_);
+      case 1 /* surfaceflinger_skia_track_events */:
+        field.get(&surfaceflinger_skia_track_events_);
         break;
-      case 6 /* dump_interval_ms */:
-        field.get(&dump_interval_ms_);
+      case 2 /* hwui_skia_track_events */:
+        field.get(&hwui_skia_track_events_);
+        break;
+      case 3 /* hwui_package_name_filter */:
+        hwui_package_name_filter_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &hwui_package_name_filter_.back());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -21887,27 +20726,32 @@ bool HeapprofdConfig_ContinuousDumpConfig::ParseFromArray(const void* raw, size_
   return !packed_error && !dec.bytes_left();
 }
 
-std::string HeapprofdConfig_ContinuousDumpConfig::SerializeAsString() const {
+std::string AndroidSdkSyspropGuardConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> HeapprofdConfig_ContinuousDumpConfig::SerializeAsArray() const {
+std::vector<uint8_t> AndroidSdkSyspropGuardConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void HeapprofdConfig_ContinuousDumpConfig::Serialize(::protozero::Message* msg) const {
-  // Field 5: dump_phase_ms
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(5, dump_phase_ms_, msg);
+void AndroidSdkSyspropGuardConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: surfaceflinger_skia_track_events
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(1, surfaceflinger_skia_track_events_, msg);
   }
 
-  // Field 6: dump_interval_ms
-  if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(6, dump_interval_ms_, msg);
+  // Field 2: hwui_skia_track_events
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, hwui_skia_track_events_, msg);
+  }
+
+  // Field 3: hwui_package_name_filter
+  for (auto& it : hwui_package_name_filter_) {
+    ::protozero::internal::gen_helpers::SerializeString(3, it, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -21919,174 +20763,7 @@ void HeapprofdConfig_ContinuousDumpConfig::Serialize(::protozero::Message* msg)
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/profiling/java_hprof_config.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/profiling/java_hprof_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_JAVA_HPROF_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_JAVA_HPROF_CONFIG_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class JavaHprofConfig;
-class JavaHprofConfig_ContinuousDumpConfig;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT JavaHprofConfig : public ::protozero::CppMessageObj {
- public:
-  using ContinuousDumpConfig = JavaHprofConfig_ContinuousDumpConfig;
-  enum FieldNumbers {
-    kProcessCmdlineFieldNumber = 1,
-    kPidFieldNumber = 2,
-    kTargetInstalledByFieldNumber = 7,
-    kContinuousDumpConfigFieldNumber = 3,
-    kMinAnonymousMemoryKbFieldNumber = 4,
-    kDumpSmapsFieldNumber = 5,
-    kIgnoredTypesFieldNumber = 6,
-  };
-
-  JavaHprofConfig();
-  ~JavaHprofConfig() override;
-  JavaHprofConfig(JavaHprofConfig&&) noexcept;
-  JavaHprofConfig& operator=(JavaHprofConfig&&);
-  JavaHprofConfig(const JavaHprofConfig&);
-  JavaHprofConfig& operator=(const JavaHprofConfig&);
-  bool operator==(const JavaHprofConfig&) const;
-  bool operator!=(const JavaHprofConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<std::string>& process_cmdline() const { return process_cmdline_; }
-  std::vector<std::string>* mutable_process_cmdline() { return &process_cmdline_; }
-  int process_cmdline_size() const { return static_cast<int>(process_cmdline_.size()); }
-  void clear_process_cmdline() { process_cmdline_.clear(); }
-  void add_process_cmdline(std::string value) { process_cmdline_.emplace_back(value); }
-  std::string* add_process_cmdline() { process_cmdline_.emplace_back(); return &process_cmdline_.back(); }
-
-  const std::vector<uint64_t>& pid() const { return pid_; }
-  std::vector<uint64_t>* mutable_pid() { return &pid_; }
-  int pid_size() const { return static_cast<int>(pid_.size()); }
-  void clear_pid() { pid_.clear(); }
-  void add_pid(uint64_t value) { pid_.emplace_back(value); }
-  uint64_t* add_pid() { pid_.emplace_back(); return &pid_.back(); }
-
-  const std::vector<std::string>& target_installed_by() const { return target_installed_by_; }
-  std::vector<std::string>* mutable_target_installed_by() { return &target_installed_by_; }
-  int target_installed_by_size() const { return static_cast<int>(target_installed_by_.size()); }
-  void clear_target_installed_by() { target_installed_by_.clear(); }
-  void add_target_installed_by(std::string value) { target_installed_by_.emplace_back(value); }
-  std::string* add_target_installed_by() { target_installed_by_.emplace_back(); return &target_installed_by_.back(); }
-
-  bool has_continuous_dump_config() const { return _has_field_[3]; }
-  const JavaHprofConfig_ContinuousDumpConfig& continuous_dump_config() const { return *continuous_dump_config_; }
-  JavaHprofConfig_ContinuousDumpConfig* mutable_continuous_dump_config() { _has_field_.set(3); return continuous_dump_config_.get(); }
-
-  bool has_min_anonymous_memory_kb() const { return _has_field_[4]; }
-  uint32_t min_anonymous_memory_kb() const { return min_anonymous_memory_kb_; }
-  void set_min_anonymous_memory_kb(uint32_t value) { min_anonymous_memory_kb_ = value; _has_field_.set(4); }
-
-  bool has_dump_smaps() const { return _has_field_[5]; }
-  bool dump_smaps() const { return dump_smaps_; }
-  void set_dump_smaps(bool value) { dump_smaps_ = value; _has_field_.set(5); }
-
-  const std::vector<std::string>& ignored_types() const { return ignored_types_; }
-  std::vector<std::string>* mutable_ignored_types() { return &ignored_types_; }
-  int ignored_types_size() const { return static_cast<int>(ignored_types_.size()); }
-  void clear_ignored_types() { ignored_types_.clear(); }
-  void add_ignored_types(std::string value) { ignored_types_.emplace_back(value); }
-  std::string* add_ignored_types() { ignored_types_.emplace_back(); return &ignored_types_.back(); }
-
- private:
-  std::vector<std::string> process_cmdline_;
-  std::vector<uint64_t> pid_;
-  std::vector<std::string> target_installed_by_;
-  ::protozero::CopyablePtr<JavaHprofConfig_ContinuousDumpConfig> continuous_dump_config_;
-  uint32_t min_anonymous_memory_kb_{};
-  bool dump_smaps_{};
-  std::vector<std::string> ignored_types_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<8> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT JavaHprofConfig_ContinuousDumpConfig : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kDumpPhaseMsFieldNumber = 1,
-    kDumpIntervalMsFieldNumber = 2,
-    kScanPidsOnlyOnStartFieldNumber = 3,
-  };
-
-  JavaHprofConfig_ContinuousDumpConfig();
-  ~JavaHprofConfig_ContinuousDumpConfig() override;
-  JavaHprofConfig_ContinuousDumpConfig(JavaHprofConfig_ContinuousDumpConfig&&) noexcept;
-  JavaHprofConfig_ContinuousDumpConfig& operator=(JavaHprofConfig_ContinuousDumpConfig&&);
-  JavaHprofConfig_ContinuousDumpConfig(const JavaHprofConfig_ContinuousDumpConfig&);
-  JavaHprofConfig_ContinuousDumpConfig& operator=(const JavaHprofConfig_ContinuousDumpConfig&);
-  bool operator==(const JavaHprofConfig_ContinuousDumpConfig&) const;
-  bool operator!=(const JavaHprofConfig_ContinuousDumpConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_dump_phase_ms() const { return _has_field_[1]; }
-  uint32_t dump_phase_ms() const { return dump_phase_ms_; }
-  void set_dump_phase_ms(uint32_t value) { dump_phase_ms_ = value; _has_field_.set(1); }
-
-  bool has_dump_interval_ms() const { return _has_field_[2]; }
-  uint32_t dump_interval_ms() const { return dump_interval_ms_; }
-  void set_dump_interval_ms(uint32_t value) { dump_interval_ms_ = value; _has_field_.set(2); }
-
-  bool has_scan_pids_only_on_start() const { return _has_field_[3]; }
-  bool scan_pids_only_on_start() const { return scan_pids_only_on_start_; }
-  void set_scan_pids_only_on_start(bool value) { scan_pids_only_on_start_ = value; _has_field_.set(3); }
-
- private:
-  uint32_t dump_phase_ms_{};
-  uint32_t dump_interval_ms_{};
-  bool scan_pids_only_on_start_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<4> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_JAVA_HPROF_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/android_system_property_config.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -22097,35 +20774,27 @@ class PERFETTO_EXPORT_COMPONENT JavaHprofConfig_ContinuousDumpConfig : public ::
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/java_hprof_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_system_property_config.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-JavaHprofConfig::JavaHprofConfig() = default;
-JavaHprofConfig::~JavaHprofConfig() = default;
-JavaHprofConfig::JavaHprofConfig(const JavaHprofConfig&) = default;
-JavaHprofConfig& JavaHprofConfig::operator=(const JavaHprofConfig&) = default;
-JavaHprofConfig::JavaHprofConfig(JavaHprofConfig&&) noexcept = default;
-JavaHprofConfig& JavaHprofConfig::operator=(JavaHprofConfig&&) = default;
+AndroidSystemPropertyConfig::AndroidSystemPropertyConfig() = default;
+AndroidSystemPropertyConfig::~AndroidSystemPropertyConfig() = default;
+AndroidSystemPropertyConfig::AndroidSystemPropertyConfig(const AndroidSystemPropertyConfig&) = default;
+AndroidSystemPropertyConfig& AndroidSystemPropertyConfig::operator=(const AndroidSystemPropertyConfig&) = default;
+AndroidSystemPropertyConfig::AndroidSystemPropertyConfig(AndroidSystemPropertyConfig&&) noexcept = default;
+AndroidSystemPropertyConfig& AndroidSystemPropertyConfig::operator=(AndroidSystemPropertyConfig&&) = default;
 
-bool JavaHprofConfig::operator==(const JavaHprofConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && process_cmdline_ == other.process_cmdline_
-   && pid_ == other.pid_
-   && target_installed_by_ == other.target_installed_by_
-   && continuous_dump_config_ == other.continuous_dump_config_
-   && min_anonymous_memory_kb_ == other.min_anonymous_memory_kb_
-   && dump_smaps_ == other.dump_smaps_
-   && ignored_types_ == other.ignored_types_;
+bool AndroidSystemPropertyConfig::operator==(const AndroidSystemPropertyConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(poll_ms_, other.poll_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(property_name_, other.property_name_);
 }
 
-bool JavaHprofConfig::ParseFromArray(const void* raw, size_t size) {
-  process_cmdline_.clear();
-  pid_.clear();
-  target_installed_by_.clear();
-  ignored_types_.clear();
+bool AndroidSystemPropertyConfig::ParseFromArray(const void* raw, size_t size) {
+  property_name_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -22135,30 +20804,12 @@ bool JavaHprofConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* process_cmdline */:
-        process_cmdline_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &process_cmdline_.back());
-        break;
-      case 2 /* pid */:
-        pid_.emplace_back();
-        field.get(&pid_.back());
-        break;
-      case 7 /* target_installed_by */:
-        target_installed_by_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &target_installed_by_.back());
-        break;
-      case 3 /* continuous_dump_config */:
-        (*continuous_dump_config_).ParseFromArray(field.data(), field.size());
-        break;
-      case 4 /* min_anonymous_memory_kb */:
-        field.get(&min_anonymous_memory_kb_);
-        break;
-      case 5 /* dump_smaps */:
-        field.get(&dump_smaps_);
+      case 1 /* poll_ms */:
+        field.get(&poll_ms_);
         break;
-      case 6 /* ignored_types */:
-        ignored_types_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &ignored_types_.back());
+      case 2 /* property_name */:
+        property_name_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &property_name_.back());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -22168,73 +20819,70 @@ bool JavaHprofConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string JavaHprofConfig::SerializeAsString() const {
+std::string AndroidSystemPropertyConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> JavaHprofConfig::SerializeAsArray() const {
+std::vector<uint8_t> AndroidSystemPropertyConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void JavaHprofConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: process_cmdline
-  for (auto& it : process_cmdline_) {
-    ::protozero::internal::gen_helpers::SerializeString(1, it, msg);
-  }
-
-  // Field 2: pid
-  for (auto& it : pid_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, it, msg);
-  }
-
-  // Field 7: target_installed_by
-  for (auto& it : target_installed_by_) {
-    ::protozero::internal::gen_helpers::SerializeString(7, it, msg);
-  }
-
-  // Field 3: continuous_dump_config
-  if (_has_field_[3]) {
-    (*continuous_dump_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(3));
-  }
-
-  // Field 4: min_anonymous_memory_kb
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, min_anonymous_memory_kb_, msg);
-  }
-
-  // Field 5: dump_smaps
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, dump_smaps_, msg);
+void AndroidSystemPropertyConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: poll_ms
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, poll_ms_, msg);
   }
 
-  // Field 6: ignored_types
-  for (auto& it : ignored_types_) {
-    ::protozero::internal::gen_helpers::SerializeString(6, it, msg);
+  // Field 2: property_name
+  for (auto& it : property_name_) {
+    ::protozero::internal::gen_helpers::SerializeString(2, it, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/app_wakelock_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/app_wakelock_config.gen.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-JavaHprofConfig_ContinuousDumpConfig::JavaHprofConfig_ContinuousDumpConfig() = default;
-JavaHprofConfig_ContinuousDumpConfig::~JavaHprofConfig_ContinuousDumpConfig() = default;
-JavaHprofConfig_ContinuousDumpConfig::JavaHprofConfig_ContinuousDumpConfig(const JavaHprofConfig_ContinuousDumpConfig&) = default;
-JavaHprofConfig_ContinuousDumpConfig& JavaHprofConfig_ContinuousDumpConfig::operator=(const JavaHprofConfig_ContinuousDumpConfig&) = default;
-JavaHprofConfig_ContinuousDumpConfig::JavaHprofConfig_ContinuousDumpConfig(JavaHprofConfig_ContinuousDumpConfig&&) noexcept = default;
-JavaHprofConfig_ContinuousDumpConfig& JavaHprofConfig_ContinuousDumpConfig::operator=(JavaHprofConfig_ContinuousDumpConfig&&) = default;
+AppWakelocksConfig::AppWakelocksConfig() = default;
+AppWakelocksConfig::~AppWakelocksConfig() = default;
+AppWakelocksConfig::AppWakelocksConfig(const AppWakelocksConfig&) = default;
+AppWakelocksConfig& AppWakelocksConfig::operator=(const AppWakelocksConfig&) = default;
+AppWakelocksConfig::AppWakelocksConfig(AppWakelocksConfig&&) noexcept = default;
+AppWakelocksConfig& AppWakelocksConfig::operator=(AppWakelocksConfig&&) = default;
 
-bool JavaHprofConfig_ContinuousDumpConfig::operator==(const JavaHprofConfig_ContinuousDumpConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && dump_phase_ms_ == other.dump_phase_ms_
-   && dump_interval_ms_ == other.dump_interval_ms_
-   && scan_pids_only_on_start_ == other.scan_pids_only_on_start_;
+bool AppWakelocksConfig::operator==(const AppWakelocksConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(write_delay_ms_, other.write_delay_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(filter_duration_below_ms_, other.filter_duration_below_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(drop_owner_pid_, other.drop_owner_pid_);
 }
 
-bool JavaHprofConfig_ContinuousDumpConfig::ParseFromArray(const void* raw, size_t size) {
+bool AppWakelocksConfig::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -22244,14 +20892,14 @@ bool JavaHprofConfig_ContinuousDumpConfig::ParseFromArray(const void* raw, size_
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* dump_phase_ms */:
-        field.get(&dump_phase_ms_);
+      case 1 /* write_delay_ms */:
+        field.get(&write_delay_ms_);
         break;
-      case 2 /* dump_interval_ms */:
-        field.get(&dump_interval_ms_);
+      case 2 /* filter_duration_below_ms */:
+        field.get(&filter_duration_below_ms_);
         break;
-      case 3 /* scan_pids_only_on_start */:
-        field.get(&scan_pids_only_on_start_);
+      case 3 /* drop_owner_pid */:
+        field.get(&drop_owner_pid_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -22261,32 +20909,32 @@ bool JavaHprofConfig_ContinuousDumpConfig::ParseFromArray(const void* raw, size_
   return !packed_error && !dec.bytes_left();
 }
 
-std::string JavaHprofConfig_ContinuousDumpConfig::SerializeAsString() const {
+std::string AppWakelocksConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> JavaHprofConfig_ContinuousDumpConfig::SerializeAsArray() const {
+std::vector<uint8_t> AppWakelocksConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void JavaHprofConfig_ContinuousDumpConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: dump_phase_ms
+void AppWakelocksConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: write_delay_ms
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, dump_phase_ms_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, write_delay_ms_, msg);
   }
 
-  // Field 2: dump_interval_ms
+  // Field 2: filter_duration_below_ms
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, dump_interval_ms_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, filter_duration_below_ms_, msg);
   }
 
-  // Field 3: scan_pids_only_on_start
+  // Field 3: drop_owner_pid
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, scan_pids_only_on_start_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, drop_owner_pid_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -22298,333 +20946,7 @@ void JavaHprofConfig_ContinuousDumpConfig::Serialize(::protozero::Message* msg)
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/profiling/perf_event_config.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/profiling/perf_event_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_PERF_EVENT_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_PERF_EVENT_CONFIG_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class PerfEventConfig;
-class PerfEventConfig_CallstackSampling;
-class PerfEventConfig_Scope;
-class PerfEvents_Timebase;
-class PerfEvents_RawEvent;
-class PerfEvents_Tracepoint;
-enum PerfEventConfig_UnwindMode : int;
-enum PerfEvents_Counter : int;
-enum PerfEvents_PerfClock : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum PerfEventConfig_UnwindMode : int {
-  PerfEventConfig_UnwindMode_UNWIND_UNKNOWN = 0,
-  PerfEventConfig_UnwindMode_UNWIND_SKIP = 1,
-  PerfEventConfig_UnwindMode_UNWIND_DWARF = 2,
-};
-
-class PERFETTO_EXPORT_COMPONENT PerfEventConfig : public ::protozero::CppMessageObj {
- public:
-  using CallstackSampling = PerfEventConfig_CallstackSampling;
-  using Scope = PerfEventConfig_Scope;
-  using UnwindMode = PerfEventConfig_UnwindMode;
-  static constexpr auto UNWIND_UNKNOWN = PerfEventConfig_UnwindMode_UNWIND_UNKNOWN;
-  static constexpr auto UNWIND_SKIP = PerfEventConfig_UnwindMode_UNWIND_SKIP;
-  static constexpr auto UNWIND_DWARF = PerfEventConfig_UnwindMode_UNWIND_DWARF;
-  static constexpr auto UnwindMode_MIN = PerfEventConfig_UnwindMode_UNWIND_UNKNOWN;
-  static constexpr auto UnwindMode_MAX = PerfEventConfig_UnwindMode_UNWIND_DWARF;
-  enum FieldNumbers {
-    kTimebaseFieldNumber = 15,
-    kCallstackSamplingFieldNumber = 16,
-    kRingBufferReadPeriodMsFieldNumber = 8,
-    kRingBufferPagesFieldNumber = 3,
-    kMaxEnqueuedFootprintKbFieldNumber = 17,
-    kMaxDaemonMemoryKbFieldNumber = 13,
-    kRemoteDescriptorTimeoutMsFieldNumber = 9,
-    kUnwindStateClearPeriodMsFieldNumber = 10,
-    kTargetInstalledByFieldNumber = 18,
-    kAllCpusFieldNumber = 1,
-    kSamplingFrequencyFieldNumber = 2,
-    kKernelFramesFieldNumber = 12,
-    kTargetPidFieldNumber = 4,
-    kTargetCmdlineFieldNumber = 5,
-    kExcludePidFieldNumber = 6,
-    kExcludeCmdlineFieldNumber = 7,
-    kAdditionalCmdlineCountFieldNumber = 11,
-  };
-
-  PerfEventConfig();
-  ~PerfEventConfig() override;
-  PerfEventConfig(PerfEventConfig&&) noexcept;
-  PerfEventConfig& operator=(PerfEventConfig&&);
-  PerfEventConfig(const PerfEventConfig&);
-  PerfEventConfig& operator=(const PerfEventConfig&);
-  bool operator==(const PerfEventConfig&) const;
-  bool operator!=(const PerfEventConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_timebase() const { return _has_field_[15]; }
-  const PerfEvents_Timebase& timebase() const { return *timebase_; }
-  PerfEvents_Timebase* mutable_timebase() { _has_field_.set(15); return timebase_.get(); }
-
-  bool has_callstack_sampling() const { return _has_field_[16]; }
-  const PerfEventConfig_CallstackSampling& callstack_sampling() const { return *callstack_sampling_; }
-  PerfEventConfig_CallstackSampling* mutable_callstack_sampling() { _has_field_.set(16); return callstack_sampling_.get(); }
-
-  bool has_ring_buffer_read_period_ms() const { return _has_field_[8]; }
-  uint32_t ring_buffer_read_period_ms() const { return ring_buffer_read_period_ms_; }
-  void set_ring_buffer_read_period_ms(uint32_t value) { ring_buffer_read_period_ms_ = value; _has_field_.set(8); }
-
-  bool has_ring_buffer_pages() const { return _has_field_[3]; }
-  uint32_t ring_buffer_pages() const { return ring_buffer_pages_; }
-  void set_ring_buffer_pages(uint32_t value) { ring_buffer_pages_ = value; _has_field_.set(3); }
-
-  bool has_max_enqueued_footprint_kb() const { return _has_field_[17]; }
-  uint64_t max_enqueued_footprint_kb() const { return max_enqueued_footprint_kb_; }
-  void set_max_enqueued_footprint_kb(uint64_t value) { max_enqueued_footprint_kb_ = value; _has_field_.set(17); }
-
-  bool has_max_daemon_memory_kb() const { return _has_field_[13]; }
-  uint32_t max_daemon_memory_kb() const { return max_daemon_memory_kb_; }
-  void set_max_daemon_memory_kb(uint32_t value) { max_daemon_memory_kb_ = value; _has_field_.set(13); }
-
-  bool has_remote_descriptor_timeout_ms() const { return _has_field_[9]; }
-  uint32_t remote_descriptor_timeout_ms() const { return remote_descriptor_timeout_ms_; }
-  void set_remote_descriptor_timeout_ms(uint32_t value) { remote_descriptor_timeout_ms_ = value; _has_field_.set(9); }
-
-  bool has_unwind_state_clear_period_ms() const { return _has_field_[10]; }
-  uint32_t unwind_state_clear_period_ms() const { return unwind_state_clear_period_ms_; }
-  void set_unwind_state_clear_period_ms(uint32_t value) { unwind_state_clear_period_ms_ = value; _has_field_.set(10); }
-
-  const std::vector<std::string>& target_installed_by() const { return target_installed_by_; }
-  std::vector<std::string>* mutable_target_installed_by() { return &target_installed_by_; }
-  int target_installed_by_size() const { return static_cast<int>(target_installed_by_.size()); }
-  void clear_target_installed_by() { target_installed_by_.clear(); }
-  void add_target_installed_by(std::string value) { target_installed_by_.emplace_back(value); }
-  std::string* add_target_installed_by() { target_installed_by_.emplace_back(); return &target_installed_by_.back(); }
-
-  bool has_all_cpus() const { return _has_field_[1]; }
-  bool all_cpus() const { return all_cpus_; }
-  void set_all_cpus(bool value) { all_cpus_ = value; _has_field_.set(1); }
-
-  bool has_sampling_frequency() const { return _has_field_[2]; }
-  uint32_t sampling_frequency() const { return sampling_frequency_; }
-  void set_sampling_frequency(uint32_t value) { sampling_frequency_ = value; _has_field_.set(2); }
-
-  bool has_kernel_frames() const { return _has_field_[12]; }
-  bool kernel_frames() const { return kernel_frames_; }
-  void set_kernel_frames(bool value) { kernel_frames_ = value; _has_field_.set(12); }
-
-  const std::vector<int32_t>& target_pid() const { return target_pid_; }
-  std::vector<int32_t>* mutable_target_pid() { return &target_pid_; }
-  int target_pid_size() const { return static_cast<int>(target_pid_.size()); }
-  void clear_target_pid() { target_pid_.clear(); }
-  void add_target_pid(int32_t value) { target_pid_.emplace_back(value); }
-  int32_t* add_target_pid() { target_pid_.emplace_back(); return &target_pid_.back(); }
-
-  const std::vector<std::string>& target_cmdline() const { return target_cmdline_; }
-  std::vector<std::string>* mutable_target_cmdline() { return &target_cmdline_; }
-  int target_cmdline_size() const { return static_cast<int>(target_cmdline_.size()); }
-  void clear_target_cmdline() { target_cmdline_.clear(); }
-  void add_target_cmdline(std::string value) { target_cmdline_.emplace_back(value); }
-  std::string* add_target_cmdline() { target_cmdline_.emplace_back(); return &target_cmdline_.back(); }
-
-  const std::vector<int32_t>& exclude_pid() const { return exclude_pid_; }
-  std::vector<int32_t>* mutable_exclude_pid() { return &exclude_pid_; }
-  int exclude_pid_size() const { return static_cast<int>(exclude_pid_.size()); }
-  void clear_exclude_pid() { exclude_pid_.clear(); }
-  void add_exclude_pid(int32_t value) { exclude_pid_.emplace_back(value); }
-  int32_t* add_exclude_pid() { exclude_pid_.emplace_back(); return &exclude_pid_.back(); }
-
-  const std::vector<std::string>& exclude_cmdline() const { return exclude_cmdline_; }
-  std::vector<std::string>* mutable_exclude_cmdline() { return &exclude_cmdline_; }
-  int exclude_cmdline_size() const { return static_cast<int>(exclude_cmdline_.size()); }
-  void clear_exclude_cmdline() { exclude_cmdline_.clear(); }
-  void add_exclude_cmdline(std::string value) { exclude_cmdline_.emplace_back(value); }
-  std::string* add_exclude_cmdline() { exclude_cmdline_.emplace_back(); return &exclude_cmdline_.back(); }
-
-  bool has_additional_cmdline_count() const { return _has_field_[11]; }
-  uint32_t additional_cmdline_count() const { return additional_cmdline_count_; }
-  void set_additional_cmdline_count(uint32_t value) { additional_cmdline_count_ = value; _has_field_.set(11); }
-
- private:
-  ::protozero::CopyablePtr<PerfEvents_Timebase> timebase_;
-  ::protozero::CopyablePtr<PerfEventConfig_CallstackSampling> callstack_sampling_;
-  uint32_t ring_buffer_read_period_ms_{};
-  uint32_t ring_buffer_pages_{};
-  uint64_t max_enqueued_footprint_kb_{};
-  uint32_t max_daemon_memory_kb_{};
-  uint32_t remote_descriptor_timeout_ms_{};
-  uint32_t unwind_state_clear_period_ms_{};
-  std::vector<std::string> target_installed_by_;
-  bool all_cpus_{};
-  uint32_t sampling_frequency_{};
-  bool kernel_frames_{};
-  std::vector<int32_t> target_pid_;
-  std::vector<std::string> target_cmdline_;
-  std::vector<int32_t> exclude_pid_;
-  std::vector<std::string> exclude_cmdline_;
-  uint32_t additional_cmdline_count_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<19> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT PerfEventConfig_CallstackSampling : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kScopeFieldNumber = 1,
-    kKernelFramesFieldNumber = 2,
-    kUserFramesFieldNumber = 3,
-  };
-
-  PerfEventConfig_CallstackSampling();
-  ~PerfEventConfig_CallstackSampling() override;
-  PerfEventConfig_CallstackSampling(PerfEventConfig_CallstackSampling&&) noexcept;
-  PerfEventConfig_CallstackSampling& operator=(PerfEventConfig_CallstackSampling&&);
-  PerfEventConfig_CallstackSampling(const PerfEventConfig_CallstackSampling&);
-  PerfEventConfig_CallstackSampling& operator=(const PerfEventConfig_CallstackSampling&);
-  bool operator==(const PerfEventConfig_CallstackSampling&) const;
-  bool operator!=(const PerfEventConfig_CallstackSampling& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_scope() const { return _has_field_[1]; }
-  const PerfEventConfig_Scope& scope() const { return *scope_; }
-  PerfEventConfig_Scope* mutable_scope() { _has_field_.set(1); return scope_.get(); }
-
-  bool has_kernel_frames() const { return _has_field_[2]; }
-  bool kernel_frames() const { return kernel_frames_; }
-  void set_kernel_frames(bool value) { kernel_frames_ = value; _has_field_.set(2); }
-
-  bool has_user_frames() const { return _has_field_[3]; }
-  PerfEventConfig_UnwindMode user_frames() const { return user_frames_; }
-  void set_user_frames(PerfEventConfig_UnwindMode value) { user_frames_ = value; _has_field_.set(3); }
-
- private:
-  ::protozero::CopyablePtr<PerfEventConfig_Scope> scope_;
-  bool kernel_frames_{};
-  PerfEventConfig_UnwindMode user_frames_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<4> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT PerfEventConfig_Scope : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kTargetPidFieldNumber = 1,
-    kTargetCmdlineFieldNumber = 2,
-    kExcludePidFieldNumber = 3,
-    kExcludeCmdlineFieldNumber = 4,
-    kAdditionalCmdlineCountFieldNumber = 5,
-    kProcessShardCountFieldNumber = 6,
-  };
-
-  PerfEventConfig_Scope();
-  ~PerfEventConfig_Scope() override;
-  PerfEventConfig_Scope(PerfEventConfig_Scope&&) noexcept;
-  PerfEventConfig_Scope& operator=(PerfEventConfig_Scope&&);
-  PerfEventConfig_Scope(const PerfEventConfig_Scope&);
-  PerfEventConfig_Scope& operator=(const PerfEventConfig_Scope&);
-  bool operator==(const PerfEventConfig_Scope&) const;
-  bool operator!=(const PerfEventConfig_Scope& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<int32_t>& target_pid() const { return target_pid_; }
-  std::vector<int32_t>* mutable_target_pid() { return &target_pid_; }
-  int target_pid_size() const { return static_cast<int>(target_pid_.size()); }
-  void clear_target_pid() { target_pid_.clear(); }
-  void add_target_pid(int32_t value) { target_pid_.emplace_back(value); }
-  int32_t* add_target_pid() { target_pid_.emplace_back(); return &target_pid_.back(); }
-
-  const std::vector<std::string>& target_cmdline() const { return target_cmdline_; }
-  std::vector<std::string>* mutable_target_cmdline() { return &target_cmdline_; }
-  int target_cmdline_size() const { return static_cast<int>(target_cmdline_.size()); }
-  void clear_target_cmdline() { target_cmdline_.clear(); }
-  void add_target_cmdline(std::string value) { target_cmdline_.emplace_back(value); }
-  std::string* add_target_cmdline() { target_cmdline_.emplace_back(); return &target_cmdline_.back(); }
-
-  const std::vector<int32_t>& exclude_pid() const { return exclude_pid_; }
-  std::vector<int32_t>* mutable_exclude_pid() { return &exclude_pid_; }
-  int exclude_pid_size() const { return static_cast<int>(exclude_pid_.size()); }
-  void clear_exclude_pid() { exclude_pid_.clear(); }
-  void add_exclude_pid(int32_t value) { exclude_pid_.emplace_back(value); }
-  int32_t* add_exclude_pid() { exclude_pid_.emplace_back(); return &exclude_pid_.back(); }
-
-  const std::vector<std::string>& exclude_cmdline() const { return exclude_cmdline_; }
-  std::vector<std::string>* mutable_exclude_cmdline() { return &exclude_cmdline_; }
-  int exclude_cmdline_size() const { return static_cast<int>(exclude_cmdline_.size()); }
-  void clear_exclude_cmdline() { exclude_cmdline_.clear(); }
-  void add_exclude_cmdline(std::string value) { exclude_cmdline_.emplace_back(value); }
-  std::string* add_exclude_cmdline() { exclude_cmdline_.emplace_back(); return &exclude_cmdline_.back(); }
-
-  bool has_additional_cmdline_count() const { return _has_field_[5]; }
-  uint32_t additional_cmdline_count() const { return additional_cmdline_count_; }
-  void set_additional_cmdline_count(uint32_t value) { additional_cmdline_count_ = value; _has_field_.set(5); }
-
-  bool has_process_shard_count() const { return _has_field_[6]; }
-  uint32_t process_shard_count() const { return process_shard_count_; }
-  void set_process_shard_count(uint32_t value) { process_shard_count_ = value; _has_field_.set(6); }
-
- private:
-  std::vector<int32_t> target_pid_;
-  std::vector<std::string> target_cmdline_;
-  std::vector<int32_t> exclude_pid_;
-  std::vector<std::string> exclude_cmdline_;
-  uint32_t additional_cmdline_count_{};
-  uint32_t process_shard_count_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<7> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_PERF_EVENT_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/cpu_per_uid_config.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -22635,47 +20957,25 @@ class PERFETTO_EXPORT_COMPONENT PerfEventConfig_Scope : public ::protozero::CppM
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/perf_event_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/common/perf_events.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/cpu_per_uid_config.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-PerfEventConfig::PerfEventConfig() = default;
-PerfEventConfig::~PerfEventConfig() = default;
-PerfEventConfig::PerfEventConfig(const PerfEventConfig&) = default;
-PerfEventConfig& PerfEventConfig::operator=(const PerfEventConfig&) = default;
-PerfEventConfig::PerfEventConfig(PerfEventConfig&&) noexcept = default;
-PerfEventConfig& PerfEventConfig::operator=(PerfEventConfig&&) = default;
+CpuPerUidConfig::CpuPerUidConfig() = default;
+CpuPerUidConfig::~CpuPerUidConfig() = default;
+CpuPerUidConfig::CpuPerUidConfig(const CpuPerUidConfig&) = default;
+CpuPerUidConfig& CpuPerUidConfig::operator=(const CpuPerUidConfig&) = default;
+CpuPerUidConfig::CpuPerUidConfig(CpuPerUidConfig&&) noexcept = default;
+CpuPerUidConfig& CpuPerUidConfig::operator=(CpuPerUidConfig&&) = default;
 
-bool PerfEventConfig::operator==(const PerfEventConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && timebase_ == other.timebase_
-   && callstack_sampling_ == other.callstack_sampling_
-   && ring_buffer_read_period_ms_ == other.ring_buffer_read_period_ms_
-   && ring_buffer_pages_ == other.ring_buffer_pages_
-   && max_enqueued_footprint_kb_ == other.max_enqueued_footprint_kb_
-   && max_daemon_memory_kb_ == other.max_daemon_memory_kb_
-   && remote_descriptor_timeout_ms_ == other.remote_descriptor_timeout_ms_
-   && unwind_state_clear_period_ms_ == other.unwind_state_clear_period_ms_
-   && target_installed_by_ == other.target_installed_by_
-   && all_cpus_ == other.all_cpus_
-   && sampling_frequency_ == other.sampling_frequency_
-   && kernel_frames_ == other.kernel_frames_
-   && target_pid_ == other.target_pid_
-   && target_cmdline_ == other.target_cmdline_
-   && exclude_pid_ == other.exclude_pid_
-   && exclude_cmdline_ == other.exclude_cmdline_
-   && additional_cmdline_count_ == other.additional_cmdline_count_;
+bool CpuPerUidConfig::operator==(const CpuPerUidConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(poll_ms_, other.poll_ms_);
 }
 
-bool PerfEventConfig::ParseFromArray(const void* raw, size_t size) {
-  target_installed_by_.clear();
-  target_pid_.clear();
-  target_cmdline_.clear();
-  exclude_pid_.clear();
-  exclude_cmdline_.clear();
+bool CpuPerUidConfig::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -22685,61 +20985,8 @@ bool PerfEventConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 15 /* timebase */:
-        (*timebase_).ParseFromArray(field.data(), field.size());
-        break;
-      case 16 /* callstack_sampling */:
-        (*callstack_sampling_).ParseFromArray(field.data(), field.size());
-        break;
-      case 8 /* ring_buffer_read_period_ms */:
-        field.get(&ring_buffer_read_period_ms_);
-        break;
-      case 3 /* ring_buffer_pages */:
-        field.get(&ring_buffer_pages_);
-        break;
-      case 17 /* max_enqueued_footprint_kb */:
-        field.get(&max_enqueued_footprint_kb_);
-        break;
-      case 13 /* max_daemon_memory_kb */:
-        field.get(&max_daemon_memory_kb_);
-        break;
-      case 9 /* remote_descriptor_timeout_ms */:
-        field.get(&remote_descriptor_timeout_ms_);
-        break;
-      case 10 /* unwind_state_clear_period_ms */:
-        field.get(&unwind_state_clear_period_ms_);
-        break;
-      case 18 /* target_installed_by */:
-        target_installed_by_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &target_installed_by_.back());
-        break;
-      case 1 /* all_cpus */:
-        field.get(&all_cpus_);
-        break;
-      case 2 /* sampling_frequency */:
-        field.get(&sampling_frequency_);
-        break;
-      case 12 /* kernel_frames */:
-        field.get(&kernel_frames_);
-        break;
-      case 4 /* target_pid */:
-        target_pid_.emplace_back();
-        field.get(&target_pid_.back());
-        break;
-      case 5 /* target_cmdline */:
-        target_cmdline_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &target_cmdline_.back());
-        break;
-      case 6 /* exclude_pid */:
-        exclude_pid_.emplace_back();
-        field.get(&exclude_pid_.back());
-        break;
-      case 7 /* exclude_cmdline */:
-        exclude_cmdline_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &exclude_cmdline_.back());
-        break;
-      case 11 /* additional_cmdline_count */:
-        field.get(&additional_cmdline_count_);
+      case 1 /* poll_ms */:
+        field.get(&poll_ms_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -22749,123 +20996,65 @@ bool PerfEventConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string PerfEventConfig::SerializeAsString() const {
+std::string CpuPerUidConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> PerfEventConfig::SerializeAsArray() const {
+std::vector<uint8_t> CpuPerUidConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void PerfEventConfig::Serialize(::protozero::Message* msg) const {
-  // Field 15: timebase
-  if (_has_field_[15]) {
-    (*timebase_).Serialize(msg->BeginNestedMessage<::protozero::Message>(15));
-  }
-
-  // Field 16: callstack_sampling
-  if (_has_field_[16]) {
-    (*callstack_sampling_).Serialize(msg->BeginNestedMessage<::protozero::Message>(16));
-  }
-
-  // Field 8: ring_buffer_read_period_ms
-  if (_has_field_[8]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(8, ring_buffer_read_period_ms_, msg);
-  }
-
-  // Field 3: ring_buffer_pages
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, ring_buffer_pages_, msg);
-  }
-
-  // Field 17: max_enqueued_footprint_kb
-  if (_has_field_[17]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(17, max_enqueued_footprint_kb_, msg);
-  }
-
-  // Field 13: max_daemon_memory_kb
-  if (_has_field_[13]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(13, max_daemon_memory_kb_, msg);
-  }
-
-  // Field 9: remote_descriptor_timeout_ms
-  if (_has_field_[9]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(9, remote_descriptor_timeout_ms_, msg);
-  }
-
-  // Field 10: unwind_state_clear_period_ms
-  if (_has_field_[10]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(10, unwind_state_clear_period_ms_, msg);
-  }
-
-  // Field 18: target_installed_by
-  for (auto& it : target_installed_by_) {
-    ::protozero::internal::gen_helpers::SerializeString(18, it, msg);
-  }
-
-  // Field 1: all_cpus
+void CpuPerUidConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: poll_ms
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(1, all_cpus_, msg);
-  }
-
-  // Field 2: sampling_frequency
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, sampling_frequency_, msg);
-  }
-
-  // Field 12: kernel_frames
-  if (_has_field_[12]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(12, kernel_frames_, msg);
-  }
-
-  // Field 4: target_pid
-  for (auto& it : target_pid_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, it, msg);
-  }
-
-  // Field 5: target_cmdline
-  for (auto& it : target_cmdline_) {
-    ::protozero::internal::gen_helpers::SerializeString(5, it, msg);
-  }
-
-  // Field 6: exclude_pid
-  for (auto& it : exclude_pid_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(6, it, msg);
-  }
-
-  // Field 7: exclude_cmdline
-  for (auto& it : exclude_cmdline_) {
-    ::protozero::internal::gen_helpers::SerializeString(7, it, msg);
-  }
-
-  // Field 11: additional_cmdline_count
-  if (_has_field_[11]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(11, additional_cmdline_count_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, poll_ms_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/inputmethod_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/inputmethod_config.gen.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-PerfEventConfig_CallstackSampling::PerfEventConfig_CallstackSampling() = default;
-PerfEventConfig_CallstackSampling::~PerfEventConfig_CallstackSampling() = default;
-PerfEventConfig_CallstackSampling::PerfEventConfig_CallstackSampling(const PerfEventConfig_CallstackSampling&) = default;
-PerfEventConfig_CallstackSampling& PerfEventConfig_CallstackSampling::operator=(const PerfEventConfig_CallstackSampling&) = default;
-PerfEventConfig_CallstackSampling::PerfEventConfig_CallstackSampling(PerfEventConfig_CallstackSampling&&) noexcept = default;
-PerfEventConfig_CallstackSampling& PerfEventConfig_CallstackSampling::operator=(PerfEventConfig_CallstackSampling&&) = default;
+InputMethodConfig::InputMethodConfig() = default;
+InputMethodConfig::~InputMethodConfig() = default;
+InputMethodConfig::InputMethodConfig(const InputMethodConfig&) = default;
+InputMethodConfig& InputMethodConfig::operator=(const InputMethodConfig&) = default;
+InputMethodConfig::InputMethodConfig(InputMethodConfig&&) noexcept = default;
+InputMethodConfig& InputMethodConfig::operator=(InputMethodConfig&&) = default;
 
-bool PerfEventConfig_CallstackSampling::operator==(const PerfEventConfig_CallstackSampling& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && scope_ == other.scope_
-   && kernel_frames_ == other.kernel_frames_
-   && user_frames_ == other.user_frames_;
+bool InputMethodConfig::operator==(const InputMethodConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(client_, other.client_)
+   && ::protozero::internal::gen_helpers::EqualsField(service_, other.service_)
+   && ::protozero::internal::gen_helpers::EqualsField(manager_service_, other.manager_service_);
 }
 
-bool PerfEventConfig_CallstackSampling::ParseFromArray(const void* raw, size_t size) {
+bool InputMethodConfig::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -22875,14 +21064,14 @@ bool PerfEventConfig_CallstackSampling::ParseFromArray(const void* raw, size_t s
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* scope */:
-        (*scope_).ParseFromArray(field.data(), field.size());
+      case 1 /* client */:
+        field.get(&client_);
         break;
-      case 2 /* kernel_frames */:
-        field.get(&kernel_frames_);
+      case 2 /* service */:
+        field.get(&service_);
         break;
-      case 3 /* user_frames */:
-        field.get(&user_frames_);
+      case 3 /* manager_service */:
+        field.get(&manager_service_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -22892,60 +21081,73 @@ bool PerfEventConfig_CallstackSampling::ParseFromArray(const void* raw, size_t s
   return !packed_error && !dec.bytes_left();
 }
 
-std::string PerfEventConfig_CallstackSampling::SerializeAsString() const {
+std::string InputMethodConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> PerfEventConfig_CallstackSampling::SerializeAsArray() const {
+std::vector<uint8_t> InputMethodConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void PerfEventConfig_CallstackSampling::Serialize(::protozero::Message* msg) const {
-  // Field 1: scope
+void InputMethodConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: client
   if (_has_field_[1]) {
-    (*scope_).Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(1, client_, msg);
   }
 
-  // Field 2: kernel_frames
+  // Field 2: service
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, kernel_frames_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, service_, msg);
   }
 
-  // Field 3: user_frames
+  // Field 3: manager_service
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, user_frames_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, manager_service_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/kernel_wakelocks_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/kernel_wakelocks_config.gen.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-PerfEventConfig_Scope::PerfEventConfig_Scope() = default;
-PerfEventConfig_Scope::~PerfEventConfig_Scope() = default;
-PerfEventConfig_Scope::PerfEventConfig_Scope(const PerfEventConfig_Scope&) = default;
-PerfEventConfig_Scope& PerfEventConfig_Scope::operator=(const PerfEventConfig_Scope&) = default;
-PerfEventConfig_Scope::PerfEventConfig_Scope(PerfEventConfig_Scope&&) noexcept = default;
-PerfEventConfig_Scope& PerfEventConfig_Scope::operator=(PerfEventConfig_Scope&&) = default;
+KernelWakelocksConfig::KernelWakelocksConfig() = default;
+KernelWakelocksConfig::~KernelWakelocksConfig() = default;
+KernelWakelocksConfig::KernelWakelocksConfig(const KernelWakelocksConfig&) = default;
+KernelWakelocksConfig& KernelWakelocksConfig::operator=(const KernelWakelocksConfig&) = default;
+KernelWakelocksConfig::KernelWakelocksConfig(KernelWakelocksConfig&&) noexcept = default;
+KernelWakelocksConfig& KernelWakelocksConfig::operator=(KernelWakelocksConfig&&) = default;
 
-bool PerfEventConfig_Scope::operator==(const PerfEventConfig_Scope& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && target_pid_ == other.target_pid_
-   && target_cmdline_ == other.target_cmdline_
-   && exclude_pid_ == other.exclude_pid_
-   && exclude_cmdline_ == other.exclude_cmdline_
-   && additional_cmdline_count_ == other.additional_cmdline_count_
-   && process_shard_count_ == other.process_shard_count_;
+bool KernelWakelocksConfig::operator==(const KernelWakelocksConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(poll_ms_, other.poll_ms_);
 }
 
-bool PerfEventConfig_Scope::ParseFromArray(const void* raw, size_t size) {
-  target_pid_.clear();
-  target_cmdline_.clear();
-  exclude_pid_.clear();
-  exclude_cmdline_.clear();
+bool KernelWakelocksConfig::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -22955,27 +21157,8 @@ bool PerfEventConfig_Scope::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* target_pid */:
-        target_pid_.emplace_back();
-        field.get(&target_pid_.back());
-        break;
-      case 2 /* target_cmdline */:
-        target_cmdline_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &target_cmdline_.back());
-        break;
-      case 3 /* exclude_pid */:
-        exclude_pid_.emplace_back();
-        field.get(&exclude_pid_.back());
-        break;
-      case 4 /* exclude_cmdline */:
-        exclude_cmdline_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &exclude_cmdline_.back());
-        break;
-      case 5 /* additional_cmdline_count */:
-        field.get(&additional_cmdline_count_);
-        break;
-      case 6 /* process_shard_count */:
-        field.get(&process_shard_count_);
+      case 1 /* poll_ms */:
+        field.get(&poll_ms_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -22985,47 +21168,22 @@ bool PerfEventConfig_Scope::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string PerfEventConfig_Scope::SerializeAsString() const {
+std::string KernelWakelocksConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> PerfEventConfig_Scope::SerializeAsArray() const {
+std::vector<uint8_t> KernelWakelocksConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void PerfEventConfig_Scope::Serialize(::protozero::Message* msg) const {
-  // Field 1: target_pid
-  for (auto& it : target_pid_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, it, msg);
-  }
-
-  // Field 2: target_cmdline
-  for (auto& it : target_cmdline_) {
-    ::protozero::internal::gen_helpers::SerializeString(2, it, msg);
-  }
-
-  // Field 3: exclude_pid
-  for (auto& it : exclude_pid_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, it, msg);
-  }
-
-  // Field 4: exclude_cmdline
-  for (auto& it : exclude_cmdline_) {
-    ::protozero::internal::gen_helpers::SerializeString(4, it, msg);
-  }
-
-  // Field 5: additional_cmdline_count
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(5, additional_cmdline_count_, msg);
-  }
-
-  // Field 6: process_shard_count
-  if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(6, process_shard_count_, msg);
+void KernelWakelocksConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: poll_ms
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, poll_ms_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -23037,585 +21195,7 @@ void PerfEventConfig_Scope::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/statsd/atom_ids.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/statsd/atom_ids.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_ATOM_IDS_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_ATOM_IDS_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum AtomId : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum AtomId : int {
-  BLE_SCAN_STATE_CHANGED = 2,
-  PROCESS_STATE_CHANGED = 3,
-  BLE_SCAN_RESULT_RECEIVED = 4,
-  SENSOR_STATE_CHANGED = 5,
-  GPS_SCAN_STATE_CHANGED = 6,
-  SYNC_STATE_CHANGED = 7,
-  SCHEDULED_JOB_STATE_CHANGED = 8,
-  SCREEN_BRIGHTNESS_CHANGED = 9,
-  WAKELOCK_STATE_CHANGED = 10,
-  LONG_PARTIAL_WAKELOCK_STATE_CHANGED = 11,
-  MOBILE_RADIO_POWER_STATE_CHANGED = 12,
-  WIFI_RADIO_POWER_STATE_CHANGED = 13,
-  ACTIVITY_MANAGER_SLEEP_STATE_CHANGED = 14,
-  MEMORY_FACTOR_STATE_CHANGED = 15,
-  EXCESSIVE_CPU_USAGE_REPORTED = 16,
-  CACHED_KILL_REPORTED = 17,
-  PROCESS_MEMORY_STAT_REPORTED = 18,
-  LAUNCHER_EVENT = 19,
-  BATTERY_SAVER_MODE_STATE_CHANGED = 20,
-  DEVICE_IDLE_MODE_STATE_CHANGED = 21,
-  DEVICE_IDLING_MODE_STATE_CHANGED = 22,
-  AUDIO_STATE_CHANGED = 23,
-  MEDIA_CODEC_STATE_CHANGED = 24,
-  CAMERA_STATE_CHANGED = 25,
-  FLASHLIGHT_STATE_CHANGED = 26,
-  UID_PROCESS_STATE_CHANGED = 27,
-  PROCESS_LIFE_CYCLE_STATE_CHANGED = 28,
-  SCREEN_STATE_CHANGED = 29,
-  BATTERY_LEVEL_CHANGED = 30,
-  CHARGING_STATE_CHANGED = 31,
-  PLUGGED_STATE_CHANGED = 32,
-  INTERACTIVE_STATE_CHANGED = 33,
-  TOUCH_EVENT_REPORTED = 34,
-  WAKEUP_ALARM_OCCURRED = 35,
-  KERNEL_WAKEUP_REPORTED = 36,
-  WIFI_LOCK_STATE_CHANGED = 37,
-  WIFI_SIGNAL_STRENGTH_CHANGED = 38,
-  WIFI_SCAN_STATE_CHANGED = 39,
-  PHONE_SIGNAL_STRENGTH_CHANGED = 40,
-  SETTING_CHANGED = 41,
-  ACTIVITY_FOREGROUND_STATE_CHANGED = 42,
-  ISOLATED_UID_CHANGED = 43,
-  PACKET_WAKEUP_OCCURRED = 44,
-  WALL_CLOCK_TIME_SHIFTED = 45,
-  ANOMALY_DETECTED = 46,
-  APP_BREADCRUMB_REPORTED = 47,
-  APP_START_OCCURRED = 48,
-  APP_START_CANCELED = 49,
-  APP_START_FULLY_DRAWN = 50,
-  LMK_KILL_OCCURRED = 51,
-  PICTURE_IN_PICTURE_STATE_CHANGED = 52,
-  WIFI_MULTICAST_LOCK_STATE_CHANGED = 53,
-  LMK_STATE_CHANGED = 54,
-  APP_START_MEMORY_STATE_CAPTURED = 55,
-  SHUTDOWN_SEQUENCE_REPORTED = 56,
-  BOOT_SEQUENCE_REPORTED = 57,
-  DAVEY_OCCURRED = 58,
-  OVERLAY_STATE_CHANGED = 59,
-  FOREGROUND_SERVICE_STATE_CHANGED = 60,
-  CALL_STATE_CHANGED = 61,
-  KEYGUARD_STATE_CHANGED = 62,
-  KEYGUARD_BOUNCER_STATE_CHANGED = 63,
-  KEYGUARD_BOUNCER_PASSWORD_ENTERED = 64,
-  APP_DIED = 65,
-  RESOURCE_CONFIGURATION_CHANGED = 66,
-  BLUETOOTH_ENABLED_STATE_CHANGED = 67,
-  BLUETOOTH_CONNECTION_STATE_CHANGED = 68,
-  GPS_SIGNAL_QUALITY_CHANGED = 69,
-  USB_CONNECTOR_STATE_CHANGED = 70,
-  SPEAKER_IMPEDANCE_REPORTED = 71,
-  HARDWARE_FAILED = 72,
-  PHYSICAL_DROP_DETECTED = 73,
-  CHARGE_CYCLES_REPORTED = 74,
-  MOBILE_CONNECTION_STATE_CHANGED = 75,
-  MOBILE_RADIO_TECHNOLOGY_CHANGED = 76,
-  USB_DEVICE_ATTACHED = 77,
-  APP_CRASH_OCCURRED = 78,
-  ANR_OCCURRED = 79,
-  WTF_OCCURRED = 80,
-  LOW_MEM_REPORTED = 81,
-  GENERIC_ATOM = 82,
-  KEY_VALUE_PAIRS_ATOM = 83,
-  VIBRATOR_STATE_CHANGED = 84,
-  DEFERRED_JOB_STATS_REPORTED = 85,
-  THERMAL_THROTTLING = 86,
-  BIOMETRIC_ACQUIRED = 87,
-  BIOMETRIC_AUTHENTICATED = 88,
-  BIOMETRIC_ERROR_OCCURRED = 89,
-  UI_EVENT_REPORTED = 90,
-  BATTERY_HEALTH_SNAPSHOT = 91,
-  SLOW_IO = 92,
-  BATTERY_CAUSED_SHUTDOWN = 93,
-  PHONE_SERVICE_STATE_CHANGED = 94,
-  PHONE_STATE_CHANGED = 95,
-  USER_RESTRICTION_CHANGED = 96,
-  SETTINGS_UI_CHANGED = 97,
-  CONNECTIVITY_STATE_CHANGED = 98,
-  SERVICE_STATE_CHANGED = 99,
-  SERVICE_LAUNCH_REPORTED = 100,
-  FLAG_FLIP_UPDATE_OCCURRED = 101,
-  BINARY_PUSH_STATE_CHANGED = 102,
-  DEVICE_POLICY_EVENT = 103,
-  DOCS_UI_FILE_OP_CANCELED = 104,
-  DOCS_UI_FILE_OP_COPY_MOVE_MODE_REPORTED = 105,
-  DOCS_UI_FILE_OP_FAILURE = 106,
-  DOCS_UI_PROVIDER_FILE_OP = 107,
-  DOCS_UI_INVALID_SCOPED_ACCESS_REQUEST = 108,
-  DOCS_UI_LAUNCH_REPORTED = 109,
-  DOCS_UI_ROOT_VISITED = 110,
-  DOCS_UI_STARTUP_MS = 111,
-  DOCS_UI_USER_ACTION_REPORTED = 112,
-  WIFI_ENABLED_STATE_CHANGED = 113,
-  WIFI_RUNNING_STATE_CHANGED = 114,
-  APP_COMPACTED = 115,
-  NETWORK_DNS_EVENT_REPORTED = 116,
-  DOCS_UI_PICKER_LAUNCHED_FROM_REPORTED = 117,
-  DOCS_UI_PICK_RESULT_REPORTED = 118,
-  DOCS_UI_SEARCH_MODE_REPORTED = 119,
-  DOCS_UI_SEARCH_TYPE_REPORTED = 120,
-  DATA_STALL_EVENT = 121,
-  RESCUE_PARTY_RESET_REPORTED = 122,
-  SIGNED_CONFIG_REPORTED = 123,
-  GNSS_NI_EVENT_REPORTED = 124,
-  BLUETOOTH_LINK_LAYER_CONNECTION_EVENT = 125,
-  BLUETOOTH_ACL_CONNECTION_STATE_CHANGED = 126,
-  BLUETOOTH_SCO_CONNECTION_STATE_CHANGED = 127,
-  APP_DOWNGRADED = 128,
-  APP_OPTIMIZED_AFTER_DOWNGRADED = 129,
-  LOW_STORAGE_STATE_CHANGED = 130,
-  GNSS_NFW_NOTIFICATION_REPORTED = 131,
-  GNSS_CONFIGURATION_REPORTED = 132,
-  USB_PORT_OVERHEAT_EVENT_REPORTED = 133,
-  NFC_ERROR_OCCURRED = 134,
-  NFC_STATE_CHANGED = 135,
-  NFC_BEAM_OCCURRED = 136,
-  NFC_CARDEMULATION_OCCURRED = 137,
-  NFC_TAG_OCCURRED = 138,
-  NFC_HCE_TRANSACTION_OCCURRED = 139,
-  SE_STATE_CHANGED = 140,
-  SE_OMAPI_REPORTED = 141,
-  BROADCAST_DISPATCH_LATENCY_REPORTED = 142,
-  ATTENTION_MANAGER_SERVICE_RESULT_REPORTED = 143,
-  ADB_CONNECTION_CHANGED = 144,
-  SPEECH_DSP_STAT_REPORTED = 145,
-  USB_CONTAMINANT_REPORTED = 146,
-  WATCHDOG_ROLLBACK_OCCURRED = 147,
-  BIOMETRIC_SYSTEM_HEALTH_ISSUE_DETECTED = 148,
-  BUBBLE_UI_CHANGED = 149,
-  SCHEDULED_JOB_CONSTRAINT_CHANGED = 150,
-  BLUETOOTH_ACTIVE_DEVICE_CHANGED = 151,
-  BLUETOOTH_A2DP_PLAYBACK_STATE_CHANGED = 152,
-  BLUETOOTH_A2DP_CODEC_CONFIG_CHANGED = 153,
-  BLUETOOTH_A2DP_CODEC_CAPABILITY_CHANGED = 154,
-  BLUETOOTH_A2DP_AUDIO_UNDERRUN_REPORTED = 155,
-  BLUETOOTH_A2DP_AUDIO_OVERRUN_REPORTED = 156,
-  BLUETOOTH_DEVICE_RSSI_REPORTED = 157,
-  BLUETOOTH_DEVICE_FAILED_CONTACT_COUNTER_REPORTED = 158,
-  BLUETOOTH_DEVICE_TX_POWER_LEVEL_REPORTED = 159,
-  BLUETOOTH_HCI_TIMEOUT_REPORTED = 160,
-  BLUETOOTH_QUALITY_REPORT_REPORTED = 161,
-  BLUETOOTH_DEVICE_INFO_REPORTED = 162,
-  BLUETOOTH_REMOTE_VERSION_INFO_REPORTED = 163,
-  BLUETOOTH_SDP_ATTRIBUTE_REPORTED = 164,
-  BLUETOOTH_BOND_STATE_CHANGED = 165,
-  BLUETOOTH_CLASSIC_PAIRING_EVENT_REPORTED = 166,
-  BLUETOOTH_SMP_PAIRING_EVENT_REPORTED = 167,
-  SCREEN_TIMEOUT_EXTENSION_REPORTED = 168,
-  PROCESS_START_TIME = 169,
-  PERMISSION_GRANT_REQUEST_RESULT_REPORTED = 170,
-  BLUETOOTH_SOCKET_CONNECTION_STATE_CHANGED = 171,
-  DEVICE_IDENTIFIER_ACCESS_DENIED = 172,
-  BUBBLE_DEVELOPER_ERROR_REPORTED = 173,
-  ASSIST_GESTURE_STAGE_REPORTED = 174,
-  ASSIST_GESTURE_FEEDBACK_REPORTED = 175,
-  ASSIST_GESTURE_PROGRESS_REPORTED = 176,
-  TOUCH_GESTURE_CLASSIFIED = 177,
-  HIDDEN_API_USED = 178,
-  STYLE_UI_CHANGED = 179,
-  PRIVACY_INDICATORS_INTERACTED = 180,
-  APP_INSTALL_ON_EXTERNAL_STORAGE_REPORTED = 181,
-  NETWORK_STACK_REPORTED = 182,
-  APP_MOVED_STORAGE_REPORTED = 183,
-  BIOMETRIC_ENROLLED = 184,
-  SYSTEM_SERVER_WATCHDOG_OCCURRED = 185,
-  TOMB_STONE_OCCURRED = 186,
-  BLUETOOTH_CLASS_OF_DEVICE_REPORTED = 187,
-  INTELLIGENCE_EVENT_REPORTED = 188,
-  THERMAL_THROTTLING_SEVERITY_STATE_CHANGED = 189,
-  ROLE_REQUEST_RESULT_REPORTED = 190,
-  MEDIAMETRICS_AUDIOPOLICY_REPORTED = 191,
-  MEDIAMETRICS_AUDIORECORD_REPORTED = 192,
-  MEDIAMETRICS_AUDIOTHREAD_REPORTED = 193,
-  MEDIAMETRICS_AUDIOTRACK_REPORTED = 194,
-  MEDIAMETRICS_CODEC_REPORTED = 195,
-  MEDIAMETRICS_DRM_WIDEVINE_REPORTED = 196,
-  MEDIAMETRICS_EXTRACTOR_REPORTED = 197,
-  MEDIAMETRICS_MEDIADRM_REPORTED = 198,
-  MEDIAMETRICS_NUPLAYER_REPORTED = 199,
-  MEDIAMETRICS_RECORDER_REPORTED = 200,
-  MEDIAMETRICS_DRMMANAGER_REPORTED = 201,
-  CAR_POWER_STATE_CHANGED = 203,
-  GARAGE_MODE_INFO = 204,
-  TEST_ATOM_REPORTED = 205,
-  CONTENT_CAPTURE_CALLER_MISMATCH_REPORTED = 206,
-  CONTENT_CAPTURE_SERVICE_EVENTS = 207,
-  CONTENT_CAPTURE_SESSION_EVENTS = 208,
-  CONTENT_CAPTURE_FLUSHED = 209,
-  LOCATION_MANAGER_API_USAGE_REPORTED = 210,
-  REVIEW_PERMISSIONS_FRAGMENT_RESULT_REPORTED = 211,
-  RUNTIME_PERMISSIONS_UPGRADE_RESULT = 212,
-  GRANT_PERMISSIONS_ACTIVITY_BUTTON_ACTIONS = 213,
-  LOCATION_ACCESS_CHECK_NOTIFICATION_ACTION = 214,
-  APP_PERMISSION_FRAGMENT_ACTION_REPORTED = 215,
-  APP_PERMISSION_FRAGMENT_VIEWED = 216,
-  APP_PERMISSIONS_FRAGMENT_VIEWED = 217,
-  PERMISSION_APPS_FRAGMENT_VIEWED = 218,
-  TEXT_SELECTION_EVENT = 219,
-  TEXT_LINKIFY_EVENT = 220,
-  CONVERSATION_ACTIONS_EVENT = 221,
-  LANGUAGE_DETECTION_EVENT = 222,
-  EXCLUSION_RECT_STATE_CHANGED = 223,
-  BACK_GESTURE_REPORTED_REPORTED = 224,
-  UPDATE_ENGINE_UPDATE_ATTEMPT_REPORTED = 225,
-  UPDATE_ENGINE_SUCCESSFUL_UPDATE_REPORTED = 226,
-  CAMERA_ACTION_EVENT = 227,
-  APP_COMPATIBILITY_CHANGE_REPORTED = 228,
-  PERFETTO_UPLOADED = 229,
-  VMS_CLIENT_CONNECTION_STATE_CHANGED = 230,
-  MEDIA_PROVIDER_SCAN_OCCURRED = 233,
-  MEDIA_CONTENT_DELETED = 234,
-  MEDIA_PROVIDER_PERMISSION_REQUESTED = 235,
-  MEDIA_PROVIDER_SCHEMA_CHANGED = 236,
-  MEDIA_PROVIDER_IDLE_MAINTENANCE_FINISHED = 237,
-  REBOOT_ESCROW_RECOVERY_REPORTED = 238,
-  BOOT_TIME_EVENT_DURATION_REPORTED = 239,
-  BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED = 240,
-  BOOT_TIME_EVENT_UTC_TIME_REPORTED = 241,
-  BOOT_TIME_EVENT_ERROR_CODE_REPORTED = 242,
-  USERSPACE_REBOOT_REPORTED = 243,
-  NOTIFICATION_REPORTED = 244,
-  NOTIFICATION_PANEL_REPORTED = 245,
-  NOTIFICATION_CHANNEL_MODIFIED = 246,
-  INTEGRITY_CHECK_RESULT_REPORTED = 247,
-  INTEGRITY_RULES_PUSHED = 248,
-  CB_MESSAGE_REPORTED = 249,
-  CB_MESSAGE_ERROR = 250,
-  WIFI_HEALTH_STAT_REPORTED = 251,
-  WIFI_FAILURE_STAT_REPORTED = 252,
-  WIFI_CONNECTION_RESULT_REPORTED = 253,
-  APP_FREEZE_CHANGED = 254,
-  SNAPSHOT_MERGE_REPORTED = 255,
-  FOREGROUND_SERVICE_APP_OP_SESSION_ENDED = 256,
-  DISPLAY_JANK_REPORTED = 257,
-  APP_STANDBY_BUCKET_CHANGED = 258,
-  SHARESHEET_STARTED = 259,
-  RANKING_SELECTED = 260,
-  TVSETTINGS_UI_INTERACTED = 261,
-  LAUNCHER_SNAPSHOT = 262,
-  PACKAGE_INSTALLER_V2_REPORTED = 263,
-  USER_LIFECYCLE_JOURNEY_REPORTED = 264,
-  USER_LIFECYCLE_EVENT_OCCURRED = 265,
-  ACCESSIBILITY_SHORTCUT_REPORTED = 266,
-  ACCESSIBILITY_SERVICE_REPORTED = 267,
-  DOCS_UI_DRAG_AND_DROP_REPORTED = 268,
-  APP_USAGE_EVENT_OCCURRED = 269,
-  AUTO_REVOKE_NOTIFICATION_CLICKED = 270,
-  AUTO_REVOKE_FRAGMENT_APP_VIEWED = 271,
-  AUTO_REVOKED_APP_INTERACTION = 272,
-  APP_PERMISSION_GROUPS_FRAGMENT_AUTO_REVOKE_ACTION = 273,
-  EVS_USAGE_STATS_REPORTED = 274,
-  AUDIO_POWER_USAGE_DATA_REPORTED = 275,
-  TV_TUNER_STATE_CHANGED = 276,
-  MEDIAOUTPUT_OP_SWITCH_REPORTED = 277,
-  CB_MESSAGE_FILTERED = 278,
-  TV_TUNER_DVR_STATUS = 279,
-  TV_CAS_SESSION_OPEN_STATUS = 280,
-  ASSISTANT_INVOCATION_REPORTED = 281,
-  DISPLAY_WAKE_REPORTED = 282,
-  CAR_USER_HAL_MODIFY_USER_REQUEST_REPORTED = 283,
-  CAR_USER_HAL_MODIFY_USER_RESPONSE_REPORTED = 284,
-  CAR_USER_HAL_POST_SWITCH_RESPONSE_REPORTED = 285,
-  CAR_USER_HAL_INITIAL_USER_INFO_REQUEST_REPORTED = 286,
-  CAR_USER_HAL_INITIAL_USER_INFO_RESPONSE_REPORTED = 287,
-  CAR_USER_HAL_USER_ASSOCIATION_REQUEST_REPORTED = 288,
-  CAR_USER_HAL_SET_USER_ASSOCIATION_RESPONSE_REPORTED = 289,
-  NETWORK_IP_PROVISIONING_REPORTED = 290,
-  NETWORK_DHCP_RENEW_REPORTED = 291,
-  NETWORK_VALIDATION_REPORTED = 292,
-  NETWORK_STACK_QUIRK_REPORTED = 293,
-  MEDIAMETRICS_AUDIORECORDDEVICEUSAGE_REPORTED = 294,
-  MEDIAMETRICS_AUDIOTHREADDEVICEUSAGE_REPORTED = 295,
-  MEDIAMETRICS_AUDIOTRACKDEVICEUSAGE_REPORTED = 296,
-  MEDIAMETRICS_AUDIODEVICECONNECTION_REPORTED = 297,
-  BLOB_COMMITTED = 298,
-  BLOB_LEASED = 299,
-  BLOB_OPENED = 300,
-  CONTACTS_PROVIDER_STATUS_REPORTED = 301,
-  KEYSTORE_KEY_EVENT_REPORTED = 302,
-  NETWORK_TETHERING_REPORTED = 303,
-  IME_TOUCH_REPORTED = 304,
-  UI_INTERACTION_FRAME_INFO_REPORTED = 305,
-  UI_ACTION_LATENCY_REPORTED = 306,
-  WIFI_DISCONNECT_REPORTED = 307,
-  WIFI_CONNECTION_STATE_CHANGED = 308,
-  HDMI_CEC_ACTIVE_SOURCE_CHANGED = 309,
-  HDMI_CEC_MESSAGE_REPORTED = 310,
-  AIRPLANE_MODE = 311,
-  MODEM_RESTART = 312,
-  CARRIER_ID_MISMATCH_REPORTED = 313,
-  CARRIER_ID_TABLE_UPDATED = 314,
-  DATA_STALL_RECOVERY_REPORTED = 315,
-  MEDIAMETRICS_MEDIAPARSER_REPORTED = 316,
-  TLS_HANDSHAKE_REPORTED = 317,
-  TEXT_CLASSIFIER_API_USAGE_REPORTED = 318,
-  CAR_WATCHDOG_KILL_STATS_REPORTED = 319,
-  MEDIAMETRICS_PLAYBACK_REPORTED = 320,
-  MEDIA_NETWORK_INFO_CHANGED = 321,
-  MEDIA_PLAYBACK_STATE_CHANGED = 322,
-  MEDIA_PLAYBACK_ERROR_REPORTED = 323,
-  MEDIA_PLAYBACK_TRACK_CHANGED = 324,
-  WIFI_SCAN_REPORTED = 325,
-  WIFI_PNO_SCAN_REPORTED = 326,
-  TIF_TUNE_CHANGED = 327,
-  AUTO_ROTATE_REPORTED = 328,
-  PERFETTO_TRIGGER = 329,
-  TRANSCODING_DATA = 330,
-  IMS_SERVICE_ENTITLEMENT_UPDATED = 331,
-  ART_DATUM_REPORTED = 332,
-  DEVICE_ROTATED = 333,
-  SIM_SPECIFIC_SETTINGS_RESTORED = 334,
-  PIN_STORAGE_EVENT = 336,
-  FACE_DOWN_REPORTED = 337,
-  BLUETOOTH_HAL_CRASH_REASON_REPORTED = 338,
-  REBOOT_ESCROW_PREPARATION_REPORTED = 339,
-  REBOOT_ESCROW_LSKF_CAPTURE_REPORTED = 340,
-  REBOOT_ESCROW_REBOOT_REPORTED = 341,
-  BINDER_LATENCY_REPORTED = 342,
-  MEDIAMETRICS_AAUDIOSTREAM_REPORTED = 343,
-  MEDIA_TRANSCODING_SESSION_ENDED = 344,
-  MAGNIFICATION_USAGE_REPORTED = 345,
-  MAGNIFICATION_MODE_WITH_IME_ON_REPORTED = 346,
-  APP_SEARCH_CALL_STATS_REPORTED = 347,
-  APP_SEARCH_PUT_DOCUMENT_STATS_REPORTED = 348,
-  DEVICE_CONTROL_CHANGED = 349,
-  DEVICE_STATE_CHANGED = 350,
-  INPUTDEVICE_REGISTERED = 351,
-  SMARTSPACE_CARD_REPORTED = 352,
-  AUTH_PROMPT_AUTHENTICATE_INVOKED = 353,
-  AUTH_MANAGER_CAN_AUTHENTICATE_INVOKED = 354,
-  AUTH_ENROLL_ACTION_INVOKED = 355,
-  AUTH_DEPRECATED_API_USED = 356,
-  UNATTENDED_REBOOT_OCCURRED = 357,
-  LONG_REBOOT_BLOCKING_REPORTED = 358,
-  LOCATION_TIME_ZONE_PROVIDER_STATE_CHANGED = 359,
-  FDTRACK_EVENT_OCCURRED = 364,
-  TIMEOUT_AUTO_EXTENDED_REPORTED = 365,
-  ODREFRESH_REPORTED = 366,
-  ALARM_BATCH_DELIVERED = 367,
-  ALARM_SCHEDULED = 368,
-  CAR_WATCHDOG_IO_OVERUSE_STATS_REPORTED = 369,
-  USER_LEVEL_HIBERNATION_STATE_CHANGED = 370,
-  APP_SEARCH_INITIALIZE_STATS_REPORTED = 371,
-  APP_SEARCH_QUERY_STATS_REPORTED = 372,
-  APP_PROCESS_DIED = 373,
-  NETWORK_IP_REACHABILITY_MONITOR_REPORTED = 374,
-  SLOW_INPUT_EVENT_REPORTED = 375,
-  ANR_OCCURRED_PROCESSING_STARTED = 376,
-  APP_SEARCH_REMOVE_STATS_REPORTED = 377,
-  MEDIA_CODEC_REPORTED = 378,
-  PERMISSION_USAGE_FRAGMENT_INTERACTION = 379,
-  PERMISSION_DETAILS_INTERACTION = 380,
-  PRIVACY_SENSOR_TOGGLE_INTERACTION = 381,
-  PRIVACY_TOGGLE_DIALOG_INTERACTION = 382,
-  APP_SEARCH_OPTIMIZE_STATS_REPORTED = 383,
-  APP_COMPAT_STATE_CHANGED = 386,
-  SIZE_COMPAT_RESTART_BUTTON_EVENT_REPORTED = 387,
-  SPLITSCREEN_UI_CHANGED = 388,
-  BLUETOOTH_CODE_PATH_COUNTER = 390,
-  BLUETOOTH_LE_BATCH_SCAN_REPORT_DELAY = 392,
-  ACCESSIBILITY_FLOATING_MENU_UI_CHANGED = 393,
-  NEURALNETWORKS_COMPILATION_COMPLETED = 394,
-  NEURALNETWORKS_EXECUTION_COMPLETED = 395,
-  NEURALNETWORKS_COMPILATION_FAILED = 396,
-  NEURALNETWORKS_EXECUTION_FAILED = 397,
-  VM_CREATION_REQUESTED = 409,
-  CAMERA_COMPAT_CONTROL_EVENT_REPORTED = 411,
-  TRACING_SERVICE_REPORT_EVENT = 424,
-  EARLY_BOOT_COMP_OS_ARTIFACTS_CHECK_REPORTED = 419,
-  ISOLATED_COMPILATION_SCHEDULED = 457,
-  ISOLATED_COMPILATION_ENDED = 458,
-  TELEPHONY_ANOMALY_DETECTED = 461,
-  HOTWORD_DETECTOR_CREATE_REQUESTED = 430,
-  HOTWORD_DETECTION_SERVICE_INIT_RESULT_REPORTED = 431,
-  HOTWORD_DETECTION_SERVICE_RESTARTED = 432,
-  HOTWORD_DETECTOR_KEYPHRASE_TRIGGERED = 433,
-  HOTWORD_DETECTOR_EVENTS = 434,
-  REMOTE_KEY_PROVISIONING_ATTEMPT = 463,
-  REMOTE_KEY_PROVISIONING_NETWORK_INFO = 464,
-  REMOTE_KEY_PROVISIONING_TIMING = 465,
-  WIFI_BYTES_TRANSFER = 10000,
-  WIFI_BYTES_TRANSFER_BY_FG_BG = 10001,
-  MOBILE_BYTES_TRANSFER = 10002,
-  MOBILE_BYTES_TRANSFER_BY_FG_BG = 10003,
-  BLUETOOTH_BYTES_TRANSFER = 10006,
-  KERNEL_WAKELOCK = 10004,
-  SUBSYSTEM_SLEEP_STATE = 10005,
-  CPU_TIME_PER_UID = 10009,
-  CPU_TIME_PER_UID_FREQ = 10010,
-  WIFI_ACTIVITY_INFO = 10011,
-  MODEM_ACTIVITY_INFO = 10012,
-  BLUETOOTH_ACTIVITY_INFO = 10007,
-  PROCESS_MEMORY_STATE = 10013,
-  SYSTEM_ELAPSED_REALTIME = 10014,
-  SYSTEM_UPTIME = 10015,
-  CPU_ACTIVE_TIME = 10016,
-  CPU_CLUSTER_TIME = 10017,
-  DISK_SPACE = 10018,
-  REMAINING_BATTERY_CAPACITY = 10019,
-  FULL_BATTERY_CAPACITY = 10020,
-  TEMPERATURE = 10021,
-  BINDER_CALLS = 10022,
-  BINDER_CALLS_EXCEPTIONS = 10023,
-  LOOPER_STATS = 10024,
-  DISK_STATS = 10025,
-  DIRECTORY_USAGE = 10026,
-  APP_SIZE = 10027,
-  CATEGORY_SIZE = 10028,
-  PROC_STATS = 10029,
-  BATTERY_VOLTAGE = 10030,
-  NUM_FINGERPRINTS_ENROLLED = 10031,
-  DISK_IO = 10032,
-  POWER_PROFILE = 10033,
-  PROC_STATS_PKG_PROC = 10034,
-  PROCESS_CPU_TIME = 10035,
-  CPU_TIME_PER_THREAD_FREQ = 10037,
-  ON_DEVICE_POWER_MEASUREMENT = 10038,
-  DEVICE_CALCULATED_POWER_USE = 10039,
-  DEVICE_CALCULATED_POWER_BLAME_UID = 10040,
-  DEVICE_CALCULATED_POWER_BLAME_OTHER = 10041,
-  PROCESS_MEMORY_HIGH_WATER_MARK = 10042,
-  BATTERY_LEVEL = 10043,
-  BUILD_INFORMATION = 10044,
-  BATTERY_CYCLE_COUNT = 10045,
-  DEBUG_ELAPSED_CLOCK = 10046,
-  DEBUG_FAILING_ELAPSED_CLOCK = 10047,
-  NUM_FACES_ENROLLED = 10048,
-  ROLE_HOLDER = 10049,
-  DANGEROUS_PERMISSION_STATE = 10050,
-  TRAIN_INFO = 10051,
-  TIME_ZONE_DATA_INFO = 10052,
-  EXTERNAL_STORAGE_INFO = 10053,
-  GPU_STATS_GLOBAL_INFO = 10054,
-  GPU_STATS_APP_INFO = 10055,
-  SYSTEM_ION_HEAP_SIZE = 10056,
-  APPS_ON_EXTERNAL_STORAGE_INFO = 10057,
-  FACE_SETTINGS = 10058,
-  COOLING_DEVICE = 10059,
-  APP_OPS = 10060,
-  PROCESS_SYSTEM_ION_HEAP_SIZE = 10061,
-  SURFACEFLINGER_STATS_GLOBAL_INFO = 10062,
-  SURFACEFLINGER_STATS_LAYER_INFO = 10063,
-  PROCESS_MEMORY_SNAPSHOT = 10064,
-  VMS_CLIENT_STATS = 10065,
-  NOTIFICATION_REMOTE_VIEWS = 10066,
-  DANGEROUS_PERMISSION_STATE_SAMPLED = 10067,
-  GRAPHICS_STATS = 10068,
-  RUNTIME_APP_OP_ACCESS = 10069,
-  ION_HEAP_SIZE = 10070,
-  PACKAGE_NOTIFICATION_PREFERENCES = 10071,
-  PACKAGE_NOTIFICATION_CHANNEL_PREFERENCES = 10072,
-  PACKAGE_NOTIFICATION_CHANNEL_GROUP_PREFERENCES = 10073,
-  GNSS_STATS = 10074,
-  ATTRIBUTED_APP_OPS = 10075,
-  VOICE_CALL_SESSION = 10076,
-  VOICE_CALL_RAT_USAGE = 10077,
-  SIM_SLOT_STATE = 10078,
-  SUPPORTED_RADIO_ACCESS_FAMILY = 10079,
-  SETTING_SNAPSHOT = 10080,
-  BLOB_INFO = 10081,
-  DATA_USAGE_BYTES_TRANSFER = 10082,
-  BYTES_TRANSFER_BY_TAG_AND_METERED = 10083,
-  DND_MODE_RULE = 10084,
-  GENERAL_EXTERNAL_STORAGE_ACCESS_STATS = 10085,
-  INCOMING_SMS = 10086,
-  OUTGOING_SMS = 10087,
-  CARRIER_ID_TABLE_VERSION = 10088,
-  DATA_CALL_SESSION = 10089,
-  CELLULAR_SERVICE_STATE = 10090,
-  CELLULAR_DATA_SERVICE_SWITCH = 10091,
-  SYSTEM_MEMORY = 10092,
-  IMS_REGISTRATION_TERMINATION = 10093,
-  IMS_REGISTRATION_STATS = 10094,
-  CPU_TIME_PER_CLUSTER_FREQ = 10095,
-  CPU_CYCLES_PER_UID_CLUSTER = 10096,
-  DEVICE_ROTATED_DATA = 10097,
-  CPU_CYCLES_PER_THREAD_GROUP_CLUSTER = 10098,
-  MEDIA_DRM_ACTIVITY_INFO = 10099,
-  OEM_MANAGED_BYTES_TRANSFER = 10100,
-  GNSS_POWER_STATS = 10101,
-  TIME_ZONE_DETECTOR_STATE = 10102,
-  KEYSTORE2_STORAGE_STATS = 10103,
-  RKP_POOL_STATS = 10104,
-  PROCESS_DMABUF_MEMORY = 10105,
-  PENDING_ALARM_INFO = 10106,
-  USER_LEVEL_HIBERNATED_APPS = 10107,
-  LAUNCHER_LAYOUT_SNAPSHOT = 10108,
-  GLOBAL_HIBERNATED_APPS = 10109,
-  INPUT_EVENT_LATENCY_SKETCH = 10110,
-  BATTERY_USAGE_STATS_BEFORE_RESET = 10111,
-  BATTERY_USAGE_STATS_SINCE_RESET = 10112,
-  BATTERY_USAGE_STATS_SINCE_RESET_USING_POWER_PROFILE_MODEL = 10113,
-  INSTALLED_INCREMENTAL_PACKAGE = 10114,
-  TELEPHONY_NETWORK_REQUESTS = 10115,
-  APP_SEARCH_STORAGE_INFO = 10116,
-  VMSTAT = 10117,
-  KEYSTORE2_KEY_CREATION_WITH_GENERAL_INFO = 10118,
-  KEYSTORE2_KEY_CREATION_WITH_AUTH_INFO = 10119,
-  KEYSTORE2_KEY_CREATION_WITH_PURPOSE_AND_MODES_INFO = 10120,
-  KEYSTORE2_ATOM_WITH_OVERFLOW = 10121,
-  KEYSTORE2_KEY_OPERATION_WITH_PURPOSE_AND_MODES_INFO = 10122,
-  KEYSTORE2_KEY_OPERATION_WITH_GENERAL_INFO = 10123,
-  RKP_ERROR_STATS = 10124,
-  KEYSTORE2_CRASH_STATS = 10125,
-  ACCESSIBILITY_SHORTCUT_STATS = 10127,
-  ACCESSIBILITY_FLOATING_MENU_STATS = 10128,
-  CAR_WATCHDOG_SYSTEM_IO_USAGE_SUMMARY = 10131,
-  CAR_WATCHDOG_UID_IO_USAGE_SUMMARY = 10132,
-  IMS_REGISTRATION_FEATURE_TAG_STATS = 10133,
-  RCS_CLIENT_PROVISIONING_STATS = 10134,
-  RCS_ACS_PROVISIONING_STATS = 10135,
-  SIP_DELEGATE_STATS = 10136,
-  SIP_TRANSPORT_FEATURE_TAG_STATS = 10137,
-  SIP_MESSAGE_RESPONSE = 10138,
-  SIP_TRANSPORT_SESSION = 10139,
-  IMS_DEDICATED_BEARER_LISTENER_EVENT = 10140,
-  IMS_DEDICATED_BEARER_EVENT = 10141,
-  IMS_REGISTRATION_SERVICE_DESC_STATS = 10142,
-  UCE_EVENT_STATS = 10143,
-  PRESENCE_NOTIFY_EVENT = 10144,
-  GBA_EVENT = 10145,
-  REMOTE_KEY_PROVISIONING_ERROR_COUNTS = 10155,
-};
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_ATOM_IDS_PROTO_CPP_H_
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/network_trace_config.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -23626,172 +21206,118 @@ enum AtomId : int {
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/statsd/atom_ids.gen.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/statsd/statsd_tracing_config.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/statsd/statsd_tracing_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_STATSD_TRACING_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_STATSD_TRACING_CONFIG_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/network_trace_config.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
-class StatsdPullAtomConfig;
-class StatsdTracingConfig;
-enum AtomId : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+NetworkPacketTraceConfig::NetworkPacketTraceConfig() = default;
+NetworkPacketTraceConfig::~NetworkPacketTraceConfig() = default;
+NetworkPacketTraceConfig::NetworkPacketTraceConfig(const NetworkPacketTraceConfig&) = default;
+NetworkPacketTraceConfig& NetworkPacketTraceConfig::operator=(const NetworkPacketTraceConfig&) = default;
+NetworkPacketTraceConfig::NetworkPacketTraceConfig(NetworkPacketTraceConfig&&) noexcept = default;
+NetworkPacketTraceConfig& NetworkPacketTraceConfig::operator=(NetworkPacketTraceConfig&&) = default;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+bool NetworkPacketTraceConfig::operator==(const NetworkPacketTraceConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(poll_ms_, other.poll_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(aggregation_threshold_, other.aggregation_threshold_)
+   && ::protozero::internal::gen_helpers::EqualsField(intern_limit_, other.intern_limit_)
+   && ::protozero::internal::gen_helpers::EqualsField(drop_local_port_, other.drop_local_port_)
+   && ::protozero::internal::gen_helpers::EqualsField(drop_remote_port_, other.drop_remote_port_)
+   && ::protozero::internal::gen_helpers::EqualsField(drop_tcp_flags_, other.drop_tcp_flags_);
+}
 
-class PERFETTO_EXPORT_COMPONENT StatsdPullAtomConfig : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kPullAtomIdFieldNumber = 1,
-    kRawPullAtomIdFieldNumber = 2,
-    kPullFrequencyMsFieldNumber = 3,
-    kPackagesFieldNumber = 4,
-  };
+bool NetworkPacketTraceConfig::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  StatsdPullAtomConfig();
-  ~StatsdPullAtomConfig() override;
-  StatsdPullAtomConfig(StatsdPullAtomConfig&&) noexcept;
-  StatsdPullAtomConfig& operator=(StatsdPullAtomConfig&&);
-  StatsdPullAtomConfig(const StatsdPullAtomConfig&);
-  StatsdPullAtomConfig& operator=(const StatsdPullAtomConfig&);
-  bool operator==(const StatsdPullAtomConfig&) const;
-  bool operator!=(const StatsdPullAtomConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<AtomId>& pull_atom_id() const { return pull_atom_id_; }
-  std::vector<AtomId>* mutable_pull_atom_id() { return &pull_atom_id_; }
-  int pull_atom_id_size() const { return static_cast<int>(pull_atom_id_.size()); }
-  void clear_pull_atom_id() { pull_atom_id_.clear(); }
-  void add_pull_atom_id(AtomId value) { pull_atom_id_.emplace_back(value); }
-  AtomId* add_pull_atom_id() { pull_atom_id_.emplace_back(); return &pull_atom_id_.back(); }
-
-  const std::vector<int32_t>& raw_pull_atom_id() const { return raw_pull_atom_id_; }
-  std::vector<int32_t>* mutable_raw_pull_atom_id() { return &raw_pull_atom_id_; }
-  int raw_pull_atom_id_size() const { return static_cast<int>(raw_pull_atom_id_.size()); }
-  void clear_raw_pull_atom_id() { raw_pull_atom_id_.clear(); }
-  void add_raw_pull_atom_id(int32_t value) { raw_pull_atom_id_.emplace_back(value); }
-  int32_t* add_raw_pull_atom_id() { raw_pull_atom_id_.emplace_back(); return &raw_pull_atom_id_.back(); }
-
-  bool has_pull_frequency_ms() const { return _has_field_[3]; }
-  int32_t pull_frequency_ms() const { return pull_frequency_ms_; }
-  void set_pull_frequency_ms(int32_t value) { pull_frequency_ms_ = value; _has_field_.set(3); }
-
-  const std::vector<std::string>& packages() const { return packages_; }
-  std::vector<std::string>* mutable_packages() { return &packages_; }
-  int packages_size() const { return static_cast<int>(packages_.size()); }
-  void clear_packages() { packages_.clear(); }
-  void add_packages(std::string value) { packages_.emplace_back(value); }
-  std::string* add_packages() { packages_.emplace_back(); return &packages_.back(); }
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* poll_ms */:
+        field.get(&poll_ms_);
+        break;
+      case 2 /* aggregation_threshold */:
+        field.get(&aggregation_threshold_);
+        break;
+      case 3 /* intern_limit */:
+        field.get(&intern_limit_);
+        break;
+      case 4 /* drop_local_port */:
+        field.get(&drop_local_port_);
+        break;
+      case 5 /* drop_remote_port */:
+        field.get(&drop_remote_port_);
+        break;
+      case 6 /* drop_tcp_flags */:
+        field.get(&drop_tcp_flags_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
- private:
-  std::vector<AtomId> pull_atom_id_;
-  std::vector<int32_t> raw_pull_atom_id_;
-  int32_t pull_frequency_ms_{};
-  std::vector<std::string> packages_;
+std::string NetworkPacketTraceConfig::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+std::vector<uint8_t> NetworkPacketTraceConfig::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  std::bitset<5> _has_field_{};
-};
+void NetworkPacketTraceConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: poll_ms
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, poll_ms_, msg);
+  }
 
+  // Field 2: aggregation_threshold
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, aggregation_threshold_, msg);
+  }
 
-class PERFETTO_EXPORT_COMPONENT StatsdTracingConfig : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kPushAtomIdFieldNumber = 1,
-    kRawPushAtomIdFieldNumber = 2,
-    kPullConfigFieldNumber = 3,
-  };
+  // Field 3: intern_limit
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, intern_limit_, msg);
+  }
 
-  StatsdTracingConfig();
-  ~StatsdTracingConfig() override;
-  StatsdTracingConfig(StatsdTracingConfig&&) noexcept;
-  StatsdTracingConfig& operator=(StatsdTracingConfig&&);
-  StatsdTracingConfig(const StatsdTracingConfig&);
-  StatsdTracingConfig& operator=(const StatsdTracingConfig&);
-  bool operator==(const StatsdTracingConfig&) const;
-  bool operator!=(const StatsdTracingConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<AtomId>& push_atom_id() const { return push_atom_id_; }
-  std::vector<AtomId>* mutable_push_atom_id() { return &push_atom_id_; }
-  int push_atom_id_size() const { return static_cast<int>(push_atom_id_.size()); }
-  void clear_push_atom_id() { push_atom_id_.clear(); }
-  void add_push_atom_id(AtomId value) { push_atom_id_.emplace_back(value); }
-  AtomId* add_push_atom_id() { push_atom_id_.emplace_back(); return &push_atom_id_.back(); }
-
-  const std::vector<int32_t>& raw_push_atom_id() const { return raw_push_atom_id_; }
-  std::vector<int32_t>* mutable_raw_push_atom_id() { return &raw_push_atom_id_; }
-  int raw_push_atom_id_size() const { return static_cast<int>(raw_push_atom_id_.size()); }
-  void clear_raw_push_atom_id() { raw_push_atom_id_.clear(); }
-  void add_raw_push_atom_id(int32_t value) { raw_push_atom_id_.emplace_back(value); }
-  int32_t* add_raw_push_atom_id() { raw_push_atom_id_.emplace_back(); return &raw_push_atom_id_.back(); }
-
-  const std::vector<StatsdPullAtomConfig>& pull_config() const { return pull_config_; }
-  std::vector<StatsdPullAtomConfig>* mutable_pull_config() { return &pull_config_; }
-  int pull_config_size() const;
-  void clear_pull_config();
-  StatsdPullAtomConfig* add_pull_config();
+  // Field 4: drop_local_port
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(4, drop_local_port_, msg);
+  }
 
- private:
-  std::vector<AtomId> push_atom_id_;
-  std::vector<int32_t> raw_push_atom_id_;
-  std::vector<StatsdPullAtomConfig> pull_config_;
+  // Field 5: drop_remote_port
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, drop_remote_port_, msg);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  // Field 6: drop_tcp_flags
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(6, drop_tcp_flags_, msg);
+  }
 
-  std::bitset<4> _has_field_{};
-};
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_STATSD_TRACING_CONFIG_PROTO_CPP_H_
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/packages_list_config.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -23802,32 +21328,27 @@ class PERFETTO_EXPORT_COMPONENT StatsdTracingConfig : public ::protozero::CppMes
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/statsd/statsd_tracing_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/statsd/atom_ids.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/packages_list_config.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-StatsdPullAtomConfig::StatsdPullAtomConfig() = default;
-StatsdPullAtomConfig::~StatsdPullAtomConfig() = default;
-StatsdPullAtomConfig::StatsdPullAtomConfig(const StatsdPullAtomConfig&) = default;
-StatsdPullAtomConfig& StatsdPullAtomConfig::operator=(const StatsdPullAtomConfig&) = default;
-StatsdPullAtomConfig::StatsdPullAtomConfig(StatsdPullAtomConfig&&) noexcept = default;
-StatsdPullAtomConfig& StatsdPullAtomConfig::operator=(StatsdPullAtomConfig&&) = default;
+PackagesListConfig::PackagesListConfig() = default;
+PackagesListConfig::~PackagesListConfig() = default;
+PackagesListConfig::PackagesListConfig(const PackagesListConfig&) = default;
+PackagesListConfig& PackagesListConfig::operator=(const PackagesListConfig&) = default;
+PackagesListConfig::PackagesListConfig(PackagesListConfig&&) noexcept = default;
+PackagesListConfig& PackagesListConfig::operator=(PackagesListConfig&&) = default;
 
-bool StatsdPullAtomConfig::operator==(const StatsdPullAtomConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && pull_atom_id_ == other.pull_atom_id_
-   && raw_pull_atom_id_ == other.raw_pull_atom_id_
-   && pull_frequency_ms_ == other.pull_frequency_ms_
-   && packages_ == other.packages_;
+bool PackagesListConfig::operator==(const PackagesListConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(package_name_filter_, other.package_name_filter_)
+   && ::protozero::internal::gen_helpers::EqualsField(only_write_on_cpu_use_every_ms_, other.only_write_on_cpu_use_every_ms_);
 }
 
-bool StatsdPullAtomConfig::ParseFromArray(const void* raw, size_t size) {
-  pull_atom_id_.clear();
-  raw_pull_atom_id_.clear();
-  packages_.clear();
+bool PackagesListConfig::ParseFromArray(const void* raw, size_t size) {
+  package_name_filter_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -23837,20 +21358,12 @@ bool StatsdPullAtomConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* pull_atom_id */:
-        pull_atom_id_.emplace_back();
-        field.get(&pull_atom_id_.back());
-        break;
-      case 2 /* raw_pull_atom_id */:
-        raw_pull_atom_id_.emplace_back();
-        field.get(&raw_pull_atom_id_.back());
-        break;
-      case 3 /* pull_frequency_ms */:
-        field.get(&pull_frequency_ms_);
+      case 1 /* package_name_filter */:
+        package_name_filter_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &package_name_filter_.back());
         break;
-      case 4 /* packages */:
-        packages_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &packages_.back());
+      case 2 /* only_write_on_cpu_use_every_ms */:
+        field.get(&only_write_on_cpu_use_every_ms_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -23860,64 +21373,72 @@ bool StatsdPullAtomConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string StatsdPullAtomConfig::SerializeAsString() const {
+std::string PackagesListConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> StatsdPullAtomConfig::SerializeAsArray() const {
+std::vector<uint8_t> PackagesListConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void StatsdPullAtomConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: pull_atom_id
-  for (auto& it : pull_atom_id_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, it, msg);
-  }
-
-  // Field 2: raw_pull_atom_id
-  for (auto& it : raw_pull_atom_id_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, it, msg);
-  }
-
-  // Field 3: pull_frequency_ms
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, pull_frequency_ms_, msg);
+void PackagesListConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: package_name_filter
+  for (auto& it : package_name_filter_) {
+    ::protozero::internal::gen_helpers::SerializeString(1, it, msg);
   }
 
-  // Field 4: packages
-  for (auto& it : packages_) {
-    ::protozero::internal::gen_helpers::SerializeString(4, it, msg);
+  // Field 2: only_write_on_cpu_use_every_ms
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, only_write_on_cpu_use_every_ms_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/pixel_modem_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/pixel_modem_config.gen.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-StatsdTracingConfig::StatsdTracingConfig() = default;
-StatsdTracingConfig::~StatsdTracingConfig() = default;
-StatsdTracingConfig::StatsdTracingConfig(const StatsdTracingConfig&) = default;
-StatsdTracingConfig& StatsdTracingConfig::operator=(const StatsdTracingConfig&) = default;
-StatsdTracingConfig::StatsdTracingConfig(StatsdTracingConfig&&) noexcept = default;
-StatsdTracingConfig& StatsdTracingConfig::operator=(StatsdTracingConfig&&) = default;
+PixelModemConfig::PixelModemConfig() = default;
+PixelModemConfig::~PixelModemConfig() = default;
+PixelModemConfig::PixelModemConfig(const PixelModemConfig&) = default;
+PixelModemConfig& PixelModemConfig::operator=(const PixelModemConfig&) = default;
+PixelModemConfig::PixelModemConfig(PixelModemConfig&&) noexcept = default;
+PixelModemConfig& PixelModemConfig::operator=(PixelModemConfig&&) = default;
 
-bool StatsdTracingConfig::operator==(const StatsdTracingConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && push_atom_id_ == other.push_atom_id_
-   && raw_push_atom_id_ == other.raw_push_atom_id_
-   && pull_config_ == other.pull_config_;
+bool PixelModemConfig::operator==(const PixelModemConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(event_group_, other.event_group_)
+   && ::protozero::internal::gen_helpers::EqualsField(pigweed_hash_allow_list_, other.pigweed_hash_allow_list_)
+   && ::protozero::internal::gen_helpers::EqualsField(pigweed_hash_deny_list_, other.pigweed_hash_deny_list_);
 }
 
-int StatsdTracingConfig::pull_config_size() const { return static_cast<int>(pull_config_.size()); }
-void StatsdTracingConfig::clear_pull_config() { pull_config_.clear(); }
-StatsdPullAtomConfig* StatsdTracingConfig::add_pull_config() { pull_config_.emplace_back(); return &pull_config_.back(); }
-bool StatsdTracingConfig::ParseFromArray(const void* raw, size_t size) {
-  push_atom_id_.clear();
-  raw_push_atom_id_.clear();
-  pull_config_.clear();
+bool PixelModemConfig::ParseFromArray(const void* raw, size_t size) {
+  pigweed_hash_allow_list_.clear();
+  pigweed_hash_deny_list_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -23927,17 +21448,16 @@ bool StatsdTracingConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* push_atom_id */:
-        push_atom_id_.emplace_back();
-        field.get(&push_atom_id_.back());
+      case 1 /* event_group */:
+        field.get(&event_group_);
         break;
-      case 2 /* raw_push_atom_id */:
-        raw_push_atom_id_.emplace_back();
-        field.get(&raw_push_atom_id_.back());
+      case 2 /* pigweed_hash_allow_list */:
+        pigweed_hash_allow_list_.emplace_back();
+        field.get(&pigweed_hash_allow_list_.back());
         break;
-      case 3 /* pull_config */:
-        pull_config_.emplace_back();
-        pull_config_.back().ParseFromArray(field.data(), field.size());
+      case 3 /* pigweed_hash_deny_list */:
+        pigweed_hash_deny_list_.emplace_back();
+        field.get(&pigweed_hash_deny_list_.back());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -23947,32 +21467,32 @@ bool StatsdTracingConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string StatsdTracingConfig::SerializeAsString() const {
+std::string PixelModemConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> StatsdTracingConfig::SerializeAsArray() const {
+std::vector<uint8_t> PixelModemConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void StatsdTracingConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: push_atom_id
-  for (auto& it : push_atom_id_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, it, msg);
+void PixelModemConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: event_group
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, event_group_, msg);
   }
 
-  // Field 2: raw_push_atom_id
-  for (auto& it : raw_push_atom_id_) {
+  // Field 2: pigweed_hash_allow_list
+  for (auto& it : pigweed_hash_allow_list_) {
     ::protozero::internal::gen_helpers::SerializeVarInt(2, it, msg);
   }
 
-  // Field 3: pull_config
-  for (auto& it : pull_config_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(3));
+  // Field 3: pigweed_hash_deny_list
+  for (auto& it : pigweed_hash_deny_list_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, it, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -23984,158 +21504,7 @@ void StatsdTracingConfig::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/sys_stats/sys_stats_config.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/sys_stats/sys_stats_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYS_STATS_SYS_STATS_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYS_STATS_SYS_STATS_CONFIG_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class SysStatsConfig;
-enum SysStatsConfig_StatCounters : int;
-enum MeminfoCounters : int;
-enum VmstatCounters : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum SysStatsConfig_StatCounters : int {
-  SysStatsConfig_StatCounters_STAT_UNSPECIFIED = 0,
-  SysStatsConfig_StatCounters_STAT_CPU_TIMES = 1,
-  SysStatsConfig_StatCounters_STAT_IRQ_COUNTS = 2,
-  SysStatsConfig_StatCounters_STAT_SOFTIRQ_COUNTS = 3,
-  SysStatsConfig_StatCounters_STAT_FORK_COUNT = 4,
-};
-
-class PERFETTO_EXPORT_COMPONENT SysStatsConfig : public ::protozero::CppMessageObj {
- public:
-  using StatCounters = SysStatsConfig_StatCounters;
-  static constexpr auto STAT_UNSPECIFIED = SysStatsConfig_StatCounters_STAT_UNSPECIFIED;
-  static constexpr auto STAT_CPU_TIMES = SysStatsConfig_StatCounters_STAT_CPU_TIMES;
-  static constexpr auto STAT_IRQ_COUNTS = SysStatsConfig_StatCounters_STAT_IRQ_COUNTS;
-  static constexpr auto STAT_SOFTIRQ_COUNTS = SysStatsConfig_StatCounters_STAT_SOFTIRQ_COUNTS;
-  static constexpr auto STAT_FORK_COUNT = SysStatsConfig_StatCounters_STAT_FORK_COUNT;
-  static constexpr auto StatCounters_MIN = SysStatsConfig_StatCounters_STAT_UNSPECIFIED;
-  static constexpr auto StatCounters_MAX = SysStatsConfig_StatCounters_STAT_FORK_COUNT;
-  enum FieldNumbers {
-    kMeminfoPeriodMsFieldNumber = 1,
-    kMeminfoCountersFieldNumber = 2,
-    kVmstatPeriodMsFieldNumber = 3,
-    kVmstatCountersFieldNumber = 4,
-    kStatPeriodMsFieldNumber = 5,
-    kStatCountersFieldNumber = 6,
-    kDevfreqPeriodMsFieldNumber = 7,
-    kCpufreqPeriodMsFieldNumber = 8,
-    kBuddyinfoPeriodMsFieldNumber = 9,
-    kDiskstatPeriodMsFieldNumber = 10,
-  };
-
-  SysStatsConfig();
-  ~SysStatsConfig() override;
-  SysStatsConfig(SysStatsConfig&&) noexcept;
-  SysStatsConfig& operator=(SysStatsConfig&&);
-  SysStatsConfig(const SysStatsConfig&);
-  SysStatsConfig& operator=(const SysStatsConfig&);
-  bool operator==(const SysStatsConfig&) const;
-  bool operator!=(const SysStatsConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_meminfo_period_ms() const { return _has_field_[1]; }
-  uint32_t meminfo_period_ms() const { return meminfo_period_ms_; }
-  void set_meminfo_period_ms(uint32_t value) { meminfo_period_ms_ = value; _has_field_.set(1); }
-
-  const std::vector<MeminfoCounters>& meminfo_counters() const { return meminfo_counters_; }
-  std::vector<MeminfoCounters>* mutable_meminfo_counters() { return &meminfo_counters_; }
-  int meminfo_counters_size() const { return static_cast<int>(meminfo_counters_.size()); }
-  void clear_meminfo_counters() { meminfo_counters_.clear(); }
-  void add_meminfo_counters(MeminfoCounters value) { meminfo_counters_.emplace_back(value); }
-  MeminfoCounters* add_meminfo_counters() { meminfo_counters_.emplace_back(); return &meminfo_counters_.back(); }
-
-  bool has_vmstat_period_ms() const { return _has_field_[3]; }
-  uint32_t vmstat_period_ms() const { return vmstat_period_ms_; }
-  void set_vmstat_period_ms(uint32_t value) { vmstat_period_ms_ = value; _has_field_.set(3); }
-
-  const std::vector<VmstatCounters>& vmstat_counters() const { return vmstat_counters_; }
-  std::vector<VmstatCounters>* mutable_vmstat_counters() { return &vmstat_counters_; }
-  int vmstat_counters_size() const { return static_cast<int>(vmstat_counters_.size()); }
-  void clear_vmstat_counters() { vmstat_counters_.clear(); }
-  void add_vmstat_counters(VmstatCounters value) { vmstat_counters_.emplace_back(value); }
-  VmstatCounters* add_vmstat_counters() { vmstat_counters_.emplace_back(); return &vmstat_counters_.back(); }
-
-  bool has_stat_period_ms() const { return _has_field_[5]; }
-  uint32_t stat_period_ms() const { return stat_period_ms_; }
-  void set_stat_period_ms(uint32_t value) { stat_period_ms_ = value; _has_field_.set(5); }
-
-  const std::vector<SysStatsConfig_StatCounters>& stat_counters() const { return stat_counters_; }
-  std::vector<SysStatsConfig_StatCounters>* mutable_stat_counters() { return &stat_counters_; }
-  int stat_counters_size() const { return static_cast<int>(stat_counters_.size()); }
-  void clear_stat_counters() { stat_counters_.clear(); }
-  void add_stat_counters(SysStatsConfig_StatCounters value) { stat_counters_.emplace_back(value); }
-  SysStatsConfig_StatCounters* add_stat_counters() { stat_counters_.emplace_back(); return &stat_counters_.back(); }
-
-  bool has_devfreq_period_ms() const { return _has_field_[7]; }
-  uint32_t devfreq_period_ms() const { return devfreq_period_ms_; }
-  void set_devfreq_period_ms(uint32_t value) { devfreq_period_ms_ = value; _has_field_.set(7); }
-
-  bool has_cpufreq_period_ms() const { return _has_field_[8]; }
-  uint32_t cpufreq_period_ms() const { return cpufreq_period_ms_; }
-  void set_cpufreq_period_ms(uint32_t value) { cpufreq_period_ms_ = value; _has_field_.set(8); }
-
-  bool has_buddyinfo_period_ms() const { return _has_field_[9]; }
-  uint32_t buddyinfo_period_ms() const { return buddyinfo_period_ms_; }
-  void set_buddyinfo_period_ms(uint32_t value) { buddyinfo_period_ms_ = value; _has_field_.set(9); }
-
-  bool has_diskstat_period_ms() const { return _has_field_[10]; }
-  uint32_t diskstat_period_ms() const { return diskstat_period_ms_; }
-  void set_diskstat_period_ms(uint32_t value) { diskstat_period_ms_ = value; _has_field_.set(10); }
-
- private:
-  uint32_t meminfo_period_ms_{};
-  std::vector<MeminfoCounters> meminfo_counters_;
-  uint32_t vmstat_period_ms_{};
-  std::vector<VmstatCounters> vmstat_counters_;
-  uint32_t stat_period_ms_{};
-  std::vector<SysStatsConfig_StatCounters> stat_counters_;
-  uint32_t devfreq_period_ms_{};
-  uint32_t cpufreq_period_ms_{};
-  uint32_t buddyinfo_period_ms_{};
-  uint32_t diskstat_period_ms_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<11> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYS_STATS_SYS_STATS_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/protolog_config.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -24146,38 +21515,28 @@ class PERFETTO_EXPORT_COMPONENT SysStatsConfig : public ::protozero::CppMessageO
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/sys_stats/sys_stats_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/common/sys_stats_counters.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/protolog_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/protolog_common.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-SysStatsConfig::SysStatsConfig() = default;
-SysStatsConfig::~SysStatsConfig() = default;
-SysStatsConfig::SysStatsConfig(const SysStatsConfig&) = default;
-SysStatsConfig& SysStatsConfig::operator=(const SysStatsConfig&) = default;
-SysStatsConfig::SysStatsConfig(SysStatsConfig&&) noexcept = default;
-SysStatsConfig& SysStatsConfig::operator=(SysStatsConfig&&) = default;
+ProtoLogGroup::ProtoLogGroup() = default;
+ProtoLogGroup::~ProtoLogGroup() = default;
+ProtoLogGroup::ProtoLogGroup(const ProtoLogGroup&) = default;
+ProtoLogGroup& ProtoLogGroup::operator=(const ProtoLogGroup&) = default;
+ProtoLogGroup::ProtoLogGroup(ProtoLogGroup&&) noexcept = default;
+ProtoLogGroup& ProtoLogGroup::operator=(ProtoLogGroup&&) = default;
 
-bool SysStatsConfig::operator==(const SysStatsConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && meminfo_period_ms_ == other.meminfo_period_ms_
-   && meminfo_counters_ == other.meminfo_counters_
-   && vmstat_period_ms_ == other.vmstat_period_ms_
-   && vmstat_counters_ == other.vmstat_counters_
-   && stat_period_ms_ == other.stat_period_ms_
-   && stat_counters_ == other.stat_counters_
-   && devfreq_period_ms_ == other.devfreq_period_ms_
-   && cpufreq_period_ms_ == other.cpufreq_period_ms_
-   && buddyinfo_period_ms_ == other.buddyinfo_period_ms_
-   && diskstat_period_ms_ == other.diskstat_period_ms_;
+bool ProtoLogGroup::operator==(const ProtoLogGroup& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(group_name_, other.group_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(log_from_, other.log_from_)
+   && ::protozero::internal::gen_helpers::EqualsField(collect_stacktrace_, other.collect_stacktrace_);
 }
 
-bool SysStatsConfig::ParseFromArray(const void* raw, size_t size) {
-  meminfo_counters_.clear();
-  vmstat_counters_.clear();
-  stat_counters_.clear();
+bool ProtoLogGroup::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -24187,38 +21546,14 @@ bool SysStatsConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* meminfo_period_ms */:
-        field.get(&meminfo_period_ms_);
-        break;
-      case 2 /* meminfo_counters */:
-        meminfo_counters_.emplace_back();
-        field.get(&meminfo_counters_.back());
-        break;
-      case 3 /* vmstat_period_ms */:
-        field.get(&vmstat_period_ms_);
-        break;
-      case 4 /* vmstat_counters */:
-        vmstat_counters_.emplace_back();
-        field.get(&vmstat_counters_.back());
-        break;
-      case 5 /* stat_period_ms */:
-        field.get(&stat_period_ms_);
-        break;
-      case 6 /* stat_counters */:
-        stat_counters_.emplace_back();
-        field.get(&stat_counters_.back());
+      case 1 /* group_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &group_name_);
         break;
-      case 7 /* devfreq_period_ms */:
-        field.get(&devfreq_period_ms_);
-        break;
-      case 8 /* cpufreq_period_ms */:
-        field.get(&cpufreq_period_ms_);
-        break;
-      case 9 /* buddyinfo_period_ms */:
-        field.get(&buddyinfo_period_ms_);
+      case 2 /* log_from */:
+        field.get(&log_from_);
         break;
-      case 10 /* diskstat_period_ms */:
-        field.get(&diskstat_period_ms_);
+      case 3 /* collect_stacktrace */:
+        field.get(&collect_stacktrace_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -24228,67 +21563,110 @@ bool SysStatsConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string SysStatsConfig::SerializeAsString() const {
+std::string ProtoLogGroup::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> SysStatsConfig::SerializeAsArray() const {
+std::vector<uint8_t> ProtoLogGroup::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void SysStatsConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: meminfo_period_ms
+void ProtoLogGroup::Serialize(::protozero::Message* msg) const {
+  // Field 1: group_name
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, meminfo_period_ms_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(1, group_name_, msg);
   }
 
-  // Field 2: meminfo_counters
-  for (auto& it : meminfo_counters_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, it, msg);
+  // Field 2: log_from
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, log_from_, msg);
   }
 
-  // Field 3: vmstat_period_ms
+  // Field 3: collect_stacktrace
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, vmstat_period_ms_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, collect_stacktrace_, msg);
   }
 
-  // Field 4: vmstat_counters
-  for (auto& it : vmstat_counters_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, it, msg);
-  }
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  // Field 5: stat_period_ms
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(5, stat_period_ms_, msg);
-  }
 
-  // Field 6: stat_counters
-  for (auto& it : stat_counters_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(6, it, msg);
-  }
+ProtoLogConfig::ProtoLogConfig() = default;
+ProtoLogConfig::~ProtoLogConfig() = default;
+ProtoLogConfig::ProtoLogConfig(const ProtoLogConfig&) = default;
+ProtoLogConfig& ProtoLogConfig::operator=(const ProtoLogConfig&) = default;
+ProtoLogConfig::ProtoLogConfig(ProtoLogConfig&&) noexcept = default;
+ProtoLogConfig& ProtoLogConfig::operator=(ProtoLogConfig&&) = default;
 
-  // Field 7: devfreq_period_ms
-  if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(7, devfreq_period_ms_, msg);
+bool ProtoLogConfig::operator==(const ProtoLogConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(group_overrides_, other.group_overrides_)
+   && ::protozero::internal::gen_helpers::EqualsField(tracing_mode_, other.tracing_mode_)
+   && ::protozero::internal::gen_helpers::EqualsField(default_log_from_level_, other.default_log_from_level_);
+}
+
+int ProtoLogConfig::group_overrides_size() const { return static_cast<int>(group_overrides_.size()); }
+void ProtoLogConfig::clear_group_overrides() { group_overrides_.clear(); }
+ProtoLogGroup* ProtoLogConfig::add_group_overrides() { group_overrides_.emplace_back(); return &group_overrides_.back(); }
+bool ProtoLogConfig::ParseFromArray(const void* raw, size_t size) {
+  group_overrides_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* group_overrides */:
+        group_overrides_.emplace_back();
+        group_overrides_.back().ParseFromArray(field.data(), field.size());
+        break;
+      case 2 /* tracing_mode */:
+        field.get(&tracing_mode_);
+        break;
+      case 3 /* default_log_from_level */:
+        field.get(&default_log_from_level_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
   }
+  return !packed_error && !dec.bytes_left();
+}
 
-  // Field 8: cpufreq_period_ms
-  if (_has_field_[8]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(8, cpufreq_period_ms_, msg);
+std::string ProtoLogConfig::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> ProtoLogConfig::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void ProtoLogConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: group_overrides
+  for (auto& it : group_overrides_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
   }
 
-  // Field 9: buddyinfo_period_ms
-  if (_has_field_[9]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(9, buddyinfo_period_ms_, msg);
+  // Field 2: tracing_mode
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, tracing_mode_, msg);
   }
 
-  // Field 10: diskstat_period_ms
-  if (_has_field_[10]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(10, diskstat_period_ms_, msg);
+  // Field 3: default_log_from_level
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, default_log_from_level_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -24300,71 +21678,7 @@ void SysStatsConfig::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/system_info/system_info.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/system_info/system_info.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYSTEM_INFO_SYSTEM_INFO_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYSTEM_INFO_SYSTEM_INFO_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class SystemInfoConfig;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT SystemInfoConfig : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  SystemInfoConfig();
-  ~SystemInfoConfig() override;
-  SystemInfoConfig(SystemInfoConfig&&) noexcept;
-  SystemInfoConfig& operator=(SystemInfoConfig&&);
-  SystemInfoConfig(const SystemInfoConfig&);
-  SystemInfoConfig& operator=(const SystemInfoConfig&);
-  bool operator==(const SystemInfoConfig&) const;
-  bool operator!=(const SystemInfoConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYSTEM_INFO_SYSTEM_INFO_PROTO_CPP_H_
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/surfaceflinger_layers_config.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -24375,24 +21689,27 @@ class PERFETTO_EXPORT_COMPONENT SystemInfoConfig : public ::protozero::CppMessag
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/system_info/system_info.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/surfaceflinger_layers_config.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-SystemInfoConfig::SystemInfoConfig() = default;
-SystemInfoConfig::~SystemInfoConfig() = default;
-SystemInfoConfig::SystemInfoConfig(const SystemInfoConfig&) = default;
-SystemInfoConfig& SystemInfoConfig::operator=(const SystemInfoConfig&) = default;
-SystemInfoConfig::SystemInfoConfig(SystemInfoConfig&&) noexcept = default;
-SystemInfoConfig& SystemInfoConfig::operator=(SystemInfoConfig&&) = default;
+SurfaceFlingerLayersConfig::SurfaceFlingerLayersConfig() = default;
+SurfaceFlingerLayersConfig::~SurfaceFlingerLayersConfig() = default;
+SurfaceFlingerLayersConfig::SurfaceFlingerLayersConfig(const SurfaceFlingerLayersConfig&) = default;
+SurfaceFlingerLayersConfig& SurfaceFlingerLayersConfig::operator=(const SurfaceFlingerLayersConfig&) = default;
+SurfaceFlingerLayersConfig::SurfaceFlingerLayersConfig(SurfaceFlingerLayersConfig&&) noexcept = default;
+SurfaceFlingerLayersConfig& SurfaceFlingerLayersConfig::operator=(SurfaceFlingerLayersConfig&&) = default;
 
-bool SystemInfoConfig::operator==(const SystemInfoConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+bool SurfaceFlingerLayersConfig::operator==(const SurfaceFlingerLayersConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(mode_, other.mode_)
+   && ::protozero::internal::gen_helpers::EqualsField(trace_flags_, other.trace_flags_);
 }
 
-bool SystemInfoConfig::ParseFromArray(const void* raw, size_t size) {
+bool SurfaceFlingerLayersConfig::ParseFromArray(const void* raw, size_t size) {
+  trace_flags_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -24402,6 +21719,13 @@ bool SystemInfoConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
+      case 1 /* mode */:
+        field.get(&mode_);
+        break;
+      case 2 /* trace_flags */:
+        trace_flags_.emplace_back();
+        field.get(&trace_flags_.back());
+        break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
         break;
@@ -24410,19 +21734,29 @@ bool SystemInfoConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string SystemInfoConfig::SerializeAsString() const {
+std::string SurfaceFlingerLayersConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> SystemInfoConfig::SerializeAsArray() const {
+std::vector<uint8_t> SurfaceFlingerLayersConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void SystemInfoConfig::Serialize(::protozero::Message* msg) const {
+void SurfaceFlingerLayersConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: mode
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, mode_, msg);
+  }
+
+  // Field 2: trace_flags
+  for (auto& it : trace_flags_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, it, msg);
+  }
+
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
@@ -24432,7 +21766,7 @@ void SystemInfoConfig::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/track_event/track_event_config.gen.cc
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/surfaceflinger_transactions_config.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -24443,37 +21777,25 @@ void SystemInfoConfig::Serialize(::protozero::Message* msg) const {
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/track_event/track_event_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/surfaceflinger_transactions_config.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-TrackEventConfig::TrackEventConfig() = default;
-TrackEventConfig::~TrackEventConfig() = default;
-TrackEventConfig::TrackEventConfig(const TrackEventConfig&) = default;
-TrackEventConfig& TrackEventConfig::operator=(const TrackEventConfig&) = default;
-TrackEventConfig::TrackEventConfig(TrackEventConfig&&) noexcept = default;
-TrackEventConfig& TrackEventConfig::operator=(TrackEventConfig&&) = default;
+SurfaceFlingerTransactionsConfig::SurfaceFlingerTransactionsConfig() = default;
+SurfaceFlingerTransactionsConfig::~SurfaceFlingerTransactionsConfig() = default;
+SurfaceFlingerTransactionsConfig::SurfaceFlingerTransactionsConfig(const SurfaceFlingerTransactionsConfig&) = default;
+SurfaceFlingerTransactionsConfig& SurfaceFlingerTransactionsConfig::operator=(const SurfaceFlingerTransactionsConfig&) = default;
+SurfaceFlingerTransactionsConfig::SurfaceFlingerTransactionsConfig(SurfaceFlingerTransactionsConfig&&) noexcept = default;
+SurfaceFlingerTransactionsConfig& SurfaceFlingerTransactionsConfig::operator=(SurfaceFlingerTransactionsConfig&&) = default;
 
-bool TrackEventConfig::operator==(const TrackEventConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && disabled_categories_ == other.disabled_categories_
-   && enabled_categories_ == other.enabled_categories_
-   && disabled_tags_ == other.disabled_tags_
-   && enabled_tags_ == other.enabled_tags_
-   && disable_incremental_timestamps_ == other.disable_incremental_timestamps_
-   && timestamp_unit_multiplier_ == other.timestamp_unit_multiplier_
-   && filter_debug_annotations_ == other.filter_debug_annotations_
-   && enable_thread_time_sampling_ == other.enable_thread_time_sampling_
-   && filter_dynamic_event_names_ == other.filter_dynamic_event_names_;
+bool SurfaceFlingerTransactionsConfig::operator==(const SurfaceFlingerTransactionsConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(mode_, other.mode_);
 }
 
-bool TrackEventConfig::ParseFromArray(const void* raw, size_t size) {
-  disabled_categories_.clear();
-  enabled_categories_.clear();
-  disabled_tags_.clear();
-  enabled_tags_.clear();
+bool SurfaceFlingerTransactionsConfig::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -24483,101 +21805,33 @@ bool TrackEventConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* disabled_categories */:
-        disabled_categories_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &disabled_categories_.back());
+      case 1 /* mode */:
+        field.get(&mode_);
         break;
-      case 2 /* enabled_categories */:
-        enabled_categories_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &enabled_categories_.back());
-        break;
-      case 3 /* disabled_tags */:
-        disabled_tags_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &disabled_tags_.back());
-        break;
-      case 4 /* enabled_tags */:
-        enabled_tags_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &enabled_tags_.back());
-        break;
-      case 5 /* disable_incremental_timestamps */:
-        field.get(&disable_incremental_timestamps_);
-        break;
-      case 6 /* timestamp_unit_multiplier */:
-        field.get(&timestamp_unit_multiplier_);
-        break;
-      case 7 /* filter_debug_annotations */:
-        field.get(&filter_debug_annotations_);
-        break;
-      case 8 /* enable_thread_time_sampling */:
-        field.get(&enable_thread_time_sampling_);
-        break;
-      case 9 /* filter_dynamic_event_names */:
-        field.get(&filter_dynamic_event_names_);
-        break;
-      default:
-        field.SerializeAndAppendTo(&unknown_fields_);
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
         break;
     }
   }
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TrackEventConfig::SerializeAsString() const {
+std::string SurfaceFlingerTransactionsConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TrackEventConfig::SerializeAsArray() const {
+std::vector<uint8_t> SurfaceFlingerTransactionsConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TrackEventConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: disabled_categories
-  for (auto& it : disabled_categories_) {
-    ::protozero::internal::gen_helpers::SerializeString(1, it, msg);
-  }
-
-  // Field 2: enabled_categories
-  for (auto& it : enabled_categories_) {
-    ::protozero::internal::gen_helpers::SerializeString(2, it, msg);
-  }
-
-  // Field 3: disabled_tags
-  for (auto& it : disabled_tags_) {
-    ::protozero::internal::gen_helpers::SerializeString(3, it, msg);
-  }
-
-  // Field 4: enabled_tags
-  for (auto& it : enabled_tags_) {
-    ::protozero::internal::gen_helpers::SerializeString(4, it, msg);
-  }
-
-  // Field 5: disable_incremental_timestamps
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, disable_incremental_timestamps_, msg);
-  }
-
-  // Field 6: timestamp_unit_multiplier
-  if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(6, timestamp_unit_multiplier_, msg);
-  }
-
-  // Field 7: filter_debug_annotations
-  if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(7, filter_debug_annotations_, msg);
-  }
-
-  // Field 8: enable_thread_time_sampling
-  if (_has_field_[8]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(8, enable_thread_time_sampling_, msg);
-  }
-
-  // Field 9: filter_dynamic_event_names
-  if (_has_field_[9]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(9, filter_dynamic_event_names_, msg);
+void SurfaceFlingerTransactionsConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: mode
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, mode_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -24589,113 +21843,86 @@ void TrackEventConfig::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/chrome/chrome_config.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/chrome/chrome_config.gen.h
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/user_list_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_CHROME_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_CHROME_CONFIG_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeConfig;
-enum ChromeConfig_ClientPriority : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/user_list_config.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
-enum ChromeConfig_ClientPriority : int {
-  ChromeConfig_ClientPriority_UNKNOWN = 0,
-  ChromeConfig_ClientPriority_BACKGROUND = 1,
-  ChromeConfig_ClientPriority_USER_INITIATED = 2,
-};
-
-class PERFETTO_EXPORT_COMPONENT ChromeConfig : public ::protozero::CppMessageObj {
- public:
-  using ClientPriority = ChromeConfig_ClientPriority;
-  static constexpr auto UNKNOWN = ChromeConfig_ClientPriority_UNKNOWN;
-  static constexpr auto BACKGROUND = ChromeConfig_ClientPriority_BACKGROUND;
-  static constexpr auto USER_INITIATED = ChromeConfig_ClientPriority_USER_INITIATED;
-  static constexpr auto ClientPriority_MIN = ChromeConfig_ClientPriority_UNKNOWN;
-  static constexpr auto ClientPriority_MAX = ChromeConfig_ClientPriority_USER_INITIATED;
-  enum FieldNumbers {
-    kTraceConfigFieldNumber = 1,
-    kPrivacyFilteringEnabledFieldNumber = 2,
-    kConvertToLegacyJsonFieldNumber = 3,
-    kClientPriorityFieldNumber = 4,
-    kJsonAgentLabelFilterFieldNumber = 5,
-  };
-
-  ChromeConfig();
-  ~ChromeConfig() override;
-  ChromeConfig(ChromeConfig&&) noexcept;
-  ChromeConfig& operator=(ChromeConfig&&);
-  ChromeConfig(const ChromeConfig&);
-  ChromeConfig& operator=(const ChromeConfig&);
-  bool operator==(const ChromeConfig&) const;
-  bool operator!=(const ChromeConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
 
-  bool has_trace_config() const { return _has_field_[1]; }
-  const std::string& trace_config() const { return trace_config_; }
-  void set_trace_config(const std::string& value) { trace_config_ = value; _has_field_.set(1); }
+AndroidUserListConfig::AndroidUserListConfig() = default;
+AndroidUserListConfig::~AndroidUserListConfig() = default;
+AndroidUserListConfig::AndroidUserListConfig(const AndroidUserListConfig&) = default;
+AndroidUserListConfig& AndroidUserListConfig::operator=(const AndroidUserListConfig&) = default;
+AndroidUserListConfig::AndroidUserListConfig(AndroidUserListConfig&&) noexcept = default;
+AndroidUserListConfig& AndroidUserListConfig::operator=(AndroidUserListConfig&&) = default;
 
-  bool has_privacy_filtering_enabled() const { return _has_field_[2]; }
-  bool privacy_filtering_enabled() const { return privacy_filtering_enabled_; }
-  void set_privacy_filtering_enabled(bool value) { privacy_filtering_enabled_ = value; _has_field_.set(2); }
+bool AndroidUserListConfig::operator==(const AndroidUserListConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(user_type_filter_, other.user_type_filter_);
+}
 
-  bool has_convert_to_legacy_json() const { return _has_field_[3]; }
-  bool convert_to_legacy_json() const { return convert_to_legacy_json_; }
-  void set_convert_to_legacy_json(bool value) { convert_to_legacy_json_ = value; _has_field_.set(3); }
+bool AndroidUserListConfig::ParseFromArray(const void* raw, size_t size) {
+  user_type_filter_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  bool has_client_priority() const { return _has_field_[4]; }
-  ChromeConfig_ClientPriority client_priority() const { return client_priority_; }
-  void set_client_priority(ChromeConfig_ClientPriority value) { client_priority_ = value; _has_field_.set(4); }
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* user_type_filter */:
+        user_type_filter_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &user_type_filter_.back());
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-  bool has_json_agent_label_filter() const { return _has_field_[5]; }
-  const std::string& json_agent_label_filter() const { return json_agent_label_filter_; }
-  void set_json_agent_label_filter(const std::string& value) { json_agent_label_filter_ = value; _has_field_.set(5); }
+std::string AndroidUserListConfig::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
- private:
-  std::string trace_config_{};
-  bool privacy_filtering_enabled_{};
-  bool convert_to_legacy_json_{};
-  ChromeConfig_ClientPriority client_priority_{};
-  std::string json_agent_label_filter_{};
+std::vector<uint8_t> AndroidUserListConfig::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+void AndroidUserListConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: user_type_filter
+  for (auto& it : user_type_filter_) {
+    ::protozero::internal::gen_helpers::SerializeString(1, it, msg);
+  }
 
-  std::bitset<6> _has_field_{};
-};
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_CHROME_CONFIG_PROTO_CPP_H_
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/windowmanager_config.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -24706,29 +21933,26 @@ class PERFETTO_EXPORT_COMPONENT ChromeConfig : public ::protozero::CppMessageObj
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/chrome_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/windowmanager_config.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-ChromeConfig::ChromeConfig() = default;
-ChromeConfig::~ChromeConfig() = default;
-ChromeConfig::ChromeConfig(const ChromeConfig&) = default;
-ChromeConfig& ChromeConfig::operator=(const ChromeConfig&) = default;
-ChromeConfig::ChromeConfig(ChromeConfig&&) noexcept = default;
-ChromeConfig& ChromeConfig::operator=(ChromeConfig&&) = default;
+WindowManagerConfig::WindowManagerConfig() = default;
+WindowManagerConfig::~WindowManagerConfig() = default;
+WindowManagerConfig::WindowManagerConfig(const WindowManagerConfig&) = default;
+WindowManagerConfig& WindowManagerConfig::operator=(const WindowManagerConfig&) = default;
+WindowManagerConfig::WindowManagerConfig(WindowManagerConfig&&) noexcept = default;
+WindowManagerConfig& WindowManagerConfig::operator=(WindowManagerConfig&&) = default;
 
-bool ChromeConfig::operator==(const ChromeConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && trace_config_ == other.trace_config_
-   && privacy_filtering_enabled_ == other.privacy_filtering_enabled_
-   && convert_to_legacy_json_ == other.convert_to_legacy_json_
-   && client_priority_ == other.client_priority_
-   && json_agent_label_filter_ == other.json_agent_label_filter_;
+bool WindowManagerConfig::operator==(const WindowManagerConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(log_frequency_, other.log_frequency_)
+   && ::protozero::internal::gen_helpers::EqualsField(log_level_, other.log_level_);
 }
 
-bool ChromeConfig::ParseFromArray(const void* raw, size_t size) {
+bool WindowManagerConfig::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -24738,20 +21962,11 @@ bool ChromeConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* trace_config */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &trace_config_);
-        break;
-      case 2 /* privacy_filtering_enabled */:
-        field.get(&privacy_filtering_enabled_);
-        break;
-      case 3 /* convert_to_legacy_json */:
-        field.get(&convert_to_legacy_json_);
+      case 1 /* log_frequency */:
+        field.get(&log_frequency_);
         break;
-      case 4 /* client_priority */:
-        field.get(&client_priority_);
-        break;
-      case 5 /* json_agent_label_filter */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &json_agent_label_filter_);
+      case 2 /* log_level */:
+        field.get(&log_level_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -24761,42 +21976,27 @@ bool ChromeConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ChromeConfig::SerializeAsString() const {
+std::string WindowManagerConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ChromeConfig::SerializeAsArray() const {
+std::vector<uint8_t> WindowManagerConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ChromeConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: trace_config
+void WindowManagerConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: log_frequency
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeString(1, trace_config_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, log_frequency_, msg);
   }
 
-  // Field 2: privacy_filtering_enabled
+  // Field 2: log_level
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, privacy_filtering_enabled_, msg);
-  }
-
-  // Field 3: convert_to_legacy_json
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, convert_to_legacy_json_, msg);
-  }
-
-  // Field 4: client_priority
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, client_priority_, msg);
-  }
-
-  // Field 5: json_agent_label_filter
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeString(5, json_agent_label_filter_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, log_level_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -24808,298 +22008,84 @@ void ChromeConfig::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/data_source_config.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/test_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TEST_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TEST_CONFIG_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class TestConfig;
-class TestConfig_DummyFields;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT TestConfig : public ::protozero::CppMessageObj {
- public:
-  using DummyFields = TestConfig_DummyFields;
-  enum FieldNumbers {
-    kMessageCountFieldNumber = 1,
-    kMaxMessagesPerSecondFieldNumber = 2,
-    kSeedFieldNumber = 3,
-    kMessageSizeFieldNumber = 4,
-    kSendBatchOnRegisterFieldNumber = 5,
-    kDummyFieldsFieldNumber = 6,
-  };
-
-  TestConfig();
-  ~TestConfig() override;
-  TestConfig(TestConfig&&) noexcept;
-  TestConfig& operator=(TestConfig&&);
-  TestConfig(const TestConfig&);
-  TestConfig& operator=(const TestConfig&);
-  bool operator==(const TestConfig&) const;
-  bool operator!=(const TestConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_message_count() const { return _has_field_[1]; }
-  uint32_t message_count() const { return message_count_; }
-  void set_message_count(uint32_t value) { message_count_ = value; _has_field_.set(1); }
-
-  bool has_max_messages_per_second() const { return _has_field_[2]; }
-  uint32_t max_messages_per_second() const { return max_messages_per_second_; }
-  void set_max_messages_per_second(uint32_t value) { max_messages_per_second_ = value; _has_field_.set(2); }
-
-  bool has_seed() const { return _has_field_[3]; }
-  uint32_t seed() const { return seed_; }
-  void set_seed(uint32_t value) { seed_ = value; _has_field_.set(3); }
-
-  bool has_message_size() const { return _has_field_[4]; }
-  uint32_t message_size() const { return message_size_; }
-  void set_message_size(uint32_t value) { message_size_ = value; _has_field_.set(4); }
-
-  bool has_send_batch_on_register() const { return _has_field_[5]; }
-  bool send_batch_on_register() const { return send_batch_on_register_; }
-  void set_send_batch_on_register(bool value) { send_batch_on_register_ = value; _has_field_.set(5); }
-
-  bool has_dummy_fields() const { return _has_field_[6]; }
-  const TestConfig_DummyFields& dummy_fields() const { return *dummy_fields_; }
-  TestConfig_DummyFields* mutable_dummy_fields() { _has_field_.set(6); return dummy_fields_.get(); }
-
- private:
-  uint32_t message_count_{};
-  uint32_t max_messages_per_second_{};
-  uint32_t seed_{};
-  uint32_t message_size_{};
-  bool send_batch_on_register_{};
-  ::protozero::CopyablePtr<TestConfig_DummyFields> dummy_fields_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<7> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT TestConfig_DummyFields : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kFieldUint32FieldNumber = 1,
-    kFieldInt32FieldNumber = 2,
-    kFieldUint64FieldNumber = 3,
-    kFieldInt64FieldNumber = 4,
-    kFieldFixed64FieldNumber = 5,
-    kFieldSfixed64FieldNumber = 6,
-    kFieldFixed32FieldNumber = 7,
-    kFieldSfixed32FieldNumber = 8,
-    kFieldDoubleFieldNumber = 9,
-    kFieldFloatFieldNumber = 10,
-    kFieldSint64FieldNumber = 11,
-    kFieldSint32FieldNumber = 12,
-    kFieldStringFieldNumber = 13,
-    kFieldBytesFieldNumber = 14,
-  };
-
-  TestConfig_DummyFields();
-  ~TestConfig_DummyFields() override;
-  TestConfig_DummyFields(TestConfig_DummyFields&&) noexcept;
-  TestConfig_DummyFields& operator=(TestConfig_DummyFields&&);
-  TestConfig_DummyFields(const TestConfig_DummyFields&);
-  TestConfig_DummyFields& operator=(const TestConfig_DummyFields&);
-  bool operator==(const TestConfig_DummyFields&) const;
-  bool operator!=(const TestConfig_DummyFields& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_field_uint32() const { return _has_field_[1]; }
-  uint32_t field_uint32() const { return field_uint32_; }
-  void set_field_uint32(uint32_t value) { field_uint32_ = value; _has_field_.set(1); }
-
-  bool has_field_int32() const { return _has_field_[2]; }
-  int32_t field_int32() const { return field_int32_; }
-  void set_field_int32(int32_t value) { field_int32_ = value; _has_field_.set(2); }
-
-  bool has_field_uint64() const { return _has_field_[3]; }
-  uint64_t field_uint64() const { return field_uint64_; }
-  void set_field_uint64(uint64_t value) { field_uint64_ = value; _has_field_.set(3); }
-
-  bool has_field_int64() const { return _has_field_[4]; }
-  int64_t field_int64() const { return field_int64_; }
-  void set_field_int64(int64_t value) { field_int64_ = value; _has_field_.set(4); }
-
-  bool has_field_fixed64() const { return _has_field_[5]; }
-  uint64_t field_fixed64() const { return field_fixed64_; }
-  void set_field_fixed64(uint64_t value) { field_fixed64_ = value; _has_field_.set(5); }
-
-  bool has_field_sfixed64() const { return _has_field_[6]; }
-  int64_t field_sfixed64() const { return field_sfixed64_; }
-  void set_field_sfixed64(int64_t value) { field_sfixed64_ = value; _has_field_.set(6); }
-
-  bool has_field_fixed32() const { return _has_field_[7]; }
-  uint32_t field_fixed32() const { return field_fixed32_; }
-  void set_field_fixed32(uint32_t value) { field_fixed32_ = value; _has_field_.set(7); }
-
-  bool has_field_sfixed32() const { return _has_field_[8]; }
-  int32_t field_sfixed32() const { return field_sfixed32_; }
-  void set_field_sfixed32(int32_t value) { field_sfixed32_ = value; _has_field_.set(8); }
-
-  bool has_field_double() const { return _has_field_[9]; }
-  double field_double() const { return field_double_; }
-  void set_field_double(double value) { field_double_ = value; _has_field_.set(9); }
-
-  bool has_field_float() const { return _has_field_[10]; }
-  float field_float() const { return field_float_; }
-  void set_field_float(float value) { field_float_ = value; _has_field_.set(10); }
-
-  bool has_field_sint64() const { return _has_field_[11]; }
-  int64_t field_sint64() const { return field_sint64_; }
-  void set_field_sint64(int64_t value) { field_sint64_ = value; _has_field_.set(11); }
-
-  bool has_field_sint32() const { return _has_field_[12]; }
-  int32_t field_sint32() const { return field_sint32_; }
-  void set_field_sint32(int32_t value) { field_sint32_ = value; _has_field_.set(12); }
-
-  bool has_field_string() const { return _has_field_[13]; }
-  const std::string& field_string() const { return field_string_; }
-  void set_field_string(const std::string& value) { field_string_ = value; _has_field_.set(13); }
-
-  bool has_field_bytes() const { return _has_field_[14]; }
-  const std::string& field_bytes() const { return field_bytes_; }
-  void set_field_bytes(const std::string& value) { field_bytes_ = value; _has_field_.set(14); }
-  void set_field_bytes(const void* p, size_t s) { field_bytes_.assign(reinterpret_cast<const char*>(p), s); _has_field_.set(14); }
-
- private:
-  uint32_t field_uint32_{};
-  int32_t field_int32_{};
-  uint64_t field_uint64_{};
-  int64_t field_int64_{};
-  uint64_t field_fixed64_{};
-  int64_t field_sfixed64_{};
-  uint32_t field_fixed32_{};
-  int32_t field_sfixed32_{};
-  double field_double_{};
-  float field_float_{};
-  int64_t field_sint64_{};
-  int32_t field_sint32_{};
-  std::string field_string_{};
-  std::string field_bytes_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<15> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TEST_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/interceptor_config.gen.h
+// gen_amalgamated begin source: gen/protos/perfetto/config/ftrace/frozen_ftrace_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTOR_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTOR_CONFIG_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class InterceptorConfig;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/ftrace/frozen_ftrace_config.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-class PERFETTO_EXPORT_COMPONENT InterceptorConfig : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kNameFieldNumber = 1,
-    kConsoleConfigFieldNumber = 100,
-  };
+FrozenFtraceConfig::FrozenFtraceConfig() = default;
+FrozenFtraceConfig::~FrozenFtraceConfig() = default;
+FrozenFtraceConfig::FrozenFtraceConfig(const FrozenFtraceConfig&) = default;
+FrozenFtraceConfig& FrozenFtraceConfig::operator=(const FrozenFtraceConfig&) = default;
+FrozenFtraceConfig::FrozenFtraceConfig(FrozenFtraceConfig&&) noexcept = default;
+FrozenFtraceConfig& FrozenFtraceConfig::operator=(FrozenFtraceConfig&&) = default;
 
-  InterceptorConfig();
-  ~InterceptorConfig() override;
-  InterceptorConfig(InterceptorConfig&&) noexcept;
-  InterceptorConfig& operator=(InterceptorConfig&&);
-  InterceptorConfig(const InterceptorConfig&);
-  InterceptorConfig& operator=(const InterceptorConfig&);
-  bool operator==(const InterceptorConfig&) const;
-  bool operator!=(const InterceptorConfig& other) const { return !(*this == other); }
+bool FrozenFtraceConfig::operator==(const FrozenFtraceConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(instance_name_, other.instance_name_);
+}
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+bool FrozenFtraceConfig::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  bool has_name() const { return _has_field_[1]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* instance_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &instance_name_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-  const std::string& console_config_raw() const { return console_config_; }
-  void set_console_config_raw(const std::string& raw) { console_config_ = raw; _has_field_.set(100); }
+std::string FrozenFtraceConfig::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
- private:
-  std::string name_{};
-  std::string console_config_;  // [lazy=true]
+std::vector<uint8_t> FrozenFtraceConfig::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+void FrozenFtraceConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: instance_name
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeString(1, instance_name_, msg);
+  }
 
-  std::bitset<101> _has_field_{};
-};
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTOR_CONFIG_PROTO_CPP_H_
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/ftrace/ftrace_config.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -25110,60 +22096,70 @@ class PERFETTO_EXPORT_COMPONENT InterceptorConfig : public ::protozero::CppMessa
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/data_source_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/system_info/system_info.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/test_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/interceptor_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/interceptors/console_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/chrome_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/ftrace/ftrace_config.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-DataSourceConfig::DataSourceConfig() = default;
-DataSourceConfig::~DataSourceConfig() = default;
-DataSourceConfig::DataSourceConfig(const DataSourceConfig&) = default;
-DataSourceConfig& DataSourceConfig::operator=(const DataSourceConfig&) = default;
-DataSourceConfig::DataSourceConfig(DataSourceConfig&&) noexcept = default;
-DataSourceConfig& DataSourceConfig::operator=(DataSourceConfig&&) = default;
-
-bool DataSourceConfig::operator==(const DataSourceConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && name_ == other.name_
-   && target_buffer_ == other.target_buffer_
-   && trace_duration_ms_ == other.trace_duration_ms_
-   && prefer_suspend_clock_for_duration_ == other.prefer_suspend_clock_for_duration_
-   && stop_timeout_ms_ == other.stop_timeout_ms_
-   && enable_extra_guardrails_ == other.enable_extra_guardrails_
-   && session_initiator_ == other.session_initiator_
-   && tracing_session_id_ == other.tracing_session_id_
-   && ftrace_config_ == other.ftrace_config_
-   && inode_file_config_ == other.inode_file_config_
-   && process_stats_config_ == other.process_stats_config_
-   && sys_stats_config_ == other.sys_stats_config_
-   && heapprofd_config_ == other.heapprofd_config_
-   && java_hprof_config_ == other.java_hprof_config_
-   && android_power_config_ == other.android_power_config_
-   && android_log_config_ == other.android_log_config_
-   && gpu_counter_config_ == other.gpu_counter_config_
-   && android_game_intervention_list_config_ == other.android_game_intervention_list_config_
-   && packages_list_config_ == other.packages_list_config_
-   && perf_event_config_ == other.perf_event_config_
-   && vulkan_memory_config_ == other.vulkan_memory_config_
-   && track_event_config_ == other.track_event_config_
-   && android_polled_state_config_ == other.android_polled_state_config_
-   && android_system_property_config_ == other.android_system_property_config_
-   && statsd_tracing_config_ == other.statsd_tracing_config_
-   && system_info_config_ == other.system_info_config_
-   && chrome_config_ == other.chrome_config_
-   && interceptor_config_ == other.interceptor_config_
-   && network_packet_trace_config_ == other.network_packet_trace_config_
-   && legacy_config_ == other.legacy_config_
-   && for_testing_ == other.for_testing_;
-}
+FtraceConfig::FtraceConfig() = default;
+FtraceConfig::~FtraceConfig() = default;
+FtraceConfig::FtraceConfig(const FtraceConfig&) = default;
+FtraceConfig& FtraceConfig::operator=(const FtraceConfig&) = default;
+FtraceConfig::FtraceConfig(FtraceConfig&&) noexcept = default;
+FtraceConfig& FtraceConfig::operator=(FtraceConfig&&) = default;
 
-bool DataSourceConfig::ParseFromArray(const void* raw, size_t size) {
+bool FtraceConfig::operator==(const FtraceConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(ftrace_events_, other.ftrace_events_)
+   && ::protozero::internal::gen_helpers::EqualsField(atrace_categories_, other.atrace_categories_)
+   && ::protozero::internal::gen_helpers::EqualsField(atrace_apps_, other.atrace_apps_)
+   && ::protozero::internal::gen_helpers::EqualsField(atrace_categories_prefer_sdk_, other.atrace_categories_prefer_sdk_)
+   && ::protozero::internal::gen_helpers::EqualsField(atrace_userspace_only_, other.atrace_userspace_only_)
+   && ::protozero::internal::gen_helpers::EqualsField(buffer_size_kb_, other.buffer_size_kb_)
+   && ::protozero::internal::gen_helpers::EqualsField(buffer_size_lower_bound_, other.buffer_size_lower_bound_)
+   && ::protozero::internal::gen_helpers::EqualsField(drain_period_ms_, other.drain_period_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(drain_buffer_percent_, other.drain_buffer_percent_)
+   && ::protozero::internal::gen_helpers::EqualsField(compact_sched_, other.compact_sched_)
+   && ::protozero::internal::gen_helpers::EqualsField(print_filter_, other.print_filter_)
+   && ::protozero::internal::gen_helpers::EqualsField(symbolize_ksyms_, other.symbolize_ksyms_)
+   && ::protozero::internal::gen_helpers::EqualsField(ksyms_mem_policy_, other.ksyms_mem_policy_)
+   && ::protozero::internal::gen_helpers::EqualsField(throttle_rss_stat_, other.throttle_rss_stat_)
+   && ::protozero::internal::gen_helpers::EqualsField(denser_generic_event_encoding_, other.denser_generic_event_encoding_)
+   && ::protozero::internal::gen_helpers::EqualsField(disable_generic_events_, other.disable_generic_events_)
+   && ::protozero::internal::gen_helpers::EqualsField(syscall_events_, other.syscall_events_)
+   && ::protozero::internal::gen_helpers::EqualsField(enable_function_graph_, other.enable_function_graph_)
+   && ::protozero::internal::gen_helpers::EqualsField(function_filters_, other.function_filters_)
+   && ::protozero::internal::gen_helpers::EqualsField(function_graph_roots_, other.function_graph_roots_)
+   && ::protozero::internal::gen_helpers::EqualsField(function_graph_max_depth_, other.function_graph_max_depth_)
+   && ::protozero::internal::gen_helpers::EqualsField(kprobe_events_, other.kprobe_events_)
+   && ::protozero::internal::gen_helpers::EqualsField(preserve_ftrace_buffer_, other.preserve_ftrace_buffer_)
+   && ::protozero::internal::gen_helpers::EqualsField(use_monotonic_raw_clock_, other.use_monotonic_raw_clock_)
+   && ::protozero::internal::gen_helpers::EqualsField(instance_name_, other.instance_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(debug_ftrace_abi_, other.debug_ftrace_abi_)
+   && ::protozero::internal::gen_helpers::EqualsField(tids_to_trace_, other.tids_to_trace_)
+   && ::protozero::internal::gen_helpers::EqualsField(tracefs_options_, other.tracefs_options_)
+   && ::protozero::internal::gen_helpers::EqualsField(tracing_cpumask_, other.tracing_cpumask_)
+   && ::protozero::internal::gen_helpers::EqualsField(initialize_ksyms_synchronously_for_testing_, other.initialize_ksyms_synchronously_for_testing_);
+}
+
+int FtraceConfig::kprobe_events_size() const { return static_cast<int>(kprobe_events_.size()); }
+void FtraceConfig::clear_kprobe_events() { kprobe_events_.clear(); }
+FtraceConfig_KprobeEvent* FtraceConfig::add_kprobe_events() { kprobe_events_.emplace_back(); return &kprobe_events_.back(); }
+int FtraceConfig::tracefs_options_size() const { return static_cast<int>(tracefs_options_.size()); }
+void FtraceConfig::clear_tracefs_options() { tracefs_options_.clear(); }
+FtraceConfig_TracefsOption* FtraceConfig::add_tracefs_options() { tracefs_options_.emplace_back(); return &tracefs_options_.back(); }
+bool FtraceConfig::ParseFromArray(const void* raw, size_t size) {
+  ftrace_events_.clear();
+  atrace_categories_.clear();
+  atrace_apps_.clear();
+  atrace_categories_prefer_sdk_.clear();
+  syscall_events_.clear();
+  function_filters_.clear();
+  function_graph_roots_.clear();
+  kprobe_events_.clear();
+  tids_to_trace_.clear();
+  tracefs_options_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -25173,98 +22169,105 @@ bool DataSourceConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
-        break;
-      case 2 /* target_buffer */:
-        field.get(&target_buffer_);
+      case 1 /* ftrace_events */:
+        ftrace_events_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &ftrace_events_.back());
         break;
-      case 3 /* trace_duration_ms */:
-        field.get(&trace_duration_ms_);
+      case 2 /* atrace_categories */:
+        atrace_categories_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &atrace_categories_.back());
         break;
-      case 122 /* prefer_suspend_clock_for_duration */:
-        field.get(&prefer_suspend_clock_for_duration_);
+      case 3 /* atrace_apps */:
+        atrace_apps_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &atrace_apps_.back());
         break;
-      case 7 /* stop_timeout_ms */:
-        field.get(&stop_timeout_ms_);
+      case 28 /* atrace_categories_prefer_sdk */:
+        atrace_categories_prefer_sdk_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &atrace_categories_prefer_sdk_.back());
         break;
-      case 6 /* enable_extra_guardrails */:
-        field.get(&enable_extra_guardrails_);
+      case 34 /* atrace_userspace_only */:
+        field.get(&atrace_userspace_only_);
         break;
-      case 8 /* session_initiator */:
-        field.get(&session_initiator_);
+      case 10 /* buffer_size_kb */:
+        field.get(&buffer_size_kb_);
         break;
-      case 4 /* tracing_session_id */:
-        field.get(&tracing_session_id_);
+      case 27 /* buffer_size_lower_bound */:
+        field.get(&buffer_size_lower_bound_);
         break;
-      case 100 /* ftrace_config */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &ftrace_config_);
+      case 11 /* drain_period_ms */:
+        field.get(&drain_period_ms_);
         break;
-      case 102 /* inode_file_config */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &inode_file_config_);
+      case 29 /* drain_buffer_percent */:
+        field.get(&drain_buffer_percent_);
         break;
-      case 103 /* process_stats_config */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &process_stats_config_);
+      case 12 /* compact_sched */:
+        (*compact_sched_).ParseFromArray(field.data(), field.size());
         break;
-      case 104 /* sys_stats_config */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &sys_stats_config_);
+      case 22 /* print_filter */:
+        (*print_filter_).ParseFromArray(field.data(), field.size());
         break;
-      case 105 /* heapprofd_config */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &heapprofd_config_);
+      case 13 /* symbolize_ksyms */:
+        field.get(&symbolize_ksyms_);
         break;
-      case 110 /* java_hprof_config */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &java_hprof_config_);
+      case 17 /* ksyms_mem_policy */:
+        field.get(&ksyms_mem_policy_);
         break;
-      case 106 /* android_power_config */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &android_power_config_);
+      case 15 /* throttle_rss_stat */:
+        field.get(&throttle_rss_stat_);
         break;
-      case 107 /* android_log_config */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &android_log_config_);
+      case 32 /* denser_generic_event_encoding */:
+        field.get(&denser_generic_event_encoding_);
         break;
-      case 108 /* gpu_counter_config */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &gpu_counter_config_);
+      case 16 /* disable_generic_events */:
+        field.get(&disable_generic_events_);
         break;
-      case 116 /* android_game_intervention_list_config */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &android_game_intervention_list_config_);
+      case 18 /* syscall_events */:
+        syscall_events_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &syscall_events_.back());
         break;
-      case 109 /* packages_list_config */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &packages_list_config_);
+      case 19 /* enable_function_graph */:
+        field.get(&enable_function_graph_);
         break;
-      case 111 /* perf_event_config */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &perf_event_config_);
+      case 20 /* function_filters */:
+        function_filters_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &function_filters_.back());
         break;
-      case 112 /* vulkan_memory_config */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &vulkan_memory_config_);
+      case 21 /* function_graph_roots */:
+        function_graph_roots_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &function_graph_roots_.back());
         break;
-      case 113 /* track_event_config */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &track_event_config_);
+      case 33 /* function_graph_max_depth */:
+        field.get(&function_graph_max_depth_);
         break;
-      case 114 /* android_polled_state_config */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &android_polled_state_config_);
+      case 30 /* kprobe_events */:
+        kprobe_events_.emplace_back();
+        kprobe_events_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 118 /* android_system_property_config */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &android_system_property_config_);
+      case 23 /* preserve_ftrace_buffer */:
+        field.get(&preserve_ftrace_buffer_);
         break;
-      case 117 /* statsd_tracing_config */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &statsd_tracing_config_);
+      case 24 /* use_monotonic_raw_clock */:
+        field.get(&use_monotonic_raw_clock_);
         break;
-      case 119 /* system_info_config */:
-        (*system_info_config_).ParseFromArray(field.data(), field.size());
+      case 25 /* instance_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &instance_name_);
         break;
-      case 101 /* chrome_config */:
-        (*chrome_config_).ParseFromArray(field.data(), field.size());
+      case 31 /* debug_ftrace_abi */:
+        field.get(&debug_ftrace_abi_);
         break;
-      case 115 /* interceptor_config */:
-        (*interceptor_config_).ParseFromArray(field.data(), field.size());
+      case 35 /* tids_to_trace */:
+        tids_to_trace_.emplace_back();
+        field.get(&tids_to_trace_.back());
         break;
-      case 120 /* network_packet_trace_config */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &network_packet_trace_config_);
+      case 36 /* tracefs_options */:
+        tracefs_options_.emplace_back();
+        tracefs_options_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 1000 /* legacy_config */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &legacy_config_);
+      case 37 /* tracing_cpumask */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &tracing_cpumask_);
         break;
-      case 1001 /* for_testing */:
-        (*for_testing_).ParseFromArray(field.data(), field.size());
+      case 14 /* initialize_ksyms_synchronously_for_testing */:
+        field.get(&initialize_ksyms_synchronously_for_testing_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -25274,214 +22277,187 @@ bool DataSourceConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string DataSourceConfig::SerializeAsString() const {
+std::string FtraceConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> DataSourceConfig::SerializeAsArray() const {
+std::vector<uint8_t> FtraceConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void DataSourceConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: name
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
+void FtraceConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: ftrace_events
+  for (auto& it : ftrace_events_) {
+    ::protozero::internal::gen_helpers::SerializeString(1, it, msg);
   }
 
-  // Field 2: target_buffer
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, target_buffer_, msg);
+  // Field 2: atrace_categories
+  for (auto& it : atrace_categories_) {
+    ::protozero::internal::gen_helpers::SerializeString(2, it, msg);
   }
 
-  // Field 3: trace_duration_ms
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, trace_duration_ms_, msg);
+  // Field 3: atrace_apps
+  for (auto& it : atrace_apps_) {
+    ::protozero::internal::gen_helpers::SerializeString(3, it, msg);
   }
 
-  // Field 122: prefer_suspend_clock_for_duration
-  if (_has_field_[122]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(122, prefer_suspend_clock_for_duration_, msg);
+  // Field 28: atrace_categories_prefer_sdk
+  for (auto& it : atrace_categories_prefer_sdk_) {
+    ::protozero::internal::gen_helpers::SerializeString(28, it, msg);
   }
 
-  // Field 7: stop_timeout_ms
-  if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(7, stop_timeout_ms_, msg);
+  // Field 34: atrace_userspace_only
+  if (_has_field_[34]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(34, atrace_userspace_only_, msg);
   }
 
-  // Field 6: enable_extra_guardrails
-  if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(6, enable_extra_guardrails_, msg);
+  // Field 10: buffer_size_kb
+  if (_has_field_[10]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(10, buffer_size_kb_, msg);
   }
 
-  // Field 8: session_initiator
-  if (_has_field_[8]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(8, session_initiator_, msg);
+  // Field 27: buffer_size_lower_bound
+  if (_has_field_[27]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(27, buffer_size_lower_bound_, msg);
   }
 
-  // Field 4: tracing_session_id
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, tracing_session_id_, msg);
+  // Field 11: drain_period_ms
+  if (_has_field_[11]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(11, drain_period_ms_, msg);
   }
 
-  // Field 100: ftrace_config
-  if (_has_field_[100]) {
-    msg->AppendString(100, ftrace_config_);
+  // Field 29: drain_buffer_percent
+  if (_has_field_[29]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(29, drain_buffer_percent_, msg);
   }
 
-  // Field 102: inode_file_config
-  if (_has_field_[102]) {
-    msg->AppendString(102, inode_file_config_);
+  // Field 12: compact_sched
+  if (_has_field_[12]) {
+    (*compact_sched_).Serialize(msg->BeginNestedMessage<::protozero::Message>(12));
   }
 
-  // Field 103: process_stats_config
-  if (_has_field_[103]) {
-    msg->AppendString(103, process_stats_config_);
+  // Field 22: print_filter
+  if (_has_field_[22]) {
+    (*print_filter_).Serialize(msg->BeginNestedMessage<::protozero::Message>(22));
   }
 
-  // Field 104: sys_stats_config
-  if (_has_field_[104]) {
-    msg->AppendString(104, sys_stats_config_);
+  // Field 13: symbolize_ksyms
+  if (_has_field_[13]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(13, symbolize_ksyms_, msg);
   }
 
-  // Field 105: heapprofd_config
-  if (_has_field_[105]) {
-    msg->AppendString(105, heapprofd_config_);
-  }
-
-  // Field 110: java_hprof_config
-  if (_has_field_[110]) {
-    msg->AppendString(110, java_hprof_config_);
+  // Field 17: ksyms_mem_policy
+  if (_has_field_[17]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(17, ksyms_mem_policy_, msg);
   }
 
-  // Field 106: android_power_config
-  if (_has_field_[106]) {
-    msg->AppendString(106, android_power_config_);
+  // Field 15: throttle_rss_stat
+  if (_has_field_[15]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(15, throttle_rss_stat_, msg);
   }
 
-  // Field 107: android_log_config
-  if (_has_field_[107]) {
-    msg->AppendString(107, android_log_config_);
+  // Field 32: denser_generic_event_encoding
+  if (_has_field_[32]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(32, denser_generic_event_encoding_, msg);
   }
 
-  // Field 108: gpu_counter_config
-  if (_has_field_[108]) {
-    msg->AppendString(108, gpu_counter_config_);
+  // Field 16: disable_generic_events
+  if (_has_field_[16]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(16, disable_generic_events_, msg);
   }
 
-  // Field 116: android_game_intervention_list_config
-  if (_has_field_[116]) {
-    msg->AppendString(116, android_game_intervention_list_config_);
+  // Field 18: syscall_events
+  for (auto& it : syscall_events_) {
+    ::protozero::internal::gen_helpers::SerializeString(18, it, msg);
   }
 
-  // Field 109: packages_list_config
-  if (_has_field_[109]) {
-    msg->AppendString(109, packages_list_config_);
+  // Field 19: enable_function_graph
+  if (_has_field_[19]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(19, enable_function_graph_, msg);
   }
 
-  // Field 111: perf_event_config
-  if (_has_field_[111]) {
-    msg->AppendString(111, perf_event_config_);
+  // Field 20: function_filters
+  for (auto& it : function_filters_) {
+    ::protozero::internal::gen_helpers::SerializeString(20, it, msg);
   }
 
-  // Field 112: vulkan_memory_config
-  if (_has_field_[112]) {
-    msg->AppendString(112, vulkan_memory_config_);
+  // Field 21: function_graph_roots
+  for (auto& it : function_graph_roots_) {
+    ::protozero::internal::gen_helpers::SerializeString(21, it, msg);
   }
 
-  // Field 113: track_event_config
-  if (_has_field_[113]) {
-    msg->AppendString(113, track_event_config_);
+  // Field 33: function_graph_max_depth
+  if (_has_field_[33]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(33, function_graph_max_depth_, msg);
   }
 
-  // Field 114: android_polled_state_config
-  if (_has_field_[114]) {
-    msg->AppendString(114, android_polled_state_config_);
+  // Field 30: kprobe_events
+  for (auto& it : kprobe_events_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(30));
   }
 
-  // Field 118: android_system_property_config
-  if (_has_field_[118]) {
-    msg->AppendString(118, android_system_property_config_);
+  // Field 23: preserve_ftrace_buffer
+  if (_has_field_[23]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(23, preserve_ftrace_buffer_, msg);
   }
 
-  // Field 117: statsd_tracing_config
-  if (_has_field_[117]) {
-    msg->AppendString(117, statsd_tracing_config_);
+  // Field 24: use_monotonic_raw_clock
+  if (_has_field_[24]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(24, use_monotonic_raw_clock_, msg);
   }
 
-  // Field 119: system_info_config
-  if (_has_field_[119]) {
-    (*system_info_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(119));
+  // Field 25: instance_name
+  if (_has_field_[25]) {
+    ::protozero::internal::gen_helpers::SerializeString(25, instance_name_, msg);
   }
 
-  // Field 101: chrome_config
-  if (_has_field_[101]) {
-    (*chrome_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(101));
+  // Field 31: debug_ftrace_abi
+  if (_has_field_[31]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(31, debug_ftrace_abi_, msg);
   }
 
-  // Field 115: interceptor_config
-  if (_has_field_[115]) {
-    (*interceptor_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(115));
+  // Field 35: tids_to_trace
+  for (auto& it : tids_to_trace_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(35, it, msg);
   }
 
-  // Field 120: network_packet_trace_config
-  if (_has_field_[120]) {
-    msg->AppendString(120, network_packet_trace_config_);
+  // Field 36: tracefs_options
+  for (auto& it : tracefs_options_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(36));
   }
 
-  // Field 1000: legacy_config
-  if (_has_field_[1000]) {
-    ::protozero::internal::gen_helpers::SerializeString(1000, legacy_config_, msg);
+  // Field 37: tracing_cpumask
+  if (_has_field_[37]) {
+    ::protozero::internal::gen_helpers::SerializeString(37, tracing_cpumask_, msg);
   }
 
-  // Field 1001: for_testing
-  if (_has_field_[1001]) {
-    (*for_testing_).Serialize(msg->BeginNestedMessage<::protozero::Message>(1001));
+  // Field 14: initialize_ksyms_synchronously_for_testing
+  if (_has_field_[14]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(14, initialize_ksyms_synchronously_for_testing_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/interceptor_config.gen.cc
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/interceptor_config.gen.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
 
-InterceptorConfig::InterceptorConfig() = default;
-InterceptorConfig::~InterceptorConfig() = default;
-InterceptorConfig::InterceptorConfig(const InterceptorConfig&) = default;
-InterceptorConfig& InterceptorConfig::operator=(const InterceptorConfig&) = default;
-InterceptorConfig::InterceptorConfig(InterceptorConfig&&) noexcept = default;
-InterceptorConfig& InterceptorConfig::operator=(InterceptorConfig&&) = default;
+FtraceConfig_TracefsOption::FtraceConfig_TracefsOption() = default;
+FtraceConfig_TracefsOption::~FtraceConfig_TracefsOption() = default;
+FtraceConfig_TracefsOption::FtraceConfig_TracefsOption(const FtraceConfig_TracefsOption&) = default;
+FtraceConfig_TracefsOption& FtraceConfig_TracefsOption::operator=(const FtraceConfig_TracefsOption&) = default;
+FtraceConfig_TracefsOption::FtraceConfig_TracefsOption(FtraceConfig_TracefsOption&&) noexcept = default;
+FtraceConfig_TracefsOption& FtraceConfig_TracefsOption::operator=(FtraceConfig_TracefsOption&&) = default;
 
-bool InterceptorConfig::operator==(const InterceptorConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && name_ == other.name_
-   && console_config_ == other.console_config_;
+bool FtraceConfig_TracefsOption::operator==(const FtraceConfig_TracefsOption& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(state_, other.state_);
 }
 
-bool InterceptorConfig::ParseFromArray(const void* raw, size_t size) {
+bool FtraceConfig_TracefsOption::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -25494,8 +22470,8 @@ bool InterceptorConfig::ParseFromArray(const void* raw, size_t size) {
       case 1 /* name */:
         ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
         break;
-      case 100 /* console_config */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &console_config_);
+      case 2 /* state */:
+        field.get(&state_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -25505,327 +22481,47 @@ bool InterceptorConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string InterceptorConfig::SerializeAsString() const {
+std::string FtraceConfig_TracefsOption::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> InterceptorConfig::SerializeAsArray() const {
+std::vector<uint8_t> FtraceConfig_TracefsOption::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void InterceptorConfig::Serialize(::protozero::Message* msg) const {
+void FtraceConfig_TracefsOption::Serialize(::protozero::Message* msg) const {
   // Field 1: name
   if (_has_field_[1]) {
     ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
   }
 
-  // Field 100: console_config
-  if (_has_field_[100]) {
-    msg->AppendString(100, console_config_);
+  // Field 2: state
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, state_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/stress_test_config.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/stress_test_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STRESS_TEST_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STRESS_TEST_CONFIG_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class StressTestConfig;
-class StressTestConfig_WriterTiming;
-class TraceConfig;
-class TraceConfig_CmdTraceStartDelay;
-class TraceConfig_AndroidReportConfig;
-class TraceConfig_TraceFilter;
-class TraceConfig_IncidentReportConfig;
-class TraceConfig_IncrementalStateConfig;
-class TraceConfig_TriggerConfig;
-class TraceConfig_TriggerConfig_Trigger;
-class TraceConfig_GuardrailOverrides;
-class TraceConfig_StatsdMetadata;
-class TraceConfig_ProducerConfig;
-class TraceConfig_BuiltinDataSource;
-class TraceConfig_DataSource;
-class DataSourceConfig;
-class TestConfig;
-class TestConfig_DummyFields;
-class InterceptorConfig;
-class ChromeConfig;
-class SystemInfoConfig;
-class TraceConfig_BufferConfig;
-enum TraceConfig_LockdownModeOperation : int;
-enum TraceConfig_CompressionType : int;
-enum TraceConfig_StatsdLogging : int;
-enum TraceConfig_TriggerConfig_TriggerMode : int;
-enum BuiltinClock : int;
-enum DataSourceConfig_SessionInitiator : int;
-enum ChromeConfig_ClientPriority : int;
-enum TraceConfig_BufferConfig_FillPolicy : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT StressTestConfig : public ::protozero::CppMessageObj {
- public:
-  using WriterTiming = StressTestConfig_WriterTiming;
-  enum FieldNumbers {
-    kTraceConfigFieldNumber = 1,
-    kShmemSizeKbFieldNumber = 2,
-    kShmemPageSizeKbFieldNumber = 3,
-    kNumProcessesFieldNumber = 4,
-    kNumThreadsFieldNumber = 5,
-    kMaxEventsFieldNumber = 6,
-    kNestingFieldNumber = 7,
-    kSteadyStateTimingsFieldNumber = 8,
-    kBurstPeriodMsFieldNumber = 9,
-    kBurstDurationMsFieldNumber = 10,
-    kBurstTimingsFieldNumber = 11,
-  };
-
-  StressTestConfig();
-  ~StressTestConfig() override;
-  StressTestConfig(StressTestConfig&&) noexcept;
-  StressTestConfig& operator=(StressTestConfig&&);
-  StressTestConfig(const StressTestConfig&);
-  StressTestConfig& operator=(const StressTestConfig&);
-  bool operator==(const StressTestConfig&) const;
-  bool operator!=(const StressTestConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_trace_config() const { return _has_field_[1]; }
-  const TraceConfig& trace_config() const { return *trace_config_; }
-  TraceConfig* mutable_trace_config() { _has_field_.set(1); return trace_config_.get(); }
-
-  bool has_shmem_size_kb() const { return _has_field_[2]; }
-  uint32_t shmem_size_kb() const { return shmem_size_kb_; }
-  void set_shmem_size_kb(uint32_t value) { shmem_size_kb_ = value; _has_field_.set(2); }
-
-  bool has_shmem_page_size_kb() const { return _has_field_[3]; }
-  uint32_t shmem_page_size_kb() const { return shmem_page_size_kb_; }
-  void set_shmem_page_size_kb(uint32_t value) { shmem_page_size_kb_ = value; _has_field_.set(3); }
-
-  bool has_num_processes() const { return _has_field_[4]; }
-  uint32_t num_processes() const { return num_processes_; }
-  void set_num_processes(uint32_t value) { num_processes_ = value; _has_field_.set(4); }
-
-  bool has_num_threads() const { return _has_field_[5]; }
-  uint32_t num_threads() const { return num_threads_; }
-  void set_num_threads(uint32_t value) { num_threads_ = value; _has_field_.set(5); }
-
-  bool has_max_events() const { return _has_field_[6]; }
-  uint32_t max_events() const { return max_events_; }
-  void set_max_events(uint32_t value) { max_events_ = value; _has_field_.set(6); }
-
-  bool has_nesting() const { return _has_field_[7]; }
-  uint32_t nesting() const { return nesting_; }
-  void set_nesting(uint32_t value) { nesting_ = value; _has_field_.set(7); }
-
-  bool has_steady_state_timings() const { return _has_field_[8]; }
-  const StressTestConfig_WriterTiming& steady_state_timings() const { return *steady_state_timings_; }
-  StressTestConfig_WriterTiming* mutable_steady_state_timings() { _has_field_.set(8); return steady_state_timings_.get(); }
-
-  bool has_burst_period_ms() const { return _has_field_[9]; }
-  uint32_t burst_period_ms() const { return burst_period_ms_; }
-  void set_burst_period_ms(uint32_t value) { burst_period_ms_ = value; _has_field_.set(9); }
-
-  bool has_burst_duration_ms() const { return _has_field_[10]; }
-  uint32_t burst_duration_ms() const { return burst_duration_ms_; }
-  void set_burst_duration_ms(uint32_t value) { burst_duration_ms_ = value; _has_field_.set(10); }
-
-  bool has_burst_timings() const { return _has_field_[11]; }
-  const StressTestConfig_WriterTiming& burst_timings() const { return *burst_timings_; }
-  StressTestConfig_WriterTiming* mutable_burst_timings() { _has_field_.set(11); return burst_timings_.get(); }
-
- private:
-  ::protozero::CopyablePtr<TraceConfig> trace_config_;
-  uint32_t shmem_size_kb_{};
-  uint32_t shmem_page_size_kb_{};
-  uint32_t num_processes_{};
-  uint32_t num_threads_{};
-  uint32_t max_events_{};
-  uint32_t nesting_{};
-  ::protozero::CopyablePtr<StressTestConfig_WriterTiming> steady_state_timings_;
-  uint32_t burst_period_ms_{};
-  uint32_t burst_duration_ms_{};
-  ::protozero::CopyablePtr<StressTestConfig_WriterTiming> burst_timings_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<12> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT StressTestConfig_WriterTiming : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kPayloadMeanFieldNumber = 1,
-    kPayloadStddevFieldNumber = 2,
-    kRateMeanFieldNumber = 3,
-    kRateStddevFieldNumber = 4,
-    kPayloadWriteTimeMsFieldNumber = 5,
-  };
-
-  StressTestConfig_WriterTiming();
-  ~StressTestConfig_WriterTiming() override;
-  StressTestConfig_WriterTiming(StressTestConfig_WriterTiming&&) noexcept;
-  StressTestConfig_WriterTiming& operator=(StressTestConfig_WriterTiming&&);
-  StressTestConfig_WriterTiming(const StressTestConfig_WriterTiming&);
-  StressTestConfig_WriterTiming& operator=(const StressTestConfig_WriterTiming&);
-  bool operator==(const StressTestConfig_WriterTiming&) const;
-  bool operator!=(const StressTestConfig_WriterTiming& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_payload_mean() const { return _has_field_[1]; }
-  double payload_mean() const { return payload_mean_; }
-  void set_payload_mean(double value) { payload_mean_ = value; _has_field_.set(1); }
-
-  bool has_payload_stddev() const { return _has_field_[2]; }
-  double payload_stddev() const { return payload_stddev_; }
-  void set_payload_stddev(double value) { payload_stddev_ = value; _has_field_.set(2); }
-
-  bool has_rate_mean() const { return _has_field_[3]; }
-  double rate_mean() const { return rate_mean_; }
-  void set_rate_mean(double value) { rate_mean_ = value; _has_field_.set(3); }
-
-  bool has_rate_stddev() const { return _has_field_[4]; }
-  double rate_stddev() const { return rate_stddev_; }
-  void set_rate_stddev(double value) { rate_stddev_ = value; _has_field_.set(4); }
-
-  bool has_payload_write_time_ms() const { return _has_field_[5]; }
-  uint32_t payload_write_time_ms() const { return payload_write_time_ms_; }
-  void set_payload_write_time_ms(uint32_t value) { payload_write_time_ms_ = value; _has_field_.set(5); }
-
- private:
-  double payload_mean_{};
-  double payload_stddev_{};
-  double rate_mean_{};
-  double rate_stddev_{};
-  uint32_t payload_write_time_ms_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<6> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STRESS_TEST_CONFIG_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/stress_test_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/trace_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/data_source_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/system_info/system_info.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/track_event/track_event_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/test_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/sys_stats/sys_stats_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/common/sys_stats_counters.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/perf_event_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/common/perf_events.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/java_hprof_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/heapprofd_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/process_stats/process_stats_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/statsd/statsd_tracing_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/statsd/atom_ids.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/power/android_power_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/interceptor_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/interceptors/console_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/inode_file/inode_file_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/gpu/vulkan_memory_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/gpu/gpu_counter_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/ftrace/ftrace_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/chrome_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/android/packages_list_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/android/network_trace_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_system_property_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_polled_state_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_log_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/common/android_log_constants.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_game_intervention_list_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/common/builtin_clock.gen.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
 
-StressTestConfig::StressTestConfig() = default;
-StressTestConfig::~StressTestConfig() = default;
-StressTestConfig::StressTestConfig(const StressTestConfig&) = default;
-StressTestConfig& StressTestConfig::operator=(const StressTestConfig&) = default;
-StressTestConfig::StressTestConfig(StressTestConfig&&) noexcept = default;
-StressTestConfig& StressTestConfig::operator=(StressTestConfig&&) = default;
+FtraceConfig_KprobeEvent::FtraceConfig_KprobeEvent() = default;
+FtraceConfig_KprobeEvent::~FtraceConfig_KprobeEvent() = default;
+FtraceConfig_KprobeEvent::FtraceConfig_KprobeEvent(const FtraceConfig_KprobeEvent&) = default;
+FtraceConfig_KprobeEvent& FtraceConfig_KprobeEvent::operator=(const FtraceConfig_KprobeEvent&) = default;
+FtraceConfig_KprobeEvent::FtraceConfig_KprobeEvent(FtraceConfig_KprobeEvent&&) noexcept = default;
+FtraceConfig_KprobeEvent& FtraceConfig_KprobeEvent::operator=(FtraceConfig_KprobeEvent&&) = default;
 
-bool StressTestConfig::operator==(const StressTestConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && trace_config_ == other.trace_config_
-   && shmem_size_kb_ == other.shmem_size_kb_
-   && shmem_page_size_kb_ == other.shmem_page_size_kb_
-   && num_processes_ == other.num_processes_
-   && num_threads_ == other.num_threads_
-   && max_events_ == other.max_events_
-   && nesting_ == other.nesting_
-   && steady_state_timings_ == other.steady_state_timings_
-   && burst_period_ms_ == other.burst_period_ms_
-   && burst_duration_ms_ == other.burst_duration_ms_
-   && burst_timings_ == other.burst_timings_;
+bool FtraceConfig_KprobeEvent::operator==(const FtraceConfig_KprobeEvent& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(probe_, other.probe_)
+   && ::protozero::internal::gen_helpers::EqualsField(type_, other.type_);
 }
 
-bool StressTestConfig::ParseFromArray(const void* raw, size_t size) {
+bool FtraceConfig_KprobeEvent::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -25835,38 +22531,11 @@ bool StressTestConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* trace_config */:
-        (*trace_config_).ParseFromArray(field.data(), field.size());
-        break;
-      case 2 /* shmem_size_kb */:
-        field.get(&shmem_size_kb_);
-        break;
-      case 3 /* shmem_page_size_kb */:
-        field.get(&shmem_page_size_kb_);
-        break;
-      case 4 /* num_processes */:
-        field.get(&num_processes_);
-        break;
-      case 5 /* num_threads */:
-        field.get(&num_threads_);
-        break;
-      case 6 /* max_events */:
-        field.get(&max_events_);
-        break;
-      case 7 /* nesting */:
-        field.get(&nesting_);
+      case 1 /* probe */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &probe_);
         break;
-      case 8 /* steady_state_timings */:
-        (*steady_state_timings_).ParseFromArray(field.data(), field.size());
-        break;
-      case 9 /* burst_period_ms */:
-        field.get(&burst_period_ms_);
-        break;
-      case 10 /* burst_duration_ms */:
-        field.get(&burst_duration_ms_);
-        break;
-      case 11 /* burst_timings */:
-        (*burst_timings_).ParseFromArray(field.data(), field.size());
+      case 2 /* type */:
+        field.get(&type_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -25876,95 +22545,108 @@ bool StressTestConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string StressTestConfig::SerializeAsString() const {
+std::string FtraceConfig_KprobeEvent::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> StressTestConfig::SerializeAsArray() const {
+std::vector<uint8_t> FtraceConfig_KprobeEvent::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void StressTestConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: trace_config
+void FtraceConfig_KprobeEvent::Serialize(::protozero::Message* msg) const {
+  // Field 1: probe
   if (_has_field_[1]) {
-    (*trace_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
+    ::protozero::internal::gen_helpers::SerializeString(1, probe_, msg);
   }
 
-  // Field 2: shmem_size_kb
+  // Field 2: type
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, shmem_size_kb_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, type_, msg);
   }
 
-  // Field 3: shmem_page_size_kb
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, shmem_page_size_kb_, msg);
-  }
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  // Field 4: num_processes
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, num_processes_, msg);
-  }
 
-  // Field 5: num_threads
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(5, num_threads_, msg);
-  }
+FtraceConfig_PrintFilter::FtraceConfig_PrintFilter() = default;
+FtraceConfig_PrintFilter::~FtraceConfig_PrintFilter() = default;
+FtraceConfig_PrintFilter::FtraceConfig_PrintFilter(const FtraceConfig_PrintFilter&) = default;
+FtraceConfig_PrintFilter& FtraceConfig_PrintFilter::operator=(const FtraceConfig_PrintFilter&) = default;
+FtraceConfig_PrintFilter::FtraceConfig_PrintFilter(FtraceConfig_PrintFilter&&) noexcept = default;
+FtraceConfig_PrintFilter& FtraceConfig_PrintFilter::operator=(FtraceConfig_PrintFilter&&) = default;
 
-  // Field 6: max_events
-  if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(6, max_events_, msg);
-  }
+bool FtraceConfig_PrintFilter::operator==(const FtraceConfig_PrintFilter& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(rules_, other.rules_);
+}
 
-  // Field 7: nesting
-  if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(7, nesting_, msg);
-  }
+int FtraceConfig_PrintFilter::rules_size() const { return static_cast<int>(rules_.size()); }
+void FtraceConfig_PrintFilter::clear_rules() { rules_.clear(); }
+FtraceConfig_PrintFilter_Rule* FtraceConfig_PrintFilter::add_rules() { rules_.emplace_back(); return &rules_.back(); }
+bool FtraceConfig_PrintFilter::ParseFromArray(const void* raw, size_t size) {
+  rules_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  // Field 8: steady_state_timings
-  if (_has_field_[8]) {
-    (*steady_state_timings_).Serialize(msg->BeginNestedMessage<::protozero::Message>(8));
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* rules */:
+        rules_.emplace_back();
+        rules_.back().ParseFromArray(field.data(), field.size());
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
   }
+  return !packed_error && !dec.bytes_left();
+}
 
-  // Field 9: burst_period_ms
-  if (_has_field_[9]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(9, burst_period_ms_, msg);
-  }
+std::string FtraceConfig_PrintFilter::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  // Field 10: burst_duration_ms
-  if (_has_field_[10]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(10, burst_duration_ms_, msg);
-  }
+std::vector<uint8_t> FtraceConfig_PrintFilter::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  // Field 11: burst_timings
-  if (_has_field_[11]) {
-    (*burst_timings_).Serialize(msg->BeginNestedMessage<::protozero::Message>(11));
+void FtraceConfig_PrintFilter::Serialize(::protozero::Message* msg) const {
+  // Field 1: rules
+  for (auto& it : rules_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-StressTestConfig_WriterTiming::StressTestConfig_WriterTiming() = default;
-StressTestConfig_WriterTiming::~StressTestConfig_WriterTiming() = default;
-StressTestConfig_WriterTiming::StressTestConfig_WriterTiming(const StressTestConfig_WriterTiming&) = default;
-StressTestConfig_WriterTiming& StressTestConfig_WriterTiming::operator=(const StressTestConfig_WriterTiming&) = default;
-StressTestConfig_WriterTiming::StressTestConfig_WriterTiming(StressTestConfig_WriterTiming&&) noexcept = default;
-StressTestConfig_WriterTiming& StressTestConfig_WriterTiming::operator=(StressTestConfig_WriterTiming&&) = default;
+FtraceConfig_PrintFilter_Rule::FtraceConfig_PrintFilter_Rule() = default;
+FtraceConfig_PrintFilter_Rule::~FtraceConfig_PrintFilter_Rule() = default;
+FtraceConfig_PrintFilter_Rule::FtraceConfig_PrintFilter_Rule(const FtraceConfig_PrintFilter_Rule&) = default;
+FtraceConfig_PrintFilter_Rule& FtraceConfig_PrintFilter_Rule::operator=(const FtraceConfig_PrintFilter_Rule&) = default;
+FtraceConfig_PrintFilter_Rule::FtraceConfig_PrintFilter_Rule(FtraceConfig_PrintFilter_Rule&&) noexcept = default;
+FtraceConfig_PrintFilter_Rule& FtraceConfig_PrintFilter_Rule::operator=(FtraceConfig_PrintFilter_Rule&&) = default;
 
-bool StressTestConfig_WriterTiming::operator==(const StressTestConfig_WriterTiming& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && payload_mean_ == other.payload_mean_
-   && payload_stddev_ == other.payload_stddev_
-   && rate_mean_ == other.rate_mean_
-   && rate_stddev_ == other.rate_stddev_
-   && payload_write_time_ms_ == other.payload_write_time_ms_;
+bool FtraceConfig_PrintFilter_Rule::operator==(const FtraceConfig_PrintFilter_Rule& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(prefix_, other.prefix_)
+   && ::protozero::internal::gen_helpers::EqualsField(atrace_msg_, other.atrace_msg_)
+   && ::protozero::internal::gen_helpers::EqualsField(allow_, other.allow_);
 }
 
-bool StressTestConfig_WriterTiming::ParseFromArray(const void* raw, size_t size) {
+bool FtraceConfig_PrintFilter_Rule::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -25974,20 +22656,14 @@ bool StressTestConfig_WriterTiming::ParseFromArray(const void* raw, size_t size)
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* payload_mean */:
-        field.get(&payload_mean_);
-        break;
-      case 2 /* payload_stddev */:
-        field.get(&payload_stddev_);
-        break;
-      case 3 /* rate_mean */:
-        field.get(&rate_mean_);
+      case 1 /* prefix */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &prefix_);
         break;
-      case 4 /* rate_stddev */:
-        field.get(&rate_stddev_);
+      case 3 /* atrace_msg */:
+        (*atrace_msg_).ParseFromArray(field.data(), field.size());
         break;
-      case 5 /* payload_write_time_ms */:
-        field.get(&payload_write_time_ms_);
+      case 2 /* allow */:
+        field.get(&allow_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -25997,88 +22673,52 @@ bool StressTestConfig_WriterTiming::ParseFromArray(const void* raw, size_t size)
   return !packed_error && !dec.bytes_left();
 }
 
-std::string StressTestConfig_WriterTiming::SerializeAsString() const {
+std::string FtraceConfig_PrintFilter_Rule::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> StressTestConfig_WriterTiming::SerializeAsArray() const {
+std::vector<uint8_t> FtraceConfig_PrintFilter_Rule::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void StressTestConfig_WriterTiming::Serialize(::protozero::Message* msg) const {
-  // Field 1: payload_mean
+void FtraceConfig_PrintFilter_Rule::Serialize(::protozero::Message* msg) const {
+  // Field 1: prefix
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeFixed(1, payload_mean_, msg);
-  }
-
-  // Field 2: payload_stddev
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeFixed(2, payload_stddev_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(1, prefix_, msg);
   }
 
-  // Field 3: rate_mean
+  // Field 3: atrace_msg
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeFixed(3, rate_mean_, msg);
-  }
-
-  // Field 4: rate_stddev
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeFixed(4, rate_stddev_, msg);
+    (*atrace_msg_).Serialize(msg->BeginNestedMessage<::protozero::Message>(3));
   }
 
-  // Field 5: payload_write_time_ms
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(5, payload_write_time_ms_, msg);
+  // Field 2: allow
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, allow_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/test_config.gen.cc
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/test_config.gen.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
 
-TestConfig::TestConfig() = default;
-TestConfig::~TestConfig() = default;
-TestConfig::TestConfig(const TestConfig&) = default;
-TestConfig& TestConfig::operator=(const TestConfig&) = default;
-TestConfig::TestConfig(TestConfig&&) noexcept = default;
-TestConfig& TestConfig::operator=(TestConfig&&) = default;
+FtraceConfig_PrintFilter_Rule_AtraceMessage::FtraceConfig_PrintFilter_Rule_AtraceMessage() = default;
+FtraceConfig_PrintFilter_Rule_AtraceMessage::~FtraceConfig_PrintFilter_Rule_AtraceMessage() = default;
+FtraceConfig_PrintFilter_Rule_AtraceMessage::FtraceConfig_PrintFilter_Rule_AtraceMessage(const FtraceConfig_PrintFilter_Rule_AtraceMessage&) = default;
+FtraceConfig_PrintFilter_Rule_AtraceMessage& FtraceConfig_PrintFilter_Rule_AtraceMessage::operator=(const FtraceConfig_PrintFilter_Rule_AtraceMessage&) = default;
+FtraceConfig_PrintFilter_Rule_AtraceMessage::FtraceConfig_PrintFilter_Rule_AtraceMessage(FtraceConfig_PrintFilter_Rule_AtraceMessage&&) noexcept = default;
+FtraceConfig_PrintFilter_Rule_AtraceMessage& FtraceConfig_PrintFilter_Rule_AtraceMessage::operator=(FtraceConfig_PrintFilter_Rule_AtraceMessage&&) = default;
 
-bool TestConfig::operator==(const TestConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && message_count_ == other.message_count_
-   && max_messages_per_second_ == other.max_messages_per_second_
-   && seed_ == other.seed_
-   && message_size_ == other.message_size_
-   && send_batch_on_register_ == other.send_batch_on_register_
-   && dummy_fields_ == other.dummy_fields_;
+bool FtraceConfig_PrintFilter_Rule_AtraceMessage::operator==(const FtraceConfig_PrintFilter_Rule_AtraceMessage& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(type_, other.type_)
+   && ::protozero::internal::gen_helpers::EqualsField(prefix_, other.prefix_);
 }
 
-bool TestConfig::ParseFromArray(const void* raw, size_t size) {
+bool FtraceConfig_PrintFilter_Rule_AtraceMessage::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -26088,23 +22728,11 @@ bool TestConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* message_count */:
-        field.get(&message_count_);
-        break;
-      case 2 /* max_messages_per_second */:
-        field.get(&max_messages_per_second_);
-        break;
-      case 3 /* seed */:
-        field.get(&seed_);
-        break;
-      case 4 /* message_size */:
-        field.get(&message_size_);
-        break;
-      case 5 /* send_batch_on_register */:
-        field.get(&send_batch_on_register_);
+      case 1 /* type */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &type_);
         break;
-      case 6 /* dummy_fields */:
-        (*dummy_fields_).ParseFromArray(field.data(), field.size());
+      case 2 /* prefix */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &prefix_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -26114,79 +22742,127 @@ bool TestConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TestConfig::SerializeAsString() const {
+std::string FtraceConfig_PrintFilter_Rule_AtraceMessage::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TestConfig::SerializeAsArray() const {
+std::vector<uint8_t> FtraceConfig_PrintFilter_Rule_AtraceMessage::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TestConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: message_count
+void FtraceConfig_PrintFilter_Rule_AtraceMessage::Serialize(::protozero::Message* msg) const {
+  // Field 1: type
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, message_count_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(1, type_, msg);
   }
 
-  // Field 2: max_messages_per_second
+  // Field 2: prefix
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, max_messages_per_second_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(2, prefix_, msg);
   }
 
-  // Field 3: seed
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, seed_, msg);
-  }
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  // Field 4: message_size
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, message_size_, msg);
-  }
 
-  // Field 5: send_batch_on_register
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, send_batch_on_register_, msg);
+FtraceConfig_CompactSchedConfig::FtraceConfig_CompactSchedConfig() = default;
+FtraceConfig_CompactSchedConfig::~FtraceConfig_CompactSchedConfig() = default;
+FtraceConfig_CompactSchedConfig::FtraceConfig_CompactSchedConfig(const FtraceConfig_CompactSchedConfig&) = default;
+FtraceConfig_CompactSchedConfig& FtraceConfig_CompactSchedConfig::operator=(const FtraceConfig_CompactSchedConfig&) = default;
+FtraceConfig_CompactSchedConfig::FtraceConfig_CompactSchedConfig(FtraceConfig_CompactSchedConfig&&) noexcept = default;
+FtraceConfig_CompactSchedConfig& FtraceConfig_CompactSchedConfig::operator=(FtraceConfig_CompactSchedConfig&&) = default;
+
+bool FtraceConfig_CompactSchedConfig::operator==(const FtraceConfig_CompactSchedConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(enabled_, other.enabled_);
+}
+
+bool FtraceConfig_CompactSchedConfig::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* enabled */:
+        field.get(&enabled_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
   }
+  return !packed_error && !dec.bytes_left();
+}
 
-  // Field 6: dummy_fields
-  if (_has_field_[6]) {
-    (*dummy_fields_).Serialize(msg->BeginNestedMessage<::protozero::Message>(6));
+std::string FtraceConfig_CompactSchedConfig::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> FtraceConfig_CompactSchedConfig::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void FtraceConfig_CompactSchedConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: enabled
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(1, enabled_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/gpu/gpu_counter_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/gpu/gpu_counter_config.gen.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-TestConfig_DummyFields::TestConfig_DummyFields() = default;
-TestConfig_DummyFields::~TestConfig_DummyFields() = default;
-TestConfig_DummyFields::TestConfig_DummyFields(const TestConfig_DummyFields&) = default;
-TestConfig_DummyFields& TestConfig_DummyFields::operator=(const TestConfig_DummyFields&) = default;
-TestConfig_DummyFields::TestConfig_DummyFields(TestConfig_DummyFields&&) noexcept = default;
-TestConfig_DummyFields& TestConfig_DummyFields::operator=(TestConfig_DummyFields&&) = default;
+GpuCounterConfig::GpuCounterConfig() = default;
+GpuCounterConfig::~GpuCounterConfig() = default;
+GpuCounterConfig::GpuCounterConfig(const GpuCounterConfig&) = default;
+GpuCounterConfig& GpuCounterConfig::operator=(const GpuCounterConfig&) = default;
+GpuCounterConfig::GpuCounterConfig(GpuCounterConfig&&) noexcept = default;
+GpuCounterConfig& GpuCounterConfig::operator=(GpuCounterConfig&&) = default;
 
-bool TestConfig_DummyFields::operator==(const TestConfig_DummyFields& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && field_uint32_ == other.field_uint32_
-   && field_int32_ == other.field_int32_
-   && field_uint64_ == other.field_uint64_
-   && field_int64_ == other.field_int64_
-   && field_fixed64_ == other.field_fixed64_
-   && field_sfixed64_ == other.field_sfixed64_
-   && field_fixed32_ == other.field_fixed32_
-   && field_sfixed32_ == other.field_sfixed32_
-   && field_double_ == other.field_double_
-   && field_float_ == other.field_float_
-   && field_sint64_ == other.field_sint64_
-   && field_sint32_ == other.field_sint32_
-   && field_string_ == other.field_string_
-   && field_bytes_ == other.field_bytes_;
+bool GpuCounterConfig::operator==(const GpuCounterConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(counter_period_ns_, other.counter_period_ns_)
+   && ::protozero::internal::gen_helpers::EqualsField(counter_ids_, other.counter_ids_)
+   && ::protozero::internal::gen_helpers::EqualsField(instrumented_sampling_, other.instrumented_sampling_)
+   && ::protozero::internal::gen_helpers::EqualsField(fix_gpu_clock_, other.fix_gpu_clock_);
 }
 
-bool TestConfig_DummyFields::ParseFromArray(const void* raw, size_t size) {
+bool GpuCounterConfig::ParseFromArray(const void* raw, size_t size) {
+  counter_ids_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -26196,47 +22872,18 @@ bool TestConfig_DummyFields::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* field_uint32 */:
-        field.get(&field_uint32_);
-        break;
-      case 2 /* field_int32 */:
-        field.get(&field_int32_);
-        break;
-      case 3 /* field_uint64 */:
-        field.get(&field_uint64_);
-        break;
-      case 4 /* field_int64 */:
-        field.get(&field_int64_);
-        break;
-      case 5 /* field_fixed64 */:
-        field.get(&field_fixed64_);
-        break;
-      case 6 /* field_sfixed64 */:
-        field.get(&field_sfixed64_);
-        break;
-      case 7 /* field_fixed32 */:
-        field.get(&field_fixed32_);
-        break;
-      case 8 /* field_sfixed32 */:
-        field.get(&field_sfixed32_);
-        break;
-      case 9 /* field_double */:
-        field.get(&field_double_);
-        break;
-      case 10 /* field_float */:
-        field.get(&field_float_);
-        break;
-      case 11 /* field_sint64 */:
-        field.get_signed(&field_sint64_);
+      case 1 /* counter_period_ns */:
+        field.get(&counter_period_ns_);
         break;
-      case 12 /* field_sint32 */:
-        field.get_signed(&field_sint32_);
+      case 2 /* counter_ids */:
+        counter_ids_.emplace_back();
+        field.get(&counter_ids_.back());
         break;
-      case 13 /* field_string */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &field_string_);
+      case 3 /* instrumented_sampling */:
+        field.get(&instrumented_sampling_);
         break;
-      case 14 /* field_bytes */:
-        field.get(&field_bytes_);
+      case 4 /* fix_gpu_clock */:
+        field.get(&fix_gpu_clock_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -26246,87 +22893,134 @@ bool TestConfig_DummyFields::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TestConfig_DummyFields::SerializeAsString() const {
+std::string GpuCounterConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TestConfig_DummyFields::SerializeAsArray() const {
+std::vector<uint8_t> GpuCounterConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TestConfig_DummyFields::Serialize(::protozero::Message* msg) const {
-  // Field 1: field_uint32
+void GpuCounterConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: counter_period_ns
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, field_uint32_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, counter_period_ns_, msg);
   }
 
-  // Field 2: field_int32
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, field_int32_, msg);
+  // Field 2: counter_ids
+  for (auto& it : counter_ids_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, it, msg);
   }
 
-  // Field 3: field_uint64
+  // Field 3: instrumented_sampling
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, field_uint64_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, instrumented_sampling_, msg);
   }
 
-  // Field 4: field_int64
+  // Field 4: fix_gpu_clock
   if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, field_int64_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(4, fix_gpu_clock_, msg);
   }
 
-  // Field 5: field_fixed64
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeFixed(5, field_fixed64_, msg);
-  }
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  // Field 6: field_sfixed64
-  if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeFixed(6, field_sfixed64_, msg);
-  }
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/gpu/gpu_renderstages_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/gpu/gpu_renderstages_config.gen.h"
 
-  // Field 7: field_fixed32
-  if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeFixed(7, field_fixed32_, msg);
-  }
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-  // Field 8: field_sfixed32
-  if (_has_field_[8]) {
-    ::protozero::internal::gen_helpers::SerializeFixed(8, field_sfixed32_, msg);
-  }
+GpuRenderStagesConfig::GpuRenderStagesConfig() = default;
+GpuRenderStagesConfig::~GpuRenderStagesConfig() = default;
+GpuRenderStagesConfig::GpuRenderStagesConfig(const GpuRenderStagesConfig&) = default;
+GpuRenderStagesConfig& GpuRenderStagesConfig::operator=(const GpuRenderStagesConfig&) = default;
+GpuRenderStagesConfig::GpuRenderStagesConfig(GpuRenderStagesConfig&&) noexcept = default;
+GpuRenderStagesConfig& GpuRenderStagesConfig::operator=(GpuRenderStagesConfig&&) = default;
 
-  // Field 9: field_double
-  if (_has_field_[9]) {
-    ::protozero::internal::gen_helpers::SerializeFixed(9, field_double_, msg);
-  }
+bool GpuRenderStagesConfig::operator==(const GpuRenderStagesConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(full_loadstore_, other.full_loadstore_)
+   && ::protozero::internal::gen_helpers::EqualsField(low_overhead_, other.low_overhead_)
+   && ::protozero::internal::gen_helpers::EqualsField(trace_metrics_, other.trace_metrics_);
+}
 
-  // Field 10: field_float
-  if (_has_field_[10]) {
-    ::protozero::internal::gen_helpers::SerializeFixed(10, field_float_, msg);
-  }
+bool GpuRenderStagesConfig::ParseFromArray(const void* raw, size_t size) {
+  trace_metrics_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  // Field 11: field_sint64
-  if (_has_field_[11]) {
-    ::protozero::internal::gen_helpers::SerializeSignedVarInt(11, field_sint64_, msg);
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* full_loadstore */:
+        field.get(&full_loadstore_);
+        break;
+      case 2 /* low_overhead */:
+        field.get(&low_overhead_);
+        break;
+      case 3 /* trace_metrics */:
+        trace_metrics_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &trace_metrics_.back());
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
   }
+  return !packed_error && !dec.bytes_left();
+}
 
-  // Field 12: field_sint32
-  if (_has_field_[12]) {
-    ::protozero::internal::gen_helpers::SerializeSignedVarInt(12, field_sint32_, msg);
+std::string GpuRenderStagesConfig::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> GpuRenderStagesConfig::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void GpuRenderStagesConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: full_loadstore
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(1, full_loadstore_, msg);
   }
 
-  // Field 13: field_string
-  if (_has_field_[13]) {
-    ::protozero::internal::gen_helpers::SerializeString(13, field_string_, msg);
+  // Field 2: low_overhead
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, low_overhead_, msg);
   }
 
-  // Field 14: field_bytes
-  if (_has_field_[14]) {
-    ::protozero::internal::gen_helpers::SerializeString(14, field_bytes_, msg);
+  // Field 3: trace_metrics
+  for (auto& it : trace_metrics_) {
+    ::protozero::internal::gen_helpers::SerializeString(3, it, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -26338,7 +23032,7 @@ void TestConfig_DummyFields::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/trace_config.gen.cc
+// gen_amalgamated begin source: gen/protos/perfetto/config/gpu/vulkan_memory_config.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -26349,99 +23043,26 @@ void TestConfig_DummyFields::Serialize(::protozero::Message* msg) const {
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/config/trace_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/data_source_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/system_info/system_info.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/track_event/track_event_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/test_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/sys_stats/sys_stats_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/common/sys_stats_counters.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/perf_event_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/common/perf_events.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/java_hprof_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/heapprofd_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/process_stats/process_stats_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/statsd/statsd_tracing_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/statsd/atom_ids.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/power/android_power_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/interceptor_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/interceptors/console_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/inode_file/inode_file_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/gpu/vulkan_memory_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/gpu/gpu_counter_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/ftrace/ftrace_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/chrome_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/android/packages_list_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/android/network_trace_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_system_property_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_polled_state_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_log_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/common/android_log_constants.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_game_intervention_list_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/common/builtin_clock.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-TraceConfig::TraceConfig() = default;
-TraceConfig::~TraceConfig() = default;
-TraceConfig::TraceConfig(const TraceConfig&) = default;
-TraceConfig& TraceConfig::operator=(const TraceConfig&) = default;
-TraceConfig::TraceConfig(TraceConfig&&) noexcept = default;
-TraceConfig& TraceConfig::operator=(TraceConfig&&) = default;
+VulkanMemoryConfig::VulkanMemoryConfig() = default;
+VulkanMemoryConfig::~VulkanMemoryConfig() = default;
+VulkanMemoryConfig::VulkanMemoryConfig(const VulkanMemoryConfig&) = default;
+VulkanMemoryConfig& VulkanMemoryConfig::operator=(const VulkanMemoryConfig&) = default;
+VulkanMemoryConfig::VulkanMemoryConfig(VulkanMemoryConfig&&) noexcept = default;
+VulkanMemoryConfig& VulkanMemoryConfig::operator=(VulkanMemoryConfig&&) = default;
 
-bool TraceConfig::operator==(const TraceConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && buffers_ == other.buffers_
-   && data_sources_ == other.data_sources_
-   && builtin_data_sources_ == other.builtin_data_sources_
-   && duration_ms_ == other.duration_ms_
-   && prefer_suspend_clock_for_duration_ == other.prefer_suspend_clock_for_duration_
-   && enable_extra_guardrails_ == other.enable_extra_guardrails_
-   && lockdown_mode_ == other.lockdown_mode_
-   && producers_ == other.producers_
-   && statsd_metadata_ == other.statsd_metadata_
-   && write_into_file_ == other.write_into_file_
-   && output_path_ == other.output_path_
-   && file_write_period_ms_ == other.file_write_period_ms_
-   && max_file_size_bytes_ == other.max_file_size_bytes_
-   && guardrail_overrides_ == other.guardrail_overrides_
-   && deferred_start_ == other.deferred_start_
-   && flush_period_ms_ == other.flush_period_ms_
-   && flush_timeout_ms_ == other.flush_timeout_ms_
-   && data_source_stop_timeout_ms_ == other.data_source_stop_timeout_ms_
-   && notify_traceur_ == other.notify_traceur_
-   && bugreport_score_ == other.bugreport_score_
-   && trigger_config_ == other.trigger_config_
-   && activate_triggers_ == other.activate_triggers_
-   && incremental_state_config_ == other.incremental_state_config_
-   && allow_user_build_tracing_ == other.allow_user_build_tracing_
-   && unique_session_name_ == other.unique_session_name_
-   && compression_type_ == other.compression_type_
-   && incident_report_config_ == other.incident_report_config_
-   && statsd_logging_ == other.statsd_logging_
-   && trace_uuid_msb_ == other.trace_uuid_msb_
-   && trace_uuid_lsb_ == other.trace_uuid_lsb_
-   && trace_filter_ == other.trace_filter_
-   && android_report_config_ == other.android_report_config_
-   && cmd_trace_start_delay_ == other.cmd_trace_start_delay_;
+bool VulkanMemoryConfig::operator==(const VulkanMemoryConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(track_driver_memory_usage_, other.track_driver_memory_usage_)
+   && ::protozero::internal::gen_helpers::EqualsField(track_device_memory_usage_, other.track_device_memory_usage_);
 }
 
-int TraceConfig::buffers_size() const { return static_cast<int>(buffers_.size()); }
-void TraceConfig::clear_buffers() { buffers_.clear(); }
-TraceConfig_BufferConfig* TraceConfig::add_buffers() { buffers_.emplace_back(); return &buffers_.back(); }
-int TraceConfig::data_sources_size() const { return static_cast<int>(data_sources_.size()); }
-void TraceConfig::clear_data_sources() { data_sources_.clear(); }
-TraceConfig_DataSource* TraceConfig::add_data_sources() { data_sources_.emplace_back(); return &data_sources_.back(); }
-int TraceConfig::producers_size() const { return static_cast<int>(producers_.size()); }
-void TraceConfig::clear_producers() { producers_.clear(); }
-TraceConfig_ProducerConfig* TraceConfig::add_producers() { producers_.emplace_back(); return &producers_.back(); }
-bool TraceConfig::ParseFromArray(const void* raw, size_t size) {
-  buffers_.clear();
-  data_sources_.clear();
-  producers_.clear();
-  activate_triggers_.clear();
+bool VulkanMemoryConfig::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -26451,108 +23072,11 @@ bool TraceConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* buffers */:
-        buffers_.emplace_back();
-        buffers_.back().ParseFromArray(field.data(), field.size());
-        break;
-      case 2 /* data_sources */:
-        data_sources_.emplace_back();
-        data_sources_.back().ParseFromArray(field.data(), field.size());
-        break;
-      case 20 /* builtin_data_sources */:
-        (*builtin_data_sources_).ParseFromArray(field.data(), field.size());
-        break;
-      case 3 /* duration_ms */:
-        field.get(&duration_ms_);
-        break;
-      case 36 /* prefer_suspend_clock_for_duration */:
-        field.get(&prefer_suspend_clock_for_duration_);
-        break;
-      case 4 /* enable_extra_guardrails */:
-        field.get(&enable_extra_guardrails_);
-        break;
-      case 5 /* lockdown_mode */:
-        field.get(&lockdown_mode_);
-        break;
-      case 6 /* producers */:
-        producers_.emplace_back();
-        producers_.back().ParseFromArray(field.data(), field.size());
-        break;
-      case 7 /* statsd_metadata */:
-        (*statsd_metadata_).ParseFromArray(field.data(), field.size());
-        break;
-      case 8 /* write_into_file */:
-        field.get(&write_into_file_);
-        break;
-      case 29 /* output_path */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &output_path_);
-        break;
-      case 9 /* file_write_period_ms */:
-        field.get(&file_write_period_ms_);
-        break;
-      case 10 /* max_file_size_bytes */:
-        field.get(&max_file_size_bytes_);
-        break;
-      case 11 /* guardrail_overrides */:
-        (*guardrail_overrides_).ParseFromArray(field.data(), field.size());
-        break;
-      case 12 /* deferred_start */:
-        field.get(&deferred_start_);
-        break;
-      case 13 /* flush_period_ms */:
-        field.get(&flush_period_ms_);
-        break;
-      case 14 /* flush_timeout_ms */:
-        field.get(&flush_timeout_ms_);
-        break;
-      case 23 /* data_source_stop_timeout_ms */:
-        field.get(&data_source_stop_timeout_ms_);
-        break;
-      case 16 /* notify_traceur */:
-        field.get(&notify_traceur_);
-        break;
-      case 30 /* bugreport_score */:
-        field.get(&bugreport_score_);
-        break;
-      case 17 /* trigger_config */:
-        (*trigger_config_).ParseFromArray(field.data(), field.size());
-        break;
-      case 18 /* activate_triggers */:
-        activate_triggers_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &activate_triggers_.back());
-        break;
-      case 21 /* incremental_state_config */:
-        (*incremental_state_config_).ParseFromArray(field.data(), field.size());
-        break;
-      case 19 /* allow_user_build_tracing */:
-        field.get(&allow_user_build_tracing_);
-        break;
-      case 22 /* unique_session_name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &unique_session_name_);
-        break;
-      case 24 /* compression_type */:
-        field.get(&compression_type_);
-        break;
-      case 25 /* incident_report_config */:
-        (*incident_report_config_).ParseFromArray(field.data(), field.size());
-        break;
-      case 31 /* statsd_logging */:
-        field.get(&statsd_logging_);
-        break;
-      case 27 /* trace_uuid_msb */:
-        field.get(&trace_uuid_msb_);
-        break;
-      case 28 /* trace_uuid_lsb */:
-        field.get(&trace_uuid_lsb_);
-        break;
-      case 33 /* trace_filter */:
-        (*trace_filter_).ParseFromArray(field.data(), field.size());
-        break;
-      case 34 /* android_report_config */:
-        (*android_report_config_).ParseFromArray(field.data(), field.size());
+      case 1 /* track_driver_memory_usage */:
+        field.get(&track_driver_memory_usage_);
         break;
-      case 35 /* cmd_trace_start_delay */:
-        (*cmd_trace_start_delay_).ParseFromArray(field.data(), field.size());
+      case 2 /* track_device_memory_usage */:
+        field.get(&track_device_memory_usage_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -26562,204 +23086,80 @@ bool TraceConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TraceConfig::SerializeAsString() const {
+std::string VulkanMemoryConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TraceConfig::SerializeAsArray() const {
+std::vector<uint8_t> VulkanMemoryConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TraceConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: buffers
-  for (auto& it : buffers_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
-  }
-
-  // Field 2: data_sources
-  for (auto& it : data_sources_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
-  }
-
-  // Field 20: builtin_data_sources
-  if (_has_field_[20]) {
-    (*builtin_data_sources_).Serialize(msg->BeginNestedMessage<::protozero::Message>(20));
+void VulkanMemoryConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: track_driver_memory_usage
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(1, track_driver_memory_usage_, msg);
   }
 
-  // Field 3: duration_ms
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, duration_ms_, msg);
+  // Field 2: track_device_memory_usage
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, track_device_memory_usage_, msg);
   }
 
-  // Field 36: prefer_suspend_clock_for_duration
-  if (_has_field_[36]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(36, prefer_suspend_clock_for_duration_, msg);
-  }
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  // Field 4: enable_extra_guardrails
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(4, enable_extra_guardrails_, msg);
-  }
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/inode_file/inode_file_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/inode_file/inode_file_config.gen.h"
 
-  // Field 5: lockdown_mode
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(5, lockdown_mode_, msg);
-  }
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-  // Field 6: producers
-  for (auto& it : producers_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(6));
-  }
+InodeFileConfig::InodeFileConfig() = default;
+InodeFileConfig::~InodeFileConfig() = default;
+InodeFileConfig::InodeFileConfig(const InodeFileConfig&) = default;
+InodeFileConfig& InodeFileConfig::operator=(const InodeFileConfig&) = default;
+InodeFileConfig::InodeFileConfig(InodeFileConfig&&) noexcept = default;
+InodeFileConfig& InodeFileConfig::operator=(InodeFileConfig&&) = default;
 
-  // Field 7: statsd_metadata
-  if (_has_field_[7]) {
-    (*statsd_metadata_).Serialize(msg->BeginNestedMessage<::protozero::Message>(7));
-  }
+bool InodeFileConfig::operator==(const InodeFileConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(scan_interval_ms_, other.scan_interval_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(scan_delay_ms_, other.scan_delay_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(scan_batch_size_, other.scan_batch_size_)
+   && ::protozero::internal::gen_helpers::EqualsField(do_not_scan_, other.do_not_scan_)
+   && ::protozero::internal::gen_helpers::EqualsField(scan_mount_points_, other.scan_mount_points_)
+   && ::protozero::internal::gen_helpers::EqualsField(mount_point_mapping_, other.mount_point_mapping_);
+}
 
-  // Field 8: write_into_file
-  if (_has_field_[8]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(8, write_into_file_, msg);
-  }
-
-  // Field 29: output_path
-  if (_has_field_[29]) {
-    ::protozero::internal::gen_helpers::SerializeString(29, output_path_, msg);
-  }
-
-  // Field 9: file_write_period_ms
-  if (_has_field_[9]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(9, file_write_period_ms_, msg);
-  }
-
-  // Field 10: max_file_size_bytes
-  if (_has_field_[10]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(10, max_file_size_bytes_, msg);
-  }
-
-  // Field 11: guardrail_overrides
-  if (_has_field_[11]) {
-    (*guardrail_overrides_).Serialize(msg->BeginNestedMessage<::protozero::Message>(11));
-  }
-
-  // Field 12: deferred_start
-  if (_has_field_[12]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(12, deferred_start_, msg);
-  }
-
-  // Field 13: flush_period_ms
-  if (_has_field_[13]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(13, flush_period_ms_, msg);
-  }
-
-  // Field 14: flush_timeout_ms
-  if (_has_field_[14]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(14, flush_timeout_ms_, msg);
-  }
-
-  // Field 23: data_source_stop_timeout_ms
-  if (_has_field_[23]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(23, data_source_stop_timeout_ms_, msg);
-  }
-
-  // Field 16: notify_traceur
-  if (_has_field_[16]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(16, notify_traceur_, msg);
-  }
-
-  // Field 30: bugreport_score
-  if (_has_field_[30]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(30, bugreport_score_, msg);
-  }
-
-  // Field 17: trigger_config
-  if (_has_field_[17]) {
-    (*trigger_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(17));
-  }
-
-  // Field 18: activate_triggers
-  for (auto& it : activate_triggers_) {
-    ::protozero::internal::gen_helpers::SerializeString(18, it, msg);
-  }
-
-  // Field 21: incremental_state_config
-  if (_has_field_[21]) {
-    (*incremental_state_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(21));
-  }
-
-  // Field 19: allow_user_build_tracing
-  if (_has_field_[19]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(19, allow_user_build_tracing_, msg);
-  }
-
-  // Field 22: unique_session_name
-  if (_has_field_[22]) {
-    ::protozero::internal::gen_helpers::SerializeString(22, unique_session_name_, msg);
-  }
-
-  // Field 24: compression_type
-  if (_has_field_[24]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(24, compression_type_, msg);
-  }
-
-  // Field 25: incident_report_config
-  if (_has_field_[25]) {
-    (*incident_report_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(25));
-  }
-
-  // Field 31: statsd_logging
-  if (_has_field_[31]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(31, statsd_logging_, msg);
-  }
-
-  // Field 27: trace_uuid_msb
-  if (_has_field_[27]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(27, trace_uuid_msb_, msg);
-  }
-
-  // Field 28: trace_uuid_lsb
-  if (_has_field_[28]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(28, trace_uuid_lsb_, msg);
-  }
-
-  // Field 33: trace_filter
-  if (_has_field_[33]) {
-    (*trace_filter_).Serialize(msg->BeginNestedMessage<::protozero::Message>(33));
-  }
-
-  // Field 34: android_report_config
-  if (_has_field_[34]) {
-    (*android_report_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(34));
-  }
-
-  // Field 35: cmd_trace_start_delay
-  if (_has_field_[35]) {
-    (*cmd_trace_start_delay_).Serialize(msg->BeginNestedMessage<::protozero::Message>(35));
-  }
-
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
-}
-
-
-TraceConfig_CmdTraceStartDelay::TraceConfig_CmdTraceStartDelay() = default;
-TraceConfig_CmdTraceStartDelay::~TraceConfig_CmdTraceStartDelay() = default;
-TraceConfig_CmdTraceStartDelay::TraceConfig_CmdTraceStartDelay(const TraceConfig_CmdTraceStartDelay&) = default;
-TraceConfig_CmdTraceStartDelay& TraceConfig_CmdTraceStartDelay::operator=(const TraceConfig_CmdTraceStartDelay&) = default;
-TraceConfig_CmdTraceStartDelay::TraceConfig_CmdTraceStartDelay(TraceConfig_CmdTraceStartDelay&&) noexcept = default;
-TraceConfig_CmdTraceStartDelay& TraceConfig_CmdTraceStartDelay::operator=(TraceConfig_CmdTraceStartDelay&&) = default;
-
-bool TraceConfig_CmdTraceStartDelay::operator==(const TraceConfig_CmdTraceStartDelay& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && min_delay_ms_ == other.min_delay_ms_
-   && max_delay_ms_ == other.max_delay_ms_;
-}
-
-bool TraceConfig_CmdTraceStartDelay::ParseFromArray(const void* raw, size_t size) {
-  unknown_fields_.clear();
-  bool packed_error = false;
+int InodeFileConfig::mount_point_mapping_size() const { return static_cast<int>(mount_point_mapping_.size()); }
+void InodeFileConfig::clear_mount_point_mapping() { mount_point_mapping_.clear(); }
+InodeFileConfig_MountPointMappingEntry* InodeFileConfig::add_mount_point_mapping() { mount_point_mapping_.emplace_back(); return &mount_point_mapping_.back(); }
+bool InodeFileConfig::ParseFromArray(const void* raw, size_t size) {
+  scan_mount_points_.clear();
+  mount_point_mapping_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
 
   ::protozero::ProtoDecoder dec(raw, size);
   for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
@@ -26767,11 +23167,25 @@ bool TraceConfig_CmdTraceStartDelay::ParseFromArray(const void* raw, size_t size
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* min_delay_ms */:
-        field.get(&min_delay_ms_);
+      case 1 /* scan_interval_ms */:
+        field.get(&scan_interval_ms_);
         break;
-      case 2 /* max_delay_ms */:
-        field.get(&max_delay_ms_);
+      case 2 /* scan_delay_ms */:
+        field.get(&scan_delay_ms_);
+        break;
+      case 3 /* scan_batch_size */:
+        field.get(&scan_batch_size_);
+        break;
+      case 4 /* do_not_scan */:
+        field.get(&do_not_scan_);
+        break;
+      case 5 /* scan_mount_points */:
+        scan_mount_points_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &scan_mount_points_.back());
+        break;
+      case 6 /* mount_point_mapping */:
+        mount_point_mapping_.emplace_back();
+        mount_point_mapping_.back().ParseFromArray(field.data(), field.size());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -26781,49 +23195,68 @@ bool TraceConfig_CmdTraceStartDelay::ParseFromArray(const void* raw, size_t size
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TraceConfig_CmdTraceStartDelay::SerializeAsString() const {
+std::string InodeFileConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TraceConfig_CmdTraceStartDelay::SerializeAsArray() const {
+std::vector<uint8_t> InodeFileConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TraceConfig_CmdTraceStartDelay::Serialize(::protozero::Message* msg) const {
-  // Field 1: min_delay_ms
+void InodeFileConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: scan_interval_ms
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, min_delay_ms_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, scan_interval_ms_, msg);
   }
 
-  // Field 2: max_delay_ms
+  // Field 2: scan_delay_ms
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, max_delay_ms_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, scan_delay_ms_, msg);
+  }
+
+  // Field 3: scan_batch_size
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, scan_batch_size_, msg);
+  }
+
+  // Field 4: do_not_scan
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(4, do_not_scan_, msg);
+  }
+
+  // Field 5: scan_mount_points
+  for (auto& it : scan_mount_points_) {
+    ::protozero::internal::gen_helpers::SerializeString(5, it, msg);
+  }
+
+  // Field 6: mount_point_mapping
+  for (auto& it : mount_point_mapping_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(6));
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-TraceConfig_AndroidReportConfig::TraceConfig_AndroidReportConfig() = default;
-TraceConfig_AndroidReportConfig::~TraceConfig_AndroidReportConfig() = default;
-TraceConfig_AndroidReportConfig::TraceConfig_AndroidReportConfig(const TraceConfig_AndroidReportConfig&) = default;
-TraceConfig_AndroidReportConfig& TraceConfig_AndroidReportConfig::operator=(const TraceConfig_AndroidReportConfig&) = default;
-TraceConfig_AndroidReportConfig::TraceConfig_AndroidReportConfig(TraceConfig_AndroidReportConfig&&) noexcept = default;
-TraceConfig_AndroidReportConfig& TraceConfig_AndroidReportConfig::operator=(TraceConfig_AndroidReportConfig&&) = default;
+InodeFileConfig_MountPointMappingEntry::InodeFileConfig_MountPointMappingEntry() = default;
+InodeFileConfig_MountPointMappingEntry::~InodeFileConfig_MountPointMappingEntry() = default;
+InodeFileConfig_MountPointMappingEntry::InodeFileConfig_MountPointMappingEntry(const InodeFileConfig_MountPointMappingEntry&) = default;
+InodeFileConfig_MountPointMappingEntry& InodeFileConfig_MountPointMappingEntry::operator=(const InodeFileConfig_MountPointMappingEntry&) = default;
+InodeFileConfig_MountPointMappingEntry::InodeFileConfig_MountPointMappingEntry(InodeFileConfig_MountPointMappingEntry&&) noexcept = default;
+InodeFileConfig_MountPointMappingEntry& InodeFileConfig_MountPointMappingEntry::operator=(InodeFileConfig_MountPointMappingEntry&&) = default;
 
-bool TraceConfig_AndroidReportConfig::operator==(const TraceConfig_AndroidReportConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && reporter_service_package_ == other.reporter_service_package_
-   && reporter_service_class_ == other.reporter_service_class_
-   && skip_report_ == other.skip_report_
-   && use_pipe_in_framework_for_testing_ == other.use_pipe_in_framework_for_testing_;
+bool InodeFileConfig_MountPointMappingEntry::operator==(const InodeFileConfig_MountPointMappingEntry& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(mountpoint_, other.mountpoint_)
+   && ::protozero::internal::gen_helpers::EqualsField(scan_roots_, other.scan_roots_);
 }
 
-bool TraceConfig_AndroidReportConfig::ParseFromArray(const void* raw, size_t size) {
+bool InodeFileConfig_MountPointMappingEntry::ParseFromArray(const void* raw, size_t size) {
+  scan_roots_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -26833,17 +23266,12 @@ bool TraceConfig_AndroidReportConfig::ParseFromArray(const void* raw, size_t siz
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* reporter_service_package */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &reporter_service_package_);
-        break;
-      case 2 /* reporter_service_class */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &reporter_service_class_);
-        break;
-      case 3 /* skip_report */:
-        field.get(&skip_report_);
+      case 1 /* mountpoint */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &mountpoint_);
         break;
-      case 4 /* use_pipe_in_framework_for_testing */:
-        field.get(&use_pipe_in_framework_for_testing_);
+      case 2 /* scan_roots */:
+        scan_roots_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &scan_roots_.back());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -26853,56 +23281,69 @@ bool TraceConfig_AndroidReportConfig::ParseFromArray(const void* raw, size_t siz
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TraceConfig_AndroidReportConfig::SerializeAsString() const {
+std::string InodeFileConfig_MountPointMappingEntry::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TraceConfig_AndroidReportConfig::SerializeAsArray() const {
+std::vector<uint8_t> InodeFileConfig_MountPointMappingEntry::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TraceConfig_AndroidReportConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: reporter_service_package
+void InodeFileConfig_MountPointMappingEntry::Serialize(::protozero::Message* msg) const {
+  // Field 1: mountpoint
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeString(1, reporter_service_package_, msg);
-  }
-
-  // Field 2: reporter_service_class
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeString(2, reporter_service_class_, msg);
-  }
-
-  // Field 3: skip_report
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, skip_report_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(1, mountpoint_, msg);
   }
 
-  // Field 4: use_pipe_in_framework_for_testing
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(4, use_pipe_in_framework_for_testing_, msg);
+  // Field 2: scan_roots
+  for (auto& it : scan_roots_) {
+    ::protozero::internal::gen_helpers::SerializeString(2, it, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/interceptors/console_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/interceptors/console_config.gen.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-TraceConfig_TraceFilter::TraceConfig_TraceFilter() = default;
-TraceConfig_TraceFilter::~TraceConfig_TraceFilter() = default;
-TraceConfig_TraceFilter::TraceConfig_TraceFilter(const TraceConfig_TraceFilter&) = default;
-TraceConfig_TraceFilter& TraceConfig_TraceFilter::operator=(const TraceConfig_TraceFilter&) = default;
-TraceConfig_TraceFilter::TraceConfig_TraceFilter(TraceConfig_TraceFilter&&) noexcept = default;
-TraceConfig_TraceFilter& TraceConfig_TraceFilter::operator=(TraceConfig_TraceFilter&&) = default;
+ConsoleConfig::ConsoleConfig() = default;
+ConsoleConfig::~ConsoleConfig() = default;
+ConsoleConfig::ConsoleConfig(const ConsoleConfig&) = default;
+ConsoleConfig& ConsoleConfig::operator=(const ConsoleConfig&) = default;
+ConsoleConfig::ConsoleConfig(ConsoleConfig&&) noexcept = default;
+ConsoleConfig& ConsoleConfig::operator=(ConsoleConfig&&) = default;
 
-bool TraceConfig_TraceFilter::operator==(const TraceConfig_TraceFilter& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && bytecode_ == other.bytecode_;
+bool ConsoleConfig::operator==(const ConsoleConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(output_, other.output_)
+   && ::protozero::internal::gen_helpers::EqualsField(enable_colors_, other.enable_colors_);
 }
 
-bool TraceConfig_TraceFilter::ParseFromArray(const void* raw, size_t size) {
+bool ConsoleConfig::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -26912,8 +23353,11 @@ bool TraceConfig_TraceFilter::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* bytecode */:
-        field.get(&bytecode_);
+      case 1 /* output */:
+        field.get(&output_);
+        break;
+      case 2 /* enable_colors */:
+        field.get(&enable_colors_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -26923,45 +23367,73 @@ bool TraceConfig_TraceFilter::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TraceConfig_TraceFilter::SerializeAsString() const {
+std::string ConsoleConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TraceConfig_TraceFilter::SerializeAsArray() const {
+std::vector<uint8_t> ConsoleConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TraceConfig_TraceFilter::Serialize(::protozero::Message* msg) const {
-  // Field 1: bytecode
+void ConsoleConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: output
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeString(1, bytecode_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, output_, msg);
+  }
+
+  // Field 2: enable_colors
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, enable_colors_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/power/android_power_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/power/android_power_config.gen.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-TraceConfig_IncidentReportConfig::TraceConfig_IncidentReportConfig() = default;
-TraceConfig_IncidentReportConfig::~TraceConfig_IncidentReportConfig() = default;
-TraceConfig_IncidentReportConfig::TraceConfig_IncidentReportConfig(const TraceConfig_IncidentReportConfig&) = default;
-TraceConfig_IncidentReportConfig& TraceConfig_IncidentReportConfig::operator=(const TraceConfig_IncidentReportConfig&) = default;
-TraceConfig_IncidentReportConfig::TraceConfig_IncidentReportConfig(TraceConfig_IncidentReportConfig&&) noexcept = default;
-TraceConfig_IncidentReportConfig& TraceConfig_IncidentReportConfig::operator=(TraceConfig_IncidentReportConfig&&) = default;
+AndroidPowerConfig::AndroidPowerConfig() = default;
+AndroidPowerConfig::~AndroidPowerConfig() = default;
+AndroidPowerConfig::AndroidPowerConfig(const AndroidPowerConfig&) = default;
+AndroidPowerConfig& AndroidPowerConfig::operator=(const AndroidPowerConfig&) = default;
+AndroidPowerConfig::AndroidPowerConfig(AndroidPowerConfig&&) noexcept = default;
+AndroidPowerConfig& AndroidPowerConfig::operator=(AndroidPowerConfig&&) = default;
 
-bool TraceConfig_IncidentReportConfig::operator==(const TraceConfig_IncidentReportConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && destination_package_ == other.destination_package_
-   && destination_class_ == other.destination_class_
-   && privacy_level_ == other.privacy_level_
-   && skip_incidentd_ == other.skip_incidentd_
-   && skip_dropbox_ == other.skip_dropbox_;
+bool AndroidPowerConfig::operator==(const AndroidPowerConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(battery_poll_ms_, other.battery_poll_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(battery_counters_, other.battery_counters_)
+   && ::protozero::internal::gen_helpers::EqualsField(collect_power_rails_, other.collect_power_rails_)
+   && ::protozero::internal::gen_helpers::EqualsField(collect_energy_estimation_breakdown_, other.collect_energy_estimation_breakdown_)
+   && ::protozero::internal::gen_helpers::EqualsField(collect_entity_state_residency_, other.collect_entity_state_residency_);
 }
 
-bool TraceConfig_IncidentReportConfig::ParseFromArray(const void* raw, size_t size) {
+bool AndroidPowerConfig::ParseFromArray(const void* raw, size_t size) {
+  battery_counters_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -26971,20 +23443,21 @@ bool TraceConfig_IncidentReportConfig::ParseFromArray(const void* raw, size_t si
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* destination_package */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &destination_package_);
+      case 1 /* battery_poll_ms */:
+        field.get(&battery_poll_ms_);
         break;
-      case 2 /* destination_class */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &destination_class_);
+      case 2 /* battery_counters */:
+        battery_counters_.emplace_back();
+        field.get(&battery_counters_.back());
         break;
-      case 3 /* privacy_level */:
-        field.get(&privacy_level_);
+      case 3 /* collect_power_rails */:
+        field.get(&collect_power_rails_);
         break;
-      case 5 /* skip_incidentd */:
-        field.get(&skip_incidentd_);
+      case 4 /* collect_energy_estimation_breakdown */:
+        field.get(&collect_energy_estimation_breakdown_);
         break;
-      case 4 /* skip_dropbox */:
-        field.get(&skip_dropbox_);
+      case 5 /* collect_entity_state_residency */:
+        field.get(&collect_entity_state_residency_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -26994,61 +23467,84 @@ bool TraceConfig_IncidentReportConfig::ParseFromArray(const void* raw, size_t si
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TraceConfig_IncidentReportConfig::SerializeAsString() const {
+std::string AndroidPowerConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TraceConfig_IncidentReportConfig::SerializeAsArray() const {
+std::vector<uint8_t> AndroidPowerConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TraceConfig_IncidentReportConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: destination_package
+void AndroidPowerConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: battery_poll_ms
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeString(1, destination_package_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, battery_poll_ms_, msg);
   }
 
-  // Field 2: destination_class
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeString(2, destination_class_, msg);
+  // Field 2: battery_counters
+  for (auto& it : battery_counters_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, it, msg);
   }
 
-  // Field 3: privacy_level
+  // Field 3: collect_power_rails
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, privacy_level_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, collect_power_rails_, msg);
   }
 
-  // Field 5: skip_incidentd
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, skip_incidentd_, msg);
+  // Field 4: collect_energy_estimation_breakdown
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(4, collect_energy_estimation_breakdown_, msg);
   }
 
-  // Field 4: skip_dropbox
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(4, skip_dropbox_, msg);
+  // Field 5: collect_entity_state_residency
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, collect_entity_state_residency_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/priority_boost/priority_boost_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/priority_boost/priority_boost_config.gen.h"
 
-TraceConfig_IncrementalStateConfig::TraceConfig_IncrementalStateConfig() = default;
-TraceConfig_IncrementalStateConfig::~TraceConfig_IncrementalStateConfig() = default;
-TraceConfig_IncrementalStateConfig::TraceConfig_IncrementalStateConfig(const TraceConfig_IncrementalStateConfig&) = default;
-TraceConfig_IncrementalStateConfig& TraceConfig_IncrementalStateConfig::operator=(const TraceConfig_IncrementalStateConfig&) = default;
-TraceConfig_IncrementalStateConfig::TraceConfig_IncrementalStateConfig(TraceConfig_IncrementalStateConfig&&) noexcept = default;
-TraceConfig_IncrementalStateConfig& TraceConfig_IncrementalStateConfig::operator=(TraceConfig_IncrementalStateConfig&&) = default;
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-bool TraceConfig_IncrementalStateConfig::operator==(const TraceConfig_IncrementalStateConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && clear_period_ms_ == other.clear_period_ms_;
+PriorityBoostConfig::PriorityBoostConfig() = default;
+PriorityBoostConfig::~PriorityBoostConfig() = default;
+PriorityBoostConfig::PriorityBoostConfig(const PriorityBoostConfig&) = default;
+PriorityBoostConfig& PriorityBoostConfig::operator=(const PriorityBoostConfig&) = default;
+PriorityBoostConfig::PriorityBoostConfig(PriorityBoostConfig&&) noexcept = default;
+PriorityBoostConfig& PriorityBoostConfig::operator=(PriorityBoostConfig&&) = default;
+
+bool PriorityBoostConfig::operator==(const PriorityBoostConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(policy_, other.policy_)
+   && ::protozero::internal::gen_helpers::EqualsField(priority_, other.priority_);
 }
 
-bool TraceConfig_IncrementalStateConfig::ParseFromArray(const void* raw, size_t size) {
+bool PriorityBoostConfig::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -27058,8 +23554,11 @@ bool TraceConfig_IncrementalStateConfig::ParseFromArray(const void* raw, size_t
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* clear_period_ms */:
-        field.get(&clear_period_ms_);
+      case 1 /* policy */:
+        field.get(&policy_);
+        break;
+      case 2 /* priority */:
+        field.get(&priority_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -27069,47 +23568,78 @@ bool TraceConfig_IncrementalStateConfig::ParseFromArray(const void* raw, size_t
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TraceConfig_IncrementalStateConfig::SerializeAsString() const {
+std::string PriorityBoostConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TraceConfig_IncrementalStateConfig::SerializeAsArray() const {
+std::vector<uint8_t> PriorityBoostConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TraceConfig_IncrementalStateConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: clear_period_ms
+void PriorityBoostConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: policy
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, clear_period_ms_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, policy_, msg);
+  }
+
+  // Field 2: priority
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, priority_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/process_stats/process_stats_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/process_stats/process_stats_config.gen.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-TraceConfig_TriggerConfig::TraceConfig_TriggerConfig() = default;
-TraceConfig_TriggerConfig::~TraceConfig_TriggerConfig() = default;
-TraceConfig_TriggerConfig::TraceConfig_TriggerConfig(const TraceConfig_TriggerConfig&) = default;
-TraceConfig_TriggerConfig& TraceConfig_TriggerConfig::operator=(const TraceConfig_TriggerConfig&) = default;
-TraceConfig_TriggerConfig::TraceConfig_TriggerConfig(TraceConfig_TriggerConfig&&) noexcept = default;
-TraceConfig_TriggerConfig& TraceConfig_TriggerConfig::operator=(TraceConfig_TriggerConfig&&) = default;
+ProcessStatsConfig::ProcessStatsConfig() = default;
+ProcessStatsConfig::~ProcessStatsConfig() = default;
+ProcessStatsConfig::ProcessStatsConfig(const ProcessStatsConfig&) = default;
+ProcessStatsConfig& ProcessStatsConfig::operator=(const ProcessStatsConfig&) = default;
+ProcessStatsConfig::ProcessStatsConfig(ProcessStatsConfig&&) noexcept = default;
+ProcessStatsConfig& ProcessStatsConfig::operator=(ProcessStatsConfig&&) = default;
 
-bool TraceConfig_TriggerConfig::operator==(const TraceConfig_TriggerConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && trigger_mode_ == other.trigger_mode_
-   && triggers_ == other.triggers_
-   && trigger_timeout_ms_ == other.trigger_timeout_ms_;
+bool ProcessStatsConfig::operator==(const ProcessStatsConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(quirks_, other.quirks_)
+   && ::protozero::internal::gen_helpers::EqualsField(scan_all_processes_on_start_, other.scan_all_processes_on_start_)
+   && ::protozero::internal::gen_helpers::EqualsField(record_thread_names_, other.record_thread_names_)
+   && ::protozero::internal::gen_helpers::EqualsField(proc_stats_poll_ms_, other.proc_stats_poll_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(proc_stats_cache_ttl_ms_, other.proc_stats_cache_ttl_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(scan_smaps_rollup_, other.scan_smaps_rollup_)
+   && ::protozero::internal::gen_helpers::EqualsField(record_process_age_, other.record_process_age_)
+   && ::protozero::internal::gen_helpers::EqualsField(record_process_runtime_, other.record_process_runtime_)
+   && ::protozero::internal::gen_helpers::EqualsField(record_process_dmabuf_rss_, other.record_process_dmabuf_rss_)
+   && ::protozero::internal::gen_helpers::EqualsField(resolve_process_fds_, other.resolve_process_fds_);
 }
 
-int TraceConfig_TriggerConfig::triggers_size() const { return static_cast<int>(triggers_.size()); }
-void TraceConfig_TriggerConfig::clear_triggers() { triggers_.clear(); }
-TraceConfig_TriggerConfig_Trigger* TraceConfig_TriggerConfig::add_triggers() { triggers_.emplace_back(); return &triggers_.back(); }
-bool TraceConfig_TriggerConfig::ParseFromArray(const void* raw, size_t size) {
-  triggers_.clear();
+bool ProcessStatsConfig::ParseFromArray(const void* raw, size_t size) {
+  quirks_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -27119,15 +23649,36 @@ bool TraceConfig_TriggerConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* trigger_mode */:
-        field.get(&trigger_mode_);
+      case 1 /* quirks */:
+        quirks_.emplace_back();
+        field.get(&quirks_.back());
         break;
-      case 2 /* triggers */:
-        triggers_.emplace_back();
-        triggers_.back().ParseFromArray(field.data(), field.size());
+      case 2 /* scan_all_processes_on_start */:
+        field.get(&scan_all_processes_on_start_);
         break;
-      case 3 /* trigger_timeout_ms */:
-        field.get(&trigger_timeout_ms_);
+      case 3 /* record_thread_names */:
+        field.get(&record_thread_names_);
+        break;
+      case 4 /* proc_stats_poll_ms */:
+        field.get(&proc_stats_poll_ms_);
+        break;
+      case 6 /* proc_stats_cache_ttl_ms */:
+        field.get(&proc_stats_cache_ttl_ms_);
+        break;
+      case 10 /* scan_smaps_rollup */:
+        field.get(&scan_smaps_rollup_);
+        break;
+      case 11 /* record_process_age */:
+        field.get(&record_process_age_);
+        break;
+      case 12 /* record_process_runtime */:
+        field.get(&record_process_runtime_);
+        break;
+      case 13 /* record_process_dmabuf_rss */:
+        field.get(&record_process_dmabuf_rss_);
+        break;
+      case 9 /* resolve_process_fds */:
+        field.get(&resolve_process_fds_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -27137,55 +23688,139 @@ bool TraceConfig_TriggerConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TraceConfig_TriggerConfig::SerializeAsString() const {
+std::string ProcessStatsConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TraceConfig_TriggerConfig::SerializeAsArray() const {
+std::vector<uint8_t> ProcessStatsConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TraceConfig_TriggerConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: trigger_mode
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, trigger_mode_, msg);
+void ProcessStatsConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: quirks
+  for (auto& it : quirks_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, it, msg);
   }
 
-  // Field 2: triggers
-  for (auto& it : triggers_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
+  // Field 2: scan_all_processes_on_start
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, scan_all_processes_on_start_, msg);
   }
 
-  // Field 3: trigger_timeout_ms
+  // Field 3: record_thread_names
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, trigger_timeout_ms_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, record_thread_names_, msg);
+  }
+
+  // Field 4: proc_stats_poll_ms
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, proc_stats_poll_ms_, msg);
+  }
+
+  // Field 6: proc_stats_cache_ttl_ms
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, proc_stats_cache_ttl_ms_, msg);
+  }
+
+  // Field 10: scan_smaps_rollup
+  if (_has_field_[10]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(10, scan_smaps_rollup_, msg);
+  }
+
+  // Field 11: record_process_age
+  if (_has_field_[11]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(11, record_process_age_, msg);
+  }
+
+  // Field 12: record_process_runtime
+  if (_has_field_[12]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(12, record_process_runtime_, msg);
+  }
+
+  // Field 13: record_process_dmabuf_rss
+  if (_has_field_[13]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(13, record_process_dmabuf_rss_, msg);
+  }
+
+  // Field 9: resolve_process_fds
+  if (_has_field_[9]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(9, resolve_process_fds_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/profiling/heapprofd_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/heapprofd_config.gen.h"
 
-TraceConfig_TriggerConfig_Trigger::TraceConfig_TriggerConfig_Trigger() = default;
-TraceConfig_TriggerConfig_Trigger::~TraceConfig_TriggerConfig_Trigger() = default;
-TraceConfig_TriggerConfig_Trigger::TraceConfig_TriggerConfig_Trigger(const TraceConfig_TriggerConfig_Trigger&) = default;
-TraceConfig_TriggerConfig_Trigger& TraceConfig_TriggerConfig_Trigger::operator=(const TraceConfig_TriggerConfig_Trigger&) = default;
-TraceConfig_TriggerConfig_Trigger::TraceConfig_TriggerConfig_Trigger(TraceConfig_TriggerConfig_Trigger&&) noexcept = default;
-TraceConfig_TriggerConfig_Trigger& TraceConfig_TriggerConfig_Trigger::operator=(TraceConfig_TriggerConfig_Trigger&&) = default;
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-bool TraceConfig_TriggerConfig_Trigger::operator==(const TraceConfig_TriggerConfig_Trigger& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && name_ == other.name_
-   && producer_name_regex_ == other.producer_name_regex_
-   && stop_delay_ms_ == other.stop_delay_ms_
-   && max_per_24_h_ == other.max_per_24_h_
-   && skip_probability_ == other.skip_probability_;
+HeapprofdConfig::HeapprofdConfig() = default;
+HeapprofdConfig::~HeapprofdConfig() = default;
+HeapprofdConfig::HeapprofdConfig(const HeapprofdConfig&) = default;
+HeapprofdConfig& HeapprofdConfig::operator=(const HeapprofdConfig&) = default;
+HeapprofdConfig::HeapprofdConfig(HeapprofdConfig&&) noexcept = default;
+HeapprofdConfig& HeapprofdConfig::operator=(HeapprofdConfig&&) = default;
+
+bool HeapprofdConfig::operator==(const HeapprofdConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(sampling_interval_bytes_, other.sampling_interval_bytes_)
+   && ::protozero::internal::gen_helpers::EqualsField(adaptive_sampling_shmem_threshold_, other.adaptive_sampling_shmem_threshold_)
+   && ::protozero::internal::gen_helpers::EqualsField(adaptive_sampling_max_sampling_interval_bytes_, other.adaptive_sampling_max_sampling_interval_bytes_)
+   && ::protozero::internal::gen_helpers::EqualsField(process_cmdline_, other.process_cmdline_)
+   && ::protozero::internal::gen_helpers::EqualsField(pid_, other.pid_)
+   && ::protozero::internal::gen_helpers::EqualsField(target_installed_by_, other.target_installed_by_)
+   && ::protozero::internal::gen_helpers::EqualsField(heaps_, other.heaps_)
+   && ::protozero::internal::gen_helpers::EqualsField(exclude_heaps_, other.exclude_heaps_)
+   && ::protozero::internal::gen_helpers::EqualsField(stream_allocations_, other.stream_allocations_)
+   && ::protozero::internal::gen_helpers::EqualsField(heap_sampling_intervals_, other.heap_sampling_intervals_)
+   && ::protozero::internal::gen_helpers::EqualsField(all_heaps_, other.all_heaps_)
+   && ::protozero::internal::gen_helpers::EqualsField(all_, other.all_)
+   && ::protozero::internal::gen_helpers::EqualsField(min_anonymous_memory_kb_, other.min_anonymous_memory_kb_)
+   && ::protozero::internal::gen_helpers::EqualsField(max_heapprofd_memory_kb_, other.max_heapprofd_memory_kb_)
+   && ::protozero::internal::gen_helpers::EqualsField(max_heapprofd_cpu_secs_, other.max_heapprofd_cpu_secs_)
+   && ::protozero::internal::gen_helpers::EqualsField(skip_symbol_prefix_, other.skip_symbol_prefix_)
+   && ::protozero::internal::gen_helpers::EqualsField(continuous_dump_config_, other.continuous_dump_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(shmem_size_bytes_, other.shmem_size_bytes_)
+   && ::protozero::internal::gen_helpers::EqualsField(block_client_, other.block_client_)
+   && ::protozero::internal::gen_helpers::EqualsField(block_client_timeout_us_, other.block_client_timeout_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(no_startup_, other.no_startup_)
+   && ::protozero::internal::gen_helpers::EqualsField(no_running_, other.no_running_)
+   && ::protozero::internal::gen_helpers::EqualsField(dump_at_max_, other.dump_at_max_)
+   && ::protozero::internal::gen_helpers::EqualsField(disable_fork_teardown_, other.disable_fork_teardown_)
+   && ::protozero::internal::gen_helpers::EqualsField(disable_vfork_detection_, other.disable_vfork_detection_);
 }
 
-bool TraceConfig_TriggerConfig_Trigger::ParseFromArray(const void* raw, size_t size) {
+bool HeapprofdConfig::ParseFromArray(const void* raw, size_t size) {
+  process_cmdline_.clear();
+  pid_.clear();
+  target_installed_by_.clear();
+  heaps_.clear();
+  exclude_heaps_.clear();
+  heap_sampling_intervals_.clear();
+  skip_symbol_prefix_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -27195,20 +23830,87 @@ bool TraceConfig_TriggerConfig_Trigger::ParseFromArray(const void* raw, size_t s
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+      case 1 /* sampling_interval_bytes */:
+        field.get(&sampling_interval_bytes_);
         break;
-      case 2 /* producer_name_regex */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &producer_name_regex_);
+      case 24 /* adaptive_sampling_shmem_threshold */:
+        field.get(&adaptive_sampling_shmem_threshold_);
         break;
-      case 3 /* stop_delay_ms */:
-        field.get(&stop_delay_ms_);
+      case 25 /* adaptive_sampling_max_sampling_interval_bytes */:
+        field.get(&adaptive_sampling_max_sampling_interval_bytes_);
         break;
-      case 4 /* max_per_24_h */:
-        field.get(&max_per_24_h_);
+      case 2 /* process_cmdline */:
+        process_cmdline_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &process_cmdline_.back());
         break;
-      case 5 /* skip_probability */:
-        field.get(&skip_probability_);
+      case 4 /* pid */:
+        pid_.emplace_back();
+        field.get(&pid_.back());
+        break;
+      case 26 /* target_installed_by */:
+        target_installed_by_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &target_installed_by_.back());
+        break;
+      case 20 /* heaps */:
+        heaps_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &heaps_.back());
+        break;
+      case 27 /* exclude_heaps */:
+        exclude_heaps_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &exclude_heaps_.back());
+        break;
+      case 23 /* stream_allocations */:
+        field.get(&stream_allocations_);
+        break;
+      case 22 /* heap_sampling_intervals */:
+        heap_sampling_intervals_.emplace_back();
+        field.get(&heap_sampling_intervals_.back());
+        break;
+      case 21 /* all_heaps */:
+        field.get(&all_heaps_);
+        break;
+      case 5 /* all */:
+        field.get(&all_);
+        break;
+      case 15 /* min_anonymous_memory_kb */:
+        field.get(&min_anonymous_memory_kb_);
+        break;
+      case 16 /* max_heapprofd_memory_kb */:
+        field.get(&max_heapprofd_memory_kb_);
+        break;
+      case 17 /* max_heapprofd_cpu_secs */:
+        field.get(&max_heapprofd_cpu_secs_);
+        break;
+      case 7 /* skip_symbol_prefix */:
+        skip_symbol_prefix_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &skip_symbol_prefix_.back());
+        break;
+      case 6 /* continuous_dump_config */:
+        (*continuous_dump_config_).ParseFromArray(field.data(), field.size());
+        break;
+      case 8 /* shmem_size_bytes */:
+        field.get(&shmem_size_bytes_);
+        break;
+      case 9 /* block_client */:
+        field.get(&block_client_);
+        break;
+      case 14 /* block_client_timeout_us */:
+        field.get(&block_client_timeout_us_);
+        break;
+      case 10 /* no_startup */:
+        field.get(&no_startup_);
+        break;
+      case 11 /* no_running */:
+        field.get(&no_running_);
+        break;
+      case 13 /* dump_at_max */:
+        field.get(&dump_at_max_);
+        break;
+      case 18 /* disable_fork_teardown */:
+        field.get(&disable_fork_teardown_);
+        break;
+      case 19 /* disable_vfork_detection */:
+        field.get(&disable_vfork_detection_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -27218,62 +23920,162 @@ bool TraceConfig_TriggerConfig_Trigger::ParseFromArray(const void* raw, size_t s
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TraceConfig_TriggerConfig_Trigger::SerializeAsString() const {
+std::string HeapprofdConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TraceConfig_TriggerConfig_Trigger::SerializeAsArray() const {
+std::vector<uint8_t> HeapprofdConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TraceConfig_TriggerConfig_Trigger::Serialize(::protozero::Message* msg) const {
-  // Field 1: name
+void HeapprofdConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: sampling_interval_bytes
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, sampling_interval_bytes_, msg);
   }
 
-  // Field 2: producer_name_regex
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeString(2, producer_name_regex_, msg);
+  // Field 24: adaptive_sampling_shmem_threshold
+  if (_has_field_[24]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(24, adaptive_sampling_shmem_threshold_, msg);
   }
 
-  // Field 3: stop_delay_ms
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, stop_delay_ms_, msg);
+  // Field 25: adaptive_sampling_max_sampling_interval_bytes
+  if (_has_field_[25]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(25, adaptive_sampling_max_sampling_interval_bytes_, msg);
   }
 
-  // Field 4: max_per_24_h
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, max_per_24_h_, msg);
+  // Field 2: process_cmdline
+  for (auto& it : process_cmdline_) {
+    ::protozero::internal::gen_helpers::SerializeString(2, it, msg);
   }
 
-  // Field 5: skip_probability
+  // Field 4: pid
+  for (auto& it : pid_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, it, msg);
+  }
+
+  // Field 26: target_installed_by
+  for (auto& it : target_installed_by_) {
+    ::protozero::internal::gen_helpers::SerializeString(26, it, msg);
+  }
+
+  // Field 20: heaps
+  for (auto& it : heaps_) {
+    ::protozero::internal::gen_helpers::SerializeString(20, it, msg);
+  }
+
+  // Field 27: exclude_heaps
+  for (auto& it : exclude_heaps_) {
+    ::protozero::internal::gen_helpers::SerializeString(27, it, msg);
+  }
+
+  // Field 23: stream_allocations
+  if (_has_field_[23]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(23, stream_allocations_, msg);
+  }
+
+  // Field 22: heap_sampling_intervals
+  for (auto& it : heap_sampling_intervals_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(22, it, msg);
+  }
+
+  // Field 21: all_heaps
+  if (_has_field_[21]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(21, all_heaps_, msg);
+  }
+
+  // Field 5: all
   if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeFixed(5, skip_probability_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, all_, msg);
+  }
+
+  // Field 15: min_anonymous_memory_kb
+  if (_has_field_[15]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(15, min_anonymous_memory_kb_, msg);
+  }
+
+  // Field 16: max_heapprofd_memory_kb
+  if (_has_field_[16]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(16, max_heapprofd_memory_kb_, msg);
+  }
+
+  // Field 17: max_heapprofd_cpu_secs
+  if (_has_field_[17]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(17, max_heapprofd_cpu_secs_, msg);
+  }
+
+  // Field 7: skip_symbol_prefix
+  for (auto& it : skip_symbol_prefix_) {
+    ::protozero::internal::gen_helpers::SerializeString(7, it, msg);
+  }
+
+  // Field 6: continuous_dump_config
+  if (_has_field_[6]) {
+    (*continuous_dump_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(6));
+  }
+
+  // Field 8: shmem_size_bytes
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(8, shmem_size_bytes_, msg);
+  }
+
+  // Field 9: block_client
+  if (_has_field_[9]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(9, block_client_, msg);
+  }
+
+  // Field 14: block_client_timeout_us
+  if (_has_field_[14]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(14, block_client_timeout_us_, msg);
+  }
+
+  // Field 10: no_startup
+  if (_has_field_[10]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(10, no_startup_, msg);
+  }
+
+  // Field 11: no_running
+  if (_has_field_[11]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(11, no_running_, msg);
+  }
+
+  // Field 13: dump_at_max
+  if (_has_field_[13]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(13, dump_at_max_, msg);
+  }
+
+  // Field 18: disable_fork_teardown
+  if (_has_field_[18]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(18, disable_fork_teardown_, msg);
+  }
+
+  // Field 19: disable_vfork_detection
+  if (_has_field_[19]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(19, disable_vfork_detection_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-TraceConfig_GuardrailOverrides::TraceConfig_GuardrailOverrides() = default;
-TraceConfig_GuardrailOverrides::~TraceConfig_GuardrailOverrides() = default;
-TraceConfig_GuardrailOverrides::TraceConfig_GuardrailOverrides(const TraceConfig_GuardrailOverrides&) = default;
-TraceConfig_GuardrailOverrides& TraceConfig_GuardrailOverrides::operator=(const TraceConfig_GuardrailOverrides&) = default;
-TraceConfig_GuardrailOverrides::TraceConfig_GuardrailOverrides(TraceConfig_GuardrailOverrides&&) noexcept = default;
-TraceConfig_GuardrailOverrides& TraceConfig_GuardrailOverrides::operator=(TraceConfig_GuardrailOverrides&&) = default;
+HeapprofdConfig_ContinuousDumpConfig::HeapprofdConfig_ContinuousDumpConfig() = default;
+HeapprofdConfig_ContinuousDumpConfig::~HeapprofdConfig_ContinuousDumpConfig() = default;
+HeapprofdConfig_ContinuousDumpConfig::HeapprofdConfig_ContinuousDumpConfig(const HeapprofdConfig_ContinuousDumpConfig&) = default;
+HeapprofdConfig_ContinuousDumpConfig& HeapprofdConfig_ContinuousDumpConfig::operator=(const HeapprofdConfig_ContinuousDumpConfig&) = default;
+HeapprofdConfig_ContinuousDumpConfig::HeapprofdConfig_ContinuousDumpConfig(HeapprofdConfig_ContinuousDumpConfig&&) noexcept = default;
+HeapprofdConfig_ContinuousDumpConfig& HeapprofdConfig_ContinuousDumpConfig::operator=(HeapprofdConfig_ContinuousDumpConfig&&) = default;
 
-bool TraceConfig_GuardrailOverrides::operator==(const TraceConfig_GuardrailOverrides& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && max_upload_per_day_bytes_ == other.max_upload_per_day_bytes_
-   && max_tracing_buffer_size_kb_ == other.max_tracing_buffer_size_kb_;
+bool HeapprofdConfig_ContinuousDumpConfig::operator==(const HeapprofdConfig_ContinuousDumpConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(dump_phase_ms_, other.dump_phase_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(dump_interval_ms_, other.dump_interval_ms_);
 }
 
-bool TraceConfig_GuardrailOverrides::ParseFromArray(const void* raw, size_t size) {
+bool HeapprofdConfig_ContinuousDumpConfig::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -27283,11 +24085,11 @@ bool TraceConfig_GuardrailOverrides::ParseFromArray(const void* raw, size_t size
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* max_upload_per_day_bytes */:
-        field.get(&max_upload_per_day_bytes_);
+      case 5 /* dump_phase_ms */:
+        field.get(&dump_phase_ms_);
         break;
-      case 2 /* max_tracing_buffer_size_kb */:
-        field.get(&max_tracing_buffer_size_kb_);
+      case 6 /* dump_interval_ms */:
+        field.get(&dump_interval_ms_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -27297,49 +24099,78 @@ bool TraceConfig_GuardrailOverrides::ParseFromArray(const void* raw, size_t size
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TraceConfig_GuardrailOverrides::SerializeAsString() const {
+std::string HeapprofdConfig_ContinuousDumpConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TraceConfig_GuardrailOverrides::SerializeAsArray() const {
+std::vector<uint8_t> HeapprofdConfig_ContinuousDumpConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TraceConfig_GuardrailOverrides::Serialize(::protozero::Message* msg) const {
-  // Field 1: max_upload_per_day_bytes
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, max_upload_per_day_bytes_, msg);
+void HeapprofdConfig_ContinuousDumpConfig::Serialize(::protozero::Message* msg) const {
+  // Field 5: dump_phase_ms
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, dump_phase_ms_, msg);
   }
 
-  // Field 2: max_tracing_buffer_size_kb
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, max_tracing_buffer_size_kb_, msg);
+  // Field 6: dump_interval_ms
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, dump_interval_ms_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/profiling/java_hprof_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/java_hprof_config.gen.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-TraceConfig_StatsdMetadata::TraceConfig_StatsdMetadata() = default;
-TraceConfig_StatsdMetadata::~TraceConfig_StatsdMetadata() = default;
-TraceConfig_StatsdMetadata::TraceConfig_StatsdMetadata(const TraceConfig_StatsdMetadata&) = default;
-TraceConfig_StatsdMetadata& TraceConfig_StatsdMetadata::operator=(const TraceConfig_StatsdMetadata&) = default;
-TraceConfig_StatsdMetadata::TraceConfig_StatsdMetadata(TraceConfig_StatsdMetadata&&) noexcept = default;
-TraceConfig_StatsdMetadata& TraceConfig_StatsdMetadata::operator=(TraceConfig_StatsdMetadata&&) = default;
+JavaHprofConfig::JavaHprofConfig() = default;
+JavaHprofConfig::~JavaHprofConfig() = default;
+JavaHprofConfig::JavaHprofConfig(const JavaHprofConfig&) = default;
+JavaHprofConfig& JavaHprofConfig::operator=(const JavaHprofConfig&) = default;
+JavaHprofConfig::JavaHprofConfig(JavaHprofConfig&&) noexcept = default;
+JavaHprofConfig& JavaHprofConfig::operator=(JavaHprofConfig&&) = default;
 
-bool TraceConfig_StatsdMetadata::operator==(const TraceConfig_StatsdMetadata& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && triggering_alert_id_ == other.triggering_alert_id_
-   && triggering_config_uid_ == other.triggering_config_uid_
-   && triggering_config_id_ == other.triggering_config_id_
-   && triggering_subscription_id_ == other.triggering_subscription_id_;
+bool JavaHprofConfig::operator==(const JavaHprofConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(process_cmdline_, other.process_cmdline_)
+   && ::protozero::internal::gen_helpers::EqualsField(pid_, other.pid_)
+   && ::protozero::internal::gen_helpers::EqualsField(target_installed_by_, other.target_installed_by_)
+   && ::protozero::internal::gen_helpers::EqualsField(continuous_dump_config_, other.continuous_dump_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(min_anonymous_memory_kb_, other.min_anonymous_memory_kb_)
+   && ::protozero::internal::gen_helpers::EqualsField(dump_smaps_, other.dump_smaps_)
+   && ::protozero::internal::gen_helpers::EqualsField(ignored_types_, other.ignored_types_);
 }
 
-bool TraceConfig_StatsdMetadata::ParseFromArray(const void* raw, size_t size) {
+bool JavaHprofConfig::ParseFromArray(const void* raw, size_t size) {
+  process_cmdline_.clear();
+  pid_.clear();
+  target_installed_by_.clear();
+  ignored_types_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -27349,17 +24180,30 @@ bool TraceConfig_StatsdMetadata::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* triggering_alert_id */:
-        field.get(&triggering_alert_id_);
+      case 1 /* process_cmdline */:
+        process_cmdline_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &process_cmdline_.back());
         break;
-      case 2 /* triggering_config_uid */:
-        field.get(&triggering_config_uid_);
+      case 2 /* pid */:
+        pid_.emplace_back();
+        field.get(&pid_.back());
         break;
-      case 3 /* triggering_config_id */:
-        field.get(&triggering_config_id_);
+      case 7 /* target_installed_by */:
+        target_installed_by_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &target_installed_by_.back());
         break;
-      case 4 /* triggering_subscription_id */:
-        field.get(&triggering_subscription_id_);
+      case 3 /* continuous_dump_config */:
+        (*continuous_dump_config_).ParseFromArray(field.data(), field.size());
+        break;
+      case 4 /* min_anonymous_memory_kb */:
+        field.get(&min_anonymous_memory_kb_);
+        break;
+      case 5 /* dump_smaps */:
+        field.get(&dump_smaps_);
+        break;
+      case 6 /* ignored_types */:
+        ignored_types_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &ignored_types_.back());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -27369,58 +24213,73 @@ bool TraceConfig_StatsdMetadata::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TraceConfig_StatsdMetadata::SerializeAsString() const {
+std::string JavaHprofConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TraceConfig_StatsdMetadata::SerializeAsArray() const {
+std::vector<uint8_t> JavaHprofConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TraceConfig_StatsdMetadata::Serialize(::protozero::Message* msg) const {
-  // Field 1: triggering_alert_id
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, triggering_alert_id_, msg);
+void JavaHprofConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: process_cmdline
+  for (auto& it : process_cmdline_) {
+    ::protozero::internal::gen_helpers::SerializeString(1, it, msg);
   }
 
-  // Field 2: triggering_config_uid
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, triggering_config_uid_, msg);
+  // Field 2: pid
+  for (auto& it : pid_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, it, msg);
   }
 
-  // Field 3: triggering_config_id
+  // Field 7: target_installed_by
+  for (auto& it : target_installed_by_) {
+    ::protozero::internal::gen_helpers::SerializeString(7, it, msg);
+  }
+
+  // Field 3: continuous_dump_config
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, triggering_config_id_, msg);
+    (*continuous_dump_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(3));
   }
 
-  // Field 4: triggering_subscription_id
+  // Field 4: min_anonymous_memory_kb
   if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, triggering_subscription_id_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, min_anonymous_memory_kb_, msg);
+  }
+
+  // Field 5: dump_smaps
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, dump_smaps_, msg);
+  }
+
+  // Field 6: ignored_types
+  for (auto& it : ignored_types_) {
+    ::protozero::internal::gen_helpers::SerializeString(6, it, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-TraceConfig_ProducerConfig::TraceConfig_ProducerConfig() = default;
-TraceConfig_ProducerConfig::~TraceConfig_ProducerConfig() = default;
-TraceConfig_ProducerConfig::TraceConfig_ProducerConfig(const TraceConfig_ProducerConfig&) = default;
-TraceConfig_ProducerConfig& TraceConfig_ProducerConfig::operator=(const TraceConfig_ProducerConfig&) = default;
-TraceConfig_ProducerConfig::TraceConfig_ProducerConfig(TraceConfig_ProducerConfig&&) noexcept = default;
-TraceConfig_ProducerConfig& TraceConfig_ProducerConfig::operator=(TraceConfig_ProducerConfig&&) = default;
+JavaHprofConfig_ContinuousDumpConfig::JavaHprofConfig_ContinuousDumpConfig() = default;
+JavaHprofConfig_ContinuousDumpConfig::~JavaHprofConfig_ContinuousDumpConfig() = default;
+JavaHprofConfig_ContinuousDumpConfig::JavaHprofConfig_ContinuousDumpConfig(const JavaHprofConfig_ContinuousDumpConfig&) = default;
+JavaHprofConfig_ContinuousDumpConfig& JavaHprofConfig_ContinuousDumpConfig::operator=(const JavaHprofConfig_ContinuousDumpConfig&) = default;
+JavaHprofConfig_ContinuousDumpConfig::JavaHprofConfig_ContinuousDumpConfig(JavaHprofConfig_ContinuousDumpConfig&&) noexcept = default;
+JavaHprofConfig_ContinuousDumpConfig& JavaHprofConfig_ContinuousDumpConfig::operator=(JavaHprofConfig_ContinuousDumpConfig&&) = default;
 
-bool TraceConfig_ProducerConfig::operator==(const TraceConfig_ProducerConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && producer_name_ == other.producer_name_
-   && shm_size_kb_ == other.shm_size_kb_
-   && page_size_kb_ == other.page_size_kb_;
+bool JavaHprofConfig_ContinuousDumpConfig::operator==(const JavaHprofConfig_ContinuousDumpConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(dump_phase_ms_, other.dump_phase_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(dump_interval_ms_, other.dump_interval_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(scan_pids_only_on_start_, other.scan_pids_only_on_start_);
 }
 
-bool TraceConfig_ProducerConfig::ParseFromArray(const void* raw, size_t size) {
+bool JavaHprofConfig_ContinuousDumpConfig::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -27430,14 +24289,14 @@ bool TraceConfig_ProducerConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* producer_name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &producer_name_);
+      case 1 /* dump_phase_ms */:
+        field.get(&dump_phase_ms_);
         break;
-      case 2 /* shm_size_kb */:
-        field.get(&shm_size_kb_);
+      case 2 /* dump_interval_ms */:
+        field.get(&dump_interval_ms_);
         break;
-      case 3 /* page_size_kb */:
-        field.get(&page_size_kb_);
+      case 3 /* scan_pids_only_on_start */:
+        field.get(&scan_pids_only_on_start_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -27447,57 +24306,102 @@ bool TraceConfig_ProducerConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TraceConfig_ProducerConfig::SerializeAsString() const {
+std::string JavaHprofConfig_ContinuousDumpConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TraceConfig_ProducerConfig::SerializeAsArray() const {
+std::vector<uint8_t> JavaHprofConfig_ContinuousDumpConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TraceConfig_ProducerConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: producer_name
+void JavaHprofConfig_ContinuousDumpConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: dump_phase_ms
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeString(1, producer_name_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, dump_phase_ms_, msg);
   }
 
-  // Field 2: shm_size_kb
+  // Field 2: dump_interval_ms
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, shm_size_kb_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, dump_interval_ms_, msg);
   }
 
-  // Field 3: page_size_kb
+  // Field 3: scan_pids_only_on_start
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, page_size_kb_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, scan_pids_only_on_start_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/profiling/perf_event_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/perf_event_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/perf_events.gen.h"
 
-TraceConfig_BuiltinDataSource::TraceConfig_BuiltinDataSource() = default;
-TraceConfig_BuiltinDataSource::~TraceConfig_BuiltinDataSource() = default;
-TraceConfig_BuiltinDataSource::TraceConfig_BuiltinDataSource(const TraceConfig_BuiltinDataSource&) = default;
-TraceConfig_BuiltinDataSource& TraceConfig_BuiltinDataSource::operator=(const TraceConfig_BuiltinDataSource&) = default;
-TraceConfig_BuiltinDataSource::TraceConfig_BuiltinDataSource(TraceConfig_BuiltinDataSource&&) noexcept = default;
-TraceConfig_BuiltinDataSource& TraceConfig_BuiltinDataSource::operator=(TraceConfig_BuiltinDataSource&&) = default;
-
-bool TraceConfig_BuiltinDataSource::operator==(const TraceConfig_BuiltinDataSource& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && disable_clock_snapshotting_ == other.disable_clock_snapshotting_
-   && disable_trace_config_ == other.disable_trace_config_
-   && disable_system_info_ == other.disable_system_info_
-   && disable_service_events_ == other.disable_service_events_
-   && primary_trace_clock_ == other.primary_trace_clock_
-   && snapshot_interval_ms_ == other.snapshot_interval_ms_
-   && prefer_suspend_clock_for_snapshot_ == other.prefer_suspend_clock_for_snapshot_;
-}
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-bool TraceConfig_BuiltinDataSource::ParseFromArray(const void* raw, size_t size) {
+PerfEventConfig::PerfEventConfig() = default;
+PerfEventConfig::~PerfEventConfig() = default;
+PerfEventConfig::PerfEventConfig(const PerfEventConfig&) = default;
+PerfEventConfig& PerfEventConfig::operator=(const PerfEventConfig&) = default;
+PerfEventConfig::PerfEventConfig(PerfEventConfig&&) noexcept = default;
+PerfEventConfig& PerfEventConfig::operator=(PerfEventConfig&&) = default;
+
+bool PerfEventConfig::operator==(const PerfEventConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(timebase_, other.timebase_)
+   && ::protozero::internal::gen_helpers::EqualsField(followers_, other.followers_)
+   && ::protozero::internal::gen_helpers::EqualsField(callstack_sampling_, other.callstack_sampling_)
+   && ::protozero::internal::gen_helpers::EqualsField(target_cpu_, other.target_cpu_)
+   && ::protozero::internal::gen_helpers::EqualsField(ring_buffer_read_period_ms_, other.ring_buffer_read_period_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(ring_buffer_pages_, other.ring_buffer_pages_)
+   && ::protozero::internal::gen_helpers::EqualsField(max_enqueued_footprint_kb_, other.max_enqueued_footprint_kb_)
+   && ::protozero::internal::gen_helpers::EqualsField(max_daemon_memory_kb_, other.max_daemon_memory_kb_)
+   && ::protozero::internal::gen_helpers::EqualsField(remote_descriptor_timeout_ms_, other.remote_descriptor_timeout_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(unwind_state_clear_period_ms_, other.unwind_state_clear_period_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(target_installed_by_, other.target_installed_by_)
+   && ::protozero::internal::gen_helpers::EqualsField(all_cpus_, other.all_cpus_)
+   && ::protozero::internal::gen_helpers::EqualsField(sampling_frequency_, other.sampling_frequency_)
+   && ::protozero::internal::gen_helpers::EqualsField(kernel_frames_, other.kernel_frames_)
+   && ::protozero::internal::gen_helpers::EqualsField(target_pid_, other.target_pid_)
+   && ::protozero::internal::gen_helpers::EqualsField(target_cmdline_, other.target_cmdline_)
+   && ::protozero::internal::gen_helpers::EqualsField(exclude_pid_, other.exclude_pid_)
+   && ::protozero::internal::gen_helpers::EqualsField(exclude_cmdline_, other.exclude_cmdline_)
+   && ::protozero::internal::gen_helpers::EqualsField(additional_cmdline_count_, other.additional_cmdline_count_);
+}
+
+int PerfEventConfig::followers_size() const { return static_cast<int>(followers_.size()); }
+void PerfEventConfig::clear_followers() { followers_.clear(); }
+FollowerEvent* PerfEventConfig::add_followers() { followers_.emplace_back(); return &followers_.back(); }
+bool PerfEventConfig::ParseFromArray(const void* raw, size_t size) {
+  followers_.clear();
+  target_cpu_.clear();
+  target_installed_by_.clear();
+  target_pid_.clear();
+  target_cmdline_.clear();
+  exclude_pid_.clear();
+  exclude_cmdline_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -27507,26 +24411,69 @@ bool TraceConfig_BuiltinDataSource::ParseFromArray(const void* raw, size_t size)
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* disable_clock_snapshotting */:
-        field.get(&disable_clock_snapshotting_);
+      case 15 /* timebase */:
+        (*timebase_).ParseFromArray(field.data(), field.size());
         break;
-      case 2 /* disable_trace_config */:
-        field.get(&disable_trace_config_);
+      case 19 /* followers */:
+        followers_.emplace_back();
+        followers_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 3 /* disable_system_info */:
-        field.get(&disable_system_info_);
+      case 16 /* callstack_sampling */:
+        (*callstack_sampling_).ParseFromArray(field.data(), field.size());
         break;
-      case 4 /* disable_service_events */:
-        field.get(&disable_service_events_);
+      case 20 /* target_cpu */:
+        target_cpu_.emplace_back();
+        field.get(&target_cpu_.back());
         break;
-      case 5 /* primary_trace_clock */:
-        field.get(&primary_trace_clock_);
+      case 8 /* ring_buffer_read_period_ms */:
+        field.get(&ring_buffer_read_period_ms_);
         break;
-      case 6 /* snapshot_interval_ms */:
-        field.get(&snapshot_interval_ms_);
+      case 3 /* ring_buffer_pages */:
+        field.get(&ring_buffer_pages_);
         break;
-      case 7 /* prefer_suspend_clock_for_snapshot */:
-        field.get(&prefer_suspend_clock_for_snapshot_);
+      case 17 /* max_enqueued_footprint_kb */:
+        field.get(&max_enqueued_footprint_kb_);
+        break;
+      case 13 /* max_daemon_memory_kb */:
+        field.get(&max_daemon_memory_kb_);
+        break;
+      case 9 /* remote_descriptor_timeout_ms */:
+        field.get(&remote_descriptor_timeout_ms_);
+        break;
+      case 10 /* unwind_state_clear_period_ms */:
+        field.get(&unwind_state_clear_period_ms_);
+        break;
+      case 18 /* target_installed_by */:
+        target_installed_by_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &target_installed_by_.back());
+        break;
+      case 1 /* all_cpus */:
+        field.get(&all_cpus_);
+        break;
+      case 2 /* sampling_frequency */:
+        field.get(&sampling_frequency_);
+        break;
+      case 12 /* kernel_frames */:
+        field.get(&kernel_frames_);
+        break;
+      case 4 /* target_pid */:
+        target_pid_.emplace_back();
+        field.get(&target_pid_.back());
+        break;
+      case 5 /* target_cmdline */:
+        target_cmdline_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &target_cmdline_.back());
+        break;
+      case 6 /* exclude_pid */:
+        exclude_pid_.emplace_back();
+        field.get(&exclude_pid_.back());
+        break;
+      case 7 /* exclude_cmdline */:
+        exclude_cmdline_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &exclude_cmdline_.back());
+        break;
+      case 11 /* additional_cmdline_count */:
+        field.get(&additional_cmdline_count_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -27536,75 +24483,133 @@ bool TraceConfig_BuiltinDataSource::ParseFromArray(const void* raw, size_t size)
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TraceConfig_BuiltinDataSource::SerializeAsString() const {
+std::string PerfEventConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TraceConfig_BuiltinDataSource::SerializeAsArray() const {
+std::vector<uint8_t> PerfEventConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TraceConfig_BuiltinDataSource::Serialize(::protozero::Message* msg) const {
-  // Field 1: disable_clock_snapshotting
+void PerfEventConfig::Serialize(::protozero::Message* msg) const {
+  // Field 15: timebase
+  if (_has_field_[15]) {
+    (*timebase_).Serialize(msg->BeginNestedMessage<::protozero::Message>(15));
+  }
+
+  // Field 19: followers
+  for (auto& it : followers_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(19));
+  }
+
+  // Field 16: callstack_sampling
+  if (_has_field_[16]) {
+    (*callstack_sampling_).Serialize(msg->BeginNestedMessage<::protozero::Message>(16));
+  }
+
+  // Field 20: target_cpu
+  for (auto& it : target_cpu_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(20, it, msg);
+  }
+
+  // Field 8: ring_buffer_read_period_ms
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(8, ring_buffer_read_period_ms_, msg);
+  }
+
+  // Field 3: ring_buffer_pages
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, ring_buffer_pages_, msg);
+  }
+
+  // Field 17: max_enqueued_footprint_kb
+  if (_has_field_[17]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(17, max_enqueued_footprint_kb_, msg);
+  }
+
+  // Field 13: max_daemon_memory_kb
+  if (_has_field_[13]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(13, max_daemon_memory_kb_, msg);
+  }
+
+  // Field 9: remote_descriptor_timeout_ms
+  if (_has_field_[9]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(9, remote_descriptor_timeout_ms_, msg);
+  }
+
+  // Field 10: unwind_state_clear_period_ms
+  if (_has_field_[10]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(10, unwind_state_clear_period_ms_, msg);
+  }
+
+  // Field 18: target_installed_by
+  for (auto& it : target_installed_by_) {
+    ::protozero::internal::gen_helpers::SerializeString(18, it, msg);
+  }
+
+  // Field 1: all_cpus
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(1, disable_clock_snapshotting_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(1, all_cpus_, msg);
   }
 
-  // Field 2: disable_trace_config
+  // Field 2: sampling_frequency
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, disable_trace_config_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, sampling_frequency_, msg);
   }
 
-  // Field 3: disable_system_info
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, disable_system_info_, msg);
+  // Field 12: kernel_frames
+  if (_has_field_[12]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(12, kernel_frames_, msg);
   }
 
-  // Field 4: disable_service_events
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(4, disable_service_events_, msg);
+  // Field 4: target_pid
+  for (auto& it : target_pid_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, it, msg);
   }
 
-  // Field 5: primary_trace_clock
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(5, primary_trace_clock_, msg);
+  // Field 5: target_cmdline
+  for (auto& it : target_cmdline_) {
+    ::protozero::internal::gen_helpers::SerializeString(5, it, msg);
   }
 
-  // Field 6: snapshot_interval_ms
-  if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(6, snapshot_interval_ms_, msg);
+  // Field 6: exclude_pid
+  for (auto& it : exclude_pid_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, it, msg);
   }
 
-  // Field 7: prefer_suspend_clock_for_snapshot
-  if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(7, prefer_suspend_clock_for_snapshot_, msg);
+  // Field 7: exclude_cmdline
+  for (auto& it : exclude_cmdline_) {
+    ::protozero::internal::gen_helpers::SerializeString(7, it, msg);
+  }
+
+  // Field 11: additional_cmdline_count
+  if (_has_field_[11]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(11, additional_cmdline_count_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-TraceConfig_DataSource::TraceConfig_DataSource() = default;
-TraceConfig_DataSource::~TraceConfig_DataSource() = default;
-TraceConfig_DataSource::TraceConfig_DataSource(const TraceConfig_DataSource&) = default;
-TraceConfig_DataSource& TraceConfig_DataSource::operator=(const TraceConfig_DataSource&) = default;
-TraceConfig_DataSource::TraceConfig_DataSource(TraceConfig_DataSource&&) noexcept = default;
-TraceConfig_DataSource& TraceConfig_DataSource::operator=(TraceConfig_DataSource&&) = default;
+PerfEventConfig_CallstackSampling::PerfEventConfig_CallstackSampling() = default;
+PerfEventConfig_CallstackSampling::~PerfEventConfig_CallstackSampling() = default;
+PerfEventConfig_CallstackSampling::PerfEventConfig_CallstackSampling(const PerfEventConfig_CallstackSampling&) = default;
+PerfEventConfig_CallstackSampling& PerfEventConfig_CallstackSampling::operator=(const PerfEventConfig_CallstackSampling&) = default;
+PerfEventConfig_CallstackSampling::PerfEventConfig_CallstackSampling(PerfEventConfig_CallstackSampling&&) noexcept = default;
+PerfEventConfig_CallstackSampling& PerfEventConfig_CallstackSampling::operator=(PerfEventConfig_CallstackSampling&&) = default;
 
-bool TraceConfig_DataSource::operator==(const TraceConfig_DataSource& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && config_ == other.config_
-   && producer_name_filter_ == other.producer_name_filter_
-   && producer_name_regex_filter_ == other.producer_name_regex_filter_;
+bool PerfEventConfig_CallstackSampling::operator==(const PerfEventConfig_CallstackSampling& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(scope_, other.scope_)
+   && ::protozero::internal::gen_helpers::EqualsField(kernel_frames_, other.kernel_frames_)
+   && ::protozero::internal::gen_helpers::EqualsField(user_frames_, other.user_frames_);
 }
 
-bool TraceConfig_DataSource::ParseFromArray(const void* raw, size_t size) {
-  producer_name_filter_.clear();
-  producer_name_regex_filter_.clear();
+bool PerfEventConfig_CallstackSampling::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -27614,16 +24619,14 @@ bool TraceConfig_DataSource::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* config */:
-        (*config_).ParseFromArray(field.data(), field.size());
+      case 1 /* scope */:
+        (*scope_).ParseFromArray(field.data(), field.size());
         break;
-      case 2 /* producer_name_filter */:
-        producer_name_filter_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &producer_name_filter_.back());
+      case 2 /* kernel_frames */:
+        field.get(&kernel_frames_);
         break;
-      case 3 /* producer_name_regex_filter */:
-        producer_name_regex_filter_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &producer_name_regex_filter_.back());
+      case 3 /* user_frames */:
+        field.get(&user_frames_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -27633,52 +24636,60 @@ bool TraceConfig_DataSource::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TraceConfig_DataSource::SerializeAsString() const {
+std::string PerfEventConfig_CallstackSampling::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TraceConfig_DataSource::SerializeAsArray() const {
+std::vector<uint8_t> PerfEventConfig_CallstackSampling::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TraceConfig_DataSource::Serialize(::protozero::Message* msg) const {
-  // Field 1: config
+void PerfEventConfig_CallstackSampling::Serialize(::protozero::Message* msg) const {
+  // Field 1: scope
   if (_has_field_[1]) {
-    (*config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
+    (*scope_).Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
   }
 
-  // Field 2: producer_name_filter
-  for (auto& it : producer_name_filter_) {
-    ::protozero::internal::gen_helpers::SerializeString(2, it, msg);
+  // Field 2: kernel_frames
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, kernel_frames_, msg);
   }
 
-  // Field 3: producer_name_regex_filter
-  for (auto& it : producer_name_regex_filter_) {
-    ::protozero::internal::gen_helpers::SerializeString(3, it, msg);
+  // Field 3: user_frames
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, user_frames_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-TraceConfig_BufferConfig::TraceConfig_BufferConfig() = default;
-TraceConfig_BufferConfig::~TraceConfig_BufferConfig() = default;
-TraceConfig_BufferConfig::TraceConfig_BufferConfig(const TraceConfig_BufferConfig&) = default;
-TraceConfig_BufferConfig& TraceConfig_BufferConfig::operator=(const TraceConfig_BufferConfig&) = default;
-TraceConfig_BufferConfig::TraceConfig_BufferConfig(TraceConfig_BufferConfig&&) noexcept = default;
-TraceConfig_BufferConfig& TraceConfig_BufferConfig::operator=(TraceConfig_BufferConfig&&) = default;
+PerfEventConfig_Scope::PerfEventConfig_Scope() = default;
+PerfEventConfig_Scope::~PerfEventConfig_Scope() = default;
+PerfEventConfig_Scope::PerfEventConfig_Scope(const PerfEventConfig_Scope&) = default;
+PerfEventConfig_Scope& PerfEventConfig_Scope::operator=(const PerfEventConfig_Scope&) = default;
+PerfEventConfig_Scope::PerfEventConfig_Scope(PerfEventConfig_Scope&&) noexcept = default;
+PerfEventConfig_Scope& PerfEventConfig_Scope::operator=(PerfEventConfig_Scope&&) = default;
 
-bool TraceConfig_BufferConfig::operator==(const TraceConfig_BufferConfig& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && size_kb_ == other.size_kb_
-   && fill_policy_ == other.fill_policy_;
+bool PerfEventConfig_Scope::operator==(const PerfEventConfig_Scope& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(target_pid_, other.target_pid_)
+   && ::protozero::internal::gen_helpers::EqualsField(target_cmdline_, other.target_cmdline_)
+   && ::protozero::internal::gen_helpers::EqualsField(exclude_pid_, other.exclude_pid_)
+   && ::protozero::internal::gen_helpers::EqualsField(exclude_cmdline_, other.exclude_cmdline_)
+   && ::protozero::internal::gen_helpers::EqualsField(additional_cmdline_count_, other.additional_cmdline_count_)
+   && ::protozero::internal::gen_helpers::EqualsField(process_shard_count_, other.process_shard_count_);
 }
 
-bool TraceConfig_BufferConfig::ParseFromArray(const void* raw, size_t size) {
+bool PerfEventConfig_Scope::ParseFromArray(const void* raw, size_t size) {
+  target_pid_.clear();
+  target_cmdline_.clear();
+  exclude_pid_.clear();
+  exclude_cmdline_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -27688,11 +24699,27 @@ bool TraceConfig_BufferConfig::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* size_kb */:
-        field.get(&size_kb_);
+      case 1 /* target_pid */:
+        target_pid_.emplace_back();
+        field.get(&target_pid_.back());
         break;
-      case 4 /* fill_policy */:
-        field.get(&fill_policy_);
+      case 2 /* target_cmdline */:
+        target_cmdline_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &target_cmdline_.back());
+        break;
+      case 3 /* exclude_pid */:
+        exclude_pid_.emplace_back();
+        field.get(&exclude_pid_.back());
+        break;
+      case 4 /* exclude_cmdline */:
+        exclude_cmdline_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &exclude_cmdline_.back());
+        break;
+      case 5 /* additional_cmdline_count */:
+        field.get(&additional_cmdline_count_);
+        break;
+      case 6 /* process_shard_count */:
+        field.get(&process_shard_count_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -27702,27 +24729,47 @@ bool TraceConfig_BufferConfig::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TraceConfig_BufferConfig::SerializeAsString() const {
+std::string PerfEventConfig_Scope::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TraceConfig_BufferConfig::SerializeAsArray() const {
+std::vector<uint8_t> PerfEventConfig_Scope::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TraceConfig_BufferConfig::Serialize(::protozero::Message* msg) const {
-  // Field 1: size_kb
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, size_kb_, msg);
+void PerfEventConfig_Scope::Serialize(::protozero::Message* msg) const {
+  // Field 1: target_pid
+  for (auto& it : target_pid_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, it, msg);
   }
 
-  // Field 4: fill_policy
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, fill_policy_, msg);
+  // Field 2: target_cmdline
+  for (auto& it : target_cmdline_) {
+    ::protozero::internal::gen_helpers::SerializeString(2, it, msg);
+  }
+
+  // Field 3: exclude_pid
+  for (auto& it : exclude_pid_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, it, msg);
+  }
+
+  // Field 4: exclude_cmdline
+  for (auto& it : exclude_cmdline_) {
+    ::protozero::internal::gen_helpers::SerializeString(4, it, msg);
+  }
+
+  // Field 5: additional_cmdline_count
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, additional_cmdline_count_, msg);
+  }
+
+  // Field 6: process_shard_count
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, process_shard_count_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -27734,186 +24781,7 @@ void TraceConfig_BufferConfig::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/common/android_energy_consumer_descriptor.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/common/android_log_constants.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/common/builtin_clock.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/common/commit_data_request.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/common/data_source_descriptor.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/common/descriptor.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/common/ftrace_descriptor.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/common/gpu_counter_descriptor.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/common/interceptor_descriptor.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/common/observable_events.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/common/perf_events.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/common/sys_stats_counters.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/common/trace_stats.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/common/tracing_service_capabilities.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/common/tracing_service_state.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/common/track_event_descriptor.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/gpu/gpu_counter_event.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/gpu/gpu_log.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/gpu/gpu_render_stage_event.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/gpu/vulkan_api_event.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/gpu/vulkan_memory_event.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/profiling/deobfuscation.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/profiling/heap_graph.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/profiling/profile_common.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/profiling/profile_packet.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/profiling/smaps.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_active_processes.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_application_state_info.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_compositor_scheduler_state.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_content_settings_event_info.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_frame_reporter.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_histogram_sample.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_keyed_service.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_latency_info.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_legacy_ipc.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_message_pump.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_mojo_event_info.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_process_descriptor.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_renderer_scheduler_state.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_thread_descriptor.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_user_event.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_window_handle_event_info.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/counter_descriptor.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/debug_annotation.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/log_message.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/process_descriptor.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/range_of_interest.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/source_location.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/task_execution.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/thread_descriptor.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/track_descriptor.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/track_event.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/interned_data/interned_data.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_active_processes.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_active_processes.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_ACTIVE_PROCESSES_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_ACTIVE_PROCESSES_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeActiveProcesses;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT ChromeActiveProcesses : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kPidFieldNumber = 1,
-  };
-
-  ChromeActiveProcesses();
-  ~ChromeActiveProcesses() override;
-  ChromeActiveProcesses(ChromeActiveProcesses&&) noexcept;
-  ChromeActiveProcesses& operator=(ChromeActiveProcesses&&);
-  ChromeActiveProcesses(const ChromeActiveProcesses&);
-  ChromeActiveProcesses& operator=(const ChromeActiveProcesses&);
-  bool operator==(const ChromeActiveProcesses&) const;
-  bool operator!=(const ChromeActiveProcesses& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<int32_t>& pid() const { return pid_; }
-  std::vector<int32_t>* mutable_pid() { return &pid_; }
-  int pid_size() const { return static_cast<int>(pid_.size()); }
-  void clear_pid() { pid_.clear(); }
-  void add_pid(int32_t value) { pid_.emplace_back(value); }
-  int32_t* add_pid() { pid_.emplace_back(); return &pid_.back(); }
-
- private:
-  std::vector<int32_t> pid_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_ACTIVE_PROCESSES_PROTO_CPP_H_
+// gen_amalgamated begin source: gen/protos/perfetto/config/protovm/protovm_config.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -27924,26 +24792,25 @@ class PERFETTO_EXPORT_COMPONENT ChromeActiveProcesses : public ::protozero::CppM
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_active_processes.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/protovm/protovm_config.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-ChromeActiveProcesses::ChromeActiveProcesses() = default;
-ChromeActiveProcesses::~ChromeActiveProcesses() = default;
-ChromeActiveProcesses::ChromeActiveProcesses(const ChromeActiveProcesses&) = default;
-ChromeActiveProcesses& ChromeActiveProcesses::operator=(const ChromeActiveProcesses&) = default;
-ChromeActiveProcesses::ChromeActiveProcesses(ChromeActiveProcesses&&) noexcept = default;
-ChromeActiveProcesses& ChromeActiveProcesses::operator=(ChromeActiveProcesses&&) = default;
+ProtoVmConfig::ProtoVmConfig() = default;
+ProtoVmConfig::~ProtoVmConfig() = default;
+ProtoVmConfig::ProtoVmConfig(const ProtoVmConfig&) = default;
+ProtoVmConfig& ProtoVmConfig::operator=(const ProtoVmConfig&) = default;
+ProtoVmConfig::ProtoVmConfig(ProtoVmConfig&&) noexcept = default;
+ProtoVmConfig& ProtoVmConfig::operator=(ProtoVmConfig&&) = default;
 
-bool ChromeActiveProcesses::operator==(const ChromeActiveProcesses& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && pid_ == other.pid_;
+bool ProtoVmConfig::operator==(const ProtoVmConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(memory_limit_kb_, other.memory_limit_kb_);
 }
 
-bool ChromeActiveProcesses::ParseFromArray(const void* raw, size_t size) {
-  pid_.clear();
+bool ProtoVmConfig::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -27953,9 +24820,8 @@ bool ChromeActiveProcesses::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* pid */:
-        pid_.emplace_back();
-        field.get(&pid_.back());
+      case 1 /* memory_limit_kb */:
+        field.get(&memory_limit_kb_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -27965,22 +24831,22 @@ bool ChromeActiveProcesses::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ChromeActiveProcesses::SerializeAsString() const {
+std::string ProtoVmConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ChromeActiveProcesses::SerializeAsArray() const {
+std::vector<uint8_t> ProtoVmConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ChromeActiveProcesses::Serialize(::protozero::Message* msg) const {
-  // Field 1: pid
-  for (auto& it : pid_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, it, msg);
+void ProtoVmConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: memory_limit_kb
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, memory_limit_kb_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -27992,122 +24858,41 @@ void ChromeActiveProcesses::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_application_state_info.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_application_state_info.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_APPLICATION_STATE_INFO_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_APPLICATION_STATE_INFO_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeApplicationStateInfo;
-enum ChromeApplicationStateInfo_ChromeApplicationState : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum ChromeApplicationStateInfo_ChromeApplicationState : int {
-  ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_UNKNOWN = 0,
-  ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_RUNNING_ACTIVITIES = 1,
-  ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_PAUSED_ACTIVITIES = 2,
-  ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_STOPPED_ACTIVITIES = 3,
-  ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES = 4,
-};
-
-class PERFETTO_EXPORT_COMPONENT ChromeApplicationStateInfo : public ::protozero::CppMessageObj {
- public:
-  using ChromeApplicationState = ChromeApplicationStateInfo_ChromeApplicationState;
-  static constexpr auto APPLICATION_STATE_UNKNOWN = ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_UNKNOWN;
-  static constexpr auto APPLICATION_STATE_HAS_RUNNING_ACTIVITIES = ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_RUNNING_ACTIVITIES;
-  static constexpr auto APPLICATION_STATE_HAS_PAUSED_ACTIVITIES = ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_PAUSED_ACTIVITIES;
-  static constexpr auto APPLICATION_STATE_HAS_STOPPED_ACTIVITIES = ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_STOPPED_ACTIVITIES;
-  static constexpr auto APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES = ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES;
-  static constexpr auto ChromeApplicationState_MIN = ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_UNKNOWN;
-  static constexpr auto ChromeApplicationState_MAX = ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES;
-  enum FieldNumbers {
-    kApplicationStateFieldNumber = 1,
-  };
-
-  ChromeApplicationStateInfo();
-  ~ChromeApplicationStateInfo() override;
-  ChromeApplicationStateInfo(ChromeApplicationStateInfo&&) noexcept;
-  ChromeApplicationStateInfo& operator=(ChromeApplicationStateInfo&&);
-  ChromeApplicationStateInfo(const ChromeApplicationStateInfo&);
-  ChromeApplicationStateInfo& operator=(const ChromeApplicationStateInfo&);
-  bool operator==(const ChromeApplicationStateInfo&) const;
-  bool operator!=(const ChromeApplicationStateInfo& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_application_state() const { return _has_field_[1]; }
-  ChromeApplicationStateInfo_ChromeApplicationState application_state() const { return application_state_; }
-  void set_application_state(ChromeApplicationStateInfo_ChromeApplicationState value) { application_state_ = value; _has_field_.set(1); }
-
- private:
-  ChromeApplicationStateInfo_ChromeApplicationState application_state_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_APPLICATION_STATE_INFO_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// gen_amalgamated begin source: gen/protos/perfetto/config/qnx/qnx_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_application_state_info.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/qnx/qnx_config.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-ChromeApplicationStateInfo::ChromeApplicationStateInfo() = default;
-ChromeApplicationStateInfo::~ChromeApplicationStateInfo() = default;
-ChromeApplicationStateInfo::ChromeApplicationStateInfo(const ChromeApplicationStateInfo&) = default;
-ChromeApplicationStateInfo& ChromeApplicationStateInfo::operator=(const ChromeApplicationStateInfo&) = default;
-ChromeApplicationStateInfo::ChromeApplicationStateInfo(ChromeApplicationStateInfo&&) noexcept = default;
-ChromeApplicationStateInfo& ChromeApplicationStateInfo::operator=(ChromeApplicationStateInfo&&) = default;
+QnxConfig::QnxConfig() = default;
+QnxConfig::~QnxConfig() = default;
+QnxConfig::QnxConfig(const QnxConfig&) = default;
+QnxConfig& QnxConfig::operator=(const QnxConfig&) = default;
+QnxConfig::QnxConfig(QnxConfig&&) noexcept = default;
+QnxConfig& QnxConfig::operator=(QnxConfig&&) = default;
 
-bool ChromeApplicationStateInfo::operator==(const ChromeApplicationStateInfo& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && application_state_ == other.application_state_;
+bool QnxConfig::operator==(const QnxConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(qnx_kernel_buffers_, other.qnx_kernel_buffers_)
+   && ::protozero::internal::gen_helpers::EqualsField(qnx_kernel_kbuffers_, other.qnx_kernel_kbuffers_)
+   && ::protozero::internal::gen_helpers::EqualsField(qnx_kernel_wide_events_, other.qnx_kernel_wide_events_)
+   && ::protozero::internal::gen_helpers::EqualsField(qnx_cache_pages_, other.qnx_cache_pages_)
+   && ::protozero::internal::gen_helpers::EqualsField(qnx_cache_max_pages_, other.qnx_cache_max_pages_)
+   && ::protozero::internal::gen_helpers::EqualsField(qnx_trace_buffer_init_bytes_, other.qnx_trace_buffer_init_bytes_);
 }
 
-bool ChromeApplicationStateInfo::ParseFromArray(const void* raw, size_t size) {
+bool QnxConfig::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -28117,8 +24902,23 @@ bool ChromeApplicationStateInfo::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* application_state */:
-        field.get(&application_state_);
+      case 1 /* qnx_kernel_buffers */:
+        field.get(&qnx_kernel_buffers_);
+        break;
+      case 2 /* qnx_kernel_kbuffers */:
+        field.get(&qnx_kernel_kbuffers_);
+        break;
+      case 3 /* qnx_kernel_wide_events */:
+        field.get(&qnx_kernel_wide_events_);
+        break;
+      case 4 /* qnx_cache_pages */:
+        field.get(&qnx_cache_pages_);
+        break;
+      case 5 /* qnx_cache_max_pages */:
+        field.get(&qnx_cache_max_pages_);
+        break;
+      case 6 /* qnx_trace_buffer_init_bytes */:
+        field.get(&qnx_trace_buffer_init_bytes_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -28128,1285 +24928,81 @@ bool ChromeApplicationStateInfo::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ChromeApplicationStateInfo::SerializeAsString() const {
+std::string QnxConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ChromeApplicationStateInfo::SerializeAsArray() const {
+std::vector<uint8_t> QnxConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ChromeApplicationStateInfo::Serialize(::protozero::Message* msg) const {
-  // Field 1: application_state
+void QnxConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: qnx_kernel_buffers
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, application_state_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, qnx_kernel_buffers_, msg);
   }
 
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
-}
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_compositor_scheduler_state.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_compositor_scheduler_state.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_COMPOSITOR_SCHEDULER_STATE_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_COMPOSITOR_SCHEDULER_STATE_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class CompositorTimingHistory;
-class BeginFrameSourceState;
-class BeginFrameArgs;
-class SourceLocation;
-class BeginFrameObserverState;
-class BeginImplFrameArgs;
-class BeginImplFrameArgs_TimestampsInUs;
-class ChromeCompositorStateMachine;
-class ChromeCompositorStateMachine_MinorState;
-class ChromeCompositorStateMachine_MajorState;
-class ChromeCompositorSchedulerState;
-enum ChromeCompositorSchedulerAction : int;
-enum BeginFrameArgs_BeginFrameArgsType : int;
-enum BeginImplFrameArgs_State : int;
-enum ChromeCompositorStateMachine_MinorState_TreePriority : int;
-enum ChromeCompositorStateMachine_MinorState_ScrollHandlerState : int;
-enum ChromeCompositorStateMachine_MajorState_BeginImplFrameState : int;
-enum ChromeCompositorStateMachine_MajorState_BeginMainFrameState : int;
-enum ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState : int;
-enum ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState : int;
-enum ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum ChromeCompositorSchedulerAction : int {
-  CC_SCHEDULER_ACTION_UNSPECIFIED = 0,
-  CC_SCHEDULER_ACTION_NONE = 1,
-  CC_SCHEDULER_ACTION_SEND_BEGIN_MAIN_FRAME = 2,
-  CC_SCHEDULER_ACTION_COMMIT = 3,
-  CC_SCHEDULER_ACTION_ACTIVATE_SYNC_TREE = 4,
-  CC_SCHEDULER_ACTION_DRAW_IF_POSSIBLE = 5,
-  CC_SCHEDULER_ACTION_DRAW_FORCED = 6,
-  CC_SCHEDULER_ACTION_DRAW_ABORT = 7,
-  CC_SCHEDULER_ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION = 8,
-  CC_SCHEDULER_ACTION_PREPARE_TILES = 9,
-  CC_SCHEDULER_ACTION_INVALIDATE_LAYER_TREE_FRAME_SINK = 10,
-  CC_SCHEDULER_ACTION_PERFORM_IMPL_SIDE_INVALIDATION = 11,
-  CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_UNTIL = 12,
-  CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_SOON = 13,
-};
-enum BeginFrameArgs_BeginFrameArgsType : int {
-  BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED = 0,
-  BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_INVALID = 1,
-  BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_NORMAL = 2,
-  BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_MISSED = 3,
-};
-enum BeginImplFrameArgs_State : int {
-  BeginImplFrameArgs_State_BEGIN_FRAME_FINISHED = 0,
-  BeginImplFrameArgs_State_BEGIN_FRAME_USING = 1,
-};
-enum ChromeCompositorStateMachine_MinorState_TreePriority : int {
-  ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_UNSPECIFIED = 0,
-  ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES = 1,
-  ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY = 2,
-  ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY = 3,
-};
-enum ChromeCompositorStateMachine_MinorState_ScrollHandlerState : int {
-  ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_HANDLER_UNSPECIFIED = 0,
-  ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_AFFECTS_SCROLL_HANDLER = 1,
-  ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER = 2,
-};
-enum ChromeCompositorStateMachine_MajorState_BeginImplFrameState : int {
-  ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_UNSPECIFIED = 0,
-  ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_IDLE = 1,
-  ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME = 2,
-  ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_INSIDE_DEADLINE = 3,
-};
-enum ChromeCompositorStateMachine_MajorState_BeginMainFrameState : int {
-  ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_UNSPECIFIED = 0,
-  ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_IDLE = 1,
-  ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_SENT = 2,
-  ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_READY_TO_COMMIT = 3,
-};
-enum ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState : int {
-  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_UNSPECIFIED = 0,
-  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_NONE = 1,
-  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_ACTIVE = 2,
-  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_CREATING = 3,
-  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT = 4,
-  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION = 5,
-};
-enum ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState : int {
-  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_UNSPECIFIED = 0,
-  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_IDLE = 1,
-  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_COMMIT = 2,
-  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_ACTIVATION = 3,
-  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_DRAW = 4,
-};
-enum ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode : int {
-  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_UNSPECIFIED = 0,
-  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_NONE = 1,
-  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_IMMEDIATE = 2,
-  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_REGULAR = 3,
-  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_LATE = 4,
-  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_BLOCKED = 5,
-};
-
-class PERFETTO_EXPORT_COMPONENT CompositorTimingHistory : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kBeginMainFrameQueueCriticalEstimateDeltaUsFieldNumber = 1,
-    kBeginMainFrameQueueNotCriticalEstimateDeltaUsFieldNumber = 2,
-    kBeginMainFrameStartToReadyToCommitEstimateDeltaUsFieldNumber = 3,
-    kCommitToReadyToActivateEstimateDeltaUsFieldNumber = 4,
-    kPrepareTilesEstimateDeltaUsFieldNumber = 5,
-    kActivateEstimateDeltaUsFieldNumber = 6,
-    kDrawEstimateDeltaUsFieldNumber = 7,
-  };
-
-  CompositorTimingHistory();
-  ~CompositorTimingHistory() override;
-  CompositorTimingHistory(CompositorTimingHistory&&) noexcept;
-  CompositorTimingHistory& operator=(CompositorTimingHistory&&);
-  CompositorTimingHistory(const CompositorTimingHistory&);
-  CompositorTimingHistory& operator=(const CompositorTimingHistory&);
-  bool operator==(const CompositorTimingHistory&) const;
-  bool operator!=(const CompositorTimingHistory& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_begin_main_frame_queue_critical_estimate_delta_us() const { return _has_field_[1]; }
-  int64_t begin_main_frame_queue_critical_estimate_delta_us() const { return begin_main_frame_queue_critical_estimate_delta_us_; }
-  void set_begin_main_frame_queue_critical_estimate_delta_us(int64_t value) { begin_main_frame_queue_critical_estimate_delta_us_ = value; _has_field_.set(1); }
-
-  bool has_begin_main_frame_queue_not_critical_estimate_delta_us() const { return _has_field_[2]; }
-  int64_t begin_main_frame_queue_not_critical_estimate_delta_us() const { return begin_main_frame_queue_not_critical_estimate_delta_us_; }
-  void set_begin_main_frame_queue_not_critical_estimate_delta_us(int64_t value) { begin_main_frame_queue_not_critical_estimate_delta_us_ = value; _has_field_.set(2); }
-
-  bool has_begin_main_frame_start_to_ready_to_commit_estimate_delta_us() const { return _has_field_[3]; }
-  int64_t begin_main_frame_start_to_ready_to_commit_estimate_delta_us() const { return begin_main_frame_start_to_ready_to_commit_estimate_delta_us_; }
-  void set_begin_main_frame_start_to_ready_to_commit_estimate_delta_us(int64_t value) { begin_main_frame_start_to_ready_to_commit_estimate_delta_us_ = value; _has_field_.set(3); }
-
-  bool has_commit_to_ready_to_activate_estimate_delta_us() const { return _has_field_[4]; }
-  int64_t commit_to_ready_to_activate_estimate_delta_us() const { return commit_to_ready_to_activate_estimate_delta_us_; }
-  void set_commit_to_ready_to_activate_estimate_delta_us(int64_t value) { commit_to_ready_to_activate_estimate_delta_us_ = value; _has_field_.set(4); }
-
-  bool has_prepare_tiles_estimate_delta_us() const { return _has_field_[5]; }
-  int64_t prepare_tiles_estimate_delta_us() const { return prepare_tiles_estimate_delta_us_; }
-  void set_prepare_tiles_estimate_delta_us(int64_t value) { prepare_tiles_estimate_delta_us_ = value; _has_field_.set(5); }
-
-  bool has_activate_estimate_delta_us() const { return _has_field_[6]; }
-  int64_t activate_estimate_delta_us() const { return activate_estimate_delta_us_; }
-  void set_activate_estimate_delta_us(int64_t value) { activate_estimate_delta_us_ = value; _has_field_.set(6); }
-
-  bool has_draw_estimate_delta_us() const { return _has_field_[7]; }
-  int64_t draw_estimate_delta_us() const { return draw_estimate_delta_us_; }
-  void set_draw_estimate_delta_us(int64_t value) { draw_estimate_delta_us_ = value; _has_field_.set(7); }
-
- private:
-  int64_t begin_main_frame_queue_critical_estimate_delta_us_{};
-  int64_t begin_main_frame_queue_not_critical_estimate_delta_us_{};
-  int64_t begin_main_frame_start_to_ready_to_commit_estimate_delta_us_{};
-  int64_t commit_to_ready_to_activate_estimate_delta_us_{};
-  int64_t prepare_tiles_estimate_delta_us_{};
-  int64_t activate_estimate_delta_us_{};
-  int64_t draw_estimate_delta_us_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<8> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT BeginFrameSourceState : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kSourceIdFieldNumber = 1,
-    kPausedFieldNumber = 2,
-    kNumObserversFieldNumber = 3,
-    kLastBeginFrameArgsFieldNumber = 4,
-  };
-
-  BeginFrameSourceState();
-  ~BeginFrameSourceState() override;
-  BeginFrameSourceState(BeginFrameSourceState&&) noexcept;
-  BeginFrameSourceState& operator=(BeginFrameSourceState&&);
-  BeginFrameSourceState(const BeginFrameSourceState&);
-  BeginFrameSourceState& operator=(const BeginFrameSourceState&);
-  bool operator==(const BeginFrameSourceState&) const;
-  bool operator!=(const BeginFrameSourceState& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_source_id() const { return _has_field_[1]; }
-  uint32_t source_id() const { return source_id_; }
-  void set_source_id(uint32_t value) { source_id_ = value; _has_field_.set(1); }
-
-  bool has_paused() const { return _has_field_[2]; }
-  bool paused() const { return paused_; }
-  void set_paused(bool value) { paused_ = value; _has_field_.set(2); }
-
-  bool has_num_observers() const { return _has_field_[3]; }
-  uint32_t num_observers() const { return num_observers_; }
-  void set_num_observers(uint32_t value) { num_observers_ = value; _has_field_.set(3); }
-
-  bool has_last_begin_frame_args() const { return _has_field_[4]; }
-  const BeginFrameArgs& last_begin_frame_args() const { return *last_begin_frame_args_; }
-  BeginFrameArgs* mutable_last_begin_frame_args() { _has_field_.set(4); return last_begin_frame_args_.get(); }
-
- private:
-  uint32_t source_id_{};
-  bool paused_{};
-  uint32_t num_observers_{};
-  ::protozero::CopyablePtr<BeginFrameArgs> last_begin_frame_args_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<5> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT BeginFrameArgs : public ::protozero::CppMessageObj {
- public:
-  using BeginFrameArgsType = BeginFrameArgs_BeginFrameArgsType;
-  static constexpr auto BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED = BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED;
-  static constexpr auto BEGIN_FRAME_ARGS_TYPE_INVALID = BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_INVALID;
-  static constexpr auto BEGIN_FRAME_ARGS_TYPE_NORMAL = BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_NORMAL;
-  static constexpr auto BEGIN_FRAME_ARGS_TYPE_MISSED = BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_MISSED;
-  static constexpr auto BeginFrameArgsType_MIN = BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED;
-  static constexpr auto BeginFrameArgsType_MAX = BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_MISSED;
-  enum FieldNumbers {
-    kTypeFieldNumber = 1,
-    kSourceIdFieldNumber = 2,
-    kSequenceNumberFieldNumber = 3,
-    kFrameTimeUsFieldNumber = 4,
-    kDeadlineUsFieldNumber = 5,
-    kIntervalDeltaUsFieldNumber = 6,
-    kOnCriticalPathFieldNumber = 7,
-    kAnimateOnlyFieldNumber = 8,
-    kSourceLocationIidFieldNumber = 9,
-    kSourceLocationFieldNumber = 10,
-    kFramesThrottledSinceLastFieldNumber = 12,
-  };
-
-  BeginFrameArgs();
-  ~BeginFrameArgs() override;
-  BeginFrameArgs(BeginFrameArgs&&) noexcept;
-  BeginFrameArgs& operator=(BeginFrameArgs&&);
-  BeginFrameArgs(const BeginFrameArgs&);
-  BeginFrameArgs& operator=(const BeginFrameArgs&);
-  bool operator==(const BeginFrameArgs&) const;
-  bool operator!=(const BeginFrameArgs& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_type() const { return _has_field_[1]; }
-  BeginFrameArgs_BeginFrameArgsType type() const { return type_; }
-  void set_type(BeginFrameArgs_BeginFrameArgsType value) { type_ = value; _has_field_.set(1); }
-
-  bool has_source_id() const { return _has_field_[2]; }
-  uint64_t source_id() const { return source_id_; }
-  void set_source_id(uint64_t value) { source_id_ = value; _has_field_.set(2); }
-
-  bool has_sequence_number() const { return _has_field_[3]; }
-  uint64_t sequence_number() const { return sequence_number_; }
-  void set_sequence_number(uint64_t value) { sequence_number_ = value; _has_field_.set(3); }
-
-  bool has_frame_time_us() const { return _has_field_[4]; }
-  int64_t frame_time_us() const { return frame_time_us_; }
-  void set_frame_time_us(int64_t value) { frame_time_us_ = value; _has_field_.set(4); }
-
-  bool has_deadline_us() const { return _has_field_[5]; }
-  int64_t deadline_us() const { return deadline_us_; }
-  void set_deadline_us(int64_t value) { deadline_us_ = value; _has_field_.set(5); }
-
-  bool has_interval_delta_us() const { return _has_field_[6]; }
-  int64_t interval_delta_us() const { return interval_delta_us_; }
-  void set_interval_delta_us(int64_t value) { interval_delta_us_ = value; _has_field_.set(6); }
-
-  bool has_on_critical_path() const { return _has_field_[7]; }
-  bool on_critical_path() const { return on_critical_path_; }
-  void set_on_critical_path(bool value) { on_critical_path_ = value; _has_field_.set(7); }
-
-  bool has_animate_only() const { return _has_field_[8]; }
-  bool animate_only() const { return animate_only_; }
-  void set_animate_only(bool value) { animate_only_ = value; _has_field_.set(8); }
-
-  bool has_source_location_iid() const { return _has_field_[9]; }
-  uint64_t source_location_iid() const { return source_location_iid_; }
-  void set_source_location_iid(uint64_t value) { source_location_iid_ = value; _has_field_.set(9); }
-
-  bool has_source_location() const { return _has_field_[10]; }
-  const SourceLocation& source_location() const { return *source_location_; }
-  SourceLocation* mutable_source_location() { _has_field_.set(10); return source_location_.get(); }
-
-  bool has_frames_throttled_since_last() const { return _has_field_[12]; }
-  int64_t frames_throttled_since_last() const { return frames_throttled_since_last_; }
-  void set_frames_throttled_since_last(int64_t value) { frames_throttled_since_last_ = value; _has_field_.set(12); }
-
- private:
-  BeginFrameArgs_BeginFrameArgsType type_{};
-  uint64_t source_id_{};
-  uint64_t sequence_number_{};
-  int64_t frame_time_us_{};
-  int64_t deadline_us_{};
-  int64_t interval_delta_us_{};
-  bool on_critical_path_{};
-  bool animate_only_{};
-  uint64_t source_location_iid_{};
-  ::protozero::CopyablePtr<SourceLocation> source_location_;
-  int64_t frames_throttled_since_last_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<13> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT BeginFrameObserverState : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kDroppedBeginFrameArgsFieldNumber = 1,
-    kLastBeginFrameArgsFieldNumber = 2,
-  };
-
-  BeginFrameObserverState();
-  ~BeginFrameObserverState() override;
-  BeginFrameObserverState(BeginFrameObserverState&&) noexcept;
-  BeginFrameObserverState& operator=(BeginFrameObserverState&&);
-  BeginFrameObserverState(const BeginFrameObserverState&);
-  BeginFrameObserverState& operator=(const BeginFrameObserverState&);
-  bool operator==(const BeginFrameObserverState&) const;
-  bool operator!=(const BeginFrameObserverState& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_dropped_begin_frame_args() const { return _has_field_[1]; }
-  int64_t dropped_begin_frame_args() const { return dropped_begin_frame_args_; }
-  void set_dropped_begin_frame_args(int64_t value) { dropped_begin_frame_args_ = value; _has_field_.set(1); }
-
-  bool has_last_begin_frame_args() const { return _has_field_[2]; }
-  const BeginFrameArgs& last_begin_frame_args() const { return *last_begin_frame_args_; }
-  BeginFrameArgs* mutable_last_begin_frame_args() { _has_field_.set(2); return last_begin_frame_args_.get(); }
-
- private:
-  int64_t dropped_begin_frame_args_{};
-  ::protozero::CopyablePtr<BeginFrameArgs> last_begin_frame_args_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT BeginImplFrameArgs : public ::protozero::CppMessageObj {
- public:
-  using TimestampsInUs = BeginImplFrameArgs_TimestampsInUs;
-  using State = BeginImplFrameArgs_State;
-  static constexpr auto BEGIN_FRAME_FINISHED = BeginImplFrameArgs_State_BEGIN_FRAME_FINISHED;
-  static constexpr auto BEGIN_FRAME_USING = BeginImplFrameArgs_State_BEGIN_FRAME_USING;
-  static constexpr auto State_MIN = BeginImplFrameArgs_State_BEGIN_FRAME_FINISHED;
-  static constexpr auto State_MAX = BeginImplFrameArgs_State_BEGIN_FRAME_USING;
-  enum FieldNumbers {
-    kUpdatedAtUsFieldNumber = 1,
-    kFinishedAtUsFieldNumber = 2,
-    kStateFieldNumber = 3,
-    kCurrentArgsFieldNumber = 4,
-    kLastArgsFieldNumber = 5,
-    kTimestampsInUsFieldNumber = 6,
-  };
-
-  BeginImplFrameArgs();
-  ~BeginImplFrameArgs() override;
-  BeginImplFrameArgs(BeginImplFrameArgs&&) noexcept;
-  BeginImplFrameArgs& operator=(BeginImplFrameArgs&&);
-  BeginImplFrameArgs(const BeginImplFrameArgs&);
-  BeginImplFrameArgs& operator=(const BeginImplFrameArgs&);
-  bool operator==(const BeginImplFrameArgs&) const;
-  bool operator!=(const BeginImplFrameArgs& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_updated_at_us() const { return _has_field_[1]; }
-  int64_t updated_at_us() const { return updated_at_us_; }
-  void set_updated_at_us(int64_t value) { updated_at_us_ = value; _has_field_.set(1); }
-
-  bool has_finished_at_us() const { return _has_field_[2]; }
-  int64_t finished_at_us() const { return finished_at_us_; }
-  void set_finished_at_us(int64_t value) { finished_at_us_ = value; _has_field_.set(2); }
-
-  bool has_state() const { return _has_field_[3]; }
-  BeginImplFrameArgs_State state() const { return state_; }
-  void set_state(BeginImplFrameArgs_State value) { state_ = value; _has_field_.set(3); }
-
-  bool has_current_args() const { return _has_field_[4]; }
-  const BeginFrameArgs& current_args() const { return *current_args_; }
-  BeginFrameArgs* mutable_current_args() { _has_field_.set(4); return current_args_.get(); }
-
-  bool has_last_args() const { return _has_field_[5]; }
-  const BeginFrameArgs& last_args() const { return *last_args_; }
-  BeginFrameArgs* mutable_last_args() { _has_field_.set(5); return last_args_.get(); }
-
-  bool has_timestamps_in_us() const { return _has_field_[6]; }
-  const BeginImplFrameArgs_TimestampsInUs& timestamps_in_us() const { return *timestamps_in_us_; }
-  BeginImplFrameArgs_TimestampsInUs* mutable_timestamps_in_us() { _has_field_.set(6); return timestamps_in_us_.get(); }
-
- private:
-  int64_t updated_at_us_{};
-  int64_t finished_at_us_{};
-  BeginImplFrameArgs_State state_{};
-  ::protozero::CopyablePtr<BeginFrameArgs> current_args_;
-  ::protozero::CopyablePtr<BeginFrameArgs> last_args_;
-  ::protozero::CopyablePtr<BeginImplFrameArgs_TimestampsInUs> timestamps_in_us_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<7> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT BeginImplFrameArgs_TimestampsInUs : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kIntervalDeltaFieldNumber = 1,
-    kNowToDeadlineDeltaFieldNumber = 2,
-    kFrameTimeToNowDeltaFieldNumber = 3,
-    kFrameTimeToDeadlineDeltaFieldNumber = 4,
-    kNowFieldNumber = 5,
-    kFrameTimeFieldNumber = 6,
-    kDeadlineFieldNumber = 7,
-  };
-
-  BeginImplFrameArgs_TimestampsInUs();
-  ~BeginImplFrameArgs_TimestampsInUs() override;
-  BeginImplFrameArgs_TimestampsInUs(BeginImplFrameArgs_TimestampsInUs&&) noexcept;
-  BeginImplFrameArgs_TimestampsInUs& operator=(BeginImplFrameArgs_TimestampsInUs&&);
-  BeginImplFrameArgs_TimestampsInUs(const BeginImplFrameArgs_TimestampsInUs&);
-  BeginImplFrameArgs_TimestampsInUs& operator=(const BeginImplFrameArgs_TimestampsInUs&);
-  bool operator==(const BeginImplFrameArgs_TimestampsInUs&) const;
-  bool operator!=(const BeginImplFrameArgs_TimestampsInUs& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_interval_delta() const { return _has_field_[1]; }
-  int64_t interval_delta() const { return interval_delta_; }
-  void set_interval_delta(int64_t value) { interval_delta_ = value; _has_field_.set(1); }
-
-  bool has_now_to_deadline_delta() const { return _has_field_[2]; }
-  int64_t now_to_deadline_delta() const { return now_to_deadline_delta_; }
-  void set_now_to_deadline_delta(int64_t value) { now_to_deadline_delta_ = value; _has_field_.set(2); }
-
-  bool has_frame_time_to_now_delta() const { return _has_field_[3]; }
-  int64_t frame_time_to_now_delta() const { return frame_time_to_now_delta_; }
-  void set_frame_time_to_now_delta(int64_t value) { frame_time_to_now_delta_ = value; _has_field_.set(3); }
-
-  bool has_frame_time_to_deadline_delta() const { return _has_field_[4]; }
-  int64_t frame_time_to_deadline_delta() const { return frame_time_to_deadline_delta_; }
-  void set_frame_time_to_deadline_delta(int64_t value) { frame_time_to_deadline_delta_ = value; _has_field_.set(4); }
-
-  bool has_now() const { return _has_field_[5]; }
-  int64_t now() const { return now_; }
-  void set_now(int64_t value) { now_ = value; _has_field_.set(5); }
-
-  bool has_frame_time() const { return _has_field_[6]; }
-  int64_t frame_time() const { return frame_time_; }
-  void set_frame_time(int64_t value) { frame_time_ = value; _has_field_.set(6); }
-
-  bool has_deadline() const { return _has_field_[7]; }
-  int64_t deadline() const { return deadline_; }
-  void set_deadline(int64_t value) { deadline_ = value; _has_field_.set(7); }
-
- private:
-  int64_t interval_delta_{};
-  int64_t now_to_deadline_delta_{};
-  int64_t frame_time_to_now_delta_{};
-  int64_t frame_time_to_deadline_delta_{};
-  int64_t now_{};
-  int64_t frame_time_{};
-  int64_t deadline_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<8> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT ChromeCompositorStateMachine : public ::protozero::CppMessageObj {
- public:
-  using MajorState = ChromeCompositorStateMachine_MajorState;
-  using MinorState = ChromeCompositorStateMachine_MinorState;
-  enum FieldNumbers {
-    kMajorStateFieldNumber = 1,
-    kMinorStateFieldNumber = 2,
-  };
-
-  ChromeCompositorStateMachine();
-  ~ChromeCompositorStateMachine() override;
-  ChromeCompositorStateMachine(ChromeCompositorStateMachine&&) noexcept;
-  ChromeCompositorStateMachine& operator=(ChromeCompositorStateMachine&&);
-  ChromeCompositorStateMachine(const ChromeCompositorStateMachine&);
-  ChromeCompositorStateMachine& operator=(const ChromeCompositorStateMachine&);
-  bool operator==(const ChromeCompositorStateMachine&) const;
-  bool operator!=(const ChromeCompositorStateMachine& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_major_state() const { return _has_field_[1]; }
-  const ChromeCompositorStateMachine_MajorState& major_state() const { return *major_state_; }
-  ChromeCompositorStateMachine_MajorState* mutable_major_state() { _has_field_.set(1); return major_state_.get(); }
-
-  bool has_minor_state() const { return _has_field_[2]; }
-  const ChromeCompositorStateMachine_MinorState& minor_state() const { return *minor_state_; }
-  ChromeCompositorStateMachine_MinorState* mutable_minor_state() { _has_field_.set(2); return minor_state_.get(); }
-
- private:
-  ::protozero::CopyablePtr<ChromeCompositorStateMachine_MajorState> major_state_;
-  ::protozero::CopyablePtr<ChromeCompositorStateMachine_MinorState> minor_state_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT ChromeCompositorStateMachine_MinorState : public ::protozero::CppMessageObj {
- public:
-  using TreePriority = ChromeCompositorStateMachine_MinorState_TreePriority;
-  static constexpr auto TREE_PRIORITY_UNSPECIFIED = ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_UNSPECIFIED;
-  static constexpr auto TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES = ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES;
-  static constexpr auto TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY = ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY;
-  static constexpr auto TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY = ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY;
-  static constexpr auto TreePriority_MIN = ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_UNSPECIFIED;
-  static constexpr auto TreePriority_MAX = ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY;
-  using ScrollHandlerState = ChromeCompositorStateMachine_MinorState_ScrollHandlerState;
-  static constexpr auto SCROLL_HANDLER_UNSPECIFIED = ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_HANDLER_UNSPECIFIED;
-  static constexpr auto SCROLL_AFFECTS_SCROLL_HANDLER = ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_AFFECTS_SCROLL_HANDLER;
-  static constexpr auto SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER = ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER;
-  static constexpr auto ScrollHandlerState_MIN = ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_HANDLER_UNSPECIFIED;
-  static constexpr auto ScrollHandlerState_MAX = ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER;
-  enum FieldNumbers {
-    kCommitCountFieldNumber = 1,
-    kCurrentFrameNumberFieldNumber = 2,
-    kLastFrameNumberSubmitPerformedFieldNumber = 3,
-    kLastFrameNumberDrawPerformedFieldNumber = 4,
-    kLastFrameNumberBeginMainFrameSentFieldNumber = 5,
-    kDidDrawFieldNumber = 6,
-    kDidSendBeginMainFrameForCurrentFrameFieldNumber = 7,
-    kDidNotifyBeginMainFrameNotExpectedUntilFieldNumber = 8,
-    kDidNotifyBeginMainFrameNotExpectedSoonFieldNumber = 9,
-    kWantsBeginMainFrameNotExpectedFieldNumber = 10,
-    kDidCommitDuringFrameFieldNumber = 11,
-    kDidInvalidateLayerTreeFrameSinkFieldNumber = 12,
-    kDidPerformImplSideInvalidaionFieldNumber = 13,
-    kDidPrepareTilesFieldNumber = 14,
-    kConsecutiveCheckerboardAnimationsFieldNumber = 15,
-    kPendingSubmitFramesFieldNumber = 16,
-    kSubmitFramesWithCurrentLayerTreeFrameSinkFieldNumber = 17,
-    kNeedsRedrawFieldNumber = 18,
-    kNeedsPrepareTilesFieldNumber = 19,
-    kNeedsBeginMainFrameFieldNumber = 20,
-    kNeedsOneBeginImplFrameFieldNumber = 21,
-    kVisibleFieldNumber = 22,
-    kBeginFrameSourcePausedFieldNumber = 23,
-    kCanDrawFieldNumber = 24,
-    kResourcelessDrawFieldNumber = 25,
-    kHasPendingTreeFieldNumber = 26,
-    kPendingTreeIsReadyForActivationFieldNumber = 27,
-    kActiveTreeNeedsFirstDrawFieldNumber = 28,
-    kActiveTreeIsReadyToDrawFieldNumber = 29,
-    kDidCreateAndInitializeFirstLayerTreeFrameSinkFieldNumber = 30,
-    kTreePriorityFieldNumber = 31,
-    kScrollHandlerStateFieldNumber = 32,
-    kCriticalBeginMainFrameToActivateIsFastFieldNumber = 33,
-    kMainThreadMissedLastDeadlineFieldNumber = 34,
-    kVideoNeedsBeginFramesFieldNumber = 36,
-    kDeferBeginMainFrameFieldNumber = 37,
-    kLastCommitHadNoUpdatesFieldNumber = 38,
-    kDidDrawInLastFrameFieldNumber = 39,
-    kDidSubmitInLastFrameFieldNumber = 40,
-    kNeedsImplSideInvalidationFieldNumber = 41,
-    kCurrentPendingTreeIsImplSideFieldNumber = 42,
-    kPreviousPendingTreeWasImplSideFieldNumber = 43,
-    kProcessingAnimationWorkletsForActiveTreeFieldNumber = 44,
-    kProcessingAnimationWorkletsForPendingTreeFieldNumber = 45,
-    kProcessingPaintWorkletsForPendingTreeFieldNumber = 46,
-  };
-
-  ChromeCompositorStateMachine_MinorState();
-  ~ChromeCompositorStateMachine_MinorState() override;
-  ChromeCompositorStateMachine_MinorState(ChromeCompositorStateMachine_MinorState&&) noexcept;
-  ChromeCompositorStateMachine_MinorState& operator=(ChromeCompositorStateMachine_MinorState&&);
-  ChromeCompositorStateMachine_MinorState(const ChromeCompositorStateMachine_MinorState&);
-  ChromeCompositorStateMachine_MinorState& operator=(const ChromeCompositorStateMachine_MinorState&);
-  bool operator==(const ChromeCompositorStateMachine_MinorState&) const;
-  bool operator!=(const ChromeCompositorStateMachine_MinorState& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_commit_count() const { return _has_field_[1]; }
-  int32_t commit_count() const { return commit_count_; }
-  void set_commit_count(int32_t value) { commit_count_ = value; _has_field_.set(1); }
-
-  bool has_current_frame_number() const { return _has_field_[2]; }
-  int32_t current_frame_number() const { return current_frame_number_; }
-  void set_current_frame_number(int32_t value) { current_frame_number_ = value; _has_field_.set(2); }
-
-  bool has_last_frame_number_submit_performed() const { return _has_field_[3]; }
-  int32_t last_frame_number_submit_performed() const { return last_frame_number_submit_performed_; }
-  void set_last_frame_number_submit_performed(int32_t value) { last_frame_number_submit_performed_ = value; _has_field_.set(3); }
-
-  bool has_last_frame_number_draw_performed() const { return _has_field_[4]; }
-  int32_t last_frame_number_draw_performed() const { return last_frame_number_draw_performed_; }
-  void set_last_frame_number_draw_performed(int32_t value) { last_frame_number_draw_performed_ = value; _has_field_.set(4); }
-
-  bool has_last_frame_number_begin_main_frame_sent() const { return _has_field_[5]; }
-  int32_t last_frame_number_begin_main_frame_sent() const { return last_frame_number_begin_main_frame_sent_; }
-  void set_last_frame_number_begin_main_frame_sent(int32_t value) { last_frame_number_begin_main_frame_sent_ = value; _has_field_.set(5); }
-
-  bool has_did_draw() const { return _has_field_[6]; }
-  bool did_draw() const { return did_draw_; }
-  void set_did_draw(bool value) { did_draw_ = value; _has_field_.set(6); }
-
-  bool has_did_send_begin_main_frame_for_current_frame() const { return _has_field_[7]; }
-  bool did_send_begin_main_frame_for_current_frame() const { return did_send_begin_main_frame_for_current_frame_; }
-  void set_did_send_begin_main_frame_for_current_frame(bool value) { did_send_begin_main_frame_for_current_frame_ = value; _has_field_.set(7); }
-
-  bool has_did_notify_begin_main_frame_not_expected_until() const { return _has_field_[8]; }
-  bool did_notify_begin_main_frame_not_expected_until() const { return did_notify_begin_main_frame_not_expected_until_; }
-  void set_did_notify_begin_main_frame_not_expected_until(bool value) { did_notify_begin_main_frame_not_expected_until_ = value; _has_field_.set(8); }
-
-  bool has_did_notify_begin_main_frame_not_expected_soon() const { return _has_field_[9]; }
-  bool did_notify_begin_main_frame_not_expected_soon() const { return did_notify_begin_main_frame_not_expected_soon_; }
-  void set_did_notify_begin_main_frame_not_expected_soon(bool value) { did_notify_begin_main_frame_not_expected_soon_ = value; _has_field_.set(9); }
-
-  bool has_wants_begin_main_frame_not_expected() const { return _has_field_[10]; }
-  bool wants_begin_main_frame_not_expected() const { return wants_begin_main_frame_not_expected_; }
-  void set_wants_begin_main_frame_not_expected(bool value) { wants_begin_main_frame_not_expected_ = value; _has_field_.set(10); }
-
-  bool has_did_commit_during_frame() const { return _has_field_[11]; }
-  bool did_commit_during_frame() const { return did_commit_during_frame_; }
-  void set_did_commit_during_frame(bool value) { did_commit_during_frame_ = value; _has_field_.set(11); }
-
-  bool has_did_invalidate_layer_tree_frame_sink() const { return _has_field_[12]; }
-  bool did_invalidate_layer_tree_frame_sink() const { return did_invalidate_layer_tree_frame_sink_; }
-  void set_did_invalidate_layer_tree_frame_sink(bool value) { did_invalidate_layer_tree_frame_sink_ = value; _has_field_.set(12); }
-
-  bool has_did_perform_impl_side_invalidaion() const { return _has_field_[13]; }
-  bool did_perform_impl_side_invalidaion() const { return did_perform_impl_side_invalidaion_; }
-  void set_did_perform_impl_side_invalidaion(bool value) { did_perform_impl_side_invalidaion_ = value; _has_field_.set(13); }
-
-  bool has_did_prepare_tiles() const { return _has_field_[14]; }
-  bool did_prepare_tiles() const { return did_prepare_tiles_; }
-  void set_did_prepare_tiles(bool value) { did_prepare_tiles_ = value; _has_field_.set(14); }
-
-  bool has_consecutive_checkerboard_animations() const { return _has_field_[15]; }
-  int32_t consecutive_checkerboard_animations() const { return consecutive_checkerboard_animations_; }
-  void set_consecutive_checkerboard_animations(int32_t value) { consecutive_checkerboard_animations_ = value; _has_field_.set(15); }
-
-  bool has_pending_submit_frames() const { return _has_field_[16]; }
-  int32_t pending_submit_frames() const { return pending_submit_frames_; }
-  void set_pending_submit_frames(int32_t value) { pending_submit_frames_ = value; _has_field_.set(16); }
-
-  bool has_submit_frames_with_current_layer_tree_frame_sink() const { return _has_field_[17]; }
-  int32_t submit_frames_with_current_layer_tree_frame_sink() const { return submit_frames_with_current_layer_tree_frame_sink_; }
-  void set_submit_frames_with_current_layer_tree_frame_sink(int32_t value) { submit_frames_with_current_layer_tree_frame_sink_ = value; _has_field_.set(17); }
-
-  bool has_needs_redraw() const { return _has_field_[18]; }
-  bool needs_redraw() const { return needs_redraw_; }
-  void set_needs_redraw(bool value) { needs_redraw_ = value; _has_field_.set(18); }
-
-  bool has_needs_prepare_tiles() const { return _has_field_[19]; }
-  bool needs_prepare_tiles() const { return needs_prepare_tiles_; }
-  void set_needs_prepare_tiles(bool value) { needs_prepare_tiles_ = value; _has_field_.set(19); }
-
-  bool has_needs_begin_main_frame() const { return _has_field_[20]; }
-  bool needs_begin_main_frame() const { return needs_begin_main_frame_; }
-  void set_needs_begin_main_frame(bool value) { needs_begin_main_frame_ = value; _has_field_.set(20); }
-
-  bool has_needs_one_begin_impl_frame() const { return _has_field_[21]; }
-  bool needs_one_begin_impl_frame() const { return needs_one_begin_impl_frame_; }
-  void set_needs_one_begin_impl_frame(bool value) { needs_one_begin_impl_frame_ = value; _has_field_.set(21); }
-
-  bool has_visible() const { return _has_field_[22]; }
-  bool visible() const { return visible_; }
-  void set_visible(bool value) { visible_ = value; _has_field_.set(22); }
-
-  bool has_begin_frame_source_paused() const { return _has_field_[23]; }
-  bool begin_frame_source_paused() const { return begin_frame_source_paused_; }
-  void set_begin_frame_source_paused(bool value) { begin_frame_source_paused_ = value; _has_field_.set(23); }
-
-  bool has_can_draw() const { return _has_field_[24]; }
-  bool can_draw() const { return can_draw_; }
-  void set_can_draw(bool value) { can_draw_ = value; _has_field_.set(24); }
-
-  bool has_resourceless_draw() const { return _has_field_[25]; }
-  bool resourceless_draw() const { return resourceless_draw_; }
-  void set_resourceless_draw(bool value) { resourceless_draw_ = value; _has_field_.set(25); }
-
-  bool has_has_pending_tree() const { return _has_field_[26]; }
-  bool has_pending_tree() const { return has_pending_tree_; }
-  void set_has_pending_tree(bool value) { has_pending_tree_ = value; _has_field_.set(26); }
-
-  bool has_pending_tree_is_ready_for_activation() const { return _has_field_[27]; }
-  bool pending_tree_is_ready_for_activation() const { return pending_tree_is_ready_for_activation_; }
-  void set_pending_tree_is_ready_for_activation(bool value) { pending_tree_is_ready_for_activation_ = value; _has_field_.set(27); }
-
-  bool has_active_tree_needs_first_draw() const { return _has_field_[28]; }
-  bool active_tree_needs_first_draw() const { return active_tree_needs_first_draw_; }
-  void set_active_tree_needs_first_draw(bool value) { active_tree_needs_first_draw_ = value; _has_field_.set(28); }
-
-  bool has_active_tree_is_ready_to_draw() const { return _has_field_[29]; }
-  bool active_tree_is_ready_to_draw() const { return active_tree_is_ready_to_draw_; }
-  void set_active_tree_is_ready_to_draw(bool value) { active_tree_is_ready_to_draw_ = value; _has_field_.set(29); }
-
-  bool has_did_create_and_initialize_first_layer_tree_frame_sink() const { return _has_field_[30]; }
-  bool did_create_and_initialize_first_layer_tree_frame_sink() const { return did_create_and_initialize_first_layer_tree_frame_sink_; }
-  void set_did_create_and_initialize_first_layer_tree_frame_sink(bool value) { did_create_and_initialize_first_layer_tree_frame_sink_ = value; _has_field_.set(30); }
-
-  bool has_tree_priority() const { return _has_field_[31]; }
-  ChromeCompositorStateMachine_MinorState_TreePriority tree_priority() const { return tree_priority_; }
-  void set_tree_priority(ChromeCompositorStateMachine_MinorState_TreePriority value) { tree_priority_ = value; _has_field_.set(31); }
-
-  bool has_scroll_handler_state() const { return _has_field_[32]; }
-  ChromeCompositorStateMachine_MinorState_ScrollHandlerState scroll_handler_state() const { return scroll_handler_state_; }
-  void set_scroll_handler_state(ChromeCompositorStateMachine_MinorState_ScrollHandlerState value) { scroll_handler_state_ = value; _has_field_.set(32); }
-
-  bool has_critical_begin_main_frame_to_activate_is_fast() const { return _has_field_[33]; }
-  bool critical_begin_main_frame_to_activate_is_fast() const { return critical_begin_main_frame_to_activate_is_fast_; }
-  void set_critical_begin_main_frame_to_activate_is_fast(bool value) { critical_begin_main_frame_to_activate_is_fast_ = value; _has_field_.set(33); }
-
-  bool has_main_thread_missed_last_deadline() const { return _has_field_[34]; }
-  bool main_thread_missed_last_deadline() const { return main_thread_missed_last_deadline_; }
-  void set_main_thread_missed_last_deadline(bool value) { main_thread_missed_last_deadline_ = value; _has_field_.set(34); }
-
-  bool has_video_needs_begin_frames() const { return _has_field_[36]; }
-  bool video_needs_begin_frames() const { return video_needs_begin_frames_; }
-  void set_video_needs_begin_frames(bool value) { video_needs_begin_frames_ = value; _has_field_.set(36); }
-
-  bool has_defer_begin_main_frame() const { return _has_field_[37]; }
-  bool defer_begin_main_frame() const { return defer_begin_main_frame_; }
-  void set_defer_begin_main_frame(bool value) { defer_begin_main_frame_ = value; _has_field_.set(37); }
-
-  bool has_last_commit_had_no_updates() const { return _has_field_[38]; }
-  bool last_commit_had_no_updates() const { return last_commit_had_no_updates_; }
-  void set_last_commit_had_no_updates(bool value) { last_commit_had_no_updates_ = value; _has_field_.set(38); }
-
-  bool has_did_draw_in_last_frame() const { return _has_field_[39]; }
-  bool did_draw_in_last_frame() const { return did_draw_in_last_frame_; }
-  void set_did_draw_in_last_frame(bool value) { did_draw_in_last_frame_ = value; _has_field_.set(39); }
-
-  bool has_did_submit_in_last_frame() const { return _has_field_[40]; }
-  bool did_submit_in_last_frame() const { return did_submit_in_last_frame_; }
-  void set_did_submit_in_last_frame(bool value) { did_submit_in_last_frame_ = value; _has_field_.set(40); }
-
-  bool has_needs_impl_side_invalidation() const { return _has_field_[41]; }
-  bool needs_impl_side_invalidation() const { return needs_impl_side_invalidation_; }
-  void set_needs_impl_side_invalidation(bool value) { needs_impl_side_invalidation_ = value; _has_field_.set(41); }
-
-  bool has_current_pending_tree_is_impl_side() const { return _has_field_[42]; }
-  bool current_pending_tree_is_impl_side() const { return current_pending_tree_is_impl_side_; }
-  void set_current_pending_tree_is_impl_side(bool value) { current_pending_tree_is_impl_side_ = value; _has_field_.set(42); }
-
-  bool has_previous_pending_tree_was_impl_side() const { return _has_field_[43]; }
-  bool previous_pending_tree_was_impl_side() const { return previous_pending_tree_was_impl_side_; }
-  void set_previous_pending_tree_was_impl_side(bool value) { previous_pending_tree_was_impl_side_ = value; _has_field_.set(43); }
-
-  bool has_processing_animation_worklets_for_active_tree() const { return _has_field_[44]; }
-  bool processing_animation_worklets_for_active_tree() const { return processing_animation_worklets_for_active_tree_; }
-  void set_processing_animation_worklets_for_active_tree(bool value) { processing_animation_worklets_for_active_tree_ = value; _has_field_.set(44); }
-
-  bool has_processing_animation_worklets_for_pending_tree() const { return _has_field_[45]; }
-  bool processing_animation_worklets_for_pending_tree() const { return processing_animation_worklets_for_pending_tree_; }
-  void set_processing_animation_worklets_for_pending_tree(bool value) { processing_animation_worklets_for_pending_tree_ = value; _has_field_.set(45); }
-
-  bool has_processing_paint_worklets_for_pending_tree() const { return _has_field_[46]; }
-  bool processing_paint_worklets_for_pending_tree() const { return processing_paint_worklets_for_pending_tree_; }
-  void set_processing_paint_worklets_for_pending_tree(bool value) { processing_paint_worklets_for_pending_tree_ = value; _has_field_.set(46); }
-
- private:
-  int32_t commit_count_{};
-  int32_t current_frame_number_{};
-  int32_t last_frame_number_submit_performed_{};
-  int32_t last_frame_number_draw_performed_{};
-  int32_t last_frame_number_begin_main_frame_sent_{};
-  bool did_draw_{};
-  bool did_send_begin_main_frame_for_current_frame_{};
-  bool did_notify_begin_main_frame_not_expected_until_{};
-  bool did_notify_begin_main_frame_not_expected_soon_{};
-  bool wants_begin_main_frame_not_expected_{};
-  bool did_commit_during_frame_{};
-  bool did_invalidate_layer_tree_frame_sink_{};
-  bool did_perform_impl_side_invalidaion_{};
-  bool did_prepare_tiles_{};
-  int32_t consecutive_checkerboard_animations_{};
-  int32_t pending_submit_frames_{};
-  int32_t submit_frames_with_current_layer_tree_frame_sink_{};
-  bool needs_redraw_{};
-  bool needs_prepare_tiles_{};
-  bool needs_begin_main_frame_{};
-  bool needs_one_begin_impl_frame_{};
-  bool visible_{};
-  bool begin_frame_source_paused_{};
-  bool can_draw_{};
-  bool resourceless_draw_{};
-  bool has_pending_tree_{};
-  bool pending_tree_is_ready_for_activation_{};
-  bool active_tree_needs_first_draw_{};
-  bool active_tree_is_ready_to_draw_{};
-  bool did_create_and_initialize_first_layer_tree_frame_sink_{};
-  ChromeCompositorStateMachine_MinorState_TreePriority tree_priority_{};
-  ChromeCompositorStateMachine_MinorState_ScrollHandlerState scroll_handler_state_{};
-  bool critical_begin_main_frame_to_activate_is_fast_{};
-  bool main_thread_missed_last_deadline_{};
-  bool video_needs_begin_frames_{};
-  bool defer_begin_main_frame_{};
-  bool last_commit_had_no_updates_{};
-  bool did_draw_in_last_frame_{};
-  bool did_submit_in_last_frame_{};
-  bool needs_impl_side_invalidation_{};
-  bool current_pending_tree_is_impl_side_{};
-  bool previous_pending_tree_was_impl_side_{};
-  bool processing_animation_worklets_for_active_tree_{};
-  bool processing_animation_worklets_for_pending_tree_{};
-  bool processing_paint_worklets_for_pending_tree_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<47> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT ChromeCompositorStateMachine_MajorState : public ::protozero::CppMessageObj {
- public:
-  using BeginImplFrameState = ChromeCompositorStateMachine_MajorState_BeginImplFrameState;
-  static constexpr auto BEGIN_IMPL_FRAME_UNSPECIFIED = ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_UNSPECIFIED;
-  static constexpr auto BEGIN_IMPL_FRAME_IDLE = ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_IDLE;
-  static constexpr auto BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME = ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME;
-  static constexpr auto BEGIN_IMPL_FRAME_INSIDE_DEADLINE = ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_INSIDE_DEADLINE;
-  static constexpr auto BeginImplFrameState_MIN = ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_UNSPECIFIED;
-  static constexpr auto BeginImplFrameState_MAX = ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_INSIDE_DEADLINE;
-  using BeginMainFrameState = ChromeCompositorStateMachine_MajorState_BeginMainFrameState;
-  static constexpr auto BEGIN_MAIN_FRAME_UNSPECIFIED = ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_UNSPECIFIED;
-  static constexpr auto BEGIN_MAIN_FRAME_IDLE = ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_IDLE;
-  static constexpr auto BEGIN_MAIN_FRAME_SENT = ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_SENT;
-  static constexpr auto BEGIN_MAIN_FRAME_READY_TO_COMMIT = ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_READY_TO_COMMIT;
-  static constexpr auto BeginMainFrameState_MIN = ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_UNSPECIFIED;
-  static constexpr auto BeginMainFrameState_MAX = ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_READY_TO_COMMIT;
-  using LayerTreeFrameSinkState = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState;
-  static constexpr auto LAYER_TREE_FRAME_UNSPECIFIED = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_UNSPECIFIED;
-  static constexpr auto LAYER_TREE_FRAME_NONE = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_NONE;
-  static constexpr auto LAYER_TREE_FRAME_ACTIVE = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_ACTIVE;
-  static constexpr auto LAYER_TREE_FRAME_CREATING = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_CREATING;
-  static constexpr auto LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT;
-  static constexpr auto LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION;
-  static constexpr auto LayerTreeFrameSinkState_MIN = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_UNSPECIFIED;
-  static constexpr auto LayerTreeFrameSinkState_MAX = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION;
-  using ForcedRedrawOnTimeoutState = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState;
-  static constexpr auto FORCED_REDRAW_UNSPECIFIED = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_UNSPECIFIED;
-  static constexpr auto FORCED_REDRAW_IDLE = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_IDLE;
-  static constexpr auto FORCED_REDRAW_WAITING_FOR_COMMIT = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_COMMIT;
-  static constexpr auto FORCED_REDRAW_WAITING_FOR_ACTIVATION = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_ACTIVATION;
-  static constexpr auto FORCED_REDRAW_WAITING_FOR_DRAW = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_DRAW;
-  static constexpr auto ForcedRedrawOnTimeoutState_MIN = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_UNSPECIFIED;
-  static constexpr auto ForcedRedrawOnTimeoutState_MAX = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_DRAW;
-  enum FieldNumbers {
-    kNextActionFieldNumber = 1,
-    kBeginImplFrameStateFieldNumber = 2,
-    kBeginMainFrameStateFieldNumber = 3,
-    kLayerTreeFrameSinkStateFieldNumber = 4,
-    kForcedRedrawStateFieldNumber = 5,
-  };
-
-  ChromeCompositorStateMachine_MajorState();
-  ~ChromeCompositorStateMachine_MajorState() override;
-  ChromeCompositorStateMachine_MajorState(ChromeCompositorStateMachine_MajorState&&) noexcept;
-  ChromeCompositorStateMachine_MajorState& operator=(ChromeCompositorStateMachine_MajorState&&);
-  ChromeCompositorStateMachine_MajorState(const ChromeCompositorStateMachine_MajorState&);
-  ChromeCompositorStateMachine_MajorState& operator=(const ChromeCompositorStateMachine_MajorState&);
-  bool operator==(const ChromeCompositorStateMachine_MajorState&) const;
-  bool operator!=(const ChromeCompositorStateMachine_MajorState& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_next_action() const { return _has_field_[1]; }
-  ChromeCompositorSchedulerAction next_action() const { return next_action_; }
-  void set_next_action(ChromeCompositorSchedulerAction value) { next_action_ = value; _has_field_.set(1); }
-
-  bool has_begin_impl_frame_state() const { return _has_field_[2]; }
-  ChromeCompositorStateMachine_MajorState_BeginImplFrameState begin_impl_frame_state() const { return begin_impl_frame_state_; }
-  void set_begin_impl_frame_state(ChromeCompositorStateMachine_MajorState_BeginImplFrameState value) { begin_impl_frame_state_ = value; _has_field_.set(2); }
-
-  bool has_begin_main_frame_state() const { return _has_field_[3]; }
-  ChromeCompositorStateMachine_MajorState_BeginMainFrameState begin_main_frame_state() const { return begin_main_frame_state_; }
-  void set_begin_main_frame_state(ChromeCompositorStateMachine_MajorState_BeginMainFrameState value) { begin_main_frame_state_ = value; _has_field_.set(3); }
-
-  bool has_layer_tree_frame_sink_state() const { return _has_field_[4]; }
-  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState layer_tree_frame_sink_state() const { return layer_tree_frame_sink_state_; }
-  void set_layer_tree_frame_sink_state(ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState value) { layer_tree_frame_sink_state_ = value; _has_field_.set(4); }
-
-  bool has_forced_redraw_state() const { return _has_field_[5]; }
-  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState forced_redraw_state() const { return forced_redraw_state_; }
-  void set_forced_redraw_state(ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState value) { forced_redraw_state_ = value; _has_field_.set(5); }
-
- private:
-  ChromeCompositorSchedulerAction next_action_{};
-  ChromeCompositorStateMachine_MajorState_BeginImplFrameState begin_impl_frame_state_{};
-  ChromeCompositorStateMachine_MajorState_BeginMainFrameState begin_main_frame_state_{};
-  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState layer_tree_frame_sink_state_{};
-  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState forced_redraw_state_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<6> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT ChromeCompositorSchedulerState : public ::protozero::CppMessageObj {
- public:
-  using BeginImplFrameDeadlineMode = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode;
-  static constexpr auto DEADLINE_MODE_UNSPECIFIED = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_UNSPECIFIED;
-  static constexpr auto DEADLINE_MODE_NONE = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_NONE;
-  static constexpr auto DEADLINE_MODE_IMMEDIATE = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_IMMEDIATE;
-  static constexpr auto DEADLINE_MODE_REGULAR = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_REGULAR;
-  static constexpr auto DEADLINE_MODE_LATE = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_LATE;
-  static constexpr auto DEADLINE_MODE_BLOCKED = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_BLOCKED;
-  static constexpr auto BeginImplFrameDeadlineMode_MIN = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_UNSPECIFIED;
-  static constexpr auto BeginImplFrameDeadlineMode_MAX = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_BLOCKED;
-  enum FieldNumbers {
-    kStateMachineFieldNumber = 1,
-    kObservingBeginFrameSourceFieldNumber = 2,
-    kBeginImplFrameDeadlineTaskFieldNumber = 3,
-    kPendingBeginFrameTaskFieldNumber = 4,
-    kSkippedLastFrameMissedExceededDeadlineFieldNumber = 5,
-    kInsideActionFieldNumber = 7,
-    kDeadlineModeFieldNumber = 8,
-    kDeadlineUsFieldNumber = 9,
-    kDeadlineScheduledAtUsFieldNumber = 10,
-    kNowUsFieldNumber = 11,
-    kNowToDeadlineDeltaUsFieldNumber = 12,
-    kNowToDeadlineScheduledAtDeltaUsFieldNumber = 13,
-    kBeginImplFrameArgsFieldNumber = 14,
-    kBeginFrameObserverStateFieldNumber = 15,
-    kBeginFrameSourceStateFieldNumber = 16,
-    kCompositorTimingHistoryFieldNumber = 17,
-  };
-
-  ChromeCompositorSchedulerState();
-  ~ChromeCompositorSchedulerState() override;
-  ChromeCompositorSchedulerState(ChromeCompositorSchedulerState&&) noexcept;
-  ChromeCompositorSchedulerState& operator=(ChromeCompositorSchedulerState&&);
-  ChromeCompositorSchedulerState(const ChromeCompositorSchedulerState&);
-  ChromeCompositorSchedulerState& operator=(const ChromeCompositorSchedulerState&);
-  bool operator==(const ChromeCompositorSchedulerState&) const;
-  bool operator!=(const ChromeCompositorSchedulerState& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_state_machine() const { return _has_field_[1]; }
-  const ChromeCompositorStateMachine& state_machine() const { return *state_machine_; }
-  ChromeCompositorStateMachine* mutable_state_machine() { _has_field_.set(1); return state_machine_.get(); }
-
-  bool has_observing_begin_frame_source() const { return _has_field_[2]; }
-  bool observing_begin_frame_source() const { return observing_begin_frame_source_; }
-  void set_observing_begin_frame_source(bool value) { observing_begin_frame_source_ = value; _has_field_.set(2); }
-
-  bool has_begin_impl_frame_deadline_task() const { return _has_field_[3]; }
-  bool begin_impl_frame_deadline_task() const { return begin_impl_frame_deadline_task_; }
-  void set_begin_impl_frame_deadline_task(bool value) { begin_impl_frame_deadline_task_ = value; _has_field_.set(3); }
-
-  bool has_pending_begin_frame_task() const { return _has_field_[4]; }
-  bool pending_begin_frame_task() const { return pending_begin_frame_task_; }
-  void set_pending_begin_frame_task(bool value) { pending_begin_frame_task_ = value; _has_field_.set(4); }
-
-  bool has_skipped_last_frame_missed_exceeded_deadline() const { return _has_field_[5]; }
-  bool skipped_last_frame_missed_exceeded_deadline() const { return skipped_last_frame_missed_exceeded_deadline_; }
-  void set_skipped_last_frame_missed_exceeded_deadline(bool value) { skipped_last_frame_missed_exceeded_deadline_ = value; _has_field_.set(5); }
-
-  bool has_inside_action() const { return _has_field_[7]; }
-  ChromeCompositorSchedulerAction inside_action() const { return inside_action_; }
-  void set_inside_action(ChromeCompositorSchedulerAction value) { inside_action_ = value; _has_field_.set(7); }
-
-  bool has_deadline_mode() const { return _has_field_[8]; }
-  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode deadline_mode() const { return deadline_mode_; }
-  void set_deadline_mode(ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode value) { deadline_mode_ = value; _has_field_.set(8); }
-
-  bool has_deadline_us() const { return _has_field_[9]; }
-  int64_t deadline_us() const { return deadline_us_; }
-  void set_deadline_us(int64_t value) { deadline_us_ = value; _has_field_.set(9); }
-
-  bool has_deadline_scheduled_at_us() const { return _has_field_[10]; }
-  int64_t deadline_scheduled_at_us() const { return deadline_scheduled_at_us_; }
-  void set_deadline_scheduled_at_us(int64_t value) { deadline_scheduled_at_us_ = value; _has_field_.set(10); }
-
-  bool has_now_us() const { return _has_field_[11]; }
-  int64_t now_us() const { return now_us_; }
-  void set_now_us(int64_t value) { now_us_ = value; _has_field_.set(11); }
-
-  bool has_now_to_deadline_delta_us() const { return _has_field_[12]; }
-  int64_t now_to_deadline_delta_us() const { return now_to_deadline_delta_us_; }
-  void set_now_to_deadline_delta_us(int64_t value) { now_to_deadline_delta_us_ = value; _has_field_.set(12); }
-
-  bool has_now_to_deadline_scheduled_at_delta_us() const { return _has_field_[13]; }
-  int64_t now_to_deadline_scheduled_at_delta_us() const { return now_to_deadline_scheduled_at_delta_us_; }
-  void set_now_to_deadline_scheduled_at_delta_us(int64_t value) { now_to_deadline_scheduled_at_delta_us_ = value; _has_field_.set(13); }
+  // Field 2: qnx_kernel_kbuffers
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, qnx_kernel_kbuffers_, msg);
+  }
 
-  bool has_begin_impl_frame_args() const { return _has_field_[14]; }
-  const BeginImplFrameArgs& begin_impl_frame_args() const { return *begin_impl_frame_args_; }
-  BeginImplFrameArgs* mutable_begin_impl_frame_args() { _has_field_.set(14); return begin_impl_frame_args_.get(); }
+  // Field 3: qnx_kernel_wide_events
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, qnx_kernel_wide_events_, msg);
+  }
 
-  bool has_begin_frame_observer_state() const { return _has_field_[15]; }
-  const BeginFrameObserverState& begin_frame_observer_state() const { return *begin_frame_observer_state_; }
-  BeginFrameObserverState* mutable_begin_frame_observer_state() { _has_field_.set(15); return begin_frame_observer_state_.get(); }
+  // Field 4: qnx_cache_pages
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, qnx_cache_pages_, msg);
+  }
 
-  bool has_begin_frame_source_state() const { return _has_field_[16]; }
-  const BeginFrameSourceState& begin_frame_source_state() const { return *begin_frame_source_state_; }
-  BeginFrameSourceState* mutable_begin_frame_source_state() { _has_field_.set(16); return begin_frame_source_state_.get(); }
+  // Field 5: qnx_cache_max_pages
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, qnx_cache_max_pages_, msg);
+  }
 
-  bool has_compositor_timing_history() const { return _has_field_[17]; }
-  const CompositorTimingHistory& compositor_timing_history() const { return *compositor_timing_history_; }
-  CompositorTimingHistory* mutable_compositor_timing_history() { _has_field_.set(17); return compositor_timing_history_.get(); }
+  // Field 6: qnx_trace_buffer_init_bytes
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, qnx_trace_buffer_init_bytes_, msg);
+  }
 
- private:
-  ::protozero::CopyablePtr<ChromeCompositorStateMachine> state_machine_;
-  bool observing_begin_frame_source_{};
-  bool begin_impl_frame_deadline_task_{};
-  bool pending_begin_frame_task_{};
-  bool skipped_last_frame_missed_exceeded_deadline_{};
-  ChromeCompositorSchedulerAction inside_action_{};
-  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode deadline_mode_{};
-  int64_t deadline_us_{};
-  int64_t deadline_scheduled_at_us_{};
-  int64_t now_us_{};
-  int64_t now_to_deadline_delta_us_{};
-  int64_t now_to_deadline_scheduled_at_delta_us_{};
-  ::protozero::CopyablePtr<BeginImplFrameArgs> begin_impl_frame_args_;
-  ::protozero::CopyablePtr<BeginFrameObserverState> begin_frame_observer_state_;
-  ::protozero::CopyablePtr<BeginFrameSourceState> begin_frame_source_state_;
-  ::protozero::CopyablePtr<CompositorTimingHistory> compositor_timing_history_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<18> _has_field_{};
-};
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_COMPOSITOR_SCHEDULER_STATE_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/source_location.gen.h
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/statsd/atom_ids.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_SOURCE_LOCATION_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_SOURCE_LOCATION_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class SourceLocation;
-class UnsymbolizedSourceLocation;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/statsd/atom_ids.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT SourceLocation : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kIidFieldNumber = 1,
-    kFileNameFieldNumber = 2,
-    kFunctionNameFieldNumber = 3,
-    kLineNumberFieldNumber = 4,
-  };
-
-  SourceLocation();
-  ~SourceLocation() override;
-  SourceLocation(SourceLocation&&) noexcept;
-  SourceLocation& operator=(SourceLocation&&);
-  SourceLocation(const SourceLocation&);
-  SourceLocation& operator=(const SourceLocation&);
-  bool operator==(const SourceLocation&) const;
-  bool operator!=(const SourceLocation& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_iid() const { return _has_field_[1]; }
-  uint64_t iid() const { return iid_; }
-  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
-
-  bool has_file_name() const { return _has_field_[2]; }
-  const std::string& file_name() const { return file_name_; }
-  void set_file_name(const std::string& value) { file_name_ = value; _has_field_.set(2); }
-
-  bool has_function_name() const { return _has_field_[3]; }
-  const std::string& function_name() const { return function_name_; }
-  void set_function_name(const std::string& value) { function_name_ = value; _has_field_.set(3); }
-
-  bool has_line_number() const { return _has_field_[4]; }
-  uint32_t line_number() const { return line_number_; }
-  void set_line_number(uint32_t value) { line_number_ = value; _has_field_.set(4); }
-
- private:
-  uint64_t iid_{};
-  std::string file_name_{};
-  std::string function_name_{};
-  uint32_t line_number_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<5> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT UnsymbolizedSourceLocation : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kIidFieldNumber = 1,
-    kMappingIdFieldNumber = 2,
-    kRelPcFieldNumber = 3,
-  };
-
-  UnsymbolizedSourceLocation();
-  ~UnsymbolizedSourceLocation() override;
-  UnsymbolizedSourceLocation(UnsymbolizedSourceLocation&&) noexcept;
-  UnsymbolizedSourceLocation& operator=(UnsymbolizedSourceLocation&&);
-  UnsymbolizedSourceLocation(const UnsymbolizedSourceLocation&);
-  UnsymbolizedSourceLocation& operator=(const UnsymbolizedSourceLocation&);
-  bool operator==(const UnsymbolizedSourceLocation&) const;
-  bool operator!=(const UnsymbolizedSourceLocation& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_iid() const { return _has_field_[1]; }
-  uint64_t iid() const { return iid_; }
-  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
-
-  bool has_mapping_id() const { return _has_field_[2]; }
-  uint64_t mapping_id() const { return mapping_id_; }
-  void set_mapping_id(uint64_t value) { mapping_id_ = value; _has_field_.set(2); }
-
-  bool has_rel_pc() const { return _has_field_[3]; }
-  uint64_t rel_pc() const { return rel_pc_; }
-  void set_rel_pc(uint64_t value) { rel_pc_ = value; _has_field_.set(3); }
-
- private:
-  uint64_t iid_{};
-  uint64_t mapping_id_{};
-  uint64_t rel_pc_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<4> _has_field_{};
-};
-
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_SOURCE_LOCATION_PROTO_CPP_H_
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/statsd/statsd_tracing_config.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -29417,32 +25013,32 @@ class PERFETTO_EXPORT_COMPONENT UnsymbolizedSourceLocation : public ::protozero:
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_compositor_scheduler_state.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/source_location.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/statsd/statsd_tracing_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/statsd/atom_ids.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-CompositorTimingHistory::CompositorTimingHistory() = default;
-CompositorTimingHistory::~CompositorTimingHistory() = default;
-CompositorTimingHistory::CompositorTimingHistory(const CompositorTimingHistory&) = default;
-CompositorTimingHistory& CompositorTimingHistory::operator=(const CompositorTimingHistory&) = default;
-CompositorTimingHistory::CompositorTimingHistory(CompositorTimingHistory&&) noexcept = default;
-CompositorTimingHistory& CompositorTimingHistory::operator=(CompositorTimingHistory&&) = default;
+StatsdPullAtomConfig::StatsdPullAtomConfig() = default;
+StatsdPullAtomConfig::~StatsdPullAtomConfig() = default;
+StatsdPullAtomConfig::StatsdPullAtomConfig(const StatsdPullAtomConfig&) = default;
+StatsdPullAtomConfig& StatsdPullAtomConfig::operator=(const StatsdPullAtomConfig&) = default;
+StatsdPullAtomConfig::StatsdPullAtomConfig(StatsdPullAtomConfig&&) noexcept = default;
+StatsdPullAtomConfig& StatsdPullAtomConfig::operator=(StatsdPullAtomConfig&&) = default;
 
-bool CompositorTimingHistory::operator==(const CompositorTimingHistory& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && begin_main_frame_queue_critical_estimate_delta_us_ == other.begin_main_frame_queue_critical_estimate_delta_us_
-   && begin_main_frame_queue_not_critical_estimate_delta_us_ == other.begin_main_frame_queue_not_critical_estimate_delta_us_
-   && begin_main_frame_start_to_ready_to_commit_estimate_delta_us_ == other.begin_main_frame_start_to_ready_to_commit_estimate_delta_us_
-   && commit_to_ready_to_activate_estimate_delta_us_ == other.commit_to_ready_to_activate_estimate_delta_us_
-   && prepare_tiles_estimate_delta_us_ == other.prepare_tiles_estimate_delta_us_
-   && activate_estimate_delta_us_ == other.activate_estimate_delta_us_
-   && draw_estimate_delta_us_ == other.draw_estimate_delta_us_;
+bool StatsdPullAtomConfig::operator==(const StatsdPullAtomConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(pull_atom_id_, other.pull_atom_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(raw_pull_atom_id_, other.raw_pull_atom_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(pull_frequency_ms_, other.pull_frequency_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(packages_, other.packages_);
 }
 
-bool CompositorTimingHistory::ParseFromArray(const void* raw, size_t size) {
+bool StatsdPullAtomConfig::ParseFromArray(const void* raw, size_t size) {
+  pull_atom_id_.clear();
+  raw_pull_atom_id_.clear();
+  packages_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -29452,26 +25048,20 @@ bool CompositorTimingHistory::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* begin_main_frame_queue_critical_estimate_delta_us */:
-        field.get(&begin_main_frame_queue_critical_estimate_delta_us_);
-        break;
-      case 2 /* begin_main_frame_queue_not_critical_estimate_delta_us */:
-        field.get(&begin_main_frame_queue_not_critical_estimate_delta_us_);
-        break;
-      case 3 /* begin_main_frame_start_to_ready_to_commit_estimate_delta_us */:
-        field.get(&begin_main_frame_start_to_ready_to_commit_estimate_delta_us_);
-        break;
-      case 4 /* commit_to_ready_to_activate_estimate_delta_us */:
-        field.get(&commit_to_ready_to_activate_estimate_delta_us_);
+      case 1 /* pull_atom_id */:
+        pull_atom_id_.emplace_back();
+        field.get(&pull_atom_id_.back());
         break;
-      case 5 /* prepare_tiles_estimate_delta_us */:
-        field.get(&prepare_tiles_estimate_delta_us_);
+      case 2 /* raw_pull_atom_id */:
+        raw_pull_atom_id_.emplace_back();
+        field.get(&raw_pull_atom_id_.back());
         break;
-      case 6 /* activate_estimate_delta_us */:
-        field.get(&activate_estimate_delta_us_);
+      case 3 /* pull_frequency_ms */:
+        field.get(&pull_frequency_ms_);
         break;
-      case 7 /* draw_estimate_delta_us */:
-        field.get(&draw_estimate_delta_us_);
+      case 4 /* packages */:
+        packages_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &packages_.back());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -29481,74 +25071,64 @@ bool CompositorTimingHistory::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string CompositorTimingHistory::SerializeAsString() const {
+std::string StatsdPullAtomConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> CompositorTimingHistory::SerializeAsArray() const {
+std::vector<uint8_t> StatsdPullAtomConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void CompositorTimingHistory::Serialize(::protozero::Message* msg) const {
-  // Field 1: begin_main_frame_queue_critical_estimate_delta_us
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, begin_main_frame_queue_critical_estimate_delta_us_, msg);
+void StatsdPullAtomConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: pull_atom_id
+  for (auto& it : pull_atom_id_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, it, msg);
   }
 
-  // Field 2: begin_main_frame_queue_not_critical_estimate_delta_us
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, begin_main_frame_queue_not_critical_estimate_delta_us_, msg);
+  // Field 2: raw_pull_atom_id
+  for (auto& it : raw_pull_atom_id_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, it, msg);
   }
 
-  // Field 3: begin_main_frame_start_to_ready_to_commit_estimate_delta_us
+  // Field 3: pull_frequency_ms
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, begin_main_frame_start_to_ready_to_commit_estimate_delta_us_, msg);
-  }
-
-  // Field 4: commit_to_ready_to_activate_estimate_delta_us
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, commit_to_ready_to_activate_estimate_delta_us_, msg);
-  }
-
-  // Field 5: prepare_tiles_estimate_delta_us
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(5, prepare_tiles_estimate_delta_us_, msg);
-  }
-
-  // Field 6: activate_estimate_delta_us
-  if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(6, activate_estimate_delta_us_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, pull_frequency_ms_, msg);
   }
 
-  // Field 7: draw_estimate_delta_us
-  if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(7, draw_estimate_delta_us_, msg);
+  // Field 4: packages
+  for (auto& it : packages_) {
+    ::protozero::internal::gen_helpers::SerializeString(4, it, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-BeginFrameSourceState::BeginFrameSourceState() = default;
-BeginFrameSourceState::~BeginFrameSourceState() = default;
-BeginFrameSourceState::BeginFrameSourceState(const BeginFrameSourceState&) = default;
-BeginFrameSourceState& BeginFrameSourceState::operator=(const BeginFrameSourceState&) = default;
-BeginFrameSourceState::BeginFrameSourceState(BeginFrameSourceState&&) noexcept = default;
-BeginFrameSourceState& BeginFrameSourceState::operator=(BeginFrameSourceState&&) = default;
+StatsdTracingConfig::StatsdTracingConfig() = default;
+StatsdTracingConfig::~StatsdTracingConfig() = default;
+StatsdTracingConfig::StatsdTracingConfig(const StatsdTracingConfig&) = default;
+StatsdTracingConfig& StatsdTracingConfig::operator=(const StatsdTracingConfig&) = default;
+StatsdTracingConfig::StatsdTracingConfig(StatsdTracingConfig&&) noexcept = default;
+StatsdTracingConfig& StatsdTracingConfig::operator=(StatsdTracingConfig&&) = default;
 
-bool BeginFrameSourceState::operator==(const BeginFrameSourceState& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && source_id_ == other.source_id_
-   && paused_ == other.paused_
-   && num_observers_ == other.num_observers_
-   && last_begin_frame_args_ == other.last_begin_frame_args_;
+bool StatsdTracingConfig::operator==(const StatsdTracingConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(push_atom_id_, other.push_atom_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(raw_push_atom_id_, other.raw_push_atom_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(pull_config_, other.pull_config_);
 }
 
-bool BeginFrameSourceState::ParseFromArray(const void* raw, size_t size) {
+int StatsdTracingConfig::pull_config_size() const { return static_cast<int>(pull_config_.size()); }
+void StatsdTracingConfig::clear_pull_config() { pull_config_.clear(); }
+StatsdPullAtomConfig* StatsdTracingConfig::add_pull_config() { pull_config_.emplace_back(); return &pull_config_.back(); }
+bool StatsdTracingConfig::ParseFromArray(const void* raw, size_t size) {
+  push_atom_id_.clear();
+  raw_push_atom_id_.clear();
+  pull_config_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -29558,17 +25138,17 @@ bool BeginFrameSourceState::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* source_id */:
-        field.get(&source_id_);
+      case 1 /* push_atom_id */:
+        push_atom_id_.emplace_back();
+        field.get(&push_atom_id_.back());
         break;
-      case 2 /* paused */:
-        field.get(&paused_);
+      case 2 /* raw_push_atom_id */:
+        raw_push_atom_id_.emplace_back();
+        field.get(&raw_push_atom_id_.back());
         break;
-      case 3 /* num_observers */:
-        field.get(&num_observers_);
-        break;
-      case 4 /* last_begin_frame_args */:
-        (*last_begin_frame_args_).ParseFromArray(field.data(), field.size());
+      case 3 /* pull_config */:
+        pull_config_.emplace_back();
+        pull_config_.back().ParseFromArray(field.data(), field.size());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -29578,66 +25158,90 @@ bool BeginFrameSourceState::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string BeginFrameSourceState::SerializeAsString() const {
+std::string StatsdTracingConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> BeginFrameSourceState::SerializeAsArray() const {
+std::vector<uint8_t> StatsdTracingConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void BeginFrameSourceState::Serialize(::protozero::Message* msg) const {
-  // Field 1: source_id
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, source_id_, msg);
-  }
-
-  // Field 2: paused
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, paused_, msg);
+void StatsdTracingConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: push_atom_id
+  for (auto& it : push_atom_id_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, it, msg);
   }
 
-  // Field 3: num_observers
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, num_observers_, msg);
+  // Field 2: raw_push_atom_id
+  for (auto& it : raw_push_atom_id_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, it, msg);
   }
 
-  // Field 4: last_begin_frame_args
-  if (_has_field_[4]) {
-    (*last_begin_frame_args_).Serialize(msg->BeginNestedMessage<::protozero::Message>(4));
+  // Field 3: pull_config
+  for (auto& it : pull_config_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(3));
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/sys_stats/sys_stats_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/sys_stats/sys_stats_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/sys_stats_counters.gen.h"
 
-BeginFrameArgs::BeginFrameArgs() = default;
-BeginFrameArgs::~BeginFrameArgs() = default;
-BeginFrameArgs::BeginFrameArgs(const BeginFrameArgs&) = default;
-BeginFrameArgs& BeginFrameArgs::operator=(const BeginFrameArgs&) = default;
-BeginFrameArgs::BeginFrameArgs(BeginFrameArgs&&) noexcept = default;
-BeginFrameArgs& BeginFrameArgs::operator=(BeginFrameArgs&&) = default;
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-bool BeginFrameArgs::operator==(const BeginFrameArgs& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && type_ == other.type_
-   && source_id_ == other.source_id_
-   && sequence_number_ == other.sequence_number_
-   && frame_time_us_ == other.frame_time_us_
-   && deadline_us_ == other.deadline_us_
-   && interval_delta_us_ == other.interval_delta_us_
-   && on_critical_path_ == other.on_critical_path_
-   && animate_only_ == other.animate_only_
-   && source_location_iid_ == other.source_location_iid_
-   && source_location_ == other.source_location_
-   && frames_throttled_since_last_ == other.frames_throttled_since_last_;
+SysStatsConfig::SysStatsConfig() = default;
+SysStatsConfig::~SysStatsConfig() = default;
+SysStatsConfig::SysStatsConfig(const SysStatsConfig&) = default;
+SysStatsConfig& SysStatsConfig::operator=(const SysStatsConfig&) = default;
+SysStatsConfig::SysStatsConfig(SysStatsConfig&&) noexcept = default;
+SysStatsConfig& SysStatsConfig::operator=(SysStatsConfig&&) = default;
+
+bool SysStatsConfig::operator==(const SysStatsConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(meminfo_period_ms_, other.meminfo_period_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(meminfo_counters_, other.meminfo_counters_)
+   && ::protozero::internal::gen_helpers::EqualsField(vmstat_period_ms_, other.vmstat_period_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(vmstat_counters_, other.vmstat_counters_)
+   && ::protozero::internal::gen_helpers::EqualsField(stat_period_ms_, other.stat_period_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(stat_counters_, other.stat_counters_)
+   && ::protozero::internal::gen_helpers::EqualsField(devfreq_period_ms_, other.devfreq_period_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(cpufreq_period_ms_, other.cpufreq_period_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(buddyinfo_period_ms_, other.buddyinfo_period_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(diskstat_period_ms_, other.diskstat_period_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(psi_period_ms_, other.psi_period_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(thermal_period_ms_, other.thermal_period_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(cpuidle_period_ms_, other.cpuidle_period_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(gpufreq_period_ms_, other.gpufreq_period_ms_);
 }
 
-bool BeginFrameArgs::ParseFromArray(const void* raw, size_t size) {
+bool SysStatsConfig::ParseFromArray(const void* raw, size_t size) {
+  meminfo_counters_.clear();
+  vmstat_counters_.clear();
+  stat_counters_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -29647,38 +25251,50 @@ bool BeginFrameArgs::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* type */:
-        field.get(&type_);
+      case 1 /* meminfo_period_ms */:
+        field.get(&meminfo_period_ms_);
         break;
-      case 2 /* source_id */:
-        field.get(&source_id_);
+      case 2 /* meminfo_counters */:
+        meminfo_counters_.emplace_back();
+        field.get(&meminfo_counters_.back());
         break;
-      case 3 /* sequence_number */:
-        field.get(&sequence_number_);
+      case 3 /* vmstat_period_ms */:
+        field.get(&vmstat_period_ms_);
         break;
-      case 4 /* frame_time_us */:
-        field.get(&frame_time_us_);
+      case 4 /* vmstat_counters */:
+        vmstat_counters_.emplace_back();
+        field.get(&vmstat_counters_.back());
         break;
-      case 5 /* deadline_us */:
-        field.get(&deadline_us_);
+      case 5 /* stat_period_ms */:
+        field.get(&stat_period_ms_);
         break;
-      case 6 /* interval_delta_us */:
-        field.get(&interval_delta_us_);
+      case 6 /* stat_counters */:
+        stat_counters_.emplace_back();
+        field.get(&stat_counters_.back());
         break;
-      case 7 /* on_critical_path */:
-        field.get(&on_critical_path_);
+      case 7 /* devfreq_period_ms */:
+        field.get(&devfreq_period_ms_);
         break;
-      case 8 /* animate_only */:
-        field.get(&animate_only_);
+      case 8 /* cpufreq_period_ms */:
+        field.get(&cpufreq_period_ms_);
         break;
-      case 9 /* source_location_iid */:
-        field.get(&source_location_iid_);
+      case 9 /* buddyinfo_period_ms */:
+        field.get(&buddyinfo_period_ms_);
         break;
-      case 10 /* source_location */:
-        (*source_location_).ParseFromArray(field.data(), field.size());
+      case 10 /* diskstat_period_ms */:
+        field.get(&diskstat_period_ms_);
         break;
-      case 12 /* frames_throttled_since_last */:
-        field.get(&frames_throttled_since_last_);
+      case 11 /* psi_period_ms */:
+        field.get(&psi_period_ms_);
+        break;
+      case 12 /* thermal_period_ms */:
+        field.get(&thermal_period_ms_);
+        break;
+      case 13 /* cpuidle_period_ms */:
+        field.get(&cpuidle_period_ms_);
+        break;
+      case 14 /* gpufreq_period_ms */:
+        field.get(&gpufreq_period_ms_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -29688,92 +25304,127 @@ bool BeginFrameArgs::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string BeginFrameArgs::SerializeAsString() const {
+std::string SysStatsConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> BeginFrameArgs::SerializeAsArray() const {
+std::vector<uint8_t> SysStatsConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void BeginFrameArgs::Serialize(::protozero::Message* msg) const {
-  // Field 1: type
+void SysStatsConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: meminfo_period_ms
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, type_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, meminfo_period_ms_, msg);
   }
 
-  // Field 2: source_id
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, source_id_, msg);
+  // Field 2: meminfo_counters
+  for (auto& it : meminfo_counters_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, it, msg);
   }
 
-  // Field 3: sequence_number
+  // Field 3: vmstat_period_ms
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, sequence_number_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, vmstat_period_ms_, msg);
   }
 
-  // Field 4: frame_time_us
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, frame_time_us_, msg);
+  // Field 4: vmstat_counters
+  for (auto& it : vmstat_counters_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, it, msg);
   }
 
-  // Field 5: deadline_us
+  // Field 5: stat_period_ms
   if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(5, deadline_us_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, stat_period_ms_, msg);
   }
 
-  // Field 6: interval_delta_us
-  if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(6, interval_delta_us_, msg);
+  // Field 6: stat_counters
+  for (auto& it : stat_counters_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, it, msg);
   }
 
-  // Field 7: on_critical_path
+  // Field 7: devfreq_period_ms
   if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(7, on_critical_path_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(7, devfreq_period_ms_, msg);
   }
 
-  // Field 8: animate_only
+  // Field 8: cpufreq_period_ms
   if (_has_field_[8]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(8, animate_only_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(8, cpufreq_period_ms_, msg);
   }
 
-  // Field 9: source_location_iid
+  // Field 9: buddyinfo_period_ms
   if (_has_field_[9]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(9, source_location_iid_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(9, buddyinfo_period_ms_, msg);
   }
 
-  // Field 10: source_location
+  // Field 10: diskstat_period_ms
   if (_has_field_[10]) {
-    (*source_location_).Serialize(msg->BeginNestedMessage<::protozero::Message>(10));
+    ::protozero::internal::gen_helpers::SerializeVarInt(10, diskstat_period_ms_, msg);
   }
 
-  // Field 12: frames_throttled_since_last
+  // Field 11: psi_period_ms
+  if (_has_field_[11]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(11, psi_period_ms_, msg);
+  }
+
+  // Field 12: thermal_period_ms
   if (_has_field_[12]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(12, frames_throttled_since_last_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(12, thermal_period_ms_, msg);
+  }
+
+  // Field 13: cpuidle_period_ms
+  if (_has_field_[13]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(13, cpuidle_period_ms_, msg);
+  }
+
+  // Field 14: gpufreq_period_ms
+  if (_has_field_[14]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(14, gpufreq_period_ms_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/system_info/system_info_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/system_info/system_info_config.gen.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-BeginFrameObserverState::BeginFrameObserverState() = default;
-BeginFrameObserverState::~BeginFrameObserverState() = default;
-BeginFrameObserverState::BeginFrameObserverState(const BeginFrameObserverState&) = default;
-BeginFrameObserverState& BeginFrameObserverState::operator=(const BeginFrameObserverState&) = default;
-BeginFrameObserverState::BeginFrameObserverState(BeginFrameObserverState&&) noexcept = default;
-BeginFrameObserverState& BeginFrameObserverState::operator=(BeginFrameObserverState&&) = default;
+SystemInfoConfig::SystemInfoConfig() = default;
+SystemInfoConfig::~SystemInfoConfig() = default;
+SystemInfoConfig::SystemInfoConfig(const SystemInfoConfig&) = default;
+SystemInfoConfig& SystemInfoConfig::operator=(const SystemInfoConfig&) = default;
+SystemInfoConfig::SystemInfoConfig(SystemInfoConfig&&) noexcept = default;
+SystemInfoConfig& SystemInfoConfig::operator=(SystemInfoConfig&&) = default;
 
-bool BeginFrameObserverState::operator==(const BeginFrameObserverState& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && dropped_begin_frame_args_ == other.dropped_begin_frame_args_
-   && last_begin_frame_args_ == other.last_begin_frame_args_;
+bool SystemInfoConfig::operator==(const SystemInfoConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
-bool BeginFrameObserverState::ParseFromArray(const void* raw, size_t size) {
+bool SystemInfoConfig::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -29783,12 +25434,6 @@ bool BeginFrameObserverState::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* dropped_begin_frame_args */:
-        field.get(&dropped_begin_frame_args_);
-        break;
-      case 2 /* last_begin_frame_args */:
-        (*last_begin_frame_args_).ParseFromArray(field.data(), field.size());
-        break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
         break;
@@ -29797,51 +25442,71 @@ bool BeginFrameObserverState::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string BeginFrameObserverState::SerializeAsString() const {
+std::string SystemInfoConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> BeginFrameObserverState::SerializeAsArray() const {
+std::vector<uint8_t> SystemInfoConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void BeginFrameObserverState::Serialize(::protozero::Message* msg) const {
-  // Field 1: dropped_begin_frame_args
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, dropped_begin_frame_args_, msg);
-  }
-
-  // Field 2: last_begin_frame_args
-  if (_has_field_[2]) {
-    (*last_begin_frame_args_).Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
-  }
-
+void SystemInfoConfig::Serialize(::protozero::Message* msg) const {
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/track_event/track_event_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/track_event/track_event_config.gen.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-BeginImplFrameArgs::BeginImplFrameArgs() = default;
-BeginImplFrameArgs::~BeginImplFrameArgs() = default;
-BeginImplFrameArgs::BeginImplFrameArgs(const BeginImplFrameArgs&) = default;
-BeginImplFrameArgs& BeginImplFrameArgs::operator=(const BeginImplFrameArgs&) = default;
-BeginImplFrameArgs::BeginImplFrameArgs(BeginImplFrameArgs&&) noexcept = default;
-BeginImplFrameArgs& BeginImplFrameArgs::operator=(BeginImplFrameArgs&&) = default;
+TrackEventConfig::TrackEventConfig() = default;
+TrackEventConfig::~TrackEventConfig() = default;
+TrackEventConfig::TrackEventConfig(const TrackEventConfig&) = default;
+TrackEventConfig& TrackEventConfig::operator=(const TrackEventConfig&) = default;
+TrackEventConfig::TrackEventConfig(TrackEventConfig&&) noexcept = default;
+TrackEventConfig& TrackEventConfig::operator=(TrackEventConfig&&) = default;
 
-bool BeginImplFrameArgs::operator==(const BeginImplFrameArgs& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && updated_at_us_ == other.updated_at_us_
-   && finished_at_us_ == other.finished_at_us_
-   && state_ == other.state_
-   && current_args_ == other.current_args_
-   && last_args_ == other.last_args_
-   && timestamps_in_us_ == other.timestamps_in_us_;
+bool TrackEventConfig::operator==(const TrackEventConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(disabled_categories_, other.disabled_categories_)
+   && ::protozero::internal::gen_helpers::EqualsField(enabled_categories_, other.enabled_categories_)
+   && ::protozero::internal::gen_helpers::EqualsField(disabled_tags_, other.disabled_tags_)
+   && ::protozero::internal::gen_helpers::EqualsField(enabled_tags_, other.enabled_tags_)
+   && ::protozero::internal::gen_helpers::EqualsField(disable_incremental_timestamps_, other.disable_incremental_timestamps_)
+   && ::protozero::internal::gen_helpers::EqualsField(timestamp_unit_multiplier_, other.timestamp_unit_multiplier_)
+   && ::protozero::internal::gen_helpers::EqualsField(filter_debug_annotations_, other.filter_debug_annotations_)
+   && ::protozero::internal::gen_helpers::EqualsField(enable_thread_time_sampling_, other.enable_thread_time_sampling_)
+   && ::protozero::internal::gen_helpers::EqualsField(thread_time_subsampling_ns_, other.thread_time_subsampling_ns_)
+   && ::protozero::internal::gen_helpers::EqualsField(filter_dynamic_event_names_, other.filter_dynamic_event_names_);
 }
 
-bool BeginImplFrameArgs::ParseFromArray(const void* raw, size_t size) {
+bool TrackEventConfig::ParseFromArray(const void* raw, size_t size) {
+  disabled_categories_.clear();
+  enabled_categories_.clear();
+  disabled_tags_.clear();
+  enabled_tags_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -29851,23 +25516,39 @@ bool BeginImplFrameArgs::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* updated_at_us */:
-        field.get(&updated_at_us_);
+      case 1 /* disabled_categories */:
+        disabled_categories_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &disabled_categories_.back());
         break;
-      case 2 /* finished_at_us */:
-        field.get(&finished_at_us_);
+      case 2 /* enabled_categories */:
+        enabled_categories_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &enabled_categories_.back());
         break;
-      case 3 /* state */:
-        field.get(&state_);
+      case 3 /* disabled_tags */:
+        disabled_tags_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &disabled_tags_.back());
         break;
-      case 4 /* current_args */:
-        (*current_args_).ParseFromArray(field.data(), field.size());
+      case 4 /* enabled_tags */:
+        enabled_tags_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &enabled_tags_.back());
         break;
-      case 5 /* last_args */:
-        (*last_args_).ParseFromArray(field.data(), field.size());
+      case 5 /* disable_incremental_timestamps */:
+        field.get(&disable_incremental_timestamps_);
         break;
-      case 6 /* timestamps_in_us */:
-        (*timestamps_in_us_).ParseFromArray(field.data(), field.size());
+      case 6 /* timestamp_unit_multiplier */:
+        field.get(&timestamp_unit_multiplier_);
+        break;
+      case 7 /* filter_debug_annotations */:
+        field.get(&filter_debug_annotations_);
+        break;
+      case 8 /* enable_thread_time_sampling */:
+        field.get(&enable_thread_time_sampling_);
+        break;
+      case 10 /* thread_time_subsampling_ns */:
+        field.get(&thread_time_subsampling_ns_);
+        break;
+      case 9 /* filter_dynamic_event_names */:
+        field.get(&filter_dynamic_event_names_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -29877,72 +25558,113 @@ bool BeginImplFrameArgs::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string BeginImplFrameArgs::SerializeAsString() const {
+std::string TrackEventConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> BeginImplFrameArgs::SerializeAsArray() const {
+std::vector<uint8_t> TrackEventConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void BeginImplFrameArgs::Serialize(::protozero::Message* msg) const {
-  // Field 1: updated_at_us
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, updated_at_us_, msg);
+void TrackEventConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: disabled_categories
+  for (auto& it : disabled_categories_) {
+    ::protozero::internal::gen_helpers::SerializeString(1, it, msg);
   }
 
-  // Field 2: finished_at_us
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, finished_at_us_, msg);
+  // Field 2: enabled_categories
+  for (auto& it : enabled_categories_) {
+    ::protozero::internal::gen_helpers::SerializeString(2, it, msg);
   }
 
-  // Field 3: state
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, state_, msg);
+  // Field 3: disabled_tags
+  for (auto& it : disabled_tags_) {
+    ::protozero::internal::gen_helpers::SerializeString(3, it, msg);
   }
 
-  // Field 4: current_args
-  if (_has_field_[4]) {
-    (*current_args_).Serialize(msg->BeginNestedMessage<::protozero::Message>(4));
+  // Field 4: enabled_tags
+  for (auto& it : enabled_tags_) {
+    ::protozero::internal::gen_helpers::SerializeString(4, it, msg);
   }
 
-  // Field 5: last_args
+  // Field 5: disable_incremental_timestamps
   if (_has_field_[5]) {
-    (*last_args_).Serialize(msg->BeginNestedMessage<::protozero::Message>(5));
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, disable_incremental_timestamps_, msg);
   }
 
-  // Field 6: timestamps_in_us
+  // Field 6: timestamp_unit_multiplier
   if (_has_field_[6]) {
-    (*timestamps_in_us_).Serialize(msg->BeginNestedMessage<::protozero::Message>(6));
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, timestamp_unit_multiplier_, msg);
+  }
+
+  // Field 7: filter_debug_annotations
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(7, filter_debug_annotations_, msg);
+  }
+
+  // Field 8: enable_thread_time_sampling
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(8, enable_thread_time_sampling_, msg);
+  }
+
+  // Field 10: thread_time_subsampling_ns
+  if (_has_field_[10]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(10, thread_time_subsampling_ns_, msg);
+  }
+
+  // Field 9: filter_dynamic_event_names
+  if (_has_field_[9]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(9, filter_dynamic_event_names_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/chrome/chrome_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/chrome_config.gen.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-BeginImplFrameArgs_TimestampsInUs::BeginImplFrameArgs_TimestampsInUs() = default;
-BeginImplFrameArgs_TimestampsInUs::~BeginImplFrameArgs_TimestampsInUs() = default;
-BeginImplFrameArgs_TimestampsInUs::BeginImplFrameArgs_TimestampsInUs(const BeginImplFrameArgs_TimestampsInUs&) = default;
-BeginImplFrameArgs_TimestampsInUs& BeginImplFrameArgs_TimestampsInUs::operator=(const BeginImplFrameArgs_TimestampsInUs&) = default;
-BeginImplFrameArgs_TimestampsInUs::BeginImplFrameArgs_TimestampsInUs(BeginImplFrameArgs_TimestampsInUs&&) noexcept = default;
-BeginImplFrameArgs_TimestampsInUs& BeginImplFrameArgs_TimestampsInUs::operator=(BeginImplFrameArgs_TimestampsInUs&&) = default;
+ChromeConfig::ChromeConfig() = default;
+ChromeConfig::~ChromeConfig() = default;
+ChromeConfig::ChromeConfig(const ChromeConfig&) = default;
+ChromeConfig& ChromeConfig::operator=(const ChromeConfig&) = default;
+ChromeConfig::ChromeConfig(ChromeConfig&&) noexcept = default;
+ChromeConfig& ChromeConfig::operator=(ChromeConfig&&) = default;
 
-bool BeginImplFrameArgs_TimestampsInUs::operator==(const BeginImplFrameArgs_TimestampsInUs& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && interval_delta_ == other.interval_delta_
-   && now_to_deadline_delta_ == other.now_to_deadline_delta_
-   && frame_time_to_now_delta_ == other.frame_time_to_now_delta_
-   && frame_time_to_deadline_delta_ == other.frame_time_to_deadline_delta_
-   && now_ == other.now_
-   && frame_time_ == other.frame_time_
-   && deadline_ == other.deadline_;
+bool ChromeConfig::operator==(const ChromeConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(trace_config_, other.trace_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(privacy_filtering_enabled_, other.privacy_filtering_enabled_)
+   && ::protozero::internal::gen_helpers::EqualsField(convert_to_legacy_json_, other.convert_to_legacy_json_)
+   && ::protozero::internal::gen_helpers::EqualsField(client_priority_, other.client_priority_)
+   && ::protozero::internal::gen_helpers::EqualsField(json_agent_label_filter_, other.json_agent_label_filter_)
+   && ::protozero::internal::gen_helpers::EqualsField(event_package_name_filter_enabled_, other.event_package_name_filter_enabled_);
 }
 
-bool BeginImplFrameArgs_TimestampsInUs::ParseFromArray(const void* raw, size_t size) {
+bool ChromeConfig::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -29952,26 +25674,23 @@ bool BeginImplFrameArgs_TimestampsInUs::ParseFromArray(const void* raw, size_t s
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* interval_delta */:
-        field.get(&interval_delta_);
-        break;
-      case 2 /* now_to_deadline_delta */:
-        field.get(&now_to_deadline_delta_);
+      case 1 /* trace_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &trace_config_);
         break;
-      case 3 /* frame_time_to_now_delta */:
-        field.get(&frame_time_to_now_delta_);
+      case 2 /* privacy_filtering_enabled */:
+        field.get(&privacy_filtering_enabled_);
         break;
-      case 4 /* frame_time_to_deadline_delta */:
-        field.get(&frame_time_to_deadline_delta_);
+      case 3 /* convert_to_legacy_json */:
+        field.get(&convert_to_legacy_json_);
         break;
-      case 5 /* now */:
-        field.get(&now_);
+      case 4 /* client_priority */:
+        field.get(&client_priority_);
         break;
-      case 6 /* frame_time */:
-        field.get(&frame_time_);
+      case 5 /* json_agent_label_filter */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &json_agent_label_filter_);
         break;
-      case 7 /* deadline */:
-        field.get(&deadline_);
+      case 6 /* event_package_name_filter_enabled */:
+        field.get(&event_package_name_filter_enabled_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -29981,72 +25700,93 @@ bool BeginImplFrameArgs_TimestampsInUs::ParseFromArray(const void* raw, size_t s
   return !packed_error && !dec.bytes_left();
 }
 
-std::string BeginImplFrameArgs_TimestampsInUs::SerializeAsString() const {
+std::string ChromeConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> BeginImplFrameArgs_TimestampsInUs::SerializeAsArray() const {
+std::vector<uint8_t> ChromeConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void BeginImplFrameArgs_TimestampsInUs::Serialize(::protozero::Message* msg) const {
-  // Field 1: interval_delta
+void ChromeConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: trace_config
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, interval_delta_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(1, trace_config_, msg);
   }
 
-  // Field 2: now_to_deadline_delta
+  // Field 2: privacy_filtering_enabled
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, now_to_deadline_delta_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, privacy_filtering_enabled_, msg);
   }
 
-  // Field 3: frame_time_to_now_delta
+  // Field 3: convert_to_legacy_json
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, frame_time_to_now_delta_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, convert_to_legacy_json_, msg);
   }
 
-  // Field 4: frame_time_to_deadline_delta
+  // Field 4: client_priority
   if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, frame_time_to_deadline_delta_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, client_priority_, msg);
   }
 
-  // Field 5: now
+  // Field 5: json_agent_label_filter
   if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(5, now_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(5, json_agent_label_filter_, msg);
   }
 
-  // Field 6: frame_time
+  // Field 6: event_package_name_filter_enabled
   if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(6, frame_time_, msg);
-  }
-
-  // Field 7: deadline
-  if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(7, deadline_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(6, event_package_name_filter_enabled_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/chrome/histogram_samples.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/histogram_samples.gen.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-ChromeCompositorStateMachine::ChromeCompositorStateMachine() = default;
-ChromeCompositorStateMachine::~ChromeCompositorStateMachine() = default;
-ChromeCompositorStateMachine::ChromeCompositorStateMachine(const ChromeCompositorStateMachine&) = default;
-ChromeCompositorStateMachine& ChromeCompositorStateMachine::operator=(const ChromeCompositorStateMachine&) = default;
-ChromeCompositorStateMachine::ChromeCompositorStateMachine(ChromeCompositorStateMachine&&) noexcept = default;
-ChromeCompositorStateMachine& ChromeCompositorStateMachine::operator=(ChromeCompositorStateMachine&&) = default;
+ChromiumHistogramSamplesConfig::ChromiumHistogramSamplesConfig() = default;
+ChromiumHistogramSamplesConfig::~ChromiumHistogramSamplesConfig() = default;
+ChromiumHistogramSamplesConfig::ChromiumHistogramSamplesConfig(const ChromiumHistogramSamplesConfig&) = default;
+ChromiumHistogramSamplesConfig& ChromiumHistogramSamplesConfig::operator=(const ChromiumHistogramSamplesConfig&) = default;
+ChromiumHistogramSamplesConfig::ChromiumHistogramSamplesConfig(ChromiumHistogramSamplesConfig&&) noexcept = default;
+ChromiumHistogramSamplesConfig& ChromiumHistogramSamplesConfig::operator=(ChromiumHistogramSamplesConfig&&) = default;
 
-bool ChromeCompositorStateMachine::operator==(const ChromeCompositorStateMachine& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && major_state_ == other.major_state_
-   && minor_state_ == other.minor_state_;
+bool ChromiumHistogramSamplesConfig::operator==(const ChromiumHistogramSamplesConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(histograms_, other.histograms_)
+   && ::protozero::internal::gen_helpers::EqualsField(filter_histogram_names_, other.filter_histogram_names_);
 }
 
-bool ChromeCompositorStateMachine::ParseFromArray(const void* raw, size_t size) {
+int ChromiumHistogramSamplesConfig::histograms_size() const { return static_cast<int>(histograms_.size()); }
+void ChromiumHistogramSamplesConfig::clear_histograms() { histograms_.clear(); }
+ChromiumHistogramSamplesConfig_HistogramSample* ChromiumHistogramSamplesConfig::add_histograms() { histograms_.emplace_back(); return &histograms_.back(); }
+bool ChromiumHistogramSamplesConfig::ParseFromArray(const void* raw, size_t size) {
+  histograms_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -30056,11 +25796,12 @@ bool ChromeCompositorStateMachine::ParseFromArray(const void* raw, size_t size)
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* major_state */:
-        (*major_state_).ParseFromArray(field.data(), field.size());
+      case 1 /* histograms */:
+        histograms_.emplace_back();
+        histograms_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 2 /* minor_state */:
-        (*minor_state_).ParseFromArray(field.data(), field.size());
+      case 2 /* filter_histogram_names */:
+        field.get(&filter_histogram_names_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -30070,90 +25811,48 @@ bool ChromeCompositorStateMachine::ParseFromArray(const void* raw, size_t size)
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ChromeCompositorStateMachine::SerializeAsString() const {
+std::string ChromiumHistogramSamplesConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ChromeCompositorStateMachine::SerializeAsArray() const {
+std::vector<uint8_t> ChromiumHistogramSamplesConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ChromeCompositorStateMachine::Serialize(::protozero::Message* msg) const {
-  // Field 1: major_state
-  if (_has_field_[1]) {
-    (*major_state_).Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
+void ChromiumHistogramSamplesConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: histograms
+  for (auto& it : histograms_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
   }
 
-  // Field 2: minor_state
+  // Field 2: filter_histogram_names
   if (_has_field_[2]) {
-    (*minor_state_).Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, filter_histogram_names_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-ChromeCompositorStateMachine_MinorState::ChromeCompositorStateMachine_MinorState() = default;
-ChromeCompositorStateMachine_MinorState::~ChromeCompositorStateMachine_MinorState() = default;
-ChromeCompositorStateMachine_MinorState::ChromeCompositorStateMachine_MinorState(const ChromeCompositorStateMachine_MinorState&) = default;
-ChromeCompositorStateMachine_MinorState& ChromeCompositorStateMachine_MinorState::operator=(const ChromeCompositorStateMachine_MinorState&) = default;
-ChromeCompositorStateMachine_MinorState::ChromeCompositorStateMachine_MinorState(ChromeCompositorStateMachine_MinorState&&) noexcept = default;
-ChromeCompositorStateMachine_MinorState& ChromeCompositorStateMachine_MinorState::operator=(ChromeCompositorStateMachine_MinorState&&) = default;
+ChromiumHistogramSamplesConfig_HistogramSample::ChromiumHistogramSamplesConfig_HistogramSample() = default;
+ChromiumHistogramSamplesConfig_HistogramSample::~ChromiumHistogramSamplesConfig_HistogramSample() = default;
+ChromiumHistogramSamplesConfig_HistogramSample::ChromiumHistogramSamplesConfig_HistogramSample(const ChromiumHistogramSamplesConfig_HistogramSample&) = default;
+ChromiumHistogramSamplesConfig_HistogramSample& ChromiumHistogramSamplesConfig_HistogramSample::operator=(const ChromiumHistogramSamplesConfig_HistogramSample&) = default;
+ChromiumHistogramSamplesConfig_HistogramSample::ChromiumHistogramSamplesConfig_HistogramSample(ChromiumHistogramSamplesConfig_HistogramSample&&) noexcept = default;
+ChromiumHistogramSamplesConfig_HistogramSample& ChromiumHistogramSamplesConfig_HistogramSample::operator=(ChromiumHistogramSamplesConfig_HistogramSample&&) = default;
 
-bool ChromeCompositorStateMachine_MinorState::operator==(const ChromeCompositorStateMachine_MinorState& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && commit_count_ == other.commit_count_
-   && current_frame_number_ == other.current_frame_number_
-   && last_frame_number_submit_performed_ == other.last_frame_number_submit_performed_
-   && last_frame_number_draw_performed_ == other.last_frame_number_draw_performed_
-   && last_frame_number_begin_main_frame_sent_ == other.last_frame_number_begin_main_frame_sent_
-   && did_draw_ == other.did_draw_
-   && did_send_begin_main_frame_for_current_frame_ == other.did_send_begin_main_frame_for_current_frame_
-   && did_notify_begin_main_frame_not_expected_until_ == other.did_notify_begin_main_frame_not_expected_until_
-   && did_notify_begin_main_frame_not_expected_soon_ == other.did_notify_begin_main_frame_not_expected_soon_
-   && wants_begin_main_frame_not_expected_ == other.wants_begin_main_frame_not_expected_
-   && did_commit_during_frame_ == other.did_commit_during_frame_
-   && did_invalidate_layer_tree_frame_sink_ == other.did_invalidate_layer_tree_frame_sink_
-   && did_perform_impl_side_invalidaion_ == other.did_perform_impl_side_invalidaion_
-   && did_prepare_tiles_ == other.did_prepare_tiles_
-   && consecutive_checkerboard_animations_ == other.consecutive_checkerboard_animations_
-   && pending_submit_frames_ == other.pending_submit_frames_
-   && submit_frames_with_current_layer_tree_frame_sink_ == other.submit_frames_with_current_layer_tree_frame_sink_
-   && needs_redraw_ == other.needs_redraw_
-   && needs_prepare_tiles_ == other.needs_prepare_tiles_
-   && needs_begin_main_frame_ == other.needs_begin_main_frame_
-   && needs_one_begin_impl_frame_ == other.needs_one_begin_impl_frame_
-   && visible_ == other.visible_
-   && begin_frame_source_paused_ == other.begin_frame_source_paused_
-   && can_draw_ == other.can_draw_
-   && resourceless_draw_ == other.resourceless_draw_
-   && has_pending_tree_ == other.has_pending_tree_
-   && pending_tree_is_ready_for_activation_ == other.pending_tree_is_ready_for_activation_
-   && active_tree_needs_first_draw_ == other.active_tree_needs_first_draw_
-   && active_tree_is_ready_to_draw_ == other.active_tree_is_ready_to_draw_
-   && did_create_and_initialize_first_layer_tree_frame_sink_ == other.did_create_and_initialize_first_layer_tree_frame_sink_
-   && tree_priority_ == other.tree_priority_
-   && scroll_handler_state_ == other.scroll_handler_state_
-   && critical_begin_main_frame_to_activate_is_fast_ == other.critical_begin_main_frame_to_activate_is_fast_
-   && main_thread_missed_last_deadline_ == other.main_thread_missed_last_deadline_
-   && video_needs_begin_frames_ == other.video_needs_begin_frames_
-   && defer_begin_main_frame_ == other.defer_begin_main_frame_
-   && last_commit_had_no_updates_ == other.last_commit_had_no_updates_
-   && did_draw_in_last_frame_ == other.did_draw_in_last_frame_
-   && did_submit_in_last_frame_ == other.did_submit_in_last_frame_
-   && needs_impl_side_invalidation_ == other.needs_impl_side_invalidation_
-   && current_pending_tree_is_impl_side_ == other.current_pending_tree_is_impl_side_
-   && previous_pending_tree_was_impl_side_ == other.previous_pending_tree_was_impl_side_
-   && processing_animation_worklets_for_active_tree_ == other.processing_animation_worklets_for_active_tree_
-   && processing_animation_worklets_for_pending_tree_ == other.processing_animation_worklets_for_pending_tree_
-   && processing_paint_worklets_for_pending_tree_ == other.processing_paint_worklets_for_pending_tree_;
+bool ChromiumHistogramSamplesConfig_HistogramSample::operator==(const ChromiumHistogramSamplesConfig_HistogramSample& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(histogram_name_, other.histogram_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(min_value_, other.min_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(max_value_, other.max_value_);
 }
 
-bool ChromeCompositorStateMachine_MinorState::ParseFromArray(const void* raw, size_t size) {
+bool ChromiumHistogramSamplesConfig_HistogramSample::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -30163,140 +25862,14 @@ bool ChromeCompositorStateMachine_MinorState::ParseFromArray(const void* raw, si
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* commit_count */:
-        field.get(&commit_count_);
-        break;
-      case 2 /* current_frame_number */:
-        field.get(&current_frame_number_);
-        break;
-      case 3 /* last_frame_number_submit_performed */:
-        field.get(&last_frame_number_submit_performed_);
-        break;
-      case 4 /* last_frame_number_draw_performed */:
-        field.get(&last_frame_number_draw_performed_);
-        break;
-      case 5 /* last_frame_number_begin_main_frame_sent */:
-        field.get(&last_frame_number_begin_main_frame_sent_);
-        break;
-      case 6 /* did_draw */:
-        field.get(&did_draw_);
-        break;
-      case 7 /* did_send_begin_main_frame_for_current_frame */:
-        field.get(&did_send_begin_main_frame_for_current_frame_);
-        break;
-      case 8 /* did_notify_begin_main_frame_not_expected_until */:
-        field.get(&did_notify_begin_main_frame_not_expected_until_);
-        break;
-      case 9 /* did_notify_begin_main_frame_not_expected_soon */:
-        field.get(&did_notify_begin_main_frame_not_expected_soon_);
-        break;
-      case 10 /* wants_begin_main_frame_not_expected */:
-        field.get(&wants_begin_main_frame_not_expected_);
-        break;
-      case 11 /* did_commit_during_frame */:
-        field.get(&did_commit_during_frame_);
-        break;
-      case 12 /* did_invalidate_layer_tree_frame_sink */:
-        field.get(&did_invalidate_layer_tree_frame_sink_);
-        break;
-      case 13 /* did_perform_impl_side_invalidaion */:
-        field.get(&did_perform_impl_side_invalidaion_);
-        break;
-      case 14 /* did_prepare_tiles */:
-        field.get(&did_prepare_tiles_);
-        break;
-      case 15 /* consecutive_checkerboard_animations */:
-        field.get(&consecutive_checkerboard_animations_);
-        break;
-      case 16 /* pending_submit_frames */:
-        field.get(&pending_submit_frames_);
-        break;
-      case 17 /* submit_frames_with_current_layer_tree_frame_sink */:
-        field.get(&submit_frames_with_current_layer_tree_frame_sink_);
-        break;
-      case 18 /* needs_redraw */:
-        field.get(&needs_redraw_);
-        break;
-      case 19 /* needs_prepare_tiles */:
-        field.get(&needs_prepare_tiles_);
-        break;
-      case 20 /* needs_begin_main_frame */:
-        field.get(&needs_begin_main_frame_);
-        break;
-      case 21 /* needs_one_begin_impl_frame */:
-        field.get(&needs_one_begin_impl_frame_);
-        break;
-      case 22 /* visible */:
-        field.get(&visible_);
-        break;
-      case 23 /* begin_frame_source_paused */:
-        field.get(&begin_frame_source_paused_);
-        break;
-      case 24 /* can_draw */:
-        field.get(&can_draw_);
-        break;
-      case 25 /* resourceless_draw */:
-        field.get(&resourceless_draw_);
-        break;
-      case 26 /* has_pending_tree */:
-        field.get(&has_pending_tree_);
-        break;
-      case 27 /* pending_tree_is_ready_for_activation */:
-        field.get(&pending_tree_is_ready_for_activation_);
-        break;
-      case 28 /* active_tree_needs_first_draw */:
-        field.get(&active_tree_needs_first_draw_);
-        break;
-      case 29 /* active_tree_is_ready_to_draw */:
-        field.get(&active_tree_is_ready_to_draw_);
-        break;
-      case 30 /* did_create_and_initialize_first_layer_tree_frame_sink */:
-        field.get(&did_create_and_initialize_first_layer_tree_frame_sink_);
-        break;
-      case 31 /* tree_priority */:
-        field.get(&tree_priority_);
-        break;
-      case 32 /* scroll_handler_state */:
-        field.get(&scroll_handler_state_);
-        break;
-      case 33 /* critical_begin_main_frame_to_activate_is_fast */:
-        field.get(&critical_begin_main_frame_to_activate_is_fast_);
-        break;
-      case 34 /* main_thread_missed_last_deadline */:
-        field.get(&main_thread_missed_last_deadline_);
-        break;
-      case 36 /* video_needs_begin_frames */:
-        field.get(&video_needs_begin_frames_);
-        break;
-      case 37 /* defer_begin_main_frame */:
-        field.get(&defer_begin_main_frame_);
-        break;
-      case 38 /* last_commit_had_no_updates */:
-        field.get(&last_commit_had_no_updates_);
-        break;
-      case 39 /* did_draw_in_last_frame */:
-        field.get(&did_draw_in_last_frame_);
-        break;
-      case 40 /* did_submit_in_last_frame */:
-        field.get(&did_submit_in_last_frame_);
-        break;
-      case 41 /* needs_impl_side_invalidation */:
-        field.get(&needs_impl_side_invalidation_);
-        break;
-      case 42 /* current_pending_tree_is_impl_side */:
-        field.get(&current_pending_tree_is_impl_side_);
-        break;
-      case 43 /* previous_pending_tree_was_impl_side */:
-        field.get(&previous_pending_tree_was_impl_side_);
-        break;
-      case 44 /* processing_animation_worklets_for_active_tree */:
-        field.get(&processing_animation_worklets_for_active_tree_);
+      case 1 /* histogram_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &histogram_name_);
         break;
-      case 45 /* processing_animation_worklets_for_pending_tree */:
-        field.get(&processing_animation_worklets_for_pending_tree_);
+      case 2 /* min_value */:
+        field.get(&min_value_);
         break;
-      case 46 /* processing_paint_worklets_for_pending_tree */:
-        field.get(&processing_paint_worklets_for_pending_tree_);
+      case 3 /* max_value */:
+        field.get(&max_value_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -30306,265 +25879,361 @@ bool ChromeCompositorStateMachine_MinorState::ParseFromArray(const void* raw, si
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ChromeCompositorStateMachine_MinorState::SerializeAsString() const {
+std::string ChromiumHistogramSamplesConfig_HistogramSample::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ChromeCompositorStateMachine_MinorState::SerializeAsArray() const {
+std::vector<uint8_t> ChromiumHistogramSamplesConfig_HistogramSample::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ChromeCompositorStateMachine_MinorState::Serialize(::protozero::Message* msg) const {
-  // Field 1: commit_count
+void ChromiumHistogramSamplesConfig_HistogramSample::Serialize(::protozero::Message* msg) const {
+  // Field 1: histogram_name
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, commit_count_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(1, histogram_name_, msg);
   }
 
-  // Field 2: current_frame_number
+  // Field 2: min_value
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, current_frame_number_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, min_value_, msg);
   }
 
-  // Field 3: last_frame_number_submit_performed
+  // Field 3: max_value
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, last_frame_number_submit_performed_, msg);
-  }
-
-  // Field 4: last_frame_number_draw_performed
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, last_frame_number_draw_performed_, msg);
-  }
-
-  // Field 5: last_frame_number_begin_main_frame_sent
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(5, last_frame_number_begin_main_frame_sent_, msg);
-  }
-
-  // Field 6: did_draw
-  if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(6, did_draw_, msg);
-  }
-
-  // Field 7: did_send_begin_main_frame_for_current_frame
-  if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(7, did_send_begin_main_frame_for_current_frame_, msg);
-  }
-
-  // Field 8: did_notify_begin_main_frame_not_expected_until
-  if (_has_field_[8]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(8, did_notify_begin_main_frame_not_expected_until_, msg);
-  }
-
-  // Field 9: did_notify_begin_main_frame_not_expected_soon
-  if (_has_field_[9]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(9, did_notify_begin_main_frame_not_expected_soon_, msg);
-  }
-
-  // Field 10: wants_begin_main_frame_not_expected
-  if (_has_field_[10]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(10, wants_begin_main_frame_not_expected_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, max_value_, msg);
   }
 
-  // Field 11: did_commit_during_frame
-  if (_has_field_[11]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(11, did_commit_during_frame_, msg);
-  }
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  // Field 12: did_invalidate_layer_tree_frame_sink
-  if (_has_field_[12]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(12, did_invalidate_layer_tree_frame_sink_, msg);
-  }
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/chrome/scenario_config.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/scenario_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/trace_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/priority_boost/priority_boost_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/data_source_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/qnx/qnx_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/histogram_samples.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/system_info/system_info_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/track_event/track_event_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/test_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/sys_stats/sys_stats_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/sys_stats_counters.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/perf_event_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/perf_events.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/java_hprof_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/heapprofd_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/process_stats/process_stats_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/statsd/statsd_tracing_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/statsd/atom_ids.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/protovm/protovm_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/power/android_power_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/interceptor_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/interceptors/console_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/inode_file/inode_file_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/gpu/gpu_renderstages_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/gpu/vulkan_memory_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/gpu/gpu_counter_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/ftrace/frozen_ftrace_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/ftrace/ftrace_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/system_metrics.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/etw/etw_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/v8_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/chrome_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/windowmanager_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/user_list_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/surfaceflinger_transactions_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/surfaceflinger_layers_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/protolog_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/protolog_common.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/pixel_modem_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/packages_list_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/network_trace_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/kernel_wakelocks_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/inputmethod_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/cpu_per_uid_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/app_wakelock_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_sdk_sysprop_guard_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_system_property_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_polled_state_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_log_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/android_log_constants.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_input_event_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_game_intervention_list_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/semantic_type.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/builtin_clock.gen.h"
 
-  // Field 13: did_perform_impl_side_invalidaion
-  if (_has_field_[13]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(13, did_perform_impl_side_invalidaion_, msg);
-  }
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-  // Field 14: did_prepare_tiles
-  if (_has_field_[14]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(14, did_prepare_tiles_, msg);
-  }
+TracingTriggerRulesConfig::TracingTriggerRulesConfig() = default;
+TracingTriggerRulesConfig::~TracingTriggerRulesConfig() = default;
+TracingTriggerRulesConfig::TracingTriggerRulesConfig(const TracingTriggerRulesConfig&) = default;
+TracingTriggerRulesConfig& TracingTriggerRulesConfig::operator=(const TracingTriggerRulesConfig&) = default;
+TracingTriggerRulesConfig::TracingTriggerRulesConfig(TracingTriggerRulesConfig&&) noexcept = default;
+TracingTriggerRulesConfig& TracingTriggerRulesConfig::operator=(TracingTriggerRulesConfig&&) = default;
 
-  // Field 15: consecutive_checkerboard_animations
-  if (_has_field_[15]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(15, consecutive_checkerboard_animations_, msg);
-  }
+bool TracingTriggerRulesConfig::operator==(const TracingTriggerRulesConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(rules_, other.rules_);
+}
 
-  // Field 16: pending_submit_frames
-  if (_has_field_[16]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(16, pending_submit_frames_, msg);
-  }
+int TracingTriggerRulesConfig::rules_size() const { return static_cast<int>(rules_.size()); }
+void TracingTriggerRulesConfig::clear_rules() { rules_.clear(); }
+TriggerRule* TracingTriggerRulesConfig::add_rules() { rules_.emplace_back(); return &rules_.back(); }
+bool TracingTriggerRulesConfig::ParseFromArray(const void* raw, size_t size) {
+  rules_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  // Field 17: submit_frames_with_current_layer_tree_frame_sink
-  if (_has_field_[17]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(17, submit_frames_with_current_layer_tree_frame_sink_, msg);
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* rules */:
+        rules_.emplace_back();
+        rules_.back().ParseFromArray(field.data(), field.size());
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
   }
+  return !packed_error && !dec.bytes_left();
+}
 
-  // Field 18: needs_redraw
-  if (_has_field_[18]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(18, needs_redraw_, msg);
-  }
+std::string TracingTriggerRulesConfig::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  // Field 19: needs_prepare_tiles
-  if (_has_field_[19]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(19, needs_prepare_tiles_, msg);
-  }
+std::vector<uint8_t> TracingTriggerRulesConfig::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  // Field 20: needs_begin_main_frame
-  if (_has_field_[20]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(20, needs_begin_main_frame_, msg);
+void TracingTriggerRulesConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: rules
+  for (auto& it : rules_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
   }
 
-  // Field 21: needs_one_begin_impl_frame
-  if (_has_field_[21]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(21, needs_one_begin_impl_frame_, msg);
-  }
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  // Field 22: visible
-  if (_has_field_[22]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(22, visible_, msg);
-  }
 
-  // Field 23: begin_frame_source_paused
-  if (_has_field_[23]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(23, begin_frame_source_paused_, msg);
-  }
+TriggerRule::TriggerRule() = default;
+TriggerRule::~TriggerRule() = default;
+TriggerRule::TriggerRule(const TriggerRule&) = default;
+TriggerRule& TriggerRule::operator=(const TriggerRule&) = default;
+TriggerRule::TriggerRule(TriggerRule&&) noexcept = default;
+TriggerRule& TriggerRule::operator=(TriggerRule&&) = default;
 
-  // Field 24: can_draw
-  if (_has_field_[24]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(24, can_draw_, msg);
-  }
+bool TriggerRule::operator==(const TriggerRule& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(trigger_chance_, other.trigger_chance_)
+   && ::protozero::internal::gen_helpers::EqualsField(delay_ms_, other.delay_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(activation_delay_ms_, other.activation_delay_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(manual_trigger_name_, other.manual_trigger_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(histogram_, other.histogram_)
+   && ::protozero::internal::gen_helpers::EqualsField(repeating_interval_, other.repeating_interval_);
+}
 
-  // Field 25: resourceless_draw
-  if (_has_field_[25]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(25, resourceless_draw_, msg);
-  }
+bool TriggerRule::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  // Field 26: has_pending_tree
-  if (_has_field_[26]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(26, has_pending_tree_, msg);
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+        break;
+      case 2 /* trigger_chance */:
+        field.get(&trigger_chance_);
+        break;
+      case 3 /* delay_ms */:
+        field.get(&delay_ms_);
+        break;
+      case 8 /* activation_delay_ms */:
+        field.get(&activation_delay_ms_);
+        break;
+      case 4 /* manual_trigger_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &manual_trigger_name_);
+        break;
+      case 5 /* histogram */:
+        (*histogram_).ParseFromArray(field.data(), field.size());
+        break;
+      case 6 /* repeating_interval */:
+        (*repeating_interval_).ParseFromArray(field.data(), field.size());
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
   }
+  return !packed_error && !dec.bytes_left();
+}
 
-  // Field 27: pending_tree_is_ready_for_activation
-  if (_has_field_[27]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(27, pending_tree_is_ready_for_activation_, msg);
-  }
+std::string TriggerRule::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  // Field 28: active_tree_needs_first_draw
-  if (_has_field_[28]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(28, active_tree_needs_first_draw_, msg);
-  }
+std::vector<uint8_t> TriggerRule::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  // Field 29: active_tree_is_ready_to_draw
-  if (_has_field_[29]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(29, active_tree_is_ready_to_draw_, msg);
+void TriggerRule::Serialize(::protozero::Message* msg) const {
+  // Field 1: name
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
   }
 
-  // Field 30: did_create_and_initialize_first_layer_tree_frame_sink
-  if (_has_field_[30]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(30, did_create_and_initialize_first_layer_tree_frame_sink_, msg);
+  // Field 2: trigger_chance
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeFixed(2, trigger_chance_, msg);
   }
 
-  // Field 31: tree_priority
-  if (_has_field_[31]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(31, tree_priority_, msg);
+  // Field 3: delay_ms
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, delay_ms_, msg);
   }
 
-  // Field 32: scroll_handler_state
-  if (_has_field_[32]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(32, scroll_handler_state_, msg);
+  // Field 8: activation_delay_ms
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(8, activation_delay_ms_, msg);
   }
 
-  // Field 33: critical_begin_main_frame_to_activate_is_fast
-  if (_has_field_[33]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(33, critical_begin_main_frame_to_activate_is_fast_, msg);
+  // Field 4: manual_trigger_name
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeString(4, manual_trigger_name_, msg);
   }
 
-  // Field 34: main_thread_missed_last_deadline
-  if (_has_field_[34]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(34, main_thread_missed_last_deadline_, msg);
+  // Field 5: histogram
+  if (_has_field_[5]) {
+    (*histogram_).Serialize(msg->BeginNestedMessage<::protozero::Message>(5));
   }
 
-  // Field 36: video_needs_begin_frames
-  if (_has_field_[36]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(36, video_needs_begin_frames_, msg);
+  // Field 6: repeating_interval
+  if (_has_field_[6]) {
+    (*repeating_interval_).Serialize(msg->BeginNestedMessage<::protozero::Message>(6));
   }
 
-  // Field 37: defer_begin_main_frame
-  if (_has_field_[37]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(37, defer_begin_main_frame_, msg);
-  }
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  // Field 38: last_commit_had_no_updates
-  if (_has_field_[38]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(38, last_commit_had_no_updates_, msg);
-  }
 
-  // Field 39: did_draw_in_last_frame
-  if (_has_field_[39]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(39, did_draw_in_last_frame_, msg);
-  }
+TriggerRule_RepeatingInterval::TriggerRule_RepeatingInterval() = default;
+TriggerRule_RepeatingInterval::~TriggerRule_RepeatingInterval() = default;
+TriggerRule_RepeatingInterval::TriggerRule_RepeatingInterval(const TriggerRule_RepeatingInterval&) = default;
+TriggerRule_RepeatingInterval& TriggerRule_RepeatingInterval::operator=(const TriggerRule_RepeatingInterval&) = default;
+TriggerRule_RepeatingInterval::TriggerRule_RepeatingInterval(TriggerRule_RepeatingInterval&&) noexcept = default;
+TriggerRule_RepeatingInterval& TriggerRule_RepeatingInterval::operator=(TriggerRule_RepeatingInterval&&) = default;
 
-  // Field 40: did_submit_in_last_frame
-  if (_has_field_[40]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(40, did_submit_in_last_frame_, msg);
-  }
+bool TriggerRule_RepeatingInterval::operator==(const TriggerRule_RepeatingInterval& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(period_ms_, other.period_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(randomized_, other.randomized_);
+}
 
-  // Field 41: needs_impl_side_invalidation
-  if (_has_field_[41]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(41, needs_impl_side_invalidation_, msg);
-  }
+bool TriggerRule_RepeatingInterval::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  // Field 42: current_pending_tree_is_impl_side
-  if (_has_field_[42]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(42, current_pending_tree_is_impl_side_, msg);
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* period_ms */:
+        field.get(&period_ms_);
+        break;
+      case 2 /* randomized */:
+        field.get(&randomized_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
   }
+  return !packed_error && !dec.bytes_left();
+}
 
-  // Field 43: previous_pending_tree_was_impl_side
-  if (_has_field_[43]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(43, previous_pending_tree_was_impl_side_, msg);
-  }
+std::string TriggerRule_RepeatingInterval::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  // Field 44: processing_animation_worklets_for_active_tree
-  if (_has_field_[44]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(44, processing_animation_worklets_for_active_tree_, msg);
-  }
+std::vector<uint8_t> TriggerRule_RepeatingInterval::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  // Field 45: processing_animation_worklets_for_pending_tree
-  if (_has_field_[45]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(45, processing_animation_worklets_for_pending_tree_, msg);
+void TriggerRule_RepeatingInterval::Serialize(::protozero::Message* msg) const {
+  // Field 1: period_ms
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, period_ms_, msg);
   }
 
-  // Field 46: processing_paint_worklets_for_pending_tree
-  if (_has_field_[46]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(46, processing_paint_worklets_for_pending_tree_, msg);
+  // Field 2: randomized
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, randomized_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-ChromeCompositorStateMachine_MajorState::ChromeCompositorStateMachine_MajorState() = default;
-ChromeCompositorStateMachine_MajorState::~ChromeCompositorStateMachine_MajorState() = default;
-ChromeCompositorStateMachine_MajorState::ChromeCompositorStateMachine_MajorState(const ChromeCompositorStateMachine_MajorState&) = default;
-ChromeCompositorStateMachine_MajorState& ChromeCompositorStateMachine_MajorState::operator=(const ChromeCompositorStateMachine_MajorState&) = default;
-ChromeCompositorStateMachine_MajorState::ChromeCompositorStateMachine_MajorState(ChromeCompositorStateMachine_MajorState&&) noexcept = default;
-ChromeCompositorStateMachine_MajorState& ChromeCompositorStateMachine_MajorState::operator=(ChromeCompositorStateMachine_MajorState&&) = default;
+TriggerRule_HistogramTrigger::TriggerRule_HistogramTrigger() = default;
+TriggerRule_HistogramTrigger::~TriggerRule_HistogramTrigger() = default;
+TriggerRule_HistogramTrigger::TriggerRule_HistogramTrigger(const TriggerRule_HistogramTrigger&) = default;
+TriggerRule_HistogramTrigger& TriggerRule_HistogramTrigger::operator=(const TriggerRule_HistogramTrigger&) = default;
+TriggerRule_HistogramTrigger::TriggerRule_HistogramTrigger(TriggerRule_HistogramTrigger&&) noexcept = default;
+TriggerRule_HistogramTrigger& TriggerRule_HistogramTrigger::operator=(TriggerRule_HistogramTrigger&&) = default;
 
-bool ChromeCompositorStateMachine_MajorState::operator==(const ChromeCompositorStateMachine_MajorState& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && next_action_ == other.next_action_
-   && begin_impl_frame_state_ == other.begin_impl_frame_state_
-   && begin_main_frame_state_ == other.begin_main_frame_state_
-   && layer_tree_frame_sink_state_ == other.layer_tree_frame_sink_state_
-   && forced_redraw_state_ == other.forced_redraw_state_;
+bool TriggerRule_HistogramTrigger::operator==(const TriggerRule_HistogramTrigger& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(histogram_name_, other.histogram_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(min_value_, other.min_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(max_value_, other.max_value_);
 }
 
-bool ChromeCompositorStateMachine_MajorState::ParseFromArray(const void* raw, size_t size) {
+bool TriggerRule_HistogramTrigger::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -30574,20 +26243,14 @@ bool ChromeCompositorStateMachine_MajorState::ParseFromArray(const void* raw, si
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* next_action */:
-        field.get(&next_action_);
-        break;
-      case 2 /* begin_impl_frame_state */:
-        field.get(&begin_impl_frame_state_);
-        break;
-      case 3 /* begin_main_frame_state */:
-        field.get(&begin_main_frame_state_);
+      case 1 /* histogram_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &histogram_name_);
         break;
-      case 4 /* layer_tree_frame_sink_state */:
-        field.get(&layer_tree_frame_sink_state_);
+      case 2 /* min_value */:
+        field.get(&min_value_);
         break;
-      case 5 /* forced_redraw_state */:
-        field.get(&forced_redraw_state_);
+      case 3 /* max_value */:
+        field.get(&max_value_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -30597,76 +26260,55 @@ bool ChromeCompositorStateMachine_MajorState::ParseFromArray(const void* raw, si
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ChromeCompositorStateMachine_MajorState::SerializeAsString() const {
+std::string TriggerRule_HistogramTrigger::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ChromeCompositorStateMachine_MajorState::SerializeAsArray() const {
+std::vector<uint8_t> TriggerRule_HistogramTrigger::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ChromeCompositorStateMachine_MajorState::Serialize(::protozero::Message* msg) const {
-  // Field 1: next_action
+void TriggerRule_HistogramTrigger::Serialize(::protozero::Message* msg) const {
+  // Field 1: histogram_name
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, next_action_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(1, histogram_name_, msg);
   }
 
-  // Field 2: begin_impl_frame_state
+  // Field 2: min_value
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, begin_impl_frame_state_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, min_value_, msg);
   }
 
-  // Field 3: begin_main_frame_state
+  // Field 3: max_value
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, begin_main_frame_state_, msg);
-  }
-
-  // Field 4: layer_tree_frame_sink_state
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, layer_tree_frame_sink_state_, msg);
-  }
-
-  // Field 5: forced_redraw_state
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(5, forced_redraw_state_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, max_value_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-ChromeCompositorSchedulerState::ChromeCompositorSchedulerState() = default;
-ChromeCompositorSchedulerState::~ChromeCompositorSchedulerState() = default;
-ChromeCompositorSchedulerState::ChromeCompositorSchedulerState(const ChromeCompositorSchedulerState&) = default;
-ChromeCompositorSchedulerState& ChromeCompositorSchedulerState::operator=(const ChromeCompositorSchedulerState&) = default;
-ChromeCompositorSchedulerState::ChromeCompositorSchedulerState(ChromeCompositorSchedulerState&&) noexcept = default;
-ChromeCompositorSchedulerState& ChromeCompositorSchedulerState::operator=(ChromeCompositorSchedulerState&&) = default;
+ChromeFieldTracingConfig::ChromeFieldTracingConfig() = default;
+ChromeFieldTracingConfig::~ChromeFieldTracingConfig() = default;
+ChromeFieldTracingConfig::ChromeFieldTracingConfig(const ChromeFieldTracingConfig&) = default;
+ChromeFieldTracingConfig& ChromeFieldTracingConfig::operator=(const ChromeFieldTracingConfig&) = default;
+ChromeFieldTracingConfig::ChromeFieldTracingConfig(ChromeFieldTracingConfig&&) noexcept = default;
+ChromeFieldTracingConfig& ChromeFieldTracingConfig::operator=(ChromeFieldTracingConfig&&) = default;
 
-bool ChromeCompositorSchedulerState::operator==(const ChromeCompositorSchedulerState& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && state_machine_ == other.state_machine_
-   && observing_begin_frame_source_ == other.observing_begin_frame_source_
-   && begin_impl_frame_deadline_task_ == other.begin_impl_frame_deadline_task_
-   && pending_begin_frame_task_ == other.pending_begin_frame_task_
-   && skipped_last_frame_missed_exceeded_deadline_ == other.skipped_last_frame_missed_exceeded_deadline_
-   && inside_action_ == other.inside_action_
-   && deadline_mode_ == other.deadline_mode_
-   && deadline_us_ == other.deadline_us_
-   && deadline_scheduled_at_us_ == other.deadline_scheduled_at_us_
-   && now_us_ == other.now_us_
-   && now_to_deadline_delta_us_ == other.now_to_deadline_delta_us_
-   && now_to_deadline_scheduled_at_delta_us_ == other.now_to_deadline_scheduled_at_delta_us_
-   && begin_impl_frame_args_ == other.begin_impl_frame_args_
-   && begin_frame_observer_state_ == other.begin_frame_observer_state_
-   && begin_frame_source_state_ == other.begin_frame_source_state_
-   && compositor_timing_history_ == other.compositor_timing_history_;
+bool ChromeFieldTracingConfig::operator==(const ChromeFieldTracingConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(scenarios_, other.scenarios_);
 }
 
-bool ChromeCompositorSchedulerState::ParseFromArray(const void* raw, size_t size) {
+int ChromeFieldTracingConfig::scenarios_size() const { return static_cast<int>(scenarios_.size()); }
+void ChromeFieldTracingConfig::clear_scenarios() { scenarios_.clear(); }
+ScenarioConfig* ChromeFieldTracingConfig::add_scenarios() { scenarios_.emplace_back(); return &scenarios_.back(); }
+bool ChromeFieldTracingConfig::ParseFromArray(const void* raw, size_t size) {
+  scenarios_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -30676,53 +26318,121 @@ bool ChromeCompositorSchedulerState::ParseFromArray(const void* raw, size_t size
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* state_machine */:
-        (*state_machine_).ParseFromArray(field.data(), field.size());
-        break;
-      case 2 /* observing_begin_frame_source */:
-        field.get(&observing_begin_frame_source_);
-        break;
-      case 3 /* begin_impl_frame_deadline_task */:
-        field.get(&begin_impl_frame_deadline_task_);
-        break;
-      case 4 /* pending_begin_frame_task */:
-        field.get(&pending_begin_frame_task_);
-        break;
-      case 5 /* skipped_last_frame_missed_exceeded_deadline */:
-        field.get(&skipped_last_frame_missed_exceeded_deadline_);
-        break;
-      case 7 /* inside_action */:
-        field.get(&inside_action_);
+      case 1 /* scenarios */:
+        scenarios_.emplace_back();
+        scenarios_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 8 /* deadline_mode */:
-        field.get(&deadline_mode_);
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
         break;
-      case 9 /* deadline_us */:
-        field.get(&deadline_us_);
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
+
+std::string ChromeFieldTracingConfig::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> ChromeFieldTracingConfig::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void ChromeFieldTracingConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: scenarios
+  for (auto& it : scenarios_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
+
+
+ScenarioConfig::ScenarioConfig() = default;
+ScenarioConfig::~ScenarioConfig() = default;
+ScenarioConfig::ScenarioConfig(const ScenarioConfig&) = default;
+ScenarioConfig& ScenarioConfig::operator=(const ScenarioConfig&) = default;
+ScenarioConfig::ScenarioConfig(ScenarioConfig&&) noexcept = default;
+ScenarioConfig& ScenarioConfig::operator=(ScenarioConfig&&) = default;
+
+bool ScenarioConfig::operator==(const ScenarioConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(scenario_name_, other.scenario_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(scenario_description_, other.scenario_description_)
+   && ::protozero::internal::gen_helpers::EqualsField(start_rules_, other.start_rules_)
+   && ::protozero::internal::gen_helpers::EqualsField(stop_rules_, other.stop_rules_)
+   && ::protozero::internal::gen_helpers::EqualsField(upload_rules_, other.upload_rules_)
+   && ::protozero::internal::gen_helpers::EqualsField(setup_rules_, other.setup_rules_)
+   && ::protozero::internal::gen_helpers::EqualsField(trace_config_, other.trace_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(nested_scenarios_, other.nested_scenarios_)
+   && ::protozero::internal::gen_helpers::EqualsField(use_system_backend_, other.use_system_backend_);
+}
+
+int ScenarioConfig::start_rules_size() const { return static_cast<int>(start_rules_.size()); }
+void ScenarioConfig::clear_start_rules() { start_rules_.clear(); }
+TriggerRule* ScenarioConfig::add_start_rules() { start_rules_.emplace_back(); return &start_rules_.back(); }
+int ScenarioConfig::stop_rules_size() const { return static_cast<int>(stop_rules_.size()); }
+void ScenarioConfig::clear_stop_rules() { stop_rules_.clear(); }
+TriggerRule* ScenarioConfig::add_stop_rules() { stop_rules_.emplace_back(); return &stop_rules_.back(); }
+int ScenarioConfig::upload_rules_size() const { return static_cast<int>(upload_rules_.size()); }
+void ScenarioConfig::clear_upload_rules() { upload_rules_.clear(); }
+TriggerRule* ScenarioConfig::add_upload_rules() { upload_rules_.emplace_back(); return &upload_rules_.back(); }
+int ScenarioConfig::setup_rules_size() const { return static_cast<int>(setup_rules_.size()); }
+void ScenarioConfig::clear_setup_rules() { setup_rules_.clear(); }
+TriggerRule* ScenarioConfig::add_setup_rules() { setup_rules_.emplace_back(); return &setup_rules_.back(); }
+int ScenarioConfig::nested_scenarios_size() const { return static_cast<int>(nested_scenarios_.size()); }
+void ScenarioConfig::clear_nested_scenarios() { nested_scenarios_.clear(); }
+NestedScenarioConfig* ScenarioConfig::add_nested_scenarios() { nested_scenarios_.emplace_back(); return &nested_scenarios_.back(); }
+bool ScenarioConfig::ParseFromArray(const void* raw, size_t size) {
+  start_rules_.clear();
+  stop_rules_.clear();
+  upload_rules_.clear();
+  setup_rules_.clear();
+  nested_scenarios_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* scenario_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &scenario_name_);
         break;
-      case 10 /* deadline_scheduled_at_us */:
-        field.get(&deadline_scheduled_at_us_);
+      case 9 /* scenario_description */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &scenario_description_);
         break;
-      case 11 /* now_us */:
-        field.get(&now_us_);
+      case 2 /* start_rules */:
+        start_rules_.emplace_back();
+        start_rules_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 12 /* now_to_deadline_delta_us */:
-        field.get(&now_to_deadline_delta_us_);
+      case 3 /* stop_rules */:
+        stop_rules_.emplace_back();
+        stop_rules_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 13 /* now_to_deadline_scheduled_at_delta_us */:
-        field.get(&now_to_deadline_scheduled_at_delta_us_);
+      case 4 /* upload_rules */:
+        upload_rules_.emplace_back();
+        upload_rules_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 14 /* begin_impl_frame_args */:
-        (*begin_impl_frame_args_).ParseFromArray(field.data(), field.size());
+      case 5 /* setup_rules */:
+        setup_rules_.emplace_back();
+        setup_rules_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 15 /* begin_frame_observer_state */:
-        (*begin_frame_observer_state_).ParseFromArray(field.data(), field.size());
+      case 6 /* trace_config */:
+        (*trace_config_).ParseFromArray(field.data(), field.size());
         break;
-      case 16 /* begin_frame_source_state */:
-        (*begin_frame_source_state_).ParseFromArray(field.data(), field.size());
+      case 7 /* nested_scenarios */:
+        nested_scenarios_.emplace_back();
+        nested_scenarios_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 17 /* compositor_timing_history */:
-        (*compositor_timing_history_).ParseFromArray(field.data(), field.size());
+      case 8 /* use_system_backend */:
+        field.get(&use_system_backend_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -30732,97 +26442,159 @@ bool ChromeCompositorSchedulerState::ParseFromArray(const void* raw, size_t size
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ChromeCompositorSchedulerState::SerializeAsString() const {
+std::string ScenarioConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ChromeCompositorSchedulerState::SerializeAsArray() const {
+std::vector<uint8_t> ScenarioConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ChromeCompositorSchedulerState::Serialize(::protozero::Message* msg) const {
-  // Field 1: state_machine
+void ScenarioConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: scenario_name
   if (_has_field_[1]) {
-    (*state_machine_).Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
+    ::protozero::internal::gen_helpers::SerializeString(1, scenario_name_, msg);
   }
 
-  // Field 2: observing_begin_frame_source
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, observing_begin_frame_source_, msg);
+  // Field 9: scenario_description
+  if (_has_field_[9]) {
+    ::protozero::internal::gen_helpers::SerializeString(9, scenario_description_, msg);
   }
 
-  // Field 3: begin_impl_frame_deadline_task
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, begin_impl_frame_deadline_task_, msg);
+  // Field 2: start_rules
+  for (auto& it : start_rules_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
   }
 
-  // Field 4: pending_begin_frame_task
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(4, pending_begin_frame_task_, msg);
+  // Field 3: stop_rules
+  for (auto& it : stop_rules_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(3));
   }
 
-  // Field 5: skipped_last_frame_missed_exceeded_deadline
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, skipped_last_frame_missed_exceeded_deadline_, msg);
+  // Field 4: upload_rules
+  for (auto& it : upload_rules_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(4));
   }
 
-  // Field 7: inside_action
-  if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(7, inside_action_, msg);
+  // Field 5: setup_rules
+  for (auto& it : setup_rules_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(5));
   }
 
-  // Field 8: deadline_mode
-  if (_has_field_[8]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(8, deadline_mode_, msg);
+  // Field 6: trace_config
+  if (_has_field_[6]) {
+    (*trace_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(6));
   }
 
-  // Field 9: deadline_us
-  if (_has_field_[9]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(9, deadline_us_, msg);
+  // Field 7: nested_scenarios
+  for (auto& it : nested_scenarios_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(7));
   }
 
-  // Field 10: deadline_scheduled_at_us
-  if (_has_field_[10]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(10, deadline_scheduled_at_us_, msg);
+  // Field 8: use_system_backend
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(8, use_system_backend_, msg);
   }
 
-  // Field 11: now_us
-  if (_has_field_[11]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(11, now_us_, msg);
-  }
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  // Field 12: now_to_deadline_delta_us
-  if (_has_field_[12]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(12, now_to_deadline_delta_us_, msg);
-  }
 
-  // Field 13: now_to_deadline_scheduled_at_delta_us
-  if (_has_field_[13]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(13, now_to_deadline_scheduled_at_delta_us_, msg);
+NestedScenarioConfig::NestedScenarioConfig() = default;
+NestedScenarioConfig::~NestedScenarioConfig() = default;
+NestedScenarioConfig::NestedScenarioConfig(const NestedScenarioConfig&) = default;
+NestedScenarioConfig& NestedScenarioConfig::operator=(const NestedScenarioConfig&) = default;
+NestedScenarioConfig::NestedScenarioConfig(NestedScenarioConfig&&) noexcept = default;
+NestedScenarioConfig& NestedScenarioConfig::operator=(NestedScenarioConfig&&) = default;
+
+bool NestedScenarioConfig::operator==(const NestedScenarioConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(scenario_name_, other.scenario_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(start_rules_, other.start_rules_)
+   && ::protozero::internal::gen_helpers::EqualsField(stop_rules_, other.stop_rules_)
+   && ::protozero::internal::gen_helpers::EqualsField(upload_rules_, other.upload_rules_);
+}
+
+int NestedScenarioConfig::start_rules_size() const { return static_cast<int>(start_rules_.size()); }
+void NestedScenarioConfig::clear_start_rules() { start_rules_.clear(); }
+TriggerRule* NestedScenarioConfig::add_start_rules() { start_rules_.emplace_back(); return &start_rules_.back(); }
+int NestedScenarioConfig::stop_rules_size() const { return static_cast<int>(stop_rules_.size()); }
+void NestedScenarioConfig::clear_stop_rules() { stop_rules_.clear(); }
+TriggerRule* NestedScenarioConfig::add_stop_rules() { stop_rules_.emplace_back(); return &stop_rules_.back(); }
+int NestedScenarioConfig::upload_rules_size() const { return static_cast<int>(upload_rules_.size()); }
+void NestedScenarioConfig::clear_upload_rules() { upload_rules_.clear(); }
+TriggerRule* NestedScenarioConfig::add_upload_rules() { upload_rules_.emplace_back(); return &upload_rules_.back(); }
+bool NestedScenarioConfig::ParseFromArray(const void* raw, size_t size) {
+  start_rules_.clear();
+  stop_rules_.clear();
+  upload_rules_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* scenario_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &scenario_name_);
+        break;
+      case 2 /* start_rules */:
+        start_rules_.emplace_back();
+        start_rules_.back().ParseFromArray(field.data(), field.size());
+        break;
+      case 3 /* stop_rules */:
+        stop_rules_.emplace_back();
+        stop_rules_.back().ParseFromArray(field.data(), field.size());
+        break;
+      case 4 /* upload_rules */:
+        upload_rules_.emplace_back();
+        upload_rules_.back().ParseFromArray(field.data(), field.size());
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
   }
+  return !packed_error && !dec.bytes_left();
+}
 
-  // Field 14: begin_impl_frame_args
-  if (_has_field_[14]) {
-    (*begin_impl_frame_args_).Serialize(msg->BeginNestedMessage<::protozero::Message>(14));
+std::string NestedScenarioConfig::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> NestedScenarioConfig::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void NestedScenarioConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: scenario_name
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeString(1, scenario_name_, msg);
   }
 
-  // Field 15: begin_frame_observer_state
-  if (_has_field_[15]) {
-    (*begin_frame_observer_state_).Serialize(msg->BeginNestedMessage<::protozero::Message>(15));
+  // Field 2: start_rules
+  for (auto& it : start_rules_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
   }
 
-  // Field 16: begin_frame_source_state
-  if (_has_field_[16]) {
-    (*begin_frame_source_state_).Serialize(msg->BeginNestedMessage<::protozero::Message>(16));
+  // Field 3: stop_rules
+  for (auto& it : stop_rules_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(3));
   }
 
-  // Field 17: compositor_timing_history
-  if (_has_field_[17]) {
-    (*compositor_timing_history_).Serialize(msg->BeginNestedMessage<::protozero::Message>(17));
+  // Field 4: upload_rules
+  for (auto& it : upload_rules_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(4));
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -30834,77 +26606,84 @@ void ChromeCompositorSchedulerState::Serialize(::protozero::Message* msg) const
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_content_settings_event_info.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_content_settings_event_info.gen.h
+// gen_amalgamated begin source: gen/protos/perfetto/config/chrome/system_metrics.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_CONTENT_SETTINGS_EVENT_INFO_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_CONTENT_SETTINGS_EVENT_INFO_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/system_metrics.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
-class ChromeContentSettingsEventInfo;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+ChromiumSystemMetricsConfig::ChromiumSystemMetricsConfig() = default;
+ChromiumSystemMetricsConfig::~ChromiumSystemMetricsConfig() = default;
+ChromiumSystemMetricsConfig::ChromiumSystemMetricsConfig(const ChromiumSystemMetricsConfig&) = default;
+ChromiumSystemMetricsConfig& ChromiumSystemMetricsConfig::operator=(const ChromiumSystemMetricsConfig&) = default;
+ChromiumSystemMetricsConfig::ChromiumSystemMetricsConfig(ChromiumSystemMetricsConfig&&) noexcept = default;
+ChromiumSystemMetricsConfig& ChromiumSystemMetricsConfig::operator=(ChromiumSystemMetricsConfig&&) = default;
 
-class PERFETTO_EXPORT_COMPONENT ChromeContentSettingsEventInfo : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kNumberOfExceptionsFieldNumber = 1,
-  };
+bool ChromiumSystemMetricsConfig::operator==(const ChromiumSystemMetricsConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(sampling_interval_ms_, other.sampling_interval_ms_);
+}
 
-  ChromeContentSettingsEventInfo();
-  ~ChromeContentSettingsEventInfo() override;
-  ChromeContentSettingsEventInfo(ChromeContentSettingsEventInfo&&) noexcept;
-  ChromeContentSettingsEventInfo& operator=(ChromeContentSettingsEventInfo&&);
-  ChromeContentSettingsEventInfo(const ChromeContentSettingsEventInfo&);
-  ChromeContentSettingsEventInfo& operator=(const ChromeContentSettingsEventInfo&);
-  bool operator==(const ChromeContentSettingsEventInfo&) const;
-  bool operator!=(const ChromeContentSettingsEventInfo& other) const { return !(*this == other); }
+bool ChromiumSystemMetricsConfig::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* sampling_interval_ms */:
+        field.get(&sampling_interval_ms_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-  bool has_number_of_exceptions() const { return _has_field_[1]; }
-  uint32_t number_of_exceptions() const { return number_of_exceptions_; }
-  void set_number_of_exceptions(uint32_t value) { number_of_exceptions_ = value; _has_field_.set(1); }
+std::string ChromiumSystemMetricsConfig::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
- private:
-  uint32_t number_of_exceptions_{};
+std::vector<uint8_t> ChromiumSystemMetricsConfig::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+void ChromiumSystemMetricsConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: sampling_interval_ms
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, sampling_interval_ms_, msg);
+  }
 
-  std::bitset<2> _has_field_{};
-};
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_CONTENT_SETTINGS_EVENT_INFO_PROTO_CPP_H_
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/chrome/v8_config.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -30915,25 +26694,26 @@ class PERFETTO_EXPORT_COMPONENT ChromeContentSettingsEventInfo : public ::protoz
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_content_settings_event_info.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/v8_config.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-ChromeContentSettingsEventInfo::ChromeContentSettingsEventInfo() = default;
-ChromeContentSettingsEventInfo::~ChromeContentSettingsEventInfo() = default;
-ChromeContentSettingsEventInfo::ChromeContentSettingsEventInfo(const ChromeContentSettingsEventInfo&) = default;
-ChromeContentSettingsEventInfo& ChromeContentSettingsEventInfo::operator=(const ChromeContentSettingsEventInfo&) = default;
-ChromeContentSettingsEventInfo::ChromeContentSettingsEventInfo(ChromeContentSettingsEventInfo&&) noexcept = default;
-ChromeContentSettingsEventInfo& ChromeContentSettingsEventInfo::operator=(ChromeContentSettingsEventInfo&&) = default;
+V8Config::V8Config() = default;
+V8Config::~V8Config() = default;
+V8Config::V8Config(const V8Config&) = default;
+V8Config& V8Config::operator=(const V8Config&) = default;
+V8Config::V8Config(V8Config&&) noexcept = default;
+V8Config& V8Config::operator=(V8Config&&) = default;
 
-bool ChromeContentSettingsEventInfo::operator==(const ChromeContentSettingsEventInfo& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && number_of_exceptions_ == other.number_of_exceptions_;
+bool V8Config::operator==(const V8Config& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(log_script_sources_, other.log_script_sources_)
+   && ::protozero::internal::gen_helpers::EqualsField(log_instructions_, other.log_instructions_);
 }
 
-bool ChromeContentSettingsEventInfo::ParseFromArray(const void* raw, size_t size) {
+bool V8Config::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -30943,8 +26723,11 @@ bool ChromeContentSettingsEventInfo::ParseFromArray(const void* raw, size_t size
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* number_of_exceptions */:
-        field.get(&number_of_exceptions_);
+      case 1 /* log_script_sources */:
+        field.get(&log_script_sources_);
+        break;
+      case 2 /* log_instructions */:
+        field.get(&log_instructions_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -30954,22 +26737,27 @@ bool ChromeContentSettingsEventInfo::ParseFromArray(const void* raw, size_t size
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ChromeContentSettingsEventInfo::SerializeAsString() const {
+std::string V8Config::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ChromeContentSettingsEventInfo::SerializeAsArray() const {
+std::vector<uint8_t> V8Config::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ChromeContentSettingsEventInfo::Serialize(::protozero::Message* msg) const {
-  // Field 1: number_of_exceptions
+void V8Config::Serialize(::protozero::Message* msg) const {
+  // Field 1: log_script_sources
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, number_of_exceptions_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(1, log_script_sources_, msg);
+  }
+
+  // Field 2: log_instructions
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, log_instructions_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -30981,210 +26769,7 @@ void ChromeContentSettingsEventInfo::Serialize(::protozero::Message* msg) const
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_frame_reporter.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_frame_reporter.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_FRAME_REPORTER_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_FRAME_REPORTER_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeFrameReporter;
-enum ChromeFrameReporter_State : int;
-enum ChromeFrameReporter_FrameDropReason : int;
-enum ChromeFrameReporter_ScrollState : int;
-enum ChromeFrameReporter_FrameType : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum ChromeFrameReporter_State : int {
-  ChromeFrameReporter_State_STATE_NO_UPDATE_DESIRED = 0,
-  ChromeFrameReporter_State_STATE_PRESENTED_ALL = 1,
-  ChromeFrameReporter_State_STATE_PRESENTED_PARTIAL = 2,
-  ChromeFrameReporter_State_STATE_DROPPED = 3,
-};
-enum ChromeFrameReporter_FrameDropReason : int {
-  ChromeFrameReporter_FrameDropReason_REASON_UNSPECIFIED = 0,
-  ChromeFrameReporter_FrameDropReason_REASON_DISPLAY_COMPOSITOR = 1,
-  ChromeFrameReporter_FrameDropReason_REASON_MAIN_THREAD = 2,
-  ChromeFrameReporter_FrameDropReason_REASON_CLIENT_COMPOSITOR = 3,
-};
-enum ChromeFrameReporter_ScrollState : int {
-  ChromeFrameReporter_ScrollState_SCROLL_NONE = 0,
-  ChromeFrameReporter_ScrollState_SCROLL_MAIN_THREAD = 1,
-  ChromeFrameReporter_ScrollState_SCROLL_COMPOSITOR_THREAD = 2,
-  ChromeFrameReporter_ScrollState_SCROLL_UNKNOWN = 3,
-};
-enum ChromeFrameReporter_FrameType : int {
-  ChromeFrameReporter_FrameType_FORKED = 0,
-  ChromeFrameReporter_FrameType_BACKFILL = 1,
-};
-
-class PERFETTO_EXPORT_COMPONENT ChromeFrameReporter : public ::protozero::CppMessageObj {
- public:
-  using State = ChromeFrameReporter_State;
-  static constexpr auto STATE_NO_UPDATE_DESIRED = ChromeFrameReporter_State_STATE_NO_UPDATE_DESIRED;
-  static constexpr auto STATE_PRESENTED_ALL = ChromeFrameReporter_State_STATE_PRESENTED_ALL;
-  static constexpr auto STATE_PRESENTED_PARTIAL = ChromeFrameReporter_State_STATE_PRESENTED_PARTIAL;
-  static constexpr auto STATE_DROPPED = ChromeFrameReporter_State_STATE_DROPPED;
-  static constexpr auto State_MIN = ChromeFrameReporter_State_STATE_NO_UPDATE_DESIRED;
-  static constexpr auto State_MAX = ChromeFrameReporter_State_STATE_DROPPED;
-  using FrameDropReason = ChromeFrameReporter_FrameDropReason;
-  static constexpr auto REASON_UNSPECIFIED = ChromeFrameReporter_FrameDropReason_REASON_UNSPECIFIED;
-  static constexpr auto REASON_DISPLAY_COMPOSITOR = ChromeFrameReporter_FrameDropReason_REASON_DISPLAY_COMPOSITOR;
-  static constexpr auto REASON_MAIN_THREAD = ChromeFrameReporter_FrameDropReason_REASON_MAIN_THREAD;
-  static constexpr auto REASON_CLIENT_COMPOSITOR = ChromeFrameReporter_FrameDropReason_REASON_CLIENT_COMPOSITOR;
-  static constexpr auto FrameDropReason_MIN = ChromeFrameReporter_FrameDropReason_REASON_UNSPECIFIED;
-  static constexpr auto FrameDropReason_MAX = ChromeFrameReporter_FrameDropReason_REASON_CLIENT_COMPOSITOR;
-  using ScrollState = ChromeFrameReporter_ScrollState;
-  static constexpr auto SCROLL_NONE = ChromeFrameReporter_ScrollState_SCROLL_NONE;
-  static constexpr auto SCROLL_MAIN_THREAD = ChromeFrameReporter_ScrollState_SCROLL_MAIN_THREAD;
-  static constexpr auto SCROLL_COMPOSITOR_THREAD = ChromeFrameReporter_ScrollState_SCROLL_COMPOSITOR_THREAD;
-  static constexpr auto SCROLL_UNKNOWN = ChromeFrameReporter_ScrollState_SCROLL_UNKNOWN;
-  static constexpr auto ScrollState_MIN = ChromeFrameReporter_ScrollState_SCROLL_NONE;
-  static constexpr auto ScrollState_MAX = ChromeFrameReporter_ScrollState_SCROLL_UNKNOWN;
-  using FrameType = ChromeFrameReporter_FrameType;
-  static constexpr auto FORKED = ChromeFrameReporter_FrameType_FORKED;
-  static constexpr auto BACKFILL = ChromeFrameReporter_FrameType_BACKFILL;
-  static constexpr auto FrameType_MIN = ChromeFrameReporter_FrameType_FORKED;
-  static constexpr auto FrameType_MAX = ChromeFrameReporter_FrameType_BACKFILL;
-  enum FieldNumbers {
-    kStateFieldNumber = 1,
-    kReasonFieldNumber = 2,
-    kFrameSourceFieldNumber = 3,
-    kFrameSequenceFieldNumber = 4,
-    kAffectsSmoothnessFieldNumber = 5,
-    kScrollStateFieldNumber = 6,
-    kHasMainAnimationFieldNumber = 7,
-    kHasCompositorAnimationFieldNumber = 8,
-    kHasSmoothInputMainFieldNumber = 9,
-    kHasMissingContentFieldNumber = 10,
-    kLayerTreeHostIdFieldNumber = 11,
-    kHasHighLatencyFieldNumber = 12,
-    kFrameTypeFieldNumber = 13,
-    kHighLatencyContributionStageFieldNumber = 14,
-  };
-
-  ChromeFrameReporter();
-  ~ChromeFrameReporter() override;
-  ChromeFrameReporter(ChromeFrameReporter&&) noexcept;
-  ChromeFrameReporter& operator=(ChromeFrameReporter&&);
-  ChromeFrameReporter(const ChromeFrameReporter&);
-  ChromeFrameReporter& operator=(const ChromeFrameReporter&);
-  bool operator==(const ChromeFrameReporter&) const;
-  bool operator!=(const ChromeFrameReporter& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_state() const { return _has_field_[1]; }
-  ChromeFrameReporter_State state() const { return state_; }
-  void set_state(ChromeFrameReporter_State value) { state_ = value; _has_field_.set(1); }
-
-  bool has_reason() const { return _has_field_[2]; }
-  ChromeFrameReporter_FrameDropReason reason() const { return reason_; }
-  void set_reason(ChromeFrameReporter_FrameDropReason value) { reason_ = value; _has_field_.set(2); }
-
-  bool has_frame_source() const { return _has_field_[3]; }
-  uint64_t frame_source() const { return frame_source_; }
-  void set_frame_source(uint64_t value) { frame_source_ = value; _has_field_.set(3); }
-
-  bool has_frame_sequence() const { return _has_field_[4]; }
-  uint64_t frame_sequence() const { return frame_sequence_; }
-  void set_frame_sequence(uint64_t value) { frame_sequence_ = value; _has_field_.set(4); }
-
-  bool has_affects_smoothness() const { return _has_field_[5]; }
-  bool affects_smoothness() const { return affects_smoothness_; }
-  void set_affects_smoothness(bool value) { affects_smoothness_ = value; _has_field_.set(5); }
-
-  bool has_scroll_state() const { return _has_field_[6]; }
-  ChromeFrameReporter_ScrollState scroll_state() const { return scroll_state_; }
-  void set_scroll_state(ChromeFrameReporter_ScrollState value) { scroll_state_ = value; _has_field_.set(6); }
-
-  bool has_has_main_animation() const { return _has_field_[7]; }
-  bool has_main_animation() const { return has_main_animation_; }
-  void set_has_main_animation(bool value) { has_main_animation_ = value; _has_field_.set(7); }
-
-  bool has_has_compositor_animation() const { return _has_field_[8]; }
-  bool has_compositor_animation() const { return has_compositor_animation_; }
-  void set_has_compositor_animation(bool value) { has_compositor_animation_ = value; _has_field_.set(8); }
-
-  bool has_has_smooth_input_main() const { return _has_field_[9]; }
-  bool has_smooth_input_main() const { return has_smooth_input_main_; }
-  void set_has_smooth_input_main(bool value) { has_smooth_input_main_ = value; _has_field_.set(9); }
-
-  bool has_has_missing_content() const { return _has_field_[10]; }
-  bool has_missing_content() const { return has_missing_content_; }
-  void set_has_missing_content(bool value) { has_missing_content_ = value; _has_field_.set(10); }
-
-  bool has_layer_tree_host_id() const { return _has_field_[11]; }
-  uint64_t layer_tree_host_id() const { return layer_tree_host_id_; }
-  void set_layer_tree_host_id(uint64_t value) { layer_tree_host_id_ = value; _has_field_.set(11); }
-
-  bool has_has_high_latency() const { return _has_field_[12]; }
-  bool has_high_latency() const { return has_high_latency_; }
-  void set_has_high_latency(bool value) { has_high_latency_ = value; _has_field_.set(12); }
-
-  bool has_frame_type() const { return _has_field_[13]; }
-  ChromeFrameReporter_FrameType frame_type() const { return frame_type_; }
-  void set_frame_type(ChromeFrameReporter_FrameType value) { frame_type_ = value; _has_field_.set(13); }
-
-  const std::vector<std::string>& high_latency_contribution_stage() const { return high_latency_contribution_stage_; }
-  std::vector<std::string>* mutable_high_latency_contribution_stage() { return &high_latency_contribution_stage_; }
-  int high_latency_contribution_stage_size() const { return static_cast<int>(high_latency_contribution_stage_.size()); }
-  void clear_high_latency_contribution_stage() { high_latency_contribution_stage_.clear(); }
-  void add_high_latency_contribution_stage(std::string value) { high_latency_contribution_stage_.emplace_back(value); }
-  std::string* add_high_latency_contribution_stage() { high_latency_contribution_stage_.emplace_back(); return &high_latency_contribution_stage_.back(); }
-
- private:
-  ChromeFrameReporter_State state_{};
-  ChromeFrameReporter_FrameDropReason reason_{};
-  uint64_t frame_source_{};
-  uint64_t frame_sequence_{};
-  bool affects_smoothness_{};
-  ChromeFrameReporter_ScrollState scroll_state_{};
-  bool has_main_animation_{};
-  bool has_compositor_animation_{};
-  bool has_smooth_input_main_{};
-  bool has_missing_content_{};
-  uint64_t layer_tree_host_id_{};
-  bool has_high_latency_{};
-  ChromeFrameReporter_FrameType frame_type_{};
-  std::vector<std::string> high_latency_contribution_stage_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<15> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_FRAME_REPORTER_PROTO_CPP_H_
+// gen_amalgamated begin source: gen/protos/perfetto/config/data_source_config.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -31195,39 +26780,85 @@ class PERFETTO_EXPORT_COMPONENT ChromeFrameReporter : public ::protozero::CppMes
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_frame_reporter.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/data_source_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/system_info/system_info_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/test_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/priority_boost/priority_boost_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/protovm/protovm_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/interceptor_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/interceptors/console_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/chrome_config.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-ChromeFrameReporter::ChromeFrameReporter() = default;
-ChromeFrameReporter::~ChromeFrameReporter() = default;
-ChromeFrameReporter::ChromeFrameReporter(const ChromeFrameReporter&) = default;
-ChromeFrameReporter& ChromeFrameReporter::operator=(const ChromeFrameReporter&) = default;
-ChromeFrameReporter::ChromeFrameReporter(ChromeFrameReporter&&) noexcept = default;
-ChromeFrameReporter& ChromeFrameReporter::operator=(ChromeFrameReporter&&) = default;
+DataSourceConfig::DataSourceConfig() = default;
+DataSourceConfig::~DataSourceConfig() = default;
+DataSourceConfig::DataSourceConfig(const DataSourceConfig&) = default;
+DataSourceConfig& DataSourceConfig::operator=(const DataSourceConfig&) = default;
+DataSourceConfig::DataSourceConfig(DataSourceConfig&&) noexcept = default;
+DataSourceConfig& DataSourceConfig::operator=(DataSourceConfig&&) = default;
 
-bool ChromeFrameReporter::operator==(const ChromeFrameReporter& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && state_ == other.state_
-   && reason_ == other.reason_
-   && frame_source_ == other.frame_source_
-   && frame_sequence_ == other.frame_sequence_
-   && affects_smoothness_ == other.affects_smoothness_
-   && scroll_state_ == other.scroll_state_
-   && has_main_animation_ == other.has_main_animation_
-   && has_compositor_animation_ == other.has_compositor_animation_
-   && has_smooth_input_main_ == other.has_smooth_input_main_
-   && has_missing_content_ == other.has_missing_content_
-   && layer_tree_host_id_ == other.layer_tree_host_id_
-   && has_high_latency_ == other.has_high_latency_
-   && frame_type_ == other.frame_type_
-   && high_latency_contribution_stage_ == other.high_latency_contribution_stage_;
+bool DataSourceConfig::operator==(const DataSourceConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(target_buffer_, other.target_buffer_)
+   && ::protozero::internal::gen_helpers::EqualsField(target_buffer_name_, other.target_buffer_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(trace_duration_ms_, other.trace_duration_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(prefer_suspend_clock_for_duration_, other.prefer_suspend_clock_for_duration_)
+   && ::protozero::internal::gen_helpers::EqualsField(stop_timeout_ms_, other.stop_timeout_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(enable_extra_guardrails_, other.enable_extra_guardrails_)
+   && ::protozero::internal::gen_helpers::EqualsField(session_initiator_, other.session_initiator_)
+   && ::protozero::internal::gen_helpers::EqualsField(tracing_session_id_, other.tracing_session_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(buffer_exhausted_policy_, other.buffer_exhausted_policy_)
+   && ::protozero::internal::gen_helpers::EqualsField(priority_boost_, other.priority_boost_)
+   && ::protozero::internal::gen_helpers::EqualsField(protovm_config_, other.protovm_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(ftrace_config_, other.ftrace_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(inode_file_config_, other.inode_file_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(process_stats_config_, other.process_stats_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(sys_stats_config_, other.sys_stats_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(heapprofd_config_, other.heapprofd_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(java_hprof_config_, other.java_hprof_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(android_power_config_, other.android_power_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(android_log_config_, other.android_log_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(gpu_counter_config_, other.gpu_counter_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(android_game_intervention_list_config_, other.android_game_intervention_list_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(packages_list_config_, other.packages_list_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(perf_event_config_, other.perf_event_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(vulkan_memory_config_, other.vulkan_memory_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(track_event_config_, other.track_event_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(android_polled_state_config_, other.android_polled_state_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(android_system_property_config_, other.android_system_property_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(statsd_tracing_config_, other.statsd_tracing_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(system_info_config_, other.system_info_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(frozen_ftrace_config_, other.frozen_ftrace_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(chrome_config_, other.chrome_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(v8_config_, other.v8_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(interceptor_config_, other.interceptor_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(network_packet_trace_config_, other.network_packet_trace_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(surfaceflinger_layers_config_, other.surfaceflinger_layers_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(surfaceflinger_transactions_config_, other.surfaceflinger_transactions_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(android_sdk_sysprop_guard_config_, other.android_sdk_sysprop_guard_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(etw_config_, other.etw_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(protolog_config_, other.protolog_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(android_input_event_config_, other.android_input_event_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(pixel_modem_config_, other.pixel_modem_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(windowmanager_config_, other.windowmanager_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(chromium_system_metrics_, other.chromium_system_metrics_)
+   && ::protozero::internal::gen_helpers::EqualsField(kernel_wakelocks_config_, other.kernel_wakelocks_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(gpu_renderstages_config_, other.gpu_renderstages_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(chromium_histogram_samples_, other.chromium_histogram_samples_)
+   && ::protozero::internal::gen_helpers::EqualsField(app_wakelocks_config_, other.app_wakelocks_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(cpu_per_uid_config_, other.cpu_per_uid_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(user_list_config_, other.user_list_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(inputmethod_config_, other.inputmethod_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(qnx_config_, other.qnx_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(legacy_config_, other.legacy_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(for_testing_, other.for_testing_);
 }
 
-bool ChromeFrameReporter::ParseFromArray(const void* raw, size_t size) {
-  high_latency_contribution_stage_.clear();
+bool DataSourceConfig::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -31237,48 +26868,167 @@ bool ChromeFrameReporter::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* state */:
-        field.get(&state_);
+      case 1 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
         break;
-      case 2 /* reason */:
-        field.get(&reason_);
+      case 2 /* target_buffer */:
+        field.get(&target_buffer_);
         break;
-      case 3 /* frame_source */:
-        field.get(&frame_source_);
+      case 11 /* target_buffer_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &target_buffer_name_);
         break;
-      case 4 /* frame_sequence */:
-        field.get(&frame_sequence_);
+      case 3 /* trace_duration_ms */:
+        field.get(&trace_duration_ms_);
         break;
-      case 5 /* affects_smoothness */:
-        field.get(&affects_smoothness_);
+      case 122 /* prefer_suspend_clock_for_duration */:
+        field.get(&prefer_suspend_clock_for_duration_);
         break;
-      case 6 /* scroll_state */:
-        field.get(&scroll_state_);
+      case 7 /* stop_timeout_ms */:
+        field.get(&stop_timeout_ms_);
         break;
-      case 7 /* has_main_animation */:
-        field.get(&has_main_animation_);
+      case 6 /* enable_extra_guardrails */:
+        field.get(&enable_extra_guardrails_);
         break;
-      case 8 /* has_compositor_animation */:
-        field.get(&has_compositor_animation_);
+      case 8 /* session_initiator */:
+        field.get(&session_initiator_);
         break;
-      case 9 /* has_smooth_input_main */:
-        field.get(&has_smooth_input_main_);
+      case 4 /* tracing_session_id */:
+        field.get(&tracing_session_id_);
         break;
-      case 10 /* has_missing_content */:
-        field.get(&has_missing_content_);
+      case 9 /* buffer_exhausted_policy */:
+        field.get(&buffer_exhausted_policy_);
         break;
-      case 11 /* layer_tree_host_id */:
-        field.get(&layer_tree_host_id_);
+      case 10 /* priority_boost */:
+        (*priority_boost_).ParseFromArray(field.data(), field.size());
         break;
-      case 12 /* has_high_latency */:
-        field.get(&has_high_latency_);
+      case 12 /* protovm_config */:
+        (*protovm_config_).ParseFromArray(field.data(), field.size());
         break;
-      case 13 /* frame_type */:
-        field.get(&frame_type_);
+      case 100 /* ftrace_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &ftrace_config_);
         break;
-      case 14 /* high_latency_contribution_stage */:
-        high_latency_contribution_stage_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &high_latency_contribution_stage_.back());
+      case 102 /* inode_file_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &inode_file_config_);
+        break;
+      case 103 /* process_stats_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &process_stats_config_);
+        break;
+      case 104 /* sys_stats_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &sys_stats_config_);
+        break;
+      case 105 /* heapprofd_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &heapprofd_config_);
+        break;
+      case 110 /* java_hprof_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &java_hprof_config_);
+        break;
+      case 106 /* android_power_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &android_power_config_);
+        break;
+      case 107 /* android_log_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &android_log_config_);
+        break;
+      case 108 /* gpu_counter_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &gpu_counter_config_);
+        break;
+      case 116 /* android_game_intervention_list_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &android_game_intervention_list_config_);
+        break;
+      case 109 /* packages_list_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &packages_list_config_);
+        break;
+      case 111 /* perf_event_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &perf_event_config_);
+        break;
+      case 112 /* vulkan_memory_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &vulkan_memory_config_);
+        break;
+      case 113 /* track_event_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &track_event_config_);
+        break;
+      case 114 /* android_polled_state_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &android_polled_state_config_);
+        break;
+      case 118 /* android_system_property_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &android_system_property_config_);
+        break;
+      case 117 /* statsd_tracing_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &statsd_tracing_config_);
+        break;
+      case 119 /* system_info_config */:
+        (*system_info_config_).ParseFromArray(field.data(), field.size());
+        break;
+      case 136 /* frozen_ftrace_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &frozen_ftrace_config_);
+        break;
+      case 101 /* chrome_config */:
+        (*chrome_config_).ParseFromArray(field.data(), field.size());
+        break;
+      case 127 /* v8_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &v8_config_);
+        break;
+      case 115 /* interceptor_config */:
+        (*interceptor_config_).ParseFromArray(field.data(), field.size());
+        break;
+      case 120 /* network_packet_trace_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &network_packet_trace_config_);
+        break;
+      case 121 /* surfaceflinger_layers_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &surfaceflinger_layers_config_);
+        break;
+      case 123 /* surfaceflinger_transactions_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &surfaceflinger_transactions_config_);
+        break;
+      case 124 /* android_sdk_sysprop_guard_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &android_sdk_sysprop_guard_config_);
+        break;
+      case 125 /* etw_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &etw_config_);
+        break;
+      case 126 /* protolog_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &protolog_config_);
+        break;
+      case 128 /* android_input_event_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &android_input_event_config_);
+        break;
+      case 129 /* pixel_modem_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &pixel_modem_config_);
+        break;
+      case 130 /* windowmanager_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &windowmanager_config_);
+        break;
+      case 131 /* chromium_system_metrics */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &chromium_system_metrics_);
+        break;
+      case 132 /* kernel_wakelocks_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &kernel_wakelocks_config_);
+        break;
+      case 133 /* gpu_renderstages_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &gpu_renderstages_config_);
+        break;
+      case 134 /* chromium_histogram_samples */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &chromium_histogram_samples_);
+        break;
+      case 135 /* app_wakelocks_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &app_wakelocks_config_);
+        break;
+      case 137 /* cpu_per_uid_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &cpu_per_uid_config_);
+        break;
+      case 138 /* user_list_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &user_list_config_);
+        break;
+      case 139 /* inputmethod_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &inputmethod_config_);
+        break;
+      case 150 /* qnx_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &qnx_config_);
+        break;
+      case 1000 /* legacy_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &legacy_config_);
+        break;
+      case 1001 /* for_testing */:
+        (*for_testing_).ParseFromArray(field.data(), field.size());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -31288,229 +27038,299 @@ bool ChromeFrameReporter::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ChromeFrameReporter::SerializeAsString() const {
+std::string DataSourceConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ChromeFrameReporter::SerializeAsArray() const {
+std::vector<uint8_t> DataSourceConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ChromeFrameReporter::Serialize(::protozero::Message* msg) const {
-  // Field 1: state
+void DataSourceConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: name
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, state_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
   }
 
-  // Field 2: reason
+  // Field 2: target_buffer
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, reason_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, target_buffer_, msg);
   }
 
-  // Field 3: frame_source
+  // Field 11: target_buffer_name
+  if (_has_field_[11]) {
+    ::protozero::internal::gen_helpers::SerializeString(11, target_buffer_name_, msg);
+  }
+
+  // Field 3: trace_duration_ms
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, frame_source_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, trace_duration_ms_, msg);
   }
 
-  // Field 4: frame_sequence
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, frame_sequence_, msg);
+  // Field 122: prefer_suspend_clock_for_duration
+  if (_has_field_[122]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(122, prefer_suspend_clock_for_duration_, msg);
   }
 
-  // Field 5: affects_smoothness
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, affects_smoothness_, msg);
+  // Field 7: stop_timeout_ms
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(7, stop_timeout_ms_, msg);
   }
 
-  // Field 6: scroll_state
+  // Field 6: enable_extra_guardrails
   if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(6, scroll_state_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(6, enable_extra_guardrails_, msg);
   }
 
-  // Field 7: has_main_animation
-  if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(7, has_main_animation_, msg);
+  // Field 8: session_initiator
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(8, session_initiator_, msg);
   }
 
-  // Field 8: has_compositor_animation
-  if (_has_field_[8]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(8, has_compositor_animation_, msg);
+  // Field 4: tracing_session_id
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, tracing_session_id_, msg);
   }
 
-  // Field 9: has_smooth_input_main
+  // Field 9: buffer_exhausted_policy
   if (_has_field_[9]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(9, has_smooth_input_main_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(9, buffer_exhausted_policy_, msg);
   }
 
-  // Field 10: has_missing_content
+  // Field 10: priority_boost
   if (_has_field_[10]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(10, has_missing_content_, msg);
+    (*priority_boost_).Serialize(msg->BeginNestedMessage<::protozero::Message>(10));
   }
 
-  // Field 11: layer_tree_host_id
-  if (_has_field_[11]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(11, layer_tree_host_id_, msg);
+  // Field 12: protovm_config
+  if (_has_field_[12]) {
+    (*protovm_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(12));
   }
 
-  // Field 12: has_high_latency
-  if (_has_field_[12]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(12, has_high_latency_, msg);
+  // Field 100: ftrace_config
+  if (_has_field_[100]) {
+    msg->AppendString(100, ftrace_config_);
   }
 
-  // Field 13: frame_type
-  if (_has_field_[13]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(13, frame_type_, msg);
+  // Field 102: inode_file_config
+  if (_has_field_[102]) {
+    msg->AppendString(102, inode_file_config_);
   }
 
-  // Field 14: high_latency_contribution_stage
-  for (auto& it : high_latency_contribution_stage_) {
-    ::protozero::internal::gen_helpers::SerializeString(14, it, msg);
+  // Field 103: process_stats_config
+  if (_has_field_[103]) {
+    msg->AppendString(103, process_stats_config_);
   }
 
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
-}
+  // Field 104: sys_stats_config
+  if (_has_field_[104]) {
+    msg->AppendString(104, sys_stats_config_);
+  }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_histogram_sample.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_histogram_sample.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_HISTOGRAM_SAMPLE_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_HISTOGRAM_SAMPLE_PROTO_CPP_H_
+  // Field 105: heapprofd_config
+  if (_has_field_[105]) {
+    msg->AppendString(105, heapprofd_config_);
+  }
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  // Field 110: java_hprof_config
+  if (_has_field_[110]) {
+    msg->AppendString(110, java_hprof_config_);
+  }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  // Field 106: android_power_config
+  if (_has_field_[106]) {
+    msg->AppendString(106, android_power_config_);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeHistogramSample;
-class HistogramName;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  // Field 107: android_log_config
+  if (_has_field_[107]) {
+    msg->AppendString(107, android_log_config_);
+  }
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  // Field 108: gpu_counter_config
+  if (_has_field_[108]) {
+    msg->AppendString(108, gpu_counter_config_);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+  // Field 116: android_game_intervention_list_config
+  if (_has_field_[116]) {
+    msg->AppendString(116, android_game_intervention_list_config_);
+  }
 
-class PERFETTO_EXPORT_COMPONENT ChromeHistogramSample : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kNameHashFieldNumber = 1,
-    kNameFieldNumber = 2,
-    kSampleFieldNumber = 3,
-    kNameIidFieldNumber = 4,
-  };
+  // Field 109: packages_list_config
+  if (_has_field_[109]) {
+    msg->AppendString(109, packages_list_config_);
+  }
+
+  // Field 111: perf_event_config
+  if (_has_field_[111]) {
+    msg->AppendString(111, perf_event_config_);
+  }
+
+  // Field 112: vulkan_memory_config
+  if (_has_field_[112]) {
+    msg->AppendString(112, vulkan_memory_config_);
+  }
 
-  ChromeHistogramSample();
-  ~ChromeHistogramSample() override;
-  ChromeHistogramSample(ChromeHistogramSample&&) noexcept;
-  ChromeHistogramSample& operator=(ChromeHistogramSample&&);
-  ChromeHistogramSample(const ChromeHistogramSample&);
-  ChromeHistogramSample& operator=(const ChromeHistogramSample&);
-  bool operator==(const ChromeHistogramSample&) const;
-  bool operator!=(const ChromeHistogramSample& other) const { return !(*this == other); }
+  // Field 113: track_event_config
+  if (_has_field_[113]) {
+    msg->AppendString(113, track_event_config_);
+  }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  // Field 114: android_polled_state_config
+  if (_has_field_[114]) {
+    msg->AppendString(114, android_polled_state_config_);
+  }
 
-  bool has_name_hash() const { return _has_field_[1]; }
-  uint64_t name_hash() const { return name_hash_; }
-  void set_name_hash(uint64_t value) { name_hash_ = value; _has_field_.set(1); }
+  // Field 118: android_system_property_config
+  if (_has_field_[118]) {
+    msg->AppendString(118, android_system_property_config_);
+  }
 
-  bool has_name() const { return _has_field_[2]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
+  // Field 117: statsd_tracing_config
+  if (_has_field_[117]) {
+    msg->AppendString(117, statsd_tracing_config_);
+  }
 
-  bool has_sample() const { return _has_field_[3]; }
-  int64_t sample() const { return sample_; }
-  void set_sample(int64_t value) { sample_ = value; _has_field_.set(3); }
+  // Field 119: system_info_config
+  if (_has_field_[119]) {
+    (*system_info_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(119));
+  }
 
-  bool has_name_iid() const { return _has_field_[4]; }
-  uint64_t name_iid() const { return name_iid_; }
-  void set_name_iid(uint64_t value) { name_iid_ = value; _has_field_.set(4); }
+  // Field 136: frozen_ftrace_config
+  if (_has_field_[136]) {
+    msg->AppendString(136, frozen_ftrace_config_);
+  }
 
- private:
-  uint64_t name_hash_{};
-  std::string name_{};
-  int64_t sample_{};
-  uint64_t name_iid_{};
+  // Field 101: chrome_config
+  if (_has_field_[101]) {
+    (*chrome_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(101));
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  // Field 127: v8_config
+  if (_has_field_[127]) {
+    msg->AppendString(127, v8_config_);
+  }
 
-  std::bitset<5> _has_field_{};
-};
+  // Field 115: interceptor_config
+  if (_has_field_[115]) {
+    (*interceptor_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(115));
+  }
 
+  // Field 120: network_packet_trace_config
+  if (_has_field_[120]) {
+    msg->AppendString(120, network_packet_trace_config_);
+  }
 
-class PERFETTO_EXPORT_COMPONENT HistogramName : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kIidFieldNumber = 1,
-    kNameFieldNumber = 2,
-  };
+  // Field 121: surfaceflinger_layers_config
+  if (_has_field_[121]) {
+    msg->AppendString(121, surfaceflinger_layers_config_);
+  }
 
-  HistogramName();
-  ~HistogramName() override;
-  HistogramName(HistogramName&&) noexcept;
-  HistogramName& operator=(HistogramName&&);
-  HistogramName(const HistogramName&);
-  HistogramName& operator=(const HistogramName&);
-  bool operator==(const HistogramName&) const;
-  bool operator!=(const HistogramName& other) const { return !(*this == other); }
+  // Field 123: surfaceflinger_transactions_config
+  if (_has_field_[123]) {
+    msg->AppendString(123, surfaceflinger_transactions_config_);
+  }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  // Field 124: android_sdk_sysprop_guard_config
+  if (_has_field_[124]) {
+    msg->AppendString(124, android_sdk_sysprop_guard_config_);
+  }
 
-  bool has_iid() const { return _has_field_[1]; }
-  uint64_t iid() const { return iid_; }
-  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
+  // Field 125: etw_config
+  if (_has_field_[125]) {
+    msg->AppendString(125, etw_config_);
+  }
 
-  bool has_name() const { return _has_field_[2]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
+  // Field 126: protolog_config
+  if (_has_field_[126]) {
+    msg->AppendString(126, protolog_config_);
+  }
 
- private:
-  uint64_t iid_{};
-  std::string name_{};
+  // Field 128: android_input_event_config
+  if (_has_field_[128]) {
+    msg->AppendString(128, android_input_event_config_);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  // Field 129: pixel_modem_config
+  if (_has_field_[129]) {
+    msg->AppendString(129, pixel_modem_config_);
+  }
 
-  std::bitset<3> _has_field_{};
-};
+  // Field 130: windowmanager_config
+  if (_has_field_[130]) {
+    msg->AppendString(130, windowmanager_config_);
+  }
+
+  // Field 131: chromium_system_metrics
+  if (_has_field_[131]) {
+    msg->AppendString(131, chromium_system_metrics_);
+  }
+
+  // Field 132: kernel_wakelocks_config
+  if (_has_field_[132]) {
+    msg->AppendString(132, kernel_wakelocks_config_);
+  }
+
+  // Field 133: gpu_renderstages_config
+  if (_has_field_[133]) {
+    msg->AppendString(133, gpu_renderstages_config_);
+  }
+
+  // Field 134: chromium_histogram_samples
+  if (_has_field_[134]) {
+    msg->AppendString(134, chromium_histogram_samples_);
+  }
+
+  // Field 135: app_wakelocks_config
+  if (_has_field_[135]) {
+    msg->AppendString(135, app_wakelocks_config_);
+  }
+
+  // Field 137: cpu_per_uid_config
+  if (_has_field_[137]) {
+    msg->AppendString(137, cpu_per_uid_config_);
+  }
+
+  // Field 138: user_list_config
+  if (_has_field_[138]) {
+    msg->AppendString(138, user_list_config_);
+  }
+
+  // Field 139: inputmethod_config
+  if (_has_field_[139]) {
+    msg->AppendString(139, inputmethod_config_);
+  }
+
+  // Field 150: qnx_config
+  if (_has_field_[150]) {
+    msg->AppendString(150, qnx_config_);
+  }
+
+  // Field 1000: legacy_config
+  if (_has_field_[1000]) {
+    ::protozero::internal::gen_helpers::SerializeString(1000, legacy_config_, msg);
+  }
+
+  // Field 1001: for_testing
+  if (_has_field_[1001]) {
+    (*for_testing_).Serialize(msg->BeginNestedMessage<::protozero::Message>(1001));
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_HISTOGRAM_SAMPLE_PROTO_CPP_H_
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/etw/etw_config.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -31521,28 +27341,32 @@ class PERFETTO_EXPORT_COMPONENT HistogramName : public ::protozero::CppMessageOb
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_histogram_sample.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/etw/etw_config.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-ChromeHistogramSample::ChromeHistogramSample() = default;
-ChromeHistogramSample::~ChromeHistogramSample() = default;
-ChromeHistogramSample::ChromeHistogramSample(const ChromeHistogramSample&) = default;
-ChromeHistogramSample& ChromeHistogramSample::operator=(const ChromeHistogramSample&) = default;
-ChromeHistogramSample::ChromeHistogramSample(ChromeHistogramSample&&) noexcept = default;
-ChromeHistogramSample& ChromeHistogramSample::operator=(ChromeHistogramSample&&) = default;
-
-bool ChromeHistogramSample::operator==(const ChromeHistogramSample& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && name_hash_ == other.name_hash_
-   && name_ == other.name_
-   && sample_ == other.sample_
-   && name_iid_ == other.name_iid_;
-}
-
-bool ChromeHistogramSample::ParseFromArray(const void* raw, size_t size) {
+EtwConfig::EtwConfig() = default;
+EtwConfig::~EtwConfig() = default;
+EtwConfig::EtwConfig(const EtwConfig&) = default;
+EtwConfig& EtwConfig::operator=(const EtwConfig&) = default;
+EtwConfig::EtwConfig(EtwConfig&&) noexcept = default;
+EtwConfig& EtwConfig::operator=(EtwConfig&&) = default;
+
+bool EtwConfig::operator==(const EtwConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(kernel_flags_, other.kernel_flags_)
+   && ::protozero::internal::gen_helpers::EqualsField(scheduler_provider_events_, other.scheduler_provider_events_)
+   && ::protozero::internal::gen_helpers::EqualsField(memory_provider_events_, other.memory_provider_events_)
+   && ::protozero::internal::gen_helpers::EqualsField(file_provider_events_, other.file_provider_events_);
+}
+
+bool EtwConfig::ParseFromArray(const void* raw, size_t size) {
+  kernel_flags_.clear();
+  scheduler_provider_events_.clear();
+  memory_provider_events_.clear();
+  file_provider_events_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -31552,17 +27376,21 @@ bool ChromeHistogramSample::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* name_hash */:
-        field.get(&name_hash_);
+      case 1 /* kernel_flags */:
+        kernel_flags_.emplace_back();
+        field.get(&kernel_flags_.back());
         break;
-      case 2 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+      case 2 /* scheduler_provider_events */:
+        scheduler_provider_events_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &scheduler_provider_events_.back());
         break;
-      case 3 /* sample */:
-        field.get(&sample_);
+      case 3 /* memory_provider_events */:
+        memory_provider_events_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &memory_provider_events_.back());
         break;
-      case 4 /* name_iid */:
-        field.get(&name_iid_);
+      case 4 /* file_provider_events */:
+        file_provider_events_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &file_provider_events_.back());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -31572,101 +27400,37 @@ bool ChromeHistogramSample::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ChromeHistogramSample::SerializeAsString() const {
+std::string EtwConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ChromeHistogramSample::SerializeAsArray() const {
+std::vector<uint8_t> EtwConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ChromeHistogramSample::Serialize(::protozero::Message* msg) const {
-  // Field 1: name_hash
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, name_hash_, msg);
-  }
-
-  // Field 2: name
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeString(2, name_, msg);
-  }
-
-  // Field 3: sample
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, sample_, msg);
-  }
-
-  // Field 4: name_iid
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, name_iid_, msg);
+void EtwConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: kernel_flags
+  for (auto& it : kernel_flags_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, it, msg);
   }
 
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
-}
-
-
-HistogramName::HistogramName() = default;
-HistogramName::~HistogramName() = default;
-HistogramName::HistogramName(const HistogramName&) = default;
-HistogramName& HistogramName::operator=(const HistogramName&) = default;
-HistogramName::HistogramName(HistogramName&&) noexcept = default;
-HistogramName& HistogramName::operator=(HistogramName&&) = default;
-
-bool HistogramName::operator==(const HistogramName& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && iid_ == other.iid_
-   && name_ == other.name_;
-}
-
-bool HistogramName::ParseFromArray(const void* raw, size_t size) {
-  unknown_fields_.clear();
-  bool packed_error = false;
-
-  ::protozero::ProtoDecoder dec(raw, size);
-  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
-    if (field.id() < _has_field_.size()) {
-      _has_field_.set(field.id());
-    }
-    switch (field.id()) {
-      case 1 /* iid */:
-        field.get(&iid_);
-        break;
-      case 2 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
-        break;
-      default:
-        field.SerializeAndAppendTo(&unknown_fields_);
-        break;
-    }
+  // Field 2: scheduler_provider_events
+  for (auto& it : scheduler_provider_events_) {
+    ::protozero::internal::gen_helpers::SerializeString(2, it, msg);
   }
-  return !packed_error && !dec.bytes_left();
-}
-
-std::string HistogramName::SerializeAsString() const {
-  ::protozero::internal::gen_helpers::MessageSerializer msg;
-  Serialize(msg.get());
-  return msg.SerializeAsString();
-}
-
-std::vector<uint8_t> HistogramName::SerializeAsArray() const {
-  ::protozero::internal::gen_helpers::MessageSerializer msg;
-  Serialize(msg.get());
-  return msg.SerializeAsArray();
-}
 
-void HistogramName::Serialize(::protozero::Message* msg) const {
-  // Field 1: iid
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, iid_, msg);
+  // Field 3: memory_provider_events
+  for (auto& it : memory_provider_events_) {
+    ::protozero::internal::gen_helpers::SerializeString(3, it, msg);
   }
 
-  // Field 2: name
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeString(2, name_, msg);
+  // Field 4: file_provider_events
+  for (auto& it : file_provider_events_) {
+    ::protozero::internal::gen_helpers::SerializeString(4, it, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -31678,77 +27442,7 @@ void HistogramName::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_keyed_service.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_keyed_service.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_KEYED_SERVICE_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_KEYED_SERVICE_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeKeyedService;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT ChromeKeyedService : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kNameFieldNumber = 1,
-  };
-
-  ChromeKeyedService();
-  ~ChromeKeyedService() override;
-  ChromeKeyedService(ChromeKeyedService&&) noexcept;
-  ChromeKeyedService& operator=(ChromeKeyedService&&);
-  ChromeKeyedService(const ChromeKeyedService&);
-  ChromeKeyedService& operator=(const ChromeKeyedService&);
-  bool operator==(const ChromeKeyedService&) const;
-  bool operator!=(const ChromeKeyedService& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_name() const { return _has_field_[1]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
-
- private:
-  std::string name_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_KEYED_SERVICE_PROTO_CPP_H_
+// gen_amalgamated begin source: gen/protos/perfetto/config/interceptor_config.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -31759,25 +27453,27 @@ class PERFETTO_EXPORT_COMPONENT ChromeKeyedService : public ::protozero::CppMess
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_keyed_service.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/interceptor_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/interceptors/console_config.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-ChromeKeyedService::ChromeKeyedService() = default;
-ChromeKeyedService::~ChromeKeyedService() = default;
-ChromeKeyedService::ChromeKeyedService(const ChromeKeyedService&) = default;
-ChromeKeyedService& ChromeKeyedService::operator=(const ChromeKeyedService&) = default;
-ChromeKeyedService::ChromeKeyedService(ChromeKeyedService&&) noexcept = default;
-ChromeKeyedService& ChromeKeyedService::operator=(ChromeKeyedService&&) = default;
+InterceptorConfig::InterceptorConfig() = default;
+InterceptorConfig::~InterceptorConfig() = default;
+InterceptorConfig::InterceptorConfig(const InterceptorConfig&) = default;
+InterceptorConfig& InterceptorConfig::operator=(const InterceptorConfig&) = default;
+InterceptorConfig::InterceptorConfig(InterceptorConfig&&) noexcept = default;
+InterceptorConfig& InterceptorConfig::operator=(InterceptorConfig&&) = default;
 
-bool ChromeKeyedService::operator==(const ChromeKeyedService& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && name_ == other.name_;
+bool InterceptorConfig::operator==(const InterceptorConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(console_config_, other.console_config_);
 }
 
-bool ChromeKeyedService::ParseFromArray(const void* raw, size_t size) {
+bool InterceptorConfig::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -31790,6 +27486,9 @@ bool ChromeKeyedService::ParseFromArray(const void* raw, size_t size) {
       case 1 /* name */:
         ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
         break;
+      case 100 /* console_config */:
+        (*console_config_).ParseFromArray(field.data(), field.size());
+        break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
         break;
@@ -31798,24 +27497,29 @@ bool ChromeKeyedService::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ChromeKeyedService::SerializeAsString() const {
+std::string InterceptorConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ChromeKeyedService::SerializeAsArray() const {
+std::vector<uint8_t> InterceptorConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ChromeKeyedService::Serialize(::protozero::Message* msg) const {
+void InterceptorConfig::Serialize(::protozero::Message* msg) const {
   // Field 1: name
   if (_has_field_[1]) {
     ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
   }
 
+  // Field 100: console_config
+  if (_has_field_[100]) {
+    (*console_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(100));
+  }
+
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
@@ -31825,224 +27529,7 @@ void ChromeKeyedService::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_latency_info.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_latency_info.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LATENCY_INFO_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LATENCY_INFO_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeLatencyInfo;
-class ChromeLatencyInfo_ComponentInfo;
-enum ChromeLatencyInfo_Step : int;
-enum ChromeLatencyInfo_LatencyComponentType : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum ChromeLatencyInfo_Step : int {
-  ChromeLatencyInfo_Step_STEP_UNSPECIFIED = 0,
-  ChromeLatencyInfo_Step_STEP_SEND_INPUT_EVENT_UI = 3,
-  ChromeLatencyInfo_Step_STEP_HANDLE_INPUT_EVENT_IMPL = 5,
-  ChromeLatencyInfo_Step_STEP_DID_HANDLE_INPUT_AND_OVERSCROLL = 8,
-  ChromeLatencyInfo_Step_STEP_HANDLE_INPUT_EVENT_MAIN = 4,
-  ChromeLatencyInfo_Step_STEP_MAIN_THREAD_SCROLL_UPDATE = 2,
-  ChromeLatencyInfo_Step_STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT = 1,
-  ChromeLatencyInfo_Step_STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL = 9,
-  ChromeLatencyInfo_Step_STEP_HANDLED_INPUT_EVENT_IMPL = 10,
-  ChromeLatencyInfo_Step_STEP_SWAP_BUFFERS = 6,
-  ChromeLatencyInfo_Step_STEP_DRAW_AND_SWAP = 7,
-  ChromeLatencyInfo_Step_STEP_FINISHED_SWAP_BUFFERS = 11,
-};
-enum ChromeLatencyInfo_LatencyComponentType : int {
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_UNSPECIFIED = 0,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH = 1,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL = 2,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL = 3,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL = 4,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_UI = 5,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN = 6,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN = 7,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL = 8,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT = 9,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH = 10,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP = 11,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME = 12,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER = 13,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP = 14,
-};
-
-class PERFETTO_EXPORT_COMPONENT ChromeLatencyInfo : public ::protozero::CppMessageObj {
- public:
-  using ComponentInfo = ChromeLatencyInfo_ComponentInfo;
-  using Step = ChromeLatencyInfo_Step;
-  static constexpr auto STEP_UNSPECIFIED = ChromeLatencyInfo_Step_STEP_UNSPECIFIED;
-  static constexpr auto STEP_SEND_INPUT_EVENT_UI = ChromeLatencyInfo_Step_STEP_SEND_INPUT_EVENT_UI;
-  static constexpr auto STEP_HANDLE_INPUT_EVENT_IMPL = ChromeLatencyInfo_Step_STEP_HANDLE_INPUT_EVENT_IMPL;
-  static constexpr auto STEP_DID_HANDLE_INPUT_AND_OVERSCROLL = ChromeLatencyInfo_Step_STEP_DID_HANDLE_INPUT_AND_OVERSCROLL;
-  static constexpr auto STEP_HANDLE_INPUT_EVENT_MAIN = ChromeLatencyInfo_Step_STEP_HANDLE_INPUT_EVENT_MAIN;
-  static constexpr auto STEP_MAIN_THREAD_SCROLL_UPDATE = ChromeLatencyInfo_Step_STEP_MAIN_THREAD_SCROLL_UPDATE;
-  static constexpr auto STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT = ChromeLatencyInfo_Step_STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT;
-  static constexpr auto STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL = ChromeLatencyInfo_Step_STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL;
-  static constexpr auto STEP_HANDLED_INPUT_EVENT_IMPL = ChromeLatencyInfo_Step_STEP_HANDLED_INPUT_EVENT_IMPL;
-  static constexpr auto STEP_SWAP_BUFFERS = ChromeLatencyInfo_Step_STEP_SWAP_BUFFERS;
-  static constexpr auto STEP_DRAW_AND_SWAP = ChromeLatencyInfo_Step_STEP_DRAW_AND_SWAP;
-  static constexpr auto STEP_FINISHED_SWAP_BUFFERS = ChromeLatencyInfo_Step_STEP_FINISHED_SWAP_BUFFERS;
-  static constexpr auto Step_MIN = ChromeLatencyInfo_Step_STEP_UNSPECIFIED;
-  static constexpr auto Step_MAX = ChromeLatencyInfo_Step_STEP_FINISHED_SWAP_BUFFERS;
-  using LatencyComponentType = ChromeLatencyInfo_LatencyComponentType;
-  static constexpr auto COMPONENT_UNSPECIFIED = ChromeLatencyInfo_LatencyComponentType_COMPONENT_UNSPECIFIED;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_UI = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_UI;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP;
-  static constexpr auto COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME = ChromeLatencyInfo_LatencyComponentType_COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME;
-  static constexpr auto COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP;
-  static constexpr auto LatencyComponentType_MIN = ChromeLatencyInfo_LatencyComponentType_COMPONENT_UNSPECIFIED;
-  static constexpr auto LatencyComponentType_MAX = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP;
-  enum FieldNumbers {
-    kTraceIdFieldNumber = 1,
-    kStepFieldNumber = 2,
-    kFrameTreeNodeIdFieldNumber = 3,
-    kComponentInfoFieldNumber = 4,
-    kIsCoalescedFieldNumber = 5,
-    kGestureScrollIdFieldNumber = 6,
-    kTouchIdFieldNumber = 7,
-  };
-
-  ChromeLatencyInfo();
-  ~ChromeLatencyInfo() override;
-  ChromeLatencyInfo(ChromeLatencyInfo&&) noexcept;
-  ChromeLatencyInfo& operator=(ChromeLatencyInfo&&);
-  ChromeLatencyInfo(const ChromeLatencyInfo&);
-  ChromeLatencyInfo& operator=(const ChromeLatencyInfo&);
-  bool operator==(const ChromeLatencyInfo&) const;
-  bool operator!=(const ChromeLatencyInfo& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_trace_id() const { return _has_field_[1]; }
-  int64_t trace_id() const { return trace_id_; }
-  void set_trace_id(int64_t value) { trace_id_ = value; _has_field_.set(1); }
-
-  bool has_step() const { return _has_field_[2]; }
-  ChromeLatencyInfo_Step step() const { return step_; }
-  void set_step(ChromeLatencyInfo_Step value) { step_ = value; _has_field_.set(2); }
-
-  bool has_frame_tree_node_id() const { return _has_field_[3]; }
-  int32_t frame_tree_node_id() const { return frame_tree_node_id_; }
-  void set_frame_tree_node_id(int32_t value) { frame_tree_node_id_ = value; _has_field_.set(3); }
-
-  const std::vector<ChromeLatencyInfo_ComponentInfo>& component_info() const { return component_info_; }
-  std::vector<ChromeLatencyInfo_ComponentInfo>* mutable_component_info() { return &component_info_; }
-  int component_info_size() const;
-  void clear_component_info();
-  ChromeLatencyInfo_ComponentInfo* add_component_info();
-
-  bool has_is_coalesced() const { return _has_field_[5]; }
-  bool is_coalesced() const { return is_coalesced_; }
-  void set_is_coalesced(bool value) { is_coalesced_ = value; _has_field_.set(5); }
-
-  bool has_gesture_scroll_id() const { return _has_field_[6]; }
-  int64_t gesture_scroll_id() const { return gesture_scroll_id_; }
-  void set_gesture_scroll_id(int64_t value) { gesture_scroll_id_ = value; _has_field_.set(6); }
-
-  bool has_touch_id() const { return _has_field_[7]; }
-  int64_t touch_id() const { return touch_id_; }
-  void set_touch_id(int64_t value) { touch_id_ = value; _has_field_.set(7); }
-
- private:
-  int64_t trace_id_{};
-  ChromeLatencyInfo_Step step_{};
-  int32_t frame_tree_node_id_{};
-  std::vector<ChromeLatencyInfo_ComponentInfo> component_info_;
-  bool is_coalesced_{};
-  int64_t gesture_scroll_id_{};
-  int64_t touch_id_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<8> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT ChromeLatencyInfo_ComponentInfo : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kComponentTypeFieldNumber = 1,
-    kTimeUsFieldNumber = 2,
-  };
-
-  ChromeLatencyInfo_ComponentInfo();
-  ~ChromeLatencyInfo_ComponentInfo() override;
-  ChromeLatencyInfo_ComponentInfo(ChromeLatencyInfo_ComponentInfo&&) noexcept;
-  ChromeLatencyInfo_ComponentInfo& operator=(ChromeLatencyInfo_ComponentInfo&&);
-  ChromeLatencyInfo_ComponentInfo(const ChromeLatencyInfo_ComponentInfo&);
-  ChromeLatencyInfo_ComponentInfo& operator=(const ChromeLatencyInfo_ComponentInfo&);
-  bool operator==(const ChromeLatencyInfo_ComponentInfo&) const;
-  bool operator!=(const ChromeLatencyInfo_ComponentInfo& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_component_type() const { return _has_field_[1]; }
-  ChromeLatencyInfo_LatencyComponentType component_type() const { return component_type_; }
-  void set_component_type(ChromeLatencyInfo_LatencyComponentType value) { component_type_ = value; _has_field_.set(1); }
-
-  bool has_time_us() const { return _has_field_[2]; }
-  uint64_t time_us() const { return time_us_; }
-  void set_time_us(uint64_t value) { time_us_ = value; _has_field_.set(2); }
-
- private:
-  ChromeLatencyInfo_LatencyComponentType component_type_{};
-  uint64_t time_us_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LATENCY_INFO_PROTO_CPP_H_
+// gen_amalgamated begin source: gen/protos/perfetto/config/stress_test_config.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -32053,35 +27540,88 @@ class PERFETTO_EXPORT_COMPONENT ChromeLatencyInfo_ComponentInfo : public ::proto
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_latency_info.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/stress_test_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/trace_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/priority_boost/priority_boost_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/data_source_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/qnx/qnx_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/histogram_samples.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/system_info/system_info_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/track_event/track_event_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/test_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/sys_stats/sys_stats_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/sys_stats_counters.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/perf_event_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/perf_events.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/java_hprof_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/heapprofd_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/process_stats/process_stats_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/statsd/statsd_tracing_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/statsd/atom_ids.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/protovm/protovm_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/power/android_power_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/interceptor_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/interceptors/console_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/inode_file/inode_file_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/gpu/gpu_renderstages_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/gpu/vulkan_memory_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/gpu/gpu_counter_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/ftrace/frozen_ftrace_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/ftrace/ftrace_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/system_metrics.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/etw/etw_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/v8_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/chrome_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/windowmanager_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/user_list_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/surfaceflinger_transactions_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/surfaceflinger_layers_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/protolog_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/protolog_common.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/pixel_modem_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/packages_list_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/network_trace_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/kernel_wakelocks_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/inputmethod_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/cpu_per_uid_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/app_wakelock_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_sdk_sysprop_guard_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_system_property_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_polled_state_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_log_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/android_log_constants.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_input_event_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_game_intervention_list_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/semantic_type.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/builtin_clock.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-ChromeLatencyInfo::ChromeLatencyInfo() = default;
-ChromeLatencyInfo::~ChromeLatencyInfo() = default;
-ChromeLatencyInfo::ChromeLatencyInfo(const ChromeLatencyInfo&) = default;
-ChromeLatencyInfo& ChromeLatencyInfo::operator=(const ChromeLatencyInfo&) = default;
-ChromeLatencyInfo::ChromeLatencyInfo(ChromeLatencyInfo&&) noexcept = default;
-ChromeLatencyInfo& ChromeLatencyInfo::operator=(ChromeLatencyInfo&&) = default;
+StressTestConfig::StressTestConfig() = default;
+StressTestConfig::~StressTestConfig() = default;
+StressTestConfig::StressTestConfig(const StressTestConfig&) = default;
+StressTestConfig& StressTestConfig::operator=(const StressTestConfig&) = default;
+StressTestConfig::StressTestConfig(StressTestConfig&&) noexcept = default;
+StressTestConfig& StressTestConfig::operator=(StressTestConfig&&) = default;
 
-bool ChromeLatencyInfo::operator==(const ChromeLatencyInfo& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && trace_id_ == other.trace_id_
-   && step_ == other.step_
-   && frame_tree_node_id_ == other.frame_tree_node_id_
-   && component_info_ == other.component_info_
-   && is_coalesced_ == other.is_coalesced_
-   && gesture_scroll_id_ == other.gesture_scroll_id_
-   && touch_id_ == other.touch_id_;
+bool StressTestConfig::operator==(const StressTestConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(trace_config_, other.trace_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(shmem_size_kb_, other.shmem_size_kb_)
+   && ::protozero::internal::gen_helpers::EqualsField(shmem_page_size_kb_, other.shmem_page_size_kb_)
+   && ::protozero::internal::gen_helpers::EqualsField(num_processes_, other.num_processes_)
+   && ::protozero::internal::gen_helpers::EqualsField(num_threads_, other.num_threads_)
+   && ::protozero::internal::gen_helpers::EqualsField(max_events_, other.max_events_)
+   && ::protozero::internal::gen_helpers::EqualsField(nesting_, other.nesting_)
+   && ::protozero::internal::gen_helpers::EqualsField(steady_state_timings_, other.steady_state_timings_)
+   && ::protozero::internal::gen_helpers::EqualsField(burst_period_ms_, other.burst_period_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(burst_duration_ms_, other.burst_duration_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(burst_timings_, other.burst_timings_);
 }
 
-int ChromeLatencyInfo::component_info_size() const { return static_cast<int>(component_info_.size()); }
-void ChromeLatencyInfo::clear_component_info() { component_info_.clear(); }
-ChromeLatencyInfo_ComponentInfo* ChromeLatencyInfo::add_component_info() { component_info_.emplace_back(); return &component_info_.back(); }
-bool ChromeLatencyInfo::ParseFromArray(const void* raw, size_t size) {
-  component_info_.clear();
+bool StressTestConfig::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -32091,27 +27631,38 @@ bool ChromeLatencyInfo::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* trace_id */:
-        field.get(&trace_id_);
+      case 1 /* trace_config */:
+        (*trace_config_).ParseFromArray(field.data(), field.size());
         break;
-      case 2 /* step */:
-        field.get(&step_);
+      case 2 /* shmem_size_kb */:
+        field.get(&shmem_size_kb_);
         break;
-      case 3 /* frame_tree_node_id */:
-        field.get(&frame_tree_node_id_);
+      case 3 /* shmem_page_size_kb */:
+        field.get(&shmem_page_size_kb_);
         break;
-      case 4 /* component_info */:
-        component_info_.emplace_back();
-        component_info_.back().ParseFromArray(field.data(), field.size());
+      case 4 /* num_processes */:
+        field.get(&num_processes_);
         break;
-      case 5 /* is_coalesced */:
-        field.get(&is_coalesced_);
+      case 5 /* num_threads */:
+        field.get(&num_threads_);
         break;
-      case 6 /* gesture_scroll_id */:
-        field.get(&gesture_scroll_id_);
+      case 6 /* max_events */:
+        field.get(&max_events_);
         break;
-      case 7 /* touch_id */:
-        field.get(&touch_id_);
+      case 7 /* nesting */:
+        field.get(&nesting_);
+        break;
+      case 8 /* steady_state_timings */:
+        (*steady_state_timings_).ParseFromArray(field.data(), field.size());
+        break;
+      case 9 /* burst_period_ms */:
+        field.get(&burst_period_ms_);
+        break;
+      case 10 /* burst_duration_ms */:
+        field.get(&burst_duration_ms_);
+        break;
+      case 11 /* burst_timings */:
+        (*burst_timings_).ParseFromArray(field.data(), field.size());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -32121,72 +27672,95 @@ bool ChromeLatencyInfo::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ChromeLatencyInfo::SerializeAsString() const {
+std::string StressTestConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ChromeLatencyInfo::SerializeAsArray() const {
+std::vector<uint8_t> StressTestConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ChromeLatencyInfo::Serialize(::protozero::Message* msg) const {
-  // Field 1: trace_id
+void StressTestConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: trace_config
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, trace_id_, msg);
+    (*trace_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
   }
 
-  // Field 2: step
+  // Field 2: shmem_size_kb
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, step_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, shmem_size_kb_, msg);
   }
 
-  // Field 3: frame_tree_node_id
+  // Field 3: shmem_page_size_kb
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, frame_tree_node_id_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, shmem_page_size_kb_, msg);
   }
 
-  // Field 4: component_info
-  for (auto& it : component_info_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(4));
-  }
+  // Field 4: num_processes
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, num_processes_, msg);
+  }
 
-  // Field 5: is_coalesced
+  // Field 5: num_threads
   if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, is_coalesced_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, num_threads_, msg);
   }
 
-  // Field 6: gesture_scroll_id
+  // Field 6: max_events
   if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(6, gesture_scroll_id_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, max_events_, msg);
   }
 
-  // Field 7: touch_id
+  // Field 7: nesting
   if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(7, touch_id_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(7, nesting_, msg);
+  }
+
+  // Field 8: steady_state_timings
+  if (_has_field_[8]) {
+    (*steady_state_timings_).Serialize(msg->BeginNestedMessage<::protozero::Message>(8));
+  }
+
+  // Field 9: burst_period_ms
+  if (_has_field_[9]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(9, burst_period_ms_, msg);
+  }
+
+  // Field 10: burst_duration_ms
+  if (_has_field_[10]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(10, burst_duration_ms_, msg);
+  }
+
+  // Field 11: burst_timings
+  if (_has_field_[11]) {
+    (*burst_timings_).Serialize(msg->BeginNestedMessage<::protozero::Message>(11));
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-ChromeLatencyInfo_ComponentInfo::ChromeLatencyInfo_ComponentInfo() = default;
-ChromeLatencyInfo_ComponentInfo::~ChromeLatencyInfo_ComponentInfo() = default;
-ChromeLatencyInfo_ComponentInfo::ChromeLatencyInfo_ComponentInfo(const ChromeLatencyInfo_ComponentInfo&) = default;
-ChromeLatencyInfo_ComponentInfo& ChromeLatencyInfo_ComponentInfo::operator=(const ChromeLatencyInfo_ComponentInfo&) = default;
-ChromeLatencyInfo_ComponentInfo::ChromeLatencyInfo_ComponentInfo(ChromeLatencyInfo_ComponentInfo&&) noexcept = default;
-ChromeLatencyInfo_ComponentInfo& ChromeLatencyInfo_ComponentInfo::operator=(ChromeLatencyInfo_ComponentInfo&&) = default;
+StressTestConfig_WriterTiming::StressTestConfig_WriterTiming() = default;
+StressTestConfig_WriterTiming::~StressTestConfig_WriterTiming() = default;
+StressTestConfig_WriterTiming::StressTestConfig_WriterTiming(const StressTestConfig_WriterTiming&) = default;
+StressTestConfig_WriterTiming& StressTestConfig_WriterTiming::operator=(const StressTestConfig_WriterTiming&) = default;
+StressTestConfig_WriterTiming::StressTestConfig_WriterTiming(StressTestConfig_WriterTiming&&) noexcept = default;
+StressTestConfig_WriterTiming& StressTestConfig_WriterTiming::operator=(StressTestConfig_WriterTiming&&) = default;
 
-bool ChromeLatencyInfo_ComponentInfo::operator==(const ChromeLatencyInfo_ComponentInfo& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && component_type_ == other.component_type_
-   && time_us_ == other.time_us_;
+bool StressTestConfig_WriterTiming::operator==(const StressTestConfig_WriterTiming& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(payload_mean_, other.payload_mean_)
+   && ::protozero::internal::gen_helpers::EqualsField(payload_stddev_, other.payload_stddev_)
+   && ::protozero::internal::gen_helpers::EqualsField(rate_mean_, other.rate_mean_)
+   && ::protozero::internal::gen_helpers::EqualsField(rate_stddev_, other.rate_stddev_)
+   && ::protozero::internal::gen_helpers::EqualsField(payload_write_time_ms_, other.payload_write_time_ms_);
 }
 
-bool ChromeLatencyInfo_ComponentInfo::ParseFromArray(const void* raw, size_t size) {
+bool StressTestConfig_WriterTiming::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -32196,11 +27770,20 @@ bool ChromeLatencyInfo_ComponentInfo::ParseFromArray(const void* raw, size_t siz
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* component_type */:
-        field.get(&component_type_);
+      case 1 /* payload_mean */:
+        field.get(&payload_mean_);
         break;
-      case 2 /* time_us */:
-        field.get(&time_us_);
+      case 2 /* payload_stddev */:
+        field.get(&payload_stddev_);
+        break;
+      case 3 /* rate_mean */:
+        field.get(&rate_mean_);
+        break;
+      case 4 /* rate_stddev */:
+        field.get(&rate_stddev_);
+        break;
+      case 5 /* payload_write_time_ms */:
+        field.get(&payload_write_time_ms_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -32210,27 +27793,42 @@ bool ChromeLatencyInfo_ComponentInfo::ParseFromArray(const void* raw, size_t siz
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ChromeLatencyInfo_ComponentInfo::SerializeAsString() const {
+std::string StressTestConfig_WriterTiming::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ChromeLatencyInfo_ComponentInfo::SerializeAsArray() const {
+std::vector<uint8_t> StressTestConfig_WriterTiming::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ChromeLatencyInfo_ComponentInfo::Serialize(::protozero::Message* msg) const {
-  // Field 1: component_type
+void StressTestConfig_WriterTiming::Serialize(::protozero::Message* msg) const {
+  // Field 1: payload_mean
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, component_type_, msg);
+    ::protozero::internal::gen_helpers::SerializeFixed(1, payload_mean_, msg);
   }
 
-  // Field 2: time_us
+  // Field 2: payload_stddev
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, time_us_, msg);
+    ::protozero::internal::gen_helpers::SerializeFixed(2, payload_stddev_, msg);
+  }
+
+  // Field 3: rate_mean
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeFixed(3, rate_mean_, msg);
+  }
+
+  // Field 4: rate_stddev
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeFixed(4, rate_stddev_, msg);
+  }
+
+  // Field 5: payload_write_time_ms
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, payload_write_time_ms_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -32242,165 +27840,7 @@ void ChromeLatencyInfo_ComponentInfo::Serialize(::protozero::Message* msg) const
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_legacy_ipc.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_legacy_ipc.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LEGACY_IPC_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LEGACY_IPC_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeLegacyIpc;
-enum ChromeLegacyIpc_MessageClass : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum ChromeLegacyIpc_MessageClass : int {
-  ChromeLegacyIpc_MessageClass_CLASS_UNSPECIFIED = 0,
-  ChromeLegacyIpc_MessageClass_CLASS_AUTOMATION = 1,
-  ChromeLegacyIpc_MessageClass_CLASS_FRAME = 2,
-  ChromeLegacyIpc_MessageClass_CLASS_PAGE = 3,
-  ChromeLegacyIpc_MessageClass_CLASS_VIEW = 4,
-  ChromeLegacyIpc_MessageClass_CLASS_WIDGET = 5,
-  ChromeLegacyIpc_MessageClass_CLASS_INPUT = 6,
-  ChromeLegacyIpc_MessageClass_CLASS_TEST = 7,
-  ChromeLegacyIpc_MessageClass_CLASS_WORKER = 8,
-  ChromeLegacyIpc_MessageClass_CLASS_NACL = 9,
-  ChromeLegacyIpc_MessageClass_CLASS_GPU_CHANNEL = 10,
-  ChromeLegacyIpc_MessageClass_CLASS_MEDIA = 11,
-  ChromeLegacyIpc_MessageClass_CLASS_PPAPI = 12,
-  ChromeLegacyIpc_MessageClass_CLASS_CHROME = 13,
-  ChromeLegacyIpc_MessageClass_CLASS_DRAG = 14,
-  ChromeLegacyIpc_MessageClass_CLASS_PRINT = 15,
-  ChromeLegacyIpc_MessageClass_CLASS_EXTENSION = 16,
-  ChromeLegacyIpc_MessageClass_CLASS_TEXT_INPUT_CLIENT = 17,
-  ChromeLegacyIpc_MessageClass_CLASS_BLINK_TEST = 18,
-  ChromeLegacyIpc_MessageClass_CLASS_ACCESSIBILITY = 19,
-  ChromeLegacyIpc_MessageClass_CLASS_PRERENDER = 20,
-  ChromeLegacyIpc_MessageClass_CLASS_CHROMOTING = 21,
-  ChromeLegacyIpc_MessageClass_CLASS_BROWSER_PLUGIN = 22,
-  ChromeLegacyIpc_MessageClass_CLASS_ANDROID_WEB_VIEW = 23,
-  ChromeLegacyIpc_MessageClass_CLASS_NACL_HOST = 24,
-  ChromeLegacyIpc_MessageClass_CLASS_ENCRYPTED_MEDIA = 25,
-  ChromeLegacyIpc_MessageClass_CLASS_CAST = 26,
-  ChromeLegacyIpc_MessageClass_CLASS_GIN_JAVA_BRIDGE = 27,
-  ChromeLegacyIpc_MessageClass_CLASS_CHROME_UTILITY_PRINTING = 28,
-  ChromeLegacyIpc_MessageClass_CLASS_OZONE_GPU = 29,
-  ChromeLegacyIpc_MessageClass_CLASS_WEB_TEST = 30,
-  ChromeLegacyIpc_MessageClass_CLASS_NETWORK_HINTS = 31,
-  ChromeLegacyIpc_MessageClass_CLASS_EXTENSIONS_GUEST_VIEW = 32,
-  ChromeLegacyIpc_MessageClass_CLASS_GUEST_VIEW = 33,
-  ChromeLegacyIpc_MessageClass_CLASS_MEDIA_PLAYER_DELEGATE = 34,
-  ChromeLegacyIpc_MessageClass_CLASS_EXTENSION_WORKER = 35,
-  ChromeLegacyIpc_MessageClass_CLASS_SUBRESOURCE_FILTER = 36,
-  ChromeLegacyIpc_MessageClass_CLASS_UNFREEZABLE_FRAME = 37,
-};
-
-class PERFETTO_EXPORT_COMPONENT ChromeLegacyIpc : public ::protozero::CppMessageObj {
- public:
-  using MessageClass = ChromeLegacyIpc_MessageClass;
-  static constexpr auto CLASS_UNSPECIFIED = ChromeLegacyIpc_MessageClass_CLASS_UNSPECIFIED;
-  static constexpr auto CLASS_AUTOMATION = ChromeLegacyIpc_MessageClass_CLASS_AUTOMATION;
-  static constexpr auto CLASS_FRAME = ChromeLegacyIpc_MessageClass_CLASS_FRAME;
-  static constexpr auto CLASS_PAGE = ChromeLegacyIpc_MessageClass_CLASS_PAGE;
-  static constexpr auto CLASS_VIEW = ChromeLegacyIpc_MessageClass_CLASS_VIEW;
-  static constexpr auto CLASS_WIDGET = ChromeLegacyIpc_MessageClass_CLASS_WIDGET;
-  static constexpr auto CLASS_INPUT = ChromeLegacyIpc_MessageClass_CLASS_INPUT;
-  static constexpr auto CLASS_TEST = ChromeLegacyIpc_MessageClass_CLASS_TEST;
-  static constexpr auto CLASS_WORKER = ChromeLegacyIpc_MessageClass_CLASS_WORKER;
-  static constexpr auto CLASS_NACL = ChromeLegacyIpc_MessageClass_CLASS_NACL;
-  static constexpr auto CLASS_GPU_CHANNEL = ChromeLegacyIpc_MessageClass_CLASS_GPU_CHANNEL;
-  static constexpr auto CLASS_MEDIA = ChromeLegacyIpc_MessageClass_CLASS_MEDIA;
-  static constexpr auto CLASS_PPAPI = ChromeLegacyIpc_MessageClass_CLASS_PPAPI;
-  static constexpr auto CLASS_CHROME = ChromeLegacyIpc_MessageClass_CLASS_CHROME;
-  static constexpr auto CLASS_DRAG = ChromeLegacyIpc_MessageClass_CLASS_DRAG;
-  static constexpr auto CLASS_PRINT = ChromeLegacyIpc_MessageClass_CLASS_PRINT;
-  static constexpr auto CLASS_EXTENSION = ChromeLegacyIpc_MessageClass_CLASS_EXTENSION;
-  static constexpr auto CLASS_TEXT_INPUT_CLIENT = ChromeLegacyIpc_MessageClass_CLASS_TEXT_INPUT_CLIENT;
-  static constexpr auto CLASS_BLINK_TEST = ChromeLegacyIpc_MessageClass_CLASS_BLINK_TEST;
-  static constexpr auto CLASS_ACCESSIBILITY = ChromeLegacyIpc_MessageClass_CLASS_ACCESSIBILITY;
-  static constexpr auto CLASS_PRERENDER = ChromeLegacyIpc_MessageClass_CLASS_PRERENDER;
-  static constexpr auto CLASS_CHROMOTING = ChromeLegacyIpc_MessageClass_CLASS_CHROMOTING;
-  static constexpr auto CLASS_BROWSER_PLUGIN = ChromeLegacyIpc_MessageClass_CLASS_BROWSER_PLUGIN;
-  static constexpr auto CLASS_ANDROID_WEB_VIEW = ChromeLegacyIpc_MessageClass_CLASS_ANDROID_WEB_VIEW;
-  static constexpr auto CLASS_NACL_HOST = ChromeLegacyIpc_MessageClass_CLASS_NACL_HOST;
-  static constexpr auto CLASS_ENCRYPTED_MEDIA = ChromeLegacyIpc_MessageClass_CLASS_ENCRYPTED_MEDIA;
-  static constexpr auto CLASS_CAST = ChromeLegacyIpc_MessageClass_CLASS_CAST;
-  static constexpr auto CLASS_GIN_JAVA_BRIDGE = ChromeLegacyIpc_MessageClass_CLASS_GIN_JAVA_BRIDGE;
-  static constexpr auto CLASS_CHROME_UTILITY_PRINTING = ChromeLegacyIpc_MessageClass_CLASS_CHROME_UTILITY_PRINTING;
-  static constexpr auto CLASS_OZONE_GPU = ChromeLegacyIpc_MessageClass_CLASS_OZONE_GPU;
-  static constexpr auto CLASS_WEB_TEST = ChromeLegacyIpc_MessageClass_CLASS_WEB_TEST;
-  static constexpr auto CLASS_NETWORK_HINTS = ChromeLegacyIpc_MessageClass_CLASS_NETWORK_HINTS;
-  static constexpr auto CLASS_EXTENSIONS_GUEST_VIEW = ChromeLegacyIpc_MessageClass_CLASS_EXTENSIONS_GUEST_VIEW;
-  static constexpr auto CLASS_GUEST_VIEW = ChromeLegacyIpc_MessageClass_CLASS_GUEST_VIEW;
-  static constexpr auto CLASS_MEDIA_PLAYER_DELEGATE = ChromeLegacyIpc_MessageClass_CLASS_MEDIA_PLAYER_DELEGATE;
-  static constexpr auto CLASS_EXTENSION_WORKER = ChromeLegacyIpc_MessageClass_CLASS_EXTENSION_WORKER;
-  static constexpr auto CLASS_SUBRESOURCE_FILTER = ChromeLegacyIpc_MessageClass_CLASS_SUBRESOURCE_FILTER;
-  static constexpr auto CLASS_UNFREEZABLE_FRAME = ChromeLegacyIpc_MessageClass_CLASS_UNFREEZABLE_FRAME;
-  static constexpr auto MessageClass_MIN = ChromeLegacyIpc_MessageClass_CLASS_UNSPECIFIED;
-  static constexpr auto MessageClass_MAX = ChromeLegacyIpc_MessageClass_CLASS_UNFREEZABLE_FRAME;
-  enum FieldNumbers {
-    kMessageClassFieldNumber = 1,
-    kMessageLineFieldNumber = 2,
-  };
-
-  ChromeLegacyIpc();
-  ~ChromeLegacyIpc() override;
-  ChromeLegacyIpc(ChromeLegacyIpc&&) noexcept;
-  ChromeLegacyIpc& operator=(ChromeLegacyIpc&&);
-  ChromeLegacyIpc(const ChromeLegacyIpc&);
-  ChromeLegacyIpc& operator=(const ChromeLegacyIpc&);
-  bool operator==(const ChromeLegacyIpc&) const;
-  bool operator!=(const ChromeLegacyIpc& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_message_class() const { return _has_field_[1]; }
-  ChromeLegacyIpc_MessageClass message_class() const { return message_class_; }
-  void set_message_class(ChromeLegacyIpc_MessageClass value) { message_class_ = value; _has_field_.set(1); }
-
-  bool has_message_line() const { return _has_field_[2]; }
-  uint32_t message_line() const { return message_line_; }
-  void set_message_line(uint32_t value) { message_line_ = value; _has_field_.set(2); }
-
- private:
-  ChromeLegacyIpc_MessageClass message_class_{};
-  uint32_t message_line_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LEGACY_IPC_PROTO_CPP_H_
+// gen_amalgamated begin source: gen/protos/perfetto/config/test_config.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -32411,26 +27851,30 @@ class PERFETTO_EXPORT_COMPONENT ChromeLegacyIpc : public ::protozero::CppMessage
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_legacy_ipc.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/test_config.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-ChromeLegacyIpc::ChromeLegacyIpc() = default;
-ChromeLegacyIpc::~ChromeLegacyIpc() = default;
-ChromeLegacyIpc::ChromeLegacyIpc(const ChromeLegacyIpc&) = default;
-ChromeLegacyIpc& ChromeLegacyIpc::operator=(const ChromeLegacyIpc&) = default;
-ChromeLegacyIpc::ChromeLegacyIpc(ChromeLegacyIpc&&) noexcept = default;
-ChromeLegacyIpc& ChromeLegacyIpc::operator=(ChromeLegacyIpc&&) = default;
+TestConfig::TestConfig() = default;
+TestConfig::~TestConfig() = default;
+TestConfig::TestConfig(const TestConfig&) = default;
+TestConfig& TestConfig::operator=(const TestConfig&) = default;
+TestConfig::TestConfig(TestConfig&&) noexcept = default;
+TestConfig& TestConfig::operator=(TestConfig&&) = default;
 
-bool ChromeLegacyIpc::operator==(const ChromeLegacyIpc& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && message_class_ == other.message_class_
-   && message_line_ == other.message_line_;
+bool TestConfig::operator==(const TestConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(message_count_, other.message_count_)
+   && ::protozero::internal::gen_helpers::EqualsField(max_messages_per_second_, other.max_messages_per_second_)
+   && ::protozero::internal::gen_helpers::EqualsField(seed_, other.seed_)
+   && ::protozero::internal::gen_helpers::EqualsField(message_size_, other.message_size_)
+   && ::protozero::internal::gen_helpers::EqualsField(send_batch_on_register_, other.send_batch_on_register_)
+   && ::protozero::internal::gen_helpers::EqualsField(dummy_fields_, other.dummy_fields_);
 }
 
-bool ChromeLegacyIpc::ParseFromArray(const void* raw, size_t size) {
+bool TestConfig::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -32440,11 +27884,23 @@ bool ChromeLegacyIpc::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* message_class */:
-        field.get(&message_class_);
+      case 1 /* message_count */:
+        field.get(&message_count_);
         break;
-      case 2 /* message_line */:
-        field.get(&message_line_);
+      case 2 /* max_messages_per_second */:
+        field.get(&max_messages_per_second_);
+        break;
+      case 3 /* seed */:
+        field.get(&seed_);
+        break;
+      case 4 /* message_size */:
+        field.get(&message_size_);
+        break;
+      case 5 /* send_batch_on_register */:
+        field.get(&send_batch_on_register_);
+        break;
+      case 6 /* dummy_fields */:
+        (*dummy_fields_).ParseFromArray(field.data(), field.size());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -32454,145 +27910,79 @@ bool ChromeLegacyIpc::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ChromeLegacyIpc::SerializeAsString() const {
+std::string TestConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ChromeLegacyIpc::SerializeAsArray() const {
+std::vector<uint8_t> TestConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ChromeLegacyIpc::Serialize(::protozero::Message* msg) const {
-  // Field 1: message_class
+void TestConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: message_count
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, message_class_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, message_count_, msg);
   }
 
-  // Field 2: message_line
+  // Field 2: max_messages_per_second
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, message_line_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, max_messages_per_second_, msg);
   }
 
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
-}
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_message_pump.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_message_pump.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MESSAGE_PUMP_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MESSAGE_PUMP_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeMessagePump;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT ChromeMessagePump : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kSentMessagesInQueueFieldNumber = 1,
-    kIoHandlerLocationIidFieldNumber = 2,
-  };
-
-  ChromeMessagePump();
-  ~ChromeMessagePump() override;
-  ChromeMessagePump(ChromeMessagePump&&) noexcept;
-  ChromeMessagePump& operator=(ChromeMessagePump&&);
-  ChromeMessagePump(const ChromeMessagePump&);
-  ChromeMessagePump& operator=(const ChromeMessagePump&);
-  bool operator==(const ChromeMessagePump&) const;
-  bool operator!=(const ChromeMessagePump& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_sent_messages_in_queue() const { return _has_field_[1]; }
-  bool sent_messages_in_queue() const { return sent_messages_in_queue_; }
-  void set_sent_messages_in_queue(bool value) { sent_messages_in_queue_ = value; _has_field_.set(1); }
-
-  bool has_io_handler_location_iid() const { return _has_field_[2]; }
-  uint64_t io_handler_location_iid() const { return io_handler_location_iid_; }
-  void set_io_handler_location_iid(uint64_t value) { io_handler_location_iid_ = value; _has_field_.set(2); }
-
- private:
-  bool sent_messages_in_queue_{};
-  uint64_t io_handler_location_iid_{};
+  // Field 3: seed
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, seed_, msg);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  // Field 4: message_size
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, message_size_, msg);
+  }
 
-  std::bitset<3> _has_field_{};
-};
+  // Field 5: send_batch_on_register
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, send_batch_on_register_, msg);
+  }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  // Field 6: dummy_fields
+  if (_has_field_[6]) {
+    (*dummy_fields_).Serialize(msg->BeginNestedMessage<::protozero::Message>(6));
+  }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MESSAGE_PUMP_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_message_pump.gen.h"
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
 
-ChromeMessagePump::ChromeMessagePump() = default;
-ChromeMessagePump::~ChromeMessagePump() = default;
-ChromeMessagePump::ChromeMessagePump(const ChromeMessagePump&) = default;
-ChromeMessagePump& ChromeMessagePump::operator=(const ChromeMessagePump&) = default;
-ChromeMessagePump::ChromeMessagePump(ChromeMessagePump&&) noexcept = default;
-ChromeMessagePump& ChromeMessagePump::operator=(ChromeMessagePump&&) = default;
+TestConfig_DummyFields::TestConfig_DummyFields() = default;
+TestConfig_DummyFields::~TestConfig_DummyFields() = default;
+TestConfig_DummyFields::TestConfig_DummyFields(const TestConfig_DummyFields&) = default;
+TestConfig_DummyFields& TestConfig_DummyFields::operator=(const TestConfig_DummyFields&) = default;
+TestConfig_DummyFields::TestConfig_DummyFields(TestConfig_DummyFields&&) noexcept = default;
+TestConfig_DummyFields& TestConfig_DummyFields::operator=(TestConfig_DummyFields&&) = default;
 
-bool ChromeMessagePump::operator==(const ChromeMessagePump& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && sent_messages_in_queue_ == other.sent_messages_in_queue_
-   && io_handler_location_iid_ == other.io_handler_location_iid_;
+bool TestConfig_DummyFields::operator==(const TestConfig_DummyFields& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(field_uint32_, other.field_uint32_)
+   && ::protozero::internal::gen_helpers::EqualsField(field_int32_, other.field_int32_)
+   && ::protozero::internal::gen_helpers::EqualsField(field_uint64_, other.field_uint64_)
+   && ::protozero::internal::gen_helpers::EqualsField(field_int64_, other.field_int64_)
+   && ::protozero::internal::gen_helpers::EqualsField(field_fixed64_, other.field_fixed64_)
+   && ::protozero::internal::gen_helpers::EqualsField(field_sfixed64_, other.field_sfixed64_)
+   && ::protozero::internal::gen_helpers::EqualsField(field_fixed32_, other.field_fixed32_)
+   && ::protozero::internal::gen_helpers::EqualsField(field_sfixed32_, other.field_sfixed32_)
+   && ::protozero::internal::gen_helpers::EqualsField(field_double_, other.field_double_)
+   && ::protozero::internal::gen_helpers::EqualsField(field_float_, other.field_float_)
+   && ::protozero::internal::gen_helpers::EqualsField(field_sint64_, other.field_sint64_)
+   && ::protozero::internal::gen_helpers::EqualsField(field_sint32_, other.field_sint32_)
+   && ::protozero::internal::gen_helpers::EqualsField(field_string_, other.field_string_)
+   && ::protozero::internal::gen_helpers::EqualsField(field_bytes_, other.field_bytes_);
 }
 
-bool ChromeMessagePump::ParseFromArray(const void* raw, size_t size) {
+bool TestConfig_DummyFields::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -32602,11 +27992,47 @@ bool ChromeMessagePump::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* sent_messages_in_queue */:
-        field.get(&sent_messages_in_queue_);
+      case 1 /* field_uint32 */:
+        field.get(&field_uint32_);
         break;
-      case 2 /* io_handler_location_iid */:
-        field.get(&io_handler_location_iid_);
+      case 2 /* field_int32 */:
+        field.get(&field_int32_);
+        break;
+      case 3 /* field_uint64 */:
+        field.get(&field_uint64_);
+        break;
+      case 4 /* field_int64 */:
+        field.get(&field_int64_);
+        break;
+      case 5 /* field_fixed64 */:
+        field.get(&field_fixed64_);
+        break;
+      case 6 /* field_sfixed64 */:
+        field.get(&field_sfixed64_);
+        break;
+      case 7 /* field_fixed32 */:
+        field.get(&field_fixed32_);
+        break;
+      case 8 /* field_sfixed32 */:
+        field.get(&field_sfixed32_);
+        break;
+      case 9 /* field_double */:
+        field.get(&field_double_);
+        break;
+      case 10 /* field_float */:
+        field.get(&field_float_);
+        break;
+      case 11 /* field_sint64 */:
+        field.get_signed(&field_sint64_);
+        break;
+      case 12 /* field_sint32 */:
+        field.get_signed(&field_sint32_);
+        break;
+      case 13 /* field_string */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &field_string_);
+        break;
+      case 14 /* field_bytes */:
+        field.get(&field_bytes_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -32616,145 +28042,99 @@ bool ChromeMessagePump::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ChromeMessagePump::SerializeAsString() const {
+std::string TestConfig_DummyFields::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ChromeMessagePump::SerializeAsArray() const {
+std::vector<uint8_t> TestConfig_DummyFields::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ChromeMessagePump::Serialize(::protozero::Message* msg) const {
-  // Field 1: sent_messages_in_queue
+void TestConfig_DummyFields::Serialize(::protozero::Message* msg) const {
+  // Field 1: field_uint32
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(1, sent_messages_in_queue_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, field_uint32_, msg);
   }
 
-  // Field 2: io_handler_location_iid
+  // Field 2: field_int32
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, io_handler_location_iid_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, field_int32_, msg);
   }
 
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
-}
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_mojo_event_info.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_mojo_event_info.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MOJO_EVENT_INFO_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MOJO_EVENT_INFO_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeMojoEventInfo;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
+  // Field 3: field_uint64
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, field_uint64_, msg);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+  // Field 4: field_int64
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, field_int64_, msg);
+  }
 
-class PERFETTO_EXPORT_COMPONENT ChromeMojoEventInfo : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kWatcherNotifyInterfaceTagFieldNumber = 1,
-    kIpcHashFieldNumber = 2,
-    kMojoInterfaceTagFieldNumber = 3,
-    kMojoInterfaceMethodIidFieldNumber = 4,
-    kIsReplyFieldNumber = 5,
-    kPayloadSizeFieldNumber = 6,
-    kDataNumBytesFieldNumber = 7,
-  };
+  // Field 5: field_fixed64
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeFixed(5, field_fixed64_, msg);
+  }
 
-  ChromeMojoEventInfo();
-  ~ChromeMojoEventInfo() override;
-  ChromeMojoEventInfo(ChromeMojoEventInfo&&) noexcept;
-  ChromeMojoEventInfo& operator=(ChromeMojoEventInfo&&);
-  ChromeMojoEventInfo(const ChromeMojoEventInfo&);
-  ChromeMojoEventInfo& operator=(const ChromeMojoEventInfo&);
-  bool operator==(const ChromeMojoEventInfo&) const;
-  bool operator!=(const ChromeMojoEventInfo& other) const { return !(*this == other); }
+  // Field 6: field_sfixed64
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeFixed(6, field_sfixed64_, msg);
+  }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  // Field 7: field_fixed32
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeFixed(7, field_fixed32_, msg);
+  }
 
-  bool has_watcher_notify_interface_tag() const { return _has_field_[1]; }
-  const std::string& watcher_notify_interface_tag() const { return watcher_notify_interface_tag_; }
-  void set_watcher_notify_interface_tag(const std::string& value) { watcher_notify_interface_tag_ = value; _has_field_.set(1); }
+  // Field 8: field_sfixed32
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeFixed(8, field_sfixed32_, msg);
+  }
 
-  bool has_ipc_hash() const { return _has_field_[2]; }
-  uint32_t ipc_hash() const { return ipc_hash_; }
-  void set_ipc_hash(uint32_t value) { ipc_hash_ = value; _has_field_.set(2); }
+  // Field 9: field_double
+  if (_has_field_[9]) {
+    ::protozero::internal::gen_helpers::SerializeFixed(9, field_double_, msg);
+  }
 
-  bool has_mojo_interface_tag() const { return _has_field_[3]; }
-  const std::string& mojo_interface_tag() const { return mojo_interface_tag_; }
-  void set_mojo_interface_tag(const std::string& value) { mojo_interface_tag_ = value; _has_field_.set(3); }
+  // Field 10: field_float
+  if (_has_field_[10]) {
+    ::protozero::internal::gen_helpers::SerializeFixed(10, field_float_, msg);
+  }
 
-  bool has_mojo_interface_method_iid() const { return _has_field_[4]; }
-  uint64_t mojo_interface_method_iid() const { return mojo_interface_method_iid_; }
-  void set_mojo_interface_method_iid(uint64_t value) { mojo_interface_method_iid_ = value; _has_field_.set(4); }
+  // Field 11: field_sint64
+  if (_has_field_[11]) {
+    ::protozero::internal::gen_helpers::SerializeSignedVarInt(11, field_sint64_, msg);
+  }
 
-  bool has_is_reply() const { return _has_field_[5]; }
-  bool is_reply() const { return is_reply_; }
-  void set_is_reply(bool value) { is_reply_ = value; _has_field_.set(5); }
+  // Field 12: field_sint32
+  if (_has_field_[12]) {
+    ::protozero::internal::gen_helpers::SerializeSignedVarInt(12, field_sint32_, msg);
+  }
 
-  bool has_payload_size() const { return _has_field_[6]; }
-  uint64_t payload_size() const { return payload_size_; }
-  void set_payload_size(uint64_t value) { payload_size_ = value; _has_field_.set(6); }
+  // Field 13: field_string
+  if (_has_field_[13]) {
+    ::protozero::internal::gen_helpers::SerializeString(13, field_string_, msg);
+  }
 
-  bool has_data_num_bytes() const { return _has_field_[7]; }
-  uint64_t data_num_bytes() const { return data_num_bytes_; }
-  void set_data_num_bytes(uint64_t value) { data_num_bytes_ = value; _has_field_.set(7); }
+  // Field 14: field_bytes
+  if (_has_field_[14]) {
+    ::protozero::internal::gen_helpers::SerializeString(14, field_bytes_, msg);
+  }
 
- private:
-  std::string watcher_notify_interface_tag_{};
-  uint32_t ipc_hash_{};
-  std::string mojo_interface_tag_{};
-  uint64_t mojo_interface_method_iid_{};
-  bool is_reply_{};
-  uint64_t payload_size_{};
-  uint64_t data_num_bytes_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<8> _has_field_{};
-};
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MOJO_EVENT_INFO_PROTO_CPP_H_
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/config/trace_config.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -32765,31 +28145,138 @@ class PERFETTO_EXPORT_COMPONENT ChromeMojoEventInfo : public ::protozero::CppMes
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_mojo_event_info.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/trace_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/priority_boost/priority_boost_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/data_source_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/qnx/qnx_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/histogram_samples.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/system_info/system_info_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/track_event/track_event_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/test_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/sys_stats/sys_stats_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/sys_stats_counters.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/perf_event_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/perf_events.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/java_hprof_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/heapprofd_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/process_stats/process_stats_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/statsd/statsd_tracing_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/statsd/atom_ids.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/protovm/protovm_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/power/android_power_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/interceptor_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/interceptors/console_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/inode_file/inode_file_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/gpu/gpu_renderstages_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/gpu/vulkan_memory_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/gpu/gpu_counter_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/ftrace/frozen_ftrace_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/ftrace/ftrace_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/system_metrics.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/etw/etw_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/v8_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/chrome_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/windowmanager_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/user_list_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/surfaceflinger_transactions_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/surfaceflinger_layers_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/protolog_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/protolog_common.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/pixel_modem_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/packages_list_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/network_trace_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/kernel_wakelocks_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/inputmethod_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/cpu_per_uid_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/app_wakelock_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_sdk_sysprop_guard_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_system_property_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_polled_state_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_log_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/android_log_constants.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_input_event_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_game_intervention_list_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/semantic_type.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/builtin_clock.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-ChromeMojoEventInfo::ChromeMojoEventInfo() = default;
-ChromeMojoEventInfo::~ChromeMojoEventInfo() = default;
-ChromeMojoEventInfo::ChromeMojoEventInfo(const ChromeMojoEventInfo&) = default;
-ChromeMojoEventInfo& ChromeMojoEventInfo::operator=(const ChromeMojoEventInfo&) = default;
-ChromeMojoEventInfo::ChromeMojoEventInfo(ChromeMojoEventInfo&&) noexcept = default;
-ChromeMojoEventInfo& ChromeMojoEventInfo::operator=(ChromeMojoEventInfo&&) = default;
+TraceConfig::TraceConfig() = default;
+TraceConfig::~TraceConfig() = default;
+TraceConfig::TraceConfig(const TraceConfig&) = default;
+TraceConfig& TraceConfig::operator=(const TraceConfig&) = default;
+TraceConfig::TraceConfig(TraceConfig&&) noexcept = default;
+TraceConfig& TraceConfig::operator=(TraceConfig&&) = default;
 
-bool ChromeMojoEventInfo::operator==(const ChromeMojoEventInfo& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && watcher_notify_interface_tag_ == other.watcher_notify_interface_tag_
-   && ipc_hash_ == other.ipc_hash_
-   && mojo_interface_tag_ == other.mojo_interface_tag_
-   && mojo_interface_method_iid_ == other.mojo_interface_method_iid_
-   && is_reply_ == other.is_reply_
-   && payload_size_ == other.payload_size_
-   && data_num_bytes_ == other.data_num_bytes_;
+bool TraceConfig::operator==(const TraceConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(buffers_, other.buffers_)
+   && ::protozero::internal::gen_helpers::EqualsField(data_sources_, other.data_sources_)
+   && ::protozero::internal::gen_helpers::EqualsField(builtin_data_sources_, other.builtin_data_sources_)
+   && ::protozero::internal::gen_helpers::EqualsField(duration_ms_, other.duration_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(prefer_suspend_clock_for_duration_, other.prefer_suspend_clock_for_duration_)
+   && ::protozero::internal::gen_helpers::EqualsField(enable_extra_guardrails_, other.enable_extra_guardrails_)
+   && ::protozero::internal::gen_helpers::EqualsField(lockdown_mode_, other.lockdown_mode_)
+   && ::protozero::internal::gen_helpers::EqualsField(producers_, other.producers_)
+   && ::protozero::internal::gen_helpers::EqualsField(statsd_metadata_, other.statsd_metadata_)
+   && ::protozero::internal::gen_helpers::EqualsField(write_into_file_, other.write_into_file_)
+   && ::protozero::internal::gen_helpers::EqualsField(output_path_, other.output_path_)
+   && ::protozero::internal::gen_helpers::EqualsField(file_write_period_ms_, other.file_write_period_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(max_file_size_bytes_, other.max_file_size_bytes_)
+   && ::protozero::internal::gen_helpers::EqualsField(guardrail_overrides_, other.guardrail_overrides_)
+   && ::protozero::internal::gen_helpers::EqualsField(deferred_start_, other.deferred_start_)
+   && ::protozero::internal::gen_helpers::EqualsField(flush_period_ms_, other.flush_period_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(flush_timeout_ms_, other.flush_timeout_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(data_source_stop_timeout_ms_, other.data_source_stop_timeout_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(notify_traceur_, other.notify_traceur_)
+   && ::protozero::internal::gen_helpers::EqualsField(bugreport_score_, other.bugreport_score_)
+   && ::protozero::internal::gen_helpers::EqualsField(bugreport_filename_, other.bugreport_filename_)
+   && ::protozero::internal::gen_helpers::EqualsField(trigger_config_, other.trigger_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(activate_triggers_, other.activate_triggers_)
+   && ::protozero::internal::gen_helpers::EqualsField(incremental_state_config_, other.incremental_state_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(allow_user_build_tracing_, other.allow_user_build_tracing_)
+   && ::protozero::internal::gen_helpers::EqualsField(unique_session_name_, other.unique_session_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(compression_type_, other.compression_type_)
+   && ::protozero::internal::gen_helpers::EqualsField(incident_report_config_, other.incident_report_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(statsd_logging_, other.statsd_logging_)
+   && ::protozero::internal::gen_helpers::EqualsField(trace_uuid_msb_, other.trace_uuid_msb_)
+   && ::protozero::internal::gen_helpers::EqualsField(trace_uuid_lsb_, other.trace_uuid_lsb_)
+   && ::protozero::internal::gen_helpers::EqualsField(trace_filter_, other.trace_filter_)
+   && ::protozero::internal::gen_helpers::EqualsField(android_report_config_, other.android_report_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(cmd_trace_start_delay_, other.cmd_trace_start_delay_)
+   && ::protozero::internal::gen_helpers::EqualsField(session_semaphores_, other.session_semaphores_)
+   && ::protozero::internal::gen_helpers::EqualsField(priority_boost_, other.priority_boost_)
+   && ::protozero::internal::gen_helpers::EqualsField(exclusive_prio_, other.exclusive_prio_)
+   && ::protozero::internal::gen_helpers::EqualsField(write_flush_mode_, other.write_flush_mode_)
+   && ::protozero::internal::gen_helpers::EqualsField(fflush_post_write_, other.fflush_post_write_)
+   && ::protozero::internal::gen_helpers::EqualsField(trace_all_machines_, other.trace_all_machines_)
+   && ::protozero::internal::gen_helpers::EqualsField(notes_, other.notes_);
 }
 
-bool ChromeMojoEventInfo::ParseFromArray(const void* raw, size_t size) {
+int TraceConfig::buffers_size() const { return static_cast<int>(buffers_.size()); }
+void TraceConfig::clear_buffers() { buffers_.clear(); }
+TraceConfig_BufferConfig* TraceConfig::add_buffers() { buffers_.emplace_back(); return &buffers_.back(); }
+int TraceConfig::data_sources_size() const { return static_cast<int>(data_sources_.size()); }
+void TraceConfig::clear_data_sources() { data_sources_.clear(); }
+TraceConfig_DataSource* TraceConfig::add_data_sources() { data_sources_.emplace_back(); return &data_sources_.back(); }
+int TraceConfig::producers_size() const { return static_cast<int>(producers_.size()); }
+void TraceConfig::clear_producers() { producers_.clear(); }
+TraceConfig_ProducerConfig* TraceConfig::add_producers() { producers_.emplace_back(); return &producers_.back(); }
+int TraceConfig::session_semaphores_size() const { return static_cast<int>(session_semaphores_.size()); }
+void TraceConfig::clear_session_semaphores() { session_semaphores_.clear(); }
+TraceConfig_SessionSemaphore* TraceConfig::add_session_semaphores() { session_semaphores_.emplace_back(); return &session_semaphores_.back(); }
+int TraceConfig::notes_size() const { return static_cast<int>(notes_.size()); }
+void TraceConfig::clear_notes() { notes_.clear(); }
+TraceConfig_Note* TraceConfig::add_notes() { notes_.emplace_back(); return &notes_.back(); }
+bool TraceConfig::ParseFromArray(const void* raw, size_t size) {
+  buffers_.clear();
+  data_sources_.clear();
+  producers_.clear();
+  activate_triggers_.clear();
+  session_semaphores_.clear();
+  notes_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -32799,26 +28286,134 @@ bool ChromeMojoEventInfo::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* watcher_notify_interface_tag */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &watcher_notify_interface_tag_);
+      case 1 /* buffers */:
+        buffers_.emplace_back();
+        buffers_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 2 /* ipc_hash */:
-        field.get(&ipc_hash_);
+      case 2 /* data_sources */:
+        data_sources_.emplace_back();
+        data_sources_.back().ParseFromArray(field.data(), field.size());
         break;
-      case 3 /* mojo_interface_tag */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &mojo_interface_tag_);
+      case 20 /* builtin_data_sources */:
+        (*builtin_data_sources_).ParseFromArray(field.data(), field.size());
         break;
-      case 4 /* mojo_interface_method_iid */:
-        field.get(&mojo_interface_method_iid_);
+      case 3 /* duration_ms */:
+        field.get(&duration_ms_);
         break;
-      case 5 /* is_reply */:
-        field.get(&is_reply_);
+      case 36 /* prefer_suspend_clock_for_duration */:
+        field.get(&prefer_suspend_clock_for_duration_);
         break;
-      case 6 /* payload_size */:
-        field.get(&payload_size_);
+      case 4 /* enable_extra_guardrails */:
+        field.get(&enable_extra_guardrails_);
         break;
-      case 7 /* data_num_bytes */:
-        field.get(&data_num_bytes_);
+      case 5 /* lockdown_mode */:
+        field.get(&lockdown_mode_);
+        break;
+      case 6 /* producers */:
+        producers_.emplace_back();
+        producers_.back().ParseFromArray(field.data(), field.size());
+        break;
+      case 7 /* statsd_metadata */:
+        (*statsd_metadata_).ParseFromArray(field.data(), field.size());
+        break;
+      case 8 /* write_into_file */:
+        field.get(&write_into_file_);
+        break;
+      case 29 /* output_path */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &output_path_);
+        break;
+      case 9 /* file_write_period_ms */:
+        field.get(&file_write_period_ms_);
+        break;
+      case 10 /* max_file_size_bytes */:
+        field.get(&max_file_size_bytes_);
+        break;
+      case 11 /* guardrail_overrides */:
+        (*guardrail_overrides_).ParseFromArray(field.data(), field.size());
+        break;
+      case 12 /* deferred_start */:
+        field.get(&deferred_start_);
+        break;
+      case 13 /* flush_period_ms */:
+        field.get(&flush_period_ms_);
+        break;
+      case 14 /* flush_timeout_ms */:
+        field.get(&flush_timeout_ms_);
+        break;
+      case 23 /* data_source_stop_timeout_ms */:
+        field.get(&data_source_stop_timeout_ms_);
+        break;
+      case 16 /* notify_traceur */:
+        field.get(&notify_traceur_);
+        break;
+      case 30 /* bugreport_score */:
+        field.get(&bugreport_score_);
+        break;
+      case 38 /* bugreport_filename */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &bugreport_filename_);
+        break;
+      case 17 /* trigger_config */:
+        (*trigger_config_).ParseFromArray(field.data(), field.size());
+        break;
+      case 18 /* activate_triggers */:
+        activate_triggers_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &activate_triggers_.back());
+        break;
+      case 21 /* incremental_state_config */:
+        (*incremental_state_config_).ParseFromArray(field.data(), field.size());
+        break;
+      case 19 /* allow_user_build_tracing */:
+        field.get(&allow_user_build_tracing_);
+        break;
+      case 22 /* unique_session_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &unique_session_name_);
+        break;
+      case 24 /* compression_type */:
+        field.get(&compression_type_);
+        break;
+      case 25 /* incident_report_config */:
+        (*incident_report_config_).ParseFromArray(field.data(), field.size());
+        break;
+      case 31 /* statsd_logging */:
+        field.get(&statsd_logging_);
+        break;
+      case 27 /* trace_uuid_msb */:
+        field.get(&trace_uuid_msb_);
+        break;
+      case 28 /* trace_uuid_lsb */:
+        field.get(&trace_uuid_lsb_);
+        break;
+      case 33 /* trace_filter */:
+        (*trace_filter_).ParseFromArray(field.data(), field.size());
+        break;
+      case 34 /* android_report_config */:
+        (*android_report_config_).ParseFromArray(field.data(), field.size());
+        break;
+      case 35 /* cmd_trace_start_delay */:
+        (*cmd_trace_start_delay_).ParseFromArray(field.data(), field.size());
+        break;
+      case 39 /* session_semaphores */:
+        session_semaphores_.emplace_back();
+        session_semaphores_.back().ParseFromArray(field.data(), field.size());
+        break;
+      case 40 /* priority_boost */:
+        (*priority_boost_).ParseFromArray(field.data(), field.size());
+        break;
+      case 41 /* exclusive_prio */:
+        field.get(&exclusive_prio_);
+        break;
+      case 44 /* write_flush_mode */:
+        field.get(&write_flush_mode_);
+        break;
+      case 45 /* fflush_post_write */:
+        field.get(&fflush_post_write_);
+        break;
+      case 43 /* trace_all_machines */:
+        field.get(&trace_all_machines_);
+        break;
+      case 46 /* notes */:
+        notes_.emplace_back();
+        notes_.back().ParseFromArray(field.data(), field.size());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -32828,279 +28423,242 @@ bool ChromeMojoEventInfo::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ChromeMojoEventInfo::SerializeAsString() const {
+std::string TraceConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ChromeMojoEventInfo::SerializeAsArray() const {
+std::vector<uint8_t> TraceConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ChromeMojoEventInfo::Serialize(::protozero::Message* msg) const {
-  // Field 1: watcher_notify_interface_tag
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeString(1, watcher_notify_interface_tag_, msg);
+void TraceConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: buffers
+  for (auto& it : buffers_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
   }
 
-  // Field 2: ipc_hash
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, ipc_hash_, msg);
+  // Field 2: data_sources
+  for (auto& it : data_sources_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
   }
 
-  // Field 3: mojo_interface_tag
+  // Field 20: builtin_data_sources
+  if (_has_field_[20]) {
+    (*builtin_data_sources_).Serialize(msg->BeginNestedMessage<::protozero::Message>(20));
+  }
+
+  // Field 3: duration_ms
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeString(3, mojo_interface_tag_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, duration_ms_, msg);
   }
 
-  // Field 4: mojo_interface_method_iid
+  // Field 36: prefer_suspend_clock_for_duration
+  if (_has_field_[36]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(36, prefer_suspend_clock_for_duration_, msg);
+  }
+
+  // Field 4: enable_extra_guardrails
   if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, mojo_interface_method_iid_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(4, enable_extra_guardrails_, msg);
   }
 
-  // Field 5: is_reply
+  // Field 5: lockdown_mode
   if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, is_reply_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, lockdown_mode_, msg);
   }
 
-  // Field 6: payload_size
-  if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(6, payload_size_, msg);
+  // Field 6: producers
+  for (auto& it : producers_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(6));
   }
 
-  // Field 7: data_num_bytes
+  // Field 7: statsd_metadata
   if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(7, data_num_bytes_, msg);
+    (*statsd_metadata_).Serialize(msg->BeginNestedMessage<::protozero::Message>(7));
   }
 
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
-}
+  // Field 8: write_into_file
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(8, write_into_file_, msg);
+  }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_process_descriptor.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_process_descriptor.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_PROCESS_DESCRIPTOR_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_PROCESS_DESCRIPTOR_PROTO_CPP_H_
+  // Field 29: output_path
+  if (_has_field_[29]) {
+    ::protozero::internal::gen_helpers::SerializeString(29, output_path_, msg);
+  }
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  // Field 9: file_write_period_ms
+  if (_has_field_[9]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(9, file_write_period_ms_, msg);
+  }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  // Field 10: max_file_size_bytes
+  if (_has_field_[10]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(10, max_file_size_bytes_, msg);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeProcessDescriptor;
-enum ChromeProcessDescriptor_ProcessType : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  // Field 11: guardrail_overrides
+  if (_has_field_[11]) {
+    (*guardrail_overrides_).Serialize(msg->BeginNestedMessage<::protozero::Message>(11));
+  }
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  // Field 12: deferred_start
+  if (_has_field_[12]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(12, deferred_start_, msg);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum ChromeProcessDescriptor_ProcessType : int {
-  ChromeProcessDescriptor_ProcessType_PROCESS_UNSPECIFIED = 0,
-  ChromeProcessDescriptor_ProcessType_PROCESS_BROWSER = 1,
-  ChromeProcessDescriptor_ProcessType_PROCESS_RENDERER = 2,
-  ChromeProcessDescriptor_ProcessType_PROCESS_UTILITY = 3,
-  ChromeProcessDescriptor_ProcessType_PROCESS_ZYGOTE = 4,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SANDBOX_HELPER = 5,
-  ChromeProcessDescriptor_ProcessType_PROCESS_GPU = 6,
-  ChromeProcessDescriptor_ProcessType_PROCESS_PPAPI_PLUGIN = 7,
-  ChromeProcessDescriptor_ProcessType_PROCESS_PPAPI_BROKER = 8,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_NETWORK = 9,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_TRACING = 10,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_STORAGE = 11,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_AUDIO = 12,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_DATA_DECODER = 13,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_UTIL_WIN = 14,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_PROXY_RESOLVER = 15,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_CDM = 16,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_VIDEO_CAPTURE = 17,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_UNZIPPER = 18,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_MIRRORING = 19,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_FILEPATCHER = 20,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_TTS = 21,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_PRINTING = 22,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_QUARANTINE = 23,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_CROS_LOCALSEARCH = 24,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_CROS_ASSISTANT_AUDIO_DECODER = 25,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_FILEUTIL = 26,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_PRINTCOMPOSITOR = 27,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_PAINTPREVIEW = 28,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_SPEECHRECOGNITION = 29,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_XRDEVICE = 30,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_READICON = 31,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_LANGUAGEDETECTION = 32,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_SHARING = 33,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_MEDIAPARSER = 34,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_QRCODEGENERATOR = 35,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_PROFILEIMPORT = 36,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_IME = 37,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_RECORDING = 38,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_SHAPEDETECTION = 39,
-  ChromeProcessDescriptor_ProcessType_PROCESS_RENDERER_EXTENSION = 40,
-};
+  // Field 13: flush_period_ms
+  if (_has_field_[13]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(13, flush_period_ms_, msg);
+  }
 
-class PERFETTO_EXPORT_COMPONENT ChromeProcessDescriptor : public ::protozero::CppMessageObj {
- public:
-  using ProcessType = ChromeProcessDescriptor_ProcessType;
-  static constexpr auto PROCESS_UNSPECIFIED = ChromeProcessDescriptor_ProcessType_PROCESS_UNSPECIFIED;
-  static constexpr auto PROCESS_BROWSER = ChromeProcessDescriptor_ProcessType_PROCESS_BROWSER;
-  static constexpr auto PROCESS_RENDERER = ChromeProcessDescriptor_ProcessType_PROCESS_RENDERER;
-  static constexpr auto PROCESS_UTILITY = ChromeProcessDescriptor_ProcessType_PROCESS_UTILITY;
-  static constexpr auto PROCESS_ZYGOTE = ChromeProcessDescriptor_ProcessType_PROCESS_ZYGOTE;
-  static constexpr auto PROCESS_SANDBOX_HELPER = ChromeProcessDescriptor_ProcessType_PROCESS_SANDBOX_HELPER;
-  static constexpr auto PROCESS_GPU = ChromeProcessDescriptor_ProcessType_PROCESS_GPU;
-  static constexpr auto PROCESS_PPAPI_PLUGIN = ChromeProcessDescriptor_ProcessType_PROCESS_PPAPI_PLUGIN;
-  static constexpr auto PROCESS_PPAPI_BROKER = ChromeProcessDescriptor_ProcessType_PROCESS_PPAPI_BROKER;
-  static constexpr auto PROCESS_SERVICE_NETWORK = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_NETWORK;
-  static constexpr auto PROCESS_SERVICE_TRACING = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_TRACING;
-  static constexpr auto PROCESS_SERVICE_STORAGE = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_STORAGE;
-  static constexpr auto PROCESS_SERVICE_AUDIO = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_AUDIO;
-  static constexpr auto PROCESS_SERVICE_DATA_DECODER = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_DATA_DECODER;
-  static constexpr auto PROCESS_SERVICE_UTIL_WIN = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_UTIL_WIN;
-  static constexpr auto PROCESS_SERVICE_PROXY_RESOLVER = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_PROXY_RESOLVER;
-  static constexpr auto PROCESS_SERVICE_CDM = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_CDM;
-  static constexpr auto PROCESS_SERVICE_VIDEO_CAPTURE = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_VIDEO_CAPTURE;
-  static constexpr auto PROCESS_SERVICE_UNZIPPER = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_UNZIPPER;
-  static constexpr auto PROCESS_SERVICE_MIRRORING = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_MIRRORING;
-  static constexpr auto PROCESS_SERVICE_FILEPATCHER = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_FILEPATCHER;
-  static constexpr auto PROCESS_SERVICE_TTS = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_TTS;
-  static constexpr auto PROCESS_SERVICE_PRINTING = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_PRINTING;
-  static constexpr auto PROCESS_SERVICE_QUARANTINE = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_QUARANTINE;
-  static constexpr auto PROCESS_SERVICE_CROS_LOCALSEARCH = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_CROS_LOCALSEARCH;
-  static constexpr auto PROCESS_SERVICE_CROS_ASSISTANT_AUDIO_DECODER = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_CROS_ASSISTANT_AUDIO_DECODER;
-  static constexpr auto PROCESS_SERVICE_FILEUTIL = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_FILEUTIL;
-  static constexpr auto PROCESS_SERVICE_PRINTCOMPOSITOR = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_PRINTCOMPOSITOR;
-  static constexpr auto PROCESS_SERVICE_PAINTPREVIEW = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_PAINTPREVIEW;
-  static constexpr auto PROCESS_SERVICE_SPEECHRECOGNITION = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_SPEECHRECOGNITION;
-  static constexpr auto PROCESS_SERVICE_XRDEVICE = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_XRDEVICE;
-  static constexpr auto PROCESS_SERVICE_READICON = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_READICON;
-  static constexpr auto PROCESS_SERVICE_LANGUAGEDETECTION = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_LANGUAGEDETECTION;
-  static constexpr auto PROCESS_SERVICE_SHARING = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_SHARING;
-  static constexpr auto PROCESS_SERVICE_MEDIAPARSER = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_MEDIAPARSER;
-  static constexpr auto PROCESS_SERVICE_QRCODEGENERATOR = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_QRCODEGENERATOR;
-  static constexpr auto PROCESS_SERVICE_PROFILEIMPORT = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_PROFILEIMPORT;
-  static constexpr auto PROCESS_SERVICE_IME = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_IME;
-  static constexpr auto PROCESS_SERVICE_RECORDING = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_RECORDING;
-  static constexpr auto PROCESS_SERVICE_SHAPEDETECTION = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_SHAPEDETECTION;
-  static constexpr auto PROCESS_RENDERER_EXTENSION = ChromeProcessDescriptor_ProcessType_PROCESS_RENDERER_EXTENSION;
-  static constexpr auto ProcessType_MIN = ChromeProcessDescriptor_ProcessType_PROCESS_UNSPECIFIED;
-  static constexpr auto ProcessType_MAX = ChromeProcessDescriptor_ProcessType_PROCESS_RENDERER_EXTENSION;
-  enum FieldNumbers {
-    kProcessTypeFieldNumber = 1,
-    kProcessPriorityFieldNumber = 2,
-    kLegacySortIndexFieldNumber = 3,
-    kHostAppPackageNameFieldNumber = 4,
-    kCrashTraceIdFieldNumber = 5,
-  };
+  // Field 14: flush_timeout_ms
+  if (_has_field_[14]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(14, flush_timeout_ms_, msg);
+  }
 
-  ChromeProcessDescriptor();
-  ~ChromeProcessDescriptor() override;
-  ChromeProcessDescriptor(ChromeProcessDescriptor&&) noexcept;
-  ChromeProcessDescriptor& operator=(ChromeProcessDescriptor&&);
-  ChromeProcessDescriptor(const ChromeProcessDescriptor&);
-  ChromeProcessDescriptor& operator=(const ChromeProcessDescriptor&);
-  bool operator==(const ChromeProcessDescriptor&) const;
-  bool operator!=(const ChromeProcessDescriptor& other) const { return !(*this == other); }
+  // Field 23: data_source_stop_timeout_ms
+  if (_has_field_[23]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(23, data_source_stop_timeout_ms_, msg);
+  }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  // Field 16: notify_traceur
+  if (_has_field_[16]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(16, notify_traceur_, msg);
+  }
 
-  bool has_process_type() const { return _has_field_[1]; }
-  ChromeProcessDescriptor_ProcessType process_type() const { return process_type_; }
-  void set_process_type(ChromeProcessDescriptor_ProcessType value) { process_type_ = value; _has_field_.set(1); }
+  // Field 30: bugreport_score
+  if (_has_field_[30]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(30, bugreport_score_, msg);
+  }
 
-  bool has_process_priority() const { return _has_field_[2]; }
-  int32_t process_priority() const { return process_priority_; }
-  void set_process_priority(int32_t value) { process_priority_ = value; _has_field_.set(2); }
+  // Field 38: bugreport_filename
+  if (_has_field_[38]) {
+    ::protozero::internal::gen_helpers::SerializeString(38, bugreport_filename_, msg);
+  }
 
-  bool has_legacy_sort_index() const { return _has_field_[3]; }
-  int32_t legacy_sort_index() const { return legacy_sort_index_; }
-  void set_legacy_sort_index(int32_t value) { legacy_sort_index_ = value; _has_field_.set(3); }
+  // Field 17: trigger_config
+  if (_has_field_[17]) {
+    (*trigger_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(17));
+  }
 
-  bool has_host_app_package_name() const { return _has_field_[4]; }
-  const std::string& host_app_package_name() const { return host_app_package_name_; }
-  void set_host_app_package_name(const std::string& value) { host_app_package_name_ = value; _has_field_.set(4); }
+  // Field 18: activate_triggers
+  for (auto& it : activate_triggers_) {
+    ::protozero::internal::gen_helpers::SerializeString(18, it, msg);
+  }
 
-  bool has_crash_trace_id() const { return _has_field_[5]; }
-  uint64_t crash_trace_id() const { return crash_trace_id_; }
-  void set_crash_trace_id(uint64_t value) { crash_trace_id_ = value; _has_field_.set(5); }
+  // Field 21: incremental_state_config
+  if (_has_field_[21]) {
+    (*incremental_state_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(21));
+  }
 
- private:
-  ChromeProcessDescriptor_ProcessType process_type_{};
-  int32_t process_priority_{};
-  int32_t legacy_sort_index_{};
-  std::string host_app_package_name_{};
-  uint64_t crash_trace_id_{};
+  // Field 19: allow_user_build_tracing
+  if (_has_field_[19]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(19, allow_user_build_tracing_, msg);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  // Field 22: unique_session_name
+  if (_has_field_[22]) {
+    ::protozero::internal::gen_helpers::SerializeString(22, unique_session_name_, msg);
+  }
 
-  std::bitset<6> _has_field_{};
-};
+  // Field 24: compression_type
+  if (_has_field_[24]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(24, compression_type_, msg);
+  }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  // Field 25: incident_report_config
+  if (_has_field_[25]) {
+    (*incident_report_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(25));
+  }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_PROCESS_DESCRIPTOR_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_process_descriptor.gen.h"
+  // Field 31: statsd_logging
+  if (_has_field_[31]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(31, statsd_logging_, msg);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+  // Field 27: trace_uuid_msb
+  if (_has_field_[27]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(27, trace_uuid_msb_, msg);
+  }
 
-ChromeProcessDescriptor::ChromeProcessDescriptor() = default;
-ChromeProcessDescriptor::~ChromeProcessDescriptor() = default;
-ChromeProcessDescriptor::ChromeProcessDescriptor(const ChromeProcessDescriptor&) = default;
-ChromeProcessDescriptor& ChromeProcessDescriptor::operator=(const ChromeProcessDescriptor&) = default;
-ChromeProcessDescriptor::ChromeProcessDescriptor(ChromeProcessDescriptor&&) noexcept = default;
-ChromeProcessDescriptor& ChromeProcessDescriptor::operator=(ChromeProcessDescriptor&&) = default;
+  // Field 28: trace_uuid_lsb
+  if (_has_field_[28]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(28, trace_uuid_lsb_, msg);
+  }
 
-bool ChromeProcessDescriptor::operator==(const ChromeProcessDescriptor& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && process_type_ == other.process_type_
-   && process_priority_ == other.process_priority_
-   && legacy_sort_index_ == other.legacy_sort_index_
-   && host_app_package_name_ == other.host_app_package_name_
-   && crash_trace_id_ == other.crash_trace_id_;
+  // Field 33: trace_filter
+  if (_has_field_[33]) {
+    (*trace_filter_).Serialize(msg->BeginNestedMessage<::protozero::Message>(33));
+  }
+
+  // Field 34: android_report_config
+  if (_has_field_[34]) {
+    (*android_report_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(34));
+  }
+
+  // Field 35: cmd_trace_start_delay
+  if (_has_field_[35]) {
+    (*cmd_trace_start_delay_).Serialize(msg->BeginNestedMessage<::protozero::Message>(35));
+  }
+
+  // Field 39: session_semaphores
+  for (auto& it : session_semaphores_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(39));
+  }
+
+  // Field 40: priority_boost
+  if (_has_field_[40]) {
+    (*priority_boost_).Serialize(msg->BeginNestedMessage<::protozero::Message>(40));
+  }
+
+  // Field 41: exclusive_prio
+  if (_has_field_[41]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(41, exclusive_prio_, msg);
+  }
+
+  // Field 44: write_flush_mode
+  if (_has_field_[44]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(44, write_flush_mode_, msg);
+  }
+
+  // Field 45: fflush_post_write
+  if (_has_field_[45]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(45, fflush_post_write_, msg);
+  }
+
+  // Field 43: trace_all_machines
+  if (_has_field_[43]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(43, trace_all_machines_, msg);
+  }
+
+  // Field 46: notes
+  for (auto& it : notes_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(46));
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
-bool ChromeProcessDescriptor::ParseFromArray(const void* raw, size_t size) {
+
+TraceConfig_Note::TraceConfig_Note() = default;
+TraceConfig_Note::~TraceConfig_Note() = default;
+TraceConfig_Note::TraceConfig_Note(const TraceConfig_Note&) = default;
+TraceConfig_Note& TraceConfig_Note::operator=(const TraceConfig_Note&) = default;
+TraceConfig_Note::TraceConfig_Note(TraceConfig_Note&&) noexcept = default;
+TraceConfig_Note& TraceConfig_Note::operator=(TraceConfig_Note&&) = default;
+
+bool TraceConfig_Note::operator==(const TraceConfig_Note& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(key_, other.key_)
+   && ::protozero::internal::gen_helpers::EqualsField(value_, other.value_);
+}
+
+bool TraceConfig_Note::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -33110,20 +28668,11 @@ bool ChromeProcessDescriptor::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* process_type */:
-        field.get(&process_type_);
-        break;
-      case 2 /* process_priority */:
-        field.get(&process_priority_);
-        break;
-      case 3 /* legacy_sort_index */:
-        field.get(&legacy_sort_index_);
-        break;
-      case 4 /* host_app_package_name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &host_app_package_name_);
+      case 1 /* key */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &key_);
         break;
-      case 5 /* crash_trace_id */:
-        field.get(&crash_trace_id_);
+      case 2 /* value */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &value_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -33133,175 +28682,111 @@ bool ChromeProcessDescriptor::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ChromeProcessDescriptor::SerializeAsString() const {
+std::string TraceConfig_Note::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ChromeProcessDescriptor::SerializeAsArray() const {
+std::vector<uint8_t> TraceConfig_Note::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ChromeProcessDescriptor::Serialize(::protozero::Message* msg) const {
-  // Field 1: process_type
+void TraceConfig_Note::Serialize(::protozero::Message* msg) const {
+  // Field 1: key
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, process_type_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(1, key_, msg);
   }
 
-  // Field 2: process_priority
+  // Field 2: value
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, process_priority_, msg);
-  }
-
-  // Field 3: legacy_sort_index
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, legacy_sort_index_, msg);
-  }
-
-  // Field 4: host_app_package_name
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeString(4, host_app_package_name_, msg);
-  }
-
-  // Field 5: crash_trace_id
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(5, crash_trace_id_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(2, value_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_renderer_scheduler_state.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_renderer_scheduler_state.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_RENDERER_SCHEDULER_STATE_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_RENDERER_SCHEDULER_STATE_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeRendererSchedulerState;
-enum ChromeRAILMode : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum ChromeRAILMode : int {
-  RAIL_MODE_NONE = 0,
-  RAIL_MODE_RESPONSE = 1,
-  RAIL_MODE_ANIMATION = 2,
-  RAIL_MODE_IDLE = 3,
-  RAIL_MODE_LOAD = 4,
-};
-
-class PERFETTO_EXPORT_COMPONENT ChromeRendererSchedulerState : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kRailModeFieldNumber = 1,
-    kIsBackgroundedFieldNumber = 2,
-    kIsHiddenFieldNumber = 3,
-  };
-
-  ChromeRendererSchedulerState();
-  ~ChromeRendererSchedulerState() override;
-  ChromeRendererSchedulerState(ChromeRendererSchedulerState&&) noexcept;
-  ChromeRendererSchedulerState& operator=(ChromeRendererSchedulerState&&);
-  ChromeRendererSchedulerState(const ChromeRendererSchedulerState&);
-  ChromeRendererSchedulerState& operator=(const ChromeRendererSchedulerState&);
-  bool operator==(const ChromeRendererSchedulerState&) const;
-  bool operator!=(const ChromeRendererSchedulerState& other) const { return !(*this == other); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+TraceConfig_SessionSemaphore::TraceConfig_SessionSemaphore() = default;
+TraceConfig_SessionSemaphore::~TraceConfig_SessionSemaphore() = default;
+TraceConfig_SessionSemaphore::TraceConfig_SessionSemaphore(const TraceConfig_SessionSemaphore&) = default;
+TraceConfig_SessionSemaphore& TraceConfig_SessionSemaphore::operator=(const TraceConfig_SessionSemaphore&) = default;
+TraceConfig_SessionSemaphore::TraceConfig_SessionSemaphore(TraceConfig_SessionSemaphore&&) noexcept = default;
+TraceConfig_SessionSemaphore& TraceConfig_SessionSemaphore::operator=(TraceConfig_SessionSemaphore&&) = default;
 
-  bool has_rail_mode() const { return _has_field_[1]; }
-  ChromeRAILMode rail_mode() const { return rail_mode_; }
-  void set_rail_mode(ChromeRAILMode value) { rail_mode_ = value; _has_field_.set(1); }
+bool TraceConfig_SessionSemaphore::operator==(const TraceConfig_SessionSemaphore& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(max_other_session_count_, other.max_other_session_count_);
+}
 
-  bool has_is_backgrounded() const { return _has_field_[2]; }
-  bool is_backgrounded() const { return is_backgrounded_; }
-  void set_is_backgrounded(bool value) { is_backgrounded_ = value; _has_field_.set(2); }
+bool TraceConfig_SessionSemaphore::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  bool has_is_hidden() const { return _has_field_[3]; }
-  bool is_hidden() const { return is_hidden_; }
-  void set_is_hidden(bool value) { is_hidden_ = value; _has_field_.set(3); }
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+        break;
+      case 2 /* max_other_session_count */:
+        field.get(&max_other_session_count_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
- private:
-  ChromeRAILMode rail_mode_{};
-  bool is_backgrounded_{};
-  bool is_hidden_{};
+std::string TraceConfig_SessionSemaphore::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+std::vector<uint8_t> TraceConfig_SessionSemaphore::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  std::bitset<4> _has_field_{};
-};
+void TraceConfig_SessionSemaphore::Serialize(::protozero::Message* msg) const {
+  // Field 1: name
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
+  }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  // Field 2: max_other_session_count
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, max_other_session_count_, msg);
+  }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_RENDERER_SCHEDULER_STATE_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_renderer_scheduler_state.gen.h"
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
 
-ChromeRendererSchedulerState::ChromeRendererSchedulerState() = default;
-ChromeRendererSchedulerState::~ChromeRendererSchedulerState() = default;
-ChromeRendererSchedulerState::ChromeRendererSchedulerState(const ChromeRendererSchedulerState&) = default;
-ChromeRendererSchedulerState& ChromeRendererSchedulerState::operator=(const ChromeRendererSchedulerState&) = default;
-ChromeRendererSchedulerState::ChromeRendererSchedulerState(ChromeRendererSchedulerState&&) noexcept = default;
-ChromeRendererSchedulerState& ChromeRendererSchedulerState::operator=(ChromeRendererSchedulerState&&) = default;
+TraceConfig_CmdTraceStartDelay::TraceConfig_CmdTraceStartDelay() = default;
+TraceConfig_CmdTraceStartDelay::~TraceConfig_CmdTraceStartDelay() = default;
+TraceConfig_CmdTraceStartDelay::TraceConfig_CmdTraceStartDelay(const TraceConfig_CmdTraceStartDelay&) = default;
+TraceConfig_CmdTraceStartDelay& TraceConfig_CmdTraceStartDelay::operator=(const TraceConfig_CmdTraceStartDelay&) = default;
+TraceConfig_CmdTraceStartDelay::TraceConfig_CmdTraceStartDelay(TraceConfig_CmdTraceStartDelay&&) noexcept = default;
+TraceConfig_CmdTraceStartDelay& TraceConfig_CmdTraceStartDelay::operator=(TraceConfig_CmdTraceStartDelay&&) = default;
 
-bool ChromeRendererSchedulerState::operator==(const ChromeRendererSchedulerState& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && rail_mode_ == other.rail_mode_
-   && is_backgrounded_ == other.is_backgrounded_
-   && is_hidden_ == other.is_hidden_;
+bool TraceConfig_CmdTraceStartDelay::operator==(const TraceConfig_CmdTraceStartDelay& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(min_delay_ms_, other.min_delay_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(max_delay_ms_, other.max_delay_ms_);
 }
 
-bool ChromeRendererSchedulerState::ParseFromArray(const void* raw, size_t size) {
+bool TraceConfig_CmdTraceStartDelay::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -33311,14 +28796,11 @@ bool ChromeRendererSchedulerState::ParseFromArray(const void* raw, size_t size)
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* rail_mode */:
-        field.get(&rail_mode_);
-        break;
-      case 2 /* is_backgrounded */:
-        field.get(&is_backgrounded_);
+      case 1 /* min_delay_ms */:
+        field.get(&min_delay_ms_);
         break;
-      case 3 /* is_hidden */:
-        field.get(&is_hidden_);
+      case 2 /* max_delay_ms */:
+        field.get(&max_delay_ms_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -33328,244 +28810,49 @@ bool ChromeRendererSchedulerState::ParseFromArray(const void* raw, size_t size)
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ChromeRendererSchedulerState::SerializeAsString() const {
+std::string TraceConfig_CmdTraceStartDelay::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ChromeRendererSchedulerState::SerializeAsArray() const {
+std::vector<uint8_t> TraceConfig_CmdTraceStartDelay::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ChromeRendererSchedulerState::Serialize(::protozero::Message* msg) const {
-  // Field 1: rail_mode
+void TraceConfig_CmdTraceStartDelay::Serialize(::protozero::Message* msg) const {
+  // Field 1: min_delay_ms
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, rail_mode_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, min_delay_ms_, msg);
   }
 
-  // Field 2: is_backgrounded
+  // Field 2: max_delay_ms
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, is_backgrounded_, msg);
-  }
-
-  // Field 3: is_hidden
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, is_hidden_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, max_delay_ms_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_thread_descriptor.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_thread_descriptor.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_THREAD_DESCRIPTOR_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_THREAD_DESCRIPTOR_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeThreadDescriptor;
-enum ChromeThreadDescriptor_ThreadType : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum ChromeThreadDescriptor_ThreadType : int {
-  ChromeThreadDescriptor_ThreadType_THREAD_UNSPECIFIED = 0,
-  ChromeThreadDescriptor_ThreadType_THREAD_MAIN = 1,
-  ChromeThreadDescriptor_ThreadType_THREAD_IO = 2,
-  ChromeThreadDescriptor_ThreadType_THREAD_POOL_BG_WORKER = 3,
-  ChromeThreadDescriptor_ThreadType_THREAD_POOL_FG_WORKER = 4,
-  ChromeThreadDescriptor_ThreadType_THREAD_POOL_FG_BLOCKING = 5,
-  ChromeThreadDescriptor_ThreadType_THREAD_POOL_BG_BLOCKING = 6,
-  ChromeThreadDescriptor_ThreadType_THREAD_POOL_SERVICE = 7,
-  ChromeThreadDescriptor_ThreadType_THREAD_COMPOSITOR = 8,
-  ChromeThreadDescriptor_ThreadType_THREAD_VIZ_COMPOSITOR = 9,
-  ChromeThreadDescriptor_ThreadType_THREAD_COMPOSITOR_WORKER = 10,
-  ChromeThreadDescriptor_ThreadType_THREAD_SERVICE_WORKER = 11,
-  ChromeThreadDescriptor_ThreadType_THREAD_NETWORK_SERVICE = 12,
-  ChromeThreadDescriptor_ThreadType_THREAD_CHILD_IO = 13,
-  ChromeThreadDescriptor_ThreadType_THREAD_BROWSER_IO = 14,
-  ChromeThreadDescriptor_ThreadType_THREAD_BROWSER_MAIN = 15,
-  ChromeThreadDescriptor_ThreadType_THREAD_RENDERER_MAIN = 16,
-  ChromeThreadDescriptor_ThreadType_THREAD_UTILITY_MAIN = 17,
-  ChromeThreadDescriptor_ThreadType_THREAD_GPU_MAIN = 18,
-  ChromeThreadDescriptor_ThreadType_THREAD_CACHE_BLOCKFILE = 19,
-  ChromeThreadDescriptor_ThreadType_THREAD_MEDIA = 20,
-  ChromeThreadDescriptor_ThreadType_THREAD_AUDIO_OUTPUTDEVICE = 21,
-  ChromeThreadDescriptor_ThreadType_THREAD_AUDIO_INPUTDEVICE = 22,
-  ChromeThreadDescriptor_ThreadType_THREAD_GPU_MEMORY = 23,
-  ChromeThreadDescriptor_ThreadType_THREAD_GPU_VSYNC = 24,
-  ChromeThreadDescriptor_ThreadType_THREAD_DXA_VIDEODECODER = 25,
-  ChromeThreadDescriptor_ThreadType_THREAD_BROWSER_WATCHDOG = 26,
-  ChromeThreadDescriptor_ThreadType_THREAD_WEBRTC_NETWORK = 27,
-  ChromeThreadDescriptor_ThreadType_THREAD_WINDOW_OWNER = 28,
-  ChromeThreadDescriptor_ThreadType_THREAD_WEBRTC_SIGNALING = 29,
-  ChromeThreadDescriptor_ThreadType_THREAD_WEBRTC_WORKER = 30,
-  ChromeThreadDescriptor_ThreadType_THREAD_PPAPI_MAIN = 31,
-  ChromeThreadDescriptor_ThreadType_THREAD_GPU_WATCHDOG = 32,
-  ChromeThreadDescriptor_ThreadType_THREAD_SWAPPER = 33,
-  ChromeThreadDescriptor_ThreadType_THREAD_GAMEPAD_POLLING = 34,
-  ChromeThreadDescriptor_ThreadType_THREAD_WEBCRYPTO = 35,
-  ChromeThreadDescriptor_ThreadType_THREAD_DATABASE = 36,
-  ChromeThreadDescriptor_ThreadType_THREAD_PROXYRESOLVER = 37,
-  ChromeThreadDescriptor_ThreadType_THREAD_DEVTOOLSADB = 38,
-  ChromeThreadDescriptor_ThreadType_THREAD_NETWORKCONFIGWATCHER = 39,
-  ChromeThreadDescriptor_ThreadType_THREAD_WASAPI_RENDER = 40,
-  ChromeThreadDescriptor_ThreadType_THREAD_LOADER_LOCK_SAMPLER = 41,
-  ChromeThreadDescriptor_ThreadType_THREAD_MEMORY_INFRA = 50,
-  ChromeThreadDescriptor_ThreadType_THREAD_SAMPLING_PROFILER = 51,
-};
-
-class PERFETTO_EXPORT_COMPONENT ChromeThreadDescriptor : public ::protozero::CppMessageObj {
- public:
-  using ThreadType = ChromeThreadDescriptor_ThreadType;
-  static constexpr auto THREAD_UNSPECIFIED = ChromeThreadDescriptor_ThreadType_THREAD_UNSPECIFIED;
-  static constexpr auto THREAD_MAIN = ChromeThreadDescriptor_ThreadType_THREAD_MAIN;
-  static constexpr auto THREAD_IO = ChromeThreadDescriptor_ThreadType_THREAD_IO;
-  static constexpr auto THREAD_POOL_BG_WORKER = ChromeThreadDescriptor_ThreadType_THREAD_POOL_BG_WORKER;
-  static constexpr auto THREAD_POOL_FG_WORKER = ChromeThreadDescriptor_ThreadType_THREAD_POOL_FG_WORKER;
-  static constexpr auto THREAD_POOL_FG_BLOCKING = ChromeThreadDescriptor_ThreadType_THREAD_POOL_FG_BLOCKING;
-  static constexpr auto THREAD_POOL_BG_BLOCKING = ChromeThreadDescriptor_ThreadType_THREAD_POOL_BG_BLOCKING;
-  static constexpr auto THREAD_POOL_SERVICE = ChromeThreadDescriptor_ThreadType_THREAD_POOL_SERVICE;
-  static constexpr auto THREAD_COMPOSITOR = ChromeThreadDescriptor_ThreadType_THREAD_COMPOSITOR;
-  static constexpr auto THREAD_VIZ_COMPOSITOR = ChromeThreadDescriptor_ThreadType_THREAD_VIZ_COMPOSITOR;
-  static constexpr auto THREAD_COMPOSITOR_WORKER = ChromeThreadDescriptor_ThreadType_THREAD_COMPOSITOR_WORKER;
-  static constexpr auto THREAD_SERVICE_WORKER = ChromeThreadDescriptor_ThreadType_THREAD_SERVICE_WORKER;
-  static constexpr auto THREAD_NETWORK_SERVICE = ChromeThreadDescriptor_ThreadType_THREAD_NETWORK_SERVICE;
-  static constexpr auto THREAD_CHILD_IO = ChromeThreadDescriptor_ThreadType_THREAD_CHILD_IO;
-  static constexpr auto THREAD_BROWSER_IO = ChromeThreadDescriptor_ThreadType_THREAD_BROWSER_IO;
-  static constexpr auto THREAD_BROWSER_MAIN = ChromeThreadDescriptor_ThreadType_THREAD_BROWSER_MAIN;
-  static constexpr auto THREAD_RENDERER_MAIN = ChromeThreadDescriptor_ThreadType_THREAD_RENDERER_MAIN;
-  static constexpr auto THREAD_UTILITY_MAIN = ChromeThreadDescriptor_ThreadType_THREAD_UTILITY_MAIN;
-  static constexpr auto THREAD_GPU_MAIN = ChromeThreadDescriptor_ThreadType_THREAD_GPU_MAIN;
-  static constexpr auto THREAD_CACHE_BLOCKFILE = ChromeThreadDescriptor_ThreadType_THREAD_CACHE_BLOCKFILE;
-  static constexpr auto THREAD_MEDIA = ChromeThreadDescriptor_ThreadType_THREAD_MEDIA;
-  static constexpr auto THREAD_AUDIO_OUTPUTDEVICE = ChromeThreadDescriptor_ThreadType_THREAD_AUDIO_OUTPUTDEVICE;
-  static constexpr auto THREAD_AUDIO_INPUTDEVICE = ChromeThreadDescriptor_ThreadType_THREAD_AUDIO_INPUTDEVICE;
-  static constexpr auto THREAD_GPU_MEMORY = ChromeThreadDescriptor_ThreadType_THREAD_GPU_MEMORY;
-  static constexpr auto THREAD_GPU_VSYNC = ChromeThreadDescriptor_ThreadType_THREAD_GPU_VSYNC;
-  static constexpr auto THREAD_DXA_VIDEODECODER = ChromeThreadDescriptor_ThreadType_THREAD_DXA_VIDEODECODER;
-  static constexpr auto THREAD_BROWSER_WATCHDOG = ChromeThreadDescriptor_ThreadType_THREAD_BROWSER_WATCHDOG;
-  static constexpr auto THREAD_WEBRTC_NETWORK = ChromeThreadDescriptor_ThreadType_THREAD_WEBRTC_NETWORK;
-  static constexpr auto THREAD_WINDOW_OWNER = ChromeThreadDescriptor_ThreadType_THREAD_WINDOW_OWNER;
-  static constexpr auto THREAD_WEBRTC_SIGNALING = ChromeThreadDescriptor_ThreadType_THREAD_WEBRTC_SIGNALING;
-  static constexpr auto THREAD_WEBRTC_WORKER = ChromeThreadDescriptor_ThreadType_THREAD_WEBRTC_WORKER;
-  static constexpr auto THREAD_PPAPI_MAIN = ChromeThreadDescriptor_ThreadType_THREAD_PPAPI_MAIN;
-  static constexpr auto THREAD_GPU_WATCHDOG = ChromeThreadDescriptor_ThreadType_THREAD_GPU_WATCHDOG;
-  static constexpr auto THREAD_SWAPPER = ChromeThreadDescriptor_ThreadType_THREAD_SWAPPER;
-  static constexpr auto THREAD_GAMEPAD_POLLING = ChromeThreadDescriptor_ThreadType_THREAD_GAMEPAD_POLLING;
-  static constexpr auto THREAD_WEBCRYPTO = ChromeThreadDescriptor_ThreadType_THREAD_WEBCRYPTO;
-  static constexpr auto THREAD_DATABASE = ChromeThreadDescriptor_ThreadType_THREAD_DATABASE;
-  static constexpr auto THREAD_PROXYRESOLVER = ChromeThreadDescriptor_ThreadType_THREAD_PROXYRESOLVER;
-  static constexpr auto THREAD_DEVTOOLSADB = ChromeThreadDescriptor_ThreadType_THREAD_DEVTOOLSADB;
-  static constexpr auto THREAD_NETWORKCONFIGWATCHER = ChromeThreadDescriptor_ThreadType_THREAD_NETWORKCONFIGWATCHER;
-  static constexpr auto THREAD_WASAPI_RENDER = ChromeThreadDescriptor_ThreadType_THREAD_WASAPI_RENDER;
-  static constexpr auto THREAD_LOADER_LOCK_SAMPLER = ChromeThreadDescriptor_ThreadType_THREAD_LOADER_LOCK_SAMPLER;
-  static constexpr auto THREAD_MEMORY_INFRA = ChromeThreadDescriptor_ThreadType_THREAD_MEMORY_INFRA;
-  static constexpr auto THREAD_SAMPLING_PROFILER = ChromeThreadDescriptor_ThreadType_THREAD_SAMPLING_PROFILER;
-  static constexpr auto ThreadType_MIN = ChromeThreadDescriptor_ThreadType_THREAD_UNSPECIFIED;
-  static constexpr auto ThreadType_MAX = ChromeThreadDescriptor_ThreadType_THREAD_SAMPLING_PROFILER;
-  enum FieldNumbers {
-    kThreadTypeFieldNumber = 1,
-    kLegacySortIndexFieldNumber = 2,
-  };
-
-  ChromeThreadDescriptor();
-  ~ChromeThreadDescriptor() override;
-  ChromeThreadDescriptor(ChromeThreadDescriptor&&) noexcept;
-  ChromeThreadDescriptor& operator=(ChromeThreadDescriptor&&);
-  ChromeThreadDescriptor(const ChromeThreadDescriptor&);
-  ChromeThreadDescriptor& operator=(const ChromeThreadDescriptor&);
-  bool operator==(const ChromeThreadDescriptor&) const;
-  bool operator!=(const ChromeThreadDescriptor& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_thread_type() const { return _has_field_[1]; }
-  ChromeThreadDescriptor_ThreadType thread_type() const { return thread_type_; }
-  void set_thread_type(ChromeThreadDescriptor_ThreadType value) { thread_type_ = value; _has_field_.set(1); }
-
-  bool has_legacy_sort_index() const { return _has_field_[2]; }
-  int32_t legacy_sort_index() const { return legacy_sort_index_; }
-  void set_legacy_sort_index(int32_t value) { legacy_sort_index_ = value; _has_field_.set(2); }
-
- private:
-  ChromeThreadDescriptor_ThreadType thread_type_{};
-  int32_t legacy_sort_index_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_THREAD_DESCRIPTOR_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_thread_descriptor.gen.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
 
-ChromeThreadDescriptor::ChromeThreadDescriptor() = default;
-ChromeThreadDescriptor::~ChromeThreadDescriptor() = default;
-ChromeThreadDescriptor::ChromeThreadDescriptor(const ChromeThreadDescriptor&) = default;
-ChromeThreadDescriptor& ChromeThreadDescriptor::operator=(const ChromeThreadDescriptor&) = default;
-ChromeThreadDescriptor::ChromeThreadDescriptor(ChromeThreadDescriptor&&) noexcept = default;
-ChromeThreadDescriptor& ChromeThreadDescriptor::operator=(ChromeThreadDescriptor&&) = default;
+TraceConfig_AndroidReportConfig::TraceConfig_AndroidReportConfig() = default;
+TraceConfig_AndroidReportConfig::~TraceConfig_AndroidReportConfig() = default;
+TraceConfig_AndroidReportConfig::TraceConfig_AndroidReportConfig(const TraceConfig_AndroidReportConfig&) = default;
+TraceConfig_AndroidReportConfig& TraceConfig_AndroidReportConfig::operator=(const TraceConfig_AndroidReportConfig&) = default;
+TraceConfig_AndroidReportConfig::TraceConfig_AndroidReportConfig(TraceConfig_AndroidReportConfig&&) noexcept = default;
+TraceConfig_AndroidReportConfig& TraceConfig_AndroidReportConfig::operator=(TraceConfig_AndroidReportConfig&&) = default;
 
-bool ChromeThreadDescriptor::operator==(const ChromeThreadDescriptor& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && thread_type_ == other.thread_type_
-   && legacy_sort_index_ == other.legacy_sort_index_;
+bool TraceConfig_AndroidReportConfig::operator==(const TraceConfig_AndroidReportConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(reporter_service_package_, other.reporter_service_package_)
+   && ::protozero::internal::gen_helpers::EqualsField(reporter_service_class_, other.reporter_service_class_)
+   && ::protozero::internal::gen_helpers::EqualsField(skip_report_, other.skip_report_)
+   && ::protozero::internal::gen_helpers::EqualsField(use_pipe_in_framework_for_testing_, other.use_pipe_in_framework_for_testing_);
 }
 
-bool ChromeThreadDescriptor::ParseFromArray(const void* raw, size_t size) {
+bool TraceConfig_AndroidReportConfig::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -33575,11 +28862,17 @@ bool ChromeThreadDescriptor::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* thread_type */:
-        field.get(&thread_type_);
+      case 1 /* reporter_service_package */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &reporter_service_package_);
         break;
-      case 2 /* legacy_sort_index */:
-        field.get(&legacy_sort_index_);
+      case 2 /* reporter_service_class */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &reporter_service_class_);
+        break;
+      case 3 /* skip_report */:
+        field.get(&skip_report_);
+        break;
+      case 4 /* use_pipe_in_framework_for_testing */:
+        field.get(&use_pipe_in_framework_for_testing_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -33589,145 +28882,60 @@ bool ChromeThreadDescriptor::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ChromeThreadDescriptor::SerializeAsString() const {
+std::string TraceConfig_AndroidReportConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ChromeThreadDescriptor::SerializeAsArray() const {
+std::vector<uint8_t> TraceConfig_AndroidReportConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ChromeThreadDescriptor::Serialize(::protozero::Message* msg) const {
-  // Field 1: thread_type
+void TraceConfig_AndroidReportConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: reporter_service_package
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, thread_type_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(1, reporter_service_package_, msg);
   }
 
-  // Field 2: legacy_sort_index
+  // Field 2: reporter_service_class
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, legacy_sort_index_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(2, reporter_service_class_, msg);
   }
 
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
-}
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_user_event.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_user_event.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_USER_EVENT_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_USER_EVENT_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeUserEvent;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT ChromeUserEvent : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kActionFieldNumber = 1,
-    kActionHashFieldNumber = 2,
-  };
-
-  ChromeUserEvent();
-  ~ChromeUserEvent() override;
-  ChromeUserEvent(ChromeUserEvent&&) noexcept;
-  ChromeUserEvent& operator=(ChromeUserEvent&&);
-  ChromeUserEvent(const ChromeUserEvent&);
-  ChromeUserEvent& operator=(const ChromeUserEvent&);
-  bool operator==(const ChromeUserEvent&) const;
-  bool operator!=(const ChromeUserEvent& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_action() const { return _has_field_[1]; }
-  const std::string& action() const { return action_; }
-  void set_action(const std::string& value) { action_ = value; _has_field_.set(1); }
-
-  bool has_action_hash() const { return _has_field_[2]; }
-  uint64_t action_hash() const { return action_hash_; }
-  void set_action_hash(uint64_t value) { action_hash_ = value; _has_field_.set(2); }
-
- private:
-  std::string action_{};
-  uint64_t action_hash_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
+  // Field 3: skip_report
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, skip_report_, msg);
+  }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  // Field 4: use_pipe_in_framework_for_testing
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(4, use_pipe_in_framework_for_testing_, msg);
+  }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_USER_EVENT_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_user_event.gen.h"
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
 
-ChromeUserEvent::ChromeUserEvent() = default;
-ChromeUserEvent::~ChromeUserEvent() = default;
-ChromeUserEvent::ChromeUserEvent(const ChromeUserEvent&) = default;
-ChromeUserEvent& ChromeUserEvent::operator=(const ChromeUserEvent&) = default;
-ChromeUserEvent::ChromeUserEvent(ChromeUserEvent&&) noexcept = default;
-ChromeUserEvent& ChromeUserEvent::operator=(ChromeUserEvent&&) = default;
+TraceConfig_TraceFilter::TraceConfig_TraceFilter() = default;
+TraceConfig_TraceFilter::~TraceConfig_TraceFilter() = default;
+TraceConfig_TraceFilter::TraceConfig_TraceFilter(const TraceConfig_TraceFilter&) = default;
+TraceConfig_TraceFilter& TraceConfig_TraceFilter::operator=(const TraceConfig_TraceFilter&) = default;
+TraceConfig_TraceFilter::TraceConfig_TraceFilter(TraceConfig_TraceFilter&&) noexcept = default;
+TraceConfig_TraceFilter& TraceConfig_TraceFilter::operator=(TraceConfig_TraceFilter&&) = default;
 
-bool ChromeUserEvent::operator==(const ChromeUserEvent& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && action_ == other.action_
-   && action_hash_ == other.action_hash_;
+bool TraceConfig_TraceFilter::operator==(const TraceConfig_TraceFilter& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(bytecode_, other.bytecode_)
+   && ::protozero::internal::gen_helpers::EqualsField(bytecode_v2_, other.bytecode_v2_)
+   && ::protozero::internal::gen_helpers::EqualsField(string_filter_chain_, other.string_filter_chain_)
+   && ::protozero::internal::gen_helpers::EqualsField(bytecode_overlay_v54_, other.bytecode_overlay_v54_)
+   && ::protozero::internal::gen_helpers::EqualsField(string_filter_chain_v54_, other.string_filter_chain_v54_);
 }
 
-bool ChromeUserEvent::ParseFromArray(const void* raw, size_t size) {
+bool TraceConfig_TraceFilter::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -33737,11 +28945,20 @@ bool ChromeUserEvent::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* action */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &action_);
+      case 1 /* bytecode */:
+        field.get(&bytecode_);
         break;
-      case 2 /* action_hash */:
-        field.get(&action_hash_);
+      case 2 /* bytecode_v2 */:
+        field.get(&bytecode_v2_);
+        break;
+      case 3 /* string_filter_chain */:
+        (*string_filter_chain_).ParseFromArray(field.data(), field.size());
+        break;
+      case 4 /* bytecode_overlay_v54 */:
+        field.get(&bytecode_overlay_v54_);
+        break;
+      case 5 /* string_filter_chain_v54 */:
+        (*string_filter_chain_v54_).ParseFromArray(field.data(), field.size());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -33751,152 +28968,126 @@ bool ChromeUserEvent::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ChromeUserEvent::SerializeAsString() const {
+std::string TraceConfig_TraceFilter::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ChromeUserEvent::SerializeAsArray() const {
+std::vector<uint8_t> TraceConfig_TraceFilter::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ChromeUserEvent::Serialize(::protozero::Message* msg) const {
-  // Field 1: action
+void TraceConfig_TraceFilter::Serialize(::protozero::Message* msg) const {
+  // Field 1: bytecode
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeString(1, action_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(1, bytecode_, msg);
   }
 
-  // Field 2: action_hash
+  // Field 2: bytecode_v2
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, action_hash_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(2, bytecode_v2_, msg);
   }
 
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
-}
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_window_handle_event_info.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_window_handle_event_info.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_WINDOW_HANDLE_EVENT_INFO_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_WINDOW_HANDLE_EVENT_INFO_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeWindowHandleEventInfo;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
+  // Field 3: string_filter_chain
+  if (_has_field_[3]) {
+    (*string_filter_chain_).Serialize(msg->BeginNestedMessage<::protozero::Message>(3));
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+  // Field 4: bytecode_overlay_v54
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeString(4, bytecode_overlay_v54_, msg);
+  }
 
-class PERFETTO_EXPORT_COMPONENT ChromeWindowHandleEventInfo : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kDpiFieldNumber = 1,
-    kMessageIdFieldNumber = 2,
-    kHwndPtrFieldNumber = 3,
-  };
+  // Field 5: string_filter_chain_v54
+  if (_has_field_[5]) {
+    (*string_filter_chain_v54_).Serialize(msg->BeginNestedMessage<::protozero::Message>(5));
+  }
 
-  ChromeWindowHandleEventInfo();
-  ~ChromeWindowHandleEventInfo() override;
-  ChromeWindowHandleEventInfo(ChromeWindowHandleEventInfo&&) noexcept;
-  ChromeWindowHandleEventInfo& operator=(ChromeWindowHandleEventInfo&&);
-  ChromeWindowHandleEventInfo(const ChromeWindowHandleEventInfo&);
-  ChromeWindowHandleEventInfo& operator=(const ChromeWindowHandleEventInfo&);
-  bool operator==(const ChromeWindowHandleEventInfo&) const;
-  bool operator!=(const ChromeWindowHandleEventInfo& other) const { return !(*this == other); }
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
 
-  bool has_dpi() const { return _has_field_[1]; }
-  uint32_t dpi() const { return dpi_; }
-  void set_dpi(uint32_t value) { dpi_ = value; _has_field_.set(1); }
+TraceConfig_TraceFilter_StringFilterChain::TraceConfig_TraceFilter_StringFilterChain() = default;
+TraceConfig_TraceFilter_StringFilterChain::~TraceConfig_TraceFilter_StringFilterChain() = default;
+TraceConfig_TraceFilter_StringFilterChain::TraceConfig_TraceFilter_StringFilterChain(const TraceConfig_TraceFilter_StringFilterChain&) = default;
+TraceConfig_TraceFilter_StringFilterChain& TraceConfig_TraceFilter_StringFilterChain::operator=(const TraceConfig_TraceFilter_StringFilterChain&) = default;
+TraceConfig_TraceFilter_StringFilterChain::TraceConfig_TraceFilter_StringFilterChain(TraceConfig_TraceFilter_StringFilterChain&&) noexcept = default;
+TraceConfig_TraceFilter_StringFilterChain& TraceConfig_TraceFilter_StringFilterChain::operator=(TraceConfig_TraceFilter_StringFilterChain&&) = default;
 
-  bool has_message_id() const { return _has_field_[2]; }
-  uint32_t message_id() const { return message_id_; }
-  void set_message_id(uint32_t value) { message_id_ = value; _has_field_.set(2); }
+bool TraceConfig_TraceFilter_StringFilterChain::operator==(const TraceConfig_TraceFilter_StringFilterChain& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(rules_, other.rules_);
+}
 
-  bool has_hwnd_ptr() const { return _has_field_[3]; }
-  uint64_t hwnd_ptr() const { return hwnd_ptr_; }
-  void set_hwnd_ptr(uint64_t value) { hwnd_ptr_ = value; _has_field_.set(3); }
+int TraceConfig_TraceFilter_StringFilterChain::rules_size() const { return static_cast<int>(rules_.size()); }
+void TraceConfig_TraceFilter_StringFilterChain::clear_rules() { rules_.clear(); }
+TraceConfig_TraceFilter_StringFilterRule* TraceConfig_TraceFilter_StringFilterChain::add_rules() { rules_.emplace_back(); return &rules_.back(); }
+bool TraceConfig_TraceFilter_StringFilterChain::ParseFromArray(const void* raw, size_t size) {
+  rules_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
 
- private:
-  uint32_t dpi_{};
-  uint32_t message_id_{};
-  uint64_t hwnd_ptr_{};
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* rules */:
+        rules_.emplace_back();
+        rules_.back().ParseFromArray(field.data(), field.size());
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+std::string TraceConfig_TraceFilter_StringFilterChain::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  std::bitset<4> _has_field_{};
-};
+std::vector<uint8_t> TraceConfig_TraceFilter_StringFilterChain::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+void TraceConfig_TraceFilter_StringFilterChain::Serialize(::protozero::Message* msg) const {
+  // Field 1: rules
+  for (auto& it : rules_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
+  }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_WINDOW_HANDLE_EVENT_INFO_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_window_handle_event_info.gen.h"
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
 
-ChromeWindowHandleEventInfo::ChromeWindowHandleEventInfo() = default;
-ChromeWindowHandleEventInfo::~ChromeWindowHandleEventInfo() = default;
-ChromeWindowHandleEventInfo::ChromeWindowHandleEventInfo(const ChromeWindowHandleEventInfo&) = default;
-ChromeWindowHandleEventInfo& ChromeWindowHandleEventInfo::operator=(const ChromeWindowHandleEventInfo&) = default;
-ChromeWindowHandleEventInfo::ChromeWindowHandleEventInfo(ChromeWindowHandleEventInfo&&) noexcept = default;
-ChromeWindowHandleEventInfo& ChromeWindowHandleEventInfo::operator=(ChromeWindowHandleEventInfo&&) = default;
+TraceConfig_TraceFilter_StringFilterRule::TraceConfig_TraceFilter_StringFilterRule() = default;
+TraceConfig_TraceFilter_StringFilterRule::~TraceConfig_TraceFilter_StringFilterRule() = default;
+TraceConfig_TraceFilter_StringFilterRule::TraceConfig_TraceFilter_StringFilterRule(const TraceConfig_TraceFilter_StringFilterRule&) = default;
+TraceConfig_TraceFilter_StringFilterRule& TraceConfig_TraceFilter_StringFilterRule::operator=(const TraceConfig_TraceFilter_StringFilterRule&) = default;
+TraceConfig_TraceFilter_StringFilterRule::TraceConfig_TraceFilter_StringFilterRule(TraceConfig_TraceFilter_StringFilterRule&&) noexcept = default;
+TraceConfig_TraceFilter_StringFilterRule& TraceConfig_TraceFilter_StringFilterRule::operator=(TraceConfig_TraceFilter_StringFilterRule&&) = default;
 
-bool ChromeWindowHandleEventInfo::operator==(const ChromeWindowHandleEventInfo& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && dpi_ == other.dpi_
-   && message_id_ == other.message_id_
-   && hwnd_ptr_ == other.hwnd_ptr_;
+bool TraceConfig_TraceFilter_StringFilterRule::operator==(const TraceConfig_TraceFilter_StringFilterRule& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(policy_, other.policy_)
+   && ::protozero::internal::gen_helpers::EqualsField(regex_pattern_, other.regex_pattern_)
+   && ::protozero::internal::gen_helpers::EqualsField(atrace_payload_starts_with_, other.atrace_payload_starts_with_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(semantic_type_, other.semantic_type_);
 }
 
-bool ChromeWindowHandleEventInfo::ParseFromArray(const void* raw, size_t size) {
+bool TraceConfig_TraceFilter_StringFilterRule::ParseFromArray(const void* raw, size_t size) {
+  semantic_type_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -33906,14 +29097,21 @@ bool ChromeWindowHandleEventInfo::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* dpi */:
-        field.get(&dpi_);
+      case 1 /* policy */:
+        field.get(&policy_);
         break;
-      case 2 /* message_id */:
-        field.get(&message_id_);
+      case 2 /* regex_pattern */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &regex_pattern_);
         break;
-      case 3 /* hwnd_ptr */:
-        field.get(&hwnd_ptr_);
+      case 3 /* atrace_payload_starts_with */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &atrace_payload_starts_with_);
+        break;
+      case 4 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+        break;
+      case 5 /* semantic_type */:
+        semantic_type_.emplace_back();
+        field.get(&semantic_type_.back());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -33923,79 +29121,65 @@ bool ChromeWindowHandleEventInfo::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ChromeWindowHandleEventInfo::SerializeAsString() const {
+std::string TraceConfig_TraceFilter_StringFilterRule::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ChromeWindowHandleEventInfo::SerializeAsArray() const {
+std::vector<uint8_t> TraceConfig_TraceFilter_StringFilterRule::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ChromeWindowHandleEventInfo::Serialize(::protozero::Message* msg) const {
-  // Field 1: dpi
+void TraceConfig_TraceFilter_StringFilterRule::Serialize(::protozero::Message* msg) const {
+  // Field 1: policy
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, dpi_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, policy_, msg);
   }
 
-  // Field 2: message_id
+  // Field 2: regex_pattern
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, message_id_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(2, regex_pattern_, msg);
   }
 
-  // Field 3: hwnd_ptr
+  // Field 3: atrace_payload_starts_with
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeFixed(3, hwnd_ptr_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(3, atrace_payload_starts_with_, msg);
+  }
+
+  // Field 4: name
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeString(4, name_, msg);
+  }
+
+  // Field 5: semantic_type
+  for (auto& it : semantic_type_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, it, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/counter_descriptor.gen.cc
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/counter_descriptor.gen.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
 
-CounterDescriptor::CounterDescriptor() = default;
-CounterDescriptor::~CounterDescriptor() = default;
-CounterDescriptor::CounterDescriptor(const CounterDescriptor&) = default;
-CounterDescriptor& CounterDescriptor::operator=(const CounterDescriptor&) = default;
-CounterDescriptor::CounterDescriptor(CounterDescriptor&&) noexcept = default;
-CounterDescriptor& CounterDescriptor::operator=(CounterDescriptor&&) = default;
+TraceConfig_IncidentReportConfig::TraceConfig_IncidentReportConfig() = default;
+TraceConfig_IncidentReportConfig::~TraceConfig_IncidentReportConfig() = default;
+TraceConfig_IncidentReportConfig::TraceConfig_IncidentReportConfig(const TraceConfig_IncidentReportConfig&) = default;
+TraceConfig_IncidentReportConfig& TraceConfig_IncidentReportConfig::operator=(const TraceConfig_IncidentReportConfig&) = default;
+TraceConfig_IncidentReportConfig::TraceConfig_IncidentReportConfig(TraceConfig_IncidentReportConfig&&) noexcept = default;
+TraceConfig_IncidentReportConfig& TraceConfig_IncidentReportConfig::operator=(TraceConfig_IncidentReportConfig&&) = default;
 
-bool CounterDescriptor::operator==(const CounterDescriptor& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && type_ == other.type_
-   && categories_ == other.categories_
-   && unit_ == other.unit_
-   && unit_name_ == other.unit_name_
-   && unit_multiplier_ == other.unit_multiplier_
-   && is_incremental_ == other.is_incremental_;
+bool TraceConfig_IncidentReportConfig::operator==(const TraceConfig_IncidentReportConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(destination_package_, other.destination_package_)
+   && ::protozero::internal::gen_helpers::EqualsField(destination_class_, other.destination_class_)
+   && ::protozero::internal::gen_helpers::EqualsField(privacy_level_, other.privacy_level_)
+   && ::protozero::internal::gen_helpers::EqualsField(skip_incidentd_, other.skip_incidentd_)
+   && ::protozero::internal::gen_helpers::EqualsField(skip_dropbox_, other.skip_dropbox_);
 }
 
-bool CounterDescriptor::ParseFromArray(const void* raw, size_t size) {
-  categories_.clear();
+bool TraceConfig_IncidentReportConfig::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -34005,24 +29189,20 @@ bool CounterDescriptor::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* type */:
-        field.get(&type_);
-        break;
-      case 2 /* categories */:
-        categories_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &categories_.back());
+      case 1 /* destination_package */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &destination_package_);
         break;
-      case 3 /* unit */:
-        field.get(&unit_);
+      case 2 /* destination_class */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &destination_class_);
         break;
-      case 6 /* unit_name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &unit_name_);
+      case 3 /* privacy_level */:
+        field.get(&privacy_level_);
         break;
-      case 4 /* unit_multiplier */:
-        field.get(&unit_multiplier_);
+      case 5 /* skip_incidentd */:
+        field.get(&skip_incidentd_);
         break;
-      case 5 /* is_incremental */:
-        field.get(&is_incremental_);
+      case 4 /* skip_dropbox */:
+        field.get(&skip_dropbox_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -34032,436 +29212,207 @@ bool CounterDescriptor::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string CounterDescriptor::SerializeAsString() const {
+std::string TraceConfig_IncidentReportConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> CounterDescriptor::SerializeAsArray() const {
+std::vector<uint8_t> TraceConfig_IncidentReportConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void CounterDescriptor::Serialize(::protozero::Message* msg) const {
-  // Field 1: type
+void TraceConfig_IncidentReportConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: destination_package
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, type_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(1, destination_package_, msg);
   }
 
-  // Field 2: categories
-  for (auto& it : categories_) {
-    ::protozero::internal::gen_helpers::SerializeString(2, it, msg);
+  // Field 2: destination_class
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeString(2, destination_class_, msg);
   }
 
-  // Field 3: unit
+  // Field 3: privacy_level
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, unit_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, privacy_level_, msg);
   }
 
-  // Field 6: unit_name
-  if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeString(6, unit_name_, msg);
+  // Field 5: skip_incidentd
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, skip_incidentd_, msg);
   }
 
-  // Field 4: unit_multiplier
+  // Field 4: skip_dropbox
   if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, unit_multiplier_, msg);
-  }
-
-  // Field 5: is_incremental
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, is_incremental_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(4, skip_dropbox_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/debug_annotation.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/debug_annotation.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_DEBUG_ANNOTATION_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_DEBUG_ANNOTATION_PROTO_CPP_H_
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+TraceConfig_IncrementalStateConfig::TraceConfig_IncrementalStateConfig() = default;
+TraceConfig_IncrementalStateConfig::~TraceConfig_IncrementalStateConfig() = default;
+TraceConfig_IncrementalStateConfig::TraceConfig_IncrementalStateConfig(const TraceConfig_IncrementalStateConfig&) = default;
+TraceConfig_IncrementalStateConfig& TraceConfig_IncrementalStateConfig::operator=(const TraceConfig_IncrementalStateConfig&) = default;
+TraceConfig_IncrementalStateConfig::TraceConfig_IncrementalStateConfig(TraceConfig_IncrementalStateConfig&&) noexcept = default;
+TraceConfig_IncrementalStateConfig& TraceConfig_IncrementalStateConfig::operator=(TraceConfig_IncrementalStateConfig&&) = default;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+bool TraceConfig_IncrementalStateConfig::operator==(const TraceConfig_IncrementalStateConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(clear_period_ms_, other.clear_period_ms_);
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class DebugAnnotationValueTypeName;
-class DebugAnnotationName;
-class DebugAnnotation;
-class DebugAnnotation_NestedValue;
-enum DebugAnnotation_NestedValue_NestedType : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+bool TraceConfig_IncrementalStateConfig::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* clear_period_ms */:
+        field.get(&clear_period_ms_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum DebugAnnotation_NestedValue_NestedType : int {
-  DebugAnnotation_NestedValue_NestedType_UNSPECIFIED = 0,
-  DebugAnnotation_NestedValue_NestedType_DICT = 1,
-  DebugAnnotation_NestedValue_NestedType_ARRAY = 2,
-};
+std::string TraceConfig_IncrementalStateConfig::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-class PERFETTO_EXPORT_COMPONENT DebugAnnotationValueTypeName : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kIidFieldNumber = 1,
-    kNameFieldNumber = 2,
-  };
-
-  DebugAnnotationValueTypeName();
-  ~DebugAnnotationValueTypeName() override;
-  DebugAnnotationValueTypeName(DebugAnnotationValueTypeName&&) noexcept;
-  DebugAnnotationValueTypeName& operator=(DebugAnnotationValueTypeName&&);
-  DebugAnnotationValueTypeName(const DebugAnnotationValueTypeName&);
-  DebugAnnotationValueTypeName& operator=(const DebugAnnotationValueTypeName&);
-  bool operator==(const DebugAnnotationValueTypeName&) const;
-  bool operator!=(const DebugAnnotationValueTypeName& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_iid() const { return _has_field_[1]; }
-  uint64_t iid() const { return iid_; }
-  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
-
-  bool has_name() const { return _has_field_[2]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
-
- private:
-  uint64_t iid_{};
-  std::string name_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT DebugAnnotationName : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kIidFieldNumber = 1,
-    kNameFieldNumber = 2,
-  };
-
-  DebugAnnotationName();
-  ~DebugAnnotationName() override;
-  DebugAnnotationName(DebugAnnotationName&&) noexcept;
-  DebugAnnotationName& operator=(DebugAnnotationName&&);
-  DebugAnnotationName(const DebugAnnotationName&);
-  DebugAnnotationName& operator=(const DebugAnnotationName&);
-  bool operator==(const DebugAnnotationName&) const;
-  bool operator!=(const DebugAnnotationName& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_iid() const { return _has_field_[1]; }
-  uint64_t iid() const { return iid_; }
-  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
+std::vector<uint8_t> TraceConfig_IncrementalStateConfig::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  bool has_name() const { return _has_field_[2]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
+void TraceConfig_IncrementalStateConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: clear_period_ms
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, clear_period_ms_, msg);
+  }
 
- private:
-  uint64_t iid_{};
-  std::string name_{};
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
 
-  std::bitset<3> _has_field_{};
-};
+TraceConfig_TriggerConfig::TraceConfig_TriggerConfig() = default;
+TraceConfig_TriggerConfig::~TraceConfig_TriggerConfig() = default;
+TraceConfig_TriggerConfig::TraceConfig_TriggerConfig(const TraceConfig_TriggerConfig&) = default;
+TraceConfig_TriggerConfig& TraceConfig_TriggerConfig::operator=(const TraceConfig_TriggerConfig&) = default;
+TraceConfig_TriggerConfig::TraceConfig_TriggerConfig(TraceConfig_TriggerConfig&&) noexcept = default;
+TraceConfig_TriggerConfig& TraceConfig_TriggerConfig::operator=(TraceConfig_TriggerConfig&&) = default;
 
+bool TraceConfig_TriggerConfig::operator==(const TraceConfig_TriggerConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(trigger_mode_, other.trigger_mode_)
+   && ::protozero::internal::gen_helpers::EqualsField(use_clone_snapshot_if_available_, other.use_clone_snapshot_if_available_)
+   && ::protozero::internal::gen_helpers::EqualsField(triggers_, other.triggers_)
+   && ::protozero::internal::gen_helpers::EqualsField(trigger_timeout_ms_, other.trigger_timeout_ms_);
+}
 
-class PERFETTO_EXPORT_COMPONENT DebugAnnotation : public ::protozero::CppMessageObj {
- public:
-  using NestedValue = DebugAnnotation_NestedValue;
-  enum FieldNumbers {
-    kNameIidFieldNumber = 1,
-    kNameFieldNumber = 10,
-    kBoolValueFieldNumber = 2,
-    kUintValueFieldNumber = 3,
-    kIntValueFieldNumber = 4,
-    kDoubleValueFieldNumber = 5,
-    kPointerValueFieldNumber = 7,
-    kNestedValueFieldNumber = 8,
-    kLegacyJsonValueFieldNumber = 9,
-    kStringValueFieldNumber = 6,
-    kStringValueIidFieldNumber = 17,
-    kProtoTypeNameFieldNumber = 16,
-    kProtoTypeNameIidFieldNumber = 13,
-    kProtoValueFieldNumber = 14,
-    kDictEntriesFieldNumber = 11,
-    kArrayValuesFieldNumber = 12,
-  };
+int TraceConfig_TriggerConfig::triggers_size() const { return static_cast<int>(triggers_.size()); }
+void TraceConfig_TriggerConfig::clear_triggers() { triggers_.clear(); }
+TraceConfig_TriggerConfig_Trigger* TraceConfig_TriggerConfig::add_triggers() { triggers_.emplace_back(); return &triggers_.back(); }
+bool TraceConfig_TriggerConfig::ParseFromArray(const void* raw, size_t size) {
+  triggers_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  DebugAnnotation();
-  ~DebugAnnotation() override;
-  DebugAnnotation(DebugAnnotation&&) noexcept;
-  DebugAnnotation& operator=(DebugAnnotation&&);
-  DebugAnnotation(const DebugAnnotation&);
-  DebugAnnotation& operator=(const DebugAnnotation&);
-  bool operator==(const DebugAnnotation&) const;
-  bool operator!=(const DebugAnnotation& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_name_iid() const { return _has_field_[1]; }
-  uint64_t name_iid() const { return name_iid_; }
-  void set_name_iid(uint64_t value) { name_iid_ = value; _has_field_.set(1); }
-
-  bool has_name() const { return _has_field_[10]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(10); }
-
-  bool has_bool_value() const { return _has_field_[2]; }
-  bool bool_value() const { return bool_value_; }
-  void set_bool_value(bool value) { bool_value_ = value; _has_field_.set(2); }
-
-  bool has_uint_value() const { return _has_field_[3]; }
-  uint64_t uint_value() const { return uint_value_; }
-  void set_uint_value(uint64_t value) { uint_value_ = value; _has_field_.set(3); }
-
-  bool has_int_value() const { return _has_field_[4]; }
-  int64_t int_value() const { return int_value_; }
-  void set_int_value(int64_t value) { int_value_ = value; _has_field_.set(4); }
-
-  bool has_double_value() const { return _has_field_[5]; }
-  double double_value() const { return double_value_; }
-  void set_double_value(double value) { double_value_ = value; _has_field_.set(5); }
-
-  bool has_pointer_value() const { return _has_field_[7]; }
-  uint64_t pointer_value() const { return pointer_value_; }
-  void set_pointer_value(uint64_t value) { pointer_value_ = value; _has_field_.set(7); }
-
-  bool has_nested_value() const { return _has_field_[8]; }
-  const DebugAnnotation_NestedValue& nested_value() const { return *nested_value_; }
-  DebugAnnotation_NestedValue* mutable_nested_value() { _has_field_.set(8); return nested_value_.get(); }
-
-  bool has_legacy_json_value() const { return _has_field_[9]; }
-  const std::string& legacy_json_value() const { return legacy_json_value_; }
-  void set_legacy_json_value(const std::string& value) { legacy_json_value_ = value; _has_field_.set(9); }
-
-  bool has_string_value() const { return _has_field_[6]; }
-  const std::string& string_value() const { return string_value_; }
-  void set_string_value(const std::string& value) { string_value_ = value; _has_field_.set(6); }
-
-  bool has_string_value_iid() const { return _has_field_[17]; }
-  uint64_t string_value_iid() const { return string_value_iid_; }
-  void set_string_value_iid(uint64_t value) { string_value_iid_ = value; _has_field_.set(17); }
-
-  bool has_proto_type_name() const { return _has_field_[16]; }
-  const std::string& proto_type_name() const { return proto_type_name_; }
-  void set_proto_type_name(const std::string& value) { proto_type_name_ = value; _has_field_.set(16); }
-
-  bool has_proto_type_name_iid() const { return _has_field_[13]; }
-  uint64_t proto_type_name_iid() const { return proto_type_name_iid_; }
-  void set_proto_type_name_iid(uint64_t value) { proto_type_name_iid_ = value; _has_field_.set(13); }
-
-  bool has_proto_value() const { return _has_field_[14]; }
-  const std::string& proto_value() const { return proto_value_; }
-  void set_proto_value(const std::string& value) { proto_value_ = value; _has_field_.set(14); }
-  void set_proto_value(const void* p, size_t s) { proto_value_.assign(reinterpret_cast<const char*>(p), s); _has_field_.set(14); }
-
-  const std::vector<DebugAnnotation>& dict_entries() const { return dict_entries_; }
-  std::vector<DebugAnnotation>* mutable_dict_entries() { return &dict_entries_; }
-  int dict_entries_size() const;
-  void clear_dict_entries();
-  DebugAnnotation* add_dict_entries();
-
-  const std::vector<DebugAnnotation>& array_values() const { return array_values_; }
-  std::vector<DebugAnnotation>* mutable_array_values() { return &array_values_; }
-  int array_values_size() const;
-  void clear_array_values();
-  DebugAnnotation* add_array_values();
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* trigger_mode */:
+        field.get(&trigger_mode_);
+        break;
+      case 5 /* use_clone_snapshot_if_available */:
+        field.get(&use_clone_snapshot_if_available_);
+        break;
+      case 2 /* triggers */:
+        triggers_.emplace_back();
+        triggers_.back().ParseFromArray(field.data(), field.size());
+        break;
+      case 3 /* trigger_timeout_ms */:
+        field.get(&trigger_timeout_ms_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
- private:
-  uint64_t name_iid_{};
-  std::string name_{};
-  bool bool_value_{};
-  uint64_t uint_value_{};
-  int64_t int_value_{};
-  double double_value_{};
-  uint64_t pointer_value_{};
-  ::protozero::CopyablePtr<DebugAnnotation_NestedValue> nested_value_;
-  std::string legacy_json_value_{};
-  std::string string_value_{};
-  uint64_t string_value_iid_{};
-  std::string proto_type_name_{};
-  uint64_t proto_type_name_iid_{};
-  std::string proto_value_{};
-  std::vector<DebugAnnotation> dict_entries_;
-  std::vector<DebugAnnotation> array_values_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<18> _has_field_{};
-};
+std::string TraceConfig_TriggerConfig::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
+std::vector<uint8_t> TraceConfig_TriggerConfig::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-class PERFETTO_EXPORT_COMPONENT DebugAnnotation_NestedValue : public ::protozero::CppMessageObj {
- public:
-  using NestedType = DebugAnnotation_NestedValue_NestedType;
-  static constexpr auto UNSPECIFIED = DebugAnnotation_NestedValue_NestedType_UNSPECIFIED;
-  static constexpr auto DICT = DebugAnnotation_NestedValue_NestedType_DICT;
-  static constexpr auto ARRAY = DebugAnnotation_NestedValue_NestedType_ARRAY;
-  static constexpr auto NestedType_MIN = DebugAnnotation_NestedValue_NestedType_UNSPECIFIED;
-  static constexpr auto NestedType_MAX = DebugAnnotation_NestedValue_NestedType_ARRAY;
-  enum FieldNumbers {
-    kNestedTypeFieldNumber = 1,
-    kDictKeysFieldNumber = 2,
-    kDictValuesFieldNumber = 3,
-    kArrayValuesFieldNumber = 4,
-    kIntValueFieldNumber = 5,
-    kDoubleValueFieldNumber = 6,
-    kBoolValueFieldNumber = 7,
-    kStringValueFieldNumber = 8,
-  };
+void TraceConfig_TriggerConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: trigger_mode
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, trigger_mode_, msg);
+  }
 
-  DebugAnnotation_NestedValue();
-  ~DebugAnnotation_NestedValue() override;
-  DebugAnnotation_NestedValue(DebugAnnotation_NestedValue&&) noexcept;
-  DebugAnnotation_NestedValue& operator=(DebugAnnotation_NestedValue&&);
-  DebugAnnotation_NestedValue(const DebugAnnotation_NestedValue&);
-  DebugAnnotation_NestedValue& operator=(const DebugAnnotation_NestedValue&);
-  bool operator==(const DebugAnnotation_NestedValue&) const;
-  bool operator!=(const DebugAnnotation_NestedValue& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_nested_type() const { return _has_field_[1]; }
-  DebugAnnotation_NestedValue_NestedType nested_type() const { return nested_type_; }
-  void set_nested_type(DebugAnnotation_NestedValue_NestedType value) { nested_type_ = value; _has_field_.set(1); }
-
-  const std::vector<std::string>& dict_keys() const { return dict_keys_; }
-  std::vector<std::string>* mutable_dict_keys() { return &dict_keys_; }
-  int dict_keys_size() const { return static_cast<int>(dict_keys_.size()); }
-  void clear_dict_keys() { dict_keys_.clear(); }
-  void add_dict_keys(std::string value) { dict_keys_.emplace_back(value); }
-  std::string* add_dict_keys() { dict_keys_.emplace_back(); return &dict_keys_.back(); }
-
-  const std::vector<DebugAnnotation_NestedValue>& dict_values() const { return dict_values_; }
-  std::vector<DebugAnnotation_NestedValue>* mutable_dict_values() { return &dict_values_; }
-  int dict_values_size() const;
-  void clear_dict_values();
-  DebugAnnotation_NestedValue* add_dict_values();
-
-  const std::vector<DebugAnnotation_NestedValue>& array_values() const { return array_values_; }
-  std::vector<DebugAnnotation_NestedValue>* mutable_array_values() { return &array_values_; }
-  int array_values_size() const;
-  void clear_array_values();
-  DebugAnnotation_NestedValue* add_array_values();
-
-  bool has_int_value() const { return _has_field_[5]; }
-  int64_t int_value() const { return int_value_; }
-  void set_int_value(int64_t value) { int_value_ = value; _has_field_.set(5); }
-
-  bool has_double_value() const { return _has_field_[6]; }
-  double double_value() const { return double_value_; }
-  void set_double_value(double value) { double_value_ = value; _has_field_.set(6); }
-
-  bool has_bool_value() const { return _has_field_[7]; }
-  bool bool_value() const { return bool_value_; }
-  void set_bool_value(bool value) { bool_value_ = value; _has_field_.set(7); }
-
-  bool has_string_value() const { return _has_field_[8]; }
-  const std::string& string_value() const { return string_value_; }
-  void set_string_value(const std::string& value) { string_value_ = value; _has_field_.set(8); }
+  // Field 5: use_clone_snapshot_if_available
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, use_clone_snapshot_if_available_, msg);
+  }
 
- private:
-  DebugAnnotation_NestedValue_NestedType nested_type_{};
-  std::vector<std::string> dict_keys_;
-  std::vector<DebugAnnotation_NestedValue> dict_values_;
-  std::vector<DebugAnnotation_NestedValue> array_values_;
-  int64_t int_value_{};
-  double double_value_{};
-  bool bool_value_{};
-  std::string string_value_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<9> _has_field_{};
-};
+  // Field 2: triggers
+  for (auto& it : triggers_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
+  }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  // Field 3: trigger_timeout_ms
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, trigger_timeout_ms_, msg);
+  }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_DEBUG_ANNOTATION_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/debug_annotation.gen.h"
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
 
-DebugAnnotationValueTypeName::DebugAnnotationValueTypeName() = default;
-DebugAnnotationValueTypeName::~DebugAnnotationValueTypeName() = default;
-DebugAnnotationValueTypeName::DebugAnnotationValueTypeName(const DebugAnnotationValueTypeName&) = default;
-DebugAnnotationValueTypeName& DebugAnnotationValueTypeName::operator=(const DebugAnnotationValueTypeName&) = default;
-DebugAnnotationValueTypeName::DebugAnnotationValueTypeName(DebugAnnotationValueTypeName&&) noexcept = default;
-DebugAnnotationValueTypeName& DebugAnnotationValueTypeName::operator=(DebugAnnotationValueTypeName&&) = default;
+TraceConfig_TriggerConfig_Trigger::TraceConfig_TriggerConfig_Trigger() = default;
+TraceConfig_TriggerConfig_Trigger::~TraceConfig_TriggerConfig_Trigger() = default;
+TraceConfig_TriggerConfig_Trigger::TraceConfig_TriggerConfig_Trigger(const TraceConfig_TriggerConfig_Trigger&) = default;
+TraceConfig_TriggerConfig_Trigger& TraceConfig_TriggerConfig_Trigger::operator=(const TraceConfig_TriggerConfig_Trigger&) = default;
+TraceConfig_TriggerConfig_Trigger::TraceConfig_TriggerConfig_Trigger(TraceConfig_TriggerConfig_Trigger&&) noexcept = default;
+TraceConfig_TriggerConfig_Trigger& TraceConfig_TriggerConfig_Trigger::operator=(TraceConfig_TriggerConfig_Trigger&&) = default;
 
-bool DebugAnnotationValueTypeName::operator==(const DebugAnnotationValueTypeName& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && iid_ == other.iid_
-   && name_ == other.name_;
+bool TraceConfig_TriggerConfig_Trigger::operator==(const TraceConfig_TriggerConfig_Trigger& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(producer_name_regex_, other.producer_name_regex_)
+   && ::protozero::internal::gen_helpers::EqualsField(stop_delay_ms_, other.stop_delay_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(max_per_24_h_, other.max_per_24_h_)
+   && ::protozero::internal::gen_helpers::EqualsField(skip_probability_, other.skip_probability_);
 }
 
-bool DebugAnnotationValueTypeName::ParseFromArray(const void* raw, size_t size) {
+bool TraceConfig_TriggerConfig_Trigger::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -34471,12 +29422,21 @@ bool DebugAnnotationValueTypeName::ParseFromArray(const void* raw, size_t size)
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* iid */:
-        field.get(&iid_);
-        break;
-      case 2 /* name */:
+      case 1 /* name */:
         ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
         break;
+      case 2 /* producer_name_regex */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &producer_name_regex_);
+        break;
+      case 3 /* stop_delay_ms */:
+        field.get(&stop_delay_ms_);
+        break;
+      case 4 /* max_per_24_h */:
+        field.get(&max_per_24_h_);
+        break;
+      case 5 /* skip_probability */:
+        field.get(&skip_probability_);
+        break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
         break;
@@ -34485,47 +29445,62 @@ bool DebugAnnotationValueTypeName::ParseFromArray(const void* raw, size_t size)
   return !packed_error && !dec.bytes_left();
 }
 
-std::string DebugAnnotationValueTypeName::SerializeAsString() const {
+std::string TraceConfig_TriggerConfig_Trigger::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> DebugAnnotationValueTypeName::SerializeAsArray() const {
+std::vector<uint8_t> TraceConfig_TriggerConfig_Trigger::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void DebugAnnotationValueTypeName::Serialize(::protozero::Message* msg) const {
-  // Field 1: iid
+void TraceConfig_TriggerConfig_Trigger::Serialize(::protozero::Message* msg) const {
+  // Field 1: name
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, iid_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
   }
 
-  // Field 2: name
+  // Field 2: producer_name_regex
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeString(2, name_, msg);
+    ::protozero::internal::gen_helpers::SerializeString(2, producer_name_regex_, msg);
+  }
+
+  // Field 3: stop_delay_ms
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, stop_delay_ms_, msg);
+  }
+
+  // Field 4: max_per_24_h
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, max_per_24_h_, msg);
+  }
+
+  // Field 5: skip_probability
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeFixed(5, skip_probability_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-DebugAnnotationName::DebugAnnotationName() = default;
-DebugAnnotationName::~DebugAnnotationName() = default;
-DebugAnnotationName::DebugAnnotationName(const DebugAnnotationName&) = default;
-DebugAnnotationName& DebugAnnotationName::operator=(const DebugAnnotationName&) = default;
-DebugAnnotationName::DebugAnnotationName(DebugAnnotationName&&) noexcept = default;
-DebugAnnotationName& DebugAnnotationName::operator=(DebugAnnotationName&&) = default;
+TraceConfig_GuardrailOverrides::TraceConfig_GuardrailOverrides() = default;
+TraceConfig_GuardrailOverrides::~TraceConfig_GuardrailOverrides() = default;
+TraceConfig_GuardrailOverrides::TraceConfig_GuardrailOverrides(const TraceConfig_GuardrailOverrides&) = default;
+TraceConfig_GuardrailOverrides& TraceConfig_GuardrailOverrides::operator=(const TraceConfig_GuardrailOverrides&) = default;
+TraceConfig_GuardrailOverrides::TraceConfig_GuardrailOverrides(TraceConfig_GuardrailOverrides&&) noexcept = default;
+TraceConfig_GuardrailOverrides& TraceConfig_GuardrailOverrides::operator=(TraceConfig_GuardrailOverrides&&) = default;
 
-bool DebugAnnotationName::operator==(const DebugAnnotationName& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && iid_ == other.iid_
-   && name_ == other.name_;
+bool TraceConfig_GuardrailOverrides::operator==(const TraceConfig_GuardrailOverrides& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(max_upload_per_day_bytes_, other.max_upload_per_day_bytes_)
+   && ::protozero::internal::gen_helpers::EqualsField(max_tracing_buffer_size_kb_, other.max_tracing_buffer_size_kb_);
 }
 
-bool DebugAnnotationName::ParseFromArray(const void* raw, size_t size) {
+bool TraceConfig_GuardrailOverrides::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -34535,11 +29510,11 @@ bool DebugAnnotationName::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* iid */:
-        field.get(&iid_);
+      case 1 /* max_upload_per_day_bytes */:
+        field.get(&max_upload_per_day_bytes_);
         break;
-      case 2 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+      case 2 /* max_tracing_buffer_size_kb */:
+        field.get(&max_tracing_buffer_size_kb_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -34549,69 +29524,49 @@ bool DebugAnnotationName::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string DebugAnnotationName::SerializeAsString() const {
+std::string TraceConfig_GuardrailOverrides::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> DebugAnnotationName::SerializeAsArray() const {
+std::vector<uint8_t> TraceConfig_GuardrailOverrides::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void DebugAnnotationName::Serialize(::protozero::Message* msg) const {
-  // Field 1: iid
+void TraceConfig_GuardrailOverrides::Serialize(::protozero::Message* msg) const {
+  // Field 1: max_upload_per_day_bytes
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, iid_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, max_upload_per_day_bytes_, msg);
   }
 
-  // Field 2: name
+  // Field 2: max_tracing_buffer_size_kb
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeString(2, name_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, max_tracing_buffer_size_kb_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-DebugAnnotation::DebugAnnotation() = default;
-DebugAnnotation::~DebugAnnotation() = default;
-DebugAnnotation::DebugAnnotation(const DebugAnnotation&) = default;
-DebugAnnotation& DebugAnnotation::operator=(const DebugAnnotation&) = default;
-DebugAnnotation::DebugAnnotation(DebugAnnotation&&) noexcept = default;
-DebugAnnotation& DebugAnnotation::operator=(DebugAnnotation&&) = default;
+TraceConfig_StatsdMetadata::TraceConfig_StatsdMetadata() = default;
+TraceConfig_StatsdMetadata::~TraceConfig_StatsdMetadata() = default;
+TraceConfig_StatsdMetadata::TraceConfig_StatsdMetadata(const TraceConfig_StatsdMetadata&) = default;
+TraceConfig_StatsdMetadata& TraceConfig_StatsdMetadata::operator=(const TraceConfig_StatsdMetadata&) = default;
+TraceConfig_StatsdMetadata::TraceConfig_StatsdMetadata(TraceConfig_StatsdMetadata&&) noexcept = default;
+TraceConfig_StatsdMetadata& TraceConfig_StatsdMetadata::operator=(TraceConfig_StatsdMetadata&&) = default;
 
-bool DebugAnnotation::operator==(const DebugAnnotation& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && name_iid_ == other.name_iid_
-   && name_ == other.name_
-   && bool_value_ == other.bool_value_
-   && uint_value_ == other.uint_value_
-   && int_value_ == other.int_value_
-   && double_value_ == other.double_value_
-   && pointer_value_ == other.pointer_value_
-   && nested_value_ == other.nested_value_
-   && legacy_json_value_ == other.legacy_json_value_
-   && string_value_ == other.string_value_
-   && string_value_iid_ == other.string_value_iid_
-   && proto_type_name_ == other.proto_type_name_
-   && proto_type_name_iid_ == other.proto_type_name_iid_
-   && proto_value_ == other.proto_value_
-   && dict_entries_ == other.dict_entries_
-   && array_values_ == other.array_values_;
+bool TraceConfig_StatsdMetadata::operator==(const TraceConfig_StatsdMetadata& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(triggering_alert_id_, other.triggering_alert_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(triggering_config_uid_, other.triggering_config_uid_)
+   && ::protozero::internal::gen_helpers::EqualsField(triggering_config_id_, other.triggering_config_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(triggering_subscription_id_, other.triggering_subscription_id_);
 }
 
-int DebugAnnotation::dict_entries_size() const { return static_cast<int>(dict_entries_.size()); }
-void DebugAnnotation::clear_dict_entries() { dict_entries_.clear(); }
-DebugAnnotation* DebugAnnotation::add_dict_entries() { dict_entries_.emplace_back(); return &dict_entries_.back(); }
-int DebugAnnotation::array_values_size() const { return static_cast<int>(array_values_.size()); }
-void DebugAnnotation::clear_array_values() { array_values_.clear(); }
-DebugAnnotation* DebugAnnotation::add_array_values() { array_values_.emplace_back(); return &array_values_.back(); }
-bool DebugAnnotation::ParseFromArray(const void* raw, size_t size) {
-  dict_entries_.clear();
-  array_values_.clear();
+bool TraceConfig_StatsdMetadata::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -34621,55 +29576,17 @@ bool DebugAnnotation::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* name_iid */:
-        field.get(&name_iid_);
-        break;
-      case 10 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
-        break;
-      case 2 /* bool_value */:
-        field.get(&bool_value_);
-        break;
-      case 3 /* uint_value */:
-        field.get(&uint_value_);
-        break;
-      case 4 /* int_value */:
-        field.get(&int_value_);
-        break;
-      case 5 /* double_value */:
-        field.get(&double_value_);
-        break;
-      case 7 /* pointer_value */:
-        field.get(&pointer_value_);
-        break;
-      case 8 /* nested_value */:
-        (*nested_value_).ParseFromArray(field.data(), field.size());
-        break;
-      case 9 /* legacy_json_value */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &legacy_json_value_);
-        break;
-      case 6 /* string_value */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &string_value_);
-        break;
-      case 17 /* string_value_iid */:
-        field.get(&string_value_iid_);
-        break;
-      case 16 /* proto_type_name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &proto_type_name_);
-        break;
-      case 13 /* proto_type_name_iid */:
-        field.get(&proto_type_name_iid_);
+      case 1 /* triggering_alert_id */:
+        field.get(&triggering_alert_id_);
         break;
-      case 14 /* proto_value */:
-        field.get(&proto_value_);
+      case 2 /* triggering_config_uid */:
+        field.get(&triggering_config_uid_);
         break;
-      case 11 /* dict_entries */:
-        dict_entries_.emplace_back();
-        dict_entries_.back().ParseFromArray(field.data(), field.size());
+      case 3 /* triggering_config_id */:
+        field.get(&triggering_config_id_);
         break;
-      case 12 /* array_values */:
-        array_values_.emplace_back();
-        array_values_.back().ParseFromArray(field.data(), field.size());
+      case 4 /* triggering_subscription_id */:
+        field.get(&triggering_subscription_id_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -34679,132 +29596,136 @@ bool DebugAnnotation::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string DebugAnnotation::SerializeAsString() const {
+std::string TraceConfig_StatsdMetadata::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> DebugAnnotation::SerializeAsArray() const {
+std::vector<uint8_t> TraceConfig_StatsdMetadata::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void DebugAnnotation::Serialize(::protozero::Message* msg) const {
-  // Field 1: name_iid
+void TraceConfig_StatsdMetadata::Serialize(::protozero::Message* msg) const {
+  // Field 1: triggering_alert_id
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, name_iid_, msg);
-  }
-
-  // Field 10: name
-  if (_has_field_[10]) {
-    ::protozero::internal::gen_helpers::SerializeString(10, name_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, triggering_alert_id_, msg);
   }
 
-  // Field 2: bool_value
+  // Field 2: triggering_config_uid
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, bool_value_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, triggering_config_uid_, msg);
   }
 
-  // Field 3: uint_value
+  // Field 3: triggering_config_id
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, uint_value_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, triggering_config_id_, msg);
   }
 
-  // Field 4: int_value
+  // Field 4: triggering_subscription_id
   if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, int_value_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, triggering_subscription_id_, msg);
   }
 
-  // Field 5: double_value
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeFixed(5, double_value_, msg);
-  }
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  // Field 7: pointer_value
-  if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(7, pointer_value_, msg);
-  }
 
-  // Field 8: nested_value
-  if (_has_field_[8]) {
-    (*nested_value_).Serialize(msg->BeginNestedMessage<::protozero::Message>(8));
-  }
+TraceConfig_ProducerConfig::TraceConfig_ProducerConfig() = default;
+TraceConfig_ProducerConfig::~TraceConfig_ProducerConfig() = default;
+TraceConfig_ProducerConfig::TraceConfig_ProducerConfig(const TraceConfig_ProducerConfig&) = default;
+TraceConfig_ProducerConfig& TraceConfig_ProducerConfig::operator=(const TraceConfig_ProducerConfig&) = default;
+TraceConfig_ProducerConfig::TraceConfig_ProducerConfig(TraceConfig_ProducerConfig&&) noexcept = default;
+TraceConfig_ProducerConfig& TraceConfig_ProducerConfig::operator=(TraceConfig_ProducerConfig&&) = default;
 
-  // Field 9: legacy_json_value
-  if (_has_field_[9]) {
-    ::protozero::internal::gen_helpers::SerializeString(9, legacy_json_value_, msg);
-  }
+bool TraceConfig_ProducerConfig::operator==(const TraceConfig_ProducerConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(producer_name_, other.producer_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(shm_size_kb_, other.shm_size_kb_)
+   && ::protozero::internal::gen_helpers::EqualsField(page_size_kb_, other.page_size_kb_);
+}
 
-  // Field 6: string_value
-  if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeString(6, string_value_, msg);
-  }
+bool TraceConfig_ProducerConfig::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  // Field 17: string_value_iid
-  if (_has_field_[17]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(17, string_value_iid_, msg);
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* producer_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &producer_name_);
+        break;
+      case 2 /* shm_size_kb */:
+        field.get(&shm_size_kb_);
+        break;
+      case 3 /* page_size_kb */:
+        field.get(&page_size_kb_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
   }
+  return !packed_error && !dec.bytes_left();
+}
 
-  // Field 16: proto_type_name
-  if (_has_field_[16]) {
-    ::protozero::internal::gen_helpers::SerializeString(16, proto_type_name_, msg);
-  }
+std::string TraceConfig_ProducerConfig::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  // Field 13: proto_type_name_iid
-  if (_has_field_[13]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(13, proto_type_name_iid_, msg);
-  }
+std::vector<uint8_t> TraceConfig_ProducerConfig::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  // Field 14: proto_value
-  if (_has_field_[14]) {
-    ::protozero::internal::gen_helpers::SerializeString(14, proto_value_, msg);
+void TraceConfig_ProducerConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: producer_name
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeString(1, producer_name_, msg);
   }
 
-  // Field 11: dict_entries
-  for (auto& it : dict_entries_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(11));
+  // Field 2: shm_size_kb
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, shm_size_kb_, msg);
   }
 
-  // Field 12: array_values
-  for (auto& it : array_values_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(12));
+  // Field 3: page_size_kb
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, page_size_kb_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-DebugAnnotation_NestedValue::DebugAnnotation_NestedValue() = default;
-DebugAnnotation_NestedValue::~DebugAnnotation_NestedValue() = default;
-DebugAnnotation_NestedValue::DebugAnnotation_NestedValue(const DebugAnnotation_NestedValue&) = default;
-DebugAnnotation_NestedValue& DebugAnnotation_NestedValue::operator=(const DebugAnnotation_NestedValue&) = default;
-DebugAnnotation_NestedValue::DebugAnnotation_NestedValue(DebugAnnotation_NestedValue&&) noexcept = default;
-DebugAnnotation_NestedValue& DebugAnnotation_NestedValue::operator=(DebugAnnotation_NestedValue&&) = default;
+TraceConfig_BuiltinDataSource::TraceConfig_BuiltinDataSource() = default;
+TraceConfig_BuiltinDataSource::~TraceConfig_BuiltinDataSource() = default;
+TraceConfig_BuiltinDataSource::TraceConfig_BuiltinDataSource(const TraceConfig_BuiltinDataSource&) = default;
+TraceConfig_BuiltinDataSource& TraceConfig_BuiltinDataSource::operator=(const TraceConfig_BuiltinDataSource&) = default;
+TraceConfig_BuiltinDataSource::TraceConfig_BuiltinDataSource(TraceConfig_BuiltinDataSource&&) noexcept = default;
+TraceConfig_BuiltinDataSource& TraceConfig_BuiltinDataSource::operator=(TraceConfig_BuiltinDataSource&&) = default;
 
-bool DebugAnnotation_NestedValue::operator==(const DebugAnnotation_NestedValue& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && nested_type_ == other.nested_type_
-   && dict_keys_ == other.dict_keys_
-   && dict_values_ == other.dict_values_
-   && array_values_ == other.array_values_
-   && int_value_ == other.int_value_
-   && double_value_ == other.double_value_
-   && bool_value_ == other.bool_value_
-   && string_value_ == other.string_value_;
+bool TraceConfig_BuiltinDataSource::operator==(const TraceConfig_BuiltinDataSource& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(disable_clock_snapshotting_, other.disable_clock_snapshotting_)
+   && ::protozero::internal::gen_helpers::EqualsField(disable_trace_config_, other.disable_trace_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(disable_system_info_, other.disable_system_info_)
+   && ::protozero::internal::gen_helpers::EqualsField(disable_service_events_, other.disable_service_events_)
+   && ::protozero::internal::gen_helpers::EqualsField(primary_trace_clock_, other.primary_trace_clock_)
+   && ::protozero::internal::gen_helpers::EqualsField(snapshot_interval_ms_, other.snapshot_interval_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(prefer_suspend_clock_for_snapshot_, other.prefer_suspend_clock_for_snapshot_)
+   && ::protozero::internal::gen_helpers::EqualsField(disable_chunk_usage_histograms_, other.disable_chunk_usage_histograms_);
 }
 
-int DebugAnnotation_NestedValue::dict_values_size() const { return static_cast<int>(dict_values_.size()); }
-void DebugAnnotation_NestedValue::clear_dict_values() { dict_values_.clear(); }
-DebugAnnotation_NestedValue* DebugAnnotation_NestedValue::add_dict_values() { dict_values_.emplace_back(); return &dict_values_.back(); }
-int DebugAnnotation_NestedValue::array_values_size() const { return static_cast<int>(array_values_.size()); }
-void DebugAnnotation_NestedValue::clear_array_values() { array_values_.clear(); }
-DebugAnnotation_NestedValue* DebugAnnotation_NestedValue::add_array_values() { array_values_.emplace_back(); return &array_values_.back(); }
-bool DebugAnnotation_NestedValue::ParseFromArray(const void* raw, size_t size) {
-  dict_keys_.clear();
-  dict_values_.clear();
-  array_values_.clear();
+bool TraceConfig_BuiltinDataSource::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -34814,32 +29735,29 @@ bool DebugAnnotation_NestedValue::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* nested_type */:
-        field.get(&nested_type_);
+      case 1 /* disable_clock_snapshotting */:
+        field.get(&disable_clock_snapshotting_);
         break;
-      case 2 /* dict_keys */:
-        dict_keys_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &dict_keys_.back());
+      case 2 /* disable_trace_config */:
+        field.get(&disable_trace_config_);
         break;
-      case 3 /* dict_values */:
-        dict_values_.emplace_back();
-        dict_values_.back().ParseFromArray(field.data(), field.size());
+      case 3 /* disable_system_info */:
+        field.get(&disable_system_info_);
         break;
-      case 4 /* array_values */:
-        array_values_.emplace_back();
-        array_values_.back().ParseFromArray(field.data(), field.size());
+      case 4 /* disable_service_events */:
+        field.get(&disable_service_events_);
         break;
-      case 5 /* int_value */:
-        field.get(&int_value_);
+      case 5 /* primary_trace_clock */:
+        field.get(&primary_trace_clock_);
         break;
-      case 6 /* double_value */:
-        field.get(&double_value_);
+      case 6 /* snapshot_interval_ms */:
+        field.get(&snapshot_interval_ms_);
         break;
-      case 7 /* bool_value */:
-        field.get(&bool_value_);
+      case 7 /* prefer_suspend_clock_for_snapshot */:
+        field.get(&prefer_suspend_clock_for_snapshot_);
         break;
-      case 8 /* string_value */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &string_value_);
+      case 8 /* disable_chunk_usage_histograms */:
+        field.get(&disable_chunk_usage_histograms_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -34849,217 +29767,82 @@ bool DebugAnnotation_NestedValue::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string DebugAnnotation_NestedValue::SerializeAsString() const {
+std::string TraceConfig_BuiltinDataSource::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> DebugAnnotation_NestedValue::SerializeAsArray() const {
+std::vector<uint8_t> TraceConfig_BuiltinDataSource::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void DebugAnnotation_NestedValue::Serialize(::protozero::Message* msg) const {
-  // Field 1: nested_type
+void TraceConfig_BuiltinDataSource::Serialize(::protozero::Message* msg) const {
+  // Field 1: disable_clock_snapshotting
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, nested_type_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(1, disable_clock_snapshotting_, msg);
   }
 
-  // Field 2: dict_keys
-  for (auto& it : dict_keys_) {
-    ::protozero::internal::gen_helpers::SerializeString(2, it, msg);
+  // Field 2: disable_trace_config
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, disable_trace_config_, msg);
   }
 
-  // Field 3: dict_values
-  for (auto& it : dict_values_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(3));
+  // Field 3: disable_system_info
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, disable_system_info_, msg);
   }
 
-  // Field 4: array_values
-  for (auto& it : array_values_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(4));
+  // Field 4: disable_service_events
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(4, disable_service_events_, msg);
   }
 
-  // Field 5: int_value
+  // Field 5: primary_trace_clock
   if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(5, int_value_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, primary_trace_clock_, msg);
   }
 
-  // Field 6: double_value
+  // Field 6: snapshot_interval_ms
   if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeFixed(6, double_value_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, snapshot_interval_ms_, msg);
   }
 
-  // Field 7: bool_value
+  // Field 7: prefer_suspend_clock_for_snapshot
   if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(7, bool_value_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(7, prefer_suspend_clock_for_snapshot_, msg);
   }
 
-  // Field 8: string_value
+  // Field 8: disable_chunk_usage_histograms
   if (_has_field_[8]) {
-    ::protozero::internal::gen_helpers::SerializeString(8, string_value_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(8, disable_chunk_usage_histograms_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/log_message.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/log_message.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_LOG_MESSAGE_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_LOG_MESSAGE_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class LogMessageBody;
-class LogMessage;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT LogMessageBody : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kIidFieldNumber = 1,
-    kBodyFieldNumber = 2,
-  };
-
-  LogMessageBody();
-  ~LogMessageBody() override;
-  LogMessageBody(LogMessageBody&&) noexcept;
-  LogMessageBody& operator=(LogMessageBody&&);
-  LogMessageBody(const LogMessageBody&);
-  LogMessageBody& operator=(const LogMessageBody&);
-  bool operator==(const LogMessageBody&) const;
-  bool operator!=(const LogMessageBody& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_iid() const { return _has_field_[1]; }
-  uint64_t iid() const { return iid_; }
-  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
-
-  bool has_body() const { return _has_field_[2]; }
-  const std::string& body() const { return body_; }
-  void set_body(const std::string& value) { body_ = value; _has_field_.set(2); }
-
- private:
-  uint64_t iid_{};
-  std::string body_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT LogMessage : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kSourceLocationIidFieldNumber = 1,
-    kBodyIidFieldNumber = 2,
-  };
-
-  LogMessage();
-  ~LogMessage() override;
-  LogMessage(LogMessage&&) noexcept;
-  LogMessage& operator=(LogMessage&&);
-  LogMessage(const LogMessage&);
-  LogMessage& operator=(const LogMessage&);
-  bool operator==(const LogMessage&) const;
-  bool operator!=(const LogMessage& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_source_location_iid() const { return _has_field_[1]; }
-  uint64_t source_location_iid() const { return source_location_iid_; }
-  void set_source_location_iid(uint64_t value) { source_location_iid_ = value; _has_field_.set(1); }
-
-  bool has_body_iid() const { return _has_field_[2]; }
-  uint64_t body_iid() const { return body_iid_; }
-  void set_body_iid(uint64_t value) { body_iid_ = value; _has_field_.set(2); }
-
- private:
-  uint64_t source_location_iid_{};
-  uint64_t body_iid_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_LOG_MESSAGE_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/log_message.gen.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
 
-LogMessageBody::LogMessageBody() = default;
-LogMessageBody::~LogMessageBody() = default;
-LogMessageBody::LogMessageBody(const LogMessageBody&) = default;
-LogMessageBody& LogMessageBody::operator=(const LogMessageBody&) = default;
-LogMessageBody::LogMessageBody(LogMessageBody&&) noexcept = default;
-LogMessageBody& LogMessageBody::operator=(LogMessageBody&&) = default;
+TraceConfig_DataSource::TraceConfig_DataSource() = default;
+TraceConfig_DataSource::~TraceConfig_DataSource() = default;
+TraceConfig_DataSource::TraceConfig_DataSource(const TraceConfig_DataSource&) = default;
+TraceConfig_DataSource& TraceConfig_DataSource::operator=(const TraceConfig_DataSource&) = default;
+TraceConfig_DataSource::TraceConfig_DataSource(TraceConfig_DataSource&&) noexcept = default;
+TraceConfig_DataSource& TraceConfig_DataSource::operator=(TraceConfig_DataSource&&) = default;
 
-bool LogMessageBody::operator==(const LogMessageBody& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && iid_ == other.iid_
-   && body_ == other.body_;
+bool TraceConfig_DataSource::operator==(const TraceConfig_DataSource& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(config_, other.config_)
+   && ::protozero::internal::gen_helpers::EqualsField(producer_name_filter_, other.producer_name_filter_)
+   && ::protozero::internal::gen_helpers::EqualsField(producer_name_regex_filter_, other.producer_name_regex_filter_)
+   && ::protozero::internal::gen_helpers::EqualsField(machine_name_filter_, other.machine_name_filter_);
 }
 
-bool LogMessageBody::ParseFromArray(const void* raw, size_t size) {
+bool TraceConfig_DataSource::ParseFromArray(const void* raw, size_t size) {
+  producer_name_filter_.clear();
+  producer_name_regex_filter_.clear();
+  machine_name_filter_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -35069,11 +29852,20 @@ bool LogMessageBody::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* iid */:
-        field.get(&iid_);
+      case 1 /* config */:
+        (*config_).ParseFromArray(field.data(), field.size());
         break;
-      case 2 /* body */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &body_);
+      case 2 /* producer_name_filter */:
+        producer_name_filter_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &producer_name_filter_.back());
+        break;
+      case 3 /* producer_name_regex_filter */:
+        producer_name_regex_filter_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &producer_name_regex_filter_.back());
+        break;
+      case 4 /* machine_name_filter */:
+        machine_name_filter_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &machine_name_filter_.back());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -35083,47 +29875,61 @@ bool LogMessageBody::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string LogMessageBody::SerializeAsString() const {
+std::string TraceConfig_DataSource::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> LogMessageBody::SerializeAsArray() const {
+std::vector<uint8_t> TraceConfig_DataSource::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void LogMessageBody::Serialize(::protozero::Message* msg) const {
-  // Field 1: iid
+void TraceConfig_DataSource::Serialize(::protozero::Message* msg) const {
+  // Field 1: config
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, iid_, msg);
+    (*config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
   }
 
-  // Field 2: body
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeString(2, body_, msg);
+  // Field 2: producer_name_filter
+  for (auto& it : producer_name_filter_) {
+    ::protozero::internal::gen_helpers::SerializeString(2, it, msg);
+  }
+
+  // Field 3: producer_name_regex_filter
+  for (auto& it : producer_name_regex_filter_) {
+    ::protozero::internal::gen_helpers::SerializeString(3, it, msg);
+  }
+
+  // Field 4: machine_name_filter
+  for (auto& it : machine_name_filter_) {
+    ::protozero::internal::gen_helpers::SerializeString(4, it, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-LogMessage::LogMessage() = default;
-LogMessage::~LogMessage() = default;
-LogMessage::LogMessage(const LogMessage&) = default;
-LogMessage& LogMessage::operator=(const LogMessage&) = default;
-LogMessage::LogMessage(LogMessage&&) noexcept = default;
-LogMessage& LogMessage::operator=(LogMessage&&) = default;
+TraceConfig_BufferConfig::TraceConfig_BufferConfig() = default;
+TraceConfig_BufferConfig::~TraceConfig_BufferConfig() = default;
+TraceConfig_BufferConfig::TraceConfig_BufferConfig(const TraceConfig_BufferConfig&) = default;
+TraceConfig_BufferConfig& TraceConfig_BufferConfig::operator=(const TraceConfig_BufferConfig&) = default;
+TraceConfig_BufferConfig::TraceConfig_BufferConfig(TraceConfig_BufferConfig&&) noexcept = default;
+TraceConfig_BufferConfig& TraceConfig_BufferConfig::operator=(TraceConfig_BufferConfig&&) = default;
 
-bool LogMessage::operator==(const LogMessage& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && source_location_iid_ == other.source_location_iid_
-   && body_iid_ == other.body_iid_;
+bool TraceConfig_BufferConfig::operator==(const TraceConfig_BufferConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(size_kb_, other.size_kb_)
+   && ::protozero::internal::gen_helpers::EqualsField(fill_policy_, other.fill_policy_)
+   && ::protozero::internal::gen_helpers::EqualsField(transfer_on_clone_, other.transfer_on_clone_)
+   && ::protozero::internal::gen_helpers::EqualsField(clear_before_clone_, other.clear_before_clone_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(experimental_mode_, other.experimental_mode_);
 }
 
-bool LogMessage::ParseFromArray(const void* raw, size_t size) {
+bool TraceConfig_BufferConfig::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -35133,11 +29939,23 @@ bool LogMessage::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* source_location_iid */:
-        field.get(&source_location_iid_);
+      case 1 /* size_kb */:
+        field.get(&size_kb_);
         break;
-      case 2 /* body_iid */:
-        field.get(&body_iid_);
+      case 4 /* fill_policy */:
+        field.get(&fill_policy_);
+        break;
+      case 5 /* transfer_on_clone */:
+        field.get(&transfer_on_clone_);
+        break;
+      case 6 /* clear_before_clone */:
+        field.get(&clear_before_clone_);
+        break;
+      case 7 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+        break;
+      case 8 /* experimental_mode */:
+        field.get(&experimental_mode_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -35147,27 +29965,47 @@ bool LogMessage::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string LogMessage::SerializeAsString() const {
+std::string TraceConfig_BufferConfig::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> LogMessage::SerializeAsArray() const {
+std::vector<uint8_t> TraceConfig_BufferConfig::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void LogMessage::Serialize(::protozero::Message* msg) const {
-  // Field 1: source_location_iid
+void TraceConfig_BufferConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: size_kb
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, source_location_iid_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, size_kb_, msg);
   }
 
-  // Field 2: body_iid
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, body_iid_, msg);
+  // Field 4: fill_policy
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, fill_policy_, msg);
+  }
+
+  // Field 5: transfer_on_clone
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, transfer_on_clone_, msg);
+  }
+
+  // Field 6: clear_before_clone
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(6, clear_before_clone_, msg);
+  }
+
+  // Field 7: name
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeString(7, name_, msg);
+  }
+
+  // Field 8: experimental_mode
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(8, experimental_mode_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -35179,149 +30017,181 @@ void LogMessage::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/process_descriptor.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/process_descriptor.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_PROCESS_DESCRIPTOR_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_PROCESS_DESCRIPTOR_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ProcessDescriptor;
-enum ProcessDescriptor_ChromeProcessType : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum ProcessDescriptor_ChromeProcessType : int {
-  ProcessDescriptor_ChromeProcessType_PROCESS_UNSPECIFIED = 0,
-  ProcessDescriptor_ChromeProcessType_PROCESS_BROWSER = 1,
-  ProcessDescriptor_ChromeProcessType_PROCESS_RENDERER = 2,
-  ProcessDescriptor_ChromeProcessType_PROCESS_UTILITY = 3,
-  ProcessDescriptor_ChromeProcessType_PROCESS_ZYGOTE = 4,
-  ProcessDescriptor_ChromeProcessType_PROCESS_SANDBOX_HELPER = 5,
-  ProcessDescriptor_ChromeProcessType_PROCESS_GPU = 6,
-  ProcessDescriptor_ChromeProcessType_PROCESS_PPAPI_PLUGIN = 7,
-  ProcessDescriptor_ChromeProcessType_PROCESS_PPAPI_BROKER = 8,
-};
-
-class PERFETTO_EXPORT_COMPONENT ProcessDescriptor : public ::protozero::CppMessageObj {
- public:
-  using ChromeProcessType = ProcessDescriptor_ChromeProcessType;
-  static constexpr auto PROCESS_UNSPECIFIED = ProcessDescriptor_ChromeProcessType_PROCESS_UNSPECIFIED;
-  static constexpr auto PROCESS_BROWSER = ProcessDescriptor_ChromeProcessType_PROCESS_BROWSER;
-  static constexpr auto PROCESS_RENDERER = ProcessDescriptor_ChromeProcessType_PROCESS_RENDERER;
-  static constexpr auto PROCESS_UTILITY = ProcessDescriptor_ChromeProcessType_PROCESS_UTILITY;
-  static constexpr auto PROCESS_ZYGOTE = ProcessDescriptor_ChromeProcessType_PROCESS_ZYGOTE;
-  static constexpr auto PROCESS_SANDBOX_HELPER = ProcessDescriptor_ChromeProcessType_PROCESS_SANDBOX_HELPER;
-  static constexpr auto PROCESS_GPU = ProcessDescriptor_ChromeProcessType_PROCESS_GPU;
-  static constexpr auto PROCESS_PPAPI_PLUGIN = ProcessDescriptor_ChromeProcessType_PROCESS_PPAPI_PLUGIN;
-  static constexpr auto PROCESS_PPAPI_BROKER = ProcessDescriptor_ChromeProcessType_PROCESS_PPAPI_BROKER;
-  static constexpr auto ChromeProcessType_MIN = ProcessDescriptor_ChromeProcessType_PROCESS_UNSPECIFIED;
-  static constexpr auto ChromeProcessType_MAX = ProcessDescriptor_ChromeProcessType_PROCESS_PPAPI_BROKER;
-  enum FieldNumbers {
-    kPidFieldNumber = 1,
-    kCmdlineFieldNumber = 2,
-    kProcessNameFieldNumber = 6,
-    kProcessPriorityFieldNumber = 5,
-    kStartTimestampNsFieldNumber = 7,
-    kChromeProcessTypeFieldNumber = 4,
-    kLegacySortIndexFieldNumber = 3,
-    kProcessLabelsFieldNumber = 8,
-  };
-
-  ProcessDescriptor();
-  ~ProcessDescriptor() override;
-  ProcessDescriptor(ProcessDescriptor&&) noexcept;
-  ProcessDescriptor& operator=(ProcessDescriptor&&);
-  ProcessDescriptor(const ProcessDescriptor&);
-  ProcessDescriptor& operator=(const ProcessDescriptor&);
-  bool operator==(const ProcessDescriptor&) const;
-  bool operator!=(const ProcessDescriptor& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_pid() const { return _has_field_[1]; }
-  int32_t pid() const { return pid_; }
-  void set_pid(int32_t value) { pid_ = value; _has_field_.set(1); }
-
-  const std::vector<std::string>& cmdline() const { return cmdline_; }
-  std::vector<std::string>* mutable_cmdline() { return &cmdline_; }
-  int cmdline_size() const { return static_cast<int>(cmdline_.size()); }
-  void clear_cmdline() { cmdline_.clear(); }
-  void add_cmdline(std::string value) { cmdline_.emplace_back(value); }
-  std::string* add_cmdline() { cmdline_.emplace_back(); return &cmdline_.back(); }
-
-  bool has_process_name() const { return _has_field_[6]; }
-  const std::string& process_name() const { return process_name_; }
-  void set_process_name(const std::string& value) { process_name_ = value; _has_field_.set(6); }
-
-  bool has_process_priority() const { return _has_field_[5]; }
-  int32_t process_priority() const { return process_priority_; }
-  void set_process_priority(int32_t value) { process_priority_ = value; _has_field_.set(5); }
-
-  bool has_start_timestamp_ns() const { return _has_field_[7]; }
-  int64_t start_timestamp_ns() const { return start_timestamp_ns_; }
-  void set_start_timestamp_ns(int64_t value) { start_timestamp_ns_ = value; _has_field_.set(7); }
-
-  bool has_chrome_process_type() const { return _has_field_[4]; }
-  ProcessDescriptor_ChromeProcessType chrome_process_type() const { return chrome_process_type_; }
-  void set_chrome_process_type(ProcessDescriptor_ChromeProcessType value) { chrome_process_type_ = value; _has_field_.set(4); }
-
-  bool has_legacy_sort_index() const { return _has_field_[3]; }
-  int32_t legacy_sort_index() const { return legacy_sort_index_; }
-  void set_legacy_sort_index(int32_t value) { legacy_sort_index_ = value; _has_field_.set(3); }
-
-  const std::vector<std::string>& process_labels() const { return process_labels_; }
-  std::vector<std::string>* mutable_process_labels() { return &process_labels_; }
-  int process_labels_size() const { return static_cast<int>(process_labels_.size()); }
-  void clear_process_labels() { process_labels_.clear(); }
-  void add_process_labels(std::string value) { process_labels_.emplace_back(value); }
-  std::string* add_process_labels() { process_labels_.emplace_back(); return &process_labels_.back(); }
-
- private:
-  int32_t pid_{};
-  std::vector<std::string> cmdline_;
-  std::string process_name_{};
-  int32_t process_priority_{};
-  int64_t start_timestamp_ns_{};
-  ProcessDescriptor_ChromeProcessType chrome_process_type_{};
-  int32_t legacy_sort_index_{};
-  std::vector<std::string> process_labels_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<9> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_PROCESS_DESCRIPTOR_PROTO_CPP_H_
+// gen_amalgamated begin source: gen/protos/perfetto/protovm/vm_program.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/common/android_energy_consumer_descriptor.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/common/android_log_constants.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/common/builtin_clock.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/common/commit_data_request.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/common/data_source_descriptor.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/common/descriptor.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/common/ftrace_descriptor.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/common/gpu_counter_descriptor.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/common/interceptor_descriptor.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/common/observable_events.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/common/perf_events.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/common/protolog_common.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/common/sys_stats_counters.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/common/system_info.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/common/trace_stats.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/common/tracing_service_capabilities.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/common/tracing_service_state.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/common/track_event_descriptor.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/graphics/insets.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/graphics/point.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/graphics/rect.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/winscope_extensions.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/protolog.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/shell_transition.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/surfaceflinger_common.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/surfaceflinger_layers.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/surfaceflinger_transactions.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/android_game_intervention_list.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/android_log.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/android_system_property.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/app_wakelock_data.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/bluetooth_trace.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/camera_event.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/cpu_per_uid_data.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/frame_timeline_event.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/gpu_mem_event.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/graphics_frame_event.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/initial_display_state.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/kernel_wakelock_data.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/network_trace.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/packages_list.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/pixel_modem_events.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/android/user_list.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/chrome/chrome_benchmark_metadata.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/chrome/chrome_metadata.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/chrome/chrome_trace_event.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/chrome/chrome_trigger.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/chrome/v8.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/gpu/gpu_counter_event.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/gpu/gpu_log.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/gpu/gpu_render_stage_event.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/gpu/vulkan_api_event.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/gpu/vulkan_memory_event.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/profiling/deobfuscation.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/profiling/heap_graph.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/profiling/profile_common.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/profiling/profile_packet.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/profiling/smaps.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_active_processes.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_application_state_info.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_compositor_scheduler_state.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_content_settings_event_info.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_frame_reporter.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_histogram_sample.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_keyed_service.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_latency_info.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_legacy_ipc.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_message_pump.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_mojo_event_info.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_process_descriptor.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_renderer_scheduler_state.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_thread_descriptor.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_user_event.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_window_handle_event_info.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/counter_descriptor.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/debug_annotation.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/log_message.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/process_descriptor.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/range_of_interest.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/screenshot.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/source_location.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/task_execution.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/thread_descriptor.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/track_descriptor.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/track_event.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/interned_data/interned_data.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_active_processes.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -35332,34 +30202,26 @@ class PERFETTO_EXPORT_COMPONENT ProcessDescriptor : public ::protozero::CppMessa
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/process_descriptor.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_active_processes.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-ProcessDescriptor::ProcessDescriptor() = default;
-ProcessDescriptor::~ProcessDescriptor() = default;
-ProcessDescriptor::ProcessDescriptor(const ProcessDescriptor&) = default;
-ProcessDescriptor& ProcessDescriptor::operator=(const ProcessDescriptor&) = default;
-ProcessDescriptor::ProcessDescriptor(ProcessDescriptor&&) noexcept = default;
-ProcessDescriptor& ProcessDescriptor::operator=(ProcessDescriptor&&) = default;
+ChromeActiveProcesses::ChromeActiveProcesses() = default;
+ChromeActiveProcesses::~ChromeActiveProcesses() = default;
+ChromeActiveProcesses::ChromeActiveProcesses(const ChromeActiveProcesses&) = default;
+ChromeActiveProcesses& ChromeActiveProcesses::operator=(const ChromeActiveProcesses&) = default;
+ChromeActiveProcesses::ChromeActiveProcesses(ChromeActiveProcesses&&) noexcept = default;
+ChromeActiveProcesses& ChromeActiveProcesses::operator=(ChromeActiveProcesses&&) = default;
 
-bool ProcessDescriptor::operator==(const ProcessDescriptor& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && pid_ == other.pid_
-   && cmdline_ == other.cmdline_
-   && process_name_ == other.process_name_
-   && process_priority_ == other.process_priority_
-   && start_timestamp_ns_ == other.start_timestamp_ns_
-   && chrome_process_type_ == other.chrome_process_type_
-   && legacy_sort_index_ == other.legacy_sort_index_
-   && process_labels_ == other.process_labels_;
+bool ChromeActiveProcesses::operator==(const ChromeActiveProcesses& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(pid_, other.pid_);
 }
 
-bool ProcessDescriptor::ParseFromArray(const void* raw, size_t size) {
-  cmdline_.clear();
-  process_labels_.clear();
+bool ChromeActiveProcesses::ParseFromArray(const void* raw, size_t size) {
+  pid_.clear();
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -35370,30 +30232,8 @@ bool ProcessDescriptor::ParseFromArray(const void* raw, size_t size) {
     }
     switch (field.id()) {
       case 1 /* pid */:
-        field.get(&pid_);
-        break;
-      case 2 /* cmdline */:
-        cmdline_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &cmdline_.back());
-        break;
-      case 6 /* process_name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &process_name_);
-        break;
-      case 5 /* process_priority */:
-        field.get(&process_priority_);
-        break;
-      case 7 /* start_timestamp_ns */:
-        field.get(&start_timestamp_ns_);
-        break;
-      case 4 /* chrome_process_type */:
-        field.get(&chrome_process_type_);
-        break;
-      case 3 /* legacy_sort_index */:
-        field.get(&legacy_sort_index_);
-        break;
-      case 8 /* process_labels */:
-        process_labels_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &process_labels_.back());
+        pid_.emplace_back();
+        field.get(&pid_.back());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -35403,57 +30243,22 @@ bool ProcessDescriptor::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ProcessDescriptor::SerializeAsString() const {
+std::string ChromeActiveProcesses::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ProcessDescriptor::SerializeAsArray() const {
+std::vector<uint8_t> ChromeActiveProcesses::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ProcessDescriptor::Serialize(::protozero::Message* msg) const {
+void ChromeActiveProcesses::Serialize(::protozero::Message* msg) const {
   // Field 1: pid
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, pid_, msg);
-  }
-
-  // Field 2: cmdline
-  for (auto& it : cmdline_) {
-    ::protozero::internal::gen_helpers::SerializeString(2, it, msg);
-  }
-
-  // Field 6: process_name
-  if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeString(6, process_name_, msg);
-  }
-
-  // Field 5: process_priority
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(5, process_priority_, msg);
-  }
-
-  // Field 7: start_timestamp_ns
-  if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(7, start_timestamp_ns_, msg);
-  }
-
-  // Field 4: chrome_process_type
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, chrome_process_type_, msg);
-  }
-
-  // Field 3: legacy_sort_index
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, legacy_sort_index_, msg);
-  }
-
-  // Field 8: process_labels
-  for (auto& it : process_labels_) {
-    ::protozero::internal::gen_helpers::SerializeString(8, it, msg);
+  for (auto& it : pid_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, it, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -35465,106 +30270,36 @@ void ProcessDescriptor::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/range_of_interest.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/range_of_interest.gen.h
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_application_state_info.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_RANGE_OF_INTEREST_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_RANGE_OF_INTEREST_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_application_state_info.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
-class TrackEventRangeOfInterest;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT TrackEventRangeOfInterest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kStartUsFieldNumber = 1,
-  };
-
-  TrackEventRangeOfInterest();
-  ~TrackEventRangeOfInterest() override;
-  TrackEventRangeOfInterest(TrackEventRangeOfInterest&&) noexcept;
-  TrackEventRangeOfInterest& operator=(TrackEventRangeOfInterest&&);
-  TrackEventRangeOfInterest(const TrackEventRangeOfInterest&);
-  TrackEventRangeOfInterest& operator=(const TrackEventRangeOfInterest&);
-  bool operator==(const TrackEventRangeOfInterest&) const;
-  bool operator!=(const TrackEventRangeOfInterest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_start_us() const { return _has_field_[1]; }
-  int64_t start_us() const { return start_us_; }
-  void set_start_us(int64_t value) { start_us_ = value; _has_field_.set(1); }
-
- private:
-  int64_t start_us_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_RANGE_OF_INTEREST_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/range_of_interest.gen.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-TrackEventRangeOfInterest::TrackEventRangeOfInterest() = default;
-TrackEventRangeOfInterest::~TrackEventRangeOfInterest() = default;
-TrackEventRangeOfInterest::TrackEventRangeOfInterest(const TrackEventRangeOfInterest&) = default;
-TrackEventRangeOfInterest& TrackEventRangeOfInterest::operator=(const TrackEventRangeOfInterest&) = default;
-TrackEventRangeOfInterest::TrackEventRangeOfInterest(TrackEventRangeOfInterest&&) noexcept = default;
-TrackEventRangeOfInterest& TrackEventRangeOfInterest::operator=(TrackEventRangeOfInterest&&) = default;
+ChromeApplicationStateInfo::ChromeApplicationStateInfo() = default;
+ChromeApplicationStateInfo::~ChromeApplicationStateInfo() = default;
+ChromeApplicationStateInfo::ChromeApplicationStateInfo(const ChromeApplicationStateInfo&) = default;
+ChromeApplicationStateInfo& ChromeApplicationStateInfo::operator=(const ChromeApplicationStateInfo&) = default;
+ChromeApplicationStateInfo::ChromeApplicationStateInfo(ChromeApplicationStateInfo&&) noexcept = default;
+ChromeApplicationStateInfo& ChromeApplicationStateInfo::operator=(ChromeApplicationStateInfo&&) = default;
 
-bool TrackEventRangeOfInterest::operator==(const TrackEventRangeOfInterest& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && start_us_ == other.start_us_;
+bool ChromeApplicationStateInfo::operator==(const ChromeApplicationStateInfo& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(application_state_, other.application_state_);
 }
 
-bool TrackEventRangeOfInterest::ParseFromArray(const void* raw, size_t size) {
+bool ChromeApplicationStateInfo::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -35574,8 +30309,8 @@ bool TrackEventRangeOfInterest::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* start_us */:
-        field.get(&start_us_);
+      case 1 /* application_state */:
+        field.get(&application_state_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -35585,22 +30320,22 @@ bool TrackEventRangeOfInterest::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TrackEventRangeOfInterest::SerializeAsString() const {
+std::string ChromeApplicationStateInfo::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TrackEventRangeOfInterest::SerializeAsArray() const {
+std::vector<uint8_t> ChromeApplicationStateInfo::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TrackEventRangeOfInterest::Serialize(::protozero::Message* msg) const {
-  // Field 1: start_us
+void ChromeApplicationStateInfo::Serialize(::protozero::Message* msg) const {
+  // Field 1: application_state
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, start_us_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, application_state_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -35612,7 +30347,7 @@ void TrackEventRangeOfInterest::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/source_location.gen.cc
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_compositor_scheduler_state.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -35623,28 +30358,32 @@ void TrackEventRangeOfInterest::Serialize(::protozero::Message* msg) const {
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_compositor_scheduler_state.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/source_location.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-SourceLocation::SourceLocation() = default;
-SourceLocation::~SourceLocation() = default;
-SourceLocation::SourceLocation(const SourceLocation&) = default;
-SourceLocation& SourceLocation::operator=(const SourceLocation&) = default;
-SourceLocation::SourceLocation(SourceLocation&&) noexcept = default;
-SourceLocation& SourceLocation::operator=(SourceLocation&&) = default;
+CompositorTimingHistory::CompositorTimingHistory() = default;
+CompositorTimingHistory::~CompositorTimingHistory() = default;
+CompositorTimingHistory::CompositorTimingHistory(const CompositorTimingHistory&) = default;
+CompositorTimingHistory& CompositorTimingHistory::operator=(const CompositorTimingHistory&) = default;
+CompositorTimingHistory::CompositorTimingHistory(CompositorTimingHistory&&) noexcept = default;
+CompositorTimingHistory& CompositorTimingHistory::operator=(CompositorTimingHistory&&) = default;
 
-bool SourceLocation::operator==(const SourceLocation& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && iid_ == other.iid_
-   && file_name_ == other.file_name_
-   && function_name_ == other.function_name_
-   && line_number_ == other.line_number_;
+bool CompositorTimingHistory::operator==(const CompositorTimingHistory& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(begin_main_frame_queue_critical_estimate_delta_us_, other.begin_main_frame_queue_critical_estimate_delta_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(begin_main_frame_queue_not_critical_estimate_delta_us_, other.begin_main_frame_queue_not_critical_estimate_delta_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(begin_main_frame_start_to_ready_to_commit_estimate_delta_us_, other.begin_main_frame_start_to_ready_to_commit_estimate_delta_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(commit_to_ready_to_activate_estimate_delta_us_, other.commit_to_ready_to_activate_estimate_delta_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(prepare_tiles_estimate_delta_us_, other.prepare_tiles_estimate_delta_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(activate_estimate_delta_us_, other.activate_estimate_delta_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(draw_estimate_delta_us_, other.draw_estimate_delta_us_);
 }
 
-bool SourceLocation::ParseFromArray(const void* raw, size_t size) {
+bool CompositorTimingHistory::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -35654,17 +30393,26 @@ bool SourceLocation::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* iid */:
-        field.get(&iid_);
+      case 1 /* begin_main_frame_queue_critical_estimate_delta_us */:
+        field.get(&begin_main_frame_queue_critical_estimate_delta_us_);
         break;
-      case 2 /* file_name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &file_name_);
+      case 2 /* begin_main_frame_queue_not_critical_estimate_delta_us */:
+        field.get(&begin_main_frame_queue_not_critical_estimate_delta_us_);
         break;
-      case 3 /* function_name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &function_name_);
+      case 3 /* begin_main_frame_start_to_ready_to_commit_estimate_delta_us */:
+        field.get(&begin_main_frame_start_to_ready_to_commit_estimate_delta_us_);
         break;
-      case 4 /* line_number */:
-        field.get(&line_number_);
+      case 4 /* commit_to_ready_to_activate_estimate_delta_us */:
+        field.get(&commit_to_ready_to_activate_estimate_delta_us_);
+        break;
+      case 5 /* prepare_tiles_estimate_delta_us */:
+        field.get(&prepare_tiles_estimate_delta_us_);
+        break;
+      case 6 /* activate_estimate_delta_us */:
+        field.get(&activate_estimate_delta_us_);
+        break;
+      case 7 /* draw_estimate_delta_us */:
+        field.get(&draw_estimate_delta_us_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -35674,58 +30422,74 @@ bool SourceLocation::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string SourceLocation::SerializeAsString() const {
+std::string CompositorTimingHistory::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> SourceLocation::SerializeAsArray() const {
+std::vector<uint8_t> CompositorTimingHistory::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void SourceLocation::Serialize(::protozero::Message* msg) const {
-  // Field 1: iid
+void CompositorTimingHistory::Serialize(::protozero::Message* msg) const {
+  // Field 1: begin_main_frame_queue_critical_estimate_delta_us
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, iid_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, begin_main_frame_queue_critical_estimate_delta_us_, msg);
   }
 
-  // Field 2: file_name
+  // Field 2: begin_main_frame_queue_not_critical_estimate_delta_us
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeString(2, file_name_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, begin_main_frame_queue_not_critical_estimate_delta_us_, msg);
   }
 
-  // Field 3: function_name
+  // Field 3: begin_main_frame_start_to_ready_to_commit_estimate_delta_us
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeString(3, function_name_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, begin_main_frame_start_to_ready_to_commit_estimate_delta_us_, msg);
   }
 
-  // Field 4: line_number
+  // Field 4: commit_to_ready_to_activate_estimate_delta_us
   if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, line_number_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, commit_to_ready_to_activate_estimate_delta_us_, msg);
+  }
+
+  // Field 5: prepare_tiles_estimate_delta_us
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, prepare_tiles_estimate_delta_us_, msg);
+  }
+
+  // Field 6: activate_estimate_delta_us
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, activate_estimate_delta_us_, msg);
+  }
+
+  // Field 7: draw_estimate_delta_us
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(7, draw_estimate_delta_us_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-UnsymbolizedSourceLocation::UnsymbolizedSourceLocation() = default;
-UnsymbolizedSourceLocation::~UnsymbolizedSourceLocation() = default;
-UnsymbolizedSourceLocation::UnsymbolizedSourceLocation(const UnsymbolizedSourceLocation&) = default;
-UnsymbolizedSourceLocation& UnsymbolizedSourceLocation::operator=(const UnsymbolizedSourceLocation&) = default;
-UnsymbolizedSourceLocation::UnsymbolizedSourceLocation(UnsymbolizedSourceLocation&&) noexcept = default;
-UnsymbolizedSourceLocation& UnsymbolizedSourceLocation::operator=(UnsymbolizedSourceLocation&&) = default;
+BeginFrameSourceState::BeginFrameSourceState() = default;
+BeginFrameSourceState::~BeginFrameSourceState() = default;
+BeginFrameSourceState::BeginFrameSourceState(const BeginFrameSourceState&) = default;
+BeginFrameSourceState& BeginFrameSourceState::operator=(const BeginFrameSourceState&) = default;
+BeginFrameSourceState::BeginFrameSourceState(BeginFrameSourceState&&) noexcept = default;
+BeginFrameSourceState& BeginFrameSourceState::operator=(BeginFrameSourceState&&) = default;
 
-bool UnsymbolizedSourceLocation::operator==(const UnsymbolizedSourceLocation& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && iid_ == other.iid_
-   && mapping_id_ == other.mapping_id_
-   && rel_pc_ == other.rel_pc_;
+bool BeginFrameSourceState::operator==(const BeginFrameSourceState& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(source_id_, other.source_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(paused_, other.paused_)
+   && ::protozero::internal::gen_helpers::EqualsField(num_observers_, other.num_observers_)
+   && ::protozero::internal::gen_helpers::EqualsField(last_begin_frame_args_, other.last_begin_frame_args_);
 }
 
-bool UnsymbolizedSourceLocation::ParseFromArray(const void* raw, size_t size) {
+bool BeginFrameSourceState::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -35735,14 +30499,17 @@ bool UnsymbolizedSourceLocation::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* iid */:
-        field.get(&iid_);
+      case 1 /* source_id */:
+        field.get(&source_id_);
         break;
-      case 2 /* mapping_id */:
-        field.get(&mapping_id_);
+      case 2 /* paused */:
+        field.get(&paused_);
         break;
-      case 3 /* rel_pc */:
-        field.get(&rel_pc_);
+      case 3 /* num_observers */:
+        field.get(&num_observers_);
+        break;
+      case 4 /* last_begin_frame_args */:
+        (*last_begin_frame_args_).ParseFromArray(field.data(), field.size());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -35752,143 +30519,66 @@ bool UnsymbolizedSourceLocation::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string UnsymbolizedSourceLocation::SerializeAsString() const {
+std::string BeginFrameSourceState::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> UnsymbolizedSourceLocation::SerializeAsArray() const {
+std::vector<uint8_t> BeginFrameSourceState::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void UnsymbolizedSourceLocation::Serialize(::protozero::Message* msg) const {
-  // Field 1: iid
+void BeginFrameSourceState::Serialize(::protozero::Message* msg) const {
+  // Field 1: source_id
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, iid_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, source_id_, msg);
   }
 
-  // Field 2: mapping_id
+  // Field 2: paused
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, mapping_id_, msg);
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, paused_, msg);
   }
 
-  // Field 3: rel_pc
+  // Field 3: num_observers
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, rel_pc_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, num_observers_, msg);
+  }
+
+  // Field 4: last_begin_frame_args
+  if (_has_field_[4]) {
+    (*last_begin_frame_args_).Serialize(msg->BeginNestedMessage<::protozero::Message>(4));
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/task_execution.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/task_execution.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TASK_EXECUTION_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TASK_EXECUTION_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class TaskExecution;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT TaskExecution : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kPostedFromIidFieldNumber = 1,
-  };
-
-  TaskExecution();
-  ~TaskExecution() override;
-  TaskExecution(TaskExecution&&) noexcept;
-  TaskExecution& operator=(TaskExecution&&);
-  TaskExecution(const TaskExecution&);
-  TaskExecution& operator=(const TaskExecution&);
-  bool operator==(const TaskExecution&) const;
-  bool operator!=(const TaskExecution& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_posted_from_iid() const { return _has_field_[1]; }
-  uint64_t posted_from_iid() const { return posted_from_iid_; }
-  void set_posted_from_iid(uint64_t value) { posted_from_iid_ = value; _has_field_.set(1); }
-
- private:
-  uint64_t posted_from_iid_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TASK_EXECUTION_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/task_execution.gen.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
 
-TaskExecution::TaskExecution() = default;
-TaskExecution::~TaskExecution() = default;
-TaskExecution::TaskExecution(const TaskExecution&) = default;
-TaskExecution& TaskExecution::operator=(const TaskExecution&) = default;
-TaskExecution::TaskExecution(TaskExecution&&) noexcept = default;
-TaskExecution& TaskExecution::operator=(TaskExecution&&) = default;
+BeginFrameArgs::BeginFrameArgs() = default;
+BeginFrameArgs::~BeginFrameArgs() = default;
+BeginFrameArgs::BeginFrameArgs(const BeginFrameArgs&) = default;
+BeginFrameArgs& BeginFrameArgs::operator=(const BeginFrameArgs&) = default;
+BeginFrameArgs::BeginFrameArgs(BeginFrameArgs&&) noexcept = default;
+BeginFrameArgs& BeginFrameArgs::operator=(BeginFrameArgs&&) = default;
 
-bool TaskExecution::operator==(const TaskExecution& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && posted_from_iid_ == other.posted_from_iid_;
+bool BeginFrameArgs::operator==(const BeginFrameArgs& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(type_, other.type_)
+   && ::protozero::internal::gen_helpers::EqualsField(source_id_, other.source_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(sequence_number_, other.sequence_number_)
+   && ::protozero::internal::gen_helpers::EqualsField(frame_time_us_, other.frame_time_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(deadline_us_, other.deadline_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(interval_delta_us_, other.interval_delta_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(on_critical_path_, other.on_critical_path_)
+   && ::protozero::internal::gen_helpers::EqualsField(animate_only_, other.animate_only_)
+   && ::protozero::internal::gen_helpers::EqualsField(source_location_iid_, other.source_location_iid_)
+   && ::protozero::internal::gen_helpers::EqualsField(source_location_, other.source_location_)
+   && ::protozero::internal::gen_helpers::EqualsField(frames_throttled_since_last_, other.frames_throttled_since_last_);
 }
 
-bool TaskExecution::ParseFromArray(const void* raw, size_t size) {
+bool BeginFrameArgs::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -35898,8 +30588,38 @@ bool TaskExecution::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* posted_from_iid */:
-        field.get(&posted_from_iid_);
+      case 1 /* type */:
+        field.get(&type_);
+        break;
+      case 2 /* source_id */:
+        field.get(&source_id_);
+        break;
+      case 3 /* sequence_number */:
+        field.get(&sequence_number_);
+        break;
+      case 4 /* frame_time_us */:
+        field.get(&frame_time_us_);
+        break;
+      case 5 /* deadline_us */:
+        field.get(&deadline_us_);
+        break;
+      case 6 /* interval_delta_us */:
+        field.get(&interval_delta_us_);
+        break;
+      case 7 /* on_critical_path */:
+        field.get(&on_critical_path_);
+        break;
+      case 8 /* animate_only */:
+        field.get(&animate_only_);
+        break;
+      case 9 /* source_location_iid */:
+        field.get(&source_location_iid_);
+        break;
+      case 10 /* source_location */:
+        (*source_location_).ParseFromArray(field.data(), field.size());
+        break;
+      case 12 /* frames_throttled_since_last */:
+        field.get(&frames_throttled_since_last_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -35909,216 +30629,92 @@ bool TaskExecution::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TaskExecution::SerializeAsString() const {
+std::string BeginFrameArgs::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TaskExecution::SerializeAsArray() const {
+std::vector<uint8_t> BeginFrameArgs::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TaskExecution::Serialize(::protozero::Message* msg) const {
-  // Field 1: posted_from_iid
+void BeginFrameArgs::Serialize(::protozero::Message* msg) const {
+  // Field 1: type
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, posted_from_iid_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, type_, msg);
   }
 
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
-}
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/thread_descriptor.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/thread_descriptor.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_THREAD_DESCRIPTOR_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_THREAD_DESCRIPTOR_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ThreadDescriptor;
-enum ThreadDescriptor_ChromeThreadType : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum ThreadDescriptor_ChromeThreadType : int {
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_UNSPECIFIED = 0,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_MAIN = 1,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_IO = 2,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_BG_WORKER = 3,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_FG_WORKER = 4,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_FB_BLOCKING = 5,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_BG_BLOCKING = 6,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_SERVICE = 7,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_COMPOSITOR = 8,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_VIZ_COMPOSITOR = 9,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_COMPOSITOR_WORKER = 10,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_SERVICE_WORKER = 11,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_MEMORY_INFRA = 50,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_SAMPLING_PROFILER = 51,
-};
-
-class PERFETTO_EXPORT_COMPONENT ThreadDescriptor : public ::protozero::CppMessageObj {
- public:
-  using ChromeThreadType = ThreadDescriptor_ChromeThreadType;
-  static constexpr auto CHROME_THREAD_UNSPECIFIED = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_UNSPECIFIED;
-  static constexpr auto CHROME_THREAD_MAIN = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_MAIN;
-  static constexpr auto CHROME_THREAD_IO = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_IO;
-  static constexpr auto CHROME_THREAD_POOL_BG_WORKER = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_BG_WORKER;
-  static constexpr auto CHROME_THREAD_POOL_FG_WORKER = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_FG_WORKER;
-  static constexpr auto CHROME_THREAD_POOL_FB_BLOCKING = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_FB_BLOCKING;
-  static constexpr auto CHROME_THREAD_POOL_BG_BLOCKING = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_BG_BLOCKING;
-  static constexpr auto CHROME_THREAD_POOL_SERVICE = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_SERVICE;
-  static constexpr auto CHROME_THREAD_COMPOSITOR = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_COMPOSITOR;
-  static constexpr auto CHROME_THREAD_VIZ_COMPOSITOR = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_VIZ_COMPOSITOR;
-  static constexpr auto CHROME_THREAD_COMPOSITOR_WORKER = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_COMPOSITOR_WORKER;
-  static constexpr auto CHROME_THREAD_SERVICE_WORKER = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_SERVICE_WORKER;
-  static constexpr auto CHROME_THREAD_MEMORY_INFRA = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_MEMORY_INFRA;
-  static constexpr auto CHROME_THREAD_SAMPLING_PROFILER = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_SAMPLING_PROFILER;
-  static constexpr auto ChromeThreadType_MIN = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_UNSPECIFIED;
-  static constexpr auto ChromeThreadType_MAX = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_SAMPLING_PROFILER;
-  enum FieldNumbers {
-    kPidFieldNumber = 1,
-    kTidFieldNumber = 2,
-    kThreadNameFieldNumber = 5,
-    kChromeThreadTypeFieldNumber = 4,
-    kReferenceTimestampUsFieldNumber = 6,
-    kReferenceThreadTimeUsFieldNumber = 7,
-    kReferenceThreadInstructionCountFieldNumber = 8,
-    kLegacySortIndexFieldNumber = 3,
-  };
-
-  ThreadDescriptor();
-  ~ThreadDescriptor() override;
-  ThreadDescriptor(ThreadDescriptor&&) noexcept;
-  ThreadDescriptor& operator=(ThreadDescriptor&&);
-  ThreadDescriptor(const ThreadDescriptor&);
-  ThreadDescriptor& operator=(const ThreadDescriptor&);
-  bool operator==(const ThreadDescriptor&) const;
-  bool operator!=(const ThreadDescriptor& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_pid() const { return _has_field_[1]; }
-  int32_t pid() const { return pid_; }
-  void set_pid(int32_t value) { pid_ = value; _has_field_.set(1); }
+  // Field 2: source_id
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, source_id_, msg);
+  }
 
-  bool has_tid() const { return _has_field_[2]; }
-  int32_t tid() const { return tid_; }
-  void set_tid(int32_t value) { tid_ = value; _has_field_.set(2); }
+  // Field 3: sequence_number
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, sequence_number_, msg);
+  }
 
-  bool has_thread_name() const { return _has_field_[5]; }
-  const std::string& thread_name() const { return thread_name_; }
-  void set_thread_name(const std::string& value) { thread_name_ = value; _has_field_.set(5); }
+  // Field 4: frame_time_us
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, frame_time_us_, msg);
+  }
 
-  bool has_chrome_thread_type() const { return _has_field_[4]; }
-  ThreadDescriptor_ChromeThreadType chrome_thread_type() const { return chrome_thread_type_; }
-  void set_chrome_thread_type(ThreadDescriptor_ChromeThreadType value) { chrome_thread_type_ = value; _has_field_.set(4); }
+  // Field 5: deadline_us
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, deadline_us_, msg);
+  }
 
-  bool has_reference_timestamp_us() const { return _has_field_[6]; }
-  int64_t reference_timestamp_us() const { return reference_timestamp_us_; }
-  void set_reference_timestamp_us(int64_t value) { reference_timestamp_us_ = value; _has_field_.set(6); }
+  // Field 6: interval_delta_us
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, interval_delta_us_, msg);
+  }
 
-  bool has_reference_thread_time_us() const { return _has_field_[7]; }
-  int64_t reference_thread_time_us() const { return reference_thread_time_us_; }
-  void set_reference_thread_time_us(int64_t value) { reference_thread_time_us_ = value; _has_field_.set(7); }
+  // Field 7: on_critical_path
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(7, on_critical_path_, msg);
+  }
 
-  bool has_reference_thread_instruction_count() const { return _has_field_[8]; }
-  int64_t reference_thread_instruction_count() const { return reference_thread_instruction_count_; }
-  void set_reference_thread_instruction_count(int64_t value) { reference_thread_instruction_count_ = value; _has_field_.set(8); }
+  // Field 8: animate_only
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(8, animate_only_, msg);
+  }
 
-  bool has_legacy_sort_index() const { return _has_field_[3]; }
-  int32_t legacy_sort_index() const { return legacy_sort_index_; }
-  void set_legacy_sort_index(int32_t value) { legacy_sort_index_ = value; _has_field_.set(3); }
+  // Field 9: source_location_iid
+  if (_has_field_[9]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(9, source_location_iid_, msg);
+  }
 
- private:
-  int32_t pid_{};
-  int32_t tid_{};
-  std::string thread_name_{};
-  ThreadDescriptor_ChromeThreadType chrome_thread_type_{};
-  int64_t reference_timestamp_us_{};
-  int64_t reference_thread_time_us_{};
-  int64_t reference_thread_instruction_count_{};
-  int32_t legacy_sort_index_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<9> _has_field_{};
-};
+  // Field 10: source_location
+  if (_has_field_[10]) {
+    (*source_location_).Serialize(msg->BeginNestedMessage<::protozero::Message>(10));
+  }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  // Field 12: frames_throttled_since_last
+  if (_has_field_[12]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(12, frames_throttled_since_last_, msg);
+  }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_THREAD_DESCRIPTOR_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/thread_descriptor.gen.h"
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
 
-ThreadDescriptor::ThreadDescriptor() = default;
-ThreadDescriptor::~ThreadDescriptor() = default;
-ThreadDescriptor::ThreadDescriptor(const ThreadDescriptor&) = default;
-ThreadDescriptor& ThreadDescriptor::operator=(const ThreadDescriptor&) = default;
-ThreadDescriptor::ThreadDescriptor(ThreadDescriptor&&) noexcept = default;
-ThreadDescriptor& ThreadDescriptor::operator=(ThreadDescriptor&&) = default;
+BeginFrameObserverState::BeginFrameObserverState() = default;
+BeginFrameObserverState::~BeginFrameObserverState() = default;
+BeginFrameObserverState::BeginFrameObserverState(const BeginFrameObserverState&) = default;
+BeginFrameObserverState& BeginFrameObserverState::operator=(const BeginFrameObserverState&) = default;
+BeginFrameObserverState::BeginFrameObserverState(BeginFrameObserverState&&) noexcept = default;
+BeginFrameObserverState& BeginFrameObserverState::operator=(BeginFrameObserverState&&) = default;
 
-bool ThreadDescriptor::operator==(const ThreadDescriptor& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && pid_ == other.pid_
-   && tid_ == other.tid_
-   && thread_name_ == other.thread_name_
-   && chrome_thread_type_ == other.chrome_thread_type_
-   && reference_timestamp_us_ == other.reference_timestamp_us_
-   && reference_thread_time_us_ == other.reference_thread_time_us_
-   && reference_thread_instruction_count_ == other.reference_thread_instruction_count_
-   && legacy_sort_index_ == other.legacy_sort_index_;
+bool BeginFrameObserverState::operator==(const BeginFrameObserverState& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(dropped_begin_frame_args_, other.dropped_begin_frame_args_)
+   && ::protozero::internal::gen_helpers::EqualsField(last_begin_frame_args_, other.last_begin_frame_args_);
 }
 
-bool ThreadDescriptor::ParseFromArray(const void* raw, size_t size) {
+bool BeginFrameObserverState::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -36128,29 +30724,11 @@ bool ThreadDescriptor::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* pid */:
-        field.get(&pid_);
-        break;
-      case 2 /* tid */:
-        field.get(&tid_);
-        break;
-      case 5 /* thread_name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &thread_name_);
-        break;
-      case 4 /* chrome_thread_type */:
-        field.get(&chrome_thread_type_);
-        break;
-      case 6 /* reference_timestamp_us */:
-        field.get(&reference_timestamp_us_);
-        break;
-      case 7 /* reference_thread_time_us */:
-        field.get(&reference_thread_time_us_);
-        break;
-      case 8 /* reference_thread_instruction_count */:
-        field.get(&reference_thread_instruction_count_);
+      case 1 /* dropped_begin_frame_args */:
+        field.get(&dropped_begin_frame_args_);
         break;
-      case 3 /* legacy_sort_index */:
-        field.get(&legacy_sort_index_);
+      case 2 /* last_begin_frame_args */:
+        (*last_begin_frame_args_).ParseFromArray(field.data(), field.size());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -36160,112 +30738,53 @@ bool ThreadDescriptor::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string ThreadDescriptor::SerializeAsString() const {
+std::string BeginFrameObserverState::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> ThreadDescriptor::SerializeAsArray() const {
+std::vector<uint8_t> BeginFrameObserverState::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void ThreadDescriptor::Serialize(::protozero::Message* msg) const {
-  // Field 1: pid
+void BeginFrameObserverState::Serialize(::protozero::Message* msg) const {
+  // Field 1: dropped_begin_frame_args
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, pid_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, dropped_begin_frame_args_, msg);
   }
 
-  // Field 2: tid
+  // Field 2: last_begin_frame_args
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, tid_, msg);
+    (*last_begin_frame_args_).Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
   }
 
-  // Field 5: thread_name
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeString(5, thread_name_, msg);
-  }
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  // Field 4: chrome_thread_type
-  if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, chrome_thread_type_, msg);
-  }
 
-  // Field 6: reference_timestamp_us
-  if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(6, reference_timestamp_us_, msg);
-  }
+BeginImplFrameArgs::BeginImplFrameArgs() = default;
+BeginImplFrameArgs::~BeginImplFrameArgs() = default;
+BeginImplFrameArgs::BeginImplFrameArgs(const BeginImplFrameArgs&) = default;
+BeginImplFrameArgs& BeginImplFrameArgs::operator=(const BeginImplFrameArgs&) = default;
+BeginImplFrameArgs::BeginImplFrameArgs(BeginImplFrameArgs&&) noexcept = default;
+BeginImplFrameArgs& BeginImplFrameArgs::operator=(BeginImplFrameArgs&&) = default;
 
-  // Field 7: reference_thread_time_us
-  if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(7, reference_thread_time_us_, msg);
-  }
+bool BeginImplFrameArgs::operator==(const BeginImplFrameArgs& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(updated_at_us_, other.updated_at_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(finished_at_us_, other.finished_at_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(state_, other.state_)
+   && ::protozero::internal::gen_helpers::EqualsField(current_args_, other.current_args_)
+   && ::protozero::internal::gen_helpers::EqualsField(last_args_, other.last_args_)
+   && ::protozero::internal::gen_helpers::EqualsField(timestamps_in_us_, other.timestamps_in_us_);
+}
 
-  // Field 8: reference_thread_instruction_count
-  if (_has_field_[8]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(8, reference_thread_instruction_count_, msg);
-  }
-
-  // Field 3: legacy_sort_index
-  if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, legacy_sort_index_, msg);
-  }
-
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
-}
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/track_descriptor.gen.cc
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_descriptor.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/counter_descriptor.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/thread_descriptor.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/process_descriptor.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_thread_descriptor.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_process_descriptor.gen.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-TrackDescriptor::TrackDescriptor() = default;
-TrackDescriptor::~TrackDescriptor() = default;
-TrackDescriptor::TrackDescriptor(const TrackDescriptor&) = default;
-TrackDescriptor& TrackDescriptor::operator=(const TrackDescriptor&) = default;
-TrackDescriptor::TrackDescriptor(TrackDescriptor&&) noexcept = default;
-TrackDescriptor& TrackDescriptor::operator=(TrackDescriptor&&) = default;
-
-bool TrackDescriptor::operator==(const TrackDescriptor& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && uuid_ == other.uuid_
-   && parent_uuid_ == other.parent_uuid_
-   && name_ == other.name_
-   && process_ == other.process_
-   && chrome_process_ == other.chrome_process_
-   && thread_ == other.thread_
-   && chrome_thread_ == other.chrome_thread_
-   && counter_ == other.counter_;
-}
-
-bool TrackDescriptor::ParseFromArray(const void* raw, size_t size) {
-  unknown_fields_.clear();
-  bool packed_error = false;
+bool BeginImplFrameArgs::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
   ::protozero::ProtoDecoder dec(raw, size);
   for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
@@ -36273,29 +30792,23 @@ bool TrackDescriptor::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* uuid */:
-        field.get(&uuid_);
-        break;
-      case 5 /* parent_uuid */:
-        field.get(&parent_uuid_);
-        break;
-      case 2 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+      case 1 /* updated_at_us */:
+        field.get(&updated_at_us_);
         break;
-      case 3 /* process */:
-        (*process_).ParseFromArray(field.data(), field.size());
+      case 2 /* finished_at_us */:
+        field.get(&finished_at_us_);
         break;
-      case 6 /* chrome_process */:
-        (*chrome_process_).ParseFromArray(field.data(), field.size());
+      case 3 /* state */:
+        field.get(&state_);
         break;
-      case 4 /* thread */:
-        (*thread_).ParseFromArray(field.data(), field.size());
+      case 4 /* current_args */:
+        (*current_args_).ParseFromArray(field.data(), field.size());
         break;
-      case 7 /* chrome_thread */:
-        (*chrome_thread_).ParseFromArray(field.data(), field.size());
+      case 5 /* last_args */:
+        (*last_args_).ParseFromArray(field.data(), field.size());
         break;
-      case 8 /* counter */:
-        (*counter_).ParseFromArray(field.data(), field.size());
+      case 6 /* timestamps_in_us */:
+        (*timestamps_in_us_).ParseFromArray(field.data(), field.size());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -36305,823 +30818,72 @@ bool TrackDescriptor::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TrackDescriptor::SerializeAsString() const {
+std::string BeginImplFrameArgs::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TrackDescriptor::SerializeAsArray() const {
+std::vector<uint8_t> BeginImplFrameArgs::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TrackDescriptor::Serialize(::protozero::Message* msg) const {
-  // Field 1: uuid
+void BeginImplFrameArgs::Serialize(::protozero::Message* msg) const {
+  // Field 1: updated_at_us
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, uuid_, msg);
-  }
-
-  // Field 5: parent_uuid
-  if (_has_field_[5]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(5, parent_uuid_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, updated_at_us_, msg);
   }
 
-  // Field 2: name
+  // Field 2: finished_at_us
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeString(2, name_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, finished_at_us_, msg);
   }
 
-  // Field 3: process
+  // Field 3: state
   if (_has_field_[3]) {
-    (*process_).Serialize(msg->BeginNestedMessage<::protozero::Message>(3));
-  }
-
-  // Field 6: chrome_process
-  if (_has_field_[6]) {
-    (*chrome_process_).Serialize(msg->BeginNestedMessage<::protozero::Message>(6));
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, state_, msg);
   }
 
-  // Field 4: thread
+  // Field 4: current_args
   if (_has_field_[4]) {
-    (*thread_).Serialize(msg->BeginNestedMessage<::protozero::Message>(4));
+    (*current_args_).Serialize(msg->BeginNestedMessage<::protozero::Message>(4));
   }
 
-  // Field 7: chrome_thread
-  if (_has_field_[7]) {
-    (*chrome_thread_).Serialize(msg->BeginNestedMessage<::protozero::Message>(7));
+  // Field 5: last_args
+  if (_has_field_[5]) {
+    (*last_args_).Serialize(msg->BeginNestedMessage<::protozero::Message>(5));
   }
 
-  // Field 8: counter
-  if (_has_field_[8]) {
-    (*counter_).Serialize(msg->BeginNestedMessage<::protozero::Message>(8));
+  // Field 6: timestamps_in_us
+  if (_has_field_[6]) {
+    (*timestamps_in_us_).Serialize(msg->BeginNestedMessage<::protozero::Message>(6));
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/track_event.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/track_event.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TRACK_EVENT_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TRACK_EVENT_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class EventName;
-class EventCategory;
-class TrackEventDefaults;
-class TrackEvent;
-class TrackEvent_LegacyEvent;
-class ChromeMojoEventInfo;
-class ChromeMessagePump;
-class SourceLocation;
-class ChromeActiveProcesses;
-class ChromeContentSettingsEventInfo;
-class ChromeWindowHandleEventInfo;
-class ChromeRendererSchedulerState;
-class ChromeApplicationStateInfo;
-class ChromeFrameReporter;
-class ChromeLatencyInfo;
-class ChromeLatencyInfo_ComponentInfo;
-class ChromeHistogramSample;
-class ChromeLegacyIpc;
-class ChromeKeyedService;
-class ChromeUserEvent;
-class ChromeCompositorSchedulerState;
-class CompositorTimingHistory;
-class BeginFrameSourceState;
-class BeginFrameArgs;
-class BeginFrameObserverState;
-class BeginImplFrameArgs;
-class BeginImplFrameArgs_TimestampsInUs;
-class ChromeCompositorStateMachine;
-class ChromeCompositorStateMachine_MinorState;
-class ChromeCompositorStateMachine_MajorState;
-class LogMessage;
-class TaskExecution;
-class DebugAnnotation;
-class DebugAnnotation_NestedValue;
-enum TrackEvent_Type : int;
-enum TrackEvent_LegacyEvent_FlowDirection : int;
-enum TrackEvent_LegacyEvent_InstantEventScope : int;
-enum ChromeRAILMode : int;
-enum ChromeApplicationStateInfo_ChromeApplicationState : int;
-enum ChromeFrameReporter_State : int;
-enum ChromeFrameReporter_FrameDropReason : int;
-enum ChromeFrameReporter_ScrollState : int;
-enum ChromeFrameReporter_FrameType : int;
-enum ChromeLatencyInfo_Step : int;
-enum ChromeLatencyInfo_LatencyComponentType : int;
-enum ChromeLegacyIpc_MessageClass : int;
-enum ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode : int;
-enum ChromeCompositorSchedulerAction : int;
-enum BeginFrameArgs_BeginFrameArgsType : int;
-enum BeginImplFrameArgs_State : int;
-enum ChromeCompositorStateMachine_MinorState_TreePriority : int;
-enum ChromeCompositorStateMachine_MinorState_ScrollHandlerState : int;
-enum ChromeCompositorStateMachine_MajorState_BeginImplFrameState : int;
-enum ChromeCompositorStateMachine_MajorState_BeginMainFrameState : int;
-enum ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState : int;
-enum ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState : int;
-enum DebugAnnotation_NestedValue_NestedType : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum TrackEvent_Type : int {
-  TrackEvent_Type_TYPE_UNSPECIFIED = 0,
-  TrackEvent_Type_TYPE_SLICE_BEGIN = 1,
-  TrackEvent_Type_TYPE_SLICE_END = 2,
-  TrackEvent_Type_TYPE_INSTANT = 3,
-  TrackEvent_Type_TYPE_COUNTER = 4,
-};
-enum TrackEvent_LegacyEvent_FlowDirection : int {
-  TrackEvent_LegacyEvent_FlowDirection_FLOW_UNSPECIFIED = 0,
-  TrackEvent_LegacyEvent_FlowDirection_FLOW_IN = 1,
-  TrackEvent_LegacyEvent_FlowDirection_FLOW_OUT = 2,
-  TrackEvent_LegacyEvent_FlowDirection_FLOW_INOUT = 3,
-};
-enum TrackEvent_LegacyEvent_InstantEventScope : int {
-  TrackEvent_LegacyEvent_InstantEventScope_SCOPE_UNSPECIFIED = 0,
-  TrackEvent_LegacyEvent_InstantEventScope_SCOPE_GLOBAL = 1,
-  TrackEvent_LegacyEvent_InstantEventScope_SCOPE_PROCESS = 2,
-  TrackEvent_LegacyEvent_InstantEventScope_SCOPE_THREAD = 3,
-};
-
-class PERFETTO_EXPORT_COMPONENT EventName : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kIidFieldNumber = 1,
-    kNameFieldNumber = 2,
-  };
-
-  EventName();
-  ~EventName() override;
-  EventName(EventName&&) noexcept;
-  EventName& operator=(EventName&&);
-  EventName(const EventName&);
-  EventName& operator=(const EventName&);
-  bool operator==(const EventName&) const;
-  bool operator!=(const EventName& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_iid() const { return _has_field_[1]; }
-  uint64_t iid() const { return iid_; }
-  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
-
-  bool has_name() const { return _has_field_[2]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
-
- private:
-  uint64_t iid_{};
-  std::string name_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT EventCategory : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kIidFieldNumber = 1,
-    kNameFieldNumber = 2,
-  };
-
-  EventCategory();
-  ~EventCategory() override;
-  EventCategory(EventCategory&&) noexcept;
-  EventCategory& operator=(EventCategory&&);
-  EventCategory(const EventCategory&);
-  EventCategory& operator=(const EventCategory&);
-  bool operator==(const EventCategory&) const;
-  bool operator!=(const EventCategory& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_iid() const { return _has_field_[1]; }
-  uint64_t iid() const { return iid_; }
-  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
-
-  bool has_name() const { return _has_field_[2]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
-
- private:
-  uint64_t iid_{};
-  std::string name_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT TrackEventDefaults : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kTrackUuidFieldNumber = 11,
-    kExtraCounterTrackUuidsFieldNumber = 31,
-    kExtraDoubleCounterTrackUuidsFieldNumber = 45,
-  };
-
-  TrackEventDefaults();
-  ~TrackEventDefaults() override;
-  TrackEventDefaults(TrackEventDefaults&&) noexcept;
-  TrackEventDefaults& operator=(TrackEventDefaults&&);
-  TrackEventDefaults(const TrackEventDefaults&);
-  TrackEventDefaults& operator=(const TrackEventDefaults&);
-  bool operator==(const TrackEventDefaults&) const;
-  bool operator!=(const TrackEventDefaults& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_track_uuid() const { return _has_field_[11]; }
-  uint64_t track_uuid() const { return track_uuid_; }
-  void set_track_uuid(uint64_t value) { track_uuid_ = value; _has_field_.set(11); }
-
-  const std::vector<uint64_t>& extra_counter_track_uuids() const { return extra_counter_track_uuids_; }
-  std::vector<uint64_t>* mutable_extra_counter_track_uuids() { return &extra_counter_track_uuids_; }
-  int extra_counter_track_uuids_size() const { return static_cast<int>(extra_counter_track_uuids_.size()); }
-  void clear_extra_counter_track_uuids() { extra_counter_track_uuids_.clear(); }
-  void add_extra_counter_track_uuids(uint64_t value) { extra_counter_track_uuids_.emplace_back(value); }
-  uint64_t* add_extra_counter_track_uuids() { extra_counter_track_uuids_.emplace_back(); return &extra_counter_track_uuids_.back(); }
-
-  const std::vector<uint64_t>& extra_double_counter_track_uuids() const { return extra_double_counter_track_uuids_; }
-  std::vector<uint64_t>* mutable_extra_double_counter_track_uuids() { return &extra_double_counter_track_uuids_; }
-  int extra_double_counter_track_uuids_size() const { return static_cast<int>(extra_double_counter_track_uuids_.size()); }
-  void clear_extra_double_counter_track_uuids() { extra_double_counter_track_uuids_.clear(); }
-  void add_extra_double_counter_track_uuids(uint64_t value) { extra_double_counter_track_uuids_.emplace_back(value); }
-  uint64_t* add_extra_double_counter_track_uuids() { extra_double_counter_track_uuids_.emplace_back(); return &extra_double_counter_track_uuids_.back(); }
-
- private:
-  uint64_t track_uuid_{};
-  std::vector<uint64_t> extra_counter_track_uuids_;
-  std::vector<uint64_t> extra_double_counter_track_uuids_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<46> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT TrackEvent : public ::protozero::CppMessageObj {
- public:
-  using LegacyEvent = TrackEvent_LegacyEvent;
-  using Type = TrackEvent_Type;
-  static constexpr auto TYPE_UNSPECIFIED = TrackEvent_Type_TYPE_UNSPECIFIED;
-  static constexpr auto TYPE_SLICE_BEGIN = TrackEvent_Type_TYPE_SLICE_BEGIN;
-  static constexpr auto TYPE_SLICE_END = TrackEvent_Type_TYPE_SLICE_END;
-  static constexpr auto TYPE_INSTANT = TrackEvent_Type_TYPE_INSTANT;
-  static constexpr auto TYPE_COUNTER = TrackEvent_Type_TYPE_COUNTER;
-  static constexpr auto Type_MIN = TrackEvent_Type_TYPE_UNSPECIFIED;
-  static constexpr auto Type_MAX = TrackEvent_Type_TYPE_COUNTER;
-  enum FieldNumbers {
-    kCategoryIidsFieldNumber = 3,
-    kCategoriesFieldNumber = 22,
-    kNameIidFieldNumber = 10,
-    kNameFieldNumber = 23,
-    kTypeFieldNumber = 9,
-    kTrackUuidFieldNumber = 11,
-    kCounterValueFieldNumber = 30,
-    kDoubleCounterValueFieldNumber = 44,
-    kExtraCounterTrackUuidsFieldNumber = 31,
-    kExtraCounterValuesFieldNumber = 12,
-    kExtraDoubleCounterTrackUuidsFieldNumber = 45,
-    kExtraDoubleCounterValuesFieldNumber = 46,
-    kFlowIdsOldFieldNumber = 36,
-    kFlowIdsFieldNumber = 47,
-    kTerminatingFlowIdsOldFieldNumber = 42,
-    kTerminatingFlowIdsFieldNumber = 48,
-    kDebugAnnotationsFieldNumber = 4,
-    kTaskExecutionFieldNumber = 5,
-    kLogMessageFieldNumber = 21,
-    kCcSchedulerStateFieldNumber = 24,
-    kChromeUserEventFieldNumber = 25,
-    kChromeKeyedServiceFieldNumber = 26,
-    kChromeLegacyIpcFieldNumber = 27,
-    kChromeHistogramSampleFieldNumber = 28,
-    kChromeLatencyInfoFieldNumber = 29,
-    kChromeFrameReporterFieldNumber = 32,
-    kChromeApplicationStateInfoFieldNumber = 39,
-    kChromeRendererSchedulerStateFieldNumber = 40,
-    kChromeWindowHandleEventInfoFieldNumber = 41,
-    kChromeContentSettingsEventInfoFieldNumber = 43,
-    kChromeActiveProcessesFieldNumber = 49,
-    kSourceLocationFieldNumber = 33,
-    kSourceLocationIidFieldNumber = 34,
-    kChromeMessagePumpFieldNumber = 35,
-    kChromeMojoEventInfoFieldNumber = 38,
-    kTimestampDeltaUsFieldNumber = 1,
-    kTimestampAbsoluteUsFieldNumber = 16,
-    kThreadTimeDeltaUsFieldNumber = 2,
-    kThreadTimeAbsoluteUsFieldNumber = 17,
-    kThreadInstructionCountDeltaFieldNumber = 8,
-    kThreadInstructionCountAbsoluteFieldNumber = 20,
-    kLegacyEventFieldNumber = 6,
-  };
-
-  TrackEvent();
-  ~TrackEvent() override;
-  TrackEvent(TrackEvent&&) noexcept;
-  TrackEvent& operator=(TrackEvent&&);
-  TrackEvent(const TrackEvent&);
-  TrackEvent& operator=(const TrackEvent&);
-  bool operator==(const TrackEvent&) const;
-  bool operator!=(const TrackEvent& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<uint64_t>& category_iids() const { return category_iids_; }
-  std::vector<uint64_t>* mutable_category_iids() { return &category_iids_; }
-  int category_iids_size() const { return static_cast<int>(category_iids_.size()); }
-  void clear_category_iids() { category_iids_.clear(); }
-  void add_category_iids(uint64_t value) { category_iids_.emplace_back(value); }
-  uint64_t* add_category_iids() { category_iids_.emplace_back(); return &category_iids_.back(); }
-
-  const std::vector<std::string>& categories() const { return categories_; }
-  std::vector<std::string>* mutable_categories() { return &categories_; }
-  int categories_size() const { return static_cast<int>(categories_.size()); }
-  void clear_categories() { categories_.clear(); }
-  void add_categories(std::string value) { categories_.emplace_back(value); }
-  std::string* add_categories() { categories_.emplace_back(); return &categories_.back(); }
-
-  bool has_name_iid() const { return _has_field_[10]; }
-  uint64_t name_iid() const { return name_iid_; }
-  void set_name_iid(uint64_t value) { name_iid_ = value; _has_field_.set(10); }
-
-  bool has_name() const { return _has_field_[23]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(23); }
-
-  bool has_type() const { return _has_field_[9]; }
-  TrackEvent_Type type() const { return type_; }
-  void set_type(TrackEvent_Type value) { type_ = value; _has_field_.set(9); }
-
-  bool has_track_uuid() const { return _has_field_[11]; }
-  uint64_t track_uuid() const { return track_uuid_; }
-  void set_track_uuid(uint64_t value) { track_uuid_ = value; _has_field_.set(11); }
-
-  bool has_counter_value() const { return _has_field_[30]; }
-  int64_t counter_value() const { return counter_value_; }
-  void set_counter_value(int64_t value) { counter_value_ = value; _has_field_.set(30); }
-
-  bool has_double_counter_value() const { return _has_field_[44]; }
-  double double_counter_value() const { return double_counter_value_; }
-  void set_double_counter_value(double value) { double_counter_value_ = value; _has_field_.set(44); }
-
-  const std::vector<uint64_t>& extra_counter_track_uuids() const { return extra_counter_track_uuids_; }
-  std::vector<uint64_t>* mutable_extra_counter_track_uuids() { return &extra_counter_track_uuids_; }
-  int extra_counter_track_uuids_size() const { return static_cast<int>(extra_counter_track_uuids_.size()); }
-  void clear_extra_counter_track_uuids() { extra_counter_track_uuids_.clear(); }
-  void add_extra_counter_track_uuids(uint64_t value) { extra_counter_track_uuids_.emplace_back(value); }
-  uint64_t* add_extra_counter_track_uuids() { extra_counter_track_uuids_.emplace_back(); return &extra_counter_track_uuids_.back(); }
-
-  const std::vector<int64_t>& extra_counter_values() const { return extra_counter_values_; }
-  std::vector<int64_t>* mutable_extra_counter_values() { return &extra_counter_values_; }
-  int extra_counter_values_size() const { return static_cast<int>(extra_counter_values_.size()); }
-  void clear_extra_counter_values() { extra_counter_values_.clear(); }
-  void add_extra_counter_values(int64_t value) { extra_counter_values_.emplace_back(value); }
-  int64_t* add_extra_counter_values() { extra_counter_values_.emplace_back(); return &extra_counter_values_.back(); }
-
-  const std::vector<uint64_t>& extra_double_counter_track_uuids() const { return extra_double_counter_track_uuids_; }
-  std::vector<uint64_t>* mutable_extra_double_counter_track_uuids() { return &extra_double_counter_track_uuids_; }
-  int extra_double_counter_track_uuids_size() const { return static_cast<int>(extra_double_counter_track_uuids_.size()); }
-  void clear_extra_double_counter_track_uuids() { extra_double_counter_track_uuids_.clear(); }
-  void add_extra_double_counter_track_uuids(uint64_t value) { extra_double_counter_track_uuids_.emplace_back(value); }
-  uint64_t* add_extra_double_counter_track_uuids() { extra_double_counter_track_uuids_.emplace_back(); return &extra_double_counter_track_uuids_.back(); }
-
-  const std::vector<double>& extra_double_counter_values() const { return extra_double_counter_values_; }
-  std::vector<double>* mutable_extra_double_counter_values() { return &extra_double_counter_values_; }
-  int extra_double_counter_values_size() const { return static_cast<int>(extra_double_counter_values_.size()); }
-  void clear_extra_double_counter_values() { extra_double_counter_values_.clear(); }
-  void add_extra_double_counter_values(double value) { extra_double_counter_values_.emplace_back(value); }
-  double* add_extra_double_counter_values() { extra_double_counter_values_.emplace_back(); return &extra_double_counter_values_.back(); }
-
-  const std::vector<uint64_t>& flow_ids_old() const { return flow_ids_old_; }
-  std::vector<uint64_t>* mutable_flow_ids_old() { return &flow_ids_old_; }
-  int flow_ids_old_size() const { return static_cast<int>(flow_ids_old_.size()); }
-  void clear_flow_ids_old() { flow_ids_old_.clear(); }
-  void add_flow_ids_old(uint64_t value) { flow_ids_old_.emplace_back(value); }
-  uint64_t* add_flow_ids_old() { flow_ids_old_.emplace_back(); return &flow_ids_old_.back(); }
-
-  const std::vector<uint64_t>& flow_ids() const { return flow_ids_; }
-  std::vector<uint64_t>* mutable_flow_ids() { return &flow_ids_; }
-  int flow_ids_size() const { return static_cast<int>(flow_ids_.size()); }
-  void clear_flow_ids() { flow_ids_.clear(); }
-  void add_flow_ids(uint64_t value) { flow_ids_.emplace_back(value); }
-  uint64_t* add_flow_ids() { flow_ids_.emplace_back(); return &flow_ids_.back(); }
-
-  const std::vector<uint64_t>& terminating_flow_ids_old() const { return terminating_flow_ids_old_; }
-  std::vector<uint64_t>* mutable_terminating_flow_ids_old() { return &terminating_flow_ids_old_; }
-  int terminating_flow_ids_old_size() const { return static_cast<int>(terminating_flow_ids_old_.size()); }
-  void clear_terminating_flow_ids_old() { terminating_flow_ids_old_.clear(); }
-  void add_terminating_flow_ids_old(uint64_t value) { terminating_flow_ids_old_.emplace_back(value); }
-  uint64_t* add_terminating_flow_ids_old() { terminating_flow_ids_old_.emplace_back(); return &terminating_flow_ids_old_.back(); }
-
-  const std::vector<uint64_t>& terminating_flow_ids() const { return terminating_flow_ids_; }
-  std::vector<uint64_t>* mutable_terminating_flow_ids() { return &terminating_flow_ids_; }
-  int terminating_flow_ids_size() const { return static_cast<int>(terminating_flow_ids_.size()); }
-  void clear_terminating_flow_ids() { terminating_flow_ids_.clear(); }
-  void add_terminating_flow_ids(uint64_t value) { terminating_flow_ids_.emplace_back(value); }
-  uint64_t* add_terminating_flow_ids() { terminating_flow_ids_.emplace_back(); return &terminating_flow_ids_.back(); }
-
-  const std::vector<DebugAnnotation>& debug_annotations() const { return debug_annotations_; }
-  std::vector<DebugAnnotation>* mutable_debug_annotations() { return &debug_annotations_; }
-  int debug_annotations_size() const;
-  void clear_debug_annotations();
-  DebugAnnotation* add_debug_annotations();
-
-  bool has_task_execution() const { return _has_field_[5]; }
-  const TaskExecution& task_execution() const { return *task_execution_; }
-  TaskExecution* mutable_task_execution() { _has_field_.set(5); return task_execution_.get(); }
-
-  bool has_log_message() const { return _has_field_[21]; }
-  const LogMessage& log_message() const { return *log_message_; }
-  LogMessage* mutable_log_message() { _has_field_.set(21); return log_message_.get(); }
-
-  bool has_cc_scheduler_state() const { return _has_field_[24]; }
-  const ChromeCompositorSchedulerState& cc_scheduler_state() const { return *cc_scheduler_state_; }
-  ChromeCompositorSchedulerState* mutable_cc_scheduler_state() { _has_field_.set(24); return cc_scheduler_state_.get(); }
-
-  bool has_chrome_user_event() const { return _has_field_[25]; }
-  const ChromeUserEvent& chrome_user_event() const { return *chrome_user_event_; }
-  ChromeUserEvent* mutable_chrome_user_event() { _has_field_.set(25); return chrome_user_event_.get(); }
-
-  bool has_chrome_keyed_service() const { return _has_field_[26]; }
-  const ChromeKeyedService& chrome_keyed_service() const { return *chrome_keyed_service_; }
-  ChromeKeyedService* mutable_chrome_keyed_service() { _has_field_.set(26); return chrome_keyed_service_.get(); }
-
-  bool has_chrome_legacy_ipc() const { return _has_field_[27]; }
-  const ChromeLegacyIpc& chrome_legacy_ipc() const { return *chrome_legacy_ipc_; }
-  ChromeLegacyIpc* mutable_chrome_legacy_ipc() { _has_field_.set(27); return chrome_legacy_ipc_.get(); }
-
-  bool has_chrome_histogram_sample() const { return _has_field_[28]; }
-  const ChromeHistogramSample& chrome_histogram_sample() const { return *chrome_histogram_sample_; }
-  ChromeHistogramSample* mutable_chrome_histogram_sample() { _has_field_.set(28); return chrome_histogram_sample_.get(); }
-
-  bool has_chrome_latency_info() const { return _has_field_[29]; }
-  const ChromeLatencyInfo& chrome_latency_info() const { return *chrome_latency_info_; }
-  ChromeLatencyInfo* mutable_chrome_latency_info() { _has_field_.set(29); return chrome_latency_info_.get(); }
-
-  bool has_chrome_frame_reporter() const { return _has_field_[32]; }
-  const ChromeFrameReporter& chrome_frame_reporter() const { return *chrome_frame_reporter_; }
-  ChromeFrameReporter* mutable_chrome_frame_reporter() { _has_field_.set(32); return chrome_frame_reporter_.get(); }
-
-  bool has_chrome_application_state_info() const { return _has_field_[39]; }
-  const ChromeApplicationStateInfo& chrome_application_state_info() const { return *chrome_application_state_info_; }
-  ChromeApplicationStateInfo* mutable_chrome_application_state_info() { _has_field_.set(39); return chrome_application_state_info_.get(); }
-
-  bool has_chrome_renderer_scheduler_state() const { return _has_field_[40]; }
-  const ChromeRendererSchedulerState& chrome_renderer_scheduler_state() const { return *chrome_renderer_scheduler_state_; }
-  ChromeRendererSchedulerState* mutable_chrome_renderer_scheduler_state() { _has_field_.set(40); return chrome_renderer_scheduler_state_.get(); }
-
-  bool has_chrome_window_handle_event_info() const { return _has_field_[41]; }
-  const ChromeWindowHandleEventInfo& chrome_window_handle_event_info() const { return *chrome_window_handle_event_info_; }
-  ChromeWindowHandleEventInfo* mutable_chrome_window_handle_event_info() { _has_field_.set(41); return chrome_window_handle_event_info_.get(); }
-
-  bool has_chrome_content_settings_event_info() const { return _has_field_[43]; }
-  const ChromeContentSettingsEventInfo& chrome_content_settings_event_info() const { return *chrome_content_settings_event_info_; }
-  ChromeContentSettingsEventInfo* mutable_chrome_content_settings_event_info() { _has_field_.set(43); return chrome_content_settings_event_info_.get(); }
-
-  bool has_chrome_active_processes() const { return _has_field_[49]; }
-  const ChromeActiveProcesses& chrome_active_processes() const { return *chrome_active_processes_; }
-  ChromeActiveProcesses* mutable_chrome_active_processes() { _has_field_.set(49); return chrome_active_processes_.get(); }
-
-  bool has_source_location() const { return _has_field_[33]; }
-  const SourceLocation& source_location() const { return *source_location_; }
-  SourceLocation* mutable_source_location() { _has_field_.set(33); return source_location_.get(); }
-
-  bool has_source_location_iid() const { return _has_field_[34]; }
-  uint64_t source_location_iid() const { return source_location_iid_; }
-  void set_source_location_iid(uint64_t value) { source_location_iid_ = value; _has_field_.set(34); }
-
-  bool has_chrome_message_pump() const { return _has_field_[35]; }
-  const ChromeMessagePump& chrome_message_pump() const { return *chrome_message_pump_; }
-  ChromeMessagePump* mutable_chrome_message_pump() { _has_field_.set(35); return chrome_message_pump_.get(); }
-
-  bool has_chrome_mojo_event_info() const { return _has_field_[38]; }
-  const ChromeMojoEventInfo& chrome_mojo_event_info() const { return *chrome_mojo_event_info_; }
-  ChromeMojoEventInfo* mutable_chrome_mojo_event_info() { _has_field_.set(38); return chrome_mojo_event_info_.get(); }
-
-  bool has_timestamp_delta_us() const { return _has_field_[1]; }
-  int64_t timestamp_delta_us() const { return timestamp_delta_us_; }
-  void set_timestamp_delta_us(int64_t value) { timestamp_delta_us_ = value; _has_field_.set(1); }
-
-  bool has_timestamp_absolute_us() const { return _has_field_[16]; }
-  int64_t timestamp_absolute_us() const { return timestamp_absolute_us_; }
-  void set_timestamp_absolute_us(int64_t value) { timestamp_absolute_us_ = value; _has_field_.set(16); }
-
-  bool has_thread_time_delta_us() const { return _has_field_[2]; }
-  int64_t thread_time_delta_us() const { return thread_time_delta_us_; }
-  void set_thread_time_delta_us(int64_t value) { thread_time_delta_us_ = value; _has_field_.set(2); }
-
-  bool has_thread_time_absolute_us() const { return _has_field_[17]; }
-  int64_t thread_time_absolute_us() const { return thread_time_absolute_us_; }
-  void set_thread_time_absolute_us(int64_t value) { thread_time_absolute_us_ = value; _has_field_.set(17); }
-
-  bool has_thread_instruction_count_delta() const { return _has_field_[8]; }
-  int64_t thread_instruction_count_delta() const { return thread_instruction_count_delta_; }
-  void set_thread_instruction_count_delta(int64_t value) { thread_instruction_count_delta_ = value; _has_field_.set(8); }
-
-  bool has_thread_instruction_count_absolute() const { return _has_field_[20]; }
-  int64_t thread_instruction_count_absolute() const { return thread_instruction_count_absolute_; }
-  void set_thread_instruction_count_absolute(int64_t value) { thread_instruction_count_absolute_ = value; _has_field_.set(20); }
-
-  bool has_legacy_event() const { return _has_field_[6]; }
-  const TrackEvent_LegacyEvent& legacy_event() const { return *legacy_event_; }
-  TrackEvent_LegacyEvent* mutable_legacy_event() { _has_field_.set(6); return legacy_event_.get(); }
-
- private:
-  std::vector<uint64_t> category_iids_;
-  std::vector<std::string> categories_;
-  uint64_t name_iid_{};
-  std::string name_{};
-  TrackEvent_Type type_{};
-  uint64_t track_uuid_{};
-  int64_t counter_value_{};
-  double double_counter_value_{};
-  std::vector<uint64_t> extra_counter_track_uuids_;
-  std::vector<int64_t> extra_counter_values_;
-  std::vector<uint64_t> extra_double_counter_track_uuids_;
-  std::vector<double> extra_double_counter_values_;
-  std::vector<uint64_t> flow_ids_old_;
-  std::vector<uint64_t> flow_ids_;
-  std::vector<uint64_t> terminating_flow_ids_old_;
-  std::vector<uint64_t> terminating_flow_ids_;
-  std::vector<DebugAnnotation> debug_annotations_;
-  ::protozero::CopyablePtr<TaskExecution> task_execution_;
-  ::protozero::CopyablePtr<LogMessage> log_message_;
-  ::protozero::CopyablePtr<ChromeCompositorSchedulerState> cc_scheduler_state_;
-  ::protozero::CopyablePtr<ChromeUserEvent> chrome_user_event_;
-  ::protozero::CopyablePtr<ChromeKeyedService> chrome_keyed_service_;
-  ::protozero::CopyablePtr<ChromeLegacyIpc> chrome_legacy_ipc_;
-  ::protozero::CopyablePtr<ChromeHistogramSample> chrome_histogram_sample_;
-  ::protozero::CopyablePtr<ChromeLatencyInfo> chrome_latency_info_;
-  ::protozero::CopyablePtr<ChromeFrameReporter> chrome_frame_reporter_;
-  ::protozero::CopyablePtr<ChromeApplicationStateInfo> chrome_application_state_info_;
-  ::protozero::CopyablePtr<ChromeRendererSchedulerState> chrome_renderer_scheduler_state_;
-  ::protozero::CopyablePtr<ChromeWindowHandleEventInfo> chrome_window_handle_event_info_;
-  ::protozero::CopyablePtr<ChromeContentSettingsEventInfo> chrome_content_settings_event_info_;
-  ::protozero::CopyablePtr<ChromeActiveProcesses> chrome_active_processes_;
-  ::protozero::CopyablePtr<SourceLocation> source_location_;
-  uint64_t source_location_iid_{};
-  ::protozero::CopyablePtr<ChromeMessagePump> chrome_message_pump_;
-  ::protozero::CopyablePtr<ChromeMojoEventInfo> chrome_mojo_event_info_;
-  int64_t timestamp_delta_us_{};
-  int64_t timestamp_absolute_us_{};
-  int64_t thread_time_delta_us_{};
-  int64_t thread_time_absolute_us_{};
-  int64_t thread_instruction_count_delta_{};
-  int64_t thread_instruction_count_absolute_{};
-  ::protozero::CopyablePtr<TrackEvent_LegacyEvent> legacy_event_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<50> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT TrackEvent_LegacyEvent : public ::protozero::CppMessageObj {
- public:
-  using FlowDirection = TrackEvent_LegacyEvent_FlowDirection;
-  static constexpr auto FLOW_UNSPECIFIED = TrackEvent_LegacyEvent_FlowDirection_FLOW_UNSPECIFIED;
-  static constexpr auto FLOW_IN = TrackEvent_LegacyEvent_FlowDirection_FLOW_IN;
-  static constexpr auto FLOW_OUT = TrackEvent_LegacyEvent_FlowDirection_FLOW_OUT;
-  static constexpr auto FLOW_INOUT = TrackEvent_LegacyEvent_FlowDirection_FLOW_INOUT;
-  static constexpr auto FlowDirection_MIN = TrackEvent_LegacyEvent_FlowDirection_FLOW_UNSPECIFIED;
-  static constexpr auto FlowDirection_MAX = TrackEvent_LegacyEvent_FlowDirection_FLOW_INOUT;
-  using InstantEventScope = TrackEvent_LegacyEvent_InstantEventScope;
-  static constexpr auto SCOPE_UNSPECIFIED = TrackEvent_LegacyEvent_InstantEventScope_SCOPE_UNSPECIFIED;
-  static constexpr auto SCOPE_GLOBAL = TrackEvent_LegacyEvent_InstantEventScope_SCOPE_GLOBAL;
-  static constexpr auto SCOPE_PROCESS = TrackEvent_LegacyEvent_InstantEventScope_SCOPE_PROCESS;
-  static constexpr auto SCOPE_THREAD = TrackEvent_LegacyEvent_InstantEventScope_SCOPE_THREAD;
-  static constexpr auto InstantEventScope_MIN = TrackEvent_LegacyEvent_InstantEventScope_SCOPE_UNSPECIFIED;
-  static constexpr auto InstantEventScope_MAX = TrackEvent_LegacyEvent_InstantEventScope_SCOPE_THREAD;
-  enum FieldNumbers {
-    kNameIidFieldNumber = 1,
-    kPhaseFieldNumber = 2,
-    kDurationUsFieldNumber = 3,
-    kThreadDurationUsFieldNumber = 4,
-    kThreadInstructionDeltaFieldNumber = 15,
-    kUnscopedIdFieldNumber = 6,
-    kLocalIdFieldNumber = 10,
-    kGlobalIdFieldNumber = 11,
-    kIdScopeFieldNumber = 7,
-    kUseAsyncTtsFieldNumber = 9,
-    kBindIdFieldNumber = 8,
-    kBindToEnclosingFieldNumber = 12,
-    kFlowDirectionFieldNumber = 13,
-    kInstantEventScopeFieldNumber = 14,
-    kPidOverrideFieldNumber = 18,
-    kTidOverrideFieldNumber = 19,
-  };
-
-  TrackEvent_LegacyEvent();
-  ~TrackEvent_LegacyEvent() override;
-  TrackEvent_LegacyEvent(TrackEvent_LegacyEvent&&) noexcept;
-  TrackEvent_LegacyEvent& operator=(TrackEvent_LegacyEvent&&);
-  TrackEvent_LegacyEvent(const TrackEvent_LegacyEvent&);
-  TrackEvent_LegacyEvent& operator=(const TrackEvent_LegacyEvent&);
-  bool operator==(const TrackEvent_LegacyEvent&) const;
-  bool operator!=(const TrackEvent_LegacyEvent& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_name_iid() const { return _has_field_[1]; }
-  uint64_t name_iid() const { return name_iid_; }
-  void set_name_iid(uint64_t value) { name_iid_ = value; _has_field_.set(1); }
-
-  bool has_phase() const { return _has_field_[2]; }
-  int32_t phase() const { return phase_; }
-  void set_phase(int32_t value) { phase_ = value; _has_field_.set(2); }
-
-  bool has_duration_us() const { return _has_field_[3]; }
-  int64_t duration_us() const { return duration_us_; }
-  void set_duration_us(int64_t value) { duration_us_ = value; _has_field_.set(3); }
-
-  bool has_thread_duration_us() const { return _has_field_[4]; }
-  int64_t thread_duration_us() const { return thread_duration_us_; }
-  void set_thread_duration_us(int64_t value) { thread_duration_us_ = value; _has_field_.set(4); }
-
-  bool has_thread_instruction_delta() const { return _has_field_[15]; }
-  int64_t thread_instruction_delta() const { return thread_instruction_delta_; }
-  void set_thread_instruction_delta(int64_t value) { thread_instruction_delta_ = value; _has_field_.set(15); }
-
-  bool has_unscoped_id() const { return _has_field_[6]; }
-  uint64_t unscoped_id() const { return unscoped_id_; }
-  void set_unscoped_id(uint64_t value) { unscoped_id_ = value; _has_field_.set(6); }
-
-  bool has_local_id() const { return _has_field_[10]; }
-  uint64_t local_id() const { return local_id_; }
-  void set_local_id(uint64_t value) { local_id_ = value; _has_field_.set(10); }
-
-  bool has_global_id() const { return _has_field_[11]; }
-  uint64_t global_id() const { return global_id_; }
-  void set_global_id(uint64_t value) { global_id_ = value; _has_field_.set(11); }
-
-  bool has_id_scope() const { return _has_field_[7]; }
-  const std::string& id_scope() const { return id_scope_; }
-  void set_id_scope(const std::string& value) { id_scope_ = value; _has_field_.set(7); }
-
-  bool has_use_async_tts() const { return _has_field_[9]; }
-  bool use_async_tts() const { return use_async_tts_; }
-  void set_use_async_tts(bool value) { use_async_tts_ = value; _has_field_.set(9); }
-
-  bool has_bind_id() const { return _has_field_[8]; }
-  uint64_t bind_id() const { return bind_id_; }
-  void set_bind_id(uint64_t value) { bind_id_ = value; _has_field_.set(8); }
-
-  bool has_bind_to_enclosing() const { return _has_field_[12]; }
-  bool bind_to_enclosing() const { return bind_to_enclosing_; }
-  void set_bind_to_enclosing(bool value) { bind_to_enclosing_ = value; _has_field_.set(12); }
-
-  bool has_flow_direction() const { return _has_field_[13]; }
-  TrackEvent_LegacyEvent_FlowDirection flow_direction() const { return flow_direction_; }
-  void set_flow_direction(TrackEvent_LegacyEvent_FlowDirection value) { flow_direction_ = value; _has_field_.set(13); }
-
-  bool has_instant_event_scope() const { return _has_field_[14]; }
-  TrackEvent_LegacyEvent_InstantEventScope instant_event_scope() const { return instant_event_scope_; }
-  void set_instant_event_scope(TrackEvent_LegacyEvent_InstantEventScope value) { instant_event_scope_ = value; _has_field_.set(14); }
-
-  bool has_pid_override() const { return _has_field_[18]; }
-  int32_t pid_override() const { return pid_override_; }
-  void set_pid_override(int32_t value) { pid_override_ = value; _has_field_.set(18); }
-
-  bool has_tid_override() const { return _has_field_[19]; }
-  int32_t tid_override() const { return tid_override_; }
-  void set_tid_override(int32_t value) { tid_override_ = value; _has_field_.set(19); }
-
- private:
-  uint64_t name_iid_{};
-  int32_t phase_{};
-  int64_t duration_us_{};
-  int64_t thread_duration_us_{};
-  int64_t thread_instruction_delta_{};
-  uint64_t unscoped_id_{};
-  uint64_t local_id_{};
-  uint64_t global_id_{};
-  std::string id_scope_{};
-  bool use_async_tts_{};
-  uint64_t bind_id_{};
-  bool bind_to_enclosing_{};
-  TrackEvent_LegacyEvent_FlowDirection flow_direction_{};
-  TrackEvent_LegacyEvent_InstantEventScope instant_event_scope_{};
-  int32_t pid_override_{};
-  int32_t tid_override_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<20> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TRACK_EVENT_PROTO_CPP_H_
-// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_event.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/source_location.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_window_handle_event_info.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_user_event.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_renderer_scheduler_state.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_mojo_event_info.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_message_pump.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_legacy_ipc.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_latency_info.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_keyed_service.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_histogram_sample.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_frame_reporter.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_content_settings_event_info.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_compositor_scheduler_state.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_application_state_info.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_active_processes.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/task_execution.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/log_message.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/debug_annotation.gen.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
 
-EventName::EventName() = default;
-EventName::~EventName() = default;
-EventName::EventName(const EventName&) = default;
-EventName& EventName::operator=(const EventName&) = default;
-EventName::EventName(EventName&&) noexcept = default;
-EventName& EventName::operator=(EventName&&) = default;
+BeginImplFrameArgs_TimestampsInUs::BeginImplFrameArgs_TimestampsInUs() = default;
+BeginImplFrameArgs_TimestampsInUs::~BeginImplFrameArgs_TimestampsInUs() = default;
+BeginImplFrameArgs_TimestampsInUs::BeginImplFrameArgs_TimestampsInUs(const BeginImplFrameArgs_TimestampsInUs&) = default;
+BeginImplFrameArgs_TimestampsInUs& BeginImplFrameArgs_TimestampsInUs::operator=(const BeginImplFrameArgs_TimestampsInUs&) = default;
+BeginImplFrameArgs_TimestampsInUs::BeginImplFrameArgs_TimestampsInUs(BeginImplFrameArgs_TimestampsInUs&&) noexcept = default;
+BeginImplFrameArgs_TimestampsInUs& BeginImplFrameArgs_TimestampsInUs::operator=(BeginImplFrameArgs_TimestampsInUs&&) = default;
 
-bool EventName::operator==(const EventName& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && iid_ == other.iid_
-   && name_ == other.name_;
+bool BeginImplFrameArgs_TimestampsInUs::operator==(const BeginImplFrameArgs_TimestampsInUs& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(interval_delta_, other.interval_delta_)
+   && ::protozero::internal::gen_helpers::EqualsField(now_to_deadline_delta_, other.now_to_deadline_delta_)
+   && ::protozero::internal::gen_helpers::EqualsField(frame_time_to_now_delta_, other.frame_time_to_now_delta_)
+   && ::protozero::internal::gen_helpers::EqualsField(frame_time_to_deadline_delta_, other.frame_time_to_deadline_delta_)
+   && ::protozero::internal::gen_helpers::EqualsField(now_, other.now_)
+   && ::protozero::internal::gen_helpers::EqualsField(frame_time_, other.frame_time_)
+   && ::protozero::internal::gen_helpers::EqualsField(deadline_, other.deadline_);
 }
 
-bool EventName::ParseFromArray(const void* raw, size_t size) {
+bool BeginImplFrameArgs_TimestampsInUs::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -37131,11 +30893,26 @@ bool EventName::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* iid */:
-        field.get(&iid_);
+      case 1 /* interval_delta */:
+        field.get(&interval_delta_);
         break;
-      case 2 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+      case 2 /* now_to_deadline_delta */:
+        field.get(&now_to_deadline_delta_);
+        break;
+      case 3 /* frame_time_to_now_delta */:
+        field.get(&frame_time_to_now_delta_);
+        break;
+      case 4 /* frame_time_to_deadline_delta */:
+        field.get(&frame_time_to_deadline_delta_);
+        break;
+      case 5 /* now */:
+        field.get(&now_);
+        break;
+      case 6 /* frame_time */:
+        field.get(&frame_time_);
+        break;
+      case 7 /* deadline */:
+        field.get(&deadline_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -37145,114 +30922,72 @@ bool EventName::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string EventName::SerializeAsString() const {
+std::string BeginImplFrameArgs_TimestampsInUs::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> EventName::SerializeAsArray() const {
+std::vector<uint8_t> BeginImplFrameArgs_TimestampsInUs::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void EventName::Serialize(::protozero::Message* msg) const {
-  // Field 1: iid
+void BeginImplFrameArgs_TimestampsInUs::Serialize(::protozero::Message* msg) const {
+  // Field 1: interval_delta
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, iid_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, interval_delta_, msg);
   }
 
-  // Field 2: name
+  // Field 2: now_to_deadline_delta
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeString(2, name_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, now_to_deadline_delta_, msg);
   }
 
-  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
-}
-
-
-EventCategory::EventCategory() = default;
-EventCategory::~EventCategory() = default;
-EventCategory::EventCategory(const EventCategory&) = default;
-EventCategory& EventCategory::operator=(const EventCategory&) = default;
-EventCategory::EventCategory(EventCategory&&) noexcept = default;
-EventCategory& EventCategory::operator=(EventCategory&&) = default;
-
-bool EventCategory::operator==(const EventCategory& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && iid_ == other.iid_
-   && name_ == other.name_;
-}
-
-bool EventCategory::ParseFromArray(const void* raw, size_t size) {
-  unknown_fields_.clear();
-  bool packed_error = false;
-
-  ::protozero::ProtoDecoder dec(raw, size);
-  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
-    if (field.id() < _has_field_.size()) {
-      _has_field_.set(field.id());
-    }
-    switch (field.id()) {
-      case 1 /* iid */:
-        field.get(&iid_);
-        break;
-      case 2 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
-        break;
-      default:
-        field.SerializeAndAppendTo(&unknown_fields_);
-        break;
-    }
+  // Field 3: frame_time_to_now_delta
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, frame_time_to_now_delta_, msg);
   }
-  return !packed_error && !dec.bytes_left();
-}
 
-std::string EventCategory::SerializeAsString() const {
-  ::protozero::internal::gen_helpers::MessageSerializer msg;
-  Serialize(msg.get());
-  return msg.SerializeAsString();
-}
+  // Field 4: frame_time_to_deadline_delta
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, frame_time_to_deadline_delta_, msg);
+  }
 
-std::vector<uint8_t> EventCategory::SerializeAsArray() const {
-  ::protozero::internal::gen_helpers::MessageSerializer msg;
-  Serialize(msg.get());
-  return msg.SerializeAsArray();
-}
+  // Field 5: now
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, now_, msg);
+  }
 
-void EventCategory::Serialize(::protozero::Message* msg) const {
-  // Field 1: iid
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, iid_, msg);
+  // Field 6: frame_time
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, frame_time_, msg);
   }
 
-  // Field 2: name
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeString(2, name_, msg);
+  // Field 7: deadline
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(7, deadline_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-TrackEventDefaults::TrackEventDefaults() = default;
-TrackEventDefaults::~TrackEventDefaults() = default;
-TrackEventDefaults::TrackEventDefaults(const TrackEventDefaults&) = default;
-TrackEventDefaults& TrackEventDefaults::operator=(const TrackEventDefaults&) = default;
-TrackEventDefaults::TrackEventDefaults(TrackEventDefaults&&) noexcept = default;
-TrackEventDefaults& TrackEventDefaults::operator=(TrackEventDefaults&&) = default;
+ChromeCompositorStateMachine::ChromeCompositorStateMachine() = default;
+ChromeCompositorStateMachine::~ChromeCompositorStateMachine() = default;
+ChromeCompositorStateMachine::ChromeCompositorStateMachine(const ChromeCompositorStateMachine&) = default;
+ChromeCompositorStateMachine& ChromeCompositorStateMachine::operator=(const ChromeCompositorStateMachine&) = default;
+ChromeCompositorStateMachine::ChromeCompositorStateMachine(ChromeCompositorStateMachine&&) noexcept = default;
+ChromeCompositorStateMachine& ChromeCompositorStateMachine::operator=(ChromeCompositorStateMachine&&) = default;
 
-bool TrackEventDefaults::operator==(const TrackEventDefaults& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && track_uuid_ == other.track_uuid_
-   && extra_counter_track_uuids_ == other.extra_counter_track_uuids_
-   && extra_double_counter_track_uuids_ == other.extra_double_counter_track_uuids_;
+bool ChromeCompositorStateMachine::operator==(const ChromeCompositorStateMachine& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(major_state_, other.major_state_)
+   && ::protozero::internal::gen_helpers::EqualsField(minor_state_, other.minor_state_);
 }
 
-bool TrackEventDefaults::ParseFromArray(const void* raw, size_t size) {
-  extra_counter_track_uuids_.clear();
-  extra_double_counter_track_uuids_.clear();
+bool ChromeCompositorStateMachine::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -37262,16 +30997,11 @@ bool TrackEventDefaults::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 11 /* track_uuid */:
-        field.get(&track_uuid_);
-        break;
-      case 31 /* extra_counter_track_uuids */:
-        extra_counter_track_uuids_.emplace_back();
-        field.get(&extra_counter_track_uuids_.back());
+      case 1 /* major_state */:
+        (*major_state_).ParseFromArray(field.data(), field.size());
         break;
-      case 45 /* extra_double_counter_track_uuids */:
-        extra_double_counter_track_uuids_.emplace_back();
-        field.get(&extra_double_counter_track_uuids_.back());
+      case 2 /* minor_state */:
+        (*minor_state_).ParseFromArray(field.data(), field.size());
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -37281,106 +31011,90 @@ bool TrackEventDefaults::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TrackEventDefaults::SerializeAsString() const {
+std::string ChromeCompositorStateMachine::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TrackEventDefaults::SerializeAsArray() const {
+std::vector<uint8_t> ChromeCompositorStateMachine::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TrackEventDefaults::Serialize(::protozero::Message* msg) const {
-  // Field 11: track_uuid
-  if (_has_field_[11]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(11, track_uuid_, msg);
-  }
-
-  // Field 31: extra_counter_track_uuids
-  for (auto& it : extra_counter_track_uuids_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(31, it, msg);
+void ChromeCompositorStateMachine::Serialize(::protozero::Message* msg) const {
+  // Field 1: major_state
+  if (_has_field_[1]) {
+    (*major_state_).Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
   }
 
-  // Field 45: extra_double_counter_track_uuids
-  for (auto& it : extra_double_counter_track_uuids_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(45, it, msg);
+  // Field 2: minor_state
+  if (_has_field_[2]) {
+    (*minor_state_).Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-TrackEvent::TrackEvent() = default;
-TrackEvent::~TrackEvent() = default;
-TrackEvent::TrackEvent(const TrackEvent&) = default;
-TrackEvent& TrackEvent::operator=(const TrackEvent&) = default;
-TrackEvent::TrackEvent(TrackEvent&&) noexcept = default;
-TrackEvent& TrackEvent::operator=(TrackEvent&&) = default;
+ChromeCompositorStateMachine_MinorState::ChromeCompositorStateMachine_MinorState() = default;
+ChromeCompositorStateMachine_MinorState::~ChromeCompositorStateMachine_MinorState() = default;
+ChromeCompositorStateMachine_MinorState::ChromeCompositorStateMachine_MinorState(const ChromeCompositorStateMachine_MinorState&) = default;
+ChromeCompositorStateMachine_MinorState& ChromeCompositorStateMachine_MinorState::operator=(const ChromeCompositorStateMachine_MinorState&) = default;
+ChromeCompositorStateMachine_MinorState::ChromeCompositorStateMachine_MinorState(ChromeCompositorStateMachine_MinorState&&) noexcept = default;
+ChromeCompositorStateMachine_MinorState& ChromeCompositorStateMachine_MinorState::operator=(ChromeCompositorStateMachine_MinorState&&) = default;
 
-bool TrackEvent::operator==(const TrackEvent& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && category_iids_ == other.category_iids_
-   && categories_ == other.categories_
-   && name_iid_ == other.name_iid_
-   && name_ == other.name_
-   && type_ == other.type_
-   && track_uuid_ == other.track_uuid_
-   && counter_value_ == other.counter_value_
-   && double_counter_value_ == other.double_counter_value_
-   && extra_counter_track_uuids_ == other.extra_counter_track_uuids_
-   && extra_counter_values_ == other.extra_counter_values_
-   && extra_double_counter_track_uuids_ == other.extra_double_counter_track_uuids_
-   && extra_double_counter_values_ == other.extra_double_counter_values_
-   && flow_ids_old_ == other.flow_ids_old_
-   && flow_ids_ == other.flow_ids_
-   && terminating_flow_ids_old_ == other.terminating_flow_ids_old_
-   && terminating_flow_ids_ == other.terminating_flow_ids_
-   && debug_annotations_ == other.debug_annotations_
-   && task_execution_ == other.task_execution_
-   && log_message_ == other.log_message_
-   && cc_scheduler_state_ == other.cc_scheduler_state_
-   && chrome_user_event_ == other.chrome_user_event_
-   && chrome_keyed_service_ == other.chrome_keyed_service_
-   && chrome_legacy_ipc_ == other.chrome_legacy_ipc_
-   && chrome_histogram_sample_ == other.chrome_histogram_sample_
-   && chrome_latency_info_ == other.chrome_latency_info_
-   && chrome_frame_reporter_ == other.chrome_frame_reporter_
-   && chrome_application_state_info_ == other.chrome_application_state_info_
-   && chrome_renderer_scheduler_state_ == other.chrome_renderer_scheduler_state_
-   && chrome_window_handle_event_info_ == other.chrome_window_handle_event_info_
-   && chrome_content_settings_event_info_ == other.chrome_content_settings_event_info_
-   && chrome_active_processes_ == other.chrome_active_processes_
-   && source_location_ == other.source_location_
-   && source_location_iid_ == other.source_location_iid_
-   && chrome_message_pump_ == other.chrome_message_pump_
-   && chrome_mojo_event_info_ == other.chrome_mojo_event_info_
-   && timestamp_delta_us_ == other.timestamp_delta_us_
-   && timestamp_absolute_us_ == other.timestamp_absolute_us_
-   && thread_time_delta_us_ == other.thread_time_delta_us_
-   && thread_time_absolute_us_ == other.thread_time_absolute_us_
-   && thread_instruction_count_delta_ == other.thread_instruction_count_delta_
-   && thread_instruction_count_absolute_ == other.thread_instruction_count_absolute_
-   && legacy_event_ == other.legacy_event_;
+bool ChromeCompositorStateMachine_MinorState::operator==(const ChromeCompositorStateMachine_MinorState& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(commit_count_, other.commit_count_)
+   && ::protozero::internal::gen_helpers::EqualsField(current_frame_number_, other.current_frame_number_)
+   && ::protozero::internal::gen_helpers::EqualsField(last_frame_number_submit_performed_, other.last_frame_number_submit_performed_)
+   && ::protozero::internal::gen_helpers::EqualsField(last_frame_number_draw_performed_, other.last_frame_number_draw_performed_)
+   && ::protozero::internal::gen_helpers::EqualsField(last_frame_number_begin_main_frame_sent_, other.last_frame_number_begin_main_frame_sent_)
+   && ::protozero::internal::gen_helpers::EqualsField(did_draw_, other.did_draw_)
+   && ::protozero::internal::gen_helpers::EqualsField(did_send_begin_main_frame_for_current_frame_, other.did_send_begin_main_frame_for_current_frame_)
+   && ::protozero::internal::gen_helpers::EqualsField(did_notify_begin_main_frame_not_expected_until_, other.did_notify_begin_main_frame_not_expected_until_)
+   && ::protozero::internal::gen_helpers::EqualsField(did_notify_begin_main_frame_not_expected_soon_, other.did_notify_begin_main_frame_not_expected_soon_)
+   && ::protozero::internal::gen_helpers::EqualsField(wants_begin_main_frame_not_expected_, other.wants_begin_main_frame_not_expected_)
+   && ::protozero::internal::gen_helpers::EqualsField(did_commit_during_frame_, other.did_commit_during_frame_)
+   && ::protozero::internal::gen_helpers::EqualsField(did_invalidate_layer_tree_frame_sink_, other.did_invalidate_layer_tree_frame_sink_)
+   && ::protozero::internal::gen_helpers::EqualsField(did_perform_impl_side_invalidaion_, other.did_perform_impl_side_invalidaion_)
+   && ::protozero::internal::gen_helpers::EqualsField(did_prepare_tiles_, other.did_prepare_tiles_)
+   && ::protozero::internal::gen_helpers::EqualsField(consecutive_checkerboard_animations_, other.consecutive_checkerboard_animations_)
+   && ::protozero::internal::gen_helpers::EqualsField(pending_submit_frames_, other.pending_submit_frames_)
+   && ::protozero::internal::gen_helpers::EqualsField(submit_frames_with_current_layer_tree_frame_sink_, other.submit_frames_with_current_layer_tree_frame_sink_)
+   && ::protozero::internal::gen_helpers::EqualsField(needs_redraw_, other.needs_redraw_)
+   && ::protozero::internal::gen_helpers::EqualsField(needs_prepare_tiles_, other.needs_prepare_tiles_)
+   && ::protozero::internal::gen_helpers::EqualsField(needs_begin_main_frame_, other.needs_begin_main_frame_)
+   && ::protozero::internal::gen_helpers::EqualsField(needs_one_begin_impl_frame_, other.needs_one_begin_impl_frame_)
+   && ::protozero::internal::gen_helpers::EqualsField(visible_, other.visible_)
+   && ::protozero::internal::gen_helpers::EqualsField(begin_frame_source_paused_, other.begin_frame_source_paused_)
+   && ::protozero::internal::gen_helpers::EqualsField(can_draw_, other.can_draw_)
+   && ::protozero::internal::gen_helpers::EqualsField(resourceless_draw_, other.resourceless_draw_)
+   && ::protozero::internal::gen_helpers::EqualsField(has_pending_tree_, other.has_pending_tree_)
+   && ::protozero::internal::gen_helpers::EqualsField(pending_tree_is_ready_for_activation_, other.pending_tree_is_ready_for_activation_)
+   && ::protozero::internal::gen_helpers::EqualsField(active_tree_needs_first_draw_, other.active_tree_needs_first_draw_)
+   && ::protozero::internal::gen_helpers::EqualsField(active_tree_is_ready_to_draw_, other.active_tree_is_ready_to_draw_)
+   && ::protozero::internal::gen_helpers::EqualsField(did_create_and_initialize_first_layer_tree_frame_sink_, other.did_create_and_initialize_first_layer_tree_frame_sink_)
+   && ::protozero::internal::gen_helpers::EqualsField(tree_priority_, other.tree_priority_)
+   && ::protozero::internal::gen_helpers::EqualsField(scroll_handler_state_, other.scroll_handler_state_)
+   && ::protozero::internal::gen_helpers::EqualsField(critical_begin_main_frame_to_activate_is_fast_, other.critical_begin_main_frame_to_activate_is_fast_)
+   && ::protozero::internal::gen_helpers::EqualsField(main_thread_missed_last_deadline_, other.main_thread_missed_last_deadline_)
+   && ::protozero::internal::gen_helpers::EqualsField(video_needs_begin_frames_, other.video_needs_begin_frames_)
+   && ::protozero::internal::gen_helpers::EqualsField(defer_begin_main_frame_, other.defer_begin_main_frame_)
+   && ::protozero::internal::gen_helpers::EqualsField(last_commit_had_no_updates_, other.last_commit_had_no_updates_)
+   && ::protozero::internal::gen_helpers::EqualsField(did_draw_in_last_frame_, other.did_draw_in_last_frame_)
+   && ::protozero::internal::gen_helpers::EqualsField(did_submit_in_last_frame_, other.did_submit_in_last_frame_)
+   && ::protozero::internal::gen_helpers::EqualsField(needs_impl_side_invalidation_, other.needs_impl_side_invalidation_)
+   && ::protozero::internal::gen_helpers::EqualsField(current_pending_tree_is_impl_side_, other.current_pending_tree_is_impl_side_)
+   && ::protozero::internal::gen_helpers::EqualsField(previous_pending_tree_was_impl_side_, other.previous_pending_tree_was_impl_side_)
+   && ::protozero::internal::gen_helpers::EqualsField(processing_animation_worklets_for_active_tree_, other.processing_animation_worklets_for_active_tree_)
+   && ::protozero::internal::gen_helpers::EqualsField(processing_animation_worklets_for_pending_tree_, other.processing_animation_worklets_for_pending_tree_)
+   && ::protozero::internal::gen_helpers::EqualsField(processing_paint_worklets_for_pending_tree_, other.processing_paint_worklets_for_pending_tree_);
 }
 
-int TrackEvent::debug_annotations_size() const { return static_cast<int>(debug_annotations_.size()); }
-void TrackEvent::clear_debug_annotations() { debug_annotations_.clear(); }
-DebugAnnotation* TrackEvent::add_debug_annotations() { debug_annotations_.emplace_back(); return &debug_annotations_.back(); }
-bool TrackEvent::ParseFromArray(const void* raw, size_t size) {
-  category_iids_.clear();
-  categories_.clear();
-  extra_counter_track_uuids_.clear();
-  extra_counter_values_.clear();
-  extra_double_counter_track_uuids_.clear();
-  extra_double_counter_values_.clear();
-  flow_ids_old_.clear();
-  flow_ids_.clear();
-  terminating_flow_ids_old_.clear();
-  terminating_flow_ids_.clear();
-  debug_annotations_.clear();
+bool ChromeCompositorStateMachine_MinorState::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -37390,142 +31104,140 @@ bool TrackEvent::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 3 /* category_iids */:
-        category_iids_.emplace_back();
-        field.get(&category_iids_.back());
+      case 1 /* commit_count */:
+        field.get(&commit_count_);
         break;
-      case 22 /* categories */:
-        categories_.emplace_back();
-        ::protozero::internal::gen_helpers::DeserializeString(field, &categories_.back());
+      case 2 /* current_frame_number */:
+        field.get(&current_frame_number_);
         break;
-      case 10 /* name_iid */:
-        field.get(&name_iid_);
+      case 3 /* last_frame_number_submit_performed */:
+        field.get(&last_frame_number_submit_performed_);
         break;
-      case 23 /* name */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+      case 4 /* last_frame_number_draw_performed */:
+        field.get(&last_frame_number_draw_performed_);
         break;
-      case 9 /* type */:
-        field.get(&type_);
+      case 5 /* last_frame_number_begin_main_frame_sent */:
+        field.get(&last_frame_number_begin_main_frame_sent_);
         break;
-      case 11 /* track_uuid */:
-        field.get(&track_uuid_);
+      case 6 /* did_draw */:
+        field.get(&did_draw_);
         break;
-      case 30 /* counter_value */:
-        field.get(&counter_value_);
+      case 7 /* did_send_begin_main_frame_for_current_frame */:
+        field.get(&did_send_begin_main_frame_for_current_frame_);
         break;
-      case 44 /* double_counter_value */:
-        field.get(&double_counter_value_);
+      case 8 /* did_notify_begin_main_frame_not_expected_until */:
+        field.get(&did_notify_begin_main_frame_not_expected_until_);
         break;
-      case 31 /* extra_counter_track_uuids */:
-        extra_counter_track_uuids_.emplace_back();
-        field.get(&extra_counter_track_uuids_.back());
+      case 9 /* did_notify_begin_main_frame_not_expected_soon */:
+        field.get(&did_notify_begin_main_frame_not_expected_soon_);
         break;
-      case 12 /* extra_counter_values */:
-        extra_counter_values_.emplace_back();
-        field.get(&extra_counter_values_.back());
+      case 10 /* wants_begin_main_frame_not_expected */:
+        field.get(&wants_begin_main_frame_not_expected_);
         break;
-      case 45 /* extra_double_counter_track_uuids */:
-        extra_double_counter_track_uuids_.emplace_back();
-        field.get(&extra_double_counter_track_uuids_.back());
+      case 11 /* did_commit_during_frame */:
+        field.get(&did_commit_during_frame_);
         break;
-      case 46 /* extra_double_counter_values */:
-        extra_double_counter_values_.emplace_back();
-        field.get(&extra_double_counter_values_.back());
+      case 12 /* did_invalidate_layer_tree_frame_sink */:
+        field.get(&did_invalidate_layer_tree_frame_sink_);
         break;
-      case 36 /* flow_ids_old */:
-        flow_ids_old_.emplace_back();
-        field.get(&flow_ids_old_.back());
+      case 13 /* did_perform_impl_side_invalidaion */:
+        field.get(&did_perform_impl_side_invalidaion_);
         break;
-      case 47 /* flow_ids */:
-        flow_ids_.emplace_back();
-        field.get(&flow_ids_.back());
+      case 14 /* did_prepare_tiles */:
+        field.get(&did_prepare_tiles_);
         break;
-      case 42 /* terminating_flow_ids_old */:
-        terminating_flow_ids_old_.emplace_back();
-        field.get(&terminating_flow_ids_old_.back());
+      case 15 /* consecutive_checkerboard_animations */:
+        field.get(&consecutive_checkerboard_animations_);
         break;
-      case 48 /* terminating_flow_ids */:
-        terminating_flow_ids_.emplace_back();
-        field.get(&terminating_flow_ids_.back());
+      case 16 /* pending_submit_frames */:
+        field.get(&pending_submit_frames_);
         break;
-      case 4 /* debug_annotations */:
-        debug_annotations_.emplace_back();
-        debug_annotations_.back().ParseFromArray(field.data(), field.size());
+      case 17 /* submit_frames_with_current_layer_tree_frame_sink */:
+        field.get(&submit_frames_with_current_layer_tree_frame_sink_);
         break;
-      case 5 /* task_execution */:
-        (*task_execution_).ParseFromArray(field.data(), field.size());
+      case 18 /* needs_redraw */:
+        field.get(&needs_redraw_);
         break;
-      case 21 /* log_message */:
-        (*log_message_).ParseFromArray(field.data(), field.size());
+      case 19 /* needs_prepare_tiles */:
+        field.get(&needs_prepare_tiles_);
         break;
-      case 24 /* cc_scheduler_state */:
-        (*cc_scheduler_state_).ParseFromArray(field.data(), field.size());
+      case 20 /* needs_begin_main_frame */:
+        field.get(&needs_begin_main_frame_);
         break;
-      case 25 /* chrome_user_event */:
-        (*chrome_user_event_).ParseFromArray(field.data(), field.size());
+      case 21 /* needs_one_begin_impl_frame */:
+        field.get(&needs_one_begin_impl_frame_);
         break;
-      case 26 /* chrome_keyed_service */:
-        (*chrome_keyed_service_).ParseFromArray(field.data(), field.size());
+      case 22 /* visible */:
+        field.get(&visible_);
         break;
-      case 27 /* chrome_legacy_ipc */:
-        (*chrome_legacy_ipc_).ParseFromArray(field.data(), field.size());
+      case 23 /* begin_frame_source_paused */:
+        field.get(&begin_frame_source_paused_);
         break;
-      case 28 /* chrome_histogram_sample */:
-        (*chrome_histogram_sample_).ParseFromArray(field.data(), field.size());
+      case 24 /* can_draw */:
+        field.get(&can_draw_);
         break;
-      case 29 /* chrome_latency_info */:
-        (*chrome_latency_info_).ParseFromArray(field.data(), field.size());
+      case 25 /* resourceless_draw */:
+        field.get(&resourceless_draw_);
         break;
-      case 32 /* chrome_frame_reporter */:
-        (*chrome_frame_reporter_).ParseFromArray(field.data(), field.size());
+      case 26 /* has_pending_tree */:
+        field.get(&has_pending_tree_);
         break;
-      case 39 /* chrome_application_state_info */:
-        (*chrome_application_state_info_).ParseFromArray(field.data(), field.size());
+      case 27 /* pending_tree_is_ready_for_activation */:
+        field.get(&pending_tree_is_ready_for_activation_);
         break;
-      case 40 /* chrome_renderer_scheduler_state */:
-        (*chrome_renderer_scheduler_state_).ParseFromArray(field.data(), field.size());
+      case 28 /* active_tree_needs_first_draw */:
+        field.get(&active_tree_needs_first_draw_);
         break;
-      case 41 /* chrome_window_handle_event_info */:
-        (*chrome_window_handle_event_info_).ParseFromArray(field.data(), field.size());
+      case 29 /* active_tree_is_ready_to_draw */:
+        field.get(&active_tree_is_ready_to_draw_);
         break;
-      case 43 /* chrome_content_settings_event_info */:
-        (*chrome_content_settings_event_info_).ParseFromArray(field.data(), field.size());
+      case 30 /* did_create_and_initialize_first_layer_tree_frame_sink */:
+        field.get(&did_create_and_initialize_first_layer_tree_frame_sink_);
         break;
-      case 49 /* chrome_active_processes */:
-        (*chrome_active_processes_).ParseFromArray(field.data(), field.size());
+      case 31 /* tree_priority */:
+        field.get(&tree_priority_);
         break;
-      case 33 /* source_location */:
-        (*source_location_).ParseFromArray(field.data(), field.size());
+      case 32 /* scroll_handler_state */:
+        field.get(&scroll_handler_state_);
         break;
-      case 34 /* source_location_iid */:
-        field.get(&source_location_iid_);
+      case 33 /* critical_begin_main_frame_to_activate_is_fast */:
+        field.get(&critical_begin_main_frame_to_activate_is_fast_);
         break;
-      case 35 /* chrome_message_pump */:
-        (*chrome_message_pump_).ParseFromArray(field.data(), field.size());
+      case 34 /* main_thread_missed_last_deadline */:
+        field.get(&main_thread_missed_last_deadline_);
         break;
-      case 38 /* chrome_mojo_event_info */:
-        (*chrome_mojo_event_info_).ParseFromArray(field.data(), field.size());
+      case 36 /* video_needs_begin_frames */:
+        field.get(&video_needs_begin_frames_);
         break;
-      case 1 /* timestamp_delta_us */:
-        field.get(&timestamp_delta_us_);
+      case 37 /* defer_begin_main_frame */:
+        field.get(&defer_begin_main_frame_);
         break;
-      case 16 /* timestamp_absolute_us */:
-        field.get(&timestamp_absolute_us_);
+      case 38 /* last_commit_had_no_updates */:
+        field.get(&last_commit_had_no_updates_);
         break;
-      case 2 /* thread_time_delta_us */:
-        field.get(&thread_time_delta_us_);
+      case 39 /* did_draw_in_last_frame */:
+        field.get(&did_draw_in_last_frame_);
         break;
-      case 17 /* thread_time_absolute_us */:
-        field.get(&thread_time_absolute_us_);
+      case 40 /* did_submit_in_last_frame */:
+        field.get(&did_submit_in_last_frame_);
         break;
-      case 8 /* thread_instruction_count_delta */:
-        field.get(&thread_instruction_count_delta_);
+      case 41 /* needs_impl_side_invalidation */:
+        field.get(&needs_impl_side_invalidation_);
         break;
-      case 20 /* thread_instruction_count_absolute */:
-        field.get(&thread_instruction_count_absolute_);
+      case 42 /* current_pending_tree_is_impl_side */:
+        field.get(&current_pending_tree_is_impl_side_);
         break;
-      case 6 /* legacy_event */:
-        (*legacy_event_).ParseFromArray(field.data(), field.size());
+      case 43 /* previous_pending_tree_was_impl_side */:
+        field.get(&previous_pending_tree_was_impl_side_);
+        break;
+      case 44 /* processing_animation_worklets_for_active_tree */:
+        field.get(&processing_animation_worklets_for_active_tree_);
+        break;
+      case 45 /* processing_animation_worklets_for_pending_tree */:
+        field.get(&processing_animation_worklets_for_pending_tree_);
+        break;
+      case 46 /* processing_paint_worklets_for_pending_tree */:
+        field.get(&processing_paint_worklets_for_pending_tree_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -37535,261 +31247,265 @@ bool TrackEvent::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TrackEvent::SerializeAsString() const {
+std::string ChromeCompositorStateMachine_MinorState::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TrackEvent::SerializeAsArray() const {
+std::vector<uint8_t> ChromeCompositorStateMachine_MinorState::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TrackEvent::Serialize(::protozero::Message* msg) const {
-  // Field 3: category_iids
-  for (auto& it : category_iids_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, it, msg);
+void ChromeCompositorStateMachine_MinorState::Serialize(::protozero::Message* msg) const {
+  // Field 1: commit_count
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, commit_count_, msg);
   }
 
-  // Field 22: categories
-  for (auto& it : categories_) {
-    ::protozero::internal::gen_helpers::SerializeString(22, it, msg);
+  // Field 2: current_frame_number
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, current_frame_number_, msg);
   }
 
-  // Field 10: name_iid
-  if (_has_field_[10]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(10, name_iid_, msg);
+  // Field 3: last_frame_number_submit_performed
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, last_frame_number_submit_performed_, msg);
   }
 
-  // Field 23: name
-  if (_has_field_[23]) {
-    ::protozero::internal::gen_helpers::SerializeString(23, name_, msg);
+  // Field 4: last_frame_number_draw_performed
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, last_frame_number_draw_performed_, msg);
   }
 
-  // Field 9: type
-  if (_has_field_[9]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(9, type_, msg);
+  // Field 5: last_frame_number_begin_main_frame_sent
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, last_frame_number_begin_main_frame_sent_, msg);
   }
 
-  // Field 11: track_uuid
-  if (_has_field_[11]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(11, track_uuid_, msg);
+  // Field 6: did_draw
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(6, did_draw_, msg);
   }
 
-  // Field 30: counter_value
-  if (_has_field_[30]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(30, counter_value_, msg);
+  // Field 7: did_send_begin_main_frame_for_current_frame
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(7, did_send_begin_main_frame_for_current_frame_, msg);
   }
 
-  // Field 44: double_counter_value
-  if (_has_field_[44]) {
-    ::protozero::internal::gen_helpers::SerializeFixed(44, double_counter_value_, msg);
+  // Field 8: did_notify_begin_main_frame_not_expected_until
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(8, did_notify_begin_main_frame_not_expected_until_, msg);
   }
 
-  // Field 31: extra_counter_track_uuids
-  for (auto& it : extra_counter_track_uuids_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(31, it, msg);
+  // Field 9: did_notify_begin_main_frame_not_expected_soon
+  if (_has_field_[9]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(9, did_notify_begin_main_frame_not_expected_soon_, msg);
   }
 
-  // Field 12: extra_counter_values
-  for (auto& it : extra_counter_values_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(12, it, msg);
+  // Field 10: wants_begin_main_frame_not_expected
+  if (_has_field_[10]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(10, wants_begin_main_frame_not_expected_, msg);
   }
 
-  // Field 45: extra_double_counter_track_uuids
-  for (auto& it : extra_double_counter_track_uuids_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(45, it, msg);
+  // Field 11: did_commit_during_frame
+  if (_has_field_[11]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(11, did_commit_during_frame_, msg);
   }
 
-  // Field 46: extra_double_counter_values
-  for (auto& it : extra_double_counter_values_) {
-    ::protozero::internal::gen_helpers::SerializeFixed(46, it, msg);
+  // Field 12: did_invalidate_layer_tree_frame_sink
+  if (_has_field_[12]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(12, did_invalidate_layer_tree_frame_sink_, msg);
   }
 
-  // Field 36: flow_ids_old
-  for (auto& it : flow_ids_old_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(36, it, msg);
+  // Field 13: did_perform_impl_side_invalidaion
+  if (_has_field_[13]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(13, did_perform_impl_side_invalidaion_, msg);
   }
 
-  // Field 47: flow_ids
-  for (auto& it : flow_ids_) {
-    ::protozero::internal::gen_helpers::SerializeFixed(47, it, msg);
+  // Field 14: did_prepare_tiles
+  if (_has_field_[14]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(14, did_prepare_tiles_, msg);
   }
 
-  // Field 42: terminating_flow_ids_old
-  for (auto& it : terminating_flow_ids_old_) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(42, it, msg);
+  // Field 15: consecutive_checkerboard_animations
+  if (_has_field_[15]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(15, consecutive_checkerboard_animations_, msg);
   }
 
-  // Field 48: terminating_flow_ids
-  for (auto& it : terminating_flow_ids_) {
-    ::protozero::internal::gen_helpers::SerializeFixed(48, it, msg);
+  // Field 16: pending_submit_frames
+  if (_has_field_[16]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(16, pending_submit_frames_, msg);
   }
 
-  // Field 4: debug_annotations
-  for (auto& it : debug_annotations_) {
-    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(4));
+  // Field 17: submit_frames_with_current_layer_tree_frame_sink
+  if (_has_field_[17]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(17, submit_frames_with_current_layer_tree_frame_sink_, msg);
   }
 
-  // Field 5: task_execution
-  if (_has_field_[5]) {
-    (*task_execution_).Serialize(msg->BeginNestedMessage<::protozero::Message>(5));
+  // Field 18: needs_redraw
+  if (_has_field_[18]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(18, needs_redraw_, msg);
   }
 
-  // Field 21: log_message
+  // Field 19: needs_prepare_tiles
+  if (_has_field_[19]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(19, needs_prepare_tiles_, msg);
+  }
+
+  // Field 20: needs_begin_main_frame
+  if (_has_field_[20]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(20, needs_begin_main_frame_, msg);
+  }
+
+  // Field 21: needs_one_begin_impl_frame
   if (_has_field_[21]) {
-    (*log_message_).Serialize(msg->BeginNestedMessage<::protozero::Message>(21));
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(21, needs_one_begin_impl_frame_, msg);
   }
 
-  // Field 24: cc_scheduler_state
+  // Field 22: visible
+  if (_has_field_[22]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(22, visible_, msg);
+  }
+
+  // Field 23: begin_frame_source_paused
+  if (_has_field_[23]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(23, begin_frame_source_paused_, msg);
+  }
+
+  // Field 24: can_draw
   if (_has_field_[24]) {
-    (*cc_scheduler_state_).Serialize(msg->BeginNestedMessage<::protozero::Message>(24));
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(24, can_draw_, msg);
   }
 
-  // Field 25: chrome_user_event
+  // Field 25: resourceless_draw
   if (_has_field_[25]) {
-    (*chrome_user_event_).Serialize(msg->BeginNestedMessage<::protozero::Message>(25));
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(25, resourceless_draw_, msg);
   }
 
-  // Field 26: chrome_keyed_service
+  // Field 26: has_pending_tree
   if (_has_field_[26]) {
-    (*chrome_keyed_service_).Serialize(msg->BeginNestedMessage<::protozero::Message>(26));
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(26, has_pending_tree_, msg);
   }
 
-  // Field 27: chrome_legacy_ipc
+  // Field 27: pending_tree_is_ready_for_activation
   if (_has_field_[27]) {
-    (*chrome_legacy_ipc_).Serialize(msg->BeginNestedMessage<::protozero::Message>(27));
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(27, pending_tree_is_ready_for_activation_, msg);
   }
 
-  // Field 28: chrome_histogram_sample
+  // Field 28: active_tree_needs_first_draw
   if (_has_field_[28]) {
-    (*chrome_histogram_sample_).Serialize(msg->BeginNestedMessage<::protozero::Message>(28));
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(28, active_tree_needs_first_draw_, msg);
   }
 
-  // Field 29: chrome_latency_info
+  // Field 29: active_tree_is_ready_to_draw
   if (_has_field_[29]) {
-    (*chrome_latency_info_).Serialize(msg->BeginNestedMessage<::protozero::Message>(29));
-  }
-
-  // Field 32: chrome_frame_reporter
-  if (_has_field_[32]) {
-    (*chrome_frame_reporter_).Serialize(msg->BeginNestedMessage<::protozero::Message>(32));
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(29, active_tree_is_ready_to_draw_, msg);
   }
 
-  // Field 39: chrome_application_state_info
-  if (_has_field_[39]) {
-    (*chrome_application_state_info_).Serialize(msg->BeginNestedMessage<::protozero::Message>(39));
+  // Field 30: did_create_and_initialize_first_layer_tree_frame_sink
+  if (_has_field_[30]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(30, did_create_and_initialize_first_layer_tree_frame_sink_, msg);
   }
 
-  // Field 40: chrome_renderer_scheduler_state
-  if (_has_field_[40]) {
-    (*chrome_renderer_scheduler_state_).Serialize(msg->BeginNestedMessage<::protozero::Message>(40));
+  // Field 31: tree_priority
+  if (_has_field_[31]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(31, tree_priority_, msg);
   }
 
-  // Field 41: chrome_window_handle_event_info
-  if (_has_field_[41]) {
-    (*chrome_window_handle_event_info_).Serialize(msg->BeginNestedMessage<::protozero::Message>(41));
+  // Field 32: scroll_handler_state
+  if (_has_field_[32]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(32, scroll_handler_state_, msg);
   }
 
-  // Field 43: chrome_content_settings_event_info
-  if (_has_field_[43]) {
-    (*chrome_content_settings_event_info_).Serialize(msg->BeginNestedMessage<::protozero::Message>(43));
+  // Field 33: critical_begin_main_frame_to_activate_is_fast
+  if (_has_field_[33]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(33, critical_begin_main_frame_to_activate_is_fast_, msg);
   }
 
-  // Field 49: chrome_active_processes
-  if (_has_field_[49]) {
-    (*chrome_active_processes_).Serialize(msg->BeginNestedMessage<::protozero::Message>(49));
+  // Field 34: main_thread_missed_last_deadline
+  if (_has_field_[34]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(34, main_thread_missed_last_deadline_, msg);
   }
 
-  // Field 33: source_location
-  if (_has_field_[33]) {
-    (*source_location_).Serialize(msg->BeginNestedMessage<::protozero::Message>(33));
+  // Field 36: video_needs_begin_frames
+  if (_has_field_[36]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(36, video_needs_begin_frames_, msg);
   }
 
-  // Field 34: source_location_iid
-  if (_has_field_[34]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(34, source_location_iid_, msg);
+  // Field 37: defer_begin_main_frame
+  if (_has_field_[37]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(37, defer_begin_main_frame_, msg);
   }
 
-  // Field 35: chrome_message_pump
-  if (_has_field_[35]) {
-    (*chrome_message_pump_).Serialize(msg->BeginNestedMessage<::protozero::Message>(35));
+  // Field 38: last_commit_had_no_updates
+  if (_has_field_[38]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(38, last_commit_had_no_updates_, msg);
   }
 
-  // Field 38: chrome_mojo_event_info
-  if (_has_field_[38]) {
-    (*chrome_mojo_event_info_).Serialize(msg->BeginNestedMessage<::protozero::Message>(38));
+  // Field 39: did_draw_in_last_frame
+  if (_has_field_[39]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(39, did_draw_in_last_frame_, msg);
   }
 
-  // Field 1: timestamp_delta_us
-  if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, timestamp_delta_us_, msg);
+  // Field 40: did_submit_in_last_frame
+  if (_has_field_[40]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(40, did_submit_in_last_frame_, msg);
   }
 
-  // Field 16: timestamp_absolute_us
-  if (_has_field_[16]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(16, timestamp_absolute_us_, msg);
+  // Field 41: needs_impl_side_invalidation
+  if (_has_field_[41]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(41, needs_impl_side_invalidation_, msg);
   }
 
-  // Field 2: thread_time_delta_us
-  if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, thread_time_delta_us_, msg);
+  // Field 42: current_pending_tree_is_impl_side
+  if (_has_field_[42]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(42, current_pending_tree_is_impl_side_, msg);
   }
 
-  // Field 17: thread_time_absolute_us
-  if (_has_field_[17]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(17, thread_time_absolute_us_, msg);
+  // Field 43: previous_pending_tree_was_impl_side
+  if (_has_field_[43]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(43, previous_pending_tree_was_impl_side_, msg);
   }
 
-  // Field 8: thread_instruction_count_delta
-  if (_has_field_[8]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(8, thread_instruction_count_delta_, msg);
+  // Field 44: processing_animation_worklets_for_active_tree
+  if (_has_field_[44]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(44, processing_animation_worklets_for_active_tree_, msg);
   }
 
-  // Field 20: thread_instruction_count_absolute
-  if (_has_field_[20]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(20, thread_instruction_count_absolute_, msg);
+  // Field 45: processing_animation_worklets_for_pending_tree
+  if (_has_field_[45]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(45, processing_animation_worklets_for_pending_tree_, msg);
   }
 
-  // Field 6: legacy_event
-  if (_has_field_[6]) {
-    (*legacy_event_).Serialize(msg->BeginNestedMessage<::protozero::Message>(6));
+  // Field 46: processing_paint_worklets_for_pending_tree
+  if (_has_field_[46]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(46, processing_paint_worklets_for_pending_tree_, msg);
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 
-TrackEvent_LegacyEvent::TrackEvent_LegacyEvent() = default;
-TrackEvent_LegacyEvent::~TrackEvent_LegacyEvent() = default;
-TrackEvent_LegacyEvent::TrackEvent_LegacyEvent(const TrackEvent_LegacyEvent&) = default;
-TrackEvent_LegacyEvent& TrackEvent_LegacyEvent::operator=(const TrackEvent_LegacyEvent&) = default;
-TrackEvent_LegacyEvent::TrackEvent_LegacyEvent(TrackEvent_LegacyEvent&&) noexcept = default;
-TrackEvent_LegacyEvent& TrackEvent_LegacyEvent::operator=(TrackEvent_LegacyEvent&&) = default;
+ChromeCompositorStateMachine_MajorState::ChromeCompositorStateMachine_MajorState() = default;
+ChromeCompositorStateMachine_MajorState::~ChromeCompositorStateMachine_MajorState() = default;
+ChromeCompositorStateMachine_MajorState::ChromeCompositorStateMachine_MajorState(const ChromeCompositorStateMachine_MajorState&) = default;
+ChromeCompositorStateMachine_MajorState& ChromeCompositorStateMachine_MajorState::operator=(const ChromeCompositorStateMachine_MajorState&) = default;
+ChromeCompositorStateMachine_MajorState::ChromeCompositorStateMachine_MajorState(ChromeCompositorStateMachine_MajorState&&) noexcept = default;
+ChromeCompositorStateMachine_MajorState& ChromeCompositorStateMachine_MajorState::operator=(ChromeCompositorStateMachine_MajorState&&) = default;
 
-bool TrackEvent_LegacyEvent::operator==(const TrackEvent_LegacyEvent& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && name_iid_ == other.name_iid_
-   && phase_ == other.phase_
-   && duration_us_ == other.duration_us_
-   && thread_duration_us_ == other.thread_duration_us_
-   && thread_instruction_delta_ == other.thread_instruction_delta_
-   && unscoped_id_ == other.unscoped_id_
-   && local_id_ == other.local_id_
-   && global_id_ == other.global_id_
-   && id_scope_ == other.id_scope_
-   && use_async_tts_ == other.use_async_tts_
-   && bind_id_ == other.bind_id_
-   && bind_to_enclosing_ == other.bind_to_enclosing_
-   && flow_direction_ == other.flow_direction_
-   && instant_event_scope_ == other.instant_event_scope_
-   && pid_override_ == other.pid_override_
-   && tid_override_ == other.tid_override_;
+bool ChromeCompositorStateMachine_MajorState::operator==(const ChromeCompositorStateMachine_MajorState& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(next_action_, other.next_action_)
+   && ::protozero::internal::gen_helpers::EqualsField(begin_impl_frame_state_, other.begin_impl_frame_state_)
+   && ::protozero::internal::gen_helpers::EqualsField(begin_main_frame_state_, other.begin_main_frame_state_)
+   && ::protozero::internal::gen_helpers::EqualsField(layer_tree_frame_sink_state_, other.layer_tree_frame_sink_state_)
+   && ::protozero::internal::gen_helpers::EqualsField(forced_redraw_state_, other.forced_redraw_state_);
 }
 
-bool TrackEvent_LegacyEvent::ParseFromArray(const void* raw, size_t size) {
+bool ChromeCompositorStateMachine_MajorState::ParseFromArray(const void* raw, size_t size) {
   unknown_fields_.clear();
   bool packed_error = false;
 
@@ -37799,53 +31515,20 @@ bool TrackEvent_LegacyEvent::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
-      case 1 /* name_iid */:
-        field.get(&name_iid_);
-        break;
-      case 2 /* phase */:
-        field.get(&phase_);
-        break;
-      case 3 /* duration_us */:
-        field.get(&duration_us_);
-        break;
-      case 4 /* thread_duration_us */:
-        field.get(&thread_duration_us_);
-        break;
-      case 15 /* thread_instruction_delta */:
-        field.get(&thread_instruction_delta_);
-        break;
-      case 6 /* unscoped_id */:
-        field.get(&unscoped_id_);
-        break;
-      case 10 /* local_id */:
-        field.get(&local_id_);
-        break;
-      case 11 /* global_id */:
-        field.get(&global_id_);
-        break;
-      case 7 /* id_scope */:
-        ::protozero::internal::gen_helpers::DeserializeString(field, &id_scope_);
-        break;
-      case 9 /* use_async_tts */:
-        field.get(&use_async_tts_);
-        break;
-      case 8 /* bind_id */:
-        field.get(&bind_id_);
-        break;
-      case 12 /* bind_to_enclosing */:
-        field.get(&bind_to_enclosing_);
+      case 1 /* next_action */:
+        field.get(&next_action_);
         break;
-      case 13 /* flow_direction */:
-        field.get(&flow_direction_);
+      case 2 /* begin_impl_frame_state */:
+        field.get(&begin_impl_frame_state_);
         break;
-      case 14 /* instant_event_scope */:
-        field.get(&instant_event_scope_);
+      case 3 /* begin_main_frame_state */:
+        field.get(&begin_main_frame_state_);
         break;
-      case 18 /* pid_override */:
-        field.get(&pid_override_);
+      case 4 /* layer_tree_frame_sink_state */:
+        field.get(&layer_tree_frame_sink_state_);
         break;
-      case 19 /* tid_override */:
-        field.get(&tid_override_);
+      case 5 /* forced_redraw_state */:
+        field.get(&forced_redraw_state_);
         break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
@@ -37855,97 +31538,232 @@ bool TrackEvent_LegacyEvent::ParseFromArray(const void* raw, size_t size) {
   return !packed_error && !dec.bytes_left();
 }
 
-std::string TrackEvent_LegacyEvent::SerializeAsString() const {
+std::string ChromeCompositorStateMachine_MajorState::SerializeAsString() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsString();
 }
 
-std::vector<uint8_t> TrackEvent_LegacyEvent::SerializeAsArray() const {
+std::vector<uint8_t> ChromeCompositorStateMachine_MajorState::SerializeAsArray() const {
   ::protozero::internal::gen_helpers::MessageSerializer msg;
   Serialize(msg.get());
   return msg.SerializeAsArray();
 }
 
-void TrackEvent_LegacyEvent::Serialize(::protozero::Message* msg) const {
-  // Field 1: name_iid
+void ChromeCompositorStateMachine_MajorState::Serialize(::protozero::Message* msg) const {
+  // Field 1: next_action
   if (_has_field_[1]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(1, name_iid_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, next_action_, msg);
   }
 
-  // Field 2: phase
+  // Field 2: begin_impl_frame_state
   if (_has_field_[2]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(2, phase_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, begin_impl_frame_state_, msg);
   }
 
-  // Field 3: duration_us
+  // Field 3: begin_main_frame_state
   if (_has_field_[3]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(3, duration_us_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, begin_main_frame_state_, msg);
   }
 
-  // Field 4: thread_duration_us
+  // Field 4: layer_tree_frame_sink_state
   if (_has_field_[4]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(4, thread_duration_us_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, layer_tree_frame_sink_state_, msg);
   }
 
-  // Field 15: thread_instruction_delta
-  if (_has_field_[15]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(15, thread_instruction_delta_, msg);
+  // Field 5: forced_redraw_state
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, forced_redraw_state_, msg);
   }
 
-  // Field 6: unscoped_id
-  if (_has_field_[6]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(6, unscoped_id_, msg);
-  }
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  // Field 10: local_id
-  if (_has_field_[10]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(10, local_id_, msg);
+
+ChromeCompositorSchedulerState::ChromeCompositorSchedulerState() = default;
+ChromeCompositorSchedulerState::~ChromeCompositorSchedulerState() = default;
+ChromeCompositorSchedulerState::ChromeCompositorSchedulerState(const ChromeCompositorSchedulerState&) = default;
+ChromeCompositorSchedulerState& ChromeCompositorSchedulerState::operator=(const ChromeCompositorSchedulerState&) = default;
+ChromeCompositorSchedulerState::ChromeCompositorSchedulerState(ChromeCompositorSchedulerState&&) noexcept = default;
+ChromeCompositorSchedulerState& ChromeCompositorSchedulerState::operator=(ChromeCompositorSchedulerState&&) = default;
+
+bool ChromeCompositorSchedulerState::operator==(const ChromeCompositorSchedulerState& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(state_machine_, other.state_machine_)
+   && ::protozero::internal::gen_helpers::EqualsField(observing_begin_frame_source_, other.observing_begin_frame_source_)
+   && ::protozero::internal::gen_helpers::EqualsField(begin_impl_frame_deadline_task_, other.begin_impl_frame_deadline_task_)
+   && ::protozero::internal::gen_helpers::EqualsField(pending_begin_frame_task_, other.pending_begin_frame_task_)
+   && ::protozero::internal::gen_helpers::EqualsField(skipped_last_frame_missed_exceeded_deadline_, other.skipped_last_frame_missed_exceeded_deadline_)
+   && ::protozero::internal::gen_helpers::EqualsField(inside_action_, other.inside_action_)
+   && ::protozero::internal::gen_helpers::EqualsField(deadline_mode_, other.deadline_mode_)
+   && ::protozero::internal::gen_helpers::EqualsField(deadline_us_, other.deadline_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(deadline_scheduled_at_us_, other.deadline_scheduled_at_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(now_us_, other.now_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(now_to_deadline_delta_us_, other.now_to_deadline_delta_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(now_to_deadline_scheduled_at_delta_us_, other.now_to_deadline_scheduled_at_delta_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(begin_impl_frame_args_, other.begin_impl_frame_args_)
+   && ::protozero::internal::gen_helpers::EqualsField(begin_frame_observer_state_, other.begin_frame_observer_state_)
+   && ::protozero::internal::gen_helpers::EqualsField(begin_frame_source_state_, other.begin_frame_source_state_)
+   && ::protozero::internal::gen_helpers::EqualsField(compositor_timing_history_, other.compositor_timing_history_);
+}
+
+bool ChromeCompositorSchedulerState::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* state_machine */:
+        (*state_machine_).ParseFromArray(field.data(), field.size());
+        break;
+      case 2 /* observing_begin_frame_source */:
+        field.get(&observing_begin_frame_source_);
+        break;
+      case 3 /* begin_impl_frame_deadline_task */:
+        field.get(&begin_impl_frame_deadline_task_);
+        break;
+      case 4 /* pending_begin_frame_task */:
+        field.get(&pending_begin_frame_task_);
+        break;
+      case 5 /* skipped_last_frame_missed_exceeded_deadline */:
+        field.get(&skipped_last_frame_missed_exceeded_deadline_);
+        break;
+      case 7 /* inside_action */:
+        field.get(&inside_action_);
+        break;
+      case 8 /* deadline_mode */:
+        field.get(&deadline_mode_);
+        break;
+      case 9 /* deadline_us */:
+        field.get(&deadline_us_);
+        break;
+      case 10 /* deadline_scheduled_at_us */:
+        field.get(&deadline_scheduled_at_us_);
+        break;
+      case 11 /* now_us */:
+        field.get(&now_us_);
+        break;
+      case 12 /* now_to_deadline_delta_us */:
+        field.get(&now_to_deadline_delta_us_);
+        break;
+      case 13 /* now_to_deadline_scheduled_at_delta_us */:
+        field.get(&now_to_deadline_scheduled_at_delta_us_);
+        break;
+      case 14 /* begin_impl_frame_args */:
+        (*begin_impl_frame_args_).ParseFromArray(field.data(), field.size());
+        break;
+      case 15 /* begin_frame_observer_state */:
+        (*begin_frame_observer_state_).ParseFromArray(field.data(), field.size());
+        break;
+      case 16 /* begin_frame_source_state */:
+        (*begin_frame_source_state_).ParseFromArray(field.data(), field.size());
+        break;
+      case 17 /* compositor_timing_history */:
+        (*compositor_timing_history_).ParseFromArray(field.data(), field.size());
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
   }
+  return !packed_error && !dec.bytes_left();
+}
 
-  // Field 11: global_id
-  if (_has_field_[11]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(11, global_id_, msg);
+std::string ChromeCompositorSchedulerState::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> ChromeCompositorSchedulerState::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void ChromeCompositorSchedulerState::Serialize(::protozero::Message* msg) const {
+  // Field 1: state_machine
+  if (_has_field_[1]) {
+    (*state_machine_).Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
   }
 
-  // Field 7: id_scope
+  // Field 2: observing_begin_frame_source
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, observing_begin_frame_source_, msg);
+  }
+
+  // Field 3: begin_impl_frame_deadline_task
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, begin_impl_frame_deadline_task_, msg);
+  }
+
+  // Field 4: pending_begin_frame_task
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(4, pending_begin_frame_task_, msg);
+  }
+
+  // Field 5: skipped_last_frame_missed_exceeded_deadline
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, skipped_last_frame_missed_exceeded_deadline_, msg);
+  }
+
+  // Field 7: inside_action
   if (_has_field_[7]) {
-    ::protozero::internal::gen_helpers::SerializeString(7, id_scope_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(7, inside_action_, msg);
   }
 
-  // Field 9: use_async_tts
+  // Field 8: deadline_mode
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(8, deadline_mode_, msg);
+  }
+
+  // Field 9: deadline_us
   if (_has_field_[9]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(9, use_async_tts_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(9, deadline_us_, msg);
   }
 
-  // Field 8: bind_id
-  if (_has_field_[8]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(8, bind_id_, msg);
+  // Field 10: deadline_scheduled_at_us
+  if (_has_field_[10]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(10, deadline_scheduled_at_us_, msg);
   }
 
-  // Field 12: bind_to_enclosing
+  // Field 11: now_us
+  if (_has_field_[11]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(11, now_us_, msg);
+  }
+
+  // Field 12: now_to_deadline_delta_us
   if (_has_field_[12]) {
-    ::protozero::internal::gen_helpers::SerializeTinyVarInt(12, bind_to_enclosing_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(12, now_to_deadline_delta_us_, msg);
   }
 
-  // Field 13: flow_direction
+  // Field 13: now_to_deadline_scheduled_at_delta_us
   if (_has_field_[13]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(13, flow_direction_, msg);
+    ::protozero::internal::gen_helpers::SerializeVarInt(13, now_to_deadline_scheduled_at_delta_us_, msg);
   }
 
-  // Field 14: instant_event_scope
+  // Field 14: begin_impl_frame_args
   if (_has_field_[14]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(14, instant_event_scope_, msg);
+    (*begin_impl_frame_args_).Serialize(msg->BeginNestedMessage<::protozero::Message>(14));
   }
 
-  // Field 18: pid_override
-  if (_has_field_[18]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(18, pid_override_, msg);
+  // Field 15: begin_frame_observer_state
+  if (_has_field_[15]) {
+    (*begin_frame_observer_state_).Serialize(msg->BeginNestedMessage<::protozero::Message>(15));
   }
 
-  // Field 19: tid_override
-  if (_has_field_[19]) {
-    ::protozero::internal::gen_helpers::SerializeVarInt(19, tid_override_, msg);
+  // Field 16: begin_frame_source_state
+  if (_has_field_[16]) {
+    (*begin_frame_source_state_).Serialize(msg->BeginNestedMessage<::protozero::Message>(16));
+  }
+
+  // Field 17: compositor_timing_history
+  if (_has_field_[17]) {
+    (*compositor_timing_history_).Serialize(msg->BeginNestedMessage<::protozero::Message>(17));
   }
 
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
@@ -37957,2729 +31775,14920 @@ void TrackEvent_LegacyEvent::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/config/android/android_game_intervention_list_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/android/android_log_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/android/android_polled_state_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/android/android_system_property_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/android/network_trace_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/android/packages_list_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/ftrace/ftrace_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/gpu/gpu_counter_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/gpu/vulkan_memory_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/inode_file/inode_file_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/interceptors/console_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/power/android_power_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/process_stats/process_stats_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/profiling/heapprofd_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/profiling/java_hprof_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/profiling/perf_event_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/statsd/atom_ids.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/statsd/statsd_tracing_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/sys_stats/sys_stats_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/system_info/system_info.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/track_event/track_event_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/chrome/chrome_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/data_source_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/interceptor_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/stress_test_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/test_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/config/trace_config.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/clock_snapshot.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/trace_uuid.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/trigger.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/system_info.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/android/android_game_intervention_list.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/android/android_log.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/android/android_system_property.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/android/camera_event.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/android/frame_timeline_event.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/android/gpu_mem_event.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/android/graphics_frame_event.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/android/initial_display_state.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/android/network_trace.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/android/packages_list.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/chrome/chrome_benchmark_metadata.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/chrome/chrome_metadata.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/chrome/chrome_trace_event.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/filesystem/inode_file_map.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/ftrace_event.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/ftrace_event_bundle.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/ftrace_stats.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/test_bundle_wrapper.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/generic.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/android_fs.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/binder.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/block.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/cgroup.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/clk.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/cma.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/compaction.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/cpuhp.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/cros_ec.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/dma_fence.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/dmabuf_heap.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/dpu.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/drm.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/ext4.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/f2fs.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/fastrpc.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/fence.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/filemap.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/ftrace.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/g2d.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/gpu_mem.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/gpu_scheduler.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/i2c.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/ion.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/ipi.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/irq.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/kmem.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/kvm.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/lowmemorykiller.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/lwis.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/mali.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/mdss.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/mm_event.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/net.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/oom.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/panel.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/power.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/printk.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/raw_syscalls.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/regulator.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/sched.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/scm.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/sde.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/signal.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/skb.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/sock.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/sync.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/synthetic.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/systrace.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/task.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/tcp.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/thermal.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/trusty.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/ufs.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/v4l2.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/virtio_gpu.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/virtio_video.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/vmscan.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/workqueue.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/perfetto/perfetto_metatrace.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/perfetto/tracing_service_event.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/power/android_energy_estimation_breakdown.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/power/android_entity_state_residency.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/power/battery_counters.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/power/power_rails.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ps/process_stats.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ps/process_tree.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/statsd/statsd_atom.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/sys_stats/sys_stats.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/system_info/cpu_info.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/translation/translation_table.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/trace_packet_defaults.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/test_event.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/test_extensions.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/trace_packet.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/trace.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/extension_descriptor.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/memory_graph.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: gen/protos/perfetto/trace/ui_state.pbzero.cc
-// Intentionally empty (crbug.com/998165)
-// gen_amalgamated begin source: src/tracing/trace_writer_base.cc
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// gen_amalgamated expanded: #include "perfetto/tracing/trace_writer_base.h"
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_content_settings_event_info.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_content_settings_event_info.gen.h"
 
 namespace perfetto {
+namespace protos {
+namespace gen {
 
-// This destructor needs to be defined in a dedicated translation unit and
-// cannot be merged together with the other ones in virtual_destructors.cc.
-// This is because trace_writer_base.h/cc  is part of a separate target
-// (src/public:common) that is linked also by other part of the codebase.
-
-TraceWriterBase::~TraceWriterBase() = default;
+ChromeContentSettingsEventInfo::ChromeContentSettingsEventInfo() = default;
+ChromeContentSettingsEventInfo::~ChromeContentSettingsEventInfo() = default;
+ChromeContentSettingsEventInfo::ChromeContentSettingsEventInfo(const ChromeContentSettingsEventInfo&) = default;
+ChromeContentSettingsEventInfo& ChromeContentSettingsEventInfo::operator=(const ChromeContentSettingsEventInfo&) = default;
+ChromeContentSettingsEventInfo::ChromeContentSettingsEventInfo(ChromeContentSettingsEventInfo&&) noexcept = default;
+ChromeContentSettingsEventInfo& ChromeContentSettingsEventInfo::operator=(ChromeContentSettingsEventInfo&&) = default;
 
-}  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/core/id_allocator.cc
-// gen_amalgamated begin header: src/tracing/core/id_allocator.h
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+bool ChromeContentSettingsEventInfo::operator==(const ChromeContentSettingsEventInfo& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(number_of_exceptions_, other.number_of_exceptions_);
+}
 
-#ifndef SRC_TRACING_CORE_ID_ALLOCATOR_H_
-#define SRC_TRACING_CORE_ID_ALLOCATOR_H_
+bool ChromeContentSettingsEventInfo::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-#include <stdint.h>
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* number_of_exceptions */:
+        field.get(&number_of_exceptions_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-#include <type_traits>
-#include <vector>
-
-namespace perfetto {
-
-// Handles assigment of IDs (int types) from a fixed-size pool.
-// Zero is not considered a valid ID.
-// The base class takes always a uint32_t and the derived class casts and checks
-// bounds at compile time. This is to avoid bloating code with different
-// instances of the main class for each size.
-class IdAllocatorGeneric {
- public:
-  // |max_id| is inclusive.
-  explicit IdAllocatorGeneric(uint32_t max_id);
-  ~IdAllocatorGeneric();
-
-  // Returns an ID in the range [1, max_id] or 0 if no more ids are available.
-  uint32_t AllocateGeneric();
-  void FreeGeneric(uint32_t);
-
-  bool IsEmpty() const;
-
- private:
-  IdAllocatorGeneric(const IdAllocatorGeneric&) = delete;
-  IdAllocatorGeneric& operator=(const IdAllocatorGeneric&) = delete;
+std::string ChromeContentSettingsEventInfo::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  const uint32_t max_id_;
-  uint32_t last_id_ = 0;
-  std::vector<bool> ids_;
-};
+std::vector<uint8_t> ChromeContentSettingsEventInfo::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-template <typename T = uint32_t>
-class IdAllocator : public IdAllocatorGeneric {
- public:
-  explicit IdAllocator(T end) : IdAllocatorGeneric(end) {
-    static_assert(std::is_integral<T>::value && std::is_unsigned<T>::value,
-                  "T must be an unsigned integer");
-    static_assert(sizeof(T) <= sizeof(uint32_t), "T is too big");
+void ChromeContentSettingsEventInfo::Serialize(::protozero::Message* msg) const {
+  // Field 1: number_of_exceptions
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, number_of_exceptions_, msg);
   }
 
-  T Allocate() { return static_cast<T>(AllocateGeneric()); }
-  void Free(T id) { FreeGeneric(id); }
-};
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
 }  // namespace perfetto
-
-#endif  // SRC_TRACING_CORE_ID_ALLOCATOR_H_
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// gen_amalgamated expanded: #include "src/tracing/core/id_allocator.h"
-
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_frame_reporter.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_frame_reporter.gen.h"
 
 namespace perfetto {
+namespace protos {
+namespace gen {
 
-IdAllocatorGeneric::IdAllocatorGeneric(uint32_t max_id) : max_id_(max_id) {
-  PERFETTO_DCHECK(max_id > 1);
-}
+ChromeFrameReporter::ChromeFrameReporter() = default;
+ChromeFrameReporter::~ChromeFrameReporter() = default;
+ChromeFrameReporter::ChromeFrameReporter(const ChromeFrameReporter&) = default;
+ChromeFrameReporter& ChromeFrameReporter::operator=(const ChromeFrameReporter&) = default;
+ChromeFrameReporter::ChromeFrameReporter(ChromeFrameReporter&&) noexcept = default;
+ChromeFrameReporter& ChromeFrameReporter::operator=(ChromeFrameReporter&&) = default;
 
-IdAllocatorGeneric::~IdAllocatorGeneric() = default;
+bool ChromeFrameReporter::operator==(const ChromeFrameReporter& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(state_, other.state_)
+   && ::protozero::internal::gen_helpers::EqualsField(reason_, other.reason_)
+   && ::protozero::internal::gen_helpers::EqualsField(frame_source_, other.frame_source_)
+   && ::protozero::internal::gen_helpers::EqualsField(frame_sequence_, other.frame_sequence_)
+   && ::protozero::internal::gen_helpers::EqualsField(affects_smoothness_, other.affects_smoothness_)
+   && ::protozero::internal::gen_helpers::EqualsField(scroll_state_, other.scroll_state_)
+   && ::protozero::internal::gen_helpers::EqualsField(has_main_animation_, other.has_main_animation_)
+   && ::protozero::internal::gen_helpers::EqualsField(has_compositor_animation_, other.has_compositor_animation_)
+   && ::protozero::internal::gen_helpers::EqualsField(has_smooth_input_main_, other.has_smooth_input_main_)
+   && ::protozero::internal::gen_helpers::EqualsField(has_missing_content_, other.has_missing_content_)
+   && ::protozero::internal::gen_helpers::EqualsField(layer_tree_host_id_, other.layer_tree_host_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(has_high_latency_, other.has_high_latency_)
+   && ::protozero::internal::gen_helpers::EqualsField(frame_type_, other.frame_type_)
+   && ::protozero::internal::gen_helpers::EqualsField(high_latency_contribution_stage_, other.high_latency_contribution_stage_)
+   && ::protozero::internal::gen_helpers::EqualsField(checkerboarded_needs_raster_, other.checkerboarded_needs_raster_)
+   && ::protozero::internal::gen_helpers::EqualsField(checkerboarded_needs_record_, other.checkerboarded_needs_record_)
+   && ::protozero::internal::gen_helpers::EqualsField(surface_frame_trace_id_, other.surface_frame_trace_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(display_trace_id_, other.display_trace_id_);
+}
 
-uint32_t IdAllocatorGeneric::AllocateGeneric() {
-  for (uint32_t ignored = 1; ignored <= max_id_; ignored++) {
-    last_id_ = last_id_ < max_id_ ? last_id_ + 1 : 1;
-    const auto id = last_id_;
+bool ChromeFrameReporter::ParseFromArray(const void* raw, size_t size) {
+  high_latency_contribution_stage_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-    // 0 is never a valid ID. So if we are looking for |id| == N and there are
-    // N or less elements in the vector, they must necessarily be all < N.
-    // e.g. if |id| == 4 and size() == 4, the vector will contain IDs 0,1,2,3.
-    if (id >= ids_.size()) {
-      ids_.resize(id + 1);
-      ids_[id] = true;
-      return id;
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
     }
-
-    if (!ids_[id]) {
-      ids_[id] = true;
-      return id;
+    switch (field.id()) {
+      case 1 /* state */:
+        field.get(&state_);
+        break;
+      case 2 /* reason */:
+        field.get(&reason_);
+        break;
+      case 3 /* frame_source */:
+        field.get(&frame_source_);
+        break;
+      case 4 /* frame_sequence */:
+        field.get(&frame_sequence_);
+        break;
+      case 5 /* affects_smoothness */:
+        field.get(&affects_smoothness_);
+        break;
+      case 6 /* scroll_state */:
+        field.get(&scroll_state_);
+        break;
+      case 7 /* has_main_animation */:
+        field.get(&has_main_animation_);
+        break;
+      case 8 /* has_compositor_animation */:
+        field.get(&has_compositor_animation_);
+        break;
+      case 9 /* has_smooth_input_main */:
+        field.get(&has_smooth_input_main_);
+        break;
+      case 10 /* has_missing_content */:
+        field.get(&has_missing_content_);
+        break;
+      case 11 /* layer_tree_host_id */:
+        field.get(&layer_tree_host_id_);
+        break;
+      case 12 /* has_high_latency */:
+        field.get(&has_high_latency_);
+        break;
+      case 13 /* frame_type */:
+        field.get(&frame_type_);
+        break;
+      case 14 /* high_latency_contribution_stage */:
+        high_latency_contribution_stage_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &high_latency_contribution_stage_.back());
+        break;
+      case 15 /* checkerboarded_needs_raster */:
+        field.get(&checkerboarded_needs_raster_);
+        break;
+      case 16 /* checkerboarded_needs_record */:
+        field.get(&checkerboarded_needs_record_);
+        break;
+      case 17 /* surface_frame_trace_id */:
+        field.get(&surface_frame_trace_id_);
+        break;
+      case 18 /* display_trace_id */:
+        field.get(&display_trace_id_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
     }
   }
-  return 0;
+  return !packed_error && !dec.bytes_left();
 }
 
-void IdAllocatorGeneric::FreeGeneric(uint32_t id) {
-  if (id == 0 || id >= ids_.size() || !ids_[id]) {
-    PERFETTO_DFATAL("Invalid id.");
-    return;
-  }
-  ids_[id] = false;
+std::string ChromeFrameReporter::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
 }
 
-bool IdAllocatorGeneric::IsEmpty() const {
-  for (auto id : ids_) {
-    if (id)
-      return false;
-  }
-  return true;
+std::vector<uint8_t> ChromeFrameReporter::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
 }
 
-}  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/core/null_trace_writer.cc
-// gen_amalgamated begin header: src/tracing/core/null_trace_writer.h
-// gen_amalgamated begin header: include/perfetto/ext/tracing/core/trace_writer.h
-// gen_amalgamated begin header: include/perfetto/ext/tracing/core/basic_types.h
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+void ChromeFrameReporter::Serialize(::protozero::Message* msg) const {
+  // Field 1: state
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, state_, msg);
+  }
 
-#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_BASIC_TYPES_H_
-#define INCLUDE_PERFETTO_EXT_TRACING_CORE_BASIC_TYPES_H_
+  // Field 2: reason
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, reason_, msg);
+  }
 
-#include <stddef.h>
-#include <stdint.h>
+  // Field 3: frame_source
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, frame_source_, msg);
+  }
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/sys_types.h"
+  // Field 4: frame_sequence
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, frame_sequence_, msg);
+  }
 
-namespace perfetto {
+  // Field 5: affects_smoothness
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, affects_smoothness_, msg);
+  }
 
-// Unique within the scope of the tracing service.
-using TracingSessionID = uint64_t;
+  // Field 6: scroll_state
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, scroll_state_, msg);
+  }
 
-// Unique within the scope of the tracing service.
-using ProducerID = uint16_t;
+  // Field 7: has_main_animation
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(7, has_main_animation_, msg);
+  }
 
-// Unique within the scope of the tracing service.
-using DataSourceInstanceID = uint64_t;
+  // Field 8: has_compositor_animation
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(8, has_compositor_animation_, msg);
+  }
 
-// Unique within the scope of a Producer.
-using WriterID = uint16_t;
+  // Field 9: has_smooth_input_main
+  if (_has_field_[9]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(9, has_smooth_input_main_, msg);
+  }
 
-// Unique within the scope of the tracing service.
-using FlushRequestID = uint64_t;
+  // Field 10: has_missing_content
+  if (_has_field_[10]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(10, has_missing_content_, msg);
+  }
 
-// We need one FD per producer and we are not going to be able to keep > 64k FDs
-// open in the service.
-static constexpr ProducerID kMaxProducerID = static_cast<ProducerID>(-1);
+  // Field 11: layer_tree_host_id
+  if (_has_field_[11]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(11, layer_tree_host_id_, msg);
+  }
 
-// 1024 Writers per producer seems a resonable bound. This reduces the ability
-// to memory-DoS the service by having to keep track of too many writer IDs.
-static constexpr WriterID kMaxWriterID = static_cast<WriterID>((1 << 10) - 1);
+  // Field 12: has_high_latency
+  if (_has_field_[12]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(12, has_high_latency_, msg);
+  }
 
-// Unique within the scope of a {ProducerID, WriterID} tuple.
-using ChunkID = uint32_t;
-static constexpr ChunkID kMaxChunkID = static_cast<ChunkID>(-1);
+  // Field 13: frame_type
+  if (_has_field_[13]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(13, frame_type_, msg);
+  }
 
-// Unique within the scope of the tracing service.
-using BufferID = uint16_t;
+  // Field 14: high_latency_contribution_stage
+  for (auto& it : high_latency_contribution_stage_) {
+    ::protozero::internal::gen_helpers::SerializeString(14, it, msg);
+  }
 
-// Target buffer ID for SharedMemoryArbiter. Values up to max uint16_t are
-// equivalent to a bound BufferID. Values above max uint16_t are reservation IDs
-// for the target buffer of a startup trace writer. Reservation IDs will be
-// translated to actual BufferIDs after they are bound by
-// SharedMemoryArbiter::BindStartupTargetBuffer().
-// TODO(mohitms): Delete this type and use `struct {uint16 ; uint16;}` instead.
-using MaybeUnboundBufferID = uint32_t;
+  // Field 15: checkerboarded_needs_raster
+  if (_has_field_[15]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(15, checkerboarded_needs_raster_, msg);
+  }
 
-// Keep this in sync with SharedMemoryABI::PageHeader::target_buffer.
-static constexpr BufferID kMaxTraceBufferID = static_cast<BufferID>(-1);
+  // Field 16: checkerboarded_needs_record
+  if (_has_field_[16]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(16, checkerboarded_needs_record_, msg);
+  }
 
-// Unique within the scope of a tracing session.
-using PacketSequenceID = uint32_t;
-// Used for extra packets emitted by the service, such as statistics.
-static constexpr PacketSequenceID kServicePacketSequenceID = 1;
-static constexpr PacketSequenceID kMaxPacketSequenceID =
-    static_cast<PacketSequenceID>(-1);
+  // Field 17: surface_frame_trace_id
+  if (_has_field_[17]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(17, surface_frame_trace_id_, msg);
+  }
 
-constexpr uid_t kInvalidUid = ::perfetto::base::kInvalidUid;
+  // Field 18: display_trace_id
+  if (_has_field_[18]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(18, display_trace_id_, msg);
+  }
 
-constexpr uint32_t kDefaultFlushTimeoutMs = 5000;
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
 }  // namespace perfetto
-
-#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_BASIC_TYPES_H_
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACE_WRITER_H_
-#define INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACE_WRITER_H_
-
-#include <functional>
-
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message_handle.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/trace_writer_base.h"
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_histogram_sample.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_histogram_sample.gen.h"
 
 namespace perfetto {
-
 namespace protos {
-namespace pbzero {
-class TracePacket;
-}  // namespace pbzero
-}  // namespace protos
+namespace gen {
 
-// See comments in include/perfetto/tracing/trace_writer_base.h
-class PERFETTO_EXPORT_COMPONENT TraceWriter : public TraceWriterBase {
- public:
-  using TracePacketHandle =
-      protozero::MessageHandle<protos::pbzero::TracePacket>;
+ChromeHistogramSample::ChromeHistogramSample() = default;
+ChromeHistogramSample::~ChromeHistogramSample() = default;
+ChromeHistogramSample::ChromeHistogramSample(const ChromeHistogramSample&) = default;
+ChromeHistogramSample& ChromeHistogramSample::operator=(const ChromeHistogramSample&) = default;
+ChromeHistogramSample::ChromeHistogramSample(ChromeHistogramSample&&) noexcept = default;
+ChromeHistogramSample& ChromeHistogramSample::operator=(ChromeHistogramSample&&) = default;
 
-  TraceWriter();
-  ~TraceWriter() override;
+bool ChromeHistogramSample::operator==(const ChromeHistogramSample& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_hash_, other.name_hash_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(sample_, other.sample_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_iid_, other.name_iid_);
+}
 
-  virtual WriterID writer_id() const = 0;
+bool ChromeHistogramSample::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
- private:
-  TraceWriter(const TraceWriter&) = delete;
-  TraceWriter& operator=(const TraceWriter&) = delete;
-};
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* name_hash */:
+        field.get(&name_hash_);
+        break;
+      case 2 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+        break;
+      case 3 /* sample */:
+        field.get(&sample_);
+        break;
+      case 4 /* name_iid */:
+        field.get(&name_iid_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-}  // namespace perfetto
+std::string ChromeHistogramSample::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACE_WRITER_H_
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+std::vector<uint8_t> ChromeHistogramSample::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-#ifndef SRC_TRACING_CORE_NULL_TRACE_WRITER_H_
-#define SRC_TRACING_CORE_NULL_TRACE_WRITER_H_
+void ChromeHistogramSample::Serialize(::protozero::Message* msg) const {
+  // Field 1: name_hash
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, name_hash_, msg);
+  }
 
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message_handle.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/root_message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_stream_null_delegate.h"
+  // Field 2: name
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeString(2, name_, msg);
+  }
 
-namespace perfetto {
+  // Field 3: sample
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, sample_, msg);
+  }
 
-// A specialization of TraceWriter which no-ops all the writes routing them
-// into a fixed region of memory
-// See //include/perfetto/ext/tracing/core/trace_writer.h for docs.
-class NullTraceWriter : public TraceWriter {
- public:
-  NullTraceWriter();
-  ~NullTraceWriter() override;
+  // Field 4: name_iid
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, name_iid_, msg);
+  }
 
-  // TraceWriter implementation. See documentation in trace_writer.h.
-  // TracePacketHandle is defined in trace_writer.h
-  TracePacketHandle NewTracePacket() override;
-  void FinishTracePacket() override;
-  void Flush(std::function<void()> callback = {}) override;
-  WriterID writer_id() const override;
-  uint64_t written() const override;
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
- private:
-  NullTraceWriter(const NullTraceWriter&) = delete;
-  NullTraceWriter& operator=(const NullTraceWriter&) = delete;
 
-  protozero::ScatteredStreamWriterNullDelegate delegate_;
-  protozero::ScatteredStreamWriter stream_;
+HistogramName::HistogramName() = default;
+HistogramName::~HistogramName() = default;
+HistogramName::HistogramName(const HistogramName&) = default;
+HistogramName& HistogramName::operator=(const HistogramName&) = default;
+HistogramName::HistogramName(HistogramName&&) noexcept = default;
+HistogramName& HistogramName::operator=(HistogramName&&) = default;
 
-  // The packet returned via NewTracePacket(). It is owned by this class,
-  // TracePacketHandle has just a pointer to it.
-  std::unique_ptr<protozero::RootMessage<protos::pbzero::TracePacket>>
-      cur_packet_;
-};
+bool HistogramName::operator==(const HistogramName& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(iid_, other.iid_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_);
+}
 
-}  // namespace perfetto
+bool HistogramName::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-#endif  // SRC_TRACING_CORE_NULL_TRACE_WRITER_H_
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* iid */:
+        field.get(&iid_);
+        break;
+      case 2 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-// gen_amalgamated expanded: #include "src/tracing/core/null_trace_writer.h"
+std::string HistogramName::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+std::vector<uint8_t> HistogramName::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h"
+void HistogramName::Serialize(::protozero::Message* msg) const {
+  // Field 1: iid
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, iid_, msg);
+  }
 
-namespace perfetto {
+  // Field 2: name
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeString(2, name_, msg);
+  }
 
-NullTraceWriter::NullTraceWriter() : delegate_(4096), stream_(&delegate_) {
-  cur_packet_.reset(new protozero::RootMessage<protos::pbzero::TracePacket>());
-  cur_packet_->Finalize();  // To avoid the DCHECK in NewTracePacket().
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
-NullTraceWriter::~NullTraceWriter() {}
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_keyed_service.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_keyed_service.gen.h"
 
-void NullTraceWriter::Flush(std::function<void()> callback) {
-  // Flush() cannot be called in the middle of a TracePacket.
-  PERFETTO_CHECK(cur_packet_->is_finalized());
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-  if (callback)
-    callback();
+ChromeKeyedService::ChromeKeyedService() = default;
+ChromeKeyedService::~ChromeKeyedService() = default;
+ChromeKeyedService::ChromeKeyedService(const ChromeKeyedService&) = default;
+ChromeKeyedService& ChromeKeyedService::operator=(const ChromeKeyedService&) = default;
+ChromeKeyedService::ChromeKeyedService(ChromeKeyedService&&) noexcept = default;
+ChromeKeyedService& ChromeKeyedService::operator=(ChromeKeyedService&&) = default;
+
+bool ChromeKeyedService::operator==(const ChromeKeyedService& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_);
 }
 
-NullTraceWriter::TracePacketHandle NullTraceWriter::NewTracePacket() {
-  // If we hit this, the caller is calling NewTracePacket() without having
-  // finalized the previous packet.
-  PERFETTO_DCHECK(cur_packet_->is_finalized());
-  cur_packet_->Reset(&stream_);
-  return TraceWriter::TracePacketHandle(cur_packet_.get());
+bool ChromeKeyedService::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
 }
 
-void NullTraceWriter::FinishTracePacket() {
-  cur_packet_->Finalize();
+std::string ChromeKeyedService::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
 }
 
-WriterID NullTraceWriter::writer_id() const {
-  return 0;
+std::vector<uint8_t> ChromeKeyedService::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
 }
 
-uint64_t NullTraceWriter::written() const {
-  return 0;
+void ChromeKeyedService::Serialize(::protozero::Message* msg) const {
+  // Field 1: name
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeString(1, name_, msg);
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 }  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/core/shared_memory_abi.cc
-// gen_amalgamated begin header: include/perfetto/ext/tracing/core/shared_memory_abi.h
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_SHARED_MEMORY_ABI_H_
-#define INCLUDE_PERFETTO_EXT_TRACING_CORE_SHARED_MEMORY_ABI_H_
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_latency_info.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_latency_info.gen.h"
 
-#include <stddef.h>
-#include <stdint.h>
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-#include <array>
-#include <atomic>
-#include <bitset>
-#include <thread>
-#include <type_traits>
-#include <utility>
+ChromeLatencyInfo::ChromeLatencyInfo() = default;
+ChromeLatencyInfo::~ChromeLatencyInfo() = default;
+ChromeLatencyInfo::ChromeLatencyInfo(const ChromeLatencyInfo&) = default;
+ChromeLatencyInfo& ChromeLatencyInfo::operator=(const ChromeLatencyInfo&) = default;
+ChromeLatencyInfo::ChromeLatencyInfo(ChromeLatencyInfo&&) noexcept = default;
+ChromeLatencyInfo& ChromeLatencyInfo::operator=(ChromeLatencyInfo&&) = default;
 
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+bool ChromeLatencyInfo::operator==(const ChromeLatencyInfo& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(trace_id_, other.trace_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(step_, other.step_)
+   && ::protozero::internal::gen_helpers::EqualsField(frame_tree_node_id_, other.frame_tree_node_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(component_info_, other.component_info_)
+   && ::protozero::internal::gen_helpers::EqualsField(is_coalesced_, other.is_coalesced_)
+   && ::protozero::internal::gen_helpers::EqualsField(gesture_scroll_id_, other.gesture_scroll_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(touch_id_, other.touch_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(input_type_, other.input_type_);
+}
 
-namespace perfetto {
+int ChromeLatencyInfo::component_info_size() const { return static_cast<int>(component_info_.size()); }
+void ChromeLatencyInfo::clear_component_info() { component_info_.clear(); }
+ChromeLatencyInfo_ComponentInfo* ChromeLatencyInfo::add_component_info() { component_info_.emplace_back(); return &component_info_.back(); }
+bool ChromeLatencyInfo::ParseFromArray(const void* raw, size_t size) {
+  component_info_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-// This file defines the binary interface of the memory buffers shared between
-// Producer and Service. This is a long-term stable ABI and has to be backwards
-// compatible to deal with mismatching Producer and Service versions.
-//
-// Overview
-// --------
-// SMB := "Shared Memory Buffer".
-// In the most typical case of a multi-process architecture (i.e. Producer and
-// Service are hosted by different processes), a Producer means almost always
-// a "client process producing data" (almost: in some cases a process might host
-// > 1 Producer, if it links two libraries, independent of each other, that both
-// use Perfetto tracing).
-// The Service has one SMB for each Producer.
-// A producer has one or (typically) more data sources. They all share the same
-// SMB.
-// The SMB is a staging area to decouple data sources living in the Producer
-// and allow them to do non-blocking async writes.
-// The SMB is *not* the ultimate logging buffer seen by the Consumer. That one
-// is larger (~MBs) and not shared with Producers.
-// Each SMB is small, typically few KB. Its size is configurable by the producer
-// within a max limit of ~MB (see kMaxShmSize in tracing_service_impl.cc).
-// The SMB is partitioned into fixed-size Page(s). The size of the Pages are
-// determined by each Producer at connection time and cannot be changed.
-// Hence, different producers can have SMB(s) that have a different Page size
-// from each other, but the page size will be constant throughout all the
-// lifetime of the SMB.
-// Page(s) are partitioned by the Producer into variable size Chunk(s):
-//
-// +------------+      +--------------------------+
-// | Producer 1 |  <-> |      SMB 1 [~32K - 1MB]  |
-// +------------+      +--------+--------+--------+
-//                     |  Page  |  Page  |  Page  |
-//                     +--------+--------+--------+
-//                     | Chunk  |        | Chunk  |
-//                     +--------+  Chunk +--------+ <----+
-//                     | Chunk  |        | Chunk  |      |
-//                     +--------+--------+--------+      +---------------------+
-//                                                       |       Service       |
-// +------------+      +--------------------------+      +---------------------+
-// | Producer 2 |  <-> |      SMB 2 [~32K - 1MB]  |     /| large ring buffers  |
-// +------------+      +--------+--------+--------+ <--+ | (100K - several MB) |
-//                     |  Page  |  Page  |  Page  |      +---------------------+
-//                     +--------+--------+--------+
-//                     | Chunk  |        | Chunk  |
-//                     +--------+  Chunk +--------+
-//                     | Chunk  |        | Chunk  |
-//                     +--------+--------+--------+
-//
-// * Sizes of both SMB and ring buffers are purely indicative and decided at
-// configuration time by the Producer (for SMB sizes) and the Consumer (for the
-// final ring buffer size).
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* trace_id */:
+        field.get(&trace_id_);
+        break;
+      case 2 /* step */:
+        field.get(&step_);
+        break;
+      case 3 /* frame_tree_node_id */:
+        field.get(&frame_tree_node_id_);
+        break;
+      case 4 /* component_info */:
+        component_info_.emplace_back();
+        component_info_.back().ParseFromArray(field.data(), field.size());
+        break;
+      case 5 /* is_coalesced */:
+        field.get(&is_coalesced_);
+        break;
+      case 6 /* gesture_scroll_id */:
+        field.get(&gesture_scroll_id_);
+        break;
+      case 7 /* touch_id */:
+        field.get(&touch_id_);
+        break;
+      case 8 /* input_type */:
+        field.get(&input_type_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-// Page
-// ----
-// A page is a portion of the shared memory buffer and defines the granularity
-// of the interaction between the Producer and tracing Service. When scanning
-// the shared memory buffer to determine if something should be moved to the
-// central logging buffers, the Service most of the times looks at and moves
-// whole pages. Similarly, the Producer sends an IPC to invite the Service to
-// drain the shared memory buffer only when a whole page is filled.
-// Having fixed the total SMB size (hence the total memory overhead), the page
-// size is a triangular tradeoff between:
-// 1) IPC traffic: smaller pages -> more IPCs.
-// 2) Producer lock freedom: larger pages -> larger chunks -> data sources can
-//    write more data without needing to swap chunks and synchronize.
-// 3) Risk of write-starving the SMB: larger pages -> higher chance that the
-//    Service won't manage to drain them and the SMB remains full.
-// The page size, on the other side, has no implications on wasted memory due to
-// fragmentations (see Chunk below).
-// The size of the page is chosen by the Service at connection time and stays
-// fixed throughout all the lifetime of the Producer. Different producers (i.e.
-// ~ different client processes) can use different page sizes.
-// The page size must be an integer multiple of 4k (this is to allow VM page
-// stealing optimizations) and obviously has to be an integer divisor of the
-// total SMB size.
+std::string ChromeLatencyInfo::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-// Chunk
-// -----
-// A chunk is a portion of a Page which is written and handled by a Producer.
-// A chunk contains a linear sequence of TracePacket(s) (the root proto).
-// A chunk cannot be written concurrently by two data sources. Protobufs must be
-// encoded as contiguous byte streams and cannot be interleaved. Therefore, on
-// the Producer side, a chunk is almost always owned exclusively by one thread
-// (% extremely peculiar slow-path cases).
-// Chunks are essentially single-writer single-thread lock-free arenas. Locking
-// happens only when a Chunk is full and a new one needs to be acquired.
-// Locking happens only within the scope of a Producer process. There is no
-// inter-process locking. The Producer cannot lock the Service and viceversa.
-// In the worst case, any of the two can starve the SMB, by marking all chunks
-// as either being read or written. But that has the only side effect of
-// losing the trace data.
-// The Producer can decide to partition each page into a number of limited
-// configurations (e.g., 1 page == 1 chunk, 1 page == 2 chunks and so on).
+std::vector<uint8_t> ChromeLatencyInfo::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-// TracePacket
-// -----------
-// Is the atom of tracing. Putting aside pages and chunks a trace is merely a
-// sequence of TracePacket(s). TracePacket is the root protobuf message.
-// A TracePacket can span across several chunks (hence even across several
-// pages). A TracePacket can therefore be >> chunk size, >> page size and even
-// >> SMB size. The Chunk header carries metadata to deal with the TracePacket
-// splitting case.
+void ChromeLatencyInfo::Serialize(::protozero::Message* msg) const {
+  // Field 1: trace_id
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, trace_id_, msg);
+  }
 
-// Use only explicitly-sized types below. DO NOT use size_t or any architecture
-// dependent size (e.g. size_t) in the struct fields. This buffer will be read
-// and written by processes that have a different bitness in the same OS.
-// Instead it's fine to assume little-endianess. Big-endian is a dream we are
-// not currently pursuing.
+  // Field 2: step
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, step_, msg);
+  }
 
-class SharedMemoryABI {
- public:
-  static constexpr size_t kMinPageSize = 4 * 1024;
+  // Field 3: frame_tree_node_id
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, frame_tree_node_id_, msg);
+  }
 
-  // This is due to Chunk::size being 16 bits.
-  static constexpr size_t kMaxPageSize = 64 * 1024;
+  // Field 4: component_info
+  for (auto& it : component_info_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(4));
+  }
 
-  // "14" is the max number that can be encoded in a 32 bit atomic word using
-  // 2 state bits per Chunk and leaving 4 bits for the page layout.
-  // See PageLayout below.
-  static constexpr size_t kMaxChunksPerPage = 14;
+  // Field 5: is_coalesced
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, is_coalesced_, msg);
+  }
 
-  // Each TracePacket in the Chunk is prefixed by a 4 bytes redundant VarInt
-  // (see proto_utils.h) stating its size.
-  static constexpr size_t kPacketHeaderSize = 4;
+  // Field 6: gesture_scroll_id
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, gesture_scroll_id_, msg);
+  }
 
-  // TraceWriter specifies this invalid packet/fragment size to signal to the
-  // service that a packet should be discarded, because the TraceWriter couldn't
-  // write its remaining fragments (e.g. because the SMB was exhausted).
-  static constexpr size_t kPacketSizeDropPacket =
-      protozero::proto_utils::kMaxMessageLength;
+  // Field 7: touch_id
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(7, touch_id_, msg);
+  }
 
-  // Chunk states and transitions:
-  //    kChunkFree  <----------------+
-  //         |  (Producer)           |
-  //         V                       |
-  //  kChunkBeingWritten             |
-  //         |  (Producer)           |
-  //         V                       |
-  //  kChunkComplete                 |
-  //         |  (Service)            |
-  //         V                       |
-  //  kChunkBeingRead                |
-  //        |   (Service)            |
-  //        +------------------------+
-  enum ChunkState : uint32_t {
-    // The Chunk is free. The Service shall never touch it, the Producer can
-    // acquire it and transition it into kChunkBeingWritten.
-    kChunkFree = 0,
+  // Field 8: input_type
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(8, input_type_, msg);
+  }
 
-    // The Chunk is being used by the Producer and is not complete yet.
-    // The Service shall never touch kChunkBeingWritten pages.
-    kChunkBeingWritten = 1,
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-    // The Service is moving the page into its non-shared ring buffer. The
-    // Producer shall never touch kChunkBeingRead pages.
-    kChunkBeingRead = 2,
 
-    // The Producer is done writing the page and won't touch it again. The
-    // Service can now move it to its non-shared ring buffer.
-    // kAllChunksComplete relies on this being == 3.
-    kChunkComplete = 3,
-  };
-  static constexpr const char* kChunkStateStr[] = {"Free", "BeingWritten",
-                                                   "BeingRead", "Complete"};
+ChromeLatencyInfo_ComponentInfo::ChromeLatencyInfo_ComponentInfo() = default;
+ChromeLatencyInfo_ComponentInfo::~ChromeLatencyInfo_ComponentInfo() = default;
+ChromeLatencyInfo_ComponentInfo::ChromeLatencyInfo_ComponentInfo(const ChromeLatencyInfo_ComponentInfo&) = default;
+ChromeLatencyInfo_ComponentInfo& ChromeLatencyInfo_ComponentInfo::operator=(const ChromeLatencyInfo_ComponentInfo&) = default;
+ChromeLatencyInfo_ComponentInfo::ChromeLatencyInfo_ComponentInfo(ChromeLatencyInfo_ComponentInfo&&) noexcept = default;
+ChromeLatencyInfo_ComponentInfo& ChromeLatencyInfo_ComponentInfo::operator=(ChromeLatencyInfo_ComponentInfo&&) = default;
 
-  enum PageLayout : uint32_t {
-    // The page is fully free and has not been partitioned yet.
-    kPageNotPartitioned = 0,
+bool ChromeLatencyInfo_ComponentInfo::operator==(const ChromeLatencyInfo_ComponentInfo& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(component_type_, other.component_type_)
+   && ::protozero::internal::gen_helpers::EqualsField(time_us_, other.time_us_);
+}
 
-    // TODO(primiano): Aligning a chunk @ 16 bytes could allow to use faster
-    // intrinsics based on quad-word moves. Do the math and check what is the
-    // fragmentation loss.
+bool ChromeLatencyInfo_ComponentInfo::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-    // align4(X) := the largest integer N s.t. (N % 4) == 0 && N <= X.
-    // 8 == sizeof(PageHeader).
-    kPageDiv1 = 1,   // Only one chunk of size: PAGE_SIZE - 8.
-    kPageDiv2 = 2,   // Two chunks of size: align4((PAGE_SIZE - 8) / 2).
-    kPageDiv4 = 3,   // Four chunks of size: align4((PAGE_SIZE - 8) / 4).
-    kPageDiv7 = 4,   // Seven chunks of size: align4((PAGE_SIZE - 8) / 7).
-    kPageDiv14 = 5,  // Fourteen chunks of size: align4((PAGE_SIZE - 8) / 14).
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* component_type */:
+        field.get(&component_type_);
+        break;
+      case 2 /* time_us */:
+        field.get(&time_us_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-    // The rationale for 7 and 14 above is to maximize the page usage for the
-    // likely case of |page_size| == 4096:
-    // (((4096 - 8) / 14) % 4) == 0, while (((4096 - 8) / 16 % 4)) == 3. So
-    // Div16 would waste 3 * 16 = 48 bytes per page for chunk alignment gaps.
+std::string ChromeLatencyInfo_ComponentInfo::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-    kPageDivReserved1 = 6,
-    kPageDivReserved2 = 7,
-    kNumPageLayouts = 8,
-  };
+std::vector<uint8_t> ChromeLatencyInfo_ComponentInfo::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  // Keep this consistent with the PageLayout enum above.
-  static constexpr uint32_t kNumChunksForLayout[] = {0, 1, 2, 4, 7, 14, 0, 0};
+void ChromeLatencyInfo_ComponentInfo::Serialize(::protozero::Message* msg) const {
+  // Field 1: component_type
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, component_type_, msg);
+  }
 
-  // Layout of a Page.
-  // +===================================================+
-  // | Page header [8 bytes]                             |
-  // | Tells how many chunks there are, how big they are |
-  // | and their state (free, read, write, complete).    |
-  // +===================================================+
-  // +***************************************************+
-  // | Chunk #0 header [8 bytes]                         |
-  // | Tells how many packets there are and whether the  |
-  // | whether the 1st and last ones are fragmented.     |
-  // | Also has a chunk id to reassemble fragments.    |
-  // +***************************************************+
-  // +---------------------------------------------------+
-  // | Packet #0 size [varint, up to 4 bytes]            |
-  // + - - - - - - - - - - - - - - - - - - - - - - - - - +
-  // | Packet #0 payload                                 |
-  // | A TracePacket protobuf message                    |
-  // +---------------------------------------------------+
-  //                         ...
-  // + . . . . . . . . . . . . . . . . . . . . . . . . . +
-  // |      Optional padding to maintain aligment        |
-  // + . . . . . . . . . . . . . . . . . . . . . . . . . +
-  // +---------------------------------------------------+
-  // | Packet #N size [varint, up to 4 bytes]            |
-  // + - - - - - - - - - - - - - - - - - - - - - - - - - +
-  // | Packet #N payload                                 |
-  // | A TracePacket protobuf message                    |
-  // +---------------------------------------------------+
-  //                         ...
-  // +***************************************************+
-  // | Chunk #M header [8 bytes]                         |
-  //                         ...
-
-  // Alignment applies to start offset only. The Chunk size is *not* aligned.
-  static constexpr uint32_t kChunkAlignment = 4;
-  static constexpr uint32_t kChunkShift = 2;
-  static constexpr uint32_t kChunkMask = 0x3;
-  static constexpr uint32_t kLayoutMask = 0x70000000;
-  static constexpr uint32_t kLayoutShift = 28;
-  static constexpr uint32_t kAllChunksMask = 0x0FFFFFFF;
-
-  // This assumes that kChunkComplete == 3.
-  static constexpr uint32_t kAllChunksComplete = 0x0FFFFFFF;
-  static constexpr uint32_t kAllChunksFree = 0;
-  static constexpr size_t kInvalidPageIdx = static_cast<size_t>(-1);
-
-  // There is one page header per page, at the beginning of the page.
-  struct PageHeader {
-    // |layout| bits:
-    // [31] [30:28] [27:26] ... [1:0]
-    //  |      |       |     |    |
-    //  |      |       |     |    +---------- ChunkState[0]
-    //  |      |       |     +--------------- ChunkState[12..1]
-    //  |      |       +--------------------- ChunkState[13]
-    //  |      +----------------------------- PageLayout (0 == page fully free)
-    //  +------------------------------------ Reserved for future use
-    std::atomic<uint32_t> layout;
-
-    // If we'll ever going to use this in the future it might come handy
-    // reviving the kPageBeingPartitioned logic (look in git log, it was there
-    // at some point in the past).
-    uint32_t reserved;
-  };
-
-  // There is one Chunk header per chunk (hence PageLayout per page) at the
-  // beginning of each chunk.
-  struct ChunkHeader {
-    enum Flags : uint8_t {
-      // If set, the first TracePacket in the chunk is partial and continues
-      // from |chunk_id| - 1 (within the same |writer_id|).
-      kFirstPacketContinuesFromPrevChunk = 1 << 0,
-
-      // If set, the last TracePacket in the chunk is partial and continues on
-      // |chunk_id| + 1 (within the same |writer_id|).
-      kLastPacketContinuesOnNextChunk = 1 << 1,
-
-      // If set, the last (fragmented) TracePacket in the chunk has holes (even
-      // if the chunk is marked as kChunkComplete) that need to be patched
-      // out-of-band before the chunk can be read.
-      kChunkNeedsPatching = 1 << 2,
-    };
-
-    struct Packets {
-      // Number of valid TracePacket protobuf messages contained in the chunk.
-      // Each TracePacket is prefixed by its own size. This field is
-      // monotonically updated by the Producer with release store semantic when
-      // the packet at position |count| is started. This last packet may not be
-      // considered complete until |count| is incremented for the subsequent
-      // packet or the chunk is completed.
-      uint16_t count : 10;
-      static constexpr size_t kMaxCount = (1 << 10) - 1;
+  // Field 2: time_us
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, time_us_, msg);
+  }
 
-      // See Flags above.
-      uint16_t flags : 6;
-    };
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-    // A monotonic counter of the chunk within the scoped of a |writer_id|.
-    // The tuple (ProducerID, WriterID, ChunkID) allows to figure out if two
-    // chunks are contiguous (and hence a trace packets spanning across them can
-    // be glued) or we had some holes due to the ring buffer wrapping.
-    // This is set only when transitioning from kChunkFree to kChunkBeingWritten
-    // and remains unchanged throughout the remaining lifetime of the chunk.
-    std::atomic<uint32_t> chunk_id;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_legacy_ipc.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_legacy_ipc.gen.h"
 
-    // ID of the writer, unique within the producer.
-    // Like |chunk_id|, this is set only when transitioning from kChunkFree to
-    // kChunkBeingWritten.
-    std::atomic<uint16_t> writer_id;
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-    // There is no ProducerID here. The service figures that out from the IPC
-    // channel, which is unspoofable.
+ChromeLegacyIpc::ChromeLegacyIpc() = default;
+ChromeLegacyIpc::~ChromeLegacyIpc() = default;
+ChromeLegacyIpc::ChromeLegacyIpc(const ChromeLegacyIpc&) = default;
+ChromeLegacyIpc& ChromeLegacyIpc::operator=(const ChromeLegacyIpc&) = default;
+ChromeLegacyIpc::ChromeLegacyIpc(ChromeLegacyIpc&&) noexcept = default;
+ChromeLegacyIpc& ChromeLegacyIpc::operator=(ChromeLegacyIpc&&) = default;
 
-    // Updated with release-store semantics.
-    std::atomic<Packets> packets;
-  };
+bool ChromeLegacyIpc::operator==(const ChromeLegacyIpc& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(message_class_, other.message_class_)
+   && ::protozero::internal::gen_helpers::EqualsField(message_line_, other.message_line_);
+}
 
-  class Chunk {
-   public:
-    Chunk();  // Constructs an invalid chunk.
+bool ChromeLegacyIpc::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-    // Chunk is move-only, to document the scope of the Acquire/Release
-    // TryLock operations below.
-    Chunk(const Chunk&) = delete;
-    Chunk operator=(const Chunk&) = delete;
-    Chunk(Chunk&&) noexcept;
-    Chunk& operator=(Chunk&&);
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* message_class */:
+        field.get(&message_class_);
+        break;
+      case 2 /* message_line */:
+        field.get(&message_line_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-    uint8_t* begin() const { return begin_; }
-    uint8_t* end() const { return begin_ + size_; }
+std::string ChromeLegacyIpc::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-    // Size, including Chunk header.
-    size_t size() const { return size_; }
+std::vector<uint8_t> ChromeLegacyIpc::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-    // Begin of the first packet (or packet fragment).
-    uint8_t* payload_begin() const { return begin_ + sizeof(ChunkHeader); }
-    size_t payload_size() const {
-      PERFETTO_DCHECK(size_ >= sizeof(ChunkHeader));
-      return size_ - sizeof(ChunkHeader);
-    }
+void ChromeLegacyIpc::Serialize(::protozero::Message* msg) const {
+  // Field 1: message_class
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, message_class_, msg);
+  }
 
-    bool is_valid() const { return begin_ && size_; }
+  // Field 2: message_line
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, message_line_, msg);
+  }
 
-    // Index of the chunk within the page [0..13] (13 comes from kPageDiv14).
-    uint8_t chunk_idx() const { return chunk_idx_; }
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-    ChunkHeader* header() { return reinterpret_cast<ChunkHeader*>(begin_); }
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_message_pump.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_message_pump.gen.h"
 
-    uint16_t writer_id() {
-      return header()->writer_id.load(std::memory_order_relaxed);
-    }
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-    // Returns the count of packets and the flags with acquire-load semantics.
-    std::pair<uint16_t, uint8_t> GetPacketCountAndFlags() {
-      auto packets = header()->packets.load(std::memory_order_acquire);
-      const uint16_t packets_count = packets.count;
-      const uint8_t packets_flags = packets.flags;
-      return std::make_pair(packets_count, packets_flags);
-    }
+ChromeMessagePump::ChromeMessagePump() = default;
+ChromeMessagePump::~ChromeMessagePump() = default;
+ChromeMessagePump::ChromeMessagePump(const ChromeMessagePump&) = default;
+ChromeMessagePump& ChromeMessagePump::operator=(const ChromeMessagePump&) = default;
+ChromeMessagePump::ChromeMessagePump(ChromeMessagePump&&) noexcept = default;
+ChromeMessagePump& ChromeMessagePump::operator=(ChromeMessagePump&&) = default;
 
-    // Increases |packets.count| with release semantics (note, however, that the
-    // packet count is incremented *before* starting writing a packet). Returns
-    // the new packet count. The increment is atomic but NOT race-free (i.e. no
-    // CAS). Only the Producer is supposed to perform this increment, and it's
-    // supposed to do that in a thread-safe way (holding a lock). A Chunk cannot
-    // be shared by multiple Producer threads without locking. The packet count
-    // is cleared by TryAcquireChunk(), when passing the new header for the
-    // chunk.
-    uint16_t IncrementPacketCount() {
-      ChunkHeader* chunk_header = header();
-      auto packets = chunk_header->packets.load(std::memory_order_relaxed);
-      packets.count++;
-      chunk_header->packets.store(packets, std::memory_order_release);
-      return packets.count;
-    }
+bool ChromeMessagePump::operator==(const ChromeMessagePump& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(sent_messages_in_queue_, other.sent_messages_in_queue_)
+   && ::protozero::internal::gen_helpers::EqualsField(io_handler_location_iid_, other.io_handler_location_iid_);
+}
 
-    // Increases |packets.count| to the given |packet_count|, but only if
-    // |packet_count| is larger than the current value of |packets.count|.
-    // Returns the new packet count. Same atomicity guarantees as
-    // IncrementPacketCount().
-    uint16_t IncreasePacketCountTo(uint16_t packet_count) {
-      ChunkHeader* chunk_header = header();
-      auto packets = chunk_header->packets.load(std::memory_order_relaxed);
-      if (packets.count < packet_count)
-        packets.count = packet_count;
-      chunk_header->packets.store(packets, std::memory_order_release);
-      return packets.count;
-    }
+bool ChromeMessagePump::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-    // Flags are cleared by TryAcquireChunk(), by passing the new header for
-    // the chunk, or through ClearNeedsPatchingFlag.
-    void SetFlag(ChunkHeader::Flags flag) {
-      ChunkHeader* chunk_header = header();
-      auto packets = chunk_header->packets.load(std::memory_order_relaxed);
-      packets.flags |= flag;
-      chunk_header->packets.store(packets, std::memory_order_release);
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
     }
-
-    // This flag can only be cleared by the producer while it is still holding
-    // on to the chunk - i.e. while the chunk is still in state
-    // ChunkState::kChunkBeingWritten and hasn't been transitioned to
-    // ChunkState::kChunkComplete. This is ok, because the service is oblivious
-    // to the needs patching flag before the chunk is released as complete.
-    void ClearNeedsPatchingFlag() {
-      ChunkHeader* chunk_header = header();
-      auto packets = chunk_header->packets.load(std::memory_order_relaxed);
-      packets.flags &= ~ChunkHeader::kChunkNeedsPatching;
-      chunk_header->packets.store(packets, std::memory_order_release);
+    switch (field.id()) {
+      case 1 /* sent_messages_in_queue */:
+        field.get(&sent_messages_in_queue_);
+        break;
+      case 2 /* io_handler_location_iid */:
+        field.get(&io_handler_location_iid_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
     }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-   private:
-    friend class SharedMemoryABI;
-    Chunk(uint8_t* begin, uint16_t size, uint8_t chunk_idx);
-
-    // Don't add extra fields, keep the move operator fast.
-    uint8_t* begin_ = nullptr;
-    uint16_t size_ = 0;
-    uint8_t chunk_idx_ = 0;
-  };
-
-  // Construct an instance from an existing shared memory buffer.
-  SharedMemoryABI(uint8_t* start, size_t size, size_t page_size);
-  SharedMemoryABI();
-
-  void Initialize(uint8_t* start, size_t size, size_t page_size);
+std::string ChromeMessagePump::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  uint8_t* start() const { return start_; }
-  uint8_t* end() const { return start_ + size_; }
-  size_t size() const { return size_; }
-  size_t page_size() const { return page_size_; }
-  size_t num_pages() const { return num_pages_; }
-  bool is_valid() { return num_pages() > 0; }
+std::vector<uint8_t> ChromeMessagePump::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  uint8_t* page_start(size_t page_idx) {
-    PERFETTO_DCHECK(page_idx < num_pages_);
-    return start_ + page_size_ * page_idx;
+void ChromeMessagePump::Serialize(::protozero::Message* msg) const {
+  // Field 1: sent_messages_in_queue
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(1, sent_messages_in_queue_, msg);
   }
 
-  PageHeader* page_header(size_t page_idx) {
-    return reinterpret_cast<PageHeader*>(page_start(page_idx));
+  // Field 2: io_handler_location_iid
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, io_handler_location_iid_, msg);
   }
 
-  // Returns true if the page is fully clear and has not been partitioned yet.
-  // The state of the page can change at any point after this returns (or even
-  // before). The Producer should use this only as a hint to decide out whether
-  // it should TryPartitionPage() or acquire an individual chunk.
-  bool is_page_free(size_t page_idx) {
-    return page_header(page_idx)->layout.load(std::memory_order_relaxed) == 0;
-  }
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  // Returns true if all chunks in the page are kChunkComplete. As above, this
-  // is advisory only. The Service is supposed to use this only to decide
-  // whether to TryAcquireAllChunksForReading() or not.
-  bool is_page_complete(size_t page_idx) {
-    auto layout = page_header(page_idx)->layout.load(std::memory_order_relaxed);
-    const uint32_t num_chunks = GetNumChunksForLayout(layout);
-    if (num_chunks == 0)
-      return false;  // Non partitioned pages cannot be complete.
-    return (layout & kAllChunksMask) ==
-           (kAllChunksComplete & ((1 << (num_chunks * kChunkShift)) - 1));
-  }
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_mojo_event_info.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_mojo_event_info.gen.h"
 
-  // For testing / debugging only.
-  std::string page_header_dbg(size_t page_idx) {
-    uint32_t x = page_header(page_idx)->layout.load(std::memory_order_relaxed);
-    return std::bitset<32>(x).to_string();
-  }
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-  // Returns the page layout, which is a bitmap that specifies the chunking
-  // layout of the page and each chunk's current state. Reads with an
-  // acquire-load semantic to ensure a producer's writes corresponding to an
-  // update of the layout (e.g. clearing a chunk's header) are observed
-  // consistently.
-  uint32_t GetPageLayout(size_t page_idx) {
-    return page_header(page_idx)->layout.load(std::memory_order_acquire);
-  }
+ChromeMojoEventInfo::ChromeMojoEventInfo() = default;
+ChromeMojoEventInfo::~ChromeMojoEventInfo() = default;
+ChromeMojoEventInfo::ChromeMojoEventInfo(const ChromeMojoEventInfo&) = default;
+ChromeMojoEventInfo& ChromeMojoEventInfo::operator=(const ChromeMojoEventInfo&) = default;
+ChromeMojoEventInfo::ChromeMojoEventInfo(ChromeMojoEventInfo&&) noexcept = default;
+ChromeMojoEventInfo& ChromeMojoEventInfo::operator=(ChromeMojoEventInfo&&) = default;
 
-  // Returns a bitmap in which each bit is set if the corresponding Chunk exists
-  // in the page (according to the page layout) and is free. If the page is not
-  // partitioned it returns 0 (as if the page had no free chunks).
-  uint32_t GetFreeChunks(size_t page_idx);
+bool ChromeMojoEventInfo::operator==(const ChromeMojoEventInfo& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(watcher_notify_interface_tag_, other.watcher_notify_interface_tag_)
+   && ::protozero::internal::gen_helpers::EqualsField(ipc_hash_, other.ipc_hash_)
+   && ::protozero::internal::gen_helpers::EqualsField(mojo_interface_tag_, other.mojo_interface_tag_)
+   && ::protozero::internal::gen_helpers::EqualsField(mojo_interface_method_iid_, other.mojo_interface_method_iid_)
+   && ::protozero::internal::gen_helpers::EqualsField(is_reply_, other.is_reply_)
+   && ::protozero::internal::gen_helpers::EqualsField(payload_size_, other.payload_size_)
+   && ::protozero::internal::gen_helpers::EqualsField(data_num_bytes_, other.data_num_bytes_);
+}
 
-  // Tries to atomically partition a page with the given |layout|. Returns true
-  // if the page was free and has been partitioned with the given |layout|,
-  // false if the page wasn't free anymore by the time we got there.
-  // If succeeds all the chunks are atomically set in the kChunkFree state.
-  bool TryPartitionPage(size_t page_idx, PageLayout layout);
+bool ChromeMojoEventInfo::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  // Tries to atomically mark a single chunk within the page as
-  // kChunkBeingWritten. Returns an invalid chunk if the page is not partitioned
-  // or the chunk is not in the kChunkFree state. If succeeds sets the chunk
-  // header to |header|.
-  Chunk TryAcquireChunkForWriting(size_t page_idx,
-                                  size_t chunk_idx,
-                                  const ChunkHeader* header) {
-    return TryAcquireChunk(page_idx, chunk_idx, kChunkBeingWritten, header);
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* watcher_notify_interface_tag */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &watcher_notify_interface_tag_);
+        break;
+      case 2 /* ipc_hash */:
+        field.get(&ipc_hash_);
+        break;
+      case 3 /* mojo_interface_tag */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &mojo_interface_tag_);
+        break;
+      case 4 /* mojo_interface_method_iid */:
+        field.get(&mojo_interface_method_iid_);
+        break;
+      case 5 /* is_reply */:
+        field.get(&is_reply_);
+        break;
+      case 6 /* payload_size */:
+        field.get(&payload_size_);
+        break;
+      case 7 /* data_num_bytes */:
+        field.get(&data_num_bytes_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
   }
+  return !packed_error && !dec.bytes_left();
+}
 
-  // Similar to TryAcquireChunkForWriting. Fails if the chunk isn't in the
-  // kChunkComplete state.
-  Chunk TryAcquireChunkForReading(size_t page_idx, size_t chunk_idx) {
-    return TryAcquireChunk(page_idx, chunk_idx, kChunkBeingRead, nullptr);
-  }
+std::string ChromeMojoEventInfo::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  // The caller must have successfully TryAcquireAllChunksForReading() or it
-  // needs to guarantee that the chunk is already in the kChunkBeingWritten
-  // state.
-  Chunk GetChunkUnchecked(size_t page_idx,
-                          uint32_t page_layout,
-                          size_t chunk_idx);
+std::vector<uint8_t> ChromeMojoEventInfo::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  // Puts a chunk into the kChunkComplete state. Returns the page index.
-  size_t ReleaseChunkAsComplete(Chunk chunk) {
-    return ReleaseChunk(std::move(chunk), kChunkComplete);
+void ChromeMojoEventInfo::Serialize(::protozero::Message* msg) const {
+  // Field 1: watcher_notify_interface_tag
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeString(1, watcher_notify_interface_tag_, msg);
   }
 
-  // Puts a chunk into the kChunkFree state. Returns the page index.
-  size_t ReleaseChunkAsFree(Chunk chunk) {
-    return ReleaseChunk(std::move(chunk), kChunkFree);
+  // Field 2: ipc_hash
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, ipc_hash_, msg);
   }
 
-  ChunkState GetChunkState(size_t page_idx, size_t chunk_idx) {
-    PageHeader* phdr = page_header(page_idx);
-    uint32_t layout = phdr->layout.load(std::memory_order_relaxed);
-    return GetChunkStateFromLayout(layout, chunk_idx);
+  // Field 3: mojo_interface_tag
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeString(3, mojo_interface_tag_, msg);
   }
 
-  std::pair<size_t, size_t> GetPageAndChunkIndex(const Chunk& chunk);
-
-  uint16_t GetChunkSizeForLayout(uint32_t page_layout) const {
-    return chunk_sizes_[(page_layout & kLayoutMask) >> kLayoutShift];
+  // Field 4: mojo_interface_method_iid
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, mojo_interface_method_iid_, msg);
   }
 
-  static ChunkState GetChunkStateFromLayout(uint32_t page_layout,
-                                            size_t chunk_idx) {
-    return static_cast<ChunkState>((page_layout >> (chunk_idx * kChunkShift)) &
-                                   kChunkMask);
+  // Field 5: is_reply
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, is_reply_, msg);
   }
 
-  static constexpr uint32_t GetNumChunksForLayout(uint32_t page_layout) {
-    return kNumChunksForLayout[(page_layout & kLayoutMask) >> kLayoutShift];
+  // Field 6: payload_size
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, payload_size_, msg);
   }
 
-  // Returns a bitmap in which each bit is set if the corresponding Chunk exists
-  // in the page (according to the page layout) and is not free. If the page is
-  // not partitioned it returns 0 (as if the page had no used chunks). Bit N
-  // corresponds to Chunk N.
-  static uint32_t GetUsedChunks(uint32_t page_layout) {
-    const uint32_t num_chunks = GetNumChunksForLayout(page_layout);
-    uint32_t res = 0;
-    for (uint32_t i = 0; i < num_chunks; i++) {
-      res |= ((page_layout & kChunkMask) != kChunkFree) ? (1 << i) : 0;
-      page_layout >>= kChunkShift;
-    }
-    return res;
+  // Field 7: data_num_bytes
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(7, data_num_bytes_, msg);
   }
 
- private:
-  SharedMemoryABI(const SharedMemoryABI&) = delete;
-  SharedMemoryABI& operator=(const SharedMemoryABI&) = delete;
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  Chunk TryAcquireChunk(size_t page_idx,
-                        size_t chunk_idx,
-                        ChunkState,
-                        const ChunkHeader*);
-  size_t ReleaseChunk(Chunk chunk, ChunkState);
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_process_descriptor.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_process_descriptor.gen.h"
 
-  uint8_t* start_ = nullptr;
-  size_t size_ = 0;
-  size_t page_size_ = 0;
-  size_t num_pages_ = 0;
-  std::array<uint16_t, kNumPageLayouts> chunk_sizes_;
-};
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-}  // namespace perfetto
+ChromeProcessDescriptor::ChromeProcessDescriptor() = default;
+ChromeProcessDescriptor::~ChromeProcessDescriptor() = default;
+ChromeProcessDescriptor::ChromeProcessDescriptor(const ChromeProcessDescriptor&) = default;
+ChromeProcessDescriptor& ChromeProcessDescriptor::operator=(const ChromeProcessDescriptor&) = default;
+ChromeProcessDescriptor::ChromeProcessDescriptor(ChromeProcessDescriptor&&) noexcept = default;
+ChromeProcessDescriptor& ChromeProcessDescriptor::operator=(ChromeProcessDescriptor&&) = default;
 
-#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_SHARED_MEMORY_ABI_H_
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the
- * License. You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an "AS
- * IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
- * express or implied. See the License for the specific language
- * governing permissions and limitations under the License.
- */
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_abi.h"
+bool ChromeProcessDescriptor::operator==(const ChromeProcessDescriptor& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(process_type_, other.process_type_)
+   && ::protozero::internal::gen_helpers::EqualsField(process_priority_, other.process_priority_)
+   && ::protozero::internal::gen_helpers::EqualsField(legacy_sort_index_, other.legacy_sort_index_)
+   && ::protozero::internal::gen_helpers::EqualsField(host_app_package_name_, other.host_app_package_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(crash_trace_id_, other.crash_trace_id_);
+}
 
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
-// gen_amalgamated expanded: #include "perfetto/base/time.h"
+bool ChromeProcessDescriptor::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-#include <sys/mman.h>
-#endif
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* process_type */:
+        field.get(&process_type_);
+        break;
+      case 2 /* process_priority */:
+        field.get(&process_priority_);
+        break;
+      case 3 /* legacy_sort_index */:
+        field.get(&legacy_sort_index_);
+        break;
+      case 4 /* host_app_package_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &host_app_package_name_);
+        break;
+      case 5 /* crash_trace_id */:
+        field.get(&crash_trace_id_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
+std::string ChromeProcessDescriptor::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-namespace perfetto {
+std::vector<uint8_t> ChromeProcessDescriptor::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-namespace {
+void ChromeProcessDescriptor::Serialize(::protozero::Message* msg) const {
+  // Field 1: process_type
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, process_type_, msg);
+  }
 
-constexpr int kRetryAttempts = 64;
+  // Field 2: process_priority
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, process_priority_, msg);
+  }
 
-inline void WaitBeforeNextAttempt(int attempt) {
-  if (attempt < kRetryAttempts / 2) {
-    std::this_thread::yield();
-  } else {
-    base::SleepMicroseconds((unsigned(attempt) / 10) * 1000);
+  // Field 3: legacy_sort_index
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, legacy_sort_index_, msg);
   }
-}
 
-// Returns the largest 4-bytes aligned chunk size <= |page_size| / |divider|
-// for each divider in PageLayout.
-constexpr size_t GetChunkSize(size_t page_size, size_t divider) {
-  return ((page_size - sizeof(SharedMemoryABI::PageHeader)) / divider) & ~3UL;
-}
+  // Field 4: host_app_package_name
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeString(4, host_app_package_name_, msg);
+  }
 
-// Initializer for the const |chunk_sizes_| array.
-std::array<uint16_t, SharedMemoryABI::kNumPageLayouts> InitChunkSizes(
-    size_t page_size) {
-  static_assert(SharedMemoryABI::kNumPageLayouts ==
-                    base::ArraySize(SharedMemoryABI::kNumChunksForLayout),
-                "kNumPageLayouts out of date");
-  std::array<uint16_t, SharedMemoryABI::kNumPageLayouts> res = {};
-  for (size_t i = 0; i < SharedMemoryABI::kNumPageLayouts; i++) {
-    size_t num_chunks = SharedMemoryABI::kNumChunksForLayout[i];
-    size_t size = num_chunks == 0 ? 0 : GetChunkSize(page_size, num_chunks);
-    PERFETTO_CHECK(size <= std::numeric_limits<uint16_t>::max());
-    res[i] = static_cast<uint16_t>(size);
+  // Field 5: crash_trace_id
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, crash_trace_id_, msg);
   }
-  return res;
-}
 
-inline void ClearChunkHeader(SharedMemoryABI::ChunkHeader* header) {
-  header->writer_id.store(0u, std::memory_order_relaxed);
-  header->chunk_id.store(0u, std::memory_order_relaxed);
-  header->packets.store({}, std::memory_order_release);
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
-}  // namespace
-
-#if !PERFETTO_IS_AT_LEAST_CPP17()
-// static
-constexpr uint32_t SharedMemoryABI::kNumChunksForLayout[];
-constexpr const char* SharedMemoryABI::kChunkStateStr[];
-constexpr const size_t SharedMemoryABI::kInvalidPageIdx;
-constexpr const size_t SharedMemoryABI::kMinPageSize;
-constexpr const size_t SharedMemoryABI::kMaxPageSize;
-constexpr const size_t SharedMemoryABI::kPacketSizeDropPacket;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_renderer_scheduler_state.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_renderer_scheduler_state.gen.h"
 
-SharedMemoryABI::SharedMemoryABI() = default;
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-SharedMemoryABI::SharedMemoryABI(uint8_t* start,
-                                 size_t size,
-                                 size_t page_size) {
-  Initialize(start, size, page_size);
-}
+ChromeRendererSchedulerState::ChromeRendererSchedulerState() = default;
+ChromeRendererSchedulerState::~ChromeRendererSchedulerState() = default;
+ChromeRendererSchedulerState::ChromeRendererSchedulerState(const ChromeRendererSchedulerState&) = default;
+ChromeRendererSchedulerState& ChromeRendererSchedulerState::operator=(const ChromeRendererSchedulerState&) = default;
+ChromeRendererSchedulerState::ChromeRendererSchedulerState(ChromeRendererSchedulerState&&) noexcept = default;
+ChromeRendererSchedulerState& ChromeRendererSchedulerState::operator=(ChromeRendererSchedulerState&&) = default;
 
-void SharedMemoryABI::Initialize(uint8_t* start,
-                                 size_t size,
-                                 size_t page_size) {
-  start_ = start;
-  size_ = size;
-  page_size_ = page_size;
-  num_pages_ = size / page_size;
-  chunk_sizes_ = InitChunkSizes(page_size);
-  static_assert(sizeof(PageHeader) == 8, "PageHeader size");
-  static_assert(sizeof(ChunkHeader) == 8, "ChunkHeader size");
-  static_assert(sizeof(ChunkHeader::chunk_id) == sizeof(ChunkID),
-                "ChunkID size");
+bool ChromeRendererSchedulerState::operator==(const ChromeRendererSchedulerState& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(rail_mode_, other.rail_mode_)
+   && ::protozero::internal::gen_helpers::EqualsField(is_backgrounded_, other.is_backgrounded_)
+   && ::protozero::internal::gen_helpers::EqualsField(is_hidden_, other.is_hidden_);
+}
 
-  static_assert(sizeof(ChunkHeader::Packets) == 2, "ChunkHeader::Packets size");
-  static_assert(alignof(ChunkHeader) == kChunkAlignment,
-                "ChunkHeader alignment");
+bool ChromeRendererSchedulerState::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  // In theory std::atomic does not guarantee that the underlying type
-  // consists only of the actual atomic word. Theoretically it could have
-  // locks or other state. In practice most implementations just implement
-  // them without extra state. The code below overlays the atomic into the
-  // SMB, hence relies on this implementation detail. This should be fine
-  // pragmatically (Chrome's base makes the same assumption), but let's have a
-  // check for this.
-  static_assert(sizeof(std::atomic<uint32_t>) == sizeof(uint32_t) &&
-                    sizeof(std::atomic<uint16_t>) == sizeof(uint16_t),
-                "Incompatible STL <atomic> implementation");
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* rail_mode */:
+        field.get(&rail_mode_);
+        break;
+      case 2 /* is_backgrounded */:
+        field.get(&is_backgrounded_);
+        break;
+      case 3 /* is_hidden */:
+        field.get(&is_hidden_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-  // Chec that the kAllChunks(Complete,Free) are consistent with the
-  // ChunkState enum values.
+std::string ChromeRendererSchedulerState::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  // These must be zero because rely on zero-initialized memory being
-  // interpreted as "free".
-  static_assert(kChunkFree == 0 && kAllChunksFree == 0,
-                "kChunkFree/kAllChunksFree and must be 0");
+std::vector<uint8_t> ChromeRendererSchedulerState::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  static_assert((kAllChunksComplete & kChunkMask) == kChunkComplete,
-                "kAllChunksComplete out of sync with kChunkComplete");
+void ChromeRendererSchedulerState::Serialize(::protozero::Message* msg) const {
+  // Field 1: rail_mode
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, rail_mode_, msg);
+  }
 
-  // Check the consistency of the kMax... constants.
-  static_assert(sizeof(ChunkHeader::writer_id) == sizeof(WriterID),
-                "WriterID size");
-  ChunkHeader chunk_header{};
-  chunk_header.chunk_id.store(static_cast<uint32_t>(-1));
-  PERFETTO_CHECK(chunk_header.chunk_id.load() == kMaxChunkID);
+  // Field 2: is_backgrounded
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, is_backgrounded_, msg);
+  }
 
-  chunk_header.writer_id.store(static_cast<uint16_t>(-1));
-  PERFETTO_CHECK(kMaxWriterID <= chunk_header.writer_id.load());
+  // Field 3: is_hidden
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, is_hidden_, msg);
+  }
 
-  PERFETTO_CHECK(page_size >= kMinPageSize);
-  PERFETTO_CHECK(page_size <= kMaxPageSize);
-  PERFETTO_CHECK(page_size % kMinPageSize == 0);
-  PERFETTO_CHECK(reinterpret_cast<uintptr_t>(start) % kMinPageSize == 0);
-  PERFETTO_CHECK(size % page_size == 0);
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
-SharedMemoryABI::Chunk SharedMemoryABI::GetChunkUnchecked(size_t page_idx,
-                                                          uint32_t page_layout,
-                                                          size_t chunk_idx) {
-  const size_t num_chunks = GetNumChunksForLayout(page_layout);
-  PERFETTO_DCHECK(chunk_idx < num_chunks);
-  // Compute the chunk virtual address and write it into |chunk|.
-  const uint16_t chunk_size = GetChunkSizeForLayout(page_layout);
-  size_t chunk_offset_in_page = sizeof(PageHeader) + chunk_idx * chunk_size;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_thread_descriptor.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_thread_descriptor.gen.h"
 
-  Chunk chunk(page_start(page_idx) + chunk_offset_in_page, chunk_size,
-              static_cast<uint8_t>(chunk_idx));
-  PERFETTO_DCHECK(chunk.end() <= end());
-  return chunk;
-}
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-SharedMemoryABI::Chunk SharedMemoryABI::TryAcquireChunk(
-    size_t page_idx,
-    size_t chunk_idx,
-    ChunkState desired_chunk_state,
-    const ChunkHeader* header) {
-  PERFETTO_DCHECK(desired_chunk_state == kChunkBeingRead ||
-                  desired_chunk_state == kChunkBeingWritten);
-  PageHeader* phdr = page_header(page_idx);
-  for (int attempt = 0; attempt < kRetryAttempts; attempt++) {
-    uint32_t layout = phdr->layout.load(std::memory_order_acquire);
-    const size_t num_chunks = GetNumChunksForLayout(layout);
+ChromeThreadDescriptor::ChromeThreadDescriptor() = default;
+ChromeThreadDescriptor::~ChromeThreadDescriptor() = default;
+ChromeThreadDescriptor::ChromeThreadDescriptor(const ChromeThreadDescriptor&) = default;
+ChromeThreadDescriptor& ChromeThreadDescriptor::operator=(const ChromeThreadDescriptor&) = default;
+ChromeThreadDescriptor::ChromeThreadDescriptor(ChromeThreadDescriptor&&) noexcept = default;
+ChromeThreadDescriptor& ChromeThreadDescriptor::operator=(ChromeThreadDescriptor&&) = default;
 
-    // The page layout has changed (or the page is free).
-    if (chunk_idx >= num_chunks)
-      return Chunk();
+bool ChromeThreadDescriptor::operator==(const ChromeThreadDescriptor& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(thread_type_, other.thread_type_)
+   && ::protozero::internal::gen_helpers::EqualsField(legacy_sort_index_, other.legacy_sort_index_)
+   && ::protozero::internal::gen_helpers::EqualsField(is_sandboxed_tid_, other.is_sandboxed_tid_);
+}
 
-    // Verify that the chunk is still in a state that allows the transition to
-    // |desired_chunk_state|. The only allowed transitions are:
-    // 1. kChunkFree -> kChunkBeingWritten (Producer).
-    // 2. kChunkComplete -> kChunkBeingRead (Service).
-    ChunkState expected_chunk_state =
-        desired_chunk_state == kChunkBeingWritten ? kChunkFree : kChunkComplete;
-    auto cur_chunk_state = (layout >> (chunk_idx * kChunkShift)) & kChunkMask;
-    if (cur_chunk_state != expected_chunk_state)
-      return Chunk();
+bool ChromeThreadDescriptor::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-    uint32_t next_layout = layout;
-    next_layout &= ~(kChunkMask << (chunk_idx * kChunkShift));
-    next_layout |= (desired_chunk_state << (chunk_idx * kChunkShift));
-    if (phdr->layout.compare_exchange_strong(layout, next_layout,
-                                             std::memory_order_acq_rel)) {
-      // Compute the chunk virtual address and write it into |chunk|.
-      Chunk chunk = GetChunkUnchecked(page_idx, layout, chunk_idx);
-      if (desired_chunk_state == kChunkBeingWritten) {
-        PERFETTO_DCHECK(header);
-        ChunkHeader* new_header = chunk.header();
-        new_header->writer_id.store(header->writer_id,
-                                    std::memory_order_relaxed);
-        new_header->chunk_id.store(header->chunk_id, std::memory_order_relaxed);
-        new_header->packets.store(header->packets, std::memory_order_release);
-      }
-      return chunk;
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* thread_type */:
+        field.get(&thread_type_);
+        break;
+      case 2 /* legacy_sort_index */:
+        field.get(&legacy_sort_index_);
+        break;
+      case 3 /* is_sandboxed_tid */:
+        field.get(&is_sandboxed_tid_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
     }
-    WaitBeforeNextAttempt(attempt);
   }
-  return Chunk();  // All our attempts failed.
+  return !packed_error && !dec.bytes_left();
 }
 
-bool SharedMemoryABI::TryPartitionPage(size_t page_idx, PageLayout layout) {
-  PERFETTO_DCHECK(layout >= kPageDiv1 && layout <= kPageDiv14);
-  uint32_t expected_layout = 0;  // Free page.
-  uint32_t next_layout = (layout << kLayoutShift) & kLayoutMask;
-  PageHeader* phdr = page_header(page_idx);
-  if (!phdr->layout.compare_exchange_strong(expected_layout, next_layout,
-                                            std::memory_order_acq_rel)) {
-    return false;
-  }
-  return true;
+std::string ChromeThreadDescriptor::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
 }
 
-uint32_t SharedMemoryABI::GetFreeChunks(size_t page_idx) {
-  uint32_t layout =
-      page_header(page_idx)->layout.load(std::memory_order_relaxed);
-  const uint32_t num_chunks = GetNumChunksForLayout(layout);
-  uint32_t res = 0;
-  for (uint32_t i = 0; i < num_chunks; i++) {
-    res |= ((layout & kChunkMask) == kChunkFree) ? (1 << i) : 0;
-    layout >>= kChunkShift;
-  }
-  return res;
+std::vector<uint8_t> ChromeThreadDescriptor::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
 }
 
-size_t SharedMemoryABI::ReleaseChunk(Chunk chunk,
-                                     ChunkState desired_chunk_state) {
-  PERFETTO_DCHECK(desired_chunk_state == kChunkComplete ||
-                  desired_chunk_state == kChunkFree);
+void ChromeThreadDescriptor::Serialize(::protozero::Message* msg) const {
+  // Field 1: thread_type
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, thread_type_, msg);
+  }
 
-  size_t page_idx;
-  size_t chunk_idx;
-  std::tie(page_idx, chunk_idx) = GetPageAndChunkIndex(chunk);
+  // Field 2: legacy_sort_index
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, legacy_sort_index_, msg);
+  }
 
-  // Reset header fields, so that the service can identify when the chunk's
-  // header has been initialized by the producer.
-  if (desired_chunk_state == kChunkFree)
-    ClearChunkHeader(chunk.header());
+  // Field 3: is_sandboxed_tid
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, is_sandboxed_tid_, msg);
+  }
 
-  for (int attempt = 0; attempt < kRetryAttempts; attempt++) {
-    PageHeader* phdr = page_header(page_idx);
-    uint32_t layout = phdr->layout.load(std::memory_order_relaxed);
-    const size_t page_chunk_size = GetChunkSizeForLayout(layout);
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-    // TODO(primiano): this should not be a CHECK, because a malicious producer
-    // could crash us by putting the chunk in an invalid state. This should
-    // gracefully fail. Keep a CHECK until then.
-    PERFETTO_CHECK(chunk.size() == page_chunk_size);
-    const uint32_t chunk_state =
-        ((layout >> (chunk_idx * kChunkShift)) & kChunkMask);
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_user_event.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_user_event.gen.h"
 
-    // Verify that the chunk is still in a state that allows the transition to
-    // |desired_chunk_state|. The only allowed transitions are:
-    // 1. kChunkBeingWritten -> kChunkComplete (Producer).
-    // 2. kChunkBeingRead -> kChunkFree (Service).
-    ChunkState expected_chunk_state;
-    if (desired_chunk_state == kChunkComplete) {
-      expected_chunk_state = kChunkBeingWritten;
-    } else {
-      expected_chunk_state = kChunkBeingRead;
-    }
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-    // TODO(primiano): should not be a CHECK (same rationale of comment above).
-    PERFETTO_CHECK(chunk_state == expected_chunk_state);
-    uint32_t next_layout = layout;
-    next_layout &= ~(kChunkMask << (chunk_idx * kChunkShift));
-    next_layout |= (desired_chunk_state << (chunk_idx * kChunkShift));
+ChromeUserEvent::ChromeUserEvent() = default;
+ChromeUserEvent::~ChromeUserEvent() = default;
+ChromeUserEvent::ChromeUserEvent(const ChromeUserEvent&) = default;
+ChromeUserEvent& ChromeUserEvent::operator=(const ChromeUserEvent&) = default;
+ChromeUserEvent::ChromeUserEvent(ChromeUserEvent&&) noexcept = default;
+ChromeUserEvent& ChromeUserEvent::operator=(ChromeUserEvent&&) = default;
 
-    // If we are freeing a chunk and all the other chunks in the page are free
-    // we should de-partition the page and mark it as clear.
-    if ((next_layout & kAllChunksMask) == kAllChunksFree)
-      next_layout = 0;
+bool ChromeUserEvent::operator==(const ChromeUserEvent& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(action_, other.action_)
+   && ::protozero::internal::gen_helpers::EqualsField(action_hash_, other.action_hash_);
+}
 
-    if (phdr->layout.compare_exchange_strong(layout, next_layout,
-                                             std::memory_order_acq_rel)) {
-      return page_idx;
+bool ChromeUserEvent::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* action */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &action_);
+        break;
+      case 2 /* action_hash */:
+        field.get(&action_hash_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
     }
-    WaitBeforeNextAttempt(attempt);
   }
-  // Too much contention on this page. Give up. This page will be left pending
-  // forever but there isn't much more we can do at this point.
-  PERFETTO_DFATAL("Too much contention on page.");
-  return kInvalidPageIdx;
+  return !packed_error && !dec.bytes_left();
 }
 
-SharedMemoryABI::Chunk::Chunk() = default;
-
-SharedMemoryABI::Chunk::Chunk(uint8_t* begin, uint16_t size, uint8_t chunk_idx)
-    : begin_(begin), size_(size), chunk_idx_(chunk_idx) {
-  PERFETTO_CHECK(reinterpret_cast<uintptr_t>(begin) % kChunkAlignment == 0);
-  PERFETTO_CHECK(size > 0);
+std::string ChromeUserEvent::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
 }
 
-SharedMemoryABI::Chunk::Chunk(Chunk&& o) noexcept {
-  *this = std::move(o);
+std::vector<uint8_t> ChromeUserEvent::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
 }
 
-SharedMemoryABI::Chunk& SharedMemoryABI::Chunk::operator=(Chunk&& o) {
-  begin_ = o.begin_;
-  size_ = o.size_;
-  chunk_idx_ = o.chunk_idx_;
-  o.begin_ = nullptr;
-  o.size_ = 0;
-  o.chunk_idx_ = 0;
-  return *this;
-}
+void ChromeUserEvent::Serialize(::protozero::Message* msg) const {
+  // Field 1: action
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeString(1, action_, msg);
+  }
 
-std::pair<size_t, size_t> SharedMemoryABI::GetPageAndChunkIndex(
-    const Chunk& chunk) {
-  PERFETTO_DCHECK(chunk.is_valid());
-  PERFETTO_DCHECK(chunk.begin() >= start_);
-  PERFETTO_DCHECK(chunk.end() <= start_ + size_);
+  // Field 2: action_hash
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, action_hash_, msg);
+  }
 
-  // TODO(primiano): The divisions below could be avoided if we cached
-  // |page_shift_|.
-  const uintptr_t rel_addr = static_cast<uintptr_t>(chunk.begin() - start_);
-  const size_t page_idx = rel_addr / page_size_;
-  const size_t offset = rel_addr % page_size_;
-  PERFETTO_DCHECK(offset >= sizeof(PageHeader));
-  PERFETTO_DCHECK(offset % kChunkAlignment == 0);
-  PERFETTO_DCHECK((offset - sizeof(PageHeader)) % chunk.size() == 0);
-  const size_t chunk_idx = (offset - sizeof(PageHeader)) / chunk.size();
-  PERFETTO_DCHECK(chunk_idx < kMaxChunksPerPage);
-  PERFETTO_DCHECK(chunk_idx < GetNumChunksForLayout(GetPageLayout(page_idx)));
-  return std::make_pair(page_idx, chunk_idx);
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
 }  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/core/shared_memory_arbiter_impl.cc
-// gen_amalgamated begin header: src/tracing/core/shared_memory_arbiter_impl.h
-// gen_amalgamated begin header: include/perfetto/ext/tracing/core/shared_memory_arbiter.h
-// gen_amalgamated begin header: include/perfetto/ext/tracing/core/tracing_service.h
-// gen_amalgamated begin header: include/perfetto/ext/tracing/core/shared_memory.h
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_SHARED_MEMORY_H_
-#define INCLUDE_PERFETTO_EXT_TRACING_CORE_SHARED_MEMORY_H_
-
-#include <stddef.h>
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_window_handle_event_info.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_window_handle_event_info.gen.h"
 
-#include <memory>
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-// gen_amalgamated expanded: #include "perfetto/base/platform_handle.h"
+ChromeWindowHandleEventInfo::ChromeWindowHandleEventInfo() = default;
+ChromeWindowHandleEventInfo::~ChromeWindowHandleEventInfo() = default;
+ChromeWindowHandleEventInfo::ChromeWindowHandleEventInfo(const ChromeWindowHandleEventInfo&) = default;
+ChromeWindowHandleEventInfo& ChromeWindowHandleEventInfo::operator=(const ChromeWindowHandleEventInfo&) = default;
+ChromeWindowHandleEventInfo::ChromeWindowHandleEventInfo(ChromeWindowHandleEventInfo&&) noexcept = default;
+ChromeWindowHandleEventInfo& ChromeWindowHandleEventInfo::operator=(ChromeWindowHandleEventInfo&&) = default;
 
-namespace perfetto {
+bool ChromeWindowHandleEventInfo::operator==(const ChromeWindowHandleEventInfo& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(dpi_, other.dpi_)
+   && ::protozero::internal::gen_helpers::EqualsField(message_id_, other.message_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(hwnd_ptr_, other.hwnd_ptr_);
+}
 
-// An abstract interface that models the shared memory region shared between
-// Service and Producer. The concrete implementation of this is up to the
-// transport layer. This can be as simple as a malloc()-ed buffer, if both
-// Producer and Service are hosted in the same process, or some posix shared
-// memory for the out-of-process case (see src/unix_rpc).
-// Both this class and the Factory are subclassed by the transport layer, which
-// will attach platform specific fields to it (e.g., a unix file descriptor).
-class PERFETTO_EXPORT_COMPONENT SharedMemory {
- public:
-  class PERFETTO_EXPORT_COMPONENT Factory {
-   public:
-    virtual ~Factory();
-    virtual std::unique_ptr<SharedMemory> CreateSharedMemory(size_t) = 0;
-  };
+bool ChromeWindowHandleEventInfo::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  // The transport layer is expected to tear down the resource associated to
-  // this object region when destroyed.
-  virtual ~SharedMemory();
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* dpi */:
+        field.get(&dpi_);
+        break;
+      case 2 /* message_id */:
+        field.get(&message_id_);
+        break;
+      case 3 /* hwnd_ptr */:
+        field.get(&hwnd_ptr_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-  virtual void* start() const = 0;
-  virtual size_t size() const = 0;
-};
+std::string ChromeWindowHandleEventInfo::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-}  // namespace perfetto
+std::vector<uint8_t> ChromeWindowHandleEventInfo::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_SHARED_MEMORY_H_
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+void ChromeWindowHandleEventInfo::Serialize(::protozero::Message* msg) const {
+  // Field 1: dpi
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, dpi_, msg);
+  }
 
-#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACING_SERVICE_H_
-#define INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACING_SERVICE_H_
+  // Field 2: message_id
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, message_id_, msg);
+  }
 
-#include <stdint.h>
+  // Field 3: hwnd_ptr
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeFixed(3, hwnd_ptr_, msg);
+  }
 
-#include <functional>
-#include <memory>
-#include <vector>
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/sys_types.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/buffer_exhausted_policy.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/counter_descriptor.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/counter_descriptor.gen.h"
 
 namespace perfetto {
+namespace protos {
+namespace gen {
 
-namespace base {
-class TaskRunner;
-}  // namespace base
+CounterDescriptor::CounterDescriptor() = default;
+CounterDescriptor::~CounterDescriptor() = default;
+CounterDescriptor::CounterDescriptor(const CounterDescriptor&) = default;
+CounterDescriptor& CounterDescriptor::operator=(const CounterDescriptor&) = default;
+CounterDescriptor::CounterDescriptor(CounterDescriptor&&) noexcept = default;
+CounterDescriptor& CounterDescriptor::operator=(CounterDescriptor&&) = default;
 
-class Consumer;
-class Producer;
-class SharedMemoryArbiter;
-class TraceWriter;
+bool CounterDescriptor::operator==(const CounterDescriptor& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(type_, other.type_)
+   && ::protozero::internal::gen_helpers::EqualsField(categories_, other.categories_)
+   && ::protozero::internal::gen_helpers::EqualsField(unit_, other.unit_)
+   && ::protozero::internal::gen_helpers::EqualsField(unit_name_, other.unit_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(unit_multiplier_, other.unit_multiplier_)
+   && ::protozero::internal::gen_helpers::EqualsField(is_incremental_, other.is_incremental_)
+   && ::protozero::internal::gen_helpers::EqualsField(y_axis_share_key_, other.y_axis_share_key_);
+}
 
-// Exposed for testing.
-std::string GetBugreportPath();
+bool CounterDescriptor::ParseFromArray(const void* raw, size_t size) {
+  categories_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-// TODO: for the moment this assumes that all the calls happen on the same
-// thread/sequence. Not sure this will be the case long term in Chrome.
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* type */:
+        field.get(&type_);
+        break;
+      case 2 /* categories */:
+        categories_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &categories_.back());
+        break;
+      case 3 /* unit */:
+        field.get(&unit_);
+        break;
+      case 6 /* unit_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &unit_name_);
+        break;
+      case 4 /* unit_multiplier */:
+        field.get(&unit_multiplier_);
+        break;
+      case 5 /* is_incremental */:
+        field.get(&is_incremental_);
+        break;
+      case 7 /* y_axis_share_key */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &y_axis_share_key_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-// The API for the Producer port of the Service.
-// Subclassed by:
-// 1. The tracing_service_impl.cc business logic when returning it in response
-//    to the ConnectProducer() method.
-// 2. The transport layer (e.g., src/ipc) when the producer and
-//    the service don't talk locally but via some IPC mechanism.
-class PERFETTO_EXPORT_COMPONENT ProducerEndpoint {
- public:
-  virtual ~ProducerEndpoint();
+std::string CounterDescriptor::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  // Disconnects the endpoint from the service, while keeping the shared memory
-  // valid. After calling this, the endpoint will no longer call any methods
-  // on the Producer.
-  virtual void Disconnect() = 0;
+std::vector<uint8_t> CounterDescriptor::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  // Called by the Producer to (un)register data sources. Data sources are
-  // identified by their name (i.e. DataSourceDescriptor.name)
-  virtual void RegisterDataSource(const DataSourceDescriptor&) = 0;
-  virtual void UpdateDataSource(const DataSourceDescriptor&) = 0;
-  virtual void UnregisterDataSource(const std::string& name) = 0;
+void CounterDescriptor::Serialize(::protozero::Message* msg) const {
+  // Field 1: type
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, type_, msg);
+  }
 
-  // Associate the trace writer with the given |writer_id| with
-  // |target_buffer|. The service may use this information to retrieve and
-  // copy uncommitted chunks written by the trace writer into its associated
-  // buffer, e.g. when a producer process crashes or when a flush is
-  // necessary.
-  virtual void RegisterTraceWriter(uint32_t writer_id,
-                                   uint32_t target_buffer) = 0;
+  // Field 2: categories
+  for (auto& it : categories_) {
+    ::protozero::internal::gen_helpers::SerializeString(2, it, msg);
+  }
 
-  // Remove the association of the trace writer previously created via
-  // RegisterTraceWriter.
-  virtual void UnregisterTraceWriter(uint32_t writer_id) = 0;
+  // Field 3: unit
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, unit_, msg);
+  }
 
-  // Called by the Producer to signal that some pages in the shared memory
-  // buffer (shared between Service and Producer) have changed.
-  // When the Producer and the Service are hosted in the same process and
-  // hence potentially live on the same task runner, This method must call
-  // TracingServiceImpl's CommitData synchronously, without any PostTask()s,
-  // if on the same thread. This is to avoid a deadlock where the Producer
-  // exhausts its SMB and stalls waiting for the service to catch up with
-  // reads, but the Service never gets to that because it lives on the same
-  // thread.
-  using CommitDataCallback = std::function<void()>;
-  virtual void CommitData(const CommitDataRequest&,
-                          CommitDataCallback callback = {}) = 0;
+  // Field 6: unit_name
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeString(6, unit_name_, msg);
+  }
 
-  virtual SharedMemory* shared_memory() const = 0;
+  // Field 4: unit_multiplier
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, unit_multiplier_, msg);
+  }
 
-  // Size of shared memory buffer pages. It's always a multiple of 4K.
-  // See shared_memory_abi.h
-  virtual size_t shared_buffer_page_size_kb() const = 0;
+  // Field 5: is_incremental
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, is_incremental_, msg);
+  }
 
-  // Creates a trace writer, which allows to create events, handling the
-  // underying shared memory buffer and signalling to the Service. This method
-  // is thread-safe but the returned object is not. A TraceWriter should be
-  // used only from a single thread, or the caller has to handle sequencing
-  // via a mutex or equivalent. This method can only be called if
-  // TracingService::ConnectProducer was called with |in_process=true|.
-  // Args:
-  // |target_buffer| is the target buffer ID where the data produced by the
-  // writer should be stored by the tracing service. This value is passed
-  // upon creation of the data source (StartDataSource()) in the
-  // DataSourceConfig.target_buffer().
-  virtual std::unique_ptr<TraceWriter> CreateTraceWriter(
-      BufferID target_buffer,
-      BufferExhaustedPolicy buffer_exhausted_policy =
-          BufferExhaustedPolicy::kDefault) = 0;
+  // Field 7: y_axis_share_key
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeString(7, y_axis_share_key_, msg);
+  }
 
-  // TODO(eseckler): Also expose CreateStartupTraceWriter() ?
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  // In some cases you can access the producer's SharedMemoryArbiter (for
-  // example if TracingService::ConnectProducer is called with
-  // |in_process=true|). The SharedMemoryArbiter can be used to create
-  // TraceWriters which is able to directly commit chunks. For the
-  // |in_process=true| case this can be done without going through an IPC layer.
-  virtual SharedMemoryArbiter* MaybeSharedMemoryArbiter() = 0;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/debug_annotation.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/debug_annotation.gen.h"
 
-  // Whether the service accepted a shared memory buffer provided by the
-  // producer.
-  virtual bool IsShmemProvidedByProducer() const = 0;
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-  // Called in response to a Producer::Flush(request_id) call after all data
-  // for the flush request has been committed.
-  virtual void NotifyFlushComplete(FlushRequestID) = 0;
+DebugAnnotationValueTypeName::DebugAnnotationValueTypeName() = default;
+DebugAnnotationValueTypeName::~DebugAnnotationValueTypeName() = default;
+DebugAnnotationValueTypeName::DebugAnnotationValueTypeName(const DebugAnnotationValueTypeName&) = default;
+DebugAnnotationValueTypeName& DebugAnnotationValueTypeName::operator=(const DebugAnnotationValueTypeName&) = default;
+DebugAnnotationValueTypeName::DebugAnnotationValueTypeName(DebugAnnotationValueTypeName&&) noexcept = default;
+DebugAnnotationValueTypeName& DebugAnnotationValueTypeName::operator=(DebugAnnotationValueTypeName&&) = default;
 
-  // Called in response to one or more Producer::StartDataSource(),
-  // if the data source registered setting the flag
-  // DataSourceDescriptor.will_notify_on_start.
-  virtual void NotifyDataSourceStarted(DataSourceInstanceID) = 0;
+bool DebugAnnotationValueTypeName::operator==(const DebugAnnotationValueTypeName& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(iid_, other.iid_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_);
+}
 
-  // Called in response to one or more Producer::StopDataSource(),
-  // if the data source registered setting the flag
-  // DataSourceDescriptor.will_notify_on_stop.
-  virtual void NotifyDataSourceStopped(DataSourceInstanceID) = 0;
+bool DebugAnnotationValueTypeName::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  // This informs the service to activate any of these triggers if any tracing
-  // session was waiting for them.
-  virtual void ActivateTriggers(const std::vector<std::string>&) = 0;
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* iid */:
+        field.get(&iid_);
+        break;
+      case 2 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-  // Emits a synchronization barrier to linearize with the service. When
-  // |callback| is invoked, the caller has the guarantee that the service has
-  // seen and processed all the requests sent by this producer prior to the
-  // Sync() call. Used mainly in tests.
-  virtual void Sync(std::function<void()> callback) = 0;
-};  // class ProducerEndpoint.
+std::string DebugAnnotationValueTypeName::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-// The API for the Consumer port of the Service.
-// Subclassed by:
-// 1. The tracing_service_impl.cc business logic when returning it in response
-// to
-//    the ConnectConsumer() method.
-// 2. The transport layer (e.g., src/ipc) when the consumer and
-//    the service don't talk locally but via some IPC mechanism.
-class PERFETTO_EXPORT_COMPONENT ConsumerEndpoint {
- public:
-  virtual ~ConsumerEndpoint();
+std::vector<uint8_t> DebugAnnotationValueTypeName::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  // Enables tracing with the given TraceConfig. The ScopedFile argument is
-  // used only when TraceConfig.write_into_file == true.
-  // If TraceConfig.deferred_start == true data sources are configured via
-  // SetupDataSource() but are not started until StartTracing() is called.
-  // This is to support pre-initialization and fast triggering of traces.
-  // The ScopedFile argument is used only when TraceConfig.write_into_file
-  // == true.
-  virtual void EnableTracing(const TraceConfig&,
-                             base::ScopedFile = base::ScopedFile()) = 0;
+void DebugAnnotationValueTypeName::Serialize(::protozero::Message* msg) const {
+  // Field 1: iid
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, iid_, msg);
+  }
 
-  // Update the trace config of an existing tracing session; only a subset
-  // of options can be changed mid-session. Currently the only
-  // supported functionality is expanding the list of producer_name_filters()
-  // (or removing the filter entirely) for existing data sources.
-  virtual void ChangeTraceConfig(const TraceConfig&) = 0;
+  // Field 2: name
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeString(2, name_, msg);
+  }
 
-  // Starts all data sources configured in the trace config. This is used only
-  // after calling EnableTracing() with TraceConfig.deferred_start=true.
-  // It's a no-op if called after a regular EnableTracing(), without setting
-  // deferred_start.
-  virtual void StartTracing() = 0;
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  virtual void DisableTracing() = 0;
 
-  // Clones an existing tracing session and attaches to it. The session is
-  // cloned in read-only mode and can only be used to read a snapshot of an
-  // existing tracing session. Will invoke Consumer::OnSessionCloned().
-  // TODO(primiano): make pure virtual after various 3way patches.
-  virtual void CloneSession(TracingSessionID);
+DebugAnnotationName::DebugAnnotationName() = default;
+DebugAnnotationName::~DebugAnnotationName() = default;
+DebugAnnotationName::DebugAnnotationName(const DebugAnnotationName&) = default;
+DebugAnnotationName& DebugAnnotationName::operator=(const DebugAnnotationName&) = default;
+DebugAnnotationName::DebugAnnotationName(DebugAnnotationName&&) noexcept = default;
+DebugAnnotationName& DebugAnnotationName::operator=(DebugAnnotationName&&) = default;
 
-  // Requests all data sources to flush their data immediately and invokes the
-  // passed callback once all of them have acked the flush (in which case
-  // the callback argument |success| will be true) or |timeout_ms| are elapsed
-  // (in which case |success| will be false).
-  // If |timeout_ms| is 0 the TraceConfig's flush_timeout_ms is used, or,
-  // if that one is not set (or is set to 0), kDefaultFlushTimeoutMs (5s) is
-  // used.
-  using FlushCallback = std::function<void(bool /*success*/)>;
-  virtual void Flush(uint32_t timeout_ms, FlushCallback) = 0;
+bool DebugAnnotationName::operator==(const DebugAnnotationName& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(iid_, other.iid_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_);
+}
 
-  // Tracing data will be delivered invoking Consumer::OnTraceData().
-  virtual void ReadBuffers() = 0;
-
-  virtual void FreeBuffers() = 0;
-
-  // Will call OnDetach().
-  virtual void Detach(const std::string& key) = 0;
-
-  // Will call OnAttach().
-  virtual void Attach(const std::string& key) = 0;
-
-  // Will call OnTraceStats().
-  virtual void GetTraceStats() = 0;
+bool DebugAnnotationName::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  // Start or stop observing events of selected types. |events_mask| specifies
-  // the types of events to observe in a bitmask of ObservableEvents::Type.
-  // To disable observing, pass 0.
-  // Will call OnObservableEvents() repeatedly whenever an event of an enabled
-  // ObservableEventType occurs.
-  // TODO(eseckler): Extend this to support producers & data sources.
-  virtual void ObserveEvents(uint32_t events_mask) = 0;
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* iid */:
+        field.get(&iid_);
+        break;
+      case 2 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-  // Used to obtain the list of connected data sources and other info about
-  // the tracing service.
-  using QueryServiceStateCallback =
-      std::function<void(bool success, const TracingServiceState&)>;
-  virtual void QueryServiceState(QueryServiceStateCallback) = 0;
+std::string DebugAnnotationName::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  // Used for feature detection. Makes sense only when the consumer and the
-  // service talk over IPC and can be from different versions.
-  using QueryCapabilitiesCallback =
-      std::function<void(const TracingServiceCapabilities&)>;
-  virtual void QueryCapabilities(QueryCapabilitiesCallback) = 0;
+std::vector<uint8_t> DebugAnnotationName::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  // If any tracing session with TraceConfig.bugreport_score > 0 is running,
-  // this will pick the highest-score one, stop it and save it into a fixed
-  // path (See kBugreportTracePath).
-  // The callback is invoked when the file has been saved, in case of success,
-  // or whenever an error occurs.
-  // Args:
-  // - success: if true, an eligible trace was found and saved into file.
-  //            If false, either there was no eligible trace running or
-  //            something else failed (See |msg|).
-  // - msg: human readable diagnostic messages to debug failures.
-  using SaveTraceForBugreportCallback =
-      std::function<void(bool /*success*/, const std::string& /*msg*/)>;
-  virtual void SaveTraceForBugreport(SaveTraceForBugreportCallback) = 0;
-};  // class ConsumerEndpoint.
+void DebugAnnotationName::Serialize(::protozero::Message* msg) const {
+  // Field 1: iid
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, iid_, msg);
+  }
 
-// The public API of the tracing Service business logic.
-//
-// Exposed to:
-// 1. The transport layer (e.g., src/unix_rpc/unix_service_host.cc),
-//    which forwards commands received from a remote producer or consumer to
-//    the actual service implementation.
-// 2. Tests.
-//
-// Subclassed by:
-//   The service business logic in src/core/tracing_service_impl.cc.
-class PERFETTO_EXPORT_COMPONENT TracingService {
- public:
-  using ProducerEndpoint = perfetto::ProducerEndpoint;
-  using ConsumerEndpoint = perfetto::ConsumerEndpoint;
+  // Field 2: name
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeString(2, name_, msg);
+  }
 
-  // Default sizes used by the service implementation and client library.
-  static constexpr size_t kDefaultShmPageSize = 4096ul;
-  static constexpr size_t kDefaultShmSize = 256 * 1024ul;
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  enum class ProducerSMBScrapingMode {
-    // Use service's default setting for SMB scraping. Currently, the default
-    // mode is to disable SMB scraping, but this may change in the future.
-    kDefault,
 
-    // Enable scraping of uncommitted chunks in producers' shared memory
-    // buffers.
-    kEnabled,
+DebugAnnotation::DebugAnnotation() = default;
+DebugAnnotation::~DebugAnnotation() = default;
+DebugAnnotation::DebugAnnotation(const DebugAnnotation&) = default;
+DebugAnnotation& DebugAnnotation::operator=(const DebugAnnotation&) = default;
+DebugAnnotation::DebugAnnotation(DebugAnnotation&&) noexcept = default;
+DebugAnnotation& DebugAnnotation::operator=(DebugAnnotation&&) = default;
 
-    // Disable scraping of uncommitted chunks in producers' shared memory
-    // buffers.
-    kDisabled
-  };
+bool DebugAnnotation::operator==(const DebugAnnotation& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_iid_, other.name_iid_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(bool_value_, other.bool_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(uint_value_, other.uint_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(int_value_, other.int_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(double_value_, other.double_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(pointer_value_, other.pointer_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(nested_value_, other.nested_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(legacy_json_value_, other.legacy_json_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(string_value_, other.string_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(string_value_iid_, other.string_value_iid_)
+   && ::protozero::internal::gen_helpers::EqualsField(proto_type_name_, other.proto_type_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(proto_type_name_iid_, other.proto_type_name_iid_)
+   && ::protozero::internal::gen_helpers::EqualsField(proto_value_, other.proto_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(dict_entries_, other.dict_entries_)
+   && ::protozero::internal::gen_helpers::EqualsField(array_values_, other.array_values_);
+}
 
-  // Implemented in src/core/tracing_service_impl.cc .
-  static std::unique_ptr<TracingService> CreateInstance(
-      std::unique_ptr<SharedMemory::Factory>,
-      base::TaskRunner*);
+int DebugAnnotation::dict_entries_size() const { return static_cast<int>(dict_entries_.size()); }
+void DebugAnnotation::clear_dict_entries() { dict_entries_.clear(); }
+DebugAnnotation* DebugAnnotation::add_dict_entries() { dict_entries_.emplace_back(); return &dict_entries_.back(); }
+int DebugAnnotation::array_values_size() const { return static_cast<int>(array_values_.size()); }
+void DebugAnnotation::clear_array_values() { array_values_.clear(); }
+DebugAnnotation* DebugAnnotation::add_array_values() { array_values_.emplace_back(); return &array_values_.back(); }
+bool DebugAnnotation::ParseFromArray(const void* raw, size_t size) {
+  dict_entries_.clear();
+  array_values_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  virtual ~TracingService();
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* name_iid */:
+        field.get(&name_iid_);
+        break;
+      case 10 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+        break;
+      case 2 /* bool_value */:
+        field.get(&bool_value_);
+        break;
+      case 3 /* uint_value */:
+        field.get(&uint_value_);
+        break;
+      case 4 /* int_value */:
+        field.get(&int_value_);
+        break;
+      case 5 /* double_value */:
+        field.get(&double_value_);
+        break;
+      case 7 /* pointer_value */:
+        field.get(&pointer_value_);
+        break;
+      case 8 /* nested_value */:
+        (*nested_value_).ParseFromArray(field.data(), field.size());
+        break;
+      case 9 /* legacy_json_value */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &legacy_json_value_);
+        break;
+      case 6 /* string_value */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &string_value_);
+        break;
+      case 17 /* string_value_iid */:
+        field.get(&string_value_iid_);
+        break;
+      case 16 /* proto_type_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &proto_type_name_);
+        break;
+      case 13 /* proto_type_name_iid */:
+        field.get(&proto_type_name_iid_);
+        break;
+      case 14 /* proto_value */:
+        field.get(&proto_value_);
+        break;
+      case 11 /* dict_entries */:
+        dict_entries_.emplace_back();
+        dict_entries_.back().ParseFromArray(field.data(), field.size());
+        break;
+      case 12 /* array_values */:
+        array_values_.emplace_back();
+        array_values_.back().ParseFromArray(field.data(), field.size());
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-  // Connects a Producer instance and obtains a ProducerEndpoint, which is
-  // essentially a 1:1 channel between one Producer and the Service.
-  //
-  // The caller has to guarantee that the passed Producer will be alive as long
-  // as the returned ProducerEndpoint is alive. Both the passed Producer and the
-  // returned ProducerEndpoint must live on the same task runner of the service,
-  // specifically:
-  // 1) The Service will call Producer::* methods on the Service's task runner.
-  // 2) The Producer should call ProducerEndpoint::* methods only on the
-  //    service's task runner, except for ProducerEndpoint::CreateTraceWriter(),
-  //    which can be called on any thread. To disconnect just destroy the
-  //    returned ProducerEndpoint object. It is safe to destroy the Producer
-  //    once the Producer::OnDisconnect() has been invoked.
-  //
-  // |uid| is the trusted user id of the producer process, used by the consumers
-  // for validating the origin of trace data. |shared_memory_size_hint_bytes|
-  // and |shared_memory_page_size_hint_bytes| are optional hints on the size of
-  // the shared memory buffer and its pages. The service can ignore the hints
-  // (e.g., if the hints are unreasonably large or other sizes were configured
-  // in a tracing session's config). |in_process| enables the ProducerEndpoint
-  // to manage its own shared memory and enables use of
-  // |ProducerEndpoint::CreateTraceWriter|.
-  //
-  // The producer can optionally provide a non-null |shm|, which the service
-  // will adopt for the connection to the producer, provided it is correctly
-  // sized. In this case, |shared_memory_page_size_hint_bytes| indicates the
-  // page size used in this SMB. The producer can use this mechanism to record
-  // tracing data to an SMB even before the tracing session is started by the
-  // service. This is used in Chrome to implement startup tracing. If the buffer
-  // is incorrectly sized, the service will discard the SMB and allocate a new
-  // one, provided to the producer via ProducerEndpoint::shared_memory() after
-  // OnTracingSetup(). To verify that the service accepted the SMB, the producer
-  // may check via ProducerEndpoint::IsShmemProvidedByProducer(). If the service
-  // accepted the SMB, the producer can then commit any data that is already in
-  // the SMB after the tracing session was started by the service via
-  // Producer::StartDataSource(). The |shm| will also be rejected when
-  // connecting to a service that is too old (pre Android-11).
-  //
-  // Can return null in the unlikely event that service has too many producers
-  // connected.
-  virtual std::unique_ptr<ProducerEndpoint> ConnectProducer(
-      Producer*,
-      uid_t uid,
-      pid_t pid,
-      const std::string& name,
-      size_t shared_memory_size_hint_bytes = 0,
-      bool in_process = false,
-      ProducerSMBScrapingMode smb_scraping_mode =
-          ProducerSMBScrapingMode::kDefault,
-      size_t shared_memory_page_size_hint_bytes = 0,
-      std::unique_ptr<SharedMemory> shm = nullptr,
-      const std::string& sdk_version = {}) = 0;
+std::string DebugAnnotation::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  // Connects a Consumer instance and obtains a ConsumerEndpoint, which is
-  // essentially a 1:1 channel between one Consumer and the Service.
-  // The caller has to guarantee that the passed Consumer will be alive as long
-  // as the returned ConsumerEndpoint is alive.
-  // To disconnect just destroy the returned ConsumerEndpoint object. It is safe
-  // to destroy the Consumer once the Consumer::OnDisconnect() has been invoked.
-  virtual std::unique_ptr<ConsumerEndpoint> ConnectConsumer(Consumer*,
-                                                            uid_t) = 0;
+std::vector<uint8_t> DebugAnnotation::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  // Enable/disable scraping of chunks in the shared memory buffer. If enabled,
-  // the service will copy uncommitted but non-empty chunks from the SMB when
-  // flushing (e.g. to handle unresponsive producers or producers unable to
-  // flush their active chunks), on producer disconnect (e.g. to recover data
-  // from crashed producers), and after disabling a tracing session (e.g. to
-  // gather data from producers that didn't stop their data sources in time).
-  //
-  // This feature is currently used by Chrome.
-  virtual void SetSMBScrapingEnabled(bool enabled) = 0;
-};
+void DebugAnnotation::Serialize(::protozero::Message* msg) const {
+  // Field 1: name_iid
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, name_iid_, msg);
+  }
 
-}  // namespace perfetto
+  // Field 10: name
+  if (_has_field_[10]) {
+    ::protozero::internal::gen_helpers::SerializeString(10, name_, msg);
+  }
 
-#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACING_SERVICE_H_
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+  // Field 2: bool_value
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, bool_value_, msg);
+  }
 
-#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_SHARED_MEMORY_ARBITER_H_
-#define INCLUDE_PERFETTO_EXT_TRACING_CORE_SHARED_MEMORY_ARBITER_H_
+  // Field 3: uint_value
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, uint_value_, msg);
+  }
 
-#include <stddef.h>
+  // Field 4: int_value
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, int_value_, msg);
+  }
 
-#include <functional>
-#include <memory>
-#include <vector>
+  // Field 5: double_value
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeFixed(5, double_value_, msg);
+  }
 
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/buffer_exhausted_policy.h"
+  // Field 7: pointer_value
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(7, pointer_value_, msg);
+  }
 
-namespace perfetto {
+  // Field 8: nested_value
+  if (_has_field_[8]) {
+    (*nested_value_).Serialize(msg->BeginNestedMessage<::protozero::Message>(8));
+  }
 
-namespace base {
-class TaskRunner;
-}
+  // Field 9: legacy_json_value
+  if (_has_field_[9]) {
+    ::protozero::internal::gen_helpers::SerializeString(9, legacy_json_value_, msg);
+  }
 
-class SharedMemory;
-class TraceWriter;
+  // Field 6: string_value
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeString(6, string_value_, msg);
+  }
 
-// Used by the Producer-side of the transport layer to vend TraceWriters
-// from the SharedMemory it receives from the Service-side.
-class PERFETTO_EXPORT_COMPONENT SharedMemoryArbiter {
- public:
-  virtual ~SharedMemoryArbiter();
+  // Field 17: string_value_iid
+  if (_has_field_[17]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(17, string_value_iid_, msg);
+  }
 
-  // Creates a new TraceWriter and assigns it a new WriterID. The WriterID is
-  // written in each chunk header owned by a given TraceWriter and is used by
-  // the Service to reconstruct TracePackets written by the same TraceWriter.
-  // Returns null impl of TraceWriter if all WriterID slots are exhausted. The
-  // writer will commit to the provided |target_buffer|. If the arbiter was
-  // created via CreateUnbound() or CreateStartupTraceWriter() is later used,
-  // only BufferExhaustedPolicy::kDrop is supported.
-  virtual std::unique_ptr<TraceWriter> CreateTraceWriter(
-      BufferID target_buffer,
-      BufferExhaustedPolicy buffer_exhausted_policy =
-          BufferExhaustedPolicy::kDefault) = 0;
+  // Field 16: proto_type_name
+  if (_has_field_[16]) {
+    ::protozero::internal::gen_helpers::SerializeString(16, proto_type_name_, msg);
+  }
 
-  // Creates a TraceWriter that will commit to the target buffer with the given
-  // reservation ID (creating a new reservation for this ID if none exists yet).
-  // The buffer reservation should be bound to an actual BufferID via
-  // BindStartupTargetBuffer() once the actual BufferID is known. Calling this
-  // method may transition the arbiter into unbound state (see state diagram in
-  // SharedMemoryArbiterImpl's class comment) and requires that all (past and
-  // future) TraceWriters are created with BufferExhaustedPolicy::kDrop.
-  //
-  // While any unbound buffer reservation exists, all commits will be buffered
-  // until all reservations were bound. Thus, until all reservations are bound,
-  // the data written to the SMB will not be consumed by the service - the SMB
-  // size should be chosen with this in mind. Startup writers always use
-  // BufferExhaustedPolicy::kDrop, as we cannot feasibly stall while not
-  // flushing to the service.
-  //
-  // The |target_buffer_reservation_id| should be greater than 0 but can
-  // otherwise be freely chosen by the producer and is only used to translate
-  // packets into the actual buffer id once
-  // BindStartupTargetBuffer(reservation_id) is called. For example, Chrome uses
-  // startup tracing not only for the first, but also subsequent tracing
-  // sessions (to enable tracing in the browser process before it instructs the
-  // tracing service to start tracing asynchronously, minimizing trace data loss
-  // in the meantime), and increments the reservation ID between sessions.
-  // Similarly, if more than a single target buffer per session is required
-  // (e.g. for two different data sources), different reservation IDs should be
-  // chosen for different target buffers.
-  virtual std::unique_ptr<TraceWriter> CreateStartupTraceWriter(
-      uint16_t target_buffer_reservation_id) = 0;
+  // Field 13: proto_type_name_iid
+  if (_has_field_[13]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(13, proto_type_name_iid_, msg);
+  }
 
-  // Should only be called on unbound SharedMemoryArbiters. Binds the arbiter to
-  // the provided ProducerEndpoint and TaskRunner. Should be called only once
-  // and on the provided |TaskRunner|. Usually called by the producer (i.e., no
-  // specific data source) once it connects to the service. Both the endpoint
-  // and task runner should remain valid for the remainder of the arbiter's
-  // lifetime.
-  virtual void BindToProducerEndpoint(TracingService::ProducerEndpoint*,
-                                      base::TaskRunner*) = 0;
+  // Field 14: proto_value
+  if (_has_field_[14]) {
+    ::protozero::internal::gen_helpers::SerializeString(14, proto_value_, msg);
+  }
 
-  // Binds commits from TraceWriters created via CreateStartupTraceWriter() with
-  // the given |target_buffer_reservation_id| to |target_buffer_id|. May only be
-  // called once per |target_buffer_reservation_id|. Should be called on the
-  // arbiter's TaskRunner, and after BindToProducerEndpoint() was called.
-  // Usually, it is called by a specific data source, after it received its
-  // configuration (including the target buffer ID) from the service.
-  virtual void BindStartupTargetBuffer(uint16_t target_buffer_reservation_id,
-                                       BufferID target_buffer_id) = 0;
+  // Field 11: dict_entries
+  for (auto& it : dict_entries_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(11));
+  }
 
-  // Treat the reservation as resolved to an invalid buffer. Commits for this
-  // reservation will be flushed to the service ASAP. The service will free
-  // committed chunks but otherwise ignore them. The producer can call this
-  // method, for example, if connection to the tracing service failed or the
-  // session was stopped concurrently before the connection was established.
-  virtual void AbortStartupTracingForReservation(
-      uint16_t target_buffer_reservation_id) = 0;
+  // Field 12: array_values
+  for (auto& it : array_values_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(12));
+  }
 
-  // Notifies the service that all data for the given FlushRequestID has been
-  // committed in the shared memory buffer. Should only be called while bound.
-  virtual void NotifyFlushComplete(FlushRequestID) = 0;
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  // Sets the duration during which commits are batched. Args:
-  // |batch_commits_duration_ms|: The length of the period, during which commits
-  // by all trace writers are accumulated, before being sent to the service.
-  // When the period ends, all accumulated commits are flushed. On the first
-  // commit after the last flush, another delayed flush is scheduled to run in
-  // |batch_commits_duration_ms|. If an immediate flush occurs (via
-  // FlushPendingCommitDataRequests()) during a batching period, any
-  // accumulated commits up to that point will be sent to the service
-  // immediately. And when the batching period ends, the commits that occurred
-  // after the immediate flush will also be sent to the service.
-  //
-  // If the duration has already been set to a non-zero value before this method
-  // is called, and there is already a scheduled flush with the previously-set
-  // duration, the new duration will take effect after the scheduled flush
-  // occurs.
-  //
-  // If |batch_commits_duration_ms| is non-zero, batched data that hasn't been
-  // sent could be lost at the end of a tracing session. To avoid this,
-  // producers should make sure that FlushPendingCommitDataRequests is called
-  // after the last TraceWriter write and before the service has stopped
-  // listening for commits from the tracing session's data sources (i.e.
-  // data sources should stop asynchronously, see
-  // DataSourceDescriptor.will_notify_on_stop=true).
-  virtual void SetBatchCommitsDuration(uint32_t batch_commits_duration_ms) = 0;
 
-  // Called to enable direct producer-side patching of chunks that have not yet
-  // been committed to the service. The return value indicates whether direct
-  // patching was successfully enabled. It will be true if
-  // SharedMemoryArbiter::SetDirectSMBPatchingSupportedByService has been called
-  // and false otherwise.
-  virtual bool EnableDirectSMBPatching() = 0;
+DebugAnnotation_NestedValue::DebugAnnotation_NestedValue() = default;
+DebugAnnotation_NestedValue::~DebugAnnotation_NestedValue() = default;
+DebugAnnotation_NestedValue::DebugAnnotation_NestedValue(const DebugAnnotation_NestedValue&) = default;
+DebugAnnotation_NestedValue& DebugAnnotation_NestedValue::operator=(const DebugAnnotation_NestedValue&) = default;
+DebugAnnotation_NestedValue::DebugAnnotation_NestedValue(DebugAnnotation_NestedValue&&) noexcept = default;
+DebugAnnotation_NestedValue& DebugAnnotation_NestedValue::operator=(DebugAnnotation_NestedValue&&) = default;
 
-  // When the producer and service live in separate processes, this method
-  // should be called if the producer receives an
-  // InitializeConnectionResponse.direct_smb_patching_supported set to true by
-  // the service (see producer_port.proto) .
-  //
-  // In the in-process case, the service will always support direct SMB patching
-  // and this method should always be called.
-  virtual void SetDirectSMBPatchingSupportedByService() = 0;
+bool DebugAnnotation_NestedValue::operator==(const DebugAnnotation_NestedValue& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(nested_type_, other.nested_type_)
+   && ::protozero::internal::gen_helpers::EqualsField(dict_keys_, other.dict_keys_)
+   && ::protozero::internal::gen_helpers::EqualsField(dict_values_, other.dict_values_)
+   && ::protozero::internal::gen_helpers::EqualsField(array_values_, other.array_values_)
+   && ::protozero::internal::gen_helpers::EqualsField(int_value_, other.int_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(double_value_, other.double_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(bool_value_, other.bool_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(string_value_, other.string_value_);
+}
 
-  // Forces an immediate commit of the completed packets, without waiting for
-  // the next task or for a batching period to end. Should only be called while
-  // bound.
-  virtual void FlushPendingCommitDataRequests(
-      std::function<void()> callback = {}) = 0;
+int DebugAnnotation_NestedValue::dict_values_size() const { return static_cast<int>(dict_values_.size()); }
+void DebugAnnotation_NestedValue::clear_dict_values() { dict_values_.clear(); }
+DebugAnnotation_NestedValue* DebugAnnotation_NestedValue::add_dict_values() { dict_values_.emplace_back(); return &dict_values_.back(); }
+int DebugAnnotation_NestedValue::array_values_size() const { return static_cast<int>(array_values_.size()); }
+void DebugAnnotation_NestedValue::clear_array_values() { array_values_.clear(); }
+DebugAnnotation_NestedValue* DebugAnnotation_NestedValue::add_array_values() { array_values_.emplace_back(); return &array_values_.back(); }
+bool DebugAnnotation_NestedValue::ParseFromArray(const void* raw, size_t size) {
+  dict_keys_.clear();
+  dict_values_.clear();
+  array_values_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  // Attempts to shut down this arbiter. This function prevents new trace
-  // writers from being created for this this arbiter, but if there are any
-  // existing trace writers, the shutdown cannot proceed and this funtion
-  // returns false. The caller should not delete the arbiter before all of its
-  // associated trace writers have been destroyed and this function returns
-  // true.
-  virtual bool TryShutdown() = 0;
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* nested_type */:
+        field.get(&nested_type_);
+        break;
+      case 2 /* dict_keys */:
+        dict_keys_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &dict_keys_.back());
+        break;
+      case 3 /* dict_values */:
+        dict_values_.emplace_back();
+        dict_values_.back().ParseFromArray(field.data(), field.size());
+        break;
+      case 4 /* array_values */:
+        array_values_.emplace_back();
+        array_values_.back().ParseFromArray(field.data(), field.size());
+        break;
+      case 5 /* int_value */:
+        field.get(&int_value_);
+        break;
+      case 6 /* double_value */:
+        field.get(&double_value_);
+        break;
+      case 7 /* bool_value */:
+        field.get(&bool_value_);
+        break;
+      case 8 /* string_value */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &string_value_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-  // Create a bound arbiter instance. Args:
-  // |SharedMemory|: the shared memory buffer to use.
-  // |page_size|: a multiple of 4KB that defines the granularity of tracing
-  // pages. See tradeoff considerations in shared_memory_abi.h.
-  // |ProducerEndpoint|: The service's producer endpoint used e.g. to commit
-  // chunks and register trace writers.
-  // |TaskRunner|: Task runner for perfetto's main thread, which executes the
-  // OnPagesCompleteCallback and IPC calls to the |ProducerEndpoint|.
-  //
-  // Implemented in src/core/shared_memory_arbiter_impl.cc.
-  static std::unique_ptr<SharedMemoryArbiter> CreateInstance(
-      SharedMemory*,
-      size_t page_size,
-      TracingService::ProducerEndpoint*,
-      base::TaskRunner*);
+std::string DebugAnnotation_NestedValue::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  // Create an unbound arbiter instance, which should later be bound to a
-  // ProducerEndpoint and TaskRunner by calling BindToProducerEndpoint(). The
-  // returned arbiter will ONLY support trace writers with
-  // BufferExhaustedPolicy::kDrop.
-  //
-  // An unbound SharedMemoryArbiter can be used to write to a producer-created
-  // SharedMemory buffer before the producer connects to the tracing service.
-  // The producer can then pass this SMB to the service when it connects (see
-  // TracingService::ConnectProducer).
-  //
-  // To trace into the SMB before the service starts the tracing session, trace
-  // writers can be obtained via CreateStartupTraceWriter() and later associated
-  // with a target buffer via BindStartupTargetBuffer(), once the target buffer
-  // is known.
-  //
-  // Implemented in src/core/shared_memory_arbiter_impl.cc. See CreateInstance()
-  // for comments about the arguments.
-  static std::unique_ptr<SharedMemoryArbiter> CreateUnboundInstance(
-      SharedMemory*,
-      size_t page_size);
-};
+std::vector<uint8_t> DebugAnnotation_NestedValue::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void DebugAnnotation_NestedValue::Serialize(::protozero::Message* msg) const {
+  // Field 1: nested_type
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, nested_type_, msg);
+  }
+
+  // Field 2: dict_keys
+  for (auto& it : dict_keys_) {
+    ::protozero::internal::gen_helpers::SerializeString(2, it, msg);
+  }
+
+  // Field 3: dict_values
+  for (auto& it : dict_values_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(3));
+  }
+
+  // Field 4: array_values
+  for (auto& it : array_values_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(4));
+  }
+
+  // Field 5: int_value
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, int_value_, msg);
+  }
+
+  // Field 6: double_value
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeFixed(6, double_value_, msg);
+  }
+
+  // Field 7: bool_value
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(7, bool_value_, msg);
+  }
+
+  // Field 8: string_value
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeString(8, string_value_, msg);
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
 }  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/log_message.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/log_message.gen.h"
 
-#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_SHARED_MEMORY_ARBITER_H_
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-#ifndef SRC_TRACING_CORE_SHARED_MEMORY_ARBITER_IMPL_H_
-#define SRC_TRACING_CORE_SHARED_MEMORY_ARBITER_IMPL_H_
+LogMessageBody::LogMessageBody() = default;
+LogMessageBody::~LogMessageBody() = default;
+LogMessageBody::LogMessageBody(const LogMessageBody&) = default;
+LogMessageBody& LogMessageBody::operator=(const LogMessageBody&) = default;
+LogMessageBody::LogMessageBody(LogMessageBody&&) noexcept = default;
+LogMessageBody& LogMessageBody::operator=(LogMessageBody&&) = default;
 
-#include <stdint.h>
+bool LogMessageBody::operator==(const LogMessageBody& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(iid_, other.iid_)
+   && ::protozero::internal::gen_helpers::EqualsField(body_, other.body_);
+}
 
-#include <functional>
-#include <map>
-#include <memory>
-#include <mutex>
-#include <vector>
+bool LogMessageBody::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/weak_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_abi.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_arbiter.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
-// gen_amalgamated expanded: #include "src/tracing/core/id_allocator.h"
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* iid */:
+        field.get(&iid_);
+        break;
+      case 2 /* body */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &body_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
+
+std::string LogMessageBody::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> LogMessageBody::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void LogMessageBody::Serialize(::protozero::Message* msg) const {
+  // Field 1: iid
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, iid_, msg);
+  }
+
+  // Field 2: body
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeString(2, body_, msg);
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
+
+
+LogMessage::LogMessage() = default;
+LogMessage::~LogMessage() = default;
+LogMessage::LogMessage(const LogMessage&) = default;
+LogMessage& LogMessage::operator=(const LogMessage&) = default;
+LogMessage::LogMessage(LogMessage&&) noexcept = default;
+LogMessage& LogMessage::operator=(LogMessage&&) = default;
+
+bool LogMessage::operator==(const LogMessage& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(source_location_iid_, other.source_location_iid_)
+   && ::protozero::internal::gen_helpers::EqualsField(body_iid_, other.body_iid_)
+   && ::protozero::internal::gen_helpers::EqualsField(prio_, other.prio_);
+}
+
+bool LogMessage::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* source_location_iid */:
+        field.get(&source_location_iid_);
+        break;
+      case 2 /* body_iid */:
+        field.get(&body_iid_);
+        break;
+      case 3 /* prio */:
+        field.get(&prio_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
+
+std::string LogMessage::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> LogMessage::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void LogMessage::Serialize(::protozero::Message* msg) const {
+  // Field 1: source_location_iid
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, source_location_iid_, msg);
+  }
+
+  // Field 2: body_iid
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, body_iid_, msg);
+  }
+
+  // Field 3: prio
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, prio_, msg);
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
+
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/process_descriptor.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/process_descriptor.gen.h"
 
 namespace perfetto {
+namespace protos {
+namespace gen {
 
-class PatchList;
-class Patch;
-class TraceWriter;
-class TraceWriterImpl;
+ProcessDescriptor::ProcessDescriptor() = default;
+ProcessDescriptor::~ProcessDescriptor() = default;
+ProcessDescriptor::ProcessDescriptor(const ProcessDescriptor&) = default;
+ProcessDescriptor& ProcessDescriptor::operator=(const ProcessDescriptor&) = default;
+ProcessDescriptor::ProcessDescriptor(ProcessDescriptor&&) noexcept = default;
+ProcessDescriptor& ProcessDescriptor::operator=(ProcessDescriptor&&) = default;
 
-namespace base {
-class TaskRunner;
-}  // namespace base
+bool ProcessDescriptor::operator==(const ProcessDescriptor& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(pid_, other.pid_)
+   && ::protozero::internal::gen_helpers::EqualsField(cmdline_, other.cmdline_)
+   && ::protozero::internal::gen_helpers::EqualsField(process_name_, other.process_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(process_priority_, other.process_priority_)
+   && ::protozero::internal::gen_helpers::EqualsField(start_timestamp_ns_, other.start_timestamp_ns_)
+   && ::protozero::internal::gen_helpers::EqualsField(chrome_process_type_, other.chrome_process_type_)
+   && ::protozero::internal::gen_helpers::EqualsField(legacy_sort_index_, other.legacy_sort_index_)
+   && ::protozero::internal::gen_helpers::EqualsField(process_labels_, other.process_labels_);
+}
 
-// This class handles the shared memory buffer on the producer side. It is used
-// to obtain thread-local chunks and to partition pages from several threads.
-// There is one arbiter instance per Producer.
-// This class is thread-safe and uses locks to do so. Data sources are supposed
-// to interact with this sporadically, only when they run out of space on their
-// current thread-local chunk.
-//
-// The arbiter can become "unbound" as a consequence of:
-//  (a) being created without an endpoint
-//  (b) CreateStartupTraceWriter calls after creation (whether created with or
-//      without endpoint).
-//
-// Entering the unbound state is only supported if all trace writers are created
-// in kDrop mode. In the unbound state, the arbiter buffers commit messages
-// until all trace writers are bound to a target buffer.
-//
-// The following state transitions are possible:
-//
-//   CreateInstance()
-//    |
-//    |  CreateUnboundInstance()
-//    |    |
-//    |    |
-//    |    V
-//    |  [ !fully_bound_, !endpoint_, 0 unbound buffer reservations ]
-//    |      |     |
-//    |      |     | CreateStartupTraceWriter(buf)
-//    |      |     |  buffer reservations += buf
-//    |      |     |
-//    |      |     |             ----
-//    |      |     |            |    | CreateStartupTraceWriter(buf)
-//    |      |     |            |    |  buffer reservations += buf
-//    |      |     V            |    V
-//    |      |   [ !fully_bound_, !endpoint_, >=1 unbound buffer reservations ]
-//    |      |                                                |
-//    |      |                       BindToProducerEndpoint() |
-//    |      |                                                |
-//    |      | BindToProducerEndpoint()                       |
-//    |      |                                                V
-//    |      |   [ !fully_bound_, endpoint_, >=1 unbound buffer reservations ]
-//    |      |   A    |    A                               |     A
-//    |      |   |    |    |                               |     |
-//    |      |   |     ----                                |     |
-//    |      |   |    CreateStartupTraceWriter(buf)        |     |
-//    |      |   |     buffer reservations += buf          |     |
-//    |      |   |                                         |     |
-//    |      |   | CreateStartupTraceWriter(buf)           |     |
-//    |      |   |  where buf is not yet bound             |     |
-//    |      |   |  buffer reservations += buf             |     | (yes)
-//    |      |   |                                         |     |
-//    |      |   |        BindStartupTargetBuffer(buf, id) |-----
-//    |      |   |           buffer reservations -= buf    | reservations > 0?
-//    |      |   |                                         |
-//    |      |   |                                         | (no)
-//    |      V   |                                         V
-//     --> [ fully_bound_, endpoint_, 0 unbound buffer reservations ]
-//              |    A
-//              |    | CreateStartupTraceWriter(buf)
-//              |    |  where buf is already bound
-//               ----
-class SharedMemoryArbiterImpl : public SharedMemoryArbiter {
- public:
-  // See SharedMemoryArbiter::CreateInstance(). |start|, |size| define the
-  // boundaries of the shared memory buffer. ProducerEndpoint and TaskRunner may
-  // be |nullptr| if created unbound, see
-  // SharedMemoryArbiter::CreateUnboundInstance().
-  SharedMemoryArbiterImpl(void* start,
-                          size_t size,
-                          size_t page_size,
-                          TracingService::ProducerEndpoint*,
-                          base::TaskRunner*);
+bool ProcessDescriptor::ParseFromArray(const void* raw, size_t size) {
+  cmdline_.clear();
+  process_labels_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  // Returns a new Chunk to write tracing data. Depending on the provided
-  // BufferExhaustedPolicy, this may return an invalid chunk if no valid free
-  // chunk could be found in the SMB.
-  SharedMemoryABI::Chunk GetNewChunk(const SharedMemoryABI::ChunkHeader&,
-                                     BufferExhaustedPolicy,
-                                     size_t size_hint = 0);
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* pid */:
+        field.get(&pid_);
+        break;
+      case 2 /* cmdline */:
+        cmdline_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &cmdline_.back());
+        break;
+      case 6 /* process_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &process_name_);
+        break;
+      case 5 /* process_priority */:
+        field.get(&process_priority_);
+        break;
+      case 7 /* start_timestamp_ns */:
+        field.get(&start_timestamp_ns_);
+        break;
+      case 4 /* chrome_process_type */:
+        field.get(&chrome_process_type_);
+        break;
+      case 3 /* legacy_sort_index */:
+        field.get(&legacy_sort_index_);
+        break;
+      case 8 /* process_labels */:
+        process_labels_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &process_labels_.back());
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-  // Puts back a Chunk that has been completed and sends a request to the
-  // service to move it to the central tracing buffer. |target_buffer| is the
-  // absolute trace buffer ID where the service should move the chunk onto (the
-  // producer is just to copy back the same number received in the
-  // DataSourceConfig upon the StartDataSource() reques).
-  // PatchList is a pointer to the list of patches for previous chunks. The
-  // first patched entries will be removed from the patched list and sent over
-  // to the service in the same CommitData() IPC request.
-  void ReturnCompletedChunk(SharedMemoryABI::Chunk,
-                            MaybeUnboundBufferID target_buffer,
-                            PatchList*);
+std::string ProcessDescriptor::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  // Send a request to the service to apply completed patches from |patch_list|.
-  // |writer_id| is the ID of the TraceWriter that calls this method,
-  // |target_buffer| is the global trace buffer ID of its target buffer.
-  void SendPatches(WriterID writer_id,
-                   MaybeUnboundBufferID target_buffer,
-                   PatchList* patch_list);
+std::vector<uint8_t> ProcessDescriptor::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  SharedMemoryABI* shmem_abi_for_testing() { return &shmem_abi_; }
+void ProcessDescriptor::Serialize(::protozero::Message* msg) const {
+  // Field 1: pid
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, pid_, msg);
+  }
 
-  static void set_default_layout_for_testing(SharedMemoryABI::PageLayout l) {
-    default_page_layout = l;
+  // Field 2: cmdline
+  for (auto& it : cmdline_) {
+    ::protozero::internal::gen_helpers::SerializeString(2, it, msg);
   }
 
-  // SharedMemoryArbiter implementation.
-  // See include/perfetto/tracing/core/shared_memory_arbiter.h for comments.
-  std::unique_ptr<TraceWriter> CreateTraceWriter(
-      BufferID target_buffer,
-      BufferExhaustedPolicy = BufferExhaustedPolicy::kDefault) override;
-  std::unique_ptr<TraceWriter> CreateStartupTraceWriter(
-      uint16_t target_buffer_reservation_id) override;
-  void BindToProducerEndpoint(TracingService::ProducerEndpoint*,
-                              base::TaskRunner*) override;
-  void BindStartupTargetBuffer(uint16_t target_buffer_reservation_id,
-                               BufferID target_buffer_id) override;
-  void AbortStartupTracingForReservation(
-      uint16_t target_buffer_reservation_id) override;
-  void NotifyFlushComplete(FlushRequestID) override;
+  // Field 6: process_name
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeString(6, process_name_, msg);
+  }
+
+  // Field 5: process_priority
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, process_priority_, msg);
+  }
+
+  // Field 7: start_timestamp_ns
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(7, start_timestamp_ns_, msg);
+  }
+
+  // Field 4: chrome_process_type
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, chrome_process_type_, msg);
+  }
+
+  // Field 3: legacy_sort_index
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, legacy_sort_index_, msg);
+  }
+
+  // Field 8: process_labels
+  for (auto& it : process_labels_) {
+    ::protozero::internal::gen_helpers::SerializeString(8, it, msg);
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
+
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/range_of_interest.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/range_of_interest.gen.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+
+TrackEventRangeOfInterest::TrackEventRangeOfInterest() = default;
+TrackEventRangeOfInterest::~TrackEventRangeOfInterest() = default;
+TrackEventRangeOfInterest::TrackEventRangeOfInterest(const TrackEventRangeOfInterest&) = default;
+TrackEventRangeOfInterest& TrackEventRangeOfInterest::operator=(const TrackEventRangeOfInterest&) = default;
+TrackEventRangeOfInterest::TrackEventRangeOfInterest(TrackEventRangeOfInterest&&) noexcept = default;
+TrackEventRangeOfInterest& TrackEventRangeOfInterest::operator=(TrackEventRangeOfInterest&&) = default;
+
+bool TrackEventRangeOfInterest::operator==(const TrackEventRangeOfInterest& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(start_us_, other.start_us_);
+}
+
+bool TrackEventRangeOfInterest::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* start_us */:
+        field.get(&start_us_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
+
+std::string TrackEventRangeOfInterest::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> TrackEventRangeOfInterest::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void TrackEventRangeOfInterest::Serialize(::protozero::Message* msg) const {
+  // Field 1: start_us
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, start_us_, msg);
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
+
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/screenshot.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/screenshot.gen.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+
+Screenshot::Screenshot() = default;
+Screenshot::~Screenshot() = default;
+Screenshot::Screenshot(const Screenshot&) = default;
+Screenshot& Screenshot::operator=(const Screenshot&) = default;
+Screenshot::Screenshot(Screenshot&&) noexcept = default;
+Screenshot& Screenshot::operator=(Screenshot&&) = default;
+
+bool Screenshot::operator==(const Screenshot& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(jpg_image_, other.jpg_image_);
+}
+
+bool Screenshot::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* jpg_image */:
+        field.get(&jpg_image_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
+
+std::string Screenshot::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> Screenshot::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void Screenshot::Serialize(::protozero::Message* msg) const {
+  // Field 1: jpg_image
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeString(1, jpg_image_, msg);
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
+
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/source_location.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/source_location.gen.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+
+SourceLocation::SourceLocation() = default;
+SourceLocation::~SourceLocation() = default;
+SourceLocation::SourceLocation(const SourceLocation&) = default;
+SourceLocation& SourceLocation::operator=(const SourceLocation&) = default;
+SourceLocation::SourceLocation(SourceLocation&&) noexcept = default;
+SourceLocation& SourceLocation::operator=(SourceLocation&&) = default;
+
+bool SourceLocation::operator==(const SourceLocation& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(iid_, other.iid_)
+   && ::protozero::internal::gen_helpers::EqualsField(file_name_, other.file_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(function_name_, other.function_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(line_number_, other.line_number_);
+}
+
+bool SourceLocation::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* iid */:
+        field.get(&iid_);
+        break;
+      case 2 /* file_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &file_name_);
+        break;
+      case 3 /* function_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &function_name_);
+        break;
+      case 4 /* line_number */:
+        field.get(&line_number_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
+
+std::string SourceLocation::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> SourceLocation::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void SourceLocation::Serialize(::protozero::Message* msg) const {
+  // Field 1: iid
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, iid_, msg);
+  }
+
+  // Field 2: file_name
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeString(2, file_name_, msg);
+  }
+
+  // Field 3: function_name
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeString(3, function_name_, msg);
+  }
+
+  // Field 4: line_number
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, line_number_, msg);
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
+
+
+UnsymbolizedSourceLocation::UnsymbolizedSourceLocation() = default;
+UnsymbolizedSourceLocation::~UnsymbolizedSourceLocation() = default;
+UnsymbolizedSourceLocation::UnsymbolizedSourceLocation(const UnsymbolizedSourceLocation&) = default;
+UnsymbolizedSourceLocation& UnsymbolizedSourceLocation::operator=(const UnsymbolizedSourceLocation&) = default;
+UnsymbolizedSourceLocation::UnsymbolizedSourceLocation(UnsymbolizedSourceLocation&&) noexcept = default;
+UnsymbolizedSourceLocation& UnsymbolizedSourceLocation::operator=(UnsymbolizedSourceLocation&&) = default;
+
+bool UnsymbolizedSourceLocation::operator==(const UnsymbolizedSourceLocation& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(iid_, other.iid_)
+   && ::protozero::internal::gen_helpers::EqualsField(mapping_id_, other.mapping_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(rel_pc_, other.rel_pc_);
+}
+
+bool UnsymbolizedSourceLocation::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* iid */:
+        field.get(&iid_);
+        break;
+      case 2 /* mapping_id */:
+        field.get(&mapping_id_);
+        break;
+      case 3 /* rel_pc */:
+        field.get(&rel_pc_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
+
+std::string UnsymbolizedSourceLocation::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> UnsymbolizedSourceLocation::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void UnsymbolizedSourceLocation::Serialize(::protozero::Message* msg) const {
+  // Field 1: iid
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, iid_, msg);
+  }
+
+  // Field 2: mapping_id
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, mapping_id_, msg);
+  }
+
+  // Field 3: rel_pc
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, rel_pc_, msg);
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
+
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/task_execution.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/task_execution.gen.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+
+TaskExecution::TaskExecution() = default;
+TaskExecution::~TaskExecution() = default;
+TaskExecution::TaskExecution(const TaskExecution&) = default;
+TaskExecution& TaskExecution::operator=(const TaskExecution&) = default;
+TaskExecution::TaskExecution(TaskExecution&&) noexcept = default;
+TaskExecution& TaskExecution::operator=(TaskExecution&&) = default;
+
+bool TaskExecution::operator==(const TaskExecution& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(posted_from_iid_, other.posted_from_iid_);
+}
+
+bool TaskExecution::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* posted_from_iid */:
+        field.get(&posted_from_iid_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
+
+std::string TaskExecution::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> TaskExecution::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void TaskExecution::Serialize(::protozero::Message* msg) const {
+  // Field 1: posted_from_iid
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, posted_from_iid_, msg);
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
+
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/thread_descriptor.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/thread_descriptor.gen.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+
+ThreadDescriptor::ThreadDescriptor() = default;
+ThreadDescriptor::~ThreadDescriptor() = default;
+ThreadDescriptor::ThreadDescriptor(const ThreadDescriptor&) = default;
+ThreadDescriptor& ThreadDescriptor::operator=(const ThreadDescriptor&) = default;
+ThreadDescriptor::ThreadDescriptor(ThreadDescriptor&&) noexcept = default;
+ThreadDescriptor& ThreadDescriptor::operator=(ThreadDescriptor&&) = default;
+
+bool ThreadDescriptor::operator==(const ThreadDescriptor& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(pid_, other.pid_)
+   && ::protozero::internal::gen_helpers::EqualsField(tid_, other.tid_)
+   && ::protozero::internal::gen_helpers::EqualsField(thread_name_, other.thread_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(chrome_thread_type_, other.chrome_thread_type_)
+   && ::protozero::internal::gen_helpers::EqualsField(reference_timestamp_us_, other.reference_timestamp_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(reference_thread_time_us_, other.reference_thread_time_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(reference_thread_instruction_count_, other.reference_thread_instruction_count_)
+   && ::protozero::internal::gen_helpers::EqualsField(legacy_sort_index_, other.legacy_sort_index_);
+}
+
+bool ThreadDescriptor::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* pid */:
+        field.get(&pid_);
+        break;
+      case 2 /* tid */:
+        field.get(&tid_);
+        break;
+      case 5 /* thread_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &thread_name_);
+        break;
+      case 4 /* chrome_thread_type */:
+        field.get(&chrome_thread_type_);
+        break;
+      case 6 /* reference_timestamp_us */:
+        field.get(&reference_timestamp_us_);
+        break;
+      case 7 /* reference_thread_time_us */:
+        field.get(&reference_thread_time_us_);
+        break;
+      case 8 /* reference_thread_instruction_count */:
+        field.get(&reference_thread_instruction_count_);
+        break;
+      case 3 /* legacy_sort_index */:
+        field.get(&legacy_sort_index_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
+
+std::string ThreadDescriptor::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> ThreadDescriptor::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void ThreadDescriptor::Serialize(::protozero::Message* msg) const {
+  // Field 1: pid
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, pid_, msg);
+  }
+
+  // Field 2: tid
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, tid_, msg);
+  }
+
+  // Field 5: thread_name
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeString(5, thread_name_, msg);
+  }
+
+  // Field 4: chrome_thread_type
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, chrome_thread_type_, msg);
+  }
+
+  // Field 6: reference_timestamp_us
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, reference_timestamp_us_, msg);
+  }
+
+  // Field 7: reference_thread_time_us
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(7, reference_thread_time_us_, msg);
+  }
+
+  // Field 8: reference_thread_instruction_count
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(8, reference_thread_instruction_count_, msg);
+  }
+
+  // Field 3: legacy_sort_index
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, legacy_sort_index_, msg);
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
+
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/track_descriptor.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_descriptor.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/counter_descriptor.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/thread_descriptor.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/process_descriptor.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_thread_descriptor.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_process_descriptor.gen.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+
+TrackDescriptor::TrackDescriptor() = default;
+TrackDescriptor::~TrackDescriptor() = default;
+TrackDescriptor::TrackDescriptor(const TrackDescriptor&) = default;
+TrackDescriptor& TrackDescriptor::operator=(const TrackDescriptor&) = default;
+TrackDescriptor::TrackDescriptor(TrackDescriptor&&) noexcept = default;
+TrackDescriptor& TrackDescriptor::operator=(TrackDescriptor&&) = default;
+
+bool TrackDescriptor::operator==(const TrackDescriptor& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(uuid_, other.uuid_)
+   && ::protozero::internal::gen_helpers::EqualsField(parent_uuid_, other.parent_uuid_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(static_name_, other.static_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(atrace_name_, other.atrace_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(description_, other.description_)
+   && ::protozero::internal::gen_helpers::EqualsField(process_, other.process_)
+   && ::protozero::internal::gen_helpers::EqualsField(chrome_process_, other.chrome_process_)
+   && ::protozero::internal::gen_helpers::EqualsField(thread_, other.thread_)
+   && ::protozero::internal::gen_helpers::EqualsField(chrome_thread_, other.chrome_thread_)
+   && ::protozero::internal::gen_helpers::EqualsField(counter_, other.counter_)
+   && ::protozero::internal::gen_helpers::EqualsField(disallow_merging_with_system_tracks_, other.disallow_merging_with_system_tracks_)
+   && ::protozero::internal::gen_helpers::EqualsField(child_ordering_, other.child_ordering_)
+   && ::protozero::internal::gen_helpers::EqualsField(sibling_order_rank_, other.sibling_order_rank_)
+   && ::protozero::internal::gen_helpers::EqualsField(sibling_merge_behavior_, other.sibling_merge_behavior_)
+   && ::protozero::internal::gen_helpers::EqualsField(sibling_merge_key_, other.sibling_merge_key_)
+   && ::protozero::internal::gen_helpers::EqualsField(sibling_merge_key_int_, other.sibling_merge_key_int_);
+}
+
+bool TrackDescriptor::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* uuid */:
+        field.get(&uuid_);
+        break;
+      case 5 /* parent_uuid */:
+        field.get(&parent_uuid_);
+        break;
+      case 2 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+        break;
+      case 10 /* static_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &static_name_);
+        break;
+      case 13 /* atrace_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &atrace_name_);
+        break;
+      case 14 /* description */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &description_);
+        break;
+      case 3 /* process */:
+        (*process_).ParseFromArray(field.data(), field.size());
+        break;
+      case 6 /* chrome_process */:
+        (*chrome_process_).ParseFromArray(field.data(), field.size());
+        break;
+      case 4 /* thread */:
+        (*thread_).ParseFromArray(field.data(), field.size());
+        break;
+      case 7 /* chrome_thread */:
+        (*chrome_thread_).ParseFromArray(field.data(), field.size());
+        break;
+      case 8 /* counter */:
+        (*counter_).ParseFromArray(field.data(), field.size());
+        break;
+      case 9 /* disallow_merging_with_system_tracks */:
+        field.get(&disallow_merging_with_system_tracks_);
+        break;
+      case 11 /* child_ordering */:
+        field.get(&child_ordering_);
+        break;
+      case 12 /* sibling_order_rank */:
+        field.get(&sibling_order_rank_);
+        break;
+      case 15 /* sibling_merge_behavior */:
+        field.get(&sibling_merge_behavior_);
+        break;
+      case 16 /* sibling_merge_key */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &sibling_merge_key_);
+        break;
+      case 17 /* sibling_merge_key_int */:
+        field.get(&sibling_merge_key_int_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
+
+std::string TrackDescriptor::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> TrackDescriptor::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void TrackDescriptor::Serialize(::protozero::Message* msg) const {
+  // Field 1: uuid
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, uuid_, msg);
+  }
+
+  // Field 5: parent_uuid
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(5, parent_uuid_, msg);
+  }
+
+  // Field 2: name
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeString(2, name_, msg);
+  }
+
+  // Field 10: static_name
+  if (_has_field_[10]) {
+    ::protozero::internal::gen_helpers::SerializeString(10, static_name_, msg);
+  }
+
+  // Field 13: atrace_name
+  if (_has_field_[13]) {
+    ::protozero::internal::gen_helpers::SerializeString(13, atrace_name_, msg);
+  }
+
+  // Field 14: description
+  if (_has_field_[14]) {
+    ::protozero::internal::gen_helpers::SerializeString(14, description_, msg);
+  }
+
+  // Field 3: process
+  if (_has_field_[3]) {
+    (*process_).Serialize(msg->BeginNestedMessage<::protozero::Message>(3));
+  }
+
+  // Field 6: chrome_process
+  if (_has_field_[6]) {
+    (*chrome_process_).Serialize(msg->BeginNestedMessage<::protozero::Message>(6));
+  }
+
+  // Field 4: thread
+  if (_has_field_[4]) {
+    (*thread_).Serialize(msg->BeginNestedMessage<::protozero::Message>(4));
+  }
+
+  // Field 7: chrome_thread
+  if (_has_field_[7]) {
+    (*chrome_thread_).Serialize(msg->BeginNestedMessage<::protozero::Message>(7));
+  }
+
+  // Field 8: counter
+  if (_has_field_[8]) {
+    (*counter_).Serialize(msg->BeginNestedMessage<::protozero::Message>(8));
+  }
+
+  // Field 9: disallow_merging_with_system_tracks
+  if (_has_field_[9]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(9, disallow_merging_with_system_tracks_, msg);
+  }
+
+  // Field 11: child_ordering
+  if (_has_field_[11]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(11, child_ordering_, msg);
+  }
+
+  // Field 12: sibling_order_rank
+  if (_has_field_[12]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(12, sibling_order_rank_, msg);
+  }
+
+  // Field 15: sibling_merge_behavior
+  if (_has_field_[15]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(15, sibling_merge_behavior_, msg);
+  }
+
+  // Field 16: sibling_merge_key
+  if (_has_field_[16]) {
+    ::protozero::internal::gen_helpers::SerializeString(16, sibling_merge_key_, msg);
+  }
+
+  // Field 17: sibling_merge_key_int
+  if (_has_field_[17]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(17, sibling_merge_key_int_, msg);
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
+
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/track_event.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_event.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/source_location.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/screenshot.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_window_handle_event_info.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_user_event.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_renderer_scheduler_state.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_mojo_event_info.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_message_pump.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_legacy_ipc.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_latency_info.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_keyed_service.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_histogram_sample.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_frame_reporter.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_content_settings_event_info.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_compositor_scheduler_state.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_application_state_info.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/chrome_active_processes.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/task_execution.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/log_message.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/debug_annotation.gen.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+
+EventName::EventName() = default;
+EventName::~EventName() = default;
+EventName::EventName(const EventName&) = default;
+EventName& EventName::operator=(const EventName&) = default;
+EventName::EventName(EventName&&) noexcept = default;
+EventName& EventName::operator=(EventName&&) = default;
+
+bool EventName::operator==(const EventName& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(iid_, other.iid_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_);
+}
+
+bool EventName::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* iid */:
+        field.get(&iid_);
+        break;
+      case 2 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
+
+std::string EventName::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> EventName::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void EventName::Serialize(::protozero::Message* msg) const {
+  // Field 1: iid
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, iid_, msg);
+  }
+
+  // Field 2: name
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeString(2, name_, msg);
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
+
+
+EventCategory::EventCategory() = default;
+EventCategory::~EventCategory() = default;
+EventCategory::EventCategory(const EventCategory&) = default;
+EventCategory& EventCategory::operator=(const EventCategory&) = default;
+EventCategory::EventCategory(EventCategory&&) noexcept = default;
+EventCategory& EventCategory::operator=(EventCategory&&) = default;
+
+bool EventCategory::operator==(const EventCategory& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(iid_, other.iid_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_);
+}
+
+bool EventCategory::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* iid */:
+        field.get(&iid_);
+        break;
+      case 2 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
+
+std::string EventCategory::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> EventCategory::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void EventCategory::Serialize(::protozero::Message* msg) const {
+  // Field 1: iid
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, iid_, msg);
+  }
+
+  // Field 2: name
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeString(2, name_, msg);
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
+
+
+TrackEventDefaults::TrackEventDefaults() = default;
+TrackEventDefaults::~TrackEventDefaults() = default;
+TrackEventDefaults::TrackEventDefaults(const TrackEventDefaults&) = default;
+TrackEventDefaults& TrackEventDefaults::operator=(const TrackEventDefaults&) = default;
+TrackEventDefaults::TrackEventDefaults(TrackEventDefaults&&) noexcept = default;
+TrackEventDefaults& TrackEventDefaults::operator=(TrackEventDefaults&&) = default;
+
+bool TrackEventDefaults::operator==(const TrackEventDefaults& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(track_uuid_, other.track_uuid_)
+   && ::protozero::internal::gen_helpers::EqualsField(extra_counter_track_uuids_, other.extra_counter_track_uuids_)
+   && ::protozero::internal::gen_helpers::EqualsField(extra_double_counter_track_uuids_, other.extra_double_counter_track_uuids_);
+}
+
+bool TrackEventDefaults::ParseFromArray(const void* raw, size_t size) {
+  extra_counter_track_uuids_.clear();
+  extra_double_counter_track_uuids_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 11 /* track_uuid */:
+        field.get(&track_uuid_);
+        break;
+      case 31 /* extra_counter_track_uuids */:
+        extra_counter_track_uuids_.emplace_back();
+        field.get(&extra_counter_track_uuids_.back());
+        break;
+      case 45 /* extra_double_counter_track_uuids */:
+        extra_double_counter_track_uuids_.emplace_back();
+        field.get(&extra_double_counter_track_uuids_.back());
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
+
+std::string TrackEventDefaults::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> TrackEventDefaults::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void TrackEventDefaults::Serialize(::protozero::Message* msg) const {
+  // Field 11: track_uuid
+  if (_has_field_[11]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(11, track_uuid_, msg);
+  }
+
+  // Field 31: extra_counter_track_uuids
+  for (auto& it : extra_counter_track_uuids_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(31, it, msg);
+  }
+
+  // Field 45: extra_double_counter_track_uuids
+  for (auto& it : extra_double_counter_track_uuids_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(45, it, msg);
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
+
+
+TrackEvent::TrackEvent() = default;
+TrackEvent::~TrackEvent() = default;
+TrackEvent::TrackEvent(const TrackEvent&) = default;
+TrackEvent& TrackEvent::operator=(const TrackEvent&) = default;
+TrackEvent::TrackEvent(TrackEvent&&) noexcept = default;
+TrackEvent& TrackEvent::operator=(TrackEvent&&) = default;
+
+bool TrackEvent::operator==(const TrackEvent& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(category_iids_, other.category_iids_)
+   && ::protozero::internal::gen_helpers::EqualsField(categories_, other.categories_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_iid_, other.name_iid_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_)
+   && ::protozero::internal::gen_helpers::EqualsField(type_, other.type_)
+   && ::protozero::internal::gen_helpers::EqualsField(track_uuid_, other.track_uuid_)
+   && ::protozero::internal::gen_helpers::EqualsField(counter_value_, other.counter_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(double_counter_value_, other.double_counter_value_)
+   && ::protozero::internal::gen_helpers::EqualsField(extra_counter_track_uuids_, other.extra_counter_track_uuids_)
+   && ::protozero::internal::gen_helpers::EqualsField(extra_counter_values_, other.extra_counter_values_)
+   && ::protozero::internal::gen_helpers::EqualsField(extra_double_counter_track_uuids_, other.extra_double_counter_track_uuids_)
+   && ::protozero::internal::gen_helpers::EqualsField(extra_double_counter_values_, other.extra_double_counter_values_)
+   && ::protozero::internal::gen_helpers::EqualsField(flow_ids_old_, other.flow_ids_old_)
+   && ::protozero::internal::gen_helpers::EqualsField(flow_ids_, other.flow_ids_)
+   && ::protozero::internal::gen_helpers::EqualsField(terminating_flow_ids_old_, other.terminating_flow_ids_old_)
+   && ::protozero::internal::gen_helpers::EqualsField(terminating_flow_ids_, other.terminating_flow_ids_)
+   && ::protozero::internal::gen_helpers::EqualsField(correlation_id_, other.correlation_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(correlation_id_str_, other.correlation_id_str_)
+   && ::protozero::internal::gen_helpers::EqualsField(correlation_id_str_iid_, other.correlation_id_str_iid_)
+   && ::protozero::internal::gen_helpers::EqualsField(callstack_, other.callstack_)
+   && ::protozero::internal::gen_helpers::EqualsField(callstack_iid_, other.callstack_iid_)
+   && ::protozero::internal::gen_helpers::EqualsField(debug_annotations_, other.debug_annotations_)
+   && ::protozero::internal::gen_helpers::EqualsField(task_execution_, other.task_execution_)
+   && ::protozero::internal::gen_helpers::EqualsField(log_message_, other.log_message_)
+   && ::protozero::internal::gen_helpers::EqualsField(cc_scheduler_state_, other.cc_scheduler_state_)
+   && ::protozero::internal::gen_helpers::EqualsField(chrome_user_event_, other.chrome_user_event_)
+   && ::protozero::internal::gen_helpers::EqualsField(chrome_keyed_service_, other.chrome_keyed_service_)
+   && ::protozero::internal::gen_helpers::EqualsField(chrome_legacy_ipc_, other.chrome_legacy_ipc_)
+   && ::protozero::internal::gen_helpers::EqualsField(chrome_histogram_sample_, other.chrome_histogram_sample_)
+   && ::protozero::internal::gen_helpers::EqualsField(chrome_latency_info_, other.chrome_latency_info_)
+   && ::protozero::internal::gen_helpers::EqualsField(chrome_frame_reporter_, other.chrome_frame_reporter_)
+   && ::protozero::internal::gen_helpers::EqualsField(chrome_application_state_info_, other.chrome_application_state_info_)
+   && ::protozero::internal::gen_helpers::EqualsField(chrome_renderer_scheduler_state_, other.chrome_renderer_scheduler_state_)
+   && ::protozero::internal::gen_helpers::EqualsField(chrome_window_handle_event_info_, other.chrome_window_handle_event_info_)
+   && ::protozero::internal::gen_helpers::EqualsField(chrome_content_settings_event_info_, other.chrome_content_settings_event_info_)
+   && ::protozero::internal::gen_helpers::EqualsField(chrome_active_processes_, other.chrome_active_processes_)
+   && ::protozero::internal::gen_helpers::EqualsField(screenshot_, other.screenshot_)
+   && ::protozero::internal::gen_helpers::EqualsField(source_location_, other.source_location_)
+   && ::protozero::internal::gen_helpers::EqualsField(source_location_iid_, other.source_location_iid_)
+   && ::protozero::internal::gen_helpers::EqualsField(chrome_message_pump_, other.chrome_message_pump_)
+   && ::protozero::internal::gen_helpers::EqualsField(chrome_mojo_event_info_, other.chrome_mojo_event_info_)
+   && ::protozero::internal::gen_helpers::EqualsField(timestamp_delta_us_, other.timestamp_delta_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(timestamp_absolute_us_, other.timestamp_absolute_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(thread_time_delta_us_, other.thread_time_delta_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(thread_time_absolute_us_, other.thread_time_absolute_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(thread_instruction_count_delta_, other.thread_instruction_count_delta_)
+   && ::protozero::internal::gen_helpers::EqualsField(thread_instruction_count_absolute_, other.thread_instruction_count_absolute_)
+   && ::protozero::internal::gen_helpers::EqualsField(legacy_event_, other.legacy_event_);
+}
+
+int TrackEvent::debug_annotations_size() const { return static_cast<int>(debug_annotations_.size()); }
+void TrackEvent::clear_debug_annotations() { debug_annotations_.clear(); }
+DebugAnnotation* TrackEvent::add_debug_annotations() { debug_annotations_.emplace_back(); return &debug_annotations_.back(); }
+bool TrackEvent::ParseFromArray(const void* raw, size_t size) {
+  category_iids_.clear();
+  categories_.clear();
+  extra_counter_track_uuids_.clear();
+  extra_counter_values_.clear();
+  extra_double_counter_track_uuids_.clear();
+  extra_double_counter_values_.clear();
+  flow_ids_old_.clear();
+  flow_ids_.clear();
+  terminating_flow_ids_old_.clear();
+  terminating_flow_ids_.clear();
+  debug_annotations_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 3 /* category_iids */:
+        category_iids_.emplace_back();
+        field.get(&category_iids_.back());
+        break;
+      case 22 /* categories */:
+        categories_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &categories_.back());
+        break;
+      case 10 /* name_iid */:
+        field.get(&name_iid_);
+        break;
+      case 23 /* name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &name_);
+        break;
+      case 9 /* type */:
+        field.get(&type_);
+        break;
+      case 11 /* track_uuid */:
+        field.get(&track_uuid_);
+        break;
+      case 30 /* counter_value */:
+        field.get(&counter_value_);
+        break;
+      case 44 /* double_counter_value */:
+        field.get(&double_counter_value_);
+        break;
+      case 31 /* extra_counter_track_uuids */:
+        extra_counter_track_uuids_.emplace_back();
+        field.get(&extra_counter_track_uuids_.back());
+        break;
+      case 12 /* extra_counter_values */:
+        extra_counter_values_.emplace_back();
+        field.get(&extra_counter_values_.back());
+        break;
+      case 45 /* extra_double_counter_track_uuids */:
+        extra_double_counter_track_uuids_.emplace_back();
+        field.get(&extra_double_counter_track_uuids_.back());
+        break;
+      case 46 /* extra_double_counter_values */:
+        extra_double_counter_values_.emplace_back();
+        field.get(&extra_double_counter_values_.back());
+        break;
+      case 36 /* flow_ids_old */:
+        flow_ids_old_.emplace_back();
+        field.get(&flow_ids_old_.back());
+        break;
+      case 47 /* flow_ids */:
+        flow_ids_.emplace_back();
+        field.get(&flow_ids_.back());
+        break;
+      case 42 /* terminating_flow_ids_old */:
+        terminating_flow_ids_old_.emplace_back();
+        field.get(&terminating_flow_ids_old_.back());
+        break;
+      case 48 /* terminating_flow_ids */:
+        terminating_flow_ids_.emplace_back();
+        field.get(&terminating_flow_ids_.back());
+        break;
+      case 52 /* correlation_id */:
+        field.get(&correlation_id_);
+        break;
+      case 53 /* correlation_id_str */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &correlation_id_str_);
+        break;
+      case 54 /* correlation_id_str_iid */:
+        field.get(&correlation_id_str_iid_);
+        break;
+      case 55 /* callstack */:
+        (*callstack_).ParseFromArray(field.data(), field.size());
+        break;
+      case 56 /* callstack_iid */:
+        field.get(&callstack_iid_);
+        break;
+      case 4 /* debug_annotations */:
+        debug_annotations_.emplace_back();
+        debug_annotations_.back().ParseFromArray(field.data(), field.size());
+        break;
+      case 5 /* task_execution */:
+        (*task_execution_).ParseFromArray(field.data(), field.size());
+        break;
+      case 21 /* log_message */:
+        (*log_message_).ParseFromArray(field.data(), field.size());
+        break;
+      case 24 /* cc_scheduler_state */:
+        (*cc_scheduler_state_).ParseFromArray(field.data(), field.size());
+        break;
+      case 25 /* chrome_user_event */:
+        (*chrome_user_event_).ParseFromArray(field.data(), field.size());
+        break;
+      case 26 /* chrome_keyed_service */:
+        (*chrome_keyed_service_).ParseFromArray(field.data(), field.size());
+        break;
+      case 27 /* chrome_legacy_ipc */:
+        (*chrome_legacy_ipc_).ParseFromArray(field.data(), field.size());
+        break;
+      case 28 /* chrome_histogram_sample */:
+        (*chrome_histogram_sample_).ParseFromArray(field.data(), field.size());
+        break;
+      case 29 /* chrome_latency_info */:
+        (*chrome_latency_info_).ParseFromArray(field.data(), field.size());
+        break;
+      case 32 /* chrome_frame_reporter */:
+        (*chrome_frame_reporter_).ParseFromArray(field.data(), field.size());
+        break;
+      case 39 /* chrome_application_state_info */:
+        (*chrome_application_state_info_).ParseFromArray(field.data(), field.size());
+        break;
+      case 40 /* chrome_renderer_scheduler_state */:
+        (*chrome_renderer_scheduler_state_).ParseFromArray(field.data(), field.size());
+        break;
+      case 41 /* chrome_window_handle_event_info */:
+        (*chrome_window_handle_event_info_).ParseFromArray(field.data(), field.size());
+        break;
+      case 43 /* chrome_content_settings_event_info */:
+        (*chrome_content_settings_event_info_).ParseFromArray(field.data(), field.size());
+        break;
+      case 49 /* chrome_active_processes */:
+        (*chrome_active_processes_).ParseFromArray(field.data(), field.size());
+        break;
+      case 50 /* screenshot */:
+        (*screenshot_).ParseFromArray(field.data(), field.size());
+        break;
+      case 33 /* source_location */:
+        (*source_location_).ParseFromArray(field.data(), field.size());
+        break;
+      case 34 /* source_location_iid */:
+        field.get(&source_location_iid_);
+        break;
+      case 35 /* chrome_message_pump */:
+        (*chrome_message_pump_).ParseFromArray(field.data(), field.size());
+        break;
+      case 38 /* chrome_mojo_event_info */:
+        (*chrome_mojo_event_info_).ParseFromArray(field.data(), field.size());
+        break;
+      case 1 /* timestamp_delta_us */:
+        field.get(&timestamp_delta_us_);
+        break;
+      case 16 /* timestamp_absolute_us */:
+        field.get(&timestamp_absolute_us_);
+        break;
+      case 2 /* thread_time_delta_us */:
+        field.get(&thread_time_delta_us_);
+        break;
+      case 17 /* thread_time_absolute_us */:
+        field.get(&thread_time_absolute_us_);
+        break;
+      case 8 /* thread_instruction_count_delta */:
+        field.get(&thread_instruction_count_delta_);
+        break;
+      case 20 /* thread_instruction_count_absolute */:
+        field.get(&thread_instruction_count_absolute_);
+        break;
+      case 6 /* legacy_event */:
+        (*legacy_event_).ParseFromArray(field.data(), field.size());
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
+
+std::string TrackEvent::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> TrackEvent::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void TrackEvent::Serialize(::protozero::Message* msg) const {
+  // Field 3: category_iids
+  for (auto& it : category_iids_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, it, msg);
+  }
+
+  // Field 22: categories
+  for (auto& it : categories_) {
+    ::protozero::internal::gen_helpers::SerializeString(22, it, msg);
+  }
+
+  // Field 10: name_iid
+  if (_has_field_[10]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(10, name_iid_, msg);
+  }
+
+  // Field 23: name
+  if (_has_field_[23]) {
+    ::protozero::internal::gen_helpers::SerializeString(23, name_, msg);
+  }
+
+  // Field 9: type
+  if (_has_field_[9]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(9, type_, msg);
+  }
+
+  // Field 11: track_uuid
+  if (_has_field_[11]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(11, track_uuid_, msg);
+  }
+
+  // Field 30: counter_value
+  if (_has_field_[30]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(30, counter_value_, msg);
+  }
+
+  // Field 44: double_counter_value
+  if (_has_field_[44]) {
+    ::protozero::internal::gen_helpers::SerializeFixed(44, double_counter_value_, msg);
+  }
+
+  // Field 31: extra_counter_track_uuids
+  for (auto& it : extra_counter_track_uuids_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(31, it, msg);
+  }
+
+  // Field 12: extra_counter_values
+  for (auto& it : extra_counter_values_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(12, it, msg);
+  }
+
+  // Field 45: extra_double_counter_track_uuids
+  for (auto& it : extra_double_counter_track_uuids_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(45, it, msg);
+  }
+
+  // Field 46: extra_double_counter_values
+  for (auto& it : extra_double_counter_values_) {
+    ::protozero::internal::gen_helpers::SerializeFixed(46, it, msg);
+  }
+
+  // Field 36: flow_ids_old
+  for (auto& it : flow_ids_old_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(36, it, msg);
+  }
+
+  // Field 47: flow_ids
+  for (auto& it : flow_ids_) {
+    ::protozero::internal::gen_helpers::SerializeFixed(47, it, msg);
+  }
+
+  // Field 42: terminating_flow_ids_old
+  for (auto& it : terminating_flow_ids_old_) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(42, it, msg);
+  }
+
+  // Field 48: terminating_flow_ids
+  for (auto& it : terminating_flow_ids_) {
+    ::protozero::internal::gen_helpers::SerializeFixed(48, it, msg);
+  }
+
+  // Field 52: correlation_id
+  if (_has_field_[52]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(52, correlation_id_, msg);
+  }
+
+  // Field 53: correlation_id_str
+  if (_has_field_[53]) {
+    ::protozero::internal::gen_helpers::SerializeString(53, correlation_id_str_, msg);
+  }
+
+  // Field 54: correlation_id_str_iid
+  if (_has_field_[54]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(54, correlation_id_str_iid_, msg);
+  }
+
+  // Field 55: callstack
+  if (_has_field_[55]) {
+    (*callstack_).Serialize(msg->BeginNestedMessage<::protozero::Message>(55));
+  }
+
+  // Field 56: callstack_iid
+  if (_has_field_[56]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(56, callstack_iid_, msg);
+  }
+
+  // Field 4: debug_annotations
+  for (auto& it : debug_annotations_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(4));
+  }
+
+  // Field 5: task_execution
+  if (_has_field_[5]) {
+    (*task_execution_).Serialize(msg->BeginNestedMessage<::protozero::Message>(5));
+  }
+
+  // Field 21: log_message
+  if (_has_field_[21]) {
+    (*log_message_).Serialize(msg->BeginNestedMessage<::protozero::Message>(21));
+  }
+
+  // Field 24: cc_scheduler_state
+  if (_has_field_[24]) {
+    (*cc_scheduler_state_).Serialize(msg->BeginNestedMessage<::protozero::Message>(24));
+  }
+
+  // Field 25: chrome_user_event
+  if (_has_field_[25]) {
+    (*chrome_user_event_).Serialize(msg->BeginNestedMessage<::protozero::Message>(25));
+  }
+
+  // Field 26: chrome_keyed_service
+  if (_has_field_[26]) {
+    (*chrome_keyed_service_).Serialize(msg->BeginNestedMessage<::protozero::Message>(26));
+  }
+
+  // Field 27: chrome_legacy_ipc
+  if (_has_field_[27]) {
+    (*chrome_legacy_ipc_).Serialize(msg->BeginNestedMessage<::protozero::Message>(27));
+  }
+
+  // Field 28: chrome_histogram_sample
+  if (_has_field_[28]) {
+    (*chrome_histogram_sample_).Serialize(msg->BeginNestedMessage<::protozero::Message>(28));
+  }
+
+  // Field 29: chrome_latency_info
+  if (_has_field_[29]) {
+    (*chrome_latency_info_).Serialize(msg->BeginNestedMessage<::protozero::Message>(29));
+  }
+
+  // Field 32: chrome_frame_reporter
+  if (_has_field_[32]) {
+    (*chrome_frame_reporter_).Serialize(msg->BeginNestedMessage<::protozero::Message>(32));
+  }
+
+  // Field 39: chrome_application_state_info
+  if (_has_field_[39]) {
+    (*chrome_application_state_info_).Serialize(msg->BeginNestedMessage<::protozero::Message>(39));
+  }
+
+  // Field 40: chrome_renderer_scheduler_state
+  if (_has_field_[40]) {
+    (*chrome_renderer_scheduler_state_).Serialize(msg->BeginNestedMessage<::protozero::Message>(40));
+  }
+
+  // Field 41: chrome_window_handle_event_info
+  if (_has_field_[41]) {
+    (*chrome_window_handle_event_info_).Serialize(msg->BeginNestedMessage<::protozero::Message>(41));
+  }
+
+  // Field 43: chrome_content_settings_event_info
+  if (_has_field_[43]) {
+    (*chrome_content_settings_event_info_).Serialize(msg->BeginNestedMessage<::protozero::Message>(43));
+  }
+
+  // Field 49: chrome_active_processes
+  if (_has_field_[49]) {
+    (*chrome_active_processes_).Serialize(msg->BeginNestedMessage<::protozero::Message>(49));
+  }
+
+  // Field 50: screenshot
+  if (_has_field_[50]) {
+    (*screenshot_).Serialize(msg->BeginNestedMessage<::protozero::Message>(50));
+  }
+
+  // Field 33: source_location
+  if (_has_field_[33]) {
+    (*source_location_).Serialize(msg->BeginNestedMessage<::protozero::Message>(33));
+  }
+
+  // Field 34: source_location_iid
+  if (_has_field_[34]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(34, source_location_iid_, msg);
+  }
+
+  // Field 35: chrome_message_pump
+  if (_has_field_[35]) {
+    (*chrome_message_pump_).Serialize(msg->BeginNestedMessage<::protozero::Message>(35));
+  }
+
+  // Field 38: chrome_mojo_event_info
+  if (_has_field_[38]) {
+    (*chrome_mojo_event_info_).Serialize(msg->BeginNestedMessage<::protozero::Message>(38));
+  }
+
+  // Field 1: timestamp_delta_us
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, timestamp_delta_us_, msg);
+  }
+
+  // Field 16: timestamp_absolute_us
+  if (_has_field_[16]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(16, timestamp_absolute_us_, msg);
+  }
+
+  // Field 2: thread_time_delta_us
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, thread_time_delta_us_, msg);
+  }
+
+  // Field 17: thread_time_absolute_us
+  if (_has_field_[17]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(17, thread_time_absolute_us_, msg);
+  }
+
+  // Field 8: thread_instruction_count_delta
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(8, thread_instruction_count_delta_, msg);
+  }
+
+  // Field 20: thread_instruction_count_absolute
+  if (_has_field_[20]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(20, thread_instruction_count_absolute_, msg);
+  }
+
+  // Field 6: legacy_event
+  if (_has_field_[6]) {
+    (*legacy_event_).Serialize(msg->BeginNestedMessage<::protozero::Message>(6));
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
+
+
+TrackEvent_LegacyEvent::TrackEvent_LegacyEvent() = default;
+TrackEvent_LegacyEvent::~TrackEvent_LegacyEvent() = default;
+TrackEvent_LegacyEvent::TrackEvent_LegacyEvent(const TrackEvent_LegacyEvent&) = default;
+TrackEvent_LegacyEvent& TrackEvent_LegacyEvent::operator=(const TrackEvent_LegacyEvent&) = default;
+TrackEvent_LegacyEvent::TrackEvent_LegacyEvent(TrackEvent_LegacyEvent&&) noexcept = default;
+TrackEvent_LegacyEvent& TrackEvent_LegacyEvent::operator=(TrackEvent_LegacyEvent&&) = default;
+
+bool TrackEvent_LegacyEvent::operator==(const TrackEvent_LegacyEvent& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_iid_, other.name_iid_)
+   && ::protozero::internal::gen_helpers::EqualsField(phase_, other.phase_)
+   && ::protozero::internal::gen_helpers::EqualsField(duration_us_, other.duration_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(thread_duration_us_, other.thread_duration_us_)
+   && ::protozero::internal::gen_helpers::EqualsField(thread_instruction_delta_, other.thread_instruction_delta_)
+   && ::protozero::internal::gen_helpers::EqualsField(unscoped_id_, other.unscoped_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(local_id_, other.local_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(global_id_, other.global_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(id_scope_, other.id_scope_)
+   && ::protozero::internal::gen_helpers::EqualsField(use_async_tts_, other.use_async_tts_)
+   && ::protozero::internal::gen_helpers::EqualsField(bind_id_, other.bind_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(bind_to_enclosing_, other.bind_to_enclosing_)
+   && ::protozero::internal::gen_helpers::EqualsField(flow_direction_, other.flow_direction_)
+   && ::protozero::internal::gen_helpers::EqualsField(instant_event_scope_, other.instant_event_scope_)
+   && ::protozero::internal::gen_helpers::EqualsField(pid_override_, other.pid_override_)
+   && ::protozero::internal::gen_helpers::EqualsField(tid_override_, other.tid_override_);
+}
+
+bool TrackEvent_LegacyEvent::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* name_iid */:
+        field.get(&name_iid_);
+        break;
+      case 2 /* phase */:
+        field.get(&phase_);
+        break;
+      case 3 /* duration_us */:
+        field.get(&duration_us_);
+        break;
+      case 4 /* thread_duration_us */:
+        field.get(&thread_duration_us_);
+        break;
+      case 15 /* thread_instruction_delta */:
+        field.get(&thread_instruction_delta_);
+        break;
+      case 6 /* unscoped_id */:
+        field.get(&unscoped_id_);
+        break;
+      case 10 /* local_id */:
+        field.get(&local_id_);
+        break;
+      case 11 /* global_id */:
+        field.get(&global_id_);
+        break;
+      case 7 /* id_scope */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &id_scope_);
+        break;
+      case 9 /* use_async_tts */:
+        field.get(&use_async_tts_);
+        break;
+      case 8 /* bind_id */:
+        field.get(&bind_id_);
+        break;
+      case 12 /* bind_to_enclosing */:
+        field.get(&bind_to_enclosing_);
+        break;
+      case 13 /* flow_direction */:
+        field.get(&flow_direction_);
+        break;
+      case 14 /* instant_event_scope */:
+        field.get(&instant_event_scope_);
+        break;
+      case 18 /* pid_override */:
+        field.get(&pid_override_);
+        break;
+      case 19 /* tid_override */:
+        field.get(&tid_override_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
+
+std::string TrackEvent_LegacyEvent::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> TrackEvent_LegacyEvent::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void TrackEvent_LegacyEvent::Serialize(::protozero::Message* msg) const {
+  // Field 1: name_iid
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, name_iid_, msg);
+  }
+
+  // Field 2: phase
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, phase_, msg);
+  }
+
+  // Field 3: duration_us
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, duration_us_, msg);
+  }
+
+  // Field 4: thread_duration_us
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, thread_duration_us_, msg);
+  }
+
+  // Field 15: thread_instruction_delta
+  if (_has_field_[15]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(15, thread_instruction_delta_, msg);
+  }
+
+  // Field 6: unscoped_id
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(6, unscoped_id_, msg);
+  }
+
+  // Field 10: local_id
+  if (_has_field_[10]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(10, local_id_, msg);
+  }
+
+  // Field 11: global_id
+  if (_has_field_[11]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(11, global_id_, msg);
+  }
+
+  // Field 7: id_scope
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeString(7, id_scope_, msg);
+  }
+
+  // Field 9: use_async_tts
+  if (_has_field_[9]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(9, use_async_tts_, msg);
+  }
+
+  // Field 8: bind_id
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(8, bind_id_, msg);
+  }
+
+  // Field 12: bind_to_enclosing
+  if (_has_field_[12]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(12, bind_to_enclosing_, msg);
+  }
+
+  // Field 13: flow_direction
+  if (_has_field_[13]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(13, flow_direction_, msg);
+  }
+
+  // Field 14: instant_event_scope
+  if (_has_field_[14]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(14, instant_event_scope_, msg);
+  }
+
+  // Field 18: pid_override
+  if (_has_field_[18]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(18, pid_override_, msg);
+  }
+
+  // Field 19: tid_override
+  if (_has_field_[19]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(19, tid_override_, msg);
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
+
+
+TrackEvent_Callstack::TrackEvent_Callstack() = default;
+TrackEvent_Callstack::~TrackEvent_Callstack() = default;
+TrackEvent_Callstack::TrackEvent_Callstack(const TrackEvent_Callstack&) = default;
+TrackEvent_Callstack& TrackEvent_Callstack::operator=(const TrackEvent_Callstack&) = default;
+TrackEvent_Callstack::TrackEvent_Callstack(TrackEvent_Callstack&&) noexcept = default;
+TrackEvent_Callstack& TrackEvent_Callstack::operator=(TrackEvent_Callstack&&) = default;
+
+bool TrackEvent_Callstack::operator==(const TrackEvent_Callstack& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(frames_, other.frames_);
+}
+
+int TrackEvent_Callstack::frames_size() const { return static_cast<int>(frames_.size()); }
+void TrackEvent_Callstack::clear_frames() { frames_.clear(); }
+TrackEvent_Callstack_Frame* TrackEvent_Callstack::add_frames() { frames_.emplace_back(); return &frames_.back(); }
+bool TrackEvent_Callstack::ParseFromArray(const void* raw, size_t size) {
+  frames_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* frames */:
+        frames_.emplace_back();
+        frames_.back().ParseFromArray(field.data(), field.size());
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
+
+std::string TrackEvent_Callstack::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> TrackEvent_Callstack::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void TrackEvent_Callstack::Serialize(::protozero::Message* msg) const {
+  // Field 1: frames
+  for (auto& it : frames_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
+
+
+TrackEvent_Callstack_Frame::TrackEvent_Callstack_Frame() = default;
+TrackEvent_Callstack_Frame::~TrackEvent_Callstack_Frame() = default;
+TrackEvent_Callstack_Frame::TrackEvent_Callstack_Frame(const TrackEvent_Callstack_Frame&) = default;
+TrackEvent_Callstack_Frame& TrackEvent_Callstack_Frame::operator=(const TrackEvent_Callstack_Frame&) = default;
+TrackEvent_Callstack_Frame::TrackEvent_Callstack_Frame(TrackEvent_Callstack_Frame&&) noexcept = default;
+TrackEvent_Callstack_Frame& TrackEvent_Callstack_Frame::operator=(TrackEvent_Callstack_Frame&&) = default;
+
+bool TrackEvent_Callstack_Frame::operator==(const TrackEvent_Callstack_Frame& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(function_name_, other.function_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(source_file_, other.source_file_)
+   && ::protozero::internal::gen_helpers::EqualsField(line_number_, other.line_number_);
+}
+
+bool TrackEvent_Callstack_Frame::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* function_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &function_name_);
+        break;
+      case 2 /* source_file */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &source_file_);
+        break;
+      case 3 /* line_number */:
+        field.get(&line_number_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
+
+std::string TrackEvent_Callstack_Frame::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> TrackEvent_Callstack_Frame::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void TrackEvent_Callstack_Frame::Serialize(::protozero::Message* msg) const {
+  // Field 1: function_name
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeString(1, function_name_, msg);
+  }
+
+  // Field 2: source_file
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeString(2, source_file_, msg);
+  }
+
+  // Field 3: line_number
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, line_number_, msg);
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
+
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/common/semantic_type.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/android_game_intervention_list_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/android_input_event_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/android_log_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/android_polled_state_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/android_sdk_sysprop_guard_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/android_system_property_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/app_wakelock_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/cpu_per_uid_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/inputmethod_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/kernel_wakelocks_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/network_trace_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/packages_list_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/pixel_modem_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/protolog_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/surfaceflinger_layers_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/surfaceflinger_transactions_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/user_list_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/windowmanager_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/ftrace/frozen_ftrace_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/ftrace/ftrace_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/gpu/gpu_counter_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/gpu/gpu_renderstages_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/gpu/vulkan_memory_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/inode_file/inode_file_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/interceptors/console_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/power/android_power_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/priority_boost/priority_boost_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/process_stats/process_stats_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/profiling/heapprofd_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/profiling/java_hprof_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/profiling/perf_event_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/protovm/protovm_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/qnx/qnx_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/statsd/atom_ids.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/statsd/statsd_tracing_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/sys_stats/sys_stats_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/system_info/system_info_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/track_event/track_event_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/chrome/chrome_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/chrome/histogram_samples.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/chrome/scenario_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/chrome/system_metrics.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/chrome/v8_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/data_source_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/etw/etw_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/interceptor_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/stress_test_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/test_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/trace_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/clock_snapshot.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/trace_uuid.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/trigger.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/etw/etw.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/etw/etw_event.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/etw/etw_event_bundle.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/filesystem/inode_file_map.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/ftrace_event.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/ftrace_event_bundle.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/ftrace_stats.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/test_bundle_wrapper.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/generic.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/android_fs.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/bcl_exynos.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/binder.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/block.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/cgroup.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/clk.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/cma.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/compaction.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/cpm_trace.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/cpuhp.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/cros_ec.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/dcvsh.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/devfreq.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/dma_fence.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/dmabuf_heap.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/dpu.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/drm.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/dwc3.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/ext4.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/f2fs.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/fastrpc.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/fence.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/filemap.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/fs.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/ftrace.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/fwtp_ftrace.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/g2d.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/google_icc_trace.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/google_irm_trace.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/gpu_mem.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/gpu_scheduler.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/hyp.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/hypervisor.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/i2c.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/ion.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/ipi.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/irq.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/irq_vectors.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/kgsl.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/kmem.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/kvm.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/lowmemorykiller.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/lwis.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/mali.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/mdss.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/mm_event.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/net.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/oom.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/panel.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/perf_trace_counters.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/pixel_mm.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/power.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/printk.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/raw_syscalls.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/regulator.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/rpm.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/samsung.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/sched.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/scm.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/scsi.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/sde.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/signal.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/skb.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/sock.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/sync.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/synthetic.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/systrace.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/task.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/tcp.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/thermal.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/thermal_exynos.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/timer.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/trusty.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/ufs.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/v4l2.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/virtio_gpu.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/virtio_video.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/vmscan.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/workqueue.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/generic_kernel/generic_power.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/generic_kernel/generic_task.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/perfetto/perfetto_metatrace.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/perfetto/trace_provenance.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/perfetto/tracing_service_event.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/power/android_energy_estimation_breakdown.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/power/android_entity_state_residency.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/power/battery_counters.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/power/power_rails.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ps/process_stats.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ps/process_tree.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/statsd/statsd_atom.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/sys_stats/sys_stats.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/system_info/cpu_info.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/translation/translation_table.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/remote_clock_sync.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/trace_packet_defaults.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/test_event.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/test_extensions.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/trace_packet.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/trace.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/extension_descriptor.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/memory_graph.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ui_state.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/evdev.pbzero.cc
+// Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: src/tracing/trace_writer_base.cc
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "perfetto/tracing/trace_writer_base.h"
+
+namespace perfetto {
+
+// This destructor needs to be defined in a dedicated translation unit and
+// cannot be merged together with the other ones in virtual_destructors.cc.
+// This is because trace_writer_base.h/cc  is part of a separate target
+// (src/public:common) that is linked also by other part of the codebase.
+
+TraceWriterBase::~TraceWriterBase() = default;
+
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/core/id_allocator.cc
+// gen_amalgamated begin header: src/tracing/core/id_allocator.h
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SRC_TRACING_CORE_ID_ALLOCATOR_H_
+#define SRC_TRACING_CORE_ID_ALLOCATOR_H_
+
+#include <stdint.h>
+
+#include <cstddef>
+#include <type_traits>
+#include <vector>
+
+namespace perfetto {
+
+// Handles assignment of IDs (int types) from a fixed-size pool.
+// Zero is not considered a valid ID.
+// The base class takes always a uint32_t and the derived class casts and checks
+// bounds at compile time. This is to avoid bloating code with different
+// instances of the main class for each size.
+class IdAllocatorGeneric {
+ public:
+  // |max_id| is inclusive.
+  explicit IdAllocatorGeneric(uint32_t max_id);
+  ~IdAllocatorGeneric();
+
+  // Returns an ID in the range [1, max_id] or 0 if no more ids are available.
+  uint32_t AllocateGeneric();
+  void FreeGeneric(uint32_t);
+
+  bool IsEmpty() const;
+
+ private:
+  IdAllocatorGeneric(const IdAllocatorGeneric&) = delete;
+  IdAllocatorGeneric& operator=(const IdAllocatorGeneric&) = delete;
+
+  const uint32_t max_id_;
+  uint32_t last_id_ = 0;
+  std::vector<bool> ids_;
+};
+
+template <typename T = uint32_t>
+class IdAllocator : public IdAllocatorGeneric {
+ public:
+  explicit IdAllocator(T end) : IdAllocatorGeneric(end) {
+    static_assert(std::is_integral<T>::value && std::is_unsigned<T>::value,
+                  "T must be an unsigned integer");
+    static_assert(sizeof(T) <= sizeof(uint32_t), "T is too big");
+  }
+
+  T Allocate() { return static_cast<T>(AllocateGeneric()); }
+
+  // Tries to allocate `n` IDs. Returns a vector of `n` valid IDs or an empty
+  // vector, if not enough IDs are available.
+  std::vector<T> AllocateMultiple(size_t n) {
+    std::vector<T> res;
+    res.reserve(n);
+    for (size_t i = 0; i < n; i++) {
+      T id = Allocate();
+      if (id) {
+        res.push_back(id);
+      } else {
+        for (T free_id : res) {
+          Free(free_id);
+        }
+        return {};
+      }
+    }
+    return res;
+  }
+
+  void Free(T id) { FreeGeneric(id); }
+};
+
+}  // namespace perfetto
+
+#endif  // SRC_TRACING_CORE_ID_ALLOCATOR_H_
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "src/tracing/core/id_allocator.h"
+
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+
+namespace perfetto {
+
+IdAllocatorGeneric::IdAllocatorGeneric(uint32_t max_id) : max_id_(max_id) {
+  PERFETTO_DCHECK(max_id > 1);
+}
+
+IdAllocatorGeneric::~IdAllocatorGeneric() = default;
+
+uint32_t IdAllocatorGeneric::AllocateGeneric() {
+  for (uint32_t ignored = 1; ignored <= max_id_; ignored++) {
+    last_id_ = last_id_ < max_id_ ? last_id_ + 1 : 1;
+    const auto id = last_id_;
+
+    // 0 is never a valid ID. So if we are looking for |id| == N and there are
+    // N or less elements in the vector, they must necessarily be all < N.
+    // e.g. if |id| == 4 and size() == 4, the vector will contain IDs 0,1,2,3.
+    if (id >= ids_.size()) {
+      ids_.resize(id + 1);
+      ids_[id] = true;
+      return id;
+    }
+
+    if (!ids_[id]) {
+      ids_[id] = true;
+      return id;
+    }
+  }
+  return 0;
+}
+
+void IdAllocatorGeneric::FreeGeneric(uint32_t id) {
+  if (id == 0 || id >= ids_.size() || !ids_[id]) {
+    PERFETTO_DFATAL("Invalid id.");
+    return;
+  }
+  ids_[id] = false;
+}
+
+bool IdAllocatorGeneric::IsEmpty() const {
+  for (auto id : ids_) {
+    if (id)
+      return false;
+  }
+  return true;
+}
+
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/core/in_process_shared_memory.cc
+// gen_amalgamated begin header: src/tracing/core/in_process_shared_memory.h
+// gen_amalgamated begin header: include/perfetto/ext/tracing/core/shared_memory.h
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_SHARED_MEMORY_H_
+#define INCLUDE_PERFETTO_EXT_TRACING_CORE_SHARED_MEMORY_H_
+
+#include <stddef.h>
+
+#include <memory>
+#include <utility>
+
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/base/platform_handle.h"
+
+namespace perfetto {
+
+// An abstract interface that models the shared memory region shared between
+// Service and Producer. The concrete implementation of this is up to the
+// transport layer. This can be as simple as a malloc()-ed buffer, if both
+// Producer and Service are hosted in the same process, or some posix shared
+// memory for the out-of-process case (see src/unix_rpc).
+// Both this class and the Factory are subclassed by the transport layer, which
+// will attach platform specific fields to it (e.g., a unix file descriptor).
+class PERFETTO_EXPORT_COMPONENT SharedMemory {
+ public:
+  class PERFETTO_EXPORT_COMPONENT Factory {
+   public:
+    virtual ~Factory();
+    virtual std::unique_ptr<SharedMemory> CreateSharedMemory(size_t) = 0;
+  };
+
+  // The transport layer is expected to tear down the resource associated to
+  // this object region when destroyed.
+  virtual ~SharedMemory();
+
+  // Read/write and read-only access to underlying buffer. The non-const method
+  // is implemented in terms of the const one so subclasses need only provide a
+  // single implementation; implementing in the opposite order would be unsafe
+  // since subclasses could effectively mutate state from inside a const method.
+  //
+  // N.B. This signature implements "deep const" that ties the constness of this
+  // object to the constness of the underlying buffer, as opposed to "shallow
+  // const" that would have the signature `void* start() const;`; this is less
+  // flexible for callers but prevents corner cases where it's transitively
+  // possible to change this object's state via the controlled memory.
+  void* start() { return const_cast<void*>(std::as_const(*this).start()); }
+  virtual const void* start() const = 0;
+
+  virtual size_t size() const = 0;
+};
+
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_SHARED_MEMORY_H_
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SRC_TRACING_CORE_IN_PROCESS_SHARED_MEMORY_H_
+#define SRC_TRACING_CORE_IN_PROCESS_SHARED_MEMORY_H_
+
+#include <memory>
+
+// gen_amalgamated expanded: #include "perfetto/ext/base/paged_memory.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory.h"
+
+namespace perfetto {
+
+// An implementation of the ShareMemory interface that allocates memory that can
+// only be shared intra-process.
+class InProcessSharedMemory : public SharedMemory {
+ public:
+  static constexpr size_t kDefaultSize = 128 * 1024;
+  static constexpr size_t kShmemEmulationSize = 1024 * 1024;
+
+  // Default ctor used for intra-process shmem between a producer and the
+  // service.
+  explicit InProcessSharedMemory(size_t size)
+      : mem_(base::PagedMemory::Allocate(size)) {}
+  ~InProcessSharedMemory() override;
+
+  static std::unique_ptr<InProcessSharedMemory> Create(
+      size_t size = kDefaultSize) {
+    return std::make_unique<InProcessSharedMemory>(size);
+  }
+
+  // SharedMemory implementation.
+  using SharedMemory::start;  // Equal priority to const and non-const versions
+  const void* start() const override;
+  size_t size() const override;
+
+  class Factory : public SharedMemory::Factory {
+   public:
+    ~Factory() override;
+    std::unique_ptr<SharedMemory> CreateSharedMemory(size_t size) override {
+      return InProcessSharedMemory::Create(size);
+    }
+  };
+
+ private:
+  base::PagedMemory mem_;
+};
+
+}  // namespace perfetto
+
+#endif  // SRC_TRACING_CORE_IN_PROCESS_SHARED_MEMORY_H_
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "src/tracing/core/in_process_shared_memory.h"
+
+namespace perfetto {
+
+InProcessSharedMemory::~InProcessSharedMemory() = default;
+InProcessSharedMemory::Factory::~Factory() = default;
+
+const void* InProcessSharedMemory::start() const {
+  return mem_.Get();
+}
+size_t InProcessSharedMemory::size() const {
+  return mem_.size();
+}
+
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/core/null_trace_writer.cc
+// gen_amalgamated begin header: src/tracing/core/null_trace_writer.h
+// gen_amalgamated begin header: include/perfetto/ext/tracing/core/basic_types.h
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_BASIC_TYPES_H_
+#define INCLUDE_PERFETTO_EXT_TRACING_CORE_BASIC_TYPES_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/ext/base/sys_types.h"
+
+namespace perfetto {
+
+// Unique within the scope of the tracing service.
+using TracingSessionID = uint64_t;
+
+// Unique within the scope of the tracing service.
+using ProducerID = uint16_t;
+
+// Unique within the scope of the tracing service.
+using DataSourceInstanceID = uint64_t;
+
+// Unique within the scope of a Producer.
+using WriterID = uint16_t;
+
+// Unique within the scope of the tracing service.
+using FlushRequestID = uint64_t;
+
+// Combines Producer and Writer ID in one word which can be used as key for
+// hashtables and other data structures.
+using ProducerAndWriterID = uint32_t;
+
+using PendingCloneID = uint64_t;
+
+inline ProducerAndWriterID MkProducerAndWriterID(ProducerID p, WriterID w) {
+  static_assert(
+      sizeof(ProducerID) + sizeof(WriterID) == sizeof(ProducerAndWriterID),
+      "MkProducerAndWriterID() and GetProducerAndWriterID() need updating");
+  return (static_cast<ProducerAndWriterID>(p) << (sizeof(WriterID) * 8)) | w;
+}
+
+inline void GetProducerAndWriterID(ProducerAndWriterID x,
+                                   ProducerID* p,
+                                   WriterID* w) {
+  static constexpr auto mask = (1ull << (sizeof(WriterID) * 8)) - 1;
+  *w = static_cast<WriterID>(x & mask);
+  *p = static_cast<ProducerID>(x >> (sizeof(WriterID) * 8));
+}
+
+// We need one FD per producer and we are not going to be able to keep > 64k FDs
+// open in the service.
+static constexpr ProducerID kMaxProducerID = static_cast<ProducerID>(-1);
+
+// 32k Writers per producer seems a resonable bound. This reduces the ability
+// to memory-DoS the service by having to keep track of too many writer IDs,
+// but enough to run certain known benchmark workloads.
+static constexpr WriterID kMaxWriterID = static_cast<WriterID>((1 << 15) - 1);
+
+// Unique within the scope of a {ProducerID, WriterID} tuple.
+using ChunkID = uint32_t;
+static constexpr ChunkID kMaxChunkID = static_cast<ChunkID>(-1);
+
+// Unique within the scope of the tracing service.
+using BufferID = uint16_t;
+
+// Target buffer ID for SharedMemoryArbiter. Values up to max uint16_t are
+// equivalent to a bound BufferID. Values above max uint16_t are reservation IDs
+// for the target buffer of a startup trace writer. Reservation IDs will be
+// translated to actual BufferIDs after they are bound by
+// SharedMemoryArbiter::BindStartupTargetBuffer().
+// TODO(mohitms): Delete this type and use `struct {uint16 ; uint16;}` instead.
+using MaybeUnboundBufferID = uint32_t;
+
+// Keep this in sync with SharedMemoryABI::PageHeader::target_buffer.
+static constexpr BufferID kMaxTraceBufferID = static_cast<BufferID>(-1);
+
+// Unique within the scope of a tracing session.
+using PacketSequenceID = uint32_t;
+// Used for extra packets emitted by the service, such as statistics.
+static constexpr PacketSequenceID kServicePacketSequenceID = 1;
+static constexpr PacketSequenceID kMaxPacketSequenceID =
+    static_cast<PacketSequenceID>(-1);
+
+constexpr uint32_t kDefaultFlushTimeoutMs = 5000;
+
+// The special id 0xffff..ffff represents the tracing session with the highest
+// bugreport score. This is used for CloneSession(kBugreportSessionId).
+constexpr TracingSessionID kBugreportSessionId =
+    static_cast<TracingSessionID>(-1);
+
+// The ID of a machine in a multi-machine tracing session.
+using MachineID = base::MachineID;
+constexpr MachineID kDefaultMachineID = base::kDefaultMachineID;
+
+constexpr uint32_t kDataSourceStopTimeoutMs = 5000;
+
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_BASIC_TYPES_H_
+// gen_amalgamated begin header: include/perfetto/ext/tracing/core/trace_writer.h
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACE_WRITER_H_
+#define INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACE_WRITER_H_
+
+#include <functional>
+
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message_handle.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/trace_writer_base.h"
+
+namespace perfetto {
+
+namespace protos {
+namespace pbzero {
+class TracePacket;
+}  // namespace pbzero
+}  // namespace protos
+
+// See comments in include/perfetto/tracing/trace_writer_base.h
+class PERFETTO_EXPORT_COMPONENT TraceWriter : public TraceWriterBase {
+ public:
+  using TracePacketHandle =
+      protozero::MessageHandle<protos::pbzero::TracePacket>;
+
+  TraceWriter();
+  ~TraceWriter() override;
+
+  virtual WriterID writer_id() const = 0;
+
+ private:
+  TraceWriter(const TraceWriter&) = delete;
+  TraceWriter& operator=(const TraceWriter&) = delete;
+};
+
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACE_WRITER_H_
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SRC_TRACING_CORE_NULL_TRACE_WRITER_H_
+#define SRC_TRACING_CORE_NULL_TRACE_WRITER_H_
+
+#include <cstdint>
+#include <functional>
+#include <memory>
+
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/root_message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_stream_null_delegate.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_stream_writer.h"
+
+namespace perfetto {
+
+// A specialization of TraceWriter which no-ops all the writes routing them
+// into a fixed region of memory
+// See //include/perfetto/ext/tracing/core/trace_writer.h for docs.
+class NullTraceWriter : public TraceWriter {
+ public:
+  NullTraceWriter();
+  ~NullTraceWriter() override;
+
+  // TraceWriter implementation. See documentation in trace_writer.h.
+  // TracePacketHandle is defined in trace_writer.h
+  TracePacketHandle NewTracePacket() override;
+  void FinishTracePacket() override;
+  void Flush(std::function<void()> callback = {}) override;
+  WriterID writer_id() const override;
+  uint64_t written() const override;
+  uint64_t drop_count() const override;
+
+ private:
+  NullTraceWriter(const NullTraceWriter&) = delete;
+  NullTraceWriter& operator=(const NullTraceWriter&) = delete;
+
+  protozero::ScatteredStreamWriterNullDelegate delegate_;
+  protozero::ScatteredStreamWriter stream_;
+
+  // The packet returned via NewTracePacket(). It is owned by this class,
+  // TracePacketHandle has just a pointer to it.
+  std::unique_ptr<protozero::RootMessage<protos::pbzero::TracePacket>>
+      cur_packet_;
+};
+
+}  // namespace perfetto
+
+#endif  // SRC_TRACING_CORE_NULL_TRACE_WRITER_H_
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "src/tracing/core/null_trace_writer.h"
+
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+
+// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h"
+
+namespace perfetto {
+
+NullTraceWriter::NullTraceWriter() : delegate_(4096), stream_(&delegate_) {
+  cur_packet_.reset(new protozero::RootMessage<protos::pbzero::TracePacket>());
+  cur_packet_->Finalize();  // To avoid the DCHECK in NewTracePacket().
+}
+
+NullTraceWriter::~NullTraceWriter() {}
+
+void NullTraceWriter::Flush(std::function<void()> callback) {
+  // Flush() cannot be called in the middle of a TracePacket.
+  PERFETTO_CHECK(cur_packet_->is_finalized());
+
+  if (callback)
+    callback();
+}
+
+NullTraceWriter::TracePacketHandle NullTraceWriter::NewTracePacket() {
+  // If we hit this, the caller is calling NewTracePacket() without having
+  // finalized the previous packet.
+  PERFETTO_DCHECK(cur_packet_->is_finalized());
+  cur_packet_->Reset(&stream_);
+  return TraceWriter::TracePacketHandle(cur_packet_.get());
+}
+
+void NullTraceWriter::FinishTracePacket() {
+  cur_packet_->Finalize();
+}
+
+WriterID NullTraceWriter::writer_id() const {
+  return 0;
+}
+
+uint64_t NullTraceWriter::written() const {
+  return 0;
+}
+
+uint64_t NullTraceWriter::drop_count() const {
+  return 0;
+}
+
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/core/shared_memory_abi.cc
+// gen_amalgamated begin header: include/perfetto/ext/tracing/core/shared_memory_abi.h
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_SHARED_MEMORY_ABI_H_
+#define INCLUDE_PERFETTO_EXT_TRACING_CORE_SHARED_MEMORY_ABI_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <array>
+#include <atomic>
+#include <bitset>
+#include <thread>
+#include <type_traits>
+#include <utility>
+
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+
+// This file defines the binary interface of the memory buffers shared between
+// Producer and Service. This is a long-term stable ABI and has to be backwards
+// compatible to deal with mismatching Producer and Service versions.
+//
+// Overview
+// --------
+// SMB := "Shared Memory Buffer".
+// In the most typical case of a multi-process architecture (i.e. Producer and
+// Service are hosted by different processes), a Producer means almost always
+// a "client process producing data" (almost: in some cases a process might host
+// > 1 Producer, if it links two libraries, independent of each other, that both
+// use Perfetto tracing).
+// The Service has one SMB for each Producer.
+// A producer has one or (typically) more data sources. They all share the same
+// SMB.
+// The SMB is a staging area to decouple data sources living in the Producer
+// and allow them to do non-blocking async writes.
+// The SMB is *not* the ultimate logging buffer seen by the Consumer. That one
+// is larger (~MBs) and not shared with Producers.
+// Each SMB is small, typically few KB. Its size is configurable by the producer
+// within a max limit of ~MB (see kMaxShmSize in tracing_service_impl.cc).
+// The SMB is partitioned into fixed-size Page(s). The size of the Pages are
+// determined by each Producer at connection time and cannot be changed.
+// Hence, different producers can have SMB(s) that have a different Page size
+// from each other, but the page size will be constant throughout all the
+// lifetime of the SMB.
+// Page(s) are partitioned by the Producer into variable size Chunk(s):
+//
+// +------------+      +--------------------------+
+// | Producer 1 |  <-> |      SMB 1 [~32K - 1MB]  |
+// +------------+      +--------+--------+--------+
+//                     |  Page  |  Page  |  Page  |
+//                     +--------+--------+--------+
+//                     | Chunk  |        | Chunk  |
+//                     +--------+  Chunk +--------+ <----+
+//                     | Chunk  |        | Chunk  |      |
+//                     +--------+--------+--------+      +---------------------+
+//                                                       |       Service       |
+// +------------+      +--------------------------+      +---------------------+
+// | Producer 2 |  <-> |      SMB 2 [~32K - 1MB]  |     /| large ring buffers  |
+// +------------+      +--------+--------+--------+ <--+ | (100K - several MB) |
+//                     |  Page  |  Page  |  Page  |      +---------------------+
+//                     +--------+--------+--------+
+//                     | Chunk  |        | Chunk  |
+//                     +--------+  Chunk +--------+
+//                     | Chunk  |        | Chunk  |
+//                     +--------+--------+--------+
+//
+// * Sizes of both SMB and ring buffers are purely indicative and decided at
+// configuration time by the Producer (for SMB sizes) and the Consumer (for the
+// final ring buffer size).
+
+// Page
+// ----
+// A page is a portion of the shared memory buffer and defines the granularity
+// of the interaction between the Producer and tracing Service. When scanning
+// the shared memory buffer to determine if something should be moved to the
+// central logging buffers, the Service most of the times looks at and moves
+// whole pages. Similarly, the Producer sends an IPC to invite the Service to
+// drain the shared memory buffer only when a whole page is filled.
+// Having fixed the total SMB size (hence the total memory overhead), the page
+// size is a triangular tradeoff between:
+// 1) IPC traffic: smaller pages -> more IPCs.
+// 2) Producer lock freedom: larger pages -> larger chunks -> data sources can
+//    write more data without needing to swap chunks and synchronize.
+// 3) Risk of write-starving the SMB: larger pages -> higher chance that the
+//    Service won't manage to drain them and the SMB remains full.
+// The page size, on the other side, has no implications on wasted memory due to
+// fragmentations (see Chunk below).
+// The size of the page is chosen by the Service at connection time and stays
+// fixed throughout all the lifetime of the Producer. Different producers (i.e.
+// ~ different client processes) can use different page sizes.
+// The page size must be an integer multiple of 4k (this is to allow VM page
+// stealing optimizations) and obviously has to be an integer divisor of the
+// total SMB size.
+
+// Chunk
+// -----
+// A chunk is a portion of a Page which is written and handled by a Producer.
+// A chunk contains a linear sequence of TracePacket(s) (the root proto).
+// A chunk cannot be written concurrently by two data sources. Protobufs must be
+// encoded as contiguous byte streams and cannot be interleaved. Therefore, on
+// the Producer side, a chunk is almost always owned exclusively by one thread
+// (% extremely peculiar slow-path cases).
+// Chunks are essentially single-writer single-thread lock-free arenas. Locking
+// happens only when a Chunk is full and a new one needs to be acquired.
+// Locking happens only within the scope of a Producer process. There is no
+// inter-process locking. The Producer cannot lock the Service and viceversa.
+// In the worst case, any of the two can starve the SMB, by marking all chunks
+// as either being read or written. But that has the only side effect of
+// losing the trace data.
+// The Producer can decide to partition each page into a number of limited
+// configurations (e.g., 1 page == 1 chunk, 1 page == 2 chunks and so on).
+
+// TracePacket
+// -----------
+// Is the atom of tracing. Putting aside pages and chunks a trace is merely a
+// sequence of TracePacket(s). TracePacket is the root protobuf message.
+// A TracePacket can span across several chunks (hence even across several
+// pages). A TracePacket can therefore be >> chunk size, >> page size and even
+// >> SMB size. The Chunk header carries metadata to deal with the TracePacket
+// splitting case.
+
+// Use only explicitly-sized types below. DO NOT use size_t or any architecture
+// dependent size (e.g. size_t) in the struct fields. This buffer will be read
+// and written by processes that have a different bitness in the same OS.
+// Instead it's fine to assume little-endianess. Big-endian is a dream we are
+// not currently pursuing.
+
+class SharedMemoryABI {
+ public:
+  static constexpr size_t kMinPageSize = 4 * 1024;
+
+  // This is due to Chunk::size being 16 bits.
+  static constexpr size_t kMaxPageSize = 64 * 1024;
+
+  // "14" is the max number that can be encoded in a 32 bit atomic word using
+  // 2 state bits per Chunk and leaving 4 bits for the page layout.
+  // See PageLayout below.
+  static constexpr size_t kMaxChunksPerPage = 14;
+
+  // Each TracePacket fragment in the Chunk is prefixed by a VarInt stating its
+  // size that is up to 4 bytes long. Since the size is often known after the
+  // fragment has been filled, the VarInt is often redundantly encoded (see
+  // proto_utils.h) to be exactly 4 bytes.
+  static constexpr size_t kPacketHeaderSize = 4;
+
+  // TraceWriter specifies this invalid packet/fragment size to signal to the
+  // service that a packet should be discarded, because the TraceWriter couldn't
+  // write its remaining fragments (e.g. because the SMB was exhausted).
+  static constexpr size_t kPacketSizeDropPacket =
+      protozero::proto_utils::kMaxMessageLength;
+
+  // Chunk states and transitions:
+  //    kChunkFree  <----------------+
+  //         |  (Producer)           |
+  //         V                       |
+  //  kChunkBeingWritten             |
+  //         |  (Producer)           |
+  //         V                       |
+  //  kChunkComplete                 |
+  //         |  (Service)            |
+  //         V                       |
+  //  kChunkBeingRead                |
+  //        |   (Service)            |
+  //        +------------------------+
+  //
+  // The ABI has an "emulation mode" for transports where shared memory isn't
+  // supported. In this mode, kChunkBeingRead is skipped. A chunk in the
+  // kChunkComplete state is released as free after the producer serializes
+  // chunk content to the protobuf message.
+  enum ChunkState : uint32_t {
+    // The Chunk is free. The Service shall never touch it, the Producer can
+    // acquire it and transition it into kChunkBeingWritten.
+    kChunkFree = 0,
+
+    // The Chunk is being used by the Producer and is not complete yet.
+    // The Service shall never touch kChunkBeingWritten pages.
+    kChunkBeingWritten = 1,
+
+    // The Service is moving the page into its non-shared ring buffer. The
+    // Producer shall never touch kChunkBeingRead pages.
+    kChunkBeingRead = 2,
+
+    // The Producer is done writing the page and won't touch it again. The
+    // Service can now move it to its non-shared ring buffer.
+    // kAllChunksComplete relies on this being == 3.
+    kChunkComplete = 3,
+  };
+  static constexpr const char* kChunkStateStr[] = {"Free", "BeingWritten",
+                                                   "BeingRead", "Complete"};
+
+  enum PageLayout : uint32_t {
+    // The page is fully free and has not been partitioned yet.
+    kPageNotPartitioned = 0,
+
+    // TODO(primiano): Aligning a chunk @ 16 bytes could allow to use faster
+    // intrinsics based on quad-word moves. Do the math and check what is the
+    // fragmentation loss.
+
+    // align4(X) := the largest integer N s.t. (N % 4) == 0 && N <= X.
+    // 8 == sizeof(PageHeader).
+    kPageDiv1 = 1,   // Only one chunk of size: PAGE_SIZE - 8.
+    kPageDiv2 = 2,   // Two chunks of size: align4((PAGE_SIZE - 8) / 2).
+    kPageDiv4 = 3,   // Four chunks of size: align4((PAGE_SIZE - 8) / 4).
+    kPageDiv7 = 4,   // Seven chunks of size: align4((PAGE_SIZE - 8) / 7).
+    kPageDiv14 = 5,  // Fourteen chunks of size: align4((PAGE_SIZE - 8) / 14).
+
+    // The rationale for 7 and 14 above is to maximize the page usage for the
+    // likely case of |page_size| == 4096:
+    // (((4096 - 8) / 14) % 4) == 0, while (((4096 - 8) / 16 % 4)) == 3. So
+    // Div16 would waste 3 * 16 = 48 bytes per page for chunk alignment gaps.
+
+    kPageDivReserved1 = 6,
+    kPageDivReserved2 = 7,
+    kNumPageLayouts = 8,
+  };
+
+  // Keep this consistent with the PageLayout enum above.
+  static constexpr uint32_t kNumChunksForLayout[] = {0, 1, 2, 4, 7, 14, 0, 0};
+
+  enum class ShmemMode {
+    // The default mode, where the shared buffer is visible to both the producer
+    // and the service.
+    kDefault,
+
+    // The emulation mode, used for producer ports without shared memory. The
+    // state transitions are all done in the producer process.
+    kShmemEmulation,
+  };
+
+  // Layout of a Page.
+  // +===================================================+
+  // | Page header [8 bytes]                             |
+  // | Tells how many chunks there are, how big they are |
+  // | and their state (free, read, write, complete).    |
+  // +===================================================+
+  // +***************************************************+
+  // | Chunk #0 header [8 bytes]                         |
+  // | Tells how many packets there are and whether the  |
+  // | whether the 1st and last ones are fragmented.     |
+  // | Also has a chunk id to reassemble fragments.    |
+  // +***************************************************+
+  // +---------------------------------------------------+
+  // | Packet #0 size [varint, up to 4 bytes]            |
+  // + - - - - - - - - - - - - - - - - - - - - - - - - - +
+  // | Packet #0 payload                                 |
+  // | A TracePacket protobuf message                    |
+  // +---------------------------------------------------+
+  //                         ...
+  // + . . . . . . . . . . . . . . . . . . . . . . . . . +
+  // |      Optional padding to maintain aligment        |
+  // + . . . . . . . . . . . . . . . . . . . . . . . . . +
+  // +---------------------------------------------------+
+  // | Packet #N size [varint, up to 4 bytes]            |
+  // + - - - - - - - - - - - - - - - - - - - - - - - - - +
+  // | Packet #N payload                                 |
+  // | A TracePacket protobuf message                    |
+  // +---------------------------------------------------+
+  //                         ...
+  // +***************************************************+
+  // | Chunk #M header [8 bytes]                         |
+  //                         ...
+
+  // Alignment applies to start offset only. The Chunk size is *not* aligned.
+  static constexpr uint32_t kChunkAlignment = 4;
+  static constexpr uint32_t kChunkShift = 2;
+  static constexpr uint32_t kChunkMask = 0x3;
+  static constexpr uint32_t kLayoutMask = 0x70000000;
+  static constexpr uint32_t kLayoutShift = 28;
+  static constexpr uint32_t kAllChunksMask = 0x0FFFFFFF;
+
+  // This assumes that kChunkComplete == 3.
+  static constexpr uint32_t kAllChunksComplete = 0x0FFFFFFF;
+  static constexpr uint32_t kAllChunksFree = 0;
+  static constexpr size_t kInvalidPageIdx = static_cast<size_t>(-1);
+
+  // There is one page header per page, at the beginning of the page.
+  struct PageHeader {
+    // |header_bitmap| bits:
+    // [31] [30:28] [27:26] ... [1:0]
+    //  |      |       |     |    |
+    //  |      |       |     |    +---------- ChunkState[0]
+    //  |      |       |     +--------------- ChunkState[12..1]
+    //  |      |       +--------------------- ChunkState[13]
+    //  |      +----------------------------- PageLayout (0 == page fully free)
+    //  +------------------------------------ Reserved for future use
+    std::atomic<uint32_t> header_bitmap;
+
+    // If we'll ever going to use this in the future it might come handy
+    // reviving the kPageBeingPartitioned logic (look in git log, it was there
+    // at some point in the past).
+    uint32_t reserved;
+  };
+
+  // There is one Chunk header per chunk (hence PageLayout per page) at the
+  // beginning of each chunk.
+  struct ChunkHeader {
+    inline static constexpr uint8_t kFlagsMask = 0x7;
+    enum Flags : uint8_t {
+      // If set, the first TracePacket in the chunk is partial and continues
+      // from |chunk_id| - 1 (within the same |writer_id|).
+      kFirstPacketContinuesFromPrevChunk = 1 << 0,
+
+      // If set, the last TracePacket in the chunk is partial and continues on
+      // |chunk_id| + 1 (within the same |writer_id|).
+      kLastPacketContinuesOnNextChunk = 1 << 1,
+
+      // If set, the last (fragmented) TracePacket in the chunk has holes (even
+      // if the chunk is marked as kChunkComplete) that need to be patched
+      // out-of-band before the chunk can be read.
+      kChunkNeedsPatching = 1 << 2,
+    };
+
+    struct Packets {
+      // Number of valid TracePacket protobuf messages contained in the chunk.
+      // Each TracePacket is prefixed by its own size. This field is
+      // monotonically updated by the Producer with release store semantic when
+      // the packet at position |count| is started. This last packet may not be
+      // considered complete until |count| is incremented for the subsequent
+      // packet or the chunk is completed.
+      uint16_t count : 10;
+      static constexpr size_t kMaxCount = (1 << 10) - 1;
+
+      // See Flags above.
+      uint16_t flags : 6;
+    };
+
+    // A monotonic counter of the chunk within the scoped of a |writer_id|.
+    // The tuple (ProducerID, WriterID, ChunkID) allows to figure out if two
+    // chunks are contiguous (and hence a trace packets spanning across them can
+    // be glued) or we had some holes due to the ring buffer wrapping.
+    // This is set only when transitioning from kChunkFree to kChunkBeingWritten
+    // and remains unchanged throughout the remaining lifetime of the chunk.
+    std::atomic<uint32_t> chunk_id;
+
+    // ID of the writer, unique within the producer.
+    // Like |chunk_id|, this is set only when transitioning from kChunkFree to
+    // kChunkBeingWritten.
+    std::atomic<uint16_t> writer_id;
+
+    // There is no ProducerID here. The service figures that out from the IPC
+    // channel, which is unspoofable.
+
+    // Updated with release-store semantics.
+    std::atomic<Packets> packets;
+  };
+
+  class Chunk {
+   public:
+    Chunk();  // Constructs an invalid chunk.
+
+    // Chunk is move-only, to document the scope of the Acquire/Release
+    // TryLock operations below.
+    Chunk(const Chunk&) = delete;
+    Chunk operator=(const Chunk&) = delete;
+    Chunk(Chunk&&) noexcept;
+    Chunk& operator=(Chunk&&);
+
+    uint8_t* begin() const { return begin_; }
+    uint8_t* end() const { return begin_ + size_; }
+
+    // Size, including Chunk header.
+    size_t size() const { return size_; }
+
+    // Begin of the first packet (or packet fragment).
+    uint8_t* payload_begin() const { return begin_ + sizeof(ChunkHeader); }
+    size_t payload_size() const {
+      PERFETTO_DCHECK(size_ >= sizeof(ChunkHeader));
+      return size_ - sizeof(ChunkHeader);
+    }
+
+    bool is_valid() const { return begin_ && size_; }
+
+    // Index of the chunk within the page [0..13] (13 comes from kPageDiv14).
+    uint8_t chunk_idx() const { return chunk_idx_; }
+
+    ChunkHeader* header() { return reinterpret_cast<ChunkHeader*>(begin_); }
+
+    uint16_t writer_id() {
+      return header()->writer_id.load(std::memory_order_relaxed);
+    }
+
+    // Returns the count of packets and the flags with acquire-load semantics.
+    std::pair<uint16_t, uint8_t> GetPacketCountAndFlags() {
+      auto packets = header()->packets.load(std::memory_order_acquire);
+      const uint16_t packets_count = packets.count;
+      const uint8_t packets_flags = packets.flags;
+      return std::make_pair(packets_count, packets_flags);
+    }
+
+    // Increases |packets.count| with release semantics (note, however, that the
+    // packet count is incremented *before* starting writing a packet). Returns
+    // the new packet count. The increment is atomic but NOT race-free (i.e. no
+    // CAS). Only the Producer is supposed to perform this increment, and it's
+    // supposed to do that in a thread-safe way (holding a lock). A Chunk cannot
+    // be shared by multiple Producer threads without locking. The packet count
+    // is cleared by TryAcquireChunk(), when passing the new header for the
+    // chunk.
+    uint16_t IncrementPacketCount() {
+      ChunkHeader* chunk_header = header();
+      auto packets = chunk_header->packets.load(std::memory_order_relaxed);
+      packets.count++;
+      chunk_header->packets.store(packets, std::memory_order_release);
+      return packets.count;
+    }
+
+    // Flags are cleared by TryAcquireChunk(), by passing the new header for
+    // the chunk, or through ClearNeedsPatchingFlag.
+    void SetFlag(ChunkHeader::Flags flag) {
+      ChunkHeader* chunk_header = header();
+      auto packets = chunk_header->packets.load(std::memory_order_relaxed);
+      packets.flags |= flag;
+      chunk_header->packets.store(packets, std::memory_order_release);
+    }
+
+    // This flag can only be cleared by the producer while it is still holding
+    // on to the chunk - i.e. while the chunk is still in state
+    // ChunkState::kChunkBeingWritten and hasn't been transitioned to
+    // ChunkState::kChunkComplete. This is ok, because the service is oblivious
+    // to the needs patching flag before the chunk is released as complete.
+    void ClearNeedsPatchingFlag() {
+      ChunkHeader* chunk_header = header();
+      auto packets = chunk_header->packets.load(std::memory_order_relaxed);
+      packets.flags &= ~ChunkHeader::kChunkNeedsPatching;
+      chunk_header->packets.store(packets, std::memory_order_release);
+    }
+
+   private:
+    friend class SharedMemoryABI;
+    Chunk(uint8_t* begin, uint16_t size, uint8_t chunk_idx);
+
+    // Don't add extra fields, keep the move operator fast.
+    uint8_t* begin_ = nullptr;
+    uint16_t size_ = 0;
+    uint8_t chunk_idx_ = 0;
+
+   public:
+    static constexpr size_t kMaxSize = 1ULL << sizeof(size_) * 8;
+  };
+
+  // Construct an instance from an existing shared memory buffer.
+  SharedMemoryABI(uint8_t* start,
+                  size_t size,
+                  size_t page_size,
+                  ShmemMode mode);
+  SharedMemoryABI();
+
+  void Initialize(uint8_t* start,
+                  size_t size,
+                  size_t page_size,
+                  ShmemMode mode);
+
+  uint8_t* start() const { return start_; }
+  uint8_t* end() const { return start_ + size_; }
+  size_t size() const { return size_; }
+  size_t page_size() const { return page_size_; }
+  size_t num_pages() const { return num_pages_; }
+  bool is_valid() { return num_pages() > 0; }
+  bool use_shmem_emulation() { return use_shmem_emulation_; }
+
+  uint8_t* page_start(size_t page_idx) {
+    PERFETTO_DCHECK(page_idx < num_pages_);
+    return start_ + page_size_ * page_idx;
+  }
+
+  PageHeader* page_header(size_t page_idx) {
+    return reinterpret_cast<PageHeader*>(page_start(page_idx));
+  }
+
+  // Returns true if the page is fully clear and has not been partitioned yet.
+  // The state of the page can change at any point after this returns (or even
+  // before). The Producer should use this only as a hint to decide out whether
+  // it should TryPartitionPage() or acquire an individual chunk.
+  bool is_page_free(size_t page_idx) {
+    return GetPageHeaderBitmap(page_idx, std::memory_order_relaxed) == 0;
+  }
+
+  // Returns true if all chunks in the page are kChunkComplete. As above, this
+  // is advisory only. The Service is supposed to use this only to decide
+  // whether to TryAcquireAllChunksForReading() or not.
+  bool is_page_complete(size_t page_idx) {
+    auto bitmap = GetPageHeaderBitmap(page_idx, std::memory_order_relaxed);
+    const uint32_t num_chunks = GetNumChunksFromHeaderBitmap(bitmap);
+    if (num_chunks == 0)
+      return false;  // Non partitioned pages cannot be complete.
+    return (bitmap & kAllChunksMask) ==
+           (kAllChunksComplete & ((1 << (num_chunks * kChunkShift)) - 1));
+  }
+
+  // For testing / debugging only.
+  std::string page_header_dbg(size_t page_idx) {
+    uint32_t x = GetPageHeaderBitmap(page_idx, std::memory_order_relaxed);
+    return std::bitset<32>(x).to_string();
+  }
+
+  // Returns the page header bitmap, which is a bitmap that specifies the
+  // chunking layout of the page and each chunk's current state. Unless
+  // explicitly specified, reads with an acquire-load semantic to ensure a
+  // producer's writes corresponding to an update of the bitmap (e.g. clearing
+  // a chunk's header) are observed consistently.
+  uint32_t GetPageHeaderBitmap(
+      size_t page_idx,
+      std::memory_order order = std::memory_order_acquire) {
+    return page_header(page_idx)->header_bitmap.load(order);
+  }
+
+  // Returns a bitmap in which each bit is set if the corresponding Chunk exists
+  // in the page (according to the page header bitmap) and is free. If the page
+  // is not partitioned it returns 0 (as if the page had no free chunks).
+  uint32_t GetFreeChunks(size_t page_idx);
+
+  // Tries to atomically partition a page with the given |layout|. Returns true
+  // if the page was free and has been partitioned with the given |layout|,
+  // false if the page wasn't free anymore by the time we got there.
+  // If succeeds all the chunks are atomically set in the kChunkFree state.
+  bool TryPartitionPage(size_t page_idx, PageLayout layout);
+
+  // Tries to atomically mark a single chunk within the page as
+  // kChunkBeingWritten. Returns an invalid chunk if the page is not partitioned
+  // or the chunk is not in the kChunkFree state. If succeeds sets the chunk
+  // header to |header|.
+  Chunk TryAcquireChunkForWriting(size_t page_idx,
+                                  size_t chunk_idx,
+                                  const ChunkHeader* header) {
+    return TryAcquireChunk(page_idx, chunk_idx, kChunkBeingWritten, header);
+  }
+
+  // Similar to TryAcquireChunkForWriting. Fails if the chunk isn't in the
+  // kChunkComplete state.
+  Chunk TryAcquireChunkForReading(size_t page_idx, size_t chunk_idx) {
+    return TryAcquireChunk(page_idx, chunk_idx, kChunkBeingRead, nullptr);
+  }
+
+  // The caller must have successfully TryAcquireAllChunksForReading() or it
+  // needs to guarantee that the chunk is already in the kChunkBeingWritten
+  // state.
+  Chunk GetChunkUnchecked(size_t page_idx,
+                          uint32_t header_bitmap,
+                          size_t chunk_idx);
+
+  // Creates a Chunk by adopting the given buffer (|data| and |size|) and chunk
+  // index. This is used for chunk data passed over the wire (e.g. tcp or
+  // vsock). The chunk should *not* be freed to the shared memory.
+  static Chunk MakeChunkFromSerializedData(uint8_t* data,
+                                           uint16_t size,
+                                           uint8_t chunk_idx) {
+    return Chunk(data, size, chunk_idx);
+  }
+
+  // Puts a chunk into the kChunkComplete state. Returns the page index.
+  size_t ReleaseChunkAsComplete(Chunk chunk) {
+    return ReleaseChunk(std::move(chunk), kChunkComplete);
+  }
+
+  // Puts a chunk into the kChunkFree state. Returns the page index.
+  size_t ReleaseChunkAsFree(Chunk chunk) {
+    return ReleaseChunk(std::move(chunk), kChunkFree);
+  }
+
+  ChunkState GetChunkState(size_t page_idx, size_t chunk_idx) {
+    uint32_t bitmap = GetPageHeaderBitmap(page_idx, std::memory_order_relaxed);
+    return GetChunkStateFromHeaderBitmap(bitmap, chunk_idx);
+  }
+
+  std::pair<size_t, size_t> GetPageAndChunkIndex(const Chunk& chunk);
+
+  uint16_t GetChunkSizeFromHeaderBitmap(uint32_t header_bitmap) const {
+    return chunk_sizes_[GetLayoutFromHeaderBitmap(header_bitmap)];
+  }
+
+  static ChunkState GetChunkStateFromHeaderBitmap(uint32_t header_bitmap,
+                                                  size_t chunk_idx) {
+    return static_cast<ChunkState>(
+        (header_bitmap >> (chunk_idx * kChunkShift)) & kChunkMask);
+  }
+
+  static constexpr PageLayout GetLayoutFromHeaderBitmap(
+      uint32_t header_bitmap) {
+    return static_cast<PageLayout>((header_bitmap & kLayoutMask) >>
+                                   kLayoutShift);
+  }
+
+  static constexpr uint32_t GetNumChunksFromHeaderBitmap(
+      uint32_t header_bitmap) {
+    return kNumChunksForLayout[GetLayoutFromHeaderBitmap(header_bitmap)];
+  }
+
+  // Returns a bitmap in which each bit is set if the corresponding Chunk exists
+  // in the page (according to the page layout) and is not free. If the page is
+  // not partitioned it returns 0 (as if the page had no used chunks). Bit N
+  // corresponds to Chunk N.
+  static uint32_t GetUsedChunks(uint32_t header_bitmap) {
+    const uint32_t num_chunks = GetNumChunksFromHeaderBitmap(header_bitmap);
+    uint32_t res = 0;
+    for (uint32_t i = 0; i < num_chunks; i++) {
+      res |= (GetChunkStateFromHeaderBitmap(header_bitmap, i) != kChunkFree)
+                 ? (1 << i)
+                 : 0;
+    }
+    return res;
+  }
+
+ private:
+  SharedMemoryABI(const SharedMemoryABI&) = delete;
+  SharedMemoryABI& operator=(const SharedMemoryABI&) = delete;
+
+  Chunk TryAcquireChunk(size_t page_idx,
+                        size_t chunk_idx,
+                        ChunkState,
+                        const ChunkHeader*);
+  size_t ReleaseChunk(Chunk chunk, ChunkState);
+
+  uint8_t* start_ = nullptr;
+  size_t size_ = 0;
+  size_t page_size_ = 0;
+  bool use_shmem_emulation_ = false;
+  size_t num_pages_ = 0;
+  std::array<uint16_t, kNumPageLayouts> chunk_sizes_;
+};
+
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_SHARED_MEMORY_ABI_H_
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the
+ * License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS
+ * IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_abi.h"
+
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+// gen_amalgamated expanded: #include "perfetto/base/time.h"
+
+#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+#include <sys/mman.h>
+#endif
+
+// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
+
+namespace perfetto {
+
+namespace {
+
+constexpr int kRetryAttempts = 64;
+
+inline void WaitBeforeNextAttempt(int attempt) {
+  if (attempt < kRetryAttempts / 2) {
+    std::this_thread::yield();
+  } else {
+    base::SleepMicroseconds((unsigned(attempt) / 10) * 1000);
+  }
+}
+
+// Returns the largest 4-bytes aligned chunk size <= |page_size| / |divider|
+// for each divider in PageLayout.
+constexpr size_t GetChunkSize(size_t page_size, size_t divider) {
+  return ((page_size - sizeof(SharedMemoryABI::PageHeader)) / divider) & ~3UL;
+}
+
+// Initializer for the const |chunk_sizes_| array.
+std::array<uint16_t, SharedMemoryABI::kNumPageLayouts> InitChunkSizes(
+    size_t page_size) {
+  static_assert(SharedMemoryABI::kNumPageLayouts ==
+                    base::ArraySize(SharedMemoryABI::kNumChunksForLayout),
+                "kNumPageLayouts out of date");
+  std::array<uint16_t, SharedMemoryABI::kNumPageLayouts> res = {};
+  for (size_t i = 0; i < SharedMemoryABI::kNumPageLayouts; i++) {
+    size_t num_chunks = SharedMemoryABI::kNumChunksForLayout[i];
+    size_t size = num_chunks == 0 ? 0 : GetChunkSize(page_size, num_chunks);
+    PERFETTO_CHECK(size <= std::numeric_limits<uint16_t>::max());
+    res[i] = static_cast<uint16_t>(size);
+  }
+  return res;
+}
+
+inline void ClearChunkHeader(SharedMemoryABI::ChunkHeader* header) {
+  header->writer_id.store(0u, std::memory_order_relaxed);
+  header->chunk_id.store(0u, std::memory_order_relaxed);
+  header->packets.store({}, std::memory_order_release);
+}
+
+}  // namespace
+
+SharedMemoryABI::SharedMemoryABI() = default;
+
+SharedMemoryABI::SharedMemoryABI(uint8_t* start,
+                                 size_t size,
+                                 size_t page_size,
+                                 ShmemMode mode) {
+  Initialize(start, size, page_size, mode);
+}
+
+void SharedMemoryABI::Initialize(uint8_t* start,
+                                 size_t size,
+                                 size_t page_size,
+                                 ShmemMode mode) {
+  start_ = start;
+  size_ = size;
+  page_size_ = page_size;
+  use_shmem_emulation_ = mode == ShmemMode::kShmemEmulation;
+  num_pages_ = size / page_size;
+  chunk_sizes_ = InitChunkSizes(page_size);
+  static_assert(sizeof(PageHeader) == 8, "PageHeader size");
+  static_assert(sizeof(ChunkHeader) == 8, "ChunkHeader size");
+  static_assert(sizeof(ChunkHeader::chunk_id) == sizeof(ChunkID),
+                "ChunkID size");
+
+  static_assert(sizeof(ChunkHeader::Packets) == 2, "ChunkHeader::Packets size");
+  static_assert(alignof(ChunkHeader) == kChunkAlignment,
+                "ChunkHeader alignment");
+
+  // In theory std::atomic does not guarantee that the underlying type
+  // consists only of the actual atomic word. Theoretically it could have
+  // locks or other state. In practice most implementations just implement
+  // them without extra state. The code below overlays the atomic into the
+  // SMB, hence relies on this implementation detail. This should be fine
+  // pragmatically (Chrome's base makes the same assumption), but let's have a
+  // check for this.
+  static_assert(sizeof(std::atomic<uint32_t>) == sizeof(uint32_t) &&
+                    sizeof(std::atomic<uint16_t>) == sizeof(uint16_t),
+                "Incompatible STL <atomic> implementation");
+
+  // Check that the kAllChunks(Complete,Free) are consistent with the
+  // ChunkState enum values.
+
+  // These must be zero because rely on zero-initialized memory being
+  // interpreted as "free".
+  static_assert(kChunkFree == 0 && kAllChunksFree == 0,
+                "kChunkFree/kAllChunksFree and must be 0");
+
+  static_assert((kAllChunksComplete & kChunkMask) == kChunkComplete,
+                "kAllChunksComplete out of sync with kChunkComplete");
+
+  // Check the consistency of the kMax... constants.
+  static_assert(sizeof(ChunkHeader::writer_id) == sizeof(WriterID),
+                "WriterID size");
+  ChunkHeader chunk_header{};
+  chunk_header.chunk_id.store(static_cast<uint32_t>(-1));
+  PERFETTO_CHECK(chunk_header.chunk_id.load() == kMaxChunkID);
+
+  chunk_header.writer_id.store(static_cast<uint16_t>(-1));
+  PERFETTO_CHECK(kMaxWriterID <= chunk_header.writer_id.load());
+
+  PERFETTO_CHECK(page_size >= kMinPageSize);
+  PERFETTO_CHECK(page_size <= kMaxPageSize);
+  PERFETTO_CHECK(page_size % kMinPageSize == 0);
+  PERFETTO_CHECK(reinterpret_cast<uintptr_t>(start) % kMinPageSize == 0);
+  PERFETTO_CHECK(size % page_size == 0);
+}
+
+SharedMemoryABI::Chunk SharedMemoryABI::GetChunkUnchecked(
+    size_t page_idx,
+    uint32_t header_bitmap,
+    size_t chunk_idx) {
+  const size_t num_chunks = GetNumChunksFromHeaderBitmap(header_bitmap);
+  PERFETTO_DCHECK(chunk_idx < num_chunks);
+  // Compute the chunk virtual address and write it into |chunk|.
+  const uint16_t chunk_size = GetChunkSizeFromHeaderBitmap(header_bitmap);
+  size_t chunk_offset_in_page = sizeof(PageHeader) + chunk_idx * chunk_size;
+
+  Chunk chunk(page_start(page_idx) + chunk_offset_in_page, chunk_size,
+              static_cast<uint8_t>(chunk_idx));
+  PERFETTO_DCHECK(chunk.end() <= end());
+  return chunk;
+}
+
+SharedMemoryABI::Chunk SharedMemoryABI::TryAcquireChunk(
+    size_t page_idx,
+    size_t chunk_idx,
+    ChunkState desired_chunk_state,
+    const ChunkHeader* header) {
+  PERFETTO_DCHECK(desired_chunk_state == kChunkBeingRead ||
+                  desired_chunk_state == kChunkBeingWritten);
+  PageHeader* phdr = page_header(page_idx);
+  for (int attempt = 0; attempt < kRetryAttempts; attempt++) {
+    uint32_t header_bitmap =
+        phdr->header_bitmap.load(std::memory_order_acquire);
+    const size_t num_chunks = GetNumChunksFromHeaderBitmap(header_bitmap);
+
+    // The page layout has changed (or the page is free).
+    if (chunk_idx >= num_chunks)
+      return Chunk();
+
+    // Verify that the chunk is still in a state that allows the transition to
+    // |desired_chunk_state|. The only allowed transitions are:
+    // 1. kChunkFree -> kChunkBeingWritten (Producer).
+    // 2. kChunkComplete -> kChunkBeingRead (Service).
+    ChunkState expected_chunk_state =
+        desired_chunk_state == kChunkBeingWritten ? kChunkFree : kChunkComplete;
+    auto cur_chunk_state =
+        GetChunkStateFromHeaderBitmap(header_bitmap, chunk_idx);
+    if (cur_chunk_state != expected_chunk_state)
+      return Chunk();
+
+    uint32_t next_header_bitmap = header_bitmap;
+    next_header_bitmap &= ~(kChunkMask << (chunk_idx * kChunkShift));
+    next_header_bitmap |= (desired_chunk_state << (chunk_idx * kChunkShift));
+    if (phdr->header_bitmap.compare_exchange_strong(
+            header_bitmap, next_header_bitmap, std::memory_order_acq_rel)) {
+      // Compute the chunk virtual address and write it into |chunk|.
+      Chunk chunk = GetChunkUnchecked(page_idx, header_bitmap, chunk_idx);
+      if (desired_chunk_state == kChunkBeingWritten) {
+        PERFETTO_DCHECK(header);
+        ChunkHeader* new_header = chunk.header();
+        new_header->writer_id.store(header->writer_id,
+                                    std::memory_order_relaxed);
+        new_header->chunk_id.store(header->chunk_id, std::memory_order_relaxed);
+        new_header->packets.store(header->packets, std::memory_order_release);
+      }
+      return chunk;
+    }
+    WaitBeforeNextAttempt(attempt);
+  }
+  return Chunk();  // All our attempts failed.
+}
+
+bool SharedMemoryABI::TryPartitionPage(size_t page_idx, PageLayout layout) {
+  PERFETTO_DCHECK(layout >= kPageDiv1 && layout <= kPageDiv14);
+  uint32_t expected_bitmap = 0;  // Free page.
+  uint32_t next_bitmap = (layout << kLayoutShift) & kLayoutMask;
+  PageHeader* phdr = page_header(page_idx);
+  if (!phdr->header_bitmap.compare_exchange_strong(expected_bitmap, next_bitmap,
+                                                   std::memory_order_acq_rel)) {
+    return false;
+  }
+  return true;
+}
+
+uint32_t SharedMemoryABI::GetFreeChunks(size_t page_idx) {
+  uint32_t bitmap = GetPageHeaderBitmap(page_idx, std::memory_order_relaxed);
+  const uint32_t num_chunks = GetNumChunksFromHeaderBitmap(bitmap);
+  uint32_t res = 0;
+
+  for (uint32_t i = 0; i < num_chunks; i++) {
+    res |=
+        (GetChunkStateFromHeaderBitmap(bitmap, i) == kChunkFree) ? (1 << i) : 0;
+  }
+  return res;
+}
+
+size_t SharedMemoryABI::ReleaseChunk(Chunk chunk,
+                                     ChunkState desired_chunk_state) {
+  PERFETTO_DCHECK(desired_chunk_state == kChunkComplete ||
+                  desired_chunk_state == kChunkFree);
+
+  size_t page_idx;
+  size_t chunk_idx;
+  std::tie(page_idx, chunk_idx) = GetPageAndChunkIndex(chunk);
+
+  // Reset header fields, so that the service can identify when the chunk's
+  // header has been initialized by the producer.
+  if (desired_chunk_state == kChunkFree)
+    ClearChunkHeader(chunk.header());
+
+  for (int attempt = 0; attempt < kRetryAttempts; attempt++) {
+    PageHeader* phdr = page_header(page_idx);
+    uint32_t bitmap = phdr->header_bitmap.load(std::memory_order_relaxed);
+    const size_t page_chunk_size = GetChunkSizeFromHeaderBitmap(bitmap);
+
+    // TODO(primiano): this should not be a CHECK, because a malicious producer
+    // could crash us by putting the chunk in an invalid state. This should
+    // gracefully fail. Keep a CHECK until then.
+    PERFETTO_CHECK(chunk.size() == page_chunk_size);
+    const uint32_t chunk_state =
+        GetChunkStateFromHeaderBitmap(bitmap, chunk_idx);
+
+    // Verify that the chunk is still in a state that allows the transition to
+    // |desired_chunk_state|. The only allowed transitions are:
+    // 1. kChunkBeingWritten -> kChunkComplete (Producer).
+    // 2. kChunkBeingRead -> kChunkFree (Service).
+    // Or in the emulation mode, the allowed transitions are:
+    // 1. kChunkBeingWritten -> kChunkComplete (Producer).
+    // 2. kChunkComplete -> kChunkFree (Producer).
+    ChunkState expected_chunk_state;
+    if (desired_chunk_state == kChunkComplete) {
+      expected_chunk_state = kChunkBeingWritten;
+    } else {
+      expected_chunk_state =
+          use_shmem_emulation_ ? kChunkComplete : kChunkBeingRead;
+    }
+
+    // TODO(primiano): should not be a CHECK (same rationale of comment above).
+    PERFETTO_CHECK(chunk_state == expected_chunk_state);
+    uint32_t next_bitmap = bitmap;
+    next_bitmap &= ~(kChunkMask << (chunk_idx * kChunkShift));
+    next_bitmap |= (desired_chunk_state << (chunk_idx * kChunkShift));
+
+    // If we are freeing a chunk and all the other chunks in the page are free
+    // we should de-partition the page and mark it as clear.
+    if ((next_bitmap & kAllChunksMask) == kAllChunksFree)
+      next_bitmap = 0;
+
+    if (phdr->header_bitmap.compare_exchange_strong(
+            bitmap, next_bitmap, std::memory_order_acq_rel)) {
+      return page_idx;
+    }
+    WaitBeforeNextAttempt(attempt);
+  }
+  // Too much contention on this page. Give up. This page will be left pending
+  // forever but there isn't much more we can do at this point.
+  PERFETTO_DFATAL("Too much contention on page.");
+  return kInvalidPageIdx;
+}
+
+SharedMemoryABI::Chunk::Chunk() = default;
+
+SharedMemoryABI::Chunk::Chunk(uint8_t* begin, uint16_t size, uint8_t chunk_idx)
+    : begin_(begin), size_(size), chunk_idx_(chunk_idx) {
+  PERFETTO_CHECK(reinterpret_cast<uintptr_t>(begin) % kChunkAlignment == 0);
+  PERFETTO_CHECK(size > 0);
+}
+
+SharedMemoryABI::Chunk::Chunk(Chunk&& o) noexcept {
+  *this = std::move(o);
+}
+
+SharedMemoryABI::Chunk& SharedMemoryABI::Chunk::operator=(Chunk&& o) {
+  begin_ = o.begin_;
+  size_ = o.size_;
+  chunk_idx_ = o.chunk_idx_;
+  o.begin_ = nullptr;
+  o.size_ = 0;
+  o.chunk_idx_ = 0;
+  return *this;
+}
+
+std::pair<size_t, size_t> SharedMemoryABI::GetPageAndChunkIndex(
+    const Chunk& chunk) {
+  PERFETTO_DCHECK(chunk.is_valid());
+  PERFETTO_DCHECK(chunk.begin() >= start_);
+  PERFETTO_DCHECK(chunk.end() <= start_ + size_);
+
+  // TODO(primiano): The divisions below could be avoided if we cached
+  // |page_shift_|.
+  const uintptr_t rel_addr = static_cast<uintptr_t>(chunk.begin() - start_);
+  const size_t page_idx = rel_addr / page_size_;
+  const size_t offset = rel_addr % page_size_;
+  PERFETTO_DCHECK(offset >= sizeof(PageHeader));
+  PERFETTO_DCHECK(offset % kChunkAlignment == 0);
+  PERFETTO_DCHECK((offset - sizeof(PageHeader)) % chunk.size() == 0);
+  const size_t chunk_idx = (offset - sizeof(PageHeader)) / chunk.size();
+  PERFETTO_DCHECK(chunk_idx < kMaxChunksPerPage);
+  PERFETTO_DCHECK(chunk_idx <
+                  GetNumChunksFromHeaderBitmap(GetPageHeaderBitmap(page_idx)));
+  return std::make_pair(page_idx, chunk_idx);
+}
+
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/core/shared_memory_arbiter_impl.cc
+// gen_amalgamated begin header: src/tracing/core/shared_memory_arbiter_impl.h
+// gen_amalgamated begin header: include/perfetto/ext/tracing/core/shared_memory_arbiter.h
+// gen_amalgamated begin header: include/perfetto/ext/tracing/core/tracing_service.h
+// gen_amalgamated begin header: include/perfetto/ext/base/clock_snapshots.h
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_EXT_BASE_CLOCK_SNAPSHOTS_H_
+#define INCLUDE_PERFETTO_EXT_BASE_CLOCK_SNAPSHOTS_H_
+
+#include <cstdint>
+#include <vector>
+
+namespace perfetto::base {
+
+struct ClockReading {
+  ClockReading(uint32_t _clock_id, uint64_t _timestamp)
+      : clock_id(_clock_id), timestamp(_timestamp) {}
+  ClockReading() = default;
+
+  // Identifier of the clock domain (of type protos::pbzero::BuiltinClock).
+  uint32_t clock_id = 0;
+  // Clock reading as uint64_t.
+  uint64_t timestamp = 0;
+};
+
+using ClockSnapshotVector = std::vector<ClockReading>;
+
+// Takes snapshots of clock readings of all supported built-in clocks.
+ClockSnapshotVector CaptureClockSnapshots();
+
+}  // namespace perfetto::base
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_CLOCK_SNAPSHOTS_H_
+// gen_amalgamated begin header: include/perfetto/ext/tracing/core/trace_packet.h
+// gen_amalgamated begin header: include/perfetto/ext/tracing/core/slice.h
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_SLICE_H_
+#define INCLUDE_PERFETTO_EXT_TRACING_CORE_SLICE_H_
+
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+
+namespace perfetto {
+
+// A simple wrapper around a virtually contiguous memory range that contains a
+// TracePacket, or just a portion of it.
+struct Slice {
+  Slice() : start(nullptr), size(0) {}
+  Slice(const void* st, size_t sz) : start(st), size(sz) {}
+  Slice(Slice&& other) noexcept = default;
+
+  // Create a Slice which owns |size| bytes of memory.
+  static Slice Allocate(size_t size) {
+    Slice slice;
+    slice.own_data_.reset(new uint8_t[size]);
+    slice.start = &slice.own_data_[0];
+    slice.size = size;
+    return slice;
+  }
+
+  static Slice TakeOwnership(std::unique_ptr<uint8_t[]> buf, size_t size) {
+    Slice slice;
+    slice.own_data_ = std::move(buf);
+    slice.start = &slice.own_data_[0];
+    slice.size = size;
+    return slice;
+  }
+
+  uint8_t* own_data() {
+    PERFETTO_DCHECK(own_data_);
+    return own_data_.get();
+  }
+
+  const void* start;
+  size_t size;
+
+ private:
+  Slice(const Slice&) = delete;
+  void operator=(const Slice&) = delete;
+
+  std::unique_ptr<uint8_t[]> own_data_;
+};
+
+// TODO(primiano): most TracePacket(s) fit in a slice or two. We need something
+// a bit more clever here that has inline capacity for 2 slices and then uses a
+// std::forward_list or a std::vector for the less likely cases.
+using Slices = std::vector<Slice>;
+
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_SLICE_H_
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACE_PACKET_H_
+#define INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACE_PACKET_H_
+
+#include <stddef.h>
+#include <memory>
+#include <optional>
+#include <tuple>
+
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/slice.h"
+
+namespace perfetto {
+
+// A wrapper around a byte buffer that contains a protobuf-encoded TracePacket
+// (see trace_packet.proto). The TracePacket is decoded only if the Consumer
+// requests that. This is to allow Consumer(s) to just stream the packet over
+// the network or save it to a file without wasting time decoding it and without
+// needing to depend on libprotobuf or the trace_packet.pb.h header.
+// If the packets are saved / streamed and not just consumed locally, consumers
+// should ensure to preserve the unknown fields in the proto. A consumer, in
+// fact, might have an older version .proto which is newer on the producer.
+class PERFETTO_EXPORT_COMPONENT TracePacket {
+ public:
+  using const_iterator = Slices::const_iterator;
+
+  // The field id of protos::Trace::packet, static_assert()-ed in the unittest.
+  static constexpr uint32_t kPacketFieldNumber = 1;
+
+  // Maximum size of the preamble returned by GetProtoPreamble().
+  static constexpr size_t kMaxPreambleBytes = 8;
+
+  TracePacket();
+  ~TracePacket();
+  TracePacket(TracePacket&&) noexcept;
+  TracePacket& operator=(TracePacket&&);
+
+  // Accesses all the raw slices in the packet, for saving them to file/network.
+  const Slices& slices() const { return slices_; }
+
+  // Mutator, used only by the service and tests.
+  void AddSlice(Slice);
+
+  // Does not copy / take ownership of the memory of the slice. The TracePacket
+  // will be valid only as long as the original buffer is valid.
+  void AddSlice(const void* start, size_t size);
+
+  void Clear();
+
+  // Total size of all slices.
+  size_t size() const { return size_; }
+
+  // Generates a protobuf preamble suitable to represent this packet as a
+  // repeated field within a root trace.proto message.
+  // Returns a pointer to a buffer, owned by this class, containing the preamble
+  // and its size.
+  std::tuple<char*, size_t> GetProtoPreamble();
+
+  // Returns the raw protobuf bytes of the slices, all stitched together into
+  // the specified buffer.
+  void GetRawBytes(std::string*) const;
+
+  // Returns the raw protobuf bytes of the slices, all stitched together into
+  // a string. Only for testing.
+  std::string GetRawBytesForTesting() const;
+
+  // Remembers the buffer index where this packet was taken from. This is
+  // usually populated for packets from a TraceBuffer, not synthetic ones.
+  std::optional<uint32_t> buffer_index_for_stats() const {
+    if (buffer_index_for_stats_ == 0)
+      return std::nullopt;
+    return buffer_index_for_stats_ - 1;
+  }
+  void set_buffer_index_for_stats(uint32_t v) {
+    buffer_index_for_stats_ = v + 1;
+  }
+
+ private:
+  TracePacket(const TracePacket&) = delete;
+  TracePacket& operator=(const TracePacket&) = delete;
+
+  Slices slices_;    // Not owned.
+  size_t size_ = 0;  // SUM(slice.size for slice in slices_).
+
+  // Internally we store index+1, and use 0 for the "not set" case.
+  uint32_t buffer_index_for_stats_ = 0;
+  char preamble_[kMaxPreambleBytes];  // Deliberately not initialized.
+
+  // Remember to update the move operators and their unittest if adding new
+  // fields. ConsumerIPCClientImpl::OnReadBuffersResponse() relies on
+  // std::move(TracePacket) to clear up the moved-from instance.
+};
+
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACE_PACKET_H_
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACING_SERVICE_H_
+#define INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACING_SERVICE_H_
+
+#include <stdint.h>
+
+#include <functional>
+#include <memory>
+#include <vector>
+
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/clock_snapshots.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/sys_types.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_packet.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/buffer_exhausted_policy.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/flush_flags.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
+
+namespace perfetto {
+
+namespace base {
+class TaskRunner;
+}  // namespace base
+
+class Consumer;
+class Producer;
+class SharedMemoryArbiter;
+class TraceWriter;
+class ClientIdentity;
+
+// TODO: for the moment this assumes that all the calls happen on the same
+// thread/sequence. Not sure this will be the case long term in Chrome.
+
+// The API for the Producer port of the Service.
+// Subclassed by:
+// 1. The tracing_service_impl.cc business logic when returning it in response
+//    to the ConnectProducer() method.
+// 2. The transport layer (e.g., src/ipc) when the producer and
+//    the service don't talk locally but via some IPC mechanism.
+class PERFETTO_EXPORT_COMPONENT ProducerEndpoint {
+ public:
+  virtual ~ProducerEndpoint();
+
+  // Disconnects the endpoint from the service, while keeping the shared memory
+  // valid. After calling this, the endpoint will no longer call any methods
+  // on the Producer.
+  virtual void Disconnect() = 0;
+
+  // Called by the Producer to (un)register data sources. Data sources are
+  // identified by their name (i.e. DataSourceDescriptor.name)
+  virtual void RegisterDataSource(const DataSourceDescriptor&) = 0;
+  virtual void UpdateDataSource(const DataSourceDescriptor&) = 0;
+  virtual void UnregisterDataSource(const std::string& name) = 0;
+
+  // Associate the trace writer with the given |writer_id| with
+  // |target_buffer|. The service may use this information to retrieve and
+  // copy uncommitted chunks written by the trace writer into its associated
+  // buffer, e.g. when a producer process crashes or when a flush is
+  // necessary.
+  virtual void RegisterTraceWriter(uint32_t writer_id,
+                                   uint32_t target_buffer) = 0;
+
+  // Remove the association of the trace writer previously created via
+  // RegisterTraceWriter.
+  virtual void UnregisterTraceWriter(uint32_t writer_id) = 0;
+
+  // Called by the Producer to signal that some pages in the shared memory
+  // buffer (shared between Service and Producer) have changed.
+  // When the Producer and the Service are hosted in the same process and
+  // hence potentially live on the same task runner, This method must call
+  // TracingServiceImpl's CommitData synchronously, without any PostTask()s,
+  // if on the same thread. This is to avoid a deadlock where the Producer
+  // exhausts its SMB and stalls waiting for the service to catch up with
+  // reads, but the Service never gets to that because it lives on the same
+  // thread.
+  using CommitDataCallback = std::function<void()>;
+  virtual void CommitData(const CommitDataRequest&,
+                          CommitDataCallback callback = {}) = 0;
+
+  virtual SharedMemory* shared_memory() const = 0;
+
+  // Size of shared memory buffer pages. It's always a multiple of 4K.
+  // See shared_memory_abi.h
+  virtual size_t shared_buffer_page_size_kb() const = 0;
+
+  // Creates a trace writer, which allows to create events, handling the
+  // underying shared memory buffer and signalling to the Service. This method
+  // is thread-safe but the returned object is not. A TraceWriter should be
+  // used only from a single thread, or the caller has to handle sequencing
+  // via a mutex or equivalent. This method can only be called if
+  // TracingService::ConnectProducer was called with |in_process=true|.
+  // Args:
+  // |target_buffer| is the target buffer ID where the data produced by the
+  // writer should be stored by the tracing service. This value is passed
+  // upon creation of the data source (StartDataSource()) in the
+  // DataSourceConfig.target_buffer().
+  virtual std::unique_ptr<TraceWriter> CreateTraceWriter(
+      BufferID target_buffer,
+      BufferExhaustedPolicy buffer_exhausted_policy) = 0;
+
+  // TODO(eseckler): Also expose CreateStartupTraceWriter() ?
+
+  // In some cases you can access the producer's SharedMemoryArbiter (for
+  // example if TracingService::ConnectProducer is called with
+  // |in_process=true|). The SharedMemoryArbiter can be used to create
+  // TraceWriters which is able to directly commit chunks. For the
+  // |in_process=true| case this can be done without going through an IPC layer.
+  virtual SharedMemoryArbiter* MaybeSharedMemoryArbiter() = 0;
+
+  // Whether the service accepted a shared memory buffer provided by the
+  // producer.
+  virtual bool IsShmemProvidedByProducer() const = 0;
+
+  // Called in response to a Producer::Flush(request_id) call after all data
+  // for the flush request has been committed.
+  virtual void NotifyFlushComplete(FlushRequestID) = 0;
+
+  // Called in response to one or more Producer::StartDataSource(),
+  // if the data source registered setting the flag
+  // DataSourceDescriptor.will_notify_on_start.
+  virtual void NotifyDataSourceStarted(DataSourceInstanceID) = 0;
+
+  // Called in response to one or more Producer::StopDataSource(),
+  // if the data source registered setting the flag
+  // DataSourceDescriptor.will_notify_on_stop.
+  virtual void NotifyDataSourceStopped(DataSourceInstanceID) = 0;
+
+  // This informs the service to activate any of these triggers if any tracing
+  // session was waiting for them.
+  virtual void ActivateTriggers(const std::vector<std::string>&) = 0;
+
+  // Emits a synchronization barrier to linearize with the service. When
+  // |callback| is invoked, the caller has the guarantee that the service has
+  // seen and processed all the requests sent by this producer prior to the
+  // Sync() call. Used mainly in tests.
+  virtual void Sync(std::function<void()> callback) = 0;
+};  // class ProducerEndpoint.
+
+// The API for the Consumer port of the Service.
+// Subclassed by:
+// 1. The tracing_service_impl.cc business logic when returning it in response
+// to
+//    the ConnectConsumer() method.
+// 2. The transport layer (e.g., src/ipc) when the consumer and
+//    the service don't talk locally but via some IPC mechanism.
+class PERFETTO_EXPORT_COMPONENT ConsumerEndpoint {
+ public:
+  virtual ~ConsumerEndpoint();
+
+  // Enables tracing with the given TraceConfig. The ScopedFile argument is
+  // used only when TraceConfig.write_into_file == true.
+  // If TraceConfig.deferred_start == true data sources are configured via
+  // SetupDataSource() but are not started until StartTracing() is called.
+  // This is to support pre-initialization and fast triggering of traces.
+  // The ScopedFile argument is used only when TraceConfig.write_into_file
+  // == true.
+  virtual void EnableTracing(const TraceConfig&,
+                             base::ScopedFile = base::ScopedFile()) = 0;
+
+  // Update the trace config of an existing tracing session; only a subset
+  // of options can be changed mid-session. Currently the only
+  // supported functionality is expanding the list of producer_name_filters()
+  // (or removing the filter entirely) for existing data sources.
+  virtual void ChangeTraceConfig(const TraceConfig&) = 0;
+
+  // Starts all data sources configured in the trace config. This is used only
+  // after calling EnableTracing() with TraceConfig.deferred_start=true.
+  // It's a no-op if called after a regular EnableTracing(), without setting
+  // deferred_start.
+  virtual void StartTracing() = 0;
+
+  virtual void DisableTracing() = 0;
+
+  // Clones an existing tracing session and attaches to it. The session is
+  // cloned in read-only mode and can only be used to read a snapshot of an
+  // existing tracing session. Will invoke Consumer::OnSessionCloned().
+  struct CloneSessionArgs {
+    // Exactly one between tsid and unique_session_name should be set.
+
+    // The id of the tracing session that should be cloned. If
+    // kBugreportSessionId (0xff...ff) the session with the highest bugreport
+    // score is cloned (if any exists).
+    TracingSessionID tsid = 0;
+
+    // The unique_session_name of the session that should be cloned.
+    std::string unique_session_name;
+
+    // If set, the trace filter will not have effect on the cloned session.
+    // Used for bugreports.
+    bool skip_trace_filter = false;
+
+    // If set, affects the generation of the FlushFlags::CloneTarget to be set
+    // to kBugreport when requesting the flush to the producers.
+    bool for_bugreport = false;
+
+    // If not empty, this is stored in the trace as name of the trigger that
+    // caused the clone.
+    std::string clone_trigger_name;
+    // If not empty, this is stored in the trace as name of the producer that
+    // triggered the clone.
+    std::string clone_trigger_producer_name;
+    // If not zero, this is stored in the trace as uid of the producer that
+    // triggered the clone.
+    uid_t clone_trigger_trusted_producer_uid = 0;
+    // If not zero, this is stored in the trace as timestamp of the trigger that
+    // caused the clone.
+    uint64_t clone_trigger_boot_time_ns = 0;
+    // If not zero, this is stored in the trace as the configured delay (in
+    // milliseconds) of the trigger that caused the clone.
+    uint64_t clone_trigger_delay_ms = 0;
+
+    // If valid, and the session that should be cloned is 'write_into_file'
+    // session, traced writes the cloned session content to this file
+    // descriptor, instead of writing it in the cloned session buffers.
+    base::ScopedFile output_file_fd;
+  };
+  virtual void CloneSession(CloneSessionArgs) = 0;
+
+  // Requests all data sources to flush their data immediately and invokes the
+  // passed callback once all of them have acked the flush (in which case
+  // the callback argument |success| will be true) or |timeout_ms| are elapsed
+  // (in which case |success| will be false).
+  // If |timeout_ms| is 0 the TraceConfig's flush_timeout_ms is used, or,
+  // if that one is not set (or is set to 0), kDefaultFlushTimeoutMs (5s) is
+  // used.
+  using FlushCallback = std::function<void(bool /*success*/)>;
+  virtual void Flush(uint32_t timeout_ms,
+                     FlushCallback callback,
+                     FlushFlags) = 0;
+
+  // This is required for legacy out-of-repo clients like arctraceservice which
+  // use the 2-version parameter.
+  inline void Flush(uint32_t timeout_ms, FlushCallback callback) {
+    Flush(timeout_ms, std::move(callback), FlushFlags());
+  }
+
+  // Tracing data will be delivered invoking Consumer::OnTraceData().
+  virtual void ReadBuffers() = 0;
+
+  virtual void FreeBuffers() = 0;
+
+  // Will call OnDetach().
+  virtual void Detach(const std::string& key) = 0;
+
+  // Will call OnAttach().
+  virtual void Attach(const std::string& key) = 0;
+
+  // Will call OnTraceStats().
+  virtual void GetTraceStats() = 0;
+
+  // Start or stop observing events of selected types. |events_mask| specifies
+  // the types of events to observe in a bitmask of ObservableEvents::Type.
+  // To disable observing, pass 0.
+  // Will call OnObservableEvents() repeatedly whenever an event of an enabled
+  // ObservableEventType occurs.
+  // TODO(eseckler): Extend this to support producers & data sources.
+  virtual void ObserveEvents(uint32_t events_mask) = 0;
+
+  // Used to obtain the list of connected data sources and other info about
+  // the tracing service.
+  struct QueryServiceStateArgs {
+    // If set, only the TracingServiceState.tracing_sessions is filled.
+    bool sessions_only = false;
+  };
+  using QueryServiceStateCallback =
+      std::function<void(bool success, const TracingServiceState&)>;
+  virtual void QueryServiceState(QueryServiceStateArgs,
+                                 QueryServiceStateCallback) = 0;
+
+  // Used for feature detection. Makes sense only when the consumer and the
+  // service talk over IPC and can be from different versions.
+  using QueryCapabilitiesCallback =
+      std::function<void(const TracingServiceCapabilities&)>;
+  virtual void QueryCapabilities(QueryCapabilitiesCallback) = 0;
+
+  // If any tracing session with TraceConfig.bugreport_score > 0 is running,
+  // this will pick the highest-score one, stop it and save it into a fixed
+  // path (See kBugreportTracePath).
+  // The callback is invoked when the file has been saved, in case of success,
+  // or whenever an error occurs.
+  // Args:
+  // - success: if true, an eligible trace was found and saved into file.
+  //            If false, either there was no eligible trace running or
+  //            something else failed (See |msg|).
+  // - msg: human readable diagnostic messages to debug failures.
+  using SaveTraceForBugreportCallback =
+      std::function<void(bool /*success*/, const std::string& /*msg*/)>;
+  virtual void SaveTraceForBugreport(SaveTraceForBugreportCallback) = 0;
+};  // class ConsumerEndpoint.
+
+struct PERFETTO_EXPORT_COMPONENT TracingServiceInitOpts {
+  // Function used by tracing service to compress packets. Takes a pointer to
+  // a vector of TracePackets and replaces the packets in the vector with
+  // compressed ones.
+  using CompressorFn = void (*)(std::vector<TracePacket>*);
+  CompressorFn compressor_fn = nullptr;
+
+  // Whether the relay endpoint is enabled on producer transport(s).
+  bool enable_relay_endpoint = false;
+
+  // An (optional) list of proto extension descriptors to dump into each trace
+  // recorded. This is to support injecting protos that are known by the
+  // embedder (e.g. the Android vendor image) but not by the upstream perfetto.
+  // See RFC-0017.
+  struct ProtoExtensionDescriptor {
+    std::string name;
+    const uint8_t* start = nullptr;
+    size_t size = 0;
+    bool gzipped = false;
+  };
+  // The caller owns the pointed memory (typically a mmaped file or a .rodata
+  // section) and must guarantee that it is indefinitely lived.
+  std::vector<ProtoExtensionDescriptor> extension_descriptors;
+};
+
+// The API for the Relay port of the Service. Subclassed by the
+// tracing_service_impl.cc business logic when returning it in response to the
+// ConnectRelayClient() method.
+class PERFETTO_EXPORT_COMPONENT RelayEndpoint {
+ public:
+  virtual ~RelayEndpoint();
+
+  // A snapshot of client and host clocks.
+  struct SyncClockSnapshot {
+    base::ClockSnapshotVector client_clock_snapshots;
+    base::ClockSnapshotVector host_clock_snapshots;
+  };
+
+  enum class SyncMode : uint32_t { PING = 1, UPDATE = 2 };
+
+  virtual void CacheSystemInfo(std::vector<uint8_t> serialized_system_info) = 0;
+  virtual void SyncClocks(SyncMode sync_mode,
+                          base::ClockSnapshotVector client_clocks,
+                          base::ClockSnapshotVector host_clocks) = 0;
+  virtual void Disconnect() = 0;
+};
+
+// The public API of the tracing Service business logic.
+//
+// Exposed to:
+// 1. The transport layer (e.g., src/unix_rpc/unix_service_host.cc),
+//    which forwards commands received from a remote producer or consumer to
+//    the actual service implementation.
+// 2. Tests.
+//
+// Subclassed by:
+//   The service business logic in src/core/tracing_service_impl.cc.
+class PERFETTO_EXPORT_COMPONENT TracingService {
+ public:
+  using ProducerEndpoint = perfetto::ProducerEndpoint;
+  using ConsumerEndpoint = perfetto::ConsumerEndpoint;
+  using RelayEndpoint = perfetto::RelayEndpoint;
+  using InitOpts = TracingServiceInitOpts;
+
+  // Default sizes used by the service implementation and client library.
+  static constexpr size_t kDefaultShmPageSize = 4096ul;
+  static constexpr size_t kDefaultShmSize = 256 * 1024ul;
+
+  enum class ProducerSMBScrapingMode {
+    // Use service's default setting for SMB scraping. Currently, the default
+    // mode is to disable SMB scraping, but this may change in the future.
+    kDefault,
+
+    // Enable scraping of uncommitted chunks in producers' shared memory
+    // buffers.
+    kEnabled,
+
+    // Disable scraping of uncommitted chunks in producers' shared memory
+    // buffers.
+    kDisabled
+  };
+
+  // Implemented in src/core/tracing_service_impl.cc . CompressorFn can be
+  // nullptr, in which case TracingService will not support compression.
+  static std::unique_ptr<TracingService> CreateInstance(
+      std::unique_ptr<SharedMemory::Factory>,
+      base::TaskRunner*,
+      InitOpts init_opts = {});
+
+  virtual ~TracingService();
+
+  // Connects a Producer instance and obtains a ProducerEndpoint, which is
+  // essentially a 1:1 channel between one Producer and the Service.
+  //
+  // The caller has to guarantee that the passed Producer will be alive as long
+  // as the returned ProducerEndpoint is alive. Both the passed Producer and the
+  // returned ProducerEndpoint must live on the same task runner of the service,
+  // specifically:
+  // 1) The Service will call Producer::* methods on the Service's task runner.
+  // 2) The Producer should call ProducerEndpoint::* methods only on the
+  //    service's task runner, except for ProducerEndpoint::CreateTraceWriter(),
+  //    which can be called on any thread. To disconnect just destroy the
+  //    returned ProducerEndpoint object. It is safe to destroy the Producer
+  //    once the Producer::OnDisconnect() has been invoked.
+  //
+  // |uid| is the trusted user id of the producer process, used by the consumers
+  // for validating the origin of trace data. |shared_memory_size_hint_bytes|
+  // and |shared_memory_page_size_hint_bytes| are optional hints on the size of
+  // the shared memory buffer and its pages. The service can ignore the hints
+  // (e.g., if the hints are unreasonably large or other sizes were configured
+  // in a tracing session's config). |in_process| enables the ProducerEndpoint
+  // to manage its own shared memory and enables use of
+  // |ProducerEndpoint::CreateTraceWriter|.
+  //
+  // The producer can optionally provide a non-null |shm|, which the service
+  // will adopt for the connection to the producer, provided it is correctly
+  // sized. In this case, |shared_memory_page_size_hint_bytes| indicates the
+  // page size used in this SMB. The producer can use this mechanism to record
+  // tracing data to an SMB even before the tracing session is started by the
+  // service. This is used in Chrome to implement startup tracing. If the buffer
+  // is incorrectly sized, the service will discard the SMB and allocate a new
+  // one, provided to the producer via ProducerEndpoint::shared_memory() after
+  // OnTracingSetup(). To verify that the service accepted the SMB, the producer
+  // may check via ProducerEndpoint::IsShmemProvidedByProducer(). If the service
+  // accepted the SMB, the producer can then commit any data that is already in
+  // the SMB after the tracing session was started by the service via
+  // Producer::StartDataSource(). The |shm| will also be rejected when
+  // connecting to a service that is too old (pre Android-11).
+  //
+  // Can return null in the unlikely event that service has too many producers
+  // connected.
+  virtual std::unique_ptr<ProducerEndpoint> ConnectProducer(
+      Producer*,
+      const ClientIdentity& client_identity,
+      const std::string& name,
+      size_t shared_memory_size_hint_bytes = 0,
+      bool in_process = false,
+      ProducerSMBScrapingMode smb_scraping_mode =
+          ProducerSMBScrapingMode::kDefault,
+      size_t shared_memory_page_size_hint_bytes = 0,
+      std::unique_ptr<SharedMemory> shm = nullptr,
+      const std::string& sdk_version = {},
+      const std::string& machine_name = {}) = 0;
+
+  // Connects a Consumer instance and obtains a ConsumerEndpoint, which is
+  // essentially a 1:1 channel between one Consumer and the Service.
+  // The caller has to guarantee that the passed Consumer will be alive as long
+  // as the returned ConsumerEndpoint is alive.
+  // To disconnect just destroy the returned ConsumerEndpoint object. It is safe
+  // to destroy the Consumer once the Consumer::OnDisconnect() has been invoked.
+  virtual std::unique_ptr<ConsumerEndpoint> ConnectConsumer(Consumer*,
+                                                            uid_t) = 0;
+
+  // Enable/disable scraping of chunks in the shared memory buffer. If enabled,
+  // the service will copy uncommitted but non-empty chunks from the SMB when
+  // flushing (e.g. to handle unresponsive producers or producers unable to
+  // flush their active chunks), on producer disconnect (e.g. to recover data
+  // from crashed producers), and after disabling a tracing session (e.g. to
+  // gather data from producers that didn't stop their data sources in time).
+  //
+  // This feature is currently used by Chrome.
+  virtual void SetSMBScrapingEnabled(bool enabled) = 0;
+
+  using RelayClientID = std::pair<base::MachineID, /*client ID*/ uint64_t>;
+  // Connects a remote RelayClient instance and obtains a RelayEndpoint, which
+  // is a 1:1 channel between one RelayClient and the Service. To disconnect
+  // just call Disconnect() of the RelayEndpoint instance. The relay client is
+  // connected using an identifier of MachineID and client ID. The service
+  // doesn't hold an object that represents the client because the relay port
+  // only has a client-to-host SyncClock() method.
+  //
+  // TODO(chinglinyu): connect the relay client using a RelayClient* object when
+  // we need host-to-client RPC method.
+  virtual std::unique_ptr<RelayEndpoint> ConnectRelayClient(RelayClientID) = 0;
+};
+
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACING_SERVICE_H_
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_SHARED_MEMORY_ARBITER_H_
+#define INCLUDE_PERFETTO_EXT_TRACING_CORE_SHARED_MEMORY_ARBITER_H_
+
+#include <stddef.h>
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <vector>
+
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_abi.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/buffer_exhausted_policy.h"
+
+namespace perfetto {
+
+namespace base {
+class TaskRunner;
+}
+
+class SharedMemory;
+class TraceWriter;
+
+// Used by the Producer-side of the transport layer to vend TraceWriters
+// from the SharedMemory it receives from the Service-side.
+class PERFETTO_EXPORT_COMPONENT SharedMemoryArbiter {
+ public:
+  using ShmemMode = SharedMemoryABI::ShmemMode;
+
+  virtual ~SharedMemoryArbiter();
+
+  // Creates a new TraceWriter and assigns it a new WriterID. The WriterID is
+  // written in each chunk header owned by a given TraceWriter and is used by
+  // the Service to reconstruct TracePackets written by the same TraceWriter.
+  // Returns null impl of TraceWriter if all WriterID slots are exhausted. The
+  // writer will commit to the provided |target_buffer|. If the arbiter was
+  // created via CreateUnbound() or CreateStartupTraceWriter() is later used,
+  // only BufferExhaustedPolicy::kDrop is supported.
+  virtual std::unique_ptr<TraceWriter> CreateTraceWriter(
+      BufferID target_buffer,
+      BufferExhaustedPolicy buffer_exhausted_policy) = 0;
+
+  // Creates a TraceWriter that will commit to the target buffer with the given
+  // reservation ID (creating a new reservation for this ID if none exists yet).
+  // The buffer reservation should be bound to an actual BufferID via
+  // BindStartupTargetBuffer() once the actual BufferID is known. Calling this
+  // method may transition the arbiter into unbound state (see state diagram in
+  // SharedMemoryArbiterImpl's class comment) and requires that all (past and
+  // future) TraceWriters are created with BufferExhaustedPolicy::kDrop.
+  //
+  // While any unbound buffer reservation exists, all commits will be buffered
+  // until all reservations were bound. Thus, until all reservations are bound,
+  // the data written to the SMB will not be consumed by the service - the SMB
+  // size should be chosen with this in mind. Startup writers always use
+  // BufferExhaustedPolicy::kDrop, as we cannot feasibly stall while not
+  // flushing to the service.
+  //
+  // The |target_buffer_reservation_id| should be greater than 0 but can
+  // otherwise be freely chosen by the producer and is only used to translate
+  // packets into the actual buffer id once
+  // BindStartupTargetBuffer(reservation_id) is called. For example, Chrome uses
+  // startup tracing not only for the first, but also subsequent tracing
+  // sessions (to enable tracing in the browser process before it instructs the
+  // tracing service to start tracing asynchronously, minimizing trace data loss
+  // in the meantime), and increments the reservation ID between sessions.
+  // Similarly, if more than a single target buffer per session is required
+  // (e.g. for two different data sources), different reservation IDs should be
+  // chosen for different target buffers.
+  virtual std::unique_ptr<TraceWriter> CreateStartupTraceWriter(
+      uint16_t target_buffer_reservation_id) = 0;
+
+  // Should only be called on unbound SharedMemoryArbiters. Binds the arbiter to
+  // the provided ProducerEndpoint and TaskRunner. Should be called only once
+  // and on the provided |TaskRunner|. Usually called by the producer (i.e., no
+  // specific data source) once it connects to the service. Both the endpoint
+  // and task runner should remain valid for the remainder of the arbiter's
+  // lifetime.
+  virtual void BindToProducerEndpoint(TracingService::ProducerEndpoint*,
+                                      base::TaskRunner*) = 0;
+
+  // Binds commits from TraceWriters created via CreateStartupTraceWriter() with
+  // the given |target_buffer_reservation_id| to |target_buffer_id|. May only be
+  // called once per |target_buffer_reservation_id|. Should be called on the
+  // arbiter's TaskRunner, and after BindToProducerEndpoint() was called.
+  // Usually, it is called by a specific data source, after it received its
+  // configuration (including the target buffer ID) from the service.
+  virtual void BindStartupTargetBuffer(uint16_t target_buffer_reservation_id,
+                                       BufferID target_buffer_id) = 0;
+
+  // Treat the reservation as resolved to an invalid buffer. Commits for this
+  // reservation will be flushed to the service ASAP. The service will free
+  // committed chunks but otherwise ignore them. The producer can call this
+  // method, for example, if connection to the tracing service failed or the
+  // session was stopped concurrently before the connection was established.
+  virtual void AbortStartupTracingForReservation(
+      uint16_t target_buffer_reservation_id) = 0;
+
+  // Notifies the service that all data for the given FlushRequestID has been
+  // committed in the shared memory buffer. Should only be called while bound.
+  virtual void NotifyFlushComplete(FlushRequestID) = 0;
+
+  // Sets the duration during which commits are batched. Args:
+  // |batch_commits_duration_ms|: The length of the period, during which commits
+  // by all trace writers are accumulated, before being sent to the service.
+  // When the period ends, all accumulated commits are flushed. On the first
+  // commit after the last flush, another delayed flush is scheduled to run in
+  // |batch_commits_duration_ms|. If an immediate flush occurs (via
+  // FlushPendingCommitDataRequests()) during a batching period, any
+  // accumulated commits up to that point will be sent to the service
+  // immediately. And when the batching period ends, the commits that occurred
+  // after the immediate flush will also be sent to the service.
+  //
+  // If the duration has already been set to a non-zero value before this method
+  // is called, and there is already a scheduled flush with the previously-set
+  // duration, the new duration will take effect after the scheduled flush
+  // occurs.
+  //
+  // If |batch_commits_duration_ms| is non-zero, batched data that hasn't been
+  // sent could be lost at the end of a tracing session. To avoid this,
+  // producers should make sure that FlushPendingCommitDataRequests is called
+  // after the last TraceWriter write and before the service has stopped
+  // listening for commits from the tracing session's data sources (i.e.
+  // data sources should stop asynchronously, see
+  // DataSourceDescriptor.will_notify_on_stop=true).
+  virtual void SetBatchCommitsDuration(uint32_t batch_commits_duration_ms) = 0;
+
+  // Called to enable direct producer-side patching of chunks that have not yet
+  // been committed to the service. The return value indicates whether direct
+  // patching was successfully enabled. It will be true if
+  // SharedMemoryArbiter::SetDirectSMBPatchingSupportedByService has been called
+  // and false otherwise.
+  virtual bool EnableDirectSMBPatching() = 0;
+
+  // When the producer and service live in separate processes, this method
+  // should be called if the producer receives an
+  // InitializeConnectionResponse.direct_smb_patching_supported set to true by
+  // the service (see producer_port.proto) .
+  //
+  // In the in-process case, the service will always support direct SMB patching
+  // and this method should always be called.
+  virtual void SetDirectSMBPatchingSupportedByService() = 0;
+
+  // Forces an immediate commit of the completed packets, without waiting for
+  // the next task or for a batching period to end. Should only be called while
+  // bound.
+  virtual void FlushPendingCommitDataRequests(
+      std::function<void()> callback = {}) = 0;
+
+  // Called when SMB scraping needs to occur on the producer-side. This only
+  // happens on producers using shmem emulation, given the tracing service
+  // doesn't have access to the SMB. If uncommitted chunks are found in the
+  // buffer they are marked completed, forcing a commit of the chunks to the
+  // tracing service.
+  virtual void ScrapeEmulatedSharedMemoryBuffer(
+      const std::map<WriterID, BufferID>& buffer_for_writers) = 0;
+
+  // Attempts to shut down this arbiter. This function prevents new trace
+  // writers from being created for this this arbiter, but if there are any
+  // existing trace writers, the shutdown cannot proceed and this funtion
+  // returns false. The caller should not delete the arbiter before all of its
+  // associated trace writers have been destroyed and this function returns
+  // true.
+  virtual bool TryShutdown() = 0;
+
+  // Create a bound arbiter instance. Args:
+  // |SharedMemory|: the shared memory buffer to use.
+  // |page_size|: a multiple of 4KB that defines the granularity of tracing
+  // pages. See tradeoff considerations in shared_memory_abi.h.
+  // |ProducerEndpoint|: The service's producer endpoint used e.g. to commit
+  // chunks and register trace writers.
+  // |TaskRunner|: Task runner for perfetto's main thread, which executes the
+  // OnPagesCompleteCallback and IPC calls to the |ProducerEndpoint|.
+  //
+  // Implemented in src/core/shared_memory_arbiter_impl.cc.
+  static std::unique_ptr<SharedMemoryArbiter> CreateInstance(
+      SharedMemory*,
+      size_t page_size,
+      ShmemMode,
+      TracingService::ProducerEndpoint*,
+      base::TaskRunner*);
+
+  // Create an unbound arbiter instance, which should later be bound to a
+  // ProducerEndpoint and TaskRunner by calling BindToProducerEndpoint(). The
+  // returned arbiter will ONLY support trace writers with
+  // BufferExhaustedPolicy::kDrop.
+  //
+  // An unbound SharedMemoryArbiter can be used to write to a producer-created
+  // SharedMemory buffer before the producer connects to the tracing service.
+  // The producer can then pass this SMB to the service when it connects (see
+  // TracingService::ConnectProducer).
+  //
+  // To trace into the SMB before the service starts the tracing session, trace
+  // writers can be obtained via CreateStartupTraceWriter() and later associated
+  // with a target buffer via BindStartupTargetBuffer(), once the target buffer
+  // is known.
+  //
+  // Implemented in src/core/shared_memory_arbiter_impl.cc. See CreateInstance()
+  // for comments about the arguments.
+  static std::unique_ptr<SharedMemoryArbiter>
+  CreateUnboundInstance(SharedMemory*, size_t page_size, ShmemMode mode);
+};
+
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_SHARED_MEMORY_ARBITER_H_
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SRC_TRACING_CORE_SHARED_MEMORY_ARBITER_IMPL_H_
+#define SRC_TRACING_CORE_SHARED_MEMORY_ARBITER_IMPL_H_
+
+#include <stdint.h>
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <vector>
+
+// gen_amalgamated expanded: #include "perfetto/ext/base/rt_mutex.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/weak_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_abi.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_arbiter.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
+// gen_amalgamated expanded: #include "src/tracing/core/id_allocator.h"
+
+namespace perfetto {
+
+class PatchList;
+class Patch;
+class TraceWriter;
+class TraceWriterImpl;
+
+namespace base {
+class TaskRunner;
+}  // namespace base
+
+// This class handles the shared memory buffer on the producer side. It is used
+// to obtain thread-local chunks and to partition pages from several threads.
+// There is one arbiter instance per Producer.
+// This class is thread-safe and uses locks to do so. Data sources are supposed
+// to interact with this sporadically, only when they run out of space on their
+// current thread-local chunk.
+//
+// The arbiter can become "unbound" as a consequence of:
+//  (a) being created without an endpoint
+//  (b) CreateStartupTraceWriter calls after creation (whether created with or
+//      without endpoint).
+//
+// Entering the unbound state is only supported if all trace writers are created
+// in kDrop mode. In the unbound state, the arbiter buffers commit messages
+// until all trace writers are bound to a target buffer.
+//
+// The following state transitions are possible:
+//
+//   CreateInstance()
+//    |
+//    |  CreateUnboundInstance()
+//    |    |
+//    |    |
+//    |    V
+//    |  [ !fully_bound_, !endpoint_, 0 unbound buffer reservations ]
+//    |      |     |
+//    |      |     | CreateStartupTraceWriter(buf)
+//    |      |     |  buffer reservations += buf
+//    |      |     |
+//    |      |     |             ----
+//    |      |     |            |    | CreateStartupTraceWriter(buf)
+//    |      |     |            |    |  buffer reservations += buf
+//    |      |     V            |    V
+//    |      |   [ !fully_bound_, !endpoint_, >=1 unbound buffer reservations ]
+//    |      |                                                |
+//    |      |                       BindToProducerEndpoint() |
+//    |      |                                                |
+//    |      | BindToProducerEndpoint()                       |
+//    |      |                                                V
+//    |      |   [ !fully_bound_, endpoint_, >=1 unbound buffer reservations ]
+//    |      |   A    |    A                               |     A
+//    |      |   |    |    |                               |     |
+//    |      |   |     ----                                |     |
+//    |      |   |    CreateStartupTraceWriter(buf)        |     |
+//    |      |   |     buffer reservations += buf          |     |
+//    |      |   |                                         |     |
+//    |      |   | CreateStartupTraceWriter(buf)           |     |
+//    |      |   |  where buf is not yet bound             |     |
+//    |      |   |  buffer reservations += buf             |     | (yes)
+//    |      |   |                                         |     |
+//    |      |   |        BindStartupTargetBuffer(buf, id) |-----
+//    |      |   |           buffer reservations -= buf    | reservations > 0?
+//    |      |   |                                         |
+//    |      |   |                                         | (no)
+//    |      V   |                                         V
+//     --> [ fully_bound_, endpoint_, 0 unbound buffer reservations ]
+//              |    A
+//              |    | CreateStartupTraceWriter(buf)
+//              |    |  where buf is already bound
+//               ----
+class SharedMemoryArbiterImpl : public SharedMemoryArbiter {
+ public:
+  // See SharedMemoryArbiter::CreateInstance(). |start|, |size| define the
+  // boundaries of the shared memory buffer. ProducerEndpoint and TaskRunner may
+  // be |nullptr| if created unbound, see
+  // SharedMemoryArbiter::CreateUnboundInstance().
+
+  // SharedMemoryArbiterImpl(void* start,
+  //                         size_t size,
+  //                         size_t page_size,
+  //                         TracingService::ProducerEndpoint*
+  //                         producer_endpoint, base::TaskRunner* task_runner) :
+  //   SharedMemoryArbiterImpl(start, size, page_size, false, producer_endpoint,
+  //   task_runner) {
+  // }
+
+  SharedMemoryArbiterImpl(void* start,
+                          size_t size,
+                          ShmemMode mode,
+                          size_t page_size,
+                          TracingService::ProducerEndpoint*,
+                          base::TaskRunner*);
+
+  // Returns a new Chunk to write tracing data. Depending on the provided
+  // BufferExhaustedPolicy, this may return an invalid chunk if no valid free
+  // chunk could be found in the SMB.
+  SharedMemoryABI::Chunk GetNewChunk(const SharedMemoryABI::ChunkHeader&,
+                                     BufferExhaustedPolicy);
+
+  // Puts back a Chunk that has been completed and sends a request to the
+  // service to move it to the central tracing buffer. |target_buffer| is the
+  // absolute trace buffer ID where the service should move the chunk onto (the
+  // producer is just to copy back the same number received in the
+  // DataSourceConfig upon the StartDataSource() request).
+  // PatchList is a pointer to the list of patches for previous chunks. The
+  // first patched entries will be removed from the patched list and sent over
+  // to the service in the same CommitData() IPC request.
+  void ReturnCompletedChunk(SharedMemoryABI::Chunk,
+                            MaybeUnboundBufferID target_buffer,
+                            PatchList*);
+
+  // Send a request to the service to apply completed patches from |patch_list|.
+  // |writer_id| is the ID of the TraceWriter that calls this method,
+  // |target_buffer| is the global trace buffer ID of its target buffer.
+  void SendPatches(WriterID writer_id,
+                   MaybeUnboundBufferID target_buffer,
+                   PatchList* patch_list);
+
+  SharedMemoryABI* shmem_abi_for_testing() { return &shmem_abi_; }
+
+  static void set_default_layout_for_testing(SharedMemoryABI::PageLayout l) {
+    default_page_layout = l;
+  }
+
+  static SharedMemoryABI::PageLayout default_page_layout_for_testing() {
+    return default_page_layout;
+  }
+
+  // F is lambda with signature:
+  // void(SharedMemoryABI::Chunk*, bool chunk_complete,
+  //      uint16_t packet_count, uint8_t packet_flags)
+  template <typename F>
+  static inline void ForEachScrapableChunk(SharedMemoryABI* shmem_abi,
+                                           F handle_chunk_function) {
+    static_assert(std::is_invocable_v<F, SharedMemoryABI::Chunk*, bool,
+                                      uint16_t, uint8_t>);
+    // num_pages() is immutable after the SMB is initialized and cannot be
+    // changed even by a producer even if malicious.
+    for (size_t page_idx = 0; page_idx < shmem_abi->num_pages(); page_idx++) {
+      uint32_t header_bitmap = shmem_abi->GetPageHeaderBitmap(page_idx);
+
+      uint32_t used_chunks =
+          shmem_abi->GetUsedChunks(header_bitmap);  // Returns a bitmap.
+      // Skip empty pages.
+      if (used_chunks == 0) {
+        continue;
+      }
+
+      // Scrape the chunks that are currently used. These should be either in
+      // state kChunkBeingWritten or kChunkComplete.
+      for (uint32_t chunk_idx = 0; used_chunks;
+           chunk_idx++, used_chunks >>= 1) {
+        if (!(used_chunks & 1))
+          continue;
+
+        auto state = SharedMemoryABI::GetChunkStateFromHeaderBitmap(
+            header_bitmap, chunk_idx);
+        PERFETTO_DCHECK(state == SharedMemoryABI::kChunkBeingWritten ||
+                        state == SharedMemoryABI::kChunkComplete);
+        bool chunk_complete = state == SharedMemoryABI::kChunkComplete;
+
+        SharedMemoryABI::Chunk chunk =
+            shmem_abi->GetChunkUnchecked(page_idx, header_bitmap, chunk_idx);
+
+        uint16_t packet_count;
+        uint8_t packet_flags;
+        // GetPacketCountAndFlags has acquire_load semantics.
+        std::tie(packet_count, packet_flags) = chunk.GetPacketCountAndFlags();
+
+        // It only makes sense to copy an incomplete chunk if there's at least
+        // one full packet available. (The producer may not have completed the
+        // last packet in it yet, so we need at least 2.)
+        if (!chunk_complete && packet_count < 2)
+          continue;
+
+        // At this point, it is safe to access the remaining header fields of
+        // the chunk. Even if the chunk was only just transferred from
+        // kChunkFree into kChunkBeingWritten state, the header should be
+        // written completely once the packet count increased above 1 (it was
+        // reset to 0 by the service when the chunk was freed).
+        handle_chunk_function(&chunk, chunk_complete, packet_count,
+                              packet_flags);
+      }
+    }
+  }
+
+  // SharedMemoryArbiter implementation.
+  // See include/perfetto/tracing/core/shared_memory_arbiter.h for comments.
+  std::unique_ptr<TraceWriter> CreateTraceWriter(
+      BufferID target_buffer,
+      BufferExhaustedPolicy) override;
+  std::unique_ptr<TraceWriter> CreateStartupTraceWriter(
+      uint16_t target_buffer_reservation_id) override;
+  void BindToProducerEndpoint(TracingService::ProducerEndpoint*,
+                              base::TaskRunner*) override;
+  void BindStartupTargetBuffer(uint16_t target_buffer_reservation_id,
+                               BufferID target_buffer_id) override;
+  void AbortStartupTracingForReservation(
+      uint16_t target_buffer_reservation_id) override;
+  void NotifyFlushComplete(FlushRequestID) override;
+
+  void SetBatchCommitsDuration(uint32_t batch_commits_duration_ms) override;
+
+  bool EnableDirectSMBPatching() override;
+
+  void SetDirectSMBPatchingSupportedByService() override;
+
+  void FlushPendingCommitDataRequests(
+      std::function<void()> callback = {}) override;
+  void ScrapeEmulatedSharedMemoryBuffer(
+      const std::map<WriterID, BufferID>& buffer_for_writers) override;
+  bool TryShutdown() override;
+
+  base::TaskRunner* task_runner() const { return task_runner_; }
+  size_t page_size() const { return shmem_abi_.page_size(); }
+  size_t num_pages() const { return shmem_abi_.num_pages(); }
+
+  base::WeakPtr<SharedMemoryArbiterImpl> GetWeakPtr() const {
+    return weak_ptr_factory_.GetWeakPtr();
+  }
+
+ private:
+  friend class TraceWriterImpl;
+  friend class StartupTraceWriterTest;
+  friend class SharedMemoryArbiterImplTest;
+
+  struct TargetBufferReservation {
+    bool resolved = false;
+    BufferID target_buffer = kInvalidBufferId;
+  };
+
+  // Placeholder for the actual target buffer ID of a startup target buffer
+  // reservation ID in |target_buffer_reservations_|.
+  static constexpr BufferID kInvalidBufferId = 0;
+
+  static SharedMemoryABI::PageLayout default_page_layout;
+
+  SharedMemoryArbiterImpl(const SharedMemoryArbiterImpl&) = delete;
+  SharedMemoryArbiterImpl& operator=(const SharedMemoryArbiterImpl&) = delete;
+
+  void UpdateCommitDataRequest(SharedMemoryABI::Chunk chunk,
+                               WriterID writer_id,
+                               MaybeUnboundBufferID target_buffer,
+                               PatchList* patch_list);
+
+  // Search the chunks that are being batched in |commit_data_req_| for a chunk
+  // that needs patching and that matches the provided |writer_id| and
+  // |patch.chunk_id|. If found, apply |patch| to that chunk, and if
+  // |chunk_needs_more_patching| is true, clear the needs patching flag of the
+  // chunk and mark it as complete - to allow the service to read it (and other
+  // chunks after it) during scraping. Returns true if the patch was applied,
+  // false otherwise.
+  //
+  // Note: the caller must be holding |lock_| for the duration of the call.
+  bool TryDirectPatchLocked(WriterID writer_id,
+                            const Patch& patch,
+                            bool chunk_needs_more_patching);
+  std::unique_ptr<TraceWriter> CreateTraceWriterInternal(
+      MaybeUnboundBufferID target_buffer,
+      BufferExhaustedPolicy);
+
+  // Called by the TraceWriter destructor.
+  void ReleaseWriterID(WriterID);
+
+  void BindStartupTargetBufferImpl(
+      std::unique_lock<base::MaybeRtMutex> scoped_lock,
+      uint16_t target_buffer_reservation_id,
+      BufferID target_buffer_id);
+
+  // Returns some statistics about chunks/pages in the shared memory buffer.
+  struct Stats {
+    size_t chunks_free = 0;
+    size_t chunks_being_written = 0;
+    size_t chunks_being_read = 0;
+    size_t chunks_complete = 0;
+
+    // No chunks are included from free/malformed pages.
+    size_t pages_free = 0;
+    size_t pages_unexpected = 0;
+  };
+  Stats GetStats();
+
+  // If any flush callbacks were queued up while the arbiter or any target
+  // buffer reservation was unbound, this wraps the pending callbacks into a new
+  // std::function and returns it. Otherwise returns an invalid std::function.
+  std::function<void()> TakePendingFlushCallbacksLocked();
+
+  // Replace occurrences of target buffer reservation IDs in |commit_data_req_|
+  // with their respective actual BufferIDs if they were already bound. Returns
+  // true iff all occurrences were replaced.
+  bool ReplaceCommitPlaceholderBufferIdsLocked();
+
+  // Update and return |fully_bound_| based on the arbiter's |pending_writers_|
+  // state.
+  bool UpdateFullyBoundLocked();
+
+  // Only accessed on |task_runner_| after the producer endpoint was bound.
+  TracingService::ProducerEndpoint* producer_endpoint_ = nullptr;
+
+  // Set to true when this instance runs in a emulation mode for a producer
+  // endpoint that doesn't support shared memory (e.g. vsock).
+  const bool use_shmem_emulation_ = false;
+
+  // --- Begin lock-protected members ---
+
+  base::MaybeRtMutex lock_;
+
+  base::TaskRunner* task_runner_ = nullptr;
+  SharedMemoryABI shmem_abi_;
+  size_t page_idx_ = 0;
+  std::unique_ptr<CommitDataRequest> commit_data_req_;
+  size_t bytes_pending_commit_ = 0;  // SUM(chunk.size() : commit_data_req_).
+  IdAllocator<WriterID> active_writer_ids_;
+  bool did_shutdown_ = false;
+
+  // Whether the arbiter itself and all startup target buffer reservations are
+  // bound. Note that this can become false again later if a new target buffer
+  // reservation is created by calling CreateStartupTraceWriter() with a new
+  // reservation id.
+  bool fully_bound_;
+
+  // Whether the arbiter was always bound. If false, the arbiter was unbound at
+  // one point in time.
+  bool was_always_bound_;
+
+  // Whether all created trace writers were created with kDrop policy.
+  bool all_writers_have_drop_policy_ = true;
+
+  // IDs of writers and their assigned target buffers that should be registered
+  // with the service after the arbiter and/or their startup target buffer is
+  // bound.
+  std::map<WriterID, MaybeUnboundBufferID> pending_writers_;
+
+  // Callbacks for flush requests issued while the arbiter or a target buffer
+  // reservation was unbound.
+  std::vector<std::function<void()>> pending_flush_callbacks_;
+
+  // See SharedMemoryArbiter::SetBatchCommitsDuration.
+  uint32_t batch_commits_duration_ms_ = 0;
+
+  // See SharedMemoryArbiter::EnableDirectSMBPatching.
+  bool direct_patching_enabled_ = false;
+
+  // See SharedMemoryArbiter::SetDirectSMBPatchingSupportedByService.
+  bool direct_patching_supported_by_service_ = false;
+
+  // Indicates whether we have already scheduled a delayed flush for the
+  // purposes of batching. Set to true at the beginning of a batching period and
+  // cleared at the end of the period. Immediate flushes that happen during a
+  // batching period will empty the |commit_data_req| (triggering an immediate
+  // IPC to the service), but will not clear this flag and the
+  // previously-scheduled delayed flush will still occur at the end of the
+  // batching period.
+  bool delayed_flush_scheduled_ = false;
+
+  // Indicates whether we have already scheduled an immediate flush due to the
+  // shared memory buffer being more than half full. Set to true when the first
+  // immediate flush is posted and cleared when the flush completes. This
+  // prevents posting multiple immediate flush tasks when chunks continue to be
+  // committed while the buffer remains over 50% full.
+  bool immediate_flush_scheduled_ = false;
+
+  // Stores target buffer reservations for writers created via
+  // CreateStartupTraceWriter(). A bound reservation sets
+  // TargetBufferReservation::resolved to true and is associated with the actual
+  // BufferID supplied in BindStartupTargetBuffer().
+  //
+  // TODO(eseckler): Clean up entries from this map. This would probably require
+  // a method in SharedMemoryArbiter that allows a producer to invalidate a
+  // reservation ID.
+  std::map<MaybeUnboundBufferID, TargetBufferReservation>
+      target_buffer_reservations_;
+
+  // --- End lock-protected members ---
+
+  // Keep at the end.
+  base::WeakPtrFactory<SharedMemoryArbiterImpl> weak_ptr_factory_;
+};
+
+}  // namespace perfetto
+
+#endif  // SRC_TRACING_CORE_SHARED_MEMORY_ARBITER_IMPL_H_
+// gen_amalgamated begin header: include/perfetto/ext/tracing/core/commit_data_request.h
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_COMMIT_DATA_REQUEST_H_
+#define INCLUDE_PERFETTO_EXT_TRACING_CORE_COMMIT_DATA_REQUEST_H_
+
+// Creates the aliases in the ::perfetto namespace, doing things like:
+// using ::perfetto::Foo = ::perfetto::protos::gen::Foo.
+// See comments in forward_decls.h for the historical reasons of this
+// indirection layer.
+// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
+
+// gen_amalgamated expanded: #include "protos/perfetto/common/commit_data_request.gen.h"
+
+#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_COMMIT_DATA_REQUEST_H_
+// gen_amalgamated begin header: src/tracing/core/trace_writer_impl.h
+// gen_amalgamated begin header: src/tracing/core/patch_list.h
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SRC_TRACING_CORE_PATCH_LIST_H_
+#define SRC_TRACING_CORE_PATCH_LIST_H_
+
+#include <array>
+#include <forward_list>
+
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_abi.h"
+
+namespace perfetto {
+
+// Used to handle the backfilling of the headers (the |size_field|) of nested
+// messages when a proto is fragmented over several chunks. These patches are
+// sent out-of-band to the tracing service, after having returned the initial
+// chunks of the fragment.
+// TODO(crbug.com/904477): Re-disable the move constructors when all usses of
+// this class have been fixed.
+class Patch {
+ public:
+  using PatchContent = std::array<uint8_t, SharedMemoryABI::kPacketHeaderSize>;
+  Patch(ChunkID c, uint16_t o) : chunk_id(c), offset(o) {}
+  Patch(const Patch&) = default;  // For tests.
+
+  const ChunkID chunk_id;
+  const uint16_t offset;
+  PatchContent size_field{};
+
+  // |size_field| contains a varint. Any varint must start with != 0. Even in
+  // the case we want to encode a size == 0, protozero will write a redundant
+  // varint for that, that is [0x80, 0x80, 0x80, 0x00]. So the first byte is 0
+  // iff we never wrote any varint into that.
+  bool is_patched() const { return size_field[0] != 0; }
+
+  // For tests.
+  bool operator==(const Patch& o) const {
+    return chunk_id == o.chunk_id && offset == o.offset &&
+           size_field == o.size_field;
+  }
+
+ private:
+  Patch& operator=(const Patch&) = delete;
+};
+
+// Note: the protozero::Message(s) will take pointers to the |size_field| of
+// these entries. This container must guarantee that the Patch objects are never
+// moved around (i.e. cannot be a vector because of reallocations can change
+// addresses of pre-existing entries).
+class PatchList {
+ public:
+  using ListType = std::forward_list<Patch>;
+  using value_type = ListType::value_type;          // For gtest.
+  using const_iterator = ListType::const_iterator;  // For gtest.
+
+  PatchList() : last_(list_.before_begin()) {}
+
+  Patch* emplace_back(ChunkID chunk_id, uint16_t offset) {
+    last_ = list_.emplace_after(last_, chunk_id, offset);
+    return &*last_;
+  }
+
+  void pop_front() {
+    PERFETTO_DCHECK(!list_.empty());
+    list_.pop_front();
+    if (empty())
+      last_ = list_.before_begin();
+  }
+
+  const Patch& front() const {
+    PERFETTO_DCHECK(!list_.empty());
+    return list_.front();
+  }
+
+  const Patch& back() const {
+    PERFETTO_DCHECK(!list_.empty());
+    return *last_;
+  }
+
+  ListType::const_iterator begin() const { return list_.begin(); }
+  ListType::const_iterator end() const { return list_.end(); }
+  bool empty() const { return list_.empty(); }
+
+ private:
+  ListType list_;
+  ListType::iterator last_;
+};
+
+}  // namespace perfetto
+
+#endif  // SRC_TRACING_CORE_PATCH_LIST_H_
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SRC_TRACING_CORE_TRACE_WRITER_IMPL_H_
+#define SRC_TRACING_CORE_TRACE_WRITER_IMPL_H_
+
+#include <cstdint>
+#include <functional>
+#include <memory>
+
+// gen_amalgamated expanded: #include "perfetto/base/proc_utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_abi.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_arbiter.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/contiguous_memory_range.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message_handle.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/root_message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_stream_writer.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/buffer_exhausted_policy.h"
+// gen_amalgamated expanded: #include "src/tracing/core/patch_list.h"
+
+namespace perfetto {
+
+class SharedMemoryArbiterImpl;
+
+// See //include/perfetto/ext/tracing/core/trace_writer.h for docs.
+//
+// Locking will happen only when a chunk is exhausted and a new one is
+// acquired from the arbiter.
+//
+// TODO: TraceWriter needs to keep the shared memory buffer alive (refcount?).
+// Otherwise if the shared memory buffer goes away (e.g. the Service crashes)
+// the TraceWriter will keep writing into unmapped memory.
+//
+class TraceWriterImpl : public TraceWriter,
+                        public protozero::MessageFinalizationListener,
+                        public protozero::ScatteredStreamWriter::Delegate {
+ public:
+  // TracePacketHandle is defined in trace_writer.h
+  TraceWriterImpl(SharedMemoryArbiterImpl*,
+                  WriterID,
+                  MaybeUnboundBufferID buffer_id,
+                  BufferExhaustedPolicy);
+  ~TraceWriterImpl() override;
+
+  // TraceWriter implementation. See documentation in trace_writer.h.
+  TracePacketHandle NewTracePacket() override;
+  void FinishTracePacket() override;
+  // Commits the data pending for the current chunk into the shared memory
+  // buffer and sends a CommitDataRequest() to the service.
+  // TODO(primiano): right now the |callback| will be called on the IPC thread.
+  // This is fine in the current single-thread scenario, but long-term
+  // trace_writer_impl.cc should be smarter and post it on the right thread.
+  void Flush(std::function<void()> callback = {}) override;
+  WriterID writer_id() const override;
+  uint64_t written() const override {
+    return protobuf_stream_writer_.written();
+  }
+  uint64_t drop_count() const override { return drop_count_; }
+
+  bool drop_packets_for_testing() const { return drop_packets_; }
+
+ private:
+  TraceWriterImpl(const TraceWriterImpl&) = delete;
+  TraceWriterImpl& operator=(const TraceWriterImpl&) = delete;
+
+  // ScatteredStreamWriter::Delegate implementation.
+  protozero::ContiguousMemoryRange GetNewBuffer() override;
+  uint8_t* AnnotatePatch(uint8_t*) override;
+
+  // MessageFinalizationListener implementation.
+  void OnMessageFinalized(protozero::Message*) override;
+
+  // Writes the size of the current fragment into the chunk.
+  //
+  // The size of nested messages inside TracePacket is written by
+  // by the user, but the size of the TracePacket fragments is written by
+  // TraceWriterImpl.
+  void FinalizeFragmentIfRequired();
+
+  // Returns |cur_chunk_| (for which is_valid() must be true) to the
+  // |shmem_arbiter|.
+  void ReturnCompletedChunk();
+
+  // The per-producer arbiter that coordinates access to the shared memory
+  // buffer from several threads.
+  SharedMemoryArbiterImpl* const shmem_arbiter_;
+
+  // ID of the current writer.
+  const WriterID id_;
+
+  // This is copied into the commit request by SharedMemoryArbiter. See comments
+  // in data_source_config.proto for |target_buffer|. If this is a reservation
+  // for a buffer ID in case of a startup trace writer, SharedMemoryArbiterImpl
+  // will also translate the reservation ID to the actual buffer ID.
+  const MaybeUnboundBufferID target_buffer_;
+
+  // Whether GetNewChunk() should stall or return an invalid chunk if the SMB is
+  // exhausted.
+  const BufferExhaustedPolicy buffer_exhausted_policy_;
+
+  // Monotonic (% wrapping) sequence id of the chunk. Together with the WriterID
+  // this allows the Service to reconstruct the linear sequence of packets.
+  ChunkID next_chunk_id_ = 0;
+
+  // The chunk we are holding onto (if any).
+  SharedMemoryABI::Chunk cur_chunk_;
+
+  // Passed to protozero message to write directly into |cur_chunk_|. It
+  // keeps track of the write pointer. It calls us back (GetNewBuffer()) when
+  // |cur_chunk_| is filled.
+  protozero::ScatteredStreamWriter protobuf_stream_writer_;
+
+  // The packet returned via NewTracePacket(). Its owned by this class,
+  // TracePacketHandle has just a pointer to it.
+  //
+  // The caller of NewTracePacket can use TakeStreamWriter() and use the stream
+  // writer directly: in that case:
+  // * cur_packet_->size() is not up to date. Only the stream writer has the
+  //   correct information.
+  // * cur_packet_->nested_message() is always nullptr.
+  // * cur_packet_->size_field() is still used to track the start of the current
+  //   fragment.
+  std::unique_ptr<protozero::RootMessage<protos::pbzero::TracePacket>>
+      cur_packet_;
+
+  // The start address of |cur_packet_| within |cur_chunk_|. Used to figure out
+  // fragments sizes when a TracePacket write is interrupted by GetNewBuffer().
+  uint8_t* cur_fragment_start_ = nullptr;
+
+  // true if we received a call to GetNewBuffer() after NewTracePacket(),
+  // false if GetNewBuffer() happened during NewTracePacket() prologue, while
+  // starting the TracePacket header.
+  bool fragmenting_packet_ = false;
+
+  // Set to |true| when the current chunk contains the maximum number of packets
+  // a chunk can contain. When this is |true|, the next packet requires starting
+  // a new chunk.
+  bool reached_max_packets_per_chunk_ = false;
+
+  // If we fail to acquire a new chunk when the arbiter operates in
+  // SharedMemory::BufferExhaustedPolicy::kDrop mode, the trace writer enters a
+  // mode in which data is written to a local garbage chunk and dropped.
+  bool drop_packets_ = false;
+
+  // Whether the trace writer should try to acquire a new chunk from the SMB
+  // when the next TracePacket is started because it filled the garbage chunk at
+  // least once since the last attempt.
+  bool retry_new_chunk_after_packet_ = false;
+
+  // Set to true if `cur_chunk_` has a packet counter that's inflated by one.
+  // The count may be inflated to convince the tracing service scraping logic
+  // that the last packet has been completed. When this is true, cur_chunk_
+  // should have at least `kExtraRoomForInflatedPacket` bytes free.
+  bool cur_chunk_packet_count_inflated_ = false;
+
+  // Points to the size field of the still open fragment we're writing to the
+  // current chunk. If the chunk was already returned, this is reset to
+  // |nullptr|. If the fragment is finalized, this is reset to |nullptr|.
+  //
+  // Note: for nested messages the field is tracked somewhere else
+  // (protozero::Message::size_field_ or PerfettoPbMsg::size_field). For the
+  // root message, protozero::Message::size_field_ is nullptr and this is used
+  // instead. This is because at the root level we deal with fragments, not
+  // logical messages.
+  uint8_t* cur_fragment_size_field_ = nullptr;
+
+  // When a packet is fragmented across different chunks, the |size_field| of
+  // the outstanding nested protobuf messages is redirected onto Patch entries
+  // in this list at the time the Chunk is returned (because at that point we
+  // have to release the ownership of the current Chunk). This list will be
+  // later sent out-of-band to the tracing service, who will patch the required
+  // chunks, if they are still around.
+  PatchList patch_list_;
+
+  // PID of the process that created the trace writer. Used for a DCHECK that
+  // aims to detect unsupported process forks while tracing.
+  const base::PlatformProcessId process_id_;
+
+  // True for the first packet on sequence. See the comment for
+  // TracePacket.first_packet_on_sequence for more details.
+  bool first_packet_on_sequence_ = true;
+
+  // Number of times the trace writter entered a
+  // SharedMemory::BufferExhaustedPolicy::kDrop mode (i.e. as indicated by the
+  // `drop_packets_` variable). Note that this does *not* necessarily equal the
+  // number of trace packets dropped as multiple packets could have been dropped
+  // in one entry into kDrop mode (i.e. this variable will be a *lower bound*
+  // but *not* an upper bound).
+  uint64_t drop_count_ = 0;
+};
+
+}  // namespace perfetto
+
+#endif  // SRC_TRACING_CORE_TRACE_WRITER_IMPL_H_
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "src/tracing/core/shared_memory_arbiter_impl.h"
+
+#include <algorithm>
+#include <limits>
+#include <utility>
+
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
+// gen_amalgamated expanded: #include "perfetto/base/time.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/flags.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/commit_data_request.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_abi.h"
+// gen_amalgamated expanded: #include "src/tracing/core/null_trace_writer.h"
+// gen_amalgamated expanded: #include "src/tracing/core/trace_writer_impl.h"
+
+namespace perfetto {
+
+using Chunk = SharedMemoryABI::Chunk;
+
+namespace {
+static_assert(sizeof(BufferID) == sizeof(uint16_t),
+              "The MaybeUnboundBufferID logic requires BufferID not to grow "
+              "above uint16_t.");
+
+MaybeUnboundBufferID MakeTargetBufferIdForReservation(uint16_t reservation_id) {
+  // Reservation IDs are stored in the upper bits.
+  PERFETTO_CHECK(reservation_id > 0);
+  return static_cast<MaybeUnboundBufferID>(reservation_id) << 16;
+}
+
+bool IsReservationTargetBufferId(MaybeUnboundBufferID buffer_id) {
+  return (buffer_id >> 16) > 0;
+}
+}  // namespace
+
+// static
+SharedMemoryABI::PageLayout SharedMemoryArbiterImpl::default_page_layout =
+    SharedMemoryABI::PageLayout::kPageDiv1;
+
+// static
+std::unique_ptr<SharedMemoryArbiter> SharedMemoryArbiter::CreateInstance(
+    SharedMemory* shared_memory,
+    size_t page_size,
+    ShmemMode mode,
+    TracingService::ProducerEndpoint* producer_endpoint,
+    base::TaskRunner* task_runner) {
+  return std::unique_ptr<SharedMemoryArbiterImpl>(new SharedMemoryArbiterImpl(
+      shared_memory->start(), shared_memory->size(), mode, page_size,
+      producer_endpoint, task_runner));
+}
+
+// static
+std::unique_ptr<SharedMemoryArbiter> SharedMemoryArbiter::CreateUnboundInstance(
+    SharedMemory* shared_memory,
+    size_t page_size,
+    ShmemMode mode) {
+  return std::unique_ptr<SharedMemoryArbiterImpl>(new SharedMemoryArbiterImpl(
+      shared_memory->start(), shared_memory->size(), mode, page_size,
+      /*producer_endpoint=*/nullptr, /*task_runner=*/nullptr));
+}
+
+SharedMemoryArbiterImpl::SharedMemoryArbiterImpl(
+    void* start,
+    size_t size,
+    ShmemMode mode,
+    size_t page_size,
+    TracingService::ProducerEndpoint* producer_endpoint,
+    base::TaskRunner* task_runner)
+    : producer_endpoint_(producer_endpoint),
+      use_shmem_emulation_(mode == ShmemMode::kShmemEmulation),
+      task_runner_(task_runner),
+      shmem_abi_(reinterpret_cast<uint8_t*>(start), size, page_size, mode),
+      active_writer_ids_(kMaxWriterID),
+      fully_bound_(task_runner && producer_endpoint),
+      was_always_bound_(fully_bound_),
+      weak_ptr_factory_(this) {}
+
+Chunk SharedMemoryArbiterImpl::GetNewChunk(
+    const SharedMemoryABI::ChunkHeader& header,
+    BufferExhaustedPolicy buffer_exhausted_policy) {
+  int stall_count = 0;
+  unsigned stall_interval_us = 0;
+  bool task_runner_runs_on_current_thread = false;
+  static const unsigned kMaxStallIntervalUs = 100000;
+  static const int kLogAfterNStalls = 3;
+  static const int kFlushCommitsAfterEveryNStalls = 2;
+  static const int kAssertAtNStalls = 300;
+
+  bool should_stall = false;
+  bool should_abort = false;
+
+  switch (buffer_exhausted_policy) {
+    case BufferExhaustedPolicy::kDrop:
+      break;
+    case BufferExhaustedPolicy::kStall:
+      should_stall = true;
+      should_abort = true;
+      break;
+    case BufferExhaustedPolicy::kStallThenDrop:
+      should_stall = true;
+      should_abort = false;
+      break;
+  }
+
+  for (;;) {
+    // TODO(primiano): Probably this lock is not really required and this code
+    // could be rewritten leveraging only the Try* atomic operations in
+    // SharedMemoryABI. But let's not be too adventurous for the moment.
+    {
+      std::unique_lock<base::MaybeRtMutex> scoped_lock(lock_);
+
+      // If ever unbound, we do not support stalling. In theory, we could
+      // support stalling for TraceWriters created after the arbiter and startup
+      // buffer reservations were bound, but to avoid raciness between the
+      // creation of startup writers and binding, we categorically forbid kStall
+      // mode.
+      PERFETTO_DCHECK(was_always_bound_ || !should_stall);
+
+      task_runner_runs_on_current_thread =
+          task_runner_ && task_runner_->RunsTasksOnCurrentThread();
+
+      // If more than half of the SMB.size() is filled with completed chunks for
+      // which we haven't notified the service yet (i.e. they are still enqueued
+      // in |commit_data_req_|), force a synchronous CommitDataRequest() even if
+      // we acquire a chunk, to reduce the likeliness of stalling the writer.
+      //
+      // We can only do this if we're writing on the same thread that we access
+      // the producer endpoint on, since we cannot notify the producer endpoint
+      // to commit synchronously on a different thread. Attempting to flush
+      // synchronously on another thread will lead to subtle bugs caused by
+      // out-of-order commit requests (crbug.com/919187#c28).
+      bool should_commit_synchronously =
+          task_runner_runs_on_current_thread && should_stall &&
+          commit_data_req_ && bytes_pending_commit_ >= shmem_abi_.size() / 2;
+
+      const size_t initial_page_idx = page_idx_;
+      for (size_t i = 0; i < shmem_abi_.num_pages(); i++) {
+        page_idx_ = (initial_page_idx + i) % shmem_abi_.num_pages();
+        bool is_new_page = false;
+
+        // TODO(primiano): make the page layout dynamic.
+        auto layout = SharedMemoryArbiterImpl::default_page_layout;
+
+        if (shmem_abi_.is_page_free(page_idx_)) {
+          is_new_page = shmem_abi_.TryPartitionPage(page_idx_, layout);
+        }
+        uint32_t free_chunks;
+        if (is_new_page) {
+          free_chunks = (1 << SharedMemoryABI::kNumChunksForLayout[layout]) - 1;
+        } else {
+          free_chunks = shmem_abi_.GetFreeChunks(page_idx_);
+        }
+
+        for (uint32_t chunk_idx = 0; free_chunks;
+             chunk_idx++, free_chunks >>= 1) {
+          if (!(free_chunks & 1))
+            continue;
+          // We found a free chunk.
+          Chunk chunk = shmem_abi_.TryAcquireChunkForWriting(
+              page_idx_, chunk_idx, &header);
+          if (!chunk.is_valid())
+            continue;
+          if (stall_count > kLogAfterNStalls) {
+            PERFETTO_DLOG("Recovered from stall after %d iterations",
+                          stall_count);
+          }
+
+          if (should_commit_synchronously) {
+            // We can't flush while holding the lock.
+            scoped_lock.unlock();
+            FlushPendingCommitDataRequests();
+            return chunk;
+          } else {
+            return chunk;
+          }
+        }
+      }
+    }  // scoped_lock
+
+    if (!should_stall) {
+      PERFETTO_DLOG("Shared memory buffer exhausted, returning invalid Chunk!");
+      return Chunk();
+    }
+
+    // Stalling is not supported if we were ever unbound (see earlier comment).
+    PERFETTO_CHECK(was_always_bound_);
+
+    // All chunks are taken (either kBeingWritten by us or kBeingRead by the
+    // Service).
+    if (stall_count++ == kLogAfterNStalls) {
+      PERFETTO_DLOG("Shared memory buffer overrun! Stalling");
+    }
+
+    if (stall_count == kAssertAtNStalls) {
+      if (should_abort) {
+        Stats stats = GetStats();
+        PERFETTO_FATAL(
+            "Shared memory buffer max stall count exceeded; possible deadlock "
+            "free=%zu bw=%zu br=%zu comp=%zu pages_free=%zu pages_err=%zu",
+            stats.chunks_free, stats.chunks_being_written,
+            stats.chunks_being_read, stats.chunks_complete, stats.pages_free,
+            stats.pages_unexpected);
+      } else {
+        PERFETTO_DLOG(
+            "Shared memory buffer exhausted, returning invalid Chunk!");
+        return Chunk();
+      }
+    }
+
+    // If the IPC thread itself is stalled because the current process has
+    // filled up the SMB, we need to make sure that the service can process and
+    // purge the chunks written by our process, by flushing any pending commit
+    // requests. Because other threads in our process can continue to
+    // concurrently grab, fill and commit any chunks purged by the service, it
+    // is possible that the SMB remains full and the IPC thread remains stalled,
+    // needing to flush the concurrently queued up commits again. This is
+    // particularly likely with in-process perfetto service where the IPC thread
+    // is the service thread. To avoid remaining stalled forever in such a
+    // situation, we attempt to flush periodically after every N stalls.
+    if (stall_count % kFlushCommitsAfterEveryNStalls == 0 &&
+        task_runner_runs_on_current_thread) {
+      // TODO(primiano): sending the IPC synchronously is a temporary workaround
+      // until the backpressure logic in probes_producer is sorted out. Until
+      // then the risk is that we stall the message loop waiting for the tracing
+      // service to consume the shared memory buffer (SMB) and, for this reason,
+      // never run the task that tells the service to purge the SMB. This must
+      // happen iff we are on the IPC thread, not doing this will cause
+      // deadlocks, doing this on the wrong thread causes out-of-order data
+      // commits (crbug.com/919187#c28).
+      FlushPendingCommitDataRequests();
+    } else {
+      base::SleepMicroseconds(stall_interval_us);
+      stall_interval_us =
+          std::min(kMaxStallIntervalUs, (stall_interval_us + 1) * 8);
+    }
+  }
+}
+
+void SharedMemoryArbiterImpl::ReturnCompletedChunk(
+    Chunk chunk,
+    MaybeUnboundBufferID target_buffer,
+    PatchList* patch_list) {
+  PERFETTO_DCHECK(chunk.is_valid());
+  const WriterID writer_id = chunk.writer_id();
+  UpdateCommitDataRequest(std::move(chunk), writer_id, target_buffer,
+                          patch_list);
+}
+
+void SharedMemoryArbiterImpl::SendPatches(WriterID writer_id,
+                                          MaybeUnboundBufferID target_buffer,
+                                          PatchList* patch_list) {
+  PERFETTO_DCHECK(!patch_list->empty() && patch_list->front().is_patched());
+  UpdateCommitDataRequest(Chunk(), writer_id, target_buffer, patch_list);
+}
+
+void SharedMemoryArbiterImpl::UpdateCommitDataRequest(
+    Chunk chunk,
+    WriterID writer_id,
+    MaybeUnboundBufferID target_buffer,
+    PatchList* patch_list) {
+  // Note: chunk will be invalid if the call came from SendPatches().
+  base::TaskRunner* task_runner_to_post_delayed_callback_on = nullptr;
+  // The delay with which the flush will be posted.
+  uint32_t flush_delay_ms = 0;
+  base::WeakPtr<SharedMemoryArbiterImpl> weak_this;
+  {
+    std::unique_lock<base::MaybeRtMutex> scoped_lock(lock_);
+
+    if (!commit_data_req_) {
+      commit_data_req_.reset(new CommitDataRequest());
+
+      // Flushing the commit is only supported while we're |fully_bound_|. If we
+      // aren't, we'll flush when |fully_bound_| is updated.
+      if (fully_bound_ && !delayed_flush_scheduled_) {
+        weak_this = weak_ptr_factory_.GetWeakPtr();
+        task_runner_to_post_delayed_callback_on = task_runner_;
+        flush_delay_ms = batch_commits_duration_ms_;
+        delayed_flush_scheduled_ = true;
+      }
+    }
+
+    CommitDataRequest::ChunksToMove* ctm = nullptr;  // Set if chunk is valid.
+    // If a valid chunk is specified, return it and attach it to the request.
+    if (chunk.is_valid()) {
+      PERFETTO_DCHECK(chunk.writer_id() == writer_id);
+      uint8_t chunk_idx = chunk.chunk_idx();
+      bytes_pending_commit_ += chunk.size();
+      size_t page_idx;
+
+      ctm = commit_data_req_->add_chunks_to_move();
+      // If the chunk needs patching, it should not be marked as complete yet,
+      // because this would indicate to the service that the producer will not
+      // be writing to it anymore, while the producer might still apply patches
+      // to the chunk later on. In particular, when re-reading (e.g. because of
+      // periodic scraping) a completed chunk, the service expects the flags of
+      // that chunk not to be removed between reads. So, let's say the producer
+      // marked the chunk as complete here and the service then read it for the
+      // first time. If the producer then fully patched the chunk, thus removing
+      // the kChunkNeedsPatching flag, and the service re-read the chunk after
+      // the patching, the service would be thrown off by the removed flag.
+      if (direct_patching_enabled_ &&
+          (chunk.GetPacketCountAndFlags().second &
+           SharedMemoryABI::ChunkHeader::kChunkNeedsPatching)) {
+        page_idx = shmem_abi_.GetPageAndChunkIndex(std::move(chunk)).first;
+      } else {
+        // If the chunk doesn't need patching, we can mark it as complete
+        // immediately. This allows the service to read it in full while
+        // scraping, which would not be the case if the chunk was left in a
+        // kChunkBeingWritten state.
+        page_idx = shmem_abi_.ReleaseChunkAsComplete(std::move(chunk));
+      }
+
+      // DO NOT access |chunk| after this point, it has been std::move()-d
+      // above.
+      ctm->set_page(static_cast<uint32_t>(page_idx));
+      ctm->set_chunk(chunk_idx);
+      ctm->set_target_buffer(target_buffer);
+    }
+
+    // Process the completed patches for previous chunks from the |patch_list|.
+    CommitDataRequest::ChunkToPatch* last_patch_req = nullptr;
+    while (!patch_list->empty() && patch_list->front().is_patched()) {
+      Patch curr_patch = patch_list->front();
+      patch_list->pop_front();
+      // Patches for the same chunk are contiguous in the |patch_list|. So, to
+      // determine if there are any other patches that apply to the chunk that
+      // is being patched, check if the next patch in the |patch_list| applies
+      // to the same chunk.
+      bool chunk_needs_more_patching =
+          !patch_list->empty() &&
+          patch_list->front().chunk_id == curr_patch.chunk_id;
+
+      if (direct_patching_enabled_ &&
+          TryDirectPatchLocked(writer_id, curr_patch,
+                               chunk_needs_more_patching)) {
+        continue;
+      }
+
+      // The chunk that this patch applies to has already been released to the
+      // service, so it cannot be patches here. Add the patch to the commit data
+      // request, so that it can be sent to the service and applied there.
+      if (!last_patch_req ||
+          last_patch_req->chunk_id() != curr_patch.chunk_id) {
+        last_patch_req = commit_data_req_->add_chunks_to_patch();
+        last_patch_req->set_writer_id(writer_id);
+        last_patch_req->set_chunk_id(curr_patch.chunk_id);
+        last_patch_req->set_target_buffer(target_buffer);
+      }
+      auto* patch = last_patch_req->add_patches();
+      patch->set_offset(curr_patch.offset);
+      patch->set_data(&curr_patch.size_field[0], curr_patch.size_field.size());
+    }
+
+    // Patches are enqueued in the |patch_list| in order and are notified to
+    // the service when the chunk is returned. The only case when the current
+    // patch list is incomplete is if there is an unpatched entry at the head of
+    // the |patch_list| that belongs to the same ChunkID as the last one we are
+    // about to send to the service.
+    if (last_patch_req && !patch_list->empty() &&
+        patch_list->front().chunk_id == last_patch_req->chunk_id()) {
+      last_patch_req->set_has_more_patches(true);
+    }
+
+    // If the buffer is filling up or if we are given a patch for a chunk
+    // that was already sent to the service, we don't want to wait for the next
+    // delayed flush to happen and we flush immediately. Otherwise, if we
+    // accumulate the patch and a crash occurs before the patch is sent, the
+    // service will not know of the patch and won't be able to reconstruct the
+    // trace.
+    if (fully_bound_ &&
+        (last_patch_req || bytes_pending_commit_ >= shmem_abi_.size() / 2)) {
+      bool should_post_immediate_flush = true;
+      if constexpr (PERFETTO_FLAGS(SMA_PREVENT_DUPLICATE_IMMEDIATE_FLUSHES)) {
+        // Only post an immediate flush task if we haven't already posted one.
+        // This prevents spamming the task runner with immediate flushes when
+        // the buffer remains over 50% full while chunks continue to be
+        // committed. See b/330580374.
+        should_post_immediate_flush = !immediate_flush_scheduled_;
+      }
+      if (should_post_immediate_flush) {
+        weak_this = weak_ptr_factory_.GetWeakPtr();
+        task_runner_to_post_delayed_callback_on = task_runner_;
+        flush_delay_ms = 0;
+        immediate_flush_scheduled_ = true;
+      }
+    }
+
+    // When using shmem emulation we commit the completed chunks immediately
+    // to prevent the |bytes_pending_commit_| to become greater than the size
+    // of the IPC buffer, since the chunk's data must be passed in the commit
+    // data request proto through the network socket. Not doing so could
+    // result in a "IPC Frame too large" issue on the host traced side.
+    if (fully_bound_ && use_shmem_emulation_) {
+      if (task_runner_->RunsTasksOnCurrentThread()) {
+        task_runner_to_post_delayed_callback_on = nullptr;
+        // Allow next call to UpdateCommitDataRequest to start
+        // another batching period.
+        delayed_flush_scheduled_ = false;
+        // We're flushing synchronously, so any scheduled immediate flush is
+        // no longer needed.
+        immediate_flush_scheduled_ = false;
+        // We can't flush while holding the lock
+        scoped_lock.unlock();
+        FlushPendingCommitDataRequests();
+      } else {
+        bool should_post_immediate_flush = true;
+        if constexpr (PERFETTO_FLAGS(SMA_PREVENT_DUPLICATE_IMMEDIATE_FLUSHES)) {
+          // Only post an immediate flush task if we haven't already posted one.
+          // This prevents spamming the task runner with immediate flushes when
+          // the buffer remains over 50% full while chunks continue to be
+          // committed. See b/330580374.
+          should_post_immediate_flush = !immediate_flush_scheduled_;
+        }
+
+        // Since we aren't on the |task_runner_| thread post a task instead,
+        // in order to prevent non-overlaping commit data request flushes.
+        if (should_post_immediate_flush) {
+          weak_this = weak_ptr_factory_.GetWeakPtr();
+          task_runner_to_post_delayed_callback_on = task_runner_;
+          flush_delay_ms = 0;
+          immediate_flush_scheduled_ = true;
+        }
+      }
+    }
+  }  // scoped_lock(lock_)
+
+  // We shouldn't post tasks while locked.
+  // |task_runner_to_post_delayed_callback_on| remains valid after unlocking,
+  // because |task_runner_| is never reset.
+  if (task_runner_to_post_delayed_callback_on) {
+    task_runner_to_post_delayed_callback_on->PostDelayedTask(
+        [weak_this] {
+          if (!weak_this)
+            return;
+          {
+            std::lock_guard<base::MaybeRtMutex> scoped_lock(weak_this->lock_);
+            // Clear |delayed_flush_scheduled_| and
+            // |immediate_flush_scheduled_|, allowing the next call to
+            // UpdateCommitDataRequest to start another batching period.
+            weak_this->delayed_flush_scheduled_ = false;
+            weak_this->immediate_flush_scheduled_ = false;
+          }
+          weak_this->FlushPendingCommitDataRequests();
+        },
+        flush_delay_ms);
+  }
+}
+
+bool SharedMemoryArbiterImpl::TryDirectPatchLocked(
+    WriterID writer_id,
+    const Patch& patch,
+    bool chunk_needs_more_patching) {
+  // Search the chunks that are being batched in |commit_data_req_| for a chunk
+  // that needs patching and that matches the provided |writer_id| and
+  // |patch.chunk_id|. Iterate |commit_data_req_| in reverse, since
+  // |commit_data_req_| is appended to at the end with newly-returned chunks,
+  // and patches are more likely to apply to chunks that have been returned
+  // recently.
+  SharedMemoryABI::Chunk chunk;
+  bool chunk_found = false;
+  auto& chunks_to_move = commit_data_req_->chunks_to_move();
+  for (auto ctm_it = chunks_to_move.rbegin(); ctm_it != chunks_to_move.rend();
+       ++ctm_it) {
+    uint32_t header_bitmap = shmem_abi_.GetPageHeaderBitmap(ctm_it->page());
+    auto chunk_state = shmem_abi_.GetChunkStateFromHeaderBitmap(
+        header_bitmap, ctm_it->chunk());
+    // Note: the subset of |commit_data_req_| chunks that still need patching is
+    // also the subset of chunks that are still being written to. The rest of
+    // the chunks in |commit_data_req_| do not need patching and have already
+    // been marked as complete.
+    if (chunk_state != SharedMemoryABI::kChunkBeingWritten)
+      continue;
+
+    chunk = shmem_abi_.GetChunkUnchecked(ctm_it->page(), header_bitmap,
+                                         ctm_it->chunk());
+    if (chunk.writer_id() == writer_id &&
+        chunk.header()->chunk_id.load(std::memory_order_relaxed) ==
+            patch.chunk_id) {
+      chunk_found = true;
+      break;
+    }
+  }
+
+  if (!chunk_found) {
+    // The chunk has already been committed to the service and the patch cannot
+    // be applied in the producer.
+    return false;
+  }
+
+  // Apply the patch.
+  size_t page_idx;
+  uint8_t chunk_idx;
+  std::tie(page_idx, chunk_idx) = shmem_abi_.GetPageAndChunkIndex(chunk);
+  PERFETTO_DCHECK(shmem_abi_.GetChunkState(page_idx, chunk_idx) ==
+                  SharedMemoryABI::ChunkState::kChunkBeingWritten);
+  auto chunk_begin = chunk.payload_begin();
+  uint8_t* ptr = chunk_begin + patch.offset;
+  PERFETTO_CHECK(ptr <= chunk.end() - SharedMemoryABI::kPacketHeaderSize);
+  // DCHECK that we are writing into a zero-filled size field and not into
+  // valid data. It relies on ScatteredStreamWriter::ReserveBytes() to
+  // zero-fill reservations in debug builds.
+  const char zero[SharedMemoryABI::kPacketHeaderSize]{};
+  PERFETTO_DCHECK(memcmp(ptr, &zero, SharedMemoryABI::kPacketHeaderSize) == 0);
+
+  memcpy(ptr, &patch.size_field[0], SharedMemoryABI::kPacketHeaderSize);
+
+  if (!chunk_needs_more_patching) {
+    // Mark that the chunk doesn't need more patching and mark it as complete,
+    // as the producer will not write to it anymore. This allows the service to
+    // read the chunk in full while scraping, which would not be the case if the
+    // chunk was left in a kChunkBeingWritten state.
+    chunk.ClearNeedsPatchingFlag();
+    shmem_abi_.ReleaseChunkAsComplete(std::move(chunk));
+  }
+
+  return true;
+}
+
+void SharedMemoryArbiterImpl::SetBatchCommitsDuration(
+    uint32_t batch_commits_duration_ms) {
+  std::lock_guard<base::MaybeRtMutex> scoped_lock(lock_);
+  batch_commits_duration_ms_ = batch_commits_duration_ms;
+}
+
+bool SharedMemoryArbiterImpl::EnableDirectSMBPatching() {
+  std::lock_guard<base::MaybeRtMutex> scoped_lock(lock_);
+  if (!direct_patching_supported_by_service_) {
+    return false;
+  }
+
+  return direct_patching_enabled_ = true;
+}
+
+void SharedMemoryArbiterImpl::SetDirectSMBPatchingSupportedByService() {
+  std::lock_guard<base::MaybeRtMutex> scoped_lock(lock_);
+  direct_patching_supported_by_service_ = true;
+}
+
+// This function is quite subtle. When making changes keep in mind these two
+// challenges:
+// 1) If the producer stalls and we happen to be on the |task_runner_| IPC
+//    thread (or, for in-process cases, on the same thread where
+//    TracingServiceImpl lives), the CommitData() call must be synchronous and
+//    not posted, to avoid deadlocks.
+// 2) When different threads hit this function, we must guarantee that we don't
+//    accidentally make commits out of order. See commit 4e4fe8f56ef and
+//    crbug.com/919187 for more context.
+void SharedMemoryArbiterImpl::FlushPendingCommitDataRequests(
+    std::function<void()> callback) {
+  std::unique_ptr<CommitDataRequest> req;
+  {
+    std::unique_lock<base::MaybeRtMutex> scoped_lock(lock_);
+
+    // Flushing is only supported while |fully_bound_|, and there may still be
+    // unbound startup trace writers. If so, skip the commit for now - it'll be
+    // done when |fully_bound_| is updated.
+    if (!fully_bound_) {
+      if (callback)
+        pending_flush_callbacks_.push_back(callback);
+      return;
+    }
+
+    // May be called by TraceWriterImpl on any thread.
+    base::TaskRunner* task_runner = task_runner_;
+    if (!task_runner->RunsTasksOnCurrentThread()) {
+      // We shouldn't post a task while holding a lock. |task_runner| remains
+      // valid after unlocking, because |task_runner_| is never reset.
+      scoped_lock.unlock();
+
+      auto weak_this = weak_ptr_factory_.GetWeakPtr();
+      task_runner->PostTask([weak_this, callback] {
+        if (weak_this)
+          weak_this->FlushPendingCommitDataRequests(std::move(callback));
+      });
+      return;
+    }
+
+    // |commit_data_req_| could have become a nullptr, for example when a forced
+    // sync flush happens in GetNewChunk().
+    if (commit_data_req_) {
+      // Make sure any placeholder buffer IDs from StartupWriters are replaced
+      // before sending the request.
+      bool all_placeholders_replaced =
+          ReplaceCommitPlaceholderBufferIdsLocked();
+      // We're |fully_bound_|, thus all writers are bound and all placeholders
+      // should have been replaced.
+      PERFETTO_DCHECK(all_placeholders_replaced);
+
+      // In order to allow patching in the producer we delay the kChunkComplete
+      // transition and keep batched chunks in the kChunkBeingWritten state.
+      // Since we are about to notify the service of all batched chunks, it will
+      // not be possible to apply any more patches to them and we need to move
+      // them to kChunkComplete - otherwise the service won't look at them.
+      for (auto& ctm : *commit_data_req_->mutable_chunks_to_move()) {
+        uint32_t header_bitmap = shmem_abi_.GetPageHeaderBitmap(ctm.page());
+        auto chunk_state = shmem_abi_.GetChunkStateFromHeaderBitmap(
+            header_bitmap, ctm.chunk());
+        // Note: the subset of |commit_data_req_| chunks that still need
+        // patching is also the subset of chunks that are still being written
+        // to. The rest of the chunks in |commit_data_req_| do not need patching
+        // and have already been marked as complete.
+        if (chunk_state == SharedMemoryABI::kChunkBeingWritten) {
+          auto chunk = shmem_abi_.GetChunkUnchecked(ctm.page(), header_bitmap,
+                                                    ctm.chunk());
+          shmem_abi_.ReleaseChunkAsComplete(std::move(chunk));
+        }
+
+        if (use_shmem_emulation_) {
+          // When running in the emulation mode:
+          // 1. serialize the chunk data to |ctm| as we won't modify the chunk
+          // anymore.
+          // 2. free the chunk as the service won't be able to do this.
+          auto chunk = shmem_abi_.GetChunkUnchecked(ctm.page(), header_bitmap,
+                                                    ctm.chunk());
+          PERFETTO_CHECK(chunk.is_valid());
+          ctm.set_data(chunk.begin(), chunk.size());
+          shmem_abi_.ReleaseChunkAsFree(std::move(chunk));
+        }
+      }
+
+      req = std::move(commit_data_req_);
+      bytes_pending_commit_ = 0;
+    }
+  }  // scoped_lock
+
+  if (req) {
+    producer_endpoint_->CommitData(*req, callback);
+  } else if (callback) {
+    // If |req| was nullptr, it means that an enqueued deferred commit was
+    // executed just before this. At this point send an empty commit request
+    // to the service, just to linearize with it and give the guarantee to the
+    // caller that the data has been flushed into the service.
+    producer_endpoint_->CommitData(CommitDataRequest(), std::move(callback));
+  }
+}
+
+bool SharedMemoryArbiterImpl::TryShutdown() {
+  std::lock_guard<base::MaybeRtMutex> scoped_lock(lock_);
+  did_shutdown_ = true;
+  // Shutdown is safe if there are no active trace writers for this arbiter.
+  return active_writer_ids_.IsEmpty();
+}
+
+std::unique_ptr<TraceWriter> SharedMemoryArbiterImpl::CreateTraceWriter(
+    BufferID target_buffer,
+    BufferExhaustedPolicy buffer_exhausted_policy) {
+  PERFETTO_CHECK(target_buffer > 0);
+  return CreateTraceWriterInternal(target_buffer, buffer_exhausted_policy);
+}
+
+std::unique_ptr<TraceWriter> SharedMemoryArbiterImpl::CreateStartupTraceWriter(
+    uint16_t target_buffer_reservation_id) {
+  return CreateTraceWriterInternal(
+      MakeTargetBufferIdForReservation(target_buffer_reservation_id),
+      BufferExhaustedPolicy::kDrop);
+}
+
+void SharedMemoryArbiterImpl::BindToProducerEndpoint(
+    TracingService::ProducerEndpoint* producer_endpoint,
+    base::TaskRunner* task_runner) {
+  PERFETTO_DCHECK(producer_endpoint && task_runner);
+  PERFETTO_DCHECK(task_runner->RunsTasksOnCurrentThread());
+
+  bool should_flush = false;
+  std::function<void()> flush_callback;
+  {
+    std::lock_guard<base::MaybeRtMutex> scoped_lock(lock_);
+    PERFETTO_CHECK(!fully_bound_);
+    PERFETTO_CHECK(!producer_endpoint_ && !task_runner_);
+
+    producer_endpoint_ = producer_endpoint;
+    task_runner_ = task_runner;
+
+    // Now that we're bound to a task runner, also reset the WeakPtrFactory to
+    // it. Because this code runs on the task runner, the factory's weak
+    // pointers will be valid on it.
+    weak_ptr_factory_.Reset(this);
+
+    // All writers registered so far should be startup trace writers, since
+    // the producer cannot feasibly know the target buffer for any future
+    // session yet.
+    for (const auto& entry : pending_writers_) {
+      PERFETTO_CHECK(IsReservationTargetBufferId(entry.second));
+    }
+
+    // If all buffer reservations are bound, we can flush pending commits.
+    if (UpdateFullyBoundLocked()) {
+      should_flush = true;
+      flush_callback = TakePendingFlushCallbacksLocked();
+    }
+  }  // scoped_lock
+
+  // Attempt to flush any pending commits (and run pending flush callbacks). If
+  // there are none, this will have no effect. If we ended up in a race that
+  // changed |fully_bound_| back to false, the commit will happen once we become
+  // |fully_bound_| again.
+  if (should_flush)
+    FlushPendingCommitDataRequests(flush_callback);
+}
+
+void SharedMemoryArbiterImpl::BindStartupTargetBuffer(
+    uint16_t target_buffer_reservation_id,
+    BufferID target_buffer_id) {
+  PERFETTO_DCHECK(target_buffer_id > 0);
+
+  std::unique_lock<base::MaybeRtMutex> scoped_lock(lock_);
+
+  // We should already be bound to an endpoint.
+  PERFETTO_CHECK(producer_endpoint_);
+  PERFETTO_CHECK(task_runner_);
+  PERFETTO_CHECK(task_runner_->RunsTasksOnCurrentThread());
+
+  BindStartupTargetBufferImpl(std::move(scoped_lock),
+                              target_buffer_reservation_id, target_buffer_id);
+}
+
+void SharedMemoryArbiterImpl::AbortStartupTracingForReservation(
+    uint16_t target_buffer_reservation_id) {
+  std::unique_lock<base::MaybeRtMutex> scoped_lock(lock_);
+
+  // If we are already bound to an arbiter, we may need to flush after aborting
+  // the session, and thus should be running on the arbiter's task runner.
+  if (task_runner_ && !task_runner_->RunsTasksOnCurrentThread()) {
+    // We shouldn't post tasks while locked.
+    auto* task_runner = task_runner_;
+    scoped_lock.unlock();
+
+    auto weak_this = weak_ptr_factory_.GetWeakPtr();
+    task_runner->PostTask([weak_this, target_buffer_reservation_id]() {
+      if (!weak_this)
+        return;
+      weak_this->AbortStartupTracingForReservation(
+          target_buffer_reservation_id);
+    });
+    return;
+  }
+
+  // Bind the target buffer reservation to an invalid buffer (ID 0), so that
+  // existing commits, as well as future commits (of currently acquired chunks),
+  // will be released as free free by the service but otherwise ignored (i.e.
+  // not copied into any valid target buffer).
+  BindStartupTargetBufferImpl(std::move(scoped_lock),
+                              target_buffer_reservation_id,
+                              /*target_buffer_id=*/kInvalidBufferId);
+}
+
+void SharedMemoryArbiterImpl::BindStartupTargetBufferImpl(
+    std::unique_lock<base::MaybeRtMutex> scoped_lock,
+    uint16_t target_buffer_reservation_id,
+    BufferID target_buffer_id) {
+  // We should already be bound to an endpoint if the target buffer is valid.
+  PERFETTO_DCHECK((producer_endpoint_ && task_runner_) ||
+                  target_buffer_id == kInvalidBufferId);
+
+  PERFETTO_DLOG("Binding startup target buffer reservation %" PRIu16
+                " to buffer %" PRIu16,
+                target_buffer_reservation_id, target_buffer_id);
+
+  MaybeUnboundBufferID reserved_id =
+      MakeTargetBufferIdForReservation(target_buffer_reservation_id);
+
+  bool should_flush = false;
+  std::function<void()> flush_callback;
+  std::vector<std::pair<WriterID, BufferID>> writers_to_register;
+
+  TargetBufferReservation& reservation =
+      target_buffer_reservations_[reserved_id];
+  PERFETTO_CHECK(!reservation.resolved);
+  reservation.resolved = true;
+  reservation.target_buffer = target_buffer_id;
+
+  // Collect trace writers associated with the reservation.
+  for (auto it = pending_writers_.begin(); it != pending_writers_.end();) {
+    if (it->second == reserved_id) {
+      // No need to register writers that have an invalid target buffer.
+      if (target_buffer_id != kInvalidBufferId) {
+        writers_to_register.push_back(
+            std::make_pair(it->first, target_buffer_id));
+      }
+      it = pending_writers_.erase(it);
+    } else {
+      it++;
+    }
+  }
+
+  // If all buffer reservations are bound, we can flush pending commits.
+  if (UpdateFullyBoundLocked()) {
+    should_flush = true;
+    flush_callback = TakePendingFlushCallbacksLocked();
+  }
+
+  scoped_lock.unlock();
+
+  // Register any newly bound trace writers with the service.
+  for (const auto& writer_and_target_buffer : writers_to_register) {
+    producer_endpoint_->RegisterTraceWriter(writer_and_target_buffer.first,
+                                            writer_and_target_buffer.second);
+  }
+
+  // Attempt to flush any pending commits (and run pending flush callbacks). If
+  // there are none, this will have no effect. If we ended up in a race that
+  // changed |fully_bound_| back to false, the commit will happen once we become
+  // |fully_bound_| again.
+  if (should_flush)
+    FlushPendingCommitDataRequests(flush_callback);
+}
+
+SharedMemoryArbiterImpl::Stats SharedMemoryArbiterImpl::GetStats() {
+  std::lock_guard<base::MaybeRtMutex> scoped_lock(lock_);
+  Stats res;
+
+  for (size_t page_idx = 0; page_idx < shmem_abi_.num_pages(); page_idx++) {
+    uint32_t bitmap = shmem_abi_.page_header(page_idx)->header_bitmap.load(
+        std::memory_order_relaxed);
+    SharedMemoryABI::PageLayout layout =
+        SharedMemoryABI::GetLayoutFromHeaderBitmap(bitmap);
+    if (layout == SharedMemoryABI::kPageNotPartitioned) {
+      res.pages_free++;
+    } else if (layout == SharedMemoryABI::kPageDivReserved1 ||
+               layout == SharedMemoryABI::kPageDivReserved2) {
+      res.pages_unexpected++;
+    }
+    // Free and unexpected pages have zero chunks.
+    const uint32_t num_chunks =
+        SharedMemoryABI::GetNumChunksFromHeaderBitmap(bitmap);
+    for (uint32_t i = 0; i < num_chunks; i++) {
+      switch (SharedMemoryABI::GetChunkStateFromHeaderBitmap(bitmap, i)) {
+        case SharedMemoryABI::kChunkFree:
+          res.chunks_free++;
+          break;
+        case SharedMemoryABI::kChunkBeingWritten:
+          res.chunks_being_written++;
+          break;
+        case SharedMemoryABI::kChunkBeingRead:
+          res.chunks_being_read++;
+          break;
+        case SharedMemoryABI::kChunkComplete:
+          res.chunks_complete++;
+          break;
+      }
+    }
+  }
+
+  return res;
+}
+
+std::function<void()>
+SharedMemoryArbiterImpl::TakePendingFlushCallbacksLocked() {
+  if (pending_flush_callbacks_.empty())
+    return std::function<void()>();
+
+  std::vector<std::function<void()>> pending_flush_callbacks;
+  pending_flush_callbacks.swap(pending_flush_callbacks_);
+  // Capture the callback list into the lambda by copy.
+  return [pending_flush_callbacks]() {
+    for (auto& callback : pending_flush_callbacks)
+      callback();
+  };
+}
+
+void SharedMemoryArbiterImpl::NotifyFlushComplete(FlushRequestID req_id) {
+  base::TaskRunner* task_runner_to_commit_on = nullptr;
+
+  {
+    std::lock_guard<base::MaybeRtMutex> scoped_lock(lock_);
+    // If a commit_data_req_ exists it means that somebody else already posted a
+    // FlushPendingCommitDataRequests() task.
+    if (!commit_data_req_) {
+      commit_data_req_.reset(new CommitDataRequest());
+
+      // Flushing the commit is only supported while we're |fully_bound_|. If we
+      // aren't, we'll flush when |fully_bound_| is updated.
+      if (fully_bound_)
+        task_runner_to_commit_on = task_runner_;
+    } else {
+      // If there is another request queued and that also contains is a reply
+      // to a flush request, reply with the highest id.
+      req_id = std::max(req_id, commit_data_req_->flush_request_id());
+    }
+    commit_data_req_->set_flush_request_id(req_id);
+  }  // scoped_lock
+
+  // We shouldn't post tasks while locked. |task_runner_to_commit_on|
+  // remains valid after unlocking, because |task_runner_| is never reset.
+  if (task_runner_to_commit_on) {
+    auto weak_this = weak_ptr_factory_.GetWeakPtr();
+    task_runner_to_commit_on->PostTask([weak_this] {
+      if (weak_this)
+        weak_this->FlushPendingCommitDataRequests();
+    });
+  }
+}
+
+void SharedMemoryArbiterImpl::ScrapeEmulatedSharedMemoryBuffer(
+    const std::map<WriterID, BufferID>& buffer_for_writers) {
+  PERFETTO_CHECK(use_shmem_emulation_);
+
+  // This function must be called on the IPC thread.
+  PERFETTO_CHECK(task_runner_->RunsTasksOnCurrentThread());
+
+  CommitDataRequest commit_req;
+  ForEachScrapableChunk(&shmem_abi_, [&](SharedMemoryABI::Chunk* chunk,
+                                         bool chunk_complete, auto, auto) {
+    const auto writer = buffer_for_writers.find(chunk->writer_id());
+    if (writer == buffer_for_writers.end())
+      return;
+    BufferID target_buffer_id = writer->second;
+    auto* ctm = commit_data_req_->add_chunks_to_move();
+    auto page_and_chunk = shmem_abi_.GetPageAndChunkIndex(*chunk);
+    ctm->set_page(static_cast<uint32_t>(page_and_chunk.first));
+    ctm->set_chunk(static_cast<uint32_t>(page_and_chunk.second));
+    ctm->set_target_buffer(target_buffer_id);
+    ctm->set_data(chunk->begin(), chunk->size());
+    ctm->set_chunk_incomplete(!chunk_complete);
+  });
+  if (commit_req.chunks_to_move_size() == 0)
+    return;
+  producer_endpoint_->CommitData(commit_req);
+}
+
+std::unique_ptr<TraceWriter> SharedMemoryArbiterImpl::CreateTraceWriterInternal(
+    MaybeUnboundBufferID target_buffer,
+    BufferExhaustedPolicy buffer_exhausted_policy) {
+  WriterID id;
+  base::TaskRunner* task_runner_to_register_on = nullptr;
+
+  {
+    std::lock_guard<base::MaybeRtMutex> scoped_lock(lock_);
+    if (did_shutdown_)
+      return std::unique_ptr<TraceWriter>(new NullTraceWriter());
+
+    id = active_writer_ids_.Allocate();
+    if (!id)
+      return std::unique_ptr<TraceWriter>(new NullTraceWriter());
+
+    PERFETTO_DCHECK(!pending_writers_.count(id));
+
+    if (IsReservationTargetBufferId(target_buffer)) {
+      // If the reservation is new, mark it as unbound in
+      // |target_buffer_reservations_|. Otherwise, if the reservation was
+      // already bound, choose the bound buffer ID now.
+      auto it_and_inserted = target_buffer_reservations_.insert(
+          {target_buffer, TargetBufferReservation()});
+      if (it_and_inserted.first->second.resolved)
+        target_buffer = it_and_inserted.first->second.target_buffer;
+    }
+
+    if (IsReservationTargetBufferId(target_buffer)) {
+      // The arbiter and/or startup buffer reservations are not bound yet, so
+      // buffer the registration of the writer until after we're bound.
+      pending_writers_[id] = target_buffer;
+
+      // Mark the arbiter as not fully bound, since we now have at least one
+      // unbound trace writer / target buffer reservation.
+      fully_bound_ = false;
+      was_always_bound_ = false;
+    } else if (target_buffer != kInvalidBufferId) {
+      // Trace writer is bound, so arbiter should be bound to an endpoint,
+      // too.
+      PERFETTO_CHECK(producer_endpoint_ && task_runner_);
+      task_runner_to_register_on = task_runner_;
+    }
+
+    // All trace writers must use kDrop policy if the arbiter ever becomes
+    // unbound.
+    bool uses_drop_policy =
+        buffer_exhausted_policy == BufferExhaustedPolicy::kDrop;
+    all_writers_have_drop_policy_ &= uses_drop_policy;
+    PERFETTO_DCHECK(fully_bound_ || uses_drop_policy);
+    PERFETTO_CHECK(fully_bound_ || all_writers_have_drop_policy_);
+    PERFETTO_CHECK(was_always_bound_ || uses_drop_policy);
+  }  // scoped_lock
+
+  // We shouldn't post tasks while locked. |task_runner_to_register_on|
+  // remains valid after unlocking, because |task_runner_| is never reset.
+  if (task_runner_to_register_on) {
+    auto weak_this = weak_ptr_factory_.GetWeakPtr();
+    task_runner_to_register_on->PostTask([weak_this, id, target_buffer] {
+      if (weak_this)
+        weak_this->producer_endpoint_->RegisterTraceWriter(id, target_buffer);
+    });
+  }
+
+  return std::unique_ptr<TraceWriter>(
+      new TraceWriterImpl(this, id, target_buffer, buffer_exhausted_policy));
+}
+
+void SharedMemoryArbiterImpl::ReleaseWriterID(WriterID id) {
+  base::TaskRunner* task_runner = nullptr;
+  base::WeakPtr<SharedMemoryArbiterImpl> weak_this;
+  {
+    std::lock_guard<base::MaybeRtMutex> scoped_lock(lock_);
+    active_writer_ids_.Free(id);
+
+    auto it = pending_writers_.find(id);
+    if (it != pending_writers_.end()) {
+      // Writer hasn't been bound yet and thus also not yet registered with
+      // the service.
+      pending_writers_.erase(it);
+      return;
+    }
+
+    // A trace writer from an aborted session may be destroyed before the
+    // arbiter is bound to a task runner. In that case, it was never
+    // registered with the service.
+    if (!task_runner_)
+      return;
+
+    // If `active_writer_ids_` is empty, `TryShutdown()` can return true
+    // and `*this` can be deleted. Let's grab everything we need from `*this`
+    // before releasing the lock.
+    weak_this = weak_ptr_factory_.GetWeakPtr();
+    task_runner = task_runner_;
+  }  // scoped_lock
+
+  // We shouldn't post tasks while locked. |task_runner| remains valid after
+  // unlocking, because |task_runner_| is never reset.
+  task_runner->PostTask([weak_this, id] {
+    if (weak_this)
+      weak_this->producer_endpoint_->UnregisterTraceWriter(id);
+  });
+}
+
+bool SharedMemoryArbiterImpl::ReplaceCommitPlaceholderBufferIdsLocked() {
+  if (!commit_data_req_)
+    return true;
+
+  bool all_placeholders_replaced = true;
+  for (auto& chunk : *commit_data_req_->mutable_chunks_to_move()) {
+    if (!IsReservationTargetBufferId(chunk.target_buffer()))
+      continue;
+    const auto it = target_buffer_reservations_.find(chunk.target_buffer());
+    PERFETTO_DCHECK(it != target_buffer_reservations_.end());
+    if (!it->second.resolved) {
+      all_placeholders_replaced = false;
+      continue;
+    }
+    chunk.set_target_buffer(it->second.target_buffer);
+  }
+  for (auto& chunk : *commit_data_req_->mutable_chunks_to_patch()) {
+    if (!IsReservationTargetBufferId(chunk.target_buffer()))
+      continue;
+    const auto it = target_buffer_reservations_.find(chunk.target_buffer());
+    PERFETTO_DCHECK(it != target_buffer_reservations_.end());
+    if (!it->second.resolved) {
+      all_placeholders_replaced = false;
+      continue;
+    }
+    chunk.set_target_buffer(it->second.target_buffer);
+  }
+  return all_placeholders_replaced;
+}
+
+bool SharedMemoryArbiterImpl::UpdateFullyBoundLocked() {
+  if (!producer_endpoint_) {
+    PERFETTO_DCHECK(!fully_bound_);
+    return false;
+  }
+  // We're fully bound if all target buffer reservations have a valid
+  // associated BufferID.
+  fully_bound_ = std::none_of(
+      target_buffer_reservations_.begin(), target_buffer_reservations_.end(),
+      [](std::pair<MaybeUnboundBufferID, TargetBufferReservation> entry) {
+        return !entry.second.resolved;
+      });
+  if (!fully_bound_)
+    was_always_bound_ = false;
+  return fully_bound_;
+}
+
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/core/trace_packet.cc
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_packet.h"
+
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+
+TracePacket::TracePacket() = default;
+TracePacket::~TracePacket() = default;
+
+TracePacket::TracePacket(TracePacket&& other) noexcept {
+  *this = std::move(other);
+}
+
+TracePacket& TracePacket::operator=(TracePacket&& other) {
+  slices_ = std::move(other.slices_);
+  other.slices_.clear();
+  size_ = other.size_;
+  other.size_ = 0;
+  buffer_index_for_stats_ = other.buffer_index_for_stats_;
+  other.buffer_index_for_stats_ = 0;
+  return *this;
+}
+
+void TracePacket::AddSlice(Slice slice) {
+  size_ += slice.size;
+  slices_.push_back(std::move(slice));
+}
+
+void TracePacket::AddSlice(const void* start, size_t size) {
+  size_ += size;
+  slices_.emplace_back(start, size);
+}
+
+void TracePacket::Clear() {
+  slices_.clear();
+  size_ = 0;
+  buffer_index_for_stats_ = 0;
+}
+
+std::tuple<char*, size_t> TracePacket::GetProtoPreamble() {
+  using protozero::proto_utils::MakeTagLengthDelimited;
+  using protozero::proto_utils::WriteVarInt;
+  uint8_t* ptr = reinterpret_cast<uint8_t*>(&preamble_[0]);
+
+  constexpr uint8_t tag = MakeTagLengthDelimited(kPacketFieldNumber);
+  static_assert(tag < 0x80, "TracePacket tag should fit in one byte");
+  *(ptr++) = tag;
+
+  ptr = WriteVarInt(size(), ptr);
+  size_t preamble_size = reinterpret_cast<uintptr_t>(ptr) -
+                         reinterpret_cast<uintptr_t>(&preamble_[0]);
+  PERFETTO_DCHECK(preamble_size <= sizeof(preamble_));
+  return std::make_tuple(&preamble_[0], preamble_size);
+}
+
+void TracePacket::GetRawBytes(std::string* out_data) const {
+  out_data->resize(size());
+  uint64_t pos = 0;
+  for (const auto& slice : slices()) {
+    PERFETTO_CHECK(pos + slice.size <= out_data->size());
+    memcpy(out_data->data() + pos, slice.start, slice.size);
+    pos += slice.size;
+  }
+}
+
+std::string TracePacket::GetRawBytesForTesting() const {
+  std::string data;
+  GetRawBytes(&data);
+  return data;
+}
+
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/core/trace_writer_impl.cc
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "src/tracing/core/trace_writer_impl.h"
+
+#include <string.h>
+
+#include <algorithm>
+#include <type_traits>
+#include <utility>
+
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/thread_annotations.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/root_message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/static_buffer.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/buffer_exhausted_policy.h"
+// gen_amalgamated expanded: #include "src/tracing/core/shared_memory_arbiter_impl.h"
+
+// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h"
+
+using protozero::proto_utils::kMessageLengthFieldSize;
+using protozero::proto_utils::WriteRedundantVarInt;
+using ChunkHeader = perfetto::SharedMemoryABI::ChunkHeader;
+
+namespace perfetto {
+
+namespace {
+constexpr size_t kPacketHeaderSize = SharedMemoryABI::kPacketHeaderSize;
+// The -1 is because we want to leave extra room to inflate the counter.
+constexpr size_t kMaxPacketsPerChunk = ChunkHeader::Packets::kMaxCount - 1;
+// When the packet count in a chunk is inflated, TraceWriter is always going to
+// leave this kExtraRoomForInflatedPacket bytes to write an empty trace packet
+// if it needs to.
+constexpr size_t kExtraRoomForInflatedPacket = 1;
+uint8_t g_garbage_chunk[1024];
+}  // namespace
+
+TraceWriterImpl::TraceWriterImpl(SharedMemoryArbiterImpl* shmem_arbiter,
+                                 WriterID id,
+                                 MaybeUnboundBufferID target_buffer,
+                                 BufferExhaustedPolicy buffer_exhausted_policy)
+    : shmem_arbiter_(shmem_arbiter),
+      id_(id),
+      target_buffer_(target_buffer),
+      buffer_exhausted_policy_(buffer_exhausted_policy),
+      protobuf_stream_writer_(this),
+      process_id_(base::GetProcessId()) {
+  // TODO(primiano): we could handle the case of running out of TraceWriterID(s)
+  // more gracefully and always return a no-op TracePacket in NewTracePacket().
+  PERFETTO_CHECK(id_ != 0);
+
+  cur_packet_.reset(new protozero::RootMessage<protos::pbzero::TracePacket>());
+  cur_packet_->Finalize();  // To avoid the CHECK in NewTracePacket().
+}
+
+TraceWriterImpl::~TraceWriterImpl() {
+  if (cur_chunk_.is_valid()) {
+    cur_packet_->Finalize();
+    Flush();
+  }
+  // This call may cause the shared memory arbiter (and the underlying memory)
+  // to get asynchronously deleted if this was the last trace writer targeting
+  // the arbiter and the arbiter was marked for shutdown.
+  shmem_arbiter_->ReleaseWriterID(id_);
+}
+
+void TraceWriterImpl::ReturnCompletedChunk() {
+  PERFETTO_DCHECK(cur_chunk_.is_valid());
+  if (cur_chunk_packet_count_inflated_) {
+    uint8_t zero_size = 0;
+    static_assert(sizeof zero_size == kExtraRoomForInflatedPacket);
+    PERFETTO_CHECK(protobuf_stream_writer_.bytes_available() != 0);
+    protobuf_stream_writer_.WriteBytesUnsafe(&zero_size, sizeof zero_size);
+    cur_chunk_packet_count_inflated_ = false;
+  }
+  shmem_arbiter_->ReturnCompletedChunk(std::move(cur_chunk_), target_buffer_,
+                                       &patch_list_);
+}
+
+void TraceWriterImpl::Flush(std::function<void()> callback) {
+  // Flush() cannot be called in the middle of a TracePacket.
+  PERFETTO_CHECK(cur_packet_->is_finalized());
+  // cur_packet_ is finalized: that means that the size is correct for all the
+  // nested submessages. The root fragment size however is not handled by
+  // protozero::Message::Finalize() and must be filled here.
+  FinalizeFragmentIfRequired();
+
+  if (cur_chunk_.is_valid()) {
+    ReturnCompletedChunk();
+  } else {
+    // When in stall mode, all patches should have been returned with the last
+    // chunk, since the last packet was completed. In drop_packets_ mode, this
+    // may not be the case because the packet may have been fragmenting when
+    // SMB exhaustion occurred and |cur_chunk_| became invalid. In this case,
+    // drop_packets_ should be true.
+    PERFETTO_DCHECK(patch_list_.empty() || drop_packets_);
+  }
+
+  // Always issue the Flush request, even if there is nothing to flush, just
+  // for the sake of getting the callback posted back.
+  shmem_arbiter_->FlushPendingCommitDataRequests(callback);
+  protobuf_stream_writer_.Reset({nullptr, nullptr});
+}
+
+TraceWriterImpl::TracePacketHandle TraceWriterImpl::NewTracePacket() {
+  // If we hit this, the caller is calling NewTracePacket() without having
+  // finalized the previous packet.
+  PERFETTO_CHECK(cur_packet_->is_finalized());
+  // If we hit this, this trace writer was created in a different process. This
+  // likely means that the process forked while tracing was active, and the
+  // forked child process tried to emit a trace event. This is not supported, as
+  // it would lead to two processes writing to the same tracing SMB.
+  PERFETTO_DCHECK(process_id_ == base::GetProcessId());
+
+  // Before starting a new packet, make sure that the last fragment size has ben
+  // written correctly. The root fragment size is not written by
+  // protozero::Message::Finalize().
+  FinalizeFragmentIfRequired();
+
+  fragmenting_packet_ = false;
+
+  // Reserve space for the size of the message. Note: this call might re-enter
+  // into this class invoking GetNewBuffer() if there isn't enough space or if
+  // this is the very first call to NewTracePacket().
+  static_assert(kPacketHeaderSize == kMessageLengthFieldSize,
+                "The packet header must match the Message header size");
+
+  bool was_dropping_packets = drop_packets_;
+
+  // It doesn't make sense to begin a packet that is going to fragment
+  // immediately after (8 is just an arbitrary estimation on the minimum size of
+  // a realistic packet).
+  bool chunk_too_full =
+      protobuf_stream_writer_.bytes_available() < kPacketHeaderSize + 8;
+  if (chunk_too_full || reached_max_packets_per_chunk_ ||
+      retry_new_chunk_after_packet_) {
+    protobuf_stream_writer_.Reset(GetNewBuffer());
+  }
+
+  // Send any completed patches to the service to facilitate trace data
+  // recovery by the service. This should only happen when we're completing
+  // the first packet in a chunk which was a continuation from the previous
+  // chunk, i.e. at most once per chunk.
+  if (!patch_list_.empty() && patch_list_.front().is_patched()) {
+    shmem_arbiter_->SendPatches(id_, target_buffer_, &patch_list_);
+  }
+
+  cur_packet_->Reset(&protobuf_stream_writer_);
+  uint8_t* header = protobuf_stream_writer_.ReserveBytes(kPacketHeaderSize);
+  memset(header, 0, kPacketHeaderSize);
+  cur_fragment_size_field_ = header;
+
+  TracePacketHandle handle(cur_packet_.get());
+  cur_fragment_start_ = protobuf_stream_writer_.write_ptr();
+  fragmenting_packet_ = true;
+
+  if (PERFETTO_LIKELY(!drop_packets_)) {
+    uint16_t new_packet_count;
+    if (cur_chunk_packet_count_inflated_) {
+      new_packet_count =
+          cur_chunk_.header()->packets.load(std::memory_order_relaxed).count;
+      cur_chunk_packet_count_inflated_ = false;
+    } else {
+      new_packet_count = cur_chunk_.IncrementPacketCount();
+    }
+    reached_max_packets_per_chunk_ = new_packet_count == kMaxPacketsPerChunk;
+
+    if (PERFETTO_UNLIKELY(was_dropping_packets)) {
+      // We've succeeded to get a new chunk from the SMB after we entered
+      // drop_packets_ mode. Record a marker into the new packet to indicate the
+      // data loss.
+      cur_packet_->set_previous_packet_dropped(true);
+    }
+  }
+
+  if (PERFETTO_UNLIKELY(first_packet_on_sequence_)) {
+    cur_packet_->set_first_packet_on_sequence(true);
+    first_packet_on_sequence_ = false;
+  }
+
+  handle.set_finalization_listener(this);
+
+  return handle;
+}
+
+// Called by the Message. We can get here in two cases:
+// 1. In the middle of writing a Message,
+// when |fragmenting_packet_| == true. In this case we want to update the
+// chunk header with a partial packet and start a new partial packet in the
+// new chunk.
+// 2. While calling ReserveBytes() for the packet header in NewTracePacket().
+// In this case |fragmenting_packet_| == false and we just want a new chunk
+// without creating any fragments.
+protozero::ContiguousMemoryRange TraceWriterImpl::GetNewBuffer() {
+  if (fragmenting_packet_ && drop_packets_) {
+    // We can't write the remaining data of the fragmenting packet to a new
+    // chunk, because we have already lost some of its data in the garbage
+    // chunk. Thus, we will wrap around in the garbage chunk, wait until the
+    // current packet was completed, and then attempt to get a new chunk from
+    // the SMB again. Instead, if |drop_packets_| is true and
+    // |fragmenting_packet_| is false, we try to acquire a valid chunk because
+    // the SMB exhaustion might be resolved.
+    retry_new_chunk_after_packet_ = true;
+    cur_fragment_size_field_ = nullptr;
+    cur_fragment_start_ = &g_garbage_chunk[0];
+    return protozero::ContiguousMemoryRange{
+        &g_garbage_chunk[0], &g_garbage_chunk[0] + sizeof(g_garbage_chunk)};
+  }
+
+  // Attempt to grab the next chunk before finalizing the current one, so that
+  // we know whether we need to start dropping packets before writing the
+  // current packet fragment's header.
+  ChunkHeader::Packets packets = {};
+  if (fragmenting_packet_) {
+    packets.count = 1;
+    packets.flags = ChunkHeader::kFirstPacketContinuesFromPrevChunk;
+  }
+
+  // The memory order of the stores below doesn't really matter. This |header|
+  // is just a local temporary object. The GetNewChunk() call below will copy it
+  // into the shared buffer with the proper barriers.
+  ChunkHeader header = {};
+  header.writer_id.store(id_, std::memory_order_relaxed);
+  header.chunk_id.store(next_chunk_id_, std::memory_order_relaxed);
+  header.packets.store(packets, std::memory_order_relaxed);
+
+  BufferExhaustedPolicy policy = buffer_exhausted_policy_;
+  if (policy == BufferExhaustedPolicy::kStallThenDrop && drop_packets_) {
+    policy = BufferExhaustedPolicy::kDrop;
+  }
+
+  SharedMemoryABI::Chunk new_chunk =
+      shmem_arbiter_->GetNewChunk(header, policy);
+  if (!new_chunk.is_valid()) {
+    // Shared memory buffer exhausted, switch into |drop_packets_| mode. We'll
+    // drop data until the garbage chunk has been filled once and then retry.
+
+    // If we started a packet in one of the previous (valid) chunks, we need to
+    // tell the service to discard it.
+    if (fragmenting_packet_) {
+      // We can only end up here if the previous chunk was a valid chunk,
+      // because we never try to acquire a new chunk in |drop_packets_| mode
+      // while fragmenting.
+      PERFETTO_DCHECK(!drop_packets_);
+
+      // Backfill the last fragment's header with an invalid size (too large),
+      // so that the service's TraceBuffer throws out the incomplete packet.
+      // It'll restart reading from the next chunk we submit.
+      WriteRedundantVarInt(SharedMemoryABI::kPacketSizeDropPacket,
+                           cur_fragment_size_field_);
+
+      // Reset the size field, since we should not write the current packet's
+      // size anymore after this.
+      cur_fragment_size_field_ = nullptr;
+
+      // We don't set kLastPacketContinuesOnNextChunk or kChunkNeedsPatching on
+      // the last chunk, because its last fragment will be discarded anyway.
+      // However, the current packet fragment points to a valid |cur_chunk_| and
+      // may have non-finalized nested messages which will continue in the
+      // garbage chunk and currently still point into |cur_chunk_|. As we are
+      // about to return |cur_chunk_|, we need to invalidate the size fields of
+      // those nested messages. Normally we move them in the |patch_list_| (see
+      // below) but in this case, it doesn't make sense to send patches for a
+      // fragment that will be discarded for sure. Thus, we clean up any size
+      // field references into |cur_chunk_|.
+      for (auto* nested_msg = cur_packet_->nested_message(); nested_msg;
+           nested_msg = nested_msg->nested_message()) {
+        uint8_t* const cur_hdr = nested_msg->size_field();
+
+        // If this is false the protozero Message has already been instructed to
+        // write, upon Finalize(), its size into the patch list.
+        bool size_field_points_within_chunk =
+            cur_hdr >= cur_chunk_.payload_begin() &&
+            cur_hdr + kMessageLengthFieldSize <= cur_chunk_.end();
+
+        if (size_field_points_within_chunk)
+          nested_msg->set_size_field(nullptr);
+      }
+    } else if (!drop_packets_ && cur_fragment_size_field_) {
+      // If we weren't dropping packets before, we should indicate to the
+      // service that we're about to lose data. We do this by invalidating the
+      // size of the last packet in |cur_chunk_|. The service will record
+      // statistics about packets with kPacketSizeDropPacket size.
+      PERFETTO_DCHECK(cur_packet_->is_finalized());
+      PERFETTO_DCHECK(cur_chunk_.is_valid());
+
+      // |cur_fragment_size_field_| should point within |cur_chunk_|'s payload.
+      PERFETTO_DCHECK(cur_fragment_size_field_ >= cur_chunk_.payload_begin() &&
+                      cur_fragment_size_field_ + kMessageLengthFieldSize <=
+                          cur_chunk_.end());
+
+      WriteRedundantVarInt(SharedMemoryABI::kPacketSizeDropPacket,
+                           cur_fragment_size_field_);
+    }
+
+    if (cur_chunk_.is_valid()) {
+      ReturnCompletedChunk();
+    }
+
+    // Only increment the count if we are newly entering this state not
+    // otherwise.
+    drop_count_ += !drop_packets_;
+    drop_packets_ = true;
+    cur_chunk_ = SharedMemoryABI::Chunk();  // Reset to an invalid chunk.
+    cur_chunk_packet_count_inflated_ = false;
+    reached_max_packets_per_chunk_ = false;
+    retry_new_chunk_after_packet_ = false;
+    cur_fragment_size_field_ = nullptr;
+    cur_fragment_start_ = &g_garbage_chunk[0];
+
+    PERFETTO_ANNOTATE_BENIGN_RACE_SIZED(&g_garbage_chunk,
+                                        sizeof(g_garbage_chunk),
+                                        "nobody reads the garbage chunk")
+    return protozero::ContiguousMemoryRange{
+        &g_garbage_chunk[0], &g_garbage_chunk[0] + sizeof(g_garbage_chunk)};
+  }  // if (!new_chunk.is_valid())
+
+  PERFETTO_DCHECK(new_chunk.is_valid());
+
+  if (fragmenting_packet_) {
+    // We should not be fragmenting a packet after we exited drop_packets_ mode,
+    // because we only retry to get a new chunk when a fresh packet is started.
+    PERFETTO_DCHECK(!drop_packets_);
+
+    uint8_t* const wptr = protobuf_stream_writer_.write_ptr();
+    PERFETTO_DCHECK(wptr >= cur_fragment_start_);
+    uint32_t partial_size = static_cast<uint32_t>(wptr - cur_fragment_start_);
+    PERFETTO_DCHECK(partial_size < cur_chunk_.size());
+
+    // Backfill the packet header with the fragment size.
+    PERFETTO_DCHECK(partial_size > 0);
+    cur_chunk_.SetFlag(ChunkHeader::kLastPacketContinuesOnNextChunk);
+    WriteRedundantVarInt(partial_size, cur_fragment_size_field_);
+
+    // Descend in the stack of non-finalized nested submessages (if any) and
+    // detour their |size_field| into the |patch_list_|. At this point we have
+    // to release the chunk and they cannot write anymore into that.
+    for (auto* nested_msg = cur_packet_->nested_message(); nested_msg;
+         nested_msg = nested_msg->nested_message()) {
+      uint8_t* cur_hdr = nested_msg->size_field();
+
+      // If this is false the protozero Message has already been instructed to
+      // write, upon Finalize(), its size into the patch list.
+      bool size_field_points_within_chunk =
+          cur_hdr >= cur_chunk_.payload_begin() &&
+          cur_hdr + kMessageLengthFieldSize <= cur_chunk_.end();
+
+      if (size_field_points_within_chunk) {
+        cur_hdr = TraceWriterImpl::AnnotatePatch(cur_hdr);
+        nested_msg->set_size_field(cur_hdr);
+      } else {
+#if PERFETTO_DCHECK_IS_ON()
+        // Ensure that the size field of the message points to an element of the
+        // patch list.
+        auto patch_it = std::find_if(
+            patch_list_.begin(), patch_list_.end(),
+            [cur_hdr](const Patch& p) { return &p.size_field[0] == cur_hdr; });
+        PERFETTO_DCHECK(patch_it != patch_list_.end());
+#endif
+      }
+    }  // for(nested_msg)
+  }  // if(fragmenting_packet)
+
+  if (cur_chunk_.is_valid()) {
+    // ReturnCompletedChunk will consume the first patched entries from
+    // |patch_list_| and shrink it.
+    ReturnCompletedChunk();
+  }
+
+  // Switch to the new chunk.
+  drop_packets_ = false;
+  reached_max_packets_per_chunk_ = false;
+  retry_new_chunk_after_packet_ = false;
+  next_chunk_id_++;
+  cur_chunk_ = std::move(new_chunk);
+  cur_chunk_packet_count_inflated_ = false;
+  cur_fragment_size_field_ = nullptr;
+
+  uint8_t* payload_begin = cur_chunk_.payload_begin();
+  if (fragmenting_packet_) {
+    cur_fragment_size_field_ = payload_begin;
+    memset(payload_begin, 0, kPacketHeaderSize);
+    payload_begin += kPacketHeaderSize;
+    cur_fragment_start_ = payload_begin;
+  }
+
+  return protozero::ContiguousMemoryRange{payload_begin, cur_chunk_.end()};
+}
+
+void TraceWriterImpl::FinishTracePacket() {
+  // If we hit this, this trace writer was created in a different process. This
+  // likely means that the process forked while tracing was active, and the
+  // forked child process tried to emit a trace event. This is not supported, as
+  // it would lead to two processes writing to the same tracing SMB.
+  PERFETTO_DCHECK(process_id_ == base::GetProcessId());
+
+  FinalizeFragmentIfRequired();
+
+  cur_packet_->Reset(&protobuf_stream_writer_);
+  cur_packet_->Finalize();  // To avoid the CHECK in NewTracePacket().
+
+  // cur_chunk_packet_count_inflated_ can be true if FinishTracePacket() is
+  // called multiple times.
+  if (cur_chunk_.is_valid() && !cur_chunk_packet_count_inflated_) {
+    if (protobuf_stream_writer_.bytes_available() <
+        kExtraRoomForInflatedPacket) {
+      ReturnCompletedChunk();
+    } else {
+      cur_chunk_packet_count_inflated_ = true;
+      cur_chunk_.IncrementPacketCount();
+    }
+  }
+
+  // Send any completed patches to the service to facilitate trace data
+  // recovery by the service. This should only happen when we're completing
+  // the first packet in a chunk which was a continuation from the previous
+  // chunk, i.e. at most once per chunk.
+  if (!patch_list_.empty() && patch_list_.front().is_patched()) {
+    shmem_arbiter_->SendPatches(id_, target_buffer_, &patch_list_);
+  }
+}
+
+void TraceWriterImpl::FinalizeFragmentIfRequired() {
+  if (!cur_fragment_size_field_) {
+    return;
+  }
+  uint8_t* const wptr = protobuf_stream_writer_.write_ptr();
+  PERFETTO_DCHECK(wptr >= cur_fragment_start_);
+  uint32_t partial_size = static_cast<uint32_t>(wptr - cur_fragment_start_);
+
+  // cur_fragment_size_field_, if not nullptr, is always inside or immediately
+  // before protobuf_stream_writer_.cur_range().
+  if (partial_size < protozero::proto_utils::kMaxOneByteMessageLength &&
+      cur_fragment_size_field_ >= protobuf_stream_writer_.cur_range().begin) {
+    // This handles compaction of the root message. For nested messages, the
+    // compaction is handled by protozero::Message::Finalize().
+    protobuf_stream_writer_.Rewind(
+        partial_size, protozero::proto_utils::kMessageLengthFieldSize - 1u);
+    *cur_fragment_size_field_ = static_cast<uint8_t>(partial_size);
+  } else {
+    WriteRedundantVarInt(partial_size, cur_fragment_size_field_);
+  }
+  cur_fragment_size_field_ = nullptr;
+}
+
+uint8_t* TraceWriterImpl::AnnotatePatch(uint8_t* to_patch) {
+  if (!cur_chunk_.is_valid()) {
+    return nullptr;
+  }
+  auto offset = static_cast<uint16_t>(to_patch - cur_chunk_.payload_begin());
+  const ChunkID cur_chunk_id =
+      cur_chunk_.header()->chunk_id.load(std::memory_order_relaxed);
+  static_assert(kPatchSize == sizeof(Patch::PatchContent),
+                "Patch size mismatch");
+  Patch* patch = patch_list_.emplace_back(cur_chunk_id, offset);
+  // Check that the flag is not already set before setting it. This is not
+  // necessary, but it makes the code faster.
+  if (!(cur_chunk_.GetPacketCountAndFlags().second &
+        ChunkHeader::kChunkNeedsPatching)) {
+    cur_chunk_.SetFlag(ChunkHeader::kChunkNeedsPatching);
+  }
+  return &patch->size_field[0];
+}
+
+void TraceWriterImpl::OnMessageFinalized(protozero::Message*) {
+  TraceWriterImpl::FinishTracePacket();
+}
+
+WriterID TraceWriterImpl::writer_id() const {
+  return id_;
+}
+
+// Base class definitions.
+TraceWriter::TraceWriter() = default;
+TraceWriter::~TraceWriter() = default;
+
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/core/virtual_destructors.cc
+// gen_amalgamated begin header: include/perfetto/ext/tracing/core/consumer.h
+// gen_amalgamated begin header: include/perfetto/ext/tracing/core/observable_events.h
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_OBSERVABLE_EVENTS_H_
+#define INCLUDE_PERFETTO_EXT_TRACING_CORE_OBSERVABLE_EVENTS_H_
+
+// Creates the aliases in the ::perfetto namespace, doing things like:
+// using ::perfetto::Foo = ::perfetto::protos::gen::Foo.
+// See comments in forward_decls.h for the historical reasons of this
+// indirection layer.
+// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
+
+// gen_amalgamated expanded: #include "protos/perfetto/common/observable_events.gen.h"
+
+#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_OBSERVABLE_EVENTS_H_
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_CONSUMER_H_
+#define INCLUDE_PERFETTO_EXT_TRACING_CORE_CONSUMER_H_
+
+#include <vector>
+
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/uuid.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/observable_events.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
+
+namespace perfetto {
+
+class TracePacket;
+
+class PERFETTO_EXPORT_COMPONENT Consumer {
+ public:
+  virtual ~Consumer();
+
+  // Called by Service (or more typically by the transport layer, on behalf of
+  // the remote Service), once the Consumer <> Service connection has been
+  // established.
+  virtual void OnConnect() = 0;
+
+  // Called by the Service or by the transport layer if the connection with the
+  // service drops, either voluntarily (e.g., by destroying the ConsumerEndpoint
+  // obtained through Service::ConnectConsumer()) or involuntarily (e.g., if the
+  // Service process crashes).
+  virtual void OnDisconnect() = 0;
+
+  // Called by the Service after the tracing session has ended. This can happen
+  // for a variety of reasons:
+  // - The consumer explicitly called DisableTracing()
+  // - The TraceConfig's |duration_ms| has been reached.
+  // - The TraceConfig's |max_file_size_bytes| has been reached.
+  // - An error occurred while trying to enable tracing. In this case |error|
+  //   is non-empty.
+  virtual void OnTracingDisabled(const std::string& error) = 0;
+
+  // Called back by the Service (or transport layer) after invoking
+  // TracingService::ConsumerEndpoint::ReadBuffers(). This function can be
+  // called more than once. Each invocation can carry one or more
+  // TracePacket(s). Upon the last call, |has_more| is set to false (i.e.
+  // |has_more| is a !EOF).
+  virtual void OnTraceData(std::vector<TracePacket>, bool has_more) = 0;
+
+  // Called back by the Service (or transport layer) after invoking
+  // TracingService::ConsumerEndpoint::Detach().
+  // The consumer can disconnect at this point and the trace session will keep
+  // on going. A new consumer can later re-attach passing back the same |key|
+  // passed to Detach(), but only if the two requests come from the same uid.
+  virtual void OnDetach(bool success) = 0;
+
+  // Called back by the Service (or transport layer) after invoking
+  // TracingService::ConsumerEndpoint::Attach().
+  virtual void OnAttach(bool success, const TraceConfig&) = 0;
+
+  // Called back by the Service (or transport layer) after invoking
+  // TracingService::ConsumerEndpoint::GetTraceStats().
+  virtual void OnTraceStats(bool success, const TraceStats&) = 0;
+
+  // Called back by the Service (or transport layer) after invoking
+  // TracingService::ConsumerEndpoint::ObserveEvents() whenever one or more
+  // ObservableEvents of enabled event types occur.
+  virtual void OnObservableEvents(const ObservableEvents&) = 0;
+
+  // Called back by the Service (or transport layer) after invoking
+  // TracingService::ConsumerEndpoint::CloneSession().
+  // TODO(primiano): make pure virtual after various 3way patches.
+  struct OnSessionClonedArgs {
+    bool success;
+    std::string error;
+    base::Uuid uuid;  // UUID of the cloned session.
+    bool was_write_into_file;
+  };
+  virtual void OnSessionCloned(const OnSessionClonedArgs&);
+};
+
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_CONSUMER_H_
+// gen_amalgamated begin header: include/perfetto/ext/tracing/core/producer.h
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_PRODUCER_H_
+#define INCLUDE_PERFETTO_EXT_TRACING_CORE_PRODUCER_H_
+
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/flush_flags.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
+
+namespace perfetto {
+
+class SharedMemory;
+
+// A Producer is an entity that connects to the write-only port of the Service
+// and exposes the ability to produce performance data on-demand. The lifecycle
+// of a Producer is as follows:
+// 1. The producer connects to the service and advertises its data sources
+//    (e.g., the ability to get kernel ftraces, to list process stats).
+// 2. The service acknowledges the connection and sends over the SharedMemory
+//    region that will be used to exchange data (together with the signalling
+//    API TracingService::ProducerEndpoint::OnPageAcquired()/OnPageReleased()).
+// 3. At some point later on, the Service asks the Producer to turn on some of
+//    the previously registered data sources, together with some configuration
+//    parameters. This happens via the StartDataSource() callback.
+// 4. In response to that the Producer will spawn an instance of the given data
+//    source and inject its data into the shared memory buffer (obtained during
+//    OnConnect).
+// This interface is subclassed by:
+//  1. The actual producer code in the clients e.g., the ftrace reader process.
+//  2. The transport layer when interposing RPC between service and producers.
+class PERFETTO_EXPORT_COMPONENT Producer {
+ public:
+  virtual ~Producer();
+
+  // Called by Service (or more typically by the transport layer, on behalf of
+  // the remote Service), once the Producer <> Service connection has been
+  // established.
+  virtual void OnConnect() = 0;
+
+  // Called by the Service or by the transport layer if the connection with the
+  // service drops, either voluntarily (e.g., by destroying the ProducerEndpoint
+  // obtained through Service::ConnectProducer()) or involuntarily (e.g., if the
+  // Service process crashes).
+  // The Producer is expected to tear down all its data sources if this happens.
+  // Once this call returns it is possible to safely destroy the Producer
+  // instance.
+  virtual void OnDisconnect() = 0;
+
+  // Called by the Service after OnConnect but before the first DataSource is
+  // created. Can be used for any setup required before tracing begins.
+  virtual void OnTracingSetup() = 0;
+
+  // Called by muxer once StartupTracing is started. It will be called before
+  // SetupStartupTracingBlocking is returned.
+  virtual void OnStartupTracingSetup() {}
+
+  // The lifecycle methods below are always called in the following sequence:
+  // SetupDataSource  -> StartDataSource -> StopDataSource.
+  // Or, in the edge case where a trace is aborted immediately:
+  // SetupDataSource  -> StopDataSource.
+  // The Setup+Start call sequence is always guaranateed, regardless of the
+  // TraceConfig.deferred_start flags.
+  // Called by the Service to configure one of the data sources previously
+  // registered through TracingService::ProducerEndpoint::RegisterDataSource().
+  // This method is always called before StartDataSource. There is always a
+  // SetupDataSource() call before each StartDataSource() call.
+  // Args:
+  // - DataSourceInstanceID is an identifier chosen by the Service that should
+  //   be assigned to the newly created data source instance. It is used to
+  //   match the StopDataSource() request below.
+  // - DataSourceConfig is the configuration for the new data source (e.g.,
+  //   tells which trace categories to enable).
+  virtual void SetupDataSource(DataSourceInstanceID,
+                               const DataSourceConfig&) = 0;
+
+  // Called by the Service to turn on one of the data sources previously
+  // registered through TracingService::ProducerEndpoint::RegisterDataSource()
+  // and initialized through SetupDataSource().
+  // Both arguments are guaranteed to be identical to the ones passed to the
+  // prior SetupDataSource() call.
+  virtual void StartDataSource(DataSourceInstanceID,
+                               const DataSourceConfig&) = 0;
+
+  // Called by the Service to shut down an existing data source instance.
+  virtual void StopDataSource(DataSourceInstanceID) = 0;
+
+  // Called by the service to request the Producer to commit the data of the
+  // given data sources and return their chunks into the shared memory buffer.
+  // The Producer is expected to invoke NotifyFlushComplete(FlushRequestID) on
+  // the Service after the data has been committed. The producer has to either
+  // reply to the flush requests in order, or can just reply to the latest one
+  // Upon seeing a NotifyFlushComplete(N), the service will assume that all
+  // flushes < N have also been committed.
+  virtual void Flush(FlushRequestID,
+                     const DataSourceInstanceID* data_source_ids,
+                     size_t num_data_sources,
+                     FlushFlags) = 0;
+
+  // Called by the service to instruct the given data sources to stop referring
+  // to any trace contents emitted so far. The intent is that after processing
+  // this call, the rest of the trace should be parsable even if all of the
+  // packets emitted so far have been lost (for example due to ring buffer
+  // overwrites).
+  //
+  // Called only for Producers with active data sources that have opted in by
+  // setting |handles_incremental_state_clear| in their DataSourceDescriptor.
+  //
+  // The way this call is handled is up to the individual Producer
+  // implementation. Some might wish to emit invalidation markers in the trace
+  // (see TracePacket.incremental_state_cleared for an existing field), and
+  // handle them when parsing the trace.
+  virtual void ClearIncrementalState(
+      const DataSourceInstanceID* data_source_ids,
+      size_t num_data_sources) = 0;
+};
+
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_PRODUCER_H_
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/consumer.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/producer.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_arbiter.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h"
+
+// gen_amalgamated expanded: #include "protos/perfetto/common/tracing_service_state.gen.h"
+
+// This translation unit contains the definitions for the destructor of pure
+// virtual interfaces for the current build target. The alternative would be
+// introducing a one-liner .cc file for each pure virtual interface, which is
+// overkill. This is for compliance with -Wweak-vtables.
+
+namespace perfetto {
+
+Consumer::~Consumer() = default;
+Producer::~Producer() = default;
+TracingService::~TracingService() = default;
+ConsumerEndpoint::~ConsumerEndpoint() = default;
+ProducerEndpoint::~ProducerEndpoint() = default;
+RelayEndpoint::~RelayEndpoint() = default;
+SharedMemory::~SharedMemory() = default;
+SharedMemory::Factory::~Factory() = default;
+SharedMemoryArbiter::~SharedMemoryArbiter() = default;
+
+// TODO(primiano): make pure virtual after various 3way patches.
+void Consumer::OnSessionCloned(const OnSessionClonedArgs&) {}
+
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/console_interceptor.cc
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "perfetto/tracing/console_interceptor.h"
+
+#include <stdarg.h>
+
+#include <algorithm>
+#include <cmath>
+#include <optional>
+#include <tuple>
+
+// gen_amalgamated expanded: #include "perfetto/ext/base/file_utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/track_event_internal.h"
+
+// gen_amalgamated expanded: #include "protos/perfetto/common/interceptor_descriptor.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/data_source_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/interceptor_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/interceptors/console_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/interned_data/interned_data.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet_defaults.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/process_descriptor.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/thread_descriptor.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_descriptor.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_event.pbzero.h"
+
+namespace perfetto {
+
+// sRGB color.
+struct ConsoleColor {
+  uint8_t r;
+  uint8_t g;
+  uint8_t b;
+};
+
+namespace {
+
+int g_output_fd_for_testing;
+
+// Google Turbo colormap.
+constexpr std::array<ConsoleColor, 16> kTurboColors = {{
+    ConsoleColor{0x30, 0x12, 0x3b},
+    ConsoleColor{0x40, 0x40, 0xa1},
+    ConsoleColor{0x46, 0x6b, 0xe3},
+    ConsoleColor{0x41, 0x93, 0xfe},
+    ConsoleColor{0x28, 0xbb, 0xeb},
+    ConsoleColor{0x17, 0xdc, 0xc2},
+    ConsoleColor{0x32, 0xf1, 0x97},
+    ConsoleColor{0x6d, 0xfd, 0x62},
+    ConsoleColor{0xa4, 0xfc, 0x3b},
+    ConsoleColor{0xcd, 0xeb, 0x34},
+    ConsoleColor{0xed, 0xcf, 0x39},
+    ConsoleColor{0xfd, 0xab, 0x33},
+    ConsoleColor{0xfa, 0x7d, 0x20},
+    ConsoleColor{0xea, 0x50, 0x0d},
+    ConsoleColor{0xd0, 0x2f, 0x04},
+    ConsoleColor{0xa9, 0x15, 0x01},
+}};
+
+constexpr size_t kHueBits = 4;
+constexpr uint32_t kMaxHue = kTurboColors.size() << kHueBits;
+constexpr uint8_t kLightness = 128u;
+constexpr ConsoleColor kWhiteColor{0xff, 0xff, 0xff};
+
+const char kDim[] = "\x1b[90m";
+const char kDefault[] = "\x1b[39m";
+const char kReset[] = "\x1b[0m";
+
+#define FMT_RGB_SET "\x1b[38;2;%d;%d;%dm"
+#define FMT_RGB_SET_BG "\x1b[48;2;%d;%d;%dm"
+
+ConsoleColor Mix(ConsoleColor a, ConsoleColor b, uint8_t ratio) {
+  return {
+      static_cast<uint8_t>(a.r + (((b.r - a.r) * ratio) >> 8)),
+      static_cast<uint8_t>(a.g + (((b.g - a.g) * ratio) >> 8)),
+      static_cast<uint8_t>(a.b + (((b.b - a.b) * ratio) >> 8)),
+  };
+}
+
+ConsoleColor HueToRGB(uint32_t hue) {
+  PERFETTO_DCHECK(hue < kMaxHue);
+  uint32_t c1 = hue >> kHueBits;
+  uint32_t c2 =
+      std::min(static_cast<uint32_t>(kTurboColors.size() - 1), c1 + 1u);
+  uint32_t ratio = hue & ((1 << kHueBits) - 1);
+  return Mix(kTurboColors[c1], kTurboColors[c2],
+             static_cast<uint8_t>(ratio | (ratio << kHueBits)));
+}
+
+uint32_t CounterToHue(uint32_t counter) {
+  // We split the hue space into 8 segments, reversing the order of bits so
+  // successive counter values will be far from each other.
+  uint32_t reversed =
+      ((counter & 0x7) >> 2) | ((counter & 0x3)) | ((counter & 0x1) << 2);
+  return reversed * kMaxHue / 8;
+}
+
+}  // namespace
+
+class ConsoleInterceptor::Delegate : public TrackEventStateTracker::Delegate {
+ public:
+  explicit Delegate(InterceptorContext&);
+  ~Delegate() override;
+
+  TrackEventStateTracker::SessionState* GetSessionState() override;
+  void OnTrackUpdated(TrackEventStateTracker::Track&) override;
+  void OnTrackEvent(const TrackEventStateTracker::Track&,
+                    const TrackEventStateTracker::ParsedTrackEvent&) override;
+
+ private:
+  using SelfHandle = LockedHandle<ConsoleInterceptor>;
+
+  InterceptorContext& context_;
+  std::optional<SelfHandle> locked_self_;
+};
+
+ConsoleInterceptor::~ConsoleInterceptor() = default;
+
+ConsoleInterceptor::ThreadLocalState::ThreadLocalState(
+    ThreadLocalStateArgs& args) {
+  if (auto self = args.GetInterceptorLocked()) {
+    start_time_ns = self->start_time_ns_;
+    use_colors = self->use_colors_;
+    fd = self->fd_;
+  }
+}
+
+ConsoleInterceptor::ThreadLocalState::~ThreadLocalState() = default;
+
+ConsoleInterceptor::Delegate::Delegate(InterceptorContext& context)
+    : context_(context) {}
+ConsoleInterceptor::Delegate::~Delegate() = default;
+
+TrackEventStateTracker::SessionState*
+ConsoleInterceptor::Delegate::GetSessionState() {
+  // When the session state is retrieved for the first time, it is cached (and
+  // kept locked) until we return from OnTracePacket. This avoids having to lock
+  // and unlock the instance multiple times per invocation.
+  if (locked_self_.has_value())
+    return &locked_self_.value()->session_state_;
+  locked_self_ =
+      std::make_optional<SelfHandle>(context_.GetInterceptorLocked());
+  return &locked_self_.value()->session_state_;
+}
+
+void ConsoleInterceptor::Delegate::OnTrackUpdated(
+    TrackEventStateTracker::Track& track) {
+  auto track_color = HueToRGB(CounterToHue(track.index));
+  std::array<char, 16> title;
+  if (!track.name.empty()) {
+    snprintf(title.data(), title.size(), "%s", track.name.c_str());
+  } else if (track.pid && track.tid) {
+    snprintf(title.data(), title.size(), "%u:%u",
+             static_cast<uint32_t>(track.pid),
+             static_cast<uint32_t>(track.tid));
+  } else if (track.pid) {
+    snprintf(title.data(), title.size(), "%" PRId64, track.pid);
+  } else {
+    snprintf(title.data(), title.size(), "%" PRIu64, track.uuid);
+  }
+  int title_width = static_cast<int>(title.size());
+
+  auto& tls = context_.GetThreadLocalState();
+  std::array<char, 128> message_prefix{};
+  size_t written = 0;
+  if (tls.use_colors) {
+    written = base::SprintfTrunc(message_prefix.data(), message_prefix.size(),
+                                 FMT_RGB_SET_BG " %s%s %-*.*s", track_color.r,
+                                 track_color.g, track_color.b, kReset, kDim,
+                                 title_width, title_width, title.data());
+  } else {
+    written = base::SprintfTrunc(message_prefix.data(), message_prefix.size(),
+                                 "%-*.*s", title_width + 2, title_width,
+                                 title.data());
+  }
+  track.user_data.assign(
+      message_prefix.begin(),
+      message_prefix.begin() + static_cast<ssize_t>(written));
+}
+
+void ConsoleInterceptor::Delegate::OnTrackEvent(
+    const TrackEventStateTracker::Track& track,
+    const TrackEventStateTracker::ParsedTrackEvent& event) {
+  // Start printing.
+  auto& tls = context_.GetThreadLocalState();
+  tls.buffer_pos = 0;
+
+  // Print timestamp and track identifier.
+  SetColor(context_, kDim);
+  Printf(context_, "[%7.3lf] %.*s",
+         static_cast<double>(event.timestamp_ns - tls.start_time_ns) / 1e9,
+         static_cast<int>(track.user_data.size()), track.user_data.data());
+
+  // Print category.
+  Printf(context_, "%-5.*s ",
+         std::min(5, static_cast<int>(event.category.size)),
+         event.category.data);
+
+  // Print stack depth.
+  for (size_t i = 0; i < event.stack_depth; i++) {
+    Printf(context_, "-  ");
+  }
+
+  // Print slice name.
+  auto slice_color = HueToRGB(event.name_hash % kMaxHue);
+  auto highlight_color = Mix(slice_color, kWhiteColor, kLightness);
+  if (event.track_event.type() == protos::pbzero::TrackEvent::TYPE_SLICE_END) {
+    SetColor(context_, kDefault);
+    Printf(context_, "} ");
+  }
+  SetColor(context_, highlight_color);
+  Printf(context_, "%.*s", static_cast<int>(event.name.size), event.name.data);
+  SetColor(context_, kReset);
+  if (event.track_event.type() ==
+      protos::pbzero::TrackEvent::TYPE_SLICE_BEGIN) {
+    SetColor(context_, kDefault);
+    Printf(context_, " {");
+  }
+
+  // Print annotations.
+  if (event.track_event.has_debug_annotations()) {
+    PrintDebugAnnotations(context_, event.track_event, slice_color,
+                          highlight_color);
+  }
+
+  // TODO(skyostil): Print typed arguments.
+
+  // Print duration for longer events.
+  constexpr uint64_t kNsPerMillisecond = 1000000u;
+  if (event.duration_ns >= 10 * kNsPerMillisecond) {
+    SetColor(context_, kDim);
+    Printf(context_, " +%" PRIu64 "ms", event.duration_ns / kNsPerMillisecond);
+  }
+  SetColor(context_, kReset);
+  Printf(context_, "\n");
+}
+
+// static
+void ConsoleInterceptor::Register() {
+  perfetto::protos::gen::InterceptorDescriptor desc;
+  desc.set_name("console");
+  Interceptor<ConsoleInterceptor>::Register(desc);
+}
+
+// static
+void ConsoleInterceptor::SetOutputFdForTesting(int fd) {
+  g_output_fd_for_testing = fd;
+}
+
+void ConsoleInterceptor::OnSetup(const SetupArgs& args) {
+  int fd = STDOUT_FILENO;
+  if (g_output_fd_for_testing)
+    fd = g_output_fd_for_testing;
+#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) && \
+    !PERFETTO_BUILDFLAG(PERFETTO_OS_WASM)
+  bool use_colors = isatty(fd);
+#else
+  bool use_colors = false;
+#endif
+  const protos::gen::ConsoleConfig& config =
+      args.config.interceptor_config().console_config();
+  if (config.has_enable_colors())
+    use_colors = config.enable_colors();
+  if (config.output() == protos::gen::ConsoleConfig::OUTPUT_STDOUT) {
+    fd = STDOUT_FILENO;
+  } else if (config.output() == protos::gen::ConsoleConfig::OUTPUT_STDERR) {
+    fd = STDERR_FILENO;
+  }
+  fd_ = fd;
+  use_colors_ = use_colors;
+}
+
+void ConsoleInterceptor::OnStart(const StartArgs&) {
+  start_time_ns_ = internal::TrackEventInternal::GetTimeNs();
+}
+
+void ConsoleInterceptor::OnStop(const StopArgs&) {}
+
+// static
+void ConsoleInterceptor::OnTracePacket(InterceptorContext context) {
+  {
+    auto& tls = context.GetThreadLocalState();
+    Delegate delegate(context);
+    perfetto::protos::pbzero::TracePacket::Decoder packet(
+        context.packet_data.data, context.packet_data.size);
+    TrackEventStateTracker::ProcessTracePacket(delegate, tls.sequence_state,
+                                               packet);
+  }  // (Potential) lock scope for session state.
+  Flush(context);
+}
+
+// static
+void ConsoleInterceptor::Printf(InterceptorContext& context,
+                                const char* format,
+                                ...) {
+  auto& tls = context.GetThreadLocalState();
+  ssize_t remaining = static_cast<ssize_t>(tls.message_buffer.size()) -
+                      static_cast<ssize_t>(tls.buffer_pos);
+  int written = 0;
+  if (remaining > 0) {
+    va_list args;
+    va_start(args, format);
+    written = vsnprintf(&tls.message_buffer[tls.buffer_pos],
+                        static_cast<size_t>(remaining), format, args);
+    PERFETTO_DCHECK(written >= 0);
+    va_end(args);
+  }
+
+  // In case of buffer overflow, flush to the fd and write the latest message to
+  // it directly instead.
+  if (remaining <= 0 || written > remaining) {
+    FILE* output = (tls.fd == STDOUT_FILENO) ? stdout : stderr;
+    if (g_output_fd_for_testing) {
+      output = fdopen(dup(g_output_fd_for_testing), "w");
+    }
+    Flush(context);
+    va_list args;
+    va_start(args, format);
+    vfprintf(output, format, args);
+    va_end(args);
+    if (g_output_fd_for_testing) {
+      fclose(output);
+    }
+  } else if (written > 0) {
+    tls.buffer_pos += static_cast<size_t>(written);
+  }
+}
+
+// static
+void ConsoleInterceptor::Flush(InterceptorContext& context) {
+  auto& tls = context.GetThreadLocalState();
+  ssize_t res = base::WriteAll(tls.fd, &tls.message_buffer[0], tls.buffer_pos);
+  PERFETTO_DCHECK(res == static_cast<ssize_t>(tls.buffer_pos));
+  tls.buffer_pos = 0;
+}
+
+// static
+void ConsoleInterceptor::SetColor(InterceptorContext& context,
+                                  const ConsoleColor& color) {
+  auto& tls = context.GetThreadLocalState();
+  if (!tls.use_colors)
+    return;
+  Printf(context, FMT_RGB_SET, color.r, color.g, color.b);
+}
+
+// static
+void ConsoleInterceptor::SetColor(InterceptorContext& context,
+                                  const char* color) {
+  auto& tls = context.GetThreadLocalState();
+  if (!tls.use_colors)
+    return;
+  Printf(context, "%s", color);
+}
+
+// static
+void ConsoleInterceptor::PrintDebugAnnotations(
+    InterceptorContext& context,
+    const protos::pbzero::TrackEvent_Decoder& track_event,
+    const ConsoleColor& slice_color,
+    const ConsoleColor& highlight_color) {
+  SetColor(context, slice_color);
+  Printf(context, "(");
+
+  bool is_first = true;
+  for (auto it = track_event.debug_annotations(); it; it++) {
+    perfetto::protos::pbzero::DebugAnnotation::Decoder annotation(*it);
+    SetColor(context, slice_color);
+    if (!is_first)
+      Printf(context, ", ");
+
+    PrintDebugAnnotationName(context, annotation);
+    Printf(context, ":");
+
+    SetColor(context, highlight_color);
+    PrintDebugAnnotationValue(context, annotation);
+
+    is_first = false;
+  }
+  SetColor(context, slice_color);
+  Printf(context, ")");
+}
+
+// static
+void ConsoleInterceptor::PrintDebugAnnotationName(
+    InterceptorContext& context,
+    const perfetto::protos::pbzero::DebugAnnotation::Decoder& annotation) {
+  auto& tls = context.GetThreadLocalState();
+  protozero::ConstChars name{};
+  if (annotation.name_iid()) {
+    name.data =
+        tls.sequence_state.debug_annotation_names[annotation.name_iid()].data();
+    name.size =
+        tls.sequence_state.debug_annotation_names[annotation.name_iid()].size();
+  } else if (annotation.has_name()) {
+    name.data = annotation.name().data;
+    name.size = annotation.name().size;
+  }
+  Printf(context, "%.*s", static_cast<int>(name.size), name.data);
+}
+
+// static
+void ConsoleInterceptor::PrintDebugAnnotationValue(
+    InterceptorContext& context,
+    const perfetto::protos::pbzero::DebugAnnotation::Decoder& annotation) {
+  if (annotation.has_bool_value()) {
+    Printf(context, "%s", annotation.bool_value() ? "true" : "false");
+  } else if (annotation.has_uint_value()) {
+    Printf(context, "%" PRIu64, annotation.uint_value());
+  } else if (annotation.has_int_value()) {
+    Printf(context, "%" PRId64, annotation.int_value());
+  } else if (annotation.has_double_value()) {
+    Printf(context, "%f", annotation.double_value());
+  } else if (annotation.has_string_value()) {
+    Printf(context, "%.*s", static_cast<int>(annotation.string_value().size),
+           annotation.string_value().data);
+  } else if (annotation.has_pointer_value()) {
+    Printf(context, "%p", reinterpret_cast<void*>(annotation.pointer_value()));
+  } else if (annotation.has_legacy_json_value()) {
+    Printf(context, "%.*s",
+           static_cast<int>(annotation.legacy_json_value().size),
+           annotation.legacy_json_value().data);
+  } else if (annotation.has_dict_entries()) {
+    Printf(context, "{");
+    bool is_first = true;
+    for (auto it = annotation.dict_entries(); it; ++it) {
+      if (!is_first)
+        Printf(context, ", ");
+      perfetto::protos::pbzero::DebugAnnotation::Decoder key_value(*it);
+      PrintDebugAnnotationName(context, key_value);
+      Printf(context, ":");
+      PrintDebugAnnotationValue(context, key_value);
+      is_first = false;
+    }
+    Printf(context, "}");
+  } else if (annotation.has_array_values()) {
+    Printf(context, "[");
+    bool is_first = true;
+    for (auto it = annotation.array_values(); it; ++it) {
+      if (!is_first)
+        Printf(context, ", ");
+      perfetto::protos::pbzero::DebugAnnotation::Decoder key_value(*it);
+      PrintDebugAnnotationValue(context, key_value);
+      is_first = false;
+    }
+    Printf(context, "]");
+  } else {
+    Printf(context, "{}");
+  }
+}
+
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/data_source.cc
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "perfetto/tracing/data_source.h"
+
+#include <atomic>
+#include <cstdint>
+
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/flags.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/data_source_internal.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/data_source_type.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_muxer.h"
+
+// gen_amalgamated expanded: #include "protos/perfetto/config/data_source_config.gen.h"
+
+namespace perfetto {
+
+DataSourceBase::StopArgs::~StopArgs() = default;
+DataSourceBase::FlushArgs::~FlushArgs() = default;
+DataSourceBase::~DataSourceBase() = default;
+void DataSourceBase::OnSetup(const SetupArgs&) {}
+void DataSourceBase::OnStart(const StartArgs&) {}
+void DataSourceBase::OnStop(const StopArgs&) {}
+void DataSourceBase::WillClearIncrementalState(
+    const ClearIncrementalStateArgs&) {}
+void DataSourceBase::OnFlush(const FlushArgs&) {}
+
+bool DataSourceBase::CanAdoptStartupSession(
+    const DataSourceConfig& startup_config,
+    const DataSourceConfig& service_config) {
+  // Clear target buffer and tracing-service provided fields for comparison of
+  // configs for startup tracing, since these fields are not available when
+  // setting up data sources for startup tracing.
+  DataSourceConfig startup_config_stripped = startup_config;
+  DataSourceConfig service_config_stripped = service_config;
+
+  startup_config_stripped.set_target_buffer(0);
+  startup_config_stripped.set_tracing_session_id(0);
+  startup_config_stripped.set_session_initiator(
+      DataSourceConfig::SESSION_INITIATOR_UNSPECIFIED);
+  startup_config_stripped.set_trace_duration_ms(0);
+  startup_config_stripped.set_stop_timeout_ms(0);
+  startup_config_stripped.set_enable_extra_guardrails(false);
+
+  service_config_stripped.set_target_buffer(0);
+  service_config_stripped.set_tracing_session_id(0);
+  service_config_stripped.set_session_initiator(
+      DataSourceConfig::SESSION_INITIATOR_UNSPECIFIED);
+  service_config_stripped.set_trace_duration_ms(0);
+  service_config_stripped.set_stop_timeout_ms(0);
+  service_config_stripped.set_enable_extra_guardrails(false);
+
+  return startup_config_stripped == service_config_stripped;
+}
+
+namespace internal {
+
+void DataSourceType::PopulateTlsInst(
+    DataSourceInstanceThreadLocalState* tls_inst,
+    DataSourceState* instance_state,
+    uint32_t instance_index) {
+  auto* tracing_impl = TracingMuxer::Get();
+  tls_inst->muxer_id_for_testing = instance_state->muxer_id_for_testing;
+  tls_inst->backend_id = instance_state->backend_id;
+  tls_inst->backend_connection_id = instance_state->backend_connection_id;
+  tls_inst->buffer_id = instance_state->buffer_id;
+  tls_inst->startup_target_buffer_reservation =
+      instance_state->startup_target_buffer_reservation.load(
+          std::memory_order_relaxed);
+  tls_inst->data_source_instance_id = instance_state->data_source_instance_id;
+  tls_inst->is_intercepted = instance_state->interceptor_id != 0;
+  tls_inst->trace_writer =
+      tracing_impl->CreateTraceWriter(&state_, instance_index, instance_state,
+                                      instance_state->buffer_exhausted_policy);
+  if (create_incremental_state_fn_) {
+    PERFETTO_DCHECK(!tls_inst->incremental_state);
+    CreateIncrementalState(tls_inst, instance_index);
+  }
+  if (create_custom_tls_fn_) {
+    tls_inst->data_source_custom_tls =
+        create_custom_tls_fn_(tls_inst, instance_index, user_arg_);
+  }
+  // Even in the case of out-of-IDs, SharedMemoryArbiterImpl returns a
+  // NullTraceWriter. The returned pointer should never be null.
+  PERFETTO_DCHECK(tls_inst->trace_writer);
+}
+
+void DataSourceType::ClearIncrementalState(
+    internal::DataSourceInstanceThreadLocalState* tls_inst,
+    uint32_t instance_index,
+    uint32_t actual_generation) {
+  if constexpr (
+      PERFETTO_FLAGS_TRACK_EVENT_INCREMENTAL_STATE_CLEAR_NOT_DESTROY) {
+    // Try to clear the existing state if we have a clear function and the
+    // state exists. This allows reusing allocated memory instead of
+    // destroying and recreating the state object.
+    void* incremental_state = tls_inst->incremental_state.get();
+    if (clear_incremental_state_fn_ && incremental_state &&
+        clear_incremental_state_fn_(incremental_state, user_arg_)) {
+      tls_inst->incremental_state_generation = actual_generation;
+    } else {
+      tls_inst->incremental_state.reset();
+      CreateIncrementalState(tls_inst, instance_index);
+    }
+  } else {
+    tls_inst->incremental_state.reset();
+    CreateIncrementalState(tls_inst, instance_index);
+  }
+}
+
+}  // namespace internal
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/debug_annotation.cc
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "perfetto/tracing/debug_annotation.h"
+
+// gen_amalgamated expanded: #include "perfetto/tracing/traced_value.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/debug_annotation.pbzero.h"
+
+namespace perfetto {
+
+DebugAnnotation::~DebugAnnotation() = default;
+
+void DebugAnnotation::WriteIntoTracedValue(TracedValue context) const {
+  Add(context.annotation_);
+}
+
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/event_context.cc
+// gen_amalgamated begin header: include/perfetto/tracing/internal/track_event_interned_fields.h
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/track_event_interned_data_index.h"
+
+#ifndef INCLUDE_PERFETTO_TRACING_INTERNAL_TRACK_EVENT_INTERNED_FIELDS_H_
+#define INCLUDE_PERFETTO_TRACING_INTERNAL_TRACK_EVENT_INTERNED_FIELDS_H_
+
+namespace perfetto {
+namespace internal {
+
+// These helpers are exposed here to allow Chromium-without-client library
+// to share the interning buffers with Perfetto internals (e.g.
+// perfetto::TracedValue implementation).
+
+struct PERFETTO_EXPORT_COMPONENT InternedEventCategory
+    : public TrackEventInternedDataIndex<
+          InternedEventCategory,
+          perfetto::protos::pbzero::InternedData::kEventCategoriesFieldNumber,
+          const char*,
+          SmallInternedDataTraits> {
+  ~InternedEventCategory() override;
+
+  static void Add(protos::pbzero::InternedData* interned_data,
+                  size_t iid,
+                  const char* value,
+                  size_t length);
+};
+
+struct PERFETTO_EXPORT_COMPONENT InternedEventName
+    : public TrackEventInternedDataIndex<
+          InternedEventName,
+          perfetto::protos::pbzero::InternedData::kEventNamesFieldNumber,
+          const char*,
+          SmallInternedDataTraits> {
+  ~InternedEventName() override;
+
+  static void Add(protos::pbzero::InternedData* interned_data,
+                  size_t iid,
+                  const char* value);
+};
+
+struct PERFETTO_EXPORT_COMPONENT InternedDebugAnnotationName
+    : public TrackEventInternedDataIndex<
+          InternedDebugAnnotationName,
+          perfetto::protos::pbzero::InternedData::
+              kDebugAnnotationNamesFieldNumber,
+          const char*,
+          SmallInternedDataTraits> {
+  ~InternedDebugAnnotationName() override;
+
+  static void Add(protos::pbzero::InternedData* interned_data,
+                  size_t iid,
+                  const char* value);
+};
+
+struct PERFETTO_EXPORT_COMPONENT InternedDebugAnnotationValueTypeName
+    : public TrackEventInternedDataIndex<
+          InternedDebugAnnotationValueTypeName,
+          perfetto::protos::pbzero::InternedData::
+              kDebugAnnotationValueTypeNamesFieldNumber,
+          const char*,
+          SmallInternedDataTraits> {
+  ~InternedDebugAnnotationValueTypeName() override;
+
+  static void Add(protos::pbzero::InternedData* interned_data,
+                  size_t iid,
+                  const char* value);
+};
+
+}  // namespace internal
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_TRACING_INTERNAL_TRACK_EVENT_INTERNED_FIELDS_H_
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "perfetto/tracing/event_context.h"
+
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/track_event_interned_fields.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/interned_data/interned_data.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_event.pbzero.h"
+
+namespace perfetto {
+
+EventContext::EventContext(
+    EventContext::TracePacketHandle trace_packet,
+    internal::TrackEventIncrementalState* incremental_state,
+    internal::TrackEventTlsState* tls_state)
+    : trace_packet_(std::move(trace_packet)),
+      event_(trace_packet_->set_track_event()),
+      incremental_state_(incremental_state),
+      tls_state_(tls_state) {}
+
+EventContext::~EventContext() {
+  if (!trace_packet_)
+    return;
+
+  // When the track event is finalized (i.e., the context is destroyed), we
+  // should flush any newly seen interned data to the trace. The data has
+  // earlier been written to a heap allocated protobuf message
+  // (|serialized_interned_data|). Here we just need to flush it to the main
+  // trace.
+  auto& serialized_interned_data = incremental_state_->serialized_interned_data;
+  if (PERFETTO_UNLIKELY(!serialized_interned_data.empty())) {
+    auto ranges = serialized_interned_data.GetRanges();
+    trace_packet_->AppendScatteredBytes(
+        perfetto::protos::pbzero::TracePacket::kInternedDataFieldNumber,
+        &ranges[0], ranges.size());
+
+    // Reset the message but keep one buffer allocated for future use.
+    serialized_interned_data.Reset();
+  }
+}
+
+protos::pbzero::DebugAnnotation* EventContext::AddDebugAnnotation(
+    const char* name) {
+  auto annotation = event()->add_debug_annotations();
+  annotation->set_name_iid(
+      internal::InternedDebugAnnotationName::Get(this, name));
+  return annotation;
+}
+
+protos::pbzero::DebugAnnotation* EventContext::AddDebugAnnotation(
+    ::perfetto::DynamicString name) {
+  auto annotation = event()->add_debug_annotations();
+  annotation->set_name(name.value);
+  return annotation;
+}
+
+TrackEventTlsStateUserData* EventContext::GetTlsUserData(const void* key) {
+  PERFETTO_CHECK(tls_state_);
+  PERFETTO_CHECK(key);
+  auto it = tls_state_->user_data.find(key);
+  if (it != tls_state_->user_data.end()) {
+    return it->second.get();
+  }
+  return nullptr;
+}
+
+void EventContext::SetTlsUserData(
+    const void* key,
+    std::unique_ptr<TrackEventTlsStateUserData> data) {
+  PERFETTO_CHECK(tls_state_);
+  PERFETTO_CHECK(key);
+  tls_state_->user_data[key] = std::move(data);
+}
+
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/interceptor.cc
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "perfetto/tracing/interceptor.h"
+
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_muxer.h"
+
+namespace perfetto {
+
+InterceptorBase::~InterceptorBase() = default;
+InterceptorBase::ThreadLocalState::~ThreadLocalState() = default;
+
+// static
+void InterceptorBase::RegisterImpl(
+    const InterceptorDescriptor& descriptor,
+    std::function<std::unique_ptr<InterceptorBase>()> factory,
+    InterceptorBase::TLSFactory tls_factory,
+    InterceptorBase::TracePacketCallback on_trace_packet) {
+  auto* tracing_impl = internal::TracingMuxer::Get();
+  tracing_impl->RegisterInterceptor(descriptor, factory, tls_factory,
+                                    on_trace_packet);
+}
+
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/internal/checked_scope.cc
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/checked_scope.h"
+
+#include <utility>
+
+namespace perfetto {
+namespace internal {
+
+#if PERFETTO_DCHECK_IS_ON()
+CheckedScope::CheckedScope(CheckedScope* parent_scope)
+    : parent_scope_(parent_scope) {
+  if (parent_scope_) {
+    PERFETTO_DCHECK(parent_scope_->is_active());
+    parent_scope_->set_is_active(false);
+  }
+}
+
+CheckedScope::~CheckedScope() {
+  Reset();
+}
+
+void CheckedScope::Reset() {
+  if (!is_active_) {
+    // The only case when inactive scope could be destroyed is when Reset() was
+    // called explicitly or the contents of the object were moved away.
+    PERFETTO_DCHECK(deleted_);
+    return;
+  }
+  is_active_ = false;
+  deleted_ = true;
+  if (parent_scope_)
+    parent_scope_->set_is_active(true);
+}
+
+CheckedScope::CheckedScope(CheckedScope&& other) {
+  *this = std::move(other);
+}
+
+CheckedScope& CheckedScope::operator=(CheckedScope&& other) {
+  is_active_ = other.is_active_;
+  parent_scope_ = other.parent_scope_;
+  deleted_ = other.deleted_;
+
+  other.is_active_ = false;
+  other.parent_scope_ = nullptr;
+  other.deleted_ = true;
+
+  return *this;
+}
+#endif
+
+}  // namespace internal
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/internal/interceptor_trace_writer.cc
+// gen_amalgamated begin header: include/perfetto/tracing/internal/interceptor_trace_writer.h
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_TRACING_INTERNAL_INTERCEPTOR_TRACE_WRITER_H_
+#define INCLUDE_PERFETTO_TRACING_INTERNAL_INTERCEPTOR_TRACE_WRITER_H_
+
+#include <atomic>
+#include <cstdint>
+#include <functional>
+#include <memory>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/message_handle.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/interceptor.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/data_source_internal.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/trace_writer_base.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h"
+
+namespace perfetto {
+namespace internal {
+
+// A heap-backed trace writer used to reroute trace packets to an interceptor.
+class InterceptorTraceWriter : public TraceWriterBase {
+ public:
+  InterceptorTraceWriter(std::unique_ptr<InterceptorBase::ThreadLocalState> tls,
+                         InterceptorBase::TracePacketCallback packet_callback,
+                         DataSourceStaticState* static_state,
+                         uint32_t instance_index);
+  ~InterceptorTraceWriter() override;
+
+  // TraceWriterBase implementation.
+  protozero::MessageHandle<protos::pbzero::TracePacket> NewTracePacket()
+      override;
+  void FinishTracePacket() override;
+  void Flush(std::function<void()> callback = {}) override;
+  uint64_t written() const override;
+  uint64_t drop_count() const override;
+
+ private:
+  std::unique_ptr<InterceptorBase::ThreadLocalState> tls_;
+  InterceptorBase::TracePacketCallback packet_callback_;
+
+  protozero::HeapBuffered<protos::pbzero::TracePacket> cur_packet_;
+  uint64_t bytes_written_ = 0;
+
+  // Static state of the data source we are intercepting.
+  DataSourceStaticState* const static_state_;
+
+  // Index of the data source tracing session which we are intercepting
+  // (0...kMaxDataSourceInstances - 1). Used to look up this interceptor's
+  // session state (i.e., the Interceptor class instance) in the
+  // DataSourceStaticState::instances array.
+  const uint32_t instance_index_;
+
+  const uint32_t sequence_id_;
+
+  static std::atomic<uint32_t> next_sequence_id_;
+};
+
+}  // namespace internal
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_TRACING_INTERNAL_INTERCEPTOR_TRACE_WRITER_H_
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/interceptor_trace_writer.h"
+
+#include <atomic>
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <utility>
+
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/field.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message_handle.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/interceptor.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/data_source_internal.h"
+
+namespace perfetto {
+namespace internal {
+
+// static
+std::atomic<uint32_t> InterceptorTraceWriter::next_sequence_id_{};
+
+InterceptorTraceWriter::InterceptorTraceWriter(
+    std::unique_ptr<InterceptorBase::ThreadLocalState> tls,
+    InterceptorBase::TracePacketCallback packet_callback,
+    DataSourceStaticState* static_state,
+    uint32_t instance_index)
+    : tls_(std::move(tls)),
+      packet_callback_(std::move(packet_callback)),
+      static_state_(static_state),
+      instance_index_(instance_index),
+      sequence_id_(++next_sequence_id_) {}
+
+InterceptorTraceWriter::~InterceptorTraceWriter() = default;
+
+protozero::MessageHandle<protos::pbzero::TracePacket>
+InterceptorTraceWriter::NewTracePacket() {
+  Flush();
+  auto packet = TraceWriter::TracePacketHandle(cur_packet_.get());
+  packet->set_trusted_packet_sequence_id(sequence_id_);
+  return packet;
+}
+
+void InterceptorTraceWriter::Flush(std::function<void()> callback) {
+  if (!cur_packet_.empty()) {
+    InterceptorBase::TracePacketCallbackArgs args{};
+    args.static_state = static_state_;
+    args.instance_index = instance_index_;
+    args.tls = tls_.get();
+
+    const auto& slices = cur_packet_.GetSlices();
+    if (slices.size() == 1) {
+      // Fast path: the current packet fits into a single slice.
+      auto slice_range = slices.begin()->GetUsedRange();
+      args.packet_data = protozero::ConstBytes{
+          slice_range.begin,
+          static_cast<size_t>(slice_range.end - slice_range.begin)};
+      bytes_written_ += static_cast<uint64_t>(args.packet_data.size);
+      packet_callback_(std::move(args));
+    } else {
+      // Fallback: stitch together multiple slices.
+      auto stitched_data = cur_packet_.SerializeAsArray();
+      args.packet_data =
+          protozero::ConstBytes{stitched_data.data(), stitched_data.size()};
+      bytes_written_ += static_cast<uint64_t>(stitched_data.size());
+      packet_callback_(std::move(args));
+    }
+    cur_packet_.Reset();
+  }
+  if (callback)
+    callback();
+}
+
+void InterceptorTraceWriter::FinishTracePacket() {}
+
+uint64_t InterceptorTraceWriter::written() const {
+  return bytes_written_;
+}
+
+uint64_t InterceptorTraceWriter::drop_count() const {
+  return 0;
+}
+
+}  // namespace internal
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/internal/tracing_backend_fake.cc
+// gen_amalgamated begin header: include/perfetto/tracing/internal/tracing_backend_fake.h
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_TRACING_INTERNAL_TRACING_BACKEND_FAKE_H_
+#define INCLUDE_PERFETTO_TRACING_INTERNAL_TRACING_BACKEND_FAKE_H_
+
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/tracing_backend.h"
+
+namespace perfetto {
+namespace internal {
+
+// A built-in implementation of TracingBackend that fails any attempt to create
+// a tracing session.
+class PERFETTO_EXPORT_COMPONENT TracingBackendFake : public TracingBackend {
+ public:
+  static TracingBackend* GetInstance();
+
+  // TracingBackend implementation.
+  std::unique_ptr<ProducerEndpoint> ConnectProducer(
+      const ConnectProducerArgs&) override;
+  std::unique_ptr<ConsumerEndpoint> ConnectConsumer(
+      const ConnectConsumerArgs&) override;
+
+ private:
+  TracingBackendFake();
+};
+
+}  // namespace internal
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_TRACING_INTERNAL_TRACING_BACKEND_FAKE_H_
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_backend_fake.h"
+
+// gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/weak_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/consumer.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/producer.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_writer.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h"
+
+namespace perfetto {
+namespace internal {
+
+namespace {
+
+class UnsupportedProducerEndpoint : public ProducerEndpoint {
+ public:
+  UnsupportedProducerEndpoint(Producer* producer, base::TaskRunner* task_runner)
+      : producer_(producer), task_runner_(task_runner) {
+    // The SDK will attempt to reconnect the producer, so instead we allow it
+    // to connect successfully, but never start any sessions.
+    auto weak_ptr = weak_ptr_factory_.GetWeakPtr();
+    task_runner_->PostTask([weak_ptr] {
+      if (weak_ptr && weak_ptr->connected_)
+        weak_ptr->producer_->OnConnect();
+    });
+  }
+  ~UnsupportedProducerEndpoint() override { Disconnect(); }
+
+  void Disconnect() override {
+    if (!connected_)
+      return;
+    connected_ = false;
+    producer_->OnDisconnect();
+  }
+
+  void RegisterDataSource(const DataSourceDescriptor&) override {}
+  void UpdateDataSource(const DataSourceDescriptor&) override {}
+  void UnregisterDataSource(const std::string& /*name*/) override {}
+
+  void RegisterTraceWriter(uint32_t /*writer_id*/,
+                           uint32_t /*target_buffer*/) override {}
+  void UnregisterTraceWriter(uint32_t /*writer_id*/) override {}
+
+  void CommitData(const CommitDataRequest&,
+                  CommitDataCallback callback) override {
+    if (connected_) {
+      callback();
+    }
+  }
+
+  SharedMemory* shared_memory() const override { return nullptr; }
+  size_t shared_buffer_page_size_kb() const override { return 0; }
+
+  std::unique_ptr<TraceWriter> CreateTraceWriter(
+      BufferID /*target_buffer*/,
+      BufferExhaustedPolicy) override {
+    return nullptr;
+  }
+
+  SharedMemoryArbiter* MaybeSharedMemoryArbiter() override { return nullptr; }
+  bool IsShmemProvidedByProducer() const override { return false; }
+
+  void NotifyFlushComplete(FlushRequestID) override {}
+  void NotifyDataSourceStarted(DataSourceInstanceID) override {}
+  void NotifyDataSourceStopped(DataSourceInstanceID) override {}
+  void ActivateTriggers(const std::vector<std::string>&) override {}
+
+  void Sync(std::function<void()> callback) override {
+    if (connected_) {
+      callback();
+    }
+  }
+
+ private:
+  Producer* const producer_;
+  base::TaskRunner* const task_runner_;
+  bool connected_ = true;
+  base::WeakPtrFactory<UnsupportedProducerEndpoint> weak_ptr_factory_{
+      this};  // Keep last.
+};
+
+class UnsupportedConsumerEndpoint : public ConsumerEndpoint {
+ public:
+  UnsupportedConsumerEndpoint(Consumer* consumer, base::TaskRunner* task_runner)
+      : consumer_(consumer), task_runner_(task_runner) {
+    // The SDK will not to reconnect the consumer, so we just disconnect it
+    // immediately, which will cancel the tracing session.
+    auto weak_this = weak_ptr_factory_.GetWeakPtr();
+    task_runner_->PostTask([weak_this] {
+      if (weak_this)
+        weak_this->consumer_->OnDisconnect();
+    });
+  }
+  ~UnsupportedConsumerEndpoint() override = default;
+
+  void EnableTracing(const TraceConfig&, base::ScopedFile) override {}
+  void ChangeTraceConfig(const TraceConfig&) override {}
+
+  void StartTracing() override {}
+  void DisableTracing() override {}
+
+  void Flush(uint32_t /*timeout_ms*/,
+             FlushCallback callback,
+             FlushFlags) override {
+    callback(/*success=*/false);
+  }
+
+  void ReadBuffers() override {}
+  void FreeBuffers() override {}
+
+  void Detach(const std::string& /*key*/) override {}
+  void Attach(const std::string& /*key*/) override {}
+
+  void GetTraceStats() override {}
+  void ObserveEvents(uint32_t /*events_mask*/) override {}
+  void QueryServiceState(QueryServiceStateArgs,
+                         QueryServiceStateCallback) override {}
+  void QueryCapabilities(QueryCapabilitiesCallback) override {}
+
+  void SaveTraceForBugreport(SaveTraceForBugreportCallback) override {}
+  void CloneSession(CloneSessionArgs) override {}
+
+ private:
+  Consumer* const consumer_;
+  base::TaskRunner* const task_runner_;
+  base::WeakPtrFactory<UnsupportedConsumerEndpoint> weak_ptr_factory_{
+      this};  // Keep last.
+};
+
+}  // namespace
+
+// static
+TracingBackend* TracingBackendFake::GetInstance() {
+  static auto* instance = new TracingBackendFake();
+  return instance;
+}
+
+TracingBackendFake::TracingBackendFake() = default;
+
+std::unique_ptr<ProducerEndpoint> TracingBackendFake::ConnectProducer(
+    const ConnectProducerArgs& args) {
+  return std::unique_ptr<ProducerEndpoint>(
+      new UnsupportedProducerEndpoint(args.producer, args.task_runner));
+}
+
+std::unique_ptr<ConsumerEndpoint> TracingBackendFake::ConnectConsumer(
+    const ConnectConsumerArgs& args) {
+  return std::unique_ptr<ConsumerEndpoint>(
+      new UnsupportedConsumerEndpoint(args.consumer, args.task_runner));
+}
+
+}  // namespace internal
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/internal/tracing_muxer_fake.cc
+// gen_amalgamated begin header: src/tracing/internal/tracing_muxer_fake.h
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SRC_TRACING_INTERNAL_TRACING_MUXER_FAKE_H_
+#define SRC_TRACING_INTERNAL_TRACING_MUXER_FAKE_H_
+
+// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_muxer.h"
+
+namespace perfetto {
+namespace internal {
+
+// An always-fail implementation of TracingMuxer. Before tracing has been
+// initialized, all muxer operations will route here and fail with a helpful
+// error message. This is to avoid introducing null checks in
+// performance-critical parts of the codebase.
+class TracingMuxerFake : public TracingMuxer {
+  class FakePlatform : public Platform {
+   public:
+    ~FakePlatform() override;
+    ThreadLocalObject* GetOrCreateThreadLocalObject() override;
+    std::unique_ptr<base::TaskRunner> CreateTaskRunner(
+        const CreateTaskRunnerArgs&) override;
+    std::string GetCurrentProcessName() override;
+
+    static FakePlatform instance;
+  };
+
+ public:
+  TracingMuxerFake() : TracingMuxer(&FakePlatform::instance) {}
+  ~TracingMuxerFake() override;
+
+  static constexpr TracingMuxerFake* Get() { return &instance; }
+
+  // TracingMuxer implementation.
+  bool RegisterDataSource(const DataSourceDescriptor&,
+                          DataSourceFactory,
+                          DataSourceParams,
+                          bool,
+                          DataSourceStaticState*) override;
+  void UpdateDataSourceDescriptor(const DataSourceDescriptor&,
+                                  const DataSourceStaticState*) override;
+  std::unique_ptr<TraceWriterBase> CreateTraceWriter(
+      DataSourceStaticState*,
+      uint32_t data_source_instance_index,
+      DataSourceState*,
+      BufferExhaustedPolicy buffer_exhausted_policy) override;
+  void DestroyStoppedTraceWritersForCurrentThread() override;
+  void RegisterInterceptor(const InterceptorDescriptor&,
+                           InterceptorFactory,
+                           InterceptorBase::TLSFactory,
+                           InterceptorBase::TracePacketCallback) override;
+  void ActivateTriggers(const std::vector<std::string>&, uint32_t) override;
+
+ private:
+  static TracingMuxerFake instance;
+};
+
+}  // namespace internal
+}  // namespace perfetto
+
+#endif  // SRC_TRACING_INTERNAL_TRACING_MUXER_FAKE_H_
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "src/tracing/internal/tracing_muxer_fake.h"
+
+namespace perfetto {
+namespace internal {
+namespace {
+
+PERFETTO_NORETURN void FailUninitialized() {
+  PERFETTO_FATAL(
+      "Tracing not initialized. Call perfetto::Tracing::Initialize() first.");
+}
+
+}  // namespace
+
+// static
+PERFETTO_NO_DESTROY TracingMuxerFake::FakePlatform
+    TracingMuxerFake::FakePlatform::instance{};
+// static
+PERFETTO_NO_DESTROY TracingMuxerFake TracingMuxerFake::instance{};
+
+TracingMuxerFake::~TracingMuxerFake() = default;
+
+TracingMuxerFake::FakePlatform::~FakePlatform() = default;
+
+Platform::ThreadLocalObject*
+TracingMuxerFake::FakePlatform::GetOrCreateThreadLocalObject() {
+  FailUninitialized();
+}
+
+std::unique_ptr<base::TaskRunner>
+TracingMuxerFake::FakePlatform::CreateTaskRunner(const CreateTaskRunnerArgs&) {
+  FailUninitialized();
+}
+
+std::string TracingMuxerFake::FakePlatform::GetCurrentProcessName() {
+  FailUninitialized();
+}
+
+bool TracingMuxerFake::RegisterDataSource(const DataSourceDescriptor&,
+                                          DataSourceFactory,
+                                          DataSourceParams,
+                                          bool,
+                                          DataSourceStaticState*) {
+  FailUninitialized();
+}
+
+void TracingMuxerFake::UpdateDataSourceDescriptor(
+    const DataSourceDescriptor&,
+    const DataSourceStaticState*) {
+  FailUninitialized();
+}
+
+std::unique_ptr<TraceWriterBase> TracingMuxerFake::CreateTraceWriter(
+    DataSourceStaticState*,
+    uint32_t,
+    DataSourceState*,
+    BufferExhaustedPolicy) {
+  FailUninitialized();
+}
+
+void TracingMuxerFake::DestroyStoppedTraceWritersForCurrentThread() {
+  FailUninitialized();
+}
+
+void TracingMuxerFake::RegisterInterceptor(
+    const InterceptorDescriptor&,
+    InterceptorFactory,
+    InterceptorBase::TLSFactory,
+    InterceptorBase::TracePacketCallback) {
+  FailUninitialized();
+}
+
+void TracingMuxerFake::ActivateTriggers(const std::vector<std::string>&,
+                                        uint32_t) {
+  FailUninitialized();
+}
+
+}  // namespace internal
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/internal/tracing_muxer_impl.cc
+// gen_amalgamated begin header: src/tracing/internal/tracing_muxer_impl.h
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SRC_TRACING_INTERNAL_TRACING_MUXER_IMPL_H_
+#define SRC_TRACING_INTERNAL_TRACING_MUXER_IMPL_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <array>
+#include <atomic>
+#include <bitset>
+#include <functional>
+#include <list>
+#include <map>
+#include <memory>
+#include <set>
+#include <utility>
+#include <vector>
+
+// gen_amalgamated expanded: #include "perfetto/base/time.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/thread_checker.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/consumer.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/producer.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/backend_type.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_descriptor.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/trace_config.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/basic_types.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_muxer.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/tracing.h"
+
+// gen_amalgamated expanded: #include "protos/perfetto/common/interceptor_descriptor.gen.h"
+
+namespace perfetto {
+
+class ConsumerEndpoint;
+class DataSourceBase;
+class ProducerEndpoint;
+class TraceWriterBase;
+class TracingBackend;
+class TracingSession;
+struct TracingInitArgs;
+
+namespace base {
+class TaskRunner;
+}
+
+namespace shlib {
+void ResetForTesting();
+}
+
+namespace test {
+class TracingMuxerImplInternalsForTest;
+}
+
+namespace internal {
+
+struct DataSourceStaticState;
+
+// This class acts as a bridge between the public API and the TracingBackend(s).
+// It exposes a simplified view of the world to the API methods handling all the
+// bookkeeping to map data source instances and trace writers to the various
+// backends. It deals with N data sources, M backends (1 backend == 1 tracing
+// service == 1 producer connection) and T concurrent tracing sessions.
+//
+// Handing data source registration and start/stop flows [producer side]:
+// ----------------------------------------------------------------------
+// 1. The API client subclasses perfetto::DataSource and calls
+//    DataSource::Register<MyDataSource>(). In turn this calls into the
+//    TracingMuxer.
+// 2. The tracing muxer iterates through all the backends (1 backend == 1
+//    service == 1 producer connection) and registers the data source on each
+//    backend.
+// 3. When any (services behind a) backend starts tracing and requests to start
+//    that specific data source, the TracingMuxerImpl constructs a new instance
+//    of MyDataSource and calls the OnStart() method.
+//
+// Controlling trace and retrieving trace data [consumer side]:
+// ------------------------------------------------------------
+// 1. The API client calls Tracing::NewTrace(), returns a RAII TracingSession
+//    object.
+// 2. NewTrace() calls into internal::TracingMuxer(Impl). TracingMuxer
+//    subclasses the TracingSession object (TracingSessionImpl) and returns it.
+// 3. The tracing muxer identifies the backend (according to the args passed to
+//    NewTrace), creates a new Consumer and connects to it.
+// 4. When the API client calls Start()/Stop()/ReadTrace() methods, the
+//    TracingMuxer forwards them to the consumer associated to the
+//    TracingSession. Likewise for callbacks coming from the consumer-side of
+//    the service.
+class TracingMuxerImpl : public TracingMuxer {
+ public:
+  // This is different than TracingSessionID because it's global across all
+  // backends. TracingSessionID is global only within the scope of one service.
+  using TracingSessionGlobalID = uint64_t;
+
+  struct RegisteredDataSource {
+    DataSourceDescriptor descriptor;
+    DataSourceFactory factory{};
+    DataSourceParams params;
+    bool no_flush = false;
+    DataSourceStaticState* static_state = nullptr;
+  };
+
+  static void InitializeInstance(const TracingInitArgs&);
+  static void ResetForTesting();
+  static void Shutdown();
+
+  // TracingMuxer implementation.
+  bool RegisterDataSource(const DataSourceDescriptor&,
+                          DataSourceFactory,
+                          DataSourceParams,
+                          bool no_flush,
+                          DataSourceStaticState*) override;
+  void UpdateDataSourceDescriptor(const DataSourceDescriptor&,
+                                  const DataSourceStaticState*) override;
+  std::unique_ptr<TraceWriterBase> CreateTraceWriter(
+      DataSourceStaticState*,
+      uint32_t data_source_instance_index,
+      DataSourceState*,
+      BufferExhaustedPolicy buffer_exhausted_policy) override;
+  void DestroyStoppedTraceWritersForCurrentThread() override;
+  void RegisterInterceptor(const InterceptorDescriptor&,
+                           InterceptorFactory,
+                           InterceptorBase::TLSFactory,
+                           InterceptorBase::TracePacketCallback) override;
+
+  void ActivateTriggers(const std::vector<std::string>&, uint32_t) override;
+
+  std::unique_ptr<TracingSession> CreateTracingSession(
+      BackendType,
+      TracingConsumerBackend* (*system_backend_factory)());
+  std::unique_ptr<StartupTracingSession> CreateStartupTracingSession(
+      const TraceConfig& config,
+      Tracing::SetupStartupTracingOpts);
+  std::unique_ptr<StartupTracingSession> CreateStartupTracingSessionBlocking(
+      const TraceConfig& config,
+      Tracing::SetupStartupTracingOpts);
+
+  // Producer-side bookkeeping methods.
+  void UpdateDataSourcesOnAllBackends();
+  void SetupDataSource(TracingBackendId,
+                       uint32_t backend_connection_id,
+                       DataSourceInstanceID,
+                       const DataSourceConfig&);
+  void StartDataSource(TracingBackendId, DataSourceInstanceID);
+  void StopDataSource_AsyncBegin(TracingBackendId, DataSourceInstanceID);
+  void ClearDataSourceIncrementalState(TracingBackendId, DataSourceInstanceID);
+  void SyncProducersForTesting();
+
+  // Consumer-side bookkeeping methods.
+  void SetupTracingSession(TracingSessionGlobalID,
+                           const std::shared_ptr<TraceConfig>&,
+                           base::ScopedFile trace_fd = base::ScopedFile());
+  void StartTracingSession(TracingSessionGlobalID);
+  void CloneTracingSession(TracingSessionGlobalID,
+                           TracingSession::CloneTraceArgs,
+                           TracingSession::CloneTraceCallback);
+  void ChangeTracingSessionConfig(TracingSessionGlobalID, const TraceConfig&);
+  void StopTracingSession(TracingSessionGlobalID);
+  void DestroyTracingSession(TracingSessionGlobalID);
+  void FlushTracingSession(TracingSessionGlobalID,
+                           uint32_t,
+                           std::function<void(bool)>);
+  void ReadTracingSessionData(
+      TracingSessionGlobalID,
+      std::function<void(TracingSession::ReadTraceCallbackArgs)>);
+  void GetTraceStats(TracingSessionGlobalID,
+                     TracingSession::GetTraceStatsCallback);
+  void QueryServiceState(TracingSessionGlobalID,
+                         TracingSession::QueryServiceStateCallback);
+
+  // Sets the batching period to |batch_commits_duration_ms| on the backends
+  // with type |backend_type|.
+  void SetBatchCommitsDurationForTesting(uint32_t batch_commits_duration_ms,
+                                         BackendType backend_type);
+
+  // Enables direct SMB patching on the backends with type |backend_type| (see
+  // SharedMemoryArbiter::EnableDirectSMBPatching). Returns true if the
+  // operation succeeded for all backends with type |backend_type|, false
+  // otherwise.
+  bool EnableDirectSMBPatchingForTesting(BackendType backend_type);
+
+  void SetMaxProducerReconnectionsForTesting(uint32_t count);
+
+ private:
+  friend class test::TracingMuxerImplInternalsForTest;
+  friend void shlib::ResetForTesting();
+
+  // For each TracingBackend we create and register one ProducerImpl instance.
+  // This talks to the producer-side of the service, gets start/stop requests
+  // from it and routes them to the registered data sources.
+  // One ProducerImpl == one backend == one tracing service.
+  // This class is needed to disambiguate callbacks coming from different
+  // services. TracingMuxerImpl can't directly implement the Producer interface
+  // because the Producer virtual methods don't allow to identify the service.
+  class ProducerImpl : public Producer {
+   public:
+    ProducerImpl(TracingMuxerImpl*,
+                 TracingBackendId,
+                 uint32_t shmem_batch_commits_duration_ms,
+                 bool shmem_direct_patching_enabled);
+    ~ProducerImpl() override;
+
+    void Initialize(std::unique_ptr<ProducerEndpoint> endpoint);
+    void RegisterDataSource(const DataSourceDescriptor&,
+                            DataSourceFactory,
+                            DataSourceStaticState*);
+    void DisposeConnection();
+
+    // perfetto::Producer implementation.
+    void OnConnect() override;
+    void OnDisconnect() override;
+    void OnTracingSetup() override;
+    void OnStartupTracingSetup() override;
+    void SetupDataSource(DataSourceInstanceID,
+                         const DataSourceConfig&) override;
+    void StartDataSource(DataSourceInstanceID,
+                         const DataSourceConfig&) override;
+    void StopDataSource(DataSourceInstanceID) override;
+    void Flush(FlushRequestID,
+               const DataSourceInstanceID*,
+               size_t,
+               FlushFlags) override;
+    void ClearIncrementalState(const DataSourceInstanceID*, size_t) override;
+
+    bool SweepDeadServices();
+    void SendOnConnectTriggers();
+    void NotifyFlushForDataSourceDone(DataSourceInstanceID, FlushRequestID);
+
+    PERFETTO_THREAD_CHECKER(thread_checker_)
+    TracingMuxerImpl* muxer_;
+    TracingBackendId const backend_id_;
+    bool connected_ = false;
+    bool did_setup_tracing_ = false;
+    bool did_setup_startup_tracing_ = false;
+    std::atomic<uint32_t> connection_id_{0};
+    uint16_t last_startup_target_buffer_reservation_ = 0;
+    bool is_producer_provided_smb_ = false;
+    bool producer_provided_smb_failed_ = false;
+
+    const uint32_t shmem_batch_commits_duration_ms_ = 0;
+    const bool shmem_direct_patching_enabled_ = false;
+
+    // Set of data sources that have been actually registered on this producer.
+    // This can be a subset of the global |data_sources_|, because data sources
+    // can register before the producer is fully connected.
+    std::bitset<kMaxDataSources> registered_data_sources_{};
+
+    // A collection of disconnected service endpoints. Since trace writers on
+    // arbitrary threads might continue writing data to disconnected services,
+    // we keep the old services around and periodically try to clean up ones
+    // that no longer have any writers (see SweepDeadServices).
+    std::list<std::shared_ptr<ProducerEndpoint>> dead_services_;
+
+    // Triggers that should be sent when the service connects (trigger_name,
+    // expiration).
+    std::list<std::pair<std::string, base::TimeMillis>> on_connect_triggers_;
+
+    std::map<FlushRequestID, std::set<DataSourceInstanceID>> pending_flushes_;
+
+    // The currently active service endpoint is maintained as an atomic shared
+    // pointer so it won't get deleted from underneath threads that are creating
+    // trace writers. At any given time one endpoint can be shared (and thus
+    // kept alive) by the |service_| pointer, an entry in |dead_services_| and
+    // as a pointer on the stack in CreateTraceWriter() (on an arbitrary
+    // thread). The endpoint is never shared outside ProducerImpl itself.
+    //
+    // WARNING: Any *write* access to this variable or any *read* access from a
+    // non-muxer thread must be done through std::atomic_{load,store} to avoid
+    // data races.
+    std::shared_ptr<ProducerEndpoint> service_;  // Keep last.
+  };
+
+  // For each TracingSession created by the API client (Tracing::NewTrace() we
+  // create and register one ConsumerImpl instance.
+  // This talks to the consumer-side of the service, gets end-of-trace and
+  // on-trace-data callbacks and routes them to the API client callbacks.
+  // This class is needed to disambiguate callbacks coming from different
+  // tracing sessions.
+  class ConsumerImpl : public Consumer {
+   public:
+    ConsumerImpl(TracingMuxerImpl*, BackendType, TracingSessionGlobalID);
+    ~ConsumerImpl() override;
+
+    void Initialize(std::unique_ptr<ConsumerEndpoint> endpoint);
+
+    // perfetto::Consumer implementation.
+    void OnConnect() override;
+    void OnDisconnect() override;
+    void OnTracingDisabled(const std::string& error) override;
+    void OnTraceData(std::vector<TracePacket>, bool has_more) override;
+    void OnDetach(bool success) override;
+    void OnAttach(bool success, const TraceConfig&) override;
+    void OnTraceStats(bool success, const TraceStats&) override;
+    void OnObservableEvents(const ObservableEvents&) override;
+    void OnSessionCloned(const OnSessionClonedArgs&) override;
+
+    void NotifyStartComplete();
+    void NotifyError(const TracingError&);
+    void NotifyStopComplete();
+
+    // Will eventually inform the |muxer_| when it is safe to remove |this|.
+    void Disconnect();
+
+    TracingMuxerImpl* muxer_;
+    BackendType const backend_type_;
+    TracingSessionGlobalID const session_id_;
+    bool connected_ = false;
+
+    // This is to handle the case where the Setup call from the API client
+    // arrives before the consumer has connected. In this case we keep around
+    // the config and check if we have it after connection.
+    bool start_pending_ = false;
+
+    // Similarly if the session is stopped before the consumer was connected, we
+    // need to wait until the session has started before stopping it.
+    bool stop_pending_ = false;
+
+    // Similarly we need to buffer a call to get trace statistics if the
+    // consumer wasn't connected yet.
+    bool get_trace_stats_pending_ = false;
+
+    // Similarly we need to buffer a session cloning args if the session is
+    // cloning another sesison before the consumer was connected.
+    std::optional<ConsumerEndpoint::CloneSessionArgs> session_to_clone_;
+
+    // Whether this session was already stopped. This will happen in response to
+    // Stop{,Blocking}, but also if the service stops the session for us
+    // automatically (e.g., when there are no data sources).
+    bool stopped_ = false;
+
+    // shared_ptr because it's posted across threads. This is to avoid copying
+    // it more than once.
+    std::shared_ptr<TraceConfig> trace_config_;
+    base::ScopedFile trace_fd_;
+
+    // If the API client passes a callback to start, we should invoke this when
+    // NotifyStartComplete() is invoked.
+    std::function<void()> start_complete_callback_;
+
+    // An internal callback used to implement StartBlocking().
+    std::function<void()> blocking_start_complete_callback_;
+
+    // If the API client passes a callback to get notification about the
+    // errors, we should invoke this when NotifyError() is invoked.
+    std::function<void(TracingError)> error_callback_;
+
+    // If the API client passes a callback to stop, we should invoke this when
+    // OnTracingDisabled() is invoked.
+    std::function<void()> stop_complete_callback_;
+
+    // An internal callback used to implement StopBlocking().
+    std::function<void()> blocking_stop_complete_callback_;
+
+    // Callback for a pending call to CloneTrace().
+    TracingSession::CloneTraceCallback clone_trace_callback_;
+
+    // Callback passed to ReadTrace().
+    std::function<void(TracingSession::ReadTraceCallbackArgs)>
+        read_trace_callback_;
+
+    // Callback passed to GetTraceStats().
+    TracingSession::GetTraceStatsCallback get_trace_stats_callback_;
+
+    // Callback for a pending call to QueryServiceState().
+    TracingSession::QueryServiceStateCallback query_service_state_callback_;
+
+    // The states of all data sources in this tracing session. |true| means the
+    // data source has started tracing.
+    using DataSourceHandle = std::pair<std::string, std::string>;
+    std::map<DataSourceHandle, bool> data_source_states_;
+
+    std::unique_ptr<ConsumerEndpoint> service_;  // Keep before last.
+    PERFETTO_THREAD_CHECKER(thread_checker_)     // Keep last.
+  };
+
+  // This object is returned to API clients when they call
+  // Tracing::CreateTracingSession().
+  class TracingSessionImpl : public TracingSession {
+   public:
+    TracingSessionImpl(TracingMuxerImpl*, TracingSessionGlobalID, BackendType);
+    ~TracingSessionImpl() override;
+    void Setup(const TraceConfig&, int fd) override;
+    void Start() override;
+    void StartBlocking() override;
+    void CloneTrace(CloneTraceArgs args, CloneTraceCallback) override;
+    void SetOnStartCallback(std::function<void()>) override;
+    void SetOnErrorCallback(std::function<void(TracingError)>) override;
+    void Stop() override;
+    void StopBlocking() override;
+    void Flush(std::function<void(bool)>, uint32_t timeout_ms) override;
+    void ReadTrace(ReadTraceCallback) override;
+    void SetOnStopCallback(std::function<void()>) override;
+    void GetTraceStats(GetTraceStatsCallback) override;
+    void QueryServiceState(QueryServiceStateCallback) override;
+    void ChangeTraceConfig(const TraceConfig&) override;
+
+   private:
+    TracingMuxerImpl* const muxer_;
+    TracingSessionGlobalID const session_id_;
+    BackendType const backend_type_;
+  };
+
+  // This object is returned to API clients when they call
+  // Tracing::SetupStartupTracing().
+  class StartupTracingSessionImpl : public StartupTracingSession {
+   public:
+    StartupTracingSessionImpl(TracingMuxerImpl*,
+                              TracingSessionGlobalID,
+                              BackendType);
+    ~StartupTracingSessionImpl() override;
+    void Abort() override;
+    void AbortBlocking() override;
+
+   private:
+    TracingMuxerImpl* const muxer_;
+    TracingSessionGlobalID const session_id_;
+    BackendType backend_type_;
+  };
+
+  struct RegisteredInterceptor {
+    protos::gen::InterceptorDescriptor descriptor;
+    InterceptorFactory factory{};
+    InterceptorBase::TLSFactory tls_factory{};
+    InterceptorBase::TracePacketCallback packet_callback{};
+  };
+
+  struct RegisteredStartupSession {
+    TracingSessionID session_id = 0;
+    int num_unbound_data_sources = 0;
+
+    bool is_aborting = false;
+    int num_aborting_data_sources = 0;
+
+    std::function<void()> on_aborted;
+    std::function<void()> on_adopted;
+  };
+
+  struct RegisteredProducerBackend {
+    // Backends are supposed to have static lifetime.
+    TracingProducerBackend* backend = nullptr;
+    TracingBackendId id = 0;
+    BackendType type{};
+
+    TracingBackend::ConnectProducerArgs producer_conn_args;
+    std::unique_ptr<ProducerImpl> producer;
+
+    std::vector<RegisteredStartupSession> startup_sessions;
+  };
+
+  struct RegisteredConsumerBackend {
+    // Backends are supposed to have static lifetime.
+    TracingConsumerBackend* backend = nullptr;
+    BackendType type{};
+    // The calling code can request more than one concurrently active tracing
+    // session for the same backend. We need to create one consumer per session.
+    std::vector<std::unique_ptr<ConsumerImpl>> consumers;
+  };
+
+  void UpdateDataSourceOnAllBackends(RegisteredDataSource& rds,
+                                     bool is_changed);
+  explicit TracingMuxerImpl(const TracingInitArgs&);
+  void Initialize(const TracingInitArgs& args);
+  void AddBackends(const TracingInitArgs& args);
+  void AddConsumerBackend(TracingConsumerBackend* backend, BackendType type);
+  void AddProducerBackend(TracingProducerBackend* backend,
+                          BackendType type,
+                          const TracingInitArgs& args);
+  ConsumerImpl* FindConsumer(TracingSessionGlobalID session_id);
+  std::pair<ConsumerImpl*, RegisteredConsumerBackend*> FindConsumerAndBackend(
+      TracingSessionGlobalID session_id);
+  RegisteredProducerBackend* FindProducerBackendById(TracingBackendId id);
+  RegisteredProducerBackend* FindProducerBackendByType(BackendType type);
+  RegisteredConsumerBackend* FindConsumerBackendByType(BackendType type);
+  void InitializeConsumer(TracingSessionGlobalID session_id);
+  void OnConsumerDisconnected(ConsumerImpl* consumer);
+  void OnProducerDisconnected(ProducerImpl* producer);
+  // Test only method.
+  void SweepDeadBackends();
+
+  struct FindDataSourceRes {
+    FindDataSourceRes() = default;
+    FindDataSourceRes(DataSourceStaticState* a,
+                      DataSourceState* b,
+                      uint32_t c,
+                      bool d)
+        : static_state(a),
+          internal_state(b),
+          instance_idx(c),
+          requires_callbacks_under_lock(d) {}
+    explicit operator bool() const { return !!internal_state; }
+
+    DataSourceStaticState* static_state = nullptr;
+    DataSourceState* internal_state = nullptr;
+    uint32_t instance_idx = 0;
+    bool requires_callbacks_under_lock = false;
+  };
+  FindDataSourceRes FindDataSource(TracingBackendId, DataSourceInstanceID);
+
+  FindDataSourceRes SetupDataSourceImpl(
+      const RegisteredDataSource&,
+      TracingBackendId,
+      uint32_t backend_connection_id,
+      DataSourceInstanceID,
+      const DataSourceConfig&,
+      TracingSessionGlobalID startup_session_id);
+  void StartDataSourceImpl(const FindDataSourceRes&);
+  void StopDataSource_AsyncBeginImpl(const FindDataSourceRes&);
+  void StopDataSource_AsyncEnd(TracingBackendId,
+                               uint32_t backend_connection_id,
+                               DataSourceInstanceID,
+                               const FindDataSourceRes&);
+  bool FlushDataSource_AsyncBegin(TracingBackendId,
+                                  DataSourceInstanceID,
+                                  FlushRequestID,
+                                  FlushFlags);
+  void FlushDataSource_AsyncEnd(TracingBackendId,
+                                uint32_t backend_connection_id,
+                                DataSourceInstanceID,
+                                const FindDataSourceRes&,
+                                FlushRequestID);
+  void AbortStartupTracingSession(TracingSessionGlobalID, BackendType);
+  // When ResetForTesting() is executed, `cb` will be called on the calling
+  // thread and on the muxer thread.
+  void AppendResetForTestingCallback(std::function<void()> cb);
+
+  // WARNING: If you add new state here, be sure to update ResetForTesting.
+  std::unique_ptr<base::TaskRunner> task_runner_;
+  std::vector<RegisteredDataSource> data_sources_;
+  // These lists can only have one backend per BackendType. The elements are
+  // sorted by BackendType priority (see BackendTypePriority). They always
+  // contain a fake low-priority kUnspecifiedBackend at the end.
+  std::list<RegisteredProducerBackend> producer_backends_;
+  std::list<RegisteredConsumerBackend> consumer_backends_;
+  std::vector<RegisteredInterceptor> interceptors_;
+  TracingPolicy* policy_ = nullptr;
+
+  // Learn more at TracingInitArgs::supports_multiple_data_source_instances
+  bool supports_multiple_data_source_instances_ = true;
+
+  std::atomic<TracingSessionGlobalID> next_tracing_session_id_{};
+  std::atomic<uint32_t> next_data_source_index_{};
+  uint32_t muxer_id_for_testing_{};
+
+  // Maximum number of times we will try to reconnect producer backend.
+  // Should only be modified for testing purposes.
+  std::atomic<uint32_t> max_producer_reconnections_{100u};
+
+  // Test only member.
+  // After ResetForTesting() is called, holds tracing backends which needs to be
+  // kept alive until all inbound references have gone away. See
+  // SweepDeadBackends().
+  std::list<RegisteredProducerBackend> dead_backends_;
+
+  // Test only member.
+  // Executes these cleanup functions on the calling thread and on the muxer
+  // thread when ResetForTesting() is called.
+  std::list<std::function<void()>> reset_callbacks_;
+
+  PERFETTO_THREAD_CHECKER(thread_checker_)
+};
+
+}  // namespace internal
+}  // namespace perfetto
+
+#endif  // SRC_TRACING_INTERNAL_TRACING_MUXER_IMPL_H_
+// gen_amalgamated begin header: include/perfetto/ext/tracing/core/trace_stats.h
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACE_STATS_H_
+#define INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACE_STATS_H_
+
+// Creates the aliases in the ::perfetto namespace, doing things like:
+// using ::perfetto::Foo = ::perfetto::protos::gen::Foo.
+// See comments in forward_decls.h for the historical reasons of this
+// indirection layer.
+// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
+
+// gen_amalgamated expanded: #include "protos/perfetto/common/trace_stats.gen.h"
+
+#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACE_STATS_H_
+// gen_amalgamated begin header: include/perfetto/tracing/core/tracing_service_state.h
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_TRACING_CORE_TRACING_SERVICE_STATE_H_
+#define INCLUDE_PERFETTO_TRACING_CORE_TRACING_SERVICE_STATE_H_
+
+// Creates the aliases in the ::perfetto namespace, doing things like:
+// using ::perfetto::Foo = ::perfetto::protos::gen::Foo.
+// See comments in forward_decls.h for the historical reasons of this
+// indirection layer.
+// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
+
+// gen_amalgamated expanded: #include "protos/perfetto/common/tracing_service_state.gen.h"
+
+#endif  // INCLUDE_PERFETTO_TRACING_CORE_TRACING_SERVICE_STATE_H_
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "src/tracing/internal/tracing_muxer_impl.h"
+
+#include <algorithm>
+#include <atomic>
+#include <mutex>
+#include <optional>
+#include <vector>
+
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
+// gen_amalgamated expanded: #include "perfetto/base/time.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/fnv_hash.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/thread_checker.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/waitable_event.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_arbiter.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_packet.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_stats.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_writer.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/buffer_exhausted_policy.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_config.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/tracing_service_state.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/data_source.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/data_source_internal.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/interceptor_trace_writer.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_backend_fake.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/trace_writer_base.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/tracing.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/tracing_backend.h"
+// gen_amalgamated expanded: #include "src/tracing/core/null_trace_writer.h"
+// gen_amalgamated expanded: #include "src/tracing/internal/tracing_muxer_fake.h"
+
+// gen_amalgamated expanded: #include "protos/perfetto/config/interceptor_config.gen.h"
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+#include <io.h>  // For dup()
+#else
+#include <unistd.h>  // For dup()
+#endif
+
+namespace perfetto {
+namespace internal {
+
+namespace {
+
+using RegisteredDataSource = TracingMuxerImpl::RegisteredDataSource;
+
+// A task runner which prevents calls to DataSource::Trace() while an operation
+// is in progress. Used to guard against unexpected re-entrancy where the
+// user-provided task runner implementation tries to enter a trace point under
+// the hood.
+class NonReentrantTaskRunner : public base::TaskRunner {
+ public:
+  NonReentrantTaskRunner(TracingMuxer* muxer,
+                         std::unique_ptr<base::TaskRunner> task_runner)
+      : muxer_(muxer), task_runner_(std::move(task_runner)) {}
+
+  // base::TaskRunner implementation.
+  void PostTask(std::function<void()> task) override {
+    CallWithGuard([&] { task_runner_->PostTask(std::move(task)); });
+  }
+
+  void PostDelayedTask(std::function<void()> task, uint32_t delay_ms) override {
+    CallWithGuard(
+        [&] { task_runner_->PostDelayedTask(std::move(task), delay_ms); });
+  }
+
+  void AddFileDescriptorWatch(base::PlatformHandle fd,
+                              std::function<void()> callback) override {
+    CallWithGuard(
+        [&] { task_runner_->AddFileDescriptorWatch(fd, std::move(callback)); });
+  }
+
+  void RemoveFileDescriptorWatch(base::PlatformHandle fd) override {
+    CallWithGuard([&] { task_runner_->RemoveFileDescriptorWatch(fd); });
+  }
+
+  bool RunsTasksOnCurrentThread() const override {
+    bool result;
+    CallWithGuard([&] { result = task_runner_->RunsTasksOnCurrentThread(); });
+    return result;
+  }
+
+ private:
+  template <typename T>
+  void CallWithGuard(T lambda) const {
+    auto* root_tls = muxer_->GetOrCreateTracingTLS();
+    if (PERFETTO_UNLIKELY(root_tls->is_in_trace_point)) {
+      lambda();
+      return;
+    }
+    ScopedReentrancyAnnotator scoped_annotator(*root_tls);
+    lambda();
+  }
+
+  TracingMuxer* const muxer_;
+  std::unique_ptr<base::TaskRunner> task_runner_;
+};
+
+class StopArgsImpl : public DataSourceBase::StopArgs {
+ public:
+  std::function<void()> HandleStopAsynchronously() const override {
+    auto closure = std::move(async_stop_closure);
+    async_stop_closure = std::function<void()>();
+    return closure;
+  }
+
+  mutable std::function<void()> async_stop_closure;
+};
+
+class FlushArgsImpl : public DataSourceBase::FlushArgs {
+ public:
+  std::function<void()> HandleFlushAsynchronously() const override {
+    auto closure = std::move(async_flush_closure);
+    async_flush_closure = std::function<void()>();
+    return closure;
+  }
+
+  mutable std::function<void()> async_flush_closure;
+};
+
+// Holds an earlier TracingMuxerImpl instance after ResetForTesting() is called.
+static TracingMuxerImpl* g_prev_instance{};
+
+template <typename RegisteredBackend>
+struct CompareBackendByType {
+  static int BackendTypePriority(BackendType type) {
+    switch (type) {
+      case kSystemBackend:
+        return 0;
+      case kInProcessBackend:
+        return 1;
+      case kCustomBackend:
+        return 2;
+      // The UnspecifiedBackend has the highest priority so that
+      // TracingBackendFake is the last one on the backend lists.
+      case kUnspecifiedBackend:
+        break;
+    }
+    return 3;
+  }
+  bool operator()(BackendType type, const RegisteredBackend& b) {
+    return BackendTypePriority(type) < BackendTypePriority(b.type);
+  }
+};
+
+BufferExhaustedPolicy ComputeBufferExhaustedPolicy(
+    const DataSourceConfig& cfg,
+    const DataSourceParams& params) {
+  if (!params.buffer_exhausted_policy_configurable) {
+    return params.default_buffer_exhausted_policy;
+  }
+
+  switch (cfg.buffer_exhausted_policy()) {
+    case DataSourceConfig::BUFFER_EXHAUSTED_UNSPECIFIED:
+      return params.default_buffer_exhausted_policy;
+    case DataSourceConfig::BUFFER_EXHAUSTED_DROP:
+      return BufferExhaustedPolicy::kDrop;
+    case DataSourceConfig::BUFFER_EXHAUSTED_STALL_THEN_ABORT:
+      return BufferExhaustedPolicy::kStall;
+    case DataSourceConfig::BUFFER_EXHAUSTED_STALL_THEN_DROP:
+      return BufferExhaustedPolicy::kStallThenDrop;
+  }
+
+  return params.default_buffer_exhausted_policy;
+}
+
+}  // namespace
+
+// ----- Begin of TracingMuxerImpl::ProducerImpl
+TracingMuxerImpl::ProducerImpl::ProducerImpl(
+    TracingMuxerImpl* muxer,
+    TracingBackendId backend_id,
+    uint32_t shmem_batch_commits_duration_ms,
+    bool shmem_direct_patching_enabled)
+    : muxer_(muxer),
+      backend_id_(backend_id),
+      shmem_batch_commits_duration_ms_(shmem_batch_commits_duration_ms),
+      shmem_direct_patching_enabled_(shmem_direct_patching_enabled) {}
+
+TracingMuxerImpl::ProducerImpl::~ProducerImpl() {
+  muxer_ = nullptr;
+}
+
+void TracingMuxerImpl::ProducerImpl::Initialize(
+    std::unique_ptr<ProducerEndpoint> endpoint) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  PERFETTO_DCHECK(!connected_);
+  connection_id_.fetch_add(1, std::memory_order_relaxed);
+  is_producer_provided_smb_ = endpoint->shared_memory();
+  last_startup_target_buffer_reservation_ = 0;
+
+  // Adopt the endpoint into a shared pointer so that we can safely share it
+  // across threads that create trace writers. The custom deleter function
+  // ensures that the endpoint is always destroyed on the muxer's thread. (Note
+  // that |task_runner| is assumed to outlive tracing sessions on all threads.)
+  auto* task_runner = muxer_->task_runner_.get();
+  auto deleter = [task_runner](ProducerEndpoint* e) {
+    if (task_runner->RunsTasksOnCurrentThread()) {
+      delete e;
+      return;
+    }
+    task_runner->PostTask([e] { delete e; });
+  };
+  std::shared_ptr<ProducerEndpoint> service(endpoint.release(), deleter);
+  // This atomic store is needed because another thread might be concurrently
+  // creating a trace writer using the previous (disconnected) |service_|. See
+  // CreateTraceWriter().
+  std::atomic_store(&service_, std::move(service));
+  // Don't try to use the service here since it may not have connected yet. See
+  // OnConnect().
+}
+
+void TracingMuxerImpl::ProducerImpl::OnConnect() {
+  PERFETTO_DLOG("Producer connected");
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  PERFETTO_DCHECK(!connected_);
+  if (is_producer_provided_smb_ && !service_->IsShmemProvidedByProducer()) {
+    PERFETTO_ELOG(
+        "The service likely doesn't support producer-provided SMBs. Preventing "
+        "future attempts to use producer-provided SMB again with this "
+        "backend.");
+    producer_provided_smb_failed_ = true;
+    // Will call OnDisconnect() and cause a reconnect without producer-provided
+    // SMB.
+    service_->Disconnect();
+    return;
+  }
+  connected_ = true;
+  muxer_->UpdateDataSourcesOnAllBackends();
+  SendOnConnectTriggers();
+}
+
+void TracingMuxerImpl::ProducerImpl::OnDisconnect() {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  // If we're being destroyed, bail out.
+  if (!muxer_)
+    return;
+  connected_ = false;
+  // Active data sources for this producer will be stopped by
+  // DestroyStoppedTraceWritersForCurrentThread() since the reconnected producer
+  // will have a different connection id (even before it has finished
+  // connecting).
+  registered_data_sources_.reset();
+  DisposeConnection();
+
+  // Try reconnecting the producer.
+  muxer_->OnProducerDisconnected(this);
+}
+
+void TracingMuxerImpl::ProducerImpl::DisposeConnection() {
+  // Keep the old service around as a dead connection in case it has active
+  // trace writers. If any tracing sessions were created, we can't clear
+  // |service_| here because other threads may be concurrently creating new
+  // trace writers. Any reconnection attempt will atomically swap the new
+  // service in place of the old one.
+  if (did_setup_tracing_ || did_setup_startup_tracing_) {
+    dead_services_.push_back(service_);
+  } else {
+    service_.reset();
+  }
+}
+
+void TracingMuxerImpl::ProducerImpl::OnTracingSetup() {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  did_setup_tracing_ = true;
+  service_->MaybeSharedMemoryArbiter()->SetBatchCommitsDuration(
+      shmem_batch_commits_duration_ms_);
+  if (shmem_direct_patching_enabled_) {
+    service_->MaybeSharedMemoryArbiter()->EnableDirectSMBPatching();
+  }
+}
+
+void TracingMuxerImpl::ProducerImpl::OnStartupTracingSetup() {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  did_setup_startup_tracing_ = true;
+}
+
+void TracingMuxerImpl::ProducerImpl::SetupDataSource(
+    DataSourceInstanceID id,
+    const DataSourceConfig& cfg) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  if (!muxer_)
+    return;
+  muxer_->SetupDataSource(
+      backend_id_, connection_id_.load(std::memory_order_relaxed), id, cfg);
+}
+
+void TracingMuxerImpl::ProducerImpl::StartDataSource(DataSourceInstanceID id,
+                                                     const DataSourceConfig&) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  if (!muxer_)
+    return;
+  muxer_->StartDataSource(backend_id_, id);
+  service_->NotifyDataSourceStarted(id);
+}
+
+void TracingMuxerImpl::ProducerImpl::StopDataSource(DataSourceInstanceID id) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  if (!muxer_)
+    return;
+  muxer_->StopDataSource_AsyncBegin(backend_id_, id);
+}
+
+void TracingMuxerImpl::ProducerImpl::Flush(
+    FlushRequestID flush_id,
+    const DataSourceInstanceID* instances,
+    size_t instance_count,
+    FlushFlags flush_flags) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  bool all_handled = true;
+  if (muxer_) {
+    for (size_t i = 0; i < instance_count; i++) {
+      DataSourceInstanceID ds_id = instances[i];
+      bool handled = muxer_->FlushDataSource_AsyncBegin(backend_id_, ds_id,
+                                                        flush_id, flush_flags);
+      if (!handled) {
+        pending_flushes_[flush_id].insert(ds_id);
+        all_handled = false;
+      }
+    }
+  }
+
+  if (all_handled) {
+    service_->NotifyFlushComplete(flush_id);
+  }
+}
+
+void TracingMuxerImpl::ProducerImpl::ClearIncrementalState(
+    const DataSourceInstanceID* instances,
+    size_t instance_count) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  if (!muxer_)
+    return;
+  for (size_t inst_idx = 0; inst_idx < instance_count; inst_idx++) {
+    muxer_->ClearDataSourceIncrementalState(backend_id_, instances[inst_idx]);
+  }
+}
+
+bool TracingMuxerImpl::ProducerImpl::SweepDeadServices() {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  auto is_unused = [](const std::shared_ptr<ProducerEndpoint>& endpoint) {
+    auto* arbiter = endpoint->MaybeSharedMemoryArbiter();
+    return !arbiter || arbiter->TryShutdown();
+  };
+  for (auto it = dead_services_.begin(); it != dead_services_.end();) {
+    auto next_it = it;
+    next_it++;
+    if (is_unused(*it)) {
+      dead_services_.erase(it);
+    }
+    it = next_it;
+  }
+  return dead_services_.empty();
+}
+
+void TracingMuxerImpl::ProducerImpl::SendOnConnectTriggers() {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  base::TimeMillis now = base::GetWallTimeMs();
+  std::vector<std::string> triggers;
+  while (!on_connect_triggers_.empty()) {
+    // Skip if we passed TTL.
+    if (on_connect_triggers_.front().second > now) {
+      triggers.push_back(std::move(on_connect_triggers_.front().first));
+    }
+    on_connect_triggers_.pop_front();
+  }
+  if (!triggers.empty()) {
+    service_->ActivateTriggers(triggers);
+  }
+}
+
+void TracingMuxerImpl::ProducerImpl::NotifyFlushForDataSourceDone(
+    DataSourceInstanceID ds_id,
+    FlushRequestID flush_id) {
+  if (!connected_) {
+    return;
+  }
+
+  {
+    auto it = pending_flushes_.find(flush_id);
+    if (it == pending_flushes_.end()) {
+      return;
+    }
+    std::set<DataSourceInstanceID>& ds_ids = it->second;
+    ds_ids.erase(ds_id);
+  }
+
+  std::optional<DataSourceInstanceID> biggest_flush_id;
+  for (auto it = pending_flushes_.begin(); it != pending_flushes_.end();) {
+    if (it->second.empty()) {
+      biggest_flush_id = it->first;
+      it = pending_flushes_.erase(it);
+    } else {
+      break;
+    }
+  }
+
+  if (biggest_flush_id) {
+    service_->NotifyFlushComplete(*biggest_flush_id);
+  }
+}
+
+// ----- End of TracingMuxerImpl::ProducerImpl methods.
+
+// ----- Begin of TracingMuxerImpl::ConsumerImpl
+TracingMuxerImpl::ConsumerImpl::ConsumerImpl(TracingMuxerImpl* muxer,
+                                             BackendType backend_type,
+                                             TracingSessionGlobalID session_id)
+    : muxer_(muxer), backend_type_(backend_type), session_id_(session_id) {}
+
+TracingMuxerImpl::ConsumerImpl::~ConsumerImpl() {
+  muxer_ = nullptr;
+}
+
+void TracingMuxerImpl::ConsumerImpl::Initialize(
+    std::unique_ptr<ConsumerEndpoint> endpoint) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  service_ = std::move(endpoint);
+  // Don't try to use the service here since it may not have connected yet. See
+  // OnConnect().
+}
+
+void TracingMuxerImpl::ConsumerImpl::OnConnect() {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  PERFETTO_DCHECK(!connected_);
+  connected_ = true;
+
+  // Observe data source instance events so we get notified when tracing starts.
+  service_->ObserveEvents(ObservableEvents::TYPE_DATA_SOURCES_INSTANCES |
+                          ObservableEvents::TYPE_ALL_DATA_SOURCES_STARTED);
+
+  // If the API client configured and started tracing before we connected,
+  // tell the backend about it now.
+  if (trace_config_)
+    muxer_->SetupTracingSession(session_id_, trace_config_);
+  if (start_pending_)
+    muxer_->StartTracingSession(session_id_);
+  if (get_trace_stats_pending_) {
+    auto callback = std::move(get_trace_stats_callback_);
+    get_trace_stats_callback_ = nullptr;
+    muxer_->GetTraceStats(session_id_, std::move(callback));
+  }
+  if (query_service_state_callback_) {
+    auto callback = std::move(query_service_state_callback_);
+    query_service_state_callback_ = nullptr;
+    muxer_->QueryServiceState(session_id_, std::move(callback));
+  }
+  if (session_to_clone_) {
+    service_->CloneSession(std::move(*session_to_clone_));
+    session_to_clone_ = std::nullopt;
+  }
+
+  if (stop_pending_)
+    muxer_->StopTracingSession(session_id_);
+}
+
+void TracingMuxerImpl::ConsumerImpl::OnDisconnect() {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  // If we're being destroyed, bail out.
+  if (!muxer_)
+    return;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+  if (!connected_ && backend_type_ == kSystemBackend) {
+    PERFETTO_ELOG(
+        "Unable to connect to the system tracing service as a consumer. On "
+        "Android, use the \"perfetto\" command line tool instead to start "
+        "system-wide tracing sessions");
+  }
+#endif  // PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+
+  // Notify the client about disconnection.
+  NotifyError(TracingError{TracingError::kDisconnected, "Peer disconnected"});
+
+  // Make sure the client doesn't hang in a blocking start/stop because of the
+  // disconnection.
+  NotifyStartComplete();
+  NotifyStopComplete();
+
+  // It shouldn't be necessary to call StopTracingSession. If we get this call
+  // it means that the service did shutdown before us, so there is no point
+  // trying it to ask it to stop the session. We should just remember to cleanup
+  // the consumer vector.
+  connected_ = false;
+
+  // Notify the muxer that it is safe to destroy |this|. This is needed because
+  // the ConsumerEndpoint stored in |service_| requires that |this| be safe to
+  // access until OnDisconnect() is called.
+  muxer_->OnConsumerDisconnected(this);
+}
+
+void TracingMuxerImpl::ConsumerImpl::Disconnect() {
+  // This is weird and deserves a comment.
+  //
+  // When we called the ConnectConsumer method on the service it returns
+  // us a ConsumerEndpoint which we stored in |service_|, however this
+  // ConsumerEndpoint holds a pointer to the ConsumerImpl pointed to by
+  // |this|. Part of the API contract to TracingService::ConnectConsumer is that
+  // the ConsumerImpl pointer has to be valid until the
+  // ConsumerImpl::OnDisconnect method is called. Therefore we reset the
+  // ConsumerEndpoint |service_|. Eventually this will call
+  // ConsumerImpl::OnDisconnect and we will inform the muxer it is safe to
+  // call the destructor of |this|.
+  service_.reset();
+}
+
+void TracingMuxerImpl::ConsumerImpl::OnTracingDisabled(
+    const std::string& error) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  PERFETTO_DCHECK(!stopped_);
+  stopped_ = true;
+
+  if (!error.empty())
+    NotifyError(TracingError{TracingError::kTracingFailed, error});
+
+  // If we're still waiting for the start event, fire it now. This may happen if
+  // there are no active data sources in the session.
+  NotifyStartComplete();
+  NotifyStopComplete();
+}
+
+void TracingMuxerImpl::ConsumerImpl::NotifyStartComplete() {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  if (start_complete_callback_) {
+    muxer_->task_runner_->PostTask(std::move(start_complete_callback_));
+    start_complete_callback_ = nullptr;
+  }
+  if (blocking_start_complete_callback_) {
+    muxer_->task_runner_->PostTask(
+        std::move(blocking_start_complete_callback_));
+    blocking_start_complete_callback_ = nullptr;
+  }
+}
+
+void TracingMuxerImpl::ConsumerImpl::NotifyError(const TracingError& error) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  if (error_callback_) {
+    muxer_->task_runner_->PostTask(
+        std::bind(std::move(error_callback_), error));
+  }
+}
+
+void TracingMuxerImpl::ConsumerImpl::NotifyStopComplete() {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  if (stop_complete_callback_) {
+    muxer_->task_runner_->PostTask(std::move(stop_complete_callback_));
+    stop_complete_callback_ = nullptr;
+  }
+  if (blocking_stop_complete_callback_) {
+    muxer_->task_runner_->PostTask(std::move(blocking_stop_complete_callback_));
+    blocking_stop_complete_callback_ = nullptr;
+  }
+}
+
+void TracingMuxerImpl::ConsumerImpl::OnTraceData(
+    std::vector<TracePacket> packets,
+    bool has_more) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  if (!read_trace_callback_)
+    return;
+
+  size_t capacity = 0;
+  for (const auto& packet : packets) {
+    // 16 is an over-estimation of the proto preamble size
+    capacity += packet.size() + 16;
+  }
+
+  // The shared_ptr is to avoid making a copy of the buffer when PostTask-ing.
+  std::shared_ptr<std::vector<char>> buf(new std::vector<char>());
+  buf->reserve(capacity);
+  for (auto& packet : packets) {
+    char* start;
+    size_t size;
+    std::tie(start, size) = packet.GetProtoPreamble();
+    buf->insert(buf->end(), start, start + size);
+    for (auto& slice : packet.slices()) {
+      const auto* slice_data = reinterpret_cast<const char*>(slice.start);
+      buf->insert(buf->end(), slice_data, slice_data + slice.size);
+    }
+  }
+
+  auto callback = read_trace_callback_;
+  muxer_->task_runner_->PostTask([callback, buf, has_more] {
+    TracingSession::ReadTraceCallbackArgs callback_arg{};
+    callback_arg.data = buf->empty() ? nullptr : &(*buf)[0];
+    callback_arg.size = buf->size();
+    callback_arg.has_more = has_more;
+    callback(callback_arg);
+  });
+
+  if (!has_more)
+    read_trace_callback_ = nullptr;
+}
+
+void TracingMuxerImpl::ConsumerImpl::OnObservableEvents(
+    const ObservableEvents& events) {
+  if (events.instance_state_changes_size()) {
+    for (const auto& state_change : events.instance_state_changes()) {
+      DataSourceHandle handle{state_change.producer_name(),
+                              state_change.data_source_name()};
+      data_source_states_[handle] =
+          state_change.state() ==
+          ObservableEvents::DATA_SOURCE_INSTANCE_STATE_STARTED;
+    }
+  }
+
+  if (events.instance_state_changes_size() ||
+      events.all_data_sources_started()) {
+    // Data sources are first reported as being stopped before starting, so once
+    // all the data sources we know about have started we can declare tracing
+    // begun. In the case where there are no matching data sources for the
+    // session, the service will report the all_data_sources_started() event
+    // without adding any instances (only since Android S / Perfetto v10.0).
+    if (start_complete_callback_ || blocking_start_complete_callback_) {
+      bool all_data_sources_started = std::all_of(
+          data_source_states_.cbegin(), data_source_states_.cend(),
+          [](std::pair<DataSourceHandle, bool> state) { return state.second; });
+      if (all_data_sources_started)
+        NotifyStartComplete();
+    }
+  }
+}
+
+void TracingMuxerImpl::ConsumerImpl::OnSessionCloned(
+    const OnSessionClonedArgs& args) {
+  if (!clone_trace_callback_)
+    return;
+  TracingSession::CloneTraceCallbackArgs callback_arg{};
+  callback_arg.success = args.success;
+  callback_arg.error = std::move(args.error);
+  callback_arg.uuid_msb = args.uuid.msb();
+  callback_arg.uuid_lsb = args.uuid.lsb();
+  muxer_->task_runner_->PostTask(
+      std::bind(std::move(clone_trace_callback_), std::move(callback_arg)));
+  clone_trace_callback_ = nullptr;
+}
+
+void TracingMuxerImpl::ConsumerImpl::OnTraceStats(
+    bool success,
+    const TraceStats& trace_stats) {
+  if (!get_trace_stats_callback_)
+    return;
+  TracingSession::GetTraceStatsCallbackArgs callback_arg{};
+  callback_arg.success = success;
+  callback_arg.trace_stats_data = trace_stats.SerializeAsArray();
+  muxer_->task_runner_->PostTask(
+      std::bind(std::move(get_trace_stats_callback_), std::move(callback_arg)));
+  get_trace_stats_callback_ = nullptr;
+}
+
+// The callbacks below are not used.
+void TracingMuxerImpl::ConsumerImpl::OnDetach(bool) {}
+void TracingMuxerImpl::ConsumerImpl::OnAttach(bool, const TraceConfig&) {}
+// ----- End of TracingMuxerImpl::ConsumerImpl
+
+// ----- Begin of TracingMuxerImpl::TracingSessionImpl
+
+// TracingSessionImpl is the RAII object returned to API clients when they
+// invoke Tracing::CreateTracingSession. They use it for starting/stopping
+// tracing.
+
+TracingMuxerImpl::TracingSessionImpl::TracingSessionImpl(
+    TracingMuxerImpl* muxer,
+    TracingSessionGlobalID session_id,
+    BackendType backend_type)
+    : muxer_(muxer), session_id_(session_id), backend_type_(backend_type) {}
+
+// Can be destroyed from any thread.
+TracingMuxerImpl::TracingSessionImpl::~TracingSessionImpl() {
+  auto* muxer = muxer_;
+  auto session_id = session_id_;
+  muxer->task_runner_->PostTask(
+      [muxer, session_id] { muxer->DestroyTracingSession(session_id); });
+}
+
+// Can be called from any thread.
+void TracingMuxerImpl::TracingSessionImpl::Setup(const TraceConfig& cfg,
+                                                 int fd) {
+  auto* muxer = muxer_;
+  auto session_id = session_id_;
+  std::shared_ptr<TraceConfig> trace_config(new TraceConfig(cfg));
+  if (fd >= 0) {
+    base::ignore_result(backend_type_);  // For -Wunused in the amalgamation.
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+    if (backend_type_ != kInProcessBackend) {
+      PERFETTO_FATAL(
+          "Passing a file descriptor to TracingSession::Setup() is only "
+          "supported with the kInProcessBackend on Windows. Use "
+          "TracingSession::ReadTrace() instead");
+    }
+#endif
+    trace_config->set_write_into_file(true);
+    fd = dup(fd);
+  }
+  muxer->task_runner_->PostTask([muxer, session_id, trace_config, fd] {
+    muxer->SetupTracingSession(session_id, trace_config, base::ScopedFile(fd));
+  });
+}
+
+// Can be called from any thread.
+void TracingMuxerImpl::TracingSessionImpl::Start() {
+  auto* muxer = muxer_;
+  auto session_id = session_id_;
+  muxer->task_runner_->PostTask(
+      [muxer, session_id] { muxer->StartTracingSession(session_id); });
+}
+
+void TracingMuxerImpl::TracingSessionImpl::CloneTrace(CloneTraceArgs args,
+                                                      CloneTraceCallback cb) {
+  auto* muxer = muxer_;
+  auto session_id = session_id_;
+  muxer->task_runner_->PostTask([muxer, session_id, args, cb] {
+    muxer->CloneTracingSession(session_id, args, std::move(cb));
+  });
+}
+
+// Can be called from any thread.
+void TracingMuxerImpl::TracingSessionImpl::ChangeTraceConfig(
+    const TraceConfig& cfg) {
+  auto* muxer = muxer_;
+  auto session_id = session_id_;
+  muxer->task_runner_->PostTask([muxer, session_id, cfg] {
+    muxer->ChangeTracingSessionConfig(session_id, cfg);
+  });
+}
+
+// Can be called from any thread except the service thread.
+void TracingMuxerImpl::TracingSessionImpl::StartBlocking() {
+  PERFETTO_DCHECK(!muxer_->task_runner_->RunsTasksOnCurrentThread());
+  auto* muxer = muxer_;
+  auto session_id = session_id_;
+  base::WaitableEvent tracing_started;
+  muxer->task_runner_->PostTask([muxer, session_id, &tracing_started] {
+    auto* consumer = muxer->FindConsumer(session_id);
+    if (!consumer) {
+      // TODO(skyostil): Signal an error to the user.
+      tracing_started.Notify();
+      return;
+    }
+    PERFETTO_DCHECK(!consumer->blocking_start_complete_callback_);
+    consumer->blocking_start_complete_callback_ = [&] {
+      tracing_started.Notify();
+    };
+    muxer->StartTracingSession(session_id);
+  });
+  tracing_started.Wait();
+}
+
+// Can be called from any thread.
+void TracingMuxerImpl::TracingSessionImpl::Flush(
+    std::function<void(bool)> user_callback,
+    uint32_t timeout_ms) {
+  auto* muxer = muxer_;
+  auto session_id = session_id_;
+  muxer->task_runner_->PostTask([muxer, session_id, timeout_ms, user_callback] {
+    auto* consumer = muxer->FindConsumer(session_id);
+    if (!consumer) {
+      std::move(user_callback)(false);
+      return;
+    }
+    muxer->FlushTracingSession(session_id, timeout_ms,
+                               std::move(user_callback));
+  });
+}
+
+// Can be called from any thread.
+void TracingMuxerImpl::TracingSessionImpl::Stop() {
+  auto* muxer = muxer_;
+  auto session_id = session_id_;
+  muxer->task_runner_->PostTask(
+      [muxer, session_id] { muxer->StopTracingSession(session_id); });
+}
+
+// Can be called from any thread except the service thread.
+void TracingMuxerImpl::TracingSessionImpl::StopBlocking() {
+  PERFETTO_DCHECK(!muxer_->task_runner_->RunsTasksOnCurrentThread());
+  auto* muxer = muxer_;
+  auto session_id = session_id_;
+  base::WaitableEvent tracing_stopped;
+  muxer->task_runner_->PostTask([muxer, session_id, &tracing_stopped] {
+    auto* consumer = muxer->FindConsumer(session_id);
+    if (!consumer) {
+      // TODO(skyostil): Signal an error to the user.
+      tracing_stopped.Notify();
+      return;
+    }
+    PERFETTO_DCHECK(!consumer->blocking_stop_complete_callback_);
+    consumer->blocking_stop_complete_callback_ = [&] {
+      tracing_stopped.Notify();
+    };
+    muxer->StopTracingSession(session_id);
+  });
+  tracing_stopped.Wait();
+}
+
+// Can be called from any thread.
+void TracingMuxerImpl::TracingSessionImpl::ReadTrace(ReadTraceCallback cb) {
+  auto* muxer = muxer_;
+  auto session_id = session_id_;
+  muxer->task_runner_->PostTask([muxer, session_id, cb] {
+    muxer->ReadTracingSessionData(session_id, std::move(cb));
+  });
+}
+
+// Can be called from any thread.
+void TracingMuxerImpl::TracingSessionImpl::SetOnStartCallback(
+    std::function<void()> cb) {
+  auto* muxer = muxer_;
+  auto session_id = session_id_;
+  muxer->task_runner_->PostTask([muxer, session_id, cb] {
+    auto* consumer = muxer->FindConsumer(session_id);
+    if (!consumer)
+      return;
+    consumer->start_complete_callback_ = cb;
+  });
+}
+
+// Can be called from any thread
+void TracingMuxerImpl::TracingSessionImpl::SetOnErrorCallback(
+    std::function<void(TracingError)> cb) {
+  auto* muxer = muxer_;
+  auto session_id = session_id_;
+  muxer->task_runner_->PostTask([muxer, session_id, cb] {
+    auto* consumer = muxer->FindConsumer(session_id);
+    if (!consumer) {
+      // Notify the client about concurrent disconnection of the session.
+      if (cb)
+        cb(TracingError{TracingError::kDisconnected, "Peer disconnected"});
+      return;
+    }
+    consumer->error_callback_ = cb;
+  });
+}
+
+// Can be called from any thread.
+void TracingMuxerImpl::TracingSessionImpl::SetOnStopCallback(
+    std::function<void()> cb) {
+  auto* muxer = muxer_;
+  auto session_id = session_id_;
+  muxer->task_runner_->PostTask([muxer, session_id, cb] {
+    auto* consumer = muxer->FindConsumer(session_id);
+    if (!consumer)
+      return;
+    consumer->stop_complete_callback_ = cb;
+  });
+}
+
+// Can be called from any thread.
+void TracingMuxerImpl::TracingSessionImpl::GetTraceStats(
+    GetTraceStatsCallback cb) {
+  auto* muxer = muxer_;
+  auto session_id = session_id_;
+  muxer->task_runner_->PostTask([muxer, session_id, cb] {
+    muxer->GetTraceStats(session_id, std::move(cb));
+  });
+}
+
+// Can be called from any thread.
+void TracingMuxerImpl::TracingSessionImpl::QueryServiceState(
+    QueryServiceStateCallback cb) {
+  auto* muxer = muxer_;
+  auto session_id = session_id_;
+  muxer->task_runner_->PostTask([muxer, session_id, cb] {
+    muxer->QueryServiceState(session_id, std::move(cb));
+  });
+}
+
+// ----- End of TracingMuxerImpl::TracingSessionImpl
+
+// ----- Begin of TracingMuxerImpl::StartupTracingSessionImpl
+
+TracingMuxerImpl::StartupTracingSessionImpl::StartupTracingSessionImpl(
+    TracingMuxerImpl* muxer,
+    TracingSessionGlobalID session_id,
+    BackendType backend_type)
+    : muxer_(muxer), session_id_(session_id), backend_type_(backend_type) {}
+
+// Can be destroyed from any thread.
+TracingMuxerImpl::StartupTracingSessionImpl::~StartupTracingSessionImpl() =
+    default;
+
+void TracingMuxerImpl::StartupTracingSessionImpl::Abort() {
+  auto* muxer = muxer_;
+  auto session_id = session_id_;
+  auto backend_type = backend_type_;
+  muxer->task_runner_->PostTask([muxer, session_id, backend_type] {
+    muxer->AbortStartupTracingSession(session_id, backend_type);
+  });
+}
+
+// Must not be called from the SDK's internal thread.
+void TracingMuxerImpl::StartupTracingSessionImpl::AbortBlocking() {
+  auto* muxer = muxer_;
+  auto session_id = session_id_;
+  auto backend_type = backend_type_;
+  PERFETTO_CHECK(!muxer->task_runner_->RunsTasksOnCurrentThread());
+  base::WaitableEvent event;
+  muxer->task_runner_->PostTask([muxer, session_id, backend_type, &event] {
+    muxer->AbortStartupTracingSession(session_id, backend_type);
+    event.Notify();
+  });
+  event.Wait();
+}
+
+// ----- End of TracingMuxerImpl::StartupTracingSessionImpl
+
+// static
+TracingMuxer* TracingMuxer::instance_ = TracingMuxerFake::Get();
+
+// This is called by perfetto::Tracing::Initialize().
+// Can be called on any thread. Typically, but not necessarily, that will be
+// the embedder's main thread.
+TracingMuxerImpl::TracingMuxerImpl(const TracingInitArgs& args)
+    : TracingMuxer(args.platform ? args.platform
+                                 : Platform::GetDefaultPlatform()) {
+  PERFETTO_DETACH_FROM_THREAD(thread_checker_);
+  instance_ = this;
+
+  // Create the thread where muxer, producers and service will live.
+  Platform::CreateTaskRunnerArgs tr_args{/*name_for_debugging=*/"TracingMuxer"};
+  task_runner_.reset(new NonReentrantTaskRunner(
+      this, platform_->CreateTaskRunner(std::move(tr_args))));
+
+  // Run the initializer on that thread.
+  task_runner_->PostTask([this, args] {
+    Initialize(args);
+    AddBackends(args);
+  });
+}
+
+void TracingMuxerImpl::Initialize(const TracingInitArgs& args) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);  // Rebind the thread checker.
+
+  policy_ = args.tracing_policy;
+  supports_multiple_data_source_instances_ =
+      args.supports_multiple_data_source_instances;
+
+  // Fallback backend for producer creation for an unsupported backend type.
+  PERFETTO_CHECK(producer_backends_.empty());
+  AddProducerBackend(internal::TracingBackendFake::GetInstance(),
+                     BackendType::kUnspecifiedBackend, args);
+  // Fallback backend for consumer creation for an unsupported backend type.
+  // This backend simply fails any attempt to start a tracing session.
+  PERFETTO_CHECK(consumer_backends_.empty());
+  AddConsumerBackend(internal::TracingBackendFake::GetInstance(),
+                     BackendType::kUnspecifiedBackend);
+}
+
+void TracingMuxerImpl::AddConsumerBackend(TracingConsumerBackend* backend,
+                                          BackendType type) {
+  if (!backend) {
+    // We skip the log in release builds because the *_backend_fake.cc code
+    // has already an ELOG before returning a nullptr.
+    PERFETTO_DLOG("Consumer backend creation failed, type %d",
+                  static_cast<int>(type));
+    return;
+  }
+  // Keep the backends sorted by type.
+  auto it =
+      std::upper_bound(consumer_backends_.begin(), consumer_backends_.end(),
+                       type, CompareBackendByType<RegisteredConsumerBackend>());
+  it = consumer_backends_.emplace(it);
+
+  RegisteredConsumerBackend& rb = *it;
+  rb.backend = backend;
+  rb.type = type;
+}
+
+void TracingMuxerImpl::AddProducerBackend(TracingProducerBackend* backend,
+                                          BackendType type,
+                                          const TracingInitArgs& args) {
+  if (!backend) {
+    // We skip the log in release builds because the *_backend_fake.cc code
+    // has already an ELOG before returning a nullptr.
+    PERFETTO_DLOG("Producer backend creation failed, type %d",
+                  static_cast<int>(type));
+    return;
+  }
+  TracingBackendId backend_id = producer_backends_.size();
+  // Keep the backends sorted by type.
+  auto it =
+      std::upper_bound(producer_backends_.begin(), producer_backends_.end(),
+                       type, CompareBackendByType<RegisteredProducerBackend>());
+  it = producer_backends_.emplace(it);
+
+  RegisteredProducerBackend& rb = *it;
+  rb.backend = backend;
+  rb.id = backend_id;
+  rb.type = type;
+  rb.producer.reset(new ProducerImpl(this, backend_id,
+                                     args.shmem_batch_commits_duration_ms,
+                                     args.shmem_direct_patching_enabled));
+  rb.producer_conn_args.producer = rb.producer.get();
+  rb.producer_conn_args.producer_name = platform_->GetCurrentProcessName();
+  rb.producer_conn_args.task_runner = task_runner_.get();
+  rb.producer_conn_args.shmem_size_hint_bytes = args.shmem_size_hint_kb * 1024;
+  rb.producer_conn_args.shmem_page_size_hint_bytes =
+      args.shmem_page_size_hint_kb * 1024;
+  rb.producer_conn_args.create_socket_async = args.create_socket_async;
+  rb.producer->Initialize(rb.backend->ConnectProducer(rb.producer_conn_args));
+}
+
+TracingMuxerImpl::RegisteredProducerBackend*
+TracingMuxerImpl::FindProducerBackendById(TracingBackendId id) {
+  for (RegisteredProducerBackend& b : producer_backends_) {
+    if (b.id == id) {
+      return &b;
+    }
+  }
+  return nullptr;
+}
+
+TracingMuxerImpl::RegisteredProducerBackend*
+TracingMuxerImpl::FindProducerBackendByType(BackendType type) {
+  for (RegisteredProducerBackend& b : producer_backends_) {
+    if (b.type == type) {
+      return &b;
+    }
+  }
+  return nullptr;
+}
+
+TracingMuxerImpl::RegisteredConsumerBackend*
+TracingMuxerImpl::FindConsumerBackendByType(BackendType type) {
+  for (RegisteredConsumerBackend& b : consumer_backends_) {
+    if (b.type == type) {
+      return &b;
+    }
+  }
+  return nullptr;
+}
+
+void TracingMuxerImpl::AddBackends(const TracingInitArgs& args) {
+  if (args.backends & kSystemBackend) {
+    PERFETTO_CHECK(args.system_producer_backend_factory_);
+    if (FindProducerBackendByType(kSystemBackend) == nullptr) {
+      AddProducerBackend(args.system_producer_backend_factory_(),
+                         kSystemBackend, args);
+    }
+    if (args.enable_system_consumer) {
+      PERFETTO_CHECK(args.system_consumer_backend_factory_);
+      if (FindConsumerBackendByType(kSystemBackend) == nullptr) {
+        AddConsumerBackend(args.system_consumer_backend_factory_(),
+                           kSystemBackend);
+      }
+    }
+  }
+
+  if (args.backends & kInProcessBackend) {
+    TracingBackend* b = nullptr;
+    if (FindProducerBackendByType(kInProcessBackend) == nullptr) {
+      if (!b) {
+        PERFETTO_CHECK(args.in_process_backend_factory_);
+        b = args.in_process_backend_factory_();
+      }
+      AddProducerBackend(b, kInProcessBackend, args);
+    }
+    if (FindConsumerBackendByType(kInProcessBackend) == nullptr) {
+      if (!b) {
+        PERFETTO_CHECK(args.in_process_backend_factory_);
+        b = args.in_process_backend_factory_();
+      }
+      AddConsumerBackend(b, kInProcessBackend);
+    }
+  }
+
+  if (args.backends & kCustomBackend) {
+    PERFETTO_CHECK(args.custom_backend);
+    if (FindProducerBackendByType(kCustomBackend) == nullptr) {
+      AddProducerBackend(args.custom_backend, kCustomBackend, args);
+    }
+    if (FindConsumerBackendByType(kCustomBackend) == nullptr) {
+      AddConsumerBackend(args.custom_backend, kCustomBackend);
+    }
+  }
+
+  if (args.backends & ~(kSystemBackend | kInProcessBackend | kCustomBackend)) {
+    PERFETTO_FATAL("Unsupported tracing backend type");
+  }
+}
+
+// Can be called from any thread (but not concurrently).
+bool TracingMuxerImpl::RegisterDataSource(
+    const DataSourceDescriptor& descriptor,
+    DataSourceFactory factory,
+    DataSourceParams params,
+    bool no_flush,
+    DataSourceStaticState* static_state) {
+  // Ignore repeated registrations.
+  if (static_state->index != kMaxDataSources)
+    return true;
+
+  uint32_t new_index = next_data_source_index_++;
+  if (new_index >= kMaxDataSources) {
+    PERFETTO_DLOG(
+        "RegisterDataSource failed: too many data sources already registered");
+    return false;
+  }
+
+  // Initialize the static state.
+  static_assert(sizeof(static_state->instances[0]) >= sizeof(DataSourceState),
+                "instances[] size mismatch");
+  for (size_t i = 0; i < static_state->instances.size(); i++)
+    new (&static_state->instances[i]) DataSourceState{};
+
+  static_state->index = new_index;
+
+  // Generate a semi-unique id for this data source.
+  uint64_t digest = base::FnvHasher::Combine(
+      reinterpret_cast<intptr_t>(static_state), base::GetWallTimeNs().count());
+  static_state->id = digest ? digest : 1;
+
+  task_runner_->PostTask(
+      [this, descriptor, factory, static_state, params, no_flush] {
+        data_sources_.emplace_back();
+        RegisteredDataSource& rds = data_sources_.back();
+        rds.descriptor = descriptor;
+        rds.factory = factory;
+        rds.params = params;
+        if (!supports_multiple_data_source_instances_) {
+          rds.params.supports_multiple_instances = false;
+        }
+        rds.static_state = static_state;
+        rds.no_flush = no_flush;
+
+        UpdateDataSourceOnAllBackends(rds, /*is_changed=*/false);
+      });
+  return true;
+}
+
+// Can be called from any thread (but not concurrently).
+void TracingMuxerImpl::UpdateDataSourceDescriptor(
+    const DataSourceDescriptor& descriptor,
+    const DataSourceStaticState* static_state) {
+  task_runner_->PostTask([this, descriptor, static_state] {
+    for (auto& rds : data_sources_) {
+      if (rds.static_state == static_state) {
+        PERFETTO_CHECK(rds.descriptor.name() == descriptor.name());
+        rds.descriptor = descriptor;
+        rds.descriptor.set_id(static_state->id);
+        UpdateDataSourceOnAllBackends(rds, /*is_changed=*/true);
+        return;
+      }
+    }
+  });
+}
+
+// Can be called from any thread (but not concurrently).
+void TracingMuxerImpl::RegisterInterceptor(
+    const InterceptorDescriptor& descriptor,
+    InterceptorFactory factory,
+    InterceptorBase::TLSFactory tls_factory,
+    InterceptorBase::TracePacketCallback packet_callback) {
+  task_runner_->PostTask([this, descriptor, factory, tls_factory,
+                          packet_callback] {
+    // Ignore repeated registrations.
+    for (const auto& interceptor : interceptors_) {
+      if (interceptor.descriptor.name() == descriptor.name()) {
+        PERFETTO_DCHECK(interceptor.tls_factory == tls_factory);
+        PERFETTO_DCHECK(interceptor.packet_callback == packet_callback);
+        return;
+      }
+    }
+    // Only allow certain interceptors for now.
+    if (descriptor.name() != "test_interceptor" &&
+        descriptor.name() != "console" && descriptor.name() != "etwexport") {
+      PERFETTO_ELOG(
+          "Interceptors are experimental. If you want to use them, please "
+          "get in touch with the project maintainers "
+          "(https://perfetto.dev/docs/contributing/"
+          "getting-started#community).");
+      return;
+    }
+    interceptors_.emplace_back();
+    RegisteredInterceptor& interceptor = interceptors_.back();
+    interceptor.descriptor = descriptor;
+    interceptor.factory = factory;
+    interceptor.tls_factory = tls_factory;
+    interceptor.packet_callback = packet_callback;
+  });
+}
+
+void TracingMuxerImpl::ActivateTriggers(
+    const std::vector<std::string>& triggers,
+    uint32_t ttl_ms) {
+  base::TimeMillis expire_time =
+      base::GetWallTimeMs() + base::TimeMillis(ttl_ms);
+  task_runner_->PostTask([this, triggers, expire_time] {
+    for (RegisteredProducerBackend& backend : producer_backends_) {
+      if (backend.producer->connected_) {
+        backend.producer->service_->ActivateTriggers(triggers);
+      } else {
+        for (const std::string& trigger : triggers) {
+          backend.producer->on_connect_triggers_.emplace_back(trigger,
+                                                              expire_time);
+        }
+      }
+    }
+  });
+}
+
+// Checks if there is any matching startup tracing data source instance for a
+// new SetupDataSource call. If so, moves the data source to this tracing
+// session (and its target buffer) and returns true, otherwise returns false.
+static bool MaybeAdoptStartupTracingInDataSource(
+    TracingBackendId backend_id,
+    uint32_t backend_connection_id,
+    DataSourceInstanceID instance_id,
+    const DataSourceConfig& cfg,
+    const std::vector<RegisteredDataSource>& data_sources) {
+  for (const auto& rds : data_sources) {
+    DataSourceStaticState* static_state = rds.static_state;
+    for (uint32_t i = 0; i < kMaxDataSourceInstances; i++) {
+      auto* internal_state = static_state->TryGet(i);
+
+      if (internal_state &&
+          internal_state->startup_target_buffer_reservation.load(
+              std::memory_order_relaxed) &&
+          internal_state->data_source_instance_id == 0 &&
+          internal_state->backend_id == backend_id &&
+          internal_state->backend_connection_id == backend_connection_id &&
+          internal_state->config &&
+          internal_state->data_source->CanAdoptStartupSession(
+              *internal_state->config, cfg)) {
+        PERFETTO_DLOG("Setting up data source %" PRIu64
+                      " %s by adopting it from a startup tracing session",
+                      instance_id, cfg.name().c_str());
+
+        std::lock_guard<std::recursive_mutex> lock(internal_state->lock);
+        // Set the associations. The actual takeover happens in
+        // StartDataSource().
+        internal_state->data_source_instance_id = instance_id;
+        internal_state->buffer_id =
+            static_cast<internal::BufferId>(cfg.target_buffer());
+        internal_state->buffer_exhausted_policy =
+            ComputeBufferExhaustedPolicy(cfg, rds.params);
+        internal_state->config.reset(new DataSourceConfig(cfg));
+
+        // TODO(eseckler): Should the data source config provided by the service
+        // be allowed to specify additional interceptors / additional data
+        // source params?
+
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// Called by the service of one of the backends.
+void TracingMuxerImpl::SetupDataSource(TracingBackendId backend_id,
+                                       uint32_t backend_connection_id,
+                                       DataSourceInstanceID instance_id,
+                                       const DataSourceConfig& cfg) {
+  PERFETTO_DLOG("Setting up data source %" PRIu64 " %s", instance_id,
+                cfg.name().c_str());
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+
+  // First check if there is any matching startup tracing data source instance.
+  if (MaybeAdoptStartupTracingInDataSource(backend_id, backend_connection_id,
+                                           instance_id, cfg, data_sources_)) {
+    return;
+  }
+
+  for (const auto& rds : data_sources_) {
+    if (rds.descriptor.name() != cfg.name())
+      continue;
+    DataSourceStaticState& static_state = *rds.static_state;
+
+    // If this data source is already active for this exact config, don't start
+    // another instance. This happens when we have several data sources with the
+    // same name, in which case the service sends one SetupDataSource event for
+    // each one. Since we can't map which event maps to which data source, we
+    // ensure each event only starts one data source instance.
+    // TODO(skyostil): Register a unique id with each data source to the service
+    // to disambiguate.
+    bool active_for_config = false;
+    for (uint32_t i = 0; i < kMaxDataSourceInstances; i++) {
+      if (!static_state.TryGet(i))
+        continue;
+      auto* internal_state =
+          reinterpret_cast<DataSourceState*>(&static_state.instances[i]);
+      if (internal_state->backend_id == backend_id &&
+          internal_state->backend_connection_id == backend_connection_id &&
+          internal_state->config && *internal_state->config == cfg) {
+        active_for_config = true;
+        break;
+      }
+    }
+    if (active_for_config) {
+      PERFETTO_DLOG(
+          "Data source %s is already active with this config, skipping",
+          cfg.name().c_str());
+      continue;
+    }
+
+    SetupDataSourceImpl(rds, backend_id, backend_connection_id, instance_id,
+                        cfg, /*startup_session_id=*/0);
+    return;
+  }
+}
+
+TracingMuxerImpl::FindDataSourceRes TracingMuxerImpl::SetupDataSourceImpl(
+    const RegisteredDataSource& rds,
+    TracingBackendId backend_id,
+    uint32_t backend_connection_id,
+    DataSourceInstanceID instance_id,
+    const DataSourceConfig& cfg,
+    TracingSessionGlobalID startup_session_id) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  DataSourceStaticState& static_state = *rds.static_state;
+
+  // If any bit is set in `static_state.valid_instances` then at least one
+  // other instance of data source is running.
+  if (!rds.params.supports_multiple_instances &&
+      static_state.valid_instances.load(std::memory_order_acquire) != 0) {
+    PERFETTO_ELOG(
+        "Failed to setup data source because some another instance of this "
+        "data source is already active");
+    return FindDataSourceRes();
+  }
+
+  for (uint32_t i = 0; i < kMaxDataSourceInstances; i++) {
+    // Find a free slot.
+    if (static_state.TryGet(i))
+      continue;
+
+    auto* internal_state =
+        reinterpret_cast<DataSourceState*>(&static_state.instances[i]);
+    std::unique_lock<std::recursive_mutex> lock(internal_state->lock);
+    static_assert(
+        std::is_same<decltype(internal_state->data_source_instance_id),
+                     DataSourceInstanceID>::value,
+        "data_source_instance_id type mismatch");
+    internal_state->muxer_id_for_testing = muxer_id_for_testing_;
+    RegisteredProducerBackend& backend = *FindProducerBackendById(backend_id);
+
+    if (startup_session_id) {
+      uint16_t& last_reservation =
+          backend.producer->last_startup_target_buffer_reservation_;
+      if (last_reservation == std::numeric_limits<uint16_t>::max()) {
+        PERFETTO_ELOG(
+            "Startup buffer reservations exhausted, dropping data source");
+        return FindDataSourceRes();
+      }
+      internal_state->startup_target_buffer_reservation.store(
+          ++last_reservation, std::memory_order_relaxed);
+    } else {
+      internal_state->startup_target_buffer_reservation.store(
+          0, std::memory_order_relaxed);
+    }
+
+    internal_state->backend_id = backend_id;
+    internal_state->backend_connection_id = backend_connection_id;
+    internal_state->data_source_instance_id = instance_id;
+    internal_state->buffer_id =
+        static_cast<internal::BufferId>(cfg.target_buffer());
+    internal_state->buffer_exhausted_policy =
+        ComputeBufferExhaustedPolicy(cfg, rds.params);
+    internal_state->config.reset(new DataSourceConfig(cfg));
+    internal_state->startup_session_id = startup_session_id;
+    internal_state->data_source = rds.factory();
+    internal_state->interceptor = nullptr;
+    internal_state->interceptor_id = 0;
+    internal_state->will_notify_on_stop = rds.descriptor.will_notify_on_stop();
+
+    if (cfg.has_interceptor_config()) {
+      for (size_t j = 0; j < interceptors_.size(); j++) {
+        if (cfg.interceptor_config().name() ==
+            interceptors_[j].descriptor.name()) {
+          PERFETTO_DLOG("Intercepting data source %" PRIu64
+                        " \"%s\" into \"%s\"",
+                        instance_id, cfg.name().c_str(),
+                        cfg.interceptor_config().name().c_str());
+          internal_state->interceptor_id = static_cast<uint32_t>(j + 1);
+          internal_state->interceptor = interceptors_[j].factory();
+          internal_state->interceptor->OnSetup({cfg});
+          break;
+        }
+      }
+      if (!internal_state->interceptor_id) {
+        PERFETTO_ELOG("Unknown interceptor configured for data source: %s",
+                      cfg.interceptor_config().name().c_str());
+      }
+    }
+
+    // This must be made at the end. See matching acquire-load in
+    // DataSource::Trace().
+    static_state.valid_instances.fetch_or(1 << i, std::memory_order_release);
+
+    DataSourceBase::SetupArgs setup_args;
+    setup_args.config = &cfg;
+    setup_args.backend_type = backend.type;
+    setup_args.internal_instance_index = i;
+
+    if (!rds.params.requires_callbacks_under_lock)
+      lock.unlock();
+    internal_state->data_source->OnSetup(setup_args);
+
+    return FindDataSourceRes(&static_state, internal_state, i,
+                             rds.params.requires_callbacks_under_lock);
+  }
+  PERFETTO_ELOG(
+      "Maximum number of data source instances exhausted. "
+      "Dropping data source %" PRIu64,
+      instance_id);
+  return FindDataSourceRes();
+}
+
+// Called by the service of one of the backends.
+void TracingMuxerImpl::StartDataSource(TracingBackendId backend_id,
+                                       DataSourceInstanceID instance_id) {
+  PERFETTO_DLOG("Starting data source %" PRIu64, instance_id);
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+
+  auto ds = FindDataSource(backend_id, instance_id);
+  if (!ds) {
+    PERFETTO_ELOG("Could not find data source to start");
+    return;
+  }
+
+  // Check if the data source was already started for startup tracing.
+  uint16_t startup_reservation =
+      ds.internal_state->startup_target_buffer_reservation.load(
+          std::memory_order_relaxed);
+  if (startup_reservation) {
+    RegisteredProducerBackend& backend = *FindProducerBackendById(backend_id);
+    TracingSessionGlobalID session_id = ds.internal_state->startup_session_id;
+    auto session_it = std::find_if(
+        backend.startup_sessions.begin(), backend.startup_sessions.end(),
+        [session_id](const RegisteredStartupSession& session) {
+          return session.session_id == session_id;
+        });
+    PERFETTO_DCHECK(session_it != backend.startup_sessions.end());
+
+    if (session_it->is_aborting) {
+      PERFETTO_DLOG("Data source %" PRIu64
+                    " was already aborted for startup tracing, not starting it",
+                    instance_id);
+      return;
+    }
+
+    PERFETTO_DLOG(
+        "Data source %" PRIu64
+        " was already started for startup tracing, binding its target buffer",
+        instance_id);
+
+    backend.producer->service_->MaybeSharedMemoryArbiter()
+        ->BindStartupTargetBuffer(startup_reservation,
+                                  ds.internal_state->buffer_id);
+
+    // The reservation ID can be used even after binding it, so there's no need
+    // for any barriers here - we just need atomicity.
+    ds.internal_state->startup_target_buffer_reservation.store(
+        0, std::memory_order_relaxed);
+
+    // TODO(eseckler): Should we reset incremental state at this point, or
+    // notify the data source some other way?
+
+    // The session should not have been fully bound yet (or aborted).
+    PERFETTO_DCHECK(session_it->num_unbound_data_sources > 0);
+
+    session_it->num_unbound_data_sources--;
+    if (session_it->num_unbound_data_sources == 0) {
+      if (session_it->on_adopted)
+        task_runner_->PostTask(session_it->on_adopted);
+      backend.startup_sessions.erase(session_it);
+    }
+    return;
+  }
+
+  StartDataSourceImpl(ds);
+}
+
+void TracingMuxerImpl::StartDataSourceImpl(const FindDataSourceRes& ds) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+
+  DataSourceBase::StartArgs start_args{};
+  start_args.internal_instance_index = ds.instance_idx;
+
+  std::unique_lock<std::recursive_mutex> lock(ds.internal_state->lock);
+  if (ds.internal_state->interceptor)
+    ds.internal_state->interceptor->OnStart({});
+  ds.internal_state->trace_lambda_enabled.store(true,
+                                                std::memory_order_relaxed);
+  PERFETTO_DCHECK(ds.internal_state->data_source != nullptr);
+
+  if (!ds.requires_callbacks_under_lock)
+    lock.unlock();
+  ds.internal_state->data_source->OnStart(start_args);
+}
+
+// Called by the service of one of the backends.
+void TracingMuxerImpl::StopDataSource_AsyncBegin(
+    TracingBackendId backend_id,
+    DataSourceInstanceID instance_id) {
+  PERFETTO_DLOG("Stopping data source %" PRIu64, instance_id);
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+
+  auto ds = FindDataSource(backend_id, instance_id);
+  if (!ds) {
+    PERFETTO_ELOG("Could not find data source to stop");
+    return;
+  }
+
+  StopDataSource_AsyncBeginImpl(ds);
+}
+
+void TracingMuxerImpl::StopDataSource_AsyncBeginImpl(
+    const FindDataSourceRes& ds) {
+  TracingBackendId backend_id = ds.internal_state->backend_id;
+  uint32_t backend_connection_id = ds.internal_state->backend_connection_id;
+  DataSourceInstanceID instance_id = ds.internal_state->data_source_instance_id;
+
+  StopArgsImpl stop_args{};
+  stop_args.internal_instance_index = ds.instance_idx;
+  stop_args.async_stop_closure = [this, backend_id, backend_connection_id,
+                                  instance_id, ds] {
+    // TracingMuxerImpl is long lived, capturing |this| is okay.
+    // The notification closure can be moved out of the StopArgs by the
+    // embedder to handle stop asynchronously. The embedder might then
+    // call the closure on a different thread than the current one, hence
+    // this nested PostTask().
+    task_runner_->PostTask(
+        [this, backend_id, backend_connection_id, instance_id, ds] {
+          StopDataSource_AsyncEnd(backend_id, backend_connection_id,
+                                  instance_id, ds);
+        });
+  };
+
+  {
+    std::unique_lock<std::recursive_mutex> lock(ds.internal_state->lock);
+
+    // Don't call OnStop again if the datasource is already stopping.
+    if (ds.internal_state->async_stop_in_progress)
+      return;
+    ds.internal_state->async_stop_in_progress = true;
+
+    if (ds.internal_state->interceptor)
+      ds.internal_state->interceptor->OnStop({});
+
+    if (!ds.requires_callbacks_under_lock)
+      lock.unlock();
+    ds.internal_state->data_source->OnStop(stop_args);
+  }
+
+  // If the embedder hasn't called StopArgs.HandleStopAsynchronously() run the
+  // async closure here. In theory we could avoid the PostTask and call
+  // straight into CompleteDataSourceAsyncStop(). We keep that to reduce
+  // divergencies between the deferred-stop vs non-deferred-stop code paths.
+  if (stop_args.async_stop_closure)
+    std::move(stop_args.async_stop_closure)();
+}
+
+void TracingMuxerImpl::StopDataSource_AsyncEnd(TracingBackendId backend_id,
+                                               uint32_t backend_connection_id,
+                                               DataSourceInstanceID instance_id,
+                                               const FindDataSourceRes& ds) {
+  PERFETTO_DLOG("Ending async stop of data source %" PRIu64, instance_id);
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+
+  // Check that the data source instance is still active and was not modified
+  // while it was being stopped.
+  if (!ds.static_state->TryGet(ds.instance_idx) ||
+      ds.internal_state->backend_id != backend_id ||
+      ds.internal_state->backend_connection_id != backend_connection_id ||
+      ds.internal_state->data_source_instance_id != instance_id) {
+    PERFETTO_ELOG(
+        "Async stop of data source %" PRIu64
+        " failed. This might be due to calling the async_stop_closure twice.",
+        instance_id);
+    return;
+  }
+
+  const uint32_t mask = ~(1U << ds.instance_idx);
+  ds.static_state->valid_instances.fetch_and(mask, std::memory_order_acq_rel);
+
+  bool will_notify_on_stop;
+  // Take the mutex to prevent that the data source is in the middle of
+  // a Trace() execution where it called GetDataSourceLocked() while we
+  // destroy it.
+  uint16_t startup_buffer_reservation;
+  TracingSessionGlobalID startup_session_id;
+  {
+    std::lock_guard<std::recursive_mutex> guard(ds.internal_state->lock);
+    ds.internal_state->trace_lambda_enabled.store(false,
+                                                  std::memory_order_relaxed);
+    ds.internal_state->data_source.reset();
+    ds.internal_state->interceptor.reset();
+    ds.internal_state->config.reset();
+    ds.internal_state->async_stop_in_progress = false;
+    will_notify_on_stop = ds.internal_state->will_notify_on_stop;
+    startup_buffer_reservation =
+        ds.internal_state->startup_target_buffer_reservation.load(
+            std::memory_order_relaxed);
+    startup_session_id = ds.internal_state->startup_session_id;
+  }
+
+  // The other fields of internal_state are deliberately *not* cleared.
+  // See races-related comments of DataSource::Trace().
+
+  TracingMuxer::generation_++;
+
+  // |producer_backends_| is append-only, Backend instances are always valid.
+  PERFETTO_CHECK(backend_id < producer_backends_.size());
+  RegisteredProducerBackend& backend = *FindProducerBackendById(backend_id);
+  ProducerImpl* producer = backend.producer.get();
+  if (!producer)
+    return;
+
+  // If the data source instance still has a startup buffer reservation, it was
+  // only active for startup tracing and never started by the service. Discard
+  // the startup buffer reservation.
+  if (startup_buffer_reservation) {
+    PERFETTO_DCHECK(startup_session_id);
+
+    if (producer->service_ && producer->service_->MaybeSharedMemoryArbiter()) {
+      producer->service_->MaybeSharedMemoryArbiter()
+          ->AbortStartupTracingForReservation(startup_buffer_reservation);
+    }
+
+    auto session_it = std::find_if(
+        backend.startup_sessions.begin(), backend.startup_sessions.end(),
+        [startup_session_id](const RegisteredStartupSession& session) {
+          return session.session_id == startup_session_id;
+        });
+
+    // Session should not be removed until abortion of all data source instances
+    // is complete.
+    PERFETTO_DCHECK(session_it != backend.startup_sessions.end());
+
+    session_it->num_aborting_data_sources--;
+    if (session_it->num_aborting_data_sources == 0) {
+      if (session_it->on_aborted)
+        task_runner_->PostTask(session_it->on_aborted);
+
+      backend.startup_sessions.erase(session_it);
+    }
+  }
+
+  if (producer->connected_ &&
+      backend.producer->connection_id_.load(std::memory_order_relaxed) ==
+          backend_connection_id) {
+    // Flush any commits that might have been batched by SharedMemoryArbiter.
+    producer->service_->MaybeSharedMemoryArbiter()
+        ->FlushPendingCommitDataRequests();
+    if (instance_id && will_notify_on_stop)
+      producer->service_->NotifyDataSourceStopped(instance_id);
+  }
+  producer->SweepDeadServices();
+  base::MaybeReleaseAllocatorMemToOS();
+}
+
+void TracingMuxerImpl::ClearDataSourceIncrementalState(
+    TracingBackendId backend_id,
+    DataSourceInstanceID instance_id) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  PERFETTO_DLOG("Clearing incremental state for data source %" PRIu64,
+                instance_id);
+  auto ds = FindDataSource(backend_id, instance_id);
+  if (!ds) {
+    PERFETTO_ELOG("Could not find data source to clear incremental state for");
+    return;
+  }
+
+  DataSourceBase::ClearIncrementalStateArgs clear_incremental_state_args;
+  clear_incremental_state_args.internal_instance_index = ds.instance_idx;
+  {
+    std::unique_lock<std::recursive_mutex> lock;
+    if (ds.requires_callbacks_under_lock)
+      lock = std::unique_lock<std::recursive_mutex>(ds.internal_state->lock);
+    ds.internal_state->data_source->WillClearIncrementalState(
+        clear_incremental_state_args);
+  }
+
+  // Make DataSource::TraceContext::GetIncrementalState() eventually notice that
+  // the incremental state should be cleared.
+  ds.static_state->GetUnsafe(ds.instance_idx)
+      ->incremental_state_generation.fetch_add(1, std::memory_order_relaxed);
+}
+
+bool TracingMuxerImpl::FlushDataSource_AsyncBegin(
+    TracingBackendId backend_id,
+    DataSourceInstanceID instance_id,
+    FlushRequestID flush_id,
+    FlushFlags flush_flags) {
+  PERFETTO_DLOG("Flushing data source %" PRIu64, instance_id);
+  auto ds = FindDataSource(backend_id, instance_id);
+  if (!ds) {
+    PERFETTO_ELOG("Could not find data source to flush");
+    return true;
+  }
+
+  uint32_t backend_connection_id = ds.internal_state->backend_connection_id;
+
+  FlushArgsImpl flush_args;
+  flush_args.flush_flags = flush_flags;
+  flush_args.internal_instance_index = ds.instance_idx;
+  flush_args.async_flush_closure = [this, backend_id, backend_connection_id,
+                                    instance_id, ds, flush_id] {
+    // TracingMuxerImpl is long lived, capturing |this| is okay.
+    // The notification closure can be moved out of the StopArgs by the
+    // embedder to handle stop asynchronously. The embedder might then
+    // call the closure on a different thread than the current one, hence
+    // this nested PostTask().
+    task_runner_->PostTask(
+        [this, backend_id, backend_connection_id, instance_id, ds, flush_id] {
+          FlushDataSource_AsyncEnd(backend_id, backend_connection_id,
+                                   instance_id, ds, flush_id);
+        });
+  };
+  {
+    std::unique_lock<std::recursive_mutex> lock;
+    if (ds.requires_callbacks_under_lock)
+      lock = std::unique_lock<std::recursive_mutex>(ds.internal_state->lock);
+    ds.internal_state->data_source->OnFlush(flush_args);
+  }
+
+  // |async_flush_closure| is moved out of |flush_args| if the producer
+  // requested to handle the flush asynchronously.
+  bool handled = static_cast<bool>(flush_args.async_flush_closure);
+  return handled;
+}
+
+void TracingMuxerImpl::FlushDataSource_AsyncEnd(
+    TracingBackendId backend_id,
+    uint32_t backend_connection_id,
+    DataSourceInstanceID instance_id,
+    const FindDataSourceRes& ds,
+    FlushRequestID flush_id) {
+  PERFETTO_DLOG("Ending async flush of data source %" PRIu64, instance_id);
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+
+  // Check that the data source instance is still active and was not modified
+  // while it was being flushed.
+  if (!ds.static_state->TryGet(ds.instance_idx) ||
+      ds.internal_state->backend_id != backend_id ||
+      ds.internal_state->backend_connection_id != backend_connection_id ||
+      ds.internal_state->data_source_instance_id != instance_id) {
+    PERFETTO_ELOG("Async flush of data source %" PRIu64
+                  " failed. This might be due to the data source being stopped "
+                  "in the meantime",
+                  instance_id);
+    return;
+  }
+
+  // |producer_backends_| is append-only, Backend instances are always valid.
+  PERFETTO_CHECK(backend_id < producer_backends_.size());
+  RegisteredProducerBackend& backend = *FindProducerBackendById(backend_id);
+
+  ProducerImpl* producer = backend.producer.get();
+  if (!producer)
+    return;
+
+  // If the tracing service disconnects and reconnects while a data source is
+  // handling a flush request, there's no point is sending the flush reply to
+  // the newly reconnected producer.
+  if (producer->connected_ &&
+      backend.producer->connection_id_.load(std::memory_order_relaxed) ==
+          backend_connection_id) {
+    producer->NotifyFlushForDataSourceDone(instance_id, flush_id);
+  }
+}
+
+void TracingMuxerImpl::SyncProducersForTesting() {
+  std::mutex mutex;
+  std::condition_variable cv;
+
+  // IPC-based producers don't report connection errors explicitly for each
+  // command, but instead with an asynchronous callback
+  // (ProducerImpl::OnDisconnected). This means that the sync command below
+  // may have completed but failed to reach the service because of a
+  // disconnection, but we can't tell until the disconnection message comes
+  // through. To guard against this, we run two whole rounds of sync round-trips
+  // before returning; the first one will detect any disconnected producers and
+  // the second one will ensure any reconnections have completed and all data
+  // sources are registered in the service again.
+  for (size_t i = 0; i < 2; i++) {
+    size_t countdown = std::numeric_limits<size_t>::max();
+    task_runner_->PostTask([this, &mutex, &cv, &countdown] {
+      {
+        std::unique_lock<std::mutex> countdown_lock(mutex);
+        countdown = producer_backends_.size();
+      }
+      for (auto& backend : producer_backends_) {
+        auto* producer = backend.producer.get();
+        producer->service_->Sync([&mutex, &cv, &countdown] {
+          std::unique_lock<std::mutex> countdown_lock(mutex);
+          countdown--;
+          cv.notify_one();
+        });
+      }
+    });
+
+    {
+      std::unique_lock<std::mutex> countdown_lock(mutex);
+      cv.wait(countdown_lock, [&countdown] { return !countdown; });
+    }
+  }
+
+  // Check that all producers are indeed connected.
+  bool done = false;
+  bool all_producers_connected = true;
+  task_runner_->PostTask([this, &mutex, &cv, &done, &all_producers_connected] {
+    for (auto& backend : producer_backends_)
+      all_producers_connected &= backend.producer->connected_;
+    std::unique_lock<std::mutex> lock(mutex);
+    done = true;
+    cv.notify_one();
+  });
+
+  {
+    std::unique_lock<std::mutex> lock(mutex);
+    cv.wait(lock, [&done] { return done; });
+  }
+  PERFETTO_DCHECK(all_producers_connected);
+}
+
+void TracingMuxerImpl::DestroyStoppedTraceWritersForCurrentThread() {
+  // Iterate across all possible data source types.
+  auto cur_generation = generation_.load(std::memory_order_acquire);
+  auto* root_tls = GetOrCreateTracingTLS();
+
+  auto destroy_stopped_instances = [](DataSourceThreadLocalState& tls) {
+    // |tls| has a vector of per-data-source-instance thread-local state.
+    DataSourceStaticState* static_state = tls.static_state;
+    if (!static_state)
+      return;  // Slot not used.
+
+    // Iterate across all possible instances for this data source.
+    for (uint32_t inst = 0; inst < kMaxDataSourceInstances; inst++) {
+      DataSourceInstanceThreadLocalState& ds_tls = tls.per_instance[inst];
+      if (!ds_tls.trace_writer)
+        continue;
+
+      DataSourceState* ds_state = static_state->TryGet(inst);
+      if (ds_state &&
+          ds_state->muxer_id_for_testing == ds_tls.muxer_id_for_testing &&
+          ds_state->backend_id == ds_tls.backend_id &&
+          ds_state->backend_connection_id == ds_tls.backend_connection_id &&
+          ds_state->startup_target_buffer_reservation.load(
+              std::memory_order_relaxed) ==
+              ds_tls.startup_target_buffer_reservation &&
+          ds_state->buffer_id == ds_tls.buffer_id &&
+          ds_state->data_source_instance_id == ds_tls.data_source_instance_id) {
+        continue;
+      }
+
+      // The DataSource instance has been destroyed or recycled.
+      ds_tls.Reset();  // Will also destroy the |ds_tls.trace_writer|.
+    }
+  };
+
+  for (size_t ds_idx = 0; ds_idx < kMaxDataSources; ds_idx++) {
+    // |tls| has a vector of per-data-source-instance thread-local state.
+    DataSourceThreadLocalState& tls = root_tls->data_sources_tls[ds_idx];
+    destroy_stopped_instances(tls);
+  }
+  destroy_stopped_instances(root_tls->track_event_tls);
+  root_tls->generation = cur_generation;
+}
+
+// Called both when a new data source is registered or when a new backend
+// connects. In both cases we want to be sure we reflected the data source
+// registrations on the backends.
+void TracingMuxerImpl::UpdateDataSourcesOnAllBackends() {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  for (RegisteredDataSource& rds : data_sources_) {
+    UpdateDataSourceOnAllBackends(rds, /*is_changed=*/false);
+  }
+}
+
+void TracingMuxerImpl::UpdateDataSourceOnAllBackends(RegisteredDataSource& rds,
+                                                     bool is_changed) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  for (RegisteredProducerBackend& backend : producer_backends_) {
+    // We cannot call RegisterDataSource on the backend before it connects.
+    if (!backend.producer->connected_)
+      continue;
+
+    PERFETTO_DCHECK(rds.static_state->index < kMaxDataSources);
+    bool is_registered = backend.producer->registered_data_sources_.test(
+        rds.static_state->index);
+    if (is_registered && !is_changed)
+      continue;
+
+    if (!rds.descriptor.no_flush()) {
+      rds.descriptor.set_no_flush(rds.no_flush);
+    }
+    rds.descriptor.set_will_notify_on_start(true);
+    if (!rds.descriptor.has_will_notify_on_stop()) {
+      rds.descriptor.set_will_notify_on_stop(true);
+    }
+
+    rds.descriptor.set_handles_incremental_state_clear(true);
+    rds.descriptor.set_id(rds.static_state->id);
+    if (is_registered) {
+      backend.producer->service_->UpdateDataSource(rds.descriptor);
+    } else {
+      backend.producer->service_->RegisterDataSource(rds.descriptor);
+    }
+    backend.producer->registered_data_sources_.set(rds.static_state->index);
+  }
+}
+
+void TracingMuxerImpl::SetupTracingSession(
+    TracingSessionGlobalID session_id,
+    const std::shared_ptr<TraceConfig>& trace_config,
+    base::ScopedFile trace_fd) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  PERFETTO_CHECK(!trace_fd || trace_config->write_into_file());
+
+  auto* consumer = FindConsumer(session_id);
+  if (!consumer)
+    return;
+
+  consumer->trace_config_ = trace_config;
+  if (trace_fd)
+    consumer->trace_fd_ = std::move(trace_fd);
+
+  if (!consumer->connected_)
+    return;
+
+  // Only used in the deferred start mode.
+  if (trace_config->deferred_start()) {
+    consumer->service_->EnableTracing(*trace_config,
+                                      std::move(consumer->trace_fd_));
+  }
+}
+
+void TracingMuxerImpl::StartTracingSession(TracingSessionGlobalID session_id) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+
+  auto* consumer = FindConsumer(session_id);
+
+  if (!consumer)
+    return;
+
+  if (!consumer->trace_config_) {
+    PERFETTO_ELOG("Must call Setup(config) first");
+    return;
+  }
+
+  if (!consumer->connected_) {
+    consumer->start_pending_ = true;
+    return;
+  }
+
+  consumer->start_pending_ = false;
+  if (consumer->trace_config_->deferred_start()) {
+    consumer->service_->StartTracing();
+  } else {
+    consumer->service_->EnableTracing(*consumer->trace_config_,
+                                      std::move(consumer->trace_fd_));
+  }
+
+  // TODO implement support for the deferred-start + fast-triggering case.
+}
+
+void TracingMuxerImpl::CloneTracingSession(
+    TracingSessionGlobalID session_id,
+    TracingSession::CloneTraceArgs args,
+    TracingSession::CloneTraceCallback callback) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  auto* consumer = FindConsumer(session_id);
+  if (!consumer) {
+    TracingSession::CloneTraceCallbackArgs callback_arg{};
+    callback_arg.success = false;
+    callback_arg.error = "Tracing session not found";
+    callback(callback_arg);
+    return;
+  }
+  // Multiple concurrent cloning isn't supported.
+  PERFETTO_DCHECK(!consumer->clone_trace_callback_);
+  consumer->clone_trace_callback_ = std::move(callback);
+  ConsumerEndpoint::CloneSessionArgs consumer_args;
+  consumer_args.unique_session_name = args.unique_session_name;
+  if (!consumer->connected_) {
+    consumer->session_to_clone_ = std::move(consumer_args);
+    return;
+  }
+  consumer->session_to_clone_ = std::nullopt;
+  consumer->service_->CloneSession(std::move(consumer_args));
+}
+
+void TracingMuxerImpl::ChangeTracingSessionConfig(
+    TracingSessionGlobalID session_id,
+    const TraceConfig& trace_config) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+
+  auto* consumer = FindConsumer(session_id);
+
+  if (!consumer)
+    return;
+
+  if (!consumer->trace_config_) {
+    // Changing the config is only supported for started sessions.
+    PERFETTO_ELOG("Must call Setup(config) and Start() first");
+    return;
+  }
+
+  consumer->trace_config_ = std::make_shared<TraceConfig>(trace_config);
+  if (consumer->connected_)
+    consumer->service_->ChangeTraceConfig(trace_config);
+}
+
+void TracingMuxerImpl::FlushTracingSession(TracingSessionGlobalID session_id,
+                                           uint32_t timeout_ms,
+                                           std::function<void(bool)> callback) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  auto* consumer = FindConsumer(session_id);
+  if (!consumer || consumer->start_pending_ || consumer->stop_pending_ ||
+      !consumer->trace_config_) {
+    PERFETTO_ELOG("Flush() can be called only after Start() and before Stop()");
+    std::move(callback)(false);
+    return;
+  }
+
+  // For now we don't want to expose the flush reason to the consumer-side SDK
+  // users to avoid misuses until there is a strong need.
+  consumer->service_->Flush(timeout_ms, std::move(callback),
+                            FlushFlags(FlushFlags::Initiator::kConsumerSdk,
+                                       FlushFlags::Reason::kExplicit));
+}
+
+void TracingMuxerImpl::StopTracingSession(TracingSessionGlobalID session_id) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  auto* consumer = FindConsumer(session_id);
+  if (!consumer)
+    return;
+
+  if (consumer->start_pending_) {
+    // If the session hasn't started yet, wait until it does before stopping.
+    consumer->stop_pending_ = true;
+    return;
+  }
+
+  consumer->stop_pending_ = false;
+  if (consumer->stopped_) {
+    // If the session was already stopped (e.g., it failed to start), don't try
+    // stopping again.
+    consumer->NotifyStopComplete();
+  } else if (!consumer->trace_config_) {
+    PERFETTO_ELOG("Must call Setup(config) and Start() first");
+    return;
+  } else {
+    consumer->service_->DisableTracing();
+  }
+
+  consumer->trace_config_.reset();
+}
+
+void TracingMuxerImpl::DestroyTracingSession(
+    TracingSessionGlobalID session_id) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  for (RegisteredConsumerBackend& backend : consumer_backends_) {
+    // We need to find the consumer (if any) and call Disconnect as we destroy
+    // the tracing session. We can't call Disconnect() inside this for loop
+    // because in the in-process case this will end up to a synchronous call to
+    // OnConsumerDisconnect which will invalidate all the iterators to
+    // |backend.consumers|.
+    ConsumerImpl* consumer = nullptr;
+    for (auto& con : backend.consumers) {
+      if (con->session_id_ == session_id) {
+        consumer = con.get();
+        break;
+      }
+    }
+    if (consumer) {
+      // We broke out of the loop above on the assumption that each backend will
+      // only have a single consumer per session. This DCHECK ensures that
+      // this is the case.
+      PERFETTO_DCHECK(
+          std::count_if(backend.consumers.begin(), backend.consumers.end(),
+                        [session_id](const std::unique_ptr<ConsumerImpl>& con) {
+                          return con->session_id_ == session_id;
+                        }) == 1u);
+      consumer->Disconnect();
+    }
+  }
+}
+
+void TracingMuxerImpl::ReadTracingSessionData(
+    TracingSessionGlobalID session_id,
+    std::function<void(TracingSession::ReadTraceCallbackArgs)> callback) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  auto* consumer = FindConsumer(session_id);
+  if (!consumer) {
+    // TODO(skyostil): Signal an error to the user.
+    TracingSession::ReadTraceCallbackArgs callback_arg{};
+    callback(callback_arg);
+    return;
+  }
+  PERFETTO_DCHECK(!consumer->read_trace_callback_);
+  consumer->read_trace_callback_ = std::move(callback);
+  consumer->service_->ReadBuffers();
+}
+
+void TracingMuxerImpl::GetTraceStats(
+    TracingSessionGlobalID session_id,
+    TracingSession::GetTraceStatsCallback callback) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  auto* consumer = FindConsumer(session_id);
+  if (!consumer) {
+    TracingSession::GetTraceStatsCallbackArgs callback_arg{};
+    callback_arg.success = false;
+    callback(std::move(callback_arg));
+    return;
+  }
+  PERFETTO_DCHECK(!consumer->get_trace_stats_callback_);
+  consumer->get_trace_stats_callback_ = std::move(callback);
+  if (!consumer->connected_) {
+    consumer->get_trace_stats_pending_ = true;
+    return;
+  }
+  consumer->get_trace_stats_pending_ = false;
+  consumer->service_->GetTraceStats();
+}
+
+void TracingMuxerImpl::QueryServiceState(
+    TracingSessionGlobalID session_id,
+    TracingSession::QueryServiceStateCallback callback) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  auto* consumer = FindConsumer(session_id);
+  if (!consumer) {
+    TracingSession::QueryServiceStateCallbackArgs callback_arg{};
+    callback_arg.success = false;
+    callback(std::move(callback_arg));
+    return;
+  }
+  PERFETTO_DCHECK(!consumer->query_service_state_callback_);
+  if (!consumer->connected_) {
+    consumer->query_service_state_callback_ = std::move(callback);
+    return;
+  }
+  auto callback_wrapper = [callback](bool success,
+                                     protos::gen::TracingServiceState state) {
+    TracingSession::QueryServiceStateCallbackArgs callback_arg{};
+    callback_arg.success = success;
+    callback_arg.service_state_data = state.SerializeAsArray();
+    callback(std::move(callback_arg));
+  };
+  consumer->service_->QueryServiceState({}, std::move(callback_wrapper));
+}
+
+void TracingMuxerImpl::SetBatchCommitsDurationForTesting(
+    uint32_t batch_commits_duration_ms,
+    BackendType backend_type) {
+  for (RegisteredProducerBackend& backend : producer_backends_) {
+    if (backend.producer && backend.producer->connected_ &&
+        backend.type == backend_type) {
+      backend.producer->service_->MaybeSharedMemoryArbiter()
+          ->SetBatchCommitsDuration(batch_commits_duration_ms);
+    }
+  }
+}
+
+bool TracingMuxerImpl::EnableDirectSMBPatchingForTesting(
+    BackendType backend_type) {
+  for (RegisteredProducerBackend& backend : producer_backends_) {
+    if (backend.producer && backend.producer->connected_ &&
+        backend.type == backend_type &&
+        !backend.producer->service_->MaybeSharedMemoryArbiter()
+             ->EnableDirectSMBPatching()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+TracingMuxerImpl::ConsumerImpl* TracingMuxerImpl::FindConsumer(
+    TracingSessionGlobalID session_id) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  return FindConsumerAndBackend(session_id).first;
+}
+
+std::pair<TracingMuxerImpl::ConsumerImpl*,
+          TracingMuxerImpl::RegisteredConsumerBackend*>
+TracingMuxerImpl::FindConsumerAndBackend(TracingSessionGlobalID session_id) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  for (RegisteredConsumerBackend& backend : consumer_backends_) {
+    for (auto& consumer : backend.consumers) {
+      if (consumer->session_id_ == session_id) {
+        return {consumer.get(), &backend};
+      }
+    }
+  }
+  return {nullptr, nullptr};
+}
+
+void TracingMuxerImpl::InitializeConsumer(TracingSessionGlobalID session_id) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+
+  auto res = FindConsumerAndBackend(session_id);
+  if (!res.first || !res.second)
+    return;
+  TracingMuxerImpl::ConsumerImpl* consumer = res.first;
+  RegisteredConsumerBackend& backend = *res.second;
+
+  TracingBackend::ConnectConsumerArgs conn_args;
+  conn_args.consumer = consumer;
+  conn_args.task_runner = task_runner_.get();
+  consumer->Initialize(backend.backend->ConnectConsumer(conn_args));
+}
+
+void TracingMuxerImpl::OnConsumerDisconnected(ConsumerImpl* consumer) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  for (RegisteredConsumerBackend& backend : consumer_backends_) {
+    auto pred = [consumer](const std::unique_ptr<ConsumerImpl>& con) {
+      return con.get() == consumer;
+    };
+    backend.consumers.erase(std::remove_if(backend.consumers.begin(),
+                                           backend.consumers.end(), pred),
+                            backend.consumers.end());
+  }
+}
+
+void TracingMuxerImpl::SetMaxProducerReconnectionsForTesting(uint32_t count) {
+  max_producer_reconnections_.store(count);
+}
+
+void TracingMuxerImpl::OnProducerDisconnected(ProducerImpl* producer) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  for (RegisteredProducerBackend& backend : producer_backends_) {
+    if (backend.producer.get() != producer)
+      continue;
+
+    // The tracing service is disconnected. It does not make sense to keep
+    // tracing (we wouldn't be able to commit). On reconnection, the tracing
+    // service will restart the data sources.
+    for (const auto& rds : data_sources_) {
+      DataSourceStaticState* static_state = rds.static_state;
+      for (uint32_t i = 0; i < kMaxDataSourceInstances; i++) {
+        auto* internal_state = static_state->TryGet(i);
+        if (internal_state && internal_state->backend_id == backend.id &&
+            internal_state->backend_connection_id ==
+                backend.producer->connection_id_.load(
+                    std::memory_order_relaxed)) {
+          StopDataSource_AsyncBeginImpl(
+              FindDataSourceRes(static_state, internal_state, i,
+                                rds.params.requires_callbacks_under_lock));
+        }
+      }
+    }
+
+    // Try reconnecting the disconnected producer. If the connection succeeds,
+    // all the data sources will be automatically re-registered.
+    if (producer->connection_id_.load(std::memory_order_relaxed) >
+        max_producer_reconnections_.load()) {
+      // Avoid reconnecting a failing producer too many times. Instead we just
+      // leak the producer instead of trying to avoid further complicating
+      // cross-thread trace writer creation.
+      PERFETTO_ELOG("Producer disconnected too many times; not reconnecting");
+      continue;
+    }
 
-  void SetBatchCommitsDuration(uint32_t batch_commits_duration_ms) override;
+    backend.producer->Initialize(
+        backend.backend->ConnectProducer(backend.producer_conn_args));
+    // Don't use producer-provided SMBs for the next connection unless startup
+    // tracing requires it again.
+    backend.producer_conn_args.use_producer_provided_smb = false;
+  }
+}
 
-  bool EnableDirectSMBPatching() override;
+void TracingMuxerImpl::SweepDeadBackends() {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  for (auto it = dead_backends_.begin(); it != dead_backends_.end();) {
+    auto next_it = it;
+    next_it++;
+    if (it->producer->SweepDeadServices())
+      dead_backends_.erase(it);
+    it = next_it;
+  }
+}
 
-  void SetDirectSMBPatchingSupportedByService() override;
+TracingMuxerImpl::FindDataSourceRes TracingMuxerImpl::FindDataSource(
+    TracingBackendId backend_id,
+    DataSourceInstanceID instance_id) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  RegisteredProducerBackend& backend = *FindProducerBackendById(backend_id);
+  for (const auto& rds : data_sources_) {
+    DataSourceStaticState* static_state = rds.static_state;
+    for (uint32_t i = 0; i < kMaxDataSourceInstances; i++) {
+      auto* internal_state = static_state->TryGet(i);
+      if (internal_state && internal_state->backend_id == backend_id &&
+          internal_state->backend_connection_id ==
+              backend.producer->connection_id_.load(
+                  std::memory_order_relaxed) &&
+          internal_state->data_source_instance_id == instance_id) {
+        return FindDataSourceRes(static_state, internal_state, i,
+                                 rds.params.requires_callbacks_under_lock);
+      }
+    }
+  }
+  return FindDataSourceRes();
+}
 
-  void FlushPendingCommitDataRequests(
-      std::function<void()> callback = {}) override;
-  bool TryShutdown() override;
+// Can be called from any thread.
+std::unique_ptr<TraceWriterBase> TracingMuxerImpl::CreateTraceWriter(
+    DataSourceStaticState* static_state,
+    uint32_t data_source_instance_index,
+    DataSourceState* data_source,
+    BufferExhaustedPolicy buffer_exhausted_policy) {
+  if (PERFETTO_UNLIKELY(data_source->interceptor_id)) {
+    // If the session is being intercepted, return a heap-backed trace writer
+    // instead. This is safe because all the data given to the interceptor is
+    // either thread-local (|instance_index|), statically allocated
+    // (|static_state|) or constant after initialization (|interceptor|). Access
+    // to the interceptor instance itself through |data_source| is protected by
+    // a statically allocated lock (similarly to the data source instance).
+    auto& interceptor = interceptors_[data_source->interceptor_id - 1];
+    return std::unique_ptr<TraceWriterBase>(new InterceptorTraceWriter(
+        interceptor.tls_factory(static_state, data_source_instance_index),
+        interceptor.packet_callback, static_state, data_source_instance_index));
+  }
+  ProducerImpl* producer =
+      FindProducerBackendById(data_source->backend_id)->producer.get();
+  // Atomically load the current service endpoint. We keep the pointer as a
+  // shared pointer on the stack to guard against it from being concurrently
+  // modified on the thread by ProducerImpl::Initialize() swapping in a
+  // reconnected service on the muxer task runner thread.
+  //
+  // The endpoint may also be concurrently modified by SweepDeadServices()
+  // clearing out old disconnected services. We guard against that by
+  // SharedMemoryArbiter keeping track of any outstanding trace writers. After
+  // shutdown has started, the trace writer created below will be a null one
+  // which will drop any written data. See SharedMemoryArbiter::TryShutdown().
+  //
+  // We use an atomic pointer instead of holding a lock because
+  // CreateTraceWriter posts tasks under the hood.
+  std::shared_ptr<ProducerEndpoint> service =
+      std::atomic_load(&producer->service_);
 
-  base::TaskRunner* task_runner() const { return task_runner_; }
-  size_t page_size() const { return shmem_abi_.page_size(); }
-  size_t num_pages() const { return shmem_abi_.num_pages(); }
+  // The service may have been disconnected and reconnected concurrently after
+  // the data source was enabled, in which case we may not have an arbiter, or
+  // would be creating a TraceWriter for the wrong (a newer) connection / SMB.
+  // Instead, early-out now. A relaxed load is fine here because the atomic_load
+  // above ensures that the |service| isn't newer.
+  if (producer->connection_id_.load(std::memory_order_relaxed) !=
+      data_source->backend_connection_id) {
+    return std::unique_ptr<TraceWriter>(new NullTraceWriter());
+  }
 
-  base::WeakPtr<SharedMemoryArbiterImpl> GetWeakPtr() const {
-    return weak_ptr_factory_.GetWeakPtr();
+  // We just need a relaxed atomic read here: We can use the reservation ID even
+  // after the buffer was bound, we just need to be sure to read it atomically.
+  uint16_t startup_buffer_reservation =
+      data_source->startup_target_buffer_reservation.load(
+          std::memory_order_relaxed);
+  if (startup_buffer_reservation) {
+    return service->MaybeSharedMemoryArbiter()->CreateStartupTraceWriter(
+        startup_buffer_reservation);
   }
+  return service->CreateTraceWriter(data_source->buffer_id,
+                                    buffer_exhausted_policy);
+}
 
- private:
-  friend class TraceWriterImpl;
-  friend class StartupTraceWriterTest;
-  friend class SharedMemoryArbiterImplTest;
+// This is called via the public API Tracing::NewTrace().
+// Can be called from any thread.
+std::unique_ptr<TracingSession> TracingMuxerImpl::CreateTracingSession(
+    BackendType requested_backend_type,
+    TracingConsumerBackend* (*system_backend_factory)()) {
+  TracingSessionGlobalID session_id = ++next_tracing_session_id_;
 
-  struct TargetBufferReservation {
-    bool resolved = false;
-    BufferID target_buffer = kInvalidBufferId;
-  };
+  // |backend_type| can only specify one backend, not an OR-ed mask.
+  PERFETTO_CHECK((requested_backend_type & (requested_backend_type - 1)) == 0);
 
-  // Placeholder for the actual target buffer ID of a startup target buffer
-  // reservation ID in |target_buffer_reservations_|.
-  static constexpr BufferID kInvalidBufferId = 0;
+  // Capturing |this| is fine because the TracingMuxer is a leaky singleton.
+  task_runner_->PostTask([this, requested_backend_type, session_id,
+                          system_backend_factory] {
+    if (requested_backend_type == kSystemBackend && system_backend_factory &&
+        !FindConsumerBackendByType(kSystemBackend)) {
+      AddConsumerBackend(system_backend_factory(), kSystemBackend);
+    }
+    for (RegisteredConsumerBackend& backend : consumer_backends_) {
+      if (requested_backend_type && backend.type &&
+          backend.type != requested_backend_type) {
+        continue;
+      }
 
-  static SharedMemoryABI::PageLayout default_page_layout;
+      // Create the consumer now, even if we have to ask the embedder below, so
+      // that any other tasks executing after this one can find the consumer and
+      // change its pending attributes.
+      backend.consumers.emplace_back(
+          new ConsumerImpl(this, backend.type, session_id));
 
-  SharedMemoryArbiterImpl(const SharedMemoryArbiterImpl&) = delete;
-  SharedMemoryArbiterImpl& operator=(const SharedMemoryArbiterImpl&) = delete;
+      // The last registered backend in |consumer_backends_| is the unsupported
+      // backend without a valid type.
+      if (!backend.type) {
+        PERFETTO_ELOG(
+            "No tracing backend ready for type=%u, consumer will disconnect",
+            requested_backend_type);
+        InitializeConsumer(session_id);
+        return;
+      }
 
-  void UpdateCommitDataRequest(SharedMemoryABI::Chunk chunk,
-                               WriterID writer_id,
-                               MaybeUnboundBufferID target_buffer,
-                               PatchList* patch_list);
+      // Check if the embedder wants to be asked for permission before
+      // connecting the consumer.
+      if (!policy_) {
+        InitializeConsumer(session_id);
+        return;
+      }
 
-  // Search the chunks that are being batched in |commit_data_req_| for a chunk
-  // that needs patching and that matches the provided |writer_id| and
-  // |patch.chunk_id|. If found, apply |patch| to that chunk, and if
-  // |chunk_needs_more_patching| is true, clear the needs patching flag of the
-  // chunk and mark it as complete - to allow the service to read it (and other
-  // chunks after it) during scraping. Returns true if the patch was applied,
-  // false otherwise.
-  //
-  // Note: the caller must be holding |lock_| for the duration of the call.
-  bool TryDirectPatchLocked(WriterID writer_id,
-                            const Patch& patch,
-                            bool chunk_needs_more_patching);
-  std::unique_ptr<TraceWriter> CreateTraceWriterInternal(
-      MaybeUnboundBufferID target_buffer,
-      BufferExhaustedPolicy);
+      BackendType type = backend.type;
+      TracingPolicy::ShouldAllowConsumerSessionArgs args;
+      args.backend_type = backend.type;
+      args.result_callback = [this, type, session_id](bool allow) {
+        task_runner_->PostTask([this, type, session_id, allow] {
+          if (allow) {
+            InitializeConsumer(session_id);
+            return;
+          }
 
-  // Called by the TraceWriter destructor.
-  void ReleaseWriterID(WriterID);
+          PERFETTO_ELOG(
+              "Consumer session for backend type type=%u forbidden, "
+              "consumer will disconnect",
+              type);
 
-  void BindStartupTargetBufferImpl(std::unique_lock<std::mutex> scoped_lock,
-                                   uint16_t target_buffer_reservation_id,
-                                   BufferID target_buffer_id);
+          auto* consumer = FindConsumer(session_id);
+          if (!consumer)
+            return;
 
-  // If any flush callbacks were queued up while the arbiter or any target
-  // buffer reservation was unbound, this wraps the pending callbacks into a new
-  // std::function and returns it. Otherwise returns an invalid std::function.
-  std::function<void()> TakePendingFlushCallbacksLocked();
+          consumer->OnDisconnect();
+        });
+      };
+      policy_->ShouldAllowConsumerSession(args);
+      return;
+    }
+    PERFETTO_DFATAL("Not reached");
+  });
 
-  // Replace occurrences of target buffer reservation IDs in |commit_data_req_|
-  // with their respective actual BufferIDs if they were already bound. Returns
-  // true iff all occurrences were replaced.
-  bool ReplaceCommitPlaceholderBufferIdsLocked();
+  return std::unique_ptr<TracingSession>(
+      new TracingSessionImpl(this, session_id, requested_backend_type));
+}
 
-  // Update and return |fully_bound_| based on the arbiter's |pending_writers_|
-  // state.
-  bool UpdateFullyBoundLocked();
+// static
+// This is called via the public API Tracing::SetupStartupTracing().
+// Can be called from any thread.
+std::unique_ptr<StartupTracingSession>
+TracingMuxerImpl::CreateStartupTracingSession(
+    const TraceConfig& config,
+    Tracing::SetupStartupTracingOpts opts) {
+  BackendType backend_type = opts.backend;
+  // |backend_type| can only specify one backend, not an OR-ed mask.
+  PERFETTO_CHECK((backend_type & (backend_type - 1)) == 0);
+  // The in-process backend doesn't support startup tracing.
+  PERFETTO_CHECK(backend_type != BackendType::kInProcessBackend);
 
-  // Only accessed on |task_runner_| after the producer endpoint was bound.
-  TracingService::ProducerEndpoint* producer_endpoint_ = nullptr;
+  TracingSessionGlobalID session_id = ++next_tracing_session_id_;
 
-  // --- Begin lock-protected members ---
+  // Capturing |this| is fine because the TracingMuxer is a leaky singleton.
+  task_runner_->PostTask([this, config, opts, backend_type, session_id] {
+    for (RegisteredProducerBackend& backend : producer_backends_) {
+      if (backend_type && backend.type && backend.type != backend_type) {
+        continue;
+      }
 
-  std::mutex lock_;
+      TracingBackendId backend_id = backend.id;
 
-  base::TaskRunner* task_runner_ = nullptr;
-  SharedMemoryABI shmem_abi_;
-  size_t page_idx_ = 0;
-  std::unique_ptr<CommitDataRequest> commit_data_req_;
-  size_t bytes_pending_commit_ = 0;  // SUM(chunk.size() : commit_data_req_).
-  IdAllocator<WriterID> active_writer_ids_;
-  bool did_shutdown_ = false;
+      // The last registered backend in |producer_backends_| is the unsupported
+      // backend without a valid type.
+      if (!backend.type) {
+        PERFETTO_ELOG(
+            "No tracing backend initialized for type=%u, startup tracing "
+            "failed",
+            backend_type);
+        if (opts.on_setup)
+          opts.on_setup(Tracing::OnStartupTracingSetupCallbackArgs{
+              0 /* num_data_sources_started */});
+        return;
+      }
 
-  // Whether the arbiter itself and all startup target buffer reservations are
-  // bound. Note that this can become false again later if a new target buffer
-  // reservation is created by calling CreateStartupTraceWriter() with a new
-  // reservation id.
-  bool fully_bound_;
+      if (!backend.producer->service_ ||
+          !backend.producer->service_->shared_memory()) {
+        // If we unsuccessfully attempted to use a producer-provided SMB in the
+        // past, don't try again.
+        if (backend.producer->producer_provided_smb_failed_) {
+          PERFETTO_ELOG(
+              "Backend %zu doesn't seem to support producer-provided "
+              "SMBs, startup tracing failed",
+              backend_id);
+          if (opts.on_setup)
+            opts.on_setup(Tracing::OnStartupTracingSetupCallbackArgs{
+                0 /* num_data_sources_started */});
+          return;
+        }
 
-  // Whether the arbiter was always bound. If false, the arbiter was unbound at
-  // one point in time.
-  bool was_always_bound_;
+        PERFETTO_DLOG("Reconnecting backend %zu for startup tracing",
+                      backend_id);
+        backend.producer_conn_args.use_producer_provided_smb = true;
+        backend.producer->service_->Disconnect();  // Causes a reconnect.
+        PERFETTO_DCHECK(backend.producer->service_ &&
+                        backend.producer->service_->MaybeSharedMemoryArbiter());
+      }
 
-  // Whether all created trace writers were created with kDrop policy.
-  bool all_writers_have_drop_policy_ = true;
+      RegisteredStartupSession session;
+      session.session_id = session_id;
+      session.on_aborted = opts.on_aborted;
+      session.on_adopted = opts.on_adopted;
 
-  // IDs of writers and their assigned target buffers that should be registered
-  // with the service after the arbiter and/or their startup target buffer is
-  // bound.
-  std::map<WriterID, MaybeUnboundBufferID> pending_writers_;
+      for (const TraceConfig::DataSource& ds_cfg : config.data_sources()) {
+        // Find all matching data sources and start one instance of each.
+        for (const auto& rds : data_sources_) {
+          if (rds.descriptor.name() != ds_cfg.config().name())
+            continue;
 
-  // Callbacks for flush requests issued while the arbiter or a target buffer
-  // reservation was unbound.
-  std::vector<std::function<void()>> pending_flush_callbacks_;
+          PERFETTO_DLOG(
+              "Setting up data source %s for startup tracing with target "
+              "buffer reservation %" PRIi32,
+              rds.descriptor.name().c_str(),
+              backend.producer->last_startup_target_buffer_reservation_ + 1u);
+          auto ds = SetupDataSourceImpl(
+              rds, backend_id,
+              backend.producer->connection_id_.load(std::memory_order_relaxed),
+              /*instance_id=*/0, ds_cfg.config(),
+              /*startup_session_id=*/session_id);
+          if (ds) {
+            StartDataSourceImpl(ds);
+            session.num_unbound_data_sources++;
+          }
+        }
+      }
 
-  // See SharedMemoryArbiter::SetBatchCommitsDuration.
-  uint32_t batch_commits_duration_ms_ = 0;
+      int num_ds = session.num_unbound_data_sources;
+      auto on_setup = opts.on_setup;
+      if (on_setup) {
+        backend.producer->OnStartupTracingSetup();
+        task_runner_->PostTask([on_setup, num_ds] {
+          on_setup(Tracing::OnStartupTracingSetupCallbackArgs{num_ds});
+        });
+      }
 
-  // See SharedMemoryArbiter::EnableDirectSMBPatching.
-  bool direct_patching_enabled_ = false;
+      if (num_ds > 0) {
+        backend.startup_sessions.push_back(std::move(session));
 
-  // See SharedMemoryArbiter::SetDirectSMBPatchingSupportedByService.
-  bool direct_patching_supported_by_service_ = false;
+        if (opts.timeout_ms > 0) {
+          task_runner_->PostDelayedTask(
+              [this, session_id, backend_type] {
+                AbortStartupTracingSession(session_id, backend_type);
+              },
+              opts.timeout_ms);
+        }
+      }
+      return;
+    }
+    PERFETTO_DFATAL("Invalid startup tracing session backend");
+  });
 
-  // Indicates whether we have already scheduled a delayed flush for the
-  // purposes of batching. Set to true at the beginning of a batching period and
-  // cleared at the end of the period. Immediate flushes that happen during a
-  // batching period will empty the |commit_data_req| (triggering an immediate
-  // IPC to the service), but will not clear this flag and the
-  // previously-scheduled delayed flush will still occur at the end of the
-  // batching period.
-  bool delayed_flush_scheduled_ = false;
+  return std::unique_ptr<StartupTracingSession>(
+      new StartupTracingSessionImpl(this, session_id, backend_type));
+}
 
-  // Stores target buffer reservations for writers created via
-  // CreateStartupTraceWriter(). A bound reservation sets
-  // TargetBufferReservation::resolved to true and is associated with the actual
-  // BufferID supplied in BindStartupTargetBuffer().
-  //
-  // TODO(eseckler): Clean up entries from this map. This would probably require
-  // a method in SharedMemoryArbiter that allows a producer to invalidate a
-  // reservation ID.
-  std::map<MaybeUnboundBufferID, TargetBufferReservation>
-      target_buffer_reservations_;
+// Must not be called from the SDK's internal thread.
+std::unique_ptr<StartupTracingSession>
+TracingMuxerImpl::CreateStartupTracingSessionBlocking(
+    const TraceConfig& config,
+    Tracing::SetupStartupTracingOpts opts) {
+  auto previous_on_setup = std::move(opts.on_setup);
+  PERFETTO_CHECK(!task_runner_->RunsTasksOnCurrentThread());
+  base::WaitableEvent event;
+  // It is safe to capture by reference because once on_setup is called only
+  // once before this method returns.
+  opts.on_setup = [&](Tracing::OnStartupTracingSetupCallbackArgs args) {
+    if (previous_on_setup) {
+      previous_on_setup(std::move(args));
+    }
+    event.Notify();
+  };
+  auto session = CreateStartupTracingSession(config, std::move(opts));
+  event.Wait();
+  return session;
+}
 
-  // --- End lock-protected members ---
+void TracingMuxerImpl::AbortStartupTracingSession(
+    TracingSessionGlobalID session_id,
+    BackendType backend_type) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
 
-  // Keep at the end.
-  base::WeakPtrFactory<SharedMemoryArbiterImpl> weak_ptr_factory_;
-};
+  for (RegisteredProducerBackend& backend : producer_backends_) {
+    if (backend_type != backend.type)
+      continue;
 
-}  // namespace perfetto
+    auto session_it = std::find_if(
+        backend.startup_sessions.begin(), backend.startup_sessions.end(),
+        [session_id](const RegisteredStartupSession& session) {
+          return session.session_id == session_id;
+        });
 
-#endif  // SRC_TRACING_CORE_SHARED_MEMORY_ARBITER_IMPL_H_
-// gen_amalgamated begin header: include/perfetto/ext/tracing/core/commit_data_request.h
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+    // The startup session may have already been aborted or fully adopted.
+    if (session_it == backend.startup_sessions.end())
+      return;
+    if (session_it->is_aborting)
+      return;
 
-#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_COMMIT_DATA_REQUEST_H_
-#define INCLUDE_PERFETTO_EXT_TRACING_CORE_COMMIT_DATA_REQUEST_H_
+    session_it->is_aborting = true;
 
-// Creates the aliases in the ::perfetto namespace, doing things like:
-// using ::perfetto::Foo = ::perfetto::protos::gen::Foo.
-// See comments in forward_decls.h for the historical reasons of this
-// indirection layer.
-// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
+    // Iterate all data sources and abort them if they weren't adopted yet.
+    for (const auto& rds : data_sources_) {
+      DataSourceStaticState* static_state = rds.static_state;
+      for (uint32_t i = 0; i < kMaxDataSourceInstances; i++) {
+        auto* internal_state = static_state->TryGet(i);
+        if (internal_state &&
+            internal_state->startup_target_buffer_reservation.load(
+                std::memory_order_relaxed) &&
+            internal_state->data_source_instance_id == 0 &&
+            internal_state->startup_session_id == session_id) {
+          PERFETTO_DLOG(
+              "Aborting startup tracing for data source %s (target buffer "
+              "reservation %" PRIu16 ")",
+              rds.descriptor.name().c_str(),
+              internal_state->startup_target_buffer_reservation.load(
+                  std::memory_order_relaxed));
 
-// gen_amalgamated expanded: #include "protos/perfetto/common/commit_data_request.gen.h"
+          // Abort the instance asynchronously by stopping it. From this point
+          // onwards, the service will not be able to adopt it via
+          // StartDataSource().
+          session_it->num_aborting_data_sources++;
+          StopDataSource_AsyncBeginImpl(
+              FindDataSourceRes(static_state, internal_state, i,
+                                rds.params.requires_callbacks_under_lock));
+        }
+      }
+    }
 
-#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_COMMIT_DATA_REQUEST_H_
-// gen_amalgamated begin header: src/tracing/core/trace_writer_impl.h
-// gen_amalgamated begin header: src/tracing/core/patch_list.h
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+    // If we did everything right, we should have aborted all still-unbound data
+    // source instances.
+    PERFETTO_DCHECK(session_it->num_unbound_data_sources ==
+                    session_it->num_aborting_data_sources);
 
-#ifndef SRC_TRACING_CORE_PATCH_LIST_H_
-#define SRC_TRACING_CORE_PATCH_LIST_H_
+    if (session_it->num_aborting_data_sources == 0) {
+      if (session_it->on_aborted)
+        task_runner_->PostTask(session_it->on_aborted);
 
-#include <array>
-#include <forward_list>
+      backend.startup_sessions.erase(session_it);
+    }
+    return;
+  }
+  // We might reach here in tests because when we start a trace, we post the
+  // Task(AbortStartupTrace, delay=timeout). When we do
+  // perfetto::ResetForTesting, we sweep dead backends, and we are not able to
+  // kill those delayed tasks because TaskRunner doesn't have support for
+  // deleting scheduled future tasks and TaskRunner doesn't have any API for us
+  // to wait for the completion of all the scheduled tasks (apart from
+  // deleting the TaskRunner) and we want to avoid doing that because we need
+  // a long running TaskRunner in muxer.
+  PERFETTO_DLOG("Invalid startup tracing session backend");
+}
+
+void TracingMuxerImpl::InitializeInstance(const TracingInitArgs& args) {
+  if (instance_ != TracingMuxerFake::Get()) {
+    // The tracing muxer was already initialized. We might need to initialize
+    // additional backends that were not configured earlier.
+    auto* muxer = static_cast<TracingMuxerImpl*>(instance_);
+    muxer->task_runner_->PostTask([muxer, args] { muxer->AddBackends(args); });
+    return;
+  }
+  // If we previously had a TracingMuxerImpl instance which was reset,
+  // reinitialize and reuse it instead of trying to create a new one. See
+  // ResetForTesting().
+  if (g_prev_instance) {
+    auto* muxer = g_prev_instance;
+    g_prev_instance = nullptr;
+    instance_ = muxer;
+    muxer->task_runner_->PostTask([muxer, args] {
+      muxer->Initialize(args);
+      muxer->AddBackends(args);
+    });
+  } else {
+    new TracingMuxerImpl(args);
+  }
+}
 
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_abi.h"
+// static
+void TracingMuxerImpl::ResetForTesting() {
+  // Ideally we'd tear down the entire TracingMuxerImpl, but the lifetimes of
+  // various objects make that a non-starter. In particular:
+  //
+  // 1) Any thread that has entered a trace event has a TraceWriter, which holds
+  //    a reference back to ProducerImpl::service_.
+  //
+  // 2) ProducerImpl::service_ has a reference back to the ProducerImpl.
+  //
+  // 3) ProducerImpl holds reference to TracingMuxerImpl::task_runner_, which in
+  //    turn depends on TracingMuxerImpl itself.
+  //
+  // Because of this, it's not safe to deallocate TracingMuxerImpl until all
+  // threads have dropped their TraceWriters. Since we can't really ask the
+  // caller to guarantee this, we'll instead reset enough of the muxer's state
+  // so that it can be reinitialized later and ensure all necessary objects from
+  // the old state remain alive until all references have gone away.
+  auto* muxer = reinterpret_cast<TracingMuxerImpl*>(instance_);
 
-namespace perfetto {
+  base::WaitableEvent reset_done;
+  auto do_reset = [muxer, &reset_done] {
+    muxer->DestroyStoppedTraceWritersForCurrentThread();
+    // Unregister all data sources so they don't interfere with any future
+    // tracing sessions.
+    for (RegisteredDataSource& rds : muxer->data_sources_) {
+      for (RegisteredProducerBackend& backend : muxer->producer_backends_) {
+        if (!backend.producer->service_ || !backend.producer->connected_)
+          continue;
+        backend.producer->service_->UnregisterDataSource(rds.descriptor.name());
+      }
+    }
+    for (auto& backend : muxer->consumer_backends_) {
+      // Check that no consumer session is currently active on any backend.
+      for (auto& consumer : backend.consumers)
+        PERFETTO_CHECK(!consumer->service_);
+    }
+    for (auto& backend : muxer->producer_backends_) {
+      backend.producer->muxer_ = nullptr;
+      backend.producer->DisposeConnection();
+      muxer->dead_backends_.push_back(std::move(backend));
+    }
+    muxer->consumer_backends_.clear();
+    muxer->producer_backends_.clear();
+    muxer->interceptors_.clear();
 
-// Used to handle the backfilling of the headers (the |size_field|) of nested
-// messages when a proto is fragmented over several chunks. These patches are
-// sent out-of-band to the tracing service, after having returned the initial
-// chunks of the fragment.
-// TODO(crbug.com/904477): Re-disable the move constructors when all usses of
-// this class have been fixed.
-class Patch {
- public:
-  using PatchContent = std::array<uint8_t, SharedMemoryABI::kPacketHeaderSize>;
-  Patch(ChunkID c, uint16_t o) : chunk_id(c), offset(o) {}
-  Patch(const Patch&) = default;  // For tests.
+    for (auto& ds : muxer->data_sources_) {
+      ds.static_state->ResetForTesting();
+    }
 
-  const ChunkID chunk_id;
-  const uint16_t offset;
-  PatchContent size_field{};
+    muxer->data_sources_.clear();
+    muxer->next_data_source_index_ = 0;
 
-  // |size_field| contains a varint. Any varint must start with != 0. Even in
-  // the case we want to encode a size == 0, protozero will write a redundant
-  // varint for that, that is [0x80, 0x80, 0x80, 0x00]. So the first byte is 0
-  // iff we never wrote any varint into that.
-  bool is_patched() const { return size_field[0] != 0; }
+    // Free all backends without active trace writers or other inbound
+    // references. Note that even if all the backends get swept, the muxer still
+    // needs to stay around since |task_runner_| is assumed to be long-lived.
+    muxer->SweepDeadBackends();
 
-  // For tests.
-  bool operator==(const Patch& o) const {
-    return chunk_id == o.chunk_id && offset == o.offset &&
-           size_field == o.size_field;
-  }
+    // Make sure we eventually discard any per-thread trace writers from the
+    // previous instance.
+    muxer->muxer_id_for_testing_++;
 
- private:
-  Patch& operator=(const Patch&) = delete;
-};
+    g_prev_instance = muxer;
+    instance_ = TracingMuxerFake::Get();
 
-// Note: the protozero::Message(s) will take pointers to the |size_field| of
-// these entries. This container must guarantee that the Patch objects are never
-// moved around (i.e. cannot be a vector because of reallocations can change
-// addresses of pre-existing entries).
-class PatchList {
- public:
-  using ListType = std::forward_list<Patch>;
-  using value_type = ListType::value_type;          // For gtest.
-  using const_iterator = ListType::const_iterator;  // For gtest.
+    // Call the user provided cleanups on the muxer thread.
+    for (auto& cb : muxer->reset_callbacks_) {
+      cb();
+    }
 
-  PatchList() : last_(list_.before_begin()) {}
+    reset_done.Notify();
+  };
 
-  Patch* emplace_back(ChunkID chunk_id, uint16_t offset) {
-    last_ = list_.emplace_after(last_, chunk_id, offset);
-    return &*last_;
+  // Some tests run the muxer and the test on the same thread. In these cases,
+  // we can reset synchronously.
+  if (muxer->task_runner_->RunsTasksOnCurrentThread()) {
+    do_reset();
+  } else {
+    muxer->DestroyStoppedTraceWritersForCurrentThread();
+    muxer->task_runner_->PostTask(std::move(do_reset));
+    reset_done.Wait();
+    // Call the user provided cleanups also on this thread.
+    for (auto& cb : muxer->reset_callbacks_) {
+      cb();
+    }
   }
+  muxer->reset_callbacks_.clear();
+}
 
-  void pop_front() {
-    PERFETTO_DCHECK(!list_.empty());
-    list_.pop_front();
-    if (empty())
-      last_ = list_.before_begin();
-  }
+// static
+void TracingMuxerImpl::Shutdown() {
+  auto* muxer = reinterpret_cast<TracingMuxerImpl*>(instance_);
 
-  const Patch& front() const {
-    PERFETTO_DCHECK(!list_.empty());
-    return list_.front();
-  }
+  // Shutting down on the muxer thread would lead to a deadlock.
+  PERFETTO_CHECK(!muxer->task_runner_->RunsTasksOnCurrentThread());
+  muxer->DestroyStoppedTraceWritersForCurrentThread();
 
-  const Patch& back() const {
-    PERFETTO_DCHECK(!list_.empty());
-    return *last_;
-  }
+  std::unique_ptr<base::TaskRunner> owned_task_runner(
+      muxer->task_runner_.get());
+  base::WaitableEvent shutdown_done;
+  owned_task_runner->PostTask([muxer, &shutdown_done] {
+    // Check that no consumer session is currently active on any backend.
+    // Producers will be automatically disconnected as a part of deleting the
+    // muxer below.
+    for (auto& backend : muxer->consumer_backends_) {
+      for (auto& consumer : backend.consumers) {
+        PERFETTO_CHECK(!consumer->service_);
+      }
+    }
+    // Make sure no trace writers are lingering around on the muxer thread. Note
+    // that we can't do this for any arbitrary thread in the process; it is the
+    // caller's responsibility to clean them up before shutting down Perfetto.
+    muxer->DestroyStoppedTraceWritersForCurrentThread();
+    // The task runner must be deleted outside the muxer thread. This is done by
+    // `owned_task_runner` above.
+    muxer->task_runner_.release();
+    auto* platform = muxer->platform_;
+    delete muxer;
+    instance_ = TracingMuxerFake::Get();
+    platform->Shutdown();
+    shutdown_done.Notify();
+  });
+  shutdown_done.Wait();
+}
 
-  ListType::const_iterator begin() const { return list_.begin(); }
-  ListType::const_iterator end() const { return list_.end(); }
-  bool empty() const { return list_.empty(); }
+void TracingMuxerImpl::AppendResetForTestingCallback(std::function<void()> cb) {
+  reset_callbacks_.push_back(std::move(cb));
+}
 
- private:
-  ListType list_;
-  ListType::iterator last_;
-};
+TracingMuxer::~TracingMuxer() = default;
 
-}  // namespace perfetto
+static_assert(std::is_same<internal::BufferId, BufferID>::value,
+              "public's BufferId and tracing/core's BufferID diverged");
 
-#endif  // SRC_TRACING_CORE_PATCH_LIST_H_
+}  // namespace internal
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/internal/track_event_internal.cc
+// gen_amalgamated begin header: include/perfetto/ext/base/no_destructor.h
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -40694,161 +46703,70 @@ class PatchList {
  * limitations under the License.
  */
 
-#ifndef SRC_TRACING_CORE_TRACE_WRITER_IMPL_H_
-#define SRC_TRACING_CORE_TRACE_WRITER_IMPL_H_
+#ifndef INCLUDE_PERFETTO_EXT_BASE_NO_DESTRUCTOR_H_
+#define INCLUDE_PERFETTO_EXT_BASE_NO_DESTRUCTOR_H_
 
-// gen_amalgamated expanded: #include "perfetto/base/proc_utils.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_abi.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_arbiter.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message_handle.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/root_message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_stream_writer.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/buffer_exhausted_policy.h"
-// gen_amalgamated expanded: #include "src/tracing/core/patch_list.h"
+#include <new>
+#include <utility>
 
 namespace perfetto {
+namespace base {
 
-class SharedMemoryArbiterImpl;
-
-// See //include/perfetto/ext/tracing/core/trace_writer.h for docs.
+// Wrapper that can hold an object of type T, without invoking the contained
+// object's destructor when being destroyed. Useful for creating statics while
+// avoiding static destructors.
 //
-// Locking will happen only when a chunk is exhausted and a new one is
-// acquired from the arbiter.
+// Stores the object inline, and therefore doesn't incur memory allocation and
+// pointer indirection overheads.
 //
-// TODO: TraceWriter needs to keep the shared memory buffer alive (refcount?).
-// Otherwise if the shared memory buffer goes away (e.g. the Service crashes)
-// the TraceWriter will keep writing into unmapped memory.
+// Example of use:
 //
-class TraceWriterImpl : public TraceWriter,
-                        public protozero::ScatteredStreamWriter::Delegate {
+//   const std::string& GetStr() {
+//     static base::NoDestructor<std::string> s("hello");
+//     return s.ref();
+//   }
+//
+template <typename T>
+class NoDestructor {
  public:
-  // TracePacketHandle is defined in trace_writer.h
-  TraceWriterImpl(SharedMemoryArbiterImpl*,
-                  WriterID,
-                  MaybeUnboundBufferID buffer_id,
-                  BufferExhaustedPolicy);
-  ~TraceWriterImpl() override;
-
-  // TraceWriter implementation. See documentation in trace_writer.h.
-  TracePacketHandle NewTracePacket() override;
-  void FinishTracePacket() override;
-  // Commits the data pending for the current chunk into the shared memory
-  // buffer and sends a CommitDataRequest() to the service.
-  // TODO(primiano): right now the |callback| will be called on the IPC thread.
-  // This is fine in the current single-thread scenario, but long-term
-  // trace_writer_impl.cc should be smarter and post it on the right thread.
-  void Flush(std::function<void()> callback = {}) override;
-  WriterID writer_id() const override;
-  uint64_t written() const override {
-    return protobuf_stream_writer_.written();
+  // Forward arguments to T's constructor. Note that this doesn't cover
+  // construction from initializer lists.
+  template <typename... Args>
+  explicit NoDestructor(Args&&... args) {
+    new (storage_) T(std::forward<Args>(args)...);
   }
 
-  void ResetChunkForTesting() { cur_chunk_ = SharedMemoryABI::Chunk(); }
-  bool drop_packets_for_testing() const { return drop_packets_; }
-
- private:
-  TraceWriterImpl(const TraceWriterImpl&) = delete;
-  TraceWriterImpl& operator=(const TraceWriterImpl&) = delete;
-
-  // ScatteredStreamWriter::Delegate implementation.
-  protozero::ContiguousMemoryRange GetNewBuffer() override;
-  uint8_t* AnnotatePatch(uint8_t*) override;
-
-  // The per-producer arbiter that coordinates access to the shared memory
-  // buffer from several threads.
-  SharedMemoryArbiterImpl* const shmem_arbiter_;
-
-  // ID of the current writer.
-  const WriterID id_;
-
-  // This is copied into the commit request by SharedMemoryArbiter. See comments
-  // in data_source_config.proto for |target_buffer|. If this is a reservation
-  // for a buffer ID in case of a startup trace writer, SharedMemoryArbiterImpl
-  // will also translate the reservation ID to the actual buffer ID.
-  const MaybeUnboundBufferID target_buffer_;
-
-  // Whether GetNewChunk() should stall or return an invalid chunk if the SMB is
-  // exhausted.
-  const BufferExhaustedPolicy buffer_exhausted_policy_;
-
-  // Monotonic (% wrapping) sequence id of the chunk. Together with the WriterID
-  // this allows the Service to reconstruct the linear sequence of packets.
-  ChunkID next_chunk_id_ = 0;
-
-  // The chunk we are holding onto (if any).
-  SharedMemoryABI::Chunk cur_chunk_;
-
-  // Passed to protozero message to write directly into |cur_chunk_|. It
-  // keeps track of the write pointer. It calls us back (GetNewBuffer()) when
-  // |cur_chunk_| is filled.
-  protozero::ScatteredStreamWriter protobuf_stream_writer_;
-
-  // The packet returned via NewTracePacket(). Its owned by this class,
-  // TracePacketHandle has just a pointer to it.
-  //
-  // The caller of NewTracePacket can use TakeStreamWriter() and use the stream
-  // writer directly: in that case:
-  // * cur_packet_->size() is not up to date. Only the stream writer has the
-  //   correct information.
-  // * cur_packet_->nested_message() is always nullptr.
-  // * cur_packet_->size_field() is still used to track the start of the current
-  //   fragment.
-  std::unique_ptr<protozero::RootMessage<protos::pbzero::TracePacket>>
-      cur_packet_;
-
-  // The start address of |cur_packet_| within |cur_chunk_|. Used to figure out
-  // fragments sizes when a TracePacket write is interrupted by GetNewBuffer().
-  uint8_t* cur_fragment_start_ = nullptr;
-
-  // true if we received a call to GetNewBuffer() after NewTracePacket(),
-  // false if GetNewBuffer() happened during NewTracePacket() prologue, while
-  // starting the TracePacket header.
-  bool fragmenting_packet_ = false;
-
-  // Set to |true| when the current chunk contains the maximum number of packets
-  // a chunk can contain. When this is |true|, the next packet requires starting
-  // a new chunk.
-  bool reached_max_packets_per_chunk_ = false;
-
-  // If we fail to acquire a new chunk when the arbiter operates in
-  // SharedMemory::BufferExhaustedPolicy::kDrop mode, the trace writer enters a
-  // mode in which data is written to a local garbage chunk and dropped.
-  bool drop_packets_ = false;
-
-  // Whether the trace writer should try to acquire a new chunk from the SMB
-  // when the next TracePacket is started because it filled the garbage chunk at
-  // least once since the last attempt.
-  bool retry_new_chunk_after_packet_ = false;
-
-  // Points to the size field of the last packet we wrote to the current chunk.
-  // If the chunk was already returned, this is reset to |nullptr|.
-  uint8_t* last_packet_size_field_ = nullptr;
+  NoDestructor(const NoDestructor&) = delete;
+  NoDestructor& operator=(const NoDestructor&) = delete;
+  NoDestructor(NoDestructor&&) = delete;
+  NoDestructor& operator=(NoDestructor&&) = delete;
 
-  // When a packet is fragmented across different chunks, the |size_field| of
-  // the outstanding nested protobuf messages is redirected onto Patch entries
-  // in this list at the time the Chunk is returned (because at that point we
-  // have to release the ownership of the current Chunk). This list will be
-  // later sent out-of-band to the tracing service, who will patch the required
-  // chunks, if they are still around.
-  PatchList patch_list_;
+  ~NoDestructor() = default;
 
-  // PID of the process that created the trace writer. Used for a DCHECK that
-  // aims to detect unsupported process forks while tracing.
-  const base::PlatformProcessId process_id_;
+  /* To avoid type-punned pointer strict aliasing warnings on GCC6 and below
+   * these need to be split over two lines. If they are collapsed onto one line.
+   *   return reinterpret_cast<const T*>(storage_);
+   * The error fires.
+   */
+  const T& ref() const {
+    auto* const cast = reinterpret_cast<const T*>(storage_);
+    return *cast;
+  }
+  T& ref() {
+    auto* const cast = reinterpret_cast<T*>(storage_);
+    return *cast;
+  }
 
-  // True for the first packet on sequence. See the comment for
-  // TracePacket.first_packet_on_sequence for more details.
-  bool first_packet_on_sequence_ = true;
+ private:
+  alignas(T) char storage_[sizeof(T)];
 };
 
+}  // namespace base
 }  // namespace perfetto
 
-#endif  // SRC_TRACING_CORE_TRACE_WRITER_IMPL_H_
+#endif  // INCLUDE_PERFETTO_EXT_BASE_NO_DESTRUCTOR_H_
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -40863,927 +46781,765 @@ class TraceWriterImpl : public TraceWriter,
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "src/tracing/core/shared_memory_arbiter_impl.h"
-
-#include <algorithm>
-#include <limits>
-#include <utility>
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/track_event_internal.h"
 
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
+// gen_amalgamated expanded: #include "perfetto/base/proc_utils.h"
 // gen_amalgamated expanded: #include "perfetto/base/time.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/commit_data_request.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory.h"
-// gen_amalgamated expanded: #include "src/tracing/core/null_trace_writer.h"
-// gen_amalgamated expanded: #include "src/tracing/core/trace_writer_impl.h"
-
-namespace perfetto {
-
-using Chunk = SharedMemoryABI::Chunk;
-
-namespace {
-static_assert(sizeof(BufferID) == sizeof(uint16_t),
-              "The MaybeUnboundBufferID logic requires BufferID not to grow "
-              "above uint16_t.");
-
-MaybeUnboundBufferID MakeTargetBufferIdForReservation(uint16_t reservation_id) {
-  // Reservation IDs are stored in the upper bits.
-  PERFETTO_CHECK(reservation_id > 0);
-  return static_cast<MaybeUnboundBufferID>(reservation_id) << 16;
-}
-
-bool IsReservationTargetBufferId(MaybeUnboundBufferID buffer_id) {
-  return (buffer_id >> 16) > 0;
-}
-}  // namespace
-
-// static
-SharedMemoryABI::PageLayout SharedMemoryArbiterImpl::default_page_layout =
-    SharedMemoryABI::PageLayout::kPageDiv1;
-
-#if !PERFETTO_IS_AT_LEAST_CPP17()
-// static
-constexpr BufferID SharedMemoryArbiterImpl::kInvalidBufferId;
+// gen_amalgamated expanded: #include "perfetto/ext/base/no_destructor.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_config.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/data_source.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/track_event_interned_fields.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/track_event.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/track_event_category_registry.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/track_event_interned_data_index.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/data_source_descriptor.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/track_event_descriptor.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/clock_snapshot.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/interned_data/interned_data.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet_defaults.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/debug_annotation.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_descriptor.pbzero.h"
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_MAC)
+#include <os/signpost.h>
 #endif
 
-// static
-std::unique_ptr<SharedMemoryArbiter> SharedMemoryArbiter::CreateInstance(
-    SharedMemory* shared_memory,
-    size_t page_size,
-    TracingService::ProducerEndpoint* producer_endpoint,
-    base::TaskRunner* task_runner) {
-  return std::unique_ptr<SharedMemoryArbiterImpl>(
-      new SharedMemoryArbiterImpl(shared_memory->start(), shared_memory->size(),
-                                  page_size, producer_endpoint, task_runner));
-}
+using perfetto::protos::pbzero::ClockSnapshot;
 
-// static
-std::unique_ptr<SharedMemoryArbiter> SharedMemoryArbiter::CreateUnboundInstance(
-    SharedMemory* shared_memory,
-    size_t page_size) {
-  return std::unique_ptr<SharedMemoryArbiterImpl>(new SharedMemoryArbiterImpl(
-      shared_memory->start(), shared_memory->size(), page_size,
-      /*producer_endpoint=*/nullptr, /*task_runner=*/nullptr));
-}
+namespace perfetto {
 
-SharedMemoryArbiterImpl::SharedMemoryArbiterImpl(
-    void* start,
-    size_t size,
-    size_t page_size,
-    TracingService::ProducerEndpoint* producer_endpoint,
-    base::TaskRunner* task_runner)
-    : producer_endpoint_(producer_endpoint),
-      task_runner_(task_runner),
-      shmem_abi_(reinterpret_cast<uint8_t*>(start), size, page_size),
-      active_writer_ids_(kMaxWriterID),
-      fully_bound_(task_runner && producer_endpoint),
-      was_always_bound_(fully_bound_),
-      weak_ptr_factory_(this) {}
+TrackEventSessionObserver::~TrackEventSessionObserver() = default;
+void TrackEventSessionObserver::OnSetup(const DataSourceBase::SetupArgs&) {}
+void TrackEventSessionObserver::OnStart(const DataSourceBase::StartArgs&) {}
+void TrackEventSessionObserver::OnStop(const DataSourceBase::StopArgs&) {}
+void TrackEventSessionObserver::WillClearIncrementalState(
+    const DataSourceBase::ClearIncrementalStateArgs&) {}
 
-Chunk SharedMemoryArbiterImpl::GetNewChunk(
-    const SharedMemoryABI::ChunkHeader& header,
-    BufferExhaustedPolicy buffer_exhausted_policy,
-    size_t size_hint) {
-  PERFETTO_DCHECK(size_hint == 0);  // Not implemented yet.
+TrackEventTlsStateUserData::~TrackEventTlsStateUserData() = default;
 
-  int stall_count = 0;
-  unsigned stall_interval_us = 0;
-  bool task_runner_runs_on_current_thread = false;
-  static const unsigned kMaxStallIntervalUs = 100000;
-  static const int kLogAfterNStalls = 3;
-  static const int kFlushCommitsAfterEveryNStalls = 2;
-  static const int kAssertAtNStalls = 200;
+namespace internal {
 
-  for (;;) {
-    // TODO(primiano): Probably this lock is not really required and this code
-    // could be rewritten leveraging only the Try* atomic operations in
-    // SharedMemoryABI. But let's not be too adventurous for the moment.
-    {
-      std::unique_lock<std::mutex> scoped_lock(lock_);
+BaseTrackEventInternedDataIndex::~BaseTrackEventInternedDataIndex() = default;
 
-      // If ever unbound, we do not support stalling. In theory, we could
-      // support stalling for TraceWriters created after the arbiter and startup
-      // buffer reservations were bound, but to avoid raciness between the
-      // creation of startup writers and binding, we categorically forbid kStall
-      // mode.
-      PERFETTO_DCHECK(was_always_bound_ ||
-                      buffer_exhausted_policy == BufferExhaustedPolicy::kDrop);
+namespace {
 
-      task_runner_runs_on_current_thread =
-          task_runner_ && task_runner_->RunsTasksOnCurrentThread();
+static constexpr const char kSlowTag[] = "slow";
+static constexpr const char kDebugTag[] = "debug";
+static constexpr const char kFilteredEventName[] = "FILTERED";
 
-      // If more than half of the SMB.size() is filled with completed chunks for
-      // which we haven't notified the service yet (i.e. they are still enqueued
-      // in |commit_data_req_|), force a synchronous CommitDataRequest() even if
-      // we acquire a chunk, to reduce the likeliness of stalling the writer.
-      //
-      // We can only do this if we're writing on the same thread that we access
-      // the producer endpoint on, since we cannot notify the producer endpoint
-      // to commit synchronously on a different thread. Attempting to flush
-      // synchronously on another thread will lead to subtle bugs caused by
-      // out-of-order commit requests (crbug.com/919187#c28).
-      bool should_commit_synchronously =
-          task_runner_runs_on_current_thread &&
-          buffer_exhausted_policy == BufferExhaustedPolicy::kStall &&
-          commit_data_req_ && bytes_pending_commit_ >= shmem_abi_.size() / 2;
+constexpr auto kClockIdIncremental =
+    TrackEventIncrementalState::kClockIdIncremental;
 
-      const size_t initial_page_idx = page_idx_;
-      for (size_t i = 0; i < shmem_abi_.num_pages(); i++) {
-        page_idx_ = (initial_page_idx + i) % shmem_abi_.num_pages();
-        bool is_new_page = false;
+constexpr auto kClockIdAbsolute = TrackEventIncrementalState::kClockIdAbsolute;
 
-        // TODO(primiano): make the page layout dynamic.
-        auto layout = SharedMemoryArbiterImpl::default_page_layout;
+class TrackEventSessionObserverRegistry {
+ public:
+  static TrackEventSessionObserverRegistry* GetInstance() {
+    static TrackEventSessionObserverRegistry* instance =
+        new TrackEventSessionObserverRegistry();  // leaked
+    return instance;
+  }
 
-        if (shmem_abi_.is_page_free(page_idx_)) {
-          // TODO(primiano): Use the |size_hint| here to decide the layout.
-          is_new_page = shmem_abi_.TryPartitionPage(page_idx_, layout);
-        }
-        uint32_t free_chunks;
-        if (is_new_page) {
-          free_chunks = (1 << SharedMemoryABI::kNumChunksForLayout[layout]) - 1;
-        } else {
-          free_chunks = shmem_abi_.GetFreeChunks(page_idx_);
-        }
+  void AddObserverForRegistry(const TrackEventCategoryRegistry& registry,
+                              TrackEventSessionObserver* observer) {
+    std::unique_lock<std::recursive_mutex> lock(mutex_);
+    observers_.emplace_back(&registry, observer);
+  }
 
-        for (uint32_t chunk_idx = 0; free_chunks;
-             chunk_idx++, free_chunks >>= 1) {
-          if (!(free_chunks & 1))
-            continue;
-          // We found a free chunk.
-          Chunk chunk = shmem_abi_.TryAcquireChunkForWriting(
-              page_idx_, chunk_idx, &header);
-          if (!chunk.is_valid())
-            continue;
-          if (stall_count > kLogAfterNStalls) {
-            PERFETTO_LOG("Recovered from stall after %d iterations",
-                         stall_count);
-          }
+  void RemoveObserverForRegistry(const TrackEventCategoryRegistry& registry,
+                                 TrackEventSessionObserver* observer) {
+    std::unique_lock<std::recursive_mutex> lock(mutex_);
+    observers_.erase(std::remove(observers_.begin(), observers_.end(),
+                                 RegisteredObserver(&registry, observer)),
+                     observers_.end());
+  }
 
-          if (should_commit_synchronously) {
-            // We can't flush while holding the lock.
-            scoped_lock.unlock();
-            FlushPendingCommitDataRequests();
-            return chunk;
-          } else {
-            return chunk;
-          }
+  void ForEachObserverForRegistries(
+      const std::vector<const TrackEventCategoryRegistry*>& registries,
+      std::function<void(TrackEventSessionObserver*)> callback) {
+    std::unique_lock<std::recursive_mutex> lock(mutex_);
+    for (auto& registered_observer : observers_) {
+      for (const auto* registry : registries) {
+        if (registry == registered_observer.registry) {
+          callback(registered_observer.observer);
         }
       }
-    }  // scoped_lock
-
-    if (buffer_exhausted_policy == BufferExhaustedPolicy::kDrop) {
-      PERFETTO_DLOG("Shared memory buffer exhausted, returning invalid Chunk!");
-      return Chunk();
     }
+  }
 
-    // Stalling is not supported if we were ever unbound (see earlier comment).
-    PERFETTO_CHECK(was_always_bound_);
-
-    // All chunks are taken (either kBeingWritten by us or kBeingRead by the
-    // Service).
-    if (stall_count++ == kLogAfterNStalls) {
-      PERFETTO_LOG("Shared memory buffer overrun! Stalling");
+ private:
+  struct RegisteredObserver {
+    RegisteredObserver(const TrackEventCategoryRegistry* r,
+                       TrackEventSessionObserver* o)
+        : registry(r), observer(o) {}
+    bool operator==(const RegisteredObserver& other) {
+      return registry == other.registry && observer == other.observer;
     }
+    const TrackEventCategoryRegistry* registry;
+    TrackEventSessionObserver* observer;
+  };
 
-    if (stall_count == kAssertAtNStalls) {
-      PERFETTO_FATAL(
-          "Shared memory buffer max stall count exceeded; possible deadlock");
-    }
+  std::recursive_mutex mutex_;
+  std::vector<RegisteredObserver> observers_;
+};
 
-    // If the IPC thread itself is stalled because the current process has
-    // filled up the SMB, we need to make sure that the service can process and
-    // purge the chunks written by our process, by flushing any pending commit
-    // requests. Because other threads in our process can continue to
-    // concurrently grab, fill and commit any chunks purged by the service, it
-    // is possible that the SMB remains full and the IPC thread remains stalled,
-    // needing to flush the concurrently queued up commits again. This is
-    // particularly likely with in-process perfetto service where the IPC thread
-    // is the service thread. To avoid remaining stalled forever in such a
-    // situation, we attempt to flush periodically after every N stalls.
-    if (stall_count % kFlushCommitsAfterEveryNStalls == 0 &&
-        task_runner_runs_on_current_thread) {
-      // TODO(primiano): sending the IPC synchronously is a temporary workaround
-      // until the backpressure logic in probes_producer is sorted out. Until
-      // then the risk is that we stall the message loop waiting for the tracing
-      // service to consume the shared memory buffer (SMB) and, for this reason,
-      // never run the task that tells the service to purge the SMB. This must
-      // happen iff we are on the IPC thread, not doing this will cause
-      // deadlocks, doing this on the wrong thread causes out-of-order data
-      // commits (crbug.com/919187#c28).
-      FlushPendingCommitDataRequests();
-    } else {
-      base::SleepMicroseconds(stall_interval_us);
-      stall_interval_us =
-          std::min(kMaxStallIntervalUs, (stall_interval_us + 1) * 8);
+enum class MatchType { kExact, kPattern, kWildcard };
+
+bool NameMatchesPattern(const std::string& pattern,
+                        const std::string& name,
+                        MatchType match_type) {
+  // To avoid pulling in all of std::regex, for now we only support a single "*"
+  // wildcard at the end of the pattern.
+  size_t i = pattern.find('*');
+  if (i != std::string::npos) {
+    PERFETTO_DCHECK(i == pattern.size() - 1);
+    if (i == 0) {
+      return match_type == MatchType::kWildcard;
     }
+    if (match_type != MatchType::kPattern)
+      return false;
+    return name.substr(0, i) == pattern.substr(0, i);
   }
+  return name == pattern;
 }
 
-void SharedMemoryArbiterImpl::ReturnCompletedChunk(
-    Chunk chunk,
-    MaybeUnboundBufferID target_buffer,
-    PatchList* patch_list) {
-  PERFETTO_DCHECK(chunk.is_valid());
-  const WriterID writer_id = chunk.writer_id();
-  UpdateCommitDataRequest(std::move(chunk), writer_id, target_buffer,
-                          patch_list);
+bool NameMatchesPatternList(const std::vector<std::string>& patterns,
+                            const std::string& name,
+                            MatchType match_type) {
+  for (const auto& pattern : patterns) {
+    if (NameMatchesPattern(pattern, name, match_type))
+      return true;
+  }
+  return false;
 }
 
-void SharedMemoryArbiterImpl::SendPatches(WriterID writer_id,
-                                          MaybeUnboundBufferID target_buffer,
-                                          PatchList* patch_list) {
-  PERFETTO_DCHECK(!patch_list->empty() && patch_list->front().is_patched());
-  UpdateCommitDataRequest(Chunk(), writer_id, target_buffer, patch_list);
+}  // namespace
+
+TrackEventInternal& TrackEventInternal::GetInstance() {
+  static base::NoDestructor<TrackEventInternal> state;
+  return state.ref();
 }
 
-void SharedMemoryArbiterImpl::UpdateCommitDataRequest(
-    Chunk chunk,
-    WriterID writer_id,
-    MaybeUnboundBufferID target_buffer,
-    PatchList* patch_list) {
-  // Note: chunk will be invalid if the call came from SendPatches().
-  base::TaskRunner* task_runner_to_post_delayed_callback_on = nullptr;
-  // The delay with which the flush will be posted.
-  uint32_t flush_delay_ms = 0;
-  base::WeakPtr<SharedMemoryArbiterImpl> weak_this;
-  {
-    std::lock_guard<std::mutex> scoped_lock(lock_);
+// static
+const Track TrackEventInternal::kDefaultTrack{};
 
-    if (!commit_data_req_) {
-      commit_data_req_.reset(new CommitDataRequest());
+// static
+std::atomic<int> TrackEventInternal::session_count_{};
 
-      // Flushing the commit is only supported while we're |fully_bound_|. If we
-      // aren't, we'll flush when |fully_bound_| is updated.
-      if (fully_bound_ && !delayed_flush_scheduled_) {
-        weak_this = weak_ptr_factory_.GetWeakPtr();
-        task_runner_to_post_delayed_callback_on = task_runner_;
-        flush_delay_ms = batch_commits_duration_ms_;
-        delayed_flush_scheduled_ = true;
-      }
-    }
+std::vector<const TrackEventCategoryRegistry*>
+TrackEventInternal::GetRegistries() {
+  std::unique_lock<std::mutex> lock(mu_);
+  return registries_;
+}
 
-    // If a valid chunk is specified, return it and attach it to the request.
-    if (chunk.is_valid()) {
-      PERFETTO_DCHECK(chunk.writer_id() == writer_id);
-      uint8_t chunk_idx = chunk.chunk_idx();
-      bytes_pending_commit_ += chunk.size();
-      size_t page_idx;
-      // If the chunk needs patching, it should not be marked as complete yet,
-      // because this would indicate to the service that the producer will not
-      // be writing to it anymore, while the producer might still apply patches
-      // to the chunk later on. In particular, when re-reading (e.g. because of
-      // periodic scraping) a completed chunk, the service expects the flags of
-      // that chunk not to be removed between reads. So, let's say the producer
-      // marked the chunk as complete here and the service then read it for the
-      // first time. If the producer then fully patched the chunk, thus removing
-      // the kChunkNeedsPatching flag, and the service re-read the chunk after
-      // the patching, the service would be thrown off by the removed flag.
-      if (direct_patching_enabled_ &&
-          (chunk.GetPacketCountAndFlags().second &
-           SharedMemoryABI::ChunkHeader::kChunkNeedsPatching)) {
-        page_idx = shmem_abi_.GetPageAndChunkIndex(std::move(chunk)).first;
-      } else {
-        // If the chunk doesn't need patching, we can mark it as complete
-        // immediately. This allows the service to read it in full while
-        // scraping, which would not be the case if the chunk was left in a
-        // kChunkBeingWritten state.
-        page_idx = shmem_abi_.ReleaseChunkAsComplete(std::move(chunk));
-      }
+std::vector<const TrackEventCategoryRegistry*> TrackEventInternal::AddRegistry(
+    const TrackEventCategoryRegistry* registry) {
+  std::unique_lock<std::mutex> lock(mu_);
+  registries_.push_back(registry);
+  return registries_;
+}
 
-      // DO NOT access |chunk| after this point, it has been std::move()-d
-      // above.
-      CommitDataRequest::ChunksToMove* ctm =
-          commit_data_req_->add_chunks_to_move();
-      ctm->set_page(static_cast<uint32_t>(page_idx));
-      ctm->set_chunk(chunk_idx);
-      ctm->set_target_buffer(target_buffer);
-    }
+void TrackEventInternal::ResetRegistriesForTesting() {
+  std::unique_lock<std::mutex> lock(mu_);
+  registries_.clear();
+}
 
-    // Process the completed patches for previous chunks from the |patch_list|.
-    CommitDataRequest::ChunkToPatch* last_patch_req = nullptr;
-    while (!patch_list->empty() && patch_list->front().is_patched()) {
-      Patch curr_patch = patch_list->front();
-      patch_list->pop_front();
-      // Patches for the same chunk are contiguous in the |patch_list|. So, to
-      // determine if there are any other patches that apply to the chunk that
-      // is being patched, check if the next patch in the |patch_list| applies
-      // to the same chunk.
-      bool chunk_needs_more_patching =
-          !patch_list->empty() &&
-          patch_list->front().chunk_id == curr_patch.chunk_id;
+// static
+bool TrackEventInternal::Initialize(
+    const std::vector<const TrackEventCategoryRegistry*> registries,
+    bool (*register_data_source)(const DataSourceDescriptor&)) {
+  DataSourceDescriptor dsd;
+  dsd.set_name("track_event");
 
-      if (direct_patching_enabled_ &&
-          TryDirectPatchLocked(writer_id, curr_patch,
-                               chunk_needs_more_patching)) {
+  protozero::HeapBuffered<protos::pbzero::TrackEventDescriptor> ted;
+  for (const auto* registry : registries) {
+    for (size_t i = 0; i < registry->category_count(); i++) {
+      auto category = registry->GetCategory(i);
+      // Don't register group categories.
+      if (category->IsGroup())
         continue;
+      auto cat = ted->add_available_categories();
+      cat->set_name(category->name);
+      if (category->description)
+        cat->set_description(category->description);
+      for (const auto& tag : category->tags) {
+        if (tag) {
+          cat->add_tags(tag);
+        }
       }
-
-      // The chunk that this patch applies to has already been released to the
-      // service, so it cannot be patches here. Add the patch to the commit data
-      // request, so that it can be sent to the service and applied there.
-      if (!last_patch_req ||
-          last_patch_req->chunk_id() != curr_patch.chunk_id) {
-        last_patch_req = commit_data_req_->add_chunks_to_patch();
-        last_patch_req->set_writer_id(writer_id);
-        last_patch_req->set_chunk_id(curr_patch.chunk_id);
-        last_patch_req->set_target_buffer(target_buffer);
-      }
-      auto* patch = last_patch_req->add_patches();
-      patch->set_offset(curr_patch.offset);
-      patch->set_data(&curr_patch.size_field[0], curr_patch.size_field.size());
     }
+  }
+  dsd.set_track_event_descriptor_raw(ted.SerializeAsString());
 
-    // Patches are enqueued in the |patch_list| in order and are notified to
-    // the service when the chunk is returned. The only case when the current
-    // patch list is incomplete is if there is an unpatched entry at the head of
-    // the |patch_list| that belongs to the same ChunkID as the last one we are
-    // about to send to the service.
-    if (last_patch_req && !patch_list->empty() &&
-        patch_list->front().chunk_id == last_patch_req->chunk_id()) {
-      last_patch_req->set_has_more_patches(true);
-    }
+  return register_data_source(dsd);
+}
 
-    // If the buffer is filling up or if we are given a patch for a chunk
-    // that was already sent to the service, we don't want to wait for the next
-    // delayed flush to happen and we flush immediately. Otherwise, if we
-    // accumulate the patch and a crash occurs before the patch is sent, the
-    // service will not know of the patch and won't be able to reconstruct the
-    // trace.
-    if (fully_bound_ &&
-        (last_patch_req || bytes_pending_commit_ >= shmem_abi_.size() / 2)) {
-      weak_this = weak_ptr_factory_.GetWeakPtr();
-      task_runner_to_post_delayed_callback_on = task_runner_;
-      flush_delay_ms = 0;
-    }
-  }  // scoped_lock(lock_)
+// static
+bool TrackEventInternal::AddSessionObserver(
+    const TrackEventCategoryRegistry& registry,
+    TrackEventSessionObserver* observer) {
+  TrackEventSessionObserverRegistry::GetInstance()->AddObserverForRegistry(
+      registry, observer);
+  return true;
+}
 
-  // We shouldn't post tasks while locked.
-  // |task_runner_to_post_delayed_callback_on| remains valid after unlocking,
-  // because |task_runner_| is never reset.
-  if (task_runner_to_post_delayed_callback_on) {
-    task_runner_to_post_delayed_callback_on->PostDelayedTask(
-        [weak_this] {
-          if (!weak_this)
-            return;
-          {
-            std::lock_guard<std::mutex> scoped_lock(weak_this->lock_);
-            // Clear |delayed_flush_scheduled_|, allowing the next call to
-            // UpdateCommitDataRequest to start another batching period.
-            weak_this->delayed_flush_scheduled_ = false;
-          }
-          weak_this->FlushPendingCommitDataRequests();
-        },
-        flush_delay_ms);
-  }
+// static
+void TrackEventInternal::RemoveSessionObserver(
+    const TrackEventCategoryRegistry& registry,
+    TrackEventSessionObserver* observer) {
+  TrackEventSessionObserverRegistry::GetInstance()->RemoveObserverForRegistry(
+      registry, observer);
 }
 
-bool SharedMemoryArbiterImpl::TryDirectPatchLocked(
-    WriterID writer_id,
-    const Patch& patch,
-    bool chunk_needs_more_patching) {
-  // Search the chunks that are being batched in |commit_data_req_| for a chunk
-  // that needs patching and that matches the provided |writer_id| and
-  // |patch.chunk_id|. Iterate |commit_data_req_| in reverse, since
-  // |commit_data_req_| is appended to at the end with newly-returned chunks,
-  // and patches are more likely to apply to chunks that have been returned
-  // recently.
-  SharedMemoryABI::Chunk chunk;
-  bool chunk_found = false;
-  auto& chunks_to_move = commit_data_req_->chunks_to_move();
-  for (auto ctm_it = chunks_to_move.rbegin(); ctm_it != chunks_to_move.rend();
-       ++ctm_it) {
-    uint32_t layout = shmem_abi_.GetPageLayout(ctm_it->page());
-    auto chunk_state =
-        shmem_abi_.GetChunkStateFromLayout(layout, ctm_it->chunk());
-    // Note: the subset of |commit_data_req_| chunks that still need patching is
-    // also the subset of chunks that are still being written to. The rest of
-    // the chunks in |commit_data_req_| do not need patching and have already
-    // been marked as complete.
-    if (chunk_state != SharedMemoryABI::kChunkBeingWritten)
-      continue;
+#if !PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) && \
+    !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+static constexpr protos::pbzero::BuiltinClock kDefaultTraceClock =
+    protos::pbzero::BUILTIN_CLOCK_BOOTTIME;
+#else
+static constexpr protos::pbzero::BuiltinClock kDefaultTraceClock =
+    protos::pbzero::BUILTIN_CLOCK_MONOTONIC;
+#endif
 
-    chunk =
-        shmem_abi_.GetChunkUnchecked(ctm_it->page(), layout, ctm_it->chunk());
-    if (chunk.writer_id() == writer_id &&
-        chunk.header()->chunk_id.load(std::memory_order_relaxed) ==
-            patch.chunk_id) {
-      chunk_found = true;
-      break;
+// static
+protos::pbzero::BuiltinClock TrackEventInternal::clock_ = kDefaultTraceClock;
+
+// static
+bool TrackEventInternal::disallow_merging_with_system_tracks_ = false;
+
+// static
+void TrackEventInternal::EnableRegistry(
+    const TrackEventCategoryRegistry* registry,
+    const protos::gen::TrackEventConfig& config,
+    uint32_t internal_instance_index) {
+  for (size_t i = 0; i < registry->category_count(); i++) {
+    if (IsCategoryEnabled(*registry, config, *registry->GetCategory(i))) {
+      PERFETTO_DLOG("EnableRegistry %" PRIu32 " %zu", internal_instance_index,
+                    i);
+      registry->EnableCategoryForInstance(i, internal_instance_index);
     }
   }
+}
 
-  if (!chunk_found) {
-    // The chunk has already been committed to the service and the patch cannot
-    // be applied in the producer.
-    return false;
+void TrackEventInternal::EnableTracing(
+    const protos::gen::TrackEventConfig& config,
+    const DataSourceBase::SetupArgs& args) {
+  std::vector<const TrackEventCategoryRegistry*> registries;
+  {
+    std::unique_lock<std::mutex> lock(mu_);
+    registries = registries_;
+    for (const auto& registry : registries) {
+      for (size_t i = 0; i < registry->category_count(); i++) {
+        if (IsCategoryEnabled(*registry, config, *registry->GetCategory(i)))
+          registry->EnableCategoryForInstance(i, args.internal_instance_index);
+      }
+    }
   }
+  TrackEventSessionObserverRegistry::GetInstance()
+      ->ForEachObserverForRegistries(
+          registries, [&](TrackEventSessionObserver* o) { o->OnSetup(args); });
+}
 
-  // Apply the patch.
-  size_t page_idx;
-  uint8_t chunk_idx;
-  std::tie(page_idx, chunk_idx) = shmem_abi_.GetPageAndChunkIndex(chunk);
-  PERFETTO_DCHECK(shmem_abi_.GetChunkState(page_idx, chunk_idx) ==
-                  SharedMemoryABI::ChunkState::kChunkBeingWritten);
-  auto chunk_begin = chunk.payload_begin();
-  uint8_t* ptr = chunk_begin + patch.offset;
-  PERFETTO_CHECK(ptr <= chunk.end() - SharedMemoryABI::kPacketHeaderSize);
-  // DCHECK that we are writing into a zero-filled size field and not into
-  // valid data. It relies on ScatteredStreamWriter::ReserveBytes() to
-  // zero-fill reservations in debug builds.
-  const char zero[SharedMemoryABI::kPacketHeaderSize]{};
-  PERFETTO_DCHECK(memcmp(ptr, &zero, SharedMemoryABI::kPacketHeaderSize) == 0);
-
-  memcpy(ptr, &patch.size_field[0], SharedMemoryABI::kPacketHeaderSize);
-
-  if (!chunk_needs_more_patching) {
-    // Mark that the chunk doesn't need more patching and mark it as complete,
-    // as the producer will not write to it anymore. This allows the service to
-    // read the chunk in full while scraping, which would not be the case if the
-    // chunk was left in a kChunkBeingWritten state.
-    chunk.ClearNeedsPatchingFlag();
-    shmem_abi_.ReleaseChunkAsComplete(std::move(chunk));
+void TrackEventInternal::DisableTracing(uint32_t internal_instance_index) {
+  std::unique_lock<std::mutex> lock(mu_);
+  for (const auto& registry : registries_) {
+    for (size_t i = 0; i < registry->category_count(); i++)
+      registry->DisableCategoryForInstance(i, internal_instance_index);
   }
-
-  return true;
 }
 
-void SharedMemoryArbiterImpl::SetBatchCommitsDuration(
-    uint32_t batch_commits_duration_ms) {
-  std::lock_guard<std::mutex> scoped_lock(lock_);
-  batch_commits_duration_ms_ = batch_commits_duration_ms;
+// static
+void TrackEventInternal::OnStart(const DataSourceBase::StartArgs& args) {
+  session_count_.fetch_add(1);
+  TrackEventSessionObserverRegistry::GetInstance()
+      ->ForEachObserverForRegistries(
+          GetInstance().GetRegistries(),
+          [&](TrackEventSessionObserver* o) { o->OnStart(args); });
 }
 
-bool SharedMemoryArbiterImpl::EnableDirectSMBPatching() {
-  std::lock_guard<std::mutex> scoped_lock(lock_);
-  if (!direct_patching_supported_by_service_) {
-    return false;
-  }
-
-  return direct_patching_enabled_ = true;
+// static
+void TrackEventInternal::OnStop(const DataSourceBase::StopArgs& args) {
+  TrackEventSessionObserverRegistry::GetInstance()
+      ->ForEachObserverForRegistries(
+          GetInstance().GetRegistries(),
+          [&](TrackEventSessionObserver* o) { o->OnStop(args); });
 }
 
-void SharedMemoryArbiterImpl::SetDirectSMBPatchingSupportedByService() {
-  std::lock_guard<std::mutex> scoped_lock(lock_);
-  direct_patching_supported_by_service_ = true;
+// static
+void TrackEventInternal::WillClearIncrementalState(
+    const DataSourceBase::ClearIncrementalStateArgs& args) {
+  TrackEventSessionObserverRegistry::GetInstance()
+      ->ForEachObserverForRegistries(GetInstance().GetRegistries(),
+                                     [&](TrackEventSessionObserver* o) {
+                                       o->WillClearIncrementalState(args);
+                                     });
 }
 
-// This function is quite subtle. When making changes keep in mind these two
-// challenges:
-// 1) If the producer stalls and we happen to be on the |task_runner_| IPC
-//    thread (or, for in-process cases, on the same thread where
-//    TracingServiceImpl lives), the CommitData() call must be synchronous and
-//    not posted, to avoid deadlocks.
-// 2) When different threads hit this function, we must guarantee that we don't
-//    accidentally make commits out of order. See commit 4e4fe8f56ef and
-//    crbug.com/919187 for more context.
-void SharedMemoryArbiterImpl::FlushPendingCommitDataRequests(
-    std::function<void()> callback) {
-  std::unique_ptr<CommitDataRequest> req;
-  {
-    std::unique_lock<std::mutex> scoped_lock(lock_);
+// static
+bool TrackEventInternal::IsCategoryEnabled(
+    const TrackEventCategoryRegistry& registry,
+    const protos::gen::TrackEventConfig& config,
+    const Category& category) {
+  // If this is a group category, check if any of its constituent categories are
+  // enabled. If so, then this one is enabled too.
+  if (category.IsGroup()) {
+    bool result = false;
+    category.ForEachGroupMember([&](const char* member_name, size_t name_size) {
+      for (size_t i = 0; i < registry.category_count(); i++) {
+        const auto ref_category = registry.GetCategory(i);
+        // Groups can't refer to other groups.
+        if (ref_category->IsGroup())
+          continue;
+        // Require an exact match.
+        if (ref_category->name_size() != name_size ||
+            strncmp(ref_category->name, member_name, name_size)) {
+          continue;
+        }
+        if (IsCategoryEnabled(registry, config, *ref_category)) {
+          result = true;
+          // Break ForEachGroupMember() loop.
+          return false;
+        }
+        break;
+      }
+      // No match? Must be a dynamic category.
+      DynamicCategory dyn_category(std::string(member_name, name_size));
+      Category ref_category{Category::FromDynamicCategory(dyn_category)};
+      if (IsCategoryEnabled(registry, config, ref_category)) {
+        result = true;
+        // Break ForEachGroupMember() loop.
+        return false;
+      }
+      // No match found => keep iterating.
+      return true;
+    });
+    return result;
+  }
 
-    // Flushing is only supported while |fully_bound_|, and there may still be
-    // unbound startup trace writers. If so, skip the commit for now - it'll be
-    // done when |fully_bound_| is updated.
-    if (!fully_bound_) {
-      if (callback)
-        pending_flush_callbacks_.push_back(callback);
-      return;
+  auto has_matching_tag = [&](std::function<bool(const char*)> matcher) {
+    for (const auto& tag : category.tags) {
+      if (!tag)
+        break;
+      if (matcher(tag))
+        return true;
     }
+    return false;
+  };
 
-    // May be called by TraceWriterImpl on any thread.
-    base::TaskRunner* task_runner = task_runner_;
-    if (!task_runner->RunsTasksOnCurrentThread()) {
-      // We shouldn't post a task while holding a lock. |task_runner| remains
-      // valid after unlocking, because |task_runner_| is never reset.
-      scoped_lock.unlock();
-
-      auto weak_this = weak_ptr_factory_.GetWeakPtr();
-      task_runner->PostTask([weak_this, callback] {
-        if (weak_this)
-          weak_this->FlushPendingCommitDataRequests(std::move(callback));
-      });
-      return;
+  // First try exact matches, then pattern matches. Last, try the global
+  // wildcard.
+  const std::array<MatchType, 3> match_types = {
+      {MatchType::kExact, MatchType::kPattern, MatchType::kWildcard}};
+  for (auto match_type : match_types) {
+    // 1. Enabled categories.
+    if (NameMatchesPatternList(config.enabled_categories(), category.name,
+                               match_type)) {
+      return true;
     }
 
-    // |commit_data_req_| could have become a nullptr, for example when a forced
-    // sync flush happens in GetNewChunk().
-    if (commit_data_req_) {
-      // Make sure any placeholder buffer IDs from StartupWriters are replaced
-      // before sending the request.
-      bool all_placeholders_replaced =
-          ReplaceCommitPlaceholderBufferIdsLocked();
-      // We're |fully_bound_|, thus all writers are bound and all placeholders
-      // should have been replaced.
-      PERFETTO_DCHECK(all_placeholders_replaced);
-
-      // In order to allow patching in the producer we delay the kChunkComplete
-      // transition and keep batched chunks in the kChunkBeingWritten state.
-      // Since we are about to notify the service of all batched chunks, it will
-      // not be possible to apply any more patches to them and we need to move
-      // them to kChunkComplete - otherwise the service won't look at them.
-      for (auto& ctm : commit_data_req_->chunks_to_move()) {
-        uint32_t layout = shmem_abi_.GetPageLayout(ctm.page());
-        auto chunk_state =
-            shmem_abi_.GetChunkStateFromLayout(layout, ctm.chunk());
-        // Note: the subset of |commit_data_req_| chunks that still need
-        // patching is also the subset of chunks that are still being written
-        // to. The rest of the chunks in |commit_data_req_| do not need patching
-        // and have already been marked as complete.
-        if (chunk_state != SharedMemoryABI::kChunkBeingWritten)
-          continue;
-
-        SharedMemoryABI::Chunk chunk =
-            shmem_abi_.GetChunkUnchecked(ctm.page(), layout, ctm.chunk());
-        shmem_abi_.ReleaseChunkAsComplete(std::move(chunk));
-      }
+    // 2. Disabled categories.
+    if (NameMatchesPatternList(config.disabled_categories(), category.name,
+                               match_type)) {
+      return false;
+    }
 
-      req = std::move(commit_data_req_);
-      bytes_pending_commit_ = 0;
+    // 3. Disabled tags.
+    if (has_matching_tag([&](const char* tag) {
+          if (config.disabled_tags_size()) {
+            return NameMatchesPatternList(config.disabled_tags(), tag,
+                                          match_type);
+          } else if (config.enabled_tags_size() == 0) {
+            // The "slow" and "debug" tags are disabled by default.
+            return NameMatchesPattern(kSlowTag, tag, match_type) ||
+                   NameMatchesPattern(kDebugTag, tag, match_type);
+          }
+          return false;
+        })) {
+      return false;
     }
-  }  // scoped_lock
 
-  if (req) {
-    producer_endpoint_->CommitData(*req, callback);
-  } else if (callback) {
-    // If |req| was nullptr, it means that an enqueued deferred commit was
-    // executed just before this. At this point send an empty commit request
-    // to the service, just to linearize with it and give the guarantee to the
-    // caller that the data has been flushed into the service.
-    producer_endpoint_->CommitData(CommitDataRequest(), std::move(callback));
+    // 4. Enabled tags.
+    if (has_matching_tag([&](const char* tag) {
+          return NameMatchesPatternList(config.enabled_tags(), tag, match_type);
+        })) {
+      return true;
+    }
   }
+
+  // If nothing matched, enable the category by default.
+  return true;
 }
 
-bool SharedMemoryArbiterImpl::TryShutdown() {
-  std::lock_guard<std::mutex> scoped_lock(lock_);
-  did_shutdown_ = true;
-  // Shutdown is safe if there are no active trace writers for this arbiter.
-  return active_writer_ids_.IsEmpty();
+// static
+uint64_t TrackEventInternal::GetTimeNs() {
+  if (GetClockId() == protos::pbzero::BUILTIN_CLOCK_BOOTTIME)
+    return static_cast<uint64_t>(perfetto::base::GetBootTimeNs().count());
+  else if (GetClockId() == protos::pbzero::BUILTIN_CLOCK_MONOTONIC)
+    return static_cast<uint64_t>(perfetto::base::GetWallTimeNs().count());
+  PERFETTO_DCHECK(GetClockId() == protos::pbzero::BUILTIN_CLOCK_MONOTONIC_RAW);
+  return static_cast<uint64_t>(perfetto::base::GetWallTimeRawNs().count());
 }
 
-std::unique_ptr<TraceWriter> SharedMemoryArbiterImpl::CreateTraceWriter(
-    BufferID target_buffer,
-    BufferExhaustedPolicy buffer_exhausted_policy) {
-  PERFETTO_CHECK(target_buffer > 0);
-  return CreateTraceWriterInternal(target_buffer, buffer_exhausted_policy);
+// static
+TraceTimestamp TrackEventInternal::GetTraceTime() {
+  return {kClockIdIncremental, GetTimeNs()};
 }
 
-std::unique_ptr<TraceWriter> SharedMemoryArbiterImpl::CreateStartupTraceWriter(
-    uint16_t target_buffer_reservation_id) {
-  return CreateTraceWriterInternal(
-      MakeTargetBufferIdForReservation(target_buffer_reservation_id),
-      BufferExhaustedPolicy::kDrop);
+// static
+int TrackEventInternal::GetSessionCount() {
+  return session_count_.load();
 }
 
-void SharedMemoryArbiterImpl::BindToProducerEndpoint(
-    TracingService::ProducerEndpoint* producer_endpoint,
-    base::TaskRunner* task_runner) {
-  PERFETTO_DCHECK(producer_endpoint && task_runner);
-  PERFETTO_DCHECK(task_runner->RunsTasksOnCurrentThread());
+// static
+void TrackEventInternal::ResetIncrementalState(
+    TraceWriterBase* trace_writer,
+    TrackEventIncrementalState* incr_state,
+    const TrackEventTlsState& tls_state,
+    const TraceTimestamp& timestamp) {
+  auto sequence_timestamp = timestamp;
+  if (timestamp.clock_id != kClockIdIncremental) {
+    sequence_timestamp = TrackEventInternal::GetTraceTime();
+  }
 
-  bool should_flush = false;
-  std::function<void()> flush_callback;
+  incr_state->last_timestamp_ns = sequence_timestamp.value;
+  auto default_track = ThreadTrack::Current();
+  auto ts_unit_multiplier = tls_state.timestamp_unit_multiplier;
+  auto thread_time_counter_track =
+      CounterTrack("thread_time", default_track)
+          .set_is_incremental(true)
+          .set_unit_multiplier(static_cast<int64_t>(ts_unit_multiplier))
+          .set_type(protos::gen::CounterDescriptor::COUNTER_THREAD_TIME_NS);
   {
-    std::lock_guard<std::mutex> scoped_lock(lock_);
-    PERFETTO_CHECK(!fully_bound_);
-    PERFETTO_CHECK(!producer_endpoint_ && !task_runner_);
-
-    producer_endpoint_ = producer_endpoint;
-    task_runner_ = task_runner;
-
-    // Now that we're bound to a task runner, also reset the WeakPtrFactory to
-    // it. Because this code runs on the task runner, the factory's weak
-    // pointers will be valid on it.
-    weak_ptr_factory_.Reset(this);
-
-    // All writers registered so far should be startup trace writers, since
-    // the producer cannot feasibly know the target buffer for any future
-    // session yet.
-    for (const auto& entry : pending_writers_) {
-      PERFETTO_CHECK(IsReservationTargetBufferId(entry.second));
+    // Mark any incremental state before this point invalid. Also set up
+    // defaults so that we don't need to repeat constant data for each packet.
+    auto packet = NewTracePacket(
+        trace_writer, incr_state, tls_state, timestamp,
+        protos::pbzero::TracePacket::SEQ_INCREMENTAL_STATE_CLEARED);
+    auto defaults = packet->set_trace_packet_defaults();
+    defaults->set_timestamp_clock_id(tls_state.default_clock);
+    // Establish the default track for this event sequence.
+    auto track_defaults = defaults->set_track_event_defaults();
+    track_defaults->set_track_uuid(default_track.uuid);
+    if (tls_state.enable_thread_time_sampling) {
+      track_defaults->add_extra_counter_track_uuids(
+          thread_time_counter_track.uuid);
     }
 
-    // If all buffer reservations are bound, we can flush pending commits.
-    if (UpdateFullyBoundLocked()) {
-      should_flush = true;
-      flush_callback = TakePendingFlushCallbacksLocked();
-    }
-  }  // scoped_lock
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_MAC)
+    // Emit a MacOS point-of-interest signpost to synchronize Mac profiler time
+    // with boot time.
+    // TODO(leszeks): Consider allowing synchronization against other clocks
+    // than boot time.
+    static os_log_t log_handle = os_log_create(
+        "dev.perfetto.clock_sync", OS_LOG_CATEGORY_POINTS_OF_INTEREST);
+    os_signpost_event_emit(
+        log_handle, OS_SIGNPOST_ID_EXCLUSIVE, "boottime", "%" PRId64,
+        static_cast<uint64_t>(perfetto::base::GetBootTimeNs().count()));
+#endif
 
-  // Attempt to flush any pending commits (and run pending flush callbacks). If
-  // there are none, this will have no effect. If we ended up in a race that
-  // changed |fully_bound_| back to false, the commit will happen once we become
-  // |fully_bound_| again.
-  if (should_flush)
-    FlushPendingCommitDataRequests(flush_callback);
-}
+    if (tls_state.default_clock != static_cast<uint32_t>(GetClockId())) {
+      ClockSnapshot* clocks = packet->set_clock_snapshot();
+      // Trace clock.
+      ClockSnapshot::Clock* trace_clock = clocks->add_clocks();
+      trace_clock->set_clock_id(static_cast<uint32_t>(GetClockId()));
+      trace_clock->set_timestamp(sequence_timestamp.value);
 
-void SharedMemoryArbiterImpl::BindStartupTargetBuffer(
-    uint16_t target_buffer_reservation_id,
-    BufferID target_buffer_id) {
-  PERFETTO_DCHECK(target_buffer_id > 0);
+      if (PERFETTO_LIKELY(tls_state.default_clock == kClockIdIncremental)) {
+        // Delta-encoded incremental clock in nanoseconds by default but
+        // configurable by |tls_state.timestamp_unit_multiplier|.
+        ClockSnapshot::Clock* clock_incremental = clocks->add_clocks();
+        clock_incremental->set_clock_id(kClockIdIncremental);
+        clock_incremental->set_timestamp(sequence_timestamp.value /
+                                         ts_unit_multiplier);
+        clock_incremental->set_is_incremental(true);
+        clock_incremental->set_unit_multiplier_ns(ts_unit_multiplier);
+      }
+      if (ts_unit_multiplier > 1) {
+        // absolute clock with custom timestamp_unit_multiplier.
+        ClockSnapshot::Clock* absolute_clock = clocks->add_clocks();
+        absolute_clock->set_clock_id(kClockIdAbsolute);
+        absolute_clock->set_timestamp(sequence_timestamp.value /
+                                      ts_unit_multiplier);
+        absolute_clock->set_is_incremental(false);
+        absolute_clock->set_unit_multiplier_ns(ts_unit_multiplier);
+      }
+    }
+  }
 
-  std::unique_lock<std::mutex> scoped_lock(lock_);
+  // Every thread should write a descriptor for its default track, because most
+  // trace points won't explicitly reference it. We also write the process
+  // descriptor from every thread that writes trace events to ensure it gets
+  // emitted at least once.
+  incr_state->seen_tracks.insert(default_track.uuid);
+  WriteTrackDescriptor(default_track, trace_writer, incr_state, tls_state,
+                       sequence_timestamp);
 
-  // We should already be bound to an endpoint.
-  PERFETTO_CHECK(producer_endpoint_);
-  PERFETTO_CHECK(task_runner_);
-  PERFETTO_CHECK(task_runner_->RunsTasksOnCurrentThread());
+  incr_state->seen_tracks.insert(ProcessTrack::Current().uuid);
+  WriteTrackDescriptor(ProcessTrack::Current(), trace_writer, incr_state,
+                       tls_state, sequence_timestamp);
 
-  BindStartupTargetBufferImpl(std::move(scoped_lock),
-                              target_buffer_reservation_id, target_buffer_id);
+  if (tls_state.enable_thread_time_sampling) {
+    WriteTrackDescriptor(thread_time_counter_track, trace_writer, incr_state,
+                         tls_state, sequence_timestamp);
+  }
 }
 
-void SharedMemoryArbiterImpl::AbortStartupTracingForReservation(
-    uint16_t target_buffer_reservation_id) {
-  std::unique_lock<std::mutex> scoped_lock(lock_);
-
-  // If we are already bound to an arbiter, we may need to flush after aborting
-  // the session, and thus should be running on the arbiter's task runner.
-  if (task_runner_ && !task_runner_->RunsTasksOnCurrentThread()) {
-    // We shouldn't post tasks while locked.
-    auto* task_runner = task_runner_;
-    scoped_lock.unlock();
-
-    auto weak_this = weak_ptr_factory_.GetWeakPtr();
-    task_runner->PostTask([weak_this, target_buffer_reservation_id]() {
-      if (!weak_this)
-        return;
-      weak_this->AbortStartupTracingForReservation(
-          target_buffer_reservation_id);
-    });
-    return;
+// static
+protozero::MessageHandle<protos::pbzero::TracePacket>
+TrackEventInternal::NewTracePacket(TraceWriterBase* trace_writer,
+                                   TrackEventIncrementalState* incr_state,
+                                   const TrackEventTlsState& tls_state,
+                                   TraceTimestamp timestamp,
+                                   uint32_t seq_flags) {
+  if (PERFETTO_UNLIKELY(tls_state.default_clock != kClockIdIncremental &&
+                        timestamp.clock_id == kClockIdIncremental)) {
+    timestamp.clock_id = tls_state.default_clock;
   }
-
-  // Bind the target buffer reservation to an invalid buffer (ID 0), so that
-  // existing commits, as well as future commits (of currently acquired chunks),
-  // will be released as free free by the service but otherwise ignored (i.e.
-  // not copied into any valid target buffer).
-  BindStartupTargetBufferImpl(std::move(scoped_lock),
-                              target_buffer_reservation_id,
-                              /*target_buffer_id=*/kInvalidBufferId);
+  auto packet = trace_writer->NewTracePacket();
+  auto ts_unit_multiplier = tls_state.timestamp_unit_multiplier;
+  if (PERFETTO_LIKELY(timestamp.clock_id == kClockIdIncremental)) {
+    if (PERFETTO_LIKELY(incr_state->last_timestamp_ns <= timestamp.value)) {
+      // No need to set the clock id here, since kClockIdIncremental is the
+      // clock id assumed by default.
+      auto time_diff_ns = timestamp.value - incr_state->last_timestamp_ns;
+      auto time_diff_units = time_diff_ns / ts_unit_multiplier;
+      packet->set_timestamp(time_diff_units);
+      incr_state->last_timestamp_ns += time_diff_units * ts_unit_multiplier;
+    } else {
+      packet->set_timestamp(timestamp.value / ts_unit_multiplier);
+      packet->set_timestamp_clock_id(ts_unit_multiplier == 1
+                                         ? static_cast<uint32_t>(GetClockId())
+                                         : kClockIdAbsolute);
+    }
+  } else if (PERFETTO_LIKELY(timestamp.clock_id == tls_state.default_clock)) {
+    packet->set_timestamp(timestamp.value / ts_unit_multiplier);
+  } else {
+    packet->set_timestamp(timestamp.value);
+    packet->set_timestamp_clock_id(timestamp.clock_id);
+  }
+  packet->set_sequence_flags(seq_flags);
+  return packet;
 }
 
-void SharedMemoryArbiterImpl::BindStartupTargetBufferImpl(
-    std::unique_lock<std::mutex> scoped_lock,
-    uint16_t target_buffer_reservation_id,
-    BufferID target_buffer_id) {
-  // We should already be bound to an endpoint if the target buffer is valid.
-  PERFETTO_DCHECK((producer_endpoint_ && task_runner_) ||
-                  target_buffer_id == kInvalidBufferId);
-
-  PERFETTO_DLOG("Binding startup target buffer reservation %" PRIu16
-                " to buffer %" PRIu16,
-                target_buffer_reservation_id, target_buffer_id);
+// static
+void TrackEventInternal::WriteEventName(StaticString event_name,
+                                        perfetto::EventContext& event_ctx,
+                                        const TrackEventTlsState&) {
+  if (PERFETTO_LIKELY(event_name.value != nullptr)) {
+    size_t name_iid = InternedEventName::Get(&event_ctx, event_name.value);
+    event_ctx.event()->set_name_iid(name_iid);
+  }
+}
 
-  MaybeUnboundBufferID reserved_id =
-      MakeTargetBufferIdForReservation(target_buffer_reservation_id);
+// static
+void TrackEventInternal::WriteEventName(perfetto::DynamicString event_name,
+                                        perfetto::EventContext& event_ctx,
+                                        const TrackEventTlsState& tls_state) {
+  if (PERFETTO_UNLIKELY(tls_state.filter_dynamic_event_names)) {
+    event_ctx.event()->set_name(kFilteredEventName,
+                                sizeof(kFilteredEventName) - 1);
+  } else {
+    event_ctx.event()->set_name(event_name.value, event_name.length);
+  }
+}
 
-  bool should_flush = false;
-  std::function<void()> flush_callback;
-  std::vector<std::pair<WriterID, BufferID>> writers_to_register;
+// static
+EventContext TrackEventInternal::WriteEvent(
+    TraceWriterBase* trace_writer,
+    TrackEventIncrementalState* incr_state,
+    TrackEventTlsState& tls_state,
+    const Category* category,
+    perfetto::protos::pbzero::TrackEvent::Type type,
+    const TraceTimestamp& timestamp,
+    bool on_current_thread_track) {
+  PERFETTO_DCHECK(!incr_state->was_cleared);
+  auto packet = NewTracePacket(trace_writer, incr_state, tls_state, timestamp);
+  EventContext ctx(std::move(packet), incr_state, &tls_state);
 
-  TargetBufferReservation& reservation =
-      target_buffer_reservations_[reserved_id];
-  PERFETTO_CHECK(!reservation.resolved);
-  reservation.resolved = true;
-  reservation.target_buffer = target_buffer_id;
+  auto track_event = ctx.event();
+  if (type != protos::pbzero::TrackEvent::TYPE_UNSPECIFIED)
+    track_event->set_type(type);
 
-  // Collect trace writers associated with the reservation.
-  for (auto it = pending_writers_.begin(); it != pending_writers_.end();) {
-    if (it->second == reserved_id) {
-      // No need to register writers that have an invalid target buffer.
-      if (target_buffer_id != kInvalidBufferId) {
-        writers_to_register.push_back(
-            std::make_pair(it->first, target_buffer_id));
-      }
-      it = pending_writers_.erase(it);
+  if (tls_state.enable_thread_time_sampling && on_current_thread_track) {
+    if (tls_state.thread_time_subsampling_ns == 0 ||
+        incr_state->last_thread_time_timestamp_ns == 0 ||
+        timestamp.value >= incr_state->last_thread_time_timestamp_ns +
+                               tls_state.thread_time_subsampling_ns) {
+      auto thread_time_ns = base::GetThreadCPUTimeNs().count();
+      auto thread_time_delta_ns =
+          thread_time_ns - incr_state->last_thread_time_ns;
+      incr_state->last_thread_time_ns = thread_time_ns;
+      incr_state->last_thread_time_timestamp_ns = timestamp.value;
+      track_event->add_extra_counter_values(
+          thread_time_delta_ns /
+          static_cast<int64_t>(tls_state.timestamp_unit_multiplier));
     } else {
-      it++;
+      // When subsampling, the skip emitting values.
+      track_event->add_extra_counter_values(0);
     }
   }
 
-  // If all buffer reservations are bound, we can flush pending commits.
-  if (UpdateFullyBoundLocked()) {
-    should_flush = true;
-    flush_callback = TakePendingFlushCallbacksLocked();
-  }
-
-  scoped_lock.unlock();
-
-  // Register any newly bound trace writers with the service.
-  for (const auto& writer_and_target_buffer : writers_to_register) {
-    producer_endpoint_->RegisterTraceWriter(writer_and_target_buffer.first,
-                                            writer_and_target_buffer.second);
+  // We assume that |category| points to the string with static lifetime.
+  // This means we can use their addresses as interning keys.
+  // TODO(skyostil): Intern categories at compile time.
+  if (category && type != protos::pbzero::TrackEvent::TYPE_SLICE_END &&
+      type != protos::pbzero::TrackEvent::TYPE_COUNTER) {
+    category->ForEachGroupMember(
+        [&](const char* member_name, size_t name_size) {
+          size_t category_iid =
+              InternedEventCategory::Get(&ctx, member_name, name_size);
+          track_event->add_category_iids(category_iid);
+          return true;
+        });
   }
-
-  // Attempt to flush any pending commits (and run pending flush callbacks). If
-  // there are none, this will have no effect. If we ended up in a race that
-  // changed |fully_bound_| back to false, the commit will happen once we become
-  // |fully_bound_| again.
-  if (should_flush)
-    FlushPendingCommitDataRequests(flush_callback);
+  return ctx;
 }
 
-std::function<void()>
-SharedMemoryArbiterImpl::TakePendingFlushCallbacksLocked() {
-  if (pending_flush_callbacks_.empty())
-    return std::function<void()>();
+// static
+protos::pbzero::DebugAnnotation* TrackEventInternal::AddDebugAnnotation(
+    perfetto::EventContext* event_ctx,
+    const char* name) {
+  auto annotation = event_ctx->event()->add_debug_annotations();
+  annotation->set_name_iid(InternedDebugAnnotationName::Get(event_ctx, name));
+  return annotation;
+}
 
-  std::vector<std::function<void()>> pending_flush_callbacks;
-  pending_flush_callbacks.swap(pending_flush_callbacks_);
-  // Capture the callback list into the lambda by copy.
-  return [pending_flush_callbacks]() {
-    for (auto& callback : pending_flush_callbacks)
-      callback();
-  };
+// static
+protos::pbzero::DebugAnnotation* TrackEventInternal::AddDebugAnnotation(
+    perfetto::EventContext* event_ctx,
+    perfetto::DynamicString name) {
+  auto annotation = event_ctx->event()->add_debug_annotations();
+  annotation->set_name(name.value);
+  return annotation;
 }
 
-void SharedMemoryArbiterImpl::NotifyFlushComplete(FlushRequestID req_id) {
-  base::TaskRunner* task_runner_to_commit_on = nullptr;
+void TrackEventDataSource::OnStart(const DataSourceBase::StartArgs& args) {
+  TrackEventInternal::OnStart(args);
+}
 
-  {
-    std::lock_guard<std::mutex> scoped_lock(lock_);
-    // If a commit_data_req_ exists it means that somebody else already posted a
-    // FlushPendingCommitDataRequests() task.
-    if (!commit_data_req_) {
-      commit_data_req_.reset(new CommitDataRequest());
+}  // namespace internal
 
-      // Flushing the commit is only supported while we're |fully_bound_|. If we
-      // aren't, we'll flush when |fully_bound_| is updated.
-      if (fully_bound_)
-        task_runner_to_commit_on = task_runner_;
-    } else {
-      // If there is another request queued and that also contains is a reply
-      // to a flush request, reply with the highest id.
-      req_id = std::max(req_id, commit_data_req_->flush_request_id());
-    }
-    commit_data_req_->set_flush_request_id(req_id);
-  }  // scoped_lock
+PERFETTO_DEFINE_DATA_SOURCE_STATIC_MEMBERS_WITH_ATTRS(
+    PERFETTO_EXPORT_COMPONENT,
+    perfetto::internal::TrackEventDataSource,
+    perfetto::internal::TrackEventDataSourceTraits);
 
-  // We shouldn't post tasks while locked. |task_runner_to_commit_on|
-  // remains valid after unlocking, because |task_runner_| is never reset.
-  if (task_runner_to_commit_on) {
-    auto weak_this = weak_ptr_factory_.GetWeakPtr();
-    task_runner_to_commit_on->PostTask([weak_this] {
-      if (weak_this)
-        weak_this->FlushPendingCommitDataRequests();
-    });
-  }
-}
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/internal/track_event_interned_fields.cc
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-std::unique_ptr<TraceWriter> SharedMemoryArbiterImpl::CreateTraceWriterInternal(
-    MaybeUnboundBufferID target_buffer,
-    BufferExhaustedPolicy buffer_exhausted_policy) {
-  WriterID id;
-  base::TaskRunner* task_runner_to_register_on = nullptr;
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/track_event_interned_fields.h"
 
-  {
-    std::lock_guard<std::mutex> scoped_lock(lock_);
-    if (did_shutdown_)
-      return std::unique_ptr<TraceWriter>(new NullTraceWriter());
+namespace perfetto {
+namespace internal {
 
-    id = active_writer_ids_.Allocate();
-    if (!id)
-      return std::unique_ptr<TraceWriter>(new NullTraceWriter());
+InternedEventCategory::~InternedEventCategory() = default;
 
-    PERFETTO_DCHECK(!pending_writers_.count(id));
+// static
+void InternedEventCategory::Add(protos::pbzero::InternedData* interned_data,
+                                size_t iid,
+                                const char* value,
+                                size_t length) {
+  auto category = interned_data->add_event_categories();
+  category->set_iid(iid);
+  category->set_name(value, length);
+}
 
-    if (IsReservationTargetBufferId(target_buffer)) {
-      // If the reservation is new, mark it as unbound in
-      // |target_buffer_reservations_|. Otherwise, if the reservation was
-      // already bound, choose the bound buffer ID now.
-      auto it_and_inserted = target_buffer_reservations_.insert(
-          {target_buffer, TargetBufferReservation()});
-      if (it_and_inserted.first->second.resolved)
-        target_buffer = it_and_inserted.first->second.target_buffer;
-    }
+InternedEventName::~InternedEventName() = default;
 
-    if (IsReservationTargetBufferId(target_buffer)) {
-      // The arbiter and/or startup buffer reservations are not bound yet, so
-      // buffer the registration of the writer until after we're bound.
-      pending_writers_[id] = target_buffer;
+// static
+void InternedEventName::Add(protos::pbzero::InternedData* interned_data,
+                            size_t iid,
+                            const char* value) {
+  auto name = interned_data->add_event_names();
+  name->set_iid(iid);
+  name->set_name(value);
+}
 
-      // Mark the arbiter as not fully bound, since we now have at least one
-      // unbound trace writer / target buffer reservation.
-      fully_bound_ = false;
-      was_always_bound_ = false;
-    } else if (target_buffer != kInvalidBufferId) {
-      // Trace writer is bound, so arbiter should be bound to an endpoint, too.
-      PERFETTO_CHECK(producer_endpoint_ && task_runner_);
-      task_runner_to_register_on = task_runner_;
-    }
+InternedDebugAnnotationName::~InternedDebugAnnotationName() = default;
 
-    // All trace writers must use kDrop policy if the arbiter ever becomes
-    // unbound.
-    bool uses_drop_policy =
-        buffer_exhausted_policy == BufferExhaustedPolicy::kDrop;
-    all_writers_have_drop_policy_ &= uses_drop_policy;
-    PERFETTO_DCHECK(fully_bound_ || uses_drop_policy);
-    PERFETTO_CHECK(fully_bound_ || all_writers_have_drop_policy_);
-    PERFETTO_CHECK(was_always_bound_ || uses_drop_policy);
-  }  // scoped_lock
+// static
+void InternedDebugAnnotationName::Add(
+    protos::pbzero::InternedData* interned_data,
+    size_t iid,
+    const char* value) {
+  auto name = interned_data->add_debug_annotation_names();
+  name->set_iid(iid);
+  name->set_name(value);
+}
 
-  // We shouldn't post tasks while locked. |task_runner_to_register_on|
-  // remains valid after unlocking, because |task_runner_| is never reset.
-  if (task_runner_to_register_on) {
-    auto weak_this = weak_ptr_factory_.GetWeakPtr();
-    task_runner_to_register_on->PostTask([weak_this, id, target_buffer] {
-      if (weak_this)
-        weak_this->producer_endpoint_->RegisterTraceWriter(id, target_buffer);
-    });
-  }
+InternedDebugAnnotationValueTypeName::~InternedDebugAnnotationValueTypeName() =
+    default;
 
-  return std::unique_ptr<TraceWriter>(
-      new TraceWriterImpl(this, id, target_buffer, buffer_exhausted_policy));
+// static
+void InternedDebugAnnotationValueTypeName::Add(
+    protos::pbzero::InternedData* interned_data,
+    size_t iid,
+    const char* value) {
+  auto name = interned_data->add_debug_annotation_value_type_names();
+  name->set_iid(iid);
+  name->set_name(value);
 }
 
-void SharedMemoryArbiterImpl::ReleaseWriterID(WriterID id) {
-  base::TaskRunner* task_runner = nullptr;
-  {
-    std::lock_guard<std::mutex> scoped_lock(lock_);
-    active_writer_ids_.Free(id);
-
-    auto it = pending_writers_.find(id);
-    if (it != pending_writers_.end()) {
-      // Writer hasn't been bound yet and thus also not yet registered with the
-      // service.
-      pending_writers_.erase(it);
-      return;
-    }
+}  // namespace internal
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/platform.cc
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-    // A trace writer from an aborted session may be destroyed before the
-    // arbiter is bound to a task runner. In that case, it was never registered
-    // with the service.
-    if (!task_runner_)
-      return;
+// gen_amalgamated expanded: #include "perfetto/tracing/platform.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_tls.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/trace_writer_base.h"
 
-    task_runner = task_runner_;
-  }  // scoped_lock
+namespace perfetto {
 
-  // We shouldn't post tasks while locked. |task_runner| remains valid after
-  // unlocking, because |task_runner_| is never reset.
-  auto weak_this = weak_ptr_factory_.GetWeakPtr();
-  task_runner->PostTask([weak_this, id] {
-    if (weak_this)
-      weak_this->producer_endpoint_->UnregisterTraceWriter(id);
-  });
-}
+PlatformThreadLocalObject::~PlatformThreadLocalObject() = default;
+Platform::~Platform() = default;
 
-bool SharedMemoryArbiterImpl::ReplaceCommitPlaceholderBufferIdsLocked() {
-  if (!commit_data_req_)
-    return true;
+void Platform::Shutdown() {}
 
-  bool all_placeholders_replaced = true;
-  for (auto& chunk : *commit_data_req_->mutable_chunks_to_move()) {
-    if (!IsReservationTargetBufferId(chunk.target_buffer()))
-      continue;
-    const auto it = target_buffer_reservations_.find(chunk.target_buffer());
-    PERFETTO_DCHECK(it != target_buffer_reservations_.end());
-    if (!it->second.resolved) {
-      all_placeholders_replaced = false;
-      continue;
-    }
-    chunk.set_target_buffer(it->second.target_buffer);
-  }
-  for (auto& chunk : *commit_data_req_->mutable_chunks_to_patch()) {
-    if (!IsReservationTargetBufferId(chunk.target_buffer()))
-      continue;
-    const auto it = target_buffer_reservations_.find(chunk.target_buffer());
-    PERFETTO_DCHECK(it != target_buffer_reservations_.end());
-    if (!it->second.resolved) {
-      all_placeholders_replaced = false;
-      continue;
-    }
-    chunk.set_target_buffer(it->second.target_buffer);
-  }
-  return all_placeholders_replaced;
+base::PlatformThreadId Platform::GetCurrentThreadId() {
+  return base::GetThreadId();
 }
 
-bool SharedMemoryArbiterImpl::UpdateFullyBoundLocked() {
-  if (!producer_endpoint_) {
-    PERFETTO_DCHECK(!fully_bound_);
-    return false;
-  }
-  // We're fully bound if all target buffer reservations have a valid associated
-  // BufferID.
-  fully_bound_ = std::none_of(
-      target_buffer_reservations_.begin(), target_buffer_reservations_.end(),
-      [](std::pair<MaybeUnboundBufferID, TargetBufferReservation> entry) {
-        return !entry.second.resolved;
-      });
-  if (!fully_bound_)
-    was_always_bound_ = false;
-  return fully_bound_;
+// static
+std::unique_ptr<PlatformThreadLocalObject>
+PlatformThreadLocalObject::CreateInstance() {
+  return std::unique_ptr<PlatformThreadLocalObject>(new internal::TracingTLS());
 }
 
+// static
+base::PlatformProcessId Platform::process_id_ = 0;
+
 }  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/core/trace_packet.cc
-// gen_amalgamated begin header: include/perfetto/ext/tracing/core/trace_packet.h
-// gen_amalgamated begin header: include/perfetto/ext/tracing/core/slice.h
+// gen_amalgamated begin source: src/tracing/platform_posix.cc
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -41798,69 +47554,129 @@ bool SharedMemoryArbiterImpl::UpdateFullyBoundLocked() {
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_SLICE_H_
-#define INCLUDE_PERFETTO_EXT_TRACING_CORE_SLICE_H_
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
 
-#include <stddef.h>
-#include <string.h>
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
 
-#include <memory>
-#include <string>
-#include <vector>
+// gen_amalgamated expanded: #include "perfetto/ext/base/file_utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/thread_task_runner.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_tls.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/platform.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/trace_writer_base.h"
 
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+#include <pthread.h>
+#include <stdlib.h>
 
 namespace perfetto {
 
-// A simple wrapper around a virtually contiguous memory range that contains a
-// TracePacket, or just a portion of it.
-struct Slice {
-  Slice() : start(nullptr), size(0) {}
-  Slice(const void* st, size_t sz) : start(st), size(sz) {}
-  Slice(Slice&& other) noexcept = default;
+namespace {
 
-  // Create a Slice which owns |size| bytes of memory.
-  static Slice Allocate(size_t size) {
-    Slice slice;
-    slice.own_data_.reset(new uint8_t[size]);
-    slice.start = &slice.own_data_[0];
-    slice.size = size;
-    return slice;
-  }
+class PlatformPosix : public Platform {
+ public:
+  PlatformPosix();
+  ~PlatformPosix() override;
 
-  static Slice TakeOwnership(std::unique_ptr<uint8_t[]> buf, size_t size) {
-    Slice slice;
-    slice.own_data_ = std::move(buf);
-    slice.start = &slice.own_data_[0];
-    slice.size = size;
-    return slice;
-  }
+  ThreadLocalObject* GetOrCreateThreadLocalObject() override;
 
-  uint8_t* own_data() {
-    PERFETTO_DCHECK(own_data_);
-    return own_data_.get();
+  std::unique_ptr<base::TaskRunner> CreateTaskRunner(
+      const CreateTaskRunnerArgs&) override;
+  std::string GetCurrentProcessName() override;
+  void Shutdown() override;
+
+ private:
+  pthread_key_t tls_key_{};
+};
+
+PlatformPosix* g_instance = nullptr;
+
+using ThreadLocalObject = Platform::ThreadLocalObject;
+
+PlatformPosix::PlatformPosix() {
+  PERFETTO_CHECK(!g_instance);
+  g_instance = this;
+  auto tls_dtor = [](void* obj) {
+    // The Posix TLS implementation resets the key before calling this dtor.
+    // Here we re-reset it to the object we are about to delete. This is to
+    // handle re-entrant usages of tracing in the PostTask done during the dtor
+    // (see comments in TracingTLS::~TracingTLS()). Chromium's platform
+    // implementation (which does NOT use this platform impl) has a similar
+    // workaround (https://crrev.com/c/2748300).
+    pthread_setspecific(g_instance->tls_key_, obj);
+    delete static_cast<ThreadLocalObject*>(obj);
+    pthread_setspecific(g_instance->tls_key_, nullptr);
+  };
+  PERFETTO_CHECK(pthread_key_create(&tls_key_, tls_dtor) == 0);
+}
+
+PlatformPosix::~PlatformPosix() {
+  // pthread_key_delete doesn't call destructors, so do it manually for the
+  // calling thread.
+  void* tls_ptr = pthread_getspecific(tls_key_);
+  delete static_cast<ThreadLocalObject*>(tls_ptr);
+
+  pthread_key_delete(tls_key_);
+  g_instance = nullptr;
+}
+
+void PlatformPosix::Shutdown() {
+  PERFETTO_CHECK(g_instance == this);
+  delete this;
+  PERFETTO_CHECK(!g_instance);
+  // We're not clearing out the instance in GetDefaultPlatform() since it's not
+  // possible to re-initialize Perfetto after calling this function anyway.
+}
+
+ThreadLocalObject* PlatformPosix::GetOrCreateThreadLocalObject() {
+  // In chromium this should be implemented using base::ThreadLocalStorage.
+  void* tls_ptr = pthread_getspecific(tls_key_);
+
+  // This is needed to handle re-entrant calls during TLS dtor.
+  // See comments in platform.cc and aosp/1712371 .
+  ThreadLocalObject* tls = static_cast<ThreadLocalObject*>(tls_ptr);
+  if (!tls) {
+    tls = ThreadLocalObject::CreateInstance().release();
+    pthread_setspecific(tls_key_, tls);
   }
+  return tls;
+}
 
-  const void* start;
-  size_t size;
+std::unique_ptr<base::TaskRunner> PlatformPosix::CreateTaskRunner(
+    const CreateTaskRunnerArgs& args) {
+  return std::unique_ptr<base::TaskRunner>(new base::ThreadTaskRunner(
+      base::ThreadTaskRunner::CreateAndStart(args.name_for_debugging)));
+}
 
- private:
-  Slice(const Slice&) = delete;
-  void operator=(const Slice&) = delete;
+std::string PlatformPosix::GetCurrentProcessName() {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+  std::string cmdline;
+  base::ReadFile("/proc/self/cmdline", &cmdline);
+  return cmdline.substr(0, cmdline.find('\0'));
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD)
+  return std::string(getprogname());
+#else
+  return "unknown_producer";
+#endif
+}
 
-  std::unique_ptr<uint8_t[]> own_data_;
-};
+}  // namespace
 
-// TODO(primiano): most TracePacket(s) fit in a slice or two. We need something
-// a bit more clever here that has inline capacity for 2 slices and then uses a
-// std::forward_list or a std::vector for the less likely cases.
-using Slices = std::vector<Slice>;
+// static
+Platform* Platform::GetDefaultPlatform() {
+  static PlatformPosix* instance = new PlatformPosix();
+  return instance;
+}
 
 }  // namespace perfetto
-
-#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_SLICE_H_
+#endif  // OS_LINUX || OS_ANDROID || OS_APPLE || OS_FUCHSIA
+// gen_amalgamated begin source: src/tracing/platform_windows.cc
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2021 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -41875,83 +47691,168 @@ using Slices = std::vector<Slice>;
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACE_PACKET_H_
-#define INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACE_PACKET_H_
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
 
-#include <stddef.h>
-#include <memory>
-#include <tuple>
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
 
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/slice.h"
+#include <windows.h>
+
+// gen_amalgamated expanded: #include "perfetto/ext/base/thread_task_runner.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_tls.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/platform.h"
+
+// Thread Termination Callbacks.
+// Windows doesn't support a per-thread destructor with its
+// TLS primitives. So, we build it manually by inserting a
+// function to be called on each thread's exit.
+// This magic is from chromium's base/threading/thread_local_storage_win.cc
+// which in turn is from http://www.codeproject.com/threads/tls.asp.
+
+#ifdef _WIN64
+#pragma comment(linker, "/INCLUDE:_tls_used")
+#pragma comment(linker, "/INCLUDE:perfetto_thread_callback_base")
+#else
+#pragma comment(linker, "/INCLUDE:__tls_used")
+#pragma comment(linker, "/INCLUDE:_perfetto_thread_callback_base")
+#endif
 
 namespace perfetto {
 
-// A wrapper around a byte buffer that contains a protobuf-encoded TracePacket
-// (see trace_packet.proto). The TracePacket is decoded only if the Consumer
-// requests that. This is to allow Consumer(s) to just stream the packet over
-// the network or save it to a file without wasting time decoding it and without
-// needing to depend on libprotobuf or the trace_packet.pb.h header.
-// If the packets are saved / streamed and not just consumed locally, consumers
-// should ensure to preserve the unknown fields in the proto. A consumer, in
-// fact, might have an older version .proto which is newer on the producer.
-class PERFETTO_EXPORT_COMPONENT TracePacket {
+namespace {
+
+class PlatformWindows : public Platform {
  public:
-  using const_iterator = Slices::const_iterator;
+  static PlatformWindows* instance;
+  PlatformWindows();
+  ~PlatformWindows() override;
 
-  // The field id of protos::Trace::packet, static_assert()-ed in the unittest.
-  static constexpr uint32_t kPacketFieldNumber = 1;
+  ThreadLocalObject* GetOrCreateThreadLocalObject() override;
+  std::unique_ptr<base::TaskRunner> CreateTaskRunner(
+      const CreateTaskRunnerArgs&) override;
+  std::string GetCurrentProcessName() override;
+  void OnThreadExit();
 
-  // Maximum size of the preamble returned by GetProtoPreamble().
-  static constexpr size_t kMaxPreambleBytes = 8;
+ private:
+  DWORD tls_key_{};
+};
 
-  TracePacket();
-  ~TracePacket();
-  TracePacket(TracePacket&&) noexcept;
-  TracePacket& operator=(TracePacket&&);
+using ThreadLocalObject = Platform::ThreadLocalObject;
 
-  // Accesses all the raw slices in the packet, for saving them to file/network.
-  const Slices& slices() const { return slices_; }
+// static
+PlatformWindows* PlatformWindows::instance = nullptr;
 
-  // Mutator, used only by the service and tests.
-  void AddSlice(Slice);
+PlatformWindows::PlatformWindows() {
+  instance = this;
+  tls_key_ = ::TlsAlloc();
+  PERFETTO_CHECK(tls_key_ != TLS_OUT_OF_INDEXES);
+}
 
-  // Does not copy / take ownership of the memory of the slice. The TracePacket
-  // will be valid only as long as the original buffer is valid.
-  void AddSlice(const void* start, size_t size);
+PlatformWindows::~PlatformWindows() {
+  ::TlsFree(tls_key_);
+  instance = nullptr;
+}
 
-  // Total size of all slices.
-  size_t size() const { return size_; }
+void PlatformWindows::OnThreadExit() {
+  auto tls = static_cast<ThreadLocalObject*>(::TlsGetValue(tls_key_));
+  if (tls) {
+    // At this point we rely on the TLS object to be still set to the TracingTLS
+    // we are deleting. See comments in TracingTLS::~TracingTLS().
+    delete tls;
+  }
+}
 
-  // Generates a protobuf preamble suitable to represent this packet as a
-  // repeated field within a root trace.proto message.
-  // Returns a pointer to a buffer, owned by this class, containing the preamble
-  // and its size.
-  std::tuple<char*, size_t> GetProtoPreamble();
+ThreadLocalObject* PlatformWindows::GetOrCreateThreadLocalObject() {
+  void* tls_ptr = ::TlsGetValue(tls_key_);
 
-  // Returns the raw protobuf bytes of the slices, all stitched together into
-  // a string. Only for testing.
-  std::string GetRawBytesForTesting();
+  auto* tls = static_cast<ThreadLocalObject*>(tls_ptr);
+  if (!tls) {
+    tls = ThreadLocalObject::CreateInstance().release();
+    ::TlsSetValue(tls_key_, tls);
+  }
+  return tls;
+}
 
- private:
-  TracePacket(const TracePacket&) = delete;
-  TracePacket& operator=(const TracePacket&) = delete;
+std::unique_ptr<base::TaskRunner> PlatformWindows::CreateTaskRunner(
+    const CreateTaskRunnerArgs& args) {
+  return std::unique_ptr<base::TaskRunner>(new base::ThreadTaskRunner(
+      base::ThreadTaskRunner::CreateAndStart(args.name_for_debugging)));
+}
 
-  Slices slices_;     // Not owned.
-  size_t size_ = 0;   // SUM(slice.size for slice in slices_).
-  char preamble_[kMaxPreambleBytes];  // Deliberately not initialized.
+std::string PlatformWindows::GetCurrentProcessName() {
+  char buf[MAX_PATH];
+  auto len = ::GetModuleFileNameA(nullptr /*current*/, buf, sizeof(buf));
+  std::string name(buf, static_cast<size_t>(len));
+  size_t sep = name.find_last_of('\\');
+  if (sep != std::string::npos)
+    name = name.substr(sep + 1);
+  return name;
+}
 
-  // Remember to update the move operators and their unittest if adding new
-  // fields. ConsumerIPCClientImpl::OnReadBuffersResponse() relies on
-  // std::move(TracePacket) to clear up the moved-from instance.
-};
+}  // namespace
+
+// static
+Platform* Platform::GetDefaultPlatform() {
+  static PlatformWindows* thread_safe_init_instance = new PlatformWindows();
+  return thread_safe_init_instance;
+}
 
 }  // namespace perfetto
 
-#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACE_PACKET_H_
+// -----------------------
+// Thread-local destructor
+// -----------------------
+
+// .CRT$XLA to .CRT$XLZ is an array of PIMAGE_TLS_CALLBACK pointers that are
+// called automatically by the OS loader code (not the CRT) when the module is
+// loaded and on thread creation. They are NOT called if the module has been
+// loaded by a LoadLibrary() call. It must have implicitly been loaded at
+// process startup.
+// See VC\crt\src\tlssup.c for reference.
+
+// extern "C" suppresses C++ name mangling so we know the symbol name for the
+// linker /INCLUDE:symbol pragma above.
+extern "C" {
+// The linker must not discard perfetto_thread_callback_base. (We force a
+// reference to this variable with a linker /INCLUDE:symbol pragma to ensure
+// that.) If this variable is discarded, the OnThreadExit function will never be
+// called.
+
+void NTAPI PerfettoOnThreadExit(PVOID, DWORD, PVOID);
+void NTAPI PerfettoOnThreadExit(PVOID, DWORD reason, PVOID) {
+  if (reason == DLL_THREAD_DETACH || reason == DLL_PROCESS_DETACH) {
+    if (perfetto::PlatformWindows::instance)
+      perfetto::PlatformWindows::instance->OnThreadExit();
+  }
+}
+
+#ifdef _WIN64
+
+// .CRT section is merged with .rdata on x64 so it must be constant data.
+#pragma const_seg(".CRT$XLP")
+
+// When defining a const variable, it must have external linkage to be sure the
+// linker doesn't discard it.
+extern const PIMAGE_TLS_CALLBACK perfetto_thread_callback_base;
+const PIMAGE_TLS_CALLBACK perfetto_thread_callback_base = PerfettoOnThreadExit;
+
+// Reset the default section.
+#pragma const_seg()
+
+#else  // _WIN64
+
+#pragma data_seg(".CRT$XLP")
+PIMAGE_TLS_CALLBACK perfetto_thread_callback_base = PerfettoOnThreadExit;
+// Reset the default section.
+#pragma data_seg()
+
+#endif  // _WIN64
+
+}  // extern "C"
+
+#endif  // OS_WIN
+// gen_amalgamated begin source: src/tracing/traced_value.cc
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2021 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -41966,70 +47867,177 @@ class PERFETTO_EXPORT_COMPONENT TracePacket {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_packet.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/traced_value.h"
 
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/debug_annotation.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/track_event_interned_fields.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/debug_annotation.pbzero.h"
+
+namespace perfetto {
+
+namespace internal {
+
+TracedValue CreateTracedValueFromProto(
+    protos::pbzero::DebugAnnotation* annotation,
+    EventContext* event_context) {
+  return TracedValue::CreateFromProto(annotation, event_context);
+}
+
+}  // namespace internal
+
+// static
+TracedValue TracedValue::CreateFromProto(
+    protos::pbzero::DebugAnnotation* annotation,
+    EventContext* event_context) {
+  return TracedValue(annotation, event_context, nullptr);
+}
+
+TracedValue::TracedValue(TracedValue&&) = default;
+TracedValue::~TracedValue() = default;
+
+void TracedValue::WriteInt64(int64_t value) && {
+  PERFETTO_DCHECK(checked_scope_.is_active());
+  annotation_->set_int_value(value);
+}
+
+void TracedValue::WriteUInt64(uint64_t value) && {
+  PERFETTO_DCHECK(checked_scope_.is_active());
+  annotation_->set_uint_value(value);
+}
+
+void TracedValue::WriteDouble(double value) && {
+  PERFETTO_DCHECK(checked_scope_.is_active());
+  annotation_->set_double_value(value);
+}
+
+void TracedValue::WriteBoolean(bool value) && {
+  PERFETTO_DCHECK(checked_scope_.is_active());
+  annotation_->set_bool_value(value);
+}
+
+void TracedValue::WriteString(const char* value) && {
+  PERFETTO_DCHECK(checked_scope_.is_active());
+  annotation_->set_string_value(value);
+}
+
+void TracedValue::WriteString(const char* value, size_t len) && {
+  PERFETTO_DCHECK(checked_scope_.is_active());
+  annotation_->set_string_value(value, len);
+}
+
+void TracedValue::WriteString(const std::string& value) && {
+  PERFETTO_DCHECK(checked_scope_.is_active());
+  annotation_->set_string_value(value);
+}
+
+void TracedValue::WriteString(std::string_view value) && {
+  PERFETTO_DCHECK(checked_scope_.is_active());
+  annotation_->set_string_value(value.data(), value.size());
+}
+
+void TracedValue::WritePointer(const void* value) && {
+  PERFETTO_DCHECK(checked_scope_.is_active());
+  annotation_->set_pointer_value(reinterpret_cast<uint64_t>(value));
+}
+
+TracedDictionary TracedValue::WriteDictionary() && {
+  // Note: this passes |checked_scope_.is_active_| bit to the parent to be
+  // picked up later by the new TracedDictionary.
+  PERFETTO_DCHECK(checked_scope_.is_active());
+  checked_scope_.Reset();
+
+  PERFETTO_DCHECK(!annotation_->is_finalized());
+  return TracedDictionary(annotation_,
+                          protos::pbzero::DebugAnnotation::kDictEntries,
+                          event_context_, checked_scope_.parent_scope());
+}
+
+TracedArray TracedValue::WriteArray() && {
+  // Note: this passes |checked_scope_.is_active_| bit to the parent to be
+  // picked up later by the new TracedDictionary.
+  PERFETTO_DCHECK(checked_scope_.is_active());
+  checked_scope_.Reset();
+
+  PERFETTO_DCHECK(!annotation_->is_finalized());
+  return TracedArray(annotation_, event_context_,
+                     checked_scope_.parent_scope());
+}
+
+protozero::Message* TracedValue::WriteProtoInternal(const char* name) {
+  if (event_context_) {
+    annotation_->set_proto_type_name_iid(
+        internal::InternedDebugAnnotationValueTypeName::Get(event_context_,
+                                                            name));
+  } else {
+    annotation_->set_proto_type_name(name);
+  }
+  return annotation_->template BeginNestedMessage<protozero::Message>(
+      protos::pbzero::DebugAnnotation::kProtoValueFieldNumber);
+}
 
-namespace perfetto {
+TracedArray::TracedArray(TracedValue annotation)
+    : TracedArray(std::move(annotation).WriteArray()) {}
 
-TracePacket::TracePacket() = default;
-TracePacket::~TracePacket() = default;
+TracedValue TracedArray::AppendItem() {
+  PERFETTO_DCHECK(checked_scope_.is_active());
+  return TracedValue(annotation_->add_array_values(), event_context_,
+                     &checked_scope_);
+}
 
-TracePacket::TracePacket(TracePacket&& other) noexcept {
-  *this = std::move(other);
+TracedDictionary TracedArray::AppendDictionary() {
+  PERFETTO_DCHECK(checked_scope_.is_active());
+  return AppendItem().WriteDictionary();
 }
 
-TracePacket& TracePacket::operator=(TracePacket&& other) {
-  slices_ = std::move(other.slices_);
-  other.slices_.clear();
-  size_ = other.size_;
-  other.size_ = 0;
-  return *this;
+TracedArray TracedArray::AppendArray() {
+  PERFETTO_DCHECK(checked_scope_.is_active());
+  return AppendItem().WriteArray();
 }
 
-void TracePacket::AddSlice(Slice slice) {
-  size_ += slice.size;
-  slices_.push_back(std::move(slice));
+TracedDictionary::TracedDictionary(TracedValue annotation)
+    : TracedDictionary(std::move(annotation).WriteDictionary()) {}
+
+TracedValue TracedDictionary::AddItem(StaticString key) {
+  PERFETTO_DCHECK(checked_scope_.is_active());
+  protos::pbzero::DebugAnnotation* item =
+      message_->BeginNestedMessage<protos::pbzero::DebugAnnotation>(field_id_);
+  item->set_name(key.value);
+  return TracedValue(item, event_context_, &checked_scope_);
 }
 
-void TracePacket::AddSlice(const void* start, size_t size) {
-  size_ += size;
-  slices_.emplace_back(start, size);
+TracedValue TracedDictionary::AddItem(DynamicString key) {
+  PERFETTO_DCHECK(checked_scope_.is_active());
+  protos::pbzero::DebugAnnotation* item =
+      message_->BeginNestedMessage<protos::pbzero::DebugAnnotation>(field_id_);
+  item->set_name(key.value);
+  return TracedValue(item, event_context_, &checked_scope_);
 }
 
-std::tuple<char*, size_t> TracePacket::GetProtoPreamble() {
-  using protozero::proto_utils::MakeTagLengthDelimited;
-  using protozero::proto_utils::WriteVarInt;
-  uint8_t* ptr = reinterpret_cast<uint8_t*>(&preamble_[0]);
+TracedDictionary TracedDictionary::AddDictionary(StaticString key) {
+  PERFETTO_DCHECK(checked_scope_.is_active());
+  return AddItem(key).WriteDictionary();
+}
 
-  constexpr uint8_t tag = MakeTagLengthDelimited(kPacketFieldNumber);
-  static_assert(tag < 0x80, "TracePacket tag should fit in one byte");
-  *(ptr++) = tag;
+TracedDictionary TracedDictionary::AddDictionary(DynamicString key) {
+  PERFETTO_DCHECK(checked_scope_.is_active());
+  return AddItem(key).WriteDictionary();
+}
 
-  ptr = WriteVarInt(size(), ptr);
-  size_t preamble_size = reinterpret_cast<uintptr_t>(ptr) -
-                         reinterpret_cast<uintptr_t>(&preamble_[0]);
-  PERFETTO_DCHECK(preamble_size <= sizeof(preamble_));
-  return std::make_tuple(&preamble_[0], preamble_size);
+TracedArray TracedDictionary::AddArray(StaticString key) {
+  PERFETTO_DCHECK(checked_scope_.is_active());
+  return AddItem(key).WriteArray();
 }
 
-std::string TracePacket::GetRawBytesForTesting() {
-  std::string data;
-  data.resize(size());
-  size_t pos = 0;
-  for (const Slice& slice : slices()) {
-    PERFETTO_CHECK(pos + slice.size <= data.size());
-    memcpy(&data[pos], slice.start, slice.size);
-    pos += slice.size;
-  }
-  return data;
+TracedArray TracedDictionary::AddArray(DynamicString key) {
+  PERFETTO_DCHECK(checked_scope_.is_active());
+  return AddItem(key).WriteArray();
 }
 
 }  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/core/trace_writer_impl.cc
+// gen_amalgamated begin source: src/tracing/tracing.cc
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -42044,416 +48052,211 @@ std::string TracePacket::GetRawBytesForTesting() {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "src/tracing/core/trace_writer_impl.h"
-
-#include <string.h>
-
-#include <algorithm>
-#include <type_traits>
-#include <utility>
-
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/thread_annotations.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/root_message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/static_buffer.h"
-// gen_amalgamated expanded: #include "src/tracing/core/shared_memory_arbiter_impl.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/tracing.h"
 
-// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h"
+#include <atomic>
+#include <condition_variable>
+#include <mutex>
 
-using protozero::proto_utils::kMessageLengthFieldSize;
-using protozero::proto_utils::WriteRedundantVarInt;
-using ChunkHeader = perfetto::SharedMemoryABI::ChunkHeader;
+// gen_amalgamated expanded: #include "perfetto/base/time.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/no_destructor.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/waitable_event.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/track_event_data_source.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/track_event_internal.h"
+// gen_amalgamated expanded: #include "src/tracing/internal/tracing_muxer_impl.h"
 
 namespace perfetto {
-
 namespace {
-constexpr size_t kPacketHeaderSize = SharedMemoryABI::kPacketHeaderSize;
-uint8_t g_garbage_chunk[1024];
-}  // namespace
-
-TraceWriterImpl::TraceWriterImpl(SharedMemoryArbiterImpl* shmem_arbiter,
-                                 WriterID id,
-                                 MaybeUnboundBufferID target_buffer,
-                                 BufferExhaustedPolicy buffer_exhausted_policy)
-    : shmem_arbiter_(shmem_arbiter),
-      id_(id),
-      target_buffer_(target_buffer),
-      buffer_exhausted_policy_(buffer_exhausted_policy),
-      protobuf_stream_writer_(this),
-      process_id_(base::GetProcessId()) {
-  // TODO(primiano): we could handle the case of running out of TraceWriterID(s)
-  // more gracefully and always return a no-op TracePacket in NewTracePacket().
-  PERFETTO_CHECK(id_ != 0);
-
-  cur_packet_.reset(new protozero::RootMessage<protos::pbzero::TracePacket>());
-  cur_packet_->Finalize();  // To avoid the CHECK in NewTracePacket().
-}
-
-TraceWriterImpl::~TraceWriterImpl() {
-  if (cur_chunk_.is_valid()) {
-    cur_packet_->Finalize();
-    Flush();
-  }
-  // This call may cause the shared memory arbiter (and the underlying memory)
-  // to get asynchronously deleted if this was the last trace writer targeting
-  // the arbiter and the arbiter was marked for shutdown.
-  shmem_arbiter_->ReleaseWriterID(id_);
-}
-
-void TraceWriterImpl::Flush(std::function<void()> callback) {
-  // Flush() cannot be called in the middle of a TracePacket.
-  PERFETTO_CHECK(cur_packet_->is_finalized());
-
-  if (cur_chunk_.is_valid()) {
-    shmem_arbiter_->ReturnCompletedChunk(std::move(cur_chunk_), target_buffer_,
-                                         &patch_list_);
-  } else {
-    // When in stall mode, all patches should have been returned with the last
-    // chunk, since the last packet was completed. In drop_packets_ mode, this
-    // may not be the case because the packet may have been fragmenting when
-    // SMB exhaustion occurred and |cur_chunk_| became invalid. In this case,
-    // drop_packets_ should be true.
-    PERFETTO_DCHECK(patch_list_.empty() || drop_packets_);
-  }
-
-  // Always issue the Flush request, even if there is nothing to flush, just
-  // for the sake of getting the callback posted back.
-  shmem_arbiter_->FlushPendingCommitDataRequests(callback);
-  protobuf_stream_writer_.Reset({nullptr, nullptr});
+bool g_was_initialized = false;
 
-  // |last_packet_size_field_| might have pointed into the chunk we returned.
-  last_packet_size_field_ = nullptr;
+// Wrapped in a function to avoid global constructor
+std::mutex& InitializedMutex() {
+  static base::NoDestructor<std::mutex> initialized_mutex;
+  return initialized_mutex.ref();
 }
+}  // namespace
 
-TraceWriterImpl::TracePacketHandle TraceWriterImpl::NewTracePacket() {
-  // If we hit this, the caller is calling NewTracePacket() without having
-  // finalized the previous packet.
-  PERFETTO_CHECK(cur_packet_->is_finalized());
-  // If we hit this, this trace writer was created in a different process. This
-  // likely means that the process forked while tracing was active, and the
-  // forked child process tried to emit a trace event. This is not supported, as
-  // it would lead to two processes writing to the same tracing SMB.
-  PERFETTO_DCHECK(process_id_ == base::GetProcessId());
-
-  fragmenting_packet_ = false;
-
-  // Reserve space for the size of the message. Note: this call might re-enter
-  // into this class invoking GetNewBuffer() if there isn't enough space or if
-  // this is the very first call to NewTracePacket().
-  static_assert(kPacketHeaderSize == kMessageLengthFieldSize,
-                "The packet header must match the Message header size");
-
-  bool was_dropping_packets = drop_packets_;
-
-  // It doesn't make sense to begin a packet that is going to fragment
-  // immediately after (8 is just an arbitrary estimation on the minimum size of
-  // a realistic packet).
-  bool chunk_too_full =
-      protobuf_stream_writer_.bytes_available() < kPacketHeaderSize + 8;
-  if (chunk_too_full || reached_max_packets_per_chunk_ ||
-      retry_new_chunk_after_packet_) {
-    protobuf_stream_writer_.Reset(GetNewBuffer());
-  }
-
-  // Send any completed patches to the service to facilitate trace data
-  // recovery by the service. This should only happen when we're completing
-  // the first packet in a chunk which was a continuation from the previous
-  // chunk, i.e. at most once per chunk.
-  if (!patch_list_.empty() && patch_list_.front().is_patched()) {
-    shmem_arbiter_->SendPatches(id_, target_buffer_, &patch_list_);
-  }
-
-  cur_packet_->Reset(&protobuf_stream_writer_);
-  uint8_t* header = protobuf_stream_writer_.ReserveBytes(kPacketHeaderSize);
-  memset(header, 0, kPacketHeaderSize);
-  cur_packet_->set_size_field(header);
-  last_packet_size_field_ = header;
-
-  TracePacketHandle handle(cur_packet_.get());
-  cur_fragment_start_ = protobuf_stream_writer_.write_ptr();
-  fragmenting_packet_ = true;
-
-  if (PERFETTO_LIKELY(!drop_packets_)) {
-    uint16_t new_packet_count = cur_chunk_.IncrementPacketCount();
-    reached_max_packets_per_chunk_ =
-        new_packet_count == ChunkHeader::Packets::kMaxCount;
+// static
+void Tracing::InitializeInternal(const TracingInitArgs& args) {
+  base::InitializeTime();
+  std::unique_lock<std::mutex> lock(InitializedMutex());
+  // If it's the first time Initialize is called, set some global params.
+  if (!g_was_initialized) {
+    // Make sure the headers and implementation files agree on the build config.
+    PERFETTO_CHECK(args.dcheck_is_on_ == PERFETTO_DCHECK_IS_ON());
+    if (args.log_message_callback) {
+      base::SetLogMessageCallback(args.log_message_callback);
+    }
 
-    if (PERFETTO_UNLIKELY(was_dropping_packets)) {
-      // We've succeeded to get a new chunk from the SMB after we entered
-      // drop_packets_ mode. Record a marker into the new packet to indicate the
-      // data loss.
-      cur_packet_->set_previous_packet_dropped(true);
+    if (args.use_monotonic_clock) {
+      PERFETTO_CHECK(!args.use_monotonic_raw_clock);
+      internal::TrackEventInternal::SetClockId(
+          protos::pbzero::BUILTIN_CLOCK_MONOTONIC);
+    } else if (args.use_monotonic_raw_clock) {
+      internal::TrackEventInternal::SetClockId(
+          protos::pbzero::BUILTIN_CLOCK_MONOTONIC_RAW);
     }
-  }
 
-  if (PERFETTO_UNLIKELY(first_packet_on_sequence_)) {
-    cur_packet_->set_first_packet_on_sequence(true);
-    first_packet_on_sequence_ = false;
+    if (args.disallow_merging_with_system_tracks) {
+      internal::TrackEventInternal::SetDisallowMergingWithSystemTracks(true);
+    }
   }
 
-  return handle;
+  internal::TracingMuxerImpl::InitializeInstance(args);
+  internal::TrackRegistry::InitializeInstance(args.process_uuid);
+  g_was_initialized = true;
 }
 
-// Called by the Message. We can get here in two cases:
-// 1. In the middle of writing a Message,
-// when |fragmenting_packet_| == true. In this case we want to update the
-// chunk header with a partial packet and start a new partial packet in the
-// new chunk.
-// 2. While calling ReserveBytes() for the packet header in NewTracePacket().
-// In this case |fragmenting_packet_| == false and we just want a new chunk
-// without creating any fragments.
-protozero::ContiguousMemoryRange TraceWriterImpl::GetNewBuffer() {
-  if (fragmenting_packet_ && drop_packets_) {
-    // We can't write the remaining data of the fragmenting packet to a new
-    // chunk, because we have already lost some of its data in the garbage
-    // chunk. Thus, we will wrap around in the garbage chunk, wait until the
-    // current packet was completed, and then attempt to get a new chunk from
-    // the SMB again. Instead, if |drop_packets_| is true and
-    // |fragmenting_packet_| is false, we try to acquire a valid chunk because
-    // the SMB exhaustion might be resolved.
-    retry_new_chunk_after_packet_ = true;
-    return protozero::ContiguousMemoryRange{
-        &g_garbage_chunk[0], &g_garbage_chunk[0] + sizeof(g_garbage_chunk)};
-  }
-
-  // Attempt to grab the next chunk before finalizing the current one, so that
-  // we know whether we need to start dropping packets before writing the
-  // current packet fragment's header.
-  ChunkHeader::Packets packets = {};
-  if (fragmenting_packet_) {
-    packets.count = 1;
-    packets.flags = ChunkHeader::kFirstPacketContinuesFromPrevChunk;
-  }
-
-  // The memory order of the stores below doesn't really matter. This |header|
-  // is just a local temporary object. The GetNewChunk() call below will copy it
-  // into the shared buffer with the proper barriers.
-  ChunkHeader header = {};
-  header.writer_id.store(id_, std::memory_order_relaxed);
-  header.chunk_id.store(next_chunk_id_, std::memory_order_relaxed);
-  header.packets.store(packets, std::memory_order_relaxed);
-
-  SharedMemoryABI::Chunk new_chunk =
-      shmem_arbiter_->GetNewChunk(header, buffer_exhausted_policy_);
-  if (!new_chunk.is_valid()) {
-    // Shared memory buffer exhausted, switch into |drop_packets_| mode. We'll
-    // drop data until the garbage chunk has been filled once and then retry.
-
-    // If we started a packet in one of the previous (valid) chunks, we need to
-    // tell the service to discard it.
-    if (fragmenting_packet_) {
-      // We can only end up here if the previous chunk was a valid chunk,
-      // because we never try to acquire a new chunk in |drop_packets_| mode
-      // while fragmenting.
-      PERFETTO_DCHECK(!drop_packets_);
-
-      // Backfill the last fragment's header with an invalid size (too large),
-      // so that the service's TraceBuffer throws out the incomplete packet.
-      // It'll restart reading from the next chunk we submit.
-      WriteRedundantVarInt(SharedMemoryABI::kPacketSizeDropPacket,
-                           cur_packet_->size_field());
-
-      // Reset the size field, since we should not write the current packet's
-      // size anymore after this.
-      cur_packet_->set_size_field(nullptr);
-
-      // We don't set kLastPacketContinuesOnNextChunk or kChunkNeedsPatching on
-      // the last chunk, because its last fragment will be discarded anyway.
-      // However, the current packet fragment points to a valid |cur_chunk_| and
-      // may have non-finalized nested messages which will continue in the
-      // garbage chunk and currently still point into |cur_chunk_|. As we are
-      // about to return |cur_chunk_|, we need to invalidate the size fields of
-      // those nested messages. Normally we move them in the |patch_list_| (see
-      // below) but in this case, it doesn't make sense to send patches for a
-      // fragment that will be discarded for sure. Thus, we clean up any size
-      // field references into |cur_chunk_|.
-      for (auto* nested_msg = cur_packet_->nested_message(); nested_msg;
-           nested_msg = nested_msg->nested_message()) {
-        uint8_t* const cur_hdr = nested_msg->size_field();
-
-        // If this is false the protozero Message has already been instructed to
-        // write, upon Finalize(), its size into the patch list.
-        bool size_field_points_within_chunk =
-            cur_hdr >= cur_chunk_.payload_begin() &&
-            cur_hdr + kMessageLengthFieldSize <= cur_chunk_.end();
-
-        if (size_field_points_within_chunk)
-          nested_msg->set_size_field(nullptr);
-      }
-    } else if (!drop_packets_ && last_packet_size_field_) {
-      // If we weren't dropping packets before, we should indicate to the
-      // service that we're about to lose data. We do this by invalidating the
-      // size of the last packet in |cur_chunk_|. The service will record
-      // statistics about packets with kPacketSizeDropPacket size.
-      PERFETTO_DCHECK(cur_packet_->is_finalized());
-      PERFETTO_DCHECK(cur_chunk_.is_valid());
-
-      // |last_packet_size_field_| should point within |cur_chunk_|'s payload.
-      PERFETTO_DCHECK(last_packet_size_field_ >= cur_chunk_.payload_begin() &&
-                      last_packet_size_field_ + kMessageLengthFieldSize <=
-                          cur_chunk_.end());
+// static
+bool Tracing::IsInitialized() {
+  std::unique_lock<std::mutex> lock(InitializedMutex());
+  return g_was_initialized;
+}
 
-      WriteRedundantVarInt(SharedMemoryABI::kPacketSizeDropPacket,
-                           last_packet_size_field_);
-    }
+// static
+void Tracing::Shutdown() {
+  std::unique_lock<std::mutex> lock(InitializedMutex());
+  if (!g_was_initialized)
+    return;
+  internal::TracingMuxerImpl::Shutdown();
+  g_was_initialized = false;
+}
 
-    if (cur_chunk_.is_valid()) {
-      shmem_arbiter_->ReturnCompletedChunk(std::move(cur_chunk_),
-                                           target_buffer_, &patch_list_);
-    }
+// static
+void Tracing::ResetForTesting() {
+  std::unique_lock<std::mutex> lock(InitializedMutex());
+  if (!g_was_initialized)
+    return;
+  base::SetLogMessageCallback(nullptr);
+  internal::TracingMuxerImpl::ResetForTesting();
+  internal::TrackRegistry::ResetForTesting();
+  internal::TrackEventDataSource::ResetForTesting();
+  g_was_initialized = false;
+}
 
-    drop_packets_ = true;
-    cur_chunk_ = SharedMemoryABI::Chunk();  // Reset to an invalid chunk.
-    reached_max_packets_per_chunk_ = false;
-    retry_new_chunk_after_packet_ = false;
-    last_packet_size_field_ = nullptr;
+//  static
+std::unique_ptr<TracingSession> Tracing::NewTraceInternal(
+    BackendType backend,
+    TracingConsumerBackend* (*system_backend_factory)()) {
+  return static_cast<internal::TracingMuxerImpl*>(internal::TracingMuxer::Get())
+      ->CreateTracingSession(backend, system_backend_factory);
+}
 
-    PERFETTO_ANNOTATE_BENIGN_RACE_SIZED(&g_garbage_chunk,
-                                        sizeof(g_garbage_chunk),
-                                        "nobody reads the garbage chunk")
-    return protozero::ContiguousMemoryRange{
-        &g_garbage_chunk[0], &g_garbage_chunk[0] + sizeof(g_garbage_chunk)};
-  }  // if (!new_chunk.is_valid())
+//  static
+std::unique_ptr<StartupTracingSession> Tracing::SetupStartupTracing(
+    const TraceConfig& config,
+    Tracing::SetupStartupTracingOpts opts) {
+  return static_cast<internal::TracingMuxerImpl*>(internal::TracingMuxer::Get())
+      ->CreateStartupTracingSession(config, std::move(opts));
+}
 
-  PERFETTO_DCHECK(new_chunk.is_valid());
+//  static
+std::unique_ptr<StartupTracingSession> Tracing::SetupStartupTracingBlocking(
+    const TraceConfig& config,
+    Tracing::SetupStartupTracingOpts opts) {
+  return static_cast<internal::TracingMuxerImpl*>(internal::TracingMuxer::Get())
+      ->CreateStartupTracingSessionBlocking(config, std::move(opts));
+}
 
-  if (fragmenting_packet_) {
-    // We should not be fragmenting a packet after we exited drop_packets_ mode,
-    // because we only retry to get a new chunk when a fresh packet is started.
-    PERFETTO_DCHECK(!drop_packets_);
+//  static
+void Tracing::ActivateTriggers(const std::vector<std::string>& triggers,
+                               uint32_t ttl_ms) {
+  internal::TracingMuxer::Get()->ActivateTriggers(triggers, ttl_ms);
+}
 
-    uint8_t* const wptr = protobuf_stream_writer_.write_ptr();
-    PERFETTO_DCHECK(wptr >= cur_fragment_start_);
-    uint32_t partial_size = static_cast<uint32_t>(wptr - cur_fragment_start_);
-    PERFETTO_DCHECK(partial_size < cur_chunk_.size());
+TracingSession::~TracingSession() = default;
 
-    // Backfill the packet header with the fragment size.
-    PERFETTO_DCHECK(partial_size > 0);
-    cur_packet_->inc_size_already_written(partial_size);
-    cur_chunk_.SetFlag(ChunkHeader::kLastPacketContinuesOnNextChunk);
-    WriteRedundantVarInt(partial_size, cur_packet_->size_field());
+void TracingSession::CloneTrace(CloneTraceArgs, CloneTraceCallback) {}
 
-    // Descend in the stack of non-finalized nested submessages (if any) and
-    // detour their |size_field| into the |patch_list_|. At this point we have
-    // to release the chunk and they cannot write anymore into that.
-    for (auto* nested_msg = cur_packet_->nested_message(); nested_msg;
-         nested_msg = nested_msg->nested_message()) {
-      uint8_t* cur_hdr = nested_msg->size_field();
+// Can be called from any thread.
+bool TracingSession::FlushBlocking(uint32_t timeout_ms) {
+  std::atomic<bool> flush_result;
+  base::WaitableEvent flush_ack;
 
-      // If this is false the protozero Message has already been instructed to
-      // write, upon Finalize(), its size into the patch list.
-      bool size_field_points_within_chunk =
-          cur_hdr >= cur_chunk_.payload_begin() &&
-          cur_hdr + kMessageLengthFieldSize <= cur_chunk_.end();
+  // The non blocking Flush() can be called on any thread. It does the PostTask
+  // internally.
+  Flush(
+      [&flush_ack, &flush_result](bool res) {
+        flush_result = res;
+        flush_ack.Notify();
+      },
+      timeout_ms);
+  flush_ack.Wait();
+  return flush_result;
+}
 
-      if (size_field_points_within_chunk) {
-        cur_hdr = TraceWriterImpl::AnnotatePatch(cur_hdr);
-        nested_msg->set_size_field(cur_hdr);
-      } else {
-#if PERFETTO_DCHECK_IS_ON()
-        // Ensure that the size field of the message points to an element of the
-        // patch list.
-        auto patch_it = std::find_if(
-            patch_list_.begin(), patch_list_.end(),
-            [cur_hdr](const Patch& p) { return &p.size_field[0] == cur_hdr; });
-        PERFETTO_DCHECK(patch_it != patch_list_.end());
-#endif
-      }
-    }  // for(nested_msg)
-  }    // if(fragmenting_packet)
+std::vector<char> TracingSession::ReadTraceBlocking() {
+  std::vector<char> raw_trace;
+  std::mutex mutex;
+  std::condition_variable cv;
 
-  if (cur_chunk_.is_valid()) {
-    // ReturnCompletedChunk will consume the first patched entries from
-    // |patch_list_| and shrink it.
-    shmem_arbiter_->ReturnCompletedChunk(std::move(cur_chunk_), target_buffer_,
-                                         &patch_list_);
-  }
+  bool all_read = false;
 
-  // Switch to the new chunk.
-  drop_packets_ = false;
-  reached_max_packets_per_chunk_ = false;
-  retry_new_chunk_after_packet_ = false;
-  next_chunk_id_++;
-  cur_chunk_ = std::move(new_chunk);
-  last_packet_size_field_ = nullptr;
+  ReadTrace([&mutex, &raw_trace, &all_read, &cv](ReadTraceCallbackArgs cb) {
+    raw_trace.insert(raw_trace.end(), cb.data, cb.data + cb.size);
+    std::unique_lock<std::mutex> lock(mutex);
+    all_read = !cb.has_more;
+    if (all_read)
+      cv.notify_one();
+  });
 
-  uint8_t* payload_begin = cur_chunk_.payload_begin();
-  if (fragmenting_packet_) {
-    cur_packet_->set_size_field(payload_begin);
-    last_packet_size_field_ = payload_begin;
-    memset(payload_begin, 0, kPacketHeaderSize);
-    payload_begin += kPacketHeaderSize;
-    cur_fragment_start_ = payload_begin;
+  {
+    std::unique_lock<std::mutex> lock(mutex);
+    cv.wait(lock, [&all_read] { return all_read; });
   }
-
-  return protozero::ContiguousMemoryRange{payload_begin, cur_chunk_.end()};
+  return raw_trace;
 }
 
-void TraceWriterImpl::FinishTracePacket() {
-  // If we hit this, this trace writer was created in a different process. This
-  // likely means that the process forked while tracing was active, and the
-  // forked child process tried to emit a trace event. This is not supported, as
-  // it would lead to two processes writing to the same tracing SMB.
-  PERFETTO_DCHECK(process_id_ == base::GetProcessId());
+TracingSession::GetTraceStatsCallbackArgs
+TracingSession::GetTraceStatsBlocking() {
+  std::mutex mutex;
+  std::condition_variable cv;
+  GetTraceStatsCallbackArgs result;
+  bool stats_read = false;
 
-  // If the caller uses TakeStreamWriter(), cur_packet_->size() is not up to
-  // date, only the stream writer knows the exact size.
-  // cur_packet_->size_field() is still used to store the start of the fragment.
-  if (cur_packet_->size_field()) {
-    uint8_t* const wptr = protobuf_stream_writer_.write_ptr();
-    PERFETTO_DCHECK(wptr >= cur_fragment_start_);
-    uint32_t partial_size = static_cast<uint32_t>(wptr - cur_fragment_start_);
+  GetTraceStats(
+      [&mutex, &result, &stats_read, &cv](GetTraceStatsCallbackArgs args) {
+        result = std::move(args);
+        std::unique_lock<std::mutex> lock(mutex);
+        stats_read = true;
+        cv.notify_one();
+      });
 
-    WriteRedundantVarInt(partial_size, last_packet_size_field_);
+  {
+    std::unique_lock<std::mutex> lock(mutex);
+    cv.wait(lock, [&stats_read] { return stats_read; });
   }
+  return result;
+}
 
-  cur_packet_->Reset(&protobuf_stream_writer_);
-  cur_packet_->Finalize();  // To avoid the CHECK in NewTracePacket().
+TracingSession::QueryServiceStateCallbackArgs
+TracingSession::QueryServiceStateBlocking() {
+  std::mutex mutex;
+  std::condition_variable cv;
+  QueryServiceStateCallbackArgs result;
+  bool status_read = false;
 
-  // Send any completed patches to the service to facilitate trace data
-  // recovery by the service. This should only happen when we're completing
-  // the first packet in a chunk which was a continuation from the previous
-  // chunk, i.e. at most once per chunk.
-  if (!patch_list_.empty() && patch_list_.front().is_patched()) {
-    shmem_arbiter_->SendPatches(id_, target_buffer_, &patch_list_);
-  }
-}
+  QueryServiceState(
+      [&mutex, &result, &status_read, &cv](QueryServiceStateCallbackArgs args) {
+        result = std::move(args);
+        std::unique_lock<std::mutex> lock(mutex);
+        status_read = true;
+        cv.notify_one();
+      });
 
-uint8_t* TraceWriterImpl::AnnotatePatch(uint8_t* to_patch) {
-  if (!cur_chunk_.is_valid()) {
-    return nullptr;
-  }
-  auto offset = static_cast<uint16_t>(to_patch - cur_chunk_.payload_begin());
-  const ChunkID cur_chunk_id =
-      cur_chunk_.header()->chunk_id.load(std::memory_order_relaxed);
-  static_assert(kPatchSize == sizeof(Patch::PatchContent),
-                "Patch size mismatch");
-  Patch* patch = patch_list_.emplace_back(cur_chunk_id, offset);
-  // Check that the flag is not already set before setting it. This is not
-  // necessary, but it makes the code faster.
-  if (!(cur_chunk_.GetPacketCountAndFlags().second &
-        ChunkHeader::kChunkNeedsPatching)) {
-    cur_chunk_.SetFlag(ChunkHeader::kChunkNeedsPatching);
+  {
+    std::unique_lock<std::mutex> lock(mutex);
+    cv.wait(lock, [&status_read] { return status_read; });
   }
-  return &patch->size_field[0];
-}
-
-WriterID TraceWriterImpl::writer_id() const {
-  return id_;
+  return result;
 }
 
-// Base class definitions.
-TraceWriter::TraceWriter() = default;
-TraceWriter::~TraceWriter() = default;
+StartupTracingSession::~StartupTracingSession() = default;
 
 }  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/core/virtual_destructors.cc
-// gen_amalgamated begin header: include/perfetto/ext/tracing/core/consumer.h
-// gen_amalgamated begin header: include/perfetto/ext/tracing/core/observable_events.h
+// gen_amalgamated begin source: src/tracing/tracing_policy.cc
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2021 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -42468,20 +48271,16 @@ TraceWriter::~TraceWriter() = default;
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_OBSERVABLE_EVENTS_H_
-#define INCLUDE_PERFETTO_EXT_TRACING_CORE_OBSERVABLE_EVENTS_H_
+// gen_amalgamated expanded: #include "perfetto/tracing/tracing_policy.h"
 
-// Creates the aliases in the ::perfetto namespace, doing things like:
-// using ::perfetto::Foo = ::perfetto::protos::gen::Foo.
-// See comments in forward_decls.h for the historical reasons of this
-// indirection layer.
-// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
+namespace perfetto {
 
-// gen_amalgamated expanded: #include "protos/perfetto/common/observable_events.gen.h"
+TracingPolicy::~TracingPolicy() = default;
 
-#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_OBSERVABLE_EVENTS_H_
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/track.cc
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -42496,82 +48295,262 @@ TraceWriter::~TraceWriter() = default;
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_CONSUMER_H_
-#define INCLUDE_PERFETTO_EXT_TRACING_CORE_CONSUMER_H_
+// gen_amalgamated expanded: #include "perfetto/tracing/track.h"
 
-#include <vector>
+// gen_amalgamated expanded: #include "perfetto/ext/base/file_utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/fnv_hash.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_splitter.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/thread_utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/uuid.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/track_event_data_source.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/track_event_internal.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/counter_descriptor.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/process_descriptor.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/process_descriptor.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/thread_descriptor.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/thread_descriptor.pbzero.h"
 
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/observable_events.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
 namespace perfetto {
 
-class TracePacket;
+// static
+uint64_t Track::process_uuid;
 
-class PERFETTO_EXPORT_COMPONENT Consumer {
- public:
-  virtual ~Consumer();
+protos::gen::TrackDescriptor Track::Serialize() const {
+  protos::gen::TrackDescriptor desc;
+  desc.set_uuid(uuid);
+  if (parent_uuid)
+    desc.set_parent_uuid(parent_uuid);
+  return desc;
+}
 
-  // Called by Service (or more typically by the transport layer, on behalf of
-  // the remote Service), once the Consumer <> Service connection has been
-  // established.
-  virtual void OnConnect() = 0;
+void Track::Serialize(protos::pbzero::TrackDescriptor* desc) const {
+  auto bytes = Serialize().SerializeAsString();
+  desc->AppendRawProtoBytes(bytes.data(), bytes.size());
+}
 
-  // Called by the Service or by the transport layer if the connection with the
-  // service drops, either voluntarily (e.g., by destroying the ConsumerEndpoint
-  // obtained through Service::ConnectConsumer()) or involuntarily (e.g., if the
-  // Service process crashes).
-  virtual void OnDisconnect() = 0;
+// static
+Track Track::ThreadScoped(const void* ptr, Track parent) {
+  if (parent.uuid == 0)
+    return Track::FromPointer(ptr, ThreadTrack::Current());
+  return Track::FromPointer(ptr, parent);
+}
 
-  // Called by the Service after the tracing session has ended. This can happen
-  // for a variety of reasons:
-  // - The consumer explicitly called DisableTracing()
-  // - The TraceConfig's |duration_ms| has been reached.
-  // - The TraceConfig's |max_file_size_bytes| has been reached.
-  // - An error occurred while trying to enable tracing. In this case |error|
-  //   is non-empty.
-  virtual void OnTracingDisabled(const std::string& error) = 0;
+protos::gen::TrackDescriptor ProcessTrack::Serialize() const {
+  auto desc = Track::Serialize();
+  auto pd = desc.mutable_process();
+  pd->set_pid(static_cast<int32_t>(pid));
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+  std::string cmdline;
+  if (base::ReadFile("/proc/self/cmdline", &cmdline)) {
+    // Since cmdline is a zero-terminated list of arguments, this ends up
+    // writing just the first element, i.e., the process name, into the process
+    // name field.
+    pd->set_process_name(cmdline.c_str());
+    base::StringSplitter splitter(std::move(cmdline), '\0');
+    while (splitter.Next()) {
+      pd->add_cmdline(
+          std::string(splitter.cur_token(), splitter.cur_token_size()));
+    }
+  }
+  // TODO(skyostil): Record command line on Windows, FreeBSD and Mac.
+#endif
+  return desc;
+}
 
-  // Called back by the Service (or transport layer) after invoking
-  // TracingService::ConsumerEndpoint::ReadBuffers(). This function can be
-  // called more than once. Each invocation can carry one or more
-  // TracePacket(s). Upon the last call, |has_more| is set to true (i.e.
-  // |has_more| is a !EOF).
-  virtual void OnTraceData(std::vector<TracePacket>, bool has_more) = 0;
+void ProcessTrack::Serialize(protos::pbzero::TrackDescriptor* desc) const {
+  auto bytes = Serialize().SerializeAsString();
+  desc->AppendRawProtoBytes(bytes.data(), bytes.size());
+}
 
-  // Called back by the Service (or transport layer) after invoking
-  // TracingService::ConsumerEndpoint::Detach().
-  // The consumer can disconnect at this point and the trace session will keep
-  // on going. A new consumer can later re-attach passing back the same |key|
-  // passed to Detach(), but only if the two requests come from the same uid.
-  virtual void OnDetach(bool success) = 0;
+protos::gen::TrackDescriptor ThreadTrack::Serialize() const {
+  auto desc = Track::Serialize();
+  auto td = desc.mutable_thread();
+  td->set_pid(static_cast<int32_t>(pid));
+  td->set_tid(static_cast<int32_t>(tid));
+  if (disallow_merging_with_system_tracks) {
+    desc.set_disallow_merging_with_system_tracks(true);
+  }
+  std::string thread_name;
+  if (base::GetThreadName(thread_name))
+    td->set_thread_name(thread_name);
+  return desc;
+}
 
-  // Called back by the Service (or transport layer) after invoking
-  // TracingService::ConsumerEndpoint::Attach().
-  virtual void OnAttach(bool success, const TraceConfig&) = 0;
+// static
+ThreadTrack ThreadTrack::Current() {
+  return ThreadTrack(
+      internal::TracingMuxer::Get()->GetCurrentThreadId(),
+      internal::TrackEventInternal::GetDisallowMergingWithSystemTracks());
+}
 
-  // Called back by the Service (or transport layer) after invoking
-  // TracingService::ConsumerEndpoint::GetTraceStats().
-  virtual void OnTraceStats(bool success, const TraceStats&) = 0;
+// static
+ThreadTrack ThreadTrack::ForThread(base::PlatformThreadId tid_) {
+  return ThreadTrack(
+      tid_, internal::TrackEventInternal::GetDisallowMergingWithSystemTracks());
+}
 
-  // Called back by the Service (or transport layer) after invoking
-  // TracingService::ConsumerEndpoint::ObserveEvents() whenever one or more
-  // ObservableEvents of enabled event types occur.
-  virtual void OnObservableEvents(const ObservableEvents&) = 0;
+void ThreadTrack::Serialize(protos::pbzero::TrackDescriptor* desc) const {
+  auto bytes = Serialize().SerializeAsString();
+  desc->AppendRawProtoBytes(bytes.data(), bytes.size());
+}
 
-  // Called back by the Service (or transport layer) after invoking
-  // TracingService::ConsumerEndpoint::CloneSession().
-  // TODO(primiano): make pure virtual after various 3way patches.
-  virtual void OnSessionCloned(bool success, const std::string& error);
-};
+protos::gen::TrackDescriptor NamedTrack::Serialize() const {
+  auto desc = Track::Serialize();
+  if (static_name_) {
+    desc.set_static_name(static_name_.value);
+  } else {
+    desc.set_name(dynamic_name_.value);
+  }
+  if (sibling_merge_behavior_ != perfetto::protos::gen::TrackDescriptor::
+                                     SIBLING_MERGE_BEHAVIOR_UNSPECIFIED) {
+    desc.set_sibling_merge_behavior(sibling_merge_behavior_);
+  }
+  if (sibling_merge_key_) {
+    desc.set_sibling_merge_key(sibling_merge_key_);
+  } else if (sibling_merge_key_int_.has_value()) {
+    desc.set_sibling_merge_key_int(*sibling_merge_key_int_);
+  }
+  return desc;
+}
 
-}  // namespace perfetto
+void NamedTrack::Serialize(protos::pbzero::TrackDescriptor* desc) const {
+  auto bytes = Serialize().SerializeAsString();
+  desc->AppendRawProtoBytes(bytes.data(), bytes.size());
+}
 
-#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_CONSUMER_H_
-// gen_amalgamated begin header: include/perfetto/ext/tracing/core/producer.h
+protos::gen::TrackDescriptor CounterTrack::Serialize() const {
+  auto desc = Track::Serialize();
+  auto* counter = desc.mutable_counter();
+  if (static_name_) {
+    desc.set_static_name(static_name_.value);
+  } else {
+    desc.set_name(dynamic_name_.value);
+  }
+
+  if (category_)
+    counter->add_categories(category_);
+  if (unit_ != perfetto::protos::pbzero::CounterDescriptor::UNIT_UNSPECIFIED)
+    counter->set_unit(static_cast<protos::gen::CounterDescriptor_Unit>(unit_));
+  {
+    // if |type| is set, we don't want to emit |unit_name|. Trace processor
+    // infers the track name from the type in that case.
+    if (type_ !=
+        perfetto::protos::gen::CounterDescriptor::COUNTER_UNSPECIFIED) {
+      counter->set_type(type_);
+    } else if (unit_name_) {
+      counter->set_unit_name(unit_name_);
+    }
+  }
+  if (unit_multiplier_ != 1)
+    counter->set_unit_multiplier(unit_multiplier_);
+  if (is_incremental_)
+    counter->set_is_incremental(is_incremental_);
+  return desc;
+}
+
+void CounterTrack::Serialize(protos::pbzero::TrackDescriptor* desc) const {
+  auto bytes = Serialize().SerializeAsString();
+  desc->AppendRawProtoBytes(bytes.data(), bytes.size());
+}
+
+namespace internal {
+namespace {
+
+uint64_t GetProcessStartTime() {
+#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  std::string stat;
+  if (!base::ReadFile("/proc/self/stat", &stat))
+    return 0u;
+  // The stat file is a single line split into space-separated fields as "pid
+  // (comm) state ppid ...". However because the command name can contain any
+  // characters (including parentheses and spaces), we need to skip past it
+  // before parsing the rest of the fields. To do that, we look for the last
+  // instance of ") " (parentheses followed by space) and parse forward from
+  // that point.
+  size_t comm_end = stat.rfind(") ");
+  if (comm_end == std::string::npos)
+    return 0u;
+  stat = stat.substr(comm_end + strlen(") "));
+  base::StringSplitter splitter(stat, ' ');
+  for (size_t skip = 0; skip < 20; skip++) {
+    if (!splitter.Next())
+      return 0u;
+  }
+  return base::CStringToUInt64(splitter.cur_token()).value_or(0u);
+#else
+  return 0;
+#endif  // !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+}
+
+}  // namespace
+
+// static
+TrackRegistry* TrackRegistry::instance_;
+
+TrackRegistry::TrackRegistry() = default;
+TrackRegistry::~TrackRegistry() = default;
+
+// static
+void TrackRegistry::InitializeInstance(std::optional<uint64_t> process_uuid) {
+  if (instance_)
+    return;
+  instance_ = new TrackRegistry();
+  if (process_uuid) {
+    Track::process_uuid = *process_uuid;
+  } else {
+    Track::process_uuid = ComputeProcessUuid();
+  }
+}
+
+// static
+uint64_t TrackRegistry::ComputeProcessUuid() {
+  // Use the process start time + pid as the unique identifier for this process.
+  // This ensures that if there are two independent copies of the Perfetto SDK
+  // in the same process (e.g., one in the app and another in a system
+  // framework), events emitted by each will be consistently interleaved on
+  // common thread and process tracks.
+  uint64_t random;
+  if (uint64_t start_time = GetProcessStartTime()) {
+    random = start_time;
+  } else {
+    // Fall back to a randomly generated identifier.
+    static uint64_t random_once = static_cast<uint64_t>(base::Uuidv4().lsb());
+    random = random_once;
+  }
+  return base::FnvHasher::Combine(random, Platform::GetCurrentProcessId());
+}
+
+void TrackRegistry::ResetForTesting() {
+  instance_->tracks_.clear();
+}
+
+void TrackRegistry::UpdateTrack(Track track,
+                                const std::string& serialized_desc) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  tracks_[track.uuid] = {serialized_desc, track.parent_uuid};
+}
+
+void TrackRegistry::EraseTrack(Track track) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  tracks_.erase(track.uuid);
+}
+
+// static
+void TrackRegistry::WriteTrackDescriptor(
+    const SerializedTrackDescriptor& desc,
+    protozero::MessageHandle<protos::pbzero::TracePacket> packet) {
+  packet->AppendString(
+      perfetto::protos::pbzero::TracePacket::kTrackDescriptorFieldNumber, desc);
+}
+
+}  // namespace internal
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/track_event_category_registry.cc
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -42586,123 +48565,145 @@ class PERFETTO_EXPORT_COMPONENT Consumer {
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_PRODUCER_H_
-#define INCLUDE_PERFETTO_EXT_TRACING_CORE_PRODUCER_H_
+// gen_amalgamated expanded: #include "perfetto/tracing/track_event_category_registry.h"
 
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
 namespace perfetto {
+namespace {
 
-class SharedMemory;
+static constexpr const char kLegacySlowPrefix[] = "disabled-by-default-";
+static constexpr const char kSlowTag[] = "slow";
 
-// A Producer is an entity that connects to the write-only port of the Service
-// and exposes the ability to produce performance data on-demand. The lifecycle
-// of a Producer is as follows:
-// 1. The producer connects to the service and advertises its data sources
-//    (e.g., the ability to get kernel ftraces, to list process stats).
-// 2. The service acknowledges the connection and sends over the SharedMemory
-//    region that will be used to exchange data (together with the signalling
-//    API TracingService::ProducerEndpoint::OnPageAcquired()/OnPageReleased()).
-// 3. At some point later on, the Service asks the Producer to turn on some of
-//    the previously registered data sources, together with some configuration
-//    parameters. This happens via the StartDataSource() callback.
-// 4. In response to that the Producer will spawn an instance of the given data
-//    source and inject its data into the shared memory buffer (obtained during
-//    OnConnect).
-// This interface is subclassed by:
-//  1. The actual producer code in the clients e.g., the ftrace reader process.
-//  2. The transport layer when interposing RPC between service and producers.
-class PERFETTO_EXPORT_COMPONENT Producer {
- public:
-  virtual ~Producer();
+}  // namespace
 
-  // Called by Service (or more typically by the transport layer, on behalf of
-  // the remote Service), once the Producer <> Service connection has been
-  // established.
-  virtual void OnConnect() = 0;
+// static
+Category Category::FromDynamicCategory(const char* name) {
+  if (GetNthNameSize(1, name, name)) {
+    Category group(Group(name));
+    PERFETTO_DCHECK(group.name);
+    return group;
+  }
+  Category category(name);
+  PERFETTO_DCHECK(category.name);
+  // Disabled-by-default categories get a "slow" tag.
+  if (!strncmp(name, kLegacySlowPrefix, strlen(kLegacySlowPrefix))) {
+    return category.SetTags(kSlowTag);
+  }
+  return category;
+}
 
-  // Called by the Service or by the transport layer if the connection with the
-  // service drops, either voluntarily (e.g., by destroying the ProducerEndpoint
-  // obtained through Service::ConnectProducer()) or involuntarily (e.g., if the
-  // Service process crashes).
-  // The Producer is expected to tear down all its data sources if this happens.
-  // Once this call returns it is possible to safely destroy the Producer
-  // instance.
-  virtual void OnDisconnect() = 0;
+Category Category::FromDynamicCategory(
+    const DynamicCategory& dynamic_category) {
+  return FromDynamicCategory(dynamic_category.name.c_str());
+}
 
-  // Called by the Service after OnConnect but before the first DataSource is
-  // created. Can be used for any setup required before tracing begins.
-  virtual void OnTracingSetup() = 0;
+namespace internal {
 
-  // Called by muxer once StartupTracing is started. It will be called before
-  // SetupStartupTracingBlocking is returned.
-  virtual void OnStartupTracingSetup() {}
+perfetto::DynamicCategory NullCategory(const perfetto::DynamicCategory&) {
+  return perfetto::DynamicCategory{};
+}
 
-  // The lifecycle methods below are always called in the following sequence:
-  // SetupDataSource  -> StartDataSource -> StopDataSource.
-  // Or, in the edge case where a trace is aborted immediately:
-  // SetupDataSource  -> StopDataSource.
-  // The Setup+Start call sequence is always guaranateed, regardless of the
-  // TraceConfig.deferred_start flags.
-  // Called by the Service to configure one of the data sources previously
-  // registered through TracingService::ProducerEndpoint::RegisterDataSource().
-  // This method is always called before StartDataSource. There is always a
-  // SetupDataSource() call before each StartDataSource() call.
-  // Args:
-  // - DataSourceInstanceID is an identifier chosen by the Service that should
-  //   be assigned to the newly created data source instance. It is used to
-  //   match the StopDataSource() request below.
-  // - DataSourceConfig is the configuration for the new data source (e.g.,
-  //   tells which trace categories to enable).
-  virtual void SetupDataSource(DataSourceInstanceID,
-                               const DataSourceConfig&) = 0;
+void TrackEventCategoryRegistry::EnableCategoryForInstance(
+    size_t category_index,
+    uint32_t instance_index) const {
+  PERFETTO_DCHECK(instance_index < kMaxDataSourceInstances);
+  PERFETTO_DCHECK(category_index < category_count_);
+  // Matches the acquire_load in DataSource::Trace().
+  state_storage_[category_index].fetch_or(
+      static_cast<uint8_t>(1u << instance_index), std::memory_order_release);
+}
 
-  // Called by the Service to turn on one of the data sources previously
-  // registered through TracingService::ProducerEndpoint::RegisterDataSource()
-  // and initialized through SetupDataSource().
-  // Both arguments are guaranteed to be identical to the ones passed to the
-  // prior SetupDataSource() call.
-  virtual void StartDataSource(DataSourceInstanceID,
-                               const DataSourceConfig&) = 0;
+void TrackEventCategoryRegistry::DisableCategoryForInstance(
+    size_t category_index,
+    uint32_t instance_index) const {
+  PERFETTO_DCHECK(instance_index < kMaxDataSourceInstances);
+  PERFETTO_DCHECK(category_index < category_count_);
+  // Matches the acquire_load in DataSource::Trace().
+  state_storage_[category_index].fetch_and(
+      static_cast<uint8_t>(~(1u << instance_index)), std::memory_order_release);
+}
 
-  // Called by the Service to shut down an existing data source instance.
-  virtual void StopDataSource(DataSourceInstanceID) = 0;
+}  // namespace internal
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/track_event_legacy.cc
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-  // Called by the service to request the Producer to commit the data of the
-  // given data sources and return their chunks into the shared memory buffer.
-  // The Producer is expected to invoke NotifyFlushComplete(FlushRequestID) on
-  // the Service after the data has been committed. The producer has to either
-  // reply to the flush requests in order, or can just reply to the latest one
-  // Upon seeing a NotifyFlushComplete(N), the service will assume that all
-  // flushes < N have also been committed.
-  virtual void Flush(FlushRequestID,
-                     const DataSourceInstanceID* data_source_ids,
-                     size_t num_data_sources) = 0;
+// gen_amalgamated expanded: #include "perfetto/tracing/track_event_legacy.h"
+
+// gen_amalgamated expanded: #include "perfetto/ext/base/fnv_hash.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/track.h"
+
+namespace perfetto {
+namespace legacy {
+
+template <>
+ThreadTrack ConvertThreadId(const PerfettoLegacyCurrentThreadId&) {
+  // Because of the short-circuit in PERFETTO_INTERNAL_LEGACY_EVENT, we should
+  // never get here.
+  PERFETTO_DCHECK(false);
+  return ThreadTrack::Current();
+}
+
+}  // namespace legacy
+
+namespace internal {
+
+void LegacyTraceId::Write(protos::pbzero::TrackEvent::LegacyEvent* event,
+                          uint32_t event_flags) const {
+  // Legacy flow events always use bind_id.
+  if (event_flags &
+      (legacy::kTraceEventFlagFlowOut | legacy::kTraceEventFlagFlowIn)) {
+    // Flow bind_ids don't have scopes, so we need to mangle in-process ones to
+    // avoid collisions.
+    if (id_flags_ & legacy::kTraceEventFlagHasLocalId) {
+      event->set_bind_id(raw_id_ ^ ProcessTrack::Current().uuid);
+    } else {
+      event->set_bind_id(raw_id_);
+    }
+    return;
+  }
+
+  uint32_t scope_flags = id_flags_ & (legacy::kTraceEventFlagHasId |
+                                      legacy::kTraceEventFlagHasLocalId |
+                                      legacy::kTraceEventFlagHasGlobalId);
+  uint64_t id = raw_id_;
+  if (scope_ && scope_flags != legacy::kTraceEventFlagHasGlobalId) {
+    id = base::FnvHasher::Combine(id, scope_);
+  }
 
-  // Called by the service to instruct the given data sources to stop referring
-  // to any trace contents emitted so far. The intent is that after processing
-  // this call, the rest of the trace should be parsable even if all of the
-  // packets emitted so far have been lost (for example due to ring buffer
-  // overwrites).
-  //
-  // Called only for Producers with active data sources that have opted in by
-  // setting |handles_incremental_state_clear| in their DataSourceDescriptor.
-  //
-  // The way this call is handled is up to the individual Producer
-  // implementation. Some might wish to emit invalidation markers in the trace
-  // (see TracePacket.incremental_state_cleared for an existing field), and
-  // handle them when parsing the trace.
-  virtual void ClearIncrementalState(
-      const DataSourceInstanceID* data_source_ids,
-      size_t num_data_sources) = 0;
-};
+  switch (scope_flags) {
+    case legacy::kTraceEventFlagHasId:
+      event->set_unscoped_id(id);
+      break;
+    case legacy::kTraceEventFlagHasLocalId:
+      event->set_local_id(id);
+      break;
+    case legacy::kTraceEventFlagHasGlobalId:
+      event->set_global_id(id);
+      break;
+  }
+  if (scope_)
+    event->set_id_scope(scope_);
+}
 
+}  // namespace internal
 }  // namespace perfetto
-
-#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_PRODUCER_H_
+// gen_amalgamated begin source: src/tracing/track_event_state_tracker.cc
 /*
- * Copyright (C) 2018 The Android Open Source Project
+ * Copyright (C) 2020 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -42717,1013 +48718,479 @@ class PERFETTO_EXPORT_COMPONENT Producer {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/consumer.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/producer.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_arbiter.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h"
-
-// This translation unit contains the definitions for the destructor of pure
-// virtual interfaces for the current build target. The alternative would be
-// introducing a one-liner .cc file for each pure virtual interface, which is
-// overkill. This is for compliance with -Wweak-vtables.
-
-namespace perfetto {
-
-Consumer::~Consumer() = default;
-Producer::~Producer() = default;
-TracingService::~TracingService() = default;
-ConsumerEndpoint::~ConsumerEndpoint() = default;
-ProducerEndpoint::~ProducerEndpoint() = default;
-SharedMemory::~SharedMemory() = default;
-SharedMemory::Factory::~Factory() = default;
-SharedMemoryArbiter::~SharedMemoryArbiter() = default;
-
-// TODO(primiano): make pure virtual after various 3way patches.
-void ConsumerEndpoint::CloneSession(TracingSessionID) {}
-void Consumer::OnSessionCloned(bool, const std::string&) {}
-
-#if !PERFETTO_IS_AT_LEAST_CPP17()
-constexpr size_t TracingService::kDefaultShmSize;
-constexpr size_t TracingService::kDefaultShmPageSize;
-#endif
-
-}  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/console_interceptor.cc
-// gen_amalgamated begin header: gen/protos/perfetto/config/interceptors/console_config.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTORS_CONSOLE_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTORS_CONSOLE_CONFIG_PROTO_H_
+// gen_amalgamated expanded: #include "perfetto/tracing/track_event_state_tracker.h"
 
-#include <stddef.h>
-#include <stdint.h>
+// gen_amalgamated expanded: #include "perfetto/ext/base/fnv_hash.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/track_event_internal.h"
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/interceptor_descriptor.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/clock_snapshot.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/interned_data/interned_data.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet_defaults.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/debug_annotation.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/process_descriptor.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/thread_descriptor.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_descriptor.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_event.pbzero.h"
 
 namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-namespace perfetto_pbzero_enum_ConsoleConfig {
-enum Output : int32_t;
-}  // namespace perfetto_pbzero_enum_ConsoleConfig
-using ConsoleConfig_Output = perfetto_pbzero_enum_ConsoleConfig::Output;
 
-namespace perfetto_pbzero_enum_ConsoleConfig {
-enum Output : int32_t {
-  OUTPUT_UNSPECIFIED = 0,
-  OUTPUT_STDOUT = 1,
-  OUTPUT_STDERR = 2,
-};
-} // namespace perfetto_pbzero_enum_ConsoleConfig
-using ConsoleConfig_Output = perfetto_pbzero_enum_ConsoleConfig::Output;
+using internal::TrackEventIncrementalState;
 
+TrackEventStateTracker::~TrackEventStateTracker() = default;
+TrackEventStateTracker::Delegate::~Delegate() = default;
 
-constexpr ConsoleConfig_Output ConsoleConfig_Output_MIN = ConsoleConfig_Output::OUTPUT_UNSPECIFIED;
-constexpr ConsoleConfig_Output ConsoleConfig_Output_MAX = ConsoleConfig_Output::OUTPUT_STDERR;
+// static
+void TrackEventStateTracker::ProcessTracePacket(
+    Delegate& delegate,
+    SequenceState& sequence_state,
+    const protos::pbzero::TracePacket_Decoder& packet) {
+  UpdateIncrementalState(delegate, sequence_state, packet);
 
+  if (!packet.has_track_event())
+    return;
+  perfetto::protos::pbzero::TrackEvent::Decoder track_event(
+      packet.track_event());
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ConsoleConfig_Output_Name(::perfetto::protos::pbzero::ConsoleConfig_Output value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ConsoleConfig_Output::OUTPUT_UNSPECIFIED:
-    return "OUTPUT_UNSPECIFIED";
+  auto clock_id = packet.timestamp_clock_id();
+  if (!packet.has_timestamp_clock_id())
+    clock_id = sequence_state.default_clock_id;
+  uint64_t timestamp = packet.timestamp();
+  // TODO(mohitms): Incorporate unit multiplier as well.
+  if (clock_id == internal::TrackEventIncrementalState::kClockIdIncremental) {
+    timestamp += sequence_state.most_recent_absolute_time_ns;
+    sequence_state.most_recent_absolute_time_ns = timestamp;
+  }
 
-  case ::perfetto::protos::pbzero::ConsoleConfig_Output::OUTPUT_STDOUT:
-    return "OUTPUT_STDOUT";
+  Track* track = &sequence_state.track;
+  if (track_event.has_track_uuid()) {
+    auto* session_state = delegate.GetSessionState();
+    if (!session_state)
+      return;  // Tracing must have ended.
+    track = &session_state->tracks[track_event.track_uuid()];
+  }
 
-  case ::perfetto::protos::pbzero::ConsoleConfig_Output::OUTPUT_STDERR:
-    return "OUTPUT_STDERR";
+  // We only log the first category of each event.
+  protozero::ConstChars category{};
+  uint64_t category_iid = 0;
+  if (auto iid_it = track_event.category_iids()) {
+    category_iid = *iid_it;
+    category.data = sequence_state.event_categories[category_iid].data();
+    category.size = sequence_state.event_categories[category_iid].size();
+  } else if (auto cat_it = track_event.categories()) {
+    category.data = reinterpret_cast<const char*>(cat_it->data());
+    category.size = cat_it->size();
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
 
-class ConsoleConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  ConsoleConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ConsoleConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ConsoleConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_output() const { return at<1>().valid(); }
-  int32_t output() const { return at<1>().as_int32(); }
-  bool has_enable_colors() const { return at<2>().valid(); }
-  bool enable_colors() const { return at<2>().as_bool(); }
-};
+  protozero::ConstChars name{};
+  uint64_t name_iid = track_event.name_iid();
+  uint64_t name_hash = 0;
+  uint64_t duration = 0;
+  if (name_iid) {
+    name.data = sequence_state.event_names[name_iid].data();
+    name.size = sequence_state.event_names[name_iid].size();
+  } else if (track_event.has_name()) {
+    name.data = track_event.name().data;
+    name.size = track_event.name().size;
+  }
 
-class ConsoleConfig : public ::protozero::Message {
- public:
-  using Decoder = ConsoleConfig_Decoder;
-  enum : int32_t {
-    kOutputFieldNumber = 1,
-    kEnableColorsFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ConsoleConfig"; }
-
-
-  using Output = ::perfetto::protos::pbzero::ConsoleConfig_Output;
-  static inline const char* Output_Name(Output value) {
-    return ::perfetto::protos::pbzero::ConsoleConfig_Output_Name(value);
-  }
-  static const Output OUTPUT_UNSPECIFIED = Output::OUTPUT_UNSPECIFIED;
-  static const Output OUTPUT_STDOUT = Output::OUTPUT_STDOUT;
-  static const Output OUTPUT_STDERR = Output::OUTPUT_STDERR;
-
-  using FieldMetadata_Output =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ConsoleConfig_Output,
-      ConsoleConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Output kOutput() { return {}; }
-  void set_output(::perfetto::protos::pbzero::ConsoleConfig_Output value) {
-    static constexpr uint32_t field_id = FieldMetadata_Output::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_EnableColors =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ConsoleConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EnableColors kEnableColors() { return {}; }
-  void set_enable_colors(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_EnableColors::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
+  if (name.data) {
+    base::FnvHasher hash;
+    hash.Update(name.data, name.size);
+    name_hash = hash.digest();
   }
-};
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/trace_packet_defaults.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+  size_t depth = track->stack.size();
+  switch (track_event.type()) {
+    case protos::pbzero::TrackEvent::TYPE_SLICE_BEGIN: {
+      StackFrame frame;
+      frame.timestamp = timestamp;
+      frame.name_hash = name_hash;
+      if (track_event.has_track_uuid()) {
+        frame.name = name.ToStdString();
+        frame.category = category.ToStdString();
+      } else {
+        frame.name_iid = name_iid;
+        frame.category_iid = category_iid;
+      }
+      track->stack.push_back(std::move(frame));
+      break;
+    }
+    case protos::pbzero::TrackEvent::TYPE_SLICE_END:
+      if (!track->stack.empty()) {
+        const auto& prev_frame = track->stack.back();
+        if (prev_frame.name_iid) {
+          name.data = sequence_state.event_names[prev_frame.name_iid].data();
+          name.size = sequence_state.event_names[prev_frame.name_iid].size();
+        } else {
+          name.data = prev_frame.name.data();
+          name.size = prev_frame.name.size();
+        }
+        name_hash = prev_frame.name_hash;
+        if (prev_frame.category_iid) {
+          category.data =
+              sequence_state.event_categories[prev_frame.category_iid].data();
+          category.size =
+              sequence_state.event_categories[prev_frame.category_iid].size();
+        } else {
+          category.data = prev_frame.category.data();
+          category.size = prev_frame.category.size();
+        }
+        duration = timestamp - prev_frame.timestamp;
+        depth--;
+      }
+      break;
+    case protos::pbzero::TrackEvent::TYPE_INSTANT:
+      break;
+    case protos::pbzero::TrackEvent::TYPE_COUNTER:
+    case protos::pbzero::TrackEvent::TYPE_UNSPECIFIED:
+      // TODO(skyostil): Support counters.
+      return;
+  }
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACE_PACKET_DEFAULTS_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACE_PACKET_DEFAULTS_PROTO_H_
+  ParsedTrackEvent parsed_event{track_event};
+  parsed_event.timestamp_ns = timestamp;
+  parsed_event.duration_ns = duration;
+  parsed_event.stack_depth = depth;
+  parsed_event.category = category;
+  parsed_event.name = name;
+  parsed_event.name_hash = name_hash;
+  delegate.OnTrackEvent(*track, parsed_event);
 
-#include <stddef.h>
-#include <stdint.h>
+  if (track_event.type() == protos::pbzero::TrackEvent::TYPE_SLICE_END &&
+      !track->stack.empty()) {
+    track->stack.pop_back();
+  }
+}
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// static
+void TrackEventStateTracker::UpdateIncrementalState(
+    Delegate& delegate,
+    SequenceState& sequence_state,
+    const protos::pbzero::TracePacket_Decoder& packet) {
+#if PERFETTO_DCHECK_IS_ON()
+  if (!sequence_state.sequence_id) {
+    sequence_state.sequence_id = packet.trusted_packet_sequence_id();
+  } else {
+    PERFETTO_DCHECK(sequence_state.sequence_id ==
+                    packet.trusted_packet_sequence_id());
+  }
+#endif
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  perfetto::protos::pbzero::ClockSnapshot::Decoder snapshot(
+      packet.clock_snapshot());
+  for (auto it = snapshot.clocks(); it; ++it) {
+    perfetto::protos::pbzero::ClockSnapshot::Clock::Decoder clock(*it);
+    // TODO(mohitms) : Handle the incremental clock other than default one.
+    if (clock.is_incremental() &&
+        clock.clock_id() ==
+            internal::TrackEventIncrementalState::kClockIdIncremental) {
+      sequence_state.most_recent_absolute_time_ns =
+          clock.timestamp() * clock.unit_multiplier_ns();
+      break;
+    }
+  }
 
-class PerfSampleDefaults;
-class TrackEventDefaults;
+  if (packet.sequence_flags() &
+      perfetto::protos::pbzero::TracePacket::SEQ_INCREMENTAL_STATE_CLEARED) {
+    // Convert any existing event names and categories on the stack to
+    // non-interned strings so we can look up their names even after the
+    // incremental state is gone.
+    for (auto& frame : sequence_state.track.stack) {
+      if (frame.name_iid) {
+        frame.name = sequence_state.event_names[frame.name_iid];
+        frame.name_iid = 0u;
+      }
+      if (frame.category_iid) {
+        frame.category = sequence_state.event_categories[frame.category_iid];
+        frame.category_iid = 0u;
+      }
+    }
+    sequence_state.event_names.clear();
+    sequence_state.event_categories.clear();
+    sequence_state.debug_annotation_names.clear();
+    sequence_state.track.uuid = 0u;
+    sequence_state.track.index = 0u;
+  }
+  if (packet.has_interned_data()) {
+    perfetto::protos::pbzero::InternedData::Decoder interned_data(
+        packet.interned_data());
+    for (auto it = interned_data.event_names(); it; it++) {
+      perfetto::protos::pbzero::EventName::Decoder entry(*it);
+      sequence_state.event_names[entry.iid()] = entry.name().ToStdString();
+    }
+    for (auto it = interned_data.event_categories(); it; it++) {
+      perfetto::protos::pbzero::EventCategory::Decoder entry(*it);
+      sequence_state.event_categories[entry.iid()] = entry.name().ToStdString();
+    }
+    for (auto it = interned_data.debug_annotation_names(); it; it++) {
+      perfetto::protos::pbzero::DebugAnnotationName::Decoder entry(*it);
+      sequence_state.debug_annotation_names[entry.iid()] =
+          entry.name().ToStdString();
+    }
+  }
+  if (packet.has_trace_packet_defaults()) {
+    perfetto::protos::pbzero::TracePacketDefaults::Decoder defaults(
+        packet.trace_packet_defaults());
+    if (defaults.has_track_event_defaults()) {
+      perfetto::protos::pbzero::TrackEventDefaults::Decoder
+          track_event_defaults(defaults.track_event_defaults());
+      sequence_state.track.uuid = track_event_defaults.track_uuid();
+      if (defaults.has_timestamp_clock_id())
+        sequence_state.default_clock_id = defaults.timestamp_clock_id();
+    }
+  }
+  if (packet.has_track_descriptor()) {
+    perfetto::protos::pbzero::TrackDescriptor::Decoder track_descriptor(
+        packet.track_descriptor());
+    auto* session_state = delegate.GetSessionState();
+    auto& track = session_state->tracks[track_descriptor.uuid()];
+    if (!track.index)
+      track.index = static_cast<uint32_t>(session_state->tracks.size() + 1);
+    track.uuid = track_descriptor.uuid();
 
-class TracePacketDefaults_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/58, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TracePacketDefaults_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TracePacketDefaults_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TracePacketDefaults_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_timestamp_clock_id() const { return at<58>().valid(); }
-  uint32_t timestamp_clock_id() const { return at<58>().as_uint32(); }
-  bool has_track_event_defaults() const { return at<11>().valid(); }
-  ::protozero::ConstBytes track_event_defaults() const { return at<11>().as_bytes(); }
-  bool has_perf_sample_defaults() const { return at<12>().valid(); }
-  ::protozero::ConstBytes perf_sample_defaults() const { return at<12>().as_bytes(); }
-};
+    if (track_descriptor.has_name()) {
+      track.name = track_descriptor.name().ToStdString();
+    } else if (track_descriptor.has_static_name()) {
+      track.name = track_descriptor.static_name().ToStdString();
+    }
+    track.pid = 0;
+    track.tid = 0;
+    if (track_descriptor.has_process()) {
+      perfetto::protos::pbzero::ProcessDescriptor::Decoder process(
+          track_descriptor.process());
+      track.pid = process.pid();
+      if (track.name.empty())
+        track.name = process.process_name().ToStdString();
+    } else if (track_descriptor.has_thread()) {
+      perfetto::protos::pbzero::ThreadDescriptor::Decoder thread(
+          track_descriptor.thread());
+      track.pid = thread.pid();
+      track.tid = thread.tid();
+      if (track.name.empty())
+        track.name = thread.thread_name().ToStdString();
+    }
+    delegate.OnTrackUpdated(track);
 
-class TracePacketDefaults : public ::protozero::Message {
- public:
-  using Decoder = TracePacketDefaults_Decoder;
-  enum : int32_t {
-    kTimestampClockIdFieldNumber = 58,
-    kTrackEventDefaultsFieldNumber = 11,
-    kPerfSampleDefaultsFieldNumber = 12,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TracePacketDefaults"; }
-
-
-  using FieldMetadata_TimestampClockId =
-    ::protozero::proto_utils::FieldMetadata<
-      58,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TracePacketDefaults>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimestampClockId kTimestampClockId() { return {}; }
-  void set_timestamp_clock_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimestampClockId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_TrackEventDefaults =
-    ::protozero::proto_utils::FieldMetadata<
-      11,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TrackEventDefaults,
-      TracePacketDefaults>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrackEventDefaults kTrackEventDefaults() { return {}; }
-  template <typename T = TrackEventDefaults> T* set_track_event_defaults() {
-    return BeginNestedMessage<T>(11);
-  }
-
-
-  using FieldMetadata_PerfSampleDefaults =
-    ::protozero::proto_utils::FieldMetadata<
-      12,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      PerfSampleDefaults,
-      TracePacketDefaults>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PerfSampleDefaults kPerfSampleDefaults() { return {}; }
-  template <typename T = PerfSampleDefaults> T* set_perf_sample_defaults() {
-    return BeginNestedMessage<T>(12);
+    // Mirror properties to the default track of the sequence. Note that
+    // this does not catch updates to the default track written through other
+    // sequences.
+    if (track.uuid == sequence_state.track.uuid) {
+      sequence_state.track.index = track.index;
+      sequence_state.track.name = track.name;
+      sequence_state.track.pid = track.pid;
+      sequence_state.track.tid = track.tid;
+      sequence_state.track.user_data = track.user_data;
+    }
   }
+}
 
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/process_descriptor.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+TrackEventStateTracker::ParsedTrackEvent::ParsedTrackEvent(
+    const perfetto::protos::pbzero::TrackEvent::Decoder& track_event_)
+    : track_event(track_event_) {}
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_PROCESS_DESCRIPTOR_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_PROCESS_DESCRIPTOR_PROTO_H_
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/virtual_destructors.cc
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-#include <stddef.h>
-#include <stdint.h>
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_tls.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/tracing.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/tracing_backend.h"
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// This translation unit contains the definitions for the destructor of pure
+// virtual interfaces for the src/public:public target. The alternative would be
+// introducing a one-liner .cc file for each pure virtual interface, which is
+// overkill. This is for compliance with -Wweak-vtables.
 
 namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-namespace perfetto_pbzero_enum_ProcessDescriptor {
-enum ChromeProcessType : int32_t;
-}  // namespace perfetto_pbzero_enum_ProcessDescriptor
-using ProcessDescriptor_ChromeProcessType = perfetto_pbzero_enum_ProcessDescriptor::ChromeProcessType;
-
-namespace perfetto_pbzero_enum_ProcessDescriptor {
-enum ChromeProcessType : int32_t {
-  PROCESS_UNSPECIFIED = 0,
-  PROCESS_BROWSER = 1,
-  PROCESS_RENDERER = 2,
-  PROCESS_UTILITY = 3,
-  PROCESS_ZYGOTE = 4,
-  PROCESS_SANDBOX_HELPER = 5,
-  PROCESS_GPU = 6,
-  PROCESS_PPAPI_PLUGIN = 7,
-  PROCESS_PPAPI_BROKER = 8,
-};
-} // namespace perfetto_pbzero_enum_ProcessDescriptor
-using ProcessDescriptor_ChromeProcessType = perfetto_pbzero_enum_ProcessDescriptor::ChromeProcessType;
-
-
-constexpr ProcessDescriptor_ChromeProcessType ProcessDescriptor_ChromeProcessType_MIN = ProcessDescriptor_ChromeProcessType::PROCESS_UNSPECIFIED;
-constexpr ProcessDescriptor_ChromeProcessType ProcessDescriptor_ChromeProcessType_MAX = ProcessDescriptor_ChromeProcessType::PROCESS_PPAPI_BROKER;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ProcessDescriptor_ChromeProcessType_Name(::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_UNSPECIFIED:
-    return "PROCESS_UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_BROWSER:
-    return "PROCESS_BROWSER";
-
-  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_RENDERER:
-    return "PROCESS_RENDERER";
-
-  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_UTILITY:
-    return "PROCESS_UTILITY";
-
-  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_ZYGOTE:
-    return "PROCESS_ZYGOTE";
-
-  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_SANDBOX_HELPER:
-    return "PROCESS_SANDBOX_HELPER";
-
-  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_GPU:
-    return "PROCESS_GPU";
-
-  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_PPAPI_PLUGIN:
-    return "PROCESS_PPAPI_PLUGIN";
+namespace internal {
 
-  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_PPAPI_BROKER:
-    return "PROCESS_PPAPI_BROKER";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
+TracingTLS::~TracingTLS() {
+  // Avoid entering trace points while the thread is being torn down.
+  // This is the problem: when a thread exits, the at-thread-exit destroys the
+  // TracingTLS. As part of that the various TraceWriter for the active data
+  // sources are destroyd. A TraceWriter dtor will issue a PostTask on the IPC
+  // thread to issue a final flush and unregister its ID with the service.
+  // The PostTask, in chromium, might have a trace event that will try to
+  // re-enter the tracing system.
+  // We fix this by resetting the TLS key to the TracingTLS object that is
+  // being destroyed in the platform impl (platform_posix.cc,
+  // platform_windows.cc, chromium's platform.cc). We carefully rely on the fact
+  // that all the tracing path that will be invoked during thread exit will
+  // early out if |is_in_trace_point| == true and will not depend on the other
+  // TLS state that has been destroyed.
+  is_in_trace_point = true;
 }
 
-class ProcessDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  ProcessDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ProcessDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ProcessDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pid() const { return at<1>().valid(); }
-  int32_t pid() const { return at<1>().as_int32(); }
-  bool has_cmdline() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> cmdline() const { return GetRepeated<::protozero::ConstChars>(2); }
-  bool has_process_name() const { return at<6>().valid(); }
-  ::protozero::ConstChars process_name() const { return at<6>().as_string(); }
-  bool has_process_priority() const { return at<5>().valid(); }
-  int32_t process_priority() const { return at<5>().as_int32(); }
-  bool has_start_timestamp_ns() const { return at<7>().valid(); }
-  int64_t start_timestamp_ns() const { return at<7>().as_int64(); }
-  bool has_chrome_process_type() const { return at<4>().valid(); }
-  int32_t chrome_process_type() const { return at<4>().as_int32(); }
-  bool has_legacy_sort_index() const { return at<3>().valid(); }
-  int32_t legacy_sort_index() const { return at<3>().as_int32(); }
-  bool has_process_labels() const { return at<8>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> process_labels() const { return GetRepeated<::protozero::ConstChars>(8); }
-};
-
-class ProcessDescriptor : public ::protozero::Message {
- public:
-  using Decoder = ProcessDescriptor_Decoder;
-  enum : int32_t {
-    kPidFieldNumber = 1,
-    kCmdlineFieldNumber = 2,
-    kProcessNameFieldNumber = 6,
-    kProcessPriorityFieldNumber = 5,
-    kStartTimestampNsFieldNumber = 7,
-    kChromeProcessTypeFieldNumber = 4,
-    kLegacySortIndexFieldNumber = 3,
-    kProcessLabelsFieldNumber = 8,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ProcessDescriptor"; }
-
-
-  using ChromeProcessType = ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType;
-  static inline const char* ChromeProcessType_Name(ChromeProcessType value) {
-    return ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType_Name(value);
-  }
-  static const ChromeProcessType PROCESS_UNSPECIFIED = ChromeProcessType::PROCESS_UNSPECIFIED;
-  static const ChromeProcessType PROCESS_BROWSER = ChromeProcessType::PROCESS_BROWSER;
-  static const ChromeProcessType PROCESS_RENDERER = ChromeProcessType::PROCESS_RENDERER;
-  static const ChromeProcessType PROCESS_UTILITY = ChromeProcessType::PROCESS_UTILITY;
-  static const ChromeProcessType PROCESS_ZYGOTE = ChromeProcessType::PROCESS_ZYGOTE;
-  static const ChromeProcessType PROCESS_SANDBOX_HELPER = ChromeProcessType::PROCESS_SANDBOX_HELPER;
-  static const ChromeProcessType PROCESS_GPU = ChromeProcessType::PROCESS_GPU;
-  static const ChromeProcessType PROCESS_PPAPI_PLUGIN = ChromeProcessType::PROCESS_PPAPI_PLUGIN;
-  static const ChromeProcessType PROCESS_PPAPI_BROKER = ChromeProcessType::PROCESS_PPAPI_BROKER;
-
-  using FieldMetadata_Pid =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ProcessDescriptor>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Cmdline =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ProcessDescriptor>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cmdline kCmdline() { return {}; }
-  void add_cmdline(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Cmdline::kFieldId, data, size);
-  }
-  void add_cmdline(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Cmdline::kFieldId, chars.data, chars.size);
-  }
-  void add_cmdline(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Cmdline::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ProcessName =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ProcessDescriptor>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessName kProcessName() { return {}; }
-  void set_process_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ProcessName::kFieldId, data, size);
-  }
-  void set_process_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ProcessName::kFieldId, chars.data, chars.size);
-  }
-  void set_process_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProcessName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ProcessPriority =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ProcessDescriptor>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessPriority kProcessPriority() { return {}; }
-  void set_process_priority(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProcessPriority::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_StartTimestampNs =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ProcessDescriptor>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StartTimestampNs kStartTimestampNs() { return {}; }
-  void set_start_timestamp_ns(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StartTimestampNs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ChromeProcessType =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType,
-      ProcessDescriptor>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeProcessType kChromeProcessType() { return {}; }
-  void set_chrome_process_type(::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType value) {
-    static constexpr uint32_t field_id = FieldMetadata_ChromeProcessType::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_LegacySortIndex =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ProcessDescriptor>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LegacySortIndex kLegacySortIndex() { return {}; }
-  void set_legacy_sort_index(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LegacySortIndex::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ProcessLabels =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ProcessDescriptor>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessLabels kProcessLabels() { return {}; }
-  void add_process_labels(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ProcessLabels::kFieldId, data, size);
-  }
-  void add_process_labels(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ProcessLabels::kFieldId, chars.data, chars.size);
-  }
-  void add_process_labels(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProcessLabels::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/thread_descriptor.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+}  // namespace internal
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_THREAD_DESCRIPTOR_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_THREAD_DESCRIPTOR_PROTO_H_
+TracingProducerBackend::~TracingProducerBackend() = default;
+TracingConsumerBackend::~TracingConsumerBackend() = default;
+TracingBackend::~TracingBackend() = default;
 
-#include <stddef.h>
-#include <stdint.h>
+}  // namespace perfetto
+// gen_amalgamated begin source: src/android_stats/statsd_logging_helper.cc
+// gen_amalgamated begin header: src/android_stats/statsd_logging_helper.h
+// gen_amalgamated begin header: src/android_stats/perfetto_atoms.h
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+#ifndef SRC_ANDROID_STATS_PERFETTO_ATOMS_H_
+#define SRC_ANDROID_STATS_PERFETTO_ATOMS_H_
 
 namespace perfetto {
-namespace protos {
-namespace pbzero {
 
-namespace perfetto_pbzero_enum_ThreadDescriptor {
-enum ChromeThreadType : int32_t;
-}  // namespace perfetto_pbzero_enum_ThreadDescriptor
-using ThreadDescriptor_ChromeThreadType = perfetto_pbzero_enum_ThreadDescriptor::ChromeThreadType;
-
-namespace perfetto_pbzero_enum_ThreadDescriptor {
-enum ChromeThreadType : int32_t {
-  CHROME_THREAD_UNSPECIFIED = 0,
-  CHROME_THREAD_MAIN = 1,
-  CHROME_THREAD_IO = 2,
-  CHROME_THREAD_POOL_BG_WORKER = 3,
-  CHROME_THREAD_POOL_FG_WORKER = 4,
-  CHROME_THREAD_POOL_FB_BLOCKING = 5,
-  CHROME_THREAD_POOL_BG_BLOCKING = 6,
-  CHROME_THREAD_POOL_SERVICE = 7,
-  CHROME_THREAD_COMPOSITOR = 8,
-  CHROME_THREAD_VIZ_COMPOSITOR = 9,
-  CHROME_THREAD_COMPOSITOR_WORKER = 10,
-  CHROME_THREAD_SERVICE_WORKER = 11,
-  CHROME_THREAD_MEMORY_INFRA = 50,
-  CHROME_THREAD_SAMPLING_PROFILER = 51,
-};
-} // namespace perfetto_pbzero_enum_ThreadDescriptor
-using ThreadDescriptor_ChromeThreadType = perfetto_pbzero_enum_ThreadDescriptor::ChromeThreadType;
+// This must match the values of the PerfettoUploadEvent enum in:
+// frameworks/proto_logging/stats/atoms.proto
+enum class PerfettoStatsdAtom {
+  kUndefined = 0,
 
+  // Checkpoints inside perfetto_cmd before tracing is finished.
+  kTraceBegin = 1,
+  kBackgroundTraceBegin = 2,
+  kCmdCloneTraceBegin = 55,
+  kCmdCloneTriggerTraceBegin = 56,
+  kOnConnect = 3,
+  kCmdOnSessionClone = 58,
+  kCmdOnTriggerSessionClone = 59,
 
-constexpr ThreadDescriptor_ChromeThreadType ThreadDescriptor_ChromeThreadType_MIN = ThreadDescriptor_ChromeThreadType::CHROME_THREAD_UNSPECIFIED;
-constexpr ThreadDescriptor_ChromeThreadType ThreadDescriptor_ChromeThreadType_MAX = ThreadDescriptor_ChromeThreadType::CHROME_THREAD_SAMPLING_PROFILER;
+  // Guardrails inside perfetto_cmd before tracing is finished.
+  kOnTimeout = 16,
 
+  // Checkpoints inside traced.
+  kTracedEnableTracing = 37,
+  kTracedStartTracing = 38,
+  kTracedDisableTracing = 39,
+  kTracedNotifyTracingDisabled = 40,
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ThreadDescriptor_ChromeThreadType_Name(::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_UNSPECIFIED:
-    return "CHROME_THREAD_UNSPECIFIED";
+  // Trigger checkpoints inside traced.
+  // These atoms are special because, along with the UUID,
+  // they log the trigger name.
+  kTracedTriggerStartTracing = 41,
+  kTracedTriggerStopTracing = 42,
+  kTracedTriggerCloneSnapshot = 53,
 
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_MAIN:
-    return "CHROME_THREAD_MAIN";
+  // Guardrails inside traced.
+  kTracedEnableTracingExistingTraceSession = 18,
+  kTracedEnableTracingTooLongTrace = 19,
+  kTracedEnableTracingInvalidTriggerTimeout = 20,
+  kTracedEnableTracingDurationWithTrigger = 21,
+  kTracedEnableTracingStopTracingWriteIntoFile = 22,
+  kTracedEnableTracingDuplicateTriggerName = 23,
+  kTracedEnableTracingInvalidDeferredStart = 24,
+  kTracedEnableTracingInvalidBufferSize = 25,
+  kTracedEnableTracingBufferSizeTooLarge = 26,
+  kTracedEnableTracingTooManyBuffers = 27,
+  kTracedEnableTracingDuplicateSessionName = 28,
+  kTracedEnableTracingSessionNameTooRecent = 29,
+  kTracedEnableTracingTooManySessionsForUid = 30,
+  kTracedEnableTracingTooManyConcurrentSessions = 31,
+  kTracedEnableTracingInvalidFdOutputFile = 32,
+  kTracedEnableTracingFailedToCreateFile = 33,
+  kTracedEnableTracingOom = 34,
+  kTracedEnableTracingUnknown = 35,
+  kTracedStartTracingInvalidSessionState = 36,
+  kTracedEnableTracingInvalidFilter = 47,
+  kTracedEnableTracingOobTargetBuffer = 48,
+  kTracedEnableTracingInvalidTriggerMode = 52,
+  kTracedEnableTracingInvalidBrFilename = 54,
+  kTracedEnableTracingFailedSessionSemaphoreCheck = 57,
+  kTracedEnablePriorityBoostInvalidConfig = 61,
+  kTracedEnablePriorityBoostOtherError = 62,
+  kTracedEnableTracingExclusiveSessionRejected = 63,
+  kTracedEnableTracingExclusiveSessionNotAllowed = 64,
+  kTracedEnableTracingDuplicateBufferName = 65,
 
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_IO:
-    return "CHROME_THREAD_IO";
+  // Checkpoints inside perfetto_cmd after tracing has finished.
+  kOnTracingDisabled = 4,
+  kFinalizeTraceAndExit = 11,
+  kCmdFwReportBegin = 49,
+  // Will be removed once incidentd is no longer used.
+  kUploadIncidentBegin = 8,
+  kNotUploadingEmptyTrace = 17,
 
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_POOL_BG_WORKER:
-    return "CHROME_THREAD_POOL_BG_WORKER";
+  // Guardrails inside perfetto_cmd after tracing has finished.
+  kCmdFwReportEmptyTrace = 50,
+  // Will be removed once incidentd is no longer used.
+  kUploadIncidentFailure = 10,
 
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_POOL_FG_WORKER:
-    return "CHROME_THREAD_POOL_FG_WORKER";
+  // "Successful" terminal states inside perfetto_cmd.
+  kCmdFwReportHandoff = 51,
 
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_POOL_FB_BLOCKING:
-    return "CHROME_THREAD_POOL_FB_BLOCKING";
+  // Deprecated as "success" is misleading; it simply means we were
+  // able to communicate with incidentd. Will be removed once
+  // incidentd is no longer used.
+  kUploadIncidentSuccess = 9,
 
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_POOL_BG_BLOCKING:
-    return "CHROME_THREAD_POOL_BG_BLOCKING";
+  // Contained trigger begin/success/failure. Replaced by
+  // |PerfettoTriggerAtom| to allow aggregation using a count metric
+  // and reduce spam.
+  // reserved 12, 13, 14;
 
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_POOL_SERVICE:
-    return "CHROME_THREAD_POOL_SERVICE";
+  // Contained that a guardrail in perfetto_cmd was hit. Replaced with
+  // kCmd* guardrails.
+  // reserved 15;
 
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_COMPOSITOR:
-    return "CHROME_THREAD_COMPOSITOR";
+  // Contained status of Dropbox uploads. Removed as Perfetto no
+  // longer supports uploading traces using Dropbox.
+  // reserved 5, 6, 7;
 
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_VIZ_COMPOSITOR:
-    return "CHROME_THREAD_VIZ_COMPOSITOR";
+  // Contained status of guardrail state initialization and upload limit in
+  // perfetto_cmd. Removed as perfetto no longer manages stateful guardrails
+  // reserved 44, 45, 46;
 
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_COMPOSITOR_WORKER:
-    return "CHROME_THREAD_COMPOSITOR_WORKER";
+  // Contained the guardrail for user build tracing. Removed as this guardrail
+  // causes more problem than it solves these days.
+  // reserved 43;
+};
 
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_SERVICE_WORKER:
-    return "CHROME_THREAD_SERVICE_WORKER";
+// This must match the values of the PerfettoTrigger::TriggerType enum in:
+// frameworks/proto_logging/stats/atoms.proto
+enum PerfettoTriggerAtom {
+  kUndefined = 0,
 
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_MEMORY_INFRA:
-    return "CHROME_THREAD_MEMORY_INFRA";
+  kTracedLimitProbability = 5,
+  kTracedLimitMaxPer24h = 6,
 
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_SAMPLING_PROFILER:
-    return "CHROME_THREAD_SAMPLING_PROFILER";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+  kTracedTrigger = 9,
 
-class ThreadDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  ThreadDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ThreadDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ThreadDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pid() const { return at<1>().valid(); }
-  int32_t pid() const { return at<1>().as_int32(); }
-  bool has_tid() const { return at<2>().valid(); }
-  int32_t tid() const { return at<2>().as_int32(); }
-  bool has_thread_name() const { return at<5>().valid(); }
-  ::protozero::ConstChars thread_name() const { return at<5>().as_string(); }
-  bool has_chrome_thread_type() const { return at<4>().valid(); }
-  int32_t chrome_thread_type() const { return at<4>().as_int32(); }
-  bool has_reference_timestamp_us() const { return at<6>().valid(); }
-  int64_t reference_timestamp_us() const { return at<6>().as_int64(); }
-  bool has_reference_thread_time_us() const { return at<7>().valid(); }
-  int64_t reference_thread_time_us() const { return at<7>().as_int64(); }
-  bool has_reference_thread_instruction_count() const { return at<8>().valid(); }
-  int64_t reference_thread_instruction_count() const { return at<8>().as_int64(); }
-  bool has_legacy_sort_index() const { return at<3>().valid(); }
-  int32_t legacy_sort_index() const { return at<3>().as_int32(); }
+  // Contained events of logging triggers through perfetto_cmd, probes and
+  // trigger_perfetto.
+  // Removed in W (Oct 2024) and replaced by |kTracedTrigger|.
+  // reserved 1, 2, 3, 4, 7, 8
 };
 
-class ThreadDescriptor : public ::protozero::Message {
- public:
-  using Decoder = ThreadDescriptor_Decoder;
-  enum : int32_t {
-    kPidFieldNumber = 1,
-    kTidFieldNumber = 2,
-    kThreadNameFieldNumber = 5,
-    kChromeThreadTypeFieldNumber = 4,
-    kReferenceTimestampUsFieldNumber = 6,
-    kReferenceThreadTimeUsFieldNumber = 7,
-    kReferenceThreadInstructionCountFieldNumber = 8,
-    kLegacySortIndexFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ThreadDescriptor"; }
-
-
-  using ChromeThreadType = ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType;
-  static inline const char* ChromeThreadType_Name(ChromeThreadType value) {
-    return ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType_Name(value);
-  }
-  static const ChromeThreadType CHROME_THREAD_UNSPECIFIED = ChromeThreadType::CHROME_THREAD_UNSPECIFIED;
-  static const ChromeThreadType CHROME_THREAD_MAIN = ChromeThreadType::CHROME_THREAD_MAIN;
-  static const ChromeThreadType CHROME_THREAD_IO = ChromeThreadType::CHROME_THREAD_IO;
-  static const ChromeThreadType CHROME_THREAD_POOL_BG_WORKER = ChromeThreadType::CHROME_THREAD_POOL_BG_WORKER;
-  static const ChromeThreadType CHROME_THREAD_POOL_FG_WORKER = ChromeThreadType::CHROME_THREAD_POOL_FG_WORKER;
-  static const ChromeThreadType CHROME_THREAD_POOL_FB_BLOCKING = ChromeThreadType::CHROME_THREAD_POOL_FB_BLOCKING;
-  static const ChromeThreadType CHROME_THREAD_POOL_BG_BLOCKING = ChromeThreadType::CHROME_THREAD_POOL_BG_BLOCKING;
-  static const ChromeThreadType CHROME_THREAD_POOL_SERVICE = ChromeThreadType::CHROME_THREAD_POOL_SERVICE;
-  static const ChromeThreadType CHROME_THREAD_COMPOSITOR = ChromeThreadType::CHROME_THREAD_COMPOSITOR;
-  static const ChromeThreadType CHROME_THREAD_VIZ_COMPOSITOR = ChromeThreadType::CHROME_THREAD_VIZ_COMPOSITOR;
-  static const ChromeThreadType CHROME_THREAD_COMPOSITOR_WORKER = ChromeThreadType::CHROME_THREAD_COMPOSITOR_WORKER;
-  static const ChromeThreadType CHROME_THREAD_SERVICE_WORKER = ChromeThreadType::CHROME_THREAD_SERVICE_WORKER;
-  static const ChromeThreadType CHROME_THREAD_MEMORY_INFRA = ChromeThreadType::CHROME_THREAD_MEMORY_INFRA;
-  static const ChromeThreadType CHROME_THREAD_SAMPLING_PROFILER = ChromeThreadType::CHROME_THREAD_SAMPLING_PROFILER;
-
-  using FieldMetadata_Pid =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ThreadDescriptor>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Tid =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ThreadDescriptor>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Tid kTid() { return {}; }
-  void set_tid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ThreadName =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ThreadDescriptor>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThreadName kThreadName() { return {}; }
-  void set_thread_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ThreadName::kFieldId, data, size);
-  }
-  void set_thread_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ThreadName::kFieldId, chars.data, chars.size);
-  }
-  void set_thread_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ThreadName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ChromeThreadType =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType,
-      ThreadDescriptor>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeThreadType kChromeThreadType() { return {}; }
-  void set_chrome_thread_type(::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType value) {
-    static constexpr uint32_t field_id = FieldMetadata_ChromeThreadType::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ReferenceTimestampUs =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ThreadDescriptor>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReferenceTimestampUs kReferenceTimestampUs() { return {}; }
-  void set_reference_timestamp_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReferenceTimestampUs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ReferenceThreadTimeUs =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ThreadDescriptor>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReferenceThreadTimeUs kReferenceThreadTimeUs() { return {}; }
-  void set_reference_thread_time_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReferenceThreadTimeUs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ReferenceThreadInstructionCount =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ThreadDescriptor>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReferenceThreadInstructionCount kReferenceThreadInstructionCount() { return {}; }
-  void set_reference_thread_instruction_count(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReferenceThreadInstructionCount::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_LegacySortIndex =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ThreadDescriptor>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LegacySortIndex kLegacySortIndex() { return {}; }
-  void set_legacy_sort_index(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LegacySortIndex::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-};
+}  // namespace perfetto
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
+#endif  // SRC_ANDROID_STATS_PERFETTO_ATOMS_H_
 /*
  * Copyright (C) 2020 The Android Open Source Project
  *
@@ -43740,462 +49207,191 @@ class ThreadDescriptor : public ::protozero::Message {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/tracing/console_interceptor.h"
-
-#include <stdarg.h>
-
-#include <algorithm>
-#include <cmath>
-#include <tuple>
+#ifndef SRC_ANDROID_STATS_STATSD_LOGGING_HELPER_H_
+#define SRC_ANDROID_STATS_STATSD_LOGGING_HELPER_H_
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/file_utils.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/hash.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/optional.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/track_event_internal.h"
+#include <stdint.h>
+#include <optional>
+#include <string>
+#include <vector>
 
-// gen_amalgamated expanded: #include "protos/perfetto/common/interceptor_descriptor.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/data_source_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/interceptor_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/interceptors/console_config.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/interned_data/interned_data.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet_defaults.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/process_descriptor.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/thread_descriptor.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_descriptor.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_event.pbzero.h"
+// gen_amalgamated expanded: #include "src/android_stats/perfetto_atoms.h"
 
 namespace perfetto {
+namespace android_stats {
 
-// sRGB color.
-struct ConsoleColor {
-  uint8_t r;
-  uint8_t g;
-  uint8_t b;
-};
-
-namespace {
-
-int g_output_fd_for_testing;
-
-// Google Turbo colormap.
-constexpr std::array<ConsoleColor, 16> kTurboColors = {{
-    ConsoleColor{0x30, 0x12, 0x3b},
-    ConsoleColor{0x40, 0x40, 0xa1},
-    ConsoleColor{0x46, 0x6b, 0xe3},
-    ConsoleColor{0x41, 0x93, 0xfe},
-    ConsoleColor{0x28, 0xbb, 0xeb},
-    ConsoleColor{0x17, 0xdc, 0xc2},
-    ConsoleColor{0x32, 0xf1, 0x97},
-    ConsoleColor{0x6d, 0xfd, 0x62},
-    ConsoleColor{0xa4, 0xfc, 0x3b},
-    ConsoleColor{0xcd, 0xeb, 0x34},
-    ConsoleColor{0xed, 0xcf, 0x39},
-    ConsoleColor{0xfd, 0xab, 0x33},
-    ConsoleColor{0xfa, 0x7d, 0x20},
-    ConsoleColor{0xea, 0x50, 0x0d},
-    ConsoleColor{0xd0, 0x2f, 0x04},
-    ConsoleColor{0xa9, 0x15, 0x01},
-}};
-
-constexpr size_t kHueBits = 4;
-constexpr uint32_t kMaxHue = kTurboColors.size() << kHueBits;
-constexpr uint8_t kLightness = 128u;
-constexpr ConsoleColor kWhiteColor{0xff, 0xff, 0xff};
-
-const char kDim[] = "\x1b[90m";
-const char kDefault[] = "\x1b[39m";
-const char kReset[] = "\x1b[0m";
-
-#define FMT_RGB_SET "\x1b[38;2;%d;%d;%dm"
-#define FMT_RGB_SET_BG "\x1b[48;2;%d;%d;%dm"
-
-ConsoleColor Mix(ConsoleColor a, ConsoleColor b, uint8_t ratio) {
-  return {
-      static_cast<uint8_t>(a.r + (((b.r - a.r) * ratio) >> 8)),
-      static_cast<uint8_t>(a.g + (((b.g - a.g) * ratio) >> 8)),
-      static_cast<uint8_t>(a.b + (((b.b - a.b) * ratio) >> 8)),
-  };
-}
-
-ConsoleColor HueToRGB(uint32_t hue) {
-  PERFETTO_DCHECK(hue < kMaxHue);
-  uint32_t c1 = hue >> kHueBits;
-  uint32_t c2 =
-      std::min(static_cast<uint32_t>(kTurboColors.size() - 1), c1 + 1u);
-  uint32_t ratio = hue & ((1 << kHueBits) - 1);
-  return Mix(kTurboColors[c1], kTurboColors[c2],
-             static_cast<uint8_t>(ratio | (ratio << kHueBits)));
-}
-
-uint32_t CounterToHue(uint32_t counter) {
-  // We split the hue space into 8 segments, reversing the order of bits so
-  // successive counter values will be far from each other.
-  uint32_t reversed =
-      ((counter & 0x7) >> 2) | ((counter & 0x3)) | ((counter & 0x1) << 2);
-  return reversed * kMaxHue / 8;
-}
-
-}  // namespace
+// Functions in this file are only active on built in the Android
+// tree. On other platforms (including Android standalone and Chromium
+// on Android) these functions are a noop.
 
-class ConsoleInterceptor::Delegate : public TrackEventStateTracker::Delegate {
- public:
-  explicit Delegate(InterceptorContext&);
-  ~Delegate() override;
+// Logs the upload event to statsd if built in the Android tree.
+void MaybeLogUploadEvent(PerfettoStatsdAtom atom,
+                         int64_t uuid_lsb,
+                         int64_t uuid_msb,
+                         const std::string& trigger_name = "");
 
-  TrackEventStateTracker::SessionState* GetSessionState() override;
-  void OnTrackUpdated(TrackEventStateTracker::Track&) override;
-  void OnTrackEvent(const TrackEventStateTracker::Track&,
-                    const TrackEventStateTracker::ParsedTrackEvent&) override;
+// Logs the trigger events to statsd if built in the Android tree.
+void MaybeLogTriggerEvent(PerfettoTriggerAtom atom,
+                          int64_t uuid_lsb,
+                          const std::string& trigger);
 
- private:
-  using SelfHandle = LockedHandle<ConsoleInterceptor>;
+}  // namespace android_stats
+}  // namespace perfetto
 
-  InterceptorContext& context_;
-  base::Optional<SelfHandle> locked_self_;
-};
+#endif  // SRC_ANDROID_STATS_STATSD_LOGGING_HELPER_H_
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-ConsoleInterceptor::~ConsoleInterceptor() = default;
+// gen_amalgamated expanded: #include "src/android_stats/statsd_logging_helper.h"
 
-ConsoleInterceptor::ThreadLocalState::ThreadLocalState(
-    ThreadLocalStateArgs& args) {
-  if (auto self = args.GetInterceptorLocked()) {
-    start_time_ns = self->start_time_ns_;
-    use_colors = self->use_colors_;
-    fd = self->fd_;
-  }
-}
+#include <cstdint>
+#include <string>
+#include <vector>
 
-ConsoleInterceptor::ThreadLocalState::~ThreadLocalState() = default;
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+// gen_amalgamated expanded: #include "src/android_stats/perfetto_atoms.h"
 
-ConsoleInterceptor::Delegate::Delegate(InterceptorContext& context)
-    : context_(context) {}
-ConsoleInterceptor::Delegate::~Delegate() = default;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) && \
+    PERFETTO_BUILDFLAG(PERFETTO_ANDROID_BUILD)
+// gen_amalgamated expanded: #include "src/android_internal/lazy_library_loader.h"  // nogncheck
+// gen_amalgamated expanded: #include "src/android_internal/statsd_logging.h"       // nogncheck
+#endif
 
-TrackEventStateTracker::SessionState*
-ConsoleInterceptor::Delegate::GetSessionState() {
-  // When the session state is retrieved for the first time, it is cached (and
-  // kept locked) until we return from OnTracePacket. This avoids having to lock
-  // and unlock the instance multiple times per invocation.
-  if (locked_self_.has_value())
-    return &locked_self_.value()->session_state_;
-  locked_self_ =
-      base::make_optional<SelfHandle>(context_.GetInterceptorLocked());
-  return &locked_self_.value()->session_state_;
-}
+namespace perfetto::android_stats {
 
-void ConsoleInterceptor::Delegate::OnTrackUpdated(
-    TrackEventStateTracker::Track& track) {
-  auto track_color = HueToRGB(CounterToHue(track.index));
-  std::array<char, 16> title;
-  if (!track.name.empty()) {
-    snprintf(title.data(), title.size(), "%s", track.name.c_str());
-  } else if (track.pid && track.tid) {
-    snprintf(title.data(), title.size(), "%u:%u",
-             static_cast<uint32_t>(track.pid),
-             static_cast<uint32_t>(track.tid));
-  } else if (track.pid) {
-    snprintf(title.data(), title.size(), "%" PRId64, track.pid);
-  } else {
-    snprintf(title.data(), title.size(), "%" PRIu64, track.uuid);
-  }
-  int title_width = static_cast<int>(title.size());
+// Make sure we don't accidentally log on non-Android tree build. Note that even
+// removing this ifdef still doesn't make uploads work on OS_ANDROID.
+// PERFETTO_LAZY_LOAD will return a nullptr on non-Android and non-in-tree
+// builds as libperfetto_android_internal will not be available.
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) && \
+    PERFETTO_BUILDFLAG(PERFETTO_ANDROID_BUILD)
 
-  auto& tls = context_.GetThreadLocalState();
-  std::array<char, 128> message_prefix{};
-  size_t written = 0;
-  if (tls.use_colors) {
-    written = base::SprintfTrunc(message_prefix.data(), message_prefix.size(),
-                                 FMT_RGB_SET_BG " %s%s %-*.*s", track_color.r,
-                                 track_color.g, track_color.b, kReset, kDim,
-                                 title_width, title_width, title.data());
-  } else {
-    written = base::SprintfTrunc(message_prefix.data(), message_prefix.size(),
-                                 "%-*.*s", title_width + 2, title_width,
-                                 title.data());
+void MaybeLogUploadEvent(PerfettoStatsdAtom atom,
+                         int64_t uuid_lsb,
+                         int64_t uuid_msb,
+                         const std::string& trigger_name) {
+  PERFETTO_LAZY_LOAD(android_internal::StatsdLogUploadEvent, log_event_fn);
+  if (log_event_fn) {
+    log_event_fn(atom, uuid_lsb, uuid_msb, trigger_name.c_str());
   }
-  track.user_data.assign(
-      message_prefix.begin(),
-      message_prefix.begin() + static_cast<ssize_t>(written));
 }
 
-void ConsoleInterceptor::Delegate::OnTrackEvent(
-    const TrackEventStateTracker::Track& track,
-    const TrackEventStateTracker::ParsedTrackEvent& event) {
-  // Start printing.
-  auto& tls = context_.GetThreadLocalState();
-  tls.buffer_pos = 0;
-
-  // Print timestamp and track identifier.
-  SetColor(context_, kDim);
-  Printf(context_, "[%7.3lf] %.*s",
-         static_cast<double>(event.timestamp_ns - tls.start_time_ns) / 1e9,
-         static_cast<int>(track.user_data.size()), track.user_data.data());
-
-  // Print category.
-  Printf(context_, "%-5.*s ",
-         std::min(5, static_cast<int>(event.category.size)),
-         event.category.data);
-
-  // Print stack depth.
-  for (size_t i = 0; i < event.stack_depth; i++) {
-    Printf(context_, "-  ");
-  }
-
-  // Print slice name.
-  auto slice_color = HueToRGB(event.name_hash % kMaxHue);
-  auto highlight_color = Mix(slice_color, kWhiteColor, kLightness);
-  if (event.track_event.type() == protos::pbzero::TrackEvent::TYPE_SLICE_END) {
-    SetColor(context_, kDefault);
-    Printf(context_, "} ");
-  }
-  SetColor(context_, highlight_color);
-  Printf(context_, "%.*s", static_cast<int>(event.name.size), event.name.data);
-  SetColor(context_, kReset);
-  if (event.track_event.type() ==
-      protos::pbzero::TrackEvent::TYPE_SLICE_BEGIN) {
-    SetColor(context_, kDefault);
-    Printf(context_, " {");
-  }
-
-  // Print annotations.
-  if (event.track_event.has_debug_annotations()) {
-    PrintDebugAnnotations(context_, event.track_event, slice_color,
-                          highlight_color);
-  }
-
-  // TODO(skyostil): Print typed arguments.
-
-  // Print duration for longer events.
-  constexpr uint64_t kNsPerMillisecond = 1000000u;
-  if (event.duration_ns >= 10 * kNsPerMillisecond) {
-    SetColor(context_, kDim);
-    Printf(context_, " +%" PRIu64 "ms", event.duration_ns / kNsPerMillisecond);
+void MaybeLogTriggerEvent(PerfettoTriggerAtom atom,
+                          int64_t uuid_lsb,
+                          const std::string& trigger_name) {
+  PERFETTO_LAZY_LOAD(android_internal::StatsdLogTriggerEvent, log_event_fn);
+  if (log_event_fn) {
+    log_event_fn(atom, uuid_lsb, trigger_name.c_str());
   }
-  SetColor(context_, kReset);
-  Printf(context_, "\n");
-}
-
-// static
-void ConsoleInterceptor::Register() {
-  perfetto::protos::gen::InterceptorDescriptor desc;
-  desc.set_name("console");
-  Interceptor<ConsoleInterceptor>::Register(desc);
-}
-
-// static
-void ConsoleInterceptor::SetOutputFdForTesting(int fd) {
-  g_output_fd_for_testing = fd;
 }
 
-void ConsoleInterceptor::OnSetup(const SetupArgs& args) {
-  int fd = STDOUT_FILENO;
-  if (g_output_fd_for_testing)
-    fd = g_output_fd_for_testing;
-#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) && \
-    !PERFETTO_BUILDFLAG(PERFETTO_OS_WASM)
-  bool use_colors = isatty(fd);
 #else
-  bool use_colors = false;
+void MaybeLogUploadEvent(PerfettoStatsdAtom,
+                         int64_t,
+                         int64_t,
+                         const std::string&) {}
+void MaybeLogTriggerEvent(PerfettoTriggerAtom, int64_t, const std::string&) {}
 #endif
-  protos::pbzero::ConsoleConfig::Decoder config(
-      args.config.interceptor_config().console_config_raw());
-  if (config.has_enable_colors())
-    use_colors = config.enable_colors();
-  if (config.output() == protos::pbzero::ConsoleConfig::OUTPUT_STDOUT) {
-    fd = STDOUT_FILENO;
-  } else if (config.output() == protos::pbzero::ConsoleConfig::OUTPUT_STDERR) {
-    fd = STDERR_FILENO;
-  }
-  fd_ = fd;
-  use_colors_ = use_colors;
-}
-
-void ConsoleInterceptor::OnStart(const StartArgs&) {
-  start_time_ns_ = internal::TrackEventInternal::GetTimeNs();
-}
-
-void ConsoleInterceptor::OnStop(const StopArgs&) {}
-
-// static
-void ConsoleInterceptor::OnTracePacket(InterceptorContext context) {
-  {
-    auto& tls = context.GetThreadLocalState();
-    Delegate delegate(context);
-    perfetto::protos::pbzero::TracePacket::Decoder packet(
-        context.packet_data.data, context.packet_data.size);
-    TrackEventStateTracker::ProcessTracePacket(delegate, tls.sequence_state,
-                                               packet);
-  }  // (Potential) lock scope for session state.
-  Flush(context);
-}
-
-// static
-void ConsoleInterceptor::Printf(InterceptorContext& context,
-                                const char* format,
-                                ...) {
-  auto& tls = context.GetThreadLocalState();
-  ssize_t remaining = static_cast<ssize_t>(tls.message_buffer.size()) -
-                      static_cast<ssize_t>(tls.buffer_pos);
-  int written = 0;
-  if (remaining > 0) {
-    va_list args;
-    va_start(args, format);
-    written = vsnprintf(&tls.message_buffer[tls.buffer_pos],
-                        static_cast<size_t>(remaining), format, args);
-    PERFETTO_DCHECK(written >= 0);
-    va_end(args);
-  }
-
-  // In case of buffer overflow, flush to the fd and write the latest message to
-  // it directly instead.
-  if (remaining <= 0 || written > remaining) {
-    FILE* output = (tls.fd == STDOUT_FILENO) ? stdout : stderr;
-    if (g_output_fd_for_testing) {
-      output = fdopen(dup(g_output_fd_for_testing), "w");
-    }
-    Flush(context);
-    va_list args;
-    va_start(args, format);
-    vfprintf(output, format, args);
-    va_end(args);
-    if (g_output_fd_for_testing) {
-      fclose(output);
-    }
-  } else if (written > 0) {
-    tls.buffer_pos += static_cast<size_t>(written);
-  }
-}
-
-// static
-void ConsoleInterceptor::Flush(InterceptorContext& context) {
-  auto& tls = context.GetThreadLocalState();
-  ssize_t res = base::WriteAll(tls.fd, &tls.message_buffer[0], tls.buffer_pos);
-  PERFETTO_DCHECK(res == static_cast<ssize_t>(tls.buffer_pos));
-  tls.buffer_pos = 0;
-}
-
-// static
-void ConsoleInterceptor::SetColor(InterceptorContext& context,
-                                  const ConsoleColor& color) {
-  auto& tls = context.GetThreadLocalState();
-  if (!tls.use_colors)
-    return;
-  Printf(context, FMT_RGB_SET, color.r, color.g, color.b);
-}
-
-// static
-void ConsoleInterceptor::SetColor(InterceptorContext& context,
-                                  const char* color) {
-  auto& tls = context.GetThreadLocalState();
-  if (!tls.use_colors)
-    return;
-  Printf(context, "%s", color);
-}
-
-// static
-void ConsoleInterceptor::PrintDebugAnnotations(
-    InterceptorContext& context,
-    const protos::pbzero::TrackEvent_Decoder& track_event,
-    const ConsoleColor& slice_color,
-    const ConsoleColor& highlight_color) {
-  SetColor(context, slice_color);
-  Printf(context, "(");
-
-  bool is_first = true;
-  for (auto it = track_event.debug_annotations(); it; it++) {
-    perfetto::protos::pbzero::DebugAnnotation::Decoder annotation(*it);
-    SetColor(context, slice_color);
-    if (!is_first)
-      Printf(context, ", ");
-
-    PrintDebugAnnotationName(context, annotation);
-    Printf(context, ":");
-
-    SetColor(context, highlight_color);
-    PrintDebugAnnotationValue(context, annotation);
-
-    is_first = false;
-  }
-  SetColor(context, slice_color);
-  Printf(context, ")");
-}
 
-// static
-void ConsoleInterceptor::PrintDebugAnnotationName(
-    InterceptorContext& context,
-    const perfetto::protos::pbzero::DebugAnnotation::Decoder& annotation) {
-  auto& tls = context.GetThreadLocalState();
-  protozero::ConstChars name{};
-  if (annotation.name_iid()) {
-    name.data =
-        tls.sequence_state.debug_annotation_names[annotation.name_iid()].data();
-    name.size =
-        tls.sequence_state.debug_annotation_names[annotation.name_iid()].size();
-  } else if (annotation.has_name()) {
-    name.data = annotation.name().data;
-    name.size = annotation.name().size;
-  }
-  Printf(context, "%.*s", static_cast<int>(name.size), name.data);
-}
+}  // namespace perfetto::android_stats
+// gen_amalgamated begin source: src/base/clock_snapshots.cc
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-// static
-void ConsoleInterceptor::PrintDebugAnnotationValue(
-    InterceptorContext& context,
-    const perfetto::protos::pbzero::DebugAnnotation::Decoder& annotation) {
-  if (annotation.has_bool_value()) {
-    Printf(context, "%s", annotation.bool_value() ? "true" : "false");
-  } else if (annotation.has_uint_value()) {
-    Printf(context, "%" PRIu64, annotation.uint_value());
-  } else if (annotation.has_int_value()) {
-    Printf(context, "%" PRId64, annotation.int_value());
-  } else if (annotation.has_double_value()) {
-    Printf(context, "%f", annotation.double_value());
-  } else if (annotation.has_string_value()) {
-    Printf(context, "%.*s", static_cast<int>(annotation.string_value().size),
-           annotation.string_value().data);
-  } else if (annotation.has_pointer_value()) {
-    Printf(context, "%p", reinterpret_cast<void*>(annotation.pointer_value()));
-  } else if (annotation.has_legacy_json_value()) {
-    Printf(context, "%.*s",
-           static_cast<int>(annotation.legacy_json_value().size),
-           annotation.legacy_json_value().data);
-  } else if (annotation.has_dict_entries()) {
-    Printf(context, "{");
-    bool is_first = true;
-    for (auto it = annotation.dict_entries(); it; ++it) {
-      if (!is_first)
-        Printf(context, ", ");
-      perfetto::protos::pbzero::DebugAnnotation::Decoder key_value(*it);
-      PrintDebugAnnotationName(context, key_value);
-      Printf(context, ":");
-      PrintDebugAnnotationValue(context, key_value);
-      is_first = false;
-    }
-    Printf(context, "}");
-  } else if (annotation.has_array_values()) {
-    Printf(context, "[");
-    bool is_first = true;
-    for (auto it = annotation.array_values(); it; ++it) {
-      if (!is_first)
-        Printf(context, ", ");
-      perfetto::protos::pbzero::DebugAnnotation::Decoder key_value(*it);
-      PrintDebugAnnotationValue(context, key_value);
-      is_first = false;
-    }
-    Printf(context, "]");
-  } else {
-    Printf(context, "{}");
+// gen_amalgamated expanded: #include "perfetto/ext/base/clock_snapshots.h"
+
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+// gen_amalgamated expanded: #include "perfetto/base/time.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/builtin_clock.pbzero.h"
+
+namespace perfetto::base {
+
+ClockSnapshotVector CaptureClockSnapshots() {
+  ClockSnapshotVector snapshot_data;
+#if !PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) &&   \
+    !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) &&     \
+    !PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) && \
+    !PERFETTO_BUILDFLAG(PERFETTO_OS_NACL) &&    \
+    !PERFETTO_BUILDFLAG(PERFETTO_OS_QNX)
+  struct {
+    clockid_t id;
+    protos::pbzero::BuiltinClock type;
+    struct timespec ts;
+  } clocks[] = {
+      {CLOCK_BOOTTIME, protos::pbzero::BUILTIN_CLOCK_BOOTTIME, {0, 0}},
+      {CLOCK_REALTIME_COARSE,
+       protos::pbzero::BUILTIN_CLOCK_REALTIME_COARSE,
+       {0, 0}},
+      {CLOCK_MONOTONIC_COARSE,
+       protos::pbzero::BUILTIN_CLOCK_MONOTONIC_COARSE,
+       {0, 0}},
+      {CLOCK_REALTIME, protos::pbzero::BUILTIN_CLOCK_REALTIME, {0, 0}},
+      {CLOCK_MONOTONIC, protos::pbzero::BUILTIN_CLOCK_MONOTONIC, {0, 0}},
+      {CLOCK_MONOTONIC_RAW,
+       protos::pbzero::BUILTIN_CLOCK_MONOTONIC_RAW,
+       {0, 0}},
+  };
+  // First snapshot all the clocks as atomically as we can.
+  for (auto& clock : clocks) {
+    if (clock_gettime(clock.id, &clock.ts) == -1)
+      PERFETTO_DLOG("clock_gettime failed for clock %d", clock.id);
+  }
+  for (auto& clock : clocks) {
+    snapshot_data.push_back(ClockReading(
+        static_cast<uint32_t>(clock.type),
+        static_cast<uint64_t>(base::FromPosixTimespec(clock.ts).count())));
   }
+#else  // OS_APPLE || OS_WIN && OS_NACL
+  auto wall_time_ns = static_cast<uint64_t>(base::GetWallTimeNs().count());
+  // The default trace clock is boot time, so we always need to emit a path to
+  // it. However since we don't actually have a boot time source on these
+  // platforms, pretend that wall time equals boot time.
+  snapshot_data.push_back(
+      ClockReading(protos::pbzero::BUILTIN_CLOCK_BOOTTIME, wall_time_ns));
+  snapshot_data.push_back(
+      ClockReading(protos::pbzero::BUILTIN_CLOCK_MONOTONIC, wall_time_ns));
+#endif
+
+#if PERFETTO_BUILDFLAG(PERFETTO_ARCH_CPU_X86_64)
+  // X86-specific but OS-independent TSC clocksource
+  snapshot_data.push_back(
+      ClockReading(protos::pbzero::BUILTIN_CLOCK_TSC, base::Rdtsc()));
+#endif  // PERFETTO_BUILDFLAG(PERFETTO_ARCH_CPU_X86_64)
+
+  return snapshot_data;
 }
 
-}  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/data_source.cc
+}  // namespace perfetto::base
+// gen_amalgamated begin source: src/base/version.cc
+// gen_amalgamated begin header: include/perfetto/ext/base/version.h
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2020 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -44210,55 +49406,49 @@ void ConsoleInterceptor::PrintDebugAnnotationValue(
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/tracing/data_source.h"
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+#ifndef INCLUDE_PERFETTO_EXT_BASE_VERSION_H_
+#define INCLUDE_PERFETTO_EXT_BASE_VERSION_H_
 
 namespace perfetto {
+namespace base {
 
-DataSourceBase::StopArgs::~StopArgs() = default;
-DataSourceBase::~DataSourceBase() = default;
-void DataSourceBase::OnSetup(const SetupArgs&) {}
-void DataSourceBase::OnStart(const StartArgs&) {}
-void DataSourceBase::OnStop(const StopArgs&) {}
-void DataSourceBase::WillClearIncrementalState(
-    const ClearIncrementalStateArgs&) {}
-
-namespace internal {
+// The returned pointer is a static string and safe to pass around.
+// Returns a human readable string currently of the approximate form:
+// Perfetto v42.1-deadbeef0 (deadbeef03c641e4b4ea9cf38e9b5696670175a9)
+// However you should not depend on the format of this string.
+// It maybe not be possible to determine the version. In which case the
+// string will be of the approximate form:
+// Perfetto v0.0 (unknown)
+const char* GetVersionString();
 
-void DataSourceType::PopulateTlsInst(
-    DataSourceInstanceThreadLocalState* tls_inst,
-    DataSourceState* instance_state,
-    uint32_t instance_index) {
-  auto* tracing_impl = TracingMuxer::Get();
-  tls_inst->muxer_id_for_testing = instance_state->muxer_id_for_testing;
-  tls_inst->backend_id = instance_state->backend_id;
-  tls_inst->backend_connection_id = instance_state->backend_connection_id;
-  tls_inst->buffer_id = instance_state->buffer_id;
-  tls_inst->startup_target_buffer_reservation =
-      instance_state->startup_target_buffer_reservation.load(
-          std::memory_order_relaxed);
-  tls_inst->data_source_instance_id = instance_state->data_source_instance_id;
-  tls_inst->is_intercepted = instance_state->interceptor_id != 0;
-  tls_inst->trace_writer = tracing_impl->CreateTraceWriter(
-      &state_, instance_index, instance_state, buffer_exhausted_policy_);
-  if (create_incremental_state_fn_) {
-    PERFETTO_DCHECK(!tls_inst->incremental_state);
-    CreateIncrementalState(tls_inst, instance_index);
-  }
-  if (create_custom_tls_fn_) {
-    tls_inst->data_source_custom_tls =
-        create_custom_tls_fn_(tls_inst, instance_index, user_arg_);
-  }
-  // Even in the case of out-of-IDs, SharedMemoryArbiterImpl returns a
-  // NullTraceWriter. The returned pointer should never be null.
-  PERFETTO_DCHECK(tls_inst->trace_writer);
-}
+// The returned pointer is a static string and safe to pass around.
+// Returns the short code used to identity the version:
+// v42.1-deadbeef0
+// It maybe not be possible to determine the version. In which case
+// this returns nullptr.
+// This can be compared with equality to other
+// version codes to detect matched builds (for example to see if
+// trace_processor_shell and the UI were built at the same revision)
+// but you should not attempt to parse it as the format may change
+// without warning.
+const char* GetVersionCode();
 
-}  // namespace internal
+}  // namespace base
 }  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/debug_annotation.cc
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_VERSION_H_
+// gen_amalgamated begin header: gen/perfetto_version.gen.h
+// Generated by write_version_header.py
+
+#ifndef GEN_PERFETTO_VERSION_GEN_H_
+#define GEN_PERFETTO_VERSION_GEN_H_
+
+#define PERFETTO_VERSION_STRING() "v54.0-7616314b3"
+#define PERFETTO_VERSION_SCM_REVISION() "7616314b391aa5fe69aa57705216c40727eb0160"
+
+#endif  // GEN_PERFETTO_VERSION_GEN_H_
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2020 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -44273,24 +49463,48 @@ void DataSourceType::PopulateTlsInst(
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/tracing/debug_annotation.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/version.h"
 
-// gen_amalgamated expanded: #include "perfetto/tracing/traced_value.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/debug_annotation.pbzero.h"
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+
+#include <stdio.h>
+
+#if PERFETTO_BUILDFLAG(PERFETTO_VERSION_GEN)
+// gen_amalgamated expanded: #include "perfetto_version.gen.h"
+#else
+#define PERFETTO_VERSION_STRING() nullptr
+#define PERFETTO_VERSION_SCM_REVISION() "unknown"
+#endif
 
 namespace perfetto {
+namespace base {
 
-DebugAnnotation::~DebugAnnotation() = default;
+const char* GetVersionCode() {
+  return PERFETTO_VERSION_STRING();
+}
 
-void DebugAnnotation::WriteIntoTracedValue(TracedValue context) const {
-  Add(context.annotation_);
+const char* GetVersionString() {
+  static const char* version_str = [] {
+    static constexpr size_t kMaxLen = 256;
+    const char* version_code = PERFETTO_VERSION_STRING();
+    if (version_code == nullptr) {
+      version_code = "v0.0";
+    }
+    char* version = new char[kMaxLen + 1];
+    snprintf(version, kMaxLen, "Perfetto %s (%s)", version_code,
+             PERFETTO_VERSION_SCM_REVISION());
+    return version;
+  }();
+  return version_str;
 }
 
+}  // namespace base
 }  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/event_context.cc
-// gen_amalgamated begin header: include/perfetto/tracing/internal/track_event_interned_fields.h
+// gen_amalgamated begin source: src/protovm/allocator.cc
+// gen_amalgamated begin header: src/protovm/allocator.h
+// gen_amalgamated begin header: src/protovm/error_handling.h
 /*
- * Copyright (C) 2021 The Android Open Source Project
+ * Copyright (C) 2025 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -44305,152 +49519,251 @@ void DebugAnnotation::WriteIntoTracedValue(TracedValue context) const {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/track_event_interned_data_index.h"
+#ifndef SRC_PROTOVM_ERROR_HANDLING_H_
+#define SRC_PROTOVM_ERROR_HANDLING_H_
 
-#ifndef INCLUDE_PERFETTO_TRACING_INTERNAL_TRACK_EVENT_INTERNED_FIELDS_H_
-#define INCLUDE_PERFETTO_TRACING_INTERNAL_TRACK_EVENT_INTERNED_FIELDS_H_
+#include <cstdarg>
+#include <cstdint>
+#include <memory>
+#include <new>
+#include <string>
+#include <type_traits>
+#include <vector>
 
-namespace perfetto {
-namespace internal {
+// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
 
-// These helpers are exposed here to allow Chromium-without-client library
-// to share the interning buffers with Perfetto internals (e.g.
-// perfetto::TracedValue implementation).
+#if defined(__GNUC__) || defined(__clang__)
+#if defined(__clang__)
+#pragma clang diagnostic push
+// Fix 'error: #pragma system_header ignored in main file' for amalgamated
+// build.
+#pragma clang diagnostic ignored "-Wpragma-system-header-outside-header"
+#endif
 
-struct PERFETTO_EXPORT_COMPONENT InternedEventCategory
-    : public TrackEventInternedDataIndex<
-          InternedEventCategory,
-          perfetto::protos::pbzero::InternedData::kEventCategoriesFieldNumber,
-          const char*,
-          SmallInternedDataTraits> {
-  ~InternedEventCategory() override;
+// Ignore GCC warning about a missing argument for a variadic macro parameter.
+#pragma GCC system_header
 
-  static void Add(protos::pbzero::InternedData* interned_data,
-                  size_t iid,
-                  const char* value,
-                  size_t length);
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+#endif
+
+namespace perfetto {
+namespace protovm {
+
+using Stacktrace = std::vector<std::string>;
+
+void LogStacktraceMessage(Stacktrace& stacktrace,
+                          const char* file_name,
+                          int file_line,
+                          const char* fmt,
+                          ...) PERFETTO_PRINTF_FORMAT(4, 5);
+
+// overload for calls without message args
+void LogStacktraceMessage(Stacktrace& stacktrace,
+                          const char* file_name,
+                          int file_line);
+
+#define PROTOVM_ABORT(fmt, ...)                                       \
+  do {                                                                \
+    auto status_abort = StatusOr<void>::Abort();                      \
+    LogStacktraceMessage(status_abort.stacktrace(),                   \
+                         ::perfetto::base::LoggingBasename(__FILE__), \
+                         __LINE__, fmt, ##__VA_ARGS__);               \
+    return status_abort;                                              \
+  } while (0)
+
+#define PROTOVM_RETURN(s, ...)                                          \
+  do {                                                                  \
+    if (s.IsAbort()) {                                                  \
+      LogStacktraceMessage(s.stacktrace(),                              \
+                           ::perfetto::base::LoggingBasename(__FILE__), \
+                           __LINE__, ##__VA_ARGS__);                    \
+    }                                                                   \
+    return s;                                                           \
+  } while (0)
+
+#define PROTOVM_RETURN_IF_NOT_OK(s, ...)                                \
+  do {                                                                  \
+    if (s.IsAbort()) {                                                  \
+      LogStacktraceMessage(s.stacktrace(),                              \
+                           ::perfetto::base::LoggingBasename(__FILE__), \
+                           __LINE__, ##__VA_ARGS__);                    \
+      return s;                                                         \
+    }                                                                   \
+    if (!s.IsOk()) {                                                    \
+      return s;                                                         \
+    }                                                                   \
+  } while (0)
+
+enum class Status : uint8_t {
+  kOk,
+  kError,
+
+  // It causes an abort of the whole VM's program. Typically indicates a
+  // fundamental issue with the program and requires developer's intervention.
+  kAbort,
 };
 
-struct PERFETTO_EXPORT_COMPONENT InternedEventName
-    : public TrackEventInternedDataIndex<
-          InternedEventName,
-          perfetto::protos::pbzero::InternedData::kEventNamesFieldNumber,
-          const char*,
-          SmallInternedDataTraits> {
-  ~InternedEventName() override;
+namespace internal {
 
-  static void Add(protos::pbzero::InternedData* interned_data,
-                  size_t iid,
-                  const char* value);
-};
+template <class T, class Arg, class... Args>
+static constexpr bool is_copy_or_move_ctor_arg_v =
+    sizeof...(Args) == 0 && std::is_same_v<T, std::decay_t<Arg>>;
 
-struct PERFETTO_EXPORT_COMPONENT InternedDebugAnnotationName
-    : public TrackEventInternedDataIndex<
-          InternedDebugAnnotationName,
-          perfetto::protos::pbzero::InternedData::
-              kDebugAnnotationNamesFieldNumber,
-          const char*,
-          SmallInternedDataTraits> {
-  ~InternedDebugAnnotationName() override;
+template <class T>
+inline constexpr std::size_t sizeof_v = sizeof(T);
 
-  static void Add(protos::pbzero::InternedData* interned_data,
-                  size_t iid,
-                  const char* value);
-};
+template <>
+inline constexpr std::size_t sizeof_v<void> = 0;
 
-struct PERFETTO_EXPORT_COMPONENT InternedDebugAnnotationValueTypeName
-    : public TrackEventInternedDataIndex<
-          InternedDebugAnnotationValueTypeName,
-          perfetto::protos::pbzero::InternedData::
-              kDebugAnnotationValueTypeNamesFieldNumber,
-          const char*,
-          SmallInternedDataTraits> {
-  ~InternedDebugAnnotationValueTypeName() override;
+template <class T>
+inline constexpr std::size_t alignof_v = alignof(T);
 
-  static void Add(protos::pbzero::InternedData* interned_data,
-                  size_t iid,
-                  const char* value);
-};
+template <>
+inline constexpr std::size_t alignof_v<void> = 0;
 
 }  // namespace internal
-}  // namespace perfetto
 
-#endif  // INCLUDE_PERFETTO_TRACING_INTERNAL_TRACK_EVENT_INTERNED_FIELDS_H_
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+template <class T>
+class StatusOr {
+ public:
+  // Factory methods to create empty instances (without value)
+  static StatusOr Ok() { return StatusOr{Status::kOk}; }
+  static StatusOr Error() { return StatusOr{Status::kError}; }
+  static StatusOr Abort() { return StatusOr{Status::kAbort}; }
 
-// gen_amalgamated expanded: #include "perfetto/tracing/event_context.h"
+  StatusOr(const StatusOr&) = delete;
 
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/track_event_interned_fields.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/interned_data/interned_data.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_event.pbzero.h"
+  StatusOr(StatusOr&& other) : status_{other.status_} {
+    if (IsOk()) {
+      if constexpr (!std::is_same_v<T, void>) {
+        new (storage_) T(std::move(other.value()));
+      }
+    } else if (IsAbort()) {
+      new (storage_) std::unique_ptr<Stacktrace>(
+          std::move(other.GetStacktraceUniquePtr()));
+    }
+  }
 
-namespace perfetto {
+  // Intentionally implicit to allow idiomatic usage (return plain value to be
+  // implicitly converted to StatusOr)
+  template <
+      class... Args,
+      // sfinae to avoid clashing with copy/move constructors
+      std::enable_if_t<!internal::is_copy_or_move_ctor_arg_v<StatusOr, Args...>,
+                       int> = 0>
+  StatusOr(Args&&... args) : status_{Status::kOk} {
+    if constexpr (!std::is_same_v<T, void>) {
+      new (storage_) T(std::forward<Args>(args)...);
+    }
+  }
+
+  // Intentionally implicit to allow idiomatic usage (e.g. return StatusOr<A> to
+  // be implicitely converted to StatusOr<B>).
+  // When status is ok, the conversion is only allowed if B = void, otherwise it
+  // would require a conversion from A to non-void B.
+  template <class U, std::enable_if_t<!std::is_same_v<U, T>, int> = 0>
+  StatusOr(StatusOr<U>&& other) : status_{other.status_} {
+    if (IsOk()) {
+      PERFETTO_DCHECK((std::is_same_v<T, void>));
+    } else if (IsAbort()) {
+      new (storage_) std::unique_ptr<Stacktrace>(
+          std::move(other.GetStacktraceUniquePtr()));
+    }
+  }
+
+  ~StatusOr() {
+    if (IsOk()) {
+      if constexpr (!std::is_same_v<T, void>) {
+        value().~T();
+      }
+    }
+    if (IsAbort()) {
+      GetStacktraceUniquePtr().~unique_ptr();
+    }
+  }
 
-EventContext::EventContext(
-    EventContext::TracePacketHandle trace_packet,
-    internal::TrackEventIncrementalState* incremental_state,
-    const internal::TrackEventTlsState* tls_state)
-    : trace_packet_(std::move(trace_packet)),
-      event_(trace_packet_->set_track_event()),
-      incremental_state_(incremental_state),
-      tls_state_(tls_state) {}
+  bool IsOk() const { return status_ == Status::kOk; }
+  bool IsError() const { return status_ == Status::kError; }
+  bool IsAbort() const { return status_ == Status::kAbort; }
 
-EventContext::~EventContext() {
-  if (!trace_packet_)
-    return;
+  template <class U = T>
+  std::enable_if_t<!std::is_same_v<U, void>, U&> value() {
+    PERFETTO_DCHECK(IsOk());
+    return *std::launder(reinterpret_cast<T*>(storage_));
+  }
 
-  // When the track event is finalized (i.e., the context is destroyed), we
-  // should flush any newly seen interned data to the trace. The data has
-  // earlier been written to a heap allocated protobuf message
-  // (|serialized_interned_data|). Here we just need to flush it to the main
-  // trace.
-  auto& serialized_interned_data = incremental_state_->serialized_interned_data;
-  if (PERFETTO_LIKELY(serialized_interned_data.empty()))
-    return;
+  template <class U = T>
+  std::enable_if_t<!std::is_same_v<U, void>, const U&> value() const {
+    return const_cast<StatusOr*>(this)->value();
+  }
 
-  auto ranges = serialized_interned_data.GetRanges();
-  trace_packet_->AppendScatteredBytes(
-      perfetto::protos::pbzero::TracePacket::kInternedDataFieldNumber,
-      &ranges[0], ranges.size());
+  template <class U = T>
+  std::enable_if_t<!std::is_same_v<U, void>, U&> operator*() {
+    return value();
+  }
 
-  // Reset the message but keep one buffer allocated for future use.
-  serialized_interned_data.Reset();
-}
+  template <class U = T>
+  std::enable_if_t<!std::is_same_v<U, void>, const U&> operator*() const {
+    return value();
+  }
 
-protos::pbzero::DebugAnnotation* EventContext::AddDebugAnnotation(
-    const char* name) {
-  auto annotation = event()->add_debug_annotations();
-  annotation->set_name_iid(
-      internal::InternedDebugAnnotationName::Get(this, name));
-  return annotation;
-}
+  template <class U = T>
+  std::enable_if_t<!std::is_same_v<U, void>, U*> operator->() {
+    return &value();
+  }
 
-protos::pbzero::DebugAnnotation* EventContext::AddDebugAnnotation(
-    ::perfetto::DynamicString name) {
-  auto annotation = event()->add_debug_annotations();
-  annotation->set_name(name.value);
-  return annotation;
-}
+  template <class U = T>
+  std::enable_if_t<!std::is_same_v<U, void>, const U*> operator->() const {
+    return &value();
+  }
+
+  Stacktrace& stacktrace() {
+    PERFETTO_DCHECK(IsAbort());
+    return **std::launder(
+        reinterpret_cast<std::unique_ptr<Stacktrace>*>(storage_));
+  }
+
+ private:
+  template <class U>
+  friend class StatusOr;
+
+  // Intentionally private to encourage the use of factory methods, instead of
+  // plain status values. E.g. StatusOr::Abort() instead of Status::kAbort.
+  // Plain status value don't include stacktrace information in case of an
+  // abort.
+  explicit StatusOr(Status status) : status_{status} {
+    PERFETTO_DCHECK((std::is_same_v<T, void>) || !IsOk());
+    if (IsAbort()) {
+      new (storage_) std::unique_ptr<Stacktrace>{new Stacktrace{}};
+    }
+  }
+
+  std::unique_ptr<Stacktrace>& GetStacktraceUniquePtr() {
+    PERFETTO_DCHECK(IsAbort());
+    return *std::launder(
+        reinterpret_cast<std::unique_ptr<Stacktrace>*>(storage_));
+  }
+
+  Status status_;
 
+  static constexpr size_t kStorageAlign =
+      std::max(internal::alignof_v<T>, alignof(std::unique_ptr<Stacktrace>));
+  static constexpr size_t kStorageSize =
+      std::max(internal::sizeof_v<T>, sizeof(std::unique_ptr<Stacktrace>));
+  alignas(kStorageAlign) unsigned char storage_[kStorageSize];
+};
+
+}  // namespace protovm
 }  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/interceptor.cc
+
+#endif  // SRC_PROTOVM_ERROR_HANDLING_H_
+// gen_amalgamated begin header: src/protovm/node.h
+// gen_amalgamated begin header: src/protovm/owned_ptr.h
 /*
- * Copyright (C) 2020 The Android Open Source Project
+ * Copyright (C) 2025 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -44465,30 +49778,70 @@ protos::pbzero::DebugAnnotation* EventContext::AddDebugAnnotation(
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/tracing/interceptor.h"
+#ifndef SRC_PROTOVM_OWNED_PTR_H_
+#define SRC_PROTOVM_OWNED_PTR_H_
 
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_muxer.h"
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
 
 namespace perfetto {
+namespace protovm {
 
-InterceptorBase::~InterceptorBase() = default;
-InterceptorBase::ThreadLocalState::~ThreadLocalState() = default;
+// OwnedPtr is essentially a std::unique_ptr that doesn't perform any deletion
+// itself. Its purpose is to clearly express ownership semantics for objects
+// that are managed with a custom allocators.
+//
+// It is not a unique_ptr, because that's not guaranteed to be standard layout
+//
+// OwnedPtr is extensively used within RwProto to manage the lifecycle and
+// clarify ownership of the internal, manually-allocated nodes.
+template <class T>
+class OwnedPtr {
+ public:
+  using pointer = T*;
+  OwnedPtr(const OwnedPtr&) = delete;
+  OwnedPtr(OwnedPtr&& other) {
+    p_ = other.p_;
+    other.p_ = nullptr;
+  }
+  OwnedPtr(T* p) noexcept : p_(p) {}  // NOLINT: explicit
+  ~OwnedPtr() noexcept { reset(); }
+  OwnedPtr& operator=(const OwnedPtr&) = delete;
+  OwnedPtr& operator=(OwnedPtr&& other) noexcept {
+    if (this == &other) {
+      return *this;
+    }
+    reset();
+    p_ = other.p_;
+    other.p_ = nullptr;
+    return *this;
+  }
+  T* get() const noexcept { return p_; }
+  T* release() noexcept {
+    T* p = p_;
+    p_ = nullptr;
+    return p;
+  }
+  typename std::add_lvalue_reference<T>::type operator*() const noexcept {
+    return *p_;
+  }
+  explicit operator bool() const noexcept { return get() != nullptr; }
+  T* operator->() const noexcept { return p_; }
+  void reset(T* p = pointer()) noexcept {
+    PERFETTO_DCHECK(p_ == nullptr);
+    p_ = p;
+  }
 
-// static
-void InterceptorBase::RegisterImpl(
-    const InterceptorDescriptor& descriptor,
-    std::function<std::unique_ptr<InterceptorBase>()> factory,
-    InterceptorBase::TLSFactory tls_factory,
-    InterceptorBase::TracePacketCallback on_trace_packet) {
-  auto* tracing_impl = internal::TracingMuxer::Get();
-  tracing_impl->RegisterInterceptor(descriptor, factory, tls_factory,
-                                    on_trace_packet);
-}
+ private:
+  T* p_ = nullptr;
+};
 
+}  // namespace protovm
 }  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/internal/checked_scope.cc
+
+#endif  // SRC_PROTOVM_OWNED_PTR_H_
+// gen_amalgamated begin header: src/protovm/scalar.h
 /*
- * Copyright (C) 2021 The Android Open Source Project
+ * Copyright (C) 2025 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -44503,62 +49856,43 @@ void InterceptorBase::RegisterImpl(
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/checked_scope.h"
+#ifndef SRC_PROTOVM_SCALAR_H_
+#define SRC_PROTOVM_SCALAR_H_
 
-#include <utility>
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
 namespace perfetto {
-namespace internal {
+namespace protovm {
 
-#if PERFETTO_DCHECK_IS_ON()
-CheckedScope::CheckedScope(CheckedScope* parent_scope)
-    : parent_scope_(parent_scope) {
-  if (parent_scope_) {
-    PERFETTO_DCHECK(parent_scope_->is_active());
-    parent_scope_->set_is_active(false);
+struct Scalar {
+  static Scalar Fixed32(uint32_t value) {
+    return Scalar{protozero::proto_utils::ProtoWireType::kFixed32, value};
   }
-}
-
-CheckedScope::~CheckedScope() {
-  Reset();
-}
 
-void CheckedScope::Reset() {
-  if (!is_active_) {
-    // The only case when inactive scope could be destroyed is when Reset() was
-    // called explicitly or the contents of the object were moved away.
-    PERFETTO_DCHECK(deleted_);
-    return;
+  static Scalar Fixed64(uint64_t value) {
+    return Scalar{protozero::proto_utils::ProtoWireType::kFixed64, value};
   }
-  is_active_ = false;
-  deleted_ = true;
-  if (parent_scope_)
-    parent_scope_->set_is_active(true);
-}
 
-CheckedScope::CheckedScope(CheckedScope&& other) {
-  *this = std::move(other);
-}
+  static Scalar VarInt(uint64_t value) {
+    return Scalar{protozero::proto_utils::ProtoWireType::kVarInt, value};
+  }
 
-CheckedScope& CheckedScope::operator=(CheckedScope&& other) {
-  is_active_ = other.is_active_;
-  parent_scope_ = other.parent_scope_;
-  deleted_ = other.deleted_;
+  bool operator==(const Scalar& other) const {
+    return wire_type == other.wire_type && value == other.value;
+  }
 
-  other.is_active_ = false;
-  other.parent_scope_ = nullptr;
-  other.deleted_ = true;
+  bool operator!=(const Scalar& other) const { return !(*this == other); }
 
-  return *this;
-}
-#endif
+  protozero::proto_utils::ProtoWireType wire_type;
+  uint64_t value;
+};
 
-}  // namespace internal
+}  // namespace protovm
 }  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/internal/interceptor_trace_writer.cc
-// gen_amalgamated begin header: include/perfetto/tracing/internal/interceptor_trace_writer.h
+
+#endif  // SRC_PROTOVM_SCALAR_H_
 /*
- * Copyright (C) 2020 The Android Open Source Project
+ * Copyright (C) 2025 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -44573,61 +49907,105 @@ CheckedScope& CheckedScope::operator=(CheckedScope&& other) {
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_TRACING_INTERNAL_INTERCEPTOR_TRACE_WRITER_H_
-#define INCLUDE_PERFETTO_TRACING_INTERNAL_INTERCEPTOR_TRACE_WRITER_H_
+#ifndef SRC_PROTOVM_NODE_H_
+#define SRC_PROTOVM_NODE_H_
 
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/interceptor.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/basic_types.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/trace_writer_base.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h"
+#include <type_traits>
+#include <variant>
+
+// gen_amalgamated expanded: #include "perfetto/ext/base/intrusive_tree.h"
+// gen_amalgamated expanded: #include "src/protovm/owned_ptr.h"
+// gen_amalgamated expanded: #include "src/protovm/scalar.h"
 
 namespace perfetto {
+namespace protovm {
+
+struct Node;
+
 namespace internal {
+struct MapNode {
+  struct Traits {
+    using KeyType = uint64_t;
+    static constexpr size_t NodeOffset() {
+      static_assert(std::is_standard_layout_v<MapNode>);
+      return offsetof(MapNode, node);
+    }
+    static const KeyType& GetKey(const MapNode& n) { return n.key; }
+  };
 
-// A heap-backed trace writer used to reroute trace packets to an interceptor.
-class InterceptorTraceWriter : public TraceWriterBase {
- public:
-  InterceptorTraceWriter(std::unique_ptr<InterceptorBase::ThreadLocalState> tls,
-                         InterceptorBase::TracePacketCallback packet_callback,
-                         DataSourceStaticState* static_state,
-                         uint32_t instance_index);
-  ~InterceptorTraceWriter() override;
+  MapNode(uint64_t k, OwnedPtr<Node> v) : key{k}, value{std::move(v)} {}
 
-  // TraceWriterBase implementation.
-  protozero::MessageHandle<protos::pbzero::TracePacket> NewTracePacket()
-      override;
-  void FinishTracePacket() override;
-  void Flush(std::function<void()> callback = {}) override;
-  uint64_t written() const override;
+  base::IntrusiveTreeNode node{};
+  uint64_t key;
+  OwnedPtr<Node> value;
+};
 
- private:
-  std::unique_ptr<InterceptorBase::ThreadLocalState> tls_;
-  InterceptorBase::TracePacketCallback packet_callback_;
+}  // namespace internal
 
-  protozero::HeapBuffered<protos::pbzero::TracePacket> cur_packet_;
-  uint64_t bytes_written_ = 0;
+using IntrusiveMap =
+    base::IntrusiveTree<internal::MapNode, internal::MapNode::Traits>;
 
-  // Static state of the data source we are intercepting.
-  DataSourceStaticState* const static_state_;
+struct Node {
+  using MapNode = internal::MapNode;
 
-  // Index of the data source tracing session which we are intercepting
-  // (0...kMaxDataSourceInstances - 1). Used to look up this interceptor's
-  // session state (i.e., the Interceptor class instance) in the
-  // DataSourceStaticState::instances array.
-  const uint32_t instance_index_;
+  struct Bytes {
+    OwnedPtr<void> data;
+    size_t size;
+  };
 
-  const uint32_t sequence_id_;
+  struct Empty {};
 
-  static std::atomic<uint32_t> next_sequence_id_;
+  struct MappedRepeatedField {
+    IntrusiveMap key_to_node;
+  };
+
+  struct IndexedRepeatedField {
+    IntrusiveMap index_to_node;
+
+    // Flag needed to track the merge state of indexed repeated field
+    // (see implementation of Merge operation in RW proto)
+    bool has_been_merged;
+  };
+
+  struct Message {
+    IntrusiveMap field_id_to_node;
+  };
+
+  template <class T>
+  T* GetIf() {
+    return std::get_if<T>(&value);
+  }
+
+  template <class T>
+  const T* GetIf() const {
+    return std::get_if<T>(&value);
+  }
+
+  const char* GetTypeName() const;
+
+  std::variant<Bytes,
+               Empty,
+               IndexedRepeatedField,
+               MapNode,
+               MappedRepeatedField,
+               Message,
+               Scalar>
+      value;
 };
 
-}  // namespace internal
+Node& GetOuterNode(Node::MapNode& map_node);
+
+}  // namespace protovm
 }  // namespace perfetto
 
-#endif  // INCLUDE_PERFETTO_TRACING_INTERNAL_INTERCEPTOR_TRACE_WRITER_H_
+#endif  // SRC_PROTOVM_NODE_H_
+// gen_amalgamated begin header: src/protovm/slab_allocator.h
+// gen_amalgamated begin header: include/perfetto/ext/base/flat_hash_map.h
+// gen_amalgamated begin header: include/perfetto/ext/base/flat_hash_map_v1.h
+// gen_amalgamated begin header: include/perfetto/ext/base/murmur_hash.h
+// gen_amalgamated begin header: include/perfetto/ext/base/hash.h
 /*
- * Copyright (C) 2020 The Android Open Source Project
+ * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -44642,79 +50020,90 @@ class InterceptorTraceWriter : public TraceWriterBase {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/interceptor_trace_writer.h"
-
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_writer.h"
-
-namespace perfetto {
-namespace internal {
-
-// static
-std::atomic<uint32_t> InterceptorTraceWriter::next_sequence_id_{};
+#ifndef INCLUDE_PERFETTO_EXT_BASE_HASH_H_
+#define INCLUDE_PERFETTO_EXT_BASE_HASH_H_
 
-InterceptorTraceWriter::InterceptorTraceWriter(
-    std::unique_ptr<InterceptorBase::ThreadLocalState> tls,
-    InterceptorBase::TracePacketCallback packet_callback,
-    DataSourceStaticState* static_state,
-    uint32_t instance_index)
-    : tls_(std::move(tls)),
-      packet_callback_(std::move(packet_callback)),
-      static_state_(static_state),
-      instance_index_(instance_index),
-      sequence_id_(++next_sequence_id_) {}
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <tuple>
+#include <utility>
 
-InterceptorTraceWriter::~InterceptorTraceWriter() = default;
+namespace perfetto::base {
 
-protozero::MessageHandle<protos::pbzero::TracePacket>
-InterceptorTraceWriter::NewTracePacket() {
-  Flush();
-  auto packet = TraceWriter::TracePacketHandle(cur_packet_.get());
-  packet->set_trusted_packet_sequence_id(sequence_id_);
-  return packet;
+// ============================================================================
+// Absl-style hash customization point
+// ============================================================================
+//
+// To make a type hashable with Perfetto hash functions, define a friend
+// function template:
+//
+//   template <typename H>
+//   friend H PerfettoHashValue(H h, const MyType& value) {
+//     return H::Combine(std::move(h), value.field1, value.field2);
+//   }
+//
+// This function will be found via ADL (Argument Dependent Lookup) when hashing
+// your type. No forward declaration is needed - ADL finds it in your type's
+// namespace.
+
+// ============================================================================
+// Built-in PerfettoHashValue implementations for common standard library
+// types. These allow standard library types to work seamlessly with the
+// absl-style hash API without requiring users to define their own
+// implementations.
+// ============================================================================
+
+// Hash function for std::optional - hashes the value if present, or a sentinel
+// if not.
+template <typename H, typename T>
+H PerfettoHashValue(H h, const std::optional<T>& value) {
+  if (value.has_value()) {
+    return H::Combine(H::Combine(std::move(h), true), *value);
+  }
+  return H::Combine(std::move(h), false, 0);
+}
+
+// Hash function for std::pair - combines hashes of both elements.
+template <typename H, typename T1, typename T2>
+H PerfettoHashValue(H h, const std::pair<T1, T2>& value) {
+  return H::Combine(std::move(h), value.first, value.second);
+}
+
+// Hash function for std::tuple - combines hashes of all elements.
+template <typename H, typename... Ts>
+H PerfettoHashValue(H h, const std::tuple<Ts...>& value) {
+  return std::apply(
+      [&h](const auto&... elements) {
+        return H::Combine(std::move(h), elements...);
+      },
+      value);
 }
 
-void InterceptorTraceWriter::Flush(std::function<void()> callback) {
-  if (!cur_packet_.empty()) {
-    InterceptorBase::TracePacketCallbackArgs args{};
-    args.static_state = static_state_;
-    args.instance_index = instance_index_;
-    args.tls = tls_.get();
-
-    const auto& slices = cur_packet_.GetSlices();
-    if (slices.size() == 1) {
-      // Fast path: the current packet fits into a single slice.
-      auto slice_range = slices.begin()->GetUsedRange();
-      args.packet_data = protozero::ConstBytes{
-          slice_range.begin,
-          static_cast<size_t>(slice_range.end - slice_range.begin)};
-      bytes_written_ += static_cast<uint64_t>(args.packet_data.size);
-      packet_callback_(std::move(args));
-    } else {
-      // Fallback: stitch together multiple slices.
-      auto stitched_data = cur_packet_.SerializeAsArray();
-      args.packet_data =
-          protozero::ConstBytes{stitched_data.data(), stitched_data.size()};
-      bytes_written_ += static_cast<uint64_t>(stitched_data.size());
-      packet_callback_(std::move(args));
-    }
-    cur_packet_.Reset();
-  }
-  if (callback)
-    callback();
+// Hash function for pointers - hashes the pointer value as an integer.
+template <typename H, typename T>
+H PerfettoHashValue(H h, const std::unique_ptr<T>& ptr) {
+  return H::Combine(std::move(h), ptr.get());
 }
-
-void InterceptorTraceWriter::FinishTracePacket() {}
-
-uint64_t InterceptorTraceWriter::written() const {
-  return bytes_written_;
+template <typename H, typename T>
+H PerfettoHashValue(H h, const std::shared_ptr<T>& ptr) {
+  return H::Combine(std::move(h), ptr.get());
 }
 
-}  // namespace internal
-}  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/internal/tracing_backend_fake.cc
-// gen_amalgamated begin header: include/perfetto/tracing/internal/tracing_backend_fake.h
+// This is for using already-hashed key into std::unordered_map and avoid the
+// cost of re-hashing. Example:
+// unordered_map<uint64_t, Value, AlreadyHashed> my_map.
+template <typename T>
+struct AlreadyHashed {
+  size_t operator()(const T& x) const { return static_cast<size_t>(x); }
+};
+
+}  // namespace perfetto::base
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_HASH_H_
 /*
- * Copyright (C) 2021 The Android Open Source Project
+ * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -44729,35 +50118,368 @@ uint64_t InterceptorTraceWriter::written() const {
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_TRACING_INTERNAL_TRACING_BACKEND_FAKE_H_
-#define INCLUDE_PERFETTO_TRACING_INTERNAL_TRACING_BACKEND_FAKE_H_
+#ifndef INCLUDE_PERFETTO_EXT_BASE_MURMUR_HASH_H_
+#define INCLUDE_PERFETTO_EXT_BASE_MURMUR_HASH_H_
 
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/tracing_backend.h"
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <utility>
 
-namespace perfetto {
-namespace internal {
+// gen_amalgamated expanded: #include "perfetto/ext/base/hash.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_view.h"
+// gen_amalgamated expanded: #include "perfetto/public/compiler.h"
+
+// We need <cmath> only for std::isnan here. But cmath is a quite heavy
+// header AND is not frequently used, so its include cost is generally
+// NOT amortized. OTOH this header is very frequently used.
+// The code below avoids pulling cmath in many translation units, reducing
+// compilation time. Under the hoods std::isnan uses __builtin_isnan if
+// available.
+#if PERFETTO_HAS_BUILTIN(__builtin_isnan)
+#define PERFETTO_IS_NAN(x) __builtin_isnan(x)
+#else
+#include <cmath>
+#define PERFETTO_IS_NAN(x) std::isnan(x)
+#endif
 
-// A built-in implementation of TracingBackend that fails any attempt to create
-// a tracing session.
-class PERFETTO_EXPORT_COMPONENT TracingBackendFake : public TracingBackend {
+// This file provides an implementation of the 64-bit MurmurHash2 algorithm,
+// also known as MurmurHash64A. This algorithm, created by Austin Appleby, is a
+// fast, non-cryptographic hash function with excellent distribution properties,
+// making it ideal for use in hash tables.
+//
+// The file also includes related hashing utilities:
+// - A standalone `fmix64` finalizer from MurmurHash3, used for hashing
+//   individual numeric types.
+// - A hash combiner for creating a single hash from a sequence of values.
+//
+// NOTE: This implementation is NOT cryptographically secure. It must not be
+// used for security-sensitive applications like password storage or digital
+// signatures, as it is not designed to be resistant to malicious attacks.
+
+namespace perfetto::base {
+
+namespace murmur_internal {
+
+// Finalizes an intermediate hash value using the `fmix64` routine from
+// MurmurHash3.
+//
+// This function's purpose is to thoroughly mix the bits of the hash state to
+// ensure the final result is well-distributed, which is critical for avoiding
+// collisions in hash tables.
+//
+// Args:
+//   h: The intermediate hash value to be finalized.
+//
+// Returns:
+//   The final, well-mixed 64-bit hash value.
+inline uint64_t MurmurHashMix(uint64_t h) {
+  h ^= h >> 33;
+  h *= 0xff51afd7ed558ccdULL;
+  h ^= h >> 33;
+  h *= 0xc4ceb9fe1a85ec53ULL;
+  h ^= h >> 33;
+  return h;
+}
+
+// Computes a 64-bit hash for a block of memory using the MurmurHash64A
+// algorithm.
+//
+// The process involves four main steps:
+// 1. Initialization: The hash state is seeded with a value derived from the
+//    input length.
+// 2. Main Loop: Data is processed in 8-byte chunks, with each chunk being
+//    mixed into the hash state.
+// 3. Tail Processing: The final 1-7 bytes of data are handled.
+// 4. Finalization: The hash state is passed through a final mixing sequence to
+//    ensure good bit distribution.
+//
+// Args:
+//   input: A pointer to the data to be hashed.
+//   len:   The length of the data in bytes.
+//
+// Returns:
+//   The 64-bit MurmurHash64A hash of the input data.
+inline uint64_t MurmurHashBytes(const void* input, size_t len) {
+  // This implementation follows the canonical MurmurHash64A algorithm.
+  // The constants `kMulConstant` (m) and the shift value `47` (r) are from
+  // the original specification.
+  // The seed is inspired by the one used in DuckDB.
+  static constexpr uint64_t kSeed = 0xe17a1465U;
+  static constexpr uint64_t kMulConstant = 0xc6a4a7935bd1e995;
+  static constexpr int kShift = 47;
+
+  uint64_t h = kSeed ^ (len * kMulConstant);
+  const auto* data = static_cast<const uint8_t*>(input);
+  const size_t num_blocks = len / 8;
+
+  // Process 8-byte (64-bit) chunks
+  for (size_t i = 0; i < num_blocks; ++i) {
+    uint64_t k;
+    memcpy(&k, data, sizeof(k));
+    data += sizeof(k);  // Advance the pointer by 8 bytes
+
+    k *= kMulConstant;
+    k ^= k >> kShift;
+    k *= kMulConstant;
+
+    h ^= k;
+    h *= kMulConstant;
+  }
+
+  // Process the remaining 1 to 7 bytes
+  // The 'byte_ptr' now points to the beginning of the tail.
+  switch (len & 7) {
+    case 7:
+      h ^= static_cast<uint64_t>(data[6]) << 48;
+      [[fallthrough]];
+    case 6:
+      h ^= static_cast<uint64_t>(data[5]) << 40;
+      [[fallthrough]];
+    case 5:
+      h ^= static_cast<uint64_t>(data[4]) << 32;
+      [[fallthrough]];
+    case 4:
+      h ^= static_cast<uint64_t>(data[3]) << 24;
+      [[fallthrough]];
+    case 3:
+      h ^= static_cast<uint64_t>(data[2]) << 16;
+      [[fallthrough]];
+    case 2:
+      h ^= static_cast<uint64_t>(data[1]) << 8;
+      [[fallthrough]];
+    case 1:
+      h ^= static_cast<uint64_t>(data[0]);
+      h *= kMulConstant;
+  }
+
+  // Final mixing stage
+  h ^= h >> kShift;
+  h *= kMulConstant;
+  h ^= h >> kShift;
+
+  return h;
+}
+
+template <typename Float, typename Int>
+Int NormalizeFloatToInt(Float value) {
+  static_assert(std::is_floating_point_v<Float>);
+  static_assert(std::is_integral_v<Int>);
+
+  // Normalize floating point representations which can vary.
+  if (PERFETTO_UNLIKELY(value == 0.0)) {
+    // Turn negative zero into positive zero
+    value = 0.0;
+  } else if (PERFETTO_UNLIKELY(PERFETTO_IS_NAN(value))) {
+    // Turn arbtirary NaN representations to a consistent NaN repr.
+    value = std::numeric_limits<Float>::quiet_NaN();
+  }
+  Int res;
+  static_assert(sizeof(Float) == sizeof(Int));
+  memcpy(&res, &value, sizeof(Float));
+  return res;
+}
+
+// Computes a 64-bit hash for a single built-in value without any combination.
+// This is the core primitive used by both MurmurHashValue and
+// MurmurHashCombiner::CombineOne for built-in types.
+//
+// NOTE: This function intentionally has no else branch for non-builtin types,
+// which will cause a compile error if called with an unsupported type. Callers
+// should check if the type is supported before calling this function.
+template <typename T>
+auto MurmurHashBuiltinValue(const T& value) {
+  if constexpr (std::is_enum_v<T>) {
+    return murmur_internal::MurmurHashMix(
+        static_cast<uint64_t>(static_cast<std::underlying_type_t<T>>(value)));
+  } else if constexpr (std::is_integral_v<T>) {
+    return murmur_internal::MurmurHashMix(static_cast<uint64_t>(value));
+  } else if constexpr (std::is_same_v<T, double>) {
+    return murmur_internal::MurmurHashMix(
+        murmur_internal::NormalizeFloatToInt<double, uint64_t>(value));
+  } else if constexpr (std::is_same_v<T, float>) {
+    return murmur_internal::MurmurHashMix(
+        murmur_internal::NormalizeFloatToInt<float, uint32_t>(value));
+  } else if constexpr (std::is_same_v<T, std::string> ||
+                       std::is_same_v<T, std::string_view> ||
+                       std::is_same_v<T, base::StringView>) {
+    return murmur_internal::MurmurHashBytes(value.data(), value.size());
+  } else if constexpr (std::is_same_v<T, const char*>) {
+    std::string_view view(value);
+    return murmur_internal::MurmurHashBytes(view.data(), view.size());
+  } else if constexpr (std::is_pointer_v<T>) {
+    return murmur_internal::MurmurHashMix(
+        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(value)));
+  } else {
+    struct InvalidBuiltin {};
+    return InvalidBuiltin{};
+  }
+}
+
+// Helper to check if a type has a built-in MurmurHash implementation.
+template <typename T>
+constexpr bool HasMurmurHashBuiltinValue() {
+  return std::is_same_v<decltype(MurmurHashBuiltinValue(std::declval<T>())),
+                        uint64_t>;
+}
+
+// Helper to check if two types are integeral and U is convertible to T.
+template <typename T, typename U>
+constexpr bool IsConvertibleIntegral() {
+  return std::is_integral_v<T> && std::is_integral_v<U> &&
+         std::is_convertible_v<U, T>;
+}
+
+// Helper to check if a type is string-like (i.e. string, c-string or string
+// views).
+template <typename T>
+constexpr bool IsStringLike() {
+  return std::is_same_v<T, std::string> ||
+         std::is_same_v<T, std::string_view> ||
+         std::is_same_v<T, base::StringView> || std::is_same_v<T, const char*>;
+}
+
+// Helper to check if heterogeneous lookup is allowed between T and U.
+// Only allows it for convertible integral types and string-like types.
+template <typename T, typename U>
+constexpr bool AllowsHeterogeneousLookup() {
+  return IsConvertibleIntegral<T, U>() ||
+         (IsStringLike<T>() && IsStringLike<U>());
+}
+
+// Helper to detect pointers in Combine(...).
+// Hashing pointers directly is prohibited as it often indicates a misuse
+// (e.g., passing ptr and len instead of a single std::string_view).
+template <typename... Args>
+constexpr bool HasPointerV = (std::is_pointer_v<Args> || ...);
+
+}  // namespace murmur_internal
+
+// ============================================================================
+// MurmurHashCombiner - the core hasher state object
+// ============================================================================
+//
+// A helper class to create a 64-bit MurmurHash from a series of
+// structured fields.
+//
+// This class supports both the absl-style hasher API and a direct
+// member Combine() method.
+//
+// Absl-style API (for custom types with PerfettoHashValue):
+//   template <typename H>
+//   friend H PerfettoHashValue(H h, const MyType& value) {
+//     return H::Combine(std::move(h), value.field1, value.field2);
+//   }
+//
+// Direct API (for simple hash combining):
+//   MurmurHashCombiner combiner;
+//   combiner.Combine(field1, field2, ...);
+//   return combiner.digest();
+//
+// IMPORTANT: This is NOT a true streaming hash. It is an order-dependent
+// combiner. It does not guarantee that hashing two concatenated chunks of data
+// will produce the same result as hashing them separately in sequence.
+class MurmurHashCombiner {
  public:
-  static TracingBackend* GetInstance();
+  MurmurHashCombiner() = default;
 
-  // TracingBackend implementation.
-  std::unique_ptr<ProducerEndpoint> ConnectProducer(
-      const ConnectProducerArgs&) override;
-  std::unique_ptr<ConsumerEndpoint> ConnectConsumer(
-      const ConnectConsumerArgs&) override;
+  // Static Combine - returns a new hasher with the combined state.
+  // This is used by the absl-style PerfettoHashValue API.
+  template <typename... Args>
+  static MurmurHashCombiner Combine(MurmurHashCombiner h, const Args&... args) {
+    h.Combine(args...);
+    return h;
+  }
+
+  // Member Combine - combines values into this hasher's state.
+  // This is a convenient API for directly combining multiple values.
+  // The combination is order-dependent.
+  template <typename... Args>
+  void Combine(const Args&... args) {
+    static_assert(!murmur_internal::HasPointerV<Args...>,
+                  "MurmurHashCombiner::Combine() does not support pointers. "
+                  "If you want to hash the contents of a memory range, use a "
+                  "single hashable object (e.g., std::string_view). If you "
+                  "want to hash a pointer address, cast it to uintptr_t.");
+    // Uses a C++17 fold expression with CombineOne for each argument.
+    (CombineOne(args), ...);
+  }
+
+  // Returns the digest (i.e. current state of the combiner).
+  uint64_t digest() const { return hash_; }
 
  private:
-  TracingBackendFake();
+  // Combines a single value into the hasher state.
+  template <typename T>
+  void CombineOne(const T& value) {
+    if constexpr (murmur_internal::HasMurmurHashBuiltinValue<T>()) {
+      Update(murmur_internal::MurmurHashBuiltinValue(value));
+    } else {
+      // For custom types, use ADL to find the PerfettoHashValue function.
+      // This will cause a compile error with a clear message if the function
+      // is not defined.
+      hash_ = PerfettoHashValue(std::move(*this), value).digest();
+    }
+  }
+
+  // Low-level update with a pre-computed hash value. This uses a fast,
+  // order-dependent combination step inspired by the `hash_combine` function
+  // in the Boost C++ libraries.
+  void Update(uint64_t piece_hash) {
+    hash_ ^= piece_hash + 0x9e3779b9 + (hash_ << 6) + (hash_ >> 2);
+  }
+
+  static constexpr uint64_t kSeed = 0xe17a1465U;
+  uint64_t hash_ = kSeed;
 };
 
-}  // namespace internal
-}  // namespace perfetto
+// Simple wrapper function around MurmurHashCombiner to improve clarity in
+// callsites to not have to instantiate the class, call Combine() then digest().
+template <typename... Args>
+uint64_t MurmurHashCombine(const Args&... value) {
+  return MurmurHashCombiner::Combine(MurmurHashCombiner{}, value...).digest();
+}
 
-#endif  // INCLUDE_PERFETTO_TRACING_INTERNAL_TRACING_BACKEND_FAKE_H_
+// Simple wrapper function to compute a hash value for a single value.
+// This is the primitive hash operation that MurmurHash<T> delegates to.
+//
+// For built-in types (integers, floats, strings), this uses a fast path that
+// avoids the overhead of the MurmurHashCombiner. For custom types, it delegates
+// to MurmurHashCombiner which will use ADL to find the PerfettoHashValue.
+template <typename T>
+uint64_t MurmurHashValue(const T& value) {
+  if constexpr (murmur_internal::HasMurmurHashBuiltinValue<T>()) {
+    return murmur_internal::MurmurHashBuiltinValue(value);
+  } else {
+    return MurmurHashCombine(value);
+  }
+}
+
+// std::hash<T> drop-in class which uses MurmurHashValue as the primitive.
+// All specializations consistently delegate to MurmurHashValue.
+template <typename T>
+struct MurmurHash {
+  using is_transparent = void;
+
+  uint64_t operator()(const T& value) const { return MurmurHashValue(value); }
+
+  // Heterogeneous lookup support. Only allowed for types where it makes sense
+  // (e.g. string-like types and convertible integral types).
+  template <typename U>
+  auto operator()(const U& value) const
+      -> std::enable_if_t<murmur_internal::AllowsHeterogeneousLookup<T, U>(),
+                          uint64_t> {
+    return MurmurHashValue(value);
+  }
+};
+
+}  // namespace perfetto::base
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_MURMUR_HASH_H_
 /*
  * Copyright (C) 2021 The Android Open Source Project
  *
@@ -44774,160 +50496,458 @@ class PERFETTO_EXPORT_COMPONENT TracingBackendFake : public TracingBackend {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_backend_fake.h"
+#ifndef INCLUDE_PERFETTO_EXT_BASE_FLAT_HASH_MAP_V1_H_
+#define INCLUDE_PERFETTO_EXT_BASE_FLAT_HASH_MAP_V1_H_
 
-// gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/weak_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/consumer.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/producer.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_writer.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h"
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/murmur_hash.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
+// gen_amalgamated expanded: #include "perfetto/public/compiler.h"
 
-namespace perfetto {
-namespace internal {
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <memory>
+#include <type_traits>
+#include <utility>
 
-namespace {
+namespace perfetto::base {
 
-class UnsupportedProducerEndpoint : public ProducerEndpoint {
- public:
-  UnsupportedProducerEndpoint(Producer* producer, base::TaskRunner* task_runner)
-      : producer_(producer), task_runner_(task_runner) {
-    // The SDK will attempt to reconnect the producer, so instead we allow it
-    // to connect successfully, but never start any sessions.
-    auto weak_ptr = weak_ptr_factory_.GetWeakPtr();
-    task_runner_->PostTask([weak_ptr] {
-      if (weak_ptr && weak_ptr->connected_)
-        weak_ptr->producer_->OnConnect();
-    });
+// An open-addressing hashmap implementation.
+// Pointers are not stable, neither for keys nor values.
+// Has similar performances of a RobinHood hash (without the complications)
+// and 2x an unordered map.
+// Doc: http://go/perfetto-hashtables .
+//
+// When used to implement a string pool in TraceProcessor, the performance
+// characteristics obtained by replaying the set of strings seeen in a 4GB trace
+// (226M strings, 1M unique) are the following (see flat_hash_map_benchmark.cc):
+// This(Linear+AppendOnly)    879,383,676 ns    258.013M insertions/s
+// This(LinearProbe):         909,206,047 ns    249.546M insertions/s
+// This(QuadraticProbe):    1,083,844,388 ns    209.363M insertions/s
+// std::unordered_map:      6,203,351,870 ns    36.5811M insertions/s
+// tsl::robin_map:            931,403,397 ns    243.622M insertions/s
+// absl::flat_hash_map:       998,013,459 ns    227.379M insertions/s
+// FollyF14FastMap:         1,181,480,602 ns    192.074M insertions/s
+//
+// The structs below define the probing algorithm used to probe slots upon a
+// collision. They are guaranteed to visit all slots as our table size is always
+// a power of two (see https://en.wikipedia.org/wiki/Quadratic_probing).
+
+// Linear probing can be faster if the hashing is well distributed and the load
+// is not high. For TraceProcessor's StringPool this is the fastest. It can
+// degenerate badly if the hashing doesn't spread (e.g., if using directly pids
+// as keys, with a no-op hashing function).
+struct LinearProbe {
+  static inline size_t Calc(size_t key_hash, size_t step, size_t capacity) {
+    return (key_hash + step) & (capacity - 1);  // Linear probe
   }
-  ~UnsupportedProducerEndpoint() override { Disconnect(); }
+};
 
-  void Disconnect() override {
-    if (!connected_)
-      return;
-    connected_ = false;
-    producer_->OnDisconnect();
+// Generates the sequence: 0, 3, 10, 21, 36, 55, ...
+// Can be a bit (~5%) slower than LinearProbe because it's less cache hot, but
+// avoids degenerating badly if the hash function is bad and causes clusters.
+// A good default choice unless benchmarks prove otherwise.
+struct QuadraticProbe {
+  static inline size_t Calc(size_t key_hash, size_t step, size_t capacity) {
+    return (key_hash + 2 * step * step + step) & (capacity - 1);
   }
+};
 
-  void RegisterDataSource(const DataSourceDescriptor&) override {}
-  void UpdateDataSource(const DataSourceDescriptor&) override {}
-  void UnregisterDataSource(const std::string& /*name*/) override {}
+// Tends to perform in the middle between linear and quadratic.
+// It's a bit more cache-effective than the QuadraticProbe but can create more
+// clustering if the hash function doesn't spread well.
+// Generates the sequence: 0, 1, 3, 6, 10, 15, 21, ...
+struct QuadraticHalfProbe {
+  static inline size_t Calc(size_t key_hash, size_t step, size_t capacity) {
+    return (key_hash + (step * step + step) / 2) & (capacity - 1);
+  }
+};
 
-  void RegisterTraceWriter(uint32_t /*writer_id*/,
-                           uint32_t /*target_buffer*/) override {}
-  void UnregisterTraceWriter(uint32_t /*writer_id*/) override {}
+// Non-templated base class to hold helpers for FlatHashMap.
+struct FlatHashMapV1Base {
+ public:
+  // Helper to detect if a hasher has is_transparent defined.
+  template <typename, typename = void>
+  struct HasIsTransparent : std::false_type {};
+
+  template <typename H>
+  struct HasIsTransparent<H, std::void_t<typename H::is_transparent>>
+      : std::true_type {};
+
+  // Helper to check if a lookup key type K is allowed.
+  // Returns true if:
+  // 1. K can be implicitly converted to Key, OR
+  // 2. Hasher has is_transparent AND Hasher is invocable with K AND Key and K
+  // are equality comparable
+  template <typename K, typename Key, typename Hasher>
+  static constexpr bool IsLookupKeyAllowed() {
+    if constexpr (HasIsTransparent<Hasher>::value) {
+      return std::is_invocable_v<Hasher, const K&> &&
+             std::is_same_v<decltype(std::declval<const Key&>() ==
+                                     std::declval<const K&>()),
+                            bool>;
+    } else if constexpr (std::is_convertible_v<K, Key>) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+};
 
-  void CommitData(const CommitDataRequest&,
-                  CommitDataCallback callback) override {
-    if (connected_) {
-      callback();
+template <typename Key,
+          typename Value,
+          typename Hasher = base::MurmurHash<Key>,
+          typename Probe = QuadraticProbe,
+          bool AppendOnly = false>
+class FlatHashMapV1 : protected FlatHashMapV1Base {
+ public:
+  class Iterator {
+   public:
+    explicit Iterator(const FlatHashMapV1* map) : map_(map) {
+      FindNextNonFree();
+    }
+    ~Iterator() = default;
+    Iterator(const Iterator&) = default;
+    Iterator& operator=(const Iterator&) = default;
+    Iterator(Iterator&&) noexcept = default;
+    Iterator& operator=(Iterator&&) noexcept = default;
+
+    Key& key() { return map_->keys_[idx_]; }
+    Value& value() { return map_->values_[idx_]; }
+    const Key& key() const { return map_->keys_[idx_]; }
+    const Value& value() const { return map_->values_[idx_]; }
+
+    explicit operator bool() const { return idx_ != kEnd; }
+    Iterator& operator++() {
+      PERFETTO_DCHECK(idx_ < map_->capacity_);
+      ++idx_;
+      FindNextNonFree();
+      return *this;
+    }
+
+   private:
+    static constexpr size_t kEnd = std::numeric_limits<size_t>::max();
+
+    void FindNextNonFree() {
+      const auto& tags = map_->tags_;
+      for (; idx_ < map_->capacity_; idx_++) {
+        if (tags[idx_] != kFreeSlot && (AppendOnly || tags[idx_] != kTombstone))
+          return;
+      }
+      idx_ = kEnd;
     }
+
+    const FlatHashMapV1* map_ = nullptr;
+    size_t idx_ = 0;
+  };  // Iterator
+  static constexpr int kDefaultLoadLimitPct = 75;
+  explicit FlatHashMapV1(size_t initial_capacity = 0,
+                         int load_limit_pct = kDefaultLoadLimitPct)
+      : load_limit_percent_(load_limit_pct) {
+    if (initial_capacity > 0)
+      Reset(initial_capacity, true);
   }
 
-  SharedMemory* shared_memory() const override { return nullptr; }
-  size_t shared_buffer_page_size_kb() const override { return 0; }
+  // We are calling Clear() so that the destructors for the inserted entries are
+  // called (unless they are trivial, in which case it will be a no-op).
+  ~FlatHashMapV1() { Clear(); }
 
-  std::unique_ptr<TraceWriter> CreateTraceWriter(
-      BufferID /*target_buffer*/,
-      BufferExhaustedPolicy) override {
-    return nullptr;
+  FlatHashMapV1(FlatHashMapV1&& other) noexcept {
+    tags_ = std::move(other.tags_);
+    keys_ = std::move(other.keys_);
+    values_ = std::move(other.values_);
+    capacity_ = other.capacity_;
+    size_ = other.size_;
+    tombstones_ = other.tombstones_;
+    max_probe_length_ = other.max_probe_length_;
+    load_limit_ = other.load_limit_;
+    load_limit_percent_ = other.load_limit_percent_;
+
+    new (&other) FlatHashMapV1();
   }
 
-  SharedMemoryArbiter* MaybeSharedMemoryArbiter() override { return nullptr; }
-  bool IsShmemProvidedByProducer() const override { return false; }
+  FlatHashMapV1& operator=(FlatHashMapV1&& other) noexcept {
+    this->~FlatHashMapV1();
+    new (this) FlatHashMapV1(std::move(other));
+    return *this;
+  }
 
-  void NotifyFlushComplete(FlushRequestID) override {}
-  void NotifyDataSourceStarted(DataSourceInstanceID) override {}
-  void NotifyDataSourceStopped(DataSourceInstanceID) override {}
-  void ActivateTriggers(const std::vector<std::string>&) override {}
+  FlatHashMapV1(const FlatHashMapV1&) = delete;
+  FlatHashMapV1& operator=(const FlatHashMapV1&) = delete;
+
+  std::pair<Value*, bool> Insert(Key key, Value value) {
+    const size_t key_hash = Hasher{}(key);
+    const uint8_t tag = HashToTag(key_hash);
+    static constexpr size_t kSlotNotFound = std::numeric_limits<size_t>::max();
+
+    // This for loop does in reality at most two attempts:
+    // The first iteration either:
+    //  - Early-returns, because the key exists already,
+    //  - Finds an insertion slot and proceeds because the load is < limit.
+    // The second iteration is only hit in the unlikely case of this insertion
+    // bringing the table beyond the target |load_limit_| (or the edge case
+    // of the HT being full, if |load_limit_pct_| = 100).
+    // We cannot simply pre-grow the table before insertion, because we must
+    // guarantee that calling Insert() with a key that already exists doesn't
+    // invalidate iterators.
+    size_t insertion_slot;
+    size_t probe_len;
+    for (;;) {
+      PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0);  // Must be a pow2.
+      insertion_slot = kSlotNotFound;
+      // Start the iteration at the desired slot (key_hash % capacity_)
+      // searching either for a free slot or a tombstone. In the worst case we
+      // might end up scanning the whole array of slots. The Probe functions are
+      // guaranteed to visit all the slots within |capacity_| steps. If we find
+      // a free slot, we can stop the search immediately (a free slot acts as an
+      // "end of chain for entries having the same hash". If we find a
+      // tombstones (a deleted slot) we remember its position, but have to keep
+      // searching until a free slot to make sure we don't insert a duplicate
+      // key.
+      for (probe_len = 0; probe_len < capacity_;) {
+        const size_t idx = Probe::Calc(key_hash, probe_len, capacity_);
+        PERFETTO_DCHECK(idx < capacity_);
+        const uint8_t tag_idx = tags_[idx];
+        ++probe_len;
+        if (tag_idx == kFreeSlot) {
+          // Rationale for "insertion_slot == kSlotNotFound": if we encountered
+          // a tombstone while iterating we should reuse that rather than
+          // taking another slot.
+          if (AppendOnly || insertion_slot == kSlotNotFound)
+            insertion_slot = idx;
+          break;
+        }
+        // We should never encounter tombstones in AppendOnly mode.
+        PERFETTO_DCHECK(!(tag_idx == kTombstone && AppendOnly));
+        if (!AppendOnly && tag_idx == kTombstone) {
+          insertion_slot = idx;
+          continue;
+        }
+        if (tag_idx == tag && keys_[idx] == key) {
+          // The key is already in the map.
+          return std::make_pair(&values_[idx], false);
+        }
+      }  // for (idx)
 
-  void Sync(std::function<void()> callback) override {
-    if (connected_) {
-      callback();
+      // If we got to this point the key does not exist (otherwise we would have
+      // hit the return above) and we are going to insert a new entry.
+      // Before doing so, ensure we stay under the target load limit.
+      if (PERFETTO_UNLIKELY(size_ >= load_limit_)) {
+        MaybeGrowAndRehash(/*grow=*/true);
+        continue;
+      }
+      // If there are too many tombstones, it's worth doing a rehash to
+      // clean them up. This is to avoid the case where we have a table full
+      // of tombstones which would cause lookups to be very slow.
+      bool is_many_tombstones = tombstones_ > size_ && size_ > 128;
+      bool is_tombstones_plus_size_too_high = tombstones_ + size_ > load_limit_;
+      if (PERFETTO_UNLIKELY(is_many_tombstones ||
+                            is_tombstones_plus_size_too_high)) {
+        MaybeGrowAndRehash(/*grow=*/false);
+        continue;
+      }
+      PERFETTO_DCHECK(insertion_slot != kSlotNotFound);
+      break;
+    }  // for (attempt)
+
+    PERFETTO_CHECK(insertion_slot < capacity_);
+
+    // We found a free slot (or a tombstone). Proceed with the insertion.
+    if (tags_[insertion_slot] == kTombstone) {
+      PERFETTO_DCHECK(tombstones_ > 0);
+      tombstones_--;
     }
+    Value* value_idx = &values_[insertion_slot];
+    new (&keys_[insertion_slot]) Key(std::move(key));
+    new (value_idx) Value(std::move(value));
+    tags_[insertion_slot] = tag;
+    PERFETTO_DCHECK(probe_len > 0 && probe_len <= capacity_);
+    max_probe_length_ = std::max(max_probe_length_, probe_len);
+    size_++;
+
+    return std::make_pair(value_idx, true);
   }
 
- private:
-  Producer* const producer_;
-  base::TaskRunner* const task_runner_;
-  bool connected_ = true;
-  base::WeakPtrFactory<UnsupportedProducerEndpoint> weak_ptr_factory_{
-      this};  // Keep last.
-};
+  template <typename K = Key>
+  Value* Find(const K& key) const {
+    const size_t idx = FindInternal(key);
+    if (idx == kNotFound)
+      return nullptr;
+    return &values_[idx];
+  }
 
-class UnsupportedConsumerEndpoint : public ConsumerEndpoint {
- public:
-  UnsupportedConsumerEndpoint(Consumer* consumer, base::TaskRunner* task_runner)
-      : consumer_(consumer), task_runner_(task_runner) {
-    // The SDK will not to reconnect the consumer, so we just disconnect it
-    // immediately, which will cancel the tracing session.
-    auto weak_this = weak_ptr_factory_.GetWeakPtr();
-    task_runner_->PostTask([weak_this] {
-      if (weak_this)
-        weak_this->consumer_->OnDisconnect();
-    });
+  template <typename K = Key>
+  bool Erase(const K& key) {
+    if (AppendOnly)
+      PERFETTO_FATAL("Erase() not supported because AppendOnly=true");
+    size_t idx = FindInternal(key);
+    if (idx == kNotFound)
+      return false;
+    EraseInternal(idx);
+    return true;
   }
-  ~UnsupportedConsumerEndpoint() override = default;
 
-  void EnableTracing(const TraceConfig&, base::ScopedFile) override {}
-  void ChangeTraceConfig(const TraceConfig&) override {}
+  void Clear() {
+    // Avoid trivial heap operations on zero-capacity std::move()-d objects.
+    if (PERFETTO_UNLIKELY(capacity_ == 0))
+      return;
 
-  void StartTracing() override {}
-  void DisableTracing() override {}
+    for (size_t i = 0; i < capacity_; ++i) {
+      const uint8_t tag = tags_[i];
+      if (tag != kFreeSlot && (AppendOnly || tag != kTombstone)) {
+        keys_[i].~Key();
+        values_[i].~Value();
+      }
+    }
+    Reset(capacity_, false);
+  }
 
-  void Flush(uint32_t /*timeout_ms*/, FlushCallback callback) override {
-    callback(/*success=*/false);
+  Value& operator[](Key key) {
+    auto it_and_inserted = Insert(std::move(key), Value{});
+    return *it_and_inserted.first;
   }
 
-  void ReadBuffers() override {}
-  void FreeBuffers() override {}
+  Iterator GetIterator() { return Iterator(this); }
+  const Iterator GetIterator() const { return Iterator(this); }
 
-  void Detach(const std::string& /*key*/) override {}
-  void Attach(const std::string& /*key*/) override {}
+  size_t size() const { return size_; }
+  size_t capacity() const { return capacity_; }
 
-  void GetTraceStats() override {}
-  void ObserveEvents(uint32_t /*events_mask*/) override {}
-  void QueryServiceState(QueryServiceStateCallback) override {}
-  void QueryCapabilities(QueryCapabilitiesCallback) override {}
+  // "protected" here is only for the flat_hash_map_benchmark.cc. Everything
+  // below is by all means private.
+ protected:
+  enum ReservedTags : uint8_t { kFreeSlot = 0, kTombstone = 1 };
+  static constexpr size_t kNotFound = std::numeric_limits<size_t>::max();
 
-  void SaveTraceForBugreport(SaveTraceForBugreportCallback) override {}
-  void CloneSession(TracingSessionID) override {}
+  template <typename K = Key>
+  size_t FindInternal(const K& key) const {
+    static_assert(
+        IsLookupKeyAllowed<K, Key, Hasher>(),
+        "Heterogeneous lookup requires Hasher to define is_transparent and "
+        "support hashing the lookup key type. For same-type lookup, Key and K "
+        "must match exactly.");
+    const size_t key_hash = Hasher{}(key);
+    const uint8_t tag = HashToTag(key_hash);
+    PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0);  // Must be a pow2.
+    PERFETTO_DCHECK(max_probe_length_ <= capacity_);
+    for (size_t i = 0; i < max_probe_length_; ++i) {
+      const size_t idx = Probe::Calc(key_hash, i, capacity_);
+      const uint8_t tag_idx = tags_[idx];
+
+      if (tag_idx == kFreeSlot)
+        return kNotFound;
+      // HashToTag() never returns kTombstone, so the tag-check below cannot
+      // possibly match. Also we just want to skip tombstones.
+      if (tag_idx == tag && keys_[idx] == key) {
+        PERFETTO_DCHECK(tag_idx > kTombstone);
+        return idx;
+      }
+    }  // for (idx)
+    return kNotFound;
+  }
+
+  void EraseInternal(size_t idx) {
+    PERFETTO_DCHECK(tags_[idx] > kTombstone);
+    PERFETTO_DCHECK(size_ > 0);
+    tags_[idx] = kTombstone;
+    keys_[idx].~Key();
+    values_[idx].~Value();
+    size_--;
+    tombstones_++;
+    PERFETTO_DCHECK(size_ + tombstones_ <= capacity_);
+  }
+
+  PERFETTO_NO_INLINE void MaybeGrowAndRehash(bool grow) {
+    PERFETTO_DCHECK(size_ <= capacity_);
+    const size_t old_capacity = capacity_;
+
+    // Grow quickly up to 1MB, then chill.
+    const size_t old_size_bytes = old_capacity * (sizeof(Key) + sizeof(Value));
+    const size_t grow_factor = old_size_bytes < (1024u * 1024u) ? 8 : 2;
+    const size_t new_capacity =
+        grow ? std::max(old_capacity * grow_factor, size_t(1024))
+             : old_capacity;
+
+    auto old_tags(std::move(tags_));
+    auto old_keys(std::move(keys_));
+    auto old_values(std::move(values_));
+    size_t old_size = size_;
+
+    // This must be a CHECK (i.e. not just a DCHECK) to prevent UAF attacks on
+    // 32-bit archs that try to double the size of the table until wrapping.
+    PERFETTO_CHECK(new_capacity >= old_capacity);
+    Reset(new_capacity, true);
+
+    size_t new_size = 0;  // Recompute the size.
+    for (size_t i = 0; i < old_capacity; ++i) {
+      const uint8_t old_tag = old_tags[i];
+      if (old_tag != kFreeSlot && old_tag != kTombstone) {
+        Insert(std::move(old_keys[i]), std::move(old_values[i]));
+        old_keys[i].~Key();  // Destroy the old objects.
+        old_values[i].~Value();
+        new_size++;
+      }
+    }
+    PERFETTO_DCHECK(new_size == old_size);
+    PERFETTO_DCHECK(tombstones_ == 0);
+    size_ = new_size;
+  }
 
- private:
-  Consumer* const consumer_;
-  base::TaskRunner* const task_runner_;
-  base::WeakPtrFactory<UnsupportedConsumerEndpoint> weak_ptr_factory_{
-      this};  // Keep last.
-};
+  // Doesn't call destructors. Use Clear() for that.
+  PERFETTO_NO_INLINE void Reset(size_t n, bool reallocate) {
+    PERFETTO_DCHECK((n & (n - 1)) == 0);  // Must be a pow2.
 
-}  // namespace
+    capacity_ = n;
+    max_probe_length_ = 0;
+    size_ = 0;
+    tombstones_ = 0;
+    load_limit_ = n * static_cast<size_t>(load_limit_percent_) / 100;
+    load_limit_ = std::min(load_limit_, n);
 
-// static
-TracingBackend* TracingBackendFake::GetInstance() {
-  static auto* instance = new TracingBackendFake();
-  return instance;
-}
+    if (reallocate) {
+      tags_.reset(new uint8_t[n]);
+      keys_ = AlignedAllocTyped<Key[]>(n);  // Deliberately not 0-initialized.
+      values_ =
+          AlignedAllocTyped<Value[]>(n);  // Deliberately not 0-initialized.
+    }
 
-TracingBackendFake::TracingBackendFake() = default;
+    // Only clear the tags if not nullptr.
+    if (tags_) {
+      memset(&tags_[0], 0, n);  // Clear all tags.
+    }
+  }
 
-std::unique_ptr<ProducerEndpoint> TracingBackendFake::ConnectProducer(
-    const ConnectProducerArgs& args) {
-  return std::unique_ptr<ProducerEndpoint>(
-      new UnsupportedProducerEndpoint(args.producer, args.task_runner));
-}
+  static inline uint8_t HashToTag(size_t full_hash) {
+    uint8_t tag = full_hash >> (sizeof(full_hash) * 8 - 8);
+    // Ensure the hash is always >= 2. We use 0, 1 for kFreeSlot and kTombstone.
+    tag += (tag <= kTombstone) << 1;
+    PERFETTO_DCHECK(tag > kTombstone);
+    return tag;
+  }
 
-std::unique_ptr<ConsumerEndpoint> TracingBackendFake::ConnectConsumer(
-    const ConnectConsumerArgs& args) {
-  return std::unique_ptr<ConsumerEndpoint>(
-      new UnsupportedConsumerEndpoint(args.consumer, args.task_runner));
-}
+  size_t capacity_ = 0;
+  size_t size_ = 0;
+  size_t tombstones_ = 0;
+  size_t max_probe_length_ = 0;
+  size_t load_limit_ = 0;  // Updated every time |capacity_| changes.
+  int load_limit_percent_ =
+      kDefaultLoadLimitPct;  // Load factor limit in % of |capacity_|.
+
+  // These arrays have always the |capacity_| elements.
+  // Note: AlignedUniquePtr just allocates memory, doesn't invoke any ctor/dtor.
+  std::unique_ptr<uint8_t[]> tags_;
+  AlignedUniquePtr<Key[]> keys_;
+  AlignedUniquePtr<Value[]> values_;
+};
 
-}  // namespace internal
-}  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/internal/tracing_muxer_fake.cc
-// gen_amalgamated begin header: src/tracing/internal/tracing_muxer_fake.h
+}  // namespace perfetto::base
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_FLAT_HASH_MAP_V1_H_
 /*
- * Copyright (C) 2021 The Android Open Source Project
+ * Copyright (C) 2025 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -44942,710 +50962,935 @@ std::unique_ptr<ConsumerEndpoint> TracingBackendFake::ConnectConsumer(
  * limitations under the License.
  */
 
-#ifndef SRC_TRACING_INTERNAL_TRACING_MUXER_FAKE_H_
-#define SRC_TRACING_INTERNAL_TRACING_MUXER_FAKE_H_
+#ifndef INCLUDE_PERFETTO_EXT_BASE_FLAT_HASH_MAP_H_
+#define INCLUDE_PERFETTO_EXT_BASE_FLAT_HASH_MAP_H_
 
-// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_muxer.h"
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/bits.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/flat_hash_map_v1.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/murmur_hash.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_view.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
+// gen_amalgamated expanded: #include "perfetto/public/compiler.h"
 
-namespace perfetto {
-namespace internal {
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <functional>
+#include <limits>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <utility>
 
-// An always-fail implementation of TracingMuxer. Before tracing has been
-// initialiazed, all muxer operations will route here and fail with a helpful
-// error message. This is to avoid introducing null checks in
-// performance-critical parts of the codebase.
-class TracingMuxerFake : public TracingMuxer {
-  class FakePlatform : public Platform {
-   public:
-    ~FakePlatform() override;
-    ThreadLocalObject* GetOrCreateThreadLocalObject() override;
-    std::unique_ptr<base::TaskRunner> CreateTaskRunner(
-        const CreateTaskRunnerArgs&) override;
-    std::string GetCurrentProcessName() override;
+#if PERFETTO_BUILDFLAG(PERFETTO_X64_CPU_OPT)
+#include <immintrin.h>
+#endif
 
-    static FakePlatform instance;
+namespace perfetto::base {
+
+// A Swiss Table-style open-addressing hashmap implementation.
+// Inspired by absl::flat_hash_map, this uses a metadata array of control bytes
+// to enable fast SIMD-accelerated probing.
+//
+// Key design choices:
+// - Control bytes: Each slot has a 1-byte tag (7-bit H2 hash or special marker)
+//   stored in a separate array, enabling fast group-based matching.
+// - SIMD acceleration: On x64, uses SSE instructions to match 16 control bytes
+//   in parallel. Falls back to SWAR (SIMD Within A Register) on other platforms
+//   matching 8 bytes at a time.
+// - Triangular probing: Uses the sequence 0, 16, 48, 96, ... (like Absl) to
+//   probe groups of slots, ensuring good cache behavior.
+// - Pointers are NOT stable: Neither keys nor values have stable addresses
+//   across insertions that trigger rehashing.
+//
+// See also: FlatHashMapV1 in flat_hash_map_v1.h for the older implementation
+// using traditional open-addressing with configurable probing strategies.
+
+// Non-templated base class to hold helpers for FlatHashMapV2.
+namespace flat_hash_map_v2_internal {
+
+// Helper to detect if a hasher has is_transparent defined.
+template <typename, typename = void>
+struct HasIsTransparent : std::false_type {};
+
+template <typename H>
+struct HasIsTransparent<H, std::void_t<typename H::is_transparent>>
+    : std::true_type {};
+
+// Equality comparator trait.
+template <typename T>
+struct HashEq : public std::equal_to<T> {};
+
+// Specialization for std::string to compare via std::string_view.
+//
+// This exists because after benchmarking, it turns out libc++ has an
+// "optimization" for std::string equality that does something byte by
+// byte comparision for short strings but this is slower than just memcmp.
+//
+// This helps close the gap to absl::flat_hash_map for string keys.
+template <>
+struct HashEq<std::string> {
+  bool operator()(const std::string& a, const std::string& b) const {
+    return std::string_view(a) == std::string_view(b);
+  }
+  bool operator()(const std::string& a, const std::string_view& b) const {
+    return std::string_view(a) == b;
+  }
+  bool operator()(const std::string& a, base::StringView b) const {
+    return base::StringView(a) == b;
+  }
+};
+
+// Helper to check if a lookup key type K is allowed.
+// Returns true if:
+// 1. K can be implicitly converted to Key, OR
+// 2. Hasher has is_transparent AND Hasher is invocable with K AND Key and K
+// are equality comparable
+template <typename K, typename Key, typename Hasher>
+static constexpr bool IsLookupKeyAllowed() {
+  if constexpr (HasIsTransparent<Hasher>::value) {
+    return std::is_invocable_v<Hasher, const K&> &&
+           std::is_same_v<decltype(std::declval<const Key&>() ==
+                                   std::declval<const K&>()),
+                          bool>;
+  } else if constexpr (std::is_convertible_v<K, Key>) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+// Swiss Table control byte encoding:
+// - Empty:   0x80 (10000000) - MSB set, easy to detect with sign bit
+// - Deleted: 0xFE (11111110) - MSB set
+// - Full:    0x00-0x7F - MSB clear, stores 7-bit H2 hash
+static constexpr uint8_t kFreeSlot = 0x80;   // Empty slot
+static constexpr uint8_t kTombstone = 0xFE;  // Deleted slot
+
+// The default load limit percent before growing the table.
+static constexpr int kDefaultLoadLimitPct = 75;
+
+}  // namespace flat_hash_map_v2_internal
+
+template <typename Key,
+          typename Value,
+          typename Hasher = base::MurmurHash<Key>,
+          typename Eq = flat_hash_map_v2_internal::HashEq<Key>>
+class FlatHashMapV2 {
+ private:
+  // Import constants from internal namespace.
+  static constexpr uint8_t kFreeSlot = flat_hash_map_v2_internal::kFreeSlot;
+  static constexpr uint8_t kTombstone = flat_hash_map_v2_internal::kTombstone;
+  static constexpr int kDefaultLoadLimitPct =
+      flat_hash_map_v2_internal::kDefaultLoadLimitPct;
+
+  // Slot structure holds both key and value
+  struct Slot {
+    Key key;
+    Value value;
   };
 
  public:
-  TracingMuxerFake() : TracingMuxer(&FakePlatform::instance) {}
-  ~TracingMuxerFake() override;
+  class Iterator {
+   public:
+    explicit Iterator(const uint8_t* ctrl, const uint8_t* ctrl_end, Slot* slot)
+        : ctrl_(ctrl), ctrl_end_(ctrl_end), slot_(slot) {
+      FindNextNonFree();
+    }
+    ~Iterator() = default;
+    Iterator(const Iterator&) = default;
+    Iterator& operator=(const Iterator&) = default;
+    Iterator(Iterator&&) noexcept = default;
+    Iterator& operator=(Iterator&&) noexcept = default;
 
-  static constexpr TracingMuxerFake* Get() {
-#if PERFETTO_HAS_NO_DESTROY()
-    return &instance;
-#else
-    return nullptr;
-#endif
+    const Key& key() { return slot_->key; }
+    Value& value() { return slot_->value; }
+    const Key& key() const { return slot_->key; }
+    const Value& value() const { return slot_->value; }
+
+    explicit operator bool() const { return ctrl_ != ctrl_end_; }
+    Iterator& operator++() {
+      PERFETTO_DCHECK(ctrl_ != ctrl_end_);
+      ++ctrl_;
+      ++slot_;
+      FindNextNonFree();
+      return *this;
+    }
+
+   private:
+    void FindNextNonFree() {
+      for (; ctrl_ != ctrl_end_; ++ctrl_, ++slot_) {
+        const uint8_t cur_ctrl = *ctrl_;
+        if (cur_ctrl != kFreeSlot && cur_ctrl != kTombstone)
+          return;
+      }
+    }
+    const uint8_t* ctrl_ = nullptr;
+    const uint8_t* ctrl_end_ = nullptr;
+    Slot* slot_ = nullptr;
+  };  // Iterator
+
+  explicit FlatHashMapV2(size_t initial_capacity = 0,
+                         int load_limit_pct = kDefaultLoadLimitPct)
+      : load_limit_percent_(load_limit_pct) {
+    if (initial_capacity > 0) {
+      Reset(initial_capacity, true);
+    }
   }
 
-  // TracingMuxer implementation.
-  bool RegisterDataSource(const DataSourceDescriptor&,
-                          DataSourceFactory,
-                          DataSourceParams,
-                          DataSourceStaticState*) override;
-  void UpdateDataSourceDescriptor(const DataSourceDescriptor&,
-                                  const DataSourceStaticState*) override;
-  std::unique_ptr<TraceWriterBase> CreateTraceWriter(
-      DataSourceStaticState*,
-      uint32_t data_source_instance_index,
-      DataSourceState*,
-      BufferExhaustedPolicy buffer_exhausted_policy) override;
-  void DestroyStoppedTraceWritersForCurrentThread() override;
-  void RegisterInterceptor(const InterceptorDescriptor&,
-                           InterceptorFactory,
-                           InterceptorBase::TLSFactory,
-                           InterceptorBase::TracePacketCallback) override;
-  void ActivateTriggers(const std::vector<std::string>&, uint32_t) override;
+  // We are calling Clear() so that the destructors for the inserted entries are
+  // called (unless they are trivial, in which case it will be a no-op).
+  ~FlatHashMapV2() { Clear(); }
 
- private:
-  static TracingMuxerFake instance;
-};
+  FlatHashMapV2(FlatHashMapV2&& other) noexcept
+      : storage_(std::move(other.storage_)),
+        capacity_(other.capacity_),
+        size_(other.size_),
+        growth_info_(other.growth_info_),
+        load_limit_percent_(other.load_limit_percent_),
+        ctrl_(other.ctrl_),
+        slots_(other.slots_) {
+    new (&other) FlatHashMapV2();
+  }
 
-}  // namespace internal
-}  // namespace perfetto
+  FlatHashMapV2& operator=(FlatHashMapV2&& other) noexcept {
+    this->~FlatHashMapV2();
+    new (this) FlatHashMapV2(std::move(other));
+    return *this;
+  }
 
-#endif  // SRC_TRACING_INTERNAL_TRACING_MUXER_FAKE_H_
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+  FlatHashMapV2(const FlatHashMapV2&) = delete;
+  FlatHashMapV2& operator=(const FlatHashMapV2&) = delete;
 
-// gen_amalgamated expanded: #include "src/tracing/internal/tracing_muxer_fake.h"
+  template <typename K = Key>
+  PERFETTO_ALWAYS_INLINE Value* Find(const K& key) const {
+    size_t key_hash = Hasher{}(key);
+    uint8_t h2 = H2(key_hash);
+    FindResult res = FindSlotIgnoringTombstones<false>(key, key_hash, h2);
+    if (PERFETTO_UNLIKELY(res.needs_insert)) {
+      return nullptr;
+    }
+    return &slots_[res.idx].value;
+  }
 
-namespace perfetto {
-namespace internal {
-namespace {
+  template <typename K = Key>
+  bool Erase(const K& key) {
+    size_t key_hash = Hasher{}(key);
+    uint8_t h2 = H2(key_hash);
+    FindResult res = FindSlotIgnoringTombstones<false>(key, key_hash, h2);
+    if (PERFETTO_UNLIKELY(res.needs_insert)) {
+      return false;
+    }
+    PERFETTO_DCHECK(size_ > 0);
+    SetCtrl(res.idx, kTombstone);
+    slots_[res.idx].key.~Key();
+    slots_[res.idx].value.~Value();
+    size_--;
+    growth_info_.has_tombstones = 1;
+    return true;
+  }
 
-PERFETTO_NORETURN void FailUninitialized() {
-  PERFETTO_FATAL(
-      "Tracing not initialized. Call perfetto::Tracing::Initialize() first.");
-}
+  PERFETTO_ALWAYS_INLINE std::pair<Value*, bool> Insert(Key key, Value value) {
+    size_t key_hash = Hasher{}(key);
+    uint8_t h2 = H2(key_hash);
+    FindResult res = FindSlotIgnoringTombstones<true>(key, key_hash, h2);
+    if (PERFETTO_UNLIKELY(!res.needs_insert)) {
+      return {&slots_[res.idx].value, false};
+    }
+    if (PERFETTO_UNLIKELY(growth_info_.growth_left == 0)) {
+      GrowAndRehash();
+      // After rehash, table has no tombstones. Find an empty slot directly
+      // instead of recursing (which would prevent inlining).
+      res.idx = FindFirstEmptyOrTombstone(key_hash);
+    }
+    PERFETTO_DCHECK(res.idx != kNotFound);
+    size_t insert_idx = res.idx;
+    bool is_freeslot = true;
+    if (PERFETTO_UNLIKELY(growth_info_.has_tombstones)) {
+      insert_idx = FindFirstEmptyOrTombstone(key_hash);
+      is_freeslot = ctrl_[insert_idx] != kTombstone;
+    }
+    new (&slots_[insert_idx].key) Key(std::move(key));
+    new (&slots_[insert_idx].value) Value(std::move(value));
+    SetCtrl(insert_idx, h2);
+    size_++;
+    if (is_freeslot) {
+      growth_info_.growth_left--;
+    }
+    return {&slots_[insert_idx].value, true};
+  }
 
-}  // namespace
+  Value& operator[](Key key) {
+    auto it_and_inserted = Insert(std::move(key), Value{});
+    return *it_and_inserted.first;
+  }
 
-#if PERFETTO_HAS_NO_DESTROY()
-// static
-PERFETTO_NO_DESTROY TracingMuxerFake::FakePlatform
-    TracingMuxerFake::FakePlatform::instance{};
-// static
-PERFETTO_NO_DESTROY TracingMuxerFake TracingMuxerFake::instance{};
-#endif  // PERFETTO_HAS_NO_DESTROY()
+  void Clear() {
+    // Avoid trivial heap operations on zero-capacity std::move()-d objects.
+    if (PERFETTO_UNLIKELY(capacity_ == 0)) {
+      return;
+    }
+    for (size_t i = 0; i < capacity_; ++i) {
+      const uint8_t tag = ctrl_[i];
+      if (tag == kFreeSlot || tag == kTombstone) {
+        continue;
+      }
+      slots_[i].key.~Key();
+      slots_[i].value.~Value();
+    }
+    Reset(capacity_, false);
+  }
 
-TracingMuxerFake::~TracingMuxerFake() = default;
+  Iterator GetIterator() { return Iterator(ctrl_, ctrl_ + capacity_, slots_); }
+  Iterator GetIterator() const {
+    return Iterator(ctrl_, ctrl_ + capacity_, slots_);
+  }
 
-TracingMuxerFake::FakePlatform::~FakePlatform() = default;
+  size_t size() const { return size_; }
+  size_t capacity() const { return capacity_; }
 
-Platform::ThreadLocalObject*
-TracingMuxerFake::FakePlatform::GetOrCreateThreadLocalObject() {
-  FailUninitialized();
-}
+ private:
+  // Result struct for FindOrPrepareInsert - avoids bit manipulation overhead
+  struct FindResult {
+    uint64_t idx : 63;
+    uint64_t needs_insert : 1;
+  };
 
-std::unique_ptr<base::TaskRunner>
-TracingMuxerFake::FakePlatform::CreateTaskRunner(const CreateTaskRunnerArgs&) {
-  FailUninitialized();
-}
+  // Tracks growth capacity and whether any deletions have occurred.
+  // Using bitfields like absl's GrowthInfo to avoid manual bit manipulation.
+  struct GrowthInfo {
+    uint64_t growth_left : 63;
+    uint64_t has_tombstones : 1;
+  };
 
-std::string TracingMuxerFake::FakePlatform::GetCurrentProcessName() {
-  FailUninitialized();
-}
+  // Not found sentinel (must fit in 63-bit FindResult.idx)
+  static constexpr size_t kNotFound = std::numeric_limits<size_t>::max() >> 1;
 
-bool TracingMuxerFake::RegisterDataSource(const DataSourceDescriptor&,
-                                          DataSourceFactory,
-                                          DataSourceParams,
-                                          DataSourceStaticState*) {
-  FailUninitialized();
-}
+  // Abstraction over a group of control bytes that enables batch operations.
+  // On x64, uses SSE to match 16 control bytes in parallel.
+  // On other platforms, uses SWAR (SIMD Within A Register) for 8 bytes.
+  //
+  // Match() returns an iterator over slots whose control byte matches h2.
+  // MatchEmpty() returns an iterator over empty slots (kFreeSlot).
+  // MatchEmptyOrDeleted() returns an iterator over empty or deleted slots.
+#if PERFETTO_BUILDFLAG(PERFETTO_X64_CPU_OPT)
+  struct Group {
+   public:
+    // Group size 16 for x64 SSE
+    static constexpr size_t kSize = 16;
+
+    // Iterates over set bits in a match mask. Each set bit indicates a slot
+    // in the group that matched the search criteria. Call Next() to get the
+    // index of each matching slot.
+    struct Iterator {
+     public:
+      PERFETTO_ALWAYS_INLINE explicit Iterator(uint16_t mask) : mask_(mask) {}
+      PERFETTO_ALWAYS_INLINE explicit operator bool() const { return mask_; }
+
+      PERFETTO_ALWAYS_INLINE size_t Next() {
+        auto idx = static_cast<size_t>(CountTrailZeros(mask_));
+        mask_ &= static_cast<uint16_t>(mask_ - 1);
+        return idx;
+      }
 
-void TracingMuxerFake::UpdateDataSourceDescriptor(
-    const DataSourceDescriptor&,
-    const DataSourceStaticState*) {
-  FailUninitialized();
-}
+     private:
+      uint16_t mask_;
+    };
 
-std::unique_ptr<TraceWriterBase> TracingMuxerFake::CreateTraceWriter(
-    DataSourceStaticState*,
-    uint32_t,
-    DataSourceState*,
-    BufferExhaustedPolicy) {
-  FailUninitialized();
-}
+    PERFETTO_ALWAYS_INLINE explicit Group(const uint8_t* pos) {
+      ctrl_ = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pos));
+    }
 
-void TracingMuxerFake::DestroyStoppedTraceWritersForCurrentThread() {
-  FailUninitialized();
-}
+    PERFETTO_ALWAYS_INLINE Iterator Match(uint8_t h2) const {
+      auto match = _mm_cmpeq_epi8(ctrl_, _mm_set1_epi8(static_cast<char>(h2)));
+      return Iterator(static_cast<uint16_t>(_mm_movemask_epi8(match)));
+    }
 
-void TracingMuxerFake::RegisterInterceptor(
-    const InterceptorDescriptor&,
-    InterceptorFactory,
-    InterceptorBase::TLSFactory,
-    InterceptorBase::TracePacketCallback) {
-  FailUninitialized();
-}
+    PERFETTO_ALWAYS_INLINE Iterator MatchEmpty() const {
+      return Iterator(static_cast<uint16_t>(
+          _mm_movemask_epi8(_mm_sign_epi8(ctrl_, ctrl_))));
+    }
+
+    PERFETTO_ALWAYS_INLINE Iterator MatchEmptyOrDeleted() const {
+      return Iterator(static_cast<uint16_t>(_mm_movemask_epi8(ctrl_)));
+    }
 
-void TracingMuxerFake::ActivateTriggers(const std::vector<std::string>&,
-                                        uint32_t) {
-  FailUninitialized();
-}
+   private:
+    __m128i ctrl_;
+  };
+#else
+  // SWAR fallback: processes 8 control bytes at a time using 64-bit arithmetic.
+  struct Group {
+   public:
+    // Group size 8 for ARM and other platforms
+    static constexpr size_t kSize = 8;
+
+    // Iterates over set bits in a sparse 64-bit mask. Each set MSB indicates
+    // a matching byte in the group. Call Next() to get the index of each
+    // matching slot.
+    struct Iterator {
+     public:
+      PERFETTO_ALWAYS_INLINE explicit Iterator(uint64_t mask) : mask_(mask) {}
+      PERFETTO_ALWAYS_INLINE explicit operator bool() const { return mask_; }
+      PERFETTO_ALWAYS_INLINE size_t Next() {
+        // Count zeros and divide by 8 (shift 3)
+        // 0x80 (Byte 0) -> CTZ 7  -> 7>>3 = 0
+        // 0x8000 (Byte 1) -> CTZ 15 -> 15>>3 = 1
+        size_t idx = static_cast<size_t>(CountTrailZeros(mask_) >> 3);
+        mask_ &= mask_ - 1;  // Clear lowest set bit
+        return idx;
+      }
 
-}  // namespace internal
-}  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/internal/tracing_muxer_impl.cc
-// gen_amalgamated begin header: src/tracing/internal/tracing_muxer_impl.h
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+     private:
+      uint64_t mask_;
+    };
 
-#ifndef SRC_TRACING_INTERNAL_TRACING_MUXER_IMPL_H_
-#define SRC_TRACING_INTERNAL_TRACING_MUXER_IMPL_H_
+    PERFETTO_ALWAYS_INLINE explicit Group(const uint8_t* pos) {
+      memcpy(&ctrl_, pos, sizeof(ctrl_));
+    }
 
-#include <stddef.h>
-#include <stdint.h>
+    PERFETTO_ALWAYS_INLINE Iterator Match(uint8_t h2) const {
+      uint64_t x = ctrl_ ^ (kLsbs * h2);
+      return Iterator((x - kLsbs) & ~x & kMsbs);
+    }
 
-#include <array>
-#include <atomic>
-#include <bitset>
-#include <list>
-#include <map>
-#include <memory>
-#include <utility>
-#include <vector>
+    PERFETTO_ALWAYS_INLINE Iterator MatchEmpty() const {
+      // 0x80 check (Empty)
+      return Iterator((ctrl_ & ~(ctrl_ << 6)) & kMsbs);
+    }
 
-// gen_amalgamated expanded: #include "perfetto/base/time.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/thread_checker.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/consumer.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/producer.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/backend_type.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_descriptor.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/core/trace_config.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/basic_types.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_muxer.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/tracing.h"
+    PERFETTO_ALWAYS_INLINE Iterator MatchEmptyOrDeleted() const {
+      // 0x80 or 0xFE check (Empty or Deleted)
+      return Iterator((ctrl_ & ~(ctrl_ << 7)) & kMsbs);
+    }
 
-// gen_amalgamated expanded: #include "protos/perfetto/common/interceptor_descriptor.gen.h"
+   private:
+    static constexpr uint64_t kLsbs = 0x0101010101010101ULL;
+    static constexpr uint64_t kMsbs = 0x8080808080808080ULL;
 
-namespace perfetto {
+    uint64_t ctrl_;
+  };
+#endif
 
-class ConsumerEndpoint;
-class DataSourceBase;
-class ProducerEndpoint;
-class TraceWriterBase;
-class TracingBackend;
-class TracingSession;
-struct TracingInitArgs;
+  // The number of cloned control bytes after the main control byte array.
+  static constexpr size_t kNumClones = Group::kSize - 1;
 
-namespace base {
-class TaskRunner;
-}
+  // Searches for a key in the table. This function IGNORES tombstones during
+  // the search - it only stops at empty slots (kFreeSlot) or matching keys.
+  //
+  // Why ignore tombstones? In Swiss Tables, tombstones mark deleted entries but
+  // must be skipped during lookup because the key we're searching for may have
+  // been inserted AFTER the tombstone was created (i.e., the key's probe
+  // sequence may have skipped over that tombstone). Only an empty slot
+  // definitively proves the key doesn't exist.
+  //
+  // Returns FindResult with idx and whether the key needs to be inserted:
+  // - If key is found: {idx, false} where idx is the slot containing the key.
+  // - If key not found and ForInsert=true: {empty_idx, true} where empty_idx
+  //   is the index of the first EMPTY slot encountered.
+  // - If key not found and ForInsert=false: {kNotFound, true}.
+  //
+  // IMPORTANT for insertion (ForInsert=true): The returned empty_idx is NOT
+  // necessarily the best slot to insert into! There may be an earlier tombstone
+  // in the probe sequence that should be reused to avoid wasting slots. When
+  // has_tombstones is set, the caller must make a SECOND pass by calling
+  // FindFirstEmptyOrTombstone() to find the actual insertion slot.
+  template <bool ForInsert, typename K = Key>
+  PERFETTO_ALWAYS_INLINE FindResult
+  FindSlotIgnoringTombstones(const K& key, size_t key_hash, uint8_t h2) const {
+    static_assert(
+        flat_hash_map_v2_internal::IsLookupKeyAllowed<K, Key, Hasher>(),
+        "Heterogeneous lookup requires Hasher to define is_transparent and "
+        "support hashing the lookup key type. For same-type lookup, Key and K "
+        "must match exactly.");
 
-namespace test {
-class TracingMuxerImplInternalsForTest;
-}
+    if (PERFETTO_UNLIKELY(ctrl_ == nullptr)) {
+      return {kNotFound, true};
+    }
 
-namespace internal {
+    const size_t cap_mask = capacity_ - 1;
+    size_t offset = H1(key_hash) & cap_mask;
+    size_t probe_size = 0;
+    const uint8_t* ctrl = ctrl_;
 
-struct DataSourceStaticState;
+    // Prefetch control bytes (like Absl's prefetch_heap_block).
+    // Use locality hint 3 (high temporal locality) for better L1 cache usage.
+    __builtin_prefetch(ctrl_ + offset, 0, 3);
 
-// This class acts as a bridge between the public API and the TracingBackend(s).
-// It exposes a simplified view of the world to the API methods handling all the
-// bookkeeping to map data source instances and trace writers to the various
-// backends. It deals with N data sources, M backends (1 backend == 1 tracing
-// service == 1 producer connection) and T concurrent tracing sessions.
-//
-// Handing data source registration and start/stop flows [producer side]:
-// ----------------------------------------------------------------------
-// 1. The API client subclasses perfetto::DataSource and calls
-//    DataSource::Register<MyDataSource>(). In turn this calls into the
-//    TracingMuxer.
-// 2. The tracing muxer iterates through all the backends (1 backend == 1
-//    service == 1 producer connection) and registers the data source on each
-//    backend.
-// 3. When any (services behind a) backend starts tracing and requests to start
-//    that specific data source, the TracingMuxerImpl constructs a new instance
-//    of MyDataSource and calls the OnStart() method.
-//
-// Controlling trace and retrieving trace data [consumer side]:
-// ------------------------------------------------------------
-// 1. The API client calls Tracing::NewTrace(), returns a RAII TracingSession
-//    object.
-// 2. NewTrace() calls into internal::TracingMuxer(Impl). TracingMuxer
-//    subclasses the TracingSession object (TracingSessionImpl) and returns it.
-// 3. The tracing muxer identifies the backend (according to the args passed to
-//    NewTrace), creates a new Consumer and connects to it.
-// 4. When the API client calls Start()/Stop()/ReadTrace() methods, the
-//    TracingMuxer forwards them to the consumer associated to the
-//    TracingSession. Likewise for callbacks coming from the consumer-side of
-//    the service.
-class TracingMuxerImpl : public TracingMuxer {
- public:
-  // This is different than TracingSessionID because it's global across all
-  // backends. TracingSessionID is global only within the scope of one service.
-  using TracingSessionGlobalID = uint64_t;
+    while (true) {
+      // Prefetch slots at current probe offset (like Absl).
+      __builtin_prefetch(slots_ + offset, 0, 3);
 
-  struct RegisteredDataSource {
-    DataSourceDescriptor descriptor;
-    DataSourceFactory factory{};
-    bool supports_multiple_instances = false;
-    bool requires_callbacks_under_lock = false;
-    DataSourceStaticState* static_state = nullptr;
-  };
+      Group group(ctrl + offset);
 
-  static void InitializeInstance(const TracingInitArgs&);
-  static void ResetForTesting();
-  static void Shutdown();
+      // Match H2 tags in this group.
+      for (auto it = group.Match(h2); PERFETTO_LIKELY(it);) {
+        // Must mask because offset + it.Next() can exceed capacity when
+        // group straddles the table boundary (using cloned control bytes).
+        size_t idx = (offset + it.Next()) & cap_mask;
+        if (PERFETTO_LIKELY(Eq{}(slots_[idx].key, key))) {
+          return {idx, false};  // Found
+        }
+      }
 
-  // TracingMuxer implementation.
-  bool RegisterDataSource(const DataSourceDescriptor&,
-                          DataSourceFactory,
-                          DataSourceParams,
-                          DataSourceStaticState*) override;
-  void UpdateDataSourceDescriptor(const DataSourceDescriptor&,
-                                  const DataSourceStaticState*) override;
-  std::unique_ptr<TraceWriterBase> CreateTraceWriter(
-      DataSourceStaticState*,
-      uint32_t data_source_instance_index,
-      DataSourceState*,
-      BufferExhaustedPolicy buffer_exhausted_policy) override;
-  void DestroyStoppedTraceWritersForCurrentThread() override;
-  void RegisterInterceptor(const InterceptorDescriptor&,
-                           InterceptorFactory,
-                           InterceptorBase::TLSFactory,
-                           InterceptorBase::TracePacketCallback) override;
+      // Check for empty slot (NOT tombstones). If we find an empty slot, the
+      // key cannot exist in the table (empty slots terminate probe chains).
+      if (auto it = group.MatchEmpty(); PERFETTO_LIKELY(it)) {
+        if constexpr (ForInsert) {
+          size_t empty_idx = (offset + it.Next()) & cap_mask;
+          return {empty_idx, true};  // Not found - empty slot for insertion
+        } else {
+          return {kNotFound, true};  // Not found - no need to compute slot
+        }
+      }
 
-  void ActivateTriggers(const std::vector<std::string>&, uint32_t) override;
+      // Triangular probing (like Absl): 0, 16, 48, 96, ...
+      probe_size += Group::kSize;
+      offset = (offset + probe_size) & cap_mask;
 
-  std::unique_ptr<TracingSession> CreateTracingSession(
-      BackendType,
-      TracingConsumerBackend* (*system_backend_factory)());
-  std::unique_ptr<StartupTracingSession> CreateStartupTracingSession(
-      const TraceConfig& config,
-      Tracing::SetupStartupTracingOpts);
-  std::unique_ptr<StartupTracingSession> CreateStartupTracingSessionBlocking(
-      const TraceConfig& config,
-      Tracing::SetupStartupTracingOpts);
+      // Should never happen with load limit.
+      PERFETTO_DCHECK(probe_size <= capacity_);
+    }
+  }
 
-  // Producer-side bookkeeping methods.
-  void UpdateDataSourcesOnAllBackends();
-  void SetupDataSource(TracingBackendId,
-                       uint32_t backend_connection_id,
-                       DataSourceInstanceID,
-                       const DataSourceConfig&);
-  void StartDataSource(TracingBackendId, DataSourceInstanceID);
-  void StopDataSource_AsyncBegin(TracingBackendId, DataSourceInstanceID);
-  void ClearDataSourceIncrementalState(TracingBackendId, DataSourceInstanceID);
-  void SyncProducersForTesting();
+  // Find first empty OR tombstone slot for insertion.
+  // Called when has_tombstones is set to find an earlier tombstone that can
+  // be reused instead of taking a new empty slot.
+  size_t FindFirstEmptyOrTombstone(size_t key_hash) const {
+    const size_t cap_mask = capacity_ - 1;
+    size_t offset = H1(key_hash) & cap_mask;
+    size_t probe_size = 0;
+    while (true) {
+      Group group(ctrl_ + offset);
+      if (auto it = group.MatchEmptyOrDeleted(); PERFETTO_LIKELY(it)) {
+        return (offset + it.Next()) & cap_mask;
+      }
+      probe_size += Group::kSize;
+      offset = (offset + probe_size) & cap_mask;
+    }
+  }
 
-  // Consumer-side bookkeeping methods.
-  void SetupTracingSession(TracingSessionGlobalID,
-                           const std::shared_ptr<TraceConfig>&,
-                           base::ScopedFile trace_fd = base::ScopedFile());
-  void StartTracingSession(TracingSessionGlobalID);
-  void ChangeTracingSessionConfig(TracingSessionGlobalID, const TraceConfig&);
-  void StopTracingSession(TracingSessionGlobalID);
-  void DestroyTracingSession(TracingSessionGlobalID);
-  void FlushTracingSession(TracingSessionGlobalID,
-                           uint32_t,
-                           std::function<void(bool)>);
-  void ReadTracingSessionData(
-      TracingSessionGlobalID,
-      std::function<void(TracingSession::ReadTraceCallbackArgs)>);
-  void GetTraceStats(TracingSessionGlobalID,
-                     TracingSession::GetTraceStatsCallback);
-  void QueryServiceState(TracingSessionGlobalID,
-                         TracingSession::QueryServiceStateCallback);
+  PERFETTO_NO_INLINE void GrowAndRehash() {
+    // Grow factor must be a power of 2 because probing uses bitwise AND
+    // for modulo arithmetic (capacity must remain a power of 2).
+    static constexpr size_t kGrowFactor = 2;
+    static_assert((kGrowFactor & (kGrowFactor - 1)) == 0,
+                  "kGrowFactor must be a power of 2");
 
-  // Sets the batching period to |batch_commits_duration_ms| on the backends
-  // with type |backend_type|.
-  void SetBatchCommitsDurationForTesting(uint32_t batch_commits_duration_ms,
-                                         BackendType backend_type);
+    PERFETTO_DCHECK(size_ <= capacity_);
 
-  // Enables direct SMB patching on the backends with type |backend_type| (see
-  // SharedMemoryArbiter::EnableDirectSMBPatching). Returns true if the
-  // operation succeeded for all backends with type |backend_type|, false
-  // otherwise.
-  bool EnableDirectSMBPatchingForTesting(BackendType backend_type);
+    size_t old_capacity = capacity_;
+    size_t old_size = size_;
+    uint8_t* old_ctrl = ctrl_;
+    Slot* old_slots = slots_;
+    std::unique_ptr<uint8_t[]> old_storage(std::move(storage_));
 
-  void SetMaxProducerReconnectionsForTesting(uint32_t count);
+    // This must be a CHECK (i.e. not just a DCHECK) to prevent UAF attacks on
+    // 32-bit archs that try to double the size of the table until wrapping.
+    size_t new_capacity = old_capacity * kGrowFactor;
+    PERFETTO_CHECK(new_capacity >= old_capacity);
+    Reset(new_capacity, true);
 
- private:
-  friend class test::TracingMuxerImplInternalsForTest;
+    size_t new_size = 0;
+    for (size_t i = 0; i < old_capacity; ++i) {
+      if (uint8_t t = old_ctrl[i]; t == kFreeSlot || t == kTombstone) {
+        continue;
+      }
+      Insert(std::move(old_slots[i].key), std::move(old_slots[i].value));
+      old_slots[i].key.~Key();  // Destroy the old objects.
+      old_slots[i].value.~Value();
+      new_size++;
+    }
+    PERFETTO_DCHECK(new_size == old_size);
+    size_ = new_size;
+  }
 
-  // For each TracingBackend we create and register one ProducerImpl instance.
-  // This talks to the producer-side of the service, gets start/stop requests
-  // from it and routes them to the registered data sources.
-  // One ProducerImpl == one backend == one tracing service.
-  // This class is needed to disambiguate callbacks coming from different
-  // services. TracingMuxerImpl can't directly implement the Producer interface
-  // because the Producer virtual methods don't allow to identify the service.
-  class ProducerImpl : public Producer {
-   public:
-    ProducerImpl(TracingMuxerImpl*,
-                 TracingBackendId,
-                 uint32_t shmem_batch_commits_duration_ms);
-    ~ProducerImpl() override;
+  // Doesn't call destructors. Use Clear() for that.
+  PERFETTO_NO_INLINE void Reset(size_t n, bool reallocate) {
+    // Must be a pow2.
+    PERFETTO_CHECK((n & (n - 1)) == 0);
 
-    void Initialize(std::unique_ptr<ProducerEndpoint> endpoint);
-    void RegisterDataSource(const DataSourceDescriptor&,
-                            DataSourceFactory,
-                            DataSourceStaticState*);
-    void DisposeConnection();
+    // Always ensure at least 128 capacity to avoid too frequent growths.
+    capacity_ = std::max<size_t>(n, 128u);
+    size_ = 0;
+    growth_info_.growth_left =
+        (capacity_ * static_cast<size_t>(load_limit_percent_)) / 100;
+    growth_info_.has_tombstones = 0;
 
-    // perfetto::Producer implementation.
-    void OnConnect() override;
-    void OnDisconnect() override;
-    void OnTracingSetup() override;
-    void OnStartupTracingSetup() override;
-    void SetupDataSource(DataSourceInstanceID,
-                         const DataSourceConfig&) override;
-    void StartDataSource(DataSourceInstanceID,
-                         const DataSourceConfig&) override;
-    void StopDataSource(DataSourceInstanceID) override;
-    void Flush(FlushRequestID, const DataSourceInstanceID*, size_t) override;
-    void ClearIncrementalState(const DataSourceInstanceID*, size_t) override;
+    if (reallocate) {
+      // See memory layout comment above |storage_|.
+      size_t slots_offset =
+          base::AlignUp(capacity_ + kNumClones, alignof(Slot));
+      storage_.reset(new uint8_t[slots_offset + (capacity_ * sizeof(Slot))]);
+      ctrl_ = storage_.get();
+      slots_ = reinterpret_cast<Slot*>(storage_.get() + slots_offset);
+    }
+    if (ctrl_) {
+      // Initialize all control bytes (including clones) to empty (kFreeSlot)
+      memset(ctrl_, kFreeSlot, capacity_ + kNumClones);
+    }
+  }
 
-    bool SweepDeadServices();
-    void SendOnConnectTriggers();
+  // Swiss Table hash splitting (matching absl):
+  // H1 = upper bits for bucket index
+  // H2 = lower 7 bits for tag
+  // This ensures H1 and H2 are independent, avoiding tag collisions within
+  // buckets. The seed XOR prevents clustering when hash values have patterns
+  // (e.g., sequential keys)
+  static constexpr size_t H1(size_t hash) { return (hash >> 7); }
+  static constexpr uint8_t H2(size_t hash) { return hash & 0x7F; }
 
-    PERFETTO_THREAD_CHECKER(thread_checker_)
-    TracingMuxerImpl* muxer_;
-    TracingBackendId const backend_id_;
-    bool connected_ = false;
-    bool did_setup_tracing_ = false;
-    bool did_setup_startup_tracing_ = false;
-    std::atomic<uint32_t> connection_id_{0};
-    uint16_t last_startup_target_buffer_reservation_ = 0;
-    bool is_producer_provided_smb_ = false;
-    bool producer_provided_smb_failed_ = false;
+  // Set control byte and update clone if needed
+  PERFETTO_ALWAYS_INLINE void SetCtrl(size_t i, uint8_t h) {
+    ctrl_[i] = h;
+    // Update clone if this is one of the first kNumClones entries
+    if (PERFETTO_UNLIKELY(i < kNumClones)) {
+      ctrl_[capacity_ + i] = h;
+    }
+  }
 
-    const uint32_t shmem_batch_commits_duration_ms_ = 0;
+  // Owns the actual memory with the following layout:
+  //
+  // [Control bytes]
+  //   |capacity_| bytes for control bytes.
+  //   kNumClones (15 or 7) bytes for control byte clones (*).
+  //   No alignment required (accessed at arbitrary byte offsets).
+  //
+  // [Padding for Slot alignment]
+  //
+  // [Slots]
+  //   capacity_ * sizeof(Slot): contains key-value pairs.
+  //   Must be aligned to alignof(Slot).
+  //
+  // (*) Control byte clones: The first kNumClones control bytes are duplicated
+  // at the end of the control array. This allows SIMD operations to read a full
+  // group (16 or 8 bytes) starting from any position without bounds checking,
+  // even near the end of the array.
+  std::unique_ptr<uint8_t[]> storage_;
 
-    // Set of data sources that have been actually registered on this producer.
-    // This can be a subset of the global |data_sources_|, because data sources
-    // can register before the producer is fully connected.
-    std::bitset<kMaxDataSources> registered_data_sources_{};
+  size_t capacity_ = 0;
+  size_t size_ = 0;
 
-    // A collection of disconnected service endpoints. Since trace writers on
-    // arbitrary threads might continue writing data to disconnected services,
-    // we keep the old services around and periodically try to clean up ones
-    // that no longer have any writers (see SweepDeadServices).
-    std::list<std::shared_ptr<ProducerEndpoint>> dead_services_;
+  // Slots remaining + has_deleted flag
+  GrowthInfo growth_info_{0, 0};
 
-    // Triggers that should be sent when the service connects (trigger_name,
-    // expiration).
-    std::list<std::pair<std::string, base::TimeMillis>> on_connect_triggers_;
+  // Load factor limit in % of |capacity_|.
+  int load_limit_percent_ = kDefaultLoadLimitPct;
 
-    // The currently active service endpoint is maintained as an atomic shared
-    // pointer so it won't get deleted from underneath threads that are creating
-    // trace writers. At any given time one endpoint can be shared (and thus
-    // kept alive) by the |service_| pointer, an entry in |dead_services_| and
-    // as a pointer on the stack in CreateTraceWriter() (on an arbitrary
-    // thread). The endpoint is never shared outside ProducerImpl itself.
-    //
-    // WARNING: Any *write* access to this variable or any *read* access from a
-    // non-muxer thread must be done through std::atomic_{load,store} to avoid
-    // data races.
-    std::shared_ptr<ProducerEndpoint> service_;  // Keep last.
-  };
+  // Cached pointers for fast access (like absl::flat_hash_map)
+  // These are updated whenever storage is allocated/reallocated.
+  uint8_t* ctrl_ = nullptr;  // Points to control bytes
+  Slot* slots_ = nullptr;    // Points to slot array
+};
 
-  // For each TracingSession created by the API client (Tracing::NewTrace() we
-  // create and register one ConsumerImpl instance.
-  // This talks to the consumer-side of the service, gets end-of-trace and
-  // on-trace-data callbacks and routes them to the API client callbacks.
-  // This class is needed to disambiguate callbacks coming from different
-  // tracing sessions.
-  class ConsumerImpl : public Consumer {
-   public:
-    ConsumerImpl(TracingMuxerImpl*, BackendType, TracingSessionGlobalID);
-    ~ConsumerImpl() override;
+// Alias FlatHashMap to FlatHashMapV1 for backward compatibility.
+//
+// TODO(lalitm): Once FlatHashMapV2 is fully tested and verified, switch this
+// to FlatHashMapV2.
+template <typename Key,
+          typename Value,
+          typename Hasher = MurmurHash<Key>,
+          typename Probe = QuadraticProbe,
+          bool AppendOnly = false>
+using FlatHashMap = FlatHashMapV1<Key, Value, Hasher, Probe, AppendOnly>;
+
+}  // namespace perfetto::base
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_FLAT_HASH_MAP_H_
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-    void Initialize(std::unique_ptr<ConsumerEndpoint> endpoint);
+#ifndef SRC_PROTOVM_SLAB_ALLOCATOR_H_
+#define SRC_PROTOVM_SLAB_ALLOCATOR_H_
 
-    // perfetto::Consumer implementation.
-    void OnConnect() override;
-    void OnDisconnect() override;
-    void OnTracingDisabled(const std::string& error) override;
-    void OnTraceData(std::vector<TracePacket>, bool has_more) override;
-    void OnDetach(bool success) override;
-    void OnAttach(bool success, const TraceConfig&) override;
-    void OnTraceStats(bool success, const TraceStats&) override;
-    void OnObservableEvents(const ObservableEvents&) override;
-    void OnSessionCloned(bool, const std::string&) override;
+#include <cstdlib>
+#include <new>
 
-    void NotifyStartComplete();
-    void NotifyError(const TracingError&);
-    void NotifyStopComplete();
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/flat_hash_map.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/intrusive_list.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/paged_memory.h"
 
-    // Will eventually inform the |muxer_| when it is safe to remove |this|.
-    void Disconnect();
+// An efficient allocator for elements with fixed size and alignment
+// requirements.
+//
+// Design doc: go/perfetto-protovm-implementation
+//
+// Key features:
+//
+// - Slab allocation: Instead of requesting memory for each individual element,
+//   this allocator pre-allocates large memory chunks (slabs). Each slab is
+//   designed to hold multiple elements.
+//
+// - Element free list: A free list tracks available elements within each
+//   individual slab, allowing for O(1) access time during allocation.
+//
+// - Slab intrusive lists: Slabs are managed within one of two intrusive lists.
+//   The "non-full slabs" list and the "full slabs" list. This organization
+//   allows "non-full" slabs (those with available space for new allocations) to
+//   be accessed in O(1) time.
+//
+// - Block-to-Slab hash map: A hash map links 4KB-aligned memory blocks to their
+//   corresponding slab. This enables O(1) mapping of an element back to its
+//   slab during deallocation.
+//
+// Allocation process:
+// 1. If there is no free slab
+//    1.1 Allocate a new slab, add it to the “non-full slabs” list, populate the
+//        block-to-slab map
+// 2. Pick any slab from the “non-full slabs” list
+// 3. Allocate the element
+// 4. If needed, move the slab to the “full slabs” list
+//
+// Deallocation process:
+// 1. Find slab from the block-to-slab map
+// 2. Free element
+// 3. If needed, move to the “non-full slabs” list
+// 4. If needed, deallocate the slab.
 
-    TracingMuxerImpl* muxer_;
-    BackendType const backend_type_;
-    TracingSessionGlobalID const session_id_;
-    bool connected_ = false;
+namespace perfetto {
+namespace protovm {
 
-    // This is to handle the case where the Setup call from the API client
-    // arrives before the consumer has connected. In this case we keep around
-    // the config and check if we have it after connection.
-    bool start_pending_ = false;
+namespace internal {
+static constexpr size_t k4KiloBytes = static_cast<size_t>(4096);
+}
 
-    // Similarly if the session is stopped before the consumer was connected, we
-    // need to wait until the session has started before stopping it.
-    bool stop_pending_ = false;
+template <size_t ElementSize, size_t ElementAlign, size_t Blocks4KB>
+class Slab {
+ public:
+  struct IntrusiveListTraits {
+    static constexpr size_t node_offset() {
+      return offsetof(Slab, intrusive_list_node_);
+    }
+  };
 
-    // Similarly we need to buffer a call to get trace statistics if the
-    // consumer wasn't connected yet.
-    bool get_trace_stats_pending_ = false;
+  Slab() : paged_memory_(base::PagedMemory::Allocate(ElementSize * kCapacity)) {
+    PERFETTO_CHECK(paged_memory_.IsValid());
 
-    // Whether this session was already stopped. This will happen in response to
-    // Stop{,Blocking}, but also if the service stops the session for us
-    // automatically (e.g., when there are no data sources).
-    bool stopped_ = false;
+    // Expect allocated memory to be always 4KB-aligned
+    PERFETTO_CHECK(reinterpret_cast<uintptr_t>(paged_memory_.Get()) %
+                       internal::k4KiloBytes ==
+                   0);
 
-    // shared_ptr because it's posted across threads. This is to avoid copying
-    // it more than once.
-    std::shared_ptr<TraceConfig> trace_config_;
-    base::ScopedFile trace_fd_;
+    ConstructSlots();
+    InitializeSlotsFreeList();
+  }
 
-    // If the API client passes a callback to start, we should invoke this when
-    // NotifyStartComplete() is invoked.
-    std::function<void()> start_complete_callback_;
+  ~Slab() { DestroySlots(); }
 
-    // An internal callback used to implement StartBlocking().
-    std::function<void()> blocking_start_complete_callback_;
+  void* Allocate() {
+    PERFETTO_DCHECK(next_free_slot_);
+    auto* slot = next_free_slot_;
+    next_free_slot_ = next_free_slot_->next;
+    ++size_;
+    return slot;
+  }
 
-    // If the API client passes a callback to get notification about the
-    // errors, we should invoke this when NotifyError() is invoked.
-    std::function<void(TracingError)> error_callback_;
+  void Free(void* p) {
+    auto* slot = static_cast<Slot*>(p);
+    PERFETTO_DCHECK(slot >= slots() && slot < slots() + kCapacity);
+    slot->next = next_free_slot_;
+    next_free_slot_ = slot;
+    --size_;
+  }
 
-    // If the API client passes a callback to stop, we should invoke this when
-    // OnTracingDisabled() is invoked.
-    std::function<void()> stop_complete_callback_;
+  bool IsFull() const { return size_ == kCapacity; }
 
-    // An internal callback used to implement StopBlocking().
-    std::function<void()> blocking_stop_complete_callback_;
+  bool IsEmpty() const { return size_ == 0; }
 
-    // Callback passed to ReadTrace().
-    std::function<void(TracingSession::ReadTraceCallbackArgs)>
-        read_trace_callback_;
+  const void* GetBeginAddress() const {
+    return const_cast<Slab*>(this)->slots();
+  }
 
-    // Callback passed to GetTraceStats().
-    TracingSession::GetTraceStatsCallback get_trace_stats_callback_;
+  const void* GetEndAddress() const {
+    return const_cast<Slab*>(this)->slots() + kCapacity;
+  }
 
-    // Callback for a pending call to QueryServiceState().
-    TracingSession::QueryServiceStateCallback query_service_state_callback_;
+ private:
+  static constexpr size_t kCapacity =
+      Blocks4KB * (internal::k4KiloBytes / ElementSize);
 
-    // The states of all data sources in this tracing session. |true| means the
-    // data source has started tracing.
-    using DataSourceHandle = std::pair<std::string, std::string>;
-    std::map<DataSourceHandle, bool> data_source_states_;
+  static_assert(kCapacity >= 128,
+                "The configured number of 4KB blocks per slab seems too small, "
+                "resulting in a low slab capacity. Slab allocation is "
+                "expensive (involves syscalls), so a high elements-to-slab "
+                "ratio is desirable to amortize the cost.");
 
-    std::unique_ptr<ConsumerEndpoint> service_;  // Keep before last.
-    PERFETTO_THREAD_CHECKER(thread_checker_)     // Keep last.
+  static_assert(ElementAlign <= internal::k4KiloBytes,
+                "SlabAllocator currently supports alignment <= 4KB");
+
+  union Slot {
+    Slot* next;
+    alignas(ElementAlign) unsigned char element[ElementSize];
   };
 
-  // This object is returned to API clients when they call
-  // Tracing::CreateTracingSession().
-  class TracingSessionImpl : public TracingSession {
-   public:
-    TracingSessionImpl(TracingMuxerImpl*, TracingSessionGlobalID, BackendType);
-    ~TracingSessionImpl() override;
-    void Setup(const TraceConfig&, int fd) override;
-    void Start() override;
-    void StartBlocking() override;
-    void SetOnStartCallback(std::function<void()>) override;
-    void SetOnErrorCallback(std::function<void(TracingError)>) override;
-    void Stop() override;
-    void StopBlocking() override;
-    void Flush(std::function<void(bool)>, uint32_t timeout_ms) override;
-    void ReadTrace(ReadTraceCallback) override;
-    void SetOnStopCallback(std::function<void()>) override;
-    void GetTraceStats(GetTraceStatsCallback) override;
-    void QueryServiceState(QueryServiceStateCallback) override;
-    void ChangeTraceConfig(const TraceConfig&) override;
+  void InitializeSlotsFreeList() {
+    next_free_slot_ = &slots()[0];
 
-   private:
-    TracingMuxerImpl* const muxer_;
-    TracingSessionGlobalID const session_id_;
-    BackendType const backend_type_;
-  };
+    for (size_t i = 0; i + 1 < kCapacity; ++i) {
+      auto& slot = slots()[i];
+      auto& next_slot = slots()[i + 1];
+      slot.next = &next_slot;
+    }
 
-  // This object is returned to API clients when they call
-  // Tracing::SetupStartupTracing().
-  class StartupTracingSessionImpl : public StartupTracingSession {
-   public:
-    StartupTracingSessionImpl(TracingMuxerImpl*,
-                              TracingSessionGlobalID,
-                              BackendType);
-    ~StartupTracingSessionImpl() override;
-    void Abort() override;
-    void AbortBlocking() override;
+    auto& last_slot = slots()[kCapacity - 1];
+    last_slot.next = nullptr;
+  }
 
-   private:
-    TracingMuxerImpl* const muxer_;
-    TracingSessionGlobalID const session_id_;
-    BackendType backend_type_;
-  };
+  void ConstructSlots() {
+    auto* slot = slots();
+    for (size_t i = 0; i < kCapacity; ++i) {
+      new (&slot[i]) Slot();
+    }
+  }
 
-  struct RegisteredInterceptor {
-    protos::gen::InterceptorDescriptor descriptor;
-    InterceptorFactory factory{};
-    InterceptorBase::TLSFactory tls_factory{};
-    InterceptorBase::TracePacketCallback packet_callback{};
-  };
+  void DestroySlots() {
+    auto* slot = slots();
+    for (size_t i = 0; i < kCapacity; ++i) {
+      slot[i].~Slot();
+    }
+  }
 
-  struct RegisteredStartupSession {
-    TracingSessionID session_id = 0;
-    int num_unbound_data_sources = 0;
+  Slot* slots() {
+    return std::launder(reinterpret_cast<Slot*>(paged_memory_.Get()));
+  }
 
-    bool is_aborting = false;
-    int num_aborting_data_sources = 0;
+  Slot* next_free_slot_{nullptr};
+  size_t size_{0};
+  base::IntrusiveListNode intrusive_list_node_;
+  base::PagedMemory paged_memory_;
+};
 
-    std::function<void()> on_aborted;
-    std::function<void()> on_adopted;
-  };
+template <size_t ElementSize, size_t ElementAlign, size_t Blocks4KBPerSlab = 16>
+class SlabAllocator {
+ public:
+  ~SlabAllocator() {
+    DeleteSlabs(slabs_non_full_);
+    DeleteSlabs(slabs_full_);
+  }
 
-  struct RegisteredProducerBackend {
-    // Backends are supposed to have static lifetime.
-    TracingProducerBackend* backend = nullptr;
-    TracingBackendId id = 0;
-    BackendType type{};
+  void* Allocate() {
+    // Create new slab if needed
+    if (slabs_non_full_.empty()) {
+      auto* slab = new SlabType();
+      slabs_non_full_.PushFront(*slab);
+      ++slabs_non_full_size_;
+      InsertHashMapEntries(*slab);
+    }
 
-    TracingBackend::ConnectProducerArgs producer_conn_args;
-    std::unique_ptr<ProducerImpl> producer;
+    // Allocate using any non-full slab
+    auto& slab = slabs_non_full_.front();
+    auto* allocated = slab.Allocate();
+    PERFETTO_CHECK(allocated);
 
-    std::vector<RegisteredStartupSession> startup_sessions;
-  };
+    // Move to "full slabs" list if needed
+    if (slab.IsFull()) {
+      slabs_non_full_.Erase(slab);
+      --slabs_non_full_size_;
+      slabs_full_.PushFront(slab);
+    }
 
-  struct RegisteredConsumerBackend {
-    // Backends are supposed to have static lifetime.
-    TracingConsumerBackend* backend = nullptr;
-    BackendType type{};
-    // The calling code can request more than one concurrently active tracing
-    // session for the same backend. We need to create one consumer per session.
-    std::vector<std::unique_ptr<ConsumerImpl>> consumers;
-  };
+    return allocated;
+  }
 
-  void UpdateDataSourceOnAllBackends(RegisteredDataSource& rds,
-                                     bool is_changed);
-  explicit TracingMuxerImpl(const TracingInitArgs&);
-  void Initialize(const TracingInitArgs& args);
-  void AddBackends(const TracingInitArgs& args);
-  void AddConsumerBackend(TracingConsumerBackend* backend, BackendType type);
-  void AddProducerBackend(TracingProducerBackend* backend,
-                          BackendType type,
-                          const TracingInitArgs& args);
-  ConsumerImpl* FindConsumer(TracingSessionGlobalID session_id);
-  std::pair<ConsumerImpl*, RegisteredConsumerBackend*> FindConsumerAndBackend(
-      TracingSessionGlobalID session_id);
-  RegisteredProducerBackend* FindProducerBackendById(TracingBackendId id);
-  RegisteredProducerBackend* FindProducerBackendByType(BackendType type);
-  RegisteredConsumerBackend* FindConsumerBackendByType(BackendType type);
-  void InitializeConsumer(TracingSessionGlobalID session_id);
-  void OnConsumerDisconnected(ConsumerImpl* consumer);
-  void OnProducerDisconnected(ProducerImpl* producer);
-  // Test only method.
-  void SweepDeadBackends();
+  void Free(void* p) {
+    auto& slab = FindSlabInHashMap(p);
 
-  struct FindDataSourceRes {
-    FindDataSourceRes() = default;
-    FindDataSourceRes(DataSourceStaticState* a,
-                      DataSourceState* b,
-                      uint32_t c,
-                      bool d)
-        : static_state(a),
-          internal_state(b),
-          instance_idx(c),
-          requires_callbacks_under_lock(d) {}
-    explicit operator bool() const { return !!internal_state; }
+    // Move to "non-full slabs" list if needed
+    if (slab.IsFull()) {
+      slabs_full_.Erase(slab);
+      slabs_non_full_.PushFront(slab);
+      ++slabs_non_full_size_;
+    }
 
-    DataSourceStaticState* static_state = nullptr;
-    DataSourceState* internal_state = nullptr;
-    uint32_t instance_idx = 0;
-    bool requires_callbacks_under_lock = false;
-  };
-  FindDataSourceRes FindDataSource(TracingBackendId, DataSourceInstanceID);
+    slab.Free(p);
 
-  FindDataSourceRes SetupDataSourceImpl(
-      const RegisteredDataSource&,
-      TracingBackendId,
-      uint32_t backend_connection_id,
-      DataSourceInstanceID,
-      const DataSourceConfig&,
-      uint64_t config_hash,
-      uint64_t startup_config_hash,
-      TracingSessionGlobalID startup_session_id);
-  void StartDataSourceImpl(const FindDataSourceRes&);
-  void StopDataSource_AsyncBeginImpl(const FindDataSourceRes&);
-  void StopDataSource_AsyncEnd(TracingBackendId,
-                               uint32_t backend_connection_id,
-                               DataSourceInstanceID,
-                               const FindDataSourceRes&);
-  void AbortStartupTracingSession(TracingSessionGlobalID, BackendType);
+    // Deallocate the slab if it becomes empty and it's not the sole non-full
+    // slab.
+    //
+    // The "is not the sole non-full slab" condition avoids thrashing scenarios
+    // where a slab is repeatedly allocated and deallocated. For example:
+    // 1. Allocate element x -> a new slab is allocated.
+    // 2. Free element x -> slab becomes empty and is deallocated.
+    // 3. Allocate element y -> a new slab is allocated again.
+    // 4. And so on...
+    if (slab.IsEmpty() && slabs_non_full_size_ > 1) {
+      EraseHashMapEntries(slab);
+      slabs_non_full_.Erase(slab);
+      --slabs_non_full_size_;
+      delete &slab;
+    }
+  }
 
-  // WARNING: If you add new state here, be sure to update ResetForTesting.
-  std::unique_ptr<base::TaskRunner> task_runner_;
-  std::vector<RegisteredDataSource> data_sources_;
-  // These lists can only have one backend per BackendType. The elements are
-  // sorted by BackendType priority (see BackendTypePriority). They always
-  // contain a fake low-priority kUnspecifiedBackend at the end.
-  std::list<RegisteredProducerBackend> producer_backends_;
-  std::list<RegisteredConsumerBackend> consumer_backends_;
-  std::vector<RegisteredInterceptor> interceptors_;
-  TracingPolicy* policy_ = nullptr;
+ private:
+  using SlabType = Slab<ElementSize, ElementAlign, Blocks4KBPerSlab>;
+  using SlabList =
+      base::IntrusiveList<SlabType, typename SlabType::IntrusiveListTraits>;
 
-  // Learn more at TracingInitArgs::supports_multiple_data_source_instances
-  bool supports_multiple_data_source_instances_ = true;
+  void InsertHashMapEntries(SlabType& slab) {
+    for (auto p = reinterpret_cast<uintptr_t>(slab.GetBeginAddress());
+         p < reinterpret_cast<uintptr_t>(slab.GetEndAddress());
+         p += internal::k4KiloBytes) {
+      PERFETTO_DCHECK(p % internal::k4KiloBytes == 0);
+      block_4KB_aligned_to_slab_.Insert(p, &slab);
+    }
+  }
 
-  std::atomic<TracingSessionGlobalID> next_tracing_session_id_{};
-  std::atomic<uint32_t> next_data_source_index_{};
-  uint32_t muxer_id_for_testing_{};
+  void EraseHashMapEntries(const SlabType& slab) {
+    for (auto p = reinterpret_cast<uintptr_t>(slab.GetBeginAddress());
+         p < reinterpret_cast<uintptr_t>(slab.GetEndAddress());
+         p += internal::k4KiloBytes) {
+      PERFETTO_DCHECK(p % internal::k4KiloBytes == 0);
+      block_4KB_aligned_to_slab_.Erase(p);
+    }
+  }
 
-  // Maximum number of times we will try to reconnect producer backend.
-  // Should only be modified for testing purposes.
-  std::atomic<uint32_t> max_producer_reconnections_{100u};
+  SlabType& FindSlabInHashMap(const void* ptr) {
+    auto ptr_4KB_aligned = reinterpret_cast<uintptr_t>(ptr) &
+                           ~(static_cast<uintptr_t>(internal::k4KiloBytes) - 1);
+    SlabType** slab = block_4KB_aligned_to_slab_.Find(ptr_4KB_aligned);
+    PERFETTO_CHECK(slab);
+    PERFETTO_CHECK(*slab);
+    return **slab;
+  }
 
-  // Test only member.
-  // After ResetForTesting() is called, holds tracing backends which needs to be
-  // kept alive until all inbound references have gone away. See
-  // SweepDeadBackends().
-  std::list<RegisteredProducerBackend> dead_backends_;
+  void DeleteSlabs(SlabList& slabs) {
+    while (!slabs.empty()) {
+      auto& slab = slabs.front();
+      slabs.PopFront();
+      delete &slab;
+    }
+  }
 
-  PERFETTO_THREAD_CHECKER(thread_checker_)
+  base::FlatHashMap<uintptr_t, SlabType*> block_4KB_aligned_to_slab_;
+  SlabList slabs_full_;
+  SlabList slabs_non_full_;
+  size_t slabs_non_full_size_{0};
 };
 
-}  // namespace internal
+}  // namespace protovm
 }  // namespace perfetto
 
-#endif  // SRC_TRACING_INTERNAL_TRACING_MUXER_IMPL_H_
-// gen_amalgamated begin header: include/perfetto/ext/tracing/core/trace_stats.h
+#endif  // SRC_PROTOVM_SLAB_ALLOCATOR_H_
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2025 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -45660,21 +51905,87 @@ class TracingMuxerImpl : public TracingMuxer {
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACE_STATS_H_
-#define INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACE_STATS_H_
+#ifndef SRC_PROTOVM_ALLOCATOR_H_
+#define SRC_PROTOVM_ALLOCATOR_H_
 
-// Creates the aliases in the ::perfetto namespace, doing things like:
-// using ::perfetto::Foo = ::perfetto::protos::gen::Foo.
-// See comments in forward_decls.h for the historical reasons of this
-// indirection layer.
-// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
+#include <cstdlib>
 
-// gen_amalgamated expanded: #include "protos/perfetto/common/trace_stats.gen.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/field.h"
 
-#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_TRACE_STATS_H_
-// gen_amalgamated begin header: include/perfetto/tracing/core/tracing_service_state.h
+// gen_amalgamated expanded: #include "src/protovm/error_handling.h"
+// gen_amalgamated expanded: #include "src/protovm/node.h"
+// gen_amalgamated expanded: #include "src/protovm/slab_allocator.h"
+
+namespace perfetto {
+namespace protovm {
+
+// A centralized allocator to manage all the memory requests from RwProto. It
+// enforces a strict memory usage limit, thus allowing fine-grained control of
+// the overall proto VM's memory footprint.
+class Allocator {
+ public:
+  explicit Allocator(size_t memory_limit_bytes);
+  StatusOr<Node::Bytes> AllocateAndCopyBytes(protozero::ConstBytes data);
+
+  // Deeply delete a node and all the referenced data. E.g. if the node holds a
+  // Node::Message, recursively delete the message fields and finally delete the
+  // node.
+  void Delete(Node* node);
+
+  // Deeply delete a node's referenced data, but do not delete the node itself.
+  // E.g. if the node holds a Node::Message, recursively delete the message
+  // fields.
+  void DeleteReferencedData(Node* node);
+
+  // Recursively delete a message's fields, but do not delete the message
+  // itself.
+  void DeleteReferencedData(Node::Message* message);
+
+  // Delete the blob referenced by the Bytes struct, but do not delete the Bytes
+  // struct itself.
+  void DeleteReferencedData(Node::Bytes* bytes);
+
+  template <class T, class... Args>
+  StatusOr<OwnedPtr<Node>> CreateNode(Args&&... args) {
+    if (used_memory_bytes_ + sizeof(Node) > memory_limit_bytes_) {
+      PROTOVM_ABORT(
+          "Failed to allocate node (%zu bytes). Memory limit: %zu [bytes]. "
+          "Used: %zu "
+          "[bytes].)",
+          sizeof(Node), memory_limit_bytes_, used_memory_bytes_);
+    }
+
+    auto* p = slab_allocator_.Allocate();
+    if (!p) {
+      PROTOVM_ABORT("Failed to allocate node");
+    }
+
+    used_memory_bytes_ += sizeof(Node);
+
+    // 1. Construct node's inner value T passing args (struct aggregate
+    // initialization)
+    // 2. Construct node passing T (struct aggregate initialization)
+    new (p) Node{T{std::forward<Args>(args)...}};
+
+    return OwnedPtr<Node>(static_cast<Node*>(p));
+  }
+
+  size_t GetMemoryUsageBytes() const { return used_memory_bytes_; }
+
+ private:
+  void DeallocateBytes(OwnedPtr<void> p, size_t size);
+
+  size_t memory_limit_bytes_{0};
+  size_t used_memory_bytes_{0};
+  SlabAllocator<sizeof(Node), alignof(Node)> slab_allocator_;
+};
+
+}  // namespace protovm
+}  // namespace perfetto
+
+#endif  // SRC_PROTOVM_ALLOCATOR_H_
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2025 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -45689,21 +52000,88 @@ class TracingMuxerImpl : public TracingMuxer {
  * limitations under the License.
  */
 
+// gen_amalgamated expanded: #include "src/protovm/allocator.h"
 
-#ifndef INCLUDE_PERFETTO_TRACING_CORE_TRACING_SERVICE_STATE_H_
-#define INCLUDE_PERFETTO_TRACING_CORE_TRACING_SERVICE_STATE_H_
+namespace perfetto {
+namespace protovm {
 
-// Creates the aliases in the ::perfetto namespace, doing things like:
-// using ::perfetto::Foo = ::perfetto::protos::gen::Foo.
-// See comments in forward_decls.h for the historical reasons of this
-// indirection layer.
-// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
+Allocator::Allocator(size_t memory_limit_bytes)
+    : memory_limit_bytes_{memory_limit_bytes}, used_memory_bytes_{0} {}
 
-// gen_amalgamated expanded: #include "protos/perfetto/common/tracing_service_state.gen.h"
+StatusOr<Node::Bytes> Allocator::AllocateAndCopyBytes(
+    protozero::ConstBytes data) {
+  if (used_memory_bytes_ + data.size > memory_limit_bytes_) {
+    PROTOVM_ABORT(
+        "Failed to allocate %zu bytes. Memory limit: %zu bytes. Used: %zu "
+        "bytes.)",
+        data.size, memory_limit_bytes_, used_memory_bytes_);
+  }
 
-#endif  // INCLUDE_PERFETTO_TRACING_CORE_TRACING_SERVICE_STATE_H_
+  if (data.size == 0) {
+    return Node::Bytes{nullptr, 0};
+  }
+
+  auto copy = OwnedPtr<void>{malloc(data.size)};
+  if (!copy) {
+    PROTOVM_ABORT("Failed to malloc %zu bytes", data.size);
+  }
+  used_memory_bytes_ += data.size;
+  memcpy(copy.get(), data.data, data.size);
+
+  return Node::Bytes{std::move(copy), data.size};
+}
+
+void Allocator::Delete(Node* node) {
+  DeleteReferencedData(node);
+  node->~Node();
+  slab_allocator_.Free(node);
+  used_memory_bytes_ -= sizeof(Node);
+}
+
+void Allocator::DeleteReferencedData(Node* node) {
+  if (auto* message = node->GetIf<Node::Message>()) {
+    DeleteReferencedData(message);
+  } else if (auto* indexed_fields = node->GetIf<Node::IndexedRepeatedField>()) {
+    for (auto it = indexed_fields->index_to_node.begin(); it;) {
+      auto& map_node = *it;
+      it = indexed_fields->index_to_node.Remove(it);
+      Delete(&GetOuterNode(map_node));
+    }
+  } else if (auto* mapped_fields = node->GetIf<Node::MappedRepeatedField>()) {
+    for (auto it = mapped_fields->key_to_node.begin(); it;) {
+      auto& map_node = *it;
+      it = mapped_fields->key_to_node.Remove(it);
+      Delete(&GetOuterNode(map_node));
+    }
+  } else if (auto* map_node = node->GetIf<Node::MapNode>()) {
+    Delete(map_node->value.release());
+  } else if (auto* bytes = node->GetIf<Node::Bytes>()) {
+    DeleteReferencedData(bytes);
+  }
+}
+
+void Allocator::DeleteReferencedData(Node::Message* message) {
+  for (auto it = message->field_id_to_node.begin(); it;) {
+    auto& map_node = *it;
+    it = message->field_id_to_node.Remove(it);
+    Delete(&GetOuterNode(map_node));
+  }
+}
+
+void Allocator::DeleteReferencedData(Node::Bytes* bytes) {
+  DeallocateBytes(std::move(bytes->data), bytes->size);
+}
+
+void Allocator::DeallocateBytes(OwnedPtr<void> p, size_t size) {
+  free(p.release());
+  used_memory_bytes_ -= size;
+}
+
+}  // namespace protovm
+}  // namespace perfetto
+// gen_amalgamated begin source: src/protovm/error_handling.cc
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2025 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -45718,3052 +52096,3421 @@ class TracingMuxerImpl : public TracingMuxer {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "src/tracing/internal/tracing_muxer_impl.h"
+// gen_amalgamated expanded: #include "src/protovm/error_handling.h"
 
-#include <algorithm>
-#include <atomic>
-#include <mutex>
-#include <vector>
+namespace perfetto {
+namespace protovm {
 
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
-// gen_amalgamated expanded: #include "perfetto/base/time.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/hash.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/thread_checker.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/waitable_event.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_arbiter.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_packet.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_stats.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_writer.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/buffer_exhausted_policy.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_config.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/core/tracing_service_state.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/data_source.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/data_source_internal.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/interceptor_trace_writer.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_backend_fake.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/trace_writer_base.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/tracing.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/tracing_backend.h"
-// gen_amalgamated expanded: #include "src/tracing/core/null_trace_writer.h"
-// gen_amalgamated expanded: #include "src/tracing/internal/tracing_muxer_fake.h"
+void LogStacktraceMessage(Stacktrace& stacktrace,
+                          const char* file_name,
+                          int file_line,
+                          const char* fmt,
+                          ...) {
+  const char* const fmt_file_info = "%s:%d ";
+  auto size_file_info =
+      std::snprintf(nullptr, 0, fmt_file_info, file_name, file_line);
 
-// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/chrome_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/interceptor_config.gen.h"
+  va_list args;
+  va_start(args, fmt);
+  auto size_message = std::vsnprintf(nullptr, 0, fmt, args);
+  va_end(args);
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-#include <io.h>  // For dup()
-#else
-#include <unistd.h>  // For dup()
-#endif
+  auto s = std::string(
+      static_cast<std::size_t>(size_file_info + size_message + 1), '.');
 
-namespace perfetto {
-namespace internal {
+  std::snprintf(s.data(), static_cast<size_t>(size_file_info) + 1,
+                fmt_file_info, file_name, file_line);
 
-namespace {
+  va_start(args, fmt);
+  std::vsnprintf(s.data() + size_file_info,
+                 static_cast<size_t>(size_message) + 1, fmt, args);
+  va_end(args);
 
-using RegisteredDataSource = TracingMuxerImpl::RegisteredDataSource;
+  s.pop_back();  // null-terminating char
 
-// A task runner which prevents calls to DataSource::Trace() while an operation
-// is in progress. Used to guard against unexpected re-entrancy where the
-// user-provided task runner implementation tries to enter a trace point under
-// the hood.
-class NonReentrantTaskRunner : public base::TaskRunner {
- public:
-  NonReentrantTaskRunner(TracingMuxer* muxer,
-                         std::unique_ptr<base::TaskRunner> task_runner)
-      : muxer_(muxer), task_runner_(std::move(task_runner)) {}
+  stacktrace.push_back(std::move(s));
+}
 
-  // base::TaskRunner implementation.
-  void PostTask(std::function<void()> task) override {
-    CallWithGuard([&] { task_runner_->PostTask(std::move(task)); });
-  }
+void LogStacktraceMessage(Stacktrace& stacktrace,
+                          const char* file_name,
+                          int file_line) {
+  const char* const fmt = "%s:%d <no message>";
+  auto size_message = std::snprintf(nullptr, 0, fmt, file_name, file_line);
+  auto s = std::string(static_cast<size_t>(size_message) + 1, '.');
+  std::snprintf(s.data(), static_cast<size_t>(size_message) + 1, fmt, file_name,
+                file_line);
 
-  void PostDelayedTask(std::function<void()> task, uint32_t delay_ms) override {
-    CallWithGuard(
-        [&] { task_runner_->PostDelayedTask(std::move(task), delay_ms); });
-  }
+  s.pop_back();  // null-terminating char
 
-  void AddFileDescriptorWatch(base::PlatformHandle fd,
-                              std::function<void()> callback) override {
-    CallWithGuard(
-        [&] { task_runner_->AddFileDescriptorWatch(fd, std::move(callback)); });
-  }
+  stacktrace.push_back(std::move(s));
+}
 
-  void RemoveFileDescriptorWatch(base::PlatformHandle fd) override {
-    CallWithGuard([&] { task_runner_->RemoveFileDescriptorWatch(fd); });
-  }
+}  // namespace protovm
+}  // namespace perfetto
+// gen_amalgamated begin source: src/protovm/executor.cc
+// gen_amalgamated begin header: src/protovm/executor.h
+// gen_amalgamated begin header: src/protovm/ro_cursor.h
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-  bool RunsTasksOnCurrentThread() const override {
-    bool result;
-    CallWithGuard([&] { result = task_runner_->RunsTasksOnCurrentThread(); });
-    return result;
-  }
+#ifndef SRC_PROTOVM_RO_CURSOR_H_
+#define SRC_PROTOVM_RO_CURSOR_H_
 
- private:
-  template <typename T>
-  void CallWithGuard(T lambda) const {
-    auto* root_tls = muxer_->GetOrCreateTracingTLS();
-    if (PERFETTO_UNLIKELY(root_tls->is_in_trace_point)) {
-      lambda();
-      return;
-    }
-    ScopedReentrancyAnnotator scoped_annotator(*root_tls);
-    lambda();
-  }
+#include <cstdint>
+#include <variant>
 
-  TracingMuxer* const muxer_;
-  std::unique_ptr<base::TaskRunner> task_runner_;
-};
+// gen_amalgamated expanded: #include "perfetto/protozero/field.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 
-class StopArgsImpl : public DataSourceBase::StopArgs {
+// gen_amalgamated expanded: #include "src/protovm/error_handling.h"
+// gen_amalgamated expanded: #include "src/protovm/scalar.h"
+
+namespace perfetto {
+namespace protovm {
+
+class RoCursor {
  public:
-  std::function<void()> HandleStopAsynchronously() const override {
-    auto closure = std::move(async_stop_closure);
-    async_stop_closure = std::function<void()>();
-    return closure;
-  }
+  class RepeatedFieldIterator {
+   public:
+    RepeatedFieldIterator();
+    explicit RepeatedFieldIterator(protozero::ProtoDecoder decoder,
+                                   uint32_t field_id);
+    RepeatedFieldIterator& operator++();
+    RoCursor operator*();
+    explicit operator bool() const;
 
-  mutable std::function<void()> async_stop_closure;
-};
+   private:
+    protozero::Field Advance();
 
-uint64_t ComputeConfigHash(const DataSourceConfig& config) {
-  base::Hasher hasher;
-  std::string config_bytes = config.SerializeAsString();
-  hasher.Update(config_bytes.data(), config_bytes.size());
-  return hasher.digest();
-}
+    protozero::ProtoDecoder decoder_;
+    uint32_t field_id_;
+    protozero::Field field_;
+  };
 
-// Holds an earlier TracingMuxerImpl instance after ResetForTesting() is called.
-static TracingMuxerImpl* g_prev_instance{};
+  RoCursor();
+  explicit RoCursor(protozero::ConstBytes data);
+  explicit RoCursor(protozero::Field data);
+  StatusOr<void> EnterField(uint32_t field_id);
+  StatusOr<void> EnterRepeatedFieldAt(uint32_t field_id, uint32_t index);
+  StatusOr<RepeatedFieldIterator> IterateRepeatedField(uint32_t field_id) const;
+  bool IsScalar() const;
+  bool IsBytes() const;
+  StatusOr<Scalar> GetScalar() const;
+  StatusOr<protozero::ConstBytes> GetBytes() const;
 
-uint64_t ComputeStartupConfigHash(DataSourceConfig config) {
-  // Clear target buffer and tracing-service provided fields for comparison of
-  // configs for startup tracing, since these fields are not available when
-  // setting up data sources for startup tracing.
-  config.set_target_buffer(0);
-  config.set_tracing_session_id(0);
-  config.set_session_initiator(DataSourceConfig::SESSION_INITIATOR_UNSPECIFIED);
-  config.set_trace_duration_ms(0);
-  config.set_stop_timeout_ms(0);
-  config.set_enable_extra_guardrails(false);
-  // Clear some fields inside Chrome config:
-  // * client_priority, because Chrome always sets the priority to
-  // USER_INITIATED when setting up startup tracing.
-  // * convert_to_legacy_json, because Telemetry initiates tracing with proto
-  // format, but in some cases adopts the tracing session later via devtools
-  // which expect json format.
-  // TODO(khokhlov): Don't clear client_priority when Chrome correctly sets it
-  // for startup tracing (and propagates it to all child processes).
-  if (config.has_chrome_config()) {
-    config.mutable_chrome_config()->set_client_priority(
-        perfetto::protos::gen::ChromeConfig::UNKNOWN);
-    config.mutable_chrome_config()->set_convert_to_legacy_json(false);
-  }
-  base::Hasher hasher;
-  std::string config_bytes = config.SerializeAsString();
-  hasher.Update(config_bytes.data(), config_bytes.size());
-  return hasher.digest();
-}
+ private:
+  StatusOr<protozero::ConstBytes> GetLengthDelimitedData() const;
 
-template <typename RegisteredBackend>
-struct CompareBackendByType {
-  static int BackendTypePriority(BackendType type) {
-    switch (type) {
-      case kSystemBackend:
-        return 0;
-      case kInProcessBackend:
-        return 1;
-      case kCustomBackend:
-        return 2;
-      // The UnspecifiedBackend has the highest priority so that
-      // TracingBackendFake is the last one on the backend lists.
-      case kUnspecifiedBackend:
-        break;
-    }
-    return 3;
-  }
-  bool operator()(BackendType type, const RegisteredBackend& b) {
-    return BackendTypePriority(type) < BackendTypePriority(b.type);
-  }
+  std::variant<protozero::ConstBytes, protozero::Field> data_;
 };
 
-}  // namespace
+}  // namespace protovm
+}  // namespace perfetto
 
-// ----- Begin of TracingMuxerImpl::ProducerImpl
-TracingMuxerImpl::ProducerImpl::ProducerImpl(
-    TracingMuxerImpl* muxer,
-    TracingBackendId backend_id,
-    uint32_t shmem_batch_commits_duration_ms)
-    : muxer_(muxer),
-      backend_id_(backend_id),
-      shmem_batch_commits_duration_ms_(shmem_batch_commits_duration_ms) {}
+#endif  // SRC_PROTOVM_RO_CURSOR_H_
+// gen_amalgamated begin header: src/protovm/rw_proto.h
+// gen_amalgamated begin header: src/protovm/rw_proto_cursor.h
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-TracingMuxerImpl::ProducerImpl::~ProducerImpl() {
-  muxer_ = nullptr;
-}
+#ifndef SRC_PROTOVM_RW_PROTO_CURSOR_H_
+#define SRC_PROTOVM_RW_PROTO_CURSOR_H_
 
-void TracingMuxerImpl::ProducerImpl::Initialize(
-    std::unique_ptr<ProducerEndpoint> endpoint) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  PERFETTO_DCHECK(!connected_);
-  connection_id_.fetch_add(1, std::memory_order_relaxed);
-  is_producer_provided_smb_ = endpoint->shared_memory();
-  last_startup_target_buffer_reservation_ = 0;
+// gen_amalgamated expanded: #include "perfetto/protozero/field.h"
 
-  // Adopt the endpoint into a shared pointer so that we can safely share it
-  // across threads that create trace writers. The custom deleter function
-  // ensures that the endpoint is always destroyed on the muxer's thread. (Note
-  // that |task_runner| is assumed to outlive tracing sessions on all threads.)
-  auto* task_runner = muxer_->task_runner_.get();
-  auto deleter = [task_runner](ProducerEndpoint* e) {
-    if (task_runner->RunsTasksOnCurrentThread()) {
-      delete e;
-      return;
-    }
-    task_runner->PostTask([e] { delete e; });
-  };
-  std::shared_ptr<ProducerEndpoint> service(endpoint.release(), deleter);
-  // This atomic store is needed because another thread might be concurrently
-  // creating a trace writer using the previous (disconnected) |service_|. See
-  // CreateTraceWriter().
-  std::atomic_store(&service_, std::move(service));
-  // Don't try to use the service here since it may not have connected yet. See
-  // OnConnect().
-}
+// gen_amalgamated expanded: #include "src/protovm/allocator.h"
+// gen_amalgamated expanded: #include "src/protovm/error_handling.h"
+// gen_amalgamated expanded: #include "src/protovm/node.h"
 
-void TracingMuxerImpl::ProducerImpl::OnConnect() {
-  PERFETTO_DLOG("Producer connected");
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  PERFETTO_DCHECK(!connected_);
-  if (is_producer_provided_smb_ && !service_->IsShmemProvidedByProducer()) {
-    PERFETTO_ELOG(
-        "The service likely doesn't support producer-provided SMBs. Preventing "
-        "future attempts to use producer-provided SMB again with this "
-        "backend.");
-    producer_provided_smb_failed_ = true;
-    // Will call OnDisconnect() and cause a reconnect without producer-provided
-    // SMB.
-    service_->Disconnect();
-    return;
-  }
-  connected_ = true;
-  muxer_->UpdateDataSourcesOnAllBackends();
-  SendOnConnectTriggers();
-}
+namespace perfetto {
+namespace protovm {
 
-void TracingMuxerImpl::ProducerImpl::OnDisconnect() {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  // If we're being destroyed, bail out.
-  if (!muxer_)
-    return;
-  connected_ = false;
-  // Active data sources for this producer will be stopped by
-  // DestroyStoppedTraceWritersForCurrentThread() since the reconnected producer
-  // will have a different connection id (even before it has finished
-  // connecting).
-  registered_data_sources_.reset();
-  DisposeConnection();
+class RwProtoCursor {
+ public:
+  class RepeatedFieldIterator {
+   public:
+    RepeatedFieldIterator();
+    RepeatedFieldIterator(Allocator* allocator, IntrusiveMap::Iterator it);
+    RepeatedFieldIterator& operator++();
+    RwProtoCursor GetCursor();
+    explicit operator bool() const;
 
-  // Try reconnecting the producer.
-  muxer_->OnProducerDisconnected(this);
-}
+   private:
+    Allocator* allocator_{nullptr};
+    IntrusiveMap::Iterator it_;
+  };
 
-void TracingMuxerImpl::ProducerImpl::DisposeConnection() {
-  // Keep the old service around as a dead connection in case it has active
-  // trace writers. If any tracing sessions were created, we can't clear
-  // |service_| here because other threads may be concurrently creating new
-  // trace writers. Any reconnection attempt will atomically swap the new
-  // service in place of the old one.
-  if (did_setup_tracing_ || did_setup_startup_tracing_) {
-    dead_services_.push_back(service_);
-  } else {
-    service_.reset();
-  }
-}
+  RwProtoCursor();
+  explicit RwProtoCursor(Node* node, Allocator* allocator);
+  StatusOr<bool> HasField(uint32_t field_id);
+  StatusOr<void> EnterField(uint32_t field_id);
+  StatusOr<void> EnterRepeatedFieldAt(uint32_t field_id, uint32_t index);
+  StatusOr<RepeatedFieldIterator> IterateRepeatedField(uint32_t field_id);
 
-void TracingMuxerImpl::ProducerImpl::OnTracingSetup() {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  did_setup_tracing_ = true;
-  service_->MaybeSharedMemoryArbiter()->SetBatchCommitsDuration(
-      shmem_batch_commits_duration_ms_);
-}
+  // Enters a specific repeated field, treating it as a map of key-value pairs.
+  //
+  // The function operates on the principle that the repeated field (identified
+  // by <field_id>) can be viewed as a collection of key-value pairs, where:
+  //  - Each message element within the repetition is a "value".
+  //  - A specific subfield within each message element (identified by
+  //   <map_key_field_id>) serves as the unique key for that element.
+  //
+  // The function performs a lookup using the provided <key> and, if a match
+  // is found, moves the cursor into the corresponding repeated field.
+  //
+  // Example:
+  //
+  // // Message currently pointer by the cursor
+  // message CurrentMessage {
+  //   repeated KeyValuePair entries = <field_id>;
+  // }
+  //
+  // message KeyValuePair {
+  //   uint32 key = <map_key_field_id>;
+  //   string value_x = ...;
+  //   string value_y = ...;
+  // }
+  //
+  // In this example <field_id> points to CurrentMessage.entries,
+  // <map_key_field_id> points to KeyValuePair.key, and <key> = 10. So the
+  // function attempts to find and enter the KeyValuePair message where
+  // key == 10.
+  StatusOr<void> EnterRepeatedFieldByKey(uint32_t field_id,
+                                         uint32_t map_key_field_id,
+                                         uint64_t key);
+
+  StatusOr<Scalar> GetScalar() const;
+  StatusOr<void> SetBytes(protozero::ConstBytes data);
+  StatusOr<void> SetScalar(Scalar scalar);
+
+  // Perform a shallow (one level) merge of two messages.
+  // The cursor must currently point to a message and 'data' must contain a
+  // message. Merge fields from the 'data' message into the message pointed by
+  // cursor. Existing fields in the cursor's message are overwritten by fields
+  // from 'data'. Fields present in 'data' but not in the cursor's message are
+  // be added/created.
+  StatusOr<void> Merge(protozero::ConstBytes data);
+
+  StatusOr<void> Delete();
 
-void TracingMuxerImpl::ProducerImpl::OnStartupTracingSetup() {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  did_setup_startup_tracing_ = true;
-}
+ private:
+  StatusOr<void> ConvertToMessageIfNeeded(Node* node);
+  StatusOr<OwnedPtr<Node>> CreateNodeFromField(protozero::Field field);
+  StatusOr<void> ConvertToMappedRepeatedFieldIfNeeded(
+      Node* node,
+      uint32_t map_key_field_id);
+  StatusOr<void> ConvertToIndexedRepeatedFieldIfNeeded(Node* node);
+  StatusOr<IntrusiveMap::Iterator> FindOrCreateMessageField(Node* node,
+                                                            uint32_t field_id);
+  StatusOr<IntrusiveMap::Iterator> FindOrCreateIndexedRepeatedField(
+      Node* node,
+      uint32_t index);
+  StatusOr<IntrusiveMap::Iterator> FindOrCreateMappedRepeatedField(
+      Node* node,
+      uint64_t key);
+  StatusOr<IntrusiveMap::Iterator> MapInsert(IntrusiveMap* map,
+                                             uint64_t key,
+                                             OwnedPtr<Node> map_value);
+  StatusOr<uint64_t> ReadScalarField(const Node& node, uint32_t field_id);
+
+  Node* node_ = nullptr;
+  std::pair<IntrusiveMap*, Node::MapNode*> holding_map_and_node_ = {};
+  Allocator* allocator_ = nullptr;
+};
 
-void TracingMuxerImpl::ProducerImpl::SetupDataSource(
-    DataSourceInstanceID id,
-    const DataSourceConfig& cfg) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  if (!muxer_)
-    return;
-  muxer_->SetupDataSource(
-      backend_id_, connection_id_.load(std::memory_order_relaxed), id, cfg);
-}
+}  // namespace protovm
+}  // namespace perfetto
 
-void TracingMuxerImpl::ProducerImpl::StartDataSource(DataSourceInstanceID id,
-                                                     const DataSourceConfig&) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  if (!muxer_)
-    return;
-  muxer_->StartDataSource(backend_id_, id);
-  service_->NotifyDataSourceStarted(id);
-}
+#endif  // SRC_PROTOVM_RW_PROTO_CURSOR_H_
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-void TracingMuxerImpl::ProducerImpl::StopDataSource(DataSourceInstanceID id) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  if (!muxer_)
-    return;
-  muxer_->StopDataSource_AsyncBegin(backend_id_, id);
-}
+#ifndef SRC_PROTOVM_RW_PROTO_H_
+#define SRC_PROTOVM_RW_PROTO_H_
 
-void TracingMuxerImpl::ProducerImpl::Flush(FlushRequestID flush_id,
-                                           const DataSourceInstanceID*,
-                                           size_t) {
-  // Flush is not plumbed for now, we just ack straight away.
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  service_->NotifyFlushComplete(flush_id);
-}
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 
-void TracingMuxerImpl::ProducerImpl::ClearIncrementalState(
-    const DataSourceInstanceID* instances,
-    size_t instance_count) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  if (!muxer_)
-    return;
-  for (size_t inst_idx = 0; inst_idx < instance_count; inst_idx++) {
-    muxer_->ClearDataSourceIncrementalState(backend_id_, instances[inst_idx]);
-  }
-}
+// gen_amalgamated expanded: #include "src/protovm/allocator.h"
+// gen_amalgamated expanded: #include "src/protovm/node.h"
+// gen_amalgamated expanded: #include "src/protovm/rw_proto_cursor.h"
 
-bool TracingMuxerImpl::ProducerImpl::SweepDeadServices() {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  auto is_unused = [](const std::shared_ptr<ProducerEndpoint>& endpoint) {
-    auto* arbiter = endpoint->MaybeSharedMemoryArbiter();
-    return !arbiter || arbiter->TryShutdown();
-  };
-  for (auto it = dead_services_.begin(); it != dead_services_.end();) {
-    auto next_it = it;
-    next_it++;
-    if (is_unused(*it)) {
-      dead_services_.erase(it);
-    }
-    it = next_it;
-  }
-  return dead_services_.empty();
-}
+namespace perfetto {
+namespace protovm {
 
-void TracingMuxerImpl::ProducerImpl::SendOnConnectTriggers() {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  base::TimeMillis now = base::GetWallTimeMs();
-  std::vector<std::string> triggers;
-  while (!on_connect_triggers_.empty()) {
-    // Skip if we passed TTL.
-    if (on_connect_triggers_.front().second > now) {
-      triggers.push_back(std::move(on_connect_triggers_.front().first));
-    }
-    on_connect_triggers_.pop_front();
-  }
-  if (!triggers.empty()) {
-    service_->ActivateTriggers(triggers);
-  }
-}
+// RwProto provides an API to create and manipulate protobuf messages without
+// requiring prior knowledge of the schema. Meaning that protobuf messages can
+// be dynamically built on-the-fly, without pre-compiled .proto definitions.
+//
+// Key features:
+//
+// - Schema-agnostic: RwProto dynamically learns the schema as fields and
+//   messages are added.
+//
+// - Tree-like representation: protobuf messages are represented internally as a
+//   tree of nodes, mirroring the nested structure of protobufs. This tree can
+//   be traversed and manipulated using a Cursor object.
+//
+// - Fine-grained Memory Management: a centralized allocator is used to manage
+//   memory for nodes, ensuring good data locality and fine-grained control over
+//   memory usage.
+//
+// Overview of RwProto's internal node structure:
+//
+//                             ┌─────────┐
+//                             │         │
+//                             │ Message │
+//                             │         │ Map<field_id, OwnedPtr<Node>>
+//                             └─┬┬┬┬┬┬──┘
+//                               │││││└────────────────────────────────┐
+//                               ││││└───────────────────────┐         │
+//               ┌───────────────┘││└──────────────┐         │         │
+//               │            ┌───┘└────┐          │         │         │
+//               │            │    ┌────▼────┐ ┌───▼───┐ ┌───▼───┐ ┌───▼────┐
+//               │            │    │         │ │       │ │       │ │        │
+//               │            │    │ Message │ │ Empty │ │ Bytes │ │ Scalar │
+//               │            │    │         │ │       │ │       │ │        │
+//               │            │    └────┬────┘ └───────┘ └───────┘ └────────┘
+//               │            │         ▼
+//               │            │        ...
+//               │            │
+//               │            │
+//               │   *********▼********
+//               │   *                *
+//               │   * Mapped         *
+//               │   * RepeatedField  *
+//               │   *                *
+//               │   ******************  Map<key, OwnedPtr<Node>>
+//               │           │ │
+//               │       ┌───┘ └────┐
+//               │       │          │
+//               │  ┌────▼────┐ ┌───▼───┐
+//               │  │         │ │       │
+//               │  │ Message │ │ Bytes │
+//               │  │         │ │       │
+//               │  └────┬────┘ └───────┘
+//               │       ▼
+//               │      ...
+//               │
+//
+//       ********▼*********
+//       *                *
+//       * Indexed        *
+//       * RepeatedField  *
+//       *                *
+//       ******************  Map<index, OwnedPtr<Node>>
+//             ││││
+//      ┌──────┘││└────────────────────┐
+//      │       │└───────────┐         │
+//      │       └──┐         │         │
+//      │          │         │         │
+// ┌────▼────┐ ┌───▼───┐ ┌───▼───┐ ┌───▼────┐
+// │         │ │       │ │       │ │        │
+// │ Message │ │ Empty │ │ Bytes │ │ Scalar │
+// │         │ │       │ │       │ │        │
+// └────┬────┘ └───────┘ └───────┘ └────────┘
+//      ▼
+//     ...
+//
+//
+// ┌─┐
+// │ │  Data node: corresponds to an actual field/message in the proto schema
+// └─┘             and eventually becomes part of the final serialized proto.
+//
+// ***
+// * *  Structural node: used to organize and provide access to message fields.
+// ***                   It is an internal helper and doesn't appear in the
+//                       final serialized proto.
+//
+//
+// Message: Represents a protobuf message. It maps field_id to corresponding
+//          node/value. It allows accessing fields as well as adding and
+//          removing them.
+//
+//
+// Empty: Represents an empty or uninitialized node. It is used as a
+//        placeholder before a node's type is determined. E.g. between an
+//        "enter field" and a "set field value" operation.
+//
+//
+// Bytes: Stores a sequence of bytes, typically representing a length-delimited
+//        protobuf field.
+//
+//
+// Scalar: Stores a scalar value.
+//
+//
+// IndexedRepeatedField: Represents a protobuf repeated field where elements
+//                       are accessed by index.
+//
+//
+// MappedRepeatedField: Represents a protobuf repeated field where elements
+//                      are accessed by key.
+class RwProto {
+ public:
+  using Cursor = RwProtoCursor;
+
+  explicit RwProto(Allocator* allocator);
+  ~RwProto();
+  Cursor GetRoot();
+  void Serialize(protozero::Message*) const;
+
+ private:
+  void SerializeField(uint32_t field_id,
+                      const Node& node,
+                      protozero::Message* proto) const;
 
-// ----- End of TracingMuxerImpl::ProducerImpl methods.
+  Allocator* allocator_{nullptr};
+  Node root_;
+};
 
-// ----- Begin of TracingMuxerImpl::ConsumerImpl
-TracingMuxerImpl::ConsumerImpl::ConsumerImpl(TracingMuxerImpl* muxer,
-                                             BackendType backend_type,
-                                             TracingSessionGlobalID session_id)
-    : muxer_(muxer), backend_type_(backend_type), session_id_(session_id) {}
+}  // namespace protovm
+}  // namespace perfetto
 
-TracingMuxerImpl::ConsumerImpl::~ConsumerImpl() {
-  muxer_ = nullptr;
-}
+#endif  // SRC_PROTOVM_RW_PROTO_H_
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-void TracingMuxerImpl::ConsumerImpl::Initialize(
-    std::unique_ptr<ConsumerEndpoint> endpoint) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  service_ = std::move(endpoint);
-  // Don't try to use the service here since it may not have connected yet. See
-  // OnConnect().
-}
+#ifndef SRC_PROTOVM_EXECUTOR_H_
+#define SRC_PROTOVM_EXECUTOR_H_
 
-void TracingMuxerImpl::ConsumerImpl::OnConnect() {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  PERFETTO_DCHECK(!connected_);
-  connected_ = true;
+#include <cstdint>
+#include <optional>
 
-  // Observe data source instance events so we get notified when tracing starts.
-  service_->ObserveEvents(ObservableEvents::TYPE_DATA_SOURCES_INSTANCES |
-                          ObservableEvents::TYPE_ALL_DATA_SOURCES_STARTED);
+// gen_amalgamated expanded: #include "protos/perfetto/protovm/vm_program.pbzero.h"
 
-  // If the API client configured and started tracing before we connected,
-  // tell the backend about it now.
-  if (trace_config_)
-    muxer_->SetupTracingSession(session_id_, trace_config_);
-  if (start_pending_)
-    muxer_->StartTracingSession(session_id_);
-  if (get_trace_stats_pending_) {
-    auto callback = std::move(get_trace_stats_callback_);
-    get_trace_stats_callback_ = nullptr;
-    muxer_->GetTraceStats(session_id_, std::move(callback));
-  }
-  if (query_service_state_callback_) {
-    auto callback = std::move(query_service_state_callback_);
-    query_service_state_callback_ = nullptr;
-    muxer_->QueryServiceState(session_id_, std::move(callback));
-  }
-  if (stop_pending_)
-    muxer_->StopTracingSession(session_id_);
-}
+// gen_amalgamated expanded: #include "src/protovm/error_handling.h"
+// gen_amalgamated expanded: #include "src/protovm/ro_cursor.h"
+// gen_amalgamated expanded: #include "src/protovm/rw_proto.h"
 
-void TracingMuxerImpl::ConsumerImpl::OnDisconnect() {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  // If we're being destroyed, bail out.
-  if (!muxer_)
-    return;
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-  if (!connected_ && backend_type_ == kSystemBackend) {
-    PERFETTO_ELOG(
-        "Unable to connect to the system tracing service as a consumer. On "
-        "Android, use the \"perfetto\" command line tool instead to start "
-        "system-wide tracing sessions");
-  }
-#endif  // PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+namespace perfetto {
+namespace protovm {
 
-  // Notify the client about disconnection.
-  NotifyError(TracingError{TracingError::kDisconnected, "Peer disconnected"});
+using CursorEnum = perfetto::protos::pbzero::VmCursorEnum;
 
-  // Make sure the client doesn't hang in a blocking start/stop because of the
-  // disconnection.
-  NotifyStartComplete();
-  NotifyStopComplete();
+struct Cursors {
+  RoCursor src;
+  RwProto::Cursor dst;
+  CursorEnum selected{CursorEnum::VM_CURSOR_UNSPECIFIED};
+  bool create_if_not_exist{false};
+};
 
-  // It shouldn't be necessary to call StopTracingSession. If we get this call
-  // it means that the service did shutdown before us, so there is no point
-  // trying it to ask it to stop the session. We should just remember to cleanup
-  // the consumer vector.
-  connected_ = false;
+// Executor's methods are virtual to be overridden in tests
+class Executor {
+ public:
+  virtual ~Executor();
+  virtual StatusOr<void> EnterField(Cursors* cursors, uint32_t field_id) const;
+  virtual StatusOr<void> EnterRepeatedFieldAt(Cursors* cursors,
+                                              uint32_t field_id,
+                                              uint32_t index) const;
+  virtual StatusOr<void> EnterRepeatedFieldByKey(Cursors* cursors,
+                                                 uint32_t field_id,
+                                                 uint32_t map_key_field_id,
+                                                 uint64_t key) const;
+  virtual StatusOr<RoCursor::RepeatedFieldIterator> IterateRepeatedField(
+      RoCursor* src,
+      uint32_t field_id) const;
+  virtual StatusOr<RwProto::Cursor::RepeatedFieldIterator> IterateRepeatedField(
+      RwProto::Cursor* dst,
+      uint32_t field_id) const;
+  virtual StatusOr<uint64_t> ReadRegister(uint8_t reg_id) const;
+  virtual StatusOr<void> WriteRegister(const Cursors& cursors, uint8_t reg_id);
+  virtual StatusOr<void> Delete(RwProto::Cursor* dst) const;
+  virtual StatusOr<void> Merge(Cursors* cursors) const;
+  virtual StatusOr<void> Set(Cursors* cursors) const;
 
-  // Notify the muxer that it is safe to destroy |this|. This is needed because
-  // the ConsumerEndpoint stored in |service_| requires that |this| be safe to
-  // access until OnDisconnect() is called.
-  muxer_->OnConsumerDisconnected(this);
-}
+ private:
+  std::array<std::optional<uint64_t>, 32> registers_;
+};
 
-void TracingMuxerImpl::ConsumerImpl::Disconnect() {
-  // This is weird and deserves a comment.
-  //
-  // When we called the ConnectConsumer method on the service it returns
-  // us a ConsumerEndpoint which we stored in |service_|, however this
-  // ConsumerEndpoint holds a pointer to the ConsumerImpl pointed to by
-  // |this|. Part of the API contract to TracingService::ConnectConsumer is that
-  // the ConsumerImpl pointer has to be valid until the
-  // ConsumerImpl::OnDisconnect method is called. Therefore we reset the
-  // ConsumerEndpoint |service_|. Eventually this will call
-  // ConsumerImpl::OnDisconnect and we will inform the muxer it is safe to
-  // call the destructor of |this|.
-  service_.reset();
-}
+}  // namespace protovm
+}  // namespace perfetto
 
-void TracingMuxerImpl::ConsumerImpl::OnTracingDisabled(
-    const std::string& error) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  PERFETTO_DCHECK(!stopped_);
-  stopped_ = true;
+#endif  // SRC_PROTOVM_EXECUTOR_H_
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-  if (!error.empty())
-    NotifyError(TracingError{TracingError::kTracingFailed, error});
+// gen_amalgamated expanded: #include "src/protovm/executor.h"
 
-  // If we're still waiting for the start event, fire it now. This may happen if
-  // there are no active data sources in the session.
-  NotifyStartComplete();
-  NotifyStopComplete();
-}
+namespace perfetto {
+namespace protovm {
 
-void TracingMuxerImpl::ConsumerImpl::NotifyStartComplete() {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  if (start_complete_callback_) {
-    muxer_->task_runner_->PostTask(std::move(start_complete_callback_));
-    start_complete_callback_ = nullptr;
+Executor::~Executor() = default;
+
+StatusOr<void> Executor::EnterField(Cursors* cursors, uint32_t field_id) const {
+  if (cursors->selected == CursorEnum::VM_CURSOR_SRC) {
+    return cursors->src.EnterField(field_id);
   }
-  if (blocking_start_complete_callback_) {
-    muxer_->task_runner_->PostTask(
-        std::move(blocking_start_complete_callback_));
-    blocking_start_complete_callback_ = nullptr;
+
+  auto has_field = cursors->dst.HasField(field_id);
+  PROTOVM_RETURN_IF_NOT_OK(has_field);
+
+  if (!has_field.value() && !cursors->create_if_not_exist) {
+    return StatusOr<void>::Error();
   }
+
+  return cursors->dst.EnterField(field_id);
 }
 
-void TracingMuxerImpl::ConsumerImpl::NotifyError(const TracingError& error) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  if (error_callback_) {
-    muxer_->task_runner_->PostTask(
-        std::bind(std::move(error_callback_), error));
+StatusOr<void> Executor::EnterRepeatedFieldAt(Cursors* cursors,
+                                              uint32_t field_id,
+                                              uint32_t index) const {
+  if (cursors->selected == CursorEnum::VM_CURSOR_SRC) {
+    return cursors->src.EnterRepeatedFieldAt(field_id, index);
   }
+
+  return cursors->dst.EnterRepeatedFieldAt(field_id, index);
 }
 
-void TracingMuxerImpl::ConsumerImpl::NotifyStopComplete() {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  if (stop_complete_callback_) {
-    muxer_->task_runner_->PostTask(std::move(stop_complete_callback_));
-    stop_complete_callback_ = nullptr;
-  }
-  if (blocking_stop_complete_callback_) {
-    muxer_->task_runner_->PostTask(std::move(blocking_stop_complete_callback_));
-    blocking_stop_complete_callback_ = nullptr;
+StatusOr<void> Executor::EnterRepeatedFieldByKey(Cursors* cursors,
+                                                 uint32_t field_id,
+                                                 uint32_t map_key_field_id,
+                                                 uint64_t key) const {
+  if (cursors->selected == CursorEnum::VM_CURSOR_SRC) {
+    PROTOVM_ABORT(
+        "Mapped repeated fields are currently supported only in RwProto");
   }
-}
 
-void TracingMuxerImpl::ConsumerImpl::OnTraceData(
-    std::vector<TracePacket> packets,
-    bool has_more) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  if (!read_trace_callback_)
-    return;
+  auto has_field = cursors->dst.HasField(field_id);
+  PROTOVM_RETURN_IF_NOT_OK(has_field);
 
-  size_t capacity = 0;
-  for (const auto& packet : packets) {
-    // 16 is an over-estimation of the proto preamble size
-    capacity += packet.size() + 16;
+  if (!has_field.value() && !cursors->create_if_not_exist) {
+    return StatusOr<void>::Error();
   }
 
-  // The shared_ptr is to avoid making a copy of the buffer when PostTask-ing.
-  std::shared_ptr<std::vector<char>> buf(new std::vector<char>());
-  buf->reserve(capacity);
-  for (auto& packet : packets) {
-    char* start;
-    size_t size;
-    std::tie(start, size) = packet.GetProtoPreamble();
-    buf->insert(buf->end(), start, start + size);
-    for (auto& slice : packet.slices()) {
-      const auto* slice_data = reinterpret_cast<const char*>(slice.start);
-      buf->insert(buf->end(), slice_data, slice_data + slice.size);
-    }
-  }
+  return cursors->dst.EnterRepeatedFieldByKey(field_id, map_key_field_id, key);
+}
 
-  auto callback = read_trace_callback_;
-  muxer_->task_runner_->PostTask([callback, buf, has_more] {
-    TracingSession::ReadTraceCallbackArgs callback_arg{};
-    callback_arg.data = buf->empty() ? nullptr : &(*buf)[0];
-    callback_arg.size = buf->size();
-    callback_arg.has_more = has_more;
-    callback(callback_arg);
-  });
+StatusOr<RoCursor::RepeatedFieldIterator> Executor::IterateRepeatedField(
+    RoCursor* src,
+    uint32_t field_id) const {
+  return src->IterateRepeatedField(field_id);
+}
 
-  if (!has_more)
-    read_trace_callback_ = nullptr;
+StatusOr<RwProto::Cursor::RepeatedFieldIterator> Executor::IterateRepeatedField(
+    RwProto::Cursor* dst,
+    uint32_t field_id) const {
+  return dst->IterateRepeatedField(field_id);
 }
 
-void TracingMuxerImpl::ConsumerImpl::OnObservableEvents(
-    const ObservableEvents& events) {
-  if (events.instance_state_changes_size()) {
-    for (const auto& state_change : events.instance_state_changes()) {
-      DataSourceHandle handle{state_change.producer_name(),
-                              state_change.data_source_name()};
-      data_source_states_[handle] =
-          state_change.state() ==
-          ObservableEvents::DATA_SOURCE_INSTANCE_STATE_STARTED;
-    }
+StatusOr<uint64_t> Executor::ReadRegister(uint8_t reg_id) const {
+  if (reg_id >= registers_.size()) {
+    PROTOVM_ABORT("Register (id = %d) is out of bounds", reg_id);
   }
-
-  if (events.instance_state_changes_size() ||
-      events.all_data_sources_started()) {
-    // Data sources are first reported as being stopped before starting, so once
-    // all the data sources we know about have started we can declare tracing
-    // begun. In the case where there are no matching data sources for the
-    // session, the service will report the all_data_sources_started() event
-    // without adding any instances (only since Android S / Perfetto v10.0).
-    if (start_complete_callback_ || blocking_start_complete_callback_) {
-      bool all_data_sources_started = std::all_of(
-          data_source_states_.cbegin(), data_source_states_.cend(),
-          [](std::pair<DataSourceHandle, bool> state) { return state.second; });
-      if (all_data_sources_started)
-        NotifyStartComplete();
-    }
+  if (!registers_[reg_id]) {
+    PROTOVM_ABORT("Register (id = %d) is not initialized)", reg_id);
   }
+  return StatusOr<uint64_t>{*registers_[reg_id]};
 }
 
-void TracingMuxerImpl::ConsumerImpl::OnSessionCloned(
-    bool /*success*/,
-    const std::string& /*error*/) {
-  // CloneSession is not exposed in the SDK. This should never happen.
-  PERFETTO_DCHECK(false);
+StatusOr<void> Executor::WriteRegister(const Cursors& cursors, uint8_t reg_id) {
+  if (reg_id >= registers_.size()) {
+    PROTOVM_ABORT("Register (id = %d) is out of bounds", reg_id);
+  }
+
+  auto status_or_scalar = cursors.selected == CursorEnum::VM_CURSOR_SRC
+                              ? cursors.src.GetScalar()
+                              : cursors.dst.GetScalar();
+  PROTOVM_RETURN_IF_NOT_OK(status_or_scalar);
+
+  registers_[reg_id] = status_or_scalar->value;
+  return StatusOr<void>::Ok();
 }
 
-void TracingMuxerImpl::ConsumerImpl::OnTraceStats(
-    bool success,
-    const TraceStats& trace_stats) {
-  if (!get_trace_stats_callback_)
-    return;
-  TracingSession::GetTraceStatsCallbackArgs callback_arg{};
-  callback_arg.success = success;
-  callback_arg.trace_stats_data = trace_stats.SerializeAsArray();
-  muxer_->task_runner_->PostTask(
-      std::bind(std::move(get_trace_stats_callback_), std::move(callback_arg)));
-  get_trace_stats_callback_ = nullptr;
+StatusOr<void> Executor::Delete(RwProto::Cursor* dst) const {
+  return dst->Delete();
 }
 
-// The callbacks below are not used.
-void TracingMuxerImpl::ConsumerImpl::OnDetach(bool) {}
-void TracingMuxerImpl::ConsumerImpl::OnAttach(bool, const TraceConfig&) {}
-// ----- End of TracingMuxerImpl::ConsumerImpl
+StatusOr<void> Executor::Merge(Cursors* cursors) const {
+  if (!cursors->src.IsBytes()) {
+    PROTOVM_ABORT(
+        "Attempted MERGE operation but src cursor has incompatible data "
+        "type");
+  }
 
-// ----- Begin of TracingMuxerImpl::TracingSessionImpl
+  return cursors->dst.Merge(*cursors->src.GetBytes());
+}
 
-// TracingSessionImpl is the RAII object returned to API clients when they
-// invoke Tracing::CreateTracingSession. They use it for starting/stopping
-// tracing.
+StatusOr<void> Executor::Set(Cursors* cursors) const {
+  if (cursors->src.IsScalar()) {
+    auto status_or_scalar = cursors->src.GetScalar();
+    PROTOVM_RETURN_IF_NOT_OK(status_or_scalar);
+    return cursors->dst.SetScalar(*status_or_scalar);
+  }
 
-TracingMuxerImpl::TracingSessionImpl::TracingSessionImpl(
-    TracingMuxerImpl* muxer,
-    TracingSessionGlobalID session_id,
-    BackendType backend_type)
-    : muxer_(muxer), session_id_(session_id), backend_type_(backend_type) {}
+  if (cursors->src.IsBytes()) {
+    auto status_or_bytes = cursors->src.GetBytes();
+    PROTOVM_RETURN_IF_NOT_OK(status_or_bytes);
+    return cursors->dst.SetBytes(*status_or_bytes);
+  }
 
-// Can be destroyed from any thread.
-TracingMuxerImpl::TracingSessionImpl::~TracingSessionImpl() {
-  auto* muxer = muxer_;
-  auto session_id = session_id_;
-  muxer->task_runner_->PostTask(
-      [muxer, session_id] { muxer->DestroyTracingSession(session_id); });
+  PROTOVM_ABORT("Attempted SET operation but src cursor has no valid data");
 }
 
-// Can be called from any thread.
-void TracingMuxerImpl::TracingSessionImpl::Setup(const TraceConfig& cfg,
-                                                 int fd) {
-  auto* muxer = muxer_;
-  auto session_id = session_id_;
-  std::shared_ptr<TraceConfig> trace_config(new TraceConfig(cfg));
-  if (fd >= 0) {
-    base::ignore_result(backend_type_);  // For -Wunused in the amalgamation.
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-    if (backend_type_ != kInProcessBackend) {
-      PERFETTO_FATAL(
-          "Passing a file descriptor to TracingSession::Setup() is only "
-          "supported with the kInProcessBackend on Windows. Use "
-          "TracingSession::ReadTrace() instead");
-    }
-#endif
-    trace_config->set_write_into_file(true);
-    fd = dup(fd);
-  }
-  muxer->task_runner_->PostTask([muxer, session_id, trace_config, fd] {
-    muxer->SetupTracingSession(session_id, trace_config, base::ScopedFile(fd));
-  });
-}
+}  // namespace protovm
+}  // namespace perfetto
+// gen_amalgamated begin source: src/protovm/node.cc
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-// Can be called from any thread.
-void TracingMuxerImpl::TracingSessionImpl::Start() {
-  auto* muxer = muxer_;
-  auto session_id = session_id_;
-  muxer->task_runner_->PostTask(
-      [muxer, session_id] { muxer->StartTracingSession(session_id); });
-}
+// gen_amalgamated expanded: #include "src/protovm/node.h"
 
-// Can be called from any thread.
-void TracingMuxerImpl::TracingSessionImpl::ChangeTraceConfig(
-    const TraceConfig& cfg) {
-  auto* muxer = muxer_;
-  auto session_id = session_id_;
-  muxer->task_runner_->PostTask([muxer, session_id, cfg] {
-    muxer->ChangeTracingSessionConfig(session_id, cfg);
-  });
+namespace perfetto {
+namespace protovm {
+
+const char* Node::GetTypeName() const {
+  return std::visit(
+      [](auto&& value) {
+        using T = std::decay_t<decltype(value)>;
+        if constexpr (std::is_same_v<T, Node::Bytes>) {
+          return "Bytes";
+        } else if constexpr (std::is_same_v<T, Node::Empty>) {
+          return "Empty";
+        } else if constexpr (std::is_same_v<T, Node::IndexedRepeatedField>) {
+          return "IndexedRepeatedField";
+        } else if constexpr (std::is_same_v<T, Node::MapNode>) {
+          return "MapEntry";
+        } else if constexpr (std::is_same_v<T, Node::MappedRepeatedField>) {
+          return "MappedRepeatedField";
+        } else if constexpr (std::is_same_v<T, Node::Message>) {
+          return "Message";
+        } else if constexpr (std::is_same_v<T, Scalar>) {
+          return "Scalar";
+        } else {
+          return "<unknown>";
+        }
+      },
+      value);
 }
 
-// Can be called from any thread except the service thread.
-void TracingMuxerImpl::TracingSessionImpl::StartBlocking() {
-  PERFETTO_DCHECK(!muxer_->task_runner_->RunsTasksOnCurrentThread());
-  auto* muxer = muxer_;
-  auto session_id = session_id_;
-  base::WaitableEvent tracing_started;
-  muxer->task_runner_->PostTask([muxer, session_id, &tracing_started] {
-    auto* consumer = muxer->FindConsumer(session_id);
-    if (!consumer) {
-      // TODO(skyostil): Signal an error to the user.
-      tracing_started.Notify();
-      return;
-    }
-    PERFETTO_DCHECK(!consumer->blocking_start_complete_callback_);
-    consumer->blocking_start_complete_callback_ = [&] {
-      tracing_started.Notify();
-    };
-    muxer->StartTracingSession(session_id);
-  });
-  tracing_started.Wait();
-}
+Node& GetOuterNode(Node::MapNode& map_node) {
+  // Hackish solution to obtain offsetof(Node, MapNode). Alas, there isn't
+  // anything like the standard offsetof that works with std::variant. Note that
+  // the calculation can't be constexpr, however the compiler optimizes it out.
+  const Node tmp{Node::MapNode{0, nullptr}};
+  const auto* tmp_map_node = std::get_if<Node::MapNode>(&tmp.value);
+  const auto kOffset = reinterpret_cast<const char*>(tmp_map_node) -
+                       reinterpret_cast<const char*>(&tmp);
 
-// Can be called from any thread.
-void TracingMuxerImpl::TracingSessionImpl::Flush(
-    std::function<void(bool)> user_callback,
-    uint32_t timeout_ms) {
-  auto* muxer = muxer_;
-  auto session_id = session_id_;
-  muxer->task_runner_->PostTask([muxer, session_id, timeout_ms, user_callback] {
-    auto* consumer = muxer->FindConsumer(session_id);
-    if (!consumer) {
-      std::move(user_callback)(false);
-      return;
-    }
-    muxer->FlushTracingSession(session_id, timeout_ms,
-                               std::move(user_callback));
-  });
+  auto* node = reinterpret_cast<char*>(&map_node);
+  node -= kOffset;
+  return *reinterpret_cast<Node*>(node);
 }
 
-// Can be called from any thread.
-void TracingMuxerImpl::TracingSessionImpl::Stop() {
-  auto* muxer = muxer_;
-  auto session_id = session_id_;
-  muxer->task_runner_->PostTask(
-      [muxer, session_id] { muxer->StopTracingSession(session_id); });
-}
+}  // namespace protovm
+}  // namespace perfetto
+// gen_amalgamated begin source: src/protovm/parser.cc
+// gen_amalgamated begin header: src/protovm/parser.h
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-// Can be called from any thread except the service thread.
-void TracingMuxerImpl::TracingSessionImpl::StopBlocking() {
-  PERFETTO_DCHECK(!muxer_->task_runner_->RunsTasksOnCurrentThread());
-  auto* muxer = muxer_;
-  auto session_id = session_id_;
-  base::WaitableEvent tracing_stopped;
-  muxer->task_runner_->PostTask([muxer, session_id, &tracing_stopped] {
-    auto* consumer = muxer->FindConsumer(session_id);
-    if (!consumer) {
-      // TODO(skyostil): Signal an error to the user.
-      tracing_stopped.Notify();
-      return;
-    }
-    PERFETTO_DCHECK(!consumer->blocking_stop_complete_callback_);
-    consumer->blocking_stop_complete_callback_ = [&] {
-      tracing_stopped.Notify();
-    };
-    muxer->StopTracingSession(session_id);
-  });
-  tracing_stopped.Wait();
-}
+#ifndef SRC_PROTOVM_PARSER_H_
+#define SRC_PROTOVM_PARSER_H_
 
-// Can be called from any thread.
-void TracingMuxerImpl::TracingSessionImpl::ReadTrace(ReadTraceCallback cb) {
-  auto* muxer = muxer_;
-  auto session_id = session_id_;
-  muxer->task_runner_->PostTask([muxer, session_id, cb] {
-    muxer->ReadTracingSessionData(session_id, std::move(cb));
-  });
-}
+// gen_amalgamated expanded: #include "perfetto/protozero/field.h"
+// gen_amalgamated expanded: #include "protos/perfetto/protovm/vm_program.pbzero.h"
 
-// Can be called from any thread.
-void TracingMuxerImpl::TracingSessionImpl::SetOnStartCallback(
-    std::function<void()> cb) {
-  auto* muxer = muxer_;
-  auto session_id = session_id_;
-  muxer->task_runner_->PostTask([muxer, session_id, cb] {
-    auto* consumer = muxer->FindConsumer(session_id);
-    if (!consumer)
-      return;
-    consumer->start_complete_callback_ = cb;
-  });
-}
+// gen_amalgamated expanded: #include "src/protovm/error_handling.h"
+// gen_amalgamated expanded: #include "src/protovm/executor.h"
+// gen_amalgamated expanded: #include "src/protovm/ro_cursor.h"
+// gen_amalgamated expanded: #include "src/protovm/rw_proto.h"
 
-// Can be called from any thread
-void TracingMuxerImpl::TracingSessionImpl::SetOnErrorCallback(
-    std::function<void(TracingError)> cb) {
-  auto* muxer = muxer_;
-  auto session_id = session_id_;
-  muxer->task_runner_->PostTask([muxer, session_id, cb] {
-    auto* consumer = muxer->FindConsumer(session_id);
-    if (!consumer) {
-      // Notify the client about concurrent disconnection of the session.
-      if (cb)
-        cb(TracingError{TracingError::kDisconnected, "Peer disconnected"});
-      return;
-    }
-    consumer->error_callback_ = cb;
-  });
-}
+namespace perfetto {
+namespace protovm {
 
-// Can be called from any thread.
-void TracingMuxerImpl::TracingSessionImpl::SetOnStopCallback(
-    std::function<void()> cb) {
-  auto* muxer = muxer_;
-  auto session_id = session_id_;
-  muxer->task_runner_->PostTask([muxer, session_id, cb] {
-    auto* consumer = muxer->FindConsumer(session_id);
-    if (!consumer)
-      return;
-    consumer->stop_complete_callback_ = cb;
-  });
-}
+class Parser {
+ public:
+  Parser(protozero::ConstBytes program, Executor* executor);
+  StatusOr<void> Run(RoCursor src, RwProto::Cursor dst);
 
-// Can be called from any thread.
-void TracingMuxerImpl::TracingSessionImpl::GetTraceStats(
-    GetTraceStatsCallback cb) {
-  auto* muxer = muxer_;
-  auto session_id = session_id_;
-  muxer->task_runner_->PostTask([muxer, session_id, cb] {
-    muxer->GetTraceStats(session_id, std::move(cb));
-  });
-}
+ private:
+  StatusOr<void> ParseInstructions(
+      protozero::RepeatedFieldIterator<protozero::ConstBytes> it_instruction);
+  StatusOr<void> ParseInstruction(
+      const protos::pbzero::VmInstruction::Decoder& instruction);
+  StatusOr<void> ParseRegLoad(
+      const protos::pbzero::VmInstruction::Decoder& instruction);
+  StatusOr<void> ParseSelect(
+      const protos::pbzero::VmInstruction::Decoder& instruction);
+  StatusOr<void> ParseSelectRec(
+      const protos::pbzero::VmInstruction::Decoder& instruction,
+      protozero::RepeatedFieldIterator<protozero::ConstBytes>
+          it_path_component);
+
+  protos::pbzero::VmProgram::Decoder program_;
+  Cursors cursors_;
+  Executor* executor_;
+};
 
-// Can be called from any thread.
-void TracingMuxerImpl::TracingSessionImpl::QueryServiceState(
-    QueryServiceStateCallback cb) {
-  auto* muxer = muxer_;
-  auto session_id = session_id_;
-  muxer->task_runner_->PostTask([muxer, session_id, cb] {
-    muxer->QueryServiceState(session_id, std::move(cb));
-  });
-}
+}  // namespace protovm
+}  // namespace perfetto
 
-// ----- End of TracingMuxerImpl::TracingSessionImpl
+#endif  // SRC_PROTOVM_PARSER_H_
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-// ----- Begin of TracingMuxerImpl::StartupTracingSessionImpl
+// gen_amalgamated expanded: #include "src/protovm/parser.h"
 
-TracingMuxerImpl::StartupTracingSessionImpl::StartupTracingSessionImpl(
-    TracingMuxerImpl* muxer,
-    TracingSessionGlobalID session_id,
-    BackendType backend_type)
-    : muxer_(muxer), session_id_(session_id), backend_type_(backend_type) {}
+namespace perfetto {
+namespace protovm {
 
-// Can be destroyed from any thread.
-TracingMuxerImpl::StartupTracingSessionImpl::~StartupTracingSessionImpl() =
-    default;
+Parser::Parser(protozero::ConstBytes program, Executor* executor)
+    : program_{program}, executor_(executor) {}
 
-void TracingMuxerImpl::StartupTracingSessionImpl::Abort() {
-  auto* muxer = muxer_;
-  auto session_id = session_id_;
-  auto backend_type = backend_type_;
-  muxer->task_runner_->PostTask([muxer, session_id, backend_type] {
-    muxer->AbortStartupTracingSession(session_id, backend_type);
-  });
+StatusOr<void> Parser::Run(RoCursor src, RwProto::Cursor dst) {
+  cursors_.src = src;
+  cursors_.dst = dst;
+  return ParseInstructions(program_.instructions());
+}
+
+StatusOr<void> Parser::ParseInstructions(
+    protozero::RepeatedFieldIterator<protozero::ConstBytes> it_instruction) {
+  int instruction_index = 0;
+  for (; it_instruction; ++it_instruction) {
+    auto instruction = protos::pbzero::VmInstruction::Decoder(*it_instruction);
+    auto status = ParseInstruction(instruction);
+
+    if (status.IsAbort()) {
+      PROTOVM_RETURN(status, "instruction[%d]", instruction_index);
+    }
+
+    if (status.IsError()) {
+      using AbortLevel = perfetto::protos::pbzero::VmInstruction::AbortLevel;
+      auto abort_level =
+          instruction.has_abort_level()
+              ? static_cast<AbortLevel>(instruction.abort_level())
+              : AbortLevel::SKIP_CURRENT_INSTRUCTION_AND_BREAK_OUTER;
+      if (abort_level == AbortLevel::SKIP_CURRENT_INSTRUCTION_AND_BREAK_OUTER) {
+        return StatusOr<void>::Error();
+      }
+      if (abort_level == AbortLevel::ABORT) {
+        PROTOVM_ABORT(
+            "instruction[%d]: returned status = error and instruction's "
+            "abort level = 'abort'",
+            instruction_index);
+      }
+    }
+
+    ++instruction_index;
+  }
+
+  return StatusOr<void>::Ok();
 }
 
-// Must not be called from the SDK's internal thread.
-void TracingMuxerImpl::StartupTracingSessionImpl::AbortBlocking() {
-  auto* muxer = muxer_;
-  auto session_id = session_id_;
-  auto backend_type = backend_type_;
-  PERFETTO_CHECK(!muxer->task_runner_->RunsTasksOnCurrentThread());
-  base::WaitableEvent event;
-  muxer->task_runner_->PostTask([muxer, session_id, backend_type, &event] {
-    muxer->AbortStartupTracingSession(session_id, backend_type);
-    event.Notify();
-  });
-  event.Wait();
+StatusOr<void> Parser::ParseInstruction(
+    const protos::pbzero::VmInstruction::Decoder& instruction) {
+  if (instruction.has_select()) {
+    auto status = ParseSelect(instruction);
+    PROTOVM_RETURN(status, "select");
+  }
+
+  if (instruction.has_reg_load()) {
+    auto status = ParseRegLoad(instruction);
+    PROTOVM_RETURN_IF_NOT_OK(status, "reg_load");
+  } else if (instruction.has_del()) {
+    auto status = executor_->Delete(&cursors_.dst);
+    PROTOVM_RETURN_IF_NOT_OK(status, "del");
+  } else if (instruction.has_merge()) {
+    auto status = executor_->Merge(&cursors_);
+    PROTOVM_RETURN_IF_NOT_OK(status, "merge");
+  } else if (instruction.has_set()) {
+    auto status = executor_->Set(&cursors_);
+    PROTOVM_RETURN_IF_NOT_OK(status, "set");
+  } else {
+    PROTOVM_ABORT("Unsupported instruction");
+  }
+
+  return ParseInstructions(instruction.nested_instructions());
 }
 
-// ----- End of TracingMuxerImpl::StartupTracingSessionImpl
+StatusOr<void> Parser::ParseRegLoad(
+    const protos::pbzero::VmInstruction::Decoder& instruction) {
+  auto saved_selected = cursors_.selected;
 
-// static
-TracingMuxer* TracingMuxer::instance_ = TracingMuxerFake::Get();
+  protos::pbzero::VmOpRegLoad::Decoder reg_load(instruction.reg_load());
+  cursors_.selected = !reg_load.has_cursor()
+                          ? CursorEnum::VM_CURSOR_SRC
+                          : static_cast<CursorEnum>(reg_load.cursor());
+  auto status = executor_->WriteRegister(
+      cursors_, static_cast<uint8_t>(reg_load.dst_register()));
 
-// This is called by perfetto::Tracing::Initialize().
-// Can be called on any thread. Typically, but not necessarily, that will be
-// the embedder's main thread.
-TracingMuxerImpl::TracingMuxerImpl(const TracingInitArgs& args)
-    : TracingMuxer(args.platform ? args.platform
-                                 : Platform::GetDefaultPlatform()) {
-  PERFETTO_DETACH_FROM_THREAD(thread_checker_);
-  instance_ = this;
+  cursors_.selected = saved_selected;
 
-  // Create the thread where muxer, producers and service will live.
-  Platform::CreateTaskRunnerArgs tr_args{/*name_for_debugging=*/"TracingMuxer"};
-  task_runner_.reset(new NonReentrantTaskRunner(
-      this, platform_->CreateTaskRunner(std::move(tr_args))));
+  PROTOVM_RETURN_IF_NOT_OK(status);
 
-  // Run the initializer on that thread.
-  task_runner_->PostTask([this, args] {
-    Initialize(args);
-    AddBackends(args);
-  });
+  return status;
 }
 
-void TracingMuxerImpl::Initialize(const TracingInitArgs& args) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);  // Rebind the thread checker.
+StatusOr<void> Parser::ParseSelect(
+    const protos::pbzero::VmInstruction::Decoder& instruction) {
+  auto saved_cursors = cursors_;
 
-  policy_ = args.tracing_policy;
-  supports_multiple_data_source_instances_ =
-      args.supports_multiple_data_source_instances;
+  protos::pbzero::VmOpSelect::Decoder select(instruction.select());
+  cursors_.selected = !select.has_cursor()
+                          ? CursorEnum::VM_CURSOR_SRC
+                          : static_cast<CursorEnum>(select.cursor());
+  cursors_.create_if_not_exist = select.create_if_not_exist();
 
-  // Fallback backend for producer creation for an unsupported backend type.
-  PERFETTO_CHECK(producer_backends_.empty());
-  AddProducerBackend(internal::TracingBackendFake::GetInstance(),
-                     BackendType::kUnspecifiedBackend, args);
-  // Fallback backend for consumer creation for an unsupported backend type.
-  // This backend simply fails any attempt to start a tracing session.
-  PERFETTO_CHECK(consumer_backends_.empty());
-  AddConsumerBackend(internal::TracingBackendFake::GetInstance(),
-                     BackendType::kUnspecifiedBackend);
+  if (cursors_.selected == CursorEnum::VM_CURSOR_SRC &&
+      cursors_.create_if_not_exist) {
+    PROTOVM_ABORT(
+        "incompatible params: src cursor (read only) + create_if_not_exist");
+  }
+
+  auto status = ParseSelectRec(instruction, select.relative_path());
+  cursors_ = saved_cursors;
+
+  return status;
 }
 
-void TracingMuxerImpl::AddConsumerBackend(TracingConsumerBackend* backend,
-                                          BackendType type) {
-  if (!backend) {
-    // We skip the log in release builds because the *_backend_fake.cc code
-    // has already an ELOG before returning a nullptr.
-    PERFETTO_DLOG("Consumer backend creation failed, type %d",
-                  static_cast<int>(type));
-    return;
-  }
-  // Keep the backends sorted by type.
-  auto it =
-      std::upper_bound(consumer_backends_.begin(), consumer_backends_.end(),
-                       type, CompareBackendByType<RegisteredConsumerBackend>());
-  it = consumer_backends_.emplace(it);
+StatusOr<void> Parser::ParseSelectRec(
+    const protos::pbzero::VmInstruction::Decoder& instruction,
+    protozero::RepeatedFieldIterator<protozero::ConstBytes> it_path_component) {
+  protos::pbzero::VmOpSelect::Decoder select(instruction.select());
+
+  bool has_entered_all_path_components = !it_path_component;
+  if (has_entered_all_path_components) {
+    return ParseInstructions(instruction.nested_instructions());
+  }
+
+  auto curr_component =
+      protos::pbzero::VmOpSelect::PathComponent::Decoder(*it_path_component);
+  ++it_path_component;
+
+  std::optional<protos::pbzero::VmOpSelect::PathComponent::Decoder>
+      next_component =
+          it_path_component
+              ? std::make_optional(
+                    protos::pbzero::VmOpSelect::PathComponent::Decoder(
+                        *it_path_component))
+              : std::nullopt;
+
+  if (!curr_component.has_field_id()) {
+    PROTOVM_ABORT("Invalid path. Expected path component with field_id.");
+  }
+
+  // iterate repeated field
+  if (curr_component.is_repeated()) {
+    if (cursors_.selected == CursorEnum::VM_CURSOR_SRC) {
+      auto status_or_it = executor_->IterateRepeatedField(
+          &cursors_.src, curr_component.field_id());
+      PROTOVM_RETURN_IF_NOT_OK(status_or_it, "iterate repeated field (id = %d)",
+                               static_cast<int>(curr_component.field_id()));
+      int index = 0;
+      for (auto it = *status_or_it; it; ++it) {
+        cursors_.src = *it;
+        auto status = ParseSelectRec(instruction, it_path_component);
+        PROTOVM_RETURN_IF_NOT_OK(status, "repeated field (id = %d, index = %d)",
+                                 static_cast<int>(curr_component.field_id()),
+                                 index);
+        ++index;
+      }
+    } else if (cursors_.selected == CursorEnum::VM_CURSOR_DST) {
+      auto status_or_it = executor_->IterateRepeatedField(
+          &cursors_.dst, curr_component.field_id());
+      PROTOVM_RETURN_IF_NOT_OK(status_or_it, "iterate repeated field (id = %d)",
+                               static_cast<int>(curr_component.field_id()));
+      int index = 0;
+      for (auto it = *status_or_it; it; ++it) {
+        cursors_.dst = it.GetCursor();
+        auto status = ParseSelectRec(instruction, it_path_component);
+        PROTOVM_RETURN_IF_NOT_OK(status, "repeated field (id = %d, index = %d)",
+                                 static_cast<int>(curr_component.field_id()),
+                                 index);
+        ++index;
+      }
+    } else {
+      PROTOVM_ABORT(
+          "Iteration over selected cursor (%d) is not supported. Should be "
+          "either SRC or DST cursor.",
+          static_cast<int>(cursors_.selected));
+    }
+    return StatusOr<void>::Ok();
+  }
+
+  // enter indexed repeated field
+  if (next_component && next_component->has_array_index()) {
+    ++it_path_component;
+    auto status_enter = executor_->EnterRepeatedFieldAt(
+        &cursors_, curr_component.field_id(), next_component->array_index());
+    PROTOVM_RETURN_IF_NOT_OK(status_enter, "enter indexed repeated field");
+    auto status_select = ParseSelectRec(instruction, it_path_component);
+    PROTOVM_RETURN(status_select, "repeated field (id = %d, index = %d)",
+                   static_cast<int>(curr_component.field_id()),
+                   static_cast<int>(next_component->array_index()));
+  }
+
+  // enter mapped repeated field
+  if (next_component && next_component->has_map_key_field_id()) {
+    ++it_path_component;
+    if (!next_component->has_register_to_match()) {
+      PROTOVM_ABORT(
+          "enter mapped repeated field: expected field 'register_to_match'");
+    }
+    auto reg_id = static_cast<uint8_t>(next_component->register_to_match());
+    auto key = executor_->ReadRegister(reg_id);
+    PROTOVM_RETURN_IF_NOT_OK(key, "enter mapped repeated field");
+    auto status_enter = executor_->EnterRepeatedFieldByKey(
+        &cursors_, curr_component.field_id(),
+        next_component->map_key_field_id(), static_cast<uint32_t>(*key));
+    PROTOVM_RETURN_IF_NOT_OK(status_enter, "enter mapped repeated field");
+    auto status_select = ParseSelectRec(instruction, it_path_component);
+    PROTOVM_RETURN(status_select, "mapped repeated field (id = %d, key = %d)",
+                   static_cast<int>(curr_component.field_id()),
+                   static_cast<int>(*key));
+  }
+
+  // enter field
+  auto status = executor_->EnterField(&cursors_, curr_component.field_id());
+  PROTOVM_RETURN_IF_NOT_OK(status, "enter field (id = %d)",
+                           static_cast<int>(curr_component.field_id()));
+
+  return ParseSelectRec(instruction, it_path_component);
+}
+
+}  // namespace protovm
+}  // namespace perfetto
+// gen_amalgamated begin source: src/protovm/ro_cursor.cc
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-  RegisteredConsumerBackend& rb = *it;
-  rb.backend = backend;
-  rb.type = type;
+// gen_amalgamated expanded: #include "src/protovm/ro_cursor.h"
+
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protovm {
+
+RoCursor::RepeatedFieldIterator::RepeatedFieldIterator()
+    : decoder_{protozero::ConstBytes{}}, field_id_{0}, field_{Advance()} {
+  PERFETTO_DCHECK(!field_.valid());
 }
 
-void TracingMuxerImpl::AddProducerBackend(TracingProducerBackend* backend,
-                                          BackendType type,
-                                          const TracingInitArgs& args) {
-  if (!backend) {
-    // We skip the log in release builds because the *_backend_fake.cc code
-    // has already an ELOG before returning a nullptr.
-    PERFETTO_DLOG("Producer backend creation failed, type %d",
-                  static_cast<int>(type));
-    return;
-  }
-  TracingBackendId backend_id = producer_backends_.size();
-  // Keep the backends sorted by type.
-  auto it =
-      std::upper_bound(producer_backends_.begin(), producer_backends_.end(),
-                       type, CompareBackendByType<RegisteredProducerBackend>());
-  it = producer_backends_.emplace(it);
+RoCursor::RepeatedFieldIterator::RepeatedFieldIterator(
+    protozero::ProtoDecoder decoder,
+    uint32_t field_id)
+    : decoder_(decoder), field_id_(field_id), field_{Advance()} {}
 
-  RegisteredProducerBackend& rb = *it;
-  rb.backend = backend;
-  rb.id = backend_id;
-  rb.type = type;
-  rb.producer.reset(
-      new ProducerImpl(this, backend_id, args.shmem_batch_commits_duration_ms));
-  rb.producer_conn_args.producer = rb.producer.get();
-  rb.producer_conn_args.producer_name = platform_->GetCurrentProcessName();
-  rb.producer_conn_args.task_runner = task_runner_.get();
-  rb.producer_conn_args.shmem_size_hint_bytes = args.shmem_size_hint_kb * 1024;
-  rb.producer_conn_args.shmem_page_size_hint_bytes =
-      args.shmem_page_size_hint_kb * 1024;
-  rb.producer->Initialize(rb.backend->ConnectProducer(rb.producer_conn_args));
+RoCursor::RepeatedFieldIterator& RoCursor::RepeatedFieldIterator::operator++() {
+  field_ = Advance();
+  return *this;
 }
 
-TracingMuxerImpl::RegisteredProducerBackend*
-TracingMuxerImpl::FindProducerBackendById(TracingBackendId id) {
-  for (RegisteredProducerBackend& b : producer_backends_) {
-    if (b.id == id) {
-      return &b;
-    }
-  }
-  return nullptr;
+RoCursor RoCursor::RepeatedFieldIterator::operator*() {
+  return RoCursor(field_);
 }
 
-TracingMuxerImpl::RegisteredProducerBackend*
-TracingMuxerImpl::FindProducerBackendByType(BackendType type) {
-  for (RegisteredProducerBackend& b : producer_backends_) {
-    if (b.type == type) {
-      return &b;
-    }
-  }
-  return nullptr;
+RoCursor::RepeatedFieldIterator::operator bool() const {
+  return field_.valid();
 }
 
-TracingMuxerImpl::RegisteredConsumerBackend*
-TracingMuxerImpl::FindConsumerBackendByType(BackendType type) {
-  for (RegisteredConsumerBackend& b : consumer_backends_) {
-    if (b.type == type) {
-      return &b;
+protozero::Field RoCursor::RepeatedFieldIterator::Advance() {
+  auto field = decoder_.ReadField();
+  while (field) {
+    if (field.id() == field_id_) {
+      break;
     }
+    field = decoder_.ReadField();
   }
-  return nullptr;
+  return field;
 }
 
-void TracingMuxerImpl::AddBackends(const TracingInitArgs& args) {
-  if (args.backends & kSystemBackend) {
-    PERFETTO_CHECK(args.system_producer_backend_factory_);
-    if (FindProducerBackendByType(kSystemBackend) == nullptr) {
-      AddProducerBackend(args.system_producer_backend_factory_(),
-                         kSystemBackend, args);
-    }
-    if (args.enable_system_consumer) {
-      PERFETTO_CHECK(args.system_consumer_backend_factory_);
-      if (FindConsumerBackendByType(kSystemBackend) == nullptr) {
-        AddConsumerBackend(args.system_consumer_backend_factory_(),
-                           kSystemBackend);
-      }
-    }
-  }
+RoCursor::RoCursor() = default;
 
-  if (args.backends & kInProcessBackend) {
-    TracingBackend* b = nullptr;
-    if (FindProducerBackendByType(kInProcessBackend) == nullptr) {
-      if (!b) {
-        PERFETTO_CHECK(args.in_process_backend_factory_);
-        b = args.in_process_backend_factory_();
-      }
-      AddProducerBackend(b, kInProcessBackend, args);
-    }
-    if (FindConsumerBackendByType(kInProcessBackend) == nullptr) {
-      if (!b) {
-        PERFETTO_CHECK(args.in_process_backend_factory_);
-        b = args.in_process_backend_factory_();
-      }
-      AddConsumerBackend(b, kInProcessBackend);
+RoCursor::RoCursor(protozero::ConstBytes data) : data_{data} {}
+
+RoCursor::RoCursor(protozero::Field data) : data_{data} {}
+
+StatusOr<void> RoCursor::EnterField(uint32_t field_id) {
+  auto status_or_data = GetLengthDelimitedData();
+  PROTOVM_RETURN_IF_NOT_OK(status_or_data);
+
+  protozero::ProtoDecoder decoder(*status_or_data);
+
+  for (auto field = decoder.ReadField(); field.valid();
+       field = decoder.ReadField()) {
+    if (field.id() == field_id) {
+      data_ = field;
+      return StatusOr<void>::Ok();
     }
   }
 
-  if (args.backends & kCustomBackend) {
-    PERFETTO_CHECK(args.custom_backend);
-    if (FindProducerBackendByType(kCustomBackend) == nullptr) {
-      AddProducerBackend(args.custom_backend, kCustomBackend, args);
+  return StatusOr<void>::Error();
+}
+
+StatusOr<void> RoCursor::EnterRepeatedFieldAt(uint32_t field_id,
+                                              uint32_t index) {
+  auto status_or_data = GetLengthDelimitedData();
+  PROTOVM_RETURN_IF_NOT_OK(status_or_data);
+
+  protozero::ProtoDecoder decoder(*status_or_data);
+
+  uint32_t current_index = 0;
+
+  for (auto field = decoder.ReadField(); field.valid();
+       field = decoder.ReadField()) {
+    if (field.id() != field_id) {
+      continue;
     }
-    if (FindConsumerBackendByType(kCustomBackend) == nullptr) {
-      AddConsumerBackend(args.custom_backend, kCustomBackend);
+
+    if (current_index == index) {
+      data_ = field.as_bytes();
+      return StatusOr<void>::Ok();
     }
-  }
 
-  if (args.backends & ~(kSystemBackend | kInProcessBackend | kCustomBackend)) {
-    PERFETTO_FATAL("Unsupported tracing backend type");
+    ++current_index;
   }
+
+  return StatusOr<void>::Error();
 }
 
-// Can be called from any thread (but not concurrently).
-bool TracingMuxerImpl::RegisterDataSource(
-    const DataSourceDescriptor& descriptor,
-    DataSourceFactory factory,
-    DataSourceParams params,
-    DataSourceStaticState* static_state) {
-  // Ignore repeated registrations.
-  if (static_state->index != kMaxDataSources)
-    return true;
+StatusOr<RoCursor::RepeatedFieldIterator> RoCursor::IterateRepeatedField(
+    uint32_t field_id) const {
+  auto status_or_data = GetLengthDelimitedData();
+  PROTOVM_RETURN_IF_NOT_OK(status_or_data);
+  protozero::ProtoDecoder decoder(*status_or_data);
+  return RepeatedFieldIterator(decoder, field_id);
+}
 
-  uint32_t new_index = next_data_source_index_++;
-  if (new_index >= kMaxDataSources) {
-    PERFETTO_DLOG(
-        "RegisterDataSource failed: too many data sources already registered");
+bool RoCursor::IsScalar() const {
+  auto* field = std::get_if<protozero::Field>(&data_);
+  if (!field) {
     return false;
   }
 
-  // Initialize the static state.
-  static_assert(sizeof(static_state->instances[0]) >= sizeof(DataSourceState),
-                "instances[] size mismatch");
-  for (size_t i = 0; i < static_state->instances.size(); i++)
-    new (&static_state->instances[i]) DataSourceState{};
-
-  static_state->index = new_index;
+  return field->type() == protozero::proto_utils::ProtoWireType::kVarInt ||
+         field->type() == protozero::proto_utils::ProtoWireType::kFixed32 ||
+         field->type() == protozero::proto_utils::ProtoWireType::kFixed64;
+}
 
-  // Generate a semi-unique id for this data source.
-  base::Hasher hash;
-  hash.Update(reinterpret_cast<intptr_t>(static_state));
-  hash.Update(base::GetWallTimeNs().count());
-  static_state->id = hash.digest() ? hash.digest() : 1;
-
-  task_runner_->PostTask([this, descriptor, factory, static_state, params] {
-    data_sources_.emplace_back();
-    RegisteredDataSource& rds = data_sources_.back();
-    rds.descriptor = descriptor;
-    rds.factory = factory;
-    rds.supports_multiple_instances =
-        supports_multiple_data_source_instances_ &&
-        params.supports_multiple_instances;
-    rds.requires_callbacks_under_lock = params.requires_callbacks_under_lock;
-    rds.static_state = static_state;
+bool RoCursor::IsBytes() const {
+  if (std::holds_alternative<protozero::ConstBytes>(data_)) {
+    return true;
+  }
 
-    UpdateDataSourceOnAllBackends(rds, /*is_changed=*/false);
-  });
-  return true;
+  auto& field = std::get<protozero::Field>(data_);
+  return field.type() ==
+         protozero::proto_utils::ProtoWireType::kLengthDelimited;
 }
 
-// Can be called from any thread (but not concurrently).
-void TracingMuxerImpl::UpdateDataSourceDescriptor(
-    const DataSourceDescriptor& descriptor,
-    const DataSourceStaticState* static_state) {
-  task_runner_->PostTask([this, descriptor, static_state] {
-    for (auto& rds : data_sources_) {
-      if (rds.static_state == static_state) {
-        PERFETTO_CHECK(rds.descriptor.name() == descriptor.name());
-        rds.descriptor = descriptor;
-        rds.descriptor.set_id(static_state->id);
-        UpdateDataSourceOnAllBackends(rds, /*is_changed=*/true);
-        return;
-      }
-    }
-  });
+StatusOr<Scalar> RoCursor::GetScalar() const {
+  if (!IsScalar()) {
+    PROTOVM_ABORT("Attempted to access length-delimited field as a scalar");
+  }
+
+  auto& field = std::get<protozero::Field>(data_);
+  return Scalar{field.type(), field.as_uint64()};
 }
 
-// Can be called from any thread (but not concurrently).
-void TracingMuxerImpl::RegisterInterceptor(
-    const InterceptorDescriptor& descriptor,
-    InterceptorFactory factory,
-    InterceptorBase::TLSFactory tls_factory,
-    InterceptorBase::TracePacketCallback packet_callback) {
-  task_runner_->PostTask(
-      [this, descriptor, factory, tls_factory, packet_callback] {
-        // Ignore repeated registrations.
-        for (const auto& interceptor : interceptors_) {
-          if (interceptor.descriptor.name() == descriptor.name()) {
-            PERFETTO_DCHECK(interceptor.tls_factory == tls_factory);
-            PERFETTO_DCHECK(interceptor.packet_callback == packet_callback);
-            return;
-          }
-        }
-        // Only allow certain interceptors for now.
-        if (descriptor.name() != "test_interceptor" &&
-            descriptor.name() != "console") {
-          PERFETTO_ELOG(
-              "Interceptors are experimental. If you want to use them, please "
-              "get in touch with the project maintainers "
-              "(https://perfetto.dev/docs/contributing/"
-              "getting-started#community).");
-          return;
-        }
-        interceptors_.emplace_back();
-        RegisteredInterceptor& interceptor = interceptors_.back();
-        interceptor.descriptor = descriptor;
-        interceptor.factory = factory;
-        interceptor.tls_factory = tls_factory;
-        interceptor.packet_callback = packet_callback;
-      });
+StatusOr<protozero::ConstBytes> RoCursor::GetBytes() const {
+  if (std::holds_alternative<protozero::ConstBytes>(data_)) {
+    return std::get<protozero::ConstBytes>(data_);
+  }
+
+  auto& field = std::get<protozero::Field>(data_);
+  if (field.type() != protozero::proto_utils::ProtoWireType::kLengthDelimited) {
+    PROTOVM_ABORT(
+        "Attempted to access field as length-delimited but actual wire "
+        "type is "
+        "%u",
+        static_cast<uint32_t>(field.type()));
+  }
+
+  return field.as_bytes();
 }
 
-void TracingMuxerImpl::ActivateTriggers(
-    const std::vector<std::string>& triggers,
-    uint32_t ttl_ms) {
-  base::TimeMillis expire_time =
-      base::GetWallTimeMs() + base::TimeMillis(ttl_ms);
-  task_runner_->PostTask([this, triggers, expire_time] {
-    for (RegisteredProducerBackend& backend : producer_backends_) {
-      if (backend.producer->connected_) {
-        backend.producer->service_->ActivateTriggers(triggers);
-      } else {
-        for (const std::string& trigger : triggers) {
-          backend.producer->on_connect_triggers_.emplace_back(trigger,
-                                                              expire_time);
-        }
-      }
+StatusOr<protozero::ConstBytes> RoCursor::GetLengthDelimitedData() const {
+  if (std::holds_alternative<protozero::Field>(data_)) {
+    auto& field = std::get<protozero::Field>(data_);
+    if (field.type() !=
+        protozero::proto_utils::ProtoWireType::kLengthDelimited) {
+      PROTOVM_ABORT(
+          "Attempted to access field as length-delimited, but actual "
+          "wire type is %u",
+          static_cast<uint32_t>(field.type()));
     }
-  });
+    return field.as_bytes();
+  }
+
+  return std::get<protozero::ConstBytes>(data_);
 }
 
-// Checks if there is any matching startup tracing data source instance for a
-// new SetupDataSource call. If so, moves the data source to this tracing
-// session (and its target buffer) and returns true, otherwise returns false.
-static bool MaybeAdoptStartupTracingInDataSource(
-    TracingBackendId backend_id,
-    uint32_t backend_connection_id,
-    DataSourceInstanceID instance_id,
-    const DataSourceConfig& cfg,
-    const std::vector<RegisteredDataSource>& data_sources) {
-  uint64_t startup_config_hash = ComputeStartupConfigHash(cfg);
+}  // namespace protovm
+}  // namespace perfetto
+// gen_amalgamated begin source: src/protovm/rw_proto.cc
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-  for (const auto& rds : data_sources) {
-    DataSourceStaticState* static_state = rds.static_state;
-    for (uint32_t i = 0; i < kMaxDataSourceInstances; i++) {
-      auto* internal_state = static_state->TryGet(i);
+// gen_amalgamated expanded: #include "src/protovm/rw_proto.h"
 
-      // TODO(eseckler): Instead of comparing config_hashes here, should we ask
-      // the data source instance for a compat check of the config?
-      if (internal_state &&
-          internal_state->startup_target_buffer_reservation.load(
-              std::memory_order_relaxed) &&
-          internal_state->data_source_instance_id == 0 &&
-          internal_state->backend_id == backend_id &&
-          internal_state->backend_connection_id == backend_connection_id &&
-          internal_state->startup_config_hash == startup_config_hash) {
-        PERFETTO_DLOG("Setting up data source %" PRIu64
-                      " %s by adopting it from a startup tracing session",
-                      instance_id, cfg.name().c_str());
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-        std::lock_guard<std::recursive_mutex> lock(internal_state->lock);
-        // Set the associations. The actual takeover happens in
-        // StartDataSource().
-        internal_state->data_source_instance_id = instance_id;
-        internal_state->buffer_id =
-            static_cast<internal::BufferId>(cfg.target_buffer());
-        internal_state->config_hash = ComputeConfigHash(cfg);
+namespace perfetto {
+namespace protovm {
 
-        // TODO(eseckler): Should the data souce config provided by the service
-        // be allowed to specify additional interceptors / additional data
-        // source params?
+RwProto::RwProto(Allocator* allocator)
+    : allocator_{allocator}, root_{Node::Empty{}} {}
 
-        return true;
-      }
-    }
-  }
-  return false;
+RwProto::~RwProto() {
+  allocator_->DeleteReferencedData(&root_);
 }
 
-// Called by the service of one of the backends.
-void TracingMuxerImpl::SetupDataSource(TracingBackendId backend_id,
-                                       uint32_t backend_connection_id,
-                                       DataSourceInstanceID instance_id,
-                                       const DataSourceConfig& cfg) {
-  PERFETTO_DLOG("Setting up data source %" PRIu64 " %s", instance_id,
-                cfg.name().c_str());
-  PERFETTO_DCHECK_THREAD(thread_checker_);
+RwProto::Cursor RwProto::GetRoot() {
+  return Cursor{&root_, allocator_};
+}
 
-  // First check if there is any matching startup tracing data source instance.
-  if (MaybeAdoptStartupTracingInDataSource(backend_id, backend_connection_id,
-                                           instance_id, cfg, data_sources_)) {
+void RwProto::Serialize(protozero::Message* proto) const {
+  if (root_.GetIf<Node::Empty>()) {
     return;
   }
-  uint64_t config_hash = ComputeConfigHash(cfg);
-
-  for (const auto& rds : data_sources_) {
-    if (rds.descriptor.name() != cfg.name())
-      continue;
-    DataSourceStaticState& static_state = *rds.static_state;
 
-    // If this data source is already active for this exact config, don't start
-    // another instance. This happens when we have several data sources with the
-    // same name, in which case the service sends one SetupDataSource event for
-    // each one. Since we can't map which event maps to which data source, we
-    // ensure each event only starts one data source instance.
-    // TODO(skyostil): Register a unique id with each data source to the service
-    // to disambiguate.
-    bool active_for_config = false;
-    for (uint32_t i = 0; i < kMaxDataSourceInstances; i++) {
-      if (!static_state.TryGet(i))
-        continue;
-      auto* internal_state =
-          reinterpret_cast<DataSourceState*>(&static_state.instances[i]);
-      if (internal_state->backend_id == backend_id &&
-          internal_state->config_hash == config_hash) {
-        active_for_config = true;
-        break;
-      }
-    }
-    if (active_for_config) {
-      PERFETTO_DLOG(
-          "Data source %s is already active with this config, skipping",
-          cfg.name().c_str());
-      continue;
-    }
-
-    SetupDataSourceImpl(rds, backend_id, backend_connection_id, instance_id,
-                        cfg, config_hash, /*startup_config_hash=*/0,
-                        /*startup_session_id=*/0);
+  if (auto* bytes = root_.GetIf<Node::Bytes>()) {
+    proto->AppendRawProtoBytes(bytes->data.get(), bytes->size);
     return;
   }
-}
 
-TracingMuxerImpl::FindDataSourceRes TracingMuxerImpl::SetupDataSourceImpl(
-    const RegisteredDataSource& rds,
-    TracingBackendId backend_id,
-    uint32_t backend_connection_id,
-    DataSourceInstanceID instance_id,
-    const DataSourceConfig& cfg,
-    uint64_t config_hash,
-    uint64_t startup_config_hash,
-    TracingSessionGlobalID startup_session_id) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  DataSourceStaticState& static_state = *rds.static_state;
+  auto* message = root_.GetIf<Node::Message>();
+  PERFETTO_DCHECK(message);
 
-  // If any bit is set in `static_state.valid_instances` then at least one
-  // other instance of data source is running.
-  if (!rds.supports_multiple_instances &&
-      static_state.valid_instances.load(std::memory_order_acquire) != 0) {
-    PERFETTO_ELOG(
-        "Failed to setup data source because some another instance of this "
-        "data source is already active");
-    return FindDataSourceRes();
+  for (auto it = message->field_id_to_node.begin(); it; ++it) {
+    auto field_id = static_cast<uint32_t>(it->key);
+    SerializeField(field_id, *it->value, proto);
   }
+}
 
-  for (uint32_t i = 0; i < kMaxDataSourceInstances; i++) {
-    // Find a free slot.
-    if (static_state.TryGet(i))
-      continue;
+void RwProto::SerializeField(uint32_t field_id,
+                             const Node& node,
+                             protozero::Message* proto) const {
+  if (node.GetIf<Node::Empty>()) {
+    return;
+  }
 
-    auto* internal_state =
-        reinterpret_cast<DataSourceState*>(&static_state.instances[i]);
-    std::unique_lock<std::recursive_mutex> lock(internal_state->lock);
-    static_assert(
-        std::is_same<decltype(internal_state->data_source_instance_id),
-                     DataSourceInstanceID>::value,
-        "data_source_instance_id type mismatch");
-    internal_state->muxer_id_for_testing = muxer_id_for_testing_;
+  if (auto* bytes = node.GetIf<Node::Bytes>()) {
+    proto->AppendBytes(field_id, bytes->data.get(), bytes->size);
+    return;
+  }
 
-    if (startup_session_id) {
-      RegisteredProducerBackend& backend = *FindProducerBackendById(backend_id);
-      uint16_t& last_reservation =
-          backend.producer->last_startup_target_buffer_reservation_;
-      if (last_reservation == std::numeric_limits<uint16_t>::max()) {
-        PERFETTO_ELOG(
-            "Startup buffer reservations exhausted, dropping data source");
-        return FindDataSourceRes();
-      }
-      internal_state->startup_target_buffer_reservation.store(
-          ++last_reservation, std::memory_order_relaxed);
-    } else {
-      internal_state->startup_target_buffer_reservation.store(
-          0, std::memory_order_relaxed);
+  if (auto* scalar = node.GetIf<Scalar>()) {
+    if (scalar->wire_type == protozero::proto_utils::ProtoWireType::kFixed32) {
+      proto->AppendFixed(field_id, static_cast<uint32_t>(scalar->value));
+      return;
     }
 
-    internal_state->backend_id = backend_id;
-    internal_state->backend_connection_id = backend_connection_id;
-    internal_state->data_source_instance_id = instance_id;
-    internal_state->buffer_id =
-        static_cast<internal::BufferId>(cfg.target_buffer());
-    internal_state->config_hash = config_hash;
-    internal_state->startup_session_id = startup_session_id;
-    internal_state->startup_config_hash = startup_config_hash;
-    internal_state->data_source = rds.factory();
-    internal_state->interceptor = nullptr;
-    internal_state->interceptor_id = 0;
-
-    if (cfg.has_interceptor_config()) {
-      for (size_t j = 0; j < interceptors_.size(); j++) {
-        if (cfg.interceptor_config().name() ==
-            interceptors_[j].descriptor.name()) {
-          PERFETTO_DLOG("Intercepting data source %" PRIu64
-                        " \"%s\" into \"%s\"",
-                        instance_id, cfg.name().c_str(),
-                        cfg.interceptor_config().name().c_str());
-          internal_state->interceptor_id = static_cast<uint32_t>(j + 1);
-          internal_state->interceptor = interceptors_[j].factory();
-          internal_state->interceptor->OnSetup({cfg});
-          break;
-        }
-      }
-      if (!internal_state->interceptor_id) {
-        PERFETTO_ELOG("Unknown interceptor configured for data source: %s",
-                      cfg.interceptor_config().name().c_str());
-      }
+    if (scalar->wire_type == protozero::proto_utils::ProtoWireType::kFixed64) {
+      proto->AppendFixed(field_id, static_cast<uint64_t>(scalar->value));
+      return;
     }
 
-    // This must be made at the end. See matching acquire-load in
-    // DataSource::Trace().
-    static_state.valid_instances.fetch_or(1 << i, std::memory_order_release);
-
-    DataSourceBase::SetupArgs setup_args;
-    setup_args.config = &cfg;
-    setup_args.internal_instance_index = i;
+    proto->AppendVarInt(field_id, scalar->value);
+    return;
+  }
 
-    if (!rds.requires_callbacks_under_lock)
-      lock.unlock();
-    internal_state->data_source->OnSetup(setup_args);
+  if (auto* message = node.GetIf<Node::Message>()) {
+    auto* message_proto =
+        proto->BeginNestedMessage<protozero::Message>(field_id);
 
-    return FindDataSourceRes(&static_state, internal_state, i,
-                             rds.requires_callbacks_under_lock);
+    for (auto it = message->field_id_to_node.begin(); it; ++it) {
+      auto message_field_id = static_cast<uint32_t>(it->key);
+      SerializeField(message_field_id, *it->value, message_proto);
+    }
   }
-  PERFETTO_ELOG(
-      "Maximum number of data source instances exhausted. "
-      "Dropping data source %" PRIu64,
-      instance_id);
-  return FindDataSourceRes();
-}
 
-// Called by the service of one of the backends.
-void TracingMuxerImpl::StartDataSource(TracingBackendId backend_id,
-                                       DataSourceInstanceID instance_id) {
-  PERFETTO_DLOG("Starting data source %" PRIu64, instance_id);
-  PERFETTO_DCHECK_THREAD(thread_checker_);
+  if (node.GetIf<Node::IndexedRepeatedField>() ||
+      node.GetIf<Node::MappedRepeatedField>()) {
+    const IntrusiveMap* map;
+    if (auto* indexed = node.GetIf<Node::IndexedRepeatedField>()) {
+      map = &indexed->index_to_node;
+    } else {
+      map = &node.GetIf<Node::MappedRepeatedField>()->key_to_node;
+    }
 
-  auto ds = FindDataSource(backend_id, instance_id);
-  if (!ds) {
-    PERFETTO_ELOG("Could not find data source to start");
-    return;
+    for (auto it = map->begin(); it; ++it) {
+      SerializeField(field_id, *it->value, proto);
+    }
   }
+}
 
-  // Check if the data source was already started for startup tracing.
-  uint16_t startup_reservation =
-      ds.internal_state->startup_target_buffer_reservation.load(
-          std::memory_order_relaxed);
-  if (startup_reservation) {
-    RegisteredProducerBackend& backend = *FindProducerBackendById(backend_id);
-    TracingSessionGlobalID session_id = ds.internal_state->startup_session_id;
-    auto session_it = std::find_if(
-        backend.startup_sessions.begin(), backend.startup_sessions.end(),
-        [session_id](const RegisteredStartupSession& session) {
-          return session.session_id == session_id;
-        });
-    PERFETTO_DCHECK(session_it != backend.startup_sessions.end());
+}  // namespace protovm
+}  // namespace perfetto
+// gen_amalgamated begin source: src/protovm/rw_proto_cursor.cc
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-    if (session_it->is_aborting) {
-      PERFETTO_DLOG("Data source %" PRIu64
-                    " was already aborted for startup tracing, not starting it",
-                    instance_id);
-      return;
-    }
+// gen_amalgamated expanded: #include "src/protovm/rw_proto_cursor.h"
 
-    PERFETTO_DLOG(
-        "Data source %" PRIu64
-        " was already started for startup tracing, binding its target buffer",
-        instance_id);
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 
-    backend.producer->service_->MaybeSharedMemoryArbiter()
-        ->BindStartupTargetBuffer(startup_reservation,
-                                  ds.internal_state->buffer_id);
+namespace perfetto {
+namespace protovm {
 
-    // The reservation ID can be used even after binding it, so there's no need
-    // for any barriers here - we just need atomicity.
-    ds.internal_state->startup_target_buffer_reservation.store(
-        0, std::memory_order_relaxed);
+RwProtoCursor::RepeatedFieldIterator::RepeatedFieldIterator()
+    : allocator_{nullptr}, it_{} {}
 
-    // TODO(eseckler): Should we reset incremental state at this point, or
-    // notify the data source some other way?
+RwProtoCursor::RepeatedFieldIterator::RepeatedFieldIterator(
+    Allocator* allocator,
+    IntrusiveMap::Iterator it)
+    : allocator_{allocator}, it_{it} {}
 
-    // The session should not have been fully bound yet (or aborted).
-    PERFETTO_DCHECK(session_it->num_unbound_data_sources > 0);
+RwProtoCursor::RepeatedFieldIterator&
+RwProtoCursor::RepeatedFieldIterator::RepeatedFieldIterator::operator++() {
+  ++it_;
+  return *this;
+}
 
-    session_it->num_unbound_data_sources--;
-    if (session_it->num_unbound_data_sources == 0) {
-      if (session_it->on_adopted)
-        task_runner_->PostTask(session_it->on_adopted);
-      backend.startup_sessions.erase(session_it);
-    }
-    return;
-  }
+RwProtoCursor RwProtoCursor::RepeatedFieldIterator::GetCursor() {
+  return RwProtoCursor{it_->value.get(), allocator_};
+}
 
-  StartDataSourceImpl(ds);
+RwProtoCursor::RepeatedFieldIterator::operator bool() const {
+  return static_cast<bool>(it_);
 }
 
-void TracingMuxerImpl::StartDataSourceImpl(const FindDataSourceRes& ds) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
+RwProtoCursor::RwProtoCursor() = default;
 
-  DataSourceBase::StartArgs start_args{};
-  start_args.internal_instance_index = ds.instance_idx;
+RwProtoCursor::RwProtoCursor(Node* node, Allocator* allocator)
+    : node_{node}, allocator_{allocator} {}
 
-  std::unique_lock<std::recursive_mutex> lock(ds.internal_state->lock);
-  if (ds.internal_state->interceptor)
-    ds.internal_state->interceptor->OnStart({});
-  ds.internal_state->trace_lambda_enabled.store(true,
-                                                std::memory_order_relaxed);
-  PERFETTO_DCHECK(ds.internal_state->data_source != nullptr);
+StatusOr<bool> RwProtoCursor::HasField(uint32_t field_id) {
+  PERFETTO_DCHECK(node_);
 
-  if (!ds.requires_callbacks_under_lock)
-    lock.unlock();
-  ds.internal_state->data_source->OnStart(start_args);
+  // Eagerly decompose bytes because the field being tested will be entered
+  // later anyways. See Executor::EnterField().
+  auto status = ConvertToMessageIfNeeded(node_);
+  PROTOVM_RETURN_IF_NOT_OK(status);
+  auto* message = node_->GetIf<Node::Message>();
+  bool found = static_cast<bool>(message->field_id_to_node.Find(field_id));
+  return found;
 }
 
-// Called by the service of one of the backends.
-void TracingMuxerImpl::StopDataSource_AsyncBegin(
-    TracingBackendId backend_id,
-    DataSourceInstanceID instance_id) {
-  PERFETTO_DLOG("Stopping data source %" PRIu64, instance_id);
-  PERFETTO_DCHECK_THREAD(thread_checker_);
+StatusOr<void> RwProtoCursor::EnterField(uint32_t field_id) {
+  PERFETTO_DCHECK(node_);
 
-  auto ds = FindDataSource(backend_id, instance_id);
-  if (!ds) {
-    PERFETTO_ELOG("Could not find data source to stop");
-    return;
+  auto status_or_it = FindOrCreateMessageField(node_, field_id);
+  PROTOVM_RETURN_IF_NOT_OK(status_or_it);
+  auto it = *status_or_it;
+
+  if (it->value->GetIf<Node::IndexedRepeatedField>()) {
+    PROTOVM_ABORT(
+        "Attempted to enter field (id=%u) as a simple field but it is an "
+        "indexed repeated field",
+        field_id);
   }
 
-  StopDataSource_AsyncBeginImpl(ds);
+  if (it->value->GetIf<Node::MappedRepeatedField>()) {
+    PROTOVM_ABORT(
+        "Attempted to enter field (id=%u) as a simple field but it is a "
+        "mapped repeated field",
+        field_id);
+  }
+
+  holding_map_and_node_ = {&node_->GetIf<Node::Message>()->field_id_to_node,
+                           std::addressof(*it)};
+  node_ = it->value.get();
+  return StatusOr<void>::Ok();
 }
 
-void TracingMuxerImpl::StopDataSource_AsyncBeginImpl(
-    const FindDataSourceRes& ds) {
-  TracingBackendId backend_id = ds.internal_state->backend_id;
-  uint32_t backend_connection_id = ds.internal_state->backend_connection_id;
-  DataSourceInstanceID instance_id = ds.internal_state->data_source_instance_id;
+StatusOr<void> RwProtoCursor::EnterRepeatedFieldAt(uint32_t field_id,
+                                                   uint32_t index) {
+  PERFETTO_DCHECK(node_);
 
-  StopArgsImpl stop_args{};
-  stop_args.internal_instance_index = ds.instance_idx;
-  stop_args.async_stop_closure = [this, backend_id, backend_connection_id,
-                                  instance_id, ds] {
-    // TracingMuxerImpl is long lived, capturing |this| is okay.
-    // The notification closure can be moved out of the StopArgs by the
-    // embedder to handle stop asynchronously. The embedder might then
-    // call the closure on a different thread than the current one, hence
-    // this nested PostTask().
-    task_runner_->PostTask(
-        [this, backend_id, backend_connection_id, instance_id, ds] {
-          StopDataSource_AsyncEnd(backend_id, backend_connection_id,
-                                  instance_id, ds);
-        });
-  };
+  auto status_or_message_field = FindOrCreateMessageField(node_, field_id);
+  PROTOVM_RETURN_IF_NOT_OK(status_or_message_field);
+  auto message_field = *status_or_message_field;
 
-  {
-    std::unique_lock<std::recursive_mutex> lock(ds.internal_state->lock);
-    if (ds.internal_state->interceptor)
-      ds.internal_state->interceptor->OnStop({});
+  auto status =
+      ConvertToIndexedRepeatedFieldIfNeeded(message_field->value.get());
+  PROTOVM_RETURN_IF_NOT_OK(status);
 
-    if (!ds.requires_callbacks_under_lock)
-      lock.unlock();
-    ds.internal_state->data_source->OnStop(stop_args);
-  }
+  auto status_or_repeated_field =
+      FindOrCreateIndexedRepeatedField(message_field->value.get(), index);
+  PROTOVM_RETURN_IF_NOT_OK(status_or_repeated_field);
 
-  // If the embedder hasn't called StopArgs.HandleStopAsynchronously() run the
-  // async closure here. In theory we could avoid the PostTask and call
-  // straight into CompleteDataSourceAsyncStop(). We keep that to reduce
-  // divergencies between the deferred-stop vs non-deferred-stop code paths.
-  if (stop_args.async_stop_closure)
-    std::move(stop_args.async_stop_closure)();
+  holding_map_and_node_ = {
+      &message_field->value->GetIf<Node::IndexedRepeatedField>()->index_to_node,
+      std::addressof(**status_or_repeated_field)};
+  node_ = (*status_or_repeated_field)->value.get();
+
+  return StatusOr<void>::Ok();
 }
 
-void TracingMuxerImpl::StopDataSource_AsyncEnd(TracingBackendId backend_id,
-                                               uint32_t backend_connection_id,
-                                               DataSourceInstanceID instance_id,
-                                               const FindDataSourceRes& ds) {
-  PERFETTO_DLOG("Ending async stop of data source %" PRIu64, instance_id);
-  PERFETTO_DCHECK_THREAD(thread_checker_);
+StatusOr<RwProtoCursor::RepeatedFieldIterator>
+RwProtoCursor::IterateRepeatedField(uint32_t field_id) {
+  PERFETTO_DCHECK(node_);
 
-  // Check that the data source instance is still active and was not modified
-  // while it was being stopped.
-  if (!ds.static_state->TryGet(ds.instance_idx) ||
-      ds.internal_state->backend_id != backend_id ||
-      ds.internal_state->backend_connection_id != backend_connection_id ||
-      ds.internal_state->data_source_instance_id != instance_id) {
-    PERFETTO_ELOG(
-        "Async stop of data source %" PRIu64
-        " failed. This might be due to calling the async_stop_closure twice.",
-        instance_id);
-    return;
-  }
+  auto status_convertion_to_message = ConvertToMessageIfNeeded(node_);
+  PROTOVM_RETURN_IF_NOT_OK(status_convertion_to_message);
 
-  const uint32_t mask = ~(1 << ds.instance_idx);
-  ds.static_state->valid_instances.fetch_and(mask, std::memory_order_acq_rel);
+  auto* message = node_->GetIf<Node::Message>();
+  auto it = message->field_id_to_node.Find(field_id);
 
-  // Take the mutex to prevent that the data source is in the middle of
-  // a Trace() execution where it called GetDataSourceLocked() while we
-  // destroy it.
-  uint16_t startup_buffer_reservation;
-  TracingSessionGlobalID startup_session_id;
-  {
-    std::lock_guard<std::recursive_mutex> guard(ds.internal_state->lock);
-    ds.internal_state->trace_lambda_enabled.store(false,
-                                                  std::memory_order_relaxed);
-    ds.internal_state->data_source.reset();
-    ds.internal_state->interceptor.reset();
-    startup_buffer_reservation =
-        ds.internal_state->startup_target_buffer_reservation.load(
-            std::memory_order_relaxed);
-    startup_session_id = ds.internal_state->startup_session_id;
+  if (!it) {
+    return RepeatedFieldIterator{};
   }
 
-  // The other fields of internal_state are deliberately *not* cleared.
-  // See races-related comments of DataSource::Trace().
+  auto* field = it->value.get();
+  auto status_convertion_to_repeated_field =
+      ConvertToIndexedRepeatedFieldIfNeeded(field);
+  PROTOVM_RETURN_IF_NOT_OK(status_convertion_to_repeated_field);
 
-  TracingMuxer::generation_++;
+  return RepeatedFieldIterator{
+      allocator_,
+      field->GetIf<Node::IndexedRepeatedField>()->index_to_node.begin()};
+}
 
-  // |producer_backends_| is append-only, Backend instances are always valid.
-  PERFETTO_CHECK(backend_id < producer_backends_.size());
-  RegisteredProducerBackend& backend = *FindProducerBackendById(backend_id);
-  ProducerImpl* producer = backend.producer.get();
-  if (!producer)
-    return;
+StatusOr<void> RwProtoCursor::EnterRepeatedFieldByKey(uint32_t field_id,
+                                                      uint32_t map_key_field_id,
+                                                      uint64_t key) {
+  PERFETTO_DCHECK(node_);
 
-  // If the data source instance still has a startup buffer reservation, it was
-  // only active for startup tracing and never started by the service. Discard
-  // the startup buffer reservation.
-  if (startup_buffer_reservation) {
-    PERFETTO_DCHECK(startup_session_id);
+  auto status_or_message_field = FindOrCreateMessageField(node_, field_id);
+  PROTOVM_RETURN_IF_NOT_OK(status_or_message_field);
+  auto message_field = *status_or_message_field;
 
-    if (producer->service_ && producer->service_->MaybeSharedMemoryArbiter()) {
-      producer->service_->MaybeSharedMemoryArbiter()
-          ->AbortStartupTracingForReservation(startup_buffer_reservation);
-    }
+  auto status_conversion = ConvertToMappedRepeatedFieldIfNeeded(
+      message_field->value.get(), map_key_field_id);
+  PROTOVM_RETURN_IF_NOT_OK(status_conversion);
 
-    auto session_it = std::find_if(
-        backend.startup_sessions.begin(), backend.startup_sessions.end(),
-        [startup_session_id](const RegisteredStartupSession& session) {
-          return session.session_id == startup_session_id;
-        });
+  auto status_or_repeated_field =
+      FindOrCreateMappedRepeatedField(message_field->value.get(), key);
+  PROTOVM_RETURN_IF_NOT_OK(status_or_repeated_field);
 
-    // Session should not be removed until abortion of all data source instances
-    // is complete.
-    PERFETTO_DCHECK(session_it != backend.startup_sessions.end());
+  holding_map_and_node_ = {
+      &message_field->value->GetIf<Node::MappedRepeatedField>()->key_to_node,
+      std::addressof(**status_or_repeated_field)};
+  node_ = (*status_or_repeated_field)->value.get();
 
-    session_it->num_aborting_data_sources--;
-    if (session_it->num_aborting_data_sources == 0) {
-      if (session_it->on_aborted)
-        task_runner_->PostTask(session_it->on_aborted);
+  return StatusOr<void>::Ok();
+}
 
-      backend.startup_sessions.erase(session_it);
-    }
-  }
+StatusOr<Scalar> RwProtoCursor::GetScalar() const {
+  PERFETTO_DCHECK(node_);
 
-  if (producer->connected_) {
-    // Flush any commits that might have been batched by SharedMemoryArbiter.
-    producer->service_->MaybeSharedMemoryArbiter()
-        ->FlushPendingCommitDataRequests();
-    if (instance_id)
-      producer->service_->NotifyDataSourceStopped(instance_id);
+  auto* scalar = node_->GetIf<Scalar>();
+  if (!scalar) {
+    PROTOVM_ABORT("Attempted \"get scalar\" operation but node has type %s",
+                  node_->GetTypeName());
   }
-  producer->SweepDeadServices();
+  return *scalar;
 }
 
-void TracingMuxerImpl::ClearDataSourceIncrementalState(
-    TracingBackendId backend_id,
-    DataSourceInstanceID instance_id) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  PERFETTO_DLOG("Clearing incremental state for data source %" PRIu64,
-                instance_id);
-  auto ds = FindDataSource(backend_id, instance_id);
-  if (!ds) {
-    PERFETTO_ELOG("Could not find data source to clear incremental state for");
-    return;
+StatusOr<void> RwProtoCursor::SetBytes(protozero::ConstBytes data) {
+  PERFETTO_DCHECK(node_);
+
+  if (bool is_compatible = node_->GetIf<Node::Empty>() ||
+                           node_->GetIf<Node::Bytes>() ||
+                           node_->GetIf<Node::Message>();
+      !is_compatible) {
+    PROTOVM_ABORT("Attempted \"set bytes\" operation but node has type %s",
+                  node_->GetTypeName());
   }
 
-  DataSourceBase::ClearIncrementalStateArgs clear_incremental_state_args;
-  clear_incremental_state_args.internal_instance_index = ds.instance_idx;
-  {
-    std::unique_lock<std::recursive_mutex> lock;
-    if (ds.requires_callbacks_under_lock)
-      lock = std::unique_lock<std::recursive_mutex>(ds.internal_state->lock);
-    ds.internal_state->data_source->WillClearIncrementalState(
-        clear_incremental_state_args);
+  auto status_or_bytes = allocator_->AllocateAndCopyBytes(data);
+  PROTOVM_RETURN_IF_NOT_OK(status_or_bytes);
+
+  allocator_->DeleteReferencedData(node_);
+  node_->value = Node::Bytes{std::move(*status_or_bytes)};
+
+  return StatusOr<void>::Ok();
+}
+
+StatusOr<void> RwProtoCursor::SetScalar(Scalar scalar) {
+  PERFETTO_DCHECK(node_);
+
+  if (bool is_compatible =
+          node_->GetIf<Node::Empty>() || node_->GetIf<Scalar>();
+      !is_compatible) {
+    PROTOVM_ABORT("Attempted \"set scalar\" operation but node has type %s",
+                  node_->GetTypeName());
   }
 
-  // Make DataSource::TraceContext::GetIncrementalState() eventually notice that
-  // the incremental state should be cleared.
-  ds.static_state->incremental_state_generation.fetch_add(
-      1, std::memory_order_relaxed);
+  node_->value = scalar;
+  return StatusOr<void>::Ok();
 }
 
-void TracingMuxerImpl::SyncProducersForTesting() {
-  std::mutex mutex;
-  std::condition_variable cv;
+StatusOr<void> RwProtoCursor::Merge(protozero::ConstBytes data) {
+  PERFETTO_DCHECK(node_);
 
-  // IPC-based producers don't report connection errors explicitly for each
-  // command, but instead with an asynchronous callback
-  // (ProducerImpl::OnDisconnected). This means that the sync command below
-  // may have completed but failed to reach the service because of a
-  // disconnection, but we can't tell until the disconnection message comes
-  // through. To guard against this, we run two whole rounds of sync round-trips
-  // before returning; the first one will detect any disconnected producers and
-  // the second one will ensure any reconnections have completed and all data
-  // sources are registered in the service again.
-  for (size_t i = 0; i < 2; i++) {
-    size_t countdown = std::numeric_limits<size_t>::max();
-    task_runner_->PostTask([this, &mutex, &cv, &countdown] {
-      {
-        std::unique_lock<std::mutex> countdown_lock(mutex);
-        countdown = producer_backends_.size();
-      }
-      for (auto& backend : producer_backends_) {
-        auto* producer = backend.producer.get();
-        producer->service_->Sync([&mutex, &cv, &countdown] {
-          std::unique_lock<std::mutex> countdown_lock(mutex);
-          countdown--;
-          cv.notify_one();
-        });
-      }
-    });
+  if (bool is_compatible = node_->GetIf<Node::Empty>() ||
+                           node_->GetIf<Node::Message>() ||
+                           node_->GetIf<Node::Bytes>();
+      !is_compatible) {
+    PROTOVM_ABORT("Attempted MERGE operation but node has type %s",
+                  node_->GetTypeName());
+  }
 
-    {
-      std::unique_lock<std::mutex> countdown_lock(mutex);
-      cv.wait(countdown_lock, [&countdown] { return !countdown; });
-    }
+  if (data.size == 0) {
+    return StatusOr<void>::Ok();
   }
 
-  // Check that all producers are indeed connected.
-  bool done = false;
-  bool all_producers_connected = true;
-  task_runner_->PostTask([this, &mutex, &cv, &done, &all_producers_connected] {
-    for (auto& backend : producer_backends_)
-      all_producers_connected &= backend.producer->connected_;
-    std::unique_lock<std::mutex> lock(mutex);
-    done = true;
-    cv.notify_one();
-  });
+  auto status_convertion = ConvertToMessageIfNeeded(node_);
+  PROTOVM_RETURN_IF_NOT_OK(status_convertion);
+  auto* message = node_->GetIf<Node::Message>();
 
-  {
-    std::unique_lock<std::mutex> lock(mutex);
-    cv.wait(lock, [&done] { return done; });
-  }
-  PERFETTO_DCHECK(all_producers_connected);
-}
+  protozero::ProtoDecoder decoder(data);
 
-void TracingMuxerImpl::DestroyStoppedTraceWritersForCurrentThread() {
-  // Iterate across all possible data source types.
-  auto cur_generation = generation_.load(std::memory_order_acquire);
-  auto* root_tls = GetOrCreateTracingTLS();
+  for (auto field = decoder.ReadField(); field.valid();
+       field = decoder.ReadField()) {
+    auto status_or_map_value = CreateNodeFromField(field);
+    PROTOVM_RETURN_IF_NOT_OK(status_or_map_value);
 
-  auto destroy_stopped_instances = [](DataSourceThreadLocalState& tls) {
-    // |tls| has a vector of per-data-source-instance thread-local state.
-    DataSourceStaticState* static_state = tls.static_state;
-    if (!static_state)
-      return;  // Slot not used.
+    auto it = message->field_id_to_node.Find(field.id());
 
-    // Iterate across all possible instances for this data source.
-    for (uint32_t inst = 0; inst < kMaxDataSourceInstances; inst++) {
-      DataSourceInstanceThreadLocalState& ds_tls = tls.per_instance[inst];
-      if (!ds_tls.trace_writer)
-        continue;
+    if (!it) {
+      auto status_or_it = MapInsert(&message->field_id_to_node, field.id(),
+                                    std::move(*status_or_map_value));
+      PROTOVM_RETURN_IF_NOT_OK(status_or_it);
+      continue;
+    }
 
-      DataSourceState* ds_state = static_state->TryGet(inst);
-      if (ds_state &&
-          ds_state->muxer_id_for_testing == ds_tls.muxer_id_for_testing &&
-          ds_state->backend_id == ds_tls.backend_id &&
-          ds_state->backend_connection_id == ds_tls.backend_connection_id &&
-          ds_state->startup_target_buffer_reservation.load(
-              std::memory_order_relaxed) ==
-              ds_tls.startup_target_buffer_reservation &&
-          ds_state->buffer_id == ds_tls.buffer_id &&
-          ds_state->data_source_instance_id == ds_tls.data_source_instance_id) {
-        continue;
-      }
+    if (it->value->GetIf<Node::MappedRepeatedField>()) {
+      PROTOVM_ABORT(
+          "Merge operation of mapped repeated field is not supported (field id "
+          "= %u)",
+          field.id());
+    }
 
-      // The DataSource instance has been destroyed or recycled.
-      ds_tls.Reset();  // Will also destroy the |ds_tls.trace_writer|.
+    if (auto* indexed_fields = it->value->GetIf<Node::IndexedRepeatedField>()) {
+      // Implements merge semantics for repeated fields: all existing fields are
+      // removed and replaced with the newly received fields.
+      if (!indexed_fields->has_been_merged) {
+        // Optimization opportunity: reuse the existing nodes to avoid N
+        // allocation-deallocation pairs, where N is the number of newly
+        // received repeated fields.
+        allocator_->DeleteReferencedData(it->value.get());
+        indexed_fields->has_been_merged = true;
+      }
+      MapInsert(&indexed_fields->index_to_node,
+                indexed_fields->index_to_node.Size(),
+                std::move(*status_or_map_value));
+      continue;
     }
-  };
 
-  for (size_t ds_idx = 0; ds_idx < kMaxDataSources; ds_idx++) {
-    // |tls| has a vector of per-data-source-instance thread-local state.
-    DataSourceThreadLocalState& tls = root_tls->data_sources_tls[ds_idx];
-    destroy_stopped_instances(tls);
+    // Optimization oppurtunity: reuse the existing node to avoid one
+    // allocation-deallocation pair
+    allocator_->Delete(it->value.release());
+    it->value = std::move(*status_or_map_value);
   }
-  destroy_stopped_instances(root_tls->track_event_tls);
-  root_tls->generation = cur_generation;
+
+  // Reset the merge state of repeated fields
+  for (auto& field : message->field_id_to_node) {
+    if (auto* indexed_fields =
+            field.value->GetIf<Node::IndexedRepeatedField>()) {
+      indexed_fields->has_been_merged = false;
+    }
+  }
+
+  return StatusOr<void>::Ok();
 }
 
-// Called both when a new data source is registered or when a new backend
-// connects. In both cases we want to be sure we reflected the data source
-// registrations on the backends.
-void TracingMuxerImpl::UpdateDataSourcesOnAllBackends() {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  for (RegisteredDataSource& rds : data_sources_) {
-    UpdateDataSourceOnAllBackends(rds, /*is_changed=*/false);
+StatusOr<void> RwProtoCursor::Delete() {
+  PERFETTO_DCHECK(node_);
+
+  bool is_root_node = !holding_map_and_node_.first;
+  if (is_root_node) {
+    node_->value = Node::Empty{};
+    return StatusOr<void>::Ok();
   }
+
+  auto [holding_map, map_node] = holding_map_and_node_;
+  PERFETTO_DCHECK(holding_map);
+  PERFETTO_DCHECK(map_node);
+  holding_map->Remove(*map_node);
+  allocator_->Delete(&GetOuterNode(*map_node));
+
+  node_ = nullptr;  // Delete operation invalidates cursor
+
+  return StatusOr<void>::Ok();
 }
 
-void TracingMuxerImpl::UpdateDataSourceOnAllBackends(RegisteredDataSource& rds,
-                                                     bool is_changed) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  for (RegisteredProducerBackend& backend : producer_backends_) {
-    // We cannot call RegisterDataSource on the backend before it connects.
-    if (!backend.producer->connected_)
-      continue;
+StatusOr<void> RwProtoCursor::ConvertToMessageIfNeeded(Node* node) {
+  if (node->GetIf<Node::Message>()) {
+    return StatusOr<void>::Ok();
+  }
 
-    PERFETTO_DCHECK(rds.static_state->index < kMaxDataSources);
-    bool is_registered = backend.producer->registered_data_sources_.test(
-        rds.static_state->index);
-    if (is_registered && !is_changed)
-      continue;
+  if (node->GetIf<Node::Empty>()) {
+    node->value = Node::Message{};
+    return StatusOr<void>::Ok();
+  }
 
-    rds.descriptor.set_will_notify_on_start(true);
-    rds.descriptor.set_will_notify_on_stop(true);
-    rds.descriptor.set_handles_incremental_state_clear(true);
-    rds.descriptor.set_id(rds.static_state->id);
-    if (is_registered) {
-      backend.producer->service_->UpdateDataSource(rds.descriptor);
-    } else {
-      backend.producer->service_->RegisterDataSource(rds.descriptor);
-    }
-    backend.producer->registered_data_sources_.set(rds.static_state->index);
+  auto* bytes = node->GetIf<Node::Bytes>();
+  if (!bytes) {
+    PROTOVM_ABORT("Attempted conversion to message but node has type %s",
+                  node->GetTypeName());
   }
-}
 
-void TracingMuxerImpl::SetupTracingSession(
-    TracingSessionGlobalID session_id,
-    const std::shared_ptr<TraceConfig>& trace_config,
-    base::ScopedFile trace_fd) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  PERFETTO_CHECK(!trace_fd || trace_config->write_into_file());
+  Node::Message message;
 
-  auto* consumer = FindConsumer(session_id);
-  if (!consumer)
-    return;
+  protozero::ProtoDecoder decoder(protozero::ConstBytes{
+      static_cast<const uint8_t*>(bytes->data.get()), bytes->size});
 
-  consumer->trace_config_ = trace_config;
-  if (trace_fd)
-    consumer->trace_fd_ = std::move(trace_fd);
+  for (auto field = decoder.ReadField(); field.valid();
+       field = decoder.ReadField()) {
+    auto status_or_map_value = CreateNodeFromField(field);
+    if (!status_or_map_value.IsOk()) {
+      allocator_->DeleteReferencedData(&message);
+      PROTOVM_RETURN(status_or_map_value);
+    }
 
-  if (!consumer->connected_)
-    return;
+    auto it = message.field_id_to_node.Find(field.id());
 
-  // Only used in the deferred start mode.
-  if (trace_config->deferred_start()) {
-    consumer->service_->EnableTracing(*trace_config,
-                                      std::move(consumer->trace_fd_));
+    // First occurrence of this field id. Just insert a new field into the
+    // map.
+    if (!it) {
+      auto status_or_it = MapInsert(&message.field_id_to_node, field.id(),
+                                    std::move(*status_or_map_value));
+      if (!status_or_it.IsOk()) {
+        allocator_->DeleteReferencedData(&message);
+        PROTOVM_RETURN(status_or_it, "Insert message field (id = %u)",
+                       field.id());
+      }
+      continue;
+    }
+
+    // Nth occurrence of this field id:
+    // 1. Make sure we have an IndexedRepeatedField node
+    // 2. Append into the IndexedRepeatedField's map
+    auto status_conversion =
+        ConvertToIndexedRepeatedFieldIfNeeded(it->value.get());
+    if (!status_conversion.IsOk()) {
+      allocator_->DeleteReferencedData(&message);
+      allocator_->Delete(status_or_map_value->release());
+      PROTOVM_RETURN(status_conversion);
+    }
+
+    auto& index_to_node =
+        it->value->GetIf<Node::IndexedRepeatedField>()->index_to_node;
+    auto status_or_it = MapInsert(&index_to_node, index_to_node.Size(),
+                                  std::move(*status_or_map_value));
+    if (!status_or_it.IsOk()) {
+      allocator_->DeleteReferencedData(&message);
+      PROTOVM_RETURN(status_or_it,
+                     "Insert repeated field (id = %u, index = %d)", field.id(),
+                     static_cast<int>(index_to_node.Size()));
+    }
   }
-}
 
-void TracingMuxerImpl::StartTracingSession(TracingSessionGlobalID session_id) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
+  allocator_->DeleteReferencedData(node);
+  node->value = message;
 
-  auto* consumer = FindConsumer(session_id);
+  return StatusOr<void>::Ok();
+}
 
-  if (!consumer)
-    return;
+StatusOr<OwnedPtr<Node>> RwProtoCursor::CreateNodeFromField(
+    protozero::Field field) {
+  if (field.type() == protozero::proto_utils::ProtoWireType::kLengthDelimited) {
+    auto status_or_bytes = allocator_->AllocateAndCopyBytes(field.as_bytes());
+    PROTOVM_RETURN_IF_NOT_OK(status_or_bytes);
+    auto status_or_node =
+        allocator_->CreateNode<Node::Bytes>(std::move(*status_or_bytes));
+    if (!status_or_node.IsOk()) {
+      allocator_->DeleteReferencedData(&status_or_bytes.value());
+      PROTOVM_RETURN(status_or_node);
+    }
 
-  if (!consumer->trace_config_) {
-    PERFETTO_ELOG("Must call Setup(config) first");
-    return;
+    return std::move(*status_or_node);
   }
 
-  if (!consumer->connected_) {
-    consumer->start_pending_ = true;
-    return;
+  auto status_or_node =
+      allocator_->CreateNode<Scalar>(field.type(), field.as_uint64());
+  if (!status_or_node.IsOk()) {
+    PROTOVM_RETURN(status_or_node);
   }
 
-  consumer->start_pending_ = false;
-  if (consumer->trace_config_->deferred_start()) {
-    consumer->service_->StartTracing();
-  } else {
-    consumer->service_->EnableTracing(*consumer->trace_config_,
-                                      std::move(consumer->trace_fd_));
+  return std::move(*status_or_node);
+}
+
+StatusOr<void> RwProtoCursor::ConvertToMappedRepeatedFieldIfNeeded(
+    Node* node,
+    uint32_t map_key_field_id) {
+  if (node->GetIf<Node::MappedRepeatedField>()) {
+    return StatusOr<void>::Ok();
   }
 
-  // TODO implement support for the deferred-start + fast-triggering case.
-}
+  if (node->GetIf<Node::Empty>()) {
+    node->value = Node::MappedRepeatedField{};
+    return StatusOr<void>::Ok();
+  }
 
-void TracingMuxerImpl::ChangeTracingSessionConfig(
-    TracingSessionGlobalID session_id,
-    const TraceConfig& trace_config) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
+  // If the current node contains a message (either raw bytes or a decomposed
+  // Node::Message), convert it into a Node::MappedRepeatedField.
+  //
+  // The process is:
+  // 1. Extract the key (identified by 'map_key_field_id') from the message data
+  // within the current 'node'.
+  // 2. Allocate a new node. The original message content from the current node
+  // is moved into this new node.
+  // 3. Repurpose the current node, replacing it with an empty
+  // Node::MappedRepeatedField
+  //    (intrusive tree that stores message fields ordered by key).
+  // 4. Insert the new node (containing Node::Message) into the repurposed
+  // current node (Node::MappedRepeatedField) using the key extracted in step 1.
+  if (node->GetIf<Node::Bytes>() || node->GetIf<Node::Message>()) {
+    auto status_or_key = ReadScalarField(*node, map_key_field_id);
+    PROTOVM_RETURN_IF_NOT_OK(status_or_key);
+
+    auto status_or_map_value = allocator_->CreateNode<Node::Empty>();
+    PROTOVM_RETURN_IF_NOT_OK(status_or_map_value);
+
+    auto map_value = std::move(*status_or_map_value);
+    map_value->value = std::move(node->value);
+    node->value = Node::MappedRepeatedField{};
+
+    auto status_or_it =
+        MapInsert(&node->GetIf<Node::MappedRepeatedField>()->key_to_node,
+                  *status_or_key, std::move(map_value));
+    PROTOVM_RETURN(status_or_it);
+  }
+
+  // If the current node is a Node::IndexedRepeatedField (intrusive tree with
+  // message fields ordered by index), this block converts it into a
+  // Node::MappedRepeatedField (intrusive tree with message fields ordered by
+  // key).
+  //
+  // The process is:
+  // 1. Initialize an empty Node::MappedRepeatedField
+  // 2. For each field in the current node (Node::IndexedRepeatedField):
+  //    2.1. Extract the key (identified by 'map_key_field_id'). Note that the
+  //         iterated fields must be messages.
+  //    2.2. Remove the field from the current node
+  //         (Node::IndexedRepeatedField).
+  //    2.3. Insert the field into the Node::MappedRepeatedField using the key
+  //         extracted in step 2.1.
+  // 3. Assign the Node::MappedRepeatedField to the current node, i.e. repurpose
+  //    current node from Node::IndexedRepeatedField to
+  //    Node::MappedRepeatedField)
+  if (auto* indexed = node->GetIf<Node::IndexedRepeatedField>()) {
+    Node::MappedRepeatedField mapped_repeated_field;
 
-  auto* consumer = FindConsumer(session_id);
+    for (auto it = indexed->index_to_node.begin(); it;) {
+      auto& map_entry = *it;
+      auto& value_node = *it->value;
 
-  if (!consumer)
-    return;
+      it = indexed->index_to_node.Remove(it);
 
-  if (!consumer->trace_config_) {
-    // Changing the config is only supported for started sessions.
-    PERFETTO_ELOG("Must call Setup(config) and Start() first");
-    return;
-  }
+      auto status_or_key = ReadScalarField(value_node, map_key_field_id);
+      PROTOVM_RETURN_IF_NOT_OK(status_or_key);
 
-  consumer->trace_config_ = std::make_shared<TraceConfig>(trace_config);
-  if (consumer->connected_)
-    consumer->service_->ChangeTraceConfig(trace_config);
-}
+      map_entry.key = *status_or_key;
+      mapped_repeated_field.key_to_node.Insert(map_entry);
+    }
 
-void TracingMuxerImpl::FlushTracingSession(TracingSessionGlobalID session_id,
-                                           uint32_t timeout_ms,
-                                           std::function<void(bool)> callback) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  auto* consumer = FindConsumer(session_id);
-  if (!consumer || consumer->start_pending_ || consumer->stop_pending_ ||
-      !consumer->trace_config_) {
-    PERFETTO_ELOG("Flush() can be called only after Start() and before Stop()");
-    std::move(callback)(false);
-    return;
+    node->value = mapped_repeated_field;
+
+    return StatusOr<void>::Ok();
   }
 
-  consumer->service_->Flush(timeout_ms, std::move(callback));
+  PROTOVM_ABORT(
+      "Attempted to access field as MappedRepeatedField but node has type "
+      "%s",
+      node->GetTypeName());
 }
 
-void TracingMuxerImpl::StopTracingSession(TracingSessionGlobalID session_id) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  auto* consumer = FindConsumer(session_id);
-  if (!consumer)
-    return;
+StatusOr<void> RwProtoCursor::ConvertToIndexedRepeatedFieldIfNeeded(
+    Node* node) {
+  if (node->GetIf<Node::IndexedRepeatedField>()) {
+    return StatusOr<void>::Ok();
+  }
 
-  if (consumer->start_pending_) {
-    // If the session hasn't started yet, wait until it does before stopping.
-    consumer->stop_pending_ = true;
-    return;
+  if (node->GetIf<Node::MappedRepeatedField>()) {
+    PROTOVM_ABORT(
+        "Attempted \"convert to indexed repeated field\" operation but "
+        "node has type %s",
+        node->GetTypeName());
   }
 
-  consumer->stop_pending_ = false;
-  if (consumer->stopped_) {
-    // If the session was already stopped (e.g., it failed to start), don't try
-    // stopping again.
-    consumer->NotifyStopComplete();
-  } else if (!consumer->trace_config_) {
-    PERFETTO_ELOG("Must call Setup(config) and Start() first");
-    return;
-  } else {
-    consumer->service_->DisableTracing();
+  if (node->GetIf<Node::Empty>()) {
+    node->value = Node::IndexedRepeatedField{};
+    return StatusOr<void>::Ok();
   }
 
-  consumer->trace_config_.reset();
+  auto status_or_map_value = allocator_->CreateNode<Node::Empty>();
+  PROTOVM_RETURN_IF_NOT_OK(status_or_map_value);
+
+  auto map_value = std::move(*status_or_map_value);
+  map_value->value = std::move(node->value);
+  node->value = Node::IndexedRepeatedField{};
+
+  auto status_or_it =
+      MapInsert(&node->GetIf<Node::IndexedRepeatedField>()->index_to_node, 0,
+                std::move(map_value));
+  PROTOVM_RETURN(status_or_it);
 }
 
-void TracingMuxerImpl::DestroyTracingSession(
-    TracingSessionGlobalID session_id) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  for (RegisteredConsumerBackend& backend : consumer_backends_) {
-    // We need to find the consumer (if any) and call Disconnect as we destroy
-    // the tracing session. We can't call Disconnect() inside this for loop
-    // because in the in-process case this will end up to a synchronous call to
-    // OnConsumerDisconnect which will invalidate all the iterators to
-    // |backend.consumers|.
-    ConsumerImpl* consumer = nullptr;
-    for (auto& con : backend.consumers) {
-      if (con->session_id_ == session_id) {
-        consumer = con.get();
-        break;
-      }
-    }
-    if (consumer) {
-      // We broke out of the loop above on the assumption that each backend will
-      // only have a single consumer per session. This DCHECK ensures that
-      // this is the case.
-      PERFETTO_DCHECK(
-          std::count_if(backend.consumers.begin(), backend.consumers.end(),
-                        [session_id](const std::unique_ptr<ConsumerImpl>& con) {
-                          return con->session_id_ == session_id;
-                        }) == 1u);
-      consumer->Disconnect();
-    }
+StatusOr<IntrusiveMap::Iterator> RwProtoCursor::FindOrCreateMessageField(
+    Node* node,
+    uint32_t field_id) {
+  auto status = ConvertToMessageIfNeeded(node);
+  PROTOVM_RETURN_IF_NOT_OK(status);
+
+  auto* message = node->GetIf<Node::Message>();
+  auto it = message->field_id_to_node.Find(field_id);
+  if (it) {
+    return it;
   }
+
+  auto status_or_map_value = allocator_->CreateNode<Node::Empty>();
+  PROTOVM_RETURN_IF_NOT_OK(status_or_map_value);
+
+  auto status_or_it = MapInsert(&message->field_id_to_node, field_id,
+                                std::move(*status_or_map_value));
+  PROTOVM_RETURN(status_or_it);
 }
 
-void TracingMuxerImpl::ReadTracingSessionData(
-    TracingSessionGlobalID session_id,
-    std::function<void(TracingSession::ReadTraceCallbackArgs)> callback) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  auto* consumer = FindConsumer(session_id);
-  if (!consumer) {
-    // TODO(skyostil): Signal an error to the user.
-    TracingSession::ReadTraceCallbackArgs callback_arg{};
-    callback(callback_arg);
-    return;
+StatusOr<IntrusiveMap::Iterator>
+RwProtoCursor::FindOrCreateIndexedRepeatedField(Node* node, uint32_t index) {
+  auto& index_to_node =
+      node->GetIf<Node::IndexedRepeatedField>()->index_to_node;
+
+  auto it = index_to_node.Find(index);
+  if (it) {
+    return it;
   }
-  PERFETTO_DCHECK(!consumer->read_trace_callback_);
-  consumer->read_trace_callback_ = std::move(callback);
-  consumer->service_->ReadBuffers();
-}
 
-void TracingMuxerImpl::GetTraceStats(
-    TracingSessionGlobalID session_id,
-    TracingSession::GetTraceStatsCallback callback) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  auto* consumer = FindConsumer(session_id);
-  if (!consumer) {
-    TracingSession::GetTraceStatsCallbackArgs callback_arg{};
-    callback_arg.success = false;
-    callback(std::move(callback_arg));
-    return;
+  bool requires_creation_and_is_not_simple_append =
+      index > index_to_node.Size();
+  if (requires_creation_and_is_not_simple_append) {
+    PROTOVM_ABORT(
+        "Attempted to insert repeated field at arbitrary position (only "
+        "append operation is supported)");
   }
-  PERFETTO_DCHECK(!consumer->get_trace_stats_callback_);
-  consumer->get_trace_stats_callback_ = std::move(callback);
-  if (!consumer->connected_) {
-    consumer->get_trace_stats_pending_ = true;
-    return;
+
+  auto status_or_map_value = allocator_->CreateNode<Node::Empty>();
+  PROTOVM_RETURN_IF_NOT_OK(status_or_map_value);
+
+  return MapInsert(&node->GetIf<Node::IndexedRepeatedField>()->index_to_node,
+                   index, std::move(*status_or_map_value));
+}
+
+StatusOr<IntrusiveMap::Iterator> RwProtoCursor::FindOrCreateMappedRepeatedField(
+    Node* node,
+    uint64_t key) {
+  auto it = node->GetIf<Node::MappedRepeatedField>()->key_to_node.Find(key);
+
+  if (it) {
+    return it;
   }
-  consumer->get_trace_stats_pending_ = false;
-  consumer->service_->GetTraceStats();
+
+  auto status_or_map_value = allocator_->CreateNode<Node::Empty>();
+  PROTOVM_RETURN_IF_NOT_OK(status_or_map_value);
+
+  return MapInsert(&node->GetIf<Node::MappedRepeatedField>()->key_to_node, key,
+                   std::move(*status_or_map_value));
 }
 
-void TracingMuxerImpl::QueryServiceState(
-    TracingSessionGlobalID session_id,
-    TracingSession::QueryServiceStateCallback callback) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  auto* consumer = FindConsumer(session_id);
-  if (!consumer) {
-    TracingSession::QueryServiceStateCallbackArgs callback_arg{};
-    callback_arg.success = false;
-    callback(std::move(callback_arg));
-    return;
+StatusOr<IntrusiveMap::Iterator> RwProtoCursor::MapInsert(
+    IntrusiveMap* map,
+    uint64_t key,
+    OwnedPtr<Node> map_value) {
+  auto status_or_map_node =
+      allocator_->CreateNode<Node::MapNode>(key, std::move(map_value));
+  if (!status_or_map_node.IsOk()) {
+    allocator_->Delete(map_value.release());
+    PROTOVM_RETURN(status_or_map_node, "Failed to allocate node");
   }
-  PERFETTO_DCHECK(!consumer->query_service_state_callback_);
-  if (!consumer->connected_) {
-    consumer->query_service_state_callback_ = std::move(callback);
-    return;
+
+  auto [it, inserted] =
+      map->Insert(*status_or_map_node->release()->GetIf<Node::MapNode>());
+  if (!inserted) {
+    allocator_->Delete(map_value.release());
+    allocator_->Delete(status_or_map_node->release());
+    PROTOVM_ABORT(
+        "Failed to insert intrusive map entry (key = %d). Duplicated key?",
+        static_cast<int>(key));
   }
-  auto callback_wrapper = [callback](bool success,
-                                     protos::gen::TracingServiceState state) {
-    TracingSession::QueryServiceStateCallbackArgs callback_arg{};
-    callback_arg.success = success;
-    callback_arg.service_state_data = state.SerializeAsArray();
-    callback(std::move(callback_arg));
-  };
-  consumer->service_->QueryServiceState(std::move(callback_wrapper));
+
+  return it;
 }
 
-void TracingMuxerImpl::SetBatchCommitsDurationForTesting(
-    uint32_t batch_commits_duration_ms,
-    BackendType backend_type) {
-  for (RegisteredProducerBackend& backend : producer_backends_) {
-    if (backend.producer && backend.producer->connected_ &&
-        backend.type == backend_type) {
-      backend.producer->service_->MaybeSharedMemoryArbiter()
-          ->SetBatchCommitsDuration(batch_commits_duration_ms);
+StatusOr<uint64_t> RwProtoCursor::ReadScalarField(const Node& node,
+                                                  uint32_t field_id) {
+  if (auto* bytes = node.GetIf<Node::Bytes>()) {
+    protozero::ProtoDecoder decoder(protozero::ConstBytes{
+        static_cast<const uint8_t*>(bytes->data.get()), bytes->size});
+
+    auto field = decoder.ReadField();
+    while (field.valid() && field.id() != field_id) {
+      field = decoder.ReadField();
+    }
+
+    if (!field.valid()) {
+      PROTOVM_ABORT(
+          "Attempted to read scalar field (id=%u) but it is not present",
+          field_id);
     }
+
+    if (field.type() ==
+        protozero::proto_utils::ProtoWireType::kLengthDelimited) {
+      PROTOVM_ABORT("Attempted to length-delimited field (id=%u) as scalar",
+                    field_id);
+    }
+
+    return field.as_uint64();
   }
-}
 
-bool TracingMuxerImpl::EnableDirectSMBPatchingForTesting(
-    BackendType backend_type) {
-  for (RegisteredProducerBackend& backend : producer_backends_) {
-    if (backend.producer && backend.producer->connected_ &&
-        backend.type == backend_type &&
-        !backend.producer->service_->MaybeSharedMemoryArbiter()
-             ->EnableDirectSMBPatching()) {
-      return false;
+  if (auto* message = node.GetIf<Node::Message>()) {
+    auto it = message->field_id_to_node.Find(field_id);
+    if (!it) {
+      PROTOVM_ABORT(
+          "Attempted to read scalar field (id=%u) but it is not present",
+          field_id);
     }
+
+    auto* scalar = it->value->GetIf<Scalar>();
+    if (!scalar) {
+      PROTOVM_ABORT(
+          "Attempted to read scalar field (id=%u) from node with type %s",
+          field_id, it->value->GetTypeName());
+    }
+
+    return scalar->value;
   }
-  return true;
-}
 
-TracingMuxerImpl::ConsumerImpl* TracingMuxerImpl::FindConsumer(
-    TracingSessionGlobalID session_id) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  return FindConsumerAndBackend(session_id).first;
+  PROTOVM_ABORT(
+      "Attempted to read scalar field (id=%u) but parent node has type %s",
+      field_id, node.GetTypeName());
 }
 
-std::pair<TracingMuxerImpl::ConsumerImpl*,
-          TracingMuxerImpl::RegisteredConsumerBackend*>
-TracingMuxerImpl::FindConsumerAndBackend(TracingSessionGlobalID session_id) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  for (RegisteredConsumerBackend& backend : consumer_backends_) {
-    for (auto& consumer : backend.consumers) {
-      if (consumer->session_id_ == session_id) {
-        return {consumer.get(), &backend};
+}  // namespace protovm
+}  // namespace perfetto
+// gen_amalgamated begin source: src/protovm/vm.cc
+// gen_amalgamated begin header: src/protovm/vm.h
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SRC_PROTOVM_VM_H_
+#define SRC_PROTOVM_VM_H_
+
+#include <memory>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field.h"
+
+// gen_amalgamated expanded: #include "src/protovm/error_handling.h"
+// gen_amalgamated expanded: #include "src/protovm/executor.h"
+// gen_amalgamated expanded: #include "src/protovm/parser.h"
+
+namespace perfetto {
+namespace protovm {
+
+// A VM that executes programs defined by data sources at registration time.
+// Used by traced to apply patches (packets overwritten in the ring buffer) to
+// an incremental state packet, thus allowing efficient incremental tracing of
+// Layers/Windows/Views without requiring periodic invalidation and achieve
+// perfect interning.
+//
+// Overview of the VM's architecture and interactions:
+//
+//
+//         ***********
+//         *         *
+//         * Program *
+//         *         *
+//         ***********
+//              │
+//              │
+//              │
+//          ┌───┴──┐            ┌────────┐
+//          │      │            │        │
+//          │Parser├────────────┤Executor│
+//          │      │            │        │
+//          └──────┘            └─┬────┬─┘
+//                                │    │
+//                          ┌─────┘    └─────┐
+//                          │                │
+//                          │                │
+//                      ┌───┴────┐       ┌───┴────┐
+//                      │        │       │        │
+//                      │RoCursor│       │RwProto │
+//                      │        │       │::Cursor│
+//                      └────┬───┘       │        │
+//                           │           └───┬────┘
+//                           │               │
+//                           │               │
+//                           │               │
+//                      *********      ***************
+//                      *       *      *             *
+//                      * Patch *      * Incremental *
+//                      *       *      *    state    *
+//                      *********      *             *
+//                                     ***************
+//
+//  ┌─┐
+//  │ │  VM's component
+//  └─┘
+//
+//  ***
+//  * *  Data
+//  ***
+//
+//
+// Parser: Understands the instructions semantic and controls the program flow.
+//         It delegates to the Executor operations like navigating through the
+//         patch and incremental state data, reading values, and manipulating
+//         fields.
+//
+//
+// Executor: Thin glue layer that mainly forwards data back and forth between
+//           the Parser and cursors. Mainly useful for testing, as it can
+//           be easily mocked and allows to test the Parser in isolation.
+//
+//
+// RoCursor: Provides read-only access to the incoming data (the patch) to be
+//           applied. It allows to traverse the proto message structure of the
+//           patch, iterating over fields and extracting field values.
+//
+//
+// RwProto::Cursor: Provides read-write access to the incremental state. It
+//                  allows traversing the proto message structure of the
+//                  incremental state, as well as deleting/inserting/merging
+//                  fields.
+class Vm {
+ public:
+  Vm(protozero::ConstBytes program,
+     size_t memory_limit_bytes,
+     protozero::ConstBytes initial_incremental_state = {nullptr, 0});
+  StatusOr<void> ApplyPatch(protozero::ConstBytes packet);
+  void SerializeIncrementalState(protozero::Message*) const;
+  std::string SerializeProgram() const;
+  std::unique_ptr<Vm> CloneReadOnly() const;
+  uint64_t GetMemoryUsageBytes() const;
+
+ private:
+  struct ReadWriteState {
+    ReadWriteState(std::string& program,
+                   size_t memory_limit_bytes,
+                   protozero::ConstBytes initial_incremental_state)
+        : executor{},
+          parser{protozero::ConstBytes{
+                     reinterpret_cast<const uint8_t*>(program.data()),
+                     program.size()},
+                 &executor},
+          allocator{memory_limit_bytes},
+          incremental_state{&allocator} {
+      if (initial_incremental_state.data) {
+        incremental_state.GetRoot().SetBytes(initial_incremental_state);
       }
     }
-  }
-  return {nullptr, nullptr};
-}
 
-void TracingMuxerImpl::InitializeConsumer(TracingSessionGlobalID session_id) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
+    Executor executor;
+    Parser parser;
+    Allocator allocator;
+    RwProto incremental_state;
+  };
 
-  auto res = FindConsumerAndBackend(session_id);
-  if (!res.first || !res.second)
-    return;
-  TracingMuxerImpl::ConsumerImpl* consumer = res.first;
-  RegisteredConsumerBackend& backend = *res.second;
+  struct ReadOnlyState {
+    explicit ReadOnlyState(std::string incremental_state)
+        : serialized_incremental_state(std::move(incremental_state)) {}
 
-  TracingBackend::ConnectConsumerArgs conn_args;
-  conn_args.consumer = consumer;
-  conn_args.task_runner = task_runner_.get();
-  consumer->Initialize(backend.backend->ConnectConsumer(conn_args));
-}
+    std::string serialized_incremental_state;
+  };
 
-void TracingMuxerImpl::OnConsumerDisconnected(ConsumerImpl* consumer) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  for (RegisteredConsumerBackend& backend : consumer_backends_) {
-    auto pred = [consumer](const std::unique_ptr<ConsumerImpl>& con) {
-      return con.get() == consumer;
-    };
-    backend.consumers.erase(std::remove_if(backend.consumers.begin(),
-                                           backend.consumers.end(), pred),
-                            backend.consumers.end());
+  // Constructor used to produce read-only copies of the ProtoVm.
+  // Private to avoid unintended copies. It should be used only for
+  // CloneReadOnly().
+  Vm(const Vm&);
+
+  // Constructor used only for cloning
+  explicit Vm(std::string incremental_state);
+
+  std::string SerializeIncrementalStateAsString() const;
+
+  std::string owned_program_;
+  std::variant<ReadWriteState, ReadOnlyState> state_;
+};
+
+}  // namespace protovm
+}  // namespace perfetto
+
+#endif  // SRC_PROTOVM_VM_H_
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "src/protovm/vm.h"
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// gen_amalgamated expanded: #include "src/protovm/error_handling.h"
+// gen_amalgamated expanded: #include "src/protovm/ro_cursor.h"
+// gen_amalgamated expanded: #include "src/protovm/rw_proto.h"
+
+namespace perfetto {
+namespace protovm {
+
+Vm::Vm(protozero::ConstBytes program,
+       size_t memory_limit_bytes,
+       protozero::ConstBytes initial_incremental_state)
+    : owned_program_(program.ToStdString()),
+      state_(std::in_place_type_t<ReadWriteState>{},
+             owned_program_,
+             memory_limit_bytes,
+             initial_incremental_state) {}
+
+Vm::Vm(const Vm& other)
+    : owned_program_(other.SerializeProgram()),
+      state_(std::in_place_type_t<ReadOnlyState>{},
+             other.SerializeIncrementalStateAsString()) {}
+
+StatusOr<void> Vm::ApplyPatch(protozero::ConstBytes packet) {
+  ReadWriteState* rw_state = std::get_if<ReadWriteState>(&state_);
+  if (!rw_state) {
+    return StatusOr<void>::Abort();
+  }
+  auto src = RoCursor(packet);
+  auto dst = rw_state->incremental_state.GetRoot();
+  return rw_state->parser.Run(src, dst);
+}
+
+void Vm::SerializeIncrementalState(protozero::Message* proto) const {
+  if (const ReadOnlyState* state = std::get_if<ReadOnlyState>(&state_); state) {
+    proto->AppendRawProtoBytes(state->serialized_incremental_state.data(),
+                               state->serialized_incremental_state.size());
+    return;
   }
+
+  const ReadWriteState* state = std::get_if<ReadWriteState>(&state_);
+  state->incremental_state.Serialize(proto);
 }
 
-void TracingMuxerImpl::SetMaxProducerReconnectionsForTesting(uint32_t count) {
-  max_producer_reconnections_.store(count);
+std::string Vm::SerializeIncrementalStateAsString() const {
+  protozero::HeapBuffered<protozero::Message> proto;
+  SerializeIncrementalState(proto.get());
+  return proto.SerializeAsString();
 }
 
-void TracingMuxerImpl::OnProducerDisconnected(ProducerImpl* producer) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  for (RegisteredProducerBackend& backend : producer_backends_) {
-    if (backend.producer.get() != producer)
-      continue;
-    // Try reconnecting the disconnected producer. If the connection succeeds,
-    // all the data sources will be automatically re-registered.
-    if (producer->connection_id_.load(std::memory_order_relaxed) >
-        max_producer_reconnections_.load()) {
-      // Avoid reconnecting a failing producer too many times. Instead we just
-      // leak the producer instead of trying to avoid further complicating
-      // cross-thread trace writer creation.
-      PERFETTO_ELOG("Producer disconnected too many times; not reconnecting");
-      continue;
-    }
-    backend.producer->Initialize(
-        backend.backend->ConnectProducer(backend.producer_conn_args));
-    // Don't use producer-provided SMBs for the next connection unless startup
-    // tracing requires it again.
-    backend.producer_conn_args.use_producer_provided_smb = false;
-  }
+std::string Vm::SerializeProgram() const {
+  return owned_program_;
+}
 
-  // Increment the generation counter to atomically ensure that:
-  // 1. Old trace writers from the severed connection eventually get cleaned up
-  //    by DestroyStoppedTraceWritersForCurrentThread().
-  // 2. No new trace writers can be created for the SharedMemoryArbiter from the
-  //    old connection.
-  TracingMuxer::generation_++;
+std::unique_ptr<Vm> Vm::CloneReadOnly() const {
+  return std::unique_ptr<Vm>(new Vm(*this));
 }
 
-void TracingMuxerImpl::SweepDeadBackends() {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  for (auto it = dead_backends_.begin(); it != dead_backends_.end();) {
-    auto next_it = it;
-    next_it++;
-    if (it->producer->SweepDeadServices())
-      dead_backends_.erase(it);
-    it = next_it;
+uint64_t Vm::GetMemoryUsageBytes() const {
+  if (const ReadOnlyState* state = std::get_if<ReadOnlyState>(&state_); state) {
+    return owned_program_.size() + state->serialized_incremental_state.size();
   }
+
+  const ReadWriteState* state = std::get_if<ReadWriteState>(&state_);
+  return owned_program_.size() + state->allocator.GetMemoryUsageBytes();
 }
 
-TracingMuxerImpl::FindDataSourceRes TracingMuxerImpl::FindDataSource(
-    TracingBackendId backend_id,
-    DataSourceInstanceID instance_id) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  RegisteredProducerBackend& backend = *FindProducerBackendById(backend_id);
-  for (const auto& rds : data_sources_) {
-    DataSourceStaticState* static_state = rds.static_state;
-    for (uint32_t i = 0; i < kMaxDataSourceInstances; i++) {
-      auto* internal_state = static_state->TryGet(i);
-      if (internal_state && internal_state->backend_id == backend_id &&
-          internal_state->backend_connection_id ==
-              backend.producer->connection_id_.load(
-                  std::memory_order_relaxed) &&
-          internal_state->data_source_instance_id == instance_id) {
-        return FindDataSourceRes(static_state, internal_state, i,
-                                 rds.requires_callbacks_under_lock);
-      }
+}  // namespace protovm
+}  // namespace perfetto
+// gen_amalgamated begin source: src/protozero/filtering/filter_bytecode_parser.cc
+// gen_amalgamated begin header: src/protozero/filtering/filter_bytecode_parser.h
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SRC_PROTOZERO_FILTERING_FILTER_BYTECODE_PARSER_H_
+#define SRC_PROTOZERO_FILTERING_FILTER_BYTECODE_PARSER_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <vector>
+
+namespace protozero {
+
+// Loads the proto-encoded bytecode in memory and allows fast lookups for tuples
+// (msg_index, field_id) to tell if a given field should be allowed or not and,
+// in the case of nested fields, what is the next message index to recurse into.
+// This class does two things:
+// 1. Expands the array of varint from the proto into a vector<uint32_t>. This
+//    is to avoid performing varint decoding on every lookup, at the cost of
+//    some extra memory (2KB-4KB). Note that the expanded vector is not just a
+//    1:1 copy of the proto one (more below). This is to avoid O(Fields) linear
+//    lookup complexity.
+// 2. Creates an index of offsets to remember the start word for each message.
+//    This is so we can jump to O(1) to the N-th message when recursing into a
+//    nested fields, without having to scan and find the (N-1)-th END_OF_MESSAGE
+//    marker.
+// Overall lookups are O(1) for field ids < 128 (kDirectlyIndexLimit) and O(N),
+// with N being the number of allowed field ranges for other fields.
+// See comments around |word_| below for the structure of the word vector.
+class FilterBytecodeParser {
+ public:
+  static constexpr uint32_t kSimpleField = 0x7fffffff;
+  static constexpr uint32_t kFilterStringField = 0x7ffffffe;
+  // FilterStringFieldWithType uses a range: 0x7fff0000 to 0x7ffffffd.
+  // The semantic type is encoded in the lower 16 bits.
+  static constexpr uint32_t kFilterStringFieldWithType = 0x7fff0000;
+  static constexpr uint32_t kFilterStringFieldWithTypeMask = 0x7fff0000;
+  static constexpr uint32_t kSemanticTypeMask = 0xffff;
+
+  // Result of a Query() operation
+  struct QueryResult {
+    bool allowed;  // Whether the field is allowed at all or no.
+
+    // If |allowed|==true && nested_msg_field() == true, this tells the message
+    // index of the nested field that should be used when recursing in the
+    // parser.
+    uint32_t nested_msg_index;
+
+    // The semantic type of the field (only meaningful when
+    // filter_string_field() returns true). A value of 0 means unspecified.
+    uint32_t semantic_type;
+
+    // If |allowed|==true, specifies if the field is of a simple type (varint,
+    // fixed32/64, string or byte).
+    bool simple_field() const { return nested_msg_index == kSimpleField; }
+
+    // If |allowed|==true, specifies if this field is a string field that needs
+    // to be filtered.
+    bool filter_string_field() const {
+      // Range: [kFilterStringFieldWithType, kFilterStringField] i.e.
+      // [0x7fff0000, 0x7ffffffe]. This excludes kSimpleField (0x7fffffff).
+      return nested_msg_index >= kFilterStringFieldWithType &&
+             nested_msg_index <= kFilterStringField;
+    }
+
+    // If |allowed|==true, specifies if the field is a nested field that needs
+    // recursion. The caller is expected to use |nested_msg_index| for the next
+    // Query() calls.
+    bool nested_msg_field() const {
+      static_assert(kFilterStringFieldWithType < kFilterStringField,
+                    "kFilterStringFieldWithType < kFilterStringField");
+      static_assert(kFilterStringField < kSimpleField,
+                    "kFilterStringField < kSimpleField");
+      return nested_msg_index < kFilterStringFieldWithType;
     }
-  }
-  return FindDataSourceRes();
-}
+  };
 
-// Can be called from any thread.
-std::unique_ptr<TraceWriterBase> TracingMuxerImpl::CreateTraceWriter(
-    DataSourceStaticState* static_state,
-    uint32_t data_source_instance_index,
-    DataSourceState* data_source,
-    BufferExhaustedPolicy buffer_exhausted_policy) {
-  if (PERFETTO_UNLIKELY(data_source->interceptor_id)) {
-    // If the session is being intercepted, return a heap-backed trace writer
-    // instead. This is safe because all the data given to the interceptor is
-    // either thread-local (|instance_index|), statically allocated
-    // (|static_state|) or constant after initialization (|interceptor|). Access
-    // to the interceptor instance itself through |data_source| is protected by
-    // a statically allocated lock (similarly to the data source instance).
-    auto& interceptor = interceptors_[data_source->interceptor_id - 1];
-    return std::unique_ptr<TraceWriterBase>(new InterceptorTraceWriter(
-        interceptor.tls_factory(static_state, data_source_instance_index),
-        interceptor.packet_callback, static_state, data_source_instance_index));
-  }
-  ProducerImpl* producer =
-      FindProducerBackendById(data_source->backend_id)->producer.get();
-  // Atomically load the current service endpoint. We keep the pointer as a
-  // shared pointer on the stack to guard against it from being concurrently
-  // modified on the thread by ProducerImpl::Initialize() swapping in a
-  // reconnected service on the muxer task runner thread.
+  // Loads a filter. The filter data consists of a sequence of varints which
+  // contains the filter opcodes and a final checksum.
+  // If a filter is already loaded, it is replaced.
   //
-  // The endpoint may also be concurrently modified by SweepDeadServices()
-  // clearing out old disconnected services. We guard against that by
-  // SharedMemoryArbiter keeping track of any outstanding trace writers. After
-  // shutdown has started, the trace writer created below will be a null one
-  // which will drop any written data. See SharedMemoryArbiter::TryShutdown().
+  // Optionally accepts an overlay (pass nullptr/0 if not needed). The overlay
+  // can add new fields or upgrade existing fields (e.g., to FilterString).
+  // The overlay uses the same opcode format as the base bytecode, but with an
+  // explicit message index prefix:
+  //   [msg_index, (field_id << 3) | opcode, argument] ... [checksum]
+  // Entry sizes depend on the opcode (same as base bytecode).
+  // Entries must be sorted by (msg_index, field_id). The base bytecode and
+  // overlay are merged during loading, maintaining sorted field order.
+  // See /rfcs/0011-subset-string-filter-rules.md for design details.
+  bool Load(const void* filter_data,
+            size_t len,
+            const void* overlay_data = nullptr,
+            size_t overlay_len = 0);
+
+  // Checks wheter a given field is allowed or not.
+  // msg_index = 0 is the index of the root message, where all queries should
+  // start from (typically perfetto.protos.Trace).
+  QueryResult Query(uint32_t msg_index, uint32_t field_id) const;
+
+  void Reset();
+  void set_suppress_logs_for_fuzzer(bool x) { suppress_logs_for_fuzzer_ = x; }
+
+ private:
+  static constexpr uint32_t kDirectlyIndexLimit = 128;
+  static constexpr uint32_t kAllowed = 1u << 31u;
+
+  bool LoadInternal(const uint8_t* filter_data,
+                    size_t len,
+                    const uint8_t* overlay_data,
+                    size_t overlay_len);
+
+  // The state of all fields for all messages is stored in one contiguous array.
+  // This is to avoid memory fragmentation and allocator overhead.
+  // We expect a high number of messages (hundreds), but each message is small.
+  // For each message we store two sets of uint32:
+  // 1. A set of "directly indexed" fields, for field ids < 128.
+  // 2. The remainder is a set of ranges.
+  // So each message descriptor consists of a sequence of words as follows:
   //
-  // We use an atomic pointer instead of holding a lock because
-  // CreateTraceWriter posts tasks under the hood.
-  std::shared_ptr<ProducerEndpoint> service =
-      std::atomic_load(&producer->service_);
+  // [0] -> how many directly indexed fields are stored next (up to 128)
+  //
+  // [1..N] -> One word per field id (See "field state" below).
+  //
+  // [N + 1] -> Start of field id range 1
+  // [N + 2] -> End of field id range 1 (exclusive, STL-style).
+  // [N + 3] -> Field state for fields in range 1 (below)
+  //
+  // [N + 4] -> Start of field id range 2
+  // [N + 5] -> End of field id range 2 (exclusive, STL-style).
+  // [N + 6] -> Field state for fields in range 2 (below)
 
-  // The service may have been disconnected and reconnected concurrently after
-  // the data source was enabled, in which case we may not have an arbiter, or
-  // would be creating a TraceWriter for the wrong (a newer) connection / SMB.
-  // Instead, early-out now. A relaxed load is fine here because the atomic_load
-  // above ensures that the |service| isn't newer.
-  if (producer->connection_id_.load(std::memory_order_relaxed) !=
-      data_source->backend_connection_id) {
-    return std::unique_ptr<TraceWriter>(new NullTraceWriter());
-  }
+  // The "field state" word is as follows:
+  // Bit 31: 1 if the field is allowed, 0 if disallowed.
+  //         Only directly indexed fields can be 0 (it doesn't make sense to add
+  //         a range and then say "btw it's NOT allowed".. don't add it then.
+  //         0 is only used for filling gaps in the directly indexed bucket.
+  // Bits [30..0] (only when MSB == allowed):
+  //  0x7fffffff: The field is "simple" (varint, fixed32/64, string, bytes) and
+  //      can be directly passed through in output. No recursion is needed.
+  //  0x7ffffffe: The field is string field which needs to be filtered.
+  //  0x7fff0000-0x7ffffffd: The field is a string field with a semantic type.
+  //      The lower 16 bits encode the semantic type.
+  //  [0, 0x7ffeffff]: The field is a nested submessage. The value is the index
+  //     that must be passed as first argument to the next Query() calls.
+  //     Note that the message index is purely a monotonic counter in the
+  std::vector<uint32_t> words_;
 
-  // We just need a relaxed atomic read here: We can use the reservation ID even
-  // after the buffer was bound, we just need to be sure to read it atomically.
-  uint16_t startup_buffer_reservation =
-      data_source->startup_target_buffer_reservation.load(
-          std::memory_order_relaxed);
-  if (startup_buffer_reservation) {
-    return service->MaybeSharedMemoryArbiter()->CreateStartupTraceWriter(
-        startup_buffer_reservation);
-  }
-  return service->CreateTraceWriter(data_source->buffer_id,
-                                    buffer_exhausted_policy);
-}
+  // One entry for each message index stored in the filter plus a sentinel at
+  // the end. Maps each message index to the offset in |words_| where the
+  // Nth message start.
+  // message_offset_.size() - 2 == the max message id that can be parsed.
+  std::vector<uint32_t> message_offset_;
 
-// This is called via the public API Tracing::NewTrace().
-// Can be called from any thread.
-std::unique_ptr<TracingSession> TracingMuxerImpl::CreateTracingSession(
-    BackendType requested_backend_type,
-    TracingConsumerBackend* (*system_backend_factory)()) {
-  TracingSessionGlobalID session_id = ++next_tracing_session_id_;
+  bool suppress_logs_for_fuzzer_ = false;
+};
 
-  // |backend_type| can only specify one backend, not an OR-ed mask.
-  PERFETTO_CHECK((requested_backend_type & (requested_backend_type - 1)) == 0);
+}  // namespace protozero
 
-  // Capturing |this| is fine because the TracingMuxer is a leaky singleton.
-  task_runner_->PostTask([this, requested_backend_type, session_id,
-                          system_backend_factory] {
-    if (requested_backend_type == kSystemBackend && system_backend_factory &&
-        !FindConsumerBackendByType(kSystemBackend)) {
-      AddConsumerBackend(system_backend_factory(), kSystemBackend);
-    }
-    for (RegisteredConsumerBackend& backend : consumer_backends_) {
-      if (requested_backend_type && backend.type &&
-          backend.type != requested_backend_type) {
-        continue;
-      }
+#endif  // SRC_PROTOZERO_FILTERING_FILTER_BYTECODE_PARSER_H_
+// gen_amalgamated begin header: src/protozero/filtering/filter_bytecode_common.h
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-      // Create the consumer now, even if we have to ask the embedder below, so
-      // that any other tasks executing after this one can find the consumer and
-      // change its pending attributes.
-      backend.consumers.emplace_back(
-          new ConsumerImpl(this, backend.type, session_id));
+#ifndef SRC_PROTOZERO_FILTERING_FILTER_BYTECODE_COMMON_H_
+#define SRC_PROTOZERO_FILTERING_FILTER_BYTECODE_COMMON_H_
 
-      // The last registered backend in |consumer_backends_| is the unsupported
-      // backend without a valid type.
-      if (!backend.type) {
-        PERFETTO_ELOG(
-            "No tracing backend ready for type=%d, consumer will disconnect",
-            requested_backend_type);
-        InitializeConsumer(session_id);
-        return;
-      }
+#include <stdint.h>
 
-      // Check if the embedder wants to be asked for permission before
-      // connecting the consumer.
-      if (!policy_) {
-        InitializeConsumer(session_id);
-        return;
-      }
+namespace protozero {
 
-      BackendType type = backend.type;
-      TracingPolicy::ShouldAllowConsumerSessionArgs args;
-      args.backend_type = backend.type;
-      args.result_callback = [this, type, session_id](bool allow) {
-        task_runner_->PostTask([this, type, session_id, allow] {
-          if (allow) {
-            InitializeConsumer(session_id);
-            return;
-          }
+enum FilterOpcode : uint32_t {
+  // The immediate value is 0 in this case.
+  kFilterOpcode_EndOfMessage = 0,
 
-          PERFETTO_ELOG(
-              "Consumer session for backend type type=%d forbidden, "
-              "consumer will disconnect",
-              type);
+  // The immediate value is the id of the allowed field.
+  kFilterOpcode_SimpleField = 1,
+
+  // The immediate value is the start of the range. The next word (without
+  // any shifting) is the length of the range.
+  kFilterOpcode_SimpleFieldRange = 2,
+
+  // The immediate value is the id of the allowed field. The next word
+  // (without any shifting) is the index of the filter that should be used to
+  // recurse into the nested message.
+  kFilterOpcode_NestedField = 3,
+
+  // The immediate value is the id of the allowed field. The behaviour of this
+  // opcode is the same as kFilterOpcode_SimpleField, with the further semantic
+  // that the field is a string and needs to be processed using the string
+  // filtering rules.
+  kFilterOpcode_FilterString = 4,
+
+  // The immediate value is the id of the allowed field. The next word (without
+  // any shifting) is the semantic type of the string field. The behaviour is
+  // similar to kFilterOpcode_FilterString, but carries semantic type info so
+  // that the string filter can apply type-specific rules.
+  kFilterOpcode_FilterStringWithType = 5,
+};
+
+// Constants for extracting opcode and field_id from bytecode words.
+// Bytecode words are encoded as: (field_id << kOpcodeShift) | opcode
+constexpr uint32_t kOpcodeMask = 0x7u;
+constexpr uint32_t kOpcodeShift = 3;
+
+}  // namespace protozero
+
+#endif  // SRC_PROTOZERO_FILTERING_FILTER_BYTECODE_COMMON_H_
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "src/protozero/filtering/filter_bytecode_parser.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <vector>
+
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/fnv_hash.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "perfetto/public/compiler.h"
+// gen_amalgamated expanded: #include "src/protozero/filtering/filter_bytecode_common.h"
+
+namespace protozero {
+
+namespace {
+
+// Parses varint-encoded bytecode and verifies checksum.
+// Returns true on success, with the checksum removed from |words|.
+bool ParseAndVerifyChecksum(const uint8_t* data,
+                            size_t len,
+                            std::vector<uint32_t>* words,
+                            bool suppress_logs) {
+  if (len == 0) {
+    return false;
+  }
+  words->reserve(len);  // An overestimation, but avoids reallocations.
+
+  // Parse varints while computing checksum in a single pass.
+  // The last word is the checksum itself and should not be hashed.
+  perfetto::base::FnvHasher hasher;
+  uint32_t actual_csum = 0;
+
+  using BytecodeDecoder =
+      PackedRepeatedFieldIterator<proto_utils::ProtoWireType::kVarInt,
+                                  uint32_t>;
+  bool has_checksum = false;
+  bool packed_parse_err = false;
+  for (BytecodeDecoder it(data, len, &packed_parse_err); it;) {
+    uint32_t word = *it++;
+    if (bool is_last_word = !it; is_last_word) {
+      actual_csum = word;
+      has_checksum = true;
+      break;
+    }
+    words->emplace_back(word);
+    hasher.Update(word);
+  }
+  if (packed_parse_err || !has_checksum) {
+    words->clear();
+    return false;
+  }
+  auto expected_csum = static_cast<uint32_t>(hasher.digest());
+  if (expected_csum != actual_csum) {
+    if (!suppress_logs) {
+      PERFETTO_ELOG("Filter bytecode checksum failed. Expected: %x, actual: %x",
+                    expected_csum, actual_csum);
+    }
+    words->clear();
+    return false;
+  }
+  return true;
+}
+
+struct OverlayEntry {
+  uint32_t msg_index;
+  uint32_t field_id;
+  uint32_t message_id;
+};
 
-          auto* consumer = FindConsumer(session_id);
-          if (!consumer)
-            return;
+// Returns the message_id for an overlay entry based on opcode and argument.
+// Returns 0 if the opcode is invalid.
+uint32_t GetMessageIdForOverlay(uint32_t opcode, uint32_t argument) {
+  switch (opcode) {
+    case kFilterOpcode_SimpleField:
+      return FilterBytecodeParser::kSimpleField;
+    case kFilterOpcode_FilterString:
+      return FilterBytecodeParser::kFilterStringField;
+    case kFilterOpcode_FilterStringWithType:
+      // For FilterStringWithType, incorporate semantic type into message_id.
+      return FilterBytecodeParser::kFilterStringFieldWithType |
+             (argument & FilterBytecodeParser::kSemanticTypeMask);
+    default:
+      return 0;  // Invalid opcode
+  }
+}
 
-          consumer->OnDisconnect();
-        });
-      };
-      policy_->ShouldAllowConsumerSession(args);
-      return;
-    }
-    PERFETTO_DFATAL("Not reached");
-  });
+}  // namespace
 
-  return std::unique_ptr<TracingSession>(
-      new TracingSessionImpl(this, session_id, requested_backend_type));
+void FilterBytecodeParser::Reset() {
+  bool suppress = suppress_logs_for_fuzzer_;
+  *this = FilterBytecodeParser();
+  suppress_logs_for_fuzzer_ = suppress;
 }
 
-// static
-// This is called via the public API Tracing::SetupStartupTracing().
-// Can be called from any thread.
-std::unique_ptr<StartupTracingSession>
-TracingMuxerImpl::CreateStartupTracingSession(
-    const TraceConfig& config,
-    Tracing::SetupStartupTracingOpts opts) {
-  BackendType backend_type = opts.backend;
-  // |backend_type| can only specify one backend, not an OR-ed mask.
-  PERFETTO_CHECK((backend_type & (backend_type - 1)) == 0);
-  // The in-process backend doesn't support startup tracing.
-  PERFETTO_CHECK(backend_type != BackendType::kInProcessBackend);
+bool FilterBytecodeParser::Load(const void* filter_data,
+                                size_t len,
+                                const void* overlay_data,
+                                size_t overlay_len) {
+  Reset();
+  bool res =
+      LoadInternal(static_cast<const uint8_t*>(filter_data), len,
+                   static_cast<const uint8_t*>(overlay_data), overlay_len);
+  // If load fails, don't leave the parser in a half broken state.
+  if (!res)
+    Reset();
+  return res;
+}
 
-  TracingSessionGlobalID session_id = ++next_tracing_session_id_;
+bool FilterBytecodeParser::LoadInternal(const uint8_t* filter_data,
+                                        size_t len,
+                                        const uint8_t* overlay_data,
+                                        size_t overlay_len) {
+  // First unpack the varints into a plain uint32 vector, so it's easy to
+  // iterate through them and look ahead.
+  std::vector<uint32_t> words;
+  if (!ParseAndVerifyChecksum(filter_data, len, &words,
+                              suppress_logs_for_fuzzer_))
+    return false;
 
-  // Capturing |this| is fine because the TracingMuxer is a leaky singleton.
-  task_runner_->PostTask([this, config, opts, backend_type, session_id] {
-    for (RegisteredProducerBackend& backend : producer_backends_) {
-      if (backend_type && backend.type && backend.type != backend_type) {
-        continue;
-      }
+  // Parse the overlay (if provided).
+  std::vector<OverlayEntry> overlay;
+  if (overlay_data && overlay_len > 0) {
+    std::vector<uint32_t> overlay_words;
+    if (!ParseAndVerifyChecksum(overlay_data, overlay_len, &overlay_words,
+                                suppress_logs_for_fuzzer_)) {
+      return false;
+    }
 
-      TracingBackendId backend_id = backend.id;
+    // Each entry is exactly 3 words: [msg_index, field_word, argument]
+    // where field_id = field_word >> 3. The argument is 0 when not needed.
+    if (overlay_words.size() % 3 != 0) {
+      PERFETTO_DLOG("overlay error: size %zu not multiple of 3",
+                    overlay_words.size());
+      return false;
+    }
 
-      // The last registered backend in |producer_backends_| is the unsupported
-      // backend without a valid type.
-      if (!backend.type) {
-        PERFETTO_ELOG(
-            "No tracing backend initialized for type=%d, startup tracing "
-            "failed",
-            backend_type);
-        if (opts.on_setup)
-          opts.on_setup(Tracing::OnStartupTracingSetupCallbackArgs{
-              0 /* num_data_sources_started */});
-        return;
+    for (size_t i = 0; i < overlay_words.size(); i += 3) {
+      overlay.emplace_back();
+
+      uint32_t opcode = overlay_words[i + 1] & kOpcodeMask;
+      uint32_t message_id =
+          GetMessageIdForOverlay(opcode, overlay_words[i + 2]);
+      if (message_id == 0) {
+        PERFETTO_DLOG("overlay error: invalid opcode %u at index %zu", opcode,
+                      i + 1);
+        return false;
       }
 
-      if (!backend.producer->service_ ||
-          !backend.producer->service_->shared_memory()) {
-        // If we unsuccessfully attempted to use a producer-provided SMB in the
-        // past, don't try again.
-        if (backend.producer->producer_provided_smb_failed_) {
-          PERFETTO_ELOG(
-              "Backend %zu doesn't seem to support producer-provided "
-              "SMBs, startup tracing failed",
-              backend_id);
-          if (opts.on_setup)
-            opts.on_setup(Tracing::OnStartupTracingSetupCallbackArgs{
-                0 /* num_data_sources_started */});
-          return;
-        }
+      OverlayEntry& entry = overlay.back();
+      entry.msg_index = overlay_words[i];
+      entry.field_id = overlay_words[i + 1] >> kOpcodeShift;
+      entry.message_id = message_id;
 
-        PERFETTO_DLOG("Reconnecting backend %zu for startup tracing",
-                      backend_id);
-        backend.producer_conn_args.use_producer_provided_smb = true;
-        backend.producer->service_->Disconnect();  // Causes a reconnect.
-        PERFETTO_DCHECK(backend.producer->service_ &&
-                        backend.producer->service_->MaybeSharedMemoryArbiter());
+      if (overlay.size() == 1) {
+        continue;
+      }
+      // Validate that overlay entries are sorted by (msg_index, field_id).
+      const OverlayEntry& prev_entry = overlay[overlay.size() - 2];
+      if (entry.msg_index < prev_entry.msg_index ||
+          (entry.msg_index == prev_entry.msg_index &&
+           entry.field_id <= prev_entry.field_id)) {
+        PERFETTO_DLOG(
+            "overlay error: entries not sorted at index %zu (msg %u, "
+            "field %u) after (msg %u, field %u)",
+            i, entry.msg_index, entry.field_id, prev_entry.msg_index,
+            prev_entry.field_id);
+        return false;
       }
+    }
+  }
 
-      RegisteredStartupSession session;
-      session.session_id = session_id;
-      session.on_aborted = opts.on_aborted;
-      session.on_adopted = opts.on_adopted;
+  // Temporary storage for each message. Cleared on every END_OF_MESSAGE.
+  std::vector<uint32_t> direct_indexed_fields;
+  std::vector<uint32_t> ranges;
+  uint32_t max_msg_index = 0;
+  uint32_t current_msg_index = 0;
+  size_t overlay_idx = 0;
 
-      for (const TraceConfig::DataSource& ds_cfg : config.data_sources()) {
-        // Find all matching data sources and start one instance of each.
-        for (const auto& rds : data_sources_) {
-          if (rds.descriptor.name() != ds_cfg.config().name())
-            continue;
+  auto add_directly_indexed_field = [&](uint32_t field_id, uint32_t msg_id) {
+    PERFETTO_DCHECK(field_id > 0 && field_id < kDirectlyIndexLimit);
+    direct_indexed_fields.resize(std::max(direct_indexed_fields.size(),
+                                          static_cast<size_t>(field_id) + 1));
+    direct_indexed_fields[field_id] = kAllowed | msg_id;
+  };
 
-          PERFETTO_DLOG(
-              "Setting up data source %s for startup tracing with target "
-              "buffer reservation %" PRIi32,
-              rds.descriptor.name().c_str(),
-              backend.producer->last_startup_target_buffer_reservation_ + 1u);
-          auto ds = SetupDataSourceImpl(
-              rds, backend_id,
-              backend.producer->connection_id_.load(std::memory_order_relaxed),
-              /*instance_id=*/0, ds_cfg.config(),
-              ComputeConfigHash(ds_cfg.config()),
-              ComputeStartupConfigHash(ds_cfg.config()),
-              /*startup_session_id=*/session_id);
-          if (ds) {
-            StartDataSourceImpl(ds);
-            session.num_unbound_data_sources++;
-          }
-        }
-      }
+  auto add_range = [&](uint32_t id_start, uint32_t id_end, uint32_t msg_id) {
+    PERFETTO_DCHECK(id_end > id_start);
+    PERFETTO_DCHECK(id_start >= kDirectlyIndexLimit);
+    ranges.emplace_back(id_start);
+    ranges.emplace_back(id_end);
+    ranges.emplace_back(kAllowed | msg_id);
+  };
 
-      int num_ds = session.num_unbound_data_sources;
-      auto on_setup = opts.on_setup;
-      if (on_setup) {
-        backend.producer->OnStartupTracingSetup();
-        task_runner_->PostTask([on_setup, num_ds] {
-          on_setup(Tracing::OnStartupTracingSetupCallbackArgs{num_ds});
-        });
+  // Merges overlay entries into the current message being built.
+  //
+  // This function processes overlay entries for the current message up to (and
+  // including) the given |field_id|. Since both base bytecode and overlay are
+  // sorted by (msg_index, field_id), we can use a two-pointer merge approach:
+  // - Entries with field_id < the given field_id are ADDed as new fields
+  // - An entry with field_id == the given field_id is an UPGRADE (returned)
+  // - Entries with field_id > the given field_id are left for later
+  //
+  // Pass std::numeric_limits<uint32_t>::max() as field_id to drain all
+  // remaining entries for the current message (called at EndOfMessage).
+  //
+  // Returns:
+  // - The msg_id to use if there's an exact match (upgrade case)
+  // - 0 if no match (use the base bytecode's msg_id)
+  // - std::numeric_limits<uint32_t>::max() on error
+  constexpr uint32_t kOverlayError = std::numeric_limits<uint32_t>::max();
+  auto process_overlay = [&](uint32_t field_id) -> uint32_t {
+    while (overlay_idx < overlay.size()) {
+      const OverlayEntry& entry = overlay[overlay_idx];
+
+      // Stop if this entry is for a later message or a later field.
+      if (entry.msg_index > current_msg_index ||
+          (entry.msg_index == current_msg_index && entry.field_id > field_id)) {
+        break;
       }
 
-      if (num_ds > 0) {
-        backend.startup_sessions.push_back(std::move(session));
+      // Message indexes are dense and we verified above that we are sorted
+      // so this must be for the current message.
+      PERFETTO_DCHECK(entry.msg_index == current_msg_index);
 
-        if (opts.timeout_ms > 0) {
-          task_runner_->PostDelayedTask(
-              [this, session_id, backend_type] {
-                AbortStartupTracingSession(session_id, backend_type);
-              },
-              opts.timeout_ms);
-        }
+      // Exact match - this is an upgrade. Return the msg_id for the caller.
+      if (entry.field_id == field_id) {
+        ++overlay_idx;
+        return entry.message_id;
       }
-      return;
-    }
-    PERFETTO_DFATAL("Invalid startup tracing session backend");
-  });
-
-  return std::unique_ptr<StartupTracingSession>(
-      new StartupTracingSessionImpl(this, session_id, backend_type));
-}
 
-// Must not be called from the SDK's internal thread.
-std::unique_ptr<StartupTracingSession>
-TracingMuxerImpl::CreateStartupTracingSessionBlocking(
-    const TraceConfig& config,
-    Tracing::SetupStartupTracingOpts opts) {
-  auto previous_on_setup = std::move(opts.on_setup);
-  PERFETTO_CHECK(!task_runner_->RunsTasksOnCurrentThread());
-  base::WaitableEvent event;
-  // It is safe to capture by reference because once on_setup is called only
-  // once before this method returns.
-  opts.on_setup = [&](Tracing::OnStartupTracingSetupCallbackArgs args) {
-    if (previous_on_setup) {
-      previous_on_setup(std::move(args));
+      // entry_field < field_id: This is a new field to ADD.
+      if (entry.field_id < kDirectlyIndexLimit) {
+        add_directly_indexed_field(entry.field_id, entry.message_id);
+      } else {
+        add_range(entry.field_id, entry.field_id + 1, entry.message_id);
+      }
+      ++overlay_idx;
     }
-    event.Notify();
+    // No match found.
+    return 0;
   };
-  auto session = CreateStartupTracingSession(config, std::move(opts));
-  event.Wait();
-  return session;
-}
 
-void TracingMuxerImpl::AbortStartupTracingSession(
-    TracingSessionGlobalID session_id,
-    BackendType backend_type) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
+  bool is_eom = true;
+  for (size_t i = 0; i < words.size(); ++i) {
+    const uint32_t word = words[i];
+    const bool has_next_word = i < words.size() - 1;
+    const uint32_t opcode = word & kOpcodeMask;
+    const uint32_t field_id = word >> kOpcodeShift;
 
-  for (RegisteredProducerBackend& backend : producer_backends_) {
-    if (backend_type != backend.type)
-      continue;
+    is_eom = opcode == kFilterOpcode_EndOfMessage;
+    if (field_id == 0 && opcode != kFilterOpcode_EndOfMessage) {
+      PERFETTO_DLOG("bytecode error @ word %zu, invalid field id (0)", i);
+      return false;
+    }
 
-    auto session_it = std::find_if(
-        backend.startup_sessions.begin(), backend.startup_sessions.end(),
-        [session_id](const RegisteredStartupSession& session) {
-          return session.session_id == session_id;
-        });
+    if (opcode == kFilterOpcode_SimpleField ||
+        opcode == kFilterOpcode_NestedField ||
+        opcode == kFilterOpcode_FilterString ||
+        opcode == kFilterOpcode_FilterStringWithType) {
+      // Field words are organized as follow:
+      // MSB: 1 if allowed, 0 if not allowed.
+      // Remaining bits:
+      //   Message index in the case of nested (non-simple) messages.
+      //   0x7fff0000-0x7ffffffe for string fields with semantic type.
+      //   0x7ffffffe in the case of string fields which need filtering.
+      //   0x7fffffff in the case of simple fields.
+      uint32_t msg_id;
+      if (opcode == kFilterOpcode_SimpleField) {
+        msg_id = kSimpleField;
+      } else if (opcode == kFilterOpcode_FilterString) {
+        msg_id = kFilterStringField;
+      } else if (opcode == kFilterOpcode_FilterStringWithType) {
+        // The next word in the bytecode contains the semantic type.
+        if (!has_next_word) {
+          PERFETTO_DLOG(
+              "bytecode error @ word %zu: unterminated filter string with type",
+              i);
+          return false;
+        }
+        uint32_t semantic_type = words[++i];
+        msg_id =
+            kFilterStringFieldWithType | (semantic_type & kSemanticTypeMask);
+      } else {  // FILTER_OPCODE_NESTED_FIELD
+        // The next word in the bytecode contains the message index.
+        if (!has_next_word) {
+          PERFETTO_DLOG("bytecode error @ word %zu: unterminated nested field",
+                        i);
+          return false;
+        }
+        msg_id = words[++i];
+        max_msg_index = std::max(max_msg_index, msg_id);
+      }
 
-    // The startup session may have already been aborted or fully adopted.
-    if (session_it == backend.startup_sessions.end())
-      return;
-    if (session_it->is_aborting)
-      return;
+      // Process overlay: add any fields that come before this one, and check
+      // if this field should be upgraded.
+      uint32_t overlay_msg_id = process_overlay(field_id);
+      if (overlay_msg_id == kOverlayError) {
+        return false;
+      }
+      if (overlay_msg_id != 0) {
+        msg_id = overlay_msg_id;
+      }
 
-    session_it->is_aborting = true;
+      if (field_id < kDirectlyIndexLimit) {
+        add_directly_indexed_field(field_id, msg_id);
+      } else {
+        // In the case of a large field id (rare) we waste an extra word and
+        // represent it as a range. Doesn't make sense to introduce extra
+        // complexity to deal with rare cases like this.
+        add_range(field_id, field_id + 1, msg_id);
+      }
+    } else if (opcode == kFilterOpcode_SimpleFieldRange) {
+      if (!has_next_word) {
+        PERFETTO_DLOG("bytecode error @ word %zu: unterminated range", i);
+        return false;
+      }
+      const uint32_t range_len = words[++i];
+      const uint32_t range_end = field_id + range_len;  // STL-style, excl.
+      uint32_t id = field_id;
 
-    // Iterate all data sources and abort them if they weren't adopted yet.
-    for (const auto& rds : data_sources_) {
-      DataSourceStaticState* static_state = rds.static_state;
-      for (uint32_t i = 0; i < kMaxDataSourceInstances; i++) {
-        auto* internal_state = static_state->TryGet(i);
-        if (internal_state &&
-            internal_state->startup_target_buffer_reservation.load(
-                std::memory_order_relaxed) &&
-            internal_state->data_source_instance_id == 0 &&
-            internal_state->startup_session_id == session_id) {
-          PERFETTO_DLOG(
-              "Aborting startup tracing for data source %s (target buffer "
-              "reservation %" PRIu16 ")",
-              rds.descriptor.name().c_str(),
-              internal_state->startup_target_buffer_reservation.load(
-                  std::memory_order_relaxed));
+      // Here's the subtle complexity: at the bytecode level, we don't know
+      // anything about the kDirectlyIndexLimit. It is legit to define a range
+      // that spans across the direct-indexing threshold (e.g. 126-132). In that
+      // case we want to add all the elements < the indexing to the O(1) bucket
+      // and add only the remaining range as a non-indexed range.
+      for (; id < range_end && id < kDirectlyIndexLimit; ++id)
+        add_directly_indexed_field(id, kAllowed | kSimpleField);
+      PERFETTO_DCHECK(id >= kDirectlyIndexLimit || id == range_end);
+      if (id < range_end)
+        add_range(id, range_end, kSimpleField);
+    } else if (opcode == kFilterOpcode_EndOfMessage) {
+      // Drain any remaining overlay entries for this message.
+      if (process_overlay(std::numeric_limits<uint32_t>::max()) ==
+          kOverlayError) {
+        return false;
+      }
 
-          // Abort the instance asynchronously by stopping it. From this point
-          // onwards, the service will not be able to adopt it via
-          // StartDataSource().
-          session_it->num_aborting_data_sources++;
-          StopDataSource_AsyncBeginImpl(
-              FindDataSourceRes(static_state, internal_state, i,
-                                rds.requires_callbacks_under_lock));
+      // Verify that the ranges are non-overlapping. Assumes that the ranges
+      // are sorted (they are, because the bytecode is sorted).
+      for (size_t r = 0; r + 3 < ranges.size(); r += 3) {
+        const uint32_t prev_range_end = ranges[r + 1];
+        const uint32_t curr_range_start = ranges[r + 3];
+        if (curr_range_start < prev_range_end) {
+          PERFETTO_DLOG(
+              "bytecode error @ message %u: overlapping ranges [%u, %u) "
+              "and [%u, ...)",
+              current_msg_index, ranges[r], prev_range_end, curr_range_start);
+          return false;
         }
       }
+
+      // For each message append:
+      // 1. The "header" word telling how many directly indexed fields there
+      //    are.
+      // 2. The words for the directly indexed fields (id < 128).
+      // 3. The rest of the fields, encoded as ranges.
+      // Also update the |message_offset_| index to remember the word offset for
+      // the current message.
+      message_offset_.emplace_back(static_cast<uint32_t>(words_.size()));
+      words_.emplace_back(static_cast<uint32_t>(direct_indexed_fields.size()));
+      words_.insert(words_.end(), direct_indexed_fields.begin(),
+                    direct_indexed_fields.end());
+      words_.insert(words_.end(), ranges.begin(), ranges.end());
+      direct_indexed_fields.clear();
+      ranges.clear();
+      ++current_msg_index;
+    } else {
+      PERFETTO_DLOG("bytecode error @ word %zu: invalid opcode (%x)", i, word);
+      return false;
     }
+  }  // (for word in bytecode).
 
-    // If we did everything right, we should have aborted all still-unbound data
-    // source instances.
-    PERFETTO_DCHECK(session_it->num_unbound_data_sources ==
-                    session_it->num_aborting_data_sources);
+  if (!is_eom) {
+    PERFETTO_DLOG(
+        "bytecode error: end of message not the last word in the bytecode");
+    return false;
+  }
 
-    if (session_it->num_aborting_data_sources == 0) {
-      if (session_it->on_aborted)
-        task_runner_->PostTask(session_it->on_aborted);
+  if (overlay_idx != overlay.size()) {
+    PERFETTO_DLOG("bytecode error: overlay contains %zu unconsumed entries",
+                  overlay.size() - overlay_idx);
+    return false;
+  }
 
-      backend.startup_sessions.erase(session_it);
-    }
-    return;
+  if (max_msg_index > 0 && max_msg_index >= message_offset_.size()) {
+    PERFETTO_DLOG(
+        "bytecode error: a message index (%u) is out of range "
+        "(num_messages=%zu)",
+        max_msg_index, message_offset_.size());
+    return false;
   }
-  // We might reach here in tests because when we start a trace, we post the
-  // Task(AbortStartupTrace, delay=timeout). When we do
-  // perfetto::ResetForTesting, we sweep dead backends, and we are not able to
-  // kill those delayed tasks because TaskRunner doesn't have support for
-  // deleting scheduled future tasks and TaskRunner doesn't have any API for us
-  // to wait for the completion of all the scheduled tasks (apart from
-  // deleting the TaskRunner) and we want to avoid doing that because we need
-  // a long running TaskRunner in muxer.
-  PERFETTO_DLOG("Invalid startup tracing session backend");
+
+  // Add a final entry to |message_offset_| so we can tell where the last
+  // message ends without an extra branch in the Query() hotpath.
+  message_offset_.emplace_back(static_cast<uint32_t>(words_.size()));
+
+  return true;
 }
 
-void TracingMuxerImpl::InitializeInstance(const TracingInitArgs& args) {
-  if (instance_ != TracingMuxerFake::Get()) {
-    // The tracing muxer was already initialized. We might need to initialize
-    // additional backends that were not configured earlier.
-    auto* muxer = static_cast<TracingMuxerImpl*>(instance_);
-    muxer->task_runner_->PostTask([muxer, args] { muxer->AddBackends(args); });
-    return;
+FilterBytecodeParser::QueryResult FilterBytecodeParser::Query(
+    uint32_t msg_index,
+    uint32_t field_id) const {
+  FilterBytecodeParser::QueryResult res{false, 0u, 0u};
+  if (static_cast<uint64_t>(msg_index) + 1 >=
+      static_cast<uint64_t>(message_offset_.size())) {
+    return res;
   }
-  // If we previously had a TracingMuxerImpl instance which was reset,
-  // reinitialize and reuse it instead of trying to create a new one. See
-  // ResetForTesting().
-  if (g_prev_instance) {
-    auto* muxer = g_prev_instance;
-    g_prev_instance = nullptr;
-    instance_ = muxer;
-    muxer->task_runner_->PostTask([muxer, args] {
-      muxer->Initialize(args);
-      muxer->AddBackends(args);
-    });
+  const uint32_t start_offset = message_offset_[msg_index];
+  // These are DCHECKs and not just CHECKS because the |words_| is populated
+  // by the LoadInternal call above. These cannot be violated with a malformed
+  // bytecode.
+  PERFETTO_DCHECK(start_offset < words_.size());
+  const uint32_t* word = &words_[start_offset];
+  const uint32_t end_off = message_offset_[msg_index + 1];
+  const uint32_t* const end = words_.data() + end_off;
+  PERFETTO_DCHECK(end > word && end <= words_.data() + words_.size());
+  const uint32_t num_directly_indexed = *(word++);
+  PERFETTO_DCHECK(num_directly_indexed <= kDirectlyIndexLimit);
+  PERFETTO_DCHECK(word + num_directly_indexed <= end);
+  uint32_t field_state = 0;
+  if (PERFETTO_LIKELY(field_id < num_directly_indexed)) {
+    PERFETTO_DCHECK(&word[field_id] < end);
+    field_state = word[field_id];
   } else {
-    new TracingMuxerImpl(args);
-  }
+    for (word = word + num_directly_indexed; word + 2 < end;) {
+      const uint32_t range_start = *(word++);
+      const uint32_t range_end = *(word++);
+      const uint32_t range_state = *(word++);
+      if (field_id >= range_start && field_id < range_end) {
+        field_state = range_state;
+        break;
+      }
+    }  // for (word in ranges)
+  }  // if (field_id >= num_directly_indexed)
+
+  res.allowed = (field_state & kAllowed) != 0;
+  res.nested_msg_index = field_state & ~kAllowed;
+  // Extract semantic type if this is a FilterStringFieldWithType.
+  // Exclude kFilterStringField (0x7ffffffe) which doesn't have semantic type.
+  if ((res.nested_msg_index & kFilterStringFieldWithTypeMask) ==
+          kFilterStringFieldWithType &&
+      res.nested_msg_index != kFilterStringField) {
+    res.semantic_type = res.nested_msg_index & kSemanticTypeMask;
+  }
+  PERFETTO_DCHECK(!res.nested_msg_field() ||
+                  res.nested_msg_index < message_offset_.size() - 1);
+  return res;
 }
 
-// static
-void TracingMuxerImpl::ResetForTesting() {
-  // Ideally we'd tear down the entire TracingMuxerImpl, but the lifetimes of
-  // various objects make that a non-starter. In particular:
-  //
-  // 1) Any thread that has entered a trace event has a TraceWriter, which holds
-  //    a reference back to ProducerImpl::service_.
-  //
-  // 2) ProducerImpl::service_ has a reference back to the ProducerImpl.
-  //
-  // 3) ProducerImpl holds reference to TracingMuxerImpl::task_runner_, which in
-  //    turn depends on TracingMuxerImpl itself.
-  //
-  // Because of this, it's not safe to deallocate TracingMuxerImpl until all
-  // threads have dropped their TraceWriters. Since we can't really ask the
-  // caller to guarantee this, we'll instead reset enough of the muxer's state
-  // so that it can be reinitialized later and ensure all necessary objects from
-  // the old state remain alive until all references have gone away.
-  auto* muxer = reinterpret_cast<TracingMuxerImpl*>(instance_);
+}  // namespace protozero
+// gen_amalgamated begin source: src/protozero/filtering/string_filter.cc
+// gen_amalgamated begin header: src/protozero/filtering/string_filter.h
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-  base::WaitableEvent reset_done;
-  auto do_reset = [muxer, &reset_done] {
-    // Unregister all data sources so they don't interfere with any future
-    // tracing sessions.
-    for (RegisteredDataSource& rds : muxer->data_sources_) {
-      for (RegisteredProducerBackend& backend : muxer->producer_backends_) {
-        if (!backend.producer->service_)
-          continue;
-        backend.producer->service_->UnregisterDataSource(rds.descriptor.name());
-      }
-    }
-    for (auto& backend : muxer->consumer_backends_) {
-      // Check that no consumer session is currently active on any backend.
-      for (auto& consumer : backend.consumers)
-        PERFETTO_CHECK(!consumer->service_);
+#ifndef SRC_PROTOZERO_FILTERING_STRING_FILTER_H_
+#define SRC_PROTOZERO_FILTERING_STRING_FILTER_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <regex>
+#include <string>
+#include <string_view>
+#include <vector>
+
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/public/compiler.h"
+
+namespace protozero {
+
+// Performs filtering of strings in an "iptables" style. See the comments in
+// |TraceConfig.TraceFilter| for information on how this class works.
+class StringFilter {
+ public:
+  // Bitmask for semantic types. Supports up to 128 semantic types.
+  class SemanticTypeMask {
+   public:
+    using Word = uint64_t;
+    static constexpr size_t kBitsPerWord = sizeof(Word) * 8;
+    static constexpr size_t kLimit = 128;
+
+    // Returns a SemanticTypeMask with only bit 0 set (UNSPECIFIED only).
+    // UNSPECIFIED is its own category and only matches if bit 0 is set.
+    static constexpr SemanticTypeMask Unspecified() {
+      return SemanticTypeMask(Word(1), Word(0));
     }
-    for (auto& backend : muxer->producer_backends_) {
-      backend.producer->muxer_ = nullptr;
-      backend.producer->DisposeConnection();
-      muxer->dead_backends_.push_back(std::move(backend));
+
+    // Creates a SemanticTypeMask from raw word values (for testing).
+    static constexpr SemanticTypeMask FromWords(Word w0, Word w1) {
+      return SemanticTypeMask(w0, w1);
     }
-    muxer->consumer_backends_.clear();
-    muxer->producer_backends_.clear();
-    muxer->interceptors_.clear();
 
-    for (auto& ds : muxer->data_sources_) {
-      ds.static_state->ResetForTesting();
+    // Default constructor: no bits set.
+    constexpr SemanticTypeMask() = default;
+
+    // Sets the bit for |semantic_type|.
+    PERFETTO_ALWAYS_INLINE void Set(uint32_t semantic_type) {
+      PERFETTO_DCHECK(semantic_type < kLimit);
+      uint32_t word_index = semantic_type / kBitsPerWord;
+      uint32_t bit_index = semantic_type % kBitsPerWord;
+      words_[word_index] |= Word(1) << bit_index;
     }
 
-    muxer->data_sources_.clear();
-    muxer->next_data_source_index_ = 0;
+    // Returns true if the bit for |semantic_type| is set.
+    PERFETTO_ALWAYS_INLINE bool IsSet(uint32_t semantic_type) const {
+      // If beyond supported range, return true (safe default: apply rule).
+      if (PERFETTO_UNLIKELY(semantic_type >= kLimit)) {
+        return true;
+      }
+      uint32_t word_index = semantic_type / kBitsPerWord;
+      uint32_t bit_index = semantic_type % kBitsPerWord;
+      return (words_[word_index] & (Word(1) << bit_index)) != 0;
+    }
 
-    // Free all backends without active trace writers or other inbound
-    // references. Note that even if all the backends get swept, the muxer still
-    // needs to stay around since |task_runner_| is assumed to be long-lived.
-    muxer->SweepDeadBackends();
+   private:
+    constexpr SemanticTypeMask(Word w0, Word w1) : words_{w0, w1} {}
 
-    // Make sure we eventually discard any per-thread trace writers from the
-    // previous instance.
-    muxer->muxer_id_for_testing_++;
+    std::array<Word, 2> words_ = {};
+  };
 
-    g_prev_instance = muxer;
-    instance_ = TracingMuxerFake::Get();
-    reset_done.Notify();
+  enum class Policy : uint8_t {
+    kMatchRedactGroups = 1,
+    kAtraceMatchRedactGroups = 2,
+    kMatchBreak = 3,
+    kAtraceMatchBreak = 4,
+    kAtraceRepeatedSearchRedactGroups = 5,
   };
 
-  // Some tests run the muxer and the test on the same thread. In these cases,
-  // we can reset synchronously.
-  if (muxer->task_runner_->RunsTasksOnCurrentThread()) {
-    do_reset();
-  } else {
-    muxer->task_runner_->PostTask(std::move(do_reset));
-    reset_done.Wait();
+  // Adds a new rule for filtering strings.
+  //
+  // If `name` is non-empty and a rule with the same name already exists, it
+  // will be replaced; otherwise the rule is appended.
+  //
+  // `semantic_type_mask` is a bitmask indicating which semantic types this rule
+  // applies to. UNSPECIFIED (0) is its own category and only matches if bit 0
+  // is explicitly set. Defaults to matching only UNSPECIFIED.
+  void AddRule(
+      Policy policy,
+      std::string_view pattern,
+      std::string atrace_payload_starts_with,
+      std::string name = {},
+      SemanticTypeMask semantic_type_mask = SemanticTypeMask::Unspecified());
+
+  // Tries to filter the given string. Returns true if the string was modified
+  // in any way, false otherwise. Uses semantic_type=0 (unspecified).
+  bool MaybeFilter(char* ptr, size_t len) const {
+    return MaybeFilter(ptr, len, /*semantic_type=*/0);
+  }
+
+  // Tries to filter the given string with a specific semantic type.
+  // Only rules that match the semantic type (or have no type restriction)
+  // are applied.
+  bool MaybeFilter(char* ptr, size_t len, uint32_t semantic_type) const {
+    if (len == 0 || rules_.empty()) {
+      return false;
+    }
+    return MaybeFilterInternal(ptr, len, semantic_type);
   }
-}
 
-// static
-void TracingMuxerImpl::Shutdown() {
-  auto* muxer = reinterpret_cast<TracingMuxerImpl*>(instance_);
+ private:
+  struct Rule {
+    Policy policy;
+    std::regex pattern;
+    std::string atrace_payload_starts_with;
+    std::string name;
+    SemanticTypeMask semantic_type_mask = SemanticTypeMask::Unspecified();
+  };
+
+  bool MaybeFilterInternal(char* ptr, size_t len, uint32_t semantic_type) const;
+
+  // All rules, in the order they were added.
+  std::vector<Rule> rules_;
+};
+
+}  // namespace protozero
+
+#endif  // SRC_PROTOZERO_FILTERING_STRING_FILTER_H_
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-  // Shutting down on the muxer thread would lead to a deadlock.
-  PERFETTO_CHECK(!muxer->task_runner_->RunsTasksOnCurrentThread());
-  muxer->DestroyStoppedTraceWritersForCurrentThread();
+// gen_amalgamated expanded: #include "src/protozero/filtering/string_filter.h"
 
-  std::unique_ptr<base::TaskRunner> owned_task_runner(
-      muxer->task_runner_.get());
-  base::WaitableEvent shutdown_done;
-  owned_task_runner->PostTask([muxer, &shutdown_done] {
-    // Check that no consumer session is currently active on any backend.
-    // Producers will be automatically disconnected as a part of deleting the
-    // muxer below.
-    for (auto& backend : muxer->consumer_backends_) {
-      for (auto& consumer : backend.consumers) {
-        PERFETTO_CHECK(!consumer->service_);
-      }
-    }
-    // Make sure no trace writers are lingering around on the muxer thread. Note
-    // that we can't do this for any arbitrary thread in the process; it is the
-    // caller's responsibility to clean them up before shutting down Perfetto.
-    muxer->DestroyStoppedTraceWritersForCurrentThread();
-    // The task runner must be deleted outside the muxer thread. This is done by
-    // `owned_task_runner` above.
-    muxer->task_runner_.release();
-    auto* platform = muxer->platform_;
-    delete muxer;
-    instance_ = TracingMuxerFake::Get();
-    platform->Shutdown();
-    shutdown_done.Notify();
-  });
-  shutdown_done.Wait();
-}
+#include <algorithm>
+#include <cstdint>
+#include <cstring>
+#include <regex>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
 
-TracingMuxer::~TracingMuxer() = default;
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/public/compiler.h"
 
-static_assert(std::is_same<internal::BufferId, BufferID>::value,
-              "public's BufferId and tracing/core's BufferID diverged");
+namespace protozero {
+namespace {
 
-}  // namespace internal
-}  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/internal/track_event_internal.cc
-// gen_amalgamated begin header: gen/protos/perfetto/common/track_event_descriptor.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+using Matches = std::match_results<char*>;
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_TRACK_EVENT_DESCRIPTOR_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_TRACK_EVENT_DESCRIPTOR_PROTO_H_
+constexpr std::string_view kRedacted = "P60REDACTED";
+constexpr char kRedactedDash = '-';
 
-#include <stddef.h>
-#include <stdint.h>
+// Returns a pointer to the first character after the tgid pipe character in
+// the atrace string given by [ptr, end). Returns null if no such character
+// exists.
+//
+// Examples:
+// E|1024 -> nullptr
+// foobarbaz -> nullptr
+// B|1024|x -> pointer to x
+PERFETTO_ALWAYS_INLINE const char* FindAtracePayloadPtr(const char* ptr,
+                                                        const char* end) {
+  // Don't even bother checking any strings which are so short that they could
+  // not contain a post-tgid section. This filters out strings like "E|" which
+  // emitted by Bionic.
+  //
+  // Also filter out any other strings starting with "E" as they never contain
+  // anything past the tgid: this removes >half of the strings for ~zero cost.
+  static constexpr size_t kEarliestSecondPipeIndex = 2;
+  const char* search_start = ptr + kEarliestSecondPipeIndex;
+  if (PERFETTO_UNLIKELY(search_start >= end || *ptr == 'E')) {
+    return nullptr;
+  }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  // We skipped past the first '|' character by starting at the character at
+  // index 2. Just find the next pipe character (i.e. the one after tgid) using
+  // memchr.
+  const char* pipe = static_cast<const char*>(
+      memchr(search_start, '|', size_t(end - search_start)));
+  return pipe ? pipe + 1 : nullptr;
+}
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+PERFETTO_ALWAYS_INLINE bool StartsWith(const char* ptr,
+                                       const char* end,
+                                       const std::string& starts_with) {
+  // Verify that the atrace string has enough characters to match against all
+  // the characters in the "starts with" string.
+  size_t len = starts_with.size();
+  if (PERFETTO_UNLIKELY(ptr + len > end))
+    return false;
 
-class TrackEventCategory;
+  // Empty string matches everything.
+  if (PERFETTO_UNLIKELY(len == 0))
+    return true;
 
-class TrackEventDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  TrackEventDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrackEventDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrackEventDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_available_categories() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> available_categories() const { return GetRepeated<::protozero::ConstBytes>(1); }
-};
+  // Quick rejection: check first character before expensive memcmp.
+  // This is very effective since most strings don't match.
+  if (PERFETTO_LIKELY(*ptr != *starts_with.data()))
+    return false;
 
-class TrackEventDescriptor : public ::protozero::Message {
- public:
-  using Decoder = TrackEventDescriptor_Decoder;
-  enum : int32_t {
-    kAvailableCategoriesFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrackEventDescriptor"; }
+  // If first char matches, do full memcmp for remaining characters.
+  return memcmp(ptr + 1, starts_with.data() + 1, len - 1) == 0;
+}
 
+void RedactMatches(const Matches& matches) {
+  // Go through every group in the matches.
+  for (size_t i = 1; i < matches.size(); ++i) {
+    const auto& match = matches[i];
+    PERFETTO_CHECK(match.second >= match.first);
 
-  using FieldMetadata_AvailableCategories =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TrackEventCategory,
-      TrackEventDescriptor>;
+    // Overwrite the match with characters from |kRedacted|. If match is
+    // smaller, we will not use all of |kRedacted| but that's fine (i.e. we
+    // will overwrite with a truncated |kRedacted|).
+    auto match_len = static_cast<size_t>(match.second - match.first);
+    size_t redacted_len = std::min(match_len, kRedacted.size());
+    memcpy(match.first, kRedacted.data(), redacted_len);
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AvailableCategories kAvailableCategories() { return {}; }
-  template <typename T = TrackEventCategory> T* add_available_categories() {
-    return BeginNestedMessage<T>(1);
+    // Overwrite any characters after |kRedacted| with |kRedactedDash|.
+    memset(match.first + redacted_len, kRedactedDash, match_len - redacted_len);
   }
+}
 
-};
+}  // namespace
 
-class TrackEventCategory_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  TrackEventCategory_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrackEventCategory_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrackEventCategory_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_description() const { return at<2>().valid(); }
-  ::protozero::ConstChars description() const { return at<2>().as_string(); }
-  bool has_tags() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> tags() const { return GetRepeated<::protozero::ConstChars>(3); }
-};
+void StringFilter::AddRule(Policy policy,
+                           std::string_view pattern_str,
+                           std::string atrace_payload_starts_with,
+                           std::string name,
+                           SemanticTypeMask semantic_type_mask) {
+  Rule new_rule{
+      policy,
+      std::regex(pattern_str.begin(), pattern_str.end(),
+                 std::regex::ECMAScript | std::regex_constants::optimize),
+      std::move(atrace_payload_starts_with), std::move(name),
+      semantic_type_mask};
+  // If name is non-empty, look for existing rule with same name and replace.
+  if (!new_rule.name.empty()) {
+    for (Rule& existing : rules_) {
+      if (existing.name == new_rule.name) {
+        existing = std::move(new_rule);
+        return;
+      }
+    }
+  }
+  rules_.push_back(std::move(new_rule));
+}
 
-class TrackEventCategory : public ::protozero::Message {
- public:
-  using Decoder = TrackEventCategory_Decoder;
-  enum : int32_t {
-    kNameFieldNumber = 1,
-    kDescriptionFieldNumber = 2,
-    kTagsFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrackEventCategory"; }
-
-
-  using FieldMetadata_Name =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TrackEventCategory>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Description =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TrackEventCategory>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Description kDescription() { return {}; }
-  void set_description(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Description::kFieldId, data, size);
-  }
-  void set_description(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Description::kFieldId, chars.data, chars.size);
-  }
-  void set_description(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Description::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Tags =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TrackEventCategory>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Tags kTags() { return {}; }
-  void add_tags(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Tags::kFieldId, data, size);
-  }
-  void add_tags(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Tags::kFieldId, chars.data, chars.size);
-  }
-  void add_tags(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Tags::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
+bool StringFilter::MaybeFilterInternal(char* ptr,
+                                       size_t len,
+                                       uint32_t semantic_type) const {
+  std::match_results<char*> matches;
+  bool atrace_find_tried = false;
+  const char* atrace_payload_ptr = nullptr;
+  for (const Rule& rule : rules_) {
+    if (!rule.semantic_type_mask.IsSet(semantic_type)) {
+      continue;
+    }
+    switch (rule.policy) {
+      case Policy::kMatchRedactGroups:
+      case Policy::kMatchBreak:
+        if (PERFETTO_UNLIKELY(
+                std::regex_match(ptr, ptr + len, matches, rule.pattern))) {
+          if (rule.policy == Policy::kMatchBreak) {
+            return false;
+          }
+          RedactMatches(matches);
+          return true;
+        }
+        break;
+      case Policy::kAtraceMatchRedactGroups:
+      case Policy::kAtraceMatchBreak:
+        atrace_payload_ptr = atrace_find_tried
+                                 ? atrace_payload_ptr
+                                 : FindAtracePayloadPtr(ptr, ptr + len);
+        atrace_find_tried = true;
+        if (atrace_payload_ptr &&
+            StartsWith(atrace_payload_ptr, ptr + len,
+                       rule.atrace_payload_starts_with) &&
+            std::regex_match(ptr, ptr + len, matches, rule.pattern)) {
+          if (rule.policy == Policy::kAtraceMatchBreak) {
+            return false;
+          }
+          RedactMatches(matches);
+          return true;
+        }
+        break;
+      case Policy::kAtraceRepeatedSearchRedactGroups:
+        atrace_payload_ptr = atrace_find_tried
+                                 ? atrace_payload_ptr
+                                 : FindAtracePayloadPtr(ptr, ptr + len);
+        atrace_find_tried = true;
+        if (atrace_payload_ptr && StartsWith(atrace_payload_ptr, ptr + len,
+                                             rule.atrace_payload_starts_with)) {
+          auto beg = std::regex_iterator<char*>(ptr, ptr + len, rule.pattern);
+          auto end = std::regex_iterator<char*>();
+          bool has_any_matches = beg != end;
+          for (auto it = std::move(beg); it != end; ++it) {
+            RedactMatches(*it);
+          }
+          if (has_any_matches) {
+            return true;
+          }
+        }
+        break;
+    }
   }
-};
+  return false;
+}
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/clock_snapshot.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+}  // namespace protozero
+// gen_amalgamated begin source: src/protozero/filtering/message_filter.cc
+// gen_amalgamated begin header: src/protozero/filtering/message_filter.h
+// gen_amalgamated begin header: src/protozero/filtering/message_tokenizer.h
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CLOCK_SNAPSHOT_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CLOCK_SNAPSHOT_PROTO_H_
+#ifndef SRC_PROTOZERO_FILTERING_MESSAGE_TOKENIZER_H_
+#define SRC_PROTOZERO_FILTERING_MESSAGE_TOKENIZER_H_
 
-#include <stddef.h>
 #include <stdint.h>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+namespace protozero {
 
-class ClockSnapshot_Clock;
-enum BuiltinClock : int32_t;
-
-namespace perfetto_pbzero_enum_ClockSnapshot_Clock {
-enum BuiltinClocks : int32_t {
-  UNKNOWN = 0,
-  REALTIME = 1,
-  REALTIME_COARSE = 2,
-  MONOTONIC = 3,
-  MONOTONIC_COARSE = 4,
-  MONOTONIC_RAW = 5,
-  BOOTTIME = 6,
-  BUILTIN_CLOCK_MAX_ID = 63,
-};
-} // namespace perfetto_pbzero_enum_ClockSnapshot_Clock
-using ClockSnapshot_Clock_BuiltinClocks = perfetto_pbzero_enum_ClockSnapshot_Clock::BuiltinClocks;
+// A helper class for schema-less tokenizing of protobuf messages.
+// This class takes a stream of proto-encoded bytes, pushed one by one in input
+// via Push(octet), and returns a stream of tokens (each Push() call can return
+// 0 or 1 token).
+// A "token" contains metadata about a field, specifically: its ID, its wire
+// type and:
+//  - For varint and fixed32/64 fields: its payload.
+//  - For string and bytes fields: the length of its payload.
+//    In this case the caller is supposed to "eat" those N bytes before calling
+//    Push() again.
+// Note that this class cannot differentiate between a string/bytes field or
+// a submessage, because they are encoded in the same way. The caller is
+// supposed to know whether a field can be recursed into by just keep calling
+// Push() or is a string that should be skipped.
+// This is inline to allow the compiler to see through the Push method and
+// avoid a function call for each byte.
+class MessageTokenizer {
+ public:
+  struct Token {
+    uint32_t field_id;  // 0 == not valid.
+    proto_utils::ProtoWireType type;
 
+    // For kLengthDelimited, |value| represent the length of the payload.
+    uint64_t value;
 
-constexpr ClockSnapshot_Clock_BuiltinClocks ClockSnapshot_Clock_BuiltinClocks_MIN = ClockSnapshot_Clock_BuiltinClocks::UNKNOWN;
-constexpr ClockSnapshot_Clock_BuiltinClocks ClockSnapshot_Clock_BuiltinClocks_MAX = ClockSnapshot_Clock_BuiltinClocks::BUILTIN_CLOCK_MAX_ID;
+    inline bool valid() const { return field_id != 0; }
+    bool operator==(const Token& o) const {
+      return field_id == o.field_id && type == o.type && value == o.value;
+    }
+  };
 
+  // Pushes a byte in input and returns a token, only when getting to the last
+  // byte of each field. Specifically:
+  // - For varint and fixed32 fields, the Token is returned after the last byte
+  //   of the numeric payload is pushed.
+  // - For length-delimited fields, this returns after the last byte of the
+  //   length is pushed (i.e. right before the payload starts). The caller is
+  //   expected to either skip the next |value| bytes (in the case of a string
+  //   or bytes fields) or keep calling Push, in the case of a submessage.
+  inline Token Push(uint8_t octet) {
+    using protozero::proto_utils::ProtoWireType;
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ClockSnapshot_Clock_BuiltinClocks_Name(::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::UNKNOWN:
-    return "UNKNOWN";
+    // Parsing a fixed32/64 field is the only case where we don't have to do
+    // any varint decoding. This is why this block is before the remaining
+    // switch statement below (all the rest is a varint).
+    if (PERFETTO_UNLIKELY(state_ == kFixedIntValue)) {
+      PERFETTO_DCHECK(fixed_int_bits_ == 32 || fixed_int_bits_ == 64);
+      fixed_int_value_ |= static_cast<uint64_t>(octet) << fixed_int_shift_;
+      fixed_int_shift_ += 8;
+      if (fixed_int_shift_ < fixed_int_bits_)
+        return Token{};  // Intermediate byte of a fixed32/64.
+      auto wire_type = fixed_int_bits_ == 32 ? ProtoWireType::kFixed32
+                                             : ProtoWireType::kFixed64;
+      uint64_t fixed_int_value = fixed_int_value_;
+      fixed_int_value_ = fixed_int_shift_ = fixed_int_bits_ = 0;
+      state_ = kFieldPreamble;
+      return Token{field_id_, wire_type, fixed_int_value};
+    }
 
-  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::REALTIME:
-    return "REALTIME";
+    // At this point either we are: (i) parsing a field preamble; (ii) parsing a
+    // varint field paylod; (iii) parsing the length of a length-delimited
+    // field. In all cases, we need to decode a varint before proceeding.
+    varint_ |= static_cast<uint64_t>(octet & 0x7F) << varint_shift_;
+    if (octet & 0x80) {
+      varint_shift_ += 7;
+      if (PERFETTO_UNLIKELY(varint_shift_ >= 64)) {
+        varint_shift_ = 0;
+        state_ = kInvalidVarInt;
+      }
+      return Token{};  // Still parsing a varint.
+    }
 
-  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::REALTIME_COARSE:
-    return "REALTIME_COARSE";
+    uint64_t varint = varint_;
+    varint_ = 0;
+    varint_shift_ = 0;
 
-  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::MONOTONIC:
-    return "MONOTONIC";
+    switch (state_) {
+      case kFieldPreamble: {
+        auto field_type = static_cast<uint32_t>(varint & 7u);  // 7 = 0..0111
+        field_id_ = static_cast<uint32_t>(varint >> 3);
 
-  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::MONOTONIC_COARSE:
-    return "MONOTONIC_COARSE";
+        // The field type is legit, now check it's well formed and within
+        // boundaries.
+        if (field_type == static_cast<uint32_t>(ProtoWireType::kVarInt)) {
+          state_ = kVarIntValue;
+        } else if (field_type ==
+                       static_cast<uint32_t>(ProtoWireType::kFixed32) ||
+                   field_type ==
+                       static_cast<uint32_t>(ProtoWireType::kFixed64)) {
+          state_ = kFixedIntValue;
+          fixed_int_shift_ = 0;
+          fixed_int_value_ = 0;
+          fixed_int_bits_ =
+              field_type == static_cast<uint32_t>(ProtoWireType::kFixed32) ? 32
+                                                                           : 64;
+        } else if (field_type ==
+                   static_cast<uint32_t>(ProtoWireType::kLengthDelimited)) {
+          state_ = kLenDelimited;
+        } else {
+          state_ = kInvalidFieldType;
+        }
+        return Token{};
+      }
 
-  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::MONOTONIC_RAW:
-    return "MONOTONIC_RAW";
+      case kVarIntValue: {
+        // Return the varint field payload and go back to the next field.
+        state_ = kFieldPreamble;
+        return Token{field_id_, ProtoWireType::kVarInt, varint};
+      }
 
-  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::BOOTTIME:
-    return "BOOTTIME";
+      case kLenDelimited: {
+        const auto payload_len = varint;
+        if (payload_len > protozero::proto_utils::kMaxMessageLength) {
+          state_ = kMessageTooBig;
+          return Token{};
+        }
+        state_ = kFieldPreamble;
+        // At this point the caller is expected to consume the next
+        // |payload_len| bytes.
+        return Token{field_id_, ProtoWireType::kLengthDelimited, payload_len};
+      }
 
-  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::BUILTIN_CLOCK_MAX_ID:
-    return "BUILTIN_CLOCK_MAX_ID";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+      case kFixedIntValue:
+        // Unreachable because of the if before the switch.
+        PERFETTO_DCHECK(false);
+        break;
 
-class ClockSnapshot_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  ClockSnapshot_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ClockSnapshot_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ClockSnapshot_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_clocks() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> clocks() const { return GetRepeated<::protozero::ConstBytes>(1); }
-  bool has_primary_trace_clock() const { return at<2>().valid(); }
-  int32_t primary_trace_clock() const { return at<2>().as_int32(); }
-};
+      // Unrecoverable error states.
+      case kInvalidFieldType:
+      case kMessageTooBig:
+      case kInvalidVarInt:
+        break;
+    }  // switch(state_)
 
-class ClockSnapshot : public ::protozero::Message {
- public:
-  using Decoder = ClockSnapshot_Decoder;
-  enum : int32_t {
-    kClocksFieldNumber = 1,
-    kPrimaryTraceClockFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ClockSnapshot"; }
-
-  using Clock = ::perfetto::protos::pbzero::ClockSnapshot_Clock;
-
-  using FieldMetadata_Clocks =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ClockSnapshot_Clock,
-      ClockSnapshot>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Clocks kClocks() { return {}; }
-  template <typename T = ClockSnapshot_Clock> T* add_clocks() {
-    return BeginNestedMessage<T>(1);
-  }
-
-
-  using FieldMetadata_PrimaryTraceClock =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::BuiltinClock,
-      ClockSnapshot>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PrimaryTraceClock kPrimaryTraceClock() { return {}; }
-  void set_primary_trace_clock(::perfetto::protos::pbzero::BuiltinClock value) {
-    static constexpr uint32_t field_id = FieldMetadata_PrimaryTraceClock::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
+    return Token{};  // Keep GCC happy.
   }
-};
 
-class ClockSnapshot_Clock_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  ClockSnapshot_Clock_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ClockSnapshot_Clock_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ClockSnapshot_Clock_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_clock_id() const { return at<1>().valid(); }
-  uint32_t clock_id() const { return at<1>().as_uint32(); }
-  bool has_timestamp() const { return at<2>().valid(); }
-  uint64_t timestamp() const { return at<2>().as_uint64(); }
-  bool has_is_incremental() const { return at<3>().valid(); }
-  bool is_incremental() const { return at<3>().as_bool(); }
-  bool has_unit_multiplier_ns() const { return at<4>().valid(); }
-  uint64_t unit_multiplier_ns() const { return at<4>().as_uint64(); }
-};
+  // Returns true if the tokenizer FSM has reached quiescence (i.e. if we are
+  // NOT in the middle of parsing a field).
+  bool idle() const {
+    return state_ == kFieldPreamble && varint_shift_ == 0 &&
+           fixed_int_shift_ == 0;
+  }
 
-class ClockSnapshot_Clock : public ::protozero::Message {
- public:
-  using Decoder = ClockSnapshot_Clock_Decoder;
-  enum : int32_t {
-    kClockIdFieldNumber = 1,
-    kTimestampFieldNumber = 2,
-    kIsIncrementalFieldNumber = 3,
-    kUnitMultiplierNsFieldNumber = 4,
+  // Only for reporting parser errors in the trace.
+  uint32_t state() const { return static_cast<uint32_t>(state_); }
+
+ private:
+  enum State {
+    kFieldPreamble = 0,  // Parsing the varint for the field preamble.
+    kVarIntValue = 1,    // Parsing the payload of a varint field.
+    kFixedIntValue = 2,  // Parsing the payload of a fixed32/64 field.
+    kLenDelimited = 3,   // Parsing the length of a length-delimited field.
+
+    // Unrecoverable error states:
+    kInvalidFieldType = 4,  // Encountered an invalid field type.
+    kMessageTooBig = 5,     // Size of the length delimited message was too big.
+    kInvalidVarInt = 6,     // Varint larger than 64 bits.
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ClockSnapshot.Clock"; }
-
-
-  using BuiltinClocks = ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks;
-  static inline const char* BuiltinClocks_Name(BuiltinClocks value) {
-    return ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks_Name(value);
-  }
-  static const BuiltinClocks UNKNOWN = BuiltinClocks::UNKNOWN;
-  static const BuiltinClocks REALTIME = BuiltinClocks::REALTIME;
-  static const BuiltinClocks REALTIME_COARSE = BuiltinClocks::REALTIME_COARSE;
-  static const BuiltinClocks MONOTONIC = BuiltinClocks::MONOTONIC;
-  static const BuiltinClocks MONOTONIC_COARSE = BuiltinClocks::MONOTONIC_COARSE;
-  static const BuiltinClocks MONOTONIC_RAW = BuiltinClocks::MONOTONIC_RAW;
-  static const BuiltinClocks BOOTTIME = BuiltinClocks::BOOTTIME;
-  static const BuiltinClocks BUILTIN_CLOCK_MAX_ID = BuiltinClocks::BUILTIN_CLOCK_MAX_ID;
-
-  using FieldMetadata_ClockId =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      ClockSnapshot_Clock>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClockId kClockId() { return {}; }
-  void set_clock_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ClockId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Timestamp =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ClockSnapshot_Clock>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timestamp kTimestamp() { return {}; }
-  void set_timestamp(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_IsIncremental =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ClockSnapshot_Clock>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IsIncremental kIsIncremental() { return {}; }
-  void set_is_incremental(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_IsIncremental::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_UnitMultiplierNs =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ClockSnapshot_Clock>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UnitMultiplierNs kUnitMultiplierNs() { return {}; }
-  void set_unit_multiplier_ns(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_UnitMultiplierNs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
+
+  State state_ = kFieldPreamble;
+  uint32_t field_id_ = 0;
+  uint64_t varint_ = 0;
+  uint32_t varint_shift_ = 0;
+  uint32_t fixed_int_shift_ = 0;
+  uint32_t fixed_int_bits_ = 0;
+  uint64_t fixed_int_value_ = 0;
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
+}  // namespace protozero
+
+#endif  // SRC_PROTOZERO_FILTERING_MESSAGE_TOKENIZER_H_
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2021 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -48778,573 +55525,584 @@ class ClockSnapshot_Clock : public ::protozero::Message {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/track_event_internal.h"
+#ifndef SRC_PROTOZERO_FILTERING_MESSAGE_FILTER_H_
+#define SRC_PROTOZERO_FILTERING_MESSAGE_FILTER_H_
 
-// gen_amalgamated expanded: #include "perfetto/base/proc_utils.h"
-// gen_amalgamated expanded: #include "perfetto/base/time.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_config.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/track_event_interned_fields.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/track_event.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/track_event_category_registry.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/track_event_interned_data_index.h"
-// gen_amalgamated expanded: #include "protos/perfetto/common/data_source_descriptor.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/common/track_event_descriptor.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/clock_snapshot.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/interned_data/interned_data.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet_defaults.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/debug_annotation.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_descriptor.pbzero.h"
+#include <stdint.h>
 
-using perfetto::protos::pbzero::ClockSnapshot;
+#include <memory>
+#include <string>
+#include <unordered_map>
 
-namespace perfetto {
+// gen_amalgamated expanded: #include "src/protozero/filtering/filter_bytecode_parser.h"
+// gen_amalgamated expanded: #include "src/protozero/filtering/message_tokenizer.h"
+// gen_amalgamated expanded: #include "src/protozero/filtering/string_filter.h"
 
-TrackEventSessionObserver::~TrackEventSessionObserver() = default;
-void TrackEventSessionObserver::OnSetup(const DataSourceBase::SetupArgs&) {}
-void TrackEventSessionObserver::OnStart(const DataSourceBase::StartArgs&) {}
-void TrackEventSessionObserver::OnStop(const DataSourceBase::StopArgs&) {}
-void TrackEventSessionObserver::WillClearIncrementalState(
-    const DataSourceBase::ClearIncrementalStateArgs&) {}
+namespace protozero {
 
-namespace internal {
+// A class to filter binary-encoded proto messages using an allow-list of field
+// ids, also known as "filter bytecode". The filter determines which fields are
+// allowed to be passed through in output and strips all the other fields.
+// See go/trace-filtering for full design.
+// This class takes in input:
+// 1) The filter bytecode, loaded once via the LoadFilterBytecode() method.
+// 2) A proto-encoded binary message. The message doesn't have to be contiguous,
+//    it can be passed as an array of arbitrarily chunked fragments.
+// The FilterMessage*() method returns in output a proto message, stripping out
+// all unknown fields. If the input is malformed (e.g., unknown proto field wire
+// types, lengths out of bound) the whole filtering failed and the |error| flag
+// of the FilteredMessage object is set to true.
+// The filtering operation is based on rewriting a copy of the message into a
+// self-allocated buffer, which is then returned in the output. The input buffer
+// is NOT altered.
+// Note also that the process of rewriting the protos gets rid of most redundant
+// varint encoding (if present). So even if all fields are allow-listed, the
+// output might NOT be bitwise identical to the input (but it will be
+// semantically equivalent).
+// Furthermore the enable_field_usage_tracking() method allows to keep track of
+// a histogram of allowed / denied fields. It slows down filtering and is
+// intended only on host tools.
+class MessageFilter {
+ public:
+  class Config {
+   public:
+    // Loads filter bytecode. If a filter is already loaded, it is replaced.
+    // Optionally accepts an overlay (pass nullptr/0 if not needed).
+    // See FilterBytecodeParser::Load() for overlay format details.
+    bool LoadFilterBytecode(const void* filter_data,
+                            size_t len,
+                            const void* overlay_data = nullptr,
+                            size_t overlay_len = 0);
 
-BaseTrackEventInternedDataIndex::~BaseTrackEventInternedDataIndex() = default;
+    bool SetFilterRoot(std::initializer_list<uint32_t> field_ids);
 
-namespace {
+    const FilterBytecodeParser& filter() const { return filter_; }
+    const StringFilter& string_filter() const { return string_filter_; }
+    StringFilter& string_filter() { return string_filter_; }
+    uint32_t root_msg_index() const { return root_msg_index_; }
 
-static constexpr const char kLegacySlowPrefix[] = "disabled-by-default-";
-static constexpr const char kSlowTag[] = "slow";
-static constexpr const char kDebugTag[] = "debug";
+   private:
+    FilterBytecodeParser filter_;
+    StringFilter string_filter_;
+    uint32_t root_msg_index_ = 0;
+  };
 
-constexpr auto kClockIdIncremental =
-    TrackEventIncrementalState::kClockIdIncremental;
+  MessageFilter();
+  explicit MessageFilter(Config);
+  ~MessageFilter();
 
-constexpr auto kClockIdAbsolute = TrackEventIncrementalState::kClockIdAbsolute;
+  struct InputSlice {
+    const void* data;
+    size_t len;
+  };
 
-class TrackEventSessionObserverRegistry {
- public:
-  static TrackEventSessionObserverRegistry* GetInstance() {
-    static TrackEventSessionObserverRegistry* instance =
-        new TrackEventSessionObserverRegistry();  // leaked
-    return instance;
+  struct FilteredMessage {
+    FilteredMessage(std::unique_ptr<uint8_t[]> d, size_t s)
+        : data(std::move(d)), size(s) {}
+    std::unique_ptr<uint8_t[]> data;
+    size_t size;  // The used bytes in |data|. This is <= sizeof(data).
+    bool error = false;
+  };
+
+  // Loads the filter bytecode that will be used to filter any subsequent
+  // message. Must be called before the first call to FilterMessage*().
+  // |filter_data| must point to a byte buffer for a proto-encoded ProtoFilter
+  // message (see proto_filter.proto).
+  // Optionally accepts an overlay (pass nullptr/0 if not needed).
+  bool LoadFilterBytecode(const void* filter_data,
+                          size_t len,
+                          const void* overlay_data = nullptr,
+                          size_t overlay_len = 0) {
+    return config_.LoadFilterBytecode(filter_data, len, overlay_data,
+                                      overlay_len);
   }
 
-  void AddObserverForRegistry(const TrackEventCategoryRegistry& registry,
-                              TrackEventSessionObserver* observer) {
-    std::unique_lock<std::recursive_mutex> lock(mutex_);
-    observers_.emplace_back(&registry, observer);
+  // This affects the filter starting point of the subsequent FilterMessage*()
+  // calls. By default the filtering process starts from the message @ index 0,
+  // the root message passed to proto_filter when generating the bytecode
+  // (in typical tracing use-cases, this is perfetto.protos.Trace). However, the
+  // caller (TracingServiceImpl) might want to filter packets from the 2nd level
+  // (perfetto.protos.TracePacket) because the root level is prepended after
+  // the fact. This call allows to change the root message for the filter.
+  // The argument |field_ids| is an array of proto field ids and determines the
+  // path to the new root. For instance, in the case of [1,2,3] SetFilterRoot
+  // will identify the sub-message for the field "root.1.2.3" and use that.
+  // In order for this to succeed all the fields in the path must be allowed
+  // in the filter and must be a nested message type.
+  bool SetFilterRoot(std::initializer_list<uint32_t> field_ids) {
+    return config_.SetFilterRoot(field_ids);
   }
 
-  void RemoveObserverForRegistry(const TrackEventCategoryRegistry& registry,
-                                 TrackEventSessionObserver* observer) {
-    std::unique_lock<std::recursive_mutex> lock(mutex_);
-    observers_.erase(std::remove(observers_.begin(), observers_.end(),
-                                 RegisteredObserver(&registry, observer)),
-                     observers_.end());
+  // Takes an input message, fragmented in arbitrary slices, and returns a
+  // filtered message in output.
+  FilteredMessage FilterMessageFragments(const InputSlice*, size_t num_slices);
+
+  // Helper for tests, where the input is a contiguous buffer.
+  FilteredMessage FilterMessage(const void* data, size_t len) {
+    InputSlice slice{data, len};
+    return FilterMessageFragments(&slice, 1);
   }
 
-  void ForEachObserverForRegistry(
-      const TrackEventCategoryRegistry& registry,
-      std::function<void(TrackEventSessionObserver*)> callback) {
-    std::unique_lock<std::recursive_mutex> lock(mutex_);
-    for (auto& registered_observer : observers_) {
-      if (&registry == registered_observer.registry) {
-        callback(registered_observer.observer);
-      }
-    }
+  // When enabled returns a map of "field path" to "usage counter".
+  // The key (std::string) is a binary buffer (i.e. NOT an ASCII/UTF-8 string)
+  // which contains a varint for each field. Consider the following:
+  // message Root { Sub1 f1 = 1; };
+  // message Sub1 { Sub2 f2 = 7;}
+  // message Sub2 { string f3 = 5; }
+  // The field .f1.f2.f3 will be encoded as \x01\0x07\x05.
+  // The value is the number of times that field has been encountered. If the
+  // field is not allow-listed in the bytecode (the field is stripped in output)
+  // the count will be negative.
+  void enable_field_usage_tracking(bool x) { track_field_usage_ = x; }
+  const std::unordered_map<std::string, int32_t>& field_usage() const {
+    return field_usage_;
   }
 
+  const Config& config() const { return config_; }
+  Config& config() { return config_; }
+
+  // Returns the helper class used to perform string filtering.
+  StringFilter& string_filter() { return config_.string_filter(); }
+
  private:
-  struct RegisteredObserver {
-    RegisteredObserver(const TrackEventCategoryRegistry* r,
-                       TrackEventSessionObserver* o)
-        : registry(r), observer(o) {}
-    bool operator==(const RegisteredObserver& other) {
-      return registry == other.registry && observer == other.observer;
-    }
-    const TrackEventCategoryRegistry* registry;
-    TrackEventSessionObserver* observer;
-  };
+  // This is called by FilterMessageFragments().
+  // Inlining allows the compiler turn the per-byte call/return into a for loop,
+  // while, at the same time, keeping the code easy to read and reason about.
+  // It gives a 20-25% speedup (265ms vs 215ms for a 25MB trace).
+  void FilterOneByte(uint8_t octet) PERFETTO_ALWAYS_INLINE;
 
-  std::recursive_mutex mutex_;
-  std::vector<RegisteredObserver> observers_;
-};
+  // No-inline because this is a slowpath (only when usage tracking is enabled).
+  void IncrementCurrentFieldUsage(uint32_t field_id,
+                                  bool allowed) PERFETTO_NO_INLINE;
+
+  // Gets into an error state which swallows all the input and emits no output.
+  void SetUnrecoverableErrorState();
+
+  // We keep track of the nest of messages in a stack. Each StackState
+  // object corresponds to a level of nesting in the proto message structure.
+  // Every time a new field of type len-delimited that has a corresponding
+  // sub-message in the bytecode is encountered, a new StackState is pushed in
+  // |stack_|. stack_[0] is a sentinel to prevent over-popping without adding
+  // extra branches in the fastpath.
+  // |stack_|. stack_[1] is the state of the root message.
+  struct StackState {
+    uint32_t in_bytes = 0;  // Number of input bytes processed.
+
+    // When |in_bytes| reaches this value, the current state should be popped.
+    // This is set when recursing into nested submessages. This is 0 only for
+    // stack_[0] (we don't know the size of the root message upfront).
+    uint32_t in_bytes_limit = 0;
+
+    // This is set when a len-delimited message is encountered, either a string
+    // or a nested submessage that is NOT allow-listed in the bytecode.
+    // This causes input bytes to be consumed without being parsed from the
+    // input stream. If |passthrough_eaten_bytes| == true, they will be copied
+    // as-is in output (e.g. in the case of an allowed string/bytes field).
+    uint32_t eat_next_bytes = 0;
+
+    // Keeps tracks of the stream_writer output counter (out_.written()) then
+    // the StackState is pushed. This is used to work out, when popping, how
+    // many bytes have been written for the current submessage.
+    uint32_t out_bytes_written_at_start = 0;
+
+    uint32_t field_id = 0;   // The proto field id for the current message.
+    uint32_t msg_index = 0;  // The index of the message filter in the bytecode.
 
-enum class MatchType { kExact, kPattern };
+    // This is a pointer to the proto preamble for the current submessage
+    // (it's nullptr for stack_[0] and non-null elsewhere). This will be filled
+    // with the actual size of the message (out_.written() -
+    // |out_bytes_written_at_start|) when finishing (popping) the message.
+    // This must be filled using WriteRedundantVarint(). Note that the
+    // |size_field_len| is variable and depends on the actual length of the
+    // input message. If the output message has roughly the same size of the
+    // input message, the length will not be redundant.
+    // In other words: the length of the field is reserved when the submessage
+    // starts. At that point we know the upper-bound for the output message
+    // (a filtered submessage can be <= the original one, but not >). So we
+    // reserve as many bytes it takes to write the input length in varint.
+    // Then, when the message is finalized and we know the actual output size
+    // we backfill the field.
+    // Consider the example of a submessage where the input size = 130 (>127,
+    // 2 varint bytes) and the output is 120 bytes. The length will be 2 bytes
+    // wide even though could have been encoded with just one byte.
+    uint8_t* size_field = nullptr;
+    uint32_t size_field_len = 0;
 
-bool NameMatchesPattern(const std::string& pattern,
-                        const std::string& name,
-                        MatchType match_type) {
-  // To avoid pulling in all of std::regex, for now we only support a single "*"
-  // wildcard at the end of the pattern.
-  size_t i = pattern.find('*');
-  if (i != std::string::npos) {
-    PERFETTO_DCHECK(i == pattern.size() - 1);
-    if (match_type != MatchType::kPattern)
-      return false;
-    return name.substr(0, i) == pattern.substr(0, i);
-  }
-  return name == pattern;
-}
+    // The pointer to the start of the string to update the string if it is
+    // filtered.
+    uint8_t* filter_string_ptr = nullptr;
+
+    // The semantic type of the string field being filtered (0 = unspecified).
+    uint32_t filter_string_semantic_type = 0;
+
+    // How |eat_next_bytes| should be handled. It seems that keeping this field
+    // at the end rather than next to |eat_next_bytes| makes the filter a little
+    // (but measurably) faster. (likely something related with struct layout vs
+    // cache sizes).
+    enum FilterAction {
+      kDrop,
+      kPassthrough,
+      kFilterString,
+    };
+    FilterAction action = FilterAction::kDrop;
+  };
 
-bool NameMatchesPatternList(const std::vector<std::string>& patterns,
-                            const std::string& name,
-                            MatchType match_type) {
-  for (const auto& pattern : patterns) {
-    if (NameMatchesPattern(pattern, name, match_type))
-      return true;
-  }
-  return false;
-}
+  uint32_t out_written() { return static_cast<uint32_t>(out_ - &out_buf_[0]); }
 
-}  // namespace
+  Config config_;
 
-// static
-const Track TrackEventInternal::kDefaultTrack{};
+  std::unique_ptr<uint8_t[]> out_buf_;
+  uint8_t* out_ = nullptr;
+  uint8_t* out_end_ = nullptr;
 
-// static
-std::atomic<int> TrackEventInternal::session_count_{};
+  MessageTokenizer tokenizer_;
+  std::vector<StackState> stack_;
 
-// static
-bool TrackEventInternal::Initialize(
-    const TrackEventCategoryRegistry& registry,
-    bool (*register_data_source)(const DataSourceDescriptor&)) {
-  DataSourceDescriptor dsd;
-  dsd.set_name("track_event");
+  bool error_ = false;
+  bool track_field_usage_ = false;
+  std::unordered_map<std::string, int32_t> field_usage_;
+};
 
-  protozero::HeapBuffered<protos::pbzero::TrackEventDescriptor> ted;
-  for (size_t i = 0; i < registry.category_count(); i++) {
-    auto category = registry.GetCategory(i);
-    // Don't register group categories.
-    if (category->IsGroup())
-      continue;
-    auto cat = ted->add_available_categories();
-    cat->set_name(category->name);
-    if (category->description)
-      cat->set_description(category->description);
-    for (const auto& tag : category->tags) {
-      if (tag)
-        cat->add_tags(tag);
-    }
-    // Disabled-by-default categories get a "slow" tag.
-    if (!strncmp(category->name, kLegacySlowPrefix, strlen(kLegacySlowPrefix)))
-      cat->add_tags(kSlowTag);
-  }
-  dsd.set_track_event_descriptor_raw(ted.SerializeAsString());
+}  // namespace protozero
 
-  return register_data_source(dsd);
-}
+#endif  // SRC_PROTOZERO_FILTERING_MESSAGE_FILTER_H_
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-// static
-bool TrackEventInternal::AddSessionObserver(
-    const TrackEventCategoryRegistry& registry,
-    TrackEventSessionObserver* observer) {
-  TrackEventSessionObserverRegistry::GetInstance()->AddObserverForRegistry(
-      registry, observer);
-  return true;
-}
+// gen_amalgamated expanded: #include "src/protozero/filtering/message_filter.h"
 
-// static
-void TrackEventInternal::RemoveSessionObserver(
-    const TrackEventCategoryRegistry& registry,
-    TrackEventSessionObserver* observer) {
-  TrackEventSessionObserverRegistry::GetInstance()->RemoveObserverForRegistry(
-      registry, observer);
-}
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "src/protozero/filtering/string_filter.h"
 
-#if !PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) && \
-    !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-static constexpr protos::pbzero::BuiltinClock kDefaultTraceClock =
-    protos::pbzero::BUILTIN_CLOCK_BOOTTIME;
-#else
-static constexpr protos::pbzero::BuiltinClock kDefaultTraceClock =
-    protos::pbzero::BUILTIN_CLOCK_MONOTONIC;
-#endif
+namespace protozero {
 
-// static
-protos::pbzero::BuiltinClock TrackEventInternal::clock_ = kDefaultTraceClock;
+namespace {
 
-// static
-void TrackEventInternal::EnableTracing(
-    const TrackEventCategoryRegistry& registry,
-    const protos::gen::TrackEventConfig& config,
-    const DataSourceBase::SetupArgs& args) {
-  for (size_t i = 0; i < registry.category_count(); i++) {
-    if (IsCategoryEnabled(registry, config, *registry.GetCategory(i)))
-      registry.EnableCategoryForInstance(i, args.internal_instance_index);
-  }
-  TrackEventSessionObserverRegistry::GetInstance()->ForEachObserverForRegistry(
-      registry, [&](TrackEventSessionObserver* o) { o->OnSetup(args); });
-}
+// Inline helpers to append proto fields in output. They are the equivalent of
+// the protozero::Message::AppendXXX() fields but don't require building and
+// maintaining a full protozero::Message object or dealing with scattered
+// output slices.
+// All these functions assume there is enough space in the output buffer, which
+// should be always the case assuming that we don't end up generating more
+// output than input.
 
-// static
-void TrackEventInternal::OnStart(const TrackEventCategoryRegistry& registry,
-                                 const DataSourceBase::StartArgs& args) {
-  session_count_.fetch_add(1);
-  TrackEventSessionObserverRegistry::GetInstance()->ForEachObserverForRegistry(
-      registry, [&](TrackEventSessionObserver* o) { o->OnStart(args); });
+inline void AppendVarInt(uint32_t field_id, uint64_t value, uint8_t** out) {
+  *out = proto_utils::WriteVarInt(proto_utils::MakeTagVarInt(field_id), *out);
+  *out = proto_utils::WriteVarInt(value, *out);
 }
 
-// static
-void TrackEventInternal::OnStop(const TrackEventCategoryRegistry& registry,
-                                const DataSourceBase::StopArgs& args) {
-  TrackEventSessionObserverRegistry::GetInstance()->ForEachObserverForRegistry(
-      registry, [&](TrackEventSessionObserver* o) { o->OnStop(args); });
+// For fixed32 / fixed64.
+template <typename INT_T /* uint32_t | uint64_t*/>
+inline void AppendFixed(uint32_t field_id, INT_T value, uint8_t** out) {
+  *out = proto_utils::WriteVarInt(proto_utils::MakeTagFixed<INT_T>(field_id),
+                                  *out);
+  memcpy(*out, &value, sizeof(value));
+  *out += sizeof(value);
 }
 
-// static
-void TrackEventInternal::DisableTracing(
-    const TrackEventCategoryRegistry& registry,
-    uint32_t internal_instance_index) {
-  for (size_t i = 0; i < registry.category_count(); i++)
-    registry.DisableCategoryForInstance(i, internal_instance_index);
+// For length-delimited (string, bytes) fields. Note: this function appends only
+// the proto preamble and the varint field that states the length of the payload
+// not the payload itself.
+// In the case of submessages, the caller needs to re-write the length at the
+// end in the in the returned memory area.
+// The problem here is that, because of filtering, the length of a submessage
+// might be < original length (the original length is still an upper-bound).
+// Returns a pair with: (1) the pointer where the final length should be written
+// into, (2) the length of the size field.
+// The caller must write a redundant varint to match the original size (i.e.
+// needs to use WriteRedundantVarInt()).
+inline std::pair<uint8_t*, uint32_t> AppendLenDelim(uint32_t field_id,
+                                                    uint32_t len,
+                                                    uint8_t** out) {
+  *out = proto_utils::WriteVarInt(proto_utils::MakeTagLengthDelimited(field_id),
+                                  *out);
+  uint8_t* size_field_start = *out;
+  *out = proto_utils::WriteVarInt(len, *out);
+  const size_t size_field_len = static_cast<size_t>(*out - size_field_start);
+  return std::make_pair(size_field_start, size_field_len);
 }
+}  // namespace
 
-// static
-void TrackEventInternal::WillClearIncrementalState(
-    const TrackEventCategoryRegistry& registry,
-    const DataSourceBase::ClearIncrementalStateArgs& args) {
-  TrackEventSessionObserverRegistry::GetInstance()->ForEachObserverForRegistry(
-      registry, [&](TrackEventSessionObserver* o) {
-        o->WillClearIncrementalState(args);
-      });
+MessageFilter::MessageFilter(Config config) : config_(std::move(config)) {
+  // Push a state on the stack for the implicit root message.
+  stack_.emplace_back();
 }
 
-// static
-bool TrackEventInternal::IsCategoryEnabled(
-    const TrackEventCategoryRegistry& registry,
-    const protos::gen::TrackEventConfig& config,
-    const Category& category) {
-  // If this is a group category, check if any of its constituent categories are
-  // enabled. If so, then this one is enabled too.
-  if (category.IsGroup()) {
-    bool result = false;
-    category.ForEachGroupMember([&](const char* member_name, size_t name_size) {
-      for (size_t i = 0; i < registry.category_count(); i++) {
-        const auto ref_category = registry.GetCategory(i);
-        // Groups can't refer to other groups.
-        if (ref_category->IsGroup())
-          continue;
-        // Require an exact match.
-        if (ref_category->name_size() != name_size ||
-            strncmp(ref_category->name, member_name, name_size)) {
-          continue;
-        }
-        if (IsCategoryEnabled(registry, config, *ref_category)) {
-          result = true;
-          // Break ForEachGroupMember() loop.
-          return false;
-        }
-        break;
-      }
-      // No match? Must be a dynamic category.
-      DynamicCategory dyn_category(std::string(member_name, name_size));
-      Category ref_category{Category::FromDynamicCategory(dyn_category)};
-      if (IsCategoryEnabled(registry, config, ref_category)) {
-        result = true;
-        // Break ForEachGroupMember() loop.
-        return false;
-      }
-      // No match found => keep iterating.
-      return true;
-    });
-    return result;
-  }
-
-  auto has_matching_tag = [&](std::function<bool(const char*)> matcher) {
-    for (const auto& tag : category.tags) {
-      if (!tag)
-        break;
-      if (matcher(tag))
-        return true;
-    }
-    // Legacy "disabled-by-default" categories automatically get the "slow" tag.
-    if (!strncmp(category.name, kLegacySlowPrefix, strlen(kLegacySlowPrefix)) &&
-        matcher(kSlowTag)) {
-      return true;
-    }
-    return false;
-  };
-
-  // First try exact matches, then pattern matches.
-  const std::array<MatchType, 2> match_types = {
-      {MatchType::kExact, MatchType::kPattern}};
-  for (auto match_type : match_types) {
-    // 1. Enabled categories.
-    if (NameMatchesPatternList(config.enabled_categories(), category.name,
-                               match_type)) {
-      return true;
-    }
-
-    // 2. Enabled tags.
-    if (has_matching_tag([&](const char* tag) {
-          return NameMatchesPatternList(config.enabled_tags(), tag, match_type);
-        })) {
-      return true;
-    }
+MessageFilter::MessageFilter() : MessageFilter(Config()) {}
 
-    // 2.5. A special case for Chrome's legacy disabled-by-default categories.
-    // We treat them as having a "slow" tag with one exception: they can be
-    // enabled by a pattern if the pattern starts with "disabled-by-default-"
-    // itself.
-    if (match_type == MatchType::kExact &&
-        !strncmp(category.name, kLegacySlowPrefix, strlen(kLegacySlowPrefix))) {
-      for (const auto& pattern : config.enabled_categories()) {
-        if (!strncmp(pattern.c_str(), kLegacySlowPrefix,
-                     strlen(kLegacySlowPrefix)) &&
-            NameMatchesPattern(pattern, category.name, MatchType::kPattern)) {
-          return true;
-        }
-      }
-    }
+MessageFilter::~MessageFilter() = default;
 
-    // 3. Disabled categories.
-    if (NameMatchesPatternList(config.disabled_categories(), category.name,
-                               match_type)) {
-      return false;
-    }
+bool MessageFilter::Config::LoadFilterBytecode(const void* filter_data,
+                                               size_t len,
+                                               const void* overlay_data,
+                                               size_t overlay_len) {
+  return filter_.Load(filter_data, len, overlay_data, overlay_len);
+}
 
-    // 4. Disabled tags.
-    if (has_matching_tag([&](const char* tag) {
-          if (config.disabled_tags_size()) {
-            return NameMatchesPatternList(config.disabled_tags(), tag,
-                                          match_type);
-          } else {
-            // The "slow" and "debug" tags are disabled by default.
-            return NameMatchesPattern(kSlowTag, tag, match_type) ||
-                   NameMatchesPattern(kDebugTag, tag, match_type);
-          }
-        })) {
+bool MessageFilter::Config::SetFilterRoot(
+    std::initializer_list<uint32_t> field_ids) {
+  uint32_t root_msg_idx = 0;
+  for (uint32_t field_id : field_ids) {
+    auto res = filter_.Query(root_msg_idx, field_id);
+    if (!res.allowed || !res.nested_msg_field())
       return false;
-    }
+    root_msg_idx = res.nested_msg_index;
   }
-
-  // If nothing matched, enable the category by default.
+  root_msg_index_ = root_msg_idx;
   return true;
 }
 
-// static
-uint64_t TrackEventInternal::GetTimeNs() {
-  if (GetClockId() == protos::pbzero::BUILTIN_CLOCK_BOOTTIME)
-    return static_cast<uint64_t>(perfetto::base::GetBootTimeNs().count());
-  else if (GetClockId() == protos::pbzero::BUILTIN_CLOCK_MONOTONIC)
-    return static_cast<uint64_t>(perfetto::base::GetWallTimeNs().count());
-  PERFETTO_DCHECK(GetClockId() == protos::pbzero::BUILTIN_CLOCK_MONOTONIC_RAW);
-  return static_cast<uint64_t>(perfetto::base::GetWallTimeRawNs().count());
-}
-
-// static
-TraceTimestamp TrackEventInternal::GetTraceTime() {
-  return {kClockIdIncremental, GetTimeNs()};
-}
+MessageFilter::FilteredMessage MessageFilter::FilterMessageFragments(
+    const InputSlice* slices,
+    size_t num_slices) {
+  // First compute the upper bound for the output. The filtered message cannot
+  // be > the original message.
+  uint32_t total_len = 0;
+  for (size_t i = 0; i < num_slices; ++i)
+    total_len += slices[i].len;
+  out_buf_.reset(new uint8_t[total_len]);
+  out_ = out_buf_.get();
+  out_end_ = out_ + total_len;
 
-// static
-int TrackEventInternal::GetSessionCount() {
-  return session_count_.load();
-}
+  // Reset the parser state.
+  tokenizer_ = MessageTokenizer();
+  error_ = false;
+  stack_.clear();
+  stack_.resize(2);
+  // stack_[0] is a sentinel and should never be hit in nominal cases. If we
+  // end up there we will just keep consuming the input stream and detecting
+  // at the end, without hurting the fastpath.
+  stack_[0].in_bytes_limit = UINT32_MAX;
+  stack_[0].eat_next_bytes = UINT32_MAX;
+  // stack_[1] is the actual root message.
+  stack_[1].in_bytes_limit = total_len;
+  stack_[1].msg_index = config_.root_msg_index();
 
-// static
-void TrackEventInternal::ResetIncrementalState(
-    TraceWriterBase* trace_writer,
-    TrackEventIncrementalState* incr_state,
-    const TrackEventTlsState& tls_state,
-    const TraceTimestamp& timestamp) {
-  auto sequence_timestamp = timestamp;
-  if (timestamp.clock_id != kClockIdIncremental) {
-    sequence_timestamp = TrackEventInternal::GetTraceTime();
+  // Process the input data and write the output.
+  for (size_t slice_idx = 0; slice_idx < num_slices; ++slice_idx) {
+    const InputSlice& slice = slices[slice_idx];
+    const uint8_t* data = static_cast<const uint8_t*>(slice.data);
+    for (size_t i = 0; i < slice.len; ++i)
+      FilterOneByte(data[i]);
   }
 
-  incr_state->last_timestamp_ns = sequence_timestamp.value;
-  auto default_track = ThreadTrack::Current();
-  auto ts_unit_multiplier = tls_state.timestamp_unit_multiplier;
-  auto thread_time_counter_track =
-      CounterTrack("thread_time", default_track)
-          .set_is_incremental(true)
-          .set_unit_multiplier(static_cast<int64_t>(ts_unit_multiplier))
-          .set_type(protos::gen::CounterDescriptor::COUNTER_THREAD_TIME_NS);
-  {
-    // Mark any incremental state before this point invalid. Also set up
-    // defaults so that we don't need to repeat constant data for each packet.
-    auto packet = NewTracePacket(
-        trace_writer, incr_state, tls_state, timestamp,
-        protos::pbzero::TracePacket::SEQ_INCREMENTAL_STATE_CLEARED);
-    auto defaults = packet->set_trace_packet_defaults();
-    defaults->set_timestamp_clock_id(tls_state.default_clock);
-    // Establish the default track for this event sequence.
-    auto track_defaults = defaults->set_track_event_defaults();
-    track_defaults->set_track_uuid(default_track.uuid);
-    if (tls_state.enable_thread_time_sampling) {
-      track_defaults->add_extra_counter_track_uuids(
-          thread_time_counter_track.uuid);
-    }
-
-    if (tls_state.default_clock != static_cast<uint32_t>(GetClockId())) {
-      ClockSnapshot* clocks = packet->set_clock_snapshot();
-      // Trace clock.
-      ClockSnapshot::Clock* trace_clock = clocks->add_clocks();
-      trace_clock->set_clock_id(static_cast<uint32_t>(GetClockId()));
-      trace_clock->set_timestamp(sequence_timestamp.value);
-
-      if (PERFETTO_LIKELY(tls_state.default_clock == kClockIdIncremental)) {
-        // Delta-encoded incremental clock in nanoseconds by default but
-        // configurable by |tls_state.timestamp_unit_multiplier|.
-        ClockSnapshot::Clock* clock_incremental = clocks->add_clocks();
-        clock_incremental->set_clock_id(kClockIdIncremental);
-        clock_incremental->set_timestamp(sequence_timestamp.value /
-                                         ts_unit_multiplier);
-        clock_incremental->set_is_incremental(true);
-        clock_incremental->set_unit_multiplier_ns(ts_unit_multiplier);
-      }
-      if (ts_unit_multiplier > 1) {
-        // absolute clock with custom timestamp_unit_multiplier.
-        ClockSnapshot::Clock* absolute_clock = clocks->add_clocks();
-        absolute_clock->set_clock_id(kClockIdAbsolute);
-        absolute_clock->set_timestamp(sequence_timestamp.value /
-                                      ts_unit_multiplier);
-        absolute_clock->set_is_incremental(false);
-        absolute_clock->set_unit_multiplier_ns(ts_unit_multiplier);
-      }
-    }
+  // Construct the output object.
+  PERFETTO_CHECK(out_ >= out_buf_.get() && out_ <= out_end_);
+  auto used_size = static_cast<size_t>(out_ - out_buf_.get());
+  FilteredMessage res{std::move(out_buf_), used_size};
+  res.error = error_;
+  if (stack_.size() != 1 || !tokenizer_.idle() ||
+      stack_[0].in_bytes != total_len) {
+    res.error = true;
   }
+  return res;
+}
 
-  // Every thread should write a descriptor for its default track, because most
-  // trace points won't explicitly reference it. We also write the process
-  // descriptor from every thread that writes trace events to ensure it gets
-  // emitted at least once.
-  WriteTrackDescriptor(default_track, trace_writer, incr_state, tls_state,
-                       sequence_timestamp);
-
-  WriteTrackDescriptor(ProcessTrack::Current(), trace_writer, incr_state,
-                       tls_state, sequence_timestamp);
+void MessageFilter::FilterOneByte(uint8_t octet) {
+  PERFETTO_DCHECK(!stack_.empty());
 
-  if (tls_state.enable_thread_time_sampling) {
-    WriteTrackDescriptor(thread_time_counter_track, trace_writer, incr_state,
-                         tls_state, sequence_timestamp);
-  }
-}
+  auto* state = &stack_.back();
+  StackState next_state{};
+  bool push_next_state = false;
 
-// static
-protozero::MessageHandle<protos::pbzero::TracePacket>
-TrackEventInternal::NewTracePacket(TraceWriterBase* trace_writer,
-                                   TrackEventIncrementalState* incr_state,
-                                   const TrackEventTlsState& tls_state,
-                                   TraceTimestamp timestamp,
-                                   uint32_t seq_flags) {
-  if (PERFETTO_UNLIKELY(tls_state.default_clock != kClockIdIncremental &&
-                        timestamp.clock_id == kClockIdIncremental)) {
-    timestamp.clock_id = tls_state.default_clock;
-  }
-  auto packet = trace_writer->NewTracePacket();
-  auto ts_unit_multiplier = tls_state.timestamp_unit_multiplier;
-  if (PERFETTO_LIKELY(timestamp.clock_id == kClockIdIncremental)) {
-    if (PERFETTO_LIKELY(incr_state->last_timestamp_ns <= timestamp.value)) {
-      // No need to set the clock id here, since kClockIdIncremental is the
-      // clock id assumed by default.
-      auto time_diff_ns = timestamp.value - incr_state->last_timestamp_ns;
-      auto time_diff_units = time_diff_ns / ts_unit_multiplier;
-      packet->set_timestamp(time_diff_units);
-      incr_state->last_timestamp_ns += time_diff_units * ts_unit_multiplier;
-    } else {
-      packet->set_timestamp(timestamp.value / ts_unit_multiplier);
-      packet->set_timestamp_clock_id(ts_unit_multiplier == 1
-                                         ? static_cast<uint32_t>(GetClockId())
-                                         : kClockIdAbsolute);
+  if (state->eat_next_bytes > 0) {
+    // This is the case where the previous tokenizer_.Push() call returned a
+    // length delimited message which is NOT a submessage (a string or a bytes
+    // field). We just want to consume it, and pass it through/filter strings
+    // if the field was allowed.
+    --state->eat_next_bytes;
+    if (state->action == StackState::kPassthrough) {
+      *(out_++) = octet;
+    } else if (state->action == StackState::kFilterString) {
+      *(out_++) = octet;
+      if (state->eat_next_bytes == 0) {
+        config_.string_filter().MaybeFilter(
+            reinterpret_cast<char*>(state->filter_string_ptr),
+            static_cast<size_t>(out_ - state->filter_string_ptr),
+            state->filter_string_semantic_type);
+      }
     }
-  } else if (PERFETTO_LIKELY(timestamp.clock_id == tls_state.default_clock)) {
-    packet->set_timestamp(timestamp.value / ts_unit_multiplier);
   } else {
-    packet->set_timestamp(timestamp.value);
-    packet->set_timestamp_clock_id(timestamp.clock_id);
-  }
-  packet->set_sequence_flags(seq_flags);
-  return packet;
-}
+    MessageTokenizer::Token token = tokenizer_.Push(octet);
+    // |token| will not be valid() in most cases and this is WAI. When pushing
+    // a varint field, only the last byte yields a token, all the other bytes
+    // return an invalid token, they just update the internal tokenizer state.
+    if (token.valid()) {
+      auto filter = config_.filter().Query(state->msg_index, token.field_id);
+      switch (token.type) {
+        case proto_utils::ProtoWireType::kVarInt:
+          if (filter.allowed && filter.simple_field())
+            AppendVarInt(token.field_id, token.value, &out_);
+          break;
+        case proto_utils::ProtoWireType::kFixed32:
+          if (filter.allowed && filter.simple_field())
+            AppendFixed(token.field_id, static_cast<uint32_t>(token.value),
+                        &out_);
+          break;
+        case proto_utils::ProtoWireType::kFixed64:
+          if (filter.allowed && filter.simple_field())
+            AppendFixed(token.field_id, static_cast<uint64_t>(token.value),
+                        &out_);
+          break;
+        case proto_utils::ProtoWireType::kLengthDelimited:
+          // Here we have two cases:
+          // A. A simple string/bytes field: we just want to consume the next
+          //    bytes (the string payload), optionally passing them through in
+          //    output if the field is allowed.
+          // B. This is a nested submessage. In this case we want to recurse and
+          //    push a new state on the stack.
+          // Note that we can't tell the difference between a
+          // "non-allowed string" and a "non-allowed submessage". But it doesn't
+          // matter because in both cases we just want to skip the next N bytes.
+          const auto submessage_len = static_cast<uint32_t>(token.value);
+          auto in_bytes_left = state->in_bytes_limit - state->in_bytes - 1;
+          if (PERFETTO_UNLIKELY(submessage_len > in_bytes_left)) {
+            // This is a malicious / malformed string/bytes/submessage that
+            // claims to be larger than the outer message that contains it.
+            return SetUnrecoverableErrorState();
+          }
 
-// static
-void TrackEventInternal::WriteEventName(StaticString event_name,
-                                        perfetto::EventContext& event_ctx,
-                                        const TrackEventTlsState&) {
-  if (PERFETTO_LIKELY(event_name.value != nullptr)) {
-    size_t name_iid = InternedEventName::Get(&event_ctx, event_name.value);
-    event_ctx.event()->set_name_iid(name_iid);
-  }
-}
+          if (filter.allowed && filter.nested_msg_field() &&
+              submessage_len > 0) {
+            // submessage_len == 0 is the edge case of a message with a 0-len
+            // (but present) submessage. In this case, if allowed, we don't want
+            // to push any further state (doing so would desync the FSM) but we
+            // still want to emit it.
+            // At this point |submessage_len| is only an upper bound. The
+            // final message written in output can be <= the one in input,
+            // only some of its fields might be allowed (also remember that
+            // this class implicitly removes redundancy varint encoding of
+            // len-delimited field lengths). The final length varint (the
+            // return value of AppendLenDelim()) will be filled when popping
+            // from |stack_|.
+            auto size_field =
+                AppendLenDelim(token.field_id, submessage_len, &out_);
+            push_next_state = true;
+            next_state.field_id = token.field_id;
+            next_state.msg_index = filter.nested_msg_index;
+            next_state.in_bytes_limit = submessage_len;
+            next_state.size_field = size_field.first;
+            next_state.size_field_len = size_field.second;
+            next_state.out_bytes_written_at_start = out_written();
+          } else {
+            // A string or bytes field, or a 0 length submessage.
+            state->eat_next_bytes = submessage_len;
+            if (filter.allowed && filter.filter_string_field()) {
+              state->action = StackState::kFilterString;
+              AppendLenDelim(token.field_id, submessage_len, &out_);
+              state->filter_string_ptr = out_;
+              state->filter_string_semantic_type = filter.semantic_type;
+            } else if (filter.allowed) {
+              state->action = StackState::kPassthrough;
+              AppendLenDelim(token.field_id, submessage_len, &out_);
+            } else {
+              state->action = StackState::kDrop;
+            }
+          }
+          break;
+      }  // switch(type)
 
-// static
-void TrackEventInternal::WriteEventName(perfetto::DynamicString event_name,
-                                        perfetto::EventContext& event_ctx,
-                                        const TrackEventTlsState& tls_state) {
-  if (PERFETTO_LIKELY(!tls_state.filter_dynamic_event_names)) {
-    event_ctx.event()->set_name(event_name.value, event_name.length);
-  }
-}
+      if (PERFETTO_UNLIKELY(track_field_usage_)) {
+        IncrementCurrentFieldUsage(token.field_id, filter.allowed);
+      }
+    }  // if (token.valid)
+  }  // if (eat_next_bytes == 0)
 
-// static
-EventContext TrackEventInternal::WriteEvent(
-    TraceWriterBase* trace_writer,
-    TrackEventIncrementalState* incr_state,
-    const TrackEventTlsState& tls_state,
-    const Category* category,
-    perfetto::protos::pbzero::TrackEvent::Type type,
-    const TraceTimestamp& timestamp,
-    bool on_current_thread_track) {
-  PERFETTO_DCHECK(!incr_state->was_cleared);
-  auto packet = NewTracePacket(trace_writer, incr_state, tls_state, timestamp);
-  EventContext ctx(std::move(packet), incr_state, &tls_state);
+  ++state->in_bytes;
+  while (state->in_bytes >= state->in_bytes_limit) {
+    PERFETTO_DCHECK(state->in_bytes == state->in_bytes_limit);
+    push_next_state = false;
 
-  auto track_event = ctx.event();
-  if (type != protos::pbzero::TrackEvent::TYPE_UNSPECIFIED)
-    track_event->set_type(type);
+    // We can't possibly write more than we read.
+    const uint32_t msg_bytes_written = static_cast<uint32_t>(
+        out_written() - state->out_bytes_written_at_start);
+    PERFETTO_DCHECK(msg_bytes_written <= state->in_bytes_limit);
 
-  if (tls_state.enable_thread_time_sampling && on_current_thread_track) {
-    int64_t thread_time_ns = base::GetThreadCPUTimeNs().count();
-    auto thread_time_delta_ns =
-        thread_time_ns - incr_state->last_thread_time_ns;
-    incr_state->last_thread_time_ns = thread_time_ns;
-    track_event->add_extra_counter_values(
-        thread_time_delta_ns /
-        static_cast<int64_t>(tls_state.timestamp_unit_multiplier));
+    // Backfill the length field of the
+    proto_utils::WriteRedundantVarInt(msg_bytes_written, state->size_field,
+                                      state->size_field_len);
+
+    const uint32_t in_bytes_processes_for_last_msg = state->in_bytes;
+    stack_.pop_back();
+    PERFETTO_CHECK(!stack_.empty());
+    state = &stack_.back();
+    state->in_bytes += in_bytes_processes_for_last_msg;
+    if (PERFETTO_UNLIKELY(!tokenizer_.idle())) {
+      // If we hit this case, it means that we got to the end of a submessage
+      // while decoding a field. We can't recover from this and we don't want to
+      // propagate a broken sub-message.
+      return SetUnrecoverableErrorState();
+    }
   }
 
-  // We assume that |category| points to the string with static lifetime.
-  // This means we can use their addresses as interning keys.
-  // TODO(skyostil): Intern categories at compile time.
-  if (category && type != protos::pbzero::TrackEvent::TYPE_SLICE_END &&
-      type != protos::pbzero::TrackEvent::TYPE_COUNTER) {
-    category->ForEachGroupMember(
-        [&](const char* member_name, size_t name_size) {
-          size_t category_iid =
-              InternedEventCategory::Get(&ctx, member_name, name_size);
-          track_event->add_category_iids(category_iid);
-          return true;
-        });
+  if (push_next_state) {
+    PERFETTO_DCHECK(tokenizer_.idle());
+    stack_.emplace_back(std::move(next_state));
+    state = &stack_.back();
   }
-  return ctx;
 }
 
-// static
-protos::pbzero::DebugAnnotation* TrackEventInternal::AddDebugAnnotation(
-    perfetto::EventContext* event_ctx,
-    const char* name) {
-  auto annotation = event_ctx->event()->add_debug_annotations();
-  annotation->set_name_iid(InternedDebugAnnotationName::Get(event_ctx, name));
-  return annotation;
+void MessageFilter::SetUnrecoverableErrorState() {
+  error_ = true;
+  stack_.clear();
+  stack_.resize(1);
+  auto& state = stack_[0];
+  state.eat_next_bytes = UINT32_MAX;
+  state.in_bytes_limit = UINT32_MAX;
+  state.action = StackState::kDrop;
+  out_ = out_buf_.get();  // Reset the write pointer.
 }
 
-// static
-protos::pbzero::DebugAnnotation* TrackEventInternal::AddDebugAnnotation(
-    perfetto::EventContext* event_ctx,
-    perfetto::DynamicString name) {
-  auto annotation = event_ctx->event()->add_debug_annotations();
-  annotation->set_name(name.value);
-  return annotation;
+void MessageFilter::IncrementCurrentFieldUsage(uint32_t field_id,
+                                               bool allowed) {
+  // Slowpath. Used mainly in offline tools and tests to workout used fields in
+  // a proto.
+  PERFETTO_DCHECK(track_field_usage_);
+
+  // Field path contains a concatenation of varints, one for each nesting level.
+  // e.g. y in message Root { Sub x = 2; }; message Sub { SubSub y = 7; }
+  // is encoded as [varint(2) + varint(7)].
+  // We use varint to take the most out of SSO (small string opt). In most cases
+  // the path will fit in the on-stack 22 bytes, requiring no heap.
+  std::string field_path;
+
+  auto append_field_id = [&field_path](uint32_t id) {
+    uint8_t buf[10];
+    uint8_t* end = proto_utils::WriteVarInt(id, buf);
+    field_path.append(reinterpret_cast<char*>(buf),
+                      static_cast<size_t>(end - buf));
+  };
+
+  // Append all the ancestors IDs from the state stack.
+  // The first entry of the stack has always ID 0 and we skip it (we don't know
+  // the ID of the root message itself).
+  PERFETTO_DCHECK(stack_.size() >= 2 && stack_[1].field_id == 0);
+  for (size_t i = 2; i < stack_.size(); ++i)
+    append_field_id(stack_[i].field_id);
+  // Append the id of the field in the current message.
+  append_field_id(field_id);
+  field_usage_[field_path] += allowed ? 1 : -1;
 }
 
-}  // namespace internal
-}  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/internal/track_event_interned_fields.cc
+}  // namespace protozero
+// gen_amalgamated begin source: src/tracing/service/clock.cc
+// gen_amalgamated begin header: src/tracing/service/clock.h
 /*
- * Copyright (C) 2021 The Android Open Source Project
+ * Copyright (C) 2024 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -49359,64 +56117,46 @@ protos::pbzero::DebugAnnotation* TrackEventInternal::AddDebugAnnotation(
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/track_event_interned_fields.h"
-
-namespace perfetto {
-namespace internal {
-
-InternedEventCategory::~InternedEventCategory() = default;
+#ifndef SRC_TRACING_SERVICE_CLOCK_H_
+#define SRC_TRACING_SERVICE_CLOCK_H_
 
-// static
-void InternedEventCategory::Add(protos::pbzero::InternedData* interned_data,
-                                size_t iid,
-                                const char* value,
-                                size_t length) {
-  auto category = interned_data->add_event_categories();
-  category->set_iid(iid);
-  category->set_name(value, length);
-}
+// gen_amalgamated expanded: #include "perfetto/base/time.h"
 
-InternedEventName::~InternedEventName() = default;
+namespace perfetto::tracing_service {
 
-// static
-void InternedEventName::Add(protos::pbzero::InternedData* interned_data,
-                            size_t iid,
-                            const char* value) {
-  auto name = interned_data->add_event_names();
-  name->set_iid(iid);
-  name->set_name(value);
-}
+class Clock {
+ public:
+  virtual ~Clock();
+  virtual base::TimeNanos GetBootTimeNs() = 0;
+  virtual base::TimeNanos GetWallTimeNs() = 0;
 
-InternedDebugAnnotationName::~InternedDebugAnnotationName() = default;
+  base::TimeMillis GetBootTimeMs() {
+    return std::chrono::duration_cast<base::TimeMillis>(GetBootTimeNs());
+  }
+  base::TimeMillis GetWallTimeMs() {
+    return std::chrono::duration_cast<base::TimeMillis>(GetWallTimeNs());
+  }
 
-// static
-void InternedDebugAnnotationName::Add(
-    protos::pbzero::InternedData* interned_data,
-    size_t iid,
-    const char* value) {
-  auto name = interned_data->add_debug_annotation_names();
-  name->set_iid(iid);
-  name->set_name(value);
-}
+  base::TimeSeconds GetBootTimeS() {
+    return std::chrono::duration_cast<base::TimeSeconds>(GetBootTimeNs());
+  }
+  base::TimeSeconds GetWallTimeS() {
+    return std::chrono::duration_cast<base::TimeSeconds>(GetWallTimeNs());
+  }
+};
 
-InternedDebugAnnotationValueTypeName::~InternedDebugAnnotationValueTypeName() =
-    default;
+class ClockImpl : public Clock {
+ public:
+  ~ClockImpl() override;
+  base::TimeNanos GetBootTimeNs() override;
+  base::TimeNanos GetWallTimeNs() override;
+};
 
-// static
-void InternedDebugAnnotationValueTypeName::Add(
-    protos::pbzero::InternedData* interned_data,
-    size_t iid,
-    const char* value) {
-  auto name = interned_data->add_debug_annotation_value_type_names();
-  name->set_iid(iid);
-  name->set_name(value);
-}
+}  // namespace perfetto::tracing_service
 
-}  // namespace internal
-}  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/platform.cc
+#endif  // SRC_TRACING_SERVICE_CLOCK_H_
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2024 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -49431,30 +56171,27 @@ void InternedDebugAnnotationValueTypeName::Add(
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/tracing/platform.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_tls.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/trace_writer_base.h"
+// gen_amalgamated expanded: #include "src/tracing/service/clock.h"
 
-namespace perfetto {
+namespace perfetto::tracing_service {
 
-PlatformThreadLocalObject::~PlatformThreadLocalObject() = default;
-Platform::~Platform() = default;
+Clock::~Clock() = default;
 
-void Platform::Shutdown() {}
+ClockImpl::~ClockImpl() = default;
 
-// static
-std::unique_ptr<PlatformThreadLocalObject>
-PlatformThreadLocalObject::CreateInstance() {
-  return std::unique_ptr<PlatformThreadLocalObject>(new internal::TracingTLS());
+base::TimeNanos ClockImpl::GetBootTimeNs() {
+  return base::GetBootTimeNs();
 }
 
-// static
-base::PlatformProcessId Platform::process_id_ = 0;
+base::TimeNanos ClockImpl::GetWallTimeNs() {
+  return base::GetWallTimeNs();
+}
 
-}  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/traced_value.cc
+}  // namespace perfetto::tracing_service
+// gen_amalgamated begin source: src/tracing/service/metatrace_writer.cc
+// gen_amalgamated begin header: src/tracing/service/metatrace_writer.h
 /*
- * Copyright (C) 2021 The Android Open Source Project
+ * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -49469,173 +56206,171 @@ base::PlatformProcessId Platform::process_id_ = 0;
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/tracing/traced_value.h"
+#ifndef SRC_TRACING_SERVICE_METATRACE_WRITER_H_
+#define SRC_TRACING_SERVICE_METATRACE_WRITER_H_
 
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/debug_annotation.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/track_event_interned_fields.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/debug_annotation.pbzero.h"
+#include <functional>
+#include <memory>
 
-namespace perfetto {
+// gen_amalgamated expanded: #include "perfetto/ext/base/metatrace.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/thread_checker.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/weak_ptr.h"
 
-namespace internal {
+namespace perfetto {
 
-TracedValue CreateTracedValueFromProto(
-    protos::pbzero::DebugAnnotation* annotation,
-    EventContext* event_context) {
-  return TracedValue::CreateFromProto(annotation, event_context);
+namespace base {
+class TaskRunner;
 }
 
-}  // namespace internal
+class TraceWriter;
 
-// static
-TracedValue TracedValue::CreateFromProto(
-    protos::pbzero::DebugAnnotation* annotation,
-    EventContext* event_context) {
-  return TracedValue(annotation, event_context, nullptr);
-}
+// Complements the base::metatrace infrastructure.
+// It hooks a callback to metatrace::Enable() and writes metatrace events into
+// a TraceWriter whenever the metatrace ring buffer is half full.
+// It is safe to create and attempt to start multiple instances of this class,
+// however only the first one will succeed because the metatrace framework
+// doesn't support multiple instances.
+// This class is defined here (instead of directly in src/probes/) so it can
+// be reused by other components (e.g. heapprofd).
+class MetatraceWriter {
+ public:
+  static constexpr char kDataSourceName[] = "perfetto.metatrace";
 
-TracedValue::TracedValue(TracedValue&&) = default;
-TracedValue::~TracedValue() = default;
+  MetatraceWriter();
+  ~MetatraceWriter();
 
-void TracedValue::WriteInt64(int64_t value) && {
-  PERFETTO_DCHECK(checked_scope_.is_active());
-  annotation_->set_int_value(value);
-}
+  MetatraceWriter(const MetatraceWriter&) = delete;
+  MetatraceWriter& operator=(const MetatraceWriter&) = delete;
+  MetatraceWriter(MetatraceWriter&&) = delete;
+  MetatraceWriter& operator=(MetatraceWriter&&) = delete;
 
-void TracedValue::WriteUInt64(uint64_t value) && {
-  PERFETTO_DCHECK(checked_scope_.is_active());
-  annotation_->set_uint_value(value);
-}
+  void Enable(base::TaskRunner*, std::unique_ptr<TraceWriter>, uint32_t tags);
+  void Disable();
+  void WriteAllAndFlushTraceWriter(std::function<void()> callback);
 
-void TracedValue::WriteDouble(double value) && {
-  PERFETTO_DCHECK(checked_scope_.is_active());
-  annotation_->set_double_value(value);
-}
+ private:
+  void WriteAllAvailableEvents();
 
-void TracedValue::WriteBoolean(bool value) && {
-  PERFETTO_DCHECK(checked_scope_.is_active());
-  annotation_->set_bool_value(value);
-}
+  bool started_ = false;
+  base::TaskRunner* task_runner_ = nullptr;
+  std::unique_ptr<TraceWriter> trace_writer_;
+  PERFETTO_THREAD_CHECKER(thread_checker_)
+  base::WeakPtrFactory<MetatraceWriter> weak_ptr_factory_;  // Keep last.
+};
 
-void TracedValue::WriteString(const char* value) && {
-  PERFETTO_DCHECK(checked_scope_.is_active());
-  annotation_->set_string_value(value);
-}
+}  // namespace perfetto
 
-void TracedValue::WriteString(const char* value, size_t len) && {
-  PERFETTO_DCHECK(checked_scope_.is_active());
-  annotation_->set_string_value(value, len);
-}
+#endif  // SRC_TRACING_SERVICE_METATRACE_WRITER_H_
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-void TracedValue::WriteString(const std::string& value) && {
-  PERFETTO_DCHECK(checked_scope_.is_active());
-  annotation_->set_string_value(value);
-}
+// gen_amalgamated expanded: #include "src/tracing/service/metatrace_writer.h"
 
-void TracedValue::WritePointer(const void* value) && {
-  PERFETTO_DCHECK(checked_scope_.is_active());
-  annotation_->set_pointer_value(reinterpret_cast<uint64_t>(value));
-}
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_writer.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_descriptor.h"
 
-TracedDictionary TracedValue::WriteDictionary() && {
-  // Note: this passes |checked_scope_.is_active_| bit to the parent to be
-  // picked up later by the new TracedDictionary.
-  PERFETTO_DCHECK(checked_scope_.is_active());
-  checked_scope_.Reset();
+// gen_amalgamated expanded: #include "protos/perfetto/trace/perfetto/perfetto_metatrace.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h"
 
-  PERFETTO_DCHECK(!annotation_->is_finalized());
-  return TracedDictionary(annotation_,
-                          protos::pbzero::DebugAnnotation::kDictEntries,
-                          event_context_, checked_scope_.parent_scope());
-}
+namespace perfetto {
 
-TracedArray TracedValue::WriteArray() && {
-  // Note: this passes |checked_scope_.is_active_| bit to the parent to be
-  // picked up later by the new TracedDictionary.
-  PERFETTO_DCHECK(checked_scope_.is_active());
-  checked_scope_.Reset();
+MetatraceWriter::MetatraceWriter() : weak_ptr_factory_(this) {}
 
-  PERFETTO_DCHECK(!annotation_->is_finalized());
-  return TracedArray(annotation_, event_context_,
-                     checked_scope_.parent_scope());
+MetatraceWriter::~MetatraceWriter() {
+  Disable();
 }
 
-protozero::Message* TracedValue::WriteProtoInternal(const char* name) {
-  if (event_context_) {
-    annotation_->set_proto_type_name_iid(
-        internal::InternedDebugAnnotationValueTypeName::Get(event_context_,
-                                                            name));
-  } else {
-    annotation_->set_proto_type_name(name);
+void MetatraceWriter::Enable(base::TaskRunner* task_runner,
+                             std::unique_ptr<TraceWriter> trace_writer,
+                             uint32_t tags) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  if (started_) {
+    PERFETTO_DFATAL_OR_ELOG("Metatrace already started from this instance");
+    return;
   }
-  return annotation_->template BeginNestedMessage<protozero::Message>(
-      protos::pbzero::DebugAnnotation::kProtoValueFieldNumber);
-}
-
-TracedArray::TracedArray(TracedValue annotation)
-    : TracedArray(std::move(annotation).WriteArray()) {}
-
-TracedValue TracedArray::AppendItem() {
-  PERFETTO_DCHECK(checked_scope_.is_active());
-  return TracedValue(annotation_->add_array_values(), event_context_,
-                     &checked_scope_);
-}
-
-TracedDictionary TracedArray::AppendDictionary() {
-  PERFETTO_DCHECK(checked_scope_.is_active());
-  return AppendItem().WriteDictionary();
-}
-
-TracedArray TracedArray::AppendArray() {
-  PERFETTO_DCHECK(checked_scope_.is_active());
-  return AppendItem().WriteArray();
+  task_runner_ = task_runner;
+  trace_writer_ = std::move(trace_writer);
+  auto weak_ptr = weak_ptr_factory_.GetWeakPtr();
+  bool enabled = metatrace::Enable(
+      [weak_ptr] {
+        if (weak_ptr)
+          weak_ptr->WriteAllAvailableEvents();
+      },
+      task_runner, tags);
+  if (!enabled)
+    return;
+  started_ = true;
 }
 
-TracedDictionary::TracedDictionary(TracedValue annotation)
-    : TracedDictionary(std::move(annotation).WriteDictionary()) {}
-
-TracedValue TracedDictionary::AddItem(StaticString key) {
-  PERFETTO_DCHECK(checked_scope_.is_active());
-  protos::pbzero::DebugAnnotation* item =
-      message_->BeginNestedMessage<protos::pbzero::DebugAnnotation>(field_id_);
-  item->set_name(key.value);
-  return TracedValue(item, event_context_, &checked_scope_);
+void MetatraceWriter::Disable() {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  if (!started_)
+    return;
+  metatrace::Disable();
+  started_ = false;
+  trace_writer_.reset();
 }
 
-TracedValue TracedDictionary::AddItem(DynamicString key) {
-  PERFETTO_DCHECK(checked_scope_.is_active());
-  protos::pbzero::DebugAnnotation* item =
-      message_->BeginNestedMessage<protos::pbzero::DebugAnnotation>(field_id_);
-  item->set_name(key.value);
-  return TracedValue(item, event_context_, &checked_scope_);
-}
+void MetatraceWriter::WriteAllAvailableEvents() {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  if (!started_)
+    return;
+  for (auto it = metatrace::RingBuffer::GetReadIterator(); it; ++it) {
+    auto type_and_id = it->type_and_id.load(std::memory_order_acquire);
+    if (type_and_id == 0)
+      break;  // Stop at the first incomplete event.
 
-TracedDictionary TracedDictionary::AddDictionary(StaticString key) {
-  PERFETTO_DCHECK(checked_scope_.is_active());
-  return AddItem(key).WriteDictionary();
-}
+    auto packet = trace_writer_->NewTracePacket();
+    packet->set_timestamp(it->timestamp_ns());
+    auto* evt = packet->set_perfetto_metatrace();
+    uint16_t type = type_and_id & metatrace::Record::kTypeMask;
+    uint16_t id = type_and_id & ~metatrace::Record::kTypeMask;
+    if (type == metatrace::Record::kTypeCounter) {
+      evt->set_counter_id(id);
+      evt->set_counter_value(it->counter_value);
+    } else {
+      evt->set_event_id(id);
+      evt->set_event_duration_ns(it->duration_ns);
+    }
 
-TracedDictionary TracedDictionary::AddDictionary(DynamicString key) {
-  PERFETTO_DCHECK(checked_scope_.is_active());
-  return AddItem(key).WriteDictionary();
-}
+    evt->set_thread_id(static_cast<uint32_t>(it->thread_id));
 
-TracedArray TracedDictionary::AddArray(StaticString key) {
-  PERFETTO_DCHECK(checked_scope_.is_active());
-  return AddItem(key).WriteArray();
+    if (metatrace::RingBuffer::has_overruns())
+      evt->set_has_overruns(true);
+  }
+  // The |it| destructor will automatically update the read index position in
+  // the meta-trace ring buffer.
 }
 
-TracedArray TracedDictionary::AddArray(DynamicString key) {
-  PERFETTO_DCHECK(checked_scope_.is_active());
-  return AddItem(key).WriteArray();
+void MetatraceWriter::WriteAllAndFlushTraceWriter(
+    std::function<void()> callback) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  if (!started_)
+    return;
+  WriteAllAvailableEvents();
+  trace_writer_->Flush(std::move(callback));
 }
 
 }  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/tracing.cc
-// gen_amalgamated begin header: include/perfetto/ext/base/no_destructor.h
+// gen_amalgamated begin source: src/tracing/service/packet_stream_validator.cc
+// gen_amalgamated begin header: src/tracing/service/packet_stream_validator.h
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -49650,70 +56385,34 @@ TracedArray TracedDictionary::AddArray(DynamicString key) {
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_EXT_BASE_NO_DESTRUCTOR_H_
-#define INCLUDE_PERFETTO_EXT_BASE_NO_DESTRUCTOR_H_
+#ifndef SRC_TRACING_SERVICE_PACKET_STREAM_VALIDATOR_H_
+#define SRC_TRACING_SERVICE_PACKET_STREAM_VALIDATOR_H_
 
-#include <new>
-#include <utility>
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/slice.h"
 
 namespace perfetto {
-namespace base {
 
-// Wrapper that can hold an object of type T, without invoking the contained
-// object's destructor when being destroyed. Useful for creating statics while
-// avoiding static destructors.
-//
-// Stores the object inline, and therefore doesn't incur memory allocation and
-// pointer indirection overheads.
-//
-// Example of use:
+// Checks that the stream of trace packets sent by the producer is well formed.
+// This includes:
 //
-//   const std::string& GetStr() {
-//     static base::NoDestructor<std::string> s("hello");
-//     return s.ref();
-//   }
+// - Checking that the packets are not truncated.
+// - There are no dangling bytes left over in the packets.
+// - Any trusted fields (e.g., uid) are not set.
 //
-template <typename T>
-class NoDestructor {
+// Note that we only validate top-level fields in the trace proto; sub-messages
+// are simply skipped.
+class PacketStreamValidator {
  public:
-  // Forward arguments to T's constructor. Note that this doesn't cover
-  // construction from initializer lists.
-  template <typename... Args>
-  explicit NoDestructor(Args&&... args) {
-    new (storage_) T(std::forward<Args>(args)...);
-  }
-
-  NoDestructor(const NoDestructor&) = delete;
-  NoDestructor& operator=(const NoDestructor&) = delete;
-  NoDestructor(NoDestructor&&) = delete;
-  NoDestructor& operator=(NoDestructor&&) = delete;
-
-  ~NoDestructor() = default;
-
-  /* To avoid type-punned pointer strict aliasing warnings on GCC6 and below
-   * these need to be split over two lines. If they are collapsed onto one line.
-   *   return reinterpret_cast<const T*>(storage_);
-   * The error fires.
-   */
-  const T& ref() const {
-    auto* const cast = reinterpret_cast<const T*>(storage_);
-    return *cast;
-  }
-  T& ref() {
-    auto* const cast = reinterpret_cast<T*>(storage_);
-    return *cast;
-  }
+  PacketStreamValidator() = delete;
 
- private:
-  alignas(T) char storage_[sizeof(T)];
+  static bool Validate(const Slices&);
 };
 
-}  // namespace base
 }  // namespace perfetto
 
-#endif  // INCLUDE_PERFETTO_EXT_BASE_NO_DESTRUCTOR_H_
+#endif  // SRC_TRACING_SERVICE_PACKET_STREAM_VALIDATOR_H_
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -49728,201 +56427,190 @@ class NoDestructor {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/tracing/tracing.h"
-
-#include <atomic>
-#include <condition_variable>
-#include <mutex>
-
-// gen_amalgamated expanded: #include "perfetto/ext/base/no_destructor.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/waitable_event.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/track_event_internal.h"
-// gen_amalgamated expanded: #include "src/tracing/internal/tracing_muxer_impl.h"
-
-namespace perfetto {
-namespace {
-bool g_was_initialized = false;
-
-// Wrapped in a function to avoid global constructor
-std::mutex& InitializedMutex() {
-  static base::NoDestructor<std::mutex> initialized_mutex;
-  return initialized_mutex.ref();
-}
-}  // namespace
-
-// static
-void Tracing::InitializeInternal(const TracingInitArgs& args) {
-  std::unique_lock<std::mutex> lock(InitializedMutex());
-  // If it's the first time Initialize is called, set some global params.
-  if (!g_was_initialized) {
-    // Make sure the headers and implementation files agree on the build config.
-    PERFETTO_CHECK(args.dcheck_is_on_ == PERFETTO_DCHECK_IS_ON());
-    if (args.log_message_callback) {
-      base::SetLogMessageCallback(args.log_message_callback);
-    }
-
-    if (args.use_monotonic_clock) {
-      PERFETTO_CHECK(!args.use_monotonic_raw_clock);
-      internal::TrackEventInternal::SetClockId(
-          protos::pbzero::BUILTIN_CLOCK_MONOTONIC);
-    } else if (args.use_monotonic_raw_clock) {
-      internal::TrackEventInternal::SetClockId(
-          protos::pbzero::BUILTIN_CLOCK_MONOTONIC_RAW);
-    }
-  }
+// gen_amalgamated expanded: #include "src/tracing/service/packet_stream_validator.h"
 
-  internal::TracingMuxerImpl::InitializeInstance(args);
-  internal::TrackRegistry::InitializeInstance();
-  g_was_initialized = true;
-}
+#include <stddef.h>
 
-// static
-bool Tracing::IsInitialized() {
-  std::unique_lock<std::mutex> lock(InitializedMutex());
-  return g_was_initialized;
-}
+#include <cinttypes>
 
-// static
-void Tracing::Shutdown() {
-  std::unique_lock<std::mutex> lock(InitializedMutex());
-  if (!g_was_initialized)
-    return;
-  internal::TracingMuxerImpl::Shutdown();
-  g_was_initialized = false;
-}
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-// static
-void Tracing::ResetForTesting() {
-  std::unique_lock<std::mutex> lock(InitializedMutex());
-  if (!g_was_initialized)
-    return;
-  base::SetLogMessageCallback(nullptr);
-  internal::TracingMuxerImpl::ResetForTesting();
-  internal::TrackRegistry::ResetForTesting();
-  g_was_initialized = false;
-}
+// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h"
 
-//  static
-std::unique_ptr<TracingSession> Tracing::NewTraceInternal(
-    BackendType backend,
-    TracingConsumerBackend* (*system_backend_factory)()) {
-  return static_cast<internal::TracingMuxerImpl*>(internal::TracingMuxer::Get())
-      ->CreateTracingSession(backend, system_backend_factory);
-}
+namespace perfetto {
 
-//  static
-std::unique_ptr<StartupTracingSession> Tracing::SetupStartupTracing(
-    const TraceConfig& config,
-    Tracing::SetupStartupTracingOpts opts) {
-  return static_cast<internal::TracingMuxerImpl*>(internal::TracingMuxer::Get())
-      ->CreateStartupTracingSession(config, std::move(opts));
-}
+namespace {
 
-//  static
-std::unique_ptr<StartupTracingSession> Tracing::SetupStartupTracingBlocking(
-    const TraceConfig& config,
-    Tracing::SetupStartupTracingOpts opts) {
-  return static_cast<internal::TracingMuxerImpl*>(internal::TracingMuxer::Get())
-      ->CreateStartupTracingSessionBlocking(config, std::move(opts));
-}
+using protozero::proto_utils::ProtoWireType;
 
-//  static
-void Tracing::ActivateTriggers(const std::vector<std::string>& triggers,
-                               uint32_t ttl_ms) {
-  internal::TracingMuxer::Get()->ActivateTriggers(triggers, ttl_ms);
-}
+const uint32_t kReservedFieldIds[] = {
+    protos::pbzero::TracePacket::kTrustedUidFieldNumber,
+    protos::pbzero::TracePacket::kTrustedPacketSequenceIdFieldNumber,
+    protos::pbzero::TracePacket::kTraceConfigFieldNumber,
+    protos::pbzero::TracePacket::kTraceStatsFieldNumber,
+    protos::pbzero::TracePacket::kCompressedPacketsFieldNumber,
+    protos::pbzero::TracePacket::kSynchronizationMarkerFieldNumber,
+    protos::pbzero::TracePacket::kTrustedPidFieldNumber,
+    protos::pbzero::TracePacket::kMachineIdFieldNumber,
+};
 
-TracingSession::~TracingSession() = default;
+// This translation unit is quite subtle and perf-sensitive. Remember to check
+// BM_PacketStreamValidator in perfetto_benchmarks when making changes.
 
-// Can be called from any thread.
-bool TracingSession::FlushBlocking(uint32_t timeout_ms) {
-  std::atomic<bool> flush_result;
-  base::WaitableEvent flush_ack;
+// Checks that a packet, spread over several slices, is well-formed and doesn't
+// contain reserved top-level fields.
+// The checking logic is based on a state-machine that skips the fields' payload
+// and operates as follows:
+//              +-------------------------------+ <-------------------------+
+// +----------> | Read field preamble (varint)  | <----------------------+  |
+// |            +-------------------------------+                        |  |
+// |              |              |            |                          |  |
+// |       <Varint>        <Fixed 32/64>     <Length-delimited field>    |  |
+// |          V                  |                      V                |  |
+// |  +------------------+       |               +--------------+        |  |
+// |  | Read field value |       |               | Read length  |        |  |
+// |  | (another varint) |       |               |   (varint)   |        |  |
+// |  +------------------+       |               +--------------+        |  |
+// |           |                 V                      V                |  |
+// +-----------+        +----------------+     +-----------------+       |  |
+//                      | Skip 4/8 Bytes |     | Skip $len Bytes |-------+  |
+//                      +----------------+     +-----------------+          |
+//                               |                                          |
+//                               +------------------------------------------+
+class ProtoFieldParserFSM {
+ public:
+  // This method effectively continuously parses varints (either for the field
+  // preamble or the payload or the submessage length) and tells the caller
+  // (the Validate() method) how many bytes to skip until the next field.
+  size_t Push(uint8_t octet) {
+    varint_ |= static_cast<uint64_t>(octet & 0x7F) << varint_shift_;
+    if (octet & 0x80) {
+      varint_shift_ += 7;
+      if (varint_shift_ >= 64) {
+        // Do not invoke UB on next call.
+        varint_shift_ = 0;
+        state_ = kInvalidVarInt;
+      }
+      return 0;
+    }
+    uint64_t varint = varint_;
+    varint_ = 0;
+    varint_shift_ = 0;
 
-  // The non blocking Flush() can be called on any thread. It does the PostTask
-  // internally.
-  Flush(
-      [&flush_ack, &flush_result](bool res) {
-        flush_result = res;
-        flush_ack.Notify();
-      },
-      timeout_ms);
-  flush_ack.Wait();
-  return flush_result;
-}
+    switch (state_) {
+      case kFieldPreamble: {
+        uint64_t field_type = varint & 7;  // 7 = 0..0111
+        auto field_id = static_cast<uint32_t>(varint >> 3);
+        // Check if the field id is reserved, go into an error state if it is.
+        for (size_t i = 0; i < base::ArraySize(kReservedFieldIds); ++i) {
+          if (field_id == kReservedFieldIds[i]) {
+            state_ = kWroteReservedField;
+            return 0;
+          }
+        }
+        // The field type is legit, now check it's well formed and within
+        // boundaries.
+        if (field_type == static_cast<uint64_t>(ProtoWireType::kVarInt)) {
+          state_ = kVarIntValue;
+        } else if (field_type ==
+                   static_cast<uint64_t>(ProtoWireType::kFixed32)) {
+          return 4;
+        } else if (field_type ==
+                   static_cast<uint64_t>(ProtoWireType::kFixed64)) {
+          return 8;
+        } else if (field_type ==
+                   static_cast<uint64_t>(ProtoWireType::kLengthDelimited)) {
+          state_ = kLenDelimitedLen;
+        } else {
+          state_ = kUnknownFieldType;
+        }
+        return 0;
+      }
 
-std::vector<char> TracingSession::ReadTraceBlocking() {
-  std::vector<char> raw_trace;
-  std::mutex mutex;
-  std::condition_variable cv;
+      case kVarIntValue: {
+        // Consume the int field payload and go back to the next field.
+        state_ = kFieldPreamble;
+        return 0;
+      }
 
-  bool all_read = false;
+      case kLenDelimitedLen: {
+        if (varint > protozero::proto_utils::kMaxMessageLength) {
+          state_ = kMessageTooBig;
+          return 0;
+        }
+        state_ = kFieldPreamble;
+        return static_cast<size_t>(varint);
+      }
 
-  ReadTrace([&mutex, &raw_trace, &all_read, &cv](ReadTraceCallbackArgs cb) {
-    raw_trace.insert(raw_trace.end(), cb.data, cb.data + cb.size);
-    std::unique_lock<std::mutex> lock(mutex);
-    all_read = !cb.has_more;
-    if (all_read)
-      cv.notify_one();
-  });
+      case kWroteReservedField:
+      case kUnknownFieldType:
+      case kMessageTooBig:
+      case kInvalidVarInt:
+        // Persistent error states.
+        return 0;
 
-  {
-    std::unique_lock<std::mutex> lock(mutex);
-    cv.wait(lock, [&all_read] { return all_read; });
+    }  // switch(state_)
+    return 0;  // To keep GCC happy.
   }
-  return raw_trace;
-}
 
-TracingSession::GetTraceStatsCallbackArgs
-TracingSession::GetTraceStatsBlocking() {
-  std::mutex mutex;
-  std::condition_variable cv;
-  GetTraceStatsCallbackArgs result;
-  bool stats_read = false;
+  // Queried at the end of the all payload. A message is well-formed only
+  // if the FSM is back to the state where it should parse the next field and
+  // hasn't started parsing any preamble.
+  bool valid() const { return state_ == kFieldPreamble && varint_shift_ == 0; }
+  int state() const { return static_cast<int>(state_); }
 
-  GetTraceStats(
-      [&mutex, &result, &stats_read, &cv](GetTraceStatsCallbackArgs args) {
-        result = std::move(args);
-        std::unique_lock<std::mutex> lock(mutex);
-        stats_read = true;
-        cv.notify_one();
-      });
+ private:
+  enum State {
+    kFieldPreamble = 0,  // Parsing the varint for the field preamble.
+    kVarIntValue,        // Parsing the varint value for the field payload.
+    kLenDelimitedLen,    // Parsing the length of the length-delimited field.
 
-  {
-    std::unique_lock<std::mutex> lock(mutex);
-    cv.wait(lock, [&stats_read] { return stats_read; });
-  }
-  return result;
-}
+    // Error states:
+    kWroteReservedField,  // Tried to set a reserved field id.
+    kUnknownFieldType,    // Encountered an invalid field type.
+    kMessageTooBig,       // Size of the length delimited message was too big.
+    kInvalidVarInt,       // VarInt larger than 64 bits.
+  };
 
-TracingSession::QueryServiceStateCallbackArgs
-TracingSession::QueryServiceStateBlocking() {
-  std::mutex mutex;
-  std::condition_variable cv;
-  QueryServiceStateCallbackArgs result;
-  bool status_read = false;
+  State state_ = kFieldPreamble;
+  uint64_t varint_ = 0;
+  uint32_t varint_shift_ = 0;
+};
 
-  QueryServiceState(
-      [&mutex, &result, &status_read, &cv](QueryServiceStateCallbackArgs args) {
-        result = std::move(args);
-        std::unique_lock<std::mutex> lock(mutex);
-        status_read = true;
-        cv.notify_one();
-      });
+}  // namespace
 
-  {
-    std::unique_lock<std::mutex> lock(mutex);
-    cv.wait(lock, [&status_read] { return status_read; });
+// static
+bool PacketStreamValidator::Validate(const Slices& slices) {
+  ProtoFieldParserFSM parser;
+  size_t skip_bytes = 0;
+  for (const Slice& slice : slices) {
+    for (size_t i = 0; i < slice.size;) {
+      const size_t skip_bytes_cur_slice = std::min(skip_bytes, slice.size - i);
+      if (skip_bytes_cur_slice > 0) {
+        i += skip_bytes_cur_slice;
+        skip_bytes -= skip_bytes_cur_slice;
+      } else {
+        uint8_t octet = *(reinterpret_cast<const uint8_t*>(slice.start) + i);
+        skip_bytes = parser.Push(octet);
+        i++;
+      }
+    }
   }
-  return result;
-}
+  if (skip_bytes == 0 && parser.valid())
+    return true;
 
-StartupTracingSession::~StartupTracingSession() = default;
+  PERFETTO_DLOG("Packet validation error (state %d, skip = %zu)",
+                parser.state(), skip_bytes);
+  return false;
+}
 
 }  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/tracing_policy.cc
+// gen_amalgamated begin source: src/tracing/service/random.cc
+// gen_amalgamated begin header: src/tracing/service/random.h
 /*
- * Copyright (C) 2021 The Android Open Source Project
+ * Copyright (C) 2024 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -49937,16 +56625,37 @@ StartupTracingSession::~StartupTracingSession() = default;
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/tracing/tracing_policy.h"
+#ifndef SRC_TRACING_SERVICE_RANDOM_H_
+#define SRC_TRACING_SERVICE_RANDOM_H_
 
-namespace perfetto {
+#include <stdint.h>
 
-TracingPolicy::~TracingPolicy() = default;
+#include <random>
 
-}  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/track.cc
+namespace perfetto::tracing_service {
+
+class Random {
+ public:
+  virtual ~Random();
+  virtual double GetValue() = 0;
+};
+
+class RandomImpl : public Random {
+ public:
+  explicit RandomImpl(uint32_t seed);
+  ~RandomImpl() override;
+  double GetValue() override;
+
+ private:
+  std::minstd_rand prng_;
+  std::uniform_real_distribution<double> dist_;
+};
+
+}  // namespace perfetto::tracing_service
+
+#endif  // SRC_TRACING_SERVICE_RANDOM_H_
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2024 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -49961,213 +56670,77 @@ TracingPolicy::~TracingPolicy() = default;
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/tracing/track.h"
-
-// gen_amalgamated expanded: #include "perfetto/ext/base/file_utils.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/hash.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/string_splitter.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/thread_utils.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/uuid.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/track_event_data_source.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/counter_descriptor.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/process_descriptor.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/process_descriptor.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/thread_descriptor.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/thread_descriptor.pbzero.h"
-
-namespace perfetto {
-
-// static
-uint64_t Track::process_uuid;
-
-protos::gen::TrackDescriptor Track::Serialize() const {
-  protos::gen::TrackDescriptor desc;
-  desc.set_uuid(uuid);
-  if (parent_uuid)
-    desc.set_parent_uuid(parent_uuid);
-  return desc;
-}
-
-void Track::Serialize(protos::pbzero::TrackDescriptor* desc) const {
-  auto bytes = Serialize().SerializeAsString();
-  desc->AppendRawProtoBytes(bytes.data(), bytes.size());
-}
-
-protos::gen::TrackDescriptor ProcessTrack::Serialize() const {
-  auto desc = Track::Serialize();
-  auto pd = desc.mutable_process();
-  pd->set_pid(static_cast<int32_t>(pid));
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-  std::string cmdline;
-  if (base::ReadFile("/proc/self/cmdline", &cmdline)) {
-    // Since cmdline is a zero-terminated list of arguments, this ends up
-    // writing just the first element, i.e., the process name, into the process
-    // name field.
-    pd->set_process_name(cmdline.c_str());
-    base::StringSplitter splitter(std::move(cmdline), '\0');
-    while (splitter.Next()) {
-      pd->add_cmdline(
-          std::string(splitter.cur_token(), splitter.cur_token_size()));
-    }
-  }
-  // TODO(skyostil): Record command line on Windows and Mac.
-#endif
-  return desc;
-}
-
-void ProcessTrack::Serialize(protos::pbzero::TrackDescriptor* desc) const {
-  auto bytes = Serialize().SerializeAsString();
-  desc->AppendRawProtoBytes(bytes.data(), bytes.size());
-}
-
-protos::gen::TrackDescriptor ThreadTrack::Serialize() const {
-  auto desc = Track::Serialize();
-  auto td = desc.mutable_thread();
-  td->set_pid(static_cast<int32_t>(pid));
-  td->set_tid(static_cast<int32_t>(tid));
-  std::string thread_name;
-  if (base::GetThreadName(thread_name))
-    td->set_thread_name(thread_name);
-  return desc;
-}
-
-void ThreadTrack::Serialize(protos::pbzero::TrackDescriptor* desc) const {
-  auto bytes = Serialize().SerializeAsString();
-  desc->AppendRawProtoBytes(bytes.data(), bytes.size());
-}
+// gen_amalgamated expanded: #include "src/tracing/service/random.h"
 
-protos::gen::TrackDescriptor CounterTrack::Serialize() const {
-  auto desc = Track::Serialize();
-  desc.set_name(name_);
-  auto* counter = desc.mutable_counter();
-  if (category_)
-    counter->add_categories(category_);
-  if (unit_ != perfetto::protos::pbzero::CounterDescriptor::UNIT_UNSPECIFIED)
-    counter->set_unit(static_cast<protos::gen::CounterDescriptor_Unit>(unit_));
-  {
-    // if |type| is set, we don't want to emit |unit_name|. Trace processor
-    // infers the track name from the type in that case.
-    if (type_ !=
-        perfetto::protos::gen::CounterDescriptor::COUNTER_UNSPECIFIED) {
-      counter->set_type(type_);
-    } else if (unit_name_) {
-      counter->set_unit_name(unit_name_);
-    }
-  }
-  if (unit_multiplier_ != 1)
-    counter->set_unit_multiplier(unit_multiplier_);
-  if (is_incremental_)
-    counter->set_is_incremental(is_incremental_);
-  return desc;
-}
+namespace perfetto::tracing_service {
 
-void CounterTrack::Serialize(protos::pbzero::TrackDescriptor* desc) const {
-  auto bytes = Serialize().SerializeAsString();
-  desc->AppendRawProtoBytes(bytes.data(), bytes.size());
-}
+Random::~Random() = default;
 
-namespace internal {
-namespace {
+RandomImpl::RandomImpl(uint32_t seed) : prng_(seed) {}
+RandomImpl::~RandomImpl() = default;
 
-uint64_t GetProcessStartTime() {
-#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-  std::string stat;
-  if (!base::ReadFile("/proc/self/stat", &stat))
-    return 0u;
-  // The stat file is a single line split into space-separated fields as "pid
-  // (comm) state ppid ...". However because the command name can contain any
-  // characters (including parentheses and spaces), we need to skip past it
-  // before parsing the rest of the fields. To do that, we look for the last
-  // instance of ") " (parentheses followed by space) and parse forward from
-  // that point.
-  size_t comm_end = stat.rfind(") ");
-  if (comm_end == std::string::npos)
-    return 0u;
-  stat = stat.substr(comm_end + strlen(") "));
-  base::StringSplitter splitter(stat, ' ');
-  for (size_t skip = 0; skip < 20; skip++) {
-    if (!splitter.Next())
-      return 0u;
-  }
-  return base::CStringToUInt64(splitter.cur_token()).value_or(0u);
-#else
-  return 0;
-#endif  // !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+double RandomImpl::GetValue() {
+  return dist_(prng_);
 }
 
-}  // namespace
-
-// static
-TrackRegistry* TrackRegistry::instance_;
-
-TrackRegistry::TrackRegistry() = default;
-TrackRegistry::~TrackRegistry() = default;
-
-// static
-void TrackRegistry::InitializeInstance() {
-  if (instance_)
-    return;
-  instance_ = new TrackRegistry();
+}  // namespace perfetto::tracing_service
+// gen_amalgamated begin source: src/tracing/service/trace_buffer_v1.cc
+// gen_amalgamated begin header: src/tracing/service/trace_buffer_v1.h
+// gen_amalgamated begin header: include/perfetto/ext/tracing/core/client_identity.h
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-  // Use the process start time + pid as the unique identifier for this process.
-  // This ensures that if there are two independent copies of the Perfetto SDK
-  // in the same process (e.g., one in the app and another in a system
-  // framework), events emitted by each will be consistently interleaved on
-  // common thread and process tracks.
-  if (uint64_t start_time = GetProcessStartTime()) {
-    base::Hasher hash;
-    hash.Update(start_time);
-    hash.Update(Platform::GetCurrentProcessId());
-    Track::process_uuid = hash.digest();
-  } else {
-    // Fall back to a randomly generated identifier.
-    Track::process_uuid = static_cast<uint64_t>(base::Uuidv4().lsb());
-  }
-}
+#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_CLIENT_IDENTITY_H_
+#define INCLUDE_PERFETTO_EXT_TRACING_CORE_CLIENT_IDENTITY_H_
 
-void TrackRegistry::ResetForTesting() {
-  instance_->tracks_.clear();
-}
+// gen_amalgamated expanded: #include "perfetto/ext/base/sys_types.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
 
-void TrackRegistry::UpdateTrack(Track track,
-                                const std::string& serialized_desc) {
-  std::lock_guard<std::mutex> lock(mutex_);
-  tracks_[track.uuid] = std::move(serialized_desc);
-}
+namespace perfetto {
 
-void TrackRegistry::UpdateTrackImpl(
-    Track track,
-    std::function<void(protos::pbzero::TrackDescriptor*)> fill_function) {
-  constexpr size_t kInitialSliceSize = 32;
-  constexpr size_t kMaximumSliceSize = 4096;
-  protozero::HeapBuffered<protos::pbzero::TrackDescriptor> new_descriptor(
-      kInitialSliceSize, kMaximumSliceSize);
-  fill_function(new_descriptor.get());
-  auto serialized_desc = new_descriptor.SerializeAsString();
-  UpdateTrack(track, serialized_desc);
-}
+// This class groups data fields of a connected client that can get passed in
+// the tracing core to be emitted to trace packets.
+class ClientIdentity {
+ public:
+  ClientIdentity() = default;
+  ClientIdentity(uid_t uid, pid_t pid, MachineID machine_id = kDefaultMachineID)
+      : uid_(uid), pid_(pid), machine_id_(machine_id) {}
 
-void TrackRegistry::EraseTrack(Track track) {
-  std::lock_guard<std::mutex> lock(mutex_);
-  tracks_.erase(track.uuid);
-}
+  bool has_uid() const { return uid_ != base::kInvalidUid; }
+  uid_t uid() const { return uid_; }
 
-// static
-void TrackRegistry::WriteTrackDescriptor(
-    const SerializedTrackDescriptor& desc,
-    protozero::MessageHandle<protos::pbzero::TracePacket> packet) {
-  packet->AppendString(
-      perfetto::protos::pbzero::TracePacket::kTrackDescriptorFieldNumber, desc);
-}
+  bool has_pid() const { return pid_ != base::kInvalidPid; }
+  pid_t pid() const { return pid_; }
 
-}  // namespace internal
+  bool has_non_default_machine_id() const {
+    return machine_id_ != kDefaultMachineID;
+  }
+  base::MachineID machine_id() const { return machine_id_; }
+
+ private:
+  uid_t uid_ = base::kInvalidUid;
+  pid_t pid_ = base::kInvalidPid;
+  MachineID machine_id_ = kDefaultMachineID;
+};
 }  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/track_event_category_registry.cc
+
+#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_CLIENT_IDENTITY_H_
+// gen_amalgamated begin header: src/tracing/service/histogram.h
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2023 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -50182,58 +56755,86 @@ void TrackRegistry::WriteTrackDescriptor(
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/tracing/track_event_category_registry.h"
+#ifndef SRC_TRACING_SERVICE_HISTOGRAM_H_
+#define SRC_TRACING_SERVICE_HISTOGRAM_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <limits>
+
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
 
 namespace perfetto {
 
-// static
-Category Category::FromDynamicCategory(const char* name) {
-  if (GetNthNameSize(1, name, name)) {
-    Category group(Group(name));
-    PERFETTO_DCHECK(group.name);
-    return group;
+using HistValue = int64_t;
+
+// Usage:
+// Histogram<10, 100, 1000> h;  // A histogram with 3 + 1 (overflow) bucket.
+// h.Add(value);
+// h.GetBucketSum(0);  // Returns SUM(x) for 0 < x <= 10
+// h.GetBucketSum(1);  // Returns SUM(x) for 10 < x <= 100
+// h.GetBucketSum(2);  // Returns SUM(x) for 100 < x <= 1000
+// h.GetBucketSum(3);  // Returns SUM(x) for x > 1000
+// Likewise h.GetBucketCount(x) returns the COUNT(x).
+template <HistValue... thresholds>
+class Histogram {
+ public:
+  // 1+ is for the overflow bucket (anything > the last threshold).
+  static constexpr size_t kNumBuckets = 1 + sizeof...(thresholds);
+
+  void Add(HistValue value) {
+    size_t bucket = BucketForValue(value);
+    bucket_sum_[bucket] += value;
+    ++bucket_count_[bucket];
   }
-  Category category(name);
-  PERFETTO_DCHECK(category.name);
-  return category;
-}
 
-Category Category::FromDynamicCategory(
-    const DynamicCategory& dynamic_category) {
-  return FromDynamicCategory(dynamic_category.name.c_str());
-}
+  static constexpr size_t num_buckets() { return kNumBuckets; }
 
-namespace internal {
+  HistValue GetBucketThres(size_t n) const {
+    PERFETTO_DCHECK(n < kNumBuckets);
+    return bucket_thres_[n];
+  }
 
-perfetto::DynamicCategory NullCategory(const perfetto::DynamicCategory&) {
-  return perfetto::DynamicCategory{};
-}
+  uint64_t GetBucketCount(size_t n) const {
+    PERFETTO_DCHECK(n < kNumBuckets);
+    return bucket_count_[n];
+  }
 
-void TrackEventCategoryRegistry::EnableCategoryForInstance(
-    size_t category_index,
-    uint32_t instance_index) const {
-  PERFETTO_DCHECK(instance_index < kMaxDataSourceInstances);
-  PERFETTO_DCHECK(category_index < category_count_);
-  // Matches the acquire_load in DataSource::Trace().
-  state_storage_[category_index].fetch_or(
-      static_cast<uint8_t>(1u << instance_index), std::memory_order_release);
-}
+  HistValue GetBucketSum(size_t n) const {
+    PERFETTO_DCHECK(n < kNumBuckets);
+    return bucket_sum_[n];
+  }
 
-void TrackEventCategoryRegistry::DisableCategoryForInstance(
-    size_t category_index,
-    uint32_t instance_index) const {
-  PERFETTO_DCHECK(instance_index < kMaxDataSourceInstances);
-  PERFETTO_DCHECK(category_index < category_count_);
-  // Matches the acquire_load in DataSource::Trace().
-  state_storage_[category_index].fetch_and(
-      static_cast<uint8_t>(~(1u << instance_index)), std::memory_order_release);
-}
+  void Merge(const Histogram& other) {
+    for (size_t i = 0; i < kNumBuckets; ++i) {
+      bucket_sum_[i] += other.bucket_sum_[i];
+      bucket_count_[i] += other.bucket_count_[i];
+    }
+  }
+
+ private:
+  static size_t BucketForValue(HistValue value) {
+    for (size_t i = 0; i < kNumBuckets - 1; i++) {
+      if (value <= bucket_thres_[i])
+        return i;
+    }
+    return kNumBuckets - 1;
+  }
+
+  static constexpr HistValue bucket_thres_[kNumBuckets]{
+      thresholds..., std::numeric_limits<HistValue>::max()};
+
+  HistValue bucket_sum_[kNumBuckets]{};
+  uint64_t bucket_count_[kNumBuckets]{};
+};
 
-}  // namespace internal
 }  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/track_event_legacy.cc
+
+#endif  // SRC_TRACING_SERVICE_HISTOGRAM_H_
+// gen_amalgamated begin header: src/tracing/service/trace_buffer.h
 /*
- * Copyright (C) 2020 The Android Open Source Project
+ * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -50248,69 +56849,144 @@ void TrackEventCategoryRegistry::DisableCategoryForInstance(
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/tracing/track_event_legacy.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/hash.h"
+#ifndef SRC_TRACING_SERVICE_TRACE_BUFFER_H_
+#define SRC_TRACING_SERVICE_TRACE_BUFFER_H_
 
-// gen_amalgamated expanded: #include "perfetto/tracing/track.h"
+#include <stdint.h>
+#include <array>
+#include <memory>
+
+// gen_amalgamated expanded: #include "perfetto/ext/base/flat_hash_map.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/client_identity.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_stats.h"
+// gen_amalgamated expanded: #include "src/tracing/service/histogram.h"
 
 namespace perfetto {
-namespace legacy {
 
-template <>
-ThreadTrack ConvertThreadId(const PerfettoLegacyCurrentThreadId&) {
-  // Because of the short-circuit in PERFETTO_INTERNAL_LEGACY_EVENT, we should
-  // never get here.
-  PERFETTO_DCHECK(false);
-  return ThreadTrack::Current();
-}
+class TracePacket;
+class TraceBuffer_WriterStats;
 
-}  // namespace legacy
+// Virtual interface for trace buffers to enable multiple implementations.
+// This interface defines the minimal surface used by the tracing service.
+class TraceBuffer {
+ public:
+  using WriterStats = TraceBuffer_WriterStats;
 
-namespace internal {
+  // See comment in the header above.
+  enum OverwritePolicy { kOverwrite, kDiscard };
 
-void LegacyTraceId::Write(protos::pbzero::TrackEvent::LegacyEvent* event,
-                          uint32_t event_flags) const {
-  // Legacy flow events always use bind_id.
-  if (event_flags &
-      (legacy::kTraceEventFlagFlowOut | legacy::kTraceEventFlagFlowIn)) {
-    // Flow bind_ids don't have scopes, so we need to mangle in-process ones to
-    // avoid collisions.
-    if (id_flags_ & legacy::kTraceEventFlagHasLocalId) {
-      event->set_bind_id(raw_id_ ^ ProcessTrack::Current().uuid);
-    } else {
-      event->set_bind_id(raw_id_);
-    }
-    return;
-  }
+  // Type of trace buffer implementation.
+  // TODO(primiano): remove this once TraceBufferV2 proves itself.
+  // kV2 is experimental and kV1WithV2Shadow is a testing-only class that
+  // is used to gather confidence that the two return the same results.
+  enum BufType {
+    kV1,
+    kV2,
+    kV1WithV2Shadow,
+  };
 
-  uint32_t scope_flags = id_flags_ & (legacy::kTraceEventFlagHasId |
-                                      legacy::kTraceEventFlagHasLocalId |
-                                      legacy::kTraceEventFlagHasGlobalId);
-  uint64_t id = raw_id_;
-  if (scope_ && scope_flags != legacy::kTraceEventFlagHasGlobalId) {
-    id = base::Hasher::Combine(id, scope_);
-  }
+  // Argument for out-of-band patches applied through TryPatchChunkContents().
+  struct Patch {
+    // From SharedMemoryABI::kPacketHeaderSize.
+    static constexpr size_t kSize = 4;
 
-  switch (scope_flags) {
-    case legacy::kTraceEventFlagHasId:
-      event->set_unscoped_id(id);
-      break;
-    case legacy::kTraceEventFlagHasLocalId:
-      event->set_local_id(id);
-      break;
-    case legacy::kTraceEventFlagHasGlobalId:
-      event->set_global_id(id);
-      break;
+    size_t offset_untrusted;
+    std::array<uint8_t, kSize> data;
+  };
+
+  // Identifiers that are constant for a packet sequence.
+  struct PacketSequenceProperties {
+    ProducerID producer_id_trusted;
+    ClientIdentity client_identity_trusted;
+    WriterID writer_id;
+
+    uid_t producer_uid_trusted() const { return client_identity_trusted.uid(); }
+    pid_t producer_pid_trusted() const { return client_identity_trusted.pid(); }
+  };
+
+  virtual ~TraceBuffer();
+
+  // Copies a Chunk from a producer Shared Memory Buffer into the trace buffer.
+  virtual void CopyChunkUntrusted(ProducerID producer_id_trusted,
+                                  const ClientIdentity& client_identity_trusted,
+                                  WriterID writer_id,
+                                  ChunkID chunk_id,
+                                  uint16_t num_fragments,
+                                  uint8_t chunk_flags,
+                                  bool chunk_complete,
+                                  const uint8_t* src,
+                                  size_t size) = 0;
+
+  // Applies a batch of |patches| to the given chunk, if the given chunk is
+  // still in the buffer. Does nothing if the given ChunkID is gone.
+  // Returns true if the chunk has been found and patched, false otherwise.
+  virtual bool TryPatchChunkContents(ProducerID,
+                                     WriterID,
+                                     ChunkID,
+                                     const Patch* patches,
+                                     size_t patches_size,
+                                     bool other_patches_pending) = 0;
+
+  // To read the contents of the buffer the caller needs to:
+  //   BeginRead()
+  //   while (ReadNextTracePacket(packet_fragments)) { ... }
+  // No other calls to any other method should be interleaved between
+  // BeginRead() and ReadNextTracePacket().
+  // Reads in the TraceBuffer are NOT idempotent.
+  virtual void BeginRead() = 0;
+
+  // Returns the next packet in the buffer, if any, and the producer_id,
+  // producer_uid, and writer_id of the producer/writer that wrote it.
+  // Returns false if no packets can be read at this point.
+  virtual bool ReadNextTracePacket(
+      TracePacket*,
+      PacketSequenceProperties* sequence_properties,
+      bool* previous_packet_on_sequence_dropped) = 0;
+
+  // Creates a read-only clone of the trace buffer. The read iterators of the
+  // new buffer will be reset, as if no Read() had been called.
+  virtual std::unique_ptr<TraceBuffer> CloneReadOnly() const = 0;
+
+  virtual void set_read_only() = 0;
+  virtual const TraceStats::BufferStats& stats() const = 0;
+  virtual const WriterStats& writer_stats() const = 0;
+  virtual size_t size() const = 0;
+  virtual size_t used_size() const = 0;
+  virtual size_t GetMemoryUsageBytes() const = 0;
+  virtual OverwritePolicy overwrite_policy() const = 0;
+  virtual bool has_data() const = 0;
+  virtual BufType buf_type() const = 0;
+
+  // Exposed for test/fake_packet.{cc,h}.
+  static inline constexpr size_t InlineChunkHeaderSize = 16;
+};
+
+class TraceBuffer_WriterStats {
+ public:
+  using WriterBuckets =
+      Histogram<8, 32, 128, 512, 1024, 2048, 4096, 8192, 12288, 16384>;
+  using WriterStatsMap = base::FlatHashMap<ProducerAndWriterID,
+                                           WriterBuckets,
+                                           std::hash<ProducerAndWriterID>,
+                                           base::QuadraticProbe,
+                                           /*AppendOnly=*/true>;
+
+  void Insert(ProducerAndWriterID key, HistValue val) {
+    map_.Insert(key, {}).first->Add(val);
   }
-  if (scope_)
-    event->set_id_scope(scope_);
-}
 
-}  // namespace internal
+  WriterStatsMap::Iterator GetIterator() const { return map_.GetIterator(); }
+
+ private:
+  WriterStatsMap map_;
+};
+
 }  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/track_event_state_tracker.cc
+
+#endif  // SRC_TRACING_SERVICE_TRACE_BUFFER_H_
 /*
- * Copyright (C) 2020 The Android Open Source Project
+ * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -50325,678 +57001,708 @@ void LegacyTraceId::Write(protos::pbzero::TrackEvent::LegacyEvent* event,
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/tracing/track_event_state_tracker.h"
-
-// gen_amalgamated expanded: #include "perfetto/ext/base/hash.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/track_event_internal.h"
+#ifndef SRC_TRACING_SERVICE_TRACE_BUFFER_V1_H_
+#define SRC_TRACING_SERVICE_TRACE_BUFFER_V1_H_
 
-// gen_amalgamated expanded: #include "protos/perfetto/common/interceptor_descriptor.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/clock_snapshot.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/interned_data/interned_data.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet_defaults.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/debug_annotation.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/process_descriptor.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/thread_descriptor.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_descriptor.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_event.pbzero.h"
+#include <stdint.h>
+#include <string.h>
 
-namespace perfetto {
+#include <array>
+#include <limits>
+#include <map>
+#include <tuple>
 
-using internal::TrackEventIncrementalState;
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/paged_memory.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/thread_annotations.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/client_identity.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/slice.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_stats.h"
+// gen_amalgamated expanded: #include "src/tracing/service/histogram.h"
+// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer.h"
 
-TrackEventStateTracker::~TrackEventStateTracker() = default;
-TrackEventStateTracker::Delegate::~Delegate() = default;
+namespace perfetto {
 
-// static
-void TrackEventStateTracker::ProcessTracePacket(
-    Delegate& delegate,
-    SequenceState& sequence_state,
-    const protos::pbzero::TracePacket_Decoder& packet) {
-  UpdateIncrementalState(delegate, sequence_state, packet);
+class TracePacket;
 
-  if (!packet.has_track_event())
-    return;
-  perfetto::protos::pbzero::TrackEvent::Decoder track_event(
-      packet.track_event());
+// The main buffer, owned by the tracing service, where all the trace data is
+// ultimately stored into. The service will own several instances of this class,
+// at least one per active consumer (as defined in the |buffers| section of
+// trace_config.proto) and will copy chunks from the producer's shared memory
+// buffers into here when a CommitData IPC is received.
+//
+// Writing into the buffer
+// -----------------------
+// Data is copied from the SMB(s) using CopyChunkUntrusted(). The buffer will
+// hence contain data coming from different producers and different writer
+// sequences, more specifically:
+// - The service receives data by several producer(s), identified by their ID.
+// - Each producer writes several sequences identified by the same WriterID.
+//   (they correspond to TraceWriter instances in the producer).
+// - Each Writer writes, in order, several chunks.
+// - Each chunk contains zero, one, or more TracePacket(s), or even just
+//   fragments of packets (when they span across several chunks).
+//
+// So at any point in time, the buffer will contain a variable number of logical
+// sequences identified by the {ProducerID, WriterID} tuple. Any given chunk
+// will only contain packets (or fragments) belonging to the same sequence.
+//
+// The buffer operates by default as a ring buffer.
+// It has two overwrite policies:
+//  1. kOverwrite (default): if the write pointer reaches the read pointer, old
+//     unread chunks will be overwritten by new chunks.
+//  2. kDiscard: if the write pointer reaches the read pointer, unread chunks
+//     are preserved and the new chunks are discarded. Any future write becomes
+//     a no-op, even if the reader manages to fully catch up. This is because
+//     once a chunk is discarded, the sequence of packets is broken and trying
+//     to recover would be too hard (also due to the fact that, at the same
+//     time, we allow out-of-order commits and chunk re-writes).
+//
+// Chunks are (over)written in the same order of the CopyChunkUntrusted() calls.
+// When overwriting old content, entire chunks are overwritten or clobbered.
+// The buffer never leaves a partial chunk around. Chunks' payload is copied
+// as-is, but their header is not and is repacked in order to keep the
+// ProducerID around.
+//
+// Chunks are stored in the buffer next to each other. Each chunk is prefixed by
+// an inline header (ChunkRecord), which contains most of the fields of the
+// SharedMemoryABI ChunkHeader + the ProducerID + the size of the payload.
+// It's a conventional binary object stream essentially, where each ChunkRecord
+// tells where it ends and hence where to find the next one, like this:
+//
+//          .-------------------------. 16 byte boundary
+//          | ChunkRecord:   16 bytes |
+//          | - chunk id:     4 bytes |
+//          | - producer id:  2 bytes |
+//          | - writer id:    2 bytes |
+//          | - #fragments:   2 bytes |
+//    +-----+ - record size:  2 bytes |
+//    |     | - flags+pad:    4 bytes |
+//    |     +-------------------------+
+//    |     |                         |
+//    |     :     Chunk payload       :
+//    |     |                         |
+//    |     +-------------------------+
+//    |     |    Optional padding     |
+//    +---> +-------------------------+ 16 byte boundary
+//          |      ChunkRecord        |
+//          :                         :
+// Chunks stored in the buffer are always rounded up to 16 bytes (that is
+// sizeof(ChunkRecord)), in order to avoid further inner fragmentation.
+// Special "padding" chunks can be put in the buffer, e.g. in the case when we
+// try to write a chunk of size N while the write pointer is at the end of the
+// buffer, but the write pointer is < N bytes from the end (and hence needs to
+// wrap over).
+// Because of this, the buffer is self-describing: the contents of the buffer
+// can be reconstructed by just looking at the buffer content (this will be
+// quite useful in future to recover the buffer from crash reports).
+//
+// However, in order to keep some operations (patching and reading) fast, a
+// lookaside index is maintained (in |index_|), keeping each chunk in the buffer
+// indexed by their {ProducerID, WriterID, ChunkID} tuple.
+//
+// Patching data out-of-band
+// -------------------------
+// This buffer also supports patching chunks' payload out-of-band, after they
+// have been stored. This is to allow producers to backfill the "size" fields
+// of the protos that spawn across several chunks, when the previous chunks are
+// returned to the service. The MaybePatchChunkContents() deals with the fact
+// that a chunk might have been lost (because of wrapping) by the time the OOB
+// IPC comes.
+//
+// Reading from the buffer
+// -----------------------
+// This class supports one reader only (the consumer). Reads are NOT idempotent
+// as they move the read cursors around. Reading back the buffer is the most
+// conceptually complex part. The ReadNextTracePacket() method operates with
+// whole packet granularity. Packets are returned only when all their fragments
+// are available.
+// This class takes care of:
+// - Gluing packets within the same sequence, even if they are not stored
+//   adjacently in the buffer.
+// - Re-ordering chunks within a sequence (using the ChunkID, which wraps).
+// - Detecting holes in packet fragments (because of loss of chunks).
+// Reads guarantee that packets for the same sequence are read in FIFO order
+// (according to their ChunkID), but don't give any guarantee about the read
+// order of packets from different sequences, see comments in
+// ReadNextTracePacket() below.
+class TraceBufferV1 : public TraceBuffer {
+ public:
+  // Import types from the interface to avoid conflicts
+  using OverwritePolicy = TraceBuffer::OverwritePolicy;
+  using Patch = TraceBuffer::Patch;
+  using PacketSequenceProperties = TraceBuffer::PacketSequenceProperties;
 
-  auto clock_id = packet.timestamp_clock_id();
-  if (!packet.has_timestamp_clock_id())
-    clock_id = sequence_state.default_clock_id;
-  uint64_t timestamp = packet.timestamp();
-  // TODO(mohitms): Incorporate unit multiplier as well.
-  if (clock_id == internal::TrackEventIncrementalState::kClockIdIncremental) {
-    timestamp += sequence_state.most_recent_absolute_time_ns;
-    sequence_state.most_recent_absolute_time_ns = timestamp;
-  }
+  // Can return nullptr if the memory allocation fails.
+  static std::unique_ptr<TraceBufferV1> Create(size_t size_in_bytes,
+                                               OverwritePolicy = kOverwrite);
 
-  Track* track = &sequence_state.track;
-  if (track_event.has_track_uuid()) {
-    auto* session_state = delegate.GetSessionState();
-    if (!session_state)
-      return;  // Tracing must have ended.
-    track = &session_state->tracks[track_event.track_uuid()];
-  }
+  ~TraceBufferV1() override;
 
-  // We only log the first category of each event.
-  protozero::ConstChars category{};
-  uint64_t category_iid = 0;
-  if (auto iid_it = track_event.category_iids()) {
-    category_iid = *iid_it;
-    category.data = sequence_state.event_categories[category_iid].data();
-    category.size = sequence_state.event_categories[category_iid].size();
-  } else if (auto cat_it = track_event.categories()) {
-    category.data = reinterpret_cast<const char*>(cat_it->data());
-    category.size = cat_it->size();
-  }
+  // Copies a Chunk from a producer Shared Memory Buffer into the trace buffer.
+  // |src| points to the first packet in the SharedMemoryABI's chunk shared with
+  // an untrusted producer. "untrusted" here means: the producer might be
+  // malicious and might change |src| concurrently while we read it (internally
+  // this method memcpy()-s first the chunk before processing it). None of the
+  // arguments should be trusted, unless otherwise stated. We can trust that
+  // |src| points to a valid memory area, but not its contents.
+  //
+  // This method may be called multiple times for the same chunk. In this case,
+  // the original chunk's payload will be overridden and its number of fragments
+  // and flags adjusted to match |num_fragments| and |chunk_flags|. The service
+  // may use this to insert partial chunks (|chunk_complete = false|) before the
+  // producer has committed them.
+  //
+  // If |chunk_complete| is |false|, the TraceBufferV1 will only consider the
+  // first |num_fragments - 1| packets to be complete, since the producer may
+  // not have finished writing the latest packet. Reading from a sequence will
+  // also not progress past any incomplete chunks until they were rewritten with
+  // |chunk_complete = true|, e.g. after a producer's commit.
+  //
+  // TODO(eseckler): Pass in a PacketStreamProperties instead of individual IDs.
+  void CopyChunkUntrusted(ProducerID producer_id_trusted,
+                          const ClientIdentity& client_identity_trusted,
+                          WriterID writer_id,
+                          ChunkID chunk_id,
+                          uint16_t num_fragments,
+                          uint8_t chunk_flags,
+                          bool chunk_complete,
+                          const uint8_t* src,
+                          size_t size) override;
 
-  protozero::ConstChars name{};
-  uint64_t name_iid = track_event.name_iid();
-  uint64_t name_hash = 0;
-  uint64_t duration = 0;
-  if (name_iid) {
-    name.data = sequence_state.event_names[name_iid].data();
-    name.size = sequence_state.event_names[name_iid].size();
-  } else if (track_event.has_name()) {
-    name.data = track_event.name().data;
-    name.size = track_event.name().size;
-  }
+  // Applies a batch of |patches| to the given chunk, if the given chunk is
+  // still in the buffer. Does nothing if the given ChunkID is gone.
+  // Returns true if the chunk has been found and patched, false otherwise.
+  // |other_patches_pending| is used to determine whether this is the only
+  // batch of patches for the chunk or there is more.
+  // If |other_patches_pending| == false, the chunk is marked as ready to be
+  // consumed. If true, the state of the chunk is not altered.
+  //
+  // Note: If the producer is batching commits (see shared_memory_arbiter.h), it
+  // will also attempt to do patching locally. Namely, if nested messages are
+  // completed while the chunk on which they started is being batched (i.e.
+  // before it has been committed to the service), the producer will apply the
+  // respective patches to the batched chunk. These patches will not be sent to
+  // the service - i.e. only the patches that the producer did not manage to
+  // apply before committing the chunk will be applied here.
+  bool TryPatchChunkContents(ProducerID,
+                             WriterID,
+                             ChunkID,
+                             const Patch* patches,
+                             size_t patches_size,
+                             bool other_patches_pending) override;
 
-  if (name.data) {
-    base::Hasher hash;
-    hash.Update(name.data, name.size);
-    name_hash = hash.digest();
-  }
+  // To read the contents of the buffer the caller needs to:
+  //   BeginRead()
+  //   while (ReadNextTracePacket(packet_fragments)) { ... }
+  // No other calls to any other method should be interleaved between
+  // BeginRead() and ReadNextTracePacket().
+  // Reads in the TraceBuffer are NOT idempotent.
+  void BeginRead() override;
 
-  size_t depth = track->stack.size();
-  switch (track_event.type()) {
-    case protos::pbzero::TrackEvent::TYPE_SLICE_BEGIN: {
-      StackFrame frame;
-      frame.timestamp = timestamp;
-      frame.name_hash = name_hash;
-      if (track_event.has_track_uuid()) {
-        frame.name = name.ToStdString();
-        frame.category = category.ToStdString();
-      } else {
-        frame.name_iid = name_iid;
-        frame.category_iid = category_iid;
-      }
-      track->stack.push_back(std::move(frame));
-      break;
-    }
-    case protos::pbzero::TrackEvent::TYPE_SLICE_END:
-      if (!track->stack.empty()) {
-        const auto& prev_frame = track->stack.back();
-        if (prev_frame.name_iid) {
-          name.data = sequence_state.event_names[prev_frame.name_iid].data();
-          name.size = sequence_state.event_names[prev_frame.name_iid].size();
-        } else {
-          name.data = prev_frame.name.data();
-          name.size = prev_frame.name.size();
-        }
-        name_hash = prev_frame.name_hash;
-        if (prev_frame.category_iid) {
-          category.data =
-              sequence_state.event_categories[prev_frame.category_iid].data();
-          category.size =
-              sequence_state.event_categories[prev_frame.category_iid].size();
-        } else {
-          category.data = prev_frame.category.data();
-          category.size = prev_frame.category.size();
-        }
-        duration = timestamp - prev_frame.timestamp;
-        depth--;
-      }
-      break;
-    case protos::pbzero::TrackEvent::TYPE_INSTANT:
-      break;
-    case protos::pbzero::TrackEvent::TYPE_COUNTER:
-    case protos::pbzero::TrackEvent::TYPE_UNSPECIFIED:
-      // TODO(skyostil): Support counters.
-      return;
-  }
+  // Returns the next packet in the buffer, if any, and the producer_id,
+  // producer_uid, and writer_id of the producer/writer that wrote it (as passed
+  // in the CopyChunkUntrusted() call). Returns false if no packets can be read
+  // at this point. If a packet was read successfully,
+  // |previous_packet_on_sequence_dropped| is set to |true| if the previous
+  // packet on the sequence was dropped from the buffer before it could be read
+  // (e.g. because its chunk was overridden due to the ring buffer wrapping or
+  // due to an ABI violation), and to |false| otherwise.
+  //
+  // This function returns only complete packets. Specifically:
+  // When there is at least one complete packet in the buffer, this function
+  // returns true and populates the TracePacket argument with the boundaries of
+  // each fragment for one packet.
+  // TracePacket will have at least one slice when this function returns true.
+  // When there are no whole packets eligible to read (e.g. we are still missing
+  // fragments) this function returns false.
+  // This function guarantees also that packets for a given
+  // {ProducerID, WriterID} are read in FIFO order.
+  // This function does not guarantee any ordering w.r.t. packets belonging to
+  // different WriterID(s). For instance, given the following packets copied
+  // into the buffer:
+  //   {ProducerID: 1, WriterID: 1}: P1 P2 P3
+  //   {ProducerID: 1, WriterID: 2}: P4 P5 P6
+  //   {ProducerID: 2, WriterID: 1}: P7 P8 P9
+  // The following read sequence is possible:
+  //   P1, P4, P7, P2, P3, P5, P8, P9, P6
+  // But the following is guaranteed to NOT happen:
+  //   P1, P5, P7, P4 (P4 cannot come after P5)
+  bool ReadNextTracePacket(TracePacket*,
+                           PacketSequenceProperties* sequence_properties,
+                           bool* previous_packet_on_sequence_dropped) override;
 
-  ParsedTrackEvent parsed_event{track_event};
-  parsed_event.timestamp_ns = timestamp;
-  parsed_event.duration_ns = duration;
-  parsed_event.stack_depth = depth;
-  parsed_event.category = category;
-  parsed_event.name = name;
-  parsed_event.name_hash = name_hash;
-  delegate.OnTrackEvent(*track, parsed_event);
+  // Creates a read-only clone of the trace buffer. Calls to
+  // CopyChunkUntrusted() and TryPatchChunkContents() on the returned cloned
+  // TraceBuffer will CHECK().
+  std::unique_ptr<TraceBuffer> CloneReadOnly() const override;
 
-  if (track_event.type() == protos::pbzero::TrackEvent::TYPE_SLICE_END &&
-      !track->stack.empty()) {
-    track->stack.pop_back();
+  void set_read_only() override { read_only_ = true; }
+  const TraceStats::BufferStats& stats() const override { return stats_; }
+  const WriterStats& writer_stats() const override { return writer_stats_; }
+  size_t size() const override { return size_; }
+  size_t used_size() const override { return used_size_; }
+  size_t GetMemoryUsageBytes() const override { return size_; }
+  OverwritePolicy overwrite_policy() const override {
+    return overwrite_policy_;
   }
-}
+  bool has_data() const override { return has_data_; }
+  BufType buf_type() const override { return kV1; }
 
-// static
-void TrackEventStateTracker::UpdateIncrementalState(
-    Delegate& delegate,
-    SequenceState& sequence_state,
-    const protos::pbzero::TracePacket_Decoder& packet) {
-#if PERFETTO_DCHECK_IS_ON()
-  if (!sequence_state.sequence_id) {
-    sequence_state.sequence_id = packet.trusted_packet_sequence_id();
-  } else {
-    PERFETTO_DCHECK(sequence_state.sequence_id ==
-                    packet.trusted_packet_sequence_id());
-  }
-#endif
+ private:
+  friend class TraceBufferTest;
 
-  perfetto::protos::pbzero::ClockSnapshot::Decoder snapshot(
-      packet.clock_snapshot());
-  for (auto it = snapshot.clocks(); it; ++it) {
-    perfetto::protos::pbzero::ClockSnapshot::Clock::Decoder clock(*it);
-    // TODO(mohitms) : Handle the incremental clock other than default one.
-    if (clock.is_incremental() &&
-        clock.clock_id() ==
-            internal::TrackEventIncrementalState::kClockIdIncremental) {
-      sequence_state.most_recent_absolute_time_ns =
-          clock.timestamp() * clock.unit_multiplier_ns();
-      break;
+  // ChunkRecord is a Chunk header stored inline in the |data_| buffer, before
+  // the chunk payload (the packets' data). The |data_| buffer looks like this:
+  // +---------------+------------------++---------------+-----------------+
+  // | ChunkRecord 1 | Chunk payload 1  || ChunkRecord 2 | Chunk payload 2 | ...
+  // +---------------+------------------++---------------+-----------------+
+  // Most of the ChunkRecord fields are copied from SharedMemoryABI::ChunkHeader
+  // (the chunk header used in the shared memory buffers).
+  // A ChunkRecord can be a special "padding" record. In this case its payload
+  // should be ignored and the record should be just skipped.
+  //
+  // Full page move optimization:
+  // This struct has to be exactly (sizeof(PageHeader) + sizeof(ChunkHeader))
+  // (from shared_memory_abi.h) to allow full page move optimizations
+  // (TODO(primiano): not implemented yet). In the special case of moving a full
+  // 4k page that contains only one chunk, in fact, we can just ask the kernel
+  // to move the full SHM page (see SPLICE_F_{GIFT,MOVE}) and overlay the
+  // ChunkRecord on top of the moved SMB's header (page + chunk header).
+  // This special requirement is covered by static_assert(s) in the .cc file.
+  struct ChunkRecord {
+    explicit ChunkRecord(size_t sz) : flags{0}, is_padding{0} {
+      PERFETTO_DCHECK(sz >= sizeof(ChunkRecord) &&
+                      sz % sizeof(ChunkRecord) == 0 && sz <= kMaxSize);
+      size = static_cast<decltype(size)>(sz);
     }
-  }
 
-  if (packet.sequence_flags() &
-      perfetto::protos::pbzero::TracePacket::SEQ_INCREMENTAL_STATE_CLEARED) {
-    // Convert any existing event names and categories on the stack to
-    // non-interned strings so we can look up their names even after the
-    // incremental state is gone.
-    for (auto& frame : sequence_state.track.stack) {
-      if (frame.name_iid) {
-        frame.name = sequence_state.event_names[frame.name_iid];
-        frame.name_iid = 0u;
-      }
-      if (frame.category_iid) {
-        frame.category = sequence_state.event_categories[frame.category_iid];
-        frame.category_iid = 0u;
-      }
-    }
-    sequence_state.event_names.clear();
-    sequence_state.event_categories.clear();
-    sequence_state.debug_annotation_names.clear();
-    sequence_state.track.uuid = 0u;
-    sequence_state.track.index = 0u;
-  }
-  if (packet.has_interned_data()) {
-    perfetto::protos::pbzero::InternedData::Decoder interned_data(
-        packet.interned_data());
-    for (auto it = interned_data.event_names(); it; it++) {
-      perfetto::protos::pbzero::EventName::Decoder entry(*it);
-      sequence_state.event_names[entry.iid()] = entry.name().ToStdString();
-    }
-    for (auto it = interned_data.event_categories(); it; it++) {
-      perfetto::protos::pbzero::EventCategory::Decoder entry(*it);
-      sequence_state.event_categories[entry.iid()] = entry.name().ToStdString();
-    }
-    for (auto it = interned_data.debug_annotation_names(); it; it++) {
-      perfetto::protos::pbzero::DebugAnnotationName::Decoder entry(*it);
-      sequence_state.debug_annotation_names[entry.iid()] =
-          entry.name().ToStdString();
-    }
-  }
-  if (packet.has_trace_packet_defaults()) {
-    perfetto::protos::pbzero::TracePacketDefaults::Decoder defaults(
-        packet.trace_packet_defaults());
-    if (defaults.has_track_event_defaults()) {
-      perfetto::protos::pbzero::TrackEventDefaults::Decoder
-          track_event_defaults(defaults.track_event_defaults());
-      sequence_state.track.uuid = track_event_defaults.track_uuid();
-      if (defaults.has_timestamp_clock_id())
-        sequence_state.default_clock_id = defaults.timestamp_clock_id();
-    }
-  }
-  if (packet.has_track_descriptor()) {
-    perfetto::protos::pbzero::TrackDescriptor::Decoder track_descriptor(
-        packet.track_descriptor());
-    auto* session_state = delegate.GetSessionState();
-    auto& track = session_state->tracks[track_descriptor.uuid()];
-    if (!track.index)
-      track.index = static_cast<uint32_t>(session_state->tracks.size() + 1);
-    track.uuid = track_descriptor.uuid();
+    bool is_valid() const { return size != 0; }
 
-    track.name = track_descriptor.name().ToStdString();
-    track.pid = 0;
-    track.tid = 0;
-    if (track_descriptor.has_process()) {
-      perfetto::protos::pbzero::ProcessDescriptor::Decoder process(
-          track_descriptor.process());
-      track.pid = process.pid();
-      if (track.name.empty())
-        track.name = process.process_name().ToStdString();
-    } else if (track_descriptor.has_thread()) {
-      perfetto::protos::pbzero::ThreadDescriptor::Decoder thread(
-          track_descriptor.thread());
-      track.pid = thread.pid();
-      track.tid = thread.tid();
-      if (track.name.empty())
-        track.name = thread.thread_name().ToStdString();
-    }
-    delegate.OnTrackUpdated(track);
+    // Keep this structure packed and exactly 16 bytes (128 bits) big.
 
-    // Mirror properties to the default track of the sequence. Note that
-    // this does not catch updates to the default track written through other
-    // sequences.
-    if (track.uuid == sequence_state.track.uuid) {
-      sequence_state.track.index = track.index;
-      sequence_state.track.name = track.name;
-      sequence_state.track.pid = track.pid;
-      sequence_state.track.tid = track.tid;
-      sequence_state.track.user_data = track.user_data;
-    }
-  }
-}
+    // [32 bits] Monotonic counter within the same writer_id.
+    ChunkID chunk_id = 0;
 
-TrackEventStateTracker::ParsedTrackEvent::ParsedTrackEvent(
-    const perfetto::protos::pbzero::TrackEvent::Decoder& track_event_)
-    : track_event(track_event_) {}
+    // [16 bits] ID of the Producer from which the Chunk was copied from.
+    ProducerID producer_id = 0;
 
-}  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/virtual_destructors.cc
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+    // [16 bits] Unique per Producer (but not within the service).
+    // If writer_id == kWriterIdPadding the record should just be skipped.
+    WriterID writer_id = 0;
 
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_tls.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/tracing.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/tracing_backend.h"
+    // Number of fragments contained in the chunk.
+    uint16_t num_fragments = 0;
 
-// This translation unit contains the definitions for the destructor of pure
-// virtual interfaces for the src/public:public target. The alternative would be
-// introducing a one-liner .cc file for each pure virtual interface, which is
-// overkill. This is for compliance with -Wweak-vtables.
+    // Size in bytes, including sizeof(ChunkRecord) itself.
+    uint16_t size;
 
-namespace perfetto {
-namespace internal {
+    uint8_t flags : 6;  // See SharedMemoryABI::ChunkHeader::flags.
+    static constexpr size_t kFlagsBitMask = (1 << 6) - 1;
 
-TracingTLS::~TracingTLS() {
-  // Avoid entering trace points while the thread is being torn down.
-  // This is the problem: when a thread exits, the at-thread-exit destroys the
-  // TracingTLS. As part of that the various TraceWriter for the active data
-  // sources are destroyd. A TraceWriter dtor will issue a PostTask on the IPC
-  // thread to issue a final flush and unregister its ID with the service.
-  // The PostTask, in chromium, might have a trace event that will try to
-  // re-enter the tracing system.
-  // We fix this by resetting the TLS key to the TracingTLS object that is
-  // being destroyed in the platform impl (platform_posix.cc,
-  // platform_windows.cc, chromium's platform.cc). We carefully rely on the fact
-  // that all the tracing path that will be invoked during thread exit will
-  // early out if |is_in_trace_point| == true and will not depend on the other
-  // TLS state that has been destroyed.
-  is_in_trace_point = true;
-}
+    uint8_t is_padding : 1;
+    uint8_t unused_flag : 1;
 
-}  // namespace internal
+    // Not strictly needed, can be reused for more fields in the future. But
+    // right now helps to spot chunks in hex dumps.
+    char unused[3] = {'C', 'H', 'U'};
 
-TracingProducerBackend::~TracingProducerBackend() = default;
-TracingConsumerBackend::~TracingConsumerBackend() = default;
-TracingBackend::~TracingBackend() = default;
+    static constexpr size_t kMaxSize =
+        std::numeric_limits<decltype(size)>::max();
+  };
 
-}  // namespace perfetto
-// gen_amalgamated begin source: src/android_stats/statsd_logging_helper.cc
-// gen_amalgamated begin header: src/android_stats/statsd_logging_helper.h
-// gen_amalgamated begin header: src/android_stats/perfetto_atoms.h
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+  // Lookaside index entry. This serves two purposes:
+  // 1) Allow a fast lookup of ChunkRecord by their ID (the tuple
+  //   {ProducerID, WriterID, ChunkID}). This is used when applying out-of-band
+  //   patches to the contents of the chunks after they have been copied into
+  //   the TraceBuffer.
+  // 2) keep the chunks ordered by their ID. This is used when reading back.
+  // 3) Keep metadata about the status of the chunk, e.g. whether the contents
+  //    have been read already and should be skipped in a future read pass.
+  // This struct should not have any field that is essential for reconstructing
+  // the contents of the buffer from a crash dump.
+  struct ChunkMeta {
+    // Key used for sorting in the map.
+    struct Key {
+      Key(ProducerID p, WriterID w, ChunkID c)
+          : producer_id{p}, writer_id{w}, chunk_id{c} {}
 
-#ifndef SRC_ANDROID_STATS_PERFETTO_ATOMS_H_
-#define SRC_ANDROID_STATS_PERFETTO_ATOMS_H_
+      Key(const Key&) noexcept = default;
+      Key& operator=(const Key&) = default;
 
-namespace perfetto {
+      explicit Key(const ChunkRecord& cr)
+          : Key(cr.producer_id, cr.writer_id, cr.chunk_id) {}
 
-// This must match the values of the PerfettoUploadEvent enum in:
-// frameworks/proto_logging/stats/atoms.proto
-enum class PerfettoStatsdAtom {
-  kUndefined = 0,
+      // Note that this sorting doesn't keep into account the fact that ChunkID
+      // will wrap over at some point. The extra logic in SequenceIterator deals
+      // with that.
+      bool operator<(const Key& other) const {
+        return std::tie(producer_id, writer_id, chunk_id) <
+               std::tie(other.producer_id, other.writer_id, other.chunk_id);
+      }
 
-  // Checkpoints inside perfetto_cmd before tracing is finished.
-  kTraceBegin = 1,
-  kBackgroundTraceBegin = 2,
-  kOnConnect = 3,
+      bool operator==(const Key& other) const {
+        return std::tie(producer_id, writer_id, chunk_id) ==
+               std::tie(other.producer_id, other.writer_id, other.chunk_id);
+      }
 
-  // Guardrails inside perfetto_cmd before tracing is finished.
-  kOnTimeout = 16,
-  kCmdUserBuildTracingNotAllowed = 43,
-  kCmdFailedToInitGuardrailState = 44,
-  kCmdInvalidGuardrailState = 45,
-  kCmdHitUploadLimit = 46,
+      bool operator!=(const Key& other) const { return !(*this == other); }
 
-  // Checkpoints inside traced.
-  kTracedEnableTracing = 37,
-  kTracedStartTracing = 38,
-  kTracedDisableTracing = 39,
-  kTracedNotifyTracingDisabled = 40,
+      // These fields should match at all times the corresponding fields in
+      // the |chunk_record|. They are copied here purely for efficiency to avoid
+      // dereferencing the buffer all the time.
+      ProducerID producer_id;
+      WriterID writer_id;
+      ChunkID chunk_id;
+    };
 
-  // Trigger checkpoints inside traced.
-  // These atoms are special because, along with the UUID,
-  // they log the trigger name.
-  kTracedTriggerStartTracing = 41,
-  kTracedTriggerStopTracing = 42,
+    enum IndexFlags : uint8_t {
+      // If set, the chunk state was kChunkComplete at the time it was copied.
+      // If unset, the chunk was still kChunkBeingWritten while copied. When
+      // reading from the chunk's sequence, the sequence will not advance past
+      // this chunk until this flag is set.
+      kComplete = 1 << 0,
 
-  // Guardrails inside traced.
-  kTracedEnableTracingExistingTraceSession = 18,
-  kTracedEnableTracingTooLongTrace = 19,
-  kTracedEnableTracingInvalidTriggerTimeout = 20,
-  kTracedEnableTracingDurationWithTrigger = 21,
-  kTracedEnableTracingStopTracingWriteIntoFile = 22,
-  kTracedEnableTracingDuplicateTriggerName = 23,
-  kTracedEnableTracingInvalidDeferredStart = 24,
-  kTracedEnableTracingInvalidBufferSize = 25,
-  kTracedEnableTracingBufferSizeTooLarge = 26,
-  kTracedEnableTracingTooManyBuffers = 27,
-  kTracedEnableTracingDuplicateSessionName = 28,
-  kTracedEnableTracingSessionNameTooRecent = 29,
-  kTracedEnableTracingTooManySessionsForUid = 30,
-  kTracedEnableTracingTooManyConcurrentSessions = 31,
-  kTracedEnableTracingInvalidFdOutputFile = 32,
-  kTracedEnableTracingFailedToCreateFile = 33,
-  kTracedEnableTracingOom = 34,
-  kTracedEnableTracingUnknown = 35,
-  kTracedStartTracingInvalidSessionState = 36,
-  kTracedEnableTracingInvalidFilter = 47,
-  kTracedEnableTracingOobTargetBuffer = 48,
+      // If set, we skipped the last packet that we read from this chunk e.g.
+      // because we it was a continuation from a previous chunk that was dropped
+      // or due to an ABI violation.
+      kLastReadPacketSkipped = 1 << 1
+    };
 
-  // Checkpoints inside perfetto_cmd after tracing has finished.
-  kOnTracingDisabled = 4,
-  kFinalizeTraceAndExit = 11,
-  kCmdFwReportBegin = 49,
-  // Will be removed once incidentd is no longer used.
-  kUploadIncidentBegin = 8,
-  kNotUploadingEmptyTrace = 17,
+    ChunkMeta(uint32_t _record_off,
+              uint16_t _num_fragments,
+              bool complete,
+              uint8_t _flags,
+              const ClientIdentity& client_identity)
+        : record_off{_record_off},
+          client_identity_trusted(client_identity),
+          flags{_flags},
+          num_fragments{_num_fragments} {
+      if (complete)
+        index_flags = kComplete;
+    }
 
-  // Guardrails inside perfetto_cmd after tracing has finished.
-  kCmdFwReportEmptyTrace = 50,
-  // Will be removed once incidentd is no longer used.
-  kUploadIncidentFailure = 10,
+    ChunkMeta(const ChunkMeta&) noexcept = default;
 
-  // "Successful" terminal states inside perfetto_cmd.
-  kCmdFwReportHandoff = 51,
+    bool is_complete() const { return index_flags & kComplete; }
 
-  // Deprecated as "success" is misleading; it simply means we were
-  // able to communicate with incidentd. Will be removed once
-  // incidentd is no longer used.
-  kUploadIncidentSuccess = 9,
+    void set_complete(bool complete) {
+      if (complete) {
+        index_flags |= kComplete;
+      } else {
+        index_flags &= ~kComplete;
+      }
+    }
 
-  // Contained trigger begin/success/failure. Replaced by
-  // |PerfettoTriggerAtom| to allow aggregation using a count metric
-  // and reduce spam.
-  // reserved 12, 13, 14;
+    bool last_read_packet_skipped() const {
+      return index_flags & kLastReadPacketSkipped;
+    }
 
-  // Contained that a guardrail in perfetto_cmd was hit. Replaced with
-  // kCmd* guardrails.
-  // reserved 15;
+    void set_last_read_packet_skipped(bool skipped) {
+      if (skipped) {
+        index_flags |= kLastReadPacketSkipped;
+      } else {
+        index_flags &= ~kLastReadPacketSkipped;
+      }
+    }
 
-  // Contained status of Dropbox uploads. Removed as Perfetto no
-  // longer supports uploading traces using Dropbox.
-  // reserved 5, 6, 7;
-};
+    const uint32_t record_off;  // Offset of ChunkRecord within |data_|.
+    const ClientIdentity client_identity_trusted;
+    // Flags set by TraceBuffer to track the state of the chunk in the index.
+    uint8_t index_flags = 0;
 
-// This must match the values of the PerfettoTrigger::TriggerType enum in:
-// frameworks/proto_logging/stats/atoms.proto
-enum PerfettoTriggerAtom {
-  kUndefined = 0,
+    // Correspond to |chunk_record->flags| and |chunk_record->num_fragments|.
+    // Copied here for performance reasons (avoids having to dereference
+    // |chunk_record| while iterating over ChunkMeta) and to aid debugging in
+    // case the buffer gets corrupted.
+    uint8_t flags = 0;           // See SharedMemoryABI::ChunkHeader::flags.
+    uint16_t num_fragments = 0;  // Total number of packet fragments.
 
-  kCmdTrigger = 1,
-  kCmdTriggerFail = 2,
+    uint16_t num_fragments_read = 0;  // Number of fragments already read.
 
-  kTriggerPerfettoTrigger = 3,
-  kTriggerPerfettoTriggerFail = 4,
+    // The start offset of the next fragment (the |num_fragments_read|-th) to be
+    // read. This is the offset in bytes from the beginning of the ChunkRecord's
+    // payload (the 1st fragment starts at |chunk_record| +
+    // sizeof(ChunkRecord)).
+    uint16_t cur_fragment_offset = 0;
+  };
 
-  kTracedLimitProbability = 5,
-  kTracedLimitMaxPer24h = 6,
+  using ChunkMap = std::map<ChunkMeta::Key, ChunkMeta>;
 
-  kProbesProducerTrigger = 7,
-  kProbesProducerTriggerFail = 8,
-};
+  // Allows to iterate over a sub-sequence of |index_| for all keys belonging to
+  // the same {ProducerID,WriterID}. Furthermore takes into account the wrapping
+  // of ChunkID. Instances are valid only as long as the |index_| is not altered
+  // (can be used safely only between adjacent ReadNextTracePacket() calls).
+  // The order of the iteration will proceed in the following order:
+  // |wrapping_id| + 1 -> |seq_end|, |seq_begin| -> |wrapping_id|.
+  // Practical example:
+  // - Assume that kMaxChunkID == 7
+  // - Assume that we have all 8 chunks in the range (0..7).
+  // - Hence, |seq_begin| == c0, |seq_end| == c7
+  // - Assume |wrapping_id| = 4 (c4 is the last chunk copied over
+  //   through a CopyChunkUntrusted()).
+  // The resulting iteration order will be: c5, c6, c7, c0, c1, c2, c3, c4.
+  struct SequenceIterator {
+    // Points to the 1st key (the one with the numerically min ChunkID).
+    ChunkMap::iterator seq_begin;
 
-}  // namespace perfetto
+    // Points one past the last key (the one with the numerically max ChunkID).
+    ChunkMap::iterator seq_end;
 
-#endif  // SRC_ANDROID_STATS_PERFETTO_ATOMS_H_
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+    // Current iterator, always >= seq_begin && <= seq_end.
+    ChunkMap::iterator cur;
 
-#ifndef SRC_ANDROID_STATS_STATSD_LOGGING_HELPER_H_
-#define SRC_ANDROID_STATS_STATSD_LOGGING_HELPER_H_
+    // The latest ChunkID written. Determines the start/end of the sequence.
+    ChunkID wrapping_id;
 
-#include <stdint.h>
-#include <string>
-#include <vector>
+    bool is_valid() const { return cur != seq_end; }
 
-// gen_amalgamated expanded: #include "src/android_stats/perfetto_atoms.h"
+    ProducerID producer_id() const {
+      PERFETTO_DCHECK(is_valid());
+      return cur->first.producer_id;
+    }
 
-namespace perfetto {
-namespace android_stats {
+    WriterID writer_id() const {
+      PERFETTO_DCHECK(is_valid());
+      return cur->first.writer_id;
+    }
 
-// Functions in this file are only active on built in the Android
-// tree. On other platforms (including Android standalone and Chromium
-// on Android) these functions are a noop.
+    ChunkID chunk_id() const {
+      PERFETTO_DCHECK(is_valid());
+      return cur->first.chunk_id;
+    }
 
-// Logs the upload event to statsd if built in the Android tree.
-void MaybeLogUploadEvent(PerfettoStatsdAtom atom,
-                         int64_t uuid_lsb,
-                         int64_t uuid_msb,
-                         const std::string& trigger_name = "");
+    ChunkMeta& operator*() {
+      PERFETTO_DCHECK(is_valid());
+      return cur->second;
+    }
+
+    // Moves |cur| to the next chunk in the index.
+    // is_valid() will become false after calling this, if this was the last
+    // entry of the sequence.
+    void MoveNext();
+
+    void MoveToEnd() { cur = seq_end; }
+  };
+
+  enum class ReadAheadResult {
+    kSucceededReturnSlices,
+    kFailedMoveToNextSequence,
+    kFailedStayOnSameSequence,
+  };
+
+  enum class ReadPacketResult {
+    kSucceeded,
+    kFailedInvalidPacket,
+    kFailedEmptyPacket,
+  };
 
-// Logs the trigger events to statsd if built in the Android tree.
-void MaybeLogTriggerEvent(PerfettoTriggerAtom atom, const std::string& trigger);
+  explicit TraceBufferV1(OverwritePolicy);
+  TraceBufferV1(const TraceBufferV1&) = delete;
+  TraceBufferV1& operator=(const TraceBufferV1&) = delete;
 
-// Logs the trigger events to statsd if built in the Android tree.
-void MaybeLogTriggerEvents(PerfettoTriggerAtom atom,
-                           const std::vector<std::string>& triggers);
+  // Not using the implicit copy ctor to avoid unintended copies.
+  // This tagged ctor should be used only for Clone().
+  struct CloneCtor {};
+  TraceBufferV1(CloneCtor, const TraceBufferV1&);
 
-}  // namespace android_stats
-}  // namespace perfetto
+  bool Initialize(size_t size);
 
-#endif  // SRC_ANDROID_STATS_STATSD_LOGGING_HELPER_H_
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+  // Returns an object that allows to iterate over chunks in the |index_| that
+  // have the same {ProducerID, WriterID} of
+  // |seq_begin.first.{producer,writer}_id|. |seq_begin| must be an iterator to
+  // the first entry in the |index_| that has a different {ProducerID, WriterID}
+  // from the previous one. It is valid for |seq_begin| to be == index_.end()
+  // (i.e. if the index is empty). The iteration takes care of ChunkID wrapping,
+  // by using |last_chunk_id_|.
+  SequenceIterator GetReadIterForSequence(ChunkMap::iterator seq_begin);
 
-// gen_amalgamated expanded: #include "src/android_stats/statsd_logging_helper.h"
+  // Used as a last resort when a buffer corruption is detected.
+  void ClearContentsAndResetRWCursors();
 
-#include <string>
+  // Adds a padding record of the given size (must be a multiple of
+  // sizeof(ChunkRecord)).
+  void AddPaddingRecord(size_t);
 
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
-// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
+  // Look for contiguous fragment of the same packet starting from |read_iter_|.
+  // If a contiguous packet is found, all the fragments are pushed into
+  // TracePacket and the function returns kSucceededReturnSlices. If not, the
+  // function returns either kFailedMoveToNextSequence or
+  // kFailedStayOnSameSequence, telling the caller to continue looking for
+  // packets.
+  ReadAheadResult ReadAhead(TracePacket*);
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) && \
-    PERFETTO_BUILDFLAG(PERFETTO_ANDROID_BUILD)
-// gen_amalgamated expanded: #include "src/android_internal/lazy_library_loader.h"  // nogncheck
-// gen_amalgamated expanded: #include "src/android_internal/statsd_logging.h"       // nogncheck
-#endif
+  // Deletes (by marking the record invalid and removing form the index) all
+  // chunks from |wptr_| to |wptr_| + |bytes_to_clear|.
+  // Returns:
+  //   * The size of the gap left between the next valid Chunk and the end of
+  //     the deletion range.
+  //   * 0 if no next valid chunk exists (if the buffer is still zeroed).
+  //   * -1 if the buffer |overwrite_policy_| == kDiscard and the deletion would
+  //     cause unread chunks to be overwritten. In this case the buffer is left
+  //     untouched.
+  // Graphically, assume the initial situation is the following (|wptr_| = 10).
+  // |0        |10 (wptr_)       |30       |40                 |60
+  // +---------+-----------------+---------+-------------------+---------+
+  // | Chunk 1 | Chunk 2         | Chunk 3 | Chunk 4           | Chunk 5 |
+  // +---------+-----------------+---------+-------------------+---------+
+  //           |_________Deletion range_______|~~return value~~|
+  //
+  // A call to DeleteNextChunksFor(32) will remove chunks 2,3,4 and return 18
+  // (60 - 42), the distance between chunk 5 and the end of the deletion range.
+  ssize_t DeleteNextChunksFor(size_t bytes_to_clear);
 
-namespace perfetto {
-namespace android_stats {
+  // Decodes the boundaries of the next packet (or a fragment) pointed by
+  // ChunkMeta and pushes that into |TracePacket|. It also increments the
+  // |num_fragments_read| counter.
+  // TracePacket can be nullptr, in which case the read state is still advanced.
+  // When TracePacket is not nullptr, ProducerID must also be not null and will
+  // be updated with the ProducerID that originally wrote the chunk.
+  ReadPacketResult ReadNextPacketInChunk(ProducerAndWriterID,
+                                         ChunkMeta*,
+                                         TracePacket*);
 
-// Make sure we don't accidentally log on non-Android tree build. Note that even
-// removing this ifdef still doesn't make uploads work on OS_ANDROID.
-// PERFETTO_LAZY_LOAD will return a nullptr on non-Android and non-in-tree
-// builds as libperfetto_android_internal will not be available.
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) && \
-    PERFETTO_BUILDFLAG(PERFETTO_ANDROID_BUILD)
+  void DcheckIsAlignedAndWithinBounds(const uint8_t* ptr) const {
+    PERFETTO_DCHECK(ptr >= begin() && ptr <= end() - sizeof(ChunkRecord));
+    PERFETTO_DCHECK(
+        (reinterpret_cast<uintptr_t>(ptr) & (alignof(ChunkRecord) - 1)) == 0);
+  }
 
-void MaybeLogUploadEvent(PerfettoStatsdAtom atom,
-                         int64_t uuid_lsb,
-                         int64_t uuid_msb,
-                         const std::string& trigger_name) {
-  PERFETTO_LAZY_LOAD(android_internal::StatsdLogUploadEvent, log_event_fn);
-  if (log_event_fn) {
-    log_event_fn(atom, uuid_lsb, uuid_msb, trigger_name.c_str());
+  ChunkRecord* GetChunkRecordAt(uint8_t* ptr) {
+    DcheckIsAlignedAndWithinBounds(ptr);
+    // We may be accessing a new (empty) record.
+    EnsureCommitted(static_cast<size_t>(ptr + sizeof(ChunkRecord) - begin()));
+    return reinterpret_cast<ChunkRecord*>(ptr);
   }
-}
 
-void MaybeLogTriggerEvent(PerfettoTriggerAtom atom,
-                          const std::string& trigger_name) {
-  PERFETTO_LAZY_LOAD(android_internal::StatsdLogTriggerEvent, log_event_fn);
-  if (log_event_fn) {
-    log_event_fn(atom, trigger_name.c_str());
+  void EnsureCommitted(size_t size) {
+    PERFETTO_DCHECK(size <= size_);
+    data_.EnsureCommitted(size);
+    used_size_ = std::max(used_size_, size);
   }
-}
 
-void MaybeLogTriggerEvents(PerfettoTriggerAtom atom,
-                           const std::vector<std::string>& triggers) {
-  PERFETTO_LAZY_LOAD(android_internal::StatsdLogTriggerEvent, log_event_fn);
-  if (log_event_fn) {
-    for (const std::string& trigger_name : triggers) {
-      log_event_fn(atom, trigger_name.c_str());
+  void DiscardWrite();
+
+  // |src| can be nullptr (in which case |size| must be ==
+  // record.size - sizeof(ChunkRecord)), for the case of writing a padding
+  // record. |wptr_| is NOT advanced by this function, the caller must do that.
+  void WriteChunkRecord(uint8_t* wptr,
+                        const ChunkRecord& record,
+                        const uint8_t* src,
+                        size_t size) {
+    // Note: |record.size| will be slightly bigger than |size| because of the
+    // ChunkRecord header and rounding, to ensure that all ChunkRecord(s) are
+    // multiple of sizeof(ChunkRecord). The invariant is:
+    // record.size >= |size| + sizeof(ChunkRecord) (== if no rounding).
+    PERFETTO_DCHECK(size <= ChunkRecord::kMaxSize);
+    PERFETTO_DCHECK(record.size >= sizeof(record));
+    PERFETTO_DCHECK(record.size % sizeof(record) == 0);
+    PERFETTO_DCHECK(record.size >= size + sizeof(record));
+    DcheckIsAlignedAndWithinBounds(wptr);
+
+    // We may be writing to this area for the first time.
+    EnsureCommitted(static_cast<size_t>(wptr + record.size - begin()));
+
+    // Deliberately not a *D*CHECK.
+    PERFETTO_CHECK(wptr + sizeof(record) + size <= end());
+    memcpy(wptr, &record, sizeof(record));
+    if (PERFETTO_LIKELY(src)) {
+      // If the producer modifies the data in the shared memory buffer while we
+      // are copying it to the central buffer, TSAN will (rightfully) flag that
+      // as a race. However the entire purpose of copying the data into the
+      // central buffer is that we can validate it without worrying that the
+      // producer changes it from under our feet, so this race is benign. The
+      // alternative would be to try computing which part of the buffer is safe
+      // to read (assuming a well-behaving client), but the risk of introducing
+      // a bug that way outweighs the benefit.
+      PERFETTO_ANNOTATE_BENIGN_RACE_SIZED(
+          src, size, "Benign race when copying chunk from shared memory.")
+      memcpy(wptr + sizeof(record), src, size);
+    } else {
+      PERFETTO_DCHECK(size == record.size - sizeof(record));
     }
+    const size_t rounding_size = record.size - sizeof(record) - size;
+    memset(wptr + sizeof(record) + size, 0, rounding_size);
   }
-}
 
-#else
-void MaybeLogUploadEvent(PerfettoStatsdAtom,
-                         int64_t,
-                         int64_t,
-                         const std::string&) {}
-void MaybeLogTriggerEvent(PerfettoTriggerAtom, const std::string&) {}
-void MaybeLogTriggerEvents(PerfettoTriggerAtom,
-                           const std::vector<std::string>&) {}
-#endif
+  uint32_t GetOffset(const void* _addr) {
+    const uintptr_t addr = reinterpret_cast<uintptr_t>(_addr);
+    const uintptr_t buf_start = reinterpret_cast<uintptr_t>(begin());
+    PERFETTO_DCHECK(addr >= buf_start && addr < buf_start + size_);
+    return static_cast<uint32_t>(addr - buf_start);
+  }
 
-}  // namespace android_stats
-}  // namespace perfetto
-// gen_amalgamated begin source: src/base/version.cc
-// gen_amalgamated begin header: include/perfetto/ext/base/version.h
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+  uint8_t* begin() const { return reinterpret_cast<uint8_t*>(data_.Get()); }
+  uint8_t* end() const { return begin() + size_; }
+  size_t size_to_end() const { return static_cast<size_t>(end() - wptr_); }
 
-#ifndef INCLUDE_PERFETTO_EXT_BASE_VERSION_H_
-#define INCLUDE_PERFETTO_EXT_BASE_VERSION_H_
+  base::PagedMemory data_;
+  size_t size_ = 0;  // Size in bytes of |data_|.
 
-namespace perfetto {
-namespace base {
+  // High watermark. The number of bytes (<= |size_|) written into the buffer
+  // before the first wraparound. This increases as data is written into the
+  // buffer and then saturates at |size_|. Used for CloneReadOnly().
+  size_t used_size_ = 0;
 
-// The returned pointer is a static string is safe to pass around.
-const char* GetVersionString();
+  size_t max_chunk_size_ = 0;  // Max size in bytes allowed for a chunk.
+  uint8_t* wptr_ = nullptr;    // Write pointer.
 
-}  // namespace base
-}  // namespace perfetto
+  // An index that keeps track of the positions and metadata of each
+  // ChunkRecord.
+  ChunkMap index_;
 
-#endif  // INCLUDE_PERFETTO_EXT_BASE_VERSION_H_
-// gen_amalgamated begin header: gen/perfetto_version.gen.h
-// Generated by write_version_header.py
+  // Read iterator used for ReadNext(). It is reset by calling BeginRead().
+  // It becomes invalid after any call to methods that alters the |index_|.
+  SequenceIterator read_iter_;
 
-#ifndef GEN_PERFETTO_VERSION_GEN_H_
-#define GEN_PERFETTO_VERSION_GEN_H_
+  // See comments at the top of the file.
+  OverwritePolicy overwrite_policy_ = kOverwrite;
 
-#define PERFETTO_VERSION_STRING() "v33.0-51eba1279"
-#define PERFETTO_VERSION_SCM_REVISION() "51eba1279d0919b22c473b63c4a399cb2dc0f053"
+  // This buffer is a read-only snapshot obtained via Clone(). If this is true
+  // calls to CopyChunkUntrusted() and TryPatchChunkContents() will CHECK().
+  bool read_only_ = false;
 
-#endif  // GEN_PERFETTO_VERSION_GEN_H_
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+  // Only used when |overwrite_policy_ == kDiscard|. This is set the first time
+  // a write fails because it would overwrite unread chunks.
+  bool discard_writes_ = false;
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/version.h"
+  // Keeps track of the highest ChunkID written for a given sequence, taking
+  // into account a potential overflow of ChunkIDs. In the case of overflow,
+  // stores the highest ChunkID written since the overflow.
+  //
+  // TODO(primiano): should clean up keys from this map. Right now it grows
+  // without bounds (although realistically is not a problem unless we have too
+  // many producers/writers within the same trace session).
+  std::map<std::pair<ProducerID, WriterID>, ChunkID> last_chunk_id_written_;
 
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+  // Statistics about buffer usage.
+  TraceStats::BufferStats stats_;
 
-#include <stdio.h>
+  // Per-{Producer, Writer} statistics.
+  WriterStats writer_stats_;
 
-#if PERFETTO_BUILDFLAG(PERFETTO_VERSION_GEN)
-// gen_amalgamated expanded: #include "perfetto_version.gen.h"
-#else
-#define PERFETTO_VERSION_STRING() "v0.0"
-#define PERFETTO_VERSION_SCM_REVISION() "unknown"
-#endif
+  // Set to true upon the very first call to CopyChunkUntrusted() and never
+  // cleared. This is used to tell if the buffer has never been used since its
+  // creation (which in turn is used to optimize `clear_before_clone`).
+  bool has_data_ = false;
 
-namespace perfetto {
-namespace base {
+#if PERFETTO_DCHECK_IS_ON()
+  bool changed_since_last_read_ = false;
+#endif
 
-const char* GetVersionString() {
-  static const char* version_str = [] {
-    static constexpr size_t kMaxLen = 256;
-    char* version = new char[kMaxLen + 1];
-    snprintf(version, kMaxLen, "Perfetto %s (%s)", PERFETTO_VERSION_STRING(),
-             PERFETTO_VERSION_SCM_REVISION());
-    return version;
-  }();
-  return version_str;
-}
+  // When true disable some DCHECKs that have been put in place to detect
+  // bugs in the producers. This is for tests that feed malicious inputs and
+  // hence mimic a buggy producer.
+  bool suppress_client_dchecks_for_testing_ = false;
+};
 
-}  // namespace base
 }  // namespace perfetto
-// gen_amalgamated begin source: src/protozero/filtering/filter_bytecode_parser.cc
-// gen_amalgamated begin header: src/protozero/filtering/filter_bytecode_parser.h
+
+#endif  // SRC_TRACING_SERVICE_TRACE_BUFFER_V1_H_
 /*
- * Copyright (C) 2021 The Android Open Source Project
+ * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -51011,802 +57717,951 @@ const char* GetVersionString() {
  * limitations under the License.
  */
 
-#ifndef SRC_PROTOZERO_FILTERING_FILTER_BYTECODE_PARSER_H_
-#define SRC_PROTOZERO_FILTERING_FILTER_BYTECODE_PARSER_H_
+// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer_v1.h"
 
-#include <stddef.h>
-#include <stdint.h>
+#include <limits>
 
-#include <vector>
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/flags.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/client_identity.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_abi.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_packet.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-namespace protozero {
+#define TRACE_BUFFER_VERBOSE_LOGGING() 0  // Set to 1 when debugging unittests.
+#if TRACE_BUFFER_VERBOSE_LOGGING()
+#define TRACE_BUFFER_DLOG PERFETTO_DLOG
+#else
+#define TRACE_BUFFER_DLOG(...) void()
+#endif
 
-// Loads the proto-encoded bytecode in memory and allows fast lookups for tuples
-// (msg_index, field_id) to tell if a given field should be allowed or not and,
-// in the case of nested fields, what is the next message index to recurse into.
-// This class does two things:
-// 1. Expands the array of varint from the proto into a vector<uint32_t>. This
-//    is to avoid performing varint decoding on every lookup, at the cost of
-//    some extra memory (2KB-4KB). Note that the expanded vector is not just a
-//    1:1 copy of the proto one (more below). This is to avoid O(Fields) linear
-//    lookup complexity.
-// 2. Creates an index of offsets to remember the start word for each message.
-//    This is so we can jump to O(1) to the N-th message when recursing into a
-//    nested fields, without having to scan and find the (N-1)-th END_OF_MESSAGE
-//    marker.
-// Overall lookups are O(1) for field ids < 128 (kDirectlyIndexLimit) and O(N),
-// with N being the number of allowed field ranges for other fields.
-// See comments around |word_| below for the structure of the word vector.
-class FilterBytecodeParser {
- public:
-  // Result of a Query() operation
-  struct QueryResult {
-    bool allowed;  // Whether the field is allowed at all or no.
+namespace perfetto {
 
-    // If |allowed|==true && simple_field()==false, this tells the message index
-    // of the nested field that should be used when recursing in the parser.
-    uint32_t nested_msg_index;
+namespace {
+constexpr uint8_t kFirstPacketContinuesFromPrevChunk =
+    SharedMemoryABI::ChunkHeader::kFirstPacketContinuesFromPrevChunk;
+constexpr uint8_t kLastPacketContinuesOnNextChunk =
+    SharedMemoryABI::ChunkHeader::kLastPacketContinuesOnNextChunk;
+constexpr uint8_t kChunkNeedsPatching =
+    SharedMemoryABI::ChunkHeader::kChunkNeedsPatching;
+}  // namespace.
 
-    // If |allowed|==true, specifies if the field is of a simple type (varint,
-    // fixed32/64, string or byte) or a nested field that needs recursion.
-    // In the latter case the caller is expected to use |nested_msg_index| for
-    // the next Query() calls.
-    bool simple_field() const { return nested_msg_index == kSimpleField; }
-  };
+// static
+std::unique_ptr<TraceBufferV1> TraceBufferV1::Create(size_t size_in_bytes,
+                                                     OverwritePolicy pol) {
+  std::unique_ptr<TraceBufferV1> trace_buffer(new TraceBufferV1(pol));
+  if (!trace_buffer->Initialize(size_in_bytes))
+    return nullptr;
+  return trace_buffer;
+}
 
-  // Loads a filter. The filter data consists of a sequence of varints which
-  // contains the filter opcodes and a final checksum.
-  bool Load(const void* filter_data, size_t len);
+TraceBufferV1::TraceBufferV1(OverwritePolicy pol) : overwrite_policy_(pol) {
+  // See comments in ChunkRecord for the rationale of this.
+  static_assert(sizeof(ChunkRecord) == sizeof(SharedMemoryABI::PageHeader) +
+                                           sizeof(SharedMemoryABI::ChunkHeader),
+                "ChunkRecord out of sync with the layout of SharedMemoryABI");
+  static_assert(sizeof(ChunkRecord) == TraceBuffer::InlineChunkHeaderSize);
+}
 
-  // Checks wheter a given field is allowed or not.
-  // msg_index = 0 is the index of the root message, where all queries should
-  // start from (typically perfetto.protos.Trace).
-  QueryResult Query(uint32_t msg_index, uint32_t field_id);
+TraceBufferV1::~TraceBufferV1() = default;
 
-  void Reset();
-  void set_suppress_logs_for_fuzzer(bool x) { suppress_logs_for_fuzzer_ = x; }
+bool TraceBufferV1::Initialize(size_t size) {
+  static_assert(
+      SharedMemoryABI::kMinPageSize % sizeof(ChunkRecord) == 0,
+      "sizeof(ChunkRecord) must be an integer divider of a page size");
+  auto max_size = std::numeric_limits<decltype(ChunkMeta::record_off)>::max();
+  PERFETTO_CHECK(size <= static_cast<size_t>(max_size));
+  data_ = base::PagedMemory::Allocate(
+      size, base::PagedMemory::kMayFail | base::PagedMemory::kDontCommit);
+  if (!data_.IsValid()) {
+    PERFETTO_ELOG("Trace buffer allocation failed (size: %zu)", size);
+    return false;
+  }
+  size_ = size;
+  used_size_ = 0;
+  stats_.set_buffer_size(size);
+  max_chunk_size_ = std::min(size, ChunkRecord::kMaxSize);
+  wptr_ = begin();
+  index_.clear();
+  last_chunk_id_written_.clear();
+  read_iter_ = GetReadIterForSequence(index_.end());
+  return true;
+}
 
- private:
-  static constexpr uint32_t kDirectlyIndexLimit = 128;
-  static constexpr uint32_t kAllowed = 1u << 31u;
-  static constexpr uint32_t kSimpleField = 0x7fffffff;
+// Note: |src| points to a shmem region that is shared with the producer. Assume
+// that the producer is malicious and will change the content of |src|
+// while we execute here. Don't do any processing on it other than memcpy().
+void TraceBufferV1::CopyChunkUntrusted(
+    ProducerID producer_id_trusted,
+    const ClientIdentity& client_identity_trusted,
+    WriterID writer_id,
+    ChunkID chunk_id,
+    uint16_t num_fragments,
+    uint8_t chunk_flags,
+    bool chunk_complete,
+    const uint8_t* src,
+    size_t size) {
+  PERFETTO_CHECK(!read_only_);
 
-  bool LoadInternal(const uint8_t* filter_data, size_t len);
+  // |record_size| = |size| + sizeof(ChunkRecord), rounded up to avoid to end
+  // up in a fragmented state where size_to_end() < sizeof(ChunkRecord).
+  const size_t record_size =
+      base::AlignUp<sizeof(ChunkRecord)>(size + sizeof(ChunkRecord));
+  TRACE_BUFFER_DLOG("CopyChunk @ %" PRIdPTR ", size=%zu", wptr_ - begin(),
+                    record_size);
+  if (PERFETTO_UNLIKELY(record_size > max_chunk_size_)) {
+    stats_.set_abi_violations(stats_.abi_violations() + 1);
+    PERFETTO_DCHECK(suppress_client_dchecks_for_testing_);
+    return;
+  }
 
-  // The state of all fields for all messages is stored in one contiguous array.
-  // This is to avoid memory fragmentation and allocator overhead.
-  // We expect a high number of messages (hundreds), but each message is small.
-  // For each message we store two sets of uint32:
-  // 1. A set of "directly indexed" fields, for field ids < 128.
-  // 2. The remainder is a set of ranges.
-  // So each message descriptor consists of a sequence of words as follows:
-  //
-  // [0] -> how many directly indexed fields are stored next (up to 128)
-  //
-  // [1..N] -> One word per field id (See "field state" below).
-  //
-  // [N + 1] -> Start of field id range 1
-  // [N + 2] -> End of field id range 1 (exclusive, STL-style).
-  // [N + 3] -> Field state for fields in range 1 (below)
-  //
-  // [N + 4] -> Start of field id range 2
-  // [N + 5] -> End of field id range 2 (exclusive, STL-style).
-  // [N + 6] -> Field state for fields in range 2 (below)
+  has_data_ = true;
+#if PERFETTO_DCHECK_IS_ON()
+  changed_since_last_read_ = true;
+#endif
 
-  // The "field state" word is as follows:
-  // Bit 31: 0 if the field is disallowed, 1 if allowed.
-  //         Only directly indexed fields can be 0 (it doesn't make sense to add
-  //         a range and then say "btw it's NOT allowed".. don't add it then.
-  //         0 is only used for filling gaps in the directly indexed bucket.
-  // Bits [30..0] (only when MSB == allowed):
-  //  0x7fffffff: The field is "simple" (varint, fixed32/64, string, bytes) and
-  //      can be directly passed through in output. No recursion is needed.
-  //  [0, 7ffffffe]: The field is a nested submessage. The value is the index
-  //     that must be passed as first argument to the next Query() calls.
-  //     Note that the message index is purely a monotonic counter in the
-  //     filter bytecode, has no proto-equivalent match (unlike field ids).
-  std::vector<uint32_t> words_;
+  // If the chunk hasn't been completed, we should only consider the first
+  // |num_fragments - 1| packets complete. For simplicity, we simply disregard
+  // the last one when we copy the chunk.
+  if (PERFETTO_UNLIKELY(!chunk_complete)) {
+    if (num_fragments > 0) {
+      num_fragments--;
+      // These flags should only affect the last packet in the chunk. We clear
+      // them, so that TraceBufferV1 is able to look at the remaining packets in
+      // this chunk.
+      chunk_flags &= ~kLastPacketContinuesOnNextChunk;
+      chunk_flags &= ~kChunkNeedsPatching;
+    }
+  }
 
-  // One entry for each message index stored in the filter plus a sentinel at
-  // the end. Maps each message index to the offset in |words_| where the
-  // Nth message start.
-  // message_offset_.size() - 2 == the max message id that can be parsed.
-  std::vector<uint32_t> message_offset_;
+  ChunkRecord record(record_size);
+  record.producer_id = producer_id_trusted;
+  record.chunk_id = chunk_id;
+  record.writer_id = writer_id;
+  record.num_fragments = num_fragments;
+  record.flags = chunk_flags & ChunkRecord::kFlagsBitMask;
+  ChunkMeta::Key key(record);
 
-  bool suppress_logs_for_fuzzer_ = false;
-};
+  // Check whether we have already copied the same chunk previously. This may
+  // happen if the service scrapes chunks in a potentially incomplete state
+  // before receiving commit requests for them from the producer. Note that the
+  // service may scrape and thus override chunks in arbitrary order since the
+  // chunks aren't ordered in the SMB.
+  const auto it = index_.find(key);
+  if (PERFETTO_UNLIKELY(it != index_.end())) {
+    ChunkMeta* record_meta = &it->second;
+    ChunkRecord* prev = GetChunkRecordAt(begin() + record_meta->record_off);
 
-}  // namespace protozero
+    // Verify that the old chunk's metadata corresponds to the new one.
+    // Overridden chunks should never change size, since the page layout is
+    // fixed per writer. The number of fragments should also never decrease and
+    // flags should not be removed.
+    if (PERFETTO_UNLIKELY(ChunkMeta::Key(*prev) != key ||
+                          prev->size != record_size ||
+                          prev->num_fragments > num_fragments ||
+                          (prev->flags & chunk_flags) != prev->flags)) {
+      stats_.set_abi_violations(stats_.abi_violations() + 1);
+      PERFETTO_DCHECK(suppress_client_dchecks_for_testing_);
+      return;
+    }
 
-#endif  // SRC_PROTOZERO_FILTERING_FILTER_BYTECODE_PARSER_H_
-// gen_amalgamated begin header: src/protozero/filtering/filter_bytecode_common.h
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+    // If this chunk was previously copied with the same number of fragments and
+    // the number didn't change, there's no need to copy it again. If the
+    // previous chunk was complete already, this should always be the case.
+    PERFETTO_DCHECK(suppress_client_dchecks_for_testing_ ||
+                    !record_meta->is_complete() ||
+                    (chunk_complete && prev->num_fragments == num_fragments));
+    if (prev->num_fragments == num_fragments) {
+      TRACE_BUFFER_DLOG("  skipping recommit of identical chunk");
+      return;
+    }
 
-#ifndef SRC_PROTOZERO_FILTERING_FILTER_BYTECODE_COMMON_H_
-#define SRC_PROTOZERO_FILTERING_FILTER_BYTECODE_COMMON_H_
+    // If we've already started reading from chunk N+1 following this chunk N,
+    // don't override chunk N. Otherwise we may end up reading a packet from
+    // chunk N after having read from chunk N+1, thereby violating sequential
+    // read of packets. This shouldn't happen if the producer is well-behaved,
+    // because it shouldn't start chunk N+1 before completing chunk N.
+    ChunkMeta::Key subsequent_key = key;
+    static_assert(std::numeric_limits<ChunkID>::max() == kMaxChunkID,
+                  "ChunkID wraps");
+    subsequent_key.chunk_id++;
+    const auto subsequent_it = index_.find(subsequent_key);
+    if (subsequent_it != index_.end() &&
+        subsequent_it->second.num_fragments_read > 0) {
+      stats_.set_abi_violations(stats_.abi_violations() + 1);
+      PERFETTO_DCHECK(suppress_client_dchecks_for_testing_);
+      return;
+    }
 
-#include <stdint.h>
+    // We should not have read past the last packet.
+    if (record_meta->num_fragments_read > prev->num_fragments) {
+      PERFETTO_ELOG(
+          "TraceBufferV1 read too many fragments from an incomplete chunk");
+      PERFETTO_DCHECK(suppress_client_dchecks_for_testing_);
+      return;
+    }
 
-namespace protozero {
+    uint8_t* wptr = reinterpret_cast<uint8_t*>(prev);
+    TRACE_BUFFER_DLOG("  overriding chunk @ %" PRIdPTR ", size=%zu",
+                      wptr - begin(), record_size);
 
-enum FilterOpcode : uint32_t {
-  // The immediate value is 0 in this case.
-  kFilterOpcode_EndOfMessage = 0,
+    // Update chunk meta data stored in the index, as it may have changed.
+    record_meta->num_fragments = num_fragments;
+    record_meta->flags = chunk_flags;
+    record_meta->set_complete(chunk_complete);
 
-  // The immediate value is the id of the allowed field.
-  kFilterOpcode_SimpleField = 1,
+    // Override the ChunkRecord contents at the original |wptr|.
+    TRACE_BUFFER_DLOG("  copying @ [%" PRIdPTR " - %" PRIdPTR "] %zu",
+                      wptr - begin(), uintptr_t(wptr - begin()) + record_size,
+                      record_size);
+    WriteChunkRecord(wptr, record, src, size);
+    TRACE_BUFFER_DLOG("Chunk raw: %s",
+                      base::HexDump(wptr, record_size).c_str());
+    stats_.set_chunks_rewritten(stats_.chunks_rewritten() + 1);
+    return;
+  }
 
-  // The immediate value is the start of the range. The next word (without
-  // any shifting) is the length of the range.
-  kFilterOpcode_SimpleFieldRange = 2,
+  if (PERFETTO_UNLIKELY(discard_writes_))
+    return DiscardWrite();
 
-  // The immediate value is the id of the allowed field. The next word
-  // (without any shifting) is the index of the filter that should be used to
-  // recurse into the nested message.
-  kFilterOpcode_NestedField = 3,
-};
-}  // namespace protozero
+  // If there isn't enough room from the given write position. Write a padding
+  // record to clear the end of the buffer and wrap back.
+  const size_t cached_size_to_end = size_to_end();
+  if (PERFETTO_UNLIKELY(record_size > cached_size_to_end)) {
+    ssize_t res = DeleteNextChunksFor(cached_size_to_end);
+    if (res == -1)
+      return DiscardWrite();
+    PERFETTO_DCHECK(static_cast<size_t>(res) <= cached_size_to_end);
+    AddPaddingRecord(cached_size_to_end);
+    wptr_ = begin();
+    stats_.set_write_wrap_count(stats_.write_wrap_count() + 1);
+    PERFETTO_DCHECK(size_to_end() >= record_size);
+  }
 
-#endif  // SRC_PROTOZERO_FILTERING_FILTER_BYTECODE_COMMON_H_
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+  // At this point either |wptr_| points to an untouched part of the buffer
+  // (i.e. *wptr_ == 0) or we are about to overwrite one or more ChunkRecord(s).
+  // In the latter case we need to first figure out where the next valid
+  // ChunkRecord is (if it exists) and add padding between the new record.
+  // Example ((w) == write cursor):
+  //
+  // Initial state (wtpr_ == 0):
+  // |0 (w)    |10               |30                  |50
+  // +---------+-----------------+--------------------+--------------------+
+  // | Chunk 1 | Chunk 2         | Chunk 3            | Chunk 4            |
+  // +---------+-----------------+--------------------+--------------------+
+  //
+  // Let's assume we now want now write a 5th Chunk of size == 35. The final
+  // state should look like this:
+  // |0                                |35 (w)         |50
+  // +---------------------------------+---------------+--------------------+
+  // | Chunk 5                         | Padding Chunk | Chunk 4            |
+  // +---------------------------------+---------------+--------------------+
 
-// gen_amalgamated expanded: #include "src/protozero/filtering/filter_bytecode_parser.h"
+  // Deletes all chunks from |wptr_| to |wptr_| + |record_size|.
+  ssize_t del_res = DeleteNextChunksFor(record_size);
+  if (del_res == -1)
+    return DiscardWrite();
+  size_t padding_size = static_cast<size_t>(del_res);
 
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/hash.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-// gen_amalgamated expanded: #include "src/protozero/filtering/filter_bytecode_common.h"
+  // Now first insert the new chunk. At the end, if necessary, add the padding.
+  stats_.set_chunks_written(stats_.chunks_written() + 1);
+  stats_.set_bytes_written(stats_.bytes_written() + record_size);
 
-namespace protozero {
+  uint32_t chunk_off = GetOffset(GetChunkRecordAt(wptr_));
+  auto it_and_inserted =
+      index_.emplace(key, ChunkMeta(chunk_off, num_fragments, chunk_complete,
+                                    chunk_flags, client_identity_trusted));
+  PERFETTO_DCHECK(it_and_inserted.second);
+  TRACE_BUFFER_DLOG("  copying @ [%" PRIdPTR " - %" PRIdPTR "] %zu",
+                    wptr_ - begin(), uintptr_t(wptr_ - begin()) + record_size,
+                    record_size);
+  WriteChunkRecord(wptr_, record, src, size);
+  TRACE_BUFFER_DLOG("Chunk raw: %s", base::HexDump(wptr_, record_size).c_str());
+  wptr_ += record_size;
+  if (wptr_ >= end()) {
+    PERFETTO_DCHECK(padding_size == 0);
+    wptr_ = begin();
+    stats_.set_write_wrap_count(stats_.write_wrap_count() + 1);
+  }
+  DcheckIsAlignedAndWithinBounds(wptr_);
 
-void FilterBytecodeParser::Reset() {
-  bool suppress = suppress_logs_for_fuzzer_;
-  *this = FilterBytecodeParser();
-  suppress_logs_for_fuzzer_ = suppress;
-}
+  // Chunks may be received out of order, so only update last_chunk_id if the
+  // new chunk_id is larger. But take into account overflows by only selecting
+  // the new ID if its distance to the latest ID is smaller than half the number
+  // space.
+  //
+  // This accounts for both the case where the new ID has just overflown and
+  // last_chunk_id be updated even though it's smaller (e.g. |chunk_id| = 1 and
+  // |last_chunk_id| = kMaxChunkId; chunk_id - last_chunk_id = 0) and the case
+  // where the new ID is an out-of-order ID right after an overflow and
+  // last_chunk_id shouldn't be updated even though it's larger (e.g. |chunk_id|
+  // = kMaxChunkId and |last_chunk_id| = 1; chunk_id - last_chunk_id =
+  // kMaxChunkId - 1).
+  auto producer_and_writer_id = std::make_pair(producer_id_trusted, writer_id);
+  ChunkID& last_chunk_id = last_chunk_id_written_[producer_and_writer_id];
+  static_assert(std::numeric_limits<ChunkID>::max() == kMaxChunkID,
+                "This code assumes that ChunkID wraps at kMaxChunkID");
+  if (chunk_id - last_chunk_id < kMaxChunkID / 2) {
+    last_chunk_id = chunk_id;
+  } else {
+    stats_.set_chunks_committed_out_of_order(
+        stats_.chunks_committed_out_of_order() + 1);
+  }
 
-bool FilterBytecodeParser::Load(const void* filter_data, size_t len) {
-  Reset();
-  bool res = LoadInternal(static_cast<const uint8_t*>(filter_data), len);
-  // If load fails, don't leave the parser in a half broken state.
-  if (!res)
-    Reset();
-  return res;
+  if (padding_size)
+    AddPaddingRecord(padding_size);
 }
 
-bool FilterBytecodeParser::LoadInternal(const uint8_t* bytecode_data,
-                                        size_t len) {
-  // First unpack the varints into a plain uint32 vector, so it's easy to
-  // iterate through them and look ahead.
-  std::vector<uint32_t> words;
-  bool packed_parse_err = false;
-  words.reserve(len);  // An overestimation, but avoids reallocations.
-  using BytecodeDecoder =
-      PackedRepeatedFieldIterator<proto_utils::ProtoWireType::kVarInt,
-                                  uint32_t>;
-  for (BytecodeDecoder it(bytecode_data, len, &packed_parse_err); it; ++it)
-    words.emplace_back(*it);
+ssize_t TraceBufferV1::DeleteNextChunksFor(size_t bytes_to_clear) {
+  PERFETTO_CHECK(!discard_writes_);
 
-  if (packed_parse_err || words.empty())
-    return false;
+  // Find the position of the first chunk which begins at or after
+  // (|wptr_| + |bytes|). Note that such a chunk might not exist and we might
+  // either reach the end of the buffer or a zeroed region of the buffer.
+  uint8_t* next_chunk_ptr = wptr_;
+  uint8_t* search_end = wptr_ + bytes_to_clear;
+  TRACE_BUFFER_DLOG("Delete [%zu %zu]", wptr_ - begin(), search_end - begin());
+  DcheckIsAlignedAndWithinBounds(wptr_);
+  PERFETTO_DCHECK(search_end <= end());
+  std::vector<ChunkMap::iterator> index_delete;
+  uint64_t chunks_overwritten = stats_.chunks_overwritten();
+  uint64_t bytes_overwritten = stats_.bytes_overwritten();
+  uint64_t padding_bytes_cleared = stats_.padding_bytes_cleared();
+  while (next_chunk_ptr < search_end) {
+    const ChunkRecord& next_chunk = *GetChunkRecordAt(next_chunk_ptr);
+    TRACE_BUFFER_DLOG(
+        "  scanning chunk [%zu %zu] (valid=%d)", next_chunk_ptr - begin(),
+        next_chunk_ptr - begin() + next_chunk.size, next_chunk.is_valid());
 
-  perfetto::base::Hasher hasher;
-  for (size_t i = 0; i < words.size() - 1; ++i)
-    hasher.Update(words[i]);
+    // We just reached the untouched part of the buffer, it's going to be all
+    // zeroes from here to end().
+    // Optimization: if during Initialize() we fill the buffer with padding
+    // records we could get rid of this branch.
+    if (PERFETTO_UNLIKELY(!next_chunk.is_valid())) {
+      // This should happen only at the first iteration. The zeroed area can
+      // only begin precisely at the |wptr_|, not after. Otherwise it means that
+      // we wrapped but screwed up the ChunkRecord chain.
+      PERFETTO_DCHECK(next_chunk_ptr == wptr_);
+      return 0;
+    }
 
-  uint32_t expected_csum = static_cast<uint32_t>(hasher.digest());
-  if (expected_csum != words.back()) {
-    if (!suppress_logs_for_fuzzer_) {
-      PERFETTO_ELOG("Filter bytecode checksum failed. Expected: %x, actual: %x",
-                    expected_csum, words.back());
+    // Remove |next_chunk| from the index, unless it's a padding record (padding
+    // records are not part of the index).
+    if (PERFETTO_LIKELY(!next_chunk.is_padding)) {
+      ChunkMeta::Key key(next_chunk);
+      auto it = index_.find(key);
+      bool will_remove = false;
+      if (PERFETTO_LIKELY(it != index_.end())) {
+        const ChunkMeta& meta = it->second;
+        if (PERFETTO_UNLIKELY(meta.num_fragments_read < meta.num_fragments)) {
+          if (overwrite_policy_ == kDiscard)
+            return -1;
+          chunks_overwritten++;
+          bytes_overwritten += next_chunk.size;
+        }
+        index_delete.push_back(it);
+        will_remove = true;
+      }
+      TRACE_BUFFER_DLOG("  del index {%" PRIu32 ",%" PRIu32 ",%u} @ [%" PRIdPTR
+                        " - %" PRIdPTR "] %d",
+                        key.producer_id, key.writer_id, key.chunk_id,
+                        next_chunk_ptr - begin(),
+                        next_chunk_ptr - begin() + next_chunk.size,
+                        will_remove);
+      PERFETTO_DCHECK(will_remove);
+    } else {
+      padding_bytes_cleared += next_chunk.size;
     }
-    return false;
-  }
 
-  words.pop_back();  // Pop the checksum.
+    next_chunk_ptr += next_chunk.size;
 
-  // Temporay storage for each message. Cleared on every END_OF_MESSAGE.
-  std::vector<uint32_t> direct_indexed_fields;
-  std::vector<uint32_t> ranges;
-  uint32_t max_msg_index = 0;
+    // We should never hit this, unless we managed to screw up while writing
+    // to the buffer and breaking the ChunkRecord(s) chain.
+    // TODO(primiano): Write more meaningful logging with the status of the
+    // buffer, to get more actionable bugs in case we hit this.
+    PERFETTO_CHECK(next_chunk_ptr <= end());
+  }
 
-  auto add_directly_indexed_field = [&](uint32_t field_id, uint32_t msg_id) {
-    PERFETTO_DCHECK(field_id > 0 && field_id < kDirectlyIndexLimit);
-    direct_indexed_fields.resize(std::max(direct_indexed_fields.size(),
-                                          static_cast<size_t>(field_id) + 1));
-    direct_indexed_fields[field_id] = kAllowed | msg_id;
-  };
+  // Remove from the index.
+  for (auto it : index_delete) {
+    index_.erase(it);
+  }
+  stats_.set_chunks_overwritten(chunks_overwritten);
+  stats_.set_bytes_overwritten(bytes_overwritten);
+  stats_.set_padding_bytes_cleared(padding_bytes_cleared);
 
-  auto add_range = [&](uint32_t id_start, uint32_t id_end, uint32_t msg_id) {
-    PERFETTO_DCHECK(id_end > id_start);
-    PERFETTO_DCHECK(id_start >= kDirectlyIndexLimit);
-    ranges.emplace_back(id_start);
-    ranges.emplace_back(id_end);
-    ranges.emplace_back(kAllowed | msg_id);
-  };
+  PERFETTO_DCHECK(next_chunk_ptr >= search_end && next_chunk_ptr <= end());
+  return static_cast<ssize_t>(next_chunk_ptr - search_end);
+}
 
-  for (size_t i = 0; i < words.size(); ++i) {
-    const uint32_t word = words[i];
-    const bool has_next_word = i < words.size() - 1;
-    const uint32_t opcode = word & 0x7u;
-    const uint32_t field_id = word >> 3;
+void TraceBufferV1::AddPaddingRecord(size_t size) {
+  PERFETTO_DCHECK(size >= sizeof(ChunkRecord) && size <= ChunkRecord::kMaxSize);
+  ChunkRecord record(size);
+  record.is_padding = 1;
+  TRACE_BUFFER_DLOG("AddPaddingRecord @ [%" PRIdPTR " - %" PRIdPTR "] %zu",
+                    wptr_ - begin(), uintptr_t(wptr_ - begin()) + size, size);
+  WriteChunkRecord(wptr_, record, nullptr, size - sizeof(ChunkRecord));
+  stats_.set_padding_bytes_written(stats_.padding_bytes_written() + size);
+  // |wptr_| is deliberately not advanced when writing a padding record.
+}
 
-    if (field_id == 0 && opcode != kFilterOpcode_EndOfMessage) {
-      PERFETTO_DLOG("bytecode error @ word %zu, invalid field id (0)", i);
-      return false;
-    }
+bool TraceBufferV1::TryPatchChunkContents(ProducerID producer_id,
+                                          WriterID writer_id,
+                                          ChunkID chunk_id,
+                                          const Patch* patches,
+                                          size_t patches_size,
+                                          bool other_patches_pending) {
+  PERFETTO_CHECK(!read_only_);
+  ChunkMeta::Key key(producer_id, writer_id, chunk_id);
+  auto it = index_.find(key);
+  if (it == index_.end()) {
+    stats_.set_patches_failed(stats_.patches_failed() + 1);
+    return false;
+  }
+  ChunkMeta& chunk_meta = it->second;
 
-    if (opcode == kFilterOpcode_SimpleField ||
-        opcode == kFilterOpcode_NestedField) {
-      // Field words are organized as follow:
-      // MSB: 1 if allowed, 0 if not allowed.
-      // Remaining bits:
-      //   Message index in the case of nested (non-simple) messages.
-      //   0x7f..f in the case of simple messages.
-      uint32_t msg_id;
-      if (opcode == kFilterOpcode_SimpleField) {
-        msg_id = kSimpleField;
-      } else {  // FILTER_OPCODE_NESTED_FIELD
-        // The next word in the bytecode contains the message index.
-        if (!has_next_word) {
-          PERFETTO_DLOG("bytecode error @ word %zu: unterminated nested field",
-                        i);
-          return false;
-        }
-        msg_id = words[++i];
-        max_msg_index = std::max(max_msg_index, msg_id);
-      }
+  // Check that the index is consistent with the actual ProducerID/WriterID
+  // stored in the ChunkRecord.
 
-      if (field_id < kDirectlyIndexLimit) {
-        add_directly_indexed_field(field_id, msg_id);
-      } else {
-        // In the case of a large field id (rare) we waste an extra word and
-        // represent it as a range. Doesn't make sense to introduce extra
-        // complexity to deal with rare cases like this.
-        add_range(field_id, field_id + 1, msg_id);
-      }
-    } else if (opcode == kFilterOpcode_SimpleFieldRange) {
-      if (!has_next_word) {
-        PERFETTO_DLOG("bytecode error @ word %zu: unterminated range", i);
-        return false;
-      }
-      const uint32_t range_len = words[++i];
-      const uint32_t range_end = field_id + range_len;  // STL-style, excl.
-      uint32_t id = field_id;
+  ChunkRecord* chunk_record = GetChunkRecordAt(begin() + chunk_meta.record_off);
+  PERFETTO_DCHECK(ChunkMeta::Key(*chunk_record) == key);
+  uint8_t* chunk_begin = reinterpret_cast<uint8_t*>(chunk_record);
+  PERFETTO_DCHECK(chunk_begin >= begin());
+  uint8_t* chunk_end = chunk_begin + chunk_record->size;
+  PERFETTO_DCHECK(chunk_end <= end());
+  uint8_t* payload_begin = chunk_begin + sizeof(ChunkRecord);
+  const size_t payload_size = static_cast<size_t>(chunk_end - payload_begin);
 
-      // Here's the subtle complexity: at the bytecode level, we don't know
-      // anything about the kDirectlyIndexLimit. It is legit to define a range
-      // that spans across the direct-indexing threshold (e.g. 126-132). In that
-      // case we want to add all the elements < the indexing to the O(1) bucket
-      // and add only the remaining range as a non-indexed range.
-      for (; id < range_end && id < kDirectlyIndexLimit; ++id)
-        add_directly_indexed_field(id, kAllowed | kSimpleField);
-      PERFETTO_DCHECK(id >= kDirectlyIndexLimit || id == range_end);
-      if (id < range_end)
-        add_range(id, range_end, kSimpleField);
-    } else if (opcode == kFilterOpcode_EndOfMessage) {
-      // For each message append:
-      // 1. The "header" word telling how many directly indexed fields there
-      //    are.
-      // 2. The words for the directly indexed fields (id < 128).
-      // 3. The rest of the fields, encoded as ranges.
-      // Also update the |message_offset_| index to remember the word offset for
-      // the current message.
-      message_offset_.emplace_back(static_cast<uint32_t>(words_.size()));
-      words_.emplace_back(static_cast<uint32_t>(direct_indexed_fields.size()));
-      words_.insert(words_.end(), direct_indexed_fields.begin(),
-                    direct_indexed_fields.end());
-      words_.insert(words_.end(), ranges.begin(), ranges.end());
-      direct_indexed_fields.clear();
-      ranges.clear();
-    } else {
-      PERFETTO_DLOG("bytecode error @ word %zu: invalid opcode (%x)", i, word);
+  static_assert(Patch::kSize == SharedMemoryABI::kPacketHeaderSize,
+                "Patch::kSize out of sync with SharedMemoryABI");
+
+  for (size_t i = 0; i < patches_size; i++) {
+    const size_t offset_untrusted = patches[i].offset_untrusted;
+    if (payload_size < Patch::kSize ||
+        offset_untrusted > payload_size - Patch::kSize) {
+      // Either the IPC was so slow and in the meantime the writer managed to
+      // wrap over |chunk_id| or the producer sent a malicious IPC.
+      stats_.set_patches_failed(stats_.patches_failed() + 1);
       return false;
     }
-  }  // (for word in bytecode).
-
-  if (max_msg_index > 0 && max_msg_index >= message_offset_.size()) {
-    PERFETTO_DLOG(
-        "bytecode error: a message index (%u) is out of range "
-        "(num_messages=%zu)",
-        max_msg_index, message_offset_.size());
-    return false;
+    TRACE_BUFFER_DLOG("PatchChunk {%" PRIu32 ",%" PRIu32
+                      ",%u} size=%zu @ %zu with {%02x %02x %02x %02x}",
+                      producer_id, writer_id, chunk_id, chunk_end - chunk_begin,
+                      offset_untrusted, patches[i].data[0], patches[i].data[1],
+                      patches[i].data[2], patches[i].data[3]);
+    uint8_t* dst = payload_begin + offset_untrusted;
+    memcpy(dst, &patches[i].data[0], Patch::kSize);
   }
+  TRACE_BUFFER_DLOG("Chunk raw (after patch): %s",
+                    base::HexDump(chunk_begin, chunk_record->size).c_str());
 
-  // Add a final entry to |message_offset_| so we can tell where the last
-  // message ends without an extra branch in the Query() hotpath.
-  message_offset_.emplace_back(static_cast<uint32_t>(words_.size()));
-
+  stats_.set_patches_succeeded(stats_.patches_succeeded() + patches_size);
+  if (!other_patches_pending) {
+    chunk_meta.flags &= ~kChunkNeedsPatching;
+    chunk_record->flags = chunk_meta.flags & ChunkRecord::kFlagsBitMask;
+  }
   return true;
 }
 
-FilterBytecodeParser::QueryResult FilterBytecodeParser::Query(
-    uint32_t msg_index,
-    uint32_t field_id) {
-  FilterBytecodeParser::QueryResult res{false, 0u};
-  if (static_cast<uint64_t>(msg_index) + 1 >=
-      static_cast<uint64_t>(message_offset_.size())) {
-    return res;
+void TraceBufferV1::BeginRead() {
+  read_iter_ = GetReadIterForSequence(index_.begin());
+#if PERFETTO_DCHECK_IS_ON()
+  changed_since_last_read_ = false;
+#endif
+}
+
+TraceBufferV1::SequenceIterator TraceBufferV1::GetReadIterForSequence(
+    ChunkMap::iterator seq_begin) {
+  SequenceIterator iter;
+  iter.seq_begin = seq_begin;
+  if (seq_begin == index_.end()) {
+    iter.cur = iter.seq_end = index_.end();
+    return iter;
   }
-  const uint32_t start_offset = message_offset_[msg_index];
-  // These are DCHECKs and not just CHECKS because the |words_| is populated
-  // by the LoadInternal call above. These cannot be violated with a malformed
-  // bytecode.
-  PERFETTO_DCHECK(start_offset < words_.size());
-  const uint32_t* word = &words_[start_offset];
-  const uint32_t end_off = message_offset_[msg_index + 1];
-  const uint32_t* const end = words_.data() + end_off;
-  PERFETTO_DCHECK(end > word && end <= words_.data() + words_.size());
-  const uint32_t num_directly_indexed = *(word++);
-  PERFETTO_DCHECK(num_directly_indexed <= kDirectlyIndexLimit);
-  PERFETTO_DCHECK(word + num_directly_indexed <= end);
-  uint32_t field_state = 0;
-  if (PERFETTO_LIKELY(field_id < num_directly_indexed)) {
-    PERFETTO_DCHECK(&word[field_id] < end);
-    field_state = word[field_id];
-  } else {
-    for (word = word + num_directly_indexed; word + 2 < end;) {
-      const uint32_t range_start = *(word++);
-      const uint32_t range_end = *(word++);
-      const uint32_t range_state = *(word++);
-      if (field_id >= range_start && field_id < range_end) {
-        field_state = range_state;
-        break;
-      }
-    }  // for (word in ranges)
-  }    // if (field_id >= num_directly_indexed)
 
-  res.allowed = (field_state & kAllowed) != 0;
-  res.nested_msg_index = field_state & ~kAllowed;
-  PERFETTO_DCHECK(res.simple_field() ||
-                  res.nested_msg_index < message_offset_.size() - 1);
-  return res;
-}
+#if PERFETTO_DCHECK_IS_ON()
+  // Either |seq_begin| is == index_.begin() or the item immediately before must
+  // belong to a different {ProducerID, WriterID} sequence.
+  if (seq_begin != index_.begin() && seq_begin != index_.end()) {
+    auto prev_it = seq_begin;
+    prev_it--;
+    PERFETTO_DCHECK(
+        seq_begin == index_.begin() ||
+        std::tie(prev_it->first.producer_id, prev_it->first.writer_id) <
+            std::tie(seq_begin->first.producer_id, seq_begin->first.writer_id));
+  }
+#endif
 
-}  // namespace protozero
-// gen_amalgamated begin source: src/protozero/filtering/message_filter.cc
-// gen_amalgamated begin header: src/protozero/filtering/message_filter.h
-// gen_amalgamated begin header: src/protozero/filtering/message_tokenizer.h
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+  // Find the first entry that has a greater {ProducerID, WriterID} (or just
+  // index_.end() if we reached the end).
+  ChunkMeta::Key key = seq_begin->first;  // Deliberate copy.
+  key.chunk_id = kMaxChunkID;
+  iter.seq_end = index_.upper_bound(key);
+  PERFETTO_DCHECK(iter.seq_begin != iter.seq_end);
 
-#ifndef SRC_PROTOZERO_FILTERING_MESSAGE_TOKENIZER_H_
-#define SRC_PROTOZERO_FILTERING_MESSAGE_TOKENIZER_H_
+  // Now find the first entry between [seq_begin, seq_end) that is
+  // > last_chunk_id_written_. This is where we the sequence will start (see
+  // notes about wrapping of IDs in the header).
+  auto producer_and_writer_id = std::make_pair(key.producer_id, key.writer_id);
+  PERFETTO_DCHECK(last_chunk_id_written_.count(producer_and_writer_id));
+  iter.wrapping_id = last_chunk_id_written_[producer_and_writer_id];
+  key.chunk_id = iter.wrapping_id;
+  iter.cur = index_.upper_bound(key);
+  if (iter.cur == iter.seq_end)
+    iter.cur = iter.seq_begin;
+  return iter;
+}
 
-#include <stdint.h>
+void TraceBufferV1::SequenceIterator::MoveNext() {
+  // Stop iterating when we reach the end of the sequence.
+  // Note: |seq_begin| might be == |seq_end|.
+  if (cur == seq_end || cur->first.chunk_id == wrapping_id) {
+    cur = seq_end;
+    return;
+  }
 
-// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  // If the current chunk wasn't completed yet, we shouldn't advance past it as
+  // it may be rewritten with additional packets.
+  if (!cur->second.is_complete()) {
+    cur = seq_end;
+    return;
+  }
 
-namespace protozero {
+  ChunkID last_chunk_id = cur->first.chunk_id;
+  if (++cur == seq_end)
+    cur = seq_begin;
 
-// A helper class for schema-less tokenizing of protobuf messages.
-// This class takes a stream of proto-encoded bytes, pushed one by one in input
-// via Push(octet), and returns a stream of tokens (each Push() call can return
-// 0 or 1 token).
-// A "token" contains metadata about a field, specifically: its ID, its wire
-// type and:
-//  - For varint and fixed32/64 fields: its payload.
-//  - For string and bytes fields: the length of its payload.
-//    In this case the caller is supposed to "eat" those N bytes before calling
-//    Push() again.
-// Note that this class cannot differentiate between a string/bytes field or
-// a submessage, because they are encoded in the same way. The caller is
-// supposed to know whether a field can be recursed into by just keep calling
-// Push() or is a string that should be skipped.
-// This is inline to allow the compiler to see through the Push method and
-// avoid a function call for each byte.
-class MessageTokenizer {
- public:
-  struct Token {
-    uint32_t field_id;  // 0 == not valid.
-    proto_utils::ProtoWireType type;
+  // There may be a missing chunk in the sequence of chunks, in which case the
+  // next chunk's ID won't follow the last one's. If so, skip the rest of the
+  // sequence. We'll return to it later once the hole is filled.
+  if (last_chunk_id + 1 != cur->first.chunk_id)
+    cur = seq_end;
+}
+
+bool TraceBufferV1::ReadNextTracePacket(
+    TracePacket* packet,
+    PacketSequenceProperties* sequence_properties,
+    bool* previous_packet_on_sequence_dropped) {
+  // Note: MoveNext() moves only within the next chunk within the same
+  // {ProducerID, WriterID} sequence. Here we want to:
+  // - return the next patched+complete packet in the current sequence, if any.
+  // - return the first patched+complete packet in the next sequence, if any.
+  // - return false if none of the above is found.
+  TRACE_BUFFER_DLOG("ReadNextTracePacket()");
 
-    // For kLengthDelimited, |value| represent the length of the payload.
-    uint64_t value;
+  // Just in case we forget to initialize these below.
+  *sequence_properties = {0, ClientIdentity(), 0};
+  *previous_packet_on_sequence_dropped = false;
 
-    inline bool valid() const { return field_id != 0; }
-    bool operator==(const Token& o) const {
-      return field_id == o.field_id && type == o.type && value == o.value;
-    }
-  };
+  // At the start of each sequence iteration, we consider the last read packet
+  // dropped. While iterating over the chunks in the sequence, we update this
+  // flag based on our knowledge about the last packet that was read from each
+  // chunk (|last_read_packet_skipped| in ChunkMeta).
+  bool previous_packet_dropped = true;
 
-  // Pushes a byte in input and returns a token, only when getting to the last
-  // byte of each field. Specifically:
-  // - For varint and fixed32 fields, the Token is returned after the last byte
-  //   of the numeric payload is pushed.
-  // - For length-delimited fields, this returns after the last byte of the
-  //   length is pushed (i.e. right before the payload starts). The caller is
-  //   expected to either skip the next |value| bytes (in the case of a string
-  //   or bytes fields) or keep calling Push, in the case of a submessage.
-  inline Token Push(uint8_t octet) {
-    using protozero::proto_utils::ProtoWireType;
+#if PERFETTO_DCHECK_IS_ON()
+  PERFETTO_DCHECK(!changed_since_last_read_);
+#endif
+  for (;; read_iter_.MoveNext()) {
+    if (PERFETTO_UNLIKELY(!read_iter_.is_valid())) {
+      // We ran out of chunks in the current {ProducerID, WriterID} sequence or
+      // we just reached the index_.end().
 
-    // Parsing a fixed32/64 field is the only case where we don't have to do
-    // any varint decoding. This is why this block is before the remaining
-    // switch statement below (all the rest is a varint).
-    if (PERFETTO_UNLIKELY(state_ == kFixedIntValue)) {
-      PERFETTO_DCHECK(fixed_int_bits_ == 32 || fixed_int_bits_ == 64);
-      fixed_int_value_ |= static_cast<uint64_t>(octet) << fixed_int_shift_;
-      fixed_int_shift_ += 8;
-      if (fixed_int_shift_ < fixed_int_bits_)
-        return Token{};  // Intermediate byte of a fixed32/64.
-      auto wire_type = fixed_int_bits_ == 32 ? ProtoWireType::kFixed32
-                                             : ProtoWireType::kFixed64;
-      uint64_t fixed_int_value = fixed_int_value_;
-      fixed_int_value_ = fixed_int_shift_ = fixed_int_bits_ = 0;
-      state_ = kFieldPreamble;
-      return Token{field_id_, wire_type, fixed_int_value};
+      if (PERFETTO_UNLIKELY(read_iter_.seq_end == index_.end()))
+        return false;
+
+      // We reached the end of sequence, move to the next one.
+      // Note: ++read_iter_.seq_end might become index_.end(), but
+      // GetReadIterForSequence() knows how to deal with that.
+      read_iter_ = GetReadIterForSequence(read_iter_.seq_end);
+      PERFETTO_DCHECK(read_iter_.is_valid() && read_iter_.cur != index_.end());
+      previous_packet_dropped = true;
     }
 
-    // At this point either we are: (i) parsing a field preamble; (ii) parsing a
-    // varint field paylod; (iii) parsing the length of a length-delimited
-    // field. In all cases, we need to decode a varint before proceeding.
-    varint_ |= static_cast<uint64_t>(octet & 0x7F) << varint_shift_;
-    if (octet & 0x80) {
-      varint_shift_ += 7;
-      if (PERFETTO_UNLIKELY(varint_shift_ >= 64)) {
-        varint_shift_ = 0;
-        state_ = kInvalidVarInt;
-      }
-      return Token{};  // Still parsing a varint.
+    ChunkMeta* chunk_meta = &*read_iter_;
+
+    // If the chunk has holes that are awaiting to be patched out-of-band,
+    // skip the current sequence and move to the next one.
+    if (chunk_meta->flags & kChunkNeedsPatching) {
+      read_iter_.MoveToEnd();
+      continue;
     }
 
-    uint64_t varint = varint_;
-    varint_ = 0;
-    varint_shift_ = 0;
+    const ProducerID trusted_producer_id = read_iter_.producer_id();
+    const WriterID writer_id = read_iter_.writer_id();
+    const ProducerAndWriterID producer_and_writer_id =
+        MkProducerAndWriterID(trusted_producer_id, writer_id);
+    const ClientIdentity& client_identity = chunk_meta->client_identity_trusted;
 
-    switch (state_) {
-      case kFieldPreamble: {
-        auto field_type = static_cast<uint32_t>(varint & 7u);  // 7 = 0..0111
-        field_id_ = static_cast<uint32_t>(varint >> 3);
+    // At this point we have a chunk in |chunk_meta| that has not been fully
+    // read. We don't know yet whether we have enough data to read the full
+    // packet (in the case it's fragmented over several chunks) and we are about
+    // to find that out. Specifically:
+    // A) If the first fragment is unread and is a fragment continuing from a
+    //    previous chunk, it means we have missed the previous ChunkID. In
+    //    fact, if this wasn't the case, a previous call to ReadNext() shouldn't
+    //    have moved the cursor to this chunk.
+    // B) Any fragment > 0 && < last is always readable. By definition an inner
+    //    packet is never fragmented and hence doesn't require neither stitching
+    //    nor any out-of-band patching. The same applies to the last packet
+    //    iff it doesn't continue on the next chunk.
+    // C) If the last packet (which might be also the only packet in the chunk)
+    //    is a fragment and continues on the next chunk, we peek at the next
+    //    chunks and, if we have all of them, mark as read and move the cursor.
+    //
+    // +---------------+   +-------------------+  +---------------+
+    // | ChunkID: 1    |   | ChunkID: 2        |  | ChunkID: 3    |
+    // |---------------+   +-------------------+  +---------------+
+    // | Packet 1      |   |                   |  | ... Packet 3  |
+    // | Packet 2      |   | ... Packet 3  ... |  | Packet 4      |
+    // | Packet 3  ... |   |                   |  | Packet 5 ...  |
+    // +---------------+   +-------------------+  +---------------+
 
-        // The field type is legit, now check it's well formed and within
-        // boundaries.
-        if (field_type == static_cast<uint32_t>(ProtoWireType::kVarInt)) {
-          state_ = kVarIntValue;
-        } else if (field_type ==
-                       static_cast<uint32_t>(ProtoWireType::kFixed32) ||
-                   field_type ==
-                       static_cast<uint32_t>(ProtoWireType::kFixed64)) {
-          state_ = kFixedIntValue;
-          fixed_int_shift_ = 0;
-          fixed_int_value_ = 0;
-          fixed_int_bits_ =
-              field_type == static_cast<uint32_t>(ProtoWireType::kFixed32) ? 32
-                                                                           : 64;
-        } else if (field_type ==
-                   static_cast<uint32_t>(ProtoWireType::kLengthDelimited)) {
-          state_ = kLenDelimited;
+    PERFETTO_DCHECK(chunk_meta->num_fragments_read <=
+                    chunk_meta->num_fragments);
+
+    // If we didn't read any packets from this chunk, the last packet was from
+    // the previous chunk we iterated over; so don't update
+    // |previous_packet_dropped| in this case.
+    if (chunk_meta->num_fragments_read > 0)
+      previous_packet_dropped = chunk_meta->last_read_packet_skipped();
+
+    while (chunk_meta->num_fragments_read < chunk_meta->num_fragments) {
+      enum { kSkip = 0, kReadOnePacket, kTryReadAhead } action;
+      if (chunk_meta->num_fragments_read == 0) {
+        if (chunk_meta->flags & kFirstPacketContinuesFromPrevChunk) {
+          action = kSkip;  // Case A.
+        } else if (chunk_meta->num_fragments == 1 &&
+                   (chunk_meta->flags & kLastPacketContinuesOnNextChunk)) {
+          action = kTryReadAhead;  // Case C.
         } else {
-          state_ = kInvalidFieldType;
+          action = kReadOnePacket;  // Case B.
         }
-        return Token{};
+      } else if (chunk_meta->num_fragments_read <
+                     chunk_meta->num_fragments - 1 ||
+                 !(chunk_meta->flags & kLastPacketContinuesOnNextChunk)) {
+        action = kReadOnePacket;  // Case B.
+      } else {
+        action = kTryReadAhead;  // Case C.
       }
 
-      case kVarIntValue: {
-        // Return the varint field payload and go back to the next field.
-        state_ = kFieldPreamble;
-        return Token{field_id_, ProtoWireType::kVarInt, varint};
-      }
+      TRACE_BUFFER_DLOG("  chunk %u, packet %hu of %hu, action=%d",
+                        read_iter_.chunk_id(), chunk_meta->num_fragments_read,
+                        chunk_meta->num_fragments, action);
 
-      case kLenDelimited: {
-        const auto payload_len = varint;
-        if (payload_len > protozero::proto_utils::kMaxMessageLength) {
-          state_ = kMessageTooBig;
-          return Token{};
-        }
-        state_ = kFieldPreamble;
-        // At this point the caller is expected to consume the next
-        // |payload_len| bytes.
-        return Token{field_id_, ProtoWireType::kLengthDelimited, payload_len};
+      if (action == kSkip) {
+        // This fragment will be skipped forever, not just in this ReadPacket()
+        // iteration. This happens by virtue of ReadNextPacketInChunk()
+        // incrementing the |num_fragments_read| and marking the fragment as
+        // read even if we didn't really.
+        ReadNextPacketInChunk(producer_and_writer_id, chunk_meta, nullptr);
+        chunk_meta->set_last_read_packet_skipped(true);
+        previous_packet_dropped = true;
+        continue;
       }
 
-      case kFixedIntValue:
-        // Unreacheable because of the if before the switch.
-        PERFETTO_DCHECK(false);
-        break;
-
-      // Unrecoverable error states.
-      case kInvalidFieldType:
-      case kMessageTooBig:
-      case kInvalidVarInt:
-        break;
-    }  // switch(state_)
+      if (action == kReadOnePacket) {
+        // The easy peasy case B.
+        ReadPacketResult result =
+            ReadNextPacketInChunk(producer_and_writer_id, chunk_meta, packet);
 
-    return Token{};  // Keep GCC happy.
-  }
+        if (PERFETTO_LIKELY(result == ReadPacketResult::kSucceeded)) {
+          *sequence_properties = {trusted_producer_id, client_identity,
+                                  writer_id};
+          *previous_packet_on_sequence_dropped = previous_packet_dropped;
+          return true;
+        } else if (result == ReadPacketResult::kFailedEmptyPacket) {
+          // We can ignore and skip empty packets.
+          PERFETTO_DCHECK(packet->slices().empty());
+          continue;
+        }
 
-  // Returns true if the tokenizer FSM has reached quiescence (i.e. if we are
-  // NOT in the middle of parsing a field).
-  bool idle() const {
-    return state_ == kFieldPreamble && varint_shift_ == 0 &&
-           fixed_int_shift_ == 0;
-  }
+        // In extremely rare cases (producer bugged / malicious) the chunk might
+        // contain an invalid fragment. In such case we don't want to stall the
+        // sequence but just skip the chunk and move on. ReadNextPacketInChunk()
+        // marks the chunk as fully read, so we don't attempt to read from it
+        // again in a future call to ReadBuffers(). It also already records an
+        // abi violation for this.
+        PERFETTO_DCHECK(result == ReadPacketResult::kFailedInvalidPacket);
+        chunk_meta->set_last_read_packet_skipped(true);
+        previous_packet_dropped = true;
+        break;
+      }
 
-  // Only for reporting parser errors in the trace.
-  uint32_t state() const { return static_cast<uint32_t>(state_); }
+      PERFETTO_DCHECK(action == kTryReadAhead);
+      ReadAheadResult ra_res = ReadAhead(packet);
+      if (ra_res == ReadAheadResult::kSucceededReturnSlices) {
+        stats_.set_readaheads_succeeded(stats_.readaheads_succeeded() + 1);
+        *sequence_properties = {trusted_producer_id, client_identity,
+                                writer_id};
+        *previous_packet_on_sequence_dropped = previous_packet_dropped;
+        return true;
+      }
 
- private:
-  enum State {
-    kFieldPreamble = 0,  // Parsing the varint for the field preamble.
-    kVarIntValue = 1,    // Parsing the payload of a varint field.
-    kFixedIntValue = 2,  // Parsing the payload of a fixed32/64 field.
-    kLenDelimited = 3,   // Parsing the length of a length-delimited field.
+      if (ra_res == ReadAheadResult::kFailedMoveToNextSequence) {
+        // readahead didn't find a contiguous packet sequence. We'll try again
+        // on the next ReadPacket() call.
+        stats_.set_readaheads_failed(stats_.readaheads_failed() + 1);
 
-    // Unrecoverable error states:
-    kInvalidFieldType = 4,  // Encountered an invalid field type.
-    kMessageTooBig = 5,     // Size of the length delimited message was too big.
-    kInvalidVarInt = 6,     // Varint larger than 64 bits.
-  };
+        // TODO(primiano): optimization: this MoveToEnd() is the reason why
+        // MoveNext() (that is called in the outer for(;;MoveNext)) needs to
+        // deal gracefully with the case of |cur|==|seq_end|. Maybe we can do
+        // something to avoid that check by reshuffling the code here?
+        read_iter_.MoveToEnd();
 
-  State state_ = kFieldPreamble;
-  uint32_t field_id_ = 0;
-  uint64_t varint_ = 0;
-  uint32_t varint_shift_ = 0;
-  uint32_t fixed_int_shift_ = 0;
-  uint32_t fixed_int_bits_ = 0;
-  uint64_t fixed_int_value_ = 0;
-};
+        // This break will go back to beginning of the for(;;MoveNext()). That
+        // will move to the next sequence because we set the read iterator to
+        // its end.
+        break;
+      }
 
-}  // namespace protozero
+      PERFETTO_DCHECK(ra_res == ReadAheadResult::kFailedStayOnSameSequence);
 
-#endif  // SRC_PROTOZERO_FILTERING_MESSAGE_TOKENIZER_H_
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+      // In this case ReadAhead() might advance |read_iter_|, so we need to
+      // re-cache the |chunk_meta| pointer to point to the current chunk.
+      chunk_meta = &*read_iter_;
+      chunk_meta->set_last_read_packet_skipped(true);
+      previous_packet_dropped = true;
+    }  // while(...)  [iterate over packet fragments for the current chunk].
+  }  // for(;;MoveNext()) [iterate over chunks].
+}
 
-#ifndef SRC_PROTOZERO_FILTERING_MESSAGE_FILTER_H_
-#define SRC_PROTOZERO_FILTERING_MESSAGE_FILTER_H_
+TraceBufferV1::ReadAheadResult TraceBufferV1::ReadAhead(TracePacket* packet) {
+  static_assert(static_cast<ChunkID>(kMaxChunkID + 1) == 0,
+                "relying on kMaxChunkID to wrap naturally");
+  TRACE_BUFFER_DLOG(" readahead start @ chunk %u", read_iter_.chunk_id());
+  ChunkID next_chunk_id = read_iter_.chunk_id() + 1;
+  SequenceIterator it = read_iter_;
+  for (it.MoveNext(); it.is_valid(); it.MoveNext(), next_chunk_id++) {
+    // We should stay within the same sequence while iterating here.
+    PERFETTO_DCHECK(it.producer_id() == read_iter_.producer_id() &&
+                    it.writer_id() == read_iter_.writer_id());
 
-#include <stdint.h>
+    TRACE_BUFFER_DLOG("   expected chunk ID: %u, actual ID: %u", next_chunk_id,
+                      it.chunk_id());
 
-#include <memory>
-#include <string>
-#include <unordered_map>
+    if (PERFETTO_UNLIKELY((*it).num_fragments == 0))
+      continue;
 
-// gen_amalgamated expanded: #include "src/protozero/filtering/filter_bytecode_parser.h"
-// gen_amalgamated expanded: #include "src/protozero/filtering/message_tokenizer.h"
+    // If we miss the next chunk, stop looking in the current sequence and
+    // try another sequence. This chunk might come in the near future.
+    // The second condition is the edge case of a buggy/malicious
+    // producer. The ChunkID is contiguous but its flags don't make sense.
+    if (it.chunk_id() != next_chunk_id ||
+        PERFETTO_UNLIKELY(
+            !((*it).flags & kFirstPacketContinuesFromPrevChunk))) {
+      return ReadAheadResult::kFailedMoveToNextSequence;
+    }
 
-namespace protozero {
+    // If the chunk is contiguous but has not been patched yet move to the next
+    // sequence and try coming back here on the next ReadNextTracePacket() call.
+    // TODO(primiano): add a test to cover this, it's a subtle case.
+    if ((*it).flags & kChunkNeedsPatching)
+      return ReadAheadResult::kFailedMoveToNextSequence;
 
-// A class to filter binary-encoded proto messages using an allow-list of field
-// ids, also known as "filter bytecode". The filter determines which fields are
-// allowed to be passed through in output and strips all the other fields.
-// See go/trace-filtering for full design.
-// This class takes in input:
-// 1) The filter bytecode, loaded once via the LoadFilterBytecode() method.
-// 2) A proto-encoded binary message. The message doesn't have to be contiguous,
-//    it can be passed as an array of arbitrarily chunked fragments.
-// The FilterMessage*() method returns in output a proto message, stripping out
-// all unknown fields. If the input is malformed (e.g., unknown proto field wire
-// types, lengths out of bound) the whole filtering failed and the |error| flag
-// of the FilteredMessage object is set to true.
-// The filtering operation is based on rewriting a copy of the message into a
-// self-allocated buffer, which is then returned in the output. The input buffer
-// is NOT altered.
-// Note also that the process of rewriting the protos gets rid of most redundant
-// varint encoding (if present). So even if all fields are allow-listed, the
-// output might NOT be bitwise identical to the input (but it will be
-// semantically equivalent).
-// Furthermore the enable_field_usage_tracking() method allows to keep track of
-// a histogram of allowed / denied fields. It slows down filtering and is
-// intended only on host tools.
-class MessageFilter {
- public:
-  MessageFilter();
-  explicit MessageFilter(const MessageFilter&);
-  ~MessageFilter();
+    // This is the case of an intermediate chunk which contains only one
+    // fragment which continues on the next chunk. This is the case for large
+    // packets, e.g.: [Packet0, Packet1(0)] [Packet1(1)] [Packet1(2), ...]
+    // (Packet1(X) := fragment X of Packet1).
+    if ((*it).num_fragments == 1 &&
+        ((*it).flags & kLastPacketContinuesOnNextChunk)) {
+      continue;
+    }
 
-  struct InputSlice {
-    const void* data;
-    size_t len;
-  };
+    // We made it! We got all fragments for the packet without holes.
+    TRACE_BUFFER_DLOG("  readahead success @ chunk %u", it.chunk_id());
+    PERFETTO_DCHECK(((*it).num_fragments == 1 &&
+                     !((*it).flags & kLastPacketContinuesOnNextChunk)) ||
+                    (*it).num_fragments > 1);
 
-  struct FilteredMessage {
-    FilteredMessage(std::unique_ptr<uint8_t[]> d, size_t s)
-        : data(std::move(d)), size(s) {}
-    std::unique_ptr<uint8_t[]> data;
-    size_t size;  // The used bytes in |data|. This is <= sizeof(data).
-    bool error = false;
-  };
+    // Now let's re-iterate over the [read_iter_, it] sequence and mark
+    // all the fragments as read.
+    bool packet_corruption = false;
+    for (;;) {
+      PERFETTO_DCHECK(read_iter_.is_valid());
+      TRACE_BUFFER_DLOG("    commit chunk %u", read_iter_.chunk_id());
+      if (PERFETTO_LIKELY((*read_iter_).num_fragments > 0)) {
+        // In the unlikely case of a corrupted packet (corrupted or empty
+        // fragment), invalidate the all stitching and move on to the next chunk
+        // in the same sequence, if any.
+        auto pw_id = MkProducerAndWriterID(it.producer_id(), it.writer_id());
+        packet_corruption |=
+            ReadNextPacketInChunk(pw_id, &*read_iter_, packet) ==
+            ReadPacketResult::kFailedInvalidPacket;
+      }
+      if (read_iter_.cur == it.cur)
+        break;
+      read_iter_.MoveNext();
+    }  // for(;;)
+    PERFETTO_DCHECK(read_iter_.cur == it.cur);
 
-  // Loads the filter bytecode that will be used to filter any subsequent
-  // message. Must be called before the first call to FilterMessage*().
-  // |filter_data| must point to a byte buffer for a proto-encoded ProtoFilter
-  // message (see proto_filter.proto).
-  bool LoadFilterBytecode(const void* filter_data, size_t len);
+    if (PERFETTO_UNLIKELY(packet_corruption)) {
+      // ReadNextPacketInChunk() already records an abi violation for this case.
+      *packet = TracePacket();  // clear.
+      return ReadAheadResult::kFailedStayOnSameSequence;
+    }
 
-  // This affects the filter starting point of the subsequent FilterMessage*()
-  // calls. By default the filtering process starts from the message @ index 0,
-  // the root message passed to proto_filter when generating the bytecode
-  // (in typical tracing use-cases, this is perfetto.protos.Trace). However, the
-  // caller (TracingServiceImpl) might want to filter packets from the 2nd level
-  // (perfetto.protos.TracePacket) because the root level is pre-pended after
-  // the fact. This call allows to change the root message for the filter.
-  // The argument |field_ids| is an array of proto field ids and determines the
-  // path to the new root. For instance, in the case of [1,2,3] SetFilterRoot
-  // will identify the sub-message for the field "root.1.2.3" and use that.
-  // In order for this to succeed all the fields in the path must be allowed
-  // in the filter and must be a nested message type.
-  bool SetFilterRoot(const uint32_t* field_ids, size_t num_fields);
+    return ReadAheadResult::kSucceededReturnSlices;
+  }  // for(it...)  [readahead loop]
+  return ReadAheadResult::kFailedMoveToNextSequence;
+}
 
-  // Takes an input message, fragmented in arbitrary slices, and returns a
-  // filtered message in output.
-  FilteredMessage FilterMessageFragments(const InputSlice*, size_t num_slices);
+TraceBufferV1::ReadPacketResult TraceBufferV1::ReadNextPacketInChunk(
+    ProducerAndWriterID producer_and_writer_id,
+    ChunkMeta* const chunk_meta,
+    TracePacket* packet) {
+  PERFETTO_DCHECK(chunk_meta->num_fragments_read < chunk_meta->num_fragments);
+  PERFETTO_DCHECK(!(chunk_meta->flags & kChunkNeedsPatching));
 
-  // Helper for tests, where the input is a contiguous buffer.
-  FilteredMessage FilterMessage(const void* data, size_t len) {
-    InputSlice slice{data, len};
-    return FilterMessageFragments(&slice, 1);
-  }
+  const uint8_t* record_begin = begin() + chunk_meta->record_off;
+  DcheckIsAlignedAndWithinBounds(record_begin);
+  auto* chunk_record = reinterpret_cast<const ChunkRecord*>(record_begin);
+  const uint8_t* record_end = record_begin + chunk_record->size;
+  const uint8_t* packets_begin = record_begin + sizeof(ChunkRecord);
+  const uint8_t* packet_begin = packets_begin + chunk_meta->cur_fragment_offset;
 
-  // When enabled returns a map of "field path" to "usage counter".
-  // The key (std::string) is a binary buffer (i.e. NOT an ASCII/UTF-8 string)
-  // which contains a varint for each field. Consider the following:
-  // message Root { Sub1 f1 = 1; };
-  // message Sub1 { Sub2 f2 = 7;}
-  // message Sub2 { string f3 = 5; }
-  // The field .f1.f2.f3 will be encoded as \x01\0x07\x05.
-  // The value is the number of times that field has been encountered. If the
-  // field is not allow-listed in the bytecode (the field is stripped in output)
-  // the count will be negative.
-  void enable_field_usage_tracking(bool x) { track_field_usage_ = x; }
-  const std::unordered_map<std::string, int32_t>& field_usage() const {
-    return field_usage_;
+  if (PERFETTO_UNLIKELY(packet_begin < packets_begin ||
+                        packet_begin >= record_end)) {
+    // The producer has a bug or is malicious and did declare that the chunk
+    // contains more packets beyond its boundaries.
+    stats_.set_abi_violations(stats_.abi_violations() + 1);
+    PERFETTO_DCHECK(suppress_client_dchecks_for_testing_);
+    chunk_meta->cur_fragment_offset = 0;
+    chunk_meta->num_fragments_read = chunk_meta->num_fragments;
+    if (PERFETTO_LIKELY(chunk_meta->is_complete())) {
+      stats_.set_chunks_read(stats_.chunks_read() + 1);
+      stats_.set_bytes_read(stats_.bytes_read() + chunk_record->size);
+    }
+    return ReadPacketResult::kFailedInvalidPacket;
   }
 
-  // Exposed only for DCHECKS in TracingServiceImpl.
-  uint32_t root_msg_index() { return root_msg_index_; }
+  // A packet (or a fragment) starts with a varint stating its size, followed
+  // by its content. The varint shouldn't be larger than 4 bytes (just in case
+  // the producer is using a redundant encoding)
+  uint64_t packet_size = 0;
+  const uint8_t* header_end =
+      std::min(packet_begin + protozero::proto_utils::kMessageLengthFieldSize,
+               record_end);
+  const uint8_t* packet_data = protozero::proto_utils::ParseVarInt(
+      packet_begin, header_end, &packet_size);
 
- private:
-  // This is called by FilterMessageFragments().
-  // Inlining allows the compiler turn the per-byte call/return into a for loop,
-  // while, at the same time, keeping the code easy to read and reason about.
-  // It gives a 20-25% speedup (265ms vs 215ms for a 25MB trace).
-  void FilterOneByte(uint8_t octet) PERFETTO_ALWAYS_INLINE;
+  const uint8_t* next_packet = packet_data + packet_size;
+  if (PERFETTO_UNLIKELY(next_packet <= packet_begin ||
+                        next_packet > record_end)) {
+    // In BufferExhaustedPolicy::kDrop mode, TraceWriter may abort a fragmented
+    // packet by writing an invalid size in the last fragment's header. We
+    // should handle this case without recording an ABI violation (since Android
+    // R).
+    if (packet_size != SharedMemoryABI::kPacketSizeDropPacket) {
+      stats_.set_abi_violations(stats_.abi_violations() + 1);
+      PERFETTO_DCHECK(suppress_client_dchecks_for_testing_);
+    } else {
+      stats_.set_trace_writer_packet_loss(stats_.trace_writer_packet_loss() +
+                                          1);
+    }
+    chunk_meta->cur_fragment_offset = 0;
+    chunk_meta->num_fragments_read = chunk_meta->num_fragments;
+    if (PERFETTO_LIKELY(chunk_meta->is_complete())) {
+      stats_.set_chunks_read(stats_.chunks_read() + 1);
+      stats_.set_bytes_read(stats_.bytes_read() + chunk_record->size);
+    }
+    return ReadPacketResult::kFailedInvalidPacket;
+  }
 
-  // No-inline because this is a slowpath (only when usage tracking is enabled).
-  void IncrementCurrentFieldUsage(uint32_t field_id,
-                                  bool allowed) PERFETTO_NO_INLINE;
+  chunk_meta->cur_fragment_offset =
+      static_cast<uint16_t>(next_packet - packets_begin);
+  chunk_meta->num_fragments_read++;
 
-  // Gets into an error state which swallows all the input and emits no output.
-  void SetUnrecoverableErrorState();
+  if (PERFETTO_UNLIKELY(chunk_meta->num_fragments_read ==
+                            chunk_meta->num_fragments &&
+                        chunk_meta->is_complete())) {
+    stats_.set_chunks_read(stats_.chunks_read() + 1);
+    stats_.set_bytes_read(stats_.bytes_read() + chunk_record->size);
+    writer_stats_.Insert(producer_and_writer_id,
+                         chunk_meta->cur_fragment_offset);
+  } else {
+    // We have at least one more packet to parse. It should be within the chunk.
+    if (chunk_meta->cur_fragment_offset + sizeof(ChunkRecord) >=
+        chunk_record->size) {
+      PERFETTO_DCHECK(suppress_client_dchecks_for_testing_);
+    }
+  }
 
-  // We keep track of the nest of messages in a stack. Each StackState
-  // object corresponds to a level of nesting in the proto message structure.
-  // Every time a new field of type len-delimited that has a corresponding
-  // sub-message in the bytecode is encountered, a new StackState is pushed in
-  // |stack_|. stack_[0] is a sentinel to prevent over-popping without adding
-  // extra branches in the fastpath.
-  // |stack_|. stack_[1] is the state of the root message.
-  struct StackState {
-    uint32_t in_bytes = 0;  // Number of input bytes processed.
+  chunk_meta->set_last_read_packet_skipped(false);
 
-    // When |in_bytes| reaches this value, the current state should be popped.
-    // This is set when recursing into nested submessages. This is 0 only for
-    // stack_[0] (we don't know the size of the root message upfront).
-    uint32_t in_bytes_limit = 0;
+  if (PERFETTO_UNLIKELY(packet_size == 0))
+    return ReadPacketResult::kFailedEmptyPacket;
 
-    // This is set when a len-delimited message is encountered, either a string
-    // or a nested submessage that is NOT allow-listed in the bytecode.
-    // This causes input bytes to be consumed without being parsed from the
-    // input stream. If |passthrough_eaten_bytes| == true, they will be copied
-    // as-is in output (e.g. in the case of an allowed string/bytes field).
-    uint32_t eat_next_bytes = 0;
+  if (PERFETTO_LIKELY(packet))
+    packet->AddSlice(packet_data, static_cast<size_t>(packet_size));
 
-    // Keeps tracks of the stream_writer output counter (out_.written()) then
-    // the StackState is pushed. This is used to work out, when popping, how
-    // many bytes have been written for the current submessage.
-    uint32_t out_bytes_written_at_start = 0;
+  return ReadPacketResult::kSucceeded;
+}
 
-    uint32_t field_id = 0;   // The proto field id for the current message.
-    uint32_t msg_index = 0;  // The index of the message filter in the bytecode.
+void TraceBufferV1::DiscardWrite() {
+  PERFETTO_DCHECK(overwrite_policy_ == kDiscard);
+  discard_writes_ = true;
+  stats_.set_chunks_discarded(stats_.chunks_discarded() + 1);
+  TRACE_BUFFER_DLOG("  discarding write");
+}
 
-    // This is a pointer to the proto preamble for the current submessage
-    // (it's nullptr for stack_[0] and non-null elsewhere). This will be filled
-    // with the actual size of the message (out_.written() -
-    // |out_bytes_written_at_start|) when finishing (popping) the message.
-    // This must be filled using WriteRedundantVarint(). Note that the
-    // |size_field_len| is variable and depends on the actual length of the
-    // input message. If the output message has roughly the same size of the
-    // input message, the length will not be redundant.
-    // In other words: the length of the field is reserved when the submessage
-    // starts. At that point we know the upper-bound for the output message
-    // (a filtered submessage can be <= the original one, but not >). So we
-    // reserve as many bytes it takes to write the input length in varint.
-    // Then, when the message is finalized and we know the actual output size
-    // we backfill the field.
-    // Consider the example of a submessage where the input size = 130 (>127,
-    // 2 varint bytes) and the output is 120 bytes. The length will be 2 bytes
-    // wide even though could have been encoded with just one byte.
-    uint8_t* size_field = nullptr;
-    uint32_t size_field_len = 0;
+std::unique_ptr<TraceBuffer> TraceBufferV1::CloneReadOnly() const {
+  std::unique_ptr<TraceBufferV1> buf(new TraceBufferV1(CloneCtor(), *this));
+  if (!buf->data_.IsValid())
+    return nullptr;  // PagedMemory::Allocate() failed. We are out of memory.
+  return buf;
+}
 
-    // When true the next |eat_next_bytes| are copied as-is in output.
-    // It seems that keeping this field at the end rather than next to
-    // |eat_next_bytes| makes the filter a little (but measurably) faster.
-    // (likely something related with struct layout vs cache sizes).
-    bool passthrough_eaten_bytes = false;
-  };
+TraceBufferV1::TraceBufferV1(CloneCtor, const TraceBufferV1& src)
+    : overwrite_policy_(src.overwrite_policy_),
+      read_only_(true),
+      discard_writes_(src.discard_writes_) {
+  if (!Initialize(src.data_.size()))
+    return;  // TraceBuffer::Clone() will check |data_| and return nullptr.
 
-  uint32_t out_written() { return static_cast<uint32_t>(out_ - &out_buf_[0]); }
+  // The assignments below must be done after Initialize().
 
-  std::unique_ptr<uint8_t[]> out_buf_;
-  uint8_t* out_ = nullptr;
-  uint8_t* out_end_ = nullptr;
-  uint32_t root_msg_index_ = 0;
+  EnsureCommitted(src.used_size_);
+  memcpy(data_.Get(), src.data_.Get(), src.used_size_);
+  last_chunk_id_written_ = src.last_chunk_id_written_;
 
-  FilterBytecodeParser filter_;
-  MessageTokenizer tokenizer_;
-  std::vector<StackState> stack_;
+  stats_ = src.stats_;
+  stats_.set_bytes_read(0);
+  stats_.set_chunks_read(0);
+  stats_.set_readaheads_failed(0);
+  stats_.set_readaheads_succeeded(0);
 
-  bool error_ = false;
-  bool track_field_usage_ = false;
-  std::unordered_map<std::string, int32_t> field_usage_;
-};
+  // Copy the index of chunk metadata.
+  // NOTE: in 2025-10 the behavior of CloneReadOnly() in presence of existing
+  // reads has changed.
+  // Before: the read iterator would be reset and the cloned buffer would behave
+  //         as if no read was performed.
+  // After: the read iterators are untouched.
+  // This is done for two reasons:
+  // 1. To converge with the behavior of TraceBufferV2, which can't support the
+  //    old behavior.
+  // 2. To support properly cloning of write_into_file sessions (b/382209797).
+  index_ = ChunkMap(src.index_);
+  if constexpr (!PERFETTO_FLAGS(BUFFER_CLONE_PRESERVE_READ_ITER)) {
+    for (auto& kv : index_) {
+      ChunkMeta& chunk_meta = kv.second;
+      chunk_meta.num_fragments_read = 0;
+      chunk_meta.cur_fragment_offset = 0;
+      chunk_meta.set_last_read_packet_skipped(false);
+    }
+  }
+  read_iter_ = SequenceIterator();
+}
 
-}  // namespace protozero
+// For the virtual base class.
+TraceBuffer::~TraceBuffer() = default;
 
-#endif  // SRC_PROTOZERO_FILTERING_MESSAGE_FILTER_H_
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/service/trace_buffer_v1_with_v2_shadow.cc
+// gen_amalgamated begin header: src/tracing/service/trace_buffer_v1_with_v2_shadow.h
 /*
- * Copyright (C) 2021 The Android Open Source Project
+ * Copyright (C) 2025 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -51821,307 +58676,122 @@ class MessageFilter {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "src/protozero/filtering/message_filter.h"
-
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace protozero {
-
-namespace {
-
-// Inline helpers to append proto fields in output. They are the equivalent of
-// the protozero::Message::AppendXXX() fields but don't require building and
-// maintaining a full protozero::Message object or dealing with scattered
-// output slices.
-// All these functions assume there is enough space in the output buffer, which
-// should be always the case assuming that we don't end up generating more
-// output than input.
-
-inline void AppendVarInt(uint32_t field_id, uint64_t value, uint8_t** out) {
-  *out = proto_utils::WriteVarInt(proto_utils::MakeTagVarInt(field_id), *out);
-  *out = proto_utils::WriteVarInt(value, *out);
-}
-
-// For fixed32 / fixed64.
-template <typename INT_T /* uint32_t | uint64_t*/>
-inline void AppendFixed(uint32_t field_id, INT_T value, uint8_t** out) {
-  *out = proto_utils::WriteVarInt(proto_utils::MakeTagFixed<INT_T>(field_id),
-                                  *out);
-  memcpy(*out, &value, sizeof(value));
-  *out += sizeof(value);
-}
-
-// For length-delimited (string, bytes) fields. Note: this function appends only
-// the proto preamble and the varint field that states the length of the payload
-// not the payload itself.
-// In the case of submessages, the caller needs to re-write the length at the
-// end in the in the returned memory area.
-// The problem here is that, because of filtering, the length of a submessage
-// might be < original length (the original length is still an upper-bound).
-// Returns a pair with: (1) the pointer where the final length should be written
-// into, (2) the length of the size field.
-// The caller must write a redundant varint to match the original size (i.e.
-// needs to use WriteRedundantVarInt()).
-inline std::pair<uint8_t*, uint32_t> AppendLenDelim(uint32_t field_id,
-                                                    uint32_t len,
-                                                    uint8_t** out) {
-  *out = proto_utils::WriteVarInt(proto_utils::MakeTagLengthDelimited(field_id),
-                                  *out);
-  uint8_t* size_field_start = *out;
-  *out = proto_utils::WriteVarInt(len, *out);
-  const size_t size_field_len = static_cast<size_t>(*out - size_field_start);
-  return std::make_pair(size_field_start, size_field_len);
-}
-}  // namespace
-
-MessageFilter::MessageFilter() {
-  // Push a state on the stack for the implicit root message.
-  stack_.emplace_back();
-}
-
-MessageFilter::MessageFilter(const MessageFilter& other)
-    : root_msg_index_(other.root_msg_index_), filter_(other.filter_) {
-  stack_.emplace_back();
-}
-
-MessageFilter::~MessageFilter() = default;
-
-bool MessageFilter::LoadFilterBytecode(const void* filter_data, size_t len) {
-  return filter_.Load(filter_data, len);
-}
-
-bool MessageFilter::SetFilterRoot(const uint32_t* field_ids,
-                                  size_t num_fields) {
-  uint32_t root_msg_idx = 0;
-  for (const uint32_t* it = field_ids; it < field_ids + num_fields; ++it) {
-    uint32_t field_id = *it;
-    auto res = filter_.Query(root_msg_idx, field_id);
-    if (!res.allowed || res.simple_field())
-      return false;
-    root_msg_idx = res.nested_msg_index;
-  }
-  root_msg_index_ = root_msg_idx;
-  return true;
-}
+#ifndef SRC_TRACING_SERVICE_TRACE_BUFFER_V1_WITH_V2_SHADOW_H_
+#define SRC_TRACING_SERVICE_TRACE_BUFFER_V1_WITH_V2_SHADOW_H_
 
-MessageFilter::FilteredMessage MessageFilter::FilterMessageFragments(
-    const InputSlice* slices,
-    size_t num_slices) {
-  // First compute the upper bound for the output. The filtered message cannot
-  // be > the original message.
-  uint32_t total_len = 0;
-  for (size_t i = 0; i < num_slices; ++i)
-    total_len += slices[i].len;
-  out_buf_.reset(new uint8_t[total_len]);
-  out_ = out_buf_.get();
-  out_end_ = out_ + total_len;
+#include <memory>
+#include <unordered_set>
 
-  // Reset the parser state.
-  tokenizer_ = MessageTokenizer();
-  error_ = false;
-  stack_.clear();
-  stack_.resize(2);
-  // stack_[0] is a sentinel and should never be hit in nominal cases. If we
-  // end up there we will just keep consuming the input stream and detecting
-  // at the end, without hurting the fastpath.
-  stack_[0].in_bytes_limit = UINT32_MAX;
-  stack_[0].eat_next_bytes = UINT32_MAX;
-  // stack_[1] is the actual root message.
-  stack_[1].in_bytes_limit = total_len;
-  stack_[1].msg_index = root_msg_index_;
+// gen_amalgamated expanded: #include "perfetto/ext/base/flat_hash_map.h"
+// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer.h"
 
-  // Process the input data and write the output.
-  for (size_t slice_idx = 0; slice_idx < num_slices; ++slice_idx) {
-    const InputSlice& slice = slices[slice_idx];
-    const uint8_t* data = static_cast<const uint8_t*>(slice.data);
-    for (size_t i = 0; i < slice.len; ++i)
-      FilterOneByte(data[i]);
-  }
+namespace perfetto {
 
-  // Construct the output object.
-  PERFETTO_CHECK(out_ >= out_buf_.get() && out_ <= out_end_);
-  auto used_size = static_cast<size_t>(out_ - out_buf_.get());
-  FilteredMessage res{std::move(out_buf_), used_size};
-  res.error = error_;
-  if (stack_.size() != 1 || !tokenizer_.idle() ||
-      stack_[0].in_bytes != total_len) {
-    res.error = true;
-  }
-  return res;
-}
+class TracePacket;
 
-void MessageFilter::FilterOneByte(uint8_t octet) {
-  PERFETTO_DCHECK(!stack_.empty());
+// ****************************************************************************
+// * THIS IS A TEMPORARY CLASS FOR TESTING PURPOSES ONLY.                     *
+// * It will be removed once TraceBufferV2 is validated and fully rolled out. *
+// ****************************************************************************
+//
+// A wrapper around TraceBufferV1 that also maintains a TraceBufferV2 shadow
+// buffer for comparison purposes. All data is written to both buffers, but
+// only V1 data is returned during readback. Comparison statistics are
+// computed to validate that V2 returns equivalent data.
+//
+// The comparison works as follows:
+// - CopyChunkUntrusted/TryPatchChunkContents: forwarded to both V1 and V2
+// - BeginRead: forwarded to both. V2 is eagerly read to completion and packet
+//   hashes are stored.
+// - ReadNextTracePacket: forwarded to V1 only. Each V1 packet's hash is
+//   compared against V2 hashes.
+// - stats(): returns V1's stats with shadow comparison fields populated.
+class TraceBufferV1WithV2Shadow : public TraceBuffer {
+ public:
+  static std::unique_ptr<TraceBufferV1WithV2Shadow> Create(size_t size_in_bytes,
+                                                           OverwritePolicy);
 
-  auto* state = &stack_.back();
-  StackState next_state{};
-  bool push_next_state = false;
+  ~TraceBufferV1WithV2Shadow() override;
 
-  if (state->eat_next_bytes > 0) {
-    // This is the case where the previous tokenizer_.Push() call returned a
-    // length delimited message which is NOT a submessage (a string or a bytes
-    // field). We just want to consume it, and pass it through in output
-    // if the field was allowed.
-    --state->eat_next_bytes;
-    if (state->passthrough_eaten_bytes)
-      *(out_++) = octet;
-  } else {
-    MessageTokenizer::Token token = tokenizer_.Push(octet);
-    // |token| will not be valid() in most cases and this is WAI. When pushing
-    // a varint field, only the last byte yields a token, all the other bytes
-    // return an invalid token, they just update the internal tokenizer state.
-    if (token.valid()) {
-      auto filter = filter_.Query(state->msg_index, token.field_id);
-      switch (token.type) {
-        case proto_utils::ProtoWireType::kVarInt:
-          if (filter.allowed && filter.simple_field())
-            AppendVarInt(token.field_id, token.value, &out_);
-          break;
-        case proto_utils::ProtoWireType::kFixed32:
-          if (filter.allowed && filter.simple_field())
-            AppendFixed(token.field_id, static_cast<uint32_t>(token.value),
-                        &out_);
-          break;
-        case proto_utils::ProtoWireType::kFixed64:
-          if (filter.allowed && filter.simple_field())
-            AppendFixed(token.field_id, static_cast<uint64_t>(token.value),
-                        &out_);
-          break;
-        case proto_utils::ProtoWireType::kLengthDelimited:
-          // Here we have two cases:
-          // A. A simple string/bytes field: we just want to consume the next
-          //    bytes (the string payload), optionally passing them through in
-          //    output if the field is allowed.
-          // B. This is a nested submessage. In this case we want to recurse and
-          //    push a new state on the stack.
-          // Note that we can't tell the difference between a
-          // "non-allowed string" and a "non-allowed submessage". But it doesn't
-          // matter because in both cases we just want to skip the next N bytes.
-          const auto submessage_len = static_cast<uint32_t>(token.value);
-          auto in_bytes_left = state->in_bytes_limit - state->in_bytes - 1;
-          if (PERFETTO_UNLIKELY(submessage_len > in_bytes_left)) {
-            // This is a malicious / malformed string/bytes/submessage that
-            // claims to be larger than the outer message that contains it.
-            return SetUnrecoverableErrorState();
-          }
+  // TraceBuffer implementation - forwards to both V1 and V2.
+  void CopyChunkUntrusted(ProducerID producer_id_trusted,
+                          const ClientIdentity& client_identity_trusted,
+                          WriterID writer_id,
+                          ChunkID chunk_id,
+                          uint16_t num_fragments,
+                          uint8_t chunk_flags,
+                          bool chunk_complete,
+                          const uint8_t* src,
+                          size_t size) override;
 
-          if (filter.allowed && !filter.simple_field() && submessage_len > 0) {
-            // submessage_len == 0 is the edge case of a message with a 0-len
-            // (but present) submessage. In this case, if allowed, we don't want
-            // to push any further state (doing so would desync the FSM) but we
-            // still want to emit it.
-            // At this point |submessage_len| is only an upper bound. The
-            // final message written in output can be <= the one in input,
-            // only some of its fields might be allowed (also remember that
-            // this class implicitly removes redundancy varint encoding of
-            // len-delimited field lengths). The final length varint (the
-            // return value of AppendLenDelim()) will be filled when popping
-            // from |stack_|.
-            auto size_field =
-                AppendLenDelim(token.field_id, submessage_len, &out_);
-            push_next_state = true;
-            next_state.field_id = token.field_id;
-            next_state.msg_index = filter.nested_msg_index;
-            next_state.in_bytes_limit = submessage_len;
-            next_state.size_field = size_field.first;
-            next_state.size_field_len = size_field.second;
-            next_state.out_bytes_written_at_start = out_written();
-          } else {
-            // A string or bytes field, or a 0 length submessage.
-            state->eat_next_bytes = submessage_len;
-            state->passthrough_eaten_bytes = filter.allowed;
-            if (filter.allowed)
-              AppendLenDelim(token.field_id, submessage_len, &out_);
-          }
-          break;
-      }  // switch(type)
+  bool TryPatchChunkContents(ProducerID,
+                             WriterID,
+                             ChunkID,
+                             const Patch* patches,
+                             size_t patches_size,
+                             bool other_patches_pending) override;
 
-      if (PERFETTO_UNLIKELY(track_field_usage_)) {
-        IncrementCurrentFieldUsage(token.field_id, filter.allowed);
-      }
-    }  // if (token.valid)
-  }    // if (eat_next_bytes == 0)
+  // BeginRead forwards to both. V2 is eagerly read and hashes are stored.
+  void BeginRead() override;
 
-  ++state->in_bytes;
-  while (state->in_bytes >= state->in_bytes_limit) {
-    PERFETTO_DCHECK(state->in_bytes == state->in_bytes_limit);
-    push_next_state = false;
+  // ReadNextTracePacket forwards to V1 only. Hash comparison is performed.
+  bool ReadNextTracePacket(TracePacket*,
+                           PacketSequenceProperties* sequence_properties,
+                           bool* previous_packet_on_sequence_dropped) override;
 
-    // We can't possibly write more than we read.
-    const uint32_t msg_bytes_written = static_cast<uint32_t>(
-        out_written() - state->out_bytes_written_at_start);
-    PERFETTO_DCHECK(msg_bytes_written <= state->in_bytes_limit);
+  std::unique_ptr<TraceBuffer> CloneReadOnly() const override;
 
-    // Backfill the length field of the
-    proto_utils::WriteRedundantVarInt(msg_bytes_written, state->size_field,
-                                      state->size_field_len);
+  // Stats returns V1's stats with shadow comparison fields populated.
+  const TraceStats::BufferStats& stats() const override;
 
-    const uint32_t in_bytes_processes_for_last_msg = state->in_bytes;
-    stack_.pop_back();
-    PERFETTO_CHECK(!stack_.empty());
-    state = &stack_.back();
-    state->in_bytes += in_bytes_processes_for_last_msg;
-    if (PERFETTO_UNLIKELY(!tokenizer_.idle())) {
-      // If we hit this case, it means that we got to the end of a submessage
-      // while decoding a field. We can't recover from this and we don't want to
-      // propagate a broken sub-message.
-      return SetUnrecoverableErrorState();
-    }
-  }
+  // These all forward to V1 only.
+  void set_read_only() override;
+  const WriterStats& writer_stats() const override;
+  size_t size() const override;
+  size_t used_size() const override;
+  size_t GetMemoryUsageBytes() const override;
+  OverwritePolicy overwrite_policy() const override;
+  bool has_data() const override;
+  BufType buf_type() const override { return kV1WithV2Shadow; }
 
-  if (push_next_state) {
-    PERFETTO_DCHECK(tokenizer_.idle());
-    stack_.emplace_back(std::move(next_state));
-    state = &stack_.back();
-  }
-}
+ private:
+  TraceBufferV1WithV2Shadow();
 
-void MessageFilter::SetUnrecoverableErrorState() {
-  error_ = true;
-  stack_.clear();
-  stack_.resize(1);
-  auto& state = stack_[0];
-  state.eat_next_bytes = UINT32_MAX;
-  state.in_bytes_limit = UINT32_MAX;
-  state.passthrough_eaten_bytes = false;
-  out_ = out_buf_.get();  // Reset the write pointer.
-}
+  // Updates the shadow comparison stats in stats_.
+  void UpdateShadowStats() const;
 
-void MessageFilter::IncrementCurrentFieldUsage(uint32_t field_id,
-                                               bool allowed) {
-  // Slowpath. Used mainly in offline tools and tests to workout used fields in
-  // a proto.
-  PERFETTO_DCHECK(track_field_usage_);
+  static constexpr uint8_t kSeenInV1 = 1 << 0;
+  static constexpr uint8_t kSeenInV2 = 1 << 1;
 
-  // Field path contains a concatenation of varints, one for each nesting level.
-  // e.g. y in message Root { Sub x = 2; }; message Sub { SubSub y = 7; }
-  // is encoded as [varint(2) + varint(7)].
-  // We use varint to take the most out of SSO (small string opt). In most cases
-  // the path will fit in the on-stack 22 bytes, requiring no heap.
-  std::string field_path;
+  std::unique_ptr<TraceBuffer> v1_;
+  std::unique_ptr<TraceBuffer> v2_;
 
-  auto append_field_id = [&field_path](uint32_t id) {
-    uint8_t buf[10];
-    uint8_t* end = proto_utils::WriteVarInt(id, buf);
-    field_path.append(reinterpret_cast<char*>(buf),
-                      static_cast<size_t>(end - buf));
+  struct HashPacketCounts {
+    uint16_t seen_in_v1 = 0;
+    uint16_t seen_in_v2 = 0;
   };
+  base::FlatHashMap<uint64_t,
+                    HashPacketCounts,
+                    base::AlreadyHashed<uint64_t>,
+                    base::QuadraticProbe,
+                    /*AppendOnly=*/true>
+      packet_hashes_;
+  uint64_t packets_seen_ = 0;
+
+  // Patch statistics.
+  uint64_t patches_attempted_ = 0;
+  uint64_t v1_patches_succeeded_ = 0;
+  uint64_t v2_patches_succeeded_ = 0;
+
+  // Cached stats that combines V1 stats with shadow comparison results.
+  mutable TraceStats::BufferStats stats_;
+};
 
-  // Append all the ancestors IDs from the state stack.
-  // The first entry of the stack has always ID 0 and we skip it (we don't know
-  // the ID of the root message itself).
-  PERFETTO_DCHECK(stack_.size() >= 2 && stack_[1].field_id == 0);
-  for (size_t i = 2; i < stack_.size(); ++i)
-    append_field_id(stack_[i].field_id);
-  // Append the id of the field in the current message.
-  append_field_id(field_id);
-  field_usage_[field_path] += allowed ? 1 : -1;
-}
+}  // namespace perfetto
 
-}  // namespace protozero
-// gen_amalgamated begin source: src/tracing/core/metatrace_writer.cc
-// gen_amalgamated begin header: src/tracing/core/metatrace_writer.h
+#endif  // SRC_TRACING_SERVICE_TRACE_BUFFER_V1_WITH_V2_SHADOW_H_
+// gen_amalgamated begin header: src/tracing/service/trace_buffer_v2.h
+// gen_amalgamated begin header: include/perfetto/ext/base/circular_queue.h
 /*
  * Copyright (C) 2019 The Android Open Source Project
  *
@@ -52138,792 +58808,385 @@ void MessageFilter::IncrementCurrentFieldUsage(uint32_t field_id,
  * limitations under the License.
  */
 
-#ifndef SRC_TRACING_CORE_METATRACE_WRITER_H_
-#define SRC_TRACING_CORE_METATRACE_WRITER_H_
+#ifndef INCLUDE_PERFETTO_EXT_BASE_CIRCULAR_QUEUE_H_
+#define INCLUDE_PERFETTO_EXT_BASE_CIRCULAR_QUEUE_H_
+
+#include <stdint.h>
+#include <stdlib.h>
+
+#include <algorithm>
+#include <cstddef>
+#include <iterator>
+
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
+
+namespace perfetto {
+namespace base {
+
+// CircularQueue is a push-back-only / pop-front-only queue with the following
+// characteristics:
+// - The storage is based on a flat circular buffer. Beginning and end wrap
+//   as necessary, to keep pushes and pops O(1) as long as capacity expansion is
+//   not required.
+// - Capacity is automatically expanded like in a std::vector. Expansion has a
+//   O(N) cost.
+// - It allows random access, allowing in-place std::sort.
+// - Iterators are not stable. Mutating the container invalidates all iterators.
+// - It doesn't bother with const-correctness.
+//
+// Implementation details:
+// Internally, |begin|, |end| and iterators use 64-bit monotonic indexes, which
+// are incremented as if the queue was backed by unlimited storage.
+// Even assuming that elements are inserted and removed every nanosecond, 64 bit
+// is enough for 584 years.
+// Wrapping happens only when addressing elements in the underlying circular
+// storage. This limits the complexity and avoiding dealing with modular
+// arithmetic all over the places.
+template <class T>
+class CircularQueue {
+ public:
+  class Iterator {
+   public:
+    using difference_type = ptrdiff_t;
+    using value_type = T;
+    using pointer = T*;
+    using reference = T&;
+    using iterator_category = std::random_access_iterator_tag;
+
+    Iterator(CircularQueue* queue, uint64_t pos, uint32_t generation)
+        : queue_(queue),
+          pos_(pos)
+#if PERFETTO_DCHECK_IS_ON()
+          ,
+          generation_(generation)
+#endif
+    {
+      ignore_result(generation);
+    }
+
+    Iterator(const Iterator&) noexcept = default;
+    Iterator& operator=(const Iterator&) noexcept = default;
+    Iterator(Iterator&&) noexcept = default;
+    Iterator& operator=(Iterator&&) noexcept = default;
+
+    T* operator->() const {
+#if PERFETTO_DCHECK_IS_ON()
+      PERFETTO_DCHECK(generation_ == queue_->generation());
+#endif
+      return queue_->Get(pos_);
+    }
+
+    T& operator*() const { return *(operator->()); }
+
+    value_type& operator[](difference_type i) { return *(*this + i); }
+
+    Iterator& operator++() {
+      Add(1);
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      Iterator ret = *this;
+      Add(1);
+      return ret;
+    }
+
+    Iterator& operator--() {
+      Add(-1);
+      return *this;
+    }
+
+    Iterator operator--(int) {
+      Iterator ret = *this;
+      Add(-1);
+      return ret;
+    }
+
+    friend Iterator operator+(const Iterator& iter, difference_type offset) {
+      Iterator ret = iter;
+      ret.Add(offset);
+      return ret;
+    }
+
+    Iterator& operator+=(difference_type offset) {
+      Add(offset);
+      return *this;
+    }
+
+    friend Iterator operator-(const Iterator& iter, difference_type offset) {
+      Iterator ret = iter;
+      ret.Add(-offset);
+      return ret;
+    }
+
+    Iterator& operator-=(difference_type offset) {
+      Add(-offset);
+      return *this;
+    }
+
+    friend ptrdiff_t operator-(const Iterator& lhs, const Iterator& rhs) {
+      return static_cast<ptrdiff_t>(lhs.pos_) -
+             static_cast<ptrdiff_t>(rhs.pos_);
+    }
+
+    friend bool operator==(const Iterator& lhs, const Iterator& rhs) {
+      return lhs.pos_ == rhs.pos_;
+    }
+
+    friend bool operator!=(const Iterator& lhs, const Iterator& rhs) {
+      return lhs.pos_ != rhs.pos_;
+    }
+
+    friend bool operator<(const Iterator& lhs, const Iterator& rhs) {
+      return lhs.pos_ < rhs.pos_;
+    }
+
+    friend bool operator<=(const Iterator& lhs, const Iterator& rhs) {
+      return lhs.pos_ <= rhs.pos_;
+    }
 
-#include <functional>
-#include <memory>
+    friend bool operator>(const Iterator& lhs, const Iterator& rhs) {
+      return lhs.pos_ > rhs.pos_;
+    }
 
-// gen_amalgamated expanded: #include "perfetto/ext/base/metatrace.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/thread_checker.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/weak_ptr.h"
+    friend bool operator>=(const Iterator& lhs, const Iterator& rhs) {
+      return lhs.pos_ >= rhs.pos_;
+    }
 
-namespace perfetto {
+   private:
+    friend class CircularQueue<T>;
 
-namespace base {
-class TaskRunner;
-}
+    inline void Add(difference_type offset) {
+      pos_ = static_cast<uint64_t>(static_cast<difference_type>(pos_) + offset);
+      PERFETTO_DCHECK(pos_ <= queue_->end_);
+    }
 
-class TraceWriter;
+    CircularQueue* queue_;
+    uint64_t pos_;
 
-// Complements the base::metatrace infrastructure.
-// It hooks a callback to metatrace::Enable() and writes metatrace events into
-// a TraceWriter whenever the metatrace ring buffer is half full.
-// It is safe to create and attempt to start multiple instances of this class,
-// however only the first one will succeed because the metatrace framework
-// doesn't support multiple instances.
-// This class is defined here (instead of directly in src/probes/) so it can
-// be reused by other components (e.g. heapprofd).
-class MetatraceWriter {
- public:
-  static constexpr char kDataSourceName[] = "perfetto.metatrace";
+#if PERFETTO_DCHECK_IS_ON()
+    uint32_t generation_;
+#endif
+  };
 
-  MetatraceWriter();
-  ~MetatraceWriter();
+  using ReverseIterator = std::reverse_iterator<Iterator>;
+  using value_type = T;
+  using const_iterator = Iterator;
+  using iterator = Iterator;
 
-  MetatraceWriter(const MetatraceWriter&) = delete;
-  MetatraceWriter& operator=(const MetatraceWriter&) = delete;
-  MetatraceWriter(MetatraceWriter&&) = delete;
-  MetatraceWriter& operator=(MetatraceWriter&&) = delete;
+  explicit CircularQueue(size_t initial_capacity = 1024) {
+    Grow(initial_capacity);
+  }
 
-  void Enable(base::TaskRunner*, std::unique_ptr<TraceWriter>, uint32_t tags);
-  void Disable();
-  void WriteAllAndFlushTraceWriter(std::function<void()> callback);
+  CircularQueue(CircularQueue&& other) noexcept
+      : entries_(std::move(other.entries_)),
+        capacity_(other.capacity_),
+        begin_(other.begin_),
+        end_(other.end_) {
+    increment_generation();
+    new (&other) CircularQueue();  // Reset the old queue so it's still usable.
+  }
 
- private:
-  void WriteAllAvailableEvents();
+  CircularQueue& operator=(CircularQueue&& other) noexcept {
+    this->~CircularQueue();                      // Destroy the current state.
+    new (this) CircularQueue(std::move(other));  // Use the move ctor above.
+    return *this;
+  }
 
-  bool started_ = false;
-  base::TaskRunner* task_runner_ = nullptr;
-  std::unique_ptr<TraceWriter> trace_writer_;
-  PERFETTO_THREAD_CHECKER(thread_checker_)
-  base::WeakPtrFactory<MetatraceWriter> weak_ptr_factory_;  // Keep last.
-};
+  explicit CircularQueue(const CircularQueue& other) noexcept {
+    Grow(other.capacity());
+    for (const auto& e : const_cast<CircularQueue&>(other))
+      emplace_back(e);
+    PERFETTO_DCHECK(size() == other.size());
+  }
 
-}  // namespace perfetto
+  CircularQueue& operator=(const CircularQueue& other) noexcept {
+    this->~CircularQueue();           // Destroy the current state.
+    new (this) CircularQueue(other);  // Use the copy ctor above.
+    return *this;
+  }
 
-#endif  // SRC_TRACING_CORE_METATRACE_WRITER_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/perfetto/perfetto_metatrace.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+  ~CircularQueue() {
+    if (!entries_) {
+      PERFETTO_DCHECK(empty());
+      return;
+    }
+    clear();  // Invoke destructors on all alive entries.
+    PERFETTO_DCHECK(empty());
+  }
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PERFETTO_PERFETTO_METATRACE_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PERFETTO_PERFETTO_METATRACE_PROTO_H_
+  template <typename... Args>
+  void emplace_back(Args&&... args) {
+    increment_generation();
+    if (PERFETTO_UNLIKELY(size() >= capacity_))
+      Grow();
+    T* slot = Get(end_++);
+    new (slot) T(std::forward<Args>(args)...);
+  }
 
-#include <stddef.h>
-#include <stdint.h>
+  void erase_front(size_t n) {
+    increment_generation();
+    for (; n && (begin_ < end_); --n) {
+      Get(begin_)->~T();
+      begin_++;  // This needs to be its own statement, Get() checks begin_.
+    }
+  }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  void pop_front() { erase_front(1); }
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  void InsertBefore(Iterator pos, T value) {
+    increment_generation();
+    PERFETTO_DCHECK(pos.queue_ == this);
+    PERFETTO_DCHECK(pos.pos_ >= begin_ && pos.pos_ <= end_);
 
-class PerfettoMetatrace_Arg;
-class PerfettoMetatrace_InternedString;
+    // Convert to relative position before potential Grow(), which rebases
+    // begin_ to 0.
+    uint64_t relative_pos = pos.pos_ - begin_;
 
-class PerfettoMetatrace_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  PerfettoMetatrace_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit PerfettoMetatrace_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit PerfettoMetatrace_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_event_id() const { return at<1>().valid(); }
-  uint32_t event_id() const { return at<1>().as_uint32(); }
-  bool has_counter_id() const { return at<2>().valid(); }
-  uint32_t counter_id() const { return at<2>().as_uint32(); }
-  bool has_event_name() const { return at<8>().valid(); }
-  ::protozero::ConstChars event_name() const { return at<8>().as_string(); }
-  bool has_event_name_iid() const { return at<11>().valid(); }
-  uint64_t event_name_iid() const { return at<11>().as_uint64(); }
-  bool has_counter_name() const { return at<9>().valid(); }
-  ::protozero::ConstChars counter_name() const { return at<9>().as_string(); }
-  bool has_event_duration_ns() const { return at<3>().valid(); }
-  uint64_t event_duration_ns() const { return at<3>().as_uint64(); }
-  bool has_counter_value() const { return at<4>().valid(); }
-  int32_t counter_value() const { return at<4>().as_int32(); }
-  bool has_thread_id() const { return at<5>().valid(); }
-  uint32_t thread_id() const { return at<5>().as_uint32(); }
-  bool has_has_overruns() const { return at<6>().valid(); }
-  bool has_overruns() const { return at<6>().as_bool(); }
-  bool has_args() const { return at<7>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> args() const { return GetRepeated<::protozero::ConstBytes>(7); }
-  bool has_interned_strings() const { return at<10>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> interned_strings() const { return GetRepeated<::protozero::ConstBytes>(10); }
-};
+    if (PERFETTO_UNLIKELY(size() >= capacity_))
+      Grow();
 
-class PerfettoMetatrace : public ::protozero::Message {
- public:
-  using Decoder = PerfettoMetatrace_Decoder;
-  enum : int32_t {
-    kEventIdFieldNumber = 1,
-    kCounterIdFieldNumber = 2,
-    kEventNameFieldNumber = 8,
-    kEventNameIidFieldNumber = 11,
-    kCounterNameFieldNumber = 9,
-    kEventDurationNsFieldNumber = 3,
-    kCounterValueFieldNumber = 4,
-    kThreadIdFieldNumber = 5,
-    kHasOverrunsFieldNumber = 6,
-    kArgsFieldNumber = 7,
-    kInternedStringsFieldNumber = 10,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.PerfettoMetatrace"; }
-
-  using Arg = ::perfetto::protos::pbzero::PerfettoMetatrace_Arg;
-  using InternedString = ::perfetto::protos::pbzero::PerfettoMetatrace_InternedString;
-
-  using FieldMetadata_EventId =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      PerfettoMetatrace>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EventId kEventId() { return {}; }
-  void set_event_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EventId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_CounterId =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      PerfettoMetatrace>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CounterId kCounterId() { return {}; }
-  void set_counter_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CounterId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_EventName =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      PerfettoMetatrace>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EventName kEventName() { return {}; }
-  void set_event_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_EventName::kFieldId, data, size);
-  }
-  void set_event_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_EventName::kFieldId, chars.data, chars.size);
-  }
-  void set_event_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_EventName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_EventNameIid =
-    ::protozero::proto_utils::FieldMetadata<
-      11,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      PerfettoMetatrace>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EventNameIid kEventNameIid() { return {}; }
-  void set_event_name_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EventNameIid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_CounterName =
-    ::protozero::proto_utils::FieldMetadata<
-      9,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      PerfettoMetatrace>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CounterName kCounterName() { return {}; }
-  void set_counter_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_CounterName::kFieldId, data, size);
-  }
-  void set_counter_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_CounterName::kFieldId, chars.data, chars.size);
-  }
-  void set_counter_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_CounterName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_EventDurationNs =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      PerfettoMetatrace>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EventDurationNs kEventDurationNs() { return {}; }
-  void set_event_duration_ns(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EventDurationNs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_CounterValue =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      PerfettoMetatrace>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CounterValue kCounterValue() { return {}; }
-  void set_counter_value(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CounterValue::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ThreadId =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      PerfettoMetatrace>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThreadId kThreadId() { return {}; }
-  void set_thread_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ThreadId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_HasOverruns =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      PerfettoMetatrace>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HasOverruns kHasOverruns() { return {}; }
-  void set_has_overruns(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_HasOverruns::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Args =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      PerfettoMetatrace_Arg,
-      PerfettoMetatrace>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Args kArgs() { return {}; }
-  template <typename T = PerfettoMetatrace_Arg> T* add_args() {
-    return BeginNestedMessage<T>(7);
-  }
-
-
-  using FieldMetadata_InternedStrings =
-    ::protozero::proto_utils::FieldMetadata<
-      10,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      PerfettoMetatrace_InternedString,
-      PerfettoMetatrace>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InternedStrings kInternedStrings() { return {}; }
-  template <typename T = PerfettoMetatrace_InternedString> T* add_interned_strings() {
-    return BeginNestedMessage<T>(10);
+    // Calculate the actual insertion position (relative_pos from current
+    // begin_).
+    uint64_t insert_pos = begin_ + relative_pos;
+
+    // Move all elements one step forward from end_ - 1 to insert_pos.
+    for (uint64_t i = end_++; i > insert_pos; --i) {
+      T* dst = Get(i);
+      T* src = Get(i - 1);
+      new (dst) T(std::move(*src));
+      src->~T();
+    }
+
+    // Place the new value at insert_pos.
+    new (Get(insert_pos)) T(std::move(value));
   }
 
-};
+  void InsertAfter(ReverseIterator pos, T value) {
+    InsertBefore(pos.base(), std::move(value));
+  }
 
-class PerfettoMetatrace_InternedString_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  PerfettoMetatrace_InternedString_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit PerfettoMetatrace_InternedString_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit PerfettoMetatrace_InternedString_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_iid() const { return at<1>().valid(); }
-  uint64_t iid() const { return at<1>().as_uint64(); }
-  bool has_value() const { return at<2>().valid(); }
-  ::protozero::ConstChars value() const { return at<2>().as_string(); }
-};
+  void clear() { erase_front(size()); }
 
-class PerfettoMetatrace_InternedString : public ::protozero::Message {
- public:
-  using Decoder = PerfettoMetatrace_InternedString_Decoder;
-  enum : int32_t {
-    kIidFieldNumber = 1,
-    kValueFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.PerfettoMetatrace.InternedString"; }
-
-
-  using FieldMetadata_Iid =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      PerfettoMetatrace_InternedString>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Iid kIid() { return {}; }
-  void set_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Value =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      PerfettoMetatrace_InternedString>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
-  }
-  void set_value(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
-  }
-  void set_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
+  void shrink_to_fit() {
+    // We only bother shrinking if we can fit in quarter of the capacity we are
+    // currently using. Moreover, don't bother shrinking below 4096 elements as
+    // that will cause a lot of reallocations for little benefit.
+    if (size() > capacity() / 2 || capacity() <= 4096) {
+      return;
+    }
+    ChangeCapacity(capacity() / 2);
   }
-};
 
-class PerfettoMetatrace_Arg_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  PerfettoMetatrace_Arg_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit PerfettoMetatrace_Arg_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit PerfettoMetatrace_Arg_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_key() const { return at<1>().valid(); }
-  ::protozero::ConstChars key() const { return at<1>().as_string(); }
-  bool has_key_iid() const { return at<3>().valid(); }
-  uint64_t key_iid() const { return at<3>().as_uint64(); }
-  bool has_value() const { return at<2>().valid(); }
-  ::protozero::ConstChars value() const { return at<2>().as_string(); }
-  bool has_value_iid() const { return at<4>().valid(); }
-  uint64_t value_iid() const { return at<4>().as_uint64(); }
-};
+  T& at(size_t idx) {
+    PERFETTO_DCHECK(idx < size());
+    return *Get(begin_ + idx);
+  }
 
-class PerfettoMetatrace_Arg : public ::protozero::Message {
- public:
-  using Decoder = PerfettoMetatrace_Arg_Decoder;
-  enum : int32_t {
-    kKeyFieldNumber = 1,
-    kKeyIidFieldNumber = 3,
-    kValueFieldNumber = 2,
-    kValueIidFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.PerfettoMetatrace.Arg"; }
-
-
-  using FieldMetadata_Key =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      PerfettoMetatrace_Arg>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Key kKey() { return {}; }
-  void set_key(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Key::kFieldId, data, size);
-  }
-  void set_key(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Key::kFieldId, chars.data, chars.size);
-  }
-  void set_key(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_KeyIid =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      PerfettoMetatrace_Arg>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KeyIid kKeyIid() { return {}; }
-  void set_key_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_KeyIid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Value =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      PerfettoMetatrace_Arg>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
-  }
-  void set_value(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
-  }
-  void set_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ValueIid =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      PerfettoMetatrace_Arg>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ValueIid kValueIid() { return {}; }
-  void set_value_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ValueIid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
+  Iterator begin() { return Iterator(this, begin_, generation()); }
+  Iterator end() { return Iterator(this, end_, generation()); }
+  Iterator begin() const {
+    return Iterator(const_cast<CircularQueue*>(this), begin_, generation());
+  }
+  Iterator end() const {
+    return Iterator(const_cast<CircularQueue*>(this), end_, generation());
   }
-};
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+  ReverseIterator rbegin() { return ReverseIterator(end()); }
+  ReverseIterator rend() { return ReverseIterator(begin()); }
 
-// gen_amalgamated expanded: #include "src/tracing/core/metatrace_writer.h"
+  Iterator Find(const T& value) {
+    auto it = std::find(begin(), end(), value);
+    return it;
+  }
 
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_writer.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_descriptor.h"
+  T& front() { return *begin(); }
+  T& back() { return *(end() - 1); }
 
-// gen_amalgamated expanded: #include "protos/perfetto/trace/perfetto/perfetto_metatrace.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h"
+  bool empty() const { return size() == 0; }
 
-namespace perfetto {
+  size_t size() const {
+    PERFETTO_DCHECK(end_ - begin_ <= capacity_);
+    return static_cast<size_t>(end_ - begin_);
+  }
 
-#if !PERFETTO_IS_AT_LEAST_CPP17()
-// static
-constexpr char MetatraceWriter::kDataSourceName[];
+  size_t capacity() const { return capacity_; }
+
+#if PERFETTO_DCHECK_IS_ON()
+  uint32_t generation() const { return generation_; }
+  void increment_generation() { ++generation_; }
+#else
+  uint32_t generation() const { return 0; }
+  void increment_generation() {}
 #endif
 
-MetatraceWriter::MetatraceWriter() : weak_ptr_factory_(this) {}
+ private:
+  void Grow(size_t new_capacity = 0) {
+    // Capacity must be always a power of two. This allows Get() to use a simple
+    // bitwise-AND for handling the wrapping instead of a full division.
+    new_capacity = new_capacity ? new_capacity : capacity_ * 2;
+    PERFETTO_CHECK((new_capacity & (new_capacity - 1)) == 0);  // Must be pow2.
 
-MetatraceWriter::~MetatraceWriter() {
-  Disable();
-}
+    // On 32-bit systems this might hit the 4GB wall and overflow. We can't do
+    // anything other than crash in this case.
+    PERFETTO_CHECK(new_capacity > capacity_);
 
-void MetatraceWriter::Enable(base::TaskRunner* task_runner,
-                             std::unique_ptr<TraceWriter> trace_writer,
-                             uint32_t tags) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  if (started_) {
-    PERFETTO_DFATAL_OR_ELOG("Metatrace already started from this instance");
-    return;
+    ChangeCapacity(new_capacity);
   }
-  task_runner_ = task_runner;
-  trace_writer_ = std::move(trace_writer);
-  auto weak_ptr = weak_ptr_factory_.GetWeakPtr();
-  bool enabled = metatrace::Enable(
-      [weak_ptr] {
-        if (weak_ptr)
-          weak_ptr->WriteAllAvailableEvents();
-      },
-      task_runner, tags);
-  if (!enabled)
-    return;
-  started_ = true;
-}
 
-void MetatraceWriter::Disable() {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  if (!started_)
-    return;
-  metatrace::Disable();
-  started_ = false;
-  trace_writer_.reset();
-}
+  void ChangeCapacity(size_t new_capacity) {
+    // We should still have enough space to fit all the elements in the queue.
+    PERFETTO_CHECK(new_capacity >= size());
 
-void MetatraceWriter::WriteAllAvailableEvents() {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  if (!started_)
-    return;
-  for (auto it = metatrace::RingBuffer::GetReadIterator(); it; ++it) {
-    auto type_and_id = it->type_and_id.load(std::memory_order_acquire);
-    if (type_and_id == 0)
-      break;  // Stop at the first incomplete event.
+    AlignedUniquePtr<T[]> new_vec = AlignedAllocTyped<T[]>(new_capacity);
 
-    auto packet = trace_writer_->NewTracePacket();
-    packet->set_timestamp(it->timestamp_ns());
-    auto* evt = packet->set_perfetto_metatrace();
-    uint16_t type = type_and_id & metatrace::Record::kTypeMask;
-    uint16_t id = type_and_id & ~metatrace::Record::kTypeMask;
-    if (type == metatrace::Record::kTypeCounter) {
-      evt->set_counter_id(id);
-      evt->set_counter_value(it->counter_value);
-    } else {
-      evt->set_event_id(id);
-      evt->set_event_duration_ns(it->duration_ns);
-    }
+    // Move all elements in the expanded array.
+    size_t new_size = 0;
+    for (uint64_t i = begin_; i < end_; i++)
+      new (&new_vec[new_size++]) T(std::move(*Get(i)));  // Placement move ctor.
 
-    evt->set_thread_id(static_cast<uint32_t>(it->thread_id));
+    // Even if all the elements are std::move()-d and likely empty, we are still
+    // required to call the dtor for them.
+    for (uint64_t i = begin_; i < end_; i++)
+      Get(i)->~T();
 
-    if (metatrace::RingBuffer::has_overruns())
-      evt->set_has_overruns(true);
+    begin_ = 0;
+    end_ = new_size;
+    capacity_ = new_capacity;
+    entries_ = std::move(new_vec);
   }
-  // The |it| destructor will automatically update the read index position in
-  // the meta-trace ring buffer.
-}
-
-void MetatraceWriter::WriteAllAndFlushTraceWriter(
-    std::function<void()> callback) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  if (!started_)
-    return;
-  WriteAllAvailableEvents();
-  trace_writer_->Flush(std::move(callback));
-}
-
-}  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/core/packet_stream_validator.cc
-// gen_amalgamated begin header: src/tracing/core/packet_stream_validator.h
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SRC_TRACING_CORE_PACKET_STREAM_VALIDATOR_H_
-#define SRC_TRACING_CORE_PACKET_STREAM_VALIDATOR_H_
 
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/slice.h"
+  inline T* Get(uint64_t pos) {
+    PERFETTO_DCHECK(pos >= begin_ && pos < end_);
+    PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0);  // Must be a pow2.
+    auto index = static_cast<size_t>(pos & (capacity_ - 1));
+    return &entries_[index];
+  }
 
-namespace perfetto {
+  // Underlying storage. It's raw malloc-ed rather than being a unique_ptr<T[]>
+  // to allow having uninitialized entries inside it.
+  AlignedUniquePtr<T[]> entries_;
+  size_t capacity_ = 0;  // Number of allocated slots (NOT bytes) in |entries_|.
 
-// Checks that the stream of trace packets sent by the producer is well formed.
-// This includes:
-//
-// - Checking that the packets are not truncated.
-// - There are no dangling bytes left over in the packets.
-// - Any trusted fields (e.g., uid) are not set.
-//
-// Note that we only validate top-level fields in the trace proto; sub-messages
-// are simply skipped.
-class PacketStreamValidator {
- public:
-  PacketStreamValidator() = delete;
+  // The |begin_| and |end_| indexes are monotonic and never wrap. Modular arith
+  // is used only when dereferencing entries in the vector.
+  uint64_t begin_ = 0;
+  uint64_t end_ = 0;
 
-  static bool Validate(const Slices&);
+// Generation is used in debug builds only for checking iterator validity.
+#if PERFETTO_DCHECK_IS_ON()
+  uint32_t generation_ = 0;
+#endif
 };
 
+}  // namespace base
 }  // namespace perfetto
 
-#endif  // SRC_TRACING_CORE_PACKET_STREAM_VALIDATOR_H_
+#endif  // INCLUDE_PERFETTO_EXT_BASE_CIRCULAR_QUEUE_H_
+// gen_amalgamated begin header: include/perfetto/ext/base/small_vector.h
 /*
- * Copyright (C) 2018 The Android Open Source Project
+ * Copyright (C) 2021 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -52938,189 +59201,188 @@ class PacketStreamValidator {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "src/tracing/core/packet_stream_validator.h"
-
-#include <stddef.h>
+#ifndef INCLUDE_PERFETTO_EXT_BASE_SMALL_VECTOR_H_
+#define INCLUDE_PERFETTO_EXT_BASE_SMALL_VECTOR_H_
 
-#include <cinttypes>
+#include <algorithm>
+#include <type_traits>
+#include <utility>
 
+// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h"
 
 namespace perfetto {
+namespace base {
 
-namespace {
-
-using protozero::proto_utils::ProtoWireType;
+// Uses inline storage first, switches to dynamic storage when it overflows.
+template <typename T, size_t kSize>
+class SmallVector {
+ public:
+  static constexpr size_t kInlineSize = kSize;
 
-const uint32_t kReservedFieldIds[] = {
-    protos::pbzero::TracePacket::kTrustedUidFieldNumber,
-    protos::pbzero::TracePacket::kTrustedPacketSequenceIdFieldNumber,
-    protos::pbzero::TracePacket::kTraceConfigFieldNumber,
-    protos::pbzero::TracePacket::kTraceStatsFieldNumber,
-    protos::pbzero::TracePacket::kCompressedPacketsFieldNumber,
-    protos::pbzero::TracePacket::kSynchronizationMarkerFieldNumber,
-    protos::pbzero::TracePacket::kTrustedPidFieldNumber,
-};
+  explicit SmallVector() = default;
 
-// This translation unit is quite subtle and perf-sensitive. Remember to check
-// BM_PacketStreamValidator in perfetto_benchmarks when making changes.
+  ~SmallVector() {
+    clear();
+    if (PERFETTO_UNLIKELY(is_using_heap()))
+      AlignedFree(begin_);
+    begin_ = end_ = end_of_storage_ = nullptr;
+  }
 
-// Checks that a packet, spread over several slices, is well-formed and doesn't
-// contain reserved top-level fields.
-// The checking logic is based on a state-machine that skips the fields' payload
-// and operates as follows:
-//              +-------------------------------+ <-------------------------+
-// +----------> | Read field preamble (varint)  | <----------------------+  |
-// |            +-------------------------------+                        |  |
-// |              |              |            |                          |  |
-// |       <Varint>        <Fixed 32/64>     <Length-delimited field>    |  |
-// |          V                  |                      V                |  |
-// |  +------------------+       |               +--------------+        |  |
-// |  | Read field value |       |               | Read length  |        |  |
-// |  | (another varint) |       |               |   (varint)   |        |  |
-// |  +------------------+       |               +--------------+        |  |
-// |           |                 V                      V                |  |
-// +-----------+        +----------------+     +-----------------+       |  |
-//                      | Skip 4/8 Bytes |     | Skip $len Bytes |-------+  |
-//                      +----------------+     +-----------------+          |
-//                               |                                          |
-//                               +------------------------------------------+
-class ProtoFieldParserFSM {
- public:
-  // This method effectively continuously parses varints (either for the field
-  // preamble or the payload or the submessage length) and tells the caller
-  // (the Validate() method) how many bytes to skip until the next field.
-  size_t Push(uint8_t octet) {
-    varint_ |= static_cast<uint64_t>(octet & 0x7F) << varint_shift_;
-    if (octet & 0x80) {
-      varint_shift_ += 7;
-      if (varint_shift_ >= 64) {
-        // Do not invoke UB on next call.
-        varint_shift_ = 0;
-        state_ = kInvalidVarInt;
+  // Move operators.
+  SmallVector(SmallVector&& other) noexcept(
+      std::is_nothrow_move_constructible<T>::value) {
+    if (other.is_using_heap()) {
+      // Move the heap content, no need to move the individual objects as their
+      // location won't change.
+      begin_ = other.begin_;
+      end_ = other.end_;
+      end_of_storage_ = other.end_of_storage_;
+    } else {
+      const size_t other_size = other.size();
+      PERFETTO_DCHECK(other_size <= capacity());
+      for (size_t i = 0; i < other_size; i++) {
+        // Move the entries and destroy the ones in the moved-from object.
+        new (&begin_[i]) T(std::move(other.begin_[i]));
+        other.begin_[i].~T();
       }
-      return 0;
+      end_ = begin_ + other_size;
     }
-    uint64_t varint = varint_;
-    varint_ = 0;
-    varint_shift_ = 0;
-
-    switch (state_) {
-      case kFieldPreamble: {
-        uint64_t field_type = varint & 7;  // 7 = 0..0111
-        auto field_id = static_cast<uint32_t>(varint >> 3);
-        // Check if the field id is reserved, go into an error state if it is.
-        for (size_t i = 0; i < base::ArraySize(kReservedFieldIds); ++i) {
-          if (field_id == kReservedFieldIds[i]) {
-            state_ = kWroteReservedField;
-            return 0;
-          }
-        }
-        // The field type is legit, now check it's well formed and within
-        // boundaries.
-        if (field_type == static_cast<uint64_t>(ProtoWireType::kVarInt)) {
-          state_ = kVarIntValue;
-        } else if (field_type ==
-                   static_cast<uint64_t>(ProtoWireType::kFixed32)) {
-          return 4;
-        } else if (field_type ==
-                   static_cast<uint64_t>(ProtoWireType::kFixed64)) {
-          return 8;
-        } else if (field_type ==
-                   static_cast<uint64_t>(ProtoWireType::kLengthDelimited)) {
-          state_ = kLenDelimitedLen;
-        } else {
-          state_ = kUnknownFieldType;
-        }
-        return 0;
-      }
-
-      case kVarIntValue: {
-        // Consume the int field payload and go back to the next field.
-        state_ = kFieldPreamble;
-        return 0;
-      }
+    auto* const other_inline_storage = other.inline_storage_begin();
+    other.end_ = other.begin_ = other_inline_storage;
+    other.end_of_storage_ = other_inline_storage + kInlineSize;
+  }
 
-      case kLenDelimitedLen: {
-        if (varint > protozero::proto_utils::kMaxMessageLength) {
-          state_ = kMessageTooBig;
-          return 0;
-        }
-        state_ = kFieldPreamble;
-        return static_cast<size_t>(varint);
-      }
+  SmallVector& operator=(SmallVector&& other) noexcept(
+      std::is_nothrow_move_constructible<T>::value) {
+    this->~SmallVector();
+    new (this) SmallVector<T, kSize>(std::move(other));
+    return *this;
+  }
 
-      case kWroteReservedField:
-      case kUnknownFieldType:
-      case kMessageTooBig:
-      case kInvalidVarInt:
-        // Persistent error states.
-        return 0;
+  // Copy operators.
+  SmallVector(const SmallVector& other) {
+    const size_t other_size = other.size();
+    if (other_size > capacity())
+      Grow(other_size);
+    // Copy-construct the elements.
+    for (size_t i = 0; i < other_size; ++i)
+      new (&begin_[i]) T(other.begin_[i]);
+    end_ = begin_ + other_size;
+  }
 
-    }          // switch(state_)
-    return 0;  // To keep GCC happy.
+  SmallVector& operator=(const SmallVector& other) {
+    if (PERFETTO_UNLIKELY(this == &other))
+      return *this;
+    this->~SmallVector();
+    new (this) SmallVector<T, kSize>(other);
+    return *this;
   }
 
-  // Queried at the end of the all payload. A message is well-formed only
-  // if the FSM is back to the state where it should parse the next field and
-  // hasn't started parsing any preamble.
-  bool valid() const { return state_ == kFieldPreamble && varint_shift_ == 0; }
-  int state() const { return static_cast<int>(state_); }
+  T* data() { return begin_; }
+  const T* data() const { return begin_; }
 
- private:
-  enum State {
-    kFieldPreamble = 0,  // Parsing the varint for the field preamble.
-    kVarIntValue,        // Parsing the varint value for the field payload.
-    kLenDelimitedLen,    // Parsing the length of the length-delimited field.
+  T* begin() { return begin_; }
+  const T* begin() const { return begin_; }
 
-    // Error states:
-    kWroteReservedField,  // Tried to set a reserved field id.
-    kUnknownFieldType,    // Encountered an invalid field type.
-    kMessageTooBig,       // Size of the length delimited message was too big.
-    kInvalidVarInt,       // VarInt larger than 64 bits.
-  };
+  T* end() { return end_; }
+  const T* end() const { return end_; }
 
-  State state_ = kFieldPreamble;
-  uint64_t varint_ = 0;
-  uint32_t varint_shift_ = 0;
-};
+  size_t size() const { return static_cast<size_t>(end_ - begin_); }
 
-}  // namespace
+  bool empty() const { return end_ == begin_; }
 
-// static
-bool PacketStreamValidator::Validate(const Slices& slices) {
-  ProtoFieldParserFSM parser;
-  size_t skip_bytes = 0;
-  for (const Slice& slice : slices) {
-    for (size_t i = 0; i < slice.size;) {
-      const size_t skip_bytes_cur_slice = std::min(skip_bytes, slice.size - i);
-      if (skip_bytes_cur_slice > 0) {
-        i += skip_bytes_cur_slice;
-        skip_bytes -= skip_bytes_cur_slice;
-      } else {
-        uint8_t octet = *(reinterpret_cast<const uint8_t*>(slice.start) + i);
-        skip_bytes = parser.Push(octet);
-        i++;
-      }
-    }
+  size_t capacity() const {
+    return static_cast<size_t>(end_of_storage_ - begin_);
+  }
+
+  T& front() {
+    PERFETTO_DCHECK(!empty());
+    return begin_[0];
+  }
+  const T& front() const {
+    PERFETTO_DCHECK(!empty());
+    return begin_[0];
   }
-  if (skip_bytes == 0 && parser.valid())
-    return true;
 
-  PERFETTO_DLOG("Packet validation error (state %d, skip = %zu)",
-                parser.state(), skip_bytes);
-  return false;
-}
+  T& back() {
+    PERFETTO_DCHECK(!empty());
+    return end_[-1];
+  }
+  const T& back() const {
+    PERFETTO_DCHECK(!empty());
+    return end_[-1];
+  }
+
+  T& operator[](size_t index) {
+    PERFETTO_DCHECK(index < size());
+    return begin_[index];
+  }
+
+  const T& operator[](size_t index) const {
+    PERFETTO_DCHECK(index < size());
+    return begin_[index];
+  }
+
+  template <typename... Args>
+  void emplace_back(Args&&... args) {
+    T* end = end_;
+    if (PERFETTO_UNLIKELY(end == end_of_storage_))
+      end = Grow();
+    new (end) T(std::forward<Args>(args)...);
+    end_ = end + 1;
+  }
 
+  void pop_back() {
+    PERFETTO_DCHECK(!empty());
+    back().~T();
+    --end_;
+  }
+
+  // Clear without reverting back to inline storage.
+  void clear() {
+    while (!empty())
+      pop_back();
+  }
+
+ private:
+  PERFETTO_NO_INLINE T* Grow(size_t desired_capacity = 0) {
+    size_t cur_size = size();
+    size_t new_capacity = desired_capacity;
+    if (desired_capacity <= cur_size)
+      new_capacity = std::max(capacity() * 2, size_t(128));
+    T* new_storage =
+        static_cast<T*>(AlignedAlloc(alignof(T), new_capacity * sizeof(T)));
+    for (size_t i = 0; i < cur_size; ++i) {
+      // Move the elements into the new heap buffer and destroy the old ones.
+      new (&new_storage[i]) T(std::move(begin_[i]));
+      begin_[i].~T();
+    }
+    if (is_using_heap())
+      AlignedFree(begin_);
+    begin_ = new_storage;
+    end_ = new_storage + cur_size;
+    end_of_storage_ = new_storage + new_capacity;
+    return end_;
+  }
+
+  T* inline_storage_begin() { return reinterpret_cast<T*>(inline_storage_); }
+  bool is_using_heap() { return begin_ != inline_storage_begin(); }
+
+  T* begin_ = inline_storage_begin();
+  T* end_ = begin_;
+  T* end_of_storage_ = begin_ + kInlineSize;
+
+  alignas(T) char inline_storage_[sizeof(T) * kInlineSize];
+};
+
+}  // namespace base
 }  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/core/trace_buffer.cc
-// gen_amalgamated begin header: src/tracing/core/trace_buffer.h
+
+#endif  // INCLUDE_PERFETTO_EXT_BASE_SMALL_VECTOR_H_
 /*
- * Copyright (C) 2018 The Android Open Source Project
+ * Copyright (C) 2025 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -53135,159 +59397,388 @@ bool PacketStreamValidator::Validate(const Slices& slices) {
  * limitations under the License.
  */
 
-#ifndef SRC_TRACING_CORE_TRACE_BUFFER_H_
-#define SRC_TRACING_CORE_TRACE_BUFFER_H_
+#ifndef SRC_TRACING_SERVICE_TRACE_BUFFER_V2_H_
+#define SRC_TRACING_SERVICE_TRACE_BUFFER_V2_H_
 
 #include <stdint.h>
 #include <string.h>
 
-#include <array>
 #include <limits>
-#include <map>
-#include <tuple>
+#include <optional>
+#include <unordered_map>
 
+// gen_amalgamated expanded: #include "perfetto/base/flat_set.h"
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/circular_queue.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/flat_hash_map.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/paged_memory.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/small_vector.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/thread_annotations.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/client_identity.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/slice.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_packet.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_stats.h"
+// gen_amalgamated expanded: #include "src/tracing/service/histogram.h"
+// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer.h"
 
 namespace perfetto {
 
 class TracePacket;
+class TraceBufferV2;
 
-// The main buffer, owned by the tracing service, where all the trace data is
-// ultimately stored into. The service will own several instances of this class,
-// at least one per active consumer (as defined in the |buffers| section of
-// trace_config.proto) and will copy chunks from the producer's shared memory
-// buffers into here when a CommitData IPC is received.
-//
-// Writing into the buffer
-// -----------------------
-// Data is copied from the SMB(s) using CopyChunkUntrusted(). The buffer will
-// hence contain data coming from different producers and different writer
-// sequences, more specifically:
-// - The service receives data by several producer(s), identified by their ID.
-// - Each producer writes several sequences identified by the same WriterID.
-//   (they correspond to TraceWriter instances in the producer).
-// - Each Writer writes, in order, several chunks.
-// - Each chunk contains zero, one, or more TracePacket(s), or even just
-//   fragments of packets (when they span across several chunks).
-//
-// So at any point in time, the buffer will contain a variable number of logical
-// sequences identified by the {ProducerID, WriterID} tuple. Any given chunk
-// will only contain packets (or fragments) belonging to the same sequence.
-//
-// The buffer operates by default as a ring buffer.
-// It has two overwrite policies:
-//  1. kOverwrite (default): if the write pointer reaches the read pointer, old
-//     unread chunks will be overwritten by new chunks.
-//  2. kDiscard: if the write pointer reaches the read pointer, unread chunks
-//     are preserved and the new chunks are discarded. Any future write becomes
-//     a no-op, even if the reader manages to fully catch up. This is because
-//     once a chunk is discarded, the sequence of packets is broken and trying
-//     to recover would be too hard (also due to the fact that, at the same
-//     time, we allow out-of-order commits and chunk re-writes).
-//
-// Chunks are (over)written in the same order of the CopyChunkUntrusted() calls.
-// When overwriting old content, entire chunks are overwritten or clobbered.
-// The buffer never leaves a partial chunk around. Chunks' payload is copied
-// as-is, but their header is not and is repacked in order to keep the
-// ProducerID around.
-//
-// Chunks are stored in the buffer next to each other. Each chunk is prefixed by
-// an inline header (ChunkRecord), which contains most of the fields of the
-// SharedMemoryABI ChunkHeader + the ProducerID + the size of the payload.
-// It's a conventional binary object stream essentially, where each ChunkRecord
-// tells where it ends and hence where to find the next one, like this:
-//
-//          .-------------------------. 16 byte boundary
-//          | ChunkRecord:   16 bytes |
-//          | - chunk id:     4 bytes |
-//          | - producer id:  2 bytes |
-//          | - writer id:    2 bytes |
-//          | - #fragments:   2 bytes |
-//    +-----+ - record size:  2 bytes |
-//    |     | - flags+pad:    4 bytes |
-//    |     +-------------------------+
-//    |     |                         |
-//    |     :     Chunk payload       :
-//    |     |                         |
-//    |     +-------------------------+
-//    |     |    Optional padding     |
-//    +---> +-------------------------+ 16 byte boundary
-//          |      ChunkRecord        |
-//          :                         :
-// Chunks stored in the buffer are always rounded up to 16 bytes (that is
-// sizeof(ChunkRecord)), in order to avoid further inner fragmentation.
-// Special "padding" chunks can be put in the buffer, e.g. in the case when we
-// try to write a chunk of size N while the write pointer is at the end of the
-// buffer, but the write pointer is < N bytes from the end (and hence needs to
-// wrap over).
-// Because of this, the buffer is self-describing: the contents of the buffer
-// can be reconstructed by just looking at the buffer content (this will be
-// quite useful in future to recover the buffer from crash reports).
-//
-// However, in order to keep some operations (patching and reading) fast, a
-// lookaside index is maintained (in |index_|), keeping each chunk in the buffer
-// indexed by their {ProducerID, WriterID, ChunkID} tuple.
-//
-// Patching data out-of-band
-// -------------------------
-// This buffer also supports patching chunks' payload out-of-band, after they
-// have been stored. This is to allow producers to backfill the "size" fields
-// of the protos that spawn across several chunks, when the previous chunks are
-// returned to the service. The MaybePatchChunkContents() deals with the fact
-// that a chunk might have been lost (because of wrapping) by the time the OOB
-// IPC comes.
-//
-// Reading from the buffer
-// -----------------------
-// This class supports one reader only (the consumer). Reads are NOT idempotent
-// as they move the read cursors around. Reading back the buffer is the most
-// conceptually complex part. The ReadNextTracePacket() method operates with
-// whole packet granularity. Packets are returned only when all their fragments
-// are available.
-// This class takes care of:
-// - Gluing packets within the same sequence, even if they are not stored
-//   adjacently in the buffer.
-// - Re-ordering chunks within a sequence (using the ChunkID, which wraps).
-// - Detecting holes in packet fragments (because of loss of chunks).
-// Reads guarantee that packets for the same sequence are read in FIFO order
-// (according to their ChunkID), but don't give any guarantee about the read
-// order of packets from different sequences, see comments in
-// ReadNextTracePacket() below.
-class TraceBuffer {
+namespace protovm {
+class Vm;
+}
+
+namespace internal {
+
+// See /docs/design-docs/trace-buffer.md for details about the design and
+// implementation details of TraceBuffer.
+
+// +---------------------------------------------------------------------------+
+// | TBChunk                                                                   |
+// +---------------------------------------------------------------------------+
+// TBChunk is the struct, stored in the trace buffer memory as a result of
+// calling CopyChunkUntrusted from a SMB chunk.
+// TBChunk exists only in the TraceBuffer PagedMemory `data_`, never on the
+// stack or on the heap. It is followed by the fragments and alignment padding.
+// A TBChunk is very similar to a SMB chunk with the following caveats:
+// - The sizeof() both is the same (16 bytes). This is very important to keep
+//   patches offsets consistent.
+// - The SMB chunk maintains a counter of fragments. TBChunk instead does
+//   byte-based bookkeeping, as that reduces the complexity of the iterators.
+// - The layout of the fields is slightly different, but they both contains
+//   ProducerID, WriterID, ChunkID, fragment counts/sizes and flags.
+//   The SMB chunk layout is an ABI. The TCHunk layout is not: it is an
+//   implementation detail and can be changed.
+// - TBChunk maintains a basic checksum for each chunk (only for debug builds).
+struct TBChunk {
+  static constexpr size_t kMaxSize = std::numeric_limits<uint16_t>::max();
+  static uint8_t Checksum(size_t off, size_t size) {
+    // Note: the checksum must be 0 for (off=0,size=0). See the comment in
+    // ReadNextTracePacket() about the edge case of the buffer completely empty.
+    return ((off >> 24) ^ (off >> 16) ^ (off >> 8) ^ off ^ (size >> 8) ^ size) &
+           0xFF;
+  }
+
+  explicit TBChunk(size_t off, size_t size_)
+      : size(static_cast<uint16_t>(size_)), checksum(Checksum(off, size)) {
+    PERFETTO_DCHECK(size_ <= kMaxSize);
+  }
+
+  // The ChunkID, as specified by the TraceWriter in the original SMB chunk.
+  ChunkID chunk_id = 0;
+
+  // A combination of producer and writer ID. This forms the primary key to
+  // look up the corresponding SequenceState from TraceBuffer.sequences_.
+  ProducerAndWriterID pri_wri_id = 0;
+
+  // Size of the chunk, excluding the TBCHunk header itself, and without
+  // accounting for any alignment. This doesn't change throughout the lifecycle
+  // of a chunk.
+  uint16_t size = 0;
+
+  // The size of the valid fragments payload. This is typically == size, with
+  // the exception of incomplete chunks committed while scraping.
+  // The payload of incomplete chunks can increase (up to the original chunk
+  // size). Wheh we scrape we set size = SMB chunk size, and
+  // payload_size = all_frag_size.
+  uint16_t payload_size = 0;
+
+  // The number of payload bytes unconsumed. This starts at payload_size and
+  // shrinks until it reaches 0 as we consume fragments.
+  // It is always <= size and <= payload_size.
+  // Effectively (payload_size - payload-avail) is the offset of the the next
+  // unconsumed fragment header (the varint with the size).
+  uint16_t payload_avail = 0;
+
+  // These are == the SharedMemoryABI's chunk flags, with the addition of
+  // MSB flags added by TraceBufferV2 like kChunkIncomplete (0x80) which doesn't
+  // exist at the ABI level, but are synthesized here.
+  uint8_t flags = 0;
+
+  // This is used for (D)CHECKS to verify the integrity of the chunk.
+  // This is a hash of the offset in the buffer and the size.
+  uint8_t checksum = 0;
+
+  // Returns the offset to the next unread fragment in the chunk. Note that this
+  // points to the next fragment header (the varint with the size) NOT payload.
+  uint16_t unread_payload_off() {
+    PERFETTO_DCHECK((payload_avail <= payload_size));
+    return payload_size - payload_avail;
+  }
+
+  // TODO(primiano): in theory we could align just up to alignof(TBChunk)
+  // rather than sizeof(TBChunk), which is 4 rather than 16 bytes. That would
+  // reduce internal fragmentation.
+  // However, doing so requires some careful thinking as that creates the
+  // opportunity for more interesting edge cases, where overwriting a chunk
+  // leaves less than sizeof(TBChunk), leaving no space for a padding header
+  // after it. See TraceBufferV2Test.Overwrite_SizeDiffLessThanChunkHeader.
+  static inline constexpr size_t alignment() { return sizeof(TBChunk); }
+
+  static inline size_t OuterSize(size_t sz) {
+    return base::AlignUp(sizeof(TBChunk) + sz, alignment());
+  }
+  size_t outer_size() { return OuterSize(size); }
+
+  bool is_padding() const { return pri_wri_id == 0; }
+
+  uint8_t* fragments_begin() {
+    return reinterpret_cast<uint8_t*>(this) + sizeof(TBChunk);
+  }
+
+  uint8_t* fragments_end() { return fragments_begin() + payload_size; }
+
+  bool IsChecksumValid(size_t off) { return Checksum(off, size) == checksum; }
+};
+
+// +---------------------------------------------------------------------------+
+// | SequenceState                                                             |
+// +---------------------------------------------------------------------------+
+// Holds the state for each sequence that has TBCHunk(s) in the buffer.
+// Remember that this struct must be copyable for CloneReadOnly(). Don't hold
+// onto any pointers in here.
+// SequenceState(s) are not deleted aggressively to preserve the
+// last_chunk_id_consumed and detect data losses in long tracing mode. We allow
+// the last kKeepLastEmptySeq to stay alive to balance data loss detection with
+// memory bloats.
+struct SequenceState {
+  SequenceState(ProducerID, WriterID, ClientIdentity);
+  ~SequenceState();
+  SequenceState(const SequenceState&) noexcept;
+  SequenceState& operator=(const SequenceState&) noexcept;
+
+  ProducerID producer_id = 0;
+  WriterID writer_id = 0;
+  ClientIdentity client_identity{};
+
+  // This is semantically a boolean that resets every time BeginRead()
+  // increments the generation counter. The semantic is:
+  // skip := skip_in_generation == TraceBuffer.read_generation_.
+  uint64_t skip_in_generation = 0;
+
+  // Used by DeleteStaleEmptySequences() to keep the latest kKeepLastEmptySeq
+  // objects around.
+  uint64_t age_for_gc = 0;
+
+  std::optional<ChunkID> last_chunk_id_consumed;
+
+  // This is set whenever a data loss is detected and cleared when reading the
+  // next packet for the sequence (which will report previous_packet_dropped).
+  bool data_loss = false;
+
+  // An ordered list of chunk offsets, sorted by their ChunkID. Each member
+  // corresponsds to the offset within buf_ for the chunk.
+  // We store buffer offsets rather than pointers to make buffer cloning easier.
+  // This is effectively a deque of TBChunk* (% a call to GetTBChunkAt(off)).
+  base::CircularQueue<size_t> chunks;
+};
+
+// +---------------------------------------------------------------------------+
+// | FragIterator                                                              |
+// +---------------------------------------------------------------------------+
+// A tokenized fragment in the buffer. Holds the fragment size & boundaries.
+// This struct is returned by FragIterator when tokenizing the fragments in
+// CopyChunkUntrusted() or reading the buffer.
+// Frag instances are short lived.
+struct Frag {
+  enum FragType : uint8_t {
+    // 1 packet == 1 fragment.
+    kFragWholePacket,
+
+    // Fragmentation cases:
+
+    // The last fragment of a chunk, when kLastPacketContinuesOnNextChunk
+    kFragBegin,
+
+    // The only fragment of a chunk when both kLastPacketContinuesOnNextChunk &
+    // kFirstPacketContinuesFromPrevChunk
+    kFragContinue,
+
+    // The first fragment of a chunk when kFirstPacketContinuesFromPrevChunk
+    kFragEnd,
+  };
+
+  // Diagram for the member variables below.
+  //  +- `begin`
+  //  |
+  //  [VarInt header][ Fragment payload ]
+  //  (  hdr_size   )(       size       )
+  //  (         size_with_header        )
+
+  // Pointes to the fragment payload, immediately after the header.
+  const uint8_t* const begin = nullptr;
+  FragType const type = kFragWholePacket;
+  uint8_t const hdr_size = 0;  // Size of the varint that tells the frag size.
+  uint16_t const size = 0;     // Size of the payload (the varint value).
+
+  uint16_t size_with_header() { return size + hdr_size; }
+
+  Frag(const uint8_t* b, FragType t, uint8_t h, uint16_t s)
+      : begin(b), type(t), hdr_size(h), size(s) {}
+};
+
+// A simple class that tokenizes fragments in a chunk and allows forward-only
+// iteration.
+// It deals with untrusted data, detecting malformed / out of bounds scenarios.
+// It does not alter the state of the buffer.
+// This is used in three places:
+// - In CopyChunkUntrusted(): to tokenize the fragments and figure out the
+//   "effective" size of the chunk, to get rid of chunk padding.
+// - In ChunkSeqReader::ReadNextPacket(): for the main read logic.
+// - In ReassembleFragmentedPacket(): for the fragment reassembly logic.
+class FragIterator {
  public:
-  static const size_t InlineChunkHeaderSize;  // For test/fake_packet.{cc,h}.
+  explicit FragIterator(TBChunk* chunk)
+      : chunk_begin_(chunk->fragments_begin()),
+        chunk_size_(chunk->payload_size),
+        next_frag_off_(chunk->unread_payload_off()),
+        chunk_flags_(chunk->flags) {}
 
-  // See comment in the header above.
-  enum OverwritePolicy { kOverwrite, kDiscard };
+  FragIterator(const uint8_t* begin, size_t size, uint8_t flags)
+      : chunk_begin_(begin), chunk_size_(size), chunk_flags_(flags) {}
 
-  // Argument for out-of-band patches applied through TryPatchChunkContents().
-  struct Patch {
-    // From SharedMemoryABI::kPacketHeaderSize.
-    static constexpr size_t kSize = 4;
+  std::optional<Frag> NextFragmentInChunk();
+  size_t next_frag_off() const { return next_frag_off_; }
+  bool chunk_corrupted() { return chunk_corrupted_; }
+  bool trace_writer_data_drop() { return trace_writer_data_drop_; }
 
-    size_t offset_untrusted;
-    std::array<uint8_t, kSize> data;
+ private:
+  const uint8_t* chunk_begin_ = nullptr;
+  size_t chunk_size_ = 0;
+  size_t next_frag_off_ = 0;
+  uint8_t chunk_flags_ = 0;
+  bool chunk_corrupted_ = false;
+  bool trace_writer_data_drop_ = false;
+};
+
+// +---------------------------------------------------------------------------+
+// | ChunkSeqIterator                                                          |
+// +---------------------------------------------------------------------------+
+// A simple utility class that iterates over the ordered list of TBChunk for
+// a given SequenceState. It merely follows the SequenceState.chunks queue
+// and detects gaps.
+class ChunkSeqIterator {
+ public:
+  // Rewinds to the first chunk of the sequence.
+  explicit ChunkSeqIterator(TraceBufferV2*, SequenceState*);
+  ChunkSeqIterator() = default;  // Creates an invalid object, for default init.
+  ChunkSeqIterator(const ChunkSeqIterator&) = default;  // Allow copy.
+  ChunkSeqIterator& operator=(const ChunkSeqIterator&) = default;
+
+  TBChunk* NextChunkInSequence();
+  void EraseCurrentChunk();
+  TBChunk* chunk() const { return chunk_; }
+  bool sequence_gap_detected() const { return sequence_gap_detected_; }
+  bool valid() const { return !!seq_ && !!chunk_; }
+
+ private:
+  TraceBufferV2* buf_ = nullptr;
+  SequenceState* seq_ = nullptr;
+  TBChunk* chunk_ = nullptr;
+  bool sequence_gap_detected_ = false;
+  size_t list_idx_ = 0;  // Offset of the current chunk in seq_.chunks.
+};
+
+// +---------------------------------------------------------------------------+
+// | ChunkSeqReader                                                            |
+// +---------------------------------------------------------------------------+
+// Encapsulates most of the readback complexity. It reads and consumes chunks
+// in sequence order, as follows:
+//
+// When constructed, the caller must pass a target TBChunk as argument. This
+// is the chunk where we will stop the iteration *.
+// At readback time this is the next chunk in the buffer that we want to read.
+// At overwrite time this is the chunk that we are about to overwriter.
+// In both cases, because of OOO commits, the next chunk in buffer-order might
+// not necessarily be the next chunk that should be consumed in FIFO order
+// (although in the vast majority cases we expect them to be in order).
+// Upon construction, it rewinds all the way back in the `SequenceState.chunks`
+// (using `ChunkSeqIterator`) and starts the iteration from there.
+// It keeps reading packets until we reach the target TBChunk passed in the
+// constructor.
+// In some cases (fragmentation) it might read beyon the target chunk. This is
+// to reassembly a packet that started in the target chunk and continued later
+// on.
+// When doing so it just consumes the fragment required for reassembly and
+// leaves the other packets in the chunk untouched, to preserve global FIFOness.
+class ChunkSeqReader {
+ public:
+  enum Mode {
+    kReadMode,   // For standard readback.
+    kEraseMode,  // For read-while-overwriting in DeleteNextChunksFor().
   };
 
-  // Identifiers that are constant for a packet sequence.
-  struct PacketSequenceProperties {
-    ProducerID producer_id_trusted;
-    uid_t producer_uid_trusted;
-    pid_t producer_pid_trusted;
-    WriterID writer_id;
+  ChunkSeqReader(TraceBufferV2*, TBChunk*, Mode);
+
+  bool ReadNextPacketInSeqOrder(TracePacket*);
+  TBChunk* end() { return end_; }
+  TBChunk* iter() { return iter_; }
+  SequenceState* seq() { return seq_; }
+
+ private:
+  ChunkSeqReader(const ChunkSeqReader&) = delete;
+  ChunkSeqReader& operator=(const ChunkSeqReader&) = delete;
+  ChunkSeqReader(ChunkSeqReader&&) = delete;
+  ChunkSeqReader& operator=(ChunkSeqReader&&) = delete;
+
+  enum class FragReassemblyResult { kSuccess = 0, kNotEnoughData, kDataLoss };
+  FragReassemblyResult ReassembleFragmentedPacket(TracePacket* out_packet,
+                                                  Frag* initial_frag);
+  void ConsumeFragment(TBChunk*, Frag*);
+
+  TraceBufferV2* const buf_ = nullptr;
+  Mode const mode_;
+
+  // This is the chunk passed in the constructor and is our stopping point.
+  // It never changes throughout the lifetime of ChunkSeqReader.
+  // Note that this is NOT the end of the sequence. This is simply where we
+  // want to stop iterating, which might be < seq_.end().
+  TBChunk* const end_ = nullptr;
+
+  SequenceState* const seq_ = nullptr;
+
+  ChunkSeqIterator seq_iter_;
+
+  // This is initially reset to the first chunk of the sequence, and advanced
+  // until we hit end_. chunk_ and end_ always belong to the same seq_.
+  TBChunk* iter_ = nullptr;
+
+  FragIterator frag_iter_;
+};
+
+}  // namespace internal
+
+// +---------------------------------------------------------------------------+
+// | TraceBufferV2                                                             |
+// +---------------------------------------------------------------------------+
+class TraceBufferV2 : public TraceBuffer {
+ public:
+  using TBChunk = internal::TBChunk;
+  using OverwritePolicy = TraceBuffer::OverwritePolicy;
+  using Patch = TraceBuffer::Patch;
+  using PacketSequenceProperties = TraceBuffer::PacketSequenceProperties;
+
+  // Represents a ProtoVM instance and some metadata
+  struct Vm {
+    Vm();
+    ~Vm();
+    Vm(Vm&&) noexcept;
+    Vm CloneReadOnly() const;
+
+    std::unique_ptr<protovm::Vm> instance;
+    std::string data_source_name;
+    uint64_t program_hash = 0;
+    uint32_t memory_limit_kb = 0;
+    base::FlatSet<ProducerID> producers;
   };
 
   // Can return nullptr if the memory allocation fails.
-  static std::unique_ptr<TraceBuffer> Create(size_t size_in_bytes,
-                                             OverwritePolicy = kOverwrite);
-
-  ~TraceBuffer();
+  static std::unique_ptr<TraceBufferV2> Create(size_t size_in_bytes,
+                                               OverwritePolicy = kOverwrite);
 
   // Copies a Chunk from a producer Shared Memory Buffer into the trace buffer.
   // |src| points to the first packet in the SharedMemoryABI's chunk shared with
@@ -53303,23 +59794,21 @@ class TraceBuffer {
   // may use this to insert partial chunks (|chunk_complete = false|) before the
   // producer has committed them.
   //
-  // If |chunk_complete| is |false|, the TraceBuffer will only consider the
-  // first |num_fragments - 1| packets to be complete, since the producer may
-  // not have finished writing the latest packet. Reading from a sequence will
-  // also not progress past any incomplete chunks until they were rewritten with
+  // If |chunk_complete| is |false|, we will only consider the first
+  // |num_fragments - 1| fragments to be complete, since the producer may have
+  // not finished writing the latest packet. Reading from a sequence will also
+  // not progress past any incomplete chunks until they were rewritten with
   // |chunk_complete = true|, e.g. after a producer's commit.
-  //
-  // TODO(eseckler): Pass in a PacketStreamProperties instead of individual IDs.
   void CopyChunkUntrusted(ProducerID producer_id_trusted,
-                          uid_t producer_uid_trusted,
-                          pid_t producer_pid_trusted,
+                          const ClientIdentity& client_identity_trusted,
                           WriterID writer_id,
                           ChunkID chunk_id,
                           uint16_t num_fragments,
                           uint8_t chunk_flags,
                           bool chunk_complete,
                           const uint8_t* src,
-                          size_t size);
+                          size_t size) override;
+
   // Applies a batch of |patches| to the given chunk, if the given chunk is
   // still in the buffer. Does nothing if the given ChunkID is gone.
   // Returns true if the chunk has been found and patched, false otherwise.
@@ -53340,22 +59829,28 @@ class TraceBuffer {
                              ChunkID,
                              const Patch* patches,
                              size_t patches_size,
-                             bool other_patches_pending);
+                             bool other_patches_pending) override;
+
+  void MaybeSetUpProtoVm(const std::string& data_source_name,
+                         const std::string& program_bytes,
+                         uint32_t memory_limit_kb,
+                         ProducerID producer_id);
+
+  const std::vector<Vm>& GetProtoVmInstances() const { return protovms_; }
 
   // To read the contents of the buffer the caller needs to:
   //   BeginRead()
   //   while (ReadNextTracePacket(packet_fragments)) { ... }
   // No other calls to any other method should be interleaved between
   // BeginRead() and ReadNextTracePacket().
-  // Reads in the TraceBuffer are NOT idempotent.
-  void BeginRead();
-
-  // Returns the next packet in the buffer, if any, and the producer_id,
-  // producer_uid, and writer_id of the producer/writer that wrote it (as passed
-  // in the CopyChunkUntrusted() call). Returns false if no packets can be read
-  // at this point. If a packet was read successfully,
-  // |previous_packet_on_sequence_dropped| is set to |true| if the previous
-  // packet on the sequence was dropped from the buffer before it could be read
+  // Reads in the TraceBufferV2 are NOT idempotent.
+  void BeginRead() override;
+
+  // Returns the next packet in the buffer, if any, and the producer/writer
+  // identity that wrote it (as passed in the CopyChunkUntrusted() call).
+  // Returns false if no packets can be read at this point.
+  // If a packet was read successfully, |previous_packet_on_sequence_dropped|
+  // signals whether any data loss has been detected on the sequence
   // (e.g. because its chunk was overridden due to the ring buffer wrapping or
   // due to an ABI violation), and to |false| otherwise.
   //
@@ -53375,421 +59870,132 @@ class TraceBuffer {
   //   {ProducerID: 1, WriterID: 2}: P4 P5 P6
   //   {ProducerID: 2, WriterID: 1}: P7 P8 P9
   // The following read sequence is possible:
-  //   P1, P4, P7, P2, P3, P5, P8, P9, P6
-  // But the following is guaranteed to NOT happen:
-  //   P1, P5, P7, P4 (P4 cannot come after P5)
-  bool ReadNextTracePacket(TracePacket*,
-                           PacketSequenceProperties* sequence_properties,
-                           bool* previous_packet_on_sequence_dropped);
-
-  // Creates a read-only clone of the trace buffer. The read iterators of the
-  // new buffer will be reset, as if no Read() had been called. Calls to
-  // CopyChunkUntrusted() and TryPatchChunkContents() on the returned cloned
-  // TraceBuffer will CHECK().
-  std::unique_ptr<TraceBuffer> CloneReadOnly() const;
-
-  const TraceStats::BufferStats& stats() const { return stats_; }
-  size_t size() const { return size_; }
-
- private:
-  friend class TraceBufferTest;
-
-  // ChunkRecord is a Chunk header stored inline in the |data_| buffer, before
-  // the chunk payload (the packets' data). The |data_| buffer looks like this:
-  // +---------------+------------------++---------------+-----------------+
-  // | ChunkRecord 1 | Chunk payload 1  || ChunkRecord 2 | Chunk payload 2 | ...
-  // +---------------+------------------++---------------+-----------------+
-  // Most of the ChunkRecord fields are copied from SharedMemoryABI::ChunkHeader
-  // (the chunk header used in the shared memory buffers).
-  // A ChunkRecord can be a special "padding" record. In this case its payload
-  // should be ignored and the record should be just skipped.
-  //
-  // Full page move optimization:
-  // This struct has to be exactly (sizeof(PageHeader) + sizeof(ChunkHeader))
-  // (from shared_memory_abi.h) to allow full page move optimizations
-  // (TODO(primiano): not implemented yet). In the special case of moving a full
-  // 4k page that contains only one chunk, in fact, we can just ask the kernel
-  // to move the full SHM page (see SPLICE_F_{GIFT,MOVE}) and overlay the
-  // ChunkRecord on top of the moved SMB's header (page + chunk header).
-  // This special requirement is covered by static_assert(s) in the .cc file.
-  struct ChunkRecord {
-    explicit ChunkRecord(size_t sz) : flags{0}, is_padding{0} {
-      PERFETTO_DCHECK(sz >= sizeof(ChunkRecord) &&
-                      sz % sizeof(ChunkRecord) == 0 && sz <= kMaxSize);
-      size = static_cast<decltype(size)>(sz);
-    }
-
-    bool is_valid() const { return size != 0; }
-
-    // Keep this structure packed and exactly 16 bytes (128 bits) big.
-
-    // [32 bits] Monotonic counter within the same writer_id.
-    ChunkID chunk_id = 0;
-
-    // [16 bits] ID of the Producer from which the Chunk was copied from.
-    ProducerID producer_id = 0;
-
-    // [16 bits] Unique per Producer (but not within the service).
-    // If writer_id == kWriterIdPadding the record should just be skipped.
-    WriterID writer_id = 0;
-
-    // Number of fragments contained in the chunk.
-    uint16_t num_fragments = 0;
-
-    // Size in bytes, including sizeof(ChunkRecord) itself.
-    uint16_t size;
-
-    uint8_t flags : 6;  // See SharedMemoryABI::ChunkHeader::flags.
-    uint8_t is_padding : 1;
-    uint8_t unused_flag : 1;
-
-    // Not strictly needed, can be reused for more fields in the future. But
-    // right now helps to spot chunks in hex dumps.
-    char unused[3] = {'C', 'H', 'U'};
-
-    static constexpr size_t kMaxSize =
-        std::numeric_limits<decltype(size)>::max();
-  };
-
-  // Lookaside index entry. This serves two purposes:
-  // 1) Allow a fast lookup of ChunkRecord by their ID (the tuple
-  //   {ProducerID, WriterID, ChunkID}). This is used when applying out-of-band
-  //   patches to the contents of the chunks after they have been copied into
-  //   the TraceBuffer.
-  // 2) keep the chunks ordered by their ID. This is used when reading back.
-  // 3) Keep metadata about the status of the chunk, e.g. whether the contents
-  //    have been read already and should be skipped in a future read pass.
-  // This struct should not have any field that is essential for reconstructing
-  // the contents of the buffer from a crash dump.
-  struct ChunkMeta {
-    // Key used for sorting in the map.
-    struct Key {
-      Key(ProducerID p, WriterID w, ChunkID c)
-          : producer_id{p}, writer_id{w}, chunk_id{c} {}
-
-      Key(const Key&) noexcept = default;
-      Key& operator=(const Key&) = default;
-
-      explicit Key(const ChunkRecord& cr)
-          : Key(cr.producer_id, cr.writer_id, cr.chunk_id) {}
-
-      // Note that this sorting doesn't keep into account the fact that ChunkID
-      // will wrap over at some point. The extra logic in SequenceIterator deals
-      // with that.
-      bool operator<(const Key& other) const {
-        return std::tie(producer_id, writer_id, chunk_id) <
-               std::tie(other.producer_id, other.writer_id, other.chunk_id);
-      }
-
-      bool operator==(const Key& other) const {
-        return std::tie(producer_id, writer_id, chunk_id) ==
-               std::tie(other.producer_id, other.writer_id, other.chunk_id);
-      }
-
-      bool operator!=(const Key& other) const { return !(*this == other); }
-
-      // These fields should match at all times the corresponding fields in
-      // the |chunk_record|. They are copied here purely for efficiency to avoid
-      // dereferencing the buffer all the time.
-      ProducerID producer_id;
-      WriterID writer_id;
-      ChunkID chunk_id;
-    };
-
-    enum IndexFlags : uint8_t {
-      // If set, the chunk state was kChunkComplete at the time it was copied.
-      // If unset, the chunk was still kChunkBeingWritten while copied. When
-      // reading from the chunk's sequence, the sequence will not advance past
-      // this chunk until this flag is set.
-      kComplete = 1 << 0,
-
-      // If set, we skipped the last packet that we read from this chunk e.g.
-      // because we it was a continuation from a previous chunk that was dropped
-      // or due to an ABI violation.
-      kLastReadPacketSkipped = 1 << 1
-    };
-
-    ChunkMeta(uint32_t _record_off,
-              uint16_t _num_fragments,
-              bool complete,
-              uint8_t _flags,
-              uid_t _trusted_uid,
-              pid_t _trusted_pid)
-        : record_off{_record_off},
-          trusted_uid{_trusted_uid},
-          trusted_pid(_trusted_pid),
-          flags{_flags},
-          num_fragments{_num_fragments} {
-      if (complete)
-        index_flags = kComplete;
-    }
-
-    ChunkMeta(const ChunkMeta&) noexcept = default;
-
-    bool is_complete() const { return index_flags & kComplete; }
-
-    void set_complete(bool complete) {
-      if (complete) {
-        index_flags |= kComplete;
-      } else {
-        index_flags &= ~kComplete;
-      }
-    }
-
-    bool last_read_packet_skipped() const {
-      return index_flags & kLastReadPacketSkipped;
-    }
-
-    void set_last_read_packet_skipped(bool skipped) {
-      if (skipped) {
-        index_flags |= kLastReadPacketSkipped;
-      } else {
-        index_flags &= ~kLastReadPacketSkipped;
-      }
-    }
-
-    const uint32_t record_off;  // Offset of ChunkRecord within |data_|.
-    const uid_t trusted_uid;    // uid of the producer.
-    const pid_t trusted_pid;    // pid of the producer.
-
-    // Flags set by TraceBuffer to track the state of the chunk in the index.
-    uint8_t index_flags = 0;
-
-    // Correspond to |chunk_record->flags| and |chunk_record->num_fragments|.
-    // Copied here for performance reasons (avoids having to dereference
-    // |chunk_record| while iterating over ChunkMeta) and to aid debugging in
-    // case the buffer gets corrupted.
-    uint8_t flags = 0;           // See SharedMemoryABI::ChunkHeader::flags.
-    uint16_t num_fragments = 0;  // Total number of packet fragments.
-
-    uint16_t num_fragments_read = 0;  // Number of fragments already read.
-
-    // The start offset of the next fragment (the |num_fragments_read|-th) to be
-    // read. This is the offset in bytes from the beginning of the ChunkRecord's
-    // payload (the 1st fragment starts at |chunk_record| +
-    // sizeof(ChunkRecord)).
-    uint16_t cur_fragment_offset = 0;
-  };
-
-  using ChunkMap = std::map<ChunkMeta::Key, ChunkMeta>;
-
-  // Allows to iterate over a sub-sequence of |index_| for all keys belonging to
-  // the same {ProducerID,WriterID}. Furthermore takes into account the wrapping
-  // of ChunkID. Instances are valid only as long as the |index_| is not altered
-  // (can be used safely only between adjacent ReadNextTracePacket() calls).
-  // The order of the iteration will proceed in the following order:
-  // |wrapping_id| + 1 -> |seq_end|, |seq_begin| -> |wrapping_id|.
-  // Practical example:
-  // - Assume that kMaxChunkID == 7
-  // - Assume that we have all 8 chunks in the range (0..7).
-  // - Hence, |seq_begin| == c0, |seq_end| == c7
-  // - Assume |wrapping_id| = 4 (c4 is the last chunk copied over
-  //   through a CopyChunkUntrusted()).
-  // The resulting iteration order will be: c5, c6, c7, c0, c1, c2, c3, c4.
-  struct SequenceIterator {
-    // Points to the 1st key (the one with the numerically min ChunkID).
-    ChunkMap::iterator seq_begin;
-
-    // Points one past the last key (the one with the numerically max ChunkID).
-    ChunkMap::iterator seq_end;
-
-    // Current iterator, always >= seq_begin && <= seq_end.
-    ChunkMap::iterator cur;
-
-    // The latest ChunkID written. Determines the start/end of the sequence.
-    ChunkID wrapping_id;
-
-    bool is_valid() const { return cur != seq_end; }
-
-    ProducerID producer_id() const {
-      PERFETTO_DCHECK(is_valid());
-      return cur->first.producer_id;
-    }
-
-    WriterID writer_id() const {
-      PERFETTO_DCHECK(is_valid());
-      return cur->first.writer_id;
-    }
-
-    ChunkID chunk_id() const {
-      PERFETTO_DCHECK(is_valid());
-      return cur->first.chunk_id;
-    }
-
-    ChunkMeta& operator*() {
-      PERFETTO_DCHECK(is_valid());
-      return cur->second;
-    }
-
-    // Moves |cur| to the next chunk in the index.
-    // is_valid() will become false after calling this, if this was the last
-    // entry of the sequence.
-    void MoveNext();
-
-    void MoveToEnd() { cur = seq_end; }
-  };
-
-  enum class ReadAheadResult {
-    kSucceededReturnSlices,
-    kFailedMoveToNextSequence,
-    kFailedStayOnSameSequence,
-  };
-
-  enum class ReadPacketResult {
-    kSucceeded,
-    kFailedInvalidPacket,
-    kFailedEmptyPacket,
-  };
-
-  explicit TraceBuffer(OverwritePolicy);
-  TraceBuffer(const TraceBuffer&) = delete;
-  TraceBuffer& operator=(const TraceBuffer&) = delete;
-
-  // Not using the implicit copy ctor to avoid unintended copies.
-  // This tagged ctor should be used only for Clone().
-  struct CloneCtor {};
-  TraceBuffer(CloneCtor, const TraceBuffer&);
-
-  bool Initialize(size_t size);
-
-  // Returns an object that allows to iterate over chunks in the |index_| that
-  // have the same {ProducerID, WriterID} of
-  // |seq_begin.first.{producer,writer}_id|. |seq_begin| must be an iterator to
-  // the first entry in the |index_| that has a different {ProducerID, WriterID}
-  // from the previous one. It is valid for |seq_begin| to be == index_.end()
-  // (i.e. if the index is empty). The iteration takes care of ChunkID wrapping,
-  // by using |last_chunk_id_|.
-  SequenceIterator GetReadIterForSequence(ChunkMap::iterator seq_begin);
-
-  // Used as a last resort when a buffer corruption is detected.
-  void ClearContentsAndResetRWCursors();
-
-  // Adds a padding record of the given size (must be a multiple of
-  // sizeof(ChunkRecord)).
-  void AddPaddingRecord(size_t);
-
-  // Look for contiguous fragment of the same packet starting from |read_iter_|.
-  // If a contiguous packet is found, all the fragments are pushed into
-  // TracePacket and the function returns kSucceededReturnSlices. If not, the
-  // function returns either kFailedMoveToNextSequence or
-  // kFailedStayOnSameSequence, telling the caller to continue looking for
-  // packets.
-  ReadAheadResult ReadAhead(TracePacket*);
-
-  // Deletes (by marking the record invalid and removing form the index) all
-  // chunks from |wptr_| to |wptr_| + |bytes_to_clear|.
-  // Returns:
-  //   * The size of the gap left between the next valid Chunk and the end of
-  //     the deletion range.
-  //   * 0 if no next valid chunk exists (if the buffer is still zeroed).
-  //   * -1 if the buffer |overwrite_policy_| == kDiscard and the deletion would
-  //     cause unread chunks to be overwritten. In this case the buffer is left
-  //     untouched.
-  // Graphically, assume the initial situation is the following (|wptr_| = 10).
-  // |0        |10 (wptr_)       |30       |40                 |60
-  // +---------+-----------------+---------+-------------------+---------+
-  // | Chunk 1 | Chunk 2         | Chunk 3 | Chunk 4           | Chunk 5 |
-  // +---------+-----------------+---------+-------------------+---------+
-  //           |_________Deletion range_______|~~return value~~|
-  //
-  // A call to DeleteNextChunksFor(32) will remove chunks 2,3,4 and return 18
-  // (60 - 42), the distance between chunk 5 and the end of the deletion range.
-  ssize_t DeleteNextChunksFor(size_t bytes_to_clear);
+  //   P1, P4, P7, P2, P3, P5, P8, P9, P6
+  // But the following is guaranteed to NOT happen:
+  //   P1, P5, P7, P4 (P4 cannot come after P5)
+  bool ReadNextTracePacket(TracePacket*,
+                           PacketSequenceProperties* sequence_properties,
+                           bool* previous_packet_on_sequence_dropped) override;
 
-  // Decodes the boundaries of the next packet (or a fragment) pointed by
-  // ChunkMeta and pushes that into |TracePacket|. It also increments the
-  // |num_fragments_read| counter.
-  // TracePacket can be nullptr, in which case the read state is still advanced.
-  // When TracePacket is not nullptr, ProducerID must also be not null and will
-  // be updated with the ProducerID that originally wrote the chunk.
-  ReadPacketResult ReadNextPacketInChunk(ChunkMeta*, TracePacket*);
+  // Creates a read-only clone of the trace buffer. The read iterators of the
+  // new buffer will be reset, as if no Read() had been called. Calls to
+  // CopyChunkUntrusted() and TryPatchChunkContents() on the returned cloned
+  // TraceBuffer will CHECK().
+  std::unique_ptr<TraceBuffer> CloneReadOnly() const override;
 
-  void DcheckIsAlignedAndWithinBounds(const uint8_t* ptr) const {
-    PERFETTO_DCHECK(ptr >= begin() && ptr <= end() - sizeof(ChunkRecord));
-    PERFETTO_DCHECK(
-        (reinterpret_cast<uintptr_t>(ptr) & (alignof(ChunkRecord) - 1)) == 0);
+  size_t size() const override { return size_; }
+  size_t used_size() const override { return used_size_; }
+  size_t GetMemoryUsageBytes() const override;
+  OverwritePolicy overwrite_policy() const override {
+    return overwrite_policy_;
   }
+  const TraceStats::BufferStats& stats() const override { return stats_; }
+  const WriterStats& writer_stats() const override { return writer_stats_; }
+  bool has_data() const override { return used_size_ > 0; }
+  void set_read_only() override { read_only_ = true; }
+  BufType buf_type() const override { return kV2; }
 
-  ChunkRecord* GetChunkRecordAt(uint8_t* ptr) {
-    DcheckIsAlignedAndWithinBounds(ptr);
-    // We may be accessing a new (empty) record.
-    data_.EnsureCommitted(
-        static_cast<size_t>(ptr + sizeof(ChunkRecord) - begin()));
-    return reinterpret_cast<ChunkRecord*>(ptr);
+  void DumpForTesting();
+
+ private:
+  using Frag = internal::Frag;
+  using SequenceState = internal::SequenceState;
+  using ChunkSeqReader = internal::ChunkSeqReader;
+
+  friend class TraceBufferV2Test;
+  friend class internal::ChunkSeqReader;
+  friend class internal::ChunkSeqIterator;
+
+  explicit TraceBufferV2(OverwritePolicy);
+  TraceBufferV2(const TraceBufferV2&) = delete;
+  TraceBufferV2& operator=(const TraceBufferV2&) = delete;
+
+  // Not using the implicit copy ctor to avoid unintended copies.
+  // This tagged ctor should be used only for Clone().
+  struct CloneCtor {};
+  TraceBufferV2(CloneCtor, const TraceBufferV2&);
+
+  bool Initialize(size_t size);
+  TBChunk* CreateTBChunk(size_t off, size_t payload_size);
+  void DeleteNextChunksFor(size_t bytes_to_clear);
+
+  void DcheckIsAlignedAndWithinBounds(size_t off) const {
+    PERFETTO_DCHECK((off & (alignof(TBChunk) - 1)) == 0);
+    PERFETTO_DCHECK(off <= size_ - sizeof(TBChunk));
   }
 
-  void DiscardWrite();
+  // This should only be used when followed by a placement new.
+  TBChunk* GetTBChunkAtUnchecked(size_t off) {
+    DcheckIsAlignedAndWithinBounds(off);
+    return reinterpret_cast<TBChunk*>(begin() + off);
+  }
 
-  // |src| can be nullptr (in which case |size| must be ==
-  // record.size - sizeof(ChunkRecord)), for the case of writing a padding
-  // record. |wptr_| is NOT advanced by this function, the caller must do that.
-  void WriteChunkRecord(uint8_t* wptr,
-                        const ChunkRecord& record,
-                        const uint8_t* src,
-                        size_t size) {
-    // Note: |record.size| will be slightly bigger than |size| because of the
-    // ChunkRecord header and rounding, to ensure that all ChunkRecord(s) are
-    // multiple of sizeof(ChunkRecord). The invariant is:
-    // record.size >= |size| + sizeof(ChunkRecord) (== if no rounding).
-    PERFETTO_DCHECK(size <= ChunkRecord::kMaxSize);
-    PERFETTO_DCHECK(record.size >= sizeof(record));
-    PERFETTO_DCHECK(record.size % sizeof(record) == 0);
-    PERFETTO_DCHECK(record.size >= size + sizeof(record));
-    PERFETTO_CHECK(record.size <= size_to_end());
-    DcheckIsAlignedAndWithinBounds(wptr);
+  TBChunk* GetTBChunkAt(size_t off) {
+    TBChunk* tbchunk = GetTBChunkAtUnchecked(off);
+    PERFETTO_CHECK(tbchunk->outer_size() <= (size_ - off));
 
-    // We may be writing to this area for the first time.
-    data_.EnsureCommitted(static_cast<size_t>(wptr + record.size - begin()));
+    // TODO(primiano): consider turning this into a DCHECK (and #ifdef-ing away
+    // the checksum code) once TBV2 proves to be reliable.
+    PERFETTO_CHECK(tbchunk->IsChecksumValid(off));
+    return tbchunk;
+  }
 
-    // Deliberately not a *D*CHECK.
-    PERFETTO_CHECK(wptr + sizeof(record) + size <= end());
-    memcpy(wptr, &record, sizeof(record));
-    if (PERFETTO_LIKELY(src)) {
-      // If the producer modifies the data in the shared memory buffer while we
-      // are copying it to the central buffer, TSAN will (rightfully) flag that
-      // as a race. However the entire purpose of copying the data into the
-      // central buffer is that we can validate it without worrying that the
-      // producer changes it from under our feet, so this race is benign. The
-      // alternative would be to try computing which part of the buffer is safe
-      // to read (assuming a well-behaving client), but the risk of introducing
-      // a bug that way outweighs the benefit.
-      PERFETTO_ANNOTATE_BENIGN_RACE_SIZED(
-          src, size, "Benign race when copying chunk from shared memory.")
-      memcpy(wptr + sizeof(record), src, size);
-    } else {
-      PERFETTO_DCHECK(size == record.size - sizeof(record));
-    }
-    const size_t rounding_size = record.size - sizeof(record) - size;
-    memset(wptr + sizeof(record) + size, 0, rounding_size);
+  // Can return nullptr for padding chunks (or in case of programming errors).
+  SequenceState* GetSeqForChunk(const TBChunk* chunk) {
+    auto it = sequences_.find(chunk->pri_wri_id);
+    return it == sequences_.end() ? nullptr : &it->second;
   }
 
-  uint32_t GetOffset(const void* _addr) {
-    const uintptr_t addr = reinterpret_cast<uintptr_t>(_addr);
-    const uintptr_t buf_start = reinterpret_cast<uintptr_t>(begin());
-    PERFETTO_DCHECK(addr >= buf_start && addr < buf_start + size_);
-    return static_cast<uint32_t>(addr - buf_start);
+  size_t OffsetOf(const TBChunk* chunk) {
+    uintptr_t addr = reinterpret_cast<uintptr_t>(chunk);
+    uintptr_t buf_start = reinterpret_cast<uintptr_t>(begin());
+    PERFETTO_DCHECK(addr >= buf_start && buf_start <= addr + size_);
+    return static_cast<size_t>(addr - buf_start);
   }
 
+  void DiscardWrite();
+  void DeleteStaleEmptySequences();
+  void MaybeProcessOverwrittenPacketWithProtoVm(const TracePacket&, ProducerID);
+
   uint8_t* begin() const { return reinterpret_cast<uint8_t*>(data_.Get()); }
   uint8_t* end() const { return begin() + size_; }
-  size_t size_to_end() const { return static_cast<size_t>(end() - wptr_); }
+  size_t size_to_end() const { return size_ - wr_; }
 
   base::PagedMemory data_;
-  size_t size_ = 0;            // Size in bytes of |data_|.
-  size_t max_chunk_size_ = 0;  // Max size in bytes allowed for a chunk.
-  uint8_t* wptr_ = nullptr;    // Write pointer.
+  size_t size_ = 0;  // Size in bytes of |data_|.
 
-  // An index that keeps track of the positions and metadata of each
-  // ChunkRecord.
-  ChunkMap index_;
+  // High watermark. The number of bytes (<= |size_|) written into the buffer
+  // before the first wraparound. This increases as data is written into the
+  // buffer and then saturates at |size_|.
+  size_t used_size_ = 0;
 
-  // Read iterator used for ReadNext(). It is reset by calling BeginRead().
-  // It becomes invalid after any call to methods that alters the |index_|.
-  SequenceIterator read_iter_;
+  size_t wr_ = 0;  // Write cursor (offset since start()).
+  size_t rd_ = 0;  // Read cursor. Reset to wr_ on every BeginRead().
+  std::optional<ChunkSeqReader> chunk_seq_reader_;
+
+  // Statistics about buffer usage.
+  TraceStats::BufferStats stats_;
+
+  // Statistics about TraceWriters.
+  WriterStats writer_stats_;
 
-  // See comments at the top of the file.
   OverwritePolicy overwrite_policy_ = kOverwrite;
 
+  // Note: we need stable pointers for SequenceState, as they get cached in
+  // BufIterator.
+  std::unordered_map<ProducerAndWriterID, SequenceState> sequences_;
+
+  // COUNT(sequences_) WHERE sequence.chunks.empty().
+  // This is maintained best effort and needs revalidation against sequences_.
+  size_t empty_sequences_ = 0;
+
+  // A generation counter incremented every time BeginRead() is called.
+  uint64_t read_generation_ = 0;
+
+  // A monotonic counter incremented every time a SequenceState becomes empty.
+  // This is used to sort SequenceState by least-recently cleared.
+  uint64_t seq_age_ = 0;
+
   // This buffer is a read-only snapshot obtained via Clone(). If this is true
   // calls to CopyChunkUntrusted() and TryPatchChunkContents() will CHECK().
   bool read_only_ = false;
@@ -53798,33 +60004,34 @@ class TraceBuffer {
   // a write fails because it would overwrite unread chunks.
   bool discard_writes_ = false;
 
-  // Keeps track of the highest ChunkID written for a given sequence, taking
-  // into account a potential overflow of ChunkIDs. In the case of overflow,
-  // stores the highest ChunkID written since the overflow.
-  //
-  // TODO(primiano): should clean up keys from this map. Right now it grows
-  // without bounds (although realistically is not a problem unless we have too
-  // many producers/writers within the same trace session).
-  std::map<std::pair<ProducerID, WriterID>, ChunkID> last_chunk_id_written_;
-
-  // Statistics about buffer usage.
-  TraceStats::BufferStats stats_;
-
-#if PERFETTO_DCHECK_IS_ON()
-  bool changed_since_last_read_ = false;
-#endif
-
   // When true disable some DCHECKs that have been put in place to detect
   // bugs in the producers. This is for tests that feed malicious inputs and
   // hence mimic a buggy producer.
   bool suppress_client_dchecks_for_testing_ = false;
+
+  // ProtoVMs used to process overwritten packets (go/perfetto-proto-vm)
+  std::vector<Vm> protovms_;
+
+  // Used to collect slices of the overwritten packet. Note that this is a
+  // member variable (instead of local) so that the memory (internal
+  // std::vector<Slice>) is re-used across overwritten packets, thus involving
+  // allocations only when the vector needs to be expanded (in practice only a
+  // few times during the initial iterations).
+  TracePacket overwritten_packet_;
+
+  // Storage used to re-write overwritten packets (from TBv2) into contiguous
+  // memory to be used as ProtoVM patches (must be continguous to be decoded
+  // with protozero). Note that this is a member variable (instead of local) so
+  // that the memory is re-used across overwritten packets, thus involving
+  // allocations only when the storage needs to be expanded.
+  std::string protovm_patch_;
 };
 
 }  // namespace perfetto
 
-#endif  // SRC_TRACING_CORE_TRACE_BUFFER_H_
+#endif  // SRC_TRACING_SERVICE_TRACE_BUFFER_V2_H_
 /*
- * Copyright (C) 2018 The Android Open Source Project
+ * Copyright (C) 2025 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -53839,904 +60046,1347 @@ class TraceBuffer {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "src/tracing/core/trace_buffer.h"
-
-#include <limits>
+// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer_v1_with_v2_shadow.h"
 
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_abi.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/fnv_hash.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_packet.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer_v1.h"
+// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer_v2.h"
 
-#define TRACE_BUFFER_VERBOSE_LOGGING() 0  // Set to 1 when debugging unittests.
-#if TRACE_BUFFER_VERBOSE_LOGGING()
-#define TRACE_BUFFER_DLOG PERFETTO_DLOG
-#else
-#define TRACE_BUFFER_DLOG(...) void()
-#endif
+// ****************************************************************************
+// * THIS IS A TEMPORARY CLASS FOR TESTING PURPOSES ONLY.                     *
+// * It will be removed once TraceBufferV2 is validated and fully rolled out. *
+// * See the header file for detailed documentation.                          *
+// ****************************************************************************
 
 namespace perfetto {
 
 namespace {
-constexpr uint8_t kFirstPacketContinuesFromPrevChunk =
-    SharedMemoryABI::ChunkHeader::kFirstPacketContinuesFromPrevChunk;
-constexpr uint8_t kLastPacketContinuesOnNextChunk =
-    SharedMemoryABI::ChunkHeader::kLastPacketContinuesOnNextChunk;
-constexpr uint8_t kChunkNeedsPatching =
-    SharedMemoryABI::ChunkHeader::kChunkNeedsPatching;
-}  // namespace.
 
-#if !PERFETTO_IS_AT_LEAST_CPP17()
-constexpr size_t TraceBuffer::ChunkRecord::kMaxSize;
-#endif
-const size_t TraceBuffer::InlineChunkHeaderSize = sizeof(ChunkRecord);
+// Stop processing hashes after these many packets. After this point we lose
+// stats accuracy for the sake of keeping memory bounded.
+constexpr size_t kMaxPacketHashes = 1000000;
 
-// static
-std::unique_ptr<TraceBuffer> TraceBuffer::Create(size_t size_in_bytes,
-                                                 OverwritePolicy pol) {
-  std::unique_ptr<TraceBuffer> trace_buffer(new TraceBuffer(pol));
-  if (!trace_buffer->Initialize(size_in_bytes))
-    return nullptr;
-  return trace_buffer;
+uint64_t ComputePacketHash(
+    const TracePacket& packet,
+    const TraceBuffer::PacketSequenceProperties& seq_props) {
+  base::MurmurHashCombiner hasher;
+  for (const Slice& slice : packet.slices()) {
+    hasher.Combine(std::string_view(reinterpret_cast<const char*>(slice.start),
+                                    slice.size));
+  }
+  hasher.Combine(seq_props.producer_id_trusted);
+  hasher.Combine(seq_props.writer_id);
+  return hasher.digest();
 }
 
-TraceBuffer::TraceBuffer(OverwritePolicy pol) : overwrite_policy_(pol) {
-  // See comments in ChunkRecord for the rationale of this.
-  static_assert(sizeof(ChunkRecord) == sizeof(SharedMemoryABI::PageHeader) +
-                                           sizeof(SharedMemoryABI::ChunkHeader),
-                "ChunkRecord out of sync with the layout of SharedMemoryABI");
+void IncrementWithSaturation(uint16_t* v) {
+  *v += *v < UINT16_MAX ? 1 : 0;
 }
 
-TraceBuffer::~TraceBuffer() = default;
+}  // namespace
 
-bool TraceBuffer::Initialize(size_t size) {
-  static_assert(
-      SharedMemoryABI::kMinPageSize % sizeof(ChunkRecord) == 0,
-      "sizeof(ChunkRecord) must be an integer divider of a page size");
-  auto max_size = std::numeric_limits<decltype(ChunkMeta::record_off)>::max();
-  PERFETTO_CHECK(size <= static_cast<size_t>(max_size));
-  data_ = base::PagedMemory::Allocate(
-      size, base::PagedMemory::kMayFail | base::PagedMemory::kDontCommit);
-  if (!data_.IsValid()) {
-    PERFETTO_ELOG("Trace buffer allocation failed (size: %zu)", size);
-    return false;
-  }
-  size_ = size;
-  stats_.set_buffer_size(size);
-  max_chunk_size_ = std::min(size, ChunkRecord::kMaxSize);
-  wptr_ = begin();
-  index_.clear();
-  last_chunk_id_written_.clear();
-  read_iter_ = GetReadIterForSequence(index_.end());
-  return true;
+TraceBufferV1WithV2Shadow::TraceBufferV1WithV2Shadow() = default;
+TraceBufferV1WithV2Shadow::~TraceBufferV1WithV2Shadow() = default;
+
+// static
+std::unique_ptr<TraceBufferV1WithV2Shadow> TraceBufferV1WithV2Shadow::Create(
+    size_t size_in_bytes,
+    OverwritePolicy policy) {
+  auto v1 = TraceBufferV1::Create(size_in_bytes, policy);
+  auto v2 = TraceBufferV2::Create(size_in_bytes, policy);
+  if (!v1 || !v2)
+    return nullptr;
+
+  std::unique_ptr<TraceBufferV1WithV2Shadow> instance(
+      new TraceBufferV1WithV2Shadow());
+  instance->v1_ = std::move(v1);
+  instance->v2_ = std::move(v2);
+  return instance;
 }
 
-// Note: |src| points to a shmem region that is shared with the producer. Assume
-// that the producer is malicious and will change the content of |src|
-// while we execute here. Don't do any processing on it other than memcpy().
-void TraceBuffer::CopyChunkUntrusted(ProducerID producer_id_trusted,
-                                     uid_t producer_uid_trusted,
-                                     pid_t producer_pid_trusted,
-                                     WriterID writer_id,
-                                     ChunkID chunk_id,
-                                     uint16_t num_fragments,
-                                     uint8_t chunk_flags,
-                                     bool chunk_complete,
-                                     const uint8_t* src,
-                                     size_t size) {
-  PERFETTO_CHECK(!read_only_);
+void TraceBufferV1WithV2Shadow::CopyChunkUntrusted(
+    ProducerID producer_id_trusted,
+    const ClientIdentity& client_identity_trusted,
+    WriterID writer_id,
+    ChunkID chunk_id,
+    uint16_t num_fragments,
+    uint8_t chunk_flags,
+    bool chunk_complete,
+    const uint8_t* src,
+    size_t size) {
+  v1_->CopyChunkUntrusted(producer_id_trusted, client_identity_trusted,
+                          writer_id, chunk_id, num_fragments, chunk_flags,
+                          chunk_complete, src, size);
+  v2_->CopyChunkUntrusted(producer_id_trusted, client_identity_trusted,
+                          writer_id, chunk_id, num_fragments, chunk_flags,
+                          chunk_complete, src, size);
+}
 
-  // |record_size| = |size| + sizeof(ChunkRecord), rounded up to avoid to end
-  // up in a fragmented state where size_to_end() < sizeof(ChunkRecord).
-  const size_t record_size =
-      base::AlignUp<sizeof(ChunkRecord)>(size + sizeof(ChunkRecord));
-  TRACE_BUFFER_DLOG("CopyChunk @ %lu, size=%zu", wptr_ - begin(), record_size);
-  if (PERFETTO_UNLIKELY(record_size > max_chunk_size_)) {
-    stats_.set_abi_violations(stats_.abi_violations() + 1);
-    PERFETTO_DCHECK(suppress_client_dchecks_for_testing_);
+bool TraceBufferV1WithV2Shadow::TryPatchChunkContents(
+    ProducerID producer_id,
+    WriterID writer_id,
+    ChunkID chunk_id,
+    const Patch* patches,
+    size_t patches_size,
+    bool other_patches_pending) {
+  patches_attempted_++;
+  bool v1_result =
+      v1_->TryPatchChunkContents(producer_id, writer_id, chunk_id, patches,
+                                 patches_size, other_patches_pending);
+  bool v2_result =
+      v2_->TryPatchChunkContents(producer_id, writer_id, chunk_id, patches,
+                                 patches_size, other_patches_pending);
+  if (v1_result)
+    v1_patches_succeeded_++;
+  if (v2_result)
+    v2_patches_succeeded_++;
+  return v1_result;
+}
+
+void TraceBufferV1WithV2Shadow::BeginRead() {
+  v1_->BeginRead();
+
+  if (packets_seen_ > kMaxPacketHashes)
     return;
-  }
 
-#if PERFETTO_DCHECK_IS_ON()
-  changed_since_last_read_ = true;
-#endif
+  // Read all V2 packets eagerly and store their hashes.
+  v2_->BeginRead();
 
-  // If the chunk hasn't been completed, we should only consider the first
-  // |num_fragments - 1| packets complete. For simplicity, we simply disregard
-  // the last one when we copy the chunk.
-  if (PERFETTO_UNLIKELY(!chunk_complete)) {
-    if (num_fragments > 0) {
-      num_fragments--;
-      // These flags should only affect the last packet in the chunk. We clear
-      // them, so that TraceBuffer is able to look at the remaining packets in
-      // this chunk.
-      chunk_flags &= ~kLastPacketContinuesOnNextChunk;
-      chunk_flags &= ~kChunkNeedsPatching;
-    }
+  for (;;) {
+    TracePacket packet;
+    PacketSequenceProperties seq_props{};
+    bool prev_dropped = false;
+    if (!v2_->ReadNextTracePacket(&packet, &seq_props, &prev_dropped))
+      break;
+    auto hash = ComputePacketHash(packet, seq_props);
+    IncrementWithSaturation(&packet_hashes_[hash].seen_in_v2);
   }
+}
 
-  ChunkRecord record(record_size);
-  record.producer_id = producer_id_trusted;
-  record.chunk_id = chunk_id;
-  record.writer_id = writer_id;
-  record.num_fragments = num_fragments;
-  record.flags = chunk_flags;
-  ChunkMeta::Key key(record);
-
-  // Check whether we have already copied the same chunk previously. This may
-  // happen if the service scrapes chunks in a potentially incomplete state
-  // before receiving commit requests for them from the producer. Note that the
-  // service may scrape and thus override chunks in arbitrary order since the
-  // chunks aren't ordered in the SMB.
-  const auto it = index_.find(key);
-  if (PERFETTO_UNLIKELY(it != index_.end())) {
-    ChunkMeta* record_meta = &it->second;
-    ChunkRecord* prev = GetChunkRecordAt(begin() + record_meta->record_off);
-
-    // Verify that the old chunk's metadata corresponds to the new one.
-    // Overridden chunks should never change size, since the page layout is
-    // fixed per writer. The number of fragments should also never decrease and
-    // flags should not be removed.
-    if (PERFETTO_UNLIKELY(ChunkMeta::Key(*prev) != key ||
-                          prev->size != record_size ||
-                          prev->num_fragments > num_fragments ||
-                          (prev->flags & chunk_flags) != prev->flags)) {
-      stats_.set_abi_violations(stats_.abi_violations() + 1);
-      PERFETTO_DCHECK(suppress_client_dchecks_for_testing_);
-      return;
-    }
-
-    // If this chunk was previously copied with the same number of fragments and
-    // the number didn't change, there's no need to copy it again. If the
-    // previous chunk was complete already, this should always be the case.
-    PERFETTO_DCHECK(suppress_client_dchecks_for_testing_ ||
-                    !record_meta->is_complete() ||
-                    (chunk_complete && prev->num_fragments == num_fragments));
-    if (prev->num_fragments == num_fragments) {
-      TRACE_BUFFER_DLOG("  skipping recommit of identical chunk");
-      return;
-    }
+bool TraceBufferV1WithV2Shadow::ReadNextTracePacket(
+    TracePacket* packet,
+    PacketSequenceProperties* sequence_properties,
+    bool* previous_packet_on_sequence_dropped) {
+  bool result = v1_->ReadNextTracePacket(packet, sequence_properties,
+                                         previous_packet_on_sequence_dropped);
+  if (result && packets_seen_ < kMaxPacketHashes) {
+    auto hash = ComputePacketHash(*packet, *sequence_properties);
+    IncrementWithSaturation(&packet_hashes_[hash].seen_in_v1);
+    ++packets_seen_;
+  }
+  return result;
+}
 
-    // If we've already started reading from chunk N+1 following this chunk N,
-    // don't override chunk N. Otherwise we may end up reading a packet from
-    // chunk N after having read from chunk N+1, thereby violating sequential
-    // read of packets. This shouldn't happen if the producer is well-behaved,
-    // because it shouldn't start chunk N+1 before completing chunk N.
-    ChunkMeta::Key subsequent_key = key;
-    static_assert(std::numeric_limits<ChunkID>::max() == kMaxChunkID,
-                  "ChunkID wraps");
-    subsequent_key.chunk_id++;
-    const auto subsequent_it = index_.find(subsequent_key);
-    if (subsequent_it != index_.end() &&
-        subsequent_it->second.num_fragments_read > 0) {
-      stats_.set_abi_violations(stats_.abi_violations() + 1);
-      PERFETTO_DCHECK(suppress_client_dchecks_for_testing_);
-      return;
-    }
+std::unique_ptr<TraceBuffer> TraceBufferV1WithV2Shadow::CloneReadOnly() const {
+  auto v1_clone = v1_->CloneReadOnly();
+  auto v2_clone = v2_->CloneReadOnly();
+  if (!v1_clone || !v2_clone)
+    return nullptr;
 
-    // We should not have read past the last packet.
-    if (record_meta->num_fragments_read > prev->num_fragments) {
-      PERFETTO_ELOG(
-          "TraceBuffer read too many fragments from an incomplete chunk");
-      PERFETTO_DCHECK(suppress_client_dchecks_for_testing_);
-      return;
+  std::unique_ptr<TraceBufferV1WithV2Shadow> clone(
+      new TraceBufferV1WithV2Shadow());
+  clone->v1_ = std::move(v1_clone);
+  clone->v2_ = std::move(v2_clone);
+  // Carry over patch stats; clone starts with fresh comparison state.
+  clone->patches_attempted_ = patches_attempted_;
+  clone->v1_patches_succeeded_ = v1_patches_succeeded_;
+  clone->v2_patches_succeeded_ = v2_patches_succeeded_;
+  return clone;
+}
+
+const TraceStats::BufferStats& TraceBufferV1WithV2Shadow::stats() const {
+  UpdateShadowStats();
+  return stats_;
+}
+
+void TraceBufferV1WithV2Shadow::UpdateShadowStats() const {
+  // Copy V1's stats as the base.
+  stats_ = v1_->stats();
+
+  // Count packets.
+  uint64_t packets_in_both = 0;
+  uint64_t packets_only_v1 = 0;
+  uint64_t packets_only_v2 = 0;
+  for (auto it = packet_hashes_.GetIterator(); it; ++it) {
+    HashPacketCounts& counts = it.value();
+    if (counts.seen_in_v1 <= counts.seen_in_v2) {
+      packets_in_both += counts.seen_in_v1;
+      packets_only_v2 += counts.seen_in_v2 - counts.seen_in_v1;
+    } else {
+      packets_in_both += counts.seen_in_v2;
+      packets_only_v1 += counts.seen_in_v1 - counts.seen_in_v2;
     }
-
-    uint8_t* wptr = reinterpret_cast<uint8_t*>(prev);
-    TRACE_BUFFER_DLOG("  overriding chunk @ %lu, size=%zu", wptr - begin(),
-                      record_size);
-
-    // Update chunk meta data stored in the index, as it may have changed.
-    record_meta->num_fragments = num_fragments;
-    record_meta->flags = chunk_flags;
-    record_meta->set_complete(chunk_complete);
-
-    // Override the ChunkRecord contents at the original |wptr|.
-    TRACE_BUFFER_DLOG("  copying @ [%lu - %lu] %zu", wptr - begin(),
-                      uintptr_t(wptr - begin()) + record_size, record_size);
-    WriteChunkRecord(wptr, record, src, size);
-    TRACE_BUFFER_DLOG("Chunk raw: %s",
-                      base::HexDump(wptr, record_size).c_str());
-    stats_.set_chunks_rewritten(stats_.chunks_rewritten() + 1);
-    return;
   }
 
-  if (PERFETTO_UNLIKELY(discard_writes_))
-    return DiscardWrite();
+  // Populate shadow buffer stats.
+  auto* shadow_stats = stats_.mutable_shadow_buffer_stats();
+  shadow_stats->set_stats_version(2);
+  shadow_stats->set_packets_seen(packets_seen_);
+  shadow_stats->set_packets_in_both(packets_in_both);
+  shadow_stats->set_packets_only_v1(packets_only_v1);
+  shadow_stats->set_packets_only_v2(packets_only_v2);
+  shadow_stats->set_patches_attempted(patches_attempted_);
+  shadow_stats->set_v1_patches_succeeded(v1_patches_succeeded_);
+  shadow_stats->set_v2_patches_succeeded(v2_patches_succeeded_);
+}
 
-  // If there isn't enough room from the given write position. Write a padding
-  // record to clear the end of the buffer and wrap back.
-  const size_t cached_size_to_end = size_to_end();
-  if (PERFETTO_UNLIKELY(record_size > cached_size_to_end)) {
-    ssize_t res = DeleteNextChunksFor(cached_size_to_end);
-    if (res == -1)
-      return DiscardWrite();
-    PERFETTO_DCHECK(static_cast<size_t>(res) <= cached_size_to_end);
-    AddPaddingRecord(cached_size_to_end);
-    wptr_ = begin();
-    stats_.set_write_wrap_count(stats_.write_wrap_count() + 1);
-    PERFETTO_DCHECK(size_to_end() >= record_size);
-  }
+void TraceBufferV1WithV2Shadow::set_read_only() {
+  v1_->set_read_only();
+  v2_->set_read_only();
+}
 
-  // At this point either |wptr_| points to an untouched part of the buffer
-  // (i.e. *wptr_ == 0) or we are about to overwrite one or more ChunkRecord(s).
-  // In the latter case we need to first figure out where the next valid
-  // ChunkRecord is (if it exists) and add padding between the new record.
-  // Example ((w) == write cursor):
-  //
-  // Initial state (wtpr_ == 0):
-  // |0 (w)    |10               |30                  |50
-  // +---------+-----------------+--------------------+--------------------+
-  // | Chunk 1 | Chunk 2         | Chunk 3            | Chunk 4            |
-  // +---------+-----------------+--------------------+--------------------+
-  //
-  // Let's assume we now want now write a 5th Chunk of size == 35. The final
-  // state should look like this:
-  // |0                                |35 (w)         |50
-  // +---------------------------------+---------------+--------------------+
-  // | Chunk 5                         | Padding Chunk | Chunk 4            |
-  // +---------------------------------+---------------+--------------------+
+const TraceBuffer::WriterStats& TraceBufferV1WithV2Shadow::writer_stats()
+    const {
+  return v1_->writer_stats();
+}
 
-  // Deletes all chunks from |wptr_| to |wptr_| + |record_size|.
-  ssize_t del_res = DeleteNextChunksFor(record_size);
-  if (del_res == -1)
-    return DiscardWrite();
-  size_t padding_size = static_cast<size_t>(del_res);
+size_t TraceBufferV1WithV2Shadow::size() const {
+  return v1_->size();
+}
 
-  // Now first insert the new chunk. At the end, if necessary, add the padding.
-  stats_.set_chunks_written(stats_.chunks_written() + 1);
-  stats_.set_bytes_written(stats_.bytes_written() + record_size);
+size_t TraceBufferV1WithV2Shadow::used_size() const {
+  return v1_->used_size();
+}
 
-  uint32_t chunk_off = GetOffset(GetChunkRecordAt(wptr_));
-  auto it_and_inserted = index_.emplace(
-      key, ChunkMeta(chunk_off, num_fragments, chunk_complete, chunk_flags,
-                     producer_uid_trusted, producer_pid_trusted));
-  PERFETTO_DCHECK(it_and_inserted.second);
-  TRACE_BUFFER_DLOG("  copying @ [%lu - %lu] %zu", wptr_ - begin(),
-                    uintptr_t(wptr_ - begin()) + record_size, record_size);
-  WriteChunkRecord(wptr_, record, src, size);
-  TRACE_BUFFER_DLOG("Chunk raw: %s", base::HexDump(wptr_, record_size).c_str());
-  wptr_ += record_size;
-  if (wptr_ >= end()) {
-    PERFETTO_DCHECK(padding_size == 0);
-    wptr_ = begin();
-    stats_.set_write_wrap_count(stats_.write_wrap_count() + 1);
-  }
-  DcheckIsAlignedAndWithinBounds(wptr_);
+size_t TraceBufferV1WithV2Shadow::GetMemoryUsageBytes() const {
+  return v1_->GetMemoryUsageBytes() + v2_->GetMemoryUsageBytes();
+}
 
-  // Chunks may be received out of order, so only update last_chunk_id if the
-  // new chunk_id is larger. But take into account overflows by only selecting
-  // the new ID if its distance to the latest ID is smaller than half the number
-  // space.
-  //
-  // This accounts for both the case where the new ID has just overflown and
-  // last_chunk_id be updated even though it's smaller (e.g. |chunk_id| = 1 and
-  // |last_chunk_id| = kMaxChunkId; chunk_id - last_chunk_id = 0) and the case
-  // where the new ID is an out-of-order ID right after an overflow and
-  // last_chunk_id shouldn't be updated even though it's larger (e.g. |chunk_id|
-  // = kMaxChunkId and |last_chunk_id| = 1; chunk_id - last_chunk_id =
-  // kMaxChunkId - 1).
-  auto producer_and_writer_id = std::make_pair(producer_id_trusted, writer_id);
-  ChunkID& last_chunk_id = last_chunk_id_written_[producer_and_writer_id];
-  static_assert(std::numeric_limits<ChunkID>::max() == kMaxChunkID,
-                "This code assumes that ChunkID wraps at kMaxChunkID");
-  if (chunk_id - last_chunk_id < kMaxChunkID / 2) {
-    last_chunk_id = chunk_id;
-  } else {
-    stats_.set_chunks_committed_out_of_order(
-        stats_.chunks_committed_out_of_order() + 1);
-  }
+TraceBuffer::OverwritePolicy TraceBufferV1WithV2Shadow::overwrite_policy()
+    const {
+  return v1_->overwrite_policy();
+}
 
-  if (padding_size)
-    AddPaddingRecord(padding_size);
+bool TraceBufferV1WithV2Shadow::has_data() const {
+  return v1_->has_data();
 }
 
-ssize_t TraceBuffer::DeleteNextChunksFor(size_t bytes_to_clear) {
-  PERFETTO_CHECK(!discard_writes_);
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/service/trace_buffer_v2.cc
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-  // Find the position of the first chunk which begins at or after
-  // (|wptr_| + |bytes|). Note that such a chunk might not exist and we might
-  // either reach the end of the buffer or a zeroed region of the buffer.
-  uint8_t* next_chunk_ptr = wptr_;
-  uint8_t* search_end = wptr_ + bytes_to_clear;
-  TRACE_BUFFER_DLOG("Delete [%zu %zu]", wptr_ - begin(), search_end - begin());
-  DcheckIsAlignedAndWithinBounds(wptr_);
-  PERFETTO_DCHECK(search_end <= end());
-  std::vector<ChunkMap::iterator> index_delete;
-  uint64_t chunks_overwritten = stats_.chunks_overwritten();
-  uint64_t bytes_overwritten = stats_.bytes_overwritten();
-  uint64_t padding_bytes_cleared = stats_.padding_bytes_cleared();
-  while (next_chunk_ptr < search_end) {
-    const ChunkRecord& next_chunk = *GetChunkRecordAt(next_chunk_ptr);
-    TRACE_BUFFER_DLOG(
-        "  scanning chunk [%zu %zu] (valid=%d)", next_chunk_ptr - begin(),
-        next_chunk_ptr - begin() + next_chunk.size, next_chunk.is_valid());
+// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer_v2.h"
 
-    // We just reached the untouched part of the buffer, it's going to be all
-    // zeroes from here to end().
-    // Optimization: if during Initialize() we fill the buffer with padding
-    // records we could get rid of this branch.
-    if (PERFETTO_UNLIKELY(!next_chunk.is_valid())) {
-      // This should happen only at the first iteration. The zeroed area can
-      // only begin precisely at the |wptr_|, not after. Otherwise it means that
-      // we wrapped but screwed up the ChunkRecord chain.
-      PERFETTO_DCHECK(next_chunk_ptr == wptr_);
-      return 0;
-    }
+#include <algorithm>
+#include <memory>
 
-    // Remove |next_chunk| from the index, unless it's a padding record (padding
-    // records are not part of the index).
-    if (PERFETTO_LIKELY(!next_chunk.is_padding)) {
-      ChunkMeta::Key key(next_chunk);
-      auto it = index_.find(key);
-      bool will_remove = false;
-      if (PERFETTO_LIKELY(it != index_.end())) {
-        const ChunkMeta& meta = it->second;
-        if (PERFETTO_UNLIKELY(meta.num_fragments_read < meta.num_fragments)) {
-          if (overwrite_policy_ == kDiscard)
-            return -1;
-          chunks_overwritten++;
-          bytes_overwritten += next_chunk.size;
-        }
-        index_delete.push_back(it);
-        will_remove = true;
-      }
-      TRACE_BUFFER_DLOG(
-          "  del index {%" PRIu32 ",%" PRIu32 ",%u} @ [%lu - %lu] %d",
-          key.producer_id, key.writer_id, key.chunk_id,
-          next_chunk_ptr - begin(), next_chunk_ptr - begin() + next_chunk.size,
-          will_remove);
-      PERFETTO_DCHECK(will_remove);
-    } else {
-      padding_bytes_cleared += next_chunk.size;
-    }
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/murmur_hash.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/client_identity.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_abi.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "src/protovm/vm.h"
 
-    next_chunk_ptr += next_chunk.size;
+// Set manually when debugging test failures.
+// TRACE_BUFFER_V2_DLOG is too verbose, even for debug builds.
+#define TRACE_BUFFER_V2_VERBOSE_LOGGING() 0
 
-    // We should never hit this, unless we managed to screw up while writing
-    // to the buffer and breaking the ChunkRecord(s) chain.
-    // TODO(primiano): Write more meaningful logging with the status of the
-    // buffer, to get more actionable bugs in case we hit this.
-    PERFETTO_CHECK(next_chunk_ptr <= end());
-  }
+#if TRACE_BUFFER_V2_VERBOSE_LOGGING()
+#define TRACE_BUFFER_V2_DLOG PERFETTO_DLOG
+#else
+#define TRACE_BUFFER_V2_DLOG(...) base::ignore_result(__VA_ARGS__)
+#endif
 
-  // Remove from the index.
-  for (auto it : index_delete) {
-    index_.erase(it);
-  }
-  stats_.set_chunks_overwritten(chunks_overwritten);
-  stats_.set_bytes_overwritten(bytes_overwritten);
-  stats_.set_padding_bytes_cleared(padding_bytes_cleared);
+using protozero::proto_utils::ParseVarInt;
+namespace proto_utils = ::protozero::proto_utils;
 
-  PERFETTO_DCHECK(next_chunk_ptr >= search_end && next_chunk_ptr <= end());
-  return static_cast<ssize_t>(next_chunk_ptr - search_end);
-}
+namespace perfetto {
 
-void TraceBuffer::AddPaddingRecord(size_t size) {
-  PERFETTO_DCHECK(size >= sizeof(ChunkRecord) && size <= ChunkRecord::kMaxSize);
-  ChunkRecord record(size);
-  record.is_padding = 1;
-  TRACE_BUFFER_DLOG("AddPaddingRecord @ [%lu - %lu] %zu", wptr_ - begin(),
-                    uintptr_t(wptr_ - begin()) + size, size);
-  WriteChunkRecord(wptr_, record, nullptr, size - sizeof(ChunkRecord));
-  stats_.set_padding_bytes_written(stats_.padding_bytes_written() + size);
-  // |wptr_| is deliberately not advanced when writing a padding record.
-}
+namespace {
 
-bool TraceBuffer::TryPatchChunkContents(ProducerID producer_id,
-                                        WriterID writer_id,
-                                        ChunkID chunk_id,
-                                        const Patch* patches,
-                                        size_t patches_size,
-                                        bool other_patches_pending) {
-  PERFETTO_CHECK(!read_only_);
-  ChunkMeta::Key key(producer_id, writer_id, chunk_id);
-  auto it = index_.find(key);
-  if (it == index_.end()) {
-    stats_.set_patches_failed(stats_.patches_failed() + 1);
-    return false;
-  }
-  ChunkMeta& chunk_meta = it->second;
+// The names below need some mangling because v1/v2.cc collide in the
+// amalgamated builds.
+constexpr uint8_t kFirstPacketContFromPrevChunk =
+    SharedMemoryABI::ChunkHeader::kFirstPacketContinuesFromPrevChunk;
+constexpr uint8_t kLastPacketContOnNextChunk =
+    SharedMemoryABI::ChunkHeader::kLastPacketContinuesOnNextChunk;
+constexpr uint8_t kChunkNeedsPatch =
+    SharedMemoryABI::ChunkHeader::kChunkNeedsPatching;
 
-  // Check that the index is consistent with the actual ProducerID/WriterID
-  // stored in the ChunkRecord.
+// The only thing that causes incomplete-ness is SMB scraping, when calling
+// CopyChunkUntrusted(...chunk_complete=false). This has nothing to do with
+// patching.
+constexpr uint8_t kChunkIncomplete = 0x80;
 
-  ChunkRecord* chunk_record = GetChunkRecordAt(begin() + chunk_meta.record_off);
-  PERFETTO_DCHECK(ChunkMeta::Key(*chunk_record) == key);
-  uint8_t* chunk_begin = reinterpret_cast<uint8_t*>(chunk_record);
-  PERFETTO_DCHECK(chunk_begin >= begin());
-  uint8_t* chunk_end = chunk_begin + chunk_record->size;
-  PERFETTO_DCHECK(chunk_end <= end());
+// Mask out the flags that don't come from the ABI like kChunkIncomplete.
+constexpr uint8_t kFlagsMask = SharedMemoryABI::ChunkHeader::kFlagsMask;
+
+// Compares two ChunkID(s) in a wrapping 32-bit ID space.
+// Returns:
+//   -1 if a comes before b in modular (wrapping) order.
+//    0 if a == b
+//   +1 if a comes after b in modular order.
+//
+// The key idea is that the order between two distinct IDs is determined by
+// whether the distance from a to b is less than 2^31 (half the range).
+// Many other TCP/IP stacks do the same, e.g.
+// https://github.com/openbsd/src/blob/master/sys/netinet/tcp_seq.h#L43
+int ChunkIdCompare(ChunkID a, ChunkID b) {
+  if (a == b)
+    return 0;
+  return (static_cast<int32_t>(a - b) < 0) ? -1 : 1;
+}
 
-  static_assert(Patch::kSize == SharedMemoryABI::kPacketHeaderSize,
-                "Patch::kSize out of sync with SharedMemoryABI");
+// The number of the latest empty SequenceState(s) to keep around.
+constexpr size_t kKeepLastEmptySeq = 1024;
 
-  for (size_t i = 0; i < patches_size; i++) {
-    uint8_t* ptr =
-        chunk_begin + sizeof(ChunkRecord) + patches[i].offset_untrusted;
-    TRACE_BUFFER_DLOG("PatchChunk {%" PRIu32 ",%" PRIu32
-                      ",%u} size=%zu @ %zu with {%02x %02x %02x %02x} cur "
-                      "{%02x %02x %02x %02x}",
-                      producer_id, writer_id, chunk_id, chunk_end - chunk_begin,
-                      patches[i].offset_untrusted, patches[i].data[0],
-                      patches[i].data[1], patches[i].data[2],
-                      patches[i].data[3], ptr[0], ptr[1], ptr[2], ptr[3]);
-    if (ptr < chunk_begin + sizeof(ChunkRecord) ||
-        ptr > chunk_end - Patch::kSize) {
-      // Either the IPC was so slow and in the meantime the writer managed to
-      // wrap over |chunk_id| or the producer sent a malicious IPC.
-      stats_.set_patches_failed(stats_.patches_failed() + 1);
-      return false;
-    }
+// The threshold when we start scanning and deleting the oldest sequences.
+constexpr size_t kEmptySequencesGcTreshold = kKeepLastEmptySeq + 128;
+}  // namespace.
 
-    memcpy(ptr, &patches[i].data[0], Patch::kSize);
-  }
-  TRACE_BUFFER_DLOG("Chunk raw (after patch): %s",
-                    base::HexDump(chunk_begin, chunk_record->size).c_str());
+namespace internal {
 
-  stats_.set_patches_succeeded(stats_.patches_succeeded() + patches_size);
-  if (!other_patches_pending) {
-    chunk_meta.flags &= ~kChunkNeedsPatching;
-    chunk_record->flags = chunk_meta.flags;
+SequenceState::SequenceState(ProducerID p, WriterID w, ClientIdentity c)
+    : producer_id(p),
+      writer_id(w),
+      client_identity(c),
+      chunks(/*initial_capacity=*/64) {}
+SequenceState::~SequenceState() = default;
+SequenceState::SequenceState(const SequenceState&) noexcept = default;
+SequenceState& SequenceState::operator=(const SequenceState&) noexcept =
+    default;
+
+// +---------------------------------------------------------------------------+
+// | FragIterator                                                              |
+// +---------------------------------------------------------------------------+
+
+std::optional<Frag> FragIterator::NextFragmentInChunk() {
+  // This function must always visit all the fragments without ever returning
+  // early. If some early return is needed, it must be done by the caller.
+  PERFETTO_DCHECK(next_frag_off_ <= chunk_size_);
+  const uint8_t* chunk_end = chunk_begin_ + chunk_size_;
+  const uint8_t* hdr_begin = chunk_begin_ + next_frag_off_;
+  if (hdr_begin >= chunk_end)
+    return std::nullopt;
+
+  bool is_first_frag = next_frag_off_ == 0;
+  uint64_t frag_size_u64 = 0;
+
+  // The structure of a fragment is the following:
+  // [ varint header ] [ payload                       ]
+  // frag_begin:  points at the beginning of the payload.
+  // hdr_size     is the size in bytes of the varint header (1 or more bytes).
+  // frag_size    is the size of the payload, without counting the header.
+  uint8_t* frag_begin =
+      const_cast<uint8_t*>(ParseVarInt(hdr_begin, chunk_end, &frag_size_u64));
+  uint8_t hdr_size =  // The fragment header is just a varint stating its size.
+      static_cast<uint8_t>(reinterpret_cast<uintptr_t>(frag_begin) -
+                           reinterpret_cast<uintptr_t>(hdr_begin));
+
+  // If the varint header is too long (e.g. ff ff .. ff), ParseVarInt will bail
+  // will out after 10 bytes.
+  if (PERFETTO_UNLIKELY(hdr_size == 0)) {
+    chunk_corrupted_ = true;
+    return std::nullopt;
+  }
+
+  // In BufferExhaustedPolicy::kDrop mode, Since Android R, TraceWriter may
+  // abort a fragmented packet by writing an invalid size in the last
+  // fragment's header. We should handle this case without recording an ABI
+  // violation.
+  if (PERFETTO_UNLIKELY(frag_size_u64 ==
+                        SharedMemoryABI::kPacketSizeDropPacket)) {
+    trace_writer_data_drop_ = true;
+    return std::nullopt;
+  }
+
+  // We don't need to do anything special about padding chunks, because their
+  // payload_avail is always 0. We naturally return nullopt on the check below.
+  if (frag_size_u64 > reinterpret_cast<uintptr_t>(chunk_end) -
+                          reinterpret_cast<uintptr_t>(frag_begin)) {
+    chunk_corrupted_ = true;
+    return std::nullopt;
+  }
+
+  uint16_t frag_size = static_cast<uint16_t>(frag_size_u64);
+  next_frag_off_ += hdr_size + frag_size;  // Was: next_frag_off_ += frag_size;
+  bool is_last_frag = next_frag_off_ >= chunk_size_;
+  bool first_frag_continues = chunk_flags_ & kFirstPacketContFromPrevChunk;
+  bool last_frag_continues = chunk_flags_ & kLastPacketContOnNextChunk;
+
+  Frag::FragType frag_type = Frag::kFragWholePacket;
+  if (is_last_frag && last_frag_continues) {
+    if (is_first_frag && first_frag_continues) {
+      frag_type = Frag::kFragContinue;
+    } else {
+      frag_type = Frag::kFragBegin;
+    }
+  } else if (is_first_frag && first_frag_continues) {
+    frag_type = Frag::kFragEnd;
+  } else {
+    frag_type = Frag::kFragWholePacket;
   }
-  return true;
+  return Frag(frag_begin, frag_type, hdr_size, frag_size);
 }
 
-void TraceBuffer::BeginRead() {
-  read_iter_ = GetReadIterForSequence(index_.begin());
-#if PERFETTO_DCHECK_IS_ON()
-  changed_since_last_read_ = false;
-#endif
+// +---------------------------------------------------------------------------+
+// | ChunkSeqIterator                                                          |
+// +---------------------------------------------------------------------------+
+
+ChunkSeqIterator::ChunkSeqIterator(TraceBufferV2* buf, SequenceState* seq)
+    : buf_(buf), seq_(seq) {
+  auto& chunk_list = seq_->chunks;
+  PERFETTO_CHECK(!chunk_list.empty());
+  size_t first_off = *chunk_list.begin();
+  TBChunk* first_chunk_of_seq = buf->GetTBChunkAt(first_off);
+  PERFETTO_DCHECK(!first_chunk_of_seq->is_padding());
+  chunk_ = first_chunk_of_seq;
 }
 
-TraceBuffer::SequenceIterator TraceBuffer::GetReadIterForSequence(
-    ChunkMap::iterator seq_begin) {
-  SequenceIterator iter;
-  iter.seq_begin = seq_begin;
-  if (seq_begin == index_.end()) {
-    iter.cur = iter.seq_end = index_.end();
-    return iter;
+TBChunk* ChunkSeqIterator::NextChunkInSequence() {
+  PERFETTO_DCHECK(seq_);
+  auto& chunk_list = seq_->chunks;
+
+  // Either the current chunk has been deleted (is_padding()), or if it exist it
+  // must be consistent with the internal tracking in list_idx_.
+  PERFETTO_DCHECK(chunk_->is_padding() ||
+                  chunk_list.at(list_idx_) == buf_->OffsetOf(chunk_));
+
+  size_t next_list_idx = list_idx_ + 1;
+  if (next_list_idx >= chunk_list.size()) {
+    // There is no "next chunk" the chunk list for this sequence.
+    // NOTE: this has nothing to do with the "ChunkID is not consecutive" check
+    // which is performed below. This is a more basic failure mode where we just
+    // don't have any chunks at all, whether they are consecutive or not.
+    return nullptr;
   }
 
-#if PERFETTO_DCHECK_IS_ON()
-  // Either |seq_begin| is == index_.begin() or the item immediately before must
-  // belong to a different {ProducerID, WriterID} sequence.
-  if (seq_begin != index_.begin() && seq_begin != index_.end()) {
-    auto prev_it = seq_begin;
-    prev_it--;
-    PERFETTO_DCHECK(
-        seq_begin == index_.begin() ||
-        std::tie(prev_it->first.producer_id, prev_it->first.writer_id) <
-            std::tie(seq_begin->first.producer_id, seq_begin->first.writer_id));
+  // At this point we need to work out if the sequence of ChunkID(s) is
+  // contiguous or we have gaps. There are two scenarios here:
+  // 1) We are iterating and consuming as part of ReadNextTracePacket(). When
+  //    we do this, each iteration erases the last chunk before moving onto the
+  //    next one. We can't use the SequenceState.chunks because the upcoming
+  //    chunk will always be the "first" in this case. However, we can look at
+  //    last_chunk_id_consumed.
+  // 2) We are iterating read-only as part of ReassembleFragmentedPacket(). In
+  //    this case we are not consuming any chunk, and we can use the combination
+  //    of SequenceState.chunks[SequenceState.next_seq_idx].
+  std::optional<ChunkID> last_chunk_id;
+  if (chunk_->is_padding()) {
+    last_chunk_id = seq_->last_chunk_id_consumed;  // Case 1.
+  } else {
+    last_chunk_id = chunk_->chunk_id;  // Case 2
   }
-#endif
 
-  // Find the first entry that has a greater {ProducerID, WriterID} (or just
-  // index_.end() if we reached the end).
-  ChunkMeta::Key key = seq_begin->first;  // Deliberate copy.
-  key.chunk_id = kMaxChunkID;
-  iter.seq_end = index_.upper_bound(key);
-  PERFETTO_DCHECK(iter.seq_begin != iter.seq_end);
+  size_t next_chunk_off = chunk_list.at(next_list_idx);      // O(1)
+  TBChunk* next_chunk = buf_->GetTBChunkAt(next_chunk_off);  // O(1)
 
-  // Now find the first entry between [seq_begin, seq_end) that is
-  // > last_chunk_id_written_. This is where we the sequence will start (see
-  // notes about wrapping of IDs in the header).
-  auto producer_and_writer_id = std::make_pair(key.producer_id, key.writer_id);
-  PERFETTO_DCHECK(last_chunk_id_written_.count(producer_and_writer_id));
-  iter.wrapping_id = last_chunk_id_written_[producer_and_writer_id];
-  key.chunk_id = iter.wrapping_id;
-  iter.cur = index_.upper_bound(key);
-  if (iter.cur == iter.seq_end)
-    iter.cur = iter.seq_begin;
-  return iter;
+  if (last_chunk_id.has_value() && next_chunk->chunk_id != *last_chunk_id + 1)
+    sequence_gap_detected_ = true;
+
+  chunk_ = next_chunk;
+  list_idx_ = next_list_idx;
+  return next_chunk;
 }
 
-void TraceBuffer::SequenceIterator::MoveNext() {
-  // Stop iterating when we reach the end of the sequence.
-  // Note: |seq_begin| might be == |seq_end|.
-  if (cur == seq_end || cur->first.chunk_id == wrapping_id) {
-    cur = seq_end;
-    return;
-  }
+void ChunkSeqIterator::EraseCurrentChunk() {
+  size_t chunk_off = buf_->OffsetOf(chunk_);
+  TRACE_BUFFER_V2_DLOG("EraseChunk() id=%u off=%zu", chunk_->chunk_id,
+                       chunk_off);
+  const uint32_t chunk_size = chunk_->size;
+  seq_->last_chunk_id_consumed = chunk_->chunk_id;
 
-  // If the current chunk wasn't completed yet, we shouldn't advance past it as
-  // it may be rewritten with additional packets.
-  if (!cur->second.is_complete()) {
-    cur = seq_end;
-    return;
+  auto& chunk_list = seq_->chunks;
+
+  // At the time of writing we only support erasing the first chunk of the
+  // sequence. Erasing from the middle is possible but requires more efforts
+  // to keep in sync the SequenceState.chunks with our list_idx_.
+  PERFETTO_CHECK(list_idx_ == 0 && *chunk_list.begin() == chunk_off);
+  chunk_list.pop_front();
+  if (chunk_list.empty()) {
+    seq_->age_for_gc = ++buf_->seq_age_;
+    ++buf_->empty_sequences_;
   }
 
-  ChunkID last_chunk_id = cur->first.chunk_id;
-  if (++cur == seq_end)
-    cur = seq_begin;
+  // list_idx_ points to the current index, but we just deleted it.
+  // Point it to -1, so the next time that is incremented it goes back to the
+  // 0th element, which is the one after the one being deleted.
+  list_idx_ = static_cast<size_t>(-1);
 
-  // There may be a missing chunk in the sequence of chunks, in which case the
-  // next chunk's ID won't follow the last one's. If so, skip the rest of the
-  // sequence. We'll return to it later once the hole is filled.
-  if (last_chunk_id + 1 != cur->first.chunk_id)
-    cur = seq_end;
+  // Zero all the fields of the chunk.
+  uint16_t old_payload_size = chunk_->payload_size;
+  TBChunk* cleared_chunk = buf_->CreateTBChunk(chunk_off, chunk_size);
+  cleared_chunk->payload_size = old_payload_size;
+
+  // NOTE Stats are NOT updated here. The right place to update stat is in the
+  // callers, specifically DeleteNextChunksFor (when we overwrite) and
+  // ConsumeFragment (when we read).
 }
 
-bool TraceBuffer::ReadNextTracePacket(
-    TracePacket* packet,
-    PacketSequenceProperties* sequence_properties,
-    bool* previous_packet_on_sequence_dropped) {
-  // Note: MoveNext() moves only within the next chunk within the same
-  // {ProducerID, WriterID} sequence. Here we want to:
-  // - return the next patched+complete packet in the current sequence, if any.
-  // - return the first patched+complete packet in the next sequence, if any.
-  // - return false if none of the above is found.
-  TRACE_BUFFER_DLOG("ReadNextTracePacket()");
+// +---------------------------------------------------------------------------+
+// | ChunkSeqReader                                                            |
+// +---------------------------------------------------------------------------+
 
-  // Just in case we forget to initialize these below.
-  *sequence_properties = {0, kInvalidUid, base::kInvalidPid, 0};
-  *previous_packet_on_sequence_dropped = false;
+ChunkSeqReader::ChunkSeqReader(TraceBufferV2* buf,
+                               TBChunk* end_chunk,
+                               Mode mode)
+    : buf_(buf),
+      mode_(mode),
+      end_(end_chunk),
+      seq_(buf_->GetSeqForChunk(end_chunk)),
+      seq_iter_(buf, seq_),
+      iter_(seq_iter_.chunk()),  // Points to the first chunk of the sequence.
+      frag_iter_(iter_) {
+  PERFETTO_DCHECK(!iter_->is_padding());
+  TRACE_BUFFER_V2_DLOG("ChunkSeqReader() last_id=%u iter_=%u end_=%u",
+                       seq_->last_chunk_id_consumed.value_or(0),
+                       iter_->chunk_id, end_->chunk_id);
 
-  // At the start of each sequence iteration, we consider the last read packet
-  // dropped. While iterating over the chunks in the sequence, we update this
-  // flag based on our knowledge about the last packet that was read from each
-  // chunk (|last_read_packet_skipped| in ChunkMeta).
-  bool previous_packet_dropped = true;
+  if (seq_->last_chunk_id_consumed.has_value() &&
+      iter_->chunk_id != *seq_->last_chunk_id_consumed + 1) {
+    seq_->data_loss = true;
+  }
+}
 
-#if PERFETTO_DCHECK_IS_ON()
-  PERFETTO_DCHECK(!changed_since_last_read_);
-#endif
-  for (;; read_iter_.MoveNext()) {
-    if (PERFETTO_UNLIKELY(!read_iter_.is_valid())) {
-      // We ran out of chunks in the current {ProducerID, WriterID} sequence or
-      // we just reached the index_.end().
+bool ChunkSeqReader::ReadNextPacketInSeqOrder(TracePacket* out_packet) {
+  PERFETTO_DCHECK(!iter_->is_padding());
+  PERFETTO_DCHECK(frag_iter_.next_frag_off() >= iter_->unread_payload_off());
+  PERFETTO_DCHECK(frag_iter_.next_frag_off() <= iter_->payload_size);
 
-      if (PERFETTO_UNLIKELY(read_iter_.seq_end == index_.end()))
-        return false;
+  // skip_in_generation is set when we detect a situation that requires
+  // "stalling" (i.e. skipping) the sequence: a fragment with no further data;
+  // a kNeedsPatching chunk; a kChunkIncomplete.
+  if (seq_->skip_in_generation == buf_->read_generation_ && mode_ == kReadMode)
+    return false;
 
-      // We reached the end of sequence, move to the next one.
-      // Note: ++read_iter_.seq_end might become index_.end(), but
-      // GetReadIterForSequence() knows how to deal with that.
-      read_iter_ = GetReadIterForSequence(read_iter_.seq_end);
-      PERFETTO_DCHECK(read_iter_.is_valid() && read_iter_.cur != index_.end());
-      previous_packet_dropped = true;
-    }
+  // It is very important that this loop terminates only after having visited
+  // all the fragments of all the chunks in the sequence up to `end_` (which is
+  // the chunk passed initially to the ChunkSeqReader's ctor).
+  // This is because this class is used both while doing readbacks and,
+  // importantly, in DeleteNextChunksFor() when overwriting.
+  for (;;) {
+    std::optional<Frag> maybe_frag = frag_iter_.NextFragmentInChunk();
+    if (!maybe_frag.has_value()) {
+      // Once we exhaust all fragments, move to the next chunk in the sequence.
+      bool end_reached = iter_ == end_;
 
-    ChunkMeta* chunk_meta = &*read_iter_;
+      if (frag_iter_.chunk_corrupted()) {
+        seq_->data_loss = true;
+      }
 
-    // If the chunk has holes that are awaiting to be patched out-of-band,
-    // skip the current sequence and move to the next one.
-    if (chunk_meta->flags & kChunkNeedsPatching) {
-      read_iter_.MoveToEnd();
+      // If a chunk is incomplete, this is the point where we stop processing
+      // the sequence (unless it is a deletion, in which case, complete or not,
+      // we have to go over it anyways because we need space for a new chunk).
+      if ((iter_->flags & kChunkIncomplete) && mode_ == kReadMode) {
+        // If the chunk is incomplete, we don't want to read past it.
+        seq_->skip_in_generation = buf_->read_generation_;
+        end_reached = true;
+      } else {
+        // We read all the fragments for the current chunk. Erase it.
+        seq_iter_.EraseCurrentChunk();
+      }
+      if (end_reached)
+        return false;  // We reached our target chunk (or an incomplete chunk).
+      TBChunk* next_chunk = seq_iter_.NextChunkInSequence();
+      if (!next_chunk)
+        return false;  // There are no more chunks in the sequence.
+      iter_ = next_chunk;
+      frag_iter_ = FragIterator(next_chunk);
       continue;
     }
 
-    const ProducerID trusted_producer_id = read_iter_.producer_id();
-    const WriterID writer_id = read_iter_.writer_id();
-    const uid_t trusted_uid = chunk_meta->trusted_uid;
-    const pid_t trusted_pid = chunk_meta->trusted_pid;
+    Frag& frag = *maybe_frag;
+    switch (frag.type) {
+      case Frag::kFragWholePacket:
+        ConsumeFragment(iter_, &frag);
+        // It's questionable whether we should propagate out empty packets. Here
+        // we match the behavior of the legacy TraceBufferV1. Some clients might
+        // be relying on the fact that empty packets don't bloat the final trace
+        // file size.
+        if (frag.size == 0) {
+          break;  // Breaks the switch(), continues the loop.
+        }
+        if (out_packet)
+          out_packet->AddSlice(frag.begin, frag.size);
+        TRACE_BUFFER_V2_DLOG(
+            "  ReadNextPacketInSeqOrder -> true (whole packet)");
+        return true;
 
-    // At this point we have a chunk in |chunk_meta| that has not been fully
-    // read. We don't know yet whether we have enough data to read the full
-    // packet (in the case it's fragmented over several chunks) and we are about
-    // to find that out. Specifically:
-    // A) If the first fragment is unread and is a fragment continuing from a
-    //    previous chunk, it means we have missed the previous ChunkID. In
-    //    fact, if this wasn't the case, a previous call to ReadNext() shouldn't
-    //    have moved the cursor to this chunk.
-    // B) Any fragment > 0 && < last is always readable. By definition an inner
-    //    packet is never fragmented and hence doesn't require neither stitching
-    //    nor any out-of-band patching. The same applies to the last packet
-    //    iff it doesn't continue on the next chunk.
-    // C) If the last packet (which might be also the only packet in the chunk)
-    //    is a fragment and continues on the next chunk, we peek at the next
-    //    chunks and, if we have all of them, mark as read and move the cursor.
-    //
-    // +---------------+   +-------------------+  +---------------+
-    // | ChunkID: 1    |   | ChunkID: 2        |  | ChunkID: 3    |
-    // |---------------+   +-------------------+  +---------------+
-    // | Packet 1      |   |                   |  | ... Packet 3  |
-    // | Packet 2      |   | ... Packet 3  ... |  | Packet 4      |
-    // | Packet 3  ... |   |                   |  | Packet 5 ...  |
-    // +---------------+   +-------------------+  +---------------+
+      case Frag::kFragContinue:
+      case Frag::kFragEnd:
+        // We should never hit these cases while iterating in this loop.
+        // In nominal conditions we should only see kFragBegin, and then we
+        // should iterate over the Continue/End in ReassembleFragmentedPacket(),
+        // which performs the lookahead. If we hit this code path, either a
+        // producer emitted a chunk sequence like [kWholePacket],[kFragEnd]
+        // or, more realistically, we had a data losss and missed the chunk with
+        // the kFragBegin.
+        seq_->data_loss = true;
+        ConsumeFragment(iter_, &frag);
+        break;  // Break the switch, continue the loop.
+
+      case Frag::kFragBegin:
+        auto reassembly_res = ReassembleFragmentedPacket(out_packet, &frag);
+        if (reassembly_res == FragReassemblyResult::kSuccess) {
+          buf_->stats_.set_readaheads_succeeded(
+              buf_->stats_.readaheads_succeeded() + 1);
+
+          // We found and consumed all the fragments for the packet.
+          // On the next ReadNextTracePacket() call, NextFragmentInChunk() will
+          // return nullopt (because, modulo client bugs, the kFragBegin here
+          // is the last fragment of the chunk). That code branch above will
+          // erase the chunk and continue with the next chunk (either in buffer
+          // or sequence order).
+          TRACE_BUFFER_V2_DLOG(
+              "  ReadNextPacketInSeqOrder -> true (reassembly)");
+          return true;
+        }
 
-    PERFETTO_DCHECK(chunk_meta->num_fragments_read <=
-                    chunk_meta->num_fragments);
+        // If we get here reassembly_res is either kNotEnoughData or kDataLoss.
 
-    // If we didn't read any packets from this chunk, the last packet was from
-    // the previous chunk we iterated over; so don't update
-    // |previous_packet_dropped| in this case.
-    if (chunk_meta->num_fragments_read > 0)
-      previous_packet_dropped = chunk_meta->last_read_packet_skipped();
+        buf_->stats_.set_readaheads_failed(buf_->stats_.readaheads_failed() +
+                                           1);
 
-    while (chunk_meta->num_fragments_read < chunk_meta->num_fragments) {
-      enum { kSkip = 0, kReadOnePacket, kTryReadAhead } action;
-      if (chunk_meta->num_fragments_read == 0) {
-        if (chunk_meta->flags & kFirstPacketContinuesFromPrevChunk) {
-          action = kSkip;  // Case A.
-        } else if (chunk_meta->num_fragments == 1 &&
-                   (chunk_meta->flags & kLastPacketContinuesOnNextChunk)) {
-          action = kTryReadAhead;  // Case C.
-        } else {
-          action = kReadOnePacket;  // Case B.
+        if (reassembly_res == FragReassemblyResult::kNotEnoughData &&
+            mode_ == kReadMode) {
+          // If we got no more chunks, there is no point insisting with this
+          // chunk, give up and let the caller try other chunks in buffer order.
+          // Note that if we get this, it does NOT mean there are no other
+          // chunks next in the sequence. We might have hit a "needs patching"
+          // chunk.
+          seq_->skip_in_generation = buf_->read_generation_;
+          return false;
+          // If mode_ == kEraseMode, we want to continue the loop and let the
+          // prologue of the loop EraseCurrentChunk().
         }
-      } else if (chunk_meta->num_fragments_read <
-                     chunk_meta->num_fragments - 1 ||
-                 !(chunk_meta->flags & kLastPacketContinuesOnNextChunk)) {
-        action = kReadOnePacket;  // Case B.
-      } else {
-        action = kTryReadAhead;  // Case C.
-      }
-
-      TRACE_BUFFER_DLOG("  chunk %u, packet %hu of %hu, action=%d",
-                        read_iter_.chunk_id(), chunk_meta->num_fragments_read,
-                        chunk_meta->num_fragments, action);
-
-      if (action == kSkip) {
-        // This fragment will be skipped forever, not just in this ReadPacket()
-        // iteration. This happens by virtue of ReadNextPacketInChunk()
-        // incrementing the |num_fragments_read| and marking the fragment as
-        // read even if we didn't really.
-        ReadNextPacketInChunk(chunk_meta, nullptr);
-        chunk_meta->set_last_read_packet_skipped(true);
-        previous_packet_dropped = true;
-        continue;
-      }
 
-      if (action == kReadOnePacket) {
-        // The easy peasy case B.
-        ReadPacketResult result = ReadNextPacketInChunk(chunk_meta, packet);
+        // If we get here either we have a kDataLoss, or
+        // kNotEnoughData && mode_ == kEraseMode.
+        // In either case we want to continue the loop and let the prologue of
+        // the next loop iteration do EraseCurrentChunk().
+        PERFETTO_DCHECK(
+            reassembly_res == FragReassemblyResult::kDataLoss ||
+            (reassembly_res == FragReassemblyResult::kNotEnoughData &&
+             mode_ == kEraseMode));
+
+        // If we detect a data loss, ReassembleFragmentedPacket() consumes all
+        // fragments up until the discontinuity point, so they don't trigger
+        // further error stats when we iterate over them again.
+        // The break below will continue with the next chunk in sequence, if
+        // any. Keep this case in mind here:
+        // - We start the read cycle
+        // - On the first chunk we find there are prior in-sequence chunks,
+        //   so we rewind (we go back on the sequence's chunk list).
+        // - Then we find that, in this sequence, there is a "broken" packet.
+        // We should keep going on the same sequence and mark the data loss.
+        seq_->data_loss = true;
+        break;  // case kFragBegin
+    }  // switch(frag.type)
+  }  // for(;;)
+}
+
+void ChunkSeqReader::ConsumeFragment(TBChunk* chunk, Frag* frag) {
+  // We must consume fragments in order (and no more than once).
+  uintptr_t payload_addr = reinterpret_cast<uintptr_t>(frag->begin);
+  uintptr_t chunk_addr = reinterpret_cast<uintptr_t>(chunk->fragments_begin());
+  PERFETTO_DCHECK(payload_addr > chunk_addr);
+  uintptr_t payload_off = payload_addr - chunk_addr;
+  PERFETTO_DCHECK(payload_off == chunk->unread_payload_off() + frag->hdr_size);
+
+  PERFETTO_DCHECK(chunk->payload_avail >= frag->size_with_header());
+  chunk->payload_avail -= frag->size_with_header();
+  if (chunk->payload_avail == 0) {
+    TRACE_BUFFER_V2_DLOG("  Fully consumed chunk @ %zu", buf_->OffsetOf(chunk));
+    if (mode_ == kReadMode) {
+      auto& stats = buf_->stats_;
+      stats.set_chunks_read(stats.chunks_read() + 1);
+      stats.set_bytes_read(stats.bytes_read() + chunk->outer_size());
+    }
+  }
+}
+
+// Tries to reassemble the packet following the chunks in sequence order (by
+// cloning the ChunkSeqIterator). If there is a data loss, it consumes anyways
+// the fragments. If there isn't enough data, leaves the fragments untouched.
+ChunkSeqReader::FragReassemblyResult ChunkSeqReader::ReassembleFragmentedPacket(
+    TracePacket* out_packet,
+    Frag* initial_frag) {
+  PERFETTO_DCHECK(initial_frag->type == Frag::kFragBegin);
+
+  TBChunk* initial_chunk = seq_iter_.chunk();
+  if (initial_chunk->flags & kChunkNeedsPatch)
+    return FragReassemblyResult::kNotEnoughData;
+
+  struct FragAndChunk {
+    FragAndChunk(Frag f, TBChunk* c) : frag(std::move(f)), chunk(c) {}
+    Frag frag;
+    TBChunk* chunk;
+  };
 
-        if (PERFETTO_LIKELY(result == ReadPacketResult::kSucceeded)) {
-          *sequence_properties = {trusted_producer_id, trusted_uid, trusted_pid,
-                                  writer_id};
-          *previous_packet_on_sequence_dropped = previous_packet_dropped;
-          return true;
-        } else if (result == ReadPacketResult::kFailedEmptyPacket) {
-          // We can ignore and skip empty packets.
-          PERFETTO_DCHECK(packet->slices().empty());
-          continue;
-        }
+  base::SmallVector<FragAndChunk, 8> frags;
+  frags.emplace_back(*initial_frag, initial_chunk);
+  ChunkSeqIterator chunk_iter = seq_iter_;  // Make copy.
 
-        // In extremely rare cases (producer bugged / malicious) the chunk might
-        // contain an invalid fragment. In such case we don't want to stall the
-        // sequence but just skip the chunk and move on. ReadNextPacketInChunk()
-        // marks the chunk as fully read, so we don't attempt to read from it
-        // again in a future call to ReadBuffers(). It also already records an
-        // abi violation for this.
-        PERFETTO_DCHECK(result == ReadPacketResult::kFailedInvalidPacket);
-        chunk_meta->set_last_read_packet_skipped(true);
-        previous_packet_dropped = true;
+  // Iterate over chunks using the linked list.
+  FragReassemblyResult res;
+  for (;;) {
+    PERFETTO_DCHECK((chunk_iter.valid()));
+    TBChunk* next_chunk = chunk_iter.NextChunkInSequence();
+    if (!next_chunk || next_chunk->flags & kChunkNeedsPatch) {
+      res = FragReassemblyResult::kNotEnoughData;
+      break;
+    }
+    if (chunk_iter.sequence_gap_detected()) {
+      // There is a gap in the sequence ID.
+      res = FragReassemblyResult::kDataLoss;
+      break;
+    }
+    FragIterator frag_iter = FragIterator(next_chunk);
+    // When we reassemble a fragmented packets we only care about one fragment
+    // per chunk. We never need to iterate (more than once) over fragments in a
+    // chunk but only look at the first one. Think about it, either:
+    // 1. The packet spans across two chunks, so we move to the next chunk,
+    //    read the first fragment, and realize that it doesn't continue further.
+    // 2. If the packet spans across chunks [0, N], the chunks [1, N-1] must
+    //    have only one fragment, with both kFirstPacketContFromPrevChunk
+    //    and kLastPacketContOnNextChunk flags.
+    std::optional<Frag> frag = frag_iter.NextFragmentInChunk();
+    if (!frag.has_value()) {
+      if (frag_iter.chunk_corrupted()) {
+        res = FragReassemblyResult::kDataLoss;
         break;
       }
+      // This can happen if a chunk in the middle of a sequence is empty. Rare
+      // but technically possible. See test Fragments_EmptyChunkInTheMiddle.
+      continue;
+    }
 
-      PERFETTO_DCHECK(action == kTryReadAhead);
-      ReadAheadResult ra_res = ReadAhead(packet);
-      if (ra_res == ReadAheadResult::kSucceededReturnSlices) {
-        stats_.set_readaheads_succeeded(stats_.readaheads_succeeded() + 1);
-        *sequence_properties = {trusted_producer_id, trusted_uid, trusted_pid,
-                                writer_id};
-        *previous_packet_on_sequence_dropped = previous_packet_dropped;
-        return true;
-      }
+    const auto& frag_type = frag->type;
+    if (frag_type == Frag::kFragContinue) {
+      frags.emplace_back(*frag, next_chunk);
+      continue;
+    }
+    if (frag_type == Frag::kFragEnd) {
+      frags.emplace_back(*frag, next_chunk);
 
-      if (ra_res == ReadAheadResult::kFailedMoveToNextSequence) {
-        // readahead didn't find a contiguous packet sequence. We'll try again
-        // on the next ReadPacket() call.
-        stats_.set_readaheads_failed(stats_.readaheads_failed() + 1);
+      res = FragReassemblyResult::kSuccess;
+      break;
+    }
+    // else: kFragBegin or kFragWholePacket
+    // This is a very weird case: the sequence id is contiguous but somehow the
+    // chain of continue-onto-next/prev is broken.
+    // In this case we want to leave frags these untouched as they don't belong
+    // to us. The next ReadNextPacketInSeqOrder calls will deal with them. Our
+    // job here is to consume only fragments for the packet we are trying to
+    // reassemble.
+    res = FragReassemblyResult::kDataLoss;
+    break;
+  }  // for (chunk in list)
 
-        // TODO(primiano): optimization: this MoveToEnd() is the reason why
-        // MoveNext() (that is called in the outer for(;;MoveNext)) needs to
-        // deal gracefully with the case of |cur|==|seq_end|. Maybe we can do
-        // something to avoid that check by reshuffling the code here?
-        read_iter_.MoveToEnd();
+  for (FragAndChunk& fc : frags) {
+    Frag& f = fc.frag;
+    if (res == FragReassemblyResult::kSuccess && f.size > 0) {
+      if (out_packet)
+        out_packet->AddSlice(f.begin, f.size);
+    }
+    if (res == FragReassemblyResult::kSuccess ||
+        res == FragReassemblyResult::kDataLoss) {
+      ConsumeFragment(fc.chunk, &f);
+    }
+  }
+  return res;
+}
 
-        // This break will go back to beginning of the for(;;MoveNext()). That
-        // will move to the next sequence because we set the read iterator to
-        // its end.
-        break;
-      }
+}  // namespace internal
 
-      PERFETTO_DCHECK(ra_res == ReadAheadResult::kFailedStayOnSameSequence);
+// +---------------------------------------------------------------------------+
+// | TraceBuffer                                                               |
+// +---------------------------------------------------------------------------+
 
-      // In this case ReadAhead() might advance |read_iter_|, so we need to
-      // re-cache the |chunk_meta| pointer to point to the current chunk.
-      chunk_meta = &*read_iter_;
-      chunk_meta->set_last_read_packet_skipped(true);
-      previous_packet_dropped = true;
-    }  // while(...)  [iterate over packet fragments for the current chunk].
-  }    // for(;;MoveNext()) [iterate over chunks].
+// static
+std::unique_ptr<TraceBufferV2> TraceBufferV2::Create(size_t size_in_bytes,
+                                                     OverwritePolicy pol) {
+  // The size and alignment of TBChunk have implications on the memory
+  // efficiency.
+  static_assert(sizeof(TBChunk) == 16);
+  static_assert(alignof(TBChunk) == 4);
+  std::unique_ptr<TraceBufferV2> trace_buffer(new TraceBufferV2(pol));
+  if (!trace_buffer->Initialize(size_in_bytes))
+    return nullptr;
+  return trace_buffer;
 }
 
-TraceBuffer::ReadAheadResult TraceBuffer::ReadAhead(TracePacket* packet) {
-  static_assert(static_cast<ChunkID>(kMaxChunkID + 1) == 0,
-                "relying on kMaxChunkID to wrap naturally");
-  TRACE_BUFFER_DLOG(" readahead start @ chunk %u", read_iter_.chunk_id());
-  ChunkID next_chunk_id = read_iter_.chunk_id() + 1;
-  SequenceIterator it = read_iter_;
-  for (it.MoveNext(); it.is_valid(); it.MoveNext(), next_chunk_id++) {
-    // We should stay within the same sequence while iterating here.
-    PERFETTO_DCHECK(it.producer_id() == read_iter_.producer_id() &&
-                    it.writer_id() == read_iter_.writer_id());
+TraceBufferV2::TraceBufferV2(OverwritePolicy pol) : overwrite_policy_(pol) {}
 
-    TRACE_BUFFER_DLOG("   expected chunk ID: %u, actual ID: %u", next_chunk_id,
-                      it.chunk_id());
+bool TraceBufferV2::Initialize(size_t size) {
+  size = base::AlignUp(std::max(size, size_t(1)), 4096);
+  // The size must be <= 4GB because we use 32 bit offsets everywhere (e.g. in
+  // the TBChunk linked list) to reduce memory overhead.
+  PERFETTO_CHECK(size <= UINT32_MAX);
+  data_ = base::PagedMemory::Allocate(
+      size, base::PagedMemory::kMayFail | base::PagedMemory::kDontCommit);
+  if (!data_.IsValid()) {
+    PERFETTO_ELOG("Trace buffer allocation failed (size: %zu)", size);
+    return false;
+  }
+  size_ = size;
+  wr_ = 0;
+  used_size_ = 0;
+  stats_.set_buffer_size(size);
+  return true;
+}
 
-    if (PERFETTO_UNLIKELY((*it).num_fragments == 0))
-      continue;
+void TraceBufferV2::BeginRead() {
+  // Start the read at the first chunk after the write cursor. However, if
+  // due to out-of-order commits there is another chunk in the same sequence
+  // prior to that (even if it's physically after in the buffer) start there
+  // to respect sequence FIFO-ness.
+  TRACE_BUFFER_V2_DLOG("BeginRead(), wr_=%zu", wr_);
+  rd_ = wr_ == used_size_ ? 0 : wr_;
+  chunk_seq_reader_.reset();
+  ++read_generation_;
+}
 
-    // If we miss the next chunk, stop looking in the current sequence and
-    // try another sequence. This chunk might come in the near future.
-    // The second condition is the edge case of a buggy/malicious
-    // producer. The ChunkID is contiguous but its flags don't make sense.
-    if (it.chunk_id() != next_chunk_id ||
-        PERFETTO_UNLIKELY(
-            !((*it).flags & kFirstPacketContinuesFromPrevChunk))) {
-      return ReadAheadResult::kFailedMoveToNextSequence;
+bool TraceBufferV2::ReadNextTracePacket(
+    TracePacket* out_packet,
+    PacketSequenceProperties* sequence_properties,
+    bool* previous_packet_on_sequence_dropped) {
+  *sequence_properties = {0, ClientIdentity(), 0};
+  *previous_packet_on_sequence_dropped = false;
+
+  // When reading back chunks, we visit the buffer in two layers
+  // (see /docs/design-docs/trace-buffer.md):
+  // - The outer layer (this function) iterates in buffer order, starting from
+  //   the wr_cursor, as that respects global FIFO-ness.
+  // - The inner layer (ChunkSeqReader::ReadNextPacketInSeqOrder()) iterates in
+  //   sequence order: it visits all the chunks until the target `chunk` has
+  //   been reached.
+  for (;;) {
+    size_t next_rd = 0;
+    // chunk_seq_reader_ is created every time we step on the outer layer, stays
+    // alive as long as we are iterating in sequence order, and is destroyed
+    // before moving again in buffer order.
+    if (!chunk_seq_reader_.has_value()) {
+      // Note: in the edge case when the buffer is completely empty, TBChunk
+      // is designed in a way such that GetTBChunkAt(0) returns an empty padding
+      // chunk with a valid (zero) checksum.
+      // This is so we don't need extra branches to deal with this rare case.
+      TBChunk* chunk = GetTBChunkAt(rd_);
+      if (!chunk->is_padding()) {
+        // Starts the inner walk in sequence order.
+        chunk_seq_reader_.emplace(this, chunk, ChunkSeqReader::kReadMode);
+        continue;
+      }
+      // If this chunk is empty, try with the next chunk in buffer order.
+      next_rd = rd_ + chunk->outer_size();
+      // Continues after the else block below...
+    } else {
+      // ReadNextPacketInSeqOrder() reads only packets up to the current chunk.
+      // Eventually it might go back to previous chunks in the sequence (even if
+      // they are ahead in buffer order) and might go a bit futher if the last
+      // fragment of the chunk is a fragmented packet and continues beyond.
+      // But, +- edge cases, it logically reads only up to `chunk`.
+      // If it returns false, we should continue in buffer order.
+      if (chunk_seq_reader_->ReadNextPacketInSeqOrder(out_packet)) {
+        SequenceState& s = *chunk_seq_reader_->seq();
+        *sequence_properties = {s.producer_id, s.client_identity, s.writer_id};
+        *previous_packet_on_sequence_dropped = s.data_loss;
+        s.data_loss = false;
+        return true;
+      }
+      // If ReadNextPacketInSeqOrder rans out of data, skip to the block below
+      // which will try with the next chunk in buffer order.
+      TBChunk* chunk = chunk_seq_reader_->end();
+      next_rd = OffsetOf(chunk) + chunk->outer_size();
+    }
+
+    // The buffer-order walk resumes here.
+    PERFETTO_DCHECK(next_rd > 0);
+    const bool wrap = next_rd >= used_size_;
+    chunk_seq_reader_.reset();
+    if (next_rd == wr_ || (wrap && wr_ == 0)) {
+      // We tried every possible chunk and hit the write cursor. There's no data
+      // to read in the buffer.
+      return false;
     }
+    rd_ = wrap ? 0 : next_rd;
+  }  // for(;;)
+}
 
-    // If the chunk is contiguous but has not been patched yet move to the next
-    // sequence and try coming back here on the next ReadNextTracePacket() call.
-    // TODO(primiano): add a test to cover this, it's a subtle case.
-    if ((*it).flags & kChunkNeedsPatching)
-      return ReadAheadResult::kFailedMoveToNextSequence;
+void TraceBufferV2::CopyChunkUntrusted(
+    ProducerID producer_id_trusted,
+    const ClientIdentity& client_identity_trusted,
+    WriterID writer_id,
+    ChunkID chunk_id,
+    uint16_t num_fragments,
+    uint8_t chunk_flags,
+    bool chunk_complete,
+    const uint8_t* src,
+    size_t src_size) {
+  TRACE_BUFFER_V2_DLOG("");
+  TRACE_BUFFER_V2_DLOG("CopyChunkUntrusted(%zu) @ wr_=%zu", src_size, wr_);
+  if (TRACE_BUFFER_V2_VERBOSE_LOGGING())
+    DumpForTesting();
 
-    // This is the case of an intermediate chunk which contains only one
-    // fragment which continues on the next chunk. This is the case for large
-    // packets, e.g.: [Packet0, Packet1(0)] [Packet1(1)] [Packet1(2), ...]
-    // (Packet1(X) := fragment X of Packet1).
-    if ((*it).num_fragments == 1 &&
-        ((*it).flags & kLastPacketContinuesOnNextChunk)) {
-      continue;
-    }
+  PERFETTO_CHECK(!read_only_);
 
-    // We made it! We got all fragments for the packet without holes.
-    TRACE_BUFFER_DLOG("  readahead success @ chunk %u", it.chunk_id());
-    PERFETTO_DCHECK(((*it).num_fragments == 1 &&
-                     !((*it).flags & kLastPacketContinuesOnNextChunk)) ||
-                    (*it).num_fragments > 1);
+  if (PERFETTO_UNLIKELY(discard_writes_))
+    return DiscardWrite();
 
-    // Now let's re-iterate over the [read_iter_, it] sequence and mark
-    // all the fragments as read.
-    bool packet_corruption = false;
-    for (;;) {
-      PERFETTO_DCHECK(read_iter_.is_valid());
-      TRACE_BUFFER_DLOG("    commit chunk %u", read_iter_.chunk_id());
-      if (PERFETTO_LIKELY((*read_iter_).num_fragments > 0)) {
-        // In the unlikely case of a corrupted packet (corrupted or empty
-        // fragment), invalidate the all stitching and move on to the next chunk
-        // in the same sequence, if any.
-        packet_corruption |= ReadNextPacketInChunk(&*read_iter_, packet) ==
-                             ReadPacketResult::kFailedInvalidPacket;
-      }
-      if (read_iter_.cur == it.cur)
-        break;
-      read_iter_.MoveNext();
-    }  // for(;;)
-    PERFETTO_DCHECK(read_iter_.cur == it.cur);
+  // chunk_complete is true in the majority of cases, and is false only when
+  // the service performs SMB scraping (upon flush).
+  // If the chunk hasn't been completed, we should only consider the first
+  // |num_fragments - 1| packets. For simplicity, we simply disregard
+  // the last one when we copy the chunk.
+  if (PERFETTO_UNLIKELY(!chunk_complete)) {
+    chunk_flags |= kChunkIncomplete;
+    if (num_fragments > 0) {
+      num_fragments--;
+      // These flags should only affect the last packet in the chunk. We clear
+      // them, so that TraceBuffer is able to look at the remaining packets in
+      // this chunk.
+      chunk_flags &= ~kLastPacketContOnNextChunk;
+      chunk_flags &= ~kChunkNeedsPatch;
+    }
+  }
 
-    if (PERFETTO_UNLIKELY(packet_corruption)) {
-      // ReadNextPacketInChunk() already records an abi violation for this case.
-      *packet = TracePacket();  // clear.
-      return ReadAheadResult::kFailedStayOnSameSequence;
+  // Compute the SUM(frags.size).
+  size_t all_frags_size = 0;
+  internal::FragIterator frag_iter(src, src_size, chunk_flags);
+  for (uint16_t frag_idx = 0; frag_idx < num_fragments; frag_idx++) {
+    std::optional<Frag> maybe_frag = frag_iter.NextFragmentInChunk();
+    if (!maybe_frag.has_value()) {
+      // Either we found less fragments than what the header said, or some
+      // fragment is out of bounds.
+      stats_.set_abi_violations(stats_.abi_violations() + 1);
+      PERFETTO_DCHECK(suppress_client_dchecks_for_testing_);
+      break;
     }
+    Frag& f = *maybe_frag;
+    all_frags_size += f.size_with_header();
+    TRACE_BUFFER_V2_DLOG("  Frag %u: %p - %p", frag_idx,
+                         static_cast<const void*>(f.begin),
+                         static_cast<const void*>(f.begin + f.size));
+  }
+  bool trace_writer_data_drop = frag_iter.trace_writer_data_drop();
 
-    return ReadAheadResult::kSucceededReturnSlices;
-  }  // for(it...)  [readahead loop]
-  return ReadAheadResult::kFailedMoveToNextSequence;
-}
+  PERFETTO_CHECK(all_frags_size <= src_size);
 
-TraceBuffer::ReadPacketResult TraceBuffer::ReadNextPacketInChunk(
-    ChunkMeta* const chunk_meta,
-    TracePacket* packet) {
-  PERFETTO_DCHECK(chunk_meta->num_fragments_read < chunk_meta->num_fragments);
-  PERFETTO_DCHECK(!(chunk_meta->flags & kChunkNeedsPatching));
+  // Make space in the buffer for the chunk we are about to copy.
 
-  const uint8_t* record_begin = begin() + chunk_meta->record_off;
-  DcheckIsAlignedAndWithinBounds(record_begin);
-  auto* chunk_record = reinterpret_cast<const ChunkRecord*>(record_begin);
-  const uint8_t* record_end = record_begin + chunk_record->size;
-  const uint8_t* packets_begin = record_begin + sizeof(ChunkRecord);
-  const uint8_t* packet_begin = packets_begin + chunk_meta->cur_fragment_offset;
+  // If the chunk is incomplete (due to scraping), we want to reserve the
+  // whole chunk space in the buffer, to allow later re-commits that will
+  // increase the payload size.
+  size_t tbchunk_size = chunk_complete ? all_frags_size : src_size;
+  const size_t tbchunk_outer_size = TBChunk::OuterSize(tbchunk_size);
 
-  if (PERFETTO_UNLIKELY(packet_begin < packets_begin ||
-                        packet_begin >= record_end)) {
-    // The producer has a bug or is malicious and did declare that the chunk
-    // contains more packets beyond its boundaries.
+  if (PERFETTO_UNLIKELY(tbchunk_outer_size > size_)) {
+    // The chunk is bigger than the buffer. Extremely rare, but can happen, e.g.
+    // if the user has specified a 16KB buffer and the SMB chunk is 32KB.
     stats_.set_abi_violations(stats_.abi_violations() + 1);
     PERFETTO_DCHECK(suppress_client_dchecks_for_testing_);
-    chunk_meta->cur_fragment_offset = 0;
-    chunk_meta->num_fragments_read = chunk_meta->num_fragments;
-    if (PERFETTO_LIKELY(chunk_meta->is_complete())) {
-      stats_.set_chunks_read(stats_.chunks_read() + 1);
-      stats_.set_bytes_read(stats_.bytes_read() + chunk_record->size);
+    return;
+  }
+
+  auto seq_key = MkProducerAndWriterID(producer_id_trusted, writer_id);
+  writer_stats_.Insert(seq_key, static_cast<HistValue>(all_frags_size));
+
+  auto [seq_it, seq_is_new] = sequences_.try_emplace(
+      seq_key,
+      SequenceState(producer_id_trusted, writer_id, client_identity_trusted));
+  if (seq_is_new) {
+    TRACE_BUFFER_V2_DLOG("  Added seq %x", seq_key);
+  }
+
+  SequenceState& seq = seq_it->second;
+  if (trace_writer_data_drop) {
+    stats_.set_trace_writer_packet_loss(stats_.trace_writer_packet_loss() + 1);
+    seq.data_loss = true;
+  }
+
+  // Don't allow re-commit of chunks that have been consumed already. It's too
+  // late and they will only mess up future chunks more.
+  if (seq.last_chunk_id_consumed.has_value() &&
+      ChunkIdCompare(chunk_id, *seq.last_chunk_id_consumed) <= 0) {
+    stats_.set_chunks_discarded(stats_.chunks_discarded() + 1);
+    PERFETTO_DCHECK(suppress_client_dchecks_for_testing_);
+    return;
+  }
+
+  // If there isn't enough room from the given write position: write a padding
+  // record to clear the end of the buffer, wrap and start at offset 0.
+  const size_t cached_size_to_end = size_to_end();
+  if (PERFETTO_UNLIKELY(tbchunk_outer_size > cached_size_to_end)) {
+    // If we reached the end of the buffer and we are using discard policy,
+    // this is where we stop. This buffer will no longer accept data.
+    if (overwrite_policy_ == kDiscard)
+      return DiscardWrite();
+
+    DeleteNextChunksFor(cached_size_to_end);
+    wr_ = 0;
+    stats_.set_write_wrap_count(stats_.write_wrap_count() + 1);
+    PERFETTO_DCHECK(size_to_end() >= tbchunk_outer_size);
+  }
+
+  // Deletes all chunks from |wptr_| to |wptr_| + |record_size|.
+  DeleteNextChunksFor(tbchunk_outer_size);
+
+  // Find the insert position in the SequenceState's chunk list. We iterate the
+  // list in reverse order as in the majority of cases chunks arrive naturally
+  // in order. SMB scraping is really the only thing that might commit chunks
+  // slightly out of order.
+  auto& chunk_list = seq.chunks;
+  auto insert_pos = chunk_list.rbegin();
+  TBChunk* recommit_chunk = nullptr;
+  for (; insert_pos != chunk_list.rend(); ++insert_pos) {
+    TBChunk* other_chunk = GetTBChunkAt(*insert_pos);
+    int cmp = ChunkIdCompare(chunk_id, other_chunk->chunk_id);
+    if (cmp > 0)
+      break;
+    if (cmp == 0) {
+      // The producer is trying to re-commit a previously copied chunk. This
+      // can happen when the service does SMB scraping (the same chunk could
+      // be scraped more than once), and later the producer does a commit.
+      // We allow recommit only if the new chunk is larger than the existing.
+      recommit_chunk = other_chunk;
+      break;
     }
-    return ReadPacketResult::kFailedInvalidPacket;
   }
 
-  // A packet (or a fragment) starts with a varint stating its size, followed
-  // by its content. The varint shouldn't be larger than 4 bytes (just in case
-  // the producer is using a redundant encoding)
-  uint64_t packet_size = 0;
-  const uint8_t* header_end =
-      std::min(packet_begin + protozero::proto_utils::kMessageLengthFieldSize,
-               record_end);
-  const uint8_t* packet_data = protozero::proto_utils::ParseVarInt(
-      packet_begin, header_end, &packet_size);
+  const uint16_t all_frags_size_u16 = static_cast<uint16_t>(all_frags_size);
 
-  const uint8_t* next_packet = packet_data + packet_size;
-  if (PERFETTO_UNLIKELY(next_packet <= packet_begin ||
-                        next_packet > record_end)) {
-    // In BufferExhaustedPolicy::kDrop mode, TraceWriter may abort a fragmented
-    // packet by writing an invalid size in the last fragment's header. We
-    // should handle this case without recording an ABI violation (since Android
-    // R).
-    if (packet_size != SharedMemoryABI::kPacketSizeDropPacket) {
+  // In the case of a re-commit we don't need to create a new chunk, we just
+  // want to overwrite the existing one.
+  if (PERFETTO_UNLIKELY(recommit_chunk)) {
+    const uint8_t recommit_flags = recommit_chunk->flags & kFlagsMask;
+    if (all_frags_size < recommit_chunk->payload_size ||
+        all_frags_size > recommit_chunk->size ||
+        (recommit_flags & chunk_flags) != recommit_flags) {
+      // The payload should never shrink, cannot grow more than the original
+      // chunk size. Flags can be added but not removed.
       stats_.set_abi_violations(stats_.abi_violations() + 1);
       PERFETTO_DCHECK(suppress_client_dchecks_for_testing_);
-    } else {
-      stats_.set_trace_writer_packet_loss(stats_.trace_writer_packet_loss() +
-                                          1);
+      return;
     }
-    chunk_meta->cur_fragment_offset = 0;
-    chunk_meta->num_fragments_read = chunk_meta->num_fragments;
-    if (PERFETTO_LIKELY(chunk_meta->is_complete())) {
-      stats_.set_chunks_read(stats_.chunks_read() + 1);
-      stats_.set_bytes_read(stats_.bytes_read() + chunk_record->size);
+    recommit_chunk->flags &= ~kChunkIncomplete;
+    if (all_frags_size == recommit_chunk->payload_size) {
+      TRACE_BUFFER_V2_DLOG("  skipping recommit of identical chunk");
+      return;
     }
-    return ReadPacketResult::kFailedInvalidPacket;
+    uint16_t payload_consumed =
+        recommit_chunk->payload_size - recommit_chunk->payload_avail;
+    recommit_chunk->payload_size = all_frags_size_u16;
+    recommit_chunk->payload_avail = all_frags_size_u16 - payload_consumed;
+    memcpy(recommit_chunk->fragments_begin(), src, all_frags_size);
+    recommit_chunk->flags |= chunk_flags;
+    stats_.set_chunks_rewritten(stats_.chunks_rewritten() + 1);
+    return;
   }
 
-  chunk_meta->cur_fragment_offset =
-      static_cast<uint16_t>(next_packet - packets_begin);
-  chunk_meta->num_fragments_read++;
+  TBChunk* tbchunk = CreateTBChunk(wr_, tbchunk_size);
+  tbchunk->payload_size = all_frags_size_u16;
+  tbchunk->payload_avail = all_frags_size_u16;
+  tbchunk->chunk_id = chunk_id;
+  tbchunk->flags = chunk_flags;
+  tbchunk->pri_wri_id = seq_key;
+  auto* payload_begin = reinterpret_cast<uint8_t*>(tbchunk) + sizeof(TBChunk);
+  uint8_t* wptr = payload_begin;
 
-  if (PERFETTO_UNLIKELY(chunk_meta->num_fragments_read ==
-                            chunk_meta->num_fragments &&
-                        chunk_meta->is_complete())) {
-    stats_.set_chunks_read(stats_.chunks_read() + 1);
-    stats_.set_bytes_read(stats_.bytes_read() + chunk_record->size);
-  } else {
-    // We have at least one more packet to parse. It should be within the chunk.
-    if (chunk_meta->cur_fragment_offset + sizeof(ChunkRecord) >=
-        chunk_record->size) {
-      PERFETTO_DCHECK(suppress_client_dchecks_for_testing_);
+  // Copy all the (valid) fragments from the SMB chunk to the TBChunk.
+  memcpy(wptr, src, all_frags_size);
+
+  PERFETTO_DCHECK(wr_ == OffsetOf(tbchunk));
+  if (insert_pos != chunk_list.rbegin()) {
+    stats_.set_chunks_committed_out_of_order(
+        stats_.chunks_committed_out_of_order() + 1);
+  }
+  chunk_list.InsertAfter(insert_pos, wr_);
+  if (chunk_list.size() == 1 && !seq_is_new) {
+    PERFETTO_DCHECK(empty_sequences_ > 0);
+    --empty_sequences_;
+  }
+
+  TRACE_BUFFER_V2_DLOG(" END OF CopyChunkUntrusted(%zu) @ wr=%zu", src_size,
+                       wr_);
+
+  wr_ += tbchunk_outer_size;
+  PERFETTO_DCHECK(wr_ <= size_ && wr_ <= used_size_);
+  wr_ = wr_ >= size_ ? 0 : wr_;
+
+  stats_.set_chunks_written(stats_.chunks_written() + 1);
+  stats_.set_bytes_written(stats_.bytes_written() + tbchunk_outer_size);
+
+  // We purge SequenceStates(s) only here, because other parts of the readback
+  // code (BeginRead()/ReadNextTracePacket()) need to cache SequenceState*
+  // pointers via seq_iter_ acros invocations.
+  if (empty_sequences_ > kEmptySequencesGcTreshold)
+    DeleteStaleEmptySequences();
+}
+
+TraceBufferV2::TBChunk* TraceBufferV2::CreateTBChunk(size_t off, size_t size) {
+  DcheckIsAlignedAndWithinBounds(off);
+  size_t end = off + TBChunk::OuterSize(size);
+  if (PERFETTO_UNLIKELY(end > used_size_)) {
+    used_size_ = end;
+    data_.EnsureCommitted(end);
+  }
+  TBChunk* chunk = GetTBChunkAtUnchecked(off);
+  return new (chunk) TBChunk(off, size);
+}
+
+// Deletes (by marking the record invalid and removing form the index) all
+// chunks from wr_ to (wr_ + bytes_to_clear).
+// Graphically, assume the initial situation is the following (|wptr_| = 10).
+// |0        |10 (wptr_)       |30       |40                 |60
+// +---------+-----------------+---------+-------------------+---------+
+// | Chunk 1 | Chunk 2         | Chunk 3 | Chunk 4           | Chunk 5 |
+// +---------+-----------------+---------+-------------------+---------+
+//           |_________Deletion range_______|~~padding chunk~~|
+//
+// A call to DeleteNextChunksFor(32) will remove chunks 2,3,4 and create a
+// 18 bytes (60 - 42) padding chunk, between the end of the deletion range and
+// the beginning of Chunk 5.
+// Unlike the old v1 impl, here DeleteNextChunksFor also takes care of writing
+// the padding chunk in case of truncation.
+void TraceBufferV2::DeleteNextChunksFor(size_t bytes_to_clear) {
+  TRACE_BUFFER_V2_DLOG("DeleteNextChunksFor(%zu) @ wr=%zu", bytes_to_clear,
+                       wr_);
+  PERFETTO_CHECK(!discard_writes_);
+  PERFETTO_DCHECK(bytes_to_clear >= sizeof(TBChunk));
+  PERFETTO_DCHECK((bytes_to_clear % TBChunk::alignment()) == 0);
+
+  DcheckIsAlignedAndWithinBounds(wr_);
+  const size_t clear_end = wr_ + bytes_to_clear;
+  PERFETTO_DCHECK(clear_end <= size_);
+
+  // This loop erases all the existing chunks in the clear range.
+  for (size_t off = wr_, next_off = 0; off < clear_end; off = next_off) {
+    if (PERFETTO_UNLIKELY(off >= used_size_)) {
+      // This happens only on the first round of writing, when there are no
+      // chunks in the buffer yet. There is nothing to delete here, easy.
+      break;
+    }
+    TBChunk* chunk = GetTBChunkAt(off);
+    const auto chunk_outer_size = chunk->outer_size();
+    next_off = off + chunk_outer_size;
+    if (chunk->is_padding()) {
+      stats_.set_padding_bytes_cleared(stats_.padding_bytes_cleared() +
+                                       chunk_outer_size);
+      continue;
+    }
+    // Reads all the packets up to the current chunk:
+    // If there are chunks prior to this (due to OOO) reads first those
+    // If the last fragment continues in the next chunk, reads that as well
+    // (but then stops and doesn't read fully the subsequent chunk).
+    ChunkSeqReader csr(this, chunk, ChunkSeqReader::kEraseMode);
+    bool has_cleared_unconsumed_fragments = false;
+    for (;;) {
+      // If we have ProtoVMs, we need to readout each packet and pass to
+      // protovm. If not, we still need to do reads, but without having to
+      // accumulated data in a packet.
+      TracePacket* maybe_packet = nullptr;
+      if (!protovms_.empty()) {
+        overwritten_packet_.Clear();
+        maybe_packet = &overwritten_packet_;
+      }
+      if (!csr.ReadNextPacketInSeqOrder(maybe_packet)) {
+        break;
+      }
+      if (maybe_packet) {
+        MaybeProcessOverwrittenPacketWithProtoVm(*maybe_packet,
+                                                 csr.seq()->producer_id);
+      }
+      has_cleared_unconsumed_fragments = true;
+    }
+
+    // In future this branch should become "&& !protovm_has_consumed_packet"
+    // We shouldn't report a data loss if ProtoVM merged the outgoing packet.
+    if (has_cleared_unconsumed_fragments) {
+      csr.seq()->data_loss = true;
     }
+
+    // ChunkSeqReader(kEraseMode) must delete the chunk once
+    // ReadNextPacketInSeqOrder() returns false.
+    PERFETTO_DCHECK(chunk->is_padding());
+
+    stats_.set_chunks_overwritten(stats_.chunks_overwritten() + 1);
+    stats_.set_bytes_overwritten(stats_.bytes_overwritten() + chunk_outer_size);
   }
 
-  chunk_meta->set_last_read_packet_skipped(false);
+  // Having consumed the packets above, this loop wipes out the contents of the
+  // chunks in a second pass.
+  for (size_t off = wr_; off < clear_end && off < used_size_;) {
+    TBChunk* chunk = GetTBChunkAt(off);
+    PERFETTO_DCHECK(chunk->is_padding());
+    size_t chunk_end = off + chunk->outer_size();
+    if (clear_end > off && clear_end < chunk_end) {
+      PERFETTO_DCHECK(chunk_end - clear_end >= sizeof(TBChunk));
+      // Create a zero padding chunk at the end.
+      TBChunk* pad_chunk =
+          CreateTBChunk(clear_end, chunk_end - clear_end - sizeof(TBChunk));
+      stats_.set_padding_bytes_written(stats_.padding_bytes_written() +
+                                       pad_chunk->outer_size());
+    }
+    off += chunk->outer_size();
+  }
+}
 
-  if (PERFETTO_UNLIKELY(packet_size == 0))
-    return ReadPacketResult::kFailedEmptyPacket;
+bool TraceBufferV2::TryPatchChunkContents(ProducerID producer_id,
+                                          WriterID writer_id,
+                                          ChunkID chunk_id,
+                                          const Patch* patches,
+                                          size_t patches_size,
+                                          bool other_patches_pending) {
+  PERFETTO_CHECK(!read_only_);
+
+  ProducerAndWriterID seq_key = MkProducerAndWriterID(producer_id, writer_id);
+  auto seq_it = sequences_.find(seq_key);
+  if (seq_it == sequences_.end()) {
+    stats_.set_patches_failed(stats_.patches_failed() + 1);
+    return false;
+  }
+
+  // We have to do a linear search to find the chunk to patch. In the majority
+  // of cases the chunk to patch is one of the last ones committed, so we walk
+  // the list backwards.
+  auto& chunk_list = seq_it->second.chunks;
+  TBChunk* chunk = nullptr;
+  for (auto it = chunk_list.rbegin(); it != chunk_list.rend(); ++it) {
+    TBChunk* it_chunk = GetTBChunkAt(*it);
+    if (it_chunk->chunk_id == chunk_id) {
+      chunk = it_chunk;
+      break;
+    }
+  }
+
+  if (chunk == nullptr) {
+    stats_.set_patches_failed(stats_.patches_failed() + 1);
+    return false;
+  }
 
-  if (PERFETTO_LIKELY(packet))
-    packet->AddSlice(packet_data, static_cast<size_t>(packet_size));
+  size_t payload_size = chunk->payload_size;
 
-  return ReadPacketResult::kSucceeded;
+  static_assert(Patch::kSize == SharedMemoryABI::kPacketHeaderSize,
+                "Patch::kSize out of sync with SharedMemoryABI");
+
+  for (size_t i = 0; i < patches_size; i++) {
+    const size_t offset_untrusted = patches[i].offset_untrusted;
+    if (payload_size < Patch::kSize ||
+        offset_untrusted > payload_size - Patch::kSize) {
+      // Either the IPC was so slow and in the meantime the writer managed to
+      // wrap over |chunk_id| or the producer sent a malicious IPC.
+      stats_.set_patches_failed(stats_.patches_failed() + 1);
+      return false;
+    }
+    PERFETTO_DCHECK(offset_untrusted >= payload_size - chunk->payload_avail);
+    TRACE_BUFFER_V2_DLOG("PatchChunk {%" PRIu32 ",%" PRIu32
+                         ",%u} size=%zu @ %zu with {%02x %02x %02x %02x}",
+                         producer_id, writer_id, chunk_id,
+                         size_t(chunk->payload_size), offset_untrusted,
+                         patches[i].data[0], patches[i].data[1],
+                         patches[i].data[2], patches[i].data[3]);
+    uint8_t* dst = chunk->fragments_begin() + offset_untrusted;
+    memcpy(dst, &patches[i].data[0], Patch::kSize);
+  }
+  TRACE_BUFFER_V2_DLOG(
+      "Chunk raw (after patch): %s",
+      base::HexDump(chunk->fragments_begin(), chunk->payload_size).c_str());
+  stats_.set_patches_succeeded(stats_.patches_succeeded() + patches_size);
+  if (!other_patches_pending) {
+    chunk->flags &= ~kChunkNeedsPatch;
+  }
+  return true;
 }
 
-void TraceBuffer::DiscardWrite() {
+void TraceBufferV2::DiscardWrite() {
   PERFETTO_DCHECK(overwrite_policy_ == kDiscard);
   discard_writes_ = true;
   stats_.set_chunks_discarded(stats_.chunks_discarded() + 1);
-  TRACE_BUFFER_DLOG("  discarding write");
+  TRACE_BUFFER_V2_DLOG("  discarding write");
+}
+
+// When a sequence has 0 chunks we could delete it straight away. However doing
+// do would remove also the last_chunk_id_consumed used to detect data losses.
+// Here we have to balance the tradeoff between:
+// - Bounding memory usage: if we have a lot of writer threads, we can't just
+//   keeping growing the SequenceStates without bounds.
+// - Retaining our ability to detect data losses for sporadic writers.
+// Here the decision is to keep the last 1024 (kKeepLastEmptySeq) empty
+// sequences and delete anything older. We have some hysteresis and start the GC
+// process only after hitting 1024+128 (kEmptySequencesGcTreshold) empty seqs.
+// This is to avoid thrashing with a sort every time one sequence becomes empty.
+// Also we have to defer the deletion of SequenceState outside of
+// ReadNextTracePacket() calls, as that caches SequenceState* pointers in
+// seq_iter_. This is called only at the end of each CopyChunkUntrusted().
+void TraceBufferV2::DeleteStaleEmptySequences() {
+  // Build a vector of iterators; sort it; delete the first size() - kThreshold.
+  using SeqIterator = decltype(sequences_)::iterator;
+  std::vector<SeqIterator> empty_seqs;
+  empty_seqs.reserve(sequences_.size());
+  for (auto it = sequences_.begin(); it != sequences_.end(); ++it) {
+    if (it->second.chunks.empty())
+      empty_seqs.emplace_back(it);
+  }
+  static_assert(kEmptySequencesGcTreshold >= kKeepLastEmptySeq);
+  if (empty_seqs.size() < kEmptySequencesGcTreshold)
+    return;
+
+  std::sort(empty_seqs.begin(), empty_seqs.end(),
+            [](const SeqIterator& a, const SeqIterator& b) {
+              return a->second.age_for_gc < b->second.age_for_gc;
+            });
+
+  size_t n_oldest = empty_seqs.size() - kKeepLastEmptySeq;
+  for (size_t i = 0; i < n_oldest; ++i) {
+    sequences_.erase(empty_seqs[i]);
+  }
+  empty_sequences_ = kKeepLastEmptySeq;
+
+  // This is not really required in the current implementation and is here just
+  // to spot bugs while refactoring the code in future. This function is
+  // only called by CopyChunkUntrusted(), but the chunk_seq_reader_ (which can
+  // hold onto a SequenceState* pointer) is reset by every BeginRead() call.
+  // By design BeginRead()/ReadNextTracePacket() cannot overlap with CCU().
+  chunk_seq_reader_.reset();
 }
 
-std::unique_ptr<TraceBuffer> TraceBuffer::CloneReadOnly() const {
-  std::unique_ptr<TraceBuffer> buf(new TraceBuffer(CloneCtor(), *this));
+std::unique_ptr<TraceBuffer> TraceBufferV2::CloneReadOnly() const {
+  std::unique_ptr<TraceBufferV2> buf(new TraceBufferV2(CloneCtor(), *this));
   if (!buf->data_.IsValid())
     return nullptr;  // PagedMemory::Allocate() failed. We are out of memory.
   return buf;
 }
 
-TraceBuffer::TraceBuffer(CloneCtor, const TraceBuffer& src)
+size_t TraceBufferV2::GetMemoryUsageBytes() const {
+  size_t total_bytes = size();
+  for (const Vm& vm : protovms_) {
+    total_bytes += vm.instance->GetMemoryUsageBytes();
+  }
+  return total_bytes;
+}
+
+TraceBufferV2::TraceBufferV2(CloneCtor, const TraceBufferV2& src)
     : overwrite_policy_(src.overwrite_policy_),
+      read_generation_(src.read_generation_),
       read_only_(true),
       discard_writes_(src.discard_writes_) {
   if (!Initialize(src.data_.size()))
-    return;  // TraceBuffer::Clone() will check |data_| and return nullptr.
+    return;  // TraceBufferV2::Clone() will check |data_| and return nullptr.
 
   // The assignments below must be done after Initialize().
 
-  data_.EnsureCommitted(data_.size());
-  memcpy(data_.Get(), src.data_.Get(), src.data_.size());
-  last_chunk_id_written_ = src.last_chunk_id_written_;
+  data_.EnsureCommitted(src.used_size_);
+  memcpy(data_.Get(), src.data_.Get(), src.used_size_);
+  used_size_ = src.used_size_;
+  wr_ = src.wr_;
 
   stats_ = src.stats_;
   stats_.set_bytes_read(0);
@@ -54744,23 +61394,140 @@ TraceBuffer::TraceBuffer(CloneCtor, const TraceBuffer& src)
   stats_.set_readaheads_failed(0);
   stats_.set_readaheads_succeeded(0);
 
-  // Copy the index of chunk metadata and reset the read states.
-  index_ = ChunkMap(src.index_);
-  for (auto& kv : index_) {
-    ChunkMeta& chunk_meta = kv.second;
-    chunk_meta.num_fragments_read = 0;
-    chunk_meta.cur_fragment_offset = 0;
-    chunk_meta.set_last_read_packet_skipped(false);
+  // Finally copy over the SequenceState map.
+  sequences_ = src.sequences_;
+
+  for (const auto& vm : src.protovms_) {
+    auto vm_cloned = vm.CloneReadOnly();
+    if (!vm_cloned.instance) {
+      PERFETTO_ELOG("Failed to clone ProtoVMs");
+      protovms_.clear();
+      break;
+    }
+    protovms_.push_back(std::move(vm_cloned));
+  }
+}
+
+TraceBufferV2::Vm TraceBufferV2::Vm::CloneReadOnly() const {
+  Vm cloned_vm;
+  cloned_vm.data_source_name = data_source_name;
+  cloned_vm.program_hash = program_hash;
+  cloned_vm.memory_limit_kb = memory_limit_kb;
+  cloned_vm.producers = producers;
+  cloned_vm.instance = instance->CloneReadOnly();
+  return cloned_vm;
+}
+
+void TraceBufferV2::DumpForTesting() {
+  PERFETTO_DLOG(
+      "------------------- DUMP BEGIN ------------------------------");
+  PERFETTO_DLOG("wr=%zu, size=%zu, used_size=%zu", wr_, size_, used_size_);
+  if (chunk_seq_reader_.has_value()) {
+    PERFETTO_DLOG("rd=%zu, target=%zu", OffsetOf(chunk_seq_reader_->iter()),
+                  OffsetOf(chunk_seq_reader_->end()));
+  } else {
+    PERFETTO_DLOG("rd=invalid");
+  }
+  for (size_t rd = 0; rd < size_;) {
+    TBChunk* c = GetTBChunkAtUnchecked(rd);
+    bool checksum_valid = c->IsChecksumValid(rd);
+    if (checksum_valid) {
+      PERFETTO_DLOG(
+          "[%06zu-%06zu] size=%05u(%05u) id=%05u pr_wr=%08x flags=%08x", rd,
+          rd + c->outer_size(), c->payload_size,
+          c->payload_size - c->payload_avail, c->chunk_id, c->pri_wri_id,
+          c->flags);
+      rd += c->outer_size();
+      continue;
+    }
+    size_t zero_start = rd;
+    // Count zeros.
+    for (; rd < size_ && begin()[rd] == 0; rd++) {
+    }
+    PERFETTO_DLOG("%zu zeros, %zu left", rd - zero_start, size_ - rd);
+    break;
+  }
+  PERFETTO_DLOG("------------------------------------------------------------");
+}
+
+TraceBufferV2::Vm::Vm() = default;
+TraceBufferV2::Vm::~Vm() = default;
+TraceBufferV2::Vm::Vm(Vm&&) noexcept = default;
+
+void TraceBufferV2::MaybeSetUpProtoVm(const std::string& data_source_name,
+                                      const std::string& program_bytes,
+                                      uint32_t memory_limit_kb,
+                                      ProducerID producer_id) {
+  Vm* vm = nullptr;
+  // Re-use existing ProtoVM instance, if any.
+  uint64_t program_hash = base::MurmurHashValue(program_bytes);
+  auto vm_it =
+      std::find_if(protovms_.begin(), protovms_.end(), [&](const Vm& vm) {
+        return vm.data_source_name == data_source_name &&
+               vm.program_hash == program_hash;
+      });
+  if (vm_it != protovms_.end()) {
+    vm = &(*vm_it);
+  } else {
+    // Otherwise instantiate new ProtoVM
+    Vm new_vm;
+    new_vm.data_source_name = data_source_name;
+    new_vm.program_hash = program_hash;
+    new_vm.memory_limit_kb = memory_limit_kb;
+
+    protozero::ConstBytes program_bytes_view{
+        reinterpret_cast<const uint8_t*>(program_bytes.data()),
+        program_bytes.size()};
+
+    new_vm.instance = std::make_unique<protovm::Vm>(
+        program_bytes_view, new_vm.memory_limit_kb * 1024);
+    if (!new_vm.instance) {
+      PERFETTO_ELOG("Failed to allocate ProtoVM");
+      return;
+    }
+
+    protovms_.push_back(std::move(new_vm));
+    vm = &protovms_.back();
+  }
+  // Update ProtoVM's producer IDs
+  vm->producers.insert(producer_id);
+}
+
+void TraceBufferV2::MaybeProcessOverwrittenPacketWithProtoVm(
+    const TracePacket& packet,
+    ProducerID producer) {
+  protovm_patch_.clear();
+
+  for (auto& vm : protovms_) {
+    if (vm.producers.find(producer) == vm.producers.end()) {
+      continue;
+    }
+    // TODO(keanmariotti): add an optimized path for the case
+    // "packet.slices().size() == 1" (zero copy)
+    if (protovm_patch_.empty()) {
+      packet.GetRawBytes(&protovm_patch_);
+    }
+    protozero::ConstBytes bytes{
+        reinterpret_cast<const uint8_t*>(protovm_patch_.data()),
+        protovm_patch_.size()};
+    auto status = vm.instance->ApplyPatch(bytes);
+    if (status.IsOk()) {
+      break;
+    }
+    if (status.IsAbort()) {
+      // TODO(keanmariotti): consider doing something more here. Ideally
+      // triggering a field upload containing the stacktrace.
+      PERFETTO_ELOG("ProtoVM abort while applying patch. Stacktrace:\n%s",
+                    base::Join(status.stacktrace(), "\n").c_str());
+    }
   }
-  read_iter_ = SequenceIterator();
 }
 
 }  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/core/tracing_service_impl.cc
-// gen_amalgamated begin header: src/tracing/core/tracing_service_impl.h
-// gen_amalgamated begin header: include/perfetto/ext/base/circular_queue.h
+// gen_amalgamated begin source: src/tracing/service/tracing_service_endpoints_impl.cc
+// gen_amalgamated begin header: src/tracing/service/tracing_service_endpoints_impl.h
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2025 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -54775,327 +61542,775 @@ TraceBuffer::TraceBuffer(CloneCtor, const TraceBuffer& src)
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_EXT_BASE_CIRCULAR_QUEUE_H_
-#define INCLUDE_PERFETTO_EXT_BASE_CIRCULAR_QUEUE_H_
+#ifndef SRC_TRACING_SERVICE_TRACING_SERVICE_ENDPOINTS_IMPL_H_
+#define SRC_TRACING_SERVICE_TRACING_SERVICE_ENDPOINTS_IMPL_H_
 
-#include <stdint.h>
-#include <stdlib.h>
+#include <functional>
+#include <map>
+#include <memory>
+#include <optional>
+#include <set>
+#include <string>
+#include <vector>
 
-#include <cstddef>
-#include <iterator>
+// gen_amalgamated expanded: #include "perfetto/ext/base/circular_queue.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/clock_snapshots.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/thread_checker.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/weak_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/weak_runner.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/client_identity.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/observable_events.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_abi.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
 
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
+// This header contains the declarations for the 3 abtract classes
+// (ProducerEndpointImpl, ConsumerEndpointImpl, RelayEndpointImpl).
+// These classes are the concrete implementation backed by TracingServiceImpl
+// and override the base interfaces defined at the API level (other
+// implementations exists in the various IPC layers to stub-out the calls).
 
 namespace perfetto {
-namespace base {
 
-// CircularQueue is a push-back-only / pop-front-only queue with the following
-// characteristics:
-// - The storage is based on a flat circular buffer. Beginning and end wrap
-//   as necessary, to keep pushes and pops O(1) as long as capacity expansion is
-//   not required.
-// - Capacity is automatically expanded like in a std::vector. Expansion has a
-//   O(N) cost.
-// - It allows random access, allowing in-place std::sort.
-// - Iterators are not stable. Mutating the container invalidates all iterators.
-// - It doesn't bother with const-correctness.
-//
-// Implementation details:
-// Internally, |begin|, |end| and iterators use 64-bit monotonic indexes, which
-// are incremented as if the queue was backed by unlimited storage.
-// Even assuming that elements are inserted and removed every nanosecond, 64 bit
-// is enough for 584 years.
-// Wrapping happens only when addressing elements in the underlying circular
-// storage. This limits the complexity and avoiding dealing with modular
-// arithmetic all over the places.
-template <class T>
-class CircularQueue {
- public:
-  class Iterator {
-   public:
-    using difference_type = ptrdiff_t;
-    using value_type = T;
-    using pointer = T*;
-    using reference = T&;
-    using iterator_category = std::random_access_iterator_tag;
+class SharedMemoryArbiterImpl;
 
-    Iterator(CircularQueue* queue, uint64_t pos, uint32_t generation)
-        : queue_(queue),
-          pos_(pos)
-#if PERFETTO_DCHECK_IS_ON()
-          ,
-          generation_(generation)
-#endif
-    {
-      ignore_result(generation);
-    }
+namespace tracing_service {
 
-    Iterator(const Iterator&) noexcept = default;
-    Iterator& operator=(const Iterator&) noexcept = default;
-    Iterator(Iterator&&) noexcept = default;
-    Iterator& operator=(Iterator&&) noexcept = default;
+class TracingServiceImpl;
+struct DataSourceInstance;
+struct TracingSession;
+struct TriggerInfo;
 
-    T* operator->() const {
-#if PERFETTO_DCHECK_IS_ON()
-      PERFETTO_DCHECK(generation_ == queue_->generation());
-#endif
-      return queue_->Get(pos_);
-    }
+// The implementation behind the service endpoint exposed to each producer.
+class ProducerEndpointImpl : public TracingService::ProducerEndpoint {
+ public:
+  ProducerEndpointImpl(ProducerID,
+                       const ClientIdentity& client_identity,
+                       TracingServiceImpl*,
+                       base::TaskRunner*,
+                       Producer*,
+                       const std::string& producer_name,
+                       const std::string& machine_name,
+                       const std::string& sdk_version,
+                       bool in_process,
+                       bool smb_scraping_enabled);
+  ~ProducerEndpointImpl() override;
 
-    T& operator*() const { return *(operator->()); }
+  // TracingService::ProducerEndpoint implementation.
+  void Disconnect() override;
+  void RegisterDataSource(const DataSourceDescriptor&) override;
+  void UpdateDataSource(const DataSourceDescriptor&) override;
+  void UnregisterDataSource(const std::string& name) override;
+  void RegisterTraceWriter(uint32_t writer_id, uint32_t target_buffer) override;
+  void UnregisterTraceWriter(uint32_t writer_id) override;
+  void CommitData(const CommitDataRequest&, CommitDataCallback) override;
+  void SetupSharedMemory(std::unique_ptr<SharedMemory>,
+                         size_t page_size_bytes,
+                         bool provided_by_producer,
+                         SharedMemoryABI::ShmemMode shmem_mode);
+  std::unique_ptr<TraceWriter> CreateTraceWriter(
+      BufferID,
+      BufferExhaustedPolicy) override;
+  SharedMemoryArbiter* MaybeSharedMemoryArbiter() override;
+  bool IsShmemProvidedByProducer() const override;
+  void NotifyFlushComplete(FlushRequestID) override;
+  void NotifyDataSourceStarted(DataSourceInstanceID) override;
+  void NotifyDataSourceStopped(DataSourceInstanceID) override;
+  SharedMemory* shared_memory() const override;
+  size_t shared_buffer_page_size_kb() const override;
+  void ActivateTriggers(const std::vector<std::string>&) override;
+  void Sync(std::function<void()> callback) override;
 
-    value_type& operator[](difference_type i) { return *(*this + i); }
+  void OnTracingSetup();
+  void SetupDataSource(DataSourceInstanceID, const DataSourceConfig&);
+  void StartDataSource(DataSourceInstanceID, const DataSourceConfig&);
+  void StopDataSource(DataSourceInstanceID);
+  void Flush(FlushRequestID,
+             const std::vector<DataSourceInstanceID>&,
+             FlushFlags);
+  void OnFreeBuffers(const std::vector<BufferID>& target_buffers);
+  void ClearIncrementalState(const std::vector<DataSourceInstanceID>&);
 
-    Iterator& operator++() {
-      Add(1);
-      return *this;
-    }
+  bool is_allowed_target_buffer(BufferID buffer_id) const {
+    return allowed_target_buffers_.count(buffer_id);
+  }
 
-    Iterator operator++(int) {
-      Iterator ret = *this;
-      Add(1);
-      return ret;
-    }
+  std::optional<BufferID> buffer_id_for_writer(WriterID writer_id) const {
+    const auto it = writers_.find(writer_id);
+    if (it != writers_.end())
+      return it->second;
+    return std::nullopt;
+  }
 
-    Iterator& operator--() {
-      Add(-1);
-      return *this;
-    }
+  bool IsShmemEmulated() { return shmem_abi_.use_shmem_emulation(); }
 
-    Iterator operator--(int) {
-      Iterator ret = *this;
-      Add(-1);
-      return ret;
-    }
+  bool IsAndroidProcessFrozen();
+  uid_t uid() const { return client_identity_.uid(); }
+  pid_t pid() const { return client_identity_.pid(); }
+  const ClientIdentity& client_identity() const { return client_identity_; }
 
-    friend Iterator operator+(const Iterator& iter, difference_type offset) {
-      Iterator ret = iter;
-      ret.Add(offset);
-      return ret;
-    }
+ private:
+  friend class TracingServiceImpl;
+  friend class ConsumerEndpointImpl;
+  ProducerEndpointImpl(const ProducerEndpointImpl&) = delete;
+  ProducerEndpointImpl& operator=(const ProducerEndpointImpl&) = delete;
+
+  ProducerID const id_;
+  ClientIdentity const client_identity_;
+  TracingServiceImpl* const service_;
+  Producer* producer_;
+  std::unique_ptr<SharedMemory> shared_memory_;
+  size_t shared_buffer_page_size_kb_ = 0;
+  SharedMemoryABI shmem_abi_;
+  size_t shmem_size_hint_bytes_ = 0;
+  size_t shmem_page_size_hint_bytes_ = 0;
+  bool is_shmem_provided_by_producer_ = false;
+  const std::string name_;
+  const std::string machine_name_;
+  std::string sdk_version_;
+  bool in_process_;
+  bool smb_scraping_enabled_;
+
+  // Set of the global target_buffer IDs that the producer is configured to
+  // write into in any active tracing session.
+  std::set<BufferID> allowed_target_buffers_;
+
+  // Maps registered TraceWriter IDs to their target buffers as registered by
+  // the producer. Note that producers aren't required to register their
+  // writers, so we may see commits of chunks with WriterIDs that aren't
+  // contained in this map. However, if a producer does register a writer, the
+  // service will prevent the writer from writing into any other buffer than
+  // the one associated with it here. The BufferIDs stored in this map are
+  // untrusted, so need to be verified against |allowed_target_buffers_|
+  // before use.
+  std::map<WriterID, BufferID> writers_;
+
+  // This is used only in in-process configurations.
+  // SharedMemoryArbiterImpl methods themselves are thread-safe.
+  std::unique_ptr<SharedMemoryArbiterImpl> inproc_shmem_arbiter_;
 
-    Iterator& operator+=(difference_type offset) {
-      Add(offset);
-      return *this;
-    }
+  PERFETTO_THREAD_CHECKER(thread_checker_)
+  base::WeakRunner weak_runner_;
+};
 
-    friend Iterator operator-(const Iterator& iter, difference_type offset) {
-      Iterator ret = iter;
-      ret.Add(-offset);
-      return ret;
-    }
+// The implementation behind the service endpoint exposed to each consumer.
+class ConsumerEndpointImpl : public TracingService::ConsumerEndpoint {
+ public:
+  ConsumerEndpointImpl(TracingServiceImpl*,
+                       base::TaskRunner*,
+                       Consumer*,
+                       uid_t uid);
+  ~ConsumerEndpointImpl() override;
 
-    Iterator& operator-=(difference_type offset) {
-      Add(-offset);
-      return *this;
-    }
+  void NotifyOnTracingDisabled(const std::string& error);
 
-    friend ptrdiff_t operator-(const Iterator& lhs, const Iterator& rhs) {
-      return static_cast<ptrdiff_t>(lhs.pos_) -
-             static_cast<ptrdiff_t>(rhs.pos_);
-    }
+  // TracingService::ConsumerEndpoint implementation.
+  void EnableTracing(const TraceConfig&, base::ScopedFile) override;
+  void ChangeTraceConfig(const TraceConfig& cfg) override;
+  void StartTracing() override;
+  void DisableTracing() override;
+  void ReadBuffers() override;
+  void FreeBuffers() override;
+  void Flush(uint32_t timeout_ms, FlushCallback, FlushFlags) override;
+  void Detach(const std::string& key) override;
+  void Attach(const std::string& key) override;
+  void GetTraceStats() override;
+  void ObserveEvents(uint32_t enabled_event_types) override;
+  void QueryServiceState(QueryServiceStateArgs,
+                         QueryServiceStateCallback) override;
+  void QueryCapabilities(QueryCapabilitiesCallback) override;
+  void SaveTraceForBugreport(SaveTraceForBugreportCallback) override;
+  void CloneSession(CloneSessionArgs) override;
 
-    friend bool operator==(const Iterator& lhs, const Iterator& rhs) {
-      return lhs.pos_ == rhs.pos_;
-    }
+  // Will queue a task to notify the consumer about the state change.
+  void OnDataSourceInstanceStateChange(const ProducerEndpointImpl&,
+                                       const DataSourceInstance&);
+  void OnAllDataSourcesStarted();
 
-    friend bool operator!=(const Iterator& lhs, const Iterator& rhs) {
-      return lhs.pos_ != rhs.pos_;
-    }
+  base::WeakPtr<ConsumerEndpointImpl> GetWeakPtr() {
+    return weak_ptr_factory_.GetWeakPtr();
+  }
 
-    friend bool operator<(const Iterator& lhs, const Iterator& rhs) {
-      return lhs.pos_ < rhs.pos_;
-    }
+ private:
+  friend class TracingServiceImpl;
+  friend struct TracingSession;
+  ConsumerEndpointImpl(const ConsumerEndpointImpl&) = delete;
+  ConsumerEndpointImpl& operator=(const ConsumerEndpointImpl&) = delete;
 
-    friend bool operator<=(const Iterator& lhs, const Iterator& rhs) {
-      return lhs.pos_ <= rhs.pos_;
-    }
+  void NotifyCloneSnapshotTrigger(const TriggerInfo& trigger_name);
 
-    friend bool operator>(const Iterator& lhs, const Iterator& rhs) {
-      return lhs.pos_ > rhs.pos_;
-    }
+  // Returns a pointer to an ObservableEvents object that the caller can fill
+  // and schedules a task to send the ObservableEvents to the consumer.
+  ObservableEvents* AddObservableEvents();
 
-    friend bool operator>=(const Iterator& lhs, const Iterator& rhs) {
-      return lhs.pos_ >= rhs.pos_;
-    }
+  base::TaskRunner* const task_runner_;
+  TracingServiceImpl* const service_;
+  Consumer* const consumer_;
+  uid_t const uid_;
+  TracingSessionID tracing_session_id_ = 0;
 
-   private:
-    inline void Add(difference_type offset) {
-      pos_ = static_cast<uint64_t>(static_cast<difference_type>(pos_) + offset);
-      PERFETTO_DCHECK(pos_ <= queue_->end_);
-    }
+  // Whether the consumer is interested in DataSourceInstance state change
+  // events.
+  uint32_t observable_events_mask_ = 0;
 
-    CircularQueue* queue_;
-    uint64_t pos_;
+  // ObservableEvents that will be sent to the consumer. If set, a task to
+  // flush the events to the consumer has been queued.
+  std::unique_ptr<ObservableEvents> observable_events_;
 
-#if PERFETTO_DCHECK_IS_ON()
-    uint32_t generation_;
-#endif
+  PERFETTO_THREAD_CHECKER(thread_checker_)
+  base::WeakPtrFactory<ConsumerEndpointImpl> weak_ptr_factory_;  // Keep last.
+};
+
+class RelayEndpointImpl : public TracingService::RelayEndpoint {
+ public:
+  using SyncMode = RelayEndpoint::SyncMode;
+  using RelayClientID = TracingService::RelayClientID;
+
+  struct SyncedClockSnapshots {
+    SyncedClockSnapshots(SyncMode _sync_mode,
+                         base::ClockSnapshotVector _client_clocks,
+                         base::ClockSnapshotVector _host_clocks)
+        : sync_mode(_sync_mode),
+          client_clocks(std::move(_client_clocks)),
+          host_clocks(std::move(_host_clocks)) {}
+    SyncMode sync_mode;
+    base::ClockSnapshotVector client_clocks;
+    base::ClockSnapshotVector host_clocks;
   };
 
-  explicit CircularQueue(size_t initial_capacity = 1024) {
-    Grow(initial_capacity);
-  }
+  explicit RelayEndpointImpl(RelayClientID relay_client_id,
+                             TracingServiceImpl* service);
+  ~RelayEndpointImpl() override;
 
-  CircularQueue(CircularQueue&& other) noexcept
-      : entries_(std::move(other.entries_)),
-        capacity_(other.capacity_),
-        begin_(other.begin_),
-        end_(other.end_) {
-    increment_generation();
-    new (&other) CircularQueue();  // Reset the old queue so it's still usable.
+  void CacheSystemInfo(std::vector<uint8_t> serialized_system_info) override {
+    serialized_system_info_ = serialized_system_info;
   }
 
-  CircularQueue& operator=(CircularQueue&& other) noexcept {
-    this->~CircularQueue();                      // Destroy the current state.
-    new (this) CircularQueue(std::move(other));  // Use the move ctor above.
-    return *this;
-  }
+  void SyncClocks(SyncMode sync_mode,
+                  base::ClockSnapshotVector client_clocks,
+                  base::ClockSnapshotVector host_clocks) override;
+  void Disconnect() override;
 
-  explicit CircularQueue(const CircularQueue& other) noexcept {
-    Grow(other.capacity());
-    for (const auto& e : const_cast<CircularQueue&>(other))
-      emplace_back(e);
-    PERFETTO_DCHECK(size() == other.size());
-  }
+  MachineID machine_id() const { return relay_client_id_.first; }
 
-  CircularQueue& operator=(const CircularQueue& other) noexcept {
-    this->~CircularQueue();           // Destroy the current state.
-    new (this) CircularQueue(other);  // Use the copy ctor above.
-    return *this;
+  base::CircularQueue<SyncedClockSnapshots>& synced_clocks() {
+    return synced_clocks_;
   }
 
-  ~CircularQueue() {
-    if (!entries_) {
-      PERFETTO_DCHECK(empty());
-      return;
-    }
-    clear();  // Invoke destructors on all alive entries.
-    PERFETTO_DCHECK(empty());
+  std::vector<uint8_t>& serialized_system_info() {
+    return serialized_system_info_;
   }
 
-  template <typename... Args>
-  void emplace_back(Args&&... args) {
-    increment_generation();
-    if (PERFETTO_UNLIKELY(size() >= capacity_))
-      Grow();
-    T* slot = Get(end_++);
-    new (slot) T(std::forward<Args>(args)...);
-  }
+ private:
+  friend class TracingServiceImpl;
+  RelayEndpointImpl(const RelayEndpointImpl&) = delete;
+  RelayEndpointImpl& operator=(const RelayEndpointImpl&) = delete;
 
-  void erase_front(size_t n) {
-    increment_generation();
-    for (; n && (begin_ < end_); --n) {
-      Get(begin_)->~T();
-      begin_++;  // This needs to be its own statement, Get() checks begin_.
-    }
+  RelayClientID relay_client_id_;
+  TracingServiceImpl* const service_;
+  std::vector<uint8_t> serialized_system_info_;
+  base::CircularQueue<SyncedClockSnapshots> synced_clocks_;
+
+  PERFETTO_THREAD_CHECKER(thread_checker_)
+};
+
+}  // namespace tracing_service
+}  // namespace perfetto
+#endif  // SRC_TRACING_SERVICE_TRACING_SERVICE_ENDPOINTS_IMPL_H_
+// gen_amalgamated begin header: include/perfetto/tracing/core/tracing_service_capabilities.h
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_TRACING_CORE_TRACING_SERVICE_CAPABILITIES_H_
+#define INCLUDE_PERFETTO_TRACING_CORE_TRACING_SERVICE_CAPABILITIES_H_
+
+// Creates the aliases in the ::perfetto namespace, doing things like:
+// using ::perfetto::Foo = ::perfetto::protos::gen::Foo.
+// See comments in forward_decls.h for the historical reasons of this
+// indirection layer.
+// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
+
+// gen_amalgamated expanded: #include "protos/perfetto/common/tracing_service_capabilities.gen.h"
+
+#endif  // INCLUDE_PERFETTO_TRACING_CORE_TRACING_SERVICE_CAPABILITIES_H_
+// gen_amalgamated begin header: src/tracing/service/tracing_service_impl.h
+// gen_amalgamated begin header: src/tracing/service/dependencies.h
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SRC_TRACING_SERVICE_DEPENDENCIES_H_
+#define SRC_TRACING_SERVICE_DEPENDENCIES_H_
+
+#include <memory>
+
+// gen_amalgamated expanded: #include "src/tracing/service/clock.h"
+// gen_amalgamated expanded: #include "src/tracing/service/random.h"
+
+namespace perfetto::tracing_service {
+
+// Dependencies of TracingServiceImpl. Can point to real implementations or to
+// mocks in tests.
+struct Dependencies {
+  std::unique_ptr<Clock> clock;
+  std::unique_ptr<Random> random;
+};
+
+}  // namespace perfetto::tracing_service
+
+#endif  // SRC_TRACING_SERVICE_DEPENDENCIES_H_
+// gen_amalgamated begin header: src/tracing/service/tracing_service_session.h
+// gen_amalgamated begin header: src/tracing/service/tracing_service_structs.h
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SRC_TRACING_SERVICE_TRACING_SERVICE_STRUCTS_H_
+#define SRC_TRACING_SERVICE_TRACING_SERVICE_STRUCTS_H_
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <set>
+#include <string>
+#include <vector>
+
+// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/sys_types.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/weak_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_config.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_descriptor.h"
+
+// This file contains common structs that are part of TracingServiceImpl and are
+// used across its various parts (e.g. tracing_service_session.cc,
+// tracing_service_endpoints_impl.cc). They exist in this dedicated header to
+// prevent dependency cycles and for better readability.
+
+namespace perfetto {
+
+class TraceBuffer;
+
+namespace tracing_service {
+
+class ConsumerEndpointImpl;
+
+struct TriggerInfo {
+  uint64_t boot_time_ns = 0;
+  std::string trigger_name;
+  std::string producer_name;
+  uid_t producer_uid = 0;
+  uint64_t trigger_delay_ms = 0;
+};
+
+struct PendingClone {
+  size_t pending_flush_cnt = 0;
+  // This vector might not be populated all at once. Some buffers might be
+  // nullptr while flushing is not done.
+  std::vector<std::unique_ptr<TraceBuffer>> buffers;
+  std::vector<int64_t> buffer_cloned_timestamps;
+  bool flush_failed = false;
+  base::WeakPtr<ConsumerEndpointImpl> weak_consumer;
+  bool skip_trace_filter = false;
+  std::optional<TriggerInfo> clone_trigger;
+  int64_t clone_started_timestamp_ns = 0;
+  base::ScopedFile output_file_fd;
+};
+
+struct PendingFlush {
+  std::set<ProducerID> producers;
+  ConsumerEndpoint::FlushCallback callback;
+  explicit PendingFlush(decltype(callback) cb) : callback(std::move(cb)) {}
+};
+
+struct TriggerHistory {
+  int64_t timestamp_ns;
+  uint64_t name_hash;
+
+  bool operator<(const TriggerHistory& other) const {
+    return timestamp_ns < other.timestamp_ns;
   }
+};
 
-  void pop_front() { erase_front(1); }
+struct RegisteredDataSource {
+  ProducerID producer_id;
+  DataSourceDescriptor descriptor;
+};
 
-  void clear() { erase_front(size()); }
+// Represents an active data source for a tracing session.
+struct DataSourceInstance {
+  DataSourceInstance(DataSourceInstanceID id,
+                     const DataSourceConfig& cfg,
+                     const std::string& ds_name,
+                     bool notify_on_start,
+                     bool notify_on_stop,
+                     bool handles_incremental_state_invalidation,
+                     bool no_flush_)
+      : instance_id(id),
+        config(cfg),
+        data_source_name(ds_name),
+        will_notify_on_start(notify_on_start),
+        will_notify_on_stop(notify_on_stop),
+        handles_incremental_state_clear(handles_incremental_state_invalidation),
+        no_flush(no_flush_) {}
+  DataSourceInstance(const DataSourceInstance&) = delete;
+  DataSourceInstance& operator=(const DataSourceInstance&) = delete;
+
+  DataSourceInstanceID instance_id;
+  DataSourceConfig config;
+  std::string data_source_name;
+  bool will_notify_on_start;
+  bool will_notify_on_stop;
+  bool handles_incremental_state_clear;
+  bool no_flush;
+
+  enum DataSourceInstanceState {
+    CONFIGURED,
+    STARTING,
+    STARTED,
+    STOPPING,
+    STOPPED
+  };
+  DataSourceInstanceState state = CONFIGURED;
+};
 
-  void shrink_to_fit() {
-    // We only bother shrinking if we can fit in quarter of the capacity we are
-    // currently using. Moreover, don't bother shrinking below 4096 elements as
-    // that will cause a lot of reallocations for little benefit.
-    if (size() > capacity() / 2 || capacity() <= 4096) {
-      return;
-    }
-    ChangeCapacity(capacity() / 2);
+}  // namespace tracing_service
+}  // namespace perfetto
+
+#endif  // SRC_TRACING_SERVICE_TRACING_SERVICE_STRUCTS_H_
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SRC_TRACING_SERVICE_TRACING_SERVICE_SESSION_H_
+#define SRC_TRACING_SERVICE_TRACING_SERVICE_SESSION_H_
+
+#include <algorithm>
+#include <map>
+#include <memory>
+#include <optional>
+#include <string>
+#include <tuple>
+#include <vector>
+
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/circular_queue.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/clock_snapshots.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/periodic_task.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_sched_boost.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/uuid.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_config.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/trace_config.h"
+
+// gen_amalgamated expanded: #include "src/tracing/service/tracing_service_structs.h"
+
+namespace protozero {
+class MessageFilter;
+}
+
+namespace perfetto {
+
+namespace protos {
+namespace gen {
+enum TraceStats_FinalFlushOutcome : int;
+}
+}  // namespace protos
+
+namespace base {
+class TaskRunner;
+}
+
+namespace tracing_service {
+
+class ConsumerEndpointImpl;
+
+// Holds the state of a tracing session. A tracing session is uniquely bound
+// a specific Consumer. Each Consumer can own one or more sessions.
+struct TracingSession {
+  enum State {
+    DISABLED = 0,
+    CONFIGURED,
+    STARTED,
+    DISABLING_WAITING_STOP_ACKS,
+    CLONED_READ_ONLY,
+  };
+
+  TracingSession(TracingSessionID,
+                 ConsumerEndpointImpl*,
+                 const TraceConfig&,
+                 base::TaskRunner*);
+  TracingSession(TracingSession&&) = delete;
+  TracingSession& operator=(TracingSession&&) = delete;
+
+  size_t num_buffers() const { return buffers_index.size(); }
+
+  uint32_t flush_timeout_ms() {
+    uint32_t timeout_ms = config.flush_timeout_ms();
+    return timeout_ms ? timeout_ms : kDefaultFlushTimeoutMs;
   }
 
-  T& at(size_t idx) {
-    PERFETTO_DCHECK(idx < size());
-    return *Get(begin_ + idx);
+  uint32_t data_source_stop_timeout_ms() {
+    uint32_t timeout_ms = config.data_source_stop_timeout_ms();
+    return timeout_ms ? timeout_ms : kDataSourceStopTimeoutMs;
   }
 
-  Iterator begin() { return Iterator(this, begin_, generation()); }
-  Iterator end() { return Iterator(this, end_, generation()); }
-  T& front() { return *begin(); }
-  T& back() { return *(end() - 1); }
+  PacketSequenceID GetPacketSequenceID(MachineID, ProducerID, WriterID);
+  DataSourceInstance* GetDataSourceInstance(ProducerID, DataSourceInstanceID);
+  bool AllDataSourceInstancesStarted();
+  bool AllDataSourceInstancesStopped();
 
-  bool empty() const { return size() == 0; }
+  // Checks whether |clone_uid| is allowed to clone the current tracing
+  // session.
+  bool IsCloneAllowed(uid_t clone_uid) const;
 
-  size_t size() const {
-    PERFETTO_DCHECK(end_ - begin_ <= capacity_);
-    return static_cast<size_t>(end_ - begin_);
-  }
+  const TracingSessionID id;
 
-  size_t capacity() const { return capacity_; }
+  // The consumer that started the session.
+  // Can be nullptr if the consumer detached from the session.
+  ConsumerEndpointImpl* consumer_maybe_null;
 
-#if PERFETTO_DCHECK_IS_ON()
-  uint32_t generation() const { return generation_; }
-  void increment_generation() { ++generation_; }
-#else
-  uint32_t generation() const { return 0; }
-  void increment_generation() {}
-#endif
+  // Unix uid of the consumer. This is valid even after the consumer detaches
+  // and does not change for the entire duration of the session. It is used to
+  // prevent that a consumer re-attaches to a session from a different uid.
+  uid_t const consumer_uid;
+
+  // The list of triggers this session received while alive and the time they
+  // were received at. This is used to insert 'fake' packets back to the
+  // consumer so they can tell when some event happened. The order matches the
+  // order they were received.
+  std::vector<TriggerInfo> received_triggers;
+
+  // The trace config provided by the Consumer when calling
+  // EnableTracing(), plus any updates performed by ChangeTraceConfig.
+  TraceConfig config;
+
+  // List of data source instances that have been enabled on the various
+  // producers for this tracing session.
+  std::multimap<ProducerID, DataSourceInstance> data_source_instances;
+
+  // For each Flush(N) request, keeps track of the set of producers for which
+  // we are still awaiting a NotifyFlushComplete(N) ack.
+  std::map<FlushRequestID, PendingFlush> pending_flushes;
+
+  // For each Clone request, keeps track of the flushes acknowledgement that
+  // we are still waiting for.
+  std::map<PendingCloneID, PendingClone> pending_clones;
+
+  PendingCloneID last_pending_clone_id_ = 0;
+
+  // Maps a per-trace-session buffer index into the corresponding global
+  // BufferID (shared namespace amongst all consumers). This vector has as
+  // many entries as |config.buffers_size()|.
+  std::vector<BufferID> buffers_index;
+
+  std::map<std::tuple<MachineID, ProducerID, WriterID>, PacketSequenceID>
+      packet_sequence_ids;
+  PacketSequenceID last_packet_sequence_id = kServicePacketSequenceID;
+
+  // Whether we should emit the trace stats next time we reach EOF while
+  // performing ReadBuffers.
+  bool should_emit_stats = false;
+
+  // Whether we should emit the sync marker the next time ReadBuffers() is
+  // called.
+  bool should_emit_sync_marker = false;
+
+  // Whether we put the initial packets (trace config, system info,
+  // etc.) into the trace output yet.
+  bool did_emit_initial_packets = false;
 
- private:
-  void Grow(size_t new_capacity = 0) {
-    // Capacity must be always a power of two. This allows Get() to use a simple
-    // bitwise-AND for handling the wrapping instead of a full division.
-    new_capacity = new_capacity ? new_capacity : capacity_ * 2;
-    PERFETTO_CHECK((new_capacity & (new_capacity - 1)) == 0);  // Must be pow2.
+  // Whether we emitted clock offsets for relay clients yet.
+  bool did_emit_remote_clock_sync_ = false;
 
-    // On 32-bit systems this might hit the 4GB wall and overflow. We can't do
-    // anything other than crash in this case.
-    PERFETTO_CHECK(new_capacity > capacity_);
+  // Whether we emitted the ProtoVM instances.
+  bool did_emit_protovm_instances_ = false;
 
-    ChangeCapacity(new_capacity);
-  }
+  // Whether we should compress TracePackets after reading them.
+  bool compress_deflate = false;
 
-  void ChangeCapacity(size_t new_capacity) {
-    // We should still have enough space to fit all the elements in the queue.
-    PERFETTO_CHECK(new_capacity >= size());
+  // The number of received triggers we've emitted into the trace output.
+  size_t num_triggers_emitted_into_trace = 0;
 
-    AlignedUniquePtr<T[]> new_vec = AlignedAllocTyped<T[]>(new_capacity);
+  // Packets that failed validation of the TrustedPacket.
+  uint64_t invalid_packets = 0;
 
-    // Move all elements in the expanded array.
-    size_t new_size = 0;
-    for (uint64_t i = begin_; i < end_; i++)
-      new (&new_vec[new_size++]) T(std::move(*Get(i)));  // Placement move ctor.
+  // Flush() stats. See comments in trace_stats.proto for more.
+  uint64_t flushes_requested = 0;
+  uint64_t flushes_succeeded = 0;
+  uint64_t flushes_failed = 0;
 
-    // Even if all the elements are std::move()-d and likely empty, we are still
-    // required to call the dtor for them.
-    for (uint64_t i = begin_; i < end_; i++)
-      Get(i)->~T();
+  // Outcome of the final Flush() done by FlushAndDisableTracing().
+  protos::gen::TraceStats_FinalFlushOutcome final_flush_outcome{};
 
-    begin_ = 0;
-    end_ = new_size;
-    capacity_ = new_capacity;
-    entries_ = std::move(new_vec);
-  }
+  // Set to true on the first call to MaybeNotifyAllDataSourcesStarted().
+  bool did_notify_all_data_source_started = false;
 
-  inline T* Get(uint64_t pos) {
-    PERFETTO_DCHECK(pos >= begin_ && pos < end_);
-    PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0);  // Must be a pow2.
-    auto index = static_cast<size_t>(pos & (capacity_ - 1));
-    return &entries_[index];
-  }
+  // Stores simple lifecycle events of a particular type (i.e. associated with
+  // a single field id in the TracingServiceEvent proto).
+  struct LifecycleEvent {
+    explicit LifecycleEvent(uint32_t f_id, uint32_t m_size = 1)
+        : field_id(f_id), max_size(m_size), timestamps(m_size) {}
 
-  // Underlying storage. It's raw malloc-ed rather than being a unique_ptr<T[]>
-  // to allow having uninitialized entries inside it.
-  AlignedUniquePtr<T[]> entries_;
-  size_t capacity_ = 0;  // Number of allocated slots (NOT bytes) in |entries_|.
+    // The field id of the event in the TracingServiceEvent proto.
+    uint32_t field_id;
 
-  // The |begin_| and |end_| indexes are monotonic and never wrap. Modular arith
-  // is used only when dereferencing entries in the vector.
-  uint64_t begin_ = 0;
-  uint64_t end_ = 0;
+    // Stores the max size of |timestamps|. Set to 1 by default (in
+    // the constructor) but can be overridden in TraceSession constructor
+    // if a larger size is required.
+    uint32_t max_size;
 
-// Generation is used in debug builds only for checking iterator validity.
-#if PERFETTO_DCHECK_IS_ON()
-  uint32_t generation_ = 0;
-#endif
+    // Stores the timestamps emitted for each event type (in nanoseconds).
+    // Emitted into the trace and cleared when the consumer next calls
+    // ReadBuffers.
+    base::CircularQueue<int64_t> timestamps;
+  };
+  std::vector<LifecycleEvent> lifecycle_events;
+
+  // Stores arbitrary lifecycle events that don't fit in lifecycle_events as
+  // serialized TracePacket protos.
+  struct ArbitraryLifecycleEvent {
+    int64_t timestamp;
+    std::vector<uint8_t> data;
+  };
+
+  std::optional<ArbitraryLifecycleEvent> slow_start_event;
+
+  std::vector<ArbitraryLifecycleEvent> last_flush_events;
+
+  // If this is a cloned tracing session, the timestamp at which each buffer
+  // was cloned.
+  std::vector<int64_t> buffer_cloned_timestamps;
+
+  using ClockSnapshotData = base::ClockSnapshotVector;
+
+  // Initial clock snapshot, captured at trace start time (when state goes to
+  // TracingSession::STARTED). Emitted into the trace when the consumer first
+  // calls ReadBuffers().
+  ClockSnapshotData initial_clock_snapshot;
+
+  // Stores clock snapshots to emit into the trace as a ring buffer. This
+  // buffer is populated both periodically and when lifecycle events happen
+  // but only when significant clock drift is detected. Emitted into the trace
+  // and cleared when the consumer next calls ReadBuffers().
+  base::CircularQueue<ClockSnapshotData> clock_snapshot_ring_buffer;
+
+  State state = DISABLED;
+
+  // If the consumer detached the session, this variable defines the key used
+  // for identifying the session later when reattaching.
+  std::string detach_key;
+
+  // This is set when the Consumer calls sets |write_into_file| == true in the
+  // TraceConfig. In this case this represents the file we should stream the
+  // trace packets into, rather than returning it to the consumer via
+  // OnTraceData().
+  base::ScopedFile write_into_file;
+  uint32_t write_period_ms = 0;
+
+  // Flush strategy for the tracing session:
+  // * kDisabled: default, no periodic or on-write flushing is performed.
+  // * kOnWrite: Buffers are flushed every time data is written to the output
+  // file.
+  // * kPeriodic: Buffers are flushed periodically based on the value of
+  //              periodic_flush_ms.
+  enum class FlushStrategy : uint8_t { kDisabled, kOnWrite, kPeriodic };
+  FlushStrategy flush_strategy = FlushStrategy::kDisabled;
+  uint32_t periodic_flush_ms = 0;
+  bool fflush_post_write = false;
+  uint64_t max_file_size_bytes = 0;
+  uint64_t bytes_written_into_file = 0;
+
+  // Periodic task for snapshotting service events (e.g. clocks, sync markers
+  // etc)
+  base::PeriodicTask snapshot_periodic_task;
+
+  // Deferred task that stops the trace when |duration_ms| expires. This is
+  // to handle the case of |prefer_suspend_clock_for_duration| which cannot
+  // use PostDelayedTask.
+  base::PeriodicTask timed_stop_task;
+
+  // When non-NULL the packets should be post-processed using the filter.
+  std::unique_ptr<protozero::MessageFilter> trace_filter;
+  uint64_t filter_input_packets = 0;
+  uint64_t filter_input_bytes = 0;
+  uint64_t filter_output_bytes = 0;
+  uint64_t filter_errors = 0;
+  uint64_t filter_time_taken_ns = 0;
+  std::vector<uint64_t> filter_bytes_discarded_per_buffer;
+
+  // A randomly generated trace identifier. Note that this does NOT always
+  // match the requested TraceConfig.trace_uuid_msb/lsb. Specifically, it does
+  // until a gap-less snapshot is requested. Each snapshot re-generates the
+  // uuid to avoid emitting two different traces with the same uuid.
+  base::Uuid trace_uuid;
+
+  // This is set when the clone operation was caused by a clone trigger.
+  std::optional<TriggerInfo> clone_trigger;
+
+  std::optional<base::ScopedSchedBoost> priority_boost;
+
+  // NOTE: when adding new fields here consider whether that state should be
+  // copied over in DoCloneSession() or not. Ask yourself: is this a
+  // "runtime state" (e.g. active data sources) or a "trace (meta)data state"?
+  // If the latter, it should be handled by DoCloneSession()).
 };
 
-}  // namespace base
+}  // namespace tracing_service
 }  // namespace perfetto
-
-#endif  // INCLUDE_PERFETTO_EXT_BASE_CIRCULAR_QUEUE_H_
+#endif  // SRC_TRACING_SERVICE_TRACING_SERVICE_SESSION_H_
 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
@@ -55112,39 +62327,35 @@ class CircularQueue {
  * limitations under the License.
  */
 
-#ifndef SRC_TRACING_CORE_TRACING_SERVICE_IMPL_H_
-#define SRC_TRACING_CORE_TRACING_SERVICE_IMPL_H_
+#ifndef SRC_TRACING_SERVICE_TRACING_SERVICE_IMPL_H_
+#define SRC_TRACING_SERVICE_TRACING_SERVICE_IMPL_H_
 
-#include <algorithm>
-#include <functional>
 #include <map>
 #include <memory>
-#include <mutex>
-#include <random>
+#include <optional>
 #include <set>
-#include <utility>
 #include <vector>
 
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
 // gen_amalgamated expanded: #include "perfetto/base/status.h"
-// gen_amalgamated expanded: #include "perfetto/base/time.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/circular_queue.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/optional.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/periodic_task.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/uuid.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/weak_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/weak_runner.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/client_identity.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/commit_data_request.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/observable_events.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_abi.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_stats.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_config.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_descriptor.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/core/trace_config.h"
 // gen_amalgamated expanded: #include "src/android_stats/perfetto_atoms.h"
 // gen_amalgamated expanded: #include "src/tracing/core/id_allocator.h"
+// gen_amalgamated expanded: #include "src/tracing/service/clock.h"
+// gen_amalgamated expanded: #include "src/tracing/service/dependencies.h"
+// gen_amalgamated expanded: #include "src/tracing/service/random.h"
+// gen_amalgamated expanded: #include "src/tracing/service/tracing_service_endpoints_impl.h"
+// gen_amalgamated expanded: #include "src/tracing/service/tracing_service_session.h"
+// gen_amalgamated expanded: #include "src/tracing/service/tracing_service_structs.h"
 
 namespace protozero {
 class MessageFilter;
@@ -55152,10 +62363,6 @@ class MessageFilter;
 
 namespace perfetto {
 
-namespace base {
-class TaskRunner;
-}  // namespace base
-
 namespace protos {
 namespace gen {
 enum TraceStats_FinalFlushOutcome : int;
@@ -55169,14 +62376,11 @@ class SharedMemoryArbiterImpl;
 class TraceBuffer;
 class TracePacket;
 
+namespace tracing_service {
 // The tracing service business logic.
 class TracingServiceImpl : public TracingService {
- private:
-  struct DataSourceInstance;
-
  public:
   static constexpr size_t kMaxShmSize = 32 * 1024 * 1024ul;
-  static constexpr uint32_t kDataSourceStopTimeoutMs = 5000;
   static constexpr uint8_t kSyncMarker[] = {0x82, 0x47, 0x7a, 0x76, 0xb2, 0x8d,
                                             0x42, 0xba, 0x81, 0xdc, 0x33, 0x32,
                                             0x6d, 0x57, 0xa0, 0x79};
@@ -55185,184 +62389,15 @@ class TracingServiceImpl : public TracingService {
                          // tracing_integration_test.cc and b/195065199
 
   // This is a rough threshold to determine how many bytes to read from the
-  // buffers on each iteration when writing into a file. Since filtering
-  // allocates memory, this limits the amount of memory allocated.
+  // buffers on each iteration when writing into a file. Since filtering and
+  // compression allocate memory, this effectively limits the amount of memory
+  // allocated.
   static constexpr size_t kWriteIntoFileChunkSize = 1024 * 1024ul;
 
-  // The implementation behind the service endpoint exposed to each producer.
-  class ProducerEndpointImpl : public TracingService::ProducerEndpoint {
-   public:
-    ProducerEndpointImpl(ProducerID,
-                         uid_t uid,
-                         pid_t pid,
-                         TracingServiceImpl*,
-                         base::TaskRunner*,
-                         Producer*,
-                         const std::string& producer_name,
-                         const std::string& sdk_version,
-                         bool in_process,
-                         bool smb_scraping_enabled);
-    ~ProducerEndpointImpl() override;
-
-    // TracingService::ProducerEndpoint implementation.
-    void Disconnect() override;
-    void RegisterDataSource(const DataSourceDescriptor&) override;
-    void UpdateDataSource(const DataSourceDescriptor&) override;
-    void UnregisterDataSource(const std::string& name) override;
-    void RegisterTraceWriter(uint32_t writer_id,
-                             uint32_t target_buffer) override;
-    void UnregisterTraceWriter(uint32_t writer_id) override;
-    void CommitData(const CommitDataRequest&, CommitDataCallback) override;
-    void SetupSharedMemory(std::unique_ptr<SharedMemory>,
-                           size_t page_size_bytes,
-                           bool provided_by_producer);
-    std::unique_ptr<TraceWriter> CreateTraceWriter(
-        BufferID,
-        BufferExhaustedPolicy) override;
-    SharedMemoryArbiter* MaybeSharedMemoryArbiter() override;
-    bool IsShmemProvidedByProducer() const override;
-    void NotifyFlushComplete(FlushRequestID) override;
-    void NotifyDataSourceStarted(DataSourceInstanceID) override;
-    void NotifyDataSourceStopped(DataSourceInstanceID) override;
-    SharedMemory* shared_memory() const override;
-    size_t shared_buffer_page_size_kb() const override;
-    void ActivateTriggers(const std::vector<std::string>&) override;
-    void Sync(std::function<void()> callback) override;
-
-    void OnTracingSetup();
-    void SetupDataSource(DataSourceInstanceID, const DataSourceConfig&);
-    void StartDataSource(DataSourceInstanceID, const DataSourceConfig&);
-    void StopDataSource(DataSourceInstanceID);
-    void Flush(FlushRequestID, const std::vector<DataSourceInstanceID>&);
-    void OnFreeBuffers(const std::vector<BufferID>& target_buffers);
-    void ClearIncrementalState(const std::vector<DataSourceInstanceID>&);
-
-    bool is_allowed_target_buffer(BufferID buffer_id) const {
-      return allowed_target_buffers_.count(buffer_id);
-    }
-
-    base::Optional<BufferID> buffer_id_for_writer(WriterID writer_id) const {
-      const auto it = writers_.find(writer_id);
-      if (it != writers_.end())
-        return it->second;
-      return base::nullopt;
-    }
-
-    uid_t uid() const { return uid_; }
-    pid_t pid() const { return pid_; }
-
-   private:
-    friend class TracingServiceImpl;
-    friend class TracingServiceImplTest;
-    friend class TracingIntegrationTest;
-    ProducerEndpointImpl(const ProducerEndpointImpl&) = delete;
-    ProducerEndpointImpl& operator=(const ProducerEndpointImpl&) = delete;
-
-    ProducerID const id_;
-    const uid_t uid_;
-    const pid_t pid_;
-    TracingServiceImpl* const service_;
-    base::TaskRunner* const task_runner_;
-    Producer* producer_;
-    std::unique_ptr<SharedMemory> shared_memory_;
-    size_t shared_buffer_page_size_kb_ = 0;
-    SharedMemoryABI shmem_abi_;
-    size_t shmem_size_hint_bytes_ = 0;
-    size_t shmem_page_size_hint_bytes_ = 0;
-    bool is_shmem_provided_by_producer_ = false;
-    const std::string name_;
-    std::string sdk_version_;
-    bool in_process_;
-    bool smb_scraping_enabled_;
-
-    // Set of the global target_buffer IDs that the producer is configured to
-    // write into in any active tracing session.
-    std::set<BufferID> allowed_target_buffers_;
-
-    // Maps registered TraceWriter IDs to their target buffers as registered by
-    // the producer. Note that producers aren't required to register their
-    // writers, so we may see commits of chunks with WriterIDs that aren't
-    // contained in this map. However, if a producer does register a writer, the
-    // service will prevent the writer from writing into any other buffer than
-    // the one associated with it here. The BufferIDs stored in this map are
-    // untrusted, so need to be verified against |allowed_target_buffers_|
-    // before use.
-    std::map<WriterID, BufferID> writers_;
-
-    // This is used only in in-process configurations.
-    // SharedMemoryArbiterImpl methods themselves are thread-safe.
-    std::unique_ptr<SharedMemoryArbiterImpl> inproc_shmem_arbiter_;
-
-    PERFETTO_THREAD_CHECKER(thread_checker_)
-    base::WeakPtrFactory<ProducerEndpointImpl> weak_ptr_factory_;  // Keep last.
-  };
-
-  // The implementation behind the service endpoint exposed to each consumer.
-  class ConsumerEndpointImpl : public TracingService::ConsumerEndpoint {
-   public:
-    ConsumerEndpointImpl(TracingServiceImpl*,
-                         base::TaskRunner*,
-                         Consumer*,
-                         uid_t uid);
-    ~ConsumerEndpointImpl() override;
-
-    void NotifyOnTracingDisabled(const std::string& error);
-
-    // TracingService::ConsumerEndpoint implementation.
-    void EnableTracing(const TraceConfig&, base::ScopedFile) override;
-    void ChangeTraceConfig(const TraceConfig& cfg) override;
-    void StartTracing() override;
-    void DisableTracing() override;
-    void ReadBuffers() override;
-    void FreeBuffers() override;
-    void Flush(uint32_t timeout_ms, FlushCallback) override;
-    void Detach(const std::string& key) override;
-    void Attach(const std::string& key) override;
-    void GetTraceStats() override;
-    void ObserveEvents(uint32_t enabled_event_types) override;
-    void QueryServiceState(QueryServiceStateCallback) override;
-    void QueryCapabilities(QueryCapabilitiesCallback) override;
-    void SaveTraceForBugreport(SaveTraceForBugreportCallback) override;
-    void CloneSession(TracingSessionID) override;
-
-    // Will queue a task to notify the consumer about the state change.
-    void OnDataSourceInstanceStateChange(const ProducerEndpointImpl&,
-                                         const DataSourceInstance&);
-    void OnAllDataSourcesStarted();
-
-    base::WeakPtr<ConsumerEndpointImpl> GetWeakPtr() {
-      return weak_ptr_factory_.GetWeakPtr();
-    }
-
-   private:
-    friend class TracingServiceImpl;
-    ConsumerEndpointImpl(const ConsumerEndpointImpl&) = delete;
-    ConsumerEndpointImpl& operator=(const ConsumerEndpointImpl&) = delete;
-
-    // Returns a pointer to an ObservableEvents object that the caller can fill
-    // and schedules a task to send the ObservableEvents to the consumer.
-    ObservableEvents* AddObservableEvents();
-
-    base::TaskRunner* const task_runner_;
-    TracingServiceImpl* const service_;
-    Consumer* const consumer_;
-    uid_t const uid_;
-    TracingSessionID tracing_session_id_ = 0;
-
-    // Whether the consumer is interested in DataSourceInstance state change
-    // events.
-    uint32_t observable_events_mask_ = 0;
-
-    // ObservableEvents that will be sent to the consumer. If set, a task to
-    // flush the events to the consumer has been queued.
-    std::unique_ptr<ObservableEvents> observable_events_;
-
-    PERFETTO_THREAD_CHECKER(thread_checker_)
-    base::WeakPtrFactory<ConsumerEndpointImpl> weak_ptr_factory_;  // Keep last.
-  };
-
   explicit TracingServiceImpl(std::unique_ptr<SharedMemory::Factory>,
-                              base::TaskRunner*);
+                              base::TaskRunner*,
+                              tracing_service::Dependencies,
+                              InitOpts = {});
   ~TracingServiceImpl() override;
 
   // Called by ProducerEndpointImpl.
@@ -55371,8 +62406,7 @@ class TracingServiceImpl : public TracingService {
   void UpdateDataSource(ProducerID, const DataSourceDescriptor&);
   void UnregisterDataSource(ProducerID, const std::string& name);
   void CopyProducerPageIntoLogBuffer(ProducerID,
-                                     uid_t,
-                                     pid_t,
+                                     const ClientIdentity&,
                                      WriterID,
                                      ChunkID,
                                      BufferID,
@@ -55384,8 +62418,8 @@ class TracingServiceImpl : public TracingService {
   void ApplyChunkPatches(ProducerID,
                          const std::vector<CommitDataRequest::ChunkToPatch>&);
   void NotifyFlushDoneForProducer(ProducerID, FlushRequestID);
-  void NotifyDataSourceStarted(ProducerID, const DataSourceInstanceID);
-  void NotifyDataSourceStopped(ProducerID, const DataSourceInstanceID);
+  void NotifyDataSourceStarted(ProducerID, DataSourceInstanceID);
+  void NotifyDataSourceStopped(ProducerID, DataSourceInstanceID);
   void ActivateTriggers(ProducerID, const std::vector<std::string>& triggers);
 
   // Called by ConsumerEndpointImpl.
@@ -55397,13 +62431,17 @@ class TracingServiceImpl : public TracingService {
                              base::ScopedFile);
   void ChangeTraceConfig(ConsumerEndpointImpl*, const TraceConfig&);
 
-  base::Status StartTracing(TracingSessionID);
-  void DisableTracing(TracingSessionID, bool disable_immediately = false);
+  void StartTracing(TracingSessionID);
+  void DisableTracing(TracingSessionID,
+                      bool disable_immediately = false,
+                      const std::string& error = {});
   void Flush(TracingSessionID tsid,
              uint32_t timeout_ms,
-             ConsumerEndpoint::FlushCallback);
+             ConsumerEndpoint::FlushCallback,
+             FlushFlags);
   void FlushAndDisableTracing(TracingSessionID);
-  void FlushAndCloneSession(ConsumerEndpointImpl*, TracingSessionID);
+  base::Status FlushAndCloneSession(ConsumerEndpointImpl*,
+                                    ConsumerEndpoint::CloneSessionArgs);
 
   // Starts reading the internal tracing buffers from the tracing session `tsid`
   // and sends them to `*consumer` (which must be != nullptr).
@@ -55417,6 +62455,9 @@ class TracingServiceImpl : public TracingService {
 
   // Reads all the tracing buffers from the tracing session `tsid` and writes
   // them into the associated file.
+  // If `async_flush_buffers_before_read` is `true` this function becomes
+  // asynchronous: immediately posts a `Flush` task and returns. Reads the
+  // buffers when the flush is done, inside the `FlushCallback`.
   //
   // Reads all the data in the buffers (or until the file is full) before
   // returning.
@@ -55426,15 +62467,15 @@ class TracingServiceImpl : public TracingService {
   // to be executed after write_period_ms.
   //
   // Returns false in case of error.
-  bool ReadBuffersIntoFile(TracingSessionID);
+  bool ReadBuffersIntoFile(TracingSessionID tsid,
+                           bool async_flush_buffers_before_read);
 
-  void FreeBuffers(TracingSessionID);
+  void FreeBuffers(TracingSessionID tsid, const std::string& error = {});
 
   // Service implementation.
   std::unique_ptr<TracingService::ProducerEndpoint> ConnectProducer(
       Producer*,
-      uid_t uid,
-      pid_t pid,
+      const ClientIdentity& client_identity,
       const std::string& producer_name,
       size_t shared_memory_size_hint_bytes = 0,
       bool in_process = false,
@@ -55442,12 +62483,18 @@ class TracingServiceImpl : public TracingService {
           ProducerSMBScrapingMode::kDefault,
       size_t shared_memory_page_size_hint_bytes = 0,
       std::unique_ptr<SharedMemory> shm = nullptr,
-      const std::string& sdk_version = {}) override;
+      const std::string& sdk_version = {},
+      const std::string& machine_name = {}) override;
 
   std::unique_ptr<TracingService::ConsumerEndpoint> ConnectConsumer(
       Consumer*,
       uid_t) override;
 
+  std::unique_ptr<TracingService::RelayEndpoint> ConnectRelayClient(
+      RelayClientID) override;
+
+  void DisconnectRelayClient(RelayClientID);
+
   // Set whether SMB scraping should be enabled by default or not. Producers can
   // override this setting for their own SMBs.
   void SetSMBScrapingEnabled(bool enabled) override {
@@ -55459,318 +62506,23 @@ class TracingServiceImpl : public TracingService {
   ProducerEndpointImpl* GetProducer(ProducerID) const;
 
  private:
-  friend class TracingServiceImplTest;
-  friend class TracingIntegrationTest;
-
-  static constexpr int64_t kOneDayInNs = 24ll * 60 * 60 * 1000 * 1000 * 1000;
-
-  struct TriggerHistory {
-    int64_t timestamp_ns;
-    uint64_t name_hash;
-
-    bool operator<(const TriggerHistory& other) const {
-      return timestamp_ns < other.timestamp_ns;
-    }
-  };
-
-  struct RegisteredDataSource {
-    ProducerID producer_id;
-    DataSourceDescriptor descriptor;
-  };
-
-  // Represents an active data source for a tracing session.
-  struct DataSourceInstance {
-    DataSourceInstance(DataSourceInstanceID id,
-                       const DataSourceConfig& cfg,
-                       const std::string& ds_name,
-                       bool notify_on_start,
-                       bool notify_on_stop,
-                       bool handles_incremental_state_invalidation)
-        : instance_id(id),
-          config(cfg),
-          data_source_name(ds_name),
-          will_notify_on_start(notify_on_start),
-          will_notify_on_stop(notify_on_stop),
-          handles_incremental_state_clear(
-              handles_incremental_state_invalidation) {}
-    DataSourceInstance(const DataSourceInstance&) = delete;
-    DataSourceInstance& operator=(const DataSourceInstance&) = delete;
-
-    DataSourceInstanceID instance_id;
-    DataSourceConfig config;
-    std::string data_source_name;
-    bool will_notify_on_start;
-    bool will_notify_on_stop;
-    bool handles_incremental_state_clear;
-
-    enum DataSourceInstanceState {
-      CONFIGURED,
-      STARTING,
-      STARTED,
-      STOPPING,
-      STOPPED
-    };
-    DataSourceInstanceState state = CONFIGURED;
-  };
-
-  struct PendingFlush {
-    std::set<ProducerID> producers;
-    ConsumerEndpoint::FlushCallback callback;
-    explicit PendingFlush(decltype(callback) cb) : callback(std::move(cb)) {}
-  };
-
-  // Holds the state of a tracing session. A tracing session is uniquely bound
-  // a specific Consumer. Each Consumer can own one or more sessions.
-  struct TracingSession {
-    enum State {
-      DISABLED = 0,
-      CONFIGURED,
-      STARTED,
-      DISABLING_WAITING_STOP_ACKS,
-      CLONED_READ_ONLY,
-    };
-
-    TracingSession(TracingSessionID,
-                   ConsumerEndpointImpl*,
-                   const TraceConfig&,
-                   base::TaskRunner*);
-    TracingSession(TracingSession&&) = delete;
-    TracingSession& operator=(TracingSession&&) = delete;
-
-    size_t num_buffers() const { return buffers_index.size(); }
-
-    uint32_t delay_to_next_write_period_ms() const {
-      PERFETTO_DCHECK(write_period_ms > 0);
-      return write_period_ms -
-             static_cast<uint32_t>(base::GetWallTimeMs().count() %
-                                   write_period_ms);
-    }
-
-    uint32_t flush_timeout_ms() {
-      uint32_t timeout_ms = config.flush_timeout_ms();
-      return timeout_ms ? timeout_ms : kDefaultFlushTimeoutMs;
-    }
-
-    uint32_t data_source_stop_timeout_ms() {
-      uint32_t timeout_ms = config.data_source_stop_timeout_ms();
-      return timeout_ms ? timeout_ms : kDataSourceStopTimeoutMs;
-    }
-
-    PacketSequenceID GetPacketSequenceID(ProducerID producer_id,
-                                         WriterID writer_id) {
-      auto key = std::make_pair(producer_id, writer_id);
-      auto it = packet_sequence_ids.find(key);
-      if (it != packet_sequence_ids.end())
-        return it->second;
-      // We shouldn't run out of sequence IDs (producer ID is 16 bit, writer IDs
-      // are limited to 1024).
-      static_assert(kMaxPacketSequenceID > kMaxProducerID * kMaxWriterID,
-                    "PacketSequenceID value space doesn't cover service "
-                    "sequence ID and all producer/writer ID combinations!");
-      PERFETTO_DCHECK(last_packet_sequence_id < kMaxPacketSequenceID);
-      PacketSequenceID sequence_id = ++last_packet_sequence_id;
-      packet_sequence_ids[key] = sequence_id;
-      return sequence_id;
-    }
-
-    DataSourceInstance* GetDataSourceInstance(
-        ProducerID producer_id,
-        DataSourceInstanceID instance_id) {
-      for (auto& inst_kv : data_source_instances) {
-        if (inst_kv.first != producer_id ||
-            inst_kv.second.instance_id != instance_id) {
-          continue;
-        }
-        return &inst_kv.second;
-      }
-      return nullptr;
-    }
-
-    bool AllDataSourceInstancesStarted() {
-      return std::all_of(
-          data_source_instances.begin(), data_source_instances.end(),
-          [](decltype(data_source_instances)::const_reference x) {
-            return x.second.state == DataSourceInstance::STARTED;
-          });
-    }
-
-    bool AllDataSourceInstancesStopped() {
-      return std::all_of(
-          data_source_instances.begin(), data_source_instances.end(),
-          [](decltype(data_source_instances)::const_reference x) {
-            return x.second.state == DataSourceInstance::STOPPED;
-          });
-    }
-
-    const TracingSessionID id;
-
-    // The consumer that started the session.
-    // Can be nullptr if the consumer detached from the session.
-    ConsumerEndpointImpl* consumer_maybe_null;
-
-    // Unix uid of the consumer. This is valid even after the consumer detaches
-    // and does not change for the entire duration of the session. It is used to
-    // prevent that a consumer re-attaches to a session from a different uid.
-    uid_t const consumer_uid;
-
-    // The list of triggers this session received while alive and the time they
-    // were received at. This is used to insert 'fake' packets back to the
-    // consumer so they can tell when some event happened. The order matches the
-    // order they were received.
-    struct TriggerInfo {
-      uint64_t boot_time_ns;
-      std::string trigger_name;
-      std::string producer_name;
-      uid_t producer_uid;
-    };
-    std::vector<TriggerInfo> received_triggers;
-
-    // The trace config provided by the Consumer when calling
-    // EnableTracing(), plus any updates performed by ChangeTraceConfig.
-    TraceConfig config;
-
-    // List of data source instances that have been enabled on the various
-    // producers for this tracing session.
-    // TODO(rsavitski): at the time of writing, the map structure is unused
-    // (even when the calling code has a key). This is also an opportunity to
-    // consider an alternative data type, e.g. a map of vectors.
-    std::multimap<ProducerID, DataSourceInstance> data_source_instances;
-
-    // For each Flush(N) request, keeps track of the set of producers for which
-    // we are still awaiting a NotifyFlushComplete(N) ack.
-    std::map<FlushRequestID, PendingFlush> pending_flushes;
-
-    // Maps a per-trace-session buffer index into the corresponding global
-    // BufferID (shared namespace amongst all consumers). This vector has as
-    // many entries as |config.buffers_size()|.
-    std::vector<BufferID> buffers_index;
-
-    std::map<std::pair<ProducerID, WriterID>, PacketSequenceID>
-        packet_sequence_ids;
-    PacketSequenceID last_packet_sequence_id = kServicePacketSequenceID;
-
-    // Whether we should emit the trace stats next time we reach EOF while
-    // performing ReadBuffers.
-    bool should_emit_stats = false;
-
-    // Whether we should emit the sync marker the next time ReadBuffers() is
-    // called.
-    bool should_emit_sync_marker = false;
-
-    // Whether we mirrored the trace config back to the trace output yet.
-    bool did_emit_config = false;
-
-    // Whether we put the system info into the trace output yet.
-    bool did_emit_system_info = false;
-
-    // The number of received triggers we've emitted into the trace output.
-    size_t num_triggers_emitted_into_trace = 0;
-
-    // Packets that failed validation of the TrustedPacket.
-    uint64_t invalid_packets = 0;
-
-    // Flush() stats. See comments in trace_stats.proto for more.
-    uint64_t flushes_requested = 0;
-    uint64_t flushes_succeeded = 0;
-    uint64_t flushes_failed = 0;
-
-    // Outcome of the final Flush() done by FlushAndDisableTracing().
-    protos::gen::TraceStats_FinalFlushOutcome final_flush_outcome{};
-
-    // Set to true on the first call to MaybeNotifyAllDataSourcesStarted().
-    bool did_notify_all_data_source_started = false;
-
-    // Stores all lifecycle events of a particular type (i.e. associated with a
-    // single field id in the TracingServiceEvent proto).
-    struct LifecycleEvent {
-      LifecycleEvent(uint32_t f_id, uint32_t m_size = 1)
-          : field_id(f_id), max_size(m_size), timestamps(m_size) {}
-
-      // The field id of the event in the TracingServiceEvent proto.
-      uint32_t field_id;
-
-      // Stores the max size of |timestamps|. Set to 1 by default (in
-      // the constructor) but can be overriden in TraceSession constructor
-      // if a larger size is required.
-      uint32_t max_size;
-
-      // Stores the timestamps emitted for each event type (in nanoseconds).
-      // Emitted into the trace and cleared when the consumer next calls
-      // ReadBuffers.
-      base::CircularQueue<int64_t> timestamps;
-    };
-    std::vector<LifecycleEvent> lifecycle_events;
-
-    using ClockSnapshotData =
-        std::vector<std::pair<uint32_t /*clock_id*/, uint64_t /*ts*/>>;
-
-    // Initial clock snapshot, captured at trace start time (when state goes to
-    // TracingSession::STARTED). Emitted into the trace when the consumer first
-    // calls ReadBuffers().
-    ClockSnapshotData initial_clock_snapshot;
-
-    // Stores clock snapshots to emit into the trace as a ring buffer. This
-    // buffer is populated both periodically and when lifecycle events happen
-    // but only when significant clock drift is detected. Emitted into the trace
-    // and cleared when the consumer next calls ReadBuffers().
-    base::CircularQueue<ClockSnapshotData> clock_snapshot_ring_buffer;
-
-    State state = DISABLED;
-
-    // If the consumer detached the session, this variable defines the key used
-    // for identifying the session later when reattaching.
-    std::string detach_key;
-
-    // This is set when the Consumer calls sets |write_into_file| == true in the
-    // TraceConfig. In this case this represents the file we should stream the
-    // trace packets into, rather than returning it to the consumer via
-    // OnTraceData().
-    base::ScopedFile write_into_file;
-    uint32_t write_period_ms = 0;
-    uint64_t max_file_size_bytes = 0;
-    uint64_t bytes_written_into_file = 0;
-
-    // Set when using SaveTraceForBugreport(). This callback will be called
-    // when the tracing session ends and the data has been saved into the file.
-    std::function<void()> on_disable_callback_for_bugreport;
-    bool seized_for_bugreport = false;
-
-    // Periodic task for snapshotting service events (e.g. clocks, sync markers
-    // etc)
-    base::PeriodicTask snapshot_periodic_task;
-
-    // Deferred task that stops the trace when |duration_ms| expires. This is
-    // to handle the case of |prefer_suspend_clock_for_duration| which cannot
-    // use PostDelayedTask.
-    base::PeriodicTask timed_stop_task;
-
-    // When non-NULL the packets should be post-processed using the filter.
-    std::unique_ptr<protozero::MessageFilter> trace_filter;
-    uint64_t filter_input_packets = 0;
-    uint64_t filter_input_bytes = 0;
-    uint64_t filter_output_bytes = 0;
-    uint64_t filter_errors = 0;
-
-    // A randomly generated trace identifier. Note that this does NOT always
-    // match the requested TraceConfig.trace_uuid_msb/lsb. Spcifically, it does
-    // until a gap-less snapshot is requested. Each snapshot re-generates the
-    // uuid to avoid emitting two different traces with the same uuid.
-    base::Uuid trace_uuid;
-
-    // NOTE: when adding new fields here consider whether that state should be
-    // copied over in DoCloneSession() or not. Ask yourself: is this a
-    // "runtime state" (e.g. active data sources) or a "trace (meta)data state"?
-    // If the latter, it should be handled by DoCloneSession()).
-  };
+  friend class ProducerEndpointImpl;
+  friend class ConsumerEndpointImpl;
 
   TracingServiceImpl(const TracingServiceImpl&) = delete;
   TracingServiceImpl& operator=(const TracingServiceImpl&) = delete;
 
+  bool IsInitiatorPrivileged(const TracingSession&);
+
   DataSourceInstance* SetupDataSource(const TraceConfig::DataSource&,
                                       const TraceConfig::ProducerConfig&,
                                       const RegisteredDataSource&,
                                       TracingSession*);
 
+  void MaybeSetUpProtoVm(const DataSourceConfig&,
+                         const RegisteredDataSource&,
+                         BufferID);
+
   // Returns the next available ProducerID that is not in |producers_|.
   ProducerID GetNextProducerID();
 
@@ -55778,6 +62530,16 @@ class TracingServiceImpl : public TracingService {
   // session doesn't exists.
   TracingSession* GetTracingSession(TracingSessionID);
 
+  // Returns a pointer to the |tracing_sessions_| entry with
+  // |unique_session_name| in the config (or nullptr if the
+  // session doesn't exists). CLONED_READ_ONLY sessions are ignored.
+  TracingSession* GetTracingSessionByUniqueName(
+      const std::string& unique_session_name);
+
+  // Returns a pointer to the tracing session that has the highest
+  // TraceConfig.bugreport_score, if any, or nullptr.
+  TracingSession* FindTracingSessionWithMaxBugreportScore();
+
   // Returns a pointer to the |tracing_sessions_| entry, matching the given
   // uid and detach key, or nullptr if no such session exists.
   TracingSession* GetDetachedSession(uid_t, const std::string& key);
@@ -55786,6 +62548,7 @@ class TracingServiceImpl : public TracingService {
   // shared memory and trace buffers.
   void UpdateMemoryGuardrail();
 
+  uint32_t DelayToNextWritePeriodMs(const TracingSession&);
   void StartDataSourceInstance(ProducerEndpointImpl*,
                                TracingSession*,
                                DataSourceInstance*);
@@ -55796,9 +62559,15 @@ class TracingServiceImpl : public TracingService {
   void PeriodicSnapshotTask(TracingSessionID);
   void MaybeSnapshotClocksIntoRingBuffer(TracingSession*);
   bool SnapshotClocks(TracingSession::ClockSnapshotData*);
-  void SnapshotLifecyleEvent(TracingSession*,
-                             uint32_t field_id,
-                             bool snapshot_clocks);
+  // Records a lifecycle event of type |field_id| with the current timestamp.
+  void SnapshotLifecycleEvent(TracingSession*,
+                              uint32_t field_id,
+                              bool snapshot_clocks);
+  // Deletes all the lifecycle events of type |field_id| and records just one,
+  // that happened at time |boot_time_ns|.
+  void SetSingleLifecycleEvent(TracingSession*,
+                               uint32_t field_id,
+                               int64_t boot_time_ns);
   void EmitClockSnapshot(TracingSession*,
                          TracingSession::ClockSnapshotData,
                          std::vector<TracePacket>*);
@@ -55806,15 +62575,22 @@ class TracingServiceImpl : public TracingService {
   void EmitStats(TracingSession*, std::vector<TracePacket>*);
   TraceStats GetTraceStats(TracingSession*);
   void EmitLifecycleEvents(TracingSession*, std::vector<TracePacket>*);
-  void EmitSeizedForBugreportLifecycleEvent(std::vector<TracePacket>*);
-  void MaybeEmitUuidAndTraceConfig(TracingSession*, std::vector<TracePacket>*);
-  void MaybeEmitSystemInfo(TracingSession*, std::vector<TracePacket>*);
+  void EmitUuid(TracingSession*, std::vector<TracePacket>*);
+  void MaybeEmitTraceConfig(TracingSession*, std::vector<TracePacket>*);
+  void EmitSystemInfo(std::vector<TracePacket>*);
+  void EmitTraceProvenance(TracingSession*, std::vector<TracePacket>*);
+  void MaybeEmitRemoteSystemInfo(std::vector<TracePacket>*);
+  void MaybeEmitCloneTrigger(TracingSession*, std::vector<TracePacket>*);
   void MaybeEmitReceivedTriggers(TracingSession*, std::vector<TracePacket>*);
+  void MaybeEmitRemoteClockSync(TracingSession*, std::vector<TracePacket>*);
+  void MaybeEmitProtoVmInstances(TracingSession*, std::vector<TracePacket>*);
+  void EmitExtensionDescriptors(TracingSession*, std::vector<TracePacket>*);
   void MaybeNotifyAllDataSourcesStarted(TracingSession*);
-  bool MaybeSaveTraceForBugreport(std::function<void()> callback);
-  void OnFlushTimeout(TracingSessionID, FlushRequestID);
+  void OnFlushTimeout(TracingSessionID, FlushRequestID, FlushFlags);
   void OnDisableTracingTimeout(TracingSessionID);
-  void DisableTracingNotifyConsumerAndFlushFile(TracingSession*);
+  void OnAllDataSourceStartedTimeout(TracingSessionID);
+  void DisableTracingNotifyConsumerAndFlushFile(TracingSession*,
+                                                const std::string& error = {});
   void PeriodicFlushTask(TracingSessionID, bool post_next_only);
   void CompleteFlush(TracingSessionID tsid,
                      ConsumerEndpoint::FlushCallback callback,
@@ -55822,9 +62598,32 @@ class TracingServiceImpl : public TracingService {
   void ScrapeSharedMemoryBuffers(TracingSession*, ProducerEndpointImpl*);
   void PeriodicClearIncrementalStateTask(TracingSessionID, bool post_next_only);
   TraceBuffer* GetBufferByID(BufferID);
-  base::Status DoCloneSession(ConsumerEndpointImpl*,
-                              TracingSessionID,
-                              bool final_flush_outcome);
+  void FlushDataSourceInstances(
+      TracingSession*,
+      uint32_t timeout_ms,
+      const std::map<ProducerID, std::vector<DataSourceInstanceID>>&,
+      ConsumerEndpoint::FlushCallback,
+      FlushFlags);
+  std::map<ProducerID, std::vector<DataSourceInstanceID>>
+  GetFlushableDataSourceInstancesForBuffers(TracingSession*,
+                                            const std::set<BufferID>&);
+  bool DoCloneBuffers(const TracingSession&,
+                      const std::set<BufferID>&,
+                      PendingClone*);
+  base::Status FinishCloneSession(ConsumerEndpointImpl*,
+                                  TracingSessionID,
+                                  std::vector<std::unique_ptr<TraceBuffer>>,
+                                  std::vector<int64_t> buf_cloned_timestamps,
+                                  bool skip_filter,
+                                  bool final_flush_outcome,
+                                  std::optional<TriggerInfo> clone_trigger,
+                                  base::Uuid*,
+                                  int64_t clone_started_timestamp_ns,
+                                  base::ScopedFile output_file_fd);
+  void OnFlushDoneForClone(TracingSessionID src_tsid,
+                           PendingCloneID clone_id,
+                           const std::set<BufferID>& buf_ids,
+                           bool final_flush_outcome);
 
   // Returns true if `*tracing_session` is waiting for a trigger that hasn't
   // happened.
@@ -55845,6 +62644,10 @@ class TracingServiceImpl : public TracingService {
   void MaybeFilterPackets(TracingSession* tracing_session,
                           std::vector<TracePacket>* packets);
 
+  // If `*tracing_session` has compression enabled, compress `*packets`.
+  void MaybeCompressPackets(TracingSession* tracing_session,
+                            std::vector<TracePacket>* packets);
+
   // If `*tracing_session` is configured to write into a file, writes `packets`
   // into the file.
   //
@@ -55858,14 +62661,16 @@ class TracingServiceImpl : public TracingService {
                            PerfettoStatsdAtom atom,
                            const std::string& trigger_name = "");
   void MaybeLogTriggerEvent(const TraceConfig&,
+                            const base::Uuid&,
                             PerfettoTriggerAtom atom,
                             const std::string& trigger_name);
   size_t PurgeExpiredAndCountTriggerInWindow(int64_t now_ns,
                                              uint64_t trigger_name_hash);
-  static void StopOnDurationMsExpiry(base::WeakPtr<TracingServiceImpl>,
-                                     TracingSessionID);
+  void StopOnDurationMsExpiry(TracingSessionID);
 
-  base::TaskRunner* const task_runner_;
+  std::unique_ptr<tracing_service::Clock> clock_;
+  std::unique_ptr<tracing_service::Random> random_;
+  const InitOpts init_opts_;
   std::unique_ptr<SharedMemory::Factory> shm_factory_;
   ProducerID last_producer_id_ = 0;
   DataSourceInstanceID last_data_source_instance_id_ = 0;
@@ -55879,24 +62684,18 @@ class TracingServiceImpl : public TracingService {
 
   std::multimap<std::string /*name*/, RegisteredDataSource> data_sources_;
   std::map<ProducerID, ProducerEndpointImpl*> producers_;
-  std::set<ConsumerEndpointImpl*> consumers_;
+  std::map<RelayClientID, RelayEndpointImpl*> relay_clients_;
   std::map<TracingSessionID, TracingSession> tracing_sessions_;
   std::map<BufferID, std::unique_ptr<TraceBuffer>> buffers_;
   std::map<std::string, int64_t> session_to_last_trace_s_;
 
   // Contains timestamps of triggers.
-  // The queue is sorted by timestamp and invocations older than
-  // |trigger_window_ns_| are purged when a trigger happens.
+  // The queue is sorted by timestamp and invocations older than 24 hours are
+  // purged when a trigger happens.
   base::CircularQueue<TriggerHistory> trigger_history_;
 
   bool smb_scraping_enabled_ = false;
   bool lockdown_mode_ = false;
-  uint32_t min_write_period_ms_ = 100;       // Overridable for testing.
-  int64_t trigger_window_ns_ = kOneDayInNs;  // Overridable for testing.
-
-  std::minstd_rand trigger_probability_rand_;
-  std::uniform_real_distribution<> trigger_probability_dist_;
-  double trigger_rnd_override_for_testing_ = 0;  // Overridable for testing.
 
   uint8_t sync_marker_packet_[32];  // Lazily initialized.
   size_t sync_marker_packet_size_ = 0;
@@ -55907,16 +62706,15 @@ class TracingServiceImpl : public TracingService {
 
   PERFETTO_THREAD_CHECKER(thread_checker_)
 
-  base::WeakPtrFactory<TracingServiceImpl>
-      weak_ptr_factory_;  // Keep at the end.
+  base::WeakRunner weak_runner_;
 };
 
+}  // namespace tracing_service
 }  // namespace perfetto
 
-#endif  // SRC_TRACING_CORE_TRACING_SERVICE_IMPL_H_
-// gen_amalgamated begin header: include/perfetto/tracing/core/tracing_service_capabilities.h
+#endif  // SRC_TRACING_SERVICE_TRACING_SERVICE_IMPL_H_
 /*
- * Copyright (C) 2020 The Android Open Source Project
+ * Copyright (C) 2025 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -55931,4598 +62729,808 @@ class TracingServiceImpl : public TracingService {
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_TRACING_CORE_TRACING_SERVICE_CAPABILITIES_H_
-#define INCLUDE_PERFETTO_TRACING_CORE_TRACING_SERVICE_CAPABILITIES_H_
-
-// Creates the aliases in the ::perfetto namespace, doing things like:
-// using ::perfetto::Foo = ::perfetto::protos::gen::Foo.
-// See comments in forward_decls.h for the historical reasons of this
-// indirection layer.
-// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
-
-// gen_amalgamated expanded: #include "protos/perfetto/common/tracing_service_capabilities.gen.h"
-
-#endif  // INCLUDE_PERFETTO_TRACING_CORE_TRACING_SERVICE_CAPABILITIES_H_
-// gen_amalgamated begin header: gen/protos/perfetto/common/trace_stats.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_TRACE_STATS_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_TRACE_STATS_PROTO_H_
+// gen_amalgamated expanded: #include "src/tracing/service/tracing_service_endpoints_impl.h"
+// gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/file_utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/metatrace.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_view.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/version.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/consumer.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/producer.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_writer.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/tracing_service_capabilities.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/tracing_service_state.h"
+// gen_amalgamated expanded: #include "src/tracing/core/shared_memory_arbiter_impl.h"
+// gen_amalgamated expanded: #include "src/tracing/service/tracing_service_impl.h"
+// gen_amalgamated expanded: #include "src/tracing/service/tracing_service_structs.h"
 
-#include <stddef.h>
-#include <stdint.h>
+// gen_amalgamated expanded: #include "protos/perfetto/common/builtin_clock.pbzero.h"
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+namespace perfetto::tracing_service {
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+namespace {
+// Partially encodes a CommitDataRequest in an int32 for the purposes of
+// metatracing. Note that it encodes only the bottom 10 bits of the producer id
+// (which is technically 16 bits wide).
+//
+// Format (by bit range):
+// [   31 ][         30 ][             29:20 ][            19:10 ][        9:0]
+// [unused][has flush id][num chunks to patch][num chunks to move][producer id]
+int32_t EncodeCommitDataRequest(ProducerID producer_id,
+                                const CommitDataRequest& req_untrusted) {
+  uint32_t cmov = static_cast<uint32_t>(req_untrusted.chunks_to_move_size());
+  uint32_t cpatch = static_cast<uint32_t>(req_untrusted.chunks_to_patch_size());
+  uint32_t has_flush_id = req_untrusted.flush_request_id() != 0;
 
-class TraceStats_BufferStats;
-class TraceStats_FilterStats;
-namespace perfetto_pbzero_enum_TraceStats {
-enum FinalFlushOutcome : int32_t;
-}  // namespace perfetto_pbzero_enum_TraceStats
-using TraceStats_FinalFlushOutcome = perfetto_pbzero_enum_TraceStats::FinalFlushOutcome;
-
-namespace perfetto_pbzero_enum_TraceStats {
-enum FinalFlushOutcome : int32_t {
-  FINAL_FLUSH_UNSPECIFIED = 0,
-  FINAL_FLUSH_SUCCEEDED = 1,
-  FINAL_FLUSH_FAILED = 2,
-};
-} // namespace perfetto_pbzero_enum_TraceStats
-using TraceStats_FinalFlushOutcome = perfetto_pbzero_enum_TraceStats::FinalFlushOutcome;
+  uint32_t mask = (1 << 10) - 1;
+  uint32_t acc = 0;
+  acc |= has_flush_id << 30;
+  acc |= (cpatch & mask) << 20;
+  acc |= (cmov & mask) << 10;
+  acc |= (producer_id & mask);
+  return static_cast<int32_t>(acc);
+}
+}  // namespace
 
+////////////////////////////////////////////////////////////////////////////////
+// ConsumerEndpointImpl implementation
+////////////////////////////////////////////////////////////////////////////////
 
-constexpr TraceStats_FinalFlushOutcome TraceStats_FinalFlushOutcome_MIN = TraceStats_FinalFlushOutcome::FINAL_FLUSH_UNSPECIFIED;
-constexpr TraceStats_FinalFlushOutcome TraceStats_FinalFlushOutcome_MAX = TraceStats_FinalFlushOutcome::FINAL_FLUSH_FAILED;
+ConsumerEndpointImpl::ConsumerEndpointImpl(TracingServiceImpl* service,
+                                           base::TaskRunner* task_runner,
+                                           Consumer* consumer,
+                                           uid_t uid)
+    : task_runner_(task_runner),
+      service_(service),
+      consumer_(consumer),
+      uid_(uid),
+      weak_ptr_factory_(this) {}
 
+ConsumerEndpointImpl::~ConsumerEndpointImpl() {
+  service_->DisconnectConsumer(this);
+  consumer_->OnDisconnect();
+}
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* TraceStats_FinalFlushOutcome_Name(::perfetto::protos::pbzero::TraceStats_FinalFlushOutcome value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::TraceStats_FinalFlushOutcome::FINAL_FLUSH_UNSPECIFIED:
-    return "FINAL_FLUSH_UNSPECIFIED";
+void ConsumerEndpointImpl::NotifyOnTracingDisabled(const std::string& error) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  task_runner_->PostTask([weak_this = weak_ptr_factory_.GetWeakPtr(),
+                          error /* deliberate copy */] {
+    if (weak_this)
+      weak_this->consumer_->OnTracingDisabled(error);
+  });
+}
 
-  case ::perfetto::protos::pbzero::TraceStats_FinalFlushOutcome::FINAL_FLUSH_SUCCEEDED:
-    return "FINAL_FLUSH_SUCCEEDED";
+void ConsumerEndpointImpl::EnableTracing(const TraceConfig& cfg,
+                                         base::ScopedFile fd) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  auto status = service_->EnableTracing(this, cfg, std::move(fd));
+  if (!status.ok())
+    NotifyOnTracingDisabled(status.message());
+}
 
-  case ::perfetto::protos::pbzero::TraceStats_FinalFlushOutcome::FINAL_FLUSH_FAILED:
-    return "FINAL_FLUSH_FAILED";
+void ConsumerEndpointImpl::ChangeTraceConfig(const TraceConfig& cfg) {
+  if (!tracing_session_id_) {
+    PERFETTO_LOG(
+        "Consumer called ChangeTraceConfig() but tracing was "
+        "not active");
+    return;
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
+  service_->ChangeTraceConfig(this, cfg);
 }
 
-class TraceStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/15, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  TraceStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_buffer_stats() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> buffer_stats() const { return GetRepeated<::protozero::ConstBytes>(1); }
-  bool has_producers_connected() const { return at<2>().valid(); }
-  uint32_t producers_connected() const { return at<2>().as_uint32(); }
-  bool has_producers_seen() const { return at<3>().valid(); }
-  uint64_t producers_seen() const { return at<3>().as_uint64(); }
-  bool has_data_sources_registered() const { return at<4>().valid(); }
-  uint32_t data_sources_registered() const { return at<4>().as_uint32(); }
-  bool has_data_sources_seen() const { return at<5>().valid(); }
-  uint64_t data_sources_seen() const { return at<5>().as_uint64(); }
-  bool has_tracing_sessions() const { return at<6>().valid(); }
-  uint32_t tracing_sessions() const { return at<6>().as_uint32(); }
-  bool has_total_buffers() const { return at<7>().valid(); }
-  uint32_t total_buffers() const { return at<7>().as_uint32(); }
-  bool has_chunks_discarded() const { return at<8>().valid(); }
-  uint64_t chunks_discarded() const { return at<8>().as_uint64(); }
-  bool has_patches_discarded() const { return at<9>().valid(); }
-  uint64_t patches_discarded() const { return at<9>().as_uint64(); }
-  bool has_invalid_packets() const { return at<10>().valid(); }
-  uint64_t invalid_packets() const { return at<10>().as_uint64(); }
-  bool has_filter_stats() const { return at<11>().valid(); }
-  ::protozero::ConstBytes filter_stats() const { return at<11>().as_bytes(); }
-  bool has_flushes_requested() const { return at<12>().valid(); }
-  uint64_t flushes_requested() const { return at<12>().as_uint64(); }
-  bool has_flushes_succeeded() const { return at<13>().valid(); }
-  uint64_t flushes_succeeded() const { return at<13>().as_uint64(); }
-  bool has_flushes_failed() const { return at<14>().valid(); }
-  uint64_t flushes_failed() const { return at<14>().as_uint64(); }
-  bool has_final_flush_outcome() const { return at<15>().valid(); }
-  int32_t final_flush_outcome() const { return at<15>().as_int32(); }
-};
-
-class TraceStats : public ::protozero::Message {
- public:
-  using Decoder = TraceStats_Decoder;
-  enum : int32_t {
-    kBufferStatsFieldNumber = 1,
-    kProducersConnectedFieldNumber = 2,
-    kProducersSeenFieldNumber = 3,
-    kDataSourcesRegisteredFieldNumber = 4,
-    kDataSourcesSeenFieldNumber = 5,
-    kTracingSessionsFieldNumber = 6,
-    kTotalBuffersFieldNumber = 7,
-    kChunksDiscardedFieldNumber = 8,
-    kPatchesDiscardedFieldNumber = 9,
-    kInvalidPacketsFieldNumber = 10,
-    kFilterStatsFieldNumber = 11,
-    kFlushesRequestedFieldNumber = 12,
-    kFlushesSucceededFieldNumber = 13,
-    kFlushesFailedFieldNumber = 14,
-    kFinalFlushOutcomeFieldNumber = 15,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceStats"; }
-
-  using BufferStats = ::perfetto::protos::pbzero::TraceStats_BufferStats;
-  using FilterStats = ::perfetto::protos::pbzero::TraceStats_FilterStats;
-
-  using FinalFlushOutcome = ::perfetto::protos::pbzero::TraceStats_FinalFlushOutcome;
-  static inline const char* FinalFlushOutcome_Name(FinalFlushOutcome value) {
-    return ::perfetto::protos::pbzero::TraceStats_FinalFlushOutcome_Name(value);
-  }
-  static const FinalFlushOutcome FINAL_FLUSH_UNSPECIFIED = FinalFlushOutcome::FINAL_FLUSH_UNSPECIFIED;
-  static const FinalFlushOutcome FINAL_FLUSH_SUCCEEDED = FinalFlushOutcome::FINAL_FLUSH_SUCCEEDED;
-  static const FinalFlushOutcome FINAL_FLUSH_FAILED = FinalFlushOutcome::FINAL_FLUSH_FAILED;
-
-  using FieldMetadata_BufferStats =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceStats_BufferStats,
-      TraceStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BufferStats kBufferStats() { return {}; }
-  template <typename T = TraceStats_BufferStats> T* add_buffer_stats() {
-    return BeginNestedMessage<T>(1);
-  }
-
-
-  using FieldMetadata_ProducersConnected =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProducersConnected kProducersConnected() { return {}; }
-  void set_producers_connected(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProducersConnected::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ProducersSeen =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProducersSeen kProducersSeen() { return {}; }
-  void set_producers_seen(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProducersSeen::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_DataSourcesRegistered =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DataSourcesRegistered kDataSourcesRegistered() { return {}; }
-  void set_data_sources_registered(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DataSourcesRegistered::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_DataSourcesSeen =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DataSourcesSeen kDataSourcesSeen() { return {}; }
-  void set_data_sources_seen(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DataSourcesSeen::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_TracingSessions =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TracingSessions kTracingSessions() { return {}; }
-  void set_tracing_sessions(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TracingSessions::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_TotalBuffers =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TotalBuffers kTotalBuffers() { return {}; }
-  void set_total_buffers(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TotalBuffers::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ChunksDiscarded =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChunksDiscarded kChunksDiscarded() { return {}; }
-  void set_chunks_discarded(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ChunksDiscarded::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_PatchesDiscarded =
-    ::protozero::proto_utils::FieldMetadata<
-      9,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PatchesDiscarded kPatchesDiscarded() { return {}; }
-  void set_patches_discarded(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PatchesDiscarded::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_InvalidPackets =
-    ::protozero::proto_utils::FieldMetadata<
-      10,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InvalidPackets kInvalidPackets() { return {}; }
-  void set_invalid_packets(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_InvalidPackets::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_FilterStats =
-    ::protozero::proto_utils::FieldMetadata<
-      11,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceStats_FilterStats,
-      TraceStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FilterStats kFilterStats() { return {}; }
-  template <typename T = TraceStats_FilterStats> T* set_filter_stats() {
-    return BeginNestedMessage<T>(11);
-  }
-
-
-  using FieldMetadata_FlushesRequested =
-    ::protozero::proto_utils::FieldMetadata<
-      12,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FlushesRequested kFlushesRequested() { return {}; }
-  void set_flushes_requested(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FlushesRequested::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_FlushesSucceeded =
-    ::protozero::proto_utils::FieldMetadata<
-      13,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FlushesSucceeded kFlushesSucceeded() { return {}; }
-  void set_flushes_succeeded(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FlushesSucceeded::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_FlushesFailed =
-    ::protozero::proto_utils::FieldMetadata<
-      14,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FlushesFailed kFlushesFailed() { return {}; }
-  void set_flushes_failed(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FlushesFailed::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_FinalFlushOutcome =
-    ::protozero::proto_utils::FieldMetadata<
-      15,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::TraceStats_FinalFlushOutcome,
-      TraceStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FinalFlushOutcome kFinalFlushOutcome() { return {}; }
-  void set_final_flush_outcome(::perfetto::protos::pbzero::TraceStats_FinalFlushOutcome value) {
-    static constexpr uint32_t field_id = FieldMetadata_FinalFlushOutcome::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
+void ConsumerEndpointImpl::StartTracing() {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  if (!tracing_session_id_) {
+    PERFETTO_LOG("Consumer called StartTracing() but tracing was not active");
+    return;
   }
-};
-
-class TraceStats_FilterStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TraceStats_FilterStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceStats_FilterStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceStats_FilterStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_input_packets() const { return at<1>().valid(); }
-  uint64_t input_packets() const { return at<1>().as_uint64(); }
-  bool has_input_bytes() const { return at<2>().valid(); }
-  uint64_t input_bytes() const { return at<2>().as_uint64(); }
-  bool has_output_bytes() const { return at<3>().valid(); }
-  uint64_t output_bytes() const { return at<3>().as_uint64(); }
-  bool has_errors() const { return at<4>().valid(); }
-  uint64_t errors() const { return at<4>().as_uint64(); }
-};
+  service_->StartTracing(tracing_session_id_);
+}
 
-class TraceStats_FilterStats : public ::protozero::Message {
- public:
-  using Decoder = TraceStats_FilterStats_Decoder;
-  enum : int32_t {
-    kInputPacketsFieldNumber = 1,
-    kInputBytesFieldNumber = 2,
-    kOutputBytesFieldNumber = 3,
-    kErrorsFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceStats.FilterStats"; }
-
-
-  using FieldMetadata_InputPackets =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats_FilterStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InputPackets kInputPackets() { return {}; }
-  void set_input_packets(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_InputPackets::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_InputBytes =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats_FilterStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InputBytes kInputBytes() { return {}; }
-  void set_input_bytes(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_InputBytes::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_OutputBytes =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats_FilterStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OutputBytes kOutputBytes() { return {}; }
-  void set_output_bytes(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OutputBytes::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Errors =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats_FilterStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Errors kErrors() { return {}; }
-  void set_errors(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Errors::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
+void ConsumerEndpointImpl::DisableTracing() {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  if (!tracing_session_id_) {
+    PERFETTO_LOG("Consumer called DisableTracing() but tracing was not active");
+    return;
   }
-};
-
-class TraceStats_BufferStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/19, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TraceStats_BufferStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceStats_BufferStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceStats_BufferStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_buffer_size() const { return at<12>().valid(); }
-  uint64_t buffer_size() const { return at<12>().as_uint64(); }
-  bool has_bytes_written() const { return at<1>().valid(); }
-  uint64_t bytes_written() const { return at<1>().as_uint64(); }
-  bool has_bytes_overwritten() const { return at<13>().valid(); }
-  uint64_t bytes_overwritten() const { return at<13>().as_uint64(); }
-  bool has_bytes_read() const { return at<14>().valid(); }
-  uint64_t bytes_read() const { return at<14>().as_uint64(); }
-  bool has_padding_bytes_written() const { return at<15>().valid(); }
-  uint64_t padding_bytes_written() const { return at<15>().as_uint64(); }
-  bool has_padding_bytes_cleared() const { return at<16>().valid(); }
-  uint64_t padding_bytes_cleared() const { return at<16>().as_uint64(); }
-  bool has_chunks_written() const { return at<2>().valid(); }
-  uint64_t chunks_written() const { return at<2>().as_uint64(); }
-  bool has_chunks_rewritten() const { return at<10>().valid(); }
-  uint64_t chunks_rewritten() const { return at<10>().as_uint64(); }
-  bool has_chunks_overwritten() const { return at<3>().valid(); }
-  uint64_t chunks_overwritten() const { return at<3>().as_uint64(); }
-  bool has_chunks_discarded() const { return at<18>().valid(); }
-  uint64_t chunks_discarded() const { return at<18>().as_uint64(); }
-  bool has_chunks_read() const { return at<17>().valid(); }
-  uint64_t chunks_read() const { return at<17>().as_uint64(); }
-  bool has_chunks_committed_out_of_order() const { return at<11>().valid(); }
-  uint64_t chunks_committed_out_of_order() const { return at<11>().as_uint64(); }
-  bool has_write_wrap_count() const { return at<4>().valid(); }
-  uint64_t write_wrap_count() const { return at<4>().as_uint64(); }
-  bool has_patches_succeeded() const { return at<5>().valid(); }
-  uint64_t patches_succeeded() const { return at<5>().as_uint64(); }
-  bool has_patches_failed() const { return at<6>().valid(); }
-  uint64_t patches_failed() const { return at<6>().as_uint64(); }
-  bool has_readaheads_succeeded() const { return at<7>().valid(); }
-  uint64_t readaheads_succeeded() const { return at<7>().as_uint64(); }
-  bool has_readaheads_failed() const { return at<8>().valid(); }
-  uint64_t readaheads_failed() const { return at<8>().as_uint64(); }
-  bool has_abi_violations() const { return at<9>().valid(); }
-  uint64_t abi_violations() const { return at<9>().as_uint64(); }
-  bool has_trace_writer_packet_loss() const { return at<19>().valid(); }
-  uint64_t trace_writer_packet_loss() const { return at<19>().as_uint64(); }
-};
+  service_->DisableTracing(tracing_session_id_);
+}
 
-class TraceStats_BufferStats : public ::protozero::Message {
- public:
-  using Decoder = TraceStats_BufferStats_Decoder;
-  enum : int32_t {
-    kBufferSizeFieldNumber = 12,
-    kBytesWrittenFieldNumber = 1,
-    kBytesOverwrittenFieldNumber = 13,
-    kBytesReadFieldNumber = 14,
-    kPaddingBytesWrittenFieldNumber = 15,
-    kPaddingBytesClearedFieldNumber = 16,
-    kChunksWrittenFieldNumber = 2,
-    kChunksRewrittenFieldNumber = 10,
-    kChunksOverwrittenFieldNumber = 3,
-    kChunksDiscardedFieldNumber = 18,
-    kChunksReadFieldNumber = 17,
-    kChunksCommittedOutOfOrderFieldNumber = 11,
-    kWriteWrapCountFieldNumber = 4,
-    kPatchesSucceededFieldNumber = 5,
-    kPatchesFailedFieldNumber = 6,
-    kReadaheadsSucceededFieldNumber = 7,
-    kReadaheadsFailedFieldNumber = 8,
-    kAbiViolationsFieldNumber = 9,
-    kTraceWriterPacketLossFieldNumber = 19,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceStats.BufferStats"; }
-
-
-  using FieldMetadata_BufferSize =
-    ::protozero::proto_utils::FieldMetadata<
-      12,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats_BufferStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BufferSize kBufferSize() { return {}; }
-  void set_buffer_size(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BufferSize::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_BytesWritten =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats_BufferStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BytesWritten kBytesWritten() { return {}; }
-  void set_bytes_written(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BytesWritten::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_BytesOverwritten =
-    ::protozero::proto_utils::FieldMetadata<
-      13,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats_BufferStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BytesOverwritten kBytesOverwritten() { return {}; }
-  void set_bytes_overwritten(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BytesOverwritten::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_BytesRead =
-    ::protozero::proto_utils::FieldMetadata<
-      14,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats_BufferStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BytesRead kBytesRead() { return {}; }
-  void set_bytes_read(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BytesRead::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_PaddingBytesWritten =
-    ::protozero::proto_utils::FieldMetadata<
-      15,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats_BufferStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PaddingBytesWritten kPaddingBytesWritten() { return {}; }
-  void set_padding_bytes_written(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PaddingBytesWritten::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_PaddingBytesCleared =
-    ::protozero::proto_utils::FieldMetadata<
-      16,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats_BufferStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PaddingBytesCleared kPaddingBytesCleared() { return {}; }
-  void set_padding_bytes_cleared(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PaddingBytesCleared::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ChunksWritten =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats_BufferStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChunksWritten kChunksWritten() { return {}; }
-  void set_chunks_written(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ChunksWritten::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ChunksRewritten =
-    ::protozero::proto_utils::FieldMetadata<
-      10,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats_BufferStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChunksRewritten kChunksRewritten() { return {}; }
-  void set_chunks_rewritten(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ChunksRewritten::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ChunksOverwritten =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats_BufferStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChunksOverwritten kChunksOverwritten() { return {}; }
-  void set_chunks_overwritten(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ChunksOverwritten::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ChunksDiscarded =
-    ::protozero::proto_utils::FieldMetadata<
-      18,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats_BufferStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChunksDiscarded kChunksDiscarded() { return {}; }
-  void set_chunks_discarded(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ChunksDiscarded::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ChunksRead =
-    ::protozero::proto_utils::FieldMetadata<
-      17,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats_BufferStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChunksRead kChunksRead() { return {}; }
-  void set_chunks_read(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ChunksRead::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ChunksCommittedOutOfOrder =
-    ::protozero::proto_utils::FieldMetadata<
-      11,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats_BufferStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChunksCommittedOutOfOrder kChunksCommittedOutOfOrder() { return {}; }
-  void set_chunks_committed_out_of_order(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ChunksCommittedOutOfOrder::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_WriteWrapCount =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats_BufferStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WriteWrapCount kWriteWrapCount() { return {}; }
-  void set_write_wrap_count(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_WriteWrapCount::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_PatchesSucceeded =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats_BufferStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PatchesSucceeded kPatchesSucceeded() { return {}; }
-  void set_patches_succeeded(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PatchesSucceeded::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_PatchesFailed =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats_BufferStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PatchesFailed kPatchesFailed() { return {}; }
-  void set_patches_failed(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PatchesFailed::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ReadaheadsSucceeded =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats_BufferStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReadaheadsSucceeded kReadaheadsSucceeded() { return {}; }
-  void set_readaheads_succeeded(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReadaheadsSucceeded::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ReadaheadsFailed =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats_BufferStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReadaheadsFailed kReadaheadsFailed() { return {}; }
-  void set_readaheads_failed(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReadaheadsFailed::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_AbiViolations =
-    ::protozero::proto_utils::FieldMetadata<
-      9,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats_BufferStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AbiViolations kAbiViolations() { return {}; }
-  void set_abi_violations(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AbiViolations::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_TraceWriterPacketLoss =
-    ::protozero::proto_utils::FieldMetadata<
-      19,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceStats_BufferStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceWriterPacketLoss kTraceWriterPacketLoss() { return {}; }
-  void set_trace_writer_packet_loss(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TraceWriterPacketLoss::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
+void ConsumerEndpointImpl::ReadBuffers() {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  if (!tracing_session_id_) {
+    PERFETTO_LOG("Consumer called ReadBuffers() but tracing was not active");
+    consumer_->OnTraceData({}, /* has_more = */ false);
+    return;
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/trace_config.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TRACE_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TRACE_CONFIG_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-class DataSourceConfig;
-class TraceConfig_AndroidReportConfig;
-class TraceConfig_BufferConfig;
-class TraceConfig_BuiltinDataSource;
-class TraceConfig_CmdTraceStartDelay;
-class TraceConfig_DataSource;
-class TraceConfig_GuardrailOverrides;
-class TraceConfig_IncidentReportConfig;
-class TraceConfig_IncrementalStateConfig;
-class TraceConfig_ProducerConfig;
-class TraceConfig_StatsdMetadata;
-class TraceConfig_TraceFilter;
-class TraceConfig_TriggerConfig;
-class TraceConfig_TriggerConfig_Trigger;
-enum BuiltinClock : int32_t;
-namespace perfetto_pbzero_enum_TraceConfig_BufferConfig {
-enum FillPolicy : int32_t;
-}  // namespace perfetto_pbzero_enum_TraceConfig_BufferConfig
-using TraceConfig_BufferConfig_FillPolicy = perfetto_pbzero_enum_TraceConfig_BufferConfig::FillPolicy;
-namespace perfetto_pbzero_enum_TraceConfig {
-enum CompressionType : int32_t;
-}  // namespace perfetto_pbzero_enum_TraceConfig
-using TraceConfig_CompressionType = perfetto_pbzero_enum_TraceConfig::CompressionType;
-namespace perfetto_pbzero_enum_TraceConfig {
-enum LockdownModeOperation : int32_t;
-}  // namespace perfetto_pbzero_enum_TraceConfig
-using TraceConfig_LockdownModeOperation = perfetto_pbzero_enum_TraceConfig::LockdownModeOperation;
-namespace perfetto_pbzero_enum_TraceConfig {
-enum StatsdLogging : int32_t;
-}  // namespace perfetto_pbzero_enum_TraceConfig
-using TraceConfig_StatsdLogging = perfetto_pbzero_enum_TraceConfig::StatsdLogging;
-namespace perfetto_pbzero_enum_TraceConfig_TriggerConfig {
-enum TriggerMode : int32_t;
-}  // namespace perfetto_pbzero_enum_TraceConfig_TriggerConfig
-using TraceConfig_TriggerConfig_TriggerMode = perfetto_pbzero_enum_TraceConfig_TriggerConfig::TriggerMode;
-
-namespace perfetto_pbzero_enum_TraceConfig {
-enum LockdownModeOperation : int32_t {
-  LOCKDOWN_UNCHANGED = 0,
-  LOCKDOWN_CLEAR = 1,
-  LOCKDOWN_SET = 2,
-};
-} // namespace perfetto_pbzero_enum_TraceConfig
-using TraceConfig_LockdownModeOperation = perfetto_pbzero_enum_TraceConfig::LockdownModeOperation;
-
-
-constexpr TraceConfig_LockdownModeOperation TraceConfig_LockdownModeOperation_MIN = TraceConfig_LockdownModeOperation::LOCKDOWN_UNCHANGED;
-constexpr TraceConfig_LockdownModeOperation TraceConfig_LockdownModeOperation_MAX = TraceConfig_LockdownModeOperation::LOCKDOWN_SET;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* TraceConfig_LockdownModeOperation_Name(::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation::LOCKDOWN_UNCHANGED:
-    return "LOCKDOWN_UNCHANGED";
-
-  case ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation::LOCKDOWN_CLEAR:
-    return "LOCKDOWN_CLEAR";
-
-  case ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation::LOCKDOWN_SET:
-    return "LOCKDOWN_SET";
+  if (!service_->ReadBuffersIntoConsumer(tracing_session_id_, this)) {
+    consumer_->OnTraceData({}, /* has_more = */ false);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-namespace perfetto_pbzero_enum_TraceConfig {
-enum CompressionType : int32_t {
-  COMPRESSION_TYPE_UNSPECIFIED = 0,
-  COMPRESSION_TYPE_DEFLATE = 1,
-};
-} // namespace perfetto_pbzero_enum_TraceConfig
-using TraceConfig_CompressionType = perfetto_pbzero_enum_TraceConfig::CompressionType;
-
-
-constexpr TraceConfig_CompressionType TraceConfig_CompressionType_MIN = TraceConfig_CompressionType::COMPRESSION_TYPE_UNSPECIFIED;
-constexpr TraceConfig_CompressionType TraceConfig_CompressionType_MAX = TraceConfig_CompressionType::COMPRESSION_TYPE_DEFLATE;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* TraceConfig_CompressionType_Name(::perfetto::protos::pbzero::TraceConfig_CompressionType value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::TraceConfig_CompressionType::COMPRESSION_TYPE_UNSPECIFIED:
-    return "COMPRESSION_TYPE_UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::TraceConfig_CompressionType::COMPRESSION_TYPE_DEFLATE:
-    return "COMPRESSION_TYPE_DEFLATE";
+void ConsumerEndpointImpl::FreeBuffers() {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  if (!tracing_session_id_) {
+    PERFETTO_LOG("Consumer called FreeBuffers() but tracing was not active");
+    return;
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
+  service_->FreeBuffers(tracing_session_id_);
+  tracing_session_id_ = 0;
 }
 
-namespace perfetto_pbzero_enum_TraceConfig {
-enum StatsdLogging : int32_t {
-  STATSD_LOGGING_UNSPECIFIED = 0,
-  STATSD_LOGGING_ENABLED = 1,
-  STATSD_LOGGING_DISABLED = 2,
-};
-} // namespace perfetto_pbzero_enum_TraceConfig
-using TraceConfig_StatsdLogging = perfetto_pbzero_enum_TraceConfig::StatsdLogging;
-
-
-constexpr TraceConfig_StatsdLogging TraceConfig_StatsdLogging_MIN = TraceConfig_StatsdLogging::STATSD_LOGGING_UNSPECIFIED;
-constexpr TraceConfig_StatsdLogging TraceConfig_StatsdLogging_MAX = TraceConfig_StatsdLogging::STATSD_LOGGING_DISABLED;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* TraceConfig_StatsdLogging_Name(::perfetto::protos::pbzero::TraceConfig_StatsdLogging value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::TraceConfig_StatsdLogging::STATSD_LOGGING_UNSPECIFIED:
-    return "STATSD_LOGGING_UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::TraceConfig_StatsdLogging::STATSD_LOGGING_ENABLED:
-    return "STATSD_LOGGING_ENABLED";
-
-  case ::perfetto::protos::pbzero::TraceConfig_StatsdLogging::STATSD_LOGGING_DISABLED:
-    return "STATSD_LOGGING_DISABLED";
+void ConsumerEndpointImpl::Flush(uint32_t timeout_ms,
+                                 FlushCallback callback,
+                                 FlushFlags flush_flags) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  if (!tracing_session_id_) {
+    PERFETTO_LOG("Consumer called Flush() but tracing was not active");
+    return;
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
+  service_->Flush(tracing_session_id_, timeout_ms, callback, flush_flags);
 }
 
-namespace perfetto_pbzero_enum_TraceConfig_TriggerConfig {
-enum TriggerMode : int32_t {
-  UNSPECIFIED = 0,
-  START_TRACING = 1,
-  STOP_TRACING = 2,
-};
-} // namespace perfetto_pbzero_enum_TraceConfig_TriggerConfig
-using TraceConfig_TriggerConfig_TriggerMode = perfetto_pbzero_enum_TraceConfig_TriggerConfig::TriggerMode;
-
+void ConsumerEndpointImpl::Detach(const std::string& key) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  bool success = service_->DetachConsumer(this, key);
+  auto weak_this = weak_ptr_factory_.GetWeakPtr();
+  task_runner_->PostTask([weak_this = std::move(weak_this), success] {
+    if (weak_this)
+      weak_this->consumer_->OnDetach(success);
+  });
+}
 
-constexpr TraceConfig_TriggerConfig_TriggerMode TraceConfig_TriggerConfig_TriggerMode_MIN = TraceConfig_TriggerConfig_TriggerMode::UNSPECIFIED;
-constexpr TraceConfig_TriggerConfig_TriggerMode TraceConfig_TriggerConfig_TriggerMode_MAX = TraceConfig_TriggerConfig_TriggerMode::STOP_TRACING;
+void ConsumerEndpointImpl::Attach(const std::string& key) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  bool success = service_->AttachConsumer(this, key);
+  task_runner_->PostTask([weak_this = weak_ptr_factory_.GetWeakPtr(), success] {
+    if (!weak_this)
+      return;
+    Consumer* consumer = weak_this->consumer_;
+    TracingSession* session =
+        weak_this->service_->GetTracingSession(weak_this->tracing_session_id_);
+    if (!session) {
+      consumer->OnAttach(false, TraceConfig());
+      return;
+    }
+    consumer->OnAttach(success, session->config);
+  });
+}
 
+void ConsumerEndpointImpl::GetTraceStats() {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  bool success = false;
+  TraceStats stats;
+  TracingSession* session = service_->GetTracingSession(tracing_session_id_);
+  if (session) {
+    success = true;
+    stats = service_->GetTraceStats(session);
+  }
+  auto weak_this = weak_ptr_factory_.GetWeakPtr();
+  task_runner_->PostTask(
+      [weak_this = std::move(weak_this), success, stats = std::move(stats)] {
+        if (weak_this)
+          weak_this->consumer_->OnTraceStats(success, stats);
+      });
+}
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* TraceConfig_TriggerConfig_TriggerMode_Name(::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode::UNSPECIFIED:
-    return "UNSPECIFIED";
+void ConsumerEndpointImpl::ObserveEvents(uint32_t events_mask) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  observable_events_mask_ = events_mask;
+  TracingSession* session = service_->GetTracingSession(tracing_session_id_);
+  if (!session)
+    return;
 
-  case ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode::START_TRACING:
-    return "START_TRACING";
+  if (observable_events_mask_ & ObservableEvents::TYPE_DATA_SOURCES_INSTANCES) {
+    // Issue initial states.
+    for (const auto& kv : session->data_source_instances) {
+      ProducerEndpointImpl* producer = service_->GetProducer(kv.first);
+      PERFETTO_DCHECK(producer);
+      OnDataSourceInstanceStateChange(*producer, kv.second);
+    }
+  }
 
-  case ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode::STOP_TRACING:
-    return "STOP_TRACING";
+  // If the ObserveEvents() call happens after data sources have acked already
+  // notify immediately.
+  if (observable_events_mask_ &
+      ObservableEvents::TYPE_ALL_DATA_SOURCES_STARTED) {
+    service_->MaybeNotifyAllDataSourcesStarted(session);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-namespace perfetto_pbzero_enum_TraceConfig_BufferConfig {
-enum FillPolicy : int32_t {
-  UNSPECIFIED = 0,
-  RING_BUFFER = 1,
-  DISCARD = 2,
-};
-} // namespace perfetto_pbzero_enum_TraceConfig_BufferConfig
-using TraceConfig_BufferConfig_FillPolicy = perfetto_pbzero_enum_TraceConfig_BufferConfig::FillPolicy;
+void ConsumerEndpointImpl::OnDataSourceInstanceStateChange(
+    const ProducerEndpointImpl& producer,
+    const DataSourceInstance& instance) {
+  if (!(observable_events_mask_ &
+        ObservableEvents::TYPE_DATA_SOURCES_INSTANCES)) {
+    return;
+  }
 
+  if (instance.state != DataSourceInstance::CONFIGURED &&
+      instance.state != DataSourceInstance::STARTED &&
+      instance.state != DataSourceInstance::STOPPED) {
+    return;
+  }
 
-constexpr TraceConfig_BufferConfig_FillPolicy TraceConfig_BufferConfig_FillPolicy_MIN = TraceConfig_BufferConfig_FillPolicy::UNSPECIFIED;
-constexpr TraceConfig_BufferConfig_FillPolicy TraceConfig_BufferConfig_FillPolicy_MAX = TraceConfig_BufferConfig_FillPolicy::DISCARD;
+  auto* observable_events = AddObservableEvents();
+  auto* change = observable_events->add_instance_state_changes();
+  change->set_producer_name(producer.name_);
+  change->set_data_source_name(instance.data_source_name);
+  if (instance.state == DataSourceInstance::STARTED) {
+    change->set_state(ObservableEvents::DATA_SOURCE_INSTANCE_STATE_STARTED);
+  } else {
+    change->set_state(ObservableEvents::DATA_SOURCE_INSTANCE_STATE_STOPPED);
+  }
+}
 
+void ConsumerEndpointImpl::OnAllDataSourcesStarted() {
+  if (!(observable_events_mask_ &
+        ObservableEvents::TYPE_ALL_DATA_SOURCES_STARTED)) {
+    return;
+  }
+  auto* observable_events = AddObservableEvents();
+  observable_events->set_all_data_sources_started(true);
+}
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* TraceConfig_BufferConfig_FillPolicy_Name(::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy::UNSPECIFIED:
-    return "UNSPECIFIED";
+void ConsumerEndpointImpl::NotifyCloneSnapshotTrigger(
+    const TriggerInfo& trigger) {
+  if (!(observable_events_mask_ & ObservableEvents::TYPE_CLONE_TRIGGER_HIT)) {
+    return;
+  }
+  auto* observable_events = AddObservableEvents();
+  auto* clone_trig = observable_events->mutable_clone_trigger_hit();
+  clone_trig->set_tracing_session_id(static_cast<int64_t>(tracing_session_id_));
+  clone_trig->set_trigger_name(trigger.trigger_name);
+  clone_trig->set_producer_name(trigger.producer_name);
+  clone_trig->set_producer_uid(static_cast<uint32_t>(trigger.producer_uid));
+  clone_trig->set_boot_time_ns(trigger.boot_time_ns);
+  clone_trig->set_trigger_delay_ms(trigger.trigger_delay_ms);
+}
 
-  case ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy::RING_BUFFER:
-    return "RING_BUFFER";
+ObservableEvents* ConsumerEndpointImpl::AddObservableEvents() {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  if (!observable_events_) {
+    observable_events_.reset(new ObservableEvents());
+    task_runner_->PostTask([weak_this = weak_ptr_factory_.GetWeakPtr()] {
+      if (!weak_this)
+        return;
 
-  case ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy::DISCARD:
-    return "DISCARD";
+      // Move into a temporary to allow reentrancy in OnObservableEvents.
+      auto observable_events = std::move(weak_this->observable_events_);
+      weak_this->consumer_->OnObservableEvents(*observable_events);
+    });
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
+  return observable_events_.get();
 }
 
-class TraceConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/36, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  TraceConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_buffers() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> buffers() const { return GetRepeated<::protozero::ConstBytes>(1); }
-  bool has_data_sources() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> data_sources() const { return GetRepeated<::protozero::ConstBytes>(2); }
-  bool has_builtin_data_sources() const { return at<20>().valid(); }
-  ::protozero::ConstBytes builtin_data_sources() const { return at<20>().as_bytes(); }
-  bool has_duration_ms() const { return at<3>().valid(); }
-  uint32_t duration_ms() const { return at<3>().as_uint32(); }
-  bool has_prefer_suspend_clock_for_duration() const { return at<36>().valid(); }
-  bool prefer_suspend_clock_for_duration() const { return at<36>().as_bool(); }
-  bool has_enable_extra_guardrails() const { return at<4>().valid(); }
-  bool enable_extra_guardrails() const { return at<4>().as_bool(); }
-  bool has_lockdown_mode() const { return at<5>().valid(); }
-  int32_t lockdown_mode() const { return at<5>().as_int32(); }
-  bool has_producers() const { return at<6>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> producers() const { return GetRepeated<::protozero::ConstBytes>(6); }
-  bool has_statsd_metadata() const { return at<7>().valid(); }
-  ::protozero::ConstBytes statsd_metadata() const { return at<7>().as_bytes(); }
-  bool has_write_into_file() const { return at<8>().valid(); }
-  bool write_into_file() const { return at<8>().as_bool(); }
-  bool has_output_path() const { return at<29>().valid(); }
-  ::protozero::ConstChars output_path() const { return at<29>().as_string(); }
-  bool has_file_write_period_ms() const { return at<9>().valid(); }
-  uint32_t file_write_period_ms() const { return at<9>().as_uint32(); }
-  bool has_max_file_size_bytes() const { return at<10>().valid(); }
-  uint64_t max_file_size_bytes() const { return at<10>().as_uint64(); }
-  bool has_guardrail_overrides() const { return at<11>().valid(); }
-  ::protozero::ConstBytes guardrail_overrides() const { return at<11>().as_bytes(); }
-  bool has_deferred_start() const { return at<12>().valid(); }
-  bool deferred_start() const { return at<12>().as_bool(); }
-  bool has_flush_period_ms() const { return at<13>().valid(); }
-  uint32_t flush_period_ms() const { return at<13>().as_uint32(); }
-  bool has_flush_timeout_ms() const { return at<14>().valid(); }
-  uint32_t flush_timeout_ms() const { return at<14>().as_uint32(); }
-  bool has_data_source_stop_timeout_ms() const { return at<23>().valid(); }
-  uint32_t data_source_stop_timeout_ms() const { return at<23>().as_uint32(); }
-  bool has_notify_traceur() const { return at<16>().valid(); }
-  bool notify_traceur() const { return at<16>().as_bool(); }
-  bool has_bugreport_score() const { return at<30>().valid(); }
-  int32_t bugreport_score() const { return at<30>().as_int32(); }
-  bool has_trigger_config() const { return at<17>().valid(); }
-  ::protozero::ConstBytes trigger_config() const { return at<17>().as_bytes(); }
-  bool has_activate_triggers() const { return at<18>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> activate_triggers() const { return GetRepeated<::protozero::ConstChars>(18); }
-  bool has_incremental_state_config() const { return at<21>().valid(); }
-  ::protozero::ConstBytes incremental_state_config() const { return at<21>().as_bytes(); }
-  bool has_allow_user_build_tracing() const { return at<19>().valid(); }
-  bool allow_user_build_tracing() const { return at<19>().as_bool(); }
-  bool has_unique_session_name() const { return at<22>().valid(); }
-  ::protozero::ConstChars unique_session_name() const { return at<22>().as_string(); }
-  bool has_compression_type() const { return at<24>().valid(); }
-  int32_t compression_type() const { return at<24>().as_int32(); }
-  bool has_incident_report_config() const { return at<25>().valid(); }
-  ::protozero::ConstBytes incident_report_config() const { return at<25>().as_bytes(); }
-  bool has_statsd_logging() const { return at<31>().valid(); }
-  int32_t statsd_logging() const { return at<31>().as_int32(); }
-  bool has_trace_uuid_msb() const { return at<27>().valid(); }
-  int64_t trace_uuid_msb() const { return at<27>().as_int64(); }
-  bool has_trace_uuid_lsb() const { return at<28>().valid(); }
-  int64_t trace_uuid_lsb() const { return at<28>().as_int64(); }
-  bool has_trace_filter() const { return at<33>().valid(); }
-  ::protozero::ConstBytes trace_filter() const { return at<33>().as_bytes(); }
-  bool has_android_report_config() const { return at<34>().valid(); }
-  ::protozero::ConstBytes android_report_config() const { return at<34>().as_bytes(); }
-  bool has_cmd_trace_start_delay() const { return at<35>().valid(); }
-  ::protozero::ConstBytes cmd_trace_start_delay() const { return at<35>().as_bytes(); }
-};
+void ConsumerEndpointImpl::QueryServiceState(
+    QueryServiceStateArgs args,
+    QueryServiceStateCallback callback) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  TracingServiceState svc_state;
 
-class TraceConfig : public ::protozero::Message {
- public:
-  using Decoder = TraceConfig_Decoder;
-  enum : int32_t {
-    kBuffersFieldNumber = 1,
-    kDataSourcesFieldNumber = 2,
-    kBuiltinDataSourcesFieldNumber = 20,
-    kDurationMsFieldNumber = 3,
-    kPreferSuspendClockForDurationFieldNumber = 36,
-    kEnableExtraGuardrailsFieldNumber = 4,
-    kLockdownModeFieldNumber = 5,
-    kProducersFieldNumber = 6,
-    kStatsdMetadataFieldNumber = 7,
-    kWriteIntoFileFieldNumber = 8,
-    kOutputPathFieldNumber = 29,
-    kFileWritePeriodMsFieldNumber = 9,
-    kMaxFileSizeBytesFieldNumber = 10,
-    kGuardrailOverridesFieldNumber = 11,
-    kDeferredStartFieldNumber = 12,
-    kFlushPeriodMsFieldNumber = 13,
-    kFlushTimeoutMsFieldNumber = 14,
-    kDataSourceStopTimeoutMsFieldNumber = 23,
-    kNotifyTraceurFieldNumber = 16,
-    kBugreportScoreFieldNumber = 30,
-    kTriggerConfigFieldNumber = 17,
-    kActivateTriggersFieldNumber = 18,
-    kIncrementalStateConfigFieldNumber = 21,
-    kAllowUserBuildTracingFieldNumber = 19,
-    kUniqueSessionNameFieldNumber = 22,
-    kCompressionTypeFieldNumber = 24,
-    kIncidentReportConfigFieldNumber = 25,
-    kStatsdLoggingFieldNumber = 31,
-    kTraceUuidMsbFieldNumber = 27,
-    kTraceUuidLsbFieldNumber = 28,
-    kTraceFilterFieldNumber = 33,
-    kAndroidReportConfigFieldNumber = 34,
-    kCmdTraceStartDelayFieldNumber = 35,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig"; }
-
-  using BufferConfig = ::perfetto::protos::pbzero::TraceConfig_BufferConfig;
-  using DataSource = ::perfetto::protos::pbzero::TraceConfig_DataSource;
-  using BuiltinDataSource = ::perfetto::protos::pbzero::TraceConfig_BuiltinDataSource;
-  using ProducerConfig = ::perfetto::protos::pbzero::TraceConfig_ProducerConfig;
-  using StatsdMetadata = ::perfetto::protos::pbzero::TraceConfig_StatsdMetadata;
-  using GuardrailOverrides = ::perfetto::protos::pbzero::TraceConfig_GuardrailOverrides;
-  using TriggerConfig = ::perfetto::protos::pbzero::TraceConfig_TriggerConfig;
-  using IncrementalStateConfig = ::perfetto::protos::pbzero::TraceConfig_IncrementalStateConfig;
-  using IncidentReportConfig = ::perfetto::protos::pbzero::TraceConfig_IncidentReportConfig;
-  using TraceFilter = ::perfetto::protos::pbzero::TraceConfig_TraceFilter;
-  using AndroidReportConfig = ::perfetto::protos::pbzero::TraceConfig_AndroidReportConfig;
-  using CmdTraceStartDelay = ::perfetto::protos::pbzero::TraceConfig_CmdTraceStartDelay;
-
-  using LockdownModeOperation = ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation;
-  static inline const char* LockdownModeOperation_Name(LockdownModeOperation value) {
-    return ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation_Name(value);
-  }
-
-  using CompressionType = ::perfetto::protos::pbzero::TraceConfig_CompressionType;
-  static inline const char* CompressionType_Name(CompressionType value) {
-    return ::perfetto::protos::pbzero::TraceConfig_CompressionType_Name(value);
-  }
-
-  using StatsdLogging = ::perfetto::protos::pbzero::TraceConfig_StatsdLogging;
-  static inline const char* StatsdLogging_Name(StatsdLogging value) {
-    return ::perfetto::protos::pbzero::TraceConfig_StatsdLogging_Name(value);
-  }
-  static const LockdownModeOperation LOCKDOWN_UNCHANGED = LockdownModeOperation::LOCKDOWN_UNCHANGED;
-  static const LockdownModeOperation LOCKDOWN_CLEAR = LockdownModeOperation::LOCKDOWN_CLEAR;
-  static const LockdownModeOperation LOCKDOWN_SET = LockdownModeOperation::LOCKDOWN_SET;
-  static const CompressionType COMPRESSION_TYPE_UNSPECIFIED = CompressionType::COMPRESSION_TYPE_UNSPECIFIED;
-  static const CompressionType COMPRESSION_TYPE_DEFLATE = CompressionType::COMPRESSION_TYPE_DEFLATE;
-  static const StatsdLogging STATSD_LOGGING_UNSPECIFIED = StatsdLogging::STATSD_LOGGING_UNSPECIFIED;
-  static const StatsdLogging STATSD_LOGGING_ENABLED = StatsdLogging::STATSD_LOGGING_ENABLED;
-  static const StatsdLogging STATSD_LOGGING_DISABLED = StatsdLogging::STATSD_LOGGING_DISABLED;
-
-  using FieldMetadata_Buffers =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_BufferConfig,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Buffers kBuffers() { return {}; }
-  template <typename T = TraceConfig_BufferConfig> T* add_buffers() {
-    return BeginNestedMessage<T>(1);
-  }
-
-
-  using FieldMetadata_DataSources =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_DataSource,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DataSources kDataSources() { return {}; }
-  template <typename T = TraceConfig_DataSource> T* add_data_sources() {
-    return BeginNestedMessage<T>(2);
-  }
-
-
-  using FieldMetadata_BuiltinDataSources =
-    ::protozero::proto_utils::FieldMetadata<
-      20,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_BuiltinDataSource,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BuiltinDataSources kBuiltinDataSources() { return {}; }
-  template <typename T = TraceConfig_BuiltinDataSource> T* set_builtin_data_sources() {
-    return BeginNestedMessage<T>(20);
-  }
-
-
-  using FieldMetadata_DurationMs =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DurationMs kDurationMs() { return {}; }
-  void set_duration_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DurationMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_PreferSuspendClockForDuration =
-    ::protozero::proto_utils::FieldMetadata<
-      36,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PreferSuspendClockForDuration kPreferSuspendClockForDuration() { return {}; }
-  void set_prefer_suspend_clock_for_duration(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_PreferSuspendClockForDuration::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_EnableExtraGuardrails =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EnableExtraGuardrails kEnableExtraGuardrails() { return {}; }
-  void set_enable_extra_guardrails(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_EnableExtraGuardrails::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_LockdownMode =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LockdownMode kLockdownMode() { return {}; }
-  void set_lockdown_mode(::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation value) {
-    static constexpr uint32_t field_id = FieldMetadata_LockdownMode::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Producers =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_ProducerConfig,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Producers kProducers() { return {}; }
-  template <typename T = TraceConfig_ProducerConfig> T* add_producers() {
-    return BeginNestedMessage<T>(6);
-  }
-
-
-  using FieldMetadata_StatsdMetadata =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_StatsdMetadata,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StatsdMetadata kStatsdMetadata() { return {}; }
-  template <typename T = TraceConfig_StatsdMetadata> T* set_statsd_metadata() {
-    return BeginNestedMessage<T>(7);
-  }
-
-
-  using FieldMetadata_WriteIntoFile =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WriteIntoFile kWriteIntoFile() { return {}; }
-  void set_write_into_file(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_WriteIntoFile::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_OutputPath =
-    ::protozero::proto_utils::FieldMetadata<
-      29,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OutputPath kOutputPath() { return {}; }
-  void set_output_path(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_OutputPath::kFieldId, data, size);
-  }
-  void set_output_path(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_OutputPath::kFieldId, chars.data, chars.size);
-  }
-  void set_output_path(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_OutputPath::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_FileWritePeriodMs =
-    ::protozero::proto_utils::FieldMetadata<
-      9,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FileWritePeriodMs kFileWritePeriodMs() { return {}; }
-  void set_file_write_period_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FileWritePeriodMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_MaxFileSizeBytes =
-    ::protozero::proto_utils::FieldMetadata<
-      10,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaxFileSizeBytes kMaxFileSizeBytes() { return {}; }
-  void set_max_file_size_bytes(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MaxFileSizeBytes::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_GuardrailOverrides =
-    ::protozero::proto_utils::FieldMetadata<
-      11,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_GuardrailOverrides,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GuardrailOverrides kGuardrailOverrides() { return {}; }
-  template <typename T = TraceConfig_GuardrailOverrides> T* set_guardrail_overrides() {
-    return BeginNestedMessage<T>(11);
-  }
-
-
-  using FieldMetadata_DeferredStart =
-    ::protozero::proto_utils::FieldMetadata<
-      12,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DeferredStart kDeferredStart() { return {}; }
-  void set_deferred_start(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DeferredStart::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_FlushPeriodMs =
-    ::protozero::proto_utils::FieldMetadata<
-      13,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FlushPeriodMs kFlushPeriodMs() { return {}; }
-  void set_flush_period_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FlushPeriodMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_FlushTimeoutMs =
-    ::protozero::proto_utils::FieldMetadata<
-      14,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FlushTimeoutMs kFlushTimeoutMs() { return {}; }
-  void set_flush_timeout_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FlushTimeoutMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_DataSourceStopTimeoutMs =
-    ::protozero::proto_utils::FieldMetadata<
-      23,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DataSourceStopTimeoutMs kDataSourceStopTimeoutMs() { return {}; }
-  void set_data_source_stop_timeout_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DataSourceStopTimeoutMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_NotifyTraceur =
-    ::protozero::proto_utils::FieldMetadata<
-      16,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NotifyTraceur kNotifyTraceur() { return {}; }
-  void set_notify_traceur(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_NotifyTraceur::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_BugreportScore =
-    ::protozero::proto_utils::FieldMetadata<
-      30,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BugreportScore kBugreportScore() { return {}; }
-  void set_bugreport_score(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BugreportScore::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_TriggerConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      17,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_TriggerConfig,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TriggerConfig kTriggerConfig() { return {}; }
-  template <typename T = TraceConfig_TriggerConfig> T* set_trigger_config() {
-    return BeginNestedMessage<T>(17);
-  }
-
-
-  using FieldMetadata_ActivateTriggers =
-    ::protozero::proto_utils::FieldMetadata<
-      18,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ActivateTriggers kActivateTriggers() { return {}; }
-  void add_activate_triggers(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ActivateTriggers::kFieldId, data, size);
-  }
-  void add_activate_triggers(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ActivateTriggers::kFieldId, chars.data, chars.size);
-  }
-  void add_activate_triggers(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ActivateTriggers::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_IncrementalStateConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      21,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_IncrementalStateConfig,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IncrementalStateConfig kIncrementalStateConfig() { return {}; }
-  template <typename T = TraceConfig_IncrementalStateConfig> T* set_incremental_state_config() {
-    return BeginNestedMessage<T>(21);
-  }
-
-
-  using FieldMetadata_AllowUserBuildTracing =
-    ::protozero::proto_utils::FieldMetadata<
-      19,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AllowUserBuildTracing kAllowUserBuildTracing() { return {}; }
-  void set_allow_user_build_tracing(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_AllowUserBuildTracing::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_UniqueSessionName =
-    ::protozero::proto_utils::FieldMetadata<
-      22,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UniqueSessionName kUniqueSessionName() { return {}; }
-  void set_unique_session_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_UniqueSessionName::kFieldId, data, size);
-  }
-  void set_unique_session_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_UniqueSessionName::kFieldId, chars.data, chars.size);
-  }
-  void set_unique_session_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_UniqueSessionName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_CompressionType =
-    ::protozero::proto_utils::FieldMetadata<
-      24,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::TraceConfig_CompressionType,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CompressionType kCompressionType() { return {}; }
-  void set_compression_type(::perfetto::protos::pbzero::TraceConfig_CompressionType value) {
-    static constexpr uint32_t field_id = FieldMetadata_CompressionType::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_IncidentReportConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      25,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_IncidentReportConfig,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IncidentReportConfig kIncidentReportConfig() { return {}; }
-  template <typename T = TraceConfig_IncidentReportConfig> T* set_incident_report_config() {
-    return BeginNestedMessage<T>(25);
-  }
-
-
-  using FieldMetadata_StatsdLogging =
-    ::protozero::proto_utils::FieldMetadata<
-      31,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::TraceConfig_StatsdLogging,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StatsdLogging kStatsdLogging() { return {}; }
-  void set_statsd_logging(::perfetto::protos::pbzero::TraceConfig_StatsdLogging value) {
-    static constexpr uint32_t field_id = FieldMetadata_StatsdLogging::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_TraceUuidMsb =
-    ::protozero::proto_utils::FieldMetadata<
-      27,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceUuidMsb kTraceUuidMsb() { return {}; }
-  void set_trace_uuid_msb(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TraceUuidMsb::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_TraceUuidLsb =
-    ::protozero::proto_utils::FieldMetadata<
-      28,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceUuidLsb kTraceUuidLsb() { return {}; }
-  void set_trace_uuid_lsb(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TraceUuidLsb::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_TraceFilter =
-    ::protozero::proto_utils::FieldMetadata<
-      33,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_TraceFilter,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceFilter kTraceFilter() { return {}; }
-  template <typename T = TraceConfig_TraceFilter> T* set_trace_filter() {
-    return BeginNestedMessage<T>(33);
-  }
-
-
-  using FieldMetadata_AndroidReportConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      34,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_AndroidReportConfig,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidReportConfig kAndroidReportConfig() { return {}; }
-  template <typename T = TraceConfig_AndroidReportConfig> T* set_android_report_config() {
-    return BeginNestedMessage<T>(34);
-  }
-
-
-  using FieldMetadata_CmdTraceStartDelay =
-    ::protozero::proto_utils::FieldMetadata<
-      35,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_CmdTraceStartDelay,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CmdTraceStartDelay kCmdTraceStartDelay() { return {}; }
-  template <typename T = TraceConfig_CmdTraceStartDelay> T* set_cmd_trace_start_delay() {
-    return BeginNestedMessage<T>(35);
-  }
+  const auto& sessions = service_->tracing_sessions_;
+  svc_state.set_tracing_service_version(base::GetVersionString());
+  svc_state.set_num_sessions(static_cast<int>(sessions.size()));
 
-};
+  int num_started = 0;
+  for (const auto& kv : sessions)
+    num_started += kv.second.state == TracingSession::State::STARTED ? 1 : 0;
+  svc_state.set_num_sessions_started(num_started);
 
-class TraceConfig_CmdTraceStartDelay_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TraceConfig_CmdTraceStartDelay_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_CmdTraceStartDelay_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_CmdTraceStartDelay_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_min_delay_ms() const { return at<1>().valid(); }
-  uint32_t min_delay_ms() const { return at<1>().as_uint32(); }
-  bool has_max_delay_ms() const { return at<2>().valid(); }
-  uint32_t max_delay_ms() const { return at<2>().as_uint32(); }
-};
+  for (const auto& kv : service_->producers_) {
+    if (args.sessions_only)
+      break;
+    auto* producer = svc_state.add_producers();
+    producer->set_id(static_cast<int>(kv.first));
+    producer->set_name(kv.second->name_);
+    producer->set_sdk_version(kv.second->sdk_version_);
+    producer->set_uid(static_cast<int32_t>(kv.second->uid()));
+    producer->set_pid(static_cast<int32_t>(kv.second->pid()));
+    producer->set_frozen(kv.second->IsAndroidProcessFrozen());
+  }
 
-class TraceConfig_CmdTraceStartDelay : public ::protozero::Message {
- public:
-  using Decoder = TraceConfig_CmdTraceStartDelay_Decoder;
-  enum : int32_t {
-    kMinDelayMsFieldNumber = 1,
-    kMaxDelayMsFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.CmdTraceStartDelay"; }
-
-
-  using FieldMetadata_MinDelayMs =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig_CmdTraceStartDelay>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MinDelayMs kMinDelayMs() { return {}; }
-  void set_min_delay_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MinDelayMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_MaxDelayMs =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig_CmdTraceStartDelay>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaxDelayMs kMaxDelayMs() { return {}; }
-  void set_max_delay_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MaxDelayMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
+  for (const auto& kv : service_->data_sources_) {
+    if (args.sessions_only)
+      break;
+    const auto& registered_data_source = kv.second;
+    auto* data_source = svc_state.add_data_sources();
+    *data_source->mutable_ds_descriptor() = registered_data_source.descriptor;
+    data_source->set_producer_id(
+        static_cast<int>(registered_data_source.producer_id));
   }
-};
 
-class TraceConfig_AndroidReportConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TraceConfig_AndroidReportConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_AndroidReportConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_AndroidReportConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_reporter_service_package() const { return at<1>().valid(); }
-  ::protozero::ConstChars reporter_service_package() const { return at<1>().as_string(); }
-  bool has_reporter_service_class() const { return at<2>().valid(); }
-  ::protozero::ConstChars reporter_service_class() const { return at<2>().as_string(); }
-  bool has_skip_report() const { return at<3>().valid(); }
-  bool skip_report() const { return at<3>().as_bool(); }
-  bool has_use_pipe_in_framework_for_testing() const { return at<4>().valid(); }
-  bool use_pipe_in_framework_for_testing() const { return at<4>().as_bool(); }
-};
+  svc_state.set_supports_tracing_sessions(true);
+  for (const auto& kv : service_->tracing_sessions_) {
+    const TracingSession& s = kv.second;
+    if (!s.IsCloneAllowed(uid_))
+      continue;
+    auto* session = svc_state.add_tracing_sessions();
+    session->set_id(s.id);
+    session->set_consumer_uid(static_cast<int>(s.consumer_uid));
+    session->set_duration_ms(s.config.duration_ms());
+    session->set_num_data_sources(
+        static_cast<uint32_t>(s.data_source_instances.size()));
+    session->set_unique_session_name(s.config.unique_session_name());
+    if (s.config.has_bugreport_score())
+      session->set_bugreport_score(s.config.bugreport_score());
+    if (s.config.has_bugreport_filename())
+      session->set_bugreport_filename(s.config.bugreport_filename());
+    for (const auto& snap_kv : s.initial_clock_snapshot) {
+      if (snap_kv.clock_id == protos::pbzero::BUILTIN_CLOCK_REALTIME)
+        session->set_start_realtime_ns(static_cast<int64_t>(snap_kv.timestamp));
+    }
+    for (const auto& buf : s.config.buffers())
+      session->add_buffer_size_kb(buf.size_kb());
 
-class TraceConfig_AndroidReportConfig : public ::protozero::Message {
- public:
-  using Decoder = TraceConfig_AndroidReportConfig_Decoder;
-  enum : int32_t {
-    kReporterServicePackageFieldNumber = 1,
-    kReporterServiceClassFieldNumber = 2,
-    kSkipReportFieldNumber = 3,
-    kUsePipeInFrameworkForTestingFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.AndroidReportConfig"; }
-
-
-  using FieldMetadata_ReporterServicePackage =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TraceConfig_AndroidReportConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReporterServicePackage kReporterServicePackage() { return {}; }
-  void set_reporter_service_package(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ReporterServicePackage::kFieldId, data, size);
-  }
-  void set_reporter_service_package(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ReporterServicePackage::kFieldId, chars.data, chars.size);
-  }
-  void set_reporter_service_package(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReporterServicePackage::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ReporterServiceClass =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TraceConfig_AndroidReportConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReporterServiceClass kReporterServiceClass() { return {}; }
-  void set_reporter_service_class(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ReporterServiceClass::kFieldId, data, size);
-  }
-  void set_reporter_service_class(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ReporterServiceClass::kFieldId, chars.data, chars.size);
-  }
-  void set_reporter_service_class(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReporterServiceClass::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_SkipReport =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TraceConfig_AndroidReportConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SkipReport kSkipReport() { return {}; }
-  void set_skip_report(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_SkipReport::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_UsePipeInFrameworkForTesting =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TraceConfig_AndroidReportConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UsePipeInFrameworkForTesting kUsePipeInFrameworkForTesting() { return {}; }
-  void set_use_pipe_in_framework_for_testing(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_UsePipeInFrameworkForTesting::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
+    switch (s.state) {
+      case TracingSession::State::DISABLED:
+        session->set_state("DISABLED");
+        break;
+      case TracingSession::State::CONFIGURED:
+        session->set_state("CONFIGURED");
+        break;
+      case TracingSession::State::STARTED:
+        session->set_is_started(true);
+        session->set_state("STARTED");
+        break;
+      case TracingSession::State::DISABLING_WAITING_STOP_ACKS:
+        session->set_state("STOP_WAIT");
+        break;
+      case TracingSession::State::CLONED_READ_ONLY:
+        session->set_state("CLONED_READ_ONLY");
+        break;
+    }
   }
-};
+  callback(/*success=*/true, svc_state);
+}
 
-class TraceConfig_TraceFilter_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TraceConfig_TraceFilter_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_TraceFilter_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_TraceFilter_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_bytecode() const { return at<1>().valid(); }
-  ::protozero::ConstBytes bytecode() const { return at<1>().as_bytes(); }
-};
+void ConsumerEndpointImpl::QueryCapabilities(
+    QueryCapabilitiesCallback callback) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  TracingServiceCapabilities caps;
+  caps.set_has_query_capabilities(true);
+  caps.set_has_trace_config_output_path(true);
+  caps.set_has_clone_session(true);
+  caps.add_observable_events(ObservableEvents::TYPE_DATA_SOURCES_INSTANCES);
+  caps.add_observable_events(ObservableEvents::TYPE_ALL_DATA_SOURCES_STARTED);
+  caps.add_observable_events(ObservableEvents::TYPE_CLONE_TRIGGER_HIT);
+  static_assert(
+      ObservableEvents::Type_MAX == ObservableEvents::TYPE_CLONE_TRIGGER_HIT,
+      "");
+  callback(caps);
+}
 
-class TraceConfig_TraceFilter : public ::protozero::Message {
- public:
-  using Decoder = TraceConfig_TraceFilter_Decoder;
-  enum : int32_t {
-    kBytecodeFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.TraceFilter"; }
-
-
-  using FieldMetadata_Bytecode =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBytes,
-      std::string,
-      TraceConfig_TraceFilter>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Bytecode kBytecode() { return {}; }
-  void set_bytecode(const uint8_t* data, size_t size) {
-    AppendBytes(FieldMetadata_Bytecode::kFieldId, data, size);
-  }
-  void set_bytecode(::protozero::ConstBytes bytes) {
-    AppendBytes(FieldMetadata_Bytecode::kFieldId, bytes.data, bytes.size);
-  }
-  void set_bytecode(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Bytecode::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBytes>
-        ::Append(*this, field_id, value);
-  }
-};
+void ConsumerEndpointImpl::SaveTraceForBugreport(
+    SaveTraceForBugreportCallback consumer_callback) {
+  consumer_callback(false,
+                    "SaveTraceForBugreport is deprecated. Use "
+                    "CloneSession(kBugreportSessionId) instead.");
+}
 
-class TraceConfig_IncidentReportConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TraceConfig_IncidentReportConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_IncidentReportConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_IncidentReportConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_destination_package() const { return at<1>().valid(); }
-  ::protozero::ConstChars destination_package() const { return at<1>().as_string(); }
-  bool has_destination_class() const { return at<2>().valid(); }
-  ::protozero::ConstChars destination_class() const { return at<2>().as_string(); }
-  bool has_privacy_level() const { return at<3>().valid(); }
-  int32_t privacy_level() const { return at<3>().as_int32(); }
-  bool has_skip_incidentd() const { return at<5>().valid(); }
-  bool skip_incidentd() const { return at<5>().as_bool(); }
-  bool has_skip_dropbox() const { return at<4>().valid(); }
-  bool skip_dropbox() const { return at<4>().as_bool(); }
-};
+void ConsumerEndpointImpl::CloneSession(CloneSessionArgs args) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  // FlushAndCloneSession will call OnSessionCloned after the async flush.
+  base::Status result = service_->FlushAndCloneSession(this, std::move(args));
 
-class TraceConfig_IncidentReportConfig : public ::protozero::Message {
- public:
-  using Decoder = TraceConfig_IncidentReportConfig_Decoder;
-  enum : int32_t {
-    kDestinationPackageFieldNumber = 1,
-    kDestinationClassFieldNumber = 2,
-    kPrivacyLevelFieldNumber = 3,
-    kSkipIncidentdFieldNumber = 5,
-    kSkipDropboxFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.IncidentReportConfig"; }
-
-
-  using FieldMetadata_DestinationPackage =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TraceConfig_IncidentReportConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DestinationPackage kDestinationPackage() { return {}; }
-  void set_destination_package(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_DestinationPackage::kFieldId, data, size);
-  }
-  void set_destination_package(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_DestinationPackage::kFieldId, chars.data, chars.size);
-  }
-  void set_destination_package(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_DestinationPackage::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_DestinationClass =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TraceConfig_IncidentReportConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DestinationClass kDestinationClass() { return {}; }
-  void set_destination_class(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_DestinationClass::kFieldId, data, size);
-  }
-  void set_destination_class(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_DestinationClass::kFieldId, chars.data, chars.size);
-  }
-  void set_destination_class(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_DestinationClass::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_PrivacyLevel =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TraceConfig_IncidentReportConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PrivacyLevel kPrivacyLevel() { return {}; }
-  void set_privacy_level(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PrivacyLevel::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_SkipIncidentd =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TraceConfig_IncidentReportConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SkipIncidentd kSkipIncidentd() { return {}; }
-  void set_skip_incidentd(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_SkipIncidentd::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_SkipDropbox =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TraceConfig_IncidentReportConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SkipDropbox kSkipDropbox() { return {}; }
-  void set_skip_dropbox(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_SkipDropbox::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
+  if (!result.ok()) {
+    consumer_->OnSessionCloned({false, result.message(), {}, false});
   }
-};
+}
 
-class TraceConfig_IncrementalStateConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TraceConfig_IncrementalStateConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_IncrementalStateConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_IncrementalStateConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_clear_period_ms() const { return at<1>().valid(); }
-  uint32_t clear_period_ms() const { return at<1>().as_uint32(); }
-};
+////////////////////////////////////////////////////////////////////////////////
+// ProducerEndpointImpl implementation
+////////////////////////////////////////////////////////////////////////////////
 
-class TraceConfig_IncrementalStateConfig : public ::protozero::Message {
- public:
-  using Decoder = TraceConfig_IncrementalStateConfig_Decoder;
-  enum : int32_t {
-    kClearPeriodMsFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.IncrementalStateConfig"; }
-
-
-  using FieldMetadata_ClearPeriodMs =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig_IncrementalStateConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClearPeriodMs kClearPeriodMs() { return {}; }
-  void set_clear_period_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ClearPeriodMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-};
+ProducerEndpointImpl::ProducerEndpointImpl(
+    ProducerID id,
+    const ClientIdentity& client_identity,
+    TracingServiceImpl* service,
+    base::TaskRunner* task_runner,
+    Producer* producer,
+    const std::string& producer_name,
+    const std::string& machine_name,
+    const std::string& sdk_version,
+    bool in_process,
+    bool smb_scraping_enabled)
+    : id_(id),
+      client_identity_(client_identity),
+      service_(service),
+      producer_(producer),
+      name_(producer_name),
+      machine_name_(machine_name),
+      sdk_version_(sdk_version),
+      in_process_(in_process),
+      smb_scraping_enabled_(smb_scraping_enabled),
+      weak_runner_(task_runner) {}
 
-class TraceConfig_TriggerConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  TraceConfig_TriggerConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_TriggerConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_TriggerConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_trigger_mode() const { return at<1>().valid(); }
-  int32_t trigger_mode() const { return at<1>().as_int32(); }
-  bool has_triggers() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> triggers() const { return GetRepeated<::protozero::ConstBytes>(2); }
-  bool has_trigger_timeout_ms() const { return at<3>().valid(); }
-  uint32_t trigger_timeout_ms() const { return at<3>().as_uint32(); }
-};
+ProducerEndpointImpl::~ProducerEndpointImpl() {
+  service_->DisconnectProducer(id_);
+  producer_->OnDisconnect();
+}
 
-class TraceConfig_TriggerConfig : public ::protozero::Message {
- public:
-  using Decoder = TraceConfig_TriggerConfig_Decoder;
-  enum : int32_t {
-    kTriggerModeFieldNumber = 1,
-    kTriggersFieldNumber = 2,
-    kTriggerTimeoutMsFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.TriggerConfig"; }
-
-  using Trigger = ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_Trigger;
-
-  using TriggerMode = ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode;
-  static inline const char* TriggerMode_Name(TriggerMode value) {
-    return ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode_Name(value);
-  }
-  static const TriggerMode UNSPECIFIED = TriggerMode::UNSPECIFIED;
-  static const TriggerMode START_TRACING = TriggerMode::START_TRACING;
-  static const TriggerMode STOP_TRACING = TriggerMode::STOP_TRACING;
-
-  using FieldMetadata_TriggerMode =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode,
-      TraceConfig_TriggerConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TriggerMode kTriggerMode() { return {}; }
-  void set_trigger_mode(::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode value) {
-    static constexpr uint32_t field_id = FieldMetadata_TriggerMode::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Triggers =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_TriggerConfig_Trigger,
-      TraceConfig_TriggerConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Triggers kTriggers() { return {}; }
-  template <typename T = TraceConfig_TriggerConfig_Trigger> T* add_triggers() {
-    return BeginNestedMessage<T>(2);
-  }
-
-
-  using FieldMetadata_TriggerTimeoutMs =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig_TriggerConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TriggerTimeoutMs kTriggerTimeoutMs() { return {}; }
-  void set_trigger_timeout_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TriggerTimeoutMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-};
+void ProducerEndpointImpl::Disconnect() {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  // Disconnection is only supported via destroying the ProducerEndpoint.
+  PERFETTO_FATAL("Not supported");
+}
 
-class TraceConfig_TriggerConfig_Trigger_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TraceConfig_TriggerConfig_Trigger_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_TriggerConfig_Trigger_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_TriggerConfig_Trigger_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_producer_name_regex() const { return at<2>().valid(); }
-  ::protozero::ConstChars producer_name_regex() const { return at<2>().as_string(); }
-  bool has_stop_delay_ms() const { return at<3>().valid(); }
-  uint32_t stop_delay_ms() const { return at<3>().as_uint32(); }
-  bool has_max_per_24_h() const { return at<4>().valid(); }
-  uint32_t max_per_24_h() const { return at<4>().as_uint32(); }
-  bool has_skip_probability() const { return at<5>().valid(); }
-  double skip_probability() const { return at<5>().as_double(); }
-};
+void ProducerEndpointImpl::RegisterDataSource(
+    const DataSourceDescriptor& desc) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  service_->RegisterDataSource(id_, desc);
+}
 
-class TraceConfig_TriggerConfig_Trigger : public ::protozero::Message {
- public:
-  using Decoder = TraceConfig_TriggerConfig_Trigger_Decoder;
-  enum : int32_t {
-    kNameFieldNumber = 1,
-    kProducerNameRegexFieldNumber = 2,
-    kStopDelayMsFieldNumber = 3,
-    kMaxPer24HFieldNumber = 4,
-    kSkipProbabilityFieldNumber = 5,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.TriggerConfig.Trigger"; }
-
-
-  using FieldMetadata_Name =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TraceConfig_TriggerConfig_Trigger>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ProducerNameRegex =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TraceConfig_TriggerConfig_Trigger>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProducerNameRegex kProducerNameRegex() { return {}; }
-  void set_producer_name_regex(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ProducerNameRegex::kFieldId, data, size);
-  }
-  void set_producer_name_regex(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ProducerNameRegex::kFieldId, chars.data, chars.size);
-  }
-  void set_producer_name_regex(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProducerNameRegex::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_StopDelayMs =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig_TriggerConfig_Trigger>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StopDelayMs kStopDelayMs() { return {}; }
-  void set_stop_delay_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StopDelayMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_MaxPer24H =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig_TriggerConfig_Trigger>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaxPer24H kMaxPer24H() { return {}; }
-  void set_max_per_24_h(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MaxPer24H::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_SkipProbability =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kDouble,
-      double,
-      TraceConfig_TriggerConfig_Trigger>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SkipProbability kSkipProbability() { return {}; }
-  void set_skip_probability(double value) {
-    static constexpr uint32_t field_id = FieldMetadata_SkipProbability::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kDouble>
-        ::Append(*this, field_id, value);
-  }
-};
+void ProducerEndpointImpl::UpdateDataSource(const DataSourceDescriptor& desc) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  service_->UpdateDataSource(id_, desc);
+}
 
-class TraceConfig_GuardrailOverrides_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TraceConfig_GuardrailOverrides_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_GuardrailOverrides_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_GuardrailOverrides_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_max_upload_per_day_bytes() const { return at<1>().valid(); }
-  uint64_t max_upload_per_day_bytes() const { return at<1>().as_uint64(); }
-  bool has_max_tracing_buffer_size_kb() const { return at<2>().valid(); }
-  uint32_t max_tracing_buffer_size_kb() const { return at<2>().as_uint32(); }
-};
+void ProducerEndpointImpl::UnregisterDataSource(const std::string& name) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  service_->UnregisterDataSource(id_, name);
+}
 
-class TraceConfig_GuardrailOverrides : public ::protozero::Message {
- public:
-  using Decoder = TraceConfig_GuardrailOverrides_Decoder;
-  enum : int32_t {
-    kMaxUploadPerDayBytesFieldNumber = 1,
-    kMaxTracingBufferSizeKbFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.GuardrailOverrides"; }
-
-
-  using FieldMetadata_MaxUploadPerDayBytes =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceConfig_GuardrailOverrides>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaxUploadPerDayBytes kMaxUploadPerDayBytes() { return {}; }
-  void set_max_upload_per_day_bytes(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MaxUploadPerDayBytes::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_MaxTracingBufferSizeKb =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig_GuardrailOverrides>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaxTracingBufferSizeKb kMaxTracingBufferSizeKb() { return {}; }
-  void set_max_tracing_buffer_size_kb(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MaxTracingBufferSizeKb::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-};
+void ProducerEndpointImpl::RegisterTraceWriter(uint32_t writer_id,
+                                               uint32_t target_buffer) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  writers_[static_cast<WriterID>(writer_id)] =
+      static_cast<BufferID>(target_buffer);
+}
 
-class TraceConfig_StatsdMetadata_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TraceConfig_StatsdMetadata_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_StatsdMetadata_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_StatsdMetadata_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_triggering_alert_id() const { return at<1>().valid(); }
-  int64_t triggering_alert_id() const { return at<1>().as_int64(); }
-  bool has_triggering_config_uid() const { return at<2>().valid(); }
-  int32_t triggering_config_uid() const { return at<2>().as_int32(); }
-  bool has_triggering_config_id() const { return at<3>().valid(); }
-  int64_t triggering_config_id() const { return at<3>().as_int64(); }
-  bool has_triggering_subscription_id() const { return at<4>().valid(); }
-  int64_t triggering_subscription_id() const { return at<4>().as_int64(); }
-};
+void ProducerEndpointImpl::UnregisterTraceWriter(uint32_t writer_id) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  writers_.erase(static_cast<WriterID>(writer_id));
+}
 
-class TraceConfig_StatsdMetadata : public ::protozero::Message {
- public:
-  using Decoder = TraceConfig_StatsdMetadata_Decoder;
-  enum : int32_t {
-    kTriggeringAlertIdFieldNumber = 1,
-    kTriggeringConfigUidFieldNumber = 2,
-    kTriggeringConfigIdFieldNumber = 3,
-    kTriggeringSubscriptionIdFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.StatsdMetadata"; }
-
-
-  using FieldMetadata_TriggeringAlertId =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TraceConfig_StatsdMetadata>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TriggeringAlertId kTriggeringAlertId() { return {}; }
-  void set_triggering_alert_id(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TriggeringAlertId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_TriggeringConfigUid =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TraceConfig_StatsdMetadata>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TriggeringConfigUid kTriggeringConfigUid() { return {}; }
-  void set_triggering_config_uid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TriggeringConfigUid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_TriggeringConfigId =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TraceConfig_StatsdMetadata>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TriggeringConfigId kTriggeringConfigId() { return {}; }
-  void set_triggering_config_id(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TriggeringConfigId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_TriggeringSubscriptionId =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TraceConfig_StatsdMetadata>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TriggeringSubscriptionId kTriggeringSubscriptionId() { return {}; }
-  void set_triggering_subscription_id(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TriggeringSubscriptionId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
-};
+void ProducerEndpointImpl::CommitData(const CommitDataRequest& req_untrusted,
+                                      CommitDataCallback callback) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
 
-class TraceConfig_ProducerConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TraceConfig_ProducerConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_ProducerConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_ProducerConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_producer_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars producer_name() const { return at<1>().as_string(); }
-  bool has_shm_size_kb() const { return at<2>().valid(); }
-  uint32_t shm_size_kb() const { return at<2>().as_uint32(); }
-  bool has_page_size_kb() const { return at<3>().valid(); }
-  uint32_t page_size_kb() const { return at<3>().as_uint32(); }
-};
+  if (metatrace::IsEnabled(metatrace::TAG_TRACE_SERVICE)) {
+    PERFETTO_METATRACE_COUNTER(TAG_TRACE_SERVICE, TRACE_SERVICE_COMMIT_DATA,
+                               EncodeCommitDataRequest(id_, req_untrusted));
+  }
 
-class TraceConfig_ProducerConfig : public ::protozero::Message {
- public:
-  using Decoder = TraceConfig_ProducerConfig_Decoder;
-  enum : int32_t {
-    kProducerNameFieldNumber = 1,
-    kShmSizeKbFieldNumber = 2,
-    kPageSizeKbFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.ProducerConfig"; }
-
-
-  using FieldMetadata_ProducerName =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TraceConfig_ProducerConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProducerName kProducerName() { return {}; }
-  void set_producer_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ProducerName::kFieldId, data, size);
-  }
-  void set_producer_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ProducerName::kFieldId, chars.data, chars.size);
-  }
-  void set_producer_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProducerName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ShmSizeKb =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig_ProducerConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ShmSizeKb kShmSizeKb() { return {}; }
-  void set_shm_size_kb(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ShmSizeKb::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_PageSizeKb =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig_ProducerConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PageSizeKb kPageSizeKb() { return {}; }
-  void set_page_size_kb(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PageSizeKb::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
+  if (!shared_memory_) {
+    PERFETTO_DLOG(
+        "Attempted to commit data before the shared memory was allocated.");
+    return;
   }
-};
+  PERFETTO_DCHECK(shmem_abi_.is_valid());
+  for (const auto& entry : req_untrusted.chunks_to_move()) {
+    const uint32_t page_idx = entry.page();
+    if (page_idx >= shmem_abi_.num_pages())
+      continue;  // A buggy or malicious producer.
 
-class TraceConfig_BuiltinDataSource_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TraceConfig_BuiltinDataSource_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_BuiltinDataSource_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_BuiltinDataSource_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_disable_clock_snapshotting() const { return at<1>().valid(); }
-  bool disable_clock_snapshotting() const { return at<1>().as_bool(); }
-  bool has_disable_trace_config() const { return at<2>().valid(); }
-  bool disable_trace_config() const { return at<2>().as_bool(); }
-  bool has_disable_system_info() const { return at<3>().valid(); }
-  bool disable_system_info() const { return at<3>().as_bool(); }
-  bool has_disable_service_events() const { return at<4>().valid(); }
-  bool disable_service_events() const { return at<4>().as_bool(); }
-  bool has_primary_trace_clock() const { return at<5>().valid(); }
-  int32_t primary_trace_clock() const { return at<5>().as_int32(); }
-  bool has_snapshot_interval_ms() const { return at<6>().valid(); }
-  uint32_t snapshot_interval_ms() const { return at<6>().as_uint32(); }
-  bool has_prefer_suspend_clock_for_snapshot() const { return at<7>().valid(); }
-  bool prefer_suspend_clock_for_snapshot() const { return at<7>().as_bool(); }
-};
+    SharedMemoryABI::Chunk chunk;
+    bool commit_data_over_ipc = entry.has_data();
+    bool chunk_complete = true;
+    if (PERFETTO_UNLIKELY(commit_data_over_ipc)) {
+      // Chunk data is passed over the wire. Create a chunk using the serialized
+      // protobuf message.
+      const std::string& data = entry.data();
+      if (data.size() > SharedMemoryABI::Chunk::kMaxSize) {
+        PERFETTO_DFATAL("IPC data commit too large: %zu", data.size());
+        continue;  // A malicious or buggy producer
+      }
+      // |data| is not altered, but we need to const_cast becasue Chunk data
+      // members are non-const.
+      chunk = SharedMemoryABI::MakeChunkFromSerializedData(
+          reinterpret_cast<uint8_t*>(const_cast<char*>(data.data())),
+          static_cast<uint16_t>(entry.data().size()),
+          static_cast<uint8_t>(entry.chunk()));
+      chunk_complete = !entry.chunk_incomplete();
+    } else
+      chunk = shmem_abi_.TryAcquireChunkForReading(page_idx, entry.chunk());
+    if (!chunk.is_valid()) {
+      PERFETTO_DLOG("Asked to move chunk %u:%u, but it's not complete",
+                    entry.page(), entry.chunk());
+      continue;
+    }
 
-class TraceConfig_BuiltinDataSource : public ::protozero::Message {
- public:
-  using Decoder = TraceConfig_BuiltinDataSource_Decoder;
-  enum : int32_t {
-    kDisableClockSnapshottingFieldNumber = 1,
-    kDisableTraceConfigFieldNumber = 2,
-    kDisableSystemInfoFieldNumber = 3,
-    kDisableServiceEventsFieldNumber = 4,
-    kPrimaryTraceClockFieldNumber = 5,
-    kSnapshotIntervalMsFieldNumber = 6,
-    kPreferSuspendClockForSnapshotFieldNumber = 7,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.BuiltinDataSource"; }
-
-
-  using FieldMetadata_DisableClockSnapshotting =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TraceConfig_BuiltinDataSource>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DisableClockSnapshotting kDisableClockSnapshotting() { return {}; }
-  void set_disable_clock_snapshotting(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DisableClockSnapshotting::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_DisableTraceConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TraceConfig_BuiltinDataSource>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DisableTraceConfig kDisableTraceConfig() { return {}; }
-  void set_disable_trace_config(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DisableTraceConfig::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_DisableSystemInfo =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TraceConfig_BuiltinDataSource>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DisableSystemInfo kDisableSystemInfo() { return {}; }
-  void set_disable_system_info(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DisableSystemInfo::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_DisableServiceEvents =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TraceConfig_BuiltinDataSource>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DisableServiceEvents kDisableServiceEvents() { return {}; }
-  void set_disable_service_events(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DisableServiceEvents::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_PrimaryTraceClock =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::BuiltinClock,
-      TraceConfig_BuiltinDataSource>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PrimaryTraceClock kPrimaryTraceClock() { return {}; }
-  void set_primary_trace_clock(::perfetto::protos::pbzero::BuiltinClock value) {
-    static constexpr uint32_t field_id = FieldMetadata_PrimaryTraceClock::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_SnapshotIntervalMs =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig_BuiltinDataSource>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SnapshotIntervalMs kSnapshotIntervalMs() { return {}; }
-  void set_snapshot_interval_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SnapshotIntervalMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_PreferSuspendClockForSnapshot =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TraceConfig_BuiltinDataSource>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PreferSuspendClockForSnapshot kPreferSuspendClockForSnapshot() { return {}; }
-  void set_prefer_suspend_clock_for_snapshot(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_PreferSuspendClockForSnapshot::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-};
+    // TryAcquireChunkForReading() has load-acquire semantics. Once acquired,
+    // the ABI contract expects the producer to not touch the chunk anymore
+    // (until the service marks that as free). This is why all the reads below
+    // are just memory_order_relaxed. Also, the code here assumes that all this
+    // data can be malicious and just gives up if anything is malformed.
+    BufferID buffer_id = static_cast<BufferID>(entry.target_buffer());
+    const SharedMemoryABI::ChunkHeader& chunk_header = *chunk.header();
+    WriterID writer_id = chunk_header.writer_id.load(std::memory_order_relaxed);
+    ChunkID chunk_id = chunk_header.chunk_id.load(std::memory_order_relaxed);
+    auto packets = chunk_header.packets.load(std::memory_order_relaxed);
+    uint16_t num_fragments = packets.count;
+    uint8_t chunk_flags = packets.flags;
 
-class TraceConfig_DataSource_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  TraceConfig_DataSource_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_DataSource_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_DataSource_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_config() const { return at<1>().valid(); }
-  ::protozero::ConstBytes config() const { return at<1>().as_bytes(); }
-  bool has_producer_name_filter() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> producer_name_filter() const { return GetRepeated<::protozero::ConstChars>(2); }
-  bool has_producer_name_regex_filter() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> producer_name_regex_filter() const { return GetRepeated<::protozero::ConstChars>(3); }
-};
+    service_->CopyProducerPageIntoLogBuffer(
+        id_, client_identity_, writer_id, chunk_id, buffer_id, num_fragments,
+        chunk_flags, chunk_complete, chunk.payload_begin(),
+        chunk.payload_size());
 
-class TraceConfig_DataSource : public ::protozero::Message {
- public:
-  using Decoder = TraceConfig_DataSource_Decoder;
-  enum : int32_t {
-    kConfigFieldNumber = 1,
-    kProducerNameFilterFieldNumber = 2,
-    kProducerNameRegexFilterFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.DataSource"; }
-
-
-  using FieldMetadata_Config =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      DataSourceConfig,
-      TraceConfig_DataSource>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Config kConfig() { return {}; }
-  template <typename T = DataSourceConfig> T* set_config() {
-    return BeginNestedMessage<T>(1);
-  }
-
-
-  using FieldMetadata_ProducerNameFilter =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TraceConfig_DataSource>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProducerNameFilter kProducerNameFilter() { return {}; }
-  void add_producer_name_filter(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ProducerNameFilter::kFieldId, data, size);
-  }
-  void add_producer_name_filter(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ProducerNameFilter::kFieldId, chars.data, chars.size);
-  }
-  void add_producer_name_filter(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProducerNameFilter::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ProducerNameRegexFilter =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TraceConfig_DataSource>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProducerNameRegexFilter kProducerNameRegexFilter() { return {}; }
-  void add_producer_name_regex_filter(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ProducerNameRegexFilter::kFieldId, data, size);
-  }
-  void add_producer_name_regex_filter(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ProducerNameRegexFilter::kFieldId, chars.data, chars.size);
-  }
-  void add_producer_name_regex_filter(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProducerNameRegexFilter::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-};
+    if (!commit_data_over_ipc) {
+      // This one has release-store semantics.
+      shmem_abi_.ReleaseChunkAsFree(std::move(chunk));
+    }
+  }  // for(chunks_to_move)
 
-class TraceConfig_BufferConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TraceConfig_BufferConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_BufferConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_BufferConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_size_kb() const { return at<1>().valid(); }
-  uint32_t size_kb() const { return at<1>().as_uint32(); }
-  bool has_fill_policy() const { return at<4>().valid(); }
-  int32_t fill_policy() const { return at<4>().as_int32(); }
-};
+  service_->ApplyChunkPatches(id_, req_untrusted.chunks_to_patch());
 
-class TraceConfig_BufferConfig : public ::protozero::Message {
- public:
-  using Decoder = TraceConfig_BufferConfig_Decoder;
-  enum : int32_t {
-    kSizeKbFieldNumber = 1,
-    kFillPolicyFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.BufferConfig"; }
-
-
-  using FillPolicy = ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy;
-  static inline const char* FillPolicy_Name(FillPolicy value) {
-    return ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy_Name(value);
-  }
-  static const FillPolicy UNSPECIFIED = FillPolicy::UNSPECIFIED;
-  static const FillPolicy RING_BUFFER = FillPolicy::RING_BUFFER;
-  static const FillPolicy DISCARD = FillPolicy::DISCARD;
-
-  using FieldMetadata_SizeKb =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig_BufferConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SizeKb kSizeKb() { return {}; }
-  void set_size_kb(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SizeKb::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_FillPolicy =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy,
-      TraceConfig_BufferConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FillPolicy kFillPolicy() { return {}; }
-  void set_fill_policy(::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy value) {
-    static constexpr uint32_t field_id = FieldMetadata_FillPolicy::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
+  if (req_untrusted.flush_request_id()) {
+    service_->NotifyFlushDoneForProducer(id_, req_untrusted.flush_request_id());
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/perfetto/tracing_service_event.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PERFETTO_TRACING_SERVICE_EVENT_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PERFETTO_TRACING_SERVICE_EVENT_PROTO_H_
+  // Keep this invocation last. ProducerIPCService::CommitData() relies on this
+  // callback being invoked within the same callstack and not posted. If this
+  // changes, the code there needs to be changed accordingly.
+  if (callback)
+    callback();
+}
 
-#include <stddef.h>
-#include <stdint.h>
+void ProducerEndpointImpl::SetupSharedMemory(
+    std::unique_ptr<SharedMemory> shared_memory,
+    size_t page_size_bytes,
+    bool provided_by_producer,
+    SharedMemoryABI::ShmemMode shmem_mode) {
+  PERFETTO_DCHECK(!shared_memory_ && !shmem_abi_.is_valid());
+  PERFETTO_DCHECK(page_size_bytes % 1024 == 0);
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  shared_memory_ = std::move(shared_memory);
+  shared_buffer_page_size_kb_ = page_size_bytes / 1024;
+  is_shmem_provided_by_producer_ = provided_by_producer;
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  shmem_abi_.Initialize(reinterpret_cast<uint8_t*>(shared_memory_->start()),
+                        shared_memory_->size(),
+                        shared_buffer_page_size_kb() * 1024, shmem_mode);
+  if (in_process_) {
+    inproc_shmem_arbiter_.reset(new SharedMemoryArbiterImpl(
+        shared_memory_->start(), shared_memory_->size(),
+        SharedMemoryABI::ShmemMode::kDefault,
+        shared_buffer_page_size_kb_ * 1024, this, weak_runner_.task_runner()));
+    inproc_shmem_arbiter_->SetDirectSMBPatchingSupportedByService();
+  }
 
+  OnTracingSetup();
+  service_->UpdateMemoryGuardrail();
+}
 
-class TracingServiceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TracingServiceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TracingServiceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TracingServiceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_tracing_started() const { return at<2>().valid(); }
-  bool tracing_started() const { return at<2>().as_bool(); }
-  bool has_all_data_sources_started() const { return at<1>().valid(); }
-  bool all_data_sources_started() const { return at<1>().as_bool(); }
-  bool has_all_data_sources_flushed() const { return at<3>().valid(); }
-  bool all_data_sources_flushed() const { return at<3>().as_bool(); }
-  bool has_read_tracing_buffers_completed() const { return at<4>().valid(); }
-  bool read_tracing_buffers_completed() const { return at<4>().as_bool(); }
-  bool has_tracing_disabled() const { return at<5>().valid(); }
-  bool tracing_disabled() const { return at<5>().as_bool(); }
-  bool has_seized_for_bugreport() const { return at<6>().valid(); }
-  bool seized_for_bugreport() const { return at<6>().as_bool(); }
-};
+SharedMemory* ProducerEndpointImpl::shared_memory() const {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  return shared_memory_.get();
+}
 
-class TracingServiceEvent : public ::protozero::Message {
- public:
-  using Decoder = TracingServiceEvent_Decoder;
-  enum : int32_t {
-    kTracingStartedFieldNumber = 2,
-    kAllDataSourcesStartedFieldNumber = 1,
-    kAllDataSourcesFlushedFieldNumber = 3,
-    kReadTracingBuffersCompletedFieldNumber = 4,
-    kTracingDisabledFieldNumber = 5,
-    kSeizedForBugreportFieldNumber = 6,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TracingServiceEvent"; }
-
-
-  using FieldMetadata_TracingStarted =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TracingServiceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TracingStarted kTracingStarted() { return {}; }
-  void set_tracing_started(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_TracingStarted::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_AllDataSourcesStarted =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TracingServiceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AllDataSourcesStarted kAllDataSourcesStarted() { return {}; }
-  void set_all_data_sources_started(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_AllDataSourcesStarted::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_AllDataSourcesFlushed =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TracingServiceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AllDataSourcesFlushed kAllDataSourcesFlushed() { return {}; }
-  void set_all_data_sources_flushed(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_AllDataSourcesFlushed::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ReadTracingBuffersCompleted =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TracingServiceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReadTracingBuffersCompleted kReadTracingBuffersCompleted() { return {}; }
-  void set_read_tracing_buffers_completed(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReadTracingBuffersCompleted::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_TracingDisabled =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TracingServiceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TracingDisabled kTracingDisabled() { return {}; }
-  void set_tracing_disabled(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_TracingDisabled::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_SeizedForBugreport =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TracingServiceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SeizedForBugreport kSeizedForBugreport() { return {}; }
-  void set_seized_for_bugreport(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_SeizedForBugreport::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-};
+size_t ProducerEndpointImpl::shared_buffer_page_size_kb() const {
+  return shared_buffer_page_size_kb_;
+}
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/system_info.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+void ProducerEndpointImpl::ActivateTriggers(
+    const std::vector<std::string>& triggers) {
+  service_->ActivateTriggers(id_, triggers);
+}
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_SYSTEM_INFO_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_SYSTEM_INFO_PROTO_H_
+void ProducerEndpointImpl::StopDataSource(DataSourceInstanceID ds_inst_id) {
+  // TODO(primiano): When we'll support tearing down the SMB, at this point we
+  // should send the Producer a TearDownTracing if all its data sources have
+  // been disabled (see b/77532839 and aosp/655179 PS1).
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  weak_runner_.PostTask(
+      [this, ds_inst_id] { producer_->StopDataSource(ds_inst_id); });
+}
 
-#include <stddef.h>
-#include <stdint.h>
+SharedMemoryArbiter* ProducerEndpointImpl::MaybeSharedMemoryArbiter() {
+  if (!inproc_shmem_arbiter_) {
+    PERFETTO_FATAL(
+        "The in-process SharedMemoryArbiter can only be used when "
+        "CreateProducer has been called with in_process=true and after tracing "
+        "has started.");
+  }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  PERFETTO_DCHECK(in_process_);
+  return inproc_shmem_arbiter_.get();
+}
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+bool ProducerEndpointImpl::IsShmemProvidedByProducer() const {
+  return is_shmem_provided_by_producer_;
+}
 
-class Utsname;
+// Can be called on any thread.
+std::unique_ptr<TraceWriter> ProducerEndpointImpl::CreateTraceWriter(
+    BufferID buf_id,
+    BufferExhaustedPolicy buffer_exhausted_policy) {
+  PERFETTO_DCHECK(MaybeSharedMemoryArbiter());
+  return MaybeSharedMemoryArbiter()->CreateTraceWriter(buf_id,
+                                                       buffer_exhausted_policy);
+}
 
-class SystemInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  SystemInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SystemInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SystemInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_utsname() const { return at<1>().valid(); }
-  ::protozero::ConstBytes utsname() const { return at<1>().as_bytes(); }
-  bool has_android_build_fingerprint() const { return at<2>().valid(); }
-  ::protozero::ConstChars android_build_fingerprint() const { return at<2>().as_string(); }
-  bool has_hz() const { return at<3>().valid(); }
-  int64_t hz() const { return at<3>().as_int64(); }
-  bool has_tracing_service_version() const { return at<4>().valid(); }
-  ::protozero::ConstChars tracing_service_version() const { return at<4>().as_string(); }
-  bool has_android_sdk_version() const { return at<5>().valid(); }
-  uint64_t android_sdk_version() const { return at<5>().as_uint64(); }
-  bool has_page_size() const { return at<6>().valid(); }
-  uint32_t page_size() const { return at<6>().as_uint32(); }
-};
+void ProducerEndpointImpl::NotifyFlushComplete(FlushRequestID id) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  PERFETTO_DCHECK(MaybeSharedMemoryArbiter());
+  return MaybeSharedMemoryArbiter()->NotifyFlushComplete(id);
+}
 
-class SystemInfo : public ::protozero::Message {
- public:
-  using Decoder = SystemInfo_Decoder;
-  enum : int32_t {
-    kUtsnameFieldNumber = 1,
-    kAndroidBuildFingerprintFieldNumber = 2,
-    kHzFieldNumber = 3,
-    kTracingServiceVersionFieldNumber = 4,
-    kAndroidSdkVersionFieldNumber = 5,
-    kPageSizeFieldNumber = 6,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.SystemInfo"; }
-
-
-  using FieldMetadata_Utsname =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      Utsname,
-      SystemInfo>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Utsname kUtsname() { return {}; }
-  template <typename T = Utsname> T* set_utsname() {
-    return BeginNestedMessage<T>(1);
-  }
-
-
-  using FieldMetadata_AndroidBuildFingerprint =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SystemInfo>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidBuildFingerprint kAndroidBuildFingerprint() { return {}; }
-  void set_android_build_fingerprint(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_AndroidBuildFingerprint::kFieldId, data, size);
-  }
-  void set_android_build_fingerprint(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_AndroidBuildFingerprint::kFieldId, chars.data, chars.size);
-  }
-  void set_android_build_fingerprint(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_AndroidBuildFingerprint::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Hz =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      SystemInfo>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Hz kHz() { return {}; }
-  void set_hz(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Hz::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_TracingServiceVersion =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SystemInfo>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TracingServiceVersion kTracingServiceVersion() { return {}; }
-  void set_tracing_service_version(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_TracingServiceVersion::kFieldId, data, size);
-  }
-  void set_tracing_service_version(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_TracingServiceVersion::kFieldId, chars.data, chars.size);
-  }
-  void set_tracing_service_version(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_TracingServiceVersion::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_AndroidSdkVersion =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SystemInfo>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidSdkVersion kAndroidSdkVersion() { return {}; }
-  void set_android_sdk_version(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AndroidSdkVersion::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_PageSize =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SystemInfo>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PageSize kPageSize() { return {}; }
-  void set_page_size(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PageSize::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-};
+void ProducerEndpointImpl::OnTracingSetup() {
+  weak_runner_.PostTask([this] { producer_->OnTracingSetup(); });
+}
 
-class Utsname_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Utsname_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Utsname_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Utsname_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_sysname() const { return at<1>().valid(); }
-  ::protozero::ConstChars sysname() const { return at<1>().as_string(); }
-  bool has_version() const { return at<2>().valid(); }
-  ::protozero::ConstChars version() const { return at<2>().as_string(); }
-  bool has_release() const { return at<3>().valid(); }
-  ::protozero::ConstChars release() const { return at<3>().as_string(); }
-  bool has_machine() const { return at<4>().valid(); }
-  ::protozero::ConstChars machine() const { return at<4>().as_string(); }
-};
+void ProducerEndpointImpl::Flush(
+    FlushRequestID flush_request_id,
+    const std::vector<DataSourceInstanceID>& data_sources,
+    FlushFlags flush_flags) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  weak_runner_.PostTask([this, flush_request_id, data_sources, flush_flags] {
+    producer_->Flush(flush_request_id, data_sources.data(), data_sources.size(),
+                     flush_flags);
+  });
+}
 
-class Utsname : public ::protozero::Message {
- public:
-  using Decoder = Utsname_Decoder;
-  enum : int32_t {
-    kSysnameFieldNumber = 1,
-    kVersionFieldNumber = 2,
-    kReleaseFieldNumber = 3,
-    kMachineFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.Utsname"; }
-
-
-  using FieldMetadata_Sysname =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      Utsname>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sysname kSysname() { return {}; }
-  void set_sysname(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Sysname::kFieldId, data, size);
-  }
-  void set_sysname(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Sysname::kFieldId, chars.data, chars.size);
-  }
-  void set_sysname(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Sysname::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Version =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      Utsname>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Version kVersion() { return {}; }
-  void set_version(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Version::kFieldId, data, size);
-  }
-  void set_version(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Version::kFieldId, chars.data, chars.size);
-  }
-  void set_version(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Version::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Release =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      Utsname>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Release kRelease() { return {}; }
-  void set_release(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Release::kFieldId, data, size);
-  }
-  void set_release(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Release::kFieldId, chars.data, chars.size);
-  }
-  void set_release(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Release::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Machine =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      Utsname>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Machine kMachine() { return {}; }
-  void set_machine(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Machine::kFieldId, data, size);
-  }
-  void set_machine(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Machine::kFieldId, chars.data, chars.size);
-  }
-  void set_machine(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Machine::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-};
+void ProducerEndpointImpl::SetupDataSource(DataSourceInstanceID ds_id,
+                                           const DataSourceConfig& config) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  allowed_target_buffers_.insert(static_cast<BufferID>(config.target_buffer()));
+  weak_runner_.PostTask([this, ds_id, config] {
+    producer_->SetupDataSource(ds_id, std::move(config));
+  });
+}
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/trace_uuid.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+void ProducerEndpointImpl::StartDataSource(DataSourceInstanceID ds_id,
+                                           const DataSourceConfig& config) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  weak_runner_.PostTask([this, ds_id, config] {
+    producer_->StartDataSource(ds_id, std::move(config));
+  });
+}
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACE_UUID_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACE_UUID_PROTO_H_
+void ProducerEndpointImpl::NotifyDataSourceStarted(
+    DataSourceInstanceID data_source_id) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  service_->NotifyDataSourceStarted(id_, data_source_id);
+}
 
-#include <stddef.h>
-#include <stdint.h>
+void ProducerEndpointImpl::NotifyDataSourceStopped(
+    DataSourceInstanceID data_source_id) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  service_->NotifyDataSourceStopped(id_, data_source_id);
+}
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+void ProducerEndpointImpl::OnFreeBuffers(
+    const std::vector<BufferID>& target_buffers) {
+  if (allowed_target_buffers_.empty())
+    return;
+  for (BufferID buffer : target_buffers)
+    allowed_target_buffers_.erase(buffer);
+}
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+void ProducerEndpointImpl::ClearIncrementalState(
+    const std::vector<DataSourceInstanceID>& data_sources) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  weak_runner_.PostTask([this, data_sources] {
+    base::StringView producer_name(name_);
+    producer_->ClearIncrementalState(data_sources.data(), data_sources.size());
+  });
+}
 
+void ProducerEndpointImpl::Sync(std::function<void()> callback) {
+  weak_runner_.task_runner()->PostTask(callback);
+}
 
-class TraceUuid_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TraceUuid_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceUuid_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceUuid_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_msb() const { return at<1>().valid(); }
-  int64_t msb() const { return at<1>().as_int64(); }
-  bool has_lsb() const { return at<2>().valid(); }
-  int64_t lsb() const { return at<2>().as_int64(); }
-};
+bool ProducerEndpointImpl::IsAndroidProcessFrozen() {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+  if (in_process_ || uid() == base::kInvalidUid || pid() == base::kInvalidPid)
+    return false;
 
-class TraceUuid : public ::protozero::Message {
- public:
-  using Decoder = TraceUuid_Decoder;
-  enum : int32_t {
-    kMsbFieldNumber = 1,
-    kLsbFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceUuid"; }
-
-
-  using FieldMetadata_Msb =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TraceUuid>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Msb kMsb() { return {}; }
-  void set_msb(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Msb::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Lsb =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TraceUuid>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lsb kLsb() { return {}; }
-  void set_lsb(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lsb::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
+  // As per aosp/3406861, there are three possible mount points for the cgroup.
+  // Look at all of them.
+  // - Historically everything was in /uid_xxx/pid_yyy (and still is if
+  //   PRODUCT_CGROUP_V2_SYS_APP_ISOLATION_ENABLED = false)
+  // - cgroup isolation introduces /apps /system subdirectories.
+  base::StackString<255> path_v1(
+      "/sys/fs/cgroup/uid_%" PRIu32 "/pid_%" PRIu32 "/cgroup.freeze",
+      static_cast<uint32_t>(uid()), static_cast<uint32_t>(pid()));
+  base::StackString<255> path_v2_app(
+      "/sys/fs/cgroup/apps/uid_%" PRIu32 "/pid_%" PRIu32 "/cgroup.freeze",
+      static_cast<uint32_t>(uid()), static_cast<uint32_t>(pid()));
+  base::StackString<255> path_v2_system(
+      "/sys/fs/cgroup/system/uid_%" PRIu32 "/pid_%" PRIu32 "/cgroup.freeze",
+      static_cast<uint32_t>(uid()), static_cast<uint32_t>(pid()));
+  const char* paths[] = {path_v1.c_str(), path_v2_app.c_str(),
+                         path_v2_system.c_str()};
+
+  for (const char* path : paths) {
+    char frozen = '0';
+    auto fd = base::OpenFile(path, O_RDONLY);
+    ssize_t rsize = 0;
+    if (fd) {
+      rsize = base::Read(*fd, &frozen, sizeof(frozen));
+      if (rsize > 0) {
+        return frozen == '1';
+      }
+    }
   }
-};
+  PERFETTO_DLOG("Failed to read cgroup.freeze from [%s, %s, %s]",
+                path_v1.c_str(), path_v2_app.c_str(), path_v2_system.c_str());
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/trigger.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+#endif
+  return false;
+}
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRIGGER_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRIGGER_PROTO_H_
+////////////////////////////////////////////////////////////////////////////////
+// RelayEndpointImpl implementation
+////////////////////////////////////////////////////////////////////////////////
+RelayEndpointImpl::RelayEndpointImpl(RelayClientID relay_client_id,
+                                     TracingServiceImpl* service)
+    : relay_client_id_(relay_client_id),
+      service_(service),
+      serialized_system_info_({}) {}
+RelayEndpointImpl::~RelayEndpointImpl() = default;
 
-#include <stddef.h>
-#include <stdint.h>
+void RelayEndpointImpl::SyncClocks(SyncMode sync_mode,
+                                   base::ClockSnapshotVector client_clocks,
+                                   base::ClockSnapshotVector host_clocks) {
+  // We keep only the most recent 5 clock sync snapshots.
+  static constexpr size_t kNumSyncClocks = 5;
+  if (synced_clocks_.size() >= kNumSyncClocks)
+    synced_clocks_.pop_front();
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  synced_clocks_.emplace_back(sync_mode, std::move(client_clocks),
+                              std::move(host_clocks));
+}
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+void RelayEndpointImpl::Disconnect() {
+  service_->DisconnectRelayClient(relay_client_id_);
+}
+}  // namespace perfetto::tracing_service
+// gen_amalgamated begin source: src/tracing/service/tracing_service_impl.cc
+// gen_amalgamated begin header: include/perfetto/ext/tracing/core/priority_boost_config.h
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
+#ifndef INCLUDE_PERFETTO_EXT_TRACING_CORE_PRIORITY_BOOST_CONFIG_H_
+#define INCLUDE_PERFETTO_EXT_TRACING_CORE_PRIORITY_BOOST_CONFIG_H_
 
-class Trigger_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Trigger_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Trigger_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Trigger_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_trigger_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars trigger_name() const { return at<1>().as_string(); }
-  bool has_producer_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars producer_name() const { return at<2>().as_string(); }
-  bool has_trusted_producer_uid() const { return at<3>().valid(); }
-  int32_t trusted_producer_uid() const { return at<3>().as_int32(); }
-};
+// gen_amalgamated expanded: #include "protos/perfetto/config/priority_boost/priority_boost_config.gen.h"
 
-class Trigger : public ::protozero::Message {
- public:
-  using Decoder = Trigger_Decoder;
-  enum : int32_t {
-    kTriggerNameFieldNumber = 1,
-    kProducerNameFieldNumber = 2,
-    kTrustedProducerUidFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.Trigger"; }
-
-
-  using FieldMetadata_TriggerName =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      Trigger>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TriggerName kTriggerName() { return {}; }
-  void set_trigger_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_TriggerName::kFieldId, data, size);
-  }
-  void set_trigger_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_TriggerName::kFieldId, chars.data, chars.size);
-  }
-  void set_trigger_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_TriggerName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ProducerName =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      Trigger>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProducerName kProducerName() { return {}; }
-  void set_producer_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ProducerName::kFieldId, data, size);
-  }
-  void set_producer_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ProducerName::kFieldId, chars.data, chars.size);
-  }
-  void set_producer_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProducerName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_TrustedProducerUid =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Trigger>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustedProducerUid kTrustedProducerUid() { return {}; }
-  void set_trusted_producer_uid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TrustedProducerUid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-};
+// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_sched_boost.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/status_or.h"
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
+namespace perfetto {
+inline base::StatusOr<base::SchedPolicyAndPrio> CreateSchedPolicyFromConfig(
+    const protos::gen::PriorityBoostConfig& config) {
+  auto policy = config.policy();
+  uint32_t priority = config.priority();
+  switch (policy) {
+    case protos::gen::PriorityBoostConfig::POLICY_SCHED_OTHER:
+      if (priority <= 20) {
+        return base::SchedPolicyAndPrio{
+            base::SchedPolicyAndPrio::Policy::kSchedOther, priority};
+      }
+      return base::ErrStatus(
+          "For the 'POLICY_SCHED_OTHER' priority must be in the range [0; 20]");
+    case protos::gen::PriorityBoostConfig::POLICY_SCHED_FIFO:
+      if (priority >= 1 && priority <= 99) {
+        return base::SchedPolicyAndPrio{
+            base::SchedPolicyAndPrio::Policy::kSchedFifo, priority};
+      }
+      return base::ErrStatus(
+          "For the 'POLICY_SCHED_FIFO' priority must be in the range [1; 99]");
+    case protos::gen::PriorityBoostConfig::POLICY_UNSPECIFIED:
+      return base::ErrStatus("Policy must not be 'POLICY_UNSPECIFIED'");
+  }
+  PERFETTO_CHECK(false);  // For GCC.
+}
+}  // namespace perfetto
+#endif  // INCLUDE_PERFETTO_EXT_TRACING_CORE_PRIORITY_BOOST_CONFIG_H_
 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
@@ -60539,18 +63547,30 @@ class Trigger : public ::protozero::Message {
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "src/tracing/core/tracing_service_impl.h"
+// gen_amalgamated expanded: #include "src/tracing/service/tracing_service_impl.h"
 
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
-
-#include <errno.h>
+#include <fcntl.h>
 #include <limits.h>
 #include <string.h>
-
+#include <algorithm>
+#include <array>
+#include <atomic>
 #include <cinttypes>
+#include <cstdint>
+#include <cstdlib>
+#include <functional>
+#include <limits>
+#include <map>
+#include <memory>
+#include <optional>
 #include <regex>
+#include <set>
+#include <string>
+#include <tuple>
+#include <unordered_map>
 #include <unordered_set>
+#include <utility>
+#include <vector>
 
 #if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) && \
     !PERFETTO_BUILDFLAG(PERFETTO_OS_NACL)
@@ -60567,51 +63587,81 @@ class Trigger : public ::protozero::Message {
 
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
     PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) || \
     PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
 #define PERFETTO_HAS_CHMOD
 #include <sys/stat.h>
 #endif
 
-#include <algorithm>
-
 // gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
 // gen_amalgamated expanded: #include "perfetto/base/status.h"
 // gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/android_utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/clock_snapshots.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/file_utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/flags.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/flat_hash_map.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/fnv_hash.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/metatrace.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/temp_file.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/periodic_task.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_sched_boost.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"  // IWYU pragma: keep
+// gen_amalgamated expanded: #include "perfetto/ext/base/sys_types.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/thread_checker.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/uuid.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/version.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/watchdog.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/client_identity.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/consumer.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/observable_events.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/priority_boost_config.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/producer.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_abi.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/slice.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_packet.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_writer.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/static_buffer.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_descriptor.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/core/tracing_service_capabilities.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/core/tracing_service_state.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/flush_flags.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/trace_config.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/trace_config.gen.h"
+// gen_amalgamated expanded: #include "src/android_stats/perfetto_atoms.h"
 // gen_amalgamated expanded: #include "src/android_stats/statsd_logging_helper.h"
+// gen_amalgamated expanded: #include "src/protovm/vm.h"
 // gen_amalgamated expanded: #include "src/protozero/filtering/message_filter.h"
-// gen_amalgamated expanded: #include "src/tracing/core/packet_stream_validator.h"
+// gen_amalgamated expanded: #include "src/protozero/filtering/string_filter.h"
 // gen_amalgamated expanded: #include "src/tracing/core/shared_memory_arbiter_impl.h"
-// gen_amalgamated expanded: #include "src/tracing/core/trace_buffer.h"
+// gen_amalgamated expanded: #include "src/tracing/service/clock.h"
+// gen_amalgamated expanded: #include "src/tracing/service/dependencies.h"
+// gen_amalgamated expanded: #include "src/tracing/service/packet_stream_validator.h"
+// gen_amalgamated expanded: #include "src/tracing/service/random.h"
+// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer.h"
+// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer_v1.h"
+// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer_v1_with_v2_shadow.h"
+// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer_v2.h"
+// gen_amalgamated expanded: #include "src/tracing/service/tracing_service_endpoints_impl.h"
+// gen_amalgamated expanded: #include "src/tracing/service/tracing_service_session.h"
+// gen_amalgamated expanded: #include "src/tracing/service/tracing_service_structs.h"
 
 // gen_amalgamated expanded: #include "protos/perfetto/common/builtin_clock.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/common/builtin_clock.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/common/trace_stats.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/system_info.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/trace_stats.pbzero.h"  // IWYU pragma: keep
+// gen_amalgamated expanded: #include "protos/perfetto/config/protovm/protovm_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/trace_config.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/protovm/vm_program.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/trace/clock_snapshot.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/extension_descriptor.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/perfetto/trace_provenance.pbzero.h"
 // gen_amalgamated expanded: #include "protos/perfetto/trace/perfetto/tracing_service_event.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/system_info.pbzero.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/remote_clock_sync.pbzero.h"
 // gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h"
 // gen_amalgamated expanded: #include "protos/perfetto/trace/trace_uuid.pbzero.h"
 // gen_amalgamated expanded: #include "protos/perfetto/trace/trigger.pbzero.h"
@@ -60627,22 +63677,33 @@ class Trigger : public ::protozero::Message {
 
 namespace perfetto {
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) && \
-    PERFETTO_BUILDFLAG(PERFETTO_ANDROID_BUILD)
-// These are the only SELinux approved dir for trace files that are created
-// directly by traced.
-const char* kTraceDirBasePath = "/data/misc/perfetto-traces/";
-const char* kAndroidProductionBugreportTracePath =
-    "/data/misc/perfetto-traces/bugreport/systrace.pftrace";
-#endif
+// static
+std::unique_ptr<TracingService> TracingService::CreateInstance(
+    std::unique_ptr<SharedMemory::Factory> shm_factory,
+    base::TaskRunner* task_runner,
+    InitOpts init_opts) {
+  tracing_service::Dependencies deps;
+  deps.clock = std::make_unique<tracing_service::ClockImpl>();
+  uint32_t seed = static_cast<uint32_t>(deps.clock->GetWallTimeMs().count());
+  deps.random = std::make_unique<tracing_service::RandomImpl>(seed);
+  return std::unique_ptr<TracingService>(
+      new tracing_service::TracingServiceImpl(
+          std::move(shm_factory), task_runner, std::move(deps), init_opts));
+}
+
+namespace tracing_service {
 
 namespace {
 constexpr int kMaxBuffersPerConsumer = 128;
 constexpr uint32_t kDefaultSnapshotsIntervalMs = 10 * 1000;
 constexpr int kDefaultWriteIntoFilePeriodMs = 5000;
+constexpr int kMinWriteIntoFilePeriodMs = 100;
+constexpr uint32_t kAllDataSourceStartedTimeout = 20000;
 constexpr int kMaxConcurrentTracingSessions = 15;
 constexpr int kMaxConcurrentTracingSessionsPerUid = 5;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
 constexpr int kMaxConcurrentTracingSessionsForStatsdUid = 10;
+#endif
 constexpr int64_t kMinSecondsBetweenTracesGuardrail = 5 * 60;
 
 constexpr uint32_t kMillisPerHour = 3600000;
@@ -60653,6 +63714,10 @@ constexpr uint32_t kMaxTracingDurationMillis = 7 * 24 * kMillisPerHour;
 constexpr uint32_t kGuardrailsMaxTracingBufferSizeKb = 128 * 1024;
 constexpr uint32_t kGuardrailsMaxTracingDurationMillis = 24 * kMillisPerHour;
 
+constexpr size_t kMaxLifecycleEventsListedDataSources = 32;
+
+constexpr uint32_t kTracePacketSystemInfoFieldId = 45;
+
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) || PERFETTO_BUILDFLAG(PERFETTO_OS_NACL)
 struct iovec {
   void* iov_base;  // Address
@@ -60675,33 +63740,12 @@ ssize_t writev(int fd, const struct iovec* iov, int iovcnt) {
 
 #define IOV_MAX 1024  // Linux compatible limit.
 
-#endif  // PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) ||
-        // PERFETTO_BUILDFLAG(PERFETTO_OS_NACL)
-
-// Partially encodes a CommitDataRequest in an int32 for the purposes of
-// metatracing. Note that it encodes only the bottom 10 bits of the producer id
-// (which is technically 16 bits wide).
-//
-// Format (by bit range):
-// [   31 ][         30 ][             29:20 ][            19:10 ][        9:0]
-// [unused][has flush id][num chunks to patch][num chunks to move][producer id]
-static int32_t EncodeCommitDataRequest(ProducerID producer_id,
-                                       const CommitDataRequest& req_untrusted) {
-  uint32_t cmov = static_cast<uint32_t>(req_untrusted.chunks_to_move_size());
-  uint32_t cpatch = static_cast<uint32_t>(req_untrusted.chunks_to_patch_size());
-  uint32_t has_flush_id = req_untrusted.flush_request_id() != 0;
-
-  uint32_t mask = (1 << 10) - 1;
-  uint32_t acc = 0;
-  acc |= has_flush_id << 30;
-  acc |= (cpatch & mask) << 20;
-  acc |= (cmov & mask) << 10;
-  acc |= (producer_id & mask);
-  return static_cast<int32_t>(acc);
-}
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_QNX)
+#define IOV_MAX 1024  // Linux compatible limit.
+#endif
 
 void SerializeAndAppendPacket(std::vector<TracePacket>* packets,
-                              std::vector<uint8_t> packet) {
+                              const std::vector<uint8_t>& packet) {
   Slice slice = Slice::Allocate(packet.size());
   memcpy(slice.own_data(), packet.data(), packet.size());
   packets->emplace_back();
@@ -60752,9 +63796,6 @@ std::tuple<size_t /*shm_size*/, size_t /*page_size*/> EnsureValidShmSizes(
 bool NameMatchesFilter(const std::string& name,
                        const std::vector<std::string>& name_filter,
                        const std::vector<std::string>& name_regex_filter) {
-  bool filter_is_set = !name_filter.empty() || !name_regex_filter.empty();
-  if (!filter_is_set)
-    return true;
   bool filter_matches = std::find(name_filter.begin(), name_filter.end(),
                                   name) != name_filter.end();
   bool filter_regex_matches =
@@ -60766,9 +63807,7 @@ bool NameMatchesFilter(const std::string& name,
   return filter_matches || filter_regex_matches;
 }
 
-// Used when:
-// 1. TraceConfig.write_into_file == true and output_path is not empty.
-// 2. Calling SaveTraceForBugreport(), from perfetto --save-for-bugreport.
+// Used when TraceConfig.write_into_file == true and output_path is not empty.
 base::ScopedFile CreateTraceFile(const std::string& path, bool overwrite) {
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) && \
     PERFETTO_BUILDFLAG(PERFETTO_ANDROID_BUILD)
@@ -60776,6 +63815,9 @@ base::ScopedFile CreateTraceFile(const std::string& path, bool overwrite) {
   // It just improves the actionability of the error when people try to save the
   // trace in a location that is not SELinux-allowed (a generic "permission
   // denied" vs "don't put it here, put it there").
+  // These are the only SELinux approved dir for trace files that are created
+  // directly by traced.
+  static const char* kTraceDirBasePath = "/data/misc/perfetto-traces/";
   if (!base::StartsWith(path, kTraceDirBasePath)) {
     PERFETTO_ELOG("Invalid output_path %s. On Android it must be within %s.",
                   path.c_str(), kTraceDirBasePath);
@@ -60796,10 +63838,6 @@ base::ScopedFile CreateTraceFile(const std::string& path, bool overwrite) {
   return fd;
 }
 
-std::string GetBugreportTmpPath() {
-  return GetBugreportPath() + ".tmp";
-}
-
 bool ShouldLogEvent(const TraceConfig& cfg) {
   switch (cfg.statsd_logging()) {
     case TraceConfig::STATSD_LOGGING_ENABLED:
@@ -60836,44 +63874,64 @@ void AppendOwnedSlicesToPacket(std::unique_ptr<uint8_t[]> data,
   }
 }
 
-}  // namespace
+using TraceFilter = protos::gen::TraceConfig::TraceFilter;
+std::optional<protozero::StringFilter::Policy> ConvertPolicy(
+    TraceFilter::StringFilterPolicy policy) {
+  switch (policy) {
+    case TraceFilter::SFP_UNSPECIFIED:
+      return std::nullopt;
+    case TraceFilter::SFP_MATCH_REDACT_GROUPS:
+      return protozero::StringFilter::Policy::kMatchRedactGroups;
+    case TraceFilter::SFP_ATRACE_MATCH_REDACT_GROUPS:
+      return protozero::StringFilter::Policy::kAtraceMatchRedactGroups;
+    case TraceFilter::SFP_MATCH_BREAK:
+      return protozero::StringFilter::Policy::kMatchBreak;
+    case TraceFilter::SFP_ATRACE_MATCH_BREAK:
+      return protozero::StringFilter::Policy::kAtraceMatchBreak;
+    case TraceFilter::SFP_ATRACE_REPEATED_SEARCH_REDACT_GROUPS:
+      return protozero::StringFilter::Policy::kAtraceRepeatedSearchRedactGroups;
+  }
+  return std::nullopt;
+}
 
-#if !PERFETTO_IS_AT_LEAST_CPP17()
-// These constants instead are defined in the header because are used by tests.
-constexpr size_t TracingServiceImpl::kMaxShmSize;
-constexpr uint32_t TracingServiceImpl::kDataSourceStopTimeoutMs;
-constexpr uint8_t TracingServiceImpl::kSyncMarker[];
-#endif
+using StringFilterRule =
+    protos::gen::TraceConfig::TraceFilter::StringFilterRule;
 
-std::string GetBugreportPath() {
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) && \
-    PERFETTO_BUILDFLAG(PERFETTO_ANDROID_BUILD)
-  return kAndroidProductionBugreportTracePath;
-#else
-  // Only for tests, SaveTraceForBugreport is not used on other OSes.
-  return base::GetSysTempDir() + "/bugreport.pftrace";
-#endif
-}
+std::optional<protozero::StringFilter::SemanticTypeMask>
+ConvertSemanticTypeMask(const StringFilterRule& rule) {
+  // UNSPECIFIED (0) is treated as its own category - it only matches rules
+  // that explicitly include bit 0 in their mask. If no semantic types are
+  // specified, default to matching only UNSPECIFIED (bit 0).
+  if (rule.semantic_type().empty()) {
+    return protozero::StringFilter::SemanticTypeMask::Unspecified();
+  }
 
-// static
-std::unique_ptr<TracingService> TracingService::CreateInstance(
-    std::unique_ptr<SharedMemory::Factory> shm_factory,
-    base::TaskRunner* task_runner) {
-  return std::unique_ptr<TracingService>(
-      new TracingServiceImpl(std::move(shm_factory), task_runner));
+  protozero::StringFilter::SemanticTypeMask mask;
+  for (const auto& type : rule.semantic_type()) {
+    auto semantic_type = static_cast<uint32_t>(type);
+    if (semantic_type >= protozero::StringFilter::SemanticTypeMask::kLimit) {
+      return std::nullopt;
+    }
+    mask.Set(semantic_type);
+  }
+  return mask;
 }
 
+}  // namespace
+
 TracingServiceImpl::TracingServiceImpl(
     std::unique_ptr<SharedMemory::Factory> shm_factory,
-    base::TaskRunner* task_runner)
-    : task_runner_(task_runner),
+    base::TaskRunner* task_runner,
+    tracing_service::Dependencies deps,
+    InitOpts init_opts)
+    : clock_(std::move(deps.clock)),
+      random_(std::move(deps.random)),
+      init_opts_(init_opts),
       shm_factory_(std::move(shm_factory)),
       uid_(base::GetCurrentUserId()),
       buffer_ids_(kMaxTraceBufferID),
-      trigger_probability_rand_(
-          static_cast<uint32_t>(base::GetWallTimeNs().count())),
-      weak_ptr_factory_(this) {
-  PERFETTO_DCHECK(task_runner_);
+      weak_runner_(task_runner) {
+  PERFETTO_DCHECK(task_runner);
 }
 
 TracingServiceImpl::~TracingServiceImpl() {
@@ -60882,19 +63940,20 @@ TracingServiceImpl::~TracingServiceImpl() {
 
 std::unique_ptr<TracingService::ProducerEndpoint>
 TracingServiceImpl::ConnectProducer(Producer* producer,
-                                    uid_t uid,
-                                    pid_t pid,
+                                    const ClientIdentity& client_identity,
                                     const std::string& producer_name,
                                     size_t shared_memory_size_hint_bytes,
                                     bool in_process,
                                     ProducerSMBScrapingMode smb_scraping_mode,
                                     size_t shared_memory_page_size_hint_bytes,
                                     std::unique_ptr<SharedMemory> shm,
-                                    const std::string& sdk_version) {
+                                    const std::string& sdk_version,
+                                    const std::string& machine_name) {
   PERFETTO_DCHECK_THREAD(thread_checker_);
 
+  auto uid = client_identity.uid();
   if (lockdown_mode_ && uid != base::GetCurrentUserId()) {
-    PERFETTO_DLOG("Lockdown mode. Rejecting producer with UID %ld",
+    PERFETTO_DLOG("Lockdown mode. Rejecting producer with UID %lu",
                   static_cast<unsigned long>(uid));
     return nullptr;
   }
@@ -60919,8 +63978,9 @@ TracingServiceImpl::ConnectProducer(Producer* producer,
   }
 
   std::unique_ptr<ProducerEndpointImpl> endpoint(new ProducerEndpointImpl(
-      id, uid, pid, this, task_runner_, producer, producer_name, sdk_version,
-      in_process, smb_scraping_enabled));
+      id, client_identity, this, weak_runner_.task_runner(), producer,
+      producer_name, machine_name, sdk_version, in_process,
+      smb_scraping_enabled));
   auto it_and_inserted = producers_.emplace(id, endpoint.get());
   PERFETTO_DCHECK(it_and_inserted.second);
   endpoint->shmem_size_hint_bytes_ = shared_memory_size_hint_bytes;
@@ -60928,11 +63988,8 @@ TracingServiceImpl::ConnectProducer(Producer* producer,
 
   // Producer::OnConnect() should run before Producer::OnTracingSetup(). The
   // latter may be posted by SetupSharedMemory() below, so post OnConnect() now.
-  auto weak_ptr = endpoint->weak_ptr_factory_.GetWeakPtr();
-  task_runner_->PostTask([weak_ptr] {
-    if (weak_ptr)
-      weak_ptr->producer_->OnConnect();
-  });
+  endpoint->weak_runner_.PostTask(
+      [endpoint = endpoint.get()] { endpoint->producer_->OnConnect(); });
 
   if (shm) {
     // The producer supplied an SMB. This is used only by Chrome; in the most
@@ -60948,8 +64005,11 @@ TracingServiceImpl::ConnectProducer(Producer* producer,
       PERFETTO_DLOG(
           "Adopting producer-provided SMB of %zu kB for producer \"%s\"",
           shm_size / 1024, endpoint->name_.c_str());
+      auto shmem_mode = client_identity.machine_id() == kDefaultMachineID
+                            ? SharedMemoryABI::ShmemMode::kDefault
+                            : SharedMemoryABI::ShmemMode::kShmemEmulation;
       endpoint->SetupSharedMemory(std::move(shm), page_size,
-                                  /*provided_by_producer=*/true);
+                                  /*provided_by_producer=*/true, shmem_mode);
     } else {
       PERFETTO_LOG(
           "Discarding incorrectly sized producer-provided SMB for producer "
@@ -60988,8 +64048,7 @@ void TracingServiceImpl::DisconnectProducer(ProducerID id) {
   UpdateMemoryGuardrail();
 }
 
-TracingServiceImpl::ProducerEndpointImpl* TracingServiceImpl::GetProducer(
-    ProducerID id) const {
+ProducerEndpointImpl* TracingServiceImpl::GetProducer(ProducerID id) const {
   PERFETTO_DCHECK_THREAD(thread_checker_);
   auto it = producers_.find(id);
   if (it == producers_.end())
@@ -61002,14 +64061,12 @@ TracingServiceImpl::ConnectConsumer(Consumer* consumer, uid_t uid) {
   PERFETTO_DCHECK_THREAD(thread_checker_);
   PERFETTO_DLOG("Consumer %p connected from UID %" PRIu64,
                 reinterpret_cast<void*>(consumer), static_cast<uint64_t>(uid));
-  std::unique_ptr<ConsumerEndpointImpl> endpoint(
-      new ConsumerEndpointImpl(this, task_runner_, consumer, uid));
-  auto it_and_inserted = consumers_.emplace(endpoint.get());
-  PERFETTO_DCHECK(it_and_inserted.second);
+  std::unique_ptr<ConsumerEndpointImpl> endpoint(new ConsumerEndpointImpl(
+      this, weak_runner_.task_runner(), consumer, uid));
   // Consumer might go away before we're able to send the connect notification,
   // if that is the case just bail out.
   auto weak_ptr = endpoint->weak_ptr_factory_.GetWeakPtr();
-  task_runner_->PostTask([weak_ptr] {
+  weak_runner_.task_runner()->PostTask([weak_ptr = std::move(weak_ptr)] {
     if (weak_ptr)
       weak_ptr->consumer_->OnConnect();
   });
@@ -61019,13 +64076,9 @@ TracingServiceImpl::ConnectConsumer(Consumer* consumer, uid_t uid) {
 void TracingServiceImpl::DisconnectConsumer(ConsumerEndpointImpl* consumer) {
   PERFETTO_DCHECK_THREAD(thread_checker_);
   PERFETTO_DLOG("Consumer %p disconnected", reinterpret_cast<void*>(consumer));
-  PERFETTO_DCHECK(consumers_.count(consumer));
 
-  // TODO(primiano) : Check that this is safe (what happens if there are
-  // ReadBuffers() calls posted in the meantime? They need to become noop).
   if (consumer->tracing_session_id_)
     FreeBuffers(consumer->tracing_session_id_);  // Will also DisableTracing().
-  consumers_.erase(consumer);
 
   // At this point no more pointers to |consumer| should be around.
   PERFETTO_DCHECK(!std::any_of(
@@ -61039,7 +64092,6 @@ bool TracingServiceImpl::DetachConsumer(ConsumerEndpointImpl* consumer,
                                         const std::string& key) {
   PERFETTO_DCHECK_THREAD(thread_checker_);
   PERFETTO_DLOG("Consumer %p detached", reinterpret_cast<void*>(consumer));
-  PERFETTO_DCHECK(consumers_.count(consumer));
 
   TracingSessionID tsid = consumer->tracing_session_id_;
   TracingSession* tracing_session;
@@ -61059,12 +64111,29 @@ bool TracingServiceImpl::DetachConsumer(ConsumerEndpointImpl* consumer,
   return true;
 }
 
+std::unique_ptr<TracingService::RelayEndpoint>
+TracingServiceImpl::ConnectRelayClient(RelayClientID relay_client_id) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+
+  auto endpoint = std::make_unique<RelayEndpointImpl>(relay_client_id, this);
+  relay_clients_[relay_client_id] = endpoint.get();
+
+  return std::move(endpoint);
+}
+
+void TracingServiceImpl::DisconnectRelayClient(RelayClientID relay_client_id) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+
+  if (relay_clients_.find(relay_client_id) == relay_clients_.end())
+    return;
+  relay_clients_.erase(relay_client_id);
+}
+
 bool TracingServiceImpl::AttachConsumer(ConsumerEndpointImpl* consumer,
                                         const std::string& key) {
   PERFETTO_DCHECK_THREAD(thread_checker_);
   PERFETTO_DLOG("Consumer %p attaching to session %s",
                 reinterpret_cast<void*>(consumer), key.c_str());
-  PERFETTO_DCHECK(consumers_.count(consumer));
 
   if (consumer->tracing_session_id_) {
     PERFETTO_ELOG(
@@ -61134,11 +64203,11 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer,
                             cfg.duration_ms(), max_duration_ms);
   }
 
-  const bool has_trigger_config = cfg.trigger_config().trigger_mode() !=
-                                  TraceConfig::TriggerConfig::UNSPECIFIED;
-  if (has_trigger_config && (cfg.trigger_config().trigger_timeout_ms() == 0 ||
-                             cfg.trigger_config().trigger_timeout_ms() >
-                                 kGuardrailsMaxTracingDurationMillis)) {
+  const bool has_trigger_config =
+      GetTriggerMode(cfg) != TraceConfig::TriggerConfig::UNSPECIFIED;
+  if (has_trigger_config &&
+      (cfg.trigger_config().trigger_timeout_ms() == 0 ||
+       cfg.trigger_config().trigger_timeout_ms() > max_duration_ms)) {
     MaybeLogUploadEvent(
         cfg, uuid,
         PerfettoStatsdAtom::kTracedEnableTracingInvalidTriggerTimeout);
@@ -61148,6 +64217,25 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer,
         cfg.trigger_config().trigger_timeout_ms());
   }
 
+  // This check has been introduced in May 2023 after finding b/274931668.
+  if (static_cast<int>(cfg.trigger_config().trigger_mode()) >
+      TraceConfig::TriggerConfig::TriggerMode_MAX) {
+    MaybeLogUploadEvent(
+        cfg, uuid, PerfettoStatsdAtom::kTracedEnableTracingInvalidTriggerMode);
+    return PERFETTO_SVC_ERR(
+        "The trace config specified an invalid trigger_mode");
+  }
+
+  if (cfg.trigger_config().use_clone_snapshot_if_available() &&
+      cfg.trigger_config().trigger_mode() !=
+          TraceConfig::TriggerConfig::STOP_TRACING) {
+    MaybeLogUploadEvent(
+        cfg, uuid, PerfettoStatsdAtom::kTracedEnableTracingInvalidTriggerMode);
+    return PERFETTO_SVC_ERR(
+        "trigger_mode must be STOP_TRACING when "
+        "use_clone_snapshot_if_available=true");
+  }
+
   if (has_trigger_config && cfg.duration_ms() != 0) {
     MaybeLogUploadEvent(
         cfg, uuid, PerfettoStatsdAtom::kTracedEnableTracingDurationWithTrigger);
@@ -61155,8 +64243,18 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer,
         "duration_ms was set, this must not be set for traces with triggers.");
   }
 
-  if (cfg.trigger_config().trigger_mode() ==
-          TraceConfig::TriggerConfig::STOP_TRACING &&
+  for (char c : cfg.bugreport_filename()) {
+    if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
+          (c >= '0' && c <= '9') || c == '-' || c == '_' || c == '.')) {
+      MaybeLogUploadEvent(
+          cfg, uuid, PerfettoStatsdAtom::kTracedEnableTracingInvalidBrFilename);
+      return PERFETTO_SVC_ERR(
+          "bugreport_filename contains invalid chars. Use [a-zA-Z0-9-_.]+");
+    }
+  }
+
+  if ((GetTriggerMode(cfg) == TraceConfig::TriggerConfig::STOP_TRACING ||
+       GetTriggerMode(cfg) == TraceConfig::TriggerConfig::CLONE_SNAPSHOT) &&
       cfg.write_into_file()) {
     // We don't support this usecase because there are subtle assumptions which
     // break around TracingServiceEvents and windowed sorting (i.e. if we don't
@@ -61168,8 +64266,8 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer,
         cfg, uuid,
         PerfettoStatsdAtom::kTracedEnableTracingStopTracingWriteIntoFile);
     return PERFETTO_SVC_ERR(
-        "Specifying trigger mode STOP_TRACING and write_into_file together is "
-        "unsupported");
+        "Specifying trigger mode STOP_TRACING/CLONE_SNAPSHOT and "
+        "write_into_file together is unsupported");
   }
 
   std::unordered_set<std::string> triggers;
@@ -61217,25 +64315,127 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer,
     }
   }
 
-  if (cfg.buffers_size() > kMaxBuffersPerConsumer) {
+  const size_t num_buffers = static_cast<size_t>(cfg.buffers_size());
+  if (num_buffers > kMaxBuffersPerConsumer) {
     MaybeLogUploadEvent(cfg, uuid,
                         PerfettoStatsdAtom::kTracedEnableTracingTooManyBuffers);
-    return PERFETTO_SVC_ERR("Too many buffers configured (%d)",
-                            cfg.buffers_size());
+    return PERFETTO_SVC_ERR("Too many buffers configured (%zu)", num_buffers);
+  }
+
+  // Build a map of buffer names to indices for named buffer resolution.
+  // Also validate that buffer names are unique within the session.
+  base::FlatHashMap<std::string, size_t> buffer_name_to_index;
+  for (size_t i = 0; i < num_buffers; ++i) {
+    const auto& buf = cfg.buffers()[i];
+    if (!buf.name().empty()) {
+      size_t* existing_idx = buffer_name_to_index.Find(buf.name());
+      if (existing_idx) {
+        MaybeLogUploadEvent(
+            cfg, uuid,
+            PerfettoStatsdAtom::kTracedEnableTracingDuplicateBufferName);
+        return PERFETTO_SVC_ERR(
+            "Duplicate buffer name \"%s\" at index %zu (first occurrence at "
+            "index %zu)",
+            buf.name().c_str(), i, *existing_idx);
+      }
+      buffer_name_to_index.Insert(buf.name(), i);
+    }
   }
+
   // Check that the config specifies all buffers for its data sources. This
   // is also checked in SetupDataSource, but it is simpler to return a proper
   // error to the consumer from here (and there will be less state to undo).
   for (const TraceConfig::DataSource& cfg_data_source : cfg.data_sources()) {
-    size_t num_buffers = static_cast<size_t>(cfg.buffers_size());
-    size_t target_buffer = cfg_data_source.config().target_buffer();
+    const auto& ds_config = cfg_data_source.config();
+
+    // Resolve target buffer: if target_buffer_name is set, look it up.
+    size_t target_buffer = ds_config.target_buffer();
+    if (!ds_config.target_buffer_name().empty()) {
+      size_t* resolved_index_ptr =
+          buffer_name_to_index.Find(ds_config.target_buffer_name());
+      if (!resolved_index_ptr) {
+        MaybeLogUploadEvent(
+            cfg, uuid, PerfettoStatsdAtom::kTracedEnableTracingOobTargetBuffer);
+        return PERFETTO_SVC_ERR(
+            "Data source \"%s\" specified target_buffer_name \"%s\" which does "
+            "not match any buffer",
+            ds_config.name().c_str(), ds_config.target_buffer_name().c_str());
+      }
+      size_t resolved_index = *resolved_index_ptr;
+
+      // If both target_buffer and target_buffer_name are specified, they must
+      // resolve to the same index. This allows configs to work with both old
+      // and new versions of the tracing service.
+      // We have to be lax on target_buffer = 0, because we shouldn't try to
+      // distinguish between a missing target_buffer and = 0, as per
+      // proto best practices.
+      if (target_buffer > 0 && target_buffer != resolved_index) {
+        MaybeLogUploadEvent(
+            cfg, uuid, PerfettoStatsdAtom::kTracedEnableTracingOobTargetBuffer);
+        return PERFETTO_SVC_ERR(
+            "Data source \"%s\" specified both target_buffer=%zu and "
+            "target_buffer_name=\"%s\" (index %zu) but they don't match",
+            ds_config.name().c_str(), target_buffer,
+            ds_config.target_buffer_name().c_str(), resolved_index);
+      }
+      target_buffer = resolved_index;
+    }
+
     if (target_buffer >= num_buffers) {
       MaybeLogUploadEvent(
           cfg, uuid, PerfettoStatsdAtom::kTracedEnableTracingOobTargetBuffer);
       return PERFETTO_SVC_ERR(
           "Data source \"%s\" specified an out of bounds target_buffer (%zu >= "
           "%zu)",
-          cfg_data_source.config().name().c_str(), target_buffer, num_buffers);
+          ds_config.name().c_str(), target_buffer, num_buffers);
+    }
+  }
+
+  uint32_t current_exclusive_prio = 0;
+  for (const auto& [_, session] : tracing_sessions_) {
+    current_exclusive_prio =
+        std::max(current_exclusive_prio, session.config.exclusive_prio());
+  }
+
+  // If an exclusive session is active, any new session must have a strictly
+  // higher priority.
+  if (current_exclusive_prio > 0 &&
+      current_exclusive_prio >= cfg.exclusive_prio()) {
+    MaybeLogUploadEvent(
+        cfg, uuid,
+        PerfettoStatsdAtom::kTracedEnableTracingExclusiveSessionRejected);
+    return PERFETTO_SVC_ERR(
+        "An exclusive session with priority %u >= requested priority %u is "
+        "already active.",
+        current_exclusive_prio, cfg.exclusive_prio());
+  }
+
+  if (cfg.exclusive_prio() > 0) {  // Exclusive mode.
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+    if (consumer->uid_ != AID_ROOT && consumer->uid_ != AID_SHELL) {
+      MaybeLogUploadEvent(
+          cfg, uuid,
+          PerfettoStatsdAtom::kTracedEnableTracingExclusiveSessionNotAllowed);
+      return PERFETTO_SVC_ERR(
+          "On android, exclusive mode can only be requested by root or shell.");
+    }
+#endif
+    // Abort all existing sessions.
+    const std::string abort_reason =
+        "Aborted due to user requested higher-priority (" +
+        std::to_string(cfg.exclusive_prio()) + ") exclusive session.";
+    for (auto it = tracing_sessions_.begin(); it != tracing_sessions_.end();) {
+      auto next_it = it;
+      ++next_it;
+      const auto session_consumer = it->second.consumer_maybe_null;
+      // FreeBuffers() will complete the teardown of the TracingSession and also
+      // remove it from tracing_sessions_.
+      FreeBuffers(it->first, abort_reason);
+      // Disassociate the consumer from the obsolete tracing session.
+      if (session_consumer) {
+        session_consumer->tracing_session_id_ = 0;
+      }
+      it = next_it;
     }
   }
 
@@ -61257,10 +64457,61 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer,
     }
   }
 
+  if (!cfg.session_semaphores().empty()) {
+    struct SemaphoreSessionsState {
+      uint64_t smallest_max_other_session_count =
+          std::numeric_limits<uint64_t>::max();
+      uint64_t session_count = 0;
+    };
+    // For each semaphore, compute the number of active sessions and the
+    // MIN(limit).
+    std::unordered_map<std::string, SemaphoreSessionsState>
+        sem_to_sessions_state;
+    for (const auto& id_and_session : tracing_sessions_) {
+      const auto& session = id_and_session.second;
+      if (session.state == TracingSession::CLONED_READ_ONLY ||
+          session.state == TracingSession::DISABLED) {
+        // Don't consider cloned or disabled sessions in checks.
+        continue;
+      }
+      for (const auto& sem : session.config.session_semaphores()) {
+        auto& sessions_state = sem_to_sessions_state[sem.name()];
+        sessions_state.smallest_max_other_session_count =
+            std::min(sessions_state.smallest_max_other_session_count,
+                     sem.max_other_session_count());
+        sessions_state.session_count++;
+      }
+    }
+
+    // Check if any of the semaphores declared by the config clashes with any of
+    // the currently active semaphores.
+    for (const auto& semaphore : cfg.session_semaphores()) {
+      auto it = sem_to_sessions_state.find(semaphore.name());
+      if (it == sem_to_sessions_state.end()) {
+        continue;
+      }
+      uint64_t max_other_session_count =
+          std::min(semaphore.max_other_session_count(),
+                   it->second.smallest_max_other_session_count);
+      if (it->second.session_count > max_other_session_count) {
+        MaybeLogUploadEvent(
+            cfg, uuid,
+            PerfettoStatsdAtom::
+                kTracedEnableTracingFailedSessionSemaphoreCheck);
+        return PERFETTO_SVC_ERR(
+            "Semaphore \"%s\" exceeds maximum allowed other session count "
+            "(%" PRIu64 " > min(%" PRIu64 ", %" PRIu64 "))",
+            semaphore.name().c_str(), it->second.session_count,
+            semaphore.max_other_session_count(),
+            it->second.smallest_max_other_session_count);
+      }
+    }
+  }
+
   if (cfg.enable_extra_guardrails()) {
     // unique_session_name can be empty
     const std::string& name = cfg.unique_session_name();
-    int64_t now_s = base::GetBootTimeS().count();
+    int64_t now_s = clock_->GetBootTimeS().count();
 
     // Remove any entries where the time limit has passed so this map doesn't
     // grow indefinitely:
@@ -61294,9 +64545,11 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer,
       }));
 
   int per_uid_limit = kMaxConcurrentTracingSessionsPerUid;
-  if (consumer->uid_ == 1066 /* AID_STATSD*/) {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+  if (consumer->uid_ == AID_STATSD) {
     per_uid_limit = kMaxConcurrentTracingSessionsForStatsdUid;
   }
+#endif
   if (sessions_for_uid >= per_uid_limit) {
     MaybeLogUploadEvent(
         cfg, uuid,
@@ -61324,13 +64577,56 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer,
   std::unique_ptr<protozero::MessageFilter> trace_filter;
   if (cfg.has_trace_filter()) {
     const auto& filt = cfg.trace_filter();
-    const std::string& bytecode = filt.bytecode();
     trace_filter.reset(new protozero::MessageFilter());
+
+    protozero::StringFilter& string_filter = trace_filter->string_filter();
+    auto add_rule = [&](const auto& rule) -> base::Status {
+      auto policy = ConvertPolicy(rule.policy());
+      if (!policy.has_value()) {
+        MaybeLogUploadEvent(
+            cfg, uuid, PerfettoStatsdAtom::kTracedEnableTracingInvalidFilter);
+        return PERFETTO_SVC_ERR(
+            "Trace filter has invalid string filtering rules, aborting");
+      }
+      auto semantic_type = ConvertSemanticTypeMask(rule);
+      if (!semantic_type.has_value()) {
+        MaybeLogUploadEvent(
+            cfg, uuid, PerfettoStatsdAtom::kTracedEnableTracingInvalidFilter);
+        return PERFETTO_SVC_ERR(
+            "Trace filter has invalid semantic types in string filtering "
+            "rules, aborting");
+      }
+      string_filter.AddRule(*policy, rule.regex_pattern(),
+                            rule.atrace_payload_starts_with(), rule.name(),
+                            *semantic_type);
+      return base::OkStatus();
+    };
+
+    // Load base string filter chain.
+    for (const auto& rule : filt.string_filter_chain().rules()) {
+      auto status = add_rule(rule);
+      if (!status.ok())
+        return status;
+    }
+
+    // Load v54 string filter chain. Rules with matching names will replace
+    // existing rules; others will be appended.
+    for (const auto& rule : filt.string_filter_chain_v54().rules()) {
+      auto status = add_rule(rule);
+      if (!status.ok())
+        return status;
+    }
+
+    const std::string& bytecode_v1 = filt.bytecode();
+    const std::string& bytecode_v2 = filt.bytecode_v2();
+    const std::string& bytecode =
+        bytecode_v2.empty() ? bytecode_v1 : bytecode_v2;
     if (!trace_filter->LoadFilterBytecode(bytecode.data(), bytecode.size())) {
       MaybeLogUploadEvent(
           cfg, uuid, PerfettoStatsdAtom::kTracedEnableTracingInvalidFilter);
       return PERFETTO_SVC_ERR("Trace filter bytecode invalid, aborting");
     }
+
     // The filter is created using perfetto.protos.Trace as root message
     // (because that makes it possible to play around with the `proto_filter`
     // tool on actual traces). Here in the service, however, we deal with
@@ -61339,19 +64635,39 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer,
     // for pre-pending the packet preamble (See GetProtoPreamble() calls), but
     // the preamble is not there at ReadBuffer time. Hence we change the root of
     // the filtering to start at the Trace.packet level.
-    uint32_t packet_field_id = TracePacket::kPacketFieldNumber;
-    if (!trace_filter->SetFilterRoot(&packet_field_id, 1)) {
+    if (!trace_filter->SetFilterRoot({TracePacket::kPacketFieldNumber})) {
       MaybeLogUploadEvent(
           cfg, uuid, PerfettoStatsdAtom::kTracedEnableTracingInvalidFilter);
       return PERFETTO_SVC_ERR("Failed to set filter root.");
     }
   }
 
+  std::optional<base::ScopedSchedBoost> priority_boost;
+  if (cfg.has_priority_boost()) {
+    auto sched_policy = CreateSchedPolicyFromConfig(cfg.priority_boost());
+    if (!sched_policy.ok()) {
+      MaybeLogUploadEvent(
+          cfg, uuid,
+          PerfettoStatsdAtom::kTracedEnablePriorityBoostInvalidConfig);
+      return PERFETTO_SVC_ERR("Invalid priority boost config: %s",
+                              sched_policy.status().c_message());
+    }
+    auto boost = base::ScopedSchedBoost::Boost(sched_policy.value());
+    if (!boost.ok()) {
+      MaybeLogUploadEvent(
+          cfg, uuid, PerfettoStatsdAtom::kTracedEnablePriorityBoostOtherError);
+      return PERFETTO_SVC_ERR("Failed to boost priority: %s",
+                              boost.status().c_message());
+    }
+    priority_boost = std::move(*boost);
+  }
+
   const TracingSessionID tsid = ++last_tracing_session_id_;
   TracingSession* tracing_session =
       &tracing_sessions_
            .emplace(std::piecewise_construct, std::forward_as_tuple(tsid),
-                    std::forward_as_tuple(tsid, consumer, cfg, task_runner_))
+                    std::forward_as_tuple(tsid, consumer, cfg,
+                                          weak_runner_.task_runner()))
            .first->second;
 
   tracing_session->trace_uuid = uuid;
@@ -61359,6 +64675,16 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer,
   if (trace_filter)
     tracing_session->trace_filter = std::move(trace_filter);
 
+  if (priority_boost)
+    tracing_session->priority_boost = std::move(priority_boost);
+
+  if (cfg.flush_period_ms() > 0) {
+    tracing_session->flush_strategy = TracingSession::FlushStrategy::kPeriodic;
+    tracing_session->periodic_flush_ms = cfg.flush_period_ms();
+  } else {
+    tracing_session->flush_strategy = TracingSession::FlushStrategy::kDisabled;
+  }
+
   if (cfg.write_into_file()) {
     if (!fd ^ !cfg.output_path().empty()) {
       MaybeLogUploadEvent(
@@ -61384,11 +64710,53 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer,
     uint32_t write_period_ms = cfg.file_write_period_ms();
     if (write_period_ms == 0)
       write_period_ms = kDefaultWriteIntoFilePeriodMs;
-    if (write_period_ms < min_write_period_ms_)
-      write_period_ms = min_write_period_ms_;
+    if (write_period_ms < kMinWriteIntoFilePeriodMs)
+      write_period_ms = kMinWriteIntoFilePeriodMs;
+
+    auto flush_mode = cfg.write_flush_mode();
+    if (flush_mode == TraceConfig::WRITE_FLUSH_AUTO ||
+        flush_mode == TraceConfig::WRITE_FLUSH_UNSPECIFIED) {
+      if (write_period_ms <=
+          static_cast<uint32_t>(kDefaultWriteIntoFilePeriodMs)) {
+        tracing_session->flush_strategy =
+            TracingSession::FlushStrategy::kPeriodic;
+        tracing_session->periodic_flush_ms =
+            static_cast<uint32_t>(kDefaultWriteIntoFilePeriodMs);
+      } else {
+        tracing_session->flush_strategy =
+            TracingSession::FlushStrategy::kOnWrite;
+      }
+
+      if (cfg.flush_period_ms() > 0) {
+        PERFETTO_LOG(
+            "Warning: flush_period_ms is ignored because write_flush_mode is "
+            "in AUTO mode. Set write_flush_mode to WRITE_FLUSH_DISABLED to "
+            "use flush_period_ms.");
+      }
+    } else if (flush_mode == TraceConfig::WRITE_FLUSH_ENABLED) {
+      tracing_session->flush_strategy = TracingSession::FlushStrategy::kOnWrite;
+      if (cfg.flush_period_ms() > 0) {
+        PERFETTO_LOG(
+            "Warning: flush_period_ms is ignored because write_flush_mode is "
+            "in WRITE_FLUSH_ENABLED mode. Set write_flush_mode to "
+            "WRITE_FLUSH_DISABLED to use flush_period_ms.");
+      }
+    }
     tracing_session->write_period_ms = write_period_ms;
     tracing_session->max_file_size_bytes = cfg.max_file_size_bytes();
     tracing_session->bytes_written_into_file = 0;
+    tracing_session->fflush_post_write =
+        cfg.fflush_post_write() == TraceConfig::FFLUSH_ENABLED;
+  }
+
+  if (cfg.compression_type() == TraceConfig::COMPRESSION_TYPE_DEFLATE) {
+    if (init_opts_.compressor_fn) {
+      tracing_session->compress_deflate = true;
+    } else {
+      PERFETTO_LOG(
+          "COMPRESSION_TYPE_DEFLATE is not supported in the current build "
+          "configuration. Skipping compression");
+    }
   }
 
   // Initialize the log buffers.
@@ -61400,7 +64768,6 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer,
   // corresponding BufferID, which is a global ID namespace for the service and
   // all producers.
   size_t total_buf_size_kb = 0;
-  const size_t num_buffers = static_cast<size_t>(cfg.buffers_size());
   tracing_session->buffers_index.reserve(num_buffers);
   for (size_t i = 0; i < num_buffers; i++) {
     const TraceConfig::BufferConfig& buffer_cfg = cfg.buffers()[i];
@@ -61426,8 +64793,19 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer,
         buffer_cfg.fill_policy() == TraceConfig::BufferConfig::DISCARD
             ? TraceBuffer::kDiscard
             : TraceBuffer::kOverwrite;
-    auto it_and_inserted =
-        buffers_.emplace(global_id, TraceBuffer::Create(buf_size, policy));
+    std::unique_ptr<TraceBuffer> new_buffer;
+    switch (buffer_cfg.experimental_mode()) {
+      case TraceConfig::BufferConfig::TRACE_BUFFER_V2:
+        new_buffer = TraceBufferV2::Create(buf_size, policy);
+        break;
+      case TraceConfig::BufferConfig::TRACE_BUFFER_V2_SHADOW_MODE:
+        new_buffer = TraceBufferV1WithV2Shadow::Create(buf_size, policy);
+        break;
+      case TraceConfig::BufferConfig::MODE_UNSPECIFIED:
+        new_buffer = TraceBufferV1::Create(buf_size, policy);
+        break;
+    }
+    auto it_and_inserted = buffers_.emplace(global_id, std::move(new_buffer));
     PERFETTO_DCHECK(it_and_inserted.second);  // buffers_.count(global_id) == 0.
     std::unique_ptr<TraceBuffer>& trace_buffer = it_and_inserted.first->second;
     if (!trace_buffer) {
@@ -61467,7 +64845,7 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer,
     auto range = data_sources_.equal_range(cfg_data_source.config().name());
     for (auto it = range.first; it != range.second; it++) {
       TraceConfig::ProducerConfig producer_config;
-      for (auto& config : cfg.producers()) {
+      for (const auto& config : cfg.producers()) {
         if (GetProducer(it->second.producer_id)->name_ ==
             config.producer_name()) {
           producer_config = config;
@@ -61480,8 +64858,7 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer,
   }
 
   bool has_start_trigger = false;
-  auto weak_this = weak_ptr_factory_.GetWeakPtr();
-  switch (cfg.trigger_config().trigger_mode()) {
+  switch (GetTriggerMode(cfg)) {
     case TraceConfig::TriggerConfig::UNSPECIFIED:
       // no triggers are specified so this isn't a trace that is using triggers.
       PERFETTO_DCHECK(!has_trigger_config);
@@ -61490,14 +64867,12 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer,
       // For traces which use START_TRACE triggers we need to ensure that the
       // tracing session will be cleaned up when it times out.
       has_start_trigger = true;
-      task_runner_->PostDelayedTask(
-          [weak_this, tsid]() {
-            if (weak_this)
-              weak_this->OnStartTriggersTimeout(tsid);
-          },
+      weak_runner_.PostDelayedTask(
+          [tsid, this]() { OnStartTriggersTimeout(tsid); },
           cfg.trigger_config().trigger_timeout_ms());
       break;
     case TraceConfig::TriggerConfig::STOP_TRACING:
+    case TraceConfig::TriggerConfig::CLONE_SNAPSHOT:
       // Update the tracing_session's duration_ms to ensure that if no trigger
       // is received the session will end and be cleaned up equal to the
       // timeout.
@@ -61507,13 +64882,16 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer,
       tracing_session->config.set_duration_ms(
           cfg.trigger_config().trigger_timeout_ms());
       break;
+
+      // The case of unknown modes (coming from future versions of the service)
+      // is handled few lines above (search for TriggerMode_MAX).
   }
 
   tracing_session->state = TracingSession::CONFIGURED;
   PERFETTO_LOG(
       "Configured tracing session %" PRIu64
-      ", #sources:%zu, duration:%d ms%s, #buffers:%d, total "
-      "buffer size:%zu KB, total sessions:%zu, uid:%d session name: \"%s\"",
+      ", #sources:%zu, duration:%u ms%s, #buffers:%d, total "
+      "buffer size:%zu KB, total sessions:%zu, uid:%u session name: \"%s\"",
       tsid, cfg.data_sources().size(), tracing_session->config.duration_ms(),
       tracing_session->config.prefer_suspend_clock_for_duration()
           ? " (suspend_clock)"
@@ -61527,7 +64905,7 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer,
   // TraceConfig.trigger_config(). If both are specified which ever one occurs
   // first will initiate the trace.
   if (!cfg.deferred_start() && !has_start_trigger)
-    return StartTracing(tsid);
+    StartTracing(tsid);
 
   return base::OkStatus();
 }
@@ -61602,6 +64980,14 @@ void TracingServiceImpl::ChangeTraceConfig(ConsumerEndpointImpl* consumer,
     *cfg_data_source.mutable_producer_name_regex_filter() =
         new_producer_name_regex_filter;
 
+    // Get the list of producers that are already set up.
+    std::unordered_set<uint16_t> set_up_producers;
+    auto& ds_instances = tracing_session->data_source_instances;
+    for (auto instance_it = ds_instances.begin();
+         instance_it != ds_instances.end(); ++instance_it) {
+      set_up_producers.insert(instance_it->first);
+    }
+
     // Scan all the registered data sources with a matching name.
     auto range = data_sources_.equal_range(cfg_data_source.config().name());
     for (auto it = range.first; it != range.second; it++) {
@@ -61611,30 +64997,22 @@ void TracingServiceImpl::ChangeTraceConfig(ConsumerEndpointImpl* consumer,
       // Check if the producer name of this data source is present
       // in the name filters. We currently only support new filters, not
       // removing old ones.
-      if (!NameMatchesFilter(producer->name_, new_producer_name_filter,
+      if ((!new_producer_name_filter.empty() ||
+           !new_producer_name_regex_filter.empty()) &&
+          !NameMatchesFilter(producer->name_, new_producer_name_filter,
                              new_producer_name_regex_filter)) {
         continue;
       }
 
-      bool already_setup = false;
-      auto& ds_instances = tracing_session->data_source_instances;
-      for (auto instance_it = ds_instances.begin();
-           instance_it != ds_instances.end(); ++instance_it) {
-        if (instance_it->first == it->second.producer_id &&
-            instance_it->second.data_source_name ==
-                cfg_data_source.config().name()) {
-          already_setup = true;
-          break;
-        }
-      }
-
-      if (already_setup)
+      // If this producer is already set up, we assume that all datasources
+      // in it started already.
+      if (set_up_producers.count(it->second.producer_id))
         continue;
 
       // If it wasn't previously setup, set it up now.
       // (The per-producer config is optional).
       TraceConfig::ProducerConfig producer_config;
-      for (auto& config : tracing_session->config.producers()) {
+      for (const auto& config : tracing_session->config.producers()) {
         if (producer->name_ == config.producer_name()) {
           producer_config = config;
           break;
@@ -61650,14 +65028,21 @@ void TracingServiceImpl::ChangeTraceConfig(ConsumerEndpointImpl* consumer,
   }
 }
 
-base::Status TracingServiceImpl::StartTracing(TracingSessionID tsid) {
+uint32_t TracingServiceImpl::DelayToNextWritePeriodMs(
+    const TracingSession& session) {
+  PERFETTO_DCHECK(session.write_period_ms > 0);
+  return session.write_period_ms -
+         static_cast<uint32_t>(clock_->GetWallTimeMs().count() %
+                               session.write_period_ms);
+}
+
+void TracingServiceImpl::StartTracing(TracingSessionID tsid) {
   PERFETTO_DCHECK_THREAD(thread_checker_);
 
-  auto weak_this = weak_ptr_factory_.GetWeakPtr();
   TracingSession* tracing_session = GetTracingSession(tsid);
   if (!tracing_session) {
-    return PERFETTO_SVC_ERR(
-        "StartTracing() failed, invalid session ID %" PRIu64, tsid);
+    PERFETTO_ELOG("StartTracing() failed, invalid session ID %" PRIu64, tsid);
+    return;
   }
 
   MaybeLogUploadEvent(tracing_session->config, tracing_session->trace_uuid,
@@ -61667,8 +65052,9 @@ base::Status TracingServiceImpl::StartTracing(TracingSessionID tsid) {
     MaybeLogUploadEvent(
         tracing_session->config, tracing_session->trace_uuid,
         PerfettoStatsdAtom::kTracedStartTracingInvalidSessionState);
-    return PERFETTO_SVC_ERR("StartTracing() failed, invalid session state: %d",
-                            tracing_session->state);
+    PERFETTO_ELOG("StartTracing() failed, invalid session state: %d",
+                  tracing_session->state);
+    return;
   }
 
   tracing_session->state = TracingSession::STARTED;
@@ -61682,7 +65068,7 @@ base::Status TracingServiceImpl::StartTracing(TracingSessionID tsid) {
   }
 
   // We don't snapshot the clocks here because we just did this above.
-  SnapshotLifecyleEvent(
+  SnapshotLifecycleEvent(
       tracing_session,
       protos::pbzero::TracingServiceEvent::kTracingStartedFieldNumber,
       false /* snapshot_clocks */);
@@ -61704,10 +65090,7 @@ base::Status TracingServiceImpl::StartTracing(TracingSessionID tsid) {
   snapshot_task_args.use_suspend_aware_timer =
       tracing_session->config.builtin_data_sources()
           .prefer_suspend_clock_for_snapshot();
-  snapshot_task_args.task = [weak_this, tsid] {
-    if (weak_this)
-      weak_this->PeriodicSnapshotTask(tsid);
-  };
+  snapshot_task_args.task = [this, tsid] { PeriodicSnapshotTask(tsid); };
   snapshot_task_args.period_ms =
       tracing_session->config.builtin_data_sources().snapshot_interval_ms();
   if (!snapshot_task_args.period_ms)
@@ -61718,7 +65101,7 @@ base::Status TracingServiceImpl::StartTracing(TracingSessionID tsid) {
   const uint32_t trace_duration_ms = tracing_session->config.duration_ms();
   if (trace_duration_ms > 0) {
     auto stop_task =
-        std::bind(&TracingServiceImpl::StopOnDurationMsExpiry, weak_this, tsid);
+        std::bind(&TracingServiceImpl::StopOnDurationMsExpiry, this, tsid);
     if (tracing_session->config.prefer_suspend_clock_for_duration()) {
       base::PeriodicTask::Args stop_args;
       stop_args.use_suspend_aware_timer = true;
@@ -61727,23 +65110,27 @@ base::Status TracingServiceImpl::StartTracing(TracingSessionID tsid) {
       stop_args.task = std::move(stop_task);
       tracing_session->timed_stop_task.Start(stop_args);
     } else {
-      task_runner_->PostDelayedTask(std::move(stop_task), trace_duration_ms);
+      weak_runner_.PostDelayedTask(std::move(stop_task), trace_duration_ms);
     }
   }  // if (trace_duration_ms > 0).
 
   // Start the periodic drain tasks if we should to save the trace into a file.
   if (tracing_session->config.write_into_file()) {
-    task_runner_->PostDelayedTask(
-        [weak_this, tsid] {
-          if (weak_this)
-            weak_this->ReadBuffersIntoFile(tsid);
+    bool async_flush_buffers_before_read =
+        tracing_session->flush_strategy ==
+        TracingSession::FlushStrategy::kOnWrite;
+    weak_runner_.PostDelayedTask(
+        [this, tsid, async_flush_buffers_before_read] {
+          ReadBuffersIntoFile(tsid, async_flush_buffers_before_read);
         },
-        tracing_session->delay_to_next_write_period_ms());
+        DelayToNextWritePeriodMs(*tracing_session));
   }
 
   // Start the periodic flush tasks if the config specified a flush period.
-  if (tracing_session->config.flush_period_ms())
+  if (tracing_session->flush_strategy ==
+      TracingSession::FlushStrategy::kPeriodic) {
     PeriodicFlushTask(tsid, /*post_next_only=*/true);
+  }
 
   // Start the periodic incremental state clear tasks if the config specified a
   // period.
@@ -61751,10 +65138,8 @@ base::Status TracingServiceImpl::StartTracing(TracingSessionID tsid) {
     PeriodicClearIncrementalStateTask(tsid, /*post_next_only=*/true);
   }
 
-  for (auto& kv : tracing_session->data_source_instances) {
-    ProducerID producer_id = kv.first;
-    DataSourceInstance& data_source = kv.second;
-    ProducerEndpointImpl* producer = GetProducer(producer_id);
+  for (auto& [prod_id, data_source] : tracing_session->data_source_instances) {
+    ProducerEndpointImpl* producer = GetProducer(prod_id);
     if (!producer) {
       PERFETTO_DFATAL("Producer does not exist.");
       continue;
@@ -61763,38 +65148,50 @@ base::Status TracingServiceImpl::StartTracing(TracingSessionID tsid) {
   }
 
   MaybeNotifyAllDataSourcesStarted(tracing_session);
-  return base::OkStatus();
+
+  // `did_notify_all_data_source_started` is only set if a consumer is
+  // connected.
+  if (tracing_session->consumer_maybe_null) {
+    weak_runner_.PostDelayedTask(
+        [this, tsid] { OnAllDataSourceStartedTimeout(tsid); },
+        kAllDataSourceStartedTimeout);
+  }
 }
 
-// static
-void TracingServiceImpl::StopOnDurationMsExpiry(
-    base::WeakPtr<TracingServiceImpl> weak_this,
-    TracingSessionID tsid) {
-  // Skip entirely the flush if the trace session doesn't exist anymore.
-  // This is to prevent misleading error messages to be logged.
-  if (!weak_this)
-    return;
-  auto* tracing_session_ptr = weak_this->GetTracingSession(tsid);
+void TracingServiceImpl::StopOnDurationMsExpiry(TracingSessionID tsid) {
+  auto* tracing_session_ptr = GetTracingSession(tsid);
   if (!tracing_session_ptr)
     return;
   // If this trace was using STOP_TRACING triggers and we've seen
   // one, then the trigger overrides the normal timeout. In this
   // case we just return and let the other task clean up this trace.
-  if (tracing_session_ptr->config.trigger_config().trigger_mode() ==
+  if (GetTriggerMode(tracing_session_ptr->config) ==
           TraceConfig::TriggerConfig::STOP_TRACING &&
       !tracing_session_ptr->received_triggers.empty())
     return;
   // In all other cases (START_TRACING or no triggers) we flush
   // after |trace_duration_ms| unconditionally.
-  weak_this->FlushAndDisableTracing(tsid);
+  FlushAndDisableTracing(tsid);
 }
 
 void TracingServiceImpl::StartDataSourceInstance(
     ProducerEndpointImpl* producer,
     TracingSession* tracing_session,
-    TracingServiceImpl::DataSourceInstance* instance) {
+    DataSourceInstance* instance) {
   PERFETTO_DCHECK(instance->state == DataSourceInstance::CONFIGURED);
-  if (instance->will_notify_on_start) {
+
+  bool start_immediately = !instance->will_notify_on_start;
+
+  if (producer->IsAndroidProcessFrozen()) {
+    PERFETTO_DLOG(
+        "skipping waiting of data source \"%s\" on producer \"%s\" (pid=%d) "
+        "because it is frozen",
+        instance->data_source_name.c_str(), producer->name_.c_str(),
+        static_cast<int>(producer->pid()));
+    start_immediately = true;
+  }
+
+  if (!start_immediately) {
     instance->state = DataSourceInstance::STARTING;
   } else {
     instance->state = DataSourceInstance::STARTED;
@@ -61815,7 +65212,8 @@ void TracingServiceImpl::StartDataSourceInstance(
 // and then drain the buffers. The actual teardown of the TracingSession happens
 // in FreeBuffers().
 void TracingServiceImpl::DisableTracing(TracingSessionID tsid,
-                                        bool disable_immediately) {
+                                        bool disable_immediately,
+                                        const std::string& error) {
   PERFETTO_DCHECK_THREAD(thread_checker_);
   TracingSession* tracing_session = GetTracingSession(tsid);
   if (!tracing_session) {
@@ -61825,9 +65223,6 @@ void TracingServiceImpl::DisableTracing(TracingSessionID tsid,
     return;
   }
 
-  MaybeLogUploadEvent(tracing_session->config, tracing_session->trace_uuid,
-                      PerfettoStatsdAtom::kTracedDisableTracing);
-
   switch (tracing_session->state) {
     // Spurious call to DisableTracing() while already disabled, nothing to do.
     case TracingSession::DISABLED:
@@ -61835,7 +65230,6 @@ void TracingServiceImpl::DisableTracing(TracingSessionID tsid,
       return;
 
     case TracingSession::CLONED_READ_ONLY:
-      PERFETTO_DLOG("DisableTracing() cannot be called on a cloned session");
       return;
 
     // This is either:
@@ -61848,7 +65242,7 @@ void TracingServiceImpl::DisableTracing(TracingSessionID tsid,
     case TracingSession::DISABLING_WAITING_STOP_ACKS:
       PERFETTO_DCHECK(!tracing_session->AllDataSourceInstancesStopped());
       if (disable_immediately)
-        DisableTracingNotifyConsumerAndFlushFile(tracing_session);
+        DisableTracingNotifyConsumerAndFlushFile(tracing_session, error);
       return;
 
     // Continues below.
@@ -61860,6 +65254,21 @@ void TracingServiceImpl::DisableTracing(TracingSessionID tsid,
 
     // This is the nominal case, continues below.
     case TracingSession::STARTED:
+      // Log the disable tracing event only when the session was actually
+      // started. This avoids double-logging in scenarios where DisableTracing
+      // is called multiple times for the same session. A common case is with
+      // traces that have a timeout (e.g. using `trigger_timeout_ms`):
+      // 1. The service's timer expires and it calls `DisableTracing`
+      // internally.
+      // 2. The service notifies the consumer (e.g. `perfetto_cmd`) that the
+      //    trace has ended.
+      // 3. The consumer, as part of its cleanup, calls `FreeBuffers()`.
+      // 4. `FreeBuffers()` on the service-side calls `DisableTracing()` again
+      //    as a safeguard.
+      // By logging only when transitioning from the `STARTED` state, we ensure
+      // we only log the effective disable event.
+      MaybeLogUploadEvent(tracing_session->config, tracing_session->trace_uuid,
+                          PerfettoStatsdAtom::kTracedDisableTracing);
       break;
   }
 
@@ -61885,16 +65294,11 @@ void TracingServiceImpl::DisableTracing(TracingSessionID tsid,
   // the session as disabled immediately, notify the consumer and flush the
   // trace file (if used).
   if (tracing_session->AllDataSourceInstancesStopped())
-    return DisableTracingNotifyConsumerAndFlushFile(tracing_session);
+    return DisableTracingNotifyConsumerAndFlushFile(tracing_session, error);
 
   tracing_session->state = TracingSession::DISABLING_WAITING_STOP_ACKS;
-  auto weak_this = weak_ptr_factory_.GetWeakPtr();
-  task_runner_->PostDelayedTask(
-      [weak_this, tsid] {
-        if (weak_this)
-          weak_this->OnDisableTracingTimeout(tsid);
-      },
-      tracing_session->data_source_stop_timeout_ms());
+  weak_runner_.PostDelayedTask([this, tsid] { OnDisableTracingTimeout(tsid); },
+                               tracing_session->data_source_stop_timeout_ms());
 
   // Deliberately NOT removing the session from |tracing_session_|, it's still
   // needed to call ReadBuffers(). FreeBuffers() will erase() the session.
@@ -61936,6 +65340,54 @@ void TracingServiceImpl::NotifyDataSourceStarted(
   }  // for (tracing_session)
 }
 
+void TracingServiceImpl::OnAllDataSourceStartedTimeout(TracingSessionID tsid) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  TracingSession* tracing_session = GetTracingSession(tsid);
+  // It would be possible to check for `AllDataSourceInstancesStarted()` here,
+  // but it doesn't make much sense, because a data source can be registered
+  // after the session has started. Therefore this is tied to
+  // `did_notify_all_data_source_started`: if that notification happened, do not
+  // record slow data sources.
+  if (!tracing_session || !tracing_session->consumer_maybe_null ||
+      tracing_session->did_notify_all_data_source_started) {
+    return;
+  }
+
+  int64_t timestamp = clock_->GetBootTimeNs().count();
+
+  protozero::HeapBuffered<protos::pbzero::TracePacket> packet;
+  packet->set_timestamp(static_cast<uint64_t>(timestamp));
+  packet->set_trusted_uid(static_cast<int32_t>(uid_));
+  packet->set_trusted_packet_sequence_id(kServicePacketSequenceID);
+
+  size_t i = 0;
+  protos::pbzero::TracingServiceEvent::DataSources* slow_data_sources =
+      packet->set_service_event()->set_slow_starting_data_sources();
+  for (const auto& [producer_id, ds_instance] :
+       tracing_session->data_source_instances) {
+    if (ds_instance.state == DataSourceInstance::STARTED) {
+      continue;
+    }
+    ProducerEndpointImpl* producer = GetProducer(producer_id);
+    if (!producer) {
+      continue;
+    }
+    if (++i > kMaxLifecycleEventsListedDataSources) {
+      break;
+    }
+    auto* ds = slow_data_sources->add_data_source();
+    ds->set_producer_name(producer->name_);
+    ds->set_data_source_name(ds_instance.data_source_name);
+    PERFETTO_LOG(
+        "Data source failed to start within 20s data_source=\"%s\", "
+        "producer=\"%s\", tsid=%" PRIu64,
+        ds_instance.data_source_name.c_str(), producer->name_.c_str(), tsid);
+  }
+
+  tracing_session->slow_start_event = TracingSession::ArbitraryLifecycleEvent{
+      timestamp, packet.SerializeAsArray()};
+}
+
 void TracingServiceImpl::MaybeNotifyAllDataSourcesStarted(
     TracingSession* tracing_session) {
   if (!tracing_session->consumer_maybe_null)
@@ -61957,7 +65409,7 @@ void TracingServiceImpl::MaybeNotifyAllDataSourcesStarted(
 
   PERFETTO_DLOG("All data sources started");
 
-  SnapshotLifecyleEvent(
+  SnapshotLifecycleEvent(
       tracing_session,
       protos::pbzero::TracingServiceEvent::kAllDataSourcesStartedFieldNumber,
       true /* snapshot_clocks */);
@@ -62011,16 +65463,19 @@ void TracingServiceImpl::ActivateTriggers(
   auto* producer = GetProducer(producer_id);
   PERFETTO_DCHECK(producer);
 
-  int64_t now_ns = base::GetBootTimeNs().count();
+  int64_t now_ns = clock_->GetBootTimeNs().count();
   for (const auto& trigger_name : triggers) {
     PERFETTO_DLOG("Received ActivateTriggers request for \"%s\"",
                   trigger_name.c_str());
-    base::Hasher hash;
+    android_stats::MaybeLogTriggerEvent(PerfettoTriggerAtom::kTracedTrigger,
+                                        /* trace_uuid_lsb */ 0, trigger_name);
+
+    base::FnvHasher hash;
     hash.Update(trigger_name.c_str(), trigger_name.size());
     std::string triggered_session_name;
     base::Uuid triggered_session_uuid;
     TracingSessionID triggered_session_id = 0;
-    int trigger_mode = 0;
+    auto trigger_mode = TraceConfig::TriggerConfig::UNSPECIFIED;
 
     uint64_t trigger_name_hash = hash.digest();
     size_t count_in_window =
@@ -62054,13 +65509,10 @@ void TracingServiceImpl::ActivateTriggers(
 
       // Use a random number between 0 and 1 to check if we should allow this
       // trigger through or not.
-      double trigger_rnd =
-          trigger_rnd_override_for_testing_ > 0
-              ? trigger_rnd_override_for_testing_
-              : trigger_probability_dist_(trigger_probability_rand_);
+      double trigger_rnd = random_->GetValue();
       PERFETTO_DCHECK(trigger_rnd >= 0 && trigger_rnd < 1);
       if (trigger_rnd < iter->skip_probability()) {
-        MaybeLogTriggerEvent(tracing_session.config,
+        MaybeLogTriggerEvent(tracing_session.config, tracing_session.trace_uuid,
                              PerfettoTriggerAtom::kTracedLimitProbability,
                              trigger_name);
         continue;
@@ -62069,7 +65521,7 @@ void TracingServiceImpl::ActivateTriggers(
       // If we already triggered more times than the limit, silently ignore
       // this trigger.
       if (iter->max_per_24_h() > 0 && count_in_window >= iter->max_per_24_h()) {
-        MaybeLogTriggerEvent(tracing_session.config,
+        MaybeLogTriggerEvent(tracing_session.config, tracing_session.trace_uuid,
                              PerfettoTriggerAtom::kTracedLimitMaxPer24h,
                              trigger_name);
         continue;
@@ -62079,16 +65531,16 @@ void TracingServiceImpl::ActivateTriggers(
       triggered_session_name = tracing_session.config.unique_session_name();
       triggered_session_uuid.set_lsb_msb(tracing_session.trace_uuid.lsb(),
                                          tracing_session.trace_uuid.msb());
-      trigger_mode = static_cast<int>(
-          tracing_session.config.trigger_config().trigger_mode());
+      trigger_mode = GetTriggerMode(tracing_session.config);
 
       const bool triggers_already_received =
           !tracing_session.received_triggers.empty();
-      tracing_session.received_triggers.push_back(
-          {static_cast<uint64_t>(now_ns), iter->name(), producer->name_,
-           producer->uid_});
-      auto weak_this = weak_ptr_factory_.GetWeakPtr();
-      switch (tracing_session.config.trigger_config().trigger_mode()) {
+      const TriggerInfo trigger = {static_cast<uint64_t>(now_ns), iter->name(),
+                                   producer->name_, producer->uid(),
+                                   iter->stop_delay_ms()};
+      MaybeSnapshotClocksIntoRingBuffer(&tracing_session);
+      tracing_session.received_triggers.push_back(trigger);
+      switch (trigger_mode) {
         case TraceConfig::TriggerConfig::START_TRACING:
           // If the session has already been triggered and moved past
           // CONFIGURED then we don't need to repeat StartTracing. This would
@@ -62123,18 +65575,34 @@ void TracingServiceImpl::ActivateTriggers(
 
           // Now that we've seen a trigger we need to stop, flush, and disable
           // this session after the configured |stop_delay_ms|.
-          task_runner_->PostDelayedTask(
-              [weak_this, tsid] {
+          weak_runner_.PostDelayedTask(
+              [this, tsid] {
                 // Skip entirely the flush if the trace session doesn't exist
                 // anymore. This is to prevent misleading error messages to be
                 // logged.
-                if (weak_this && weak_this->GetTracingSession(tsid))
-                  weak_this->FlushAndDisableTracing(tsid);
+                if (GetTracingSession(tsid))
+                  FlushAndDisableTracing(tsid);
               },
               // If this trigger is zero this will immediately executable and
               // will happen shortly.
               iter->stop_delay_ms());
           break;
+
+        case TraceConfig::TriggerConfig::CLONE_SNAPSHOT:
+          trigger_activated = true;
+          MaybeLogUploadEvent(
+              tracing_session.config, tracing_session.trace_uuid,
+              PerfettoStatsdAtom::kTracedTriggerCloneSnapshot, iter->name());
+          weak_runner_.PostDelayedTask(
+              [this, tsid, trigger] {
+                auto* tsess = GetTracingSession(tsid);
+                if (!tsess || !tsess->consumer_maybe_null)
+                  return;
+                tsess->consumer_maybe_null->NotifyCloneSnapshotTrigger(trigger);
+              },
+              iter->stop_delay_ms());
+          break;
+
         case TraceConfig::TriggerConfig::UNSPECIFIED:
           PERFETTO_ELOG("Trigger activated but trigger mode unspecified.");
           break;
@@ -62176,7 +65644,8 @@ void TracingServiceImpl::OnDisableTracingTimeout(TracingSessionID tsid) {
 }
 
 void TracingServiceImpl::DisableTracingNotifyConsumerAndFlushFile(
-    TracingSession* tracing_session) {
+    TracingSession* tracing_session,
+    const std::string& error) {
   PERFETTO_DCHECK(tracing_session->state != TracingSession::DISABLED);
   for (auto& inst_kv : tracing_session->data_source_instances) {
     if (inst_kv.second.state == DataSourceInstance::STOPPED)
@@ -62195,31 +65664,29 @@ void TracingServiceImpl::DisableTracingNotifyConsumerAndFlushFile(
   for (auto& producer_id_and_producer : producers_)
     ScrapeSharedMemoryBuffers(tracing_session, producer_id_and_producer.second);
 
-  SnapshotLifecyleEvent(
+  SnapshotLifecycleEvent(
       tracing_session,
       protos::pbzero::TracingServiceEvent::kTracingDisabledFieldNumber,
       true /* snapshot_clocks */);
 
   if (tracing_session->write_into_file) {
     tracing_session->write_period_ms = 0;
-    ReadBuffersIntoFile(tracing_session->id);
-  }
-
-  if (tracing_session->on_disable_callback_for_bugreport) {
-    std::move(tracing_session->on_disable_callback_for_bugreport)();
-    tracing_session->on_disable_callback_for_bugreport = nullptr;
+    // Buffers are scraped, no need to flush before reading into file.
+    ReadBuffersIntoFile(tracing_session->id,
+                        /* async_flush_buffers_before_read = */ false);
   }
 
   MaybeLogUploadEvent(tracing_session->config, tracing_session->trace_uuid,
                       PerfettoStatsdAtom::kTracedNotifyTracingDisabled);
 
   if (tracing_session->consumer_maybe_null)
-    tracing_session->consumer_maybe_null->NotifyOnTracingDisabled("");
+    tracing_session->consumer_maybe_null->NotifyOnTracingDisabled(error);
 }
 
 void TracingServiceImpl::Flush(TracingSessionID tsid,
                                uint32_t timeout_ms,
-                               ConsumerEndpoint::FlushCallback callback) {
+                               ConsumerEndpoint::FlushCallback callback,
+                               FlushFlags flush_flags) {
   PERFETTO_DCHECK_THREAD(thread_checker_);
   TracingSession* tracing_session = GetTracingSession(tsid);
   if (!tracing_session) {
@@ -62227,6 +65694,40 @@ void TracingServiceImpl::Flush(TracingSessionID tsid,
     return;
   }
 
+  SnapshotLifecycleEvent(
+      tracing_session,
+      protos::pbzero::TracingServiceEvent::kFlushStartedFieldNumber,
+      false /* snapshot_clocks */);
+
+  std::map<ProducerID, std::vector<DataSourceInstanceID>> data_source_instances;
+  for (const auto& [producer_id, ds_inst] :
+       tracing_session->data_source_instances) {
+    if (!ds_inst.no_flush) {
+      data_source_instances[producer_id].push_back(ds_inst.instance_id);
+      continue;
+    }
+    ProducerEndpointImpl* producer = GetProducer(producer_id);
+    if (producer->smb_scraping_enabled_ && producer->IsShmemEmulated()) {
+      // Remote producers (connected via traced_relay) don't share buffer memory
+      // with the tracing service, therefore we NEED to trigger a flush request
+      // so that the producer can self-scrape their emulated SMB. Trigger the
+      // flush by inserting an empty vector if the producer not in the map
+      // already. See RFC-0010.
+      data_source_instances.try_emplace(producer_id);
+    }
+  }
+  FlushDataSourceInstances(tracing_session, timeout_ms, data_source_instances,
+                           std::move(callback), flush_flags);
+}
+
+void TracingServiceImpl::FlushDataSourceInstances(
+    TracingSession* tracing_session,
+    uint32_t timeout_ms,
+    const std::map<ProducerID, std::vector<DataSourceInstanceID>>&
+        data_source_instances,
+    ConsumerEndpoint::FlushCallback callback,
+    FlushFlags flush_flags) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
   if (!timeout_ms)
     timeout_ms = tracing_session->flush_timeout_ms();
 
@@ -62238,11 +65739,13 @@ void TracingServiceImpl::Flush(TracingSessionID tsid,
   }
 
   if (tracing_session->state != TracingSession::STARTED) {
-    PERFETTO_ELOG("Flush() called, but tracing has not been started");
+    PERFETTO_LOG("Flush() called, but tracing has not been started");
     callback(false);
     return;
   }
 
+  tracing_session->last_flush_events.clear();
+
   ++tracing_session->flushes_requested;
   FlushRequestID flush_request_id = ++last_flush_request_id_;
   PendingFlush& pending_flush =
@@ -62254,31 +65757,28 @@ void TracingServiceImpl::Flush(TracingSessionID tsid,
   // Send a flush request to each producer involved in the tracing session. In
   // order to issue a flush request we have to build a map of all data source
   // instance ids enabled for each producer.
-  std::map<ProducerID, std::vector<DataSourceInstanceID>> flush_map;
-  for (const auto& data_source_inst : tracing_session->data_source_instances) {
-    const ProducerID producer_id = data_source_inst.first;
-    const DataSourceInstanceID ds_inst_id = data_source_inst.second.instance_id;
-    flush_map[producer_id].push_back(ds_inst_id);
-  }
 
-  for (const auto& kv : flush_map) {
-    ProducerID producer_id = kv.first;
+  for (const auto& [producer_id, data_sources] : data_source_instances) {
     ProducerEndpointImpl* producer = GetProducer(producer_id);
-    const std::vector<DataSourceInstanceID>& data_sources = kv.second;
-    producer->Flush(flush_request_id, data_sources);
-    pending_flush.producers.insert(producer_id);
+    producer->Flush(flush_request_id, data_sources, flush_flags);
+    if (!producer->IsAndroidProcessFrozen()) {
+      pending_flush.producers.insert(producer_id);
+    } else {
+      PERFETTO_DLOG(
+          "skipping waiting flush for on producer \"%s\" (pid=%" PRIu32
+          ") because it is frozen",
+          producer->name_.c_str(), static_cast<uint32_t>(producer->pid()));
+    }
   }
 
   // If there are no producers to flush (realistically this happens only in
   // some tests) fire OnFlushTimeout() straight away, without waiting.
-  if (flush_map.empty())
+  if (data_source_instances.empty())
     timeout_ms = 0;
 
-  auto weak_this = weak_ptr_factory_.GetWeakPtr();
-  task_runner_->PostDelayedTask(
-      [weak_this, tsid, flush_request_id] {
-        if (weak_this)
-          weak_this->OnFlushTimeout(tsid, flush_request_id);
+  weak_runner_.PostDelayedTask(
+      [this, tsid = tracing_session->id, flush_request_id, flush_flags] {
+        OnFlushTimeout(tsid, flush_request_id, flush_flags);
       },
       timeout_ms);
 }
@@ -62294,25 +65794,23 @@ void TracingServiceImpl::NotifyFlushDoneForProducer(
       PendingFlush& pending_flush = it->second;
       pending_flush.producers.erase(producer_id);
       if (pending_flush.producers.empty()) {
-        auto weak_this = weak_ptr_factory_.GetWeakPtr();
         TracingSessionID tsid = kv.first;
         auto callback = std::move(pending_flush.callback);
-        task_runner_->PostTask([weak_this, tsid, callback]() {
-          if (weak_this) {
-            weak_this->CompleteFlush(tsid, std::move(callback),
-                                     /*success=*/true);
-          }
+        weak_runner_.PostTask([this, tsid, callback = std::move(callback)]() {
+          CompleteFlush(tsid, std::move(callback),
+                        /*success=*/true);
         });
         it = pending_flushes.erase(it);
       } else {
         it++;
       }
     }  // for (pending_flushes)
-  }    // for (tracing_session)
+  }  // for (tracing_session)
 }
 
 void TracingServiceImpl::OnFlushTimeout(TracingSessionID tsid,
-                                        FlushRequestID flush_request_id) {
+                                        FlushRequestID flush_request_id,
+                                        FlushFlags flush_flags) {
   TracingSession* tracing_session = GetTracingSession(tsid);
   if (!tracing_session)
     return;
@@ -62320,9 +65818,51 @@ void TracingServiceImpl::OnFlushTimeout(TracingSessionID tsid,
   if (it == tracing_session->pending_flushes.end())
     return;  // Nominal case: flush was completed and acked on time.
 
+  PendingFlush& pending_flush = it->second;
+
   // If there were no producers to flush, consider it a success.
-  bool success = it->second.producers.empty();
-  auto callback = std::move(it->second.callback);
+  bool success = pending_flush.producers.empty();
+  auto callback = std::move(pending_flush.callback);
+  // If flush failed and this is a "final" flush, log which data sources were
+  // slow.
+  if ((flush_flags.reason() == FlushFlags::Reason::kTraceClone ||
+       flush_flags.reason() == FlushFlags::Reason::kTraceStop) &&
+      !success) {
+    int64_t timestamp = clock_->GetBootTimeNs().count();
+
+    protozero::HeapBuffered<protos::pbzero::TracePacket> packet;
+    packet->set_timestamp(static_cast<uint64_t>(timestamp));
+    packet->set_trusted_uid(static_cast<int32_t>(uid_));
+    packet->set_trusted_packet_sequence_id(kServicePacketSequenceID);
+
+    size_t i = 0;
+    protos::pbzero::TracingServiceEvent::DataSources* event =
+        packet->set_service_event()->set_last_flush_slow_data_sources();
+    for (const auto& producer_id : pending_flush.producers) {
+      ProducerEndpointImpl* producer = GetProducer(producer_id);
+      if (!producer) {
+        continue;
+      }
+      if (++i > kMaxLifecycleEventsListedDataSources) {
+        break;
+      }
+
+      auto ds_id_range =
+          tracing_session->data_source_instances.equal_range(producer_id);
+      for (auto ds_it = ds_id_range.first; ds_it != ds_id_range.second;
+           ds_it++) {
+        auto* ds = event->add_data_source();
+        ds->set_producer_name(producer->name_);
+        ds->set_data_source_name(ds_it->second.data_source_name);
+        if (++i > kMaxLifecycleEventsListedDataSources) {
+          break;
+        }
+      }
+    }
+
+    tracing_session->last_flush_events.push_back(
+        {timestamp, packet.SerializeAsArray()});
+  }
   tracing_session->pending_flushes.erase(it);
   CompleteFlush(tsid, std::move(callback), success);
 }
@@ -62341,7 +65881,7 @@ void TracingServiceImpl::CompleteFlush(TracingSessionID tsid,
   for (auto& producer_id_and_producer : producers_) {
     ScrapeSharedMemoryBuffers(tracing_session, producer_id_and_producer.second);
   }
-  SnapshotLifecyleEvent(
+  SnapshotLifecycleEvent(
       tracing_session,
       protos::pbzero::TracingServiceEvent::kAllDataSourcesFlushedFieldNumber,
       true /* snapshot_clocks */);
@@ -62354,7 +65894,7 @@ void TracingServiceImpl::CompleteFlush(TracingSessionID tsid,
 void TracingServiceImpl::ScrapeSharedMemoryBuffers(
     TracingSession* tracing_session,
     ProducerEndpointImpl* producer) {
-  if (!producer->smb_scraping_enabled_)
+  if (!producer->smb_scraping_enabled_ || producer->IsShmemEmulated())
     return;
 
   // Can't copy chunks if we don't know about any trace writers.
@@ -62363,7 +65903,7 @@ void TracingServiceImpl::ScrapeSharedMemoryBuffers(
 
   // Performance optimization: On flush or session disconnect, this method is
   // called for each producer. If the producer doesn't participate in the
-  // session, there's no need to scape its chunks right now. We can tell if a
+  // session, there's no need to scrape its chunks right now. We can tell if a
   // producer participates in the session by checking if the producer is allowed
   // to write into the session's log buffers.
   const auto& session_buffers = tracing_session->buffers_index;
@@ -62379,18 +65919,18 @@ void TracingServiceImpl::ScrapeSharedMemoryBuffers(
 
   // Find and copy any uncommitted chunks from the SMB.
   //
-  // In nominal conditions, the page layout of the used SMB pages should never
-  // change because the service is the only one who is supposed to modify used
-  // pages (to make them free again).
+  // In nominal conditions, the page header bitmap of the used SMB pages should
+  // never change because the service is the only one who is supposed to modify
+  // used pages (to make them free again).
   //
   // However, the code here needs to deal with the case of a malicious producer
   // altering the SMB in unpredictable ways. Thankfully the SMB size is
   // immutable, so a chunk will always point to some valid memory, even if the
   // producer alters the intended layout and chunk header concurrently.
-  // Ultimately a malicious producer altering the SMB's chunk layout while we
-  // are iterating in this function is not any different from the case of a
-  // malicious producer asking to commit a chunk made of random data, which is
-  // something this class has to deal with regardless.
+  // Ultimately a malicious producer altering the SMB's chunk header bitamp
+  // while we are iterating in this function is not any different from the case
+  // of a malicious producer asking to commit a chunk made of random data,
+  // which is something this class has to deal with regardless.
   //
   // The only legitimate mutations that can happen from sane producers,
   // concurrently to this function, are:
@@ -62398,101 +65938,66 @@ void TracingServiceImpl::ScrapeSharedMemoryBuffers(
   //   B. free chunks being migrated to kChunkBeingWritten,
   //   C. kChunkBeingWritten chunks being migrated to kChunkCompleted.
 
-  SharedMemoryABI* abi = &producer->shmem_abi_;
-  // num_pages() is immutable after the SMB is initialized and cannot be changed
-  // even by a producer even if malicious.
-  for (size_t page_idx = 0; page_idx < abi->num_pages(); page_idx++) {
-    uint32_t layout = abi->GetPageLayout(page_idx);
-
-    uint32_t used_chunks = abi->GetUsedChunks(layout);  // Returns a bitmap.
-    // Skip empty pages.
-    if (used_chunks == 0)
-      continue;
-
-    // Scrape the chunks that are currently used. These should be either in
-    // state kChunkBeingWritten or kChunkComplete.
-    for (uint32_t chunk_idx = 0; used_chunks; chunk_idx++, used_chunks >>= 1) {
-      if (!(used_chunks & 1))
-        continue;
-
-      SharedMemoryABI::ChunkState state =
-          SharedMemoryABI::GetChunkStateFromLayout(layout, chunk_idx);
-      PERFETTO_DCHECK(state == SharedMemoryABI::kChunkBeingWritten ||
-                      state == SharedMemoryABI::kChunkComplete);
-      bool chunk_complete = state == SharedMemoryABI::kChunkComplete;
-
-      SharedMemoryABI::Chunk chunk =
-          abi->GetChunkUnchecked(page_idx, layout, chunk_idx);
-
-      uint16_t packet_count;
-      uint8_t flags;
-      // GetPacketCountAndFlags has acquire_load semantics.
-      std::tie(packet_count, flags) = chunk.GetPacketCountAndFlags();
-
-      // It only makes sense to copy an incomplete chunk if there's at least
-      // one full packet available. (The producer may not have completed the
-      // last packet in it yet, so we need at least 2.)
-      if (!chunk_complete && packet_count < 2)
-        continue;
-
-      // At this point, it is safe to access the remaining header fields of
-      // the chunk. Even if the chunk was only just transferred from
-      // kChunkFree into kChunkBeingWritten state, the header should be
-      // written completely once the packet count increased above 1 (it was
-      // reset to 0 by the service when the chunk was freed).
-
-      WriterID writer_id = chunk.writer_id();
-      base::Optional<BufferID> target_buffer_id =
-          producer->buffer_id_for_writer(writer_id);
-
-      // We can only scrape this chunk if we know which log buffer to copy it
-      // into.
-      if (!target_buffer_id)
-        continue;
+  SharedMemoryArbiterImpl::ForEachScrapableChunk(
+      &producer->shmem_abi_,
+      [&](SharedMemoryABI::Chunk* chunk, bool chunk_complete,
+          uint16_t packet_count, uint8_t packet_flags) {
+        WriterID writer_id = chunk->writer_id();
+        std::optional<BufferID> target_buffer_id =
+            producer->buffer_id_for_writer(writer_id);
+
+        // We can only scrape this chunk if we know which log buffer to copy it
+        // into.
+        if (!target_buffer_id)
+          return;
 
-      // Skip chunks that don't belong to the requested tracing session.
-      bool target_buffer_belongs_to_session =
-          std::find(session_buffers.begin(), session_buffers.end(),
-                    *target_buffer_id) != session_buffers.end();
-      if (!target_buffer_belongs_to_session)
-        continue;
+        // Skip chunks that don't belong to the requested tracing session.
+        bool target_buffer_belongs_to_session =
+            std::find(session_buffers.begin(), session_buffers.end(),
+                      *target_buffer_id) != session_buffers.end();
+        if (!target_buffer_belongs_to_session)
+          return;
 
-      uint32_t chunk_id =
-          chunk.header()->chunk_id.load(std::memory_order_relaxed);
+        uint32_t chunk_id =
+            chunk->header()->chunk_id.load(std::memory_order_relaxed);
 
-      CopyProducerPageIntoLogBuffer(
-          producer->id_, producer->uid_, producer->pid_, writer_id, chunk_id,
-          *target_buffer_id, packet_count, flags, chunk_complete,
-          chunk.payload_begin(), chunk.payload_size());
-    }
-  }
+        CopyProducerPageIntoLogBuffer(
+            producer->id_, producer->client_identity_, writer_id, chunk_id,
+            *target_buffer_id, packet_count, packet_flags, chunk_complete,
+            chunk->payload_begin(), chunk->payload_size());
+      });
 }
 
 void TracingServiceImpl::FlushAndDisableTracing(TracingSessionID tsid) {
   PERFETTO_DCHECK_THREAD(thread_checker_);
   PERFETTO_DLOG("Triggering final flush for %" PRIu64, tsid);
-  auto weak_this = weak_ptr_factory_.GetWeakPtr();
-  Flush(tsid, 0, [weak_this, tsid](bool success) {
-    // This was a DLOG up to Jun 2021 (v16, Android S).
-    PERFETTO_LOG("FlushAndDisableTracing(%" PRIu64 ") done, success=%d", tsid,
-                 success);
-    if (!weak_this)
-      return;
-    TracingSession* session = weak_this->GetTracingSession(tsid);
-    session->final_flush_outcome = success ? TraceStats::FINAL_FLUSH_SUCCEEDED
+  Flush(
+      tsid, 0,
+      [this, tsid](bool success) {
+        // This was a DLOG up to Jun 2021 (v16, Android S).
+        PERFETTO_LOG("FlushAndDisableTracing(%" PRIu64 ") done, success=%d",
+                     tsid, success);
+        TracingSession* session = GetTracingSession(tsid);
+        if (!session) {
+          return;
+        }
+        session->final_flush_outcome = success
+                                           ? TraceStats::FINAL_FLUSH_SUCCEEDED
                                            : TraceStats::FINAL_FLUSH_FAILED;
-    if (session->consumer_maybe_null) {
-      // If the consumer is still attached, just disable the session but give it
-      // a chance to read the contents.
-      weak_this->DisableTracing(tsid);
-    } else {
-      // If the consumer detached, destroy the session. If the consumer did
-      // start the session in long-tracing mode, the service will have saved
-      // the contents to the passed file. If not, the contents will be
-      // destroyed.
-      weak_this->FreeBuffers(tsid);
-    }
-  });
+        if (session->consumer_maybe_null) {
+          // If the consumer is still attached, just disable the session but
+          // give it a chance to read the contents.
+          DisableTracing(tsid);
+        } else {
+          // If the consumer detached, destroy the session. If the consumer did
+          // start the session in long-tracing mode, the service will have saved
+          // the contents to the passed file. If not, the contents will be
+          // destroyed.
+          FreeBuffers(tsid);
+        }
+      },
+      FlushFlags(FlushFlags::Initiator::kTraced,
+                 FlushFlags::Reason::kTraceStop));
 }
 
 void TracingServiceImpl::PeriodicFlushTask(TracingSessionID tsid,
@@ -62502,24 +66007,26 @@ void TracingServiceImpl::PeriodicFlushTask(TracingSessionID tsid,
   if (!tracing_session || tracing_session->state != TracingSession::STARTED)
     return;
 
-  uint32_t flush_period_ms = tracing_session->config.flush_period_ms();
-  auto weak_this = weak_ptr_factory_.GetWeakPtr();
-  task_runner_->PostDelayedTask(
-      [weak_this, tsid] {
-        if (weak_this)
-          weak_this->PeriodicFlushTask(tsid, /*post_next_only=*/false);
-      },
-      flush_period_ms - static_cast<uint32_t>(base::GetWallTimeMs().count() %
+  PERFETTO_CHECK(tracing_session->flush_strategy ==
+                 TracingSession::FlushStrategy::kPeriodic);
+  uint32_t flush_period_ms = tracing_session->periodic_flush_ms;
+  weak_runner_.PostDelayedTask(
+      [this, tsid] { PeriodicFlushTask(tsid, /*post_next_only=*/false); },
+      flush_period_ms - static_cast<uint32_t>(clock_->GetWallTimeMs().count() %
                                               flush_period_ms));
 
   if (post_next_only)
     return;
 
   PERFETTO_DLOG("Triggering periodic flush for trace session %" PRIu64, tsid);
-  Flush(tsid, 0, [](bool success) {
-    if (!success)
-      PERFETTO_ELOG("Periodic flush timed out");
-  });
+  Flush(
+      tsid, 0,
+      [](bool success) {
+        if (!success)
+          PERFETTO_ELOG("Periodic flush timed out");
+      },
+      FlushFlags(FlushFlags::Initiator::kTraced,
+                 FlushFlags::Reason::kPeriodic));
 }
 
 void TracingServiceImpl::PeriodicClearIncrementalStateTask(
@@ -62532,14 +66039,11 @@ void TracingServiceImpl::PeriodicClearIncrementalStateTask(
 
   uint32_t clear_period_ms =
       tracing_session->config.incremental_state_config().clear_period_ms();
-  auto weak_this = weak_ptr_factory_.GetWeakPtr();
-  task_runner_->PostDelayedTask(
-      [weak_this, tsid] {
-        if (weak_this)
-          weak_this->PeriodicClearIncrementalStateTask(
-              tsid, /*post_next_only=*/false);
+  weak_runner_.PostDelayedTask(
+      [this, tsid] {
+        PeriodicClearIncrementalStateTask(tsid, /*post_next_only=*/false);
       },
-      clear_period_ms - static_cast<uint32_t>(base::GetWallTimeMs().count() %
+      clear_period_ms - static_cast<uint32_t>(clock_->GetWallTimeMs().count() %
                                               clear_period_ms));
 
   if (post_next_only)
@@ -62591,21 +66095,6 @@ bool TracingServiceImpl::ReadBuffersIntoConsumer(
     return false;
   }
 
-  // If a bugreport request happened and the trace was stolen for that, give
-  // an empty trace with a clear signal to the consumer. This deals only with
-  // the case of readback-from-IPC. A similar code-path deals with the
-  // write_into_file case in MaybeSaveTraceForBugreport().
-  if (tracing_session->seized_for_bugreport) {
-    std::vector<TracePacket> packets;
-    if (!tracing_session->config.builtin_data_sources()
-             .disable_service_events()) {
-      EmitSeizedForBugreportLifecycleEvent(&packets);
-    }
-    EmitLifecycleEvents(tracing_session, &packets);
-    consumer->consumer_->OnTraceData(std::move(packets), /*has_more=*/false);
-    return true;
-  }
-
   if (IsWaitingForTrigger(tracing_session))
     return false;
 
@@ -62627,12 +66116,12 @@ bool TracingServiceImpl::ReadBuffersIntoConsumer(
 
   if (has_more) {
     auto weak_consumer = consumer->weak_ptr_factory_.GetWeakPtr();
-    auto weak_this = weak_ptr_factory_.GetWeakPtr();
-    task_runner_->PostTask([weak_this, weak_consumer, tsid] {
-      if (!weak_this || !weak_consumer)
-        return;
-      weak_this->ReadBuffersIntoConsumer(tsid, weak_consumer.get());
-    });
+    weak_runner_.PostTask(
+        [this, weak_consumer = std::move(weak_consumer), tsid] {
+          if (!weak_consumer)
+            return;
+          ReadBuffersIntoConsumer(tsid, weak_consumer.get());
+        });
   }
 
   // Keep this as tail call, just in case the consumer re-enters.
@@ -62640,7 +66129,9 @@ bool TracingServiceImpl::ReadBuffersIntoConsumer(
   return true;
 }
 
-bool TracingServiceImpl::ReadBuffersIntoFile(TracingSessionID tsid) {
+bool TracingServiceImpl::ReadBuffersIntoFile(
+    TracingSessionID tsid,
+    bool async_flush_buffers_before_read) {
   PERFETTO_DCHECK_THREAD(thread_checker_);
   TracingSession* tracing_session = GetTracingSession(tsid);
   if (!tracing_session) {
@@ -62654,44 +66145,69 @@ bool TracingServiceImpl::ReadBuffersIntoFile(TracingSessionID tsid) {
   if (!tracing_session->write_into_file)
     return false;
 
-  if (!tracing_session->seized_for_bugreport &&
-      IsWaitingForTrigger(tracing_session))
+  if (IsWaitingForTrigger(tracing_session))
     return false;
 
-  // ReadBuffers() can allocate memory internally, for filtering. By limiting
-  // the data that ReadBuffers() reads to kWriteIntoChunksSize per iteration,
-  // we limit the amount of memory used on each iteration.
-  //
-  // It would be tempting to split this into multiple tasks like in
-  // ReadBuffersIntoConsumer, but that's not currently possible.
-  // ReadBuffersIntoFile has to read the whole available data before returning,
-  // to support the disable_immediately=true code paths.
-  bool has_more = true;
-  bool stop_writing_into_file = false;
-  do {
-    std::vector<TracePacket> packets =
-        ReadBuffers(tracing_session, kWriteIntoFileChunkSize, &has_more);
+  auto do_read_buffers_into_file_fn =
+      [this, tsid](bool async_flush_buffers_before_read) {
+        TracingSession* tracing_session = GetTracingSession(tsid);
+        if (!tracing_session)
+          return;
+        // ReadBuffers() can allocate memory internally, for filtering. By
+        // limiting the data that ReadBuffers() reads to kWriteIntoChunksSize
+        // per iteration, we limit the amount of memory used on each iteration.
+        //
+        // It would be tempting to split this into multiple tasks like in
+        // ReadBuffersIntoConsumer, but that's not currently possible.
+        // ReadBuffersIntoFile has to read the whole available data before
+        // returning, to support the disable_immediately=true code paths.
+        bool has_more = true;
+        bool stop_writing_into_file = false;
+        do {
+          std::vector<TracePacket> packets =
+              ReadBuffers(tracing_session, kWriteIntoFileChunkSize, &has_more);
+
+          stop_writing_into_file =
+              WriteIntoFile(tracing_session, std::move(packets));
+        } while (has_more && !stop_writing_into_file);
+
+        if (stop_writing_into_file || tracing_session->write_period_ms == 0) {
+          // Ensure all data was written to the file before we close it.
+          base::FlushFile(tracing_session->write_into_file.get());
+          tracing_session->write_into_file.reset();
+          tracing_session->write_period_ms = 0;
+          if (tracing_session->state == TracingSession::STARTED)
+            DisableTracing(tsid);
+          return;
+        }
 
-    stop_writing_into_file = WriteIntoFile(tracing_session, std::move(packets));
-  } while (has_more && !stop_writing_into_file);
+        if (tracing_session->fflush_post_write) {
+          // Ensure all data was written to the file.
+          base::FlushFile(tracing_session->write_into_file.get());
+        }
 
-  if (stop_writing_into_file || tracing_session->write_period_ms == 0) {
-    // Ensure all data was written to the file before we close it.
-    base::FlushFile(tracing_session->write_into_file.get());
-    tracing_session->write_into_file.reset();
-    tracing_session->write_period_ms = 0;
-    if (tracing_session->state == TracingSession::STARTED)
-      DisableTracing(tsid);
-    return true;
+        weak_runner_.PostDelayedTask(
+            [this, tsid, async_flush_buffers_before_read] {
+              ReadBuffersIntoFile(tsid, async_flush_buffers_before_read);
+            },
+            DelayToNextWritePeriodMs(*tracing_session));
+      };
+
+  if (async_flush_buffers_before_read) {
+    Flush(
+        tsid, 0,
+        [do_read_buffers_into_file_fn](bool success) {
+          if (!success)
+            PERFETTO_ELOG("ReadBuffersIntoFile flush timed out");
+          do_read_buffers_into_file_fn(
+              /* async_flush_buffers_before_read= */ true);
+        },
+        FlushFlags(FlushFlags::Initiator::kTraced,
+                   FlushFlags::Reason::kPeriodic));
+  } else {
+    do_read_buffers_into_file_fn(/* async_flush_buffers_before_read= */ false);
   }
 
-  auto weak_this = weak_ptr_factory_.GetWeakPtr();
-  task_runner_->PostDelayedTask(
-      [weak_this, tsid] {
-        if (weak_this)
-          weak_this->ReadBuffersIntoFile(tsid);
-      },
-      tracing_session->delay_to_next_write_period_ms());
   return true;
 }
 
@@ -62714,6 +66230,19 @@ bool TracingServiceImpl::IsWaitingForTrigger(TracingSession* tracing_session) {
         "ReadBuffers(): tracing session has not received a trigger yet.");
     return true;
   }
+
+  // Traces with CLONE_SNAPSHOT triggers are a special case of the above. They
+  // can be read only via a CloneSession() request. This is to keep the
+  // behavior consistent with the STOP_TRACING+triggers case and avoid periodic
+  // finalizations and uploads of the main CLONE_SNAPSHOT triggers.
+  if (GetTriggerMode(tracing_session->config) ==
+      TraceConfig::TriggerConfig::CLONE_SNAPSHOT) {
+    PERFETTO_DLOG(
+        "ReadBuffers(): skipping because the tracing session has "
+        "CLONE_SNAPSHOT triggers defined");
+    return true;
+  }
+
   return false;
 }
 
@@ -62746,11 +66275,21 @@ std::vector<TracePacket> TracingServiceImpl::ReadBuffers(
   }
 
   if (!tracing_session->config.builtin_data_sources().disable_trace_config()) {
-    MaybeEmitUuidAndTraceConfig(tracing_session, &packets);
+    MaybeEmitTraceConfig(tracing_session, &packets);
+    MaybeEmitCloneTrigger(tracing_session, &packets);
     MaybeEmitReceivedTriggers(tracing_session, &packets);
   }
-  if (!tracing_session->config.builtin_data_sources().disable_system_info())
-    MaybeEmitSystemInfo(tracing_session, &packets);
+  if (!tracing_session->did_emit_initial_packets) {
+    EmitUuid(tracing_session, &packets);
+    EmitExtensionDescriptors(tracing_session, &packets);
+    EmitTraceProvenance(tracing_session, &packets);
+    if (!tracing_session->config.builtin_data_sources().disable_system_info()) {
+      EmitSystemInfo(&packets);
+      if (!relay_clients_.empty())
+        MaybeEmitRemoteSystemInfo(&packets);
+    }
+  }
+  tracing_session->did_emit_initial_packets = true;
 
   // Note that in the proto comment, we guarantee that the tracing_started
   // lifecycle event will be emitted before any data packets so make sure to
@@ -62758,6 +66297,16 @@ std::vector<TracePacket> TracingServiceImpl::ReadBuffers(
   if (!tracing_session->config.builtin_data_sources().disable_service_events())
     EmitLifecycleEvents(tracing_session, &packets);
 
+  // In a multi-machine tracing session, emit clock synchronization messages for
+  // remote machines.
+  if (!tracing_session->config.builtin_data_sources()
+           .disable_clock_snapshotting() &&
+      !relay_clients_.empty()) {
+    MaybeEmitRemoteClockSync(tracing_session, &packets);
+  }
+
+  MaybeEmitProtoVmInstances(tracing_session, &packets);
+
   size_t packets_bytes = 0;  // SUM(slice.size() for each slice in |packets|).
 
   // Add up size for packets added by the Maybe* calls above.
@@ -62785,11 +66334,12 @@ std::vector<TracePacket> TracingServiceImpl::ReadBuffers(
                                     &previous_packet_dropped)) {
         break;
       }
+      packet.set_buffer_index_for_stats(static_cast<uint32_t>(buf_idx));
       PERFETTO_DCHECK(sequence_properties.producer_id_trusted != 0);
       PERFETTO_DCHECK(sequence_properties.writer_id != 0);
-      PERFETTO_DCHECK(sequence_properties.producer_uid_trusted != kInvalidUid);
-      // Not checking sequence_properties.producer_pid_trusted: it is
-      // base::kInvalidPid if the platform doesn't support it.
+      PERFETTO_DCHECK(sequence_properties.client_identity_trusted.has_uid());
+      // Not checking sequence_properties.client_identity_trusted.has_pid():
+      // it is false if the platform doesn't support it.
 
       PERFETTO_DCHECK(packet.size() > 0);
       if (!PacketStreamValidator::Validate(packet.slices())) {
@@ -62809,16 +66359,22 @@ std::vector<TracePacket> TracingServiceImpl::ReadBuffers(
       Slice slice = Slice::Allocate(32);
       protozero::StaticBuffered<protos::pbzero::TracePacket> trusted_packet(
           slice.own_data(), slice.size);
+      const auto& client_identity_trusted =
+          sequence_properties.client_identity_trusted;
       trusted_packet->set_trusted_uid(
-          static_cast<int32_t>(sequence_properties.producer_uid_trusted));
+          static_cast<int32_t>(client_identity_trusted.uid()));
       trusted_packet->set_trusted_packet_sequence_id(
           tracing_session->GetPacketSequenceID(
+              client_identity_trusted.machine_id(),
               sequence_properties.producer_id_trusted,
               sequence_properties.writer_id));
-      if (sequence_properties.producer_pid_trusted != base::kInvalidPid) {
+      if (client_identity_trusted.has_pid()) {
         // Not supported on all platforms.
         trusted_packet->set_trusted_pid(
-            static_cast<int32_t>(sequence_properties.producer_pid_trusted));
+            static_cast<int32_t>(client_identity_trusted.pid()));
+      }
+      if (client_identity_trusted.has_non_default_machine_id()) {
+        trusted_packet->set_machine_id(client_identity_trusted.machine_id());
       }
       if (previous_packet_dropped)
         trusted_packet->set_previous_packet_dropped(previous_packet_dropped);
@@ -62830,7 +66386,7 @@ std::vector<TracePacket> TracingServiceImpl::ReadBuffers(
       did_hit_threshold = packets_bytes >= threshold;
       packets.emplace_back(std::move(packet));
     }  // for(packets...)
-  }    // for(buffers...)
+  }  // for(buffers...)
 
   *has_more = did_hit_threshold;
 
@@ -62843,10 +66399,10 @@ std::vector<TracePacket> TracingServiceImpl::ReadBuffers(
     // We don't bother snapshotting clocks here because we wouldn't be able to
     // emit it and we shouldn't have significant drift from the last snapshot in
     // any case.
-    SnapshotLifecyleEvent(tracing_session,
-                          protos::pbzero::TracingServiceEvent::
-                              kReadTracingBuffersCompletedFieldNumber,
-                          false /* snapshot_clocks */);
+    SnapshotLifecycleEvent(tracing_session,
+                           protos::pbzero::TracingServiceEvent::
+                               kReadTracingBuffersCompletedFieldNumber,
+                           false /* snapshot_clocks */);
     EmitLifecycleEvents(tracing_session, &packets);
   }
 
@@ -62862,6 +66418,8 @@ std::vector<TracePacket> TracingServiceImpl::ReadBuffers(
 
   MaybeFilterPackets(tracing_session, &packets);
 
+  MaybeCompressPackets(tracing_session, &packets);
+
   if (!*has_more) {
     // We've observed some extremely high memory usage by scudo after
     // MaybeFilterPackets in the past. The original bug (b/195145848) is fixed
@@ -62884,22 +66442,25 @@ void TracingServiceImpl::MaybeFilterPackets(TracingSession* tracing_session,
     return;
   }
   protozero::MessageFilter& trace_filter = *tracing_session->trace_filter;
-  // The filter root shoud be reset from protos.Trace to protos.TracePacket
+  // The filter root should be reset from protos.Trace to protos.TracePacket
   // by the earlier call to SetFilterRoot() in EnableTracing().
-  PERFETTO_DCHECK(trace_filter.root_msg_index() != 0);
+  PERFETTO_DCHECK(trace_filter.config().root_msg_index() != 0);
   std::vector<protozero::MessageFilter::InputSlice> filter_input;
+  auto start = clock_->GetWallTimeNs();
   for (TracePacket& packet : *packets) {
     const auto& packet_slices = packet.slices();
+    const size_t input_packet_size = packet.size();
     filter_input.clear();
     filter_input.resize(packet_slices.size());
     ++tracing_session->filter_input_packets;
-    tracing_session->filter_input_bytes += packet.size();
+    tracing_session->filter_input_bytes += input_packet_size;
     for (size_t i = 0; i < packet_slices.size(); ++i)
       filter_input[i] = {packet_slices[i].start, packet_slices[i].size};
     auto filtered_packet = trace_filter.FilterMessageFragments(
         &filter_input[0], filter_input.size());
 
     // Replace the packet in-place with the filtered one (unless failed).
+    std::optional<uint32_t> maybe_buffer_idx = packet.buffer_index_for_stats();
     packet = TracePacket();
     if (filtered_packet.error) {
       ++tracing_session->filter_errors;
@@ -62908,10 +66469,36 @@ void TracingServiceImpl::MaybeFilterPackets(TracingSession* tracing_session,
       continue;
     }
     tracing_session->filter_output_bytes += filtered_packet.size;
+    if (maybe_buffer_idx.has_value()) {
+      // Keep the per-buffer stats updated. Also propagate the
+      // buffer_index_for_stats in the output packet to allow accounting by
+      // other parts of the ReadBuffer pipeline.
+      uint32_t buffer_idx = maybe_buffer_idx.value();
+      packet.set_buffer_index_for_stats(buffer_idx);
+      auto& vec = tracing_session->filter_bytes_discarded_per_buffer;
+      if (static_cast<size_t>(buffer_idx) >= vec.size())
+        vec.resize(buffer_idx + 1);
+      PERFETTO_DCHECK(input_packet_size >= filtered_packet.size);
+      size_t bytes_filtered_out = input_packet_size - filtered_packet.size;
+      vec[buffer_idx] += bytes_filtered_out;
+    }
     AppendOwnedSlicesToPacket(std::move(filtered_packet.data),
                               filtered_packet.size, kMaxTracePacketSliceSize,
                               &packet);
   }
+  auto end = clock_->GetWallTimeNs();
+  tracing_session->filter_time_taken_ns +=
+      static_cast<uint64_t>((end - start).count());
+}
+
+void TracingServiceImpl::MaybeCompressPackets(
+    TracingSession* tracing_session,
+    std::vector<TracePacket>* packets) {
+  if (!tracing_session->compress_deflate) {
+    return;
+  }
+
+  init_opts_.compressor_fn(packets);
 }
 
 bool TracingServiceImpl::WriteIntoFile(TracingSession* tracing_session,
@@ -62985,7 +66572,8 @@ bool TracingServiceImpl::WriteIntoFile(TracingSession* tracing_session,
   return stop_writing_into_file;
 }
 
-void TracingServiceImpl::FreeBuffers(TracingSessionID tsid) {
+void TracingServiceImpl::FreeBuffers(TracingSessionID tsid,
+                                     const std::string& error) {
   PERFETTO_DCHECK_THREAD(thread_checker_);
   PERFETTO_DLOG("Freeing buffers for session %" PRIu64, tsid);
   TracingSession* tracing_session = GetTracingSession(tsid);
@@ -62993,7 +66581,7 @@ void TracingServiceImpl::FreeBuffers(TracingSessionID tsid) {
     PERFETTO_DLOG("FreeBuffers() failed, invalid session ID %" PRIu64, tsid);
     return;  // TODO(primiano): signal failure?
   }
-  DisableTracing(tsid, /*disable_immediately=*/true);
+  DisableTracing(tsid, /*disable_immediately=*/true, error);
 
   PERFETTO_DCHECK(tracing_session->AllDataSourceInstancesStopped());
   tracing_session->data_source_instances.clear();
@@ -63014,26 +66602,84 @@ void TracingServiceImpl::FreeBuffers(TracingSessionID tsid) {
   bool is_long_trace =
       (tracing_session->config.write_into_file() &&
        tracing_session->config.file_write_period_ms() < kMillisPerDay);
-  bool seized_for_bugreport = tracing_session->seized_for_bugreport;
+  auto pending_clones = std::move(tracing_session->pending_clones);
   tracing_sessions_.erase(tsid);
   tracing_session = nullptr;
   UpdateMemoryGuardrail();
 
+  for (const auto& id_to_clone_op : pending_clones) {
+    const PendingClone& clone_op = id_to_clone_op.second;
+    if (clone_op.weak_consumer) {
+      weak_runner_.task_runner()->PostTask(
+          [weak_consumer = clone_op.weak_consumer] {
+            if (weak_consumer) {
+              weak_consumer->consumer_->OnSessionCloned(
+                  {false, "Original session ended", {}, false});
+            }
+          });
+    }
+  }
+
   PERFETTO_LOG("Tracing session %" PRIu64 " ended, total sessions:%zu", tsid,
                tracing_sessions_.size());
-
 #if PERFETTO_BUILDFLAG(PERFETTO_ANDROID_BUILD) && \
     PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-  if (notify_traceur && (seized_for_bugreport || is_long_trace)) {
+  if (notify_traceur && is_long_trace) {
     PERFETTO_LAZY_LOAD(android_internal::NotifyTraceSessionEnded, notify_fn);
-    if (!notify_fn || !notify_fn(seized_for_bugreport))
+    if (!notify_fn || !notify_fn(/*session_stolen=*/false))
       PERFETTO_ELOG("Failed to notify Traceur long tracing has ended");
   }
-#else
-  base::ignore_result(notify_traceur);
-  base::ignore_result(is_long_trace);
-  base::ignore_result(seized_for_bugreport);
-#endif
+#else
+  base::ignore_result(notify_traceur);
+  base::ignore_result(is_long_trace);
+#endif
+}
+
+void TracingServiceImpl::MaybeSetUpProtoVm(
+    const DataSourceConfig& ds_config,
+    const RegisteredDataSource& ds_instance,
+    BufferID buffer_id) {
+  if (!ds_config.has_protovm_config() &&
+      !ds_instance.descriptor.has_protovm_program()) {
+    return;  // Data source has no ProtoVM
+  }
+  // TODO(keanmariotti): report the errors below in a trace packet as well, so
+  // that we can surface them on the UI.
+  if (!ds_instance.descriptor.has_protovm_program()) {
+    PERFETTO_ELOG(
+        "ProtoVM config for data source %s specifies a ProtoVM, but the data "
+        "source instance (ProducerID: %d) doesn't specify a ProtoVM program",
+        ds_config.name().c_str(), ds_instance.producer_id);
+    return;
+  }
+  if (!ds_config.has_protovm_config()) {
+    PERFETTO_ELOG(
+        "Received ProtoVM program from data souce instance (ProducerID: %d, "
+        "Data source name: %s), but the data source config doesn't specify a "
+        "ProtoVM.",
+        ds_instance.producer_id, ds_config.name().c_str());
+    return;
+  }
+  if (!ds_config.protovm_config().has_memory_limit_kb()) {
+    PERFETTO_ELOG(
+        "ProtoVM config for data source %s doesn't specify a memory limit",
+        ds_config.name().c_str());
+    return;
+  }
+  auto it = buffers_.find(buffer_id);
+  PERFETTO_CHECK(it != buffers_.cend());
+  if (it->second->buf_type() != TraceBuffer::BufType::kV2) {
+    PERFETTO_ELOG(
+        "Data source %s is configured to run a ProtoVM, but the corresponding "
+        "buffer is not of type V2",
+        ds_config.name().c_str());
+    return;
+  }
+  auto* buffer = static_cast<TraceBufferV2*>(it->second.get());
+  buffer->MaybeSetUpProtoVm(
+      ds_config.name(),
+      ds_instance.descriptor.protovm_program().SerializeAsString(),
+      ds_config.protovm_config().memory_limit_kb(), ds_instance.producer_id);
 }
 
 void TracingServiceImpl::RegisterDataSource(ProducerID producer_id,
@@ -63081,7 +66727,7 @@ void TracingServiceImpl::RegisterDataSource(ProducerID producer_id,
     }
 
     TraceConfig::ProducerConfig producer_config;
-    for (auto& config : tracing_session.config.producers()) {
+    for (const auto& config : tracing_session.config.producers()) {
       if (producer->name_ == config.producer_name()) {
         producer_config = config;
         break;
@@ -63135,6 +66781,14 @@ void TracingServiceImpl::StopDataSourceInstance(ProducerEndpointImpl* producer,
                                                 DataSourceInstance* instance,
                                                 bool disable_immediately) {
   const DataSourceInstanceID ds_inst_id = instance->instance_id;
+  if (producer->IsAndroidProcessFrozen()) {
+    PERFETTO_DLOG(
+        "skipping waiting of data source \"%s\" on producer \"%s\" (pid=%d) "
+        "because it is frozen",
+        instance->data_source_name.c_str(), producer->name_.c_str(),
+        static_cast<int>(producer->pid()));
+    disable_immediately = true;
+  }
   if (instance->will_notify_on_stop && !disable_immediately) {
     instance->state = DataSourceInstance::STOPPING;
   } else {
@@ -63199,7 +66853,38 @@ void TracingServiceImpl::UnregisterDataSource(ProducerID producer_id,
       name.c_str(), producer_id);
 }
 
-TracingServiceImpl::DataSourceInstance* TracingServiceImpl::SetupDataSource(
+bool TracingServiceImpl::IsInitiatorPrivileged(
+    const TracingSession& tracing_session) {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+  if (tracing_session.consumer_uid == AID_STATSD &&
+      tracing_session.config.statsd_metadata().triggering_config_uid() !=
+          AID_SHELL &&
+      tracing_session.config.statsd_metadata().triggering_config_uid() !=
+          AID_ROOT) {
+    // StatsD can be triggered either by shell, root or an app that has DUMP and
+    // USAGE_STATS permission. When triggered by shell or root, we do not want
+    // to consider the trace a trusted system trace, as it was initiated by the
+    // user. Otherwise, it has to come from an app with DUMP and
+    // PACKAGE_USAGE_STATS, which has to be preinstalled and trusted by the
+    // system.
+    // Check for shell / root: https://bit.ly/3b7oZNi
+    // Check for DUMP or PACKAGE_USAGE_STATS: https://bit.ly/3ep0NrR
+    return true;
+  }
+  if (tracing_session.consumer_uid == 1000 /* AID_SYSTEM */) {
+    // AID_SYSTEM is considered a privileged initiator so that system_server can
+    // profile apps that are not profileable by shell. Other AID_SYSTEM
+    // processes are not allowed by SELinux to connect to the consumer socket or
+    // to exec perfetto.
+    return true;
+  }
+#else
+  base::ignore_result(tracing_session);
+#endif
+  return false;
+}
+
+DataSourceInstance* TracingServiceImpl::SetupDataSource(
     const TraceConfig::DataSource& cfg_data_source,
     const TraceConfig::ProducerConfig& producer_config,
     const RegisteredDataSource& data_source,
@@ -63209,26 +66894,69 @@ TracingServiceImpl::DataSourceInstance* TracingServiceImpl::SetupDataSource(
   PERFETTO_DCHECK(producer);
   // An existing producer that is not ftrace could have registered itself as
   // ftrace, we must not enable it in that case.
-  if (lockdown_mode_ && producer->uid_ != uid_) {
+  if (lockdown_mode_ && producer->uid() != uid_) {
     PERFETTO_DLOG("Lockdown mode: not enabling producer %hu", producer->id_);
     return nullptr;
   }
-  // TODO(primiano): Add tests for registration ordering (data sources vs
-  // consumers).
-  if (!NameMatchesFilter(producer->name_,
-                         cfg_data_source.producer_name_filter(),
-                         cfg_data_source.producer_name_regex_filter())) {
-    PERFETTO_DLOG("Data source: %s is filtered out for producer: %s",
+
+  // Check machine name filter for multi-machine (traced_relay) tracing.
+  bool is_host_machine =
+      producer->client_identity().machine_id() == kDefaultMachineID;
+  if (cfg_data_source.machine_name_filter_size()) {
+    // Explicit set of machines to match.
+    const auto& cfg_names = cfg_data_source.machine_name_filter();
+    bool filter_match =
+        NameMatchesFilter(producer->machine_name_, cfg_names, {});
+    // Special case: "host" also always matches the host machine.
+    bool host_match =
+        is_host_machine && NameMatchesFilter("host", cfg_names, {});
+    if (!filter_match && !host_match) {
+      PERFETTO_DLOG("Data source: %s is filtered out for machine: %s",
+                    cfg_data_source.config().name().c_str(),
+                    producer->machine_name_.c_str());
+      return nullptr;
+    }
+  } else if (!tracing_session->config.trace_all_machines() &&
+             !is_host_machine) {
+    // Default matching behaviour starting from perfetto v54: match only host,
+    // unless the config sets a top level flag.
+    PERFETTO_DLOG("Data source: %s is filtered out for remote machine: %s",
                   cfg_data_source.config().name().c_str(),
-                  producer->name_.c_str());
+                  producer->machine_name_.c_str());
     return nullptr;
   }
 
-  auto relative_buffer_id = cfg_data_source.config().target_buffer();
+  // Check producer name filter.
+  if (cfg_data_source.producer_name_filter_size() ||
+      cfg_data_source.producer_name_regex_filter_size()) {
+    if (!NameMatchesFilter(producer->name_,
+                           cfg_data_source.producer_name_filter(),
+                           cfg_data_source.producer_name_regex_filter())) {
+      PERFETTO_DLOG("Data source: %s is filtered out for producer: %s",
+                    cfg_data_source.config().name().c_str(),
+                    producer->name_.c_str());
+      return nullptr;
+    }
+  }
+
+  // Resolve the target buffer index. If target_buffer_name is specified, look
+  // up the index from the buffer names in the config.
+  uint32_t relative_buffer_id = cfg_data_source.config().target_buffer();
+  const auto& ds_cfg = cfg_data_source.config();
+  if (!ds_cfg.target_buffer_name().empty()) {
+    // Look up the buffer index by name from the trace config.
+    for (size_t i = 0; i < tracing_session->num_buffers(); ++i) {
+      const auto& buf = tracing_session->config.buffers()[i];
+      if (buf.name() == ds_cfg.target_buffer_name()) {
+        relative_buffer_id = static_cast<uint32_t>(i);
+        break;
+      }
+    }
+  }
   if (relative_buffer_id >= tracing_session->num_buffers()) {
     PERFETTO_LOG(
         "The TraceConfig for DataSource %s specified a target_buffer out of "
-        "bound (%d). Skipping it.",
+        "bound (%u). Skipping it.",
         cfg_data_source.config().name().c_str(), relative_buffer_id);
     return nullptr;
   }
@@ -63250,7 +66978,8 @@ TracingServiceImpl::DataSourceInstance* TracingServiceImpl::SetupDataSource(
           data_source.descriptor.name(),
           data_source.descriptor.will_notify_on_start(),
           data_source.descriptor.will_notify_on_stop(),
-          data_source.descriptor.handles_incremental_state_clear()));
+          data_source.descriptor.handles_incremental_state_clear(),
+          data_source.descriptor.no_flush()));
   DataSourceInstance* ds_instance = &insert_iter->second;
 
   // New data source instance starts out in CONFIGURED state.
@@ -63274,19 +67003,7 @@ TracingServiceImpl::DataSourceInstance* TracingServiceImpl::SetupDataSource(
   ds_config.set_stop_timeout_ms(tracing_session->data_source_stop_timeout_ms());
   ds_config.set_enable_extra_guardrails(
       tracing_session->config.enable_extra_guardrails());
-  if (tracing_session->consumer_uid == 1066 /* AID_STATSD */ &&
-      tracing_session->config.statsd_metadata().triggering_config_uid() !=
-          2000 /* AID_SHELL */
-      && tracing_session->config.statsd_metadata().triggering_config_uid() !=
-             0 /* AID_ROOT */) {
-    // StatsD can be triggered either by shell, root or an app that has DUMP and
-    // USAGE_STATS permission. When triggered by shell or root, we do not want
-    // to consider the trace a trusted system trace, as it was initiated by the
-    // user. Otherwise, it has to come from an app with DUMP and
-    // PACKAGE_USAGE_STATS, which has to be preinstalled and trusted by the
-    // system.
-    // Check for shell / root: https://bit.ly/3b7oZNi
-    // Check for DUMP or PACKAGE_USAGE_STATS: https://bit.ly/3ep0NrR
+  if (IsInitiatorPrivileged(*tracing_session)) {
     ds_config.set_session_initiator(
         DataSourceConfig::SESSION_INITIATOR_TRUSTED_SYSTEM);
   } else {
@@ -63300,6 +67017,8 @@ TracingServiceImpl::DataSourceInstance* TracingServiceImpl::SetupDataSource(
   PERFETTO_DCHECK(global_id);
   ds_config.set_target_buffer(global_id);
 
+  MaybeSetUpProtoVm(ds_config, data_source, global_id);
+
   PERFETTO_DLOG("Setting up data source %s with target buffer %" PRIu16,
                 ds_config.name().c_str(), global_id);
   if (!producer->shared_memory()) {
@@ -63336,9 +67055,17 @@ TracingServiceImpl::DataSourceInstance* TracingServiceImpl::SetupDataSource(
     // client to go away.
     PERFETTO_DLOG("Creating SMB of %zu KB for producer \"%s\"", shm_size / 1024,
                   producer->name_.c_str());
+    // In the case the producer is using shmem emulation, because we use
+    // MMAP to allocate the memory and we never write to it, the shared
+    // memory is mapped to the zero page, essentially costing zero
+    // physical memory.
     auto shared_memory = shm_factory_->CreateSharedMemory(shm_size);
+    auto shmem_mode =
+        producer->client_identity().machine_id() == kDefaultMachineID
+            ? SharedMemoryABI::ShmemMode::kDefault
+            : SharedMemoryABI::ShmemMode::kShmemEmulation;
     producer->SetupSharedMemory(std::move(shared_memory), page_size,
-                                /*provided_by_producer=*/false);
+                                /*provided_by_producer=*/false, shmem_mode);
   }
   producer->SetupDataSource(inst_id, ds_config);
   return ds_instance;
@@ -63349,8 +67076,7 @@ TracingServiceImpl::DataSourceInstance* TracingServiceImpl::SetupDataSource(
 // in terms of being a valid pointer, but not the contents.
 void TracingServiceImpl::CopyProducerPageIntoLogBuffer(
     ProducerID producer_id_trusted,
-    uid_t producer_uid_trusted,
-    pid_t producer_pid_trusted,
+    const ClientIdentity& client_identity_trusted,
     WriterID writer_id,
     ChunkID chunk_id,
     BufferID buffer_id,
@@ -63392,7 +67118,7 @@ void TracingServiceImpl::CopyProducerPageIntoLogBuffer(
 
   // If the writer was registered by the producer, it should only write into the
   // buffer it was registered with.
-  base::Optional<BufferID> associated_buffer =
+  std::optional<BufferID> associated_buffer =
       producer->buffer_id_for_writer(writer_id);
   if (associated_buffer && *associated_buffer != buffer_id) {
     PERFETTO_ELOG("Writer %" PRIu16 " of producer %" PRIu16
@@ -63405,10 +67131,9 @@ void TracingServiceImpl::CopyProducerPageIntoLogBuffer(
     return;
   }
 
-  buf->CopyChunkUntrusted(producer_id_trusted, producer_uid_trusted,
-                          producer_pid_trusted, writer_id, chunk_id,
-                          num_fragments, chunk_flags, chunk_complete, src,
-                          size);
+  buf->CopyChunkUntrusted(producer_id_trusted, client_identity_trusted,
+                          writer_id, chunk_id, num_fragments, chunk_flags,
+                          chunk_complete, src, size);
 }
 
 void TracingServiceImpl::ApplyChunkPatches(
@@ -63473,9 +67198,8 @@ void TracingServiceImpl::ApplyChunkPatches(
   }
 }
 
-TracingServiceImpl::TracingSession* TracingServiceImpl::GetDetachedSession(
-    uid_t uid,
-    const std::string& key) {
+TracingSession* TracingServiceImpl::GetDetachedSession(uid_t uid,
+                                                       const std::string& key) {
   PERFETTO_DCHECK_THREAD(thread_checker_);
   for (auto& kv : tracing_sessions_) {
     TracingSession* session = &kv.second;
@@ -63487,8 +67211,7 @@ TracingServiceImpl::TracingSession* TracingServiceImpl::GetDetachedSession(
   return nullptr;
 }
 
-TracingServiceImpl::TracingSession* TracingServiceImpl::GetTracingSession(
-    TracingSessionID tsid) {
+TracingSession* TracingServiceImpl::GetTracingSession(TracingSessionID tsid) {
   PERFETTO_DCHECK_THREAD(thread_checker_);
   auto it = tsid ? tracing_sessions_.find(tsid) : tracing_sessions_.end();
   if (it == tracing_sessions_.end())
@@ -63496,6 +67219,40 @@ TracingServiceImpl::TracingSession* TracingServiceImpl::GetTracingSession(
   return &it->second;
 }
 
+TracingSession* TracingServiceImpl::GetTracingSessionByUniqueName(
+    const std::string& unique_session_name) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  if (unique_session_name.empty()) {
+    return nullptr;
+  }
+  for (auto& session_id_and_session : tracing_sessions_) {
+    TracingSession& session = session_id_and_session.second;
+    if (session.state == TracingSession::CLONED_READ_ONLY) {
+      continue;
+    }
+    if (session.config.unique_session_name() == unique_session_name) {
+      return &session;
+    }
+  }
+  return nullptr;
+}
+
+TracingSession* TracingServiceImpl::FindTracingSessionWithMaxBugreportScore() {
+  TracingSession* max_session = nullptr;
+  for (auto& session_id_and_session : tracing_sessions_) {
+    auto& session = session_id_and_session.second;
+    const int32_t score = session.config.bugreport_score();
+    // Exclude sessions with 0 (or below) score. By default tracing sessions
+    // should NOT be eligible to be attached to bugreports.
+    if (score <= 0 || session.state != TracingSession::STARTED)
+      continue;
+
+    if (!max_session || score > max_session->config.bugreport_score())
+      max_session = &session;
+  }
+  return max_session;
+}
+
 ProducerID TracingServiceImpl::GetNextProducerID() {
   PERFETTO_DCHECK_THREAD(thread_checker_);
   PERFETTO_CHECK(producers_.size() < kMaxProducerID);
@@ -63510,7 +67267,7 @@ TraceBuffer* TracingServiceImpl::GetBufferByID(BufferID buffer_id) {
   auto buf_iter = buffers_.find(buffer_id);
   if (buf_iter == buffers_.end())
     return nullptr;
-  return &*buf_iter->second;
+  return buf_iter->second.get();
 }
 
 void TracingServiceImpl::OnStartTriggersTimeout(TracingSessionID tsid) {
@@ -63549,7 +67306,20 @@ void TracingServiceImpl::UpdateMemoryGuardrail() {
 
   // Sum up all the trace buffers.
   for (const auto& id_to_buffer : buffers_) {
-    total_buffer_bytes += id_to_buffer.second->size();
+    total_buffer_bytes += id_to_buffer.second->GetMemoryUsageBytes();
+  }
+
+  // Sum up all the cloned traced buffers.
+  for (const auto& id_to_ts : tracing_sessions_) {
+    const TracingSession& ts = id_to_ts.second;
+    for (const auto& id_to_clone_op : ts.pending_clones) {
+      const PendingClone& clone_op = id_to_clone_op.second;
+      for (const std::unique_ptr<TraceBuffer>& buf : clone_op.buffers) {
+        if (buf) {
+          total_buffer_bytes += buf->GetMemoryUsageBytes();
+        }
+      }
+    }
   }
 
   // Set the guard rail to 32MB + the sum of all the buffers over a 30 second
@@ -63570,9 +67340,9 @@ void TracingServiceImpl::PeriodicSnapshotTask(TracingSessionID tsid) {
   MaybeSnapshotClocksIntoRingBuffer(tracing_session);
 }
 
-void TracingServiceImpl::SnapshotLifecyleEvent(TracingSession* tracing_session,
-                                               uint32_t field_id,
-                                               bool snapshot_clocks) {
+void TracingServiceImpl::SnapshotLifecycleEvent(TracingSession* tracing_session,
+                                                uint32_t field_id,
+                                                bool snapshot_clocks) {
   // field_id should be an id of a field in TracingServiceEvent.
   auto& lifecycle_events = tracing_session->lifecycle_events;
   auto event_it =
@@ -63600,7 +67370,31 @@ void TracingServiceImpl::SnapshotLifecyleEvent(TracingSession* tracing_session,
     event->timestamps.erase_front(1 + event->timestamps.size() -
                                   event->max_size);
   }
-  event->timestamps.emplace_back(base::GetBootTimeNs().count());
+  event->timestamps.emplace_back(clock_->GetBootTimeNs().count());
+}
+
+void TracingServiceImpl::SetSingleLifecycleEvent(
+    TracingSession* tracing_session,
+    uint32_t field_id,
+    int64_t boot_timestamp_ns) {
+  // field_id should be an id of a field in TracingServiceEvent.
+  auto& lifecycle_events = tracing_session->lifecycle_events;
+  auto event_it =
+      std::find_if(lifecycle_events.begin(), lifecycle_events.end(),
+                   [field_id](const TracingSession::LifecycleEvent& event) {
+                     return event.field_id == field_id;
+                   });
+
+  TracingSession::LifecycleEvent* event;
+  if (event_it == lifecycle_events.end()) {
+    lifecycle_events.emplace_back(field_id);
+    event = &lifecycle_events.back();
+  } else {
+    event = &*event_it;
+  }
+
+  event->timestamps.clear();
+  event->timestamps.emplace_back(boot_timestamp_ns);
 }
 
 void TracingServiceImpl::MaybeSnapshotClocksIntoRingBuffer(
@@ -63643,50 +67437,8 @@ bool TracingServiceImpl::SnapshotClocks(
   // been emitted into the trace yet (see comment below).
   static constexpr int64_t kSignificantDriftNs = 10 * 1000 * 1000;  // 10 ms
 
-  TracingSession::ClockSnapshotData new_snapshot_data;
-
-#if !PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) && \
-    !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) &&   \
-    !PERFETTO_BUILDFLAG(PERFETTO_OS_NACL)
-  struct {
-    clockid_t id;
-    protos::pbzero::BuiltinClock type;
-    struct timespec ts;
-  } clocks[] = {
-      {CLOCK_BOOTTIME, protos::pbzero::BUILTIN_CLOCK_BOOTTIME, {0, 0}},
-      {CLOCK_REALTIME_COARSE,
-       protos::pbzero::BUILTIN_CLOCK_REALTIME_COARSE,
-       {0, 0}},
-      {CLOCK_MONOTONIC_COARSE,
-       protos::pbzero::BUILTIN_CLOCK_MONOTONIC_COARSE,
-       {0, 0}},
-      {CLOCK_REALTIME, protos::pbzero::BUILTIN_CLOCK_REALTIME, {0, 0}},
-      {CLOCK_MONOTONIC, protos::pbzero::BUILTIN_CLOCK_MONOTONIC, {0, 0}},
-      {CLOCK_MONOTONIC_RAW,
-       protos::pbzero::BUILTIN_CLOCK_MONOTONIC_RAW,
-       {0, 0}},
-  };
-  // First snapshot all the clocks as atomically as we can.
-  for (auto& clock : clocks) {
-    if (clock_gettime(clock.id, &clock.ts) == -1)
-      PERFETTO_DLOG("clock_gettime failed for clock %d", clock.id);
-  }
-  for (auto& clock : clocks) {
-    new_snapshot_data.push_back(std::make_pair(
-        static_cast<uint32_t>(clock.type),
-        static_cast<uint64_t>(base::FromPosixTimespec(clock.ts).count())));
-  }
-#else  // OS_APPLE || OS_WIN && OS_NACL
-  auto wall_time_ns = static_cast<uint64_t>(base::GetWallTimeNs().count());
-  // The default trace clock is boot time, so we always need to emit a path to
-  // it. However since we don't actually have a boot time source on these
-  // platforms, pretend that wall time equals boot time.
-  new_snapshot_data.push_back(
-      std::make_pair(protos::pbzero::BUILTIN_CLOCK_BOOTTIME, wall_time_ns));
-  new_snapshot_data.push_back(
-      std::make_pair(protos::pbzero::BUILTIN_CLOCK_MONOTONIC, wall_time_ns));
-#endif
-
+  TracingSession::ClockSnapshotData new_snapshot_data =
+      base::CaptureClockSnapshots();
   // If we're about to update a session's latest clock snapshot that hasn't been
   // emitted into the trace yet, check whether the clocks have drifted enough to
   // warrant overriding the current snapshot values. The older snapshot would be
@@ -63696,18 +67448,18 @@ bool TracingServiceImpl::SnapshotClocks(
   // we try to keep it if we can.
   if (!snapshot_data->empty()) {
     PERFETTO_DCHECK(snapshot_data->size() == new_snapshot_data.size());
-    PERFETTO_DCHECK((*snapshot_data)[0].first ==
+    PERFETTO_DCHECK((*snapshot_data)[0].clock_id ==
                     protos::gen::BUILTIN_CLOCK_BOOTTIME);
 
     bool update_snapshot = false;
-    uint64_t old_boot_ns = (*snapshot_data)[0].second;
-    uint64_t new_boot_ns = new_snapshot_data[0].second;
+    uint64_t old_boot_ns = (*snapshot_data)[0].timestamp;
+    uint64_t new_boot_ns = new_snapshot_data[0].timestamp;
     int64_t boot_diff =
         static_cast<int64_t>(new_boot_ns) - static_cast<int64_t>(old_boot_ns);
 
     for (size_t i = 1; i < snapshot_data->size(); i++) {
-      uint64_t old_ns = (*snapshot_data)[i].second;
-      uint64_t new_ns = new_snapshot_data[i].second;
+      uint64_t old_ns = (*snapshot_data)[i].timestamp;
+      uint64_t new_ns = new_snapshot_data[i].timestamp;
 
       int64_t diff =
           static_cast<int64_t>(new_ns) - static_cast<int64_t>(old_ns);
@@ -63746,8 +67498,8 @@ void TracingServiceImpl::EmitClockSnapshot(
 
   for (auto& clock_id_and_ts : snapshot_data) {
     auto* c = snapshot->add_clocks();
-    c->set_clock_id(clock_id_and_ts.first);
-    c->set_timestamp(clock_id_and_ts.second);
+    c->set_clock_id(clock_id_and_ts.clock_id);
+    c->set_timestamp(clock_id_and_ts.timestamp);
   }
 
   packet->set_trusted_uid(static_cast<int32_t>(uid_));
@@ -63808,6 +67560,9 @@ TraceStats TracingServiceImpl::GetTraceStats(TracingSession* tracing_session) {
     filt_stats->set_input_bytes(tracing_session->filter_input_bytes);
     filt_stats->set_output_bytes(tracing_session->filter_output_bytes);
     filt_stats->set_errors(tracing_session->filter_errors);
+    filt_stats->set_time_taken_ns(tracing_session->filter_time_taken_ns);
+    for (uint64_t value : tracing_session->filter_bytes_discarded_per_buffer)
+      filt_stats->add_bytes_discarded_per_buffer(value);
   }
 
   for (BufferID buf_id : tracing_session->buffers_index) {
@@ -63818,78 +67573,187 @@ TraceStats TracingServiceImpl::GetTraceStats(TracingSession* tracing_session) {
     }
     *trace_stats.add_buffer_stats() = buf->stats();
   }  // for (buf in session).
-  return trace_stats;
-}
 
-void TracingServiceImpl::MaybeEmitUuidAndTraceConfig(
-    TracingSession* tracing_session,
-    std::vector<TracePacket>* packets) {
-  if (tracing_session->did_emit_config)
-    return;
-  tracing_session->did_emit_config = true;
+  if (!tracing_session->config.builtin_data_sources()
+           .disable_chunk_usage_histograms()) {
+    // Emit chunk usage stats broken down by sequence ID (i.e. by trace-writer).
+    // Writer stats are updated by each TraceBuffer object at ReadBuffers time,
+    // and there can be >1 buffer per session. A trace writer never writes to
+    // more than one buffer (it's technically allowed but doesn't happen in the
+    // current impl of the tracing SDK).
+
+    bool has_written_bucket_definition = false;
+    uint32_t buf_idx = static_cast<uint32_t>(-1);
+    for (const BufferID buf_id : tracing_session->buffers_index) {
+      ++buf_idx;
+      const TraceBuffer* buf = GetBufferByID(buf_id);
+      if (!buf)
+        continue;
+      for (auto it = buf->writer_stats().GetIterator(); it; ++it) {
+        const auto& hist = it.value();
+        ProducerID p;
+        WriterID w;
+        GetProducerAndWriterID(it.key(), &p, &w);
+        if (!has_written_bucket_definition) {
+          // Serialize one-off the histogram bucket definition, which is the
+          // same for all entries in the map.
+          has_written_bucket_definition = true;
+          // The -1 in the loop below is to skip the implicit overflow bucket.
+          for (size_t i = 0; i < hist.num_buckets() - 1; ++i) {
+            trace_stats.add_chunk_payload_histogram_def(hist.GetBucketThres(i));
+          }
+        }  // if(!has_written_bucket_definition)
+        auto* wri_stats = trace_stats.add_writer_stats();
+        wri_stats->set_sequence_id(
+            tracing_session->GetPacketSequenceID(kDefaultMachineID, p, w));
+        wri_stats->set_buffer(buf_idx);
+        for (size_t i = 0; i < hist.num_buckets(); ++i) {
+          wri_stats->add_chunk_payload_histogram_counts(hist.GetBucketCount(i));
+          wri_stats->add_chunk_payload_histogram_sum(hist.GetBucketSum(i));
+        }
+      }  // for each sequence (writer).
+    }  // for each buffer.
+  }  // if (!disable_chunk_usage_histograms)
 
-  {
-    protozero::HeapBuffered<protos::pbzero::TracePacket> packet;
-    packet->set_trusted_uid(static_cast<int32_t>(uid_));
-    packet->set_trusted_packet_sequence_id(kServicePacketSequenceID);
-    auto* uuid = packet->set_trace_uuid();
-    uuid->set_lsb(tracing_session->trace_uuid.lsb());
-    uuid->set_msb(tracing_session->trace_uuid.msb());
-    SerializeAndAppendPacket(packets, packet.SerializeAsArray());
-  }
+  return trace_stats;
+}
 
-  {
-    protozero::HeapBuffered<protos::pbzero::TracePacket> packet;
-    packet->set_trusted_uid(static_cast<int32_t>(uid_));
-    packet->set_trusted_packet_sequence_id(kServicePacketSequenceID);
-    tracing_session->config.Serialize(packet->set_trace_config());
-    SerializeAndAppendPacket(packets, packet.SerializeAsArray());
-  }
+void TracingServiceImpl::EmitUuid(TracingSession* tracing_session,
+                                  std::vector<TracePacket>* packets) {
+  protozero::HeapBuffered<protos::pbzero::TracePacket> packet;
+  packet->set_trusted_uid(static_cast<int32_t>(uid_));
+  packet->set_trusted_packet_sequence_id(kServicePacketSequenceID);
+  auto* uuid = packet->set_trace_uuid();
+  uuid->set_lsb(tracing_session->trace_uuid.lsb());
+  uuid->set_msb(tracing_session->trace_uuid.msb());
+  SerializeAndAppendPacket(packets, packet.SerializeAsArray());
 }
 
-void TracingServiceImpl::MaybeEmitSystemInfo(
+void TracingServiceImpl::MaybeEmitTraceConfig(
     TracingSession* tracing_session,
     std::vector<TracePacket>* packets) {
-  if (tracing_session->did_emit_system_info)
+  if (tracing_session->did_emit_initial_packets)
     return;
-  tracing_session->did_emit_system_info = true;
+  protozero::HeapBuffered<protos::pbzero::TracePacket> packet;
+  packet->set_trusted_uid(static_cast<int32_t>(uid_));
+  packet->set_trusted_packet_sequence_id(kServicePacketSequenceID);
+  tracing_session->config.Serialize(packet->set_trace_config());
+  SerializeAndAppendPacket(packets, packet.SerializeAsArray());
+}
+
+void TracingServiceImpl::EmitSystemInfo(std::vector<TracePacket>* packets) {
   protozero::HeapBuffered<protos::pbzero::TracePacket> packet;
   auto* info = packet->set_system_info();
+
+  base::SystemInfo sys_info = base::GetSystemInfo();
   info->set_tracing_service_version(base::GetVersionString());
-#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) && \
-    !PERFETTO_BUILDFLAG(PERFETTO_OS_NACL)
-  struct utsname uname_info;
-  if (uname(&uname_info) == 0) {
+
+  if (sys_info.timezone_off_mins.has_value())
+    info->set_timezone_off_mins(*sys_info.timezone_off_mins);
+
+  if (sys_info.utsname_info.has_value()) {
     auto* utsname_info = info->set_utsname();
-    utsname_info->set_sysname(uname_info.sysname);
-    utsname_info->set_version(uname_info.version);
-    utsname_info->set_machine(uname_info.machine);
-    utsname_info->set_release(uname_info.release);
-  }
-#endif  // !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-  std::string fingerprint_value = base::GetAndroidProp("ro.build.fingerprint");
-  if (!fingerprint_value.empty()) {
-    info->set_android_build_fingerprint(fingerprint_value);
-  } else {
-    PERFETTO_ELOG("Unable to read ro.build.fingerprint");
-  }
+    utsname_info->set_sysname(sys_info.utsname_info->sysname);
+    utsname_info->set_version(sys_info.utsname_info->version);
+    utsname_info->set_machine(sys_info.utsname_info->machine);
+    utsname_info->set_release(sys_info.utsname_info->release);
+  }
+
+  if (sys_info.page_size.has_value())
+    info->set_page_size(*sys_info.page_size);
+  if (sys_info.system_ram_bytes.has_value())
+    info->set_system_ram_bytes(*sys_info.system_ram_bytes);
+  if (sys_info.num_cpus.has_value())
+    info->set_num_cpus(*sys_info.num_cpus);
+
+  if (!sys_info.android_build_fingerprint.empty())
+    info->set_android_build_fingerprint(sys_info.android_build_fingerprint);
+  if (!sys_info.android_device_manufacturer.empty())
+    info->set_android_device_manufacturer(sys_info.android_device_manufacturer);
+  if (sys_info.android_sdk_version.has_value())
+    info->set_android_sdk_version(*sys_info.android_sdk_version);
+  if (!sys_info.android_soc_model.empty())
+    info->set_android_soc_model(sys_info.android_soc_model);
+  if (!sys_info.android_guest_soc_model.empty())
+    info->set_android_guest_soc_model(sys_info.android_guest_soc_model);
+  if (!sys_info.android_hardware_revision.empty())
+    info->set_android_hardware_revision(sys_info.android_hardware_revision);
+  if (!sys_info.android_storage_model.empty())
+    info->set_android_storage_model(sys_info.android_storage_model);
+  if (!sys_info.android_ram_model.empty())
+    info->set_android_ram_model(sys_info.android_ram_model);
+  if (!sys_info.android_serial_console.empty())
+    info->set_android_serial_console(sys_info.android_serial_console);
 
-  std::string sdk_str_value = base::GetAndroidProp("ro.build.version.sdk");
-  base::Optional<uint64_t> sdk_value = base::StringToUInt64(sdk_str_value);
-  if (sdk_value.has_value()) {
-    info->set_android_sdk_version(*sdk_value);
-  } else {
-    PERFETTO_ELOG("Unable to read ro.build.version.sdk");
+  packet->set_trusted_uid(static_cast<int32_t>(uid_));
+  packet->set_trusted_packet_sequence_id(kServicePacketSequenceID);
+  SerializeAndAppendPacket(packets, packet.SerializeAsArray());
+}
+
+void TracingServiceImpl::EmitTraceProvenance(
+    TracingSession* tracing_session,
+    std::vector<TracePacket>* packets) {
+  protozero::HeapBuffered<protos::pbzero::TracePacket> packet;
+  packet->set_timestamp(static_cast<uint64_t>(clock_->GetBootTimeNs().count()));
+  auto* provenance = packet->set_trace_provenance();
+  for (const BufferID buf_id : tracing_session->buffers_index) {
+    auto* buffer_proto = provenance->add_buffers();
+    TraceBuffer* buf = GetBufferByID(buf_id);
+    if (!buf)
+      continue;
+    for (auto it = buf->writer_stats().GetIterator(); it; ++it) {
+      ProducerID producer_id;
+      WriterID writer_id;
+      GetProducerAndWriterID(it.key(), &producer_id, &writer_id);
+      ProducerEndpointImpl* producer = GetProducer(producer_id);
+      // TODO(primiano): here we default to kDefaultMachineID for disconnected
+      // producers. Alternatively we can refactor the writer stats key to
+      // include the machine ID (e.g. MachineAndProducerAndWriterID instead of
+      // ProducerAndWriterID)
+      MachineID machine_id = producer ? producer->client_identity().machine_id()
+                                      : kDefaultMachineID;
+      auto* sequence_proto = buffer_proto->add_sequences();
+      sequence_proto->set_id(tracing_session->GetPacketSequenceID(
+          machine_id, producer_id, writer_id));
+      sequence_proto->set_producer_id(static_cast<int32_t>(producer_id));
+    }
   }
-  info->set_hz(sysconf(_SC_CLK_TCK));
-  info->set_page_size(static_cast<uint32_t>(sysconf(_SC_PAGESIZE)));
-#endif  // PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
   packet->set_trusted_uid(static_cast<int32_t>(uid_));
   packet->set_trusted_packet_sequence_id(kServicePacketSequenceID);
   SerializeAndAppendPacket(packets, packet.SerializeAsArray());
 }
 
+void TracingServiceImpl::MaybeEmitRemoteSystemInfo(
+    std::vector<TracePacket>* packets) {
+  std::unordered_set<MachineID> did_emit_machines;
+  for (const auto& id_and_relay_client : relay_clients_) {
+    const auto& relay_client = id_and_relay_client.second;
+    auto machine_id = relay_client->machine_id();
+    if (did_emit_machines.find(machine_id) != did_emit_machines.end())
+      continue;  // Already emitted for the machine (e.g. multiple clients).
+
+    if (relay_client->serialized_system_info().empty()) {
+      PERFETTO_DLOG("System info not provided for machine ID = %" PRIu32,
+                    machine_id);
+      continue;
+    }
+
+    // Don't emit twice for the same machine.
+    did_emit_machines.insert(machine_id);
+
+    protozero::HeapBuffered<protos::pbzero::TracePacket> packet;
+    auto& system_info = relay_client->serialized_system_info();
+
+    packet->AppendBytes(kTracePacketSystemInfoFieldId, system_info.data(),
+                        system_info.size());
+
+    packet->set_machine_id(machine_id);
+    packet->set_trusted_uid(static_cast<int32_t>(uid_));
+    packet->set_trusted_packet_sequence_id(kServicePacketSequenceID);
+    SerializeAndAppendPacket(packets, packet.SerializeAsArray());
+  }
+}
+
 void TracingServiceImpl::EmitLifecycleEvents(
     TracingSession* tracing_session,
     std::vector<TracePacket>* packets) {
@@ -63911,6 +67775,33 @@ void TracingServiceImpl::EmitLifecycleEvents(
     event.timestamps.clear();
   }
 
+  if (tracing_session->slow_start_event.has_value()) {
+    const TracingSession::ArbitraryLifecycleEvent& event =
+        *tracing_session->slow_start_event;
+    timestamped_packets.emplace_back(event.timestamp, std::move(event.data));
+  }
+  tracing_session->slow_start_event.reset();
+
+  for (auto& event : tracing_session->last_flush_events) {
+    timestamped_packets.emplace_back(event.timestamp, std::move(event.data));
+  }
+  tracing_session->last_flush_events.clear();
+
+  for (size_t i = 0; i < tracing_session->buffer_cloned_timestamps.size();
+       i++) {
+    protozero::HeapBuffered<protos::pbzero::TracePacket> packet;
+    int64_t ts = tracing_session->buffer_cloned_timestamps[i];
+    packet->set_timestamp(static_cast<uint64_t>(ts));
+    packet->set_trusted_uid(static_cast<int32_t>(uid_));
+    packet->set_trusted_packet_sequence_id(kServicePacketSequenceID);
+
+    auto* service_event = packet->set_service_event();
+    service_event->set_buffer_cloned(static_cast<uint32_t>(i));
+
+    timestamped_packets.emplace_back(ts, packet.SerializeAsArray());
+  }
+  tracing_session->buffer_cloned_timestamps.clear();
+
   // We sort by timestamp here to ensure that the "sequence" of lifecycle
   // packets has monotonic timestamps like other sequences in the trace.
   // Note that these events could still be out of order with respect to other
@@ -63920,933 +67811,768 @@ void TracingServiceImpl::EmitLifecycleEvents(
               return a.first < b.first;
             });
 
-  for (const auto& pair : timestamped_packets)
+  for (auto& pair : timestamped_packets)
     SerializeAndAppendPacket(packets, std::move(pair.second));
 }
 
-void TracingServiceImpl::EmitSeizedForBugreportLifecycleEvent(
-    std::vector<TracePacket>* packets) {
-  protozero::HeapBuffered<protos::pbzero::TracePacket> packet;
-  packet->set_timestamp(static_cast<uint64_t>(base::GetBootTimeNs().count()));
-  packet->set_trusted_uid(static_cast<int32_t>(uid_));
-  packet->set_trusted_packet_sequence_id(kServicePacketSequenceID);
-  auto* service_event = packet->set_service_event();
-  service_event->AppendVarInt(
-      protos::pbzero::TracingServiceEvent::kSeizedForBugreportFieldNumber, 1);
-  SerializeAndAppendPacket(packets, packet.SerializeAsArray());
-}
-
-void TracingServiceImpl::MaybeEmitReceivedTriggers(
+void TracingServiceImpl::MaybeEmitRemoteClockSync(
     TracingSession* tracing_session,
     std::vector<TracePacket>* packets) {
-  PERFETTO_DCHECK(tracing_session->num_triggers_emitted_into_trace <=
-                  tracing_session->received_triggers.size());
-  for (size_t i = tracing_session->num_triggers_emitted_into_trace;
-       i < tracing_session->received_triggers.size(); ++i) {
-    const auto& info = tracing_session->received_triggers[i];
-    protozero::HeapBuffered<protos::pbzero::TracePacket> packet;
-    auto* trigger = packet->set_trigger();
-    trigger->set_trigger_name(info.trigger_name);
-    trigger->set_producer_name(info.producer_name);
-    trigger->set_trusted_producer_uid(static_cast<int32_t>(info.producer_uid));
-
-    packet->set_timestamp(info.boot_time_ns);
-    packet->set_trusted_uid(static_cast<int32_t>(uid_));
-    packet->set_trusted_packet_sequence_id(kServicePacketSequenceID);
-    SerializeAndAppendPacket(packets, packet.SerializeAsArray());
-    ++tracing_session->num_triggers_emitted_into_trace;
-  }
-}
-
-bool TracingServiceImpl::MaybeSaveTraceForBugreport(
-    std::function<void()> callback) {
-  TracingSession* max_session = nullptr;
-  TracingSessionID max_tsid = 0;
-  for (auto& session_id_and_session : tracing_sessions_) {
-    auto& session = session_id_and_session.second;
-    const int32_t score = session.config.bugreport_score();
-    // Exclude sessions with 0 (or below) score. By default tracing sessions
-    // should NOT be eligible to be attached to bugreports.
-    if (score <= 0 || session.state != TracingSession::STARTED)
-      continue;
-
-    // Also don't try to steal long traces with write_into_file if their content
-    // has been already partially written into a file, as we would get partial
-    // traces on both sides. We can't just copy the original file into the
-    // bugreport because the file could be too big (GBs) for bugreports.
-    // The only case where it's legit to steal traces with write_into_file, is
-    // when the consumer specified a very large write_period_ms (e.g. 24h),
-    // meaning that this is effectively a ring-buffer trace. Traceur (the
-    // Android System Tracing app), which uses --detach, does this to have a
-    // consistent invocation path for long-traces and ring-buffer-mode traces.
-    if (session.write_into_file && session.bytes_written_into_file > 0)
-      continue;
-
-    // If we are already in the process of finalizing another trace for
-    // bugreport, don't even start another one, as they would try to write onto
-    // the same file.
-    if (session.on_disable_callback_for_bugreport)
-      return false;
-
-    if (!max_session || score > max_session->config.bugreport_score()) {
-      max_session = &session;
-      max_tsid = session_id_and_session.first;
-    }
-  }
-
-  // No eligible trace found.
-  if (!max_session)
-    return false;
-
-  PERFETTO_LOG("Seizing trace for bugreport. tsid:%" PRIu64
-               " state:%d wf:%d score:%d name:\"%s\"",
-               max_tsid, max_session->state, !!max_session->write_into_file,
-               max_session->config.bugreport_score(),
-               max_session->config.unique_session_name().c_str());
-
-  auto br_fd = CreateTraceFile(GetBugreportTmpPath(), /*overwrite=*/true);
-  if (!br_fd)
-    return false;
-
-  if (max_session->write_into_file) {
-    auto fd = *max_session->write_into_file;
-    // If we are stealing a write_into_file session, add a marker that explains
-    // why the trace has been stolen rather than creating an empty file. This is
-    // only for write_into_file traces. A similar code path deals with the case
-    // of reading-back a seized trace from IPC in ReadBuffersIntoConsumer().
-    if (!max_session->config.builtin_data_sources().disable_service_events()) {
-      std::vector<TracePacket> packets;
-      EmitSeizedForBugreportLifecycleEvent(&packets);
-      for (auto& packet : packets) {
-        char* preamble;
-        size_t preamble_size = 0;
-        std::tie(preamble, preamble_size) = packet.GetProtoPreamble();
-        base::WriteAll(fd, preamble, preamble_size);
-        for (const Slice& slice : packet.slices()) {
-          base::WriteAll(fd, slice.start, slice.size);
-        }
-      }  // for (packets)
-    }    // if (!disable_service_events())
-  }      // if (max_session->write_into_file)
-  max_session->write_into_file = std::move(br_fd);
-  max_session->on_disable_callback_for_bugreport = std::move(callback);
-  max_session->seized_for_bugreport = true;
-
-  // Post a task to avoid that early FlushAndDisableTracing() failures invoke
-  // the callback before we return. That would re-enter in a weird way the
-  // callstack of the calling ConsumerEndpointImpl::SaveTraceForBugreport().
-  auto weak_this = weak_ptr_factory_.GetWeakPtr();
-  task_runner_->PostTask([weak_this, max_tsid] {
-    if (weak_this)
-      weak_this->FlushAndDisableTracing(max_tsid);
-  });
-  return true;
-}
-
-void TracingServiceImpl::MaybeLogUploadEvent(const TraceConfig& cfg,
-                                             const base::Uuid& uuid,
-                                             PerfettoStatsdAtom atom,
-                                             const std::string& trigger_name) {
-  if (!ShouldLogEvent(cfg))
-    return;
-
-  PERFETTO_DCHECK(uuid);  // The UUID must be set at this point.
-  android_stats::MaybeLogUploadEvent(atom, uuid.lsb(), uuid.msb(),
-                                     trigger_name);
-}
-
-void TracingServiceImpl::MaybeLogTriggerEvent(const TraceConfig& cfg,
-                                              PerfettoTriggerAtom atom,
-                                              const std::string& trigger_name) {
-  if (!ShouldLogEvent(cfg))
+  if (tracing_session->did_emit_remote_clock_sync_)
     return;
-  android_stats::MaybeLogTriggerEvent(atom, trigger_name);
-}
 
-size_t TracingServiceImpl::PurgeExpiredAndCountTriggerInWindow(
-    int64_t now_ns,
-    uint64_t trigger_name_hash) {
-  PERFETTO_DCHECK(
-      std::is_sorted(trigger_history_.begin(), trigger_history_.end()));
-  size_t remove_count = 0;
-  size_t trigger_count = 0;
-  for (const TriggerHistory& h : trigger_history_) {
-    if (h.timestamp_ns < now_ns - trigger_window_ns_) {
-      remove_count++;
-    } else if (h.name_hash == trigger_name_hash) {
-      trigger_count++;
+  std::unordered_set<MachineID> did_emit_machines;
+  for (const auto& id_and_relay_client : relay_clients_) {
+    const auto& relay_client = id_and_relay_client.second;
+    auto machine_id = relay_client->machine_id();
+    if (did_emit_machines.find(machine_id) != did_emit_machines.end())
+      continue;  // Already emitted for the machine (e.g. multiple clients).
+
+    auto& sync_clock_snapshots = relay_client->synced_clocks();
+    if (sync_clock_snapshots.empty()) {
+      PERFETTO_DLOG("Clock not synchronized for machine ID = %" PRIu32,
+                    machine_id);
+      continue;
     }
-  }
-  trigger_history_.erase_front(remove_count);
-  return trigger_count;
-}
-
-void TracingServiceImpl::FlushAndCloneSession(ConsumerEndpointImpl* consumer,
-                                              TracingSessionID tsid) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  auto weak_this = weak_ptr_factory_.GetWeakPtr();
-  auto weak_consumer = consumer->GetWeakPtr();
-  Flush(tsid, 0, [weak_this, tsid, weak_consumer](bool final_flush_outcome) {
-    PERFETTO_LOG("FlushAndCloneSession(%" PRIu64 ") started, success=%d", tsid,
-                 final_flush_outcome);
-    if (!weak_this || !weak_consumer)
-      return;
-    base::Status result =
-        weak_this->DoCloneSession(&*weak_consumer, tsid, final_flush_outcome);
-    weak_consumer->consumer_->OnSessionCloned(result.ok(), result.message());
-  });
-}
-
-base::Status TracingServiceImpl::DoCloneSession(ConsumerEndpointImpl* consumer,
-                                                TracingSessionID src_tsid,
-                                                bool final_flush_outcome) {
-  PERFETTO_DLOG("CloneSession(%" PRIu64 ") started, consumer uid: %d", src_tsid,
-                static_cast<int>(consumer->uid_));
-  TracingSession* src = GetTracingSession(src_tsid);
-
-  // The session might be gone by the time we try to clone it.
-  if (!src)
-    return PERFETTO_SVC_ERR("session not found");
 
-  if (consumer->tracing_session_id_) {
-    return PERFETTO_SVC_ERR(
-        "The consumer is already attached to another tracing session");
-  }
+    // Don't emit twice for the same machine.
+    did_emit_machines.insert(machine_id);
 
-  if (src->consumer_uid != consumer->uid_ && consumer->uid_ != 0)
-    return PERFETTO_SVC_ERR("Not allowed to clone a session from another UID");
+    protozero::HeapBuffered<protos::pbzero::TracePacket> sync_packet;
+    sync_packet->set_machine_id(machine_id);
+    sync_packet->set_trusted_uid(static_cast<int32_t>(uid_));
+    auto* remote_clock_sync = sync_packet->set_remote_clock_sync();
+    for (const auto& sync_exchange : relay_client->synced_clocks()) {
+      auto* sync_exchange_msg = remote_clock_sync->add_synced_clocks();
 
-  // First clone all TraceBuffer(s). This can fail because of ENOMEM. If it
-  // happens bail out early before creating any session.
-  std::vector<std::pair<BufferID, std::unique_ptr<TraceBuffer>>> buf_snaps;
-  buf_snaps.reserve(src->num_buffers());
-  bool buf_clone_failed = false;
-  for (BufferID src_buf_id : src->buffers_index) {
-    TraceBuffer* src_buf = GetBufferByID(src_buf_id);
-    std::unique_ptr<TraceBuffer> buf_snap = src_buf->CloneReadOnly();
-    BufferID buf_global_id = buffer_ids_.Allocate();
-    buf_clone_failed |= !buf_snap.get() || !buf_global_id;
-    buf_snaps.emplace_back(buf_global_id, std::move(buf_snap));
-  }
+      auto* client_snapshots = sync_exchange_msg->set_client_clocks();
+      for (const auto& client_clock : sync_exchange.client_clocks) {
+        auto* clock = client_snapshots->add_clocks();
+        clock->set_clock_id(client_clock.clock_id);
+        clock->set_timestamp(client_clock.timestamp);
+      }
 
-  // Free up allocated IDs in case of failure. No need to free the TraceBuffers,
-  // as they are still owned by the temporary |buf_snaps|.
-  if (buf_clone_failed) {
-    for (auto& kv : buf_snaps) {
-      if (kv.first)
-        buffer_ids_.Free(kv.first);
+      auto* host_snapshots = sync_exchange_msg->set_host_clocks();
+      for (const auto& host_clock : sync_exchange.host_clocks) {
+        auto* clock = host_snapshots->add_clocks();
+        clock->set_clock_id(host_clock.clock_id);
+        clock->set_timestamp(host_clock.timestamp);
+      }
     }
-    return PERFETTO_SVC_ERR("Buffer allocation failed");
-  }
-
-  const TracingSessionID tsid = ++last_tracing_session_id_;
-  TracingSession* cloned_session =
-      &tracing_sessions_
-           .emplace(
-               std::piecewise_construct, std::forward_as_tuple(tsid),
-               std::forward_as_tuple(tsid, consumer, src->config, task_runner_))
-           .first->second;
-
-  cloned_session->state = TracingSession::CLONED_READ_ONLY;
-  cloned_session->trace_uuid = base::Uuidv4();  // Generate a new UUID.
 
-  for (auto& kv : buf_snaps) {
-    BufferID buf_global_id = kv.first;
-    std::unique_ptr<TraceBuffer>& buf = kv.second;
-    buffers_.emplace(buf_global_id, std::move(buf));
-    cloned_session->buffers_index.emplace_back(buf_global_id);
-  }
-  UpdateMemoryGuardrail();
-
-  // Copy over relevant state that we want to persist in the cloned session.
-  // Mostly stats and metadata that is emitted in the trace file by the service.
-  cloned_session->received_triggers = src->received_triggers;
-  cloned_session->lifecycle_events =
-      std::vector<TracingSession::LifecycleEvent>(src->lifecycle_events);
-  cloned_session->initial_clock_snapshot = src->initial_clock_snapshot;
-  cloned_session->clock_snapshot_ring_buffer = src->clock_snapshot_ring_buffer;
-  cloned_session->invalid_packets = src->invalid_packets;
-  cloned_session->flushes_requested = src->flushes_requested;
-  cloned_session->flushes_succeeded = src->flushes_succeeded;
-  cloned_session->flushes_failed = src->flushes_failed;
-  if (src->trace_filter) {
-    // Copy the trace filter.
-    cloned_session->trace_filter.reset(
-        new protozero::MessageFilter(*src->trace_filter));
+    SerializeAndAppendPacket(packets, sync_packet.SerializeAsArray());
   }
 
-  PERFETTO_DLOG("Consumer (uid:%d) cloned tracing session %" PRIu64
-                " -> %" PRIu64,
-                static_cast<int>(consumer->uid_), src_tsid, tsid);
-
-  consumer->tracing_session_id_ = tsid;
-  cloned_session->final_flush_outcome = final_flush_outcome
-                                            ? TraceStats::FINAL_FLUSH_SUCCEEDED
-                                            : TraceStats::FINAL_FLUSH_FAILED;
-  return base::OkStatus();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// TracingServiceImpl::ConsumerEndpointImpl implementation
-////////////////////////////////////////////////////////////////////////////////
-
-TracingServiceImpl::ConsumerEndpointImpl::ConsumerEndpointImpl(
-    TracingServiceImpl* service,
-    base::TaskRunner* task_runner,
-    Consumer* consumer,
-    uid_t uid)
-    : task_runner_(task_runner),
-      service_(service),
-      consumer_(consumer),
-      uid_(uid),
-      weak_ptr_factory_(this) {}
-
-TracingServiceImpl::ConsumerEndpointImpl::~ConsumerEndpointImpl() {
-  service_->DisconnectConsumer(this);
-  consumer_->OnDisconnect();
-}
-
-void TracingServiceImpl::ConsumerEndpointImpl::NotifyOnTracingDisabled(
-    const std::string& error) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  auto weak_this = weak_ptr_factory_.GetWeakPtr();
-  task_runner_->PostTask([weak_this, error /* deliberate copy */] {
-    if (weak_this)
-      weak_this->consumer_->OnTracingDisabled(error);
-  });
-}
-
-void TracingServiceImpl::ConsumerEndpointImpl::EnableTracing(
-    const TraceConfig& cfg,
-    base::ScopedFile fd) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  auto status = service_->EnableTracing(this, cfg, std::move(fd));
-  if (!status.ok())
-    NotifyOnTracingDisabled(status.message());
-}
-
-void TracingServiceImpl::ConsumerEndpointImpl::ChangeTraceConfig(
-    const TraceConfig& cfg) {
-  if (!tracing_session_id_) {
-    PERFETTO_LOG(
-        "Consumer called ChangeTraceConfig() but tracing was "
-        "not active");
-    return;
-  }
-  service_->ChangeTraceConfig(this, cfg);
+  tracing_session->did_emit_remote_clock_sync_ = true;
 }
 
-void TracingServiceImpl::ConsumerEndpointImpl::StartTracing() {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  if (!tracing_session_id_) {
-    PERFETTO_LOG("Consumer called StartTracing() but tracing was not active");
+void TracingServiceImpl::MaybeEmitProtoVmInstances(
+    TracingSession* tracing_session,
+    std::vector<TracePacket>* packets) {
+  if (tracing_session->did_emit_protovm_instances_)
     return;
-  }
-  service_->StartTracing(tracing_session_id_);
-}
 
-void TracingServiceImpl::ConsumerEndpointImpl::DisableTracing() {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  if (!tracing_session_id_) {
-    PERFETTO_LOG("Consumer called DisableTracing() but tracing was not active");
-    return;
-  }
-  service_->DisableTracing(tracing_session_id_);
-}
+  std::optional<protozero::HeapBuffered<protos::pbzero::TracePacket>>
+      maybe_packet;
 
-void TracingServiceImpl::ConsumerEndpointImpl::ReadBuffers() {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  if (!tracing_session_id_) {
-    PERFETTO_LOG("Consumer called ReadBuffers() but tracing was not active");
-    consumer_->OnTraceData({}, /* has_more = */ false);
-    return;
-  }
-  if (!service_->ReadBuffersIntoConsumer(tracing_session_id_, this)) {
-    consumer_->OnTraceData({}, /* has_more = */ false);
-  }
-}
+  auto get_packet_protovms =
+      [&, protovms = static_cast<protos::pbzero::TracePacket::ProtoVms*>(
+              nullptr)]() mutable {
+        if (protovms) {
+          return protovms;
+        }
+        maybe_packet.emplace();
+        protovms = maybe_packet.value()->set_protovms();
+        return protovms;
+      };
 
-void TracingServiceImpl::ConsumerEndpointImpl::FreeBuffers() {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  if (!tracing_session_id_) {
-    PERFETTO_LOG("Consumer called FreeBuffers() but tracing was not active");
-    return;
+  for (auto buffer_id : tracing_session->buffers_index) {
+    auto it = buffers_.find(buffer_id);
+    PERFETTO_CHECK(it != buffers_.cend());
+    if (it->second->buf_type() != TraceBuffer::BufType::kV2) {
+      continue;
+    }
+    auto* buffer = static_cast<TraceBufferV2*>(it->second.get());
+    for (const TraceBufferV2::Vm& vm : buffer->GetProtoVmInstances()) {
+      auto* vm_instance = get_packet_protovms()->add_instance();
+      vm_instance->AppendString(
+          protos::pbzero::TracePacket::ProtoVms::Instance::kProgramFieldNumber,
+          vm.instance->SerializeProgram());
+      auto* state = vm_instance->set_state();
+      vm.instance->SerializeIncrementalState(state);
+      vm_instance->set_memory_limit_kb(vm.memory_limit_kb);
+      for (ProducerID producer_id : vm.producers) {
+        vm_instance->add_producer_id(producer_id);
+      }
+    }
   }
-  service_->FreeBuffers(tracing_session_id_);
-  tracing_session_id_ = 0;
-}
 
-void TracingServiceImpl::ConsumerEndpointImpl::Flush(uint32_t timeout_ms,
-                                                     FlushCallback callback) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  if (!tracing_session_id_) {
-    PERFETTO_LOG("Consumer called Flush() but tracing was not active");
-    return;
+  if (maybe_packet) {
+    maybe_packet.value()->set_trusted_uid(static_cast<int32_t>(uid_));
+    maybe_packet.value()->set_trusted_packet_sequence_id(
+        kServicePacketSequenceID);
+    SerializeAndAppendPacket(packets, maybe_packet->SerializeAsArray());
   }
-  service_->Flush(tracing_session_id_, timeout_ms, callback);
-}
-
-void TracingServiceImpl::ConsumerEndpointImpl::Detach(const std::string& key) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  bool success = service_->DetachConsumer(this, key);
-  auto weak_this = weak_ptr_factory_.GetWeakPtr();
-  task_runner_->PostTask([weak_this, success] {
-    if (weak_this)
-      weak_this->consumer_->OnDetach(success);
-  });
-}
-
-void TracingServiceImpl::ConsumerEndpointImpl::Attach(const std::string& key) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  bool success = service_->AttachConsumer(this, key);
-  auto weak_this = weak_ptr_factory_.GetWeakPtr();
-  task_runner_->PostTask([weak_this, success] {
-    if (!weak_this)
-      return;
-    Consumer* consumer = weak_this->consumer_;
-    TracingSession* session =
-        weak_this->service_->GetTracingSession(weak_this->tracing_session_id_);
-    if (!session) {
-      consumer->OnAttach(false, TraceConfig());
-      return;
-    }
-    consumer->OnAttach(success, session->config);
-  });
-}
 
-void TracingServiceImpl::ConsumerEndpointImpl::GetTraceStats() {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  bool success = false;
-  TraceStats stats;
-  TracingSession* session = service_->GetTracingSession(tracing_session_id_);
-  if (session) {
-    success = true;
-    stats = service_->GetTraceStats(session);
-  }
-  auto weak_this = weak_ptr_factory_.GetWeakPtr();
-  task_runner_->PostTask([weak_this, success, stats] {
-    if (weak_this)
-      weak_this->consumer_->OnTraceStats(success, stats);
-  });
+  tracing_session->did_emit_protovm_instances_ = true;
 }
 
-void TracingServiceImpl::ConsumerEndpointImpl::ObserveEvents(
-    uint32_t events_mask) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  observable_events_mask_ = events_mask;
-  TracingSession* session = service_->GetTracingSession(tracing_session_id_);
-  if (!session)
-    return;
-
-  if (observable_events_mask_ & ObservableEvents::TYPE_DATA_SOURCES_INSTANCES) {
-    // Issue initial states.
-    for (const auto& kv : session->data_source_instances) {
-      ProducerEndpointImpl* producer = service_->GetProducer(kv.first);
-      PERFETTO_DCHECK(producer);
-      OnDataSourceInstanceStateChange(*producer, kv.second);
-    }
-  }
-
-  // If the ObserveEvents() call happens after data sources have acked already
-  // notify immediately.
-  if (observable_events_mask_ &
-      ObservableEvents::TYPE_ALL_DATA_SOURCES_STARTED) {
-    service_->MaybeNotifyAllDataSourcesStarted(session);
+void TracingServiceImpl::EmitExtensionDescriptors(
+    TracingSession*,
+    std::vector<TracePacket>* packets) {
+  for (const auto& desc : init_opts_.extension_descriptors) {
+    protozero::HeapBuffered<protos::pbzero::TracePacket> packet;
+    packet->set_trusted_uid(static_cast<int32_t>(uid_));
+    packet->set_trusted_packet_sequence_id(kServicePacketSequenceID);
+    auto* ext = packet->set_extension_descriptor();
+    if (desc.gzipped) {
+      ext->set_extension_set_gzip(desc.start, desc.size);
+    } else {
+      ext->AppendBytes(
+          protos::pbzero::ExtensionDescriptor::kExtensionSetFieldNumber,
+          desc.start, desc.size);
+    }
+    if (!desc.name.empty()) {
+      ext->set_file_name(desc.name);
+    }
+    SerializeAndAppendPacket(packets, packet.SerializeAsArray());
   }
 }
 
-void TracingServiceImpl::ConsumerEndpointImpl::OnDataSourceInstanceStateChange(
-    const ProducerEndpointImpl& producer,
-    const DataSourceInstance& instance) {
-  if (!(observable_events_mask_ &
-        ObservableEvents::TYPE_DATA_SOURCES_INSTANCES)) {
+void TracingServiceImpl::MaybeEmitCloneTrigger(
+    TracingSession* tracing_session,
+    std::vector<TracePacket>* packets) {
+  if (tracing_session->did_emit_initial_packets)
     return;
-  }
 
-  if (instance.state != DataSourceInstance::CONFIGURED &&
-      instance.state != DataSourceInstance::STARTED &&
-      instance.state != DataSourceInstance::STOPPED) {
-    return;
+  if (tracing_session->clone_trigger.has_value()) {
+    protozero::HeapBuffered<protos::pbzero::TracePacket> packet;
+    auto* trigger = packet->set_clone_snapshot_trigger();
+    const auto& info = tracing_session->clone_trigger.value();
+    trigger->set_trigger_name(info.trigger_name);
+    trigger->set_producer_name(info.producer_name);
+    trigger->set_trusted_producer_uid(static_cast<int32_t>(info.producer_uid));
+    trigger->set_stop_delay_ms(info.trigger_delay_ms);
+
+    packet->set_timestamp(info.boot_time_ns);
+    packet->set_trusted_uid(static_cast<int32_t>(uid_));
+    packet->set_trusted_packet_sequence_id(kServicePacketSequenceID);
+    SerializeAndAppendPacket(packets, packet.SerializeAsArray());
   }
+}
 
-  auto* observable_events = AddObservableEvents();
-  auto* change = observable_events->add_instance_state_changes();
-  change->set_producer_name(producer.name_);
-  change->set_data_source_name(instance.data_source_name);
-  if (instance.state == DataSourceInstance::STARTED) {
-    change->set_state(ObservableEvents::DATA_SOURCE_INSTANCE_STATE_STARTED);
-  } else {
-    change->set_state(ObservableEvents::DATA_SOURCE_INSTANCE_STATE_STOPPED);
+void TracingServiceImpl::MaybeEmitReceivedTriggers(
+    TracingSession* tracing_session,
+    std::vector<TracePacket>* packets) {
+  PERFETTO_DCHECK(tracing_session->num_triggers_emitted_into_trace <=
+                  tracing_session->received_triggers.size());
+  for (size_t i = tracing_session->num_triggers_emitted_into_trace;
+       i < tracing_session->received_triggers.size(); ++i) {
+    const auto& info = tracing_session->received_triggers[i];
+    protozero::HeapBuffered<protos::pbzero::TracePacket> packet;
+    auto* trigger = packet->set_trigger();
+    trigger->set_trigger_name(info.trigger_name);
+    trigger->set_producer_name(info.producer_name);
+    trigger->set_trusted_producer_uid(static_cast<int32_t>(info.producer_uid));
+    trigger->set_stop_delay_ms(info.trigger_delay_ms);
+
+    packet->set_timestamp(info.boot_time_ns);
+    packet->set_trusted_uid(static_cast<int32_t>(uid_));
+    packet->set_trusted_packet_sequence_id(kServicePacketSequenceID);
+    SerializeAndAppendPacket(packets, packet.SerializeAsArray());
+    ++tracing_session->num_triggers_emitted_into_trace;
   }
 }
 
-void TracingServiceImpl::ConsumerEndpointImpl::OnAllDataSourcesStarted() {
-  if (!(observable_events_mask_ &
-        ObservableEvents::TYPE_ALL_DATA_SOURCES_STARTED)) {
+void TracingServiceImpl::MaybeLogUploadEvent(const TraceConfig& cfg,
+                                             const base::Uuid& uuid,
+                                             PerfettoStatsdAtom atom,
+                                             const std::string& trigger_name) {
+  if (!ShouldLogEvent(cfg))
     return;
-  }
-  auto* observable_events = AddObservableEvents();
-  observable_events->set_all_data_sources_started(true);
+
+  PERFETTO_CHECK(uuid);  // The UUID must be set at this point.
+  android_stats::MaybeLogUploadEvent(atom, uuid.lsb(), uuid.msb(),
+                                     trigger_name);
 }
 
-ObservableEvents*
-TracingServiceImpl::ConsumerEndpointImpl::AddObservableEvents() {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  if (!observable_events_) {
-    observable_events_.reset(new ObservableEvents());
-    auto weak_this = weak_ptr_factory_.GetWeakPtr();
-    task_runner_->PostTask([weak_this] {
-      if (!weak_this)
-        return;
+void TracingServiceImpl::MaybeLogTriggerEvent(const TraceConfig& cfg,
+                                              const base::Uuid& uuid,
+                                              PerfettoTriggerAtom atom,
+                                              const std::string& trigger_name) {
+  if (!ShouldLogEvent(cfg))
+    return;
 
-      // Move into a temporary to allow reentrancy in OnObservableEvents.
-      auto observable_events = std::move(weak_this->observable_events_);
-      weak_this->consumer_->OnObservableEvents(*observable_events);
-    });
+  PERFETTO_CHECK(uuid);  // The UUID must be set at this point.
+  android_stats::MaybeLogTriggerEvent(atom, uuid.lsb(), trigger_name);
+}
+
+size_t TracingServiceImpl::PurgeExpiredAndCountTriggerInWindow(
+    int64_t now_ns,
+    uint64_t trigger_name_hash) {
+  constexpr int64_t kOneDayInNs = 24ll * 60 * 60 * 1000 * 1000 * 1000;
+  PERFETTO_DCHECK(
+      std::is_sorted(trigger_history_.begin(), trigger_history_.end()));
+  size_t remove_count = 0;
+  size_t trigger_count = 0;
+  for (const TriggerHistory& h : trigger_history_) {
+    if (h.timestamp_ns < now_ns - kOneDayInNs) {
+      remove_count++;
+    } else if (h.name_hash == trigger_name_hash) {
+      trigger_count++;
+    }
   }
-  return observable_events_.get();
+  trigger_history_.erase_front(remove_count);
+  return trigger_count;
 }
 
-void TracingServiceImpl::ConsumerEndpointImpl::QueryServiceState(
-    QueryServiceStateCallback callback) {
+base::Status TracingServiceImpl::FlushAndCloneSession(
+    ConsumerEndpointImpl* consumer,
+    ConsumerEndpoint::CloneSessionArgs args) {
   PERFETTO_DCHECK_THREAD(thread_checker_);
-  TracingServiceState svc_state;
-
-  const auto& sessions = service_->tracing_sessions_;
-  svc_state.set_tracing_service_version(base::GetVersionString());
-  svc_state.set_num_sessions(static_cast<int>(sessions.size()));
-
-  int num_started = 0;
-  for (const auto& kv : sessions)
-    num_started += kv.second.state == TracingSession::State::STARTED ? 1 : 0;
-  svc_state.set_num_sessions_started(static_cast<int>(num_started));
+  auto clone_target = FlushFlags::CloneTarget::kUnknown;
+
+  TracingSession* session = nullptr;
+  if (args.for_bugreport) {
+    clone_target = FlushFlags::CloneTarget::kBugreport;
+  }
+  if (args.tsid != 0) {
+    if (args.tsid == kBugreportSessionId) {
+      // This branch is only here to support the legacy protocol where we could
+      // clone only a single session using the magic ID kBugreportSessionId.
+      // The newer perfetto --clone-all-for-bugreport first queries the existing
+      // sessions and then issues individual clone requests specifying real
+      // session IDs, setting args.{for_bugreport,skip_trace_filter}=true.
+      PERFETTO_LOG("Looking for sessions for bugreport");
+      session = FindTracingSessionWithMaxBugreportScore();
+      if (!session) {
+        return base::ErrStatus(
+            "No tracing sessions eligible for bugreport found");
+      }
+      args.tsid = session->id;
+      clone_target = FlushFlags::CloneTarget::kBugreport;
+      args.skip_trace_filter = true;
+    } else {
+      session = GetTracingSession(args.tsid);
+    }
+  } else if (!args.unique_session_name.empty()) {
+    session = GetTracingSessionByUniqueName(args.unique_session_name);
+  }
 
-  for (const auto& kv : service_->producers_) {
-    auto* producer = svc_state.add_producers();
-    producer->set_id(static_cast<int>(kv.first));
-    producer->set_name(kv.second->name_);
-    producer->set_sdk_version(kv.second->sdk_version_);
-    producer->set_uid(static_cast<int32_t>(kv.second->uid()));
-    producer->set_pid(static_cast<int32_t>(kv.second->pid()));
+  if (!session) {
+    return base::ErrStatus("Tracing session not found");
   }
 
-  for (const auto& kv : service_->data_sources_) {
-    const auto& registered_data_source = kv.second;
-    auto* data_source = svc_state.add_data_sources();
-    *data_source->mutable_ds_descriptor() = registered_data_source.descriptor;
-    data_source->set_producer_id(
-        static_cast<int>(registered_data_source.producer_id));
+  // Skip the UID check for sessions marked with a bugreport_score > 0.
+  // Those sessions, by design, can be stolen by any other consumer for the
+  // sake of creating snapshots for bugreports.
+  if (!session->IsCloneAllowed(consumer->uid_)) {
+    return PERFETTO_SVC_ERR("Not allowed to clone a session from another UID");
   }
 
-  svc_state.set_supports_tracing_sessions(true);
-  for (const auto& kv : service_->tracing_sessions_) {
-    const TracingSession& s = kv.second;
-    // List only tracing sessions for the calling UID (or everything for root).
-    if (uid_ != 0 && uid_ != s.consumer_uid)
-      continue;
-    auto* session = svc_state.add_tracing_sessions();
-    session->set_id(s.id);
-    session->set_consumer_uid(static_cast<int>(s.consumer_uid));
-    session->set_duration_ms(s.config.duration_ms());
-    session->set_num_data_sources(
-        static_cast<uint32_t>(s.data_source_instances.size()));
-    session->set_unique_session_name(s.config.unique_session_name());
-    for (const auto& snap_kv : s.initial_clock_snapshot) {
-      if (snap_kv.first == protos::pbzero::BUILTIN_CLOCK_REALTIME)
-        session->set_start_realtime_ns(static_cast<int64_t>(snap_kv.second));
+  // The new logic we use to clone 'write_into_file' session relies on the
+  // 'buffer_clone_preserve_read_iter' flag being true; see b/448604718.
+  //
+  // The old logic ignored |session->write_into_file| when doing clone.
+  // Therefore, if the 'buffer_clone_preserve_read_iter' flag is false, we
+  // ignore the file to make the new logic behave like the old logic.
+  bool clone_session_write_into_file =
+      PERFETTO_FLAGS(BUFFER_CLONE_PRESERVE_READ_ITER) &&
+      session->write_into_file;
+
+  if (clone_session_write_into_file) {
+    if (!args.output_file_fd) {
+      return PERFETTO_SVC_ERR(
+          "Failed to clone 'write_into_file' session: a file descriptor is "
+          "required to copy existing file");
     }
-    for (const auto& buf : s.config.buffers())
-      session->add_buffer_size_kb(buf.size_kb());
+    base::FlushFile(*session->write_into_file);
+    base::Status status =
+        base::CopyFileContents(*session->write_into_file, *args.output_file_fd);
+    if (!status.ok()) {
+      return PERFETTO_SVC_ERR(
+          "Failed to clone 'write_into_file' session: failed to copy existing "
+          "file: %s",
+          status.c_message());
+    }
+  } else {
+    // The client always sends a FD because when it asks to CloneSession,
+    // it doesn't know if the session being cloned is WIF or not. If it's
+    // not we should just ignore the file, the client will readback via IPC
+    // as usual in that case.
+    args.output_file_fd.reset();
+  }
+
+  // If any of the buffers are marked as clear_before_clone, reset them before
+  // issuing the Flush(kCloneReason).
+  size_t buf_idx = 0;
+  for (BufferID src_buf_id : session->buffers_index) {
+    if (!session->config.buffers()[buf_idx++].clear_before_clone())
+      continue;
+    auto buf_iter = buffers_.find(src_buf_id);
+    PERFETTO_CHECK(buf_iter != buffers_.end());
+    std::unique_ptr<TraceBuffer>& buf = buf_iter->second;
+
+    // No need to reset the buffer if nothing has been written into it yet.
+    // This is the canonical case if producers behive nicely and don't timeout
+    // the handling of writes during the flush.
+    // This check avoids a useless re-mmap upon every Clone() if the buffer is
+    // already empty (when used in combination with `transfer_on_clone`).
+    if (!buf->has_data())
+      continue;
 
-    switch (s.state) {
-      case TracingSession::State::DISABLED:
-        session->set_state("DISABLED");
-        break;
-      case TracingSession::State::CONFIGURED:
-        session->set_state("CONFIGURED");
-        break;
-      case TracingSession::State::STARTED:
-        session->set_state("STARTED");
+    // Some leftover data was left in the buffer. Recreate it to empty it.
+    const auto buf_policy = buf->overwrite_policy();
+    const auto buf_size = buf->size();
+    const auto buf_type = buf->buf_type();
+    std::unique_ptr<TraceBuffer> old_buf = std::move(buf);
+    switch (buf_type) {
+      case TraceBuffer::kV1:
+        buf = TraceBufferV1::Create(buf_size, buf_policy);
         break;
-      case TracingSession::State::DISABLING_WAITING_STOP_ACKS:
-        session->set_state("STOP_WAIT");
+      case TraceBuffer::kV2:
+        buf = TraceBufferV2::Create(buf_size, buf_policy);
         break;
-      case TracingSession::State::CLONED_READ_ONLY:
-        session->set_state("CLONED_READ_ONLY");
+      case TraceBuffer::kV1WithV2Shadow:
+        buf = TraceBufferV1WithV2Shadow::Create(buf_size, buf_policy);
         break;
     }
+    if (!buf) {
+      // This is extremely rare but could happen on 32-bit. If the new buffer
+      // allocation failed, put back the buffer where it was and fail the clone.
+      // We cannot leave the original tracing session buffer-less as it would
+      // cause crashes when data sources commit new data.
+      buf = std::move(old_buf);
+      return base::ErrStatus(
+          "Buffer allocation failed while attempting to clone");
+    }
   }
-  callback(/*success=*/true, svc_state);
-}
 
-void TracingServiceImpl::ConsumerEndpointImpl::QueryCapabilities(
-    QueryCapabilitiesCallback callback) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  TracingServiceCapabilities caps;
-  caps.set_has_query_capabilities(true);
-  caps.set_has_trace_config_output_path(true);
-  caps.add_observable_events(ObservableEvents::TYPE_DATA_SOURCES_INSTANCES);
-  caps.add_observable_events(ObservableEvents::TYPE_ALL_DATA_SOURCES_STARTED);
-  static_assert(ObservableEvents::Type_MAX ==
-                    ObservableEvents::TYPE_ALL_DATA_SOURCES_STARTED,
-                "");
-  callback(caps);
-}
+  auto weak_consumer = consumer->GetWeakPtr();
 
-void TracingServiceImpl::ConsumerEndpointImpl::SaveTraceForBugreport(
-    SaveTraceForBugreportCallback consumer_callback) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  auto on_complete_callback = [consumer_callback] {
-    if (rename(GetBugreportTmpPath().c_str(), GetBugreportPath().c_str())) {
-      consumer_callback(false, "rename(" + GetBugreportTmpPath() + ", " +
-                                   GetBugreportPath() + ") failed (" +
-                                   strerror(errno) + ")");
+  const PendingCloneID clone_id = session->last_pending_clone_id_++;
+
+  auto& clone_op = session->pending_clones[clone_id];
+  clone_op.pending_flush_cnt = 0;
+  // Pre-initialize these vectors just as an optimization to avoid reallocations
+  // in DoCloneBuffers().
+  clone_op.buffers.reserve(session->buffers_index.size());
+  clone_op.buffer_cloned_timestamps.reserve(session->buffers_index.size());
+  clone_op.weak_consumer = weak_consumer;
+  clone_op.skip_trace_filter = args.skip_trace_filter;
+  if (!args.clone_trigger_name.empty()) {
+    clone_op.clone_trigger = {
+        args.clone_trigger_boot_time_ns, args.clone_trigger_name,
+        args.clone_trigger_producer_name,
+        args.clone_trigger_trusted_producer_uid, args.clone_trigger_delay_ms};
+  }
+  if (args.output_file_fd) {
+    clone_op.output_file_fd = std::move(args.output_file_fd);
+  }
+
+  // Issue separate flush requests for separate buffer groups. The buffer marked
+  // as transfer_on_clone will be flushed and cloned separately: even if they're
+  // slower (like in the case of Winscope tracing), they will not delay the
+  // snapshot of the other buffers.
+  //
+  // In the future we might want to split the buffer into more groups and maybe
+  // allow this to be configurable.
+  std::array<std::set<BufferID>, 2> bufs_groups;
+  for (size_t i = 0; i < session->buffers_index.size(); i++) {
+    if (session->config.buffers()[i].transfer_on_clone()) {
+      bufs_groups[0].insert(session->buffers_index[i]);
     } else {
-      consumer_callback(true, GetBugreportPath());
+      bufs_groups[1].insert(session->buffers_index[i]);
     }
-  };
-  if (!service_->MaybeSaveTraceForBugreport(std::move(on_complete_callback))) {
-    consumer_callback(false,
-                      "No trace with TraceConfig.bugreport_score > 0 eligible "
-                      "for bug reporting was found");
   }
-}
-
-void TracingServiceImpl::ConsumerEndpointImpl::CloneSession(
-    TracingSessionID tsid) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  // FlushAndCloneSession will call OnSessionCloned after the async flush.
-  service_->FlushAndCloneSession(this, tsid);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// TracingServiceImpl::ProducerEndpointImpl implementation
-////////////////////////////////////////////////////////////////////////////////
 
-TracingServiceImpl::ProducerEndpointImpl::ProducerEndpointImpl(
-    ProducerID id,
-    uid_t uid,
-    pid_t pid,
-    TracingServiceImpl* service,
-    base::TaskRunner* task_runner,
-    Producer* producer,
-    const std::string& producer_name,
-    const std::string& sdk_version,
-    bool in_process,
-    bool smb_scraping_enabled)
-    : id_(id),
-      uid_(uid),
-      pid_(pid),
-      service_(service),
-      task_runner_(task_runner),
-      producer_(producer),
-      name_(producer_name),
-      sdk_version_(sdk_version),
-      in_process_(in_process),
-      smb_scraping_enabled_(smb_scraping_enabled),
-      weak_ptr_factory_(this) {}
+  SnapshotLifecycleEvent(
+      session, protos::pbzero::TracingServiceEvent::kFlushStartedFieldNumber,
+      /*snapshot_clocks=*/true);
+  clone_op.pending_flush_cnt = bufs_groups.size();
+  clone_op.clone_started_timestamp_ns = clock_->GetBootTimeNs().count();
+  for (const std::set<BufferID>& buf_group : bufs_groups) {
+    FlushDataSourceInstances(
+        session, 0,
+        GetFlushableDataSourceInstancesForBuffers(session, buf_group),
+        [tsid = session->id, clone_id, buf_group, this](bool final_flush) {
+          OnFlushDoneForClone(tsid, clone_id, buf_group, final_flush);
+        },
+        FlushFlags(FlushFlags::Initiator::kTraced,
+                   FlushFlags::Reason::kTraceClone, clone_target));
+  }
 
-TracingServiceImpl::ProducerEndpointImpl::~ProducerEndpointImpl() {
-  service_->DisconnectProducer(id_);
-  producer_->OnDisconnect();
+  return base::OkStatus();
 }
 
-void TracingServiceImpl::ProducerEndpointImpl::Disconnect() {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  // Disconnection is only supported via destroying the ProducerEndpoint.
-  PERFETTO_FATAL("Not supported");
-}
+std::map<ProducerID, std::vector<DataSourceInstanceID>>
+TracingServiceImpl::GetFlushableDataSourceInstancesForBuffers(
+    TracingSession* session,
+    const std::set<BufferID>& bufs) {
+  std::map<ProducerID, std::vector<DataSourceInstanceID>> data_source_instances;
 
-void TracingServiceImpl::ProducerEndpointImpl::RegisterDataSource(
-    const DataSourceDescriptor& desc) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  service_->RegisterDataSource(id_, desc);
-}
+  for (const auto& [producer_id, ds_inst] : session->data_source_instances) {
+    // TODO(ddiproietto): Consider if we should skip instances if ds_inst.state
+    // != DataSourceInstance::STARTED
+    if (ds_inst.no_flush) {
+      continue;
+    }
+    if (!bufs.count(static_cast<BufferID>(ds_inst.config.target_buffer()))) {
+      continue;
+    }
+    data_source_instances[producer_id].push_back(ds_inst.instance_id);
+  }
 
-void TracingServiceImpl::ProducerEndpointImpl::UpdateDataSource(
-    const DataSourceDescriptor& desc) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  service_->UpdateDataSource(id_, desc);
+  return data_source_instances;
 }
 
-void TracingServiceImpl::ProducerEndpointImpl::UnregisterDataSource(
-    const std::string& name) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  service_->UnregisterDataSource(id_, name);
-}
+void TracingServiceImpl::OnFlushDoneForClone(TracingSessionID tsid,
+                                             PendingCloneID clone_id,
+                                             const std::set<BufferID>& buf_ids,
+                                             bool final_flush_outcome) {
+  TracingSession* src = GetTracingSession(tsid);
+  // The session might be gone by the time we try to clone it.
+  if (!src) {
+    return;
+  }
 
-void TracingServiceImpl::ProducerEndpointImpl::RegisterTraceWriter(
-    uint32_t writer_id,
-    uint32_t target_buffer) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  writers_[static_cast<WriterID>(writer_id)] =
-      static_cast<BufferID>(target_buffer);
-}
+  auto it = src->pending_clones.find(clone_id);
+  if (it == src->pending_clones.end()) {
+    return;
+  }
+  auto& clone_op = it->second;
 
-void TracingServiceImpl::ProducerEndpointImpl::UnregisterTraceWriter(
-    uint32_t writer_id) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  writers_.erase(static_cast<WriterID>(writer_id));
-}
+  if (final_flush_outcome == false) {
+    clone_op.flush_failed = true;
+  }
 
-void TracingServiceImpl::ProducerEndpointImpl::CommitData(
-    const CommitDataRequest& req_untrusted,
-    CommitDataCallback callback) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
+  base::Status result;
+  base::Uuid uuid;
 
-  if (metatrace::IsEnabled(metatrace::TAG_TRACE_SERVICE)) {
-    PERFETTO_METATRACE_COUNTER(TAG_TRACE_SERVICE, TRACE_SERVICE_COMMIT_DATA,
-                               EncodeCommitDataRequest(id_, req_untrusted));
+  // First clone the flushed TraceBuffer(s). This can fail because of ENOMEM. If
+  // it happens bail out early before creating any session.
+  if (!DoCloneBuffers(*src, buf_ids, &clone_op)) {
+    result = PERFETTO_SVC_ERR("Buffer allocation failed");
   }
 
-  if (!shared_memory_) {
-    PERFETTO_DLOG(
-        "Attempted to commit data before the shared memory was allocated.");
-    return;
-  }
-  PERFETTO_DCHECK(shmem_abi_.is_valid());
-  for (const auto& entry : req_untrusted.chunks_to_move()) {
-    const uint32_t page_idx = entry.page();
-    if (page_idx >= shmem_abi_.num_pages())
-      continue;  // A buggy or malicious producer.
+  bool was_write_into_file = false;
+  if (result.ok()) {
+    UpdateMemoryGuardrail();
 
-    SharedMemoryABI::Chunk chunk =
-        shmem_abi_.TryAcquireChunkForReading(page_idx, entry.chunk());
-    if (!chunk.is_valid()) {
-      PERFETTO_DLOG("Asked to move chunk %d:%d, but it's not complete",
-                    entry.page(), entry.chunk());
-      continue;
+    if (--clone_op.pending_flush_cnt != 0) {
+      // Wait for more pending flushes.
+      return;
     }
 
-    // TryAcquireChunkForReading() has load-acquire semantics. Once acquired,
-    // the ABI contract expects the producer to not touch the chunk anymore
-    // (until the service marks that as free). This is why all the reads below
-    // are just memory_order_relaxed. Also, the code here assumes that all this
-    // data can be malicious and just gives up if anything is malformed.
-    BufferID buffer_id = static_cast<BufferID>(entry.target_buffer());
-    const SharedMemoryABI::ChunkHeader& chunk_header = *chunk.header();
-    WriterID writer_id = chunk_header.writer_id.load(std::memory_order_relaxed);
-    ChunkID chunk_id = chunk_header.chunk_id.load(std::memory_order_relaxed);
-    auto packets = chunk_header.packets.load(std::memory_order_relaxed);
-    uint16_t num_fragments = packets.count;
-    uint8_t chunk_flags = packets.flags;
-
-    service_->CopyProducerPageIntoLogBuffer(
-        id_, uid_, pid_, writer_id, chunk_id, buffer_id, num_fragments,
-        chunk_flags,
-        /*chunk_complete=*/true, chunk.payload_begin(), chunk.payload_size());
-
-    // This one has release-store semantics.
-    shmem_abi_.ReleaseChunkAsFree(std::move(chunk));
-  }  // for(chunks_to_move)
+    PERFETTO_LOG("FlushAndCloneSession(%" PRIu64 ") started, success=%d", tsid,
+                 final_flush_outcome);
 
-  service_->ApplyChunkPatches(id_, req_untrusted.chunks_to_patch());
+    if (clone_op.weak_consumer) {
+      was_write_into_file = static_cast<bool>(clone_op.output_file_fd);
+      result = FinishCloneSession(
+          &*clone_op.weak_consumer, tsid, std::move(clone_op.buffers),
+          std::move(clone_op.buffer_cloned_timestamps),
+          clone_op.skip_trace_filter, !clone_op.flush_failed,
+          clone_op.clone_trigger, &uuid, clone_op.clone_started_timestamp_ns,
+          std::move(clone_op.output_file_fd));
+    }
+  }  // if (result.ok())
 
-  if (req_untrusted.flush_request_id()) {
-    service_->NotifyFlushDoneForProducer(id_, req_untrusted.flush_request_id());
+  if (clone_op.weak_consumer) {
+    clone_op.weak_consumer->consumer_->OnSessionCloned(
+        {result.ok(), result.message(), uuid, was_write_into_file});
   }
 
-  // Keep this invocation last. ProducerIPCService::CommitData() relies on this
-  // callback being invoked within the same callstack and not posted. If this
-  // changes, the code there needs to be changed accordingly.
-  if (callback)
-    callback();
+  src->pending_clones.erase(it);
+  UpdateMemoryGuardrail();
 }
 
-void TracingServiceImpl::ProducerEndpointImpl::SetupSharedMemory(
-    std::unique_ptr<SharedMemory> shared_memory,
-    size_t page_size_bytes,
-    bool provided_by_producer) {
-  PERFETTO_DCHECK(!shared_memory_ && !shmem_abi_.is_valid());
-  PERFETTO_DCHECK(page_size_bytes % 1024 == 0);
+bool TracingServiceImpl::DoCloneBuffers(const TracingSession& src,
+                                        const std::set<BufferID>& buf_ids,
+                                        PendingClone* clone_op) {
+  PERFETTO_DCHECK(src.num_buffers() == src.config.buffers().size());
+  clone_op->buffers.resize(src.buffers_index.size());
+  clone_op->buffer_cloned_timestamps.resize(src.buffers_index.size());
 
-  shared_memory_ = std::move(shared_memory);
-  shared_buffer_page_size_kb_ = page_size_bytes / 1024;
-  is_shmem_provided_by_producer_ = provided_by_producer;
+  int64_t now = clock_->GetBootTimeNs().count();
 
-  shmem_abi_.Initialize(reinterpret_cast<uint8_t*>(shared_memory_->start()),
-                        shared_memory_->size(),
-                        shared_buffer_page_size_kb() * 1024);
-  if (in_process_) {
-    inproc_shmem_arbiter_.reset(new SharedMemoryArbiterImpl(
-        shared_memory_->start(), shared_memory_->size(),
-        shared_buffer_page_size_kb_ * 1024, this, task_runner_));
-    inproc_shmem_arbiter_->SetDirectSMBPatchingSupportedByService();
+  for (size_t buf_idx = 0; buf_idx < src.buffers_index.size(); buf_idx++) {
+    BufferID src_buf_id = src.buffers_index[buf_idx];
+    if (buf_ids.count(src_buf_id) == 0)
+      continue;
+    auto buf_iter = buffers_.find(src_buf_id);
+    PERFETTO_CHECK(buf_iter != buffers_.end());
+    std::unique_ptr<TraceBuffer>& src_buf = buf_iter->second;
+    std::unique_ptr<TraceBuffer> new_buf;
+    if (src.config.buffers()[buf_idx].transfer_on_clone()) {
+      const auto buf_policy = src_buf->overwrite_policy();
+      const auto buf_size = src_buf->size();
+      const auto buf_type = src_buf->buf_type();
+      new_buf = std::move(src_buf);
+      switch (buf_type) {
+        case TraceBuffer::kV1:
+          src_buf = TraceBufferV1::Create(buf_size, buf_policy);
+          break;
+        case TraceBuffer::kV2:
+          src_buf = TraceBufferV2::Create(buf_size, buf_policy);
+          break;
+        case TraceBuffer::kV1WithV2Shadow:
+          src_buf = TraceBufferV1WithV2Shadow::Create(buf_size, buf_policy);
+          break;
+      }
+      if (!src_buf) {
+        // If the allocation fails put the buffer back and let the code below
+        // handle the failure gracefully.
+        src_buf = std::move(new_buf);
+      }
+    } else {
+      new_buf = src_buf->CloneReadOnly();
+    }
+    if (!new_buf.get()) {
+      return false;
+    }
+    clone_op->buffers[buf_idx] = std::move(new_buf);
+    clone_op->buffer_cloned_timestamps[buf_idx] = now;
   }
-
-  OnTracingSetup();
-  service_->UpdateMemoryGuardrail();
-}
-
-SharedMemory* TracingServiceImpl::ProducerEndpointImpl::shared_memory() const {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  return shared_memory_.get();
+  return true;
 }
 
-size_t TracingServiceImpl::ProducerEndpointImpl::shared_buffer_page_size_kb()
-    const {
-  return shared_buffer_page_size_kb_;
-}
+base::Status TracingServiceImpl::FinishCloneSession(
+    ConsumerEndpointImpl* consumer,
+    TracingSessionID src_tsid,
+    std::vector<std::unique_ptr<TraceBuffer>> buf_snaps,
+    std::vector<int64_t> buf_cloned_timestamps,
+    bool skip_trace_filter,
+    bool final_flush_outcome,
+    std::optional<TriggerInfo> clone_trigger,
+    base::Uuid* new_uuid,
+    int64_t clone_started_timestamp_ns,
+    base::ScopedFile output_file_fd) {
+  PERFETTO_DLOG("CloneSession(%" PRIu64
+                ", skip_trace_filter=%d) started, consumer uid: %d",
+                src_tsid, skip_trace_filter, static_cast<int>(consumer->uid_));
 
-void TracingServiceImpl::ProducerEndpointImpl::ActivateTriggers(
-    const std::vector<std::string>& triggers) {
-  service_->ActivateTriggers(id_, triggers);
-}
+  TracingSession* src = GetTracingSession(src_tsid);
 
-void TracingServiceImpl::ProducerEndpointImpl::StopDataSource(
-    DataSourceInstanceID ds_inst_id) {
-  // TODO(primiano): When we'll support tearing down the SMB, at this point we
-  // should send the Producer a TearDownTracing if all its data sources have
-  // been disabled (see b/77532839 and aosp/655179 PS1).
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  auto weak_this = weak_ptr_factory_.GetWeakPtr();
-  task_runner_->PostTask([weak_this, ds_inst_id] {
-    if (weak_this)
-      weak_this->producer_->StopDataSource(ds_inst_id);
-  });
-}
+  // The session might be gone by the time we try to clone it.
+  if (!src)
+    return PERFETTO_SVC_ERR("session not found");
 
-SharedMemoryArbiter*
-TracingServiceImpl::ProducerEndpointImpl::MaybeSharedMemoryArbiter() {
-  if (!inproc_shmem_arbiter_) {
-    PERFETTO_FATAL(
-        "The in-process SharedMemoryArbiter can only be used when "
-        "CreateProducer has been called with in_process=true and after tracing "
-        "has started.");
+  if (consumer->tracing_session_id_) {
+    return PERFETTO_SVC_ERR(
+        "The consumer is already attached to another tracing session");
   }
 
-  PERFETTO_DCHECK(in_process_);
-  return inproc_shmem_arbiter_.get();
-}
+  std::vector<BufferID> buf_ids =
+      buffer_ids_.AllocateMultiple(buf_snaps.size());
+  if (buf_ids.size() != buf_snaps.size()) {
+    return PERFETTO_SVC_ERR("Buffer id allocation failed");
+  }
 
-bool TracingServiceImpl::ProducerEndpointImpl::IsShmemProvidedByProducer()
-    const {
-  return is_shmem_provided_by_producer_;
-}
+  PERFETTO_CHECK(std::none_of(
+      buf_snaps.begin(), buf_snaps.end(),
+      [](const std::unique_ptr<TraceBuffer>& buf) { return buf == nullptr; }));
 
-// Can be called on any thread.
-std::unique_ptr<TraceWriter>
-TracingServiceImpl::ProducerEndpointImpl::CreateTraceWriter(
-    BufferID buf_id,
-    BufferExhaustedPolicy buffer_exhausted_policy) {
-  PERFETTO_DCHECK(MaybeSharedMemoryArbiter());
-  return MaybeSharedMemoryArbiter()->CreateTraceWriter(buf_id,
-                                                       buffer_exhausted_policy);
-}
+  const TracingSessionID tsid = ++last_tracing_session_id_;
+  TracingSession* cloned_session =
+      &tracing_sessions_
+           .emplace(std::piecewise_construct, std::forward_as_tuple(tsid),
+                    std::forward_as_tuple(tsid, consumer, src->config,
+                                          weak_runner_.task_runner()))
+           .first->second;
 
-void TracingServiceImpl::ProducerEndpointImpl::NotifyFlushComplete(
-    FlushRequestID id) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  PERFETTO_DCHECK(MaybeSharedMemoryArbiter());
-  return MaybeSharedMemoryArbiter()->NotifyFlushComplete(id);
-}
+  // Generate a new UUID for the cloned session, but preserve the LSB. In some
+  // contexts the LSB is used to tie the trace back to the statsd subscription
+  // that triggered it. See the corresponding code in perfetto_cmd.cc which
+  // reads at triggering_subscription_id().
+  const int64_t orig_uuid_lsb = src->trace_uuid.lsb();
+  cloned_session->state = TracingSession::CLONED_READ_ONLY;
+  cloned_session->trace_uuid = base::Uuidv4();
+  cloned_session->trace_uuid.set_lsb(orig_uuid_lsb);
+  *new_uuid = cloned_session->trace_uuid;
+
+  for (size_t i = 0; i < buf_snaps.size(); i++) {
+    BufferID buf_global_id = buf_ids[i];
+    std::unique_ptr<TraceBuffer>& buf = buf_snaps[i];
+    // This is only needed for transfer_on_clone. Other buffers are already
+    // marked as read-only by CloneReadOnly(). We cannot do this early because
+    // in case of an allocation failure we will put std::move() the original
+    // buffer back in its place and in that case should not be made read-only.
+    buf->set_read_only();
+    buffers_.emplace(buf_global_id, std::move(buf));
+    cloned_session->buffers_index.emplace_back(buf_global_id);
+  }
+  UpdateMemoryGuardrail();
 
-void TracingServiceImpl::ProducerEndpointImpl::OnTracingSetup() {
-  auto weak_this = weak_ptr_factory_.GetWeakPtr();
-  task_runner_->PostTask([weak_this] {
-    if (weak_this)
-      weak_this->producer_->OnTracingSetup();
-  });
-}
+  // Copy over relevant state that we want to persist in the cloned session.
+  // Mostly stats and metadata that is emitted in the trace file by the service.
+  // Also clear the received trigger list in the main tracing session. A
+  // CLONE_SNAPSHOT session can go in ring buffer mode for several hours and get
+  // snapshotted several times. This causes two issues with `received_triggers`:
+  // 1. Adding noise in the cloned trace emitting triggers that happened too
+  //    far back (see b/290799105).
+  // 2. Bloating memory (see b/290798988).
+  cloned_session->should_emit_stats = true;
+  cloned_session->clone_trigger = clone_trigger;
+  cloned_session->received_triggers = std::move(src->received_triggers);
+  src->received_triggers.clear();
+  src->num_triggers_emitted_into_trace = 0;
+  cloned_session->lifecycle_events =
+      std::vector<TracingSession::LifecycleEvent>(src->lifecycle_events);
+  cloned_session->slow_start_event = src->slow_start_event;
+  cloned_session->last_flush_events = src->last_flush_events;
+  cloned_session->initial_clock_snapshot = src->initial_clock_snapshot;
+  cloned_session->clock_snapshot_ring_buffer = src->clock_snapshot_ring_buffer;
+  cloned_session->invalid_packets = src->invalid_packets;
+  cloned_session->flushes_requested = src->flushes_requested;
+  cloned_session->flushes_succeeded = src->flushes_succeeded;
+  cloned_session->flushes_failed = src->flushes_failed;
+  cloned_session->compress_deflate = src->compress_deflate;
+  if (src->trace_filter && !skip_trace_filter) {
+    // Copy the trace filter, unless it's a clone-for-bugreport (b/317065412).
+    cloned_session->trace_filter.reset(
+        new protozero::MessageFilter(src->trace_filter->config()));
+  }
 
-void TracingServiceImpl::ProducerEndpointImpl::Flush(
-    FlushRequestID flush_request_id,
-    const std::vector<DataSourceInstanceID>& data_sources) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  auto weak_this = weak_ptr_factory_.GetWeakPtr();
-  task_runner_->PostTask([weak_this, flush_request_id, data_sources] {
-    if (weak_this) {
-      weak_this->producer_->Flush(flush_request_id, data_sources.data(),
-                                  data_sources.size());
-    }
-  });
-}
+  cloned_session->buffer_cloned_timestamps = std::move(buf_cloned_timestamps);
 
-void TracingServiceImpl::ProducerEndpointImpl::SetupDataSource(
-    DataSourceInstanceID ds_id,
-    const DataSourceConfig& config) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  allowed_target_buffers_.insert(static_cast<BufferID>(config.target_buffer()));
-  auto weak_this = weak_ptr_factory_.GetWeakPtr();
-  task_runner_->PostTask([weak_this, ds_id, config] {
-    if (weak_this)
-      weak_this->producer_->SetupDataSource(ds_id, std::move(config));
-  });
-}
+  SetSingleLifecycleEvent(
+      cloned_session,
+      protos::pbzero::TracingServiceEvent::kCloneStartedFieldNumber,
+      clone_started_timestamp_ns);
 
-void TracingServiceImpl::ProducerEndpointImpl::StartDataSource(
-    DataSourceInstanceID ds_id,
-    const DataSourceConfig& config) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  auto weak_this = weak_ptr_factory_.GetWeakPtr();
-  task_runner_->PostTask([weak_this, ds_id, config] {
-    if (weak_this)
-      weak_this->producer_->StartDataSource(ds_id, std::move(config));
-  });
-}
+  SnapshotLifecycleEvent(
+      cloned_session,
+      protos::pbzero::TracingServiceEvent::kTracingDisabledFieldNumber,
+      true /* snapshot_clocks */);
 
-void TracingServiceImpl::ProducerEndpointImpl::NotifyDataSourceStarted(
-    DataSourceInstanceID data_source_id) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  service_->NotifyDataSourceStarted(id_, data_source_id);
-}
+  PERFETTO_DLOG("Consumer (uid:%d) cloned tracing session %" PRIu64
+                " -> %" PRIu64,
+                static_cast<int>(consumer->uid_), src_tsid, tsid);
 
-void TracingServiceImpl::ProducerEndpointImpl::NotifyDataSourceStopped(
-    DataSourceInstanceID data_source_id) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  service_->NotifyDataSourceStopped(id_, data_source_id);
-}
+  consumer->tracing_session_id_ = tsid;
+  cloned_session->final_flush_outcome = final_flush_outcome
+                                            ? TraceStats::FINAL_FLUSH_SUCCEEDED
+                                            : TraceStats::FINAL_FLUSH_FAILED;
+  if (output_file_fd) {
+    cloned_session->write_into_file = std::move(output_file_fd);
+    cloned_session->write_period_ms = 0;
+    // Buffers are flushed, no need to flush again before reading into file.
+    ReadBuffersIntoFile(cloned_session->id,
+                        /* async_flush_buffers_before_read= */ false);
+  }
 
-void TracingServiceImpl::ProducerEndpointImpl::OnFreeBuffers(
-    const std::vector<BufferID>& target_buffers) {
-  if (allowed_target_buffers_.empty())
-    return;
-  for (BufferID buffer : target_buffers)
-    allowed_target_buffers_.erase(buffer);
+  return base::OkStatus();
 }
 
-void TracingServiceImpl::ProducerEndpointImpl::ClearIncrementalState(
-    const std::vector<DataSourceInstanceID>& data_sources) {
-  PERFETTO_DCHECK_THREAD(thread_checker_);
-  auto weak_this = weak_ptr_factory_.GetWeakPtr();
-  task_runner_->PostTask([weak_this, data_sources] {
-    if (weak_this) {
-      base::StringView producer_name(weak_this->name_);
-      weak_this->producer_->ClearIncrementalState(data_sources.data(),
-                                                  data_sources.size());
-    }
-  });
-}
+}  // namespace tracing_service
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/service/tracing_service_session.cc
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-void TracingServiceImpl::ProducerEndpointImpl::Sync(
-    std::function<void()> callback) {
-  task_runner_->PostTask(callback);
-}
+// gen_amalgamated expanded: #include "src/tracing/service/tracing_service_session.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/perfetto/tracing_service_event.pbzero.h"
+// gen_amalgamated expanded: #include "src/protozero/filtering/message_filter.h"
+// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer.h"
+// gen_amalgamated expanded: #include "src/tracing/service/tracing_service_endpoints_impl.h"
 
-////////////////////////////////////////////////////////////////////////////////
-// TracingServiceImpl::TracingSession implementation
-////////////////////////////////////////////////////////////////////////////////
+namespace perfetto::tracing_service {
 
-TracingServiceImpl::TracingSession::TracingSession(
-    TracingSessionID session_id,
-    ConsumerEndpointImpl* consumer,
-    const TraceConfig& new_config,
-    base::TaskRunner* task_runner)
+TracingSession::TracingSession(TracingSessionID session_id,
+                               ConsumerEndpointImpl* consumer,
+                               const TraceConfig& new_config,
+                               base::TaskRunner* task_runner)
     : id(session_id),
       consumer_maybe_null(consumer),
       consumer_uid(consumer->uid_),
       config(new_config),
       snapshot_periodic_task(task_runner),
       timed_stop_task(task_runner) {
-  // all_data_sources_flushed is special because we store up to 64 events of
-  // this type. Other events will go through the default case in
+  // all_data_sources_flushed (and flush_started) is special because we store up
+  // to 64 events of this type. Other events will go through the default case in
   // SnapshotLifecycleEvent() where they will be given a max history of 1.
   lifecycle_events.emplace_back(
       protos::pbzero::TracingServiceEvent::kAllDataSourcesFlushedFieldNumber,
       64 /* max_size */);
+  lifecycle_events.emplace_back(
+      protos::pbzero::TracingServiceEvent::kFlushStartedFieldNumber,
+      64 /* max_size */);
 }
 
-}  // namespace perfetto
+bool TracingSession::IsCloneAllowed(uid_t clone_uid) const {
+  if (clone_uid == 0)
+    return true;  // Root is always allowed to clone everything.
+  if (clone_uid == this->consumer_uid)
+    return true;  // Allow cloning if the uids match.
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+  // On Android allow shell to clone sessions marked as exported for bugreport.
+  // Dumpstate (invoked by adb bugreport) invokes commands as shell.
+  if (clone_uid == AID_SHELL && this->config.bugreport_score() > 0)
+    return true;
+#endif
+  return false;
+}
+
+PacketSequenceID TracingSession::GetPacketSequenceID(MachineID machine_id,
+                                                     ProducerID producer_id,
+                                                     WriterID writer_id) {
+  auto key = std::make_tuple(machine_id, producer_id, writer_id);
+  auto it = packet_sequence_ids.find(key);
+  if (it != packet_sequence_ids.end())
+    return it->second;
+  // We shouldn't run out of sequence IDs (producer ID is 16 bit, writer IDs
+  // are limited to 1024).
+  static_assert(kMaxPacketSequenceID > kMaxProducerID * kMaxWriterID,
+                "PacketSequenceID value space doesn't cover service "
+                "sequence ID and all producer/writer ID combinations!");
+  PERFETTO_DCHECK(last_packet_sequence_id < kMaxPacketSequenceID);
+  PacketSequenceID sequence_id = ++last_packet_sequence_id;
+  packet_sequence_ids[key] = sequence_id;
+  return sequence_id;
+}
+
+DataSourceInstance* TracingSession::GetDataSourceInstance(
+    ProducerID producer_id,
+    DataSourceInstanceID instance_id) {
+  for (auto& inst_kv : data_source_instances) {
+    if (inst_kv.first != producer_id ||
+        inst_kv.second.instance_id != instance_id) {
+      continue;
+    }
+    return &inst_kv.second;
+  }
+  return nullptr;
+}
+
+bool TracingSession::AllDataSourceInstancesStarted() {
+  return std::all_of(data_source_instances.begin(), data_source_instances.end(),
+                     [](decltype(data_source_instances)::const_reference x) {
+                       return x.second.state == DataSourceInstance::STARTED;
+                     });
+}
+
+bool TracingSession::AllDataSourceInstancesStopped() {
+  return std::all_of(data_source_instances.begin(), data_source_instances.end(),
+                     [](decltype(data_source_instances)::const_reference x) {
+                       return x.second.state == DataSourceInstance::STOPPED;
+                     });
+}
+
+}  // namespace perfetto::tracing_service
 // gen_amalgamated begin source: src/tracing/internal/in_process_tracing_backend.cc
 /*
  * Copyright (C) 2019 The Android Open Source Project
@@ -64869,9 +68595,12 @@ TracingServiceImpl::TracingSession::TracingSession(
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
 // gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/paged_memory.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/client_identity.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h"
 
+// gen_amalgamated expanded: #include "src/tracing/core/in_process_shared_memory.h"
+
 // TODO(primiano): When the in-process backend is used, we should never end up
 // in a situation where the thread where the TracingService and Producer live
 // writes a packet and hence can get into the GetNewChunk() stall.
@@ -64884,60 +68613,21 @@ TracingServiceImpl::TracingSession::TracingSession(
 namespace perfetto {
 namespace internal {
 
-namespace {
-
-class InProcessShm : public SharedMemory {
- public:
-  explicit InProcessShm(size_t size);
-  ~InProcessShm() override;
-  void* start() const override;
-  size_t size() const override;
-
- private:
-  base::PagedMemory mem_;
-};
-
-class InProcessShmFactory : public SharedMemory::Factory {
- public:
-  ~InProcessShmFactory() override;
-  std::unique_ptr<SharedMemory> CreateSharedMemory(size_t) override;
-};
-
-InProcessShm::~InProcessShm() = default;
-
-InProcessShm::InProcessShm(size_t size)
-    : mem_(base::PagedMemory::Allocate(size)) {}
-
-void* InProcessShm::start() const {
-  return mem_.Get();
-}
-
-size_t InProcessShm::size() const {
-  return mem_.size();
-}
-
-InProcessShmFactory::~InProcessShmFactory() = default;
-std::unique_ptr<SharedMemory> InProcessShmFactory::CreateSharedMemory(
-    size_t size) {
-  return std::unique_ptr<SharedMemory>(new InProcessShm(size));
-}
-
-}  // namespace
-
 // static
 TracingBackend* InProcessTracingBackend::GetInstance() {
   static auto* instance = new InProcessTracingBackend();
   return instance;
 }
 
-InProcessTracingBackend::InProcessTracingBackend() {}
+InProcessTracingBackend::InProcessTracingBackend() = default;
+InProcessTracingBackend::~InProcessTracingBackend() = default;
 
 std::unique_ptr<ProducerEndpoint> InProcessTracingBackend::ConnectProducer(
     const ConnectProducerArgs& args) {
   PERFETTO_DCHECK(args.task_runner->RunsTasksOnCurrentThread());
   return GetOrCreateService(args.task_runner)
-      ->ConnectProducer(args.producer, /*uid=*/0, /*pid=*/0, args.producer_name,
-                        args.shmem_size_hint_bytes,
+      ->ConnectProducer(args.producer, ClientIdentity(/*uid=*/0, /*pid=*/0),
+                        args.producer_name, args.shmem_size_hint_bytes,
                         /*in_process=*/true,
                         TracingService::ProducerSMBScrapingMode::kEnabled,
                         args.shmem_page_size_hint_bytes);
@@ -64952,7 +68642,8 @@ std::unique_ptr<ConsumerEndpoint> InProcessTracingBackend::ConnectConsumer(
 TracingService* InProcessTracingBackend::GetOrCreateService(
     base::TaskRunner* task_runner) {
   if (!service_) {
-    std::unique_ptr<InProcessShmFactory> shm(new InProcessShmFactory());
+    std::unique_ptr<InProcessSharedMemory::Factory> shm(
+        new InProcessSharedMemory::Factory());
     service_ = TracingService::CreateInstance(std::move(shm), task_runner);
     service_->SetSMBScrapingEnabled(true);
   }
@@ -64962,1160 +68653,6 @@ TracingService* InProcessTracingBackend::GetOrCreateService(
 }  // namespace internal
 }  // namespace perfetto
 // gen_amalgamated begin source: gen/protos/perfetto/ipc/consumer_port.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/ipc/consumer_port.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_CONSUMER_PORT_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_CONSUMER_PORT_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class CloneSessionResponse;
-class CloneSessionRequest;
-class SaveTraceForBugreportResponse;
-class SaveTraceForBugreportRequest;
-class QueryCapabilitiesResponse;
-class TracingServiceCapabilities;
-class QueryCapabilitiesRequest;
-class QueryServiceStateResponse;
-class TracingServiceState;
-class TracingServiceState_TracingSession;
-class TracingServiceState_DataSource;
-class DataSourceDescriptor;
-class TracingServiceState_Producer;
-class QueryServiceStateRequest;
-class ObserveEventsResponse;
-class ObservableEvents;
-class ObservableEvents_DataSourceInstanceStateChange;
-class ObserveEventsRequest;
-class GetTraceStatsResponse;
-class TraceStats;
-class TraceStats_FilterStats;
-class TraceStats_BufferStats;
-class GetTraceStatsRequest;
-class AttachResponse;
-class TraceConfig;
-class TraceConfig_CmdTraceStartDelay;
-class TraceConfig_AndroidReportConfig;
-class TraceConfig_TraceFilter;
-class TraceConfig_IncidentReportConfig;
-class TraceConfig_IncrementalStateConfig;
-class TraceConfig_TriggerConfig;
-class TraceConfig_TriggerConfig_Trigger;
-class TraceConfig_GuardrailOverrides;
-class TraceConfig_StatsdMetadata;
-class TraceConfig_ProducerConfig;
-class TraceConfig_BuiltinDataSource;
-class TraceConfig_DataSource;
-class DataSourceConfig;
-class TestConfig;
-class TestConfig_DummyFields;
-class InterceptorConfig;
-class ChromeConfig;
-class SystemInfoConfig;
-class TraceConfig_BufferConfig;
-class AttachRequest;
-class DetachResponse;
-class DetachRequest;
-class FlushResponse;
-class FlushRequest;
-class FreeBuffersResponse;
-class FreeBuffersRequest;
-class ReadBuffersResponse;
-class ReadBuffersResponse_Slice;
-class ReadBuffersRequest;
-class DisableTracingResponse;
-class DisableTracingRequest;
-class ChangeTraceConfigResponse;
-class ChangeTraceConfigRequest;
-class StartTracingResponse;
-class StartTracingRequest;
-class EnableTracingResponse;
-class EnableTracingRequest;
-enum ObservableEvents_Type : int;
-enum ObservableEvents_DataSourceInstanceState : int;
-enum TraceStats_FinalFlushOutcome : int;
-enum TraceConfig_LockdownModeOperation : int;
-enum TraceConfig_CompressionType : int;
-enum TraceConfig_StatsdLogging : int;
-enum TraceConfig_TriggerConfig_TriggerMode : int;
-enum BuiltinClock : int;
-enum DataSourceConfig_SessionInitiator : int;
-enum ChromeConfig_ClientPriority : int;
-enum TraceConfig_BufferConfig_FillPolicy : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT CloneSessionResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kSuccessFieldNumber = 1,
-    kErrorFieldNumber = 2,
-  };
-
-  CloneSessionResponse();
-  ~CloneSessionResponse() override;
-  CloneSessionResponse(CloneSessionResponse&&) noexcept;
-  CloneSessionResponse& operator=(CloneSessionResponse&&);
-  CloneSessionResponse(const CloneSessionResponse&);
-  CloneSessionResponse& operator=(const CloneSessionResponse&);
-  bool operator==(const CloneSessionResponse&) const;
-  bool operator!=(const CloneSessionResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_success() const { return _has_field_[1]; }
-  bool success() const { return success_; }
-  void set_success(bool value) { success_ = value; _has_field_.set(1); }
-
-  bool has_error() const { return _has_field_[2]; }
-  const std::string& error() const { return error_; }
-  void set_error(const std::string& value) { error_ = value; _has_field_.set(2); }
-
- private:
-  bool success_{};
-  std::string error_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT CloneSessionRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kSessionIdFieldNumber = 1,
-  };
-
-  CloneSessionRequest();
-  ~CloneSessionRequest() override;
-  CloneSessionRequest(CloneSessionRequest&&) noexcept;
-  CloneSessionRequest& operator=(CloneSessionRequest&&);
-  CloneSessionRequest(const CloneSessionRequest&);
-  CloneSessionRequest& operator=(const CloneSessionRequest&);
-  bool operator==(const CloneSessionRequest&) const;
-  bool operator!=(const CloneSessionRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_session_id() const { return _has_field_[1]; }
-  uint64_t session_id() const { return session_id_; }
-  void set_session_id(uint64_t value) { session_id_ = value; _has_field_.set(1); }
-
- private:
-  uint64_t session_id_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT SaveTraceForBugreportResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kSuccessFieldNumber = 1,
-    kMsgFieldNumber = 2,
-  };
-
-  SaveTraceForBugreportResponse();
-  ~SaveTraceForBugreportResponse() override;
-  SaveTraceForBugreportResponse(SaveTraceForBugreportResponse&&) noexcept;
-  SaveTraceForBugreportResponse& operator=(SaveTraceForBugreportResponse&&);
-  SaveTraceForBugreportResponse(const SaveTraceForBugreportResponse&);
-  SaveTraceForBugreportResponse& operator=(const SaveTraceForBugreportResponse&);
-  bool operator==(const SaveTraceForBugreportResponse&) const;
-  bool operator!=(const SaveTraceForBugreportResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_success() const { return _has_field_[1]; }
-  bool success() const { return success_; }
-  void set_success(bool value) { success_ = value; _has_field_.set(1); }
-
-  bool has_msg() const { return _has_field_[2]; }
-  const std::string& msg() const { return msg_; }
-  void set_msg(const std::string& value) { msg_ = value; _has_field_.set(2); }
-
- private:
-  bool success_{};
-  std::string msg_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT SaveTraceForBugreportRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  SaveTraceForBugreportRequest();
-  ~SaveTraceForBugreportRequest() override;
-  SaveTraceForBugreportRequest(SaveTraceForBugreportRequest&&) noexcept;
-  SaveTraceForBugreportRequest& operator=(SaveTraceForBugreportRequest&&);
-  SaveTraceForBugreportRequest(const SaveTraceForBugreportRequest&);
-  SaveTraceForBugreportRequest& operator=(const SaveTraceForBugreportRequest&);
-  bool operator==(const SaveTraceForBugreportRequest&) const;
-  bool operator!=(const SaveTraceForBugreportRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT QueryCapabilitiesResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kCapabilitiesFieldNumber = 1,
-  };
-
-  QueryCapabilitiesResponse();
-  ~QueryCapabilitiesResponse() override;
-  QueryCapabilitiesResponse(QueryCapabilitiesResponse&&) noexcept;
-  QueryCapabilitiesResponse& operator=(QueryCapabilitiesResponse&&);
-  QueryCapabilitiesResponse(const QueryCapabilitiesResponse&);
-  QueryCapabilitiesResponse& operator=(const QueryCapabilitiesResponse&);
-  bool operator==(const QueryCapabilitiesResponse&) const;
-  bool operator!=(const QueryCapabilitiesResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_capabilities() const { return _has_field_[1]; }
-  const TracingServiceCapabilities& capabilities() const { return *capabilities_; }
-  TracingServiceCapabilities* mutable_capabilities() { _has_field_.set(1); return capabilities_.get(); }
-
- private:
-  ::protozero::CopyablePtr<TracingServiceCapabilities> capabilities_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT QueryCapabilitiesRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  QueryCapabilitiesRequest();
-  ~QueryCapabilitiesRequest() override;
-  QueryCapabilitiesRequest(QueryCapabilitiesRequest&&) noexcept;
-  QueryCapabilitiesRequest& operator=(QueryCapabilitiesRequest&&);
-  QueryCapabilitiesRequest(const QueryCapabilitiesRequest&);
-  QueryCapabilitiesRequest& operator=(const QueryCapabilitiesRequest&);
-  bool operator==(const QueryCapabilitiesRequest&) const;
-  bool operator!=(const QueryCapabilitiesRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT QueryServiceStateResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kServiceStateFieldNumber = 1,
-  };
-
-  QueryServiceStateResponse();
-  ~QueryServiceStateResponse() override;
-  QueryServiceStateResponse(QueryServiceStateResponse&&) noexcept;
-  QueryServiceStateResponse& operator=(QueryServiceStateResponse&&);
-  QueryServiceStateResponse(const QueryServiceStateResponse&);
-  QueryServiceStateResponse& operator=(const QueryServiceStateResponse&);
-  bool operator==(const QueryServiceStateResponse&) const;
-  bool operator!=(const QueryServiceStateResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_service_state() const { return _has_field_[1]; }
-  const TracingServiceState& service_state() const { return *service_state_; }
-  TracingServiceState* mutable_service_state() { _has_field_.set(1); return service_state_.get(); }
-
- private:
-  ::protozero::CopyablePtr<TracingServiceState> service_state_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT QueryServiceStateRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  QueryServiceStateRequest();
-  ~QueryServiceStateRequest() override;
-  QueryServiceStateRequest(QueryServiceStateRequest&&) noexcept;
-  QueryServiceStateRequest& operator=(QueryServiceStateRequest&&);
-  QueryServiceStateRequest(const QueryServiceStateRequest&);
-  QueryServiceStateRequest& operator=(const QueryServiceStateRequest&);
-  bool operator==(const QueryServiceStateRequest&) const;
-  bool operator!=(const QueryServiceStateRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT ObserveEventsResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kEventsFieldNumber = 1,
-  };
-
-  ObserveEventsResponse();
-  ~ObserveEventsResponse() override;
-  ObserveEventsResponse(ObserveEventsResponse&&) noexcept;
-  ObserveEventsResponse& operator=(ObserveEventsResponse&&);
-  ObserveEventsResponse(const ObserveEventsResponse&);
-  ObserveEventsResponse& operator=(const ObserveEventsResponse&);
-  bool operator==(const ObserveEventsResponse&) const;
-  bool operator!=(const ObserveEventsResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_events() const { return _has_field_[1]; }
-  const ObservableEvents& events() const { return *events_; }
-  ObservableEvents* mutable_events() { _has_field_.set(1); return events_.get(); }
-
- private:
-  ::protozero::CopyablePtr<ObservableEvents> events_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT ObserveEventsRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kEventsToObserveFieldNumber = 1,
-  };
-
-  ObserveEventsRequest();
-  ~ObserveEventsRequest() override;
-  ObserveEventsRequest(ObserveEventsRequest&&) noexcept;
-  ObserveEventsRequest& operator=(ObserveEventsRequest&&);
-  ObserveEventsRequest(const ObserveEventsRequest&);
-  ObserveEventsRequest& operator=(const ObserveEventsRequest&);
-  bool operator==(const ObserveEventsRequest&) const;
-  bool operator!=(const ObserveEventsRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<ObservableEvents_Type>& events_to_observe() const { return events_to_observe_; }
-  std::vector<ObservableEvents_Type>* mutable_events_to_observe() { return &events_to_observe_; }
-  int events_to_observe_size() const { return static_cast<int>(events_to_observe_.size()); }
-  void clear_events_to_observe() { events_to_observe_.clear(); }
-  void add_events_to_observe(ObservableEvents_Type value) { events_to_observe_.emplace_back(value); }
-  ObservableEvents_Type* add_events_to_observe() { events_to_observe_.emplace_back(); return &events_to_observe_.back(); }
-
- private:
-  std::vector<ObservableEvents_Type> events_to_observe_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT GetTraceStatsResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kTraceStatsFieldNumber = 1,
-  };
-
-  GetTraceStatsResponse();
-  ~GetTraceStatsResponse() override;
-  GetTraceStatsResponse(GetTraceStatsResponse&&) noexcept;
-  GetTraceStatsResponse& operator=(GetTraceStatsResponse&&);
-  GetTraceStatsResponse(const GetTraceStatsResponse&);
-  GetTraceStatsResponse& operator=(const GetTraceStatsResponse&);
-  bool operator==(const GetTraceStatsResponse&) const;
-  bool operator!=(const GetTraceStatsResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_trace_stats() const { return _has_field_[1]; }
-  const TraceStats& trace_stats() const { return *trace_stats_; }
-  TraceStats* mutable_trace_stats() { _has_field_.set(1); return trace_stats_.get(); }
-
- private:
-  ::protozero::CopyablePtr<TraceStats> trace_stats_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT GetTraceStatsRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  GetTraceStatsRequest();
-  ~GetTraceStatsRequest() override;
-  GetTraceStatsRequest(GetTraceStatsRequest&&) noexcept;
-  GetTraceStatsRequest& operator=(GetTraceStatsRequest&&);
-  GetTraceStatsRequest(const GetTraceStatsRequest&);
-  GetTraceStatsRequest& operator=(const GetTraceStatsRequest&);
-  bool operator==(const GetTraceStatsRequest&) const;
-  bool operator!=(const GetTraceStatsRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT AttachResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kTraceConfigFieldNumber = 1,
-  };
-
-  AttachResponse();
-  ~AttachResponse() override;
-  AttachResponse(AttachResponse&&) noexcept;
-  AttachResponse& operator=(AttachResponse&&);
-  AttachResponse(const AttachResponse&);
-  AttachResponse& operator=(const AttachResponse&);
-  bool operator==(const AttachResponse&) const;
-  bool operator!=(const AttachResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_trace_config() const { return _has_field_[1]; }
-  const TraceConfig& trace_config() const { return *trace_config_; }
-  TraceConfig* mutable_trace_config() { _has_field_.set(1); return trace_config_.get(); }
-
- private:
-  ::protozero::CopyablePtr<TraceConfig> trace_config_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT AttachRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kKeyFieldNumber = 1,
-  };
-
-  AttachRequest();
-  ~AttachRequest() override;
-  AttachRequest(AttachRequest&&) noexcept;
-  AttachRequest& operator=(AttachRequest&&);
-  AttachRequest(const AttachRequest&);
-  AttachRequest& operator=(const AttachRequest&);
-  bool operator==(const AttachRequest&) const;
-  bool operator!=(const AttachRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_key() const { return _has_field_[1]; }
-  const std::string& key() const { return key_; }
-  void set_key(const std::string& value) { key_ = value; _has_field_.set(1); }
-
- private:
-  std::string key_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT DetachResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  DetachResponse();
-  ~DetachResponse() override;
-  DetachResponse(DetachResponse&&) noexcept;
-  DetachResponse& operator=(DetachResponse&&);
-  DetachResponse(const DetachResponse&);
-  DetachResponse& operator=(const DetachResponse&);
-  bool operator==(const DetachResponse&) const;
-  bool operator!=(const DetachResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT DetachRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kKeyFieldNumber = 1,
-  };
-
-  DetachRequest();
-  ~DetachRequest() override;
-  DetachRequest(DetachRequest&&) noexcept;
-  DetachRequest& operator=(DetachRequest&&);
-  DetachRequest(const DetachRequest&);
-  DetachRequest& operator=(const DetachRequest&);
-  bool operator==(const DetachRequest&) const;
-  bool operator!=(const DetachRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_key() const { return _has_field_[1]; }
-  const std::string& key() const { return key_; }
-  void set_key(const std::string& value) { key_ = value; _has_field_.set(1); }
-
- private:
-  std::string key_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT FlushResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  FlushResponse();
-  ~FlushResponse() override;
-  FlushResponse(FlushResponse&&) noexcept;
-  FlushResponse& operator=(FlushResponse&&);
-  FlushResponse(const FlushResponse&);
-  FlushResponse& operator=(const FlushResponse&);
-  bool operator==(const FlushResponse&) const;
-  bool operator!=(const FlushResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT FlushRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kTimeoutMsFieldNumber = 1,
-  };
-
-  FlushRequest();
-  ~FlushRequest() override;
-  FlushRequest(FlushRequest&&) noexcept;
-  FlushRequest& operator=(FlushRequest&&);
-  FlushRequest(const FlushRequest&);
-  FlushRequest& operator=(const FlushRequest&);
-  bool operator==(const FlushRequest&) const;
-  bool operator!=(const FlushRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_timeout_ms() const { return _has_field_[1]; }
-  uint32_t timeout_ms() const { return timeout_ms_; }
-  void set_timeout_ms(uint32_t value) { timeout_ms_ = value; _has_field_.set(1); }
-
- private:
-  uint32_t timeout_ms_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT FreeBuffersResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  FreeBuffersResponse();
-  ~FreeBuffersResponse() override;
-  FreeBuffersResponse(FreeBuffersResponse&&) noexcept;
-  FreeBuffersResponse& operator=(FreeBuffersResponse&&);
-  FreeBuffersResponse(const FreeBuffersResponse&);
-  FreeBuffersResponse& operator=(const FreeBuffersResponse&);
-  bool operator==(const FreeBuffersResponse&) const;
-  bool operator!=(const FreeBuffersResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT FreeBuffersRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kBufferIdsFieldNumber = 1,
-  };
-
-  FreeBuffersRequest();
-  ~FreeBuffersRequest() override;
-  FreeBuffersRequest(FreeBuffersRequest&&) noexcept;
-  FreeBuffersRequest& operator=(FreeBuffersRequest&&);
-  FreeBuffersRequest(const FreeBuffersRequest&);
-  FreeBuffersRequest& operator=(const FreeBuffersRequest&);
-  bool operator==(const FreeBuffersRequest&) const;
-  bool operator!=(const FreeBuffersRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<uint32_t>& buffer_ids() const { return buffer_ids_; }
-  std::vector<uint32_t>* mutable_buffer_ids() { return &buffer_ids_; }
-  int buffer_ids_size() const { return static_cast<int>(buffer_ids_.size()); }
-  void clear_buffer_ids() { buffer_ids_.clear(); }
-  void add_buffer_ids(uint32_t value) { buffer_ids_.emplace_back(value); }
-  uint32_t* add_buffer_ids() { buffer_ids_.emplace_back(); return &buffer_ids_.back(); }
-
- private:
-  std::vector<uint32_t> buffer_ids_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT ReadBuffersResponse : public ::protozero::CppMessageObj {
- public:
-  using Slice = ReadBuffersResponse_Slice;
-  enum FieldNumbers {
-    kSlicesFieldNumber = 2,
-  };
-
-  ReadBuffersResponse();
-  ~ReadBuffersResponse() override;
-  ReadBuffersResponse(ReadBuffersResponse&&) noexcept;
-  ReadBuffersResponse& operator=(ReadBuffersResponse&&);
-  ReadBuffersResponse(const ReadBuffersResponse&);
-  ReadBuffersResponse& operator=(const ReadBuffersResponse&);
-  bool operator==(const ReadBuffersResponse&) const;
-  bool operator!=(const ReadBuffersResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<ReadBuffersResponse_Slice>& slices() const { return slices_; }
-  std::vector<ReadBuffersResponse_Slice>* mutable_slices() { return &slices_; }
-  int slices_size() const;
-  void clear_slices();
-  ReadBuffersResponse_Slice* add_slices();
-
- private:
-  std::vector<ReadBuffersResponse_Slice> slices_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT ReadBuffersResponse_Slice : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kDataFieldNumber = 1,
-    kLastSliceForPacketFieldNumber = 2,
-  };
-
-  ReadBuffersResponse_Slice();
-  ~ReadBuffersResponse_Slice() override;
-  ReadBuffersResponse_Slice(ReadBuffersResponse_Slice&&) noexcept;
-  ReadBuffersResponse_Slice& operator=(ReadBuffersResponse_Slice&&);
-  ReadBuffersResponse_Slice(const ReadBuffersResponse_Slice&);
-  ReadBuffersResponse_Slice& operator=(const ReadBuffersResponse_Slice&);
-  bool operator==(const ReadBuffersResponse_Slice&) const;
-  bool operator!=(const ReadBuffersResponse_Slice& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_data() const { return _has_field_[1]; }
-  const std::string& data() const { return data_; }
-  void set_data(const std::string& value) { data_ = value; _has_field_.set(1); }
-  void set_data(const void* p, size_t s) { data_.assign(reinterpret_cast<const char*>(p), s); _has_field_.set(1); }
-
-  bool has_last_slice_for_packet() const { return _has_field_[2]; }
-  bool last_slice_for_packet() const { return last_slice_for_packet_; }
-  void set_last_slice_for_packet(bool value) { last_slice_for_packet_ = value; _has_field_.set(2); }
-
- private:
-  std::string data_{};
-  bool last_slice_for_packet_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT ReadBuffersRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  ReadBuffersRequest();
-  ~ReadBuffersRequest() override;
-  ReadBuffersRequest(ReadBuffersRequest&&) noexcept;
-  ReadBuffersRequest& operator=(ReadBuffersRequest&&);
-  ReadBuffersRequest(const ReadBuffersRequest&);
-  ReadBuffersRequest& operator=(const ReadBuffersRequest&);
-  bool operator==(const ReadBuffersRequest&) const;
-  bool operator!=(const ReadBuffersRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT DisableTracingResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  DisableTracingResponse();
-  ~DisableTracingResponse() override;
-  DisableTracingResponse(DisableTracingResponse&&) noexcept;
-  DisableTracingResponse& operator=(DisableTracingResponse&&);
-  DisableTracingResponse(const DisableTracingResponse&);
-  DisableTracingResponse& operator=(const DisableTracingResponse&);
-  bool operator==(const DisableTracingResponse&) const;
-  bool operator!=(const DisableTracingResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT DisableTracingRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  DisableTracingRequest();
-  ~DisableTracingRequest() override;
-  DisableTracingRequest(DisableTracingRequest&&) noexcept;
-  DisableTracingRequest& operator=(DisableTracingRequest&&);
-  DisableTracingRequest(const DisableTracingRequest&);
-  DisableTracingRequest& operator=(const DisableTracingRequest&);
-  bool operator==(const DisableTracingRequest&) const;
-  bool operator!=(const DisableTracingRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT ChangeTraceConfigResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  ChangeTraceConfigResponse();
-  ~ChangeTraceConfigResponse() override;
-  ChangeTraceConfigResponse(ChangeTraceConfigResponse&&) noexcept;
-  ChangeTraceConfigResponse& operator=(ChangeTraceConfigResponse&&);
-  ChangeTraceConfigResponse(const ChangeTraceConfigResponse&);
-  ChangeTraceConfigResponse& operator=(const ChangeTraceConfigResponse&);
-  bool operator==(const ChangeTraceConfigResponse&) const;
-  bool operator!=(const ChangeTraceConfigResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT ChangeTraceConfigRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kTraceConfigFieldNumber = 1,
-  };
-
-  ChangeTraceConfigRequest();
-  ~ChangeTraceConfigRequest() override;
-  ChangeTraceConfigRequest(ChangeTraceConfigRequest&&) noexcept;
-  ChangeTraceConfigRequest& operator=(ChangeTraceConfigRequest&&);
-  ChangeTraceConfigRequest(const ChangeTraceConfigRequest&);
-  ChangeTraceConfigRequest& operator=(const ChangeTraceConfigRequest&);
-  bool operator==(const ChangeTraceConfigRequest&) const;
-  bool operator!=(const ChangeTraceConfigRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_trace_config() const { return _has_field_[1]; }
-  const TraceConfig& trace_config() const { return *trace_config_; }
-  TraceConfig* mutable_trace_config() { _has_field_.set(1); return trace_config_.get(); }
-
- private:
-  ::protozero::CopyablePtr<TraceConfig> trace_config_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT StartTracingResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  StartTracingResponse();
-  ~StartTracingResponse() override;
-  StartTracingResponse(StartTracingResponse&&) noexcept;
-  StartTracingResponse& operator=(StartTracingResponse&&);
-  StartTracingResponse(const StartTracingResponse&);
-  StartTracingResponse& operator=(const StartTracingResponse&);
-  bool operator==(const StartTracingResponse&) const;
-  bool operator!=(const StartTracingResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT StartTracingRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  StartTracingRequest();
-  ~StartTracingRequest() override;
-  StartTracingRequest(StartTracingRequest&&) noexcept;
-  StartTracingRequest& operator=(StartTracingRequest&&);
-  StartTracingRequest(const StartTracingRequest&);
-  StartTracingRequest& operator=(const StartTracingRequest&);
-  bool operator==(const StartTracingRequest&) const;
-  bool operator!=(const StartTracingRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT EnableTracingResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kDisabledFieldNumber = 1,
-    kErrorFieldNumber = 3,
-  };
-
-  EnableTracingResponse();
-  ~EnableTracingResponse() override;
-  EnableTracingResponse(EnableTracingResponse&&) noexcept;
-  EnableTracingResponse& operator=(EnableTracingResponse&&);
-  EnableTracingResponse(const EnableTracingResponse&);
-  EnableTracingResponse& operator=(const EnableTracingResponse&);
-  bool operator==(const EnableTracingResponse&) const;
-  bool operator!=(const EnableTracingResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_disabled() const { return _has_field_[1]; }
-  bool disabled() const { return disabled_; }
-  void set_disabled(bool value) { disabled_ = value; _has_field_.set(1); }
-
-  bool has_error() const { return _has_field_[3]; }
-  const std::string& error() const { return error_; }
-  void set_error(const std::string& value) { error_ = value; _has_field_.set(3); }
-
- private:
-  bool disabled_{};
-  std::string error_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<4> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT EnableTracingRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kTraceConfigFieldNumber = 1,
-    kAttachNotificationOnlyFieldNumber = 2,
-  };
-
-  EnableTracingRequest();
-  ~EnableTracingRequest() override;
-  EnableTracingRequest(EnableTracingRequest&&) noexcept;
-  EnableTracingRequest& operator=(EnableTracingRequest&&);
-  EnableTracingRequest(const EnableTracingRequest&);
-  EnableTracingRequest& operator=(const EnableTracingRequest&);
-  bool operator==(const EnableTracingRequest&) const;
-  bool operator!=(const EnableTracingRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_trace_config() const { return _has_field_[1]; }
-  const TraceConfig& trace_config() const { return *trace_config_; }
-  TraceConfig* mutable_trace_config() { _has_field_.set(1); return trace_config_.get(); }
-
-  bool has_attach_notification_only() const { return _has_field_[2]; }
-  bool attach_notification_only() const { return attach_notification_only_; }
-  void set_attach_notification_only(bool value) { attach_notification_only_ = value; _has_field_.set(2); }
-
- private:
-  ::protozero::CopyablePtr<TraceConfig> trace_config_;
-  bool attach_notification_only_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_CONSUMER_PORT_PROTO_CPP_H_
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -66128,8 +68665,11 @@ class PERFETTO_EXPORT_COMPONENT EnableTracingRequest : public ::protozero::CppMe
 #endif
 // gen_amalgamated expanded: #include "protos/perfetto/ipc/consumer_port.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/trace_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/priority_boost/priority_boost_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/data_source_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/system_info/system_info.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/qnx/qnx_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/histogram_samples.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/system_info/system_info_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/track_event/track_event_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/test_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/sys_stats/sys_stats_config.gen.h"
@@ -66141,27 +68681,48 @@ class PERFETTO_EXPORT_COMPONENT EnableTracingRequest : public ::protozero::CppMe
 // gen_amalgamated expanded: #include "protos/perfetto/config/process_stats/process_stats_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/statsd/statsd_tracing_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/statsd/atom_ids.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/protovm/protovm_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/power/android_power_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/interceptor_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/interceptors/console_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/inode_file/inode_file_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/gpu/gpu_renderstages_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/gpu/vulkan_memory_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/gpu/gpu_counter_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/ftrace/frozen_ftrace_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/ftrace/ftrace_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/system_metrics.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/etw/etw_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/v8_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/chrome/chrome_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/windowmanager_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/user_list_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/surfaceflinger_transactions_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/surfaceflinger_layers_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/protolog_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/protolog_common.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/pixel_modem_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/android/packages_list_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/android/network_trace_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/kernel_wakelocks_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/inputmethod_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/cpu_per_uid_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/app_wakelock_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_sdk_sysprop_guard_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_system_property_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_polled_state_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_log_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/common/android_log_constants.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_input_event_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_game_intervention_list_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/semantic_type.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/common/builtin_clock.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/common/trace_stats.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/common/tracing_service_capabilities.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/common/observable_events.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/common/tracing_service_state.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/common/data_source_descriptor.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/protovm/vm_program.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/common/track_event_descriptor.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/common/gpu_counter_descriptor.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/common/ftrace_descriptor.gen.h"
@@ -66179,9 +68740,12 @@ CloneSessionResponse::CloneSessionResponse(CloneSessionResponse&&) noexcept = de
 CloneSessionResponse& CloneSessionResponse::operator=(CloneSessionResponse&&) = default;
 
 bool CloneSessionResponse::operator==(const CloneSessionResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && success_ == other.success_
-   && error_ == other.error_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(success_, other.success_)
+   && ::protozero::internal::gen_helpers::EqualsField(error_, other.error_)
+   && ::protozero::internal::gen_helpers::EqualsField(uuid_msb_, other.uuid_msb_)
+   && ::protozero::internal::gen_helpers::EqualsField(uuid_lsb_, other.uuid_lsb_)
+   && ::protozero::internal::gen_helpers::EqualsField(was_write_into_file_, other.was_write_into_file_);
 }
 
 bool CloneSessionResponse::ParseFromArray(const void* raw, size_t size) {
@@ -66200,6 +68764,15 @@ bool CloneSessionResponse::ParseFromArray(const void* raw, size_t size) {
       case 2 /* error */:
         ::protozero::internal::gen_helpers::DeserializeString(field, &error_);
         break;
+      case 3 /* uuid_msb */:
+        field.get(&uuid_msb_);
+        break;
+      case 4 /* uuid_lsb */:
+        field.get(&uuid_lsb_);
+        break;
+      case 5 /* was_write_into_file */:
+        field.get(&was_write_into_file_);
+        break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
         break;
@@ -66231,6 +68804,21 @@ void CloneSessionResponse::Serialize(::protozero::Message* msg) const {
     ::protozero::internal::gen_helpers::SerializeString(2, error_, msg);
   }
 
+  // Field 3: uuid_msb
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, uuid_msb_, msg);
+  }
+
+  // Field 4: uuid_lsb
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(4, uuid_lsb_, msg);
+  }
+
+  // Field 5: was_write_into_file
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(5, was_write_into_file_, msg);
+  }
+
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
@@ -66243,8 +68831,16 @@ CloneSessionRequest::CloneSessionRequest(CloneSessionRequest&&) noexcept = defau
 CloneSessionRequest& CloneSessionRequest::operator=(CloneSessionRequest&&) = default;
 
 bool CloneSessionRequest::operator==(const CloneSessionRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && session_id_ == other.session_id_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(session_id_, other.session_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(unique_session_name_, other.unique_session_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(skip_trace_filter_, other.skip_trace_filter_)
+   && ::protozero::internal::gen_helpers::EqualsField(for_bugreport_, other.for_bugreport_)
+   && ::protozero::internal::gen_helpers::EqualsField(clone_trigger_name_, other.clone_trigger_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(clone_trigger_producer_name_, other.clone_trigger_producer_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(clone_trigger_trusted_producer_uid_, other.clone_trigger_trusted_producer_uid_)
+   && ::protozero::internal::gen_helpers::EqualsField(clone_trigger_boot_time_ns_, other.clone_trigger_boot_time_ns_)
+   && ::protozero::internal::gen_helpers::EqualsField(clone_trigger_delay_ms_, other.clone_trigger_delay_ms_);
 }
 
 bool CloneSessionRequest::ParseFromArray(const void* raw, size_t size) {
@@ -66260,6 +68856,30 @@ bool CloneSessionRequest::ParseFromArray(const void* raw, size_t size) {
       case 1 /* session_id */:
         field.get(&session_id_);
         break;
+      case 4 /* unique_session_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &unique_session_name_);
+        break;
+      case 2 /* skip_trace_filter */:
+        field.get(&skip_trace_filter_);
+        break;
+      case 3 /* for_bugreport */:
+        field.get(&for_bugreport_);
+        break;
+      case 5 /* clone_trigger_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &clone_trigger_name_);
+        break;
+      case 6 /* clone_trigger_producer_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &clone_trigger_producer_name_);
+        break;
+      case 7 /* clone_trigger_trusted_producer_uid */:
+        field.get(&clone_trigger_trusted_producer_uid_);
+        break;
+      case 8 /* clone_trigger_boot_time_ns */:
+        field.get(&clone_trigger_boot_time_ns_);
+        break;
+      case 9 /* clone_trigger_delay_ms */:
+        field.get(&clone_trigger_delay_ms_);
+        break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
         break;
@@ -66286,6 +68906,46 @@ void CloneSessionRequest::Serialize(::protozero::Message* msg) const {
     ::protozero::internal::gen_helpers::SerializeVarInt(1, session_id_, msg);
   }
 
+  // Field 4: unique_session_name
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeString(4, unique_session_name_, msg);
+  }
+
+  // Field 2: skip_trace_filter
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, skip_trace_filter_, msg);
+  }
+
+  // Field 3: for_bugreport
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, for_bugreport_, msg);
+  }
+
+  // Field 5: clone_trigger_name
+  if (_has_field_[5]) {
+    ::protozero::internal::gen_helpers::SerializeString(5, clone_trigger_name_, msg);
+  }
+
+  // Field 6: clone_trigger_producer_name
+  if (_has_field_[6]) {
+    ::protozero::internal::gen_helpers::SerializeString(6, clone_trigger_producer_name_, msg);
+  }
+
+  // Field 7: clone_trigger_trusted_producer_uid
+  if (_has_field_[7]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(7, clone_trigger_trusted_producer_uid_, msg);
+  }
+
+  // Field 8: clone_trigger_boot_time_ns
+  if (_has_field_[8]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(8, clone_trigger_boot_time_ns_, msg);
+  }
+
+  // Field 9: clone_trigger_delay_ms
+  if (_has_field_[9]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(9, clone_trigger_delay_ms_, msg);
+  }
+
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
@@ -66298,9 +68958,9 @@ SaveTraceForBugreportResponse::SaveTraceForBugreportResponse(SaveTraceForBugrepo
 SaveTraceForBugreportResponse& SaveTraceForBugreportResponse::operator=(SaveTraceForBugreportResponse&&) = default;
 
 bool SaveTraceForBugreportResponse::operator==(const SaveTraceForBugreportResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && success_ == other.success_
-   && msg_ == other.msg_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(success_, other.success_)
+   && ::protozero::internal::gen_helpers::EqualsField(msg_, other.msg_);
 }
 
 bool SaveTraceForBugreportResponse::ParseFromArray(const void* raw, size_t size) {
@@ -66362,7 +69022,7 @@ SaveTraceForBugreportRequest::SaveTraceForBugreportRequest(SaveTraceForBugreport
 SaveTraceForBugreportRequest& SaveTraceForBugreportRequest::operator=(SaveTraceForBugreportRequest&&) = default;
 
 bool SaveTraceForBugreportRequest::operator==(const SaveTraceForBugreportRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
 bool SaveTraceForBugreportRequest::ParseFromArray(const void* raw, size_t size) {
@@ -66408,8 +69068,8 @@ QueryCapabilitiesResponse::QueryCapabilitiesResponse(QueryCapabilitiesResponse&&
 QueryCapabilitiesResponse& QueryCapabilitiesResponse::operator=(QueryCapabilitiesResponse&&) = default;
 
 bool QueryCapabilitiesResponse::operator==(const QueryCapabilitiesResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && capabilities_ == other.capabilities_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(capabilities_, other.capabilities_);
 }
 
 bool QueryCapabilitiesResponse::ParseFromArray(const void* raw, size_t size) {
@@ -66463,7 +69123,7 @@ QueryCapabilitiesRequest::QueryCapabilitiesRequest(QueryCapabilitiesRequest&&) n
 QueryCapabilitiesRequest& QueryCapabilitiesRequest::operator=(QueryCapabilitiesRequest&&) = default;
 
 bool QueryCapabilitiesRequest::operator==(const QueryCapabilitiesRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
 bool QueryCapabilitiesRequest::ParseFromArray(const void* raw, size_t size) {
@@ -66509,8 +69169,8 @@ QueryServiceStateResponse::QueryServiceStateResponse(QueryServiceStateResponse&&
 QueryServiceStateResponse& QueryServiceStateResponse::operator=(QueryServiceStateResponse&&) = default;
 
 bool QueryServiceStateResponse::operator==(const QueryServiceStateResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && service_state_ == other.service_state_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(service_state_, other.service_state_);
 }
 
 bool QueryServiceStateResponse::ParseFromArray(const void* raw, size_t size) {
@@ -66564,7 +69224,8 @@ QueryServiceStateRequest::QueryServiceStateRequest(QueryServiceStateRequest&&) n
 QueryServiceStateRequest& QueryServiceStateRequest::operator=(QueryServiceStateRequest&&) = default;
 
 bool QueryServiceStateRequest::operator==(const QueryServiceStateRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(sessions_only_, other.sessions_only_);
 }
 
 bool QueryServiceStateRequest::ParseFromArray(const void* raw, size_t size) {
@@ -66577,6 +69238,9 @@ bool QueryServiceStateRequest::ParseFromArray(const void* raw, size_t size) {
       _has_field_.set(field.id());
     }
     switch (field.id()) {
+      case 1 /* sessions_only */:
+        field.get(&sessions_only_);
+        break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
         break;
@@ -66598,6 +69262,11 @@ std::vector<uint8_t> QueryServiceStateRequest::SerializeAsArray() const {
 }
 
 void QueryServiceStateRequest::Serialize(::protozero::Message* msg) const {
+  // Field 1: sessions_only
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(1, sessions_only_, msg);
+  }
+
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
@@ -66610,8 +69279,8 @@ ObserveEventsResponse::ObserveEventsResponse(ObserveEventsResponse&&) noexcept =
 ObserveEventsResponse& ObserveEventsResponse::operator=(ObserveEventsResponse&&) = default;
 
 bool ObserveEventsResponse::operator==(const ObserveEventsResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && events_ == other.events_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(events_, other.events_);
 }
 
 bool ObserveEventsResponse::ParseFromArray(const void* raw, size_t size) {
@@ -66665,8 +69334,8 @@ ObserveEventsRequest::ObserveEventsRequest(ObserveEventsRequest&&) noexcept = de
 ObserveEventsRequest& ObserveEventsRequest::operator=(ObserveEventsRequest&&) = default;
 
 bool ObserveEventsRequest::operator==(const ObserveEventsRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && events_to_observe_ == other.events_to_observe_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(events_to_observe_, other.events_to_observe_);
 }
 
 bool ObserveEventsRequest::ParseFromArray(const void* raw, size_t size) {
@@ -66722,8 +69391,8 @@ GetTraceStatsResponse::GetTraceStatsResponse(GetTraceStatsResponse&&) noexcept =
 GetTraceStatsResponse& GetTraceStatsResponse::operator=(GetTraceStatsResponse&&) = default;
 
 bool GetTraceStatsResponse::operator==(const GetTraceStatsResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && trace_stats_ == other.trace_stats_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(trace_stats_, other.trace_stats_);
 }
 
 bool GetTraceStatsResponse::ParseFromArray(const void* raw, size_t size) {
@@ -66777,7 +69446,7 @@ GetTraceStatsRequest::GetTraceStatsRequest(GetTraceStatsRequest&&) noexcept = de
 GetTraceStatsRequest& GetTraceStatsRequest::operator=(GetTraceStatsRequest&&) = default;
 
 bool GetTraceStatsRequest::operator==(const GetTraceStatsRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
 bool GetTraceStatsRequest::ParseFromArray(const void* raw, size_t size) {
@@ -66823,8 +69492,8 @@ AttachResponse::AttachResponse(AttachResponse&&) noexcept = default;
 AttachResponse& AttachResponse::operator=(AttachResponse&&) = default;
 
 bool AttachResponse::operator==(const AttachResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && trace_config_ == other.trace_config_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(trace_config_, other.trace_config_);
 }
 
 bool AttachResponse::ParseFromArray(const void* raw, size_t size) {
@@ -66878,8 +69547,8 @@ AttachRequest::AttachRequest(AttachRequest&&) noexcept = default;
 AttachRequest& AttachRequest::operator=(AttachRequest&&) = default;
 
 bool AttachRequest::operator==(const AttachRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && key_ == other.key_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(key_, other.key_);
 }
 
 bool AttachRequest::ParseFromArray(const void* raw, size_t size) {
@@ -66933,7 +69602,7 @@ DetachResponse::DetachResponse(DetachResponse&&) noexcept = default;
 DetachResponse& DetachResponse::operator=(DetachResponse&&) = default;
 
 bool DetachResponse::operator==(const DetachResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
 bool DetachResponse::ParseFromArray(const void* raw, size_t size) {
@@ -66979,8 +69648,8 @@ DetachRequest::DetachRequest(DetachRequest&&) noexcept = default;
 DetachRequest& DetachRequest::operator=(DetachRequest&&) = default;
 
 bool DetachRequest::operator==(const DetachRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && key_ == other.key_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(key_, other.key_);
 }
 
 bool DetachRequest::ParseFromArray(const void* raw, size_t size) {
@@ -67034,7 +69703,7 @@ FlushResponse::FlushResponse(FlushResponse&&) noexcept = default;
 FlushResponse& FlushResponse::operator=(FlushResponse&&) = default;
 
 bool FlushResponse::operator==(const FlushResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
 bool FlushResponse::ParseFromArray(const void* raw, size_t size) {
@@ -67080,8 +69749,9 @@ FlushRequest::FlushRequest(FlushRequest&&) noexcept = default;
 FlushRequest& FlushRequest::operator=(FlushRequest&&) = default;
 
 bool FlushRequest::operator==(const FlushRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && timeout_ms_ == other.timeout_ms_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(timeout_ms_, other.timeout_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(flags_, other.flags_);
 }
 
 bool FlushRequest::ParseFromArray(const void* raw, size_t size) {
@@ -67097,6 +69767,9 @@ bool FlushRequest::ParseFromArray(const void* raw, size_t size) {
       case 1 /* timeout_ms */:
         field.get(&timeout_ms_);
         break;
+      case 2 /* flags */:
+        field.get(&flags_);
+        break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
         break;
@@ -67123,6 +69796,11 @@ void FlushRequest::Serialize(::protozero::Message* msg) const {
     ::protozero::internal::gen_helpers::SerializeVarInt(1, timeout_ms_, msg);
   }
 
+  // Field 2: flags
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, flags_, msg);
+  }
+
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
@@ -67135,7 +69813,7 @@ FreeBuffersResponse::FreeBuffersResponse(FreeBuffersResponse&&) noexcept = defau
 FreeBuffersResponse& FreeBuffersResponse::operator=(FreeBuffersResponse&&) = default;
 
 bool FreeBuffersResponse::operator==(const FreeBuffersResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
 bool FreeBuffersResponse::ParseFromArray(const void* raw, size_t size) {
@@ -67181,8 +69859,8 @@ FreeBuffersRequest::FreeBuffersRequest(FreeBuffersRequest&&) noexcept = default;
 FreeBuffersRequest& FreeBuffersRequest::operator=(FreeBuffersRequest&&) = default;
 
 bool FreeBuffersRequest::operator==(const FreeBuffersRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && buffer_ids_ == other.buffer_ids_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(buffer_ids_, other.buffer_ids_);
 }
 
 bool FreeBuffersRequest::ParseFromArray(const void* raw, size_t size) {
@@ -67238,8 +69916,8 @@ ReadBuffersResponse::ReadBuffersResponse(ReadBuffersResponse&&) noexcept = defau
 ReadBuffersResponse& ReadBuffersResponse::operator=(ReadBuffersResponse&&) = default;
 
 bool ReadBuffersResponse::operator==(const ReadBuffersResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && slices_ == other.slices_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(slices_, other.slices_);
 }
 
 int ReadBuffersResponse::slices_size() const { return static_cast<int>(slices_.size()); }
@@ -67298,9 +69976,9 @@ ReadBuffersResponse_Slice::ReadBuffersResponse_Slice(ReadBuffersResponse_Slice&&
 ReadBuffersResponse_Slice& ReadBuffersResponse_Slice::operator=(ReadBuffersResponse_Slice&&) = default;
 
 bool ReadBuffersResponse_Slice::operator==(const ReadBuffersResponse_Slice& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && data_ == other.data_
-   && last_slice_for_packet_ == other.last_slice_for_packet_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(data_, other.data_)
+   && ::protozero::internal::gen_helpers::EqualsField(last_slice_for_packet_, other.last_slice_for_packet_);
 }
 
 bool ReadBuffersResponse_Slice::ParseFromArray(const void* raw, size_t size) {
@@ -67362,7 +70040,7 @@ ReadBuffersRequest::ReadBuffersRequest(ReadBuffersRequest&&) noexcept = default;
 ReadBuffersRequest& ReadBuffersRequest::operator=(ReadBuffersRequest&&) = default;
 
 bool ReadBuffersRequest::operator==(const ReadBuffersRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
 bool ReadBuffersRequest::ParseFromArray(const void* raw, size_t size) {
@@ -67408,7 +70086,7 @@ DisableTracingResponse::DisableTracingResponse(DisableTracingResponse&&) noexcep
 DisableTracingResponse& DisableTracingResponse::operator=(DisableTracingResponse&&) = default;
 
 bool DisableTracingResponse::operator==(const DisableTracingResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
 bool DisableTracingResponse::ParseFromArray(const void* raw, size_t size) {
@@ -67454,7 +70132,7 @@ DisableTracingRequest::DisableTracingRequest(DisableTracingRequest&&) noexcept =
 DisableTracingRequest& DisableTracingRequest::operator=(DisableTracingRequest&&) = default;
 
 bool DisableTracingRequest::operator==(const DisableTracingRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
 bool DisableTracingRequest::ParseFromArray(const void* raw, size_t size) {
@@ -67500,7 +70178,7 @@ ChangeTraceConfigResponse::ChangeTraceConfigResponse(ChangeTraceConfigResponse&&
 ChangeTraceConfigResponse& ChangeTraceConfigResponse::operator=(ChangeTraceConfigResponse&&) = default;
 
 bool ChangeTraceConfigResponse::operator==(const ChangeTraceConfigResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
 bool ChangeTraceConfigResponse::ParseFromArray(const void* raw, size_t size) {
@@ -67546,8 +70224,8 @@ ChangeTraceConfigRequest::ChangeTraceConfigRequest(ChangeTraceConfigRequest&&) n
 ChangeTraceConfigRequest& ChangeTraceConfigRequest::operator=(ChangeTraceConfigRequest&&) = default;
 
 bool ChangeTraceConfigRequest::operator==(const ChangeTraceConfigRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && trace_config_ == other.trace_config_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(trace_config_, other.trace_config_);
 }
 
 bool ChangeTraceConfigRequest::ParseFromArray(const void* raw, size_t size) {
@@ -67601,7 +70279,7 @@ StartTracingResponse::StartTracingResponse(StartTracingResponse&&) noexcept = de
 StartTracingResponse& StartTracingResponse::operator=(StartTracingResponse&&) = default;
 
 bool StartTracingResponse::operator==(const StartTracingResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
 bool StartTracingResponse::ParseFromArray(const void* raw, size_t size) {
@@ -67647,7 +70325,7 @@ StartTracingRequest::StartTracingRequest(StartTracingRequest&&) noexcept = defau
 StartTracingRequest& StartTracingRequest::operator=(StartTracingRequest&&) = default;
 
 bool StartTracingRequest::operator==(const StartTracingRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
 bool StartTracingRequest::ParseFromArray(const void* raw, size_t size) {
@@ -67693,9 +70371,9 @@ EnableTracingResponse::EnableTracingResponse(EnableTracingResponse&&) noexcept =
 EnableTracingResponse& EnableTracingResponse::operator=(EnableTracingResponse&&) = default;
 
 bool EnableTracingResponse::operator==(const EnableTracingResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && disabled_ == other.disabled_
-   && error_ == other.error_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(disabled_, other.disabled_)
+   && ::protozero::internal::gen_helpers::EqualsField(error_, other.error_);
 }
 
 bool EnableTracingResponse::ParseFromArray(const void* raw, size_t size) {
@@ -67757,9 +70435,9 @@ EnableTracingRequest::EnableTracingRequest(EnableTracingRequest&&) noexcept = de
 EnableTracingRequest& EnableTracingRequest::operator=(EnableTracingRequest&&) = default;
 
 bool EnableTracingRequest::operator==(const EnableTracingRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && trace_config_ == other.trace_config_
-   && attach_notification_only_ == other.attach_notification_only_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(trace_config_, other.trace_config_)
+   && ::protozero::internal::gen_helpers::EqualsField(attach_notification_only_, other.attach_notification_only_);
 }
 
 bool EnableTracingRequest::ParseFromArray(const void* raw, size_t size) {
@@ -67819,1156 +70497,6 @@ void EnableTracingRequest::Serialize(::protozero::Message* msg) const {
 #pragma GCC diagnostic pop
 #endif
 // gen_amalgamated begin source: gen/protos/perfetto/ipc/producer_port.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/ipc/producer_port.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_PRODUCER_PORT_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_PRODUCER_PORT_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class SyncResponse;
-class SyncRequest;
-class GetAsyncCommandResponse;
-class GetAsyncCommandResponse_ClearIncrementalState;
-class GetAsyncCommandResponse_Flush;
-class GetAsyncCommandResponse_StopDataSource;
-class GetAsyncCommandResponse_StartDataSource;
-class DataSourceConfig;
-class TestConfig;
-class TestConfig_DummyFields;
-class InterceptorConfig;
-class ChromeConfig;
-class SystemInfoConfig;
-class GetAsyncCommandResponse_SetupDataSource;
-class GetAsyncCommandResponse_SetupTracing;
-class GetAsyncCommandRequest;
-class ActivateTriggersResponse;
-class ActivateTriggersRequest;
-class NotifyDataSourceStoppedResponse;
-class NotifyDataSourceStoppedRequest;
-class NotifyDataSourceStartedResponse;
-class NotifyDataSourceStartedRequest;
-class CommitDataResponse;
-class UnregisterTraceWriterResponse;
-class UnregisterTraceWriterRequest;
-class RegisterTraceWriterResponse;
-class RegisterTraceWriterRequest;
-class UnregisterDataSourceResponse;
-class UnregisterDataSourceRequest;
-class UpdateDataSourceResponse;
-class UpdateDataSourceRequest;
-class DataSourceDescriptor;
-class RegisterDataSourceResponse;
-class RegisterDataSourceRequest;
-class InitializeConnectionResponse;
-class InitializeConnectionRequest;
-enum DataSourceConfig_SessionInitiator : int;
-enum ChromeConfig_ClientPriority : int;
-enum InitializeConnectionRequest_ProducerSMBScrapingMode : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum InitializeConnectionRequest_ProducerSMBScrapingMode : int {
-  InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_UNSPECIFIED = 0,
-  InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_ENABLED = 1,
-  InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_DISABLED = 2,
-};
-
-class PERFETTO_EXPORT_COMPONENT SyncResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  SyncResponse();
-  ~SyncResponse() override;
-  SyncResponse(SyncResponse&&) noexcept;
-  SyncResponse& operator=(SyncResponse&&);
-  SyncResponse(const SyncResponse&);
-  SyncResponse& operator=(const SyncResponse&);
-  bool operator==(const SyncResponse&) const;
-  bool operator!=(const SyncResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT SyncRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  SyncRequest();
-  ~SyncRequest() override;
-  SyncRequest(SyncRequest&&) noexcept;
-  SyncRequest& operator=(SyncRequest&&);
-  SyncRequest(const SyncRequest&);
-  SyncRequest& operator=(const SyncRequest&);
-  bool operator==(const SyncRequest&) const;
-  bool operator!=(const SyncRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT GetAsyncCommandResponse : public ::protozero::CppMessageObj {
- public:
-  using SetupDataSource = GetAsyncCommandResponse_SetupDataSource;
-  using StartDataSource = GetAsyncCommandResponse_StartDataSource;
-  using StopDataSource = GetAsyncCommandResponse_StopDataSource;
-  using SetupTracing = GetAsyncCommandResponse_SetupTracing;
-  using Flush = GetAsyncCommandResponse_Flush;
-  using ClearIncrementalState = GetAsyncCommandResponse_ClearIncrementalState;
-  enum FieldNumbers {
-    kSetupTracingFieldNumber = 3,
-    kSetupDataSourceFieldNumber = 6,
-    kStartDataSourceFieldNumber = 1,
-    kStopDataSourceFieldNumber = 2,
-    kFlushFieldNumber = 5,
-    kClearIncrementalStateFieldNumber = 7,
-  };
-
-  GetAsyncCommandResponse();
-  ~GetAsyncCommandResponse() override;
-  GetAsyncCommandResponse(GetAsyncCommandResponse&&) noexcept;
-  GetAsyncCommandResponse& operator=(GetAsyncCommandResponse&&);
-  GetAsyncCommandResponse(const GetAsyncCommandResponse&);
-  GetAsyncCommandResponse& operator=(const GetAsyncCommandResponse&);
-  bool operator==(const GetAsyncCommandResponse&) const;
-  bool operator!=(const GetAsyncCommandResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_setup_tracing() const { return _has_field_[3]; }
-  const GetAsyncCommandResponse_SetupTracing& setup_tracing() const { return *setup_tracing_; }
-  GetAsyncCommandResponse_SetupTracing* mutable_setup_tracing() { _has_field_.set(3); return setup_tracing_.get(); }
-
-  bool has_setup_data_source() const { return _has_field_[6]; }
-  const GetAsyncCommandResponse_SetupDataSource& setup_data_source() const { return *setup_data_source_; }
-  GetAsyncCommandResponse_SetupDataSource* mutable_setup_data_source() { _has_field_.set(6); return setup_data_source_.get(); }
-
-  bool has_start_data_source() const { return _has_field_[1]; }
-  const GetAsyncCommandResponse_StartDataSource& start_data_source() const { return *start_data_source_; }
-  GetAsyncCommandResponse_StartDataSource* mutable_start_data_source() { _has_field_.set(1); return start_data_source_.get(); }
-
-  bool has_stop_data_source() const { return _has_field_[2]; }
-  const GetAsyncCommandResponse_StopDataSource& stop_data_source() const { return *stop_data_source_; }
-  GetAsyncCommandResponse_StopDataSource* mutable_stop_data_source() { _has_field_.set(2); return stop_data_source_.get(); }
-
-  bool has_flush() const { return _has_field_[5]; }
-  const GetAsyncCommandResponse_Flush& flush() const { return *flush_; }
-  GetAsyncCommandResponse_Flush* mutable_flush() { _has_field_.set(5); return flush_.get(); }
-
-  bool has_clear_incremental_state() const { return _has_field_[7]; }
-  const GetAsyncCommandResponse_ClearIncrementalState& clear_incremental_state() const { return *clear_incremental_state_; }
-  GetAsyncCommandResponse_ClearIncrementalState* mutable_clear_incremental_state() { _has_field_.set(7); return clear_incremental_state_.get(); }
-
- private:
-  ::protozero::CopyablePtr<GetAsyncCommandResponse_SetupTracing> setup_tracing_;
-  ::protozero::CopyablePtr<GetAsyncCommandResponse_SetupDataSource> setup_data_source_;
-  ::protozero::CopyablePtr<GetAsyncCommandResponse_StartDataSource> start_data_source_;
-  ::protozero::CopyablePtr<GetAsyncCommandResponse_StopDataSource> stop_data_source_;
-  ::protozero::CopyablePtr<GetAsyncCommandResponse_Flush> flush_;
-  ::protozero::CopyablePtr<GetAsyncCommandResponse_ClearIncrementalState> clear_incremental_state_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<8> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT GetAsyncCommandResponse_ClearIncrementalState : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kDataSourceIdsFieldNumber = 1,
-  };
-
-  GetAsyncCommandResponse_ClearIncrementalState();
-  ~GetAsyncCommandResponse_ClearIncrementalState() override;
-  GetAsyncCommandResponse_ClearIncrementalState(GetAsyncCommandResponse_ClearIncrementalState&&) noexcept;
-  GetAsyncCommandResponse_ClearIncrementalState& operator=(GetAsyncCommandResponse_ClearIncrementalState&&);
-  GetAsyncCommandResponse_ClearIncrementalState(const GetAsyncCommandResponse_ClearIncrementalState&);
-  GetAsyncCommandResponse_ClearIncrementalState& operator=(const GetAsyncCommandResponse_ClearIncrementalState&);
-  bool operator==(const GetAsyncCommandResponse_ClearIncrementalState&) const;
-  bool operator!=(const GetAsyncCommandResponse_ClearIncrementalState& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<uint64_t>& data_source_ids() const { return data_source_ids_; }
-  std::vector<uint64_t>* mutable_data_source_ids() { return &data_source_ids_; }
-  int data_source_ids_size() const { return static_cast<int>(data_source_ids_.size()); }
-  void clear_data_source_ids() { data_source_ids_.clear(); }
-  void add_data_source_ids(uint64_t value) { data_source_ids_.emplace_back(value); }
-  uint64_t* add_data_source_ids() { data_source_ids_.emplace_back(); return &data_source_ids_.back(); }
-
- private:
-  std::vector<uint64_t> data_source_ids_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT GetAsyncCommandResponse_Flush : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kDataSourceIdsFieldNumber = 1,
-    kRequestIdFieldNumber = 2,
-  };
-
-  GetAsyncCommandResponse_Flush();
-  ~GetAsyncCommandResponse_Flush() override;
-  GetAsyncCommandResponse_Flush(GetAsyncCommandResponse_Flush&&) noexcept;
-  GetAsyncCommandResponse_Flush& operator=(GetAsyncCommandResponse_Flush&&);
-  GetAsyncCommandResponse_Flush(const GetAsyncCommandResponse_Flush&);
-  GetAsyncCommandResponse_Flush& operator=(const GetAsyncCommandResponse_Flush&);
-  bool operator==(const GetAsyncCommandResponse_Flush&) const;
-  bool operator!=(const GetAsyncCommandResponse_Flush& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<uint64_t>& data_source_ids() const { return data_source_ids_; }
-  std::vector<uint64_t>* mutable_data_source_ids() { return &data_source_ids_; }
-  int data_source_ids_size() const { return static_cast<int>(data_source_ids_.size()); }
-  void clear_data_source_ids() { data_source_ids_.clear(); }
-  void add_data_source_ids(uint64_t value) { data_source_ids_.emplace_back(value); }
-  uint64_t* add_data_source_ids() { data_source_ids_.emplace_back(); return &data_source_ids_.back(); }
-
-  bool has_request_id() const { return _has_field_[2]; }
-  uint64_t request_id() const { return request_id_; }
-  void set_request_id(uint64_t value) { request_id_ = value; _has_field_.set(2); }
-
- private:
-  std::vector<uint64_t> data_source_ids_;
-  uint64_t request_id_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT GetAsyncCommandResponse_StopDataSource : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kInstanceIdFieldNumber = 1,
-  };
-
-  GetAsyncCommandResponse_StopDataSource();
-  ~GetAsyncCommandResponse_StopDataSource() override;
-  GetAsyncCommandResponse_StopDataSource(GetAsyncCommandResponse_StopDataSource&&) noexcept;
-  GetAsyncCommandResponse_StopDataSource& operator=(GetAsyncCommandResponse_StopDataSource&&);
-  GetAsyncCommandResponse_StopDataSource(const GetAsyncCommandResponse_StopDataSource&);
-  GetAsyncCommandResponse_StopDataSource& operator=(const GetAsyncCommandResponse_StopDataSource&);
-  bool operator==(const GetAsyncCommandResponse_StopDataSource&) const;
-  bool operator!=(const GetAsyncCommandResponse_StopDataSource& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_instance_id() const { return _has_field_[1]; }
-  uint64_t instance_id() const { return instance_id_; }
-  void set_instance_id(uint64_t value) { instance_id_ = value; _has_field_.set(1); }
-
- private:
-  uint64_t instance_id_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT GetAsyncCommandResponse_StartDataSource : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kNewInstanceIdFieldNumber = 1,
-    kConfigFieldNumber = 2,
-  };
-
-  GetAsyncCommandResponse_StartDataSource();
-  ~GetAsyncCommandResponse_StartDataSource() override;
-  GetAsyncCommandResponse_StartDataSource(GetAsyncCommandResponse_StartDataSource&&) noexcept;
-  GetAsyncCommandResponse_StartDataSource& operator=(GetAsyncCommandResponse_StartDataSource&&);
-  GetAsyncCommandResponse_StartDataSource(const GetAsyncCommandResponse_StartDataSource&);
-  GetAsyncCommandResponse_StartDataSource& operator=(const GetAsyncCommandResponse_StartDataSource&);
-  bool operator==(const GetAsyncCommandResponse_StartDataSource&) const;
-  bool operator!=(const GetAsyncCommandResponse_StartDataSource& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_new_instance_id() const { return _has_field_[1]; }
-  uint64_t new_instance_id() const { return new_instance_id_; }
-  void set_new_instance_id(uint64_t value) { new_instance_id_ = value; _has_field_.set(1); }
-
-  bool has_config() const { return _has_field_[2]; }
-  const DataSourceConfig& config() const { return *config_; }
-  DataSourceConfig* mutable_config() { _has_field_.set(2); return config_.get(); }
-
- private:
-  uint64_t new_instance_id_{};
-  ::protozero::CopyablePtr<DataSourceConfig> config_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT GetAsyncCommandResponse_SetupDataSource : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kNewInstanceIdFieldNumber = 1,
-    kConfigFieldNumber = 2,
-  };
-
-  GetAsyncCommandResponse_SetupDataSource();
-  ~GetAsyncCommandResponse_SetupDataSource() override;
-  GetAsyncCommandResponse_SetupDataSource(GetAsyncCommandResponse_SetupDataSource&&) noexcept;
-  GetAsyncCommandResponse_SetupDataSource& operator=(GetAsyncCommandResponse_SetupDataSource&&);
-  GetAsyncCommandResponse_SetupDataSource(const GetAsyncCommandResponse_SetupDataSource&);
-  GetAsyncCommandResponse_SetupDataSource& operator=(const GetAsyncCommandResponse_SetupDataSource&);
-  bool operator==(const GetAsyncCommandResponse_SetupDataSource&) const;
-  bool operator!=(const GetAsyncCommandResponse_SetupDataSource& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_new_instance_id() const { return _has_field_[1]; }
-  uint64_t new_instance_id() const { return new_instance_id_; }
-  void set_new_instance_id(uint64_t value) { new_instance_id_ = value; _has_field_.set(1); }
-
-  bool has_config() const { return _has_field_[2]; }
-  const DataSourceConfig& config() const { return *config_; }
-  DataSourceConfig* mutable_config() { _has_field_.set(2); return config_.get(); }
-
- private:
-  uint64_t new_instance_id_{};
-  ::protozero::CopyablePtr<DataSourceConfig> config_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT GetAsyncCommandResponse_SetupTracing : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kSharedBufferPageSizeKbFieldNumber = 1,
-    kShmKeyWindowsFieldNumber = 2,
-  };
-
-  GetAsyncCommandResponse_SetupTracing();
-  ~GetAsyncCommandResponse_SetupTracing() override;
-  GetAsyncCommandResponse_SetupTracing(GetAsyncCommandResponse_SetupTracing&&) noexcept;
-  GetAsyncCommandResponse_SetupTracing& operator=(GetAsyncCommandResponse_SetupTracing&&);
-  GetAsyncCommandResponse_SetupTracing(const GetAsyncCommandResponse_SetupTracing&);
-  GetAsyncCommandResponse_SetupTracing& operator=(const GetAsyncCommandResponse_SetupTracing&);
-  bool operator==(const GetAsyncCommandResponse_SetupTracing&) const;
-  bool operator!=(const GetAsyncCommandResponse_SetupTracing& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_shared_buffer_page_size_kb() const { return _has_field_[1]; }
-  uint32_t shared_buffer_page_size_kb() const { return shared_buffer_page_size_kb_; }
-  void set_shared_buffer_page_size_kb(uint32_t value) { shared_buffer_page_size_kb_ = value; _has_field_.set(1); }
-
-  bool has_shm_key_windows() const { return _has_field_[2]; }
-  const std::string& shm_key_windows() const { return shm_key_windows_; }
-  void set_shm_key_windows(const std::string& value) { shm_key_windows_ = value; _has_field_.set(2); }
-
- private:
-  uint32_t shared_buffer_page_size_kb_{};
-  std::string shm_key_windows_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT GetAsyncCommandRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  GetAsyncCommandRequest();
-  ~GetAsyncCommandRequest() override;
-  GetAsyncCommandRequest(GetAsyncCommandRequest&&) noexcept;
-  GetAsyncCommandRequest& operator=(GetAsyncCommandRequest&&);
-  GetAsyncCommandRequest(const GetAsyncCommandRequest&);
-  GetAsyncCommandRequest& operator=(const GetAsyncCommandRequest&);
-  bool operator==(const GetAsyncCommandRequest&) const;
-  bool operator!=(const GetAsyncCommandRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT ActivateTriggersResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  ActivateTriggersResponse();
-  ~ActivateTriggersResponse() override;
-  ActivateTriggersResponse(ActivateTriggersResponse&&) noexcept;
-  ActivateTriggersResponse& operator=(ActivateTriggersResponse&&);
-  ActivateTriggersResponse(const ActivateTriggersResponse&);
-  ActivateTriggersResponse& operator=(const ActivateTriggersResponse&);
-  bool operator==(const ActivateTriggersResponse&) const;
-  bool operator!=(const ActivateTriggersResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT ActivateTriggersRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kTriggerNamesFieldNumber = 1,
-  };
-
-  ActivateTriggersRequest();
-  ~ActivateTriggersRequest() override;
-  ActivateTriggersRequest(ActivateTriggersRequest&&) noexcept;
-  ActivateTriggersRequest& operator=(ActivateTriggersRequest&&);
-  ActivateTriggersRequest(const ActivateTriggersRequest&);
-  ActivateTriggersRequest& operator=(const ActivateTriggersRequest&);
-  bool operator==(const ActivateTriggersRequest&) const;
-  bool operator!=(const ActivateTriggersRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<std::string>& trigger_names() const { return trigger_names_; }
-  std::vector<std::string>* mutable_trigger_names() { return &trigger_names_; }
-  int trigger_names_size() const { return static_cast<int>(trigger_names_.size()); }
-  void clear_trigger_names() { trigger_names_.clear(); }
-  void add_trigger_names(std::string value) { trigger_names_.emplace_back(value); }
-  std::string* add_trigger_names() { trigger_names_.emplace_back(); return &trigger_names_.back(); }
-
- private:
-  std::vector<std::string> trigger_names_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT NotifyDataSourceStoppedResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  NotifyDataSourceStoppedResponse();
-  ~NotifyDataSourceStoppedResponse() override;
-  NotifyDataSourceStoppedResponse(NotifyDataSourceStoppedResponse&&) noexcept;
-  NotifyDataSourceStoppedResponse& operator=(NotifyDataSourceStoppedResponse&&);
-  NotifyDataSourceStoppedResponse(const NotifyDataSourceStoppedResponse&);
-  NotifyDataSourceStoppedResponse& operator=(const NotifyDataSourceStoppedResponse&);
-  bool operator==(const NotifyDataSourceStoppedResponse&) const;
-  bool operator!=(const NotifyDataSourceStoppedResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT NotifyDataSourceStoppedRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kDataSourceIdFieldNumber = 1,
-  };
-
-  NotifyDataSourceStoppedRequest();
-  ~NotifyDataSourceStoppedRequest() override;
-  NotifyDataSourceStoppedRequest(NotifyDataSourceStoppedRequest&&) noexcept;
-  NotifyDataSourceStoppedRequest& operator=(NotifyDataSourceStoppedRequest&&);
-  NotifyDataSourceStoppedRequest(const NotifyDataSourceStoppedRequest&);
-  NotifyDataSourceStoppedRequest& operator=(const NotifyDataSourceStoppedRequest&);
-  bool operator==(const NotifyDataSourceStoppedRequest&) const;
-  bool operator!=(const NotifyDataSourceStoppedRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_data_source_id() const { return _has_field_[1]; }
-  uint64_t data_source_id() const { return data_source_id_; }
-  void set_data_source_id(uint64_t value) { data_source_id_ = value; _has_field_.set(1); }
-
- private:
-  uint64_t data_source_id_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT NotifyDataSourceStartedResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  NotifyDataSourceStartedResponse();
-  ~NotifyDataSourceStartedResponse() override;
-  NotifyDataSourceStartedResponse(NotifyDataSourceStartedResponse&&) noexcept;
-  NotifyDataSourceStartedResponse& operator=(NotifyDataSourceStartedResponse&&);
-  NotifyDataSourceStartedResponse(const NotifyDataSourceStartedResponse&);
-  NotifyDataSourceStartedResponse& operator=(const NotifyDataSourceStartedResponse&);
-  bool operator==(const NotifyDataSourceStartedResponse&) const;
-  bool operator!=(const NotifyDataSourceStartedResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT NotifyDataSourceStartedRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kDataSourceIdFieldNumber = 1,
-  };
-
-  NotifyDataSourceStartedRequest();
-  ~NotifyDataSourceStartedRequest() override;
-  NotifyDataSourceStartedRequest(NotifyDataSourceStartedRequest&&) noexcept;
-  NotifyDataSourceStartedRequest& operator=(NotifyDataSourceStartedRequest&&);
-  NotifyDataSourceStartedRequest(const NotifyDataSourceStartedRequest&);
-  NotifyDataSourceStartedRequest& operator=(const NotifyDataSourceStartedRequest&);
-  bool operator==(const NotifyDataSourceStartedRequest&) const;
-  bool operator!=(const NotifyDataSourceStartedRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_data_source_id() const { return _has_field_[1]; }
-  uint64_t data_source_id() const { return data_source_id_; }
-  void set_data_source_id(uint64_t value) { data_source_id_ = value; _has_field_.set(1); }
-
- private:
-  uint64_t data_source_id_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT CommitDataResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  CommitDataResponse();
-  ~CommitDataResponse() override;
-  CommitDataResponse(CommitDataResponse&&) noexcept;
-  CommitDataResponse& operator=(CommitDataResponse&&);
-  CommitDataResponse(const CommitDataResponse&);
-  CommitDataResponse& operator=(const CommitDataResponse&);
-  bool operator==(const CommitDataResponse&) const;
-  bool operator!=(const CommitDataResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT UnregisterTraceWriterResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  UnregisterTraceWriterResponse();
-  ~UnregisterTraceWriterResponse() override;
-  UnregisterTraceWriterResponse(UnregisterTraceWriterResponse&&) noexcept;
-  UnregisterTraceWriterResponse& operator=(UnregisterTraceWriterResponse&&);
-  UnregisterTraceWriterResponse(const UnregisterTraceWriterResponse&);
-  UnregisterTraceWriterResponse& operator=(const UnregisterTraceWriterResponse&);
-  bool operator==(const UnregisterTraceWriterResponse&) const;
-  bool operator!=(const UnregisterTraceWriterResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT UnregisterTraceWriterRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kTraceWriterIdFieldNumber = 1,
-  };
-
-  UnregisterTraceWriterRequest();
-  ~UnregisterTraceWriterRequest() override;
-  UnregisterTraceWriterRequest(UnregisterTraceWriterRequest&&) noexcept;
-  UnregisterTraceWriterRequest& operator=(UnregisterTraceWriterRequest&&);
-  UnregisterTraceWriterRequest(const UnregisterTraceWriterRequest&);
-  UnregisterTraceWriterRequest& operator=(const UnregisterTraceWriterRequest&);
-  bool operator==(const UnregisterTraceWriterRequest&) const;
-  bool operator!=(const UnregisterTraceWriterRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_trace_writer_id() const { return _has_field_[1]; }
-  uint32_t trace_writer_id() const { return trace_writer_id_; }
-  void set_trace_writer_id(uint32_t value) { trace_writer_id_ = value; _has_field_.set(1); }
-
- private:
-  uint32_t trace_writer_id_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT RegisterTraceWriterResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  RegisterTraceWriterResponse();
-  ~RegisterTraceWriterResponse() override;
-  RegisterTraceWriterResponse(RegisterTraceWriterResponse&&) noexcept;
-  RegisterTraceWriterResponse& operator=(RegisterTraceWriterResponse&&);
-  RegisterTraceWriterResponse(const RegisterTraceWriterResponse&);
-  RegisterTraceWriterResponse& operator=(const RegisterTraceWriterResponse&);
-  bool operator==(const RegisterTraceWriterResponse&) const;
-  bool operator!=(const RegisterTraceWriterResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT RegisterTraceWriterRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kTraceWriterIdFieldNumber = 1,
-    kTargetBufferFieldNumber = 2,
-  };
-
-  RegisterTraceWriterRequest();
-  ~RegisterTraceWriterRequest() override;
-  RegisterTraceWriterRequest(RegisterTraceWriterRequest&&) noexcept;
-  RegisterTraceWriterRequest& operator=(RegisterTraceWriterRequest&&);
-  RegisterTraceWriterRequest(const RegisterTraceWriterRequest&);
-  RegisterTraceWriterRequest& operator=(const RegisterTraceWriterRequest&);
-  bool operator==(const RegisterTraceWriterRequest&) const;
-  bool operator!=(const RegisterTraceWriterRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_trace_writer_id() const { return _has_field_[1]; }
-  uint32_t trace_writer_id() const { return trace_writer_id_; }
-  void set_trace_writer_id(uint32_t value) { trace_writer_id_ = value; _has_field_.set(1); }
-
-  bool has_target_buffer() const { return _has_field_[2]; }
-  uint32_t target_buffer() const { return target_buffer_; }
-  void set_target_buffer(uint32_t value) { target_buffer_ = value; _has_field_.set(2); }
-
- private:
-  uint32_t trace_writer_id_{};
-  uint32_t target_buffer_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT UnregisterDataSourceResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  UnregisterDataSourceResponse();
-  ~UnregisterDataSourceResponse() override;
-  UnregisterDataSourceResponse(UnregisterDataSourceResponse&&) noexcept;
-  UnregisterDataSourceResponse& operator=(UnregisterDataSourceResponse&&);
-  UnregisterDataSourceResponse(const UnregisterDataSourceResponse&);
-  UnregisterDataSourceResponse& operator=(const UnregisterDataSourceResponse&);
-  bool operator==(const UnregisterDataSourceResponse&) const;
-  bool operator!=(const UnregisterDataSourceResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT UnregisterDataSourceRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kDataSourceNameFieldNumber = 1,
-  };
-
-  UnregisterDataSourceRequest();
-  ~UnregisterDataSourceRequest() override;
-  UnregisterDataSourceRequest(UnregisterDataSourceRequest&&) noexcept;
-  UnregisterDataSourceRequest& operator=(UnregisterDataSourceRequest&&);
-  UnregisterDataSourceRequest(const UnregisterDataSourceRequest&);
-  UnregisterDataSourceRequest& operator=(const UnregisterDataSourceRequest&);
-  bool operator==(const UnregisterDataSourceRequest&) const;
-  bool operator!=(const UnregisterDataSourceRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_data_source_name() const { return _has_field_[1]; }
-  const std::string& data_source_name() const { return data_source_name_; }
-  void set_data_source_name(const std::string& value) { data_source_name_ = value; _has_field_.set(1); }
-
- private:
-  std::string data_source_name_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT UpdateDataSourceResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  UpdateDataSourceResponse();
-  ~UpdateDataSourceResponse() override;
-  UpdateDataSourceResponse(UpdateDataSourceResponse&&) noexcept;
-  UpdateDataSourceResponse& operator=(UpdateDataSourceResponse&&);
-  UpdateDataSourceResponse(const UpdateDataSourceResponse&);
-  UpdateDataSourceResponse& operator=(const UpdateDataSourceResponse&);
-  bool operator==(const UpdateDataSourceResponse&) const;
-  bool operator!=(const UpdateDataSourceResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
- private:
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT UpdateDataSourceRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kDataSourceDescriptorFieldNumber = 1,
-  };
-
-  UpdateDataSourceRequest();
-  ~UpdateDataSourceRequest() override;
-  UpdateDataSourceRequest(UpdateDataSourceRequest&&) noexcept;
-  UpdateDataSourceRequest& operator=(UpdateDataSourceRequest&&);
-  UpdateDataSourceRequest(const UpdateDataSourceRequest&);
-  UpdateDataSourceRequest& operator=(const UpdateDataSourceRequest&);
-  bool operator==(const UpdateDataSourceRequest&) const;
-  bool operator!=(const UpdateDataSourceRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_data_source_descriptor() const { return _has_field_[1]; }
-  const DataSourceDescriptor& data_source_descriptor() const { return *data_source_descriptor_; }
-  DataSourceDescriptor* mutable_data_source_descriptor() { _has_field_.set(1); return data_source_descriptor_.get(); }
-
- private:
-  ::protozero::CopyablePtr<DataSourceDescriptor> data_source_descriptor_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT RegisterDataSourceResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kErrorFieldNumber = 1,
-  };
-
-  RegisterDataSourceResponse();
-  ~RegisterDataSourceResponse() override;
-  RegisterDataSourceResponse(RegisterDataSourceResponse&&) noexcept;
-  RegisterDataSourceResponse& operator=(RegisterDataSourceResponse&&);
-  RegisterDataSourceResponse(const RegisterDataSourceResponse&);
-  RegisterDataSourceResponse& operator=(const RegisterDataSourceResponse&);
-  bool operator==(const RegisterDataSourceResponse&) const;
-  bool operator!=(const RegisterDataSourceResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_error() const { return _has_field_[1]; }
-  const std::string& error() const { return error_; }
-  void set_error(const std::string& value) { error_ = value; _has_field_.set(1); }
-
- private:
-  std::string error_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT RegisterDataSourceRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kDataSourceDescriptorFieldNumber = 1,
-  };
-
-  RegisterDataSourceRequest();
-  ~RegisterDataSourceRequest() override;
-  RegisterDataSourceRequest(RegisterDataSourceRequest&&) noexcept;
-  RegisterDataSourceRequest& operator=(RegisterDataSourceRequest&&);
-  RegisterDataSourceRequest(const RegisterDataSourceRequest&);
-  RegisterDataSourceRequest& operator=(const RegisterDataSourceRequest&);
-  bool operator==(const RegisterDataSourceRequest&) const;
-  bool operator!=(const RegisterDataSourceRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_data_source_descriptor() const { return _has_field_[1]; }
-  const DataSourceDescriptor& data_source_descriptor() const { return *data_source_descriptor_; }
-  DataSourceDescriptor* mutable_data_source_descriptor() { _has_field_.set(1); return data_source_descriptor_.get(); }
-
- private:
-  ::protozero::CopyablePtr<DataSourceDescriptor> data_source_descriptor_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT InitializeConnectionResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kUsingShmemProvidedByProducerFieldNumber = 1,
-    kDirectSmbPatchingSupportedFieldNumber = 2,
-  };
-
-  InitializeConnectionResponse();
-  ~InitializeConnectionResponse() override;
-  InitializeConnectionResponse(InitializeConnectionResponse&&) noexcept;
-  InitializeConnectionResponse& operator=(InitializeConnectionResponse&&);
-  InitializeConnectionResponse(const InitializeConnectionResponse&);
-  InitializeConnectionResponse& operator=(const InitializeConnectionResponse&);
-  bool operator==(const InitializeConnectionResponse&) const;
-  bool operator!=(const InitializeConnectionResponse& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_using_shmem_provided_by_producer() const { return _has_field_[1]; }
-  bool using_shmem_provided_by_producer() const { return using_shmem_provided_by_producer_; }
-  void set_using_shmem_provided_by_producer(bool value) { using_shmem_provided_by_producer_ = value; _has_field_.set(1); }
-
-  bool has_direct_smb_patching_supported() const { return _has_field_[2]; }
-  bool direct_smb_patching_supported() const { return direct_smb_patching_supported_; }
-  void set_direct_smb_patching_supported(bool value) { direct_smb_patching_supported_ = value; _has_field_.set(2); }
-
- private:
-  bool using_shmem_provided_by_producer_{};
-  bool direct_smb_patching_supported_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<3> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT InitializeConnectionRequest : public ::protozero::CppMessageObj {
- public:
-  using ProducerSMBScrapingMode = InitializeConnectionRequest_ProducerSMBScrapingMode;
-  static constexpr auto SMB_SCRAPING_UNSPECIFIED = InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_UNSPECIFIED;
-  static constexpr auto SMB_SCRAPING_ENABLED = InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_ENABLED;
-  static constexpr auto SMB_SCRAPING_DISABLED = InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_DISABLED;
-  static constexpr auto ProducerSMBScrapingMode_MIN = InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_UNSPECIFIED;
-  static constexpr auto ProducerSMBScrapingMode_MAX = InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_DISABLED;
-  enum FieldNumbers {
-    kSharedMemoryPageSizeHintBytesFieldNumber = 1,
-    kSharedMemorySizeHintBytesFieldNumber = 2,
-    kProducerNameFieldNumber = 3,
-    kSmbScrapingModeFieldNumber = 4,
-    kProducerProvidedShmemFieldNumber = 6,
-    kSdkVersionFieldNumber = 8,
-    kShmKeyWindowsFieldNumber = 7,
-  };
-
-  InitializeConnectionRequest();
-  ~InitializeConnectionRequest() override;
-  InitializeConnectionRequest(InitializeConnectionRequest&&) noexcept;
-  InitializeConnectionRequest& operator=(InitializeConnectionRequest&&);
-  InitializeConnectionRequest(const InitializeConnectionRequest&);
-  InitializeConnectionRequest& operator=(const InitializeConnectionRequest&);
-  bool operator==(const InitializeConnectionRequest&) const;
-  bool operator!=(const InitializeConnectionRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_shared_memory_page_size_hint_bytes() const { return _has_field_[1]; }
-  uint32_t shared_memory_page_size_hint_bytes() const { return shared_memory_page_size_hint_bytes_; }
-  void set_shared_memory_page_size_hint_bytes(uint32_t value) { shared_memory_page_size_hint_bytes_ = value; _has_field_.set(1); }
-
-  bool has_shared_memory_size_hint_bytes() const { return _has_field_[2]; }
-  uint32_t shared_memory_size_hint_bytes() const { return shared_memory_size_hint_bytes_; }
-  void set_shared_memory_size_hint_bytes(uint32_t value) { shared_memory_size_hint_bytes_ = value; _has_field_.set(2); }
-
-  bool has_producer_name() const { return _has_field_[3]; }
-  const std::string& producer_name() const { return producer_name_; }
-  void set_producer_name(const std::string& value) { producer_name_ = value; _has_field_.set(3); }
-
-  bool has_smb_scraping_mode() const { return _has_field_[4]; }
-  InitializeConnectionRequest_ProducerSMBScrapingMode smb_scraping_mode() const { return smb_scraping_mode_; }
-  void set_smb_scraping_mode(InitializeConnectionRequest_ProducerSMBScrapingMode value) { smb_scraping_mode_ = value; _has_field_.set(4); }
-
-  bool has_producer_provided_shmem() const { return _has_field_[6]; }
-  bool producer_provided_shmem() const { return producer_provided_shmem_; }
-  void set_producer_provided_shmem(bool value) { producer_provided_shmem_ = value; _has_field_.set(6); }
-
-  bool has_sdk_version() const { return _has_field_[8]; }
-  const std::string& sdk_version() const { return sdk_version_; }
-  void set_sdk_version(const std::string& value) { sdk_version_ = value; _has_field_.set(8); }
-
-  bool has_shm_key_windows() const { return _has_field_[7]; }
-  const std::string& shm_key_windows() const { return shm_key_windows_; }
-  void set_shm_key_windows(const std::string& value) { shm_key_windows_ = value; _has_field_.set(7); }
-
- private:
-  uint32_t shared_memory_page_size_hint_bytes_{};
-  uint32_t shared_memory_size_hint_bytes_{};
-  std::string producer_name_{};
-  InitializeConnectionRequest_ProducerSMBScrapingMode smb_scraping_mode_{};
-  bool producer_provided_shmem_{};
-  std::string sdk_version_{};
-  std::string shm_key_windows_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<9> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_PRODUCER_PORT_PROTO_CPP_H_
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -68981,11 +70509,14 @@ class PERFETTO_EXPORT_COMPONENT InitializeConnectionRequest : public ::protozero
 #endif
 // gen_amalgamated expanded: #include "protos/perfetto/ipc/producer_port.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/common/data_source_descriptor.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/protovm/vm_program.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/common/track_event_descriptor.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/common/gpu_counter_descriptor.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/common/ftrace_descriptor.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/data_source_config.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/config/system_info/system_info.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/qnx/qnx_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/histogram_samples.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/system_info/system_info_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/track_event/track_event_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/test_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/sys_stats/sys_stats_config.gen.h"
@@ -68995,22 +70526,42 @@ class PERFETTO_EXPORT_COMPONENT InitializeConnectionRequest : public ::protozero
 // gen_amalgamated expanded: #include "protos/perfetto/config/profiling/java_hprof_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/profiling/heapprofd_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/process_stats/process_stats_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/priority_boost/priority_boost_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/statsd/statsd_tracing_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/statsd/atom_ids.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/protovm/protovm_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/power/android_power_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/interceptor_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/interceptors/console_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/inode_file/inode_file_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/gpu/gpu_renderstages_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/gpu/vulkan_memory_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/gpu/gpu_counter_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/ftrace/frozen_ftrace_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/ftrace/ftrace_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/system_metrics.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/etw/etw_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/v8_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/chrome/chrome_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/windowmanager_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/user_list_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/surfaceflinger_transactions_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/surfaceflinger_layers_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/protolog_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/protolog_common.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/pixel_modem_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/android/packages_list_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/android/network_trace_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/kernel_wakelocks_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/inputmethod_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/cpu_per_uid_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/app_wakelock_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_sdk_sysprop_guard_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_system_property_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_polled_state_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_log_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/common/android_log_constants.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_input_event_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_game_intervention_list_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/common/commit_data_request.gen.h"
 
@@ -69026,7 +70577,7 @@ SyncResponse::SyncResponse(SyncResponse&&) noexcept = default;
 SyncResponse& SyncResponse::operator=(SyncResponse&&) = default;
 
 bool SyncResponse::operator==(const SyncResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
 bool SyncResponse::ParseFromArray(const void* raw, size_t size) {
@@ -69072,7 +70623,7 @@ SyncRequest::SyncRequest(SyncRequest&&) noexcept = default;
 SyncRequest& SyncRequest::operator=(SyncRequest&&) = default;
 
 bool SyncRequest::operator==(const SyncRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
 bool SyncRequest::ParseFromArray(const void* raw, size_t size) {
@@ -69118,13 +70669,13 @@ GetAsyncCommandResponse::GetAsyncCommandResponse(GetAsyncCommandResponse&&) noex
 GetAsyncCommandResponse& GetAsyncCommandResponse::operator=(GetAsyncCommandResponse&&) = default;
 
 bool GetAsyncCommandResponse::operator==(const GetAsyncCommandResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && setup_tracing_ == other.setup_tracing_
-   && setup_data_source_ == other.setup_data_source_
-   && start_data_source_ == other.start_data_source_
-   && stop_data_source_ == other.stop_data_source_
-   && flush_ == other.flush_
-   && clear_incremental_state_ == other.clear_incremental_state_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(setup_tracing_, other.setup_tracing_)
+   && ::protozero::internal::gen_helpers::EqualsField(setup_data_source_, other.setup_data_source_)
+   && ::protozero::internal::gen_helpers::EqualsField(start_data_source_, other.start_data_source_)
+   && ::protozero::internal::gen_helpers::EqualsField(stop_data_source_, other.stop_data_source_)
+   && ::protozero::internal::gen_helpers::EqualsField(flush_, other.flush_)
+   && ::protozero::internal::gen_helpers::EqualsField(clear_incremental_state_, other.clear_incremental_state_);
 }
 
 bool GetAsyncCommandResponse::ParseFromArray(const void* raw, size_t size) {
@@ -69218,8 +70769,8 @@ GetAsyncCommandResponse_ClearIncrementalState::GetAsyncCommandResponse_ClearIncr
 GetAsyncCommandResponse_ClearIncrementalState& GetAsyncCommandResponse_ClearIncrementalState::operator=(GetAsyncCommandResponse_ClearIncrementalState&&) = default;
 
 bool GetAsyncCommandResponse_ClearIncrementalState::operator==(const GetAsyncCommandResponse_ClearIncrementalState& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && data_source_ids_ == other.data_source_ids_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(data_source_ids_, other.data_source_ids_);
 }
 
 bool GetAsyncCommandResponse_ClearIncrementalState::ParseFromArray(const void* raw, size_t size) {
@@ -69275,9 +70826,10 @@ GetAsyncCommandResponse_Flush::GetAsyncCommandResponse_Flush(GetAsyncCommandResp
 GetAsyncCommandResponse_Flush& GetAsyncCommandResponse_Flush::operator=(GetAsyncCommandResponse_Flush&&) = default;
 
 bool GetAsyncCommandResponse_Flush::operator==(const GetAsyncCommandResponse_Flush& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && data_source_ids_ == other.data_source_ids_
-   && request_id_ == other.request_id_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(data_source_ids_, other.data_source_ids_)
+   && ::protozero::internal::gen_helpers::EqualsField(request_id_, other.request_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(flags_, other.flags_);
 }
 
 bool GetAsyncCommandResponse_Flush::ParseFromArray(const void* raw, size_t size) {
@@ -69298,6 +70850,9 @@ bool GetAsyncCommandResponse_Flush::ParseFromArray(const void* raw, size_t size)
       case 2 /* request_id */:
         field.get(&request_id_);
         break;
+      case 3 /* flags */:
+        field.get(&flags_);
+        break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
         break;
@@ -69329,6 +70884,11 @@ void GetAsyncCommandResponse_Flush::Serialize(::protozero::Message* msg) const {
     ::protozero::internal::gen_helpers::SerializeVarInt(2, request_id_, msg);
   }
 
+  // Field 3: flags
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, flags_, msg);
+  }
+
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
@@ -69341,8 +70901,8 @@ GetAsyncCommandResponse_StopDataSource::GetAsyncCommandResponse_StopDataSource(G
 GetAsyncCommandResponse_StopDataSource& GetAsyncCommandResponse_StopDataSource::operator=(GetAsyncCommandResponse_StopDataSource&&) = default;
 
 bool GetAsyncCommandResponse_StopDataSource::operator==(const GetAsyncCommandResponse_StopDataSource& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && instance_id_ == other.instance_id_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(instance_id_, other.instance_id_);
 }
 
 bool GetAsyncCommandResponse_StopDataSource::ParseFromArray(const void* raw, size_t size) {
@@ -69396,9 +70956,9 @@ GetAsyncCommandResponse_StartDataSource::GetAsyncCommandResponse_StartDataSource
 GetAsyncCommandResponse_StartDataSource& GetAsyncCommandResponse_StartDataSource::operator=(GetAsyncCommandResponse_StartDataSource&&) = default;
 
 bool GetAsyncCommandResponse_StartDataSource::operator==(const GetAsyncCommandResponse_StartDataSource& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && new_instance_id_ == other.new_instance_id_
-   && config_ == other.config_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(new_instance_id_, other.new_instance_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(config_, other.config_);
 }
 
 bool GetAsyncCommandResponse_StartDataSource::ParseFromArray(const void* raw, size_t size) {
@@ -69460,9 +71020,9 @@ GetAsyncCommandResponse_SetupDataSource::GetAsyncCommandResponse_SetupDataSource
 GetAsyncCommandResponse_SetupDataSource& GetAsyncCommandResponse_SetupDataSource::operator=(GetAsyncCommandResponse_SetupDataSource&&) = default;
 
 bool GetAsyncCommandResponse_SetupDataSource::operator==(const GetAsyncCommandResponse_SetupDataSource& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && new_instance_id_ == other.new_instance_id_
-   && config_ == other.config_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(new_instance_id_, other.new_instance_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(config_, other.config_);
 }
 
 bool GetAsyncCommandResponse_SetupDataSource::ParseFromArray(const void* raw, size_t size) {
@@ -69524,9 +71084,9 @@ GetAsyncCommandResponse_SetupTracing::GetAsyncCommandResponse_SetupTracing(GetAs
 GetAsyncCommandResponse_SetupTracing& GetAsyncCommandResponse_SetupTracing::operator=(GetAsyncCommandResponse_SetupTracing&&) = default;
 
 bool GetAsyncCommandResponse_SetupTracing::operator==(const GetAsyncCommandResponse_SetupTracing& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && shared_buffer_page_size_kb_ == other.shared_buffer_page_size_kb_
-   && shm_key_windows_ == other.shm_key_windows_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(shared_buffer_page_size_kb_, other.shared_buffer_page_size_kb_)
+   && ::protozero::internal::gen_helpers::EqualsField(shm_key_windows_, other.shm_key_windows_);
 }
 
 bool GetAsyncCommandResponse_SetupTracing::ParseFromArray(const void* raw, size_t size) {
@@ -69588,7 +71148,7 @@ GetAsyncCommandRequest::GetAsyncCommandRequest(GetAsyncCommandRequest&&) noexcep
 GetAsyncCommandRequest& GetAsyncCommandRequest::operator=(GetAsyncCommandRequest&&) = default;
 
 bool GetAsyncCommandRequest::operator==(const GetAsyncCommandRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
 bool GetAsyncCommandRequest::ParseFromArray(const void* raw, size_t size) {
@@ -69634,7 +71194,7 @@ ActivateTriggersResponse::ActivateTriggersResponse(ActivateTriggersResponse&&) n
 ActivateTriggersResponse& ActivateTriggersResponse::operator=(ActivateTriggersResponse&&) = default;
 
 bool ActivateTriggersResponse::operator==(const ActivateTriggersResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
 bool ActivateTriggersResponse::ParseFromArray(const void* raw, size_t size) {
@@ -69680,8 +71240,8 @@ ActivateTriggersRequest::ActivateTriggersRequest(ActivateTriggersRequest&&) noex
 ActivateTriggersRequest& ActivateTriggersRequest::operator=(ActivateTriggersRequest&&) = default;
 
 bool ActivateTriggersRequest::operator==(const ActivateTriggersRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && trigger_names_ == other.trigger_names_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(trigger_names_, other.trigger_names_);
 }
 
 bool ActivateTriggersRequest::ParseFromArray(const void* raw, size_t size) {
@@ -69737,7 +71297,7 @@ NotifyDataSourceStoppedResponse::NotifyDataSourceStoppedResponse(NotifyDataSourc
 NotifyDataSourceStoppedResponse& NotifyDataSourceStoppedResponse::operator=(NotifyDataSourceStoppedResponse&&) = default;
 
 bool NotifyDataSourceStoppedResponse::operator==(const NotifyDataSourceStoppedResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
 bool NotifyDataSourceStoppedResponse::ParseFromArray(const void* raw, size_t size) {
@@ -69783,8 +71343,8 @@ NotifyDataSourceStoppedRequest::NotifyDataSourceStoppedRequest(NotifyDataSourceS
 NotifyDataSourceStoppedRequest& NotifyDataSourceStoppedRequest::operator=(NotifyDataSourceStoppedRequest&&) = default;
 
 bool NotifyDataSourceStoppedRequest::operator==(const NotifyDataSourceStoppedRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && data_source_id_ == other.data_source_id_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(data_source_id_, other.data_source_id_);
 }
 
 bool NotifyDataSourceStoppedRequest::ParseFromArray(const void* raw, size_t size) {
@@ -69838,7 +71398,7 @@ NotifyDataSourceStartedResponse::NotifyDataSourceStartedResponse(NotifyDataSourc
 NotifyDataSourceStartedResponse& NotifyDataSourceStartedResponse::operator=(NotifyDataSourceStartedResponse&&) = default;
 
 bool NotifyDataSourceStartedResponse::operator==(const NotifyDataSourceStartedResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
 bool NotifyDataSourceStartedResponse::ParseFromArray(const void* raw, size_t size) {
@@ -69884,8 +71444,8 @@ NotifyDataSourceStartedRequest::NotifyDataSourceStartedRequest(NotifyDataSourceS
 NotifyDataSourceStartedRequest& NotifyDataSourceStartedRequest::operator=(NotifyDataSourceStartedRequest&&) = default;
 
 bool NotifyDataSourceStartedRequest::operator==(const NotifyDataSourceStartedRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && data_source_id_ == other.data_source_id_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(data_source_id_, other.data_source_id_);
 }
 
 bool NotifyDataSourceStartedRequest::ParseFromArray(const void* raw, size_t size) {
@@ -69939,7 +71499,7 @@ CommitDataResponse::CommitDataResponse(CommitDataResponse&&) noexcept = default;
 CommitDataResponse& CommitDataResponse::operator=(CommitDataResponse&&) = default;
 
 bool CommitDataResponse::operator==(const CommitDataResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
 bool CommitDataResponse::ParseFromArray(const void* raw, size_t size) {
@@ -69985,7 +71545,7 @@ UnregisterTraceWriterResponse::UnregisterTraceWriterResponse(UnregisterTraceWrit
 UnregisterTraceWriterResponse& UnregisterTraceWriterResponse::operator=(UnregisterTraceWriterResponse&&) = default;
 
 bool UnregisterTraceWriterResponse::operator==(const UnregisterTraceWriterResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
 bool UnregisterTraceWriterResponse::ParseFromArray(const void* raw, size_t size) {
@@ -70031,8 +71591,8 @@ UnregisterTraceWriterRequest::UnregisterTraceWriterRequest(UnregisterTraceWriter
 UnregisterTraceWriterRequest& UnregisterTraceWriterRequest::operator=(UnregisterTraceWriterRequest&&) = default;
 
 bool UnregisterTraceWriterRequest::operator==(const UnregisterTraceWriterRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && trace_writer_id_ == other.trace_writer_id_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(trace_writer_id_, other.trace_writer_id_);
 }
 
 bool UnregisterTraceWriterRequest::ParseFromArray(const void* raw, size_t size) {
@@ -70086,7 +71646,7 @@ RegisterTraceWriterResponse::RegisterTraceWriterResponse(RegisterTraceWriterResp
 RegisterTraceWriterResponse& RegisterTraceWriterResponse::operator=(RegisterTraceWriterResponse&&) = default;
 
 bool RegisterTraceWriterResponse::operator==(const RegisterTraceWriterResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
 bool RegisterTraceWriterResponse::ParseFromArray(const void* raw, size_t size) {
@@ -70132,9 +71692,9 @@ RegisterTraceWriterRequest::RegisterTraceWriterRequest(RegisterTraceWriterReques
 RegisterTraceWriterRequest& RegisterTraceWriterRequest::operator=(RegisterTraceWriterRequest&&) = default;
 
 bool RegisterTraceWriterRequest::operator==(const RegisterTraceWriterRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && trace_writer_id_ == other.trace_writer_id_
-   && target_buffer_ == other.target_buffer_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(trace_writer_id_, other.trace_writer_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(target_buffer_, other.target_buffer_);
 }
 
 bool RegisterTraceWriterRequest::ParseFromArray(const void* raw, size_t size) {
@@ -70196,7 +71756,7 @@ UnregisterDataSourceResponse::UnregisterDataSourceResponse(UnregisterDataSourceR
 UnregisterDataSourceResponse& UnregisterDataSourceResponse::operator=(UnregisterDataSourceResponse&&) = default;
 
 bool UnregisterDataSourceResponse::operator==(const UnregisterDataSourceResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
 bool UnregisterDataSourceResponse::ParseFromArray(const void* raw, size_t size) {
@@ -70242,8 +71802,8 @@ UnregisterDataSourceRequest::UnregisterDataSourceRequest(UnregisterDataSourceReq
 UnregisterDataSourceRequest& UnregisterDataSourceRequest::operator=(UnregisterDataSourceRequest&&) = default;
 
 bool UnregisterDataSourceRequest::operator==(const UnregisterDataSourceRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && data_source_name_ == other.data_source_name_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(data_source_name_, other.data_source_name_);
 }
 
 bool UnregisterDataSourceRequest::ParseFromArray(const void* raw, size_t size) {
@@ -70297,7 +71857,7 @@ UpdateDataSourceResponse::UpdateDataSourceResponse(UpdateDataSourceResponse&&) n
 UpdateDataSourceResponse& UpdateDataSourceResponse::operator=(UpdateDataSourceResponse&&) = default;
 
 bool UpdateDataSourceResponse::operator==(const UpdateDataSourceResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
 }
 
 bool UpdateDataSourceResponse::ParseFromArray(const void* raw, size_t size) {
@@ -70343,8 +71903,8 @@ UpdateDataSourceRequest::UpdateDataSourceRequest(UpdateDataSourceRequest&&) noex
 UpdateDataSourceRequest& UpdateDataSourceRequest::operator=(UpdateDataSourceRequest&&) = default;
 
 bool UpdateDataSourceRequest::operator==(const UpdateDataSourceRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && data_source_descriptor_ == other.data_source_descriptor_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(data_source_descriptor_, other.data_source_descriptor_);
 }
 
 bool UpdateDataSourceRequest::ParseFromArray(const void* raw, size_t size) {
@@ -70398,8 +71958,8 @@ RegisterDataSourceResponse::RegisterDataSourceResponse(RegisterDataSourceRespons
 RegisterDataSourceResponse& RegisterDataSourceResponse::operator=(RegisterDataSourceResponse&&) = default;
 
 bool RegisterDataSourceResponse::operator==(const RegisterDataSourceResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && error_ == other.error_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(error_, other.error_);
 }
 
 bool RegisterDataSourceResponse::ParseFromArray(const void* raw, size_t size) {
@@ -70453,8 +72013,8 @@ RegisterDataSourceRequest::RegisterDataSourceRequest(RegisterDataSourceRequest&&
 RegisterDataSourceRequest& RegisterDataSourceRequest::operator=(RegisterDataSourceRequest&&) = default;
 
 bool RegisterDataSourceRequest::operator==(const RegisterDataSourceRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && data_source_descriptor_ == other.data_source_descriptor_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(data_source_descriptor_, other.data_source_descriptor_);
 }
 
 bool RegisterDataSourceRequest::ParseFromArray(const void* raw, size_t size) {
@@ -70508,9 +72068,10 @@ InitializeConnectionResponse::InitializeConnectionResponse(InitializeConnectionR
 InitializeConnectionResponse& InitializeConnectionResponse::operator=(InitializeConnectionResponse&&) = default;
 
 bool InitializeConnectionResponse::operator==(const InitializeConnectionResponse& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && using_shmem_provided_by_producer_ == other.using_shmem_provided_by_producer_
-   && direct_smb_patching_supported_ == other.direct_smb_patching_supported_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(using_shmem_provided_by_producer_, other.using_shmem_provided_by_producer_)
+   && ::protozero::internal::gen_helpers::EqualsField(direct_smb_patching_supported_, other.direct_smb_patching_supported_)
+   && ::protozero::internal::gen_helpers::EqualsField(use_shmem_emulation_, other.use_shmem_emulation_);
 }
 
 bool InitializeConnectionResponse::ParseFromArray(const void* raw, size_t size) {
@@ -70529,6 +72090,9 @@ bool InitializeConnectionResponse::ParseFromArray(const void* raw, size_t size)
       case 2 /* direct_smb_patching_supported */:
         field.get(&direct_smb_patching_supported_);
         break;
+      case 3 /* use_shmem_emulation */:
+        field.get(&use_shmem_emulation_);
+        break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
         break;
@@ -70560,6 +72124,11 @@ void InitializeConnectionResponse::Serialize(::protozero::Message* msg) const {
     ::protozero::internal::gen_helpers::SerializeTinyVarInt(2, direct_smb_patching_supported_, msg);
   }
 
+  // Field 3: use_shmem_emulation
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, use_shmem_emulation_, msg);
+  }
+
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
@@ -70572,14 +72141,14 @@ InitializeConnectionRequest::InitializeConnectionRequest(InitializeConnectionReq
 InitializeConnectionRequest& InitializeConnectionRequest::operator=(InitializeConnectionRequest&&) = default;
 
 bool InitializeConnectionRequest::operator==(const InitializeConnectionRequest& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && shared_memory_page_size_hint_bytes_ == other.shared_memory_page_size_hint_bytes_
-   && shared_memory_size_hint_bytes_ == other.shared_memory_size_hint_bytes_
-   && producer_name_ == other.producer_name_
-   && smb_scraping_mode_ == other.smb_scraping_mode_
-   && producer_provided_shmem_ == other.producer_provided_shmem_
-   && sdk_version_ == other.sdk_version_
-   && shm_key_windows_ == other.shm_key_windows_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(shared_memory_page_size_hint_bytes_, other.shared_memory_page_size_hint_bytes_)
+   && ::protozero::internal::gen_helpers::EqualsField(shared_memory_size_hint_bytes_, other.shared_memory_size_hint_bytes_)
+   && ::protozero::internal::gen_helpers::EqualsField(producer_name_, other.producer_name_)
+   && ::protozero::internal::gen_helpers::EqualsField(smb_scraping_mode_, other.smb_scraping_mode_)
+   && ::protozero::internal::gen_helpers::EqualsField(producer_provided_shmem_, other.producer_provided_shmem_)
+   && ::protozero::internal::gen_helpers::EqualsField(sdk_version_, other.sdk_version_)
+   && ::protozero::internal::gen_helpers::EqualsField(shm_key_windows_, other.shm_key_windows_);
 }
 
 bool InitializeConnectionRequest::ParseFromArray(const void* raw, size_t size) {
@@ -70678,390 +72247,310 @@ void InitializeConnectionRequest::Serialize(::protozero::Message* msg) const {
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
-// gen_amalgamated begin source: gen/protos/perfetto/ipc/wire_protocol.gen.cc
-// gen_amalgamated begin header: gen/protos/perfetto/ipc/wire_protocol.gen.h
+// gen_amalgamated begin source: gen/protos/perfetto/ipc/relay_port.gen.cc
+// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_WIRE_PROTOCOL_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_WIRE_PROTOCOL_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class IPCFrame;
-class IPCFrame_RequestError;
-class IPCFrame_InvokeMethodReply;
-class IPCFrame_InvokeMethod;
-class IPCFrame_BindServiceReply;
-class IPCFrame_BindServiceReply_MethodInfo;
-class IPCFrame_BindService;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// gen_amalgamated expanded: #include "protos/perfetto/ipc/relay_port.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/system_info.gen.h"
 
 namespace perfetto {
 namespace protos {
 namespace gen {
 
-class PERFETTO_EXPORT_COMPONENT IPCFrame : public ::protozero::CppMessageObj {
- public:
-  using BindService = IPCFrame_BindService;
-  using BindServiceReply = IPCFrame_BindServiceReply;
-  using InvokeMethod = IPCFrame_InvokeMethod;
-  using InvokeMethodReply = IPCFrame_InvokeMethodReply;
-  using RequestError = IPCFrame_RequestError;
-  enum FieldNumbers {
-    kRequestIdFieldNumber = 2,
-    kMsgBindServiceFieldNumber = 3,
-    kMsgBindServiceReplyFieldNumber = 4,
-    kMsgInvokeMethodFieldNumber = 5,
-    kMsgInvokeMethodReplyFieldNumber = 6,
-    kMsgRequestErrorFieldNumber = 7,
-    kDataForTestingFieldNumber = 1,
-  };
-
-  IPCFrame();
-  ~IPCFrame() override;
-  IPCFrame(IPCFrame&&) noexcept;
-  IPCFrame& operator=(IPCFrame&&);
-  IPCFrame(const IPCFrame&);
-  IPCFrame& operator=(const IPCFrame&);
-  bool operator==(const IPCFrame&) const;
-  bool operator!=(const IPCFrame& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_request_id() const { return _has_field_[2]; }
-  uint64_t request_id() const { return request_id_; }
-  void set_request_id(uint64_t value) { request_id_ = value; _has_field_.set(2); }
-
-  bool has_msg_bind_service() const { return _has_field_[3]; }
-  const IPCFrame_BindService& msg_bind_service() const { return *msg_bind_service_; }
-  IPCFrame_BindService* mutable_msg_bind_service() { _has_field_.set(3); return msg_bind_service_.get(); }
-
-  bool has_msg_bind_service_reply() const { return _has_field_[4]; }
-  const IPCFrame_BindServiceReply& msg_bind_service_reply() const { return *msg_bind_service_reply_; }
-  IPCFrame_BindServiceReply* mutable_msg_bind_service_reply() { _has_field_.set(4); return msg_bind_service_reply_.get(); }
-
-  bool has_msg_invoke_method() const { return _has_field_[5]; }
-  const IPCFrame_InvokeMethod& msg_invoke_method() const { return *msg_invoke_method_; }
-  IPCFrame_InvokeMethod* mutable_msg_invoke_method() { _has_field_.set(5); return msg_invoke_method_.get(); }
-
-  bool has_msg_invoke_method_reply() const { return _has_field_[6]; }
-  const IPCFrame_InvokeMethodReply& msg_invoke_method_reply() const { return *msg_invoke_method_reply_; }
-  IPCFrame_InvokeMethodReply* mutable_msg_invoke_method_reply() { _has_field_.set(6); return msg_invoke_method_reply_.get(); }
-
-  bool has_msg_request_error() const { return _has_field_[7]; }
-  const IPCFrame_RequestError& msg_request_error() const { return *msg_request_error_; }
-  IPCFrame_RequestError* mutable_msg_request_error() { _has_field_.set(7); return msg_request_error_.get(); }
-
-  const std::vector<std::string>& data_for_testing() const { return data_for_testing_; }
-  std::vector<std::string>* mutable_data_for_testing() { return &data_for_testing_; }
-  int data_for_testing_size() const { return static_cast<int>(data_for_testing_.size()); }
-  void clear_data_for_testing() { data_for_testing_.clear(); }
-  void add_data_for_testing(std::string value) { data_for_testing_.emplace_back(value); }
-  std::string* add_data_for_testing() { data_for_testing_.emplace_back(); return &data_for_testing_.back(); }
-
- private:
-  uint64_t request_id_{};
-  ::protozero::CopyablePtr<IPCFrame_BindService> msg_bind_service_;
-  ::protozero::CopyablePtr<IPCFrame_BindServiceReply> msg_bind_service_reply_;
-  ::protozero::CopyablePtr<IPCFrame_InvokeMethod> msg_invoke_method_;
-  ::protozero::CopyablePtr<IPCFrame_InvokeMethodReply> msg_invoke_method_reply_;
-  ::protozero::CopyablePtr<IPCFrame_RequestError> msg_request_error_;
-  std::vector<std::string> data_for_testing_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<8> _has_field_{};
-};
+SyncClockResponse::SyncClockResponse() = default;
+SyncClockResponse::~SyncClockResponse() = default;
+SyncClockResponse::SyncClockResponse(const SyncClockResponse&) = default;
+SyncClockResponse& SyncClockResponse::operator=(const SyncClockResponse&) = default;
+SyncClockResponse::SyncClockResponse(SyncClockResponse&&) noexcept = default;
+SyncClockResponse& SyncClockResponse::operator=(SyncClockResponse&&) = default;
 
+bool SyncClockResponse::operator==(const SyncClockResponse& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
+}
 
-class PERFETTO_EXPORT_COMPONENT IPCFrame_RequestError : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kErrorFieldNumber = 1,
-  };
-
-  IPCFrame_RequestError();
-  ~IPCFrame_RequestError() override;
-  IPCFrame_RequestError(IPCFrame_RequestError&&) noexcept;
-  IPCFrame_RequestError& operator=(IPCFrame_RequestError&&);
-  IPCFrame_RequestError(const IPCFrame_RequestError&);
-  IPCFrame_RequestError& operator=(const IPCFrame_RequestError&);
-  bool operator==(const IPCFrame_RequestError&) const;
-  bool operator!=(const IPCFrame_RequestError& other) const { return !(*this == other); }
+bool SyncClockResponse::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-  bool has_error() const { return _has_field_[1]; }
-  const std::string& error() const { return error_; }
-  void set_error(const std::string& value) { error_ = value; _has_field_.set(1); }
+std::string SyncClockResponse::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
- private:
-  std::string error_{};
+std::vector<uint8_t> SyncClockResponse::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+void SyncClockResponse::Serialize(::protozero::Message* msg) const {
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  std::bitset<2> _has_field_{};
-};
 
+SyncClockRequest::SyncClockRequest() = default;
+SyncClockRequest::~SyncClockRequest() = default;
+SyncClockRequest::SyncClockRequest(const SyncClockRequest&) = default;
+SyncClockRequest& SyncClockRequest::operator=(const SyncClockRequest&) = default;
+SyncClockRequest::SyncClockRequest(SyncClockRequest&&) noexcept = default;
+SyncClockRequest& SyncClockRequest::operator=(SyncClockRequest&&) = default;
 
-class PERFETTO_EXPORT_COMPONENT IPCFrame_InvokeMethodReply : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kSuccessFieldNumber = 1,
-    kHasMoreFieldNumber = 2,
-    kReplyProtoFieldNumber = 3,
-  };
+bool SyncClockRequest::operator==(const SyncClockRequest& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(phase_, other.phase_)
+   && ::protozero::internal::gen_helpers::EqualsField(clocks_, other.clocks_);
+}
 
-  IPCFrame_InvokeMethodReply();
-  ~IPCFrame_InvokeMethodReply() override;
-  IPCFrame_InvokeMethodReply(IPCFrame_InvokeMethodReply&&) noexcept;
-  IPCFrame_InvokeMethodReply& operator=(IPCFrame_InvokeMethodReply&&);
-  IPCFrame_InvokeMethodReply(const IPCFrame_InvokeMethodReply&);
-  IPCFrame_InvokeMethodReply& operator=(const IPCFrame_InvokeMethodReply&);
-  bool operator==(const IPCFrame_InvokeMethodReply&) const;
-  bool operator!=(const IPCFrame_InvokeMethodReply& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_success() const { return _has_field_[1]; }
-  bool success() const { return success_; }
-  void set_success(bool value) { success_ = value; _has_field_.set(1); }
-
-  bool has_has_more() const { return _has_field_[2]; }
-  bool has_more() const { return has_more_; }
-  void set_has_more(bool value) { has_more_ = value; _has_field_.set(2); }
+int SyncClockRequest::clocks_size() const { return static_cast<int>(clocks_.size()); }
+void SyncClockRequest::clear_clocks() { clocks_.clear(); }
+SyncClockRequest_Clock* SyncClockRequest::add_clocks() { clocks_.emplace_back(); return &clocks_.back(); }
+bool SyncClockRequest::ParseFromArray(const void* raw, size_t size) {
+  clocks_.clear();
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  bool has_reply_proto() const { return _has_field_[3]; }
-  const std::string& reply_proto() const { return reply_proto_; }
-  void set_reply_proto(const std::string& value) { reply_proto_ = value; _has_field_.set(3); }
-  void set_reply_proto(const void* p, size_t s) { reply_proto_.assign(reinterpret_cast<const char*>(p), s); _has_field_.set(3); }
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* phase */:
+        field.get(&phase_);
+        break;
+      case 2 /* clocks */:
+        clocks_.emplace_back();
+        clocks_.back().ParseFromArray(field.data(), field.size());
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
- private:
-  bool success_{};
-  bool has_more_{};
-  std::string reply_proto_{};
+std::string SyncClockRequest::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+std::vector<uint8_t> SyncClockRequest::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  std::bitset<4> _has_field_{};
-};
+void SyncClockRequest::Serialize(::protozero::Message* msg) const {
+  // Field 1: phase
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, phase_, msg);
+  }
 
+  // Field 2: clocks
+  for (auto& it : clocks_) {
+    it.Serialize(msg->BeginNestedMessage<::protozero::Message>(2));
+  }
 
-class PERFETTO_EXPORT_COMPONENT IPCFrame_InvokeMethod : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kServiceIdFieldNumber = 1,
-    kMethodIdFieldNumber = 2,
-    kArgsProtoFieldNumber = 3,
-    kDropReplyFieldNumber = 4,
-  };
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  IPCFrame_InvokeMethod();
-  ~IPCFrame_InvokeMethod() override;
-  IPCFrame_InvokeMethod(IPCFrame_InvokeMethod&&) noexcept;
-  IPCFrame_InvokeMethod& operator=(IPCFrame_InvokeMethod&&);
-  IPCFrame_InvokeMethod(const IPCFrame_InvokeMethod&);
-  IPCFrame_InvokeMethod& operator=(const IPCFrame_InvokeMethod&);
-  bool operator==(const IPCFrame_InvokeMethod&) const;
-  bool operator!=(const IPCFrame_InvokeMethod& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_service_id() const { return _has_field_[1]; }
-  uint32_t service_id() const { return service_id_; }
-  void set_service_id(uint32_t value) { service_id_ = value; _has_field_.set(1); }
-
-  bool has_method_id() const { return _has_field_[2]; }
-  uint32_t method_id() const { return method_id_; }
-  void set_method_id(uint32_t value) { method_id_ = value; _has_field_.set(2); }
-
-  bool has_args_proto() const { return _has_field_[3]; }
-  const std::string& args_proto() const { return args_proto_; }
-  void set_args_proto(const std::string& value) { args_proto_ = value; _has_field_.set(3); }
-  void set_args_proto(const void* p, size_t s) { args_proto_.assign(reinterpret_cast<const char*>(p), s); _has_field_.set(3); }
-
-  bool has_drop_reply() const { return _has_field_[4]; }
-  bool drop_reply() const { return drop_reply_; }
-  void set_drop_reply(bool value) { drop_reply_ = value; _has_field_.set(4); }
 
- private:
-  uint32_t service_id_{};
-  uint32_t method_id_{};
-  std::string args_proto_{};
-  bool drop_reply_{};
+SyncClockRequest_Clock::SyncClockRequest_Clock() = default;
+SyncClockRequest_Clock::~SyncClockRequest_Clock() = default;
+SyncClockRequest_Clock::SyncClockRequest_Clock(const SyncClockRequest_Clock&) = default;
+SyncClockRequest_Clock& SyncClockRequest_Clock::operator=(const SyncClockRequest_Clock&) = default;
+SyncClockRequest_Clock::SyncClockRequest_Clock(SyncClockRequest_Clock&&) noexcept = default;
+SyncClockRequest_Clock& SyncClockRequest_Clock::operator=(SyncClockRequest_Clock&&) = default;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+bool SyncClockRequest_Clock::operator==(const SyncClockRequest_Clock& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(clock_id_, other.clock_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(timestamp_, other.timestamp_);
+}
 
-  std::bitset<5> _has_field_{};
-};
+bool SyncClockRequest_Clock::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* clock_id */:
+        field.get(&clock_id_);
+        break;
+      case 2 /* timestamp */:
+        field.get(&timestamp_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-class PERFETTO_EXPORT_COMPONENT IPCFrame_BindServiceReply : public ::protozero::CppMessageObj {
- public:
-  using MethodInfo = IPCFrame_BindServiceReply_MethodInfo;
-  enum FieldNumbers {
-    kSuccessFieldNumber = 1,
-    kServiceIdFieldNumber = 2,
-    kMethodsFieldNumber = 3,
-  };
+std::string SyncClockRequest_Clock::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
-  IPCFrame_BindServiceReply();
-  ~IPCFrame_BindServiceReply() override;
-  IPCFrame_BindServiceReply(IPCFrame_BindServiceReply&&) noexcept;
-  IPCFrame_BindServiceReply& operator=(IPCFrame_BindServiceReply&&);
-  IPCFrame_BindServiceReply(const IPCFrame_BindServiceReply&);
-  IPCFrame_BindServiceReply& operator=(const IPCFrame_BindServiceReply&);
-  bool operator==(const IPCFrame_BindServiceReply&) const;
-  bool operator!=(const IPCFrame_BindServiceReply& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_success() const { return _has_field_[1]; }
-  bool success() const { return success_; }
-  void set_success(bool value) { success_ = value; _has_field_.set(1); }
-
-  bool has_service_id() const { return _has_field_[2]; }
-  uint32_t service_id() const { return service_id_; }
-  void set_service_id(uint32_t value) { service_id_ = value; _has_field_.set(2); }
-
-  const std::vector<IPCFrame_BindServiceReply_MethodInfo>& methods() const { return methods_; }
-  std::vector<IPCFrame_BindServiceReply_MethodInfo>* mutable_methods() { return &methods_; }
-  int methods_size() const;
-  void clear_methods();
-  IPCFrame_BindServiceReply_MethodInfo* add_methods();
+std::vector<uint8_t> SyncClockRequest_Clock::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
- private:
-  bool success_{};
-  uint32_t service_id_{};
-  std::vector<IPCFrame_BindServiceReply_MethodInfo> methods_;
+void SyncClockRequest_Clock::Serialize(::protozero::Message* msg) const {
+  // Field 1: clock_id
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, clock_id_, msg);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  // Field 2: timestamp
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, timestamp_, msg);
+  }
 
-  std::bitset<4> _has_field_{};
-};
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
 
-class PERFETTO_EXPORT_COMPONENT IPCFrame_BindServiceReply_MethodInfo : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kIdFieldNumber = 1,
-    kNameFieldNumber = 2,
-  };
+InitRelayResponse::InitRelayResponse() = default;
+InitRelayResponse::~InitRelayResponse() = default;
+InitRelayResponse::InitRelayResponse(const InitRelayResponse&) = default;
+InitRelayResponse& InitRelayResponse::operator=(const InitRelayResponse&) = default;
+InitRelayResponse::InitRelayResponse(InitRelayResponse&&) noexcept = default;
+InitRelayResponse& InitRelayResponse::operator=(InitRelayResponse&&) = default;
 
-  IPCFrame_BindServiceReply_MethodInfo();
-  ~IPCFrame_BindServiceReply_MethodInfo() override;
-  IPCFrame_BindServiceReply_MethodInfo(IPCFrame_BindServiceReply_MethodInfo&&) noexcept;
-  IPCFrame_BindServiceReply_MethodInfo& operator=(IPCFrame_BindServiceReply_MethodInfo&&);
-  IPCFrame_BindServiceReply_MethodInfo(const IPCFrame_BindServiceReply_MethodInfo&);
-  IPCFrame_BindServiceReply_MethodInfo& operator=(const IPCFrame_BindServiceReply_MethodInfo&);
-  bool operator==(const IPCFrame_BindServiceReply_MethodInfo&) const;
-  bool operator!=(const IPCFrame_BindServiceReply_MethodInfo& other) const { return !(*this == other); }
+bool InitRelayResponse::operator==(const InitRelayResponse& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_);
+}
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+bool InitRelayResponse::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  bool has_id() const { return _has_field_[1]; }
-  uint32_t id() const { return id_; }
-  void set_id(uint32_t value) { id_ = value; _has_field_.set(1); }
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-  bool has_name() const { return _has_field_[2]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
+std::string InitRelayResponse::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
- private:
-  uint32_t id_{};
-  std::string name_{};
+std::vector<uint8_t> InitRelayResponse::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+void InitRelayResponse::Serialize(::protozero::Message* msg) const {
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
-  std::bitset<3> _has_field_{};
-};
 
+InitRelayRequest::InitRelayRequest() = default;
+InitRelayRequest::~InitRelayRequest() = default;
+InitRelayRequest::InitRelayRequest(const InitRelayRequest&) = default;
+InitRelayRequest& InitRelayRequest::operator=(const InitRelayRequest&) = default;
+InitRelayRequest::InitRelayRequest(InitRelayRequest&&) noexcept = default;
+InitRelayRequest& InitRelayRequest::operator=(InitRelayRequest&&) = default;
 
-class PERFETTO_EXPORT_COMPONENT IPCFrame_BindService : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kServiceNameFieldNumber = 1,
-  };
+bool InitRelayRequest::operator==(const InitRelayRequest& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(system_info_, other.system_info_);
+}
 
-  IPCFrame_BindService();
-  ~IPCFrame_BindService() override;
-  IPCFrame_BindService(IPCFrame_BindService&&) noexcept;
-  IPCFrame_BindService& operator=(IPCFrame_BindService&&);
-  IPCFrame_BindService(const IPCFrame_BindService&);
-  IPCFrame_BindService& operator=(const IPCFrame_BindService&);
-  bool operator==(const IPCFrame_BindService&) const;
-  bool operator!=(const IPCFrame_BindService& other) const { return !(*this == other); }
+bool InitRelayRequest::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* system_info */:
+        (*system_info_).ParseFromArray(field.data(), field.size());
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
 
-  bool has_service_name() const { return _has_field_[1]; }
-  const std::string& service_name() const { return service_name_; }
-  void set_service_name(const std::string& value) { service_name_ = value; _has_field_.set(1); }
+std::string InitRelayRequest::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
 
- private:
-  std::string service_name_{};
+std::vector<uint8_t> InitRelayRequest::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+void InitRelayRequest::Serialize(::protozero::Message* msg) const {
+  // Field 1: system_info
+  if (_has_field_[1]) {
+    (*system_info_).Serialize(msg->BeginNestedMessage<::protozero::Message>(1));
+  }
 
-  std::bitset<2> _has_field_{};
-};
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
 
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_WIRE_PROTOCOL_PROTO_CPP_H_
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// gen_amalgamated begin source: gen/protos/perfetto/ipc/wire_protocol.gen.cc
 // gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
@@ -71086,14 +72575,15 @@ IPCFrame::IPCFrame(IPCFrame&&) noexcept = default;
 IPCFrame& IPCFrame::operator=(IPCFrame&&) = default;
 
 bool IPCFrame::operator==(const IPCFrame& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && request_id_ == other.request_id_
-   && msg_bind_service_ == other.msg_bind_service_
-   && msg_bind_service_reply_ == other.msg_bind_service_reply_
-   && msg_invoke_method_ == other.msg_invoke_method_
-   && msg_invoke_method_reply_ == other.msg_invoke_method_reply_
-   && msg_request_error_ == other.msg_request_error_
-   && data_for_testing_ == other.data_for_testing_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(request_id_, other.request_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(msg_bind_service_, other.msg_bind_service_)
+   && ::protozero::internal::gen_helpers::EqualsField(msg_bind_service_reply_, other.msg_bind_service_reply_)
+   && ::protozero::internal::gen_helpers::EqualsField(msg_invoke_method_, other.msg_invoke_method_)
+   && ::protozero::internal::gen_helpers::EqualsField(msg_invoke_method_reply_, other.msg_invoke_method_reply_)
+   && ::protozero::internal::gen_helpers::EqualsField(msg_request_error_, other.msg_request_error_)
+   && ::protozero::internal::gen_helpers::EqualsField(set_peer_identity_, other.set_peer_identity_)
+   && ::protozero::internal::gen_helpers::EqualsField(data_for_testing_, other.data_for_testing_);
 }
 
 bool IPCFrame::ParseFromArray(const void* raw, size_t size) {
@@ -71125,6 +72615,9 @@ bool IPCFrame::ParseFromArray(const void* raw, size_t size) {
       case 7 /* msg_request_error */:
         (*msg_request_error_).ParseFromArray(field.data(), field.size());
         break;
+      case 8 /* set_peer_identity */:
+        (*set_peer_identity_).ParseFromArray(field.data(), field.size());
+        break;
       case 1 /* data_for_testing */:
         data_for_testing_.emplace_back();
         field.get(&data_for_testing_.back());
@@ -71180,6 +72673,11 @@ void IPCFrame::Serialize(::protozero::Message* msg) const {
     (*msg_request_error_).Serialize(msg->BeginNestedMessage<::protozero::Message>(7));
   }
 
+  // Field 8: set_peer_identity
+  if (_has_field_[8]) {
+    (*set_peer_identity_).Serialize(msg->BeginNestedMessage<::protozero::Message>(8));
+  }
+
   // Field 1: data_for_testing
   for (auto& it : data_for_testing_) {
     ::protozero::internal::gen_helpers::SerializeString(1, it, msg);
@@ -71189,6 +72687,88 @@ void IPCFrame::Serialize(::protozero::Message* msg) const {
 }
 
 
+IPCFrame_SetPeerIdentity::IPCFrame_SetPeerIdentity() = default;
+IPCFrame_SetPeerIdentity::~IPCFrame_SetPeerIdentity() = default;
+IPCFrame_SetPeerIdentity::IPCFrame_SetPeerIdentity(const IPCFrame_SetPeerIdentity&) = default;
+IPCFrame_SetPeerIdentity& IPCFrame_SetPeerIdentity::operator=(const IPCFrame_SetPeerIdentity&) = default;
+IPCFrame_SetPeerIdentity::IPCFrame_SetPeerIdentity(IPCFrame_SetPeerIdentity&&) noexcept = default;
+IPCFrame_SetPeerIdentity& IPCFrame_SetPeerIdentity::operator=(IPCFrame_SetPeerIdentity&&) = default;
+
+bool IPCFrame_SetPeerIdentity::operator==(const IPCFrame_SetPeerIdentity& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(pid_, other.pid_)
+   && ::protozero::internal::gen_helpers::EqualsField(uid_, other.uid_)
+   && ::protozero::internal::gen_helpers::EqualsField(machine_id_hint_, other.machine_id_hint_)
+   && ::protozero::internal::gen_helpers::EqualsField(machine_name_, other.machine_name_);
+}
+
+bool IPCFrame_SetPeerIdentity::ParseFromArray(const void* raw, size_t size) {
+  unknown_fields_.clear();
+  bool packed_error = false;
+
+  ::protozero::ProtoDecoder dec(raw, size);
+  for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) {
+    if (field.id() < _has_field_.size()) {
+      _has_field_.set(field.id());
+    }
+    switch (field.id()) {
+      case 1 /* pid */:
+        field.get(&pid_);
+        break;
+      case 2 /* uid */:
+        field.get(&uid_);
+        break;
+      case 3 /* machine_id_hint */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &machine_id_hint_);
+        break;
+      case 4 /* machine_name */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &machine_name_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
+
+std::string IPCFrame_SetPeerIdentity::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> IPCFrame_SetPeerIdentity::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void IPCFrame_SetPeerIdentity::Serialize(::protozero::Message* msg) const {
+  // Field 1: pid
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, pid_, msg);
+  }
+
+  // Field 2: uid
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, uid_, msg);
+  }
+
+  // Field 3: machine_id_hint
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeString(3, machine_id_hint_, msg);
+  }
+
+  // Field 4: machine_name
+  if (_has_field_[4]) {
+    ::protozero::internal::gen_helpers::SerializeString(4, machine_name_, msg);
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
+
+
 IPCFrame_RequestError::IPCFrame_RequestError() = default;
 IPCFrame_RequestError::~IPCFrame_RequestError() = default;
 IPCFrame_RequestError::IPCFrame_RequestError(const IPCFrame_RequestError&) = default;
@@ -71197,8 +72777,8 @@ IPCFrame_RequestError::IPCFrame_RequestError(IPCFrame_RequestError&&) noexcept =
 IPCFrame_RequestError& IPCFrame_RequestError::operator=(IPCFrame_RequestError&&) = default;
 
 bool IPCFrame_RequestError::operator==(const IPCFrame_RequestError& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && error_ == other.error_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(error_, other.error_);
 }
 
 bool IPCFrame_RequestError::ParseFromArray(const void* raw, size_t size) {
@@ -71252,10 +72832,10 @@ IPCFrame_InvokeMethodReply::IPCFrame_InvokeMethodReply(IPCFrame_InvokeMethodRepl
 IPCFrame_InvokeMethodReply& IPCFrame_InvokeMethodReply::operator=(IPCFrame_InvokeMethodReply&&) = default;
 
 bool IPCFrame_InvokeMethodReply::operator==(const IPCFrame_InvokeMethodReply& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && success_ == other.success_
-   && has_more_ == other.has_more_
-   && reply_proto_ == other.reply_proto_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(success_, other.success_)
+   && ::protozero::internal::gen_helpers::EqualsField(has_more_, other.has_more_)
+   && ::protozero::internal::gen_helpers::EqualsField(reply_proto_, other.reply_proto_);
 }
 
 bool IPCFrame_InvokeMethodReply::ParseFromArray(const void* raw, size_t size) {
@@ -71325,11 +72905,11 @@ IPCFrame_InvokeMethod::IPCFrame_InvokeMethod(IPCFrame_InvokeMethod&&) noexcept =
 IPCFrame_InvokeMethod& IPCFrame_InvokeMethod::operator=(IPCFrame_InvokeMethod&&) = default;
 
 bool IPCFrame_InvokeMethod::operator==(const IPCFrame_InvokeMethod& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && service_id_ == other.service_id_
-   && method_id_ == other.method_id_
-   && args_proto_ == other.args_proto_
-   && drop_reply_ == other.drop_reply_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(service_id_, other.service_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(method_id_, other.method_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(args_proto_, other.args_proto_)
+   && ::protozero::internal::gen_helpers::EqualsField(drop_reply_, other.drop_reply_);
 }
 
 bool IPCFrame_InvokeMethod::ParseFromArray(const void* raw, size_t size) {
@@ -71407,10 +72987,10 @@ IPCFrame_BindServiceReply::IPCFrame_BindServiceReply(IPCFrame_BindServiceReply&&
 IPCFrame_BindServiceReply& IPCFrame_BindServiceReply::operator=(IPCFrame_BindServiceReply&&) = default;
 
 bool IPCFrame_BindServiceReply::operator==(const IPCFrame_BindServiceReply& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && success_ == other.success_
-   && service_id_ == other.service_id_
-   && methods_ == other.methods_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(success_, other.success_)
+   && ::protozero::internal::gen_helpers::EqualsField(service_id_, other.service_id_)
+   && ::protozero::internal::gen_helpers::EqualsField(methods_, other.methods_);
 }
 
 int IPCFrame_BindServiceReply::methods_size() const { return static_cast<int>(methods_.size()); }
@@ -71485,9 +73065,9 @@ IPCFrame_BindServiceReply_MethodInfo::IPCFrame_BindServiceReply_MethodInfo(IPCFr
 IPCFrame_BindServiceReply_MethodInfo& IPCFrame_BindServiceReply_MethodInfo::operator=(IPCFrame_BindServiceReply_MethodInfo&&) = default;
 
 bool IPCFrame_BindServiceReply_MethodInfo::operator==(const IPCFrame_BindServiceReply_MethodInfo& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && id_ == other.id_
-   && name_ == other.name_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(id_, other.id_)
+   && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_);
 }
 
 bool IPCFrame_BindServiceReply_MethodInfo::ParseFromArray(const void* raw, size_t size) {
@@ -71549,8 +73129,8 @@ IPCFrame_BindService::IPCFrame_BindService(IPCFrame_BindService&&) noexcept = de
 IPCFrame_BindService& IPCFrame_BindService::operator=(IPCFrame_BindService&&) = default;
 
 bool IPCFrame_BindService::operator==(const IPCFrame_BindService& other) const {
-  return unknown_fields_ == other.unknown_fields_
-   && service_name_ == other.service_name_;
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(service_name_, other.service_name_);
 }
 
 bool IPCFrame_BindService::ParseFromArray(const void* raw, size_t size) {
@@ -71627,10 +73207,14 @@ void IPCFrame_BindService::Serialize(::protozero::Message* msg) const {
 
 #include <memory>
 #include <string>
+#include <utility>
+#include <vector>
 
 // gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
 // gen_amalgamated expanded: #include "perfetto/base/export.h"
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/base/platform_handle.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/weak_ptr.h"
@@ -71640,33 +73224,24 @@ struct msghdr;
 namespace perfetto {
 namespace base {
 
-// Define the SocketHandle and ScopedSocketHandle types.
-// On POSIX OSes, a SocketHandle is really just an int (a file descriptor).
-// On Windows, sockets are have their own type (SOCKET) which is neither a
-// HANDLE nor an int. However Windows SOCKET(s) can have a event HANDLE attached
-// to them (which in Perfetto is a PlatformHandle), and that can be used in
-// WaitForMultipleObjects, hence in base::TaskRunner.AddFileDescriptorWatch().
+// Define the ScopedSocketHandle type.
 
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-// uintptr_t really reads as SOCKET here (Windows headers typedef to that).
-// As usual we don't just use SOCKET here to avoid leaking Windows.h includes
-// in our headers.
-using SocketHandle = uintptr_t;  // SOCKET
-int CloseSocket(SocketHandle);   // A wrapper around ::closesocket().
+int CloseSocket(SocketHandle);  // A wrapper around ::closesocket().
 using ScopedSocketHandle =
     ScopedResource<SocketHandle, CloseSocket, static_cast<SocketHandle>(-1)>;
 #else
-using SocketHandle = int;
 using ScopedSocketHandle = ScopedFile;
 #endif
 
+class LinuxFileWatch;
 class TaskRunner;
 
 // Use arbitrarily high values to avoid that some code accidentally ends up
 // assuming that these enum values match the sysroot's SOCK_xxx defines rather
-// than using GetSockType() / GetSockFamily().
+// than using MkSockType() / MkSockFamily().
 enum class SockType { kStream = 100, kDgram, kSeqPacket };
-enum class SockFamily { kUnix = 200, kInet, kInet6 };
+enum class SockFamily { kUnspec = 0, kUnix = 200, kInet, kInet6, kVsock };
 
 // Controls the getsockopt(SO_PEERCRED) behavior, which allows to obtain the
 // peer credentials.
@@ -71686,6 +73261,52 @@ enum class SockPeerCredMode {
 #endif
 };
 
+// Returns the socket family from the full address that perfetto uses.
+// Addr can be:
+// - /path/to/socket : for linked AF_UNIX sockets.
+// - @abstract_name  : for abstract AF_UNIX sockets.
+// - 1.2.3.4:8080    : for Inet sockets.
+// - [::1]:8080      : for Inet6 sockets.
+// - vsock://-1:3000 : for VM sockets.
+SockFamily GetSockFamily(const char* addr);
+
+// NetAddrInfo is a wrapper for a full address and it's family
+// and type.
+struct NetAddrInfo {
+  NetAddrInfo(std::string _ip_port, SockFamily _family, SockType _type)
+      : ip_port(std::move(_ip_port)), family(_family), type(_type) {}
+  std::string ip_port;  // full address with ip and port
+  SockFamily family;    // socket family
+  SockType type;        // socket type
+};
+
+// Returns a list of NetAddrInfo from ip and port which
+// ip can be an ipv4 or an ipv6 or a domain.
+// 127.0.0.1    : ipv4 address
+// localhost    : domain
+// ::1          : ipv6 address
+// port is a normal tcp port as string.
+std::vector<NetAddrInfo> GetNetAddrInfo(const std::string& ip,
+                                        const std::string& port);
+
+// Returns whether inter-process shared memory is supported for the socket.
+inline bool SockShmemSupported(SockFamily sock_family) {
+#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  return sock_family == SockFamily::kUnix;
+#else
+  base::ignore_result(sock_family);
+  // On Windows shm is negotiated by sharing an unguessable token
+  // over TCP sockets. In theory works on any socket type, in practice
+  // we need to tell the difference between a local and a remote
+  // connection. For now we assume everything is local.
+  // See comments on r.android.com/2951909 .
+  return true;
+#endif
+}
+inline bool SockShmemSupported(const char* addr) {
+  return SockShmemSupported(GetSockFamily(addr));
+}
+
 // UnixSocketRaw is a basic wrapper around sockets. It exposes wrapper
 // methods that take care of most common pitfalls (e.g., marking fd as
 // O_CLOEXEC, avoiding SIGPIPE, properly handling partial writes). It is used as
@@ -71722,6 +73343,7 @@ class UnixSocketRaw {
   void SetBlocking(bool);
   void DcheckIsBlocking(bool expected) const;  // No-op on release and Win.
   void SetRetainOnExec(bool retain);
+  std::string GetSockAddr() const;
   SockType type() const { return type_; }
   SockFamily family() const { return family_; }
   SocketHandle fd() const { return *fd_; }
@@ -71927,6 +73549,9 @@ class PERFETTO_EXPORT_COMPONENT UnixSocket {
   void SetRxTimeout(uint32_t timeout_ms) {
     PERFETTO_CHECK(sock_raw_.SetRxTimeout(timeout_ms));
   }
+
+  std::string GetSockAddr() const { return sock_raw_.GetSockAddr(); }
+
   // Returns true is the message was queued, false if there was no space in the
   // output buffer, in which case the client should retry or give up.
   // If any other error happens the socket will be shutdown and
@@ -71966,6 +73591,7 @@ class PERFETTO_EXPORT_COMPONENT UnixSocket {
   bool is_connected() const { return state_ == State::kConnected; }
   bool is_listening() const { return state_ == State::kListening; }
   SocketHandle fd() const { return sock_raw_.fd(); }
+  SockFamily family() const { return sock_raw_.family(); }
 
   // User ID of the peer, as returned by the kernel. If the client disconnects
   // and the socket goes into the kDisconnected state, it retains the uid of
@@ -71980,7 +73606,7 @@ class PERFETTO_EXPORT_COMPONENT UnixSocket {
   }
 #endif
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX_BUT_NOT_QNX) || \
     PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
   // Process ID of the peer, as returned by the kernel. If the client
   // disconnects and the socket goes into the kDisconnected state, it
@@ -72038,10 +73664,80 @@ class PERFETTO_EXPORT_COMPONENT UnixSocket {
   WeakPtrFactory<UnixSocket> weak_ptr_factory_;  // Keep last.
 };
 
+// Creates a LinuxFileWatch for the given unix socket.
+// Returns nullptr if:
+// - flags::use_unix_socket_inotify == false
+// - `sock_name` is not a file-system linked unix socket.
+// - The underlying filesystem doesn't support inotify (or other errors occur).
+// - Any platform other than Linux/Android.
+// When successful, the LinuxFileWatch is an opaque RAII handle that will remove
+// the watch on destruction.
+std::unique_ptr<LinuxFileWatch> WatchUnixSocketCreation(
+    TaskRunner* task_runner,
+    const char* sock_name,
+    std::function<void()> callback);
+
 }  // namespace base
 }  // namespace perfetto
 
 #endif  // INCLUDE_PERFETTO_EXT_BASE_UNIX_SOCKET_H_
+// gen_amalgamated begin header: src/base/vm_sockets.h
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SRC_BASE_VM_SOCKETS_H_
+#define SRC_BASE_VM_SOCKETS_H_
+
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+
+#include <sys/socket.h>
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_QNX)
+// Requires the QNX Advanced Virtualization Framework
+#include <vm_sockets.h>
+#elif defined(AF_VSOCK)
+// Use system vm_socket.h if available.
+#include <linux/vm_sockets.h>
+#else  // defined(AF_SOCK)
+// Fallback and use the stripped copy from the UAPI vm_sockets.h.
+
+#include <stdint.h>  // For uint8_t.
+
+#define AF_VSOCK 40
+
+struct sockaddr_vm {
+  sa_family_t svm_family;
+  unsigned short svm_reserved1;
+  unsigned int svm_port;
+  unsigned int svm_cid;
+  uint8_t svm_flags;
+  unsigned char svm_zero[sizeof(struct sockaddr) - sizeof(sa_family_t) -
+                         sizeof(unsigned short) - sizeof(unsigned int) -
+                         sizeof(unsigned int) - sizeof(uint8_t)];
+};
+
+#endif  // defined(AF_SOCK)
+
+#endif  // PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||
+        // PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+
+#endif  // SRC_BASE_VM_SOCKETS_H_
 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
@@ -72067,16 +73763,21 @@ class PERFETTO_EXPORT_COMPONENT UnixSocket {
 #include <sys/stat.h>
 #include <sys/types.h>
 // gen_amalgamated expanded: #include "perfetto/base/compiler.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/android_utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/file_utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/flags.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
 
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
 // The include order matters on these three Windows header groups.
-#include <Windows.h>
+#include <windows.h>
 
-#include <WS2tcpip.h>
-#include <WinSock2.h>
+#include <winsock2.h>
+#include <ws2tcpip.h>
 
 #include <afunix.h>
 #else
+#include <arpa/inet.h>
 #include <netdb.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>
@@ -72086,7 +73787,8 @@ class PERFETTO_EXPORT_COMPONENT UnixSocket {
 #include <unistd.h>
 #endif
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD)
 #include <sys/ucred.h>
 #endif
 
@@ -72100,6 +73802,16 @@ class PERFETTO_EXPORT_COMPONENT UnixSocket {
 // gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
 
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+// Use a local stripped copy of vm_sockets.h from UAPI.
+// gen_amalgamated expanded: #include "src/base/vm_sockets.h"
+#endif
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_QNX)
+#include <sys/time.h>
+#endif
+
 namespace perfetto {
 namespace base {
 
@@ -72119,6 +73831,20 @@ using CBufLenType = size_t;
 using CBufLenType = socklen_t;
 #endif
 
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+constexpr char kVsockNamePrefix[] = "vsock://";
+#endif
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+bool IsVirtualized() {
+  static bool is_virtualized = [] {
+    return base::GetAndroidProp("ro.traced.hypervisor") == "true";
+  }();
+  return is_virtualized;
+}
+#endif
+
 // A wrapper around variable-size sockaddr structs.
 // This is solving the following problem: when calling connect() or bind(), the
 // caller needs to take care to allocate the right struct (sockaddr_un for
@@ -72139,7 +73865,7 @@ struct SockaddrAny {
   socklen_t size;
 };
 
-inline int GetSockFamily(SockFamily family) {
+inline int MkSockFamily(SockFamily family) {
   switch (family) {
     case SockFamily::kUnix:
       return AF_UNIX;
@@ -72147,11 +73873,19 @@ inline int GetSockFamily(SockFamily family) {
       return AF_INET;
     case SockFamily::kInet6:
       return AF_INET6;
+    case SockFamily::kVsock:
+#ifdef AF_VSOCK
+      return AF_VSOCK;
+#else
+      return AF_UNSPEC;  // Return AF_UNSPEC on unsupported platforms.
+#endif
+    case SockFamily::kUnspec:
+      return AF_UNSPEC;
   }
   PERFETTO_CHECK(false);  // For GCC.
 }
 
-inline int GetSockType(SockType type) {
+inline int MkSockType(SockType type) {
 #if defined(SOCK_CLOEXEC)
   constexpr int kSockCloExec = SOCK_CLOEXEC;
 #else
@@ -72171,7 +73905,7 @@ inline int GetSockType(SockType type) {
 SockaddrAny MakeSockAddr(SockFamily family, const std::string& socket_name) {
   switch (family) {
     case SockFamily::kUnix: {
-      struct sockaddr_un saddr {};
+      struct sockaddr_un saddr{};
       const size_t name_len = socket_name.size();
       if (name_len + 1 /* for trailing \0 */ >= sizeof(saddr.sun_path)) {
         errno = ENAMETOOLONG;
@@ -72186,7 +73920,7 @@ SockaddrAny MakeSockAddr(SockFamily family, const std::string& socket_name) {
         PERFETTO_ELOG(
             "Abstract AF_UNIX sockets are not supported on Windows, see "
             "https://github.com/microsoft/WSL/issues/4240");
-        return SockaddrAny{};
+        return SockaddrAny();
 #endif
       }
       saddr.sun_family = AF_UNIX;
@@ -72194,7 +73928,7 @@ SockaddrAny MakeSockAddr(SockFamily family, const std::string& socket_name) {
           __builtin_offsetof(sockaddr_un, sun_path) + name_len + 1);
 
       // Abstract sockets do NOT require a trailing null terminator (which is
-      // instad mandatory for filesystem sockets). Any byte up to `size`,
+      // instead mandatory for filesystem sockets). Any byte up to `size`,
       // including '\0' will become part of the socket name.
       if (saddr.sun_path[0] == '\0')
         --size;
@@ -72205,7 +73939,7 @@ SockaddrAny MakeSockAddr(SockFamily family, const std::string& socket_name) {
       auto parts = SplitString(socket_name, ":");
       PERFETTO_CHECK(parts.size() == 2);
       struct addrinfo* addr_info = nullptr;
-      struct addrinfo hints {};
+      struct addrinfo hints{};
       hints.ai_family = AF_INET;
       PERFETTO_CHECK(getaddrinfo(parts[0].c_str(), parts[1].c_str(), &hints,
                                  &addr_info) == 0);
@@ -72223,7 +73957,7 @@ SockaddrAny MakeSockAddr(SockFamily family, const std::string& socket_name) {
       auto port = SplitString(parts[1], ":");
       PERFETTO_CHECK(port.size() == 1);
       struct addrinfo* addr_info = nullptr;
-      struct addrinfo hints {};
+      struct addrinfo hints{};
       hints.ai_family = AF_INET6;
       PERFETTO_CHECK(getaddrinfo(address[0].c_str(), port[0].c_str(), &hints,
                                  &addr_info) == 0);
@@ -72233,11 +73967,40 @@ SockaddrAny MakeSockAddr(SockFamily family, const std::string& socket_name) {
       freeaddrinfo(addr_info);
       return res;
     }
+    case SockFamily::kVsock: {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+      PERFETTO_CHECK(StartsWith(socket_name, kVsockNamePrefix));
+      auto address_port = StripPrefix(socket_name, kVsockNamePrefix);
+      auto parts = SplitString(address_port, ":");
+      PERFETTO_CHECK(parts.size() == 2);
+      sockaddr_vm addr;
+      memset(&addr, 0, sizeof(addr));
+      addr.svm_family = AF_VSOCK;
+      addr.svm_cid = *base::StringToUInt32(parts[0]);
+      addr.svm_port = *base::StringToUInt32(parts[1]);
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+      if (IsVirtualized()) {
+        // VM-to-VM VSOCK communication requires messages to be
+        // routed through the host.
+        addr.svm_flags = VMADDR_FLAG_TO_HOST;
+      }
+#endif
+      SockaddrAny res(&addr, sizeof(addr));
+      return res;
+#else
+      errno = ENOTSOCK;
+      return SockaddrAny();
+#endif
+    }
+    case SockFamily::kUnspec:
+      errno = ENOTSOCK;
+      return SockaddrAny();
   }
   PERFETTO_CHECK(false);  // For GCC.
 }
 
-ScopedSocketHandle CreateSocketHandle(SockFamily family, SockType type) {
+void InitWinSockOnce() {
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
   static bool init_winsock_once = [] {
     WSADATA ignored{};
@@ -72245,10 +74008,51 @@ ScopedSocketHandle CreateSocketHandle(SockFamily family, SockType type) {
   }();
   PERFETTO_CHECK(init_winsock_once);
 #endif
-  return ScopedSocketHandle(
-      socket(GetSockFamily(family), GetSockType(type), 0));
 }
 
+ScopedSocketHandle CreateSocketHandle(SockFamily family, SockType type) {
+  InitWinSockOnce();
+  return ScopedSocketHandle(socket(MkSockFamily(family), MkSockType(type), 0));
+}
+
+std::string AddrinfoToIpStr(const struct addrinfo* addrinfo_ptr) {
+  PERFETTO_CHECK(addrinfo_ptr && addrinfo_ptr->ai_addr);
+  PERFETTO_CHECK((addrinfo_ptr->ai_family == AF_INET) ||
+                 (addrinfo_ptr->ai_family == AF_INET6));
+
+  void* addr_ptr = nullptr;
+  char ip_str_buffer[INET6_ADDRSTRLEN];
+
+  if (addrinfo_ptr->ai_family == AF_INET) {  // IPv4
+    struct sockaddr_in* ipv4_addr =
+        reinterpret_cast<struct sockaddr_in*>(addrinfo_ptr->ai_addr);
+    addr_ptr = &(ipv4_addr->sin_addr);
+  } else if (addrinfo_ptr->ai_family == AF_INET6) {  // IPv6
+    struct sockaddr_in6* ipv6_addr =
+        reinterpret_cast<struct sockaddr_in6*>(addrinfo_ptr->ai_addr);
+    addr_ptr = &(ipv6_addr->sin6_addr);
+  }
+  PERFETTO_CHECK(inet_ntop(addrinfo_ptr->ai_family, addr_ptr, ip_str_buffer,
+                           sizeof(ip_str_buffer)) != NULL);
+  return std::string(ip_str_buffer);
+}
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+// On macOS, setsockopt(SO_SNDTIMEO/SO_RCVTIMEO) can fail with EINVAL if the
+// peer has disconnected. Since the server cannot know this, we check if
+// getpeername() also fails to detect the disconnection and swallow the error.
+// This keeps the behaviour aligned to Linux.
+bool ShouldIgnoreSocketTimeoutError(SocketHandle fd) {
+  if (errno != EINVAL)
+    return false;
+
+  struct sockaddr_storage addr;
+  socklen_t addr_len = sizeof(addr);
+  return getpeername(fd, reinterpret_cast<struct sockaddr*>(&addr),
+                     &addr_len) != 0;
+}
+#endif
+
 }  // namespace
 
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
@@ -72257,6 +74061,57 @@ int CloseSocket(SocketHandle s) {
 }
 #endif
 
+SockFamily GetSockFamily(const char* addr) {
+  if (strlen(addr) == 0)
+    return SockFamily::kUnspec;
+
+  if (addr[0] == '@')
+    return SockFamily::kUnix;  // Abstract AF_UNIX sockets.
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+  // Vsock address starts with vsock://.
+  if (strncmp(addr, kVsockNamePrefix, strlen(kVsockNamePrefix)) == 0)
+    return SockFamily::kVsock;
+#endif
+
+  // If `addr` ends in :NNNN it's either a kInet or kInet6 socket.
+  const char* col = strrchr(addr, ':');
+  if (col && CStringToInt32(col + 1).has_value()) {
+    return addr[0] == '[' ? SockFamily::kInet6 : SockFamily::kInet;
+  }
+
+  return SockFamily::kUnix;  // For anything else assume it's a linked AF_UNIX.
+}
+
+std::vector<NetAddrInfo> GetNetAddrInfo(const std::string& ip,
+                                        const std::string& port) {
+  InitWinSockOnce();
+  struct addrinfo hints;
+  struct addrinfo* serv_info;
+  struct addrinfo* p;
+  memset(&hints, 0, sizeof hints);
+  hints.ai_family = AF_UNSPEC;
+  hints.ai_socktype = SOCK_STREAM;
+  hints.ai_flags = AI_PASSIVE;
+  PERFETTO_CHECK(getaddrinfo(ip.c_str(), port.c_str(), &hints, &serv_info) ==
+                 0);
+  std::vector<NetAddrInfo> res;
+  for (p = serv_info; p != nullptr; p = p->ai_next) {
+    if (p->ai_family == AF_INET) {
+      std::string ip_str = AddrinfoToIpStr(p);
+      std::string ip_port = ip_str + ":" + port;
+      res.emplace_back(ip_port, SockFamily::kInet, SockType::kStream);
+    } else if (p->ai_family == AF_INET6) {
+      std::string ip_str = AddrinfoToIpStr(p);
+      std::string ip_port = "[" + ip_str + "]:" + port;
+      res.emplace_back(ip_port, SockFamily::kInet6, SockType::kStream);
+    }
+  }
+  freeaddrinfo(serv_info);
+  return res;
+}
+
 // +-----------------------+
 // | UnixSocketRaw methods |
 // +-----------------------+
@@ -72289,7 +74144,7 @@ std::pair<UnixSocketRaw, UnixSocketRaw> UnixSocketRaw::CreatePairPosix(
     SockFamily family,
     SockType type) {
   int fds[2];
-  if (socketpair(GetSockFamily(family), GetSockType(type), 0, fds) != 0) {
+  if (socketpair(MkSockFamily(family), MkSockType(type), 0, fds) != 0) {
     return std::make_pair(UnixSocketRaw(), UnixSocketRaw());
   }
   return std::make_pair(UnixSocketRaw(ScopedFile(fds[0]), family, type),
@@ -72315,11 +74170,24 @@ UnixSocketRaw::UnixSocketRaw(ScopedSocketHandle fd,
                              SockType type)
     : fd_(std::move(fd)), family_(family), type_(type) {
   PERFETTO_CHECK(fd_);
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD)
   const int no_sigpipe = 1;
   setsockopt(*fd_, SOL_SOCKET, SO_NOSIGPIPE, &no_sigpipe, sizeof(no_sigpipe));
 #endif
 
+// QNX doesn't support setting SO_REUSEADDR option when using vsocks.
+#if !PERFETTO_BUILDFLAG(PERFETTO_OS_QNX)
+  if (family == SockFamily::kVsock) {
+    int flag = 1;
+    // The reinterpret_cast<const char*> is needed for Windows, where the 4th
+    // arg is a const char* (on other POSIX system is a const void*).
+    PERFETTO_CHECK(!setsockopt(*fd_, SOL_SOCKET, SO_REUSEADDR,
+                               reinterpret_cast<const char*>(&flag),
+                               sizeof(flag)));
+  }
+#endif
+
   if (family == SockFamily::kInet || family == SockFamily::kInet6) {
     int flag = 1;
     // The reinterpret_cast<const char*> is needed for Windows, where the 4th
@@ -72327,7 +74195,6 @@ UnixSocketRaw::UnixSocketRaw(ScopedSocketHandle fd,
     PERFETTO_CHECK(!setsockopt(*fd_, SOL_SOCKET, SO_REUSEADDR,
                                reinterpret_cast<const char*>(&flag),
                                sizeof(flag)));
-    flag = 1;
     // Disable Nagle's algorithm, optimize for low-latency.
     // See https://github.com/google/perfetto/issues/70.
     setsockopt(*fd_, IPPROTO_TCP, TCP_NODELAY,
@@ -72431,6 +74298,26 @@ bool UnixSocketRaw::Connect(const std::string& socket_name) {
   bool continue_async = WSAGetLastError() == WSAEWOULDBLOCK;
 #else
   bool continue_async = errno == EINPROGRESS;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_QNX)
+  // QNX doesn't support the SO_ERROR socket option for vsock.
+  // Therefore block the connect call by polling the socket
+  // until it is writable.
+  bool is_blocking_call = family_ == SockFamily::kVsock;
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+  // For VM-to-VM communication block until the socket is writable.
+  // Not blocking leads to race condition where no error is found
+  // with SO_ERROR socket option but the socket is still not writable
+  // so subsequent socket calls fail.
+  bool is_blocking_call = family_ == SockFamily::kVsock && IsVirtualized();
+#else
+  bool is_blocking_call = false;
+#endif
+  if (is_blocking_call && res < 0 && continue_async) {
+    pollfd pfd{*fd_, POLLOUT, 0};
+    if (PERFETTO_EINTR(poll(&pfd, 1 /*nfds*/, 3000 /*timeout*/)) <= 0)
+      return false;
+    return (pfd.revents & POLLOUT) != 0;
+  }
 #endif
   if (res && !continue_async)
     return false;
@@ -72639,15 +74526,31 @@ bool UnixSocketRaw::SetTxTimeout(uint32_t timeout_ms) {
   DWORD timeout = timeout_ms;
   ignore_result(tx_timeout_ms_);
 #else
-  struct timeval timeout {};
+  struct timeval timeout{};
   uint32_t timeout_sec = timeout_ms / 1000;
   timeout.tv_sec = static_cast<decltype(timeout.tv_sec)>(timeout_sec);
   timeout.tv_usec = static_cast<decltype(timeout.tv_usec)>(
       (timeout_ms - (timeout_sec * 1000)) * 1000);
 #endif
-  return setsockopt(*fd_, SOL_SOCKET, SO_SNDTIMEO,
-                    reinterpret_cast<const char*>(&timeout),
-                    sizeof(timeout)) == 0;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_QNX)
+  if (family() == SockFamily::kVsock) {
+    // QNX doesn't support SO_SNDTIMEO for vsocks.
+    return true;
+  }
+#endif
+
+  if (setsockopt(*fd_, SOL_SOCKET, SO_SNDTIMEO,
+                 reinterpret_cast<const char*>(&timeout),
+                 sizeof(timeout)) == 0) {
+    return true;
+  }
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+  if (ShouldIgnoreSocketTimeoutError(*fd_))
+    return true;
+#endif
+
+  return false;
 }
 
 bool UnixSocketRaw::SetRxTimeout(uint32_t timeout_ms) {
@@ -72655,15 +74558,69 @@ bool UnixSocketRaw::SetRxTimeout(uint32_t timeout_ms) {
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
   DWORD timeout = timeout_ms;
 #else
-  struct timeval timeout {};
+  struct timeval timeout{};
   uint32_t timeout_sec = timeout_ms / 1000;
   timeout.tv_sec = static_cast<decltype(timeout.tv_sec)>(timeout_sec);
   timeout.tv_usec = static_cast<decltype(timeout.tv_usec)>(
       (timeout_ms - (timeout_sec * 1000)) * 1000);
 #endif
-  return setsockopt(*fd_, SOL_SOCKET, SO_RCVTIMEO,
-                    reinterpret_cast<const char*>(&timeout),
-                    sizeof(timeout)) == 0;
+  if (setsockopt(*fd_, SOL_SOCKET, SO_RCVTIMEO,
+                 reinterpret_cast<const char*>(&timeout),
+                 sizeof(timeout)) == 0) {
+    return true;
+  }
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+  if (ShouldIgnoreSocketTimeoutError(*fd_))
+    return true;
+#endif
+
+  return false;
+}
+
+std::string UnixSocketRaw::GetSockAddr() const {
+  struct sockaddr_storage stg{};
+  socklen_t slen = sizeof(stg);
+  PERFETTO_CHECK(
+      getsockname(*fd_, reinterpret_cast<struct sockaddr*>(&stg), &slen) == 0);
+  char addr[255]{};
+
+  if (stg.ss_family == AF_UNIX) {
+    auto* saddr = reinterpret_cast<struct sockaddr_un*>(&stg);
+    static_assert(sizeof(addr) >= sizeof(saddr->sun_path), "addr too small");
+    memcpy(addr, saddr->sun_path, sizeof(saddr->sun_path));
+    addr[0] = addr[0] == '\0' ? '@' : addr[0];
+    addr[sizeof(saddr->sun_path) - 1] = '\0';
+    return std::string(addr);
+  }
+
+  if (stg.ss_family == AF_INET) {
+    auto* saddr = reinterpret_cast<struct sockaddr_in*>(&stg);
+    PERFETTO_CHECK(inet_ntop(AF_INET, &saddr->sin_addr, addr, sizeof(addr)));
+    uint16_t port = ntohs(saddr->sin_port);
+    base::StackString<255> addr_and_port("%s:%" PRIu16, addr, port);
+    return addr_and_port.ToStdString();
+  }
+
+  if (stg.ss_family == AF_INET6) {
+    auto* saddr = reinterpret_cast<struct sockaddr_in6*>(&stg);
+    PERFETTO_CHECK(inet_ntop(AF_INET6, &saddr->sin6_addr, addr, sizeof(addr)));
+    auto port = ntohs(saddr->sin6_port);
+    base::StackString<255> addr_and_port("[%s]:%" PRIu16, addr, port);
+    return addr_and_port.ToStdString();
+  }
+
+#if defined(AF_VSOCK) && (PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
+                          PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID))
+  if (stg.ss_family == AF_VSOCK) {
+    auto* saddr = reinterpret_cast<struct sockaddr_vm*>(&stg);
+    base::StackString<255> addr_and_port("%s%u:%u", kVsockNamePrefix,
+                                         saddr->svm_cid, saddr->svm_port);
+    return addr_and_port.ToStdString();
+  }
+#endif
+
+  PERFETTO_FATAL("GetSockAddr() unsupported on family %d", stg.ss_family);
 }
 
 #if defined(__GNUC__) && !PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
@@ -72847,7 +74804,14 @@ void UnixSocket::ReadPeerCredentialsPosix() {
     return;
   PERFETTO_CHECK(peer_cred_mode_ != SockPeerCredMode::kIgnore);
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_QNX)
+  int fd = sock_raw_.fd();
+  gid_t peer_gid = 0;
+  int res = getpeereid(fd, &peer_uid_, &peer_gid);
+  ignore_result(peer_gid);
+  PERFETTO_CHECK(res == 0);
+  // There is no pid when obtaining peer credentials for QNX
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
     PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
   struct ucred user_cred;
   socklen_t len = sizeof(user_cred);
@@ -72856,7 +74820,8 @@ void UnixSocket::ReadPeerCredentialsPosix() {
   PERFETTO_CHECK(res == 0);
   peer_uid_ = user_cred.uid;
   peer_pid_ = user_cred.pid;
-#elif PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD)
   struct xucred user_cred;
   socklen_t len = sizeof(user_cred);
   int res = getsockopt(sock_raw_.fd(), 0, LOCAL_PEERCRED, &user_cred, &len);
@@ -72912,7 +74877,7 @@ void UnixSocket::OnEvent() {
       // re-posted immediately. In both cases, not doing a Recv() in
       // OnDataAvailable, leads to something bad (getting stuck on Windows,
       // getting in a hot loop on Linux), so doesn't feel we should worry too
-      // much about this. If we wanted to keep the behavrior consistent, here
+      // much about this. If we wanted to keep the behavior consistent, here
       // we should do something like: `if (sock_raw_)
       // sock_raw_.SetBlocking(false)` (Note that the socket might be closed
       // by the time we come back here, hence the if part).
@@ -72957,11 +74922,22 @@ void UnixSocket::OnEvent() {
 
   if (state_ == State::kConnecting) {
     PERFETTO_DCHECK(sock_raw_);
-    int sock_err = EINVAL;
-    socklen_t err_len = sizeof(sock_err);
-    int res =
-        getsockopt(sock_raw_.fd(), SOL_SOCKET, SO_ERROR, &sock_err, &err_len);
-
+    int res = 0, sock_err = 0;
+    bool is_error_opt_supported = true;
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_QNX)
+    // QNX doesn't support the SO_ERROR socket option for vsock.
+    // Since, we make the connect call blocking, it is fine to skip
+    // the error check and simply continue with the connection flow.
+    if (sock_raw_.family() == SockFamily::kVsock) {
+      is_error_opt_supported = false;
+    }
+#endif
+    if (is_error_opt_supported) {
+      sock_err = EINVAL;
+      socklen_t err_len = sizeof(sock_err);
+      res =
+          getsockopt(sock_raw_.fd(), SOL_SOCKET, SO_ERROR, &sock_err, &err_len);
+    }
     if (res == 0 && sock_err == EINPROGRESS)
       return;  // Not connected yet, just a spurious FD watch wakeup.
     if (res == 0 && sock_err == 0) {
@@ -73097,6 +75073,22 @@ void UnixSocket::EventListener::OnConnect(UnixSocket*, bool) {}
 void UnixSocket::EventListener::OnDisconnect(UnixSocket*) {}
 void UnixSocket::EventListener::OnDataAvailable(UnixSocket*) {}
 
+std::unique_ptr<LinuxFileWatch> WatchUnixSocketCreation(
+    TaskRunner* task_runner,
+    const char* sock_name,
+    std::function<void()> callback) {
+  if constexpr (!PERFETTO_FLAGS(USE_UNIX_SOCKET_INOTIFY))
+    return nullptr;
+
+  if (!sock_name || base::GetSockFamily(sock_name) != base::SockFamily::kUnix ||
+      sock_name[0] == '@') {
+    // We can add a inotify watch only for non-abstract (linked) Unix sockets.
+    return nullptr;
+  }
+  return LinuxFileWatch::WatchFileCreation(task_runner, sock_name,
+                                           std::move(callback));
+}
+
 }  // namespace base
 }  // namespace perfetto
 // gen_amalgamated begin source: src/ipc/buffered_frame_deserializer.cc
@@ -73633,10 +75625,6 @@ class DeferredBase {
   explicit DeferredBase(
       std::function<void(AsyncResult<ProtoMessage>)> callback = nullptr);
 
-  template <typename T>
-  explicit DeferredBase(Deferred<T> other)
-      : callback_(std::move(other.callback_)) {}
-
   ~DeferredBase();
   DeferredBase(DeferredBase&&) noexcept;
   DeferredBase& operator=(DeferredBase&&);
@@ -73946,6 +75934,9 @@ class Host {
   virtual void AdoptConnectedSocket_Fuchsia(
       base::ScopedSocketHandle,
       std::function<bool(int)> send_fd_cb) = 0;
+
+  // Overrides the default send timeout for the per-connection sockets.
+  virtual void SetSocketSendTimeoutMs(uint32_t timeout_ms) = 0;
 };
 
 }  // namespace ipc
@@ -73974,6 +75965,7 @@ class Host {
 #define INCLUDE_PERFETTO_EXT_IPC_CLIENT_INFO_H_
 
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/sys_types.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
 // gen_amalgamated expanded: #include "perfetto/ext/ipc/basic_types.h"
 
@@ -73984,11 +75976,21 @@ namespace ipc {
 class ClientInfo {
  public:
   ClientInfo() = default;
-  ClientInfo(ClientID client_id, uid_t uid, pid_t pid)
-      : client_id_(client_id), uid_(uid), pid_(pid) {}
+  ClientInfo(ClientID client_id,
+             uid_t uid,
+             pid_t pid,
+             base::MachineID machine_id,
+             std::string machine_name)
+      : client_id_(client_id),
+        uid_(uid),
+        pid_(pid),
+        machine_id_(machine_id),
+        machine_name_(machine_name) {}
 
   bool operator==(const ClientInfo& other) const {
-    return (client_id_ == other.client_id_ && uid_ == other.uid_);
+    return std::tie(client_id_, uid_, pid_, machine_id_, machine_name_) ==
+           std::tie(other.client_id_, other.uid_, other.pid_, other.machine_id_,
+                    other.machine_name_);
   }
   bool operator!=(const ClientInfo& other) const { return !(*this == other); }
 
@@ -74009,10 +76011,21 @@ class ClientInfo {
   // Posix process ID. Comes from the kernel and can be trusted.
   int32_t pid() const { return pid_; }
 
+  // An integral ID that identifies the machine the client is on.
+  base::MachineID machine_id() const { return machine_id_; }
+
+  // Name of the machine.
+  std::string machine_name() const { return machine_name_; }
+
  private:
   ClientID client_id_ = 0;
+  // The following fields are emitted to trace packets and should be kept in
+  // sync with perfetto::ClientIdentity.
   uid_t uid_ = kInvalidUid;
   pid_t pid_ = base::kInvalidPid;
+  base::MachineID machine_id_ = base::kDefaultMachineID;
+  // ... end of fields shared with ClientIdentity.
+  std::string machine_name_;
 };
 
 }  // namespace ipc
@@ -74073,6 +76086,8 @@ class Service {
     return base::ScopedFile();
   }
 
+  bool use_shmem_emulation() { return use_shmem_emulation_; }
+
  private:
   friend class HostImpl;
   ClientInfo client_info_;
@@ -74087,6 +76102,10 @@ class Service {
   // invocation per client that supplies an FD and the client needs to
   // wait for this one to return before calling another one.
   base::ScopedFile* received_fd_;
+
+  // Whether the socket needs to emulate shared memory buffer. Set by HostImpl
+  // when the service is exposed.
+  bool use_shmem_emulation_ = false;
 };
 
 }  // namespace ipc
@@ -74258,6 +76277,7 @@ ServiceProxy::EventListener::~EventListener() = default;
 #include <memory>
 
 // gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/file_utils.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/unix_socket.h"
 // gen_amalgamated expanded: #include "perfetto/ext/ipc/client.h"
@@ -74330,6 +76350,7 @@ class ClientImpl : public Client, public base::UnixSocket::EventListener {
   bool invoking_method_reply_ = false;
   const char* socket_name_ = nullptr;
   bool socket_retry_ = false;
+  bool delayed_reconnect_pending_ = false;
   uint32_t socket_backoff_ms_ = 0;
   std::unique_ptr<base::UnixSocket> sock_;
   base::TaskRunner* const task_runner_;
@@ -74342,6 +76363,9 @@ class ClientImpl : public Client, public base::UnixSocket::EventListener {
   // Queue of calls to BindService() that happened before the socket connected.
   std::list<base::WeakPtr<ServiceProxy>> queued_bindings_;
 
+  // To inotify-watch the file creation in case of connection failure.
+  std::unique_ptr<base::LinuxFileWatch> sock_inotify_;
+
   base::WeakPtrFactory<Client> weak_ptr_factory_;  // Keep last.
 };
 
@@ -74446,6 +76470,7 @@ class ServiceDescriptor {
 #include <utility>
 
 // gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/file_utils.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/unix_socket.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
 // gen_amalgamated expanded: #include "perfetto/ext/ipc/service_descriptor.h"
@@ -74499,9 +76524,11 @@ ClientImpl::~ClientImpl() {
 
 void ClientImpl::TryConnect() {
   PERFETTO_DCHECK(socket_name_);
-  sock_ = base::UnixSocket::Connect(socket_name_, this, task_runner_,
-                                    kClientSockFamily, base::SockType::kStream,
-                                    base::SockPeerCredMode::kIgnore);
+  if (sock_ && sock_->is_connected())
+    return;
+  sock_ = base::UnixSocket::Connect(
+      socket_name_, this, task_runner_, base::GetSockFamily(socket_name_),
+      base::SockType::kStream, base::SockPeerCredMode::kIgnore);
 }
 
 void ClientImpl::BindService(base::WeakPtr<ServiceProxy> service_proxy) {
@@ -74576,22 +76603,45 @@ bool ClientImpl::SendFrame(const Frame& frame, int fd) {
 }
 
 void ClientImpl::OnConnect(base::UnixSocket*, bool connected) {
+  // If the connection fails, we get a OnConnect(connected=false) call.
+  // We retry here with two strategies in parallel:
+  // - A time-based approach, with backoff.
+  // - An event-based approach using inotify.
+  // We cannot rely only on inotify because it's not supported on all platforms
+  // (and even on Linux, it works only if the underlying FS supports it).
   if (!connected && socket_retry_) {
-    socket_backoff_ms_ =
-        (socket_backoff_ms_ < 10000) ? socket_backoff_ms_ + 1000 : 30000;
-    PERFETTO_DLOG(
-        "Connection to traced's UNIX socket failed, retrying in %u seconds",
-        socket_backoff_ms_ / 1000);
     auto weak_this = weak_ptr_factory_.GetWeakPtr();
-    task_runner_->PostDelayedTask(
-        [weak_this] {
-          if (weak_this)
-            static_cast<ClientImpl&>(*weak_this).TryConnect();
-        },
-        socket_backoff_ms_);
+    if (!delayed_reconnect_pending_) {
+      delayed_reconnect_pending_ = true;
+      socket_backoff_ms_ =
+          (socket_backoff_ms_ < 10000) ? socket_backoff_ms_ + 1000 : 30000;
+      PERFETTO_DLOG(
+          "Connection to traced's UNIX socket failed, retrying in %u seconds",
+          socket_backoff_ms_ / 1000);
+
+      task_runner_->PostDelayedTask(
+          [weak_this] {
+            if (!weak_this)
+              return;
+            auto& thiz = *static_cast<ClientImpl*>(weak_this.get());
+            thiz.delayed_reconnect_pending_ = false;
+            thiz.TryConnect();
+          },
+          socket_backoff_ms_);
+    }  // if(delayed_reconnect_pending_)
+
+    if (!sock_inotify_) {
+      sock_inotify_ = base::WatchUnixSocketCreation(
+          task_runner_, socket_name_, [weak_this] {
+            if (weak_this)
+              static_cast<ClientImpl*>(weak_this.get())->TryConnect();
+          });
+    }  // if(!sock_inotify_)
     return;
   }
 
+  sock_inotify_.reset();
+
   // Drain the BindService() calls that were queued before establishing the
   // connection with the host. Note that if we got disconnected, the call to
   // OnConnect below might delete |this|, so move everything on the stack first.
@@ -74615,6 +76665,17 @@ void ClientImpl::OnDisconnect(base::UnixSocket*) {
         service_proxy->OnDisconnect();
     });
   }
+  for (const auto& it : queued_requests_) {
+    const QueuedRequest& queued_request = it.second;
+    if (queued_request.type != Frame::kMsgBindServiceFieldNumber) {
+      continue;
+    }
+    base::WeakPtr<ServiceProxy> service_proxy = queued_request.service_proxy;
+    task_runner_->PostTask([service_proxy] {
+      if (service_proxy)
+        service_proxy->OnConnect(false);
+    });
+  }
   service_bindings_.clear();
   queued_bindings_.clear();
 }
@@ -74893,6 +76954,7 @@ base::WeakPtr<ServiceProxy> ServiceProxy::GetWeakPtr() const {
 
 // gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/sys_types.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/thread_checker.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/unix_socket.h"
 // gen_amalgamated expanded: #include "perfetto/ext/ipc/deferred.h"
@@ -74902,6 +76964,8 @@ base::WeakPtr<ServiceProxy> ServiceProxy::GetWeakPtr() const {
 namespace perfetto {
 namespace ipc {
 
+constexpr uint32_t kDefaultIpcTxTimeoutMs = 10000;
+
 class HostImpl : public Host, public base::UnixSocket::EventListener {
  public:
   HostImpl(const char* socket_name, base::TaskRunner*);
@@ -74914,6 +76978,7 @@ class HostImpl : public Host, public base::UnixSocket::EventListener {
   void AdoptConnectedSocket_Fuchsia(
       base::ScopedSocketHandle,
       std::function<bool(int)> send_fd_cb) override;
+  void SetSocketSendTimeoutMs(uint32_t timeout_ms) override;
 
   // base::UnixSocket::EventListener implementation.
   void OnNewIncomingConnection(base::UnixSocket*,
@@ -74932,6 +76997,21 @@ class HostImpl : public Host, public base::UnixSocket::EventListener {
     BufferedFrameDeserializer frame_deserializer;
     base::ScopedFile received_fd;
     std::function<bool(int)> send_fd_cb_fuchsia;
+    // Peer identity set using IPCFrame sent by the client. These 3 fields
+    // should be used only for non-AF_UNIX connections AF_UNIX connections
+    // should only rely on the peer identity obtained from the socket.
+    uid_t uid_override = base::kInvalidUid;
+    pid_t pid_override = base::kInvalidPid;
+
+    // |machine_id| is mapped from machine_id_hint (or socket hostname if
+    // |the client doesn't support machine_id_hint).
+    base::MachineID machine_id = base::kDefaultMachineID;
+    std::string machine_name;
+
+    pid_t GetLinuxPeerPid() const;
+    uid_t GetPosixPeerUid() const;
+    base::MachineID GetMachineID() const { return machine_id; }
+    std::string GetMachineName() const { return machine_name; }
   };
   struct ExposedService {
     ExposedService(ServiceID, const std::string&, std::unique_ptr<Service>);
@@ -74951,6 +77031,8 @@ class HostImpl : public Host, public base::UnixSocket::EventListener {
   void OnReceivedFrame(ClientConnection*, const Frame&);
   void OnBindService(ClientConnection*, const Frame&);
   void OnInvokeMethod(ClientConnection*, const Frame&);
+  void OnSetPeerIdentity(ClientConnection*, const Frame&);
+
   void ReplyToMethodInvocation(ClientID, RequestID, AsyncResult<ProtoMessage>);
   const ExposedService* GetServiceByName(const std::string&);
 
@@ -74961,8 +77043,10 @@ class HostImpl : public Host, public base::UnixSocket::EventListener {
   std::unique_ptr<base::UnixSocket> sock_;  // The listening socket.
   std::map<ClientID, std::unique_ptr<ClientConnection>> clients_;
   std::map<base::UnixSocket*, ClientConnection*> clients_by_socket_;
+  std::string machine_name_;
   ServiceID last_service_id_ = 0;
   ClientID last_client_id_ = 0;
+  uint32_t socket_tx_timeout_ms_ = kDefaultIpcTxTimeoutMs;
   PERFETTO_THREAD_CHECKER(thread_checker_)
   base::WeakPtrFactory<HostImpl> weak_ptr_factory_;  // Keep last.
 };
@@ -74994,9 +77078,14 @@ class HostImpl : public Host, public base::UnixSocket::EventListener {
 #include <utility>
 
 // gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
 // gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
 // gen_amalgamated expanded: #include "perfetto/base/time.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/android_utils.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/crash_keys.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/sys_types.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/unix_socket.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
 // gen_amalgamated expanded: #include "perfetto/ext/ipc/service.h"
 // gen_amalgamated expanded: #include "perfetto/ext/ipc/service_descriptor.h"
@@ -75015,28 +77104,74 @@ constexpr base::SockFamily kHostSockFamily =
 
 base::CrashKey g_crash_key_uid("ipc_uid");
 
-uid_t GetPosixPeerUid(base::UnixSocket* sock) {
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) || \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA)
-  base::ignore_result(sock);
-  // Unsupported. Must be != kInvalidUid or the PacketValidator will fail.
-  return 0;
-#else
-  return sock->peer_uid_posix();
+base::MachineID GenerateMachineID(base::UnixSocket* sock,
+                                  const std::string& machine_id_hint) {
+  // The special value of base::kDefaultMachineID is reserved for local
+  // producers.
+  if (!sock->is_connected() || sock->family() == base::SockFamily::kUnix)
+    return base::kDefaultMachineID;
+
+  base::FnvHasher hasher;
+  // Use the hint from the client, or fallback to hostname if the client
+  // doesn't provide a hint.
+  if (!machine_id_hint.empty()) {
+    hasher.Update(machine_id_hint);
+  } else {
+    // Use the socket address without the port number part as the hint.
+    auto host_id = sock->GetSockAddr();
+    auto pos = std::string::npos;
+    switch (sock->family()) {
+      case base::SockFamily::kInet:
+        PERFETTO_FALLTHROUGH;
+      case base::SockFamily::kInet6:
+        PERFETTO_FALLTHROUGH;
+      case base::SockFamily::kVsock:
+        pos = host_id.rfind(":");
+        if (pos != std::string::npos)
+          host_id.resize(pos);
+        break;
+      case base::SockFamily::kUnspec:
+        PERFETTO_FALLTHROUGH;
+      case base::SockFamily::kUnix:
+        PERFETTO_DFATAL("Should be unreachable.");
+        return base::kDefaultMachineID;
+    }
+    hasher.Update(host_id);
+  }
+
+  // Take the lower 32-bit from the hash.
+  uint32_t digest = static_cast<uint32_t>(hasher.digest());
+  // Avoid the extremely unlikely case that the hasher digest happens to be 0.
+  return digest == base::kDefaultMachineID ? 1 : digest;
+}
+}  // namespace
+
+uid_t HostImpl::ClientConnection::GetPosixPeerUid() const {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+  if (sock->family() == base::SockFamily::kUnix)
+    return sock->peer_uid_posix();
 #endif
+
+  // For non-unix sockets, check if the UID is set in OnSetPeerIdentity().
+  if (uid_override != base::kInvalidUid)
+    return uid_override;
+  // Must be != kInvalidUid or the PacketValidator will fail.
+  return 0;
 }
 
-pid_t GetLinuxPeerPid(base::UnixSocket* sock) {
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
+pid_t HostImpl::ClientConnection::GetLinuxPeerPid() const {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX_BUT_NOT_QNX) || \
     PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-  return sock->peer_pid_linux();
-#else
-  base::ignore_result(sock);
-  return base::kInvalidPid;  // Unsupported.
+  if (sock->family() == base::SockFamily::kUnix)
+    return sock->peer_pid_linux();
 #endif
-}
 
-}  // namespace
+  // For non-unix sockets, return the PID set in OnSetPeerIdentity().
+  return pid_override;
+}
 
 // static
 std::unique_ptr<Host> Host::CreateInstance(const char* socket_name,
@@ -75065,24 +77200,31 @@ std::unique_ptr<Host> Host::CreateInstance_Fuchsia(
 
 HostImpl::HostImpl(base::ScopedSocketHandle socket_fd,
                    base::TaskRunner* task_runner)
-    : task_runner_(task_runner), weak_ptr_factory_(this) {
+    : task_runner_(task_runner),
+      machine_name_(base::GetPerfettoMachineName()),
+      weak_ptr_factory_(this) {
   PERFETTO_DCHECK_THREAD(thread_checker_);
   sock_ = base::UnixSocket::Listen(std::move(socket_fd), this, task_runner_,
                                    kHostSockFamily, base::SockType::kStream);
 }
 
 HostImpl::HostImpl(const char* socket_name, base::TaskRunner* task_runner)
-    : task_runner_(task_runner), weak_ptr_factory_(this) {
+    : task_runner_(task_runner),
+      machine_name_(base::GetPerfettoMachineName()),
+      weak_ptr_factory_(this) {
   PERFETTO_DCHECK_THREAD(thread_checker_);
   sock_ = base::UnixSocket::Listen(socket_name, this, task_runner_,
-                                   kHostSockFamily, base::SockType::kStream);
+                                   base::GetSockFamily(socket_name),
+                                   base::SockType::kStream);
   if (!sock_) {
     PERFETTO_PLOG("Failed to create %s", socket_name);
   }
 }
 
 HostImpl::HostImpl(base::TaskRunner* task_runner)
-    : task_runner_(task_runner), weak_ptr_factory_(this) {
+    : task_runner_(task_runner),
+      machine_name_(base::GetPerfettoMachineName()),
+      weak_ptr_factory_(this) {
   PERFETTO_DCHECK_THREAD(thread_checker_);
 }
 
@@ -75095,6 +77237,8 @@ bool HostImpl::ExposeService(std::unique_ptr<Service> service) {
     PERFETTO_DLOG("Duplicate ExposeService(): %s", service_name.c_str());
     return false;
   }
+  service->use_shmem_emulation_ =
+      sock() && !base::SockShmemSupported(sock()->family());
   ServiceID sid = ++last_service_id_;
   ExposedService exposed_service(sid, service_name, std::move(service));
   services_.emplace(sid, std::move(exposed_service));
@@ -75120,6 +77264,12 @@ void HostImpl::AdoptConnectedSocket_Fuchsia(
   PERFETTO_DCHECK(client_connection->send_fd_cb_fuchsia);
 }
 
+void HostImpl::SetSocketSendTimeoutMs(uint32_t timeout_ms) {
+  PERFETTO_DCHECK_THREAD(thread_checker_);
+  // Should be less than the watchdog period (30s).
+  socket_tx_timeout_ms_ = timeout_ms;
+}
+
 void HostImpl::OnNewIncomingConnection(
     base::UnixSocket*,
     std::unique_ptr<base::UnixSocket> new_conn) {
@@ -75129,8 +77279,10 @@ void HostImpl::OnNewIncomingConnection(
   clients_by_socket_[new_conn.get()] = client.get();
   client->id = client_id;
   client->sock = std::move(new_conn);
-  // Watchdog is 30 seconds, so set the socket timeout to 10 seconds.
-  client->sock->SetTxTimeout(10000);
+  client->sock->SetTxTimeout(socket_tx_timeout_ms_);
+  if (client->sock->family() == base::SockFamily::kUnix) {
+    client->machine_name = machine_name_;
+  }
   clients_[client_id] = std::move(client);
 }
 
@@ -75142,7 +77294,7 @@ void HostImpl::OnDataAvailable(base::UnixSocket* sock) {
   ClientConnection* client = it->second;
   BufferedFrameDeserializer& frame_deserializer = client->frame_deserializer;
 
-  auto peer_uid = GetPosixPeerUid(client->sock.get());
+  auto peer_uid = client->GetPosixPeerUid();
   auto scoped_key = g_crash_key_uid.SetScoped(static_cast<int64_t>(peer_uid));
 
   size_t rsize;
@@ -75172,6 +77324,8 @@ void HostImpl::OnReceivedFrame(ClientConnection* client,
     return OnBindService(client, req_frame);
   if (req_frame.has_msg_invoke_method())
     return OnInvokeMethod(client, req_frame);
+  if (req_frame.has_set_peer_identity())
+    return OnSetPeerIdentity(client, req_frame);
 
   PERFETTO_DLOG("Received invalid RPC frame from client %" PRIu64, client->id);
   Frame reply_frame;
@@ -75239,16 +77393,40 @@ void HostImpl::OnInvokeMethod(ClientConnection* client,
     });
   }
 
-  auto peer_uid = GetPosixPeerUid(client->sock.get());
+  auto peer_uid = client->GetPosixPeerUid();
   auto scoped_key = g_crash_key_uid.SetScoped(static_cast<int64_t>(peer_uid));
   service->client_info_ =
-      ClientInfo(client->id, peer_uid, GetLinuxPeerPid(client->sock.get()));
+      ClientInfo(client->id, peer_uid, client->GetLinuxPeerPid(),
+                 client->GetMachineID(), client->GetMachineName());
   service->received_fd_ = &client->received_fd;
   method.invoker(service, *decoded_req_args, std::move(deferred_reply));
   service->received_fd_ = nullptr;
   service->client_info_ = ClientInfo();
 }
 
+void HostImpl::OnSetPeerIdentity(ClientConnection* client,
+                                 const Frame& req_frame) {
+  if (client->sock->family() == base::SockFamily::kUnix) {
+    PERFETTO_DLOG("SetPeerIdentity is ignored for unix socket connections.");
+    return;
+  }
+
+  // This is can only be set once by the relay service.
+  if (client->pid_override != base::kInvalidPid ||
+      client->uid_override != base::kInvalidUid) {
+    PERFETTO_DLOG("Already received SetPeerIdentity.");
+    return;
+  }
+
+  const auto& set_peer_identity = req_frame.set_peer_identity();
+  client->pid_override = set_peer_identity.pid();
+  client->uid_override = static_cast<uid_t>(set_peer_identity.uid());
+
+  client->machine_id = GenerateMachineID(client->sock.get(),
+                                         set_peer_identity.machine_id_hint());
+  client->machine_name = set_peer_identity.machine_name();
+}
+
 void HostImpl::ReplyToMethodInvocation(ClientID client_id,
                                        RequestID request_id,
                                        AsyncResult<ProtoMessage> reply) {
@@ -75275,7 +77453,7 @@ void HostImpl::ReplyToMethodInvocation(ClientID client_id,
 
 // static
 void HostImpl::SendFrame(ClientConnection* client, const Frame& frame, int fd) {
-  auto peer_uid = GetPosixPeerUid(client->sock.get());
+  auto peer_uid = client->GetPosixPeerUid();
   auto scoped_key = g_crash_key_uid.SetScoped(static_cast<int64_t>(peer_uid));
 
   std::string buf = BufferedFrameDeserializer::Serialize(frame);
@@ -75308,10 +77486,13 @@ void HostImpl::OnDisconnect(base::UnixSocket* sock) {
   auto it = clients_by_socket_.find(sock);
   if (it == clients_by_socket_.end())
     return;
-  ClientID client_id = it->second->id;
+  auto* client = it->second;
+  ClientID client_id = client->id;
+
+  ClientInfo client_info(client_id, client->GetPosixPeerUid(),
+                         client->GetLinuxPeerPid(), client->GetMachineID(),
+                         client->GetMachineName());
 
-  ClientInfo client_info(client_id, GetPosixPeerUid(sock),
-                         GetLinuxPeerPid(sock));
   clients_by_socket_.erase(it);
   PERFETTO_DCHECK(clients_.count(client_id));
   clients_.erase(client_id);
@@ -76052,37 +78233,132 @@ void ProducerPortProxy::UpdateDataSource(const UpdateDataSourceRequest& request,
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
-// gen_amalgamated begin source: src/tracing/ipc/default_socket.cc
-// gen_amalgamated begin header: include/perfetto/ext/tracing/ipc/default_socket.h
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+// gen_amalgamated begin source: gen/protos/perfetto/ipc/relay_port.ipc.cc
+// gen_amalgamated begin header: gen/protos/perfetto/ipc/relay_port.ipc.h
+// DO NOT EDIT. Autogenerated by Perfetto IPC
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_RELAY_PORT_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_RELAY_PORT_PROTO_H_
 
-#ifndef INCLUDE_PERFETTO_EXT_TRACING_IPC_DEFAULT_SOCKET_H_
-#define INCLUDE_PERFETTO_EXT_TRACING_IPC_DEFAULT_SOCKET_H_
+// gen_amalgamated expanded: #include "perfetto/ext/ipc/deferred.h"
+// gen_amalgamated expanded: #include "perfetto/ext/ipc/service.h"
+// gen_amalgamated expanded: #include "perfetto/ext/ipc/service_descriptor.h"
+// gen_amalgamated expanded: #include "perfetto/ext/ipc/service_proxy.h"
 
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "protos/perfetto/ipc/relay_port.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/common/system_info.gen.h"
 
 namespace perfetto {
+namespace protos {
+namespace gen {
+
+class RelayPort : public ::perfetto::ipc::Service {
+ private:
+  static ::perfetto::ipc::ServiceDescriptor* NewDescriptor();
+
+ public:
+  ~RelayPort() override;
+
+  static const ::perfetto::ipc::ServiceDescriptor& GetDescriptorStatic();
+
+  // Service implementation.
+  const ::perfetto::ipc::ServiceDescriptor& GetDescriptor() override;
+
+  // Methods from the .proto file
+  using DeferredInitRelayResponse = ::perfetto::ipc::Deferred<InitRelayResponse>;
+  virtual void InitRelay(const InitRelayRequest&, DeferredInitRelayResponse) = 0;
+
+  using DeferredSyncClockResponse = ::perfetto::ipc::Deferred<SyncClockResponse>;
+  virtual void SyncClock(const SyncClockRequest&, DeferredSyncClockResponse) = 0;
 
-PERFETTO_EXPORT_COMPONENT const char* GetConsumerSocket();
-PERFETTO_EXPORT_COMPONENT const char* GetProducerSocket();
+};
+
+
+class RelayPortProxy : public ::perfetto::ipc::ServiceProxy {
+ public:
+   explicit RelayPortProxy(::perfetto::ipc::ServiceProxy::EventListener*);
+   ~RelayPortProxy() override;
+
+  // ServiceProxy implementation.
+  const ::perfetto::ipc::ServiceDescriptor& GetDescriptor() override;
+
+  // Methods from the .proto file
+  using DeferredInitRelayResponse = ::perfetto::ipc::Deferred<InitRelayResponse>;
+  void InitRelay(const InitRelayRequest&, DeferredInitRelayResponse, int fd = -1);
+
+  using DeferredSyncClockResponse = ::perfetto::ipc::Deferred<SyncClockResponse>;
+  void SyncClock(const SyncClockRequest&, DeferredSyncClockResponse, int fd = -1);
+
+};
 
 }  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_RELAY_PORT_PROTO_H_
+// DO NOT EDIT. Autogenerated by Perfetto IPC
+// gen_amalgamated expanded: #include "protos/perfetto/ipc/relay_port.ipc.h"
+// gen_amalgamated expanded: #include "perfetto/ext/ipc/codegen_helpers.h"
 
-#endif  // INCLUDE_PERFETTO_EXT_TRACING_IPC_DEFAULT_SOCKET_H_
+#include <memory>
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+::perfetto::ipc::ServiceDescriptor* RelayPort::NewDescriptor() {
+  auto* desc = new ::perfetto::ipc::ServiceDescriptor();
+  desc->service_name = "RelayPort";
+
+  desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{
+     "InitRelay",
+     &_IPC_Decoder<InitRelayRequest>,
+     &_IPC_Decoder<InitRelayResponse>,
+     &_IPC_Invoker<RelayPort, InitRelayRequest, InitRelayResponse, &RelayPort::InitRelay>});
+
+  desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{
+     "SyncClock",
+     &_IPC_Decoder<SyncClockRequest>,
+     &_IPC_Decoder<SyncClockResponse>,
+     &_IPC_Invoker<RelayPort, SyncClockRequest, SyncClockResponse, &RelayPort::SyncClock>});
+  desc->methods.shrink_to_fit();
+  return desc;
+}
+
+
+const ::perfetto::ipc::ServiceDescriptor& RelayPort::GetDescriptorStatic() {
+  static auto* instance = NewDescriptor();
+  return *instance;
+}
+
+// Host-side definitions.
+RelayPort::~RelayPort() = default;
+
+const ::perfetto::ipc::ServiceDescriptor& RelayPort::GetDescriptor() {
+  return GetDescriptorStatic();
+}
+
+// Client-side definitions.
+RelayPortProxy::RelayPortProxy(::perfetto::ipc::ServiceProxy::EventListener* event_listener)
+    : ::perfetto::ipc::ServiceProxy(event_listener) {}
+
+RelayPortProxy::~RelayPortProxy() = default;
+
+const ::perfetto::ipc::ServiceDescriptor& RelayPortProxy::GetDescriptor() {
+  return RelayPort::GetDescriptorStatic();
+}
+
+void RelayPortProxy::InitRelay(const InitRelayRequest& request, DeferredInitRelayResponse reply, int fd) {
+  BeginInvoke("InitRelay", request, ::perfetto::ipc::DeferredBase(std::move(reply)),
+              fd);
+}
+
+void RelayPortProxy::SyncClock(const SyncClockRequest& request, DeferredSyncClockResponse reply, int fd) {
+  BeginInvoke("SyncClock", request, ::perfetto::ipc::DeferredBase(std::move(reply)),
+              fd);
+}
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+// gen_amalgamated begin source: src/tracing/ipc/default_socket.cc
 /*
  * Copyright (C) 2018 The Android Open Source Project
  *
@@ -76099,10 +78375,12 @@ PERFETTO_EXPORT_COMPONENT const char* GetProducerSocket();
  * limitations under the License.
  */
 
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/ipc/default_socket.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/default_socket.h"
 
 // gen_amalgamated expanded: #include "perfetto/base/build_config.h"
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/android_utils.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/utils.h"
 // gen_amalgamated expanded: #include "perfetto/ext/ipc/basic_types.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
@@ -76111,6 +78389,7 @@ PERFETTO_EXPORT_COMPONENT const char* GetProducerSocket();
 
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
     PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) || \
     PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
 #include <unistd.h>
 #endif
@@ -76151,8 +78430,6 @@ bool UseRunPerfettoBaseDir() {
 
 }  // anonymous namespace
 
-static_assert(kInvalidUid == ipc::kInvalidUid, "kInvalidUid mismatching");
-
 const char* GetProducerSocket() {
   const char* name = getenv("PERFETTO_PRODUCER_SOCK_NAME");
   if (name == nullptr) {
@@ -76172,6 +78449,25 @@ const char* GetProducerSocket() {
   return name;
 }
 
+std::string GetRelaySocket() {
+  // The relay socket is optional and is connected only when the env var is set.
+  // In Android, if the env var isn't set then we check the
+  // |traced_relay.relay_port| system property.
+  const char* name = getenv("PERFETTO_RELAY_SOCK_NAME");
+  if (name != nullptr)
+    return std::string(name);
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+  return base::GetAndroidProp("traced_relay.relay_port");
+#else
+  return std::string();
+#endif
+}
+
+std::vector<std::string> TokenizeProducerSockets(
+    const char* producer_socket_names) {
+  return base::SplitString(producer_socket_names, ",");
+}
+
 const char* GetConsumerSocket() {
   const char* name = getenv("PERFETTO_CONSUMER_SOCK_NAME");
   if (name == nullptr) {
@@ -76270,7 +78566,7 @@ base::ScopedFile CreateMemfd(const char* name, unsigned int flags);
 
 #define PERFETTO_MEMFD_ENABLED()             \
   PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
-      PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX)
+      PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX_BUT_NOT_QNX)
 
 #if PERFETTO_MEMFD_ENABLED()
 
@@ -76370,6 +78666,7 @@ base::ScopedFile CreateMemfd(const char*, unsigned int) {
     PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
     PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) ||   \
     PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) || \
     PERFETTO_BUILDFLAG(PERFETTO_OS_WASM)
 
 #include <stddef.h>
@@ -76408,7 +78705,8 @@ class PosixSharedMemory : public SharedMemory {
   int fd() const { return fd_.get(); }
 
   // SharedMemory implementation.
-  void* start() const override { return start_; }
+  using SharedMemory::start;  // Equal priority to const and non-const versions
+  const void* start() const override { return start_; }
   size_t size() const override { return size_; }
 
  private:
@@ -76449,6 +78747,7 @@ class PosixSharedMemory : public SharedMemory {
     PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
     PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) ||   \
     PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) || \
     PERFETTO_BUILDFLAG(PERFETTO_OS_WASM)
 
 #include <fcntl.h>
@@ -76589,6 +78888,8 @@ std::unique_ptr<SharedMemory> PosixSharedMemory::Factory::CreateSharedMemory(
 
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
 
+#include <string>
+
 // gen_amalgamated expanded: #include "perfetto/base/build_config.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory.h"
@@ -76607,13 +78908,21 @@ class SharedMemoryWindows : public SharedMemory {
   };
 
   // Create a brand new SHM region.
-  static std::unique_ptr<SharedMemoryWindows> Create(size_t size);
+  enum Flags { kNone = 0, kInheritableHandles };
+  static std::unique_ptr<SharedMemoryWindows> Create(
+      size_t size,
+      Flags flags = Flags::kNone);
   static std::unique_ptr<SharedMemoryWindows> Attach(const std::string& key);
+  static std::unique_ptr<SharedMemoryWindows> AttachToHandleWithKey(
+      base::ScopedPlatformHandle fd,
+      const std::string& key);
   ~SharedMemoryWindows() override;
   const std::string& key() const { return key_; }
+  const base::ScopedPlatformHandle& handle() const { return handle_; }
 
   // SharedMemory implementation.
-  void* start() const override { return start_; }
+  using SharedMemory::start;  // Equal priority to const and non-const versions
+  const void* start() const override { return start_; }
   size_t size() const override { return size_; }
 
  private:
@@ -76658,7 +78967,7 @@ class SharedMemoryWindows : public SharedMemory {
 #include <memory>
 #include <random>
 
-#include <Windows.h>
+#include <windows.h>
 
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h"
@@ -76666,15 +78975,21 @@ class SharedMemoryWindows : public SharedMemory {
 namespace perfetto {
 
 // static
-std::unique_ptr<SharedMemoryWindows> SharedMemoryWindows::Create(size_t size) {
+std::unique_ptr<SharedMemoryWindows> SharedMemoryWindows::Create(size_t size,
+                                                                 Flags flags) {
   base::ScopedPlatformHandle shmem_handle;
   std::random_device rnd_dev;
   uint64_t rnd_key = (static_cast<uint64_t>(rnd_dev()) << 32) | rnd_dev();
   std::string key = "perfetto_shm_" + base::Uint64ToHexStringNoPrefix(rnd_key);
+
+  SECURITY_ATTRIBUTES security_attributes = {};
+  security_attributes.nLength = sizeof(SECURITY_ATTRIBUTES);
+  if (flags & Flags::kInheritableHandles)
+    security_attributes.bInheritHandle = TRUE;
+
   shmem_handle.reset(CreateFileMappingA(
       INVALID_HANDLE_VALUE,  // Use paging file.
-      nullptr,               // Default security.
-      PAGE_READWRITE,
+      &security_attributes, PAGE_READWRITE,
       static_cast<DWORD>(size >> 32),  // maximum object size (high-order DWORD)
       static_cast<DWORD>(size),        // maximum object size (low-order DWORD)
       key.c_str()));
@@ -76724,6 +79039,29 @@ std::unique_ptr<SharedMemoryWindows> SharedMemoryWindows::Attach(
       new SharedMemoryWindows(start, size, key, std::move(shmem_handle)));
 }
 
+// static
+std::unique_ptr<SharedMemoryWindows> SharedMemoryWindows::AttachToHandleWithKey(
+    base::ScopedPlatformHandle shmem_handle,
+    const std::string& key) {
+  void* start =
+      MapViewOfFile(*shmem_handle, FILE_MAP_ALL_ACCESS, /*offsetHigh=*/0,
+                    /*offsetLow=*/0, /*dwNumberOfBytesToMap=*/0);
+  if (!start) {
+    PERFETTO_PLOG("MapViewOfFile() failed");
+    return nullptr;
+  }
+
+  MEMORY_BASIC_INFORMATION info{};
+  if (!VirtualQuery(start, &info, sizeof(info))) {
+    PERFETTO_PLOG("VirtualQuery() failed");
+    return nullptr;
+  }
+  size_t size = info.RegionSize;
+
+  return std::unique_ptr<SharedMemoryWindows>(
+      new SharedMemoryWindows(start, size, key, std::move(shmem_handle)));
+}
+
 SharedMemoryWindows::SharedMemoryWindows(void* start,
                                          size_t size,
                                          std::string key,
@@ -76873,15 +79211,16 @@ class ConsumerIPCClientImpl : public TracingService::ConsumerEndpoint,
   void DisableTracing() override;
   void ReadBuffers() override;
   void FreeBuffers() override;
-  void Flush(uint32_t timeout_ms, FlushCallback) override;
+  void Flush(uint32_t timeout_ms, FlushCallback, FlushFlags) override;
   void Detach(const std::string& key) override;
   void Attach(const std::string& key) override;
   void GetTraceStats() override;
   void ObserveEvents(uint32_t enabled_event_types) override;
-  void QueryServiceState(QueryServiceStateCallback) override;
+  void QueryServiceState(QueryServiceStateArgs,
+                         QueryServiceStateCallback) override;
   void QueryCapabilities(QueryCapabilitiesCallback) override;
   void SaveTraceForBugreport(SaveTraceForBugreportCallback) override;
-  void CloneSession(TracingSessionID) override;
+  void CloneSession(CloneSessionArgs) override;
 
   // ipc::ServiceProxy::EventListener implementation.
   // These methods are invoked by the IPC layer, which knows nothing about
@@ -77159,7 +79498,9 @@ void ConsumerIPCClientImpl::FreeBuffers() {
   consumer_port_.FreeBuffers(req, std::move(async_response));
 }
 
-void ConsumerIPCClientImpl::Flush(uint32_t timeout_ms, FlushCallback callback) {
+void ConsumerIPCClientImpl::Flush(uint32_t timeout_ms,
+                                  FlushCallback callback,
+                                  FlushFlags flush_flags) {
   if (!connected_) {
     PERFETTO_DLOG("Cannot Flush(), not connected to tracing service");
     return callback(/*success=*/false);
@@ -77167,6 +79508,7 @@ void ConsumerIPCClientImpl::Flush(uint32_t timeout_ms, FlushCallback callback) {
 
   protos::gen::FlushRequest req;
   req.set_timeout_ms(static_cast<uint32_t>(timeout_ms));
+  req.set_flags(flush_flags.flags());
   ipc::Deferred<protos::gen::FlushResponse> async_response;
   async_response.Bind(
       [callback](ipc::AsyncResult<protos::gen::FlushResponse> response) {
@@ -77217,7 +79559,7 @@ void ConsumerIPCClientImpl::Attach(const std::string& key) {
           const TraceConfig& trace_config = response->trace_config();
 
           // If attached successfully, also attach to the end-of-trace
-          // notificaton callback, via EnableTracing(attach_notification_only).
+          // notification callback, via EnableTracing(attach_notification_only).
           protos::gen::EnableTracingRequest enable_req;
           enable_req.set_attach_notification_only(true);
           ipc::Deferred<protos::gen::EnableTracingResponse> enable_resp;
@@ -77291,6 +79633,7 @@ void ConsumerIPCClientImpl::ObserveEvents(uint32_t enabled_event_types) {
 }
 
 void ConsumerIPCClientImpl::QueryServiceState(
+    QueryServiceStateArgs args,
     QueryServiceStateCallback callback) {
   if (!connected_) {
     PERFETTO_DLOG(
@@ -77301,6 +79644,7 @@ void ConsumerIPCClientImpl::QueryServiceState(
   auto it = pending_query_svc_reqs_.insert(pending_query_svc_reqs_.end(),
                                            {std::move(callback), {}});
   protos::gen::QueryServiceStateRequest req;
+  req.set_sessions_only(args.sessions_only);
   ipc::Deferred<protos::gen::QueryServiceStateResponse> async_response;
   auto weak_this = weak_ptr_factory_.GetWeakPtr();
   async_response.Bind(
@@ -77397,14 +79741,48 @@ void ConsumerIPCClientImpl::SaveTraceForBugreport(
   consumer_port_.SaveTraceForBugreport(req, std::move(async_response));
 }
 
-void ConsumerIPCClientImpl::CloneSession(TracingSessionID tsid) {
+void ConsumerIPCClientImpl::CloneSession(CloneSessionArgs args) {
   if (!connected_) {
     PERFETTO_DLOG("Cannot CloneSession(), not connected to tracing service");
     return;
   }
 
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  if (args.output_file_fd) {
+    consumer_->OnSessionCloned(
+        {false,
+         "Passing FDs into CloneSession is not supported on Windows",
+         {},
+         false});
+    return;
+  }
+#endif
+
   protos::gen::CloneSessionRequest req;
-  req.set_session_id(tsid);
+  if (args.tsid) {
+    req.set_session_id(args.tsid);
+  }
+  if (!args.unique_session_name.empty()) {
+    req.set_unique_session_name(args.unique_session_name);
+  }
+  req.set_skip_trace_filter(args.skip_trace_filter);
+  req.set_for_bugreport(args.for_bugreport);
+  if (!args.clone_trigger_name.empty()) {
+    req.set_clone_trigger_name(args.clone_trigger_name);
+  }
+  if (!args.clone_trigger_producer_name.empty()) {
+    req.set_clone_trigger_producer_name(args.clone_trigger_producer_name);
+  }
+  if (args.clone_trigger_trusted_producer_uid != 0) {
+    req.set_clone_trigger_trusted_producer_uid(
+        static_cast<int32_t>(args.clone_trigger_trusted_producer_uid));
+  }
+  if (args.clone_trigger_boot_time_ns != 0) {
+    req.set_clone_trigger_boot_time_ns(args.clone_trigger_boot_time_ns);
+  }
+  if (args.clone_trigger_delay_ms != 0) {
+    req.set_clone_trigger_delay_ms(args.clone_trigger_delay_ms);
+  }
   ipc::Deferred<protos::gen::CloneSessionResponse> async_response;
   auto weak_this = weak_ptr_factory_.GetWeakPtr();
 
@@ -77417,13 +79795,18 @@ void ConsumerIPCClientImpl::CloneSession(TracingSessionID tsid) {
           // If the IPC fails, we are talking to an older version of the service
           // that didn't support CloneSession at all.
           weak_this->consumer_->OnSessionCloned(
-              false, "CloneSession IPC not supported");
+              {false, "CloneSession IPC not supported", {}, false});
         } else {
-          weak_this->consumer_->OnSessionCloned(response->success(),
-                                                response->error());
+          base::Uuid uuid(response->uuid_lsb(), response->uuid_msb());
+          weak_this->consumer_->OnSessionCloned(
+              {response->success(), response->error(), uuid,
+               response->was_write_into_file()});
         }
       });
-  consumer_port_.CloneSession(req, std::move(async_response));
+  // |args.output_file_fd| will be closed when this function returns, but it's
+  // fine because the IPC layer dup()'s it when sending the IPC.
+  consumer_port_.CloneSession(req, std::move(async_response),
+                              *args.output_file_fd);
 }
 }  // namespace perfetto
 // gen_amalgamated begin source: src/tracing/ipc/producer/producer_ipc_client_impl.cc
@@ -77456,6 +79839,7 @@ void ConsumerIPCClientImpl::CloneSession(TracingSessionID tsid) {
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_arbiter.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/tracing_backend.h"
 
 namespace perfetto {
 
@@ -77520,7 +79904,8 @@ class PERFETTO_EXPORT_COMPONENT ProducerIPCClient {
       size_t shared_memory_size_hint_bytes = 0,
       size_t shared_memory_page_size_hint_bytes = 0,
       std::unique_ptr<SharedMemory> shm = nullptr,
-      std::unique_ptr<SharedMemoryArbiter> shm_arbiter = nullptr);
+      std::unique_ptr<SharedMemoryArbiter> shm_arbiter = nullptr,
+      CreateSocketAsync create_socket_async = nullptr);
 
  protected:
   ProducerIPCClient() = delete;
@@ -77577,6 +79962,8 @@ class SharedMemoryArbiter;
 // IPC channel to the remote Service. This class is the glue layer between the
 // generic Service interface exposed to the clients of the library and the
 // actual IPC transport.
+// If create_socket_async is set, it will be called to create and connect to a
+// socket to the service. If unset, the producer will create and connect itself.
 class ProducerIPCClientImpl : public TracingService::ProducerEndpoint,
                               public ipc::ServiceProxy::EventListener {
  public:
@@ -77588,7 +79975,8 @@ class ProducerIPCClientImpl : public TracingService::ProducerEndpoint,
                         size_t shared_memory_size_hint_bytes,
                         size_t shared_memory_page_size_hint_bytes,
                         std::unique_ptr<SharedMemory> shm,
-                        std::unique_ptr<SharedMemoryArbiter> shm_arbiter);
+                        std::unique_ptr<SharedMemoryArbiter> shm_arbiter,
+                        CreateSocketAsync create_socket_async);
   ~ProducerIPCClientImpl() override;
 
   // TracingService::ProducerEndpoint implementation.
@@ -77631,7 +80019,8 @@ class ProducerIPCClientImpl : public TracingService::ProducerEndpoint,
   // Invoked soon after having established the connection with the service.
   void OnConnectionInitialized(bool connection_succeeded,
                                bool using_shmem_provided_by_producer,
-                               bool direct_smb_patching_supported);
+                               bool direct_smb_patching_supported,
+                               bool use_shmem_emulation);
 
   // Invoked when the remote Service sends an IPC to tell us to do something
   // (e.g. start/stop a data source).
@@ -77651,6 +80040,13 @@ class ProducerIPCClientImpl : public TracingService::ProducerEndpoint,
   // to |ipc_channel_| and (de)serializes method invocations over the wire.
   std::unique_ptr<protos::gen::ProducerPortProxy> producer_port_;
 
+  // Maps registered TraceWriter IDs to their target buffers as registered
+  // by the producer. When using shmem emulation, the producer internally
+  // needs the mapping of writer to buffer in order to do producer-side
+  // SMB scraping as it cannot rely on the map stored in the tracing
+  // service.
+  std::map<WriterID, BufferID> writers_for_scraping_;
+
   std::unique_ptr<SharedMemory> shared_memory_;
   std::unique_ptr<SharedMemoryArbiter> shared_memory_arbiter_;
   size_t shared_buffer_page_size_kb_ = 0;
@@ -77662,6 +80058,7 @@ class ProducerIPCClientImpl : public TracingService::ProducerEndpoint,
   TracingService::ProducerSMBScrapingMode const smb_scraping_mode_;
   bool is_shmem_provided_by_producer_ = false;
   bool direct_smb_patching_supported_ = false;
+  bool use_shmem_emulation_ = false;
   std::vector<std::function<void()>> pending_sync_reqs_;
   base::WeakPtrFactory<ProducerIPCClientImpl> weak_factory_{this};
   PERFETTO_THREAD_CHECKER(thread_checker_)
@@ -77694,15 +80091,18 @@ class ProducerIPCClientImpl : public TracingService::ProducerEndpoint,
 
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
 // gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/unix_socket.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/version.h"
 // gen_amalgamated expanded: #include "perfetto/ext/ipc/client.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/commit_data_request.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/producer.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_abi.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_arbiter.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_writer.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_config.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_descriptor.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/core/trace_config.h"
+// gen_amalgamated expanded: #include "src/tracing/core/in_process_shared_memory.h"
 
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
 // gen_amalgamated expanded: #include "src/tracing/ipc/shared_memory_windows.h"
@@ -77735,7 +80135,7 @@ std::unique_ptr<TracingService::ProducerEndpoint> ProducerIPCClient::Connect(
                ProducerIPCClient::ConnectionFlags::kRetryIfUnreachable},
           producer, producer_name, task_runner, smb_scraping_mode,
           shared_memory_size_hint_bytes, shared_memory_page_size_hint_bytes,
-          std::move(shm), std::move(shm_arbiter)));
+          std::move(shm), std::move(shm_arbiter), nullptr));
 }
 
 // static. (Declared in include/tracing/ipc/producer_ipc_client.h).
@@ -77748,13 +80148,14 @@ std::unique_ptr<TracingService::ProducerEndpoint> ProducerIPCClient::Connect(
     size_t shared_memory_size_hint_bytes,
     size_t shared_memory_page_size_hint_bytes,
     std::unique_ptr<SharedMemory> shm,
-    std::unique_ptr<SharedMemoryArbiter> shm_arbiter) {
+    std::unique_ptr<SharedMemoryArbiter> shm_arbiter,
+    CreateSocketAsync create_socket_async) {
   return std::unique_ptr<TracingService::ProducerEndpoint>(
-      new ProducerIPCClientImpl(std::move(conn_args), producer, producer_name,
-                                task_runner, smb_scraping_mode,
-                                shared_memory_size_hint_bytes,
-                                shared_memory_page_size_hint_bytes,
-                                std::move(shm), std::move(shm_arbiter)));
+      new ProducerIPCClientImpl(
+          std::move(conn_args), producer, producer_name, task_runner,
+          smb_scraping_mode, shared_memory_size_hint_bytes,
+          shared_memory_page_size_hint_bytes, std::move(shm),
+          std::move(shm_arbiter), create_socket_async));
 }
 
 ProducerIPCClientImpl::ProducerIPCClientImpl(
@@ -77766,13 +80167,12 @@ ProducerIPCClientImpl::ProducerIPCClientImpl(
     size_t shared_memory_size_hint_bytes,
     size_t shared_memory_page_size_hint_bytes,
     std::unique_ptr<SharedMemory> shm,
-    std::unique_ptr<SharedMemoryArbiter> shm_arbiter)
+    std::unique_ptr<SharedMemoryArbiter> shm_arbiter,
+    CreateSocketAsync create_socket_async)
     : producer_(producer),
       task_runner_(task_runner),
       receive_shmem_fd_cb_fuchsia_(
           std::move(conn_args.receive_shmem_fd_cb_fuchsia)),
-      ipc_channel_(
-          ipc::Client::CreateInstance(std::move(conn_args), task_runner)),
       producer_port_(
           new protos::gen::ProducerPortProxy(this /* event_listener */)),
       shared_memory_(std::move(shm)),
@@ -77793,7 +80193,28 @@ ProducerIPCClientImpl::ProducerIPCClientImpl(
     shared_buffer_page_size_kb_ = shared_memory_page_size_hint_bytes_ / 1024;
   }
 
-  ipc_channel_->BindService(producer_port_->GetWeakPtr());
+  if (create_socket_async) {
+    PERFETTO_DCHECK(conn_args.socket_name);
+    auto weak_this = weak_factory_.GetWeakPtr();
+    create_socket_async(
+        [weak_this, task_runner = task_runner_](base::SocketHandle fd) {
+          task_runner->PostTask([weak_this, fd] {
+            base::ScopedSocketHandle handle(fd);
+            if (!weak_this) {
+              return;
+            }
+            ipc::Client::ConnArgs args(std::move(handle));
+            weak_this->ipc_channel_ = ipc::Client::CreateInstance(
+                std::move(args), weak_this->task_runner_);
+            weak_this->ipc_channel_->BindService(
+                weak_this->producer_port_->GetWeakPtr());
+          });
+        });
+  } else {
+    ipc_channel_ =
+        ipc::Client::CreateInstance(std::move(conn_args), task_runner);
+    ipc_channel_->BindService(producer_port_->GetWeakPtr());
+  }
   PERFETTO_DCHECK_THREAD(thread_checker_);
 }
 
@@ -77828,7 +80249,8 @@ void ProducerIPCClientImpl::OnConnect() {
         OnConnectionInitialized(
             resp.success(),
             resp.success() ? resp->using_shmem_provided_by_producer() : false,
-            resp.success() ? resp->direct_smb_patching_supported() : false);
+            resp.success() ? resp->direct_smb_patching_supported() : false,
+            resp.success() ? resp->use_shmem_emulation() : false);
       });
   protos::gen::InitializeConnectionRequest req;
   req.set_producer_name(name_);
@@ -77877,7 +80299,7 @@ void ProducerIPCClientImpl::OnConnect() {
                                   std::move(on_cmd));
 
   // If there are pending Sync() requests, send them now.
-  for (const auto& pending_sync : pending_sync_reqs_)
+  for (auto& pending_sync : pending_sync_reqs_)
     Sync(std::move(pending_sync));
   pending_sync_reqs_.clear();
 }
@@ -77911,7 +80333,8 @@ void ProducerIPCClientImpl::ScheduleDisconnect() {
 void ProducerIPCClientImpl::OnConnectionInitialized(
     bool connection_succeeded,
     bool using_shmem_provided_by_producer,
-    bool direct_smb_patching_supported) {
+    bool direct_smb_patching_supported,
+    bool use_shmem_emulation) {
   PERFETTO_DCHECK_THREAD(thread_checker_);
   // If connection_succeeded == false, the OnDisconnect() call will follow next
   // and there we'll notify the |producer_|. TODO: add a test for this.
@@ -77919,6 +80342,11 @@ void ProducerIPCClientImpl::OnConnectionInitialized(
     return;
   is_shmem_provided_by_producer_ = using_shmem_provided_by_producer;
   direct_smb_patching_supported_ = direct_smb_patching_supported;
+  // The tracing service may reject using shared memory and tell the client to
+  // commit data over the socket. This can happen when the client connects to
+  // the service via a relay service:
+  // client <-Unix socket-> relay service <- vsock -> tracing service.
+  use_shmem_emulation_ = use_shmem_emulation;
   producer_->OnConnect();
 
   // Bail out if the service failed to adopt our producer-allocated SMB.
@@ -77996,7 +80424,17 @@ void ProducerIPCClientImpl::OnServiceRequest(
                                         /*require_seals_if_supported=*/false);
     }
 #endif
+    if (use_shmem_emulation_) {
+      PERFETTO_CHECK(!ipc_shared_memory);
+      // Need to create an emulated shmem buffer when the transport doesn't
+      // support it.
+      ipc_shared_memory = InProcessSharedMemory::Create(
+          /*size=*/InProcessSharedMemory::kShmemEmulationSize);
+    }
     if (ipc_shared_memory) {
+      auto shmem_mode = use_shmem_emulation_
+                            ? SharedMemoryABI::ShmemMode::kShmemEmulation
+                            : SharedMemoryABI::ShmemMode::kDefault;
       // This is the nominal case used in most configurations, where the service
       // provides the SMB.
       PERFETTO_CHECK(!is_shmem_provided_by_producer_ && !shared_memory_);
@@ -78004,8 +80442,8 @@ void ProducerIPCClientImpl::OnServiceRequest(
       shared_buffer_page_size_kb_ =
           cmd.setup_tracing().shared_buffer_page_size_kb();
       shared_memory_arbiter_ = SharedMemoryArbiter::CreateInstance(
-          shared_memory_.get(), shared_buffer_page_size_kb_ * 1024, this,
-          task_runner_);
+          shared_memory_.get(), shared_buffer_page_size_kb_ * 1024, shmem_mode,
+          this, task_runner_);
       if (direct_smb_patching_supported_)
         shared_memory_arbiter_->SetDirectSMBPatchingSupportedByService();
     } else {
@@ -78024,10 +80462,12 @@ void ProducerIPCClientImpl::OnServiceRequest(
     const auto* data_source_ids = cmd.flush().data_source_ids().data();
     static_assert(sizeof(data_source_ids[0]) == sizeof(DataSourceInstanceID),
                   "data_source_ids should be 64-bit");
+
+    FlushFlags flags(cmd.flush().flags());
     producer_->Flush(
         cmd.flush().request_id(),
         reinterpret_cast<const DataSourceInstanceID*>(data_source_ids),
-        static_cast<size_t>(cmd.flush().data_source_ids().size()));
+        static_cast<size_t>(cmd.flush().data_source_ids().size()), flags);
     return;
   }
 
@@ -78103,6 +80543,11 @@ void ProducerIPCClientImpl::RegisterTraceWriter(uint32_t writer_id,
         "Cannot RegisterTraceWriter(), not connected to tracing service");
     return;
   }
+  if (use_shmem_emulation_ &&
+      smb_scraping_mode_ == TracingService::ProducerSMBScrapingMode::kEnabled) {
+    writers_for_scraping_[static_cast<WriterID>(writer_id)] =
+        static_cast<BufferID>(target_buffer);
+  }
   protos::gen::RegisterTraceWriterRequest req;
   req.set_trace_writer_id(writer_id);
   req.set_target_buffer(target_buffer);
@@ -78117,6 +80562,10 @@ void ProducerIPCClientImpl::UnregisterTraceWriter(uint32_t writer_id) {
         "Cannot UnregisterTraceWriter(), not connected to tracing service");
     return;
   }
+  if (use_shmem_emulation_ &&
+      smb_scraping_mode_ == TracingService::ProducerSMBScrapingMode::kEnabled) {
+    writers_for_scraping_.erase(static_cast<WriterID>(writer_id));
+  }
   protos::gen::UnregisterTraceWriterRequest req;
   req.set_trace_writer_id(writer_id);
   producer_port_->UnregisterTraceWriter(
@@ -78223,7 +80672,23 @@ bool ProducerIPCClientImpl::IsShmemProvidedByProducer() const {
 }
 
 void ProducerIPCClientImpl::NotifyFlushComplete(FlushRequestID req_id) {
-  return shared_memory_arbiter_->NotifyFlushComplete(req_id);
+  shared_memory_arbiter_->NotifyFlushComplete(req_id);
+
+  // NB: For producers using SMB emulation, the actual value of
+  // ProducerSMBScrapingMode::kDefault in the service-side is unknown on the
+  // producer-side. Therefore we only do producer-side SMB scraping if the
+  // scraping mode is explicitly enabled.
+  if (use_shmem_emulation_ &&
+      smb_scraping_mode_ == TracingService::ProducerSMBScrapingMode::kEnabled) {
+    // Producer-side SMB scraping should occur after the flush is complete.
+    // Most often the NotifyFlushComplete method is called at the end of a
+    // producer's Flush method which also very commonly posts a flush pending
+    // commit data request to the producer IPC client's task runner. Posting
+    // the SMB scraping task into the task runner should push the SMB scraping
+    // after the pending flush data request.
+    shared_memory_arbiter_->ScrapeEmulatedSharedMemoryBuffer(
+        writers_for_scraping_);
+  }
 }
 
 SharedMemory* ProducerIPCClientImpl::shared_memory() const {
@@ -78276,7 +80741,7 @@ class Host;
 
 // Implements the Consumer port of the IPC service. This class proxies requests
 // and responses between the core service logic (|svc_|) and remote Consumer(s)
-// on the IPC socket, through the methods overriddden from ConsumerPort.
+// on the IPC socket, through the methods overridden from ConsumerPort.
 class ConsumerIPCService : public protos::gen::ConsumerPort {
  public:
   explicit ConsumerIPCService(TracingService* core_service);
@@ -78333,7 +80798,7 @@ class ConsumerIPCService : public protos::gen::ConsumerPort {
     void OnAttach(bool, const TraceConfig&) override;
     void OnTraceStats(bool, const TraceStats&) override;
     void OnObservableEvents(const ObservableEvents&) override;
-    void OnSessionCloned(bool, const std::string&) override;
+    void OnSessionCloned(const OnSessionClonedArgs&) override;
 
     void CloseObserveEventsResponseStream();
 
@@ -78542,8 +81007,9 @@ void ConsumerIPCService::Flush(const protos::gen::FlushRequest& req,
     if (weak_this)
       weak_this->OnFlushCallback(success, std::move(it));
   };
-  GetConsumerForCurrentRequest()->service_endpoint->Flush(req.timeout_ms(),
-                                                          std::move(callback));
+  FlushFlags flags(req.flags());
+  GetConsumerForCurrentRequest()->service_endpoint->Flush(
+      req.timeout_ms(), std::move(callback), flags);
 }
 
 // Called by the IPC layer.
@@ -78598,7 +81064,7 @@ void ConsumerIPCService::ObserveEvents(
 
 // Called by the IPC layer.
 void ConsumerIPCService::QueryServiceState(
-    const protos::gen::QueryServiceStateRequest&,
+    const protos::gen::QueryServiceStateRequest& req,
     DeferredQueryServiceStateResponse resp) {
   RemoteConsumer* remote_consumer = GetConsumerForCurrentRequest();
   auto it = pending_query_service_responses_.insert(
@@ -78609,7 +81075,9 @@ void ConsumerIPCService::QueryServiceState(
     if (weak_this)
       weak_this->OnQueryServiceCallback(success, svc_state, std::move(it));
   };
-  remote_consumer->service_endpoint->QueryServiceState(callback);
+  ConsumerEndpoint::QueryServiceStateArgs args;
+  args.sessions_only = req.sessions_only();
+  remote_consumer->service_endpoint->QueryServiceState(args, callback);
 }
 
 // Called by the service in response to service_endpoint->QueryServiceState().
@@ -78740,7 +81208,35 @@ void ConsumerIPCService::CloneSession(
     DeferredCloneSessionResponse resp) {
   RemoteConsumer* remote_consumer = GetConsumerForCurrentRequest();
   remote_consumer->clone_session_response = std::move(resp);
-  remote_consumer->service_endpoint->CloneSession(req.session_id());
+  ConsumerEndpoint::CloneSessionArgs args;
+  args.skip_trace_filter = req.skip_trace_filter();
+  args.for_bugreport = req.for_bugreport();
+  if (req.has_session_id()) {
+    args.tsid = req.session_id();
+  }
+  if (req.has_unique_session_name()) {
+    args.unique_session_name = req.unique_session_name();
+  }
+  if (req.has_clone_trigger_name()) {
+    args.clone_trigger_name = req.clone_trigger_name();
+  }
+  if (req.has_clone_trigger_producer_name()) {
+    args.clone_trigger_producer_name = req.clone_trigger_producer_name();
+  }
+  if (req.has_clone_trigger_trusted_producer_uid()) {
+    args.clone_trigger_trusted_producer_uid =
+        static_cast<uid_t>(req.clone_trigger_trusted_producer_uid());
+  }
+  if (req.has_clone_trigger_boot_time_ns()) {
+    args.clone_trigger_boot_time_ns = req.clone_trigger_boot_time_ns();
+  }
+  if (req.has_clone_trigger_delay_ms()) {
+    args.clone_trigger_delay_ms = req.clone_trigger_delay_ms();
+  }
+  // The client (perfetto_cmd) always sends the file descriptor, but the traced
+  // uses it only if the session to clone is 'write_into_file' session.
+  args.output_file_fd = ipc::Service::TakeReceivedFD();
+  remote_consumer->service_endpoint->CloneSession(std::move(args));
 }
 
 // Called by the service in response to
@@ -78893,14 +81389,16 @@ void ConsumerIPCService::RemoteConsumer::CloseObserveEventsResponseStream() {
 }
 
 void ConsumerIPCService::RemoteConsumer::OnSessionCloned(
-    bool success,
-    const std::string& error) {
+    const OnSessionClonedArgs& args) {
   if (!clone_session_response.IsBound())
     return;
 
   auto resp = ipc::AsyncResult<protos::gen::CloneSessionResponse>::Create();
-  resp->set_success(success);
-  resp->set_error(error);
+  resp->set_success(args.success);
+  resp->set_error(args.error);
+  resp->set_uuid_msb(args.uuid.msb());
+  resp->set_uuid_lsb(args.uuid.lsb());
+  resp->set_was_write_into_file(args.was_write_into_file);
   std::move(clone_session_response).Resolve(std::move(resp));
 }
 
@@ -78946,7 +81444,7 @@ class Host;
 
 // Implements the Producer port of the IPC service. This class proxies requests
 // and responses between the core service logic (|svc_|) and remote Producer(s)
-// on the IPC socket, through the methods overriddden from ProducerPort.
+// on the IPC socket, through the methods overridden from ProducerPort.
 class ProducerIPCService : public protos::gen::ProducerPort {
  public:
   explicit ProducerIPCService(TracingService* core_service);
@@ -79002,7 +81500,8 @@ class ProducerIPCService : public protos::gen::ProducerPort {
     void OnTracingSetup() override;
     void Flush(FlushRequestID,
                const DataSourceInstanceID* data_source_ids,
-               size_t num_data_sources) override;
+               size_t num_data_sources,
+               FlushFlags) override;
 
     void ClearIncrementalState(const DataSourceInstanceID* data_source_ids,
                                size_t num_data_sources) override;
@@ -79071,6 +81570,7 @@ class ProducerIPCService : public protos::gen::ProducerPort {
 // gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
 // gen_amalgamated expanded: #include "perfetto/ext/ipc/host.h"
 // gen_amalgamated expanded: #include "perfetto/ext/ipc/service.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/client_identity.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/commit_data_request.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_config.h"
@@ -79164,13 +81664,16 @@ void ProducerIPCService::InitializeConnection(
 #endif
   }
 
+  // Copy the data fields to be emitted to trace packets into ClientIdentity.
+  ClientIdentity client_identity(client_info.uid(), client_info.pid(),
+                                 client_info.machine_id());
   // ConnectProducer will call OnConnect() on the next task.
   producer->service_endpoint = core_service_->ConnectProducer(
-      producer.get(), client_info.uid(), client_info.pid(), req.producer_name(),
+      producer.get(), client_identity, req.producer_name(),
       req.shared_memory_size_hint_bytes(),
       /*in_process=*/false, smb_scraping_mode,
       req.shared_memory_page_size_hint_bytes(), std::move(shmem),
-      req.sdk_version());
+      req.sdk_version(), client_info.machine_name());
 
   // Could happen if the service has too many producers connected.
   if (!producer->service_endpoint) {
@@ -79178,7 +81681,9 @@ void ProducerIPCService::InitializeConnection(
     return;
   }
 
+  bool use_shmem_emulation = ipc::Service::use_shmem_emulation();
   bool using_producer_shmem =
+      !use_shmem_emulation &&
       producer->service_endpoint->IsShmemProvidedByProducer();
 
   producers_.emplace(ipc_client_id, std::move(producer));
@@ -79188,6 +81693,7 @@ void ProducerIPCService::InitializeConnection(
       ipc::AsyncResult<protos::gen::InitializeConnectionResponse>::Create();
   async_res->set_using_shmem_provided_by_producer(using_producer_shmem);
   async_res->set_direct_smb_patching_supported(true);
+  async_res->set_use_shmem_emulation(use_shmem_emulation);
   response.Resolve(std::move(async_res));
 }
 
@@ -79552,7 +82058,8 @@ void ProducerIPCService::RemoteProducer::SendSetupTracing() {
 void ProducerIPCService::RemoteProducer::Flush(
     FlushRequestID flush_request_id,
     const DataSourceInstanceID* data_source_ids,
-    size_t num_data_sources) {
+    size_t num_data_sources,
+    FlushFlags flush_flags) {
   if (!async_producer_commands.IsBound()) {
     PERFETTO_DLOG(
         "The Service tried to request a flush but the remote Producer has not "
@@ -79564,6 +82071,7 @@ void ProducerIPCService::RemoteProducer::Flush(
   for (size_t i = 0; i < num_data_sources; i++)
     cmd->mutable_flush()->add_data_source_ids(data_source_ids[i]);
   cmd->mutable_flush()->set_request_id(flush_request_id);
+  cmd->mutable_flush()->set_flags(flush_flags.flags());
   async_producer_commands.Resolve(std::move(cmd));
 }
 
@@ -79584,6 +82092,184 @@ void ProducerIPCService::RemoteProducer::ClearIncrementalState(
   async_producer_commands.Resolve(std::move(cmd));
 }
 
+}  // namespace perfetto
+// gen_amalgamated begin source: src/tracing/ipc/service/relay_ipc_service.cc
+// gen_amalgamated begin header: src/tracing/ipc/service/relay_ipc_service.h
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SRC_TRACING_IPC_SERVICE_RELAY_IPC_SERVICE_H_
+#define SRC_TRACING_IPC_SERVICE_RELAY_IPC_SERVICE_H_
+
+#include <limits>
+#include <list>
+
+// gen_amalgamated expanded: #include "perfetto/ext/base/flat_hash_map.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/sys_types.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/weak_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/ext/ipc/basic_types.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h"
+
+// gen_amalgamated expanded: #include "protos/perfetto/ipc/relay_port.ipc.h"
+
+namespace perfetto {
+
+// Implements the RelayPort IPC service.
+class RelayIPCService : public protos::gen::RelayPort {
+ public:
+  explicit RelayIPCService(TracingService* core_service);
+  ~RelayIPCService() override = default;
+
+  void OnClientDisconnected() override;
+  void InitRelay(const protos::gen::InitRelayRequest&,
+                 DeferredInitRelayResponse) override;
+  void SyncClock(const protos::gen::SyncClockRequest&,
+                 DeferredSyncClockResponse) override;
+
+ private:
+  TracingService* const core_service_;
+
+  using ClockSnapshots =
+      base::FlatHashMap<uint32_t, std::pair<uint64_t, uint64_t>>;
+  struct ClockSnapshotRecords {
+    base::MachineID machine_id = base::kDefaultMachineID;
+
+    // Keep track of most recent clock snapshots, ordered by local timestamps
+    // (CLOCK_BOOTTIME).
+    std::list<ClockSnapshots> clock_snapshots;
+
+    uint64_t min_rtt = std::numeric_limits<uint64_t>::max();
+  };
+
+  TracingService::RelayEndpoint* GetRelayEndpoint(ipc::ClientID);
+
+  base::FlatHashMap<ipc::ClientID,
+                    std::unique_ptr<TracingService::RelayEndpoint>>
+      relay_endpoints_;
+
+  base::WeakPtrFactory<RelayIPCService> weak_ptr_factory_;  // Keep last.
+};
+
+}  // namespace perfetto
+
+#endif  // SRC_TRACING_IPC_SERVICE_RELAY_IPC_SERVICE_H_
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// gen_amalgamated expanded: #include "src/tracing/ipc/service/relay_ipc_service.h"
+
+#include <cinttypes>
+#include <utility>
+
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/ext/base/clock_snapshots.h"
+// gen_amalgamated expanded: #include "perfetto/ext/ipc/service.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
+
+namespace perfetto {
+
+RelayIPCService::RelayIPCService(TracingService* core_service)
+    : core_service_(core_service), weak_ptr_factory_(this) {}
+
+TracingService::RelayEndpoint* RelayIPCService::GetRelayEndpoint(
+    ipc::ClientID client_id) {
+  auto* endpoint = relay_endpoints_.Find(client_id);
+  if (!endpoint)
+    return nullptr;
+  return endpoint->get();
+}
+
+void RelayIPCService::OnClientDisconnected() {
+  auto client_id = ipc::Service::client_info().client_id();
+  PERFETTO_DLOG("Relay endpoint %" PRIu64 " disconnected ", client_id);
+
+  auto* endpoint = GetRelayEndpoint(client_id);
+  if (!endpoint)
+    return;
+
+  endpoint->Disconnect();
+  relay_endpoints_.Erase(client_id);
+}
+
+void RelayIPCService::InitRelay(const protos::gen::InitRelayRequest& req,
+                                DeferredInitRelayResponse resp) {
+  // Send the response to client to reduce RTT.
+  auto async_resp = ipc::AsyncResult<protos::gen::InitRelayResponse>::Create();
+  resp.Resolve(std::move(async_resp));
+
+  // Handle the request in the core service.
+  auto machine_id = ipc::Service::client_info().machine_id();
+  auto client_id = ipc::Service::client_info().client_id();
+  auto* endpoint = GetRelayEndpoint(client_id);
+  if (!endpoint) {
+    auto ep = core_service_->ConnectRelayClient(
+        std::make_pair(machine_id, client_id));
+    endpoint = ep.get();
+    relay_endpoints_.Insert(client_id, std::move(ep));
+  }
+
+  endpoint->CacheSystemInfo(req.system_info().SerializeAsArray());
+}
+
+void RelayIPCService::SyncClock(const protos::gen::SyncClockRequest& req,
+                                DeferredSyncClockResponse resp) {
+  auto host_clock_snapshots = base::CaptureClockSnapshots();
+
+  // Send the response to client to reduce RTT.
+  auto async_resp = ipc::AsyncResult<protos::gen::SyncClockResponse>::Create();
+  resp.Resolve(std::move(async_resp));
+
+  base::ClockSnapshotVector client_clock_snapshots;
+  for (size_t i = 0; i < req.clocks().size(); i++) {
+    auto& client_clock = req.clocks()[i];
+    client_clock_snapshots.emplace_back(client_clock.clock_id(),
+                                        client_clock.timestamp());
+  }
+
+  // Handle the request in the core service.
+  auto machine_id = ipc::Service::client_info().machine_id();
+  auto client_id = ipc::Service::client_info().client_id();
+  auto* endpoint = GetRelayEndpoint(client_id);
+  if (!endpoint) {
+    auto ep = core_service_->ConnectRelayClient(
+        std::make_pair(machine_id, client_id));
+    endpoint = ep.get();
+    relay_endpoints_.Insert(client_id, std::move(ep));
+  }
+
+  RelayEndpoint::SyncMode mode = req.phase() == SyncClockRequest::PING
+                                     ? RelayEndpoint::SyncMode::PING
+                                     : RelayEndpoint::SyncMode::UPDATE;
+  endpoint->SyncClocks(mode, std::move(client_clock_snapshots),
+                       std::move(host_clock_snapshots));
+}
 }  // namespace perfetto
 // gen_amalgamated begin source: src/tracing/ipc/service/service_ipc_host_impl.cc
 // gen_amalgamated begin header: src/tracing/ipc/service/service_ipc_host_impl.h
@@ -79607,12 +82293,13 @@ void ProducerIPCService::RemoteProducer::ClearIncrementalState(
 #ifndef INCLUDE_PERFETTO_EXT_TRACING_IPC_SERVICE_IPC_HOST_H_
 #define INCLUDE_PERFETTO_EXT_TRACING_IPC_SERVICE_IPC_HOST_H_
 
+#include <list>
 #include <memory>
 
 // gen_amalgamated expanded: #include "perfetto/base/export.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h"
 // gen_amalgamated expanded: #include "perfetto/ext/base/unix_socket.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h"
+// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h"
 
 namespace perfetto {
 namespace base {
@@ -79623,7 +82310,31 @@ namespace ipc {
 class Host;
 }  // namespace ipc
 
-class TracingService;
+// The argument passed to ServiceIPCHost::Start. Can be either:
+// 1. a socket name (e.g., "/dev/unix/socket" for AF_UNIX, "127.0.0.1:1234" for
+//    TCP, "vsock://1:1234")
+// 2. A FD of a pre-bound socket. This handles the case of Android in-tree
+//    builds where init creates the socket and passes the FD in env var
+//    (See perfetto.rc).
+// 3. A pre-existing ipc::Host object.
+struct ListenEndpoint {
+  explicit ListenEndpoint(const char* socket_name);
+  explicit ListenEndpoint(std::string socket_name);
+  explicit ListenEndpoint(base::ScopedSocketHandle);
+  explicit ListenEndpoint(std::unique_ptr<ipc::Host>);
+  ~ListenEndpoint();
+
+  // Allow move but not copy.
+  ListenEndpoint(ListenEndpoint&&) noexcept;
+  ListenEndpoint& operator=(ListenEndpoint&&);
+  ListenEndpoint(const ListenEndpoint&) noexcept = delete;
+  ListenEndpoint& operator=(const ListenEndpoint&) noexcept = delete;
+
+  // Only one of these is ever set.
+  std::string sock_name;
+  base::ScopedSocketHandle sock_handle;
+  std::unique_ptr<ipc::Host> ipc_host;
+};
 
 // Creates an instance of the service (business logic + UNIX socket transport).
 // Exposed to:
@@ -79632,25 +82343,37 @@ class TracingService;
 //   src/tracing/ipc/service/service_ipc_host_impl.cc
 class PERFETTO_EXPORT_COMPONENT ServiceIPCHost {
  public:
-  static std::unique_ptr<ServiceIPCHost> CreateInstance(base::TaskRunner*);
+  static std::unique_ptr<ServiceIPCHost> CreateInstance(
+      base::TaskRunner*,
+      TracingService::InitOpts = {});
   virtual ~ServiceIPCHost();
 
   // Start listening on the Producer & Consumer ports. Returns false in case of
   // failure (e.g., something else is listening on |socket_name|).
-  virtual bool Start(const char* producer_socket_name,
-                     const char* consumer_socket_name) = 0;
+  virtual bool Start(std::list<ListenEndpoint> producer_sockets,
+                     ListenEndpoint consumer_socket) = 0;
+
+  virtual TracingService* service() const = 0;
+
+  // The methods below are for API compatibility with other projects that use
+  // some of the old flavours of Start(), back in the days when we supported
+  // only one socket or fd.
 
   // Like the above, but takes two file descriptors to already bound sockets.
   // This is used when building as part of the Android tree, where init opens
   // and binds the socket beore exec()-ing us.
-  virtual bool Start(base::ScopedSocketHandle producer_socket_fd,
-                     base::ScopedSocketHandle consumer_socket_fd) = 0;
+  // Note: An internal Google project uses this (b/390202952).
+  bool Start(base::ScopedSocketHandle producer_socket_fd,
+             base::ScopedSocketHandle consumer_socket_fd);
 
   // Allows callers to supply preconstructed Hosts.
-  virtual bool Start(std::unique_ptr<ipc::Host> producer_host,
-                     std::unique_ptr<ipc::Host> consumer_host) = 0;
+  bool Start(std::unique_ptr<ipc::Host> producer_host,
+             std::unique_ptr<ipc::Host> consumer_host);
 
-  virtual TracingService* service() const = 0;
+  // Used by tests. producer_socket_name can be a comma-separated list of N
+  // endpoints to listen onto.
+  bool Start(const char* producer_socket_names,
+             const char* consumer_socket_name);
 
  protected:
   ServiceIPCHost();
@@ -79698,16 +82421,13 @@ class Host;
 // producer_ipc_service.cc and consumer_ipc_service.cc.
 class ServiceIPCHostImpl : public ServiceIPCHost {
  public:
-  ServiceIPCHostImpl(base::TaskRunner*);
+  explicit ServiceIPCHostImpl(base::TaskRunner*,
+                              TracingService::InitOpts init_opts = {});
   ~ServiceIPCHostImpl() override;
 
   // ServiceIPCHost implementation.
-  bool Start(const char* producer_socket_name,
-             const char* consumer_socket_name) override;
-  bool Start(base::ScopedSocketHandle producer_socket_fd,
-             base::ScopedSocketHandle consumer_socket_fd) override;
-  bool Start(std::unique_ptr<ipc::Host> producer_host,
-             std::unique_ptr<ipc::Host> consumer_host) override;
+  bool Start(std::list<ListenEndpoint> producer_sockets,
+             ListenEndpoint consumer_socket) override;
 
   TracingService* service() const override;
 
@@ -79716,11 +82436,15 @@ class ServiceIPCHostImpl : public ServiceIPCHost {
   void Shutdown();
 
   base::TaskRunner* const task_runner_;
+  const TracingService::InitOpts init_opts_;
   std::unique_ptr<TracingService> svc_;  // The service business logic.
 
-  // The IPC host that listens on the Producer socket. It owns the
-  // PosixServiceProducerPort instance which deals with all producers' IPC(s).
-  std::unique_ptr<ipc::Host> producer_ipc_port_;
+  // The IPC hosts that listen on the Producer sockets. They own the
+  // PosixServiceProducerPort instances which deal with all producers' IPC(s).
+  // Note that there can be multiple producer sockets if it's specified in the
+  // producer socket name (e.g. for listening both on vsock for VMs and AF_UNIX
+  // for processes on the same machine).
+  std::vector<std::unique_ptr<ipc::Host>> producer_ipc_ports_;
 
   // As above, but for the Consumer port.
   std::unique_ptr<ipc::Host> consumer_ipc_port_;
@@ -79747,12 +82471,16 @@ class ServiceIPCHostImpl : public ServiceIPCHost {
 
 // gen_amalgamated expanded: #include "src/tracing/ipc/service/service_ipc_host_impl.h"
 
+#include <list>
+
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
 // gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
 // gen_amalgamated expanded: #include "perfetto/ext/ipc/host.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/default_socket.h"
 // gen_amalgamated expanded: #include "src/tracing/ipc/service/consumer_ipc_service.h"
 // gen_amalgamated expanded: #include "src/tracing/ipc/service/producer_ipc_service.h"
+// gen_amalgamated expanded: #include "src/tracing/ipc/service/relay_ipc_service.h"
 
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
 // gen_amalgamated expanded: #include "src/tracing/ipc/shared_memory_windows.h"
@@ -79762,53 +82490,52 @@ class ServiceIPCHostImpl : public ServiceIPCHost {
 
 namespace perfetto {
 
+namespace {
+constexpr uint32_t kProducerSocketTxTimeoutMs = 10;
+
+std::unique_ptr<ipc::Host> CreateIpcHost(base::TaskRunner* task_runner,
+                                         ListenEndpoint ep) {
+  if (!ep.sock_name.empty()) {
+    PERFETTO_DCHECK(!ep.sock_handle && !ep.ipc_host);
+    return ipc::Host::CreateInstance(ep.sock_name.c_str(), task_runner);
+  }
+  if (ep.sock_handle) {
+    PERFETTO_DCHECK(!ep.ipc_host);
+    return ipc::Host::CreateInstance(std::move(ep.sock_handle), task_runner);
+  }
+  PERFETTO_DCHECK(ep.ipc_host);
+  return std::move(ep.ipc_host);
+}
+
+}  // namespace
+
 // TODO(fmayer): implement per-uid connection limit (b/69093705).
 
 // Implements the publicly exposed factory method declared in
 // include/tracing/posix_ipc/posix_service_host.h.
 std::unique_ptr<ServiceIPCHost> ServiceIPCHost::CreateInstance(
-    base::TaskRunner* task_runner) {
-  return std::unique_ptr<ServiceIPCHost>(new ServiceIPCHostImpl(task_runner));
+    base::TaskRunner* task_runner,
+    TracingService::InitOpts init_opts) {
+  return std::unique_ptr<ServiceIPCHost>(
+      new ServiceIPCHostImpl(task_runner, init_opts));
 }
 
-ServiceIPCHostImpl::ServiceIPCHostImpl(base::TaskRunner* task_runner)
-    : task_runner_(task_runner) {}
+ServiceIPCHostImpl::ServiceIPCHostImpl(base::TaskRunner* task_runner,
+                                       TracingService::InitOpts init_opts)
+    : task_runner_(task_runner), init_opts_(init_opts) {}
 
 ServiceIPCHostImpl::~ServiceIPCHostImpl() {}
 
-bool ServiceIPCHostImpl::Start(const char* producer_socket_name,
-                               const char* consumer_socket_name) {
+bool ServiceIPCHostImpl::Start(std::list<ListenEndpoint> producer_sockets,
+                               ListenEndpoint consumer_socket) {
   PERFETTO_CHECK(!svc_);  // Check if already started.
 
   // Initialize the IPC transport.
-  producer_ipc_port_ =
-      ipc::Host::CreateInstance(producer_socket_name, task_runner_);
-  consumer_ipc_port_ =
-      ipc::Host::CreateInstance(consumer_socket_name, task_runner_);
-  return DoStart();
-}
-
-bool ServiceIPCHostImpl::Start(base::ScopedSocketHandle producer_socket_fd,
-                               base::ScopedSocketHandle consumer_socket_fd) {
-  PERFETTO_CHECK(!svc_);  // Check if already started.
-
-  // Initialize the IPC transport.
-  producer_ipc_port_ =
-      ipc::Host::CreateInstance(std::move(producer_socket_fd), task_runner_);
-  consumer_ipc_port_ =
-      ipc::Host::CreateInstance(std::move(consumer_socket_fd), task_runner_);
-  return DoStart();
-}
-
-bool ServiceIPCHostImpl::Start(std::unique_ptr<ipc::Host> producer_host,
-                               std::unique_ptr<ipc::Host> consumer_host) {
-  PERFETTO_CHECK(!svc_);  // Check if already started.
-  PERFETTO_DCHECK(producer_host);
-  PERFETTO_DCHECK(consumer_host);
-
-  // Initialize the IPC transport.
-  producer_ipc_port_ = std::move(producer_host);
-  consumer_ipc_port_ = std::move(consumer_host);
+  for (auto& sock : producer_sockets) {
+    producer_ipc_ports_.emplace_back(
+        CreateIpcHost(task_runner_, std::move(sock)));
+  }
+  consumer_ipc_port_ = CreateIpcHost(task_runner_, std::move(consumer_socket));
 
   return DoStart();
 }
@@ -79822,18 +82549,44 @@ bool ServiceIPCHostImpl::DoStart() {
   std::unique_ptr<SharedMemory::Factory> shm_factory(
       new PosixSharedMemory::Factory());
 #endif
-  svc_ = TracingService::CreateInstance(std::move(shm_factory), task_runner_);
-
-  if (!producer_ipc_port_ || !consumer_ipc_port_) {
+  svc_ = TracingService::CreateInstance(std::move(shm_factory), task_runner_,
+                                        init_opts_);
+
+  if (producer_ipc_ports_.empty() || !consumer_ipc_port_ ||
+      std::any_of(producer_ipc_ports_.begin(), producer_ipc_ports_.end(),
+                  [](const std::unique_ptr<ipc::Host>& port) {
+                    return port == nullptr;
+                  })) {
     Shutdown();
     return false;
   }
 
-  // TODO(fmayer): add a test that destroyes the ServiceIPCHostImpl soon after
+  // Lower the timeout for blocking socket sends to producers as we shouldn't
+  // normally exhaust the kernel send buffer unless the producer is
+  // unresponsive. We'll drop the connection if the timeout is hit (see
+  // UnixSocket::Send). Context in b/236813972, b/193234818.
+  // Consumer port continues using the default timeout (10s) as there are
+  // generally fewer consumer processes, and they're better behaved. Also the
+  // consumer port ipcs might exhaust the send buffer under normal operation
+  // due to large messages such as ReadBuffersResponse.
+  for (auto& producer_ipc_port : producer_ipc_ports_)
+    producer_ipc_port->SetSocketSendTimeoutMs(kProducerSocketTxTimeoutMs);
+
+  // TODO(fmayer): add a test that destroys the ServiceIPCHostImpl soon after
   // Start() and checks that no spurious callbacks are issued.
-  bool producer_service_exposed = producer_ipc_port_->ExposeService(
-      std::unique_ptr<ipc::Service>(new ProducerIPCService(svc_.get())));
-  PERFETTO_CHECK(producer_service_exposed);
+  for (auto& producer_ipc_port : producer_ipc_ports_) {
+    bool producer_service_exposed = producer_ipc_port->ExposeService(
+        std::unique_ptr<ipc::Service>(new ProducerIPCService(svc_.get())));
+    PERFETTO_CHECK(producer_service_exposed);
+
+    if (!init_opts_.enable_relay_endpoint)
+      continue;
+    // Expose a secondary service for sync with remote relay service
+    // if requested.
+    bool relay_service_exposed = producer_ipc_port->ExposeService(
+        std::unique_ptr<ipc::Service>(new RelayIPCService(svc_.get())));
+    PERFETTO_CHECK(relay_service_exposed);
+  }
 
   bool consumer_service_exposed = consumer_ipc_port_->ExposeService(
       std::unique_ptr<ipc::Service>(new ConsumerIPCService(svc_.get())));
@@ -79849,7 +82602,7 @@ TracingService* ServiceIPCHostImpl::service() const {
 void ServiceIPCHostImpl::Shutdown() {
   // TODO(primiano): add a test that causes the Shutdown() and checks that no
   // spurious callbacks are issued.
-  producer_ipc_port_.reset();
+  producer_ipc_ports_.clear();
   consumer_ipc_port_.reset();
   svc_.reset();
 }
@@ -79858,6 +82611,44 @@ void ServiceIPCHostImpl::Shutdown() {
 ServiceIPCHost::ServiceIPCHost() = default;
 ServiceIPCHost::~ServiceIPCHost() = default;
 
+// Definitions for ListenEndpoint, declared in service_ipc_host.h.
+ListenEndpoint::ListenEndpoint(const char* socket_name)
+    : sock_name(socket_name) {}
+ListenEndpoint::ListenEndpoint(std::string socket_name)
+    : sock_name(std::move(socket_name)) {}
+ListenEndpoint::ListenEndpoint(base::ScopedSocketHandle sh)
+    : sock_handle(std::move(sh)) {}
+ListenEndpoint::ListenEndpoint(std::unique_ptr<ipc::Host> ih)
+    : ipc_host(std::move(ih)) {}
+ListenEndpoint::ListenEndpoint(ListenEndpoint&&) noexcept = default;
+ListenEndpoint& ListenEndpoint::operator=(ListenEndpoint&&) = default;
+ListenEndpoint::~ListenEndpoint() = default;
+
+// Definitions for overloads of Start, declared in service_ipc_host.h.
+
+bool ServiceIPCHost::Start(const char* producer_socket_names,
+                           const char* consumer_socket_name) {
+  std::list<ListenEndpoint> eps;
+  for (const auto& sock_name : TokenizeProducerSockets(producer_socket_names)) {
+    eps.emplace_back(ListenEndpoint(sock_name));
+  }
+  return Start(std::move(eps), ListenEndpoint(consumer_socket_name));
+}
+
+bool ServiceIPCHost::Start(base::ScopedSocketHandle producer_socket_fd,
+                           base::ScopedSocketHandle consumer_socket_fd) {
+  std::list<ListenEndpoint> eps;
+  eps.emplace_back(ListenEndpoint(std::move(producer_socket_fd)));
+  return Start(std::move(eps), ListenEndpoint(std::move(consumer_socket_fd)));
+}
+
+bool ServiceIPCHost::Start(std::unique_ptr<ipc::Host> producer_host,
+                           std::unique_ptr<ipc::Host> consumer_host) {
+  std::list<ListenEndpoint> eps;
+  eps.emplace_back(ListenEndpoint(std::move(producer_host)));
+  return Start(std::move(eps), ListenEndpoint(std::move(consumer_host)));
+}
+
 }  // namespace perfetto
 // gen_amalgamated begin source: src/tracing/internal/system_tracing_backend.cc
 /*
@@ -79881,8 +82672,8 @@ ServiceIPCHost::~ServiceIPCHost() = default;
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
 // gen_amalgamated expanded: #include "perfetto/base/task_runner.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h"
-// gen_amalgamated expanded: #include "perfetto/ext/tracing/ipc/default_socket.h"
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/ipc/producer_ipc_client.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/default_socket.h"
 
 #if PERFETTO_BUILDFLAG(PERFETTO_SYSTEM_CONSUMER)
 // gen_amalgamated expanded: #include "perfetto/ext/tracing/ipc/consumer_ipc_client.h"
@@ -79923,15 +82714,16 @@ std::unique_ptr<ProducerEndpoint> SystemProducerTracingBackend::ConnectProducer(
 #else
     shm = PosixSharedMemory::Create(shmem_size_hint);
 #endif
-    arbiter = SharedMemoryArbiter::CreateUnboundInstance(shm.get(),
-                                                         shmem_page_size_hint);
+    arbiter = SharedMemoryArbiter::CreateUnboundInstance(
+        shm.get(), shmem_page_size_hint, SharedMemoryABI::ShmemMode::kDefault);
   }
 
+  ipc::Client::ConnArgs conn_args(GetProducerSocket(), true);
   auto endpoint = ProducerIPCClient::Connect(
-      GetProducerSocket(), args.producer, args.producer_name, args.task_runner,
+      std::move(conn_args), args.producer, args.producer_name, args.task_runner,
       TracingService::ProducerSMBScrapingMode::kEnabled, shmem_size_hint,
       shmem_page_size_hint, std::move(shm), std::move(arbiter),
-      ProducerIPCClient::ConnectionFlags::kRetryIfUnreachable);
+      args.create_socket_async);
   PERFETTO_CHECK(endpoint);
   return endpoint;
 }
@@ -79960,315 +82752,4 @@ std::unique_ptr<ConsumerEndpoint> SystemConsumerTracingBackend::ConnectConsumer(
 
 }  // namespace internal
 }  // namespace perfetto
-// gen_amalgamated begin source: src/tracing/platform_posix.cc
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
-
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA) || \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
-
-// gen_amalgamated expanded: #include "perfetto/ext/base/file_utils.h"
-// gen_amalgamated expanded: #include "perfetto/ext/base/thread_task_runner.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_tls.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/platform.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/trace_writer_base.h"
-
-#include <pthread.h>
-#include <stdlib.h>
-
-namespace perfetto {
-
-namespace {
-
-class PlatformPosix : public Platform {
- public:
-  PlatformPosix();
-  ~PlatformPosix() override;
-
-  ThreadLocalObject* GetOrCreateThreadLocalObject() override;
-
-  std::unique_ptr<base::TaskRunner> CreateTaskRunner(
-      const CreateTaskRunnerArgs&) override;
-  std::string GetCurrentProcessName() override;
-  void Shutdown() override;
-
- private:
-  pthread_key_t tls_key_{};
-};
-
-PlatformPosix* g_instance = nullptr;
-
-using ThreadLocalObject = Platform::ThreadLocalObject;
-
-PlatformPosix::PlatformPosix() {
-  PERFETTO_CHECK(!g_instance);
-  g_instance = this;
-  auto tls_dtor = [](void* obj) {
-    // The Posix TLS implementation resets the key before calling this dtor.
-    // Here we re-reset it to the object we are about to delete. This is to
-    // handle re-entrant usages of tracing in the PostTask done during the dtor
-    // (see comments in TracingTLS::~TracingTLS()). Chromium's platform
-    // implementation (which does NOT use this platform impl) has a similar
-    // workaround (https://crrev.com/c/2748300).
-    pthread_setspecific(g_instance->tls_key_, obj);
-    delete static_cast<ThreadLocalObject*>(obj);
-    pthread_setspecific(g_instance->tls_key_, nullptr);
-  };
-  PERFETTO_CHECK(pthread_key_create(&tls_key_, tls_dtor) == 0);
-}
-
-PlatformPosix::~PlatformPosix() {
-  // pthread_key_delete doesn't call destructors, so do it manually for the
-  // calling thread.
-  void* tls_ptr = pthread_getspecific(tls_key_);
-  delete static_cast<ThreadLocalObject*>(tls_ptr);
-
-  pthread_key_delete(tls_key_);
-  g_instance = nullptr;
-}
-
-void PlatformPosix::Shutdown() {
-  PERFETTO_CHECK(g_instance == this);
-  delete this;
-  PERFETTO_CHECK(!g_instance);
-  // We're not clearing out the instance in GetDefaultPlatform() since it's not
-  // possible to re-initialize Perfetto after calling this function anyway.
-}
-
-ThreadLocalObject* PlatformPosix::GetOrCreateThreadLocalObject() {
-  // In chromium this should be implemented using base::ThreadLocalStorage.
-  void* tls_ptr = pthread_getspecific(tls_key_);
-
-  // This is needed to handle re-entrant calls during TLS dtor.
-  // See comments in platform.cc and aosp/1712371 .
-  ThreadLocalObject* tls = static_cast<ThreadLocalObject*>(tls_ptr);
-  if (!tls) {
-    tls = ThreadLocalObject::CreateInstance().release();
-    pthread_setspecific(tls_key_, tls);
-  }
-  return tls;
-}
-
-std::unique_ptr<base::TaskRunner> PlatformPosix::CreateTaskRunner(
-    const CreateTaskRunnerArgs& args) {
-  return std::unique_ptr<base::TaskRunner>(new base::ThreadTaskRunner(
-      base::ThreadTaskRunner::CreateAndStart(args.name_for_debugging)));
-}
-
-std::string PlatformPosix::GetCurrentProcessName() {
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-  std::string cmdline;
-  base::ReadFile("/proc/self/cmdline", &cmdline);
-  return cmdline.substr(0, cmdline.find('\0'));
-#elif PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
-  return std::string(getprogname());
-#else
-  return "unknown_producer";
-#endif
-}
-
-}  // namespace
-
-// static
-Platform* Platform::GetDefaultPlatform() {
-  static PlatformPosix* instance = new PlatformPosix();
-  return instance;
-}
-
-}  // namespace perfetto
-#endif  // OS_LINUX || OS_ANDROID || OS_APPLE || OS_FUCHSIA
-// gen_amalgamated begin source: src/tracing/platform_windows.cc
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
-
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-
-#include <Windows.h>
-
-// gen_amalgamated expanded: #include "perfetto/ext/base/thread_task_runner.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_tls.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/platform.h"
-
-// Thread Termination Callbacks.
-// Windows doesn't support a per-thread destructor with its
-// TLS primitives. So, we build it manually by inserting a
-// function to be called on each thread's exit.
-// This magic is from chromium's base/threading/thread_local_storage_win.cc
-// which in turn is from http://www.codeproject.com/threads/tls.asp.
-
-#ifdef _WIN64
-#pragma comment(linker, "/INCLUDE:_tls_used")
-#pragma comment(linker, "/INCLUDE:perfetto_thread_callback_base")
-#else
-#pragma comment(linker, "/INCLUDE:__tls_used")
-#pragma comment(linker, "/INCLUDE:_perfetto_thread_callback_base")
-#endif
-
-namespace perfetto {
-
-namespace {
-
-class PlatformWindows : public Platform {
- public:
-  static PlatformWindows* instance;
-  PlatformWindows();
-  ~PlatformWindows() override;
-
-  ThreadLocalObject* GetOrCreateThreadLocalObject() override;
-  std::unique_ptr<base::TaskRunner> CreateTaskRunner(
-      const CreateTaskRunnerArgs&) override;
-  std::string GetCurrentProcessName() override;
-  void OnThreadExit();
-
- private:
-  DWORD tls_key_{};
-};
-
-using ThreadLocalObject = Platform::ThreadLocalObject;
-
-// static
-PlatformWindows* PlatformWindows::instance = nullptr;
-
-PlatformWindows::PlatformWindows() {
-  instance = this;
-  tls_key_ = ::TlsAlloc();
-  PERFETTO_CHECK(tls_key_ != TLS_OUT_OF_INDEXES);
-}
-
-PlatformWindows::~PlatformWindows() {
-  ::TlsFree(tls_key_);
-  instance = nullptr;
-}
-
-void PlatformWindows::OnThreadExit() {
-  auto tls = static_cast<ThreadLocalObject*>(::TlsGetValue(tls_key_));
-  if (tls) {
-    // At this point we rely on the TLS object to be still set to the TracingTLS
-    // we are deleting. See comments in TracingTLS::~TracingTLS().
-    delete tls;
-  }
-}
-
-ThreadLocalObject* PlatformWindows::GetOrCreateThreadLocalObject() {
-  void* tls_ptr = ::TlsGetValue(tls_key_);
-
-  auto* tls = static_cast<ThreadLocalObject*>(tls_ptr);
-  if (!tls) {
-    tls = ThreadLocalObject::CreateInstance().release();
-    ::TlsSetValue(tls_key_, tls);
-  }
-  return tls;
-}
-
-std::unique_ptr<base::TaskRunner> PlatformWindows::CreateTaskRunner(
-    const CreateTaskRunnerArgs& args) {
-  return std::unique_ptr<base::TaskRunner>(new base::ThreadTaskRunner(
-      base::ThreadTaskRunner::CreateAndStart(args.name_for_debugging)));
-}
-
-std::string PlatformWindows::GetCurrentProcessName() {
-  char buf[MAX_PATH];
-  auto len = ::GetModuleFileNameA(nullptr /*current*/, buf, sizeof(buf));
-  std::string name(buf, static_cast<size_t>(len));
-  size_t sep = name.find_last_of('\\');
-  if (sep != std::string::npos)
-    name = name.substr(sep + 1);
-  return name;
-}
-
-}  // namespace
-
-// static
-Platform* Platform::GetDefaultPlatform() {
-  static PlatformWindows* thread_safe_init_instance = new PlatformWindows();
-  return thread_safe_init_instance;
-}
-
-}  // namespace perfetto
-
-// -----------------------
-// Thread-local destructor
-// -----------------------
-
-// .CRT$XLA to .CRT$XLZ is an array of PIMAGE_TLS_CALLBACK pointers that are
-// called automatically by the OS loader code (not the CRT) when the module is
-// loaded and on thread creation. They are NOT called if the module has been
-// loaded by a LoadLibrary() call. It must have implicitly been loaded at
-// process startup.
-// See VC\crt\src\tlssup.c for reference.
-
-// extern "C" suppresses C++ name mangling so we know the symbol name for the
-// linker /INCLUDE:symbol pragma above.
-extern "C" {
-// The linker must not discard perfetto_thread_callback_base. (We force a
-// reference to this variable with a linker /INCLUDE:symbol pragma to ensure
-// that.) If this variable is discarded, the OnThreadExit function will never be
-// called.
-
-void NTAPI PerfettoOnThreadExit(PVOID, DWORD, PVOID);
-void NTAPI PerfettoOnThreadExit(PVOID, DWORD reason, PVOID) {
-  if (reason == DLL_THREAD_DETACH || reason == DLL_PROCESS_DETACH) {
-    if (perfetto::PlatformWindows::instance)
-      perfetto::PlatformWindows::instance->OnThreadExit();
-  }
-}
-
-#ifdef _WIN64
-
-// .CRT section is merged with .rdata on x64 so it must be constant data.
-#pragma const_seg(".CRT$XLP")
-
-// When defining a const variable, it must have external linkage to be sure the
-// linker doesn't discard it.
-extern const PIMAGE_TLS_CALLBACK perfetto_thread_callback_base;
-const PIMAGE_TLS_CALLBACK perfetto_thread_callback_base = PerfettoOnThreadExit;
-
-// Reset the default section.
-#pragma const_seg()
-
-#else  // _WIN64
-
-#pragma data_seg(".CRT$XLP")
-PIMAGE_TLS_CALLBACK perfetto_thread_callback_base = PerfettoOnThreadExit;
-// Reset the default section.
-#pragma data_seg()
-
-#endif  // _WIN64
-
-}  // extern "C"
-
-#endif  // OS_WIN
 
diff --git a/velox/external/perfetto/sdk/perfetto.h b/velox/external/perfetto/sdk/perfetto.h
index 1f6750d6cbe..46a9d51a835 100644
--- a/velox/external/perfetto/sdk/perfetto.h
+++ b/velox/external/perfetto/sdk/perfetto.h
@@ -41,6 +41,7 @@
 #define GEN_BUILD_CONFIG_PERFETTO_BUILD_FLAGS_H_
 
 // clang-format off
+
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ANDROID_BUILD() (0)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_CHROMIUM_BUILD() (0)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_STANDALONE_BUILD() (0)
@@ -48,26 +49,75 @@
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_IPC() (1)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_WATCHDOG() (0)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPONENT_BUILD() (0)
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ENABLE_ETM_IMPORTER() (0)
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_LLVM_SYMBOLIZER() (0)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_FORCE_DLOG_ON() (0)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_FORCE_DLOG_OFF() (0)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_FORCE_DCHECK_ON() (0)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_FORCE_DCHECK_OFF() (0)
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_HTTP_ADDITIONAL_CORS_ORIGINS() ("")
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_VERBOSE_LOGS() (1)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_VERSION_GEN() (1)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TP_PERCENTILE() (0)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TP_LINENOISE() (0)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TP_HTTPD() (0)
-#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TP_JSON() (1)
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TP_INSTRUMENTS() (0)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_LOCAL_SYMBOLIZER() (0)
-#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ZLIB() (1)
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ZLIB() (0)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TRACED_PERF() (0)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_HEAPPROFD() (0)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_STDERR_CRASH_DUMP() (0)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_X64_CPU_OPT() (0)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_LLVM_DEMANGLE() (0)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_SYSTEM_CONSUMER() (1)
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_THREAD_SAFETY_ANNOTATIONS() (0)
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ENABLE_WINSCOPE() (1)
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ENABLE_RT_MUTEX() (1)
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ENABLE_LOCKFREE_TASKRUNNER() (1)
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ENABLE_SOCK_INOTIFY() (1)
+
+struct PerfettoBuildFlag {
+  const char* name;
+  int value;
+};
+
+static const struct PerfettoBuildFlag kPerfettoBuildFlags[] = {
+    {"PERFETTO_ANDROID_BUILD", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ANDROID_BUILD()},
+    {"PERFETTO_CHROMIUM_BUILD", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_CHROMIUM_BUILD()},
+    {"PERFETTO_STANDALONE_BUILD", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_STANDALONE_BUILD()},
+    {"PERFETTO_START_DAEMONS", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_START_DAEMONS()},
+    {"PERFETTO_IPC", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_IPC()},
+    {"PERFETTO_COMPONENT_BUILD", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPONENT_BUILD()},
+    {"PERFETTO_ENABLE_ETM_IMPORTER", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ENABLE_ETM_IMPORTER()},
+    {"PERFETTO_LLVM_SYMBOLIZER", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_LLVM_SYMBOLIZER()},
+    {"PERFETTO_FORCE_DLOG_ON", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_FORCE_DLOG_ON()},
+    {"PERFETTO_FORCE_DLOG_OFF", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_FORCE_DLOG_OFF()},
+    {"PERFETTO_FORCE_DCHECK_ON", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_FORCE_DCHECK_ON()},
+    {"PERFETTO_FORCE_DCHECK_OFF", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_FORCE_DCHECK_OFF()},
+    {"PERFETTO_VERBOSE_LOGS", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_VERBOSE_LOGS()},
+    {"PERFETTO_VERSION_GEN", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_VERSION_GEN()},
+    {"PERFETTO_TP_PERCENTILE", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TP_PERCENTILE()},
+    {"PERFETTO_TP_LINENOISE", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TP_LINENOISE()},
+    {"PERFETTO_TP_HTTPD", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TP_HTTPD()},
+    {"PERFETTO_TP_INSTRUMENTS", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TP_INSTRUMENTS()},
+    {"PERFETTO_ZLIB", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ZLIB()},
+    {"PERFETTO_TRACED_PERF", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TRACED_PERF()},
+    {"PERFETTO_HEAPPROFD", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_HEAPPROFD()},
+    {"PERFETTO_STDERR_CRASH_DUMP", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_STDERR_CRASH_DUMP()},
+    {"PERFETTO_X64_CPU_OPT", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_X64_CPU_OPT()},
+    {"PERFETTO_LLVM_DEMANGLE", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_LLVM_DEMANGLE()},
+    {"PERFETTO_SYSTEM_CONSUMER", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_SYSTEM_CONSUMER()},
+    {"PERFETTO_THREAD_SAFETY_ANNOTATIONS", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_THREAD_SAFETY_ANNOTATIONS()},
+    {"PERFETTO_ENABLE_WINSCOPE", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ENABLE_WINSCOPE()},
+    {"PERFETTO_ENABLE_RT_MUTEX", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ENABLE_RT_MUTEX()},
+    {"PERFETTO_ENABLE_LOCKFREE_TASKRUNNER", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ENABLE_LOCKFREE_TASKRUNNER()},
+    {"PERFETTO_ENABLE_SOCK_INOTIFY", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ENABLE_SOCK_INOTIFY()},
+};
+
+static const int kPerfettoBuildFlagsCount = sizeof(kPerfettoBuildFlags) / sizeof(struct PerfettoBuildFlag);
 
 // clang-format on
+
 #endif  // GEN_BUILD_CONFIG_PERFETTO_BUILD_FLAGS_H_
 /*
  * Copyright (C) 2017 The Android Open Source Project
@@ -98,6 +148,7 @@
 #if defined(__ANDROID__)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_ANDROID() 1
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX_BUT_NOT_QNX() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WIN() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_MAC() 0
@@ -105,26 +156,53 @@
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WASM() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FUCHSIA() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_NACL() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_QNX() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE_TVOS() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FREEBSD() 0
 #elif defined(__APPLE__)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_ANDROID() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE() 1
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX_BUT_NOT_QNX() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WIN() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WASM() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FUCHSIA() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_NACL() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_QNX() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FREEBSD() 0
 // Include TARGET_OS_IPHONE when on __APPLE__ systems.
 #include <TargetConditionals.h>
 #if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_MAC() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_IOS() 1
+#if defined(TARGET_OS_TV) && TARGET_OS_TV
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE_TVOS() 1
+#else
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE_TVOS() 0
+#endif
 #else
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_MAC() 1
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_IOS() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE_TVOS() 0
 #endif
 #elif defined(__linux__)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_ANDROID() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX() 1
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX_BUT_NOT_QNX() 1
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WIN() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_MAC() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_IOS() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WASM() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FUCHSIA() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_NACL() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_QNX() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE_TVOS() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FREEBSD() 0
+#elif defined(__QNXNTO__)
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_ANDROID() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX() 1
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX_BUT_NOT_QNX() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WIN() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_MAC() 0
@@ -132,9 +210,13 @@
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WASM() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FUCHSIA() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_NACL() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_QNX() 1
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE_TVOS() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FREEBSD() 0
 #elif defined(_WIN32)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_ANDROID() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX_BUT_NOT_QNX() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WIN() 1
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_MAC() 0
@@ -142,9 +224,13 @@
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WASM() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FUCHSIA() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_NACL() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_QNX() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE_TVOS() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FREEBSD() 0
 #elif defined(__EMSCRIPTEN__)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_ANDROID() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX_BUT_NOT_QNX() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WIN() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_MAC() 0
@@ -152,19 +238,27 @@
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WASM() 1
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FUCHSIA() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_NACL() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_QNX() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE_TVOS() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FREEBSD() 0
 #elif defined(__Fuchsia__)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_ANDROID() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_MAC() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_IOS() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX_BUT_NOT_QNX() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WIN() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WASM() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FUCHSIA() 1
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_NACL() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_QNX() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE_TVOS() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FREEBSD() 0
 #elif defined(__native_client__)
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_ANDROID() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX_BUT_NOT_QNX() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WIN() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_MAC() 0
@@ -172,6 +266,23 @@
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WASM() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FUCHSIA() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_NACL() 1
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_QNX() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE_TVOS() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FREEBSD() 0
+#elif defined(__FreeBSD__)
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_ANDROID() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX_BUT_NOT_QNX() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WIN() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_MAC() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_IOS() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WASM() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FUCHSIA() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_NACL() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_QNX() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE_TVOS() 0
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FREEBSD() 1
 #else
 #error OS not supported (see build_config.h)
 #endif
@@ -180,7 +291,7 @@
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_CLANG() 1
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_GCC() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_MSVC() 0
-#elif defined(__GNUC__) // Careful: Clang also defines this!
+#elif defined(__GNUC__)  // Careful: Clang also defines this!
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_CLANG() 0
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_GCC() 1
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_MSVC() 0
@@ -200,6 +311,29 @@
 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ANDROID_USERDEBUG_BUILD() 0
 #endif
 
+// Processor architecture detection.  For more info on what's defined, see:
+//   http://msdn.microsoft.com/en-us/library/b0084kay.aspx
+//   http://www.agner.org/optimize/calling_conventions.pdf
+//   or with gcc, run: "echo | gcc -E -dM -"
+#if defined(__aarch64__) || defined(_M_ARM64)
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ARCH_CPU_ARM64() 1
+#else
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ARCH_CPU_ARM64() 0
+#endif
+
+#if defined(__x86_64__) || defined(_M_X64)
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ARCH_CPU_X86_64() 1
+#else
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ARCH_CPU_X86_64() 0
+#endif
+
+// TODO(primiano): add a preprocessor macro to detect RISC-V on MSVC.
+#if defined(__riscv)
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ARCH_CPU_RISCV() 1
+#else
+#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ARCH_CPU_RISCV() 0
+#endif
+
 // perfetto_build_flags.h contains the tweakable build flags defined via GN.
 // - In GN builds (e.g., standalone, chromium, v8) this file is generated at
 //   build time via the gen_rule //gn/gen_buildflags.
@@ -238,11 +372,11 @@
 #include <stddef.h>
 
 #if defined(__GNUC__) || defined(__clang__)
-#define PERFETTO_LIKELY(_x) __builtin_expect(!!(_x), 1)
-#define PERFETTO_UNLIKELY(_x) __builtin_expect(!!(_x), 0)
+#define PERFETTO_LIKELY(...) __builtin_expect(!!(__VA_ARGS__), 1)
+#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0)
 #else
-#define PERFETTO_LIKELY(_x) (_x)
-#define PERFETTO_UNLIKELY(_x) (_x)
+#define PERFETTO_LIKELY(...) (__VA_ARGS__)
+#define PERFETTO_UNLIKELY(...) (__VA_ARGS__)
 #endif
 
 // PERFETTO_STATIC_CAST(TYPE, VAL): avoids the -Wold-style-cast warning when
@@ -269,6 +403,22 @@
 #define PERFETTO_NULL NULL
 #endif
 
+#if defined(__clang__)
+#define PERFETTO_ALWAYS_INLINE __attribute__((__always_inline__))
+#define PERFETTO_NO_INLINE __attribute__((__noinline__))
+#else
+// GCC is too pedantic and often fails with the error:
+// "always_inline function might not be inlinable"
+#define PERFETTO_ALWAYS_INLINE
+#define PERFETTO_NO_INLINE
+#endif
+
+#if defined(__has_builtin)
+#define PERFETTO_HAS_BUILTIN(x) __has_builtin(x)
+#else
+#define PERFETTO_HAS_BUILTIN(x) 0
+#endif
+
 #endif  // INCLUDE_PERFETTO_PUBLIC_COMPILER_H_
 /*
  * Copyright (C) 2019 The Android Open Source Project
@@ -289,20 +439,22 @@
 #ifndef INCLUDE_PERFETTO_BASE_COMPILER_H_
 #define INCLUDE_PERFETTO_BASE_COMPILER_H_
 
-#include <stddef.h>
+#include <cstddef>
 #include <type_traits>
+#include <variant>
 
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
 // gen_amalgamated expanded: #include "perfetto/public/compiler.h"
 
-#if __cplusplus >= 201703
-#define PERFETTO_IS_AT_LEAST_CPP17() 1
-#elif defined(_MSVC_LANG) && _MSVC_LANG >= 201703L
-// Without additional flags, MSVC is not standard compliant and keeps
-// __cplusplus stuck at an old value, even with C++17
-#define PERFETTO_IS_AT_LEAST_CPP17() 1
+#if defined(_MSC_VER)
+#define PERFETTO_ASSUME(x) __assume(x)
+#elif defined(__clang__)
+#define PERFETTO_ASSUME(x) __builtin_assume(x)
 #else
-#define PERFETTO_IS_AT_LEAST_CPP17() 0
+#define PERFETTO_ASSUME(x)     \
+  do {                         \
+    if (!(x))                  \
+      __builtin_unreachable(); \
+  } while (0)
 #endif
 
 // __has_attribute is supported only by clang and recent versions of GCC.
@@ -325,16 +477,6 @@
 #define PERFETTO_UNUSED
 #endif
 
-#if defined(__clang__)
-#define PERFETTO_ALWAYS_INLINE __attribute__((__always_inline__))
-#define PERFETTO_NO_INLINE __attribute__((__noinline__))
-#else
-// GCC is too pedantic and often fails with the error:
-// "always_inline function might not be inlinable"
-#define PERFETTO_ALWAYS_INLINE
-#define PERFETTO_NO_INLINE
-#endif
-
 #if defined(__GNUC__) || defined(__clang__)
 #define PERFETTO_NORETURN __attribute__((__noreturn__))
 #else
@@ -357,16 +499,6 @@
 #define PERFETTO_PRINTF_FORMAT(x, y)
 #endif
 
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_IOS)
-// TODO(b/158814068): For iOS builds, thread_local is only supported since iOS
-// 8. We'd have to use pthread for thread local data instead here. For now, just
-// define it to nothing since we don't support running perfetto or the client
-// lib on iOS right now.
-#define PERFETTO_THREAD_LOCAL
-#else
-#define PERFETTO_THREAD_LOCAL thread_local
-#endif
-
 #if defined(__GNUC__) || defined(__clang__)
 #define PERFETTO_POPCOUNT(x) __builtin_popcountll(x)
 #else
@@ -389,6 +521,19 @@ extern "C" void __asan_unpoison_memory_region(void const volatile*, size_t);
 #define PERFETTO_ASAN_UNPOISON(addr, size)
 #endif  // __clang__
 
+// __has_feature is Clang-specific so must be gated behind a __clang__ check.
+// Using && doesn't work because the preprocessor doesn't short-circuit.
+#if defined(__clang__)
+#if __has_feature(memory_sanitizer)
+extern "C" void __msan_unpoison(void const volatile*, size_t);
+#define PERFETTO_MSAN_UNPOISON(a, s) __msan_unpoison((a), (s))
+#else
+#define PERFETTO_MSAN_UNPOISON(addr, size)
+#endif  // __has_feature(memory_sanitizer)
+#else
+#define PERFETTO_MSAN_UNPOISON(addr, size)
+#endif  // __clang__
+
 #if defined(__GNUC__) || defined(__clang__)
 #define PERFETTO_IS_LITTLE_ENDIAN() __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
 #else
@@ -410,13 +555,11 @@ extern "C" void __asan_unpoison_memory_region(void const volatile*, size_t);
 #define PERFETTO_EXPORT_ENTRYPOINT
 #endif
 
-// Disables thread safety analysis for functions where the compiler can't
-// accurate figure out which locks are being held.
+// Disables undefined behavior analysis for a function.
 #if defined(__clang__)
-#define PERFETTO_NO_THREAD_SAFETY_ANALYSIS \
-  __attribute__((no_thread_safety_analysis))
+#define PERFETTO_NO_SANITIZE_UNDEFINED __attribute__((no_sanitize("undefined")))
 #else
-#define PERFETTO_NO_THREAD_SAFETY_ANALYSIS
+#define PERFETTO_NO_SANITIZE_UNDEFINED
 #endif
 
 // Avoid calling the exit-time destructor on an object with static lifetime.
@@ -429,20 +572,26 @@ extern "C" void __asan_unpoison_memory_region(void const volatile*, size_t);
 #endif
 
 // Macro for telling -Wimplicit-fallthrough that a fallthrough is intentional.
-#if defined(__clang__)
-#define PERFETTO_FALLTHROUGH [[clang::fallthrough]]
+#define PERFETTO_FALLTHROUGH [[fallthrough]]
+
+// Depending on the version of the compiler, __has_builtin can be provided or
+// not.
+#if defined(__has_builtin)
+#if __has_builtin(__builtin_stack_address)
+#define PERFETTO_HAS_BUILTIN_STACK_ADDRESS() 1
 #else
-#define PERFETTO_FALLTHROUGH
+#define PERFETTO_HAS_BUILTIN_STACK_ADDRESS() 0
+#endif
+#else
+#define PERFETTO_HAS_BUILTIN_STACK_ADDRESS() 0
 #endif
 
-namespace perfetto {
-namespace base {
+namespace perfetto::base {
 
 template <typename... T>
 inline void ignore_result(const T&...) {}
 
-}  // namespace base
-}  // namespace perfetto
+}  // namespace perfetto::base
 
 #endif  // INCLUDE_PERFETTO_BASE_COMPILER_H_
 // gen_amalgamated begin header: include/perfetto/base/export.h
@@ -563,8 +712,18 @@ inline void ignore_result(const T&...) {}
 // gen_amalgamated expanded: #include "perfetto/base/export.h"
 
 #if defined(__GNUC__) || defined(__clang__)
+#if defined(__clang__)
+#pragma clang diagnostic push
+// Fix 'error: #pragma system_header ignored in main file' for clang in Google3.
+#pragma clang diagnostic ignored "-Wpragma-system-header-outside-header"
+#endif
+
 // Ignore GCC warning about a missing argument for a variadic macro parameter.
 #pragma GCC system_header
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
 #endif
 
 #if PERFETTO_BUILDFLAG(PERFETTO_FORCE_DCHECK_ON)
@@ -627,16 +786,16 @@ constexpr const char* StrEnd(const char* s) {
   return *s ? StrEnd(s + 1) : s;
 }
 
-constexpr const char* BasenameRecursive(const char* s,
-                                        const char* begin,
-                                        const char* end) {
+constexpr const char* LoggingBasenameRecursive(const char* s,
+                                               const char* begin,
+                                               const char* end) {
   return (*s == '/' && s < end)
              ? (s + 1)
-             : ((s > begin) ? BasenameRecursive(s - 1, begin, end) : s);
+             : ((s > begin) ? LoggingBasenameRecursive(s - 1, begin, end) : s);
 }
 
-constexpr const char* Basename(const char* str) {
-  return BasenameRecursive(StrEnd(str), str, StrEnd(str));
+constexpr const char* LoggingBasename(const char* str) {
+  return LoggingBasenameRecursive(StrEnd(str), str, StrEnd(str));
 }
 
 enum LogLev { kLogDebug = 0, kLogInfo, kLogImportant, kLogError };
@@ -679,18 +838,19 @@ inline void MaybeSerializeLastLogsForCrashReporting() {}
 #endif
 
 #if defined(PERFETTO_ANDROID_ASYNC_SAFE_LOG)
-#define PERFETTO_XLOG(level, fmt, ...)                                        \
-  do {                                                                        \
-    async_safe_format_log((ANDROID_LOG_DEBUG + level), "perfetto",            \
-                          "%s:%d " fmt, ::perfetto::base::Basename(__FILE__), \
-                          __LINE__, ##__VA_ARGS__);                           \
+#define PERFETTO_XLOG(level, fmt, ...)                                         \
+  do {                                                                         \
+    async_safe_format_log(                                                     \
+        (ANDROID_LOG_DEBUG + level), "perfetto", "%s:%d " fmt,                 \
+        ::perfetto::base::LoggingBasename(__FILE__), __LINE__, ##__VA_ARGS__); \
   } while (0)
 #elif defined(PERFETTO_DISABLE_LOG)
-#define PERFETTO_XLOG(level, fmt, ...) ::perfetto::base::ignore_result(level, \
-                                fmt, ##__VA_ARGS__)
+#define PERFETTO_XLOG(level, fmt, ...) \
+  ::perfetto::base::ignore_result(level, fmt, ##__VA_ARGS__)
 #else
 #define PERFETTO_XLOG(level, fmt, ...)                                      \
-  ::perfetto::base::LogMessage(level, ::perfetto::base::Basename(__FILE__), \
+  ::perfetto::base::LogMessage(level,                                       \
+                               ::perfetto::base::LoggingBasename(__FILE__), \
                                __LINE__, fmt, ##__VA_ARGS__)
 #endif
 
@@ -803,9 +963,11 @@ inline void MaybeSerializeLastLogsForCrashReporting() {}
 #ifndef INCLUDE_PERFETTO_BASE_TIME_H_
 #define INCLUDE_PERFETTO_BASE_TIME_H_
 
+#include <stdint.h>
 #include <time.h>
 
 #include <chrono>
+#include <optional>
 #include <string>
 
 // gen_amalgamated expanded: #include "perfetto/base/build_config.h"
@@ -822,6 +984,12 @@ inline void MaybeSerializeLastLogsForCrashReporting() {}
 #include <emscripten/emscripten.h>
 #endif
 
+#if PERFETTO_BUILDFLAG(PERFETTO_ARCH_CPU_X86_64)
+#if PERFETTO_BUILDFLAG(PERFETTO_COMPILER_MSVC)
+#include <intrin.h>
+#endif
+#endif
+
 namespace perfetto {
 namespace base {
 
@@ -834,6 +1002,7 @@ inline TimeNanos FromPosixTimespec(const struct timespec& ts) {
 }
 
 void SleepMicroseconds(unsigned interval_us);
+void InitializeTime();
 
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
 
@@ -851,14 +1020,39 @@ inline TimeNanos GetBootTimeNs() {
 #elif PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
 
 inline TimeNanos GetWallTimeNs() {
-  auto init_time_factor = []() -> uint64_t {
+  auto init_timebase_info = []() -> mach_timebase_info_data_t {
     mach_timebase_info_data_t timebase_info;
     mach_timebase_info(&timebase_info);
-    return timebase_info.numer / timebase_info.denom;
+    return timebase_info;
   };
 
-  static uint64_t monotonic_timebase_factor = init_time_factor();
-  return TimeNanos(mach_absolute_time() * monotonic_timebase_factor);
+  static mach_timebase_info_data_t timebase_info = init_timebase_info();
+  uint64_t mach_time = mach_absolute_time();
+
+  // Take the fast path when the conversion is 1:1. The result will for sure fit
+  // into an int_64 because we're going from nanoseconds to microseconds.
+  if (timebase_info.numer == timebase_info.denom) {
+    return TimeNanos(mach_time);
+  }
+
+  // Nanoseconds is mach_time * timebase.numer // timebase.denom. Divide first
+  // to reduce the chance of overflow. Also stash the remainder right now,
+  // a likely byproduct of the division.
+  uint64_t nanoseconds = mach_time / timebase_info.denom;
+  const uint64_t mach_time_remainder = mach_time % timebase_info.denom;
+
+  // Now multiply, keeping an eye out for overflow.
+  PERFETTO_CHECK(!__builtin_umulll_overflow(nanoseconds, timebase_info.numer,
+                                            &nanoseconds));
+
+  // By dividing first we lose precision. Regain it by adding back the
+  // nanoseconds from the remainder, with an eye out for overflow.
+  uint64_t least_significant_nanoseconds =
+      (mach_time_remainder * timebase_info.numer) / timebase_info.denom;
+  PERFETTO_CHECK(!__builtin_uaddll_overflow(
+      nanoseconds, least_significant_nanoseconds, &nanoseconds));
+
+  return TimeNanos(nanoseconds);
 }
 
 inline TimeNanos GetWallTimeRawNs() {
@@ -870,6 +1064,9 @@ inline TimeNanos GetBootTimeNs() {
   return GetWallTimeNs();
 }
 
+// Before MacOS 10.12 clock_gettime() was not implemented.
+#if (defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && \
+     __MAC_OS_X_VERSION_MIN_REQUIRED < 101200)
 inline TimeNanos GetThreadCPUTimeNs() {
   mach_port_t this_thread = mach_thread_self();
   mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
@@ -888,6 +1085,13 @@ inline TimeNanos GetThreadCPUTimeNs() {
                    info.system_time.seconds * 1000000000LL +
                    info.system_time.microseconds * 1000LL);
 }
+#else
+inline TimeNanos GetThreadCPUTimeNs() {
+  struct timespec ts = {};
+  PERFETTO_CHECK(clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts) == 0);
+  return FromPosixTimespec(ts);
+}
+#endif
 
 #elif PERFETTO_BUILDFLAG(PERFETTO_OS_WASM)
 
@@ -930,6 +1134,33 @@ inline TimeNanos GetBootTimeNs() {
   return TimeNanos(0);
 }
 
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_QNX)
+
+constexpr clockid_t kWallTimeClockSource = CLOCK_MONOTONIC;
+
+inline TimeNanos GetTimeInternalNs(clockid_t clk_id) {
+  struct timespec ts = {};
+  PERFETTO_CHECK(clock_gettime(clk_id, &ts) == 0);
+  return FromPosixTimespec(ts);
+}
+
+inline TimeNanos GetWallTimeNs() {
+  return GetTimeInternalNs(kWallTimeClockSource);
+}
+
+inline TimeNanos GetWallTimeRawNs() {
+  return GetTimeInternalNs(CLOCK_MONOTONIC);
+}
+
+inline TimeNanos GetThreadCPUTimeNs() {
+  return GetTimeInternalNs(CLOCK_THREAD_CPUTIME_ID);
+}
+
+// TODO: Clock that counts time during suspend is not implemented on QNX.
+inline TimeNanos GetBootTimeNs() {
+  return GetWallTimeNs();
+}
+
 #else  // posix
 
 constexpr clockid_t kWallTimeClockSource = CLOCK_MONOTONIC;
@@ -957,7 +1188,14 @@ inline TimeNanos GetWallTimeNs() {
 }
 
 inline TimeNanos GetWallTimeRawNs() {
+#if (PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD))
+  // Note: CLOCK_MONOTONIC_RAW is a Linux extension.
+  // FreeBSD doesn't implement it and its CLOCK_MONOTONIC_FAST
+  // doesnt implement the same semantics as CLOCK_MONOTONIC_RAW.
+  return GetTimeInternalNs(CLOCK_MONOTONIC);
+#else
   return GetTimeInternalNs(CLOCK_MONOTONIC_RAW);
+#endif
 }
 
 inline TimeNanos GetThreadCPUTimeNs() {
@@ -982,7 +1220,7 @@ inline TimeSeconds GetWallTimeS() {
 }
 
 inline struct timespec ToPosixTimespec(TimeMillis time) {
-  struct timespec ts {};
+  struct timespec ts{};
   const long time_s = static_cast<long>(time.count() / 1000);
   ts.tv_sec = time_s;
   ts.tv_nsec = (static_cast<long>(time.count()) - time_s * 1000L) * 1000000L;
@@ -1012,7 +1250,7 @@ inline int64_t MkTime(int year, int month, int day, int h, int m, int s) {
   PERFETTO_DCHECK(year >= 1900);
   PERFETTO_DCHECK(month > 0 && month <= 12);
   PERFETTO_DCHECK(day > 0 && day <= 31);
-  struct tm tms {};
+  struct tm tms{};
   tms.tm_year = year - 1900;
   tms.tm_mon = month - 1;
   tms.tm_mday = day;
@@ -1022,6 +1260,22 @@ inline int64_t MkTime(int year, int month, int day, int h, int m, int s) {
   return TimeGm(&tms);
 }
 
+#if PERFETTO_BUILDFLAG(PERFETTO_ARCH_CPU_X86_64)
+inline uint64_t Rdtsc() {
+#if PERFETTO_BUILDFLAG(PERFETTO_COMPILER_MSVC)
+  return static_cast<uint64_t>(__rdtsc());
+#else
+  // Use inline asm for clang and gcc: rust ffi bindgen crashes in using
+  // intrinsics on ChromeOS.
+  uint64_t low, high;
+  __asm__ volatile("rdtsc" : "=a"(low), "=d"(high));
+  return (high << 32) | low;
+#endif
+}
+#endif
+
+std::optional<int32_t> GetTimezoneOffsetMins();
+
 }  // namespace base
 }  // namespace perfetto
 
@@ -1055,7 +1309,8 @@ enum class BufferExhaustedPolicy {
   // available and wait for the tracing service to free one. Note that this
   // requires that messages the arbiter sends to the tracing service (from any
   // TraceWriter thread) will be received by it, even if all TraceWriter threads
-  // are stalled.
+  // are stalled. If no free SMB chunk becomes available after a few seconds,
+  // the process will be aborted.
   kStall,
 
   // SharedMemoryArbiterImpl::GetNewChunk() will return an invalid chunk if no
@@ -1064,8 +1319,16 @@ enum class BufferExhaustedPolicy {
   // succeeds again.
   kDrop,
 
-  // TODO(eseckler): Switch to kDrop by default and change the Android code to
-  // explicitly request kStall instead.
+  // SharedMemoryArbiterImpl::GetNewChunk() will stall if no free SMB chunk is
+  // available and wait for the tracing service to free one. Note that this
+  // requires that messages the arbiter sends to the tracing service (from any
+  // TraceWriter thread) will be received by it, even if all TraceWriter threads
+  // are stalled. If no free SMB chunk becomes available after a few seconds,
+  // SharedMemoryArbiterImpl::GetNewChunk() will return an invalid chunk and
+  // data will be lost.
+  kStallThenDrop,
+
+  // Deprecated alias. Do not use.
   kDefault = kStall
 };
 
@@ -1115,6 +1378,184 @@ struct ContiguousMemoryRange {
 
 #endif  // INCLUDE_PERFETTO_PROTOZERO_CONTIGUOUS_MEMORY_RANGE_H_
 // gen_amalgamated begin header: include/perfetto/protozero/proto_utils.h
+// gen_amalgamated begin header: include/perfetto/public/pb_utils.h
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_PUBLIC_PB_UTILS_H_
+#define INCLUDE_PERFETTO_PUBLIC_PB_UTILS_H_
+
+#include <assert.h>
+#include <stdint.h>
+#include <string.h>
+
+// gen_amalgamated expanded: #include "perfetto/public/compiler.h"
+
+// Type of fields that can be found in a protobuf serialized message.
+enum PerfettoPbWireType {
+  PERFETTO_PB_WIRE_TYPE_VARINT = 0,
+  PERFETTO_PB_WIRE_TYPE_FIXED64 = 1,
+  PERFETTO_PB_WIRE_TYPE_DELIMITED = 2,
+  PERFETTO_PB_WIRE_TYPE_FIXED32 = 5,
+};
+
+// Creates a field tag, which encodes the field type and the field id.
+static inline uint32_t PerfettoPbMakeTag(int32_t field_id,
+                                         enum PerfettoPbWireType wire_type) {
+  return ((PERFETTO_STATIC_CAST(uint32_t, field_id)) << 3) |
+         PERFETTO_STATIC_CAST(uint32_t, wire_type);
+}
+
+enum {
+  // Maximum bytes size of a 64-bit integer encoded as a VarInt.
+  PERFETTO_PB_VARINT_MAX_SIZE_64 = 10,
+  // Maximum bytes size of a 32-bit integer encoded as a VarInt.
+  PERFETTO_PB_VARINT_MAX_SIZE_32 = 5,
+};
+
+// Encodes `value` as a VarInt into `*dst`.
+//
+// `dst` must point into a buffer big enough to represent `value`:
+// PERFETTO_PB_VARINT_MAX_SIZE_* can help.
+static inline uint8_t* PerfettoPbWriteVarInt(uint64_t value, uint8_t* dst) {
+  uint8_t byte;
+  while (value >= 0x80) {
+    byte = (value & 0x7f) | 0x80;
+    *dst++ = byte;
+    value >>= 7;
+  }
+  byte = value & 0x7f;
+  *dst++ = byte;
+
+  return dst;
+}
+
+// Encodes `value` as a fixed32 (little endian) into `*dst`.
+//
+// `dst` must point into a buffer with at least 4 bytes of space.
+static inline uint8_t* PerfettoPbWriteFixed32(uint32_t value, uint8_t* buf) {
+  buf[0] = PERFETTO_STATIC_CAST(uint8_t, value);
+  buf[1] = PERFETTO_STATIC_CAST(uint8_t, value >> 8);
+  buf[2] = PERFETTO_STATIC_CAST(uint8_t, value >> 16);
+  buf[3] = PERFETTO_STATIC_CAST(uint8_t, value >> 24);
+  return buf + 4;
+}
+
+// Encodes `value` as a fixed32 (little endian) into `*dst`.
+//
+// `dst` must point into a buffer with at least 8 bytes of space.
+static inline uint8_t* PerfettoPbWriteFixed64(uint64_t value, uint8_t* buf) {
+  buf[0] = PERFETTO_STATIC_CAST(uint8_t, value);
+  buf[1] = PERFETTO_STATIC_CAST(uint8_t, value >> 8);
+  buf[2] = PERFETTO_STATIC_CAST(uint8_t, value >> 16);
+  buf[3] = PERFETTO_STATIC_CAST(uint8_t, value >> 24);
+  buf[4] = PERFETTO_STATIC_CAST(uint8_t, value >> 32);
+  buf[5] = PERFETTO_STATIC_CAST(uint8_t, value >> 40);
+  buf[6] = PERFETTO_STATIC_CAST(uint8_t, value >> 48);
+  buf[7] = PERFETTO_STATIC_CAST(uint8_t, value >> 56);
+  return buf + 8;
+}
+
+// Parses a VarInt from the encoded buffer [start, end). |end| is STL-style and
+// points one byte past the end of buffer.
+// The parsed int value is stored in the output arg |value|. Returns a pointer
+// to the next unconsumed byte (so start < retval <= end) or |start| if the
+// VarInt could not be fully parsed because there was not enough space in the
+// buffer.
+static inline const uint8_t* PerfettoPbParseVarInt(const uint8_t* start,
+                                                   const uint8_t* end,
+                                                   uint64_t* out_value) {
+  const uint8_t* pos = start;
+  uint64_t value = 0;
+  for (uint32_t shift = 0; pos < end && shift < 64u; shift += 7) {
+    // Cache *pos into |cur_byte| to prevent that the compiler dereferences the
+    // pointer twice (here and in the if() below) due to char* aliasing rules.
+    uint8_t cur_byte = *pos++;
+    value |= PERFETTO_STATIC_CAST(uint64_t, cur_byte & 0x7f) << shift;
+    if ((cur_byte & 0x80) == 0) {
+      // In valid cases we get here.
+      *out_value = value;
+      return pos;
+    }
+  }
+  *out_value = 0;
+  return start;
+}
+
+static inline uint32_t PerfettoPbZigZagEncode32(int32_t value) {
+#if defined(__cplusplus) || \
+    (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L)
+  // Right-shift of negative values is implementation specific.
+  // Assert the implementation does what we expect, which is that shifting an
+  // positive int32_t by 31 gives an all 0 bitmap, and a negative int32_t gives
+  // an all 1 bitmap.
+  static_assert(
+      PERFETTO_STATIC_CAST(uint32_t, INT32_C(-1) >> 31) == ~UINT32_C(0),
+      "implementation does not support assumed rightshift");
+  static_assert(PERFETTO_STATIC_CAST(uint32_t, INT32_C(1) >> 31) == UINT32_C(0),
+                "implementation does not support assumed rightshift");
+#endif
+
+  return (PERFETTO_STATIC_CAST(uint32_t, value) << 1) ^
+         PERFETTO_STATIC_CAST(uint32_t, value >> 31);
+}
+
+static inline uint64_t PerfettoPbZigZagEncode64(int64_t value) {
+#if defined(__cplusplus) || \
+    (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L)
+  // Right-shift of negative values is implementation specific.
+  // Assert the implementation does what we expect, which is that shifting an
+  // positive int64_t by 63 gives an all 0 bitmap, and a negative int64_t gives
+  // an all 1 bitmap.
+  static_assert(
+      PERFETTO_STATIC_CAST(uint64_t, INT64_C(-1) >> 63) == ~UINT64_C(0),
+      "implementation does not support assumed rightshift");
+  static_assert(PERFETTO_STATIC_CAST(uint64_t, INT64_C(1) >> 63) == UINT64_C(0),
+                "implementation does not support assumed rightshift");
+#endif
+
+  return (PERFETTO_STATIC_CAST(uint64_t, value) << 1) ^
+         PERFETTO_STATIC_CAST(uint64_t, value >> 63);
+}
+
+static inline int32_t PerfettoPbZigZagDecode32(uint32_t value) {
+  uint32_t mask =
+      PERFETTO_STATIC_CAST(uint32_t, -PERFETTO_STATIC_CAST(int32_t, value & 1));
+  return PERFETTO_STATIC_CAST(int32_t, ((value >> 1) ^ mask));
+}
+
+static inline int64_t PerfettoPbZigZagDecode64(uint64_t value) {
+  uint64_t mask =
+      PERFETTO_STATIC_CAST(uint64_t, -PERFETTO_STATIC_CAST(int64_t, value & 1));
+  return PERFETTO_STATIC_CAST(int64_t, ((value >> 1) ^ mask));
+}
+
+static inline uint64_t PerfettoPbDoubleToFixed64(double value) {
+  uint64_t val;
+  memcpy(&val, &value, sizeof val);
+  return val;
+}
+
+static inline uint32_t PerfettoPbFloatToFixed32(float value) {
+  uint32_t val;
+  memcpy(&val, &value, sizeof val);
+  return val;
+}
+
+#endif  // INCLUDE_PERFETTO_PUBLIC_PB_UTILS_H_
 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
@@ -1140,6 +1581,7 @@ struct ContiguousMemoryRange {
 #include <type_traits>
 
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/public/pb_utils.h"
 
 // Helper macro for the constexpr functions containing
 // the switch statement: if C++14 is supported, this macro
@@ -1236,6 +1678,7 @@ inline const char* ProtoSchemaToString(ProtoSchemaType v) {
 // Maximum message size supported: 256 MiB (4 x 7-bit due to varint encoding).
 constexpr size_t kMessageLengthFieldSize = 4;
 constexpr size_t kMaxMessageLength = (1u << (kMessageLengthFieldSize * 7)) - 1;
+constexpr size_t kMaxOneByteMessageLength = (1 << 7) - 1;
 
 // Field tag is encoded as 32-bit varint (5 bytes at most).
 // Largest value of simple (not length-delimited) field is 64-bit varint
@@ -1243,6 +1686,21 @@ constexpr size_t kMaxMessageLength = (1u << (kMessageLengthFieldSize * 7)) - 1;
 constexpr size_t kMaxTagEncodedSize = 5;
 constexpr size_t kMaxSimpleFieldEncodedSize = kMaxTagEncodedSize + 10;
 
+constexpr uint8_t kFieldTypeNumBits = 3;
+
+constexpr uint64_t GetTagFieldId(uint64_t tag) {
+  // Since, the least 3 significant bits determine the field type. Skip them and
+  // return the id.
+  return (tag >> kFieldTypeNumBits);
+}
+
+constexpr uint64_t GetTagFieldType(uint64_t tag) {
+  // The least 3 significant bits determine the field type.
+  constexpr uint64_t kFieldTypeMask =
+      (1 << kFieldTypeNumBits) - 1;  // 0000 0111;
+  return (tag & kFieldTypeMask);
+}
+
 // Proto types: (int|uint|sint)(32|64), bool, enum.
 constexpr uint32_t MakeTagVarInt(uint32_t field_id) {
   return (field_id << 3) | static_cast<uint32_t>(ProtoWireType::kVarInt);
@@ -1271,7 +1729,7 @@ inline typename std::make_unsigned<T>::type ZigZagEncode(T value) {
   // Right-shift of negative values is implementation specific.
   // Assert the implementation does what we expect, which is that shifting any
   // positive value by sizeof(T) * 8 - 1 gives an all 0 bitmap, and a negative
-  // value gives and all 1 bitmap.
+  // value gives an all 1 bitmap.
   constexpr uint64_t kUnsignedZero = 0u;
   constexpr int64_t kNegativeOne = -1;
   constexpr int64_t kPositiveOne = 1;
@@ -1370,21 +1828,7 @@ void StaticAssertSingleBytePreamble() {
 inline const uint8_t* ParseVarInt(const uint8_t* start,
                                   const uint8_t* end,
                                   uint64_t* out_value) {
-  const uint8_t* pos = start;
-  uint64_t value = 0;
-  for (uint32_t shift = 0; pos < end && shift < 64u; shift += 7) {
-    // Cache *pos into |cur_byte| to prevent that the compiler dereferences the
-    // pointer twice (here and in the if() below) due to char* aliasing rules.
-    uint8_t cur_byte = *pos++;
-    value |= static_cast<uint64_t>(cur_byte & 0x7f) << shift;
-    if ((cur_byte & 0x80) == 0) {
-      // In valid cases we get here.
-      *out_value = value;
-      return pos;
-    }
-  }
-  *out_value = 0;
-  return start;
+  return PerfettoPbParseVarInt(start, end, out_value);
 }
 
 enum class RepetitionType {
@@ -1419,21 +1863,6 @@ struct FieldMetadata : public FieldMetadataBase {
   using message_type = MessageType;
 };
 
-namespace internal {
-
-// Ideally we would create variables of FieldMetadata<...> type directly,
-// but before C++17's support for constexpr inline variables arrive, we have to
-// actually use pointers to inline functions instead to avoid having to define
-// symbols in *.pbzero.cc files.
-//
-// Note: protozero bindings will generate Message::kFieldName variable and which
-// can then be passed to TRACE_EVENT macro for inline writing of typed messages.
-// The fact that the former can be passed to the latter is a part of the stable
-// API, while the particular type is not and users should not rely on it.
-template <typename T>
-using FieldMetadataHelper = T (*)(void);
-
-}  // namespace internal
 }  // namespace proto_utils
 }  // namespace protozero
 
@@ -1460,6 +1889,7 @@ using FieldMetadataHelper = T (*)(void);
 #include <stdint.h>
 
 #include <string>
+#include <string_view>
 #include <vector>
 
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
@@ -1481,7 +1911,9 @@ struct ConstChars {
   // Allow implicit conversion to perfetto's base::StringView without depending
   // on perfetto/base or viceversa.
   static constexpr bool kConvertibleToStringView = true;
-  std::string ToStdString() const { return std::string(data, size); }
+  static constexpr bool kHashable = true;
+  std::string ToStdString() const { return {data, size}; }
+  std::string_view ToStdStringView() const { return {data, size}; }
 
   const char* data;
   size_t size;
@@ -1496,7 +1928,7 @@ struct ConstChars {
 class Field {
  public:
   bool valid() const { return id_ != 0; }
-  uint16_t id() const { return id_; }
+  uint32_t id() const { return id_; }
   explicit operator bool() const { return valid(); }
 
   proto_utils::ProtoWireType type() const {
@@ -1592,11 +2024,11 @@ class Field {
 
   uint64_t raw_int_value() const { return int_value_; }
 
-  void initialize(uint16_t id,
+  void initialize(uint32_t id,
                   uint8_t type,
                   uint64_t int_value,
                   uint32_t size) {
-    id_ = id;
+    id_ = id & kMaxId;
     type_ = type;
     int_value_ = int_value;
     size_ = size;
@@ -1631,19 +2063,21 @@ class Field {
   // to |dst|. |dst| is resized accordingly.
   void SerializeAndAppendTo(std::vector<uint8_t>* dst) const;
 
+  static constexpr uint32_t kMaxId = (1 << 24) - 1;  // See id_ : 24 below.
  private:
   template <typename Container>
   void SerializeAndAppendToInternal(Container* dst) const;
 
   // Fields are deliberately not initialized to keep the class trivially
   // constructible. It makes a large perf difference for ProtoDecoder.
-
   uint64_t int_value_;  // In kLengthDelimited this contains the data() addr.
   uint32_t size_;       // Only valid when when type == kLengthDelimited.
-  uint16_t id_;         // Proto field ordinal.
-  uint8_t type_;        // proto_utils::ProtoWireType.
-};
 
+  // Note: MSVC and clang-cl require bit-fields to be of the same type, hence
+  // the `: 8` below rather than uint8_t.
+  uint32_t id_ : 24;   // Proto field ordinal.
+  uint32_t type_ : 8;  // proto_utils::ProtoWireType.
+};
 // The Field struct is used in a lot of perf-sensitive contexts.
 static_assert(sizeof(Field) == 16, "Field struct too big");
 
@@ -1712,6 +2146,10 @@ class TraceConfig;
 class TraceStats;
 class TracingServiceCapabilities;
 class TracingServiceState;
+class InitRelayRequest;
+class InitRelayResponse;
+class SyncClockRequest;
+class SyncClockResponse;
 
 }  // namespace gen
 }  // namespace protos
@@ -1726,6 +2164,10 @@ using TraceStats = ::perfetto::protos::gen::TraceStats;
 using TracingServiceCapabilities =
     ::perfetto::protos::gen::TracingServiceCapabilities;
 using TracingServiceState = ::perfetto::protos::gen::TracingServiceState;
+using InitRelayRequest = ::perfetto::protos::gen::InitRelayRequest;
+using InitRelayResponse = ::perfetto::protos::gen::InitRelayResponse;
+using SyncClockRequest = ::perfetto::protos::gen::SyncClockRequest;
+using SyncClockResponse = ::perfetto::protos::gen::SyncClockResponse;
 
 }  // namespace perfetto
 
@@ -1778,6 +2220,557 @@ constexpr size_t kMaxDataSourceInstances = 8;
 
 #endif  // INCLUDE_PERFETTO_TRACING_INTERNAL_BASIC_TYPES_H_
 // gen_amalgamated begin header: include/perfetto/tracing/internal/data_source_internal.h
+// gen_amalgamated begin header: include/perfetto/tracing/core/data_source_config.h
+// gen_amalgamated begin header: gen/protos/perfetto/config/data_source_config.gen.h
+// gen_amalgamated begin header: include/perfetto/protozero/cpp_message_obj.h
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_PROTOZERO_CPP_MESSAGE_OBJ_H_
+#define INCLUDE_PERFETTO_PROTOZERO_CPP_MESSAGE_OBJ_H_
+
+#include <stdint.h>
+
+#include <string>
+#include <vector>
+
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+
+namespace protozero {
+
+// Base class for generated .gen.h classes, which are full C++ objects that
+// support both ser and deserialization (but are not zero-copy).
+// This is only used by the "cpp" targets not the "pbzero" ones.
+class PERFETTO_EXPORT_COMPONENT CppMessageObj {
+ public:
+  virtual ~CppMessageObj();
+  virtual std::string SerializeAsString() const = 0;
+  virtual std::vector<uint8_t> SerializeAsArray() const = 0;
+  virtual bool ParseFromArray(const void*, size_t) = 0;
+
+  bool ParseFromString(const std::string& str) {
+    return ParseFromArray(str.data(), str.size());
+  }
+};
+
+}  // namespace protozero
+
+#endif  // INCLUDE_PERFETTO_PROTOZERO_CPP_MESSAGE_OBJ_H_
+// gen_amalgamated begin header: include/perfetto/protozero/copyable_ptr.h
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_PROTOZERO_COPYABLE_PTR_H_
+#define INCLUDE_PERFETTO_PROTOZERO_COPYABLE_PTR_H_
+
+#include <memory>
+#include <utility>
+
+namespace protozero {
+
+// This class is essentially a std::vector<T> of fixed size = 1.
+// It's a pointer wrapper with deep copying and deep equality comparison.
+// At all effects this wrapper behaves like the underlying T, with the exception
+// of the heap indirection.
+// Conversely to a std::unique_ptr, the pointer will be always valid, never
+// null. The problem it solves is the following: when generating C++ classes
+// from proto files, we want to keep each header hermetic (i.e. not #include
+// headers of dependent types). As such we can't directly instantiate T
+// field members but we can instead rely on pointers, so only the .cc file needs
+// to see the actual definition of T. If the generated classes were move-only we
+// could just use a unique_ptr there. But they aren't, hence this wrapper.
+// Converesely to unique_ptr, this wrapper:
+// - Default constructs the T instance in its constructor.
+// - Implements deep comparison in operator== instead of pointer comparison.
+template <typename T>
+class CopyablePtr {
+ public:
+  CopyablePtr() : ptr_(new T()) {}
+  ~CopyablePtr() = default;
+
+  // Copy operators.
+  CopyablePtr(const CopyablePtr& other) : ptr_(new T(*other.ptr_)) {}
+  CopyablePtr& operator=(const CopyablePtr& other) {
+    *ptr_ = *other.ptr_;
+    return *this;
+  }
+
+  // Move operators.
+  CopyablePtr(CopyablePtr&& other) noexcept : ptr_(std::move(other.ptr_)) {
+    other.ptr_.reset(new T());
+  }
+
+  CopyablePtr& operator=(CopyablePtr&& other) {
+    ptr_ = std::move(other.ptr_);
+    other.ptr_.reset(new T());
+    return *this;
+  }
+
+  T* get() { return ptr_.get(); }
+  const T* get() const { return ptr_.get(); }
+
+  T* operator->() { return ptr_.get(); }
+  const T* operator->() const { return ptr_.get(); }
+
+  T& operator*() { return *ptr_; }
+  const T& operator*() const { return *ptr_; }
+
+  friend bool operator==(const CopyablePtr& lhs, const CopyablePtr& rhs) {
+    return *lhs == *rhs;
+  }
+
+  friend bool operator!=(const CopyablePtr& lhs, const CopyablePtr& rhs) {
+    // In theory the underlying type might have a special operator!=
+    // implementation which is not just !(x == y). Respect that.
+    return *lhs != *rhs;
+  }
+
+ private:
+  std::unique_ptr<T> ptr_;
+};
+
+}  // namespace protozero
+
+#endif  // INCLUDE_PERFETTO_PROTOZERO_COPYABLE_PTR_H_
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_DATA_SOURCE_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_DATA_SOURCE_CONFIG_PROTO_CPP_H_
+
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+class DataSourceConfig;
+class TestConfig;
+class TestConfig_DummyFields;
+class InterceptorConfig;
+class ConsoleConfig;
+class ChromeConfig;
+class SystemInfoConfig;
+class ProtoVmConfig;
+class PriorityBoostConfig;
+enum DataSourceConfig_SessionInitiator : int;
+enum DataSourceConfig_BufferExhaustedPolicy : int;
+enum ConsoleConfig_Output : int;
+enum ChromeConfig_ClientPriority : int;
+enum PriorityBoostConfig_BoostPolicy : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+namespace protozero {
+class Message;
+}  // namespace protozero
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum DataSourceConfig_SessionInitiator : int {
+  DataSourceConfig_SessionInitiator_SESSION_INITIATOR_UNSPECIFIED = 0,
+  DataSourceConfig_SessionInitiator_SESSION_INITIATOR_TRUSTED_SYSTEM = 1,
+};
+enum DataSourceConfig_BufferExhaustedPolicy : int {
+  DataSourceConfig_BufferExhaustedPolicy_BUFFER_EXHAUSTED_UNSPECIFIED = 0,
+  DataSourceConfig_BufferExhaustedPolicy_BUFFER_EXHAUSTED_DROP = 1,
+  DataSourceConfig_BufferExhaustedPolicy_BUFFER_EXHAUSTED_STALL_THEN_ABORT = 2,
+  DataSourceConfig_BufferExhaustedPolicy_BUFFER_EXHAUSTED_STALL_THEN_DROP = 3,
+};
+
+class PERFETTO_EXPORT_COMPONENT DataSourceConfig : public ::protozero::CppMessageObj {
+ public:
+  using SessionInitiator = DataSourceConfig_SessionInitiator;
+  static constexpr auto SESSION_INITIATOR_UNSPECIFIED = DataSourceConfig_SessionInitiator_SESSION_INITIATOR_UNSPECIFIED;
+  static constexpr auto SESSION_INITIATOR_TRUSTED_SYSTEM = DataSourceConfig_SessionInitiator_SESSION_INITIATOR_TRUSTED_SYSTEM;
+  static constexpr auto SessionInitiator_MIN = DataSourceConfig_SessionInitiator_SESSION_INITIATOR_UNSPECIFIED;
+  static constexpr auto SessionInitiator_MAX = DataSourceConfig_SessionInitiator_SESSION_INITIATOR_TRUSTED_SYSTEM;
+  using BufferExhaustedPolicy = DataSourceConfig_BufferExhaustedPolicy;
+  static constexpr auto BUFFER_EXHAUSTED_UNSPECIFIED = DataSourceConfig_BufferExhaustedPolicy_BUFFER_EXHAUSTED_UNSPECIFIED;
+  static constexpr auto BUFFER_EXHAUSTED_DROP = DataSourceConfig_BufferExhaustedPolicy_BUFFER_EXHAUSTED_DROP;
+  static constexpr auto BUFFER_EXHAUSTED_STALL_THEN_ABORT = DataSourceConfig_BufferExhaustedPolicy_BUFFER_EXHAUSTED_STALL_THEN_ABORT;
+  static constexpr auto BUFFER_EXHAUSTED_STALL_THEN_DROP = DataSourceConfig_BufferExhaustedPolicy_BUFFER_EXHAUSTED_STALL_THEN_DROP;
+  static constexpr auto BufferExhaustedPolicy_MIN = DataSourceConfig_BufferExhaustedPolicy_BUFFER_EXHAUSTED_UNSPECIFIED;
+  static constexpr auto BufferExhaustedPolicy_MAX = DataSourceConfig_BufferExhaustedPolicy_BUFFER_EXHAUSTED_STALL_THEN_DROP;
+  enum FieldNumbers {
+    kNameFieldNumber = 1,
+    kTargetBufferFieldNumber = 2,
+    kTargetBufferNameFieldNumber = 11,
+    kTraceDurationMsFieldNumber = 3,
+    kPreferSuspendClockForDurationFieldNumber = 122,
+    kStopTimeoutMsFieldNumber = 7,
+    kEnableExtraGuardrailsFieldNumber = 6,
+    kSessionInitiatorFieldNumber = 8,
+    kTracingSessionIdFieldNumber = 4,
+    kBufferExhaustedPolicyFieldNumber = 9,
+    kPriorityBoostFieldNumber = 10,
+    kProtovmConfigFieldNumber = 12,
+    kFtraceConfigFieldNumber = 100,
+    kInodeFileConfigFieldNumber = 102,
+    kProcessStatsConfigFieldNumber = 103,
+    kSysStatsConfigFieldNumber = 104,
+    kHeapprofdConfigFieldNumber = 105,
+    kJavaHprofConfigFieldNumber = 110,
+    kAndroidPowerConfigFieldNumber = 106,
+    kAndroidLogConfigFieldNumber = 107,
+    kGpuCounterConfigFieldNumber = 108,
+    kAndroidGameInterventionListConfigFieldNumber = 116,
+    kPackagesListConfigFieldNumber = 109,
+    kPerfEventConfigFieldNumber = 111,
+    kVulkanMemoryConfigFieldNumber = 112,
+    kTrackEventConfigFieldNumber = 113,
+    kAndroidPolledStateConfigFieldNumber = 114,
+    kAndroidSystemPropertyConfigFieldNumber = 118,
+    kStatsdTracingConfigFieldNumber = 117,
+    kSystemInfoConfigFieldNumber = 119,
+    kFrozenFtraceConfigFieldNumber = 136,
+    kChromeConfigFieldNumber = 101,
+    kV8ConfigFieldNumber = 127,
+    kInterceptorConfigFieldNumber = 115,
+    kNetworkPacketTraceConfigFieldNumber = 120,
+    kSurfaceflingerLayersConfigFieldNumber = 121,
+    kSurfaceflingerTransactionsConfigFieldNumber = 123,
+    kAndroidSdkSyspropGuardConfigFieldNumber = 124,
+    kEtwConfigFieldNumber = 125,
+    kProtologConfigFieldNumber = 126,
+    kAndroidInputEventConfigFieldNumber = 128,
+    kPixelModemConfigFieldNumber = 129,
+    kWindowmanagerConfigFieldNumber = 130,
+    kChromiumSystemMetricsFieldNumber = 131,
+    kKernelWakelocksConfigFieldNumber = 132,
+    kGpuRenderstagesConfigFieldNumber = 133,
+    kChromiumHistogramSamplesFieldNumber = 134,
+    kAppWakelocksConfigFieldNumber = 135,
+    kCpuPerUidConfigFieldNumber = 137,
+    kUserListConfigFieldNumber = 138,
+    kInputmethodConfigFieldNumber = 139,
+    kQnxConfigFieldNumber = 150,
+    kLegacyConfigFieldNumber = 1000,
+    kForTestingFieldNumber = 1001,
+  };
+
+  DataSourceConfig();
+  ~DataSourceConfig() override;
+  DataSourceConfig(DataSourceConfig&&) noexcept;
+  DataSourceConfig& operator=(DataSourceConfig&&);
+  DataSourceConfig(const DataSourceConfig&);
+  DataSourceConfig& operator=(const DataSourceConfig&);
+  bool operator==(const DataSourceConfig&) const;
+  bool operator!=(const DataSourceConfig& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_name() const { return _has_field_[1]; }
+  const std::string& name() const { return name_; }
+  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
+
+  bool has_target_buffer() const { return _has_field_[2]; }
+  uint32_t target_buffer() const { return target_buffer_; }
+  void set_target_buffer(uint32_t value) { target_buffer_ = value; _has_field_.set(2); }
+
+  bool has_target_buffer_name() const { return _has_field_[11]; }
+  const std::string& target_buffer_name() const { return target_buffer_name_; }
+  void set_target_buffer_name(const std::string& value) { target_buffer_name_ = value; _has_field_.set(11); }
+
+  bool has_trace_duration_ms() const { return _has_field_[3]; }
+  uint32_t trace_duration_ms() const { return trace_duration_ms_; }
+  void set_trace_duration_ms(uint32_t value) { trace_duration_ms_ = value; _has_field_.set(3); }
+
+  bool has_prefer_suspend_clock_for_duration() const { return _has_field_[122]; }
+  bool prefer_suspend_clock_for_duration() const { return prefer_suspend_clock_for_duration_; }
+  void set_prefer_suspend_clock_for_duration(bool value) { prefer_suspend_clock_for_duration_ = value; _has_field_.set(122); }
+
+  bool has_stop_timeout_ms() const { return _has_field_[7]; }
+  uint32_t stop_timeout_ms() const { return stop_timeout_ms_; }
+  void set_stop_timeout_ms(uint32_t value) { stop_timeout_ms_ = value; _has_field_.set(7); }
+
+  bool has_enable_extra_guardrails() const { return _has_field_[6]; }
+  bool enable_extra_guardrails() const { return enable_extra_guardrails_; }
+  void set_enable_extra_guardrails(bool value) { enable_extra_guardrails_ = value; _has_field_.set(6); }
+
+  bool has_session_initiator() const { return _has_field_[8]; }
+  DataSourceConfig_SessionInitiator session_initiator() const { return session_initiator_; }
+  void set_session_initiator(DataSourceConfig_SessionInitiator value) { session_initiator_ = value; _has_field_.set(8); }
+
+  bool has_tracing_session_id() const { return _has_field_[4]; }
+  uint64_t tracing_session_id() const { return tracing_session_id_; }
+  void set_tracing_session_id(uint64_t value) { tracing_session_id_ = value; _has_field_.set(4); }
+
+  bool has_buffer_exhausted_policy() const { return _has_field_[9]; }
+  DataSourceConfig_BufferExhaustedPolicy buffer_exhausted_policy() const { return buffer_exhausted_policy_; }
+  void set_buffer_exhausted_policy(DataSourceConfig_BufferExhaustedPolicy value) { buffer_exhausted_policy_ = value; _has_field_.set(9); }
+
+  bool has_priority_boost() const { return _has_field_[10]; }
+  const PriorityBoostConfig& priority_boost() const { return *priority_boost_; }
+  PriorityBoostConfig* mutable_priority_boost() { _has_field_.set(10); return priority_boost_.get(); }
+
+  bool has_protovm_config() const { return _has_field_[12]; }
+  const ProtoVmConfig& protovm_config() const { return *protovm_config_; }
+  ProtoVmConfig* mutable_protovm_config() { _has_field_.set(12); return protovm_config_.get(); }
+
+  const std::string& ftrace_config_raw() const { return ftrace_config_; }
+  void set_ftrace_config_raw(const std::string& raw) { ftrace_config_ = raw; _has_field_.set(100); }
+
+  const std::string& inode_file_config_raw() const { return inode_file_config_; }
+  void set_inode_file_config_raw(const std::string& raw) { inode_file_config_ = raw; _has_field_.set(102); }
+
+  const std::string& process_stats_config_raw() const { return process_stats_config_; }
+  void set_process_stats_config_raw(const std::string& raw) { process_stats_config_ = raw; _has_field_.set(103); }
+
+  const std::string& sys_stats_config_raw() const { return sys_stats_config_; }
+  void set_sys_stats_config_raw(const std::string& raw) { sys_stats_config_ = raw; _has_field_.set(104); }
+
+  const std::string& heapprofd_config_raw() const { return heapprofd_config_; }
+  void set_heapprofd_config_raw(const std::string& raw) { heapprofd_config_ = raw; _has_field_.set(105); }
+
+  const std::string& java_hprof_config_raw() const { return java_hprof_config_; }
+  void set_java_hprof_config_raw(const std::string& raw) { java_hprof_config_ = raw; _has_field_.set(110); }
+
+  const std::string& android_power_config_raw() const { return android_power_config_; }
+  void set_android_power_config_raw(const std::string& raw) { android_power_config_ = raw; _has_field_.set(106); }
+
+  const std::string& android_log_config_raw() const { return android_log_config_; }
+  void set_android_log_config_raw(const std::string& raw) { android_log_config_ = raw; _has_field_.set(107); }
+
+  const std::string& gpu_counter_config_raw() const { return gpu_counter_config_; }
+  void set_gpu_counter_config_raw(const std::string& raw) { gpu_counter_config_ = raw; _has_field_.set(108); }
+
+  const std::string& android_game_intervention_list_config_raw() const { return android_game_intervention_list_config_; }
+  void set_android_game_intervention_list_config_raw(const std::string& raw) { android_game_intervention_list_config_ = raw; _has_field_.set(116); }
+
+  const std::string& packages_list_config_raw() const { return packages_list_config_; }
+  void set_packages_list_config_raw(const std::string& raw) { packages_list_config_ = raw; _has_field_.set(109); }
+
+  const std::string& perf_event_config_raw() const { return perf_event_config_; }
+  void set_perf_event_config_raw(const std::string& raw) { perf_event_config_ = raw; _has_field_.set(111); }
+
+  const std::string& vulkan_memory_config_raw() const { return vulkan_memory_config_; }
+  void set_vulkan_memory_config_raw(const std::string& raw) { vulkan_memory_config_ = raw; _has_field_.set(112); }
+
+  const std::string& track_event_config_raw() const { return track_event_config_; }
+  void set_track_event_config_raw(const std::string& raw) { track_event_config_ = raw; _has_field_.set(113); }
+
+  const std::string& android_polled_state_config_raw() const { return android_polled_state_config_; }
+  void set_android_polled_state_config_raw(const std::string& raw) { android_polled_state_config_ = raw; _has_field_.set(114); }
+
+  const std::string& android_system_property_config_raw() const { return android_system_property_config_; }
+  void set_android_system_property_config_raw(const std::string& raw) { android_system_property_config_ = raw; _has_field_.set(118); }
+
+  const std::string& statsd_tracing_config_raw() const { return statsd_tracing_config_; }
+  void set_statsd_tracing_config_raw(const std::string& raw) { statsd_tracing_config_ = raw; _has_field_.set(117); }
+
+  bool has_system_info_config() const { return _has_field_[119]; }
+  const SystemInfoConfig& system_info_config() const { return *system_info_config_; }
+  SystemInfoConfig* mutable_system_info_config() { _has_field_.set(119); return system_info_config_.get(); }
+
+  const std::string& frozen_ftrace_config_raw() const { return frozen_ftrace_config_; }
+  void set_frozen_ftrace_config_raw(const std::string& raw) { frozen_ftrace_config_ = raw; _has_field_.set(136); }
+
+  bool has_chrome_config() const { return _has_field_[101]; }
+  const ChromeConfig& chrome_config() const { return *chrome_config_; }
+  ChromeConfig* mutable_chrome_config() { _has_field_.set(101); return chrome_config_.get(); }
+
+  const std::string& v8_config_raw() const { return v8_config_; }
+  void set_v8_config_raw(const std::string& raw) { v8_config_ = raw; _has_field_.set(127); }
+
+  bool has_interceptor_config() const { return _has_field_[115]; }
+  const InterceptorConfig& interceptor_config() const { return *interceptor_config_; }
+  InterceptorConfig* mutable_interceptor_config() { _has_field_.set(115); return interceptor_config_.get(); }
+
+  const std::string& network_packet_trace_config_raw() const { return network_packet_trace_config_; }
+  void set_network_packet_trace_config_raw(const std::string& raw) { network_packet_trace_config_ = raw; _has_field_.set(120); }
+
+  const std::string& surfaceflinger_layers_config_raw() const { return surfaceflinger_layers_config_; }
+  void set_surfaceflinger_layers_config_raw(const std::string& raw) { surfaceflinger_layers_config_ = raw; _has_field_.set(121); }
+
+  const std::string& surfaceflinger_transactions_config_raw() const { return surfaceflinger_transactions_config_; }
+  void set_surfaceflinger_transactions_config_raw(const std::string& raw) { surfaceflinger_transactions_config_ = raw; _has_field_.set(123); }
+
+  const std::string& android_sdk_sysprop_guard_config_raw() const { return android_sdk_sysprop_guard_config_; }
+  void set_android_sdk_sysprop_guard_config_raw(const std::string& raw) { android_sdk_sysprop_guard_config_ = raw; _has_field_.set(124); }
+
+  const std::string& etw_config_raw() const { return etw_config_; }
+  void set_etw_config_raw(const std::string& raw) { etw_config_ = raw; _has_field_.set(125); }
+
+  const std::string& protolog_config_raw() const { return protolog_config_; }
+  void set_protolog_config_raw(const std::string& raw) { protolog_config_ = raw; _has_field_.set(126); }
+
+  const std::string& android_input_event_config_raw() const { return android_input_event_config_; }
+  void set_android_input_event_config_raw(const std::string& raw) { android_input_event_config_ = raw; _has_field_.set(128); }
+
+  const std::string& pixel_modem_config_raw() const { return pixel_modem_config_; }
+  void set_pixel_modem_config_raw(const std::string& raw) { pixel_modem_config_ = raw; _has_field_.set(129); }
+
+  const std::string& windowmanager_config_raw() const { return windowmanager_config_; }
+  void set_windowmanager_config_raw(const std::string& raw) { windowmanager_config_ = raw; _has_field_.set(130); }
+
+  const std::string& chromium_system_metrics_raw() const { return chromium_system_metrics_; }
+  void set_chromium_system_metrics_raw(const std::string& raw) { chromium_system_metrics_ = raw; _has_field_.set(131); }
+
+  const std::string& kernel_wakelocks_config_raw() const { return kernel_wakelocks_config_; }
+  void set_kernel_wakelocks_config_raw(const std::string& raw) { kernel_wakelocks_config_ = raw; _has_field_.set(132); }
+
+  const std::string& gpu_renderstages_config_raw() const { return gpu_renderstages_config_; }
+  void set_gpu_renderstages_config_raw(const std::string& raw) { gpu_renderstages_config_ = raw; _has_field_.set(133); }
+
+  const std::string& chromium_histogram_samples_raw() const { return chromium_histogram_samples_; }
+  void set_chromium_histogram_samples_raw(const std::string& raw) { chromium_histogram_samples_ = raw; _has_field_.set(134); }
+
+  const std::string& app_wakelocks_config_raw() const { return app_wakelocks_config_; }
+  void set_app_wakelocks_config_raw(const std::string& raw) { app_wakelocks_config_ = raw; _has_field_.set(135); }
+
+  const std::string& cpu_per_uid_config_raw() const { return cpu_per_uid_config_; }
+  void set_cpu_per_uid_config_raw(const std::string& raw) { cpu_per_uid_config_ = raw; _has_field_.set(137); }
+
+  const std::string& user_list_config_raw() const { return user_list_config_; }
+  void set_user_list_config_raw(const std::string& raw) { user_list_config_ = raw; _has_field_.set(138); }
+
+  const std::string& inputmethod_config_raw() const { return inputmethod_config_; }
+  void set_inputmethod_config_raw(const std::string& raw) { inputmethod_config_ = raw; _has_field_.set(139); }
+
+  const std::string& qnx_config_raw() const { return qnx_config_; }
+  void set_qnx_config_raw(const std::string& raw) { qnx_config_ = raw; _has_field_.set(150); }
+
+  bool has_legacy_config() const { return _has_field_[1000]; }
+  const std::string& legacy_config() const { return legacy_config_; }
+  void set_legacy_config(const std::string& value) { legacy_config_ = value; _has_field_.set(1000); }
+
+  bool has_for_testing() const { return _has_field_[1001]; }
+  const TestConfig& for_testing() const { return *for_testing_; }
+  TestConfig* mutable_for_testing() { _has_field_.set(1001); return for_testing_.get(); }
+
+ private:
+  std::string name_{};
+  uint32_t target_buffer_{};
+  std::string target_buffer_name_{};
+  uint32_t trace_duration_ms_{};
+  bool prefer_suspend_clock_for_duration_{};
+  uint32_t stop_timeout_ms_{};
+  bool enable_extra_guardrails_{};
+  DataSourceConfig_SessionInitiator session_initiator_{};
+  uint64_t tracing_session_id_{};
+  DataSourceConfig_BufferExhaustedPolicy buffer_exhausted_policy_{};
+  ::protozero::CopyablePtr<PriorityBoostConfig> priority_boost_;
+  ::protozero::CopyablePtr<ProtoVmConfig> protovm_config_;
+  std::string ftrace_config_;  // [lazy=true]
+  std::string inode_file_config_;  // [lazy=true]
+  std::string process_stats_config_;  // [lazy=true]
+  std::string sys_stats_config_;  // [lazy=true]
+  std::string heapprofd_config_;  // [lazy=true]
+  std::string java_hprof_config_;  // [lazy=true]
+  std::string android_power_config_;  // [lazy=true]
+  std::string android_log_config_;  // [lazy=true]
+  std::string gpu_counter_config_;  // [lazy=true]
+  std::string android_game_intervention_list_config_;  // [lazy=true]
+  std::string packages_list_config_;  // [lazy=true]
+  std::string perf_event_config_;  // [lazy=true]
+  std::string vulkan_memory_config_;  // [lazy=true]
+  std::string track_event_config_;  // [lazy=true]
+  std::string android_polled_state_config_;  // [lazy=true]
+  std::string android_system_property_config_;  // [lazy=true]
+  std::string statsd_tracing_config_;  // [lazy=true]
+  ::protozero::CopyablePtr<SystemInfoConfig> system_info_config_;
+  std::string frozen_ftrace_config_;  // [lazy=true]
+  ::protozero::CopyablePtr<ChromeConfig> chrome_config_;
+  std::string v8_config_;  // [lazy=true]
+  ::protozero::CopyablePtr<InterceptorConfig> interceptor_config_;
+  std::string network_packet_trace_config_;  // [lazy=true]
+  std::string surfaceflinger_layers_config_;  // [lazy=true]
+  std::string surfaceflinger_transactions_config_;  // [lazy=true]
+  std::string android_sdk_sysprop_guard_config_;  // [lazy=true]
+  std::string etw_config_;  // [lazy=true]
+  std::string protolog_config_;  // [lazy=true]
+  std::string android_input_event_config_;  // [lazy=true]
+  std::string pixel_modem_config_;  // [lazy=true]
+  std::string windowmanager_config_;  // [lazy=true]
+  std::string chromium_system_metrics_;  // [lazy=true]
+  std::string kernel_wakelocks_config_;  // [lazy=true]
+  std::string gpu_renderstages_config_;  // [lazy=true]
+  std::string chromium_histogram_samples_;  // [lazy=true]
+  std::string app_wakelocks_config_;  // [lazy=true]
+  std::string cpu_per_uid_config_;  // [lazy=true]
+  std::string user_list_config_;  // [lazy=true]
+  std::string inputmethod_config_;  // [lazy=true]
+  std::string qnx_config_;  // [lazy=true]
+  std::string legacy_config_{};
+  ::protozero::CopyablePtr<TestConfig> for_testing_;
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<1002> _has_field_{};
+};
+
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_DATA_SOURCE_CONFIG_PROTO_CPP_H_
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_TRACING_CORE_DATA_SOURCE_CONFIG_H_
+#define INCLUDE_PERFETTO_TRACING_CORE_DATA_SOURCE_CONFIG_H_
+
+// Creates the aliases in the ::perfetto namespace, doing things like:
+// using ::perfetto::Foo = ::perfetto::protos::gen::Foo.
+// See comments in forward_decls.h for the historical reasons of this
+// indirection layer.
+// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"  // IWYU pragma: export
+
+// gen_amalgamated expanded: #include "protos/perfetto/config/data_source_config.gen.h"  // IWYU pragma: export
+
+#endif  // INCLUDE_PERFETTO_TRACING_CORE_DATA_SOURCE_CONFIG_H_
 // gen_amalgamated begin header: include/perfetto/tracing/trace_writer_base.h
 // gen_amalgamated begin header: include/perfetto/protozero/message_handle.h
 // gen_amalgamated begin header: include/perfetto/protozero/message.h
@@ -1806,8 +2799,11 @@ constexpr size_t kMaxDataSourceInstances = 8;
 #include <stdint.h>
 #include <string.h>
 
+#include <algorithm>
+
 // gen_amalgamated expanded: #include "perfetto/base/compiler.h"
 // gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/contiguous_memory_range.h"
 
 namespace protozero {
@@ -1843,7 +2839,7 @@ class PERFETTO_EXPORT_COMPONENT ScatteredStreamWriter {
     // pointer is nullptr, the caller should not write anything.
     //
     // The implementation considers the patch ready to apply when the caller
-    // writes the the first byte a value that's different than 0 (the
+    // writes the first byte a value that's different than 0 (the
     // implementation periodically checks for this).
     virtual uint8_t* AnnotatePatch(uint8_t* patch_addr);
   };
@@ -1859,17 +2855,22 @@ class PERFETTO_EXPORT_COMPONENT ScatteredStreamWriter {
 
   // Assumes that the caller checked that there is enough headroom.
   // TODO(primiano): perf optimization, this is a tracing hot path. The
-  // compiler can make strong optimization on memcpy if the size arg is a
+  // compiler can make strong optimization on std::copy if the size arg is a
   // constexpr. Make a templated variant of this for fixed-size writes.
   // TODO(primiano): restrict / noalias might also help.
   inline void WriteBytesUnsafe(const uint8_t* src, size_t size) {
     uint8_t* const end = write_ptr_ + size;
     assert(end <= cur_range_.end);
-    memcpy(write_ptr_, src, size);
+    std::copy(src, src + size, write_ptr_);
     write_ptr_ = end;
   }
 
-  inline void WriteBytes(const uint8_t* src, size_t size) {
+  inline void WriteBytes(const uint8_t* src,
+                         size_t size) PERFETTO_NO_SANITIZE_UNDEFINED {
+    // If the stream writer hasn't been initialized, constructing the end
+    // pointer below invokes undefined behavior because `write_ptr_` is null.
+    // Since this function is on the hot path, we suppress the warning instead
+    // of adding a conditional branch.
     uint8_t* const end = write_ptr_ + size;
     if (PERFETTO_LIKELY(end <= cur_range_.end))
       return WriteBytesUnsafe(src, size);
@@ -1893,6 +2894,20 @@ class PERFETTO_EXPORT_COMPONENT ScatteredStreamWriter {
     return begin;
   }
 
+  // Shifts the previously written `size` bytes backwards in memory by `offset`
+  // bytes, moving the write pointer back accordingly. The shifted result must
+  // still be fully contained by the current range.
+  void Rewind(size_t size, size_t offset) {
+    uint8_t* src = write_ptr_ - size;
+    uint8_t* dst = src - offset;
+    PERFETTO_DCHECK(src >= cur_range_.begin);
+    PERFETTO_DCHECK(src + size <= cur_range_.end);
+    PERFETTO_DCHECK(dst >= cur_range_.begin);
+    PERFETTO_DCHECK(dst + size <= cur_range_.end);
+    memmove(dst, src, size);
+    write_ptr_ -= offset;
+  }
+
   // Resets the buffer boundaries and the write pointer to the given |range|.
   // Subsequent WriteByte(s) will write into |range|.
   void Reset(ContiguousMemoryRange range);
@@ -2006,24 +3021,25 @@ class PERFETTO_EXPORT_COMPONENT Message {
   // all nested messages) and seals the message. Returns the size of the message
   // (and all nested sub-messages), without taking into account any chunking.
   // Finalize is idempotent and can be called several times w/o side effects.
+  // Short messages may be compacted in memory into the size field, since their
+  // size can be represented with fewer than
+  // proto_utils::kMessageLengthFieldSize bytes.
   uint32_t Finalize();
 
   // Optional. If is_valid() == true, the corresponding memory region (its
   // length == proto_utils::kMessageLengthFieldSize) is backfilled with the size
-  // of this message (minus |size_already_written| below). This is the mechanism
-  // used by messages to backfill their corresponding size field in the parent
-  // message.
+  // of this message. This is the mechanism used by messages to backfill their
+  // corresponding size field in the parent message. In most cases this is only
+  // used for nested messages and the ScatteredStreamWriter::Delegate (e.g.
+  // TraceWriterImpl), takes case of the outer message.
   uint8_t* size_field() const { return size_field_; }
   void set_size_field(uint8_t* size_field) { size_field_ = size_field; }
 
-  // This is to deal with case of backfilling the size of a root (non-nested)
-  // message which is split into multiple chunks. Upon finalization only the
-  // partial size that lies in the last chunk has to be backfilled.
-  void inc_size_already_written(uint32_t sz) { size_already_written_ += sz; }
-
   Message* nested_message() { return nested_message_; }
 
-  bool is_finalized() const { return finalized_; }
+  bool is_finalized() const {
+    return message_state_ != MessageState::kNotFinalized;
+  }
 
 #if PERFETTO_DCHECK_IS_ON()
   void set_handle(MessageHandleBase* handle) { handle_ = handle; }
@@ -2122,6 +3138,8 @@ class PERFETTO_EXPORT_COMPONENT Message {
   // The caller needs to guarantee that the appended data is properly
   // proto-encoded and each field has a proto preamble.
   void AppendRawProtoBytes(const void* data, size_t size) {
+    if (nested_message_)
+      EndNestedMessage();
     const uint8_t* src = reinterpret_cast<const uint8_t*>(data);
     WriteToStream(src, src + size);
   }
@@ -2136,7 +3154,7 @@ class PERFETTO_EXPORT_COMPONENT Message {
   void EndNestedMessage();
 
   void WriteToStream(const uint8_t* src_begin, const uint8_t* src_end) {
-    PERFETTO_DCHECK(!finalized_);
+    PERFETTO_DCHECK(!is_finalized());
     PERFETTO_DCHECK(src_begin <= src_end);
     const uint32_t size = static_cast<uint32_t>(src_end - src_begin);
     stream_writer_->WriteBytes(src_begin, size);
@@ -2170,12 +3188,19 @@ class PERFETTO_EXPORT_COMPONENT Message {
   // Keeps track of the size of the current message.
   uint32_t size_;
 
-  // See comment for inc_size_already_written().
-  uint32_t size_already_written_;
+  enum class MessageState : uint8_t {
+    // Message is still being written to.
+    kNotFinalized,
+    // Finalized, no more changes to the message are allowed. This is to DCHECK
+    // attempts of writing to a message which has been Finalize()-d.
+    kFinalized,
+    // Finalized, and additionally the message data has been partially or fully
+    // compacted into the last 3 bytes of `size_field_`. See the comment in
+    // Finalize().
+    kFinalizedWithCompaction,
+  };
 
-  // When true, no more changes to the message are allowed. This is to DCHECK
-  // attempts of writing to a message which has been Finalize()-d.
-  bool finalized_;
+  MessageState message_state_;
 
 #if PERFETTO_DCHECK_IS_ON()
   // Current generation of message. Incremented on Reset.
@@ -2218,6 +3243,12 @@ namespace protozero {
 
 class Message;
 
+class PERFETTO_EXPORT_COMPONENT MessageFinalizationListener {
+ public:
+  virtual ~MessageFinalizationListener();
+  virtual void OnMessageFinalized(Message* message) = 0;
+};
+
 // MessageHandle allows to decouple the lifetime of a proto message
 // from the underlying storage. It gives the following guarantees:
 // - The underlying message is finalized (if still alive) if the handle goes
@@ -2231,11 +3262,30 @@ class Message;
 
 class PERFETTO_EXPORT_COMPONENT MessageHandleBase {
  public:
-  ~MessageHandleBase();
+  ~MessageHandleBase() {
+    if (message_) {
+#if PERFETTO_DCHECK_IS_ON()
+      PERFETTO_DCHECK(generation_ == message_->generation_);
+#endif
+      FinalizeMessage();
+    }
+  }
 
   // Move-only type.
-  MessageHandleBase(MessageHandleBase&&) noexcept;
-  MessageHandleBase& operator=(MessageHandleBase&&);
+  MessageHandleBase(MessageHandleBase&& other) noexcept {
+    Move(std::move(other));
+  }
+
+  MessageHandleBase& operator=(MessageHandleBase&& other) noexcept {
+    // If the current handle was pointing to a message and is being reset to a
+    // new one, finalize the old message. However, if the other message is the
+    // same as the one we point to, don't finalize.
+    if (message_ && message_ != other.message_)
+      FinalizeMessage();
+    Move(std::move(other));
+    return *this;
+  }
+
   explicit operator bool() const {
 #if PERFETTO_DCHECK_IS_ON()
     PERFETTO_DCHECK(!message_ || generation_ == message_->generation_);
@@ -2243,6 +3293,10 @@ class PERFETTO_EXPORT_COMPONENT MessageHandleBase {
     return !!message_;
   }
 
+  void set_finalization_listener(MessageFinalizationListener* listener) {
+    listener_ = listener;
+  }
+
   // Returns a (non-owned, it should not be deleted) pointer to the
   // ScatteredStreamWriter used to write the message data. The Message becomes
   // unusable after this point.
@@ -2254,11 +3308,19 @@ class PERFETTO_EXPORT_COMPONENT MessageHandleBase {
     message_->set_handle(nullptr);
 #endif
     message_ = nullptr;
+    listener_ = nullptr;
     return stream_writer;
   }
 
  protected:
-  explicit MessageHandleBase(Message* = nullptr);
+  explicit MessageHandleBase(Message* message = nullptr) : message_(message) {
+#if PERFETTO_DCHECK_IS_ON()
+    generation_ = message_ ? message->generation_ : 0;
+    if (message_)
+      message_->set_handle(this);
+#endif
+  }
+
   Message* operator->() const {
 #if PERFETTO_DCHECK_IS_ON()
     PERFETTO_DCHECK(!message_ || generation_ == message_->generation_);
@@ -2276,13 +3338,34 @@ class PERFETTO_EXPORT_COMPONENT MessageHandleBase {
     // This is called by Message::Finalize().
     PERFETTO_DCHECK(message_->is_finalized());
     message_ = nullptr;
+    listener_ = nullptr;
   }
 
-  void Move(MessageHandleBase&&);
+  void Move(MessageHandleBase&& other) {
+    message_ = other.message_;
+    other.message_ = nullptr;
+    listener_ = other.listener_;
+    other.listener_ = nullptr;
+#if PERFETTO_DCHECK_IS_ON()
+    if (message_) {
+      generation_ = message_->generation_;
+      message_->set_handle(this);
+    }
+#endif
+  }
 
-  void FinalizeMessage() { message_->Finalize(); }
+  void FinalizeMessage() {
+    // |message_| and |listener_| may be cleared by reset_message() during
+    // Message::Finalize().
+    auto* listener = listener_;
+    auto* message = message_;
+    message->Finalize();
+    if (listener)
+      listener->OnMessageFinalized(message);
+  }
 
   Message* message_;
+  MessageFinalizationListener* listener_ = nullptr;
 #if PERFETTO_DCHECK_IS_ON()
   uint32_t generation_;
 #endif
@@ -2329,6 +3412,8 @@ class MessageHandle : public MessageHandleBase {
 #ifndef INCLUDE_PERFETTO_TRACING_TRACE_WRITER_BASE_H_
 #define INCLUDE_PERFETTO_TRACING_TRACE_WRITER_BASE_H_
 
+#include <cstdint>
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message_handle.h"
 
 namespace perfetto {
@@ -2346,7 +3431,7 @@ class TracePacket;
 // chunk and will write into the shared buffer without any locking most of the
 // time.
 
-class TraceWriterBase {
+class PERFETTO_EXPORT_COMPONENT TraceWriterBase {
  public:
   virtual ~TraceWriterBase();
 
@@ -2395,6 +3480,14 @@ class TraceWriterBase {
 
   // Bytes written since creation. Not reset when new chunks are acquired.
   virtual uint64_t written() const = 0;
+
+  // Number of times the trace writer entered a mode in which it started
+  // dropping data.
+  //
+  // This does not necessarily correspond to the number of packets/chunks
+  // dropped, as multiple such packets/chunks can be dropped on entry into a
+  // drop data mode.
+  virtual uint64_t drop_count() const = 0;
 };
 
 }  // namespace perfetto
@@ -2424,12 +3517,12 @@ class TraceWriterBase {
 
 #include <array>
 #include <atomic>
-#include <functional>
 #include <memory>
 #include <mutex>
 
 // No perfetto headers (other than tracing/api and protozero) should be here.
 // gen_amalgamated expanded: #include "perfetto/tracing/buffer_exhausted_policy.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_config.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/internal/basic_types.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/trace_writer_base.h"
 
@@ -2495,16 +3588,11 @@ struct DataSourceState {
   // to the startup session's ID.
   uint64_t startup_session_id = 0;
 
-  // A hash of the trace config used by this instance. This is used to
-  // de-duplicate instances for data sources with identical names (e.g., track
-  // event).
-  uint64_t config_hash = 0;
-
-  // Similar to config_hash, but excludes target buffers and service-set fields
-  // for matching of startup-tracing data source instances to sessions later
-  // started by the service.
-  // Learn more: ComputeStartupConfigHash
-  uint64_t startup_config_hash = 0;
+  // The trace config used by this instance. This is used to de-duplicate
+  // instances for data sources with identical names (e.g., track event).
+  // We store it as a pointer to be able to free memory after the datasource
+  // is stopped.
+  std::unique_ptr<DataSourceConfig> config;
 
   // If this data source is being intercepted (see Interceptor), this field
   // contains the non-zero id of a registered interceptor which should receive
@@ -2513,6 +3601,23 @@ struct DataSourceState {
   // the following slots.
   uint32_t interceptor_id = 0;
 
+  // This is set to true when the datasource is in the process of async stop.
+  // The flag is checked by the tracing muxer to avoid calling OnStop for the
+  // second time.
+  bool async_stop_in_progress = false;
+
+  // Whether this data source instance should call NotifyDataSourceStopped()
+  // when it's stopped.
+  bool will_notify_on_stop = false;
+
+  // The wanted behavior for this data source instance when a TraceWriter runs
+  // out of space in the shared memory buffer.
+  BufferExhaustedPolicy buffer_exhausted_policy = BufferExhaustedPolicy::kDrop;
+
+  // Incremented whenever incremental state should be reset for this instance of
+  // this data source.
+  std::atomic<uint32_t> incremental_state_generation{0};
+
   // This lock is not held to implement Trace() and it's used only if the trace
   // code wants to access its own data source state.
   // This is to prevent that accessing the data source on an arbitrary embedder
@@ -2545,15 +3650,16 @@ struct DataSourceStaticState {
   std::atomic<uint32_t> valid_instances{};
   std::array<DataSourceStateStorage, kMaxDataSourceInstances> instances{};
 
-  // Incremented whenever incremental state should be reset for any instance of
-  // this data source.
-  std::atomic<uint32_t> incremental_state_generation{};
+  // The caller must be sure that `n` was a valid instance at some point (either
+  // through a previous read of `valid_instances` or because the instance lock
+  // is held).
+  DataSourceState* GetUnsafe(size_t n) {
+    return reinterpret_cast<DataSourceState*>(&instances[n]);
+  }
 
   // Can be used with a cached |valid_instances| bitmap.
   DataSourceState* TryGetCached(uint32_t cached_bitmap, size_t n) {
-    return cached_bitmap & (1 << n)
-               ? reinterpret_cast<DataSourceState*>(&instances[n])
-               : nullptr;
+    return cached_bitmap & (1 << n) ? GetUnsafe(n) : nullptr;
   }
 
   DataSourceState* TryGet(size_t n) {
@@ -2570,7 +3676,6 @@ struct DataSourceStaticState {
     index = kMaxDataSources;
     valid_instances.store(0, std::memory_order_release);
     instances = {};
-    incremental_state_generation.store(0, std::memory_order_release);
   }
 };
 
@@ -2853,7 +3958,7 @@ class PERFETTO_EXPORT_COMPONENT InterceptorBase {
   // To define your own state, subclass this with the same name in the
   // interceptor class. A reference to the state can then be looked up through
   // context.GetThreadLocalState() in the trace packet interceptor function.
-  class ThreadLocalState {
+  class PERFETTO_EXPORT_COMPONENT ThreadLocalState {
    public:
     virtual ~ThreadLocalState();
   };
@@ -3348,15 +4453,20 @@ class PackedFixedSizeInt : public PackedBufferBase {
 #ifndef INCLUDE_PERFETTO_PROTOZERO_PROTO_DECODER_H_
 #define INCLUDE_PERFETTO_PROTOZERO_PROTO_DECODER_H_
 
-#include <stdint.h>
-#include <array>
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
 #include <memory>
-#include <vector>
+#include <string>
+#include <type_traits>
+#include <variant>
 
-// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/field.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "perfetto/public/compiler.h"
 
 namespace protozero {
 
@@ -3410,8 +4520,8 @@ class PERFETTO_EXPORT_COMPONENT ProtoDecoder {
   const uint8_t* end() const { return end_; }
 
  protected:
-  const uint8_t* const begin_;
-  const uint8_t* const end_;
+  const uint8_t* begin_;
+  const uint8_t* end_;
   const uint8_t* read_ptr_ = nullptr;
 };
 
@@ -3598,6 +4708,51 @@ class PackedRepeatedFieldIterator {
   bool* const parse_error_;
 };
 
+// A dispatching wrapper that can handle both packed and non-packed repeated
+// fields. It holds either a RepeatedFieldIterator or
+// PackedRepeatedFieldIterator and forwards calls to the appropriate one using
+// std::variant and base utilities.
+template <proto_utils::ProtoWireType wire_type, typename CppType>
+class UnifiedRepeatedFieldIterator {
+ public:
+  using RegularIterator = RepeatedFieldIterator<CppType>;
+  using PackedIterator = PackedRepeatedFieldIterator<wire_type, CppType>;
+  using VariantType = std::variant<RegularIterator, PackedIterator>;
+
+  // Constructor taking a regular iterator
+  explicit UnifiedRepeatedFieldIterator(RegularIterator iter)
+      : iter_(std::move(iter)) {}
+
+  // Constructor taking a packed iterator
+  explicit UnifiedRepeatedFieldIterator(PackedIterator iter)
+      : iter_(std::move(iter)) {}
+
+  // Constructs an invalid iterator.
+  UnifiedRepeatedFieldIterator() : iter_(RegularIterator()) {}
+
+  explicit operator bool() const {
+    return std::visit([](auto& it) { return static_cast<bool>(it); }, iter_);
+  }
+
+  CppType operator*() const {
+    return std::visit([](auto& it) { return *it; }, iter_);
+  }
+
+  UnifiedRepeatedFieldIterator& operator++() {
+    std::visit([](auto& it) { ++it; }, iter_);
+    return *this;
+  }
+
+  UnifiedRepeatedFieldIterator operator++(int) {
+    UnifiedRepeatedFieldIterator it(*this);
+    ++(*this);
+    return it;
+  }
+
+ private:
+  VariantType iter_;
+};
+
 // This decoder loads all fields upfront, without recursing in nested messages.
 // It is used as a base class for typed decoders generated by the pbzero plugin.
 // The split between TypedProtoDecoderBase and TypedProtoDecoder<> is to have
@@ -3671,7 +4826,8 @@ class PERFETTO_EXPORT_COMPONENT TypedProtoDecoderBase : public ProtoDecoder {
       uint32_t field_id,
       bool* parse_error_location) const {
     const Field& field = Get(field_id);
-    if (field.valid()) {
+    if (field.valid() &&
+        field.type() == proto_utils::ProtoWireType::kLengthDelimited) {
       return PackedRepeatedFieldIterator<wire_type, cpp_type>(
           field.data(), field.size(), parse_error_location);
     }
@@ -3679,6 +4835,32 @@ class PERFETTO_EXPORT_COMPONENT TypedProtoDecoderBase : public ProtoDecoder {
         nullptr, 0, parse_error_location);
   }
 
+  // Returns a unified iterator that automatically dispatches between packed and
+  // non-packed repeated field iteration based on the wire format. This allows
+  // parsers to handle both formats without knowing ahead of time which one is
+  // used.
+  //
+  // Example usage:
+  //   bool parse_error = false;
+  //   for (auto it = decoder.GetUnifiedRepeated<wire_type, int32_t>(N,
+  //   &parse_error);
+  //        it; ++it) { ... }
+  template <proto_utils::ProtoWireType wire_type, typename cpp_type>
+  UnifiedRepeatedFieldIterator<wire_type, cpp_type> GetUnifiedRepeated(
+      uint32_t field_id,
+      bool* parse_error_location) const {
+    const Field& field = Get(field_id);
+    if (field.valid() &&
+        field.type() == proto_utils::ProtoWireType::kLengthDelimited) {
+      // This looks like a packed repeated field
+      return UnifiedRepeatedFieldIterator<wire_type, cpp_type>(
+          GetPackedRepeated<wire_type, cpp_type>(field_id,
+                                                 parse_error_location));
+    }  // This is either invalid or a non-packed repeated field
+    return UnifiedRepeatedFieldIterator<wire_type, cpp_type>(
+        GetRepeated<cpp_type>(field_id));
+  }
+
  protected:
   TypedProtoDecoderBase(Field* storage,
                         uint32_t num_fields,
@@ -3753,7 +4935,11 @@ class PERFETTO_EXPORT_COMPONENT TypedProtoDecoderBase : public ProtoDecoder {
 
 // Template class instantiated by the auto-generated decoder classes declared in
 // xxx.pbzero.h files.
-template <int MAX_FIELD_ID, bool HAS_NONPACKED_REPEATED_FIELDS>
+// TODO(lalitm): the second argument exists for legacy reasons as targets in
+// G3 are (incorrectly) depending on internal implementation details of
+// Perfetto via checked-in protozero classes. Remove this when they fix this
+// incorrect dependency.
+template <int MAX_FIELD_ID, bool = false>
 class TypedProtoDecoder : public TypedProtoDecoderBase {
  public:
   TypedProtoDecoder(const uint8_t* buffer, size_t length)
@@ -3782,6 +4968,19 @@ class TypedProtoDecoder : public TypedProtoDecoderBase {
 
   TypedProtoDecoder(TypedProtoDecoder&& other) noexcept
       : TypedProtoDecoderBase(std::move(other)) {
+    MaybeCopyOnStackStorage(other);
+  }
+
+  TypedProtoDecoder& operator=(TypedProtoDecoder&& other) noexcept {
+    if (this != &other) {
+      TypedProtoDecoderBase::operator=(std::move(other));
+      MaybeCopyOnStackStorage(other);
+    }
+    return *this;
+  }
+
+ private:
+  void MaybeCopyOnStackStorage(const TypedProtoDecoder& other) {
     // If the moved-from decoder was using on-stack storage, we need to update
     // our pointer to point to this decoder's on-stack storage.
     if (fields_ == other.on_stack_storage_) {
@@ -3791,7 +4990,6 @@ class TypedProtoDecoder : public TypedProtoDecoderBase {
     }
   }
 
- private:
   Field on_stack_storage_[PROTOZERO_DECODER_INITIAL_STACK_CAPACITY];
 };
 
@@ -3815,7 +5013,6 @@ class TypedProtoDecoder : public TypedProtoDecoderBase {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
-
 class ChromeActiveProcesses;
 class ChromeApplicationStateInfo;
 class ChromeCompositorSchedulerState;
@@ -3832,8 +5029,11 @@ class ChromeUserEvent;
 class ChromeWindowHandleEventInfo;
 class DebugAnnotation;
 class LogMessage;
+class Screenshot;
 class SourceLocation;
 class TaskExecution;
+class TrackEvent_Callstack;
+class TrackEvent_Callstack_Frame;
 class TrackEvent_LegacyEvent;
 namespace perfetto_pbzero_enum_TrackEvent_LegacyEvent {
 enum FlowDirection : int32_t;
@@ -3847,6 +5047,13 @@ namespace perfetto_pbzero_enum_TrackEvent {
 enum Type : int32_t;
 }  // namespace perfetto_pbzero_enum_TrackEvent
 using TrackEvent_Type = perfetto_pbzero_enum_TrackEvent::Type;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
 namespace perfetto_pbzero_enum_TrackEvent {
 enum Type : int32_t {
@@ -3951,7 +5158,7 @@ const char* TrackEvent_LegacyEvent_InstantEventScope_Name(::perfetto::protos::pb
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-class EventName_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class EventName_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
   EventName_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit EventName_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -3980,14 +5187,7 @@ class EventName : public ::protozero::Message {
       uint64_t,
       EventName>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Iid kIid() { return {}; }
+  static constexpr FieldMetadata_Iid kIid{};
   void set_iid(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -4005,14 +5205,7 @@ class EventName : public ::protozero::Message {
       std::string,
       EventName>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -4029,7 +5222,7 @@ class EventName : public ::protozero::Message {
   }
 };
 
-class EventCategory_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class EventCategory_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
   EventCategory_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit EventCategory_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -4058,14 +5251,7 @@ class EventCategory : public ::protozero::Message {
       uint64_t,
       EventCategory>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Iid kIid() { return {}; }
+  static constexpr FieldMetadata_Iid kIid{};
   void set_iid(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -4083,14 +5269,7 @@ class EventCategory : public ::protozero::Message {
       std::string,
       EventCategory>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -4107,7 +5286,7 @@ class EventCategory : public ::protozero::Message {
   }
 };
 
-class TrackEventDefaults_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/45, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class TrackEventDefaults_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/45> {
  public:
   TrackEventDefaults_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit TrackEventDefaults_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -4139,14 +5318,7 @@ class TrackEventDefaults : public ::protozero::Message {
       uint64_t,
       TrackEventDefaults>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrackUuid kTrackUuid() { return {}; }
+  static constexpr FieldMetadata_TrackUuid kTrackUuid{};
   void set_track_uuid(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_TrackUuid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -4164,14 +5336,7 @@ class TrackEventDefaults : public ::protozero::Message {
       uint64_t,
       TrackEventDefaults>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExtraCounterTrackUuids kExtraCounterTrackUuids() { return {}; }
+  static constexpr FieldMetadata_ExtraCounterTrackUuids kExtraCounterTrackUuids{};
   void add_extra_counter_track_uuids(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ExtraCounterTrackUuids::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -4189,14 +5354,7 @@ class TrackEventDefaults : public ::protozero::Message {
       uint64_t,
       TrackEventDefaults>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExtraDoubleCounterTrackUuids kExtraDoubleCounterTrackUuids() { return {}; }
+  static constexpr FieldMetadata_ExtraDoubleCounterTrackUuids kExtraDoubleCounterTrackUuids{};
   void add_extra_double_counter_track_uuids(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ExtraDoubleCounterTrackUuids::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -4207,7 +5365,7 @@ class TrackEventDefaults : public ::protozero::Message {
   }
 };
 
-class TrackEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/49, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class TrackEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/56> {
  public:
   TrackEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit TrackEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -4244,6 +5402,16 @@ class TrackEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=
   ::protozero::RepeatedFieldIterator<uint64_t> terminating_flow_ids_old() const { return GetRepeated<uint64_t>(42); }
   bool has_terminating_flow_ids() const { return at<48>().valid(); }
   ::protozero::RepeatedFieldIterator<uint64_t> terminating_flow_ids() const { return GetRepeated<uint64_t>(48); }
+  bool has_correlation_id() const { return at<52>().valid(); }
+  uint64_t correlation_id() const { return at<52>().as_uint64(); }
+  bool has_correlation_id_str() const { return at<53>().valid(); }
+  ::protozero::ConstChars correlation_id_str() const { return at<53>().as_string(); }
+  bool has_correlation_id_str_iid() const { return at<54>().valid(); }
+  uint64_t correlation_id_str_iid() const { return at<54>().as_uint64(); }
+  bool has_callstack() const { return at<55>().valid(); }
+  ::protozero::ConstBytes callstack() const { return at<55>().as_bytes(); }
+  bool has_callstack_iid() const { return at<56>().valid(); }
+  uint64_t callstack_iid() const { return at<56>().as_uint64(); }
   bool has_debug_annotations() const { return at<4>().valid(); }
   ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> debug_annotations() const { return GetRepeated<::protozero::ConstBytes>(4); }
   bool has_task_execution() const { return at<5>().valid(); }
@@ -4274,6 +5442,8 @@ class TrackEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=
   ::protozero::ConstBytes chrome_content_settings_event_info() const { return at<43>().as_bytes(); }
   bool has_chrome_active_processes() const { return at<49>().valid(); }
   ::protozero::ConstBytes chrome_active_processes() const { return at<49>().as_bytes(); }
+  bool has_screenshot() const { return at<50>().valid(); }
+  ::protozero::ConstBytes screenshot() const { return at<50>().as_bytes(); }
   bool has_source_location() const { return at<33>().valid(); }
   ::protozero::ConstBytes source_location() const { return at<33>().as_bytes(); }
   bool has_source_location_iid() const { return at<34>().valid(); }
@@ -4318,6 +5488,11 @@ class TrackEvent : public ::protozero::Message {
     kFlowIdsFieldNumber = 47,
     kTerminatingFlowIdsOldFieldNumber = 42,
     kTerminatingFlowIdsFieldNumber = 48,
+    kCorrelationIdFieldNumber = 52,
+    kCorrelationIdStrFieldNumber = 53,
+    kCorrelationIdStrIidFieldNumber = 54,
+    kCallstackFieldNumber = 55,
+    kCallstackIidFieldNumber = 56,
     kDebugAnnotationsFieldNumber = 4,
     kTaskExecutionFieldNumber = 5,
     kLogMessageFieldNumber = 21,
@@ -4333,6 +5508,7 @@ class TrackEvent : public ::protozero::Message {
     kChromeWindowHandleEventInfoFieldNumber = 41,
     kChromeContentSettingsEventInfoFieldNumber = 43,
     kChromeActiveProcessesFieldNumber = 49,
+    kScreenshotFieldNumber = 50,
     kSourceLocationFieldNumber = 33,
     kSourceLocationIidFieldNumber = 34,
     kChromeMessagePumpFieldNumber = 35,
@@ -4347,17 +5523,18 @@ class TrackEvent : public ::protozero::Message {
   };
   static constexpr const char* GetName() { return ".perfetto.protos.TrackEvent"; }
 
+  using Callstack = ::perfetto::protos::pbzero::TrackEvent_Callstack;
   using LegacyEvent = ::perfetto::protos::pbzero::TrackEvent_LegacyEvent;
 
   using Type = ::perfetto::protos::pbzero::TrackEvent_Type;
   static inline const char* Type_Name(Type value) {
     return ::perfetto::protos::pbzero::TrackEvent_Type_Name(value);
   }
-  static const Type TYPE_UNSPECIFIED = Type::TYPE_UNSPECIFIED;
-  static const Type TYPE_SLICE_BEGIN = Type::TYPE_SLICE_BEGIN;
-  static const Type TYPE_SLICE_END = Type::TYPE_SLICE_END;
-  static const Type TYPE_INSTANT = Type::TYPE_INSTANT;
-  static const Type TYPE_COUNTER = Type::TYPE_COUNTER;
+  static inline const Type TYPE_UNSPECIFIED = Type::TYPE_UNSPECIFIED;
+  static inline const Type TYPE_SLICE_BEGIN = Type::TYPE_SLICE_BEGIN;
+  static inline const Type TYPE_SLICE_END = Type::TYPE_SLICE_END;
+  static inline const Type TYPE_INSTANT = Type::TYPE_INSTANT;
+  static inline const Type TYPE_COUNTER = Type::TYPE_COUNTER;
 
   using FieldMetadata_CategoryIids =
     ::protozero::proto_utils::FieldMetadata<
@@ -4367,14 +5544,7 @@ class TrackEvent : public ::protozero::Message {
       uint64_t,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CategoryIids kCategoryIids() { return {}; }
+  static constexpr FieldMetadata_CategoryIids kCategoryIids{};
   void add_category_iids(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_CategoryIids::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -4392,14 +5562,7 @@ class TrackEvent : public ::protozero::Message {
       std::string,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Categories kCategories() { return {}; }
+  static constexpr FieldMetadata_Categories kCategories{};
   void add_categories(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Categories::kFieldId, data, size);
   }
@@ -4423,14 +5586,7 @@ class TrackEvent : public ::protozero::Message {
       uint64_t,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NameIid kNameIid() { return {}; }
+  static constexpr FieldMetadata_NameIid kNameIid{};
   void set_name_iid(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NameIid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -4448,14 +5604,7 @@ class TrackEvent : public ::protozero::Message {
       std::string,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -4476,18 +5625,11 @@ class TrackEvent : public ::protozero::Message {
       9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::TrackEvent_Type,
+      TrackEvent_Type,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(::perfetto::protos::pbzero::TrackEvent_Type value) {
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(TrackEvent_Type value) {
     static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
@@ -4504,14 +5646,7 @@ class TrackEvent : public ::protozero::Message {
       uint64_t,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrackUuid kTrackUuid() { return {}; }
+  static constexpr FieldMetadata_TrackUuid kTrackUuid{};
   void set_track_uuid(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_TrackUuid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -4529,14 +5664,7 @@ class TrackEvent : public ::protozero::Message {
       int64_t,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CounterValue kCounterValue() { return {}; }
+  static constexpr FieldMetadata_CounterValue kCounterValue{};
   void set_counter_value(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_CounterValue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -4554,14 +5682,7 @@ class TrackEvent : public ::protozero::Message {
       double,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DoubleCounterValue kDoubleCounterValue() { return {}; }
+  static constexpr FieldMetadata_DoubleCounterValue kDoubleCounterValue{};
   void set_double_counter_value(double value) {
     static constexpr uint32_t field_id = FieldMetadata_DoubleCounterValue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -4579,14 +5700,7 @@ class TrackEvent : public ::protozero::Message {
       uint64_t,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExtraCounterTrackUuids kExtraCounterTrackUuids() { return {}; }
+  static constexpr FieldMetadata_ExtraCounterTrackUuids kExtraCounterTrackUuids{};
   void add_extra_counter_track_uuids(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ExtraCounterTrackUuids::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -4604,14 +5718,7 @@ class TrackEvent : public ::protozero::Message {
       int64_t,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExtraCounterValues kExtraCounterValues() { return {}; }
+  static constexpr FieldMetadata_ExtraCounterValues kExtraCounterValues{};
   void add_extra_counter_values(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ExtraCounterValues::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -4629,14 +5736,7 @@ class TrackEvent : public ::protozero::Message {
       uint64_t,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExtraDoubleCounterTrackUuids kExtraDoubleCounterTrackUuids() { return {}; }
+  static constexpr FieldMetadata_ExtraDoubleCounterTrackUuids kExtraDoubleCounterTrackUuids{};
   void add_extra_double_counter_track_uuids(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ExtraDoubleCounterTrackUuids::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -4654,14 +5754,7 @@ class TrackEvent : public ::protozero::Message {
       double,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExtraDoubleCounterValues kExtraDoubleCounterValues() { return {}; }
+  static constexpr FieldMetadata_ExtraDoubleCounterValues kExtraDoubleCounterValues{};
   void add_extra_double_counter_values(double value) {
     static constexpr uint32_t field_id = FieldMetadata_ExtraDoubleCounterValues::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -4679,14 +5772,7 @@ class TrackEvent : public ::protozero::Message {
       uint64_t,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FlowIdsOld kFlowIdsOld() { return {}; }
+  static constexpr FieldMetadata_FlowIdsOld kFlowIdsOld{};
   void add_flow_ids_old(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_FlowIdsOld::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -4704,14 +5790,7 @@ class TrackEvent : public ::protozero::Message {
       uint64_t,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FlowIds kFlowIds() { return {}; }
+  static constexpr FieldMetadata_FlowIds kFlowIds{};
   void add_flow_ids(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_FlowIds::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -4729,14 +5808,7 @@ class TrackEvent : public ::protozero::Message {
       uint64_t,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TerminatingFlowIdsOld kTerminatingFlowIdsOld() { return {}; }
+  static constexpr FieldMetadata_TerminatingFlowIdsOld kTerminatingFlowIdsOld{};
   void add_terminating_flow_ids_old(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_TerminatingFlowIdsOld::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -4754,14 +5826,7 @@ class TrackEvent : public ::protozero::Message {
       uint64_t,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TerminatingFlowIds kTerminatingFlowIds() { return {}; }
+  static constexpr FieldMetadata_TerminatingFlowIds kTerminatingFlowIds{};
   void add_terminating_flow_ids(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_TerminatingFlowIds::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -4771,6 +5836,98 @@ class TrackEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
+  using FieldMetadata_CorrelationId =
+    ::protozero::proto_utils::FieldMetadata<
+      52,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TrackEvent>;
+
+  static constexpr FieldMetadata_CorrelationId kCorrelationId{};
+  void set_correlation_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CorrelationId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CorrelationIdStr =
+    ::protozero::proto_utils::FieldMetadata<
+      53,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TrackEvent>;
+
+  static constexpr FieldMetadata_CorrelationIdStr kCorrelationIdStr{};
+  void set_correlation_id_str(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_CorrelationIdStr::kFieldId, data, size);
+  }
+  void set_correlation_id_str(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_CorrelationIdStr::kFieldId, chars.data, chars.size);
+  }
+  void set_correlation_id_str(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_CorrelationIdStr::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CorrelationIdStrIid =
+    ::protozero::proto_utils::FieldMetadata<
+      54,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TrackEvent>;
+
+  static constexpr FieldMetadata_CorrelationIdStrIid kCorrelationIdStrIid{};
+  void set_correlation_id_str_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CorrelationIdStrIid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Callstack =
+    ::protozero::proto_utils::FieldMetadata<
+      55,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TrackEvent_Callstack,
+      TrackEvent>;
+
+  static constexpr FieldMetadata_Callstack kCallstack{};
+  template <typename T = TrackEvent_Callstack> T* set_callstack() {
+    return BeginNestedMessage<T>(55);
+  }
+
+
+  using FieldMetadata_CallstackIid =
+    ::protozero::proto_utils::FieldMetadata<
+      56,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TrackEvent>;
+
+  static constexpr FieldMetadata_CallstackIid kCallstackIid{};
+  void set_callstack_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CallstackIid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
   using FieldMetadata_DebugAnnotations =
     ::protozero::proto_utils::FieldMetadata<
       4,
@@ -4779,14 +5936,7 @@ class TrackEvent : public ::protozero::Message {
       DebugAnnotation,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DebugAnnotations kDebugAnnotations() { return {}; }
+  static constexpr FieldMetadata_DebugAnnotations kDebugAnnotations{};
   template <typename T = DebugAnnotation> T* add_debug_annotations() {
     return BeginNestedMessage<T>(4);
   }
@@ -4800,14 +5950,7 @@ class TrackEvent : public ::protozero::Message {
       TaskExecution,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TaskExecution kTaskExecution() { return {}; }
+  static constexpr FieldMetadata_TaskExecution kTaskExecution{};
   template <typename T = TaskExecution> T* set_task_execution() {
     return BeginNestedMessage<T>(5);
   }
@@ -4821,14 +5964,7 @@ class TrackEvent : public ::protozero::Message {
       LogMessage,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LogMessage kLogMessage() { return {}; }
+  static constexpr FieldMetadata_LogMessage kLogMessage{};
   template <typename T = LogMessage> T* set_log_message() {
     return BeginNestedMessage<T>(21);
   }
@@ -4842,14 +5978,7 @@ class TrackEvent : public ::protozero::Message {
       ChromeCompositorSchedulerState,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CcSchedulerState kCcSchedulerState() { return {}; }
+  static constexpr FieldMetadata_CcSchedulerState kCcSchedulerState{};
   template <typename T = ChromeCompositorSchedulerState> T* set_cc_scheduler_state() {
     return BeginNestedMessage<T>(24);
   }
@@ -4863,14 +5992,7 @@ class TrackEvent : public ::protozero::Message {
       ChromeUserEvent,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeUserEvent kChromeUserEvent() { return {}; }
+  static constexpr FieldMetadata_ChromeUserEvent kChromeUserEvent{};
   template <typename T = ChromeUserEvent> T* set_chrome_user_event() {
     return BeginNestedMessage<T>(25);
   }
@@ -4884,14 +6006,7 @@ class TrackEvent : public ::protozero::Message {
       ChromeKeyedService,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeKeyedService kChromeKeyedService() { return {}; }
+  static constexpr FieldMetadata_ChromeKeyedService kChromeKeyedService{};
   template <typename T = ChromeKeyedService> T* set_chrome_keyed_service() {
     return BeginNestedMessage<T>(26);
   }
@@ -4905,14 +6020,7 @@ class TrackEvent : public ::protozero::Message {
       ChromeLegacyIpc,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeLegacyIpc kChromeLegacyIpc() { return {}; }
+  static constexpr FieldMetadata_ChromeLegacyIpc kChromeLegacyIpc{};
   template <typename T = ChromeLegacyIpc> T* set_chrome_legacy_ipc() {
     return BeginNestedMessage<T>(27);
   }
@@ -4926,14 +6034,7 @@ class TrackEvent : public ::protozero::Message {
       ChromeHistogramSample,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeHistogramSample kChromeHistogramSample() { return {}; }
+  static constexpr FieldMetadata_ChromeHistogramSample kChromeHistogramSample{};
   template <typename T = ChromeHistogramSample> T* set_chrome_histogram_sample() {
     return BeginNestedMessage<T>(28);
   }
@@ -4947,14 +6048,7 @@ class TrackEvent : public ::protozero::Message {
       ChromeLatencyInfo,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeLatencyInfo kChromeLatencyInfo() { return {}; }
+  static constexpr FieldMetadata_ChromeLatencyInfo kChromeLatencyInfo{};
   template <typename T = ChromeLatencyInfo> T* set_chrome_latency_info() {
     return BeginNestedMessage<T>(29);
   }
@@ -4968,14 +6062,7 @@ class TrackEvent : public ::protozero::Message {
       ChromeFrameReporter,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeFrameReporter kChromeFrameReporter() { return {}; }
+  static constexpr FieldMetadata_ChromeFrameReporter kChromeFrameReporter{};
   template <typename T = ChromeFrameReporter> T* set_chrome_frame_reporter() {
     return BeginNestedMessage<T>(32);
   }
@@ -4989,14 +6076,7 @@ class TrackEvent : public ::protozero::Message {
       ChromeApplicationStateInfo,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeApplicationStateInfo kChromeApplicationStateInfo() { return {}; }
+  static constexpr FieldMetadata_ChromeApplicationStateInfo kChromeApplicationStateInfo{};
   template <typename T = ChromeApplicationStateInfo> T* set_chrome_application_state_info() {
     return BeginNestedMessage<T>(39);
   }
@@ -5010,14 +6090,7 @@ class TrackEvent : public ::protozero::Message {
       ChromeRendererSchedulerState,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeRendererSchedulerState kChromeRendererSchedulerState() { return {}; }
+  static constexpr FieldMetadata_ChromeRendererSchedulerState kChromeRendererSchedulerState{};
   template <typename T = ChromeRendererSchedulerState> T* set_chrome_renderer_scheduler_state() {
     return BeginNestedMessage<T>(40);
   }
@@ -5031,14 +6104,7 @@ class TrackEvent : public ::protozero::Message {
       ChromeWindowHandleEventInfo,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeWindowHandleEventInfo kChromeWindowHandleEventInfo() { return {}; }
+  static constexpr FieldMetadata_ChromeWindowHandleEventInfo kChromeWindowHandleEventInfo{};
   template <typename T = ChromeWindowHandleEventInfo> T* set_chrome_window_handle_event_info() {
     return BeginNestedMessage<T>(41);
   }
@@ -5052,14 +6118,7 @@ class TrackEvent : public ::protozero::Message {
       ChromeContentSettingsEventInfo,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeContentSettingsEventInfo kChromeContentSettingsEventInfo() { return {}; }
+  static constexpr FieldMetadata_ChromeContentSettingsEventInfo kChromeContentSettingsEventInfo{};
   template <typename T = ChromeContentSettingsEventInfo> T* set_chrome_content_settings_event_info() {
     return BeginNestedMessage<T>(43);
   }
@@ -5073,19 +6132,26 @@ class TrackEvent : public ::protozero::Message {
       ChromeActiveProcesses,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeActiveProcesses kChromeActiveProcesses() { return {}; }
+  static constexpr FieldMetadata_ChromeActiveProcesses kChromeActiveProcesses{};
   template <typename T = ChromeActiveProcesses> T* set_chrome_active_processes() {
     return BeginNestedMessage<T>(49);
   }
 
 
+  using FieldMetadata_Screenshot =
+    ::protozero::proto_utils::FieldMetadata<
+      50,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      Screenshot,
+      TrackEvent>;
+
+  static constexpr FieldMetadata_Screenshot kScreenshot{};
+  template <typename T = Screenshot> T* set_screenshot() {
+    return BeginNestedMessage<T>(50);
+  }
+
+
   using FieldMetadata_SourceLocation =
     ::protozero::proto_utils::FieldMetadata<
       33,
@@ -5094,14 +6160,7 @@ class TrackEvent : public ::protozero::Message {
       SourceLocation,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SourceLocation kSourceLocation() { return {}; }
+  static constexpr FieldMetadata_SourceLocation kSourceLocation{};
   template <typename T = SourceLocation> T* set_source_location() {
     return BeginNestedMessage<T>(33);
   }
@@ -5115,14 +6174,7 @@ class TrackEvent : public ::protozero::Message {
       uint64_t,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SourceLocationIid kSourceLocationIid() { return {}; }
+  static constexpr FieldMetadata_SourceLocationIid kSourceLocationIid{};
   void set_source_location_iid(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_SourceLocationIid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -5140,14 +6192,7 @@ class TrackEvent : public ::protozero::Message {
       ChromeMessagePump,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeMessagePump kChromeMessagePump() { return {}; }
+  static constexpr FieldMetadata_ChromeMessagePump kChromeMessagePump{};
   template <typename T = ChromeMessagePump> T* set_chrome_message_pump() {
     return BeginNestedMessage<T>(35);
   }
@@ -5161,14 +6206,7 @@ class TrackEvent : public ::protozero::Message {
       ChromeMojoEventInfo,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeMojoEventInfo kChromeMojoEventInfo() { return {}; }
+  static constexpr FieldMetadata_ChromeMojoEventInfo kChromeMojoEventInfo{};
   template <typename T = ChromeMojoEventInfo> T* set_chrome_mojo_event_info() {
     return BeginNestedMessage<T>(38);
   }
@@ -5182,14 +6220,7 @@ class TrackEvent : public ::protozero::Message {
       int64_t,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimestampDeltaUs kTimestampDeltaUs() { return {}; }
+  static constexpr FieldMetadata_TimestampDeltaUs kTimestampDeltaUs{};
   void set_timestamp_delta_us(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_TimestampDeltaUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -5207,14 +6238,7 @@ class TrackEvent : public ::protozero::Message {
       int64_t,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimestampAbsoluteUs kTimestampAbsoluteUs() { return {}; }
+  static constexpr FieldMetadata_TimestampAbsoluteUs kTimestampAbsoluteUs{};
   void set_timestamp_absolute_us(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_TimestampAbsoluteUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -5232,14 +6256,7 @@ class TrackEvent : public ::protozero::Message {
       int64_t,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThreadTimeDeltaUs kThreadTimeDeltaUs() { return {}; }
+  static constexpr FieldMetadata_ThreadTimeDeltaUs kThreadTimeDeltaUs{};
   void set_thread_time_delta_us(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ThreadTimeDeltaUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -5257,14 +6274,7 @@ class TrackEvent : public ::protozero::Message {
       int64_t,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThreadTimeAbsoluteUs kThreadTimeAbsoluteUs() { return {}; }
+  static constexpr FieldMetadata_ThreadTimeAbsoluteUs kThreadTimeAbsoluteUs{};
   void set_thread_time_absolute_us(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ThreadTimeAbsoluteUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -5282,14 +6292,7 @@ class TrackEvent : public ::protozero::Message {
       int64_t,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThreadInstructionCountDelta kThreadInstructionCountDelta() { return {}; }
+  static constexpr FieldMetadata_ThreadInstructionCountDelta kThreadInstructionCountDelta{};
   void set_thread_instruction_count_delta(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ThreadInstructionCountDelta::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -5307,14 +6310,7 @@ class TrackEvent : public ::protozero::Message {
       int64_t,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThreadInstructionCountAbsolute kThreadInstructionCountAbsolute() { return {}; }
+  static constexpr FieldMetadata_ThreadInstructionCountAbsolute kThreadInstructionCountAbsolute{};
   void set_thread_instruction_count_absolute(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ThreadInstructionCountAbsolute::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -5332,21 +6328,14 @@ class TrackEvent : public ::protozero::Message {
       TrackEvent_LegacyEvent,
       TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LegacyEvent kLegacyEvent() { return {}; }
+  static constexpr FieldMetadata_LegacyEvent kLegacyEvent{};
   template <typename T = TrackEvent_LegacyEvent> T* set_legacy_event() {
     return BeginNestedMessage<T>(6);
   }
 
 };
 
-class TrackEvent_LegacyEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/19, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class TrackEvent_LegacyEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/19> {
  public:
   TrackEvent_LegacyEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit TrackEvent_LegacyEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -5418,14 +6407,14 @@ class TrackEvent_LegacyEvent : public ::protozero::Message {
   static inline const char* InstantEventScope_Name(InstantEventScope value) {
     return ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_InstantEventScope_Name(value);
   }
-  static const FlowDirection FLOW_UNSPECIFIED = FlowDirection::FLOW_UNSPECIFIED;
-  static const FlowDirection FLOW_IN = FlowDirection::FLOW_IN;
-  static const FlowDirection FLOW_OUT = FlowDirection::FLOW_OUT;
-  static const FlowDirection FLOW_INOUT = FlowDirection::FLOW_INOUT;
-  static const InstantEventScope SCOPE_UNSPECIFIED = InstantEventScope::SCOPE_UNSPECIFIED;
-  static const InstantEventScope SCOPE_GLOBAL = InstantEventScope::SCOPE_GLOBAL;
-  static const InstantEventScope SCOPE_PROCESS = InstantEventScope::SCOPE_PROCESS;
-  static const InstantEventScope SCOPE_THREAD = InstantEventScope::SCOPE_THREAD;
+  static inline const FlowDirection FLOW_UNSPECIFIED = FlowDirection::FLOW_UNSPECIFIED;
+  static inline const FlowDirection FLOW_IN = FlowDirection::FLOW_IN;
+  static inline const FlowDirection FLOW_OUT = FlowDirection::FLOW_OUT;
+  static inline const FlowDirection FLOW_INOUT = FlowDirection::FLOW_INOUT;
+  static inline const InstantEventScope SCOPE_UNSPECIFIED = InstantEventScope::SCOPE_UNSPECIFIED;
+  static inline const InstantEventScope SCOPE_GLOBAL = InstantEventScope::SCOPE_GLOBAL;
+  static inline const InstantEventScope SCOPE_PROCESS = InstantEventScope::SCOPE_PROCESS;
+  static inline const InstantEventScope SCOPE_THREAD = InstantEventScope::SCOPE_THREAD;
 
   using FieldMetadata_NameIid =
     ::protozero::proto_utils::FieldMetadata<
@@ -5435,14 +6424,7 @@ class TrackEvent_LegacyEvent : public ::protozero::Message {
       uint64_t,
       TrackEvent_LegacyEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NameIid kNameIid() { return {}; }
+  static constexpr FieldMetadata_NameIid kNameIid{};
   void set_name_iid(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NameIid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -5460,14 +6442,7 @@ class TrackEvent_LegacyEvent : public ::protozero::Message {
       int32_t,
       TrackEvent_LegacyEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Phase kPhase() { return {}; }
+  static constexpr FieldMetadata_Phase kPhase{};
   void set_phase(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Phase::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -5485,14 +6460,7 @@ class TrackEvent_LegacyEvent : public ::protozero::Message {
       int64_t,
       TrackEvent_LegacyEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DurationUs kDurationUs() { return {}; }
+  static constexpr FieldMetadata_DurationUs kDurationUs{};
   void set_duration_us(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_DurationUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -5510,14 +6478,7 @@ class TrackEvent_LegacyEvent : public ::protozero::Message {
       int64_t,
       TrackEvent_LegacyEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThreadDurationUs kThreadDurationUs() { return {}; }
+  static constexpr FieldMetadata_ThreadDurationUs kThreadDurationUs{};
   void set_thread_duration_us(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ThreadDurationUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -5535,14 +6496,7 @@ class TrackEvent_LegacyEvent : public ::protozero::Message {
       int64_t,
       TrackEvent_LegacyEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThreadInstructionDelta kThreadInstructionDelta() { return {}; }
+  static constexpr FieldMetadata_ThreadInstructionDelta kThreadInstructionDelta{};
   void set_thread_instruction_delta(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ThreadInstructionDelta::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -5560,14 +6514,7 @@ class TrackEvent_LegacyEvent : public ::protozero::Message {
       uint64_t,
       TrackEvent_LegacyEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UnscopedId kUnscopedId() { return {}; }
+  static constexpr FieldMetadata_UnscopedId kUnscopedId{};
   void set_unscoped_id(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_UnscopedId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -5585,14 +6532,7 @@ class TrackEvent_LegacyEvent : public ::protozero::Message {
       uint64_t,
       TrackEvent_LegacyEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LocalId kLocalId() { return {}; }
+  static constexpr FieldMetadata_LocalId kLocalId{};
   void set_local_id(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_LocalId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -5610,14 +6550,7 @@ class TrackEvent_LegacyEvent : public ::protozero::Message {
       uint64_t,
       TrackEvent_LegacyEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GlobalId kGlobalId() { return {}; }
+  static constexpr FieldMetadata_GlobalId kGlobalId{};
   void set_global_id(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_GlobalId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -5635,14 +6568,7 @@ class TrackEvent_LegacyEvent : public ::protozero::Message {
       std::string,
       TrackEvent_LegacyEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IdScope kIdScope() { return {}; }
+  static constexpr FieldMetadata_IdScope kIdScope{};
   void set_id_scope(const char* data, size_t size) {
     AppendBytes(FieldMetadata_IdScope::kFieldId, data, size);
   }
@@ -5666,14 +6592,7 @@ class TrackEvent_LegacyEvent : public ::protozero::Message {
       bool,
       TrackEvent_LegacyEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UseAsyncTts kUseAsyncTts() { return {}; }
+  static constexpr FieldMetadata_UseAsyncTts kUseAsyncTts{};
   void set_use_async_tts(bool value) {
     static constexpr uint32_t field_id = FieldMetadata_UseAsyncTts::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -5691,14 +6610,7 @@ class TrackEvent_LegacyEvent : public ::protozero::Message {
       uint64_t,
       TrackEvent_LegacyEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BindId kBindId() { return {}; }
+  static constexpr FieldMetadata_BindId kBindId{};
   void set_bind_id(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_BindId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -5716,14 +6628,7 @@ class TrackEvent_LegacyEvent : public ::protozero::Message {
       bool,
       TrackEvent_LegacyEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BindToEnclosing kBindToEnclosing() { return {}; }
+  static constexpr FieldMetadata_BindToEnclosing kBindToEnclosing{};
   void set_bind_to_enclosing(bool value) {
     static constexpr uint32_t field_id = FieldMetadata_BindToEnclosing::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -5738,18 +6643,11 @@ class TrackEvent_LegacyEvent : public ::protozero::Message {
       13,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_FlowDirection,
+      TrackEvent_LegacyEvent_FlowDirection,
       TrackEvent_LegacyEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FlowDirection kFlowDirection() { return {}; }
-  void set_flow_direction(::perfetto::protos::pbzero::TrackEvent_LegacyEvent_FlowDirection value) {
+  static constexpr FieldMetadata_FlowDirection kFlowDirection{};
+  void set_flow_direction(TrackEvent_LegacyEvent_FlowDirection value) {
     static constexpr uint32_t field_id = FieldMetadata_FlowDirection::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
@@ -5763,18 +6661,11 @@ class TrackEvent_LegacyEvent : public ::protozero::Message {
       14,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_InstantEventScope,
+      TrackEvent_LegacyEvent_InstantEventScope,
       TrackEvent_LegacyEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InstantEventScope kInstantEventScope() { return {}; }
-  void set_instant_event_scope(::perfetto::protos::pbzero::TrackEvent_LegacyEvent_InstantEventScope value) {
+  static constexpr FieldMetadata_InstantEventScope kInstantEventScope{};
+  void set_instant_event_scope(TrackEvent_LegacyEvent_InstantEventScope value) {
     static constexpr uint32_t field_id = FieldMetadata_InstantEventScope::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
@@ -5791,14 +6682,7 @@ class TrackEvent_LegacyEvent : public ::protozero::Message {
       int32_t,
       TrackEvent_LegacyEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PidOverride kPidOverride() { return {}; }
+  static constexpr FieldMetadata_PidOverride kPidOverride{};
   void set_pid_override(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_PidOverride::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -5816,14 +6700,7 @@ class TrackEvent_LegacyEvent : public ::protozero::Message {
       int32_t,
       TrackEvent_LegacyEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TidOverride kTidOverride() { return {}; }
+  static constexpr FieldMetadata_TidOverride kTidOverride{};
   void set_tid_override(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_TidOverride::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -5834,6 +6711,131 @@ class TrackEvent_LegacyEvent : public ::protozero::Message {
   }
 };
 
+class TrackEvent_Callstack_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  TrackEvent_Callstack_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TrackEvent_Callstack_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TrackEvent_Callstack_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_frames() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> frames() const { return GetRepeated<::protozero::ConstBytes>(1); }
+};
+
+class TrackEvent_Callstack : public ::protozero::Message {
+ public:
+  using Decoder = TrackEvent_Callstack_Decoder;
+  enum : int32_t {
+    kFramesFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TrackEvent.Callstack"; }
+
+  using Frame = ::perfetto::protos::pbzero::TrackEvent_Callstack_Frame;
+
+  using FieldMetadata_Frames =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TrackEvent_Callstack_Frame,
+      TrackEvent_Callstack>;
+
+  static constexpr FieldMetadata_Frames kFrames{};
+  template <typename T = TrackEvent_Callstack_Frame> T* add_frames() {
+    return BeginNestedMessage<T>(1);
+  }
+
+};
+
+class TrackEvent_Callstack_Frame_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  TrackEvent_Callstack_Frame_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TrackEvent_Callstack_Frame_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TrackEvent_Callstack_Frame_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_function_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars function_name() const { return at<1>().as_string(); }
+  bool has_source_file() const { return at<2>().valid(); }
+  ::protozero::ConstChars source_file() const { return at<2>().as_string(); }
+  bool has_line_number() const { return at<3>().valid(); }
+  uint32_t line_number() const { return at<3>().as_uint32(); }
+};
+
+class TrackEvent_Callstack_Frame : public ::protozero::Message {
+ public:
+  using Decoder = TrackEvent_Callstack_Frame_Decoder;
+  enum : int32_t {
+    kFunctionNameFieldNumber = 1,
+    kSourceFileFieldNumber = 2,
+    kLineNumberFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TrackEvent.Callstack.Frame"; }
+
+
+  using FieldMetadata_FunctionName =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TrackEvent_Callstack_Frame>;
+
+  static constexpr FieldMetadata_FunctionName kFunctionName{};
+  void set_function_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_FunctionName::kFieldId, data, size);
+  }
+  void set_function_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_FunctionName::kFieldId, chars.data, chars.size);
+  }
+  void set_function_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_FunctionName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SourceFile =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TrackEvent_Callstack_Frame>;
+
+  static constexpr FieldMetadata_SourceFile kSourceFile{};
+  void set_source_file(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_SourceFile::kFieldId, data, size);
+  }
+  void set_source_file(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_SourceFile::kFieldId, chars.data, chars.size);
+  }
+  void set_source_file(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_SourceFile::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_LineNumber =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TrackEvent_Callstack_Frame>;
+
+  static constexpr FieldMetadata_LineNumber kLineNumber{};
+  void set_line_number(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LineNumber::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
 } // Namespace.
 } // Namespace.
 } // Namespace.
@@ -5954,7 +6956,7 @@ class PERFETTO_EXPORT_COMPONENT TrackEventStateTracker {
 
   // Interface used by the tracker to access tracing session and sequence state
   // and to report parsed track events.
-  class Delegate {
+  class PERFETTO_EXPORT_COMPONENT Delegate {
    public:
     virtual ~Delegate();
 
@@ -6116,418 +7118,6 @@ class PERFETTO_EXPORT_COMPONENT ConsoleInterceptor
 }  // namespace perfetto
 
 #endif  // INCLUDE_PERFETTO_TRACING_CONSOLE_INTERCEPTOR_H_
-// gen_amalgamated begin header: include/perfetto/tracing/core/data_source_config.h
-// gen_amalgamated begin header: gen/protos/perfetto/config/data_source_config.gen.h
-// gen_amalgamated begin header: include/perfetto/protozero/cpp_message_obj.h
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef INCLUDE_PERFETTO_PROTOZERO_CPP_MESSAGE_OBJ_H_
-#define INCLUDE_PERFETTO_PROTOZERO_CPP_MESSAGE_OBJ_H_
-
-#include <stdint.h>
-
-#include <string>
-#include <vector>
-
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace protozero {
-
-// Base class for generated .gen.h classes, which are full C++ objects that
-// support both ser and deserialization (but are not zero-copy).
-// This is only used by the "cpp" targets not the "pbzero" ones.
-class PERFETTO_EXPORT_COMPONENT CppMessageObj {
- public:
-  virtual ~CppMessageObj();
-  virtual std::string SerializeAsString() const = 0;
-  virtual std::vector<uint8_t> SerializeAsArray() const = 0;
-  virtual bool ParseFromArray(const void*, size_t) = 0;
-
-  bool ParseFromString(const std::string& str) {
-    return ParseFromArray(str.data(), str.size());
-  }
-};
-
-}  // namespace protozero
-
-#endif  // INCLUDE_PERFETTO_PROTOZERO_CPP_MESSAGE_OBJ_H_
-// gen_amalgamated begin header: include/perfetto/protozero/copyable_ptr.h
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef INCLUDE_PERFETTO_PROTOZERO_COPYABLE_PTR_H_
-#define INCLUDE_PERFETTO_PROTOZERO_COPYABLE_PTR_H_
-
-#include <memory>
-
-namespace protozero {
-
-// This class is essentially a std::vector<T> of fixed size = 1.
-// It's a pointer wrapper with deep copying and deep equality comparison.
-// At all effects this wrapper behaves like the underlying T, with the exception
-// of the heap indirection.
-// Conversely to a std::unique_ptr, the pointer will be always valid, never
-// null. The problem it solves is the following: when generating C++ classes
-// from proto files, we want to keep each header hermetic (i.e. not #include
-// headers of dependent types). As such we can't directly instantiate T
-// field members but we can instead rely on pointers, so only the .cc file needs
-// to see the actual definition of T. If the generated classes were move-only we
-// could just use a unique_ptr there. But they aren't, hence this wrapper.
-// Converesely to unique_ptr, this wrapper:
-// - Default constructs the T instance in its constructor.
-// - Implements deep comparison in operator== instead of pointer comparison.
-template <typename T>
-class CopyablePtr {
- public:
-  CopyablePtr() : ptr_(new T()) {}
-  ~CopyablePtr() = default;
-
-  // Copy operators.
-  CopyablePtr(const CopyablePtr& other) : ptr_(new T(*other.ptr_)) {}
-  CopyablePtr& operator=(const CopyablePtr& other) {
-    *ptr_ = *other.ptr_;
-    return *this;
-  }
-
-  // Move operators.
-  CopyablePtr(CopyablePtr&& other) noexcept : ptr_(std::move(other.ptr_)) {
-    other.ptr_.reset(new T());
-  }
-
-  CopyablePtr& operator=(CopyablePtr&& other) {
-    ptr_ = std::move(other.ptr_);
-    other.ptr_.reset(new T());
-    return *this;
-  }
-
-  T* get() { return ptr_.get(); }
-  const T* get() const { return ptr_.get(); }
-
-  T* operator->() { return ptr_.get(); }
-  const T* operator->() const { return ptr_.get(); }
-
-  T& operator*() { return *ptr_; }
-  const T& operator*() const { return *ptr_; }
-
-  friend bool operator==(const CopyablePtr& lhs, const CopyablePtr& rhs) {
-    return *lhs == *rhs;
-  }
-
-  friend bool operator!=(const CopyablePtr& lhs, const CopyablePtr& rhs) {
-    // In theory the underlying type might have a special operator!=
-    // implementation which is not just !(x == y). Respect that.
-    return *lhs != *rhs;
-  }
-
- private:
-  std::unique_ptr<T> ptr_;
-};
-
-}  // namespace protozero
-
-#endif  // INCLUDE_PERFETTO_PROTOZERO_COPYABLE_PTR_H_
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_DATA_SOURCE_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_DATA_SOURCE_CONFIG_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class DataSourceConfig;
-class TestConfig;
-class TestConfig_DummyFields;
-class InterceptorConfig;
-class ChromeConfig;
-class SystemInfoConfig;
-enum DataSourceConfig_SessionInitiator : int;
-enum ChromeConfig_ClientPriority : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum DataSourceConfig_SessionInitiator : int {
-  DataSourceConfig_SessionInitiator_SESSION_INITIATOR_UNSPECIFIED = 0,
-  DataSourceConfig_SessionInitiator_SESSION_INITIATOR_TRUSTED_SYSTEM = 1,
-};
-
-class PERFETTO_EXPORT_COMPONENT DataSourceConfig : public ::protozero::CppMessageObj {
- public:
-  using SessionInitiator = DataSourceConfig_SessionInitiator;
-  static constexpr auto SESSION_INITIATOR_UNSPECIFIED = DataSourceConfig_SessionInitiator_SESSION_INITIATOR_UNSPECIFIED;
-  static constexpr auto SESSION_INITIATOR_TRUSTED_SYSTEM = DataSourceConfig_SessionInitiator_SESSION_INITIATOR_TRUSTED_SYSTEM;
-  static constexpr auto SessionInitiator_MIN = DataSourceConfig_SessionInitiator_SESSION_INITIATOR_UNSPECIFIED;
-  static constexpr auto SessionInitiator_MAX = DataSourceConfig_SessionInitiator_SESSION_INITIATOR_TRUSTED_SYSTEM;
-  enum FieldNumbers {
-    kNameFieldNumber = 1,
-    kTargetBufferFieldNumber = 2,
-    kTraceDurationMsFieldNumber = 3,
-    kPreferSuspendClockForDurationFieldNumber = 122,
-    kStopTimeoutMsFieldNumber = 7,
-    kEnableExtraGuardrailsFieldNumber = 6,
-    kSessionInitiatorFieldNumber = 8,
-    kTracingSessionIdFieldNumber = 4,
-    kFtraceConfigFieldNumber = 100,
-    kInodeFileConfigFieldNumber = 102,
-    kProcessStatsConfigFieldNumber = 103,
-    kSysStatsConfigFieldNumber = 104,
-    kHeapprofdConfigFieldNumber = 105,
-    kJavaHprofConfigFieldNumber = 110,
-    kAndroidPowerConfigFieldNumber = 106,
-    kAndroidLogConfigFieldNumber = 107,
-    kGpuCounterConfigFieldNumber = 108,
-    kAndroidGameInterventionListConfigFieldNumber = 116,
-    kPackagesListConfigFieldNumber = 109,
-    kPerfEventConfigFieldNumber = 111,
-    kVulkanMemoryConfigFieldNumber = 112,
-    kTrackEventConfigFieldNumber = 113,
-    kAndroidPolledStateConfigFieldNumber = 114,
-    kAndroidSystemPropertyConfigFieldNumber = 118,
-    kStatsdTracingConfigFieldNumber = 117,
-    kSystemInfoConfigFieldNumber = 119,
-    kChromeConfigFieldNumber = 101,
-    kInterceptorConfigFieldNumber = 115,
-    kNetworkPacketTraceConfigFieldNumber = 120,
-    kLegacyConfigFieldNumber = 1000,
-    kForTestingFieldNumber = 1001,
-  };
-
-  DataSourceConfig();
-  ~DataSourceConfig() override;
-  DataSourceConfig(DataSourceConfig&&) noexcept;
-  DataSourceConfig& operator=(DataSourceConfig&&);
-  DataSourceConfig(const DataSourceConfig&);
-  DataSourceConfig& operator=(const DataSourceConfig&);
-  bool operator==(const DataSourceConfig&) const;
-  bool operator!=(const DataSourceConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_name() const { return _has_field_[1]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
-
-  bool has_target_buffer() const { return _has_field_[2]; }
-  uint32_t target_buffer() const { return target_buffer_; }
-  void set_target_buffer(uint32_t value) { target_buffer_ = value; _has_field_.set(2); }
-
-  bool has_trace_duration_ms() const { return _has_field_[3]; }
-  uint32_t trace_duration_ms() const { return trace_duration_ms_; }
-  void set_trace_duration_ms(uint32_t value) { trace_duration_ms_ = value; _has_field_.set(3); }
-
-  bool has_prefer_suspend_clock_for_duration() const { return _has_field_[122]; }
-  bool prefer_suspend_clock_for_duration() const { return prefer_suspend_clock_for_duration_; }
-  void set_prefer_suspend_clock_for_duration(bool value) { prefer_suspend_clock_for_duration_ = value; _has_field_.set(122); }
-
-  bool has_stop_timeout_ms() const { return _has_field_[7]; }
-  uint32_t stop_timeout_ms() const { return stop_timeout_ms_; }
-  void set_stop_timeout_ms(uint32_t value) { stop_timeout_ms_ = value; _has_field_.set(7); }
-
-  bool has_enable_extra_guardrails() const { return _has_field_[6]; }
-  bool enable_extra_guardrails() const { return enable_extra_guardrails_; }
-  void set_enable_extra_guardrails(bool value) { enable_extra_guardrails_ = value; _has_field_.set(6); }
-
-  bool has_session_initiator() const { return _has_field_[8]; }
-  DataSourceConfig_SessionInitiator session_initiator() const { return session_initiator_; }
-  void set_session_initiator(DataSourceConfig_SessionInitiator value) { session_initiator_ = value; _has_field_.set(8); }
-
-  bool has_tracing_session_id() const { return _has_field_[4]; }
-  uint64_t tracing_session_id() const { return tracing_session_id_; }
-  void set_tracing_session_id(uint64_t value) { tracing_session_id_ = value; _has_field_.set(4); }
-
-  const std::string& ftrace_config_raw() const { return ftrace_config_; }
-  void set_ftrace_config_raw(const std::string& raw) { ftrace_config_ = raw; _has_field_.set(100); }
-
-  const std::string& inode_file_config_raw() const { return inode_file_config_; }
-  void set_inode_file_config_raw(const std::string& raw) { inode_file_config_ = raw; _has_field_.set(102); }
-
-  const std::string& process_stats_config_raw() const { return process_stats_config_; }
-  void set_process_stats_config_raw(const std::string& raw) { process_stats_config_ = raw; _has_field_.set(103); }
-
-  const std::string& sys_stats_config_raw() const { return sys_stats_config_; }
-  void set_sys_stats_config_raw(const std::string& raw) { sys_stats_config_ = raw; _has_field_.set(104); }
-
-  const std::string& heapprofd_config_raw() const { return heapprofd_config_; }
-  void set_heapprofd_config_raw(const std::string& raw) { heapprofd_config_ = raw; _has_field_.set(105); }
-
-  const std::string& java_hprof_config_raw() const { return java_hprof_config_; }
-  void set_java_hprof_config_raw(const std::string& raw) { java_hprof_config_ = raw; _has_field_.set(110); }
-
-  const std::string& android_power_config_raw() const { return android_power_config_; }
-  void set_android_power_config_raw(const std::string& raw) { android_power_config_ = raw; _has_field_.set(106); }
-
-  const std::string& android_log_config_raw() const { return android_log_config_; }
-  void set_android_log_config_raw(const std::string& raw) { android_log_config_ = raw; _has_field_.set(107); }
-
-  const std::string& gpu_counter_config_raw() const { return gpu_counter_config_; }
-  void set_gpu_counter_config_raw(const std::string& raw) { gpu_counter_config_ = raw; _has_field_.set(108); }
-
-  const std::string& android_game_intervention_list_config_raw() const { return android_game_intervention_list_config_; }
-  void set_android_game_intervention_list_config_raw(const std::string& raw) { android_game_intervention_list_config_ = raw; _has_field_.set(116); }
-
-  const std::string& packages_list_config_raw() const { return packages_list_config_; }
-  void set_packages_list_config_raw(const std::string& raw) { packages_list_config_ = raw; _has_field_.set(109); }
-
-  const std::string& perf_event_config_raw() const { return perf_event_config_; }
-  void set_perf_event_config_raw(const std::string& raw) { perf_event_config_ = raw; _has_field_.set(111); }
-
-  const std::string& vulkan_memory_config_raw() const { return vulkan_memory_config_; }
-  void set_vulkan_memory_config_raw(const std::string& raw) { vulkan_memory_config_ = raw; _has_field_.set(112); }
-
-  const std::string& track_event_config_raw() const { return track_event_config_; }
-  void set_track_event_config_raw(const std::string& raw) { track_event_config_ = raw; _has_field_.set(113); }
-
-  const std::string& android_polled_state_config_raw() const { return android_polled_state_config_; }
-  void set_android_polled_state_config_raw(const std::string& raw) { android_polled_state_config_ = raw; _has_field_.set(114); }
-
-  const std::string& android_system_property_config_raw() const { return android_system_property_config_; }
-  void set_android_system_property_config_raw(const std::string& raw) { android_system_property_config_ = raw; _has_field_.set(118); }
-
-  const std::string& statsd_tracing_config_raw() const { return statsd_tracing_config_; }
-  void set_statsd_tracing_config_raw(const std::string& raw) { statsd_tracing_config_ = raw; _has_field_.set(117); }
-
-  bool has_system_info_config() const { return _has_field_[119]; }
-  const SystemInfoConfig& system_info_config() const { return *system_info_config_; }
-  SystemInfoConfig* mutable_system_info_config() { _has_field_.set(119); return system_info_config_.get(); }
-
-  bool has_chrome_config() const { return _has_field_[101]; }
-  const ChromeConfig& chrome_config() const { return *chrome_config_; }
-  ChromeConfig* mutable_chrome_config() { _has_field_.set(101); return chrome_config_.get(); }
-
-  bool has_interceptor_config() const { return _has_field_[115]; }
-  const InterceptorConfig& interceptor_config() const { return *interceptor_config_; }
-  InterceptorConfig* mutable_interceptor_config() { _has_field_.set(115); return interceptor_config_.get(); }
-
-  const std::string& network_packet_trace_config_raw() const { return network_packet_trace_config_; }
-  void set_network_packet_trace_config_raw(const std::string& raw) { network_packet_trace_config_ = raw; _has_field_.set(120); }
-
-  bool has_legacy_config() const { return _has_field_[1000]; }
-  const std::string& legacy_config() const { return legacy_config_; }
-  void set_legacy_config(const std::string& value) { legacy_config_ = value; _has_field_.set(1000); }
-
-  bool has_for_testing() const { return _has_field_[1001]; }
-  const TestConfig& for_testing() const { return *for_testing_; }
-  TestConfig* mutable_for_testing() { _has_field_.set(1001); return for_testing_.get(); }
-
- private:
-  std::string name_{};
-  uint32_t target_buffer_{};
-  uint32_t trace_duration_ms_{};
-  bool prefer_suspend_clock_for_duration_{};
-  uint32_t stop_timeout_ms_{};
-  bool enable_extra_guardrails_{};
-  DataSourceConfig_SessionInitiator session_initiator_{};
-  uint64_t tracing_session_id_{};
-  std::string ftrace_config_;  // [lazy=true]
-  std::string inode_file_config_;  // [lazy=true]
-  std::string process_stats_config_;  // [lazy=true]
-  std::string sys_stats_config_;  // [lazy=true]
-  std::string heapprofd_config_;  // [lazy=true]
-  std::string java_hprof_config_;  // [lazy=true]
-  std::string android_power_config_;  // [lazy=true]
-  std::string android_log_config_;  // [lazy=true]
-  std::string gpu_counter_config_;  // [lazy=true]
-  std::string android_game_intervention_list_config_;  // [lazy=true]
-  std::string packages_list_config_;  // [lazy=true]
-  std::string perf_event_config_;  // [lazy=true]
-  std::string vulkan_memory_config_;  // [lazy=true]
-  std::string track_event_config_;  // [lazy=true]
-  std::string android_polled_state_config_;  // [lazy=true]
-  std::string android_system_property_config_;  // [lazy=true]
-  std::string statsd_tracing_config_;  // [lazy=true]
-  ::protozero::CopyablePtr<SystemInfoConfig> system_info_config_;
-  ::protozero::CopyablePtr<ChromeConfig> chrome_config_;
-  ::protozero::CopyablePtr<InterceptorConfig> interceptor_config_;
-  std::string network_packet_trace_config_;  // [lazy=true]
-  std::string legacy_config_{};
-  ::protozero::CopyablePtr<TestConfig> for_testing_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<1002> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_DATA_SOURCE_CONFIG_PROTO_CPP_H_
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef INCLUDE_PERFETTO_TRACING_CORE_DATA_SOURCE_CONFIG_H_
-#define INCLUDE_PERFETTO_TRACING_CORE_DATA_SOURCE_CONFIG_H_
-
-// Creates the aliases in the ::perfetto namespace, doing things like:
-// using ::perfetto::Foo = ::perfetto::protos::gen::Foo.
-// See comments in forward_decls.h for the historical reasons of this
-// indirection layer.
-// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
-
-// gen_amalgamated expanded: #include "protos/perfetto/config/data_source_config.gen.h"
-
-#endif  // INCLUDE_PERFETTO_TRACING_CORE_DATA_SOURCE_CONFIG_H_
 // gen_amalgamated begin header: include/perfetto/tracing/core/data_source_descriptor.h
 // gen_amalgamated begin header: gen/protos/perfetto/common/data_source_descriptor.gen.h
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
@@ -6548,6 +7138,16 @@ namespace perfetto {
 namespace protos {
 namespace gen {
 class DataSourceDescriptor;
+class VmProgram;
+class VmInstruction;
+class VmOpDel;
+class VmOpSet;
+class VmOpMerge;
+class VmOpRegLoad;
+class VmOpSelect;
+class VmOpSelect_PathComponent;
+enum VmInstruction_AbortLevel : int;
+enum VmCursorEnum : int;
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
@@ -6568,6 +7168,8 @@ class PERFETTO_EXPORT_COMPONENT DataSourceDescriptor : public ::protozero::CppMe
     kWillNotifyOnStopFieldNumber = 2,
     kWillNotifyOnStartFieldNumber = 3,
     kHandlesIncrementalStateClearFieldNumber = 4,
+    kNoFlushFieldNumber = 9,
+    kProtovmProgramFieldNumber = 10,
     kGpuCounterDescriptorFieldNumber = 5,
     kTrackEventDescriptorFieldNumber = 6,
     kFtraceDescriptorFieldNumber = 8,
@@ -6607,6 +7209,14 @@ class PERFETTO_EXPORT_COMPONENT DataSourceDescriptor : public ::protozero::CppMe
   bool handles_incremental_state_clear() const { return handles_incremental_state_clear_; }
   void set_handles_incremental_state_clear(bool value) { handles_incremental_state_clear_ = value; _has_field_.set(4); }
 
+  bool has_no_flush() const { return _has_field_[9]; }
+  bool no_flush() const { return no_flush_; }
+  void set_no_flush(bool value) { no_flush_ = value; _has_field_.set(9); }
+
+  bool has_protovm_program() const { return _has_field_[10]; }
+  const VmProgram& protovm_program() const { return *protovm_program_; }
+  VmProgram* mutable_protovm_program() { _has_field_.set(10); return protovm_program_.get(); }
+
   const std::string& gpu_counter_descriptor_raw() const { return gpu_counter_descriptor_; }
   void set_gpu_counter_descriptor_raw(const std::string& raw) { gpu_counter_descriptor_ = raw; _has_field_.set(5); }
 
@@ -6622,6 +7232,8 @@ class PERFETTO_EXPORT_COMPONENT DataSourceDescriptor : public ::protozero::CppMe
   bool will_notify_on_stop_{};
   bool will_notify_on_start_{};
   bool handles_incremental_state_clear_{};
+  bool no_flush_{};
+  ::protozero::CopyablePtr<VmProgram> protovm_program_;
   std::string gpu_counter_descriptor_;  // [lazy=true]
   std::string track_event_descriptor_;  // [lazy=true]
   std::string ftrace_descriptor_;  // [lazy=true]
@@ -6630,7 +7242,7 @@ class PERFETTO_EXPORT_COMPONENT DataSourceDescriptor : public ::protozero::CppMe
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<9> _has_field_{};
+  std::bitset<11> _has_field_{};
 };
 
 }  // namespace perfetto
@@ -6686,9 +7298,14 @@ namespace perfetto {
 namespace protos {
 namespace gen {
 class TraceConfig;
+class TraceConfig_Note;
+class PriorityBoostConfig;
+class TraceConfig_SessionSemaphore;
 class TraceConfig_CmdTraceStartDelay;
 class TraceConfig_AndroidReportConfig;
 class TraceConfig_TraceFilter;
+class TraceConfig_TraceFilter_StringFilterChain;
+class TraceConfig_TraceFilter_StringFilterRule;
 class TraceConfig_IncidentReportConfig;
 class TraceConfig_IncrementalStateConfig;
 class TraceConfig_TriggerConfig;
@@ -6702,17 +7319,27 @@ class DataSourceConfig;
 class TestConfig;
 class TestConfig_DummyFields;
 class InterceptorConfig;
+class ConsoleConfig;
 class ChromeConfig;
 class SystemInfoConfig;
+class ProtoVmConfig;
 class TraceConfig_BufferConfig;
 enum TraceConfig_LockdownModeOperation : int;
 enum TraceConfig_CompressionType : int;
 enum TraceConfig_StatsdLogging : int;
+enum TraceConfig_WriteFlushMode : int;
+enum TraceConfig_FFlushMode : int;
+enum PriorityBoostConfig_BoostPolicy : int;
+enum TraceConfig_TraceFilter_StringFilterPolicy : int;
+enum SemanticType : int;
 enum TraceConfig_TriggerConfig_TriggerMode : int;
 enum BuiltinClock : int;
 enum DataSourceConfig_SessionInitiator : int;
+enum DataSourceConfig_BufferExhaustedPolicy : int;
+enum ConsoleConfig_Output : int;
 enum ChromeConfig_ClientPriority : int;
 enum TraceConfig_BufferConfig_FillPolicy : int;
+enum TraceConfig_BufferConfig_ExperimentalMode : int;
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
@@ -6738,16 +7365,41 @@ enum TraceConfig_StatsdLogging : int {
   TraceConfig_StatsdLogging_STATSD_LOGGING_ENABLED = 1,
   TraceConfig_StatsdLogging_STATSD_LOGGING_DISABLED = 2,
 };
+enum TraceConfig_WriteFlushMode : int {
+  TraceConfig_WriteFlushMode_WRITE_FLUSH_UNSPECIFIED = 0,
+  TraceConfig_WriteFlushMode_WRITE_FLUSH_AUTO = 1,
+  TraceConfig_WriteFlushMode_WRITE_FLUSH_DISABLED = 2,
+  TraceConfig_WriteFlushMode_WRITE_FLUSH_ENABLED = 3,
+};
+enum TraceConfig_FFlushMode : int {
+  TraceConfig_FFlushMode_FFLUSH_UNSPECIFIED = 0,
+  TraceConfig_FFlushMode_FFLUSH_DISABLED = 1,
+  TraceConfig_FFlushMode_FFLUSH_ENABLED = 2,
+};
+enum TraceConfig_TraceFilter_StringFilterPolicy : int {
+  TraceConfig_TraceFilter_StringFilterPolicy_SFP_UNSPECIFIED = 0,
+  TraceConfig_TraceFilter_StringFilterPolicy_SFP_MATCH_REDACT_GROUPS = 1,
+  TraceConfig_TraceFilter_StringFilterPolicy_SFP_ATRACE_MATCH_REDACT_GROUPS = 2,
+  TraceConfig_TraceFilter_StringFilterPolicy_SFP_MATCH_BREAK = 3,
+  TraceConfig_TraceFilter_StringFilterPolicy_SFP_ATRACE_MATCH_BREAK = 4,
+  TraceConfig_TraceFilter_StringFilterPolicy_SFP_ATRACE_REPEATED_SEARCH_REDACT_GROUPS = 5,
+};
 enum TraceConfig_TriggerConfig_TriggerMode : int {
   TraceConfig_TriggerConfig_TriggerMode_UNSPECIFIED = 0,
   TraceConfig_TriggerConfig_TriggerMode_START_TRACING = 1,
   TraceConfig_TriggerConfig_TriggerMode_STOP_TRACING = 2,
+  TraceConfig_TriggerConfig_TriggerMode_CLONE_SNAPSHOT = 4,
 };
 enum TraceConfig_BufferConfig_FillPolicy : int {
   TraceConfig_BufferConfig_FillPolicy_UNSPECIFIED = 0,
   TraceConfig_BufferConfig_FillPolicy_RING_BUFFER = 1,
   TraceConfig_BufferConfig_FillPolicy_DISCARD = 2,
 };
+enum TraceConfig_BufferConfig_ExperimentalMode : int {
+  TraceConfig_BufferConfig_ExperimentalMode_MODE_UNSPECIFIED = 0,
+  TraceConfig_BufferConfig_ExperimentalMode_TRACE_BUFFER_V2 = 1,
+  TraceConfig_BufferConfig_ExperimentalMode_TRACE_BUFFER_V2_SHADOW_MODE = 2,
+};
 
 class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj {
  public:
@@ -6763,6 +7415,8 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj
   using TraceFilter = TraceConfig_TraceFilter;
   using AndroidReportConfig = TraceConfig_AndroidReportConfig;
   using CmdTraceStartDelay = TraceConfig_CmdTraceStartDelay;
+  using SessionSemaphore = TraceConfig_SessionSemaphore;
+  using Note = TraceConfig_Note;
   using LockdownModeOperation = TraceConfig_LockdownModeOperation;
   static constexpr auto LOCKDOWN_UNCHANGED = TraceConfig_LockdownModeOperation_LOCKDOWN_UNCHANGED;
   static constexpr auto LOCKDOWN_CLEAR = TraceConfig_LockdownModeOperation_LOCKDOWN_CLEAR;
@@ -6780,6 +7434,19 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj
   static constexpr auto STATSD_LOGGING_DISABLED = TraceConfig_StatsdLogging_STATSD_LOGGING_DISABLED;
   static constexpr auto StatsdLogging_MIN = TraceConfig_StatsdLogging_STATSD_LOGGING_UNSPECIFIED;
   static constexpr auto StatsdLogging_MAX = TraceConfig_StatsdLogging_STATSD_LOGGING_DISABLED;
+  using WriteFlushMode = TraceConfig_WriteFlushMode;
+  static constexpr auto WRITE_FLUSH_UNSPECIFIED = TraceConfig_WriteFlushMode_WRITE_FLUSH_UNSPECIFIED;
+  static constexpr auto WRITE_FLUSH_AUTO = TraceConfig_WriteFlushMode_WRITE_FLUSH_AUTO;
+  static constexpr auto WRITE_FLUSH_DISABLED = TraceConfig_WriteFlushMode_WRITE_FLUSH_DISABLED;
+  static constexpr auto WRITE_FLUSH_ENABLED = TraceConfig_WriteFlushMode_WRITE_FLUSH_ENABLED;
+  static constexpr auto WriteFlushMode_MIN = TraceConfig_WriteFlushMode_WRITE_FLUSH_UNSPECIFIED;
+  static constexpr auto WriteFlushMode_MAX = TraceConfig_WriteFlushMode_WRITE_FLUSH_ENABLED;
+  using FFlushMode = TraceConfig_FFlushMode;
+  static constexpr auto FFLUSH_UNSPECIFIED = TraceConfig_FFlushMode_FFLUSH_UNSPECIFIED;
+  static constexpr auto FFLUSH_DISABLED = TraceConfig_FFlushMode_FFLUSH_DISABLED;
+  static constexpr auto FFLUSH_ENABLED = TraceConfig_FFlushMode_FFLUSH_ENABLED;
+  static constexpr auto FFlushMode_MIN = TraceConfig_FFlushMode_FFLUSH_UNSPECIFIED;
+  static constexpr auto FFlushMode_MAX = TraceConfig_FFlushMode_FFLUSH_ENABLED;
   enum FieldNumbers {
     kBuffersFieldNumber = 1,
     kDataSourcesFieldNumber = 2,
@@ -6801,6 +7468,7 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj
     kDataSourceStopTimeoutMsFieldNumber = 23,
     kNotifyTraceurFieldNumber = 16,
     kBugreportScoreFieldNumber = 30,
+    kBugreportFilenameFieldNumber = 38,
     kTriggerConfigFieldNumber = 17,
     kActivateTriggersFieldNumber = 18,
     kIncrementalStateConfigFieldNumber = 21,
@@ -6814,6 +7482,13 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj
     kTraceFilterFieldNumber = 33,
     kAndroidReportConfigFieldNumber = 34,
     kCmdTraceStartDelayFieldNumber = 35,
+    kSessionSemaphoresFieldNumber = 39,
+    kPriorityBoostFieldNumber = 40,
+    kExclusivePrioFieldNumber = 41,
+    kWriteFlushModeFieldNumber = 44,
+    kFflushPostWriteFieldNumber = 45,
+    kTraceAllMachinesFieldNumber = 43,
+    kNotesFieldNumber = 46,
   };
 
   TraceConfig();
@@ -6916,6 +7591,10 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj
   int32_t bugreport_score() const { return bugreport_score_; }
   void set_bugreport_score(int32_t value) { bugreport_score_ = value; _has_field_.set(30); }
 
+  bool has_bugreport_filename() const { return _has_field_[38]; }
+  const std::string& bugreport_filename() const { return bugreport_filename_; }
+  void set_bugreport_filename(const std::string& value) { bugreport_filename_ = value; _has_field_.set(38); }
+
   bool has_trigger_config() const { return _has_field_[17]; }
   const TraceConfig_TriggerConfig& trigger_config() const { return *trigger_config_; }
   TraceConfig_TriggerConfig* mutable_trigger_config() { _has_field_.set(17); return trigger_config_.get(); }
@@ -6971,6 +7650,38 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj
   const TraceConfig_CmdTraceStartDelay& cmd_trace_start_delay() const { return *cmd_trace_start_delay_; }
   TraceConfig_CmdTraceStartDelay* mutable_cmd_trace_start_delay() { _has_field_.set(35); return cmd_trace_start_delay_.get(); }
 
+  const std::vector<TraceConfig_SessionSemaphore>& session_semaphores() const { return session_semaphores_; }
+  std::vector<TraceConfig_SessionSemaphore>* mutable_session_semaphores() { return &session_semaphores_; }
+  int session_semaphores_size() const;
+  void clear_session_semaphores();
+  TraceConfig_SessionSemaphore* add_session_semaphores();
+
+  bool has_priority_boost() const { return _has_field_[40]; }
+  const PriorityBoostConfig& priority_boost() const { return *priority_boost_; }
+  PriorityBoostConfig* mutable_priority_boost() { _has_field_.set(40); return priority_boost_.get(); }
+
+  bool has_exclusive_prio() const { return _has_field_[41]; }
+  uint32_t exclusive_prio() const { return exclusive_prio_; }
+  void set_exclusive_prio(uint32_t value) { exclusive_prio_ = value; _has_field_.set(41); }
+
+  bool has_write_flush_mode() const { return _has_field_[44]; }
+  TraceConfig_WriteFlushMode write_flush_mode() const { return write_flush_mode_; }
+  void set_write_flush_mode(TraceConfig_WriteFlushMode value) { write_flush_mode_ = value; _has_field_.set(44); }
+
+  bool has_fflush_post_write() const { return _has_field_[45]; }
+  TraceConfig_FFlushMode fflush_post_write() const { return fflush_post_write_; }
+  void set_fflush_post_write(TraceConfig_FFlushMode value) { fflush_post_write_ = value; _has_field_.set(45); }
+
+  bool has_trace_all_machines() const { return _has_field_[43]; }
+  bool trace_all_machines() const { return trace_all_machines_; }
+  void set_trace_all_machines(bool value) { trace_all_machines_ = value; _has_field_.set(43); }
+
+  const std::vector<TraceConfig_Note>& notes() const { return notes_; }
+  std::vector<TraceConfig_Note>* mutable_notes() { return &notes_; }
+  int notes_size() const;
+  void clear_notes();
+  TraceConfig_Note* add_notes();
+
  private:
   std::vector<TraceConfig_BufferConfig> buffers_;
   std::vector<TraceConfig_DataSource> data_sources_;
@@ -6992,6 +7703,7 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj
   uint32_t data_source_stop_timeout_ms_{};
   bool notify_traceur_{};
   int32_t bugreport_score_{};
+  std::string bugreport_filename_{};
   ::protozero::CopyablePtr<TraceConfig_TriggerConfig> trigger_config_;
   std::vector<std::string> activate_triggers_;
   ::protozero::CopyablePtr<TraceConfig_IncrementalStateConfig> incremental_state_config_;
@@ -7005,12 +7717,101 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj
   ::protozero::CopyablePtr<TraceConfig_TraceFilter> trace_filter_;
   ::protozero::CopyablePtr<TraceConfig_AndroidReportConfig> android_report_config_;
   ::protozero::CopyablePtr<TraceConfig_CmdTraceStartDelay> cmd_trace_start_delay_;
+  std::vector<TraceConfig_SessionSemaphore> session_semaphores_;
+  ::protozero::CopyablePtr<PriorityBoostConfig> priority_boost_;
+  uint32_t exclusive_prio_{};
+  TraceConfig_WriteFlushMode write_flush_mode_{};
+  TraceConfig_FFlushMode fflush_post_write_{};
+  bool trace_all_machines_{};
+  std::vector<TraceConfig_Note> notes_;
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<47> _has_field_{};
+};
+
+
+class PERFETTO_EXPORT_COMPONENT TraceConfig_Note : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+
+  TraceConfig_Note();
+  ~TraceConfig_Note() override;
+  TraceConfig_Note(TraceConfig_Note&&) noexcept;
+  TraceConfig_Note& operator=(TraceConfig_Note&&);
+  TraceConfig_Note(const TraceConfig_Note&);
+  TraceConfig_Note& operator=(const TraceConfig_Note&);
+  bool operator==(const TraceConfig_Note&) const;
+  bool operator!=(const TraceConfig_Note& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_key() const { return _has_field_[1]; }
+  const std::string& key() const { return key_; }
+  void set_key(const std::string& value) { key_ = value; _has_field_.set(1); }
+
+  bool has_value() const { return _has_field_[2]; }
+  const std::string& value() const { return value_; }
+  void set_value(const std::string& value) { value_ = value; _has_field_.set(2); }
+
+ private:
+  std::string key_{};
+  std::string value_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<3> _has_field_{};
+};
+
+
+class PERFETTO_EXPORT_COMPONENT TraceConfig_SessionSemaphore : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kNameFieldNumber = 1,
+    kMaxOtherSessionCountFieldNumber = 2,
+  };
+
+  TraceConfig_SessionSemaphore();
+  ~TraceConfig_SessionSemaphore() override;
+  TraceConfig_SessionSemaphore(TraceConfig_SessionSemaphore&&) noexcept;
+  TraceConfig_SessionSemaphore& operator=(TraceConfig_SessionSemaphore&&);
+  TraceConfig_SessionSemaphore(const TraceConfig_SessionSemaphore&);
+  TraceConfig_SessionSemaphore& operator=(const TraceConfig_SessionSemaphore&);
+  bool operator==(const TraceConfig_SessionSemaphore&) const;
+  bool operator!=(const TraceConfig_SessionSemaphore& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_name() const { return _has_field_[1]; }
+  const std::string& name() const { return name_; }
+  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
+
+  bool has_max_other_session_count() const { return _has_field_[2]; }
+  uint64_t max_other_session_count() const { return max_other_session_count_; }
+  void set_max_other_session_count(uint64_t value) { max_other_session_count_ = value; _has_field_.set(2); }
+
+ private:
+  std::string name_{};
+  uint64_t max_other_session_count_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<37> _has_field_{};
+  std::bitset<3> _has_field_{};
 };
 
 
@@ -7110,8 +7911,23 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig_AndroidReportConfig : public ::proto
 
 class PERFETTO_EXPORT_COMPONENT TraceConfig_TraceFilter : public ::protozero::CppMessageObj {
  public:
+  using StringFilterRule = TraceConfig_TraceFilter_StringFilterRule;
+  using StringFilterChain = TraceConfig_TraceFilter_StringFilterChain;
+  using StringFilterPolicy = TraceConfig_TraceFilter_StringFilterPolicy;
+  static constexpr auto SFP_UNSPECIFIED = TraceConfig_TraceFilter_StringFilterPolicy_SFP_UNSPECIFIED;
+  static constexpr auto SFP_MATCH_REDACT_GROUPS = TraceConfig_TraceFilter_StringFilterPolicy_SFP_MATCH_REDACT_GROUPS;
+  static constexpr auto SFP_ATRACE_MATCH_REDACT_GROUPS = TraceConfig_TraceFilter_StringFilterPolicy_SFP_ATRACE_MATCH_REDACT_GROUPS;
+  static constexpr auto SFP_MATCH_BREAK = TraceConfig_TraceFilter_StringFilterPolicy_SFP_MATCH_BREAK;
+  static constexpr auto SFP_ATRACE_MATCH_BREAK = TraceConfig_TraceFilter_StringFilterPolicy_SFP_ATRACE_MATCH_BREAK;
+  static constexpr auto SFP_ATRACE_REPEATED_SEARCH_REDACT_GROUPS = TraceConfig_TraceFilter_StringFilterPolicy_SFP_ATRACE_REPEATED_SEARCH_REDACT_GROUPS;
+  static constexpr auto StringFilterPolicy_MIN = TraceConfig_TraceFilter_StringFilterPolicy_SFP_UNSPECIFIED;
+  static constexpr auto StringFilterPolicy_MAX = TraceConfig_TraceFilter_StringFilterPolicy_SFP_ATRACE_REPEATED_SEARCH_REDACT_GROUPS;
   enum FieldNumbers {
     kBytecodeFieldNumber = 1,
+    kBytecodeV2FieldNumber = 2,
+    kStringFilterChainFieldNumber = 3,
+    kBytecodeOverlayV54FieldNumber = 4,
+    kStringFilterChainV54FieldNumber = 5,
   };
 
   TraceConfig_TraceFilter();
@@ -7133,8 +7949,67 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig_TraceFilter : public ::protozero::Cp
   void set_bytecode(const std::string& value) { bytecode_ = value; _has_field_.set(1); }
   void set_bytecode(const void* p, size_t s) { bytecode_.assign(reinterpret_cast<const char*>(p), s); _has_field_.set(1); }
 
+  bool has_bytecode_v2() const { return _has_field_[2]; }
+  const std::string& bytecode_v2() const { return bytecode_v2_; }
+  void set_bytecode_v2(const std::string& value) { bytecode_v2_ = value; _has_field_.set(2); }
+  void set_bytecode_v2(const void* p, size_t s) { bytecode_v2_.assign(reinterpret_cast<const char*>(p), s); _has_field_.set(2); }
+
+  bool has_string_filter_chain() const { return _has_field_[3]; }
+  const TraceConfig_TraceFilter_StringFilterChain& string_filter_chain() const { return *string_filter_chain_; }
+  TraceConfig_TraceFilter_StringFilterChain* mutable_string_filter_chain() { _has_field_.set(3); return string_filter_chain_.get(); }
+
+  bool has_bytecode_overlay_v54() const { return _has_field_[4]; }
+  const std::string& bytecode_overlay_v54() const { return bytecode_overlay_v54_; }
+  void set_bytecode_overlay_v54(const std::string& value) { bytecode_overlay_v54_ = value; _has_field_.set(4); }
+  void set_bytecode_overlay_v54(const void* p, size_t s) { bytecode_overlay_v54_.assign(reinterpret_cast<const char*>(p), s); _has_field_.set(4); }
+
+  bool has_string_filter_chain_v54() const { return _has_field_[5]; }
+  const TraceConfig_TraceFilter_StringFilterChain& string_filter_chain_v54() const { return *string_filter_chain_v54_; }
+  TraceConfig_TraceFilter_StringFilterChain* mutable_string_filter_chain_v54() { _has_field_.set(5); return string_filter_chain_v54_.get(); }
+
  private:
   std::string bytecode_{};
+  std::string bytecode_v2_{};
+  ::protozero::CopyablePtr<TraceConfig_TraceFilter_StringFilterChain> string_filter_chain_;
+  std::string bytecode_overlay_v54_{};
+  ::protozero::CopyablePtr<TraceConfig_TraceFilter_StringFilterChain> string_filter_chain_v54_;
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<6> _has_field_{};
+};
+
+
+class PERFETTO_EXPORT_COMPONENT TraceConfig_TraceFilter_StringFilterChain : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kRulesFieldNumber = 1,
+  };
+
+  TraceConfig_TraceFilter_StringFilterChain();
+  ~TraceConfig_TraceFilter_StringFilterChain() override;
+  TraceConfig_TraceFilter_StringFilterChain(TraceConfig_TraceFilter_StringFilterChain&&) noexcept;
+  TraceConfig_TraceFilter_StringFilterChain& operator=(TraceConfig_TraceFilter_StringFilterChain&&);
+  TraceConfig_TraceFilter_StringFilterChain(const TraceConfig_TraceFilter_StringFilterChain&);
+  TraceConfig_TraceFilter_StringFilterChain& operator=(const TraceConfig_TraceFilter_StringFilterChain&);
+  bool operator==(const TraceConfig_TraceFilter_StringFilterChain&) const;
+  bool operator!=(const TraceConfig_TraceFilter_StringFilterChain& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  const std::vector<TraceConfig_TraceFilter_StringFilterRule>& rules() const { return rules_; }
+  std::vector<TraceConfig_TraceFilter_StringFilterRule>* mutable_rules() { return &rules_; }
+  int rules_size() const;
+  void clear_rules();
+  TraceConfig_TraceFilter_StringFilterRule* add_rules();
+
+ private:
+  std::vector<TraceConfig_TraceFilter_StringFilterRule> rules_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
@@ -7144,6 +8019,68 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig_TraceFilter : public ::protozero::Cp
 };
 
 
+class PERFETTO_EXPORT_COMPONENT TraceConfig_TraceFilter_StringFilterRule : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kPolicyFieldNumber = 1,
+    kRegexPatternFieldNumber = 2,
+    kAtracePayloadStartsWithFieldNumber = 3,
+    kNameFieldNumber = 4,
+    kSemanticTypeFieldNumber = 5,
+  };
+
+  TraceConfig_TraceFilter_StringFilterRule();
+  ~TraceConfig_TraceFilter_StringFilterRule() override;
+  TraceConfig_TraceFilter_StringFilterRule(TraceConfig_TraceFilter_StringFilterRule&&) noexcept;
+  TraceConfig_TraceFilter_StringFilterRule& operator=(TraceConfig_TraceFilter_StringFilterRule&&);
+  TraceConfig_TraceFilter_StringFilterRule(const TraceConfig_TraceFilter_StringFilterRule&);
+  TraceConfig_TraceFilter_StringFilterRule& operator=(const TraceConfig_TraceFilter_StringFilterRule&);
+  bool operator==(const TraceConfig_TraceFilter_StringFilterRule&) const;
+  bool operator!=(const TraceConfig_TraceFilter_StringFilterRule& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_policy() const { return _has_field_[1]; }
+  TraceConfig_TraceFilter_StringFilterPolicy policy() const { return policy_; }
+  void set_policy(TraceConfig_TraceFilter_StringFilterPolicy value) { policy_ = value; _has_field_.set(1); }
+
+  bool has_regex_pattern() const { return _has_field_[2]; }
+  const std::string& regex_pattern() const { return regex_pattern_; }
+  void set_regex_pattern(const std::string& value) { regex_pattern_ = value; _has_field_.set(2); }
+
+  bool has_atrace_payload_starts_with() const { return _has_field_[3]; }
+  const std::string& atrace_payload_starts_with() const { return atrace_payload_starts_with_; }
+  void set_atrace_payload_starts_with(const std::string& value) { atrace_payload_starts_with_ = value; _has_field_.set(3); }
+
+  bool has_name() const { return _has_field_[4]; }
+  const std::string& name() const { return name_; }
+  void set_name(const std::string& value) { name_ = value; _has_field_.set(4); }
+
+  const std::vector<SemanticType>& semantic_type() const { return semantic_type_; }
+  std::vector<SemanticType>* mutable_semantic_type() { return &semantic_type_; }
+  int semantic_type_size() const { return static_cast<int>(semantic_type_.size()); }
+  void clear_semantic_type() { semantic_type_.clear(); }
+  void add_semantic_type(SemanticType value) { semantic_type_.emplace_back(value); }
+  SemanticType* add_semantic_type() { semantic_type_.emplace_back(); return &semantic_type_.back(); }
+
+ private:
+  TraceConfig_TraceFilter_StringFilterPolicy policy_{};
+  std::string regex_pattern_{};
+  std::string atrace_payload_starts_with_{};
+  std::string name_{};
+  std::vector<SemanticType> semantic_type_;
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<6> _has_field_{};
+};
+
+
 class PERFETTO_EXPORT_COMPONENT TraceConfig_IncidentReportConfig : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
@@ -7245,10 +8182,12 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig_TriggerConfig : public ::protozero::
   static constexpr auto UNSPECIFIED = TraceConfig_TriggerConfig_TriggerMode_UNSPECIFIED;
   static constexpr auto START_TRACING = TraceConfig_TriggerConfig_TriggerMode_START_TRACING;
   static constexpr auto STOP_TRACING = TraceConfig_TriggerConfig_TriggerMode_STOP_TRACING;
+  static constexpr auto CLONE_SNAPSHOT = TraceConfig_TriggerConfig_TriggerMode_CLONE_SNAPSHOT;
   static constexpr auto TriggerMode_MIN = TraceConfig_TriggerConfig_TriggerMode_UNSPECIFIED;
-  static constexpr auto TriggerMode_MAX = TraceConfig_TriggerConfig_TriggerMode_STOP_TRACING;
+  static constexpr auto TriggerMode_MAX = TraceConfig_TriggerConfig_TriggerMode_CLONE_SNAPSHOT;
   enum FieldNumbers {
     kTriggerModeFieldNumber = 1,
+    kUseCloneSnapshotIfAvailableFieldNumber = 5,
     kTriggersFieldNumber = 2,
     kTriggerTimeoutMsFieldNumber = 3,
   };
@@ -7271,6 +8210,10 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig_TriggerConfig : public ::protozero::
   TraceConfig_TriggerConfig_TriggerMode trigger_mode() const { return trigger_mode_; }
   void set_trigger_mode(TraceConfig_TriggerConfig_TriggerMode value) { trigger_mode_ = value; _has_field_.set(1); }
 
+  bool has_use_clone_snapshot_if_available() const { return _has_field_[5]; }
+  bool use_clone_snapshot_if_available() const { return use_clone_snapshot_if_available_; }
+  void set_use_clone_snapshot_if_available(bool value) { use_clone_snapshot_if_available_ = value; _has_field_.set(5); }
+
   const std::vector<TraceConfig_TriggerConfig_Trigger>& triggers() const { return triggers_; }
   std::vector<TraceConfig_TriggerConfig_Trigger>* mutable_triggers() { return &triggers_; }
   int triggers_size() const;
@@ -7283,6 +8226,7 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig_TriggerConfig : public ::protozero::
 
  private:
   TraceConfig_TriggerConfig_TriggerMode trigger_mode_{};
+  bool use_clone_snapshot_if_available_{};
   std::vector<TraceConfig_TriggerConfig_Trigger> triggers_;
   uint32_t trigger_timeout_ms_{};
 
@@ -7290,7 +8234,7 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig_TriggerConfig : public ::protozero::
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<4> _has_field_{};
+  std::bitset<6> _has_field_{};
 };
 
 
@@ -7504,6 +8448,7 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig_BuiltinDataSource : public ::protoze
     kPrimaryTraceClockFieldNumber = 5,
     kSnapshotIntervalMsFieldNumber = 6,
     kPreferSuspendClockForSnapshotFieldNumber = 7,
+    kDisableChunkUsageHistogramsFieldNumber = 8,
   };
 
   TraceConfig_BuiltinDataSource();
@@ -7548,6 +8493,10 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig_BuiltinDataSource : public ::protoze
   bool prefer_suspend_clock_for_snapshot() const { return prefer_suspend_clock_for_snapshot_; }
   void set_prefer_suspend_clock_for_snapshot(bool value) { prefer_suspend_clock_for_snapshot_ = value; _has_field_.set(7); }
 
+  bool has_disable_chunk_usage_histograms() const { return _has_field_[8]; }
+  bool disable_chunk_usage_histograms() const { return disable_chunk_usage_histograms_; }
+  void set_disable_chunk_usage_histograms(bool value) { disable_chunk_usage_histograms_ = value; _has_field_.set(8); }
+
  private:
   bool disable_clock_snapshotting_{};
   bool disable_trace_config_{};
@@ -7556,12 +8505,13 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig_BuiltinDataSource : public ::protoze
   BuiltinClock primary_trace_clock_{};
   uint32_t snapshot_interval_ms_{};
   bool prefer_suspend_clock_for_snapshot_{};
+  bool disable_chunk_usage_histograms_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<8> _has_field_{};
+  std::bitset<9> _has_field_{};
 };
 
 
@@ -7571,6 +8521,7 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig_DataSource : public ::protozero::Cpp
     kConfigFieldNumber = 1,
     kProducerNameFilterFieldNumber = 2,
     kProducerNameRegexFilterFieldNumber = 3,
+    kMachineNameFilterFieldNumber = 4,
   };
 
   TraceConfig_DataSource();
@@ -7605,16 +8556,24 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig_DataSource : public ::protozero::Cpp
   void add_producer_name_regex_filter(std::string value) { producer_name_regex_filter_.emplace_back(value); }
   std::string* add_producer_name_regex_filter() { producer_name_regex_filter_.emplace_back(); return &producer_name_regex_filter_.back(); }
 
+  const std::vector<std::string>& machine_name_filter() const { return machine_name_filter_; }
+  std::vector<std::string>* mutable_machine_name_filter() { return &machine_name_filter_; }
+  int machine_name_filter_size() const { return static_cast<int>(machine_name_filter_.size()); }
+  void clear_machine_name_filter() { machine_name_filter_.clear(); }
+  void add_machine_name_filter(std::string value) { machine_name_filter_.emplace_back(value); }
+  std::string* add_machine_name_filter() { machine_name_filter_.emplace_back(); return &machine_name_filter_.back(); }
+
  private:
   ::protozero::CopyablePtr<DataSourceConfig> config_;
   std::vector<std::string> producer_name_filter_;
   std::vector<std::string> producer_name_regex_filter_;
+  std::vector<std::string> machine_name_filter_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<4> _has_field_{};
+  std::bitset<5> _has_field_{};
 };
 
 
@@ -7626,9 +8585,19 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig_BufferConfig : public ::protozero::C
   static constexpr auto DISCARD = TraceConfig_BufferConfig_FillPolicy_DISCARD;
   static constexpr auto FillPolicy_MIN = TraceConfig_BufferConfig_FillPolicy_UNSPECIFIED;
   static constexpr auto FillPolicy_MAX = TraceConfig_BufferConfig_FillPolicy_DISCARD;
+  using ExperimentalMode = TraceConfig_BufferConfig_ExperimentalMode;
+  static constexpr auto MODE_UNSPECIFIED = TraceConfig_BufferConfig_ExperimentalMode_MODE_UNSPECIFIED;
+  static constexpr auto TRACE_BUFFER_V2 = TraceConfig_BufferConfig_ExperimentalMode_TRACE_BUFFER_V2;
+  static constexpr auto TRACE_BUFFER_V2_SHADOW_MODE = TraceConfig_BufferConfig_ExperimentalMode_TRACE_BUFFER_V2_SHADOW_MODE;
+  static constexpr auto ExperimentalMode_MIN = TraceConfig_BufferConfig_ExperimentalMode_MODE_UNSPECIFIED;
+  static constexpr auto ExperimentalMode_MAX = TraceConfig_BufferConfig_ExperimentalMode_TRACE_BUFFER_V2_SHADOW_MODE;
   enum FieldNumbers {
     kSizeKbFieldNumber = 1,
     kFillPolicyFieldNumber = 4,
+    kTransferOnCloneFieldNumber = 5,
+    kClearBeforeCloneFieldNumber = 6,
+    kNameFieldNumber = 7,
+    kExperimentalModeFieldNumber = 8,
   };
 
   TraceConfig_BufferConfig();
@@ -7653,15 +8622,35 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig_BufferConfig : public ::protozero::C
   TraceConfig_BufferConfig_FillPolicy fill_policy() const { return fill_policy_; }
   void set_fill_policy(TraceConfig_BufferConfig_FillPolicy value) { fill_policy_ = value; _has_field_.set(4); }
 
+  bool has_transfer_on_clone() const { return _has_field_[5]; }
+  bool transfer_on_clone() const { return transfer_on_clone_; }
+  void set_transfer_on_clone(bool value) { transfer_on_clone_ = value; _has_field_.set(5); }
+
+  bool has_clear_before_clone() const { return _has_field_[6]; }
+  bool clear_before_clone() const { return clear_before_clone_; }
+  void set_clear_before_clone(bool value) { clear_before_clone_ = value; _has_field_.set(6); }
+
+  bool has_name() const { return _has_field_[7]; }
+  const std::string& name() const { return name_; }
+  void set_name(const std::string& value) { name_ = value; _has_field_.set(7); }
+
+  bool has_experimental_mode() const { return _has_field_[8]; }
+  TraceConfig_BufferConfig_ExperimentalMode experimental_mode() const { return experimental_mode_; }
+  void set_experimental_mode(TraceConfig_BufferConfig_ExperimentalMode value) { experimental_mode_ = value; _has_field_.set(8); }
+
  private:
   uint32_t size_kb_{};
   TraceConfig_BufferConfig_FillPolicy fill_policy_{};
+  bool transfer_on_clone_{};
+  bool clear_before_clone_{};
+  std::string name_{};
+  TraceConfig_BufferConfig_ExperimentalMode experimental_mode_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<5> _has_field_{};
+  std::bitset<9> _has_field_{};
 };
 
 }  // namespace perfetto
@@ -7696,8 +8685,175 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig_BufferConfig : public ::protozero::C
 
 // gen_amalgamated expanded: #include "protos/perfetto/config/trace_config.gen.h"
 
+namespace perfetto {
+
+inline TraceConfig::TriggerConfig::TriggerMode GetTriggerMode(
+    const TraceConfig& cfg) {
+  auto mode = cfg.trigger_config().trigger_mode();
+  if (cfg.trigger_config().use_clone_snapshot_if_available())
+    mode = TraceConfig::TriggerConfig::CLONE_SNAPSHOT;
+  return mode;
+}
+
+}  // namespace perfetto
+
 #endif  // INCLUDE_PERFETTO_TRACING_CORE_TRACE_CONFIG_H_
 // gen_amalgamated begin header: include/perfetto/tracing/data_source.h
+// gen_amalgamated begin header: include/perfetto/tracing/backend_type.h
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_TRACING_BACKEND_TYPE_H_
+#define INCLUDE_PERFETTO_TRACING_BACKEND_TYPE_H_
+
+#include <stdint.h>
+
+namespace perfetto {
+
+enum BackendType : uint32_t {
+  kUnspecifiedBackend = 0,
+
+  // Connects to a previously-initialized perfetto tracing backend for
+  // in-process. If the in-process backend has not been previously initialized
+  // it will do so and create the tracing service on a dedicated thread.
+  kInProcessBackend = 1 << 0,
+
+  // Connects to the system tracing service (e.g. on Linux/Android/Mac uses a
+  // named UNIX socket).
+  kSystemBackend = 1 << 1,
+
+  // Used to provide a custom IPC transport to connect to the service.
+  // TracingInitArgs::custom_backend must be non-null and point to an
+  // indefinitely lived instance.
+  kCustomBackend = 1 << 2,
+};
+
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_TRACING_BACKEND_TYPE_H_
+// gen_amalgamated begin header: include/perfetto/tracing/core/flush_flags.h
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_TRACING_CORE_FLUSH_FLAGS_H_
+#define INCLUDE_PERFETTO_TRACING_CORE_FLUSH_FLAGS_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+namespace perfetto {
+
+// This class is a wrapper around the uint64_t flags that are sent across the
+// tracing protocol whenenver a flush occurs. It helps determining the reason
+// and initiator of the flush.
+// NOTE: the values here are part of the tracing protocol ABI. Do not renumber.
+class FlushFlags {
+ public:
+  enum class Initiator : uint64_t {
+    // DO NOT RENUMBER, ABI.
+    kUnknown = 0,
+    kTraced = 1,
+    kPerfettoCmd = 2,
+    kConsumerSdk = 3,
+    kMax,
+  };
+
+  enum class Reason : uint64_t {
+    // DO NOT RENUMBER, ABI.
+    kUnknown = 0,
+    kPeriodic = 1,
+    kTraceStop = 2,
+    kTraceClone = 3,
+    kExplicit = 4,
+    kMax,
+  };
+
+  enum class CloneTarget : uint64_t {
+    // DO NOT RENUMBER, ABI.
+    kUnknown = 0,
+    kBugreport = 1,
+    kMax,
+  };
+
+  explicit FlushFlags(uint64_t flags = 0) : flags_(flags) {}
+  FlushFlags(Initiator i, Reason r, CloneTarget c = CloneTarget::kUnknown)
+      : flags_((static_cast<uint64_t>(i) << kInitiatorShift) |
+               (static_cast<uint64_t>(r) << kReasonShift) |
+               (static_cast<uint64_t>(c) << kCloneTargetShift)) {}
+
+  bool operator==(const FlushFlags& o) const { return flags_ == o.flags_; }
+  bool operator!=(const FlushFlags& o) const { return !(*this == o); }
+
+  Initiator initiator() const {
+    // Due to version mismatch we might see a value from the future that we
+    // didn't know yet. If that happens, short ciruit to kUnknown.
+    static_assert(
+        uint64_t(Initiator::kMax) - 1 <= (kInitiatorMask >> kInitiatorShift),
+        "enum out of range");
+    const uint64_t value = (flags_ & kInitiatorMask) >> kInitiatorShift;
+    return value < uint64_t(Initiator::kMax) ? Initiator(value)
+                                             : Initiator::kUnknown;
+  }
+
+  Reason reason() const {
+    static_assert(uint64_t(Reason::kMax) - 1 <= (kReasonMask >> kReasonShift),
+                  "enum out of range");
+    const uint64_t value = (flags_ & kReasonMask) >> kReasonShift;
+    return value < uint64_t(Reason::kMax) ? Reason(value) : Reason::kUnknown;
+  }
+
+  CloneTarget clone_target() const {
+    static_assert(uint64_t(CloneTarget::kMax) - 1 <=
+                      (kCloneTargetMask >> kCloneTargetShift),
+                  "enum out of range");
+    const uint64_t value = (flags_ & kCloneTargetMask) >> kCloneTargetShift;
+    return value < uint64_t(CloneTarget::kMax) ? CloneTarget(value)
+                                               : CloneTarget::kUnknown;
+  }
+
+  uint64_t flags() const { return flags_; }
+
+ private:
+  // DO NOT CHANGE, ABI.
+  static constexpr uint64_t kReasonMask = 0xF;
+  static constexpr uint64_t kReasonShift = 0;
+  static constexpr uint64_t kInitiatorMask = 0xF0;
+  static constexpr uint64_t kInitiatorShift = 4;
+  static constexpr uint64_t kCloneTargetMask = 0xF00;
+  static constexpr uint64_t kCloneTargetShift = 8;
+
+  uint64_t flags_ = 0;
+};
+
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_TRACING_CORE_FLUSH_FLAGS_H_
 // gen_amalgamated begin header: include/perfetto/tracing/internal/data_source_type.h
 // gen_amalgamated begin header: include/perfetto/tracing/internal/tracing_muxer.h
 // gen_amalgamated begin header: include/perfetto/tracing/internal/tracing_tls.h
@@ -7762,10 +8918,9 @@ inline PlatformProcessId GetProcessId() {
 }  // namespace perfetto
 
 #endif  // INCLUDE_PERFETTO_BASE_PROC_UTILS_H_
-// gen_amalgamated begin header: include/perfetto/tracing/tracing.h
-// gen_amalgamated begin header: include/perfetto/tracing/backend_type.h
+// gen_amalgamated begin header: include/perfetto/base/thread_utils.h
 /*
- * Copyright (C) 2021 The Android Open Source Project
+ * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -7780,36 +8935,162 @@ inline PlatformProcessId GetProcessId() {
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_TRACING_BACKEND_TYPE_H_
-#define INCLUDE_PERFETTO_TRACING_BACKEND_TYPE_H_
+#ifndef INCLUDE_PERFETTO_BASE_THREAD_UTILS_H_
+#define INCLUDE_PERFETTO_BASE_THREAD_UTILS_H_
 
 #include <stdint.h>
 
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+extern "C" {
+// Prototype extracted from the Windows SDK to avoid including windows.h.
+__declspec(dllimport) unsigned long __stdcall GetCurrentThreadId();
+}
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA)
+#include <zircon/types.h>
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_QNX)
+#include <sys/types.h>
+#include <unistd.h>
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <unistd.h>
+#else
+#include <pthread.h>
+#endif
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD)
+#include <pthread_np.h>
+#endif
+
 namespace perfetto {
+namespace base {
 
-enum BackendType : uint32_t {
-  kUnspecifiedBackend = 0,
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_QNX)
+using PlatformThreadId = pid_t;
+inline PlatformThreadId GetThreadId() {
+  return gettid();
+}
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX)
+using PlatformThreadId = pid_t;
+inline PlatformThreadId GetThreadId() {
+  return static_cast<pid_t>(syscall(__NR_gettid));
+}
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA)
+using PlatformThreadId = zx_koid_t;
+// Not inlined because the result is cached internally.
+PERFETTO_EXPORT_COMPONENT PlatformThreadId GetThreadId();
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+using PlatformThreadId = uint64_t;
+inline PlatformThreadId GetThreadId() {
+  uint64_t tid;
+  pthread_threadid_np(nullptr, &tid);
+  return tid;
+}
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+using PlatformThreadId = uint64_t;
+inline PlatformThreadId GetThreadId() {
+  return static_cast<uint64_t>(GetCurrentThreadId());
+}
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_NACL)
+using PlatformThreadId = pid_t;
+inline PlatformThreadId GetThreadId() {
+  return reinterpret_cast<int32_t>(pthread_self());
+}
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD)
+using PlatformThreadId = uint64_t;
+inline PlatformThreadId GetThreadId() {
+  return static_cast<uint64_t>(pthread_getthreadid_np());
+}
+#else  // Default to pthreads in case no OS is set.
+using PlatformThreadId = pthread_t;
+inline PlatformThreadId GetThreadId() {
+  return pthread_self();
+}
+#endif
 
-  // Connects to a previously-initialized perfetto tracing backend for
-  // in-process. If the in-process backend has not been previously initialized
-  // it will do so and create the tracing service on a dedicated thread.
-  kInProcessBackend = 1 << 0,
+}  // namespace base
+}  // namespace perfetto
 
-  // Connects to the system tracing service (e.g. on Linux/Android/Mac uses a
-  // named UNIX socket).
-  kSystemBackend = 1 << 1,
+#endif  // INCLUDE_PERFETTO_BASE_THREAD_UTILS_H_
+// gen_amalgamated begin header: include/perfetto/tracing/tracing.h
+// gen_amalgamated begin header: include/perfetto/tracing/internal/in_process_tracing_backend.h
+// gen_amalgamated begin header: include/perfetto/tracing/tracing_backend.h
+// gen_amalgamated begin header: include/perfetto/base/platform_handle.h
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-  // Used to provide a custom IPC transport to connect to the service.
-  // TracingInitArgs::custom_backend must be non-null and point to an
-  // indefinitely lived instance.
-  kCustomBackend = 1 << 2,
+#ifndef INCLUDE_PERFETTO_BASE_PLATFORM_HANDLE_H_
+#define INCLUDE_PERFETTO_BASE_PLATFORM_HANDLE_H_
+
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+
+namespace perfetto {
+namespace base {
+
+// PlatformHandle should be used only for types that are HANDLE(s) in Windows.
+// It should NOT be used to blanket-replace "int fd" in the codebase.
+// Windows has two types of "handles", which, in UNIX-land, both map to int:
+// 1. File handles returned by the posix-compatibility API like _open().
+//    These are just int(s) and should stay such, because all the posix-like API
+//    in windows.h take an int, not a HANDLE.
+// 2. Handles returned by old-school WINAPI like CreateFile, CreateEvent etc.
+//    These are proper HANDLE(s). PlatformHandle should be used here.
+//
+// On Windows, sockets have their own type (SOCKET) which is neither a HANDLE
+// nor an int. However Windows SOCKET(s) can have an event HANDLE attached
+// to them (which in Perfetto is a PlatformHandle), and that can be used in
+// WaitForMultipleObjects, hence in base::TaskRunner.AddFileDescriptorWatch().
+// On POSIX OSes, a SocketHandle is really just an int (a file descriptor).
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+// windows.h typedefs HANDLE to void*, and SOCKET to uintptr_t. We use their
+// types to avoid leaking windows.h through our headers.
+using PlatformHandle = void*;
+using SocketHandle = uintptr_t;
+
+// On Windows both nullptr and 0xffff... (INVALID_HANDLE_VALUE) are invalid.
+struct PlatformHandleChecker {
+  static inline bool IsValid(PlatformHandle h) {
+    return h && h != reinterpret_cast<PlatformHandle>(-1);
+  }
 };
+#else
+using PlatformHandle = int;
+using SocketHandle = int;
+struct PlatformHandleChecker {
+  static inline bool IsValid(PlatformHandle h) { return h >= 0; }
+};
+#endif
+
+// The definition of this lives in base/file_utils.cc (to avoid creating an
+// extra build edge for a one liner). This is really an alias for close() (UNIX)
+// CloseHandle() (Windows). THe indirection layer is just to avoid leaking
+// system headers like windows.h through perfetto headers.
+// Thre return value is always UNIX-style: 0 on success, -1 on failure.
+int ClosePlatformHandle(PlatformHandle);
 
+}  // namespace base
 }  // namespace perfetto
 
-#endif  // INCLUDE_PERFETTO_TRACING_BACKEND_TYPE_H_
-// gen_amalgamated begin header: include/perfetto/tracing/internal/in_process_tracing_backend.h
-// gen_amalgamated begin header: include/perfetto/tracing/tracing_backend.h
+#endif  // INCLUDE_PERFETTO_BASE_PLATFORM_HANDLE_H_
 /*
  * Copyright (C) 2019 The Android Open Source Project
  *
@@ -7829,10 +9110,12 @@ enum BackendType : uint32_t {
 #ifndef INCLUDE_PERFETTO_TRACING_TRACING_BACKEND_H_
 #define INCLUDE_PERFETTO_TRACING_TRACING_BACKEND_H_
 
+#include <functional>
 #include <memory>
 #include <string>
 
 // gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/base/platform_handle.h"
 
 // The embedder can (but doesn't have to) extend the TracingBackend class and
 // pass as an argument to Tracing::Initialize(kCustomBackend) to override the
@@ -7855,6 +9138,9 @@ class ConsumerEndpoint;
 class Producer;
 class ProducerEndpoint;
 
+using CreateSocketCallback = std::function<void(base::SocketHandle)>;
+using CreateSocketAsync = void (*)(CreateSocketCallback);
+
 // Responsible for connecting to the producer.
 class PERFETTO_EXPORT_COMPONENT TracingProducerBackend {
  public:
@@ -7886,6 +9172,10 @@ class PERFETTO_EXPORT_COMPONENT TracingProducerBackend {
     // it to the service when connecting.
     // It's used in startup tracing.
     bool use_producer_provided_smb = false;
+
+    // If set, the producer will call this function to create and connect to a
+    // socket. See the corresponding field in TracingInitArgs for more info.
+    CreateSocketAsync create_socket_async = nullptr;
   };
 
   virtual std::unique_ptr<ProducerEndpoint> ConnectProducer(
@@ -7961,6 +9251,8 @@ class PERFETTO_EXPORT_COMPONENT InProcessTracingBackend
  public:
   static TracingBackend* GetInstance();
 
+  ~InProcessTracingBackend() override;
+
   // TracingBackend implementation.
   std::unique_ptr<ProducerEndpoint> ConnectProducer(
       const ConnectProducerArgs&) override;
@@ -7979,6 +9271,48 @@ class PERFETTO_EXPORT_COMPONENT InProcessTracingBackend
 
 #endif  // INCLUDE_PERFETTO_TRACING_INTERNAL_IN_PROCESS_TRACING_BACKEND_H_
 // gen_amalgamated begin header: include/perfetto/tracing/internal/system_tracing_backend.h
+// gen_amalgamated begin header: include/perfetto/tracing/default_socket.h
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_TRACING_DEFAULT_SOCKET_H_
+#define INCLUDE_PERFETTO_TRACING_DEFAULT_SOCKET_H_
+
+#include <string>
+#include <vector>
+
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+
+namespace perfetto {
+
+PERFETTO_EXPORT_COMPONENT const char* GetConsumerSocket();
+// This function is used for tokenize the |producer_socket_names| string into
+// multiple producer socket names.
+PERFETTO_EXPORT_COMPONENT std::vector<std::string> TokenizeProducerSockets(
+    const char* producer_socket_names);
+PERFETTO_EXPORT_COMPONENT const char* GetProducerSocket();
+
+// Optionally returns the relay socket name. The relay socket is used
+// for forwarding the IPC messages between the local producers and the remote
+// tracing service.
+PERFETTO_EXPORT_COMPONENT std::string GetRelaySocket();
+
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_TRACING_DEFAULT_SOCKET_H_
 /*
  * Copyright (C) 2019 The Android Open Source Project
  *
@@ -7999,6 +9333,7 @@ class PERFETTO_EXPORT_COMPONENT InProcessTracingBackend
 #define INCLUDE_PERFETTO_TRACING_INTERNAL_SYSTEM_TRACING_BACKEND_H_
 
 // gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/default_socket.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/tracing_backend.h"
 
 namespace perfetto {
@@ -8123,7 +9458,10 @@ class PERFETTO_EXPORT_COMPONENT TracingPolicy {
 
 #include <functional>
 #include <memory>
+#include <optional>
 #include <string>
+#include <tuple>
+#include <utility>
 #include <vector>
 
 // gen_amalgamated expanded: #include "perfetto/base/compiler.h"
@@ -8207,6 +9545,11 @@ struct TracingInitArgs {
   // delay, i.e. commits will be sent to the service at the next opportunity.
   uint32_t shmem_batch_commits_duration_ms = 0;
 
+  // [Optional] Enables direct producer-side patching of chunks that have not
+  // yet been committed to the service. This flag will only have an effect
+  // if the service supports direct patching, otherwise it will be ignored.
+  bool shmem_direct_patching_enabled = false;
+
   // [Optional] If set, the policy object is notified when certain SDK events
   // occur and may apply policy decisions, such as denying connections. The
   // embedder is responsible for ensuring the object remains alive for the
@@ -8241,6 +9584,29 @@ struct TracingInitArgs {
   // only already instantiated backends.
   bool enable_system_consumer = true;
 
+  // When true, sets disallow_merging_with_system_tracks in TrackDescriptor,
+  // making sure that Trace Processor doesn't merge track event and system
+  // event tracks for the same thread.
+  bool disallow_merging_with_system_tracks = false;
+
+  // If set, this function will be called by the producer client to create a
+  // socket for connection to the system service. The function takes one
+  // argument: a callback that takes an open file descriptor. The function
+  // should create a socket with the name defined by
+  // perfetto::GetProducerSocket(), connect to it, and return the corresponding
+  // descriptor via the callback.
+  // This is intended for the use-case where a process being traced is run
+  // inside a sandbox and can't create sockets directly.
+  // Not yet supported for consumer connections currently.
+  CreateSocketAsync create_socket_async = nullptr;
+
+  // [Optional] Specifies a custom track uuid for the current current. If
+  // specified, perfetto::ProcessTrack::Current().uuid will have this value. The
+  // value provided must be unique among all processes. When not specified, the
+  // perfetto::ProcessTrack::Current().uuid is chosen automatically based on
+  // PID, start time and a random source.
+  std::optional<uint64_t> process_uuid = std::nullopt;
+
  protected:
   friend class Tracing;
   friend class internal::TracingMuxerImpl;
@@ -8299,30 +9665,8 @@ class PERFETTO_EXPORT_COMPONENT Tracing {
 
   // Start a new tracing session using the given tracing backend. Use
   // |kUnspecifiedBackend| to select an available backend automatically.
-  static inline std::unique_ptr<TracingSession> NewTrace(
-      BackendType backend = kUnspecifiedBackend) PERFETTO_ALWAYS_INLINE {
-    // This code is inlined to allow dead-code elimination for unused consumer
-    // implementation. The logic behind it is the following:
-    // Nothing other than the code below references the GetInstance() method
-    // below. From a linker-graph viewpoint, those GetInstance() pull in many
-    // other pieces of the codebase (ConsumerOnlySystemTracingBackend pulls
-    // ConsumerIPCClient). Due to the inline, the compiler can see through the
-    // code and realize that some branches are always not taken. When that
-    // happens, no reference to the backends' GetInstance() is emitted and that
-    // allows the linker GC to get rid of the entire set of dependencies.
-    TracingConsumerBackend* (*system_backend_factory)();
-    system_backend_factory = nullptr;
-    // In case PERFETTO_IPC is disabled, a fake system backend is used, which
-    // always panics. NewTrace(kSystemBackend) should fail if PERFETTO_IPC is
-    // diabled, not panic.
-#if PERFETTO_BUILDFLAG(PERFETTO_IPC)
-    if (backend & kSystemBackend) {
-      system_backend_factory =
-          &internal::SystemConsumerTracingBackend::GetInstance;
-    }
-#endif
-    return NewTraceInternal(backend, system_backend_factory);
-  }
+  static PERFETTO_ALWAYS_INLINE inline std::unique_ptr<TracingSession> NewTrace(
+      BackendType backend = kUnspecifiedBackend);
 
   // Shut down Perfetto, releasing any allocated OS resources (threads, files,
   // sockets, etc.). Note that Perfetto cannot be reinitialized again in the
@@ -8444,12 +9788,36 @@ class PERFETTO_EXPORT_COMPONENT TracingSession {
   // started.
   virtual void StartBlocking() = 0;
 
+  // Struct passed as argument to the callback passed to CloneTrace().
+  struct CloneTraceCallbackArgs {
+    bool success;
+    std::string error;
+    // UUID of the cloned session.
+    int64_t uuid_msb;
+    int64_t uuid_lsb;
+  };
+
+  // Struct passed as argument to CloneTrace().
+  struct CloneTraceArgs {
+    // The unique_session_name of the session that should be cloned.
+    std::string unique_session_name;
+  };
+
+  // Clones an existing initialized tracing session from the same `BackendType`
+  // as this tracing session, and attaches to it. The session is cloned in
+  // read-only mode and can only be used to read a snapshot of an existing
+  // tracing session. For each session, only one CloneTrace call can be pending
+  // at the same time; subsequent calls after the callback is executed are
+  // supported.
+  using CloneTraceCallback = std::function<void(CloneTraceCallbackArgs)>;
+  virtual void CloneTrace(CloneTraceArgs args, CloneTraceCallback);
+
   // This callback will be invoked when all data sources have acknowledged that
   // tracing has started. This callback will be invoked on an internal perfetto
   // thread.
   virtual void SetOnStartCallback(std::function<void()>) = 0;
 
-  // This callback can be used to get a notification when some error occured
+  // This callback can be used to get a notification when some error occurred
   // (e.g., peer disconnection). Error type will be passed as an argument. This
   // callback will be invoked on an internal perfetto thread.
   virtual void SetOnErrorCallback(std::function<void(TracingError)>) = 0;
@@ -8603,6 +9971,31 @@ class PERFETTO_EXPORT_COMPONENT StartupTracingSession {
   virtual void AbortBlocking() = 0;
 };
 
+PERFETTO_ALWAYS_INLINE inline std::unique_ptr<TracingSession> Tracing::NewTrace(
+    BackendType backend) {
+  // This code is inlined to allow dead-code elimination for unused consumer
+  // implementation. The logic behind it is the following:
+  // Nothing other than the code below references the GetInstance() method
+  // below. From a linker-graph viewpoint, those GetInstance() pull in many
+  // other pieces of the codebase (ConsumerOnlySystemTracingBackend pulls
+  // ConsumerIPCClient). Due to the inline, the compiler can see through the
+  // code and realize that some branches are always not taken. When that
+  // happens, no reference to the backends' GetInstance() is emitted and that
+  // allows the linker GC to get rid of the entire set of dependencies.
+  TracingConsumerBackend* (*system_backend_factory)();
+  system_backend_factory = nullptr;
+  // In case PERFETTO_IPC is disabled, a fake system backend is used, which
+  // always panics. NewTrace(kSystemBackend) should fail if PERFETTO_IPC is
+  // diabled, not panic.
+#if PERFETTO_BUILDFLAG(PERFETTO_IPC)
+  if (backend & kSystemBackend) {
+    system_backend_factory =
+        &internal::SystemConsumerTracingBackend::GetInstance;
+  }
+#endif
+  return NewTraceInternal(backend, system_backend_factory);
+}
+
 }  // namespace perfetto
 
 #endif  // INCLUDE_PERFETTO_TRACING_TRACING_H_
@@ -8635,6 +10028,7 @@ class PERFETTO_EXPORT_COMPONENT StartupTracingSession {
 // gen_amalgamated expanded: #include "perfetto/base/export.h"
 // gen_amalgamated expanded: #include "perfetto/base/logging.h"
 // gen_amalgamated expanded: #include "perfetto/base/proc_utils.h"
+// gen_amalgamated expanded: #include "perfetto/base/thread_utils.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/tracing.h"
 
 namespace perfetto {
@@ -8716,6 +10110,11 @@ class PERFETTO_EXPORT_COMPONENT Platform {
   // interface must not be used after calling this function.
   virtual void Shutdown();
 
+  // Returns the thread ID provided by the OS by default. Chromium uses
+  // different thread IDs on some platforms, so it needs the ability to
+  // override this method.
+  virtual base::PlatformThreadId GetCurrentThreadId();
+
  private:
   static base::PlatformProcessId process_id_;
 };
@@ -8858,11 +10257,13 @@ struct ScopedReentrancyAnnotator {
 #include <memory>
 
 // gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/buffer_exhausted_policy.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/interceptor.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/internal/basic_types.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_tls.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/platform.h"
+
 namespace perfetto {
 
 class DataSourceBase;
@@ -8873,8 +10274,15 @@ class TracingSession;
 namespace internal {
 
 struct DataSourceParams {
-  bool supports_multiple_instances;
-  bool requires_callbacks_under_lock;
+  // This is the policy configured by the data source code
+  // (DataSource::kBufferExhaustedPolicy in C++ or
+  // PerfettoDsSetBufferExhaustedPolicy in C). It can be overridden by the
+  // consumer via config if buffer_exhausted_policy_configurable is true.
+  BufferExhaustedPolicy default_buffer_exhausted_policy =
+      BufferExhaustedPolicy::kDrop;
+  bool buffer_exhausted_policy_configurable = false;
+  bool supports_multiple_instances = true;
+  bool requires_callbacks_under_lock = true;
 };
 
 struct DataSourceStaticState;
@@ -8905,6 +10313,7 @@ class PERFETTO_EXPORT_COMPONENT TracingMuxer {
   virtual bool RegisterDataSource(const DataSourceDescriptor&,
                                   DataSourceFactory,
                                   DataSourceParams,
+                                  bool no_flush,
                                   DataSourceStaticState*) = 0;
 
   // Updates the DataSourceDescriptor for the DataSource.
@@ -8940,6 +10349,10 @@ class PERFETTO_EXPORT_COMPONENT TracingMuxer {
   virtual void ActivateTriggers(const std::vector<std::string>&,
                                 uint32_t ttl_ms) = 0;
 
+  base::PlatformThreadId GetCurrentThreadId() {
+    return platform_->GetCurrentThreadId();
+  }
+
  protected:
   explicit TracingMuxer(Platform* platform) : platform_(platform) {}
 
@@ -8957,14 +10370,19 @@ class PERFETTO_EXPORT_COMPONENT TracingMuxer {
 #ifndef INCLUDE_PERFETTO_TRACING_INTERNAL_DATA_SOURCE_TYPE_H_
 #define INCLUDE_PERFETTO_TRACING_INTERNAL_DATA_SOURCE_TYPE_H_
 
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+#include <atomic>
+#include <cassert>
+#include <cstdint>
+
 // gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/public/compiler.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/basic_types.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/internal/data_source_internal.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_muxer.h"
 
-namespace perfetto {
-namespace internal {
+namespace perfetto::internal {
 
 // Represents a data source type (not an instance).
 //
@@ -8995,30 +10413,38 @@ class PERFETTO_EXPORT_COMPONENT DataSourceType {
           DataSourceInstanceThreadLocalState* tls_inst,
           uint32_t instance_index,
           void* user_arg);
+  // Function pointer type used to clear the incremental state without
+  // destroying it. Returns true if clearing was successful, false otherwise.
+  // If nullptr or returns false, the incremental state will be destroyed and
+  // recreated.
+  using ClearIncrementalStateFn = bool (*)(void* incremental_state,
+                                           void* user_arg);
 
   // Registers the data source type with the central tracing muxer.
   // * `descriptor` is the data source protobuf descriptor.
   // * `factory` is a std::function used to create instances of the data source
   //   type.
-  // * `buffer_exhausted_policy` specifies what to do when the shared memory
-  //   buffer runs out of chunks.
   // * `create_custom_tls_fn` and `create_incremental_state_fn` are function
   //   pointers called to create custom state. They will receive `user_arg` as
   //   an extra param.
+  // * `clear_incremental_state_fn` is an optional function pointer called to
+  //   clear incremental state without destroying it. If nullptr or returns
+  //   false, the state will be destroyed and recreated.
   bool Register(const DataSourceDescriptor& descriptor,
                 TracingMuxer::DataSourceFactory factory,
                 internal::DataSourceParams params,
-                BufferExhaustedPolicy buffer_exhausted_policy,
+                bool no_flush,
                 CreateCustomTlsFn create_custom_tls_fn,
                 CreateIncrementalStateFn create_incremental_state_fn,
+                ClearIncrementalStateFn clear_incremental_state_fn,
                 void* user_arg) {
-    buffer_exhausted_policy_ = buffer_exhausted_policy;
     create_custom_tls_fn_ = create_custom_tls_fn;
     create_incremental_state_fn_ = create_incremental_state_fn;
+    clear_incremental_state_fn_ = clear_incremental_state_fn;
     user_arg_ = user_arg;
     auto* tracing_impl = TracingMuxer::Get();
     return tracing_impl->RegisterDataSource(descriptor, factory, params,
-                                            &state_);
+                                            no_flush, &state_);
   }
 
   // Updates the data source type descriptor.
@@ -9123,8 +10549,7 @@ class PERFETTO_EXPORT_COMPONENT DataSourceType {
   InstancesIterator BeginIteration(
       uint32_t cached_instances,
       DataSourceThreadLocalState* tls_state,
-      typename TracePointTraits::TracePointData trace_point_data)
-      PERFETTO_ALWAYS_INLINE {
+      typename TracePointTraits::TracePointData trace_point_data) {
     InstancesIterator it{};
     it.cached_instances = cached_instances;
     FirstActiveInstance<TracePointTraits>(&it, tls_state, trace_point_data);
@@ -9139,10 +10564,10 @@ class PERFETTO_EXPORT_COMPONENT DataSourceType {
   // `TracePointTraits` and `trace_point_data` are customization point for
   // getting the active instances bitmap.
   template <typename TracePointTraits>
-  void NextIteration(InstancesIterator* iterator,
-                     DataSourceThreadLocalState* tls_state,
-                     typename TracePointTraits::TracePointData trace_point_data)
-      PERFETTO_ALWAYS_INLINE {
+  void NextIteration(
+      InstancesIterator* iterator,
+      DataSourceThreadLocalState* tls_state,
+      typename TracePointTraits::TracePointData trace_point_data) {
     iterator->i++;
     FirstActiveInstance<TracePointTraits>(iterator, tls_state,
                                           trace_point_data);
@@ -9152,11 +10577,12 @@ class PERFETTO_EXPORT_COMPONENT DataSourceType {
       internal::DataSourceInstanceThreadLocalState* tls_inst,
       uint32_t instance_index) {
     // Recreate incremental state data if it has been reset by the service.
-    if (tls_inst->incremental_state_generation !=
-        static_state()->incremental_state_generation.load(
-            std::memory_order_relaxed)) {
-      tls_inst->incremental_state.reset();
-      CreateIncrementalState(tls_inst, instance_index);
+    uint32_t actual_generation =
+        static_state()
+            ->GetUnsafe(instance_index)
+            ->incremental_state_generation.load(std::memory_order_relaxed);
+    if (tls_inst->incremental_state_generation != actual_generation) {
+      ClearIncrementalState(tls_inst, instance_index, actual_generation);
     }
     return tls_inst->incremental_state.get();
   }
@@ -9173,14 +10599,19 @@ class PERFETTO_EXPORT_COMPONENT DataSourceType {
     tls_inst->incremental_state =
         create_incremental_state_fn_(tls_inst, instance_index, user_arg_);
     tls_inst->incremental_state_generation =
-        static_state()->incremental_state_generation.load(
-            std::memory_order_relaxed);
+        static_state()
+            ->GetUnsafe(instance_index)
+            ->incremental_state_generation.load(std::memory_order_relaxed);
   }
 
   void PopulateTlsInst(DataSourceInstanceThreadLocalState* tls_inst,
                        DataSourceState* instance_state,
                        uint32_t instance_index);
 
+  void ClearIncrementalState(internal::DataSourceInstanceThreadLocalState*,
+                             uint32_t instance_index,
+                             uint32_t actual_generation);
+
   // Advances `*iterator` to the first active instance whose index is greater or
   // equal than `iterator->i`.
   template <typename TracePointTraits>
@@ -9242,15 +10673,13 @@ class PERFETTO_EXPORT_COMPONENT DataSourceType {
   // per data-source *instance*.
   template <typename DataSourceTraits>
   DataSourceThreadLocalState* GetOrCreateDataSourceTLS() {
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_IOS)
-    PERFETTO_FATAL("Data source TLS not supported on iOS, see b/158814068");
-#endif
     auto* tracing_impl = TracingMuxer::Get();
     TracingTLS* root_tls = tracing_impl->GetOrCreateTracingTLS();
     DataSourceThreadLocalState* ds_tls =
         DataSourceTraits::GetDataSourceTLS(&state_, root_tls);
     // We keep re-initializing as the initialization is idempotent and not worth
-    // the code for extra checks.
+    // the code for extra checks. Also, ds_tls->static_state might point to
+    // another data source if ResetForTesting() has been used.
     ds_tls->static_state = &state_;
     assert(!ds_tls->root_tls || ds_tls->root_tls == root_tls);
     ds_tls->root_tls = root_tls;
@@ -9258,16 +10687,15 @@ class PERFETTO_EXPORT_COMPONENT DataSourceType {
   }
 
   DataSourceStaticState state_;
-  BufferExhaustedPolicy buffer_exhausted_policy_{};
   CreateCustomTlsFn create_custom_tls_fn_ = nullptr;
   CreateIncrementalStateFn create_incremental_state_fn_ = nullptr;
+  ClearIncrementalStateFn clear_incremental_state_fn_ = nullptr;
   // User defined pointer that carries extra content for the fn_ callbacks
   // above. Only used in the C shared library.
   void* user_arg_ = nullptr;
 };
 
-}  // namespace internal
-}  // namespace perfetto
+}  // namespace perfetto::internal
 
 #endif  // INCLUDE_PERFETTO_TRACING_INTERNAL_DATA_SOURCE_TYPE_H_
 // gen_amalgamated begin header: gen/protos/perfetto/trace/trace_packet.pbzero.h
@@ -9288,25 +10716,35 @@ class PERFETTO_EXPORT_COMPONENT DataSourceType {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
-
 class AndroidCameraFrameEvent;
 class AndroidCameraSessionStats;
 class AndroidEnergyEstimationBreakdown;
 class AndroidGameInterventionList;
 class AndroidLogPacket;
 class AndroidSystemProperty;
+class AndroidUserList;
+class AppWakelockBundle;
 class BatteryCounters;
+class BluetoothTraceEvent;
 class ChromeBenchmarkMetadata;
 class ChromeEventBundle;
 class ChromeMetadataPacket;
+class ChromeTrigger;
 class ClockSnapshot;
 class CpuInfo;
+class CpuPerUidData;
 class DeobfuscationMapping;
 class EntityStateResidency;
+class EtwTraceEventBundle;
+class EvdevEvent;
 class ExtensionDescriptor;
 class FrameTimelineEvent;
 class FtraceEventBundle;
 class FtraceStats;
+class GenericKernelCpuFrequencyEvent;
+class GenericKernelProcessTree;
+class GenericKernelTaskRenameEvent;
+class GenericKernelTaskStateEvent;
 class GpuCounterEvent;
 class GpuLog;
 class GpuMemTotalEvent;
@@ -9316,18 +10754,27 @@ class HeapGraph;
 class InitialDisplayState;
 class InodeFileMap;
 class InternedData;
+class KernelWakelockData;
+class LayersSnapshotProto;
 class MemoryTrackerSnapshot;
 class ModuleSymbols;
+class NetworkPacketBundle;
 class NetworkPacketEvent;
 class PackagesList;
 class PerfSample;
 class PerfettoMetatrace;
+class PixelModemEvents;
+class PixelModemTokenDatabase;
 class PowerRails;
 class ProcessDescriptor;
 class ProcessStats;
 class ProcessTree;
 class ProfilePacket;
-class ProfiledFrameSymbols;
+class ProtoLogMessage;
+class ProtoLogViewerConfig;
+class RemoteClockSync;
+class ShellHandlerMappings;
+class ShellTransition;
 class SmapsPacket;
 class StatsdAtom;
 class StreamingAllocation;
@@ -9338,18 +10785,37 @@ class SystemInfo;
 class TestEvent;
 class ThreadDescriptor;
 class TraceConfig;
+class TracePacket;
+class TracePacket_ProtoVms;
+class TracePacket_ProtoVms_Instance;
 class TracePacketDefaults;
+class TraceProvenance;
 class TraceStats;
 class TraceUuid;
 class TracingServiceEvent;
 class TrackDescriptor;
 class TrackEvent;
 class TrackEventRangeOfInterest;
+class TransactionTraceEntry;
 class TranslationTable;
 class Trigger;
 class UiState;
+class V8CodeMove;
+class V8InternalCode;
+class V8JsCode;
+class V8RegExpCode;
+class V8WasmCode;
+class VmProgram;
 class VulkanApiEvent;
 class VulkanMemoryEvent;
+class WinscopeExtensions;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
 namespace perfetto_pbzero_enum_TracePacket {
 enum SequenceFlags : int32_t {
@@ -9380,7 +10846,7 @@ const char* TracePacket_SequenceFlags_Name(::perfetto::protos::pbzero::TracePack
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-class TracePacket_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/900, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class TracePacket_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/900> {
  public:
   TracePacket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit TracePacket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -9427,6 +10893,8 @@ class TracePacket_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID
   ::protozero::ConstBytes system_info() const { return at<45>().as_bytes(); }
   bool has_trigger() const { return at<46>().valid(); }
   ::protozero::ConstBytes trigger() const { return at<46>().as_bytes(); }
+  bool has_chrome_trigger() const { return at<109>().valid(); }
+  ::protozero::ConstBytes chrome_trigger() const { return at<109>().as_bytes(); }
   bool has_packages_list() const { return at<47>().valid(); }
   ::protozero::ConstBytes packages_list() const { return at<47>().as_bytes(); }
   bool has_chrome_benchmark_metadata() const { return at<48>().valid(); }
@@ -9485,8 +10953,10 @@ class TracePacket_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID
   ::protozero::ConstBytes android_system_property() const { return at<86>().as_bytes(); }
   bool has_entity_state_residency() const { return at<91>().valid(); }
   ::protozero::ConstBytes entity_state_residency() const { return at<91>().as_bytes(); }
-  bool has_profiled_frame_symbols() const { return at<55>().valid(); }
-  ::protozero::ConstBytes profiled_frame_symbols() const { return at<55>().as_bytes(); }
+  bool has_trace_provenance() const { return at<124>().valid(); }
+  ::protozero::ConstBytes trace_provenance() const { return at<124>().as_bytes(); }
+  bool has_protovms() const { return at<125>().valid(); }
+  ::protozero::ConstBytes protovms() const { return at<125>().as_bytes(); }
   bool has_module_symbols() const { return at<61>().valid(); }
   ::protozero::ConstBytes module_symbols() const { return at<61>().as_bytes(); }
   bool has_deobfuscation_mapping() const { return at<64>().valid(); }
@@ -9507,8 +10977,64 @@ class TracePacket_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID
   ::protozero::ConstBytes extension_descriptor() const { return at<72>().as_bytes(); }
   bool has_network_packet() const { return at<88>().valid(); }
   ::protozero::ConstBytes network_packet() const { return at<88>().as_bytes(); }
+  bool has_network_packet_bundle() const { return at<92>().valid(); }
+  ::protozero::ConstBytes network_packet_bundle() const { return at<92>().as_bytes(); }
   bool has_track_event_range_of_interest() const { return at<90>().valid(); }
   ::protozero::ConstBytes track_event_range_of_interest() const { return at<90>().as_bytes(); }
+  bool has_surfaceflinger_layers_snapshot() const { return at<93>().valid(); }
+  ::protozero::ConstBytes surfaceflinger_layers_snapshot() const { return at<93>().as_bytes(); }
+  bool has_surfaceflinger_transactions() const { return at<94>().valid(); }
+  ::protozero::ConstBytes surfaceflinger_transactions() const { return at<94>().as_bytes(); }
+  bool has_shell_transition() const { return at<96>().valid(); }
+  ::protozero::ConstBytes shell_transition() const { return at<96>().as_bytes(); }
+  bool has_shell_handler_mappings() const { return at<97>().valid(); }
+  ::protozero::ConstBytes shell_handler_mappings() const { return at<97>().as_bytes(); }
+  bool has_protolog_message() const { return at<104>().valid(); }
+  ::protozero::ConstBytes protolog_message() const { return at<104>().as_bytes(); }
+  bool has_protolog_viewer_config() const { return at<105>().valid(); }
+  ::protozero::ConstBytes protolog_viewer_config() const { return at<105>().as_bytes(); }
+  bool has_winscope_extensions() const { return at<112>().valid(); }
+  ::protozero::ConstBytes winscope_extensions() const { return at<112>().as_bytes(); }
+  bool has_etw_events() const { return at<95>().valid(); }
+  ::protozero::ConstBytes etw_events() const { return at<95>().as_bytes(); }
+  bool has_v8_js_code() const { return at<99>().valid(); }
+  ::protozero::ConstBytes v8_js_code() const { return at<99>().as_bytes(); }
+  bool has_v8_internal_code() const { return at<100>().valid(); }
+  ::protozero::ConstBytes v8_internal_code() const { return at<100>().as_bytes(); }
+  bool has_v8_wasm_code() const { return at<101>().valid(); }
+  ::protozero::ConstBytes v8_wasm_code() const { return at<101>().as_bytes(); }
+  bool has_v8_reg_exp_code() const { return at<102>().valid(); }
+  ::protozero::ConstBytes v8_reg_exp_code() const { return at<102>().as_bytes(); }
+  bool has_v8_code_move() const { return at<103>().valid(); }
+  ::protozero::ConstBytes v8_code_move() const { return at<103>().as_bytes(); }
+  bool has_remote_clock_sync() const { return at<107>().valid(); }
+  ::protozero::ConstBytes remote_clock_sync() const { return at<107>().as_bytes(); }
+  bool has_pixel_modem_events() const { return at<110>().valid(); }
+  ::protozero::ConstBytes pixel_modem_events() const { return at<110>().as_bytes(); }
+  bool has_pixel_modem_token_database() const { return at<111>().valid(); }
+  ::protozero::ConstBytes pixel_modem_token_database() const { return at<111>().as_bytes(); }
+  bool has_clone_snapshot_trigger() const { return at<113>().valid(); }
+  ::protozero::ConstBytes clone_snapshot_trigger() const { return at<113>().as_bytes(); }
+  bool has_bluetooth_trace_event() const { return at<114>().valid(); }
+  ::protozero::ConstBytes bluetooth_trace_event() const { return at<114>().as_bytes(); }
+  bool has_kernel_wakelock_data() const { return at<115>().valid(); }
+  ::protozero::ConstBytes kernel_wakelock_data() const { return at<115>().as_bytes(); }
+  bool has_app_wakelock_bundle() const { return at<116>().valid(); }
+  ::protozero::ConstBytes app_wakelock_bundle() const { return at<116>().as_bytes(); }
+  bool has_generic_kernel_task_state_event() const { return at<117>().valid(); }
+  ::protozero::ConstBytes generic_kernel_task_state_event() const { return at<117>().as_bytes(); }
+  bool has_generic_kernel_cpu_freq_event() const { return at<118>().valid(); }
+  ::protozero::ConstBytes generic_kernel_cpu_freq_event() const { return at<118>().as_bytes(); }
+  bool has_generic_kernel_task_rename_event() const { return at<120>().valid(); }
+  ::protozero::ConstBytes generic_kernel_task_rename_event() const { return at<120>().as_bytes(); }
+  bool has_generic_kernel_process_tree() const { return at<122>().valid(); }
+  ::protozero::ConstBytes generic_kernel_process_tree() const { return at<122>().as_bytes(); }
+  bool has_cpu_per_uid_data() const { return at<119>().valid(); }
+  ::protozero::ConstBytes cpu_per_uid_data() const { return at<119>().as_bytes(); }
+  bool has_evdev_event() const { return at<121>().valid(); }
+  ::protozero::ConstBytes evdev_event() const { return at<121>().as_bytes(); }
+  bool has_user_list() const { return at<123>().valid(); }
+  ::protozero::ConstBytes user_list() const { return at<123>().as_bytes(); }
   bool has_for_testing() const { return at<900>().valid(); }
   ::protozero::ConstBytes for_testing() const { return at<900>().as_bytes(); }
   bool has_trusted_uid() const { return at<3>().valid(); }
@@ -9529,6 +11055,8 @@ class TracePacket_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID
   bool previous_packet_dropped() const { return at<42>().as_bool(); }
   bool has_first_packet_on_sequence() const { return at<87>().valid(); }
   bool first_packet_on_sequence() const { return at<87>().as_bool(); }
+  bool has_machine_id() const { return at<98>().valid(); }
+  uint32_t machine_id() const { return at<98>().as_uint32(); }
 };
 
 class TracePacket : public ::protozero::Message {
@@ -9556,6 +11084,7 @@ class TracePacket : public ::protozero::Message {
     kAndroidLogFieldNumber = 39,
     kSystemInfoFieldNumber = 45,
     kTriggerFieldNumber = 46,
+    kChromeTriggerFieldNumber = 109,
     kPackagesListFieldNumber = 47,
     kChromeBenchmarkMetadataFieldNumber = 48,
     kPerfettoMetatraceFieldNumber = 49,
@@ -9585,7 +11114,8 @@ class TracePacket : public ::protozero::Message {
     kStatsdAtomFieldNumber = 84,
     kAndroidSystemPropertyFieldNumber = 86,
     kEntityStateResidencyFieldNumber = 91,
-    kProfiledFrameSymbolsFieldNumber = 55,
+    kTraceProvenanceFieldNumber = 124,
+    kProtovmsFieldNumber = 125,
     kModuleSymbolsFieldNumber = 61,
     kDeobfuscationMappingFieldNumber = 64,
     kTrackDescriptorFieldNumber = 60,
@@ -9596,7 +11126,35 @@ class TracePacket : public ::protozero::Message {
     kCompressedPacketsFieldNumber = 50,
     kExtensionDescriptorFieldNumber = 72,
     kNetworkPacketFieldNumber = 88,
+    kNetworkPacketBundleFieldNumber = 92,
     kTrackEventRangeOfInterestFieldNumber = 90,
+    kSurfaceflingerLayersSnapshotFieldNumber = 93,
+    kSurfaceflingerTransactionsFieldNumber = 94,
+    kShellTransitionFieldNumber = 96,
+    kShellHandlerMappingsFieldNumber = 97,
+    kProtologMessageFieldNumber = 104,
+    kProtologViewerConfigFieldNumber = 105,
+    kWinscopeExtensionsFieldNumber = 112,
+    kEtwEventsFieldNumber = 95,
+    kV8JsCodeFieldNumber = 99,
+    kV8InternalCodeFieldNumber = 100,
+    kV8WasmCodeFieldNumber = 101,
+    kV8RegExpCodeFieldNumber = 102,
+    kV8CodeMoveFieldNumber = 103,
+    kRemoteClockSyncFieldNumber = 107,
+    kPixelModemEventsFieldNumber = 110,
+    kPixelModemTokenDatabaseFieldNumber = 111,
+    kCloneSnapshotTriggerFieldNumber = 113,
+    kBluetoothTraceEventFieldNumber = 114,
+    kKernelWakelockDataFieldNumber = 115,
+    kAppWakelockBundleFieldNumber = 116,
+    kGenericKernelTaskStateEventFieldNumber = 117,
+    kGenericKernelCpuFreqEventFieldNumber = 118,
+    kGenericKernelTaskRenameEventFieldNumber = 120,
+    kGenericKernelProcessTreeFieldNumber = 122,
+    kCpuPerUidDataFieldNumber = 119,
+    kEvdevEventFieldNumber = 121,
+    kUserListFieldNumber = 123,
     kForTestingFieldNumber = 900,
     kTrustedUidFieldNumber = 3,
     kTrustedPacketSequenceIdFieldNumber = 10,
@@ -9607,17 +11165,19 @@ class TracePacket : public ::protozero::Message {
     kTracePacketDefaultsFieldNumber = 59,
     kPreviousPacketDroppedFieldNumber = 42,
     kFirstPacketOnSequenceFieldNumber = 87,
+    kMachineIdFieldNumber = 98,
   };
   static constexpr const char* GetName() { return ".perfetto.protos.TracePacket"; }
 
+  using ProtoVms = ::perfetto::protos::pbzero::TracePacket_ProtoVms;
 
   using SequenceFlags = ::perfetto::protos::pbzero::TracePacket_SequenceFlags;
   static inline const char* SequenceFlags_Name(SequenceFlags value) {
     return ::perfetto::protos::pbzero::TracePacket_SequenceFlags_Name(value);
   }
-  static const SequenceFlags SEQ_UNSPECIFIED = SequenceFlags::SEQ_UNSPECIFIED;
-  static const SequenceFlags SEQ_INCREMENTAL_STATE_CLEARED = SequenceFlags::SEQ_INCREMENTAL_STATE_CLEARED;
-  static const SequenceFlags SEQ_NEEDS_INCREMENTAL_STATE = SequenceFlags::SEQ_NEEDS_INCREMENTAL_STATE;
+  static inline const SequenceFlags SEQ_UNSPECIFIED = SequenceFlags::SEQ_UNSPECIFIED;
+  static inline const SequenceFlags SEQ_INCREMENTAL_STATE_CLEARED = SequenceFlags::SEQ_INCREMENTAL_STATE_CLEARED;
+  static inline const SequenceFlags SEQ_NEEDS_INCREMENTAL_STATE = SequenceFlags::SEQ_NEEDS_INCREMENTAL_STATE;
 
   using FieldMetadata_Timestamp =
     ::protozero::proto_utils::FieldMetadata<
@@ -9627,14 +11187,7 @@ class TracePacket : public ::protozero::Message {
       uint64_t,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timestamp kTimestamp() { return {}; }
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
   void set_timestamp(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -9652,14 +11205,7 @@ class TracePacket : public ::protozero::Message {
       uint32_t,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimestampClockId kTimestampClockId() { return {}; }
+  static constexpr FieldMetadata_TimestampClockId kTimestampClockId{};
   void set_timestamp_clock_id(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_TimestampClockId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -9677,14 +11223,7 @@ class TracePacket : public ::protozero::Message {
       ProcessTree,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessTree kProcessTree() { return {}; }
+  static constexpr FieldMetadata_ProcessTree kProcessTree{};
   template <typename T = ProcessTree> T* set_process_tree() {
     return BeginNestedMessage<T>(2);
   }
@@ -9698,14 +11237,7 @@ class TracePacket : public ::protozero::Message {
       ProcessStats,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessStats kProcessStats() { return {}; }
+  static constexpr FieldMetadata_ProcessStats kProcessStats{};
   template <typename T = ProcessStats> T* set_process_stats() {
     return BeginNestedMessage<T>(9);
   }
@@ -9719,14 +11251,7 @@ class TracePacket : public ::protozero::Message {
       InodeFileMap,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InodeFileMap kInodeFileMap() { return {}; }
+  static constexpr FieldMetadata_InodeFileMap kInodeFileMap{};
   template <typename T = InodeFileMap> T* set_inode_file_map() {
     return BeginNestedMessage<T>(4);
   }
@@ -9740,14 +11265,7 @@ class TracePacket : public ::protozero::Message {
       ChromeEventBundle,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeEvents kChromeEvents() { return {}; }
+  static constexpr FieldMetadata_ChromeEvents kChromeEvents{};
   template <typename T = ChromeEventBundle> T* set_chrome_events() {
     return BeginNestedMessage<T>(5);
   }
@@ -9761,14 +11279,7 @@ class TracePacket : public ::protozero::Message {
       ClockSnapshot,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClockSnapshot kClockSnapshot() { return {}; }
+  static constexpr FieldMetadata_ClockSnapshot kClockSnapshot{};
   template <typename T = ClockSnapshot> T* set_clock_snapshot() {
     return BeginNestedMessage<T>(6);
   }
@@ -9782,14 +11293,7 @@ class TracePacket : public ::protozero::Message {
       SysStats,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SysStats kSysStats() { return {}; }
+  static constexpr FieldMetadata_SysStats kSysStats{};
   template <typename T = SysStats> T* set_sys_stats() {
     return BeginNestedMessage<T>(7);
   }
@@ -9803,14 +11307,7 @@ class TracePacket : public ::protozero::Message {
       TrackEvent,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrackEvent kTrackEvent() { return {}; }
+  static constexpr FieldMetadata_TrackEvent kTrackEvent{};
   template <typename T = TrackEvent> T* set_track_event() {
     return BeginNestedMessage<T>(11);
   }
@@ -9824,14 +11321,7 @@ class TracePacket : public ::protozero::Message {
       TraceUuid,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceUuid kTraceUuid() { return {}; }
+  static constexpr FieldMetadata_TraceUuid kTraceUuid{};
   template <typename T = TraceUuid> T* set_trace_uuid() {
     return BeginNestedMessage<T>(89);
   }
@@ -9845,14 +11335,7 @@ class TracePacket : public ::protozero::Message {
       TraceConfig,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceConfig kTraceConfig() { return {}; }
+  static constexpr FieldMetadata_TraceConfig kTraceConfig{};
   template <typename T = TraceConfig> T* set_trace_config() {
     return BeginNestedMessage<T>(33);
   }
@@ -9866,14 +11349,7 @@ class TracePacket : public ::protozero::Message {
       FtraceStats,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FtraceStats kFtraceStats() { return {}; }
+  static constexpr FieldMetadata_FtraceStats kFtraceStats{};
   template <typename T = FtraceStats> T* set_ftrace_stats() {
     return BeginNestedMessage<T>(34);
   }
@@ -9887,14 +11363,7 @@ class TracePacket : public ::protozero::Message {
       TraceStats,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceStats kTraceStats() { return {}; }
+  static constexpr FieldMetadata_TraceStats kTraceStats{};
   template <typename T = TraceStats> T* set_trace_stats() {
     return BeginNestedMessage<T>(35);
   }
@@ -9908,14 +11377,7 @@ class TracePacket : public ::protozero::Message {
       ProfilePacket,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProfilePacket kProfilePacket() { return {}; }
+  static constexpr FieldMetadata_ProfilePacket kProfilePacket{};
   template <typename T = ProfilePacket> T* set_profile_packet() {
     return BeginNestedMessage<T>(37);
   }
@@ -9929,14 +11391,7 @@ class TracePacket : public ::protozero::Message {
       StreamingAllocation,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StreamingAllocation kStreamingAllocation() { return {}; }
+  static constexpr FieldMetadata_StreamingAllocation kStreamingAllocation{};
   template <typename T = StreamingAllocation> T* set_streaming_allocation() {
     return BeginNestedMessage<T>(74);
   }
@@ -9950,14 +11405,7 @@ class TracePacket : public ::protozero::Message {
       StreamingFree,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StreamingFree kStreamingFree() { return {}; }
+  static constexpr FieldMetadata_StreamingFree kStreamingFree{};
   template <typename T = StreamingFree> T* set_streaming_free() {
     return BeginNestedMessage<T>(75);
   }
@@ -9971,14 +11419,7 @@ class TracePacket : public ::protozero::Message {
       BatteryCounters,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Battery kBattery() { return {}; }
+  static constexpr FieldMetadata_Battery kBattery{};
   template <typename T = BatteryCounters> T* set_battery() {
     return BeginNestedMessage<T>(38);
   }
@@ -9992,14 +11433,7 @@ class TracePacket : public ::protozero::Message {
       PowerRails,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PowerRails kPowerRails() { return {}; }
+  static constexpr FieldMetadata_PowerRails kPowerRails{};
   template <typename T = PowerRails> T* set_power_rails() {
     return BeginNestedMessage<T>(40);
   }
@@ -10013,14 +11447,7 @@ class TracePacket : public ::protozero::Message {
       AndroidLogPacket,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidLog kAndroidLog() { return {}; }
+  static constexpr FieldMetadata_AndroidLog kAndroidLog{};
   template <typename T = AndroidLogPacket> T* set_android_log() {
     return BeginNestedMessage<T>(39);
   }
@@ -10034,14 +11461,7 @@ class TracePacket : public ::protozero::Message {
       SystemInfo,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SystemInfo kSystemInfo() { return {}; }
+  static constexpr FieldMetadata_SystemInfo kSystemInfo{};
   template <typename T = SystemInfo> T* set_system_info() {
     return BeginNestedMessage<T>(45);
   }
@@ -10055,19 +11475,26 @@ class TracePacket : public ::protozero::Message {
       Trigger,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Trigger kTrigger() { return {}; }
+  static constexpr FieldMetadata_Trigger kTrigger{};
   template <typename T = Trigger> T* set_trigger() {
     return BeginNestedMessage<T>(46);
   }
 
 
+  using FieldMetadata_ChromeTrigger =
+    ::protozero::proto_utils::FieldMetadata<
+      109,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromeTrigger,
+      TracePacket>;
+
+  static constexpr FieldMetadata_ChromeTrigger kChromeTrigger{};
+  template <typename T = ChromeTrigger> T* set_chrome_trigger() {
+    return BeginNestedMessage<T>(109);
+  }
+
+
   using FieldMetadata_PackagesList =
     ::protozero::proto_utils::FieldMetadata<
       47,
@@ -10076,14 +11503,7 @@ class TracePacket : public ::protozero::Message {
       PackagesList,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PackagesList kPackagesList() { return {}; }
+  static constexpr FieldMetadata_PackagesList kPackagesList{};
   template <typename T = PackagesList> T* set_packages_list() {
     return BeginNestedMessage<T>(47);
   }
@@ -10097,14 +11517,7 @@ class TracePacket : public ::protozero::Message {
       ChromeBenchmarkMetadata,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeBenchmarkMetadata kChromeBenchmarkMetadata() { return {}; }
+  static constexpr FieldMetadata_ChromeBenchmarkMetadata kChromeBenchmarkMetadata{};
   template <typename T = ChromeBenchmarkMetadata> T* set_chrome_benchmark_metadata() {
     return BeginNestedMessage<T>(48);
   }
@@ -10118,14 +11531,7 @@ class TracePacket : public ::protozero::Message {
       PerfettoMetatrace,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PerfettoMetatrace kPerfettoMetatrace() { return {}; }
+  static constexpr FieldMetadata_PerfettoMetatrace kPerfettoMetatrace{};
   template <typename T = PerfettoMetatrace> T* set_perfetto_metatrace() {
     return BeginNestedMessage<T>(49);
   }
@@ -10139,14 +11545,7 @@ class TracePacket : public ::protozero::Message {
       ChromeMetadataPacket,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeMetadata kChromeMetadata() { return {}; }
+  static constexpr FieldMetadata_ChromeMetadata kChromeMetadata{};
   template <typename T = ChromeMetadataPacket> T* set_chrome_metadata() {
     return BeginNestedMessage<T>(51);
   }
@@ -10160,14 +11559,7 @@ class TracePacket : public ::protozero::Message {
       GpuCounterEvent,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GpuCounterEvent kGpuCounterEvent() { return {}; }
+  static constexpr FieldMetadata_GpuCounterEvent kGpuCounterEvent{};
   template <typename T = GpuCounterEvent> T* set_gpu_counter_event() {
     return BeginNestedMessage<T>(52);
   }
@@ -10181,14 +11573,7 @@ class TracePacket : public ::protozero::Message {
       GpuRenderStageEvent,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GpuRenderStageEvent kGpuRenderStageEvent() { return {}; }
+  static constexpr FieldMetadata_GpuRenderStageEvent kGpuRenderStageEvent{};
   template <typename T = GpuRenderStageEvent> T* set_gpu_render_stage_event() {
     return BeginNestedMessage<T>(53);
   }
@@ -10202,14 +11587,7 @@ class TracePacket : public ::protozero::Message {
       StreamingProfilePacket,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StreamingProfilePacket kStreamingProfilePacket() { return {}; }
+  static constexpr FieldMetadata_StreamingProfilePacket kStreamingProfilePacket{};
   template <typename T = StreamingProfilePacket> T* set_streaming_profile_packet() {
     return BeginNestedMessage<T>(54);
   }
@@ -10223,14 +11601,7 @@ class TracePacket : public ::protozero::Message {
       HeapGraph,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HeapGraph kHeapGraph() { return {}; }
+  static constexpr FieldMetadata_HeapGraph kHeapGraph{};
   template <typename T = HeapGraph> T* set_heap_graph() {
     return BeginNestedMessage<T>(56);
   }
@@ -10244,14 +11615,7 @@ class TracePacket : public ::protozero::Message {
       GraphicsFrameEvent,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GraphicsFrameEvent kGraphicsFrameEvent() { return {}; }
+  static constexpr FieldMetadata_GraphicsFrameEvent kGraphicsFrameEvent{};
   template <typename T = GraphicsFrameEvent> T* set_graphics_frame_event() {
     return BeginNestedMessage<T>(57);
   }
@@ -10265,14 +11629,7 @@ class TracePacket : public ::protozero::Message {
       VulkanMemoryEvent,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VulkanMemoryEvent kVulkanMemoryEvent() { return {}; }
+  static constexpr FieldMetadata_VulkanMemoryEvent kVulkanMemoryEvent{};
   template <typename T = VulkanMemoryEvent> T* set_vulkan_memory_event() {
     return BeginNestedMessage<T>(62);
   }
@@ -10286,14 +11643,7 @@ class TracePacket : public ::protozero::Message {
       GpuLog,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GpuLog kGpuLog() { return {}; }
+  static constexpr FieldMetadata_GpuLog kGpuLog{};
   template <typename T = GpuLog> T* set_gpu_log() {
     return BeginNestedMessage<T>(63);
   }
@@ -10307,14 +11657,7 @@ class TracePacket : public ::protozero::Message {
       VulkanApiEvent,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VulkanApiEvent kVulkanApiEvent() { return {}; }
+  static constexpr FieldMetadata_VulkanApiEvent kVulkanApiEvent{};
   template <typename T = VulkanApiEvent> T* set_vulkan_api_event() {
     return BeginNestedMessage<T>(65);
   }
@@ -10328,14 +11671,7 @@ class TracePacket : public ::protozero::Message {
       PerfSample,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PerfSample kPerfSample() { return {}; }
+  static constexpr FieldMetadata_PerfSample kPerfSample{};
   template <typename T = PerfSample> T* set_perf_sample() {
     return BeginNestedMessage<T>(66);
   }
@@ -10349,14 +11685,7 @@ class TracePacket : public ::protozero::Message {
       CpuInfo,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpuInfo kCpuInfo() { return {}; }
+  static constexpr FieldMetadata_CpuInfo kCpuInfo{};
   template <typename T = CpuInfo> T* set_cpu_info() {
     return BeginNestedMessage<T>(67);
   }
@@ -10370,14 +11699,7 @@ class TracePacket : public ::protozero::Message {
       SmapsPacket,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SmapsPacket kSmapsPacket() { return {}; }
+  static constexpr FieldMetadata_SmapsPacket kSmapsPacket{};
   template <typename T = SmapsPacket> T* set_smaps_packet() {
     return BeginNestedMessage<T>(68);
   }
@@ -10391,14 +11713,7 @@ class TracePacket : public ::protozero::Message {
       TracingServiceEvent,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ServiceEvent kServiceEvent() { return {}; }
+  static constexpr FieldMetadata_ServiceEvent kServiceEvent{};
   template <typename T = TracingServiceEvent> T* set_service_event() {
     return BeginNestedMessage<T>(69);
   }
@@ -10412,14 +11727,7 @@ class TracePacket : public ::protozero::Message {
       InitialDisplayState,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InitialDisplayState kInitialDisplayState() { return {}; }
+  static constexpr FieldMetadata_InitialDisplayState kInitialDisplayState{};
   template <typename T = InitialDisplayState> T* set_initial_display_state() {
     return BeginNestedMessage<T>(70);
   }
@@ -10433,14 +11741,7 @@ class TracePacket : public ::protozero::Message {
       GpuMemTotalEvent,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GpuMemTotalEvent kGpuMemTotalEvent() { return {}; }
+  static constexpr FieldMetadata_GpuMemTotalEvent kGpuMemTotalEvent{};
   template <typename T = GpuMemTotalEvent> T* set_gpu_mem_total_event() {
     return BeginNestedMessage<T>(71);
   }
@@ -10454,14 +11755,7 @@ class TracePacket : public ::protozero::Message {
       MemoryTrackerSnapshot,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MemoryTrackerSnapshot kMemoryTrackerSnapshot() { return {}; }
+  static constexpr FieldMetadata_MemoryTrackerSnapshot kMemoryTrackerSnapshot{};
   template <typename T = MemoryTrackerSnapshot> T* set_memory_tracker_snapshot() {
     return BeginNestedMessage<T>(73);
   }
@@ -10475,14 +11769,7 @@ class TracePacket : public ::protozero::Message {
       FrameTimelineEvent,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FrameTimelineEvent kFrameTimelineEvent() { return {}; }
+  static constexpr FieldMetadata_FrameTimelineEvent kFrameTimelineEvent{};
   template <typename T = FrameTimelineEvent> T* set_frame_timeline_event() {
     return BeginNestedMessage<T>(76);
   }
@@ -10496,14 +11783,7 @@ class TracePacket : public ::protozero::Message {
       AndroidEnergyEstimationBreakdown,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidEnergyEstimationBreakdown kAndroidEnergyEstimationBreakdown() { return {}; }
+  static constexpr FieldMetadata_AndroidEnergyEstimationBreakdown kAndroidEnergyEstimationBreakdown{};
   template <typename T = AndroidEnergyEstimationBreakdown> T* set_android_energy_estimation_breakdown() {
     return BeginNestedMessage<T>(77);
   }
@@ -10517,14 +11797,7 @@ class TracePacket : public ::protozero::Message {
       UiState,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UiState kUiState() { return {}; }
+  static constexpr FieldMetadata_UiState kUiState{};
   template <typename T = UiState> T* set_ui_state() {
     return BeginNestedMessage<T>(78);
   }
@@ -10538,14 +11811,7 @@ class TracePacket : public ::protozero::Message {
       AndroidCameraFrameEvent,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidCameraFrameEvent kAndroidCameraFrameEvent() { return {}; }
+  static constexpr FieldMetadata_AndroidCameraFrameEvent kAndroidCameraFrameEvent{};
   template <typename T = AndroidCameraFrameEvent> T* set_android_camera_frame_event() {
     return BeginNestedMessage<T>(80);
   }
@@ -10559,14 +11825,7 @@ class TracePacket : public ::protozero::Message {
       AndroidCameraSessionStats,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidCameraSessionStats kAndroidCameraSessionStats() { return {}; }
+  static constexpr FieldMetadata_AndroidCameraSessionStats kAndroidCameraSessionStats{};
   template <typename T = AndroidCameraSessionStats> T* set_android_camera_session_stats() {
     return BeginNestedMessage<T>(81);
   }
@@ -10580,14 +11839,7 @@ class TracePacket : public ::protozero::Message {
       TranslationTable,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TranslationTable kTranslationTable() { return {}; }
+  static constexpr FieldMetadata_TranslationTable kTranslationTable{};
   template <typename T = TranslationTable> T* set_translation_table() {
     return BeginNestedMessage<T>(82);
   }
@@ -10601,14 +11853,7 @@ class TracePacket : public ::protozero::Message {
       AndroidGameInterventionList,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidGameInterventionList kAndroidGameInterventionList() { return {}; }
+  static constexpr FieldMetadata_AndroidGameInterventionList kAndroidGameInterventionList{};
   template <typename T = AndroidGameInterventionList> T* set_android_game_intervention_list() {
     return BeginNestedMessage<T>(83);
   }
@@ -10622,14 +11867,7 @@ class TracePacket : public ::protozero::Message {
       StatsdAtom,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StatsdAtom kStatsdAtom() { return {}; }
+  static constexpr FieldMetadata_StatsdAtom kStatsdAtom{};
   template <typename T = StatsdAtom> T* set_statsd_atom() {
     return BeginNestedMessage<T>(84);
   }
@@ -10643,14 +11881,7 @@ class TracePacket : public ::protozero::Message {
       AndroidSystemProperty,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidSystemProperty kAndroidSystemProperty() { return {}; }
+  static constexpr FieldMetadata_AndroidSystemProperty kAndroidSystemProperty{};
   template <typename T = AndroidSystemProperty> T* set_android_system_property() {
     return BeginNestedMessage<T>(86);
   }
@@ -10664,37 +11895,37 @@ class TracePacket : public ::protozero::Message {
       EntityStateResidency,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EntityStateResidency kEntityStateResidency() { return {}; }
+  static constexpr FieldMetadata_EntityStateResidency kEntityStateResidency{};
   template <typename T = EntityStateResidency> T* set_entity_state_residency() {
     return BeginNestedMessage<T>(91);
   }
 
 
-  using FieldMetadata_ProfiledFrameSymbols =
+  using FieldMetadata_TraceProvenance =
     ::protozero::proto_utils::FieldMetadata<
-      55,
+      124,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ProfiledFrameSymbols,
+      TraceProvenance,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProfiledFrameSymbols kProfiledFrameSymbols() { return {}; }
-  template <typename T = ProfiledFrameSymbols> T* set_profiled_frame_symbols() {
-    return BeginNestedMessage<T>(55);
+  static constexpr FieldMetadata_TraceProvenance kTraceProvenance{};
+  template <typename T = TraceProvenance> T* set_trace_provenance() {
+    return BeginNestedMessage<T>(124);
+  }
+
+
+  using FieldMetadata_Protovms =
+    ::protozero::proto_utils::FieldMetadata<
+      125,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TracePacket_ProtoVms,
+      TracePacket>;
+
+  static constexpr FieldMetadata_Protovms kProtovms{};
+  template <typename T = TracePacket_ProtoVms> T* set_protovms() {
+    return BeginNestedMessage<T>(125);
   }
 
 
@@ -10706,14 +11937,7 @@ class TracePacket : public ::protozero::Message {
       ModuleSymbols,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ModuleSymbols kModuleSymbols() { return {}; }
+  static constexpr FieldMetadata_ModuleSymbols kModuleSymbols{};
   template <typename T = ModuleSymbols> T* set_module_symbols() {
     return BeginNestedMessage<T>(61);
   }
@@ -10727,14 +11951,7 @@ class TracePacket : public ::protozero::Message {
       DeobfuscationMapping,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DeobfuscationMapping kDeobfuscationMapping() { return {}; }
+  static constexpr FieldMetadata_DeobfuscationMapping kDeobfuscationMapping{};
   template <typename T = DeobfuscationMapping> T* set_deobfuscation_mapping() {
     return BeginNestedMessage<T>(64);
   }
@@ -10748,14 +11965,7 @@ class TracePacket : public ::protozero::Message {
       TrackDescriptor,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrackDescriptor kTrackDescriptor() { return {}; }
+  static constexpr FieldMetadata_TrackDescriptor kTrackDescriptor{};
   template <typename T = TrackDescriptor> T* set_track_descriptor() {
     return BeginNestedMessage<T>(60);
   }
@@ -10769,14 +11979,7 @@ class TracePacket : public ::protozero::Message {
       ProcessDescriptor,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessDescriptor kProcessDescriptor() { return {}; }
+  static constexpr FieldMetadata_ProcessDescriptor kProcessDescriptor{};
   template <typename T = ProcessDescriptor> T* set_process_descriptor() {
     return BeginNestedMessage<T>(43);
   }
@@ -10790,14 +11993,7 @@ class TracePacket : public ::protozero::Message {
       ThreadDescriptor,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThreadDescriptor kThreadDescriptor() { return {}; }
+  static constexpr FieldMetadata_ThreadDescriptor kThreadDescriptor{};
   template <typename T = ThreadDescriptor> T* set_thread_descriptor() {
     return BeginNestedMessage<T>(44);
   }
@@ -10811,14 +12007,7 @@ class TracePacket : public ::protozero::Message {
       FtraceEventBundle,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FtraceEvents kFtraceEvents() { return {}; }
+  static constexpr FieldMetadata_FtraceEvents kFtraceEvents{};
   template <typename T = FtraceEventBundle> T* set_ftrace_events() {
     return BeginNestedMessage<T>(1);
   }
@@ -10832,14 +12021,7 @@ class TracePacket : public ::protozero::Message {
       std::string,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SynchronizationMarker kSynchronizationMarker() { return {}; }
+  static constexpr FieldMetadata_SynchronizationMarker kSynchronizationMarker{};
   void set_synchronization_marker(const uint8_t* data, size_t size) {
     AppendBytes(FieldMetadata_SynchronizationMarker::kFieldId, data, size);
   }
@@ -10863,14 +12045,7 @@ class TracePacket : public ::protozero::Message {
       std::string,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CompressedPackets kCompressedPackets() { return {}; }
+  static constexpr FieldMetadata_CompressedPackets kCompressedPackets{};
   void set_compressed_packets(const uint8_t* data, size_t size) {
     AppendBytes(FieldMetadata_CompressedPackets::kFieldId, data, size);
   }
@@ -10894,14 +12069,7 @@ class TracePacket : public ::protozero::Message {
       ExtensionDescriptor,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExtensionDescriptor kExtensionDescriptor() { return {}; }
+  static constexpr FieldMetadata_ExtensionDescriptor kExtensionDescriptor{};
   template <typename T = ExtensionDescriptor> T* set_extension_descriptor() {
     return BeginNestedMessage<T>(72);
   }
@@ -10915,19 +12083,26 @@ class TracePacket : public ::protozero::Message {
       NetworkPacketEvent,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NetworkPacket kNetworkPacket() { return {}; }
+  static constexpr FieldMetadata_NetworkPacket kNetworkPacket{};
   template <typename T = NetworkPacketEvent> T* set_network_packet() {
     return BeginNestedMessage<T>(88);
   }
 
 
+  using FieldMetadata_NetworkPacketBundle =
+    ::protozero::proto_utils::FieldMetadata<
+      92,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      NetworkPacketBundle,
+      TracePacket>;
+
+  static constexpr FieldMetadata_NetworkPacketBundle kNetworkPacketBundle{};
+  template <typename T = NetworkPacketBundle> T* set_network_packet_bundle() {
+    return BeginNestedMessage<T>(92);
+  }
+
+
   using FieldMetadata_TrackEventRangeOfInterest =
     ::protozero::proto_utils::FieldMetadata<
       90,
@@ -10936,19 +12111,390 @@ class TracePacket : public ::protozero::Message {
       TrackEventRangeOfInterest,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrackEventRangeOfInterest kTrackEventRangeOfInterest() { return {}; }
+  static constexpr FieldMetadata_TrackEventRangeOfInterest kTrackEventRangeOfInterest{};
   template <typename T = TrackEventRangeOfInterest> T* set_track_event_range_of_interest() {
     return BeginNestedMessage<T>(90);
   }
 
 
+  using FieldMetadata_SurfaceflingerLayersSnapshot =
+    ::protozero::proto_utils::FieldMetadata<
+      93,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      LayersSnapshotProto,
+      TracePacket>;
+
+  static constexpr FieldMetadata_SurfaceflingerLayersSnapshot kSurfaceflingerLayersSnapshot{};
+  template <typename T = LayersSnapshotProto> T* set_surfaceflinger_layers_snapshot() {
+    return BeginNestedMessage<T>(93);
+  }
+
+
+  using FieldMetadata_SurfaceflingerTransactions =
+    ::protozero::proto_utils::FieldMetadata<
+      94,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TransactionTraceEntry,
+      TracePacket>;
+
+  static constexpr FieldMetadata_SurfaceflingerTransactions kSurfaceflingerTransactions{};
+  template <typename T = TransactionTraceEntry> T* set_surfaceflinger_transactions() {
+    return BeginNestedMessage<T>(94);
+  }
+
+
+  using FieldMetadata_ShellTransition =
+    ::protozero::proto_utils::FieldMetadata<
+      96,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ShellTransition,
+      TracePacket>;
+
+  static constexpr FieldMetadata_ShellTransition kShellTransition{};
+  template <typename T = ShellTransition> T* set_shell_transition() {
+    return BeginNestedMessage<T>(96);
+  }
+
+
+  using FieldMetadata_ShellHandlerMappings =
+    ::protozero::proto_utils::FieldMetadata<
+      97,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ShellHandlerMappings,
+      TracePacket>;
+
+  static constexpr FieldMetadata_ShellHandlerMappings kShellHandlerMappings{};
+  template <typename T = ShellHandlerMappings> T* set_shell_handler_mappings() {
+    return BeginNestedMessage<T>(97);
+  }
+
+
+  using FieldMetadata_ProtologMessage =
+    ::protozero::proto_utils::FieldMetadata<
+      104,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ProtoLogMessage,
+      TracePacket>;
+
+  static constexpr FieldMetadata_ProtologMessage kProtologMessage{};
+  template <typename T = ProtoLogMessage> T* set_protolog_message() {
+    return BeginNestedMessage<T>(104);
+  }
+
+
+  using FieldMetadata_ProtologViewerConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      105,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ProtoLogViewerConfig,
+      TracePacket>;
+
+  static constexpr FieldMetadata_ProtologViewerConfig kProtologViewerConfig{};
+  template <typename T = ProtoLogViewerConfig> T* set_protolog_viewer_config() {
+    return BeginNestedMessage<T>(105);
+  }
+
+
+  using FieldMetadata_WinscopeExtensions =
+    ::protozero::proto_utils::FieldMetadata<
+      112,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      WinscopeExtensions,
+      TracePacket>;
+
+  static constexpr FieldMetadata_WinscopeExtensions kWinscopeExtensions{};
+  template <typename T = WinscopeExtensions> T* set_winscope_extensions() {
+    return BeginNestedMessage<T>(112);
+  }
+
+
+  using FieldMetadata_EtwEvents =
+    ::protozero::proto_utils::FieldMetadata<
+      95,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      EtwTraceEventBundle,
+      TracePacket>;
+
+  static constexpr FieldMetadata_EtwEvents kEtwEvents{};
+  template <typename T = EtwTraceEventBundle> T* set_etw_events() {
+    return BeginNestedMessage<T>(95);
+  }
+
+
+  using FieldMetadata_V8JsCode =
+    ::protozero::proto_utils::FieldMetadata<
+      99,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      V8JsCode,
+      TracePacket>;
+
+  static constexpr FieldMetadata_V8JsCode kV8JsCode{};
+  template <typename T = V8JsCode> T* set_v8_js_code() {
+    return BeginNestedMessage<T>(99);
+  }
+
+
+  using FieldMetadata_V8InternalCode =
+    ::protozero::proto_utils::FieldMetadata<
+      100,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      V8InternalCode,
+      TracePacket>;
+
+  static constexpr FieldMetadata_V8InternalCode kV8InternalCode{};
+  template <typename T = V8InternalCode> T* set_v8_internal_code() {
+    return BeginNestedMessage<T>(100);
+  }
+
+
+  using FieldMetadata_V8WasmCode =
+    ::protozero::proto_utils::FieldMetadata<
+      101,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      V8WasmCode,
+      TracePacket>;
+
+  static constexpr FieldMetadata_V8WasmCode kV8WasmCode{};
+  template <typename T = V8WasmCode> T* set_v8_wasm_code() {
+    return BeginNestedMessage<T>(101);
+  }
+
+
+  using FieldMetadata_V8RegExpCode =
+    ::protozero::proto_utils::FieldMetadata<
+      102,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      V8RegExpCode,
+      TracePacket>;
+
+  static constexpr FieldMetadata_V8RegExpCode kV8RegExpCode{};
+  template <typename T = V8RegExpCode> T* set_v8_reg_exp_code() {
+    return BeginNestedMessage<T>(102);
+  }
+
+
+  using FieldMetadata_V8CodeMove =
+    ::protozero::proto_utils::FieldMetadata<
+      103,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      V8CodeMove,
+      TracePacket>;
+
+  static constexpr FieldMetadata_V8CodeMove kV8CodeMove{};
+  template <typename T = V8CodeMove> T* set_v8_code_move() {
+    return BeginNestedMessage<T>(103);
+  }
+
+
+  using FieldMetadata_RemoteClockSync =
+    ::protozero::proto_utils::FieldMetadata<
+      107,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      RemoteClockSync,
+      TracePacket>;
+
+  static constexpr FieldMetadata_RemoteClockSync kRemoteClockSync{};
+  template <typename T = RemoteClockSync> T* set_remote_clock_sync() {
+    return BeginNestedMessage<T>(107);
+  }
+
+
+  using FieldMetadata_PixelModemEvents =
+    ::protozero::proto_utils::FieldMetadata<
+      110,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PixelModemEvents,
+      TracePacket>;
+
+  static constexpr FieldMetadata_PixelModemEvents kPixelModemEvents{};
+  template <typename T = PixelModemEvents> T* set_pixel_modem_events() {
+    return BeginNestedMessage<T>(110);
+  }
+
+
+  using FieldMetadata_PixelModemTokenDatabase =
+    ::protozero::proto_utils::FieldMetadata<
+      111,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PixelModemTokenDatabase,
+      TracePacket>;
+
+  static constexpr FieldMetadata_PixelModemTokenDatabase kPixelModemTokenDatabase{};
+  template <typename T = PixelModemTokenDatabase> T* set_pixel_modem_token_database() {
+    return BeginNestedMessage<T>(111);
+  }
+
+
+  using FieldMetadata_CloneSnapshotTrigger =
+    ::protozero::proto_utils::FieldMetadata<
+      113,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      Trigger,
+      TracePacket>;
+
+  static constexpr FieldMetadata_CloneSnapshotTrigger kCloneSnapshotTrigger{};
+  template <typename T = Trigger> T* set_clone_snapshot_trigger() {
+    return BeginNestedMessage<T>(113);
+  }
+
+
+  using FieldMetadata_BluetoothTraceEvent =
+    ::protozero::proto_utils::FieldMetadata<
+      114,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BluetoothTraceEvent,
+      TracePacket>;
+
+  static constexpr FieldMetadata_BluetoothTraceEvent kBluetoothTraceEvent{};
+  template <typename T = BluetoothTraceEvent> T* set_bluetooth_trace_event() {
+    return BeginNestedMessage<T>(114);
+  }
+
+
+  using FieldMetadata_KernelWakelockData =
+    ::protozero::proto_utils::FieldMetadata<
+      115,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      KernelWakelockData,
+      TracePacket>;
+
+  static constexpr FieldMetadata_KernelWakelockData kKernelWakelockData{};
+  template <typename T = KernelWakelockData> T* set_kernel_wakelock_data() {
+    return BeginNestedMessage<T>(115);
+  }
+
+
+  using FieldMetadata_AppWakelockBundle =
+    ::protozero::proto_utils::FieldMetadata<
+      116,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AppWakelockBundle,
+      TracePacket>;
+
+  static constexpr FieldMetadata_AppWakelockBundle kAppWakelockBundle{};
+  template <typename T = AppWakelockBundle> T* set_app_wakelock_bundle() {
+    return BeginNestedMessage<T>(116);
+  }
+
+
+  using FieldMetadata_GenericKernelTaskStateEvent =
+    ::protozero::proto_utils::FieldMetadata<
+      117,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      GenericKernelTaskStateEvent,
+      TracePacket>;
+
+  static constexpr FieldMetadata_GenericKernelTaskStateEvent kGenericKernelTaskStateEvent{};
+  template <typename T = GenericKernelTaskStateEvent> T* set_generic_kernel_task_state_event() {
+    return BeginNestedMessage<T>(117);
+  }
+
+
+  using FieldMetadata_GenericKernelCpuFreqEvent =
+    ::protozero::proto_utils::FieldMetadata<
+      118,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      GenericKernelCpuFrequencyEvent,
+      TracePacket>;
+
+  static constexpr FieldMetadata_GenericKernelCpuFreqEvent kGenericKernelCpuFreqEvent{};
+  template <typename T = GenericKernelCpuFrequencyEvent> T* set_generic_kernel_cpu_freq_event() {
+    return BeginNestedMessage<T>(118);
+  }
+
+
+  using FieldMetadata_GenericKernelTaskRenameEvent =
+    ::protozero::proto_utils::FieldMetadata<
+      120,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      GenericKernelTaskRenameEvent,
+      TracePacket>;
+
+  static constexpr FieldMetadata_GenericKernelTaskRenameEvent kGenericKernelTaskRenameEvent{};
+  template <typename T = GenericKernelTaskRenameEvent> T* set_generic_kernel_task_rename_event() {
+    return BeginNestedMessage<T>(120);
+  }
+
+
+  using FieldMetadata_GenericKernelProcessTree =
+    ::protozero::proto_utils::FieldMetadata<
+      122,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      GenericKernelProcessTree,
+      TracePacket>;
+
+  static constexpr FieldMetadata_GenericKernelProcessTree kGenericKernelProcessTree{};
+  template <typename T = GenericKernelProcessTree> T* set_generic_kernel_process_tree() {
+    return BeginNestedMessage<T>(122);
+  }
+
+
+  using FieldMetadata_CpuPerUidData =
+    ::protozero::proto_utils::FieldMetadata<
+      119,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      CpuPerUidData,
+      TracePacket>;
+
+  static constexpr FieldMetadata_CpuPerUidData kCpuPerUidData{};
+  template <typename T = CpuPerUidData> T* set_cpu_per_uid_data() {
+    return BeginNestedMessage<T>(119);
+  }
+
+
+  using FieldMetadata_EvdevEvent =
+    ::protozero::proto_utils::FieldMetadata<
+      121,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      EvdevEvent,
+      TracePacket>;
+
+  static constexpr FieldMetadata_EvdevEvent kEvdevEvent{};
+  template <typename T = EvdevEvent> T* set_evdev_event() {
+    return BeginNestedMessage<T>(121);
+  }
+
+
+  using FieldMetadata_UserList =
+    ::protozero::proto_utils::FieldMetadata<
+      123,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AndroidUserList,
+      TracePacket>;
+
+  static constexpr FieldMetadata_UserList kUserList{};
+  template <typename T = AndroidUserList> T* set_user_list() {
+    return BeginNestedMessage<T>(123);
+  }
+
+
   using FieldMetadata_ForTesting =
     ::protozero::proto_utils::FieldMetadata<
       900,
@@ -10957,14 +12503,7 @@ class TracePacket : public ::protozero::Message {
       TestEvent,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ForTesting kForTesting() { return {}; }
+  static constexpr FieldMetadata_ForTesting kForTesting{};
   template <typename T = TestEvent> T* set_for_testing() {
     return BeginNestedMessage<T>(900);
   }
@@ -10978,14 +12517,7 @@ class TracePacket : public ::protozero::Message {
       int32_t,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustedUid kTrustedUid() { return {}; }
+  static constexpr FieldMetadata_TrustedUid kTrustedUid{};
   void set_trusted_uid(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_TrustedUid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -11003,14 +12535,7 @@ class TracePacket : public ::protozero::Message {
       uint32_t,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustedPacketSequenceId kTrustedPacketSequenceId() { return {}; }
+  static constexpr FieldMetadata_TrustedPacketSequenceId kTrustedPacketSequenceId{};
   void set_trusted_packet_sequence_id(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_TrustedPacketSequenceId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -11028,14 +12553,7 @@ class TracePacket : public ::protozero::Message {
       int32_t,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustedPid kTrustedPid() { return {}; }
+  static constexpr FieldMetadata_TrustedPid kTrustedPid{};
   void set_trusted_pid(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_TrustedPid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -11053,14 +12571,7 @@ class TracePacket : public ::protozero::Message {
       InternedData,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InternedData kInternedData() { return {}; }
+  static constexpr FieldMetadata_InternedData kInternedData{};
   template <typename T = InternedData> T* set_interned_data() {
     return BeginNestedMessage<T>(12);
   }
@@ -11074,14 +12585,7 @@ class TracePacket : public ::protozero::Message {
       uint32_t,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SequenceFlags kSequenceFlags() { return {}; }
+  static constexpr FieldMetadata_SequenceFlags kSequenceFlags{};
   void set_sequence_flags(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_SequenceFlags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -11099,14 +12603,7 @@ class TracePacket : public ::protozero::Message {
       bool,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IncrementalStateCleared kIncrementalStateCleared() { return {}; }
+  static constexpr FieldMetadata_IncrementalStateCleared kIncrementalStateCleared{};
   void set_incremental_state_cleared(bool value) {
     static constexpr uint32_t field_id = FieldMetadata_IncrementalStateCleared::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -11124,14 +12621,7 @@ class TracePacket : public ::protozero::Message {
       TracePacketDefaults,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TracePacketDefaults kTracePacketDefaults() { return {}; }
+  static constexpr FieldMetadata_TracePacketDefaults kTracePacketDefaults{};
   template <typename T = TracePacketDefaults> T* set_trace_packet_defaults() {
     return BeginNestedMessage<T>(59);
   }
@@ -11145,14 +12635,7 @@ class TracePacket : public ::protozero::Message {
       bool,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PreviousPacketDropped kPreviousPacketDropped() { return {}; }
+  static constexpr FieldMetadata_PreviousPacketDropped kPreviousPacketDropped{};
   void set_previous_packet_dropped(bool value) {
     static constexpr uint32_t field_id = FieldMetadata_PreviousPacketDropped::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -11170,14 +12653,7 @@ class TracePacket : public ::protozero::Message {
       bool,
       TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FirstPacketOnSequence kFirstPacketOnSequence() { return {}; }
+  static constexpr FieldMetadata_FirstPacketOnSequence kFirstPacketOnSequence{};
   void set_first_packet_on_sequence(bool value) {
     static constexpr uint32_t field_id = FieldMetadata_FirstPacketOnSequence::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -11186,6 +12662,150 @@ class TracePacket : public ::protozero::Message {
       ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_MachineId =
+    ::protozero::proto_utils::FieldMetadata<
+      98,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TracePacket>;
+
+  static constexpr FieldMetadata_MachineId kMachineId{};
+  void set_machine_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MachineId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class TracePacket_ProtoVms_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  TracePacket_ProtoVms_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TracePacket_ProtoVms_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TracePacket_ProtoVms_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_instance() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> instance() const { return GetRepeated<::protozero::ConstBytes>(1); }
+};
+
+class TracePacket_ProtoVms : public ::protozero::Message {
+ public:
+  using Decoder = TracePacket_ProtoVms_Decoder;
+  enum : int32_t {
+    kInstanceFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TracePacket.ProtoVms"; }
+
+  using Instance = ::perfetto::protos::pbzero::TracePacket_ProtoVms_Instance;
+
+  using FieldMetadata_Instance =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TracePacket_ProtoVms_Instance,
+      TracePacket_ProtoVms>;
+
+  static constexpr FieldMetadata_Instance kInstance{};
+  template <typename T = TracePacket_ProtoVms_Instance> T* add_instance() {
+    return BeginNestedMessage<T>(1);
+  }
+
+};
+
+class TracePacket_ProtoVms_Instance_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  TracePacket_ProtoVms_Instance_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TracePacket_ProtoVms_Instance_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TracePacket_ProtoVms_Instance_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_program() const { return at<1>().valid(); }
+  ::protozero::ConstBytes program() const { return at<1>().as_bytes(); }
+  bool has_state() const { return at<2>().valid(); }
+  ::protozero::ConstBytes state() const { return at<2>().as_bytes(); }
+  bool has_memory_limit_kb() const { return at<3>().valid(); }
+  uint32_t memory_limit_kb() const { return at<3>().as_uint32(); }
+  bool has_producer_id() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> producer_id() const { return GetRepeated<int32_t>(4); }
+};
+
+class TracePacket_ProtoVms_Instance : public ::protozero::Message {
+ public:
+  using Decoder = TracePacket_ProtoVms_Instance_Decoder;
+  enum : int32_t {
+    kProgramFieldNumber = 1,
+    kStateFieldNumber = 2,
+    kMemoryLimitKbFieldNumber = 3,
+    kProducerIdFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TracePacket.ProtoVms.Instance"; }
+
+
+  using FieldMetadata_Program =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      VmProgram,
+      TracePacket_ProtoVms_Instance>;
+
+  static constexpr FieldMetadata_Program kProgram{};
+  template <typename T = VmProgram> T* set_program() {
+    return BeginNestedMessage<T>(1);
+  }
+
+
+  using FieldMetadata_State =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TracePacket,
+      TracePacket_ProtoVms_Instance>;
+
+  static constexpr FieldMetadata_State kState{};
+  template <typename T = TracePacket> T* set_state() {
+    return BeginNestedMessage<T>(2);
+  }
+
+
+  using FieldMetadata_MemoryLimitKb =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TracePacket_ProtoVms_Instance>;
+
+  static constexpr FieldMetadata_MemoryLimitKb kMemoryLimitKb{};
+  void set_memory_limit_kb(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MemoryLimitKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ProducerId =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TracePacket_ProtoVms_Instance>;
+
+  static constexpr FieldMetadata_ProducerId kProducerId{};
+  void add_producer_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProducerId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 };
 
 } // Namespace.
@@ -11215,20 +12835,27 @@ class TracePacket : public ::protozero::Message {
 // override in order to create a custom data source that gets tracing Start/Stop
 // notifications and emits tracing data.
 
-#include <assert.h>
-#include <stddef.h>
-#include <stdint.h>
-
 #include <array>
 #include <atomic>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
 #include <functional>
 #include <memory>
 #include <mutex>
+#include <type_traits>
+#include <utility>
 
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message_handle.h"
+// gen_amalgamated expanded: #include "perfetto/public/compiler.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/backend_type.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/buffer_exhausted_policy.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/core/flush_flags.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/basic_types.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/internal/data_source_internal.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/internal/data_source_type.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_muxer.h"
@@ -11260,10 +12887,18 @@ namespace perfetto {
 namespace internal {
 class TracingMuxerImpl;
 class TrackEventCategoryRegistry;
-template <typename, const internal::TrackEventCategoryRegistry*>
-class TrackEventDataSource;
+template <const internal::TrackEventCategoryRegistry*>
+class TrackEvent;
 }  // namespace internal
 
+namespace shlib {
+class TrackEvent;
+}  // namespace shlib
+
+namespace test {
+class DataSourceInternalForTest;
+}  // namespace test
+
 // Base class with the virtual methods to get start/stop notifications.
 // Embedders are supposed to derive the templated version below, not this one.
 class PERFETTO_EXPORT_COMPONENT DataSourceBase {
@@ -11277,12 +12912,17 @@ class PERFETTO_EXPORT_COMPONENT DataSourceBase {
   // OnSetup() is invoked when tracing is configured. In most cases this happens
   // just before starting the trace. In the case of deferred start (see
   // deferred_start in trace_config.proto) start might happen later.
+  //
+  // Can be called from any thread.
   class SetupArgs {
    public:
     // This is valid only within the scope of the OnSetup() call and must not
     // be retained.
     const DataSourceConfig* config = nullptr;
 
+    // Backend type.
+    BackendType backend_type = kUnspecifiedBackend;
+
     // The index of this data source instance (0..kMaxDataSourceInstances - 1).
     uint32_t internal_instance_index = 0;
   };
@@ -11293,9 +12933,12 @@ class PERFETTO_EXPORT_COMPONENT DataSourceBase {
     // The index of this data source instance (0..kMaxDataSourceInstances - 1).
     uint32_t internal_instance_index = 0;
   };
+  // Invoked after tracing is actually started.
+  //
+  // Can be called from any thread.
   virtual void OnStart(const StartArgs&);
 
-  class StopArgs {
+  class PERFETTO_EXPORT_COMPONENT StopArgs {
    public:
     virtual ~StopArgs();
 
@@ -11322,6 +12965,11 @@ class PERFETTO_EXPORT_COMPONENT DataSourceBase {
     // The index of this data source instance (0..kMaxDataSourceInstances - 1).
     uint32_t internal_instance_index = 0;
   };
+  // Invoked before tracing is stopped.
+  //
+  // Can be called from any thread. Blocking this for too long it's not a good
+  // idea and can cause deadlocks. Use HandleAsynchronously() to postpone
+  // disabling the data source instance.
   virtual void OnStop(const StopArgs&);
 
   class ClearIncrementalStateArgs {
@@ -11329,7 +12977,41 @@ class PERFETTO_EXPORT_COMPONENT DataSourceBase {
     // The index of this data source instance (0..kMaxDataSourceInstances - 1).
     uint32_t internal_instance_index = 0;
   };
+  // Invoked before marking the thread local per-instance incremental state
+  // outdated.
+  //
+  // Can be called from any thread.
   virtual void WillClearIncrementalState(const ClearIncrementalStateArgs&);
+
+  class FlushArgs {
+   public:
+    virtual ~FlushArgs();
+
+    // HandleFlushAsynchronously() can be called to postpone acknowledging the
+    // flush request. This function returns a closure that must be invoked after
+    // the flush request has been processed. The returned closure can be called
+    // from any thread.
+    virtual std::function<void()> HandleFlushAsynchronously() const = 0;
+
+    // The index of this data source instance (0..kMaxDataSourceInstances - 1).
+    uint32_t internal_instance_index = 0;
+
+    // The reason and initiator of the flush. See flush_flags.h .
+    FlushFlags flush_flags;
+  };
+  // Called when the tracing service requests a Flush. Users can override this
+  // to tell other threads to flush their TraceContext for this data source
+  // (the library cannot execute code on all the threads on its own).
+  //
+  // Can be called from any thread. Blocking this for too long it's not a good
+  // idea and can cause deadlocks. Use HandleAsynchronously() to postpone
+  // sending the flush acknowledgement to the service.
+  virtual void OnFlush(const FlushArgs&);
+
+  // Determines whether a startup session can be adopted by a service-initiated
+  // tracing session (i.e. whether their configs are compatible).
+  virtual bool CanAdoptStartupSession(const DataSourceConfig& startup_config,
+                                      const DataSourceConfig& service_config);
 };
 
 struct DefaultDataSourceTraits {
@@ -11351,12 +13033,38 @@ struct DefaultDataSourceTraits {
       internal::DataSourceStaticState* static_state,
       internal::TracingTLS* root_tls) {
     auto* ds_tls = &root_tls->data_sources_tls[static_state->index];
-    // The per-type TLS is either zero-initialized or must have been initialized
-    // for this specific data source type.
-    assert(!ds_tls->static_state ||
-           ds_tls->static_state->index == static_state->index);
+    // ds_tls->static_state can be:
+    // * nullptr
+    // * equal to static_state
+    // * equal to the static state of a different data source, in tests (when
+    //   ResetForTesting() has been used)
+    // In any case, there's no need to do anything, the caller will reinitialize
+    // static_state.
     return ds_tls;
   }
+
+  // Allows clearing incremental state without destroying and recreating it.
+  // This is useful for data sources that use large data structures (e.g., hash
+  // maps) which are expensive to reallocate. Return true if clearing was
+  // successful. If the method is not defined or returns false, the incremental
+  // state will be destroyed and recreated.
+  static bool ClearIncrementalState(IncrementalStateType*) { return false; }
+};
+
+// Holds the type for a DataSource. Accessed by the static Trace() method
+// fastpaths. This allows redefinitions under a component where a component
+// specific export macro is used.
+// Due to C2086 (redefinition) error on MSVC/clang-cl, internal::DataSourceType
+// can't be a static data member. To avoid explicit specialization after
+// instantiation error, type() needs to be in a template helper class that's
+// instantiated independently from DataSource. See b/280777748.
+template <typename DerivedDataSource,
+          typename DataSourceTraits = DefaultDataSourceTraits>
+struct DataSourceHelper {
+  static internal::DataSourceType& type() {
+    static perfetto::internal::DataSourceType type_;
+    return type_;
+  }
 };
 
 // Templated base class meant to be derived by embedders to create a custom data
@@ -11369,6 +13077,7 @@ template <typename DerivedDataSource,
           typename DataSourceTraits = DefaultDataSourceTraits>
 class DataSource : public DataSourceBase {
   struct DefaultTracePointTraits;
+  using Helper = DataSourceHelper<DerivedDataSource, DataSourceTraits>;
 
  public:
   // The BufferExhaustedPolicy to use for TraceWriters of this DataSource.
@@ -11377,6 +13086,9 @@ class DataSource : public DataSourceBase {
   constexpr static BufferExhaustedPolicy kBufferExhaustedPolicy =
       BufferExhaustedPolicy::kDrop;
 
+  // Whether the kBufferExhaustedPolicy policy above is overridable via config.
+  constexpr static bool kBufferExhaustedPolicyConfigurable = false;
+
   // When this flag is false, we cannot have multiple instances of this data
   // source. When a data source is already active and if we attempt
   // to start another instance of that data source (via another tracing
@@ -11455,7 +13167,8 @@ class DataSource : public DataSourceBase {
     // validity before using it. After checking, the handle is guaranteed to
     // remain valid until the handle goes out of scope.
     LockedHandle<DerivedDataSource> GetDataSourceLocked() const {
-      auto* internal_state = type_.static_state()->TryGet(instance_index_);
+      auto* internal_state =
+          Helper::type().static_state()->TryGet(instance_index_);
       if (!internal_state)
         return LockedHandle<DerivedDataSource>();
       std::unique_lock<std::recursive_mutex> lock(internal_state->lock);
@@ -11473,13 +13186,15 @@ class DataSource : public DataSourceBase {
 
     typename DataSourceTraits::IncrementalStateType* GetIncrementalState() {
       return static_cast<typename DataSourceTraits::IncrementalStateType*>(
-          type_.GetIncrementalState(tls_inst_, instance_index_));
+          Helper::type().GetIncrementalState(tls_inst_, instance_index_));
     }
 
+    uint32_t instance_index() const { return instance_index_; }
+
    private:
     friend class DataSource;
-    template <typename, const internal::TrackEventCategoryRegistry*>
-    friend class internal::TrackEventDataSource;
+    template <const internal::TrackEventCategoryRegistry*>
+    friend class internal::TrackEvent;
     TraceContext(internal::DataSourceInstanceThreadLocalState* tls_inst,
                  uint32_t instance_index)
         : tls_inst_(tls_inst), instance_index_(instance_index) {}
@@ -11551,20 +13266,20 @@ class DataSource : public DataSourceBase {
       typename Traits::TracePointData trace_point_data = {}) {
     PERFETTO_DCHECK(cached_instances);
 
-    if (!type_.TracePrologue<DataSourceTraits, Traits>(
+    if (!Helper::type().template TracePrologue<DataSourceTraits, Traits>(
             &tls_state_, &cached_instances, trace_point_data)) {
       return;
     }
 
     for (internal::DataSourceType::InstancesIterator it =
-             type_.BeginIteration<Traits>(cached_instances, tls_state_,
-                                          trace_point_data);
-         it.instance;
-         type_.NextIteration<Traits>(&it, tls_state_, trace_point_data)) {
+             Helper::type().template BeginIteration<Traits>(
+                 cached_instances, tls_state_, trace_point_data);
+         it.instance; Helper::type().template NextIteration<Traits>(
+             &it, tls_state_, trace_point_data)) {
       tracing_fn(TraceContext(it.instance, it.i));
     }
 
-    type_.TraceEpilogue(tls_state_);
+    Helper::type().TraceEpilogue(tls_state_);
   }
 
   // Registers the data source on all tracing backends, including ones that
@@ -11582,32 +13297,45 @@ class DataSource : public DataSourceBase {
                        const Args&... constructor_args) {
     // Silences -Wunused-variable warning in case the trace method is not used
     // by the translation unit that declares the data source.
-    (void)type_;
     (void)tls_state_;
 
     auto factory = [constructor_args...]() {
       return std::unique_ptr<DataSourceBase>(
           new DerivedDataSource(constructor_args...));
     };
-    internal::DataSourceParams params{
-        DerivedDataSource::kSupportsMultipleInstances,
-        DerivedDataSource::kRequiresCallbacksUnderLock};
-    return type_.Register(
-        descriptor, factory, params, DerivedDataSource::kBufferExhaustedPolicy,
+    constexpr bool no_flush =
+        std::is_same_v<decltype(&DerivedDataSource::OnFlush),
+                       decltype(&DataSourceBase::OnFlush)>;
+    internal::DataSourceParams params;
+    params.requires_callbacks_under_lock =
+        DerivedDataSource::kRequiresCallbacksUnderLock;
+    params.supports_multiple_instances =
+        DerivedDataSource::kSupportsMultipleInstances;
+    params.default_buffer_exhausted_policy =
+        DerivedDataSource::kBufferExhaustedPolicy;
+    params.buffer_exhausted_policy_configurable =
+        DerivedDataSource::kBufferExhaustedPolicyConfigurable;
+    return Helper::type().Register(
+        descriptor, factory, params, no_flush,
         GetCreateTlsFn(
             static_cast<typename DataSourceTraits::TlsStateType*>(nullptr)),
         GetCreateIncrementalStateFn(
             static_cast<typename DataSourceTraits::IncrementalStateType*>(
                 nullptr)),
+        GetClearIncrementalStateFn(
+            static_cast<typename DataSourceTraits::IncrementalStateType*>(
+                nullptr)),
         nullptr);
   }
 
   // Updates the data source descriptor.
   static void UpdateDescriptor(const DataSourceDescriptor& descriptor) {
-    type_.UpdateDescriptor(descriptor);
+    Helper::type().UpdateDescriptor(descriptor);
   }
 
  private:
+  friend ::perfetto::test::DataSourceInternalForTest;
+  friend ::perfetto::shlib::TrackEvent;
   // Traits for customizing the behavior of a specific trace point.
   struct DefaultTracePointTraits {
     // By default, every call to DataSource::Trace() will record trace events
@@ -11624,7 +13352,7 @@ class DataSource : public DataSourceBase {
     // implement per-category enabled states.
     struct TracePointData {};
     static constexpr std::atomic<uint32_t>* GetActiveInstances(TracePointData) {
-      return type_.valid_instances();
+      return Helper::type().valid_instances();
     }
   };
 
@@ -11651,6 +13379,44 @@ class DataSource : public DataSourceBase {
     return nullptr;
   }
 
+  // Detection idiom for checking if DataSourceTraits::ClearIncrementalState(T*)
+  // exists. Supports traits that don't inherit from DefaultDataSourceTraits.
+  template <typename Traits, typename T, typename = void>
+  struct HasClearIncrementalState : std::false_type {};
+
+  template <typename Traits, typename T>
+  struct HasClearIncrementalState<
+      Traits,
+      T,
+      std::void_t<decltype(Traits::ClearIncrementalState(std::declval<T*>()))>>
+      : std::true_type {};
+
+  // Wrapper that calls DataSourceTraits::ClearIncrementalState if it exists.
+  // Returns false if the method is not defined in the traits.
+  template <typename T>
+  static bool ClearIncrementalStateWrapper(void* incremental_state, void*) {
+    if constexpr (HasClearIncrementalState<DataSourceTraits, T>::value) {
+      return DataSourceTraits::ClearIncrementalState(
+          reinterpret_cast<T*>(incremental_state));
+    } else {
+      base::ignore_result(incremental_state);
+      return false;
+    }
+  }
+
+  // The second parameter here is used to specialize the case where there is no
+  // incremental state type.
+  template <typename T>
+  static internal::DataSourceType::ClearIncrementalStateFn
+  GetClearIncrementalStateFn(const T*) {
+    return &ClearIncrementalStateWrapper<T>;
+  }
+
+  static internal::DataSourceType::ClearIncrementalStateFn
+  GetClearIncrementalStateFn(const void*) {
+    return nullptr;
+  }
+
   template <typename T>
   static internal::DataSourceInstanceThreadLocalState::ObjectWithDeleter
   CreateDataSourceCustomTls(
@@ -11674,10 +13440,6 @@ class DataSource : public DataSourceBase {
     return nullptr;
   }
 
-  // The type of this data source. Accessed by the static Trace() method
-  // fastpaths.
-  static internal::DataSourceType type_;
-
   // This TLS object is a cached raw pointer and has deliberately no destructor.
   // The Platform implementation is supposed to create and manage the lifetime
   // of the Platform::ThreadLocalObject and take care of destroying it.
@@ -11685,16 +13447,12 @@ class DataSource : public DataSourceBase {
   // destructors) that we need to defer to the embedder. In chromium's platform
   // implementation, for instance, the tls slot is implemented using
   // chromium's base::ThreadLocalStorage.
-  static PERFETTO_THREAD_LOCAL internal::DataSourceThreadLocalState* tls_state_;
+  static thread_local internal::DataSourceThreadLocalState* tls_state_;
 };
 
 // static
 template <typename T, typename D>
-internal::DataSourceType DataSource<T, D>::type_;
-// static
-template <typename T, typename D>
-PERFETTO_THREAD_LOCAL internal::DataSourceThreadLocalState*
-    DataSource<T, D>::tls_state_;
+thread_local internal::DataSourceThreadLocalState* DataSource<T, D>::tls_state_;
 
 }  // namespace perfetto
 
@@ -11702,7 +13460,7 @@ PERFETTO_THREAD_LOCAL internal::DataSourceThreadLocalState*
 // the macro invocation (e.g., "MACRO(...);") to avoid warnings about extra
 // semicolons.
 #define PERFETTO_INTERNAL_SWALLOW_SEMICOLON() \
-  extern int perfetto_internal_unused
+  [[maybe_unused]] extern int perfetto_internal_unused
 
 // This macro must be used once for each data source next to the data source's
 // declaration.
@@ -11715,16 +13473,11 @@ PERFETTO_THREAD_LOCAL internal::DataSourceThreadLocalState*
 // where a component specific export macro is used.
 #define PERFETTO_DECLARE_DATA_SOURCE_STATIC_MEMBERS_WITH_ATTRS(attrs, ...) \
   template <>                                                              \
-  attrs perfetto::internal::DataSourceType                                 \
-      perfetto::DataSource<__VA_ARGS__>::type_
+  attrs perfetto::internal::DataSourceType&                                \
+  perfetto::DataSourceHelper<__VA_ARGS__>::type()
 
 // This macro must be used once for each data source in one source file to
 // allocate static storage for the data source's static state.
-//
-// Note: if MSVC fails with a C2086 (redefinition) error here, use the
-// permissive- flag to enable standards-compliant mode. See
-// https://developercommunity.visualstudio.com/content/problem/319447/
-// explicit-specialization-of-static-data-member-inco.html.
 #define PERFETTO_DEFINE_DATA_SOURCE_STATIC_MEMBERS(...)  \
   PERFETTO_DEFINE_DATA_SOURCE_STATIC_MEMBERS_WITH_ATTRS( \
       PERFETTO_COMPONENT_EXPORT, __VA_ARGS__)
@@ -11734,8 +13487,12 @@ PERFETTO_THREAD_LOCAL internal::DataSourceThreadLocalState*
 // where a component specific export macro is used.
 #define PERFETTO_DEFINE_DATA_SOURCE_STATIC_MEMBERS_WITH_ATTRS(attrs, ...) \
   template <>                                                             \
-  attrs perfetto::internal::DataSourceType                                \
-      perfetto::DataSource<__VA_ARGS__>::type_ {}
+  perfetto::internal::DataSourceType&                                     \
+  perfetto::DataSourceHelper<__VA_ARGS__>::type() {                       \
+    static perfetto::internal::DataSourceType type_;                      \
+    return type_;                                                         \
+  }                                                                       \
+  PERFETTO_INTERNAL_SWALLOW_SEMICOLON()
 
 #endif  // INCLUDE_PERFETTO_TRACING_DATA_SOURCE_H_
 // gen_amalgamated begin header: include/perfetto/tracing/track_event.h
@@ -11797,8 +13554,8 @@ using decay_t = typename std::decay<T>::type;
 
 template <class T>
 struct remove_cvref {
-  using type = typename std::remove_cv<typename std::remove_cv<
-      typename std::remove_reference<T>::type>::type>::type;
+  using type =
+      typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 };
 template <class T>
 using remove_cvref_t = typename remove_cvref<T>::type;
@@ -11816,6 +13573,307 @@ struct is_specialization<Ref<Args...>, Ref> : std::true_type {};
 }  // namespace perfetto
 
 #endif  // INCLUDE_PERFETTO_BASE_TEMPLATE_UTIL_H_
+// gen_amalgamated begin header: include/perfetto/base/thread_annotations.h
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_BASE_THREAD_ANNOTATIONS_H_
+#define INCLUDE_PERFETTO_BASE_THREAD_ANNOTATIONS_H_
+
+// This header file contains macro definitions for thread safety annotations
+// that allow developers to document the locking policies of multi-threaded
+// code. The annotations can also help program analysis tools to identify
+// potential thread safety issues.
+//
+// These macro definitions are copied from the Chromium code base:
+// https://source.chromium.org/chromium/chromium/src/+/main:base/thread_annotations.h;drc=10d865767e72f494da1e4e868eb6ae9befe87422
+// with the 'PERFETTO_' prefix added.
+//
+// Note that no analysis is done inside constructors and destructors,
+// regardless of what attributes are used. See
+// https://clang.llvm.org/docs/ThreadSafetyAnalysis.html#no-checking-inside-constructors-and-destructors
+// for details.
+//
+// Note that the annotations we use are described as deprecated in the Clang
+// documentation, linked below. E.g. we use PERFETTO_EXCLUSIVE_LOCKS_REQUIRED
+// where the Clang docs use REQUIRES.
+//
+// http://clang.llvm.org/docs/ThreadSafetyAnalysis.html
+//
+// We use the deprecated Clang annotations to match Abseil (relevant header
+// linked below) and its ecosystem of libraries. We will follow Abseil with
+// respect to upgrading to more modern annotations.
+//
+// https://github.com/abseil/abseil-cpp/blob/master/absl/base/thread_annotations.h
+//
+// These annotations are implemented using compiler attributes. Using the macros
+// defined here instead of raw attributes allow for portability and future
+// compatibility.
+//
+// When referring to mutexes in the arguments of the attributes, you should
+// use variable names or more complex expressions (e.g. my_object->mutex_)
+// that evaluate to a concrete mutex object whenever possible. If the mutex
+// you want to refer to is not in scope, you may use a member pointer
+// (e.g. &MyClass::mutex_) to refer to a mutex in some (unknown) object.
+
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+
+#ifdef THREAD_SANITIZER
+#include <sanitizer/tsan_interface.h>
+
+#define PERFETTO_TSAN_MUTEX_CREATE __tsan_mutex_create
+#define PERFETTO_TSAN_MUTEX_DESTROY __tsan_mutex_destroy
+#define PERFETTO_TSAN_MUTEX_PRE_LOCK __tsan_mutex_pre_lock
+#define PERFETTO_TSAN_MUTEX_POST_LOCK __tsan_mutex_post_lock
+#define PERFETTO_TSAN_MUTEX_PRE_UNLOCK __tsan_mutex_pre_unlock
+#define PERFETTO_TSAN_MUTEX_POST_UNLOCK __tsan_mutex_post_unlock
+#else
+
+#define PERFETTO_TSAN_MUTEX_CREATE(...)
+#define PERFETTO_TSAN_MUTEX_DESTROY(...)
+#define PERFETTO_TSAN_MUTEX_PRE_LOCK(...)
+#define PERFETTO_TSAN_MUTEX_POST_LOCK(...)
+#define PERFETTO_TSAN_MUTEX_PRE_UNLOCK(...)
+#define PERFETTO_TSAN_MUTEX_POST_UNLOCK(...)
+
+#endif
+
+#if defined(__clang__) && PERFETTO_BUILDFLAG(PERFETTO_THREAD_SAFETY_ANNOTATIONS)
+#define PERFETTO_THREAD_ANNOTATION_ATTRIBUTE__(x) __attribute__((x))
+#else
+#define PERFETTO_THREAD_ANNOTATION_ATTRIBUTE__(x)  // no-op
+#endif
+
+// PERFETTO_GUARDED_BY()
+//
+// Documents if a shared field or global variable needs to be protected by a
+// mutex. PERFETTO_GUARDED_BY() allows the user to specify a particular mutex
+// that should be held when accessing the annotated variable.
+//
+// Example:
+//
+//   Mutex mu;
+//   int p1 PERFETTO_GUARDED_BY(mu);
+#define PERFETTO_GUARDED_BY(x) \
+  PERFETTO_THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
+
+// PERFETTO_PT_GUARDED_BY()
+//
+// Documents if the memory location pointed to by a pointer should be guarded
+// by a mutex when dereferencing the pointer.
+//
+// Example:
+//   Mutex mu;
+//   int *p1 PERFETTO_PT_GUARDED_BY(mu);
+//
+// Note that a pointer variable to a shared memory location could itself be a
+// shared variable.
+//
+// Example:
+//
+//     // `q`, guarded by `mu1`, points to a shared memory location that is
+//     // guarded by `mu2`:
+//     int *q PERFETTO_GUARDED_BY(mu1) PERFETTO_PT_GUARDED_BY(mu2);
+#define PERFETTO_PT_GUARDED_BY(x) \
+  PERFETTO_THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x))
+
+// PERFETTO_ACQUIRED_AFTER() / PERFETTO_ACQUIRED_BEFORE()
+//
+// Documents the acquisition order between locks that can be held
+// simultaneously by a thread. For any two locks that need to be annotated
+// to establish an acquisition order, only one of them needs the annotation.
+// (i.e. You don't have to annotate both locks with both PERFETTO_ACQUIRED_AFTER
+// and PERFETTO_ACQUIRED_BEFORE.)
+//
+// Example:
+//
+//   Mutex m1;
+//   Mutex m2 PERFETTO_ACQUIRED_AFTER(m1);
+#define PERFETTO_ACQUIRED_AFTER(...) \
+  PERFETTO_THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(__VA_ARGS__))
+
+#define PERFETTO_ACQUIRED_BEFORE(...) \
+  PERFETTO_THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(__VA_ARGS__))
+
+// PERFETTO_EXCLUSIVE_LOCKS_REQUIRED() / PERFETTO_SHARED_LOCKS_REQUIRED()
+//
+// Documents a function that expects a mutex to be held prior to entry.
+// The mutex is expected to be held both on entry to, and exit from, the
+// function.
+//
+// Example:
+//
+//   Mutex mu1, mu2;
+//   int a PERFETTO_GUARDED_BY(mu1);
+//   int b PERFETTO_GUARDED_BY(mu2);
+//
+//   void foo() PERFETTO_EXCLUSIVE_LOCKS_REQUIRED(mu1, mu2) { ... };
+#define PERFETTO_EXCLUSIVE_LOCKS_REQUIRED(...) \
+  PERFETTO_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__))
+
+#define PERFETTO_SHARED_LOCKS_REQUIRED(...) \
+  PERFETTO_THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__))
+
+// PERFETTO_LOCKS_EXCLUDED()
+//
+// Documents the locks acquired in the body of the function. These locks
+// cannot be held when calling this function (as Abseil's `Mutex` locks are
+// non-reentrant).
+#define PERFETTO_LOCKS_EXCLUDED(...) \
+  PERFETTO_THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
+
+// PERFETTO_LOCK_RETURNED()
+//
+// Documents a function that returns a mutex without acquiring it.  For example,
+// a public getter method that returns a pointer to a private mutex should
+// be annotated with PERFETTO_LOCK_RETURNED.
+#define PERFETTO_LOCK_RETURNED(x) \
+  PERFETTO_THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
+
+// PERFETTO_LOCKABLE
+//
+// Documents if a class/type is a lockable type (such as the `Mutex` class).
+#define PERFETTO_LOCKABLE PERFETTO_THREAD_ANNOTATION_ATTRIBUTE__(lockable)
+
+// PERFETTO_SCOPED_LOCKABLE
+//
+// Documents if a class does RAII locking (such as the `MutexLock` class).
+// The constructor should use `LOCK_FUNCTION()` to specify the mutex that is
+// acquired, and the destructor should use `PERFETTO_UNLOCK_FUNCTION()` with no
+// arguments; the analysis will assume that the destructor unlocks whatever the
+// constructor locked.
+#define PERFETTO_SCOPED_LOCKABLE \
+  PERFETTO_THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
+
+// PERFETTO_EXCLUSIVE_LOCK_FUNCTION()
+//
+// Documents functions that acquire a lock in the body of a function, and do
+// not release it.
+#define PERFETTO_EXCLUSIVE_LOCK_FUNCTION(...) \
+  PERFETTO_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__))
+
+// PERFETTO_SHARED_LOCK_FUNCTION()
+//
+// Documents functions that acquire a shared (reader) lock in the body of a
+// function, and do not release it.
+#define PERFETTO_SHARED_LOCK_FUNCTION(...) \
+  PERFETTO_THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__))
+
+// PERFETTO_UNLOCK_FUNCTION()
+//
+// Documents functions that expect a lock to be held on entry to the function,
+// and release it in the body of the function.
+#define PERFETTO_UNLOCK_FUNCTION(...) \
+  PERFETTO_THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__))
+
+// PERFETTO_EXCLUSIVE_TRYLOCK_FUNCTION() / PERFETTO_SHARED_TRYLOCK_FUNCTION()
+//
+// Documents functions that try to acquire a lock, and return success or failure
+// (or a non-boolean value that can be interpreted as a boolean).
+// The first argument should be `true` for functions that return `true` on
+// success, or `false` for functions that return `false` on success. The second
+// argument specifies the mutex that is locked on success. If unspecified, this
+// mutex is assumed to be `this`.
+#define PERFETTO_EXCLUSIVE_TRYLOCK_FUNCTION(...) \
+  PERFETTO_THREAD_ANNOTATION_ATTRIBUTE__(        \
+      exclusive_trylock_function(__VA_ARGS__))
+
+#define PERFETTO_SHARED_TRYLOCK_FUNCTION(...) \
+  PERFETTO_THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__))
+
+// PERFETTO_ASSERT_EXCLUSIVE_LOCK() / PERFETTO_ASSERT_SHARED_LOCK()
+//
+// Documents functions that dynamically check to see if a lock is held, and fail
+// if it is not held.
+#define PERFETTO_ASSERT_EXCLUSIVE_LOCK(...) \
+  PERFETTO_THREAD_ANNOTATION_ATTRIBUTE__(assert_exclusive_lock(__VA_ARGS__))
+
+#define PERFETTO_ASSERT_SHARED_LOCK(...) \
+  PERFETTO_THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_lock(__VA_ARGS__))
+
+// PERFETTO_NO_THREAD_SAFETY_ANALYSIS is special and differs from other
+// macros defined in this file, it was defined in `compiler.h` and used before
+// we introduce Thread Safety Analysis. Therefore, we define it here even if
+// 'PERFETTO_ENABLE_THREAD_SAFETY_ANNOTATIONS' macro is not defined.
+
+#if defined(__clang__)
+// PERFETTO_NO_THREAD_SAFETY_ANALYSIS
+//
+// Turns off thread safety checking within the body of a particular function.
+// This annotation is used to mark functions that are known to be correct, but
+// the locking behavior is more complicated than the analyzer can handle.
+#define PERFETTO_NO_THREAD_SAFETY_ANALYSIS \
+  __attribute__((no_thread_safety_analysis))
+#else
+#define PERFETTO_NO_THREAD_SAFETY_ANALYSIS
+#endif
+
+//------------------------------------------------------------------------------
+// Tool-Supplied Annotations
+//------------------------------------------------------------------------------
+
+// PERFETTO_TS_UNCHECKED should be placed around lock expressions that are not
+// valid C++ syntax, but which are present for documentation purposes.  These
+// annotations will be ignored by the analysis.
+#define PERFETTO_TS_UNCHECKED(x) ""
+
+// TS_FIXME is used to mark lock expressions that are not valid C++ syntax.
+// It is used by automated tools to mark and disable invalid expressions.
+// The annotation should either be fixed, or changed to PERFETTO_TS_UNCHECKED.
+#define PERFETTO_TS_FIXME(x) ""
+
+// Like NO_THREAD_SAFETY_ANALYSIS, this turns off checking within the body of
+// a particular function.  However, this attribute is used to mark functions
+// that are incorrect and need to be fixed.  It is used by automated tools to
+// avoid breaking the build when the analysis is updated.
+// Code owners are expected to eventually fix the routine.
+#define PERFETTO_NO_THREAD_SAFETY_ANALYSIS_FIXME \
+  PERFETTO_NO_THREAD_SAFETY_ANALYSIS
+
+// Similar to NO_THREAD_SAFETY_ANALYSIS_FIXME, this macro marks a
+// PERFETTO_GUARDED_BY annotation that needs to be fixed, because it is
+// producing thread safety warning.  It disables the PERFETTO_GUARDED_BY.
+#define PERFETTO_PERFETTO_GUARDED_BY_FIXME(x)
+
+// Disables warnings for a single read operation.  This can be used to avoid
+// warnings when it is known that the read is not actually involved in a race,
+// but the compiler cannot confirm that.
+#define PERFETTO_TS_UNCHECKED_READ(x) \
+  perfetto::thread_safety_analysis::ts_unchecked_read(x)
+
+namespace perfetto {
+namespace thread_safety_analysis {
+
+// Takes a reference to a guarded data member, and returns an unguarded
+// reference.
+template <typename T>
+inline const T& ts_unchecked_read(const T& v)
+    PERFETTO_NO_THREAD_SAFETY_ANALYSIS {
+  return v;
+}
+
+template <typename T>
+inline T& ts_unchecked_read(T& v) PERFETTO_NO_THREAD_SAFETY_ANALYSIS {
+  return v;
+}
+
+}  // namespace thread_safety_analysis
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_BASE_THREAD_ANNOTATIONS_H_
 // gen_amalgamated begin header: include/perfetto/tracing/event_context.h
 // gen_amalgamated begin header: include/perfetto/tracing/internal/track_event_internal.h
 // gen_amalgamated begin header: include/perfetto/base/flat_set.h
@@ -11838,7 +13896,10 @@ struct is_specialization<Ref<Args...>, Ref> : std::true_type {};
 #ifndef INCLUDE_PERFETTO_BASE_FLAT_SET_H_
 #define INCLUDE_PERFETTO_BASE_FLAT_SET_H_
 
+#include <stddef.h>
+
 #include <algorithm>
+#include <utility>
 #include <vector>
 
 // A vector-based set::set-like container.
@@ -11910,6 +13971,8 @@ class FlatSet {
   size_t size() const { return entries_.size(); }
   const_iterator begin() const { return entries_.begin(); }
   const_iterator end() const { return entries_.end(); }
+  const T& back() const { return entries_.back(); }
+  void pop_back() { entries_.pop_back(); }
 
  private:
   std::vector<T> entries_;
@@ -11979,7 +14042,7 @@ class PERFETTO_EXPORT_COMPONENT MessageArena {
   // DCHECKs, it MUST be the pointer obtained by the last NewMessage() call.
   void DeleteLastMessage(Message* msg) {
     PERFETTO_DCHECK(!blocks_.empty() && blocks_.front().entries > 0);
-    PERFETTO_DCHECK(&blocks_.front().storage[blocks_.front().entries - 1] ==
+    PERFETTO_DCHECK(blocks_.front().storage[blocks_.front().entries - 1] ==
                     static_cast<void*>(msg));
     DeleteLastMessageInternal();
   }
@@ -12004,8 +14067,7 @@ class PERFETTO_EXPORT_COMPONENT MessageArena {
 
     Block() { PERFETTO_ASAN_POISON(storage, sizeof(storage)); }
 
-    std::aligned_storage<sizeof(Message), alignof(Message)>::type
-        storage[kCapacity];
+    alignas(Message) char storage[kCapacity][sizeof(Message)];
     uint32_t entries = 0;  // # Message entries used (<= kCapacity).
   };
 
@@ -12151,6 +14213,9 @@ class PERFETTO_EXPORT_COMPONENT ScatteredHeapBuffer
   // Stitch all the slices into a single contiguous buffer.
   std::vector<uint8_t> StitchSlices();
 
+  // Stitch all the slices into a contiguous output buffer.
+  std::pair<std::unique_ptr<uint8_t[]>, size_t> StitchAsUniquePtr();
+
   // Note that the returned ranges point back to this buffer and thus cannot
   // outlive it.
   std::vector<protozero::ContiguousMemoryRange> GetRanges();
@@ -12229,6 +14294,11 @@ class HeapBuffered {
     return std::string(reinterpret_cast<const char*>(vec.data()), vec.size());
   }
 
+  std::pair<std::unique_ptr<uint8_t[]>, size_t> SerializeAsUniquePtr() {
+    msg_.Finalize();
+    return shb_.StitchAsUniquePtr();
+  }
+
   std::vector<protozero::ContiguousMemoryRange> GetRanges() {
     msg_.Finalize();
     return shb_.GetRanges();
@@ -12349,13 +14419,19 @@ struct check_traced_proto_support;
 namespace perfetto {
 namespace protos {
 namespace pbzero {
-
 class DebugAnnotation;
 class DebugAnnotation_NestedValue;
 namespace perfetto_pbzero_enum_DebugAnnotation_NestedValue {
 enum NestedType : int32_t;
 }  // namespace perfetto_pbzero_enum_DebugAnnotation_NestedValue
 using DebugAnnotation_NestedValue_NestedType = perfetto_pbzero_enum_DebugAnnotation_NestedValue::NestedType;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
 namespace perfetto_pbzero_enum_DebugAnnotation_NestedValue {
 enum NestedType : int32_t {
@@ -12386,7 +14462,7 @@ const char* DebugAnnotation_NestedValue_NestedType_Name(::perfetto::protos::pbze
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-class DebugAnnotationValueTypeName_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DebugAnnotationValueTypeName_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
   DebugAnnotationValueTypeName_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit DebugAnnotationValueTypeName_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -12415,14 +14491,7 @@ class DebugAnnotationValueTypeName : public ::protozero::Message {
       uint64_t,
       DebugAnnotationValueTypeName>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Iid kIid() { return {}; }
+  static constexpr FieldMetadata_Iid kIid{};
   void set_iid(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -12440,14 +14509,7 @@ class DebugAnnotationValueTypeName : public ::protozero::Message {
       std::string,
       DebugAnnotationValueTypeName>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -12464,7 +14526,7 @@ class DebugAnnotationValueTypeName : public ::protozero::Message {
   }
 };
 
-class DebugAnnotationName_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DebugAnnotationName_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
   DebugAnnotationName_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit DebugAnnotationName_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -12493,14 +14555,7 @@ class DebugAnnotationName : public ::protozero::Message {
       uint64_t,
       DebugAnnotationName>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Iid kIid() { return {}; }
+  static constexpr FieldMetadata_Iid kIid{};
   void set_iid(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -12518,14 +14573,7 @@ class DebugAnnotationName : public ::protozero::Message {
       std::string,
       DebugAnnotationName>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -12542,7 +14590,7 @@ class DebugAnnotationName : public ::protozero::Message {
   }
 };
 
-class DebugAnnotation_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/17, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class DebugAnnotation_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/17> {
  public:
   DebugAnnotation_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit DebugAnnotation_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -12614,14 +14662,7 @@ class DebugAnnotation : public ::protozero::Message {
       uint64_t,
       DebugAnnotation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NameIid kNameIid() { return {}; }
+  static constexpr FieldMetadata_NameIid kNameIid{};
   void set_name_iid(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NameIid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -12639,14 +14680,7 @@ class DebugAnnotation : public ::protozero::Message {
       std::string,
       DebugAnnotation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -12670,14 +14704,7 @@ class DebugAnnotation : public ::protozero::Message {
       bool,
       DebugAnnotation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BoolValue kBoolValue() { return {}; }
+  static constexpr FieldMetadata_BoolValue kBoolValue{};
   void set_bool_value(bool value) {
     static constexpr uint32_t field_id = FieldMetadata_BoolValue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -12695,14 +14722,7 @@ class DebugAnnotation : public ::protozero::Message {
       uint64_t,
       DebugAnnotation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UintValue kUintValue() { return {}; }
+  static constexpr FieldMetadata_UintValue kUintValue{};
   void set_uint_value(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_UintValue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -12720,14 +14740,7 @@ class DebugAnnotation : public ::protozero::Message {
       int64_t,
       DebugAnnotation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IntValue kIntValue() { return {}; }
+  static constexpr FieldMetadata_IntValue kIntValue{};
   void set_int_value(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -12745,14 +14758,7 @@ class DebugAnnotation : public ::protozero::Message {
       double,
       DebugAnnotation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DoubleValue kDoubleValue() { return {}; }
+  static constexpr FieldMetadata_DoubleValue kDoubleValue{};
   void set_double_value(double value) {
     static constexpr uint32_t field_id = FieldMetadata_DoubleValue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -12770,14 +14776,7 @@ class DebugAnnotation : public ::protozero::Message {
       uint64_t,
       DebugAnnotation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PointerValue kPointerValue() { return {}; }
+  static constexpr FieldMetadata_PointerValue kPointerValue{};
   void set_pointer_value(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_PointerValue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -12795,14 +14794,7 @@ class DebugAnnotation : public ::protozero::Message {
       DebugAnnotation_NestedValue,
       DebugAnnotation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NestedValue kNestedValue() { return {}; }
+  static constexpr FieldMetadata_NestedValue kNestedValue{};
   template <typename T = DebugAnnotation_NestedValue> T* set_nested_value() {
     return BeginNestedMessage<T>(8);
   }
@@ -12816,14 +14808,7 @@ class DebugAnnotation : public ::protozero::Message {
       std::string,
       DebugAnnotation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LegacyJsonValue kLegacyJsonValue() { return {}; }
+  static constexpr FieldMetadata_LegacyJsonValue kLegacyJsonValue{};
   void set_legacy_json_value(const char* data, size_t size) {
     AppendBytes(FieldMetadata_LegacyJsonValue::kFieldId, data, size);
   }
@@ -12847,14 +14832,7 @@ class DebugAnnotation : public ::protozero::Message {
       std::string,
       DebugAnnotation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StringValue kStringValue() { return {}; }
+  static constexpr FieldMetadata_StringValue kStringValue{};
   void set_string_value(const char* data, size_t size) {
     AppendBytes(FieldMetadata_StringValue::kFieldId, data, size);
   }
@@ -12878,14 +14856,7 @@ class DebugAnnotation : public ::protozero::Message {
       uint64_t,
       DebugAnnotation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StringValueIid kStringValueIid() { return {}; }
+  static constexpr FieldMetadata_StringValueIid kStringValueIid{};
   void set_string_value_iid(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_StringValueIid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -12903,14 +14874,7 @@ class DebugAnnotation : public ::protozero::Message {
       std::string,
       DebugAnnotation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProtoTypeName kProtoTypeName() { return {}; }
+  static constexpr FieldMetadata_ProtoTypeName kProtoTypeName{};
   void set_proto_type_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_ProtoTypeName::kFieldId, data, size);
   }
@@ -12934,14 +14898,7 @@ class DebugAnnotation : public ::protozero::Message {
       uint64_t,
       DebugAnnotation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProtoTypeNameIid kProtoTypeNameIid() { return {}; }
+  static constexpr FieldMetadata_ProtoTypeNameIid kProtoTypeNameIid{};
   void set_proto_type_name_iid(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ProtoTypeNameIid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -12959,14 +14916,7 @@ class DebugAnnotation : public ::protozero::Message {
       std::string,
       DebugAnnotation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProtoValue kProtoValue() { return {}; }
+  static constexpr FieldMetadata_ProtoValue kProtoValue{};
   void set_proto_value(const uint8_t* data, size_t size) {
     AppendBytes(FieldMetadata_ProtoValue::kFieldId, data, size);
   }
@@ -12990,14 +14940,7 @@ class DebugAnnotation : public ::protozero::Message {
       DebugAnnotation,
       DebugAnnotation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DictEntries kDictEntries() { return {}; }
+  static constexpr FieldMetadata_DictEntries kDictEntries{};
   template <typename T = DebugAnnotation> T* add_dict_entries() {
     return BeginNestedMessage<T>(11);
   }
@@ -13011,21 +14954,14 @@ class DebugAnnotation : public ::protozero::Message {
       DebugAnnotation,
       DebugAnnotation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ArrayValues kArrayValues() { return {}; }
+  static constexpr FieldMetadata_ArrayValues kArrayValues{};
   template <typename T = DebugAnnotation> T* add_array_values() {
     return BeginNestedMessage<T>(12);
   }
 
 };
 
-class DebugAnnotation_NestedValue_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class DebugAnnotation_NestedValue_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
  public:
   DebugAnnotation_NestedValue_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit DebugAnnotation_NestedValue_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -13068,27 +15004,20 @@ class DebugAnnotation_NestedValue : public ::protozero::Message {
   static inline const char* NestedType_Name(NestedType value) {
     return ::perfetto::protos::pbzero::DebugAnnotation_NestedValue_NestedType_Name(value);
   }
-  static const NestedType UNSPECIFIED = NestedType::UNSPECIFIED;
-  static const NestedType DICT = NestedType::DICT;
-  static const NestedType ARRAY = NestedType::ARRAY;
+  static inline const NestedType UNSPECIFIED = NestedType::UNSPECIFIED;
+  static inline const NestedType DICT = NestedType::DICT;
+  static inline const NestedType ARRAY = NestedType::ARRAY;
 
   using FieldMetadata_NestedType =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::DebugAnnotation_NestedValue_NestedType,
+      DebugAnnotation_NestedValue_NestedType,
       DebugAnnotation_NestedValue>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NestedType kNestedType() { return {}; }
-  void set_nested_type(::perfetto::protos::pbzero::DebugAnnotation_NestedValue_NestedType value) {
+  static constexpr FieldMetadata_NestedType kNestedType{};
+  void set_nested_type(DebugAnnotation_NestedValue_NestedType value) {
     static constexpr uint32_t field_id = FieldMetadata_NestedType::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
@@ -13105,14 +15034,7 @@ class DebugAnnotation_NestedValue : public ::protozero::Message {
       std::string,
       DebugAnnotation_NestedValue>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DictKeys kDictKeys() { return {}; }
+  static constexpr FieldMetadata_DictKeys kDictKeys{};
   void add_dict_keys(const char* data, size_t size) {
     AppendBytes(FieldMetadata_DictKeys::kFieldId, data, size);
   }
@@ -13136,14 +15058,7 @@ class DebugAnnotation_NestedValue : public ::protozero::Message {
       DebugAnnotation_NestedValue,
       DebugAnnotation_NestedValue>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DictValues kDictValues() { return {}; }
+  static constexpr FieldMetadata_DictValues kDictValues{};
   template <typename T = DebugAnnotation_NestedValue> T* add_dict_values() {
     return BeginNestedMessage<T>(3);
   }
@@ -13157,14 +15072,7 @@ class DebugAnnotation_NestedValue : public ::protozero::Message {
       DebugAnnotation_NestedValue,
       DebugAnnotation_NestedValue>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ArrayValues kArrayValues() { return {}; }
+  static constexpr FieldMetadata_ArrayValues kArrayValues{};
   template <typename T = DebugAnnotation_NestedValue> T* add_array_values() {
     return BeginNestedMessage<T>(4);
   }
@@ -13178,14 +15086,7 @@ class DebugAnnotation_NestedValue : public ::protozero::Message {
       int64_t,
       DebugAnnotation_NestedValue>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IntValue kIntValue() { return {}; }
+  static constexpr FieldMetadata_IntValue kIntValue{};
   void set_int_value(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -13203,14 +15104,7 @@ class DebugAnnotation_NestedValue : public ::protozero::Message {
       double,
       DebugAnnotation_NestedValue>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DoubleValue kDoubleValue() { return {}; }
+  static constexpr FieldMetadata_DoubleValue kDoubleValue{};
   void set_double_value(double value) {
     static constexpr uint32_t field_id = FieldMetadata_DoubleValue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -13228,14 +15122,7 @@ class DebugAnnotation_NestedValue : public ::protozero::Message {
       bool,
       DebugAnnotation_NestedValue>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BoolValue kBoolValue() { return {}; }
+  static constexpr FieldMetadata_BoolValue kBoolValue{};
   void set_bool_value(bool value) {
     static constexpr uint32_t field_id = FieldMetadata_BoolValue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -13253,14 +15140,7 @@ class DebugAnnotation_NestedValue : public ::protozero::Message {
       std::string,
       DebugAnnotation_NestedValue>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StringValue kStringValue() { return {}; }
+  static constexpr FieldMetadata_StringValue kStringValue{};
   void set_string_value(const char* data, size_t size) {
     AppendBytes(FieldMetadata_StringValue::kFieldId, data, size);
   }
@@ -13345,6 +15225,90 @@ class PERFETTO_EXPORT_COMPONENT DebugAnnotation {
 }  // namespace perfetto
 
 #endif  // INCLUDE_PERFETTO_TRACING_DEBUG_ANNOTATION_H_
+// gen_amalgamated begin header: include/perfetto/tracing/string_helpers.h
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_TRACING_STRING_HELPERS_H_
+#define INCLUDE_PERFETTO_TRACING_STRING_HELPERS_H_
+
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+
+#include <cstddef>
+#include <string>
+
+namespace perfetto {
+
+// A wrapper for marking strings that can't be determined to be static at build
+// time, but are in fact static.
+class PERFETTO_EXPORT_COMPONENT StaticString {
+ public:
+  // Implicit constructor for string literals.
+  template <size_t N>
+  constexpr StaticString(const char (&str)[N]) : value(str) {}
+
+  // Implicit constructor for null strings.
+  constexpr StaticString(std::nullptr_t) : value(nullptr) {}
+
+  constexpr explicit StaticString(const char* str) : value(str) {}
+
+  operator bool() const { return !!value; }
+
+  const char* value;
+};
+
+// A explicit wrapper for marking strings as dynamic to ensure that perfetto
+// doesn't try to cache the pointer value.
+class PERFETTO_EXPORT_COMPONENT DynamicString {
+ public:
+  explicit DynamicString(const std::string& str)
+      : value(str.data()), length(str.length()) {}
+  explicit DynamicString(const char* str) : value(str) {
+    PERFETTO_DCHECK(str);
+    length = strlen(str);
+  }
+  DynamicString(const char* str, size_t len) : value(str), length(len) {}
+  constexpr DynamicString() : value(nullptr), length(0) {}
+
+  operator bool() const { return !!value; }
+
+  const char* value;
+  size_t length;
+};
+
+namespace internal {
+
+template <size_t N>
+constexpr const char* GetStaticString(const char (&string)[N]) {
+  return string;
+}
+
+constexpr std::nullptr_t GetStaticString(std::nullptr_t) {
+  return nullptr;
+}
+
+constexpr const char* GetStaticString(perfetto::StaticString string) {
+  return string.value;
+}
+
+}  // namespace internal
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_TRACING_STRING_HELPERS_H_
 // gen_amalgamated begin header: include/perfetto/tracing/traced_value.h
 // gen_amalgamated begin header: include/perfetto/tracing/internal/checked_scope.h
 /*
@@ -13430,85 +15394,6 @@ class CheckedScope {
 }  // namespace perfetto
 
 #endif  // INCLUDE_PERFETTO_TRACING_INTERNAL_CHECKED_SCOPE_H_
-// gen_amalgamated begin header: include/perfetto/tracing/string_helpers.h
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef INCLUDE_PERFETTO_TRACING_STRING_HELPERS_H_
-#define INCLUDE_PERFETTO_TRACING_STRING_HELPERS_H_
-
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-
-#include <cstddef>
-#include <string>
-
-namespace perfetto {
-
-// A wrapper for marking strings that can't be determined to be static at build
-// time, but are in fact static.
-class PERFETTO_EXPORT_COMPONENT StaticString {
- public:
-  // Implicit constructor for string literals.
-  template <size_t N>
-  constexpr StaticString(const char (&str)[N]) : value(str) {}
-
-  // Implicit constructor for null strings.
-  constexpr StaticString(std::nullptr_t) : value(nullptr) {}
-
-  constexpr explicit StaticString(const char* str) : value(str) {}
-
-  const char* value;
-};
-
-// A explicit wrapper for marking strings as dynamic to ensure that perfetto
-// doesn't try to cache the pointer value.
-class PERFETTO_EXPORT_COMPONENT DynamicString {
- public:
-  explicit DynamicString(const std::string& str)
-      : value(str.data()), length(str.length()) {}
-  explicit DynamicString(const char* str) : value(str) {
-    PERFETTO_DCHECK(str);
-    length = strlen(str);
-  }
-  DynamicString(const char* str, size_t len) : value(str), length(len) {}
-
-  const char* value;
-  size_t length;
-};
-
-namespace internal {
-
-template <size_t N>
-constexpr const char* GetStaticString(const char (&string)[N]) {
-  return string;
-}
-
-constexpr std::nullptr_t GetStaticString(std::nullptr_t) {
-  return nullptr;
-}
-
-constexpr const char* GetStaticString(perfetto::StaticString string) {
-  return string.value;
-}
-
-}  // namespace internal
-}  // namespace perfetto
-
-#endif  // INCLUDE_PERFETTO_TRACING_STRING_HELPERS_H_
 /*
  * Copyright (C) 2021 The Android Open Source Project
  *
@@ -13538,6 +15423,8 @@ constexpr const char* GetStaticString(perfetto::StaticString string) {
 // gen_amalgamated expanded: #include "perfetto/tracing/traced_value_forward.h"
 
 #include <memory>
+#include <string>
+#include <string_view>
 #include <type_traits>
 #include <utility>
 
@@ -13634,7 +15521,7 @@ namespace internal {
 PERFETTO_EXPORT_COMPONENT TracedValue
 CreateTracedValueFromProto(protos::pbzero::DebugAnnotation*,
                            EventContext* = nullptr);
-}
+}  // namespace internal
 
 class PERFETTO_EXPORT_COMPONENT TracedValue {
  public:
@@ -13656,6 +15543,7 @@ class PERFETTO_EXPORT_COMPONENT TracedValue {
   void WriteString(const char*) &&;
   void WriteString(const char*, size_t len) &&;
   void WriteString(const std::string&) &&;
+  void WriteString(std::string_view) &&;
   void WritePointer(const void* value) &&;
   template <typename MessageType>
   TracedProto<MessageType> WriteProto() &&;
@@ -13665,7 +15553,7 @@ class PERFETTO_EXPORT_COMPONENT TracedValue {
   // active at the same time. It's only allowed to call methods on the active
   // scope.
   // - When a scope creates a nested scope, the new scope becomes active.
-  // - When a scope is destroyed, it's parent scope becomes active again.
+  // - When a scope is destroyed, its parent scope becomes active again.
   //
   // Typically users will have to create a scope only at the beginning of a
   // conversion function and this scope should be destroyed at the end of it.
@@ -13797,11 +15685,10 @@ class PERFETTO_EXPORT_COMPONENT TracedDictionary {
   // Create a |TracedDictionary| which will populate the given field of the
   // given |message|.
   template <typename MessageType, typename FieldMetadata>
-  inline TracedDictionary(
-      MessageType* message,
-      protozero::proto_utils::internal::FieldMetadataHelper<FieldMetadata>,
-      EventContext* event_context,
-      internal::CheckedScope* parent_scope)
+  inline TracedDictionary(MessageType* message,
+                          FieldMetadata,
+                          EventContext* event_context,
+                          internal::CheckedScope* parent_scope)
       : message_(message),
         field_id_(FieldMetadata::kFieldId),
         event_context_(event_context),
@@ -13932,12 +15819,13 @@ struct is_incomplete_type<const char[]> {
 // class does not have it support, so they are useful in SFINAE and in producing
 // helpful compiler results.
 template <typename T, class Result = void>
-using check_traced_value_support_t = decltype(
-    internal::WriteImpl(
-        std::declval<base::priority_tag<internal::kMaxWriteImplPriority>>(),
-        std::declval<TracedValue>(),
-        std::declval<T>()),
-    std::declval<Result>());
+using check_traced_value_support_t =
+    decltype(internal::WriteImpl(
+                 std::declval<
+                     base::priority_tag<internal::kMaxWriteImplPriority>>(),
+                 std::declval<TracedValue>(),
+                 std::declval<T>()),
+             std::declval<Result>());
 
 // check_traced_value_support<T, V>::type is defined (and equal to V) iff T
 // supports being passed to WriteIntoTracedValue. See the comment in
@@ -14139,6 +16027,15 @@ struct TraceFormatTraits<std::string> {
   }
 };
 
+// Specialisation for C++ string_views.
+template <>
+struct TraceFormatTraits<std::string_view> {
+  inline static void WriteIntoTrace(TracedValue context,
+                                    std::string_view value) {
+    std::move(context).WriteString(value);
+  }
+};
+
 // Specialisation for (const) void*, which writes the pointer value.
 template <>
 struct TraceFormatTraits<void*> {
@@ -14213,93 +16110,7 @@ struct TraceFormatTraits<std::nullptr_t> {
 
 #endif  // INCLUDE_PERFETTO_TRACING_TRACED_VALUE_H_
 // gen_amalgamated begin header: include/perfetto/tracing/track.h
-// gen_amalgamated begin header: include/perfetto/base/thread_utils.h
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef INCLUDE_PERFETTO_BASE_THREAD_UTILS_H_
-#define INCLUDE_PERFETTO_BASE_THREAD_UTILS_H_
-
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-extern "C" {
-// Prototype extracted from the Windows SDK to avoid including windows.h.
-__declspec(dllimport) unsigned long __stdcall GetCurrentThreadId();
-}
-#elif PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA)
-#include <zircon/types.h>
-#elif PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
-    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-#include <sys/syscall.h>
-#include <sys/types.h>
-#include <unistd.h>
-#else
-#include <pthread.h>
-#endif
-
-namespace perfetto {
-namespace base {
-
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-using PlatformThreadId = pid_t;
-inline PlatformThreadId GetThreadId() {
-  return gettid();
-}
-#elif PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX)
-using PlatformThreadId = pid_t;
-inline PlatformThreadId GetThreadId() {
-  return static_cast<pid_t>(syscall(__NR_gettid));
-}
-#elif PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA)
-using PlatformThreadId = zx_koid_t;
-// Not inlined because the result is cached internally.
-PERFETTO_EXPORT_COMPONENT PlatformThreadId GetThreadId();
-#elif PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
-using PlatformThreadId = uint64_t;
-inline PlatformThreadId GetThreadId() {
-  uint64_t tid;
-  pthread_threadid_np(nullptr, &tid);
-  return tid;
-}
-#elif PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-using PlatformThreadId = uint64_t;
-inline PlatformThreadId GetThreadId() {
-  return static_cast<uint64_t>(GetCurrentThreadId());
-}
-#elif PERFETTO_BUILDFLAG(PERFETTO_OS_NACL)
-using PlatformThreadId = pid_t;
-inline PlatformThreadId GetThreadId() {
-  return reinterpret_cast<int32_t>(pthread_self());
-}
-#else  // Default to pthreads in case no OS is set.
-using PlatformThreadId = pthread_t;
-inline PlatformThreadId GetThreadId() {
-  return pthread_self();
-}
-#endif
-
-}  // namespace base
-}  // namespace perfetto
-
-#endif  // INCLUDE_PERFETTO_BASE_THREAD_UTILS_H_
-// gen_amalgamated begin header: include/perfetto/tracing/internal/compile_time_hash.h
+// gen_amalgamated begin header: include/perfetto/tracing/internal/fnv1a.h
 /*
  * Copyright (C) 2021 The Android Open Source Project
  *
@@ -14316,53 +16127,47 @@ inline PlatformThreadId GetThreadId() {
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_TRACING_INTERNAL_COMPILE_TIME_HASH_H_
-#define INCLUDE_PERFETTO_TRACING_INTERNAL_COMPILE_TIME_HASH_H_
+#ifndef INCLUDE_PERFETTO_TRACING_INTERNAL_FNV1A_H_
+#define INCLUDE_PERFETTO_TRACING_INTERNAL_FNV1A_H_
 
-#include <stddef.h>
-#include <stdint.h>
+#include <cstddef>
+#include <cstdint>
 
 namespace perfetto {
 namespace internal {
 
-// A helper class which computes a 64-bit hash of the input data at compile
-// time. The algorithm used is FNV-1a as it is fast and easy to implement and
-// has relatively few collisions.
+// Constexpr functions to compute a 64-bit hash of the input data. The algorithm
+// used is FNV-1a as it is fast and easy to implement and has relatively few
+// collisions.
+//
 // WARNING: This hash function should not be used for any cryptographic purpose.
-class CompileTimeHash {
- public:
-  // Creates an empty hash object
-  constexpr inline CompileTimeHash() {}
 
-  // Hashes a byte array.
-  constexpr inline CompileTimeHash Update(const char* data, size_t size) const {
-    return CompileTimeHash(HashRecursively(kFnv1a64OffsetBasis, data, size));
-  }
+static constexpr uint64_t kFnv1a64OffsetBasis = 0xcbf29ce484222325;
+static constexpr uint64_t kFnv1a64Prime = 0x100000001b3;
 
-  constexpr inline uint64_t digest() const { return result_; }
-
- private:
-  constexpr inline CompileTimeHash(uint64_t result) : result_(result) {}
-
-  static constexpr inline uint64_t HashRecursively(uint64_t value,
-                                                   const char* data,
-                                                   size_t size) {
-    return !size ? value
-                 : HashRecursively(
-                       (value ^ static_cast<uint8_t>(*data)) * kFnv1a64Prime,
-                       data + 1, size - 1);
+static constexpr inline uint64_t Fnv1a(const char* s) {
+  uint64_t ret = kFnv1a64OffsetBasis;
+  for (; *s; s++) {
+    ret = ret ^ static_cast<uint8_t>(*s);
+    ret *= kFnv1a64Prime;
   }
+  return ret;
+}
 
-  static constexpr uint64_t kFnv1a64OffsetBasis = 0xcbf29ce484222325;
-  static constexpr uint64_t kFnv1a64Prime = 0x100000001b3;
-
-  uint64_t result_ = kFnv1a64OffsetBasis;
-};
+static constexpr inline uint64_t Fnv1a(const void* data, size_t size) {
+  uint64_t ret = kFnv1a64OffsetBasis;
+  const uint8_t* s = static_cast<const uint8_t*>(data);
+  for (size_t i = 0; i < size; i++) {
+    ret = ret ^ s[i];
+    ret *= kFnv1a64Prime;
+  }
+  return ret;
+}
 
 }  // namespace internal
 }  // namespace perfetto
 
-#endif  // INCLUDE_PERFETTO_TRACING_INTERNAL_COMPILE_TIME_HASH_H_
+#endif  // INCLUDE_PERFETTO_TRACING_INTERNAL_FNV1A_H_
 // gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/counter_descriptor.gen.h
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
 #ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_COUNTER_DESCRIPTOR_PROTO_CPP_H_
@@ -14429,6 +16234,7 @@ class PERFETTO_EXPORT_COMPONENT CounterDescriptor : public ::protozero::CppMessa
     kUnitNameFieldNumber = 6,
     kUnitMultiplierFieldNumber = 4,
     kIsIncrementalFieldNumber = 5,
+    kYAxisShareKeyFieldNumber = 7,
   };
 
   CounterDescriptor();
@@ -14472,6 +16278,10 @@ class PERFETTO_EXPORT_COMPONENT CounterDescriptor : public ::protozero::CppMessa
   bool is_incremental() const { return is_incremental_; }
   void set_is_incremental(bool value) { is_incremental_ = value; _has_field_.set(5); }
 
+  bool has_y_axis_share_key() const { return _has_field_[7]; }
+  const std::string& y_axis_share_key() const { return y_axis_share_key_; }
+  void set_y_axis_share_key(const std::string& value) { y_axis_share_key_ = value; _has_field_.set(7); }
+
  private:
   CounterDescriptor_BuiltinCounterType type_{};
   std::vector<std::string> categories_;
@@ -14479,12 +16289,13 @@ class PERFETTO_EXPORT_COMPONENT CounterDescriptor : public ::protozero::CppMessa
   std::string unit_name_{};
   int64_t unit_multiplier_{};
   bool is_incremental_{};
+  std::string y_axis_share_key_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<7> _has_field_{};
+  std::bitset<8> _has_field_{};
 };
 
 }  // namespace perfetto
@@ -14510,7 +16321,6 @@ class PERFETTO_EXPORT_COMPONENT CounterDescriptor : public ::protozero::CppMessa
 namespace perfetto {
 namespace protos {
 namespace pbzero {
-
 namespace perfetto_pbzero_enum_CounterDescriptor {
 enum BuiltinCounterType : int32_t;
 }  // namespace perfetto_pbzero_enum_CounterDescriptor
@@ -14519,6 +16329,13 @@ namespace perfetto_pbzero_enum_CounterDescriptor {
 enum Unit : int32_t;
 }  // namespace perfetto_pbzero_enum_CounterDescriptor
 using CounterDescriptor_Unit = perfetto_pbzero_enum_CounterDescriptor::Unit;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
 namespace perfetto_pbzero_enum_CounterDescriptor {
 enum BuiltinCounterType : int32_t {
@@ -14582,7 +16399,7 @@ const char* CounterDescriptor_Unit_Name(::perfetto::protos::pbzero::CounterDescr
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-class CounterDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class CounterDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
   CounterDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit CounterDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -14599,6 +16416,8 @@ class CounterDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FI
   int64_t unit_multiplier() const { return at<4>().as_int64(); }
   bool has_is_incremental() const { return at<5>().valid(); }
   bool is_incremental() const { return at<5>().as_bool(); }
+  bool has_y_axis_share_key() const { return at<7>().valid(); }
+  ::protozero::ConstChars y_axis_share_key() const { return at<7>().as_string(); }
 };
 
 class CounterDescriptor : public ::protozero::Message {
@@ -14611,6 +16430,7 @@ class CounterDescriptor : public ::protozero::Message {
     kUnitNameFieldNumber = 6,
     kUnitMultiplierFieldNumber = 4,
     kIsIncrementalFieldNumber = 5,
+    kYAxisShareKeyFieldNumber = 7,
   };
   static constexpr const char* GetName() { return ".perfetto.protos.CounterDescriptor"; }
 
@@ -14624,31 +16444,24 @@ class CounterDescriptor : public ::protozero::Message {
   static inline const char* Unit_Name(Unit value) {
     return ::perfetto::protos::pbzero::CounterDescriptor_Unit_Name(value);
   }
-  static const BuiltinCounterType COUNTER_UNSPECIFIED = BuiltinCounterType::COUNTER_UNSPECIFIED;
-  static const BuiltinCounterType COUNTER_THREAD_TIME_NS = BuiltinCounterType::COUNTER_THREAD_TIME_NS;
-  static const BuiltinCounterType COUNTER_THREAD_INSTRUCTION_COUNT = BuiltinCounterType::COUNTER_THREAD_INSTRUCTION_COUNT;
-  static const Unit UNIT_UNSPECIFIED = Unit::UNIT_UNSPECIFIED;
-  static const Unit UNIT_TIME_NS = Unit::UNIT_TIME_NS;
-  static const Unit UNIT_COUNT = Unit::UNIT_COUNT;
-  static const Unit UNIT_SIZE_BYTES = Unit::UNIT_SIZE_BYTES;
+  static inline const BuiltinCounterType COUNTER_UNSPECIFIED = BuiltinCounterType::COUNTER_UNSPECIFIED;
+  static inline const BuiltinCounterType COUNTER_THREAD_TIME_NS = BuiltinCounterType::COUNTER_THREAD_TIME_NS;
+  static inline const BuiltinCounterType COUNTER_THREAD_INSTRUCTION_COUNT = BuiltinCounterType::COUNTER_THREAD_INSTRUCTION_COUNT;
+  static inline const Unit UNIT_UNSPECIFIED = Unit::UNIT_UNSPECIFIED;
+  static inline const Unit UNIT_TIME_NS = Unit::UNIT_TIME_NS;
+  static inline const Unit UNIT_COUNT = Unit::UNIT_COUNT;
+  static inline const Unit UNIT_SIZE_BYTES = Unit::UNIT_SIZE_BYTES;
 
   using FieldMetadata_Type =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::CounterDescriptor_BuiltinCounterType,
+      CounterDescriptor_BuiltinCounterType,
       CounterDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(::perfetto::protos::pbzero::CounterDescriptor_BuiltinCounterType value) {
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(CounterDescriptor_BuiltinCounterType value) {
     static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
@@ -14665,14 +16478,7 @@ class CounterDescriptor : public ::protozero::Message {
       std::string,
       CounterDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Categories kCategories() { return {}; }
+  static constexpr FieldMetadata_Categories kCategories{};
   void add_categories(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Categories::kFieldId, data, size);
   }
@@ -14693,18 +16499,11 @@ class CounterDescriptor : public ::protozero::Message {
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::CounterDescriptor_Unit,
+      CounterDescriptor_Unit,
       CounterDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Unit kUnit() { return {}; }
-  void set_unit(::perfetto::protos::pbzero::CounterDescriptor_Unit value) {
+  static constexpr FieldMetadata_Unit kUnit{};
+  void set_unit(CounterDescriptor_Unit value) {
     static constexpr uint32_t field_id = FieldMetadata_Unit::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
@@ -14721,14 +16520,7 @@ class CounterDescriptor : public ::protozero::Message {
       std::string,
       CounterDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UnitName kUnitName() { return {}; }
+  static constexpr FieldMetadata_UnitName kUnitName{};
   void set_unit_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_UnitName::kFieldId, data, size);
   }
@@ -14752,14 +16544,7 @@ class CounterDescriptor : public ::protozero::Message {
       int64_t,
       CounterDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UnitMultiplier kUnitMultiplier() { return {}; }
+  static constexpr FieldMetadata_UnitMultiplier kUnitMultiplier{};
   void set_unit_multiplier(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_UnitMultiplier::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -14777,14 +16562,7 @@ class CounterDescriptor : public ::protozero::Message {
       bool,
       CounterDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IsIncremental kIsIncremental() { return {}; }
+  static constexpr FieldMetadata_IsIncremental kIsIncremental{};
   void set_is_incremental(bool value) {
     static constexpr uint32_t field_id = FieldMetadata_IsIncremental::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -14793,6 +16571,937 @@ class CounterDescriptor : public ::protozero::Message {
       ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_YAxisShareKey =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      CounterDescriptor>;
+
+  static constexpr FieldMetadata_YAxisShareKey kYAxisShareKey{};
+  void set_y_axis_share_key(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_YAxisShareKey::kFieldId, data, size);
+  }
+  void set_y_axis_share_key(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_YAxisShareKey::kFieldId, chars.data, chars.size);
+  }
+  void set_y_axis_share_key(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_YAxisShareKey::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/process_descriptor.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_PROCESS_DESCRIPTOR_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_PROCESS_DESCRIPTOR_PROTO_CPP_H_
+
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+class ProcessDescriptor;
+enum ProcessDescriptor_ChromeProcessType : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+namespace protozero {
+class Message;
+}  // namespace protozero
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum ProcessDescriptor_ChromeProcessType : int {
+  ProcessDescriptor_ChromeProcessType_PROCESS_UNSPECIFIED = 0,
+  ProcessDescriptor_ChromeProcessType_PROCESS_BROWSER = 1,
+  ProcessDescriptor_ChromeProcessType_PROCESS_RENDERER = 2,
+  ProcessDescriptor_ChromeProcessType_PROCESS_UTILITY = 3,
+  ProcessDescriptor_ChromeProcessType_PROCESS_ZYGOTE = 4,
+  ProcessDescriptor_ChromeProcessType_PROCESS_SANDBOX_HELPER = 5,
+  ProcessDescriptor_ChromeProcessType_PROCESS_GPU = 6,
+  ProcessDescriptor_ChromeProcessType_PROCESS_PPAPI_PLUGIN = 7,
+  ProcessDescriptor_ChromeProcessType_PROCESS_PPAPI_BROKER = 8,
+};
+
+class PERFETTO_EXPORT_COMPONENT ProcessDescriptor : public ::protozero::CppMessageObj {
+ public:
+  using ChromeProcessType = ProcessDescriptor_ChromeProcessType;
+  static constexpr auto PROCESS_UNSPECIFIED = ProcessDescriptor_ChromeProcessType_PROCESS_UNSPECIFIED;
+  static constexpr auto PROCESS_BROWSER = ProcessDescriptor_ChromeProcessType_PROCESS_BROWSER;
+  static constexpr auto PROCESS_RENDERER = ProcessDescriptor_ChromeProcessType_PROCESS_RENDERER;
+  static constexpr auto PROCESS_UTILITY = ProcessDescriptor_ChromeProcessType_PROCESS_UTILITY;
+  static constexpr auto PROCESS_ZYGOTE = ProcessDescriptor_ChromeProcessType_PROCESS_ZYGOTE;
+  static constexpr auto PROCESS_SANDBOX_HELPER = ProcessDescriptor_ChromeProcessType_PROCESS_SANDBOX_HELPER;
+  static constexpr auto PROCESS_GPU = ProcessDescriptor_ChromeProcessType_PROCESS_GPU;
+  static constexpr auto PROCESS_PPAPI_PLUGIN = ProcessDescriptor_ChromeProcessType_PROCESS_PPAPI_PLUGIN;
+  static constexpr auto PROCESS_PPAPI_BROKER = ProcessDescriptor_ChromeProcessType_PROCESS_PPAPI_BROKER;
+  static constexpr auto ChromeProcessType_MIN = ProcessDescriptor_ChromeProcessType_PROCESS_UNSPECIFIED;
+  static constexpr auto ChromeProcessType_MAX = ProcessDescriptor_ChromeProcessType_PROCESS_PPAPI_BROKER;
+  enum FieldNumbers {
+    kPidFieldNumber = 1,
+    kCmdlineFieldNumber = 2,
+    kProcessNameFieldNumber = 6,
+    kProcessPriorityFieldNumber = 5,
+    kStartTimestampNsFieldNumber = 7,
+    kChromeProcessTypeFieldNumber = 4,
+    kLegacySortIndexFieldNumber = 3,
+    kProcessLabelsFieldNumber = 8,
+  };
+
+  ProcessDescriptor();
+  ~ProcessDescriptor() override;
+  ProcessDescriptor(ProcessDescriptor&&) noexcept;
+  ProcessDescriptor& operator=(ProcessDescriptor&&);
+  ProcessDescriptor(const ProcessDescriptor&);
+  ProcessDescriptor& operator=(const ProcessDescriptor&);
+  bool operator==(const ProcessDescriptor&) const;
+  bool operator!=(const ProcessDescriptor& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_pid() const { return _has_field_[1]; }
+  int32_t pid() const { return pid_; }
+  void set_pid(int32_t value) { pid_ = value; _has_field_.set(1); }
+
+  const std::vector<std::string>& cmdline() const { return cmdline_; }
+  std::vector<std::string>* mutable_cmdline() { return &cmdline_; }
+  int cmdline_size() const { return static_cast<int>(cmdline_.size()); }
+  void clear_cmdline() { cmdline_.clear(); }
+  void add_cmdline(std::string value) { cmdline_.emplace_back(value); }
+  std::string* add_cmdline() { cmdline_.emplace_back(); return &cmdline_.back(); }
+
+  bool has_process_name() const { return _has_field_[6]; }
+  const std::string& process_name() const { return process_name_; }
+  void set_process_name(const std::string& value) { process_name_ = value; _has_field_.set(6); }
+
+  bool has_process_priority() const { return _has_field_[5]; }
+  int32_t process_priority() const { return process_priority_; }
+  void set_process_priority(int32_t value) { process_priority_ = value; _has_field_.set(5); }
+
+  bool has_start_timestamp_ns() const { return _has_field_[7]; }
+  int64_t start_timestamp_ns() const { return start_timestamp_ns_; }
+  void set_start_timestamp_ns(int64_t value) { start_timestamp_ns_ = value; _has_field_.set(7); }
+
+  bool has_chrome_process_type() const { return _has_field_[4]; }
+  ProcessDescriptor_ChromeProcessType chrome_process_type() const { return chrome_process_type_; }
+  void set_chrome_process_type(ProcessDescriptor_ChromeProcessType value) { chrome_process_type_ = value; _has_field_.set(4); }
+
+  bool has_legacy_sort_index() const { return _has_field_[3]; }
+  int32_t legacy_sort_index() const { return legacy_sort_index_; }
+  void set_legacy_sort_index(int32_t value) { legacy_sort_index_ = value; _has_field_.set(3); }
+
+  const std::vector<std::string>& process_labels() const { return process_labels_; }
+  std::vector<std::string>* mutable_process_labels() { return &process_labels_; }
+  int process_labels_size() const { return static_cast<int>(process_labels_.size()); }
+  void clear_process_labels() { process_labels_.clear(); }
+  void add_process_labels(std::string value) { process_labels_.emplace_back(value); }
+  std::string* add_process_labels() { process_labels_.emplace_back(); return &process_labels_.back(); }
+
+ private:
+  int32_t pid_{};
+  std::vector<std::string> cmdline_;
+  std::string process_name_{};
+  int32_t process_priority_{};
+  int64_t start_timestamp_ns_{};
+  ProcessDescriptor_ChromeProcessType chrome_process_type_{};
+  int32_t legacy_sort_index_{};
+  std::vector<std::string> process_labels_;
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<9> _has_field_{};
+};
+
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_PROCESS_DESCRIPTOR_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/process_descriptor.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_PROCESS_DESCRIPTOR_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_PROCESS_DESCRIPTOR_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+namespace perfetto_pbzero_enum_ProcessDescriptor {
+enum ChromeProcessType : int32_t;
+}  // namespace perfetto_pbzero_enum_ProcessDescriptor
+using ProcessDescriptor_ChromeProcessType = perfetto_pbzero_enum_ProcessDescriptor::ChromeProcessType;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_ProcessDescriptor {
+enum ChromeProcessType : int32_t {
+  PROCESS_UNSPECIFIED = 0,
+  PROCESS_BROWSER = 1,
+  PROCESS_RENDERER = 2,
+  PROCESS_UTILITY = 3,
+  PROCESS_ZYGOTE = 4,
+  PROCESS_SANDBOX_HELPER = 5,
+  PROCESS_GPU = 6,
+  PROCESS_PPAPI_PLUGIN = 7,
+  PROCESS_PPAPI_BROKER = 8,
+};
+} // namespace perfetto_pbzero_enum_ProcessDescriptor
+using ProcessDescriptor_ChromeProcessType = perfetto_pbzero_enum_ProcessDescriptor::ChromeProcessType;
+
+
+constexpr ProcessDescriptor_ChromeProcessType ProcessDescriptor_ChromeProcessType_MIN = ProcessDescriptor_ChromeProcessType::PROCESS_UNSPECIFIED;
+constexpr ProcessDescriptor_ChromeProcessType ProcessDescriptor_ChromeProcessType_MAX = ProcessDescriptor_ChromeProcessType::PROCESS_PPAPI_BROKER;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ProcessDescriptor_ChromeProcessType_Name(::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_UNSPECIFIED:
+    return "PROCESS_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_BROWSER:
+    return "PROCESS_BROWSER";
+
+  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_RENDERER:
+    return "PROCESS_RENDERER";
+
+  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_UTILITY:
+    return "PROCESS_UTILITY";
+
+  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_ZYGOTE:
+    return "PROCESS_ZYGOTE";
+
+  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_SANDBOX_HELPER:
+    return "PROCESS_SANDBOX_HELPER";
+
+  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_GPU:
+    return "PROCESS_GPU";
+
+  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_PPAPI_PLUGIN:
+    return "PROCESS_PPAPI_PLUGIN";
+
+  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_PPAPI_BROKER:
+    return "PROCESS_PPAPI_BROKER";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class ProcessDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
+ public:
+  ProcessDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProcessDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProcessDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  int32_t pid() const { return at<1>().as_int32(); }
+  bool has_cmdline() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> cmdline() const { return GetRepeated<::protozero::ConstChars>(2); }
+  bool has_process_name() const { return at<6>().valid(); }
+  ::protozero::ConstChars process_name() const { return at<6>().as_string(); }
+  bool has_process_priority() const { return at<5>().valid(); }
+  int32_t process_priority() const { return at<5>().as_int32(); }
+  bool has_start_timestamp_ns() const { return at<7>().valid(); }
+  int64_t start_timestamp_ns() const { return at<7>().as_int64(); }
+  bool has_chrome_process_type() const { return at<4>().valid(); }
+  int32_t chrome_process_type() const { return at<4>().as_int32(); }
+  bool has_legacy_sort_index() const { return at<3>().valid(); }
+  int32_t legacy_sort_index() const { return at<3>().as_int32(); }
+  bool has_process_labels() const { return at<8>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> process_labels() const { return GetRepeated<::protozero::ConstChars>(8); }
+};
+
+class ProcessDescriptor : public ::protozero::Message {
+ public:
+  using Decoder = ProcessDescriptor_Decoder;
+  enum : int32_t {
+    kPidFieldNumber = 1,
+    kCmdlineFieldNumber = 2,
+    kProcessNameFieldNumber = 6,
+    kProcessPriorityFieldNumber = 5,
+    kStartTimestampNsFieldNumber = 7,
+    kChromeProcessTypeFieldNumber = 4,
+    kLegacySortIndexFieldNumber = 3,
+    kProcessLabelsFieldNumber = 8,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ProcessDescriptor"; }
+
+
+  using ChromeProcessType = ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType;
+  static inline const char* ChromeProcessType_Name(ChromeProcessType value) {
+    return ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType_Name(value);
+  }
+  static inline const ChromeProcessType PROCESS_UNSPECIFIED = ChromeProcessType::PROCESS_UNSPECIFIED;
+  static inline const ChromeProcessType PROCESS_BROWSER = ChromeProcessType::PROCESS_BROWSER;
+  static inline const ChromeProcessType PROCESS_RENDERER = ChromeProcessType::PROCESS_RENDERER;
+  static inline const ChromeProcessType PROCESS_UTILITY = ChromeProcessType::PROCESS_UTILITY;
+  static inline const ChromeProcessType PROCESS_ZYGOTE = ChromeProcessType::PROCESS_ZYGOTE;
+  static inline const ChromeProcessType PROCESS_SANDBOX_HELPER = ChromeProcessType::PROCESS_SANDBOX_HELPER;
+  static inline const ChromeProcessType PROCESS_GPU = ChromeProcessType::PROCESS_GPU;
+  static inline const ChromeProcessType PROCESS_PPAPI_PLUGIN = ChromeProcessType::PROCESS_PPAPI_PLUGIN;
+  static inline const ChromeProcessType PROCESS_PPAPI_BROKER = ChromeProcessType::PROCESS_PPAPI_BROKER;
+
+  using FieldMetadata_Pid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ProcessDescriptor>;
+
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Cmdline =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ProcessDescriptor>;
+
+  static constexpr FieldMetadata_Cmdline kCmdline{};
+  void add_cmdline(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Cmdline::kFieldId, data, size);
+  }
+  void add_cmdline(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Cmdline::kFieldId, chars.data, chars.size);
+  }
+  void add_cmdline(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cmdline::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ProcessName =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ProcessDescriptor>;
+
+  static constexpr FieldMetadata_ProcessName kProcessName{};
+  void set_process_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ProcessName::kFieldId, data, size);
+  }
+  void set_process_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ProcessName::kFieldId, chars.data, chars.size);
+  }
+  void set_process_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProcessName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ProcessPriority =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ProcessDescriptor>;
+
+  static constexpr FieldMetadata_ProcessPriority kProcessPriority{};
+  void set_process_priority(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProcessPriority::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StartTimestampNs =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ProcessDescriptor>;
+
+  static constexpr FieldMetadata_StartTimestampNs kStartTimestampNs{};
+  void set_start_timestamp_ns(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StartTimestampNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ChromeProcessType =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ProcessDescriptor_ChromeProcessType,
+      ProcessDescriptor>;
+
+  static constexpr FieldMetadata_ChromeProcessType kChromeProcessType{};
+  void set_chrome_process_type(ProcessDescriptor_ChromeProcessType value) {
+    static constexpr uint32_t field_id = FieldMetadata_ChromeProcessType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_LegacySortIndex =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ProcessDescriptor>;
+
+  static constexpr FieldMetadata_LegacySortIndex kLegacySortIndex{};
+  void set_legacy_sort_index(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LegacySortIndex::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ProcessLabels =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ProcessDescriptor>;
+
+  static constexpr FieldMetadata_ProcessLabels kProcessLabels{};
+  void add_process_labels(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ProcessLabels::kFieldId, data, size);
+  }
+  void add_process_labels(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ProcessLabels::kFieldId, chars.data, chars.size);
+  }
+  void add_process_labels(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProcessLabels::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/thread_descriptor.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_THREAD_DESCRIPTOR_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_THREAD_DESCRIPTOR_PROTO_CPP_H_
+
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+class ThreadDescriptor;
+enum ThreadDescriptor_ChromeThreadType : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+namespace protozero {
+class Message;
+}  // namespace protozero
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum ThreadDescriptor_ChromeThreadType : int {
+  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_UNSPECIFIED = 0,
+  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_MAIN = 1,
+  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_IO = 2,
+  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_BG_WORKER = 3,
+  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_FG_WORKER = 4,
+  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_FB_BLOCKING = 5,
+  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_BG_BLOCKING = 6,
+  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_SERVICE = 7,
+  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_COMPOSITOR = 8,
+  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_VIZ_COMPOSITOR = 9,
+  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_COMPOSITOR_WORKER = 10,
+  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_SERVICE_WORKER = 11,
+  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_MEMORY_INFRA = 50,
+  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_SAMPLING_PROFILER = 51,
+};
+
+class PERFETTO_EXPORT_COMPONENT ThreadDescriptor : public ::protozero::CppMessageObj {
+ public:
+  using ChromeThreadType = ThreadDescriptor_ChromeThreadType;
+  static constexpr auto CHROME_THREAD_UNSPECIFIED = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_UNSPECIFIED;
+  static constexpr auto CHROME_THREAD_MAIN = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_MAIN;
+  static constexpr auto CHROME_THREAD_IO = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_IO;
+  static constexpr auto CHROME_THREAD_POOL_BG_WORKER = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_BG_WORKER;
+  static constexpr auto CHROME_THREAD_POOL_FG_WORKER = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_FG_WORKER;
+  static constexpr auto CHROME_THREAD_POOL_FB_BLOCKING = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_FB_BLOCKING;
+  static constexpr auto CHROME_THREAD_POOL_BG_BLOCKING = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_BG_BLOCKING;
+  static constexpr auto CHROME_THREAD_POOL_SERVICE = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_SERVICE;
+  static constexpr auto CHROME_THREAD_COMPOSITOR = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_COMPOSITOR;
+  static constexpr auto CHROME_THREAD_VIZ_COMPOSITOR = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_VIZ_COMPOSITOR;
+  static constexpr auto CHROME_THREAD_COMPOSITOR_WORKER = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_COMPOSITOR_WORKER;
+  static constexpr auto CHROME_THREAD_SERVICE_WORKER = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_SERVICE_WORKER;
+  static constexpr auto CHROME_THREAD_MEMORY_INFRA = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_MEMORY_INFRA;
+  static constexpr auto CHROME_THREAD_SAMPLING_PROFILER = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_SAMPLING_PROFILER;
+  static constexpr auto ChromeThreadType_MIN = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_UNSPECIFIED;
+  static constexpr auto ChromeThreadType_MAX = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_SAMPLING_PROFILER;
+  enum FieldNumbers {
+    kPidFieldNumber = 1,
+    kTidFieldNumber = 2,
+    kThreadNameFieldNumber = 5,
+    kChromeThreadTypeFieldNumber = 4,
+    kReferenceTimestampUsFieldNumber = 6,
+    kReferenceThreadTimeUsFieldNumber = 7,
+    kReferenceThreadInstructionCountFieldNumber = 8,
+    kLegacySortIndexFieldNumber = 3,
+  };
+
+  ThreadDescriptor();
+  ~ThreadDescriptor() override;
+  ThreadDescriptor(ThreadDescriptor&&) noexcept;
+  ThreadDescriptor& operator=(ThreadDescriptor&&);
+  ThreadDescriptor(const ThreadDescriptor&);
+  ThreadDescriptor& operator=(const ThreadDescriptor&);
+  bool operator==(const ThreadDescriptor&) const;
+  bool operator!=(const ThreadDescriptor& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_pid() const { return _has_field_[1]; }
+  int32_t pid() const { return pid_; }
+  void set_pid(int32_t value) { pid_ = value; _has_field_.set(1); }
+
+  bool has_tid() const { return _has_field_[2]; }
+  int32_t tid() const { return tid_; }
+  void set_tid(int32_t value) { tid_ = value; _has_field_.set(2); }
+
+  bool has_thread_name() const { return _has_field_[5]; }
+  const std::string& thread_name() const { return thread_name_; }
+  void set_thread_name(const std::string& value) { thread_name_ = value; _has_field_.set(5); }
+
+  bool has_chrome_thread_type() const { return _has_field_[4]; }
+  ThreadDescriptor_ChromeThreadType chrome_thread_type() const { return chrome_thread_type_; }
+  void set_chrome_thread_type(ThreadDescriptor_ChromeThreadType value) { chrome_thread_type_ = value; _has_field_.set(4); }
+
+  bool has_reference_timestamp_us() const { return _has_field_[6]; }
+  int64_t reference_timestamp_us() const { return reference_timestamp_us_; }
+  void set_reference_timestamp_us(int64_t value) { reference_timestamp_us_ = value; _has_field_.set(6); }
+
+  bool has_reference_thread_time_us() const { return _has_field_[7]; }
+  int64_t reference_thread_time_us() const { return reference_thread_time_us_; }
+  void set_reference_thread_time_us(int64_t value) { reference_thread_time_us_ = value; _has_field_.set(7); }
+
+  bool has_reference_thread_instruction_count() const { return _has_field_[8]; }
+  int64_t reference_thread_instruction_count() const { return reference_thread_instruction_count_; }
+  void set_reference_thread_instruction_count(int64_t value) { reference_thread_instruction_count_ = value; _has_field_.set(8); }
+
+  bool has_legacy_sort_index() const { return _has_field_[3]; }
+  int32_t legacy_sort_index() const { return legacy_sort_index_; }
+  void set_legacy_sort_index(int32_t value) { legacy_sort_index_ = value; _has_field_.set(3); }
+
+ private:
+  int32_t pid_{};
+  int32_t tid_{};
+  std::string thread_name_{};
+  ThreadDescriptor_ChromeThreadType chrome_thread_type_{};
+  int64_t reference_timestamp_us_{};
+  int64_t reference_thread_time_us_{};
+  int64_t reference_thread_instruction_count_{};
+  int32_t legacy_sort_index_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<9> _has_field_{};
+};
+
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_THREAD_DESCRIPTOR_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/thread_descriptor.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_THREAD_DESCRIPTOR_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_THREAD_DESCRIPTOR_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+namespace perfetto_pbzero_enum_ThreadDescriptor {
+enum ChromeThreadType : int32_t;
+}  // namespace perfetto_pbzero_enum_ThreadDescriptor
+using ThreadDescriptor_ChromeThreadType = perfetto_pbzero_enum_ThreadDescriptor::ChromeThreadType;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_ThreadDescriptor {
+enum ChromeThreadType : int32_t {
+  CHROME_THREAD_UNSPECIFIED = 0,
+  CHROME_THREAD_MAIN = 1,
+  CHROME_THREAD_IO = 2,
+  CHROME_THREAD_POOL_BG_WORKER = 3,
+  CHROME_THREAD_POOL_FG_WORKER = 4,
+  CHROME_THREAD_POOL_FB_BLOCKING = 5,
+  CHROME_THREAD_POOL_BG_BLOCKING = 6,
+  CHROME_THREAD_POOL_SERVICE = 7,
+  CHROME_THREAD_COMPOSITOR = 8,
+  CHROME_THREAD_VIZ_COMPOSITOR = 9,
+  CHROME_THREAD_COMPOSITOR_WORKER = 10,
+  CHROME_THREAD_SERVICE_WORKER = 11,
+  CHROME_THREAD_MEMORY_INFRA = 50,
+  CHROME_THREAD_SAMPLING_PROFILER = 51,
+};
+} // namespace perfetto_pbzero_enum_ThreadDescriptor
+using ThreadDescriptor_ChromeThreadType = perfetto_pbzero_enum_ThreadDescriptor::ChromeThreadType;
+
+
+constexpr ThreadDescriptor_ChromeThreadType ThreadDescriptor_ChromeThreadType_MIN = ThreadDescriptor_ChromeThreadType::CHROME_THREAD_UNSPECIFIED;
+constexpr ThreadDescriptor_ChromeThreadType ThreadDescriptor_ChromeThreadType_MAX = ThreadDescriptor_ChromeThreadType::CHROME_THREAD_SAMPLING_PROFILER;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ThreadDescriptor_ChromeThreadType_Name(::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_UNSPECIFIED:
+    return "CHROME_THREAD_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_MAIN:
+    return "CHROME_THREAD_MAIN";
+
+  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_IO:
+    return "CHROME_THREAD_IO";
+
+  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_POOL_BG_WORKER:
+    return "CHROME_THREAD_POOL_BG_WORKER";
+
+  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_POOL_FG_WORKER:
+    return "CHROME_THREAD_POOL_FG_WORKER";
+
+  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_POOL_FB_BLOCKING:
+    return "CHROME_THREAD_POOL_FB_BLOCKING";
+
+  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_POOL_BG_BLOCKING:
+    return "CHROME_THREAD_POOL_BG_BLOCKING";
+
+  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_POOL_SERVICE:
+    return "CHROME_THREAD_POOL_SERVICE";
+
+  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_COMPOSITOR:
+    return "CHROME_THREAD_COMPOSITOR";
+
+  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_VIZ_COMPOSITOR:
+    return "CHROME_THREAD_VIZ_COMPOSITOR";
+
+  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_COMPOSITOR_WORKER:
+    return "CHROME_THREAD_COMPOSITOR_WORKER";
+
+  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_SERVICE_WORKER:
+    return "CHROME_THREAD_SERVICE_WORKER";
+
+  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_MEMORY_INFRA:
+    return "CHROME_THREAD_MEMORY_INFRA";
+
+  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_SAMPLING_PROFILER:
+    return "CHROME_THREAD_SAMPLING_PROFILER";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class ThreadDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
+ public:
+  ThreadDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ThreadDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ThreadDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  int32_t pid() const { return at<1>().as_int32(); }
+  bool has_tid() const { return at<2>().valid(); }
+  int32_t tid() const { return at<2>().as_int32(); }
+  bool has_thread_name() const { return at<5>().valid(); }
+  ::protozero::ConstChars thread_name() const { return at<5>().as_string(); }
+  bool has_chrome_thread_type() const { return at<4>().valid(); }
+  int32_t chrome_thread_type() const { return at<4>().as_int32(); }
+  bool has_reference_timestamp_us() const { return at<6>().valid(); }
+  int64_t reference_timestamp_us() const { return at<6>().as_int64(); }
+  bool has_reference_thread_time_us() const { return at<7>().valid(); }
+  int64_t reference_thread_time_us() const { return at<7>().as_int64(); }
+  bool has_reference_thread_instruction_count() const { return at<8>().valid(); }
+  int64_t reference_thread_instruction_count() const { return at<8>().as_int64(); }
+  bool has_legacy_sort_index() const { return at<3>().valid(); }
+  int32_t legacy_sort_index() const { return at<3>().as_int32(); }
+};
+
+class ThreadDescriptor : public ::protozero::Message {
+ public:
+  using Decoder = ThreadDescriptor_Decoder;
+  enum : int32_t {
+    kPidFieldNumber = 1,
+    kTidFieldNumber = 2,
+    kThreadNameFieldNumber = 5,
+    kChromeThreadTypeFieldNumber = 4,
+    kReferenceTimestampUsFieldNumber = 6,
+    kReferenceThreadTimeUsFieldNumber = 7,
+    kReferenceThreadInstructionCountFieldNumber = 8,
+    kLegacySortIndexFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ThreadDescriptor"; }
+
+
+  using ChromeThreadType = ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType;
+  static inline const char* ChromeThreadType_Name(ChromeThreadType value) {
+    return ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType_Name(value);
+  }
+  static inline const ChromeThreadType CHROME_THREAD_UNSPECIFIED = ChromeThreadType::CHROME_THREAD_UNSPECIFIED;
+  static inline const ChromeThreadType CHROME_THREAD_MAIN = ChromeThreadType::CHROME_THREAD_MAIN;
+  static inline const ChromeThreadType CHROME_THREAD_IO = ChromeThreadType::CHROME_THREAD_IO;
+  static inline const ChromeThreadType CHROME_THREAD_POOL_BG_WORKER = ChromeThreadType::CHROME_THREAD_POOL_BG_WORKER;
+  static inline const ChromeThreadType CHROME_THREAD_POOL_FG_WORKER = ChromeThreadType::CHROME_THREAD_POOL_FG_WORKER;
+  static inline const ChromeThreadType CHROME_THREAD_POOL_FB_BLOCKING = ChromeThreadType::CHROME_THREAD_POOL_FB_BLOCKING;
+  static inline const ChromeThreadType CHROME_THREAD_POOL_BG_BLOCKING = ChromeThreadType::CHROME_THREAD_POOL_BG_BLOCKING;
+  static inline const ChromeThreadType CHROME_THREAD_POOL_SERVICE = ChromeThreadType::CHROME_THREAD_POOL_SERVICE;
+  static inline const ChromeThreadType CHROME_THREAD_COMPOSITOR = ChromeThreadType::CHROME_THREAD_COMPOSITOR;
+  static inline const ChromeThreadType CHROME_THREAD_VIZ_COMPOSITOR = ChromeThreadType::CHROME_THREAD_VIZ_COMPOSITOR;
+  static inline const ChromeThreadType CHROME_THREAD_COMPOSITOR_WORKER = ChromeThreadType::CHROME_THREAD_COMPOSITOR_WORKER;
+  static inline const ChromeThreadType CHROME_THREAD_SERVICE_WORKER = ChromeThreadType::CHROME_THREAD_SERVICE_WORKER;
+  static inline const ChromeThreadType CHROME_THREAD_MEMORY_INFRA = ChromeThreadType::CHROME_THREAD_MEMORY_INFRA;
+  static inline const ChromeThreadType CHROME_THREAD_SAMPLING_PROFILER = ChromeThreadType::CHROME_THREAD_SAMPLING_PROFILER;
+
+  using FieldMetadata_Pid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ThreadDescriptor>;
+
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Tid =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ThreadDescriptor>;
+
+  static constexpr FieldMetadata_Tid kTid{};
+  void set_tid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ThreadName =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ThreadDescriptor>;
+
+  static constexpr FieldMetadata_ThreadName kThreadName{};
+  void set_thread_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ThreadName::kFieldId, data, size);
+  }
+  void set_thread_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ThreadName::kFieldId, chars.data, chars.size);
+  }
+  void set_thread_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ThreadName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ChromeThreadType =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ThreadDescriptor_ChromeThreadType,
+      ThreadDescriptor>;
+
+  static constexpr FieldMetadata_ChromeThreadType kChromeThreadType{};
+  void set_chrome_thread_type(ThreadDescriptor_ChromeThreadType value) {
+    static constexpr uint32_t field_id = FieldMetadata_ChromeThreadType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ReferenceTimestampUs =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ThreadDescriptor>;
+
+  static constexpr FieldMetadata_ReferenceTimestampUs kReferenceTimestampUs{};
+  void set_reference_timestamp_us(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReferenceTimestampUs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ReferenceThreadTimeUs =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ThreadDescriptor>;
+
+  static constexpr FieldMetadata_ReferenceThreadTimeUs kReferenceThreadTimeUs{};
+  void set_reference_thread_time_us(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReferenceThreadTimeUs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ReferenceThreadInstructionCount =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ThreadDescriptor>;
+
+  static constexpr FieldMetadata_ReferenceThreadInstructionCount kReferenceThreadInstructionCount{};
+  void set_reference_thread_instruction_count(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReferenceThreadInstructionCount::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_LegacySortIndex =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ThreadDescriptor>;
+
+  static constexpr FieldMetadata_LegacySortIndex kLegacySortIndex{};
+  void set_legacy_sort_index(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LegacySortIndex::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 };
 
 } // Namespace.
@@ -14823,11 +17532,11 @@ class ChromeThreadDescriptor;
 class ThreadDescriptor;
 class ChromeProcessDescriptor;
 class ProcessDescriptor;
+enum TrackDescriptor_ChildTracksOrdering : int;
+enum TrackDescriptor_SiblingMergeBehavior : int;
 enum CounterDescriptor_BuiltinCounterType : int;
 enum CounterDescriptor_Unit : int;
-enum ChromeThreadDescriptor_ThreadType : int;
 enum ThreadDescriptor_ChromeThreadType : int;
-enum ChromeProcessDescriptor_ProcessType : int;
 enum ProcessDescriptor_ChromeProcessType : int;
 }  // namespace perfetto
 }  // namespace protos
@@ -14840,18 +17549,53 @@ class Message;
 namespace perfetto {
 namespace protos {
 namespace gen {
+enum TrackDescriptor_ChildTracksOrdering : int {
+  TrackDescriptor_ChildTracksOrdering_UNKNOWN = 0,
+  TrackDescriptor_ChildTracksOrdering_LEXICOGRAPHIC = 1,
+  TrackDescriptor_ChildTracksOrdering_CHRONOLOGICAL = 2,
+  TrackDescriptor_ChildTracksOrdering_EXPLICIT = 3,
+};
+enum TrackDescriptor_SiblingMergeBehavior : int {
+  TrackDescriptor_SiblingMergeBehavior_SIBLING_MERGE_BEHAVIOR_UNSPECIFIED = 0,
+  TrackDescriptor_SiblingMergeBehavior_SIBLING_MERGE_BEHAVIOR_BY_TRACK_NAME = 1,
+  TrackDescriptor_SiblingMergeBehavior_SIBLING_MERGE_BEHAVIOR_NONE = 2,
+  TrackDescriptor_SiblingMergeBehavior_SIBLING_MERGE_BEHAVIOR_BY_SIBLING_MERGE_KEY = 3,
+};
 
 class PERFETTO_EXPORT_COMPONENT TrackDescriptor : public ::protozero::CppMessageObj {
  public:
+  using ChildTracksOrdering = TrackDescriptor_ChildTracksOrdering;
+  static constexpr auto UNKNOWN = TrackDescriptor_ChildTracksOrdering_UNKNOWN;
+  static constexpr auto LEXICOGRAPHIC = TrackDescriptor_ChildTracksOrdering_LEXICOGRAPHIC;
+  static constexpr auto CHRONOLOGICAL = TrackDescriptor_ChildTracksOrdering_CHRONOLOGICAL;
+  static constexpr auto EXPLICIT = TrackDescriptor_ChildTracksOrdering_EXPLICIT;
+  static constexpr auto ChildTracksOrdering_MIN = TrackDescriptor_ChildTracksOrdering_UNKNOWN;
+  static constexpr auto ChildTracksOrdering_MAX = TrackDescriptor_ChildTracksOrdering_EXPLICIT;
+  using SiblingMergeBehavior = TrackDescriptor_SiblingMergeBehavior;
+  static constexpr auto SIBLING_MERGE_BEHAVIOR_UNSPECIFIED = TrackDescriptor_SiblingMergeBehavior_SIBLING_MERGE_BEHAVIOR_UNSPECIFIED;
+  static constexpr auto SIBLING_MERGE_BEHAVIOR_BY_TRACK_NAME = TrackDescriptor_SiblingMergeBehavior_SIBLING_MERGE_BEHAVIOR_BY_TRACK_NAME;
+  static constexpr auto SIBLING_MERGE_BEHAVIOR_NONE = TrackDescriptor_SiblingMergeBehavior_SIBLING_MERGE_BEHAVIOR_NONE;
+  static constexpr auto SIBLING_MERGE_BEHAVIOR_BY_SIBLING_MERGE_KEY = TrackDescriptor_SiblingMergeBehavior_SIBLING_MERGE_BEHAVIOR_BY_SIBLING_MERGE_KEY;
+  static constexpr auto SiblingMergeBehavior_MIN = TrackDescriptor_SiblingMergeBehavior_SIBLING_MERGE_BEHAVIOR_UNSPECIFIED;
+  static constexpr auto SiblingMergeBehavior_MAX = TrackDescriptor_SiblingMergeBehavior_SIBLING_MERGE_BEHAVIOR_BY_SIBLING_MERGE_KEY;
   enum FieldNumbers {
     kUuidFieldNumber = 1,
     kParentUuidFieldNumber = 5,
     kNameFieldNumber = 2,
+    kStaticNameFieldNumber = 10,
+    kAtraceNameFieldNumber = 13,
+    kDescriptionFieldNumber = 14,
     kProcessFieldNumber = 3,
     kChromeProcessFieldNumber = 6,
     kThreadFieldNumber = 4,
     kChromeThreadFieldNumber = 7,
     kCounterFieldNumber = 8,
+    kDisallowMergingWithSystemTracksFieldNumber = 9,
+    kChildOrderingFieldNumber = 11,
+    kSiblingOrderRankFieldNumber = 12,
+    kSiblingMergeBehaviorFieldNumber = 15,
+    kSiblingMergeKeyFieldNumber = 16,
+    kSiblingMergeKeyIntFieldNumber = 17,
   };
 
   TrackDescriptor();
@@ -14880,6 +17624,18 @@ class PERFETTO_EXPORT_COMPONENT TrackDescriptor : public ::protozero::CppMessage
   const std::string& name() const { return name_; }
   void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
 
+  bool has_static_name() const { return _has_field_[10]; }
+  const std::string& static_name() const { return static_name_; }
+  void set_static_name(const std::string& value) { static_name_ = value; _has_field_.set(10); }
+
+  bool has_atrace_name() const { return _has_field_[13]; }
+  const std::string& atrace_name() const { return atrace_name_; }
+  void set_atrace_name(const std::string& value) { atrace_name_ = value; _has_field_.set(13); }
+
+  bool has_description() const { return _has_field_[14]; }
+  const std::string& description() const { return description_; }
+  void set_description(const std::string& value) { description_ = value; _has_field_.set(14); }
+
   bool has_process() const { return _has_field_[3]; }
   const ProcessDescriptor& process() const { return *process_; }
   ProcessDescriptor* mutable_process() { _has_field_.set(3); return process_.get(); }
@@ -14900,21 +17656,54 @@ class PERFETTO_EXPORT_COMPONENT TrackDescriptor : public ::protozero::CppMessage
   const CounterDescriptor& counter() const { return *counter_; }
   CounterDescriptor* mutable_counter() { _has_field_.set(8); return counter_.get(); }
 
+  bool has_disallow_merging_with_system_tracks() const { return _has_field_[9]; }
+  bool disallow_merging_with_system_tracks() const { return disallow_merging_with_system_tracks_; }
+  void set_disallow_merging_with_system_tracks(bool value) { disallow_merging_with_system_tracks_ = value; _has_field_.set(9); }
+
+  bool has_child_ordering() const { return _has_field_[11]; }
+  TrackDescriptor_ChildTracksOrdering child_ordering() const { return child_ordering_; }
+  void set_child_ordering(TrackDescriptor_ChildTracksOrdering value) { child_ordering_ = value; _has_field_.set(11); }
+
+  bool has_sibling_order_rank() const { return _has_field_[12]; }
+  int32_t sibling_order_rank() const { return sibling_order_rank_; }
+  void set_sibling_order_rank(int32_t value) { sibling_order_rank_ = value; _has_field_.set(12); }
+
+  bool has_sibling_merge_behavior() const { return _has_field_[15]; }
+  TrackDescriptor_SiblingMergeBehavior sibling_merge_behavior() const { return sibling_merge_behavior_; }
+  void set_sibling_merge_behavior(TrackDescriptor_SiblingMergeBehavior value) { sibling_merge_behavior_ = value; _has_field_.set(15); }
+
+  bool has_sibling_merge_key() const { return _has_field_[16]; }
+  const std::string& sibling_merge_key() const { return sibling_merge_key_; }
+  void set_sibling_merge_key(const std::string& value) { sibling_merge_key_ = value; _has_field_.set(16); }
+
+  bool has_sibling_merge_key_int() const { return _has_field_[17]; }
+  uint64_t sibling_merge_key_int() const { return sibling_merge_key_int_; }
+  void set_sibling_merge_key_int(uint64_t value) { sibling_merge_key_int_ = value; _has_field_.set(17); }
+
  private:
   uint64_t uuid_{};
   uint64_t parent_uuid_{};
   std::string name_{};
+  std::string static_name_{};
+  std::string atrace_name_{};
+  std::string description_{};
   ::protozero::CopyablePtr<ProcessDescriptor> process_;
   ::protozero::CopyablePtr<ChromeProcessDescriptor> chrome_process_;
   ::protozero::CopyablePtr<ThreadDescriptor> thread_;
   ::protozero::CopyablePtr<ChromeThreadDescriptor> chrome_thread_;
   ::protozero::CopyablePtr<CounterDescriptor> counter_;
+  bool disallow_merging_with_system_tracks_{};
+  TrackDescriptor_ChildTracksOrdering child_ordering_{};
+  int32_t sibling_order_rank_{};
+  TrackDescriptor_SiblingMergeBehavior sibling_merge_behavior_{};
+  std::string sibling_merge_key_{};
+  uint64_t sibling_merge_key_int_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<9> _has_field_{};
+  std::bitset<18> _has_field_{};
 };
 
 }  // namespace perfetto
@@ -14940,14 +17729,94 @@ class PERFETTO_EXPORT_COMPONENT TrackDescriptor : public ::protozero::CppMessage
 namespace perfetto {
 namespace protos {
 namespace pbzero {
-
 class ChromeProcessDescriptor;
 class ChromeThreadDescriptor;
 class CounterDescriptor;
 class ProcessDescriptor;
 class ThreadDescriptor;
+namespace perfetto_pbzero_enum_TrackDescriptor {
+enum ChildTracksOrdering : int32_t;
+}  // namespace perfetto_pbzero_enum_TrackDescriptor
+using TrackDescriptor_ChildTracksOrdering = perfetto_pbzero_enum_TrackDescriptor::ChildTracksOrdering;
+namespace perfetto_pbzero_enum_TrackDescriptor {
+enum SiblingMergeBehavior : int32_t;
+}  // namespace perfetto_pbzero_enum_TrackDescriptor
+using TrackDescriptor_SiblingMergeBehavior = perfetto_pbzero_enum_TrackDescriptor::SiblingMergeBehavior;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-class TrackDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_TrackDescriptor {
+enum ChildTracksOrdering : int32_t {
+  UNKNOWN = 0,
+  LEXICOGRAPHIC = 1,
+  CHRONOLOGICAL = 2,
+  EXPLICIT = 3,
+};
+} // namespace perfetto_pbzero_enum_TrackDescriptor
+using TrackDescriptor_ChildTracksOrdering = perfetto_pbzero_enum_TrackDescriptor::ChildTracksOrdering;
+
+
+constexpr TrackDescriptor_ChildTracksOrdering TrackDescriptor_ChildTracksOrdering_MIN = TrackDescriptor_ChildTracksOrdering::UNKNOWN;
+constexpr TrackDescriptor_ChildTracksOrdering TrackDescriptor_ChildTracksOrdering_MAX = TrackDescriptor_ChildTracksOrdering::EXPLICIT;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* TrackDescriptor_ChildTracksOrdering_Name(::perfetto::protos::pbzero::TrackDescriptor_ChildTracksOrdering value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::TrackDescriptor_ChildTracksOrdering::UNKNOWN:
+    return "UNKNOWN";
+
+  case ::perfetto::protos::pbzero::TrackDescriptor_ChildTracksOrdering::LEXICOGRAPHIC:
+    return "LEXICOGRAPHIC";
+
+  case ::perfetto::protos::pbzero::TrackDescriptor_ChildTracksOrdering::CHRONOLOGICAL:
+    return "CHRONOLOGICAL";
+
+  case ::perfetto::protos::pbzero::TrackDescriptor_ChildTracksOrdering::EXPLICIT:
+    return "EXPLICIT";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_TrackDescriptor {
+enum SiblingMergeBehavior : int32_t {
+  SIBLING_MERGE_BEHAVIOR_UNSPECIFIED = 0,
+  SIBLING_MERGE_BEHAVIOR_BY_TRACK_NAME = 1,
+  SIBLING_MERGE_BEHAVIOR_NONE = 2,
+  SIBLING_MERGE_BEHAVIOR_BY_SIBLING_MERGE_KEY = 3,
+};
+} // namespace perfetto_pbzero_enum_TrackDescriptor
+using TrackDescriptor_SiblingMergeBehavior = perfetto_pbzero_enum_TrackDescriptor::SiblingMergeBehavior;
+
+
+constexpr TrackDescriptor_SiblingMergeBehavior TrackDescriptor_SiblingMergeBehavior_MIN = TrackDescriptor_SiblingMergeBehavior::SIBLING_MERGE_BEHAVIOR_UNSPECIFIED;
+constexpr TrackDescriptor_SiblingMergeBehavior TrackDescriptor_SiblingMergeBehavior_MAX = TrackDescriptor_SiblingMergeBehavior::SIBLING_MERGE_BEHAVIOR_BY_SIBLING_MERGE_KEY;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* TrackDescriptor_SiblingMergeBehavior_Name(::perfetto::protos::pbzero::TrackDescriptor_SiblingMergeBehavior value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::TrackDescriptor_SiblingMergeBehavior::SIBLING_MERGE_BEHAVIOR_UNSPECIFIED:
+    return "SIBLING_MERGE_BEHAVIOR_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::TrackDescriptor_SiblingMergeBehavior::SIBLING_MERGE_BEHAVIOR_BY_TRACK_NAME:
+    return "SIBLING_MERGE_BEHAVIOR_BY_TRACK_NAME";
+
+  case ::perfetto::protos::pbzero::TrackDescriptor_SiblingMergeBehavior::SIBLING_MERGE_BEHAVIOR_NONE:
+    return "SIBLING_MERGE_BEHAVIOR_NONE";
+
+  case ::perfetto::protos::pbzero::TrackDescriptor_SiblingMergeBehavior::SIBLING_MERGE_BEHAVIOR_BY_SIBLING_MERGE_KEY:
+    return "SIBLING_MERGE_BEHAVIOR_BY_SIBLING_MERGE_KEY";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class TrackDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/17> {
  public:
   TrackDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit TrackDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -14958,6 +17827,12 @@ class TrackDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIEL
   uint64_t parent_uuid() const { return at<5>().as_uint64(); }
   bool has_name() const { return at<2>().valid(); }
   ::protozero::ConstChars name() const { return at<2>().as_string(); }
+  bool has_static_name() const { return at<10>().valid(); }
+  ::protozero::ConstChars static_name() const { return at<10>().as_string(); }
+  bool has_atrace_name() const { return at<13>().valid(); }
+  ::protozero::ConstChars atrace_name() const { return at<13>().as_string(); }
+  bool has_description() const { return at<14>().valid(); }
+  ::protozero::ConstChars description() const { return at<14>().as_string(); }
   bool has_process() const { return at<3>().valid(); }
   ::protozero::ConstBytes process() const { return at<3>().as_bytes(); }
   bool has_chrome_process() const { return at<6>().valid(); }
@@ -14968,6 +17843,18 @@ class TrackDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIEL
   ::protozero::ConstBytes chrome_thread() const { return at<7>().as_bytes(); }
   bool has_counter() const { return at<8>().valid(); }
   ::protozero::ConstBytes counter() const { return at<8>().as_bytes(); }
+  bool has_disallow_merging_with_system_tracks() const { return at<9>().valid(); }
+  bool disallow_merging_with_system_tracks() const { return at<9>().as_bool(); }
+  bool has_child_ordering() const { return at<11>().valid(); }
+  int32_t child_ordering() const { return at<11>().as_int32(); }
+  bool has_sibling_order_rank() const { return at<12>().valid(); }
+  int32_t sibling_order_rank() const { return at<12>().as_int32(); }
+  bool has_sibling_merge_behavior() const { return at<15>().valid(); }
+  int32_t sibling_merge_behavior() const { return at<15>().as_int32(); }
+  bool has_sibling_merge_key() const { return at<16>().valid(); }
+  ::protozero::ConstChars sibling_merge_key() const { return at<16>().as_string(); }
+  bool has_sibling_merge_key_int() const { return at<17>().valid(); }
+  uint64_t sibling_merge_key_int() const { return at<17>().as_uint64(); }
 };
 
 class TrackDescriptor : public ::protozero::Message {
@@ -14977,15 +17864,42 @@ class TrackDescriptor : public ::protozero::Message {
     kUuidFieldNumber = 1,
     kParentUuidFieldNumber = 5,
     kNameFieldNumber = 2,
+    kStaticNameFieldNumber = 10,
+    kAtraceNameFieldNumber = 13,
+    kDescriptionFieldNumber = 14,
     kProcessFieldNumber = 3,
     kChromeProcessFieldNumber = 6,
     kThreadFieldNumber = 4,
     kChromeThreadFieldNumber = 7,
     kCounterFieldNumber = 8,
+    kDisallowMergingWithSystemTracksFieldNumber = 9,
+    kChildOrderingFieldNumber = 11,
+    kSiblingOrderRankFieldNumber = 12,
+    kSiblingMergeBehaviorFieldNumber = 15,
+    kSiblingMergeKeyFieldNumber = 16,
+    kSiblingMergeKeyIntFieldNumber = 17,
   };
   static constexpr const char* GetName() { return ".perfetto.protos.TrackDescriptor"; }
 
 
+  using ChildTracksOrdering = ::perfetto::protos::pbzero::TrackDescriptor_ChildTracksOrdering;
+  static inline const char* ChildTracksOrdering_Name(ChildTracksOrdering value) {
+    return ::perfetto::protos::pbzero::TrackDescriptor_ChildTracksOrdering_Name(value);
+  }
+
+  using SiblingMergeBehavior = ::perfetto::protos::pbzero::TrackDescriptor_SiblingMergeBehavior;
+  static inline const char* SiblingMergeBehavior_Name(SiblingMergeBehavior value) {
+    return ::perfetto::protos::pbzero::TrackDescriptor_SiblingMergeBehavior_Name(value);
+  }
+  static inline const ChildTracksOrdering UNKNOWN = ChildTracksOrdering::UNKNOWN;
+  static inline const ChildTracksOrdering LEXICOGRAPHIC = ChildTracksOrdering::LEXICOGRAPHIC;
+  static inline const ChildTracksOrdering CHRONOLOGICAL = ChildTracksOrdering::CHRONOLOGICAL;
+  static inline const ChildTracksOrdering EXPLICIT = ChildTracksOrdering::EXPLICIT;
+  static inline const SiblingMergeBehavior SIBLING_MERGE_BEHAVIOR_UNSPECIFIED = SiblingMergeBehavior::SIBLING_MERGE_BEHAVIOR_UNSPECIFIED;
+  static inline const SiblingMergeBehavior SIBLING_MERGE_BEHAVIOR_BY_TRACK_NAME = SiblingMergeBehavior::SIBLING_MERGE_BEHAVIOR_BY_TRACK_NAME;
+  static inline const SiblingMergeBehavior SIBLING_MERGE_BEHAVIOR_NONE = SiblingMergeBehavior::SIBLING_MERGE_BEHAVIOR_NONE;
+  static inline const SiblingMergeBehavior SIBLING_MERGE_BEHAVIOR_BY_SIBLING_MERGE_KEY = SiblingMergeBehavior::SIBLING_MERGE_BEHAVIOR_BY_SIBLING_MERGE_KEY;
+
   using FieldMetadata_Uuid =
     ::protozero::proto_utils::FieldMetadata<
       1,
@@ -14994,14 +17908,7 @@ class TrackDescriptor : public ::protozero::Message {
       uint64_t,
       TrackDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Uuid kUuid() { return {}; }
+  static constexpr FieldMetadata_Uuid kUuid{};
   void set_uuid(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Uuid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -15019,14 +17926,7 @@ class TrackDescriptor : public ::protozero::Message {
       uint64_t,
       TrackDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ParentUuid kParentUuid() { return {}; }
+  static constexpr FieldMetadata_ParentUuid kParentUuid{};
   void set_parent_uuid(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ParentUuid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -15044,14 +17944,7 @@ class TrackDescriptor : public ::protozero::Message {
       std::string,
       TrackDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -15067,6 +17960,78 @@ class TrackDescriptor : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
+  using FieldMetadata_StaticName =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TrackDescriptor>;
+
+  static constexpr FieldMetadata_StaticName kStaticName{};
+  void set_static_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_StaticName::kFieldId, data, size);
+  }
+  void set_static_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_StaticName::kFieldId, chars.data, chars.size);
+  }
+  void set_static_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_StaticName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_AtraceName =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TrackDescriptor>;
+
+  static constexpr FieldMetadata_AtraceName kAtraceName{};
+  void set_atrace_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_AtraceName::kFieldId, data, size);
+  }
+  void set_atrace_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_AtraceName::kFieldId, chars.data, chars.size);
+  }
+  void set_atrace_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_AtraceName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Description =
+    ::protozero::proto_utils::FieldMetadata<
+      14,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TrackDescriptor>;
+
+  static constexpr FieldMetadata_Description kDescription{};
+  void set_description(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Description::kFieldId, data, size);
+  }
+  void set_description(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Description::kFieldId, chars.data, chars.size);
+  }
+  void set_description(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Description::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
   using FieldMetadata_Process =
     ::protozero::proto_utils::FieldMetadata<
       3,
@@ -15075,14 +18040,7 @@ class TrackDescriptor : public ::protozero::Message {
       ProcessDescriptor,
       TrackDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Process kProcess() { return {}; }
+  static constexpr FieldMetadata_Process kProcess{};
   template <typename T = ProcessDescriptor> T* set_process() {
     return BeginNestedMessage<T>(3);
   }
@@ -15096,14 +18054,7 @@ class TrackDescriptor : public ::protozero::Message {
       ChromeProcessDescriptor,
       TrackDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeProcess kChromeProcess() { return {}; }
+  static constexpr FieldMetadata_ChromeProcess kChromeProcess{};
   template <typename T = ChromeProcessDescriptor> T* set_chrome_process() {
     return BeginNestedMessage<T>(6);
   }
@@ -15117,14 +18068,7 @@ class TrackDescriptor : public ::protozero::Message {
       ThreadDescriptor,
       TrackDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Thread kThread() { return {}; }
+  static constexpr FieldMetadata_Thread kThread{};
   template <typename T = ThreadDescriptor> T* set_thread() {
     return BeginNestedMessage<T>(4);
   }
@@ -15138,14 +18082,7 @@ class TrackDescriptor : public ::protozero::Message {
       ChromeThreadDescriptor,
       TrackDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeThread kChromeThread() { return {}; }
+  static constexpr FieldMetadata_ChromeThread kChromeThread{};
   template <typename T = ChromeThreadDescriptor> T* set_chrome_thread() {
     return BeginNestedMessage<T>(7);
   }
@@ -15159,66 +18096,180 @@ class TrackDescriptor : public ::protozero::Message {
       CounterDescriptor,
       TrackDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Counter kCounter() { return {}; }
+  static constexpr FieldMetadata_Counter kCounter{};
   template <typename T = CounterDescriptor> T* set_counter() {
     return BeginNestedMessage<T>(8);
   }
 
-};
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+  using FieldMetadata_DisallowMergingWithSystemTracks =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TrackDescriptor>;
 
-#ifndef INCLUDE_PERFETTO_TRACING_TRACK_H_
-#define INCLUDE_PERFETTO_TRACING_TRACK_H_
+  static constexpr FieldMetadata_DisallowMergingWithSystemTracks kDisallowMergingWithSystemTracks{};
+  void set_disallow_merging_with_system_tracks(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DisallowMergingWithSystemTracks::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  using FieldMetadata_ChildOrdering =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      TrackDescriptor_ChildTracksOrdering,
+      TrackDescriptor>;
+
+  static constexpr FieldMetadata_ChildOrdering kChildOrdering{};
+  void set_child_ordering(TrackDescriptor_ChildTracksOrdering value) {
+    static constexpr uint32_t field_id = FieldMetadata_ChildOrdering::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SiblingOrderRank =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TrackDescriptor>;
+
+  static constexpr FieldMetadata_SiblingOrderRank kSiblingOrderRank{};
+  void set_sibling_order_rank(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SiblingOrderRank::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SiblingMergeBehavior =
+    ::protozero::proto_utils::FieldMetadata<
+      15,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      TrackDescriptor_SiblingMergeBehavior,
+      TrackDescriptor>;
+
+  static constexpr FieldMetadata_SiblingMergeBehavior kSiblingMergeBehavior{};
+  void set_sibling_merge_behavior(TrackDescriptor_SiblingMergeBehavior value) {
+    static constexpr uint32_t field_id = FieldMetadata_SiblingMergeBehavior::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SiblingMergeKey =
+    ::protozero::proto_utils::FieldMetadata<
+      16,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TrackDescriptor>;
+
+  static constexpr FieldMetadata_SiblingMergeKey kSiblingMergeKey{};
+  void set_sibling_merge_key(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_SiblingMergeKey::kFieldId, data, size);
+  }
+  void set_sibling_merge_key(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_SiblingMergeKey::kFieldId, chars.data, chars.size);
+  }
+  void set_sibling_merge_key(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_SiblingMergeKey::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SiblingMergeKeyInt =
+    ::protozero::proto_utils::FieldMetadata<
+      17,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TrackDescriptor>;
+
+  static constexpr FieldMetadata_SiblingMergeKeyInt kSiblingMergeKeyInt{};
+  void set_sibling_merge_key_int(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SiblingMergeKeyInt::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_TRACING_TRACK_H_
+#define INCLUDE_PERFETTO_TRACING_TRACK_H_
+
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 // gen_amalgamated expanded: #include "perfetto/base/proc_utils.h"
 // gen_amalgamated expanded: #include "perfetto/base/thread_utils.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message_handle.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
-// gen_amalgamated expanded: #include "perfetto/tracing/internal/compile_time_hash.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/fnv1a.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_muxer.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/platform.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/counter_descriptor.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/counter_descriptor.pbzero.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_descriptor.gen.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_descriptor.pbzero.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/string_helpers.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h"  // IWYU pragma: export
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/counter_descriptor.gen.h"  // IWYU pragma: export
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/counter_descriptor.pbzero.h"  // IWYU pragma: export
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/process_descriptor.gen.h"  // IWYU pragma: export
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/process_descriptor.pbzero.h"  // IWYU pragma: export
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/thread_descriptor.gen.h"  // IWYU pragma: export
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/thread_descriptor.pbzero.h"  // IWYU pragma: export
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_descriptor.gen.h"  // IWYU pragma: export
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_descriptor.pbzero.h"  // IWYU pragma: export
 
 #include <stdint.h>
 #include <map>
 #include <mutex>
+#include <optional>
 
 namespace perfetto {
 namespace internal {
 class TrackRegistry;
-}
-class Flow;
-class TerminatingFlow;
+template <class T>
+class FlowImpl;
+}  // namespace internal
 
 // Track events are recorded on a timeline track, which maintains the relative
 // time ordering of all events on that track. Each thread has its own default
@@ -15298,11 +18349,7 @@ struct PERFETTO_EXPORT_COMPONENT Track {
   // Construct a track using |ptr| as identifier within thread-scope.
   // Shorthand for `Track::FromPointer(ptr, ThreadTrack::Current())`
   // Usage: TRACE_EVENT_BEGIN("...", "...", perfetto::Track::ThreadScoped(this))
-  static Track ThreadScoped(
-      const void* ptr,
-      Track parent = MakeThreadTrack(base::GetThreadId())) {
-    return Track::FromPointer(ptr, parent);
-  }
+  static Track ThreadScoped(const void* ptr, Track parent = Track());
 
  protected:
   constexpr Track(uint64_t uuid_, uint64_t parent_uuid_)
@@ -15318,15 +18365,13 @@ struct PERFETTO_EXPORT_COMPONENT Track {
   static Track MakeProcessTrack() { return Track(process_uuid, Track()); }
 
   static constexpr inline uint64_t CompileTimeHash(const char* string) {
-    return internal::CompileTimeHash()
-        .Update(string, static_cast<size_t>(base::StrEnd(string) - string))
-        .digest();
+    return internal::Fnv1a(string);
   }
 
  private:
   friend class internal::TrackRegistry;
-  friend class Flow;
-  friend class TerminatingFlow;
+  template <class T>
+  friend class internal::FlowImpl;
   static uint64_t process_uuid;
 };
 
@@ -15351,22 +18396,141 @@ struct PERFETTO_EXPORT_COMPONENT ProcessTrack : public Track {
 struct PERFETTO_EXPORT_COMPONENT ThreadTrack : public Track {
   const base::PlatformProcessId pid;
   const base::PlatformThreadId tid;
+  bool disallow_merging_with_system_tracks = false;
 
-  static ThreadTrack Current() { return ThreadTrack(base::GetThreadId()); }
+  static ThreadTrack Current();
 
   // Represents a thread in the current process.
-  static ThreadTrack ForThread(base::PlatformThreadId tid_) {
-    return ThreadTrack(tid_);
-  }
+  static ThreadTrack ForThread(base::PlatformThreadId tid_);
 
   void Serialize(protos::pbzero::TrackDescriptor*) const;
   protos::gen::TrackDescriptor Serialize() const;
 
  private:
-  explicit ThreadTrack(base::PlatformThreadId tid_)
+  explicit ThreadTrack(base::PlatformThreadId tid_,
+                       bool disallow_merging_with_system_tracks_)
       : Track(MakeThreadTrack(tid_)),
         pid(ProcessTrack::Current().pid),
-        tid(tid_) {}
+        tid(tid_),
+        disallow_merging_with_system_tracks(
+            disallow_merging_with_system_tracks_) {}
+};
+
+// A track that's identified by an explcit name, id and its parent.
+class PERFETTO_EXPORT_COMPONENT NamedTrack : public Track {
+  // A random value mixed into named track uuids to avoid collisions with
+  // other types of tracks.
+  static constexpr uint64_t kNamedTrackMagic = 0xCD571EC5EAD37024ul;
+
+ public:
+  // `name` is hashed to get a uuid identifying the track. Optionally specify
+  // `id` to differentiate between multiple tracks with the same `name` and
+  // `parent`.
+  NamedTrack(DynamicString name,
+             uint64_t id = 0,
+             Track parent = MakeProcessTrack())
+      : Track(id ^ internal::Fnv1a(name.value, name.length) ^ kNamedTrackMagic,
+              parent),
+        static_name_(nullptr),
+        dynamic_name_(name) {}
+
+  constexpr NamedTrack(StaticString name,
+                       uint64_t id = 0,
+                       Track parent = MakeProcessTrack())
+      : Track(id ^ internal::Fnv1a(name.value) ^ kNamedTrackMagic, parent),
+        static_name_(name) {}
+
+  // Construct a track using `name` and `ptr` as identifier.
+  template <class TrackEventName>
+  static NamedTrack FromPointer(TrackEventName&& name,
+                                const void* ptr,
+                                Track parent = MakeProcessTrack()) {
+    // Using pointers as global TrackIds isn't supported as pointers are
+    // per-proccess and the same pointer value can be used in different
+    // processes. If you hit this check but are providing no |parent| track,
+    // verify that Tracing::Initialize() was called for the current process.
+    PERFETTO_DCHECK(parent.uuid != Track().uuid);
+
+    return NamedTrack(std::forward<TrackEventName>(name),
+                      static_cast<uint64_t>(reinterpret_cast<uintptr_t>(ptr)),
+                      parent);
+  }
+
+  // Construct a track using `name` and `id` as identifier within thread-scope.
+  // Shorthand for `Track::NamedTrack("name", id, ThreadTrack::Current())`
+  // Usage: TRACE_EVENT_BEGIN("...", "...",
+  // perfetto::NamedTrack::ThreadScoped("rendering"))
+  template <class TrackEventName>
+  static NamedTrack ThreadScoped(TrackEventName&& name,
+                                 uint64_t id = 0,
+                                 Track parent = Track()) {
+    if (parent.uuid == 0)
+      return NamedTrack(std::forward<TrackEventName>(name), id,
+                        ThreadTrack::Current());
+    return NamedTrack(std::forward<TrackEventName>(name), id, parent);
+  }
+
+  // Same as above using `name` and `ptr` as identifier within thread-scope.
+  template <class TrackEventName>
+  static NamedTrack ThreadScoped(TrackEventName&& name,
+                                 const void* ptr,
+                                 Track parent = Track()) {
+    if (parent.uuid == 0) {
+      return NamedTrack::FromPointer(std::forward<TrackEventName>(name), ptr,
+                                     ThreadTrack::Current());
+    }
+    return NamedTrack::FromPointer(std::forward<TrackEventName>(name), ptr,
+                                   parent);
+  }
+
+  template <class TrackEventName>
+  static NamedTrack Global(TrackEventName&& name, uint64_t id = 0) {
+    return NamedTrack(std::forward<TrackEventName>(name), id, Track());
+  }
+
+  constexpr NamedTrack disable_sibling_merge() const {
+    return NamedTrack(
+        *this,
+        perfetto::protos::gen::TrackDescriptor::SIBLING_MERGE_BEHAVIOR_NONE,
+        nullptr, std::nullopt);
+  }
+  constexpr NamedTrack set_sibling_merge_key(const char* key) {
+    return NamedTrack(*this,
+                      perfetto::protos::gen::TrackDescriptor::
+                          SIBLING_MERGE_BEHAVIOR_BY_SIBLING_MERGE_KEY,
+                      key, std::nullopt);
+  }
+  constexpr NamedTrack set_sibling_merge_key(uint64_t key) {
+    return NamedTrack(*this,
+                      perfetto::protos::gen::TrackDescriptor::
+                          SIBLING_MERGE_BEHAVIOR_BY_SIBLING_MERGE_KEY,
+                      nullptr, key);
+  }
+
+  void Serialize(protos::pbzero::TrackDescriptor*) const;
+  protos::gen::TrackDescriptor Serialize() const;
+
+ private:
+  constexpr NamedTrack(
+      const NamedTrack& other,
+      perfetto::protos::gen::TrackDescriptor::SiblingMergeBehavior
+          sibling_merge_behavior,
+      const char* sibling_merge_key,
+      std::optional<uint64_t> sibling_merge_key_int)
+      : Track(other),
+        static_name_(other.static_name_),
+        dynamic_name_(other.dynamic_name_),
+        sibling_merge_behavior_(sibling_merge_behavior),
+        sibling_merge_key_(sibling_merge_key),
+        sibling_merge_key_int_(std::move(sibling_merge_key_int)) {}
+
+  StaticString static_name_;
+  DynamicString dynamic_name_;
+  perfetto::protos::gen::TrackDescriptor::SiblingMergeBehavior
+      sibling_merge_behavior_{perfetto::protos::gen::TrackDescriptor::
+                                  SIBLING_MERGE_BEHAVIOR_UNSPECIFIED};
+  const char* sibling_merge_key_{nullptr};
+  std::optional<uint64_t> sibling_merge_key_int_ = std::nullopt;
 };
 
 // A track for recording counter values with the TRACE_COUNTER macro. Counter
@@ -15382,72 +18546,117 @@ class PERFETTO_EXPORT_COMPONENT CounterTrack : public Track {
   using CounterType =
       perfetto::protos::gen::CounterDescriptor::BuiltinCounterType;
 
-  // |name| must be a string with static lifetime.
-  constexpr explicit CounterTrack(const char* name,
+  // |name| must outlive this object.
+  constexpr explicit CounterTrack(StaticString name,
+                                  Track parent = MakeProcessTrack())
+      : CounterTrack(
+            name,
+            0u,
+            perfetto::protos::pbzero::CounterDescriptor::UNIT_UNSPECIFIED,
+            nullptr,
+            parent) {}
+
+  constexpr explicit CounterTrack(StaticString name,
+                                  uint64_t id,
                                   Track parent = MakeProcessTrack())
-      : Track(CompileTimeHash(name) ^ kCounterMagic, parent),
-        name_(name),
-        category_(nullptr) {}
+      : CounterTrack(
+            name,
+            id,
+            perfetto::protos::pbzero::CounterDescriptor::UNIT_UNSPECIFIED,
+            nullptr,
+            parent) {}
+
+  explicit CounterTrack(DynamicString name, Track parent = MakeProcessTrack())
+      : CounterTrack(
+            name,
+            0u,
+            perfetto::protos::pbzero::CounterDescriptor::UNIT_UNSPECIFIED,
+            nullptr,
+            parent) {}
+
+  explicit CounterTrack(DynamicString name,
+                        uint64_t id,
+                        Track parent = MakeProcessTrack())
+      : CounterTrack(
+            name,
+            id,
+            perfetto::protos::pbzero::CounterDescriptor::UNIT_UNSPECIFIED,
+            nullptr,
+            parent) {}
 
   // |unit_name| is a free-form description of the unit used by this counter. It
-  // must have static lifetime.
-  constexpr CounterTrack(const char* name,
+  // must outlive this object.
+  template <class TrackEventName>
+  constexpr CounterTrack(TrackEventName&& name,
                          const char* unit_name,
                          Track parent = MakeProcessTrack())
-      : Track(CompileTimeHash(name) ^ kCounterMagic, parent),
-        name_(name),
-        category_(nullptr),
-        unit_name_(unit_name) {}
-
-  constexpr CounterTrack(const char* name,
+      : CounterTrack(
+            std::forward<TrackEventName>(name),
+            0u,
+            perfetto::protos::pbzero::CounterDescriptor::UNIT_UNSPECIFIED,
+            unit_name,
+            parent) {}
+
+  template <class TrackEventName>
+  constexpr CounterTrack(TrackEventName&& name,
                          Unit unit,
                          Track parent = MakeProcessTrack())
-      : Track(CompileTimeHash(name) ^ kCounterMagic, parent),
-        name_(name),
-        category_(nullptr),
-        unit_(unit) {}
-
-  static constexpr CounterTrack Global(const char* name,
+      : CounterTrack(std::forward<TrackEventName>(name),
+                     0u,
+                     unit,
+                     nullptr,
+                     parent) {}
+
+  template <class TrackEventName>
+  static constexpr CounterTrack Global(TrackEventName&& name,
                                        const char* unit_name) {
-    return CounterTrack(name, unit_name, Track());
+    return CounterTrack(std::forward<TrackEventName>(name), unit_name, Track());
   }
 
-  static constexpr CounterTrack Global(const char* name, Unit unit) {
-    return CounterTrack(name, unit, Track());
+  template <class TrackEventName>
+  static constexpr CounterTrack Global(TrackEventName&& name, Unit unit) {
+    return CounterTrack(std::forward<TrackEventName>(name), unit, Track());
   }
 
-  static constexpr CounterTrack Global(const char* name) {
-    return Global(name, nullptr);
+  template <class TrackEventName>
+  static constexpr CounterTrack Global(TrackEventName&& name) {
+    return Global(std::forward<TrackEventName>(name), nullptr);
   }
 
   constexpr CounterTrack set_unit(Unit unit) const {
-    return CounterTrack(uuid, parent_uuid, name_, category_, unit, unit_name_,
-                        unit_multiplier_, is_incremental_, type_);
+    return CounterTrack(uuid, parent_uuid, static_name_, dynamic_name_,
+                        category_, unit, unit_name_, unit_multiplier_,
+                        is_incremental_, type_);
   }
 
   constexpr CounterTrack set_type(CounterType type) const {
-    return CounterTrack(uuid, parent_uuid, name_, category_, unit_, unit_name_,
-                        unit_multiplier_, is_incremental_, type);
+    return CounterTrack(uuid, parent_uuid, static_name_, dynamic_name_,
+                        category_, unit_, unit_name_, unit_multiplier_,
+                        is_incremental_, type);
   }
 
   constexpr CounterTrack set_unit_name(const char* unit_name) const {
-    return CounterTrack(uuid, parent_uuid, name_, category_, unit_, unit_name,
-                        unit_multiplier_, is_incremental_, type_);
+    return CounterTrack(uuid, parent_uuid, static_name_, dynamic_name_,
+                        category_, unit_, unit_name, unit_multiplier_,
+                        is_incremental_, type_);
   }
 
   constexpr CounterTrack set_unit_multiplier(int64_t unit_multiplier) const {
-    return CounterTrack(uuid, parent_uuid, name_, category_, unit_, unit_name_,
-                        unit_multiplier, is_incremental_, type_);
+    return CounterTrack(uuid, parent_uuid, static_name_, dynamic_name_,
+                        category_, unit_, unit_name_, unit_multiplier,
+                        is_incremental_, type_);
   }
 
   constexpr CounterTrack set_category(const char* category) const {
-    return CounterTrack(uuid, parent_uuid, name_, category, unit_, unit_name_,
-                        unit_multiplier_, is_incremental_, type_);
+    return CounterTrack(uuid, parent_uuid, static_name_, dynamic_name_,
+                        category, unit_, unit_name_, unit_multiplier_,
+                        is_incremental_, type_);
   }
 
   constexpr CounterTrack set_is_incremental(bool is_incremental = true) const {
-    return CounterTrack(uuid, parent_uuid, name_, category_, unit_, unit_name_,
-                        unit_multiplier_, is_incremental, type_);
+    return CounterTrack(uuid, parent_uuid, static_name_, dynamic_name_,
+                        category_, unit_, unit_name_, unit_multiplier_,
+                        is_incremental, type_);
   }
 
   constexpr bool is_incremental() const { return is_incremental_; }
@@ -15456,9 +18665,32 @@ class PERFETTO_EXPORT_COMPONENT CounterTrack : public Track {
   protos::gen::TrackDescriptor Serialize() const;
 
  private:
+  constexpr CounterTrack(StaticString name,
+                         uint64_t id,
+                         Unit unit,
+                         const char* unit_name,
+                         Track parent)
+      : Track(id ^ internal::Fnv1a(name.value) ^ kCounterMagic, parent),
+        static_name_(name),
+        category_(nullptr),
+        unit_(unit),
+        unit_name_(unit_name) {}
+  CounterTrack(DynamicString name,
+               uint64_t id,
+               Unit unit,
+               const char* unit_name,
+               Track parent)
+      : Track(id ^ internal::Fnv1a(name.value, name.length) ^ kCounterMagic,
+              parent),
+        static_name_(nullptr),
+        dynamic_name_(name),
+        category_(nullptr),
+        unit_(unit),
+        unit_name_(unit_name) {}
   constexpr CounterTrack(uint64_t uuid_,
                          uint64_t parent_uuid_,
-                         const char* name,
+                         StaticString static_name,
+                         DynamicString dynamic_name,
                          const char* category,
                          Unit unit,
                          const char* unit_name,
@@ -15466,7 +18698,8 @@ class PERFETTO_EXPORT_COMPONENT CounterTrack : public Track {
                          bool is_incremental,
                          CounterType type)
       : Track(uuid_, parent_uuid_),
-        name_(name),
+        static_name_(static_name),
+        dynamic_name_(dynamic_name),
         category_(category),
         unit_(unit),
         unit_name_(unit_name),
@@ -15474,7 +18707,8 @@ class PERFETTO_EXPORT_COMPONENT CounterTrack : public Track {
         is_incremental_(is_incremental),
         type_(type) {}
 
-  const char* const name_;
+  StaticString static_name_;
+  DynamicString dynamic_name_;
   const char* const category_;
   Unit unit_ = perfetto::protos::pbzero::CounterDescriptor::UNIT_UNSPECIFIED;
   const char* const unit_name_ = nullptr;
@@ -15499,70 +18733,71 @@ namespace internal {
 class PERFETTO_EXPORT_COMPONENT TrackRegistry {
  public:
   using SerializedTrackDescriptor = std::string;
+  struct TrackInfo {
+    SerializedTrackDescriptor desc;
+    uint64_t parent_uuid = 0;
+  };
 
   TrackRegistry();
   ~TrackRegistry();
 
-  static void InitializeInstance();
+  static void InitializeInstance(
+      std::optional<uint64_t> process_uuid = std::nullopt);
   static void ResetForTesting();
+  static uint64_t ComputeProcessUuid();
   static TrackRegistry* Get() { return instance_; }
 
   void EraseTrack(Track);
 
-  // Store metadata for |track| in the registry. |fill_function| is called
-  // synchronously to record additional properties for the track.
-  template <typename TrackType>
-  void UpdateTrack(
-      const TrackType& track,
-      std::function<void(protos::pbzero::TrackDescriptor*)> fill_function) {
-    UpdateTrackImpl(track, [&](protos::pbzero::TrackDescriptor* desc) {
-      track.Serialize(desc);
-      fill_function(desc);
-    });
-  }
-
   // This variant lets the user supply a serialized track descriptor directly.
   void UpdateTrack(Track, const std::string& serialized_desc);
 
   // If |track| exists in the registry, write out the serialized track
   // descriptor for it into |packet|. Otherwise just the ephemeral track object
   // is serialized without any additional metadata.
+  //
+  // Returns the parent track uuid.
   template <typename TrackType>
-  void SerializeTrack(
+  uint64_t SerializeTrack(
       const TrackType& track,
       protozero::MessageHandle<protos::pbzero::TracePacket> packet) {
     // If the track has extra metadata (recorded with UpdateTrack), it will be
     // found in the registry. To minimize the time the lock is held, make a copy
     // of the data held in the registry and write it outside the lock.
-    std::string desc_copy;
-    {
-      std::lock_guard<std::mutex> lock(mutex_);
-      const auto& it = tracks_.find(track.uuid);
-      if (it != tracks_.end()) {
-        desc_copy = it->second;
-        PERFETTO_DCHECK(!desc_copy.empty());
-      }
-    }
-    if (!desc_copy.empty()) {
-      WriteTrackDescriptor(std::move(desc_copy), std::move(packet));
+    auto track_info = FindTrackInfo(track.uuid);
+    if (track_info) {
+      WriteTrackDescriptor(std::move(track_info->desc), std::move(packet));
+      return track_info->parent_uuid;
     } else {
       // Otherwise we just write the basic descriptor for this type of track
       // (e.g., just uuid, no name).
       track.Serialize(packet->set_track_descriptor());
+      return track.parent_uuid;
     }
   }
 
+  // If saved in the registry, returns the serialize track descriptor and parent
+  // uuid for `uuid`.
+  std::optional<TrackInfo> FindTrackInfo(uint64_t uuid) {
+    std::optional<TrackInfo> track_info;
+    {
+      std::lock_guard<std::mutex> lock(mutex_);
+      const auto it = tracks_.find(uuid);
+      if (it != tracks_.end()) {
+        track_info = it->second;
+        PERFETTO_DCHECK(!track_info->desc.empty());
+      }
+    }
+    return track_info;
+  }
+
   static void WriteTrackDescriptor(
       const SerializedTrackDescriptor& desc,
       protozero::MessageHandle<protos::pbzero::TracePacket> packet);
 
  private:
-  void UpdateTrackImpl(
-      Track,
-      std::function<void(protos::pbzero::TrackDescriptor*)> fill_function);
-
   std::mutex mutex_;
-  std::map<uint64_t /* uuid */, SerializedTrackDescriptor> tracks_;
+  std::map<uint64_t /* uuid */, TrackInfo> tracks_;
 
   static TrackRegistry* instance_;
 };
@@ -15586,11 +18821,11 @@ class PERFETTO_EXPORT_COMPONENT TrackRegistry {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
 enum BuiltinClock : int32_t {
   BUILTIN_CLOCK_UNKNOWN = 0,
   BUILTIN_CLOCK_REALTIME = 1,
@@ -15599,6 +18834,9 @@ enum BuiltinClock : int32_t {
   BUILTIN_CLOCK_MONOTONIC_COARSE = 4,
   BUILTIN_CLOCK_MONOTONIC_RAW = 5,
   BUILTIN_CLOCK_BOOTTIME = 6,
+  BUILTIN_CLOCK_TSC = 9,
+  BUILTIN_CLOCK_PERF = 10,
+  BUILTIN_CLOCK_TRACE_FILE = 11,
   BUILTIN_CLOCK_MAX_ID = 63,
 };
 
@@ -15630,6 +18868,15 @@ const char* BuiltinClock_Name(::perfetto::protos::pbzero::BuiltinClock value) {
   case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_BOOTTIME:
     return "BUILTIN_CLOCK_BOOTTIME";
 
+  case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_TSC:
+    return "BUILTIN_CLOCK_TSC";
+
+  case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_PERF:
+    return "BUILTIN_CLOCK_PERF";
+
+  case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_TRACE_FILE:
+    return "BUILTIN_CLOCK_TRACE_FILE";
+
   case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_MAX_ID:
     return "BUILTIN_CLOCK_MAX_ID";
   }
@@ -15658,7 +18905,8 @@ const char* BuiltinClock_Name(::perfetto::protos::pbzero::BuiltinClock value) {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
-
+class AndroidJobName;
+class AppWakelockInfo;
 class Callstack;
 class DebugAnnotationName;
 class DebugAnnotationValueTypeName;
@@ -15669,13 +18917,89 @@ class HistogramName;
 class InternedGpuRenderStageSpecification;
 class InternedGraphicsContext;
 class InternedString;
+class InternedV8Isolate;
+class InternedV8JsFunction;
+class InternedV8JsScript;
+class InternedV8String;
+class InternedV8WasmScript;
 class LogMessageBody;
 class Mapping;
-class ProfiledFrameSymbols;
+class NetworkPacketContext;
 class SourceLocation;
 class UnsymbolizedSourceLocation;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-class InternedData_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/29, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class AndroidJobName_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  AndroidJobName_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidJobName_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidJobName_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_iid() const { return at<1>().valid(); }
+  uint64_t iid() const { return at<1>().as_uint64(); }
+  bool has_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars name() const { return at<2>().as_string(); }
+};
+
+class AndroidJobName : public ::protozero::Message {
+ public:
+  using Decoder = AndroidJobName_Decoder;
+  enum : int32_t {
+    kIidFieldNumber = 1,
+    kNameFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidJobName"; }
+
+
+  using FieldMetadata_Iid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      AndroidJobName>;
+
+  static constexpr FieldMetadata_Iid kIid{};
+  void set_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      AndroidJobName>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class InternedData_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/46> {
  public:
   InternedData_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit InternedData_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -15704,8 +19028,6 @@ class InternedData_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_I
   ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> source_paths() const { return GetRepeated<::protozero::ConstBytes>(18); }
   bool has_function_names() const { return at<5>().valid(); }
   ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> function_names() const { return GetRepeated<::protozero::ConstBytes>(5); }
-  bool has_profiled_frame_symbols() const { return at<21>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> profiled_frame_symbols() const { return GetRepeated<::protozero::ConstBytes>(21); }
   bool has_mappings() const { return at<19>().valid(); }
   ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> mappings() const { return GetRepeated<::protozero::ConstBytes>(19); }
   bool has_frames() const { return at<6>().valid(); }
@@ -15722,6 +19044,40 @@ class InternedData_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_I
   ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> kernel_symbols() const { return GetRepeated<::protozero::ConstBytes>(26); }
   bool has_debug_annotation_string_values() const { return at<29>().valid(); }
   ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> debug_annotation_string_values() const { return GetRepeated<::protozero::ConstBytes>(29); }
+  bool has_packet_context() const { return at<30>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> packet_context() const { return GetRepeated<::protozero::ConstBytes>(30); }
+  bool has_v8_js_function_name() const { return at<31>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> v8_js_function_name() const { return GetRepeated<::protozero::ConstBytes>(31); }
+  bool has_v8_js_function() const { return at<32>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> v8_js_function() const { return GetRepeated<::protozero::ConstBytes>(32); }
+  bool has_v8_js_script() const { return at<33>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> v8_js_script() const { return GetRepeated<::protozero::ConstBytes>(33); }
+  bool has_v8_wasm_script() const { return at<34>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> v8_wasm_script() const { return GetRepeated<::protozero::ConstBytes>(34); }
+  bool has_v8_isolate() const { return at<35>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> v8_isolate() const { return GetRepeated<::protozero::ConstBytes>(35); }
+  bool has_protolog_string_args() const { return at<36>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> protolog_string_args() const { return GetRepeated<::protozero::ConstBytes>(36); }
+  bool has_protolog_stacktrace() const { return at<37>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> protolog_stacktrace() const { return GetRepeated<::protozero::ConstBytes>(37); }
+  bool has_viewcapture_package_name() const { return at<38>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> viewcapture_package_name() const { return GetRepeated<::protozero::ConstBytes>(38); }
+  bool has_viewcapture_window_name() const { return at<39>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> viewcapture_window_name() const { return GetRepeated<::protozero::ConstBytes>(39); }
+  bool has_viewcapture_view_id() const { return at<40>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> viewcapture_view_id() const { return GetRepeated<::protozero::ConstBytes>(40); }
+  bool has_viewcapture_class_name() const { return at<41>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> viewcapture_class_name() const { return GetRepeated<::protozero::ConstBytes>(41); }
+  bool has_viewcapture_content_description() const { return at<45>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> viewcapture_content_description() const { return GetRepeated<::protozero::ConstBytes>(45); }
+  bool has_viewcapture_text() const { return at<46>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> viewcapture_text() const { return GetRepeated<::protozero::ConstBytes>(46); }
+  bool has_app_wakelock_info() const { return at<42>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> app_wakelock_info() const { return GetRepeated<::protozero::ConstBytes>(42); }
+  bool has_correlation_id_str() const { return at<43>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> correlation_id_str() const { return GetRepeated<::protozero::ConstBytes>(43); }
+  bool has_android_job_name() const { return at<44>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> android_job_name() const { return GetRepeated<::protozero::ConstBytes>(44); }
 };
 
 class InternedData : public ::protozero::Message {
@@ -15740,7 +19096,6 @@ class InternedData : public ::protozero::Message {
     kMappingPathsFieldNumber = 17,
     kSourcePathsFieldNumber = 18,
     kFunctionNamesFieldNumber = 5,
-    kProfiledFrameSymbolsFieldNumber = 21,
     kMappingsFieldNumber = 19,
     kFramesFieldNumber = 6,
     kCallstacksFieldNumber = 7,
@@ -15749,6 +19104,23 @@ class InternedData : public ::protozero::Message {
     kGpuSpecificationsFieldNumber = 24,
     kKernelSymbolsFieldNumber = 26,
     kDebugAnnotationStringValuesFieldNumber = 29,
+    kPacketContextFieldNumber = 30,
+    kV8JsFunctionNameFieldNumber = 31,
+    kV8JsFunctionFieldNumber = 32,
+    kV8JsScriptFieldNumber = 33,
+    kV8WasmScriptFieldNumber = 34,
+    kV8IsolateFieldNumber = 35,
+    kProtologStringArgsFieldNumber = 36,
+    kProtologStacktraceFieldNumber = 37,
+    kViewcapturePackageNameFieldNumber = 38,
+    kViewcaptureWindowNameFieldNumber = 39,
+    kViewcaptureViewIdFieldNumber = 40,
+    kViewcaptureClassNameFieldNumber = 41,
+    kViewcaptureContentDescriptionFieldNumber = 45,
+    kViewcaptureTextFieldNumber = 46,
+    kAppWakelockInfoFieldNumber = 42,
+    kCorrelationIdStrFieldNumber = 43,
+    kAndroidJobNameFieldNumber = 44,
   };
   static constexpr const char* GetName() { return ".perfetto.protos.InternedData"; }
 
@@ -15761,14 +19133,7 @@ class InternedData : public ::protozero::Message {
       EventCategory,
       InternedData>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EventCategories kEventCategories() { return {}; }
+  static constexpr FieldMetadata_EventCategories kEventCategories{};
   template <typename T = EventCategory> T* add_event_categories() {
     return BeginNestedMessage<T>(1);
   }
@@ -15782,14 +19147,7 @@ class InternedData : public ::protozero::Message {
       EventName,
       InternedData>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EventNames kEventNames() { return {}; }
+  static constexpr FieldMetadata_EventNames kEventNames{};
   template <typename T = EventName> T* add_event_names() {
     return BeginNestedMessage<T>(2);
   }
@@ -15803,14 +19161,7 @@ class InternedData : public ::protozero::Message {
       DebugAnnotationName,
       InternedData>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DebugAnnotationNames kDebugAnnotationNames() { return {}; }
+  static constexpr FieldMetadata_DebugAnnotationNames kDebugAnnotationNames{};
   template <typename T = DebugAnnotationName> T* add_debug_annotation_names() {
     return BeginNestedMessage<T>(3);
   }
@@ -15824,14 +19175,7 @@ class InternedData : public ::protozero::Message {
       DebugAnnotationValueTypeName,
       InternedData>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DebugAnnotationValueTypeNames kDebugAnnotationValueTypeNames() { return {}; }
+  static constexpr FieldMetadata_DebugAnnotationValueTypeNames kDebugAnnotationValueTypeNames{};
   template <typename T = DebugAnnotationValueTypeName> T* add_debug_annotation_value_type_names() {
     return BeginNestedMessage<T>(27);
   }
@@ -15845,14 +19189,7 @@ class InternedData : public ::protozero::Message {
       SourceLocation,
       InternedData>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SourceLocations kSourceLocations() { return {}; }
+  static constexpr FieldMetadata_SourceLocations kSourceLocations{};
   template <typename T = SourceLocation> T* add_source_locations() {
     return BeginNestedMessage<T>(4);
   }
@@ -15866,14 +19203,7 @@ class InternedData : public ::protozero::Message {
       UnsymbolizedSourceLocation,
       InternedData>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UnsymbolizedSourceLocations kUnsymbolizedSourceLocations() { return {}; }
+  static constexpr FieldMetadata_UnsymbolizedSourceLocations kUnsymbolizedSourceLocations{};
   template <typename T = UnsymbolizedSourceLocation> T* add_unsymbolized_source_locations() {
     return BeginNestedMessage<T>(28);
   }
@@ -15887,14 +19217,7 @@ class InternedData : public ::protozero::Message {
       LogMessageBody,
       InternedData>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LogMessageBody kLogMessageBody() { return {}; }
+  static constexpr FieldMetadata_LogMessageBody kLogMessageBody{};
   template <typename T = LogMessageBody> T* add_log_message_body() {
     return BeginNestedMessage<T>(20);
   }
@@ -15908,14 +19231,7 @@ class InternedData : public ::protozero::Message {
       HistogramName,
       InternedData>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HistogramNames kHistogramNames() { return {}; }
+  static constexpr FieldMetadata_HistogramNames kHistogramNames{};
   template <typename T = HistogramName> T* add_histogram_names() {
     return BeginNestedMessage<T>(25);
   }
@@ -15929,14 +19245,7 @@ class InternedData : public ::protozero::Message {
       InternedString,
       InternedData>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BuildIds kBuildIds() { return {}; }
+  static constexpr FieldMetadata_BuildIds kBuildIds{};
   template <typename T = InternedString> T* add_build_ids() {
     return BeginNestedMessage<T>(16);
   }
@@ -15950,14 +19259,7 @@ class InternedData : public ::protozero::Message {
       InternedString,
       InternedData>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MappingPaths kMappingPaths() { return {}; }
+  static constexpr FieldMetadata_MappingPaths kMappingPaths{};
   template <typename T = InternedString> T* add_mapping_paths() {
     return BeginNestedMessage<T>(17);
   }
@@ -15971,14 +19273,7 @@ class InternedData : public ::protozero::Message {
       InternedString,
       InternedData>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SourcePaths kSourcePaths() { return {}; }
+  static constexpr FieldMetadata_SourcePaths kSourcePaths{};
   template <typename T = InternedString> T* add_source_paths() {
     return BeginNestedMessage<T>(18);
   }
@@ -15992,40 +19287,12 @@ class InternedData : public ::protozero::Message {
       InternedString,
       InternedData>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FunctionNames kFunctionNames() { return {}; }
+  static constexpr FieldMetadata_FunctionNames kFunctionNames{};
   template <typename T = InternedString> T* add_function_names() {
     return BeginNestedMessage<T>(5);
   }
 
 
-  using FieldMetadata_ProfiledFrameSymbols =
-    ::protozero::proto_utils::FieldMetadata<
-      21,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ProfiledFrameSymbols,
-      InternedData>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProfiledFrameSymbols kProfiledFrameSymbols() { return {}; }
-  template <typename T = ProfiledFrameSymbols> T* add_profiled_frame_symbols() {
-    return BeginNestedMessage<T>(21);
-  }
-
-
   using FieldMetadata_Mappings =
     ::protozero::proto_utils::FieldMetadata<
       19,
@@ -16034,14 +19301,7 @@ class InternedData : public ::protozero::Message {
       Mapping,
       InternedData>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mappings kMappings() { return {}; }
+  static constexpr FieldMetadata_Mappings kMappings{};
   template <typename T = Mapping> T* add_mappings() {
     return BeginNestedMessage<T>(19);
   }
@@ -16055,14 +19315,7 @@ class InternedData : public ::protozero::Message {
       Frame,
       InternedData>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Frames kFrames() { return {}; }
+  static constexpr FieldMetadata_Frames kFrames{};
   template <typename T = Frame> T* add_frames() {
     return BeginNestedMessage<T>(6);
   }
@@ -16076,14 +19329,7 @@ class InternedData : public ::protozero::Message {
       Callstack,
       InternedData>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Callstacks kCallstacks() { return {}; }
+  static constexpr FieldMetadata_Callstacks kCallstacks{};
   template <typename T = Callstack> T* add_callstacks() {
     return BeginNestedMessage<T>(7);
   }
@@ -16097,14 +19343,7 @@ class InternedData : public ::protozero::Message {
       InternedString,
       InternedData>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VulkanMemoryKeys kVulkanMemoryKeys() { return {}; }
+  static constexpr FieldMetadata_VulkanMemoryKeys kVulkanMemoryKeys{};
   template <typename T = InternedString> T* add_vulkan_memory_keys() {
     return BeginNestedMessage<T>(22);
   }
@@ -16118,14 +19357,7 @@ class InternedData : public ::protozero::Message {
       InternedGraphicsContext,
       InternedData>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GraphicsContexts kGraphicsContexts() { return {}; }
+  static constexpr FieldMetadata_GraphicsContexts kGraphicsContexts{};
   template <typename T = InternedGraphicsContext> T* add_graphics_contexts() {
     return BeginNestedMessage<T>(23);
   }
@@ -16139,14 +19371,7 @@ class InternedData : public ::protozero::Message {
       InternedGpuRenderStageSpecification,
       InternedData>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GpuSpecifications kGpuSpecifications() { return {}; }
+  static constexpr FieldMetadata_GpuSpecifications kGpuSpecifications{};
   template <typename T = InternedGpuRenderStageSpecification> T* add_gpu_specifications() {
     return BeginNestedMessage<T>(24);
   }
@@ -16160,14 +19385,7 @@ class InternedData : public ::protozero::Message {
       InternedString,
       InternedData>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KernelSymbols kKernelSymbols() { return {}; }
+  static constexpr FieldMetadata_KernelSymbols kKernelSymbols{};
   template <typename T = InternedString> T* add_kernel_symbols() {
     return BeginNestedMessage<T>(26);
   }
@@ -16181,18 +19399,249 @@ class InternedData : public ::protozero::Message {
       InternedString,
       InternedData>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DebugAnnotationStringValues kDebugAnnotationStringValues() { return {}; }
+  static constexpr FieldMetadata_DebugAnnotationStringValues kDebugAnnotationStringValues{};
   template <typename T = InternedString> T* add_debug_annotation_string_values() {
     return BeginNestedMessage<T>(29);
   }
 
+
+  using FieldMetadata_PacketContext =
+    ::protozero::proto_utils::FieldMetadata<
+      30,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      NetworkPacketContext,
+      InternedData>;
+
+  static constexpr FieldMetadata_PacketContext kPacketContext{};
+  template <typename T = NetworkPacketContext> T* add_packet_context() {
+    return BeginNestedMessage<T>(30);
+  }
+
+
+  using FieldMetadata_V8JsFunctionName =
+    ::protozero::proto_utils::FieldMetadata<
+      31,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      InternedV8String,
+      InternedData>;
+
+  static constexpr FieldMetadata_V8JsFunctionName kV8JsFunctionName{};
+  template <typename T = InternedV8String> T* add_v8_js_function_name() {
+    return BeginNestedMessage<T>(31);
+  }
+
+
+  using FieldMetadata_V8JsFunction =
+    ::protozero::proto_utils::FieldMetadata<
+      32,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      InternedV8JsFunction,
+      InternedData>;
+
+  static constexpr FieldMetadata_V8JsFunction kV8JsFunction{};
+  template <typename T = InternedV8JsFunction> T* add_v8_js_function() {
+    return BeginNestedMessage<T>(32);
+  }
+
+
+  using FieldMetadata_V8JsScript =
+    ::protozero::proto_utils::FieldMetadata<
+      33,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      InternedV8JsScript,
+      InternedData>;
+
+  static constexpr FieldMetadata_V8JsScript kV8JsScript{};
+  template <typename T = InternedV8JsScript> T* add_v8_js_script() {
+    return BeginNestedMessage<T>(33);
+  }
+
+
+  using FieldMetadata_V8WasmScript =
+    ::protozero::proto_utils::FieldMetadata<
+      34,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      InternedV8WasmScript,
+      InternedData>;
+
+  static constexpr FieldMetadata_V8WasmScript kV8WasmScript{};
+  template <typename T = InternedV8WasmScript> T* add_v8_wasm_script() {
+    return BeginNestedMessage<T>(34);
+  }
+
+
+  using FieldMetadata_V8Isolate =
+    ::protozero::proto_utils::FieldMetadata<
+      35,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      InternedV8Isolate,
+      InternedData>;
+
+  static constexpr FieldMetadata_V8Isolate kV8Isolate{};
+  template <typename T = InternedV8Isolate> T* add_v8_isolate() {
+    return BeginNestedMessage<T>(35);
+  }
+
+
+  using FieldMetadata_ProtologStringArgs =
+    ::protozero::proto_utils::FieldMetadata<
+      36,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      InternedString,
+      InternedData>;
+
+  static constexpr FieldMetadata_ProtologStringArgs kProtologStringArgs{};
+  template <typename T = InternedString> T* add_protolog_string_args() {
+    return BeginNestedMessage<T>(36);
+  }
+
+
+  using FieldMetadata_ProtologStacktrace =
+    ::protozero::proto_utils::FieldMetadata<
+      37,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      InternedString,
+      InternedData>;
+
+  static constexpr FieldMetadata_ProtologStacktrace kProtologStacktrace{};
+  template <typename T = InternedString> T* add_protolog_stacktrace() {
+    return BeginNestedMessage<T>(37);
+  }
+
+
+  using FieldMetadata_ViewcapturePackageName =
+    ::protozero::proto_utils::FieldMetadata<
+      38,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      InternedString,
+      InternedData>;
+
+  static constexpr FieldMetadata_ViewcapturePackageName kViewcapturePackageName{};
+  template <typename T = InternedString> T* add_viewcapture_package_name() {
+    return BeginNestedMessage<T>(38);
+  }
+
+
+  using FieldMetadata_ViewcaptureWindowName =
+    ::protozero::proto_utils::FieldMetadata<
+      39,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      InternedString,
+      InternedData>;
+
+  static constexpr FieldMetadata_ViewcaptureWindowName kViewcaptureWindowName{};
+  template <typename T = InternedString> T* add_viewcapture_window_name() {
+    return BeginNestedMessage<T>(39);
+  }
+
+
+  using FieldMetadata_ViewcaptureViewId =
+    ::protozero::proto_utils::FieldMetadata<
+      40,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      InternedString,
+      InternedData>;
+
+  static constexpr FieldMetadata_ViewcaptureViewId kViewcaptureViewId{};
+  template <typename T = InternedString> T* add_viewcapture_view_id() {
+    return BeginNestedMessage<T>(40);
+  }
+
+
+  using FieldMetadata_ViewcaptureClassName =
+    ::protozero::proto_utils::FieldMetadata<
+      41,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      InternedString,
+      InternedData>;
+
+  static constexpr FieldMetadata_ViewcaptureClassName kViewcaptureClassName{};
+  template <typename T = InternedString> T* add_viewcapture_class_name() {
+    return BeginNestedMessage<T>(41);
+  }
+
+
+  using FieldMetadata_ViewcaptureContentDescription =
+    ::protozero::proto_utils::FieldMetadata<
+      45,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      InternedString,
+      InternedData>;
+
+  static constexpr FieldMetadata_ViewcaptureContentDescription kViewcaptureContentDescription{};
+  template <typename T = InternedString> T* add_viewcapture_content_description() {
+    return BeginNestedMessage<T>(45);
+  }
+
+
+  using FieldMetadata_ViewcaptureText =
+    ::protozero::proto_utils::FieldMetadata<
+      46,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      InternedString,
+      InternedData>;
+
+  static constexpr FieldMetadata_ViewcaptureText kViewcaptureText{};
+  template <typename T = InternedString> T* add_viewcapture_text() {
+    return BeginNestedMessage<T>(46);
+  }
+
+
+  using FieldMetadata_AppWakelockInfo =
+    ::protozero::proto_utils::FieldMetadata<
+      42,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AppWakelockInfo,
+      InternedData>;
+
+  static constexpr FieldMetadata_AppWakelockInfo kAppWakelockInfo{};
+  template <typename T = AppWakelockInfo> T* add_app_wakelock_info() {
+    return BeginNestedMessage<T>(42);
+  }
+
+
+  using FieldMetadata_CorrelationIdStr =
+    ::protozero::proto_utils::FieldMetadata<
+      43,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      InternedString,
+      InternedData>;
+
+  static constexpr FieldMetadata_CorrelationIdStr kCorrelationIdStr{};
+  template <typename T = InternedString> T* add_correlation_id_str() {
+    return BeginNestedMessage<T>(43);
+  }
+
+
+  using FieldMetadata_AndroidJobName =
+    ::protozero::proto_utils::FieldMetadata<
+      44,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AndroidJobName,
+      InternedData>;
+
+  static constexpr FieldMetadata_AndroidJobName kAndroidJobName{};
+  template <typename T = AndroidJobName> T* add_android_job_name() {
+    return BeginNestedMessage<T>(44);
+  }
+
 };
 
 } // Namespace.
@@ -16218,11 +19667,16 @@ class InternedData : public ::protozero::Message {
 #ifndef INCLUDE_PERFETTO_TRACING_INTERNAL_TRACK_EVENT_INTERNAL_H_
 #define INCLUDE_PERFETTO_TRACING_INTERNAL_TRACK_EVENT_INTERNAL_H_
 
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 // gen_amalgamated expanded: #include "perfetto/base/flat_set.h"
+// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message_handle.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+// gen_amalgamated expanded: #include "perfetto/public/compiler.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/data_source.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/debug_annotation.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/string_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/trace_writer_base.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/traced_value.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/track.h"
@@ -16230,7 +19684,18 @@ class InternedData : public ::protozero::Message {
 // gen_amalgamated expanded: #include "protos/perfetto/trace/interned_data/interned_data.pbzero.h"
 // gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_event.pbzero.h"
 
+#include <array>
+#include <atomic>
+#include <cstddef>
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string>
 #include <unordered_map>
+#include <utility>
+#include <vector>
 
 namespace perfetto {
 
@@ -16284,6 +19749,18 @@ class PERFETTO_EXPORT_COMPONENT TrackEventSessionObserver {
       const DataSourceBase::ClearIncrementalStateArgs&);
 };
 
+// A class that the embedder can store arbitrary data user data per thread.
+class PERFETTO_EXPORT_COMPONENT TrackEventTlsStateUserData {
+ public:
+  TrackEventTlsStateUserData() = default;
+  // Not clonable.
+  TrackEventTlsStateUserData(const TrackEventTlsStateUserData&) = delete;
+  TrackEventTlsStateUserData& operator=(const TrackEventTlsStateUserData&) =
+      delete;
+
+  virtual ~TrackEventTlsStateUserData();
+};
+
 namespace internal {
 class TrackEventCategoryRegistry;
 
@@ -16301,10 +19778,12 @@ struct TrackEventTlsState {
   template <typename TraceContext>
   explicit TrackEventTlsState(const TraceContext& trace_context);
   bool enable_thread_time_sampling = false;
+  uint64_t thread_time_subsampling_ns = 0;
   bool filter_debug_annotations = false;
   bool filter_dynamic_event_names = false;
   uint64_t timestamp_unit_multiplier = 1;
   uint32_t default_clock;
+  std::map<const void*, std::unique_ptr<TrackEventTlsStateUserData>> user_data;
 };
 
 struct TrackEventIncrementalState {
@@ -16363,6 +19842,22 @@ struct TrackEventIncrementalState {
   // The value is used for delta encoding of counter values.
   std::unordered_map<uint64_t, int64_t> last_counter_value_per_track;
   int64_t last_thread_time_ns = 0;
+  uint64_t last_thread_time_timestamp_ns = 0;
+
+  // Clears the incremental state without destroying and recreating this object.
+  // This allows reusing allocated memory in hash maps and other data structures
+  // instead of deallocating and reallocating them.
+  void Clear() {
+    was_cleared = true;
+    serialized_interned_data.Reset();
+    interned_data_indices = {};
+    seen_tracks.clear();
+    dynamic_categories.clear();
+    last_timestamp_ns = 0;
+    last_counter_value_per_track.clear();
+    last_thread_time_ns = 0;
+    last_thread_time_timestamp_ns = 0;
+  }
 };
 
 // The backend portion of the track event trace point implemention. Outlined to
@@ -16370,8 +19865,18 @@ struct TrackEventIncrementalState {
 // namespaces.
 class PERFETTO_EXPORT_COMPONENT TrackEventInternal {
  public:
+  static TrackEventInternal& GetInstance();
+
+  std::vector<const TrackEventCategoryRegistry*> AddRegistry(
+      const TrackEventCategoryRegistry*);
+  void EnableTracing(const protos::gen::TrackEventConfig& config,
+                     const DataSourceBase::SetupArgs&);
+  void DisableTracing(uint32_t internal_instance_index);
+
+  void ResetRegistriesForTesting();
+
   static bool Initialize(
-      const TrackEventCategoryRegistry&,
+      const std::vector<const TrackEventCategoryRegistry*> registries,
       bool (*register_data_source)(const DataSourceDescriptor&));
 
   static bool AddSessionObserver(const TrackEventCategoryRegistry&,
@@ -16379,17 +19884,12 @@ class PERFETTO_EXPORT_COMPONENT TrackEventInternal {
   static void RemoveSessionObserver(const TrackEventCategoryRegistry&,
                                     TrackEventSessionObserver*);
 
-  static void EnableTracing(const TrackEventCategoryRegistry& registry,
-                            const protos::gen::TrackEventConfig& config,
-                            const DataSourceBase::SetupArgs&);
-  static void OnStart(const TrackEventCategoryRegistry&,
-                      const DataSourceBase::StartArgs&);
-  static void OnStop(const TrackEventCategoryRegistry&,
-                     const DataSourceBase::StopArgs&);
-  static void DisableTracing(const TrackEventCategoryRegistry& registry,
+  static void EnableRegistry(const TrackEventCategoryRegistry* registry,
+                             const protos::gen::TrackEventConfig& config,
                              uint32_t internal_instance_index);
+  static void OnStart(const DataSourceBase::StartArgs&);
+  static void OnStop(const DataSourceBase::StopArgs&);
   static void WillClearIncrementalState(
-      const TrackEventCategoryRegistry&,
       const DataSourceBase::ClearIncrementalStateArgs&);
 
   static bool IsCategoryEnabled(const TrackEventCategoryRegistry& registry,
@@ -16407,7 +19907,7 @@ class PERFETTO_EXPORT_COMPONENT TrackEventInternal {
   static perfetto::EventContext WriteEvent(
       TraceWriterBase*,
       TrackEventIncrementalState*,
-      const TrackEventTlsState& tls_state,
+      TrackEventTlsState& tls_state,
       const Category* category,
       perfetto::protos::pbzero::TrackEvent::Type,
       const TraceTimestamp& timestamp,
@@ -16447,22 +19947,42 @@ class PERFETTO_EXPORT_COMPONENT TrackEventInternal {
       TrackEventIncrementalState* incr_state,
       const TrackEventTlsState& tls_state,
       const TraceTimestamp& timestamp) {
-    auto it_and_inserted = incr_state->seen_tracks.insert(track.uuid);
-    if (PERFETTO_LIKELY(!it_and_inserted.second))
-      return;
-    WriteTrackDescriptor(track, trace_writer, incr_state, tls_state, timestamp);
+    uint64_t uuid = track.uuid;
+    if (uuid) {
+      auto it_and_inserted = incr_state->seen_tracks.insert(uuid);
+      if (PERFETTO_LIKELY(!it_and_inserted.second))
+        return;
+      uuid = WriteTrackDescriptor(track, trace_writer, incr_state, tls_state,
+                                  timestamp);
+    }
+    while (uuid) {
+      auto it_and_inserted = incr_state->seen_tracks.insert(uuid);
+      if (PERFETTO_LIKELY(!it_and_inserted.second))
+        return;
+      std::optional<TrackRegistry::TrackInfo> track_info =
+          TrackRegistry::Get()->FindTrackInfo(uuid);
+      if (!track_info) {
+        return;
+      }
+      TrackRegistry::WriteTrackDescriptor(
+          std::move(track_info->desc),
+          NewTracePacket(trace_writer, incr_state, tls_state, timestamp));
+      uuid = track_info->parent_uuid;
+    }
   }
 
   // Unconditionally write a track descriptor into the trace.
+  //
+  // Returns the parent track uuid.
   template <typename TrackType>
-  static void WriteTrackDescriptor(const TrackType& track,
-                                   TraceWriterBase* trace_writer,
-                                   TrackEventIncrementalState* incr_state,
-                                   const TrackEventTlsState& tls_state,
-                                   const TraceTimestamp& timestamp) {
+  static uint64_t WriteTrackDescriptor(const TrackType& track,
+                                       TraceWriterBase* trace_writer,
+                                       TrackEventIncrementalState* incr_state,
+                                       const TrackEventTlsState& tls_state,
+                                       const TraceTimestamp& timestamp) {
     ResetIncrementalStateIfRequired(trace_writer, incr_state, tls_state,
                                     timestamp);
-    TrackRegistry::Get()->SerializeTrack(
+    return TrackRegistry::Get()->SerializeTrack(
         track, NewTracePacket(trace_writer, incr_state, tls_state, timestamp));
   }
 
@@ -16476,12 +19996,22 @@ class PERFETTO_EXPORT_COMPONENT TrackEventInternal {
     clock_ = clock;
   }
 
+  static inline bool GetDisallowMergingWithSystemTracks() {
+    return disallow_merging_with_system_tracks_;
+  }
+  static inline void SetDisallowMergingWithSystemTracks(
+      bool disallow_merging_with_system_tracks) {
+    disallow_merging_with_system_tracks_ = disallow_merging_with_system_tracks;
+  }
+
   static int GetSessionCount();
 
   // Represents the default track for the calling thread.
   static const Track kDefaultTrack;
 
  private:
+  std::vector<const TrackEventCategoryRegistry*> GetRegistries();
+
   static void ResetIncrementalState(TraceWriterBase* trace_writer,
                                     TrackEventIncrementalState* incr_state,
                                     const TrackEventTlsState& tls_state,
@@ -16506,6 +20036,10 @@ class PERFETTO_EXPORT_COMPONENT TrackEventInternal {
   static std::atomic<int> session_count_;
 
   static protos::pbzero::BuiltinClock clock_;
+  static bool disallow_merging_with_system_tracks_;
+
+  std::mutex mu_;
+  std::vector<const TrackEventCategoryRegistry*> registries_;
 };
 
 template <typename TraceContext>
@@ -16518,6 +20052,7 @@ TrackEventTlsState::TrackEventTlsState(const TraceContext& trace_context) {
     filter_debug_annotations = config.filter_debug_annotations();
     filter_dynamic_event_names = config.filter_dynamic_event_names();
     enable_thread_time_sampling = config.enable_thread_time_sampling();
+    thread_time_subsampling_ns = config.thread_time_subsampling_ns();
     if (config.has_timestamp_unit_multiplier()) {
       timestamp_unit_multiplier = config.timestamp_unit_multiplier();
     }
@@ -16642,7 +20177,7 @@ class TracedProto {
   // repeated and non-repeated complex fields are supported.
   template <typename FieldMetadata>
   TracedProto<typename FieldMetadata::cpp_field_type> WriteNestedMessage(
-      protozero::proto_utils::internal::FieldMetadataHelper<FieldMetadata>) {
+      FieldMetadata) {
     static_assert(std::is_base_of<MessageType,
                                   typename FieldMetadata::message_type>::value,
                   "Field should belong to the current message");
@@ -16661,8 +20196,7 @@ class TracedProto {
   // string), but requires the |field| to be non-repeateable (i.e. optional).
   // For repeatable fields, AppendValue or AppendFrom should be used.
   template <typename FieldMetadata, typename ValueType>
-  void Set(protozero::proto_utils::internal::FieldMetadataHelper<FieldMetadata>,
-           ValueType&& value) {
+  void Set(FieldMetadata, ValueType&& value) {
     static_assert(std::is_base_of<MessageType,
                                   typename FieldMetadata::message_type>::value,
                   "Field should belong to the current message");
@@ -16688,9 +20222,7 @@ class TracedProto {
   // current message. If the field is not repeated, Set() should be used
   // instead.
   template <typename FieldMetadata, typename ValueType>
-  void AppendValue(
-      protozero::proto_utils::internal::FieldMetadataHelper<FieldMetadata>,
-      ValueType&& value) {
+  void AppendValue(FieldMetadata, ValueType&& value) {
     static_assert(std::is_base_of<MessageType,
                                   typename FieldMetadata::message_type>::value,
                   "Field should belong to the current message");
@@ -16714,9 +20246,7 @@ class TracedProto {
   // current message. If the field is not repeated, Set() should be used
   // instead.
   template <typename FieldMetadata, typename ValueType>
-  void AppendFrom(
-      protozero::proto_utils::internal::FieldMetadataHelper<FieldMetadata>,
-      ValueType&& value) {
+  void AppendFrom(FieldMetadata, ValueType&& value) {
     static_assert(std::is_base_of<MessageType,
                                   typename FieldMetadata::message_type>::value,
                   "Field should belong to the current message");
@@ -16739,8 +20269,7 @@ class TracedProto {
   // above and make these methods private.
   template <typename FieldMetadata>
   TracedProto<typename FieldMetadata::cpp_field_type> WriteNestedMessage() {
-    return WriteNestedMessage(
-        protozero::proto_utils::internal::FieldMetadataHelper<FieldMetadata>());
+    return WriteNestedMessage(FieldMetadata());
   }
 
  private:
@@ -16853,9 +20382,9 @@ WriteIntoTracedProtoImpl(base::priority_tag<1>,
 
 // If T has WriteIntoTrace(TracedProto<MessageType>) method, use it.
 template <typename MessageType, typename T>
-decltype(
-    std::declval<T>().WriteIntoTrace(std::declval<TracedProto<MessageType>>()),
-    void())
+decltype(std::declval<T>().WriteIntoTrace(
+             std::declval<TracedProto<MessageType>>()),
+         void())
 WriteIntoTracedProtoImpl(base::priority_tag<0>,
                          TracedProto<MessageType> message,
                          T&& value) {
@@ -16941,10 +20470,9 @@ void WriteIntoTracedProto(TracedProto<MessageType> message, ValueType&& value) {
 }
 
 template <typename MessageType, typename FieldMetadataType, typename ValueType>
-void WriteTracedProtoField(
-    TracedProto<MessageType>& message,
-    protozero::proto_utils::internal::FieldMetadataHelper<FieldMetadataType>,
-    ValueType&& value) {
+void WriteTracedProtoField(TracedProto<MessageType>& message,
+                           FieldMetadataType,
+                           ValueType&& value) {
   static_assert(
       std::is_base_of<protozero::proto_utils::FieldMetadataBase,
                       FieldMetadataType>::value,
@@ -17010,15 +20538,11 @@ class PERFETTO_EXPORT_COMPONENT EventContext {
  public:
   EventContext(EventContext&&) = default;
 
-  // For Chromium during the transition phase to the client library.
-  // TODO(eseckler): Remove once Chromium has switched to client lib entirely.
   explicit EventContext(
       protos::pbzero::TrackEvent* event,
       internal::TrackEventIncrementalState* incremental_state = nullptr,
-      bool filter_debug_annotations = false)
-      : event_(event),
-        incremental_state_(incremental_state),
-        filter_debug_annotations_(filter_debug_annotations) {}
+      bool /*filter_debug_annotations*/ = false)
+      : event_(event), incremental_state_(incremental_state) {}
 
   ~EventContext();
 
@@ -17034,12 +20558,17 @@ class PERFETTO_EXPORT_COMPONENT EventContext {
   // TODO(kraskevich): Come up with a more precise name once we have more than
   // one usecase.
   bool ShouldFilterDebugAnnotations() const {
-    if (tls_state_) {
-      return tls_state_->filter_debug_annotations;
-    }
-    // In Chromium tls_state_ is nullptr, so we need to get this information
-    // from a separate field.
-    return filter_debug_annotations_;
+    if (!tls_state_)
+      return false;
+    return tls_state_->filter_debug_annotations;
+  }
+
+  // Disclaimer: Experimental method, subject to change. Exposed publicly to
+  // emit some DynamicFilter fields in Chromium only in local tracing.
+  bool ShouldFilterDynamicEventNames() const {
+    if (!tls_state_)
+      return false;
+    return tls_state_->filter_dynamic_event_names;
   }
 
   // Get a TrackEvent message to write typed arguments to.
@@ -17082,17 +20611,29 @@ class PERFETTO_EXPORT_COMPONENT EventContext {
                          std::forward<T>(value));
   }
 
+  // Read arbitrary user data that is associated with the thread-local per
+  // instance state of the track event. `key` must be non-null and unique
+  // per TrackEventTlsStateUserData subclass.
+  TrackEventTlsStateUserData* GetTlsUserData(const void* key);
+
+  // Set arbitrary user data that is associated with the thread-local per
+  // instance state of the track event. `key` must be non-null and unique
+  // per TrackEventTlsStateUserData subclass.
+  void SetTlsUserData(const void* key,
+                      std::unique_ptr<TrackEventTlsStateUserData> data);
+
  private:
   template <typename, size_t, typename, typename>
   friend class TrackEventInternedDataIndex;
   friend class internal::TrackEventInternal;
+  friend class TracedProtoTest;
 
   using TracePacketHandle =
       ::protozero::MessageHandle<protos::pbzero::TracePacket>;
 
   EventContext(TracePacketHandle,
                internal::TrackEventIncrementalState*,
-               const internal::TrackEventTlsState*);
+               internal::TrackEventTlsState*);
   EventContext(const EventContext&) = delete;
 
   protos::pbzero::DebugAnnotation* AddDebugAnnotation(const char* name);
@@ -17102,19 +20643,475 @@ class PERFETTO_EXPORT_COMPONENT EventContext {
   TracePacketHandle trace_packet_;
   protos::pbzero::TrackEvent* event_;
   internal::TrackEventIncrementalState* incremental_state_;
-  // TODO(mohitms): Make it const-reference instead of pointer, once we
-  // are certain that it cannot be nullptr. Once we switch to client library in
-  // chrome, we can make that happen.
-  const internal::TrackEventTlsState* tls_state_ = nullptr;
-  // TODO(kraskevich): Come up with a more precise name once we have more than
-  // one usecase.
-  // TODO(kraskevich): Remove once Chromium has fully switched to client lib.
-  const bool filter_debug_annotations_ = false;
+  internal::TrackEventTlsState* tls_state_ = nullptr;
 };
 
 }  // namespace perfetto
 
 #endif  // INCLUDE_PERFETTO_TRACING_EVENT_CONTEXT_H_
+// gen_amalgamated begin header: include/perfetto/tracing/internal/track_event_legacy.h
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_TRACING_INTERNAL_TRACK_EVENT_LEGACY_H_
+#define INCLUDE_PERFETTO_TRACING_INTERNAL_TRACK_EVENT_LEGACY_H_
+
+// gen_amalgamated expanded: #include "perfetto/base/build_config.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/event_context.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/track.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_event.pbzero.h"
+
+#ifndef PERFETTO_ENABLE_LEGACY_TRACE_EVENTS
+#define PERFETTO_ENABLE_LEGACY_TRACE_EVENTS 0
+#endif
+
+// ----------------------------------------------------------------------------
+// Constants.
+// ----------------------------------------------------------------------------
+
+namespace perfetto {
+namespace legacy {
+
+enum TraceEventFlag {
+  kTraceEventFlagNone = 0,
+  kTraceEventFlagCopy = 1u << 0,
+  kTraceEventFlagHasId = 1u << 1,
+  kTraceEventFlagScopeOffset = 1u << 2,
+  kTraceEventFlagScopeExtra = 1u << 3,
+  kTraceEventFlagExplicitTimestamp = 1u << 4,
+  kTraceEventFlagAsyncTTS = 1u << 5,
+  kTraceEventFlagBindToEnclosing = 1u << 6,
+  kTraceEventFlagFlowIn = 1u << 7,
+  kTraceEventFlagFlowOut = 1u << 8,
+  kTraceEventFlagHasContextId = 1u << 9,
+  kTraceEventFlagHasProcessId = 1u << 10,
+  kTraceEventFlagHasLocalId = 1u << 11,
+  kTraceEventFlagHasGlobalId = 1u << 12,
+  // TODO(eseckler): Remove once we have native support for typed proto events
+  // in TRACE_EVENT macros.
+  kTraceEventFlagTypedProtoArgs = 1u << 15,
+  kTraceEventFlagJavaStringLiterals = 1u << 16,
+};
+
+enum PerfettoLegacyCurrentThreadId { kCurrentThreadId };
+
+// The following user-provided adaptors are used to serialize user-defined
+// thread id and time types into track events. For full compatibility, the user
+// should also define the following macros appropriately:
+//
+//   #define TRACE_TIME_TICKS_NOW() ...
+//   #define TRACE_TIME_NOW() ...
+
+// User-provided function to convert an abstract thread id into a thread track.
+template <typename T>
+ThreadTrack ConvertThreadId(const T&);
+
+// Built-in implementation for events referring to the current thread.
+template <>
+ThreadTrack PERFETTO_EXPORT_COMPONENT
+ConvertThreadId(const PerfettoLegacyCurrentThreadId&);
+
+}  // namespace legacy
+}  // namespace perfetto
+
+#if PERFETTO_ENABLE_LEGACY_TRACE_EVENTS
+// The following constants are defined in the global namespace, since they were
+// originally implemented as macros.
+// TODO(joenotcharles):  According to
+// https://chromium.googlesource.com/chromium/src/+/HEAD/styleguide/c++/defining_compile_time_const.md
+// (which isn't binding on perfetto but has good advice) these should be
+// `inline constexpr`.
+
+// Event phases.
+static constexpr char TRACE_EVENT_PHASE_BEGIN = 'B';
+static constexpr char TRACE_EVENT_PHASE_END = 'E';
+static constexpr char TRACE_EVENT_PHASE_COMPLETE = 'X';
+static constexpr char TRACE_EVENT_PHASE_INSTANT = 'I';
+static constexpr char TRACE_EVENT_PHASE_ASYNC_BEGIN = 'S';
+static constexpr char TRACE_EVENT_PHASE_ASYNC_STEP_INTO = 'T';
+static constexpr char TRACE_EVENT_PHASE_ASYNC_STEP_PAST = 'p';
+static constexpr char TRACE_EVENT_PHASE_ASYNC_END = 'F';
+static constexpr char TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN = 'b';
+static constexpr char TRACE_EVENT_PHASE_NESTABLE_ASYNC_END = 'e';
+static constexpr char TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT = 'n';
+static constexpr char TRACE_EVENT_PHASE_FLOW_BEGIN = 's';
+static constexpr char TRACE_EVENT_PHASE_FLOW_STEP = 't';
+static constexpr char TRACE_EVENT_PHASE_FLOW_END = 'f';
+static constexpr char TRACE_EVENT_PHASE_METADATA = 'M';
+static constexpr char TRACE_EVENT_PHASE_COUNTER = 'C';
+static constexpr char TRACE_EVENT_PHASE_SAMPLE = 'P';
+static constexpr char TRACE_EVENT_PHASE_CREATE_OBJECT = 'N';
+static constexpr char TRACE_EVENT_PHASE_SNAPSHOT_OBJECT = 'O';
+static constexpr char TRACE_EVENT_PHASE_DELETE_OBJECT = 'D';
+static constexpr char TRACE_EVENT_PHASE_MEMORY_DUMP = 'v';
+static constexpr char TRACE_EVENT_PHASE_MARK = 'R';
+static constexpr char TRACE_EVENT_PHASE_CLOCK_SYNC = 'c';
+
+// Flags for changing the behavior of TRACE_EVENT_API_ADD_TRACE_EVENT.
+static constexpr uint32_t TRACE_EVENT_FLAG_NONE =
+    perfetto::legacy::kTraceEventFlagNone;
+static constexpr uint32_t TRACE_EVENT_FLAG_COPY =
+    perfetto::legacy::kTraceEventFlagCopy;
+static constexpr uint32_t TRACE_EVENT_FLAG_HAS_ID =
+    perfetto::legacy::kTraceEventFlagHasId;
+static constexpr uint32_t TRACE_EVENT_FLAG_SCOPE_OFFSET =
+    perfetto::legacy::kTraceEventFlagScopeOffset;
+static constexpr uint32_t TRACE_EVENT_FLAG_SCOPE_EXTRA =
+    perfetto::legacy::kTraceEventFlagScopeExtra;
+static constexpr uint32_t TRACE_EVENT_FLAG_EXPLICIT_TIMESTAMP =
+    perfetto::legacy::kTraceEventFlagExplicitTimestamp;
+static constexpr uint32_t TRACE_EVENT_FLAG_ASYNC_TTS =
+    perfetto::legacy::kTraceEventFlagAsyncTTS;
+static constexpr uint32_t TRACE_EVENT_FLAG_BIND_TO_ENCLOSING =
+    perfetto::legacy::kTraceEventFlagBindToEnclosing;
+static constexpr uint32_t TRACE_EVENT_FLAG_FLOW_IN =
+    perfetto::legacy::kTraceEventFlagFlowIn;
+static constexpr uint32_t TRACE_EVENT_FLAG_FLOW_OUT =
+    perfetto::legacy::kTraceEventFlagFlowOut;
+static constexpr uint32_t TRACE_EVENT_FLAG_HAS_CONTEXT_ID =
+    perfetto::legacy::kTraceEventFlagHasContextId;
+static constexpr uint32_t TRACE_EVENT_FLAG_HAS_PROCESS_ID =
+    perfetto::legacy::kTraceEventFlagHasProcessId;
+static constexpr uint32_t TRACE_EVENT_FLAG_HAS_LOCAL_ID =
+    perfetto::legacy::kTraceEventFlagHasLocalId;
+static constexpr uint32_t TRACE_EVENT_FLAG_HAS_GLOBAL_ID =
+    perfetto::legacy::kTraceEventFlagHasGlobalId;
+static constexpr uint32_t TRACE_EVENT_FLAG_TYPED_PROTO_ARGS =
+    perfetto::legacy::kTraceEventFlagTypedProtoArgs;
+static constexpr uint32_t TRACE_EVENT_FLAG_JAVA_STRING_LITERALS =
+    perfetto::legacy::kTraceEventFlagJavaStringLiterals;
+
+static constexpr uint32_t TRACE_EVENT_FLAG_SCOPE_MASK =
+    TRACE_EVENT_FLAG_SCOPE_OFFSET | TRACE_EVENT_FLAG_SCOPE_EXTRA;
+
+// Type values for identifying types in the TraceValue union.
+static constexpr uint8_t TRACE_VALUE_TYPE_BOOL = 1;
+static constexpr uint8_t TRACE_VALUE_TYPE_UINT = 2;
+static constexpr uint8_t TRACE_VALUE_TYPE_INT = 3;
+static constexpr uint8_t TRACE_VALUE_TYPE_DOUBLE = 4;
+static constexpr uint8_t TRACE_VALUE_TYPE_POINTER = 5;
+static constexpr uint8_t TRACE_VALUE_TYPE_STRING = 6;
+static constexpr uint8_t TRACE_VALUE_TYPE_COPY_STRING = 7;
+static constexpr uint8_t TRACE_VALUE_TYPE_CONVERTABLE = 8;
+static constexpr uint8_t TRACE_VALUE_TYPE_PROTO = 9;
+
+// Enum reflecting the scope of an INSTANT event. Must fit within
+// TRACE_EVENT_FLAG_SCOPE_MASK.
+static constexpr uint8_t TRACE_EVENT_SCOPE_GLOBAL = 0u << 2;
+static constexpr uint8_t TRACE_EVENT_SCOPE_PROCESS = 1u << 2;
+static constexpr uint8_t TRACE_EVENT_SCOPE_THREAD = 2u << 2;
+
+static constexpr char TRACE_EVENT_SCOPE_NAME_GLOBAL = 'g';
+static constexpr char TRACE_EVENT_SCOPE_NAME_PROCESS = 'p';
+static constexpr char TRACE_EVENT_SCOPE_NAME_THREAD = 't';
+
+#define TRACE_EVENT_API_CURRENT_THREAD_ID ::perfetto::legacy::kCurrentThreadId
+
+#endif  // PERFETTO_ENABLE_LEGACY_TRACE_EVENTS
+
+namespace perfetto {
+namespace internal {
+
+// LegacyTraceId encapsulates an ID that can either be an integer or pointer.
+class PERFETTO_EXPORT_COMPONENT LegacyTraceId {
+ public:
+  // Can be combined with WithScope.
+  class LocalId {
+   public:
+    explicit LocalId(const void* raw_id)
+        : raw_id_(static_cast<uint64_t>(reinterpret_cast<uintptr_t>(raw_id))) {}
+    explicit LocalId(uint64_t raw_id) : raw_id_(raw_id) {}
+    uint64_t raw_id() const { return raw_id_; }
+
+   private:
+    uint64_t raw_id_;
+  };
+
+  // Can be combined with WithScope.
+  class GlobalId {
+   public:
+    explicit GlobalId(uint64_t raw_id) : raw_id_(raw_id) {}
+    uint64_t raw_id() const { return raw_id_; }
+
+   private:
+    uint64_t raw_id_;
+  };
+
+  class WithScope {
+   public:
+    WithScope(const char* scope, uint64_t raw_id)
+        : scope_(scope), raw_id_(raw_id) {}
+    WithScope(const char* scope, LocalId local_id)
+        : scope_(scope), raw_id_(local_id.raw_id()) {
+      id_flags_ = legacy::kTraceEventFlagHasLocalId;
+    }
+    WithScope(const char* scope, GlobalId global_id)
+        : scope_(scope), raw_id_(global_id.raw_id()) {
+      id_flags_ = legacy::kTraceEventFlagHasGlobalId;
+    }
+    WithScope(const char* scope, uint64_t prefix, uint64_t raw_id)
+        : scope_(scope), has_prefix_(true), prefix_(prefix), raw_id_(raw_id) {}
+    WithScope(const char* scope, uint64_t prefix, GlobalId global_id)
+        : scope_(scope),
+          has_prefix_(true),
+          prefix_(prefix),
+          raw_id_(global_id.raw_id()) {
+      id_flags_ = legacy::kTraceEventFlagHasGlobalId;
+    }
+    uint64_t raw_id() const { return raw_id_; }
+    const char* scope() const { return scope_; }
+    bool has_prefix() const { return has_prefix_; }
+    uint64_t prefix() const { return prefix_; }
+    uint32_t id_flags() const { return id_flags_; }
+
+   private:
+    const char* scope_ = nullptr;
+    bool has_prefix_ = false;
+    uint64_t prefix_;
+    uint64_t raw_id_;
+    uint32_t id_flags_ = legacy::kTraceEventFlagHasId;
+  };
+
+  explicit LegacyTraceId(const void* raw_id)
+      : raw_id_(static_cast<uint64_t>(reinterpret_cast<uintptr_t>(raw_id))) {
+    id_flags_ = legacy::kTraceEventFlagHasLocalId;
+  }
+  explicit LegacyTraceId(uint64_t raw_id) : raw_id_(raw_id) {}
+  explicit LegacyTraceId(uint32_t raw_id) : raw_id_(raw_id) {}
+  explicit LegacyTraceId(uint16_t raw_id) : raw_id_(raw_id) {}
+  explicit LegacyTraceId(uint8_t raw_id) : raw_id_(raw_id) {}
+  explicit LegacyTraceId(int64_t raw_id)
+      : raw_id_(static_cast<uint64_t>(raw_id)) {}
+  explicit LegacyTraceId(int32_t raw_id)
+      : raw_id_(static_cast<uint64_t>(raw_id)) {}
+  explicit LegacyTraceId(int16_t raw_id)
+      : raw_id_(static_cast<uint64_t>(raw_id)) {}
+  explicit LegacyTraceId(int8_t raw_id)
+      : raw_id_(static_cast<uint64_t>(raw_id)) {}
+// Different platforms disagree on which integer types are same and which
+// are different. E.g. on Mac size_t is considered a different type from
+// uint64_t even though it has the same size and signedness.
+// Below we add overloads for those types that are known to cause ambiguity.
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
+  explicit LegacyTraceId(size_t raw_id) : raw_id_(raw_id) {}
+  explicit LegacyTraceId(intptr_t raw_id)
+      : raw_id_(static_cast<uint64_t>(raw_id)) {}
+#elif PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+  explicit LegacyTraceId(unsigned long raw_id) : raw_id_(raw_id) {}
+#endif
+  explicit LegacyTraceId(LocalId raw_id) : raw_id_(raw_id.raw_id()) {
+    id_flags_ = legacy::kTraceEventFlagHasLocalId;
+  }
+  explicit LegacyTraceId(GlobalId raw_id) : raw_id_(raw_id.raw_id()) {
+    id_flags_ = legacy::kTraceEventFlagHasGlobalId;
+  }
+  explicit LegacyTraceId(WithScope scoped_id)
+      : scope_(scoped_id.scope()),
+        has_prefix_(scoped_id.has_prefix()),
+        prefix_(scoped_id.prefix()),
+        raw_id_(scoped_id.raw_id()),
+        id_flags_(scoped_id.id_flags()) {}
+
+  uint64_t raw_id() const { return raw_id_; }
+  const char* scope() const { return scope_; }
+  bool has_prefix() const { return has_prefix_; }
+  uint64_t prefix() const { return prefix_; }
+  uint32_t id_flags() const { return id_flags_; }
+
+  void Write(protos::pbzero::TrackEvent::LegacyEvent*,
+             uint32_t event_flags) const;
+
+ private:
+  const char* scope_ = nullptr;
+  bool has_prefix_ = false;
+  uint64_t prefix_;
+  uint64_t raw_id_;
+  uint32_t id_flags_ = legacy::kTraceEventFlagHasId;
+};
+
+#if PERFETTO_ENABLE_LEGACY_TRACE_EVENTS
+template <typename T>
+bool IsEqual(T x, T y) {
+  return x == y;
+}
+
+template <typename T, typename U>
+bool IsEqual(T, U) {
+  return false;
+}
+
+class PERFETTO_EXPORT_COMPONENT TrackEventLegacy {
+ public:
+  static constexpr protos::pbzero::TrackEvent::Type PhaseToType(char phase) {
+    // clang-format off
+    return (phase == TRACE_EVENT_PHASE_BEGIN) ?
+               protos::pbzero::TrackEvent::TYPE_SLICE_BEGIN :
+           (phase == TRACE_EVENT_PHASE_END) ?
+               protos::pbzero::TrackEvent::TYPE_SLICE_END :
+           (phase == TRACE_EVENT_PHASE_INSTANT) ?
+               protos::pbzero::TrackEvent::TYPE_INSTANT :
+           protos::pbzero::TrackEvent::TYPE_UNSPECIFIED;
+    // clang-format on
+  }
+
+  // Reduce binary size overhead by outlining most of the code for writing a
+  // legacy trace event.
+  template <typename... Args>
+  static void WriteLegacyEvent(EventContext ctx,
+                               char phase,
+                               uint32_t flags,
+                               Args&&... args) PERFETTO_NO_INLINE {
+    PERFETTO_DCHECK(!(flags & TRACE_EVENT_FLAG_HAS_PROCESS_ID));
+    AddDebugAnnotations(&ctx, std::forward<Args>(args)...);
+    if (NeedLegacyFlags(phase, flags)) {
+      auto legacy_event = ctx.event()->set_legacy_event();
+      SetLegacyFlags(legacy_event, phase, flags);
+    }
+  }
+
+  template <typename ThreadIdType, typename... Args>
+  static void WriteLegacyEventWithIdAndTid(EventContext ctx,
+                                           char phase,
+                                           uint32_t flags,
+                                           const LegacyTraceId& id,
+                                           const ThreadIdType& thread_id,
+                                           Args&&... args) PERFETTO_NO_INLINE {
+    //
+    // Overrides to consider:
+    //
+    // 1. If we have an id, we need to write {unscoped,local,global}_id and/or
+    //    bind_id.
+    // 2. If we have a thread id, we need to write track_uuid() or
+    //    {pid,tid}_override if the id represents another process.  The
+    //    conversion from |thread_id| happens in embedder code since the type is
+    //    embedder-specified.
+    // 3. If we have a timestamp, we need to write a different timestamp in the
+    //    trace packet itself and make sure TrackEvent won't write one
+    //    internally. This is already done at the call site.
+    //
+    PERFETTO_DCHECK(PhaseToType(phase) ==
+                        protos::pbzero::TrackEvent::TYPE_UNSPECIFIED ||
+                    !(flags & TRACE_EVENT_FLAG_HAS_PROCESS_ID));
+    flags |= id.id_flags();
+    AddDebugAnnotations(&ctx, std::forward<Args>(args)...);
+    if (NeedLegacyFlags(phase, flags)) {
+      auto legacy_event = ctx.event()->set_legacy_event();
+      SetLegacyFlags(legacy_event, phase, flags);
+      if (id.id_flags())
+        id.Write(legacy_event, flags);
+      if (flags & TRACE_EVENT_FLAG_HAS_PROCESS_ID) {
+        // The thread identifier actually represents a process id. Let's set an
+        // override for it.
+        int32_t pid_override =
+            static_cast<int32_t>(legacy::ConvertThreadId(thread_id).tid);
+        legacy_event->set_pid_override(pid_override);
+        legacy_event->set_tid_override(-1);
+      } else {
+        // Only synchronous phases are supported for other threads. These phases
+        // are supported in TrackEvent types and receive a track_uuid
+        // association via TrackEventDataSource::TraceForCategoryImpl().
+        PERFETTO_DCHECK(PhaseToType(phase) !=
+                            protos::pbzero::TrackEvent::TYPE_UNSPECIFIED ||
+                        IsEqual(thread_id, TRACE_EVENT_API_CURRENT_THREAD_ID) ||
+                        legacy::ConvertThreadId(thread_id).tid ==
+                            ThreadTrack::Current().tid);
+      }
+    }
+  }
+
+  // No arguments.
+  static void AddDebugAnnotations(EventContext*) {}
+
+  // N number of debug arguments.
+  template <typename ArgNameType, typename ArgType, typename... OtherArgs>
+  static void AddDebugAnnotations(EventContext* ctx,
+                                  ArgNameType&& arg_name,
+                                  ArgType&& arg_value,
+                                  OtherArgs&&... more_args) {
+    TrackEventInternal::AddDebugAnnotation(ctx,
+                                           std::forward<ArgNameType>(arg_name),
+                                           std::forward<ArgType>(arg_value));
+    AddDebugAnnotations(ctx, std::forward<OtherArgs>(more_args)...);
+  }
+
+ private:
+  static bool NeedLegacyFlags(char phase, uint32_t flags) {
+    if (PhaseToType(phase) == protos::pbzero::TrackEvent::TYPE_UNSPECIFIED)
+      return true;
+    // TODO(skyostil): Implement/deprecate:
+    // - TRACE_EVENT_FLAG_EXPLICIT_TIMESTAMP
+    // - TRACE_EVENT_FLAG_HAS_CONTEXT_ID
+    // - TRACE_EVENT_FLAG_TYPED_PROTO_ARGS
+    // - TRACE_EVENT_FLAG_JAVA_STRING_LITERALS
+    return flags &
+           (TRACE_EVENT_FLAG_HAS_ID | TRACE_EVENT_FLAG_HAS_LOCAL_ID |
+            TRACE_EVENT_FLAG_HAS_GLOBAL_ID | TRACE_EVENT_FLAG_ASYNC_TTS |
+            TRACE_EVENT_FLAG_BIND_TO_ENCLOSING | TRACE_EVENT_FLAG_FLOW_IN |
+            TRACE_EVENT_FLAG_FLOW_OUT | TRACE_EVENT_FLAG_HAS_PROCESS_ID);
+  }
+
+  static void SetLegacyFlags(
+      protos::pbzero::TrackEvent::LegacyEvent* legacy_event,
+      char phase,
+      uint32_t flags) {
+    if (PhaseToType(phase) == protos::pbzero::TrackEvent::TYPE_UNSPECIFIED)
+      legacy_event->set_phase(phase);
+    if (flags & TRACE_EVENT_FLAG_ASYNC_TTS)
+      legacy_event->set_use_async_tts(true);
+    if (flags & TRACE_EVENT_FLAG_BIND_TO_ENCLOSING)
+      legacy_event->set_bind_to_enclosing(true);
+
+    const auto kFlowIn = TRACE_EVENT_FLAG_FLOW_IN;
+    const auto kFlowOut = TRACE_EVENT_FLAG_FLOW_OUT;
+    const auto kFlowInOut = kFlowIn | kFlowOut;
+    if ((flags & kFlowInOut) == kFlowInOut) {
+      legacy_event->set_flow_direction(
+          protos::pbzero::TrackEvent::LegacyEvent::FLOW_INOUT);
+    } else if (flags & kFlowIn) {
+      legacy_event->set_flow_direction(
+          protos::pbzero::TrackEvent::LegacyEvent::FLOW_IN);
+    } else if (flags & kFlowOut) {
+      legacy_event->set_flow_direction(
+          protos::pbzero::TrackEvent::LegacyEvent::FLOW_OUT);
+    }
+  }
+};
+#endif  // PERFETTO_ENABLE_LEGACY_TRACE_EVENTS
+
+// Legacy macros allow argument values to be nullptr and convert them to the
+// "NULL" string. The following function helps mimic this behavior: it forwards
+// all types of arguments apart from a nullptr string as is, and in case of a
+// nullptr returns "NULL".
+template <typename T>
+inline T PossiblyNull(T&& value) {
+  return std::forward<T>(value);
+}
+
+inline const char* PossiblyNull(const char* name) {
+  return name ? name : "NULL";
+}
+
+inline const char* PossiblyNull(char* name) {
+  return name ? name : "NULL";
+}
+
+}  // namespace internal
+}  // namespace perfetto
+
+#endif  // INCLUDE_PERFETTO_TRACING_INTERNAL_TRACK_EVENT_LEGACY_H_
 // gen_amalgamated begin header: include/perfetto/tracing/internal/write_track_event_args.h
 // gen_amalgamated begin header: include/perfetto/tracing/track_event_args.h
 /*
@@ -17139,77 +21136,88 @@ class PERFETTO_EXPORT_COMPONENT EventContext {
 // gen_amalgamated expanded: #include "perfetto/tracing/event_context.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/track.h"
 
-#include <functional>
-
 namespace perfetto {
+namespace internal {
 
 // A helper to add |flow_id| as a non-terminating flow id to TRACE_EVENT
 // inline: TRACE_EVENT(..., perfetto::Flow::ProcessScoped(42));
-class Flow {
+template <class Traits>
+class FlowImpl {
  public:
   // |flow_id| which is local within a given process (e.g. atomic counter xor'ed
   // with feature-specific value). This value is xor'ed with Perfetto's internal
   // process track id to attempt to ensure that it's globally-unique.
-  static PERFETTO_ALWAYS_INLINE inline std::function<void(EventContext&)>
-  ProcessScoped(uint64_t flow_id) {
+  static PERFETTO_ALWAYS_INLINE inline FlowImpl ProcessScoped(
+      uint64_t flow_id) {
     return Global(flow_id ^ Track::process_uuid);
   }
 
+  // Same as above, but combines the flow id with an extra `named_scope`'s hash.
+  static PERFETTO_ALWAYS_INLINE inline FlowImpl ProcessScoped(
+      uint64_t flow_id,
+      const char* named_scope) {
+    return Global(flow_id, named_scope);
+  }
+
   // Same as above, but construct an id from a pointer.
   // NOTE: After the object is destroyed, the value of |ptr| can be reused for a
   // different object (in particular if the object is allocated on a stack).
   // Please ensure that you emit a trace event with the flow id of
   // perfetto::TerminatingFlow::FromPointer(this) from the destructor of the
   // object to avoid accidental conflicts.
-  static PERFETTO_ALWAYS_INLINE inline std::function<void(EventContext&)>
-  FromPointer(void* ptr) {
+  static PERFETTO_ALWAYS_INLINE inline FlowImpl FromPointer(const void* ptr) {
     return ProcessScoped(reinterpret_cast<uintptr_t>(ptr));
   }
 
+  // Same as above, but combines the flow id with an extra `named_scope`'s hash.
+  static PERFETTO_ALWAYS_INLINE inline FlowImpl FromPointer(
+      const void* ptr,
+      const char* named_scope) {
+    return ProcessScoped(reinterpret_cast<uintptr_t>(ptr), named_scope);
+  }
+
   // Add the |flow_id|. The caller is responsible for ensuring that it's
   // globally-unique (e.g. by generating a random value). This should be used
   // only for flow events which cross the process boundary (e.g. IPCs).
-  static PERFETTO_ALWAYS_INLINE inline std::function<void(EventContext&)>
-  Global(uint64_t flow_id) {
-    return [flow_id](perfetto::EventContext& ctx) {
-      ctx.event()->add_flow_ids(flow_id);
-    };
+  static PERFETTO_ALWAYS_INLINE inline FlowImpl Global(uint64_t flow_id) {
+    return FlowImpl(flow_id);
+  }
+
+  // Same as above, but combines the flow id with an extra `named_scope`'s hash.
+  static PERFETTO_ALWAYS_INLINE inline FlowImpl Global(
+      uint64_t flow_id,
+      const char* named_scope) {
+    return FlowImpl(flow_id ^ internal::Fnv1a(named_scope));
   }
 
   // TODO(altimin): Remove once converting a single usage in Chromium.
-  explicit constexpr Flow(uint64_t flow_id) : flow_id_(flow_id) {}
+  explicit constexpr FlowImpl(uint64_t flow_id) : flow_id_(flow_id) {}
 
-  void operator()(EventContext& ctx) { ctx.event()->add_flow_ids(flow_id_); }
+  void operator()(EventContext& ctx) const {
+    Traits::EmitFlowId(ctx, flow_id_);
+  }
 
  private:
   uint64_t flow_id_;
 };
 
-// A helper to add a given |flow_id| as a terminating flow to TRACE_EVENT
-// inline.
-class TerminatingFlow {
- public:
-  // See `Flow::ProcessScoped(uint64_t)`.
-  static PERFETTO_ALWAYS_INLINE inline std::function<void(EventContext&)>
-  ProcessScoped(uint64_t flow_id) {
-    return Global(flow_id ^ Track::process_uuid);
-  }
-
-  // See `Flow::FromPointer(void*)`.
-  static PERFETTO_ALWAYS_INLINE inline std::function<void(EventContext&)>
-  FromPointer(void* ptr) {
-    return ProcessScoped(reinterpret_cast<uintptr_t>(ptr));
+struct DefaultFlowTraits {
+  static void EmitFlowId(EventContext& ctx, uint64_t flow_id) {
+    ctx.event()->add_flow_ids(flow_id);
   }
+};
 
-  // See `Flow::Global(uint64_t)`.
-  static PERFETTO_ALWAYS_INLINE inline std::function<void(EventContext&)>
-  Global(uint64_t flow_id) {
-    return [flow_id](perfetto::EventContext& ctx) {
-      ctx.event()->add_terminating_flow_ids(flow_id);
-    };
+struct TerminatingFlowTraits {
+  static void EmitFlowId(EventContext& ctx, uint64_t flow_id) {
+    ctx.event()->add_terminating_flow_ids(flow_id);
   }
 };
 
+}  // namespace internal
+
+using Flow = internal::FlowImpl<internal::DefaultFlowTraits>;
+using TerminatingFlow = internal::FlowImpl<internal::TerminatingFlowTraits>;
+
 }  // namespace perfetto
 
 #endif  // INCLUDE_PERFETTO_TRACING_TRACK_EVENT_ARGS_H_
@@ -17288,6 +21296,24 @@ static constexpr bool IsValidTraceLambdaTakingReference() {
   return IsValidTraceLambdaTakingReferenceImpl<T>(nullptr);
 }
 
+template <typename T>
+static constexpr bool IsFieldMetadataTypeImpl(
+    typename std::enable_if<
+        std::is_base_of<protozero::proto_utils::FieldMetadataBase,
+                        T>::value>::type* = nullptr) {
+  return true;
+}
+
+template <typename T>
+static constexpr bool IsFieldMetadataTypeImpl(...) {
+  return false;
+}
+
+template <typename T>
+static constexpr bool IsFieldMetadataType() {
+  return IsFieldMetadataTypeImpl<T>(nullptr);
+}
+
 }  // namespace
 
 // Write an old-style lambda taking an EventContext (without a reference)
@@ -17310,13 +21336,15 @@ PERFETTO_ALWAYS_INLINE void WriteTrackEventArgs(EventContext event_ctx,
                                                 ArgValue&& arg_value,
                                                 Args&&... args);
 
-template <typename FieldMetadataType, typename ArgValue, typename... Args>
-PERFETTO_ALWAYS_INLINE void WriteTrackEventArgs(
-    EventContext event_ctx,
-    protozero::proto_utils::internal::FieldMetadataHelper<FieldMetadataType>
-        field_name,
-    ArgValue&& arg_value,
-    Args&&... args);
+template <typename FieldMetadataType,
+          typename ArgValue,
+          typename... Args,
+          typename FieldMetadataTypeCheck = typename std::enable_if<
+              IsFieldMetadataType<FieldMetadataType>()>::type>
+PERFETTO_ALWAYS_INLINE void WriteTrackEventArgs(EventContext event_ctx,
+                                                FieldMetadataType field_name,
+                                                ArgValue&& arg_value,
+                                                Args&&... args);
 
 template <typename ArgumentFunction,
           typename... Args,
@@ -17334,13 +21362,14 @@ PERFETTO_ALWAYS_INLINE void WriteTrackEventArgs(
 }
 
 // Write one typed message and recursively write the rest of the arguments.
-template <typename FieldMetadataType, typename ArgValue, typename... Args>
-PERFETTO_ALWAYS_INLINE void WriteTrackEventArgs(
-    EventContext event_ctx,
-    protozero::proto_utils::internal::FieldMetadataHelper<FieldMetadataType>
-        field_name,
-    ArgValue&& arg_value,
-    Args&&... args) {
+template <typename FieldMetadataType,
+          typename ArgValue,
+          typename... Args,
+          typename FieldMetadataTypeCheck>
+PERFETTO_ALWAYS_INLINE void WriteTrackEventArgs(EventContext event_ctx,
+                                                FieldMetadataType field_name,
+                                                ArgValue&& arg_value,
+                                                Args&&... args) {
   static_assert(std::is_base_of<protozero::proto_utils::FieldMetadataBase,
                                 FieldMetadataType>::value,
                 "");
@@ -17558,11 +21587,10 @@ constexpr const char* NullCategory(const char*) {
 perfetto::DynamicCategory NullCategory(const perfetto::DynamicCategory&);
 
 constexpr bool StringMatchesPrefix(const char* str, const char* prefix) {
-  return !*str ? !*prefix
-               : !*prefix ? true
-                          : *str != *prefix
-                                ? false
-                                : StringMatchesPrefix(str + 1, prefix + 1);
+  return !*str             ? !*prefix
+         : !*prefix        ? true
+         : *str != *prefix ? false
+                           : StringMatchesPrefix(str + 1, prefix + 1);
 }
 
 constexpr bool IsStringInPrefixList(const char*) {
@@ -17635,11 +21663,10 @@ class PERFETTO_EXPORT_COMPONENT TrackEventCategoryRegistry {
   }
 
   constexpr bool ValidateCategories(size_t index = 0) const {
-    return (index == category_count_)
-               ? true
-               : IsValidCategoryName(categories_[index].name)
-                     ? ValidateCategories(index + 1)
-                     : false;
+    return (index == category_count_) ? true
+           : IsValidCategoryName(categories_[index].name)
+               ? ValidateCategories(index + 1)
+               : false;
   }
 
  private:
@@ -17647,12 +21674,11 @@ class PERFETTO_EXPORT_COMPONENT TrackEventCategoryRegistry {
   constexpr size_t FindImpl(const char* name,
                             bool is_dynamic,
                             size_t index = 0) const {
-    return is_dynamic ? kDynamicCategoryIndex
-                      : (index == category_count_)
-                            ? kInvalidCategoryIndex
-                            : StringEq(categories_[index].name, name)
-                                  ? index
-                                  : FindImpl(name, false, index + 1);
+    return is_dynamic                   ? kDynamicCategoryIndex
+           : (index == category_count_) ? kInvalidCategoryIndex
+           : StringEq(categories_[index].name, name)
+               ? index
+               : FindImpl(name, false, index + 1);
   }
 
   // A compile time helper for checking that a category index is valid.
@@ -17674,14 +21700,15 @@ class PERFETTO_EXPORT_COMPONENT TrackEventCategoryRegistry {
   }
 
   static constexpr bool IsValidCategoryName(const char* name) {
-    return (!name || *name == '\"' || *name == '*' || *name == ' ')
-               ? false
-               : *name ? IsValidCategoryName(name + 1) : true;
+    return (!name || *name == '\"' || *name == '*' || *name == ' ') ? false
+           : *name ? IsValidCategoryName(name + 1)
+                   : true;
   }
 
   static constexpr bool StringEq(const char* a, const char* b) {
-    return *a != *b ? false
-                    : (!*a || !*b) ? (*a == *b) : StringEq(a + 1, b + 1);
+    return *a != *b       ? false
+           : (!*a || !*b) ? (*a == *b)
+                          : StringEq(a + 1, b + 1);
   }
 
   const Category* const categories_;
@@ -17735,6 +21762,7 @@ class PERFETTO_EXPORT_COMPONENT TrackEventConfig : public ::protozero::CppMessag
     kTimestampUnitMultiplierFieldNumber = 6,
     kFilterDebugAnnotationsFieldNumber = 7,
     kEnableThreadTimeSamplingFieldNumber = 8,
+    kThreadTimeSubsamplingNsFieldNumber = 10,
     kFilterDynamicEventNamesFieldNumber = 9,
   };
 
@@ -17796,6 +21824,10 @@ class PERFETTO_EXPORT_COMPONENT TrackEventConfig : public ::protozero::CppMessag
   bool enable_thread_time_sampling() const { return enable_thread_time_sampling_; }
   void set_enable_thread_time_sampling(bool value) { enable_thread_time_sampling_ = value; _has_field_.set(8); }
 
+  bool has_thread_time_subsampling_ns() const { return _has_field_[10]; }
+  uint64_t thread_time_subsampling_ns() const { return thread_time_subsampling_ns_; }
+  void set_thread_time_subsampling_ns(uint64_t value) { thread_time_subsampling_ns_ = value; _has_field_.set(10); }
+
   bool has_filter_dynamic_event_names() const { return _has_field_[9]; }
   bool filter_dynamic_event_names() const { return filter_dynamic_event_names_; }
   void set_filter_dynamic_event_names(bool value) { filter_dynamic_event_names_ = value; _has_field_.set(9); }
@@ -17809,13 +21841,14 @@ class PERFETTO_EXPORT_COMPONENT TrackEventConfig : public ::protozero::CppMessag
   uint64_t timestamp_unit_multiplier_{};
   bool filter_debug_annotations_{};
   bool enable_thread_time_sampling_{};
+  uint64_t thread_time_subsampling_ns_{};
   bool filter_dynamic_event_names_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<10> _has_field_{};
+  std::bitset<11> _has_field_{};
 };
 
 }  // namespace perfetto
@@ -17842,13 +21875,14 @@ class PERFETTO_EXPORT_COMPONENT TrackEventConfig : public ::protozero::CppMessag
 #ifndef INCLUDE_PERFETTO_TRACING_INTERNAL_TRACK_EVENT_DATA_SOURCE_H_
 #define INCLUDE_PERFETTO_TRACING_INTERNAL_TRACK_EVENT_DATA_SOURCE_H_
 
-// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
 // gen_amalgamated expanded: #include "perfetto/base/template_util.h"
+// gen_amalgamated expanded: #include "perfetto/base/thread_annotations.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/message_handle.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_config.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/data_source.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/event_context.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/internal/track_event_internal.h"
+// gen_amalgamated expanded: #include "perfetto/tracing/internal/track_event_legacy.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/internal/write_track_event_args.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/track.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/track_event_category_registry.h"
@@ -17900,7 +21934,8 @@ template <>
 struct TraceTimestampTraits<uint64_t> {
   static inline TraceTimestamp ConvertTimestampToTraceTimeNs(
       const uint64_t& timestamp) {
-    return {static_cast<uint32_t>(internal::TrackEventInternal::GetClockId()), timestamp};
+    return {static_cast<uint32_t>(internal::TrackEventInternal::GetClockId()),
+            timestamp};
   }
 };
 
@@ -17932,14 +21967,15 @@ static constexpr bool IsValidNormalTrack() {
 // Because the user can use arbitrary timestamp types, we can't compare against
 // any known base type here. Instead, we check that a track or a trace lambda
 // isn't being interpreted as a timestamp.
-template <typename T,
-          typename CanBeConvertedToNsCheck = decltype(
-              ::perfetto::TraceTimestampTraits<typename base::remove_cvref_t<
-                  T>>::ConvertTimestampToTraceTimeNs(std::declval<T>())),
-          typename NotTrackCheck =
-              typename std::enable_if<!IsValidNormalTrack<T>()>::type,
-          typename NotLambdaCheck =
-              typename std::enable_if<!IsValidTraceLambda<T>()>::type>
+template <
+    typename T,
+    typename CanBeConvertedToNsCheck =
+        decltype(::perfetto::TraceTimestampTraits<typename base::remove_cvref_t<
+                     T>>::ConvertTimestampToTraceTimeNs(std::declval<T>())),
+    typename NotTrackCheck =
+        typename std::enable_if<!IsValidNormalTrack<T>()>::type,
+    typename NotLambdaCheck =
+        typename std::enable_if<!IsValidTraceLambda<T>()>::type>
 static constexpr bool IsValidTimestamp() {
   return true;
 }
@@ -17948,27 +21984,63 @@ static constexpr bool IsValidTimestamp() {
 template <typename...>
 using void_t = void;
 
-// Returns true iff `GetStaticString(T)` is defined OR T == DynamicString.
+// Helper to check if T is a pure rvalue (prvalue).
+template <typename T>
+constexpr bool IsPrvalue = !std::is_reference_v<T>;
+
+// Returns true iff `T` is a valid event name type.
+// Valid types are:
+// - Types for which `GetStaticString(T)` is defined.
+// - Temporary `perfetto::DynamicString` objects. `DynamicString` uses a raw
+//   pointer, so to prevent dangling pointers, the underlying string must
+//   outlive the event. Requiring it to be a pure rvalue (prvalue) ensures this
+//   for the duration of the TRACE_EVENT call.
 template <typename T, typename = void>
-struct IsValidEventNameType
-    : std::is_same<perfetto::DynamicString, typename std::decay<T>::type> {};
+constexpr bool IsValidEventNameType =
+    std::is_same_v<perfetto::DynamicString, std::decay_t<T>> && IsPrvalue<T>;
 
 template <typename T>
-struct IsValidEventNameType<
-    T,
-    void_t<decltype(GetStaticString(std::declval<T>()))>> : std::true_type {};
+constexpr bool
+    IsValidEventNameType<T,
+                         void_t<decltype(GetStaticString(std::declval<T>()))>> =
+        true;
 
 template <typename T>
 inline void ValidateEventNameType() {
   static_assert(
-      IsValidEventNameType<T>::value,
+      IsValidEventNameType<T>,
       "Event names must be static strings. To use dynamic event names, see "
       "https://perfetto.dev/docs/instrumentation/"
       "track-events#dynamic-event-names");
 }
 
+inline bool UnorderedEqual(std::vector<std::string> vec1,
+                           std::vector<std::string> vec2) {
+  std::sort(vec1.begin(), vec1.end());
+  vec1.erase(std::unique(vec1.begin(), vec1.end()), vec1.end());
+  std::sort(vec2.begin(), vec2.end());
+  vec2.erase(std::unique(vec2.begin(), vec2.end()), vec2.end());
+  return vec1 == vec2;
+}
+
 }  // namespace
 
+inline ::perfetto::DynamicString DecayEventNameType(
+    ::perfetto::DynamicString name) {
+  return name;
+}
+
+inline ::perfetto::StaticString DecayEventNameType(
+    ::perfetto::StaticString name) {
+  return name;
+}
+
+// Convert all static strings of different length to StaticString to avoid
+// unnecessary template instantiations.
+inline ::perfetto::StaticString DecayEventNameType(const char* name) {
+  return ::perfetto::StaticString{name};
+}
+
 // Traits for dynamic categories.
 template <typename CategoryType>
 struct CategoryTraits {
@@ -18015,42 +22087,32 @@ struct TrackEventDataSourceTraits : public perfetto::DefaultDataSourceTraits {
                                                       TracingTLS* root_tls) {
     return &root_tls->track_event_tls;
   }
+
+  // Clear the incremental state without destroying and recreating it. This
+  // allows reusing allocated memory in hash maps.
+  static bool ClearIncrementalState(TrackEventIncrementalState* incr_state) {
+    incr_state->Clear();
+    return true;
+  }
 };
 
-// A generic track event data source which is instantiated once per track event
-// category namespace.
-template <typename DerivedDataSource,
-          const TrackEventCategoryRegistry* Registry>
-class TrackEventDataSource
-    : public DataSource<DerivedDataSource, TrackEventDataSourceTraits> {
-  using Base = DataSource<DerivedDataSource, TrackEventDataSourceTraits>;
+// A generic track event data source.
+class PERFETTO_EXPORT_COMPONENT TrackEventDataSource
+    : public DataSource<TrackEventDataSource, TrackEventDataSourceTraits> {
+  using Base = DataSource<TrackEventDataSource, TrackEventDataSourceTraits>;
 
  public:
   static constexpr bool kRequiresCallbacksUnderLock = false;
 
-  // Add or remove a session observer for this track event data source. The
-  // observer will be notified about started and stopped tracing sessions.
-  // Returns |true| if the observer was successfully added (i.e., the maximum
-  // number of observers wasn't exceeded).
-  static bool AddSessionObserver(TrackEventSessionObserver* observer) {
-    return TrackEventInternal::AddSessionObserver(*Registry, observer);
-  }
-
-  static void RemoveSessionObserver(TrackEventSessionObserver* observer) {
-    TrackEventInternal::RemoveSessionObserver(*Registry, observer);
-  }
-
   // DataSource implementation.
   void OnSetup(const DataSourceBase::SetupArgs& args) override {
     auto config_raw = args.config->track_event_config_raw();
     bool ok = config_.ParseFromArray(config_raw.data(), config_raw.size());
     PERFETTO_DCHECK(ok);
-    TrackEventInternal::EnableTracing(*Registry, config_, args);
+    TrackEventInternal::GetInstance().EnableTracing(config_, args);
   }
 
-  void OnStart(const DataSourceBase::StartArgs& args) override {
-    TrackEventInternal::OnStart(*Registry, args);
-  }
+  void OnStart(const DataSourceBase::StartArgs& args) override;
 
   void OnStop(const DataSourceBase::StopArgs& args) override {
     auto outer_stop_closure = args.HandleStopAsynchronously();
@@ -18059,11 +22121,11 @@ class TrackEventDataSource
     inner_stop_args.internal_instance_index = internal_instance_index;
     inner_stop_args.async_stop_closure = [internal_instance_index,
                                           outer_stop_closure] {
-      TrackEventInternal::DisableTracing(*Registry, internal_instance_index);
+      TrackEventInternal::GetInstance().DisableTracing(internal_instance_index);
       outer_stop_closure();
     };
 
-    TrackEventInternal::OnStop(*Registry, inner_stop_args);
+    TrackEventInternal::OnStop(inner_stop_args);
 
     // If inner_stop_args.HandleStopAsynchronously() hasn't been called,
     // run the async closure here.
@@ -18073,21 +22135,163 @@ class TrackEventDataSource
 
   void WillClearIncrementalState(
       const DataSourceBase::ClearIncrementalStateArgs& args) override {
-    TrackEventInternal::WillClearIncrementalState(*Registry, args);
+    TrackEventInternal::WillClearIncrementalState(args);
+  }
+
+  // In Chrome, startup sessions are propagated from the browser process to
+  // child processes using command-line flags. Command-line flags can only
+  // convey the category filter and privacy settings, so we use only those
+  // to determine which startup sessions to adopt.
+  // TODO(khokhlov): After Chrome is able to propagate the entire config to the
+  // child process, we can make this comparison more strict by only clearing
+  // selected fields and comparing everything else. One specific thing to keep
+  // in mind is to clear the |convert_to_legacy_json| field, because Telemetry
+  // initiates tracing with proto format, but in some cases adopts the tracing
+  // session later via devtools which expect json format.
+  bool CanAdoptStartupSession(const DataSourceConfig& startup_config,
+                              const DataSourceConfig& service_config) override {
+    if (startup_config.track_event_config_raw().empty() ||
+        service_config.track_event_config_raw().empty()) {
+      return false;
+    }
+
+    protos::gen::TrackEventConfig startup_te_cfg;
+    startup_te_cfg.ParseFromString(startup_config.track_event_config_raw());
+    protos::gen::TrackEventConfig service_te_cfg;
+    service_te_cfg.ParseFromString(service_config.track_event_config_raw());
+
+    if (!UnorderedEqual(startup_te_cfg.enabled_categories(),
+                        service_te_cfg.enabled_categories())) {
+      return false;
+    }
+    if (!UnorderedEqual(startup_te_cfg.disabled_categories(),
+                        service_te_cfg.disabled_categories())) {
+      return false;
+    }
+    if (!UnorderedEqual(startup_te_cfg.enabled_tags(),
+                        service_te_cfg.enabled_tags())) {
+      return false;
+    }
+    if (!UnorderedEqual(startup_te_cfg.disabled_tags(),
+                        service_te_cfg.disabled_tags())) {
+      return false;
+    }
+    if (startup_te_cfg.filter_debug_annotations() !=
+        service_te_cfg.filter_debug_annotations()) {
+      return false;
+    }
+    if (startup_te_cfg.filter_dynamic_event_names() !=
+        service_te_cfg.filter_dynamic_event_names()) {
+      return false;
+    }
+
+    return true;
+  }
+
+  static bool AddRegistry(const TrackEventCategoryRegistry* registry) {
+    // Registration is performed out-of-line so users don't need to depend on
+    // DataSourceDescriptor C++ bindings.
+    auto registries = TrackEventInternal::GetInstance().AddRegistry(registry);
+    Trace([&](TraceContext ctx) {
+      protos::gen::TrackEventConfig config;
+      {
+        if (auto data_source = ctx.GetDataSourceLocked()) {
+          config = data_source->GetConfig();
+        } else {
+          return;
+        }
+      }
+      TrackEventInternal::EnableRegistry(registry, config,
+                                         ctx.instance_index());
+    });
+    if (registries.size() == 1) {
+      return TrackEventInternal::Initialize(
+          registries,
+          [](const DataSourceDescriptor& dsd) { return Register(dsd); });
+    }
+    return TrackEventInternal::Initialize(registries,
+                                          [](const DataSourceDescriptor& dsd) {
+                                            UpdateDescriptor(dsd);
+                                            return true;
+                                          });
+  }
+
+  const protos::gen::TrackEventConfig& GetConfig() const { return config_; }
+
+  static void ResetForTesting() {
+    TrackEventInternal::GetInstance().ResetRegistriesForTesting();
+  }
+
+ private:
+  // Config for the current tracing session.
+  protos::gen::TrackEventConfig config_;
+};
+
+template <const TrackEventCategoryRegistry* Registry>
+class TrackEvent {
+ public:
+  using TraceContext = TrackEventDataSource::TraceContext;
+  static bool Register() { return TrackEventDataSource::AddRegistry(Registry); }
+
+  // Add or remove a session observer for this track event data source. The
+  // observer will be notified about started and stopped tracing sessions.
+  // Returns |true| if the observer was successfully added (i.e., the maximum
+  // number of observers wasn't exceeded).
+  static bool AddSessionObserver(TrackEventSessionObserver* observer) {
+    return TrackEventInternal::AddSessionObserver(*Registry, observer);
+  }
+
+  static void RemoveSessionObserver(TrackEventSessionObserver* observer) {
+    TrackEventInternal::RemoveSessionObserver(*Registry, observer);
   }
 
   static void Flush() {
-    Base::template Trace([](typename Base::TraceContext ctx) { ctx.Flush(); });
+    TrackEventDataSource::Trace(
+        [](TrackEventDataSource::TraceContext ctx) { ctx.Flush(); });
+  }
+
+  template <typename Callback>
+  static void Trace(Callback cb) {
+    TrackEventDataSource::Trace(cb);
+  }
+
+  template <typename Callback>
+  static void CallIfEnabled(Callback callback) PERFETTO_ALWAYS_INLINE {
+    TrackEventDataSource::CallIfEnabled(callback);
   }
 
   // Determine if *any* tracing category is enabled.
   static bool IsEnabled() {
     bool enabled = false;
-    Base::template CallIfEnabled(
-        [&](uint32_t /*instances*/) { enabled = true; });
+    CallIfEnabled([&](uint32_t /*instances*/) { enabled = true; });
     return enabled;
   }
 
+  // Determine if `config` enables a given static category.
+  static bool IsCategoryEnabledByConfig(
+      const protos::gen::TrackEventConfig& config,
+      size_t category_index) {
+    return TrackEventInternal::IsCategoryEnabled(
+        *Registry, config, *Registry->GetCategory(category_index));
+  }
+
+  // Determine if `config` enables a given dynamic category.
+  static bool IsCategoryEnabledByConfig(
+      const protos::gen::TrackEventConfig& config,
+      const DynamicCategory& category) {
+    return TrackEventInternal::IsCategoryEnabled(
+        *Registry, config, Category::FromDynamicCategory(category));
+  }
+
+  // Determine if tracing for the given static category is enabled in a session
+  // identified by `internal_instance_index`.
+  static bool IsCategoryEnabledBySession(size_t internal_instance_index,
+                                         size_t category_index) {
+    std::atomic<uint8_t>* state = Registry->GetCategoryState(category_index);
+    return state->load(std::memory_order_relaxed) &
+           static_cast<uint8_t>(1u << internal_instance_index);
+  }
+
   // Determine if tracing for the given static category is enabled.
   static bool IsCategoryEnabled(size_t category_index) {
     return Registry->GetCategoryState(category_index)
@@ -18098,8 +22302,8 @@ class TrackEventDataSource
   static bool IsDynamicCategoryEnabled(
       const DynamicCategory& dynamic_category) {
     bool enabled = false;
-    Base::template Trace([&](typename Base::TraceContext ctx) {
-      enabled = IsDynamicCategoryEnabled(&ctx, dynamic_category);
+    Trace([&](typename TrackEventDataSource::TraceContext ctx) {
+      enabled = enabled || IsDynamicCategoryEnabled(&ctx, dynamic_category);
     });
     return enabled;
   }
@@ -18111,11 +22315,188 @@ class TrackEventDataSource
   template <typename Callback>
   static void CallIfCategoryEnabled(size_t category_index,
                                     Callback callback) PERFETTO_ALWAYS_INLINE {
-    Base::template CallIfEnabled<CategoryTracePointTraits>(
+    TrackEventDataSource::CallIfEnabled<CategoryTracePointTraits>(
         [&callback](uint32_t instances) { callback(instances); },
         {category_index});
   }
 
+  // The following methods forward all arguments to TraceForCategoryBody
+  // while casting string constants to const char* and integer arguments to
+  // int64_t, uint64_t or bool.
+  template <typename CategoryType,
+            typename EventNameType,
+            typename... Arguments>
+  static void TraceForCategory(uint32_t instances,
+                               const CategoryType& category,
+                               const EventNameType& name,
+                               perfetto::protos::pbzero::TrackEvent::Type type,
+                               Arguments&&... args) PERFETTO_ALWAYS_INLINE {
+    TraceForCategoryBody(instances, DecayStrType(category), DecayStrType(name),
+                         type, DecayArgType(args)...);
+  }
+
+#if PERFETTO_ENABLE_LEGACY_TRACE_EVENTS
+  template <typename TrackType,
+            typename CategoryType,
+            typename EventNameType,
+            typename... Arguments,
+            typename TrackTypeCheck = typename std::enable_if<
+                std::is_convertible<TrackType, Track>::value>::type>
+  static void TraceForCategoryLegacy(
+      uint32_t instances,
+      const CategoryType& category,
+      const EventNameType& event_name,
+      perfetto::protos::pbzero::TrackEvent::Type type,
+      TrackType&& track,
+      char phase,
+      uint32_t flags,
+      Arguments&&... args) PERFETTO_ALWAYS_INLINE {
+    TraceForCategoryLegacyBody(instances, DecayStrType(category),
+                               DecayStrType(event_name), type, track, phase,
+                               flags, DecayArgType(args)...);
+  }
+
+  template <typename TrackType,
+            typename CategoryType,
+            typename EventNameType,
+            typename TimestampType = uint64_t,
+            typename... Arguments,
+            typename TrackTypeCheck = typename std::enable_if<
+                std::is_convertible<TrackType, Track>::value>::type,
+            typename TimestampTypeCheck = typename std::enable_if<
+                IsValidTimestamp<TimestampType>()>::type>
+  static void TraceForCategoryLegacy(
+      uint32_t instances,
+      const CategoryType& category,
+      const EventNameType& event_name,
+      perfetto::protos::pbzero::TrackEvent::Type type,
+      TrackType&& track,
+      char phase,
+      uint32_t flags,
+      TimestampType&& timestamp,
+      Arguments&&... args) PERFETTO_ALWAYS_INLINE {
+    TraceForCategoryLegacyBody(instances, DecayStrType(category),
+                               DecayStrType(event_name), type, track, phase,
+                               flags, timestamp, DecayArgType(args)...);
+  }
+
+  template <typename TrackType,
+            typename CategoryType,
+            typename EventNameType,
+            typename ThreadIdType,
+            typename LegacyIdType,
+            typename... Arguments,
+            typename TrackTypeCheck = typename std::enable_if<
+                std::is_convertible<TrackType, Track>::value>::type>
+  static void TraceForCategoryLegacyWithId(
+      uint32_t instances,
+      const CategoryType& category,
+      const EventNameType& event_name,
+      perfetto::protos::pbzero::TrackEvent::Type type,
+      TrackType&& track,
+      char phase,
+      uint32_t flags,
+      ThreadIdType thread_id,
+      LegacyIdType legacy_id,
+      Arguments&&... args) PERFETTO_ALWAYS_INLINE {
+    TraceForCategoryLegacyWithIdBody(
+        instances, DecayStrType(category), DecayStrType(event_name), type,
+        track, phase, flags, thread_id, legacy_id, DecayArgType(args)...);
+  }
+
+  template <typename TrackType,
+            typename CategoryType,
+            typename EventNameType,
+            typename ThreadIdType,
+            typename LegacyIdType,
+            typename TimestampType = uint64_t,
+            typename... Arguments,
+            typename TrackTypeCheck = typename std::enable_if<
+                std::is_convertible<TrackType, Track>::value>::type,
+            typename TimestampTypeCheck = typename std::enable_if<
+                IsValidTimestamp<TimestampType>()>::type>
+  static void TraceForCategoryLegacyWithId(
+      uint32_t instances,
+      const CategoryType& category,
+      const EventNameType& event_name,
+      perfetto::protos::pbzero::TrackEvent::Type type,
+      TrackType&& track,
+      char phase,
+      uint32_t flags,
+      ThreadIdType thread_id,
+      LegacyIdType legacy_id,
+      TimestampType&& timestamp,
+      Arguments&&... args) PERFETTO_ALWAYS_INLINE {
+    TraceForCategoryLegacyWithIdBody(instances, DecayStrType(category),
+                                     DecayStrType(event_name), type, track,
+                                     phase, flags, thread_id, legacy_id,
+                                     timestamp, DecayArgType(args)...);
+  }
+#endif
+
+  // Record metadata about different types of timeline tracks. See Track.
+  static void SetTrackDescriptor(const Track& track,
+                                 const protos::gen::TrackDescriptor& desc) {
+    PERFETTO_DCHECK(track.uuid == desc.uuid());
+    TrackRegistry::Get()->UpdateTrack(track, desc.SerializeAsString());
+    Trace([&](TrackEventDataSource::TraceContext ctx) {
+      TrackEventInternal::WriteTrackDescriptor(
+          track, ctx.tls_inst_->trace_writer.get(), ctx.GetIncrementalState(),
+          *ctx.GetCustomTlsState(), TrackEventInternal::GetTraceTime());
+    });
+  }
+
+  static void EraseTrackDescriptor(const Track& track) {
+    TrackRegistry::Get()->EraseTrack(track);
+  }
+
+  // Returns the current trace timestamp in nanoseconds. Note the returned
+  // timebase may vary depending on the platform, but will always match the
+  // timestamps recorded by track events (see GetTraceClockId).
+  static uint64_t GetTraceTimeNs() { return TrackEventInternal::GetTimeNs(); }
+
+  // Returns the type of clock used by GetTraceTimeNs().
+  static constexpr protos::pbzero::BuiltinClock GetTraceClockId() {
+    return TrackEventInternal::GetClockId();
+  }
+
+ private:
+  // The DecayStrType method is used to avoid unnecessary instantiations of
+  // templates on string constants of different sizes. Without it, strings
+  // of different lengths have different types: char[10], char[15] etc.
+  // DecayStrType forwards all types of arguments as is, with the exception
+  // of string constants which are all cast to const char*. This allows to
+  // avoid extra instantiations of TraceForCategory templates.
+  template <typename T>
+  static T&& DecayStrType(T&& t) {
+    return std::forward<T>(t);
+  }
+
+  static const char* DecayStrType(const char* t) { return t; }
+
+  // The DecayArgType method is used to avoid unnecessary instantiations of
+  // templates on:
+  // * string constants of different sizes.
+  // * primitive of different constness (or references).
+  // This avoids extra instantiations of TraceForCategory templates.
+  template <typename T>
+  static T&& DecayArgType(T&& t) {
+    return std::forward<T>(t);
+  }
+
+  static const char* DecayArgType(const char* s) { return s; }
+  static uint64_t DecayArgType(uint64_t u) { return u; }
+  static uint32_t DecayArgType(uint32_t u) { return u; }
+  static uint16_t DecayArgType(uint16_t u) { return u; }
+  static uint8_t DecayArgType(uint8_t u) { return u; }
+  static int64_t DecayArgType(int64_t i) { return i; }
+  static int32_t DecayArgType(int32_t i) { return i; }
+  static int16_t DecayArgType(int16_t i) { return i; }
+  static int8_t DecayArgType(int8_t i) { return i; }
+  static bool DecayArgType(bool b) { return b; }
+  static float DecayArgType(float f) { return f; }
+  static double DecayArgType(double f) { return f; }
+
   // Once we've determined tracing to be enabled for this category, actually
   // write a trace event onto this thread's default track. Outlined to avoid
   // bloating code (mostly stack depth) at the actual trace point.
@@ -18130,15 +22511,15 @@ class TrackEventDataSource
   template <typename CategoryType,
             typename EventNameType,
             typename... Arguments>
-  static void TraceForCategory(uint32_t instances,
-                               const CategoryType& category,
-                               const EventNameType& event_name,
-                               perfetto::protos::pbzero::TrackEvent::Type type,
-                               Arguments&&... args) PERFETTO_NO_INLINE {
-    TraceForCategoryImpl(instances, category, event_name, type,
-                         TrackEventInternal::kDefaultTrack,
-                         TrackEventInternal::GetTraceTime(),
-                         std::forward<Arguments>(args)...);
+  static void TraceForCategoryBody(
+      uint32_t instances,
+      const CategoryType& category,
+      const EventNameType& event_name,
+      perfetto::protos::pbzero::TrackEvent::Type type,
+      Arguments&&... args) PERFETTO_NO_INLINE {
+    TraceForCategoryImplNoTimestamp(instances, category, event_name, type,
+                                    TrackEventInternal::kDefaultTrack,
+                                    std::forward<Arguments>(args)...);
   }
 
   // Trace point which takes a track, but not timestamp.
@@ -18152,15 +22533,16 @@ class TrackEventDataSource
             typename... Arguments,
             typename TrackTypeCheck = typename std::enable_if<
                 std::is_convertible<TrackType, Track>::value>::type>
-  static void TraceForCategory(uint32_t instances,
-                               const CategoryType& category,
-                               const EventNameType& event_name,
-                               perfetto::protos::pbzero::TrackEvent::Type type,
-                               TrackType&& track,
-                               Arguments&&... args) PERFETTO_NO_INLINE {
-    TraceForCategoryImpl(
-        instances, category, event_name, type, std::forward<TrackType>(track),
-        TrackEventInternal::GetTraceTime(), std::forward<Arguments>(args)...);
+  static void TraceForCategoryBody(
+      uint32_t instances,
+      const CategoryType& category,
+      const EventNameType& event_name,
+      perfetto::protos::pbzero::TrackEvent::Type type,
+      TrackType&& track,
+      Arguments&&... args) PERFETTO_NO_INLINE {
+    TraceForCategoryImplNoTimestamp(instances, category, event_name, type,
+                                    std::forward<TrackType>(track),
+                                    std::forward<Arguments>(args)...);
   }
 
   // Trace point which takes a timestamp, but not track.
@@ -18170,12 +22552,13 @@ class TrackEventDataSource
             typename... Arguments,
             typename TimestampTypeCheck = typename std::enable_if<
                 IsValidTimestamp<TimestampType>()>::type>
-  static void TraceForCategory(uint32_t instances,
-                               const CategoryType& category,
-                               const EventNameType& event_name,
-                               perfetto::protos::pbzero::TrackEvent::Type type,
-                               TimestampType&& timestamp,
-                               Arguments&&... args) PERFETTO_NO_INLINE {
+  static void TraceForCategoryBody(
+      uint32_t instances,
+      const CategoryType& category,
+      const EventNameType& event_name,
+      perfetto::protos::pbzero::TrackEvent::Type type,
+      TimestampType&& timestamp,
+      Arguments&&... args) PERFETTO_NO_INLINE {
     TraceForCategoryImpl(instances, category, event_name, type,
                          TrackEventInternal::kDefaultTrack,
                          std::forward<TimestampType>(timestamp),
@@ -18192,13 +22575,14 @@ class TrackEventDataSource
                 std::is_convertible<TrackType, Track>::value>::type,
             typename TimestampTypeCheck = typename std::enable_if<
                 IsValidTimestamp<TimestampType>()>::type>
-  static void TraceForCategory(uint32_t instances,
-                               const CategoryType& category,
-                               const EventNameType& event_name,
-                               perfetto::protos::pbzero::TrackEvent::Type type,
-                               TrackType&& track,
-                               TimestampType&& timestamp,
-                               Arguments&&... args) PERFETTO_NO_INLINE {
+  static void TraceForCategoryBody(
+      uint32_t instances,
+      const CategoryType& category,
+      const EventNameType& event_name,
+      perfetto::protos::pbzero::TrackEvent::Type type,
+      TrackType&& track,
+      TimestampType&& timestamp,
+      Arguments&&... args) PERFETTO_NO_INLINE {
     TraceForCategoryImpl(instances, category, event_name, type,
                          std::forward<TrackType>(track),
                          std::forward<TimestampType>(timestamp),
@@ -18207,12 +22591,13 @@ class TrackEventDataSource
 
   // Trace point with with a counter sample.
   template <typename CategoryType, typename EventNameType, typename ValueType>
-  static void TraceForCategory(uint32_t instances,
-                               const CategoryType& category,
-                               const EventNameType&,
-                               perfetto::protos::pbzero::TrackEvent::Type type,
-                               CounterTrack track,
-                               ValueType value) PERFETTO_ALWAYS_INLINE {
+  static void TraceForCategoryBody(
+      uint32_t instances,
+      const CategoryType& category,
+      const EventNameType&,
+      perfetto::protos::pbzero::TrackEvent::Type type,
+      CounterTrack track,
+      ValueType value) PERFETTO_ALWAYS_INLINE {
     PERFETTO_DCHECK(type == perfetto::protos::pbzero::TrackEvent::TYPE_COUNTER);
     TraceForCategory(instances, category, /*name=*/nullptr, type, track,
                      TrackEventInternal::GetTraceTime(), value);
@@ -18225,13 +22610,14 @@ class TrackEventDataSource
             typename TimestampTypeCheck = typename std::enable_if<
                 IsValidTimestamp<TimestampType>()>::type,
             typename ValueType>
-  static void TraceForCategory(uint32_t instances,
-                               const CategoryType& category,
-                               const EventNameType&,
-                               perfetto::protos::pbzero::TrackEvent::Type type,
-                               CounterTrack track,
-                               TimestampType timestamp,
-                               ValueType value) PERFETTO_ALWAYS_INLINE {
+  static void TraceForCategoryBody(
+      uint32_t instances,
+      const CategoryType& category,
+      const EventNameType&,
+      perfetto::protos::pbzero::TrackEvent::Type type,
+      CounterTrack track,
+      TimestampType timestamp,
+      ValueType value) PERFETTO_NO_INLINE {
     PERFETTO_DCHECK(type == perfetto::protos::pbzero::TrackEvent::TYPE_COUNTER);
     TraceForCategoryImpl(
         instances, category, /*name=*/nullptr, type, track, timestamp,
@@ -18257,66 +22643,133 @@ class TrackEventDataSource
         });
   }
 
-  // Initialize the track event library. Should be called before tracing is
-  // enabled.
-  static bool Register() {
-    // Registration is performed out-of-line so users don't need to depend on
-    // DataSourceDescriptor C++ bindings.
-    return TrackEventInternal::Initialize(
-        *Registry,
-        [](const DataSourceDescriptor& dsd) { return Base::Register(dsd); });
-  }
-
-  // Record metadata about different types of timeline tracks. See Track.
-  static void SetTrackDescriptor(const Track& track,
-                                 const protos::gen::TrackDescriptor& desc) {
-    PERFETTO_DCHECK(track.uuid == desc.uuid());
-    TrackRegistry::Get()->UpdateTrack(track, desc.SerializeAsString());
-    Base::template Trace([&](typename Base::TraceContext ctx) {
-      TrackEventInternal::WriteTrackDescriptor(
-          track, ctx.tls_inst_->trace_writer.get(), ctx.GetIncrementalState(),
-          *ctx.GetCustomTlsState(), TrackEventInternal::GetTraceTime());
-    });
-  }
-
-  // DEPRECATED. Only kept for backwards compatibility.
-  static void SetTrackDescriptor(
-      const Track& track,
-      std::function<void(protos::pbzero::TrackDescriptor*)> callback) {
-    SetTrackDescriptorImpl(track, std::move(callback));
-  }
-
-  // DEPRECATED. Only kept for backwards compatibility.
-  static void SetProcessDescriptor(
-      std::function<void(protos::pbzero::TrackDescriptor*)> callback,
-      const ProcessTrack& track = ProcessTrack::Current()) {
-    SetTrackDescriptorImpl(std::move(track), std::move(callback));
+// Additional trace points used in legacy macros.
+// It's possible to implement legacy macros using a common TraceForCategory,
+// by supplying a lambda that sets all necessary legacy fields. But this
+// results in a binary size bloat because every trace point generates its own
+// template instantiation with its own lambda. ICF can't eliminate those as
+// each lambda captures different variables and so the code is not completely
+// identical.
+// What we do instead is define additional TraceForCategoryLegacy templates
+// that take legacy arguments directly. Their instantiations can have the same
+// binary code for at least some macro invocations and so can be successfully
+// folded by the linker.
+#if PERFETTO_ENABLE_LEGACY_TRACE_EVENTS
+  template <typename TrackType,
+            typename CategoryType,
+            typename EventNameType,
+            typename... Arguments,
+            typename TrackTypeCheck = typename std::enable_if<
+                std::is_convertible<TrackType, Track>::value>::type>
+  static void TraceForCategoryLegacyBody(
+      uint32_t instances,
+      const CategoryType& category,
+      const EventNameType& event_name,
+      perfetto::protos::pbzero::TrackEvent::Type type,
+      TrackType&& track,
+      char phase,
+      uint32_t flags,
+      Arguments&&... args) PERFETTO_NO_INLINE {
+    TraceForCategoryImplNoTimestamp(
+        instances, category, event_name, type, track,
+        [&](perfetto::EventContext ctx) PERFETTO_NO_THREAD_SAFETY_ANALYSIS {
+          using ::perfetto::internal::TrackEventLegacy;
+          TrackEventLegacy::WriteLegacyEvent(std::move(ctx), phase, flags,
+                                             args...);
+        });
   }
 
-  // DEPRECATED. Only kept for backwards compatibility.
-  static void SetThreadDescriptor(
-      std::function<void(protos::pbzero::TrackDescriptor*)> callback,
-      const ThreadTrack& track = ThreadTrack::Current()) {
-    SetTrackDescriptorImpl(std::move(track), std::move(callback));
+  template <typename TrackType,
+            typename CategoryType,
+            typename EventNameType,
+            typename TimestampType = uint64_t,
+            typename... Arguments,
+            typename TrackTypeCheck = typename std::enable_if<
+                std::is_convertible<TrackType, Track>::value>::type,
+            typename TimestampTypeCheck = typename std::enable_if<
+                IsValidTimestamp<TimestampType>()>::type>
+  static void TraceForCategoryLegacyBody(
+      uint32_t instances,
+      const CategoryType& category,
+      const EventNameType& event_name,
+      perfetto::protos::pbzero::TrackEvent::Type type,
+      TrackType&& track,
+      char phase,
+      uint32_t flags,
+      TimestampType&& timestamp,
+      Arguments&&... args) PERFETTO_NO_INLINE {
+    TraceForCategoryImpl(
+        instances, category, event_name, type, track, timestamp,
+        [&](perfetto::EventContext ctx) PERFETTO_NO_THREAD_SAFETY_ANALYSIS {
+          using ::perfetto::internal::TrackEventLegacy;
+          TrackEventLegacy::WriteLegacyEvent(std::move(ctx), phase, flags,
+                                             args...);
+        });
   }
 
-  static void EraseTrackDescriptor(const Track& track) {
-    TrackRegistry::Get()->EraseTrack(track);
+  template <typename TrackType,
+            typename CategoryType,
+            typename EventNameType,
+            typename ThreadIdType,
+            typename LegacyIdType,
+            typename... Arguments,
+            typename TrackTypeCheck = typename std::enable_if<
+                std::is_convertible<TrackType, Track>::value>::type>
+  static void TraceForCategoryLegacyWithIdBody(
+      uint32_t instances,
+      const CategoryType& category,
+      const EventNameType& event_name,
+      perfetto::protos::pbzero::TrackEvent::Type type,
+      TrackType&& track,
+      char phase,
+      uint32_t flags,
+      ThreadIdType thread_id,
+      LegacyIdType legacy_id,
+      Arguments&&... args) PERFETTO_NO_INLINE {
+    TraceForCategoryImplNoTimestamp(
+        instances, category, event_name, type, track,
+        [&](perfetto::EventContext ctx) PERFETTO_NO_THREAD_SAFETY_ANALYSIS {
+          using ::perfetto::internal::TrackEventLegacy;
+          ::perfetto::internal::LegacyTraceId trace_id{legacy_id};
+          TrackEventLegacy::WriteLegacyEventWithIdAndTid(
+              std::move(ctx), phase, flags, trace_id, thread_id, args...);
+        });
   }
 
-  // Returns the current trace timestamp in nanoseconds. Note the returned
-  // timebase may vary depending on the platform, but will always match the
-  // timestamps recorded by track events (see GetTraceClockId).
-  static uint64_t GetTraceTimeNs() { return TrackEventInternal::GetTimeNs(); }
-
-  // Returns the type of clock used by GetTraceTimeNs().
-  static constexpr protos::pbzero::BuiltinClock GetTraceClockId() {
-    return TrackEventInternal::GetClockId();
+  template <typename TrackType,
+            typename CategoryType,
+            typename EventNameType,
+            typename ThreadIdType,
+            typename LegacyIdType,
+            typename TimestampType = uint64_t,
+            typename... Arguments,
+            typename TrackTypeCheck = typename std::enable_if<
+                std::is_convertible<TrackType, Track>::value>::type,
+            typename TimestampTypeCheck = typename std::enable_if<
+                IsValidTimestamp<TimestampType>()>::type>
+  static void TraceForCategoryLegacyWithIdBody(
+      uint32_t instances,
+      const CategoryType& category,
+      const EventNameType& event_name,
+      perfetto::protos::pbzero::TrackEvent::Type type,
+      TrackType&& track,
+      char phase,
+      uint32_t flags,
+      ThreadIdType thread_id,
+      LegacyIdType legacy_id,
+      TimestampType&& timestamp,
+      Arguments&&... args) PERFETTO_NO_INLINE {
+    TraceForCategoryImpl(
+        instances, category, event_name, type, track, timestamp,
+        [&](perfetto::EventContext ctx) PERFETTO_NO_THREAD_SAFETY_ANALYSIS {
+          using ::perfetto::internal::TrackEventLegacy;
+          ::perfetto::internal::LegacyTraceId trace_id{legacy_id};
+          TrackEventLegacy::WriteLegacyEventWithIdAndTid(
+              std::move(ctx), phase, flags, trace_id, thread_id, args...);
+        });
   }
+#endif  // PERFETTO_ENABLE_LEGACY_TRACE_EVENTS
 
-  const protos::gen::TrackEventConfig& GetConfig() const { return config_; }
-
- private:
   // Each category has its own enabled/disabled state, stored in the category
   // registry.
   struct CategoryTracePointTraits {
@@ -18333,6 +22786,117 @@ class TrackEventDataSource
     }
   };
 
+  template <typename CategoryType,
+            typename EventNameType,
+            typename TrackType = Track,
+            typename TrackTypeCheck =
+                typename std::enable_if<IsValidTrack<TrackType>()>::type>
+  static perfetto::EventContext WriteTrackEventImpl(
+      TrackEventDataSource::TraceContext& ctx,
+      const CategoryType& category,
+      const EventNameType& event_name,
+      perfetto::protos::pbzero::TrackEvent::Type type,
+      const TrackType& track,
+      const TraceTimestamp& trace_timestamp) PERFETTO_ALWAYS_INLINE {
+    using CatTraits = CategoryTraits<CategoryType>;
+    const Category* static_category =
+        CatTraits::GetStaticCategory(Registry, category);
+
+    TrackEventTlsState& tls_state = *ctx.GetCustomTlsState();
+    TraceWriterBase* trace_writer = ctx.tls_inst_->trace_writer.get();
+    // Make sure incremental state is valid.
+    TrackEventIncrementalState* incr_state = ctx.GetIncrementalState();
+    TrackEventInternal::ResetIncrementalStateIfRequired(
+        trace_writer, incr_state, tls_state, trace_timestamp);
+
+    // Write the track descriptor before any event on the track.
+    if (track) {
+      TrackEventInternal::WriteTrackDescriptorIfNeeded(
+          track, trace_writer, incr_state, tls_state, trace_timestamp);
+    }
+
+    // Write the event itself.
+    bool on_current_thread_track =
+        (&track == &TrackEventInternal::kDefaultTrack);
+    auto event_ctx = TrackEventInternal::WriteEvent(
+        trace_writer, incr_state, tls_state, static_category, type,
+        trace_timestamp, on_current_thread_track);
+    // event name should be emitted with `TRACE_EVENT_BEGIN` macros
+    // but not with `TRACE_EVENT_END`.
+    if (type != protos::pbzero::TrackEvent::TYPE_SLICE_END) {
+      TrackEventInternal::WriteEventName(event_name, event_ctx, tls_state);
+    }
+    // Write dynamic categories (except for events that don't require
+    // categories). For counter events, the counter name (and optional
+    // category) is stored as part of the track descriptor instead being
+    // recorded with individual events.
+    if (CatTraits::kIsDynamic &&
+        type != protos::pbzero::TrackEvent::TYPE_SLICE_END &&
+        type != protos::pbzero::TrackEvent::TYPE_COUNTER) {
+      DynamicCategory dynamic_category =
+          CatTraits::GetDynamicCategory(category);
+      Category cat = Category::FromDynamicCategory(dynamic_category);
+      cat.ForEachGroupMember([&](const char* member_name, size_t name_size) {
+        event_ctx.event()->add_categories(member_name, name_size);
+        return true;
+      });
+    }
+    if (type == protos::pbzero::TrackEvent::TYPE_UNSPECIFIED) {
+      // Explicitly clear the track, so that the event is not associated
+      // with the default track, but instead uses the legacy mechanism
+      // based on the phase and pid/tid override.
+      event_ctx.event()->set_track_uuid(0);
+    } else if (!on_current_thread_track) {
+      // We emit these events using TrackDescriptors, and we cannot emit
+      // events on behalf of other processes using the TrackDescriptor
+      // format. Chrome is the only user of events with explicit process
+      // ids and currently only Chrome emits PHASE_MEMORY_DUMP events
+      // with an explicit process id, so we should be fine here.
+      // TODO(mohitms): Get rid of events with explicit process ids
+      // entirely.
+      event_ctx.event()->set_track_uuid(track.uuid);
+    }
+
+    return event_ctx;
+  }
+
+  template <typename CategoryType,
+            typename EventNameType,
+            typename TrackType = Track,
+            typename TimestampType = uint64_t,
+            typename TimestampTypeCheck = typename std::enable_if<
+                IsValidTimestamp<TimestampType>()>::type,
+            typename TrackTypeCheck =
+                typename std::enable_if<IsValidTrack<TrackType>()>::type>
+  static perfetto::EventContext WriteTrackEvent(
+      TrackEventDataSource::TraceContext& ctx,
+      const CategoryType& category,
+      const EventNameType& event_name,
+      perfetto::protos::pbzero::TrackEvent::Type type,
+      const TrackType& track,
+      const TimestampType& timestamp) PERFETTO_NO_INLINE {
+    TraceTimestamp trace_timestamp = ::perfetto::TraceTimestampTraits<
+        TimestampType>::ConvertTimestampToTraceTimeNs(timestamp);
+    return WriteTrackEventImpl(ctx, category, event_name, type, track,
+                               trace_timestamp);
+  }
+
+  template <typename CategoryType,
+            typename EventNameType,
+            typename TrackType = Track,
+            typename TrackTypeCheck =
+                typename std::enable_if<IsValidTrack<TrackType>()>::type>
+  static perfetto::EventContext WriteTrackEvent(
+      TrackEventDataSource::TraceContext& ctx,
+      const CategoryType& category,
+      const EventNameType& event_name,
+      perfetto::protos::pbzero::TrackEvent::Type type,
+      const TrackType& track) PERFETTO_NO_INLINE {
+    TraceTimestamp trace_timestamp = TrackEventInternal::GetTraceTime();
+    return WriteTrackEventImpl(ctx, category, event_name, type, track,
+                               trace_timestamp);
+  }
+
   template <typename CategoryType,
             typename EventNameType,
             typename TrackType = Track,
@@ -18351,10 +22915,8 @@ class TrackEventDataSource
       const TimestampType& timestamp,
       Arguments&&... args) PERFETTO_ALWAYS_INLINE {
     using CatTraits = CategoryTraits<CategoryType>;
-    const Category* static_category =
-        CatTraits::GetStaticCategory(Registry, category);
     TraceWithInstances(
-        instances, category, [&](typename Base::TraceContext ctx) {
+        instances, category, [&](TrackEventDataSource::TraceContext ctx) {
           // If this category is dynamic, first check whether it's enabled.
           if (CatTraits::kIsDynamic &&
               !IsDynamicCategoryEnabled(
@@ -18362,69 +22924,40 @@ class TrackEventDataSource
             return;
           }
 
-          const TrackEventTlsState& tls_state = *ctx.GetCustomTlsState();
-          TraceTimestamp trace_timestamp = ::perfetto::TraceTimestampTraits<
-              TimestampType>::ConvertTimestampToTraceTimeNs(timestamp);
-
-          TraceWriterBase* trace_writer = ctx.tls_inst_->trace_writer.get();
-          // Make sure incremental state is valid.
-          TrackEventIncrementalState* incr_state = ctx.GetIncrementalState();
-          TrackEventInternal::ResetIncrementalStateIfRequired(
-              trace_writer, incr_state, tls_state, trace_timestamp);
+          auto event_ctx = WriteTrackEvent(ctx, category, event_name, type,
+                                           track, timestamp);
+          WriteTrackEventArgs(std::move(event_ctx),
+                              std::forward<Arguments>(args)...);
+        });
+  }
 
-          // Write the track descriptor before any event on the track.
-          if (track) {
-            TrackEventInternal::WriteTrackDescriptorIfNeeded(
-                track, trace_writer, incr_state, tls_state, trace_timestamp);
+  template <typename CategoryType,
+            typename EventNameType,
+            typename TrackType = Track,
+            typename TrackTypeCheck =
+                typename std::enable_if<IsValidTrack<TrackType>()>::type,
+            typename... Arguments>
+  static void TraceForCategoryImplNoTimestamp(
+      uint32_t instances,
+      const CategoryType& category,
+      const EventNameType& event_name,
+      perfetto::protos::pbzero::TrackEvent::Type type,
+      const TrackType& track,
+      Arguments&&... args) PERFETTO_ALWAYS_INLINE {
+    using CatTraits = CategoryTraits<CategoryType>;
+    TraceWithInstances(
+        instances, category, [&](TrackEventDataSource::TraceContext ctx) {
+          // If this category is dynamic, first check whether it's enabled.
+          if (CatTraits::kIsDynamic &&
+              !IsDynamicCategoryEnabled(
+                  &ctx, CatTraits::GetDynamicCategory(category))) {
+            return;
           }
 
-          // Write the event itself.
-          {
-            bool on_current_thread_track =
-                (&track == &TrackEventInternal::kDefaultTrack);
-            auto event_ctx = TrackEventInternal::WriteEvent(
-                trace_writer, incr_state, tls_state, static_category, type,
-                trace_timestamp, on_current_thread_track);
-            // event name should be emitted with `TRACE_EVENT_BEGIN` macros
-            // but not with `TRACE_EVENT_END`.
-            if (type != protos::pbzero::TrackEvent::TYPE_SLICE_END) {
-              TrackEventInternal::WriteEventName(event_name, event_ctx,
-                                                 tls_state);
-            }
-            // Write dynamic categories (except for events that don't require
-            // categories). For counter events, the counter name (and optional
-            // category) is stored as part of the track descriptor instead being
-            // recorded with individual events.
-            if (CatTraits::kIsDynamic &&
-                type != protos::pbzero::TrackEvent::TYPE_SLICE_END &&
-                type != protos::pbzero::TrackEvent::TYPE_COUNTER) {
-              DynamicCategory dynamic_category =
-                  CatTraits::GetDynamicCategory(category);
-              Category cat = Category::FromDynamicCategory(dynamic_category);
-              cat.ForEachGroupMember(
-                  [&](const char* member_name, size_t name_size) {
-                    event_ctx.event()->add_categories(member_name, name_size);
-                    return true;
-                  });
-            }
-            if (type == protos::pbzero::TrackEvent::TYPE_UNSPECIFIED) {
-              // Explicitly clear the track, so that the event is not associated
-              // with the default track, but instead uses the legacy mechanism
-              // based on the phase and pid/tid override.
-              event_ctx.event()->set_track_uuid(0);
-            } else if (!on_current_thread_track) {
-              // We emit these events using TrackDescriptors, and we cannot emit
-              // events on behalf of other processes using the TrackDescriptor
-              // format. Chrome is the only user of events with explicit process
-              // ids and currently only Chrome emits PHASE_MEMORY_DUMP events
-              // with an explicit process id, so we should be fine here.
-              // TODO(mohitms): Get rid of events with explicit process ids
-              // entirely.
-              event_ctx.event()->set_track_uuid(track.uuid);
-            }
-            WriteTrackEventArgs(std::move(event_ctx),
-                                std::forward<Arguments>(args)...);
-          }  // event_ctx
+          auto event_ctx =
+              WriteTrackEvent(ctx, category, event_name, type, track);
+          WriteTrackEventArgs(std::move(event_ctx),
+                              std::forward<Arguments>(args)...);
         });
   }
 
@@ -18434,32 +22967,18 @@ class TrackEventDataSource
                                  Lambda lambda) PERFETTO_ALWAYS_INLINE {
     using CatTraits = CategoryTraits<CategoryType>;
     if (CatTraits::kIsDynamic) {
-      Base::template TraceWithInstances(instances, std::move(lambda));
+      TrackEventDataSource::TraceWithInstances(instances, std::move(lambda));
     } else {
-      Base::template TraceWithInstances<CategoryTracePointTraits>(
+      TrackEventDataSource::TraceWithInstances<CategoryTracePointTraits>(
           instances, std::move(lambda), {CatTraits::GetStaticIndex(category)});
     }
   }
 
-  // Records a track descriptor into the track descriptor registry and, if we
-  // are tracing, also mirrors the descriptor into the trace.
-  template <typename TrackType>
-  static void SetTrackDescriptorImpl(
-      const TrackType& track,
-      std::function<void(protos::pbzero::TrackDescriptor*)> callback) {
-    TrackRegistry::Get()->UpdateTrack(track, std::move(callback));
-    Base::template Trace([&](typename Base::TraceContext ctx) {
-      TrackEventInternal::WriteTrackDescriptor(
-          track, ctx.tls_inst_->trace_writer.get(), ctx.GetIncrementalState(),
-          *ctx.GetCustomTlsState(), TrackEventInternal::GetTraceTime());
-    });
-  }
-
   // Determines if the given dynamic category is enabled, first by checking the
   // per-trace writer cache or by falling back to computing it based on the
   // trace config for the given session.
   static bool IsDynamicCategoryEnabled(
-      typename Base::TraceContext* ctx,
+      TrackEventDataSource::TraceContext* ctx,
       const DynamicCategory& dynamic_category) {
     auto incr_state = ctx->GetIncrementalState();
     auto it = incr_state->dynamic_categories.find(dynamic_category.name);
@@ -18467,9 +22986,12 @@ class TrackEventDataSource
       // We haven't seen this category before. Let's figure out if it's enabled.
       // This requires grabbing a lock to read the session's trace config.
       auto ds = ctx->GetDataSourceLocked();
+      if (!ds) {
+        return false;
+      }
       Category category{Category::FromDynamicCategory(dynamic_category)};
       bool enabled = TrackEventInternal::IsCategoryEnabled(
-          *Registry, ds->config_, category);
+          *Registry, ds->GetConfig(), category);
       // TODO(skyostil): Cap the size of |dynamic_categories|.
       incr_state->dynamic_categories[dynamic_category.name] = enabled;
       return enabled;
@@ -18484,6 +23006,11 @@ class TrackEventDataSource
 }  // namespace internal
 }  // namespace perfetto
 
+PERFETTO_DECLARE_DATA_SOURCE_STATIC_MEMBERS_WITH_ATTRS(
+    PERFETTO_EXPORT_COMPONENT,
+    perfetto::internal::TrackEventDataSource,
+    perfetto::internal::TrackEventDataSourceTraits);
+
 #endif  // INCLUDE_PERFETTO_TRACING_INTERNAL_TRACK_EVENT_DATA_SOURCE_H_
 // gen_amalgamated begin header: include/perfetto/tracing/internal/track_event_macros.h
 /*
@@ -18509,14 +23036,24 @@ class TrackEventDataSource
 // implementation. Perfetto API users typically don't need to use anything here
 // directly.
 
-// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
+// gen_amalgamated expanded: #include "perfetto/base/thread_annotations.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/internal/track_event_data_source.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/string_helpers.h"
 // gen_amalgamated expanded: #include "perfetto/tracing/track_event_category_registry.h"
 
-// Ignore GCC warning about a missing argument for a variadic macro parameter.
 #if defined(__GNUC__) || defined(__clang__)
+#if defined(__clang__)
+#pragma clang diagnostic push
+// Fix 'error: #pragma system_header ignored in main file' for clang in Google3.
+#pragma clang diagnostic ignored "-Wpragma-system-header-outside-header"
+#endif
+
+// Ignore GCC warning about a missing argument for a variadic macro parameter.
 #pragma GCC system_header
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
 #endif
 
 // Defines data structures for backing a category registry.
@@ -18531,8 +23068,8 @@ class TrackEventDataSource
 //
 #define PERFETTO_INTERNAL_DECLARE_CATEGORIES(attrs, ...)                      \
   namespace internal {                                                        \
-  constexpr ::perfetto::Category kCategories[] = {__VA_ARGS__};               \
-  constexpr size_t kCategoryCount =                                           \
+  inline constexpr ::perfetto::Category kCategories[] = {__VA_ARGS__};        \
+  inline constexpr size_t kCategoryCount =                                    \
       sizeof(kCategories) / sizeof(kCategories[0]);                           \
   /* The per-instance enable/disable state per category */                    \
   attrs extern std::atomic<uint8_t> g_category_state_storage[kCategoryCount]; \
@@ -18554,7 +23091,7 @@ class TrackEventDataSource
   /* https://bugs.llvm.org/show_bug.cgi?id=51558 */                           \
   /**/                                                                        \
   /* TODO(skyostil): Unify these using a C++17 inline constexpr variable. */  \
-  constexpr ::perfetto::internal::TrackEventCategoryRegistry                  \
+  inline constexpr ::perfetto::internal::TrackEventCategoryRegistry           \
       kConstExprCategoryRegistry(kCategoryCount, &kCategories[0], nullptr);   \
   attrs extern const ::perfetto::internal::TrackEventCategoryRegistry         \
       kCategoryRegistry;                                                      \
@@ -18575,14 +23112,12 @@ class TrackEventDataSource
 // Defines the TrackEvent data source for the current track event namespace.
 // `virtual ~TrackEvent` is added to avoid `-Wweak-vtables` warning.
 // Learn more : aosp/2019906
-#define PERFETTO_INTERNAL_DECLARE_TRACK_EVENT_DATA_SOURCE(attrs)               \
-  struct attrs TrackEvent : public ::perfetto::internal::TrackEventDataSource< \
-                                TrackEvent, &internal::kCategoryRegistry> {    \
-    virtual ~TrackEvent();                                                     \
-  }
+#define PERFETTO_INTERNAL_DECLARE_TRACK_EVENT_DATA_SOURCE(attrs) \
+  struct attrs PERFETTO_COMPONENT_EXPORT TrackEvent              \
+      : public ::perfetto::internal::TrackEvent<                 \
+            &internal::kCategoryRegistry> {}
 
-#define PERFETTO_INTERNAL_DEFINE_TRACK_EVENT_DATA_SOURCE() \
-  TrackEvent::~TrackEvent() = default;
+#define PERFETTO_INTERNAL_DEFINE_TRACK_EVENT_DATA_SOURCE()
 
 // At compile time, turns a category name represented by a static string into an
 // index into the current category registry. A build error will be generated if
@@ -18598,33 +23133,51 @@ class TrackEventDataSource
 #define PERFETTO_INTERNAL_CONCAT(a, b) PERFETTO_INTERNAL_CONCAT2(a, b)
 #define PERFETTO_UID(prefix) PERFETTO_INTERNAL_CONCAT(prefix, __LINE__)
 
+#if PERFETTO_BUILDFLAG(PERFETTO_COMPILER_MSVC)
+// MSVC with /permissive- fails to build without this. Probably a compiler bug.
+#define PERFETTO_INTERNAL_STATIC_FOR_MSVC static
+#else
+// On the other hand, if we add static with clang, binary size of the chromium
+// build will increase dramatically.
+#define PERFETTO_INTERNAL_STATIC_FOR_MSVC
+#endif
+
 // Efficiently determines whether tracing is enabled for the given category, and
 // if so, emits one trace event with the given arguments.
-#define PERFETTO_INTERNAL_TRACK_EVENT(category, name, ...)                     \
+#define PERFETTO_INTERNAL_TRACK_EVENT_WITH_METHOD(method, category, name, ...) \
   do {                                                                         \
-    ::perfetto::internal::ValidateEventNameType<decltype(name)>();             \
+    /* Double parentheses allow decltype to detect the value category, */      \
+    /* enabling the detection of variables (lvalues) vs temporaries. */        \
+    ::perfetto::internal::ValidateEventNameType<decltype((name))>();           \
     namespace tns = PERFETTO_TRACK_EVENT_NAMESPACE;                            \
-    /* Compute the category index outside the lambda to work around a */       \
-    /* GCC 7 bug */                                                            \
-    constexpr auto PERFETTO_UID(                                               \
+    /* Compute the category index outside the lambda to work around a GCC 7 */ \
+    /* bug. */                                                                 \
+    /* This is more efficient as a non-static because it's passed into */      \
+    /* `method` by reference, so the compiler needs to take the address. */    \
+    /* Taking the address of a variable with static storage duration, held */  \
+    /* in .rodata, is more expensive than the address of a local. */           \
+    PERFETTO_INTERNAL_STATIC_FOR_MSVC constexpr size_t PERFETTO_UID(           \
         kCatIndex_ADD_TO_PERFETTO_DEFINE_CATEGORIES_IF_FAILS_) =               \
         PERFETTO_GET_CATEGORY_INDEX(category);                                 \
     if (::PERFETTO_TRACK_EVENT_NAMESPACE::internal::IsDynamicCategory(         \
             category)) {                                                       \
       tns::TrackEvent::CallIfEnabled(                                          \
           [&](uint32_t instances) PERFETTO_NO_THREAD_SAFETY_ANALYSIS {         \
-            tns::TrackEvent::TraceForCategory(instances, category, name,       \
-                                              ##__VA_ARGS__);                  \
+            tns::TrackEvent::method(                                           \
+                instances, category,                                           \
+                ::perfetto::internal::DecayEventNameType(name),                \
+                ##__VA_ARGS__);                                                \
           });                                                                  \
     } else {                                                                   \
       tns::TrackEvent::CallIfCategoryEnabled(                                  \
           PERFETTO_UID(kCatIndex_ADD_TO_PERFETTO_DEFINE_CATEGORIES_IF_FAILS_), \
           [&](uint32_t instances) PERFETTO_NO_THREAD_SAFETY_ANALYSIS {         \
-            tns::TrackEvent::TraceForCategory(                                 \
+            tns::TrackEvent::method(                                           \
                 instances,                                                     \
                 PERFETTO_UID(                                                  \
                     kCatIndex_ADD_TO_PERFETTO_DEFINE_CATEGORIES_IF_FAILS_),    \
-                name, ##__VA_ARGS__);                                          \
+                ::perfetto::internal::DecayEventNameType(name),                \
+                ##__VA_ARGS__);                                                \
           });                                                                  \
     }                                                                          \
   } while (false)
@@ -18632,13 +23185,13 @@ class TrackEventDataSource
 // C++17 doesn't like a move constructor being defined for the EventFinalizer
 // class but C++11 and MSVC doesn't compile without it being defined so support
 // both.
-#if PERFETTO_IS_AT_LEAST_CPP17() && !PERFETTO_BUILDFLAG(PERFETTO_COMPILER_MSVC)
+#if !PERFETTO_BUILDFLAG(PERFETTO_COMPILER_MSVC)
 #define PERFETTO_INTERNAL_EVENT_FINALIZER_KEYWORD delete
 #else
 #define PERFETTO_INTERNAL_EVENT_FINALIZER_KEYWORD default
 #endif
 
-#define PERFETTO_INTERNAL_SCOPED_TRACK_EVENT(category, name, ...)             \
+#define PERFETTO_INTERNAL_SCOPED_EVENT_FINALIZER(category)                    \
   struct PERFETTO_UID(ScopedEvent) {                                          \
     struct EventFinalizer {                                                   \
       /* The parameter is an implementation detail. It allows the          */ \
@@ -18649,7 +23202,9 @@ class TrackEventDataSource
       /* that the scoped event is exactly ONE line and can't escape the    */ \
       /* scope if used in a single line if statement.                      */ \
       EventFinalizer(...) {}                                                  \
-      ~EventFinalizer() { TRACE_EVENT_END(category); }                        \
+      ~EventFinalizer() {                                                     \
+        TRACE_EVENT_END(category);                                            \
+      }                                                                       \
                                                                               \
       EventFinalizer(const EventFinalizer&) = delete;                         \
       inline EventFinalizer& operator=(const EventFinalizer&) = delete;       \
@@ -18658,14 +23213,36 @@ class TrackEventDataSource
           PERFETTO_INTERNAL_EVENT_FINALIZER_KEYWORD;                          \
       EventFinalizer& operator=(EventFinalizer&&) = delete;                   \
     } finalizer;                                                              \
-  } PERFETTO_UID(scoped_event) {                                              \
-    [&]() {                                                                   \
-      TRACE_EVENT_BEGIN(category, name, ##__VA_ARGS__);                       \
-      return 0;                                                               \
-    }()                                                                       \
   }
 
-#if PERFETTO_BUILDFLAG(PERFETTO_COMPILER_GCC)
+#define PERFETTO_INTERNAL_SCOPED_TRACK_EVENT(category, name, ...) \
+  PERFETTO_INTERNAL_SCOPED_EVENT_FINALIZER(category)              \
+  PERFETTO_UID(scoped_event) {                                    \
+    [&]() {                                                       \
+      TRACE_EVENT_BEGIN(category, name, ##__VA_ARGS__);           \
+      return 0;                                                   \
+    }()                                                           \
+  }
+
+#if PERFETTO_ENABLE_LEGACY_TRACE_EVENTS
+// Required for TRACE_EVENT_WITH_FLOW legacy macros, which pass the bind_id as
+// id.
+#define PERFETTO_INTERNAL_SCOPED_LEGACY_TRACK_EVENT_WITH_ID(               \
+    category, name, track, flags, thread_id, id, ...)                      \
+  PERFETTO_INTERNAL_SCOPED_EVENT_FINALIZER(category)                       \
+  PERFETTO_UID(scoped_event) {                                             \
+    [&]() {                                                                \
+      PERFETTO_INTERNAL_TRACK_EVENT_WITH_METHOD(                           \
+          TraceForCategoryLegacyWithId, category, name,                    \
+          ::perfetto::protos::pbzero::TrackEvent::TYPE_SLICE_BEGIN, track, \
+          'B', flags, thread_id, id, ##__VA_ARGS__);                       \
+      return 0;                                                            \
+    }()                                                                    \
+  }
+#endif  // PERFETTO_ENABLE_LEGACY_TRACE_EVENTS
+
+#if PERFETTO_BUILDFLAG(PERFETTO_COMPILER_GCC) || \
+    PERFETTO_BUILDFLAG(PERFETTO_COMPILER_MSVC)
 // On GCC versions <9 there's a bug that prevents using captured constant
 // variables in constexpr evaluation inside a lambda:
 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82643
@@ -18839,13 +23416,16 @@ class TrackEventDataSource
 // If the program uses multiple track event namespaces, category & track event
 // registration (see quickstart above) needs to happen for both namespaces
 // separately.
+
 #ifndef PERFETTO_TRACK_EVENT_NAMESPACE
 #define PERFETTO_TRACK_EVENT_NAMESPACE perfetto_track_event
 #endif
 
 // Deprecated; see perfetto::Category().
 #define PERFETTO_CATEGORY(name) \
-  ::perfetto::Category { #name }
+  ::perfetto::Category {        \
+    #name                       \
+  }
 
 // Internal helpers for determining if a given category is defined at build or
 // runtime.
@@ -18902,9 +23482,7 @@ constexpr bool IsDynamicCategory(const ::perfetto::DynamicCategory&) {
   } /* namespace PERFETTO_TRACK_EVENT_NAMESPACE  */                        \
   using PERFETTO_TRACK_EVENT_NAMESPACE::TrackEvent;                        \
   } /* namespace ns */                                                     \
-  PERFETTO_DECLARE_DATA_SOURCE_STATIC_MEMBERS_WITH_ATTRS(                  \
-      attrs, ns::PERFETTO_TRACK_EVENT_NAMESPACE::TrackEvent,               \
-      ::perfetto::internal::TrackEventDataSourceTraits)
+  PERFETTO_INTERNAL_SWALLOW_SEMICOLON()
 
 // Register the set of available categories by passing a list of categories to
 // this macro: perfetto::Category("cat1"), perfetto::Category("cat2"), ...
@@ -18950,9 +23528,7 @@ constexpr bool IsDynamicCategory(const ::perfetto::DynamicCategory&) {
   PERFETTO_INTERNAL_DEFINE_TRACK_EVENT_DATA_SOURCE()                           \
   } /* namespace PERFETTO_TRACK_EVENT_NAMESPACE */                             \
   } /* namespace ns */                                                         \
-  PERFETTO_DEFINE_DATA_SOURCE_STATIC_MEMBERS_WITH_ATTRS(                       \
-      attrs, ns::PERFETTO_TRACK_EVENT_NAMESPACE::TrackEvent,                   \
-      ::perfetto::internal::TrackEventDataSourceTraits)
+  PERFETTO_INTERNAL_SWALLOW_SEMICOLON()
 
 // Allocate storage for each category by using this macro once per track event
 // namespace.
@@ -18965,9 +23541,19 @@ constexpr bool IsDynamicCategory(const ::perfetto::DynamicCategory&) {
 #define PERFETTO_TRACK_EVENT_STATIC_STORAGE() \
   PERFETTO_TRACK_EVENT_STATIC_STORAGE_IN_NAMESPACE(perfetto)
 
-// Ignore GCC warning about a missing argument for a variadic macro parameter.
 #if defined(__GNUC__) || defined(__clang__)
+#if defined(__clang__)
+#pragma clang diagnostic push
+// Fix 'error: #pragma system_header ignored in main file' for clang in Google3.
+#pragma clang diagnostic ignored "-Wpragma-system-header-outside-header"
+#endif
+
+// Ignore GCC warning about a missing argument for a variadic macro parameter.
 #pragma GCC system_header
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
 #endif
 
 // Begin a slice under |category| with the title |name|. Both strings must be
@@ -19000,14 +23586,18 @@ constexpr bool IsDynamicCategory(const ::perfetto::DynamicCategory&) {
 // 1. A lambda for writing custom TrackEvent fields:
 //
 //   TRACE_EVENT("category", "Name", [&](perfetto::EventContext ctx) {
-//     ctx.event()->set_custom_value(...);
+//     auto* debug_annotation = ctx.event()->add_debug_annotations();
+//     debug_annotation->set_name("key");
+//     debug_annotation->set_string_value("value");
 //   });
 //
 // 2. A timestamp and a lambda:
 //
 //   TRACE_EVENT("category", "Name", time_in_nanoseconds,
 //       [&](perfetto::EventContext ctx) {
-//     ctx.event()->set_custom_value(...);
+//     auto* debug_annotation = ctx.event()->add_debug_annotations();
+//     debug_annotation->set_name("key");
+//     debug_annotation->set_string_value("value");
 //   });
 //
 //   |time_in_nanoseconds| should be an uint64_t by default. To support custom
@@ -19028,7 +23618,9 @@ constexpr bool IsDynamicCategory(const ::perfetto::DynamicCategory&) {
 //
 //   TRACE_EVENT("category", "Name", "arg", value,
 //       [&](perfetto::EventContext ctx) {
-//     ctx.event()->set_custom_value(...);
+//     auto* debug_annotation = ctx.event()->add_debug_annotations();
+//     debug_annotation->set_name("key");
+//     debug_annotation->set_string_value("value");
 //   });
 //
 // 5. An overridden track:
@@ -19041,7 +23633,9 @@ constexpr bool IsDynamicCategory(const ::perfetto::DynamicCategory&) {
 //
 //   TRACE_EVENT("category", "Name", perfetto::Track(1234),
 //       [&](perfetto::EventContext ctx) {
-//     ctx.event()->set_custom_value(...);
+//     auto* debug_annotation = ctx.event()->add_debug_annotations();
+//     debug_annotation->set_name("key");
+//     debug_annotation->set_string_value("value");
 //   });
 //
 // 7. A track and a timestamp:
@@ -19053,7 +23647,9 @@ constexpr bool IsDynamicCategory(const ::perfetto::DynamicCategory&) {
 //
 //   TRACE_EVENT("category", "Name", perfetto::Track(1234),
 //       time_in_nanoseconds, [&](perfetto::EventContext ctx) {
-//     ctx.event()->set_custom_value(...);
+//     auto* debug_annotation = ctx.event()->add_debug_annotations();
+//     debug_annotation->set_name("key");
+//     debug_annotation->set_string_value("value");
 //   });
 //
 // 9. A track and an arbitrary number of debug annotions:
@@ -19064,14 +23660,14 @@ constexpr bool IsDynamicCategory(const ::perfetto::DynamicCategory&) {
 //               "arg", value, "arg2", value2);
 //
 #define TRACE_EVENT_BEGIN(category, name, ...) \
-  PERFETTO_INTERNAL_TRACK_EVENT(               \
-      category, name,                          \
+  PERFETTO_INTERNAL_TRACK_EVENT_WITH_METHOD(   \
+      TraceForCategory, category, name,        \
       ::perfetto::protos::pbzero::TrackEvent::TYPE_SLICE_BEGIN, ##__VA_ARGS__)
 
 // End a slice under |category|.
-#define TRACE_EVENT_END(category, ...) \
-  PERFETTO_INTERNAL_TRACK_EVENT(       \
-      category, /*name=*/nullptr,      \
+#define TRACE_EVENT_END(category, ...)              \
+  PERFETTO_INTERNAL_TRACK_EVENT_WITH_METHOD(        \
+      TraceForCategory, category, /*name=*/nullptr, \
       ::perfetto::protos::pbzero::TrackEvent::TYPE_SLICE_END, ##__VA_ARGS__)
 
 // Begin a slice which gets automatically closed when going out of scope.
@@ -19079,10 +23675,10 @@ constexpr bool IsDynamicCategory(const ::perfetto::DynamicCategory&) {
   PERFETTO_INTERNAL_SCOPED_TRACK_EVENT(category, name, ##__VA_ARGS__)
 
 // Emit a slice which has zero duration.
-#define TRACE_EVENT_INSTANT(category, name, ...)                            \
-  PERFETTO_INTERNAL_TRACK_EVENT(                                            \
-      category, name, ::perfetto::protos::pbzero::TrackEvent::TYPE_INSTANT, \
-      ##__VA_ARGS__)
+#define TRACE_EVENT_INSTANT(category, name, ...) \
+  PERFETTO_INTERNAL_TRACK_EVENT_WITH_METHOD(     \
+      TraceForCategory, category, name,          \
+      ::perfetto::protos::pbzero::TrackEvent::TYPE_INSTANT, ##__VA_ARGS__)
 
 // Efficiently determine if the given static or dynamic trace category or
 // category group is enabled for tracing.
@@ -19127,8 +23723,8 @@ constexpr bool IsDynamicCategory(const ::perfetto::DynamicCategory&) {
 //   TRACE_COUNTER("category", "MyCounter", timestamp, value);
 //
 #define TRACE_COUNTER(category, track, ...)                 \
-  PERFETTO_INTERNAL_TRACK_EVENT(                            \
-      category, /*name=*/nullptr,                           \
+  PERFETTO_INTERNAL_TRACK_EVENT_WITH_METHOD(                \
+      TraceForCategory, category, /*name=*/nullptr,         \
       ::perfetto::protos::pbzero::TrackEvent::TYPE_COUNTER, \
       ::perfetto::CounterTrack(track), ##__VA_ARGS__)
 
@@ -19314,8 +23910,15 @@ class TrackEventInternedDataIndex
   static size_t Get(EventContext* ctx,
                     const ValueType& value,
                     Args&&... add_args) {
+    return Get(ctx->incremental_state_, value, std::forward<Args>(add_args)...);
+  }
+
+  template <typename... Args>
+  static size_t Get(internal::TrackEventIncrementalState* incremental_state,
+                    const ValueType& value,
+                    Args&&... add_args) {
     // First check if the value exists in the dictionary.
-    auto index_for_field = GetOrCreateIndexForField(ctx->incremental_state_);
+    auto index_for_field = GetOrCreateIndexForField(incremental_state);
     size_t iid;
     if (PERFETTO_LIKELY(index_for_field->index_.LookUpOrInsert(&iid, value))) {
       PERFETTO_DCHECK(iid);
@@ -19326,9 +23929,9 @@ class TrackEventInternedDataIndex
     // the heap buffered message (which is committed to the trace when the
     // packet ends).
     PERFETTO_DCHECK(iid);
-    InternedDataType::Add(
-        ctx->incremental_state_->serialized_interned_data.get(), iid,
-        std::move(value), std::forward<Args>(add_args)...);
+    InternedDataType::Add(incremental_state->serialized_interned_data.get(),
+                          iid, std::move(value),
+                          std::forward<Args>(add_args)...);
     return iid;
   }
 
@@ -19427,134 +24030,20 @@ class TrackEventInternedDataIndex
 #define PERFETTO_ENABLE_LEGACY_TRACE_EVENTS 0
 #endif
 
-// Ignore GCC warning about a missing argument for a variadic macro parameter.
 #if defined(__GNUC__) || defined(__clang__)
-#pragma GCC system_header
+#if defined(__clang__)
+#pragma clang diagnostic push
+// Fix 'error: #pragma system_header ignored in main file' for clang in Google3.
+#pragma clang diagnostic ignored "-Wpragma-system-header-outside-header"
 #endif
 
-// ----------------------------------------------------------------------------
-// Constants.
-// ----------------------------------------------------------------------------
-
-namespace perfetto {
-namespace legacy {
-
-enum TraceEventFlag {
-  kTraceEventFlagNone = 0,
-  kTraceEventFlagCopy = 1u << 0,
-  kTraceEventFlagHasId = 1u << 1,
-  kTraceEventFlagScopeOffset = 1u << 2,
-  kTraceEventFlagScopeExtra = 1u << 3,
-  kTraceEventFlagExplicitTimestamp = 1u << 4,
-  kTraceEventFlagAsyncTTS = 1u << 5,
-  kTraceEventFlagBindToEnclosing = 1u << 6,
-  kTraceEventFlagFlowIn = 1u << 7,
-  kTraceEventFlagFlowOut = 1u << 8,
-  kTraceEventFlagHasContextId = 1u << 9,
-  kTraceEventFlagHasProcessId = 1u << 10,
-  kTraceEventFlagHasLocalId = 1u << 11,
-  kTraceEventFlagHasGlobalId = 1u << 12,
-  // TODO(eseckler): Remove once we have native support for typed proto events
-  // in TRACE_EVENT macros.
-  kTraceEventFlagTypedProtoArgs = 1u << 15,
-  kTraceEventFlagJavaStringLiterals = 1u << 16,
-};
-
-enum PerfettoLegacyCurrentThreadId { kCurrentThreadId };
-
-}  // namespace legacy
-}  // namespace perfetto
-
-#if PERFETTO_ENABLE_LEGACY_TRACE_EVENTS
-// The following constants are defined in the global namespace, since they were
-// originally implemented as macros.
-
-// Event phases.
-static constexpr char TRACE_EVENT_PHASE_BEGIN = 'B';
-static constexpr char TRACE_EVENT_PHASE_END = 'E';
-static constexpr char TRACE_EVENT_PHASE_COMPLETE = 'X';
-static constexpr char TRACE_EVENT_PHASE_INSTANT = 'I';
-static constexpr char TRACE_EVENT_PHASE_ASYNC_BEGIN = 'S';
-static constexpr char TRACE_EVENT_PHASE_ASYNC_STEP_INTO = 'T';
-static constexpr char TRACE_EVENT_PHASE_ASYNC_STEP_PAST = 'p';
-static constexpr char TRACE_EVENT_PHASE_ASYNC_END = 'F';
-static constexpr char TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN = 'b';
-static constexpr char TRACE_EVENT_PHASE_NESTABLE_ASYNC_END = 'e';
-static constexpr char TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT = 'n';
-static constexpr char TRACE_EVENT_PHASE_FLOW_BEGIN = 's';
-static constexpr char TRACE_EVENT_PHASE_FLOW_STEP = 't';
-static constexpr char TRACE_EVENT_PHASE_FLOW_END = 'f';
-static constexpr char TRACE_EVENT_PHASE_METADATA = 'M';
-static constexpr char TRACE_EVENT_PHASE_COUNTER = 'C';
-static constexpr char TRACE_EVENT_PHASE_SAMPLE = 'P';
-static constexpr char TRACE_EVENT_PHASE_CREATE_OBJECT = 'N';
-static constexpr char TRACE_EVENT_PHASE_SNAPSHOT_OBJECT = 'O';
-static constexpr char TRACE_EVENT_PHASE_DELETE_OBJECT = 'D';
-static constexpr char TRACE_EVENT_PHASE_MEMORY_DUMP = 'v';
-static constexpr char TRACE_EVENT_PHASE_MARK = 'R';
-static constexpr char TRACE_EVENT_PHASE_CLOCK_SYNC = 'c';
-
-// Flags for changing the behavior of TRACE_EVENT_API_ADD_TRACE_EVENT.
-static constexpr uint32_t TRACE_EVENT_FLAG_NONE =
-    perfetto::legacy::kTraceEventFlagNone;
-static constexpr uint32_t TRACE_EVENT_FLAG_COPY =
-    perfetto::legacy::kTraceEventFlagCopy;
-static constexpr uint32_t TRACE_EVENT_FLAG_HAS_ID =
-    perfetto::legacy::kTraceEventFlagHasId;
-static constexpr uint32_t TRACE_EVENT_FLAG_SCOPE_OFFSET =
-    perfetto::legacy::kTraceEventFlagScopeOffset;
-static constexpr uint32_t TRACE_EVENT_FLAG_SCOPE_EXTRA =
-    perfetto::legacy::kTraceEventFlagScopeExtra;
-static constexpr uint32_t TRACE_EVENT_FLAG_EXPLICIT_TIMESTAMP =
-    perfetto::legacy::kTraceEventFlagExplicitTimestamp;
-static constexpr uint32_t TRACE_EVENT_FLAG_ASYNC_TTS =
-    perfetto::legacy::kTraceEventFlagAsyncTTS;
-static constexpr uint32_t TRACE_EVENT_FLAG_BIND_TO_ENCLOSING =
-    perfetto::legacy::kTraceEventFlagBindToEnclosing;
-static constexpr uint32_t TRACE_EVENT_FLAG_FLOW_IN =
-    perfetto::legacy::kTraceEventFlagFlowIn;
-static constexpr uint32_t TRACE_EVENT_FLAG_FLOW_OUT =
-    perfetto::legacy::kTraceEventFlagFlowOut;
-static constexpr uint32_t TRACE_EVENT_FLAG_HAS_CONTEXT_ID =
-    perfetto::legacy::kTraceEventFlagHasContextId;
-static constexpr uint32_t TRACE_EVENT_FLAG_HAS_PROCESS_ID =
-    perfetto::legacy::kTraceEventFlagHasProcessId;
-static constexpr uint32_t TRACE_EVENT_FLAG_HAS_LOCAL_ID =
-    perfetto::legacy::kTraceEventFlagHasLocalId;
-static constexpr uint32_t TRACE_EVENT_FLAG_HAS_GLOBAL_ID =
-    perfetto::legacy::kTraceEventFlagHasGlobalId;
-static constexpr uint32_t TRACE_EVENT_FLAG_TYPED_PROTO_ARGS =
-    perfetto::legacy::kTraceEventFlagTypedProtoArgs;
-static constexpr uint32_t TRACE_EVENT_FLAG_JAVA_STRING_LITERALS =
-    perfetto::legacy::kTraceEventFlagJavaStringLiterals;
-
-static constexpr uint32_t TRACE_EVENT_FLAG_SCOPE_MASK =
-    TRACE_EVENT_FLAG_SCOPE_OFFSET | TRACE_EVENT_FLAG_SCOPE_EXTRA;
-
-// Type values for identifying types in the TraceValue union.
-static constexpr uint8_t TRACE_VALUE_TYPE_BOOL = 1;
-static constexpr uint8_t TRACE_VALUE_TYPE_UINT = 2;
-static constexpr uint8_t TRACE_VALUE_TYPE_INT = 3;
-static constexpr uint8_t TRACE_VALUE_TYPE_DOUBLE = 4;
-static constexpr uint8_t TRACE_VALUE_TYPE_POINTER = 5;
-static constexpr uint8_t TRACE_VALUE_TYPE_STRING = 6;
-static constexpr uint8_t TRACE_VALUE_TYPE_COPY_STRING = 7;
-static constexpr uint8_t TRACE_VALUE_TYPE_CONVERTABLE = 8;
-static constexpr uint8_t TRACE_VALUE_TYPE_PROTO = 9;
-
-// Enum reflecting the scope of an INSTANT event. Must fit within
-// TRACE_EVENT_FLAG_SCOPE_MASK.
-static constexpr uint8_t TRACE_EVENT_SCOPE_GLOBAL = 0u << 2;
-static constexpr uint8_t TRACE_EVENT_SCOPE_PROCESS = 1u << 2;
-static constexpr uint8_t TRACE_EVENT_SCOPE_THREAD = 2u << 2;
-
-static constexpr char TRACE_EVENT_SCOPE_NAME_GLOBAL = 'g';
-static constexpr char TRACE_EVENT_SCOPE_NAME_PROCESS = 'p';
-static constexpr char TRACE_EVENT_SCOPE_NAME_THREAD = 't';
-
-#define TRACE_EVENT_API_CURRENT_THREAD_ID ::perfetto::legacy::kCurrentThreadId
+// Ignore GCC warning about a missing argument for a variadic macro parameter.
+#pragma GCC system_header
 
-#endif  // PERFETTO_ENABLE_LEGACY_TRACE_EVENTS
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+#endif
 
 // ----------------------------------------------------------------------------
 // Internal legacy trace point implementation.
@@ -19580,310 +24069,36 @@ ThreadTrack PERFETTO_EXPORT_COMPONENT
 ConvertThreadId(const PerfettoLegacyCurrentThreadId&);
 
 }  // namespace legacy
-
-namespace internal {
-
-// LegacyTraceId encapsulates an ID that can either be an integer or pointer.
-class PERFETTO_EXPORT_COMPONENT LegacyTraceId {
- public:
-  // Can be combined with WithScope.
-  class LocalId {
-   public:
-    explicit LocalId(const void* raw_id)
-        : raw_id_(static_cast<uint64_t>(reinterpret_cast<uintptr_t>(raw_id))) {}
-    explicit LocalId(uint64_t raw_id) : raw_id_(raw_id) {}
-    uint64_t raw_id() const { return raw_id_; }
-
-   private:
-    uint64_t raw_id_;
-  };
-
-  // Can be combined with WithScope.
-  class GlobalId {
-   public:
-    explicit GlobalId(uint64_t raw_id) : raw_id_(raw_id) {}
-    uint64_t raw_id() const { return raw_id_; }
-
-   private:
-    uint64_t raw_id_;
-  };
-
-  class WithScope {
-   public:
-    WithScope(const char* scope, uint64_t raw_id)
-        : scope_(scope), raw_id_(raw_id) {}
-    WithScope(const char* scope, LocalId local_id)
-        : scope_(scope), raw_id_(local_id.raw_id()) {
-      id_flags_ = legacy::kTraceEventFlagHasLocalId;
-    }
-    WithScope(const char* scope, GlobalId global_id)
-        : scope_(scope), raw_id_(global_id.raw_id()) {
-      id_flags_ = legacy::kTraceEventFlagHasGlobalId;
-    }
-    WithScope(const char* scope, uint64_t prefix, uint64_t raw_id)
-        : scope_(scope), has_prefix_(true), prefix_(prefix), raw_id_(raw_id) {}
-    WithScope(const char* scope, uint64_t prefix, GlobalId global_id)
-        : scope_(scope),
-          has_prefix_(true),
-          prefix_(prefix),
-          raw_id_(global_id.raw_id()) {
-      id_flags_ = legacy::kTraceEventFlagHasGlobalId;
-    }
-    uint64_t raw_id() const { return raw_id_; }
-    const char* scope() const { return scope_; }
-    bool has_prefix() const { return has_prefix_; }
-    uint64_t prefix() const { return prefix_; }
-    uint32_t id_flags() const { return id_flags_; }
-
-   private:
-    const char* scope_ = nullptr;
-    bool has_prefix_ = false;
-    uint64_t prefix_;
-    uint64_t raw_id_;
-    uint32_t id_flags_ = legacy::kTraceEventFlagHasId;
-  };
-
-  explicit LegacyTraceId(const void* raw_id)
-      : raw_id_(static_cast<uint64_t>(reinterpret_cast<uintptr_t>(raw_id))) {
-    id_flags_ = legacy::kTraceEventFlagHasLocalId;
-  }
-  explicit LegacyTraceId(uint64_t raw_id) : raw_id_(raw_id) {}
-  explicit LegacyTraceId(uint32_t raw_id) : raw_id_(raw_id) {}
-  explicit LegacyTraceId(uint16_t raw_id) : raw_id_(raw_id) {}
-  explicit LegacyTraceId(uint8_t raw_id) : raw_id_(raw_id) {}
-  explicit LegacyTraceId(int64_t raw_id)
-      : raw_id_(static_cast<uint64_t>(raw_id)) {}
-  explicit LegacyTraceId(int32_t raw_id)
-      : raw_id_(static_cast<uint64_t>(raw_id)) {}
-  explicit LegacyTraceId(int16_t raw_id)
-      : raw_id_(static_cast<uint64_t>(raw_id)) {}
-  explicit LegacyTraceId(int8_t raw_id)
-      : raw_id_(static_cast<uint64_t>(raw_id)) {}
-// Different platforms disagree on which integer types are same and which
-// are different. E.g. on Mac size_t is considered a different type from
-// uint64_t even though it has the same size and signedness.
-// Below we add overloads for those types that are known to cause ambiguity.
-#if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)
-  explicit LegacyTraceId(size_t raw_id) : raw_id_(raw_id) {}
-  explicit LegacyTraceId(intptr_t raw_id)
-      : raw_id_(static_cast<uint64_t>(raw_id)) {}
-#elif PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
-  explicit LegacyTraceId(unsigned long raw_id) : raw_id_(raw_id) {}
-#endif
-  explicit LegacyTraceId(LocalId raw_id) : raw_id_(raw_id.raw_id()) {
-    id_flags_ = legacy::kTraceEventFlagHasLocalId;
-  }
-  explicit LegacyTraceId(GlobalId raw_id) : raw_id_(raw_id.raw_id()) {
-    id_flags_ = legacy::kTraceEventFlagHasGlobalId;
-  }
-  explicit LegacyTraceId(WithScope scoped_id)
-      : scope_(scoped_id.scope()),
-        has_prefix_(scoped_id.has_prefix()),
-        prefix_(scoped_id.prefix()),
-        raw_id_(scoped_id.raw_id()),
-        id_flags_(scoped_id.id_flags()) {}
-
-  uint64_t raw_id() const { return raw_id_; }
-  const char* scope() const { return scope_; }
-  bool has_prefix() const { return has_prefix_; }
-  uint64_t prefix() const { return prefix_; }
-  uint32_t id_flags() const { return id_flags_; }
-
-  void Write(protos::pbzero::TrackEvent::LegacyEvent*,
-             uint32_t event_flags) const;
-
- private:
-  const char* scope_ = nullptr;
-  bool has_prefix_ = false;
-  uint64_t prefix_;
-  uint64_t raw_id_;
-  uint32_t id_flags_ = legacy::kTraceEventFlagHasId;
-};
-
-}  // namespace internal
 }  // namespace perfetto
 
 #if PERFETTO_ENABLE_LEGACY_TRACE_EVENTS
 
-namespace perfetto {
-namespace internal {
-
-template <typename T>
-bool IsEqual(T x, T y) {
-  return x == y;
-}
-
-template <typename T, typename U>
-bool IsEqual(T x, U y) {
-  return false;
-}
-
-class PERFETTO_EXPORT_COMPONENT TrackEventLegacy {
- public:
-  static constexpr protos::pbzero::TrackEvent::Type PhaseToType(char phase) {
-    // clang-format off
-    return (phase == TRACE_EVENT_PHASE_BEGIN) ?
-               protos::pbzero::TrackEvent::TYPE_SLICE_BEGIN :
-           (phase == TRACE_EVENT_PHASE_END) ?
-               protos::pbzero::TrackEvent::TYPE_SLICE_END :
-           (phase == TRACE_EVENT_PHASE_INSTANT) ?
-               protos::pbzero::TrackEvent::TYPE_INSTANT :
-           protos::pbzero::TrackEvent::TYPE_UNSPECIFIED;
-    // clang-format on
-  }
-
-  // Reduce binary size overhead by outlining most of the code for writing a
-  // legacy trace event.
-  template <typename... Args>
-  static void WriteLegacyEvent(EventContext ctx,
-                               char phase,
-                               uint32_t flags,
-                               Args&&... args) PERFETTO_NO_INLINE {
-    PERFETTO_DCHECK(!(flags & TRACE_EVENT_FLAG_HAS_PROCESS_ID));
-    AddDebugAnnotations(&ctx, std::forward<Args>(args)...);
-    if (NeedLegacyFlags(phase, flags)) {
-      auto legacy_event = ctx.event()->set_legacy_event();
-      SetLegacyFlags(legacy_event, phase, flags);
-    }
-  }
-
-  template <typename ThreadIdType, typename... Args>
-  static void WriteLegacyEventWithIdAndTid(EventContext ctx,
-                                           char phase,
-                                           uint32_t flags,
-                                           const LegacyTraceId& id,
-                                           const ThreadIdType& thread_id,
-                                           Args&&... args) PERFETTO_NO_INLINE {
-    //
-    // Overrides to consider:
-    //
-    // 1. If we have an id, we need to write {unscoped,local,global}_id and/or
-    //    bind_id.
-    // 2. If we have a thread id, we need to write track_uuid() or
-    //    {pid,tid}_override if the id represents another process.  The
-    //    conversion from |thread_id| happens in embedder code since the type is
-    //    embedder-specified.
-    // 3. If we have a timestamp, we need to write a different timestamp in the
-    //    trace packet itself and make sure TrackEvent won't write one
-    //    internally. This is already done at the call site.
-    //
-    PERFETTO_DCHECK(PhaseToType(phase) ==
-                        protos::pbzero::TrackEvent::TYPE_UNSPECIFIED ||
-                    !(flags & TRACE_EVENT_FLAG_HAS_PROCESS_ID));
-    flags |= id.id_flags();
-    AddDebugAnnotations(&ctx, std::forward<Args>(args)...);
-    if (NeedLegacyFlags(phase, flags)) {
-      auto legacy_event = ctx.event()->set_legacy_event();
-      SetLegacyFlags(legacy_event, phase, flags);
-      if (id.id_flags())
-        id.Write(legacy_event, flags);
-      if (flags & TRACE_EVENT_FLAG_HAS_PROCESS_ID) {
-        // The thread identifier actually represents a process id. Let's set an
-        // override for it.
-        int32_t pid_override =
-            static_cast<int32_t>(legacy::ConvertThreadId(thread_id).tid);
-        legacy_event->set_pid_override(pid_override);
-        legacy_event->set_tid_override(-1);
-      } else {
-        // Only synchronous phases are supported for other threads. These phases
-        // are supported in TrackEvent types and receive a track_uuid
-        // association via TrackEventDataSource::TraceForCategoryImpl().
-        PERFETTO_DCHECK(PhaseToType(phase) !=
-                            protos::pbzero::TrackEvent::TYPE_UNSPECIFIED ||
-                        IsEqual(thread_id, TRACE_EVENT_API_CURRENT_THREAD_ID) ||
-                        legacy::ConvertThreadId(thread_id).tid ==
-                            ThreadTrack::Current().tid);
-      }
-    }
-  }
-
-  // No arguments.
-  static void AddDebugAnnotations(EventContext*) {}
-
-  // N number of debug arguments.
-  template <typename ArgNameType, typename ArgType, typename... OtherArgs>
-  static void AddDebugAnnotations(EventContext* ctx,
-                                  ArgNameType&& arg_name,
-                                  ArgType&& arg_value,
-                                  OtherArgs&&... more_args) {
-    TrackEventInternal::AddDebugAnnotation(ctx,
-                                           std::forward<ArgNameType>(arg_name),
-                                           std::forward<ArgType>(arg_value));
-    AddDebugAnnotations(ctx, std::forward<OtherArgs>(more_args)...);
-  }
-
- private:
-  static bool NeedLegacyFlags(char phase, uint32_t flags) {
-    if (PhaseToType(phase) == protos::pbzero::TrackEvent::TYPE_UNSPECIFIED)
-      return true;
-    // TODO(skyostil): Implement/deprecate:
-    // - TRACE_EVENT_FLAG_EXPLICIT_TIMESTAMP
-    // - TRACE_EVENT_FLAG_HAS_CONTEXT_ID
-    // - TRACE_EVENT_FLAG_TYPED_PROTO_ARGS
-    // - TRACE_EVENT_FLAG_JAVA_STRING_LITERALS
-    return flags &
-           (TRACE_EVENT_FLAG_HAS_ID | TRACE_EVENT_FLAG_HAS_LOCAL_ID |
-            TRACE_EVENT_FLAG_HAS_GLOBAL_ID | TRACE_EVENT_FLAG_ASYNC_TTS |
-            TRACE_EVENT_FLAG_BIND_TO_ENCLOSING | TRACE_EVENT_FLAG_FLOW_IN |
-            TRACE_EVENT_FLAG_FLOW_OUT | TRACE_EVENT_FLAG_HAS_PROCESS_ID);
-  }
-
-  static void SetLegacyFlags(
-      protos::pbzero::TrackEvent::LegacyEvent* legacy_event,
-      char phase,
-      uint32_t flags) {
-    if (PhaseToType(phase) == protos::pbzero::TrackEvent::TYPE_UNSPECIFIED)
-      legacy_event->set_phase(phase);
-    if (flags & TRACE_EVENT_FLAG_ASYNC_TTS)
-      legacy_event->set_use_async_tts(true);
-    if (flags & TRACE_EVENT_FLAG_BIND_TO_ENCLOSING)
-      legacy_event->set_bind_to_enclosing(true);
-
-    const auto kFlowIn = TRACE_EVENT_FLAG_FLOW_IN;
-    const auto kFlowOut = TRACE_EVENT_FLAG_FLOW_OUT;
-    const auto kFlowInOut = kFlowIn | kFlowOut;
-    if ((flags & kFlowInOut) == kFlowInOut) {
-      legacy_event->set_flow_direction(
-          protos::pbzero::TrackEvent::LegacyEvent::FLOW_INOUT);
-    } else if (flags & kFlowIn) {
-      legacy_event->set_flow_direction(
-          protos::pbzero::TrackEvent::LegacyEvent::FLOW_IN);
-    } else if (flags & kFlowOut) {
-      legacy_event->set_flow_direction(
-          protos::pbzero::TrackEvent::LegacyEvent::FLOW_OUT);
-    }
-  }
-};
-
-inline ::perfetto::DynamicString GetEventNameTypeForLegacyEvents(
-    ::perfetto::DynamicString name) {
-  return name;
-}
-
-inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
-    ::perfetto::StaticString name) {
-  return name;
-}
-
-// In legacy macro, `const char*` is considered static by default, unless it's
-// wrapped in `TRACE_STR_COPY`.
-inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
-    const char* name) {
-  return ::perfetto::StaticString{name};
-}
-
-}  // namespace internal
-}  // namespace perfetto
-
 // Implementations for the INTERNAL_* adapter macros used by the trace points
 // below.
 #define PERFETTO_INTERNAL_LEGACY_EVENT_ON_TRACK(phase, category, name, track, \
                                                 ...)                          \
-  PERFETTO_INTERNAL_TRACK_EVENT(                                              \
-      category, ::perfetto::internal::GetEventNameTypeForLegacyEvents(name),  \
+  PERFETTO_INTERNAL_TRACK_EVENT_WITH_METHOD(                                  \
+      TraceForCategory, category,                                             \
+      ::perfetto::internal::DecayEventNameType(name),                         \
       ::perfetto::internal::TrackEventLegacy::PhaseToType(phase), track,      \
       ##__VA_ARGS__);
 
+#define PERFETTO_INTERNAL_LEGACY_EVENT_WITH_FLAGS_ON_TRACK(              \
+    phase, category, name, track, flags, ...)                            \
+  PERFETTO_INTERNAL_TRACK_EVENT_WITH_METHOD(                             \
+      TraceForCategoryLegacy, category,                                  \
+      ::perfetto::internal::DecayEventNameType(name),                    \
+      ::perfetto::internal::TrackEventLegacy::PhaseToType(phase), track, \
+      phase, flags, ##__VA_ARGS__);
+
+#define PERFETTO_INTERNAL_LEGACY_EVENT_WITH_ID_ON_TRACK(                 \
+    phase, category, name, track, flags, thread_id, id, ...)             \
+  PERFETTO_INTERNAL_TRACK_EVENT_WITH_METHOD(                             \
+      TraceForCategoryLegacyWithId, category,                            \
+      ::perfetto::internal::DecayEventNameType(name),                    \
+      ::perfetto::internal::TrackEventLegacy::PhaseToType(phase), track, \
+      phase, flags, thread_id, id, ##__VA_ARGS__);
+
 // The main entrypoint for writing unscoped legacy events.  This macro
 // determines the right track to write the event on based on |flags| and
 // |thread_id|.
@@ -19895,23 +24110,29 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
     /* First check the scope for instant events. */                        \
     if ((phase) == TRACE_EVENT_PHASE_INSTANT) {                            \
       /* Note: Avoids the need to set LegacyEvent::instant_event_scope. */ \
-      auto scope = (flags)&TRACE_EVENT_FLAG_SCOPE_MASK;                    \
+      auto scope = (flags) & TRACE_EVENT_FLAG_SCOPE_MASK;                  \
       switch (scope) {                                                     \
         case TRACE_EVENT_SCOPE_GLOBAL:                                     \
-          PERFETTO_INTERNAL_LEGACY_EVENT_ON_TRACK(                         \
-              phase, category, name, ::perfetto::Track::Global(0),         \
+          PERFETTO_INTERNAL_LEGACY_EVENT_WITH_FLAGS_ON_TRACK(              \
+              phase, category, name, ::perfetto::Track::Global(0), flags,  \
               ##__VA_ARGS__);                                              \
           return;                                                          \
         case TRACE_EVENT_SCOPE_PROCESS:                                    \
-          PERFETTO_INTERNAL_LEGACY_EVENT_ON_TRACK(                         \
+          PERFETTO_INTERNAL_LEGACY_EVENT_WITH_FLAGS_ON_TRACK(              \
               phase, category, name, ::perfetto::ProcessTrack::Current(),  \
-              ##__VA_ARGS__);                                              \
+              flags, ##__VA_ARGS__);                                       \
           return;                                                          \
         default:                                                           \
         case TRACE_EVENT_SCOPE_THREAD:                                     \
           /* Fallthrough. */                                               \
           break;                                                           \
       }                                                                    \
+    } else if ((phase) == TRACE_EVENT_PHASE_MARK) {                        \
+      /* Similarly, mark events should always go on the global track. */   \
+      PERFETTO_INTERNAL_LEGACY_EVENT_WITH_FLAGS_ON_TRACK(                  \
+          phase, category, name, ::perfetto::Track::Global(0), flags,      \
+          ##__VA_ARGS__);                                                  \
+      return;                                                              \
     }                                                                      \
     /* If an event targets the current thread or another process, write    \
      * it on the current thread's track. The process override case is      \
@@ -19919,85 +24140,101 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
     if (std::is_same<                                                      \
             decltype(thread_id),                                           \
             ::perfetto::legacy::PerfettoLegacyCurrentThreadId>::value ||   \
-        ((flags)&TRACE_EVENT_FLAG_HAS_PROCESS_ID)) {                       \
-      PERFETTO_INTERNAL_LEGACY_EVENT_ON_TRACK(                             \
-          phase, category, name, TrackEventInternal::kDefaultTrack,        \
+        ((flags) & TRACE_EVENT_FLAG_HAS_PROCESS_ID)) {                     \
+      PERFETTO_INTERNAL_LEGACY_EVENT_WITH_FLAGS_ON_TRACK(                  \
+          phase, category, name, TrackEventInternal::kDefaultTrack, flags, \
           ##__VA_ARGS__);                                                  \
     } else {                                                               \
-      PERFETTO_INTERNAL_LEGACY_EVENT_ON_TRACK(                             \
+      PERFETTO_INTERNAL_LEGACY_EVENT_WITH_FLAGS_ON_TRACK(                  \
           phase, category, name,                                           \
-          ::perfetto::legacy::ConvertThreadId(thread_id), ##__VA_ARGS__);  \
+          ::perfetto::legacy::ConvertThreadId(thread_id), flags,           \
+          ##__VA_ARGS__);                                                  \
     }                                                                      \
   }()
 
-#define INTERNAL_TRACE_EVENT_ADD(phase, category, name, flags, ...)        \
-  PERFETTO_INTERNAL_LEGACY_EVENT(                                          \
-      phase, category, name, flags, ::perfetto::legacy::kCurrentThreadId,  \
-      [&](perfetto::EventContext ctx) PERFETTO_NO_THREAD_SAFETY_ANALYSIS { \
-        using ::perfetto::internal::TrackEventLegacy;                      \
-        TrackEventLegacy::WriteLegacyEvent(std::move(ctx), phase, flags,   \
-                                           ##__VA_ARGS__);                 \
-      })
-
-// PERFETTO_INTERNAL_SCOPED_TRACK_EVENT does not require GetStaticString, as it
-// uses TRACE_EVENT_BEGIN/END internally, which already have this call.
-#define INTERNAL_TRACE_EVENT_ADD_SCOPED(category, name, ...)                 \
-  PERFETTO_INTERNAL_SCOPED_TRACK_EVENT(                                      \
-      category, ::perfetto::internal::GetEventNameTypeForLegacyEvents(name), \
-      [&](perfetto::EventContext ctx) PERFETTO_NO_THREAD_SAFETY_ANALYSIS {   \
-        using ::perfetto::internal::TrackEventLegacy;                        \
-        TrackEventLegacy::AddDebugAnnotations(&ctx, ##__VA_ARGS__);          \
-      })
-
-// PERFETTO_INTERNAL_SCOPED_TRACK_EVENT does not require GetStaticString, as it
-// uses TRACE_EVENT_BEGIN/END internally, which already have this call.
-#define INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category, name, bind_id,   \
-                                                  flags, ...)                \
-  PERFETTO_INTERNAL_SCOPED_TRACK_EVENT(                                      \
-      category, ::perfetto::internal::GetEventNameTypeForLegacyEvents(name), \
-      [&](perfetto::EventContext ctx) PERFETTO_NO_THREAD_SAFETY_ANALYSIS {   \
-        using ::perfetto::internal::TrackEventLegacy;                        \
-        ::perfetto::internal::LegacyTraceId PERFETTO_UID(trace_id){bind_id}; \
-        TrackEventLegacy::WriteLegacyEventWithIdAndTid(                      \
-            std::move(ctx), TRACE_EVENT_PHASE_BEGIN, flags,                  \
-            PERFETTO_UID(trace_id), TRACE_EVENT_API_CURRENT_THREAD_ID,       \
-            ##__VA_ARGS__);                                                  \
-      })
-
-#define INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP(phase, category, name,     \
-                                                timestamp, flags, ...)     \
-  PERFETTO_INTERNAL_LEGACY_EVENT(                                          \
-      phase, category, name, flags, ::perfetto::legacy::kCurrentThreadId,  \
-      timestamp,                                                           \
-      [&](perfetto::EventContext ctx) PERFETTO_NO_THREAD_SAFETY_ANALYSIS { \
-        using ::perfetto::internal::TrackEventLegacy;                      \
-        TrackEventLegacy::WriteLegacyEvent(std::move(ctx), phase, flags,   \
-                                           ##__VA_ARGS__);                 \
-      })
-
-#define INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                  \
-    phase, category, name, id, thread_id, timestamp, flags, ...)             \
-  PERFETTO_INTERNAL_LEGACY_EVENT(                                            \
-      phase, category, name, flags, thread_id, timestamp,                    \
-      [&](perfetto::EventContext ctx) PERFETTO_NO_THREAD_SAFETY_ANALYSIS {   \
-        using ::perfetto::internal::TrackEventLegacy;                        \
-        ::perfetto::internal::LegacyTraceId PERFETTO_UID(trace_id){id};      \
-        TrackEventLegacy::WriteLegacyEventWithIdAndTid(                      \
-            std::move(ctx), phase, flags, PERFETTO_UID(trace_id), thread_id, \
-            ##__VA_ARGS__);                                                  \
-      })
-
-#define INTERNAL_TRACE_EVENT_ADD_WITH_ID(phase, category, name, id, flags, \
-                                         ...)                              \
-  PERFETTO_INTERNAL_LEGACY_EVENT(                                          \
-      phase, category, name, flags, ::perfetto::legacy::kCurrentThreadId,  \
-      [&](perfetto::EventContext ctx) PERFETTO_NO_THREAD_SAFETY_ANALYSIS { \
-        using ::perfetto::internal::TrackEventLegacy;                      \
-        ::perfetto::internal::LegacyTraceId PERFETTO_UID(trace_id){id};    \
-        TrackEventLegacy::WriteLegacyEventWithIdAndTid(                    \
-            std::move(ctx), phase, flags, PERFETTO_UID(trace_id),          \
-            TRACE_EVENT_API_CURRENT_THREAD_ID, ##__VA_ARGS__);             \
-      })
+#define PERFETTO_INTERNAL_LEGACY_EVENT_WITH_ID(phase, category, name, flags, \
+                                               thread_id, id, ...)           \
+  [&]() {                                                                    \
+    using ::perfetto::internal::TrackEventInternal;                          \
+    PERFETTO_DCHECK(!(flags & TRACE_EVENT_FLAG_COPY));                       \
+    /* First check the scope for instant events. */                          \
+    if ((phase) == TRACE_EVENT_PHASE_INSTANT) {                              \
+      /* Note: Avoids the need to set LegacyEvent::instant_event_scope. */   \
+      auto scope = (flags) & TRACE_EVENT_FLAG_SCOPE_MASK;                    \
+      switch (scope) {                                                       \
+        case TRACE_EVENT_SCOPE_GLOBAL:                                       \
+          PERFETTO_INTERNAL_LEGACY_EVENT_WITH_ID_ON_TRACK(                   \
+              phase, category, name, ::perfetto::Track::Global(0), flags,    \
+              thread_id, id, ##__VA_ARGS__);                                 \
+          return;                                                            \
+        case TRACE_EVENT_SCOPE_PROCESS:                                      \
+          PERFETTO_INTERNAL_LEGACY_EVENT_WITH_ID_ON_TRACK(                   \
+              phase, category, name, ::perfetto::ProcessTrack::Current(),    \
+              flags, thread_id, id, ##__VA_ARGS__);                          \
+          return;                                                            \
+        default:                                                             \
+        case TRACE_EVENT_SCOPE_THREAD:                                       \
+          /* Fallthrough. */                                                 \
+          break;                                                             \
+      }                                                                      \
+    } else if ((phase) == TRACE_EVENT_PHASE_MARK) {                          \
+      /* Similarly, mark events should always go on the global track. */     \
+      PERFETTO_INTERNAL_LEGACY_EVENT_WITH_FLAGS_ON_TRACK(                    \
+          phase, category, name, ::perfetto::Track::Global(0), flags,        \
+          ##__VA_ARGS__);                                                    \
+      return;                                                                \
+    }                                                                        \
+    /* If an event targets the current thread or another process, write      \
+     * it on the current thread's track. The process override case is        \
+     * handled through |pid_override| in WriteLegacyEvent. */                \
+    if (std::is_same<                                                        \
+            decltype(thread_id),                                             \
+            ::perfetto::legacy::PerfettoLegacyCurrentThreadId>::value ||     \
+        ((flags) & TRACE_EVENT_FLAG_HAS_PROCESS_ID)) {                       \
+      PERFETTO_INTERNAL_LEGACY_EVENT_WITH_ID_ON_TRACK(                       \
+          phase, category, name, TrackEventInternal::kDefaultTrack, flags,   \
+          thread_id, id, ##__VA_ARGS__);                                     \
+    } else {                                                                 \
+      PERFETTO_INTERNAL_LEGACY_EVENT_WITH_ID_ON_TRACK(                       \
+          phase, category, name,                                             \
+          ::perfetto::legacy::ConvertThreadId(thread_id), flags, thread_id,  \
+          id, ##__VA_ARGS__);                                                \
+    }                                                                        \
+  }()
+
+#define INTERNAL_TRACE_EVENT_ADD(phase, category, name, flags, ...)           \
+  PERFETTO_INTERNAL_LEGACY_EVENT(                                             \
+      phase, category, ::perfetto::internal::DecayEventNameType(name), flags, \
+      ::perfetto::legacy::kCurrentThreadId, ##__VA_ARGS__)
+
+#define INTERNAL_TRACE_EVENT_ADD_SCOPED(category, name, ...) \
+  PERFETTO_INTERNAL_SCOPED_TRACK_EVENT(                      \
+      category, ::perfetto::internal::DecayEventNameType(name), ##__VA_ARGS__)
+
+#define INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category, name, bind_id, \
+                                                  flags, ...)              \
+  PERFETTO_INTERNAL_SCOPED_LEGACY_TRACK_EVENT_WITH_ID(                     \
+      category, ::perfetto::internal::DecayEventNameType(name),            \
+      ::perfetto::internal::TrackEventInternal::kDefaultTrack, flags,      \
+      TRACE_EVENT_API_CURRENT_THREAD_ID, bind_id, ##__VA_ARGS__)
+
+#define INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP(phase, category, name,        \
+                                                timestamp, flags, ...)        \
+  PERFETTO_INTERNAL_LEGACY_EVENT(                                             \
+      phase, category, ::perfetto::internal::DecayEventNameType(name), flags, \
+      ::perfetto::legacy::kCurrentThreadId, timestamp, ##__VA_ARGS__)
+
+#define INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                   \
+    phase, category, name, id, thread_id, timestamp, flags, ...)              \
+  PERFETTO_INTERNAL_LEGACY_EVENT_WITH_ID(                                     \
+      phase, category, ::perfetto::internal::DecayEventNameType(name), flags, \
+      thread_id, id, timestamp, ##__VA_ARGS__)
+
+#define INTERNAL_TRACE_EVENT_ADD_WITH_ID(phase, category, name, id, flags,    \
+                                         ...)                                 \
+  PERFETTO_INTERNAL_LEGACY_EVENT_WITH_ID(                                     \
+      phase, category, ::perfetto::internal::DecayEventNameType(name), flags, \
+      ::perfetto::legacy::kCurrentThreadId, id, ##__VA_ARGS__)
 
 #define INTERNAL_TRACE_EVENT_METADATA_ADD(category, name, ...)         \
   INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_METADATA, category, name, \
@@ -20007,6 +24244,9 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
 // Legacy tracing common API (adapted from trace_event_common.h).
 // ----------------------------------------------------------------------------
 
+// disabled-by-default- prefix used to have a special meaning in chrome. This
+// is no longer true and TRACE_DISABLED_BY_DEFAULT merely adds a prefix to the
+// category name.
 #define TRACE_DISABLED_BY_DEFAULT(name) "disabled-by-default-" name
 
 // Scoped events.
@@ -20016,20 +24256,26 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
   INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name, bind_id, \
                                             flow_flags)
 #define TRACE_EVENT1(category_group, name, arg1_name, arg1_val) \
-  INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, arg1_name, arg1_val)
-#define TRACE_EVENT_WITH_FLOW1(category_group, name, bind_id, flow_flags,  \
-                               arg1_name, arg1_val)                        \
-  INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name, bind_id, \
-                                            flow_flags, arg1_name, arg1_val)
-#define TRACE_EVENT2(category_group, name, arg1_name, arg1_val, arg2_name,   \
-                     arg2_val)                                               \
-  INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, arg1_name, arg1_val, \
-                                  arg2_name, arg2_val)
-#define TRACE_EVENT_WITH_FLOW2(category_group, name, bind_id, flow_flags,    \
-                               arg1_name, arg1_val, arg2_name, arg2_val)     \
-  INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name, bind_id,   \
-                                            flow_flags, arg1_name, arg1_val, \
-                                            arg2_name, arg2_val)
+  INTERNAL_TRACE_EVENT_ADD_SCOPED(                              \
+      category_group, name, arg1_name,                          \
+      ::perfetto::internal::PossiblyNull(arg1_val))
+#define TRACE_EVENT_WITH_FLOW1(category_group, name, bind_id, flow_flags, \
+                               arg1_name, arg1_val)                       \
+  INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(                              \
+      category_group, name, bind_id, flow_flags, arg1_name,               \
+      ::perfetto::internal::PossiblyNull(arg1_val))
+#define TRACE_EVENT2(category_group, name, arg1_name, arg1_val, arg2_name, \
+                     arg2_val)                                             \
+  INTERNAL_TRACE_EVENT_ADD_SCOPED(                                         \
+      category_group, name, arg1_name,                                     \
+      ::perfetto::internal::PossiblyNull(arg1_val), arg2_name,             \
+      ::perfetto::internal::PossiblyNull(arg2_val))
+#define TRACE_EVENT_WITH_FLOW2(category_group, name, bind_id, flow_flags, \
+                               arg1_name, arg1_val, arg2_name, arg2_val)  \
+  INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(                              \
+      category_group, name, bind_id, flow_flags, arg1_name,               \
+      ::perfetto::internal::PossiblyNull(arg1_val), arg2_name,            \
+      ::perfetto::internal::PossiblyNull(arg2_val))
 
 // Instant events.
 #define TRACE_EVENT_INSTANT0(category_group, name, scope)                   \
@@ -20037,12 +24283,15 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
                            TRACE_EVENT_FLAG_NONE | scope)
 #define TRACE_EVENT_INSTANT1(category_group, name, scope, arg1_name, arg1_val) \
   INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name,    \
-                           TRACE_EVENT_FLAG_NONE | scope, arg1_name, arg1_val)
+                           TRACE_EVENT_FLAG_NONE | scope, arg1_name,           \
+                           ::perfetto::internal::PossiblyNull(arg1_val))
 #define TRACE_EVENT_INSTANT2(category_group, name, scope, arg1_name, arg1_val, \
                              arg2_name, arg2_val)                              \
   INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name,    \
-                           TRACE_EVENT_FLAG_NONE | scope, arg1_name, arg1_val, \
-                           arg2_name, arg2_val)
+                           TRACE_EVENT_FLAG_NONE | scope, arg1_name,           \
+                           ::perfetto::internal::PossiblyNull(arg1_val),       \
+                           arg2_name,                                          \
+                           ::perfetto::internal::PossiblyNull(arg2_val))
 #define TRACE_EVENT_COPY_INSTANT0(category_group, name, scope)        \
   INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, \
                            ::perfetto::DynamicString{name}, scope)
@@ -20050,20 +24299,24 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
                                   arg1_val)                               \
   INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group,     \
                            ::perfetto::DynamicString{name}, scope,        \
-                           ::perfetto::DynamicString{arg1_name}, arg1_val)
-#define TRACE_EVENT_COPY_INSTANT2(category_group, name, scope, arg1_name,  \
-                                  arg1_val, arg2_name, arg2_val)           \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group,      \
-                           ::perfetto::DynamicString{name}, scope,         \
-                           ::perfetto::DynamicString{arg1_name}, arg1_val, \
-                           ::perfetto::DynamicString{arg2_name}, arg2_val)
+                           ::perfetto::DynamicString{arg1_name},          \
+                           ::perfetto::internal::PossiblyNull(arg1_val))
+#define TRACE_EVENT_COPY_INSTANT2(category_group, name, scope, arg1_name, \
+                                  arg1_val, arg2_name, arg2_val)          \
+  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group,     \
+                           ::perfetto::DynamicString{name}, scope,        \
+                           ::perfetto::DynamicString{arg1_name},          \
+                           ::perfetto::internal::PossiblyNull(arg1_val),  \
+                           ::perfetto::DynamicString{arg2_name},          \
+                           ::perfetto::internal::PossiblyNull(arg2_val))
 #define TRACE_EVENT_INSTANT_WITH_FLAGS0(category_group, name, scope_and_flags) \
   INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name,    \
                            scope_and_flags)
 #define TRACE_EVENT_INSTANT_WITH_FLAGS1(category_group, name, scope_and_flags, \
                                         arg1_name, arg1_val)                   \
   INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name,    \
-                           scope_and_flags, arg1_name, arg1_val)
+                           scope_and_flags, arg1_name,                         \
+                           ::perfetto::internal::PossiblyNull(arg1_val))
 
 // Instant events with explicit timestamps.
 #define TRACE_EVENT_INSTANT_WITH_TIMESTAMP0(category_group, name, scope,   \
@@ -20076,7 +24329,8 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
                                             timestamp, arg_name, arg_val) \
   INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP(                                \
       TRACE_EVENT_PHASE_INSTANT, category_group, name, timestamp,         \
-      TRACE_EVENT_FLAG_NONE | scope, arg_name, arg_val)
+      TRACE_EVENT_FLAG_NONE | scope, arg_name,                            \
+      ::perfetto::internal::PossiblyNull(arg_val))
 
 // Begin events.
 #define TRACE_EVENT_BEGIN0(category_group, name)                          \
@@ -20084,25 +24338,30 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
                            TRACE_EVENT_FLAG_NONE)
 #define TRACE_EVENT_BEGIN1(category_group, name, arg1_name, arg1_val)     \
   INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, \
-                           TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
-#define TRACE_EVENT_BEGIN2(category_group, name, arg1_name, arg1_val,     \
-                           arg2_name, arg2_val)                           \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, \
-                           TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val,    \
-                           arg2_name, arg2_val)
+                           TRACE_EVENT_FLAG_NONE, arg1_name,              \
+                           ::perfetto::internal::PossiblyNull(arg1_val))
+#define TRACE_EVENT_BEGIN2(category_group, name, arg1_name, arg1_val,       \
+                           arg2_name, arg2_val)                             \
+  INTERNAL_TRACE_EVENT_ADD(                                                 \
+      TRACE_EVENT_PHASE_BEGIN, category_group, name, TRACE_EVENT_FLAG_NONE, \
+      arg1_name, ::perfetto::internal::PossiblyNull(arg1_val), arg2_name,   \
+      ::perfetto::internal::PossiblyNull(arg2_val))
 #define TRACE_EVENT_BEGIN_WITH_FLAGS0(category_group, name, flags) \
   INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, flags)
 #define TRACE_EVENT_BEGIN_WITH_FLAGS1(category_group, name, flags, arg1_name, \
                                       arg1_val)                               \
   INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name,     \
-                           flags, arg1_name, arg1_val)
+                           flags, arg1_name,                                  \
+                           ::perfetto::internal::PossiblyNull(arg1_val))
 #define TRACE_EVENT_COPY_BEGIN2(category_group, name, arg1_name, arg1_val, \
                                 arg2_name, arg2_val)                       \
   INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group,        \
                            ::perfetto::DynamicString{name},                \
                            TRACE_EVENT_FLAG_NONE,                          \
-                           ::perfetto::DynamicString{arg1_name}, arg1_val, \
-                           ::perfetto::DynamicString{arg2_name}, arg2_val)
+                           ::perfetto::DynamicString{arg1_name},           \
+                           ::perfetto::internal::PossiblyNull(arg1_val),   \
+                           ::perfetto::DynamicString{arg2_name},           \
+                           ::perfetto::internal::PossiblyNull(arg2_val))
 
 // Begin events with explicit timestamps.
 #define TRACE_EVENT_BEGIN_WITH_ID_TID_AND_TIMESTAMP0(category_group, name, id, \
@@ -20121,15 +24380,18 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
   INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                    \
       TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group,                     \
       ::perfetto::DynamicString{name}, id, thread_id, timestamp,         \
-      TRACE_EVENT_FLAG_NONE, ::perfetto::DynamicString{arg1_name}, arg1_val)
-#define TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP2(                   \
-    category_group, name, id, thread_id, timestamp, arg1_name, arg1_val,     \
-    arg2_name, arg2_val)                                                     \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                        \
-      TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group,                         \
-      ::perfetto::DynamicString{name}, id, thread_id, timestamp,             \
-      TRACE_EVENT_FLAG_NONE, ::perfetto::DynamicString{arg1_name}, arg1_val, \
-      ::perfetto::DynamicString{arg2_name}, arg2_val)
+      TRACE_EVENT_FLAG_NONE, ::perfetto::DynamicString{arg1_name},       \
+      ::perfetto::internal::PossiblyNull(arg1_val))
+#define TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP2(               \
+    category_group, name, id, thread_id, timestamp, arg1_name, arg1_val, \
+    arg2_name, arg2_val)                                                 \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                    \
+      TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group,                     \
+      ::perfetto::DynamicString{name}, id, thread_id, timestamp,         \
+      TRACE_EVENT_FLAG_NONE, ::perfetto::DynamicString{arg1_name},       \
+      ::perfetto::internal::PossiblyNull(arg1_val),                      \
+      ::perfetto::DynamicString{arg2_name},                              \
+      ::perfetto::internal::PossiblyNull(arg2_val))
 
 // End events.
 #define TRACE_EVENT_END0(category_group, name)                          \
@@ -20137,24 +24399,29 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
                            TRACE_EVENT_FLAG_NONE)
 #define TRACE_EVENT_END1(category_group, name, arg1_name, arg1_val)     \
   INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, \
-                           TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
+                           TRACE_EVENT_FLAG_NONE, arg1_name,            \
+                           ::perfetto::internal::PossiblyNull(arg1_val))
 #define TRACE_EVENT_END2(category_group, name, arg1_name, arg1_val, arg2_name, \
                          arg2_val)                                             \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name,        \
-                           TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val,         \
-                           arg2_name, arg2_val)
+  INTERNAL_TRACE_EVENT_ADD(                                                    \
+      TRACE_EVENT_PHASE_END, category_group, name, TRACE_EVENT_FLAG_NONE,      \
+      arg1_name, ::perfetto::internal::PossiblyNull(arg1_val), arg2_name,      \
+      ::perfetto::internal::PossiblyNull(arg2_val))
 #define TRACE_EVENT_END_WITH_FLAGS0(category_group, name, flags) \
   INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, flags)
 #define TRACE_EVENT_END_WITH_FLAGS1(category_group, name, flags, arg1_name,    \
                                     arg1_val)                                  \
   INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, flags, \
-                           arg1_name, arg1_val)
+                           arg1_name,                                          \
+                           ::perfetto::internal::PossiblyNull(arg1_val))
 #define TRACE_EVENT_COPY_END2(category_group, name, arg1_name, arg1_val,      \
                               arg2_name, arg2_val)                            \
   INTERNAL_TRACE_EVENT_ADD(                                                   \
       TRACE_EVENT_PHASE_END, category_group, ::perfetto::DynamicString{name}, \
-      TRACE_EVENT_FLAG_NONE, ::perfetto::DynamicString{arg1_name}, arg1_val,  \
-      ::perfetto::DynamicString{arg2_name}, arg2_val)
+      TRACE_EVENT_FLAG_NONE, ::perfetto::DynamicString{arg1_name},            \
+      ::perfetto::internal::PossiblyNull(arg1_val),                           \
+      ::perfetto::DynamicString{arg2_name},                                   \
+      ::perfetto::internal::PossiblyNull(arg2_val))
 
 // Mark events.
 #define TRACE_EVENT_MARK_WITH_TIMESTAMP0(category_group, name, timestamp)  \
@@ -20166,13 +24433,16 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
                                          arg1_name, arg1_val)             \
   INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP(                                \
       TRACE_EVENT_PHASE_MARK, category_group, name, timestamp,            \
-      TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
+      TRACE_EVENT_FLAG_NONE, arg1_name,                                   \
+      ::perfetto::internal::PossiblyNull(arg1_val))
 
 #define TRACE_EVENT_MARK_WITH_TIMESTAMP2(                                      \
     category_group, name, timestamp, arg1_name, arg1_val, arg2_name, arg2_val) \
   INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP(                                     \
       TRACE_EVENT_PHASE_MARK, category_group, name, timestamp,                 \
-      TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
+      TRACE_EVENT_FLAG_NONE, arg1_name,                                        \
+      ::perfetto::internal::PossiblyNull(arg1_val), arg2_name,                 \
+      ::perfetto::internal::PossiblyNull(arg2_val))
 
 #define TRACE_EVENT_COPY_MARK(category_group, name)                \
   INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_MARK, category_group, \
@@ -20182,7 +24452,8 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
 #define TRACE_EVENT_COPY_MARK1(category_group, name, arg1_name, arg1_val)      \
   INTERNAL_TRACE_EVENT_ADD(                                                    \
       TRACE_EVENT_PHASE_MARK, category_group, ::perfetto::DynamicString{name}, \
-      TRACE_EVENT_FLAG_NONE, ::perfetto::DynamicString{arg1_name}, arg1_val)
+      TRACE_EVENT_FLAG_NONE, ::perfetto::DynamicString{arg1_name},             \
+      ::perfetto::internal::PossiblyNull(arg1_val))
 
 #define TRACE_EVENT_COPY_MARK_WITH_TIMESTAMP(category_group, name, timestamp)  \
   INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP(                                     \
@@ -20206,15 +24477,18 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
   INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                    \
       TRACE_EVENT_PHASE_ASYNC_END, category_group,                       \
       ::perfetto::DynamicString{name}, id, thread_id, timestamp,         \
-      TRACE_EVENT_FLAG_NONE, ::perfetto::DynamicString{arg1_name}, arg1_val)
-#define TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP2(                     \
-    category_group, name, id, thread_id, timestamp, arg1_name, arg1_val,     \
-    arg2_name, arg2_val)                                                     \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                        \
-      TRACE_EVENT_PHASE_ASYNC_END, category_group,                           \
-      ::perfetto::DynamicString{name}, id, thread_id, timestamp,             \
-      TRACE_EVENT_FLAG_NONE, ::perfetto::DynamicString{arg1_name}, arg1_val, \
-      ::perfetto::DynamicString{arg2_name}, arg2_val)
+      TRACE_EVENT_FLAG_NONE, ::perfetto::DynamicString{arg1_name},       \
+      ::perfetto::internal::PossiblyNull(arg1_val))
+#define TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP2(                 \
+    category_group, name, id, thread_id, timestamp, arg1_name, arg1_val, \
+    arg2_name, arg2_val)                                                 \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                    \
+      TRACE_EVENT_PHASE_ASYNC_END, category_group,                       \
+      ::perfetto::DynamicString{name}, id, thread_id, timestamp,         \
+      TRACE_EVENT_FLAG_NONE, ::perfetto::DynamicString{arg1_name},       \
+      ::perfetto::internal::PossiblyNull(arg1_val),                      \
+      ::perfetto::DynamicString{arg2_name},                              \
+      ::perfetto::internal::PossiblyNull(arg2_val))
 
 // Counters.
 #define TRACE_COUNTER1(category_group, name, value)                         \
@@ -20293,14 +24567,17 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
                                    TRACE_EVENT_FLAG_NONE)
 #define TRACE_EVENT_ASYNC_BEGIN1(category_group, name, id, arg1_name, \
                                  arg1_val)                            \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN,     \
-                                   category_group, name, id,          \
-                                   TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                   \
+      TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id,        \
+      TRACE_EVENT_FLAG_NONE, arg1_name,                               \
+      ::perfetto::internal::PossiblyNull(arg1_val))
 #define TRACE_EVENT_ASYNC_BEGIN2(category_group, name, id, arg1_name, \
                                  arg1_val, arg2_name, arg2_val)       \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                   \
       TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id,        \
-      TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
+      TRACE_EVENT_FLAG_NONE, arg1_name,                               \
+      ::perfetto::internal::PossiblyNull(arg1_val), arg2_name,        \
+      ::perfetto::internal::PossiblyNull(arg2_val))
 #define TRACE_EVENT_COPY_ASYNC_BEGIN0(category_group, name, id) \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(                             \
       TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group,            \
@@ -20310,14 +24587,17 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                        \
       TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group,                       \
       ::perfetto::DynamicString{name}, id, TRACE_EVENT_FLAG_NONE,          \
-      ::perfetto::DynamicString{arg1_name}, arg1_val)
+      ::perfetto::DynamicString{arg1_name},                                \
+      ::perfetto::internal::PossiblyNull(arg1_val))
 #define TRACE_EVENT_COPY_ASYNC_BEGIN2(category_group, name, id, arg1_name, \
                                       arg1_val, arg2_name, arg2_val)       \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                        \
       TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group,                       \
       ::perfetto::DynamicString{name}, id, TRACE_EVENT_FLAG_NONE,          \
-      ::perfetto::DynamicString{arg1_name}, arg1_val,                      \
-      ::perfetto::DynamicString{arg2_name}, arg2_val)
+      ::perfetto::DynamicString{arg1_name},                                \
+      ::perfetto::internal::PossiblyNull(arg1_val),                        \
+      ::perfetto::DynamicString{arg2_name},                                \
+      ::perfetto::internal::PossiblyNull(arg2_val))
 #define TRACE_EVENT_ASYNC_BEGIN_WITH_FLAGS0(category_group, name, id, flags) \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN,            \
                                    category_group, name, id, flags)
@@ -20333,7 +24613,7 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
   INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                      \
       TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id,             \
       TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
-      arg1_name, arg1_val)
+      arg1_name, ::perfetto::internal::PossiblyNull(arg1_val))
 #define TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP_AND_FLAGS0(     \
     category_group, name, id, timestamp, flags)                         \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                   \
@@ -20350,7 +24630,8 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
   INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                          \
       TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id,                 \
       TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE,     \
-      arg1_name, arg1_val, arg2_name, arg2_val)
+      arg1_name, ::perfetto::internal::PossiblyNull(arg1_val), arg2_name,      \
+      ::perfetto::internal::PossiblyNull(arg2_val))
 #define TRACE_EVENT_COPY_ASYNC_BEGIN_WITH_TIMESTAMP0(category_group, name, id, \
                                                      timestamp)                \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                          \
@@ -20372,7 +24653,8 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
                                      arg1_name, arg1_val)            \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                  \
       TRACE_EVENT_PHASE_ASYNC_STEP_INTO, category_group, name, id,   \
-      TRACE_EVENT_FLAG_NONE, "step", step, arg1_name, arg1_val)
+      TRACE_EVENT_FLAG_NONE, "step", step, arg1_name,                \
+      ::perfetto::internal::PossiblyNull(arg1_val))
 
 // Legacy async step into events with timestamps.
 #define TRACE_EVENT_ASYNC_STEP_INTO_WITH_TIMESTAMP0(category_group, name, id, \
@@ -20391,7 +24673,8 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
                                      arg1_name, arg1_val)            \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                  \
       TRACE_EVENT_PHASE_ASYNC_STEP_PAST, category_group, name, id,   \
-      TRACE_EVENT_FLAG_NONE, "step", step, arg1_name, arg1_val)
+      TRACE_EVENT_FLAG_NONE, "step", step, arg1_name,                \
+      ::perfetto::internal::PossiblyNull(arg1_val))
 
 // Legacy async end events.
 #define TRACE_EVENT_ASYNC_END0(category_group, name, id)        \
@@ -20399,14 +24682,17 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
                                    category_group, name, id,    \
                                    TRACE_EVENT_FLAG_NONE)
 #define TRACE_EVENT_ASYNC_END1(category_group, name, id, arg1_name, arg1_val) \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END,               \
-                                   category_group, name, id,                  \
-                                   TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                           \
+      TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id,                  \
+      TRACE_EVENT_FLAG_NONE, arg1_name,                                       \
+      ::perfetto::internal::PossiblyNull(arg1_val))
 #define TRACE_EVENT_ASYNC_END2(category_group, name, id, arg1_name, arg1_val, \
                                arg2_name, arg2_val)                           \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                           \
       TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id,                  \
-      TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
+      TRACE_EVENT_FLAG_NONE, arg1_name,                                       \
+      ::perfetto::internal::PossiblyNull(arg1_val), arg2_name,                \
+      ::perfetto::internal::PossiblyNull(arg2_val))
 #define TRACE_EVENT_COPY_ASYNC_END0(category_group, name, id) \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(                           \
       TRACE_EVENT_PHASE_ASYNC_END, category_group,            \
@@ -20416,14 +24702,17 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                      \
       TRACE_EVENT_PHASE_ASYNC_END, category_group,                       \
       ::perfetto::DynamicString{name}, id, TRACE_EVENT_FLAG_NONE,        \
-      ::perfetto::DynamicString{arg1_name}, arg1_val)
+      ::perfetto::DynamicString{arg1_name},                              \
+      ::perfetto::internal::PossiblyNull(arg1_val))
 #define TRACE_EVENT_COPY_ASYNC_END2(category_group, name, id, arg1_name, \
                                     arg1_val, arg2_name, arg2_val)       \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                      \
       TRACE_EVENT_PHASE_ASYNC_END, category_group,                       \
       ::perfetto::DynamicString{name}, id, TRACE_EVENT_FLAG_NONE,        \
-      ::perfetto::DynamicString{arg1_name}, arg1_val,                    \
-      ::perfetto::DynamicString{arg2_name}, arg2_val)
+      ::perfetto::DynamicString{arg1_name},                              \
+      ::perfetto::internal::PossiblyNull(arg1_val),                      \
+      ::perfetto::DynamicString{arg2_name},                              \
+      ::perfetto::internal::PossiblyNull(arg2_val))
 #define TRACE_EVENT_ASYNC_END_WITH_FLAGS0(category_group, name, id, flags) \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END,            \
                                    category_group, name, id, flags)
@@ -20439,14 +24728,15 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
   INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                         \
       TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id,                  \
       TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE,    \
-      arg1_name, arg1_val)
+      arg1_name, ::perfetto::internal::PossiblyNull(arg1_val))
 #define TRACE_EVENT_ASYNC_END_WITH_TIMESTAMP2(category_group, name, id,       \
                                               timestamp, arg1_name, arg1_val, \
                                               arg2_name, arg2_val)            \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                         \
       TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id,                  \
       TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE,    \
-      arg1_name, arg1_val, arg2_name, arg2_val)
+      arg1_name, ::perfetto::internal::PossiblyNull(arg1_val), arg2_name,     \
+      ::perfetto::internal::PossiblyNull(arg2_val))
 #define TRACE_EVENT_COPY_ASYNC_END_WITH_TIMESTAMP0(category_group, name, id,  \
                                                    timestamp)                 \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                         \
@@ -20466,14 +24756,17 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
                                    TRACE_EVENT_FLAG_NONE)
 #define TRACE_EVENT_NESTABLE_ASYNC_BEGIN1(category_group, name, id, arg1_name, \
                                           arg1_val)                            \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN,     \
-                                   category_group, name, id,                   \
-                                   TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                            \
+      TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id,        \
+      TRACE_EVENT_FLAG_NONE, arg1_name,                                        \
+      ::perfetto::internal::PossiblyNull(arg1_val))
 #define TRACE_EVENT_NESTABLE_ASYNC_BEGIN2(category_group, name, id, arg1_name, \
                                           arg1_val, arg2_name, arg2_val)       \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                            \
       TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id,        \
-      TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
+      TRACE_EVENT_FLAG_NONE, arg1_name,                                        \
+      ::perfetto::internal::PossiblyNull(arg1_val), arg2_name,                 \
+      ::perfetto::internal::PossiblyNull(arg2_val))
 #define TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_FLAGS0(category_group, name, id, \
                                                      flags)                    \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN,     \
@@ -20483,7 +24776,7 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
   INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                      \
       TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id,    \
       TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
-      arg1_name, arg1_val)
+      arg1_name, ::perfetto::internal::PossiblyNull(arg1_val))
 
 // Async end events.
 #define TRACE_EVENT_NESTABLE_ASYNC_END0(category_group, name, id)        \
@@ -20492,14 +24785,17 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
                                    TRACE_EVENT_FLAG_NONE)
 #define TRACE_EVENT_NESTABLE_ASYNC_END1(category_group, name, id, arg1_name, \
                                         arg1_val)                            \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_END,     \
-                                   category_group, name, id,                 \
-                                   TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                          \
+      TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id,        \
+      TRACE_EVENT_FLAG_NONE, arg1_name,                                      \
+      ::perfetto::internal::PossiblyNull(arg1_val))
 #define TRACE_EVENT_NESTABLE_ASYNC_END2(category_group, name, id, arg1_name, \
                                         arg1_val, arg2_name, arg2_val)       \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                          \
       TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id,        \
-      TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
+      TRACE_EVENT_FLAG_NONE, arg1_name,                                      \
+      ::perfetto::internal::PossiblyNull(arg1_val), arg2_name,               \
+      ::perfetto::internal::PossiblyNull(arg2_val))
 #define TRACE_EVENT_NESTABLE_ASYNC_END_WITH_FLAGS0(category_group, name, id, \
                                                    flags)                    \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_END,     \
@@ -20510,30 +24806,37 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT, \
                                    category_group, name, id,                 \
                                    TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_NESTABLE_ASYNC_INSTANT1(category_group, name, id,        \
-                                            arg1_name, arg1_val)             \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT, \
-                                   category_group, name, id,                 \
-                                   TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
+#define TRACE_EVENT_NESTABLE_ASYNC_INSTANT1(category_group, name, id,     \
+                                            arg1_name, arg1_val)          \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                       \
+      TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT, category_group, name, id, \
+      TRACE_EVENT_FLAG_NONE, arg1_name,                                   \
+      ::perfetto::internal::PossiblyNull(arg1_val))
 #define TRACE_EVENT_NESTABLE_ASYNC_INSTANT2(                              \
     category_group, name, id, arg1_name, arg1_val, arg2_name, arg2_val)   \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                       \
       TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT, category_group, name, id, \
-      TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
+      TRACE_EVENT_FLAG_NONE, arg1_name,                                   \
+      ::perfetto::internal::PossiblyNull(arg1_val), arg2_name,            \
+      ::perfetto::internal::PossiblyNull(arg2_val))
 #define TRACE_EVENT_COPY_NESTABLE_ASYNC_BEGIN_WITH_TTS2(                \
     category_group, name, id, arg1_name, arg1_val, arg2_name, arg2_val) \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                     \
       TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group,           \
       ::perfetto::DynamicString{name}, id, TRACE_EVENT_FLAG_ASYNC_TTS,  \
-      ::perfetto::DynamicString{arg1_name}, arg1_val,                   \
-      ::perfetto::DynamicString{arg2_name}, arg2_val)
+      ::perfetto::DynamicString{arg1_name},                             \
+      ::perfetto::internal::PossiblyNull(arg1_val),                     \
+      ::perfetto::DynamicString{arg2_name},                             \
+      ::perfetto::internal::PossiblyNull(arg2_val))
 #define TRACE_EVENT_COPY_NESTABLE_ASYNC_END_WITH_TTS2(                  \
     category_group, name, id, arg1_name, arg1_val, arg2_name, arg2_val) \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                     \
       TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group,             \
       ::perfetto::DynamicString{name}, id, TRACE_EVENT_FLAG_ASYNC_TTS,  \
-      ::perfetto::DynamicString{arg1_name}, arg1_val,                   \
-      ::perfetto::DynamicString{arg2_name}, arg2_val)
+      ::perfetto::DynamicString{arg1_name},                             \
+      ::perfetto::internal::PossiblyNull(arg1_val),                     \
+      ::perfetto::DynamicString{arg2_name},                             \
+      ::perfetto::internal::PossiblyNull(arg2_val))
 
 // Async events with explicit timestamps.
 #define TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP0(category_group, name, \
@@ -20551,14 +24854,15 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
   INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                      \
       TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id,      \
       TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
-      arg1_name, arg1_val)
+      arg1_name, ::perfetto::internal::PossiblyNull(arg1_val))
 #define TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP2(                    \
     category_group, name, id, timestamp, arg1_name, arg1_val, arg2_name,   \
     arg2_val)                                                              \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                      \
       TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id,      \
       TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
-      arg1_name, arg1_val, arg2_name, arg2_val)
+      arg1_name, ::perfetto::internal::PossiblyNull(arg1_val), arg2_name,  \
+      ::perfetto::internal::PossiblyNull(arg2_val))
 #define TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP_AND_FLAGS0(     \
     category_group, name, id, timestamp, flags)                       \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                 \
@@ -20578,14 +24882,17 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                      \
       TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group,            \
       ::perfetto::DynamicString{name}, id, TRACE_EVENT_FLAG_NONE,        \
-      ::perfetto::DynamicString{arg1_name}, arg1_val)
+      ::perfetto::DynamicString{arg1_name},                              \
+      ::perfetto::internal::PossiblyNull(arg1_val))
 #define TRACE_EVENT_COPY_NESTABLE_ASYNC_BEGIN2(                         \
     category_group, name, id, arg1_name, arg1_val, arg2_name, arg2_val) \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                     \
       TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group,           \
       ::perfetto::DynamicString{name}, id, TRACE_EVENT_FLAG_NONE,       \
-      ::perfetto::DynamicString{arg1_name}, arg1_val,                   \
-      ::perfetto::DynamicString{arg2_name}, arg2_val)
+      ::perfetto::DynamicString{arg1_name},                             \
+      ::perfetto::internal::PossiblyNull(arg1_val),                     \
+      ::perfetto::DynamicString{arg2_name},                             \
+      ::perfetto::internal::PossiblyNull(arg2_val))
 #define TRACE_EVENT_COPY_NESTABLE_ASYNC_END0(category_group, name, id) \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                    \
       TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group,            \
@@ -20602,7 +24909,7 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
       TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group,                 \
       ::perfetto::DynamicString{name}, id, TRACE_EVENT_API_CURRENT_THREAD_ID, \
       timestamp, TRACE_EVENT_FLAG_NONE, ::perfetto::DynamicString{arg1_name}, \
-      arg1_val)
+      ::perfetto::internal::PossiblyNull(arg1_val))
 #define TRACE_EVENT_COPY_NESTABLE_ASYNC_END_WITH_TIMESTAMP0(                  \
     category_group, name, id, timestamp)                                      \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                         \
@@ -20615,12 +24922,16 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
   INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                      \
       TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id,      \
       TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
-      ::perfetto::DynamicString{arg1_name}, arg1_val,                      \
-      ::perfetto::DynamicString{arg2_name}, arg2_val)
+      ::perfetto::DynamicString{arg1_name},                                \
+      ::perfetto::internal::PossiblyNull(arg1_val),                        \
+      ::perfetto::DynamicString{arg2_name},                                \
+      ::perfetto::internal::PossiblyNull(arg2_val))
 
 // Metadata events.
 #define TRACE_EVENT_METADATA1(category_group, name, arg1_name, arg1_val) \
-  INTERNAL_TRACE_EVENT_METADATA_ADD(category_group, name, arg1_name, arg1_val)
+  INTERNAL_TRACE_EVENT_METADATA_ADD(                                     \
+      category_group, name, arg1_name,                                   \
+      ::perfetto::internal::PossiblyNull(arg1_val))
 
 // Clock sync events.
 #define TRACE_EVENT_CLOCK_SYNC_RECEIVER(sync_id)                           \
@@ -20644,13 +24955,6 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
       TRACE_EVENT_PHASE_SNAPSHOT_OBJECT, category_group, name, id,    \
       TRACE_EVENT_FLAG_NONE, "snapshot", snapshot)
 
-#define TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID_AND_TIMESTAMP(                 \
-    category_group, name, id, timestamp, snapshot)                         \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                      \
-      TRACE_EVENT_PHASE_SNAPSHOT_OBJECT, category_group, name, id,         \
-      TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
-      "snapshot", snapshot)
-
 #define TRACE_EVENT_OBJECT_DELETED_WITH_ID(category_group, name, id) \
   INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_DELETE_OBJECT,  \
                                    category_group, name, id,         \
@@ -20690,7 +24994,10 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
 // involvement from the embedder. APIs such as TRACE_EVENT_API_ADD_TRACE_EVENT
 // are still up to the embedder to define.
 
-#define TRACE_STR_COPY(str) (::perfetto::DynamicString{str})
+#define TRACE_STR_COPY(str)                 \
+  ::perfetto::DynamicString {               \
+    ::perfetto::internal::PossiblyNull(str) \
+  }
 
 #define TRACE_ID_WITH_SCOPE(scope, ...) \
   ::perfetto::internal::LegacyTraceId::WithScope(scope, ##__VA_ARGS__)
@@ -20708,19 +25015,19 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
 // non-zero indicates at least one tracing session for this category is active.
 // Note that callers should not make any assumptions at what each bit represents
 // in the status byte. Does not support dynamic categories.
-#define TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(category)              \
-  reinterpret_cast<const uint8_t*>(                                       \
-      [&] {                                                               \
-        static_assert(                                                    \
-            !std::is_same<::perfetto::DynamicCategory,                    \
-                          decltype(category)>::value,                     \
-            "Enabled flag pointers are not supported for dynamic trace "  \
-            "categories.");                                               \
-      },                                                                  \
-      PERFETTO_TRACK_EVENT_NAMESPACE::internal::kCategoryRegistry         \
-          .GetCategoryState(                                              \
-              PERFETTO_TRACK_EVENT_NAMESPACE::internal::kCategoryRegistry \
-                  .Find(category, /*is_dynamic=*/false)))
+#define TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(category)             \
+  reinterpret_cast<const uint8_t*>(                                      \
+      [&] {                                                              \
+        static_assert(                                                   \
+            !std::is_same<::perfetto::DynamicCategory,                   \
+                          decltype(category)>::value,                    \
+            "Enabled flag pointers are not supported for dynamic trace " \
+            "categories.");                                              \
+      },                                                                 \
+      PERFETTO_TRACK_EVENT_NAMESPACE::internal::kCategoryRegistry        \
+          .GetCategoryState(PERFETTO_TRACK_EVENT_NAMESPACE::internal::   \
+                                kConstExprCategoryRegistry.Find(         \
+                                    category, /*is_dynamic=*/false)))
 
 // Given a pointer returned by TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED,
 // yields a pointer to the name of the corresponding category group.
@@ -20778,6 +25085,494 @@ inline ::perfetto::StaticString GetEventNameTypeForLegacyEvents(
 // gen_amalgamated expanded: #include "perfetto/tracing/track_event_state_tracker.h"
 
 #endif  // INCLUDE_PERFETTO_TRACING_H_
+// gen_amalgamated begin header: include/perfetto/public/abi/atomic.h
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_PERFETTO_PUBLIC_ABI_ATOMIC_H_
+#define INCLUDE_PERFETTO_PUBLIC_ABI_ATOMIC_H_
+
+// Problem: C++11 and C11 use a different syntax for atomics and the C11 syntax
+// is not supported in C++11.
+//
+// This header bridges the gap.
+//
+// This assumes that C++11 atomics are binary compatible with C11 atomics. While
+// this is technically not required by the standards, reasonable compilers
+// appear to guarantee this.
+
+#ifdef __cplusplus
+#include <atomic>
+#else
+#include <stdatomic.h>
+#endif
+
+#ifdef __cplusplus
+#define PERFETTO_ATOMIC(TYPE) std::atomic<TYPE>
+#else
+#define PERFETTO_ATOMIC(TYPE) _Atomic(TYPE)
+#endif
+
+#ifdef __cplusplus
+#define PERFETTO_ATOMIC_LOAD std::atomic_load
+#define PERFETTO_ATOMIC_LOAD_EXPLICIT std::atomic_load_explicit
+#define PERFETTO_ATOMIC_STORE std::atomic_store
+#define PERFETTO_ATOMIC_STORE_EXPLICIT std::atomic_store_explicit
+
+#define PERFETTO_MEMORY_ORDER_ACQ_REL std::memory_order_acq_rel
+#define PERFETTO_MEMORY_ORDER_ACQUIRE std::memory_order_acquire
+#define PERFETTO_MEMORY_ORDER_CONSUME std::memory_order_consume
+#define PERFETTO_MEMORY_ORDER_RELAXED std::memory_order_relaxed
+#define PERFETTO_MEMORY_ORDER_RELEASE std::memory_order_release
+#define PERFETTO_MEMORY_ORDER_SEQ_CST std::memory_order_seq_cst
+#else
+#define PERFETTO_ATOMIC_LOAD atomic_load
+#define PERFETTO_ATOMIC_LOAD_EXPLICIT atomic_load_explicit
+#define PERFETTO_ATOMIC_STORE atomic_store
+#define PERFETTO_ATOMIC_STORE_EXPLICIT atomic_store_explicit
+
+#define PERFETTO_MEMORY_ORDER_ACQ_REL memory_order_acq_rel
+#define PERFETTO_MEMORY_ORDER_ACQUIRE memory_order_acquire
+#define PERFETTO_MEMORY_ORDER_CONSUME memory_order_consume
+#define PERFETTO_MEMORY_ORDER_RELAXED memory_order_relaxed
+#define PERFETTO_MEMORY_ORDER_RELEASE memory_order_release
+#define PERFETTO_MEMORY_ORDER_SEQ_CST memory_order_seq_cst
+#endif
+
+#endif  // INCLUDE_PERFETTO_PUBLIC_ABI_ATOMIC_H_
+// gen_amalgamated begin header: gen/protos/perfetto/protovm/vm_program.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_PROTOVM_VM_PROGRAM_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_PROTOVM_VM_PROGRAM_PROTO_CPP_H_
+
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+class VmOpDel;
+class VmOpSet;
+class VmOpMerge;
+class VmOpRegLoad;
+class VmOpSelect;
+class VmOpSelect_PathComponent;
+class VmInstruction;
+class VmProgram;
+enum VmCursorEnum : int;
+enum VmInstruction_AbortLevel : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+namespace protozero {
+class Message;
+}  // namespace protozero
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum VmCursorEnum : int {
+  VM_CURSOR_UNSPECIFIED = 0,
+  VM_CURSOR_SRC = 1,
+  VM_CURSOR_DST = 2,
+  VM_CURSOR_BOTH = 3,
+};
+enum VmInstruction_AbortLevel : int {
+  VmInstruction_AbortLevel_SKIP_CURRENT_INSTRUCTION = 1,
+  VmInstruction_AbortLevel_SKIP_CURRENT_INSTRUCTION_AND_BREAK_OUTER = 2,
+  VmInstruction_AbortLevel_ABORT = 3,
+};
+
+class PERFETTO_EXPORT_COMPONENT VmOpDel : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+  };
+
+  VmOpDel();
+  ~VmOpDel() override;
+  VmOpDel(VmOpDel&&) noexcept;
+  VmOpDel& operator=(VmOpDel&&);
+  VmOpDel(const VmOpDel&);
+  VmOpDel& operator=(const VmOpDel&);
+  bool operator==(const VmOpDel&) const;
+  bool operator!=(const VmOpDel& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+ private:
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<2> _has_field_{};
+};
+
+
+class PERFETTO_EXPORT_COMPONENT VmOpSet : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+  };
+
+  VmOpSet();
+  ~VmOpSet() override;
+  VmOpSet(VmOpSet&&) noexcept;
+  VmOpSet& operator=(VmOpSet&&);
+  VmOpSet(const VmOpSet&);
+  VmOpSet& operator=(const VmOpSet&);
+  bool operator==(const VmOpSet&) const;
+  bool operator!=(const VmOpSet& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+ private:
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<2> _has_field_{};
+};
+
+
+class PERFETTO_EXPORT_COMPONENT VmOpMerge : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+  };
+
+  VmOpMerge();
+  ~VmOpMerge() override;
+  VmOpMerge(VmOpMerge&&) noexcept;
+  VmOpMerge& operator=(VmOpMerge&&);
+  VmOpMerge(const VmOpMerge&);
+  VmOpMerge& operator=(const VmOpMerge&);
+  bool operator==(const VmOpMerge&) const;
+  bool operator!=(const VmOpMerge& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+ private:
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<2> _has_field_{};
+};
+
+
+class PERFETTO_EXPORT_COMPONENT VmOpRegLoad : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kCursorFieldNumber = 1,
+    kDstRegisterFieldNumber = 2,
+  };
+
+  VmOpRegLoad();
+  ~VmOpRegLoad() override;
+  VmOpRegLoad(VmOpRegLoad&&) noexcept;
+  VmOpRegLoad& operator=(VmOpRegLoad&&);
+  VmOpRegLoad(const VmOpRegLoad&);
+  VmOpRegLoad& operator=(const VmOpRegLoad&);
+  bool operator==(const VmOpRegLoad&) const;
+  bool operator!=(const VmOpRegLoad& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_cursor() const { return _has_field_[1]; }
+  VmCursorEnum cursor() const { return cursor_; }
+  void set_cursor(VmCursorEnum value) { cursor_ = value; _has_field_.set(1); }
+
+  bool has_dst_register() const { return _has_field_[2]; }
+  uint32_t dst_register() const { return dst_register_; }
+  void set_dst_register(uint32_t value) { dst_register_ = value; _has_field_.set(2); }
+
+ private:
+  VmCursorEnum cursor_{};
+  uint32_t dst_register_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<3> _has_field_{};
+};
+
+
+class PERFETTO_EXPORT_COMPONENT VmOpSelect : public ::protozero::CppMessageObj {
+ public:
+  using PathComponent = VmOpSelect_PathComponent;
+  enum FieldNumbers {
+    kCursorFieldNumber = 1,
+    kRelativePathFieldNumber = 2,
+    kCreateIfNotExistFieldNumber = 3,
+  };
+
+  VmOpSelect();
+  ~VmOpSelect() override;
+  VmOpSelect(VmOpSelect&&) noexcept;
+  VmOpSelect& operator=(VmOpSelect&&);
+  VmOpSelect(const VmOpSelect&);
+  VmOpSelect& operator=(const VmOpSelect&);
+  bool operator==(const VmOpSelect&) const;
+  bool operator!=(const VmOpSelect& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_cursor() const { return _has_field_[1]; }
+  VmCursorEnum cursor() const { return cursor_; }
+  void set_cursor(VmCursorEnum value) { cursor_ = value; _has_field_.set(1); }
+
+  const std::vector<VmOpSelect_PathComponent>& relative_path() const { return relative_path_; }
+  std::vector<VmOpSelect_PathComponent>* mutable_relative_path() { return &relative_path_; }
+  int relative_path_size() const;
+  void clear_relative_path();
+  VmOpSelect_PathComponent* add_relative_path();
+
+  bool has_create_if_not_exist() const { return _has_field_[3]; }
+  bool create_if_not_exist() const { return create_if_not_exist_; }
+  void set_create_if_not_exist(bool value) { create_if_not_exist_ = value; _has_field_.set(3); }
+
+ private:
+  VmCursorEnum cursor_{};
+  std::vector<VmOpSelect_PathComponent> relative_path_;
+  bool create_if_not_exist_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<4> _has_field_{};
+};
+
+
+class PERFETTO_EXPORT_COMPONENT VmOpSelect_PathComponent : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kFieldIdFieldNumber = 1,
+    kArrayIndexFieldNumber = 2,
+    kMapKeyFieldIdFieldNumber = 3,
+    kIsRepeatedFieldNumber = 5,
+    kRegisterToMatchFieldNumber = 6,
+    kStoreForeachIndexIntoRegisterFieldNumber = 7,
+  };
+
+  VmOpSelect_PathComponent();
+  ~VmOpSelect_PathComponent() override;
+  VmOpSelect_PathComponent(VmOpSelect_PathComponent&&) noexcept;
+  VmOpSelect_PathComponent& operator=(VmOpSelect_PathComponent&&);
+  VmOpSelect_PathComponent(const VmOpSelect_PathComponent&);
+  VmOpSelect_PathComponent& operator=(const VmOpSelect_PathComponent&);
+  bool operator==(const VmOpSelect_PathComponent&) const;
+  bool operator!=(const VmOpSelect_PathComponent& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_field_id() const { return _has_field_[1]; }
+  uint32_t field_id() const { return field_id_; }
+  void set_field_id(uint32_t value) { field_id_ = value; _has_field_.set(1); }
+
+  bool has_array_index() const { return _has_field_[2]; }
+  uint32_t array_index() const { return array_index_; }
+  void set_array_index(uint32_t value) { array_index_ = value; _has_field_.set(2); }
+
+  bool has_map_key_field_id() const { return _has_field_[3]; }
+  uint32_t map_key_field_id() const { return map_key_field_id_; }
+  void set_map_key_field_id(uint32_t value) { map_key_field_id_ = value; _has_field_.set(3); }
+
+  bool has_is_repeated() const { return _has_field_[5]; }
+  bool is_repeated() const { return is_repeated_; }
+  void set_is_repeated(bool value) { is_repeated_ = value; _has_field_.set(5); }
+
+  bool has_register_to_match() const { return _has_field_[6]; }
+  uint32_t register_to_match() const { return register_to_match_; }
+  void set_register_to_match(uint32_t value) { register_to_match_ = value; _has_field_.set(6); }
+
+  bool has_store_foreach_index_into_register() const { return _has_field_[7]; }
+  uint32_t store_foreach_index_into_register() const { return store_foreach_index_into_register_; }
+  void set_store_foreach_index_into_register(uint32_t value) { store_foreach_index_into_register_ = value; _has_field_.set(7); }
+
+ private:
+  uint32_t field_id_{};
+  uint32_t array_index_{};
+  uint32_t map_key_field_id_{};
+  bool is_repeated_{};
+  uint32_t register_to_match_{};
+  uint32_t store_foreach_index_into_register_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<8> _has_field_{};
+};
+
+
+class PERFETTO_EXPORT_COMPONENT VmInstruction : public ::protozero::CppMessageObj {
+ public:
+  using AbortLevel = VmInstruction_AbortLevel;
+  static constexpr auto SKIP_CURRENT_INSTRUCTION = VmInstruction_AbortLevel_SKIP_CURRENT_INSTRUCTION;
+  static constexpr auto SKIP_CURRENT_INSTRUCTION_AND_BREAK_OUTER = VmInstruction_AbortLevel_SKIP_CURRENT_INSTRUCTION_AND_BREAK_OUTER;
+  static constexpr auto ABORT = VmInstruction_AbortLevel_ABORT;
+  static constexpr auto AbortLevel_MIN = VmInstruction_AbortLevel_SKIP_CURRENT_INSTRUCTION;
+  static constexpr auto AbortLevel_MAX = VmInstruction_AbortLevel_ABORT;
+  enum FieldNumbers {
+    kSelectFieldNumber = 1,
+    kRegLoadFieldNumber = 2,
+    kMergeFieldNumber = 3,
+    kSetFieldNumber = 4,
+    kDelFieldNumber = 5,
+    kAbortLevelFieldNumber = 6,
+    kNestedInstructionsFieldNumber = 7,
+  };
+
+  VmInstruction();
+  ~VmInstruction() override;
+  VmInstruction(VmInstruction&&) noexcept;
+  VmInstruction& operator=(VmInstruction&&);
+  VmInstruction(const VmInstruction&);
+  VmInstruction& operator=(const VmInstruction&);
+  bool operator==(const VmInstruction&) const;
+  bool operator!=(const VmInstruction& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_select() const { return _has_field_[1]; }
+  const VmOpSelect& select() const { return *select_; }
+  VmOpSelect* mutable_select() { _has_field_.set(1); return select_.get(); }
+
+  bool has_reg_load() const { return _has_field_[2]; }
+  const VmOpRegLoad& reg_load() const { return *reg_load_; }
+  VmOpRegLoad* mutable_reg_load() { _has_field_.set(2); return reg_load_.get(); }
+
+  bool has_merge() const { return _has_field_[3]; }
+  const VmOpMerge& merge() const { return *merge_; }
+  VmOpMerge* mutable_merge() { _has_field_.set(3); return merge_.get(); }
+
+  bool has_set() const { return _has_field_[4]; }
+  const VmOpSet& set() const { return *set_; }
+  VmOpSet* mutable_set() { _has_field_.set(4); return set_.get(); }
+
+  bool has_del() const { return _has_field_[5]; }
+  const VmOpDel& del() const { return *del_; }
+  VmOpDel* mutable_del() { _has_field_.set(5); return del_.get(); }
+
+  bool has_abort_level() const { return _has_field_[6]; }
+  VmInstruction_AbortLevel abort_level() const { return abort_level_; }
+  void set_abort_level(VmInstruction_AbortLevel value) { abort_level_ = value; _has_field_.set(6); }
+
+  const std::vector<VmInstruction>& nested_instructions() const { return nested_instructions_; }
+  std::vector<VmInstruction>* mutable_nested_instructions() { return &nested_instructions_; }
+  int nested_instructions_size() const;
+  void clear_nested_instructions();
+  VmInstruction* add_nested_instructions();
+
+ private:
+  ::protozero::CopyablePtr<VmOpSelect> select_;
+  ::protozero::CopyablePtr<VmOpRegLoad> reg_load_;
+  ::protozero::CopyablePtr<VmOpMerge> merge_;
+  ::protozero::CopyablePtr<VmOpSet> set_;
+  ::protozero::CopyablePtr<VmOpDel> del_;
+  VmInstruction_AbortLevel abort_level_{};
+  std::vector<VmInstruction> nested_instructions_;
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<8> _has_field_{};
+};
+
+
+class PERFETTO_EXPORT_COMPONENT VmProgram : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kVersionFieldNumber = 1,
+    kInstructionsFieldNumber = 2,
+  };
+
+  VmProgram();
+  ~VmProgram() override;
+  VmProgram(VmProgram&&) noexcept;
+  VmProgram& operator=(VmProgram&&);
+  VmProgram(const VmProgram&);
+  VmProgram& operator=(const VmProgram&);
+  bool operator==(const VmProgram&) const;
+  bool operator!=(const VmProgram& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_version() const { return _has_field_[1]; }
+  uint32_t version() const { return version_; }
+  void set_version(uint32_t value) { version_ = value; _has_field_.set(1); }
+
+  const std::vector<VmInstruction>& instructions() const { return instructions_; }
+  std::vector<VmInstruction>* mutable_instructions() { return &instructions_; }
+  int instructions_size() const;
+  void clear_instructions();
+  VmInstruction* add_instructions();
+
+ private:
+  uint32_t version_{};
+  std::vector<VmInstruction> instructions_;
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<3> _has_field_{};
+};
+
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_PROTOVM_VM_PROGRAM_PROTO_CPP_H_
 // gen_amalgamated begin header: gen/protos/perfetto/common/android_energy_consumer_descriptor.gen.h
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
 #ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_ANDROID_ENERGY_CONSUMER_DESCRIPTOR_PROTO_CPP_H_
@@ -20998,6 +25793,9 @@ enum BuiltinClock : int {
   BUILTIN_CLOCK_MONOTONIC_COARSE = 4,
   BUILTIN_CLOCK_MONOTONIC_RAW = 5,
   BUILTIN_CLOCK_BOOTTIME = 6,
+  BUILTIN_CLOCK_TSC = 9,
+  BUILTIN_CLOCK_PERF = 10,
+  BUILTIN_CLOCK_TRACE_FILE = 11,
   BUILTIN_CLOCK_MAX_ID = 63,
 };
 }  // namespace perfetto
@@ -21202,6 +26000,8 @@ class PERFETTO_EXPORT_COMPONENT CommitDataRequest_ChunksToMove : public ::protoz
     kPageFieldNumber = 1,
     kChunkFieldNumber = 2,
     kTargetBufferFieldNumber = 3,
+    kDataFieldNumber = 4,
+    kChunkIncompleteFieldNumber = 5,
   };
 
   CommitDataRequest_ChunksToMove();
@@ -21230,16 +26030,27 @@ class PERFETTO_EXPORT_COMPONENT CommitDataRequest_ChunksToMove : public ::protoz
   uint32_t target_buffer() const { return target_buffer_; }
   void set_target_buffer(uint32_t value) { target_buffer_ = value; _has_field_.set(3); }
 
+  bool has_data() const { return _has_field_[4]; }
+  const std::string& data() const { return data_; }
+  void set_data(const std::string& value) { data_ = value; _has_field_.set(4); }
+  void set_data(const void* p, size_t s) { data_.assign(reinterpret_cast<const char*>(p), s); _has_field_.set(4); }
+
+  bool has_chunk_incomplete() const { return _has_field_[5]; }
+  bool chunk_incomplete() const { return chunk_incomplete_; }
+  void set_chunk_incomplete(bool value) { chunk_incomplete_ = value; _has_field_.set(5); }
+
  private:
   uint32_t page_{};
   uint32_t chunk_{};
   uint32_t target_buffer_{};
+  std::string data_{};
+  bool chunk_incomplete_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<4> _has_field_{};
+  std::bitset<6> _has_field_{};
 };
 
 }  // namespace perfetto
@@ -21247,115 +26058,6 @@ class PERFETTO_EXPORT_COMPONENT CommitDataRequest_ChunksToMove : public ::protoz
 }  // namespace gen
 
 #endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_COMMIT_DATA_REQUEST_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/common/data_source_descriptor.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_DATA_SOURCE_DESCRIPTOR_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_DATA_SOURCE_DESCRIPTOR_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class DataSourceDescriptor;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT DataSourceDescriptor : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kNameFieldNumber = 1,
-    kIdFieldNumber = 7,
-    kWillNotifyOnStopFieldNumber = 2,
-    kWillNotifyOnStartFieldNumber = 3,
-    kHandlesIncrementalStateClearFieldNumber = 4,
-    kGpuCounterDescriptorFieldNumber = 5,
-    kTrackEventDescriptorFieldNumber = 6,
-    kFtraceDescriptorFieldNumber = 8,
-  };
-
-  DataSourceDescriptor();
-  ~DataSourceDescriptor() override;
-  DataSourceDescriptor(DataSourceDescriptor&&) noexcept;
-  DataSourceDescriptor& operator=(DataSourceDescriptor&&);
-  DataSourceDescriptor(const DataSourceDescriptor&);
-  DataSourceDescriptor& operator=(const DataSourceDescriptor&);
-  bool operator==(const DataSourceDescriptor&) const;
-  bool operator!=(const DataSourceDescriptor& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_name() const { return _has_field_[1]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
-
-  bool has_id() const { return _has_field_[7]; }
-  uint64_t id() const { return id_; }
-  void set_id(uint64_t value) { id_ = value; _has_field_.set(7); }
-
-  bool has_will_notify_on_stop() const { return _has_field_[2]; }
-  bool will_notify_on_stop() const { return will_notify_on_stop_; }
-  void set_will_notify_on_stop(bool value) { will_notify_on_stop_ = value; _has_field_.set(2); }
-
-  bool has_will_notify_on_start() const { return _has_field_[3]; }
-  bool will_notify_on_start() const { return will_notify_on_start_; }
-  void set_will_notify_on_start(bool value) { will_notify_on_start_ = value; _has_field_.set(3); }
-
-  bool has_handles_incremental_state_clear() const { return _has_field_[4]; }
-  bool handles_incremental_state_clear() const { return handles_incremental_state_clear_; }
-  void set_handles_incremental_state_clear(bool value) { handles_incremental_state_clear_ = value; _has_field_.set(4); }
-
-  const std::string& gpu_counter_descriptor_raw() const { return gpu_counter_descriptor_; }
-  void set_gpu_counter_descriptor_raw(const std::string& raw) { gpu_counter_descriptor_ = raw; _has_field_.set(5); }
-
-  const std::string& track_event_descriptor_raw() const { return track_event_descriptor_; }
-  void set_track_event_descriptor_raw(const std::string& raw) { track_event_descriptor_ = raw; _has_field_.set(6); }
-
-  const std::string& ftrace_descriptor_raw() const { return ftrace_descriptor_; }
-  void set_ftrace_descriptor_raw(const std::string& raw) { ftrace_descriptor_ = raw; _has_field_.set(8); }
-
- private:
-  std::string name_{};
-  uint64_t id_{};
-  bool will_notify_on_stop_{};
-  bool will_notify_on_start_{};
-  bool handles_incremental_state_clear_{};
-  std::string gpu_counter_descriptor_;  // [lazy=true]
-  std::string track_event_descriptor_;  // [lazy=true]
-  std::string ftrace_descriptor_;  // [lazy=true]
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<9> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_DATA_SOURCE_DESCRIPTOR_PROTO_CPP_H_
 // gen_amalgamated begin header: gen/protos/perfetto/common/descriptor.gen.h
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
 #ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_DESCRIPTOR_PROTO_CPP_H_
@@ -21379,6 +26081,9 @@ class EnumValueDescriptorProto;
 class EnumDescriptorProto;
 class OneofDescriptorProto;
 class FieldDescriptorProto;
+class FieldOptions;
+class UninterpretedOption;
+class UninterpretedOption_NamePart;
 class DescriptorProto;
 class DescriptorProto_ReservedRange;
 class FileDescriptorProto;
@@ -21622,6 +26327,7 @@ class PERFETTO_EXPORT_COMPONENT FieldDescriptorProto : public ::protozero::CppMe
     kTypeNameFieldNumber = 6,
     kExtendeeFieldNumber = 2,
     kDefaultValueFieldNumber = 7,
+    kOptionsFieldNumber = 8,
     kOneofIndexFieldNumber = 9,
   };
 
@@ -21667,6 +26373,10 @@ class PERFETTO_EXPORT_COMPONENT FieldDescriptorProto : public ::protozero::CppMe
   const std::string& default_value() const { return default_value_; }
   void set_default_value(const std::string& value) { default_value_ = value; _has_field_.set(7); }
 
+  bool has_options() const { return _has_field_[8]; }
+  const FieldOptions& options() const { return *options_; }
+  FieldOptions* mutable_options() { _has_field_.set(8); return options_.get(); }
+
   bool has_oneof_index() const { return _has_field_[9]; }
   int32_t oneof_index() const { return oneof_index_; }
   void set_oneof_index(int32_t value) { oneof_index_ = value; _has_field_.set(9); }
@@ -21679,6 +26389,7 @@ class PERFETTO_EXPORT_COMPONENT FieldDescriptorProto : public ::protozero::CppMe
   std::string type_name_{};
   std::string extendee_{};
   std::string default_value_{};
+  ::protozero::CopyablePtr<FieldOptions> options_;
   int32_t oneof_index_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
@@ -21689,6 +26400,165 @@ class PERFETTO_EXPORT_COMPONENT FieldDescriptorProto : public ::protozero::CppMe
 };
 
 
+class PERFETTO_EXPORT_COMPONENT FieldOptions : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kPackedFieldNumber = 2,
+    kUninterpretedOptionFieldNumber = 999,
+  };
+
+  FieldOptions();
+  ~FieldOptions() override;
+  FieldOptions(FieldOptions&&) noexcept;
+  FieldOptions& operator=(FieldOptions&&);
+  FieldOptions(const FieldOptions&);
+  FieldOptions& operator=(const FieldOptions&);
+  bool operator==(const FieldOptions&) const;
+  bool operator!=(const FieldOptions& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_packed() const { return _has_field_[2]; }
+  bool packed() const { return packed_; }
+  void set_packed(bool value) { packed_ = value; _has_field_.set(2); }
+
+  const std::vector<UninterpretedOption>& uninterpreted_option() const { return uninterpreted_option_; }
+  std::vector<UninterpretedOption>* mutable_uninterpreted_option() { return &uninterpreted_option_; }
+  int uninterpreted_option_size() const;
+  void clear_uninterpreted_option();
+  UninterpretedOption* add_uninterpreted_option();
+
+ private:
+  bool packed_{};
+  std::vector<UninterpretedOption> uninterpreted_option_;
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<1000> _has_field_{};
+};
+
+
+class PERFETTO_EXPORT_COMPONENT UninterpretedOption : public ::protozero::CppMessageObj {
+ public:
+  using NamePart = UninterpretedOption_NamePart;
+  enum FieldNumbers {
+    kNameFieldNumber = 2,
+    kIdentifierValueFieldNumber = 3,
+    kPositiveIntValueFieldNumber = 4,
+    kNegativeIntValueFieldNumber = 5,
+    kDoubleValueFieldNumber = 6,
+    kStringValueFieldNumber = 7,
+    kAggregateValueFieldNumber = 8,
+  };
+
+  UninterpretedOption();
+  ~UninterpretedOption() override;
+  UninterpretedOption(UninterpretedOption&&) noexcept;
+  UninterpretedOption& operator=(UninterpretedOption&&);
+  UninterpretedOption(const UninterpretedOption&);
+  UninterpretedOption& operator=(const UninterpretedOption&);
+  bool operator==(const UninterpretedOption&) const;
+  bool operator!=(const UninterpretedOption& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  const std::vector<UninterpretedOption_NamePart>& name() const { return name_; }
+  std::vector<UninterpretedOption_NamePart>* mutable_name() { return &name_; }
+  int name_size() const;
+  void clear_name();
+  UninterpretedOption_NamePart* add_name();
+
+  bool has_identifier_value() const { return _has_field_[3]; }
+  const std::string& identifier_value() const { return identifier_value_; }
+  void set_identifier_value(const std::string& value) { identifier_value_ = value; _has_field_.set(3); }
+
+  bool has_positive_int_value() const { return _has_field_[4]; }
+  uint64_t positive_int_value() const { return positive_int_value_; }
+  void set_positive_int_value(uint64_t value) { positive_int_value_ = value; _has_field_.set(4); }
+
+  bool has_negative_int_value() const { return _has_field_[5]; }
+  int64_t negative_int_value() const { return negative_int_value_; }
+  void set_negative_int_value(int64_t value) { negative_int_value_ = value; _has_field_.set(5); }
+
+  bool has_double_value() const { return _has_field_[6]; }
+  double double_value() const { return double_value_; }
+  void set_double_value(double value) { double_value_ = value; _has_field_.set(6); }
+
+  bool has_string_value() const { return _has_field_[7]; }
+  const std::string& string_value() const { return string_value_; }
+  void set_string_value(const std::string& value) { string_value_ = value; _has_field_.set(7); }
+  void set_string_value(const void* p, size_t s) { string_value_.assign(reinterpret_cast<const char*>(p), s); _has_field_.set(7); }
+
+  bool has_aggregate_value() const { return _has_field_[8]; }
+  const std::string& aggregate_value() const { return aggregate_value_; }
+  void set_aggregate_value(const std::string& value) { aggregate_value_ = value; _has_field_.set(8); }
+
+ private:
+  std::vector<UninterpretedOption_NamePart> name_;
+  std::string identifier_value_{};
+  uint64_t positive_int_value_{};
+  int64_t negative_int_value_{};
+  double double_value_{};
+  std::string string_value_{};
+  std::string aggregate_value_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<9> _has_field_{};
+};
+
+
+class PERFETTO_EXPORT_COMPONENT UninterpretedOption_NamePart : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kNamePartFieldNumber = 1,
+    kIsExtensionFieldNumber = 2,
+  };
+
+  UninterpretedOption_NamePart();
+  ~UninterpretedOption_NamePart() override;
+  UninterpretedOption_NamePart(UninterpretedOption_NamePart&&) noexcept;
+  UninterpretedOption_NamePart& operator=(UninterpretedOption_NamePart&&);
+  UninterpretedOption_NamePart(const UninterpretedOption_NamePart&);
+  UninterpretedOption_NamePart& operator=(const UninterpretedOption_NamePart&);
+  bool operator==(const UninterpretedOption_NamePart&) const;
+  bool operator!=(const UninterpretedOption_NamePart& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_name_part() const { return _has_field_[1]; }
+  const std::string& name_part() const { return name_part_; }
+  void set_name_part(const std::string& value) { name_part_ = value; _has_field_.set(1); }
+
+  bool has_is_extension() const { return _has_field_[2]; }
+  bool is_extension() const { return is_extension_; }
+  void set_is_extension(bool value) { is_extension_ = value; _has_field_.set(2); }
+
+ private:
+  std::string name_part_{};
+  bool is_extension_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<3> _has_field_{};
+};
+
+
 class PERFETTO_EXPORT_COMPONENT DescriptorProto : public ::protozero::CppMessageObj {
  public:
   using ReservedRange = DescriptorProto_ReservedRange;
@@ -22113,6 +26983,7 @@ enum GpuCounterDescriptor_GpuCounterGroup : int {
   GpuCounterDescriptor_GpuCounterGroup_PRIMITIVES = 4,
   GpuCounterDescriptor_GpuCounterGroup_MEMORY = 5,
   GpuCounterDescriptor_GpuCounterGroup_COMPUTE = 6,
+  GpuCounterDescriptor_GpuCounterGroup_RAY_TRACING = 7,
 };
 enum GpuCounterDescriptor_MeasureUnit : int {
   GpuCounterDescriptor_MeasureUnit_NONE = 0,
@@ -22170,8 +27041,9 @@ class PERFETTO_EXPORT_COMPONENT GpuCounterDescriptor : public ::protozero::CppMe
   static constexpr auto PRIMITIVES = GpuCounterDescriptor_GpuCounterGroup_PRIMITIVES;
   static constexpr auto MEMORY = GpuCounterDescriptor_GpuCounterGroup_MEMORY;
   static constexpr auto COMPUTE = GpuCounterDescriptor_GpuCounterGroup_COMPUTE;
+  static constexpr auto RAY_TRACING = GpuCounterDescriptor_GpuCounterGroup_RAY_TRACING;
   static constexpr auto GpuCounterGroup_MIN = GpuCounterDescriptor_GpuCounterGroup_UNCLASSIFIED;
-  static constexpr auto GpuCounterGroup_MAX = GpuCounterDescriptor_GpuCounterGroup_COMPUTE;
+  static constexpr auto GpuCounterGroup_MAX = GpuCounterDescriptor_GpuCounterGroup_RAY_TRACING;
   using MeasureUnit = GpuCounterDescriptor_MeasureUnit;
   static constexpr auto NONE = GpuCounterDescriptor_MeasureUnit_NONE;
   static constexpr auto BIT = GpuCounterDescriptor_MeasureUnit_BIT;
@@ -22524,6 +27396,7 @@ namespace perfetto {
 namespace protos {
 namespace gen {
 class ObservableEvents;
+class ObservableEvents_CloneTriggerHit;
 class ObservableEvents_DataSourceInstanceStateChange;
 enum ObservableEvents_Type : int;
 enum ObservableEvents_DataSourceInstanceState : int;
@@ -22542,6 +27415,7 @@ enum ObservableEvents_Type : int {
   ObservableEvents_Type_TYPE_UNSPECIFIED = 0,
   ObservableEvents_Type_TYPE_DATA_SOURCES_INSTANCES = 1,
   ObservableEvents_Type_TYPE_ALL_DATA_SOURCES_STARTED = 2,
+  ObservableEvents_Type_TYPE_CLONE_TRIGGER_HIT = 4,
 };
 enum ObservableEvents_DataSourceInstanceState : int {
   ObservableEvents_DataSourceInstanceState_DATA_SOURCE_INSTANCE_STATE_STOPPED = 1,
@@ -22551,12 +27425,14 @@ enum ObservableEvents_DataSourceInstanceState : int {
 class PERFETTO_EXPORT_COMPONENT ObservableEvents : public ::protozero::CppMessageObj {
  public:
   using DataSourceInstanceStateChange = ObservableEvents_DataSourceInstanceStateChange;
+  using CloneTriggerHit = ObservableEvents_CloneTriggerHit;
   using Type = ObservableEvents_Type;
   static constexpr auto TYPE_UNSPECIFIED = ObservableEvents_Type_TYPE_UNSPECIFIED;
   static constexpr auto TYPE_DATA_SOURCES_INSTANCES = ObservableEvents_Type_TYPE_DATA_SOURCES_INSTANCES;
   static constexpr auto TYPE_ALL_DATA_SOURCES_STARTED = ObservableEvents_Type_TYPE_ALL_DATA_SOURCES_STARTED;
+  static constexpr auto TYPE_CLONE_TRIGGER_HIT = ObservableEvents_Type_TYPE_CLONE_TRIGGER_HIT;
   static constexpr auto Type_MIN = ObservableEvents_Type_TYPE_UNSPECIFIED;
-  static constexpr auto Type_MAX = ObservableEvents_Type_TYPE_ALL_DATA_SOURCES_STARTED;
+  static constexpr auto Type_MAX = ObservableEvents_Type_TYPE_CLONE_TRIGGER_HIT;
   using DataSourceInstanceState = ObservableEvents_DataSourceInstanceState;
   static constexpr auto DATA_SOURCE_INSTANCE_STATE_STOPPED = ObservableEvents_DataSourceInstanceState_DATA_SOURCE_INSTANCE_STATE_STOPPED;
   static constexpr auto DATA_SOURCE_INSTANCE_STATE_STARTED = ObservableEvents_DataSourceInstanceState_DATA_SOURCE_INSTANCE_STATE_STARTED;
@@ -22565,6 +27441,7 @@ class PERFETTO_EXPORT_COMPONENT ObservableEvents : public ::protozero::CppMessag
   enum FieldNumbers {
     kInstanceStateChangesFieldNumber = 1,
     kAllDataSourcesStartedFieldNumber = 2,
+    kCloneTriggerHitFieldNumber = 3,
   };
 
   ObservableEvents();
@@ -22591,15 +27468,85 @@ class PERFETTO_EXPORT_COMPONENT ObservableEvents : public ::protozero::CppMessag
   bool all_data_sources_started() const { return all_data_sources_started_; }
   void set_all_data_sources_started(bool value) { all_data_sources_started_ = value; _has_field_.set(2); }
 
+  bool has_clone_trigger_hit() const { return _has_field_[3]; }
+  const ObservableEvents_CloneTriggerHit& clone_trigger_hit() const { return *clone_trigger_hit_; }
+  ObservableEvents_CloneTriggerHit* mutable_clone_trigger_hit() { _has_field_.set(3); return clone_trigger_hit_.get(); }
+
  private:
   std::vector<ObservableEvents_DataSourceInstanceStateChange> instance_state_changes_;
   bool all_data_sources_started_{};
+  ::protozero::CopyablePtr<ObservableEvents_CloneTriggerHit> clone_trigger_hit_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<3> _has_field_{};
+  std::bitset<4> _has_field_{};
+};
+
+
+class PERFETTO_EXPORT_COMPONENT ObservableEvents_CloneTriggerHit : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kTracingSessionIdFieldNumber = 1,
+    kTriggerNameFieldNumber = 2,
+    kProducerNameFieldNumber = 3,
+    kProducerUidFieldNumber = 4,
+    kBootTimeNsFieldNumber = 5,
+    kTriggerDelayMsFieldNumber = 6,
+  };
+
+  ObservableEvents_CloneTriggerHit();
+  ~ObservableEvents_CloneTriggerHit() override;
+  ObservableEvents_CloneTriggerHit(ObservableEvents_CloneTriggerHit&&) noexcept;
+  ObservableEvents_CloneTriggerHit& operator=(ObservableEvents_CloneTriggerHit&&);
+  ObservableEvents_CloneTriggerHit(const ObservableEvents_CloneTriggerHit&);
+  ObservableEvents_CloneTriggerHit& operator=(const ObservableEvents_CloneTriggerHit&);
+  bool operator==(const ObservableEvents_CloneTriggerHit&) const;
+  bool operator!=(const ObservableEvents_CloneTriggerHit& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_tracing_session_id() const { return _has_field_[1]; }
+  int64_t tracing_session_id() const { return tracing_session_id_; }
+  void set_tracing_session_id(int64_t value) { tracing_session_id_ = value; _has_field_.set(1); }
+
+  bool has_trigger_name() const { return _has_field_[2]; }
+  const std::string& trigger_name() const { return trigger_name_; }
+  void set_trigger_name(const std::string& value) { trigger_name_ = value; _has_field_.set(2); }
+
+  bool has_producer_name() const { return _has_field_[3]; }
+  const std::string& producer_name() const { return producer_name_; }
+  void set_producer_name(const std::string& value) { producer_name_ = value; _has_field_.set(3); }
+
+  bool has_producer_uid() const { return _has_field_[4]; }
+  uint32_t producer_uid() const { return producer_uid_; }
+  void set_producer_uid(uint32_t value) { producer_uid_ = value; _has_field_.set(4); }
+
+  bool has_boot_time_ns() const { return _has_field_[5]; }
+  uint64_t boot_time_ns() const { return boot_time_ns_; }
+  void set_boot_time_ns(uint64_t value) { boot_time_ns_ = value; _has_field_.set(5); }
+
+  bool has_trigger_delay_ms() const { return _has_field_[6]; }
+  uint64_t trigger_delay_ms() const { return trigger_delay_ms_; }
+  void set_trigger_delay_ms(uint64_t value) { trigger_delay_ms_ = value; _has_field_.set(6); }
+
+ private:
+  int64_t tracing_session_id_{};
+  std::string trigger_name_{};
+  std::string producer_name_{};
+  uint32_t producer_uid_{};
+  uint64_t boot_time_ns_{};
+  uint64_t trigger_delay_ms_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<7> _has_field_{};
 };
 
 
@@ -22672,11 +27619,13 @@ class PERFETTO_EXPORT_COMPONENT ObservableEvents_DataSourceInstanceStateChange :
 namespace perfetto {
 namespace protos {
 namespace gen {
-class PerfEvents;
+class FollowerEvent;
 class PerfEvents_RawEvent;
 class PerfEvents_Tracepoint;
+class PerfEvents;
 class PerfEvents_Timebase;
 enum PerfEvents_Counter : int;
+enum PerfEvents_EventModifier : int;
 enum PerfEvents_PerfClock : int;
 }  // namespace perfetto
 }  // namespace protos
@@ -22712,6 +27661,12 @@ enum PerfEvents_Counter : int {
   PerfEvents_Counter_HW_STALLED_CYCLES_BACKEND = 18,
   PerfEvents_Counter_HW_REF_CPU_CYCLES = 19,
 };
+enum PerfEvents_EventModifier : int {
+  PerfEvents_EventModifier_UNKNOWN_EVENT_MODIFIER = 0,
+  PerfEvents_EventModifier_EVENT_MODIFIER_COUNT_USERSPACE = 1,
+  PerfEvents_EventModifier_EVENT_MODIFIER_COUNT_KERNEL = 2,
+  PerfEvents_EventModifier_EVENT_MODIFIER_COUNT_HYPERVISOR = 3,
+};
 enum PerfEvents_PerfClock : int {
   PerfEvents_PerfClock_UNKNOWN_PERF_CLOCK = 0,
   PerfEvents_PerfClock_PERF_CLOCK_REALTIME = 1,
@@ -22720,67 +27675,65 @@ enum PerfEvents_PerfClock : int {
   PerfEvents_PerfClock_PERF_CLOCK_BOOTTIME = 4,
 };
 
-class PERFETTO_EXPORT_COMPONENT PerfEvents : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT FollowerEvent : public ::protozero::CppMessageObj {
  public:
-  using Timebase = PerfEvents_Timebase;
-  using Tracepoint = PerfEvents_Tracepoint;
-  using RawEvent = PerfEvents_RawEvent;
-  using Counter = PerfEvents_Counter;
-  static constexpr auto UNKNOWN_COUNTER = PerfEvents_Counter_UNKNOWN_COUNTER;
-  static constexpr auto SW_CPU_CLOCK = PerfEvents_Counter_SW_CPU_CLOCK;
-  static constexpr auto SW_PAGE_FAULTS = PerfEvents_Counter_SW_PAGE_FAULTS;
-  static constexpr auto SW_TASK_CLOCK = PerfEvents_Counter_SW_TASK_CLOCK;
-  static constexpr auto SW_CONTEXT_SWITCHES = PerfEvents_Counter_SW_CONTEXT_SWITCHES;
-  static constexpr auto SW_CPU_MIGRATIONS = PerfEvents_Counter_SW_CPU_MIGRATIONS;
-  static constexpr auto SW_PAGE_FAULTS_MIN = PerfEvents_Counter_SW_PAGE_FAULTS_MIN;
-  static constexpr auto SW_PAGE_FAULTS_MAJ = PerfEvents_Counter_SW_PAGE_FAULTS_MAJ;
-  static constexpr auto SW_ALIGNMENT_FAULTS = PerfEvents_Counter_SW_ALIGNMENT_FAULTS;
-  static constexpr auto SW_EMULATION_FAULTS = PerfEvents_Counter_SW_EMULATION_FAULTS;
-  static constexpr auto SW_DUMMY = PerfEvents_Counter_SW_DUMMY;
-  static constexpr auto HW_CPU_CYCLES = PerfEvents_Counter_HW_CPU_CYCLES;
-  static constexpr auto HW_INSTRUCTIONS = PerfEvents_Counter_HW_INSTRUCTIONS;
-  static constexpr auto HW_CACHE_REFERENCES = PerfEvents_Counter_HW_CACHE_REFERENCES;
-  static constexpr auto HW_CACHE_MISSES = PerfEvents_Counter_HW_CACHE_MISSES;
-  static constexpr auto HW_BRANCH_INSTRUCTIONS = PerfEvents_Counter_HW_BRANCH_INSTRUCTIONS;
-  static constexpr auto HW_BRANCH_MISSES = PerfEvents_Counter_HW_BRANCH_MISSES;
-  static constexpr auto HW_BUS_CYCLES = PerfEvents_Counter_HW_BUS_CYCLES;
-  static constexpr auto HW_STALLED_CYCLES_FRONTEND = PerfEvents_Counter_HW_STALLED_CYCLES_FRONTEND;
-  static constexpr auto HW_STALLED_CYCLES_BACKEND = PerfEvents_Counter_HW_STALLED_CYCLES_BACKEND;
-  static constexpr auto HW_REF_CPU_CYCLES = PerfEvents_Counter_HW_REF_CPU_CYCLES;
-  static constexpr auto Counter_MIN = PerfEvents_Counter_UNKNOWN_COUNTER;
-  static constexpr auto Counter_MAX = PerfEvents_Counter_SW_DUMMY;
-  using PerfClock = PerfEvents_PerfClock;
-  static constexpr auto UNKNOWN_PERF_CLOCK = PerfEvents_PerfClock_UNKNOWN_PERF_CLOCK;
-  static constexpr auto PERF_CLOCK_REALTIME = PerfEvents_PerfClock_PERF_CLOCK_REALTIME;
-  static constexpr auto PERF_CLOCK_MONOTONIC = PerfEvents_PerfClock_PERF_CLOCK_MONOTONIC;
-  static constexpr auto PERF_CLOCK_MONOTONIC_RAW = PerfEvents_PerfClock_PERF_CLOCK_MONOTONIC_RAW;
-  static constexpr auto PERF_CLOCK_BOOTTIME = PerfEvents_PerfClock_PERF_CLOCK_BOOTTIME;
-  static constexpr auto PerfClock_MIN = PerfEvents_PerfClock_UNKNOWN_PERF_CLOCK;
-  static constexpr auto PerfClock_MAX = PerfEvents_PerfClock_PERF_CLOCK_BOOTTIME;
   enum FieldNumbers {
+    kCounterFieldNumber = 1,
+    kTracepointFieldNumber = 2,
+    kRawEventFieldNumber = 3,
+    kModifiersFieldNumber = 5,
+    kNameFieldNumber = 4,
   };
 
-  PerfEvents();
-  ~PerfEvents() override;
-  PerfEvents(PerfEvents&&) noexcept;
-  PerfEvents& operator=(PerfEvents&&);
-  PerfEvents(const PerfEvents&);
-  PerfEvents& operator=(const PerfEvents&);
-  bool operator==(const PerfEvents&) const;
-  bool operator!=(const PerfEvents& other) const { return !(*this == other); }
+  FollowerEvent();
+  ~FollowerEvent() override;
+  FollowerEvent(FollowerEvent&&) noexcept;
+  FollowerEvent& operator=(FollowerEvent&&);
+  FollowerEvent(const FollowerEvent&);
+  FollowerEvent& operator=(const FollowerEvent&);
+  bool operator==(const FollowerEvent&) const;
+  bool operator!=(const FollowerEvent& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
+  bool has_counter() const { return _has_field_[1]; }
+  PerfEvents_Counter counter() const { return counter_; }
+  void set_counter(PerfEvents_Counter value) { counter_ = value; _has_field_.set(1); }
+
+  bool has_tracepoint() const { return _has_field_[2]; }
+  const PerfEvents_Tracepoint& tracepoint() const { return *tracepoint_; }
+  PerfEvents_Tracepoint* mutable_tracepoint() { _has_field_.set(2); return tracepoint_.get(); }
+
+  bool has_raw_event() const { return _has_field_[3]; }
+  const PerfEvents_RawEvent& raw_event() const { return *raw_event_; }
+  PerfEvents_RawEvent* mutable_raw_event() { _has_field_.set(3); return raw_event_.get(); }
+
+  const std::vector<PerfEvents_EventModifier>& modifiers() const { return modifiers_; }
+  std::vector<PerfEvents_EventModifier>* mutable_modifiers() { return &modifiers_; }
+  int modifiers_size() const { return static_cast<int>(modifiers_.size()); }
+  void clear_modifiers() { modifiers_.clear(); }
+  void add_modifiers(PerfEvents_EventModifier value) { modifiers_.emplace_back(value); }
+  PerfEvents_EventModifier* add_modifiers() { modifiers_.emplace_back(); return &modifiers_.back(); }
+
+  bool has_name() const { return _has_field_[4]; }
+  const std::string& name() const { return name_; }
+  void set_name(const std::string& value) { name_ = value; _has_field_.set(4); }
+
  private:
+  PerfEvents_Counter counter_{};
+  ::protozero::CopyablePtr<PerfEvents_Tracepoint> tracepoint_;
+  ::protozero::CopyablePtr<PerfEvents_RawEvent> raw_event_;
+  std::vector<PerfEvents_EventModifier> modifiers_;
+  std::string name_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<2> _has_field_{};
+  std::bitset<6> _has_field_{};
 };
 
 
@@ -22878,14 +27831,87 @@ class PERFETTO_EXPORT_COMPONENT PerfEvents_Tracepoint : public ::protozero::CppM
 };
 
 
+class PERFETTO_EXPORT_COMPONENT PerfEvents : public ::protozero::CppMessageObj {
+ public:
+  using Timebase = PerfEvents_Timebase;
+  using Tracepoint = PerfEvents_Tracepoint;
+  using RawEvent = PerfEvents_RawEvent;
+  using Counter = PerfEvents_Counter;
+  static constexpr auto UNKNOWN_COUNTER = PerfEvents_Counter_UNKNOWN_COUNTER;
+  static constexpr auto SW_CPU_CLOCK = PerfEvents_Counter_SW_CPU_CLOCK;
+  static constexpr auto SW_PAGE_FAULTS = PerfEvents_Counter_SW_PAGE_FAULTS;
+  static constexpr auto SW_TASK_CLOCK = PerfEvents_Counter_SW_TASK_CLOCK;
+  static constexpr auto SW_CONTEXT_SWITCHES = PerfEvents_Counter_SW_CONTEXT_SWITCHES;
+  static constexpr auto SW_CPU_MIGRATIONS = PerfEvents_Counter_SW_CPU_MIGRATIONS;
+  static constexpr auto SW_PAGE_FAULTS_MIN = PerfEvents_Counter_SW_PAGE_FAULTS_MIN;
+  static constexpr auto SW_PAGE_FAULTS_MAJ = PerfEvents_Counter_SW_PAGE_FAULTS_MAJ;
+  static constexpr auto SW_ALIGNMENT_FAULTS = PerfEvents_Counter_SW_ALIGNMENT_FAULTS;
+  static constexpr auto SW_EMULATION_FAULTS = PerfEvents_Counter_SW_EMULATION_FAULTS;
+  static constexpr auto SW_DUMMY = PerfEvents_Counter_SW_DUMMY;
+  static constexpr auto HW_CPU_CYCLES = PerfEvents_Counter_HW_CPU_CYCLES;
+  static constexpr auto HW_INSTRUCTIONS = PerfEvents_Counter_HW_INSTRUCTIONS;
+  static constexpr auto HW_CACHE_REFERENCES = PerfEvents_Counter_HW_CACHE_REFERENCES;
+  static constexpr auto HW_CACHE_MISSES = PerfEvents_Counter_HW_CACHE_MISSES;
+  static constexpr auto HW_BRANCH_INSTRUCTIONS = PerfEvents_Counter_HW_BRANCH_INSTRUCTIONS;
+  static constexpr auto HW_BRANCH_MISSES = PerfEvents_Counter_HW_BRANCH_MISSES;
+  static constexpr auto HW_BUS_CYCLES = PerfEvents_Counter_HW_BUS_CYCLES;
+  static constexpr auto HW_STALLED_CYCLES_FRONTEND = PerfEvents_Counter_HW_STALLED_CYCLES_FRONTEND;
+  static constexpr auto HW_STALLED_CYCLES_BACKEND = PerfEvents_Counter_HW_STALLED_CYCLES_BACKEND;
+  static constexpr auto HW_REF_CPU_CYCLES = PerfEvents_Counter_HW_REF_CPU_CYCLES;
+  static constexpr auto Counter_MIN = PerfEvents_Counter_UNKNOWN_COUNTER;
+  static constexpr auto Counter_MAX = PerfEvents_Counter_SW_DUMMY;
+  using PerfClock = PerfEvents_PerfClock;
+  static constexpr auto UNKNOWN_PERF_CLOCK = PerfEvents_PerfClock_UNKNOWN_PERF_CLOCK;
+  static constexpr auto PERF_CLOCK_REALTIME = PerfEvents_PerfClock_PERF_CLOCK_REALTIME;
+  static constexpr auto PERF_CLOCK_MONOTONIC = PerfEvents_PerfClock_PERF_CLOCK_MONOTONIC;
+  static constexpr auto PERF_CLOCK_MONOTONIC_RAW = PerfEvents_PerfClock_PERF_CLOCK_MONOTONIC_RAW;
+  static constexpr auto PERF_CLOCK_BOOTTIME = PerfEvents_PerfClock_PERF_CLOCK_BOOTTIME;
+  static constexpr auto PerfClock_MIN = PerfEvents_PerfClock_UNKNOWN_PERF_CLOCK;
+  static constexpr auto PerfClock_MAX = PerfEvents_PerfClock_PERF_CLOCK_BOOTTIME;
+  using EventModifier = PerfEvents_EventModifier;
+  static constexpr auto UNKNOWN_EVENT_MODIFIER = PerfEvents_EventModifier_UNKNOWN_EVENT_MODIFIER;
+  static constexpr auto EVENT_MODIFIER_COUNT_USERSPACE = PerfEvents_EventModifier_EVENT_MODIFIER_COUNT_USERSPACE;
+  static constexpr auto EVENT_MODIFIER_COUNT_KERNEL = PerfEvents_EventModifier_EVENT_MODIFIER_COUNT_KERNEL;
+  static constexpr auto EVENT_MODIFIER_COUNT_HYPERVISOR = PerfEvents_EventModifier_EVENT_MODIFIER_COUNT_HYPERVISOR;
+  static constexpr auto EventModifier_MIN = PerfEvents_EventModifier_UNKNOWN_EVENT_MODIFIER;
+  static constexpr auto EventModifier_MAX = PerfEvents_EventModifier_EVENT_MODIFIER_COUNT_HYPERVISOR;
+  enum FieldNumbers {
+  };
+
+  PerfEvents();
+  ~PerfEvents() override;
+  PerfEvents(PerfEvents&&) noexcept;
+  PerfEvents& operator=(PerfEvents&&);
+  PerfEvents(const PerfEvents&);
+  PerfEvents& operator=(const PerfEvents&);
+  bool operator==(const PerfEvents&) const;
+  bool operator!=(const PerfEvents& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+ private:
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<2> _has_field_{};
+};
+
+
 class PERFETTO_EXPORT_COMPONENT PerfEvents_Timebase : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
     kFrequencyFieldNumber = 2,
     kPeriodFieldNumber = 1,
+    kPollPeriodMsFieldNumber = 6,
     kCounterFieldNumber = 4,
     kTracepointFieldNumber = 3,
     kRawEventFieldNumber = 5,
+    kModifiersFieldNumber = 12,
     kTimestampClockFieldNumber = 11,
     kNameFieldNumber = 10,
   };
@@ -22912,6 +27938,10 @@ class PERFETTO_EXPORT_COMPONENT PerfEvents_Timebase : public ::protozero::CppMes
   uint64_t period() const { return period_; }
   void set_period(uint64_t value) { period_ = value; _has_field_.set(1); }
 
+  bool has_poll_period_ms() const { return _has_field_[6]; }
+  uint32_t poll_period_ms() const { return poll_period_ms_; }
+  void set_poll_period_ms(uint32_t value) { poll_period_ms_ = value; _has_field_.set(6); }
+
   bool has_counter() const { return _has_field_[4]; }
   PerfEvents_Counter counter() const { return counter_; }
   void set_counter(PerfEvents_Counter value) { counter_ = value; _has_field_.set(4); }
@@ -22924,6 +27954,13 @@ class PERFETTO_EXPORT_COMPONENT PerfEvents_Timebase : public ::protozero::CppMes
   const PerfEvents_RawEvent& raw_event() const { return *raw_event_; }
   PerfEvents_RawEvent* mutable_raw_event() { _has_field_.set(5); return raw_event_.get(); }
 
+  const std::vector<PerfEvents_EventModifier>& modifiers() const { return modifiers_; }
+  std::vector<PerfEvents_EventModifier>* mutable_modifiers() { return &modifiers_; }
+  int modifiers_size() const { return static_cast<int>(modifiers_.size()); }
+  void clear_modifiers() { modifiers_.clear(); }
+  void add_modifiers(PerfEvents_EventModifier value) { modifiers_.emplace_back(value); }
+  PerfEvents_EventModifier* add_modifiers() { modifiers_.emplace_back(); return &modifiers_.back(); }
+
   bool has_timestamp_clock() const { return _has_field_[11]; }
   PerfEvents_PerfClock timestamp_clock() const { return timestamp_clock_; }
   void set_timestamp_clock(PerfEvents_PerfClock value) { timestamp_clock_ = value; _has_field_.set(11); }
@@ -22935,9 +27972,11 @@ class PERFETTO_EXPORT_COMPONENT PerfEvents_Timebase : public ::protozero::CppMes
  private:
   uint64_t frequency_{};
   uint64_t period_{};
+  uint32_t poll_period_ms_{};
   PerfEvents_Counter counter_{};
   ::protozero::CopyablePtr<PerfEvents_Tracepoint> tracepoint_;
   ::protozero::CopyablePtr<PerfEvents_RawEvent> raw_event_;
+  std::vector<PerfEvents_EventModifier> modifiers_;
   PerfEvents_PerfClock timestamp_clock_{};
   std::string name_{};
 
@@ -22945,7 +27984,7 @@ class PERFETTO_EXPORT_COMPONENT PerfEvents_Timebase : public ::protozero::CppMes
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<12> _has_field_{};
+  std::bitset<13> _has_field_{};
 };
 
 }  // namespace perfetto
@@ -22953,6 +27992,50 @@ class PERFETTO_EXPORT_COMPONENT PerfEvents_Timebase : public ::protozero::CppMes
 }  // namespace gen
 
 #endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_PERF_EVENTS_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/common/protolog_common.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_PROTOLOG_COMMON_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_PROTOLOG_COMMON_PROTO_CPP_H_
+
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum ProtoLogLevel : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+namespace protozero {
+class Message;
+}  // namespace protozero
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum ProtoLogLevel : int {
+  PROTOLOG_LEVEL_UNDEFINED = 0,
+  PROTOLOG_LEVEL_DEBUG = 1,
+  PROTOLOG_LEVEL_VERBOSE = 2,
+  PROTOLOG_LEVEL_INFO = 3,
+  PROTOLOG_LEVEL_WARN = 4,
+  PROTOLOG_LEVEL_ERROR = 5,
+  PROTOLOG_LEVEL_WTF = 6,
+};
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_PROTOLOG_COMMON_PROTO_CPP_H_
 // gen_amalgamated begin header: gen/protos/perfetto/common/sys_stats_counters.gen.h
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
 #ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_SYS_STATS_COUNTERS_PROTO_CPP_H_
@@ -23019,6 +28102,11 @@ enum MeminfoCounters : int {
   MEMINFO_VMALLOC_CHUNK = 31,
   MEMINFO_CMA_TOTAL = 32,
   MEMINFO_CMA_FREE = 33,
+  MEMINFO_GPU = 34,
+  MEMINFO_ZRAM = 35,
+  MEMINFO_MISC = 36,
+  MEMINFO_ION_HEAP = 37,
+  MEMINFO_ION_HEAP_POOL = 38,
 };
 enum VmstatCounters : int {
   VMSTAT_UNSPECIFIED = 0,
@@ -23150,12 +28238,286 @@ enum VmstatCounters : int {
   VMSTAT_SWAP_RA = 126,
   VMSTAT_SWAP_RA_HIT = 127,
   VMSTAT_WORKINGSET_RESTORE = 128,
+  VMSTAT_ALLOCSTALL_DEVICE = 129,
+  VMSTAT_ALLOCSTALL_DMA32 = 130,
+  VMSTAT_BALLOON_DEFLATE = 131,
+  VMSTAT_BALLOON_INFLATE = 132,
+  VMSTAT_BALLOON_MIGRATE = 133,
+  VMSTAT_CMA_ALLOC_FAIL = 134,
+  VMSTAT_CMA_ALLOC_SUCCESS = 135,
+  VMSTAT_NR_FILE_HUGEPAGES = 136,
+  VMSTAT_NR_FILE_PMDMAPPED = 137,
+  VMSTAT_NR_FOLL_PIN_ACQUIRED = 138,
+  VMSTAT_NR_FOLL_PIN_RELEASED = 139,
+  VMSTAT_NR_SEC_PAGE_TABLE_PAGES = 140,
+  VMSTAT_NR_SHADOW_CALL_STACK = 141,
+  VMSTAT_NR_SWAPCACHED = 142,
+  VMSTAT_NR_THROTTLED_WRITTEN = 143,
+  VMSTAT_PGALLOC_DEVICE = 144,
+  VMSTAT_PGALLOC_DMA32 = 145,
+  VMSTAT_PGDEMOTE_DIRECT = 146,
+  VMSTAT_PGDEMOTE_KSWAPD = 147,
+  VMSTAT_PGREUSE = 148,
+  VMSTAT_PGSCAN_ANON = 149,
+  VMSTAT_PGSCAN_FILE = 150,
+  VMSTAT_PGSKIP_DEVICE = 151,
+  VMSTAT_PGSKIP_DMA32 = 152,
+  VMSTAT_PGSTEAL_ANON = 153,
+  VMSTAT_PGSTEAL_FILE = 154,
+  VMSTAT_THP_COLLAPSE_ALLOC = 155,
+  VMSTAT_THP_COLLAPSE_ALLOC_FAILED = 156,
+  VMSTAT_THP_DEFERRED_SPLIT_PAGE = 157,
+  VMSTAT_THP_FAULT_ALLOC = 158,
+  VMSTAT_THP_FAULT_FALLBACK = 159,
+  VMSTAT_THP_FAULT_FALLBACK_CHARGE = 160,
+  VMSTAT_THP_FILE_ALLOC = 161,
+  VMSTAT_THP_FILE_FALLBACK = 162,
+  VMSTAT_THP_FILE_FALLBACK_CHARGE = 163,
+  VMSTAT_THP_FILE_MAPPED = 164,
+  VMSTAT_THP_MIGRATION_FAIL = 165,
+  VMSTAT_THP_MIGRATION_SPLIT = 166,
+  VMSTAT_THP_MIGRATION_SUCCESS = 167,
+  VMSTAT_THP_SCAN_EXCEED_NONE_PTE = 168,
+  VMSTAT_THP_SCAN_EXCEED_SHARE_PTE = 169,
+  VMSTAT_THP_SCAN_EXCEED_SWAP_PTE = 170,
+  VMSTAT_THP_SPLIT_PAGE = 171,
+  VMSTAT_THP_SPLIT_PAGE_FAILED = 172,
+  VMSTAT_THP_SPLIT_PMD = 173,
+  VMSTAT_THP_SWPOUT = 174,
+  VMSTAT_THP_SWPOUT_FALLBACK = 175,
+  VMSTAT_THP_ZERO_PAGE_ALLOC = 176,
+  VMSTAT_THP_ZERO_PAGE_ALLOC_FAILED = 177,
+  VMSTAT_VMA_LOCK_ABORT = 178,
+  VMSTAT_VMA_LOCK_MISS = 179,
+  VMSTAT_VMA_LOCK_RETRY = 180,
+  VMSTAT_VMA_LOCK_SUCCESS = 181,
+  VMSTAT_WORKINGSET_ACTIVATE_ANON = 182,
+  VMSTAT_WORKINGSET_ACTIVATE_FILE = 183,
+  VMSTAT_WORKINGSET_NODES = 184,
+  VMSTAT_WORKINGSET_REFAULT_ANON = 185,
+  VMSTAT_WORKINGSET_REFAULT_FILE = 186,
+  VMSTAT_WORKINGSET_RESTORE_ANON = 187,
+  VMSTAT_WORKINGSET_RESTORE_FILE = 188,
 };
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
 
 #endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_SYS_STATS_COUNTERS_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/common/system_info.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_SYSTEM_INFO_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_SYSTEM_INFO_PROTO_CPP_H_
+
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+class SystemInfo;
+class Utsname;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+namespace protozero {
+class Message;
+}  // namespace protozero
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+
+class PERFETTO_EXPORT_COMPONENT SystemInfo : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kUtsnameFieldNumber = 1,
+    kAndroidBuildFingerprintFieldNumber = 2,
+    kAndroidDeviceManufacturerFieldNumber = 14,
+    kAndroidSocModelFieldNumber = 9,
+    kAndroidGuestSocModelFieldNumber = 13,
+    kAndroidHardwareRevisionFieldNumber = 10,
+    kAndroidStorageModelFieldNumber = 11,
+    kAndroidRamModelFieldNumber = 12,
+    kAndroidSerialConsoleFieldNumber = 15,
+    kTracingServiceVersionFieldNumber = 4,
+    kAndroidSdkVersionFieldNumber = 5,
+    kPageSizeFieldNumber = 6,
+    kNumCpusFieldNumber = 8,
+    kTimezoneOffMinsFieldNumber = 7,
+    kHzFieldNumber = 3,
+    kSystemRamBytesFieldNumber = 16,
+  };
+
+  SystemInfo();
+  ~SystemInfo() override;
+  SystemInfo(SystemInfo&&) noexcept;
+  SystemInfo& operator=(SystemInfo&&);
+  SystemInfo(const SystemInfo&);
+  SystemInfo& operator=(const SystemInfo&);
+  bool operator==(const SystemInfo&) const;
+  bool operator!=(const SystemInfo& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_utsname() const { return _has_field_[1]; }
+  const Utsname& utsname() const { return *utsname_; }
+  Utsname* mutable_utsname() { _has_field_.set(1); return utsname_.get(); }
+
+  bool has_android_build_fingerprint() const { return _has_field_[2]; }
+  const std::string& android_build_fingerprint() const { return android_build_fingerprint_; }
+  void set_android_build_fingerprint(const std::string& value) { android_build_fingerprint_ = value; _has_field_.set(2); }
+
+  bool has_android_device_manufacturer() const { return _has_field_[14]; }
+  const std::string& android_device_manufacturer() const { return android_device_manufacturer_; }
+  void set_android_device_manufacturer(const std::string& value) { android_device_manufacturer_ = value; _has_field_.set(14); }
+
+  bool has_android_soc_model() const { return _has_field_[9]; }
+  const std::string& android_soc_model() const { return android_soc_model_; }
+  void set_android_soc_model(const std::string& value) { android_soc_model_ = value; _has_field_.set(9); }
+
+  bool has_android_guest_soc_model() const { return _has_field_[13]; }
+  const std::string& android_guest_soc_model() const { return android_guest_soc_model_; }
+  void set_android_guest_soc_model(const std::string& value) { android_guest_soc_model_ = value; _has_field_.set(13); }
+
+  bool has_android_hardware_revision() const { return _has_field_[10]; }
+  const std::string& android_hardware_revision() const { return android_hardware_revision_; }
+  void set_android_hardware_revision(const std::string& value) { android_hardware_revision_ = value; _has_field_.set(10); }
+
+  bool has_android_storage_model() const { return _has_field_[11]; }
+  const std::string& android_storage_model() const { return android_storage_model_; }
+  void set_android_storage_model(const std::string& value) { android_storage_model_ = value; _has_field_.set(11); }
+
+  bool has_android_ram_model() const { return _has_field_[12]; }
+  const std::string& android_ram_model() const { return android_ram_model_; }
+  void set_android_ram_model(const std::string& value) { android_ram_model_ = value; _has_field_.set(12); }
+
+  bool has_android_serial_console() const { return _has_field_[15]; }
+  const std::string& android_serial_console() const { return android_serial_console_; }
+  void set_android_serial_console(const std::string& value) { android_serial_console_ = value; _has_field_.set(15); }
+
+  bool has_tracing_service_version() const { return _has_field_[4]; }
+  const std::string& tracing_service_version() const { return tracing_service_version_; }
+  void set_tracing_service_version(const std::string& value) { tracing_service_version_ = value; _has_field_.set(4); }
+
+  bool has_android_sdk_version() const { return _has_field_[5]; }
+  uint64_t android_sdk_version() const { return android_sdk_version_; }
+  void set_android_sdk_version(uint64_t value) { android_sdk_version_ = value; _has_field_.set(5); }
+
+  bool has_page_size() const { return _has_field_[6]; }
+  uint32_t page_size() const { return page_size_; }
+  void set_page_size(uint32_t value) { page_size_ = value; _has_field_.set(6); }
+
+  bool has_num_cpus() const { return _has_field_[8]; }
+  uint32_t num_cpus() const { return num_cpus_; }
+  void set_num_cpus(uint32_t value) { num_cpus_ = value; _has_field_.set(8); }
+
+  bool has_timezone_off_mins() const { return _has_field_[7]; }
+  int32_t timezone_off_mins() const { return timezone_off_mins_; }
+  void set_timezone_off_mins(int32_t value) { timezone_off_mins_ = value; _has_field_.set(7); }
+
+  bool has_hz() const { return _has_field_[3]; }
+  int64_t hz() const { return hz_; }
+  void set_hz(int64_t value) { hz_ = value; _has_field_.set(3); }
+
+  bool has_system_ram_bytes() const { return _has_field_[16]; }
+  uint64_t system_ram_bytes() const { return system_ram_bytes_; }
+  void set_system_ram_bytes(uint64_t value) { system_ram_bytes_ = value; _has_field_.set(16); }
+
+ private:
+  ::protozero::CopyablePtr<Utsname> utsname_;
+  std::string android_build_fingerprint_{};
+  std::string android_device_manufacturer_{};
+  std::string android_soc_model_{};
+  std::string android_guest_soc_model_{};
+  std::string android_hardware_revision_{};
+  std::string android_storage_model_{};
+  std::string android_ram_model_{};
+  std::string android_serial_console_{};
+  std::string tracing_service_version_{};
+  uint64_t android_sdk_version_{};
+  uint32_t page_size_{};
+  uint32_t num_cpus_{};
+  int32_t timezone_off_mins_{};
+  int64_t hz_{};
+  uint64_t system_ram_bytes_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<17> _has_field_{};
+};
+
+
+class PERFETTO_EXPORT_COMPONENT Utsname : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kSysnameFieldNumber = 1,
+    kVersionFieldNumber = 2,
+    kReleaseFieldNumber = 3,
+    kMachineFieldNumber = 4,
+  };
+
+  Utsname();
+  ~Utsname() override;
+  Utsname(Utsname&&) noexcept;
+  Utsname& operator=(Utsname&&);
+  Utsname(const Utsname&);
+  Utsname& operator=(const Utsname&);
+  bool operator==(const Utsname&) const;
+  bool operator!=(const Utsname& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_sysname() const { return _has_field_[1]; }
+  const std::string& sysname() const { return sysname_; }
+  void set_sysname(const std::string& value) { sysname_ = value; _has_field_.set(1); }
+
+  bool has_version() const { return _has_field_[2]; }
+  const std::string& version() const { return version_; }
+  void set_version(const std::string& value) { version_ = value; _has_field_.set(2); }
+
+  bool has_release() const { return _has_field_[3]; }
+  const std::string& release() const { return release_; }
+  void set_release(const std::string& value) { release_ = value; _has_field_.set(3); }
+
+  bool has_machine() const { return _has_field_[4]; }
+  const std::string& machine() const { return machine_; }
+  void set_machine(const std::string& value) { machine_ = value; _has_field_.set(4); }
+
+ private:
+  std::string sysname_{};
+  std::string version_{};
+  std::string release_{};
+  std::string machine_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<5> _has_field_{};
+};
+
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_SYSTEM_INFO_PROTO_CPP_H_
 // gen_amalgamated begin header: gen/protos/perfetto/common/trace_stats.gen.h
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
 #ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_TRACE_STATS_PROTO_CPP_H_
@@ -23176,7 +28538,9 @@ namespace protos {
 namespace gen {
 class TraceStats;
 class TraceStats_FilterStats;
+class TraceStats_WriterStats;
 class TraceStats_BufferStats;
+class TraceStats_BufferStats_ShadowBufferStats;
 enum TraceStats_FinalFlushOutcome : int;
 }  // namespace perfetto
 }  // namespace protos
@@ -23198,6 +28562,7 @@ enum TraceStats_FinalFlushOutcome : int {
 class PERFETTO_EXPORT_COMPONENT TraceStats : public ::protozero::CppMessageObj {
  public:
   using BufferStats = TraceStats_BufferStats;
+  using WriterStats = TraceStats_WriterStats;
   using FilterStats = TraceStats_FilterStats;
   using FinalFlushOutcome = TraceStats_FinalFlushOutcome;
   static constexpr auto FINAL_FLUSH_UNSPECIFIED = TraceStats_FinalFlushOutcome_FINAL_FLUSH_UNSPECIFIED;
@@ -23207,6 +28572,8 @@ class PERFETTO_EXPORT_COMPONENT TraceStats : public ::protozero::CppMessageObj {
   static constexpr auto FinalFlushOutcome_MAX = TraceStats_FinalFlushOutcome_FINAL_FLUSH_FAILED;
   enum FieldNumbers {
     kBufferStatsFieldNumber = 1,
+    kChunkPayloadHistogramDefFieldNumber = 17,
+    kWriterStatsFieldNumber = 18,
     kProducersConnectedFieldNumber = 2,
     kProducersSeenFieldNumber = 3,
     kDataSourcesRegisteredFieldNumber = 4,
@@ -23243,6 +28610,19 @@ class PERFETTO_EXPORT_COMPONENT TraceStats : public ::protozero::CppMessageObj {
   void clear_buffer_stats();
   TraceStats_BufferStats* add_buffer_stats();
 
+  const std::vector<int64_t>& chunk_payload_histogram_def() const { return chunk_payload_histogram_def_; }
+  std::vector<int64_t>* mutable_chunk_payload_histogram_def() { return &chunk_payload_histogram_def_; }
+  int chunk_payload_histogram_def_size() const { return static_cast<int>(chunk_payload_histogram_def_.size()); }
+  void clear_chunk_payload_histogram_def() { chunk_payload_histogram_def_.clear(); }
+  void add_chunk_payload_histogram_def(int64_t value) { chunk_payload_histogram_def_.emplace_back(value); }
+  int64_t* add_chunk_payload_histogram_def() { chunk_payload_histogram_def_.emplace_back(); return &chunk_payload_histogram_def_.back(); }
+
+  const std::vector<TraceStats_WriterStats>& writer_stats() const { return writer_stats_; }
+  std::vector<TraceStats_WriterStats>* mutable_writer_stats() { return &writer_stats_; }
+  int writer_stats_size() const;
+  void clear_writer_stats();
+  TraceStats_WriterStats* add_writer_stats();
+
   bool has_producers_connected() const { return _has_field_[2]; }
   uint32_t producers_connected() const { return producers_connected_; }
   void set_producers_connected(uint32_t value) { producers_connected_ = value; _has_field_.set(2); }
@@ -23301,6 +28681,8 @@ class PERFETTO_EXPORT_COMPONENT TraceStats : public ::protozero::CppMessageObj {
 
  private:
   std::vector<TraceStats_BufferStats> buffer_stats_;
+  std::vector<int64_t> chunk_payload_histogram_def_;
+  std::vector<TraceStats_WriterStats> writer_stats_;
   uint32_t producers_connected_{};
   uint64_t producers_seen_{};
   uint32_t data_sources_registered_{};
@@ -23320,7 +28702,7 @@ class PERFETTO_EXPORT_COMPONENT TraceStats : public ::protozero::CppMessageObj {
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<16> _has_field_{};
+  std::bitset<19> _has_field_{};
 };
 
 
@@ -23331,6 +28713,8 @@ class PERFETTO_EXPORT_COMPONENT TraceStats_FilterStats : public ::protozero::Cpp
     kInputBytesFieldNumber = 2,
     kOutputBytesFieldNumber = 3,
     kErrorsFieldNumber = 4,
+    kTimeTakenNsFieldNumber = 5,
+    kBytesDiscardedPerBufferFieldNumber = 20,
   };
 
   TraceStats_FilterStats();
@@ -23363,11 +28747,83 @@ class PERFETTO_EXPORT_COMPONENT TraceStats_FilterStats : public ::protozero::Cpp
   uint64_t errors() const { return errors_; }
   void set_errors(uint64_t value) { errors_ = value; _has_field_.set(4); }
 
+  bool has_time_taken_ns() const { return _has_field_[5]; }
+  uint64_t time_taken_ns() const { return time_taken_ns_; }
+  void set_time_taken_ns(uint64_t value) { time_taken_ns_ = value; _has_field_.set(5); }
+
+  const std::vector<uint64_t>& bytes_discarded_per_buffer() const { return bytes_discarded_per_buffer_; }
+  std::vector<uint64_t>* mutable_bytes_discarded_per_buffer() { return &bytes_discarded_per_buffer_; }
+  int bytes_discarded_per_buffer_size() const { return static_cast<int>(bytes_discarded_per_buffer_.size()); }
+  void clear_bytes_discarded_per_buffer() { bytes_discarded_per_buffer_.clear(); }
+  void add_bytes_discarded_per_buffer(uint64_t value) { bytes_discarded_per_buffer_.emplace_back(value); }
+  uint64_t* add_bytes_discarded_per_buffer() { bytes_discarded_per_buffer_.emplace_back(); return &bytes_discarded_per_buffer_.back(); }
+
  private:
   uint64_t input_packets_{};
   uint64_t input_bytes_{};
   uint64_t output_bytes_{};
   uint64_t errors_{};
+  uint64_t time_taken_ns_{};
+  std::vector<uint64_t> bytes_discarded_per_buffer_;
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<21> _has_field_{};
+};
+
+
+class PERFETTO_EXPORT_COMPONENT TraceStats_WriterStats : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kSequenceIdFieldNumber = 1,
+    kBufferFieldNumber = 4,
+    kChunkPayloadHistogramCountsFieldNumber = 2,
+    kChunkPayloadHistogramSumFieldNumber = 3,
+  };
+
+  TraceStats_WriterStats();
+  ~TraceStats_WriterStats() override;
+  TraceStats_WriterStats(TraceStats_WriterStats&&) noexcept;
+  TraceStats_WriterStats& operator=(TraceStats_WriterStats&&);
+  TraceStats_WriterStats(const TraceStats_WriterStats&);
+  TraceStats_WriterStats& operator=(const TraceStats_WriterStats&);
+  bool operator==(const TraceStats_WriterStats&) const;
+  bool operator!=(const TraceStats_WriterStats& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_sequence_id() const { return _has_field_[1]; }
+  uint64_t sequence_id() const { return sequence_id_; }
+  void set_sequence_id(uint64_t value) { sequence_id_ = value; _has_field_.set(1); }
+
+  bool has_buffer() const { return _has_field_[4]; }
+  uint32_t buffer() const { return buffer_; }
+  void set_buffer(uint32_t value) { buffer_ = value; _has_field_.set(4); }
+
+  const std::vector<uint64_t>& chunk_payload_histogram_counts() const { return chunk_payload_histogram_counts_; }
+  std::vector<uint64_t>* mutable_chunk_payload_histogram_counts() { return &chunk_payload_histogram_counts_; }
+  int chunk_payload_histogram_counts_size() const { return static_cast<int>(chunk_payload_histogram_counts_.size()); }
+  void clear_chunk_payload_histogram_counts() { chunk_payload_histogram_counts_.clear(); }
+  void add_chunk_payload_histogram_counts(uint64_t value) { chunk_payload_histogram_counts_.emplace_back(value); }
+  uint64_t* add_chunk_payload_histogram_counts() { chunk_payload_histogram_counts_.emplace_back(); return &chunk_payload_histogram_counts_.back(); }
+
+  const std::vector<int64_t>& chunk_payload_histogram_sum() const { return chunk_payload_histogram_sum_; }
+  std::vector<int64_t>* mutable_chunk_payload_histogram_sum() { return &chunk_payload_histogram_sum_; }
+  int chunk_payload_histogram_sum_size() const { return static_cast<int>(chunk_payload_histogram_sum_.size()); }
+  void clear_chunk_payload_histogram_sum() { chunk_payload_histogram_sum_.clear(); }
+  void add_chunk_payload_histogram_sum(int64_t value) { chunk_payload_histogram_sum_.emplace_back(value); }
+  int64_t* add_chunk_payload_histogram_sum() { chunk_payload_histogram_sum_.emplace_back(); return &chunk_payload_histogram_sum_.back(); }
+
+ private:
+  uint64_t sequence_id_{};
+  uint32_t buffer_{};
+  std::vector<uint64_t> chunk_payload_histogram_counts_;
+  std::vector<int64_t> chunk_payload_histogram_sum_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
@@ -23379,6 +28835,7 @@ class PERFETTO_EXPORT_COMPONENT TraceStats_FilterStats : public ::protozero::Cpp
 
 class PERFETTO_EXPORT_COMPONENT TraceStats_BufferStats : public ::protozero::CppMessageObj {
  public:
+  using ShadowBufferStats = TraceStats_BufferStats_ShadowBufferStats;
   enum FieldNumbers {
     kBufferSizeFieldNumber = 12,
     kBytesWrittenFieldNumber = 1,
@@ -23399,6 +28856,7 @@ class PERFETTO_EXPORT_COMPONENT TraceStats_BufferStats : public ::protozero::Cpp
     kReadaheadsFailedFieldNumber = 8,
     kAbiViolationsFieldNumber = 9,
     kTraceWriterPacketLossFieldNumber = 19,
+    kShadowBufferStatsFieldNumber = 21,
   };
 
   TraceStats_BufferStats();
@@ -23491,6 +28949,10 @@ class PERFETTO_EXPORT_COMPONENT TraceStats_BufferStats : public ::protozero::Cpp
   uint64_t trace_writer_packet_loss() const { return trace_writer_packet_loss_; }
   void set_trace_writer_packet_loss(uint64_t value) { trace_writer_packet_loss_ = value; _has_field_.set(19); }
 
+  bool has_shadow_buffer_stats() const { return _has_field_[21]; }
+  const TraceStats_BufferStats_ShadowBufferStats& shadow_buffer_stats() const { return *shadow_buffer_stats_; }
+  TraceStats_BufferStats_ShadowBufferStats* mutable_shadow_buffer_stats() { _has_field_.set(21); return shadow_buffer_stats_.get(); }
+
  private:
   uint64_t buffer_size_{};
   uint64_t bytes_written_{};
@@ -23511,12 +28973,90 @@ class PERFETTO_EXPORT_COMPONENT TraceStats_BufferStats : public ::protozero::Cpp
   uint64_t readaheads_failed_{};
   uint64_t abi_violations_{};
   uint64_t trace_writer_packet_loss_{};
+  ::protozero::CopyablePtr<TraceStats_BufferStats_ShadowBufferStats> shadow_buffer_stats_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<20> _has_field_{};
+  std::bitset<22> _has_field_{};
+};
+
+
+class PERFETTO_EXPORT_COMPONENT TraceStats_BufferStats_ShadowBufferStats : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kPacketsSeenFieldNumber = 1,
+    kPacketsInBothFieldNumber = 2,
+    kPacketsOnlyV1FieldNumber = 3,
+    kPacketsOnlyV2FieldNumber = 4,
+    kPatchesAttemptedFieldNumber = 5,
+    kV1PatchesSucceededFieldNumber = 6,
+    kV2PatchesSucceededFieldNumber = 7,
+    kStatsVersionFieldNumber = 8,
+  };
+
+  TraceStats_BufferStats_ShadowBufferStats();
+  ~TraceStats_BufferStats_ShadowBufferStats() override;
+  TraceStats_BufferStats_ShadowBufferStats(TraceStats_BufferStats_ShadowBufferStats&&) noexcept;
+  TraceStats_BufferStats_ShadowBufferStats& operator=(TraceStats_BufferStats_ShadowBufferStats&&);
+  TraceStats_BufferStats_ShadowBufferStats(const TraceStats_BufferStats_ShadowBufferStats&);
+  TraceStats_BufferStats_ShadowBufferStats& operator=(const TraceStats_BufferStats_ShadowBufferStats&);
+  bool operator==(const TraceStats_BufferStats_ShadowBufferStats&) const;
+  bool operator!=(const TraceStats_BufferStats_ShadowBufferStats& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_packets_seen() const { return _has_field_[1]; }
+  uint64_t packets_seen() const { return packets_seen_; }
+  void set_packets_seen(uint64_t value) { packets_seen_ = value; _has_field_.set(1); }
+
+  bool has_packets_in_both() const { return _has_field_[2]; }
+  uint64_t packets_in_both() const { return packets_in_both_; }
+  void set_packets_in_both(uint64_t value) { packets_in_both_ = value; _has_field_.set(2); }
+
+  bool has_packets_only_v1() const { return _has_field_[3]; }
+  uint64_t packets_only_v1() const { return packets_only_v1_; }
+  void set_packets_only_v1(uint64_t value) { packets_only_v1_ = value; _has_field_.set(3); }
+
+  bool has_packets_only_v2() const { return _has_field_[4]; }
+  uint64_t packets_only_v2() const { return packets_only_v2_; }
+  void set_packets_only_v2(uint64_t value) { packets_only_v2_ = value; _has_field_.set(4); }
+
+  bool has_patches_attempted() const { return _has_field_[5]; }
+  uint64_t patches_attempted() const { return patches_attempted_; }
+  void set_patches_attempted(uint64_t value) { patches_attempted_ = value; _has_field_.set(5); }
+
+  bool has_v1_patches_succeeded() const { return _has_field_[6]; }
+  uint64_t v1_patches_succeeded() const { return v1_patches_succeeded_; }
+  void set_v1_patches_succeeded(uint64_t value) { v1_patches_succeeded_ = value; _has_field_.set(6); }
+
+  bool has_v2_patches_succeeded() const { return _has_field_[7]; }
+  uint64_t v2_patches_succeeded() const { return v2_patches_succeeded_; }
+  void set_v2_patches_succeeded(uint64_t value) { v2_patches_succeeded_ = value; _has_field_.set(7); }
+
+  bool has_stats_version() const { return _has_field_[8]; }
+  uint32_t stats_version() const { return stats_version_; }
+  void set_stats_version(uint32_t value) { stats_version_ = value; _has_field_.set(8); }
+
+ private:
+  uint64_t packets_seen_{};
+  uint64_t packets_in_both_{};
+  uint64_t packets_only_v1_{};
+  uint64_t packets_only_v2_{};
+  uint64_t patches_attempted_{};
+  uint64_t v1_patches_succeeded_{};
+  uint64_t v2_patches_succeeded_{};
+  uint32_t stats_version_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<9> _has_field_{};
 };
 
 }  // namespace perfetto
@@ -23562,6 +29102,7 @@ class PERFETTO_EXPORT_COMPONENT TracingServiceCapabilities : public ::protozero:
     kHasQueryCapabilitiesFieldNumber = 1,
     kObservableEventsFieldNumber = 2,
     kHasTraceConfigOutputPathFieldNumber = 3,
+    kHasCloneSessionFieldNumber = 4,
   };
 
   TracingServiceCapabilities();
@@ -23593,16 +29134,21 @@ class PERFETTO_EXPORT_COMPONENT TracingServiceCapabilities : public ::protozero:
   bool has_trace_config_output_path() const { return has_trace_config_output_path_; }
   void set_has_trace_config_output_path(bool value) { has_trace_config_output_path_ = value; _has_field_.set(3); }
 
+  bool has_has_clone_session() const { return _has_field_[4]; }
+  bool has_clone_session() const { return has_clone_session_; }
+  void set_has_clone_session(bool value) { has_clone_session_ = value; _has_field_.set(4); }
+
  private:
   bool has_query_capabilities_{};
   std::vector<ObservableEvents_Type> observable_events_;
   bool has_trace_config_output_path_{};
+  bool has_clone_session_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<4> _has_field_{};
+  std::bitset<5> _has_field_{};
 };
 
 }  // namespace perfetto
@@ -23632,7 +29178,17 @@ class TracingServiceState;
 class TracingServiceState_TracingSession;
 class TracingServiceState_DataSource;
 class DataSourceDescriptor;
+class VmProgram;
+class VmInstruction;
+class VmOpDel;
+class VmOpSet;
+class VmOpMerge;
+class VmOpRegLoad;
+class VmOpSelect;
+class VmOpSelect_PathComponent;
 class TracingServiceState_Producer;
+enum VmInstruction_AbortLevel : int;
+enum VmCursorEnum : int;
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
@@ -23736,6 +29292,9 @@ class PERFETTO_EXPORT_COMPONENT TracingServiceState_TracingSession : public ::pr
     kDurationMsFieldNumber = 6,
     kNumDataSourcesFieldNumber = 7,
     kStartRealtimeNsFieldNumber = 8,
+    kBugreportScoreFieldNumber = 9,
+    kBugreportFilenameFieldNumber = 10,
+    kIsStartedFieldNumber = 11,
   };
 
   TracingServiceState_TracingSession();
@@ -23787,6 +29346,18 @@ class PERFETTO_EXPORT_COMPONENT TracingServiceState_TracingSession : public ::pr
   int64_t start_realtime_ns() const { return start_realtime_ns_; }
   void set_start_realtime_ns(int64_t value) { start_realtime_ns_ = value; _has_field_.set(8); }
 
+  bool has_bugreport_score() const { return _has_field_[9]; }
+  int32_t bugreport_score() const { return bugreport_score_; }
+  void set_bugreport_score(int32_t value) { bugreport_score_ = value; _has_field_.set(9); }
+
+  bool has_bugreport_filename() const { return _has_field_[10]; }
+  const std::string& bugreport_filename() const { return bugreport_filename_; }
+  void set_bugreport_filename(const std::string& value) { bugreport_filename_ = value; _has_field_.set(10); }
+
+  bool has_is_started() const { return _has_field_[11]; }
+  bool is_started() const { return is_started_; }
+  void set_is_started(bool value) { is_started_ = value; _has_field_.set(11); }
+
  private:
   uint64_t id_{};
   int32_t consumer_uid_{};
@@ -23796,12 +29367,15 @@ class PERFETTO_EXPORT_COMPONENT TracingServiceState_TracingSession : public ::pr
   uint32_t duration_ms_{};
   uint32_t num_data_sources_{};
   int64_t start_realtime_ns_{};
+  int32_t bugreport_score_{};
+  std::string bugreport_filename_{};
+  bool is_started_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<9> _has_field_{};
+  std::bitset<12> _has_field_{};
 };
 
 
@@ -23854,6 +29428,7 @@ class PERFETTO_EXPORT_COMPONENT TracingServiceState_Producer : public ::protozer
     kPidFieldNumber = 5,
     kUidFieldNumber = 3,
     kSdkVersionFieldNumber = 4,
+    kFrozenFieldNumber = 6,
   };
 
   TracingServiceState_Producer();
@@ -23890,18 +29465,23 @@ class PERFETTO_EXPORT_COMPONENT TracingServiceState_Producer : public ::protozer
   const std::string& sdk_version() const { return sdk_version_; }
   void set_sdk_version(const std::string& value) { sdk_version_ = value; _has_field_.set(4); }
 
+  bool has_frozen() const { return _has_field_[6]; }
+  bool frozen() const { return frozen_; }
+  void set_frozen(bool value) { frozen_ = value; _has_field_.set(6); }
+
  private:
   int32_t id_{};
   std::string name_{};
   int32_t pid_{};
   int32_t uid_{};
   std::string sdk_version_{};
+  bool frozen_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<6> _has_field_{};
+  std::bitset<7> _has_field_{};
 };
 
 }  // namespace perfetto
@@ -24032,6 +29612,625 @@ class PERFETTO_EXPORT_COMPONENT TrackEventCategory : public ::protozero::CppMess
 }  // namespace gen
 
 #endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_TRACK_EVENT_DESCRIPTOR_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/protovm/vm_program.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_PROTOVM_VM_PROGRAM_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_PROTOVM_VM_PROGRAM_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class VmInstruction;
+class VmOpDel;
+class VmOpMerge;
+class VmOpRegLoad;
+class VmOpSelect;
+class VmOpSelect_PathComponent;
+class VmOpSet;
+enum VmCursorEnum : int32_t;
+namespace perfetto_pbzero_enum_VmInstruction {
+enum AbortLevel : int32_t;
+}  // namespace perfetto_pbzero_enum_VmInstruction
+using VmInstruction_AbortLevel = perfetto_pbzero_enum_VmInstruction::AbortLevel;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+enum VmCursorEnum : int32_t {
+  VM_CURSOR_UNSPECIFIED = 0,
+  VM_CURSOR_SRC = 1,
+  VM_CURSOR_DST = 2,
+  VM_CURSOR_BOTH = 3,
+};
+
+constexpr VmCursorEnum VmCursorEnum_MIN = VmCursorEnum::VM_CURSOR_UNSPECIFIED;
+constexpr VmCursorEnum VmCursorEnum_MAX = VmCursorEnum::VM_CURSOR_BOTH;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* VmCursorEnum_Name(::perfetto::protos::pbzero::VmCursorEnum value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::VmCursorEnum::VM_CURSOR_UNSPECIFIED:
+    return "VM_CURSOR_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::VmCursorEnum::VM_CURSOR_SRC:
+    return "VM_CURSOR_SRC";
+
+  case ::perfetto::protos::pbzero::VmCursorEnum::VM_CURSOR_DST:
+    return "VM_CURSOR_DST";
+
+  case ::perfetto::protos::pbzero::VmCursorEnum::VM_CURSOR_BOTH:
+    return "VM_CURSOR_BOTH";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_VmInstruction {
+enum AbortLevel : int32_t {
+  SKIP_CURRENT_INSTRUCTION = 1,
+  SKIP_CURRENT_INSTRUCTION_AND_BREAK_OUTER = 2,
+  ABORT = 3,
+};
+} // namespace perfetto_pbzero_enum_VmInstruction
+using VmInstruction_AbortLevel = perfetto_pbzero_enum_VmInstruction::AbortLevel;
+
+
+constexpr VmInstruction_AbortLevel VmInstruction_AbortLevel_MIN = VmInstruction_AbortLevel::SKIP_CURRENT_INSTRUCTION;
+constexpr VmInstruction_AbortLevel VmInstruction_AbortLevel_MAX = VmInstruction_AbortLevel::ABORT;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* VmInstruction_AbortLevel_Name(::perfetto::protos::pbzero::VmInstruction_AbortLevel value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::VmInstruction_AbortLevel::SKIP_CURRENT_INSTRUCTION:
+    return "SKIP_CURRENT_INSTRUCTION";
+
+  case ::perfetto::protos::pbzero::VmInstruction_AbortLevel::SKIP_CURRENT_INSTRUCTION_AND_BREAK_OUTER:
+    return "SKIP_CURRENT_INSTRUCTION_AND_BREAK_OUTER";
+
+  case ::perfetto::protos::pbzero::VmInstruction_AbortLevel::ABORT:
+    return "ABORT";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class VmOpDel_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0> {
+ public:
+  VmOpDel_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit VmOpDel_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit VmOpDel_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+};
+
+class VmOpDel : public ::protozero::Message {
+ public:
+  using Decoder = VmOpDel_Decoder;
+  static constexpr const char* GetName() { return ".perfetto.protos.VmOpDel"; }
+
+};
+
+class VmOpSet_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0> {
+ public:
+  VmOpSet_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit VmOpSet_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit VmOpSet_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+};
+
+class VmOpSet : public ::protozero::Message {
+ public:
+  using Decoder = VmOpSet_Decoder;
+  static constexpr const char* GetName() { return ".perfetto.protos.VmOpSet"; }
+
+};
+
+class VmOpMerge_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0> {
+ public:
+  VmOpMerge_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit VmOpMerge_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit VmOpMerge_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+};
+
+class VmOpMerge : public ::protozero::Message {
+ public:
+  using Decoder = VmOpMerge_Decoder;
+  static constexpr const char* GetName() { return ".perfetto.protos.VmOpMerge"; }
+
+};
+
+class VmOpRegLoad_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  VmOpRegLoad_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit VmOpRegLoad_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit VmOpRegLoad_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cursor() const { return at<1>().valid(); }
+  int32_t cursor() const { return at<1>().as_int32(); }
+  bool has_dst_register() const { return at<2>().valid(); }
+  uint32_t dst_register() const { return at<2>().as_uint32(); }
+};
+
+class VmOpRegLoad : public ::protozero::Message {
+ public:
+  using Decoder = VmOpRegLoad_Decoder;
+  enum : int32_t {
+    kCursorFieldNumber = 1,
+    kDstRegisterFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.VmOpRegLoad"; }
+
+
+  using FieldMetadata_Cursor =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      VmCursorEnum,
+      VmOpRegLoad>;
+
+  static constexpr FieldMetadata_Cursor kCursor{};
+  void set_cursor(VmCursorEnum value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cursor::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DstRegister =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VmOpRegLoad>;
+
+  static constexpr FieldMetadata_DstRegister kDstRegister{};
+  void set_dst_register(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DstRegister::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class VmOpSelect_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  VmOpSelect_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit VmOpSelect_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit VmOpSelect_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cursor() const { return at<1>().valid(); }
+  int32_t cursor() const { return at<1>().as_int32(); }
+  bool has_relative_path() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> relative_path() const { return GetRepeated<::protozero::ConstBytes>(2); }
+  bool has_create_if_not_exist() const { return at<3>().valid(); }
+  bool create_if_not_exist() const { return at<3>().as_bool(); }
+};
+
+class VmOpSelect : public ::protozero::Message {
+ public:
+  using Decoder = VmOpSelect_Decoder;
+  enum : int32_t {
+    kCursorFieldNumber = 1,
+    kRelativePathFieldNumber = 2,
+    kCreateIfNotExistFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.VmOpSelect"; }
+
+  using PathComponent = ::perfetto::protos::pbzero::VmOpSelect_PathComponent;
+
+  using FieldMetadata_Cursor =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      VmCursorEnum,
+      VmOpSelect>;
+
+  static constexpr FieldMetadata_Cursor kCursor{};
+  void set_cursor(VmCursorEnum value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cursor::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_RelativePath =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      VmOpSelect_PathComponent,
+      VmOpSelect>;
+
+  static constexpr FieldMetadata_RelativePath kRelativePath{};
+  template <typename T = VmOpSelect_PathComponent> T* add_relative_path() {
+    return BeginNestedMessage<T>(2);
+  }
+
+
+  using FieldMetadata_CreateIfNotExist =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      VmOpSelect>;
+
+  static constexpr FieldMetadata_CreateIfNotExist kCreateIfNotExist{};
+  void set_create_if_not_exist(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_CreateIfNotExist::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class VmOpSelect_PathComponent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
+ public:
+  VmOpSelect_PathComponent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit VmOpSelect_PathComponent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit VmOpSelect_PathComponent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_field_id() const { return at<1>().valid(); }
+  uint32_t field_id() const { return at<1>().as_uint32(); }
+  bool has_array_index() const { return at<2>().valid(); }
+  uint32_t array_index() const { return at<2>().as_uint32(); }
+  bool has_map_key_field_id() const { return at<3>().valid(); }
+  uint32_t map_key_field_id() const { return at<3>().as_uint32(); }
+  bool has_is_repeated() const { return at<5>().valid(); }
+  bool is_repeated() const { return at<5>().as_bool(); }
+  bool has_register_to_match() const { return at<6>().valid(); }
+  uint32_t register_to_match() const { return at<6>().as_uint32(); }
+  bool has_store_foreach_index_into_register() const { return at<7>().valid(); }
+  uint32_t store_foreach_index_into_register() const { return at<7>().as_uint32(); }
+};
+
+class VmOpSelect_PathComponent : public ::protozero::Message {
+ public:
+  using Decoder = VmOpSelect_PathComponent_Decoder;
+  enum : int32_t {
+    kFieldIdFieldNumber = 1,
+    kArrayIndexFieldNumber = 2,
+    kMapKeyFieldIdFieldNumber = 3,
+    kIsRepeatedFieldNumber = 5,
+    kRegisterToMatchFieldNumber = 6,
+    kStoreForeachIndexIntoRegisterFieldNumber = 7,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.VmOpSelect.PathComponent"; }
+
+
+  using FieldMetadata_FieldId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VmOpSelect_PathComponent>;
+
+  static constexpr FieldMetadata_FieldId kFieldId{};
+  void set_field_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FieldId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ArrayIndex =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VmOpSelect_PathComponent>;
+
+  static constexpr FieldMetadata_ArrayIndex kArrayIndex{};
+  void set_array_index(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ArrayIndex::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MapKeyFieldId =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VmOpSelect_PathComponent>;
+
+  static constexpr FieldMetadata_MapKeyFieldId kMapKeyFieldId{};
+  void set_map_key_field_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MapKeyFieldId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IsRepeated =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      VmOpSelect_PathComponent>;
+
+  static constexpr FieldMetadata_IsRepeated kIsRepeated{};
+  void set_is_repeated(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsRepeated::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_RegisterToMatch =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VmOpSelect_PathComponent>;
+
+  static constexpr FieldMetadata_RegisterToMatch kRegisterToMatch{};
+  void set_register_to_match(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RegisterToMatch::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StoreForeachIndexIntoRegister =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VmOpSelect_PathComponent>;
+
+  static constexpr FieldMetadata_StoreForeachIndexIntoRegister kStoreForeachIndexIntoRegister{};
+  void set_store_foreach_index_into_register(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StoreForeachIndexIntoRegister::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class VmInstruction_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
+ public:
+  VmInstruction_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit VmInstruction_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit VmInstruction_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_select() const { return at<1>().valid(); }
+  ::protozero::ConstBytes select() const { return at<1>().as_bytes(); }
+  bool has_reg_load() const { return at<2>().valid(); }
+  ::protozero::ConstBytes reg_load() const { return at<2>().as_bytes(); }
+  bool has_merge() const { return at<3>().valid(); }
+  ::protozero::ConstBytes merge() const { return at<3>().as_bytes(); }
+  bool has_set() const { return at<4>().valid(); }
+  ::protozero::ConstBytes set() const { return at<4>().as_bytes(); }
+  bool has_del() const { return at<5>().valid(); }
+  ::protozero::ConstBytes del() const { return at<5>().as_bytes(); }
+  bool has_abort_level() const { return at<6>().valid(); }
+  int32_t abort_level() const { return at<6>().as_int32(); }
+  bool has_nested_instructions() const { return at<7>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> nested_instructions() const { return GetRepeated<::protozero::ConstBytes>(7); }
+};
+
+class VmInstruction : public ::protozero::Message {
+ public:
+  using Decoder = VmInstruction_Decoder;
+  enum : int32_t {
+    kSelectFieldNumber = 1,
+    kRegLoadFieldNumber = 2,
+    kMergeFieldNumber = 3,
+    kSetFieldNumber = 4,
+    kDelFieldNumber = 5,
+    kAbortLevelFieldNumber = 6,
+    kNestedInstructionsFieldNumber = 7,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.VmInstruction"; }
+
+
+  using AbortLevel = ::perfetto::protos::pbzero::VmInstruction_AbortLevel;
+  static inline const char* AbortLevel_Name(AbortLevel value) {
+    return ::perfetto::protos::pbzero::VmInstruction_AbortLevel_Name(value);
+  }
+  static inline const AbortLevel SKIP_CURRENT_INSTRUCTION = AbortLevel::SKIP_CURRENT_INSTRUCTION;
+  static inline const AbortLevel SKIP_CURRENT_INSTRUCTION_AND_BREAK_OUTER = AbortLevel::SKIP_CURRENT_INSTRUCTION_AND_BREAK_OUTER;
+  static inline const AbortLevel ABORT = AbortLevel::ABORT;
+
+  using FieldMetadata_Select =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      VmOpSelect,
+      VmInstruction>;
+
+  static constexpr FieldMetadata_Select kSelect{};
+  template <typename T = VmOpSelect> T* set_select() {
+    return BeginNestedMessage<T>(1);
+  }
+
+
+  using FieldMetadata_RegLoad =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      VmOpRegLoad,
+      VmInstruction>;
+
+  static constexpr FieldMetadata_RegLoad kRegLoad{};
+  template <typename T = VmOpRegLoad> T* set_reg_load() {
+    return BeginNestedMessage<T>(2);
+  }
+
+
+  using FieldMetadata_Merge =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      VmOpMerge,
+      VmInstruction>;
+
+  static constexpr FieldMetadata_Merge kMerge{};
+  template <typename T = VmOpMerge> T* set_merge() {
+    return BeginNestedMessage<T>(3);
+  }
+
+
+  using FieldMetadata_Set =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      VmOpSet,
+      VmInstruction>;
+
+  static constexpr FieldMetadata_Set kSet{};
+  template <typename T = VmOpSet> T* set_set() {
+    return BeginNestedMessage<T>(4);
+  }
+
+
+  using FieldMetadata_Del =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      VmOpDel,
+      VmInstruction>;
+
+  static constexpr FieldMetadata_Del kDel{};
+  template <typename T = VmOpDel> T* set_del() {
+    return BeginNestedMessage<T>(5);
+  }
+
+
+  using FieldMetadata_AbortLevel =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      VmInstruction_AbortLevel,
+      VmInstruction>;
+
+  static constexpr FieldMetadata_AbortLevel kAbortLevel{};
+  void set_abort_level(VmInstruction_AbortLevel value) {
+    static constexpr uint32_t field_id = FieldMetadata_AbortLevel::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NestedInstructions =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      VmInstruction,
+      VmInstruction>;
+
+  static constexpr FieldMetadata_NestedInstructions kNestedInstructions{};
+  template <typename T = VmInstruction> T* add_nested_instructions() {
+    return BeginNestedMessage<T>(7);
+  }
+
+};
+
+class VmProgram_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  VmProgram_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit VmProgram_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit VmProgram_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_version() const { return at<1>().valid(); }
+  uint32_t version() const { return at<1>().as_uint32(); }
+  bool has_instructions() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> instructions() const { return GetRepeated<::protozero::ConstBytes>(2); }
+};
+
+class VmProgram : public ::protozero::Message {
+ public:
+  using Decoder = VmProgram_Decoder;
+  enum : int32_t {
+    kVersionFieldNumber = 1,
+    kInstructionsFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.VmProgram"; }
+
+
+  using FieldMetadata_Version =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VmProgram>;
+
+  static constexpr FieldMetadata_Version kVersion{};
+  void set_version(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Version::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Instructions =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      VmInstruction,
+      VmProgram>;
+
+  static constexpr FieldMetadata_Instructions kInstructions{};
+  template <typename T = VmInstruction> T* add_instructions() {
+    return BeginNestedMessage<T>(2);
+  }
+
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
 // gen_amalgamated begin header: gen/protos/perfetto/common/android_energy_consumer_descriptor.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
@@ -24050,10 +30249,16 @@ class PERFETTO_EXPORT_COMPONENT TrackEventCategory : public ::protozero::CppMess
 namespace perfetto {
 namespace protos {
 namespace pbzero {
-
 class AndroidEnergyConsumer;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-class AndroidEnergyConsumerDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class AndroidEnergyConsumerDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
   AndroidEnergyConsumerDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit AndroidEnergyConsumerDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -24079,21 +30284,14 @@ class AndroidEnergyConsumerDescriptor : public ::protozero::Message {
       AndroidEnergyConsumer,
       AndroidEnergyConsumerDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EnergyConsumers kEnergyConsumers() { return {}; }
+  static constexpr FieldMetadata_EnergyConsumers kEnergyConsumers{};
   template <typename T = AndroidEnergyConsumer> T* add_energy_consumers() {
     return BeginNestedMessage<T>(1);
   }
 
 };
 
-class AndroidEnergyConsumer_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class AndroidEnergyConsumer_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
   AndroidEnergyConsumer_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit AndroidEnergyConsumer_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -24128,14 +30326,7 @@ class AndroidEnergyConsumer : public ::protozero::Message {
       int32_t,
       AndroidEnergyConsumer>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EnergyConsumerId kEnergyConsumerId() { return {}; }
+  static constexpr FieldMetadata_EnergyConsumerId kEnergyConsumerId{};
   void set_energy_consumer_id(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_EnergyConsumerId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -24153,14 +30344,7 @@ class AndroidEnergyConsumer : public ::protozero::Message {
       int32_t,
       AndroidEnergyConsumer>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ordinal kOrdinal() { return {}; }
+  static constexpr FieldMetadata_Ordinal kOrdinal{};
   void set_ordinal(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ordinal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -24178,14 +30362,7 @@ class AndroidEnergyConsumer : public ::protozero::Message {
       std::string,
       AndroidEnergyConsumer>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
+  static constexpr FieldMetadata_Type kType{};
   void set_type(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Type::kFieldId, data, size);
   }
@@ -24209,14 +30386,7 @@ class AndroidEnergyConsumer : public ::protozero::Message {
       std::string,
       AndroidEnergyConsumer>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -24252,11 +30422,11 @@ class AndroidEnergyConsumer : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
 enum AndroidLogId : int32_t {
   LID_DEFAULT = 0,
   LID_RADIO = 1,
@@ -24347,75 +30517,6 @@ const char* AndroidLogPriority_Name(::perfetto::protos::pbzero::AndroidLogPriori
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/common/builtin_clock.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_BUILTIN_CLOCK_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_BUILTIN_CLOCK_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-enum BuiltinClock : int32_t {
-  BUILTIN_CLOCK_UNKNOWN = 0,
-  BUILTIN_CLOCK_REALTIME = 1,
-  BUILTIN_CLOCK_REALTIME_COARSE = 2,
-  BUILTIN_CLOCK_MONOTONIC = 3,
-  BUILTIN_CLOCK_MONOTONIC_COARSE = 4,
-  BUILTIN_CLOCK_MONOTONIC_RAW = 5,
-  BUILTIN_CLOCK_BOOTTIME = 6,
-  BUILTIN_CLOCK_MAX_ID = 63,
-};
-
-constexpr BuiltinClock BuiltinClock_MIN = BuiltinClock::BUILTIN_CLOCK_UNKNOWN;
-constexpr BuiltinClock BuiltinClock_MAX = BuiltinClock::BUILTIN_CLOCK_MAX_ID;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* BuiltinClock_Name(::perfetto::protos::pbzero::BuiltinClock value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_UNKNOWN:
-    return "BUILTIN_CLOCK_UNKNOWN";
-
-  case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_REALTIME:
-    return "BUILTIN_CLOCK_REALTIME";
-
-  case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_REALTIME_COARSE:
-    return "BUILTIN_CLOCK_REALTIME_COARSE";
-
-  case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_MONOTONIC:
-    return "BUILTIN_CLOCK_MONOTONIC";
-
-  case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_MONOTONIC_COARSE:
-    return "BUILTIN_CLOCK_MONOTONIC_COARSE";
-
-  case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_MONOTONIC_RAW:
-    return "BUILTIN_CLOCK_MONOTONIC_RAW";
-
-  case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_BOOTTIME:
-    return "BUILTIN_CLOCK_BOOTTIME";
-
-  case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_MAX_ID:
-    return "BUILTIN_CLOCK_MAX_ID";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
 } // Namespace.
 } // Namespace.
 } // Namespace.
@@ -24438,12 +30539,18 @@ const char* BuiltinClock_Name(::perfetto::protos::pbzero::BuiltinClock value) {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
-
 class CommitDataRequest_ChunkToPatch;
 class CommitDataRequest_ChunkToPatch_Patch;
 class CommitDataRequest_ChunksToMove;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-class CommitDataRequest_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class CommitDataRequest_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
   CommitDataRequest_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit CommitDataRequest_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -24477,14 +30584,7 @@ class CommitDataRequest : public ::protozero::Message {
       CommitDataRequest_ChunksToMove,
       CommitDataRequest>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChunksToMove kChunksToMove() { return {}; }
+  static constexpr FieldMetadata_ChunksToMove kChunksToMove{};
   template <typename T = CommitDataRequest_ChunksToMove> T* add_chunks_to_move() {
     return BeginNestedMessage<T>(1);
   }
@@ -24498,14 +30598,7 @@ class CommitDataRequest : public ::protozero::Message {
       CommitDataRequest_ChunkToPatch,
       CommitDataRequest>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChunksToPatch kChunksToPatch() { return {}; }
+  static constexpr FieldMetadata_ChunksToPatch kChunksToPatch{};
   template <typename T = CommitDataRequest_ChunkToPatch> T* add_chunks_to_patch() {
     return BeginNestedMessage<T>(2);
   }
@@ -24519,14 +30612,7 @@ class CommitDataRequest : public ::protozero::Message {
       uint64_t,
       CommitDataRequest>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FlushRequestId kFlushRequestId() { return {}; }
+  static constexpr FieldMetadata_FlushRequestId kFlushRequestId{};
   void set_flush_request_id(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_FlushRequestId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -24537,7 +30623,7 @@ class CommitDataRequest : public ::protozero::Message {
   }
 };
 
-class CommitDataRequest_ChunkToPatch_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class CommitDataRequest_ChunkToPatch_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
   CommitDataRequest_ChunkToPatch_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit CommitDataRequest_ChunkToPatch_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -24576,14 +30662,7 @@ class CommitDataRequest_ChunkToPatch : public ::protozero::Message {
       uint32_t,
       CommitDataRequest_ChunkToPatch>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TargetBuffer kTargetBuffer() { return {}; }
+  static constexpr FieldMetadata_TargetBuffer kTargetBuffer{};
   void set_target_buffer(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_TargetBuffer::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -24601,14 +30680,7 @@ class CommitDataRequest_ChunkToPatch : public ::protozero::Message {
       uint32_t,
       CommitDataRequest_ChunkToPatch>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WriterId kWriterId() { return {}; }
+  static constexpr FieldMetadata_WriterId kWriterId{};
   void set_writer_id(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_WriterId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -24626,14 +30698,7 @@ class CommitDataRequest_ChunkToPatch : public ::protozero::Message {
       uint32_t,
       CommitDataRequest_ChunkToPatch>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChunkId kChunkId() { return {}; }
+  static constexpr FieldMetadata_ChunkId kChunkId{};
   void set_chunk_id(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ChunkId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -24651,14 +30716,7 @@ class CommitDataRequest_ChunkToPatch : public ::protozero::Message {
       CommitDataRequest_ChunkToPatch_Patch,
       CommitDataRequest_ChunkToPatch>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Patches kPatches() { return {}; }
+  static constexpr FieldMetadata_Patches kPatches{};
   template <typename T = CommitDataRequest_ChunkToPatch_Patch> T* add_patches() {
     return BeginNestedMessage<T>(4);
   }
@@ -24672,14 +30730,7 @@ class CommitDataRequest_ChunkToPatch : public ::protozero::Message {
       bool,
       CommitDataRequest_ChunkToPatch>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HasMorePatches kHasMorePatches() { return {}; }
+  static constexpr FieldMetadata_HasMorePatches kHasMorePatches{};
   void set_has_more_patches(bool value) {
     static constexpr uint32_t field_id = FieldMetadata_HasMorePatches::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -24690,7 +30741,7 @@ class CommitDataRequest_ChunkToPatch : public ::protozero::Message {
   }
 };
 
-class CommitDataRequest_ChunkToPatch_Patch_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class CommitDataRequest_ChunkToPatch_Patch_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
   CommitDataRequest_ChunkToPatch_Patch_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit CommitDataRequest_ChunkToPatch_Patch_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -24719,14 +30770,7 @@ class CommitDataRequest_ChunkToPatch_Patch : public ::protozero::Message {
       uint32_t,
       CommitDataRequest_ChunkToPatch_Patch>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Offset kOffset() { return {}; }
+  static constexpr FieldMetadata_Offset kOffset{};
   void set_offset(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -24744,14 +30788,7 @@ class CommitDataRequest_ChunkToPatch_Patch : public ::protozero::Message {
       std::string,
       CommitDataRequest_ChunkToPatch_Patch>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Data kData() { return {}; }
+  static constexpr FieldMetadata_Data kData{};
   void set_data(const uint8_t* data, size_t size) {
     AppendBytes(FieldMetadata_Data::kFieldId, data, size);
   }
@@ -24768,7 +30805,7 @@ class CommitDataRequest_ChunkToPatch_Patch : public ::protozero::Message {
   }
 };
 
-class CommitDataRequest_ChunksToMove_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class CommitDataRequest_ChunksToMove_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
   CommitDataRequest_ChunksToMove_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit CommitDataRequest_ChunksToMove_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -24779,6 +30816,10 @@ class CommitDataRequest_ChunksToMove_Decoder : public ::protozero::TypedProtoDec
   uint32_t chunk() const { return at<2>().as_uint32(); }
   bool has_target_buffer() const { return at<3>().valid(); }
   uint32_t target_buffer() const { return at<3>().as_uint32(); }
+  bool has_data() const { return at<4>().valid(); }
+  ::protozero::ConstBytes data() const { return at<4>().as_bytes(); }
+  bool has_chunk_incomplete() const { return at<5>().valid(); }
+  bool chunk_incomplete() const { return at<5>().as_bool(); }
 };
 
 class CommitDataRequest_ChunksToMove : public ::protozero::Message {
@@ -24788,6 +30829,8 @@ class CommitDataRequest_ChunksToMove : public ::protozero::Message {
     kPageFieldNumber = 1,
     kChunkFieldNumber = 2,
     kTargetBufferFieldNumber = 3,
+    kDataFieldNumber = 4,
+    kChunkIncompleteFieldNumber = 5,
   };
   static constexpr const char* GetName() { return ".perfetto.protos.CommitDataRequest.ChunksToMove"; }
 
@@ -24800,14 +30843,7 @@ class CommitDataRequest_ChunksToMove : public ::protozero::Message {
       uint32_t,
       CommitDataRequest_ChunksToMove>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Page kPage() { return {}; }
+  static constexpr FieldMetadata_Page kPage{};
   void set_page(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -24825,14 +30861,7 @@ class CommitDataRequest_ChunksToMove : public ::protozero::Message {
       uint32_t,
       CommitDataRequest_ChunksToMove>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Chunk kChunk() { return {}; }
+  static constexpr FieldMetadata_Chunk kChunk{};
   void set_chunk(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Chunk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -24850,14 +30879,7 @@ class CommitDataRequest_ChunksToMove : public ::protozero::Message {
       uint32_t,
       CommitDataRequest_ChunksToMove>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TargetBuffer kTargetBuffer() { return {}; }
+  static constexpr FieldMetadata_TargetBuffer kTargetBuffer{};
   void set_target_buffer(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_TargetBuffer::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -24866,6 +30888,48 @@ class CommitDataRequest_ChunksToMove : public ::protozero::Message {
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_Data =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      CommitDataRequest_ChunksToMove>;
+
+  static constexpr FieldMetadata_Data kData{};
+  void set_data(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_Data::kFieldId, data, size);
+  }
+  void set_data(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_Data::kFieldId, bytes.data, bytes.size);
+  }
+  void set_data(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Data::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ChunkIncomplete =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      CommitDataRequest_ChunksToMove>;
+
+  static constexpr FieldMetadata_ChunkIncomplete kChunkIncomplete{};
+  void set_chunk_incomplete(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ChunkIncomplete::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 };
 
 } // Namespace.
@@ -24890,12 +30954,19 @@ class CommitDataRequest_ChunksToMove : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
-
 class FtraceDescriptor;
 class GpuCounterDescriptor;
 class TrackEventDescriptor;
+class VmProgram;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-class DataSourceDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DataSourceDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10> {
  public:
   DataSourceDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit DataSourceDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -24910,6 +30981,10 @@ class DataSourceDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX
   bool will_notify_on_start() const { return at<3>().as_bool(); }
   bool has_handles_incremental_state_clear() const { return at<4>().valid(); }
   bool handles_incremental_state_clear() const { return at<4>().as_bool(); }
+  bool has_no_flush() const { return at<9>().valid(); }
+  bool no_flush() const { return at<9>().as_bool(); }
+  bool has_protovm_program() const { return at<10>().valid(); }
+  ::protozero::ConstBytes protovm_program() const { return at<10>().as_bytes(); }
   bool has_gpu_counter_descriptor() const { return at<5>().valid(); }
   ::protozero::ConstBytes gpu_counter_descriptor() const { return at<5>().as_bytes(); }
   bool has_track_event_descriptor() const { return at<6>().valid(); }
@@ -24927,6 +31002,8 @@ class DataSourceDescriptor : public ::protozero::Message {
     kWillNotifyOnStopFieldNumber = 2,
     kWillNotifyOnStartFieldNumber = 3,
     kHandlesIncrementalStateClearFieldNumber = 4,
+    kNoFlushFieldNumber = 9,
+    kProtovmProgramFieldNumber = 10,
     kGpuCounterDescriptorFieldNumber = 5,
     kTrackEventDescriptorFieldNumber = 6,
     kFtraceDescriptorFieldNumber = 8,
@@ -24942,14 +31019,7 @@ class DataSourceDescriptor : public ::protozero::Message {
       std::string,
       DataSourceDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -24973,14 +31043,7 @@ class DataSourceDescriptor : public ::protozero::Message {
       uint64_t,
       DataSourceDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
+  static constexpr FieldMetadata_Id kId{};
   void set_id(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -24998,14 +31061,7 @@ class DataSourceDescriptor : public ::protozero::Message {
       bool,
       DataSourceDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WillNotifyOnStop kWillNotifyOnStop() { return {}; }
+  static constexpr FieldMetadata_WillNotifyOnStop kWillNotifyOnStop{};
   void set_will_notify_on_stop(bool value) {
     static constexpr uint32_t field_id = FieldMetadata_WillNotifyOnStop::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -25023,14 +31079,7 @@ class DataSourceDescriptor : public ::protozero::Message {
       bool,
       DataSourceDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WillNotifyOnStart kWillNotifyOnStart() { return {}; }
+  static constexpr FieldMetadata_WillNotifyOnStart kWillNotifyOnStart{};
   void set_will_notify_on_start(bool value) {
     static constexpr uint32_t field_id = FieldMetadata_WillNotifyOnStart::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -25048,14 +31097,7 @@ class DataSourceDescriptor : public ::protozero::Message {
       bool,
       DataSourceDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HandlesIncrementalStateClear kHandlesIncrementalStateClear() { return {}; }
+  static constexpr FieldMetadata_HandlesIncrementalStateClear kHandlesIncrementalStateClear{};
   void set_handles_incremental_state_clear(bool value) {
     static constexpr uint32_t field_id = FieldMetadata_HandlesIncrementalStateClear::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -25065,6 +31107,38 @@ class DataSourceDescriptor : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
+  using FieldMetadata_NoFlush =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      DataSourceDescriptor>;
+
+  static constexpr FieldMetadata_NoFlush kNoFlush{};
+  void set_no_flush(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_NoFlush::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ProtovmProgram =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      VmProgram,
+      DataSourceDescriptor>;
+
+  static constexpr FieldMetadata_ProtovmProgram kProtovmProgram{};
+  template <typename T = VmProgram> T* set_protovm_program() {
+    return BeginNestedMessage<T>(10);
+  }
+
+
   using FieldMetadata_GpuCounterDescriptor =
     ::protozero::proto_utils::FieldMetadata<
       5,
@@ -25073,14 +31147,7 @@ class DataSourceDescriptor : public ::protozero::Message {
       GpuCounterDescriptor,
       DataSourceDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GpuCounterDescriptor kGpuCounterDescriptor() { return {}; }
+  static constexpr FieldMetadata_GpuCounterDescriptor kGpuCounterDescriptor{};
   template <typename T = GpuCounterDescriptor> T* set_gpu_counter_descriptor() {
     return BeginNestedMessage<T>(5);
   }
@@ -25098,14 +31165,7 @@ class DataSourceDescriptor : public ::protozero::Message {
       TrackEventDescriptor,
       DataSourceDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrackEventDescriptor kTrackEventDescriptor() { return {}; }
+  static constexpr FieldMetadata_TrackEventDescriptor kTrackEventDescriptor{};
   template <typename T = TrackEventDescriptor> T* set_track_event_descriptor() {
     return BeginNestedMessage<T>(6);
   }
@@ -25123,14 +31183,7 @@ class DataSourceDescriptor : public ::protozero::Message {
       FtraceDescriptor,
       DataSourceDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FtraceDescriptor kFtraceDescriptor() { return {}; }
+  static constexpr FieldMetadata_FtraceDescriptor kFtraceDescriptor{};
   template <typename T = FtraceDescriptor> T* set_ftrace_descriptor() {
     return BeginNestedMessage<T>(8);
   }
@@ -25163,15 +31216,17 @@ class DataSourceDescriptor : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
-
 class DescriptorProto;
 class DescriptorProto_ReservedRange;
 class EnumDescriptorProto;
 class EnumValueDescriptorProto;
 class FieldDescriptorProto;
+class FieldOptions;
 class FileDescriptorProto;
 class OneofDescriptorProto;
 class OneofOptions;
+class UninterpretedOption;
+class UninterpretedOption_NamePart;
 namespace perfetto_pbzero_enum_FieldDescriptorProto {
 enum Label : int32_t;
 }  // namespace perfetto_pbzero_enum_FieldDescriptorProto
@@ -25180,6 +31235,13 @@ namespace perfetto_pbzero_enum_FieldDescriptorProto {
 enum Type : int32_t;
 }  // namespace perfetto_pbzero_enum_FieldDescriptorProto
 using FieldDescriptorProto_Type = perfetto_pbzero_enum_FieldDescriptorProto::Type;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
 namespace perfetto_pbzero_enum_FieldDescriptorProto {
 enum Type : int32_t {
@@ -25299,7 +31361,7 @@ const char* FieldDescriptorProto_Label_Name(::perfetto::protos::pbzero::FieldDes
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-class OneofOptions_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class OneofOptions_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0> {
  public:
   OneofOptions_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit OneofOptions_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -25313,7 +31375,7 @@ class OneofOptions : public ::protozero::Message {
 
 };
 
-class EnumValueDescriptorProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class EnumValueDescriptorProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
   EnumValueDescriptorProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit EnumValueDescriptorProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -25342,14 +31404,7 @@ class EnumValueDescriptorProto : public ::protozero::Message {
       std::string,
       EnumValueDescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -25373,14 +31428,7 @@ class EnumValueDescriptorProto : public ::protozero::Message {
       int32_t,
       EnumValueDescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Number kNumber() { return {}; }
+  static constexpr FieldMetadata_Number kNumber{};
   void set_number(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Number::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -25391,7 +31439,7 @@ class EnumValueDescriptorProto : public ::protozero::Message {
   }
 };
 
-class EnumDescriptorProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class EnumDescriptorProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
   EnumDescriptorProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit EnumDescriptorProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -25423,14 +31471,7 @@ class EnumDescriptorProto : public ::protozero::Message {
       std::string,
       EnumDescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -25454,14 +31495,7 @@ class EnumDescriptorProto : public ::protozero::Message {
       EnumValueDescriptorProto,
       EnumDescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
+  static constexpr FieldMetadata_Value kValue{};
   template <typename T = EnumValueDescriptorProto> T* add_value() {
     return BeginNestedMessage<T>(2);
   }
@@ -25475,14 +31509,7 @@ class EnumDescriptorProto : public ::protozero::Message {
       std::string,
       EnumDescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReservedName kReservedName() { return {}; }
+  static constexpr FieldMetadata_ReservedName kReservedName{};
   void add_reserved_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_ReservedName::kFieldId, data, size);
   }
@@ -25499,7 +31526,7 @@ class EnumDescriptorProto : public ::protozero::Message {
   }
 };
 
-class OneofDescriptorProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class OneofDescriptorProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
   OneofDescriptorProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit OneofDescriptorProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -25528,14 +31555,7 @@ class OneofDescriptorProto : public ::protozero::Message {
       std::string,
       OneofDescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -25559,21 +31579,14 @@ class OneofDescriptorProto : public ::protozero::Message {
       OneofOptions,
       OneofDescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Options kOptions() { return {}; }
+  static constexpr FieldMetadata_Options kOptions{};
   template <typename T = OneofOptions> T* set_options() {
     return BeginNestedMessage<T>(2);
   }
 
 };
 
-class FieldDescriptorProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class FieldDescriptorProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9> {
  public:
   FieldDescriptorProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit FieldDescriptorProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -25592,6 +31605,8 @@ class FieldDescriptorProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX
   ::protozero::ConstChars extendee() const { return at<2>().as_string(); }
   bool has_default_value() const { return at<7>().valid(); }
   ::protozero::ConstChars default_value() const { return at<7>().as_string(); }
+  bool has_options() const { return at<8>().valid(); }
+  ::protozero::ConstBytes options() const { return at<8>().as_bytes(); }
   bool has_oneof_index() const { return at<9>().valid(); }
   int32_t oneof_index() const { return at<9>().as_int32(); }
 };
@@ -25607,6 +31622,7 @@ class FieldDescriptorProto : public ::protozero::Message {
     kTypeNameFieldNumber = 6,
     kExtendeeFieldNumber = 2,
     kDefaultValueFieldNumber = 7,
+    kOptionsFieldNumber = 8,
     kOneofIndexFieldNumber = 9,
   };
   static constexpr const char* GetName() { return ".perfetto.protos.FieldDescriptorProto"; }
@@ -25621,27 +31637,27 @@ class FieldDescriptorProto : public ::protozero::Message {
   static inline const char* Label_Name(Label value) {
     return ::perfetto::protos::pbzero::FieldDescriptorProto_Label_Name(value);
   }
-  static const Type TYPE_DOUBLE = Type::TYPE_DOUBLE;
-  static const Type TYPE_FLOAT = Type::TYPE_FLOAT;
-  static const Type TYPE_INT64 = Type::TYPE_INT64;
-  static const Type TYPE_UINT64 = Type::TYPE_UINT64;
-  static const Type TYPE_INT32 = Type::TYPE_INT32;
-  static const Type TYPE_FIXED64 = Type::TYPE_FIXED64;
-  static const Type TYPE_FIXED32 = Type::TYPE_FIXED32;
-  static const Type TYPE_BOOL = Type::TYPE_BOOL;
-  static const Type TYPE_STRING = Type::TYPE_STRING;
-  static const Type TYPE_GROUP = Type::TYPE_GROUP;
-  static const Type TYPE_MESSAGE = Type::TYPE_MESSAGE;
-  static const Type TYPE_BYTES = Type::TYPE_BYTES;
-  static const Type TYPE_UINT32 = Type::TYPE_UINT32;
-  static const Type TYPE_ENUM = Type::TYPE_ENUM;
-  static const Type TYPE_SFIXED32 = Type::TYPE_SFIXED32;
-  static const Type TYPE_SFIXED64 = Type::TYPE_SFIXED64;
-  static const Type TYPE_SINT32 = Type::TYPE_SINT32;
-  static const Type TYPE_SINT64 = Type::TYPE_SINT64;
-  static const Label LABEL_OPTIONAL = Label::LABEL_OPTIONAL;
-  static const Label LABEL_REQUIRED = Label::LABEL_REQUIRED;
-  static const Label LABEL_REPEATED = Label::LABEL_REPEATED;
+  static inline const Type TYPE_DOUBLE = Type::TYPE_DOUBLE;
+  static inline const Type TYPE_FLOAT = Type::TYPE_FLOAT;
+  static inline const Type TYPE_INT64 = Type::TYPE_INT64;
+  static inline const Type TYPE_UINT64 = Type::TYPE_UINT64;
+  static inline const Type TYPE_INT32 = Type::TYPE_INT32;
+  static inline const Type TYPE_FIXED64 = Type::TYPE_FIXED64;
+  static inline const Type TYPE_FIXED32 = Type::TYPE_FIXED32;
+  static inline const Type TYPE_BOOL = Type::TYPE_BOOL;
+  static inline const Type TYPE_STRING = Type::TYPE_STRING;
+  static inline const Type TYPE_GROUP = Type::TYPE_GROUP;
+  static inline const Type TYPE_MESSAGE = Type::TYPE_MESSAGE;
+  static inline const Type TYPE_BYTES = Type::TYPE_BYTES;
+  static inline const Type TYPE_UINT32 = Type::TYPE_UINT32;
+  static inline const Type TYPE_ENUM = Type::TYPE_ENUM;
+  static inline const Type TYPE_SFIXED32 = Type::TYPE_SFIXED32;
+  static inline const Type TYPE_SFIXED64 = Type::TYPE_SFIXED64;
+  static inline const Type TYPE_SINT32 = Type::TYPE_SINT32;
+  static inline const Type TYPE_SINT64 = Type::TYPE_SINT64;
+  static inline const Label LABEL_OPTIONAL = Label::LABEL_OPTIONAL;
+  static inline const Label LABEL_REQUIRED = Label::LABEL_REQUIRED;
+  static inline const Label LABEL_REPEATED = Label::LABEL_REPEATED;
 
   using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
@@ -25651,14 +31667,7 @@ class FieldDescriptorProto : public ::protozero::Message {
       std::string,
       FieldDescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -25682,14 +31691,7 @@ class FieldDescriptorProto : public ::protozero::Message {
       int32_t,
       FieldDescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Number kNumber() { return {}; }
+  static constexpr FieldMetadata_Number kNumber{};
   void set_number(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Number::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -25704,18 +31706,11 @@ class FieldDescriptorProto : public ::protozero::Message {
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::FieldDescriptorProto_Label,
+      FieldDescriptorProto_Label,
       FieldDescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Label kLabel() { return {}; }
-  void set_label(::perfetto::protos::pbzero::FieldDescriptorProto_Label value) {
+  static constexpr FieldMetadata_Label kLabel{};
+  void set_label(FieldDescriptorProto_Label value) {
     static constexpr uint32_t field_id = FieldMetadata_Label::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
@@ -25729,18 +31724,11 @@ class FieldDescriptorProto : public ::protozero::Message {
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::FieldDescriptorProto_Type,
+      FieldDescriptorProto_Type,
       FieldDescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(::perfetto::protos::pbzero::FieldDescriptorProto_Type value) {
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(FieldDescriptorProto_Type value) {
     static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
@@ -25757,14 +31745,7 @@ class FieldDescriptorProto : public ::protozero::Message {
       std::string,
       FieldDescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TypeName kTypeName() { return {}; }
+  static constexpr FieldMetadata_TypeName kTypeName{};
   void set_type_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_TypeName::kFieldId, data, size);
   }
@@ -25788,14 +31769,7 @@ class FieldDescriptorProto : public ::protozero::Message {
       std::string,
       FieldDescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Extendee kExtendee() { return {}; }
+  static constexpr FieldMetadata_Extendee kExtendee{};
   void set_extendee(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Extendee::kFieldId, data, size);
   }
@@ -25819,14 +31793,7 @@ class FieldDescriptorProto : public ::protozero::Message {
       std::string,
       FieldDescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DefaultValue kDefaultValue() { return {}; }
+  static constexpr FieldMetadata_DefaultValue kDefaultValue{};
   void set_default_value(const char* data, size_t size) {
     AppendBytes(FieldMetadata_DefaultValue::kFieldId, data, size);
   }
@@ -25842,6 +31809,20 @@ class FieldDescriptorProto : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
+  using FieldMetadata_Options =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FieldOptions,
+      FieldDescriptorProto>;
+
+  static constexpr FieldMetadata_Options kOptions{};
+  template <typename T = FieldOptions> T* set_options() {
+    return BeginNestedMessage<T>(8);
+  }
+
+
   using FieldMetadata_OneofIndex =
     ::protozero::proto_utils::FieldMetadata<
       9,
@@ -25850,14 +31831,7 @@ class FieldDescriptorProto : public ::protozero::Message {
       int32_t,
       FieldDescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OneofIndex kOneofIndex() { return {}; }
+  static constexpr FieldMetadata_OneofIndex kOneofIndex{};
   void set_oneof_index(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_OneofIndex::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -25868,7 +31842,303 @@ class FieldDescriptorProto : public ::protozero::Message {
   }
 };
 
-class DescriptorProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class FieldOptions_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/999> {
+ public:
+  FieldOptions_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FieldOptions_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FieldOptions_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_packed() const { return at<2>().valid(); }
+  bool packed() const { return at<2>().as_bool(); }
+  bool has_uninterpreted_option() const { return at<999>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> uninterpreted_option() const { return GetRepeated<::protozero::ConstBytes>(999); }
+};
+
+class FieldOptions : public ::protozero::Message {
+ public:
+  using Decoder = FieldOptions_Decoder;
+  enum : int32_t {
+    kPackedFieldNumber = 2,
+    kUninterpretedOptionFieldNumber = 999,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FieldOptions"; }
+
+
+  using FieldMetadata_Packed =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      FieldOptions>;
+
+  static constexpr FieldMetadata_Packed kPacked{};
+  void set_packed(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_Packed::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_UninterpretedOption =
+    ::protozero::proto_utils::FieldMetadata<
+      999,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      UninterpretedOption,
+      FieldOptions>;
+
+  static constexpr FieldMetadata_UninterpretedOption kUninterpretedOption{};
+  template <typename T = UninterpretedOption> T* add_uninterpreted_option() {
+    return BeginNestedMessage<T>(999);
+  }
+
+};
+
+class UninterpretedOption_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
+ public:
+  UninterpretedOption_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit UninterpretedOption_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit UninterpretedOption_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> name() const { return GetRepeated<::protozero::ConstBytes>(2); }
+  bool has_identifier_value() const { return at<3>().valid(); }
+  ::protozero::ConstChars identifier_value() const { return at<3>().as_string(); }
+  bool has_positive_int_value() const { return at<4>().valid(); }
+  uint64_t positive_int_value() const { return at<4>().as_uint64(); }
+  bool has_negative_int_value() const { return at<5>().valid(); }
+  int64_t negative_int_value() const { return at<5>().as_int64(); }
+  bool has_double_value() const { return at<6>().valid(); }
+  double double_value() const { return at<6>().as_double(); }
+  bool has_string_value() const { return at<7>().valid(); }
+  ::protozero::ConstBytes string_value() const { return at<7>().as_bytes(); }
+  bool has_aggregate_value() const { return at<8>().valid(); }
+  ::protozero::ConstChars aggregate_value() const { return at<8>().as_string(); }
+};
+
+class UninterpretedOption : public ::protozero::Message {
+ public:
+  using Decoder = UninterpretedOption_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 2,
+    kIdentifierValueFieldNumber = 3,
+    kPositiveIntValueFieldNumber = 4,
+    kNegativeIntValueFieldNumber = 5,
+    kDoubleValueFieldNumber = 6,
+    kStringValueFieldNumber = 7,
+    kAggregateValueFieldNumber = 8,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.UninterpretedOption"; }
+
+  using NamePart = ::perfetto::protos::pbzero::UninterpretedOption_NamePart;
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      UninterpretedOption_NamePart,
+      UninterpretedOption>;
+
+  static constexpr FieldMetadata_Name kName{};
+  template <typename T = UninterpretedOption_NamePart> T* add_name() {
+    return BeginNestedMessage<T>(2);
+  }
+
+
+  using FieldMetadata_IdentifierValue =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      UninterpretedOption>;
+
+  static constexpr FieldMetadata_IdentifierValue kIdentifierValue{};
+  void set_identifier_value(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_IdentifierValue::kFieldId, data, size);
+  }
+  void set_identifier_value(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_IdentifierValue::kFieldId, chars.data, chars.size);
+  }
+  void set_identifier_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_IdentifierValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PositiveIntValue =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      UninterpretedOption>;
+
+  static constexpr FieldMetadata_PositiveIntValue kPositiveIntValue{};
+  void set_positive_int_value(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PositiveIntValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NegativeIntValue =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      UninterpretedOption>;
+
+  static constexpr FieldMetadata_NegativeIntValue kNegativeIntValue{};
+  void set_negative_int_value(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NegativeIntValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DoubleValue =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kDouble,
+      double,
+      UninterpretedOption>;
+
+  static constexpr FieldMetadata_DoubleValue kDoubleValue{};
+  void set_double_value(double value) {
+    static constexpr uint32_t field_id = FieldMetadata_DoubleValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StringValue =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      UninterpretedOption>;
+
+  static constexpr FieldMetadata_StringValue kStringValue{};
+  void set_string_value(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_StringValue::kFieldId, data, size);
+  }
+  void set_string_value(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_StringValue::kFieldId, bytes.data, bytes.size);
+  }
+  void set_string_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_StringValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_AggregateValue =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      UninterpretedOption>;
+
+  static constexpr FieldMetadata_AggregateValue kAggregateValue{};
+  void set_aggregate_value(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_AggregateValue::kFieldId, data, size);
+  }
+  void set_aggregate_value(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_AggregateValue::kFieldId, chars.data, chars.size);
+  }
+  void set_aggregate_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_AggregateValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class UninterpretedOption_NamePart_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  UninterpretedOption_NamePart_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit UninterpretedOption_NamePart_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit UninterpretedOption_NamePart_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name_part() const { return at<1>().valid(); }
+  ::protozero::ConstChars name_part() const { return at<1>().as_string(); }
+  bool has_is_extension() const { return at<2>().valid(); }
+  bool is_extension() const { return at<2>().as_bool(); }
+};
+
+class UninterpretedOption_NamePart : public ::protozero::Message {
+ public:
+  using Decoder = UninterpretedOption_NamePart_Decoder;
+  enum : int32_t {
+    kNamePartFieldNumber = 1,
+    kIsExtensionFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.UninterpretedOption.NamePart"; }
+
+
+  using FieldMetadata_NamePart =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      UninterpretedOption_NamePart>;
+
+  static constexpr FieldMetadata_NamePart kNamePart{};
+  void set_name_part(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_NamePart::kFieldId, data, size);
+  }
+  void set_name_part(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_NamePart::kFieldId, chars.data, chars.size);
+  }
+  void set_name_part(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_NamePart::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IsExtension =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      UninterpretedOption_NamePart>;
+
+  static constexpr FieldMetadata_IsExtension kIsExtension{};
+  void set_is_extension(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsExtension::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class DescriptorProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10> {
  public:
   DescriptorProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit DescriptorProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -25916,14 +32186,7 @@ class DescriptorProto : public ::protozero::Message {
       std::string,
       DescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -25947,14 +32210,7 @@ class DescriptorProto : public ::protozero::Message {
       FieldDescriptorProto,
       DescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Field kField() { return {}; }
+  static constexpr FieldMetadata_Field kField{};
   template <typename T = FieldDescriptorProto> T* add_field() {
     return BeginNestedMessage<T>(2);
   }
@@ -25968,14 +32224,7 @@ class DescriptorProto : public ::protozero::Message {
       FieldDescriptorProto,
       DescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Extension kExtension() { return {}; }
+  static constexpr FieldMetadata_Extension kExtension{};
   template <typename T = FieldDescriptorProto> T* add_extension() {
     return BeginNestedMessage<T>(6);
   }
@@ -25989,14 +32238,7 @@ class DescriptorProto : public ::protozero::Message {
       DescriptorProto,
       DescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NestedType kNestedType() { return {}; }
+  static constexpr FieldMetadata_NestedType kNestedType{};
   template <typename T = DescriptorProto> T* add_nested_type() {
     return BeginNestedMessage<T>(3);
   }
@@ -26010,14 +32252,7 @@ class DescriptorProto : public ::protozero::Message {
       EnumDescriptorProto,
       DescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EnumType kEnumType() { return {}; }
+  static constexpr FieldMetadata_EnumType kEnumType{};
   template <typename T = EnumDescriptorProto> T* add_enum_type() {
     return BeginNestedMessage<T>(4);
   }
@@ -26031,14 +32266,7 @@ class DescriptorProto : public ::protozero::Message {
       OneofDescriptorProto,
       DescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OneofDecl kOneofDecl() { return {}; }
+  static constexpr FieldMetadata_OneofDecl kOneofDecl{};
   template <typename T = OneofDescriptorProto> T* add_oneof_decl() {
     return BeginNestedMessage<T>(8);
   }
@@ -26052,14 +32280,7 @@ class DescriptorProto : public ::protozero::Message {
       DescriptorProto_ReservedRange,
       DescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReservedRange kReservedRange() { return {}; }
+  static constexpr FieldMetadata_ReservedRange kReservedRange{};
   template <typename T = DescriptorProto_ReservedRange> T* add_reserved_range() {
     return BeginNestedMessage<T>(9);
   }
@@ -26073,14 +32294,7 @@ class DescriptorProto : public ::protozero::Message {
       std::string,
       DescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReservedName kReservedName() { return {}; }
+  static constexpr FieldMetadata_ReservedName kReservedName{};
   void add_reserved_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_ReservedName::kFieldId, data, size);
   }
@@ -26097,7 +32311,7 @@ class DescriptorProto : public ::protozero::Message {
   }
 };
 
-class DescriptorProto_ReservedRange_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DescriptorProto_ReservedRange_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
   DescriptorProto_ReservedRange_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit DescriptorProto_ReservedRange_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -26126,14 +32340,7 @@ class DescriptorProto_ReservedRange : public ::protozero::Message {
       int32_t,
       DescriptorProto_ReservedRange>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Start kStart() { return {}; }
+  static constexpr FieldMetadata_Start kStart{};
   void set_start(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -26151,14 +32358,7 @@ class DescriptorProto_ReservedRange : public ::protozero::Message {
       int32_t,
       DescriptorProto_ReservedRange>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_End kEnd() { return {}; }
+  static constexpr FieldMetadata_End kEnd{};
   void set_end(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_End::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -26169,7 +32369,7 @@ class DescriptorProto_ReservedRange : public ::protozero::Message {
   }
 };
 
-class FileDescriptorProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class FileDescriptorProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11> {
  public:
   FileDescriptorProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit FileDescriptorProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -26216,14 +32416,7 @@ class FileDescriptorProto : public ::protozero::Message {
       std::string,
       FileDescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -26247,14 +32440,7 @@ class FileDescriptorProto : public ::protozero::Message {
       std::string,
       FileDescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Package kPackage() { return {}; }
+  static constexpr FieldMetadata_Package kPackage{};
   void set_package(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Package::kFieldId, data, size);
   }
@@ -26278,14 +32464,7 @@ class FileDescriptorProto : public ::protozero::Message {
       std::string,
       FileDescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dependency kDependency() { return {}; }
+  static constexpr FieldMetadata_Dependency kDependency{};
   void add_dependency(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Dependency::kFieldId, data, size);
   }
@@ -26309,14 +32488,7 @@ class FileDescriptorProto : public ::protozero::Message {
       int32_t,
       FileDescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PublicDependency kPublicDependency() { return {}; }
+  static constexpr FieldMetadata_PublicDependency kPublicDependency{};
   void add_public_dependency(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_PublicDependency::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -26334,14 +32506,7 @@ class FileDescriptorProto : public ::protozero::Message {
       int32_t,
       FileDescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WeakDependency kWeakDependency() { return {}; }
+  static constexpr FieldMetadata_WeakDependency kWeakDependency{};
   void add_weak_dependency(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_WeakDependency::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -26359,14 +32524,7 @@ class FileDescriptorProto : public ::protozero::Message {
       DescriptorProto,
       FileDescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MessageType kMessageType() { return {}; }
+  static constexpr FieldMetadata_MessageType kMessageType{};
   template <typename T = DescriptorProto> T* add_message_type() {
     return BeginNestedMessage<T>(4);
   }
@@ -26380,14 +32538,7 @@ class FileDescriptorProto : public ::protozero::Message {
       EnumDescriptorProto,
       FileDescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EnumType kEnumType() { return {}; }
+  static constexpr FieldMetadata_EnumType kEnumType{};
   template <typename T = EnumDescriptorProto> T* add_enum_type() {
     return BeginNestedMessage<T>(5);
   }
@@ -26401,21 +32552,14 @@ class FileDescriptorProto : public ::protozero::Message {
       FieldDescriptorProto,
       FileDescriptorProto>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Extension kExtension() { return {}; }
+  static constexpr FieldMetadata_Extension kExtension{};
   template <typename T = FieldDescriptorProto> T* add_extension() {
     return BeginNestedMessage<T>(7);
   }
 
 };
 
-class FileDescriptorSet_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class FileDescriptorSet_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
   FileDescriptorSet_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit FileDescriptorSet_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -26441,14 +32585,7 @@ class FileDescriptorSet : public ::protozero::Message {
       FileDescriptorProto,
       FileDescriptorSet>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_File kFile() { return {}; }
+  static constexpr FieldMetadata_File kFile{};
   template <typename T = FileDescriptorProto> T* add_file() {
     return BeginNestedMessage<T>(1);
   }
@@ -26477,10 +32614,16 @@ class FileDescriptorSet : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
-
 class FtraceDescriptor_AtraceCategory;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-class FtraceDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class FtraceDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
   FtraceDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit FtraceDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -26507,21 +32650,14 @@ class FtraceDescriptor : public ::protozero::Message {
       FtraceDescriptor_AtraceCategory,
       FtraceDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AtraceCategories kAtraceCategories() { return {}; }
+  static constexpr FieldMetadata_AtraceCategories kAtraceCategories{};
   template <typename T = FtraceDescriptor_AtraceCategory> T* add_atrace_categories() {
     return BeginNestedMessage<T>(1);
   }
 
 };
 
-class FtraceDescriptor_AtraceCategory_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class FtraceDescriptor_AtraceCategory_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
   FtraceDescriptor_AtraceCategory_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit FtraceDescriptor_AtraceCategory_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -26550,14 +32686,7 @@ class FtraceDescriptor_AtraceCategory : public ::protozero::Message {
       std::string,
       FtraceDescriptor_AtraceCategory>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -26581,14 +32710,7 @@ class FtraceDescriptor_AtraceCategory : public ::protozero::Message {
       std::string,
       FtraceDescriptor_AtraceCategory>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Description kDescription() { return {}; }
+  static constexpr FieldMetadata_Description kDescription{};
   void set_description(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Description::kFieldId, data, size);
   }
@@ -26627,7 +32749,6 @@ class FtraceDescriptor_AtraceCategory : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
-
 class GpuCounterDescriptor_GpuCounterBlock;
 class GpuCounterDescriptor_GpuCounterSpec;
 namespace perfetto_pbzero_enum_GpuCounterDescriptor {
@@ -26638,6 +32759,13 @@ namespace perfetto_pbzero_enum_GpuCounterDescriptor {
 enum MeasureUnit : int32_t;
 }  // namespace perfetto_pbzero_enum_GpuCounterDescriptor
 using GpuCounterDescriptor_MeasureUnit = perfetto_pbzero_enum_GpuCounterDescriptor::MeasureUnit;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
 namespace perfetto_pbzero_enum_GpuCounterDescriptor {
 enum GpuCounterGroup : int32_t {
@@ -26648,13 +32776,14 @@ enum GpuCounterGroup : int32_t {
   PRIMITIVES = 4,
   MEMORY = 5,
   COMPUTE = 6,
+  RAY_TRACING = 7,
 };
 } // namespace perfetto_pbzero_enum_GpuCounterDescriptor
 using GpuCounterDescriptor_GpuCounterGroup = perfetto_pbzero_enum_GpuCounterDescriptor::GpuCounterGroup;
 
 
 constexpr GpuCounterDescriptor_GpuCounterGroup GpuCounterDescriptor_GpuCounterGroup_MIN = GpuCounterDescriptor_GpuCounterGroup::UNCLASSIFIED;
-constexpr GpuCounterDescriptor_GpuCounterGroup GpuCounterDescriptor_GpuCounterGroup_MAX = GpuCounterDescriptor_GpuCounterGroup::COMPUTE;
+constexpr GpuCounterDescriptor_GpuCounterGroup GpuCounterDescriptor_GpuCounterGroup_MAX = GpuCounterDescriptor_GpuCounterGroup::RAY_TRACING;
 
 
 PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
@@ -26680,6 +32809,9 @@ const char* GpuCounterDescriptor_GpuCounterGroup_Name(::perfetto::protos::pbzero
 
   case ::perfetto::protos::pbzero::GpuCounterDescriptor_GpuCounterGroup::COMPUTE:
     return "COMPUTE";
+
+  case ::perfetto::protos::pbzero::GpuCounterDescriptor_GpuCounterGroup::RAY_TRACING:
+    return "RAY_TRACING";
   }
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
@@ -26865,7 +32997,7 @@ const char* GpuCounterDescriptor_MeasureUnit_Name(::perfetto::protos::pbzero::Gp
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-class GpuCounterDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class GpuCounterDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
   GpuCounterDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit GpuCounterDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -26906,54 +33038,55 @@ class GpuCounterDescriptor : public ::protozero::Message {
   static inline const char* MeasureUnit_Name(MeasureUnit value) {
     return ::perfetto::protos::pbzero::GpuCounterDescriptor_MeasureUnit_Name(value);
   }
-  static const GpuCounterGroup UNCLASSIFIED = GpuCounterGroup::UNCLASSIFIED;
-  static const GpuCounterGroup SYSTEM = GpuCounterGroup::SYSTEM;
-  static const GpuCounterGroup VERTICES = GpuCounterGroup::VERTICES;
-  static const GpuCounterGroup FRAGMENTS = GpuCounterGroup::FRAGMENTS;
-  static const GpuCounterGroup PRIMITIVES = GpuCounterGroup::PRIMITIVES;
-  static const GpuCounterGroup MEMORY = GpuCounterGroup::MEMORY;
-  static const GpuCounterGroup COMPUTE = GpuCounterGroup::COMPUTE;
-  static const MeasureUnit NONE = MeasureUnit::NONE;
-  static const MeasureUnit BIT = MeasureUnit::BIT;
-  static const MeasureUnit KILOBIT = MeasureUnit::KILOBIT;
-  static const MeasureUnit MEGABIT = MeasureUnit::MEGABIT;
-  static const MeasureUnit GIGABIT = MeasureUnit::GIGABIT;
-  static const MeasureUnit TERABIT = MeasureUnit::TERABIT;
-  static const MeasureUnit PETABIT = MeasureUnit::PETABIT;
-  static const MeasureUnit BYTE = MeasureUnit::BYTE;
-  static const MeasureUnit KILOBYTE = MeasureUnit::KILOBYTE;
-  static const MeasureUnit MEGABYTE = MeasureUnit::MEGABYTE;
-  static const MeasureUnit GIGABYTE = MeasureUnit::GIGABYTE;
-  static const MeasureUnit TERABYTE = MeasureUnit::TERABYTE;
-  static const MeasureUnit PETABYTE = MeasureUnit::PETABYTE;
-  static const MeasureUnit HERTZ = MeasureUnit::HERTZ;
-  static const MeasureUnit KILOHERTZ = MeasureUnit::KILOHERTZ;
-  static const MeasureUnit MEGAHERTZ = MeasureUnit::MEGAHERTZ;
-  static const MeasureUnit GIGAHERTZ = MeasureUnit::GIGAHERTZ;
-  static const MeasureUnit TERAHERTZ = MeasureUnit::TERAHERTZ;
-  static const MeasureUnit PETAHERTZ = MeasureUnit::PETAHERTZ;
-  static const MeasureUnit NANOSECOND = MeasureUnit::NANOSECOND;
-  static const MeasureUnit MICROSECOND = MeasureUnit::MICROSECOND;
-  static const MeasureUnit MILLISECOND = MeasureUnit::MILLISECOND;
-  static const MeasureUnit SECOND = MeasureUnit::SECOND;
-  static const MeasureUnit MINUTE = MeasureUnit::MINUTE;
-  static const MeasureUnit HOUR = MeasureUnit::HOUR;
-  static const MeasureUnit VERTEX = MeasureUnit::VERTEX;
-  static const MeasureUnit PIXEL = MeasureUnit::PIXEL;
-  static const MeasureUnit TRIANGLE = MeasureUnit::TRIANGLE;
-  static const MeasureUnit PRIMITIVE = MeasureUnit::PRIMITIVE;
-  static const MeasureUnit FRAGMENT = MeasureUnit::FRAGMENT;
-  static const MeasureUnit MILLIWATT = MeasureUnit::MILLIWATT;
-  static const MeasureUnit WATT = MeasureUnit::WATT;
-  static const MeasureUnit KILOWATT = MeasureUnit::KILOWATT;
-  static const MeasureUnit JOULE = MeasureUnit::JOULE;
-  static const MeasureUnit VOLT = MeasureUnit::VOLT;
-  static const MeasureUnit AMPERE = MeasureUnit::AMPERE;
-  static const MeasureUnit CELSIUS = MeasureUnit::CELSIUS;
-  static const MeasureUnit FAHRENHEIT = MeasureUnit::FAHRENHEIT;
-  static const MeasureUnit KELVIN = MeasureUnit::KELVIN;
-  static const MeasureUnit PERCENT = MeasureUnit::PERCENT;
-  static const MeasureUnit INSTRUCTION = MeasureUnit::INSTRUCTION;
+  static inline const GpuCounterGroup UNCLASSIFIED = GpuCounterGroup::UNCLASSIFIED;
+  static inline const GpuCounterGroup SYSTEM = GpuCounterGroup::SYSTEM;
+  static inline const GpuCounterGroup VERTICES = GpuCounterGroup::VERTICES;
+  static inline const GpuCounterGroup FRAGMENTS = GpuCounterGroup::FRAGMENTS;
+  static inline const GpuCounterGroup PRIMITIVES = GpuCounterGroup::PRIMITIVES;
+  static inline const GpuCounterGroup MEMORY = GpuCounterGroup::MEMORY;
+  static inline const GpuCounterGroup COMPUTE = GpuCounterGroup::COMPUTE;
+  static inline const GpuCounterGroup RAY_TRACING = GpuCounterGroup::RAY_TRACING;
+  static inline const MeasureUnit NONE = MeasureUnit::NONE;
+  static inline const MeasureUnit BIT = MeasureUnit::BIT;
+  static inline const MeasureUnit KILOBIT = MeasureUnit::KILOBIT;
+  static inline const MeasureUnit MEGABIT = MeasureUnit::MEGABIT;
+  static inline const MeasureUnit GIGABIT = MeasureUnit::GIGABIT;
+  static inline const MeasureUnit TERABIT = MeasureUnit::TERABIT;
+  static inline const MeasureUnit PETABIT = MeasureUnit::PETABIT;
+  static inline const MeasureUnit BYTE = MeasureUnit::BYTE;
+  static inline const MeasureUnit KILOBYTE = MeasureUnit::KILOBYTE;
+  static inline const MeasureUnit MEGABYTE = MeasureUnit::MEGABYTE;
+  static inline const MeasureUnit GIGABYTE = MeasureUnit::GIGABYTE;
+  static inline const MeasureUnit TERABYTE = MeasureUnit::TERABYTE;
+  static inline const MeasureUnit PETABYTE = MeasureUnit::PETABYTE;
+  static inline const MeasureUnit HERTZ = MeasureUnit::HERTZ;
+  static inline const MeasureUnit KILOHERTZ = MeasureUnit::KILOHERTZ;
+  static inline const MeasureUnit MEGAHERTZ = MeasureUnit::MEGAHERTZ;
+  static inline const MeasureUnit GIGAHERTZ = MeasureUnit::GIGAHERTZ;
+  static inline const MeasureUnit TERAHERTZ = MeasureUnit::TERAHERTZ;
+  static inline const MeasureUnit PETAHERTZ = MeasureUnit::PETAHERTZ;
+  static inline const MeasureUnit NANOSECOND = MeasureUnit::NANOSECOND;
+  static inline const MeasureUnit MICROSECOND = MeasureUnit::MICROSECOND;
+  static inline const MeasureUnit MILLISECOND = MeasureUnit::MILLISECOND;
+  static inline const MeasureUnit SECOND = MeasureUnit::SECOND;
+  static inline const MeasureUnit MINUTE = MeasureUnit::MINUTE;
+  static inline const MeasureUnit HOUR = MeasureUnit::HOUR;
+  static inline const MeasureUnit VERTEX = MeasureUnit::VERTEX;
+  static inline const MeasureUnit PIXEL = MeasureUnit::PIXEL;
+  static inline const MeasureUnit TRIANGLE = MeasureUnit::TRIANGLE;
+  static inline const MeasureUnit PRIMITIVE = MeasureUnit::PRIMITIVE;
+  static inline const MeasureUnit FRAGMENT = MeasureUnit::FRAGMENT;
+  static inline const MeasureUnit MILLIWATT = MeasureUnit::MILLIWATT;
+  static inline const MeasureUnit WATT = MeasureUnit::WATT;
+  static inline const MeasureUnit KILOWATT = MeasureUnit::KILOWATT;
+  static inline const MeasureUnit JOULE = MeasureUnit::JOULE;
+  static inline const MeasureUnit VOLT = MeasureUnit::VOLT;
+  static inline const MeasureUnit AMPERE = MeasureUnit::AMPERE;
+  static inline const MeasureUnit CELSIUS = MeasureUnit::CELSIUS;
+  static inline const MeasureUnit FAHRENHEIT = MeasureUnit::FAHRENHEIT;
+  static inline const MeasureUnit KELVIN = MeasureUnit::KELVIN;
+  static inline const MeasureUnit PERCENT = MeasureUnit::PERCENT;
+  static inline const MeasureUnit INSTRUCTION = MeasureUnit::INSTRUCTION;
 
   using FieldMetadata_Specs =
     ::protozero::proto_utils::FieldMetadata<
@@ -26963,14 +33096,7 @@ class GpuCounterDescriptor : public ::protozero::Message {
       GpuCounterDescriptor_GpuCounterSpec,
       GpuCounterDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Specs kSpecs() { return {}; }
+  static constexpr FieldMetadata_Specs kSpecs{};
   template <typename T = GpuCounterDescriptor_GpuCounterSpec> T* add_specs() {
     return BeginNestedMessage<T>(1);
   }
@@ -26984,14 +33110,7 @@ class GpuCounterDescriptor : public ::protozero::Message {
       GpuCounterDescriptor_GpuCounterBlock,
       GpuCounterDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Blocks kBlocks() { return {}; }
+  static constexpr FieldMetadata_Blocks kBlocks{};
   template <typename T = GpuCounterDescriptor_GpuCounterBlock> T* add_blocks() {
     return BeginNestedMessage<T>(2);
   }
@@ -27005,14 +33124,7 @@ class GpuCounterDescriptor : public ::protozero::Message {
       uint64_t,
       GpuCounterDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MinSamplingPeriodNs kMinSamplingPeriodNs() { return {}; }
+  static constexpr FieldMetadata_MinSamplingPeriodNs kMinSamplingPeriodNs{};
   void set_min_sampling_period_ns(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_MinSamplingPeriodNs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -27030,14 +33142,7 @@ class GpuCounterDescriptor : public ::protozero::Message {
       uint64_t,
       GpuCounterDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaxSamplingPeriodNs kMaxSamplingPeriodNs() { return {}; }
+  static constexpr FieldMetadata_MaxSamplingPeriodNs kMaxSamplingPeriodNs{};
   void set_max_sampling_period_ns(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_MaxSamplingPeriodNs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -27055,14 +33160,7 @@ class GpuCounterDescriptor : public ::protozero::Message {
       bool,
       GpuCounterDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SupportsInstrumentedSampling kSupportsInstrumentedSampling() { return {}; }
+  static constexpr FieldMetadata_SupportsInstrumentedSampling kSupportsInstrumentedSampling{};
   void set_supports_instrumented_sampling(bool value) {
     static constexpr uint32_t field_id = FieldMetadata_SupportsInstrumentedSampling::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -27073,7 +33171,7 @@ class GpuCounterDescriptor : public ::protozero::Message {
   }
 };
 
-class GpuCounterDescriptor_GpuCounterBlock_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class GpuCounterDescriptor_GpuCounterBlock_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
   GpuCounterDescriptor_GpuCounterBlock_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit GpuCounterDescriptor_GpuCounterBlock_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -27111,14 +33209,7 @@ class GpuCounterDescriptor_GpuCounterBlock : public ::protozero::Message {
       uint32_t,
       GpuCounterDescriptor_GpuCounterBlock>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockId kBlockId() { return {}; }
+  static constexpr FieldMetadata_BlockId kBlockId{};
   void set_block_id(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_BlockId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -27136,14 +33227,7 @@ class GpuCounterDescriptor_GpuCounterBlock : public ::protozero::Message {
       uint32_t,
       GpuCounterDescriptor_GpuCounterBlock>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockCapacity kBlockCapacity() { return {}; }
+  static constexpr FieldMetadata_BlockCapacity kBlockCapacity{};
   void set_block_capacity(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_BlockCapacity::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -27161,14 +33245,7 @@ class GpuCounterDescriptor_GpuCounterBlock : public ::protozero::Message {
       std::string,
       GpuCounterDescriptor_GpuCounterBlock>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -27192,14 +33269,7 @@ class GpuCounterDescriptor_GpuCounterBlock : public ::protozero::Message {
       std::string,
       GpuCounterDescriptor_GpuCounterBlock>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Description kDescription() { return {}; }
+  static constexpr FieldMetadata_Description kDescription{};
   void set_description(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Description::kFieldId, data, size);
   }
@@ -27223,14 +33293,7 @@ class GpuCounterDescriptor_GpuCounterBlock : public ::protozero::Message {
       uint32_t,
       GpuCounterDescriptor_GpuCounterBlock>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CounterIds kCounterIds() { return {}; }
+  static constexpr FieldMetadata_CounterIds kCounterIds{};
   void add_counter_ids(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_CounterIds::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -27241,7 +33304,7 @@ class GpuCounterDescriptor_GpuCounterBlock : public ::protozero::Message {
   }
 };
 
-class GpuCounterDescriptor_GpuCounterSpec_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class GpuCounterDescriptor_GpuCounterSpec_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10> {
  public:
   GpuCounterDescriptor_GpuCounterSpec_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit GpuCounterDescriptor_GpuCounterSpec_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -27291,14 +33354,7 @@ class GpuCounterDescriptor_GpuCounterSpec : public ::protozero::Message {
       uint32_t,
       GpuCounterDescriptor_GpuCounterSpec>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CounterId kCounterId() { return {}; }
+  static constexpr FieldMetadata_CounterId kCounterId{};
   void set_counter_id(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_CounterId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -27316,14 +33372,7 @@ class GpuCounterDescriptor_GpuCounterSpec : public ::protozero::Message {
       std::string,
       GpuCounterDescriptor_GpuCounterSpec>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -27347,14 +33396,7 @@ class GpuCounterDescriptor_GpuCounterSpec : public ::protozero::Message {
       std::string,
       GpuCounterDescriptor_GpuCounterSpec>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Description kDescription() { return {}; }
+  static constexpr FieldMetadata_Description kDescription{};
   void set_description(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Description::kFieldId, data, size);
   }
@@ -27378,14 +33420,7 @@ class GpuCounterDescriptor_GpuCounterSpec : public ::protozero::Message {
       int64_t,
       GpuCounterDescriptor_GpuCounterSpec>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IntPeakValue kIntPeakValue() { return {}; }
+  static constexpr FieldMetadata_IntPeakValue kIntPeakValue{};
   void set_int_peak_value(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_IntPeakValue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -27403,14 +33438,7 @@ class GpuCounterDescriptor_GpuCounterSpec : public ::protozero::Message {
       double,
       GpuCounterDescriptor_GpuCounterSpec>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DoublePeakValue kDoublePeakValue() { return {}; }
+  static constexpr FieldMetadata_DoublePeakValue kDoublePeakValue{};
   void set_double_peak_value(double value) {
     static constexpr uint32_t field_id = FieldMetadata_DoublePeakValue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -27425,18 +33453,11 @@ class GpuCounterDescriptor_GpuCounterSpec : public ::protozero::Message {
       7,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::GpuCounterDescriptor_MeasureUnit,
+      GpuCounterDescriptor_MeasureUnit,
       GpuCounterDescriptor_GpuCounterSpec>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NumeratorUnits kNumeratorUnits() { return {}; }
-  void add_numerator_units(::perfetto::protos::pbzero::GpuCounterDescriptor_MeasureUnit value) {
+  static constexpr FieldMetadata_NumeratorUnits kNumeratorUnits{};
+  void add_numerator_units(GpuCounterDescriptor_MeasureUnit value) {
     static constexpr uint32_t field_id = FieldMetadata_NumeratorUnits::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
@@ -27450,18 +33471,11 @@ class GpuCounterDescriptor_GpuCounterSpec : public ::protozero::Message {
       8,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::GpuCounterDescriptor_MeasureUnit,
+      GpuCounterDescriptor_MeasureUnit,
       GpuCounterDescriptor_GpuCounterSpec>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DenominatorUnits kDenominatorUnits() { return {}; }
-  void add_denominator_units(::perfetto::protos::pbzero::GpuCounterDescriptor_MeasureUnit value) {
+  static constexpr FieldMetadata_DenominatorUnits kDenominatorUnits{};
+  void add_denominator_units(GpuCounterDescriptor_MeasureUnit value) {
     static constexpr uint32_t field_id = FieldMetadata_DenominatorUnits::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
@@ -27478,14 +33492,7 @@ class GpuCounterDescriptor_GpuCounterSpec : public ::protozero::Message {
       bool,
       GpuCounterDescriptor_GpuCounterSpec>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SelectByDefault kSelectByDefault() { return {}; }
+  static constexpr FieldMetadata_SelectByDefault kSelectByDefault{};
   void set_select_by_default(bool value) {
     static constexpr uint32_t field_id = FieldMetadata_SelectByDefault::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -27500,18 +33507,11 @@ class GpuCounterDescriptor_GpuCounterSpec : public ::protozero::Message {
       10,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::GpuCounterDescriptor_GpuCounterGroup,
+      GpuCounterDescriptor_GpuCounterGroup,
       GpuCounterDescriptor_GpuCounterSpec>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Groups kGroups() { return {}; }
-  void add_groups(::perfetto::protos::pbzero::GpuCounterDescriptor_GpuCounterGroup value) {
+  static constexpr FieldMetadata_Groups kGroups{};
+  void add_groups(GpuCounterDescriptor_GpuCounterGroup value) {
     static constexpr uint32_t field_id = FieldMetadata_Groups::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
@@ -27540,12 +33540,12 @@ class GpuCounterDescriptor_GpuCounterSpec : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class InterceptorDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class InterceptorDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
   InterceptorDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit InterceptorDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -27571,14 +33571,7 @@ class InterceptorDescriptor : public ::protozero::Message {
       std::string,
       InterceptorDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -27617,25 +33610,33 @@ class InterceptorDescriptor : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
-
+class ObservableEvents_CloneTriggerHit;
 class ObservableEvents_DataSourceInstanceStateChange;
 namespace perfetto_pbzero_enum_ObservableEvents {
 enum DataSourceInstanceState : int32_t;
 }  // namespace perfetto_pbzero_enum_ObservableEvents
 using ObservableEvents_DataSourceInstanceState = perfetto_pbzero_enum_ObservableEvents::DataSourceInstanceState;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
 namespace perfetto_pbzero_enum_ObservableEvents {
 enum Type : int32_t {
   TYPE_UNSPECIFIED = 0,
   TYPE_DATA_SOURCES_INSTANCES = 1,
   TYPE_ALL_DATA_SOURCES_STARTED = 2,
+  TYPE_CLONE_TRIGGER_HIT = 4,
 };
 } // namespace perfetto_pbzero_enum_ObservableEvents
 using ObservableEvents_Type = perfetto_pbzero_enum_ObservableEvents::Type;
 
 
 constexpr ObservableEvents_Type ObservableEvents_Type_MIN = ObservableEvents_Type::TYPE_UNSPECIFIED;
-constexpr ObservableEvents_Type ObservableEvents_Type_MAX = ObservableEvents_Type::TYPE_ALL_DATA_SOURCES_STARTED;
+constexpr ObservableEvents_Type ObservableEvents_Type_MAX = ObservableEvents_Type::TYPE_CLONE_TRIGGER_HIT;
 
 
 PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
@@ -27649,6 +33650,9 @@ const char* ObservableEvents_Type_Name(::perfetto::protos::pbzero::ObservableEve
 
   case ::perfetto::protos::pbzero::ObservableEvents_Type::TYPE_ALL_DATA_SOURCES_STARTED:
     return "TYPE_ALL_DATA_SOURCES_STARTED";
+
+  case ::perfetto::protos::pbzero::ObservableEvents_Type::TYPE_CLONE_TRIGGER_HIT:
+    return "TYPE_CLONE_TRIGGER_HIT";
   }
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
@@ -27678,7 +33682,7 @@ const char* ObservableEvents_DataSourceInstanceState_Name(::perfetto::protos::pb
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-class ObservableEvents_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class ObservableEvents_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
   ObservableEvents_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit ObservableEvents_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -27687,6 +33691,8 @@ class ObservableEvents_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIE
   ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> instance_state_changes() const { return GetRepeated<::protozero::ConstBytes>(1); }
   bool has_all_data_sources_started() const { return at<2>().valid(); }
   bool all_data_sources_started() const { return at<2>().as_bool(); }
+  bool has_clone_trigger_hit() const { return at<3>().valid(); }
+  ::protozero::ConstBytes clone_trigger_hit() const { return at<3>().as_bytes(); }
 };
 
 class ObservableEvents : public ::protozero::Message {
@@ -27695,10 +33701,12 @@ class ObservableEvents : public ::protozero::Message {
   enum : int32_t {
     kInstanceStateChangesFieldNumber = 1,
     kAllDataSourcesStartedFieldNumber = 2,
+    kCloneTriggerHitFieldNumber = 3,
   };
   static constexpr const char* GetName() { return ".perfetto.protos.ObservableEvents"; }
 
   using DataSourceInstanceStateChange = ::perfetto::protos::pbzero::ObservableEvents_DataSourceInstanceStateChange;
+  using CloneTriggerHit = ::perfetto::protos::pbzero::ObservableEvents_CloneTriggerHit;
 
   using Type = ::perfetto::protos::pbzero::ObservableEvents_Type;
   static inline const char* Type_Name(Type value) {
@@ -27709,11 +33717,12 @@ class ObservableEvents : public ::protozero::Message {
   static inline const char* DataSourceInstanceState_Name(DataSourceInstanceState value) {
     return ::perfetto::protos::pbzero::ObservableEvents_DataSourceInstanceState_Name(value);
   }
-  static const Type TYPE_UNSPECIFIED = Type::TYPE_UNSPECIFIED;
-  static const Type TYPE_DATA_SOURCES_INSTANCES = Type::TYPE_DATA_SOURCES_INSTANCES;
-  static const Type TYPE_ALL_DATA_SOURCES_STARTED = Type::TYPE_ALL_DATA_SOURCES_STARTED;
-  static const DataSourceInstanceState DATA_SOURCE_INSTANCE_STATE_STOPPED = DataSourceInstanceState::DATA_SOURCE_INSTANCE_STATE_STOPPED;
-  static const DataSourceInstanceState DATA_SOURCE_INSTANCE_STATE_STARTED = DataSourceInstanceState::DATA_SOURCE_INSTANCE_STATE_STARTED;
+  static inline const Type TYPE_UNSPECIFIED = Type::TYPE_UNSPECIFIED;
+  static inline const Type TYPE_DATA_SOURCES_INSTANCES = Type::TYPE_DATA_SOURCES_INSTANCES;
+  static inline const Type TYPE_ALL_DATA_SOURCES_STARTED = Type::TYPE_ALL_DATA_SOURCES_STARTED;
+  static inline const Type TYPE_CLONE_TRIGGER_HIT = Type::TYPE_CLONE_TRIGGER_HIT;
+  static inline const DataSourceInstanceState DATA_SOURCE_INSTANCE_STATE_STOPPED = DataSourceInstanceState::DATA_SOURCE_INSTANCE_STATE_STOPPED;
+  static inline const DataSourceInstanceState DATA_SOURCE_INSTANCE_STATE_STARTED = DataSourceInstanceState::DATA_SOURCE_INSTANCE_STATE_STARTED;
 
   using FieldMetadata_InstanceStateChanges =
     ::protozero::proto_utils::FieldMetadata<
@@ -27723,14 +33732,7 @@ class ObservableEvents : public ::protozero::Message {
       ObservableEvents_DataSourceInstanceStateChange,
       ObservableEvents>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InstanceStateChanges kInstanceStateChanges() { return {}; }
+  static constexpr FieldMetadata_InstanceStateChanges kInstanceStateChanges{};
   template <typename T = ObservableEvents_DataSourceInstanceStateChange> T* add_instance_state_changes() {
     return BeginNestedMessage<T>(1);
   }
@@ -27744,14 +33746,7 @@ class ObservableEvents : public ::protozero::Message {
       bool,
       ObservableEvents>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AllDataSourcesStarted kAllDataSourcesStarted() { return {}; }
+  static constexpr FieldMetadata_AllDataSourcesStarted kAllDataSourcesStarted{};
   void set_all_data_sources_started(bool value) {
     static constexpr uint32_t field_id = FieldMetadata_AllDataSourcesStarted::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -27760,9 +33755,177 @@ class ObservableEvents : public ::protozero::Message {
       ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_CloneTriggerHit =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ObservableEvents_CloneTriggerHit,
+      ObservableEvents>;
+
+  static constexpr FieldMetadata_CloneTriggerHit kCloneTriggerHit{};
+  template <typename T = ObservableEvents_CloneTriggerHit> T* set_clone_trigger_hit() {
+    return BeginNestedMessage<T>(3);
+  }
+
+};
+
+class ObservableEvents_CloneTriggerHit_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
+ public:
+  ObservableEvents_CloneTriggerHit_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ObservableEvents_CloneTriggerHit_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ObservableEvents_CloneTriggerHit_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_tracing_session_id() const { return at<1>().valid(); }
+  int64_t tracing_session_id() const { return at<1>().as_int64(); }
+  bool has_trigger_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars trigger_name() const { return at<2>().as_string(); }
+  bool has_producer_name() const { return at<3>().valid(); }
+  ::protozero::ConstChars producer_name() const { return at<3>().as_string(); }
+  bool has_producer_uid() const { return at<4>().valid(); }
+  uint32_t producer_uid() const { return at<4>().as_uint32(); }
+  bool has_boot_time_ns() const { return at<5>().valid(); }
+  uint64_t boot_time_ns() const { return at<5>().as_uint64(); }
+  bool has_trigger_delay_ms() const { return at<6>().valid(); }
+  uint64_t trigger_delay_ms() const { return at<6>().as_uint64(); }
+};
+
+class ObservableEvents_CloneTriggerHit : public ::protozero::Message {
+ public:
+  using Decoder = ObservableEvents_CloneTriggerHit_Decoder;
+  enum : int32_t {
+    kTracingSessionIdFieldNumber = 1,
+    kTriggerNameFieldNumber = 2,
+    kProducerNameFieldNumber = 3,
+    kProducerUidFieldNumber = 4,
+    kBootTimeNsFieldNumber = 5,
+    kTriggerDelayMsFieldNumber = 6,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ObservableEvents.CloneTriggerHit"; }
+
+
+  using FieldMetadata_TracingSessionId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ObservableEvents_CloneTriggerHit>;
+
+  static constexpr FieldMetadata_TracingSessionId kTracingSessionId{};
+  void set_tracing_session_id(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TracingSessionId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TriggerName =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ObservableEvents_CloneTriggerHit>;
+
+  static constexpr FieldMetadata_TriggerName kTriggerName{};
+  void set_trigger_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_TriggerName::kFieldId, data, size);
+  }
+  void set_trigger_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_TriggerName::kFieldId, chars.data, chars.size);
+  }
+  void set_trigger_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_TriggerName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ProducerName =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ObservableEvents_CloneTriggerHit>;
+
+  static constexpr FieldMetadata_ProducerName kProducerName{};
+  void set_producer_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ProducerName::kFieldId, data, size);
+  }
+  void set_producer_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ProducerName::kFieldId, chars.data, chars.size);
+  }
+  void set_producer_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProducerName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ProducerUid =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ObservableEvents_CloneTriggerHit>;
+
+  static constexpr FieldMetadata_ProducerUid kProducerUid{};
+  void set_producer_uid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProducerUid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BootTimeNs =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ObservableEvents_CloneTriggerHit>;
+
+  static constexpr FieldMetadata_BootTimeNs kBootTimeNs{};
+  void set_boot_time_ns(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BootTimeNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TriggerDelayMs =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ObservableEvents_CloneTriggerHit>;
+
+  static constexpr FieldMetadata_TriggerDelayMs kTriggerDelayMs{};
+  void set_trigger_delay_ms(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TriggerDelayMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class ObservableEvents_DataSourceInstanceStateChange_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class ObservableEvents_DataSourceInstanceStateChange_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
   ObservableEvents_DataSourceInstanceStateChange_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit ObservableEvents_DataSourceInstanceStateChange_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -27794,14 +33957,7 @@ class ObservableEvents_DataSourceInstanceStateChange : public ::protozero::Messa
       std::string,
       ObservableEvents_DataSourceInstanceStateChange>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProducerName kProducerName() { return {}; }
+  static constexpr FieldMetadata_ProducerName kProducerName{};
   void set_producer_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_ProducerName::kFieldId, data, size);
   }
@@ -27825,14 +33981,7 @@ class ObservableEvents_DataSourceInstanceStateChange : public ::protozero::Messa
       std::string,
       ObservableEvents_DataSourceInstanceStateChange>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DataSourceName kDataSourceName() { return {}; }
+  static constexpr FieldMetadata_DataSourceName kDataSourceName{};
   void set_data_source_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_DataSourceName::kFieldId, data, size);
   }
@@ -27853,18 +34002,11 @@ class ObservableEvents_DataSourceInstanceStateChange : public ::protozero::Messa
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ObservableEvents_DataSourceInstanceState,
+      ObservableEvents_DataSourceInstanceState,
       ObservableEvents_DataSourceInstanceStateChange>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_State kState() { return {}; }
-  void set_state(::perfetto::protos::pbzero::ObservableEvents_DataSourceInstanceState value) {
+  static constexpr FieldMetadata_State kState{};
+  void set_state(ObservableEvents_DataSourceInstanceState value) {
     static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
@@ -27896,7 +34038,6 @@ class ObservableEvents_DataSourceInstanceStateChange : public ::protozero::Messa
 namespace perfetto {
 namespace protos {
 namespace pbzero {
-
 class PerfEvents_RawEvent;
 class PerfEvents_Timebase;
 class PerfEvents_Tracepoint;
@@ -27905,9 +34046,20 @@ enum Counter : int32_t;
 }  // namespace perfetto_pbzero_enum_PerfEvents
 using PerfEvents_Counter = perfetto_pbzero_enum_PerfEvents::Counter;
 namespace perfetto_pbzero_enum_PerfEvents {
+enum EventModifier : int32_t;
+}  // namespace perfetto_pbzero_enum_PerfEvents
+using PerfEvents_EventModifier = perfetto_pbzero_enum_PerfEvents::EventModifier;
+namespace perfetto_pbzero_enum_PerfEvents {
 enum PerfClock : int32_t;
 }  // namespace perfetto_pbzero_enum_PerfEvents
 using PerfEvents_PerfClock = perfetto_pbzero_enum_PerfEvents::PerfClock;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
 namespace perfetto_pbzero_enum_PerfEvents {
 enum Counter : int32_t {
@@ -28047,7 +34199,159 @@ const char* PerfEvents_PerfClock_Name(::perfetto::protos::pbzero::PerfEvents_Per
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-class PerfEvents_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+namespace perfetto_pbzero_enum_PerfEvents {
+enum EventModifier : int32_t {
+  UNKNOWN_EVENT_MODIFIER = 0,
+  EVENT_MODIFIER_COUNT_USERSPACE = 1,
+  EVENT_MODIFIER_COUNT_KERNEL = 2,
+  EVENT_MODIFIER_COUNT_HYPERVISOR = 3,
+};
+} // namespace perfetto_pbzero_enum_PerfEvents
+using PerfEvents_EventModifier = perfetto_pbzero_enum_PerfEvents::EventModifier;
+
+
+constexpr PerfEvents_EventModifier PerfEvents_EventModifier_MIN = PerfEvents_EventModifier::UNKNOWN_EVENT_MODIFIER;
+constexpr PerfEvents_EventModifier PerfEvents_EventModifier_MAX = PerfEvents_EventModifier::EVENT_MODIFIER_COUNT_HYPERVISOR;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* PerfEvents_EventModifier_Name(::perfetto::protos::pbzero::PerfEvents_EventModifier value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::PerfEvents_EventModifier::UNKNOWN_EVENT_MODIFIER:
+    return "UNKNOWN_EVENT_MODIFIER";
+
+  case ::perfetto::protos::pbzero::PerfEvents_EventModifier::EVENT_MODIFIER_COUNT_USERSPACE:
+    return "EVENT_MODIFIER_COUNT_USERSPACE";
+
+  case ::perfetto::protos::pbzero::PerfEvents_EventModifier::EVENT_MODIFIER_COUNT_KERNEL:
+    return "EVENT_MODIFIER_COUNT_KERNEL";
+
+  case ::perfetto::protos::pbzero::PerfEvents_EventModifier::EVENT_MODIFIER_COUNT_HYPERVISOR:
+    return "EVENT_MODIFIER_COUNT_HYPERVISOR";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class FollowerEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  FollowerEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FollowerEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FollowerEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_counter() const { return at<1>().valid(); }
+  int32_t counter() const { return at<1>().as_int32(); }
+  bool has_tracepoint() const { return at<2>().valid(); }
+  ::protozero::ConstBytes tracepoint() const { return at<2>().as_bytes(); }
+  bool has_raw_event() const { return at<3>().valid(); }
+  ::protozero::ConstBytes raw_event() const { return at<3>().as_bytes(); }
+  bool has_modifiers() const { return at<5>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> modifiers() const { return GetRepeated<int32_t>(5); }
+  bool has_name() const { return at<4>().valid(); }
+  ::protozero::ConstChars name() const { return at<4>().as_string(); }
+};
+
+class FollowerEvent : public ::protozero::Message {
+ public:
+  using Decoder = FollowerEvent_Decoder;
+  enum : int32_t {
+    kCounterFieldNumber = 1,
+    kTracepointFieldNumber = 2,
+    kRawEventFieldNumber = 3,
+    kModifiersFieldNumber = 5,
+    kNameFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FollowerEvent"; }
+
+
+  using FieldMetadata_Counter =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      PerfEvents_Counter,
+      FollowerEvent>;
+
+  static constexpr FieldMetadata_Counter kCounter{};
+  void set_counter(PerfEvents_Counter value) {
+    static constexpr uint32_t field_id = FieldMetadata_Counter::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Tracepoint =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PerfEvents_Tracepoint,
+      FollowerEvent>;
+
+  static constexpr FieldMetadata_Tracepoint kTracepoint{};
+  template <typename T = PerfEvents_Tracepoint> T* set_tracepoint() {
+    return BeginNestedMessage<T>(2);
+  }
+
+
+  using FieldMetadata_RawEvent =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PerfEvents_RawEvent,
+      FollowerEvent>;
+
+  static constexpr FieldMetadata_RawEvent kRawEvent{};
+  template <typename T = PerfEvents_RawEvent> T* set_raw_event() {
+    return BeginNestedMessage<T>(3);
+  }
+
+
+  using FieldMetadata_Modifiers =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      PerfEvents_EventModifier,
+      FollowerEvent>;
+
+  static constexpr FieldMetadata_Modifiers kModifiers{};
+  void add_modifiers(PerfEvents_EventModifier value) {
+    static constexpr uint32_t field_id = FieldMetadata_Modifiers::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FollowerEvent>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class PerfEvents_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0> {
  public:
   PerfEvents_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit PerfEvents_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -28072,35 +34376,44 @@ class PerfEvents : public ::protozero::Message {
   static inline const char* PerfClock_Name(PerfClock value) {
     return ::perfetto::protos::pbzero::PerfEvents_PerfClock_Name(value);
   }
-  static const Counter UNKNOWN_COUNTER = Counter::UNKNOWN_COUNTER;
-  static const Counter SW_CPU_CLOCK = Counter::SW_CPU_CLOCK;
-  static const Counter SW_PAGE_FAULTS = Counter::SW_PAGE_FAULTS;
-  static const Counter SW_TASK_CLOCK = Counter::SW_TASK_CLOCK;
-  static const Counter SW_CONTEXT_SWITCHES = Counter::SW_CONTEXT_SWITCHES;
-  static const Counter SW_CPU_MIGRATIONS = Counter::SW_CPU_MIGRATIONS;
-  static const Counter SW_PAGE_FAULTS_MIN = Counter::SW_PAGE_FAULTS_MIN;
-  static const Counter SW_PAGE_FAULTS_MAJ = Counter::SW_PAGE_FAULTS_MAJ;
-  static const Counter SW_ALIGNMENT_FAULTS = Counter::SW_ALIGNMENT_FAULTS;
-  static const Counter SW_EMULATION_FAULTS = Counter::SW_EMULATION_FAULTS;
-  static const Counter SW_DUMMY = Counter::SW_DUMMY;
-  static const Counter HW_CPU_CYCLES = Counter::HW_CPU_CYCLES;
-  static const Counter HW_INSTRUCTIONS = Counter::HW_INSTRUCTIONS;
-  static const Counter HW_CACHE_REFERENCES = Counter::HW_CACHE_REFERENCES;
-  static const Counter HW_CACHE_MISSES = Counter::HW_CACHE_MISSES;
-  static const Counter HW_BRANCH_INSTRUCTIONS = Counter::HW_BRANCH_INSTRUCTIONS;
-  static const Counter HW_BRANCH_MISSES = Counter::HW_BRANCH_MISSES;
-  static const Counter HW_BUS_CYCLES = Counter::HW_BUS_CYCLES;
-  static const Counter HW_STALLED_CYCLES_FRONTEND = Counter::HW_STALLED_CYCLES_FRONTEND;
-  static const Counter HW_STALLED_CYCLES_BACKEND = Counter::HW_STALLED_CYCLES_BACKEND;
-  static const Counter HW_REF_CPU_CYCLES = Counter::HW_REF_CPU_CYCLES;
-  static const PerfClock UNKNOWN_PERF_CLOCK = PerfClock::UNKNOWN_PERF_CLOCK;
-  static const PerfClock PERF_CLOCK_REALTIME = PerfClock::PERF_CLOCK_REALTIME;
-  static const PerfClock PERF_CLOCK_MONOTONIC = PerfClock::PERF_CLOCK_MONOTONIC;
-  static const PerfClock PERF_CLOCK_MONOTONIC_RAW = PerfClock::PERF_CLOCK_MONOTONIC_RAW;
-  static const PerfClock PERF_CLOCK_BOOTTIME = PerfClock::PERF_CLOCK_BOOTTIME;
-};
-
-class PerfEvents_RawEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+
+  using EventModifier = ::perfetto::protos::pbzero::PerfEvents_EventModifier;
+  static inline const char* EventModifier_Name(EventModifier value) {
+    return ::perfetto::protos::pbzero::PerfEvents_EventModifier_Name(value);
+  }
+  static inline const Counter UNKNOWN_COUNTER = Counter::UNKNOWN_COUNTER;
+  static inline const Counter SW_CPU_CLOCK = Counter::SW_CPU_CLOCK;
+  static inline const Counter SW_PAGE_FAULTS = Counter::SW_PAGE_FAULTS;
+  static inline const Counter SW_TASK_CLOCK = Counter::SW_TASK_CLOCK;
+  static inline const Counter SW_CONTEXT_SWITCHES = Counter::SW_CONTEXT_SWITCHES;
+  static inline const Counter SW_CPU_MIGRATIONS = Counter::SW_CPU_MIGRATIONS;
+  static inline const Counter SW_PAGE_FAULTS_MIN = Counter::SW_PAGE_FAULTS_MIN;
+  static inline const Counter SW_PAGE_FAULTS_MAJ = Counter::SW_PAGE_FAULTS_MAJ;
+  static inline const Counter SW_ALIGNMENT_FAULTS = Counter::SW_ALIGNMENT_FAULTS;
+  static inline const Counter SW_EMULATION_FAULTS = Counter::SW_EMULATION_FAULTS;
+  static inline const Counter SW_DUMMY = Counter::SW_DUMMY;
+  static inline const Counter HW_CPU_CYCLES = Counter::HW_CPU_CYCLES;
+  static inline const Counter HW_INSTRUCTIONS = Counter::HW_INSTRUCTIONS;
+  static inline const Counter HW_CACHE_REFERENCES = Counter::HW_CACHE_REFERENCES;
+  static inline const Counter HW_CACHE_MISSES = Counter::HW_CACHE_MISSES;
+  static inline const Counter HW_BRANCH_INSTRUCTIONS = Counter::HW_BRANCH_INSTRUCTIONS;
+  static inline const Counter HW_BRANCH_MISSES = Counter::HW_BRANCH_MISSES;
+  static inline const Counter HW_BUS_CYCLES = Counter::HW_BUS_CYCLES;
+  static inline const Counter HW_STALLED_CYCLES_FRONTEND = Counter::HW_STALLED_CYCLES_FRONTEND;
+  static inline const Counter HW_STALLED_CYCLES_BACKEND = Counter::HW_STALLED_CYCLES_BACKEND;
+  static inline const Counter HW_REF_CPU_CYCLES = Counter::HW_REF_CPU_CYCLES;
+  static inline const PerfClock UNKNOWN_PERF_CLOCK = PerfClock::UNKNOWN_PERF_CLOCK;
+  static inline const PerfClock PERF_CLOCK_REALTIME = PerfClock::PERF_CLOCK_REALTIME;
+  static inline const PerfClock PERF_CLOCK_MONOTONIC = PerfClock::PERF_CLOCK_MONOTONIC;
+  static inline const PerfClock PERF_CLOCK_MONOTONIC_RAW = PerfClock::PERF_CLOCK_MONOTONIC_RAW;
+  static inline const PerfClock PERF_CLOCK_BOOTTIME = PerfClock::PERF_CLOCK_BOOTTIME;
+  static inline const EventModifier UNKNOWN_EVENT_MODIFIER = EventModifier::UNKNOWN_EVENT_MODIFIER;
+  static inline const EventModifier EVENT_MODIFIER_COUNT_USERSPACE = EventModifier::EVENT_MODIFIER_COUNT_USERSPACE;
+  static inline const EventModifier EVENT_MODIFIER_COUNT_KERNEL = EventModifier::EVENT_MODIFIER_COUNT_KERNEL;
+  static inline const EventModifier EVENT_MODIFIER_COUNT_HYPERVISOR = EventModifier::EVENT_MODIFIER_COUNT_HYPERVISOR;
+};
+
+class PerfEvents_RawEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
   PerfEvents_RawEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit PerfEvents_RawEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -28135,14 +34448,7 @@ class PerfEvents_RawEvent : public ::protozero::Message {
       uint32_t,
       PerfEvents_RawEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
+  static constexpr FieldMetadata_Type kType{};
   void set_type(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -28160,14 +34466,7 @@ class PerfEvents_RawEvent : public ::protozero::Message {
       uint64_t,
       PerfEvents_RawEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Config kConfig() { return {}; }
+  static constexpr FieldMetadata_Config kConfig{};
   void set_config(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Config::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -28185,14 +34484,7 @@ class PerfEvents_RawEvent : public ::protozero::Message {
       uint64_t,
       PerfEvents_RawEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Config1 kConfig1() { return {}; }
+  static constexpr FieldMetadata_Config1 kConfig1{};
   void set_config1(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Config1::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -28210,14 +34502,7 @@ class PerfEvents_RawEvent : public ::protozero::Message {
       uint64_t,
       PerfEvents_RawEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Config2 kConfig2() { return {}; }
+  static constexpr FieldMetadata_Config2 kConfig2{};
   void set_config2(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Config2::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -28228,7 +34513,7 @@ class PerfEvents_RawEvent : public ::protozero::Message {
   }
 };
 
-class PerfEvents_Tracepoint_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class PerfEvents_Tracepoint_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
   PerfEvents_Tracepoint_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit PerfEvents_Tracepoint_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -28257,14 +34542,7 @@ class PerfEvents_Tracepoint : public ::protozero::Message {
       std::string,
       PerfEvents_Tracepoint>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -28288,14 +34566,7 @@ class PerfEvents_Tracepoint : public ::protozero::Message {
       std::string,
       PerfEvents_Tracepoint>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Filter kFilter() { return {}; }
+  static constexpr FieldMetadata_Filter kFilter{};
   void set_filter(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Filter::kFieldId, data, size);
   }
@@ -28312,7 +34583,7 @@ class PerfEvents_Tracepoint : public ::protozero::Message {
   }
 };
 
-class PerfEvents_Timebase_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class PerfEvents_Timebase_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/12> {
  public:
   PerfEvents_Timebase_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit PerfEvents_Timebase_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -28321,12 +34592,16 @@ class PerfEvents_Timebase_Decoder : public ::protozero::TypedProtoDecoder</*MAX_
   uint64_t frequency() const { return at<2>().as_uint64(); }
   bool has_period() const { return at<1>().valid(); }
   uint64_t period() const { return at<1>().as_uint64(); }
+  bool has_poll_period_ms() const { return at<6>().valid(); }
+  uint32_t poll_period_ms() const { return at<6>().as_uint32(); }
   bool has_counter() const { return at<4>().valid(); }
   int32_t counter() const { return at<4>().as_int32(); }
   bool has_tracepoint() const { return at<3>().valid(); }
   ::protozero::ConstBytes tracepoint() const { return at<3>().as_bytes(); }
   bool has_raw_event() const { return at<5>().valid(); }
   ::protozero::ConstBytes raw_event() const { return at<5>().as_bytes(); }
+  bool has_modifiers() const { return at<12>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> modifiers() const { return GetRepeated<int32_t>(12); }
   bool has_timestamp_clock() const { return at<11>().valid(); }
   int32_t timestamp_clock() const { return at<11>().as_int32(); }
   bool has_name() const { return at<10>().valid(); }
@@ -28339,9 +34614,11 @@ class PerfEvents_Timebase : public ::protozero::Message {
   enum : int32_t {
     kFrequencyFieldNumber = 2,
     kPeriodFieldNumber = 1,
+    kPollPeriodMsFieldNumber = 6,
     kCounterFieldNumber = 4,
     kTracepointFieldNumber = 3,
     kRawEventFieldNumber = 5,
+    kModifiersFieldNumber = 12,
     kTimestampClockFieldNumber = 11,
     kNameFieldNumber = 10,
   };
@@ -28356,14 +34633,7 @@ class PerfEvents_Timebase : public ::protozero::Message {
       uint64_t,
       PerfEvents_Timebase>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Frequency kFrequency() { return {}; }
+  static constexpr FieldMetadata_Frequency kFrequency{};
   void set_frequency(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Frequency::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -28381,14 +34651,7 @@ class PerfEvents_Timebase : public ::protozero::Message {
       uint64_t,
       PerfEvents_Timebase>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Period kPeriod() { return {}; }
+  static constexpr FieldMetadata_Period kPeriod{};
   void set_period(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Period::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -28398,23 +34661,34 @@ class PerfEvents_Timebase : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
+  using FieldMetadata_PollPeriodMs =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      PerfEvents_Timebase>;
+
+  static constexpr FieldMetadata_PollPeriodMs kPollPeriodMs{};
+  void set_poll_period_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PollPeriodMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
   using FieldMetadata_Counter =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::PerfEvents_Counter,
+      PerfEvents_Counter,
       PerfEvents_Timebase>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Counter kCounter() { return {}; }
-  void set_counter(::perfetto::protos::pbzero::PerfEvents_Counter value) {
+  static constexpr FieldMetadata_Counter kCounter{};
+  void set_counter(PerfEvents_Counter value) {
     static constexpr uint32_t field_id = FieldMetadata_Counter::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
@@ -28431,14 +34705,7 @@ class PerfEvents_Timebase : public ::protozero::Message {
       PerfEvents_Tracepoint,
       PerfEvents_Timebase>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Tracepoint kTracepoint() { return {}; }
+  static constexpr FieldMetadata_Tracepoint kTracepoint{};
   template <typename T = PerfEvents_Tracepoint> T* set_tracepoint() {
     return BeginNestedMessage<T>(3);
   }
@@ -28452,36 +34719,40 @@ class PerfEvents_Timebase : public ::protozero::Message {
       PerfEvents_RawEvent,
       PerfEvents_Timebase>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RawEvent kRawEvent() { return {}; }
+  static constexpr FieldMetadata_RawEvent kRawEvent{};
   template <typename T = PerfEvents_RawEvent> T* set_raw_event() {
     return BeginNestedMessage<T>(5);
   }
 
 
+  using FieldMetadata_Modifiers =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      PerfEvents_EventModifier,
+      PerfEvents_Timebase>;
+
+  static constexpr FieldMetadata_Modifiers kModifiers{};
+  void add_modifiers(PerfEvents_EventModifier value) {
+    static constexpr uint32_t field_id = FieldMetadata_Modifiers::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
   using FieldMetadata_TimestampClock =
     ::protozero::proto_utils::FieldMetadata<
       11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::PerfEvents_PerfClock,
+      PerfEvents_PerfClock,
       PerfEvents_Timebase>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimestampClock kTimestampClock() { return {}; }
-  void set_timestamp_clock(::perfetto::protos::pbzero::PerfEvents_PerfClock value) {
+  static constexpr FieldMetadata_TimestampClock kTimestampClock{};
+  void set_timestamp_clock(PerfEvents_PerfClock value) {
     static constexpr uint32_t field_id = FieldMetadata_TimestampClock::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
@@ -28498,14 +34769,7 @@ class PerfEvents_Timebase : public ::protozero::Message {
       std::string,
       PerfEvents_Timebase>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -28522,6 +34786,71 @@ class PerfEvents_Timebase : public ::protozero::Message {
   }
 };
 
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/common/protolog_common.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_PROTOLOG_COMMON_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_PROTOLOG_COMMON_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+enum ProtoLogLevel : int32_t {
+  PROTOLOG_LEVEL_UNDEFINED = 0,
+  PROTOLOG_LEVEL_DEBUG = 1,
+  PROTOLOG_LEVEL_VERBOSE = 2,
+  PROTOLOG_LEVEL_INFO = 3,
+  PROTOLOG_LEVEL_WARN = 4,
+  PROTOLOG_LEVEL_ERROR = 5,
+  PROTOLOG_LEVEL_WTF = 6,
+};
+
+constexpr ProtoLogLevel ProtoLogLevel_MIN = ProtoLogLevel::PROTOLOG_LEVEL_UNDEFINED;
+constexpr ProtoLogLevel ProtoLogLevel_MAX = ProtoLogLevel::PROTOLOG_LEVEL_WTF;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ProtoLogLevel_Name(::perfetto::protos::pbzero::ProtoLogLevel value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ProtoLogLevel::PROTOLOG_LEVEL_UNDEFINED:
+    return "PROTOLOG_LEVEL_UNDEFINED";
+
+  case ::perfetto::protos::pbzero::ProtoLogLevel::PROTOLOG_LEVEL_DEBUG:
+    return "PROTOLOG_LEVEL_DEBUG";
+
+  case ::perfetto::protos::pbzero::ProtoLogLevel::PROTOLOG_LEVEL_VERBOSE:
+    return "PROTOLOG_LEVEL_VERBOSE";
+
+  case ::perfetto::protos::pbzero::ProtoLogLevel::PROTOLOG_LEVEL_INFO:
+    return "PROTOLOG_LEVEL_INFO";
+
+  case ::perfetto::protos::pbzero::ProtoLogLevel::PROTOLOG_LEVEL_WARN:
+    return "PROTOLOG_LEVEL_WARN";
+
+  case ::perfetto::protos::pbzero::ProtoLogLevel::PROTOLOG_LEVEL_ERROR:
+    return "PROTOLOG_LEVEL_ERROR";
+
+  case ::perfetto::protos::pbzero::ProtoLogLevel::PROTOLOG_LEVEL_WTF:
+    return "PROTOLOG_LEVEL_WTF";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
 } // Namespace.
 } // Namespace.
 } // Namespace.
@@ -28541,11 +34870,11 @@ class PerfEvents_Timebase : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
 enum MeminfoCounters : int32_t {
   MEMINFO_UNSPECIFIED = 0,
   MEMINFO_MEM_TOTAL = 1,
@@ -28581,10 +34910,15 @@ enum MeminfoCounters : int32_t {
   MEMINFO_VMALLOC_CHUNK = 31,
   MEMINFO_CMA_TOTAL = 32,
   MEMINFO_CMA_FREE = 33,
+  MEMINFO_GPU = 34,
+  MEMINFO_ZRAM = 35,
+  MEMINFO_MISC = 36,
+  MEMINFO_ION_HEAP = 37,
+  MEMINFO_ION_HEAP_POOL = 38,
 };
 
 constexpr MeminfoCounters MeminfoCounters_MIN = MeminfoCounters::MEMINFO_UNSPECIFIED;
-constexpr MeminfoCounters MeminfoCounters_MAX = MeminfoCounters::MEMINFO_CMA_FREE;
+constexpr MeminfoCounters MeminfoCounters_MAX = MeminfoCounters::MEMINFO_ION_HEAP_POOL;
 
 
 PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
@@ -28691,6 +35025,21 @@ const char* MeminfoCounters_Name(::perfetto::protos::pbzero::MeminfoCounters val
 
   case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_CMA_FREE:
     return "MEMINFO_CMA_FREE";
+
+  case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_GPU:
+    return "MEMINFO_GPU";
+
+  case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_ZRAM:
+    return "MEMINFO_ZRAM";
+
+  case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_MISC:
+    return "MEMINFO_MISC";
+
+  case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_ION_HEAP:
+    return "MEMINFO_ION_HEAP";
+
+  case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_ION_HEAP_POOL:
+    return "MEMINFO_ION_HEAP_POOL";
   }
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
@@ -28825,10 +35174,70 @@ enum VmstatCounters : int32_t {
   VMSTAT_SWAP_RA = 126,
   VMSTAT_SWAP_RA_HIT = 127,
   VMSTAT_WORKINGSET_RESTORE = 128,
+  VMSTAT_ALLOCSTALL_DEVICE = 129,
+  VMSTAT_ALLOCSTALL_DMA32 = 130,
+  VMSTAT_BALLOON_DEFLATE = 131,
+  VMSTAT_BALLOON_INFLATE = 132,
+  VMSTAT_BALLOON_MIGRATE = 133,
+  VMSTAT_CMA_ALLOC_FAIL = 134,
+  VMSTAT_CMA_ALLOC_SUCCESS = 135,
+  VMSTAT_NR_FILE_HUGEPAGES = 136,
+  VMSTAT_NR_FILE_PMDMAPPED = 137,
+  VMSTAT_NR_FOLL_PIN_ACQUIRED = 138,
+  VMSTAT_NR_FOLL_PIN_RELEASED = 139,
+  VMSTAT_NR_SEC_PAGE_TABLE_PAGES = 140,
+  VMSTAT_NR_SHADOW_CALL_STACK = 141,
+  VMSTAT_NR_SWAPCACHED = 142,
+  VMSTAT_NR_THROTTLED_WRITTEN = 143,
+  VMSTAT_PGALLOC_DEVICE = 144,
+  VMSTAT_PGALLOC_DMA32 = 145,
+  VMSTAT_PGDEMOTE_DIRECT = 146,
+  VMSTAT_PGDEMOTE_KSWAPD = 147,
+  VMSTAT_PGREUSE = 148,
+  VMSTAT_PGSCAN_ANON = 149,
+  VMSTAT_PGSCAN_FILE = 150,
+  VMSTAT_PGSKIP_DEVICE = 151,
+  VMSTAT_PGSKIP_DMA32 = 152,
+  VMSTAT_PGSTEAL_ANON = 153,
+  VMSTAT_PGSTEAL_FILE = 154,
+  VMSTAT_THP_COLLAPSE_ALLOC = 155,
+  VMSTAT_THP_COLLAPSE_ALLOC_FAILED = 156,
+  VMSTAT_THP_DEFERRED_SPLIT_PAGE = 157,
+  VMSTAT_THP_FAULT_ALLOC = 158,
+  VMSTAT_THP_FAULT_FALLBACK = 159,
+  VMSTAT_THP_FAULT_FALLBACK_CHARGE = 160,
+  VMSTAT_THP_FILE_ALLOC = 161,
+  VMSTAT_THP_FILE_FALLBACK = 162,
+  VMSTAT_THP_FILE_FALLBACK_CHARGE = 163,
+  VMSTAT_THP_FILE_MAPPED = 164,
+  VMSTAT_THP_MIGRATION_FAIL = 165,
+  VMSTAT_THP_MIGRATION_SPLIT = 166,
+  VMSTAT_THP_MIGRATION_SUCCESS = 167,
+  VMSTAT_THP_SCAN_EXCEED_NONE_PTE = 168,
+  VMSTAT_THP_SCAN_EXCEED_SHARE_PTE = 169,
+  VMSTAT_THP_SCAN_EXCEED_SWAP_PTE = 170,
+  VMSTAT_THP_SPLIT_PAGE = 171,
+  VMSTAT_THP_SPLIT_PAGE_FAILED = 172,
+  VMSTAT_THP_SPLIT_PMD = 173,
+  VMSTAT_THP_SWPOUT = 174,
+  VMSTAT_THP_SWPOUT_FALLBACK = 175,
+  VMSTAT_THP_ZERO_PAGE_ALLOC = 176,
+  VMSTAT_THP_ZERO_PAGE_ALLOC_FAILED = 177,
+  VMSTAT_VMA_LOCK_ABORT = 178,
+  VMSTAT_VMA_LOCK_MISS = 179,
+  VMSTAT_VMA_LOCK_RETRY = 180,
+  VMSTAT_VMA_LOCK_SUCCESS = 181,
+  VMSTAT_WORKINGSET_ACTIVATE_ANON = 182,
+  VMSTAT_WORKINGSET_ACTIVATE_FILE = 183,
+  VMSTAT_WORKINGSET_NODES = 184,
+  VMSTAT_WORKINGSET_REFAULT_ANON = 185,
+  VMSTAT_WORKINGSET_REFAULT_FILE = 186,
+  VMSTAT_WORKINGSET_RESTORE_ANON = 187,
+  VMSTAT_WORKINGSET_RESTORE_FILE = 188,
 };
 
 constexpr VmstatCounters VmstatCounters_MIN = VmstatCounters::VMSTAT_UNSPECIFIED;
-constexpr VmstatCounters VmstatCounters_MAX = VmstatCounters::VMSTAT_WORKINGSET_RESTORE;
+constexpr VmstatCounters VmstatCounters_MAX = VmstatCounters::VMSTAT_WORKINGSET_RESTORE_FILE;
 
 
 PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
@@ -29220,10 +35629,747 @@ const char* VmstatCounters_Name(::perfetto::protos::pbzero::VmstatCounters value
 
   case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_WORKINGSET_RESTORE:
     return "VMSTAT_WORKINGSET_RESTORE";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_ALLOCSTALL_DEVICE:
+    return "VMSTAT_ALLOCSTALL_DEVICE";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_ALLOCSTALL_DMA32:
+    return "VMSTAT_ALLOCSTALL_DMA32";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_BALLOON_DEFLATE:
+    return "VMSTAT_BALLOON_DEFLATE";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_BALLOON_INFLATE:
+    return "VMSTAT_BALLOON_INFLATE";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_BALLOON_MIGRATE:
+    return "VMSTAT_BALLOON_MIGRATE";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_CMA_ALLOC_FAIL:
+    return "VMSTAT_CMA_ALLOC_FAIL";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_CMA_ALLOC_SUCCESS:
+    return "VMSTAT_CMA_ALLOC_SUCCESS";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_FILE_HUGEPAGES:
+    return "VMSTAT_NR_FILE_HUGEPAGES";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_FILE_PMDMAPPED:
+    return "VMSTAT_NR_FILE_PMDMAPPED";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_FOLL_PIN_ACQUIRED:
+    return "VMSTAT_NR_FOLL_PIN_ACQUIRED";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_FOLL_PIN_RELEASED:
+    return "VMSTAT_NR_FOLL_PIN_RELEASED";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_SEC_PAGE_TABLE_PAGES:
+    return "VMSTAT_NR_SEC_PAGE_TABLE_PAGES";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_SHADOW_CALL_STACK:
+    return "VMSTAT_NR_SHADOW_CALL_STACK";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_SWAPCACHED:
+    return "VMSTAT_NR_SWAPCACHED";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_THROTTLED_WRITTEN:
+    return "VMSTAT_NR_THROTTLED_WRITTEN";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGALLOC_DEVICE:
+    return "VMSTAT_PGALLOC_DEVICE";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGALLOC_DMA32:
+    return "VMSTAT_PGALLOC_DMA32";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGDEMOTE_DIRECT:
+    return "VMSTAT_PGDEMOTE_DIRECT";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGDEMOTE_KSWAPD:
+    return "VMSTAT_PGDEMOTE_KSWAPD";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGREUSE:
+    return "VMSTAT_PGREUSE";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSCAN_ANON:
+    return "VMSTAT_PGSCAN_ANON";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSCAN_FILE:
+    return "VMSTAT_PGSCAN_FILE";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSKIP_DEVICE:
+    return "VMSTAT_PGSKIP_DEVICE";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSKIP_DMA32:
+    return "VMSTAT_PGSKIP_DMA32";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSTEAL_ANON:
+    return "VMSTAT_PGSTEAL_ANON";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSTEAL_FILE:
+    return "VMSTAT_PGSTEAL_FILE";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_COLLAPSE_ALLOC:
+    return "VMSTAT_THP_COLLAPSE_ALLOC";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_COLLAPSE_ALLOC_FAILED:
+    return "VMSTAT_THP_COLLAPSE_ALLOC_FAILED";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_DEFERRED_SPLIT_PAGE:
+    return "VMSTAT_THP_DEFERRED_SPLIT_PAGE";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_FAULT_ALLOC:
+    return "VMSTAT_THP_FAULT_ALLOC";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_FAULT_FALLBACK:
+    return "VMSTAT_THP_FAULT_FALLBACK";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_FAULT_FALLBACK_CHARGE:
+    return "VMSTAT_THP_FAULT_FALLBACK_CHARGE";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_FILE_ALLOC:
+    return "VMSTAT_THP_FILE_ALLOC";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_FILE_FALLBACK:
+    return "VMSTAT_THP_FILE_FALLBACK";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_FILE_FALLBACK_CHARGE:
+    return "VMSTAT_THP_FILE_FALLBACK_CHARGE";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_FILE_MAPPED:
+    return "VMSTAT_THP_FILE_MAPPED";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_MIGRATION_FAIL:
+    return "VMSTAT_THP_MIGRATION_FAIL";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_MIGRATION_SPLIT:
+    return "VMSTAT_THP_MIGRATION_SPLIT";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_MIGRATION_SUCCESS:
+    return "VMSTAT_THP_MIGRATION_SUCCESS";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_SCAN_EXCEED_NONE_PTE:
+    return "VMSTAT_THP_SCAN_EXCEED_NONE_PTE";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_SCAN_EXCEED_SHARE_PTE:
+    return "VMSTAT_THP_SCAN_EXCEED_SHARE_PTE";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_SCAN_EXCEED_SWAP_PTE:
+    return "VMSTAT_THP_SCAN_EXCEED_SWAP_PTE";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_SPLIT_PAGE:
+    return "VMSTAT_THP_SPLIT_PAGE";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_SPLIT_PAGE_FAILED:
+    return "VMSTAT_THP_SPLIT_PAGE_FAILED";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_SPLIT_PMD:
+    return "VMSTAT_THP_SPLIT_PMD";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_SWPOUT:
+    return "VMSTAT_THP_SWPOUT";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_SWPOUT_FALLBACK:
+    return "VMSTAT_THP_SWPOUT_FALLBACK";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_ZERO_PAGE_ALLOC:
+    return "VMSTAT_THP_ZERO_PAGE_ALLOC";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_ZERO_PAGE_ALLOC_FAILED:
+    return "VMSTAT_THP_ZERO_PAGE_ALLOC_FAILED";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_VMA_LOCK_ABORT:
+    return "VMSTAT_VMA_LOCK_ABORT";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_VMA_LOCK_MISS:
+    return "VMSTAT_VMA_LOCK_MISS";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_VMA_LOCK_RETRY:
+    return "VMSTAT_VMA_LOCK_RETRY";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_VMA_LOCK_SUCCESS:
+    return "VMSTAT_VMA_LOCK_SUCCESS";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_WORKINGSET_ACTIVATE_ANON:
+    return "VMSTAT_WORKINGSET_ACTIVATE_ANON";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_WORKINGSET_ACTIVATE_FILE:
+    return "VMSTAT_WORKINGSET_ACTIVATE_FILE";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_WORKINGSET_NODES:
+    return "VMSTAT_WORKINGSET_NODES";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_WORKINGSET_REFAULT_ANON:
+    return "VMSTAT_WORKINGSET_REFAULT_ANON";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_WORKINGSET_REFAULT_FILE:
+    return "VMSTAT_WORKINGSET_REFAULT_FILE";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_WORKINGSET_RESTORE_ANON:
+    return "VMSTAT_WORKINGSET_RESTORE_ANON";
+
+  case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_WORKINGSET_RESTORE_FILE:
+    return "VMSTAT_WORKINGSET_RESTORE_FILE";
   }
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/common/system_info.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_SYSTEM_INFO_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_SYSTEM_INFO_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class Utsname;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class SystemInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/16> {
+ public:
+  SystemInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SystemInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SystemInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_utsname() const { return at<1>().valid(); }
+  ::protozero::ConstBytes utsname() const { return at<1>().as_bytes(); }
+  bool has_android_build_fingerprint() const { return at<2>().valid(); }
+  ::protozero::ConstChars android_build_fingerprint() const { return at<2>().as_string(); }
+  bool has_android_device_manufacturer() const { return at<14>().valid(); }
+  ::protozero::ConstChars android_device_manufacturer() const { return at<14>().as_string(); }
+  bool has_android_soc_model() const { return at<9>().valid(); }
+  ::protozero::ConstChars android_soc_model() const { return at<9>().as_string(); }
+  bool has_android_guest_soc_model() const { return at<13>().valid(); }
+  ::protozero::ConstChars android_guest_soc_model() const { return at<13>().as_string(); }
+  bool has_android_hardware_revision() const { return at<10>().valid(); }
+  ::protozero::ConstChars android_hardware_revision() const { return at<10>().as_string(); }
+  bool has_android_storage_model() const { return at<11>().valid(); }
+  ::protozero::ConstChars android_storage_model() const { return at<11>().as_string(); }
+  bool has_android_ram_model() const { return at<12>().valid(); }
+  ::protozero::ConstChars android_ram_model() const { return at<12>().as_string(); }
+  bool has_android_serial_console() const { return at<15>().valid(); }
+  ::protozero::ConstChars android_serial_console() const { return at<15>().as_string(); }
+  bool has_tracing_service_version() const { return at<4>().valid(); }
+  ::protozero::ConstChars tracing_service_version() const { return at<4>().as_string(); }
+  bool has_android_sdk_version() const { return at<5>().valid(); }
+  uint64_t android_sdk_version() const { return at<5>().as_uint64(); }
+  bool has_page_size() const { return at<6>().valid(); }
+  uint32_t page_size() const { return at<6>().as_uint32(); }
+  bool has_num_cpus() const { return at<8>().valid(); }
+  uint32_t num_cpus() const { return at<8>().as_uint32(); }
+  bool has_timezone_off_mins() const { return at<7>().valid(); }
+  int32_t timezone_off_mins() const { return at<7>().as_int32(); }
+  bool has_hz() const { return at<3>().valid(); }
+  int64_t hz() const { return at<3>().as_int64(); }
+  bool has_system_ram_bytes() const { return at<16>().valid(); }
+  uint64_t system_ram_bytes() const { return at<16>().as_uint64(); }
+};
+
+class SystemInfo : public ::protozero::Message {
+ public:
+  using Decoder = SystemInfo_Decoder;
+  enum : int32_t {
+    kUtsnameFieldNumber = 1,
+    kAndroidBuildFingerprintFieldNumber = 2,
+    kAndroidDeviceManufacturerFieldNumber = 14,
+    kAndroidSocModelFieldNumber = 9,
+    kAndroidGuestSocModelFieldNumber = 13,
+    kAndroidHardwareRevisionFieldNumber = 10,
+    kAndroidStorageModelFieldNumber = 11,
+    kAndroidRamModelFieldNumber = 12,
+    kAndroidSerialConsoleFieldNumber = 15,
+    kTracingServiceVersionFieldNumber = 4,
+    kAndroidSdkVersionFieldNumber = 5,
+    kPageSizeFieldNumber = 6,
+    kNumCpusFieldNumber = 8,
+    kTimezoneOffMinsFieldNumber = 7,
+    kHzFieldNumber = 3,
+    kSystemRamBytesFieldNumber = 16,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SystemInfo"; }
+
+
+  using FieldMetadata_Utsname =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      Utsname,
+      SystemInfo>;
+
+  static constexpr FieldMetadata_Utsname kUtsname{};
+  template <typename T = Utsname> T* set_utsname() {
+    return BeginNestedMessage<T>(1);
+  }
+
+
+  using FieldMetadata_AndroidBuildFingerprint =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SystemInfo>;
+
+  static constexpr FieldMetadata_AndroidBuildFingerprint kAndroidBuildFingerprint{};
+  void set_android_build_fingerprint(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_AndroidBuildFingerprint::kFieldId, data, size);
+  }
+  void set_android_build_fingerprint(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_AndroidBuildFingerprint::kFieldId, chars.data, chars.size);
+  }
+  void set_android_build_fingerprint(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_AndroidBuildFingerprint::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_AndroidDeviceManufacturer =
+    ::protozero::proto_utils::FieldMetadata<
+      14,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SystemInfo>;
+
+  static constexpr FieldMetadata_AndroidDeviceManufacturer kAndroidDeviceManufacturer{};
+  void set_android_device_manufacturer(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_AndroidDeviceManufacturer::kFieldId, data, size);
+  }
+  void set_android_device_manufacturer(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_AndroidDeviceManufacturer::kFieldId, chars.data, chars.size);
+  }
+  void set_android_device_manufacturer(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_AndroidDeviceManufacturer::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_AndroidSocModel =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SystemInfo>;
+
+  static constexpr FieldMetadata_AndroidSocModel kAndroidSocModel{};
+  void set_android_soc_model(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_AndroidSocModel::kFieldId, data, size);
+  }
+  void set_android_soc_model(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_AndroidSocModel::kFieldId, chars.data, chars.size);
+  }
+  void set_android_soc_model(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_AndroidSocModel::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_AndroidGuestSocModel =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SystemInfo>;
+
+  static constexpr FieldMetadata_AndroidGuestSocModel kAndroidGuestSocModel{};
+  void set_android_guest_soc_model(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_AndroidGuestSocModel::kFieldId, data, size);
+  }
+  void set_android_guest_soc_model(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_AndroidGuestSocModel::kFieldId, chars.data, chars.size);
+  }
+  void set_android_guest_soc_model(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_AndroidGuestSocModel::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_AndroidHardwareRevision =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SystemInfo>;
+
+  static constexpr FieldMetadata_AndroidHardwareRevision kAndroidHardwareRevision{};
+  void set_android_hardware_revision(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_AndroidHardwareRevision::kFieldId, data, size);
+  }
+  void set_android_hardware_revision(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_AndroidHardwareRevision::kFieldId, chars.data, chars.size);
+  }
+  void set_android_hardware_revision(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_AndroidHardwareRevision::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_AndroidStorageModel =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SystemInfo>;
+
+  static constexpr FieldMetadata_AndroidStorageModel kAndroidStorageModel{};
+  void set_android_storage_model(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_AndroidStorageModel::kFieldId, data, size);
+  }
+  void set_android_storage_model(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_AndroidStorageModel::kFieldId, chars.data, chars.size);
+  }
+  void set_android_storage_model(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_AndroidStorageModel::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_AndroidRamModel =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SystemInfo>;
+
+  static constexpr FieldMetadata_AndroidRamModel kAndroidRamModel{};
+  void set_android_ram_model(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_AndroidRamModel::kFieldId, data, size);
+  }
+  void set_android_ram_model(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_AndroidRamModel::kFieldId, chars.data, chars.size);
+  }
+  void set_android_ram_model(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_AndroidRamModel::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_AndroidSerialConsole =
+    ::protozero::proto_utils::FieldMetadata<
+      15,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SystemInfo>;
+
+  static constexpr FieldMetadata_AndroidSerialConsole kAndroidSerialConsole{};
+  void set_android_serial_console(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_AndroidSerialConsole::kFieldId, data, size);
+  }
+  void set_android_serial_console(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_AndroidSerialConsole::kFieldId, chars.data, chars.size);
+  }
+  void set_android_serial_console(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_AndroidSerialConsole::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TracingServiceVersion =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SystemInfo>;
+
+  static constexpr FieldMetadata_TracingServiceVersion kTracingServiceVersion{};
+  void set_tracing_service_version(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_TracingServiceVersion::kFieldId, data, size);
+  }
+  void set_tracing_service_version(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_TracingServiceVersion::kFieldId, chars.data, chars.size);
+  }
+  void set_tracing_service_version(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_TracingServiceVersion::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_AndroidSdkVersion =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SystemInfo>;
+
+  static constexpr FieldMetadata_AndroidSdkVersion kAndroidSdkVersion{};
+  void set_android_sdk_version(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AndroidSdkVersion::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PageSize =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SystemInfo>;
+
+  static constexpr FieldMetadata_PageSize kPageSize{};
+  void set_page_size(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PageSize::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NumCpus =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SystemInfo>;
+
+  static constexpr FieldMetadata_NumCpus kNumCpus{};
+  void set_num_cpus(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NumCpus::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TimezoneOffMins =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SystemInfo>;
+
+  static constexpr FieldMetadata_TimezoneOffMins kTimezoneOffMins{};
+  void set_timezone_off_mins(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimezoneOffMins::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Hz =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      SystemInfo>;
+
+  static constexpr FieldMetadata_Hz kHz{};
+  void set_hz(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Hz::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SystemRamBytes =
+    ::protozero::proto_utils::FieldMetadata<
+      16,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SystemInfo>;
+
+  static constexpr FieldMetadata_SystemRamBytes kSystemRamBytes{};
+  void set_system_ram_bytes(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SystemRamBytes::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class Utsname_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  Utsname_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Utsname_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Utsname_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_sysname() const { return at<1>().valid(); }
+  ::protozero::ConstChars sysname() const { return at<1>().as_string(); }
+  bool has_version() const { return at<2>().valid(); }
+  ::protozero::ConstChars version() const { return at<2>().as_string(); }
+  bool has_release() const { return at<3>().valid(); }
+  ::protozero::ConstChars release() const { return at<3>().as_string(); }
+  bool has_machine() const { return at<4>().valid(); }
+  ::protozero::ConstChars machine() const { return at<4>().as_string(); }
+};
+
+class Utsname : public ::protozero::Message {
+ public:
+  using Decoder = Utsname_Decoder;
+  enum : int32_t {
+    kSysnameFieldNumber = 1,
+    kVersionFieldNumber = 2,
+    kReleaseFieldNumber = 3,
+    kMachineFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Utsname"; }
+
+
+  using FieldMetadata_Sysname =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      Utsname>;
+
+  static constexpr FieldMetadata_Sysname kSysname{};
+  void set_sysname(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Sysname::kFieldId, data, size);
+  }
+  void set_sysname(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Sysname::kFieldId, chars.data, chars.size);
+  }
+  void set_sysname(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Sysname::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Version =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      Utsname>;
+
+  static constexpr FieldMetadata_Version kVersion{};
+  void set_version(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Version::kFieldId, data, size);
+  }
+  void set_version(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Version::kFieldId, chars.data, chars.size);
+  }
+  void set_version(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Version::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Release =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      Utsname>;
+
+  static constexpr FieldMetadata_Release kRelease{};
+  void set_release(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Release::kFieldId, data, size);
+  }
+  void set_release(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Release::kFieldId, chars.data, chars.size);
+  }
+  void set_release(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Release::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Machine =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      Utsname>;
+
+  static constexpr FieldMetadata_Machine kMachine{};
+  void set_machine(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Machine::kFieldId, data, size);
+  }
+  void set_machine(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Machine::kFieldId, chars.data, chars.size);
+  }
+  void set_machine(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Machine::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
 } // Namespace.
 } // Namespace.
 } // Namespace.
@@ -29246,13 +36392,21 @@ const char* VmstatCounters_Name(::perfetto::protos::pbzero::VmstatCounters value
 namespace perfetto {
 namespace protos {
 namespace pbzero {
-
 class TraceStats_BufferStats;
+class TraceStats_BufferStats_ShadowBufferStats;
 class TraceStats_FilterStats;
+class TraceStats_WriterStats;
 namespace perfetto_pbzero_enum_TraceStats {
 enum FinalFlushOutcome : int32_t;
 }  // namespace perfetto_pbzero_enum_TraceStats
 using TraceStats_FinalFlushOutcome = perfetto_pbzero_enum_TraceStats::FinalFlushOutcome;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
 namespace perfetto_pbzero_enum_TraceStats {
 enum FinalFlushOutcome : int32_t {
@@ -29283,13 +36437,17 @@ const char* TraceStats_FinalFlushOutcome_Name(::perfetto::protos::pbzero::TraceS
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-class TraceStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/15, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class TraceStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/18> {
  public:
   TraceStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit TraceStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
   explicit TraceStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_buffer_stats() const { return at<1>().valid(); }
   ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> buffer_stats() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  bool has_chunk_payload_histogram_def() const { return at<17>().valid(); }
+  ::protozero::RepeatedFieldIterator<int64_t> chunk_payload_histogram_def() const { return GetRepeated<int64_t>(17); }
+  bool has_writer_stats() const { return at<18>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> writer_stats() const { return GetRepeated<::protozero::ConstBytes>(18); }
   bool has_producers_connected() const { return at<2>().valid(); }
   uint32_t producers_connected() const { return at<2>().as_uint32(); }
   bool has_producers_seen() const { return at<3>().valid(); }
@@ -29325,6 +36483,8 @@ class TraceStats : public ::protozero::Message {
   using Decoder = TraceStats_Decoder;
   enum : int32_t {
     kBufferStatsFieldNumber = 1,
+    kChunkPayloadHistogramDefFieldNumber = 17,
+    kWriterStatsFieldNumber = 18,
     kProducersConnectedFieldNumber = 2,
     kProducersSeenFieldNumber = 3,
     kDataSourcesRegisteredFieldNumber = 4,
@@ -29343,15 +36503,16 @@ class TraceStats : public ::protozero::Message {
   static constexpr const char* GetName() { return ".perfetto.protos.TraceStats"; }
 
   using BufferStats = ::perfetto::protos::pbzero::TraceStats_BufferStats;
+  using WriterStats = ::perfetto::protos::pbzero::TraceStats_WriterStats;
   using FilterStats = ::perfetto::protos::pbzero::TraceStats_FilterStats;
 
   using FinalFlushOutcome = ::perfetto::protos::pbzero::TraceStats_FinalFlushOutcome;
   static inline const char* FinalFlushOutcome_Name(FinalFlushOutcome value) {
     return ::perfetto::protos::pbzero::TraceStats_FinalFlushOutcome_Name(value);
   }
-  static const FinalFlushOutcome FINAL_FLUSH_UNSPECIFIED = FinalFlushOutcome::FINAL_FLUSH_UNSPECIFIED;
-  static const FinalFlushOutcome FINAL_FLUSH_SUCCEEDED = FinalFlushOutcome::FINAL_FLUSH_SUCCEEDED;
-  static const FinalFlushOutcome FINAL_FLUSH_FAILED = FinalFlushOutcome::FINAL_FLUSH_FAILED;
+  static inline const FinalFlushOutcome FINAL_FLUSH_UNSPECIFIED = FinalFlushOutcome::FINAL_FLUSH_UNSPECIFIED;
+  static inline const FinalFlushOutcome FINAL_FLUSH_SUCCEEDED = FinalFlushOutcome::FINAL_FLUSH_SUCCEEDED;
+  static inline const FinalFlushOutcome FINAL_FLUSH_FAILED = FinalFlushOutcome::FINAL_FLUSH_FAILED;
 
   using FieldMetadata_BufferStats =
     ::protozero::proto_utils::FieldMetadata<
@@ -29361,19 +36522,44 @@ class TraceStats : public ::protozero::Message {
       TraceStats_BufferStats,
       TraceStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BufferStats kBufferStats() { return {}; }
+  static constexpr FieldMetadata_BufferStats kBufferStats{};
   template <typename T = TraceStats_BufferStats> T* add_buffer_stats() {
     return BeginNestedMessage<T>(1);
   }
 
 
+  using FieldMetadata_ChunkPayloadHistogramDef =
+    ::protozero::proto_utils::FieldMetadata<
+      17,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      TraceStats>;
+
+  static constexpr FieldMetadata_ChunkPayloadHistogramDef kChunkPayloadHistogramDef{};
+  void add_chunk_payload_histogram_def(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ChunkPayloadHistogramDef::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_WriterStats =
+    ::protozero::proto_utils::FieldMetadata<
+      18,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TraceStats_WriterStats,
+      TraceStats>;
+
+  static constexpr FieldMetadata_WriterStats kWriterStats{};
+  template <typename T = TraceStats_WriterStats> T* add_writer_stats() {
+    return BeginNestedMessage<T>(18);
+  }
+
+
   using FieldMetadata_ProducersConnected =
     ::protozero::proto_utils::FieldMetadata<
       2,
@@ -29382,14 +36568,7 @@ class TraceStats : public ::protozero::Message {
       uint32_t,
       TraceStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProducersConnected kProducersConnected() { return {}; }
+  static constexpr FieldMetadata_ProducersConnected kProducersConnected{};
   void set_producers_connected(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ProducersConnected::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -29407,14 +36586,7 @@ class TraceStats : public ::protozero::Message {
       uint64_t,
       TraceStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProducersSeen kProducersSeen() { return {}; }
+  static constexpr FieldMetadata_ProducersSeen kProducersSeen{};
   void set_producers_seen(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ProducersSeen::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -29432,14 +36604,7 @@ class TraceStats : public ::protozero::Message {
       uint32_t,
       TraceStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DataSourcesRegistered kDataSourcesRegistered() { return {}; }
+  static constexpr FieldMetadata_DataSourcesRegistered kDataSourcesRegistered{};
   void set_data_sources_registered(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_DataSourcesRegistered::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -29457,14 +36622,7 @@ class TraceStats : public ::protozero::Message {
       uint64_t,
       TraceStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DataSourcesSeen kDataSourcesSeen() { return {}; }
+  static constexpr FieldMetadata_DataSourcesSeen kDataSourcesSeen{};
   void set_data_sources_seen(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_DataSourcesSeen::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -29482,14 +36640,7 @@ class TraceStats : public ::protozero::Message {
       uint32_t,
       TraceStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TracingSessions kTracingSessions() { return {}; }
+  static constexpr FieldMetadata_TracingSessions kTracingSessions{};
   void set_tracing_sessions(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_TracingSessions::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -29507,14 +36658,7 @@ class TraceStats : public ::protozero::Message {
       uint32_t,
       TraceStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TotalBuffers kTotalBuffers() { return {}; }
+  static constexpr FieldMetadata_TotalBuffers kTotalBuffers{};
   void set_total_buffers(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_TotalBuffers::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -29532,14 +36676,7 @@ class TraceStats : public ::protozero::Message {
       uint64_t,
       TraceStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChunksDiscarded kChunksDiscarded() { return {}; }
+  static constexpr FieldMetadata_ChunksDiscarded kChunksDiscarded{};
   void set_chunks_discarded(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ChunksDiscarded::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -29557,14 +36694,7 @@ class TraceStats : public ::protozero::Message {
       uint64_t,
       TraceStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PatchesDiscarded kPatchesDiscarded() { return {}; }
+  static constexpr FieldMetadata_PatchesDiscarded kPatchesDiscarded{};
   void set_patches_discarded(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_PatchesDiscarded::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -29582,14 +36712,7 @@ class TraceStats : public ::protozero::Message {
       uint64_t,
       TraceStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InvalidPackets kInvalidPackets() { return {}; }
+  static constexpr FieldMetadata_InvalidPackets kInvalidPackets{};
   void set_invalid_packets(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_InvalidPackets::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -29607,14 +36730,7 @@ class TraceStats : public ::protozero::Message {
       TraceStats_FilterStats,
       TraceStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FilterStats kFilterStats() { return {}; }
+  static constexpr FieldMetadata_FilterStats kFilterStats{};
   template <typename T = TraceStats_FilterStats> T* set_filter_stats() {
     return BeginNestedMessage<T>(11);
   }
@@ -29628,14 +36744,7 @@ class TraceStats : public ::protozero::Message {
       uint64_t,
       TraceStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FlushesRequested kFlushesRequested() { return {}; }
+  static constexpr FieldMetadata_FlushesRequested kFlushesRequested{};
   void set_flushes_requested(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_FlushesRequested::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -29653,14 +36762,7 @@ class TraceStats : public ::protozero::Message {
       uint64_t,
       TraceStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FlushesSucceeded kFlushesSucceeded() { return {}; }
+  static constexpr FieldMetadata_FlushesSucceeded kFlushesSucceeded{};
   void set_flushes_succeeded(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_FlushesSucceeded::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -29678,14 +36780,7 @@ class TraceStats : public ::protozero::Message {
       uint64_t,
       TraceStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FlushesFailed kFlushesFailed() { return {}; }
+  static constexpr FieldMetadata_FlushesFailed kFlushesFailed{};
   void set_flushes_failed(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_FlushesFailed::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -29700,18 +36795,11 @@ class TraceStats : public ::protozero::Message {
       15,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::TraceStats_FinalFlushOutcome,
+      TraceStats_FinalFlushOutcome,
       TraceStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FinalFlushOutcome kFinalFlushOutcome() { return {}; }
-  void set_final_flush_outcome(::perfetto::protos::pbzero::TraceStats_FinalFlushOutcome value) {
+  static constexpr FieldMetadata_FinalFlushOutcome kFinalFlushOutcome{};
+  void set_final_flush_outcome(TraceStats_FinalFlushOutcome value) {
     static constexpr uint32_t field_id = FieldMetadata_FinalFlushOutcome::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
@@ -29721,7 +36809,7 @@ class TraceStats : public ::protozero::Message {
   }
 };
 
-class TraceStats_FilterStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class TraceStats_FilterStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/20> {
  public:
   TraceStats_FilterStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit TraceStats_FilterStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -29734,6 +36822,10 @@ class TraceStats_FilterStats_Decoder : public ::protozero::TypedProtoDecoder</*M
   uint64_t output_bytes() const { return at<3>().as_uint64(); }
   bool has_errors() const { return at<4>().valid(); }
   uint64_t errors() const { return at<4>().as_uint64(); }
+  bool has_time_taken_ns() const { return at<5>().valid(); }
+  uint64_t time_taken_ns() const { return at<5>().as_uint64(); }
+  bool has_bytes_discarded_per_buffer() const { return at<20>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint64_t> bytes_discarded_per_buffer() const { return GetRepeated<uint64_t>(20); }
 };
 
 class TraceStats_FilterStats : public ::protozero::Message {
@@ -29744,6 +36836,8 @@ class TraceStats_FilterStats : public ::protozero::Message {
     kInputBytesFieldNumber = 2,
     kOutputBytesFieldNumber = 3,
     kErrorsFieldNumber = 4,
+    kTimeTakenNsFieldNumber = 5,
+    kBytesDiscardedPerBufferFieldNumber = 20,
   };
   static constexpr const char* GetName() { return ".perfetto.protos.TraceStats.FilterStats"; }
 
@@ -29756,14 +36850,7 @@ class TraceStats_FilterStats : public ::protozero::Message {
       uint64_t,
       TraceStats_FilterStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InputPackets kInputPackets() { return {}; }
+  static constexpr FieldMetadata_InputPackets kInputPackets{};
   void set_input_packets(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_InputPackets::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -29781,14 +36868,7 @@ class TraceStats_FilterStats : public ::protozero::Message {
       uint64_t,
       TraceStats_FilterStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InputBytes kInputBytes() { return {}; }
+  static constexpr FieldMetadata_InputBytes kInputBytes{};
   void set_input_bytes(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_InputBytes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -29806,14 +36886,7 @@ class TraceStats_FilterStats : public ::protozero::Message {
       uint64_t,
       TraceStats_FilterStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OutputBytes kOutputBytes() { return {}; }
+  static constexpr FieldMetadata_OutputBytes kOutputBytes{};
   void set_output_bytes(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_OutputBytes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -29831,14 +36904,7 @@ class TraceStats_FilterStats : public ::protozero::Message {
       uint64_t,
       TraceStats_FilterStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Errors kErrors() { return {}; }
+  static constexpr FieldMetadata_Errors kErrors{};
   void set_errors(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Errors::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -29847,9 +36913,137 @@ class TraceStats_FilterStats : public ::protozero::Message {
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_TimeTakenNs =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TraceStats_FilterStats>;
+
+  static constexpr FieldMetadata_TimeTakenNs kTimeTakenNs{};
+  void set_time_taken_ns(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimeTakenNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BytesDiscardedPerBuffer =
+    ::protozero::proto_utils::FieldMetadata<
+      20,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TraceStats_FilterStats>;
+
+  static constexpr FieldMetadata_BytesDiscardedPerBuffer kBytesDiscardedPerBuffer{};
+  void add_bytes_discarded_per_buffer(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BytesDiscardedPerBuffer::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class TraceStats_WriterStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  TraceStats_WriterStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceStats_WriterStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceStats_WriterStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_sequence_id() const { return at<1>().valid(); }
+  uint64_t sequence_id() const { return at<1>().as_uint64(); }
+  bool has_buffer() const { return at<4>().valid(); }
+  uint32_t buffer() const { return at<4>().as_uint32(); }
+  bool has_chunk_payload_histogram_counts() const { return at<2>().valid(); }
+  ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> chunk_payload_histogram_counts(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(2, parse_error_ptr); }
+  bool has_chunk_payload_histogram_sum() const { return at<3>().valid(); }
+  ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, int64_t> chunk_payload_histogram_sum(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, int64_t>(3, parse_error_ptr); }
+};
+
+class TraceStats_WriterStats : public ::protozero::Message {
+ public:
+  using Decoder = TraceStats_WriterStats_Decoder;
+  enum : int32_t {
+    kSequenceIdFieldNumber = 1,
+    kBufferFieldNumber = 4,
+    kChunkPayloadHistogramCountsFieldNumber = 2,
+    kChunkPayloadHistogramSumFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceStats.WriterStats"; }
+
+
+  using FieldMetadata_SequenceId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TraceStats_WriterStats>;
+
+  static constexpr FieldMetadata_SequenceId kSequenceId{};
+  void set_sequence_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SequenceId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Buffer =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TraceStats_WriterStats>;
+
+  static constexpr FieldMetadata_Buffer kBuffer{};
+  void set_buffer(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Buffer::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ChunkPayloadHistogramCounts =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TraceStats_WriterStats>;
+
+  static constexpr FieldMetadata_ChunkPayloadHistogramCounts kChunkPayloadHistogramCounts{};
+  void set_chunk_payload_histogram_counts(const ::protozero::PackedVarInt& packed_buffer) {
+    AppendBytes(FieldMetadata_ChunkPayloadHistogramCounts::kFieldId, packed_buffer.data(),
+                packed_buffer.size());
+  }
+
+  using FieldMetadata_ChunkPayloadHistogramSum =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      TraceStats_WriterStats>;
+
+  static constexpr FieldMetadata_ChunkPayloadHistogramSum kChunkPayloadHistogramSum{};
+  void set_chunk_payload_histogram_sum(const ::protozero::PackedVarInt& packed_buffer) {
+    AppendBytes(FieldMetadata_ChunkPayloadHistogramSum::kFieldId, packed_buffer.data(),
+                packed_buffer.size());
+  }
 };
 
-class TraceStats_BufferStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/19, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class TraceStats_BufferStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/21> {
  public:
   TraceStats_BufferStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit TraceStats_BufferStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -29892,6 +37086,8 @@ class TraceStats_BufferStats_Decoder : public ::protozero::TypedProtoDecoder</*M
   uint64_t abi_violations() const { return at<9>().as_uint64(); }
   bool has_trace_writer_packet_loss() const { return at<19>().valid(); }
   uint64_t trace_writer_packet_loss() const { return at<19>().as_uint64(); }
+  bool has_shadow_buffer_stats() const { return at<21>().valid(); }
+  ::protozero::ConstBytes shadow_buffer_stats() const { return at<21>().as_bytes(); }
 };
 
 class TraceStats_BufferStats : public ::protozero::Message {
@@ -29917,9 +37113,11 @@ class TraceStats_BufferStats : public ::protozero::Message {
     kReadaheadsFailedFieldNumber = 8,
     kAbiViolationsFieldNumber = 9,
     kTraceWriterPacketLossFieldNumber = 19,
+    kShadowBufferStatsFieldNumber = 21,
   };
   static constexpr const char* GetName() { return ".perfetto.protos.TraceStats.BufferStats"; }
 
+  using ShadowBufferStats = ::perfetto::protos::pbzero::TraceStats_BufferStats_ShadowBufferStats;
 
   using FieldMetadata_BufferSize =
     ::protozero::proto_utils::FieldMetadata<
@@ -29929,14 +37127,7 @@ class TraceStats_BufferStats : public ::protozero::Message {
       uint64_t,
       TraceStats_BufferStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BufferSize kBufferSize() { return {}; }
+  static constexpr FieldMetadata_BufferSize kBufferSize{};
   void set_buffer_size(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_BufferSize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -29954,14 +37145,7 @@ class TraceStats_BufferStats : public ::protozero::Message {
       uint64_t,
       TraceStats_BufferStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BytesWritten kBytesWritten() { return {}; }
+  static constexpr FieldMetadata_BytesWritten kBytesWritten{};
   void set_bytes_written(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_BytesWritten::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -29979,14 +37163,7 @@ class TraceStats_BufferStats : public ::protozero::Message {
       uint64_t,
       TraceStats_BufferStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BytesOverwritten kBytesOverwritten() { return {}; }
+  static constexpr FieldMetadata_BytesOverwritten kBytesOverwritten{};
   void set_bytes_overwritten(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_BytesOverwritten::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30004,14 +37181,7 @@ class TraceStats_BufferStats : public ::protozero::Message {
       uint64_t,
       TraceStats_BufferStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BytesRead kBytesRead() { return {}; }
+  static constexpr FieldMetadata_BytesRead kBytesRead{};
   void set_bytes_read(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_BytesRead::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30029,14 +37199,7 @@ class TraceStats_BufferStats : public ::protozero::Message {
       uint64_t,
       TraceStats_BufferStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PaddingBytesWritten kPaddingBytesWritten() { return {}; }
+  static constexpr FieldMetadata_PaddingBytesWritten kPaddingBytesWritten{};
   void set_padding_bytes_written(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_PaddingBytesWritten::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30054,14 +37217,7 @@ class TraceStats_BufferStats : public ::protozero::Message {
       uint64_t,
       TraceStats_BufferStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PaddingBytesCleared kPaddingBytesCleared() { return {}; }
+  static constexpr FieldMetadata_PaddingBytesCleared kPaddingBytesCleared{};
   void set_padding_bytes_cleared(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_PaddingBytesCleared::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30079,14 +37235,7 @@ class TraceStats_BufferStats : public ::protozero::Message {
       uint64_t,
       TraceStats_BufferStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChunksWritten kChunksWritten() { return {}; }
+  static constexpr FieldMetadata_ChunksWritten kChunksWritten{};
   void set_chunks_written(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ChunksWritten::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30104,14 +37253,7 @@ class TraceStats_BufferStats : public ::protozero::Message {
       uint64_t,
       TraceStats_BufferStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChunksRewritten kChunksRewritten() { return {}; }
+  static constexpr FieldMetadata_ChunksRewritten kChunksRewritten{};
   void set_chunks_rewritten(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ChunksRewritten::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30129,14 +37271,7 @@ class TraceStats_BufferStats : public ::protozero::Message {
       uint64_t,
       TraceStats_BufferStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChunksOverwritten kChunksOverwritten() { return {}; }
+  static constexpr FieldMetadata_ChunksOverwritten kChunksOverwritten{};
   void set_chunks_overwritten(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ChunksOverwritten::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30154,14 +37289,7 @@ class TraceStats_BufferStats : public ::protozero::Message {
       uint64_t,
       TraceStats_BufferStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChunksDiscarded kChunksDiscarded() { return {}; }
+  static constexpr FieldMetadata_ChunksDiscarded kChunksDiscarded{};
   void set_chunks_discarded(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ChunksDiscarded::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30179,14 +37307,7 @@ class TraceStats_BufferStats : public ::protozero::Message {
       uint64_t,
       TraceStats_BufferStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChunksRead kChunksRead() { return {}; }
+  static constexpr FieldMetadata_ChunksRead kChunksRead{};
   void set_chunks_read(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ChunksRead::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30204,14 +37325,7 @@ class TraceStats_BufferStats : public ::protozero::Message {
       uint64_t,
       TraceStats_BufferStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChunksCommittedOutOfOrder kChunksCommittedOutOfOrder() { return {}; }
+  static constexpr FieldMetadata_ChunksCommittedOutOfOrder kChunksCommittedOutOfOrder{};
   void set_chunks_committed_out_of_order(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ChunksCommittedOutOfOrder::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30229,14 +37343,7 @@ class TraceStats_BufferStats : public ::protozero::Message {
       uint64_t,
       TraceStats_BufferStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WriteWrapCount kWriteWrapCount() { return {}; }
+  static constexpr FieldMetadata_WriteWrapCount kWriteWrapCount{};
   void set_write_wrap_count(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_WriteWrapCount::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30254,14 +37361,7 @@ class TraceStats_BufferStats : public ::protozero::Message {
       uint64_t,
       TraceStats_BufferStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PatchesSucceeded kPatchesSucceeded() { return {}; }
+  static constexpr FieldMetadata_PatchesSucceeded kPatchesSucceeded{};
   void set_patches_succeeded(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_PatchesSucceeded::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30279,14 +37379,7 @@ class TraceStats_BufferStats : public ::protozero::Message {
       uint64_t,
       TraceStats_BufferStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PatchesFailed kPatchesFailed() { return {}; }
+  static constexpr FieldMetadata_PatchesFailed kPatchesFailed{};
   void set_patches_failed(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_PatchesFailed::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30304,14 +37397,7 @@ class TraceStats_BufferStats : public ::protozero::Message {
       uint64_t,
       TraceStats_BufferStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReadaheadsSucceeded kReadaheadsSucceeded() { return {}; }
+  static constexpr FieldMetadata_ReadaheadsSucceeded kReadaheadsSucceeded{};
   void set_readaheads_succeeded(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ReadaheadsSucceeded::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30329,14 +37415,7 @@ class TraceStats_BufferStats : public ::protozero::Message {
       uint64_t,
       TraceStats_BufferStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReadaheadsFailed kReadaheadsFailed() { return {}; }
+  static constexpr FieldMetadata_ReadaheadsFailed kReadaheadsFailed{};
   void set_readaheads_failed(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ReadaheadsFailed::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30354,14 +37433,7 @@ class TraceStats_BufferStats : public ::protozero::Message {
       uint64_t,
       TraceStats_BufferStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AbiViolations kAbiViolations() { return {}; }
+  static constexpr FieldMetadata_AbiViolations kAbiViolations{};
   void set_abi_violations(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_AbiViolations::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30379,14 +37451,7 @@ class TraceStats_BufferStats : public ::protozero::Message {
       uint64_t,
       TraceStats_BufferStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceWriterPacketLoss kTraceWriterPacketLoss() { return {}; }
+  static constexpr FieldMetadata_TraceWriterPacketLoss kTraceWriterPacketLoss{};
   void set_trace_writer_packet_loss(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_TraceWriterPacketLoss::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30395,6 +37460,204 @@ class TraceStats_BufferStats : public ::protozero::Message {
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_ShadowBufferStats =
+    ::protozero::proto_utils::FieldMetadata<
+      21,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TraceStats_BufferStats_ShadowBufferStats,
+      TraceStats_BufferStats>;
+
+  static constexpr FieldMetadata_ShadowBufferStats kShadowBufferStats{};
+  template <typename T = TraceStats_BufferStats_ShadowBufferStats> T* set_shadow_buffer_stats() {
+    return BeginNestedMessage<T>(21);
+  }
+
+};
+
+class TraceStats_BufferStats_ShadowBufferStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
+ public:
+  TraceStats_BufferStats_ShadowBufferStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceStats_BufferStats_ShadowBufferStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceStats_BufferStats_ShadowBufferStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_packets_seen() const { return at<1>().valid(); }
+  uint64_t packets_seen() const { return at<1>().as_uint64(); }
+  bool has_packets_in_both() const { return at<2>().valid(); }
+  uint64_t packets_in_both() const { return at<2>().as_uint64(); }
+  bool has_packets_only_v1() const { return at<3>().valid(); }
+  uint64_t packets_only_v1() const { return at<3>().as_uint64(); }
+  bool has_packets_only_v2() const { return at<4>().valid(); }
+  uint64_t packets_only_v2() const { return at<4>().as_uint64(); }
+  bool has_patches_attempted() const { return at<5>().valid(); }
+  uint64_t patches_attempted() const { return at<5>().as_uint64(); }
+  bool has_v1_patches_succeeded() const { return at<6>().valid(); }
+  uint64_t v1_patches_succeeded() const { return at<6>().as_uint64(); }
+  bool has_v2_patches_succeeded() const { return at<7>().valid(); }
+  uint64_t v2_patches_succeeded() const { return at<7>().as_uint64(); }
+  bool has_stats_version() const { return at<8>().valid(); }
+  uint32_t stats_version() const { return at<8>().as_uint32(); }
+};
+
+class TraceStats_BufferStats_ShadowBufferStats : public ::protozero::Message {
+ public:
+  using Decoder = TraceStats_BufferStats_ShadowBufferStats_Decoder;
+  enum : int32_t {
+    kPacketsSeenFieldNumber = 1,
+    kPacketsInBothFieldNumber = 2,
+    kPacketsOnlyV1FieldNumber = 3,
+    kPacketsOnlyV2FieldNumber = 4,
+    kPatchesAttemptedFieldNumber = 5,
+    kV1PatchesSucceededFieldNumber = 6,
+    kV2PatchesSucceededFieldNumber = 7,
+    kStatsVersionFieldNumber = 8,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceStats.BufferStats.ShadowBufferStats"; }
+
+
+  using FieldMetadata_PacketsSeen =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TraceStats_BufferStats_ShadowBufferStats>;
+
+  static constexpr FieldMetadata_PacketsSeen kPacketsSeen{};
+  void set_packets_seen(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PacketsSeen::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PacketsInBoth =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TraceStats_BufferStats_ShadowBufferStats>;
+
+  static constexpr FieldMetadata_PacketsInBoth kPacketsInBoth{};
+  void set_packets_in_both(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PacketsInBoth::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PacketsOnlyV1 =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TraceStats_BufferStats_ShadowBufferStats>;
+
+  static constexpr FieldMetadata_PacketsOnlyV1 kPacketsOnlyV1{};
+  void set_packets_only_v1(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PacketsOnlyV1::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PacketsOnlyV2 =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TraceStats_BufferStats_ShadowBufferStats>;
+
+  static constexpr FieldMetadata_PacketsOnlyV2 kPacketsOnlyV2{};
+  void set_packets_only_v2(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PacketsOnlyV2::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PatchesAttempted =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TraceStats_BufferStats_ShadowBufferStats>;
+
+  static constexpr FieldMetadata_PatchesAttempted kPatchesAttempted{};
+  void set_patches_attempted(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PatchesAttempted::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_V1PatchesSucceeded =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TraceStats_BufferStats_ShadowBufferStats>;
+
+  static constexpr FieldMetadata_V1PatchesSucceeded kV1PatchesSucceeded{};
+  void set_v1_patches_succeeded(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_V1PatchesSucceeded::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_V2PatchesSucceeded =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TraceStats_BufferStats_ShadowBufferStats>;
+
+  static constexpr FieldMetadata_V2PatchesSucceeded kV2PatchesSucceeded{};
+  void set_v2_patches_succeeded(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_V2PatchesSucceeded::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StatsVersion =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TraceStats_BufferStats_ShadowBufferStats>;
+
+  static constexpr FieldMetadata_StatsVersion kStatsVersion{};
+  void set_stats_version(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StatsVersion::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 };
 
 } // Namespace.
@@ -30419,13 +37682,19 @@ class TraceStats_BufferStats : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
-
 namespace perfetto_pbzero_enum_ObservableEvents {
 enum Type : int32_t;
 }  // namespace perfetto_pbzero_enum_ObservableEvents
 using ObservableEvents_Type = perfetto_pbzero_enum_ObservableEvents::Type;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-class TracingServiceCapabilities_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class TracingServiceCapabilities_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
   TracingServiceCapabilities_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit TracingServiceCapabilities_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -30436,6 +37705,8 @@ class TracingServiceCapabilities_Decoder : public ::protozero::TypedProtoDecoder
   ::protozero::RepeatedFieldIterator<int32_t> observable_events() const { return GetRepeated<int32_t>(2); }
   bool has_has_trace_config_output_path() const { return at<3>().valid(); }
   bool has_trace_config_output_path() const { return at<3>().as_bool(); }
+  bool has_has_clone_session() const { return at<4>().valid(); }
+  bool has_clone_session() const { return at<4>().as_bool(); }
 };
 
 class TracingServiceCapabilities : public ::protozero::Message {
@@ -30445,6 +37716,7 @@ class TracingServiceCapabilities : public ::protozero::Message {
     kHasQueryCapabilitiesFieldNumber = 1,
     kObservableEventsFieldNumber = 2,
     kHasTraceConfigOutputPathFieldNumber = 3,
+    kHasCloneSessionFieldNumber = 4,
   };
   static constexpr const char* GetName() { return ".perfetto.protos.TracingServiceCapabilities"; }
 
@@ -30457,14 +37729,7 @@ class TracingServiceCapabilities : public ::protozero::Message {
       bool,
       TracingServiceCapabilities>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HasQueryCapabilities kHasQueryCapabilities() { return {}; }
+  static constexpr FieldMetadata_HasQueryCapabilities kHasQueryCapabilities{};
   void set_has_query_capabilities(bool value) {
     static constexpr uint32_t field_id = FieldMetadata_HasQueryCapabilities::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30479,18 +37744,11 @@ class TracingServiceCapabilities : public ::protozero::Message {
       2,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ObservableEvents_Type,
+      ObservableEvents_Type,
       TracingServiceCapabilities>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ObservableEvents kObservableEvents() { return {}; }
-  void add_observable_events(::perfetto::protos::pbzero::ObservableEvents_Type value) {
+  static constexpr FieldMetadata_ObservableEvents kObservableEvents{};
+  void add_observable_events(ObservableEvents_Type value) {
     static constexpr uint32_t field_id = FieldMetadata_ObservableEvents::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
@@ -30507,14 +37765,7 @@ class TracingServiceCapabilities : public ::protozero::Message {
       bool,
       TracingServiceCapabilities>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HasTraceConfigOutputPath kHasTraceConfigOutputPath() { return {}; }
+  static constexpr FieldMetadata_HasTraceConfigOutputPath kHasTraceConfigOutputPath{};
   void set_has_trace_config_output_path(bool value) {
     static constexpr uint32_t field_id = FieldMetadata_HasTraceConfigOutputPath::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30523,6 +37774,24 @@ class TracingServiceCapabilities : public ::protozero::Message {
       ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_HasCloneSession =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TracingServiceCapabilities>;
+
+  static constexpr FieldMetadata_HasCloneSession kHasCloneSession{};
+  void set_has_clone_session(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_HasCloneSession::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 };
 
 } // Namespace.
@@ -30547,13 +37816,19 @@ class TracingServiceCapabilities : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
-
 class DataSourceDescriptor;
 class TracingServiceState_DataSource;
 class TracingServiceState_Producer;
 class TracingServiceState_TracingSession;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-class TracingServiceState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class TracingServiceState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
   TracingServiceState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit TracingServiceState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -30600,14 +37875,7 @@ class TracingServiceState : public ::protozero::Message {
       TracingServiceState_Producer,
       TracingServiceState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Producers kProducers() { return {}; }
+  static constexpr FieldMetadata_Producers kProducers{};
   template <typename T = TracingServiceState_Producer> T* add_producers() {
     return BeginNestedMessage<T>(1);
   }
@@ -30621,14 +37889,7 @@ class TracingServiceState : public ::protozero::Message {
       TracingServiceState_DataSource,
       TracingServiceState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DataSources kDataSources() { return {}; }
+  static constexpr FieldMetadata_DataSources kDataSources{};
   template <typename T = TracingServiceState_DataSource> T* add_data_sources() {
     return BeginNestedMessage<T>(2);
   }
@@ -30642,14 +37903,7 @@ class TracingServiceState : public ::protozero::Message {
       TracingServiceState_TracingSession,
       TracingServiceState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TracingSessions kTracingSessions() { return {}; }
+  static constexpr FieldMetadata_TracingSessions kTracingSessions{};
   template <typename T = TracingServiceState_TracingSession> T* add_tracing_sessions() {
     return BeginNestedMessage<T>(6);
   }
@@ -30663,14 +37917,7 @@ class TracingServiceState : public ::protozero::Message {
       bool,
       TracingServiceState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SupportsTracingSessions kSupportsTracingSessions() { return {}; }
+  static constexpr FieldMetadata_SupportsTracingSessions kSupportsTracingSessions{};
   void set_supports_tracing_sessions(bool value) {
     static constexpr uint32_t field_id = FieldMetadata_SupportsTracingSessions::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30688,14 +37935,7 @@ class TracingServiceState : public ::protozero::Message {
       int32_t,
       TracingServiceState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NumSessions kNumSessions() { return {}; }
+  static constexpr FieldMetadata_NumSessions kNumSessions{};
   void set_num_sessions(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NumSessions::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30713,14 +37953,7 @@ class TracingServiceState : public ::protozero::Message {
       int32_t,
       TracingServiceState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NumSessionsStarted kNumSessionsStarted() { return {}; }
+  static constexpr FieldMetadata_NumSessionsStarted kNumSessionsStarted{};
   void set_num_sessions_started(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NumSessionsStarted::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30738,14 +37971,7 @@ class TracingServiceState : public ::protozero::Message {
       std::string,
       TracingServiceState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TracingServiceVersion kTracingServiceVersion() { return {}; }
+  static constexpr FieldMetadata_TracingServiceVersion kTracingServiceVersion{};
   void set_tracing_service_version(const char* data, size_t size) {
     AppendBytes(FieldMetadata_TracingServiceVersion::kFieldId, data, size);
   }
@@ -30762,7 +37988,7 @@ class TracingServiceState : public ::protozero::Message {
   }
 };
 
-class TracingServiceState_TracingSession_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class TracingServiceState_TracingSession_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11> {
  public:
   TracingServiceState_TracingSession_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit TracingServiceState_TracingSession_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -30783,6 +38009,12 @@ class TracingServiceState_TracingSession_Decoder : public ::protozero::TypedProt
   uint32_t num_data_sources() const { return at<7>().as_uint32(); }
   bool has_start_realtime_ns() const { return at<8>().valid(); }
   int64_t start_realtime_ns() const { return at<8>().as_int64(); }
+  bool has_bugreport_score() const { return at<9>().valid(); }
+  int32_t bugreport_score() const { return at<9>().as_int32(); }
+  bool has_bugreport_filename() const { return at<10>().valid(); }
+  ::protozero::ConstChars bugreport_filename() const { return at<10>().as_string(); }
+  bool has_is_started() const { return at<11>().valid(); }
+  bool is_started() const { return at<11>().as_bool(); }
 };
 
 class TracingServiceState_TracingSession : public ::protozero::Message {
@@ -30797,6 +38029,9 @@ class TracingServiceState_TracingSession : public ::protozero::Message {
     kDurationMsFieldNumber = 6,
     kNumDataSourcesFieldNumber = 7,
     kStartRealtimeNsFieldNumber = 8,
+    kBugreportScoreFieldNumber = 9,
+    kBugreportFilenameFieldNumber = 10,
+    kIsStartedFieldNumber = 11,
   };
   static constexpr const char* GetName() { return ".perfetto.protos.TracingServiceState.TracingSession"; }
 
@@ -30809,14 +38044,7 @@ class TracingServiceState_TracingSession : public ::protozero::Message {
       uint64_t,
       TracingServiceState_TracingSession>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
+  static constexpr FieldMetadata_Id kId{};
   void set_id(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30834,14 +38062,7 @@ class TracingServiceState_TracingSession : public ::protozero::Message {
       int32_t,
       TracingServiceState_TracingSession>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ConsumerUid kConsumerUid() { return {}; }
+  static constexpr FieldMetadata_ConsumerUid kConsumerUid{};
   void set_consumer_uid(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ConsumerUid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30859,14 +38080,7 @@ class TracingServiceState_TracingSession : public ::protozero::Message {
       std::string,
       TracingServiceState_TracingSession>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_State kState() { return {}; }
+  static constexpr FieldMetadata_State kState{};
   void set_state(const char* data, size_t size) {
     AppendBytes(FieldMetadata_State::kFieldId, data, size);
   }
@@ -30890,14 +38104,7 @@ class TracingServiceState_TracingSession : public ::protozero::Message {
       std::string,
       TracingServiceState_TracingSession>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UniqueSessionName kUniqueSessionName() { return {}; }
+  static constexpr FieldMetadata_UniqueSessionName kUniqueSessionName{};
   void set_unique_session_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_UniqueSessionName::kFieldId, data, size);
   }
@@ -30921,14 +38128,7 @@ class TracingServiceState_TracingSession : public ::protozero::Message {
       uint32_t,
       TracingServiceState_TracingSession>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BufferSizeKb kBufferSizeKb() { return {}; }
+  static constexpr FieldMetadata_BufferSizeKb kBufferSizeKb{};
   void add_buffer_size_kb(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_BufferSizeKb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30946,14 +38146,7 @@ class TracingServiceState_TracingSession : public ::protozero::Message {
       uint32_t,
       TracingServiceState_TracingSession>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DurationMs kDurationMs() { return {}; }
+  static constexpr FieldMetadata_DurationMs kDurationMs{};
   void set_duration_ms(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_DurationMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30971,14 +38164,7 @@ class TracingServiceState_TracingSession : public ::protozero::Message {
       uint32_t,
       TracingServiceState_TracingSession>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NumDataSources kNumDataSources() { return {}; }
+  static constexpr FieldMetadata_NumDataSources kNumDataSources{};
   void set_num_data_sources(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NumDataSources::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -30996,14 +38182,7 @@ class TracingServiceState_TracingSession : public ::protozero::Message {
       int64_t,
       TracingServiceState_TracingSession>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StartRealtimeNs kStartRealtimeNs() { return {}; }
+  static constexpr FieldMetadata_StartRealtimeNs kStartRealtimeNs{};
   void set_start_realtime_ns(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_StartRealtimeNs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -31012,9 +38191,69 @@ class TracingServiceState_TracingSession : public ::protozero::Message {
       ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_BugreportScore =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TracingServiceState_TracingSession>;
+
+  static constexpr FieldMetadata_BugreportScore kBugreportScore{};
+  void set_bugreport_score(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BugreportScore::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BugreportFilename =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TracingServiceState_TracingSession>;
+
+  static constexpr FieldMetadata_BugreportFilename kBugreportFilename{};
+  void set_bugreport_filename(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_BugreportFilename::kFieldId, data, size);
+  }
+  void set_bugreport_filename(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_BugreportFilename::kFieldId, chars.data, chars.size);
+  }
+  void set_bugreport_filename(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_BugreportFilename::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IsStarted =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TracingServiceState_TracingSession>;
+
+  static constexpr FieldMetadata_IsStarted kIsStarted{};
+  void set_is_started(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsStarted::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class TracingServiceState_DataSource_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class TracingServiceState_DataSource_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
   TracingServiceState_DataSource_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit TracingServiceState_DataSource_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -31043,14 +38282,7 @@ class TracingServiceState_DataSource : public ::protozero::Message {
       DataSourceDescriptor,
       TracingServiceState_DataSource>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DsDescriptor kDsDescriptor() { return {}; }
+  static constexpr FieldMetadata_DsDescriptor kDsDescriptor{};
   template <typename T = DataSourceDescriptor> T* set_ds_descriptor() {
     return BeginNestedMessage<T>(1);
   }
@@ -31064,14 +38296,7 @@ class TracingServiceState_DataSource : public ::protozero::Message {
       int32_t,
       TracingServiceState_DataSource>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProducerId kProducerId() { return {}; }
+  static constexpr FieldMetadata_ProducerId kProducerId{};
   void set_producer_id(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ProducerId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -31082,7 +38307,7 @@ class TracingServiceState_DataSource : public ::protozero::Message {
   }
 };
 
-class TracingServiceState_Producer_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class TracingServiceState_Producer_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
   TracingServiceState_Producer_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit TracingServiceState_Producer_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -31097,6 +38322,8 @@ class TracingServiceState_Producer_Decoder : public ::protozero::TypedProtoDecod
   int32_t uid() const { return at<3>().as_int32(); }
   bool has_sdk_version() const { return at<4>().valid(); }
   ::protozero::ConstChars sdk_version() const { return at<4>().as_string(); }
+  bool has_frozen() const { return at<6>().valid(); }
+  bool frozen() const { return at<6>().as_bool(); }
 };
 
 class TracingServiceState_Producer : public ::protozero::Message {
@@ -31108,6 +38335,7 @@ class TracingServiceState_Producer : public ::protozero::Message {
     kPidFieldNumber = 5,
     kUidFieldNumber = 3,
     kSdkVersionFieldNumber = 4,
+    kFrozenFieldNumber = 6,
   };
   static constexpr const char* GetName() { return ".perfetto.protos.TracingServiceState.Producer"; }
 
@@ -31120,14 +38348,7 @@ class TracingServiceState_Producer : public ::protozero::Message {
       int32_t,
       TracingServiceState_Producer>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
+  static constexpr FieldMetadata_Id kId{};
   void set_id(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -31145,14 +38366,7 @@ class TracingServiceState_Producer : public ::protozero::Message {
       std::string,
       TracingServiceState_Producer>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -31176,14 +38390,7 @@ class TracingServiceState_Producer : public ::protozero::Message {
       int32_t,
       TracingServiceState_Producer>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
+  static constexpr FieldMetadata_Pid kPid{};
   void set_pid(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -31201,14 +38408,7 @@ class TracingServiceState_Producer : public ::protozero::Message {
       int32_t,
       TracingServiceState_Producer>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Uid kUid() { return {}; }
+  static constexpr FieldMetadata_Uid kUid{};
   void set_uid(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -31226,14 +38426,7 @@ class TracingServiceState_Producer : public ::protozero::Message {
       std::string,
       TracingServiceState_Producer>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SdkVersion kSdkVersion() { return {}; }
+  static constexpr FieldMetadata_SdkVersion kSdkVersion{};
   void set_sdk_version(const char* data, size_t size) {
     AppendBytes(FieldMetadata_SdkVersion::kFieldId, data, size);
   }
@@ -31248,6 +38441,24 @@ class TracingServiceState_Producer : public ::protozero::Message {
       ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_Frozen =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TracingServiceState_Producer>;
+
+  static constexpr FieldMetadata_Frozen kFrozen{};
+  void set_frozen(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_Frozen::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 };
 
 } // Namespace.
@@ -31272,10 +38483,16 @@ class TracingServiceState_Producer : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
-
 class TrackEventCategory;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-class TrackEventDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class TrackEventDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
   TrackEventDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit TrackEventDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -31301,21 +38518,14 @@ class TrackEventDescriptor : public ::protozero::Message {
       TrackEventCategory,
       TrackEventDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AvailableCategories kAvailableCategories() { return {}; }
+  static constexpr FieldMetadata_AvailableCategories kAvailableCategories{};
   template <typename T = TrackEventCategory> T* add_available_categories() {
     return BeginNestedMessage<T>(1);
   }
 
 };
 
-class TrackEventCategory_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class TrackEventCategory_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
   TrackEventCategory_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit TrackEventCategory_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -31347,14 +38557,7 @@ class TrackEventCategory : public ::protozero::Message {
       std::string,
       TrackEventCategory>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -31378,14 +38581,7 @@ class TrackEventCategory : public ::protozero::Message {
       std::string,
       TrackEventCategory>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Description kDescription() { return {}; }
+  static constexpr FieldMetadata_Description kDescription{};
   void set_description(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Description::kFieldId, data, size);
   }
@@ -31409,14 +38605,7 @@ class TrackEventCategory : public ::protozero::Message {
       std::string,
       TrackEventCategory>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Tags kTags() { return {}; }
+  static constexpr FieldMetadata_Tags kTags{};
   void add_tags(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Tags::kFieldId, data, size);
   }
@@ -31437,10 +38626,10 @@ class TrackEventCategory : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/track_event/track_event_config.gen.h
+// gen_amalgamated begin header: gen/protos/perfetto/common/semantic_type.gen.h
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TRACK_EVENT_TRACK_EVENT_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TRACK_EVENT_TRACK_EVENT_CONFIG_PROTO_CPP_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_SEMANTIC_TYPE_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_SEMANTIC_TYPE_PROTO_CPP_H_
 
 #include <stdint.h>
 #include <bitset>
@@ -31455,7 +38644,7 @@ class TrackEventCategory : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace gen {
-class TrackEventConfig;
+enum SemanticType : int;
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
@@ -31467,6938 +38656,7332 @@ class Message;
 namespace perfetto {
 namespace protos {
 namespace gen {
+enum SemanticType : int {
+  SEMANTIC_TYPE_UNSPECIFIED = 0,
+  SEMANTIC_TYPE_ATRACE = 1,
+  SEMANTIC_TYPE_JOB = 2,
+  SEMANTIC_TYPE_WAKELOCK = 3,
+};
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-class PERFETTO_EXPORT_COMPONENT TrackEventConfig : public ::protozero::CppMessageObj {
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_SEMANTIC_TYPE_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_game_intervention_list_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_GAME_INTERVENTION_LIST_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_GAME_INTERVENTION_LIST_CONFIG_PROTO_CPP_H_
+
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+class AndroidGameInterventionListConfig;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+namespace protozero {
+class Message;
+}  // namespace protozero
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+
+class PERFETTO_EXPORT_COMPONENT AndroidGameInterventionListConfig : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kDisabledCategoriesFieldNumber = 1,
-    kEnabledCategoriesFieldNumber = 2,
-    kDisabledTagsFieldNumber = 3,
-    kEnabledTagsFieldNumber = 4,
-    kDisableIncrementalTimestampsFieldNumber = 5,
-    kTimestampUnitMultiplierFieldNumber = 6,
-    kFilterDebugAnnotationsFieldNumber = 7,
-    kEnableThreadTimeSamplingFieldNumber = 8,
-    kFilterDynamicEventNamesFieldNumber = 9,
+    kPackageNameFilterFieldNumber = 1,
   };
 
-  TrackEventConfig();
-  ~TrackEventConfig() override;
-  TrackEventConfig(TrackEventConfig&&) noexcept;
-  TrackEventConfig& operator=(TrackEventConfig&&);
-  TrackEventConfig(const TrackEventConfig&);
-  TrackEventConfig& operator=(const TrackEventConfig&);
-  bool operator==(const TrackEventConfig&) const;
-  bool operator!=(const TrackEventConfig& other) const { return !(*this == other); }
+  AndroidGameInterventionListConfig();
+  ~AndroidGameInterventionListConfig() override;
+  AndroidGameInterventionListConfig(AndroidGameInterventionListConfig&&) noexcept;
+  AndroidGameInterventionListConfig& operator=(AndroidGameInterventionListConfig&&);
+  AndroidGameInterventionListConfig(const AndroidGameInterventionListConfig&);
+  AndroidGameInterventionListConfig& operator=(const AndroidGameInterventionListConfig&);
+  bool operator==(const AndroidGameInterventionListConfig&) const;
+  bool operator!=(const AndroidGameInterventionListConfig& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  const std::vector<std::string>& disabled_categories() const { return disabled_categories_; }
-  std::vector<std::string>* mutable_disabled_categories() { return &disabled_categories_; }
-  int disabled_categories_size() const { return static_cast<int>(disabled_categories_.size()); }
-  void clear_disabled_categories() { disabled_categories_.clear(); }
-  void add_disabled_categories(std::string value) { disabled_categories_.emplace_back(value); }
-  std::string* add_disabled_categories() { disabled_categories_.emplace_back(); return &disabled_categories_.back(); }
-
-  const std::vector<std::string>& enabled_categories() const { return enabled_categories_; }
-  std::vector<std::string>* mutable_enabled_categories() { return &enabled_categories_; }
-  int enabled_categories_size() const { return static_cast<int>(enabled_categories_.size()); }
-  void clear_enabled_categories() { enabled_categories_.clear(); }
-  void add_enabled_categories(std::string value) { enabled_categories_.emplace_back(value); }
-  std::string* add_enabled_categories() { enabled_categories_.emplace_back(); return &enabled_categories_.back(); }
-
-  const std::vector<std::string>& disabled_tags() const { return disabled_tags_; }
-  std::vector<std::string>* mutable_disabled_tags() { return &disabled_tags_; }
-  int disabled_tags_size() const { return static_cast<int>(disabled_tags_.size()); }
-  void clear_disabled_tags() { disabled_tags_.clear(); }
-  void add_disabled_tags(std::string value) { disabled_tags_.emplace_back(value); }
-  std::string* add_disabled_tags() { disabled_tags_.emplace_back(); return &disabled_tags_.back(); }
-
-  const std::vector<std::string>& enabled_tags() const { return enabled_tags_; }
-  std::vector<std::string>* mutable_enabled_tags() { return &enabled_tags_; }
-  int enabled_tags_size() const { return static_cast<int>(enabled_tags_.size()); }
-  void clear_enabled_tags() { enabled_tags_.clear(); }
-  void add_enabled_tags(std::string value) { enabled_tags_.emplace_back(value); }
-  std::string* add_enabled_tags() { enabled_tags_.emplace_back(); return &enabled_tags_.back(); }
-
-  bool has_disable_incremental_timestamps() const { return _has_field_[5]; }
-  bool disable_incremental_timestamps() const { return disable_incremental_timestamps_; }
-  void set_disable_incremental_timestamps(bool value) { disable_incremental_timestamps_ = value; _has_field_.set(5); }
-
-  bool has_timestamp_unit_multiplier() const { return _has_field_[6]; }
-  uint64_t timestamp_unit_multiplier() const { return timestamp_unit_multiplier_; }
-  void set_timestamp_unit_multiplier(uint64_t value) { timestamp_unit_multiplier_ = value; _has_field_.set(6); }
-
-  bool has_filter_debug_annotations() const { return _has_field_[7]; }
-  bool filter_debug_annotations() const { return filter_debug_annotations_; }
-  void set_filter_debug_annotations(bool value) { filter_debug_annotations_ = value; _has_field_.set(7); }
-
-  bool has_enable_thread_time_sampling() const { return _has_field_[8]; }
-  bool enable_thread_time_sampling() const { return enable_thread_time_sampling_; }
-  void set_enable_thread_time_sampling(bool value) { enable_thread_time_sampling_ = value; _has_field_.set(8); }
-
-  bool has_filter_dynamic_event_names() const { return _has_field_[9]; }
-  bool filter_dynamic_event_names() const { return filter_dynamic_event_names_; }
-  void set_filter_dynamic_event_names(bool value) { filter_dynamic_event_names_ = value; _has_field_.set(9); }
+  const std::vector<std::string>& package_name_filter() const { return package_name_filter_; }
+  std::vector<std::string>* mutable_package_name_filter() { return &package_name_filter_; }
+  int package_name_filter_size() const { return static_cast<int>(package_name_filter_.size()); }
+  void clear_package_name_filter() { package_name_filter_.clear(); }
+  void add_package_name_filter(std::string value) { package_name_filter_.emplace_back(value); }
+  std::string* add_package_name_filter() { package_name_filter_.emplace_back(); return &package_name_filter_.back(); }
 
  private:
-  std::vector<std::string> disabled_categories_;
-  std::vector<std::string> enabled_categories_;
-  std::vector<std::string> disabled_tags_;
-  std::vector<std::string> enabled_tags_;
-  bool disable_incremental_timestamps_{};
-  uint64_t timestamp_unit_multiplier_{};
-  bool filter_debug_annotations_{};
-  bool enable_thread_time_sampling_{};
-  bool filter_dynamic_event_names_{};
+  std::vector<std::string> package_name_filter_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<10> _has_field_{};
+  std::bitset<2> _has_field_{};
 };
 
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TRACK_EVENT_TRACK_EVENT_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_game_intervention_list_config.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_GAME_INTERVENTION_LIST_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_GAME_INTERVENTION_LIST_CONFIG_PROTO_H_
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_GAME_INTERVENTION_LIST_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_input_event_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_INPUT_EVENT_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_INPUT_EVENT_CONFIG_PROTO_CPP_H_
 
-#include <stddef.h>
 #include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
 namespace perfetto {
 namespace protos {
-namespace pbzero {
+namespace gen {
+class AndroidInputEventConfig;
+class AndroidInputEventConfig_TraceRule;
+enum AndroidInputEventConfig_TraceMode : int;
+enum AndroidInputEventConfig_TraceLevel : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-class AndroidGameInterventionListConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  AndroidGameInterventionListConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AndroidGameInterventionListConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AndroidGameInterventionListConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_package_name_filter() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> package_name_filter() const { return GetRepeated<::protozero::ConstChars>(1); }
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum AndroidInputEventConfig_TraceMode : int {
+  AndroidInputEventConfig_TraceMode_TRACE_MODE_TRACE_ALL = 0,
+  AndroidInputEventConfig_TraceMode_TRACE_MODE_USE_RULES = 1,
+};
+enum AndroidInputEventConfig_TraceLevel : int {
+  AndroidInputEventConfig_TraceLevel_TRACE_LEVEL_NONE = 0,
+  AndroidInputEventConfig_TraceLevel_TRACE_LEVEL_REDACTED = 1,
+  AndroidInputEventConfig_TraceLevel_TRACE_LEVEL_COMPLETE = 2,
+};
+
+class PERFETTO_EXPORT_COMPONENT AndroidInputEventConfig : public ::protozero::CppMessageObj {
+ public:
+  using TraceRule = AndroidInputEventConfig_TraceRule;
+  using TraceMode = AndroidInputEventConfig_TraceMode;
+  static constexpr auto TRACE_MODE_TRACE_ALL = AndroidInputEventConfig_TraceMode_TRACE_MODE_TRACE_ALL;
+  static constexpr auto TRACE_MODE_USE_RULES = AndroidInputEventConfig_TraceMode_TRACE_MODE_USE_RULES;
+  static constexpr auto TraceMode_MIN = AndroidInputEventConfig_TraceMode_TRACE_MODE_TRACE_ALL;
+  static constexpr auto TraceMode_MAX = AndroidInputEventConfig_TraceMode_TRACE_MODE_USE_RULES;
+  using TraceLevel = AndroidInputEventConfig_TraceLevel;
+  static constexpr auto TRACE_LEVEL_NONE = AndroidInputEventConfig_TraceLevel_TRACE_LEVEL_NONE;
+  static constexpr auto TRACE_LEVEL_REDACTED = AndroidInputEventConfig_TraceLevel_TRACE_LEVEL_REDACTED;
+  static constexpr auto TRACE_LEVEL_COMPLETE = AndroidInputEventConfig_TraceLevel_TRACE_LEVEL_COMPLETE;
+  static constexpr auto TraceLevel_MIN = AndroidInputEventConfig_TraceLevel_TRACE_LEVEL_NONE;
+  static constexpr auto TraceLevel_MAX = AndroidInputEventConfig_TraceLevel_TRACE_LEVEL_COMPLETE;
+  enum FieldNumbers {
+    kModeFieldNumber = 1,
+    kRulesFieldNumber = 2,
+    kTraceDispatcherInputEventsFieldNumber = 3,
+    kTraceDispatcherWindowDispatchFieldNumber = 4,
+  };
+
+  AndroidInputEventConfig();
+  ~AndroidInputEventConfig() override;
+  AndroidInputEventConfig(AndroidInputEventConfig&&) noexcept;
+  AndroidInputEventConfig& operator=(AndroidInputEventConfig&&);
+  AndroidInputEventConfig(const AndroidInputEventConfig&);
+  AndroidInputEventConfig& operator=(const AndroidInputEventConfig&);
+  bool operator==(const AndroidInputEventConfig&) const;
+  bool operator!=(const AndroidInputEventConfig& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_mode() const { return _has_field_[1]; }
+  AndroidInputEventConfig_TraceMode mode() const { return mode_; }
+  void set_mode(AndroidInputEventConfig_TraceMode value) { mode_ = value; _has_field_.set(1); }
+
+  const std::vector<AndroidInputEventConfig_TraceRule>& rules() const { return rules_; }
+  std::vector<AndroidInputEventConfig_TraceRule>* mutable_rules() { return &rules_; }
+  int rules_size() const;
+  void clear_rules();
+  AndroidInputEventConfig_TraceRule* add_rules();
+
+  bool has_trace_dispatcher_input_events() const { return _has_field_[3]; }
+  bool trace_dispatcher_input_events() const { return trace_dispatcher_input_events_; }
+  void set_trace_dispatcher_input_events(bool value) { trace_dispatcher_input_events_ = value; _has_field_.set(3); }
+
+  bool has_trace_dispatcher_window_dispatch() const { return _has_field_[4]; }
+  bool trace_dispatcher_window_dispatch() const { return trace_dispatcher_window_dispatch_; }
+  void set_trace_dispatcher_window_dispatch(bool value) { trace_dispatcher_window_dispatch_ = value; _has_field_.set(4); }
+
+ private:
+  AndroidInputEventConfig_TraceMode mode_{};
+  std::vector<AndroidInputEventConfig_TraceRule> rules_;
+  bool trace_dispatcher_input_events_{};
+  bool trace_dispatcher_window_dispatch_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<5> _has_field_{};
 };
 
-class AndroidGameInterventionListConfig : public ::protozero::Message {
+
+class PERFETTO_EXPORT_COMPONENT AndroidInputEventConfig_TraceRule : public ::protozero::CppMessageObj {
  public:
-  using Decoder = AndroidGameInterventionListConfig_Decoder;
-  enum : int32_t {
-    kPackageNameFilterFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.AndroidGameInterventionListConfig"; }
+  enum FieldNumbers {
+    kTraceLevelFieldNumber = 1,
+    kMatchAllPackagesFieldNumber = 2,
+    kMatchAnyPackagesFieldNumber = 3,
+    kMatchSecureFieldNumber = 4,
+    kMatchImeConnectionActiveFieldNumber = 5,
+  };
+
+  AndroidInputEventConfig_TraceRule();
+  ~AndroidInputEventConfig_TraceRule() override;
+  AndroidInputEventConfig_TraceRule(AndroidInputEventConfig_TraceRule&&) noexcept;
+  AndroidInputEventConfig_TraceRule& operator=(AndroidInputEventConfig_TraceRule&&);
+  AndroidInputEventConfig_TraceRule(const AndroidInputEventConfig_TraceRule&);
+  AndroidInputEventConfig_TraceRule& operator=(const AndroidInputEventConfig_TraceRule&);
+  bool operator==(const AndroidInputEventConfig_TraceRule&) const;
+  bool operator!=(const AndroidInputEventConfig_TraceRule& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
+  bool has_trace_level() const { return _has_field_[1]; }
+  AndroidInputEventConfig_TraceLevel trace_level() const { return trace_level_; }
+  void set_trace_level(AndroidInputEventConfig_TraceLevel value) { trace_level_ = value; _has_field_.set(1); }
 
-  using FieldMetadata_PackageNameFilter =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      AndroidGameInterventionListConfig>;
+  const std::vector<std::string>& match_all_packages() const { return match_all_packages_; }
+  std::vector<std::string>* mutable_match_all_packages() { return &match_all_packages_; }
+  int match_all_packages_size() const { return static_cast<int>(match_all_packages_.size()); }
+  void clear_match_all_packages() { match_all_packages_.clear(); }
+  void add_match_all_packages(std::string value) { match_all_packages_.emplace_back(value); }
+  std::string* add_match_all_packages() { match_all_packages_.emplace_back(); return &match_all_packages_.back(); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PackageNameFilter kPackageNameFilter() { return {}; }
-  void add_package_name_filter(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_PackageNameFilter::kFieldId, data, size);
-  }
-  void add_package_name_filter(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_PackageNameFilter::kFieldId, chars.data, chars.size);
-  }
-  void add_package_name_filter(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_PackageNameFilter::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  const std::vector<std::string>& match_any_packages() const { return match_any_packages_; }
+  std::vector<std::string>* mutable_match_any_packages() { return &match_any_packages_; }
+  int match_any_packages_size() const { return static_cast<int>(match_any_packages_.size()); }
+  void clear_match_any_packages() { match_any_packages_.clear(); }
+  void add_match_any_packages(std::string value) { match_any_packages_.emplace_back(value); }
+  std::string* add_match_any_packages() { match_any_packages_.emplace_back(); return &match_any_packages_.back(); }
+
+  bool has_match_secure() const { return _has_field_[4]; }
+  bool match_secure() const { return match_secure_; }
+  void set_match_secure(bool value) { match_secure_ = value; _has_field_.set(4); }
+
+  bool has_match_ime_connection_active() const { return _has_field_[5]; }
+  bool match_ime_connection_active() const { return match_ime_connection_active_; }
+  void set_match_ime_connection_active(bool value) { match_ime_connection_active_ = value; _has_field_.set(5); }
+
+ private:
+  AndroidInputEventConfig_TraceLevel trace_level_{};
+  std::vector<std::string> match_all_packages_;
+  std::vector<std::string> match_any_packages_;
+  bool match_secure_{};
+  bool match_ime_connection_active_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<6> _has_field_{};
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_log_config.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_LOG_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_LOG_CONFIG_PROTO_H_
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_INPUT_EVENT_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_log_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_LOG_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_LOG_CONFIG_PROTO_CPP_H_
 
-#include <stddef.h>
 #include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
 namespace perfetto {
 namespace protos {
-namespace pbzero {
+namespace gen {
+class AndroidLogConfig;
+enum AndroidLogId : int;
+enum AndroidLogPriority : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-enum AndroidLogId : int32_t;
-enum AndroidLogPriority : int32_t;
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-class AndroidLogConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  AndroidLogConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AndroidLogConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AndroidLogConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_log_ids() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<int32_t> log_ids() const { return GetRepeated<int32_t>(1); }
-  bool has_min_prio() const { return at<3>().valid(); }
-  int32_t min_prio() const { return at<3>().as_int32(); }
-  bool has_filter_tags() const { return at<4>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> filter_tags() const { return GetRepeated<::protozero::ConstChars>(4); }
-};
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-class AndroidLogConfig : public ::protozero::Message {
+class PERFETTO_EXPORT_COMPONENT AndroidLogConfig : public ::protozero::CppMessageObj {
  public:
-  using Decoder = AndroidLogConfig_Decoder;
-  enum : int32_t {
+  enum FieldNumbers {
     kLogIdsFieldNumber = 1,
     kMinPrioFieldNumber = 3,
     kFilterTagsFieldNumber = 4,
+    kPreserveLogBufferFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.AndroidLogConfig"; }
 
+  AndroidLogConfig();
+  ~AndroidLogConfig() override;
+  AndroidLogConfig(AndroidLogConfig&&) noexcept;
+  AndroidLogConfig& operator=(AndroidLogConfig&&);
+  AndroidLogConfig(const AndroidLogConfig&);
+  AndroidLogConfig& operator=(const AndroidLogConfig&);
+  bool operator==(const AndroidLogConfig&) const;
+  bool operator!=(const AndroidLogConfig& other) const { return !(*this == other); }
 
-  using FieldMetadata_LogIds =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::AndroidLogId,
-      AndroidLogConfig>;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LogIds kLogIds() { return {}; }
-  void add_log_ids(::perfetto::protos::pbzero::AndroidLogId value) {
-    static constexpr uint32_t field_id = FieldMetadata_LogIds::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
+  const std::vector<AndroidLogId>& log_ids() const { return log_ids_; }
+  std::vector<AndroidLogId>* mutable_log_ids() { return &log_ids_; }
+  int log_ids_size() const { return static_cast<int>(log_ids_.size()); }
+  void clear_log_ids() { log_ids_.clear(); }
+  void add_log_ids(AndroidLogId value) { log_ids_.emplace_back(value); }
+  AndroidLogId* add_log_ids() { log_ids_.emplace_back(); return &log_ids_.back(); }
 
-  using FieldMetadata_MinPrio =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::AndroidLogPriority,
-      AndroidLogConfig>;
+  bool has_min_prio() const { return _has_field_[3]; }
+  AndroidLogPriority min_prio() const { return min_prio_; }
+  void set_min_prio(AndroidLogPriority value) { min_prio_ = value; _has_field_.set(3); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MinPrio kMinPrio() { return {}; }
-  void set_min_prio(::perfetto::protos::pbzero::AndroidLogPriority value) {
-    static constexpr uint32_t field_id = FieldMetadata_MinPrio::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
+  const std::vector<std::string>& filter_tags() const { return filter_tags_; }
+  std::vector<std::string>* mutable_filter_tags() { return &filter_tags_; }
+  int filter_tags_size() const { return static_cast<int>(filter_tags_.size()); }
+  void clear_filter_tags() { filter_tags_.clear(); }
+  void add_filter_tags(std::string value) { filter_tags_.emplace_back(value); }
+  std::string* add_filter_tags() { filter_tags_.emplace_back(); return &filter_tags_.back(); }
 
-  using FieldMetadata_FilterTags =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      AndroidLogConfig>;
+  bool has_preserve_log_buffer() const { return _has_field_[5]; }
+  bool preserve_log_buffer() const { return preserve_log_buffer_; }
+  void set_preserve_log_buffer(bool value) { preserve_log_buffer_ = value; _has_field_.set(5); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FilterTags kFilterTags() { return {}; }
-  void add_filter_tags(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_FilterTags::kFieldId, data, size);
-  }
-  void add_filter_tags(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_FilterTags::kFieldId, chars.data, chars.size);
-  }
-  void add_filter_tags(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_FilterTags::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+ private:
+  std::vector<AndroidLogId> log_ids_;
+  AndroidLogPriority min_prio_{};
+  std::vector<std::string> filter_tags_;
+  bool preserve_log_buffer_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<6> _has_field_{};
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_polled_state_config.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_POLLED_STATE_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_POLLED_STATE_CONFIG_PROTO_H_
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_LOG_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_polled_state_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_POLLED_STATE_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_POLLED_STATE_CONFIG_PROTO_CPP_H_
 
-#include <stddef.h>
 #include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
 namespace perfetto {
 namespace protos {
-namespace pbzero {
+namespace gen {
+class AndroidPolledStateConfig;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-class AndroidPolledStateConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  AndroidPolledStateConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AndroidPolledStateConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AndroidPolledStateConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_poll_ms() const { return at<1>().valid(); }
-  uint32_t poll_ms() const { return at<1>().as_uint32(); }
-};
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-class AndroidPolledStateConfig : public ::protozero::Message {
+class PERFETTO_EXPORT_COMPONENT AndroidPolledStateConfig : public ::protozero::CppMessageObj {
  public:
-  using Decoder = AndroidPolledStateConfig_Decoder;
-  enum : int32_t {
+  enum FieldNumbers {
     kPollMsFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.AndroidPolledStateConfig"; }
 
+  AndroidPolledStateConfig();
+  ~AndroidPolledStateConfig() override;
+  AndroidPolledStateConfig(AndroidPolledStateConfig&&) noexcept;
+  AndroidPolledStateConfig& operator=(AndroidPolledStateConfig&&);
+  AndroidPolledStateConfig(const AndroidPolledStateConfig&);
+  AndroidPolledStateConfig& operator=(const AndroidPolledStateConfig&);
+  bool operator==(const AndroidPolledStateConfig&) const;
+  bool operator!=(const AndroidPolledStateConfig& other) const { return !(*this == other); }
 
-  using FieldMetadata_PollMs =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      AndroidPolledStateConfig>;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PollMs kPollMs() { return {}; }
-  void set_poll_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PollMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  bool has_poll_ms() const { return _has_field_[1]; }
+  uint32_t poll_ms() const { return poll_ms_; }
+  void set_poll_ms(uint32_t value) { poll_ms_ = value; _has_field_.set(1); }
+
+ private:
+  uint32_t poll_ms_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<2> _has_field_{};
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_system_property_config.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_SYSTEM_PROPERTY_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_SYSTEM_PROPERTY_CONFIG_PROTO_H_
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_POLLED_STATE_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_sdk_sysprop_guard_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_SDK_SYSPROP_GUARD_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_SDK_SYSPROP_GUARD_CONFIG_PROTO_CPP_H_
 
-#include <stddef.h>
 #include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
 namespace perfetto {
 namespace protos {
-namespace pbzero {
+namespace gen {
+class AndroidSdkSyspropGuardConfig;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-class AndroidSystemPropertyConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  AndroidSystemPropertyConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AndroidSystemPropertyConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AndroidSystemPropertyConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_poll_ms() const { return at<1>().valid(); }
-  uint32_t poll_ms() const { return at<1>().as_uint32(); }
-  bool has_property_name() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> property_name() const { return GetRepeated<::protozero::ConstChars>(2); }
-};
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-class AndroidSystemPropertyConfig : public ::protozero::Message {
+class PERFETTO_EXPORT_COMPONENT AndroidSdkSyspropGuardConfig : public ::protozero::CppMessageObj {
  public:
-  using Decoder = AndroidSystemPropertyConfig_Decoder;
-  enum : int32_t {
-    kPollMsFieldNumber = 1,
-    kPropertyNameFieldNumber = 2,
+  enum FieldNumbers {
+    kSurfaceflingerSkiaTrackEventsFieldNumber = 1,
+    kHwuiSkiaTrackEventsFieldNumber = 2,
+    kHwuiPackageNameFilterFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.AndroidSystemPropertyConfig"; }
 
+  AndroidSdkSyspropGuardConfig();
+  ~AndroidSdkSyspropGuardConfig() override;
+  AndroidSdkSyspropGuardConfig(AndroidSdkSyspropGuardConfig&&) noexcept;
+  AndroidSdkSyspropGuardConfig& operator=(AndroidSdkSyspropGuardConfig&&);
+  AndroidSdkSyspropGuardConfig(const AndroidSdkSyspropGuardConfig&);
+  AndroidSdkSyspropGuardConfig& operator=(const AndroidSdkSyspropGuardConfig&);
+  bool operator==(const AndroidSdkSyspropGuardConfig&) const;
+  bool operator!=(const AndroidSdkSyspropGuardConfig& other) const { return !(*this == other); }
 
-  using FieldMetadata_PollMs =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      AndroidSystemPropertyConfig>;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PollMs kPollMs() { return {}; }
-  void set_poll_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PollMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  bool has_surfaceflinger_skia_track_events() const { return _has_field_[1]; }
+  bool surfaceflinger_skia_track_events() const { return surfaceflinger_skia_track_events_; }
+  void set_surfaceflinger_skia_track_events(bool value) { surfaceflinger_skia_track_events_ = value; _has_field_.set(1); }
 
-  using FieldMetadata_PropertyName =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      AndroidSystemPropertyConfig>;
+  bool has_hwui_skia_track_events() const { return _has_field_[2]; }
+  bool hwui_skia_track_events() const { return hwui_skia_track_events_; }
+  void set_hwui_skia_track_events(bool value) { hwui_skia_track_events_ = value; _has_field_.set(2); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PropertyName kPropertyName() { return {}; }
-  void add_property_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_PropertyName::kFieldId, data, size);
-  }
-  void add_property_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_PropertyName::kFieldId, chars.data, chars.size);
-  }
-  void add_property_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_PropertyName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  const std::vector<std::string>& hwui_package_name_filter() const { return hwui_package_name_filter_; }
+  std::vector<std::string>* mutable_hwui_package_name_filter() { return &hwui_package_name_filter_; }
+  int hwui_package_name_filter_size() const { return static_cast<int>(hwui_package_name_filter_.size()); }
+  void clear_hwui_package_name_filter() { hwui_package_name_filter_.clear(); }
+  void add_hwui_package_name_filter(std::string value) { hwui_package_name_filter_.emplace_back(value); }
+  std::string* add_hwui_package_name_filter() { hwui_package_name_filter_.emplace_back(); return &hwui_package_name_filter_.back(); }
+
+ private:
+  bool surfaceflinger_skia_track_events_{};
+  bool hwui_skia_track_events_{};
+  std::vector<std::string> hwui_package_name_filter_;
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<4> _has_field_{};
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/android/network_trace_config.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_NETWORK_TRACE_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_NETWORK_TRACE_CONFIG_PROTO_H_
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_SDK_SYSPROP_GUARD_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_system_property_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_SYSTEM_PROPERTY_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_SYSTEM_PROPERTY_CONFIG_PROTO_CPP_H_
 
-#include <stddef.h>
 #include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
 namespace perfetto {
 namespace protos {
-namespace pbzero {
+namespace gen {
+class AndroidSystemPropertyConfig;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-class NetworkPacketTraceConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  NetworkPacketTraceConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit NetworkPacketTraceConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit NetworkPacketTraceConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_poll_ms() const { return at<1>().valid(); }
-  uint32_t poll_ms() const { return at<1>().as_uint32(); }
-};
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-class NetworkPacketTraceConfig : public ::protozero::Message {
+class PERFETTO_EXPORT_COMPONENT AndroidSystemPropertyConfig : public ::protozero::CppMessageObj {
  public:
-  using Decoder = NetworkPacketTraceConfig_Decoder;
-  enum : int32_t {
+  enum FieldNumbers {
     kPollMsFieldNumber = 1,
+    kPropertyNameFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.NetworkPacketTraceConfig"; }
 
+  AndroidSystemPropertyConfig();
+  ~AndroidSystemPropertyConfig() override;
+  AndroidSystemPropertyConfig(AndroidSystemPropertyConfig&&) noexcept;
+  AndroidSystemPropertyConfig& operator=(AndroidSystemPropertyConfig&&);
+  AndroidSystemPropertyConfig(const AndroidSystemPropertyConfig&);
+  AndroidSystemPropertyConfig& operator=(const AndroidSystemPropertyConfig&);
+  bool operator==(const AndroidSystemPropertyConfig&) const;
+  bool operator!=(const AndroidSystemPropertyConfig& other) const { return !(*this == other); }
 
-  using FieldMetadata_PollMs =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      NetworkPacketTraceConfig>;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PollMs kPollMs() { return {}; }
-  void set_poll_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PollMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  bool has_poll_ms() const { return _has_field_[1]; }
+  uint32_t poll_ms() const { return poll_ms_; }
+  void set_poll_ms(uint32_t value) { poll_ms_ = value; _has_field_.set(1); }
+
+  const std::vector<std::string>& property_name() const { return property_name_; }
+  std::vector<std::string>* mutable_property_name() { return &property_name_; }
+  int property_name_size() const { return static_cast<int>(property_name_.size()); }
+  void clear_property_name() { property_name_.clear(); }
+  void add_property_name(std::string value) { property_name_.emplace_back(value); }
+  std::string* add_property_name() { property_name_.emplace_back(); return &property_name_.back(); }
+
+ private:
+  uint32_t poll_ms_{};
+  std::vector<std::string> property_name_;
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<3> _has_field_{};
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/android/packages_list_config.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PACKAGES_LIST_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PACKAGES_LIST_CONFIG_PROTO_H_
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_SYSTEM_PROPERTY_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/app_wakelock_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_APP_WAKELOCK_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_APP_WAKELOCK_CONFIG_PROTO_CPP_H_
 
-#include <stddef.h>
 #include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
 namespace perfetto {
 namespace protos {
-namespace pbzero {
+namespace gen {
+class AppWakelocksConfig;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-class PackagesListConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  PackagesListConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit PackagesListConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit PackagesListConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_package_name_filter() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> package_name_filter() const { return GetRepeated<::protozero::ConstChars>(1); }
-};
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-class PackagesListConfig : public ::protozero::Message {
+class PERFETTO_EXPORT_COMPONENT AppWakelocksConfig : public ::protozero::CppMessageObj {
  public:
-  using Decoder = PackagesListConfig_Decoder;
-  enum : int32_t {
-    kPackageNameFilterFieldNumber = 1,
+  enum FieldNumbers {
+    kWriteDelayMsFieldNumber = 1,
+    kFilterDurationBelowMsFieldNumber = 2,
+    kDropOwnerPidFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.PackagesListConfig"; }
 
+  AppWakelocksConfig();
+  ~AppWakelocksConfig() override;
+  AppWakelocksConfig(AppWakelocksConfig&&) noexcept;
+  AppWakelocksConfig& operator=(AppWakelocksConfig&&);
+  AppWakelocksConfig(const AppWakelocksConfig&);
+  AppWakelocksConfig& operator=(const AppWakelocksConfig&);
+  bool operator==(const AppWakelocksConfig&) const;
+  bool operator!=(const AppWakelocksConfig& other) const { return !(*this == other); }
 
-  using FieldMetadata_PackageNameFilter =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      PackagesListConfig>;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PackageNameFilter kPackageNameFilter() { return {}; }
-  void add_package_name_filter(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_PackageNameFilter::kFieldId, data, size);
-  }
-  void add_package_name_filter(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_PackageNameFilter::kFieldId, chars.data, chars.size);
-  }
-  void add_package_name_filter(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_PackageNameFilter::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  bool has_write_delay_ms() const { return _has_field_[1]; }
+  int32_t write_delay_ms() const { return write_delay_ms_; }
+  void set_write_delay_ms(int32_t value) { write_delay_ms_ = value; _has_field_.set(1); }
+
+  bool has_filter_duration_below_ms() const { return _has_field_[2]; }
+  int32_t filter_duration_below_ms() const { return filter_duration_below_ms_; }
+  void set_filter_duration_below_ms(int32_t value) { filter_duration_below_ms_ = value; _has_field_.set(2); }
+
+  bool has_drop_owner_pid() const { return _has_field_[3]; }
+  bool drop_owner_pid() const { return drop_owner_pid_; }
+  void set_drop_owner_pid(bool value) { drop_owner_pid_ = value; _has_field_.set(3); }
+
+ private:
+  int32_t write_delay_ms_{};
+  int32_t filter_duration_below_ms_{};
+  bool drop_owner_pid_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<4> _has_field_{};
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/ftrace/ftrace_config.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_FTRACE_FTRACE_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_FTRACE_FTRACE_CONFIG_PROTO_H_
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_APP_WAKELOCK_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/cpu_per_uid_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_CPU_PER_UID_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_CPU_PER_UID_CONFIG_PROTO_CPP_H_
 
-#include <stddef.h>
 #include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
 namespace perfetto {
 namespace protos {
-namespace pbzero {
+namespace gen {
+class CpuPerUidConfig;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-class FtraceConfig_CompactSchedConfig;
-class FtraceConfig_PrintFilter;
-class FtraceConfig_PrintFilter_Rule;
-class FtraceConfig_PrintFilter_Rule_AtraceMessage;
-namespace perfetto_pbzero_enum_FtraceConfig {
-enum KsymsMemPolicy : int32_t;
-}  // namespace perfetto_pbzero_enum_FtraceConfig
-using FtraceConfig_KsymsMemPolicy = perfetto_pbzero_enum_FtraceConfig::KsymsMemPolicy;
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-namespace perfetto_pbzero_enum_FtraceConfig {
-enum KsymsMemPolicy : int32_t {
-  KSYMS_UNSPECIFIED = 0,
-  KSYMS_CLEANUP_ON_STOP = 1,
-  KSYMS_RETAIN = 2,
-};
-} // namespace perfetto_pbzero_enum_FtraceConfig
-using FtraceConfig_KsymsMemPolicy = perfetto_pbzero_enum_FtraceConfig::KsymsMemPolicy;
+namespace perfetto {
+namespace protos {
+namespace gen {
 
+class PERFETTO_EXPORT_COMPONENT CpuPerUidConfig : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kPollMsFieldNumber = 1,
+  };
 
-constexpr FtraceConfig_KsymsMemPolicy FtraceConfig_KsymsMemPolicy_MIN = FtraceConfig_KsymsMemPolicy::KSYMS_UNSPECIFIED;
-constexpr FtraceConfig_KsymsMemPolicy FtraceConfig_KsymsMemPolicy_MAX = FtraceConfig_KsymsMemPolicy::KSYMS_RETAIN;
+  CpuPerUidConfig();
+  ~CpuPerUidConfig() override;
+  CpuPerUidConfig(CpuPerUidConfig&&) noexcept;
+  CpuPerUidConfig& operator=(CpuPerUidConfig&&);
+  CpuPerUidConfig(const CpuPerUidConfig&);
+  CpuPerUidConfig& operator=(const CpuPerUidConfig&);
+  bool operator==(const CpuPerUidConfig&) const;
+  bool operator!=(const CpuPerUidConfig& other) const { return !(*this == other); }
 
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* FtraceConfig_KsymsMemPolicy_Name(::perfetto::protos::pbzero::FtraceConfig_KsymsMemPolicy value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::FtraceConfig_KsymsMemPolicy::KSYMS_UNSPECIFIED:
-    return "KSYMS_UNSPECIFIED";
+  bool has_poll_ms() const { return _has_field_[1]; }
+  uint32_t poll_ms() const { return poll_ms_; }
+  void set_poll_ms(uint32_t value) { poll_ms_ = value; _has_field_.set(1); }
 
-  case ::perfetto::protos::pbzero::FtraceConfig_KsymsMemPolicy::KSYMS_CLEANUP_ON_STOP:
-    return "KSYMS_CLEANUP_ON_STOP";
+ private:
+  uint32_t poll_ms_{};
 
-  case ::perfetto::protos::pbzero::FtraceConfig_KsymsMemPolicy::KSYMS_RETAIN:
-    return "KSYMS_RETAIN";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-class FtraceConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/24, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  FtraceConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit FtraceConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit FtraceConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_ftrace_events() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> ftrace_events() const { return GetRepeated<::protozero::ConstChars>(1); }
-  bool has_atrace_categories() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> atrace_categories() const { return GetRepeated<::protozero::ConstChars>(2); }
-  bool has_atrace_apps() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> atrace_apps() const { return GetRepeated<::protozero::ConstChars>(3); }
-  bool has_buffer_size_kb() const { return at<10>().valid(); }
-  uint32_t buffer_size_kb() const { return at<10>().as_uint32(); }
-  bool has_drain_period_ms() const { return at<11>().valid(); }
-  uint32_t drain_period_ms() const { return at<11>().as_uint32(); }
-  bool has_compact_sched() const { return at<12>().valid(); }
-  ::protozero::ConstBytes compact_sched() const { return at<12>().as_bytes(); }
-  bool has_print_filter() const { return at<22>().valid(); }
-  ::protozero::ConstBytes print_filter() const { return at<22>().as_bytes(); }
-  bool has_symbolize_ksyms() const { return at<13>().valid(); }
-  bool symbolize_ksyms() const { return at<13>().as_bool(); }
-  bool has_ksyms_mem_policy() const { return at<17>().valid(); }
-  int32_t ksyms_mem_policy() const { return at<17>().as_int32(); }
-  bool has_initialize_ksyms_synchronously_for_testing() const { return at<14>().valid(); }
-  bool initialize_ksyms_synchronously_for_testing() const { return at<14>().as_bool(); }
-  bool has_throttle_rss_stat() const { return at<15>().valid(); }
-  bool throttle_rss_stat() const { return at<15>().as_bool(); }
-  bool has_disable_generic_events() const { return at<16>().valid(); }
-  bool disable_generic_events() const { return at<16>().as_bool(); }
-  bool has_syscall_events() const { return at<18>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> syscall_events() const { return GetRepeated<::protozero::ConstChars>(18); }
-  bool has_enable_function_graph() const { return at<19>().valid(); }
-  bool enable_function_graph() const { return at<19>().as_bool(); }
-  bool has_function_filters() const { return at<20>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> function_filters() const { return GetRepeated<::protozero::ConstChars>(20); }
-  bool has_function_graph_roots() const { return at<21>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> function_graph_roots() const { return GetRepeated<::protozero::ConstChars>(21); }
-  bool has_preserve_ftrace_buffer() const { return at<23>().valid(); }
-  bool preserve_ftrace_buffer() const { return at<23>().as_bool(); }
-  bool has_use_monotonic_raw_clock() const { return at<24>().valid(); }
-  bool use_monotonic_raw_clock() const { return at<24>().as_bool(); }
+  std::bitset<2> _has_field_{};
 };
 
-class FtraceConfig : public ::protozero::Message {
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_CPU_PER_UID_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/inputmethod_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_INPUTMETHOD_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_INPUTMETHOD_CONFIG_PROTO_CPP_H_
+
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+class InputMethodConfig;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+namespace protozero {
+class Message;
+}  // namespace protozero
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+
+class PERFETTO_EXPORT_COMPONENT InputMethodConfig : public ::protozero::CppMessageObj {
  public:
-  using Decoder = FtraceConfig_Decoder;
-  enum : int32_t {
-    kFtraceEventsFieldNumber = 1,
-    kAtraceCategoriesFieldNumber = 2,
-    kAtraceAppsFieldNumber = 3,
-    kBufferSizeKbFieldNumber = 10,
-    kDrainPeriodMsFieldNumber = 11,
-    kCompactSchedFieldNumber = 12,
-    kPrintFilterFieldNumber = 22,
-    kSymbolizeKsymsFieldNumber = 13,
-    kKsymsMemPolicyFieldNumber = 17,
-    kInitializeKsymsSynchronouslyForTestingFieldNumber = 14,
-    kThrottleRssStatFieldNumber = 15,
-    kDisableGenericEventsFieldNumber = 16,
-    kSyscallEventsFieldNumber = 18,
-    kEnableFunctionGraphFieldNumber = 19,
-    kFunctionFiltersFieldNumber = 20,
-    kFunctionGraphRootsFieldNumber = 21,
-    kPreserveFtraceBufferFieldNumber = 23,
-    kUseMonotonicRawClockFieldNumber = 24,
+  enum FieldNumbers {
+    kClientFieldNumber = 1,
+    kServiceFieldNumber = 2,
+    kManagerServiceFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.FtraceConfig"; }
 
-  using CompactSchedConfig = ::perfetto::protos::pbzero::FtraceConfig_CompactSchedConfig;
-  using PrintFilter = ::perfetto::protos::pbzero::FtraceConfig_PrintFilter;
+  InputMethodConfig();
+  ~InputMethodConfig() override;
+  InputMethodConfig(InputMethodConfig&&) noexcept;
+  InputMethodConfig& operator=(InputMethodConfig&&);
+  InputMethodConfig(const InputMethodConfig&);
+  InputMethodConfig& operator=(const InputMethodConfig&);
+  bool operator==(const InputMethodConfig&) const;
+  bool operator!=(const InputMethodConfig& other) const { return !(*this == other); }
 
-  using KsymsMemPolicy = ::perfetto::protos::pbzero::FtraceConfig_KsymsMemPolicy;
-  static inline const char* KsymsMemPolicy_Name(KsymsMemPolicy value) {
-    return ::perfetto::protos::pbzero::FtraceConfig_KsymsMemPolicy_Name(value);
-  }
-  static const KsymsMemPolicy KSYMS_UNSPECIFIED = KsymsMemPolicy::KSYMS_UNSPECIFIED;
-  static const KsymsMemPolicy KSYMS_CLEANUP_ON_STOP = KsymsMemPolicy::KSYMS_CLEANUP_ON_STOP;
-  static const KsymsMemPolicy KSYMS_RETAIN = KsymsMemPolicy::KSYMS_RETAIN;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  using FieldMetadata_FtraceEvents =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      FtraceConfig>;
+  bool has_client() const { return _has_field_[1]; }
+  bool client() const { return client_; }
+  void set_client(bool value) { client_ = value; _has_field_.set(1); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FtraceEvents kFtraceEvents() { return {}; }
-  void add_ftrace_events(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_FtraceEvents::kFieldId, data, size);
-  }
-  void add_ftrace_events(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_FtraceEvents::kFieldId, chars.data, chars.size);
-  }
-  void add_ftrace_events(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_FtraceEvents::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  bool has_service() const { return _has_field_[2]; }
+  bool service() const { return service_; }
+  void set_service(bool value) { service_ = value; _has_field_.set(2); }
 
-  using FieldMetadata_AtraceCategories =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      FtraceConfig>;
+  bool has_manager_service() const { return _has_field_[3]; }
+  bool manager_service() const { return manager_service_; }
+  void set_manager_service(bool value) { manager_service_ = value; _has_field_.set(3); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AtraceCategories kAtraceCategories() { return {}; }
-  void add_atrace_categories(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_AtraceCategories::kFieldId, data, size);
-  }
-  void add_atrace_categories(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_AtraceCategories::kFieldId, chars.data, chars.size);
-  }
-  void add_atrace_categories(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_AtraceCategories::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+ private:
+  bool client_{};
+  bool service_{};
+  bool manager_service_{};
 
-  using FieldMetadata_AtraceApps =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      FtraceConfig>;
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AtraceApps kAtraceApps() { return {}; }
-  void add_atrace_apps(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_AtraceApps::kFieldId, data, size);
-  }
-  void add_atrace_apps(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_AtraceApps::kFieldId, chars.data, chars.size);
-  }
-  void add_atrace_apps(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_AtraceApps::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  std::bitset<4> _has_field_{};
+};
 
-  using FieldMetadata_BufferSizeKb =
-    ::protozero::proto_utils::FieldMetadata<
-      10,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      FtraceConfig>;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BufferSizeKb kBufferSizeKb() { return {}; }
-  void set_buffer_size_kb(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BufferSizeKb::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_INPUTMETHOD_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/kernel_wakelocks_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_KERNEL_WAKELOCKS_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_KERNEL_WAKELOCKS_CONFIG_PROTO_CPP_H_
 
-  using FieldMetadata_DrainPeriodMs =
-    ::protozero::proto_utils::FieldMetadata<
-      11,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      FtraceConfig>;
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DrainPeriodMs kDrainPeriodMs() { return {}; }
-  void set_drain_period_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DrainPeriodMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  using FieldMetadata_CompactSched =
-    ::protozero::proto_utils::FieldMetadata<
-      12,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      FtraceConfig_CompactSchedConfig,
-      FtraceConfig>;
+namespace perfetto {
+namespace protos {
+namespace gen {
+class KernelWakelocksConfig;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CompactSched kCompactSched() { return {}; }
-  template <typename T = FtraceConfig_CompactSchedConfig> T* set_compact_sched() {
-    return BeginNestedMessage<T>(12);
-  }
+namespace protozero {
+class Message;
+}  // namespace protozero
 
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-  using FieldMetadata_PrintFilter =
-    ::protozero::proto_utils::FieldMetadata<
-      22,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      FtraceConfig_PrintFilter,
-      FtraceConfig>;
+class PERFETTO_EXPORT_COMPONENT KernelWakelocksConfig : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kPollMsFieldNumber = 1,
+  };
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PrintFilter kPrintFilter() { return {}; }
-  template <typename T = FtraceConfig_PrintFilter> T* set_print_filter() {
-    return BeginNestedMessage<T>(22);
-  }
+  KernelWakelocksConfig();
+  ~KernelWakelocksConfig() override;
+  KernelWakelocksConfig(KernelWakelocksConfig&&) noexcept;
+  KernelWakelocksConfig& operator=(KernelWakelocksConfig&&);
+  KernelWakelocksConfig(const KernelWakelocksConfig&);
+  KernelWakelocksConfig& operator=(const KernelWakelocksConfig&);
+  bool operator==(const KernelWakelocksConfig&) const;
+  bool operator!=(const KernelWakelocksConfig& other) const { return !(*this == other); }
 
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  using FieldMetadata_SymbolizeKsyms =
-    ::protozero::proto_utils::FieldMetadata<
-      13,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      FtraceConfig>;
+  bool has_poll_ms() const { return _has_field_[1]; }
+  uint32_t poll_ms() const { return poll_ms_; }
+  void set_poll_ms(uint32_t value) { poll_ms_ = value; _has_field_.set(1); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SymbolizeKsyms kSymbolizeKsyms() { return {}; }
-  void set_symbolize_ksyms(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_SymbolizeKsyms::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+ private:
+  uint32_t poll_ms_{};
 
-  using FieldMetadata_KsymsMemPolicy =
-    ::protozero::proto_utils::FieldMetadata<
-      17,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::FtraceConfig_KsymsMemPolicy,
-      FtraceConfig>;
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KsymsMemPolicy kKsymsMemPolicy() { return {}; }
-  void set_ksyms_mem_policy(::perfetto::protos::pbzero::FtraceConfig_KsymsMemPolicy value) {
-    static constexpr uint32_t field_id = FieldMetadata_KsymsMemPolicy::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
+  std::bitset<2> _has_field_{};
+};
 
-  using FieldMetadata_InitializeKsymsSynchronouslyForTesting =
-    ::protozero::proto_utils::FieldMetadata<
-      14,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      FtraceConfig>;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InitializeKsymsSynchronouslyForTesting kInitializeKsymsSynchronouslyForTesting() { return {}; }
-  void set_initialize_ksyms_synchronously_for_testing(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_InitializeKsymsSynchronouslyForTesting::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_KERNEL_WAKELOCKS_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/network_trace_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_NETWORK_TRACE_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_NETWORK_TRACE_CONFIG_PROTO_CPP_H_
 
-  using FieldMetadata_ThrottleRssStat =
-    ::protozero::proto_utils::FieldMetadata<
-      15,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      FtraceConfig>;
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThrottleRssStat kThrottleRssStat() { return {}; }
-  void set_throttle_rss_stat(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_ThrottleRssStat::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  using FieldMetadata_DisableGenericEvents =
-    ::protozero::proto_utils::FieldMetadata<
-      16,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      FtraceConfig>;
+namespace perfetto {
+namespace protos {
+namespace gen {
+class NetworkPacketTraceConfig;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DisableGenericEvents kDisableGenericEvents() { return {}; }
-  void set_disable_generic_events(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DisableGenericEvents::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  using FieldMetadata_SyscallEvents =
-    ::protozero::proto_utils::FieldMetadata<
-      18,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      FtraceConfig>;
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SyscallEvents kSyscallEvents() { return {}; }
-  void add_syscall_events(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_SyscallEvents::kFieldId, data, size);
-  }
-  void add_syscall_events(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_SyscallEvents::kFieldId, chars.data, chars.size);
-  }
-  void add_syscall_events(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_SyscallEvents::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+class PERFETTO_EXPORT_COMPONENT NetworkPacketTraceConfig : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kPollMsFieldNumber = 1,
+    kAggregationThresholdFieldNumber = 2,
+    kInternLimitFieldNumber = 3,
+    kDropLocalPortFieldNumber = 4,
+    kDropRemotePortFieldNumber = 5,
+    kDropTcpFlagsFieldNumber = 6,
+  };
 
-  using FieldMetadata_EnableFunctionGraph =
-    ::protozero::proto_utils::FieldMetadata<
-      19,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      FtraceConfig>;
+  NetworkPacketTraceConfig();
+  ~NetworkPacketTraceConfig() override;
+  NetworkPacketTraceConfig(NetworkPacketTraceConfig&&) noexcept;
+  NetworkPacketTraceConfig& operator=(NetworkPacketTraceConfig&&);
+  NetworkPacketTraceConfig(const NetworkPacketTraceConfig&);
+  NetworkPacketTraceConfig& operator=(const NetworkPacketTraceConfig&);
+  bool operator==(const NetworkPacketTraceConfig&) const;
+  bool operator!=(const NetworkPacketTraceConfig& other) const { return !(*this == other); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EnableFunctionGraph kEnableFunctionGraph() { return {}; }
-  void set_enable_function_graph(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_EnableFunctionGraph::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  using FieldMetadata_FunctionFilters =
-    ::protozero::proto_utils::FieldMetadata<
-      20,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      FtraceConfig>;
+  bool has_poll_ms() const { return _has_field_[1]; }
+  uint32_t poll_ms() const { return poll_ms_; }
+  void set_poll_ms(uint32_t value) { poll_ms_ = value; _has_field_.set(1); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FunctionFilters kFunctionFilters() { return {}; }
-  void add_function_filters(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_FunctionFilters::kFieldId, data, size);
-  }
-  void add_function_filters(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_FunctionFilters::kFieldId, chars.data, chars.size);
-  }
-  void add_function_filters(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_FunctionFilters::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  bool has_aggregation_threshold() const { return _has_field_[2]; }
+  uint32_t aggregation_threshold() const { return aggregation_threshold_; }
+  void set_aggregation_threshold(uint32_t value) { aggregation_threshold_ = value; _has_field_.set(2); }
 
-  using FieldMetadata_FunctionGraphRoots =
-    ::protozero::proto_utils::FieldMetadata<
-      21,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      FtraceConfig>;
+  bool has_intern_limit() const { return _has_field_[3]; }
+  uint32_t intern_limit() const { return intern_limit_; }
+  void set_intern_limit(uint32_t value) { intern_limit_ = value; _has_field_.set(3); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FunctionGraphRoots kFunctionGraphRoots() { return {}; }
-  void add_function_graph_roots(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_FunctionGraphRoots::kFieldId, data, size);
-  }
-  void add_function_graph_roots(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_FunctionGraphRoots::kFieldId, chars.data, chars.size);
-  }
-  void add_function_graph_roots(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_FunctionGraphRoots::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  bool has_drop_local_port() const { return _has_field_[4]; }
+  bool drop_local_port() const { return drop_local_port_; }
+  void set_drop_local_port(bool value) { drop_local_port_ = value; _has_field_.set(4); }
 
-  using FieldMetadata_PreserveFtraceBuffer =
-    ::protozero::proto_utils::FieldMetadata<
-      23,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      FtraceConfig>;
+  bool has_drop_remote_port() const { return _has_field_[5]; }
+  bool drop_remote_port() const { return drop_remote_port_; }
+  void set_drop_remote_port(bool value) { drop_remote_port_ = value; _has_field_.set(5); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PreserveFtraceBuffer kPreserveFtraceBuffer() { return {}; }
-  void set_preserve_ftrace_buffer(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_PreserveFtraceBuffer::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  bool has_drop_tcp_flags() const { return _has_field_[6]; }
+  bool drop_tcp_flags() const { return drop_tcp_flags_; }
+  void set_drop_tcp_flags(bool value) { drop_tcp_flags_ = value; _has_field_.set(6); }
 
-  using FieldMetadata_UseMonotonicRawClock =
-    ::protozero::proto_utils::FieldMetadata<
-      24,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      FtraceConfig>;
+ private:
+  uint32_t poll_ms_{};
+  uint32_t aggregation_threshold_{};
+  uint32_t intern_limit_{};
+  bool drop_local_port_{};
+  bool drop_remote_port_{};
+  bool drop_tcp_flags_{};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UseMonotonicRawClock kUseMonotonicRawClock() { return {}; }
-  void set_use_monotonic_raw_clock(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_UseMonotonicRawClock::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-};
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-class FtraceConfig_PrintFilter_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  FtraceConfig_PrintFilter_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit FtraceConfig_PrintFilter_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit FtraceConfig_PrintFilter_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_rules() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> rules() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  std::bitset<7> _has_field_{};
 };
 
-class FtraceConfig_PrintFilter : public ::protozero::Message {
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_NETWORK_TRACE_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/packages_list_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PACKAGES_LIST_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PACKAGES_LIST_CONFIG_PROTO_CPP_H_
+
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+class PackagesListConfig;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+namespace protozero {
+class Message;
+}  // namespace protozero
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+
+class PERFETTO_EXPORT_COMPONENT PackagesListConfig : public ::protozero::CppMessageObj {
  public:
-  using Decoder = FtraceConfig_PrintFilter_Decoder;
-  enum : int32_t {
-    kRulesFieldNumber = 1,
+  enum FieldNumbers {
+    kPackageNameFilterFieldNumber = 1,
+    kOnlyWriteOnCpuUseEveryMsFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.FtraceConfig.PrintFilter"; }
 
-  using Rule = ::perfetto::protos::pbzero::FtraceConfig_PrintFilter_Rule;
+  PackagesListConfig();
+  ~PackagesListConfig() override;
+  PackagesListConfig(PackagesListConfig&&) noexcept;
+  PackagesListConfig& operator=(PackagesListConfig&&);
+  PackagesListConfig(const PackagesListConfig&);
+  PackagesListConfig& operator=(const PackagesListConfig&);
+  bool operator==(const PackagesListConfig&) const;
+  bool operator!=(const PackagesListConfig& other) const { return !(*this == other); }
 
-  using FieldMetadata_Rules =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      FtraceConfig_PrintFilter_Rule,
-      FtraceConfig_PrintFilter>;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Rules kRules() { return {}; }
-  template <typename T = FtraceConfig_PrintFilter_Rule> T* add_rules() {
-    return BeginNestedMessage<T>(1);
-  }
+  const std::vector<std::string>& package_name_filter() const { return package_name_filter_; }
+  std::vector<std::string>* mutable_package_name_filter() { return &package_name_filter_; }
+  int package_name_filter_size() const { return static_cast<int>(package_name_filter_.size()); }
+  void clear_package_name_filter() { package_name_filter_.clear(); }
+  void add_package_name_filter(std::string value) { package_name_filter_.emplace_back(value); }
+  std::string* add_package_name_filter() { package_name_filter_.emplace_back(); return &package_name_filter_.back(); }
+
+  bool has_only_write_on_cpu_use_every_ms() const { return _has_field_[2]; }
+  uint32_t only_write_on_cpu_use_every_ms() const { return only_write_on_cpu_use_every_ms_; }
+  void set_only_write_on_cpu_use_every_ms(uint32_t value) { only_write_on_cpu_use_every_ms_ = value; _has_field_.set(2); }
+
+ private:
+  std::vector<std::string> package_name_filter_;
+  uint32_t only_write_on_cpu_use_every_ms_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
+  std::bitset<3> _has_field_{};
 };
 
-class FtraceConfig_PrintFilter_Rule_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  FtraceConfig_PrintFilter_Rule_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit FtraceConfig_PrintFilter_Rule_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit FtraceConfig_PrintFilter_Rule_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_prefix() const { return at<1>().valid(); }
-  ::protozero::ConstChars prefix() const { return at<1>().as_string(); }
-  bool has_atrace_msg() const { return at<3>().valid(); }
-  ::protozero::ConstBytes atrace_msg() const { return at<3>().as_bytes(); }
-  bool has_allow() const { return at<2>().valid(); }
-  bool allow() const { return at<2>().as_bool(); }
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PACKAGES_LIST_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/pixel_modem_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PIXEL_MODEM_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PIXEL_MODEM_CONFIG_PROTO_CPP_H_
+
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+class PixelModemConfig;
+enum PixelModemConfig_EventGroup : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+namespace protozero {
+class Message;
+}  // namespace protozero
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum PixelModemConfig_EventGroup : int {
+  PixelModemConfig_EventGroup_EVENT_GROUP_UNKNOWN = 0,
+  PixelModemConfig_EventGroup_EVENT_GROUP_LOW_BANDWIDTH = 1,
+  PixelModemConfig_EventGroup_EVENT_GROUP_HIGH_AND_LOW_BANDWIDTH = 2,
 };
 
-class FtraceConfig_PrintFilter_Rule : public ::protozero::Message {
+class PERFETTO_EXPORT_COMPONENT PixelModemConfig : public ::protozero::CppMessageObj {
  public:
-  using Decoder = FtraceConfig_PrintFilter_Rule_Decoder;
-  enum : int32_t {
-    kPrefixFieldNumber = 1,
-    kAtraceMsgFieldNumber = 3,
-    kAllowFieldNumber = 2,
+  using EventGroup = PixelModemConfig_EventGroup;
+  static constexpr auto EVENT_GROUP_UNKNOWN = PixelModemConfig_EventGroup_EVENT_GROUP_UNKNOWN;
+  static constexpr auto EVENT_GROUP_LOW_BANDWIDTH = PixelModemConfig_EventGroup_EVENT_GROUP_LOW_BANDWIDTH;
+  static constexpr auto EVENT_GROUP_HIGH_AND_LOW_BANDWIDTH = PixelModemConfig_EventGroup_EVENT_GROUP_HIGH_AND_LOW_BANDWIDTH;
+  static constexpr auto EventGroup_MIN = PixelModemConfig_EventGroup_EVENT_GROUP_UNKNOWN;
+  static constexpr auto EventGroup_MAX = PixelModemConfig_EventGroup_EVENT_GROUP_HIGH_AND_LOW_BANDWIDTH;
+  enum FieldNumbers {
+    kEventGroupFieldNumber = 1,
+    kPigweedHashAllowListFieldNumber = 2,
+    kPigweedHashDenyListFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.FtraceConfig.PrintFilter.Rule"; }
 
-  using AtraceMessage = ::perfetto::protos::pbzero::FtraceConfig_PrintFilter_Rule_AtraceMessage;
+  PixelModemConfig();
+  ~PixelModemConfig() override;
+  PixelModemConfig(PixelModemConfig&&) noexcept;
+  PixelModemConfig& operator=(PixelModemConfig&&);
+  PixelModemConfig(const PixelModemConfig&);
+  PixelModemConfig& operator=(const PixelModemConfig&);
+  bool operator==(const PixelModemConfig&) const;
+  bool operator!=(const PixelModemConfig& other) const { return !(*this == other); }
 
-  using FieldMetadata_Prefix =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      FtraceConfig_PrintFilter_Rule>;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Prefix kPrefix() { return {}; }
-  void set_prefix(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Prefix::kFieldId, data, size);
-  }
-  void set_prefix(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Prefix::kFieldId, chars.data, chars.size);
-  }
-  void set_prefix(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Prefix::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  bool has_event_group() const { return _has_field_[1]; }
+  PixelModemConfig_EventGroup event_group() const { return event_group_; }
+  void set_event_group(PixelModemConfig_EventGroup value) { event_group_ = value; _has_field_.set(1); }
 
-  using FieldMetadata_AtraceMsg =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      FtraceConfig_PrintFilter_Rule_AtraceMessage,
-      FtraceConfig_PrintFilter_Rule>;
+  const std::vector<int64_t>& pigweed_hash_allow_list() const { return pigweed_hash_allow_list_; }
+  std::vector<int64_t>* mutable_pigweed_hash_allow_list() { return &pigweed_hash_allow_list_; }
+  int pigweed_hash_allow_list_size() const { return static_cast<int>(pigweed_hash_allow_list_.size()); }
+  void clear_pigweed_hash_allow_list() { pigweed_hash_allow_list_.clear(); }
+  void add_pigweed_hash_allow_list(int64_t value) { pigweed_hash_allow_list_.emplace_back(value); }
+  int64_t* add_pigweed_hash_allow_list() { pigweed_hash_allow_list_.emplace_back(); return &pigweed_hash_allow_list_.back(); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AtraceMsg kAtraceMsg() { return {}; }
-  template <typename T = FtraceConfig_PrintFilter_Rule_AtraceMessage> T* set_atrace_msg() {
-    return BeginNestedMessage<T>(3);
-  }
+  const std::vector<int64_t>& pigweed_hash_deny_list() const { return pigweed_hash_deny_list_; }
+  std::vector<int64_t>* mutable_pigweed_hash_deny_list() { return &pigweed_hash_deny_list_; }
+  int pigweed_hash_deny_list_size() const { return static_cast<int>(pigweed_hash_deny_list_.size()); }
+  void clear_pigweed_hash_deny_list() { pigweed_hash_deny_list_.clear(); }
+  void add_pigweed_hash_deny_list(int64_t value) { pigweed_hash_deny_list_.emplace_back(value); }
+  int64_t* add_pigweed_hash_deny_list() { pigweed_hash_deny_list_.emplace_back(); return &pigweed_hash_deny_list_.back(); }
 
+ private:
+  PixelModemConfig_EventGroup event_group_{};
+  std::vector<int64_t> pigweed_hash_allow_list_;
+  std::vector<int64_t> pigweed_hash_deny_list_;
 
-  using FieldMetadata_Allow =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      FtraceConfig_PrintFilter_Rule>;
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Allow kAllow() { return {}; }
-  void set_allow(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_Allow::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  std::bitset<4> _has_field_{};
 };
 
-class FtraceConfig_PrintFilter_Rule_AtraceMessage_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  FtraceConfig_PrintFilter_Rule_AtraceMessage_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit FtraceConfig_PrintFilter_Rule_AtraceMessage_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit FtraceConfig_PrintFilter_Rule_AtraceMessage_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_type() const { return at<1>().valid(); }
-  ::protozero::ConstChars type() const { return at<1>().as_string(); }
-  bool has_prefix() const { return at<2>().valid(); }
-  ::protozero::ConstChars prefix() const { return at<2>().as_string(); }
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PIXEL_MODEM_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/protolog_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PROTOLOG_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PROTOLOG_CONFIG_PROTO_CPP_H_
+
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+class ProtoLogGroup;
+class ProtoLogConfig;
+enum ProtoLogLevel : int;
+enum ProtoLogConfig_TracingMode : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+namespace protozero {
+class Message;
+}  // namespace protozero
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum ProtoLogConfig_TracingMode : int {
+  ProtoLogConfig_TracingMode_DEFAULT = 0,
+  ProtoLogConfig_TracingMode_ENABLE_ALL = 1,
 };
 
-class FtraceConfig_PrintFilter_Rule_AtraceMessage : public ::protozero::Message {
+class PERFETTO_EXPORT_COMPONENT ProtoLogGroup : public ::protozero::CppMessageObj {
  public:
-  using Decoder = FtraceConfig_PrintFilter_Rule_AtraceMessage_Decoder;
-  enum : int32_t {
-    kTypeFieldNumber = 1,
-    kPrefixFieldNumber = 2,
+  enum FieldNumbers {
+    kGroupNameFieldNumber = 1,
+    kLogFromFieldNumber = 2,
+    kCollectStacktraceFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.FtraceConfig.PrintFilter.Rule.AtraceMessage"; }
 
+  ProtoLogGroup();
+  ~ProtoLogGroup() override;
+  ProtoLogGroup(ProtoLogGroup&&) noexcept;
+  ProtoLogGroup& operator=(ProtoLogGroup&&);
+  ProtoLogGroup(const ProtoLogGroup&);
+  ProtoLogGroup& operator=(const ProtoLogGroup&);
+  bool operator==(const ProtoLogGroup&) const;
+  bool operator!=(const ProtoLogGroup& other) const { return !(*this == other); }
 
-  using FieldMetadata_Type =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      FtraceConfig_PrintFilter_Rule_AtraceMessage>;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Type::kFieldId, data, size);
-  }
-  void set_type(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Type::kFieldId, chars.data, chars.size);
-  }
-  void set_type(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  bool has_group_name() const { return _has_field_[1]; }
+  const std::string& group_name() const { return group_name_; }
+  void set_group_name(const std::string& value) { group_name_ = value; _has_field_.set(1); }
 
-  using FieldMetadata_Prefix =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      FtraceConfig_PrintFilter_Rule_AtraceMessage>;
+  bool has_log_from() const { return _has_field_[2]; }
+  ProtoLogLevel log_from() const { return log_from_; }
+  void set_log_from(ProtoLogLevel value) { log_from_ = value; _has_field_.set(2); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Prefix kPrefix() { return {}; }
-  void set_prefix(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Prefix::kFieldId, data, size);
-  }
-  void set_prefix(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Prefix::kFieldId, chars.data, chars.size);
-  }
-  void set_prefix(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Prefix::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-};
+  bool has_collect_stacktrace() const { return _has_field_[3]; }
+  bool collect_stacktrace() const { return collect_stacktrace_; }
+  void set_collect_stacktrace(bool value) { collect_stacktrace_ = value; _has_field_.set(3); }
 
-class FtraceConfig_CompactSchedConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  FtraceConfig_CompactSchedConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit FtraceConfig_CompactSchedConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit FtraceConfig_CompactSchedConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_enabled() const { return at<1>().valid(); }
-  bool enabled() const { return at<1>().as_bool(); }
+ private:
+  std::string group_name_{};
+  ProtoLogLevel log_from_{};
+  bool collect_stacktrace_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<4> _has_field_{};
 };
 
-class FtraceConfig_CompactSchedConfig : public ::protozero::Message {
+
+class PERFETTO_EXPORT_COMPONENT ProtoLogConfig : public ::protozero::CppMessageObj {
  public:
-  using Decoder = FtraceConfig_CompactSchedConfig_Decoder;
-  enum : int32_t {
-    kEnabledFieldNumber = 1,
+  using TracingMode = ProtoLogConfig_TracingMode;
+  static constexpr auto DEFAULT = ProtoLogConfig_TracingMode_DEFAULT;
+  static constexpr auto ENABLE_ALL = ProtoLogConfig_TracingMode_ENABLE_ALL;
+  static constexpr auto TracingMode_MIN = ProtoLogConfig_TracingMode_DEFAULT;
+  static constexpr auto TracingMode_MAX = ProtoLogConfig_TracingMode_ENABLE_ALL;
+  enum FieldNumbers {
+    kGroupOverridesFieldNumber = 1,
+    kTracingModeFieldNumber = 2,
+    kDefaultLogFromLevelFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.FtraceConfig.CompactSchedConfig"; }
 
+  ProtoLogConfig();
+  ~ProtoLogConfig() override;
+  ProtoLogConfig(ProtoLogConfig&&) noexcept;
+  ProtoLogConfig& operator=(ProtoLogConfig&&);
+  ProtoLogConfig(const ProtoLogConfig&);
+  ProtoLogConfig& operator=(const ProtoLogConfig&);
+  bool operator==(const ProtoLogConfig&) const;
+  bool operator!=(const ProtoLogConfig& other) const { return !(*this == other); }
 
-  using FieldMetadata_Enabled =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      FtraceConfig_CompactSchedConfig>;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Enabled kEnabled() { return {}; }
-  void set_enabled(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_Enabled::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  const std::vector<ProtoLogGroup>& group_overrides() const { return group_overrides_; }
+  std::vector<ProtoLogGroup>* mutable_group_overrides() { return &group_overrides_; }
+  int group_overrides_size() const;
+  void clear_group_overrides();
+  ProtoLogGroup* add_group_overrides();
+
+  bool has_tracing_mode() const { return _has_field_[2]; }
+  ProtoLogConfig_TracingMode tracing_mode() const { return tracing_mode_; }
+  void set_tracing_mode(ProtoLogConfig_TracingMode value) { tracing_mode_ = value; _has_field_.set(2); }
+
+  bool has_default_log_from_level() const { return _has_field_[3]; }
+  ProtoLogLevel default_log_from_level() const { return default_log_from_level_; }
+  void set_default_log_from_level(ProtoLogLevel value) { default_log_from_level_ = value; _has_field_.set(3); }
+
+ private:
+  std::vector<ProtoLogGroup> group_overrides_;
+  ProtoLogConfig_TracingMode tracing_mode_{};
+  ProtoLogLevel default_log_from_level_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<4> _has_field_{};
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/gpu/gpu_counter_config.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_GPU_COUNTER_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_GPU_COUNTER_CONFIG_PROTO_H_
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PROTOLOG_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/surfaceflinger_layers_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_SURFACEFLINGER_LAYERS_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_SURFACEFLINGER_LAYERS_CONFIG_PROTO_CPP_H_
 
-#include <stddef.h>
 #include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
 namespace perfetto {
 namespace protos {
-namespace pbzero {
-
+namespace gen {
+class SurfaceFlingerLayersConfig;
+enum SurfaceFlingerLayersConfig_Mode : int;
+enum SurfaceFlingerLayersConfig_TraceFlag : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-class GpuCounterConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  GpuCounterConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit GpuCounterConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit GpuCounterConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_counter_period_ns() const { return at<1>().valid(); }
-  uint64_t counter_period_ns() const { return at<1>().as_uint64(); }
-  bool has_counter_ids() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint32_t> counter_ids() const { return GetRepeated<uint32_t>(2); }
-  bool has_instrumented_sampling() const { return at<3>().valid(); }
-  bool instrumented_sampling() const { return at<3>().as_bool(); }
-  bool has_fix_gpu_clock() const { return at<4>().valid(); }
-  bool fix_gpu_clock() const { return at<4>().as_bool(); }
-};
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-class GpuCounterConfig : public ::protozero::Message {
- public:
-  using Decoder = GpuCounterConfig_Decoder;
-  enum : int32_t {
-    kCounterPeriodNsFieldNumber = 1,
-    kCounterIdsFieldNumber = 2,
-    kInstrumentedSamplingFieldNumber = 3,
-    kFixGpuClockFieldNumber = 4,
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum SurfaceFlingerLayersConfig_Mode : int {
+  SurfaceFlingerLayersConfig_Mode_MODE_UNSPECIFIED = 0,
+  SurfaceFlingerLayersConfig_Mode_MODE_ACTIVE = 1,
+  SurfaceFlingerLayersConfig_Mode_MODE_GENERATED = 2,
+  SurfaceFlingerLayersConfig_Mode_MODE_DUMP = 3,
+  SurfaceFlingerLayersConfig_Mode_MODE_GENERATED_BUGREPORT_ONLY = 4,
+};
+enum SurfaceFlingerLayersConfig_TraceFlag : int {
+  SurfaceFlingerLayersConfig_TraceFlag_TRACE_FLAG_UNSPECIFIED = 0,
+  SurfaceFlingerLayersConfig_TraceFlag_TRACE_FLAG_INPUT = 2,
+  SurfaceFlingerLayersConfig_TraceFlag_TRACE_FLAG_COMPOSITION = 4,
+  SurfaceFlingerLayersConfig_TraceFlag_TRACE_FLAG_EXTRA = 8,
+  SurfaceFlingerLayersConfig_TraceFlag_TRACE_FLAG_HWC = 16,
+  SurfaceFlingerLayersConfig_TraceFlag_TRACE_FLAG_BUFFERS = 32,
+  SurfaceFlingerLayersConfig_TraceFlag_TRACE_FLAG_VIRTUAL_DISPLAYS = 64,
+  SurfaceFlingerLayersConfig_TraceFlag_TRACE_FLAG_ALL = 14,
+};
+
+class PERFETTO_EXPORT_COMPONENT SurfaceFlingerLayersConfig : public ::protozero::CppMessageObj {
+ public:
+  using Mode = SurfaceFlingerLayersConfig_Mode;
+  static constexpr auto MODE_UNSPECIFIED = SurfaceFlingerLayersConfig_Mode_MODE_UNSPECIFIED;
+  static constexpr auto MODE_ACTIVE = SurfaceFlingerLayersConfig_Mode_MODE_ACTIVE;
+  static constexpr auto MODE_GENERATED = SurfaceFlingerLayersConfig_Mode_MODE_GENERATED;
+  static constexpr auto MODE_DUMP = SurfaceFlingerLayersConfig_Mode_MODE_DUMP;
+  static constexpr auto MODE_GENERATED_BUGREPORT_ONLY = SurfaceFlingerLayersConfig_Mode_MODE_GENERATED_BUGREPORT_ONLY;
+  static constexpr auto Mode_MIN = SurfaceFlingerLayersConfig_Mode_MODE_UNSPECIFIED;
+  static constexpr auto Mode_MAX = SurfaceFlingerLayersConfig_Mode_MODE_GENERATED_BUGREPORT_ONLY;
+  using TraceFlag = SurfaceFlingerLayersConfig_TraceFlag;
+  static constexpr auto TRACE_FLAG_UNSPECIFIED = SurfaceFlingerLayersConfig_TraceFlag_TRACE_FLAG_UNSPECIFIED;
+  static constexpr auto TRACE_FLAG_INPUT = SurfaceFlingerLayersConfig_TraceFlag_TRACE_FLAG_INPUT;
+  static constexpr auto TRACE_FLAG_COMPOSITION = SurfaceFlingerLayersConfig_TraceFlag_TRACE_FLAG_COMPOSITION;
+  static constexpr auto TRACE_FLAG_EXTRA = SurfaceFlingerLayersConfig_TraceFlag_TRACE_FLAG_EXTRA;
+  static constexpr auto TRACE_FLAG_HWC = SurfaceFlingerLayersConfig_TraceFlag_TRACE_FLAG_HWC;
+  static constexpr auto TRACE_FLAG_BUFFERS = SurfaceFlingerLayersConfig_TraceFlag_TRACE_FLAG_BUFFERS;
+  static constexpr auto TRACE_FLAG_VIRTUAL_DISPLAYS = SurfaceFlingerLayersConfig_TraceFlag_TRACE_FLAG_VIRTUAL_DISPLAYS;
+  static constexpr auto TRACE_FLAG_ALL = SurfaceFlingerLayersConfig_TraceFlag_TRACE_FLAG_ALL;
+  static constexpr auto TraceFlag_MIN = SurfaceFlingerLayersConfig_TraceFlag_TRACE_FLAG_UNSPECIFIED;
+  static constexpr auto TraceFlag_MAX = SurfaceFlingerLayersConfig_TraceFlag_TRACE_FLAG_VIRTUAL_DISPLAYS;
+  enum FieldNumbers {
+    kModeFieldNumber = 1,
+    kTraceFlagsFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.GpuCounterConfig"; }
-
-
-  using FieldMetadata_CounterPeriodNs =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      GpuCounterConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CounterPeriodNs kCounterPeriodNs() { return {}; }
-  void set_counter_period_ns(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CounterPeriodNs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
+  SurfaceFlingerLayersConfig();
+  ~SurfaceFlingerLayersConfig() override;
+  SurfaceFlingerLayersConfig(SurfaceFlingerLayersConfig&&) noexcept;
+  SurfaceFlingerLayersConfig& operator=(SurfaceFlingerLayersConfig&&);
+  SurfaceFlingerLayersConfig(const SurfaceFlingerLayersConfig&);
+  SurfaceFlingerLayersConfig& operator=(const SurfaceFlingerLayersConfig&);
+  bool operator==(const SurfaceFlingerLayersConfig&) const;
+  bool operator!=(const SurfaceFlingerLayersConfig& other) const { return !(*this == other); }
 
-  using FieldMetadata_CounterIds =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      GpuCounterConfig>;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CounterIds kCounterIds() { return {}; }
-  void add_counter_ids(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CounterIds::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  bool has_mode() const { return _has_field_[1]; }
+  SurfaceFlingerLayersConfig_Mode mode() const { return mode_; }
+  void set_mode(SurfaceFlingerLayersConfig_Mode value) { mode_ = value; _has_field_.set(1); }
 
-  using FieldMetadata_InstrumentedSampling =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      GpuCounterConfig>;
+  const std::vector<SurfaceFlingerLayersConfig_TraceFlag>& trace_flags() const { return trace_flags_; }
+  std::vector<SurfaceFlingerLayersConfig_TraceFlag>* mutable_trace_flags() { return &trace_flags_; }
+  int trace_flags_size() const { return static_cast<int>(trace_flags_.size()); }
+  void clear_trace_flags() { trace_flags_.clear(); }
+  void add_trace_flags(SurfaceFlingerLayersConfig_TraceFlag value) { trace_flags_.emplace_back(value); }
+  SurfaceFlingerLayersConfig_TraceFlag* add_trace_flags() { trace_flags_.emplace_back(); return &trace_flags_.back(); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InstrumentedSampling kInstrumentedSampling() { return {}; }
-  void set_instrumented_sampling(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_InstrumentedSampling::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+ private:
+  SurfaceFlingerLayersConfig_Mode mode_{};
+  std::vector<SurfaceFlingerLayersConfig_TraceFlag> trace_flags_;
 
-  using FieldMetadata_FixGpuClock =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      GpuCounterConfig>;
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FixGpuClock kFixGpuClock() { return {}; }
-  void set_fix_gpu_clock(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_FixGpuClock::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  std::bitset<3> _has_field_{};
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/gpu/vulkan_memory_config.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_VULKAN_MEMORY_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_VULKAN_MEMORY_CONFIG_PROTO_H_
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_SURFACEFLINGER_LAYERS_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/surfaceflinger_transactions_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_SURFACEFLINGER_TRANSACTIONS_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_SURFACEFLINGER_TRANSACTIONS_CONFIG_PROTO_CPP_H_
 
-#include <stddef.h>
 #include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
 namespace perfetto {
 namespace protos {
-namespace pbzero {
+namespace gen {
+class SurfaceFlingerTransactionsConfig;
+enum SurfaceFlingerTransactionsConfig_Mode : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-class VulkanMemoryConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  VulkanMemoryConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit VulkanMemoryConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit VulkanMemoryConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_track_driver_memory_usage() const { return at<1>().valid(); }
-  bool track_driver_memory_usage() const { return at<1>().as_bool(); }
-  bool has_track_device_memory_usage() const { return at<2>().valid(); }
-  bool track_device_memory_usage() const { return at<2>().as_bool(); }
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum SurfaceFlingerTransactionsConfig_Mode : int {
+  SurfaceFlingerTransactionsConfig_Mode_MODE_UNSPECIFIED = 0,
+  SurfaceFlingerTransactionsConfig_Mode_MODE_CONTINUOUS = 1,
+  SurfaceFlingerTransactionsConfig_Mode_MODE_ACTIVE = 2,
 };
 
-class VulkanMemoryConfig : public ::protozero::Message {
+class PERFETTO_EXPORT_COMPONENT SurfaceFlingerTransactionsConfig : public ::protozero::CppMessageObj {
  public:
-  using Decoder = VulkanMemoryConfig_Decoder;
-  enum : int32_t {
-    kTrackDriverMemoryUsageFieldNumber = 1,
-    kTrackDeviceMemoryUsageFieldNumber = 2,
+  using Mode = SurfaceFlingerTransactionsConfig_Mode;
+  static constexpr auto MODE_UNSPECIFIED = SurfaceFlingerTransactionsConfig_Mode_MODE_UNSPECIFIED;
+  static constexpr auto MODE_CONTINUOUS = SurfaceFlingerTransactionsConfig_Mode_MODE_CONTINUOUS;
+  static constexpr auto MODE_ACTIVE = SurfaceFlingerTransactionsConfig_Mode_MODE_ACTIVE;
+  static constexpr auto Mode_MIN = SurfaceFlingerTransactionsConfig_Mode_MODE_UNSPECIFIED;
+  static constexpr auto Mode_MAX = SurfaceFlingerTransactionsConfig_Mode_MODE_ACTIVE;
+  enum FieldNumbers {
+    kModeFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.VulkanMemoryConfig"; }
 
+  SurfaceFlingerTransactionsConfig();
+  ~SurfaceFlingerTransactionsConfig() override;
+  SurfaceFlingerTransactionsConfig(SurfaceFlingerTransactionsConfig&&) noexcept;
+  SurfaceFlingerTransactionsConfig& operator=(SurfaceFlingerTransactionsConfig&&);
+  SurfaceFlingerTransactionsConfig(const SurfaceFlingerTransactionsConfig&);
+  SurfaceFlingerTransactionsConfig& operator=(const SurfaceFlingerTransactionsConfig&);
+  bool operator==(const SurfaceFlingerTransactionsConfig&) const;
+  bool operator!=(const SurfaceFlingerTransactionsConfig& other) const { return !(*this == other); }
 
-  using FieldMetadata_TrackDriverMemoryUsage =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      VulkanMemoryConfig>;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrackDriverMemoryUsage kTrackDriverMemoryUsage() { return {}; }
-  void set_track_driver_memory_usage(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_TrackDriverMemoryUsage::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  bool has_mode() const { return _has_field_[1]; }
+  SurfaceFlingerTransactionsConfig_Mode mode() const { return mode_; }
+  void set_mode(SurfaceFlingerTransactionsConfig_Mode value) { mode_ = value; _has_field_.set(1); }
 
-  using FieldMetadata_TrackDeviceMemoryUsage =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      VulkanMemoryConfig>;
+ private:
+  SurfaceFlingerTransactionsConfig_Mode mode_{};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrackDeviceMemoryUsage kTrackDeviceMemoryUsage() { return {}; }
-  void set_track_device_memory_usage(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_TrackDeviceMemoryUsage::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<2> _has_field_{};
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/inode_file/inode_file_config.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INODE_FILE_INODE_FILE_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INODE_FILE_INODE_FILE_CONFIG_PROTO_H_
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_SURFACEFLINGER_TRANSACTIONS_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/user_list_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_USER_LIST_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_USER_LIST_CONFIG_PROTO_CPP_H_
 
-#include <stddef.h>
 #include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
 namespace perfetto {
 namespace protos {
-namespace pbzero {
+namespace gen {
+class AndroidUserListConfig;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-class InodeFileConfig_MountPointMappingEntry;
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-class InodeFileConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  InodeFileConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit InodeFileConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit InodeFileConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_scan_interval_ms() const { return at<1>().valid(); }
-  uint32_t scan_interval_ms() const { return at<1>().as_uint32(); }
-  bool has_scan_delay_ms() const { return at<2>().valid(); }
-  uint32_t scan_delay_ms() const { return at<2>().as_uint32(); }
-  bool has_scan_batch_size() const { return at<3>().valid(); }
-  uint32_t scan_batch_size() const { return at<3>().as_uint32(); }
-  bool has_do_not_scan() const { return at<4>().valid(); }
-  bool do_not_scan() const { return at<4>().as_bool(); }
-  bool has_scan_mount_points() const { return at<5>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> scan_mount_points() const { return GetRepeated<::protozero::ConstChars>(5); }
-  bool has_mount_point_mapping() const { return at<6>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> mount_point_mapping() const { return GetRepeated<::protozero::ConstBytes>(6); }
-};
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-class InodeFileConfig : public ::protozero::Message {
+class PERFETTO_EXPORT_COMPONENT AndroidUserListConfig : public ::protozero::CppMessageObj {
  public:
-  using Decoder = InodeFileConfig_Decoder;
-  enum : int32_t {
-    kScanIntervalMsFieldNumber = 1,
-    kScanDelayMsFieldNumber = 2,
-    kScanBatchSizeFieldNumber = 3,
-    kDoNotScanFieldNumber = 4,
-    kScanMountPointsFieldNumber = 5,
-    kMountPointMappingFieldNumber = 6,
+  enum FieldNumbers {
+    kUserTypeFilterFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.InodeFileConfig"; }
 
-  using MountPointMappingEntry = ::perfetto::protos::pbzero::InodeFileConfig_MountPointMappingEntry;
+  AndroidUserListConfig();
+  ~AndroidUserListConfig() override;
+  AndroidUserListConfig(AndroidUserListConfig&&) noexcept;
+  AndroidUserListConfig& operator=(AndroidUserListConfig&&);
+  AndroidUserListConfig(const AndroidUserListConfig&);
+  AndroidUserListConfig& operator=(const AndroidUserListConfig&);
+  bool operator==(const AndroidUserListConfig&) const;
+  bool operator!=(const AndroidUserListConfig& other) const { return !(*this == other); }
 
-  using FieldMetadata_ScanIntervalMs =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      InodeFileConfig>;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ScanIntervalMs kScanIntervalMs() { return {}; }
-  void set_scan_interval_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ScanIntervalMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  const std::vector<std::string>& user_type_filter() const { return user_type_filter_; }
+  std::vector<std::string>* mutable_user_type_filter() { return &user_type_filter_; }
+  int user_type_filter_size() const { return static_cast<int>(user_type_filter_.size()); }
+  void clear_user_type_filter() { user_type_filter_.clear(); }
+  void add_user_type_filter(std::string value) { user_type_filter_.emplace_back(value); }
+  std::string* add_user_type_filter() { user_type_filter_.emplace_back(); return &user_type_filter_.back(); }
 
-  using FieldMetadata_ScanDelayMs =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      InodeFileConfig>;
+ private:
+  std::vector<std::string> user_type_filter_;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ScanDelayMs kScanDelayMs() { return {}; }
-  void set_scan_delay_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ScanDelayMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  using FieldMetadata_ScanBatchSize =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      InodeFileConfig>;
+  std::bitset<2> _has_field_{};
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ScanBatchSize kScanBatchSize() { return {}; }
-  void set_scan_batch_size(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ScanBatchSize::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  using FieldMetadata_DoNotScan =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      InodeFileConfig>;
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_USER_LIST_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/windowmanager_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_WINDOWMANAGER_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_WINDOWMANAGER_CONFIG_PROTO_CPP_H_
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DoNotScan kDoNotScan() { return {}; }
-  void set_do_not_scan(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DoNotScan::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  using FieldMetadata_ScanMountPoints =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      InodeFileConfig>;
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ScanMountPoints kScanMountPoints() { return {}; }
-  void add_scan_mount_points(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ScanMountPoints::kFieldId, data, size);
-  }
-  void add_scan_mount_points(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ScanMountPoints::kFieldId, chars.data, chars.size);
-  }
-  void add_scan_mount_points(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ScanMountPoints::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+namespace perfetto {
+namespace protos {
+namespace gen {
+class WindowManagerConfig;
+enum WindowManagerConfig_LogFrequency : int;
+enum WindowManagerConfig_LogLevel : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  using FieldMetadata_MountPointMapping =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      InodeFileConfig_MountPointMappingEntry,
-      InodeFileConfig>;
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MountPointMapping kMountPointMapping() { return {}; }
-  template <typename T = InodeFileConfig_MountPointMappingEntry> T* add_mount_point_mapping() {
-    return BeginNestedMessage<T>(6);
-  }
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum WindowManagerConfig_LogFrequency : int {
+  WindowManagerConfig_LogFrequency_LOG_FREQUENCY_UNSPECIFIED = 0,
+  WindowManagerConfig_LogFrequency_LOG_FREQUENCY_FRAME = 1,
+  WindowManagerConfig_LogFrequency_LOG_FREQUENCY_TRANSACTION = 2,
+  WindowManagerConfig_LogFrequency_LOG_FREQUENCY_SINGLE_DUMP = 3,
+};
+enum WindowManagerConfig_LogLevel : int {
+  WindowManagerConfig_LogLevel_LOG_LEVEL_UNSPECIFIED = 0,
+  WindowManagerConfig_LogLevel_LOG_LEVEL_VERBOSE = 1,
+  WindowManagerConfig_LogLevel_LOG_LEVEL_DEBUG = 2,
+  WindowManagerConfig_LogLevel_LOG_LEVEL_CRITICAL = 3,
+};
+
+class PERFETTO_EXPORT_COMPONENT WindowManagerConfig : public ::protozero::CppMessageObj {
+ public:
+  using LogFrequency = WindowManagerConfig_LogFrequency;
+  static constexpr auto LOG_FREQUENCY_UNSPECIFIED = WindowManagerConfig_LogFrequency_LOG_FREQUENCY_UNSPECIFIED;
+  static constexpr auto LOG_FREQUENCY_FRAME = WindowManagerConfig_LogFrequency_LOG_FREQUENCY_FRAME;
+  static constexpr auto LOG_FREQUENCY_TRANSACTION = WindowManagerConfig_LogFrequency_LOG_FREQUENCY_TRANSACTION;
+  static constexpr auto LOG_FREQUENCY_SINGLE_DUMP = WindowManagerConfig_LogFrequency_LOG_FREQUENCY_SINGLE_DUMP;
+  static constexpr auto LogFrequency_MIN = WindowManagerConfig_LogFrequency_LOG_FREQUENCY_UNSPECIFIED;
+  static constexpr auto LogFrequency_MAX = WindowManagerConfig_LogFrequency_LOG_FREQUENCY_SINGLE_DUMP;
+  using LogLevel = WindowManagerConfig_LogLevel;
+  static constexpr auto LOG_LEVEL_UNSPECIFIED = WindowManagerConfig_LogLevel_LOG_LEVEL_UNSPECIFIED;
+  static constexpr auto LOG_LEVEL_VERBOSE = WindowManagerConfig_LogLevel_LOG_LEVEL_VERBOSE;
+  static constexpr auto LOG_LEVEL_DEBUG = WindowManagerConfig_LogLevel_LOG_LEVEL_DEBUG;
+  static constexpr auto LOG_LEVEL_CRITICAL = WindowManagerConfig_LogLevel_LOG_LEVEL_CRITICAL;
+  static constexpr auto LogLevel_MIN = WindowManagerConfig_LogLevel_LOG_LEVEL_UNSPECIFIED;
+  static constexpr auto LogLevel_MAX = WindowManagerConfig_LogLevel_LOG_LEVEL_CRITICAL;
+  enum FieldNumbers {
+    kLogFrequencyFieldNumber = 1,
+    kLogLevelFieldNumber = 2,
+  };
 
-};
+  WindowManagerConfig();
+  ~WindowManagerConfig() override;
+  WindowManagerConfig(WindowManagerConfig&&) noexcept;
+  WindowManagerConfig& operator=(WindowManagerConfig&&);
+  WindowManagerConfig(const WindowManagerConfig&);
+  WindowManagerConfig& operator=(const WindowManagerConfig&);
+  bool operator==(const WindowManagerConfig&) const;
+  bool operator!=(const WindowManagerConfig& other) const { return !(*this == other); }
 
-class InodeFileConfig_MountPointMappingEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  InodeFileConfig_MountPointMappingEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit InodeFileConfig_MountPointMappingEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit InodeFileConfig_MountPointMappingEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_mountpoint() const { return at<1>().valid(); }
-  ::protozero::ConstChars mountpoint() const { return at<1>().as_string(); }
-  bool has_scan_roots() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> scan_roots() const { return GetRepeated<::protozero::ConstChars>(2); }
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_log_frequency() const { return _has_field_[1]; }
+  WindowManagerConfig_LogFrequency log_frequency() const { return log_frequency_; }
+  void set_log_frequency(WindowManagerConfig_LogFrequency value) { log_frequency_ = value; _has_field_.set(1); }
+
+  bool has_log_level() const { return _has_field_[2]; }
+  WindowManagerConfig_LogLevel log_level() const { return log_level_; }
+  void set_log_level(WindowManagerConfig_LogLevel value) { log_level_ = value; _has_field_.set(2); }
+
+ private:
+  WindowManagerConfig_LogFrequency log_frequency_{};
+  WindowManagerConfig_LogLevel log_level_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<3> _has_field_{};
 };
 
-class InodeFileConfig_MountPointMappingEntry : public ::protozero::Message {
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_WINDOWMANAGER_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/ftrace/frozen_ftrace_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_FTRACE_FROZEN_FTRACE_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_FTRACE_FROZEN_FTRACE_CONFIG_PROTO_CPP_H_
+
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+class FrozenFtraceConfig;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+namespace protozero {
+class Message;
+}  // namespace protozero
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+
+class PERFETTO_EXPORT_COMPONENT FrozenFtraceConfig : public ::protozero::CppMessageObj {
  public:
-  using Decoder = InodeFileConfig_MountPointMappingEntry_Decoder;
-  enum : int32_t {
-    kMountpointFieldNumber = 1,
-    kScanRootsFieldNumber = 2,
+  enum FieldNumbers {
+    kInstanceNameFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.InodeFileConfig.MountPointMappingEntry"; }
 
+  FrozenFtraceConfig();
+  ~FrozenFtraceConfig() override;
+  FrozenFtraceConfig(FrozenFtraceConfig&&) noexcept;
+  FrozenFtraceConfig& operator=(FrozenFtraceConfig&&);
+  FrozenFtraceConfig(const FrozenFtraceConfig&);
+  FrozenFtraceConfig& operator=(const FrozenFtraceConfig&);
+  bool operator==(const FrozenFtraceConfig&) const;
+  bool operator!=(const FrozenFtraceConfig& other) const { return !(*this == other); }
 
-  using FieldMetadata_Mountpoint =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      InodeFileConfig_MountPointMappingEntry>;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mountpoint kMountpoint() { return {}; }
-  void set_mountpoint(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Mountpoint::kFieldId, data, size);
-  }
-  void set_mountpoint(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Mountpoint::kFieldId, chars.data, chars.size);
-  }
-  void set_mountpoint(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mountpoint::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  bool has_instance_name() const { return _has_field_[1]; }
+  const std::string& instance_name() const { return instance_name_; }
+  void set_instance_name(const std::string& value) { instance_name_ = value; _has_field_.set(1); }
 
-  using FieldMetadata_ScanRoots =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      InodeFileConfig_MountPointMappingEntry>;
+ private:
+  std::string instance_name_{};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ScanRoots kScanRoots() { return {}; }
-  void add_scan_roots(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ScanRoots::kFieldId, data, size);
-  }
-  void add_scan_roots(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ScanRoots::kFieldId, chars.data, chars.size);
-  }
-  void add_scan_roots(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ScanRoots::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<2> _has_field_{};
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/interceptors/console_config.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTORS_CONSOLE_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTORS_CONSOLE_CONFIG_PROTO_H_
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_FTRACE_FROZEN_FTRACE_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/ftrace/ftrace_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_FTRACE_FTRACE_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_FTRACE_FTRACE_CONFIG_PROTO_CPP_H_
 
-#include <stddef.h>
 #include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
 namespace perfetto {
 namespace protos {
-namespace pbzero {
+namespace gen {
+class FtraceConfig;
+class FtraceConfig_TracefsOption;
+class FtraceConfig_KprobeEvent;
+class FtraceConfig_PrintFilter;
+class FtraceConfig_PrintFilter_Rule;
+class FtraceConfig_PrintFilter_Rule_AtraceMessage;
+class FtraceConfig_CompactSchedConfig;
+enum FtraceConfig_KsymsMemPolicy : int;
+enum FtraceConfig_TracefsOption_State : int;
+enum FtraceConfig_KprobeEvent_KprobeType : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-namespace perfetto_pbzero_enum_ConsoleConfig {
-enum Output : int32_t;
-}  // namespace perfetto_pbzero_enum_ConsoleConfig
-using ConsoleConfig_Output = perfetto_pbzero_enum_ConsoleConfig::Output;
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-namespace perfetto_pbzero_enum_ConsoleConfig {
-enum Output : int32_t {
-  OUTPUT_UNSPECIFIED = 0,
-  OUTPUT_STDOUT = 1,
-  OUTPUT_STDERR = 2,
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum FtraceConfig_KsymsMemPolicy : int {
+  FtraceConfig_KsymsMemPolicy_KSYMS_UNSPECIFIED = 0,
+  FtraceConfig_KsymsMemPolicy_KSYMS_CLEANUP_ON_STOP = 1,
+  FtraceConfig_KsymsMemPolicy_KSYMS_RETAIN = 2,
 };
-} // namespace perfetto_pbzero_enum_ConsoleConfig
-using ConsoleConfig_Output = perfetto_pbzero_enum_ConsoleConfig::Output;
+enum FtraceConfig_TracefsOption_State : int {
+  FtraceConfig_TracefsOption_State_STATE_UNKNOWN = 0,
+  FtraceConfig_TracefsOption_State_STATE_ENABLED = 1,
+  FtraceConfig_TracefsOption_State_STATE_DISABLED = 2,
+};
+enum FtraceConfig_KprobeEvent_KprobeType : int {
+  FtraceConfig_KprobeEvent_KprobeType_KPROBE_TYPE_UNKNOWN = 0,
+  FtraceConfig_KprobeEvent_KprobeType_KPROBE_TYPE_KPROBE = 1,
+  FtraceConfig_KprobeEvent_KprobeType_KPROBE_TYPE_KRETPROBE = 2,
+  FtraceConfig_KprobeEvent_KprobeType_KPROBE_TYPE_BOTH = 3,
+};
+
+class PERFETTO_EXPORT_COMPONENT FtraceConfig : public ::protozero::CppMessageObj {
+ public:
+  using CompactSchedConfig = FtraceConfig_CompactSchedConfig;
+  using PrintFilter = FtraceConfig_PrintFilter;
+  using KprobeEvent = FtraceConfig_KprobeEvent;
+  using TracefsOption = FtraceConfig_TracefsOption;
+  using KsymsMemPolicy = FtraceConfig_KsymsMemPolicy;
+  static constexpr auto KSYMS_UNSPECIFIED = FtraceConfig_KsymsMemPolicy_KSYMS_UNSPECIFIED;
+  static constexpr auto KSYMS_CLEANUP_ON_STOP = FtraceConfig_KsymsMemPolicy_KSYMS_CLEANUP_ON_STOP;
+  static constexpr auto KSYMS_RETAIN = FtraceConfig_KsymsMemPolicy_KSYMS_RETAIN;
+  static constexpr auto KsymsMemPolicy_MIN = FtraceConfig_KsymsMemPolicy_KSYMS_UNSPECIFIED;
+  static constexpr auto KsymsMemPolicy_MAX = FtraceConfig_KsymsMemPolicy_KSYMS_RETAIN;
+  enum FieldNumbers {
+    kFtraceEventsFieldNumber = 1,
+    kAtraceCategoriesFieldNumber = 2,
+    kAtraceAppsFieldNumber = 3,
+    kAtraceCategoriesPreferSdkFieldNumber = 28,
+    kAtraceUserspaceOnlyFieldNumber = 34,
+    kBufferSizeKbFieldNumber = 10,
+    kBufferSizeLowerBoundFieldNumber = 27,
+    kDrainPeriodMsFieldNumber = 11,
+    kDrainBufferPercentFieldNumber = 29,
+    kCompactSchedFieldNumber = 12,
+    kPrintFilterFieldNumber = 22,
+    kSymbolizeKsymsFieldNumber = 13,
+    kKsymsMemPolicyFieldNumber = 17,
+    kThrottleRssStatFieldNumber = 15,
+    kDenserGenericEventEncodingFieldNumber = 32,
+    kDisableGenericEventsFieldNumber = 16,
+    kSyscallEventsFieldNumber = 18,
+    kEnableFunctionGraphFieldNumber = 19,
+    kFunctionFiltersFieldNumber = 20,
+    kFunctionGraphRootsFieldNumber = 21,
+    kFunctionGraphMaxDepthFieldNumber = 33,
+    kKprobeEventsFieldNumber = 30,
+    kPreserveFtraceBufferFieldNumber = 23,
+    kUseMonotonicRawClockFieldNumber = 24,
+    kInstanceNameFieldNumber = 25,
+    kDebugFtraceAbiFieldNumber = 31,
+    kTidsToTraceFieldNumber = 35,
+    kTracefsOptionsFieldNumber = 36,
+    kTracingCpumaskFieldNumber = 37,
+    kInitializeKsymsSynchronouslyForTestingFieldNumber = 14,
+  };
 
+  FtraceConfig();
+  ~FtraceConfig() override;
+  FtraceConfig(FtraceConfig&&) noexcept;
+  FtraceConfig& operator=(FtraceConfig&&);
+  FtraceConfig(const FtraceConfig&);
+  FtraceConfig& operator=(const FtraceConfig&);
+  bool operator==(const FtraceConfig&) const;
+  bool operator!=(const FtraceConfig& other) const { return !(*this == other); }
 
-constexpr ConsoleConfig_Output ConsoleConfig_Output_MIN = ConsoleConfig_Output::OUTPUT_UNSPECIFIED;
-constexpr ConsoleConfig_Output ConsoleConfig_Output_MAX = ConsoleConfig_Output::OUTPUT_STDERR;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
+  const std::vector<std::string>& ftrace_events() const { return ftrace_events_; }
+  std::vector<std::string>* mutable_ftrace_events() { return &ftrace_events_; }
+  int ftrace_events_size() const { return static_cast<int>(ftrace_events_.size()); }
+  void clear_ftrace_events() { ftrace_events_.clear(); }
+  void add_ftrace_events(std::string value) { ftrace_events_.emplace_back(value); }
+  std::string* add_ftrace_events() { ftrace_events_.emplace_back(); return &ftrace_events_.back(); }
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ConsoleConfig_Output_Name(::perfetto::protos::pbzero::ConsoleConfig_Output value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ConsoleConfig_Output::OUTPUT_UNSPECIFIED:
-    return "OUTPUT_UNSPECIFIED";
+  const std::vector<std::string>& atrace_categories() const { return atrace_categories_; }
+  std::vector<std::string>* mutable_atrace_categories() { return &atrace_categories_; }
+  int atrace_categories_size() const { return static_cast<int>(atrace_categories_.size()); }
+  void clear_atrace_categories() { atrace_categories_.clear(); }
+  void add_atrace_categories(std::string value) { atrace_categories_.emplace_back(value); }
+  std::string* add_atrace_categories() { atrace_categories_.emplace_back(); return &atrace_categories_.back(); }
 
-  case ::perfetto::protos::pbzero::ConsoleConfig_Output::OUTPUT_STDOUT:
-    return "OUTPUT_STDOUT";
+  const std::vector<std::string>& atrace_apps() const { return atrace_apps_; }
+  std::vector<std::string>* mutable_atrace_apps() { return &atrace_apps_; }
+  int atrace_apps_size() const { return static_cast<int>(atrace_apps_.size()); }
+  void clear_atrace_apps() { atrace_apps_.clear(); }
+  void add_atrace_apps(std::string value) { atrace_apps_.emplace_back(value); }
+  std::string* add_atrace_apps() { atrace_apps_.emplace_back(); return &atrace_apps_.back(); }
 
-  case ::perfetto::protos::pbzero::ConsoleConfig_Output::OUTPUT_STDERR:
-    return "OUTPUT_STDERR";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+  const std::vector<std::string>& atrace_categories_prefer_sdk() const { return atrace_categories_prefer_sdk_; }
+  std::vector<std::string>* mutable_atrace_categories_prefer_sdk() { return &atrace_categories_prefer_sdk_; }
+  int atrace_categories_prefer_sdk_size() const { return static_cast<int>(atrace_categories_prefer_sdk_.size()); }
+  void clear_atrace_categories_prefer_sdk() { atrace_categories_prefer_sdk_.clear(); }
+  void add_atrace_categories_prefer_sdk(std::string value) { atrace_categories_prefer_sdk_.emplace_back(value); }
+  std::string* add_atrace_categories_prefer_sdk() { atrace_categories_prefer_sdk_.emplace_back(); return &atrace_categories_prefer_sdk_.back(); }
 
-class ConsoleConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  ConsoleConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ConsoleConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ConsoleConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_output() const { return at<1>().valid(); }
-  int32_t output() const { return at<1>().as_int32(); }
-  bool has_enable_colors() const { return at<2>().valid(); }
-  bool enable_colors() const { return at<2>().as_bool(); }
-};
+  bool has_atrace_userspace_only() const { return _has_field_[34]; }
+  bool atrace_userspace_only() const { return atrace_userspace_only_; }
+  void set_atrace_userspace_only(bool value) { atrace_userspace_only_ = value; _has_field_.set(34); }
 
-class ConsoleConfig : public ::protozero::Message {
- public:
-  using Decoder = ConsoleConfig_Decoder;
-  enum : int32_t {
-    kOutputFieldNumber = 1,
-    kEnableColorsFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ConsoleConfig"; }
+  bool has_buffer_size_kb() const { return _has_field_[10]; }
+  uint32_t buffer_size_kb() const { return buffer_size_kb_; }
+  void set_buffer_size_kb(uint32_t value) { buffer_size_kb_ = value; _has_field_.set(10); }
 
+  bool has_buffer_size_lower_bound() const { return _has_field_[27]; }
+  bool buffer_size_lower_bound() const { return buffer_size_lower_bound_; }
+  void set_buffer_size_lower_bound(bool value) { buffer_size_lower_bound_ = value; _has_field_.set(27); }
 
-  using Output = ::perfetto::protos::pbzero::ConsoleConfig_Output;
-  static inline const char* Output_Name(Output value) {
-    return ::perfetto::protos::pbzero::ConsoleConfig_Output_Name(value);
-  }
-  static const Output OUTPUT_UNSPECIFIED = Output::OUTPUT_UNSPECIFIED;
-  static const Output OUTPUT_STDOUT = Output::OUTPUT_STDOUT;
-  static const Output OUTPUT_STDERR = Output::OUTPUT_STDERR;
+  bool has_drain_period_ms() const { return _has_field_[11]; }
+  uint32_t drain_period_ms() const { return drain_period_ms_; }
+  void set_drain_period_ms(uint32_t value) { drain_period_ms_ = value; _has_field_.set(11); }
 
-  using FieldMetadata_Output =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ConsoleConfig_Output,
-      ConsoleConfig>;
+  bool has_drain_buffer_percent() const { return _has_field_[29]; }
+  uint32_t drain_buffer_percent() const { return drain_buffer_percent_; }
+  void set_drain_buffer_percent(uint32_t value) { drain_buffer_percent_ = value; _has_field_.set(29); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Output kOutput() { return {}; }
-  void set_output(::perfetto::protos::pbzero::ConsoleConfig_Output value) {
-    static constexpr uint32_t field_id = FieldMetadata_Output::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
+  bool has_compact_sched() const { return _has_field_[12]; }
+  const FtraceConfig_CompactSchedConfig& compact_sched() const { return *compact_sched_; }
+  FtraceConfig_CompactSchedConfig* mutable_compact_sched() { _has_field_.set(12); return compact_sched_.get(); }
 
-  using FieldMetadata_EnableColors =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ConsoleConfig>;
+  bool has_print_filter() const { return _has_field_[22]; }
+  const FtraceConfig_PrintFilter& print_filter() const { return *print_filter_; }
+  FtraceConfig_PrintFilter* mutable_print_filter() { _has_field_.set(22); return print_filter_.get(); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EnableColors kEnableColors() { return {}; }
-  void set_enable_colors(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_EnableColors::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-};
+  bool has_symbolize_ksyms() const { return _has_field_[13]; }
+  bool symbolize_ksyms() const { return symbolize_ksyms_; }
+  void set_symbolize_ksyms(bool value) { symbolize_ksyms_ = value; _has_field_.set(13); }
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/power/android_power_config.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+  bool has_ksyms_mem_policy() const { return _has_field_[17]; }
+  FtraceConfig_KsymsMemPolicy ksyms_mem_policy() const { return ksyms_mem_policy_; }
+  void set_ksyms_mem_policy(FtraceConfig_KsymsMemPolicy value) { ksyms_mem_policy_ = value; _has_field_.set(17); }
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_POWER_ANDROID_POWER_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_POWER_ANDROID_POWER_CONFIG_PROTO_H_
+  bool has_throttle_rss_stat() const { return _has_field_[15]; }
+  bool throttle_rss_stat() const { return throttle_rss_stat_; }
+  void set_throttle_rss_stat(bool value) { throttle_rss_stat_ = value; _has_field_.set(15); }
 
-#include <stddef.h>
-#include <stdint.h>
+  bool has_denser_generic_event_encoding() const { return _has_field_[32]; }
+  bool denser_generic_event_encoding() const { return denser_generic_event_encoding_; }
+  void set_denser_generic_event_encoding(bool value) { denser_generic_event_encoding_ = value; _has_field_.set(32); }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  bool has_disable_generic_events() const { return _has_field_[16]; }
+  bool disable_generic_events() const { return disable_generic_events_; }
+  void set_disable_generic_events(bool value) { disable_generic_events_ = value; _has_field_.set(16); }
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  const std::vector<std::string>& syscall_events() const { return syscall_events_; }
+  std::vector<std::string>* mutable_syscall_events() { return &syscall_events_; }
+  int syscall_events_size() const { return static_cast<int>(syscall_events_.size()); }
+  void clear_syscall_events() { syscall_events_.clear(); }
+  void add_syscall_events(std::string value) { syscall_events_.emplace_back(value); }
+  std::string* add_syscall_events() { syscall_events_.emplace_back(); return &syscall_events_.back(); }
 
-namespace perfetto_pbzero_enum_AndroidPowerConfig {
-enum BatteryCounters : int32_t;
-}  // namespace perfetto_pbzero_enum_AndroidPowerConfig
-using AndroidPowerConfig_BatteryCounters = perfetto_pbzero_enum_AndroidPowerConfig::BatteryCounters;
+  bool has_enable_function_graph() const { return _has_field_[19]; }
+  bool enable_function_graph() const { return enable_function_graph_; }
+  void set_enable_function_graph(bool value) { enable_function_graph_ = value; _has_field_.set(19); }
 
-namespace perfetto_pbzero_enum_AndroidPowerConfig {
-enum BatteryCounters : int32_t {
-  BATTERY_COUNTER_UNSPECIFIED = 0,
-  BATTERY_COUNTER_CHARGE = 1,
-  BATTERY_COUNTER_CAPACITY_PERCENT = 2,
-  BATTERY_COUNTER_CURRENT = 3,
-  BATTERY_COUNTER_CURRENT_AVG = 4,
-};
-} // namespace perfetto_pbzero_enum_AndroidPowerConfig
-using AndroidPowerConfig_BatteryCounters = perfetto_pbzero_enum_AndroidPowerConfig::BatteryCounters;
+  const std::vector<std::string>& function_filters() const { return function_filters_; }
+  std::vector<std::string>* mutable_function_filters() { return &function_filters_; }
+  int function_filters_size() const { return static_cast<int>(function_filters_.size()); }
+  void clear_function_filters() { function_filters_.clear(); }
+  void add_function_filters(std::string value) { function_filters_.emplace_back(value); }
+  std::string* add_function_filters() { function_filters_.emplace_back(); return &function_filters_.back(); }
 
+  const std::vector<std::string>& function_graph_roots() const { return function_graph_roots_; }
+  std::vector<std::string>* mutable_function_graph_roots() { return &function_graph_roots_; }
+  int function_graph_roots_size() const { return static_cast<int>(function_graph_roots_.size()); }
+  void clear_function_graph_roots() { function_graph_roots_.clear(); }
+  void add_function_graph_roots(std::string value) { function_graph_roots_.emplace_back(value); }
+  std::string* add_function_graph_roots() { function_graph_roots_.emplace_back(); return &function_graph_roots_.back(); }
 
-constexpr AndroidPowerConfig_BatteryCounters AndroidPowerConfig_BatteryCounters_MIN = AndroidPowerConfig_BatteryCounters::BATTERY_COUNTER_UNSPECIFIED;
-constexpr AndroidPowerConfig_BatteryCounters AndroidPowerConfig_BatteryCounters_MAX = AndroidPowerConfig_BatteryCounters::BATTERY_COUNTER_CURRENT_AVG;
+  bool has_function_graph_max_depth() const { return _has_field_[33]; }
+  uint32_t function_graph_max_depth() const { return function_graph_max_depth_; }
+  void set_function_graph_max_depth(uint32_t value) { function_graph_max_depth_ = value; _has_field_.set(33); }
 
+  const std::vector<FtraceConfig_KprobeEvent>& kprobe_events() const { return kprobe_events_; }
+  std::vector<FtraceConfig_KprobeEvent>* mutable_kprobe_events() { return &kprobe_events_; }
+  int kprobe_events_size() const;
+  void clear_kprobe_events();
+  FtraceConfig_KprobeEvent* add_kprobe_events();
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* AndroidPowerConfig_BatteryCounters_Name(::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters::BATTERY_COUNTER_UNSPECIFIED:
-    return "BATTERY_COUNTER_UNSPECIFIED";
+  bool has_preserve_ftrace_buffer() const { return _has_field_[23]; }
+  bool preserve_ftrace_buffer() const { return preserve_ftrace_buffer_; }
+  void set_preserve_ftrace_buffer(bool value) { preserve_ftrace_buffer_ = value; _has_field_.set(23); }
 
-  case ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters::BATTERY_COUNTER_CHARGE:
-    return "BATTERY_COUNTER_CHARGE";
+  bool has_use_monotonic_raw_clock() const { return _has_field_[24]; }
+  bool use_monotonic_raw_clock() const { return use_monotonic_raw_clock_; }
+  void set_use_monotonic_raw_clock(bool value) { use_monotonic_raw_clock_ = value; _has_field_.set(24); }
 
-  case ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters::BATTERY_COUNTER_CAPACITY_PERCENT:
-    return "BATTERY_COUNTER_CAPACITY_PERCENT";
+  bool has_instance_name() const { return _has_field_[25]; }
+  const std::string& instance_name() const { return instance_name_; }
+  void set_instance_name(const std::string& value) { instance_name_ = value; _has_field_.set(25); }
 
-  case ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters::BATTERY_COUNTER_CURRENT:
-    return "BATTERY_COUNTER_CURRENT";
+  bool has_debug_ftrace_abi() const { return _has_field_[31]; }
+  bool debug_ftrace_abi() const { return debug_ftrace_abi_; }
+  void set_debug_ftrace_abi(bool value) { debug_ftrace_abi_ = value; _has_field_.set(31); }
 
-  case ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters::BATTERY_COUNTER_CURRENT_AVG:
-    return "BATTERY_COUNTER_CURRENT_AVG";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+  const std::vector<uint32_t>& tids_to_trace() const { return tids_to_trace_; }
+  std::vector<uint32_t>* mutable_tids_to_trace() { return &tids_to_trace_; }
+  int tids_to_trace_size() const { return static_cast<int>(tids_to_trace_.size()); }
+  void clear_tids_to_trace() { tids_to_trace_.clear(); }
+  void add_tids_to_trace(uint32_t value) { tids_to_trace_.emplace_back(value); }
+  uint32_t* add_tids_to_trace() { tids_to_trace_.emplace_back(); return &tids_to_trace_.back(); }
 
-class AndroidPowerConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  AndroidPowerConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AndroidPowerConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AndroidPowerConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_battery_poll_ms() const { return at<1>().valid(); }
-  uint32_t battery_poll_ms() const { return at<1>().as_uint32(); }
-  bool has_battery_counters() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<int32_t> battery_counters() const { return GetRepeated<int32_t>(2); }
-  bool has_collect_power_rails() const { return at<3>().valid(); }
-  bool collect_power_rails() const { return at<3>().as_bool(); }
-  bool has_collect_energy_estimation_breakdown() const { return at<4>().valid(); }
-  bool collect_energy_estimation_breakdown() const { return at<4>().as_bool(); }
-  bool has_collect_entity_state_residency() const { return at<5>().valid(); }
-  bool collect_entity_state_residency() const { return at<5>().as_bool(); }
+  const std::vector<FtraceConfig_TracefsOption>& tracefs_options() const { return tracefs_options_; }
+  std::vector<FtraceConfig_TracefsOption>* mutable_tracefs_options() { return &tracefs_options_; }
+  int tracefs_options_size() const;
+  void clear_tracefs_options();
+  FtraceConfig_TracefsOption* add_tracefs_options();
+
+  bool has_tracing_cpumask() const { return _has_field_[37]; }
+  const std::string& tracing_cpumask() const { return tracing_cpumask_; }
+  void set_tracing_cpumask(const std::string& value) { tracing_cpumask_ = value; _has_field_.set(37); }
+
+  bool has_initialize_ksyms_synchronously_for_testing() const { return _has_field_[14]; }
+  bool initialize_ksyms_synchronously_for_testing() const { return initialize_ksyms_synchronously_for_testing_; }
+  void set_initialize_ksyms_synchronously_for_testing(bool value) { initialize_ksyms_synchronously_for_testing_ = value; _has_field_.set(14); }
+
+ private:
+  std::vector<std::string> ftrace_events_;
+  std::vector<std::string> atrace_categories_;
+  std::vector<std::string> atrace_apps_;
+  std::vector<std::string> atrace_categories_prefer_sdk_;
+  bool atrace_userspace_only_{};
+  uint32_t buffer_size_kb_{};
+  bool buffer_size_lower_bound_{};
+  uint32_t drain_period_ms_{};
+  uint32_t drain_buffer_percent_{};
+  ::protozero::CopyablePtr<FtraceConfig_CompactSchedConfig> compact_sched_;
+  ::protozero::CopyablePtr<FtraceConfig_PrintFilter> print_filter_;
+  bool symbolize_ksyms_{};
+  FtraceConfig_KsymsMemPolicy ksyms_mem_policy_{};
+  bool throttle_rss_stat_{};
+  bool denser_generic_event_encoding_{};
+  bool disable_generic_events_{};
+  std::vector<std::string> syscall_events_;
+  bool enable_function_graph_{};
+  std::vector<std::string> function_filters_;
+  std::vector<std::string> function_graph_roots_;
+  uint32_t function_graph_max_depth_{};
+  std::vector<FtraceConfig_KprobeEvent> kprobe_events_;
+  bool preserve_ftrace_buffer_{};
+  bool use_monotonic_raw_clock_{};
+  std::string instance_name_{};
+  bool debug_ftrace_abi_{};
+  std::vector<uint32_t> tids_to_trace_;
+  std::vector<FtraceConfig_TracefsOption> tracefs_options_;
+  std::string tracing_cpumask_{};
+  bool initialize_ksyms_synchronously_for_testing_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<38> _has_field_{};
 };
 
-class AndroidPowerConfig : public ::protozero::Message {
+
+class PERFETTO_EXPORT_COMPONENT FtraceConfig_TracefsOption : public ::protozero::CppMessageObj {
  public:
-  using Decoder = AndroidPowerConfig_Decoder;
-  enum : int32_t {
-    kBatteryPollMsFieldNumber = 1,
-    kBatteryCountersFieldNumber = 2,
-    kCollectPowerRailsFieldNumber = 3,
-    kCollectEnergyEstimationBreakdownFieldNumber = 4,
-    kCollectEntityStateResidencyFieldNumber = 5,
+  using State = FtraceConfig_TracefsOption_State;
+  static constexpr auto STATE_UNKNOWN = FtraceConfig_TracefsOption_State_STATE_UNKNOWN;
+  static constexpr auto STATE_ENABLED = FtraceConfig_TracefsOption_State_STATE_ENABLED;
+  static constexpr auto STATE_DISABLED = FtraceConfig_TracefsOption_State_STATE_DISABLED;
+  static constexpr auto State_MIN = FtraceConfig_TracefsOption_State_STATE_UNKNOWN;
+  static constexpr auto State_MAX = FtraceConfig_TracefsOption_State_STATE_DISABLED;
+  enum FieldNumbers {
+    kNameFieldNumber = 1,
+    kStateFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.AndroidPowerConfig"; }
 
+  FtraceConfig_TracefsOption();
+  ~FtraceConfig_TracefsOption() override;
+  FtraceConfig_TracefsOption(FtraceConfig_TracefsOption&&) noexcept;
+  FtraceConfig_TracefsOption& operator=(FtraceConfig_TracefsOption&&);
+  FtraceConfig_TracefsOption(const FtraceConfig_TracefsOption&);
+  FtraceConfig_TracefsOption& operator=(const FtraceConfig_TracefsOption&);
+  bool operator==(const FtraceConfig_TracefsOption&) const;
+  bool operator!=(const FtraceConfig_TracefsOption& other) const { return !(*this == other); }
 
-  using BatteryCounters = ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters;
-  static inline const char* BatteryCounters_Name(BatteryCounters value) {
-    return ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters_Name(value);
-  }
-  static const BatteryCounters BATTERY_COUNTER_UNSPECIFIED = BatteryCounters::BATTERY_COUNTER_UNSPECIFIED;
-  static const BatteryCounters BATTERY_COUNTER_CHARGE = BatteryCounters::BATTERY_COUNTER_CHARGE;
-  static const BatteryCounters BATTERY_COUNTER_CAPACITY_PERCENT = BatteryCounters::BATTERY_COUNTER_CAPACITY_PERCENT;
-  static const BatteryCounters BATTERY_COUNTER_CURRENT = BatteryCounters::BATTERY_COUNTER_CURRENT;
-  static const BatteryCounters BATTERY_COUNTER_CURRENT_AVG = BatteryCounters::BATTERY_COUNTER_CURRENT_AVG;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  using FieldMetadata_BatteryPollMs =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      AndroidPowerConfig>;
+  bool has_name() const { return _has_field_[1]; }
+  const std::string& name() const { return name_; }
+  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BatteryPollMs kBatteryPollMs() { return {}; }
-  void set_battery_poll_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BatteryPollMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  bool has_state() const { return _has_field_[2]; }
+  FtraceConfig_TracefsOption_State state() const { return state_; }
+  void set_state(FtraceConfig_TracefsOption_State value) { state_ = value; _has_field_.set(2); }
 
-  using FieldMetadata_BatteryCounters =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters,
-      AndroidPowerConfig>;
+ private:
+  std::string name_{};
+  FtraceConfig_TracefsOption_State state_{};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BatteryCounters kBatteryCounters() { return {}; }
-  void add_battery_counters(::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters value) {
-    static constexpr uint32_t field_id = FieldMetadata_BatteryCounters::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  using FieldMetadata_CollectPowerRails =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      AndroidPowerConfig>;
+  std::bitset<3> _has_field_{};
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CollectPowerRails kCollectPowerRails() { return {}; }
-  void set_collect_power_rails(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_CollectPowerRails::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
 
-  using FieldMetadata_CollectEnergyEstimationBreakdown =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      AndroidPowerConfig>;
+class PERFETTO_EXPORT_COMPONENT FtraceConfig_KprobeEvent : public ::protozero::CppMessageObj {
+ public:
+  using KprobeType = FtraceConfig_KprobeEvent_KprobeType;
+  static constexpr auto KPROBE_TYPE_UNKNOWN = FtraceConfig_KprobeEvent_KprobeType_KPROBE_TYPE_UNKNOWN;
+  static constexpr auto KPROBE_TYPE_KPROBE = FtraceConfig_KprobeEvent_KprobeType_KPROBE_TYPE_KPROBE;
+  static constexpr auto KPROBE_TYPE_KRETPROBE = FtraceConfig_KprobeEvent_KprobeType_KPROBE_TYPE_KRETPROBE;
+  static constexpr auto KPROBE_TYPE_BOTH = FtraceConfig_KprobeEvent_KprobeType_KPROBE_TYPE_BOTH;
+  static constexpr auto KprobeType_MIN = FtraceConfig_KprobeEvent_KprobeType_KPROBE_TYPE_UNKNOWN;
+  static constexpr auto KprobeType_MAX = FtraceConfig_KprobeEvent_KprobeType_KPROBE_TYPE_BOTH;
+  enum FieldNumbers {
+    kProbeFieldNumber = 1,
+    kTypeFieldNumber = 2,
+  };
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CollectEnergyEstimationBreakdown kCollectEnergyEstimationBreakdown() { return {}; }
-  void set_collect_energy_estimation_breakdown(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_CollectEnergyEstimationBreakdown::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  FtraceConfig_KprobeEvent();
+  ~FtraceConfig_KprobeEvent() override;
+  FtraceConfig_KprobeEvent(FtraceConfig_KprobeEvent&&) noexcept;
+  FtraceConfig_KprobeEvent& operator=(FtraceConfig_KprobeEvent&&);
+  FtraceConfig_KprobeEvent(const FtraceConfig_KprobeEvent&);
+  FtraceConfig_KprobeEvent& operator=(const FtraceConfig_KprobeEvent&);
+  bool operator==(const FtraceConfig_KprobeEvent&) const;
+  bool operator!=(const FtraceConfig_KprobeEvent& other) const { return !(*this == other); }
 
-  using FieldMetadata_CollectEntityStateResidency =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      AndroidPowerConfig>;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CollectEntityStateResidency kCollectEntityStateResidency() { return {}; }
-  void set_collect_entity_state_residency(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_CollectEntityStateResidency::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  bool has_probe() const { return _has_field_[1]; }
+  const std::string& probe() const { return probe_; }
+  void set_probe(const std::string& value) { probe_ = value; _has_field_.set(1); }
+
+  bool has_type() const { return _has_field_[2]; }
+  FtraceConfig_KprobeEvent_KprobeType type() const { return type_; }
+  void set_type(FtraceConfig_KprobeEvent_KprobeType value) { type_ = value; _has_field_.set(2); }
+
+ private:
+  std::string probe_{};
+  FtraceConfig_KprobeEvent_KprobeType type_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<3> _has_field_{};
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/process_stats/process_stats_config.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROCESS_STATS_PROCESS_STATS_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROCESS_STATS_PROCESS_STATS_CONFIG_PROTO_H_
+class PERFETTO_EXPORT_COMPONENT FtraceConfig_PrintFilter : public ::protozero::CppMessageObj {
+ public:
+  using Rule = FtraceConfig_PrintFilter_Rule;
+  enum FieldNumbers {
+    kRulesFieldNumber = 1,
+  };
 
-#include <stddef.h>
-#include <stdint.h>
+  FtraceConfig_PrintFilter();
+  ~FtraceConfig_PrintFilter() override;
+  FtraceConfig_PrintFilter(FtraceConfig_PrintFilter&&) noexcept;
+  FtraceConfig_PrintFilter& operator=(FtraceConfig_PrintFilter&&);
+  FtraceConfig_PrintFilter(const FtraceConfig_PrintFilter&);
+  FtraceConfig_PrintFilter& operator=(const FtraceConfig_PrintFilter&);
+  bool operator==(const FtraceConfig_PrintFilter&) const;
+  bool operator!=(const FtraceConfig_PrintFilter& other) const { return !(*this == other); }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  const std::vector<FtraceConfig_PrintFilter_Rule>& rules() const { return rules_; }
+  std::vector<FtraceConfig_PrintFilter_Rule>* mutable_rules() { return &rules_; }
+  int rules_size() const;
+  void clear_rules();
+  FtraceConfig_PrintFilter_Rule* add_rules();
 
-namespace perfetto_pbzero_enum_ProcessStatsConfig {
-enum Quirks : int32_t;
-}  // namespace perfetto_pbzero_enum_ProcessStatsConfig
-using ProcessStatsConfig_Quirks = perfetto_pbzero_enum_ProcessStatsConfig::Quirks;
+ private:
+  std::vector<FtraceConfig_PrintFilter_Rule> rules_;
 
-namespace perfetto_pbzero_enum_ProcessStatsConfig {
-enum Quirks : int32_t {
-  QUIRKS_UNSPECIFIED = 0,
-  DISABLE_INITIAL_DUMP = 1,
-  DISABLE_ON_DEMAND = 2,
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<2> _has_field_{};
 };
-} // namespace perfetto_pbzero_enum_ProcessStatsConfig
-using ProcessStatsConfig_Quirks = perfetto_pbzero_enum_ProcessStatsConfig::Quirks;
 
 
-constexpr ProcessStatsConfig_Quirks ProcessStatsConfig_Quirks_MIN = ProcessStatsConfig_Quirks::QUIRKS_UNSPECIFIED;
-constexpr ProcessStatsConfig_Quirks ProcessStatsConfig_Quirks_MAX = ProcessStatsConfig_Quirks::DISABLE_ON_DEMAND;
+class PERFETTO_EXPORT_COMPONENT FtraceConfig_PrintFilter_Rule : public ::protozero::CppMessageObj {
+ public:
+  using AtraceMessage = FtraceConfig_PrintFilter_Rule_AtraceMessage;
+  enum FieldNumbers {
+    kPrefixFieldNumber = 1,
+    kAtraceMsgFieldNumber = 3,
+    kAllowFieldNumber = 2,
+  };
+
+  FtraceConfig_PrintFilter_Rule();
+  ~FtraceConfig_PrintFilter_Rule() override;
+  FtraceConfig_PrintFilter_Rule(FtraceConfig_PrintFilter_Rule&&) noexcept;
+  FtraceConfig_PrintFilter_Rule& operator=(FtraceConfig_PrintFilter_Rule&&);
+  FtraceConfig_PrintFilter_Rule(const FtraceConfig_PrintFilter_Rule&);
+  FtraceConfig_PrintFilter_Rule& operator=(const FtraceConfig_PrintFilter_Rule&);
+  bool operator==(const FtraceConfig_PrintFilter_Rule&) const;
+  bool operator!=(const FtraceConfig_PrintFilter_Rule& other) const { return !(*this == other); }
 
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ProcessStatsConfig_Quirks_Name(::perfetto::protos::pbzero::ProcessStatsConfig_Quirks value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ProcessStatsConfig_Quirks::QUIRKS_UNSPECIFIED:
-    return "QUIRKS_UNSPECIFIED";
+  bool has_prefix() const { return _has_field_[1]; }
+  const std::string& prefix() const { return prefix_; }
+  void set_prefix(const std::string& value) { prefix_ = value; _has_field_.set(1); }
 
-  case ::perfetto::protos::pbzero::ProcessStatsConfig_Quirks::DISABLE_INITIAL_DUMP:
-    return "DISABLE_INITIAL_DUMP";
+  bool has_atrace_msg() const { return _has_field_[3]; }
+  const FtraceConfig_PrintFilter_Rule_AtraceMessage& atrace_msg() const { return *atrace_msg_; }
+  FtraceConfig_PrintFilter_Rule_AtraceMessage* mutable_atrace_msg() { _has_field_.set(3); return atrace_msg_.get(); }
 
-  case ::perfetto::protos::pbzero::ProcessStatsConfig_Quirks::DISABLE_ON_DEMAND:
-    return "DISABLE_ON_DEMAND";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+  bool has_allow() const { return _has_field_[2]; }
+  bool allow() const { return allow_; }
+  void set_allow(bool value) { allow_ = value; _has_field_.set(2); }
 
-class ProcessStatsConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  ProcessStatsConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ProcessStatsConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ProcessStatsConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_quirks() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<int32_t> quirks() const { return GetRepeated<int32_t>(1); }
-  bool has_scan_all_processes_on_start() const { return at<2>().valid(); }
-  bool scan_all_processes_on_start() const { return at<2>().as_bool(); }
-  bool has_record_thread_names() const { return at<3>().valid(); }
-  bool record_thread_names() const { return at<3>().as_bool(); }
-  bool has_proc_stats_poll_ms() const { return at<4>().valid(); }
-  uint32_t proc_stats_poll_ms() const { return at<4>().as_uint32(); }
-  bool has_proc_stats_cache_ttl_ms() const { return at<6>().valid(); }
-  uint32_t proc_stats_cache_ttl_ms() const { return at<6>().as_uint32(); }
-  bool has_resolve_process_fds() const { return at<9>().valid(); }
-  bool resolve_process_fds() const { return at<9>().as_bool(); }
+ private:
+  std::string prefix_{};
+  ::protozero::CopyablePtr<FtraceConfig_PrintFilter_Rule_AtraceMessage> atrace_msg_;
+  bool allow_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<4> _has_field_{};
 };
 
-class ProcessStatsConfig : public ::protozero::Message {
+
+class PERFETTO_EXPORT_COMPONENT FtraceConfig_PrintFilter_Rule_AtraceMessage : public ::protozero::CppMessageObj {
  public:
-  using Decoder = ProcessStatsConfig_Decoder;
-  enum : int32_t {
-    kQuirksFieldNumber = 1,
-    kScanAllProcessesOnStartFieldNumber = 2,
-    kRecordThreadNamesFieldNumber = 3,
-    kProcStatsPollMsFieldNumber = 4,
-    kProcStatsCacheTtlMsFieldNumber = 6,
-    kResolveProcessFdsFieldNumber = 9,
+  enum FieldNumbers {
+    kTypeFieldNumber = 1,
+    kPrefixFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ProcessStatsConfig"; }
 
+  FtraceConfig_PrintFilter_Rule_AtraceMessage();
+  ~FtraceConfig_PrintFilter_Rule_AtraceMessage() override;
+  FtraceConfig_PrintFilter_Rule_AtraceMessage(FtraceConfig_PrintFilter_Rule_AtraceMessage&&) noexcept;
+  FtraceConfig_PrintFilter_Rule_AtraceMessage& operator=(FtraceConfig_PrintFilter_Rule_AtraceMessage&&);
+  FtraceConfig_PrintFilter_Rule_AtraceMessage(const FtraceConfig_PrintFilter_Rule_AtraceMessage&);
+  FtraceConfig_PrintFilter_Rule_AtraceMessage& operator=(const FtraceConfig_PrintFilter_Rule_AtraceMessage&);
+  bool operator==(const FtraceConfig_PrintFilter_Rule_AtraceMessage&) const;
+  bool operator!=(const FtraceConfig_PrintFilter_Rule_AtraceMessage& other) const { return !(*this == other); }
 
-  using Quirks = ::perfetto::protos::pbzero::ProcessStatsConfig_Quirks;
-  static inline const char* Quirks_Name(Quirks value) {
-    return ::perfetto::protos::pbzero::ProcessStatsConfig_Quirks_Name(value);
-  }
-  static const Quirks QUIRKS_UNSPECIFIED = Quirks::QUIRKS_UNSPECIFIED;
-  static const Quirks DISABLE_INITIAL_DUMP = Quirks::DISABLE_INITIAL_DUMP;
-  static const Quirks DISABLE_ON_DEMAND = Quirks::DISABLE_ON_DEMAND;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  using FieldMetadata_Quirks =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ProcessStatsConfig_Quirks,
-      ProcessStatsConfig>;
+  bool has_type() const { return _has_field_[1]; }
+  const std::string& type() const { return type_; }
+  void set_type(const std::string& value) { type_ = value; _has_field_.set(1); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Quirks kQuirks() { return {}; }
-  void add_quirks(::perfetto::protos::pbzero::ProcessStatsConfig_Quirks value) {
-    static constexpr uint32_t field_id = FieldMetadata_Quirks::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
+  bool has_prefix() const { return _has_field_[2]; }
+  const std::string& prefix() const { return prefix_; }
+  void set_prefix(const std::string& value) { prefix_ = value; _has_field_.set(2); }
 
-  using FieldMetadata_ScanAllProcessesOnStart =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ProcessStatsConfig>;
+ private:
+  std::string type_{};
+  std::string prefix_{};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ScanAllProcessesOnStart kScanAllProcessesOnStart() { return {}; }
-  void set_scan_all_processes_on_start(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_ScanAllProcessesOnStart::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  using FieldMetadata_RecordThreadNames =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ProcessStatsConfig>;
+  std::bitset<3> _has_field_{};
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RecordThreadNames kRecordThreadNames() { return {}; }
-  void set_record_thread_names(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_RecordThreadNames::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
 
-  using FieldMetadata_ProcStatsPollMs =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      ProcessStatsConfig>;
+class PERFETTO_EXPORT_COMPONENT FtraceConfig_CompactSchedConfig : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kEnabledFieldNumber = 1,
+  };
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcStatsPollMs kProcStatsPollMs() { return {}; }
-  void set_proc_stats_poll_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProcStatsPollMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  FtraceConfig_CompactSchedConfig();
+  ~FtraceConfig_CompactSchedConfig() override;
+  FtraceConfig_CompactSchedConfig(FtraceConfig_CompactSchedConfig&&) noexcept;
+  FtraceConfig_CompactSchedConfig& operator=(FtraceConfig_CompactSchedConfig&&);
+  FtraceConfig_CompactSchedConfig(const FtraceConfig_CompactSchedConfig&);
+  FtraceConfig_CompactSchedConfig& operator=(const FtraceConfig_CompactSchedConfig&);
+  bool operator==(const FtraceConfig_CompactSchedConfig&) const;
+  bool operator!=(const FtraceConfig_CompactSchedConfig& other) const { return !(*this == other); }
 
-  using FieldMetadata_ProcStatsCacheTtlMs =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      ProcessStatsConfig>;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcStatsCacheTtlMs kProcStatsCacheTtlMs() { return {}; }
-  void set_proc_stats_cache_ttl_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProcStatsCacheTtlMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  bool has_enabled() const { return _has_field_[1]; }
+  bool enabled() const { return enabled_; }
+  void set_enabled(bool value) { enabled_ = value; _has_field_.set(1); }
 
-  using FieldMetadata_ResolveProcessFds =
-    ::protozero::proto_utils::FieldMetadata<
-      9,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ProcessStatsConfig>;
+ private:
+  bool enabled_{};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ResolveProcessFds kResolveProcessFds() { return {}; }
-  void set_resolve_process_fds(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_ResolveProcessFds::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<2> _has_field_{};
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/profiling/heapprofd_config.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_HEAPPROFD_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_HEAPPROFD_CONFIG_PROTO_H_
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_FTRACE_FTRACE_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/gpu/gpu_counter_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_GPU_COUNTER_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_GPU_COUNTER_CONFIG_PROTO_CPP_H_
 
-#include <stddef.h>
 #include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
 namespace perfetto {
 namespace protos {
-namespace pbzero {
+namespace gen {
+class GpuCounterConfig;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-class HeapprofdConfig_ContinuousDumpConfig;
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-class HeapprofdConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/27, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  HeapprofdConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit HeapprofdConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit HeapprofdConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_sampling_interval_bytes() const { return at<1>().valid(); }
-  uint64_t sampling_interval_bytes() const { return at<1>().as_uint64(); }
-  bool has_adaptive_sampling_shmem_threshold() const { return at<24>().valid(); }
-  uint64_t adaptive_sampling_shmem_threshold() const { return at<24>().as_uint64(); }
-  bool has_adaptive_sampling_max_sampling_interval_bytes() const { return at<25>().valid(); }
-  uint64_t adaptive_sampling_max_sampling_interval_bytes() const { return at<25>().as_uint64(); }
-  bool has_process_cmdline() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> process_cmdline() const { return GetRepeated<::protozero::ConstChars>(2); }
-  bool has_pid() const { return at<4>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> pid() const { return GetRepeated<uint64_t>(4); }
-  bool has_target_installed_by() const { return at<26>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> target_installed_by() const { return GetRepeated<::protozero::ConstChars>(26); }
-  bool has_heaps() const { return at<20>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> heaps() const { return GetRepeated<::protozero::ConstChars>(20); }
-  bool has_exclude_heaps() const { return at<27>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> exclude_heaps() const { return GetRepeated<::protozero::ConstChars>(27); }
-  bool has_stream_allocations() const { return at<23>().valid(); }
-  bool stream_allocations() const { return at<23>().as_bool(); }
-  bool has_heap_sampling_intervals() const { return at<22>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> heap_sampling_intervals() const { return GetRepeated<uint64_t>(22); }
-  bool has_all_heaps() const { return at<21>().valid(); }
-  bool all_heaps() const { return at<21>().as_bool(); }
-  bool has_all() const { return at<5>().valid(); }
-  bool all() const { return at<5>().as_bool(); }
-  bool has_min_anonymous_memory_kb() const { return at<15>().valid(); }
-  uint32_t min_anonymous_memory_kb() const { return at<15>().as_uint32(); }
-  bool has_max_heapprofd_memory_kb() const { return at<16>().valid(); }
-  uint32_t max_heapprofd_memory_kb() const { return at<16>().as_uint32(); }
-  bool has_max_heapprofd_cpu_secs() const { return at<17>().valid(); }
-  uint64_t max_heapprofd_cpu_secs() const { return at<17>().as_uint64(); }
-  bool has_skip_symbol_prefix() const { return at<7>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> skip_symbol_prefix() const { return GetRepeated<::protozero::ConstChars>(7); }
-  bool has_continuous_dump_config() const { return at<6>().valid(); }
-  ::protozero::ConstBytes continuous_dump_config() const { return at<6>().as_bytes(); }
-  bool has_shmem_size_bytes() const { return at<8>().valid(); }
-  uint64_t shmem_size_bytes() const { return at<8>().as_uint64(); }
-  bool has_block_client() const { return at<9>().valid(); }
-  bool block_client() const { return at<9>().as_bool(); }
-  bool has_block_client_timeout_us() const { return at<14>().valid(); }
-  uint32_t block_client_timeout_us() const { return at<14>().as_uint32(); }
-  bool has_no_startup() const { return at<10>().valid(); }
-  bool no_startup() const { return at<10>().as_bool(); }
-  bool has_no_running() const { return at<11>().valid(); }
-  bool no_running() const { return at<11>().as_bool(); }
-  bool has_dump_at_max() const { return at<13>().valid(); }
-  bool dump_at_max() const { return at<13>().as_bool(); }
-  bool has_disable_fork_teardown() const { return at<18>().valid(); }
-  bool disable_fork_teardown() const { return at<18>().as_bool(); }
-  bool has_disable_vfork_detection() const { return at<19>().valid(); }
-  bool disable_vfork_detection() const { return at<19>().as_bool(); }
-};
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-class HeapprofdConfig : public ::protozero::Message {
+class PERFETTO_EXPORT_COMPONENT GpuCounterConfig : public ::protozero::CppMessageObj {
  public:
-  using Decoder = HeapprofdConfig_Decoder;
-  enum : int32_t {
-    kSamplingIntervalBytesFieldNumber = 1,
-    kAdaptiveSamplingShmemThresholdFieldNumber = 24,
-    kAdaptiveSamplingMaxSamplingIntervalBytesFieldNumber = 25,
-    kProcessCmdlineFieldNumber = 2,
-    kPidFieldNumber = 4,
-    kTargetInstalledByFieldNumber = 26,
-    kHeapsFieldNumber = 20,
-    kExcludeHeapsFieldNumber = 27,
-    kStreamAllocationsFieldNumber = 23,
-    kHeapSamplingIntervalsFieldNumber = 22,
-    kAllHeapsFieldNumber = 21,
-    kAllFieldNumber = 5,
-    kMinAnonymousMemoryKbFieldNumber = 15,
-    kMaxHeapprofdMemoryKbFieldNumber = 16,
-    kMaxHeapprofdCpuSecsFieldNumber = 17,
-    kSkipSymbolPrefixFieldNumber = 7,
-    kContinuousDumpConfigFieldNumber = 6,
-    kShmemSizeBytesFieldNumber = 8,
-    kBlockClientFieldNumber = 9,
-    kBlockClientTimeoutUsFieldNumber = 14,
-    kNoStartupFieldNumber = 10,
-    kNoRunningFieldNumber = 11,
-    kDumpAtMaxFieldNumber = 13,
-    kDisableForkTeardownFieldNumber = 18,
-    kDisableVforkDetectionFieldNumber = 19,
+  enum FieldNumbers {
+    kCounterPeriodNsFieldNumber = 1,
+    kCounterIdsFieldNumber = 2,
+    kInstrumentedSamplingFieldNumber = 3,
+    kFixGpuClockFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.HeapprofdConfig"; }
 
-  using ContinuousDumpConfig = ::perfetto::protos::pbzero::HeapprofdConfig_ContinuousDumpConfig;
+  GpuCounterConfig();
+  ~GpuCounterConfig() override;
+  GpuCounterConfig(GpuCounterConfig&&) noexcept;
+  GpuCounterConfig& operator=(GpuCounterConfig&&);
+  GpuCounterConfig(const GpuCounterConfig&);
+  GpuCounterConfig& operator=(const GpuCounterConfig&);
+  bool operator==(const GpuCounterConfig&) const;
+  bool operator!=(const GpuCounterConfig& other) const { return !(*this == other); }
 
-  using FieldMetadata_SamplingIntervalBytes =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      HeapprofdConfig>;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SamplingIntervalBytes kSamplingIntervalBytes() { return {}; }
-  void set_sampling_interval_bytes(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SamplingIntervalBytes::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
+  bool has_counter_period_ns() const { return _has_field_[1]; }
+  uint64_t counter_period_ns() const { return counter_period_ns_; }
+  void set_counter_period_ns(uint64_t value) { counter_period_ns_ = value; _has_field_.set(1); }
 
-  using FieldMetadata_AdaptiveSamplingShmemThreshold =
-    ::protozero::proto_utils::FieldMetadata<
-      24,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      HeapprofdConfig>;
+  const std::vector<uint32_t>& counter_ids() const { return counter_ids_; }
+  std::vector<uint32_t>* mutable_counter_ids() { return &counter_ids_; }
+  int counter_ids_size() const { return static_cast<int>(counter_ids_.size()); }
+  void clear_counter_ids() { counter_ids_.clear(); }
+  void add_counter_ids(uint32_t value) { counter_ids_.emplace_back(value); }
+  uint32_t* add_counter_ids() { counter_ids_.emplace_back(); return &counter_ids_.back(); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AdaptiveSamplingShmemThreshold kAdaptiveSamplingShmemThreshold() { return {}; }
-  void set_adaptive_sampling_shmem_threshold(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AdaptiveSamplingShmemThreshold::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
+  bool has_instrumented_sampling() const { return _has_field_[3]; }
+  bool instrumented_sampling() const { return instrumented_sampling_; }
+  void set_instrumented_sampling(bool value) { instrumented_sampling_ = value; _has_field_.set(3); }
 
-  using FieldMetadata_AdaptiveSamplingMaxSamplingIntervalBytes =
-    ::protozero::proto_utils::FieldMetadata<
-      25,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      HeapprofdConfig>;
+  bool has_fix_gpu_clock() const { return _has_field_[4]; }
+  bool fix_gpu_clock() const { return fix_gpu_clock_; }
+  void set_fix_gpu_clock(bool value) { fix_gpu_clock_ = value; _has_field_.set(4); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AdaptiveSamplingMaxSamplingIntervalBytes kAdaptiveSamplingMaxSamplingIntervalBytes() { return {}; }
-  void set_adaptive_sampling_max_sampling_interval_bytes(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AdaptiveSamplingMaxSamplingIntervalBytes::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
+ private:
+  uint64_t counter_period_ns_{};
+  std::vector<uint32_t> counter_ids_;
+  bool instrumented_sampling_{};
+  bool fix_gpu_clock_{};
 
-  using FieldMetadata_ProcessCmdline =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      HeapprofdConfig>;
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessCmdline kProcessCmdline() { return {}; }
-  void add_process_cmdline(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ProcessCmdline::kFieldId, data, size);
-  }
-  void add_process_cmdline(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ProcessCmdline::kFieldId, chars.data, chars.size);
-  }
-  void add_process_cmdline(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProcessCmdline::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  std::bitset<5> _has_field_{};
+};
 
-  using FieldMetadata_Pid =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      HeapprofdConfig>;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void add_pid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_GPU_COUNTER_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/gpu/gpu_renderstages_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_GPU_RENDERSTAGES_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_GPU_RENDERSTAGES_CONFIG_PROTO_CPP_H_
 
-  using FieldMetadata_TargetInstalledBy =
-    ::protozero::proto_utils::FieldMetadata<
-      26,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      HeapprofdConfig>;
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TargetInstalledBy kTargetInstalledBy() { return {}; }
-  void add_target_installed_by(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_TargetInstalledBy::kFieldId, data, size);
-  }
-  void add_target_installed_by(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_TargetInstalledBy::kFieldId, chars.data, chars.size);
-  }
-  void add_target_installed_by(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_TargetInstalledBy::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  using FieldMetadata_Heaps =
-    ::protozero::proto_utils::FieldMetadata<
-      20,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      HeapprofdConfig>;
+namespace perfetto {
+namespace protos {
+namespace gen {
+class GpuRenderStagesConfig;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Heaps kHeaps() { return {}; }
-  void add_heaps(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Heaps::kFieldId, data, size);
-  }
-  void add_heaps(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Heaps::kFieldId, chars.data, chars.size);
-  }
-  void add_heaps(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Heaps::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  using FieldMetadata_ExcludeHeaps =
-    ::protozero::proto_utils::FieldMetadata<
-      27,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      HeapprofdConfig>;
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExcludeHeaps kExcludeHeaps() { return {}; }
-  void add_exclude_heaps(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ExcludeHeaps::kFieldId, data, size);
-  }
-  void add_exclude_heaps(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ExcludeHeaps::kFieldId, chars.data, chars.size);
-  }
-  void add_exclude_heaps(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ExcludeHeaps::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+class PERFETTO_EXPORT_COMPONENT GpuRenderStagesConfig : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kFullLoadstoreFieldNumber = 1,
+    kLowOverheadFieldNumber = 2,
+    kTraceMetricsFieldNumber = 3,
+  };
 
-  using FieldMetadata_StreamAllocations =
-    ::protozero::proto_utils::FieldMetadata<
-      23,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      HeapprofdConfig>;
+  GpuRenderStagesConfig();
+  ~GpuRenderStagesConfig() override;
+  GpuRenderStagesConfig(GpuRenderStagesConfig&&) noexcept;
+  GpuRenderStagesConfig& operator=(GpuRenderStagesConfig&&);
+  GpuRenderStagesConfig(const GpuRenderStagesConfig&);
+  GpuRenderStagesConfig& operator=(const GpuRenderStagesConfig&);
+  bool operator==(const GpuRenderStagesConfig&) const;
+  bool operator!=(const GpuRenderStagesConfig& other) const { return !(*this == other); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StreamAllocations kStreamAllocations() { return {}; }
-  void set_stream_allocations(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_StreamAllocations::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  using FieldMetadata_HeapSamplingIntervals =
-    ::protozero::proto_utils::FieldMetadata<
-      22,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      HeapprofdConfig>;
+  bool has_full_loadstore() const { return _has_field_[1]; }
+  bool full_loadstore() const { return full_loadstore_; }
+  void set_full_loadstore(bool value) { full_loadstore_ = value; _has_field_.set(1); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HeapSamplingIntervals kHeapSamplingIntervals() { return {}; }
-  void add_heap_sampling_intervals(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_HeapSamplingIntervals::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
+  bool has_low_overhead() const { return _has_field_[2]; }
+  bool low_overhead() const { return low_overhead_; }
+  void set_low_overhead(bool value) { low_overhead_ = value; _has_field_.set(2); }
 
-  using FieldMetadata_AllHeaps =
-    ::protozero::proto_utils::FieldMetadata<
-      21,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      HeapprofdConfig>;
+  const std::vector<std::string>& trace_metrics() const { return trace_metrics_; }
+  std::vector<std::string>* mutable_trace_metrics() { return &trace_metrics_; }
+  int trace_metrics_size() const { return static_cast<int>(trace_metrics_.size()); }
+  void clear_trace_metrics() { trace_metrics_.clear(); }
+  void add_trace_metrics(std::string value) { trace_metrics_.emplace_back(value); }
+  std::string* add_trace_metrics() { trace_metrics_.emplace_back(); return &trace_metrics_.back(); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AllHeaps kAllHeaps() { return {}; }
-  void set_all_heaps(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_AllHeaps::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+ private:
+  bool full_loadstore_{};
+  bool low_overhead_{};
+  std::vector<std::string> trace_metrics_;
 
-  using FieldMetadata_All =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      HeapprofdConfig>;
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_All kAll() { return {}; }
-  void set_all(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_All::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  std::bitset<4> _has_field_{};
+};
 
-  using FieldMetadata_MinAnonymousMemoryKb =
-    ::protozero::proto_utils::FieldMetadata<
-      15,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      HeapprofdConfig>;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MinAnonymousMemoryKb kMinAnonymousMemoryKb() { return {}; }
-  void set_min_anonymous_memory_kb(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MinAnonymousMemoryKb::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_GPU_RENDERSTAGES_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/gpu/vulkan_memory_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_VULKAN_MEMORY_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_VULKAN_MEMORY_CONFIG_PROTO_CPP_H_
 
-  using FieldMetadata_MaxHeapprofdMemoryKb =
-    ::protozero::proto_utils::FieldMetadata<
-      16,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      HeapprofdConfig>;
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaxHeapprofdMemoryKb kMaxHeapprofdMemoryKb() { return {}; }
-  void set_max_heapprofd_memory_kb(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MaxHeapprofdMemoryKb::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  using FieldMetadata_MaxHeapprofdCpuSecs =
-    ::protozero::proto_utils::FieldMetadata<
-      17,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      HeapprofdConfig>;
+namespace perfetto {
+namespace protos {
+namespace gen {
+class VulkanMemoryConfig;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaxHeapprofdCpuSecs kMaxHeapprofdCpuSecs() { return {}; }
-  void set_max_heapprofd_cpu_secs(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MaxHeapprofdCpuSecs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  using FieldMetadata_SkipSymbolPrefix =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      HeapprofdConfig>;
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SkipSymbolPrefix kSkipSymbolPrefix() { return {}; }
-  void add_skip_symbol_prefix(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_SkipSymbolPrefix::kFieldId, data, size);
-  }
-  void add_skip_symbol_prefix(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_SkipSymbolPrefix::kFieldId, chars.data, chars.size);
-  }
-  void add_skip_symbol_prefix(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_SkipSymbolPrefix::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+class PERFETTO_EXPORT_COMPONENT VulkanMemoryConfig : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kTrackDriverMemoryUsageFieldNumber = 1,
+    kTrackDeviceMemoryUsageFieldNumber = 2,
+  };
 
-  using FieldMetadata_ContinuousDumpConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      HeapprofdConfig_ContinuousDumpConfig,
-      HeapprofdConfig>;
+  VulkanMemoryConfig();
+  ~VulkanMemoryConfig() override;
+  VulkanMemoryConfig(VulkanMemoryConfig&&) noexcept;
+  VulkanMemoryConfig& operator=(VulkanMemoryConfig&&);
+  VulkanMemoryConfig(const VulkanMemoryConfig&);
+  VulkanMemoryConfig& operator=(const VulkanMemoryConfig&);
+  bool operator==(const VulkanMemoryConfig&) const;
+  bool operator!=(const VulkanMemoryConfig& other) const { return !(*this == other); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ContinuousDumpConfig kContinuousDumpConfig() { return {}; }
-  template <typename T = HeapprofdConfig_ContinuousDumpConfig> T* set_continuous_dump_config() {
-    return BeginNestedMessage<T>(6);
-  }
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
+  bool has_track_driver_memory_usage() const { return _has_field_[1]; }
+  bool track_driver_memory_usage() const { return track_driver_memory_usage_; }
+  void set_track_driver_memory_usage(bool value) { track_driver_memory_usage_ = value; _has_field_.set(1); }
 
-  using FieldMetadata_ShmemSizeBytes =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      HeapprofdConfig>;
+  bool has_track_device_memory_usage() const { return _has_field_[2]; }
+  bool track_device_memory_usage() const { return track_device_memory_usage_; }
+  void set_track_device_memory_usage(bool value) { track_device_memory_usage_ = value; _has_field_.set(2); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ShmemSizeBytes kShmemSizeBytes() { return {}; }
-  void set_shmem_size_bytes(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ShmemSizeBytes::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
+ private:
+  bool track_driver_memory_usage_{};
+  bool track_device_memory_usage_{};
 
-  using FieldMetadata_BlockClient =
-    ::protozero::proto_utils::FieldMetadata<
-      9,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      HeapprofdConfig>;
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockClient kBlockClient() { return {}; }
-  void set_block_client(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_BlockClient::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  std::bitset<3> _has_field_{};
+};
 
-  using FieldMetadata_BlockClientTimeoutUs =
-    ::protozero::proto_utils::FieldMetadata<
-      14,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      HeapprofdConfig>;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockClientTimeoutUs kBlockClientTimeoutUs() { return {}; }
-  void set_block_client_timeout_us(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BlockClientTimeoutUs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_VULKAN_MEMORY_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/inode_file/inode_file_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INODE_FILE_INODE_FILE_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INODE_FILE_INODE_FILE_CONFIG_PROTO_CPP_H_
 
-  using FieldMetadata_NoStartup =
-    ::protozero::proto_utils::FieldMetadata<
-      10,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      HeapprofdConfig>;
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NoStartup kNoStartup() { return {}; }
-  void set_no_startup(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_NoStartup::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  using FieldMetadata_NoRunning =
-    ::protozero::proto_utils::FieldMetadata<
-      11,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      HeapprofdConfig>;
+namespace perfetto {
+namespace protos {
+namespace gen {
+class InodeFileConfig;
+class InodeFileConfig_MountPointMappingEntry;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NoRunning kNoRunning() { return {}; }
-  void set_no_running(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_NoRunning::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  using FieldMetadata_DumpAtMax =
-    ::protozero::proto_utils::FieldMetadata<
-      13,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      HeapprofdConfig>;
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DumpAtMax kDumpAtMax() { return {}; }
-  void set_dump_at_max(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DumpAtMax::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+class PERFETTO_EXPORT_COMPONENT InodeFileConfig : public ::protozero::CppMessageObj {
+ public:
+  using MountPointMappingEntry = InodeFileConfig_MountPointMappingEntry;
+  enum FieldNumbers {
+    kScanIntervalMsFieldNumber = 1,
+    kScanDelayMsFieldNumber = 2,
+    kScanBatchSizeFieldNumber = 3,
+    kDoNotScanFieldNumber = 4,
+    kScanMountPointsFieldNumber = 5,
+    kMountPointMappingFieldNumber = 6,
+  };
 
-  using FieldMetadata_DisableForkTeardown =
-    ::protozero::proto_utils::FieldMetadata<
-      18,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      HeapprofdConfig>;
+  InodeFileConfig();
+  ~InodeFileConfig() override;
+  InodeFileConfig(InodeFileConfig&&) noexcept;
+  InodeFileConfig& operator=(InodeFileConfig&&);
+  InodeFileConfig(const InodeFileConfig&);
+  InodeFileConfig& operator=(const InodeFileConfig&);
+  bool operator==(const InodeFileConfig&) const;
+  bool operator!=(const InodeFileConfig& other) const { return !(*this == other); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DisableForkTeardown kDisableForkTeardown() { return {}; }
-  void set_disable_fork_teardown(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DisableForkTeardown::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  using FieldMetadata_DisableVforkDetection =
-    ::protozero::proto_utils::FieldMetadata<
-      19,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      HeapprofdConfig>;
+  bool has_scan_interval_ms() const { return _has_field_[1]; }
+  uint32_t scan_interval_ms() const { return scan_interval_ms_; }
+  void set_scan_interval_ms(uint32_t value) { scan_interval_ms_ = value; _has_field_.set(1); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DisableVforkDetection kDisableVforkDetection() { return {}; }
-  void set_disable_vfork_detection(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DisableVforkDetection::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-};
+  bool has_scan_delay_ms() const { return _has_field_[2]; }
+  uint32_t scan_delay_ms() const { return scan_delay_ms_; }
+  void set_scan_delay_ms(uint32_t value) { scan_delay_ms_ = value; _has_field_.set(2); }
 
-class HeapprofdConfig_ContinuousDumpConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  HeapprofdConfig_ContinuousDumpConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit HeapprofdConfig_ContinuousDumpConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit HeapprofdConfig_ContinuousDumpConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dump_phase_ms() const { return at<5>().valid(); }
-  uint32_t dump_phase_ms() const { return at<5>().as_uint32(); }
-  bool has_dump_interval_ms() const { return at<6>().valid(); }
-  uint32_t dump_interval_ms() const { return at<6>().as_uint32(); }
+  bool has_scan_batch_size() const { return _has_field_[3]; }
+  uint32_t scan_batch_size() const { return scan_batch_size_; }
+  void set_scan_batch_size(uint32_t value) { scan_batch_size_ = value; _has_field_.set(3); }
+
+  bool has_do_not_scan() const { return _has_field_[4]; }
+  bool do_not_scan() const { return do_not_scan_; }
+  void set_do_not_scan(bool value) { do_not_scan_ = value; _has_field_.set(4); }
+
+  const std::vector<std::string>& scan_mount_points() const { return scan_mount_points_; }
+  std::vector<std::string>* mutable_scan_mount_points() { return &scan_mount_points_; }
+  int scan_mount_points_size() const { return static_cast<int>(scan_mount_points_.size()); }
+  void clear_scan_mount_points() { scan_mount_points_.clear(); }
+  void add_scan_mount_points(std::string value) { scan_mount_points_.emplace_back(value); }
+  std::string* add_scan_mount_points() { scan_mount_points_.emplace_back(); return &scan_mount_points_.back(); }
+
+  const std::vector<InodeFileConfig_MountPointMappingEntry>& mount_point_mapping() const { return mount_point_mapping_; }
+  std::vector<InodeFileConfig_MountPointMappingEntry>* mutable_mount_point_mapping() { return &mount_point_mapping_; }
+  int mount_point_mapping_size() const;
+  void clear_mount_point_mapping();
+  InodeFileConfig_MountPointMappingEntry* add_mount_point_mapping();
+
+ private:
+  uint32_t scan_interval_ms_{};
+  uint32_t scan_delay_ms_{};
+  uint32_t scan_batch_size_{};
+  bool do_not_scan_{};
+  std::vector<std::string> scan_mount_points_;
+  std::vector<InodeFileConfig_MountPointMappingEntry> mount_point_mapping_;
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<7> _has_field_{};
 };
 
-class HeapprofdConfig_ContinuousDumpConfig : public ::protozero::Message {
+
+class PERFETTO_EXPORT_COMPONENT InodeFileConfig_MountPointMappingEntry : public ::protozero::CppMessageObj {
  public:
-  using Decoder = HeapprofdConfig_ContinuousDumpConfig_Decoder;
-  enum : int32_t {
-    kDumpPhaseMsFieldNumber = 5,
-    kDumpIntervalMsFieldNumber = 6,
+  enum FieldNumbers {
+    kMountpointFieldNumber = 1,
+    kScanRootsFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.HeapprofdConfig.ContinuousDumpConfig"; }
 
+  InodeFileConfig_MountPointMappingEntry();
+  ~InodeFileConfig_MountPointMappingEntry() override;
+  InodeFileConfig_MountPointMappingEntry(InodeFileConfig_MountPointMappingEntry&&) noexcept;
+  InodeFileConfig_MountPointMappingEntry& operator=(InodeFileConfig_MountPointMappingEntry&&);
+  InodeFileConfig_MountPointMappingEntry(const InodeFileConfig_MountPointMappingEntry&);
+  InodeFileConfig_MountPointMappingEntry& operator=(const InodeFileConfig_MountPointMappingEntry&);
+  bool operator==(const InodeFileConfig_MountPointMappingEntry&) const;
+  bool operator!=(const InodeFileConfig_MountPointMappingEntry& other) const { return !(*this == other); }
 
-  using FieldMetadata_DumpPhaseMs =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      HeapprofdConfig_ContinuousDumpConfig>;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DumpPhaseMs kDumpPhaseMs() { return {}; }
-  void set_dump_phase_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DumpPhaseMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  bool has_mountpoint() const { return _has_field_[1]; }
+  const std::string& mountpoint() const { return mountpoint_; }
+  void set_mountpoint(const std::string& value) { mountpoint_ = value; _has_field_.set(1); }
 
-  using FieldMetadata_DumpIntervalMs =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      HeapprofdConfig_ContinuousDumpConfig>;
+  const std::vector<std::string>& scan_roots() const { return scan_roots_; }
+  std::vector<std::string>* mutable_scan_roots() { return &scan_roots_; }
+  int scan_roots_size() const { return static_cast<int>(scan_roots_.size()); }
+  void clear_scan_roots() { scan_roots_.clear(); }
+  void add_scan_roots(std::string value) { scan_roots_.emplace_back(value); }
+  std::string* add_scan_roots() { scan_roots_.emplace_back(); return &scan_roots_.back(); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DumpIntervalMs kDumpIntervalMs() { return {}; }
-  void set_dump_interval_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DumpIntervalMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+ private:
+  std::string mountpoint_{};
+  std::vector<std::string> scan_roots_;
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<3> _has_field_{};
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/profiling/java_hprof_config.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_JAVA_HPROF_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_JAVA_HPROF_CONFIG_PROTO_H_
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INODE_FILE_INODE_FILE_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/interceptors/console_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTORS_CONSOLE_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTORS_CONSOLE_CONFIG_PROTO_CPP_H_
 
-#include <stddef.h>
 #include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
 namespace perfetto {
 namespace protos {
-namespace pbzero {
+namespace gen {
+class ConsoleConfig;
+enum ConsoleConfig_Output : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-class JavaHprofConfig_ContinuousDumpConfig;
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-class JavaHprofConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  JavaHprofConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit JavaHprofConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit JavaHprofConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_process_cmdline() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> process_cmdline() const { return GetRepeated<::protozero::ConstChars>(1); }
-  bool has_pid() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> pid() const { return GetRepeated<uint64_t>(2); }
-  bool has_target_installed_by() const { return at<7>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> target_installed_by() const { return GetRepeated<::protozero::ConstChars>(7); }
-  bool has_continuous_dump_config() const { return at<3>().valid(); }
-  ::protozero::ConstBytes continuous_dump_config() const { return at<3>().as_bytes(); }
-  bool has_min_anonymous_memory_kb() const { return at<4>().valid(); }
-  uint32_t min_anonymous_memory_kb() const { return at<4>().as_uint32(); }
-  bool has_dump_smaps() const { return at<5>().valid(); }
-  bool dump_smaps() const { return at<5>().as_bool(); }
-  bool has_ignored_types() const { return at<6>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> ignored_types() const { return GetRepeated<::protozero::ConstChars>(6); }
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum ConsoleConfig_Output : int {
+  ConsoleConfig_Output_OUTPUT_UNSPECIFIED = 0,
+  ConsoleConfig_Output_OUTPUT_STDOUT = 1,
+  ConsoleConfig_Output_OUTPUT_STDERR = 2,
 };
 
-class JavaHprofConfig : public ::protozero::Message {
+class PERFETTO_EXPORT_COMPONENT ConsoleConfig : public ::protozero::CppMessageObj {
  public:
-  using Decoder = JavaHprofConfig_Decoder;
-  enum : int32_t {
-    kProcessCmdlineFieldNumber = 1,
-    kPidFieldNumber = 2,
-    kTargetInstalledByFieldNumber = 7,
-    kContinuousDumpConfigFieldNumber = 3,
-    kMinAnonymousMemoryKbFieldNumber = 4,
-    kDumpSmapsFieldNumber = 5,
-    kIgnoredTypesFieldNumber = 6,
+  using Output = ConsoleConfig_Output;
+  static constexpr auto OUTPUT_UNSPECIFIED = ConsoleConfig_Output_OUTPUT_UNSPECIFIED;
+  static constexpr auto OUTPUT_STDOUT = ConsoleConfig_Output_OUTPUT_STDOUT;
+  static constexpr auto OUTPUT_STDERR = ConsoleConfig_Output_OUTPUT_STDERR;
+  static constexpr auto Output_MIN = ConsoleConfig_Output_OUTPUT_UNSPECIFIED;
+  static constexpr auto Output_MAX = ConsoleConfig_Output_OUTPUT_STDERR;
+  enum FieldNumbers {
+    kOutputFieldNumber = 1,
+    kEnableColorsFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.JavaHprofConfig"; }
-
-  using ContinuousDumpConfig = ::perfetto::protos::pbzero::JavaHprofConfig_ContinuousDumpConfig;
-
-  using FieldMetadata_ProcessCmdline =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      JavaHprofConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessCmdline kProcessCmdline() { return {}; }
-  void add_process_cmdline(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ProcessCmdline::kFieldId, data, size);
-  }
-  void add_process_cmdline(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ProcessCmdline::kFieldId, chars.data, chars.size);
-  }
-  void add_process_cmdline(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProcessCmdline::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
 
-  using FieldMetadata_Pid =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      JavaHprofConfig>;
+  ConsoleConfig();
+  ~ConsoleConfig() override;
+  ConsoleConfig(ConsoleConfig&&) noexcept;
+  ConsoleConfig& operator=(ConsoleConfig&&);
+  ConsoleConfig(const ConsoleConfig&);
+  ConsoleConfig& operator=(const ConsoleConfig&);
+  bool operator==(const ConsoleConfig&) const;
+  bool operator!=(const ConsoleConfig& other) const { return !(*this == other); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void add_pid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  using FieldMetadata_TargetInstalledBy =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      JavaHprofConfig>;
+  bool has_output() const { return _has_field_[1]; }
+  ConsoleConfig_Output output() const { return output_; }
+  void set_output(ConsoleConfig_Output value) { output_ = value; _has_field_.set(1); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TargetInstalledBy kTargetInstalledBy() { return {}; }
-  void add_target_installed_by(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_TargetInstalledBy::kFieldId, data, size);
-  }
-  void add_target_installed_by(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_TargetInstalledBy::kFieldId, chars.data, chars.size);
-  }
-  void add_target_installed_by(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_TargetInstalledBy::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  bool has_enable_colors() const { return _has_field_[2]; }
+  bool enable_colors() const { return enable_colors_; }
+  void set_enable_colors(bool value) { enable_colors_ = value; _has_field_.set(2); }
 
-  using FieldMetadata_ContinuousDumpConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      JavaHprofConfig_ContinuousDumpConfig,
-      JavaHprofConfig>;
+ private:
+  ConsoleConfig_Output output_{};
+  bool enable_colors_{};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ContinuousDumpConfig kContinuousDumpConfig() { return {}; }
-  template <typename T = JavaHprofConfig_ContinuousDumpConfig> T* set_continuous_dump_config() {
-    return BeginNestedMessage<T>(3);
-  }
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
+  std::bitset<3> _has_field_{};
+};
 
-  using FieldMetadata_MinAnonymousMemoryKb =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      JavaHprofConfig>;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MinAnonymousMemoryKb kMinAnonymousMemoryKb() { return {}; }
-  void set_min_anonymous_memory_kb(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MinAnonymousMemoryKb::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTORS_CONSOLE_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/power/android_power_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_POWER_ANDROID_POWER_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_POWER_ANDROID_POWER_CONFIG_PROTO_CPP_H_
 
-  using FieldMetadata_DumpSmaps =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      JavaHprofConfig>;
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DumpSmaps kDumpSmaps() { return {}; }
-  void set_dump_smaps(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DumpSmaps::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  using FieldMetadata_IgnoredTypes =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      JavaHprofConfig>;
+namespace perfetto {
+namespace protos {
+namespace gen {
+class AndroidPowerConfig;
+enum AndroidPowerConfig_BatteryCounters : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IgnoredTypes kIgnoredTypes() { return {}; }
-  void add_ignored_types(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_IgnoredTypes::kFieldId, data, size);
-  }
-  void add_ignored_types(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_IgnoredTypes::kFieldId, chars.data, chars.size);
-  }
-  void add_ignored_types(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_IgnoredTypes::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-};
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-class JavaHprofConfig_ContinuousDumpConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  JavaHprofConfig_ContinuousDumpConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit JavaHprofConfig_ContinuousDumpConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit JavaHprofConfig_ContinuousDumpConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dump_phase_ms() const { return at<1>().valid(); }
-  uint32_t dump_phase_ms() const { return at<1>().as_uint32(); }
-  bool has_dump_interval_ms() const { return at<2>().valid(); }
-  uint32_t dump_interval_ms() const { return at<2>().as_uint32(); }
-  bool has_scan_pids_only_on_start() const { return at<3>().valid(); }
-  bool scan_pids_only_on_start() const { return at<3>().as_bool(); }
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum AndroidPowerConfig_BatteryCounters : int {
+  AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_UNSPECIFIED = 0,
+  AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CHARGE = 1,
+  AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CAPACITY_PERCENT = 2,
+  AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CURRENT = 3,
+  AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CURRENT_AVG = 4,
+  AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_VOLTAGE = 5,
 };
 
-class JavaHprofConfig_ContinuousDumpConfig : public ::protozero::Message {
+class PERFETTO_EXPORT_COMPONENT AndroidPowerConfig : public ::protozero::CppMessageObj {
  public:
-  using Decoder = JavaHprofConfig_ContinuousDumpConfig_Decoder;
-  enum : int32_t {
-    kDumpPhaseMsFieldNumber = 1,
-    kDumpIntervalMsFieldNumber = 2,
-    kScanPidsOnlyOnStartFieldNumber = 3,
+  using BatteryCounters = AndroidPowerConfig_BatteryCounters;
+  static constexpr auto BATTERY_COUNTER_UNSPECIFIED = AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_UNSPECIFIED;
+  static constexpr auto BATTERY_COUNTER_CHARGE = AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CHARGE;
+  static constexpr auto BATTERY_COUNTER_CAPACITY_PERCENT = AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CAPACITY_PERCENT;
+  static constexpr auto BATTERY_COUNTER_CURRENT = AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CURRENT;
+  static constexpr auto BATTERY_COUNTER_CURRENT_AVG = AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CURRENT_AVG;
+  static constexpr auto BATTERY_COUNTER_VOLTAGE = AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_VOLTAGE;
+  static constexpr auto BatteryCounters_MIN = AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_UNSPECIFIED;
+  static constexpr auto BatteryCounters_MAX = AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_VOLTAGE;
+  enum FieldNumbers {
+    kBatteryPollMsFieldNumber = 1,
+    kBatteryCountersFieldNumber = 2,
+    kCollectPowerRailsFieldNumber = 3,
+    kCollectEnergyEstimationBreakdownFieldNumber = 4,
+    kCollectEntityStateResidencyFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.JavaHprofConfig.ContinuousDumpConfig"; }
 
+  AndroidPowerConfig();
+  ~AndroidPowerConfig() override;
+  AndroidPowerConfig(AndroidPowerConfig&&) noexcept;
+  AndroidPowerConfig& operator=(AndroidPowerConfig&&);
+  AndroidPowerConfig(const AndroidPowerConfig&);
+  AndroidPowerConfig& operator=(const AndroidPowerConfig&);
+  bool operator==(const AndroidPowerConfig&) const;
+  bool operator!=(const AndroidPowerConfig& other) const { return !(*this == other); }
 
-  using FieldMetadata_DumpPhaseMs =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      JavaHprofConfig_ContinuousDumpConfig>;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DumpPhaseMs kDumpPhaseMs() { return {}; }
-  void set_dump_phase_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DumpPhaseMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  bool has_battery_poll_ms() const { return _has_field_[1]; }
+  uint32_t battery_poll_ms() const { return battery_poll_ms_; }
+  void set_battery_poll_ms(uint32_t value) { battery_poll_ms_ = value; _has_field_.set(1); }
 
-  using FieldMetadata_DumpIntervalMs =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      JavaHprofConfig_ContinuousDumpConfig>;
+  const std::vector<AndroidPowerConfig_BatteryCounters>& battery_counters() const { return battery_counters_; }
+  std::vector<AndroidPowerConfig_BatteryCounters>* mutable_battery_counters() { return &battery_counters_; }
+  int battery_counters_size() const { return static_cast<int>(battery_counters_.size()); }
+  void clear_battery_counters() { battery_counters_.clear(); }
+  void add_battery_counters(AndroidPowerConfig_BatteryCounters value) { battery_counters_.emplace_back(value); }
+  AndroidPowerConfig_BatteryCounters* add_battery_counters() { battery_counters_.emplace_back(); return &battery_counters_.back(); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DumpIntervalMs kDumpIntervalMs() { return {}; }
-  void set_dump_interval_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DumpIntervalMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  bool has_collect_power_rails() const { return _has_field_[3]; }
+  bool collect_power_rails() const { return collect_power_rails_; }
+  void set_collect_power_rails(bool value) { collect_power_rails_ = value; _has_field_.set(3); }
 
-  using FieldMetadata_ScanPidsOnlyOnStart =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      JavaHprofConfig_ContinuousDumpConfig>;
+  bool has_collect_energy_estimation_breakdown() const { return _has_field_[4]; }
+  bool collect_energy_estimation_breakdown() const { return collect_energy_estimation_breakdown_; }
+  void set_collect_energy_estimation_breakdown(bool value) { collect_energy_estimation_breakdown_ = value; _has_field_.set(4); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ScanPidsOnlyOnStart kScanPidsOnlyOnStart() { return {}; }
-  void set_scan_pids_only_on_start(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_ScanPidsOnlyOnStart::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  bool has_collect_entity_state_residency() const { return _has_field_[5]; }
+  bool collect_entity_state_residency() const { return collect_entity_state_residency_; }
+  void set_collect_entity_state_residency(bool value) { collect_entity_state_residency_ = value; _has_field_.set(5); }
+
+ private:
+  uint32_t battery_poll_ms_{};
+  std::vector<AndroidPowerConfig_BatteryCounters> battery_counters_;
+  bool collect_power_rails_{};
+  bool collect_energy_estimation_breakdown_{};
+  bool collect_entity_state_residency_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<6> _has_field_{};
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/profiling/perf_event_config.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_PERF_EVENT_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_PERF_EVENT_CONFIG_PROTO_H_
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_POWER_ANDROID_POWER_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/priority_boost/priority_boost_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PRIORITY_BOOST_PRIORITY_BOOST_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PRIORITY_BOOST_PRIORITY_BOOST_CONFIG_PROTO_CPP_H_
 
-#include <stddef.h>
 #include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
 namespace perfetto {
 namespace protos {
-namespace pbzero {
+namespace gen {
+class PriorityBoostConfig;
+enum PriorityBoostConfig_BoostPolicy : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-class PerfEventConfig_CallstackSampling;
-class PerfEventConfig_Scope;
-class PerfEvents_Timebase;
-namespace perfetto_pbzero_enum_PerfEventConfig {
-enum UnwindMode : int32_t;
-}  // namespace perfetto_pbzero_enum_PerfEventConfig
-using PerfEventConfig_UnwindMode = perfetto_pbzero_enum_PerfEventConfig::UnwindMode;
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-namespace perfetto_pbzero_enum_PerfEventConfig {
-enum UnwindMode : int32_t {
-  UNWIND_UNKNOWN = 0,
-  UNWIND_SKIP = 1,
-  UNWIND_DWARF = 2,
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum PriorityBoostConfig_BoostPolicy : int {
+  PriorityBoostConfig_BoostPolicy_POLICY_UNSPECIFIED = 0,
+  PriorityBoostConfig_BoostPolicy_POLICY_SCHED_OTHER = 1,
+  PriorityBoostConfig_BoostPolicy_POLICY_SCHED_FIFO = 2,
 };
-} // namespace perfetto_pbzero_enum_PerfEventConfig
-using PerfEventConfig_UnwindMode = perfetto_pbzero_enum_PerfEventConfig::UnwindMode;
 
+class PERFETTO_EXPORT_COMPONENT PriorityBoostConfig : public ::protozero::CppMessageObj {
+ public:
+  using BoostPolicy = PriorityBoostConfig_BoostPolicy;
+  static constexpr auto POLICY_UNSPECIFIED = PriorityBoostConfig_BoostPolicy_POLICY_UNSPECIFIED;
+  static constexpr auto POLICY_SCHED_OTHER = PriorityBoostConfig_BoostPolicy_POLICY_SCHED_OTHER;
+  static constexpr auto POLICY_SCHED_FIFO = PriorityBoostConfig_BoostPolicy_POLICY_SCHED_FIFO;
+  static constexpr auto BoostPolicy_MIN = PriorityBoostConfig_BoostPolicy_POLICY_UNSPECIFIED;
+  static constexpr auto BoostPolicy_MAX = PriorityBoostConfig_BoostPolicy_POLICY_SCHED_FIFO;
+  enum FieldNumbers {
+    kPolicyFieldNumber = 1,
+    kPriorityFieldNumber = 2,
+  };
 
-constexpr PerfEventConfig_UnwindMode PerfEventConfig_UnwindMode_MIN = PerfEventConfig_UnwindMode::UNWIND_UNKNOWN;
-constexpr PerfEventConfig_UnwindMode PerfEventConfig_UnwindMode_MAX = PerfEventConfig_UnwindMode::UNWIND_DWARF;
+  PriorityBoostConfig();
+  ~PriorityBoostConfig() override;
+  PriorityBoostConfig(PriorityBoostConfig&&) noexcept;
+  PriorityBoostConfig& operator=(PriorityBoostConfig&&);
+  PriorityBoostConfig(const PriorityBoostConfig&);
+  PriorityBoostConfig& operator=(const PriorityBoostConfig&);
+  bool operator==(const PriorityBoostConfig&) const;
+  bool operator!=(const PriorityBoostConfig& other) const { return !(*this == other); }
 
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* PerfEventConfig_UnwindMode_Name(::perfetto::protos::pbzero::PerfEventConfig_UnwindMode value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::PerfEventConfig_UnwindMode::UNWIND_UNKNOWN:
-    return "UNWIND_UNKNOWN";
+  bool has_policy() const { return _has_field_[1]; }
+  PriorityBoostConfig_BoostPolicy policy() const { return policy_; }
+  void set_policy(PriorityBoostConfig_BoostPolicy value) { policy_ = value; _has_field_.set(1); }
 
-  case ::perfetto::protos::pbzero::PerfEventConfig_UnwindMode::UNWIND_SKIP:
-    return "UNWIND_SKIP";
+  bool has_priority() const { return _has_field_[2]; }
+  uint32_t priority() const { return priority_; }
+  void set_priority(uint32_t value) { priority_ = value; _has_field_.set(2); }
 
-  case ::perfetto::protos::pbzero::PerfEventConfig_UnwindMode::UNWIND_DWARF:
-    return "UNWIND_DWARF";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+ private:
+  PriorityBoostConfig_BoostPolicy policy_{};
+  uint32_t priority_{};
 
-class PerfEventConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/18, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  PerfEventConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit PerfEventConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit PerfEventConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_timebase() const { return at<15>().valid(); }
-  ::protozero::ConstBytes timebase() const { return at<15>().as_bytes(); }
-  bool has_callstack_sampling() const { return at<16>().valid(); }
-  ::protozero::ConstBytes callstack_sampling() const { return at<16>().as_bytes(); }
-  bool has_ring_buffer_read_period_ms() const { return at<8>().valid(); }
-  uint32_t ring_buffer_read_period_ms() const { return at<8>().as_uint32(); }
-  bool has_ring_buffer_pages() const { return at<3>().valid(); }
-  uint32_t ring_buffer_pages() const { return at<3>().as_uint32(); }
-  bool has_max_enqueued_footprint_kb() const { return at<17>().valid(); }
-  uint64_t max_enqueued_footprint_kb() const { return at<17>().as_uint64(); }
-  bool has_max_daemon_memory_kb() const { return at<13>().valid(); }
-  uint32_t max_daemon_memory_kb() const { return at<13>().as_uint32(); }
-  bool has_remote_descriptor_timeout_ms() const { return at<9>().valid(); }
-  uint32_t remote_descriptor_timeout_ms() const { return at<9>().as_uint32(); }
-  bool has_unwind_state_clear_period_ms() const { return at<10>().valid(); }
-  uint32_t unwind_state_clear_period_ms() const { return at<10>().as_uint32(); }
-  bool has_target_installed_by() const { return at<18>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> target_installed_by() const { return GetRepeated<::protozero::ConstChars>(18); }
-  bool has_all_cpus() const { return at<1>().valid(); }
-  bool all_cpus() const { return at<1>().as_bool(); }
-  bool has_sampling_frequency() const { return at<2>().valid(); }
-  uint32_t sampling_frequency() const { return at<2>().as_uint32(); }
-  bool has_kernel_frames() const { return at<12>().valid(); }
-  bool kernel_frames() const { return at<12>().as_bool(); }
-  bool has_target_pid() const { return at<4>().valid(); }
-  ::protozero::RepeatedFieldIterator<int32_t> target_pid() const { return GetRepeated<int32_t>(4); }
-  bool has_target_cmdline() const { return at<5>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> target_cmdline() const { return GetRepeated<::protozero::ConstChars>(5); }
-  bool has_exclude_pid() const { return at<6>().valid(); }
-  ::protozero::RepeatedFieldIterator<int32_t> exclude_pid() const { return GetRepeated<int32_t>(6); }
-  bool has_exclude_cmdline() const { return at<7>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> exclude_cmdline() const { return GetRepeated<::protozero::ConstChars>(7); }
-  bool has_additional_cmdline_count() const { return at<11>().valid(); }
-  uint32_t additional_cmdline_count() const { return at<11>().as_uint32(); }
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<3> _has_field_{};
 };
 
-class PerfEventConfig : public ::protozero::Message {
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PRIORITY_BOOST_PRIORITY_BOOST_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/process_stats/process_stats_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROCESS_STATS_PROCESS_STATS_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROCESS_STATS_PROCESS_STATS_CONFIG_PROTO_CPP_H_
+
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+class ProcessStatsConfig;
+enum ProcessStatsConfig_Quirks : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+namespace protozero {
+class Message;
+}  // namespace protozero
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum ProcessStatsConfig_Quirks : int {
+  ProcessStatsConfig_Quirks_QUIRKS_UNSPECIFIED = 0,
+  ProcessStatsConfig_Quirks_DISABLE_INITIAL_DUMP = 1,
+  ProcessStatsConfig_Quirks_DISABLE_ON_DEMAND = 2,
+};
+
+class PERFETTO_EXPORT_COMPONENT ProcessStatsConfig : public ::protozero::CppMessageObj {
  public:
-  using Decoder = PerfEventConfig_Decoder;
-  enum : int32_t {
-    kTimebaseFieldNumber = 15,
-    kCallstackSamplingFieldNumber = 16,
-    kRingBufferReadPeriodMsFieldNumber = 8,
-    kRingBufferPagesFieldNumber = 3,
-    kMaxEnqueuedFootprintKbFieldNumber = 17,
-    kMaxDaemonMemoryKbFieldNumber = 13,
-    kRemoteDescriptorTimeoutMsFieldNumber = 9,
-    kUnwindStateClearPeriodMsFieldNumber = 10,
-    kTargetInstalledByFieldNumber = 18,
-    kAllCpusFieldNumber = 1,
-    kSamplingFrequencyFieldNumber = 2,
-    kKernelFramesFieldNumber = 12,
-    kTargetPidFieldNumber = 4,
-    kTargetCmdlineFieldNumber = 5,
-    kExcludePidFieldNumber = 6,
-    kExcludeCmdlineFieldNumber = 7,
-    kAdditionalCmdlineCountFieldNumber = 11,
+  using Quirks = ProcessStatsConfig_Quirks;
+  static constexpr auto QUIRKS_UNSPECIFIED = ProcessStatsConfig_Quirks_QUIRKS_UNSPECIFIED;
+  static constexpr auto DISABLE_INITIAL_DUMP = ProcessStatsConfig_Quirks_DISABLE_INITIAL_DUMP;
+  static constexpr auto DISABLE_ON_DEMAND = ProcessStatsConfig_Quirks_DISABLE_ON_DEMAND;
+  static constexpr auto Quirks_MIN = ProcessStatsConfig_Quirks_QUIRKS_UNSPECIFIED;
+  static constexpr auto Quirks_MAX = ProcessStatsConfig_Quirks_DISABLE_ON_DEMAND;
+  enum FieldNumbers {
+    kQuirksFieldNumber = 1,
+    kScanAllProcessesOnStartFieldNumber = 2,
+    kRecordThreadNamesFieldNumber = 3,
+    kProcStatsPollMsFieldNumber = 4,
+    kProcStatsCacheTtlMsFieldNumber = 6,
+    kScanSmapsRollupFieldNumber = 10,
+    kRecordProcessAgeFieldNumber = 11,
+    kRecordProcessRuntimeFieldNumber = 12,
+    kRecordProcessDmabufRssFieldNumber = 13,
+    kResolveProcessFdsFieldNumber = 9,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.PerfEventConfig"; }
 
-  using CallstackSampling = ::perfetto::protos::pbzero::PerfEventConfig_CallstackSampling;
-  using Scope = ::perfetto::protos::pbzero::PerfEventConfig_Scope;
+  ProcessStatsConfig();
+  ~ProcessStatsConfig() override;
+  ProcessStatsConfig(ProcessStatsConfig&&) noexcept;
+  ProcessStatsConfig& operator=(ProcessStatsConfig&&);
+  ProcessStatsConfig(const ProcessStatsConfig&);
+  ProcessStatsConfig& operator=(const ProcessStatsConfig&);
+  bool operator==(const ProcessStatsConfig&) const;
+  bool operator!=(const ProcessStatsConfig& other) const { return !(*this == other); }
 
-  using UnwindMode = ::perfetto::protos::pbzero::PerfEventConfig_UnwindMode;
-  static inline const char* UnwindMode_Name(UnwindMode value) {
-    return ::perfetto::protos::pbzero::PerfEventConfig_UnwindMode_Name(value);
-  }
-  static const UnwindMode UNWIND_UNKNOWN = UnwindMode::UNWIND_UNKNOWN;
-  static const UnwindMode UNWIND_SKIP = UnwindMode::UNWIND_SKIP;
-  static const UnwindMode UNWIND_DWARF = UnwindMode::UNWIND_DWARF;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  using FieldMetadata_Timebase =
-    ::protozero::proto_utils::FieldMetadata<
-      15,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      PerfEvents_Timebase,
-      PerfEventConfig>;
+  const std::vector<ProcessStatsConfig_Quirks>& quirks() const { return quirks_; }
+  std::vector<ProcessStatsConfig_Quirks>* mutable_quirks() { return &quirks_; }
+  int quirks_size() const { return static_cast<int>(quirks_.size()); }
+  void clear_quirks() { quirks_.clear(); }
+  void add_quirks(ProcessStatsConfig_Quirks value) { quirks_.emplace_back(value); }
+  ProcessStatsConfig_Quirks* add_quirks() { quirks_.emplace_back(); return &quirks_.back(); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timebase kTimebase() { return {}; }
-  template <typename T = PerfEvents_Timebase> T* set_timebase() {
-    return BeginNestedMessage<T>(15);
-  }
+  bool has_scan_all_processes_on_start() const { return _has_field_[2]; }
+  bool scan_all_processes_on_start() const { return scan_all_processes_on_start_; }
+  void set_scan_all_processes_on_start(bool value) { scan_all_processes_on_start_ = value; _has_field_.set(2); }
 
+  bool has_record_thread_names() const { return _has_field_[3]; }
+  bool record_thread_names() const { return record_thread_names_; }
+  void set_record_thread_names(bool value) { record_thread_names_ = value; _has_field_.set(3); }
 
-  using FieldMetadata_CallstackSampling =
-    ::protozero::proto_utils::FieldMetadata<
-      16,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      PerfEventConfig_CallstackSampling,
-      PerfEventConfig>;
+  bool has_proc_stats_poll_ms() const { return _has_field_[4]; }
+  uint32_t proc_stats_poll_ms() const { return proc_stats_poll_ms_; }
+  void set_proc_stats_poll_ms(uint32_t value) { proc_stats_poll_ms_ = value; _has_field_.set(4); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CallstackSampling kCallstackSampling() { return {}; }
-  template <typename T = PerfEventConfig_CallstackSampling> T* set_callstack_sampling() {
-    return BeginNestedMessage<T>(16);
-  }
+  bool has_proc_stats_cache_ttl_ms() const { return _has_field_[6]; }
+  uint32_t proc_stats_cache_ttl_ms() const { return proc_stats_cache_ttl_ms_; }
+  void set_proc_stats_cache_ttl_ms(uint32_t value) { proc_stats_cache_ttl_ms_ = value; _has_field_.set(6); }
 
+  bool has_scan_smaps_rollup() const { return _has_field_[10]; }
+  bool scan_smaps_rollup() const { return scan_smaps_rollup_; }
+  void set_scan_smaps_rollup(bool value) { scan_smaps_rollup_ = value; _has_field_.set(10); }
 
-  using FieldMetadata_RingBufferReadPeriodMs =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      PerfEventConfig>;
+  bool has_record_process_age() const { return _has_field_[11]; }
+  bool record_process_age() const { return record_process_age_; }
+  void set_record_process_age(bool value) { record_process_age_ = value; _has_field_.set(11); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RingBufferReadPeriodMs kRingBufferReadPeriodMs() { return {}; }
-  void set_ring_buffer_read_period_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RingBufferReadPeriodMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  bool has_record_process_runtime() const { return _has_field_[12]; }
+  bool record_process_runtime() const { return record_process_runtime_; }
+  void set_record_process_runtime(bool value) { record_process_runtime_ = value; _has_field_.set(12); }
 
-  using FieldMetadata_RingBufferPages =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      PerfEventConfig>;
+  bool has_record_process_dmabuf_rss() const { return _has_field_[13]; }
+  bool record_process_dmabuf_rss() const { return record_process_dmabuf_rss_; }
+  void set_record_process_dmabuf_rss(bool value) { record_process_dmabuf_rss_ = value; _has_field_.set(13); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RingBufferPages kRingBufferPages() { return {}; }
-  void set_ring_buffer_pages(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RingBufferPages::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  bool has_resolve_process_fds() const { return _has_field_[9]; }
+  bool resolve_process_fds() const { return resolve_process_fds_; }
+  void set_resolve_process_fds(bool value) { resolve_process_fds_ = value; _has_field_.set(9); }
 
-  using FieldMetadata_MaxEnqueuedFootprintKb =
-    ::protozero::proto_utils::FieldMetadata<
-      17,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      PerfEventConfig>;
+ private:
+  std::vector<ProcessStatsConfig_Quirks> quirks_;
+  bool scan_all_processes_on_start_{};
+  bool record_thread_names_{};
+  uint32_t proc_stats_poll_ms_{};
+  uint32_t proc_stats_cache_ttl_ms_{};
+  bool scan_smaps_rollup_{};
+  bool record_process_age_{};
+  bool record_process_runtime_{};
+  bool record_process_dmabuf_rss_{};
+  bool resolve_process_fds_{};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaxEnqueuedFootprintKb kMaxEnqueuedFootprintKb() { return {}; }
-  void set_max_enqueued_footprint_kb(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MaxEnqueuedFootprintKb::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  using FieldMetadata_MaxDaemonMemoryKb =
-    ::protozero::proto_utils::FieldMetadata<
-      13,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      PerfEventConfig>;
+  std::bitset<14> _has_field_{};
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaxDaemonMemoryKb kMaxDaemonMemoryKb() { return {}; }
-  void set_max_daemon_memory_kb(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MaxDaemonMemoryKb::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  using FieldMetadata_RemoteDescriptorTimeoutMs =
-    ::protozero::proto_utils::FieldMetadata<
-      9,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      PerfEventConfig>;
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROCESS_STATS_PROCESS_STATS_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/profiling/heapprofd_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_HEAPPROFD_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_HEAPPROFD_CONFIG_PROTO_CPP_H_
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RemoteDescriptorTimeoutMs kRemoteDescriptorTimeoutMs() { return {}; }
-  void set_remote_descriptor_timeout_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RemoteDescriptorTimeoutMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  using FieldMetadata_UnwindStateClearPeriodMs =
-    ::protozero::proto_utils::FieldMetadata<
-      10,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      PerfEventConfig>;
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UnwindStateClearPeriodMs kUnwindStateClearPeriodMs() { return {}; }
-  void set_unwind_state_clear_period_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_UnwindStateClearPeriodMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+namespace perfetto {
+namespace protos {
+namespace gen {
+class HeapprofdConfig;
+class HeapprofdConfig_ContinuousDumpConfig;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  using FieldMetadata_TargetInstalledBy =
-    ::protozero::proto_utils::FieldMetadata<
-      18,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      PerfEventConfig>;
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TargetInstalledBy kTargetInstalledBy() { return {}; }
-  void add_target_installed_by(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_TargetInstalledBy::kFieldId, data, size);
-  }
-  void add_target_installed_by(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_TargetInstalledBy::kFieldId, chars.data, chars.size);
-  }
-  void add_target_installed_by(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_TargetInstalledBy::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-  using FieldMetadata_AllCpus =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      PerfEventConfig>;
+class PERFETTO_EXPORT_COMPONENT HeapprofdConfig : public ::protozero::CppMessageObj {
+ public:
+  using ContinuousDumpConfig = HeapprofdConfig_ContinuousDumpConfig;
+  enum FieldNumbers {
+    kSamplingIntervalBytesFieldNumber = 1,
+    kAdaptiveSamplingShmemThresholdFieldNumber = 24,
+    kAdaptiveSamplingMaxSamplingIntervalBytesFieldNumber = 25,
+    kProcessCmdlineFieldNumber = 2,
+    kPidFieldNumber = 4,
+    kTargetInstalledByFieldNumber = 26,
+    kHeapsFieldNumber = 20,
+    kExcludeHeapsFieldNumber = 27,
+    kStreamAllocationsFieldNumber = 23,
+    kHeapSamplingIntervalsFieldNumber = 22,
+    kAllHeapsFieldNumber = 21,
+    kAllFieldNumber = 5,
+    kMinAnonymousMemoryKbFieldNumber = 15,
+    kMaxHeapprofdMemoryKbFieldNumber = 16,
+    kMaxHeapprofdCpuSecsFieldNumber = 17,
+    kSkipSymbolPrefixFieldNumber = 7,
+    kContinuousDumpConfigFieldNumber = 6,
+    kShmemSizeBytesFieldNumber = 8,
+    kBlockClientFieldNumber = 9,
+    kBlockClientTimeoutUsFieldNumber = 14,
+    kNoStartupFieldNumber = 10,
+    kNoRunningFieldNumber = 11,
+    kDumpAtMaxFieldNumber = 13,
+    kDisableForkTeardownFieldNumber = 18,
+    kDisableVforkDetectionFieldNumber = 19,
+  };
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AllCpus kAllCpus() { return {}; }
-  void set_all_cpus(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_AllCpus::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  HeapprofdConfig();
+  ~HeapprofdConfig() override;
+  HeapprofdConfig(HeapprofdConfig&&) noexcept;
+  HeapprofdConfig& operator=(HeapprofdConfig&&);
+  HeapprofdConfig(const HeapprofdConfig&);
+  HeapprofdConfig& operator=(const HeapprofdConfig&);
+  bool operator==(const HeapprofdConfig&) const;
+  bool operator!=(const HeapprofdConfig& other) const { return !(*this == other); }
 
-  using FieldMetadata_SamplingFrequency =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      PerfEventConfig>;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SamplingFrequency kSamplingFrequency() { return {}; }
-  void set_sampling_frequency(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SamplingFrequency::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  bool has_sampling_interval_bytes() const { return _has_field_[1]; }
+  uint64_t sampling_interval_bytes() const { return sampling_interval_bytes_; }
+  void set_sampling_interval_bytes(uint64_t value) { sampling_interval_bytes_ = value; _has_field_.set(1); }
 
-  using FieldMetadata_KernelFrames =
-    ::protozero::proto_utils::FieldMetadata<
-      12,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      PerfEventConfig>;
+  bool has_adaptive_sampling_shmem_threshold() const { return _has_field_[24]; }
+  uint64_t adaptive_sampling_shmem_threshold() const { return adaptive_sampling_shmem_threshold_; }
+  void set_adaptive_sampling_shmem_threshold(uint64_t value) { adaptive_sampling_shmem_threshold_ = value; _has_field_.set(24); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KernelFrames kKernelFrames() { return {}; }
-  void set_kernel_frames(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_KernelFrames::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  bool has_adaptive_sampling_max_sampling_interval_bytes() const { return _has_field_[25]; }
+  uint64_t adaptive_sampling_max_sampling_interval_bytes() const { return adaptive_sampling_max_sampling_interval_bytes_; }
+  void set_adaptive_sampling_max_sampling_interval_bytes(uint64_t value) { adaptive_sampling_max_sampling_interval_bytes_ = value; _has_field_.set(25); }
 
-  using FieldMetadata_TargetPid =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      PerfEventConfig>;
+  const std::vector<std::string>& process_cmdline() const { return process_cmdline_; }
+  std::vector<std::string>* mutable_process_cmdline() { return &process_cmdline_; }
+  int process_cmdline_size() const { return static_cast<int>(process_cmdline_.size()); }
+  void clear_process_cmdline() { process_cmdline_.clear(); }
+  void add_process_cmdline(std::string value) { process_cmdline_.emplace_back(value); }
+  std::string* add_process_cmdline() { process_cmdline_.emplace_back(); return &process_cmdline_.back(); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TargetPid kTargetPid() { return {}; }
-  void add_target_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TargetPid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+  const std::vector<uint64_t>& pid() const { return pid_; }
+  std::vector<uint64_t>* mutable_pid() { return &pid_; }
+  int pid_size() const { return static_cast<int>(pid_.size()); }
+  void clear_pid() { pid_.clear(); }
+  void add_pid(uint64_t value) { pid_.emplace_back(value); }
+  uint64_t* add_pid() { pid_.emplace_back(); return &pid_.back(); }
 
-  using FieldMetadata_TargetCmdline =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      PerfEventConfig>;
+  const std::vector<std::string>& target_installed_by() const { return target_installed_by_; }
+  std::vector<std::string>* mutable_target_installed_by() { return &target_installed_by_; }
+  int target_installed_by_size() const { return static_cast<int>(target_installed_by_.size()); }
+  void clear_target_installed_by() { target_installed_by_.clear(); }
+  void add_target_installed_by(std::string value) { target_installed_by_.emplace_back(value); }
+  std::string* add_target_installed_by() { target_installed_by_.emplace_back(); return &target_installed_by_.back(); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TargetCmdline kTargetCmdline() { return {}; }
-  void add_target_cmdline(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_TargetCmdline::kFieldId, data, size);
-  }
-  void add_target_cmdline(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_TargetCmdline::kFieldId, chars.data, chars.size);
-  }
-  void add_target_cmdline(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_TargetCmdline::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  const std::vector<std::string>& heaps() const { return heaps_; }
+  std::vector<std::string>* mutable_heaps() { return &heaps_; }
+  int heaps_size() const { return static_cast<int>(heaps_.size()); }
+  void clear_heaps() { heaps_.clear(); }
+  void add_heaps(std::string value) { heaps_.emplace_back(value); }
+  std::string* add_heaps() { heaps_.emplace_back(); return &heaps_.back(); }
 
-  using FieldMetadata_ExcludePid =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      PerfEventConfig>;
+  const std::vector<std::string>& exclude_heaps() const { return exclude_heaps_; }
+  std::vector<std::string>* mutable_exclude_heaps() { return &exclude_heaps_; }
+  int exclude_heaps_size() const { return static_cast<int>(exclude_heaps_.size()); }
+  void clear_exclude_heaps() { exclude_heaps_.clear(); }
+  void add_exclude_heaps(std::string value) { exclude_heaps_.emplace_back(value); }
+  std::string* add_exclude_heaps() { exclude_heaps_.emplace_back(); return &exclude_heaps_.back(); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExcludePid kExcludePid() { return {}; }
-  void add_exclude_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ExcludePid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+  bool has_stream_allocations() const { return _has_field_[23]; }
+  bool stream_allocations() const { return stream_allocations_; }
+  void set_stream_allocations(bool value) { stream_allocations_ = value; _has_field_.set(23); }
 
-  using FieldMetadata_ExcludeCmdline =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      PerfEventConfig>;
+  const std::vector<uint64_t>& heap_sampling_intervals() const { return heap_sampling_intervals_; }
+  std::vector<uint64_t>* mutable_heap_sampling_intervals() { return &heap_sampling_intervals_; }
+  int heap_sampling_intervals_size() const { return static_cast<int>(heap_sampling_intervals_.size()); }
+  void clear_heap_sampling_intervals() { heap_sampling_intervals_.clear(); }
+  void add_heap_sampling_intervals(uint64_t value) { heap_sampling_intervals_.emplace_back(value); }
+  uint64_t* add_heap_sampling_intervals() { heap_sampling_intervals_.emplace_back(); return &heap_sampling_intervals_.back(); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExcludeCmdline kExcludeCmdline() { return {}; }
-  void add_exclude_cmdline(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ExcludeCmdline::kFieldId, data, size);
-  }
-  void add_exclude_cmdline(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ExcludeCmdline::kFieldId, chars.data, chars.size);
-  }
-  void add_exclude_cmdline(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ExcludeCmdline::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  bool has_all_heaps() const { return _has_field_[21]; }
+  bool all_heaps() const { return all_heaps_; }
+  void set_all_heaps(bool value) { all_heaps_ = value; _has_field_.set(21); }
 
-  using FieldMetadata_AdditionalCmdlineCount =
-    ::protozero::proto_utils::FieldMetadata<
-      11,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      PerfEventConfig>;
+  bool has_all() const { return _has_field_[5]; }
+  bool all() const { return all_; }
+  void set_all(bool value) { all_ = value; _has_field_.set(5); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AdditionalCmdlineCount kAdditionalCmdlineCount() { return {}; }
-  void set_additional_cmdline_count(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AdditionalCmdlineCount::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-};
+  bool has_min_anonymous_memory_kb() const { return _has_field_[15]; }
+  uint32_t min_anonymous_memory_kb() const { return min_anonymous_memory_kb_; }
+  void set_min_anonymous_memory_kb(uint32_t value) { min_anonymous_memory_kb_ = value; _has_field_.set(15); }
 
-class PerfEventConfig_Scope_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  PerfEventConfig_Scope_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit PerfEventConfig_Scope_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit PerfEventConfig_Scope_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_target_pid() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<int32_t> target_pid() const { return GetRepeated<int32_t>(1); }
-  bool has_target_cmdline() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> target_cmdline() const { return GetRepeated<::protozero::ConstChars>(2); }
-  bool has_exclude_pid() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<int32_t> exclude_pid() const { return GetRepeated<int32_t>(3); }
-  bool has_exclude_cmdline() const { return at<4>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> exclude_cmdline() const { return GetRepeated<::protozero::ConstChars>(4); }
-  bool has_additional_cmdline_count() const { return at<5>().valid(); }
-  uint32_t additional_cmdline_count() const { return at<5>().as_uint32(); }
-  bool has_process_shard_count() const { return at<6>().valid(); }
-  uint32_t process_shard_count() const { return at<6>().as_uint32(); }
-};
+  bool has_max_heapprofd_memory_kb() const { return _has_field_[16]; }
+  uint32_t max_heapprofd_memory_kb() const { return max_heapprofd_memory_kb_; }
+  void set_max_heapprofd_memory_kb(uint32_t value) { max_heapprofd_memory_kb_ = value; _has_field_.set(16); }
 
-class PerfEventConfig_Scope : public ::protozero::Message {
- public:
-  using Decoder = PerfEventConfig_Scope_Decoder;
-  enum : int32_t {
-    kTargetPidFieldNumber = 1,
-    kTargetCmdlineFieldNumber = 2,
-    kExcludePidFieldNumber = 3,
-    kExcludeCmdlineFieldNumber = 4,
-    kAdditionalCmdlineCountFieldNumber = 5,
-    kProcessShardCountFieldNumber = 6,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.PerfEventConfig.Scope"; }
+  bool has_max_heapprofd_cpu_secs() const { return _has_field_[17]; }
+  uint64_t max_heapprofd_cpu_secs() const { return max_heapprofd_cpu_secs_; }
+  void set_max_heapprofd_cpu_secs(uint64_t value) { max_heapprofd_cpu_secs_ = value; _has_field_.set(17); }
 
+  const std::vector<std::string>& skip_symbol_prefix() const { return skip_symbol_prefix_; }
+  std::vector<std::string>* mutable_skip_symbol_prefix() { return &skip_symbol_prefix_; }
+  int skip_symbol_prefix_size() const { return static_cast<int>(skip_symbol_prefix_.size()); }
+  void clear_skip_symbol_prefix() { skip_symbol_prefix_.clear(); }
+  void add_skip_symbol_prefix(std::string value) { skip_symbol_prefix_.emplace_back(value); }
+  std::string* add_skip_symbol_prefix() { skip_symbol_prefix_.emplace_back(); return &skip_symbol_prefix_.back(); }
 
-  using FieldMetadata_TargetPid =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      PerfEventConfig_Scope>;
+  bool has_continuous_dump_config() const { return _has_field_[6]; }
+  const HeapprofdConfig_ContinuousDumpConfig& continuous_dump_config() const { return *continuous_dump_config_; }
+  HeapprofdConfig_ContinuousDumpConfig* mutable_continuous_dump_config() { _has_field_.set(6); return continuous_dump_config_.get(); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TargetPid kTargetPid() { return {}; }
-  void add_target_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TargetPid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+  bool has_shmem_size_bytes() const { return _has_field_[8]; }
+  uint64_t shmem_size_bytes() const { return shmem_size_bytes_; }
+  void set_shmem_size_bytes(uint64_t value) { shmem_size_bytes_ = value; _has_field_.set(8); }
 
-  using FieldMetadata_TargetCmdline =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      PerfEventConfig_Scope>;
+  bool has_block_client() const { return _has_field_[9]; }
+  bool block_client() const { return block_client_; }
+  void set_block_client(bool value) { block_client_ = value; _has_field_.set(9); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TargetCmdline kTargetCmdline() { return {}; }
-  void add_target_cmdline(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_TargetCmdline::kFieldId, data, size);
-  }
-  void add_target_cmdline(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_TargetCmdline::kFieldId, chars.data, chars.size);
-  }
-  void add_target_cmdline(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_TargetCmdline::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  bool has_block_client_timeout_us() const { return _has_field_[14]; }
+  uint32_t block_client_timeout_us() const { return block_client_timeout_us_; }
+  void set_block_client_timeout_us(uint32_t value) { block_client_timeout_us_ = value; _has_field_.set(14); }
 
-  using FieldMetadata_ExcludePid =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      PerfEventConfig_Scope>;
+  bool has_no_startup() const { return _has_field_[10]; }
+  bool no_startup() const { return no_startup_; }
+  void set_no_startup(bool value) { no_startup_ = value; _has_field_.set(10); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExcludePid kExcludePid() { return {}; }
-  void add_exclude_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ExcludePid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+  bool has_no_running() const { return _has_field_[11]; }
+  bool no_running() const { return no_running_; }
+  void set_no_running(bool value) { no_running_ = value; _has_field_.set(11); }
 
-  using FieldMetadata_ExcludeCmdline =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      PerfEventConfig_Scope>;
+  bool has_dump_at_max() const { return _has_field_[13]; }
+  bool dump_at_max() const { return dump_at_max_; }
+  void set_dump_at_max(bool value) { dump_at_max_ = value; _has_field_.set(13); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExcludeCmdline kExcludeCmdline() { return {}; }
-  void add_exclude_cmdline(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ExcludeCmdline::kFieldId, data, size);
-  }
-  void add_exclude_cmdline(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ExcludeCmdline::kFieldId, chars.data, chars.size);
-  }
-  void add_exclude_cmdline(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ExcludeCmdline::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  bool has_disable_fork_teardown() const { return _has_field_[18]; }
+  bool disable_fork_teardown() const { return disable_fork_teardown_; }
+  void set_disable_fork_teardown(bool value) { disable_fork_teardown_ = value; _has_field_.set(18); }
 
-  using FieldMetadata_AdditionalCmdlineCount =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      PerfEventConfig_Scope>;
+  bool has_disable_vfork_detection() const { return _has_field_[19]; }
+  bool disable_vfork_detection() const { return disable_vfork_detection_; }
+  void set_disable_vfork_detection(bool value) { disable_vfork_detection_ = value; _has_field_.set(19); }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AdditionalCmdlineCount kAdditionalCmdlineCount() { return {}; }
-  void set_additional_cmdline_count(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AdditionalCmdlineCount::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+ private:
+  uint64_t sampling_interval_bytes_{};
+  uint64_t adaptive_sampling_shmem_threshold_{};
+  uint64_t adaptive_sampling_max_sampling_interval_bytes_{};
+  std::vector<std::string> process_cmdline_;
+  std::vector<uint64_t> pid_;
+  std::vector<std::string> target_installed_by_;
+  std::vector<std::string> heaps_;
+  std::vector<std::string> exclude_heaps_;
+  bool stream_allocations_{};
+  std::vector<uint64_t> heap_sampling_intervals_;
+  bool all_heaps_{};
+  bool all_{};
+  uint32_t min_anonymous_memory_kb_{};
+  uint32_t max_heapprofd_memory_kb_{};
+  uint64_t max_heapprofd_cpu_secs_{};
+  std::vector<std::string> skip_symbol_prefix_;
+  ::protozero::CopyablePtr<HeapprofdConfig_ContinuousDumpConfig> continuous_dump_config_;
+  uint64_t shmem_size_bytes_{};
+  bool block_client_{};
+  uint32_t block_client_timeout_us_{};
+  bool no_startup_{};
+  bool no_running_{};
+  bool dump_at_max_{};
+  bool disable_fork_teardown_{};
+  bool disable_vfork_detection_{};
 
-  using FieldMetadata_ProcessShardCount =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      PerfEventConfig_Scope>;
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessShardCount kProcessShardCount() { return {}; }
-  void set_process_shard_count(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProcessShardCount::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  std::bitset<28> _has_field_{};
 };
 
-class PerfEventConfig_CallstackSampling_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  PerfEventConfig_CallstackSampling_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit PerfEventConfig_CallstackSampling_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit PerfEventConfig_CallstackSampling_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_scope() const { return at<1>().valid(); }
-  ::protozero::ConstBytes scope() const { return at<1>().as_bytes(); }
-  bool has_kernel_frames() const { return at<2>().valid(); }
-  bool kernel_frames() const { return at<2>().as_bool(); }
-  bool has_user_frames() const { return at<3>().valid(); }
-  int32_t user_frames() const { return at<3>().as_int32(); }
-};
 
-class PerfEventConfig_CallstackSampling : public ::protozero::Message {
+class PERFETTO_EXPORT_COMPONENT HeapprofdConfig_ContinuousDumpConfig : public ::protozero::CppMessageObj {
  public:
-  using Decoder = PerfEventConfig_CallstackSampling_Decoder;
-  enum : int32_t {
-    kScopeFieldNumber = 1,
-    kKernelFramesFieldNumber = 2,
-    kUserFramesFieldNumber = 3,
+  enum FieldNumbers {
+    kDumpPhaseMsFieldNumber = 5,
+    kDumpIntervalMsFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.PerfEventConfig.CallstackSampling"; }
 
+  HeapprofdConfig_ContinuousDumpConfig();
+  ~HeapprofdConfig_ContinuousDumpConfig() override;
+  HeapprofdConfig_ContinuousDumpConfig(HeapprofdConfig_ContinuousDumpConfig&&) noexcept;
+  HeapprofdConfig_ContinuousDumpConfig& operator=(HeapprofdConfig_ContinuousDumpConfig&&);
+  HeapprofdConfig_ContinuousDumpConfig(const HeapprofdConfig_ContinuousDumpConfig&);
+  HeapprofdConfig_ContinuousDumpConfig& operator=(const HeapprofdConfig_ContinuousDumpConfig&);
+  bool operator==(const HeapprofdConfig_ContinuousDumpConfig&) const;
+  bool operator!=(const HeapprofdConfig_ContinuousDumpConfig& other) const { return !(*this == other); }
 
-  using FieldMetadata_Scope =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      PerfEventConfig_Scope,
-      PerfEventConfig_CallstackSampling>;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Scope kScope() { return {}; }
-  template <typename T = PerfEventConfig_Scope> T* set_scope() {
-    return BeginNestedMessage<T>(1);
-  }
+  bool has_dump_phase_ms() const { return _has_field_[5]; }
+  uint32_t dump_phase_ms() const { return dump_phase_ms_; }
+  void set_dump_phase_ms(uint32_t value) { dump_phase_ms_ = value; _has_field_.set(5); }
 
+  bool has_dump_interval_ms() const { return _has_field_[6]; }
+  uint32_t dump_interval_ms() const { return dump_interval_ms_; }
+  void set_dump_interval_ms(uint32_t value) { dump_interval_ms_ = value; _has_field_.set(6); }
 
-  using FieldMetadata_KernelFrames =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      PerfEventConfig_CallstackSampling>;
+ private:
+  uint32_t dump_phase_ms_{};
+  uint32_t dump_interval_ms_{};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KernelFrames kKernelFrames() { return {}; }
-  void set_kernel_frames(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_KernelFrames::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  using FieldMetadata_UserFrames =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::PerfEventConfig_UnwindMode,
-      PerfEventConfig_CallstackSampling>;
+  std::bitset<7> _has_field_{};
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UserFrames kUserFrames() { return {}; }
-  void set_user_frames(::perfetto::protos::pbzero::PerfEventConfig_UnwindMode value) {
-    static constexpr uint32_t field_id = FieldMetadata_UserFrames::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/statsd/atom_ids.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_ATOM_IDS_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_ATOM_IDS_PROTO_H_
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_HEAPPROFD_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/profiling/java_hprof_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_JAVA_HPROF_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_JAVA_HPROF_CONFIG_PROTO_CPP_H_
 
-#include <stddef.h>
 #include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
 namespace perfetto {
 namespace protos {
-namespace pbzero {
+namespace gen {
+class JavaHprofConfig;
+class JavaHprofConfig_ContinuousDumpConfig;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-enum AtomId : int32_t {
-  BLE_SCAN_STATE_CHANGED = 2,
-  PROCESS_STATE_CHANGED = 3,
-  BLE_SCAN_RESULT_RECEIVED = 4,
-  SENSOR_STATE_CHANGED = 5,
-  GPS_SCAN_STATE_CHANGED = 6,
-  SYNC_STATE_CHANGED = 7,
-  SCHEDULED_JOB_STATE_CHANGED = 8,
-  SCREEN_BRIGHTNESS_CHANGED = 9,
-  WAKELOCK_STATE_CHANGED = 10,
-  LONG_PARTIAL_WAKELOCK_STATE_CHANGED = 11,
-  MOBILE_RADIO_POWER_STATE_CHANGED = 12,
-  WIFI_RADIO_POWER_STATE_CHANGED = 13,
-  ACTIVITY_MANAGER_SLEEP_STATE_CHANGED = 14,
-  MEMORY_FACTOR_STATE_CHANGED = 15,
-  EXCESSIVE_CPU_USAGE_REPORTED = 16,
-  CACHED_KILL_REPORTED = 17,
-  PROCESS_MEMORY_STAT_REPORTED = 18,
-  LAUNCHER_EVENT = 19,
-  BATTERY_SAVER_MODE_STATE_CHANGED = 20,
-  DEVICE_IDLE_MODE_STATE_CHANGED = 21,
-  DEVICE_IDLING_MODE_STATE_CHANGED = 22,
-  AUDIO_STATE_CHANGED = 23,
-  MEDIA_CODEC_STATE_CHANGED = 24,
-  CAMERA_STATE_CHANGED = 25,
-  FLASHLIGHT_STATE_CHANGED = 26,
-  UID_PROCESS_STATE_CHANGED = 27,
-  PROCESS_LIFE_CYCLE_STATE_CHANGED = 28,
-  SCREEN_STATE_CHANGED = 29,
-  BATTERY_LEVEL_CHANGED = 30,
-  CHARGING_STATE_CHANGED = 31,
-  PLUGGED_STATE_CHANGED = 32,
-  INTERACTIVE_STATE_CHANGED = 33,
-  TOUCH_EVENT_REPORTED = 34,
-  WAKEUP_ALARM_OCCURRED = 35,
-  KERNEL_WAKEUP_REPORTED = 36,
-  WIFI_LOCK_STATE_CHANGED = 37,
-  WIFI_SIGNAL_STRENGTH_CHANGED = 38,
-  WIFI_SCAN_STATE_CHANGED = 39,
-  PHONE_SIGNAL_STRENGTH_CHANGED = 40,
-  SETTING_CHANGED = 41,
-  ACTIVITY_FOREGROUND_STATE_CHANGED = 42,
-  ISOLATED_UID_CHANGED = 43,
-  PACKET_WAKEUP_OCCURRED = 44,
-  WALL_CLOCK_TIME_SHIFTED = 45,
-  ANOMALY_DETECTED = 46,
-  APP_BREADCRUMB_REPORTED = 47,
-  APP_START_OCCURRED = 48,
-  APP_START_CANCELED = 49,
-  APP_START_FULLY_DRAWN = 50,
-  LMK_KILL_OCCURRED = 51,
-  PICTURE_IN_PICTURE_STATE_CHANGED = 52,
-  WIFI_MULTICAST_LOCK_STATE_CHANGED = 53,
-  LMK_STATE_CHANGED = 54,
-  APP_START_MEMORY_STATE_CAPTURED = 55,
-  SHUTDOWN_SEQUENCE_REPORTED = 56,
-  BOOT_SEQUENCE_REPORTED = 57,
-  DAVEY_OCCURRED = 58,
-  OVERLAY_STATE_CHANGED = 59,
-  FOREGROUND_SERVICE_STATE_CHANGED = 60,
-  CALL_STATE_CHANGED = 61,
-  KEYGUARD_STATE_CHANGED = 62,
-  KEYGUARD_BOUNCER_STATE_CHANGED = 63,
-  KEYGUARD_BOUNCER_PASSWORD_ENTERED = 64,
-  APP_DIED = 65,
-  RESOURCE_CONFIGURATION_CHANGED = 66,
-  BLUETOOTH_ENABLED_STATE_CHANGED = 67,
-  BLUETOOTH_CONNECTION_STATE_CHANGED = 68,
-  GPS_SIGNAL_QUALITY_CHANGED = 69,
-  USB_CONNECTOR_STATE_CHANGED = 70,
-  SPEAKER_IMPEDANCE_REPORTED = 71,
-  HARDWARE_FAILED = 72,
-  PHYSICAL_DROP_DETECTED = 73,
-  CHARGE_CYCLES_REPORTED = 74,
-  MOBILE_CONNECTION_STATE_CHANGED = 75,
-  MOBILE_RADIO_TECHNOLOGY_CHANGED = 76,
-  USB_DEVICE_ATTACHED = 77,
-  APP_CRASH_OCCURRED = 78,
-  ANR_OCCURRED = 79,
-  WTF_OCCURRED = 80,
-  LOW_MEM_REPORTED = 81,
-  GENERIC_ATOM = 82,
-  KEY_VALUE_PAIRS_ATOM = 83,
-  VIBRATOR_STATE_CHANGED = 84,
-  DEFERRED_JOB_STATS_REPORTED = 85,
-  THERMAL_THROTTLING = 86,
-  BIOMETRIC_ACQUIRED = 87,
-  BIOMETRIC_AUTHENTICATED = 88,
-  BIOMETRIC_ERROR_OCCURRED = 89,
-  UI_EVENT_REPORTED = 90,
-  BATTERY_HEALTH_SNAPSHOT = 91,
-  SLOW_IO = 92,
-  BATTERY_CAUSED_SHUTDOWN = 93,
-  PHONE_SERVICE_STATE_CHANGED = 94,
-  PHONE_STATE_CHANGED = 95,
-  USER_RESTRICTION_CHANGED = 96,
-  SETTINGS_UI_CHANGED = 97,
-  CONNECTIVITY_STATE_CHANGED = 98,
-  SERVICE_STATE_CHANGED = 99,
-  SERVICE_LAUNCH_REPORTED = 100,
-  FLAG_FLIP_UPDATE_OCCURRED = 101,
-  BINARY_PUSH_STATE_CHANGED = 102,
-  DEVICE_POLICY_EVENT = 103,
-  DOCS_UI_FILE_OP_CANCELED = 104,
-  DOCS_UI_FILE_OP_COPY_MOVE_MODE_REPORTED = 105,
-  DOCS_UI_FILE_OP_FAILURE = 106,
-  DOCS_UI_PROVIDER_FILE_OP = 107,
-  DOCS_UI_INVALID_SCOPED_ACCESS_REQUEST = 108,
-  DOCS_UI_LAUNCH_REPORTED = 109,
-  DOCS_UI_ROOT_VISITED = 110,
-  DOCS_UI_STARTUP_MS = 111,
-  DOCS_UI_USER_ACTION_REPORTED = 112,
-  WIFI_ENABLED_STATE_CHANGED = 113,
-  WIFI_RUNNING_STATE_CHANGED = 114,
-  APP_COMPACTED = 115,
-  NETWORK_DNS_EVENT_REPORTED = 116,
-  DOCS_UI_PICKER_LAUNCHED_FROM_REPORTED = 117,
-  DOCS_UI_PICK_RESULT_REPORTED = 118,
-  DOCS_UI_SEARCH_MODE_REPORTED = 119,
-  DOCS_UI_SEARCH_TYPE_REPORTED = 120,
-  DATA_STALL_EVENT = 121,
-  RESCUE_PARTY_RESET_REPORTED = 122,
-  SIGNED_CONFIG_REPORTED = 123,
-  GNSS_NI_EVENT_REPORTED = 124,
-  BLUETOOTH_LINK_LAYER_CONNECTION_EVENT = 125,
-  BLUETOOTH_ACL_CONNECTION_STATE_CHANGED = 126,
-  BLUETOOTH_SCO_CONNECTION_STATE_CHANGED = 127,
-  APP_DOWNGRADED = 128,
-  APP_OPTIMIZED_AFTER_DOWNGRADED = 129,
-  LOW_STORAGE_STATE_CHANGED = 130,
-  GNSS_NFW_NOTIFICATION_REPORTED = 131,
-  GNSS_CONFIGURATION_REPORTED = 132,
-  USB_PORT_OVERHEAT_EVENT_REPORTED = 133,
-  NFC_ERROR_OCCURRED = 134,
-  NFC_STATE_CHANGED = 135,
-  NFC_BEAM_OCCURRED = 136,
-  NFC_CARDEMULATION_OCCURRED = 137,
-  NFC_TAG_OCCURRED = 138,
-  NFC_HCE_TRANSACTION_OCCURRED = 139,
-  SE_STATE_CHANGED = 140,
-  SE_OMAPI_REPORTED = 141,
-  BROADCAST_DISPATCH_LATENCY_REPORTED = 142,
-  ATTENTION_MANAGER_SERVICE_RESULT_REPORTED = 143,
-  ADB_CONNECTION_CHANGED = 144,
-  SPEECH_DSP_STAT_REPORTED = 145,
-  USB_CONTAMINANT_REPORTED = 146,
-  WATCHDOG_ROLLBACK_OCCURRED = 147,
-  BIOMETRIC_SYSTEM_HEALTH_ISSUE_DETECTED = 148,
-  BUBBLE_UI_CHANGED = 149,
-  SCHEDULED_JOB_CONSTRAINT_CHANGED = 150,
-  BLUETOOTH_ACTIVE_DEVICE_CHANGED = 151,
-  BLUETOOTH_A2DP_PLAYBACK_STATE_CHANGED = 152,
-  BLUETOOTH_A2DP_CODEC_CONFIG_CHANGED = 153,
-  BLUETOOTH_A2DP_CODEC_CAPABILITY_CHANGED = 154,
-  BLUETOOTH_A2DP_AUDIO_UNDERRUN_REPORTED = 155,
-  BLUETOOTH_A2DP_AUDIO_OVERRUN_REPORTED = 156,
-  BLUETOOTH_DEVICE_RSSI_REPORTED = 157,
-  BLUETOOTH_DEVICE_FAILED_CONTACT_COUNTER_REPORTED = 158,
-  BLUETOOTH_DEVICE_TX_POWER_LEVEL_REPORTED = 159,
-  BLUETOOTH_HCI_TIMEOUT_REPORTED = 160,
-  BLUETOOTH_QUALITY_REPORT_REPORTED = 161,
-  BLUETOOTH_DEVICE_INFO_REPORTED = 162,
-  BLUETOOTH_REMOTE_VERSION_INFO_REPORTED = 163,
-  BLUETOOTH_SDP_ATTRIBUTE_REPORTED = 164,
-  BLUETOOTH_BOND_STATE_CHANGED = 165,
-  BLUETOOTH_CLASSIC_PAIRING_EVENT_REPORTED = 166,
-  BLUETOOTH_SMP_PAIRING_EVENT_REPORTED = 167,
-  SCREEN_TIMEOUT_EXTENSION_REPORTED = 168,
-  PROCESS_START_TIME = 169,
-  PERMISSION_GRANT_REQUEST_RESULT_REPORTED = 170,
-  BLUETOOTH_SOCKET_CONNECTION_STATE_CHANGED = 171,
-  DEVICE_IDENTIFIER_ACCESS_DENIED = 172,
-  BUBBLE_DEVELOPER_ERROR_REPORTED = 173,
-  ASSIST_GESTURE_STAGE_REPORTED = 174,
-  ASSIST_GESTURE_FEEDBACK_REPORTED = 175,
-  ASSIST_GESTURE_PROGRESS_REPORTED = 176,
-  TOUCH_GESTURE_CLASSIFIED = 177,
-  HIDDEN_API_USED = 178,
-  STYLE_UI_CHANGED = 179,
-  PRIVACY_INDICATORS_INTERACTED = 180,
-  APP_INSTALL_ON_EXTERNAL_STORAGE_REPORTED = 181,
-  NETWORK_STACK_REPORTED = 182,
-  APP_MOVED_STORAGE_REPORTED = 183,
-  BIOMETRIC_ENROLLED = 184,
-  SYSTEM_SERVER_WATCHDOG_OCCURRED = 185,
-  TOMB_STONE_OCCURRED = 186,
-  BLUETOOTH_CLASS_OF_DEVICE_REPORTED = 187,
-  INTELLIGENCE_EVENT_REPORTED = 188,
-  THERMAL_THROTTLING_SEVERITY_STATE_CHANGED = 189,
-  ROLE_REQUEST_RESULT_REPORTED = 190,
-  MEDIAMETRICS_AUDIOPOLICY_REPORTED = 191,
-  MEDIAMETRICS_AUDIORECORD_REPORTED = 192,
-  MEDIAMETRICS_AUDIOTHREAD_REPORTED = 193,
-  MEDIAMETRICS_AUDIOTRACK_REPORTED = 194,
-  MEDIAMETRICS_CODEC_REPORTED = 195,
-  MEDIAMETRICS_DRM_WIDEVINE_REPORTED = 196,
-  MEDIAMETRICS_EXTRACTOR_REPORTED = 197,
-  MEDIAMETRICS_MEDIADRM_REPORTED = 198,
-  MEDIAMETRICS_NUPLAYER_REPORTED = 199,
-  MEDIAMETRICS_RECORDER_REPORTED = 200,
-  MEDIAMETRICS_DRMMANAGER_REPORTED = 201,
-  CAR_POWER_STATE_CHANGED = 203,
-  GARAGE_MODE_INFO = 204,
-  TEST_ATOM_REPORTED = 205,
-  CONTENT_CAPTURE_CALLER_MISMATCH_REPORTED = 206,
-  CONTENT_CAPTURE_SERVICE_EVENTS = 207,
-  CONTENT_CAPTURE_SESSION_EVENTS = 208,
-  CONTENT_CAPTURE_FLUSHED = 209,
-  LOCATION_MANAGER_API_USAGE_REPORTED = 210,
-  REVIEW_PERMISSIONS_FRAGMENT_RESULT_REPORTED = 211,
-  RUNTIME_PERMISSIONS_UPGRADE_RESULT = 212,
-  GRANT_PERMISSIONS_ACTIVITY_BUTTON_ACTIONS = 213,
-  LOCATION_ACCESS_CHECK_NOTIFICATION_ACTION = 214,
-  APP_PERMISSION_FRAGMENT_ACTION_REPORTED = 215,
-  APP_PERMISSION_FRAGMENT_VIEWED = 216,
-  APP_PERMISSIONS_FRAGMENT_VIEWED = 217,
-  PERMISSION_APPS_FRAGMENT_VIEWED = 218,
-  TEXT_SELECTION_EVENT = 219,
-  TEXT_LINKIFY_EVENT = 220,
-  CONVERSATION_ACTIONS_EVENT = 221,
-  LANGUAGE_DETECTION_EVENT = 222,
-  EXCLUSION_RECT_STATE_CHANGED = 223,
-  BACK_GESTURE_REPORTED_REPORTED = 224,
-  UPDATE_ENGINE_UPDATE_ATTEMPT_REPORTED = 225,
-  UPDATE_ENGINE_SUCCESSFUL_UPDATE_REPORTED = 226,
-  CAMERA_ACTION_EVENT = 227,
-  APP_COMPATIBILITY_CHANGE_REPORTED = 228,
-  PERFETTO_UPLOADED = 229,
-  VMS_CLIENT_CONNECTION_STATE_CHANGED = 230,
-  MEDIA_PROVIDER_SCAN_OCCURRED = 233,
-  MEDIA_CONTENT_DELETED = 234,
-  MEDIA_PROVIDER_PERMISSION_REQUESTED = 235,
-  MEDIA_PROVIDER_SCHEMA_CHANGED = 236,
-  MEDIA_PROVIDER_IDLE_MAINTENANCE_FINISHED = 237,
-  REBOOT_ESCROW_RECOVERY_REPORTED = 238,
-  BOOT_TIME_EVENT_DURATION_REPORTED = 239,
-  BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED = 240,
-  BOOT_TIME_EVENT_UTC_TIME_REPORTED = 241,
-  BOOT_TIME_EVENT_ERROR_CODE_REPORTED = 242,
-  USERSPACE_REBOOT_REPORTED = 243,
-  NOTIFICATION_REPORTED = 244,
-  NOTIFICATION_PANEL_REPORTED = 245,
-  NOTIFICATION_CHANNEL_MODIFIED = 246,
-  INTEGRITY_CHECK_RESULT_REPORTED = 247,
-  INTEGRITY_RULES_PUSHED = 248,
-  CB_MESSAGE_REPORTED = 249,
-  CB_MESSAGE_ERROR = 250,
-  WIFI_HEALTH_STAT_REPORTED = 251,
-  WIFI_FAILURE_STAT_REPORTED = 252,
-  WIFI_CONNECTION_RESULT_REPORTED = 253,
-  APP_FREEZE_CHANGED = 254,
-  SNAPSHOT_MERGE_REPORTED = 255,
-  FOREGROUND_SERVICE_APP_OP_SESSION_ENDED = 256,
-  DISPLAY_JANK_REPORTED = 257,
-  APP_STANDBY_BUCKET_CHANGED = 258,
-  SHARESHEET_STARTED = 259,
-  RANKING_SELECTED = 260,
-  TVSETTINGS_UI_INTERACTED = 261,
-  LAUNCHER_SNAPSHOT = 262,
-  PACKAGE_INSTALLER_V2_REPORTED = 263,
-  USER_LIFECYCLE_JOURNEY_REPORTED = 264,
-  USER_LIFECYCLE_EVENT_OCCURRED = 265,
-  ACCESSIBILITY_SHORTCUT_REPORTED = 266,
-  ACCESSIBILITY_SERVICE_REPORTED = 267,
-  DOCS_UI_DRAG_AND_DROP_REPORTED = 268,
-  APP_USAGE_EVENT_OCCURRED = 269,
-  AUTO_REVOKE_NOTIFICATION_CLICKED = 270,
-  AUTO_REVOKE_FRAGMENT_APP_VIEWED = 271,
-  AUTO_REVOKED_APP_INTERACTION = 272,
-  APP_PERMISSION_GROUPS_FRAGMENT_AUTO_REVOKE_ACTION = 273,
-  EVS_USAGE_STATS_REPORTED = 274,
-  AUDIO_POWER_USAGE_DATA_REPORTED = 275,
-  TV_TUNER_STATE_CHANGED = 276,
-  MEDIAOUTPUT_OP_SWITCH_REPORTED = 277,
-  CB_MESSAGE_FILTERED = 278,
-  TV_TUNER_DVR_STATUS = 279,
-  TV_CAS_SESSION_OPEN_STATUS = 280,
-  ASSISTANT_INVOCATION_REPORTED = 281,
-  DISPLAY_WAKE_REPORTED = 282,
-  CAR_USER_HAL_MODIFY_USER_REQUEST_REPORTED = 283,
-  CAR_USER_HAL_MODIFY_USER_RESPONSE_REPORTED = 284,
-  CAR_USER_HAL_POST_SWITCH_RESPONSE_REPORTED = 285,
-  CAR_USER_HAL_INITIAL_USER_INFO_REQUEST_REPORTED = 286,
-  CAR_USER_HAL_INITIAL_USER_INFO_RESPONSE_REPORTED = 287,
-  CAR_USER_HAL_USER_ASSOCIATION_REQUEST_REPORTED = 288,
-  CAR_USER_HAL_SET_USER_ASSOCIATION_RESPONSE_REPORTED = 289,
-  NETWORK_IP_PROVISIONING_REPORTED = 290,
-  NETWORK_DHCP_RENEW_REPORTED = 291,
-  NETWORK_VALIDATION_REPORTED = 292,
-  NETWORK_STACK_QUIRK_REPORTED = 293,
-  MEDIAMETRICS_AUDIORECORDDEVICEUSAGE_REPORTED = 294,
-  MEDIAMETRICS_AUDIOTHREADDEVICEUSAGE_REPORTED = 295,
-  MEDIAMETRICS_AUDIOTRACKDEVICEUSAGE_REPORTED = 296,
-  MEDIAMETRICS_AUDIODEVICECONNECTION_REPORTED = 297,
-  BLOB_COMMITTED = 298,
-  BLOB_LEASED = 299,
-  BLOB_OPENED = 300,
-  CONTACTS_PROVIDER_STATUS_REPORTED = 301,
-  KEYSTORE_KEY_EVENT_REPORTED = 302,
-  NETWORK_TETHERING_REPORTED = 303,
-  IME_TOUCH_REPORTED = 304,
-  UI_INTERACTION_FRAME_INFO_REPORTED = 305,
-  UI_ACTION_LATENCY_REPORTED = 306,
-  WIFI_DISCONNECT_REPORTED = 307,
-  WIFI_CONNECTION_STATE_CHANGED = 308,
-  HDMI_CEC_ACTIVE_SOURCE_CHANGED = 309,
-  HDMI_CEC_MESSAGE_REPORTED = 310,
-  AIRPLANE_MODE = 311,
-  MODEM_RESTART = 312,
-  CARRIER_ID_MISMATCH_REPORTED = 313,
-  CARRIER_ID_TABLE_UPDATED = 314,
-  DATA_STALL_RECOVERY_REPORTED = 315,
-  MEDIAMETRICS_MEDIAPARSER_REPORTED = 316,
-  TLS_HANDSHAKE_REPORTED = 317,
-  TEXT_CLASSIFIER_API_USAGE_REPORTED = 318,
-  CAR_WATCHDOG_KILL_STATS_REPORTED = 319,
-  MEDIAMETRICS_PLAYBACK_REPORTED = 320,
-  MEDIA_NETWORK_INFO_CHANGED = 321,
-  MEDIA_PLAYBACK_STATE_CHANGED = 322,
-  MEDIA_PLAYBACK_ERROR_REPORTED = 323,
-  MEDIA_PLAYBACK_TRACK_CHANGED = 324,
-  WIFI_SCAN_REPORTED = 325,
-  WIFI_PNO_SCAN_REPORTED = 326,
-  TIF_TUNE_CHANGED = 327,
-  AUTO_ROTATE_REPORTED = 328,
-  PERFETTO_TRIGGER = 329,
-  TRANSCODING_DATA = 330,
-  IMS_SERVICE_ENTITLEMENT_UPDATED = 331,
-  ART_DATUM_REPORTED = 332,
-  DEVICE_ROTATED = 333,
-  SIM_SPECIFIC_SETTINGS_RESTORED = 334,
-  PIN_STORAGE_EVENT = 336,
-  FACE_DOWN_REPORTED = 337,
-  BLUETOOTH_HAL_CRASH_REASON_REPORTED = 338,
-  REBOOT_ESCROW_PREPARATION_REPORTED = 339,
-  REBOOT_ESCROW_LSKF_CAPTURE_REPORTED = 340,
-  REBOOT_ESCROW_REBOOT_REPORTED = 341,
-  BINDER_LATENCY_REPORTED = 342,
-  MEDIAMETRICS_AAUDIOSTREAM_REPORTED = 343,
-  MEDIA_TRANSCODING_SESSION_ENDED = 344,
-  MAGNIFICATION_USAGE_REPORTED = 345,
-  MAGNIFICATION_MODE_WITH_IME_ON_REPORTED = 346,
-  APP_SEARCH_CALL_STATS_REPORTED = 347,
-  APP_SEARCH_PUT_DOCUMENT_STATS_REPORTED = 348,
-  DEVICE_CONTROL_CHANGED = 349,
-  DEVICE_STATE_CHANGED = 350,
-  INPUTDEVICE_REGISTERED = 351,
-  SMARTSPACE_CARD_REPORTED = 352,
-  AUTH_PROMPT_AUTHENTICATE_INVOKED = 353,
-  AUTH_MANAGER_CAN_AUTHENTICATE_INVOKED = 354,
-  AUTH_ENROLL_ACTION_INVOKED = 355,
-  AUTH_DEPRECATED_API_USED = 356,
-  UNATTENDED_REBOOT_OCCURRED = 357,
-  LONG_REBOOT_BLOCKING_REPORTED = 358,
-  LOCATION_TIME_ZONE_PROVIDER_STATE_CHANGED = 359,
-  FDTRACK_EVENT_OCCURRED = 364,
-  TIMEOUT_AUTO_EXTENDED_REPORTED = 365,
-  ODREFRESH_REPORTED = 366,
-  ALARM_BATCH_DELIVERED = 367,
-  ALARM_SCHEDULED = 368,
-  CAR_WATCHDOG_IO_OVERUSE_STATS_REPORTED = 369,
-  USER_LEVEL_HIBERNATION_STATE_CHANGED = 370,
-  APP_SEARCH_INITIALIZE_STATS_REPORTED = 371,
-  APP_SEARCH_QUERY_STATS_REPORTED = 372,
-  APP_PROCESS_DIED = 373,
-  NETWORK_IP_REACHABILITY_MONITOR_REPORTED = 374,
-  SLOW_INPUT_EVENT_REPORTED = 375,
-  ANR_OCCURRED_PROCESSING_STARTED = 376,
-  APP_SEARCH_REMOVE_STATS_REPORTED = 377,
-  MEDIA_CODEC_REPORTED = 378,
-  PERMISSION_USAGE_FRAGMENT_INTERACTION = 379,
-  PERMISSION_DETAILS_INTERACTION = 380,
-  PRIVACY_SENSOR_TOGGLE_INTERACTION = 381,
-  PRIVACY_TOGGLE_DIALOG_INTERACTION = 382,
-  APP_SEARCH_OPTIMIZE_STATS_REPORTED = 383,
-  APP_COMPAT_STATE_CHANGED = 386,
-  SIZE_COMPAT_RESTART_BUTTON_EVENT_REPORTED = 387,
-  SPLITSCREEN_UI_CHANGED = 388,
-  BLUETOOTH_CODE_PATH_COUNTER = 390,
-  BLUETOOTH_LE_BATCH_SCAN_REPORT_DELAY = 392,
-  ACCESSIBILITY_FLOATING_MENU_UI_CHANGED = 393,
-  NEURALNETWORKS_COMPILATION_COMPLETED = 394,
-  NEURALNETWORKS_EXECUTION_COMPLETED = 395,
-  NEURALNETWORKS_COMPILATION_FAILED = 396,
-  NEURALNETWORKS_EXECUTION_FAILED = 397,
-  VM_CREATION_REQUESTED = 409,
-  CAMERA_COMPAT_CONTROL_EVENT_REPORTED = 411,
-  TRACING_SERVICE_REPORT_EVENT = 424,
-  EARLY_BOOT_COMP_OS_ARTIFACTS_CHECK_REPORTED = 419,
-  ISOLATED_COMPILATION_SCHEDULED = 457,
-  ISOLATED_COMPILATION_ENDED = 458,
-  TELEPHONY_ANOMALY_DETECTED = 461,
-  HOTWORD_DETECTOR_CREATE_REQUESTED = 430,
-  HOTWORD_DETECTION_SERVICE_INIT_RESULT_REPORTED = 431,
-  HOTWORD_DETECTION_SERVICE_RESTARTED = 432,
-  HOTWORD_DETECTOR_KEYPHRASE_TRIGGERED = 433,
-  HOTWORD_DETECTOR_EVENTS = 434,
-  REMOTE_KEY_PROVISIONING_ATTEMPT = 463,
-  REMOTE_KEY_PROVISIONING_NETWORK_INFO = 464,
-  REMOTE_KEY_PROVISIONING_TIMING = 465,
-  WIFI_BYTES_TRANSFER = 10000,
-  WIFI_BYTES_TRANSFER_BY_FG_BG = 10001,
-  MOBILE_BYTES_TRANSFER = 10002,
-  MOBILE_BYTES_TRANSFER_BY_FG_BG = 10003,
-  BLUETOOTH_BYTES_TRANSFER = 10006,
-  KERNEL_WAKELOCK = 10004,
-  SUBSYSTEM_SLEEP_STATE = 10005,
-  CPU_TIME_PER_UID = 10009,
-  CPU_TIME_PER_UID_FREQ = 10010,
-  WIFI_ACTIVITY_INFO = 10011,
-  MODEM_ACTIVITY_INFO = 10012,
-  BLUETOOTH_ACTIVITY_INFO = 10007,
-  PROCESS_MEMORY_STATE = 10013,
-  SYSTEM_ELAPSED_REALTIME = 10014,
-  SYSTEM_UPTIME = 10015,
-  CPU_ACTIVE_TIME = 10016,
-  CPU_CLUSTER_TIME = 10017,
-  DISK_SPACE = 10018,
-  REMAINING_BATTERY_CAPACITY = 10019,
-  FULL_BATTERY_CAPACITY = 10020,
-  TEMPERATURE = 10021,
-  BINDER_CALLS = 10022,
-  BINDER_CALLS_EXCEPTIONS = 10023,
-  LOOPER_STATS = 10024,
-  DISK_STATS = 10025,
-  DIRECTORY_USAGE = 10026,
-  APP_SIZE = 10027,
-  CATEGORY_SIZE = 10028,
-  PROC_STATS = 10029,
-  BATTERY_VOLTAGE = 10030,
-  NUM_FINGERPRINTS_ENROLLED = 10031,
-  DISK_IO = 10032,
-  POWER_PROFILE = 10033,
-  PROC_STATS_PKG_PROC = 10034,
-  PROCESS_CPU_TIME = 10035,
-  CPU_TIME_PER_THREAD_FREQ = 10037,
-  ON_DEVICE_POWER_MEASUREMENT = 10038,
-  DEVICE_CALCULATED_POWER_USE = 10039,
-  DEVICE_CALCULATED_POWER_BLAME_UID = 10040,
-  DEVICE_CALCULATED_POWER_BLAME_OTHER = 10041,
-  PROCESS_MEMORY_HIGH_WATER_MARK = 10042,
-  BATTERY_LEVEL = 10043,
-  BUILD_INFORMATION = 10044,
-  BATTERY_CYCLE_COUNT = 10045,
-  DEBUG_ELAPSED_CLOCK = 10046,
-  DEBUG_FAILING_ELAPSED_CLOCK = 10047,
-  NUM_FACES_ENROLLED = 10048,
-  ROLE_HOLDER = 10049,
-  DANGEROUS_PERMISSION_STATE = 10050,
-  TRAIN_INFO = 10051,
-  TIME_ZONE_DATA_INFO = 10052,
-  EXTERNAL_STORAGE_INFO = 10053,
-  GPU_STATS_GLOBAL_INFO = 10054,
-  GPU_STATS_APP_INFO = 10055,
-  SYSTEM_ION_HEAP_SIZE = 10056,
-  APPS_ON_EXTERNAL_STORAGE_INFO = 10057,
-  FACE_SETTINGS = 10058,
-  COOLING_DEVICE = 10059,
-  APP_OPS = 10060,
-  PROCESS_SYSTEM_ION_HEAP_SIZE = 10061,
-  SURFACEFLINGER_STATS_GLOBAL_INFO = 10062,
-  SURFACEFLINGER_STATS_LAYER_INFO = 10063,
-  PROCESS_MEMORY_SNAPSHOT = 10064,
-  VMS_CLIENT_STATS = 10065,
-  NOTIFICATION_REMOTE_VIEWS = 10066,
-  DANGEROUS_PERMISSION_STATE_SAMPLED = 10067,
-  GRAPHICS_STATS = 10068,
-  RUNTIME_APP_OP_ACCESS = 10069,
-  ION_HEAP_SIZE = 10070,
-  PACKAGE_NOTIFICATION_PREFERENCES = 10071,
-  PACKAGE_NOTIFICATION_CHANNEL_PREFERENCES = 10072,
-  PACKAGE_NOTIFICATION_CHANNEL_GROUP_PREFERENCES = 10073,
-  GNSS_STATS = 10074,
-  ATTRIBUTED_APP_OPS = 10075,
-  VOICE_CALL_SESSION = 10076,
-  VOICE_CALL_RAT_USAGE = 10077,
-  SIM_SLOT_STATE = 10078,
-  SUPPORTED_RADIO_ACCESS_FAMILY = 10079,
-  SETTING_SNAPSHOT = 10080,
-  BLOB_INFO = 10081,
-  DATA_USAGE_BYTES_TRANSFER = 10082,
-  BYTES_TRANSFER_BY_TAG_AND_METERED = 10083,
-  DND_MODE_RULE = 10084,
-  GENERAL_EXTERNAL_STORAGE_ACCESS_STATS = 10085,
-  INCOMING_SMS = 10086,
-  OUTGOING_SMS = 10087,
-  CARRIER_ID_TABLE_VERSION = 10088,
-  DATA_CALL_SESSION = 10089,
-  CELLULAR_SERVICE_STATE = 10090,
-  CELLULAR_DATA_SERVICE_SWITCH = 10091,
-  SYSTEM_MEMORY = 10092,
-  IMS_REGISTRATION_TERMINATION = 10093,
-  IMS_REGISTRATION_STATS = 10094,
-  CPU_TIME_PER_CLUSTER_FREQ = 10095,
-  CPU_CYCLES_PER_UID_CLUSTER = 10096,
-  DEVICE_ROTATED_DATA = 10097,
-  CPU_CYCLES_PER_THREAD_GROUP_CLUSTER = 10098,
-  MEDIA_DRM_ACTIVITY_INFO = 10099,
-  OEM_MANAGED_BYTES_TRANSFER = 10100,
-  GNSS_POWER_STATS = 10101,
-  TIME_ZONE_DETECTOR_STATE = 10102,
-  KEYSTORE2_STORAGE_STATS = 10103,
-  RKP_POOL_STATS = 10104,
-  PROCESS_DMABUF_MEMORY = 10105,
-  PENDING_ALARM_INFO = 10106,
-  USER_LEVEL_HIBERNATED_APPS = 10107,
-  LAUNCHER_LAYOUT_SNAPSHOT = 10108,
-  GLOBAL_HIBERNATED_APPS = 10109,
-  INPUT_EVENT_LATENCY_SKETCH = 10110,
-  BATTERY_USAGE_STATS_BEFORE_RESET = 10111,
-  BATTERY_USAGE_STATS_SINCE_RESET = 10112,
-  BATTERY_USAGE_STATS_SINCE_RESET_USING_POWER_PROFILE_MODEL = 10113,
-  INSTALLED_INCREMENTAL_PACKAGE = 10114,
-  TELEPHONY_NETWORK_REQUESTS = 10115,
-  APP_SEARCH_STORAGE_INFO = 10116,
-  VMSTAT = 10117,
-  KEYSTORE2_KEY_CREATION_WITH_GENERAL_INFO = 10118,
-  KEYSTORE2_KEY_CREATION_WITH_AUTH_INFO = 10119,
-  KEYSTORE2_KEY_CREATION_WITH_PURPOSE_AND_MODES_INFO = 10120,
-  KEYSTORE2_ATOM_WITH_OVERFLOW = 10121,
-  KEYSTORE2_KEY_OPERATION_WITH_PURPOSE_AND_MODES_INFO = 10122,
-  KEYSTORE2_KEY_OPERATION_WITH_GENERAL_INFO = 10123,
-  RKP_ERROR_STATS = 10124,
-  KEYSTORE2_CRASH_STATS = 10125,
-  ACCESSIBILITY_SHORTCUT_STATS = 10127,
-  ACCESSIBILITY_FLOATING_MENU_STATS = 10128,
-  CAR_WATCHDOG_SYSTEM_IO_USAGE_SUMMARY = 10131,
-  CAR_WATCHDOG_UID_IO_USAGE_SUMMARY = 10132,
-  IMS_REGISTRATION_FEATURE_TAG_STATS = 10133,
-  RCS_CLIENT_PROVISIONING_STATS = 10134,
-  RCS_ACS_PROVISIONING_STATS = 10135,
-  SIP_DELEGATE_STATS = 10136,
-  SIP_TRANSPORT_FEATURE_TAG_STATS = 10137,
-  SIP_MESSAGE_RESPONSE = 10138,
-  SIP_TRANSPORT_SESSION = 10139,
-  IMS_DEDICATED_BEARER_LISTENER_EVENT = 10140,
-  IMS_DEDICATED_BEARER_EVENT = 10141,
-  IMS_REGISTRATION_SERVICE_DESC_STATS = 10142,
-  UCE_EVENT_STATS = 10143,
-  PRESENCE_NOTIFY_EVENT = 10144,
-  GBA_EVENT = 10145,
-  REMOTE_KEY_PROVISIONING_ERROR_COUNTS = 10155,
-};
-
-constexpr AtomId AtomId_MIN = AtomId::BLE_SCAN_STATE_CHANGED;
-constexpr AtomId AtomId_MAX = AtomId::REMOTE_KEY_PROVISIONING_ERROR_COUNTS;
+namespace perfetto {
+namespace protos {
+namespace gen {
 
+class PERFETTO_EXPORT_COMPONENT JavaHprofConfig : public ::protozero::CppMessageObj {
+ public:
+  using ContinuousDumpConfig = JavaHprofConfig_ContinuousDumpConfig;
+  enum FieldNumbers {
+    kProcessCmdlineFieldNumber = 1,
+    kPidFieldNumber = 2,
+    kTargetInstalledByFieldNumber = 7,
+    kContinuousDumpConfigFieldNumber = 3,
+    kMinAnonymousMemoryKbFieldNumber = 4,
+    kDumpSmapsFieldNumber = 5,
+    kIgnoredTypesFieldNumber = 6,
+  };
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* AtomId_Name(::perfetto::protos::pbzero::AtomId value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::AtomId::BLE_SCAN_STATE_CHANGED:
-    return "BLE_SCAN_STATE_CHANGED";
+  JavaHprofConfig();
+  ~JavaHprofConfig() override;
+  JavaHprofConfig(JavaHprofConfig&&) noexcept;
+  JavaHprofConfig& operator=(JavaHprofConfig&&);
+  JavaHprofConfig(const JavaHprofConfig&);
+  JavaHprofConfig& operator=(const JavaHprofConfig&);
+  bool operator==(const JavaHprofConfig&) const;
+  bool operator!=(const JavaHprofConfig& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::PROCESS_STATE_CHANGED:
-    return "PROCESS_STATE_CHANGED";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::BLE_SCAN_RESULT_RECEIVED:
-    return "BLE_SCAN_RESULT_RECEIVED";
+  const std::vector<std::string>& process_cmdline() const { return process_cmdline_; }
+  std::vector<std::string>* mutable_process_cmdline() { return &process_cmdline_; }
+  int process_cmdline_size() const { return static_cast<int>(process_cmdline_.size()); }
+  void clear_process_cmdline() { process_cmdline_.clear(); }
+  void add_process_cmdline(std::string value) { process_cmdline_.emplace_back(value); }
+  std::string* add_process_cmdline() { process_cmdline_.emplace_back(); return &process_cmdline_.back(); }
 
-  case ::perfetto::protos::pbzero::AtomId::SENSOR_STATE_CHANGED:
-    return "SENSOR_STATE_CHANGED";
+  const std::vector<uint64_t>& pid() const { return pid_; }
+  std::vector<uint64_t>* mutable_pid() { return &pid_; }
+  int pid_size() const { return static_cast<int>(pid_.size()); }
+  void clear_pid() { pid_.clear(); }
+  void add_pid(uint64_t value) { pid_.emplace_back(value); }
+  uint64_t* add_pid() { pid_.emplace_back(); return &pid_.back(); }
 
-  case ::perfetto::protos::pbzero::AtomId::GPS_SCAN_STATE_CHANGED:
-    return "GPS_SCAN_STATE_CHANGED";
+  const std::vector<std::string>& target_installed_by() const { return target_installed_by_; }
+  std::vector<std::string>* mutable_target_installed_by() { return &target_installed_by_; }
+  int target_installed_by_size() const { return static_cast<int>(target_installed_by_.size()); }
+  void clear_target_installed_by() { target_installed_by_.clear(); }
+  void add_target_installed_by(std::string value) { target_installed_by_.emplace_back(value); }
+  std::string* add_target_installed_by() { target_installed_by_.emplace_back(); return &target_installed_by_.back(); }
 
-  case ::perfetto::protos::pbzero::AtomId::SYNC_STATE_CHANGED:
-    return "SYNC_STATE_CHANGED";
+  bool has_continuous_dump_config() const { return _has_field_[3]; }
+  const JavaHprofConfig_ContinuousDumpConfig& continuous_dump_config() const { return *continuous_dump_config_; }
+  JavaHprofConfig_ContinuousDumpConfig* mutable_continuous_dump_config() { _has_field_.set(3); return continuous_dump_config_.get(); }
 
-  case ::perfetto::protos::pbzero::AtomId::SCHEDULED_JOB_STATE_CHANGED:
-    return "SCHEDULED_JOB_STATE_CHANGED";
+  bool has_min_anonymous_memory_kb() const { return _has_field_[4]; }
+  uint32_t min_anonymous_memory_kb() const { return min_anonymous_memory_kb_; }
+  void set_min_anonymous_memory_kb(uint32_t value) { min_anonymous_memory_kb_ = value; _has_field_.set(4); }
 
-  case ::perfetto::protos::pbzero::AtomId::SCREEN_BRIGHTNESS_CHANGED:
-    return "SCREEN_BRIGHTNESS_CHANGED";
+  bool has_dump_smaps() const { return _has_field_[5]; }
+  bool dump_smaps() const { return dump_smaps_; }
+  void set_dump_smaps(bool value) { dump_smaps_ = value; _has_field_.set(5); }
 
-  case ::perfetto::protos::pbzero::AtomId::WAKELOCK_STATE_CHANGED:
-    return "WAKELOCK_STATE_CHANGED";
+  const std::vector<std::string>& ignored_types() const { return ignored_types_; }
+  std::vector<std::string>* mutable_ignored_types() { return &ignored_types_; }
+  int ignored_types_size() const { return static_cast<int>(ignored_types_.size()); }
+  void clear_ignored_types() { ignored_types_.clear(); }
+  void add_ignored_types(std::string value) { ignored_types_.emplace_back(value); }
+  std::string* add_ignored_types() { ignored_types_.emplace_back(); return &ignored_types_.back(); }
 
-  case ::perfetto::protos::pbzero::AtomId::LONG_PARTIAL_WAKELOCK_STATE_CHANGED:
-    return "LONG_PARTIAL_WAKELOCK_STATE_CHANGED";
+ private:
+  std::vector<std::string> process_cmdline_;
+  std::vector<uint64_t> pid_;
+  std::vector<std::string> target_installed_by_;
+  ::protozero::CopyablePtr<JavaHprofConfig_ContinuousDumpConfig> continuous_dump_config_;
+  uint32_t min_anonymous_memory_kb_{};
+  bool dump_smaps_{};
+  std::vector<std::string> ignored_types_;
 
-  case ::perfetto::protos::pbzero::AtomId::MOBILE_RADIO_POWER_STATE_CHANGED:
-    return "MOBILE_RADIO_POWER_STATE_CHANGED";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::WIFI_RADIO_POWER_STATE_CHANGED:
-    return "WIFI_RADIO_POWER_STATE_CHANGED";
+  std::bitset<8> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::ACTIVITY_MANAGER_SLEEP_STATE_CHANGED:
-    return "ACTIVITY_MANAGER_SLEEP_STATE_CHANGED";
 
-  case ::perfetto::protos::pbzero::AtomId::MEMORY_FACTOR_STATE_CHANGED:
-    return "MEMORY_FACTOR_STATE_CHANGED";
+class PERFETTO_EXPORT_COMPONENT JavaHprofConfig_ContinuousDumpConfig : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kDumpPhaseMsFieldNumber = 1,
+    kDumpIntervalMsFieldNumber = 2,
+    kScanPidsOnlyOnStartFieldNumber = 3,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::EXCESSIVE_CPU_USAGE_REPORTED:
-    return "EXCESSIVE_CPU_USAGE_REPORTED";
+  JavaHprofConfig_ContinuousDumpConfig();
+  ~JavaHprofConfig_ContinuousDumpConfig() override;
+  JavaHprofConfig_ContinuousDumpConfig(JavaHprofConfig_ContinuousDumpConfig&&) noexcept;
+  JavaHprofConfig_ContinuousDumpConfig& operator=(JavaHprofConfig_ContinuousDumpConfig&&);
+  JavaHprofConfig_ContinuousDumpConfig(const JavaHprofConfig_ContinuousDumpConfig&);
+  JavaHprofConfig_ContinuousDumpConfig& operator=(const JavaHprofConfig_ContinuousDumpConfig&);
+  bool operator==(const JavaHprofConfig_ContinuousDumpConfig&) const;
+  bool operator!=(const JavaHprofConfig_ContinuousDumpConfig& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::CACHED_KILL_REPORTED:
-    return "CACHED_KILL_REPORTED";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::PROCESS_MEMORY_STAT_REPORTED:
-    return "PROCESS_MEMORY_STAT_REPORTED";
+  bool has_dump_phase_ms() const { return _has_field_[1]; }
+  uint32_t dump_phase_ms() const { return dump_phase_ms_; }
+  void set_dump_phase_ms(uint32_t value) { dump_phase_ms_ = value; _has_field_.set(1); }
 
-  case ::perfetto::protos::pbzero::AtomId::LAUNCHER_EVENT:
-    return "LAUNCHER_EVENT";
+  bool has_dump_interval_ms() const { return _has_field_[2]; }
+  uint32_t dump_interval_ms() const { return dump_interval_ms_; }
+  void set_dump_interval_ms(uint32_t value) { dump_interval_ms_ = value; _has_field_.set(2); }
 
-  case ::perfetto::protos::pbzero::AtomId::BATTERY_SAVER_MODE_STATE_CHANGED:
-    return "BATTERY_SAVER_MODE_STATE_CHANGED";
+  bool has_scan_pids_only_on_start() const { return _has_field_[3]; }
+  bool scan_pids_only_on_start() const { return scan_pids_only_on_start_; }
+  void set_scan_pids_only_on_start(bool value) { scan_pids_only_on_start_ = value; _has_field_.set(3); }
 
-  case ::perfetto::protos::pbzero::AtomId::DEVICE_IDLE_MODE_STATE_CHANGED:
-    return "DEVICE_IDLE_MODE_STATE_CHANGED";
+ private:
+  uint32_t dump_phase_ms_{};
+  uint32_t dump_interval_ms_{};
+  bool scan_pids_only_on_start_{};
 
-  case ::perfetto::protos::pbzero::AtomId::DEVICE_IDLING_MODE_STATE_CHANGED:
-    return "DEVICE_IDLING_MODE_STATE_CHANGED";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::AUDIO_STATE_CHANGED:
-    return "AUDIO_STATE_CHANGED";
+  std::bitset<4> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIA_CODEC_STATE_CHANGED:
-    return "MEDIA_CODEC_STATE_CHANGED";
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::CAMERA_STATE_CHANGED:
-    return "CAMERA_STATE_CHANGED";
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_JAVA_HPROF_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/profiling/perf_event_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_PERF_EVENT_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_PERF_EVENT_CONFIG_PROTO_CPP_H_
 
-  case ::perfetto::protos::pbzero::AtomId::FLASHLIGHT_STATE_CHANGED:
-    return "FLASHLIGHT_STATE_CHANGED";
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  case ::perfetto::protos::pbzero::AtomId::UID_PROCESS_STATE_CHANGED:
-    return "UID_PROCESS_STATE_CHANGED";
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  case ::perfetto::protos::pbzero::AtomId::PROCESS_LIFE_CYCLE_STATE_CHANGED:
-    return "PROCESS_LIFE_CYCLE_STATE_CHANGED";
+namespace perfetto {
+namespace protos {
+namespace gen {
+class PerfEventConfig;
+class PerfEventConfig_CallstackSampling;
+class PerfEventConfig_Scope;
+class FollowerEvent;
+class PerfEvents_RawEvent;
+class PerfEvents_Tracepoint;
+class PerfEvents_Timebase;
+enum PerfEventConfig_UnwindMode : int;
+enum PerfEvents_Counter : int;
+enum PerfEvents_EventModifier : int;
+enum PerfEvents_PerfClock : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::SCREEN_STATE_CHANGED:
-    return "SCREEN_STATE_CHANGED";
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  case ::perfetto::protos::pbzero::AtomId::BATTERY_LEVEL_CHANGED:
-    return "BATTERY_LEVEL_CHANGED";
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum PerfEventConfig_UnwindMode : int {
+  PerfEventConfig_UnwindMode_UNWIND_UNKNOWN = 0,
+  PerfEventConfig_UnwindMode_UNWIND_SKIP = 1,
+  PerfEventConfig_UnwindMode_UNWIND_DWARF = 2,
+  PerfEventConfig_UnwindMode_UNWIND_FRAME_POINTER = 3,
+};
 
-  case ::perfetto::protos::pbzero::AtomId::CHARGING_STATE_CHANGED:
-    return "CHARGING_STATE_CHANGED";
+class PERFETTO_EXPORT_COMPONENT PerfEventConfig : public ::protozero::CppMessageObj {
+ public:
+  using CallstackSampling = PerfEventConfig_CallstackSampling;
+  using Scope = PerfEventConfig_Scope;
+  using UnwindMode = PerfEventConfig_UnwindMode;
+  static constexpr auto UNWIND_UNKNOWN = PerfEventConfig_UnwindMode_UNWIND_UNKNOWN;
+  static constexpr auto UNWIND_SKIP = PerfEventConfig_UnwindMode_UNWIND_SKIP;
+  static constexpr auto UNWIND_DWARF = PerfEventConfig_UnwindMode_UNWIND_DWARF;
+  static constexpr auto UNWIND_FRAME_POINTER = PerfEventConfig_UnwindMode_UNWIND_FRAME_POINTER;
+  static constexpr auto UnwindMode_MIN = PerfEventConfig_UnwindMode_UNWIND_UNKNOWN;
+  static constexpr auto UnwindMode_MAX = PerfEventConfig_UnwindMode_UNWIND_FRAME_POINTER;
+  enum FieldNumbers {
+    kTimebaseFieldNumber = 15,
+    kFollowersFieldNumber = 19,
+    kCallstackSamplingFieldNumber = 16,
+    kTargetCpuFieldNumber = 20,
+    kRingBufferReadPeriodMsFieldNumber = 8,
+    kRingBufferPagesFieldNumber = 3,
+    kMaxEnqueuedFootprintKbFieldNumber = 17,
+    kMaxDaemonMemoryKbFieldNumber = 13,
+    kRemoteDescriptorTimeoutMsFieldNumber = 9,
+    kUnwindStateClearPeriodMsFieldNumber = 10,
+    kTargetInstalledByFieldNumber = 18,
+    kAllCpusFieldNumber = 1,
+    kSamplingFrequencyFieldNumber = 2,
+    kKernelFramesFieldNumber = 12,
+    kTargetPidFieldNumber = 4,
+    kTargetCmdlineFieldNumber = 5,
+    kExcludePidFieldNumber = 6,
+    kExcludeCmdlineFieldNumber = 7,
+    kAdditionalCmdlineCountFieldNumber = 11,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::PLUGGED_STATE_CHANGED:
-    return "PLUGGED_STATE_CHANGED";
+  PerfEventConfig();
+  ~PerfEventConfig() override;
+  PerfEventConfig(PerfEventConfig&&) noexcept;
+  PerfEventConfig& operator=(PerfEventConfig&&);
+  PerfEventConfig(const PerfEventConfig&);
+  PerfEventConfig& operator=(const PerfEventConfig&);
+  bool operator==(const PerfEventConfig&) const;
+  bool operator!=(const PerfEventConfig& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::INTERACTIVE_STATE_CHANGED:
-    return "INTERACTIVE_STATE_CHANGED";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::TOUCH_EVENT_REPORTED:
-    return "TOUCH_EVENT_REPORTED";
+  bool has_timebase() const { return _has_field_[15]; }
+  const PerfEvents_Timebase& timebase() const { return *timebase_; }
+  PerfEvents_Timebase* mutable_timebase() { _has_field_.set(15); return timebase_.get(); }
 
-  case ::perfetto::protos::pbzero::AtomId::WAKEUP_ALARM_OCCURRED:
-    return "WAKEUP_ALARM_OCCURRED";
+  const std::vector<FollowerEvent>& followers() const { return followers_; }
+  std::vector<FollowerEvent>* mutable_followers() { return &followers_; }
+  int followers_size() const;
+  void clear_followers();
+  FollowerEvent* add_followers();
 
-  case ::perfetto::protos::pbzero::AtomId::KERNEL_WAKEUP_REPORTED:
-    return "KERNEL_WAKEUP_REPORTED";
+  bool has_callstack_sampling() const { return _has_field_[16]; }
+  const PerfEventConfig_CallstackSampling& callstack_sampling() const { return *callstack_sampling_; }
+  PerfEventConfig_CallstackSampling* mutable_callstack_sampling() { _has_field_.set(16); return callstack_sampling_.get(); }
 
-  case ::perfetto::protos::pbzero::AtomId::WIFI_LOCK_STATE_CHANGED:
-    return "WIFI_LOCK_STATE_CHANGED";
+  const std::vector<uint32_t>& target_cpu() const { return target_cpu_; }
+  std::vector<uint32_t>* mutable_target_cpu() { return &target_cpu_; }
+  int target_cpu_size() const { return static_cast<int>(target_cpu_.size()); }
+  void clear_target_cpu() { target_cpu_.clear(); }
+  void add_target_cpu(uint32_t value) { target_cpu_.emplace_back(value); }
+  uint32_t* add_target_cpu() { target_cpu_.emplace_back(); return &target_cpu_.back(); }
 
-  case ::perfetto::protos::pbzero::AtomId::WIFI_SIGNAL_STRENGTH_CHANGED:
-    return "WIFI_SIGNAL_STRENGTH_CHANGED";
+  bool has_ring_buffer_read_period_ms() const { return _has_field_[8]; }
+  uint32_t ring_buffer_read_period_ms() const { return ring_buffer_read_period_ms_; }
+  void set_ring_buffer_read_period_ms(uint32_t value) { ring_buffer_read_period_ms_ = value; _has_field_.set(8); }
 
-  case ::perfetto::protos::pbzero::AtomId::WIFI_SCAN_STATE_CHANGED:
-    return "WIFI_SCAN_STATE_CHANGED";
+  bool has_ring_buffer_pages() const { return _has_field_[3]; }
+  uint32_t ring_buffer_pages() const { return ring_buffer_pages_; }
+  void set_ring_buffer_pages(uint32_t value) { ring_buffer_pages_ = value; _has_field_.set(3); }
 
-  case ::perfetto::protos::pbzero::AtomId::PHONE_SIGNAL_STRENGTH_CHANGED:
-    return "PHONE_SIGNAL_STRENGTH_CHANGED";
+  bool has_max_enqueued_footprint_kb() const { return _has_field_[17]; }
+  uint64_t max_enqueued_footprint_kb() const { return max_enqueued_footprint_kb_; }
+  void set_max_enqueued_footprint_kb(uint64_t value) { max_enqueued_footprint_kb_ = value; _has_field_.set(17); }
 
-  case ::perfetto::protos::pbzero::AtomId::SETTING_CHANGED:
-    return "SETTING_CHANGED";
+  bool has_max_daemon_memory_kb() const { return _has_field_[13]; }
+  uint32_t max_daemon_memory_kb() const { return max_daemon_memory_kb_; }
+  void set_max_daemon_memory_kb(uint32_t value) { max_daemon_memory_kb_ = value; _has_field_.set(13); }
 
-  case ::perfetto::protos::pbzero::AtomId::ACTIVITY_FOREGROUND_STATE_CHANGED:
-    return "ACTIVITY_FOREGROUND_STATE_CHANGED";
+  bool has_remote_descriptor_timeout_ms() const { return _has_field_[9]; }
+  uint32_t remote_descriptor_timeout_ms() const { return remote_descriptor_timeout_ms_; }
+  void set_remote_descriptor_timeout_ms(uint32_t value) { remote_descriptor_timeout_ms_ = value; _has_field_.set(9); }
 
-  case ::perfetto::protos::pbzero::AtomId::ISOLATED_UID_CHANGED:
-    return "ISOLATED_UID_CHANGED";
+  bool has_unwind_state_clear_period_ms() const { return _has_field_[10]; }
+  uint32_t unwind_state_clear_period_ms() const { return unwind_state_clear_period_ms_; }
+  void set_unwind_state_clear_period_ms(uint32_t value) { unwind_state_clear_period_ms_ = value; _has_field_.set(10); }
 
-  case ::perfetto::protos::pbzero::AtomId::PACKET_WAKEUP_OCCURRED:
-    return "PACKET_WAKEUP_OCCURRED";
+  const std::vector<std::string>& target_installed_by() const { return target_installed_by_; }
+  std::vector<std::string>* mutable_target_installed_by() { return &target_installed_by_; }
+  int target_installed_by_size() const { return static_cast<int>(target_installed_by_.size()); }
+  void clear_target_installed_by() { target_installed_by_.clear(); }
+  void add_target_installed_by(std::string value) { target_installed_by_.emplace_back(value); }
+  std::string* add_target_installed_by() { target_installed_by_.emplace_back(); return &target_installed_by_.back(); }
 
-  case ::perfetto::protos::pbzero::AtomId::WALL_CLOCK_TIME_SHIFTED:
-    return "WALL_CLOCK_TIME_SHIFTED";
+  bool has_all_cpus() const { return _has_field_[1]; }
+  bool all_cpus() const { return all_cpus_; }
+  void set_all_cpus(bool value) { all_cpus_ = value; _has_field_.set(1); }
 
-  case ::perfetto::protos::pbzero::AtomId::ANOMALY_DETECTED:
-    return "ANOMALY_DETECTED";
+  bool has_sampling_frequency() const { return _has_field_[2]; }
+  uint32_t sampling_frequency() const { return sampling_frequency_; }
+  void set_sampling_frequency(uint32_t value) { sampling_frequency_ = value; _has_field_.set(2); }
 
-  case ::perfetto::protos::pbzero::AtomId::APP_BREADCRUMB_REPORTED:
-    return "APP_BREADCRUMB_REPORTED";
+  bool has_kernel_frames() const { return _has_field_[12]; }
+  bool kernel_frames() const { return kernel_frames_; }
+  void set_kernel_frames(bool value) { kernel_frames_ = value; _has_field_.set(12); }
 
-  case ::perfetto::protos::pbzero::AtomId::APP_START_OCCURRED:
-    return "APP_START_OCCURRED";
+  const std::vector<int32_t>& target_pid() const { return target_pid_; }
+  std::vector<int32_t>* mutable_target_pid() { return &target_pid_; }
+  int target_pid_size() const { return static_cast<int>(target_pid_.size()); }
+  void clear_target_pid() { target_pid_.clear(); }
+  void add_target_pid(int32_t value) { target_pid_.emplace_back(value); }
+  int32_t* add_target_pid() { target_pid_.emplace_back(); return &target_pid_.back(); }
 
-  case ::perfetto::protos::pbzero::AtomId::APP_START_CANCELED:
-    return "APP_START_CANCELED";
+  const std::vector<std::string>& target_cmdline() const { return target_cmdline_; }
+  std::vector<std::string>* mutable_target_cmdline() { return &target_cmdline_; }
+  int target_cmdline_size() const { return static_cast<int>(target_cmdline_.size()); }
+  void clear_target_cmdline() { target_cmdline_.clear(); }
+  void add_target_cmdline(std::string value) { target_cmdline_.emplace_back(value); }
+  std::string* add_target_cmdline() { target_cmdline_.emplace_back(); return &target_cmdline_.back(); }
 
-  case ::perfetto::protos::pbzero::AtomId::APP_START_FULLY_DRAWN:
-    return "APP_START_FULLY_DRAWN";
+  const std::vector<int32_t>& exclude_pid() const { return exclude_pid_; }
+  std::vector<int32_t>* mutable_exclude_pid() { return &exclude_pid_; }
+  int exclude_pid_size() const { return static_cast<int>(exclude_pid_.size()); }
+  void clear_exclude_pid() { exclude_pid_.clear(); }
+  void add_exclude_pid(int32_t value) { exclude_pid_.emplace_back(value); }
+  int32_t* add_exclude_pid() { exclude_pid_.emplace_back(); return &exclude_pid_.back(); }
 
-  case ::perfetto::protos::pbzero::AtomId::LMK_KILL_OCCURRED:
-    return "LMK_KILL_OCCURRED";
+  const std::vector<std::string>& exclude_cmdline() const { return exclude_cmdline_; }
+  std::vector<std::string>* mutable_exclude_cmdline() { return &exclude_cmdline_; }
+  int exclude_cmdline_size() const { return static_cast<int>(exclude_cmdline_.size()); }
+  void clear_exclude_cmdline() { exclude_cmdline_.clear(); }
+  void add_exclude_cmdline(std::string value) { exclude_cmdline_.emplace_back(value); }
+  std::string* add_exclude_cmdline() { exclude_cmdline_.emplace_back(); return &exclude_cmdline_.back(); }
 
-  case ::perfetto::protos::pbzero::AtomId::PICTURE_IN_PICTURE_STATE_CHANGED:
-    return "PICTURE_IN_PICTURE_STATE_CHANGED";
+  bool has_additional_cmdline_count() const { return _has_field_[11]; }
+  uint32_t additional_cmdline_count() const { return additional_cmdline_count_; }
+  void set_additional_cmdline_count(uint32_t value) { additional_cmdline_count_ = value; _has_field_.set(11); }
 
-  case ::perfetto::protos::pbzero::AtomId::WIFI_MULTICAST_LOCK_STATE_CHANGED:
-    return "WIFI_MULTICAST_LOCK_STATE_CHANGED";
+ private:
+  ::protozero::CopyablePtr<PerfEvents_Timebase> timebase_;
+  std::vector<FollowerEvent> followers_;
+  ::protozero::CopyablePtr<PerfEventConfig_CallstackSampling> callstack_sampling_;
+  std::vector<uint32_t> target_cpu_;
+  uint32_t ring_buffer_read_period_ms_{};
+  uint32_t ring_buffer_pages_{};
+  uint64_t max_enqueued_footprint_kb_{};
+  uint32_t max_daemon_memory_kb_{};
+  uint32_t remote_descriptor_timeout_ms_{};
+  uint32_t unwind_state_clear_period_ms_{};
+  std::vector<std::string> target_installed_by_;
+  bool all_cpus_{};
+  uint32_t sampling_frequency_{};
+  bool kernel_frames_{};
+  std::vector<int32_t> target_pid_;
+  std::vector<std::string> target_cmdline_;
+  std::vector<int32_t> exclude_pid_;
+  std::vector<std::string> exclude_cmdline_;
+  uint32_t additional_cmdline_count_{};
 
-  case ::perfetto::protos::pbzero::AtomId::LMK_STATE_CHANGED:
-    return "LMK_STATE_CHANGED";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::APP_START_MEMORY_STATE_CAPTURED:
-    return "APP_START_MEMORY_STATE_CAPTURED";
+  std::bitset<21> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::SHUTDOWN_SEQUENCE_REPORTED:
-    return "SHUTDOWN_SEQUENCE_REPORTED";
 
-  case ::perfetto::protos::pbzero::AtomId::BOOT_SEQUENCE_REPORTED:
-    return "BOOT_SEQUENCE_REPORTED";
+class PERFETTO_EXPORT_COMPONENT PerfEventConfig_CallstackSampling : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kScopeFieldNumber = 1,
+    kKernelFramesFieldNumber = 2,
+    kUserFramesFieldNumber = 3,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::DAVEY_OCCURRED:
-    return "DAVEY_OCCURRED";
+  PerfEventConfig_CallstackSampling();
+  ~PerfEventConfig_CallstackSampling() override;
+  PerfEventConfig_CallstackSampling(PerfEventConfig_CallstackSampling&&) noexcept;
+  PerfEventConfig_CallstackSampling& operator=(PerfEventConfig_CallstackSampling&&);
+  PerfEventConfig_CallstackSampling(const PerfEventConfig_CallstackSampling&);
+  PerfEventConfig_CallstackSampling& operator=(const PerfEventConfig_CallstackSampling&);
+  bool operator==(const PerfEventConfig_CallstackSampling&) const;
+  bool operator!=(const PerfEventConfig_CallstackSampling& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::OVERLAY_STATE_CHANGED:
-    return "OVERLAY_STATE_CHANGED";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::FOREGROUND_SERVICE_STATE_CHANGED:
-    return "FOREGROUND_SERVICE_STATE_CHANGED";
+  bool has_scope() const { return _has_field_[1]; }
+  const PerfEventConfig_Scope& scope() const { return *scope_; }
+  PerfEventConfig_Scope* mutable_scope() { _has_field_.set(1); return scope_.get(); }
 
-  case ::perfetto::protos::pbzero::AtomId::CALL_STATE_CHANGED:
-    return "CALL_STATE_CHANGED";
+  bool has_kernel_frames() const { return _has_field_[2]; }
+  bool kernel_frames() const { return kernel_frames_; }
+  void set_kernel_frames(bool value) { kernel_frames_ = value; _has_field_.set(2); }
 
-  case ::perfetto::protos::pbzero::AtomId::KEYGUARD_STATE_CHANGED:
-    return "KEYGUARD_STATE_CHANGED";
+  bool has_user_frames() const { return _has_field_[3]; }
+  PerfEventConfig_UnwindMode user_frames() const { return user_frames_; }
+  void set_user_frames(PerfEventConfig_UnwindMode value) { user_frames_ = value; _has_field_.set(3); }
 
-  case ::perfetto::protos::pbzero::AtomId::KEYGUARD_BOUNCER_STATE_CHANGED:
-    return "KEYGUARD_BOUNCER_STATE_CHANGED";
+ private:
+  ::protozero::CopyablePtr<PerfEventConfig_Scope> scope_;
+  bool kernel_frames_{};
+  PerfEventConfig_UnwindMode user_frames_{};
 
-  case ::perfetto::protos::pbzero::AtomId::KEYGUARD_BOUNCER_PASSWORD_ENTERED:
-    return "KEYGUARD_BOUNCER_PASSWORD_ENTERED";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::APP_DIED:
-    return "APP_DIED";
+  std::bitset<4> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::RESOURCE_CONFIGURATION_CHANGED:
-    return "RESOURCE_CONFIGURATION_CHANGED";
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_ENABLED_STATE_CHANGED:
-    return "BLUETOOTH_ENABLED_STATE_CHANGED";
+class PERFETTO_EXPORT_COMPONENT PerfEventConfig_Scope : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kTargetPidFieldNumber = 1,
+    kTargetCmdlineFieldNumber = 2,
+    kExcludePidFieldNumber = 3,
+    kExcludeCmdlineFieldNumber = 4,
+    kAdditionalCmdlineCountFieldNumber = 5,
+    kProcessShardCountFieldNumber = 6,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_CONNECTION_STATE_CHANGED:
-    return "BLUETOOTH_CONNECTION_STATE_CHANGED";
+  PerfEventConfig_Scope();
+  ~PerfEventConfig_Scope() override;
+  PerfEventConfig_Scope(PerfEventConfig_Scope&&) noexcept;
+  PerfEventConfig_Scope& operator=(PerfEventConfig_Scope&&);
+  PerfEventConfig_Scope(const PerfEventConfig_Scope&);
+  PerfEventConfig_Scope& operator=(const PerfEventConfig_Scope&);
+  bool operator==(const PerfEventConfig_Scope&) const;
+  bool operator!=(const PerfEventConfig_Scope& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::GPS_SIGNAL_QUALITY_CHANGED:
-    return "GPS_SIGNAL_QUALITY_CHANGED";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::USB_CONNECTOR_STATE_CHANGED:
-    return "USB_CONNECTOR_STATE_CHANGED";
+  const std::vector<int32_t>& target_pid() const { return target_pid_; }
+  std::vector<int32_t>* mutable_target_pid() { return &target_pid_; }
+  int target_pid_size() const { return static_cast<int>(target_pid_.size()); }
+  void clear_target_pid() { target_pid_.clear(); }
+  void add_target_pid(int32_t value) { target_pid_.emplace_back(value); }
+  int32_t* add_target_pid() { target_pid_.emplace_back(); return &target_pid_.back(); }
 
-  case ::perfetto::protos::pbzero::AtomId::SPEAKER_IMPEDANCE_REPORTED:
-    return "SPEAKER_IMPEDANCE_REPORTED";
+  const std::vector<std::string>& target_cmdline() const { return target_cmdline_; }
+  std::vector<std::string>* mutable_target_cmdline() { return &target_cmdline_; }
+  int target_cmdline_size() const { return static_cast<int>(target_cmdline_.size()); }
+  void clear_target_cmdline() { target_cmdline_.clear(); }
+  void add_target_cmdline(std::string value) { target_cmdline_.emplace_back(value); }
+  std::string* add_target_cmdline() { target_cmdline_.emplace_back(); return &target_cmdline_.back(); }
 
-  case ::perfetto::protos::pbzero::AtomId::HARDWARE_FAILED:
-    return "HARDWARE_FAILED";
+  const std::vector<int32_t>& exclude_pid() const { return exclude_pid_; }
+  std::vector<int32_t>* mutable_exclude_pid() { return &exclude_pid_; }
+  int exclude_pid_size() const { return static_cast<int>(exclude_pid_.size()); }
+  void clear_exclude_pid() { exclude_pid_.clear(); }
+  void add_exclude_pid(int32_t value) { exclude_pid_.emplace_back(value); }
+  int32_t* add_exclude_pid() { exclude_pid_.emplace_back(); return &exclude_pid_.back(); }
 
-  case ::perfetto::protos::pbzero::AtomId::PHYSICAL_DROP_DETECTED:
-    return "PHYSICAL_DROP_DETECTED";
+  const std::vector<std::string>& exclude_cmdline() const { return exclude_cmdline_; }
+  std::vector<std::string>* mutable_exclude_cmdline() { return &exclude_cmdline_; }
+  int exclude_cmdline_size() const { return static_cast<int>(exclude_cmdline_.size()); }
+  void clear_exclude_cmdline() { exclude_cmdline_.clear(); }
+  void add_exclude_cmdline(std::string value) { exclude_cmdline_.emplace_back(value); }
+  std::string* add_exclude_cmdline() { exclude_cmdline_.emplace_back(); return &exclude_cmdline_.back(); }
 
-  case ::perfetto::protos::pbzero::AtomId::CHARGE_CYCLES_REPORTED:
-    return "CHARGE_CYCLES_REPORTED";
+  bool has_additional_cmdline_count() const { return _has_field_[5]; }
+  uint32_t additional_cmdline_count() const { return additional_cmdline_count_; }
+  void set_additional_cmdline_count(uint32_t value) { additional_cmdline_count_ = value; _has_field_.set(5); }
 
-  case ::perfetto::protos::pbzero::AtomId::MOBILE_CONNECTION_STATE_CHANGED:
-    return "MOBILE_CONNECTION_STATE_CHANGED";
+  bool has_process_shard_count() const { return _has_field_[6]; }
+  uint32_t process_shard_count() const { return process_shard_count_; }
+  void set_process_shard_count(uint32_t value) { process_shard_count_ = value; _has_field_.set(6); }
 
-  case ::perfetto::protos::pbzero::AtomId::MOBILE_RADIO_TECHNOLOGY_CHANGED:
-    return "MOBILE_RADIO_TECHNOLOGY_CHANGED";
+ private:
+  std::vector<int32_t> target_pid_;
+  std::vector<std::string> target_cmdline_;
+  std::vector<int32_t> exclude_pid_;
+  std::vector<std::string> exclude_cmdline_;
+  uint32_t additional_cmdline_count_{};
+  uint32_t process_shard_count_{};
 
-  case ::perfetto::protos::pbzero::AtomId::USB_DEVICE_ATTACHED:
-    return "USB_DEVICE_ATTACHED";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::APP_CRASH_OCCURRED:
-    return "APP_CRASH_OCCURRED";
+  std::bitset<7> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::ANR_OCCURRED:
-    return "ANR_OCCURRED";
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::WTF_OCCURRED:
-    return "WTF_OCCURRED";
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_PERF_EVENT_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/protovm/protovm_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROTOVM_PROTOVM_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROTOVM_PROTOVM_CONFIG_PROTO_CPP_H_
 
-  case ::perfetto::protos::pbzero::AtomId::LOW_MEM_REPORTED:
-    return "LOW_MEM_REPORTED";
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  case ::perfetto::protos::pbzero::AtomId::GENERIC_ATOM:
-    return "GENERIC_ATOM";
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  case ::perfetto::protos::pbzero::AtomId::KEY_VALUE_PAIRS_ATOM:
-    return "KEY_VALUE_PAIRS_ATOM";
+namespace perfetto {
+namespace protos {
+namespace gen {
+class ProtoVmConfig;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::VIBRATOR_STATE_CHANGED:
-    return "VIBRATOR_STATE_CHANGED";
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  case ::perfetto::protos::pbzero::AtomId::DEFERRED_JOB_STATS_REPORTED:
-    return "DEFERRED_JOB_STATS_REPORTED";
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-  case ::perfetto::protos::pbzero::AtomId::THERMAL_THROTTLING:
-    return "THERMAL_THROTTLING";
+class PERFETTO_EXPORT_COMPONENT ProtoVmConfig : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kMemoryLimitKbFieldNumber = 1,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::BIOMETRIC_ACQUIRED:
-    return "BIOMETRIC_ACQUIRED";
+  ProtoVmConfig();
+  ~ProtoVmConfig() override;
+  ProtoVmConfig(ProtoVmConfig&&) noexcept;
+  ProtoVmConfig& operator=(ProtoVmConfig&&);
+  ProtoVmConfig(const ProtoVmConfig&);
+  ProtoVmConfig& operator=(const ProtoVmConfig&);
+  bool operator==(const ProtoVmConfig&) const;
+  bool operator!=(const ProtoVmConfig& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::BIOMETRIC_AUTHENTICATED:
-    return "BIOMETRIC_AUTHENTICATED";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::BIOMETRIC_ERROR_OCCURRED:
-    return "BIOMETRIC_ERROR_OCCURRED";
+  bool has_memory_limit_kb() const { return _has_field_[1]; }
+  uint32_t memory_limit_kb() const { return memory_limit_kb_; }
+  void set_memory_limit_kb(uint32_t value) { memory_limit_kb_ = value; _has_field_.set(1); }
 
-  case ::perfetto::protos::pbzero::AtomId::UI_EVENT_REPORTED:
-    return "UI_EVENT_REPORTED";
+ private:
+  uint32_t memory_limit_kb_{};
 
-  case ::perfetto::protos::pbzero::AtomId::BATTERY_HEALTH_SNAPSHOT:
-    return "BATTERY_HEALTH_SNAPSHOT";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::SLOW_IO:
-    return "SLOW_IO";
+  std::bitset<2> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::BATTERY_CAUSED_SHUTDOWN:
-    return "BATTERY_CAUSED_SHUTDOWN";
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::PHONE_SERVICE_STATE_CHANGED:
-    return "PHONE_SERVICE_STATE_CHANGED";
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROTOVM_PROTOVM_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/qnx/qnx_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_QNX_QNX_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_QNX_QNX_CONFIG_PROTO_CPP_H_
 
-  case ::perfetto::protos::pbzero::AtomId::PHONE_STATE_CHANGED:
-    return "PHONE_STATE_CHANGED";
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  case ::perfetto::protos::pbzero::AtomId::USER_RESTRICTION_CHANGED:
-    return "USER_RESTRICTION_CHANGED";
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  case ::perfetto::protos::pbzero::AtomId::SETTINGS_UI_CHANGED:
-    return "SETTINGS_UI_CHANGED";
+namespace perfetto {
+namespace protos {
+namespace gen {
+class QnxConfig;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::CONNECTIVITY_STATE_CHANGED:
-    return "CONNECTIVITY_STATE_CHANGED";
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  case ::perfetto::protos::pbzero::AtomId::SERVICE_STATE_CHANGED:
-    return "SERVICE_STATE_CHANGED";
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-  case ::perfetto::protos::pbzero::AtomId::SERVICE_LAUNCH_REPORTED:
-    return "SERVICE_LAUNCH_REPORTED";
+class PERFETTO_EXPORT_COMPONENT QnxConfig : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kQnxKernelBuffersFieldNumber = 1,
+    kQnxKernelKbuffersFieldNumber = 2,
+    kQnxKernelWideEventsFieldNumber = 3,
+    kQnxCachePagesFieldNumber = 4,
+    kQnxCacheMaxPagesFieldNumber = 5,
+    kQnxTraceBufferInitBytesFieldNumber = 6,
+  };
+
+  QnxConfig();
+  ~QnxConfig() override;
+  QnxConfig(QnxConfig&&) noexcept;
+  QnxConfig& operator=(QnxConfig&&);
+  QnxConfig(const QnxConfig&);
+  QnxConfig& operator=(const QnxConfig&);
+  bool operator==(const QnxConfig&) const;
+  bool operator!=(const QnxConfig& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::FLAG_FLIP_UPDATE_OCCURRED:
-    return "FLAG_FLIP_UPDATE_OCCURRED";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::BINARY_PUSH_STATE_CHANGED:
-    return "BINARY_PUSH_STATE_CHANGED";
+  bool has_qnx_kernel_buffers() const { return _has_field_[1]; }
+  uint32_t qnx_kernel_buffers() const { return qnx_kernel_buffers_; }
+  void set_qnx_kernel_buffers(uint32_t value) { qnx_kernel_buffers_ = value; _has_field_.set(1); }
 
-  case ::perfetto::protos::pbzero::AtomId::DEVICE_POLICY_EVENT:
-    return "DEVICE_POLICY_EVENT";
+  bool has_qnx_kernel_kbuffers() const { return _has_field_[2]; }
+  uint32_t qnx_kernel_kbuffers() const { return qnx_kernel_kbuffers_; }
+  void set_qnx_kernel_kbuffers(uint32_t value) { qnx_kernel_kbuffers_ = value; _has_field_.set(2); }
 
-  case ::perfetto::protos::pbzero::AtomId::DOCS_UI_FILE_OP_CANCELED:
-    return "DOCS_UI_FILE_OP_CANCELED";
+  bool has_qnx_kernel_wide_events() const { return _has_field_[3]; }
+  bool qnx_kernel_wide_events() const { return qnx_kernel_wide_events_; }
+  void set_qnx_kernel_wide_events(bool value) { qnx_kernel_wide_events_ = value; _has_field_.set(3); }
 
-  case ::perfetto::protos::pbzero::AtomId::DOCS_UI_FILE_OP_COPY_MOVE_MODE_REPORTED:
-    return "DOCS_UI_FILE_OP_COPY_MOVE_MODE_REPORTED";
+  bool has_qnx_cache_pages() const { return _has_field_[4]; }
+  uint32_t qnx_cache_pages() const { return qnx_cache_pages_; }
+  void set_qnx_cache_pages(uint32_t value) { qnx_cache_pages_ = value; _has_field_.set(4); }
 
-  case ::perfetto::protos::pbzero::AtomId::DOCS_UI_FILE_OP_FAILURE:
-    return "DOCS_UI_FILE_OP_FAILURE";
+  bool has_qnx_cache_max_pages() const { return _has_field_[5]; }
+  int32_t qnx_cache_max_pages() const { return qnx_cache_max_pages_; }
+  void set_qnx_cache_max_pages(int32_t value) { qnx_cache_max_pages_ = value; _has_field_.set(5); }
 
-  case ::perfetto::protos::pbzero::AtomId::DOCS_UI_PROVIDER_FILE_OP:
-    return "DOCS_UI_PROVIDER_FILE_OP";
+  bool has_qnx_trace_buffer_init_bytes() const { return _has_field_[6]; }
+  uint32_t qnx_trace_buffer_init_bytes() const { return qnx_trace_buffer_init_bytes_; }
+  void set_qnx_trace_buffer_init_bytes(uint32_t value) { qnx_trace_buffer_init_bytes_ = value; _has_field_.set(6); }
 
-  case ::perfetto::protos::pbzero::AtomId::DOCS_UI_INVALID_SCOPED_ACCESS_REQUEST:
-    return "DOCS_UI_INVALID_SCOPED_ACCESS_REQUEST";
+ private:
+  uint32_t qnx_kernel_buffers_{};
+  uint32_t qnx_kernel_kbuffers_{};
+  bool qnx_kernel_wide_events_{};
+  uint32_t qnx_cache_pages_{};
+  int32_t qnx_cache_max_pages_{};
+  uint32_t qnx_trace_buffer_init_bytes_{};
 
-  case ::perfetto::protos::pbzero::AtomId::DOCS_UI_LAUNCH_REPORTED:
-    return "DOCS_UI_LAUNCH_REPORTED";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::DOCS_UI_ROOT_VISITED:
-    return "DOCS_UI_ROOT_VISITED";
+  std::bitset<7> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::DOCS_UI_STARTUP_MS:
-    return "DOCS_UI_STARTUP_MS";
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::DOCS_UI_USER_ACTION_REPORTED:
-    return "DOCS_UI_USER_ACTION_REPORTED";
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_QNX_QNX_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/statsd/atom_ids.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_ATOM_IDS_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_ATOM_IDS_PROTO_CPP_H_
 
-  case ::perfetto::protos::pbzero::AtomId::WIFI_ENABLED_STATE_CHANGED:
-    return "WIFI_ENABLED_STATE_CHANGED";
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  case ::perfetto::protos::pbzero::AtomId::WIFI_RUNNING_STATE_CHANGED:
-    return "WIFI_RUNNING_STATE_CHANGED";
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  case ::perfetto::protos::pbzero::AtomId::APP_COMPACTED:
-    return "APP_COMPACTED";
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum AtomId : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::NETWORK_DNS_EVENT_REPORTED:
-    return "NETWORK_DNS_EVENT_REPORTED";
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  case ::perfetto::protos::pbzero::AtomId::DOCS_UI_PICKER_LAUNCHED_FROM_REPORTED:
-    return "DOCS_UI_PICKER_LAUNCHED_FROM_REPORTED";
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum AtomId : int {
+  ATOM_UNSPECIFIED = 0,
+  ATOM_BLE_SCAN_STATE_CHANGED = 2,
+  ATOM_PROCESS_STATE_CHANGED = 3,
+  ATOM_BLE_SCAN_RESULT_RECEIVED = 4,
+  ATOM_SENSOR_STATE_CHANGED = 5,
+  ATOM_GPS_SCAN_STATE_CHANGED = 6,
+  ATOM_SYNC_STATE_CHANGED = 7,
+  ATOM_SCHEDULED_JOB_STATE_CHANGED = 8,
+  ATOM_SCREEN_BRIGHTNESS_CHANGED = 9,
+  ATOM_WAKELOCK_STATE_CHANGED = 10,
+  ATOM_LONG_PARTIAL_WAKELOCK_STATE_CHANGED = 11,
+  ATOM_MOBILE_RADIO_POWER_STATE_CHANGED = 12,
+  ATOM_WIFI_RADIO_POWER_STATE_CHANGED = 13,
+  ATOM_ACTIVITY_MANAGER_SLEEP_STATE_CHANGED = 14,
+  ATOM_MEMORY_FACTOR_STATE_CHANGED = 15,
+  ATOM_EXCESSIVE_CPU_USAGE_REPORTED = 16,
+  ATOM_CACHED_KILL_REPORTED = 17,
+  ATOM_PROCESS_MEMORY_STAT_REPORTED = 18,
+  ATOM_LAUNCHER_EVENT = 19,
+  ATOM_BATTERY_SAVER_MODE_STATE_CHANGED = 20,
+  ATOM_DEVICE_IDLE_MODE_STATE_CHANGED = 21,
+  ATOM_DEVICE_IDLING_MODE_STATE_CHANGED = 22,
+  ATOM_AUDIO_STATE_CHANGED = 23,
+  ATOM_MEDIA_CODEC_STATE_CHANGED = 24,
+  ATOM_CAMERA_STATE_CHANGED = 25,
+  ATOM_FLASHLIGHT_STATE_CHANGED = 26,
+  ATOM_UID_PROCESS_STATE_CHANGED = 27,
+  ATOM_PROCESS_LIFE_CYCLE_STATE_CHANGED = 28,
+  ATOM_SCREEN_STATE_CHANGED = 29,
+  ATOM_BATTERY_LEVEL_CHANGED = 30,
+  ATOM_CHARGING_STATE_CHANGED = 31,
+  ATOM_PLUGGED_STATE_CHANGED = 32,
+  ATOM_INTERACTIVE_STATE_CHANGED = 33,
+  ATOM_TOUCH_EVENT_REPORTED = 34,
+  ATOM_WAKEUP_ALARM_OCCURRED = 35,
+  ATOM_KERNEL_WAKEUP_REPORTED = 36,
+  ATOM_WIFI_LOCK_STATE_CHANGED = 37,
+  ATOM_WIFI_SIGNAL_STRENGTH_CHANGED = 38,
+  ATOM_WIFI_SCAN_STATE_CHANGED = 39,
+  ATOM_PHONE_SIGNAL_STRENGTH_CHANGED = 40,
+  ATOM_SETTING_CHANGED = 41,
+  ATOM_ACTIVITY_FOREGROUND_STATE_CHANGED = 42,
+  ATOM_ISOLATED_UID_CHANGED = 43,
+  ATOM_PACKET_WAKEUP_OCCURRED = 44,
+  ATOM_WALL_CLOCK_TIME_SHIFTED = 45,
+  ATOM_ANOMALY_DETECTED = 46,
+  ATOM_APP_BREADCRUMB_REPORTED = 47,
+  ATOM_APP_START_OCCURRED = 48,
+  ATOM_APP_START_CANCELED = 49,
+  ATOM_APP_START_FULLY_DRAWN = 50,
+  ATOM_LMK_KILL_OCCURRED = 51,
+  ATOM_PICTURE_IN_PICTURE_STATE_CHANGED = 52,
+  ATOM_WIFI_MULTICAST_LOCK_STATE_CHANGED = 53,
+  ATOM_APP_START_MEMORY_STATE_CAPTURED = 55,
+  ATOM_SHUTDOWN_SEQUENCE_REPORTED = 56,
+  ATOM_BOOT_SEQUENCE_REPORTED = 57,
+  ATOM_OVERLAY_STATE_CHANGED = 59,
+  ATOM_FOREGROUND_SERVICE_STATE_CHANGED = 60,
+  ATOM_CALL_STATE_CHANGED = 61,
+  ATOM_KEYGUARD_STATE_CHANGED = 62,
+  ATOM_KEYGUARD_BOUNCER_STATE_CHANGED = 63,
+  ATOM_KEYGUARD_BOUNCER_PASSWORD_ENTERED = 64,
+  ATOM_APP_DIED = 65,
+  ATOM_RESOURCE_CONFIGURATION_CHANGED = 66,
+  ATOM_BLUETOOTH_ENABLED_STATE_CHANGED = 67,
+  ATOM_BLUETOOTH_CONNECTION_STATE_CHANGED = 68,
+  ATOM_GPS_SIGNAL_QUALITY_CHANGED = 69,
+  ATOM_USB_CONNECTOR_STATE_CHANGED = 70,
+  ATOM_SPEAKER_IMPEDANCE_REPORTED = 71,
+  ATOM_HARDWARE_FAILED = 72,
+  ATOM_PHYSICAL_DROP_DETECTED = 73,
+  ATOM_CHARGE_CYCLES_REPORTED = 74,
+  ATOM_MOBILE_CONNECTION_STATE_CHANGED = 75,
+  ATOM_MOBILE_RADIO_TECHNOLOGY_CHANGED = 76,
+  ATOM_USB_DEVICE_ATTACHED = 77,
+  ATOM_APP_CRASH_OCCURRED = 78,
+  ATOM_ANR_OCCURRED = 79,
+  ATOM_WTF_OCCURRED = 80,
+  ATOM_LOW_MEM_REPORTED = 81,
+  ATOM_GENERIC_ATOM = 82,
+  ATOM_VIBRATOR_STATE_CHANGED = 84,
+  ATOM_DEFERRED_JOB_STATS_REPORTED = 85,
+  ATOM_THERMAL_THROTTLING = 86,
+  ATOM_BIOMETRIC_ACQUIRED = 87,
+  ATOM_BIOMETRIC_AUTHENTICATED = 88,
+  ATOM_BIOMETRIC_ERROR_OCCURRED = 89,
+  ATOM_UI_EVENT_REPORTED = 90,
+  ATOM_BATTERY_HEALTH_SNAPSHOT = 91,
+  ATOM_SLOW_IO = 92,
+  ATOM_BATTERY_CAUSED_SHUTDOWN = 93,
+  ATOM_PHONE_SERVICE_STATE_CHANGED = 94,
+  ATOM_PHONE_STATE_CHANGED = 95,
+  ATOM_USER_RESTRICTION_CHANGED = 96,
+  ATOM_SETTINGS_UI_CHANGED = 97,
+  ATOM_CONNECTIVITY_STATE_CHANGED = 98,
+  ATOM_SERVICE_STATE_CHANGED = 99,
+  ATOM_SERVICE_LAUNCH_REPORTED = 100,
+  ATOM_FLAG_FLIP_UPDATE_OCCURRED = 101,
+  ATOM_BINARY_PUSH_STATE_CHANGED = 102,
+  ATOM_DEVICE_POLICY_EVENT = 103,
+  ATOM_DOCS_UI_FILE_OP_CANCELED = 104,
+  ATOM_DOCS_UI_FILE_OP_COPY_MOVE_MODE_REPORTED = 105,
+  ATOM_DOCS_UI_FILE_OP_FAILURE = 106,
+  ATOM_DOCS_UI_PROVIDER_FILE_OP = 107,
+  ATOM_DOCS_UI_INVALID_SCOPED_ACCESS_REQUEST = 108,
+  ATOM_DOCS_UI_LAUNCH_REPORTED = 109,
+  ATOM_DOCS_UI_ROOT_VISITED = 110,
+  ATOM_DOCS_UI_STARTUP_MS = 111,
+  ATOM_DOCS_UI_USER_ACTION_REPORTED = 112,
+  ATOM_WIFI_ENABLED_STATE_CHANGED = 113,
+  ATOM_WIFI_RUNNING_STATE_CHANGED = 114,
+  ATOM_APP_COMPACTED = 115,
+  ATOM_NETWORK_DNS_EVENT_REPORTED = 116,
+  ATOM_DOCS_UI_PICKER_LAUNCHED_FROM_REPORTED = 117,
+  ATOM_DOCS_UI_PICK_RESULT_REPORTED = 118,
+  ATOM_DOCS_UI_SEARCH_MODE_REPORTED = 119,
+  ATOM_DOCS_UI_SEARCH_TYPE_REPORTED = 120,
+  ATOM_DATA_STALL_EVENT = 121,
+  ATOM_RESCUE_PARTY_RESET_REPORTED = 122,
+  ATOM_SIGNED_CONFIG_REPORTED = 123,
+  ATOM_GNSS_NI_EVENT_REPORTED = 124,
+  ATOM_BLUETOOTH_LINK_LAYER_CONNECTION_EVENT = 125,
+  ATOM_BLUETOOTH_ACL_CONNECTION_STATE_CHANGED = 126,
+  ATOM_BLUETOOTH_SCO_CONNECTION_STATE_CHANGED = 127,
+  ATOM_APP_DOWNGRADED = 128,
+  ATOM_APP_OPTIMIZED_AFTER_DOWNGRADED = 129,
+  ATOM_LOW_STORAGE_STATE_CHANGED = 130,
+  ATOM_GNSS_NFW_NOTIFICATION_REPORTED = 131,
+  ATOM_GNSS_CONFIGURATION_REPORTED = 132,
+  ATOM_USB_PORT_OVERHEAT_EVENT_REPORTED = 133,
+  ATOM_NFC_ERROR_OCCURRED = 134,
+  ATOM_NFC_STATE_CHANGED = 135,
+  ATOM_NFC_BEAM_OCCURRED = 136,
+  ATOM_NFC_CARDEMULATION_OCCURRED = 137,
+  ATOM_NFC_TAG_OCCURRED = 138,
+  ATOM_NFC_HCE_TRANSACTION_OCCURRED = 139,
+  ATOM_SE_STATE_CHANGED = 140,
+  ATOM_SE_OMAPI_REPORTED = 141,
+  ATOM_BROADCAST_DISPATCH_LATENCY_REPORTED = 142,
+  ATOM_ATTENTION_MANAGER_SERVICE_RESULT_REPORTED = 143,
+  ATOM_ADB_CONNECTION_CHANGED = 144,
+  ATOM_SPEECH_DSP_STAT_REPORTED = 145,
+  ATOM_USB_CONTAMINANT_REPORTED = 146,
+  ATOM_WATCHDOG_ROLLBACK_OCCURRED = 147,
+  ATOM_BIOMETRIC_SYSTEM_HEALTH_ISSUE_DETECTED = 148,
+  ATOM_BUBBLE_UI_CHANGED = 149,
+  ATOM_SCHEDULED_JOB_CONSTRAINT_CHANGED = 150,
+  ATOM_BLUETOOTH_ACTIVE_DEVICE_CHANGED = 151,
+  ATOM_BLUETOOTH_A2DP_PLAYBACK_STATE_CHANGED = 152,
+  ATOM_BLUETOOTH_A2DP_CODEC_CONFIG_CHANGED = 153,
+  ATOM_BLUETOOTH_A2DP_CODEC_CAPABILITY_CHANGED = 154,
+  ATOM_BLUETOOTH_A2DP_AUDIO_UNDERRUN_REPORTED = 155,
+  ATOM_BLUETOOTH_A2DP_AUDIO_OVERRUN_REPORTED = 156,
+  ATOM_BLUETOOTH_DEVICE_RSSI_REPORTED = 157,
+  ATOM_BLUETOOTH_DEVICE_FAILED_CONTACT_COUNTER_REPORTED = 158,
+  ATOM_BLUETOOTH_DEVICE_TX_POWER_LEVEL_REPORTED = 159,
+  ATOM_BLUETOOTH_HCI_TIMEOUT_REPORTED = 160,
+  ATOM_BLUETOOTH_QUALITY_REPORT_REPORTED = 161,
+  ATOM_BLUETOOTH_DEVICE_INFO_REPORTED = 162,
+  ATOM_BLUETOOTH_REMOTE_VERSION_INFO_REPORTED = 163,
+  ATOM_BLUETOOTH_SDP_ATTRIBUTE_REPORTED = 164,
+  ATOM_BLUETOOTH_BOND_STATE_CHANGED = 165,
+  ATOM_BLUETOOTH_CLASSIC_PAIRING_EVENT_REPORTED = 166,
+  ATOM_BLUETOOTH_SMP_PAIRING_EVENT_REPORTED = 167,
+  ATOM_SCREEN_TIMEOUT_EXTENSION_REPORTED = 168,
+  ATOM_PROCESS_START_TIME = 169,
+  ATOM_PERMISSION_GRANT_REQUEST_RESULT_REPORTED = 170,
+  ATOM_BLUETOOTH_SOCKET_CONNECTION_STATE_CHANGED = 171,
+  ATOM_DEVICE_IDENTIFIER_ACCESS_DENIED = 172,
+  ATOM_BUBBLE_DEVELOPER_ERROR_REPORTED = 173,
+  ATOM_ASSIST_GESTURE_STAGE_REPORTED = 174,
+  ATOM_ASSIST_GESTURE_FEEDBACK_REPORTED = 175,
+  ATOM_ASSIST_GESTURE_PROGRESS_REPORTED = 176,
+  ATOM_TOUCH_GESTURE_CLASSIFIED = 177,
+  ATOM_HIDDEN_API_USED = 178,
+  ATOM_STYLE_UI_CHANGED = 179,
+  ATOM_PRIVACY_INDICATORS_INTERACTED = 180,
+  ATOM_APP_INSTALL_ON_EXTERNAL_STORAGE_REPORTED = 181,
+  ATOM_NETWORK_STACK_REPORTED = 182,
+  ATOM_APP_MOVED_STORAGE_REPORTED = 183,
+  ATOM_BIOMETRIC_ENROLLED = 184,
+  ATOM_SYSTEM_SERVER_WATCHDOG_OCCURRED = 185,
+  ATOM_TOMB_STONE_OCCURRED = 186,
+  ATOM_BLUETOOTH_CLASS_OF_DEVICE_REPORTED = 187,
+  ATOM_INTELLIGENCE_EVENT_REPORTED = 188,
+  ATOM_THERMAL_THROTTLING_SEVERITY_STATE_CHANGED = 189,
+  ATOM_ROLE_REQUEST_RESULT_REPORTED = 190,
+  ATOM_MEDIAMETRICS_AUDIOPOLICY_REPORTED = 191,
+  ATOM_MEDIAMETRICS_AUDIORECORD_REPORTED = 192,
+  ATOM_MEDIAMETRICS_AUDIOTHREAD_REPORTED = 193,
+  ATOM_MEDIAMETRICS_AUDIOTRACK_REPORTED = 194,
+  ATOM_MEDIAMETRICS_CODEC_REPORTED = 195,
+  ATOM_MEDIAMETRICS_DRM_WIDEVINE_REPORTED = 196,
+  ATOM_MEDIAMETRICS_EXTRACTOR_REPORTED = 197,
+  ATOM_MEDIAMETRICS_MEDIADRM_REPORTED = 198,
+  ATOM_MEDIAMETRICS_NUPLAYER_REPORTED = 199,
+  ATOM_MEDIAMETRICS_RECORDER_REPORTED = 200,
+  ATOM_MEDIAMETRICS_DRMMANAGER_REPORTED = 201,
+  ATOM_CAR_POWER_STATE_CHANGED = 203,
+  ATOM_GARAGE_MODE_INFO = 204,
+  ATOM_TEST_ATOM_REPORTED = 205,
+  ATOM_CONTENT_CAPTURE_CALLER_MISMATCH_REPORTED = 206,
+  ATOM_CONTENT_CAPTURE_SERVICE_EVENTS = 207,
+  ATOM_CONTENT_CAPTURE_SESSION_EVENTS = 208,
+  ATOM_CONTENT_CAPTURE_FLUSHED = 209,
+  ATOM_LOCATION_MANAGER_API_USAGE_REPORTED = 210,
+  ATOM_REVIEW_PERMISSIONS_FRAGMENT_RESULT_REPORTED = 211,
+  ATOM_RUNTIME_PERMISSIONS_UPGRADE_RESULT = 212,
+  ATOM_GRANT_PERMISSIONS_ACTIVITY_BUTTON_ACTIONS = 213,
+  ATOM_LOCATION_ACCESS_CHECK_NOTIFICATION_ACTION = 214,
+  ATOM_APP_PERMISSION_FRAGMENT_ACTION_REPORTED = 215,
+  ATOM_APP_PERMISSION_FRAGMENT_VIEWED = 216,
+  ATOM_APP_PERMISSIONS_FRAGMENT_VIEWED = 217,
+  ATOM_PERMISSION_APPS_FRAGMENT_VIEWED = 218,
+  ATOM_TEXT_SELECTION_EVENT = 219,
+  ATOM_TEXT_LINKIFY_EVENT = 220,
+  ATOM_CONVERSATION_ACTIONS_EVENT = 221,
+  ATOM_LANGUAGE_DETECTION_EVENT = 222,
+  ATOM_EXCLUSION_RECT_STATE_CHANGED = 223,
+  ATOM_BACK_GESTURE_REPORTED_REPORTED = 224,
+  ATOM_UPDATE_ENGINE_UPDATE_ATTEMPT_REPORTED = 225,
+  ATOM_UPDATE_ENGINE_SUCCESSFUL_UPDATE_REPORTED = 226,
+  ATOM_CAMERA_ACTION_EVENT = 227,
+  ATOM_APP_COMPATIBILITY_CHANGE_REPORTED = 228,
+  ATOM_PERFETTO_UPLOADED = 229,
+  ATOM_VMS_CLIENT_CONNECTION_STATE_CHANGED = 230,
+  ATOM_MEDIA_PROVIDER_SCAN_OCCURRED = 233,
+  ATOM_MEDIA_CONTENT_DELETED = 234,
+  ATOM_MEDIA_PROVIDER_PERMISSION_REQUESTED = 235,
+  ATOM_MEDIA_PROVIDER_SCHEMA_CHANGED = 236,
+  ATOM_MEDIA_PROVIDER_IDLE_MAINTENANCE_FINISHED = 237,
+  ATOM_REBOOT_ESCROW_RECOVERY_REPORTED = 238,
+  ATOM_BOOT_TIME_EVENT_DURATION_REPORTED = 239,
+  ATOM_BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED = 240,
+  ATOM_BOOT_TIME_EVENT_UTC_TIME_REPORTED = 241,
+  ATOM_BOOT_TIME_EVENT_ERROR_CODE_REPORTED = 242,
+  ATOM_USERSPACE_REBOOT_REPORTED = 243,
+  ATOM_NOTIFICATION_REPORTED = 244,
+  ATOM_NOTIFICATION_PANEL_REPORTED = 245,
+  ATOM_NOTIFICATION_CHANNEL_MODIFIED = 246,
+  ATOM_INTEGRITY_CHECK_RESULT_REPORTED = 247,
+  ATOM_INTEGRITY_RULES_PUSHED = 248,
+  ATOM_CB_MESSAGE_REPORTED = 249,
+  ATOM_CB_MESSAGE_ERROR = 250,
+  ATOM_WIFI_HEALTH_STAT_REPORTED = 251,
+  ATOM_WIFI_FAILURE_STAT_REPORTED = 252,
+  ATOM_WIFI_CONNECTION_RESULT_REPORTED = 253,
+  ATOM_APP_FREEZE_CHANGED = 254,
+  ATOM_SNAPSHOT_MERGE_REPORTED = 255,
+  ATOM_FOREGROUND_SERVICE_APP_OP_SESSION_ENDED = 256,
+  ATOM_DISPLAY_JANK_REPORTED = 257,
+  ATOM_APP_STANDBY_BUCKET_CHANGED = 258,
+  ATOM_SHARESHEET_STARTED = 259,
+  ATOM_RANKING_SELECTED = 260,
+  ATOM_TVSETTINGS_UI_INTERACTED = 261,
+  ATOM_LAUNCHER_SNAPSHOT = 262,
+  ATOM_PACKAGE_INSTALLER_V2_REPORTED = 263,
+  ATOM_USER_LIFECYCLE_JOURNEY_REPORTED = 264,
+  ATOM_USER_LIFECYCLE_EVENT_OCCURRED = 265,
+  ATOM_ACCESSIBILITY_SHORTCUT_REPORTED = 266,
+  ATOM_ACCESSIBILITY_SERVICE_REPORTED = 267,
+  ATOM_DOCS_UI_DRAG_AND_DROP_REPORTED = 268,
+  ATOM_APP_USAGE_EVENT_OCCURRED = 269,
+  ATOM_AUTO_REVOKE_NOTIFICATION_CLICKED = 270,
+  ATOM_AUTO_REVOKE_FRAGMENT_APP_VIEWED = 271,
+  ATOM_AUTO_REVOKED_APP_INTERACTION = 272,
+  ATOM_APP_PERMISSION_GROUPS_FRAGMENT_AUTO_REVOKE_ACTION = 273,
+  ATOM_EVS_USAGE_STATS_REPORTED = 274,
+  ATOM_AUDIO_POWER_USAGE_DATA_REPORTED = 275,
+  ATOM_TV_TUNER_STATE_CHANGED = 276,
+  ATOM_MEDIAOUTPUT_OP_SWITCH_REPORTED = 277,
+  ATOM_CB_MESSAGE_FILTERED = 278,
+  ATOM_TV_TUNER_DVR_STATUS = 279,
+  ATOM_TV_CAS_SESSION_OPEN_STATUS = 280,
+  ATOM_ASSISTANT_INVOCATION_REPORTED = 281,
+  ATOM_DISPLAY_WAKE_REPORTED = 282,
+  ATOM_CAR_USER_HAL_MODIFY_USER_REQUEST_REPORTED = 283,
+  ATOM_CAR_USER_HAL_MODIFY_USER_RESPONSE_REPORTED = 284,
+  ATOM_CAR_USER_HAL_POST_SWITCH_RESPONSE_REPORTED = 285,
+  ATOM_CAR_USER_HAL_INITIAL_USER_INFO_REQUEST_REPORTED = 286,
+  ATOM_CAR_USER_HAL_INITIAL_USER_INFO_RESPONSE_REPORTED = 287,
+  ATOM_CAR_USER_HAL_USER_ASSOCIATION_REQUEST_REPORTED = 288,
+  ATOM_CAR_USER_HAL_SET_USER_ASSOCIATION_RESPONSE_REPORTED = 289,
+  ATOM_NETWORK_IP_PROVISIONING_REPORTED = 290,
+  ATOM_NETWORK_DHCP_RENEW_REPORTED = 291,
+  ATOM_NETWORK_VALIDATION_REPORTED = 292,
+  ATOM_NETWORK_STACK_QUIRK_REPORTED = 293,
+  ATOM_MEDIAMETRICS_AUDIORECORDDEVICEUSAGE_REPORTED = 294,
+  ATOM_MEDIAMETRICS_AUDIOTHREADDEVICEUSAGE_REPORTED = 295,
+  ATOM_MEDIAMETRICS_AUDIOTRACKDEVICEUSAGE_REPORTED = 296,
+  ATOM_MEDIAMETRICS_AUDIODEVICECONNECTION_REPORTED = 297,
+  ATOM_BLOB_COMMITTED = 298,
+  ATOM_BLOB_LEASED = 299,
+  ATOM_BLOB_OPENED = 300,
+  ATOM_CONTACTS_PROVIDER_STATUS_REPORTED = 301,
+  ATOM_KEYSTORE_KEY_EVENT_REPORTED = 302,
+  ATOM_NETWORK_TETHERING_REPORTED = 303,
+  ATOM_IME_TOUCH_REPORTED = 304,
+  ATOM_UI_INTERACTION_FRAME_INFO_REPORTED = 305,
+  ATOM_UI_ACTION_LATENCY_REPORTED = 306,
+  ATOM_WIFI_DISCONNECT_REPORTED = 307,
+  ATOM_WIFI_CONNECTION_STATE_CHANGED = 308,
+  ATOM_HDMI_CEC_ACTIVE_SOURCE_CHANGED = 309,
+  ATOM_HDMI_CEC_MESSAGE_REPORTED = 310,
+  ATOM_AIRPLANE_MODE = 311,
+  ATOM_MODEM_RESTART = 312,
+  ATOM_CARRIER_ID_MISMATCH_REPORTED = 313,
+  ATOM_CARRIER_ID_TABLE_UPDATED = 314,
+  ATOM_DATA_STALL_RECOVERY_REPORTED = 315,
+  ATOM_MEDIAMETRICS_MEDIAPARSER_REPORTED = 316,
+  ATOM_TLS_HANDSHAKE_REPORTED = 317,
+  ATOM_TEXT_CLASSIFIER_API_USAGE_REPORTED = 318,
+  ATOM_CAR_WATCHDOG_KILL_STATS_REPORTED = 319,
+  ATOM_MEDIAMETRICS_PLAYBACK_REPORTED = 320,
+  ATOM_MEDIA_NETWORK_INFO_CHANGED = 321,
+  ATOM_MEDIA_PLAYBACK_STATE_CHANGED = 322,
+  ATOM_MEDIA_PLAYBACK_ERROR_REPORTED = 323,
+  ATOM_MEDIA_PLAYBACK_TRACK_CHANGED = 324,
+  ATOM_WIFI_SCAN_REPORTED = 325,
+  ATOM_WIFI_PNO_SCAN_REPORTED = 326,
+  ATOM_TIF_TUNE_CHANGED = 327,
+  ATOM_AUTO_ROTATE_REPORTED = 328,
+  ATOM_PERFETTO_TRIGGER = 329,
+  ATOM_TRANSCODING_DATA = 330,
+  ATOM_IMS_SERVICE_ENTITLEMENT_UPDATED = 331,
+  ATOM_DEVICE_ROTATED = 333,
+  ATOM_SIM_SPECIFIC_SETTINGS_RESTORED = 334,
+  ATOM_TEXT_CLASSIFIER_DOWNLOAD_REPORTED = 335,
+  ATOM_PIN_STORAGE_EVENT = 336,
+  ATOM_FACE_DOWN_REPORTED = 337,
+  ATOM_BLUETOOTH_HAL_CRASH_REASON_REPORTED = 338,
+  ATOM_REBOOT_ESCROW_PREPARATION_REPORTED = 339,
+  ATOM_REBOOT_ESCROW_LSKF_CAPTURE_REPORTED = 340,
+  ATOM_REBOOT_ESCROW_REBOOT_REPORTED = 341,
+  ATOM_BINDER_LATENCY_REPORTED = 342,
+  ATOM_MEDIAMETRICS_AAUDIOSTREAM_REPORTED = 343,
+  ATOM_MEDIA_TRANSCODING_SESSION_ENDED = 344,
+  ATOM_MAGNIFICATION_USAGE_REPORTED = 345,
+  ATOM_MAGNIFICATION_MODE_WITH_IME_ON_REPORTED = 346,
+  ATOM_APP_SEARCH_CALL_STATS_REPORTED = 347,
+  ATOM_APP_SEARCH_PUT_DOCUMENT_STATS_REPORTED = 348,
+  ATOM_DEVICE_CONTROL_CHANGED = 349,
+  ATOM_DEVICE_STATE_CHANGED = 350,
+  ATOM_INPUTDEVICE_REGISTERED = 351,
+  ATOM_SMARTSPACE_CARD_REPORTED = 352,
+  ATOM_AUTH_PROMPT_AUTHENTICATE_INVOKED = 353,
+  ATOM_AUTH_MANAGER_CAN_AUTHENTICATE_INVOKED = 354,
+  ATOM_AUTH_ENROLL_ACTION_INVOKED = 355,
+  ATOM_AUTH_DEPRECATED_API_USED = 356,
+  ATOM_UNATTENDED_REBOOT_OCCURRED = 357,
+  ATOM_LONG_REBOOT_BLOCKING_REPORTED = 358,
+  ATOM_LOCATION_TIME_ZONE_PROVIDER_STATE_CHANGED = 359,
+  ATOM_FDTRACK_EVENT_OCCURRED = 364,
+  ATOM_TIMEOUT_AUTO_EXTENDED_REPORTED = 365,
+  ATOM_ALARM_BATCH_DELIVERED = 367,
+  ATOM_ALARM_SCHEDULED = 368,
+  ATOM_CAR_WATCHDOG_IO_OVERUSE_STATS_REPORTED = 369,
+  ATOM_USER_LEVEL_HIBERNATION_STATE_CHANGED = 370,
+  ATOM_APP_SEARCH_INITIALIZE_STATS_REPORTED = 371,
+  ATOM_APP_SEARCH_QUERY_STATS_REPORTED = 372,
+  ATOM_APP_PROCESS_DIED = 373,
+  ATOM_NETWORK_IP_REACHABILITY_MONITOR_REPORTED = 374,
+  ATOM_SLOW_INPUT_EVENT_REPORTED = 375,
+  ATOM_ANR_OCCURRED_PROCESSING_STARTED = 376,
+  ATOM_APP_SEARCH_REMOVE_STATS_REPORTED = 377,
+  ATOM_MEDIA_CODEC_REPORTED = 378,
+  ATOM_PERMISSION_USAGE_FRAGMENT_INTERACTION = 379,
+  ATOM_PERMISSION_DETAILS_INTERACTION = 380,
+  ATOM_PRIVACY_SENSOR_TOGGLE_INTERACTION = 381,
+  ATOM_PRIVACY_TOGGLE_DIALOG_INTERACTION = 382,
+  ATOM_APP_SEARCH_OPTIMIZE_STATS_REPORTED = 383,
+  ATOM_NON_A11Y_TOOL_SERVICE_WARNING_REPORT = 384,
+  ATOM_APP_COMPAT_STATE_CHANGED = 386,
+  ATOM_SIZE_COMPAT_RESTART_BUTTON_EVENT_REPORTED = 387,
+  ATOM_SPLITSCREEN_UI_CHANGED = 388,
+  ATOM_NETWORK_DNS_HANDSHAKE_REPORTED = 389,
+  ATOM_BLUETOOTH_CODE_PATH_COUNTER = 390,
+  ATOM_BLUETOOTH_LE_BATCH_SCAN_REPORT_DELAY = 392,
+  ATOM_ACCESSIBILITY_FLOATING_MENU_UI_CHANGED = 393,
+  ATOM_NEURALNETWORKS_COMPILATION_COMPLETED = 394,
+  ATOM_NEURALNETWORKS_EXECUTION_COMPLETED = 395,
+  ATOM_NEURALNETWORKS_COMPILATION_FAILED = 396,
+  ATOM_NEURALNETWORKS_EXECUTION_FAILED = 397,
+  ATOM_CONTEXT_HUB_BOOTED = 398,
+  ATOM_CONTEXT_HUB_RESTARTED = 399,
+  ATOM_CONTEXT_HUB_LOADED_NANOAPP_SNAPSHOT_REPORTED = 400,
+  ATOM_CHRE_CODE_DOWNLOAD_TRANSACTED = 401,
+  ATOM_UWB_SESSION_INITED = 402,
+  ATOM_UWB_SESSION_CLOSED = 403,
+  ATOM_UWB_FIRST_RANGING_RECEIVED = 404,
+  ATOM_UWB_RANGING_MEASUREMENT_RECEIVED = 405,
+  ATOM_TEXT_CLASSIFIER_DOWNLOAD_WORK_SCHEDULED = 406,
+  ATOM_TEXT_CLASSIFIER_DOWNLOAD_WORK_COMPLETED = 407,
+  ATOM_CLIPBOARD_CLEARED = 408,
+  ATOM_VM_CREATION_REQUESTED = 409,
+  ATOM_NEARBY_DEVICE_SCAN_STATE_CHANGED = 410,
+  ATOM_APPLICATION_LOCALES_CHANGED = 412,
+  ATOM_MEDIAMETRICS_AUDIOTRACKSTATUS_REPORTED = 413,
+  ATOM_FOLD_STATE_DURATION_REPORTED = 414,
+  ATOM_LOCATION_TIME_ZONE_PROVIDER_CONTROLLER_STATE_CHANGED = 415,
+  ATOM_DISPLAY_HBM_STATE_CHANGED = 416,
+  ATOM_DISPLAY_HBM_BRIGHTNESS_CHANGED = 417,
+  ATOM_PERSISTENT_URI_PERMISSIONS_FLUSHED = 418,
+  ATOM_EARLY_BOOT_COMP_OS_ARTIFACTS_CHECK_REPORTED = 419,
+  ATOM_VBMETA_DIGEST_REPORTED = 420,
+  ATOM_APEX_INFO_GATHERED = 421,
+  ATOM_PVM_INFO_GATHERED = 422,
+  ATOM_WEAR_SETTINGS_UI_INTERACTED = 423,
+  ATOM_TRACING_SERVICE_REPORT_EVENT = 424,
+  ATOM_MEDIAMETRICS_AUDIORECORDSTATUS_REPORTED = 425,
+  ATOM_LAUNCHER_LATENCY = 426,
+  ATOM_DROPBOX_ENTRY_DROPPED = 427,
+  ATOM_WIFI_P2P_CONNECTION_REPORTED = 428,
+  ATOM_GAME_STATE_CHANGED = 429,
+  ATOM_HOTWORD_DETECTOR_CREATE_REQUESTED = 430,
+  ATOM_HOTWORD_DETECTION_SERVICE_INIT_RESULT_REPORTED = 431,
+  ATOM_HOTWORD_DETECTION_SERVICE_RESTARTED = 432,
+  ATOM_HOTWORD_DETECTOR_KEYPHRASE_TRIGGERED = 433,
+  ATOM_HOTWORD_DETECTOR_EVENTS = 434,
+  ATOM_BOOT_COMPLETED_BROADCAST_COMPLETION_LATENCY_REPORTED = 437,
+  ATOM_CONTACTS_INDEXER_UPDATE_STATS_REPORTED = 440,
+  ATOM_APP_BACKGROUND_RESTRICTIONS_INFO = 441,
+  ATOM_MMS_SMS_PROVIDER_GET_THREAD_ID_FAILED = 442,
+  ATOM_MMS_SMS_DATABASE_HELPER_ON_UPGRADE_FAILED = 443,
+  ATOM_PERMISSION_REMINDER_NOTIFICATION_INTERACTED = 444,
+  ATOM_RECENT_PERMISSION_DECISIONS_INTERACTED = 445,
+  ATOM_GNSS_PSDS_DOWNLOAD_REPORTED = 446,
+  ATOM_LE_AUDIO_CONNECTION_SESSION_REPORTED = 447,
+  ATOM_LE_AUDIO_BROADCAST_SESSION_REPORTED = 448,
+  ATOM_DREAM_UI_EVENT_REPORTED = 449,
+  ATOM_TASK_MANAGER_EVENT_REPORTED = 450,
+  ATOM_CDM_ASSOCIATION_ACTION = 451,
+  ATOM_MAGNIFICATION_TRIPLE_TAP_AND_HOLD_ACTIVATED_SESSION_REPORTED = 452,
+  ATOM_MAGNIFICATION_FOLLOW_TYPING_FOCUS_ACTIVATED_SESSION_REPORTED = 453,
+  ATOM_ACCESSIBILITY_TEXT_READING_OPTIONS_CHANGED = 454,
+  ATOM_WIFI_SETUP_FAILURE_CRASH_REPORTED = 455,
+  ATOM_UWB_DEVICE_ERROR_REPORTED = 456,
+  ATOM_ISOLATED_COMPILATION_SCHEDULED = 457,
+  ATOM_ISOLATED_COMPILATION_ENDED = 458,
+  ATOM_ONS_OPPORTUNISTIC_ESIM_PROVISIONING_COMPLETE = 459,
+  ATOM_SYSTEM_SERVER_PRE_WATCHDOG_OCCURRED = 460,
+  ATOM_TELEPHONY_ANOMALY_DETECTED = 461,
+  ATOM_LETTERBOX_POSITION_CHANGED = 462,
+  ATOM_REMOTE_KEY_PROVISIONING_ATTEMPT = 463,
+  ATOM_REMOTE_KEY_PROVISIONING_NETWORK_INFO = 464,
+  ATOM_REMOTE_KEY_PROVISIONING_TIMING = 465,
+  ATOM_MEDIAOUTPUT_OP_INTERACTION_REPORT = 466,
+  ATOM_SYNC_EXEMPTION_OCCURRED = 468,
+  ATOM_AUTOFILL_PRESENTATION_EVENT_REPORTED = 469,
+  ATOM_DOCK_STATE_CHANGED = 470,
+  ATOM_SAFETY_SOURCE_STATE_COLLECTED = 471,
+  ATOM_SAFETY_CENTER_SYSTEM_EVENT_REPORTED = 472,
+  ATOM_SAFETY_CENTER_INTERACTION_REPORTED = 473,
+  ATOM_SETTINGS_PROVIDER_SETTING_CHANGED = 474,
+  ATOM_BROADCAST_DELIVERY_EVENT_REPORTED = 475,
+  ATOM_SERVICE_REQUEST_EVENT_REPORTED = 476,
+  ATOM_PROVIDER_ACQUISITION_EVENT_REPORTED = 477,
+  ATOM_BLUETOOTH_DEVICE_NAME_REPORTED = 478,
+  ATOM_CB_CONFIG_UPDATED = 479,
+  ATOM_CB_MODULE_ERROR_REPORTED = 480,
+  ATOM_CB_SERVICE_FEATURE_CHANGED = 481,
+  ATOM_CB_RECEIVER_FEATURE_CHANGED = 482,
+  ATOM_PRIVACY_SIGNAL_NOTIFICATION_INTERACTION = 484,
+  ATOM_PRIVACY_SIGNAL_ISSUE_CARD_INTERACTION = 485,
+  ATOM_PRIVACY_SIGNALS_JOB_FAILURE = 486,
+  ATOM_VIBRATION_REPORTED = 487,
+  ATOM_UWB_RANGING_START = 489,
+  ATOM_APP_COMPACTED_V2 = 491,
+  ATOM_DISPLAY_BRIGHTNESS_CHANGED = 494,
+  ATOM_ACTIVITY_ACTION_BLOCKED = 495,
+  ATOM_NETWORK_DNS_SERVER_SUPPORT_REPORTED = 504,
+  ATOM_VM_BOOTED = 505,
+  ATOM_VM_EXITED = 506,
+  ATOM_AMBIENT_BRIGHTNESS_STATS_REPORTED = 507,
+  ATOM_MEDIAMETRICS_SPATIALIZERCAPABILITIES_REPORTED = 508,
+  ATOM_MEDIAMETRICS_SPATIALIZERDEVICEENABLED_REPORTED = 509,
+  ATOM_MEDIAMETRICS_HEADTRACKERDEVICEENABLED_REPORTED = 510,
+  ATOM_MEDIAMETRICS_HEADTRACKERDEVICESUPPORTED_REPORTED = 511,
+  ATOM_HEARING_AID_INFO_REPORTED = 513,
+  ATOM_DEVICE_WIDE_JOB_CONSTRAINT_CHANGED = 514,
+  ATOM_AMBIENT_MODE_CHANGED = 515,
+  ATOM_ANR_LATENCY_REPORTED = 516,
+  ATOM_RESOURCE_API_INFO = 517,
+  ATOM_SYSTEM_DEFAULT_NETWORK_CHANGED = 518,
+  ATOM_IWLAN_SETUP_DATA_CALL_RESULT_REPORTED = 519,
+  ATOM_IWLAN_PDN_DISCONNECTED_REASON_REPORTED = 520,
+  ATOM_AIRPLANE_MODE_SESSION_REPORTED = 521,
+  ATOM_VM_CPU_STATUS_REPORTED = 522,
+  ATOM_VM_MEM_STATUS_REPORTED = 523,
+  ATOM_PACKAGE_INSTALLATION_SESSION_REPORTED = 524,
+  ATOM_DEFAULT_NETWORK_REMATCH_INFO = 525,
+  ATOM_NETWORK_SELECTION_PERFORMANCE = 526,
+  ATOM_NETWORK_NSD_REPORTED = 527,
+  ATOM_BLUETOOTH_DISCONNECTION_REASON_REPORTED = 529,
+  ATOM_BLUETOOTH_LOCAL_VERSIONS_REPORTED = 530,
+  ATOM_BLUETOOTH_REMOTE_SUPPORTED_FEATURES_REPORTED = 531,
+  ATOM_BLUETOOTH_LOCAL_SUPPORTED_FEATURES_REPORTED = 532,
+  ATOM_BLUETOOTH_GATT_APP_INFO = 533,
+  ATOM_BRIGHTNESS_CONFIGURATION_UPDATED = 534,
+  ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_LAUNCHED = 538,
+  ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FINISHED = 539,
+  ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_CONNECTION_REPORTED = 540,
+  ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_DEVICE_SCAN_TRIGGERED = 541,
+  ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FIRST_DEVICE_SCAN_LATENCY = 542,
+  ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_CONNECT_DEVICE_LATENCY = 543,
+  ATOM_PACKAGE_MANAGER_SNAPSHOT_REPORTED = 544,
+  ATOM_PACKAGE_MANAGER_APPS_FILTER_CACHE_BUILD_REPORTED = 545,
+  ATOM_PACKAGE_MANAGER_APPS_FILTER_CACHE_UPDATE_REPORTED = 546,
+  ATOM_LAUNCHER_IMPRESSION_EVENT = 547,
+  ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_ALL_DEVICES_SCAN_LATENCY = 549,
+  ATOM_WS_WATCH_FACE_EDITED = 551,
+  ATOM_WS_WATCH_FACE_FAVORITE_ACTION_REPORTED = 552,
+  ATOM_WS_WATCH_FACE_SET_ACTION_REPORTED = 553,
+  ATOM_PACKAGE_UNINSTALLATION_REPORTED = 554,
+  ATOM_GAME_MODE_CHANGED = 555,
+  ATOM_GAME_MODE_CONFIGURATION_CHANGED = 556,
+  ATOM_BEDTIME_MODE_STATE_CHANGED = 557,
+  ATOM_NETWORK_SLICE_SESSION_ENDED = 558,
+  ATOM_NETWORK_SLICE_DAILY_DATA_USAGE_REPORTED = 559,
+  ATOM_NFC_TAG_TYPE_OCCURRED = 560,
+  ATOM_NFC_AID_CONFLICT_OCCURRED = 561,
+  ATOM_NFC_READER_CONFLICT_OCCURRED = 562,
+  ATOM_WS_TILE_LIST_CHANGED = 563,
+  ATOM_GET_TYPE_ACCESSED_WITHOUT_PERMISSION = 564,
+  ATOM_MOBILE_BUNDLED_APP_INFO_GATHERED = 566,
+  ATOM_WS_WATCH_FACE_COMPLICATION_SET_CHANGED = 567,
+  ATOM_MEDIA_DRM_CREATED = 568,
+  ATOM_MEDIA_DRM_ERRORED = 569,
+  ATOM_MEDIA_DRM_SESSION_OPENED = 570,
+  ATOM_MEDIA_DRM_SESSION_CLOSED = 571,
+  ATOM_USER_SELECTED_RESOLUTION = 572,
+  ATOM_UNSAFE_INTENT_EVENT_REPORTED = 573,
+  ATOM_PERFORMANCE_HINT_SESSION_REPORTED = 574,
+  ATOM_MEDIAMETRICS_MIDI_DEVICE_CLOSE_REPORTED = 576,
+  ATOM_BIOMETRIC_TOUCH_REPORTED = 577,
+  ATOM_HOTWORD_AUDIO_EGRESS_EVENT_REPORTED = 578,
+  ATOM_LOCATION_ENABLED_STATE_CHANGED = 580,
+  ATOM_IME_REQUEST_FINISHED = 581,
+  ATOM_USB_COMPLIANCE_WARNINGS_REPORTED = 582,
+  ATOM_APP_SUPPORTED_LOCALES_CHANGED = 583,
+  ATOM_MEDIA_PROVIDER_VOLUME_RECOVERY_REPORTED = 586,
+  ATOM_BIOMETRIC_PROPERTIES_COLLECTED = 587,
+  ATOM_KERNEL_WAKEUP_ATTRIBUTED = 588,
+  ATOM_SCREEN_STATE_CHANGED_V2 = 589,
+  ATOM_WS_BACKUP_ACTION_REPORTED = 590,
+  ATOM_WS_RESTORE_ACTION_REPORTED = 591,
+  ATOM_DEVICE_LOG_ACCESS_EVENT_REPORTED = 592,
+  ATOM_MEDIA_SESSION_UPDATED = 594,
+  ATOM_WEAR_OOBE_STATE_CHANGED = 595,
+  ATOM_WS_NOTIFICATION_UPDATED = 596,
+  ATOM_NETWORK_VALIDATION_FAILURE_STATS_DAILY_REPORTED = 601,
+  ATOM_WS_COMPLICATION_TAPPED = 602,
+  ATOM_WS_NOTIFICATION_BLOCKING = 780,
+  ATOM_WS_NOTIFICATION_BRIDGEMODE_UPDATED = 822,
+  ATOM_WS_NOTIFICATION_DISMISSAL_ACTIONED = 823,
+  ATOM_WS_NOTIFICATION_ACTIONED = 824,
+  ATOM_WS_NOTIFICATION_LATENCY = 880,
+  ATOM_WIFI_BYTES_TRANSFER = 10000,
+  ATOM_WIFI_BYTES_TRANSFER_BY_FG_BG = 10001,
+  ATOM_MOBILE_BYTES_TRANSFER = 10002,
+  ATOM_MOBILE_BYTES_TRANSFER_BY_FG_BG = 10003,
+  ATOM_BLUETOOTH_BYTES_TRANSFER = 10006,
+  ATOM_KERNEL_WAKELOCK = 10004,
+  ATOM_SUBSYSTEM_SLEEP_STATE = 10005,
+  ATOM_CPU_TIME_PER_UID = 10009,
+  ATOM_CPU_TIME_PER_UID_FREQ = 10010,
+  ATOM_WIFI_ACTIVITY_INFO = 10011,
+  ATOM_MODEM_ACTIVITY_INFO = 10012,
+  ATOM_BLUETOOTH_ACTIVITY_INFO = 10007,
+  ATOM_PROCESS_MEMORY_STATE = 10013,
+  ATOM_SYSTEM_ELAPSED_REALTIME = 10014,
+  ATOM_SYSTEM_UPTIME = 10015,
+  ATOM_CPU_ACTIVE_TIME = 10016,
+  ATOM_CPU_CLUSTER_TIME = 10017,
+  ATOM_DISK_SPACE = 10018,
+  ATOM_REMAINING_BATTERY_CAPACITY = 10019,
+  ATOM_FULL_BATTERY_CAPACITY = 10020,
+  ATOM_TEMPERATURE = 10021,
+  ATOM_BINDER_CALLS = 10022,
+  ATOM_BINDER_CALLS_EXCEPTIONS = 10023,
+  ATOM_LOOPER_STATS = 10024,
+  ATOM_DISK_STATS = 10025,
+  ATOM_DIRECTORY_USAGE = 10026,
+  ATOM_APP_SIZE = 10027,
+  ATOM_CATEGORY_SIZE = 10028,
+  ATOM_PROC_STATS = 10029,
+  ATOM_BATTERY_VOLTAGE = 10030,
+  ATOM_NUM_FINGERPRINTS_ENROLLED = 10031,
+  ATOM_DISK_IO = 10032,
+  ATOM_POWER_PROFILE = 10033,
+  ATOM_PROC_STATS_PKG_PROC = 10034,
+  ATOM_PROCESS_CPU_TIME = 10035,
+  ATOM_CPU_TIME_PER_THREAD_FREQ = 10037,
+  ATOM_ON_DEVICE_POWER_MEASUREMENT = 10038,
+  ATOM_DEVICE_CALCULATED_POWER_USE = 10039,
+  ATOM_PROCESS_MEMORY_HIGH_WATER_MARK = 10042,
+  ATOM_BATTERY_LEVEL = 10043,
+  ATOM_BUILD_INFORMATION = 10044,
+  ATOM_BATTERY_CYCLE_COUNT = 10045,
+  ATOM_DEBUG_ELAPSED_CLOCK = 10046,
+  ATOM_DEBUG_FAILING_ELAPSED_CLOCK = 10047,
+  ATOM_NUM_FACES_ENROLLED = 10048,
+  ATOM_ROLE_HOLDER = 10049,
+  ATOM_DANGEROUS_PERMISSION_STATE = 10050,
+  ATOM_TRAIN_INFO = 10051,
+  ATOM_TIME_ZONE_DATA_INFO = 10052,
+  ATOM_EXTERNAL_STORAGE_INFO = 10053,
+  ATOM_GPU_STATS_GLOBAL_INFO = 10054,
+  ATOM_GPU_STATS_APP_INFO = 10055,
+  ATOM_SYSTEM_ION_HEAP_SIZE = 10056,
+  ATOM_APPS_ON_EXTERNAL_STORAGE_INFO = 10057,
+  ATOM_FACE_SETTINGS = 10058,
+  ATOM_COOLING_DEVICE = 10059,
+  ATOM_APP_OPS = 10060,
+  ATOM_PROCESS_SYSTEM_ION_HEAP_SIZE = 10061,
+  ATOM_SURFACEFLINGER_STATS_GLOBAL_INFO = 10062,
+  ATOM_SURFACEFLINGER_STATS_LAYER_INFO = 10063,
+  ATOM_PROCESS_MEMORY_SNAPSHOT = 10064,
+  ATOM_VMS_CLIENT_STATS = 10065,
+  ATOM_NOTIFICATION_REMOTE_VIEWS = 10066,
+  ATOM_DANGEROUS_PERMISSION_STATE_SAMPLED = 10067,
+  ATOM_GRAPHICS_STATS = 10068,
+  ATOM_RUNTIME_APP_OP_ACCESS = 10069,
+  ATOM_ION_HEAP_SIZE = 10070,
+  ATOM_PACKAGE_NOTIFICATION_PREFERENCES = 10071,
+  ATOM_PACKAGE_NOTIFICATION_CHANNEL_PREFERENCES = 10072,
+  ATOM_PACKAGE_NOTIFICATION_CHANNEL_GROUP_PREFERENCES = 10073,
+  ATOM_GNSS_STATS = 10074,
+  ATOM_ATTRIBUTED_APP_OPS = 10075,
+  ATOM_VOICE_CALL_SESSION = 10076,
+  ATOM_VOICE_CALL_RAT_USAGE = 10077,
+  ATOM_SIM_SLOT_STATE = 10078,
+  ATOM_SUPPORTED_RADIO_ACCESS_FAMILY = 10079,
+  ATOM_SETTING_SNAPSHOT = 10080,
+  ATOM_BLOB_INFO = 10081,
+  ATOM_DATA_USAGE_BYTES_TRANSFER = 10082,
+  ATOM_BYTES_TRANSFER_BY_TAG_AND_METERED = 10083,
+  ATOM_DND_MODE_RULE = 10084,
+  ATOM_GENERAL_EXTERNAL_STORAGE_ACCESS_STATS = 10085,
+  ATOM_INCOMING_SMS = 10086,
+  ATOM_OUTGOING_SMS = 10087,
+  ATOM_CARRIER_ID_TABLE_VERSION = 10088,
+  ATOM_DATA_CALL_SESSION = 10089,
+  ATOM_CELLULAR_SERVICE_STATE = 10090,
+  ATOM_CELLULAR_DATA_SERVICE_SWITCH = 10091,
+  ATOM_SYSTEM_MEMORY = 10092,
+  ATOM_IMS_REGISTRATION_TERMINATION = 10093,
+  ATOM_IMS_REGISTRATION_STATS = 10094,
+  ATOM_CPU_TIME_PER_CLUSTER_FREQ = 10095,
+  ATOM_CPU_CYCLES_PER_UID_CLUSTER = 10096,
+  ATOM_DEVICE_ROTATED_DATA = 10097,
+  ATOM_CPU_CYCLES_PER_THREAD_GROUP_CLUSTER = 10098,
+  ATOM_MEDIA_DRM_ACTIVITY_INFO = 10099,
+  ATOM_OEM_MANAGED_BYTES_TRANSFER = 10100,
+  ATOM_GNSS_POWER_STATS = 10101,
+  ATOM_TIME_ZONE_DETECTOR_STATE = 10102,
+  ATOM_KEYSTORE2_STORAGE_STATS = 10103,
+  ATOM_RKP_POOL_STATS = 10104,
+  ATOM_PROCESS_DMABUF_MEMORY = 10105,
+  ATOM_PENDING_ALARM_INFO = 10106,
+  ATOM_USER_LEVEL_HIBERNATED_APPS = 10107,
+  ATOM_LAUNCHER_LAYOUT_SNAPSHOT = 10108,
+  ATOM_GLOBAL_HIBERNATED_APPS = 10109,
+  ATOM_INPUT_EVENT_LATENCY_SKETCH = 10110,
+  ATOM_BATTERY_USAGE_STATS_BEFORE_RESET = 10111,
+  ATOM_BATTERY_USAGE_STATS_SINCE_RESET = 10112,
+  ATOM_BATTERY_USAGE_STATS_SINCE_RESET_USING_POWER_PROFILE_MODEL = 10113,
+  ATOM_INSTALLED_INCREMENTAL_PACKAGE = 10114,
+  ATOM_TELEPHONY_NETWORK_REQUESTS = 10115,
+  ATOM_APP_SEARCH_STORAGE_INFO = 10116,
+  ATOM_VMSTAT = 10117,
+  ATOM_KEYSTORE2_KEY_CREATION_WITH_GENERAL_INFO = 10118,
+  ATOM_KEYSTORE2_KEY_CREATION_WITH_AUTH_INFO = 10119,
+  ATOM_KEYSTORE2_KEY_CREATION_WITH_PURPOSE_AND_MODES_INFO = 10120,
+  ATOM_KEYSTORE2_ATOM_WITH_OVERFLOW = 10121,
+  ATOM_KEYSTORE2_KEY_OPERATION_WITH_PURPOSE_AND_MODES_INFO = 10122,
+  ATOM_KEYSTORE2_KEY_OPERATION_WITH_GENERAL_INFO = 10123,
+  ATOM_RKP_ERROR_STATS = 10124,
+  ATOM_KEYSTORE2_CRASH_STATS = 10125,
+  ATOM_VENDOR_APEX_INFO = 10126,
+  ATOM_ACCESSIBILITY_SHORTCUT_STATS = 10127,
+  ATOM_ACCESSIBILITY_FLOATING_MENU_STATS = 10128,
+  ATOM_DATA_USAGE_BYTES_TRANSFER_V2 = 10129,
+  ATOM_MEDIA_CAPABILITIES = 10130,
+  ATOM_CAR_WATCHDOG_SYSTEM_IO_USAGE_SUMMARY = 10131,
+  ATOM_CAR_WATCHDOG_UID_IO_USAGE_SUMMARY = 10132,
+  ATOM_IMS_REGISTRATION_FEATURE_TAG_STATS = 10133,
+  ATOM_RCS_CLIENT_PROVISIONING_STATS = 10134,
+  ATOM_RCS_ACS_PROVISIONING_STATS = 10135,
+  ATOM_SIP_DELEGATE_STATS = 10136,
+  ATOM_SIP_TRANSPORT_FEATURE_TAG_STATS = 10137,
+  ATOM_SIP_MESSAGE_RESPONSE = 10138,
+  ATOM_SIP_TRANSPORT_SESSION = 10139,
+  ATOM_IMS_DEDICATED_BEARER_LISTENER_EVENT = 10140,
+  ATOM_IMS_DEDICATED_BEARER_EVENT = 10141,
+  ATOM_IMS_REGISTRATION_SERVICE_DESC_STATS = 10142,
+  ATOM_UCE_EVENT_STATS = 10143,
+  ATOM_PRESENCE_NOTIFY_EVENT = 10144,
+  ATOM_GBA_EVENT = 10145,
+  ATOM_PER_SIM_STATUS = 10146,
+  ATOM_GPU_WORK_PER_UID = 10147,
+  ATOM_PERSISTENT_URI_PERMISSIONS_AMOUNT_PER_PACKAGE = 10148,
+  ATOM_SIGNED_PARTITION_INFO = 10149,
+  ATOM_PINNED_FILE_SIZES_PER_PACKAGE = 10150,
+  ATOM_PENDING_INTENTS_PER_PACKAGE = 10151,
+  ATOM_USER_INFO = 10152,
+  ATOM_TELEPHONY_NETWORK_REQUESTS_V2 = 10153,
+  ATOM_DEVICE_TELEPHONY_PROPERTIES = 10154,
+  ATOM_REMOTE_KEY_PROVISIONING_ERROR_COUNTS = 10155,
+  ATOM_SAFETY_STATE = 10156,
+  ATOM_INCOMING_MMS = 10157,
+  ATOM_OUTGOING_MMS = 10158,
+  ATOM_MULTI_USER_INFO = 10160,
+  ATOM_NETWORK_BPF_MAP_INFO = 10161,
+  ATOM_OUTGOING_SHORT_CODE_SMS = 10162,
+  ATOM_CONNECTIVITY_STATE_SAMPLE = 10163,
+  ATOM_NETWORK_SELECTION_REMATCH_REASONS_INFO = 10164,
+  ATOM_GAME_MODE_INFO = 10165,
+  ATOM_GAME_MODE_CONFIGURATION = 10166,
+  ATOM_GAME_MODE_LISTENER = 10167,
+  ATOM_NETWORK_SLICE_REQUEST_COUNT = 10168,
+  ATOM_WS_TILE_SNAPSHOT = 10169,
+  ATOM_WS_ACTIVE_WATCH_FACE_COMPLICATION_SET_SNAPSHOT = 10170,
+  ATOM_PROCESS_STATE = 10171,
+  ATOM_PROCESS_ASSOCIATION = 10172,
+  ATOM_ADPF_SYSTEM_COMPONENT_INFO = 10173,
+  ATOM_NOTIFICATION_MEMORY_USE = 10174,
+  ATOM_HDR_CAPABILITIES = 10175,
+  ATOM_WS_FAVOURITE_WATCH_FACE_LIST_SNAPSHOT = 10176,
+  ATOM_ACCESSIBILITY_CHECK_RESULT_REPORTED = 910,
+  ATOM_ADAPTIVE_AUTH_UNLOCK_AFTER_LOCK_REPORTED = 820,
+  ATOM_THERMAL_STATUS_CALLED = 772,
+  ATOM_THERMAL_HEADROOM_CALLED = 773,
+  ATOM_THERMAL_HEADROOM_THRESHOLDS_CALLED = 774,
+  ATOM_ADPF_HINT_SESSION_TID_CLEANUP = 839,
+  ATOM_THERMAL_HEADROOM_THRESHOLDS = 10201,
+  ATOM_ADPF_SESSION_SNAPSHOT = 10218,
+  ATOM_JSSCRIPTENGINE_LATENCY_REPORTED = 483,
+  ATOM_AD_SERVICES_API_CALLED = 435,
+  ATOM_AD_SERVICES_MESUREMENT_REPORTS_UPLOADED = 436,
+  ATOM_MOBILE_DATA_DOWNLOAD_FILE_GROUP_STATUS_REPORTED = 490,
+  ATOM_MOBILE_DATA_DOWNLOAD_DOWNLOAD_RESULT_REPORTED = 502,
+  ATOM_AD_SERVICES_SETTINGS_USAGE_REPORTED = 493,
+  ATOM_BACKGROUND_FETCH_PROCESS_REPORTED = 496,
+  ATOM_UPDATE_CUSTOM_AUDIENCE_PROCESS_REPORTED = 497,
+  ATOM_RUN_AD_BIDDING_PROCESS_REPORTED = 498,
+  ATOM_RUN_AD_SCORING_PROCESS_REPORTED = 499,
+  ATOM_RUN_AD_SELECTION_PROCESS_REPORTED = 500,
+  ATOM_RUN_AD_BIDDING_PER_CA_PROCESS_REPORTED = 501,
+  ATOM_MOBILE_DATA_DOWNLOAD_FILE_GROUP_STORAGE_STATS_REPORTED = 503,
+  ATOM_AD_SERVICES_MEASUREMENT_REGISTRATIONS = 512,
+  ATOM_AD_SERVICES_GET_TOPICS_REPORTED = 535,
+  ATOM_AD_SERVICES_EPOCH_COMPUTATION_GET_TOP_TOPICS_REPORTED = 536,
+  ATOM_AD_SERVICES_EPOCH_COMPUTATION_CLASSIFIER_REPORTED = 537,
+  ATOM_AD_SERVICES_BACK_COMPAT_GET_TOPICS_REPORTED = 598,
+  ATOM_AD_SERVICES_BACK_COMPAT_EPOCH_COMPUTATION_CLASSIFIER_REPORTED = 599,
+  ATOM_AD_SERVICES_MEASUREMENT_DEBUG_KEYS = 640,
+  ATOM_AD_SERVICES_ERROR_REPORTED = 662,
+  ATOM_AD_SERVICES_BACKGROUND_JOBS_EXECUTION_REPORTED = 663,
+  ATOM_AD_SERVICES_MEASUREMENT_DELAYED_SOURCE_REGISTRATION = 673,
+  ATOM_AD_SERVICES_MEASUREMENT_ATTRIBUTION = 674,
+  ATOM_AD_SERVICES_MEASUREMENT_JOBS = 675,
+  ATOM_AD_SERVICES_MEASUREMENT_WIPEOUT = 676,
+  ATOM_AD_SERVICES_MEASUREMENT_AD_ID_MATCH_FOR_DEBUG_KEYS = 695,
+  ATOM_AD_SERVICES_ENROLLMENT_DATA_STORED = 697,
+  ATOM_AD_SERVICES_ENROLLMENT_FILE_DOWNLOADED = 698,
+  ATOM_AD_SERVICES_ENROLLMENT_MATCHED = 699,
+  ATOM_AD_SERVICES_CONSENT_MIGRATED = 702,
+  ATOM_AD_SERVICES_ENROLLMENT_FAILED = 714,
+  ATOM_AD_SERVICES_MEASUREMENT_CLICK_VERIFICATION = 756,
+  ATOM_AD_SERVICES_ENCRYPTION_KEY_FETCHED = 765,
+  ATOM_AD_SERVICES_ENCRYPTION_KEY_DB_TRANSACTION_ENDED = 766,
+  ATOM_DESTINATION_REGISTERED_BEACONS = 767,
+  ATOM_REPORT_INTERACTION_API_CALLED = 768,
+  ATOM_INTERACTION_REPORTING_TABLE_CLEARED = 769,
+  ATOM_APP_MANIFEST_CONFIG_HELPER_CALLED = 788,
+  ATOM_AD_FILTERING_PROCESS_JOIN_CA_REPORTED = 793,
+  ATOM_AD_FILTERING_PROCESS_AD_SELECTION_REPORTED = 794,
+  ATOM_AD_COUNTER_HISTOGRAM_UPDATER_REPORTED = 795,
+  ATOM_SIGNATURE_VERIFICATION = 807,
+  ATOM_K_ANON_IMMEDIATE_SIGN_JOIN_STATUS_REPORTED = 808,
+  ATOM_K_ANON_BACKGROUND_JOB_STATUS_REPORTED = 809,
+  ATOM_K_ANON_INITIALIZE_STATUS_REPORTED = 810,
+  ATOM_K_ANON_SIGN_STATUS_REPORTED = 811,
+  ATOM_K_ANON_JOIN_STATUS_REPORTED = 812,
+  ATOM_K_ANON_KEY_ATTESTATION_STATUS_REPORTED = 813,
+  ATOM_GET_AD_SELECTION_DATA_API_CALLED = 814,
+  ATOM_GET_AD_SELECTION_DATA_BUYER_INPUT_GENERATED = 815,
+  ATOM_BACKGROUND_JOB_SCHEDULING_REPORTED = 834,
+  ATOM_TOPICS_ENCRYPTION_EPOCH_COMPUTATION_REPORTED = 840,
+  ATOM_TOPICS_ENCRYPTION_GET_TOPICS_REPORTED = 841,
+  ATOM_ADSERVICES_SHELL_COMMAND_CALLED = 842,
+  ATOM_UPDATE_SIGNALS_API_CALLED = 843,
+  ATOM_ENCODING_JOB_RUN = 844,
+  ATOM_ENCODING_JS_FETCH = 845,
+  ATOM_ENCODING_JS_EXECUTION = 846,
+  ATOM_PERSIST_AD_SELECTION_RESULT_CALLED = 847,
+  ATOM_SERVER_AUCTION_KEY_FETCH_CALLED = 848,
+  ATOM_SERVER_AUCTION_BACKGROUND_KEY_FETCH_ENABLED = 849,
+  ATOM_AD_SERVICES_MEASUREMENT_PROCESS_ODP_REGISTRATION = 864,
+  ATOM_AD_SERVICES_MEASUREMENT_NOTIFY_REGISTRATION_TO_ODP = 865,
+  ATOM_SELECT_ADS_FROM_OUTCOMES_API_CALLED = 876,
+  ATOM_REPORT_IMPRESSION_API_CALLED = 877,
+  ATOM_AD_SERVICES_ENROLLMENT_TRANSACTION_STATS = 885,
+  ATOM_AD_SERVICES_COBALT_LOGGER_EVENT_REPORTED = 902,
+  ATOM_AD_SERVICES_COBALT_PERIODIC_JOB_EVENT_REPORTED = 903,
+  ATOM_UPDATE_SIGNALS_PROCESS_REPORTED = 905,
+  ATOM_TOPICS_SCHEDULE_EPOCH_JOB_SETTING_REPORTED = 930,
+  ATOM_AI_WALLPAPERS_BUTTON_PRESSED = 706,
+  ATOM_AI_WALLPAPERS_TEMPLATE_SELECTED = 707,
+  ATOM_AI_WALLPAPERS_TERM_SELECTED = 708,
+  ATOM_AI_WALLPAPERS_WALLPAPER_SET = 709,
+  ATOM_AI_WALLPAPERS_SESSION_SUMMARY = 710,
+  ATOM_APEX_INSTALLATION_REQUESTED = 732,
+  ATOM_APEX_INSTALLATION_STAGED = 733,
+  ATOM_APEX_INSTALLATION_ENDED = 734,
+  ATOM_APP_SEARCH_SET_SCHEMA_STATS_REPORTED = 385,
+  ATOM_APP_SEARCH_SCHEMA_MIGRATION_STATS_REPORTED = 579,
+  ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_STATS_REPORTED = 825,
+  ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_RAW_QUERY_STATS_REPORTED = 826,
+  ATOM_APP_SEARCH_APPS_INDEXER_STATS_REPORTED = 909,
+  ATOM_ART_DATUM_REPORTED = 332,
+  ATOM_ART_DEVICE_DATUM_REPORTED = 550,
+  ATOM_ART_DATUM_DELTA_REPORTED = 565,
+  ATOM_ART_DEX2OAT_REPORTED = 929,
+  ATOM_ART_DEVICE_STATUS = 10205,
+  ATOM_BACKGROUND_DEXOPT_JOB_ENDED = 467,
+  ATOM_PREREBOOT_DEXOPT_JOB_ENDED = 883,
+  ATOM_ODREFRESH_REPORTED = 366,
+  ATOM_ODSIGN_REPORTED = 548,
+  ATOM_AUTOFILL_UI_EVENT_REPORTED = 603,
+  ATOM_AUTOFILL_FILL_REQUEST_REPORTED = 604,
+  ATOM_AUTOFILL_FILL_RESPONSE_REPORTED = 605,
+  ATOM_AUTOFILL_SAVE_EVENT_REPORTED = 606,
+  ATOM_AUTOFILL_SESSION_COMMITTED = 607,
+  ATOM_AUTOFILL_FIELD_CLASSIFICATION_EVENT_REPORTED = 659,
+  ATOM_CAR_RECENTS_EVENT_REPORTED = 770,
+  ATOM_CAR_CALM_MODE_EVENT_REPORTED = 797,
+  ATOM_CAR_WAKEUP_FROM_SUSPEND_REPORTED = 852,
+  ATOM_PLUGIN_INITIALIZED = 655,
+  ATOM_BLUETOOTH_HASHED_DEVICE_NAME_REPORTED = 613,
+  ATOM_BLUETOOTH_L2CAP_COC_CLIENT_CONNECTION = 614,
+  ATOM_BLUETOOTH_L2CAP_COC_SERVER_CONNECTION = 615,
+  ATOM_BLUETOOTH_LE_SESSION_CONNECTED = 656,
+  ATOM_RESTRICTED_BLUETOOTH_DEVICE_NAME_REPORTED = 666,
+  ATOM_BLUETOOTH_PROFILE_CONNECTION_ATTEMPTED = 696,
+  ATOM_BLUETOOTH_CONTENT_PROFILE_ERROR_REPORTED = 781,
+  ATOM_BLUETOOTH_RFCOMM_CONNECTION_ATTEMPTED = 782,
+  ATOM_REMOTE_DEVICE_INFORMATION_WITH_METRIC_ID = 862,
+  ATOM_LE_APP_SCAN_STATE_CHANGED = 870,
+  ATOM_LE_RADIO_SCAN_STOPPED = 871,
+  ATOM_LE_SCAN_RESULT_RECEIVED = 872,
+  ATOM_LE_SCAN_ABUSED = 873,
+  ATOM_LE_ADV_STATE_CHANGED = 874,
+  ATOM_LE_ADV_ERROR_REPORTED = 875,
+  ATOM_A2DP_SESSION_REPORTED = 904,
+  ATOM_BLUETOOTH_CROSS_LAYER_EVENT_REPORTED = 916,
+  ATOM_BROADCAST_AUDIO_SESSION_REPORTED = 927,
+  ATOM_BROADCAST_AUDIO_SYNC_REPORTED = 928,
+  ATOM_BLUETOOTH_RFCOMM_CONNECTION_REPORTED_AT_CLOSE = 982,
+  ATOM_BLUETOOTH_LE_CONNECTION = 988,
+  ATOM_BROADCAST_SENT = 922,
+  ATOM_CAMERA_FEATURE_COMBINATION_QUERY_EVENT = 900,
+  ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_STATE_CHANGED = 934,
+  ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_UPDATE_FAILED = 972,
+  ATOM_DAILY_KEEPALIVE_INFO_REPORTED = 650,
+  ATOM_NETWORK_REQUEST_STATE_CHANGED = 779,
+  ATOM_TETHERING_ACTIVE_SESSIONS_REPORTED = 925,
+  ATOM_NETWORK_STATS_RECORDER_FILE_OPERATED = 783,
+  ATOM_CORE_NETWORKING_TERRIBLE_ERROR_OCCURRED = 979,
+  ATOM_APF_SESSION_INFO_REPORTED = 777,
+  ATOM_IP_CLIENT_RA_INFO_REPORTED = 778,
+  ATOM_VPN_CONNECTION_STATE_CHANGED = 850,
+  ATOM_VPN_CONNECTION_REPORTED = 851,
+  ATOM_CPU_POLICY = 10199,
+  ATOM_CREDENTIAL_MANAGER_API_CALLED = 585,
+  ATOM_CREDENTIAL_MANAGER_INIT_PHASE_REPORTED = 651,
+  ATOM_CREDENTIAL_MANAGER_CANDIDATE_PHASE_REPORTED = 652,
+  ATOM_CREDENTIAL_MANAGER_FINAL_PHASE_REPORTED = 653,
+  ATOM_CREDENTIAL_MANAGER_TOTAL_REPORTED = 667,
+  ATOM_CREDENTIAL_MANAGER_FINALNOUID_REPORTED = 668,
+  ATOM_CREDENTIAL_MANAGER_GET_REPORTED = 669,
+  ATOM_CREDENTIAL_MANAGER_AUTH_CLICK_REPORTED = 670,
+  ATOM_CREDENTIAL_MANAGER_APIV2_CALLED = 671,
+  ATOM_CRONET_ENGINE_CREATED = 703,
+  ATOM_CRONET_TRAFFIC_REPORTED = 704,
+  ATOM_CRONET_ENGINE_BUILDER_INITIALIZED = 762,
+  ATOM_CRONET_HTTP_FLAGS_INITIALIZED = 763,
+  ATOM_CRONET_INITIALIZED = 764,
+  ATOM_DESKTOP_MODE_UI_CHANGED = 818,
+  ATOM_DESKTOP_MODE_SESSION_TASK_UPDATE = 819,
+  ATOM_DESKTOP_MODE_TASK_SIZE_UPDATED = 935,
+  ATOM_DEVICE_LOCK_CHECK_IN_REQUEST_REPORTED = 726,
+  ATOM_DEVICE_LOCK_PROVISIONING_COMPLETE_REPORTED = 727,
+  ATOM_DEVICE_LOCK_KIOSK_APP_REQUEST_REPORTED = 728,
+  ATOM_DEVICE_LOCK_CHECK_IN_RETRY_REPORTED = 789,
+  ATOM_DEVICE_LOCK_PROVISION_FAILURE_REPORTED = 790,
+  ATOM_DEVICE_LOCK_LOCK_UNLOCK_DEVICE_FAILURE_REPORTED = 791,
+  ATOM_DEVICE_POLICY_MANAGEMENT_MODE = 10216,
+  ATOM_DEVICE_POLICY_STATE = 10217,
+  ATOM_DISPLAY_MODE_DIRECTOR_VOTE_CHANGED = 792,
+  ATOM_EXTERNAL_DISPLAY_STATE_CHANGED = 806,
+  ATOM_DND_STATE_CHANGED = 657,
+  ATOM_DREAM_SETTING_CHANGED = 705,
+  ATOM_DREAM_SETTING_SNAPSHOT = 10192,
+  ATOM_EXPRESS_EVENT_REPORTED = 528,
+  ATOM_EXPRESS_HISTOGRAM_SAMPLE_REPORTED = 593,
+  ATOM_EXPRESS_UID_EVENT_REPORTED = 644,
+  ATOM_EXPRESS_UID_HISTOGRAM_SAMPLE_REPORTED = 658,
+  ATOM_FEDERATED_COMPUTE_API_CALLED = 712,
+  ATOM_FEDERATED_COMPUTE_TRAINING_EVENT_REPORTED = 771,
+  ATOM_EXAMPLE_ITERATOR_NEXT_LATENCY_REPORTED = 838,
+  ATOM_FULL_SCREEN_INTENT_LAUNCHED = 631,
+  ATOM_BAL_ALLOWED = 632,
+  ATOM_IN_TASK_ACTIVITY_STARTED = 685,
+  ATOM_DEVICE_ORIENTATION_CHANGED = 906,
+  ATOM_CACHED_APPS_HIGH_WATERMARK = 10189,
+  ATOM_STYLUS_PREDICTION_METRICS_REPORTED = 718,
+  ATOM_USER_RISK_EVENT_REPORTED = 725,
+  ATOM_MEDIA_PROJECTION_STATE_CHANGED = 729,
+  ATOM_MEDIA_PROJECTION_TARGET_CHANGED = 730,
+  ATOM_EXCESSIVE_BINDER_PROXY_COUNT_REPORTED = 853,
+  ATOM_PROXY_BYTES_TRANSFER_BY_FG_BG = 10200,
+  ATOM_MOBILE_BYTES_TRANSFER_BY_PROC_STATE = 10204,
+  ATOM_BIOMETRIC_FRR_NOTIFICATION = 817,
+  ATOM_SENSITIVE_CONTENT_MEDIA_PROJECTION_SESSION = 830,
+  ATOM_SENSITIVE_NOTIFICATION_APP_PROTECTION_SESSION = 831,
+  ATOM_SENSITIVE_NOTIFICATION_APP_PROTECTION_APPLIED = 832,
+  ATOM_SENSITIVE_NOTIFICATION_REDACTION = 833,
+  ATOM_SENSITIVE_CONTENT_APP_PROTECTION = 835,
+  ATOM_APP_RESTRICTION_STATE_CHANGED = 866,
+  ATOM_BATTERY_USAGE_STATS_PER_UID = 10209,
+  ATOM_POSTGC_MEMORY_SNAPSHOT = 924,
+  ATOM_POWER_SAVE_TEMP_ALLOWLIST_CHANGED = 926,
+  ATOM_APP_OP_ACCESS_TRACKED = 931,
+  ATOM_CONTENT_OR_FILE_URI_EVENT_REPORTED = 933,
+  ATOM_APPLICATION_GRAMMATICAL_INFLECTION_CHANGED = 584,
+  ATOM_SYSTEM_GRAMMATICAL_INFLECTION_CHANGED = 816,
+  ATOM_BATTERY_HEALTH = 10220,
+  ATOM_HDMI_EARC_STATUS_REPORTED = 701,
+  ATOM_HDMI_SOUNDBAR_MODE_STATUS_REPORTED = 724,
+  ATOM_HEALTH_CONNECT_API_CALLED = 616,
+  ATOM_HEALTH_CONNECT_USAGE_STATS = 617,
+  ATOM_HEALTH_CONNECT_STORAGE_STATS = 618,
+  ATOM_HEALTH_CONNECT_API_INVOKED = 643,
+  ATOM_EXERCISE_ROUTE_API_CALLED = 654,
+  ATOM_HEALTH_CONNECT_EXPORT_INVOKED = 907,
+  ATOM_HEALTH_CONNECT_IMPORT_INVOKED = 918,
+  ATOM_HEALTH_CONNECT_EXPORT_IMPORT_STATS_REPORTED = 919,
+  ATOM_HEALTH_CONNECT_UI_IMPRESSION = 623,
+  ATOM_HEALTH_CONNECT_UI_INTERACTION = 624,
+  ATOM_HEALTH_CONNECT_APP_OPENED_REPORTED = 625,
+  ATOM_HOTWORD_EGRESS_SIZE_ATOM_REPORTED = 761,
+  ATOM_IKE_SESSION_TERMINATED = 678,
+  ATOM_IKE_LIVENESS_CHECK_SESSION_VALIDATED = 760,
+  ATOM_NEGOTIATED_SECURITY_ASSOCIATION = 821,
+  ATOM_KEYBOARD_CONFIGURED = 682,
+  ATOM_KEYBOARD_SYSTEMS_EVENT_REPORTED = 683,
+  ATOM_INPUTDEVICE_USAGE_REPORTED = 686,
+  ATOM_INPUT_EVENT_LATENCY_REPORTED = 932,
+  ATOM_TOUCHPAD_USAGE = 10191,
+  ATOM_KERNEL_OOM_KILL_OCCURRED = 754,
+  ATOM_EMERGENCY_STATE_CHANGED = 633,
+  ATOM_CHRE_SIGNIFICANT_MOTION_STATE_CHANGED = 868,
+  ATOM_POPULATION_DENSITY_PROVIDER_LOADING_REPORTED = 1002,
+  ATOM_DENSITY_BASED_COARSE_LOCATIONS_USAGE_REPORTED = 1003,
+  ATOM_DENSITY_BASED_COARSE_LOCATIONS_PROVIDER_QUERY_REPORTED = 1004,
+  ATOM_MEDIA_CODEC_RECLAIM_REQUEST_COMPLETED = 600,
+  ATOM_MEDIA_CODEC_STARTED = 641,
+  ATOM_MEDIA_CODEC_STOPPED = 642,
+  ATOM_MEDIA_CODEC_RENDERED = 684,
+  ATOM_MEDIA_EDITING_ENDED_REPORTED = 798,
+  ATOM_MTE_STATE = 10181,
+  ATOM_MICROXR_DEVICE_BOOT_COMPLETE_REPORTED = 901,
+  ATOM_NFC_OBSERVE_MODE_STATE_CHANGED = 855,
+  ATOM_NFC_FIELD_CHANGED = 856,
+  ATOM_NFC_POLLING_LOOP_NOTIFICATION_REPORTED = 857,
+  ATOM_NFC_PROPRIETARY_CAPABILITIES_REPORTED = 858,
+  ATOM_ONDEVICEPERSONALIZATION_API_CALLED = 711,
+  ATOM_COMPONENT_STATE_CHANGED_REPORTED = 863,
+  ATOM_PDF_LOAD_REPORTED = 859,
+  ATOM_PDF_API_USAGE_REPORTED = 860,
+  ATOM_PDF_SEARCH_REPORTED = 861,
+  ATOM_PRESSURE_STALL_INFORMATION = 10229,
+  ATOM_PERMISSION_RATIONALE_DIALOG_VIEWED = 645,
+  ATOM_PERMISSION_RATIONALE_DIALOG_ACTION_REPORTED = 646,
+  ATOM_APP_DATA_SHARING_UPDATES_NOTIFICATION_INTERACTION = 647,
+  ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_VIEWED = 648,
+  ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_ACTION_REPORTED = 649,
+  ATOM_ENHANCED_CONFIRMATION_DIALOG_RESULT_REPORTED = 827,
+  ATOM_ENHANCED_CONFIRMATION_RESTRICTION_CLEARED = 828,
+  ATOM_PHOTOPICKER_SESSION_INFO_REPORTED = 886,
+  ATOM_PHOTOPICKER_API_INFO_REPORTED = 887,
+  ATOM_PHOTOPICKER_UI_EVENT_LOGGED = 888,
+  ATOM_PHOTOPICKER_MEDIA_ITEM_STATUS_REPORTED = 889,
+  ATOM_PHOTOPICKER_PREVIEW_INFO_LOGGED = 890,
+  ATOM_PHOTOPICKER_MENU_INTERACTION_LOGGED = 891,
+  ATOM_PHOTOPICKER_BANNER_INTERACTION_LOGGED = 892,
+  ATOM_PHOTOPICKER_MEDIA_LIBRARY_INFO_LOGGED = 893,
+  ATOM_PHOTOPICKER_PAGE_INFO_LOGGED = 894,
+  ATOM_PHOTOPICKER_MEDIA_GRID_SYNC_INFO_REPORTED = 895,
+  ATOM_PHOTOPICKER_ALBUM_SYNC_INFO_REPORTED = 896,
+  ATOM_PHOTOPICKER_SEARCH_INFO_REPORTED = 897,
+  ATOM_SEARCH_DATA_EXTRACTION_DETAILS_REPORTED = 898,
+  ATOM_EMBEDDED_PHOTOPICKER_INFO_REPORTED = 899,
+  ATOM_ATOM_9999 = 9999,
+  ATOM_ATOM_99999 = 99999,
+  ATOM_SCREEN_OFF_REPORTED = 776,
+  ATOM_SCREEN_TIMEOUT_OVERRIDE_REPORTED = 836,
+  ATOM_SCREEN_INTERACTIVE_SESSION_REPORTED = 837,
+  ATOM_SCREEN_DIM_REPORTED = 867,
+  ATOM_MEDIA_PROVIDER_DATABASE_ROLLBACK_REPORTED = 784,
+  ATOM_BACKUP_SETUP_STATUS_REPORTED = 785,
+  ATOM_RANGING_SESSION_CONFIGURED = 993,
+  ATOM_RANGING_SESSION_STARTED = 994,
+  ATOM_RANGING_SESSION_CLOSED = 995,
+  ATOM_RANGING_TECHNOLOGY_STARTED = 996,
+  ATOM_RANGING_TECHNOLOGY_STOPPED = 997,
+  ATOM_RKPD_POOL_STATS = 664,
+  ATOM_RKPD_CLIENT_OPERATION = 665,
+  ATOM_SANDBOX_API_CALLED = 488,
+  ATOM_SANDBOX_ACTIVITY_EVENT_OCCURRED = 735,
+  ATOM_SDK_SANDBOX_RESTRICTED_ACCESS_IN_SESSION = 796,
+  ATOM_SANDBOX_SDK_STORAGE = 10159,
+  ATOM_SELINUX_AUDIT_LOG = 799,
+  ATOM_SETTINGS_SPA_REPORTED = 622,
+  ATOM_TEST_EXTENSION_ATOM_REPORTED = 660,
+  ATOM_TEST_RESTRICTED_ATOM_REPORTED = 672,
+  ATOM_STATS_SOCKET_LOSS_REPORTED = 752,
+  ATOM_LOCKSCREEN_SHORTCUT_SELECTED = 611,
+  ATOM_LOCKSCREEN_SHORTCUT_TRIGGERED = 612,
+  ATOM_LAUNCHER_IMPRESSION_EVENT_V2 = 716,
+  ATOM_DISPLAY_SWITCH_LATENCY_TRACKED = 753,
+  ATOM_NOTIFICATION_LISTENER_SERVICE = 829,
+  ATOM_NAV_HANDLE_TOUCH_POINTS = 869,
+  ATOM_COMMUNAL_HUB_WIDGET_EVENT_REPORTED = 908,
+  ATOM_COMMUNAL_HUB_SNAPSHOT = 10226,
+  ATOM_EMERGENCY_NUMBER_DIALED = 637,
+  ATOM_CALL_STATS = 10221,
+  ATOM_CALL_AUDIO_ROUTE_STATS = 10222,
+  ATOM_TELECOM_API_STATS = 10223,
+  ATOM_TELECOM_ERROR_STATS = 10224,
+  ATOM_CELLULAR_RADIO_POWER_STATE_CHANGED = 713,
+  ATOM_EMERGENCY_NUMBERS_INFO = 10180,
+  ATOM_DATA_NETWORK_VALIDATION = 10207,
+  ATOM_DATA_RAT_STATE_CHANGED = 854,
+  ATOM_CONNECTED_CHANNEL_CHANGED = 882,
+  ATOM_IWLAN_UNDERLYING_NETWORK_VALIDATION_RESULT_REPORTED = 923,
+  ATOM_QUALIFIED_RAT_LIST_CHANGED = 634,
+  ATOM_QNS_IMS_CALL_DROP_STATS = 635,
+  ATOM_QNS_FALLBACK_RESTRICTION_CHANGED = 636,
+  ATOM_QNS_RAT_PREFERENCE_MISMATCH_INFO = 10177,
+  ATOM_QNS_HANDOVER_TIME_MILLIS = 10178,
+  ATOM_QNS_HANDOVER_PINGPONG = 10179,
+  ATOM_SATELLITE_CONTROLLER = 10182,
+  ATOM_SATELLITE_SESSION = 10183,
+  ATOM_SATELLITE_INCOMING_DATAGRAM = 10184,
+  ATOM_SATELLITE_OUTGOING_DATAGRAM = 10185,
+  ATOM_SATELLITE_PROVISION = 10186,
+  ATOM_SATELLITE_SOS_MESSAGE_RECOMMENDER = 10187,
+  ATOM_CARRIER_ROAMING_SATELLITE_SESSION = 10211,
+  ATOM_CARRIER_ROAMING_SATELLITE_CONTROLLER_STATS = 10212,
+  ATOM_CONTROLLER_STATS_PER_PACKAGE = 10213,
+  ATOM_SATELLITE_ENTITLEMENT = 10214,
+  ATOM_SATELLITE_CONFIG_UPDATER = 10215,
+  ATOM_SATELLITE_ACCESS_CONTROLLER = 10219,
+  ATOM_CELLULAR_IDENTIFIER_DISCLOSED = 800,
+  ATOM_THREADNETWORK_TELEMETRY_DATA_REPORTED = 738,
+  ATOM_THREADNETWORK_TOPO_ENTRY_REPEATED = 739,
+  ATOM_THREADNETWORK_DEVICE_INFO_REPORTED = 740,
+  ATOM_BOOT_INTEGRITY_INFO_REPORTED = 775,
+  ATOM_TV_LOW_POWER_STANDBY_POLICY = 679,
+  ATOM_EXTERNAL_TV_INPUT_EVENT = 717,
+  ATOM_TEST_UPROBESTATS_ATOM_REPORTED = 915,
+  ATOM_UWB_ACTIVITY_INFO = 10188,
+  ATOM_MEDIATOR_UPDATED = 721,
+  ATOM_SYSPROXY_BLUETOOTH_BYTES_TRANSFER = 10196,
+  ATOM_SYSPROXY_CONNECTION_UPDATED = 786,
+  ATOM_WEAR_COMPANION_CONNECTION_STATE = 921,
+  ATOM_MEDIA_ACTION_REPORTED = 608,
+  ATOM_MEDIA_CONTROLS_LAUNCHED = 609,
+  ATOM_MEDIA_SESSION_STATE_CHANGED = 677,
+  ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_DEVICE_SCAN_API_LATENCY = 757,
+  ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_SASS_DEVICE_UNAVAILABLE = 758,
+  ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FASTPAIR_API_TIMEOUT = 759,
+  ATOM_WEAR_MODE_STATE_CHANGED = 715,
+  ATOM_RENDERER_INITIALIZED = 736,
+  ATOM_SCHEMA_VERSION_RECEIVED = 737,
+  ATOM_LAYOUT_INSPECTED = 741,
+  ATOM_LAYOUT_EXPRESSION_INSPECTED = 742,
+  ATOM_LAYOUT_ANIMATIONS_INSPECTED = 743,
+  ATOM_MATERIAL_COMPONENTS_INSPECTED = 744,
+  ATOM_TILE_REQUESTED = 745,
+  ATOM_STATE_RESPONSE_RECEIVED = 746,
+  ATOM_TILE_RESPONSE_RECEIVED = 747,
+  ATOM_INFLATION_FINISHED = 748,
+  ATOM_INFLATION_FAILED = 749,
+  ATOM_IGNORED_INFLATION_FAILURES_REPORTED = 750,
+  ATOM_DRAWABLE_RENDERED = 751,
+  ATOM_WEAR_TIME_SYNC_REQUESTED = 911,
+  ATOM_WEAR_TIME_UPDATE_STARTED = 912,
+  ATOM_WEAR_TIME_SYNC_ATTEMPT_COMPLETED = 913,
+  ATOM_WEAR_TIME_CHANGED = 914,
+  ATOM_WEAR_ADAPTIVE_SUSPEND_STATS_REPORTED = 619,
+  ATOM_WEAR_POWER_ANOMALY_SERVICE_OPERATIONAL_STATS_REPORTED = 620,
+  ATOM_WEAR_POWER_ANOMALY_SERVICE_EVENT_STATS_REPORTED = 621,
+  ATOM_WS_WEAR_TIME_SESSION = 610,
+  ATOM_WS_INCOMING_CALL_ACTION_REPORTED = 626,
+  ATOM_WS_CALL_DISCONNECTION_REPORTED = 627,
+  ATOM_WS_CALL_DURATION_REPORTED = 628,
+  ATOM_WS_CALL_USER_EXPERIENCE_LATENCY_REPORTED = 629,
+  ATOM_WS_CALL_INTERACTION_REPORTED = 630,
+  ATOM_WS_ON_BODY_STATE_CHANGED = 787,
+  ATOM_WS_WATCH_FACE_RESTRICTED_COMPLICATIONS_IMPACTED = 802,
+  ATOM_WS_WATCH_FACE_DEFAULT_RESTRICTED_COMPLICATIONS_REMOVED = 803,
+  ATOM_WS_COMPLICATIONS_IMPACTED_NOTIFICATION_EVENT_REPORTED = 804,
+  ATOM_WS_REMOTE_EVENT_USAGE_REPORTED = 920,
+  ATOM_WS_BUGREPORT_REQUESTED = 936,
+  ATOM_WS_BUGREPORT_TRIGGERED = 937,
+  ATOM_WS_BUGREPORT_FINISHED = 938,
+  ATOM_WS_BUGREPORT_RESULT_RECEIVED = 939,
+  ATOM_WS_STANDALONE_MODE_SNAPSHOT = 10197,
+  ATOM_WS_FAVORITE_WATCH_FACE_SNAPSHOT = 10206,
+  ATOM_WS_PHOTOS_WATCH_FACE_FEATURE_SNAPSHOT = 10225,
+  ATOM_WS_WATCH_FACE_CUSTOMIZATION_SNAPSHOT = 10227,
+  ATOM_WEAR_POWER_MENU_OPENED = 731,
+  ATOM_WEAR_ASSISTANT_OPENED = 755,
+  ATOM_FIRST_OVERLAY_STATE_CHANGED = 917,
+  ATOM_WIFI_AWARE_NDP_REPORTED = 638,
+  ATOM_WIFI_AWARE_ATTACH_REPORTED = 639,
+  ATOM_WIFI_SELF_RECOVERY_TRIGGERED = 661,
+  ATOM_SOFT_AP_STARTED = 680,
+  ATOM_SOFT_AP_STOPPED = 681,
+  ATOM_WIFI_LOCK_RELEASED = 687,
+  ATOM_WIFI_LOCK_DEACTIVATED = 688,
+  ATOM_WIFI_CONFIG_SAVED = 689,
+  ATOM_WIFI_AWARE_RESOURCE_USING_CHANGED = 690,
+  ATOM_WIFI_AWARE_HAL_API_CALLED = 691,
+  ATOM_WIFI_LOCAL_ONLY_REQUEST_RECEIVED = 692,
+  ATOM_WIFI_LOCAL_ONLY_REQUEST_SCAN_TRIGGERED = 693,
+  ATOM_WIFI_THREAD_TASK_EXECUTED = 694,
+  ATOM_WIFI_STATE_CHANGED = 700,
+  ATOM_PNO_SCAN_STARTED = 719,
+  ATOM_PNO_SCAN_STOPPED = 720,
+  ATOM_WIFI_IS_UNUSABLE_REPORTED = 722,
+  ATOM_WIFI_AP_CAPABILITIES_REPORTED = 723,
+  ATOM_SOFT_AP_STATE_CHANGED = 805,
+  ATOM_SCORER_PREDICTION_RESULT_REPORTED = 884,
+  ATOM_WIFI_AWARE_CAPABILITIES = 10190,
+  ATOM_WIFI_MODULE_INFO = 10193,
+  ATOM_WIFI_SETTING_INFO = 10194,
+  ATOM_WIFI_COMPLEX_SETTING_INFO = 10195,
+  ATOM_WIFI_CONFIGURED_NETWORK_INFO = 10198,
+};
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::DOCS_UI_PICK_RESULT_REPORTED:
-    return "DOCS_UI_PICK_RESULT_REPORTED";
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_ATOM_IDS_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/statsd/statsd_tracing_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_STATSD_TRACING_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_STATSD_TRACING_CONFIG_PROTO_CPP_H_
 
-  case ::perfetto::protos::pbzero::AtomId::DOCS_UI_SEARCH_MODE_REPORTED:
-    return "DOCS_UI_SEARCH_MODE_REPORTED";
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  case ::perfetto::protos::pbzero::AtomId::DOCS_UI_SEARCH_TYPE_REPORTED:
-    return "DOCS_UI_SEARCH_TYPE_REPORTED";
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  case ::perfetto::protos::pbzero::AtomId::DATA_STALL_EVENT:
-    return "DATA_STALL_EVENT";
+namespace perfetto {
+namespace protos {
+namespace gen {
+class StatsdPullAtomConfig;
+class StatsdTracingConfig;
+enum AtomId : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::RESCUE_PARTY_RESET_REPORTED:
-    return "RESCUE_PARTY_RESET_REPORTED";
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  case ::perfetto::protos::pbzero::AtomId::SIGNED_CONFIG_REPORTED:
-    return "SIGNED_CONFIG_REPORTED";
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-  case ::perfetto::protos::pbzero::AtomId::GNSS_NI_EVENT_REPORTED:
-    return "GNSS_NI_EVENT_REPORTED";
+class PERFETTO_EXPORT_COMPONENT StatsdPullAtomConfig : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kPullAtomIdFieldNumber = 1,
+    kRawPullAtomIdFieldNumber = 2,
+    kPullFrequencyMsFieldNumber = 3,
+    kPackagesFieldNumber = 4,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_LINK_LAYER_CONNECTION_EVENT:
-    return "BLUETOOTH_LINK_LAYER_CONNECTION_EVENT";
+  StatsdPullAtomConfig();
+  ~StatsdPullAtomConfig() override;
+  StatsdPullAtomConfig(StatsdPullAtomConfig&&) noexcept;
+  StatsdPullAtomConfig& operator=(StatsdPullAtomConfig&&);
+  StatsdPullAtomConfig(const StatsdPullAtomConfig&);
+  StatsdPullAtomConfig& operator=(const StatsdPullAtomConfig&);
+  bool operator==(const StatsdPullAtomConfig&) const;
+  bool operator!=(const StatsdPullAtomConfig& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_ACL_CONNECTION_STATE_CHANGED:
-    return "BLUETOOTH_ACL_CONNECTION_STATE_CHANGED";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_SCO_CONNECTION_STATE_CHANGED:
-    return "BLUETOOTH_SCO_CONNECTION_STATE_CHANGED";
+  const std::vector<AtomId>& pull_atom_id() const { return pull_atom_id_; }
+  std::vector<AtomId>* mutable_pull_atom_id() { return &pull_atom_id_; }
+  int pull_atom_id_size() const { return static_cast<int>(pull_atom_id_.size()); }
+  void clear_pull_atom_id() { pull_atom_id_.clear(); }
+  void add_pull_atom_id(AtomId value) { pull_atom_id_.emplace_back(value); }
+  AtomId* add_pull_atom_id() { pull_atom_id_.emplace_back(); return &pull_atom_id_.back(); }
 
-  case ::perfetto::protos::pbzero::AtomId::APP_DOWNGRADED:
-    return "APP_DOWNGRADED";
+  const std::vector<int32_t>& raw_pull_atom_id() const { return raw_pull_atom_id_; }
+  std::vector<int32_t>* mutable_raw_pull_atom_id() { return &raw_pull_atom_id_; }
+  int raw_pull_atom_id_size() const { return static_cast<int>(raw_pull_atom_id_.size()); }
+  void clear_raw_pull_atom_id() { raw_pull_atom_id_.clear(); }
+  void add_raw_pull_atom_id(int32_t value) { raw_pull_atom_id_.emplace_back(value); }
+  int32_t* add_raw_pull_atom_id() { raw_pull_atom_id_.emplace_back(); return &raw_pull_atom_id_.back(); }
 
-  case ::perfetto::protos::pbzero::AtomId::APP_OPTIMIZED_AFTER_DOWNGRADED:
-    return "APP_OPTIMIZED_AFTER_DOWNGRADED";
+  bool has_pull_frequency_ms() const { return _has_field_[3]; }
+  int32_t pull_frequency_ms() const { return pull_frequency_ms_; }
+  void set_pull_frequency_ms(int32_t value) { pull_frequency_ms_ = value; _has_field_.set(3); }
 
-  case ::perfetto::protos::pbzero::AtomId::LOW_STORAGE_STATE_CHANGED:
-    return "LOW_STORAGE_STATE_CHANGED";
+  const std::vector<std::string>& packages() const { return packages_; }
+  std::vector<std::string>* mutable_packages() { return &packages_; }
+  int packages_size() const { return static_cast<int>(packages_.size()); }
+  void clear_packages() { packages_.clear(); }
+  void add_packages(std::string value) { packages_.emplace_back(value); }
+  std::string* add_packages() { packages_.emplace_back(); return &packages_.back(); }
 
-  case ::perfetto::protos::pbzero::AtomId::GNSS_NFW_NOTIFICATION_REPORTED:
-    return "GNSS_NFW_NOTIFICATION_REPORTED";
+ private:
+  std::vector<AtomId> pull_atom_id_;
+  std::vector<int32_t> raw_pull_atom_id_;
+  int32_t pull_frequency_ms_{};
+  std::vector<std::string> packages_;
 
-  case ::perfetto::protos::pbzero::AtomId::GNSS_CONFIGURATION_REPORTED:
-    return "GNSS_CONFIGURATION_REPORTED";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::USB_PORT_OVERHEAT_EVENT_REPORTED:
-    return "USB_PORT_OVERHEAT_EVENT_REPORTED";
+  std::bitset<5> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::NFC_ERROR_OCCURRED:
-    return "NFC_ERROR_OCCURRED";
 
-  case ::perfetto::protos::pbzero::AtomId::NFC_STATE_CHANGED:
-    return "NFC_STATE_CHANGED";
+class PERFETTO_EXPORT_COMPONENT StatsdTracingConfig : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kPushAtomIdFieldNumber = 1,
+    kRawPushAtomIdFieldNumber = 2,
+    kPullConfigFieldNumber = 3,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::NFC_BEAM_OCCURRED:
-    return "NFC_BEAM_OCCURRED";
+  StatsdTracingConfig();
+  ~StatsdTracingConfig() override;
+  StatsdTracingConfig(StatsdTracingConfig&&) noexcept;
+  StatsdTracingConfig& operator=(StatsdTracingConfig&&);
+  StatsdTracingConfig(const StatsdTracingConfig&);
+  StatsdTracingConfig& operator=(const StatsdTracingConfig&);
+  bool operator==(const StatsdTracingConfig&) const;
+  bool operator!=(const StatsdTracingConfig& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::NFC_CARDEMULATION_OCCURRED:
-    return "NFC_CARDEMULATION_OCCURRED";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::NFC_TAG_OCCURRED:
-    return "NFC_TAG_OCCURRED";
+  const std::vector<AtomId>& push_atom_id() const { return push_atom_id_; }
+  std::vector<AtomId>* mutable_push_atom_id() { return &push_atom_id_; }
+  int push_atom_id_size() const { return static_cast<int>(push_atom_id_.size()); }
+  void clear_push_atom_id() { push_atom_id_.clear(); }
+  void add_push_atom_id(AtomId value) { push_atom_id_.emplace_back(value); }
+  AtomId* add_push_atom_id() { push_atom_id_.emplace_back(); return &push_atom_id_.back(); }
 
-  case ::perfetto::protos::pbzero::AtomId::NFC_HCE_TRANSACTION_OCCURRED:
-    return "NFC_HCE_TRANSACTION_OCCURRED";
+  const std::vector<int32_t>& raw_push_atom_id() const { return raw_push_atom_id_; }
+  std::vector<int32_t>* mutable_raw_push_atom_id() { return &raw_push_atom_id_; }
+  int raw_push_atom_id_size() const { return static_cast<int>(raw_push_atom_id_.size()); }
+  void clear_raw_push_atom_id() { raw_push_atom_id_.clear(); }
+  void add_raw_push_atom_id(int32_t value) { raw_push_atom_id_.emplace_back(value); }
+  int32_t* add_raw_push_atom_id() { raw_push_atom_id_.emplace_back(); return &raw_push_atom_id_.back(); }
 
-  case ::perfetto::protos::pbzero::AtomId::SE_STATE_CHANGED:
-    return "SE_STATE_CHANGED";
+  const std::vector<StatsdPullAtomConfig>& pull_config() const { return pull_config_; }
+  std::vector<StatsdPullAtomConfig>* mutable_pull_config() { return &pull_config_; }
+  int pull_config_size() const;
+  void clear_pull_config();
+  StatsdPullAtomConfig* add_pull_config();
 
-  case ::perfetto::protos::pbzero::AtomId::SE_OMAPI_REPORTED:
-    return "SE_OMAPI_REPORTED";
+ private:
+  std::vector<AtomId> push_atom_id_;
+  std::vector<int32_t> raw_push_atom_id_;
+  std::vector<StatsdPullAtomConfig> pull_config_;
 
-  case ::perfetto::protos::pbzero::AtomId::BROADCAST_DISPATCH_LATENCY_REPORTED:
-    return "BROADCAST_DISPATCH_LATENCY_REPORTED";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::ATTENTION_MANAGER_SERVICE_RESULT_REPORTED:
-    return "ATTENTION_MANAGER_SERVICE_RESULT_REPORTED";
+  std::bitset<4> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::ADB_CONNECTION_CHANGED:
-    return "ADB_CONNECTION_CHANGED";
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::SPEECH_DSP_STAT_REPORTED:
-    return "SPEECH_DSP_STAT_REPORTED";
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_STATSD_TRACING_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/sys_stats/sys_stats_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYS_STATS_SYS_STATS_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYS_STATS_SYS_STATS_CONFIG_PROTO_CPP_H_
 
-  case ::perfetto::protos::pbzero::AtomId::USB_CONTAMINANT_REPORTED:
-    return "USB_CONTAMINANT_REPORTED";
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  case ::perfetto::protos::pbzero::AtomId::WATCHDOG_ROLLBACK_OCCURRED:
-    return "WATCHDOG_ROLLBACK_OCCURRED";
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  case ::perfetto::protos::pbzero::AtomId::BIOMETRIC_SYSTEM_HEALTH_ISSUE_DETECTED:
-    return "BIOMETRIC_SYSTEM_HEALTH_ISSUE_DETECTED";
+namespace perfetto {
+namespace protos {
+namespace gen {
+class SysStatsConfig;
+enum SysStatsConfig_StatCounters : int;
+enum MeminfoCounters : int;
+enum VmstatCounters : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::BUBBLE_UI_CHANGED:
-    return "BUBBLE_UI_CHANGED";
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  case ::perfetto::protos::pbzero::AtomId::SCHEDULED_JOB_CONSTRAINT_CHANGED:
-    return "SCHEDULED_JOB_CONSTRAINT_CHANGED";
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum SysStatsConfig_StatCounters : int {
+  SysStatsConfig_StatCounters_STAT_UNSPECIFIED = 0,
+  SysStatsConfig_StatCounters_STAT_CPU_TIMES = 1,
+  SysStatsConfig_StatCounters_STAT_IRQ_COUNTS = 2,
+  SysStatsConfig_StatCounters_STAT_SOFTIRQ_COUNTS = 3,
+  SysStatsConfig_StatCounters_STAT_FORK_COUNT = 4,
+};
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_ACTIVE_DEVICE_CHANGED:
-    return "BLUETOOTH_ACTIVE_DEVICE_CHANGED";
+class PERFETTO_EXPORT_COMPONENT SysStatsConfig : public ::protozero::CppMessageObj {
+ public:
+  using StatCounters = SysStatsConfig_StatCounters;
+  static constexpr auto STAT_UNSPECIFIED = SysStatsConfig_StatCounters_STAT_UNSPECIFIED;
+  static constexpr auto STAT_CPU_TIMES = SysStatsConfig_StatCounters_STAT_CPU_TIMES;
+  static constexpr auto STAT_IRQ_COUNTS = SysStatsConfig_StatCounters_STAT_IRQ_COUNTS;
+  static constexpr auto STAT_SOFTIRQ_COUNTS = SysStatsConfig_StatCounters_STAT_SOFTIRQ_COUNTS;
+  static constexpr auto STAT_FORK_COUNT = SysStatsConfig_StatCounters_STAT_FORK_COUNT;
+  static constexpr auto StatCounters_MIN = SysStatsConfig_StatCounters_STAT_UNSPECIFIED;
+  static constexpr auto StatCounters_MAX = SysStatsConfig_StatCounters_STAT_FORK_COUNT;
+  enum FieldNumbers {
+    kMeminfoPeriodMsFieldNumber = 1,
+    kMeminfoCountersFieldNumber = 2,
+    kVmstatPeriodMsFieldNumber = 3,
+    kVmstatCountersFieldNumber = 4,
+    kStatPeriodMsFieldNumber = 5,
+    kStatCountersFieldNumber = 6,
+    kDevfreqPeriodMsFieldNumber = 7,
+    kCpufreqPeriodMsFieldNumber = 8,
+    kBuddyinfoPeriodMsFieldNumber = 9,
+    kDiskstatPeriodMsFieldNumber = 10,
+    kPsiPeriodMsFieldNumber = 11,
+    kThermalPeriodMsFieldNumber = 12,
+    kCpuidlePeriodMsFieldNumber = 13,
+    kGpufreqPeriodMsFieldNumber = 14,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_A2DP_PLAYBACK_STATE_CHANGED:
-    return "BLUETOOTH_A2DP_PLAYBACK_STATE_CHANGED";
+  SysStatsConfig();
+  ~SysStatsConfig() override;
+  SysStatsConfig(SysStatsConfig&&) noexcept;
+  SysStatsConfig& operator=(SysStatsConfig&&);
+  SysStatsConfig(const SysStatsConfig&);
+  SysStatsConfig& operator=(const SysStatsConfig&);
+  bool operator==(const SysStatsConfig&) const;
+  bool operator!=(const SysStatsConfig& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_A2DP_CODEC_CONFIG_CHANGED:
-    return "BLUETOOTH_A2DP_CODEC_CONFIG_CHANGED";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_A2DP_CODEC_CAPABILITY_CHANGED:
-    return "BLUETOOTH_A2DP_CODEC_CAPABILITY_CHANGED";
+  bool has_meminfo_period_ms() const { return _has_field_[1]; }
+  uint32_t meminfo_period_ms() const { return meminfo_period_ms_; }
+  void set_meminfo_period_ms(uint32_t value) { meminfo_period_ms_ = value; _has_field_.set(1); }
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_A2DP_AUDIO_UNDERRUN_REPORTED:
-    return "BLUETOOTH_A2DP_AUDIO_UNDERRUN_REPORTED";
+  const std::vector<MeminfoCounters>& meminfo_counters() const { return meminfo_counters_; }
+  std::vector<MeminfoCounters>* mutable_meminfo_counters() { return &meminfo_counters_; }
+  int meminfo_counters_size() const { return static_cast<int>(meminfo_counters_.size()); }
+  void clear_meminfo_counters() { meminfo_counters_.clear(); }
+  void add_meminfo_counters(MeminfoCounters value) { meminfo_counters_.emplace_back(value); }
+  MeminfoCounters* add_meminfo_counters() { meminfo_counters_.emplace_back(); return &meminfo_counters_.back(); }
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_A2DP_AUDIO_OVERRUN_REPORTED:
-    return "BLUETOOTH_A2DP_AUDIO_OVERRUN_REPORTED";
+  bool has_vmstat_period_ms() const { return _has_field_[3]; }
+  uint32_t vmstat_period_ms() const { return vmstat_period_ms_; }
+  void set_vmstat_period_ms(uint32_t value) { vmstat_period_ms_ = value; _has_field_.set(3); }
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_DEVICE_RSSI_REPORTED:
-    return "BLUETOOTH_DEVICE_RSSI_REPORTED";
+  const std::vector<VmstatCounters>& vmstat_counters() const { return vmstat_counters_; }
+  std::vector<VmstatCounters>* mutable_vmstat_counters() { return &vmstat_counters_; }
+  int vmstat_counters_size() const { return static_cast<int>(vmstat_counters_.size()); }
+  void clear_vmstat_counters() { vmstat_counters_.clear(); }
+  void add_vmstat_counters(VmstatCounters value) { vmstat_counters_.emplace_back(value); }
+  VmstatCounters* add_vmstat_counters() { vmstat_counters_.emplace_back(); return &vmstat_counters_.back(); }
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_DEVICE_FAILED_CONTACT_COUNTER_REPORTED:
-    return "BLUETOOTH_DEVICE_FAILED_CONTACT_COUNTER_REPORTED";
+  bool has_stat_period_ms() const { return _has_field_[5]; }
+  uint32_t stat_period_ms() const { return stat_period_ms_; }
+  void set_stat_period_ms(uint32_t value) { stat_period_ms_ = value; _has_field_.set(5); }
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_DEVICE_TX_POWER_LEVEL_REPORTED:
-    return "BLUETOOTH_DEVICE_TX_POWER_LEVEL_REPORTED";
+  const std::vector<SysStatsConfig_StatCounters>& stat_counters() const { return stat_counters_; }
+  std::vector<SysStatsConfig_StatCounters>* mutable_stat_counters() { return &stat_counters_; }
+  int stat_counters_size() const { return static_cast<int>(stat_counters_.size()); }
+  void clear_stat_counters() { stat_counters_.clear(); }
+  void add_stat_counters(SysStatsConfig_StatCounters value) { stat_counters_.emplace_back(value); }
+  SysStatsConfig_StatCounters* add_stat_counters() { stat_counters_.emplace_back(); return &stat_counters_.back(); }
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_HCI_TIMEOUT_REPORTED:
-    return "BLUETOOTH_HCI_TIMEOUT_REPORTED";
+  bool has_devfreq_period_ms() const { return _has_field_[7]; }
+  uint32_t devfreq_period_ms() const { return devfreq_period_ms_; }
+  void set_devfreq_period_ms(uint32_t value) { devfreq_period_ms_ = value; _has_field_.set(7); }
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_QUALITY_REPORT_REPORTED:
-    return "BLUETOOTH_QUALITY_REPORT_REPORTED";
+  bool has_cpufreq_period_ms() const { return _has_field_[8]; }
+  uint32_t cpufreq_period_ms() const { return cpufreq_period_ms_; }
+  void set_cpufreq_period_ms(uint32_t value) { cpufreq_period_ms_ = value; _has_field_.set(8); }
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_DEVICE_INFO_REPORTED:
-    return "BLUETOOTH_DEVICE_INFO_REPORTED";
+  bool has_buddyinfo_period_ms() const { return _has_field_[9]; }
+  uint32_t buddyinfo_period_ms() const { return buddyinfo_period_ms_; }
+  void set_buddyinfo_period_ms(uint32_t value) { buddyinfo_period_ms_ = value; _has_field_.set(9); }
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_REMOTE_VERSION_INFO_REPORTED:
-    return "BLUETOOTH_REMOTE_VERSION_INFO_REPORTED";
+  bool has_diskstat_period_ms() const { return _has_field_[10]; }
+  uint32_t diskstat_period_ms() const { return diskstat_period_ms_; }
+  void set_diskstat_period_ms(uint32_t value) { diskstat_period_ms_ = value; _has_field_.set(10); }
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_SDP_ATTRIBUTE_REPORTED:
-    return "BLUETOOTH_SDP_ATTRIBUTE_REPORTED";
+  bool has_psi_period_ms() const { return _has_field_[11]; }
+  uint32_t psi_period_ms() const { return psi_period_ms_; }
+  void set_psi_period_ms(uint32_t value) { psi_period_ms_ = value; _has_field_.set(11); }
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_BOND_STATE_CHANGED:
-    return "BLUETOOTH_BOND_STATE_CHANGED";
+  bool has_thermal_period_ms() const { return _has_field_[12]; }
+  uint32_t thermal_period_ms() const { return thermal_period_ms_; }
+  void set_thermal_period_ms(uint32_t value) { thermal_period_ms_ = value; _has_field_.set(12); }
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_CLASSIC_PAIRING_EVENT_REPORTED:
-    return "BLUETOOTH_CLASSIC_PAIRING_EVENT_REPORTED";
+  bool has_cpuidle_period_ms() const { return _has_field_[13]; }
+  uint32_t cpuidle_period_ms() const { return cpuidle_period_ms_; }
+  void set_cpuidle_period_ms(uint32_t value) { cpuidle_period_ms_ = value; _has_field_.set(13); }
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_SMP_PAIRING_EVENT_REPORTED:
-    return "BLUETOOTH_SMP_PAIRING_EVENT_REPORTED";
+  bool has_gpufreq_period_ms() const { return _has_field_[14]; }
+  uint32_t gpufreq_period_ms() const { return gpufreq_period_ms_; }
+  void set_gpufreq_period_ms(uint32_t value) { gpufreq_period_ms_ = value; _has_field_.set(14); }
 
-  case ::perfetto::protos::pbzero::AtomId::SCREEN_TIMEOUT_EXTENSION_REPORTED:
-    return "SCREEN_TIMEOUT_EXTENSION_REPORTED";
+ private:
+  uint32_t meminfo_period_ms_{};
+  std::vector<MeminfoCounters> meminfo_counters_;
+  uint32_t vmstat_period_ms_{};
+  std::vector<VmstatCounters> vmstat_counters_;
+  uint32_t stat_period_ms_{};
+  std::vector<SysStatsConfig_StatCounters> stat_counters_;
+  uint32_t devfreq_period_ms_{};
+  uint32_t cpufreq_period_ms_{};
+  uint32_t buddyinfo_period_ms_{};
+  uint32_t diskstat_period_ms_{};
+  uint32_t psi_period_ms_{};
+  uint32_t thermal_period_ms_{};
+  uint32_t cpuidle_period_ms_{};
+  uint32_t gpufreq_period_ms_{};
 
-  case ::perfetto::protos::pbzero::AtomId::PROCESS_START_TIME:
-    return "PROCESS_START_TIME";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::PERMISSION_GRANT_REQUEST_RESULT_REPORTED:
-    return "PERMISSION_GRANT_REQUEST_RESULT_REPORTED";
+  std::bitset<15> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_SOCKET_CONNECTION_STATE_CHANGED:
-    return "BLUETOOTH_SOCKET_CONNECTION_STATE_CHANGED";
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::DEVICE_IDENTIFIER_ACCESS_DENIED:
-    return "DEVICE_IDENTIFIER_ACCESS_DENIED";
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYS_STATS_SYS_STATS_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/system_info/system_info_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYSTEM_INFO_SYSTEM_INFO_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYSTEM_INFO_SYSTEM_INFO_CONFIG_PROTO_CPP_H_
 
-  case ::perfetto::protos::pbzero::AtomId::BUBBLE_DEVELOPER_ERROR_REPORTED:
-    return "BUBBLE_DEVELOPER_ERROR_REPORTED";
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  case ::perfetto::protos::pbzero::AtomId::ASSIST_GESTURE_STAGE_REPORTED:
-    return "ASSIST_GESTURE_STAGE_REPORTED";
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  case ::perfetto::protos::pbzero::AtomId::ASSIST_GESTURE_FEEDBACK_REPORTED:
-    return "ASSIST_GESTURE_FEEDBACK_REPORTED";
+namespace perfetto {
+namespace protos {
+namespace gen {
+class SystemInfoConfig;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::ASSIST_GESTURE_PROGRESS_REPORTED:
-    return "ASSIST_GESTURE_PROGRESS_REPORTED";
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  case ::perfetto::protos::pbzero::AtomId::TOUCH_GESTURE_CLASSIFIED:
-    return "TOUCH_GESTURE_CLASSIFIED";
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-  case ::perfetto::protos::pbzero::AtomId::HIDDEN_API_USED:
-    return "HIDDEN_API_USED";
+class PERFETTO_EXPORT_COMPONENT SystemInfoConfig : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::STYLE_UI_CHANGED:
-    return "STYLE_UI_CHANGED";
+  SystemInfoConfig();
+  ~SystemInfoConfig() override;
+  SystemInfoConfig(SystemInfoConfig&&) noexcept;
+  SystemInfoConfig& operator=(SystemInfoConfig&&);
+  SystemInfoConfig(const SystemInfoConfig&);
+  SystemInfoConfig& operator=(const SystemInfoConfig&);
+  bool operator==(const SystemInfoConfig&) const;
+  bool operator!=(const SystemInfoConfig& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::PRIVACY_INDICATORS_INTERACTED:
-    return "PRIVACY_INDICATORS_INTERACTED";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::APP_INSTALL_ON_EXTERNAL_STORAGE_REPORTED:
-    return "APP_INSTALL_ON_EXTERNAL_STORAGE_REPORTED";
+ private:
 
-  case ::perfetto::protos::pbzero::AtomId::NETWORK_STACK_REPORTED:
-    return "NETWORK_STACK_REPORTED";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::APP_MOVED_STORAGE_REPORTED:
-    return "APP_MOVED_STORAGE_REPORTED";
+  std::bitset<2> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::BIOMETRIC_ENROLLED:
-    return "BIOMETRIC_ENROLLED";
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::SYSTEM_SERVER_WATCHDOG_OCCURRED:
-    return "SYSTEM_SERVER_WATCHDOG_OCCURRED";
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYSTEM_INFO_SYSTEM_INFO_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/chrome/chrome_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_CHROME_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_CHROME_CONFIG_PROTO_CPP_H_
 
-  case ::perfetto::protos::pbzero::AtomId::TOMB_STONE_OCCURRED:
-    return "TOMB_STONE_OCCURRED";
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_CLASS_OF_DEVICE_REPORTED:
-    return "BLUETOOTH_CLASS_OF_DEVICE_REPORTED";
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  case ::perfetto::protos::pbzero::AtomId::INTELLIGENCE_EVENT_REPORTED:
-    return "INTELLIGENCE_EVENT_REPORTED";
+namespace perfetto {
+namespace protos {
+namespace gen {
+class ChromeConfig;
+enum ChromeConfig_ClientPriority : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::THERMAL_THROTTLING_SEVERITY_STATE_CHANGED:
-    return "THERMAL_THROTTLING_SEVERITY_STATE_CHANGED";
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  case ::perfetto::protos::pbzero::AtomId::ROLE_REQUEST_RESULT_REPORTED:
-    return "ROLE_REQUEST_RESULT_REPORTED";
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum ChromeConfig_ClientPriority : int {
+  ChromeConfig_ClientPriority_UNKNOWN = 0,
+  ChromeConfig_ClientPriority_BACKGROUND = 1,
+  ChromeConfig_ClientPriority_USER_INITIATED = 2,
+};
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIAMETRICS_AUDIOPOLICY_REPORTED:
-    return "MEDIAMETRICS_AUDIOPOLICY_REPORTED";
+class PERFETTO_EXPORT_COMPONENT ChromeConfig : public ::protozero::CppMessageObj {
+ public:
+  using ClientPriority = ChromeConfig_ClientPriority;
+  static constexpr auto UNKNOWN = ChromeConfig_ClientPriority_UNKNOWN;
+  static constexpr auto BACKGROUND = ChromeConfig_ClientPriority_BACKGROUND;
+  static constexpr auto USER_INITIATED = ChromeConfig_ClientPriority_USER_INITIATED;
+  static constexpr auto ClientPriority_MIN = ChromeConfig_ClientPriority_UNKNOWN;
+  static constexpr auto ClientPriority_MAX = ChromeConfig_ClientPriority_USER_INITIATED;
+  enum FieldNumbers {
+    kTraceConfigFieldNumber = 1,
+    kPrivacyFilteringEnabledFieldNumber = 2,
+    kConvertToLegacyJsonFieldNumber = 3,
+    kClientPriorityFieldNumber = 4,
+    kJsonAgentLabelFilterFieldNumber = 5,
+    kEventPackageNameFilterEnabledFieldNumber = 6,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIAMETRICS_AUDIORECORD_REPORTED:
-    return "MEDIAMETRICS_AUDIORECORD_REPORTED";
+  ChromeConfig();
+  ~ChromeConfig() override;
+  ChromeConfig(ChromeConfig&&) noexcept;
+  ChromeConfig& operator=(ChromeConfig&&);
+  ChromeConfig(const ChromeConfig&);
+  ChromeConfig& operator=(const ChromeConfig&);
+  bool operator==(const ChromeConfig&) const;
+  bool operator!=(const ChromeConfig& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIAMETRICS_AUDIOTHREAD_REPORTED:
-    return "MEDIAMETRICS_AUDIOTHREAD_REPORTED";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIAMETRICS_AUDIOTRACK_REPORTED:
-    return "MEDIAMETRICS_AUDIOTRACK_REPORTED";
+  bool has_trace_config() const { return _has_field_[1]; }
+  const std::string& trace_config() const { return trace_config_; }
+  void set_trace_config(const std::string& value) { trace_config_ = value; _has_field_.set(1); }
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIAMETRICS_CODEC_REPORTED:
-    return "MEDIAMETRICS_CODEC_REPORTED";
+  bool has_privacy_filtering_enabled() const { return _has_field_[2]; }
+  bool privacy_filtering_enabled() const { return privacy_filtering_enabled_; }
+  void set_privacy_filtering_enabled(bool value) { privacy_filtering_enabled_ = value; _has_field_.set(2); }
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIAMETRICS_DRM_WIDEVINE_REPORTED:
-    return "MEDIAMETRICS_DRM_WIDEVINE_REPORTED";
+  bool has_convert_to_legacy_json() const { return _has_field_[3]; }
+  bool convert_to_legacy_json() const { return convert_to_legacy_json_; }
+  void set_convert_to_legacy_json(bool value) { convert_to_legacy_json_ = value; _has_field_.set(3); }
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIAMETRICS_EXTRACTOR_REPORTED:
-    return "MEDIAMETRICS_EXTRACTOR_REPORTED";
+  bool has_client_priority() const { return _has_field_[4]; }
+  ChromeConfig_ClientPriority client_priority() const { return client_priority_; }
+  void set_client_priority(ChromeConfig_ClientPriority value) { client_priority_ = value; _has_field_.set(4); }
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIAMETRICS_MEDIADRM_REPORTED:
-    return "MEDIAMETRICS_MEDIADRM_REPORTED";
+  bool has_json_agent_label_filter() const { return _has_field_[5]; }
+  const std::string& json_agent_label_filter() const { return json_agent_label_filter_; }
+  void set_json_agent_label_filter(const std::string& value) { json_agent_label_filter_ = value; _has_field_.set(5); }
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIAMETRICS_NUPLAYER_REPORTED:
-    return "MEDIAMETRICS_NUPLAYER_REPORTED";
+  bool has_event_package_name_filter_enabled() const { return _has_field_[6]; }
+  bool event_package_name_filter_enabled() const { return event_package_name_filter_enabled_; }
+  void set_event_package_name_filter_enabled(bool value) { event_package_name_filter_enabled_ = value; _has_field_.set(6); }
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIAMETRICS_RECORDER_REPORTED:
-    return "MEDIAMETRICS_RECORDER_REPORTED";
+ private:
+  std::string trace_config_{};
+  bool privacy_filtering_enabled_{};
+  bool convert_to_legacy_json_{};
+  ChromeConfig_ClientPriority client_priority_{};
+  std::string json_agent_label_filter_{};
+  bool event_package_name_filter_enabled_{};
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIAMETRICS_DRMMANAGER_REPORTED:
-    return "MEDIAMETRICS_DRMMANAGER_REPORTED";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::CAR_POWER_STATE_CHANGED:
-    return "CAR_POWER_STATE_CHANGED";
+  std::bitset<7> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::GARAGE_MODE_INFO:
-    return "GARAGE_MODE_INFO";
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::TEST_ATOM_REPORTED:
-    return "TEST_ATOM_REPORTED";
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_CHROME_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/chrome/histogram_samples.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_HISTOGRAM_SAMPLES_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_HISTOGRAM_SAMPLES_PROTO_CPP_H_
 
-  case ::perfetto::protos::pbzero::AtomId::CONTENT_CAPTURE_CALLER_MISMATCH_REPORTED:
-    return "CONTENT_CAPTURE_CALLER_MISMATCH_REPORTED";
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  case ::perfetto::protos::pbzero::AtomId::CONTENT_CAPTURE_SERVICE_EVENTS:
-    return "CONTENT_CAPTURE_SERVICE_EVENTS";
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  case ::perfetto::protos::pbzero::AtomId::CONTENT_CAPTURE_SESSION_EVENTS:
-    return "CONTENT_CAPTURE_SESSION_EVENTS";
+namespace perfetto {
+namespace protos {
+namespace gen {
+class ChromiumHistogramSamplesConfig;
+class ChromiumHistogramSamplesConfig_HistogramSample;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::CONTENT_CAPTURE_FLUSHED:
-    return "CONTENT_CAPTURE_FLUSHED";
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  case ::perfetto::protos::pbzero::AtomId::LOCATION_MANAGER_API_USAGE_REPORTED:
-    return "LOCATION_MANAGER_API_USAGE_REPORTED";
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-  case ::perfetto::protos::pbzero::AtomId::REVIEW_PERMISSIONS_FRAGMENT_RESULT_REPORTED:
-    return "REVIEW_PERMISSIONS_FRAGMENT_RESULT_REPORTED";
+class PERFETTO_EXPORT_COMPONENT ChromiumHistogramSamplesConfig : public ::protozero::CppMessageObj {
+ public:
+  using HistogramSample = ChromiumHistogramSamplesConfig_HistogramSample;
+  enum FieldNumbers {
+    kHistogramsFieldNumber = 1,
+    kFilterHistogramNamesFieldNumber = 2,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::RUNTIME_PERMISSIONS_UPGRADE_RESULT:
-    return "RUNTIME_PERMISSIONS_UPGRADE_RESULT";
+  ChromiumHistogramSamplesConfig();
+  ~ChromiumHistogramSamplesConfig() override;
+  ChromiumHistogramSamplesConfig(ChromiumHistogramSamplesConfig&&) noexcept;
+  ChromiumHistogramSamplesConfig& operator=(ChromiumHistogramSamplesConfig&&);
+  ChromiumHistogramSamplesConfig(const ChromiumHistogramSamplesConfig&);
+  ChromiumHistogramSamplesConfig& operator=(const ChromiumHistogramSamplesConfig&);
+  bool operator==(const ChromiumHistogramSamplesConfig&) const;
+  bool operator!=(const ChromiumHistogramSamplesConfig& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::GRANT_PERMISSIONS_ACTIVITY_BUTTON_ACTIONS:
-    return "GRANT_PERMISSIONS_ACTIVITY_BUTTON_ACTIONS";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::LOCATION_ACCESS_CHECK_NOTIFICATION_ACTION:
-    return "LOCATION_ACCESS_CHECK_NOTIFICATION_ACTION";
+  const std::vector<ChromiumHistogramSamplesConfig_HistogramSample>& histograms() const { return histograms_; }
+  std::vector<ChromiumHistogramSamplesConfig_HistogramSample>* mutable_histograms() { return &histograms_; }
+  int histograms_size() const;
+  void clear_histograms();
+  ChromiumHistogramSamplesConfig_HistogramSample* add_histograms();
 
-  case ::perfetto::protos::pbzero::AtomId::APP_PERMISSION_FRAGMENT_ACTION_REPORTED:
-    return "APP_PERMISSION_FRAGMENT_ACTION_REPORTED";
+  bool has_filter_histogram_names() const { return _has_field_[2]; }
+  bool filter_histogram_names() const { return filter_histogram_names_; }
+  void set_filter_histogram_names(bool value) { filter_histogram_names_ = value; _has_field_.set(2); }
 
-  case ::perfetto::protos::pbzero::AtomId::APP_PERMISSION_FRAGMENT_VIEWED:
-    return "APP_PERMISSION_FRAGMENT_VIEWED";
+ private:
+  std::vector<ChromiumHistogramSamplesConfig_HistogramSample> histograms_;
+  bool filter_histogram_names_{};
 
-  case ::perfetto::protos::pbzero::AtomId::APP_PERMISSIONS_FRAGMENT_VIEWED:
-    return "APP_PERMISSIONS_FRAGMENT_VIEWED";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::PERMISSION_APPS_FRAGMENT_VIEWED:
-    return "PERMISSION_APPS_FRAGMENT_VIEWED";
+  std::bitset<3> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::TEXT_SELECTION_EVENT:
-    return "TEXT_SELECTION_EVENT";
 
-  case ::perfetto::protos::pbzero::AtomId::TEXT_LINKIFY_EVENT:
-    return "TEXT_LINKIFY_EVENT";
+class PERFETTO_EXPORT_COMPONENT ChromiumHistogramSamplesConfig_HistogramSample : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kHistogramNameFieldNumber = 1,
+    kMinValueFieldNumber = 2,
+    kMaxValueFieldNumber = 3,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::CONVERSATION_ACTIONS_EVENT:
-    return "CONVERSATION_ACTIONS_EVENT";
+  ChromiumHistogramSamplesConfig_HistogramSample();
+  ~ChromiumHistogramSamplesConfig_HistogramSample() override;
+  ChromiumHistogramSamplesConfig_HistogramSample(ChromiumHistogramSamplesConfig_HistogramSample&&) noexcept;
+  ChromiumHistogramSamplesConfig_HistogramSample& operator=(ChromiumHistogramSamplesConfig_HistogramSample&&);
+  ChromiumHistogramSamplesConfig_HistogramSample(const ChromiumHistogramSamplesConfig_HistogramSample&);
+  ChromiumHistogramSamplesConfig_HistogramSample& operator=(const ChromiumHistogramSamplesConfig_HistogramSample&);
+  bool operator==(const ChromiumHistogramSamplesConfig_HistogramSample&) const;
+  bool operator!=(const ChromiumHistogramSamplesConfig_HistogramSample& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::LANGUAGE_DETECTION_EVENT:
-    return "LANGUAGE_DETECTION_EVENT";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::EXCLUSION_RECT_STATE_CHANGED:
-    return "EXCLUSION_RECT_STATE_CHANGED";
+  bool has_histogram_name() const { return _has_field_[1]; }
+  const std::string& histogram_name() const { return histogram_name_; }
+  void set_histogram_name(const std::string& value) { histogram_name_ = value; _has_field_.set(1); }
 
-  case ::perfetto::protos::pbzero::AtomId::BACK_GESTURE_REPORTED_REPORTED:
-    return "BACK_GESTURE_REPORTED_REPORTED";
+  bool has_min_value() const { return _has_field_[2]; }
+  int64_t min_value() const { return min_value_; }
+  void set_min_value(int64_t value) { min_value_ = value; _has_field_.set(2); }
 
-  case ::perfetto::protos::pbzero::AtomId::UPDATE_ENGINE_UPDATE_ATTEMPT_REPORTED:
-    return "UPDATE_ENGINE_UPDATE_ATTEMPT_REPORTED";
+  bool has_max_value() const { return _has_field_[3]; }
+  int64_t max_value() const { return max_value_; }
+  void set_max_value(int64_t value) { max_value_ = value; _has_field_.set(3); }
 
-  case ::perfetto::protos::pbzero::AtomId::UPDATE_ENGINE_SUCCESSFUL_UPDATE_REPORTED:
-    return "UPDATE_ENGINE_SUCCESSFUL_UPDATE_REPORTED";
+ private:
+  std::string histogram_name_{};
+  int64_t min_value_{};
+  int64_t max_value_{};
 
-  case ::perfetto::protos::pbzero::AtomId::CAMERA_ACTION_EVENT:
-    return "CAMERA_ACTION_EVENT";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::APP_COMPATIBILITY_CHANGE_REPORTED:
-    return "APP_COMPATIBILITY_CHANGE_REPORTED";
+  std::bitset<4> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::PERFETTO_UPLOADED:
-    return "PERFETTO_UPLOADED";
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::VMS_CLIENT_CONNECTION_STATE_CHANGED:
-    return "VMS_CLIENT_CONNECTION_STATE_CHANGED";
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_HISTOGRAM_SAMPLES_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/chrome/scenario_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_SCENARIO_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_SCENARIO_CONFIG_PROTO_CPP_H_
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIA_PROVIDER_SCAN_OCCURRED:
-    return "MEDIA_PROVIDER_SCAN_OCCURRED";
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIA_CONTENT_DELETED:
-    return "MEDIA_CONTENT_DELETED";
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIA_PROVIDER_PERMISSION_REQUESTED:
-    return "MEDIA_PROVIDER_PERMISSION_REQUESTED";
+namespace perfetto {
+namespace protos {
+namespace gen {
+class TracingTriggerRulesConfig;
+class TriggerRule;
+class TriggerRule_RepeatingInterval;
+class TriggerRule_HistogramTrigger;
+class ChromeFieldTracingConfig;
+class ScenarioConfig;
+class NestedScenarioConfig;
+class TraceConfig;
+class TraceConfig_Note;
+class PriorityBoostConfig;
+class TraceConfig_SessionSemaphore;
+class TraceConfig_CmdTraceStartDelay;
+class TraceConfig_AndroidReportConfig;
+class TraceConfig_TraceFilter;
+class TraceConfig_TraceFilter_StringFilterChain;
+class TraceConfig_TraceFilter_StringFilterRule;
+class TraceConfig_IncidentReportConfig;
+class TraceConfig_IncrementalStateConfig;
+class TraceConfig_TriggerConfig;
+class TraceConfig_TriggerConfig_Trigger;
+class TraceConfig_GuardrailOverrides;
+class TraceConfig_StatsdMetadata;
+class TraceConfig_ProducerConfig;
+class TraceConfig_BuiltinDataSource;
+class TraceConfig_DataSource;
+class DataSourceConfig;
+class TestConfig;
+class TestConfig_DummyFields;
+class InterceptorConfig;
+class ConsoleConfig;
+class ChromeConfig;
+class SystemInfoConfig;
+class ProtoVmConfig;
+class TraceConfig_BufferConfig;
+enum TraceConfig_LockdownModeOperation : int;
+enum TraceConfig_CompressionType : int;
+enum TraceConfig_StatsdLogging : int;
+enum TraceConfig_WriteFlushMode : int;
+enum TraceConfig_FFlushMode : int;
+enum PriorityBoostConfig_BoostPolicy : int;
+enum TraceConfig_TraceFilter_StringFilterPolicy : int;
+enum SemanticType : int;
+enum TraceConfig_TriggerConfig_TriggerMode : int;
+enum BuiltinClock : int;
+enum DataSourceConfig_SessionInitiator : int;
+enum DataSourceConfig_BufferExhaustedPolicy : int;
+enum ConsoleConfig_Output : int;
+enum ChromeConfig_ClientPriority : int;
+enum TraceConfig_BufferConfig_FillPolicy : int;
+enum TraceConfig_BufferConfig_ExperimentalMode : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIA_PROVIDER_SCHEMA_CHANGED:
-    return "MEDIA_PROVIDER_SCHEMA_CHANGED";
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIA_PROVIDER_IDLE_MAINTENANCE_FINISHED:
-    return "MEDIA_PROVIDER_IDLE_MAINTENANCE_FINISHED";
-
-  case ::perfetto::protos::pbzero::AtomId::REBOOT_ESCROW_RECOVERY_REPORTED:
-    return "REBOOT_ESCROW_RECOVERY_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::BOOT_TIME_EVENT_DURATION_REPORTED:
-    return "BOOT_TIME_EVENT_DURATION_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED:
-    return "BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::BOOT_TIME_EVENT_UTC_TIME_REPORTED:
-    return "BOOT_TIME_EVENT_UTC_TIME_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::BOOT_TIME_EVENT_ERROR_CODE_REPORTED:
-    return "BOOT_TIME_EVENT_ERROR_CODE_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::USERSPACE_REBOOT_REPORTED:
-    return "USERSPACE_REBOOT_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::NOTIFICATION_REPORTED:
-    return "NOTIFICATION_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::NOTIFICATION_PANEL_REPORTED:
-    return "NOTIFICATION_PANEL_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::NOTIFICATION_CHANNEL_MODIFIED:
-    return "NOTIFICATION_CHANNEL_MODIFIED";
-
-  case ::perfetto::protos::pbzero::AtomId::INTEGRITY_CHECK_RESULT_REPORTED:
-    return "INTEGRITY_CHECK_RESULT_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::INTEGRITY_RULES_PUSHED:
-    return "INTEGRITY_RULES_PUSHED";
-
-  case ::perfetto::protos::pbzero::AtomId::CB_MESSAGE_REPORTED:
-    return "CB_MESSAGE_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::CB_MESSAGE_ERROR:
-    return "CB_MESSAGE_ERROR";
-
-  case ::perfetto::protos::pbzero::AtomId::WIFI_HEALTH_STAT_REPORTED:
-    return "WIFI_HEALTH_STAT_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::WIFI_FAILURE_STAT_REPORTED:
-    return "WIFI_FAILURE_STAT_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::WIFI_CONNECTION_RESULT_REPORTED:
-    return "WIFI_CONNECTION_RESULT_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::APP_FREEZE_CHANGED:
-    return "APP_FREEZE_CHANGED";
-
-  case ::perfetto::protos::pbzero::AtomId::SNAPSHOT_MERGE_REPORTED:
-    return "SNAPSHOT_MERGE_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::FOREGROUND_SERVICE_APP_OP_SESSION_ENDED:
-    return "FOREGROUND_SERVICE_APP_OP_SESSION_ENDED";
-
-  case ::perfetto::protos::pbzero::AtomId::DISPLAY_JANK_REPORTED:
-    return "DISPLAY_JANK_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::APP_STANDBY_BUCKET_CHANGED:
-    return "APP_STANDBY_BUCKET_CHANGED";
-
-  case ::perfetto::protos::pbzero::AtomId::SHARESHEET_STARTED:
-    return "SHARESHEET_STARTED";
-
-  case ::perfetto::protos::pbzero::AtomId::RANKING_SELECTED:
-    return "RANKING_SELECTED";
-
-  case ::perfetto::protos::pbzero::AtomId::TVSETTINGS_UI_INTERACTED:
-    return "TVSETTINGS_UI_INTERACTED";
-
-  case ::perfetto::protos::pbzero::AtomId::LAUNCHER_SNAPSHOT:
-    return "LAUNCHER_SNAPSHOT";
-
-  case ::perfetto::protos::pbzero::AtomId::PACKAGE_INSTALLER_V2_REPORTED:
-    return "PACKAGE_INSTALLER_V2_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::USER_LIFECYCLE_JOURNEY_REPORTED:
-    return "USER_LIFECYCLE_JOURNEY_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::USER_LIFECYCLE_EVENT_OCCURRED:
-    return "USER_LIFECYCLE_EVENT_OCCURRED";
-
-  case ::perfetto::protos::pbzero::AtomId::ACCESSIBILITY_SHORTCUT_REPORTED:
-    return "ACCESSIBILITY_SHORTCUT_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::ACCESSIBILITY_SERVICE_REPORTED:
-    return "ACCESSIBILITY_SERVICE_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::DOCS_UI_DRAG_AND_DROP_REPORTED:
-    return "DOCS_UI_DRAG_AND_DROP_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::APP_USAGE_EVENT_OCCURRED:
-    return "APP_USAGE_EVENT_OCCURRED";
-
-  case ::perfetto::protos::pbzero::AtomId::AUTO_REVOKE_NOTIFICATION_CLICKED:
-    return "AUTO_REVOKE_NOTIFICATION_CLICKED";
-
-  case ::perfetto::protos::pbzero::AtomId::AUTO_REVOKE_FRAGMENT_APP_VIEWED:
-    return "AUTO_REVOKE_FRAGMENT_APP_VIEWED";
-
-  case ::perfetto::protos::pbzero::AtomId::AUTO_REVOKED_APP_INTERACTION:
-    return "AUTO_REVOKED_APP_INTERACTION";
-
-  case ::perfetto::protos::pbzero::AtomId::APP_PERMISSION_GROUPS_FRAGMENT_AUTO_REVOKE_ACTION:
-    return "APP_PERMISSION_GROUPS_FRAGMENT_AUTO_REVOKE_ACTION";
-
-  case ::perfetto::protos::pbzero::AtomId::EVS_USAGE_STATS_REPORTED:
-    return "EVS_USAGE_STATS_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::AUDIO_POWER_USAGE_DATA_REPORTED:
-    return "AUDIO_POWER_USAGE_DATA_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::TV_TUNER_STATE_CHANGED:
-    return "TV_TUNER_STATE_CHANGED";
-
-  case ::perfetto::protos::pbzero::AtomId::MEDIAOUTPUT_OP_SWITCH_REPORTED:
-    return "MEDIAOUTPUT_OP_SWITCH_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::CB_MESSAGE_FILTERED:
-    return "CB_MESSAGE_FILTERED";
-
-  case ::perfetto::protos::pbzero::AtomId::TV_TUNER_DVR_STATUS:
-    return "TV_TUNER_DVR_STATUS";
-
-  case ::perfetto::protos::pbzero::AtomId::TV_CAS_SESSION_OPEN_STATUS:
-    return "TV_CAS_SESSION_OPEN_STATUS";
-
-  case ::perfetto::protos::pbzero::AtomId::ASSISTANT_INVOCATION_REPORTED:
-    return "ASSISTANT_INVOCATION_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::DISPLAY_WAKE_REPORTED:
-    return "DISPLAY_WAKE_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::CAR_USER_HAL_MODIFY_USER_REQUEST_REPORTED:
-    return "CAR_USER_HAL_MODIFY_USER_REQUEST_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::CAR_USER_HAL_MODIFY_USER_RESPONSE_REPORTED:
-    return "CAR_USER_HAL_MODIFY_USER_RESPONSE_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::CAR_USER_HAL_POST_SWITCH_RESPONSE_REPORTED:
-    return "CAR_USER_HAL_POST_SWITCH_RESPONSE_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::CAR_USER_HAL_INITIAL_USER_INFO_REQUEST_REPORTED:
-    return "CAR_USER_HAL_INITIAL_USER_INFO_REQUEST_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::CAR_USER_HAL_INITIAL_USER_INFO_RESPONSE_REPORTED:
-    return "CAR_USER_HAL_INITIAL_USER_INFO_RESPONSE_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::CAR_USER_HAL_USER_ASSOCIATION_REQUEST_REPORTED:
-    return "CAR_USER_HAL_USER_ASSOCIATION_REQUEST_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::CAR_USER_HAL_SET_USER_ASSOCIATION_RESPONSE_REPORTED:
-    return "CAR_USER_HAL_SET_USER_ASSOCIATION_RESPONSE_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::NETWORK_IP_PROVISIONING_REPORTED:
-    return "NETWORK_IP_PROVISIONING_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::NETWORK_DHCP_RENEW_REPORTED:
-    return "NETWORK_DHCP_RENEW_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::NETWORK_VALIDATION_REPORTED:
-    return "NETWORK_VALIDATION_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::NETWORK_STACK_QUIRK_REPORTED:
-    return "NETWORK_STACK_QUIRK_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::MEDIAMETRICS_AUDIORECORDDEVICEUSAGE_REPORTED:
-    return "MEDIAMETRICS_AUDIORECORDDEVICEUSAGE_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::MEDIAMETRICS_AUDIOTHREADDEVICEUSAGE_REPORTED:
-    return "MEDIAMETRICS_AUDIOTHREADDEVICEUSAGE_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::MEDIAMETRICS_AUDIOTRACKDEVICEUSAGE_REPORTED:
-    return "MEDIAMETRICS_AUDIOTRACKDEVICEUSAGE_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::MEDIAMETRICS_AUDIODEVICECONNECTION_REPORTED:
-    return "MEDIAMETRICS_AUDIODEVICECONNECTION_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::BLOB_COMMITTED:
-    return "BLOB_COMMITTED";
-
-  case ::perfetto::protos::pbzero::AtomId::BLOB_LEASED:
-    return "BLOB_LEASED";
-
-  case ::perfetto::protos::pbzero::AtomId::BLOB_OPENED:
-    return "BLOB_OPENED";
-
-  case ::perfetto::protos::pbzero::AtomId::CONTACTS_PROVIDER_STATUS_REPORTED:
-    return "CONTACTS_PROVIDER_STATUS_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::KEYSTORE_KEY_EVENT_REPORTED:
-    return "KEYSTORE_KEY_EVENT_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::NETWORK_TETHERING_REPORTED:
-    return "NETWORK_TETHERING_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::IME_TOUCH_REPORTED:
-    return "IME_TOUCH_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::UI_INTERACTION_FRAME_INFO_REPORTED:
-    return "UI_INTERACTION_FRAME_INFO_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::UI_ACTION_LATENCY_REPORTED:
-    return "UI_ACTION_LATENCY_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::WIFI_DISCONNECT_REPORTED:
-    return "WIFI_DISCONNECT_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::WIFI_CONNECTION_STATE_CHANGED:
-    return "WIFI_CONNECTION_STATE_CHANGED";
-
-  case ::perfetto::protos::pbzero::AtomId::HDMI_CEC_ACTIVE_SOURCE_CHANGED:
-    return "HDMI_CEC_ACTIVE_SOURCE_CHANGED";
-
-  case ::perfetto::protos::pbzero::AtomId::HDMI_CEC_MESSAGE_REPORTED:
-    return "HDMI_CEC_MESSAGE_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::AIRPLANE_MODE:
-    return "AIRPLANE_MODE";
-
-  case ::perfetto::protos::pbzero::AtomId::MODEM_RESTART:
-    return "MODEM_RESTART";
-
-  case ::perfetto::protos::pbzero::AtomId::CARRIER_ID_MISMATCH_REPORTED:
-    return "CARRIER_ID_MISMATCH_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::CARRIER_ID_TABLE_UPDATED:
-    return "CARRIER_ID_TABLE_UPDATED";
-
-  case ::perfetto::protos::pbzero::AtomId::DATA_STALL_RECOVERY_REPORTED:
-    return "DATA_STALL_RECOVERY_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::MEDIAMETRICS_MEDIAPARSER_REPORTED:
-    return "MEDIAMETRICS_MEDIAPARSER_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::TLS_HANDSHAKE_REPORTED:
-    return "TLS_HANDSHAKE_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::TEXT_CLASSIFIER_API_USAGE_REPORTED:
-    return "TEXT_CLASSIFIER_API_USAGE_REPORTED";
-
-  case ::perfetto::protos::pbzero::AtomId::CAR_WATCHDOG_KILL_STATS_REPORTED:
-    return "CAR_WATCHDOG_KILL_STATS_REPORTED";
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIAMETRICS_PLAYBACK_REPORTED:
-    return "MEDIAMETRICS_PLAYBACK_REPORTED";
+class PERFETTO_EXPORT_COMPONENT TracingTriggerRulesConfig : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kRulesFieldNumber = 1,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIA_NETWORK_INFO_CHANGED:
-    return "MEDIA_NETWORK_INFO_CHANGED";
+  TracingTriggerRulesConfig();
+  ~TracingTriggerRulesConfig() override;
+  TracingTriggerRulesConfig(TracingTriggerRulesConfig&&) noexcept;
+  TracingTriggerRulesConfig& operator=(TracingTriggerRulesConfig&&);
+  TracingTriggerRulesConfig(const TracingTriggerRulesConfig&);
+  TracingTriggerRulesConfig& operator=(const TracingTriggerRulesConfig&);
+  bool operator==(const TracingTriggerRulesConfig&) const;
+  bool operator!=(const TracingTriggerRulesConfig& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIA_PLAYBACK_STATE_CHANGED:
-    return "MEDIA_PLAYBACK_STATE_CHANGED";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIA_PLAYBACK_ERROR_REPORTED:
-    return "MEDIA_PLAYBACK_ERROR_REPORTED";
+  const std::vector<TriggerRule>& rules() const { return rules_; }
+  std::vector<TriggerRule>* mutable_rules() { return &rules_; }
+  int rules_size() const;
+  void clear_rules();
+  TriggerRule* add_rules();
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIA_PLAYBACK_TRACK_CHANGED:
-    return "MEDIA_PLAYBACK_TRACK_CHANGED";
+ private:
+  std::vector<TriggerRule> rules_;
 
-  case ::perfetto::protos::pbzero::AtomId::WIFI_SCAN_REPORTED:
-    return "WIFI_SCAN_REPORTED";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::WIFI_PNO_SCAN_REPORTED:
-    return "WIFI_PNO_SCAN_REPORTED";
+  std::bitset<2> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::TIF_TUNE_CHANGED:
-    return "TIF_TUNE_CHANGED";
 
-  case ::perfetto::protos::pbzero::AtomId::AUTO_ROTATE_REPORTED:
-    return "AUTO_ROTATE_REPORTED";
+class PERFETTO_EXPORT_COMPONENT TriggerRule : public ::protozero::CppMessageObj {
+ public:
+  using HistogramTrigger = TriggerRule_HistogramTrigger;
+  using RepeatingInterval = TriggerRule_RepeatingInterval;
+  enum FieldNumbers {
+    kNameFieldNumber = 1,
+    kTriggerChanceFieldNumber = 2,
+    kDelayMsFieldNumber = 3,
+    kActivationDelayMsFieldNumber = 8,
+    kManualTriggerNameFieldNumber = 4,
+    kHistogramFieldNumber = 5,
+    kRepeatingIntervalFieldNumber = 6,
+  };
+
+  TriggerRule();
+  ~TriggerRule() override;
+  TriggerRule(TriggerRule&&) noexcept;
+  TriggerRule& operator=(TriggerRule&&);
+  TriggerRule(const TriggerRule&);
+  TriggerRule& operator=(const TriggerRule&);
+  bool operator==(const TriggerRule&) const;
+  bool operator!=(const TriggerRule& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::PERFETTO_TRIGGER:
-    return "PERFETTO_TRIGGER";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::TRANSCODING_DATA:
-    return "TRANSCODING_DATA";
+  bool has_name() const { return _has_field_[1]; }
+  const std::string& name() const { return name_; }
+  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
 
-  case ::perfetto::protos::pbzero::AtomId::IMS_SERVICE_ENTITLEMENT_UPDATED:
-    return "IMS_SERVICE_ENTITLEMENT_UPDATED";
+  bool has_trigger_chance() const { return _has_field_[2]; }
+  float trigger_chance() const { return trigger_chance_; }
+  void set_trigger_chance(float value) { trigger_chance_ = value; _has_field_.set(2); }
 
-  case ::perfetto::protos::pbzero::AtomId::ART_DATUM_REPORTED:
-    return "ART_DATUM_REPORTED";
+  bool has_delay_ms() const { return _has_field_[3]; }
+  uint64_t delay_ms() const { return delay_ms_; }
+  void set_delay_ms(uint64_t value) { delay_ms_ = value; _has_field_.set(3); }
 
-  case ::perfetto::protos::pbzero::AtomId::DEVICE_ROTATED:
-    return "DEVICE_ROTATED";
+  bool has_activation_delay_ms() const { return _has_field_[8]; }
+  uint64_t activation_delay_ms() const { return activation_delay_ms_; }
+  void set_activation_delay_ms(uint64_t value) { activation_delay_ms_ = value; _has_field_.set(8); }
 
-  case ::perfetto::protos::pbzero::AtomId::SIM_SPECIFIC_SETTINGS_RESTORED:
-    return "SIM_SPECIFIC_SETTINGS_RESTORED";
+  bool has_manual_trigger_name() const { return _has_field_[4]; }
+  const std::string& manual_trigger_name() const { return manual_trigger_name_; }
+  void set_manual_trigger_name(const std::string& value) { manual_trigger_name_ = value; _has_field_.set(4); }
 
-  case ::perfetto::protos::pbzero::AtomId::PIN_STORAGE_EVENT:
-    return "PIN_STORAGE_EVENT";
+  bool has_histogram() const { return _has_field_[5]; }
+  const TriggerRule_HistogramTrigger& histogram() const { return *histogram_; }
+  TriggerRule_HistogramTrigger* mutable_histogram() { _has_field_.set(5); return histogram_.get(); }
 
-  case ::perfetto::protos::pbzero::AtomId::FACE_DOWN_REPORTED:
-    return "FACE_DOWN_REPORTED";
+  bool has_repeating_interval() const { return _has_field_[6]; }
+  const TriggerRule_RepeatingInterval& repeating_interval() const { return *repeating_interval_; }
+  TriggerRule_RepeatingInterval* mutable_repeating_interval() { _has_field_.set(6); return repeating_interval_.get(); }
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_HAL_CRASH_REASON_REPORTED:
-    return "BLUETOOTH_HAL_CRASH_REASON_REPORTED";
+ private:
+  std::string name_{};
+  float trigger_chance_{};
+  uint64_t delay_ms_{};
+  uint64_t activation_delay_ms_{};
+  std::string manual_trigger_name_{};
+  ::protozero::CopyablePtr<TriggerRule_HistogramTrigger> histogram_;
+  ::protozero::CopyablePtr<TriggerRule_RepeatingInterval> repeating_interval_;
 
-  case ::perfetto::protos::pbzero::AtomId::REBOOT_ESCROW_PREPARATION_REPORTED:
-    return "REBOOT_ESCROW_PREPARATION_REPORTED";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::REBOOT_ESCROW_LSKF_CAPTURE_REPORTED:
-    return "REBOOT_ESCROW_LSKF_CAPTURE_REPORTED";
+  std::bitset<9> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::REBOOT_ESCROW_REBOOT_REPORTED:
-    return "REBOOT_ESCROW_REBOOT_REPORTED";
 
-  case ::perfetto::protos::pbzero::AtomId::BINDER_LATENCY_REPORTED:
-    return "BINDER_LATENCY_REPORTED";
+class PERFETTO_EXPORT_COMPONENT TriggerRule_RepeatingInterval : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kPeriodMsFieldNumber = 1,
+    kRandomizedFieldNumber = 2,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIAMETRICS_AAUDIOSTREAM_REPORTED:
-    return "MEDIAMETRICS_AAUDIOSTREAM_REPORTED";
+  TriggerRule_RepeatingInterval();
+  ~TriggerRule_RepeatingInterval() override;
+  TriggerRule_RepeatingInterval(TriggerRule_RepeatingInterval&&) noexcept;
+  TriggerRule_RepeatingInterval& operator=(TriggerRule_RepeatingInterval&&);
+  TriggerRule_RepeatingInterval(const TriggerRule_RepeatingInterval&);
+  TriggerRule_RepeatingInterval& operator=(const TriggerRule_RepeatingInterval&);
+  bool operator==(const TriggerRule_RepeatingInterval&) const;
+  bool operator!=(const TriggerRule_RepeatingInterval& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIA_TRANSCODING_SESSION_ENDED:
-    return "MEDIA_TRANSCODING_SESSION_ENDED";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::MAGNIFICATION_USAGE_REPORTED:
-    return "MAGNIFICATION_USAGE_REPORTED";
+  bool has_period_ms() const { return _has_field_[1]; }
+  uint64_t period_ms() const { return period_ms_; }
+  void set_period_ms(uint64_t value) { period_ms_ = value; _has_field_.set(1); }
 
-  case ::perfetto::protos::pbzero::AtomId::MAGNIFICATION_MODE_WITH_IME_ON_REPORTED:
-    return "MAGNIFICATION_MODE_WITH_IME_ON_REPORTED";
+  bool has_randomized() const { return _has_field_[2]; }
+  bool randomized() const { return randomized_; }
+  void set_randomized(bool value) { randomized_ = value; _has_field_.set(2); }
 
-  case ::perfetto::protos::pbzero::AtomId::APP_SEARCH_CALL_STATS_REPORTED:
-    return "APP_SEARCH_CALL_STATS_REPORTED";
+ private:
+  uint64_t period_ms_{};
+  bool randomized_{};
 
-  case ::perfetto::protos::pbzero::AtomId::APP_SEARCH_PUT_DOCUMENT_STATS_REPORTED:
-    return "APP_SEARCH_PUT_DOCUMENT_STATS_REPORTED";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::DEVICE_CONTROL_CHANGED:
-    return "DEVICE_CONTROL_CHANGED";
+  std::bitset<3> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::DEVICE_STATE_CHANGED:
-    return "DEVICE_STATE_CHANGED";
 
-  case ::perfetto::protos::pbzero::AtomId::INPUTDEVICE_REGISTERED:
-    return "INPUTDEVICE_REGISTERED";
+class PERFETTO_EXPORT_COMPONENT TriggerRule_HistogramTrigger : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kHistogramNameFieldNumber = 1,
+    kMinValueFieldNumber = 2,
+    kMaxValueFieldNumber = 3,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::SMARTSPACE_CARD_REPORTED:
-    return "SMARTSPACE_CARD_REPORTED";
+  TriggerRule_HistogramTrigger();
+  ~TriggerRule_HistogramTrigger() override;
+  TriggerRule_HistogramTrigger(TriggerRule_HistogramTrigger&&) noexcept;
+  TriggerRule_HistogramTrigger& operator=(TriggerRule_HistogramTrigger&&);
+  TriggerRule_HistogramTrigger(const TriggerRule_HistogramTrigger&);
+  TriggerRule_HistogramTrigger& operator=(const TriggerRule_HistogramTrigger&);
+  bool operator==(const TriggerRule_HistogramTrigger&) const;
+  bool operator!=(const TriggerRule_HistogramTrigger& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::AUTH_PROMPT_AUTHENTICATE_INVOKED:
-    return "AUTH_PROMPT_AUTHENTICATE_INVOKED";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::AUTH_MANAGER_CAN_AUTHENTICATE_INVOKED:
-    return "AUTH_MANAGER_CAN_AUTHENTICATE_INVOKED";
+  bool has_histogram_name() const { return _has_field_[1]; }
+  const std::string& histogram_name() const { return histogram_name_; }
+  void set_histogram_name(const std::string& value) { histogram_name_ = value; _has_field_.set(1); }
 
-  case ::perfetto::protos::pbzero::AtomId::AUTH_ENROLL_ACTION_INVOKED:
-    return "AUTH_ENROLL_ACTION_INVOKED";
+  bool has_min_value() const { return _has_field_[2]; }
+  int64_t min_value() const { return min_value_; }
+  void set_min_value(int64_t value) { min_value_ = value; _has_field_.set(2); }
 
-  case ::perfetto::protos::pbzero::AtomId::AUTH_DEPRECATED_API_USED:
-    return "AUTH_DEPRECATED_API_USED";
+  bool has_max_value() const { return _has_field_[3]; }
+  int64_t max_value() const { return max_value_; }
+  void set_max_value(int64_t value) { max_value_ = value; _has_field_.set(3); }
 
-  case ::perfetto::protos::pbzero::AtomId::UNATTENDED_REBOOT_OCCURRED:
-    return "UNATTENDED_REBOOT_OCCURRED";
+ private:
+  std::string histogram_name_{};
+  int64_t min_value_{};
+  int64_t max_value_{};
 
-  case ::perfetto::protos::pbzero::AtomId::LONG_REBOOT_BLOCKING_REPORTED:
-    return "LONG_REBOOT_BLOCKING_REPORTED";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::LOCATION_TIME_ZONE_PROVIDER_STATE_CHANGED:
-    return "LOCATION_TIME_ZONE_PROVIDER_STATE_CHANGED";
+  std::bitset<4> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::FDTRACK_EVENT_OCCURRED:
-    return "FDTRACK_EVENT_OCCURRED";
 
-  case ::perfetto::protos::pbzero::AtomId::TIMEOUT_AUTO_EXTENDED_REPORTED:
-    return "TIMEOUT_AUTO_EXTENDED_REPORTED";
+class PERFETTO_EXPORT_COMPONENT ChromeFieldTracingConfig : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kScenariosFieldNumber = 1,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::ODREFRESH_REPORTED:
-    return "ODREFRESH_REPORTED";
+  ChromeFieldTracingConfig();
+  ~ChromeFieldTracingConfig() override;
+  ChromeFieldTracingConfig(ChromeFieldTracingConfig&&) noexcept;
+  ChromeFieldTracingConfig& operator=(ChromeFieldTracingConfig&&);
+  ChromeFieldTracingConfig(const ChromeFieldTracingConfig&);
+  ChromeFieldTracingConfig& operator=(const ChromeFieldTracingConfig&);
+  bool operator==(const ChromeFieldTracingConfig&) const;
+  bool operator!=(const ChromeFieldTracingConfig& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::ALARM_BATCH_DELIVERED:
-    return "ALARM_BATCH_DELIVERED";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::ALARM_SCHEDULED:
-    return "ALARM_SCHEDULED";
+  const std::vector<ScenarioConfig>& scenarios() const { return scenarios_; }
+  std::vector<ScenarioConfig>* mutable_scenarios() { return &scenarios_; }
+  int scenarios_size() const;
+  void clear_scenarios();
+  ScenarioConfig* add_scenarios();
 
-  case ::perfetto::protos::pbzero::AtomId::CAR_WATCHDOG_IO_OVERUSE_STATS_REPORTED:
-    return "CAR_WATCHDOG_IO_OVERUSE_STATS_REPORTED";
+ private:
+  std::vector<ScenarioConfig> scenarios_;
 
-  case ::perfetto::protos::pbzero::AtomId::USER_LEVEL_HIBERNATION_STATE_CHANGED:
-    return "USER_LEVEL_HIBERNATION_STATE_CHANGED";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::APP_SEARCH_INITIALIZE_STATS_REPORTED:
-    return "APP_SEARCH_INITIALIZE_STATS_REPORTED";
+  std::bitset<2> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::APP_SEARCH_QUERY_STATS_REPORTED:
-    return "APP_SEARCH_QUERY_STATS_REPORTED";
 
-  case ::perfetto::protos::pbzero::AtomId::APP_PROCESS_DIED:
-    return "APP_PROCESS_DIED";
+class PERFETTO_EXPORT_COMPONENT ScenarioConfig : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kScenarioNameFieldNumber = 1,
+    kScenarioDescriptionFieldNumber = 9,
+    kStartRulesFieldNumber = 2,
+    kStopRulesFieldNumber = 3,
+    kUploadRulesFieldNumber = 4,
+    kSetupRulesFieldNumber = 5,
+    kTraceConfigFieldNumber = 6,
+    kNestedScenariosFieldNumber = 7,
+    kUseSystemBackendFieldNumber = 8,
+  };
+
+  ScenarioConfig();
+  ~ScenarioConfig() override;
+  ScenarioConfig(ScenarioConfig&&) noexcept;
+  ScenarioConfig& operator=(ScenarioConfig&&);
+  ScenarioConfig(const ScenarioConfig&);
+  ScenarioConfig& operator=(const ScenarioConfig&);
+  bool operator==(const ScenarioConfig&) const;
+  bool operator!=(const ScenarioConfig& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::NETWORK_IP_REACHABILITY_MONITOR_REPORTED:
-    return "NETWORK_IP_REACHABILITY_MONITOR_REPORTED";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::SLOW_INPUT_EVENT_REPORTED:
-    return "SLOW_INPUT_EVENT_REPORTED";
+  bool has_scenario_name() const { return _has_field_[1]; }
+  const std::string& scenario_name() const { return scenario_name_; }
+  void set_scenario_name(const std::string& value) { scenario_name_ = value; _has_field_.set(1); }
+
+  bool has_scenario_description() const { return _has_field_[9]; }
+  const std::string& scenario_description() const { return scenario_description_; }
+  void set_scenario_description(const std::string& value) { scenario_description_ = value; _has_field_.set(9); }
+
+  const std::vector<TriggerRule>& start_rules() const { return start_rules_; }
+  std::vector<TriggerRule>* mutable_start_rules() { return &start_rules_; }
+  int start_rules_size() const;
+  void clear_start_rules();
+  TriggerRule* add_start_rules();
+
+  const std::vector<TriggerRule>& stop_rules() const { return stop_rules_; }
+  std::vector<TriggerRule>* mutable_stop_rules() { return &stop_rules_; }
+  int stop_rules_size() const;
+  void clear_stop_rules();
+  TriggerRule* add_stop_rules();
+
+  const std::vector<TriggerRule>& upload_rules() const { return upload_rules_; }
+  std::vector<TriggerRule>* mutable_upload_rules() { return &upload_rules_; }
+  int upload_rules_size() const;
+  void clear_upload_rules();
+  TriggerRule* add_upload_rules();
+
+  const std::vector<TriggerRule>& setup_rules() const { return setup_rules_; }
+  std::vector<TriggerRule>* mutable_setup_rules() { return &setup_rules_; }
+  int setup_rules_size() const;
+  void clear_setup_rules();
+  TriggerRule* add_setup_rules();
+
+  bool has_trace_config() const { return _has_field_[6]; }
+  const TraceConfig& trace_config() const { return *trace_config_; }
+  TraceConfig* mutable_trace_config() { _has_field_.set(6); return trace_config_.get(); }
 
-  case ::perfetto::protos::pbzero::AtomId::ANR_OCCURRED_PROCESSING_STARTED:
-    return "ANR_OCCURRED_PROCESSING_STARTED";
+  const std::vector<NestedScenarioConfig>& nested_scenarios() const { return nested_scenarios_; }
+  std::vector<NestedScenarioConfig>* mutable_nested_scenarios() { return &nested_scenarios_; }
+  int nested_scenarios_size() const;
+  void clear_nested_scenarios();
+  NestedScenarioConfig* add_nested_scenarios();
 
-  case ::perfetto::protos::pbzero::AtomId::APP_SEARCH_REMOVE_STATS_REPORTED:
-    return "APP_SEARCH_REMOVE_STATS_REPORTED";
+  bool has_use_system_backend() const { return _has_field_[8]; }
+  bool use_system_backend() const { return use_system_backend_; }
+  void set_use_system_backend(bool value) { use_system_backend_ = value; _has_field_.set(8); }
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIA_CODEC_REPORTED:
-    return "MEDIA_CODEC_REPORTED";
+ private:
+  std::string scenario_name_{};
+  std::string scenario_description_{};
+  std::vector<TriggerRule> start_rules_;
+  std::vector<TriggerRule> stop_rules_;
+  std::vector<TriggerRule> upload_rules_;
+  std::vector<TriggerRule> setup_rules_;
+  ::protozero::CopyablePtr<TraceConfig> trace_config_;
+  std::vector<NestedScenarioConfig> nested_scenarios_;
+  bool use_system_backend_{};
 
-  case ::perfetto::protos::pbzero::AtomId::PERMISSION_USAGE_FRAGMENT_INTERACTION:
-    return "PERMISSION_USAGE_FRAGMENT_INTERACTION";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::PERMISSION_DETAILS_INTERACTION:
-    return "PERMISSION_DETAILS_INTERACTION";
+  std::bitset<10> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::PRIVACY_SENSOR_TOGGLE_INTERACTION:
-    return "PRIVACY_SENSOR_TOGGLE_INTERACTION";
 
-  case ::perfetto::protos::pbzero::AtomId::PRIVACY_TOGGLE_DIALOG_INTERACTION:
-    return "PRIVACY_TOGGLE_DIALOG_INTERACTION";
+class PERFETTO_EXPORT_COMPONENT NestedScenarioConfig : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kScenarioNameFieldNumber = 1,
+    kStartRulesFieldNumber = 2,
+    kStopRulesFieldNumber = 3,
+    kUploadRulesFieldNumber = 4,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::APP_SEARCH_OPTIMIZE_STATS_REPORTED:
-    return "APP_SEARCH_OPTIMIZE_STATS_REPORTED";
+  NestedScenarioConfig();
+  ~NestedScenarioConfig() override;
+  NestedScenarioConfig(NestedScenarioConfig&&) noexcept;
+  NestedScenarioConfig& operator=(NestedScenarioConfig&&);
+  NestedScenarioConfig(const NestedScenarioConfig&);
+  NestedScenarioConfig& operator=(const NestedScenarioConfig&);
+  bool operator==(const NestedScenarioConfig&) const;
+  bool operator!=(const NestedScenarioConfig& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::APP_COMPAT_STATE_CHANGED:
-    return "APP_COMPAT_STATE_CHANGED";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::SIZE_COMPAT_RESTART_BUTTON_EVENT_REPORTED:
-    return "SIZE_COMPAT_RESTART_BUTTON_EVENT_REPORTED";
+  bool has_scenario_name() const { return _has_field_[1]; }
+  const std::string& scenario_name() const { return scenario_name_; }
+  void set_scenario_name(const std::string& value) { scenario_name_ = value; _has_field_.set(1); }
 
-  case ::perfetto::protos::pbzero::AtomId::SPLITSCREEN_UI_CHANGED:
-    return "SPLITSCREEN_UI_CHANGED";
+  const std::vector<TriggerRule>& start_rules() const { return start_rules_; }
+  std::vector<TriggerRule>* mutable_start_rules() { return &start_rules_; }
+  int start_rules_size() const;
+  void clear_start_rules();
+  TriggerRule* add_start_rules();
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_CODE_PATH_COUNTER:
-    return "BLUETOOTH_CODE_PATH_COUNTER";
+  const std::vector<TriggerRule>& stop_rules() const { return stop_rules_; }
+  std::vector<TriggerRule>* mutable_stop_rules() { return &stop_rules_; }
+  int stop_rules_size() const;
+  void clear_stop_rules();
+  TriggerRule* add_stop_rules();
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_LE_BATCH_SCAN_REPORT_DELAY:
-    return "BLUETOOTH_LE_BATCH_SCAN_REPORT_DELAY";
+  const std::vector<TriggerRule>& upload_rules() const { return upload_rules_; }
+  std::vector<TriggerRule>* mutable_upload_rules() { return &upload_rules_; }
+  int upload_rules_size() const;
+  void clear_upload_rules();
+  TriggerRule* add_upload_rules();
 
-  case ::perfetto::protos::pbzero::AtomId::ACCESSIBILITY_FLOATING_MENU_UI_CHANGED:
-    return "ACCESSIBILITY_FLOATING_MENU_UI_CHANGED";
+ private:
+  std::string scenario_name_{};
+  std::vector<TriggerRule> start_rules_;
+  std::vector<TriggerRule> stop_rules_;
+  std::vector<TriggerRule> upload_rules_;
 
-  case ::perfetto::protos::pbzero::AtomId::NEURALNETWORKS_COMPILATION_COMPLETED:
-    return "NEURALNETWORKS_COMPILATION_COMPLETED";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::NEURALNETWORKS_EXECUTION_COMPLETED:
-    return "NEURALNETWORKS_EXECUTION_COMPLETED";
+  std::bitset<5> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::NEURALNETWORKS_COMPILATION_FAILED:
-    return "NEURALNETWORKS_COMPILATION_FAILED";
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::NEURALNETWORKS_EXECUTION_FAILED:
-    return "NEURALNETWORKS_EXECUTION_FAILED";
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_SCENARIO_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/chrome/system_metrics.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_SYSTEM_METRICS_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_SYSTEM_METRICS_PROTO_CPP_H_
 
-  case ::perfetto::protos::pbzero::AtomId::VM_CREATION_REQUESTED:
-    return "VM_CREATION_REQUESTED";
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  case ::perfetto::protos::pbzero::AtomId::CAMERA_COMPAT_CONTROL_EVENT_REPORTED:
-    return "CAMERA_COMPAT_CONTROL_EVENT_REPORTED";
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  case ::perfetto::protos::pbzero::AtomId::TRACING_SERVICE_REPORT_EVENT:
-    return "TRACING_SERVICE_REPORT_EVENT";
+namespace perfetto {
+namespace protos {
+namespace gen {
+class ChromiumSystemMetricsConfig;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::EARLY_BOOT_COMP_OS_ARTIFACTS_CHECK_REPORTED:
-    return "EARLY_BOOT_COMP_OS_ARTIFACTS_CHECK_REPORTED";
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  case ::perfetto::protos::pbzero::AtomId::ISOLATED_COMPILATION_SCHEDULED:
-    return "ISOLATED_COMPILATION_SCHEDULED";
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-  case ::perfetto::protos::pbzero::AtomId::ISOLATED_COMPILATION_ENDED:
-    return "ISOLATED_COMPILATION_ENDED";
+class PERFETTO_EXPORT_COMPONENT ChromiumSystemMetricsConfig : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kSamplingIntervalMsFieldNumber = 1,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::TELEPHONY_ANOMALY_DETECTED:
-    return "TELEPHONY_ANOMALY_DETECTED";
+  ChromiumSystemMetricsConfig();
+  ~ChromiumSystemMetricsConfig() override;
+  ChromiumSystemMetricsConfig(ChromiumSystemMetricsConfig&&) noexcept;
+  ChromiumSystemMetricsConfig& operator=(ChromiumSystemMetricsConfig&&);
+  ChromiumSystemMetricsConfig(const ChromiumSystemMetricsConfig&);
+  ChromiumSystemMetricsConfig& operator=(const ChromiumSystemMetricsConfig&);
+  bool operator==(const ChromiumSystemMetricsConfig&) const;
+  bool operator!=(const ChromiumSystemMetricsConfig& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::HOTWORD_DETECTOR_CREATE_REQUESTED:
-    return "HOTWORD_DETECTOR_CREATE_REQUESTED";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::HOTWORD_DETECTION_SERVICE_INIT_RESULT_REPORTED:
-    return "HOTWORD_DETECTION_SERVICE_INIT_RESULT_REPORTED";
+  bool has_sampling_interval_ms() const { return _has_field_[1]; }
+  uint32_t sampling_interval_ms() const { return sampling_interval_ms_; }
+  void set_sampling_interval_ms(uint32_t value) { sampling_interval_ms_ = value; _has_field_.set(1); }
 
-  case ::perfetto::protos::pbzero::AtomId::HOTWORD_DETECTION_SERVICE_RESTARTED:
-    return "HOTWORD_DETECTION_SERVICE_RESTARTED";
+ private:
+  uint32_t sampling_interval_ms_{};
 
-  case ::perfetto::protos::pbzero::AtomId::HOTWORD_DETECTOR_KEYPHRASE_TRIGGERED:
-    return "HOTWORD_DETECTOR_KEYPHRASE_TRIGGERED";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::HOTWORD_DETECTOR_EVENTS:
-    return "HOTWORD_DETECTOR_EVENTS";
+  std::bitset<2> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::REMOTE_KEY_PROVISIONING_ATTEMPT:
-    return "REMOTE_KEY_PROVISIONING_ATTEMPT";
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::REMOTE_KEY_PROVISIONING_NETWORK_INFO:
-    return "REMOTE_KEY_PROVISIONING_NETWORK_INFO";
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_SYSTEM_METRICS_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/chrome/v8_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_V8_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_V8_CONFIG_PROTO_CPP_H_
 
-  case ::perfetto::protos::pbzero::AtomId::REMOTE_KEY_PROVISIONING_TIMING:
-    return "REMOTE_KEY_PROVISIONING_TIMING";
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  case ::perfetto::protos::pbzero::AtomId::WIFI_BYTES_TRANSFER:
-    return "WIFI_BYTES_TRANSFER";
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  case ::perfetto::protos::pbzero::AtomId::WIFI_BYTES_TRANSFER_BY_FG_BG:
-    return "WIFI_BYTES_TRANSFER_BY_FG_BG";
+namespace perfetto {
+namespace protos {
+namespace gen {
+class V8Config;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::MOBILE_BYTES_TRANSFER:
-    return "MOBILE_BYTES_TRANSFER";
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  case ::perfetto::protos::pbzero::AtomId::MOBILE_BYTES_TRANSFER_BY_FG_BG:
-    return "MOBILE_BYTES_TRANSFER_BY_FG_BG";
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_BYTES_TRANSFER:
-    return "BLUETOOTH_BYTES_TRANSFER";
+class PERFETTO_EXPORT_COMPONENT V8Config : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kLogScriptSourcesFieldNumber = 1,
+    kLogInstructionsFieldNumber = 2,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::KERNEL_WAKELOCK:
-    return "KERNEL_WAKELOCK";
+  V8Config();
+  ~V8Config() override;
+  V8Config(V8Config&&) noexcept;
+  V8Config& operator=(V8Config&&);
+  V8Config(const V8Config&);
+  V8Config& operator=(const V8Config&);
+  bool operator==(const V8Config&) const;
+  bool operator!=(const V8Config& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::SUBSYSTEM_SLEEP_STATE:
-    return "SUBSYSTEM_SLEEP_STATE";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::CPU_TIME_PER_UID:
-    return "CPU_TIME_PER_UID";
+  bool has_log_script_sources() const { return _has_field_[1]; }
+  bool log_script_sources() const { return log_script_sources_; }
+  void set_log_script_sources(bool value) { log_script_sources_ = value; _has_field_.set(1); }
 
-  case ::perfetto::protos::pbzero::AtomId::CPU_TIME_PER_UID_FREQ:
-    return "CPU_TIME_PER_UID_FREQ";
+  bool has_log_instructions() const { return _has_field_[2]; }
+  bool log_instructions() const { return log_instructions_; }
+  void set_log_instructions(bool value) { log_instructions_ = value; _has_field_.set(2); }
 
-  case ::perfetto::protos::pbzero::AtomId::WIFI_ACTIVITY_INFO:
-    return "WIFI_ACTIVITY_INFO";
+ private:
+  bool log_script_sources_{};
+  bool log_instructions_{};
 
-  case ::perfetto::protos::pbzero::AtomId::MODEM_ACTIVITY_INFO:
-    return "MODEM_ACTIVITY_INFO";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::BLUETOOTH_ACTIVITY_INFO:
-    return "BLUETOOTH_ACTIVITY_INFO";
+  std::bitset<3> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::PROCESS_MEMORY_STATE:
-    return "PROCESS_MEMORY_STATE";
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::SYSTEM_ELAPSED_REALTIME:
-    return "SYSTEM_ELAPSED_REALTIME";
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_V8_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/etw/etw_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ETW_ETW_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ETW_ETW_CONFIG_PROTO_CPP_H_
 
-  case ::perfetto::protos::pbzero::AtomId::SYSTEM_UPTIME:
-    return "SYSTEM_UPTIME";
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  case ::perfetto::protos::pbzero::AtomId::CPU_ACTIVE_TIME:
-    return "CPU_ACTIVE_TIME";
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  case ::perfetto::protos::pbzero::AtomId::CPU_CLUSTER_TIME:
-    return "CPU_CLUSTER_TIME";
+namespace perfetto {
+namespace protos {
+namespace gen {
+class EtwConfig;
+enum EtwConfig_KernelFlag : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::DISK_SPACE:
-    return "DISK_SPACE";
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  case ::perfetto::protos::pbzero::AtomId::REMAINING_BATTERY_CAPACITY:
-    return "REMAINING_BATTERY_CAPACITY";
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum EtwConfig_KernelFlag : int {
+  EtwConfig_KernelFlag_CSWITCH = 0,
+  EtwConfig_KernelFlag_DISPATCHER = 1,
+};
 
-  case ::perfetto::protos::pbzero::AtomId::FULL_BATTERY_CAPACITY:
-    return "FULL_BATTERY_CAPACITY";
+class PERFETTO_EXPORT_COMPONENT EtwConfig : public ::protozero::CppMessageObj {
+ public:
+  using KernelFlag = EtwConfig_KernelFlag;
+  static constexpr auto CSWITCH = EtwConfig_KernelFlag_CSWITCH;
+  static constexpr auto DISPATCHER = EtwConfig_KernelFlag_DISPATCHER;
+  static constexpr auto KernelFlag_MIN = EtwConfig_KernelFlag_CSWITCH;
+  static constexpr auto KernelFlag_MAX = EtwConfig_KernelFlag_DISPATCHER;
+  enum FieldNumbers {
+    kKernelFlagsFieldNumber = 1,
+    kSchedulerProviderEventsFieldNumber = 2,
+    kMemoryProviderEventsFieldNumber = 3,
+    kFileProviderEventsFieldNumber = 4,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::TEMPERATURE:
-    return "TEMPERATURE";
+  EtwConfig();
+  ~EtwConfig() override;
+  EtwConfig(EtwConfig&&) noexcept;
+  EtwConfig& operator=(EtwConfig&&);
+  EtwConfig(const EtwConfig&);
+  EtwConfig& operator=(const EtwConfig&);
+  bool operator==(const EtwConfig&) const;
+  bool operator!=(const EtwConfig& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::BINDER_CALLS:
-    return "BINDER_CALLS";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::BINDER_CALLS_EXCEPTIONS:
-    return "BINDER_CALLS_EXCEPTIONS";
+  const std::vector<EtwConfig_KernelFlag>& kernel_flags() const { return kernel_flags_; }
+  std::vector<EtwConfig_KernelFlag>* mutable_kernel_flags() { return &kernel_flags_; }
+  int kernel_flags_size() const { return static_cast<int>(kernel_flags_.size()); }
+  void clear_kernel_flags() { kernel_flags_.clear(); }
+  void add_kernel_flags(EtwConfig_KernelFlag value) { kernel_flags_.emplace_back(value); }
+  EtwConfig_KernelFlag* add_kernel_flags() { kernel_flags_.emplace_back(); return &kernel_flags_.back(); }
+
+  const std::vector<std::string>& scheduler_provider_events() const { return scheduler_provider_events_; }
+  std::vector<std::string>* mutable_scheduler_provider_events() { return &scheduler_provider_events_; }
+  int scheduler_provider_events_size() const { return static_cast<int>(scheduler_provider_events_.size()); }
+  void clear_scheduler_provider_events() { scheduler_provider_events_.clear(); }
+  void add_scheduler_provider_events(std::string value) { scheduler_provider_events_.emplace_back(value); }
+  std::string* add_scheduler_provider_events() { scheduler_provider_events_.emplace_back(); return &scheduler_provider_events_.back(); }
+
+  const std::vector<std::string>& memory_provider_events() const { return memory_provider_events_; }
+  std::vector<std::string>* mutable_memory_provider_events() { return &memory_provider_events_; }
+  int memory_provider_events_size() const { return static_cast<int>(memory_provider_events_.size()); }
+  void clear_memory_provider_events() { memory_provider_events_.clear(); }
+  void add_memory_provider_events(std::string value) { memory_provider_events_.emplace_back(value); }
+  std::string* add_memory_provider_events() { memory_provider_events_.emplace_back(); return &memory_provider_events_.back(); }
+
+  const std::vector<std::string>& file_provider_events() const { return file_provider_events_; }
+  std::vector<std::string>* mutable_file_provider_events() { return &file_provider_events_; }
+  int file_provider_events_size() const { return static_cast<int>(file_provider_events_.size()); }
+  void clear_file_provider_events() { file_provider_events_.clear(); }
+  void add_file_provider_events(std::string value) { file_provider_events_.emplace_back(value); }
+  std::string* add_file_provider_events() { file_provider_events_.emplace_back(); return &file_provider_events_.back(); }
 
-  case ::perfetto::protos::pbzero::AtomId::LOOPER_STATS:
-    return "LOOPER_STATS";
+ private:
+  std::vector<EtwConfig_KernelFlag> kernel_flags_;
+  std::vector<std::string> scheduler_provider_events_;
+  std::vector<std::string> memory_provider_events_;
+  std::vector<std::string> file_provider_events_;
 
-  case ::perfetto::protos::pbzero::AtomId::DISK_STATS:
-    return "DISK_STATS";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::DIRECTORY_USAGE:
-    return "DIRECTORY_USAGE";
+  std::bitset<5> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::APP_SIZE:
-    return "APP_SIZE";
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::CATEGORY_SIZE:
-    return "CATEGORY_SIZE";
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ETW_ETW_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/interceptor_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTOR_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTOR_CONFIG_PROTO_CPP_H_
 
-  case ::perfetto::protos::pbzero::AtomId::PROC_STATS:
-    return "PROC_STATS";
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  case ::perfetto::protos::pbzero::AtomId::BATTERY_VOLTAGE:
-    return "BATTERY_VOLTAGE";
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  case ::perfetto::protos::pbzero::AtomId::NUM_FINGERPRINTS_ENROLLED:
-    return "NUM_FINGERPRINTS_ENROLLED";
+namespace perfetto {
+namespace protos {
+namespace gen {
+class InterceptorConfig;
+class ConsoleConfig;
+enum ConsoleConfig_Output : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::DISK_IO:
-    return "DISK_IO";
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  case ::perfetto::protos::pbzero::AtomId::POWER_PROFILE:
-    return "POWER_PROFILE";
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-  case ::perfetto::protos::pbzero::AtomId::PROC_STATS_PKG_PROC:
-    return "PROC_STATS_PKG_PROC";
+class PERFETTO_EXPORT_COMPONENT InterceptorConfig : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kNameFieldNumber = 1,
+    kConsoleConfigFieldNumber = 100,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::PROCESS_CPU_TIME:
-    return "PROCESS_CPU_TIME";
+  InterceptorConfig();
+  ~InterceptorConfig() override;
+  InterceptorConfig(InterceptorConfig&&) noexcept;
+  InterceptorConfig& operator=(InterceptorConfig&&);
+  InterceptorConfig(const InterceptorConfig&);
+  InterceptorConfig& operator=(const InterceptorConfig&);
+  bool operator==(const InterceptorConfig&) const;
+  bool operator!=(const InterceptorConfig& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::CPU_TIME_PER_THREAD_FREQ:
-    return "CPU_TIME_PER_THREAD_FREQ";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::ON_DEVICE_POWER_MEASUREMENT:
-    return "ON_DEVICE_POWER_MEASUREMENT";
+  bool has_name() const { return _has_field_[1]; }
+  const std::string& name() const { return name_; }
+  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
 
-  case ::perfetto::protos::pbzero::AtomId::DEVICE_CALCULATED_POWER_USE:
-    return "DEVICE_CALCULATED_POWER_USE";
+  bool has_console_config() const { return _has_field_[100]; }
+  const ConsoleConfig& console_config() const { return *console_config_; }
+  ConsoleConfig* mutable_console_config() { _has_field_.set(100); return console_config_.get(); }
 
-  case ::perfetto::protos::pbzero::AtomId::DEVICE_CALCULATED_POWER_BLAME_UID:
-    return "DEVICE_CALCULATED_POWER_BLAME_UID";
+ private:
+  std::string name_{};
+  ::protozero::CopyablePtr<ConsoleConfig> console_config_;
 
-  case ::perfetto::protos::pbzero::AtomId::DEVICE_CALCULATED_POWER_BLAME_OTHER:
-    return "DEVICE_CALCULATED_POWER_BLAME_OTHER";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::PROCESS_MEMORY_HIGH_WATER_MARK:
-    return "PROCESS_MEMORY_HIGH_WATER_MARK";
+  std::bitset<101> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::BATTERY_LEVEL:
-    return "BATTERY_LEVEL";
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::BUILD_INFORMATION:
-    return "BUILD_INFORMATION";
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTOR_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/stress_test_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STRESS_TEST_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STRESS_TEST_CONFIG_PROTO_CPP_H_
 
-  case ::perfetto::protos::pbzero::AtomId::BATTERY_CYCLE_COUNT:
-    return "BATTERY_CYCLE_COUNT";
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  case ::perfetto::protos::pbzero::AtomId::DEBUG_ELAPSED_CLOCK:
-    return "DEBUG_ELAPSED_CLOCK";
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  case ::perfetto::protos::pbzero::AtomId::DEBUG_FAILING_ELAPSED_CLOCK:
-    return "DEBUG_FAILING_ELAPSED_CLOCK";
+namespace perfetto {
+namespace protos {
+namespace gen {
+class StressTestConfig;
+class StressTestConfig_WriterTiming;
+class TraceConfig;
+class TraceConfig_Note;
+class PriorityBoostConfig;
+class TraceConfig_SessionSemaphore;
+class TraceConfig_CmdTraceStartDelay;
+class TraceConfig_AndroidReportConfig;
+class TraceConfig_TraceFilter;
+class TraceConfig_TraceFilter_StringFilterChain;
+class TraceConfig_TraceFilter_StringFilterRule;
+class TraceConfig_IncidentReportConfig;
+class TraceConfig_IncrementalStateConfig;
+class TraceConfig_TriggerConfig;
+class TraceConfig_TriggerConfig_Trigger;
+class TraceConfig_GuardrailOverrides;
+class TraceConfig_StatsdMetadata;
+class TraceConfig_ProducerConfig;
+class TraceConfig_BuiltinDataSource;
+class TraceConfig_DataSource;
+class DataSourceConfig;
+class TestConfig;
+class TestConfig_DummyFields;
+class InterceptorConfig;
+class ConsoleConfig;
+class ChromeConfig;
+class SystemInfoConfig;
+class ProtoVmConfig;
+class TraceConfig_BufferConfig;
+enum TraceConfig_LockdownModeOperation : int;
+enum TraceConfig_CompressionType : int;
+enum TraceConfig_StatsdLogging : int;
+enum TraceConfig_WriteFlushMode : int;
+enum TraceConfig_FFlushMode : int;
+enum PriorityBoostConfig_BoostPolicy : int;
+enum TraceConfig_TraceFilter_StringFilterPolicy : int;
+enum SemanticType : int;
+enum TraceConfig_TriggerConfig_TriggerMode : int;
+enum BuiltinClock : int;
+enum DataSourceConfig_SessionInitiator : int;
+enum DataSourceConfig_BufferExhaustedPolicy : int;
+enum ConsoleConfig_Output : int;
+enum ChromeConfig_ClientPriority : int;
+enum TraceConfig_BufferConfig_FillPolicy : int;
+enum TraceConfig_BufferConfig_ExperimentalMode : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::NUM_FACES_ENROLLED:
-    return "NUM_FACES_ENROLLED";
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  case ::perfetto::protos::pbzero::AtomId::ROLE_HOLDER:
-    return "ROLE_HOLDER";
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-  case ::perfetto::protos::pbzero::AtomId::DANGEROUS_PERMISSION_STATE:
-    return "DANGEROUS_PERMISSION_STATE";
+class PERFETTO_EXPORT_COMPONENT StressTestConfig : public ::protozero::CppMessageObj {
+ public:
+  using WriterTiming = StressTestConfig_WriterTiming;
+  enum FieldNumbers {
+    kTraceConfigFieldNumber = 1,
+    kShmemSizeKbFieldNumber = 2,
+    kShmemPageSizeKbFieldNumber = 3,
+    kNumProcessesFieldNumber = 4,
+    kNumThreadsFieldNumber = 5,
+    kMaxEventsFieldNumber = 6,
+    kNestingFieldNumber = 7,
+    kSteadyStateTimingsFieldNumber = 8,
+    kBurstPeriodMsFieldNumber = 9,
+    kBurstDurationMsFieldNumber = 10,
+    kBurstTimingsFieldNumber = 11,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::TRAIN_INFO:
-    return "TRAIN_INFO";
+  StressTestConfig();
+  ~StressTestConfig() override;
+  StressTestConfig(StressTestConfig&&) noexcept;
+  StressTestConfig& operator=(StressTestConfig&&);
+  StressTestConfig(const StressTestConfig&);
+  StressTestConfig& operator=(const StressTestConfig&);
+  bool operator==(const StressTestConfig&) const;
+  bool operator!=(const StressTestConfig& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::TIME_ZONE_DATA_INFO:
-    return "TIME_ZONE_DATA_INFO";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::EXTERNAL_STORAGE_INFO:
-    return "EXTERNAL_STORAGE_INFO";
+  bool has_trace_config() const { return _has_field_[1]; }
+  const TraceConfig& trace_config() const { return *trace_config_; }
+  TraceConfig* mutable_trace_config() { _has_field_.set(1); return trace_config_.get(); }
 
-  case ::perfetto::protos::pbzero::AtomId::GPU_STATS_GLOBAL_INFO:
-    return "GPU_STATS_GLOBAL_INFO";
+  bool has_shmem_size_kb() const { return _has_field_[2]; }
+  uint32_t shmem_size_kb() const { return shmem_size_kb_; }
+  void set_shmem_size_kb(uint32_t value) { shmem_size_kb_ = value; _has_field_.set(2); }
 
-  case ::perfetto::protos::pbzero::AtomId::GPU_STATS_APP_INFO:
-    return "GPU_STATS_APP_INFO";
+  bool has_shmem_page_size_kb() const { return _has_field_[3]; }
+  uint32_t shmem_page_size_kb() const { return shmem_page_size_kb_; }
+  void set_shmem_page_size_kb(uint32_t value) { shmem_page_size_kb_ = value; _has_field_.set(3); }
 
-  case ::perfetto::protos::pbzero::AtomId::SYSTEM_ION_HEAP_SIZE:
-    return "SYSTEM_ION_HEAP_SIZE";
+  bool has_num_processes() const { return _has_field_[4]; }
+  uint32_t num_processes() const { return num_processes_; }
+  void set_num_processes(uint32_t value) { num_processes_ = value; _has_field_.set(4); }
 
-  case ::perfetto::protos::pbzero::AtomId::APPS_ON_EXTERNAL_STORAGE_INFO:
-    return "APPS_ON_EXTERNAL_STORAGE_INFO";
+  bool has_num_threads() const { return _has_field_[5]; }
+  uint32_t num_threads() const { return num_threads_; }
+  void set_num_threads(uint32_t value) { num_threads_ = value; _has_field_.set(5); }
 
-  case ::perfetto::protos::pbzero::AtomId::FACE_SETTINGS:
-    return "FACE_SETTINGS";
+  bool has_max_events() const { return _has_field_[6]; }
+  uint32_t max_events() const { return max_events_; }
+  void set_max_events(uint32_t value) { max_events_ = value; _has_field_.set(6); }
 
-  case ::perfetto::protos::pbzero::AtomId::COOLING_DEVICE:
-    return "COOLING_DEVICE";
+  bool has_nesting() const { return _has_field_[7]; }
+  uint32_t nesting() const { return nesting_; }
+  void set_nesting(uint32_t value) { nesting_ = value; _has_field_.set(7); }
 
-  case ::perfetto::protos::pbzero::AtomId::APP_OPS:
-    return "APP_OPS";
+  bool has_steady_state_timings() const { return _has_field_[8]; }
+  const StressTestConfig_WriterTiming& steady_state_timings() const { return *steady_state_timings_; }
+  StressTestConfig_WriterTiming* mutable_steady_state_timings() { _has_field_.set(8); return steady_state_timings_.get(); }
 
-  case ::perfetto::protos::pbzero::AtomId::PROCESS_SYSTEM_ION_HEAP_SIZE:
-    return "PROCESS_SYSTEM_ION_HEAP_SIZE";
+  bool has_burst_period_ms() const { return _has_field_[9]; }
+  uint32_t burst_period_ms() const { return burst_period_ms_; }
+  void set_burst_period_ms(uint32_t value) { burst_period_ms_ = value; _has_field_.set(9); }
 
-  case ::perfetto::protos::pbzero::AtomId::SURFACEFLINGER_STATS_GLOBAL_INFO:
-    return "SURFACEFLINGER_STATS_GLOBAL_INFO";
+  bool has_burst_duration_ms() const { return _has_field_[10]; }
+  uint32_t burst_duration_ms() const { return burst_duration_ms_; }
+  void set_burst_duration_ms(uint32_t value) { burst_duration_ms_ = value; _has_field_.set(10); }
 
-  case ::perfetto::protos::pbzero::AtomId::SURFACEFLINGER_STATS_LAYER_INFO:
-    return "SURFACEFLINGER_STATS_LAYER_INFO";
+  bool has_burst_timings() const { return _has_field_[11]; }
+  const StressTestConfig_WriterTiming& burst_timings() const { return *burst_timings_; }
+  StressTestConfig_WriterTiming* mutable_burst_timings() { _has_field_.set(11); return burst_timings_.get(); }
 
-  case ::perfetto::protos::pbzero::AtomId::PROCESS_MEMORY_SNAPSHOT:
-    return "PROCESS_MEMORY_SNAPSHOT";
+ private:
+  ::protozero::CopyablePtr<TraceConfig> trace_config_;
+  uint32_t shmem_size_kb_{};
+  uint32_t shmem_page_size_kb_{};
+  uint32_t num_processes_{};
+  uint32_t num_threads_{};
+  uint32_t max_events_{};
+  uint32_t nesting_{};
+  ::protozero::CopyablePtr<StressTestConfig_WriterTiming> steady_state_timings_;
+  uint32_t burst_period_ms_{};
+  uint32_t burst_duration_ms_{};
+  ::protozero::CopyablePtr<StressTestConfig_WriterTiming> burst_timings_;
 
-  case ::perfetto::protos::pbzero::AtomId::VMS_CLIENT_STATS:
-    return "VMS_CLIENT_STATS";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::NOTIFICATION_REMOTE_VIEWS:
-    return "NOTIFICATION_REMOTE_VIEWS";
+  std::bitset<12> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::DANGEROUS_PERMISSION_STATE_SAMPLED:
-    return "DANGEROUS_PERMISSION_STATE_SAMPLED";
 
-  case ::perfetto::protos::pbzero::AtomId::GRAPHICS_STATS:
-    return "GRAPHICS_STATS";
+class PERFETTO_EXPORT_COMPONENT StressTestConfig_WriterTiming : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kPayloadMeanFieldNumber = 1,
+    kPayloadStddevFieldNumber = 2,
+    kRateMeanFieldNumber = 3,
+    kRateStddevFieldNumber = 4,
+    kPayloadWriteTimeMsFieldNumber = 5,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::RUNTIME_APP_OP_ACCESS:
-    return "RUNTIME_APP_OP_ACCESS";
+  StressTestConfig_WriterTiming();
+  ~StressTestConfig_WriterTiming() override;
+  StressTestConfig_WriterTiming(StressTestConfig_WriterTiming&&) noexcept;
+  StressTestConfig_WriterTiming& operator=(StressTestConfig_WriterTiming&&);
+  StressTestConfig_WriterTiming(const StressTestConfig_WriterTiming&);
+  StressTestConfig_WriterTiming& operator=(const StressTestConfig_WriterTiming&);
+  bool operator==(const StressTestConfig_WriterTiming&) const;
+  bool operator!=(const StressTestConfig_WriterTiming& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::ION_HEAP_SIZE:
-    return "ION_HEAP_SIZE";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::PACKAGE_NOTIFICATION_PREFERENCES:
-    return "PACKAGE_NOTIFICATION_PREFERENCES";
+  bool has_payload_mean() const { return _has_field_[1]; }
+  double payload_mean() const { return payload_mean_; }
+  void set_payload_mean(double value) { payload_mean_ = value; _has_field_.set(1); }
 
-  case ::perfetto::protos::pbzero::AtomId::PACKAGE_NOTIFICATION_CHANNEL_PREFERENCES:
-    return "PACKAGE_NOTIFICATION_CHANNEL_PREFERENCES";
+  bool has_payload_stddev() const { return _has_field_[2]; }
+  double payload_stddev() const { return payload_stddev_; }
+  void set_payload_stddev(double value) { payload_stddev_ = value; _has_field_.set(2); }
 
-  case ::perfetto::protos::pbzero::AtomId::PACKAGE_NOTIFICATION_CHANNEL_GROUP_PREFERENCES:
-    return "PACKAGE_NOTIFICATION_CHANNEL_GROUP_PREFERENCES";
+  bool has_rate_mean() const { return _has_field_[3]; }
+  double rate_mean() const { return rate_mean_; }
+  void set_rate_mean(double value) { rate_mean_ = value; _has_field_.set(3); }
 
-  case ::perfetto::protos::pbzero::AtomId::GNSS_STATS:
-    return "GNSS_STATS";
+  bool has_rate_stddev() const { return _has_field_[4]; }
+  double rate_stddev() const { return rate_stddev_; }
+  void set_rate_stddev(double value) { rate_stddev_ = value; _has_field_.set(4); }
 
-  case ::perfetto::protos::pbzero::AtomId::ATTRIBUTED_APP_OPS:
-    return "ATTRIBUTED_APP_OPS";
+  bool has_payload_write_time_ms() const { return _has_field_[5]; }
+  uint32_t payload_write_time_ms() const { return payload_write_time_ms_; }
+  void set_payload_write_time_ms(uint32_t value) { payload_write_time_ms_ = value; _has_field_.set(5); }
 
-  case ::perfetto::protos::pbzero::AtomId::VOICE_CALL_SESSION:
-    return "VOICE_CALL_SESSION";
+ private:
+  double payload_mean_{};
+  double payload_stddev_{};
+  double rate_mean_{};
+  double rate_stddev_{};
+  uint32_t payload_write_time_ms_{};
 
-  case ::perfetto::protos::pbzero::AtomId::VOICE_CALL_RAT_USAGE:
-    return "VOICE_CALL_RAT_USAGE";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::SIM_SLOT_STATE:
-    return "SIM_SLOT_STATE";
+  std::bitset<6> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::SUPPORTED_RADIO_ACCESS_FAMILY:
-    return "SUPPORTED_RADIO_ACCESS_FAMILY";
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::SETTING_SNAPSHOT:
-    return "SETTING_SNAPSHOT";
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STRESS_TEST_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/test_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TEST_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TEST_CONFIG_PROTO_CPP_H_
 
-  case ::perfetto::protos::pbzero::AtomId::BLOB_INFO:
-    return "BLOB_INFO";
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  case ::perfetto::protos::pbzero::AtomId::DATA_USAGE_BYTES_TRANSFER:
-    return "DATA_USAGE_BYTES_TRANSFER";
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  case ::perfetto::protos::pbzero::AtomId::BYTES_TRANSFER_BY_TAG_AND_METERED:
-    return "BYTES_TRANSFER_BY_TAG_AND_METERED";
+namespace perfetto {
+namespace protos {
+namespace gen {
+class TestConfig;
+class TestConfig_DummyFields;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::DND_MODE_RULE:
-    return "DND_MODE_RULE";
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  case ::perfetto::protos::pbzero::AtomId::GENERAL_EXTERNAL_STORAGE_ACCESS_STATS:
-    return "GENERAL_EXTERNAL_STORAGE_ACCESS_STATS";
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-  case ::perfetto::protos::pbzero::AtomId::INCOMING_SMS:
-    return "INCOMING_SMS";
+class PERFETTO_EXPORT_COMPONENT TestConfig : public ::protozero::CppMessageObj {
+ public:
+  using DummyFields = TestConfig_DummyFields;
+  enum FieldNumbers {
+    kMessageCountFieldNumber = 1,
+    kMaxMessagesPerSecondFieldNumber = 2,
+    kSeedFieldNumber = 3,
+    kMessageSizeFieldNumber = 4,
+    kSendBatchOnRegisterFieldNumber = 5,
+    kDummyFieldsFieldNumber = 6,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::OUTGOING_SMS:
-    return "OUTGOING_SMS";
+  TestConfig();
+  ~TestConfig() override;
+  TestConfig(TestConfig&&) noexcept;
+  TestConfig& operator=(TestConfig&&);
+  TestConfig(const TestConfig&);
+  TestConfig& operator=(const TestConfig&);
+  bool operator==(const TestConfig&) const;
+  bool operator!=(const TestConfig& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::CARRIER_ID_TABLE_VERSION:
-    return "CARRIER_ID_TABLE_VERSION";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::DATA_CALL_SESSION:
-    return "DATA_CALL_SESSION";
+  bool has_message_count() const { return _has_field_[1]; }
+  uint32_t message_count() const { return message_count_; }
+  void set_message_count(uint32_t value) { message_count_ = value; _has_field_.set(1); }
 
-  case ::perfetto::protos::pbzero::AtomId::CELLULAR_SERVICE_STATE:
-    return "CELLULAR_SERVICE_STATE";
+  bool has_max_messages_per_second() const { return _has_field_[2]; }
+  uint32_t max_messages_per_second() const { return max_messages_per_second_; }
+  void set_max_messages_per_second(uint32_t value) { max_messages_per_second_ = value; _has_field_.set(2); }
 
-  case ::perfetto::protos::pbzero::AtomId::CELLULAR_DATA_SERVICE_SWITCH:
-    return "CELLULAR_DATA_SERVICE_SWITCH";
+  bool has_seed() const { return _has_field_[3]; }
+  uint32_t seed() const { return seed_; }
+  void set_seed(uint32_t value) { seed_ = value; _has_field_.set(3); }
 
-  case ::perfetto::protos::pbzero::AtomId::SYSTEM_MEMORY:
-    return "SYSTEM_MEMORY";
+  bool has_message_size() const { return _has_field_[4]; }
+  uint32_t message_size() const { return message_size_; }
+  void set_message_size(uint32_t value) { message_size_ = value; _has_field_.set(4); }
 
-  case ::perfetto::protos::pbzero::AtomId::IMS_REGISTRATION_TERMINATION:
-    return "IMS_REGISTRATION_TERMINATION";
+  bool has_send_batch_on_register() const { return _has_field_[5]; }
+  bool send_batch_on_register() const { return send_batch_on_register_; }
+  void set_send_batch_on_register(bool value) { send_batch_on_register_ = value; _has_field_.set(5); }
 
-  case ::perfetto::protos::pbzero::AtomId::IMS_REGISTRATION_STATS:
-    return "IMS_REGISTRATION_STATS";
+  bool has_dummy_fields() const { return _has_field_[6]; }
+  const TestConfig_DummyFields& dummy_fields() const { return *dummy_fields_; }
+  TestConfig_DummyFields* mutable_dummy_fields() { _has_field_.set(6); return dummy_fields_.get(); }
 
-  case ::perfetto::protos::pbzero::AtomId::CPU_TIME_PER_CLUSTER_FREQ:
-    return "CPU_TIME_PER_CLUSTER_FREQ";
+ private:
+  uint32_t message_count_{};
+  uint32_t max_messages_per_second_{};
+  uint32_t seed_{};
+  uint32_t message_size_{};
+  bool send_batch_on_register_{};
+  ::protozero::CopyablePtr<TestConfig_DummyFields> dummy_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::CPU_CYCLES_PER_UID_CLUSTER:
-    return "CPU_CYCLES_PER_UID_CLUSTER";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::DEVICE_ROTATED_DATA:
-    return "DEVICE_ROTATED_DATA";
+  std::bitset<7> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::CPU_CYCLES_PER_THREAD_GROUP_CLUSTER:
-    return "CPU_CYCLES_PER_THREAD_GROUP_CLUSTER";
 
-  case ::perfetto::protos::pbzero::AtomId::MEDIA_DRM_ACTIVITY_INFO:
-    return "MEDIA_DRM_ACTIVITY_INFO";
+class PERFETTO_EXPORT_COMPONENT TestConfig_DummyFields : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kFieldUint32FieldNumber = 1,
+    kFieldInt32FieldNumber = 2,
+    kFieldUint64FieldNumber = 3,
+    kFieldInt64FieldNumber = 4,
+    kFieldFixed64FieldNumber = 5,
+    kFieldSfixed64FieldNumber = 6,
+    kFieldFixed32FieldNumber = 7,
+    kFieldSfixed32FieldNumber = 8,
+    kFieldDoubleFieldNumber = 9,
+    kFieldFloatFieldNumber = 10,
+    kFieldSint64FieldNumber = 11,
+    kFieldSint32FieldNumber = 12,
+    kFieldStringFieldNumber = 13,
+    kFieldBytesFieldNumber = 14,
+  };
 
-  case ::perfetto::protos::pbzero::AtomId::OEM_MANAGED_BYTES_TRANSFER:
-    return "OEM_MANAGED_BYTES_TRANSFER";
+  TestConfig_DummyFields();
+  ~TestConfig_DummyFields() override;
+  TestConfig_DummyFields(TestConfig_DummyFields&&) noexcept;
+  TestConfig_DummyFields& operator=(TestConfig_DummyFields&&);
+  TestConfig_DummyFields(const TestConfig_DummyFields&);
+  TestConfig_DummyFields& operator=(const TestConfig_DummyFields&);
+  bool operator==(const TestConfig_DummyFields&) const;
+  bool operator!=(const TestConfig_DummyFields& other) const { return !(*this == other); }
 
-  case ::perfetto::protos::pbzero::AtomId::GNSS_POWER_STATS:
-    return "GNSS_POWER_STATS";
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  case ::perfetto::protos::pbzero::AtomId::TIME_ZONE_DETECTOR_STATE:
-    return "TIME_ZONE_DETECTOR_STATE";
+  bool has_field_uint32() const { return _has_field_[1]; }
+  uint32_t field_uint32() const { return field_uint32_; }
+  void set_field_uint32(uint32_t value) { field_uint32_ = value; _has_field_.set(1); }
 
-  case ::perfetto::protos::pbzero::AtomId::KEYSTORE2_STORAGE_STATS:
-    return "KEYSTORE2_STORAGE_STATS";
+  bool has_field_int32() const { return _has_field_[2]; }
+  int32_t field_int32() const { return field_int32_; }
+  void set_field_int32(int32_t value) { field_int32_ = value; _has_field_.set(2); }
 
-  case ::perfetto::protos::pbzero::AtomId::RKP_POOL_STATS:
-    return "RKP_POOL_STATS";
+  bool has_field_uint64() const { return _has_field_[3]; }
+  uint64_t field_uint64() const { return field_uint64_; }
+  void set_field_uint64(uint64_t value) { field_uint64_ = value; _has_field_.set(3); }
 
-  case ::perfetto::protos::pbzero::AtomId::PROCESS_DMABUF_MEMORY:
-    return "PROCESS_DMABUF_MEMORY";
+  bool has_field_int64() const { return _has_field_[4]; }
+  int64_t field_int64() const { return field_int64_; }
+  void set_field_int64(int64_t value) { field_int64_ = value; _has_field_.set(4); }
 
-  case ::perfetto::protos::pbzero::AtomId::PENDING_ALARM_INFO:
-    return "PENDING_ALARM_INFO";
+  bool has_field_fixed64() const { return _has_field_[5]; }
+  uint64_t field_fixed64() const { return field_fixed64_; }
+  void set_field_fixed64(uint64_t value) { field_fixed64_ = value; _has_field_.set(5); }
 
-  case ::perfetto::protos::pbzero::AtomId::USER_LEVEL_HIBERNATED_APPS:
-    return "USER_LEVEL_HIBERNATED_APPS";
+  bool has_field_sfixed64() const { return _has_field_[6]; }
+  int64_t field_sfixed64() const { return field_sfixed64_; }
+  void set_field_sfixed64(int64_t value) { field_sfixed64_ = value; _has_field_.set(6); }
 
-  case ::perfetto::protos::pbzero::AtomId::LAUNCHER_LAYOUT_SNAPSHOT:
-    return "LAUNCHER_LAYOUT_SNAPSHOT";
+  bool has_field_fixed32() const { return _has_field_[7]; }
+  uint32_t field_fixed32() const { return field_fixed32_; }
+  void set_field_fixed32(uint32_t value) { field_fixed32_ = value; _has_field_.set(7); }
 
-  case ::perfetto::protos::pbzero::AtomId::GLOBAL_HIBERNATED_APPS:
-    return "GLOBAL_HIBERNATED_APPS";
+  bool has_field_sfixed32() const { return _has_field_[8]; }
+  int32_t field_sfixed32() const { return field_sfixed32_; }
+  void set_field_sfixed32(int32_t value) { field_sfixed32_ = value; _has_field_.set(8); }
 
-  case ::perfetto::protos::pbzero::AtomId::INPUT_EVENT_LATENCY_SKETCH:
-    return "INPUT_EVENT_LATENCY_SKETCH";
+  bool has_field_double() const { return _has_field_[9]; }
+  double field_double() const { return field_double_; }
+  void set_field_double(double value) { field_double_ = value; _has_field_.set(9); }
 
-  case ::perfetto::protos::pbzero::AtomId::BATTERY_USAGE_STATS_BEFORE_RESET:
-    return "BATTERY_USAGE_STATS_BEFORE_RESET";
+  bool has_field_float() const { return _has_field_[10]; }
+  float field_float() const { return field_float_; }
+  void set_field_float(float value) { field_float_ = value; _has_field_.set(10); }
 
-  case ::perfetto::protos::pbzero::AtomId::BATTERY_USAGE_STATS_SINCE_RESET:
-    return "BATTERY_USAGE_STATS_SINCE_RESET";
+  bool has_field_sint64() const { return _has_field_[11]; }
+  int64_t field_sint64() const { return field_sint64_; }
+  void set_field_sint64(int64_t value) { field_sint64_ = value; _has_field_.set(11); }
 
-  case ::perfetto::protos::pbzero::AtomId::BATTERY_USAGE_STATS_SINCE_RESET_USING_POWER_PROFILE_MODEL:
-    return "BATTERY_USAGE_STATS_SINCE_RESET_USING_POWER_PROFILE_MODEL";
+  bool has_field_sint32() const { return _has_field_[12]; }
+  int32_t field_sint32() const { return field_sint32_; }
+  void set_field_sint32(int32_t value) { field_sint32_ = value; _has_field_.set(12); }
 
-  case ::perfetto::protos::pbzero::AtomId::INSTALLED_INCREMENTAL_PACKAGE:
-    return "INSTALLED_INCREMENTAL_PACKAGE";
+  bool has_field_string() const { return _has_field_[13]; }
+  const std::string& field_string() const { return field_string_; }
+  void set_field_string(const std::string& value) { field_string_ = value; _has_field_.set(13); }
 
-  case ::perfetto::protos::pbzero::AtomId::TELEPHONY_NETWORK_REQUESTS:
-    return "TELEPHONY_NETWORK_REQUESTS";
+  bool has_field_bytes() const { return _has_field_[14]; }
+  const std::string& field_bytes() const { return field_bytes_; }
+  void set_field_bytes(const std::string& value) { field_bytes_ = value; _has_field_.set(14); }
+  void set_field_bytes(const void* p, size_t s) { field_bytes_.assign(reinterpret_cast<const char*>(p), s); _has_field_.set(14); }
 
-  case ::perfetto::protos::pbzero::AtomId::APP_SEARCH_STORAGE_INFO:
-    return "APP_SEARCH_STORAGE_INFO";
+ private:
+  uint32_t field_uint32_{};
+  int32_t field_int32_{};
+  uint64_t field_uint64_{};
+  int64_t field_int64_{};
+  uint64_t field_fixed64_{};
+  int64_t field_sfixed64_{};
+  uint32_t field_fixed32_{};
+  int32_t field_sfixed32_{};
+  double field_double_{};
+  float field_float_{};
+  int64_t field_sint64_{};
+  int32_t field_sint32_{};
+  std::string field_string_{};
+  std::string field_bytes_{};
 
-  case ::perfetto::protos::pbzero::AtomId::VMSTAT:
-    return "VMSTAT";
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  case ::perfetto::protos::pbzero::AtomId::KEYSTORE2_KEY_CREATION_WITH_GENERAL_INFO:
-    return "KEYSTORE2_KEY_CREATION_WITH_GENERAL_INFO";
+  std::bitset<15> _has_field_{};
+};
 
-  case ::perfetto::protos::pbzero::AtomId::KEYSTORE2_KEY_CREATION_WITH_AUTH_INFO:
-    return "KEYSTORE2_KEY_CREATION_WITH_AUTH_INFO";
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  case ::perfetto::protos::pbzero::AtomId::KEYSTORE2_KEY_CREATION_WITH_PURPOSE_AND_MODES_INFO:
-    return "KEYSTORE2_KEY_CREATION_WITH_PURPOSE_AND_MODES_INFO";
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TEST_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/common/semantic_type.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  case ::perfetto::protos::pbzero::AtomId::KEYSTORE2_ATOM_WITH_OVERFLOW:
-    return "KEYSTORE2_ATOM_WITH_OVERFLOW";
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_SEMANTIC_TYPE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_COMMON_SEMANTIC_TYPE_PROTO_H_
 
-  case ::perfetto::protos::pbzero::AtomId::KEYSTORE2_KEY_OPERATION_WITH_PURPOSE_AND_MODES_INFO:
-    return "KEYSTORE2_KEY_OPERATION_WITH_PURPOSE_AND_MODES_INFO";
+#include <stddef.h>
+#include <stdint.h>
 
-  case ::perfetto::protos::pbzero::AtomId::KEYSTORE2_KEY_OPERATION_WITH_GENERAL_INFO:
-    return "KEYSTORE2_KEY_OPERATION_WITH_GENERAL_INFO";
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  case ::perfetto::protos::pbzero::AtomId::RKP_ERROR_STATS:
-    return "RKP_ERROR_STATS";
 
-  case ::perfetto::protos::pbzero::AtomId::KEYSTORE2_CRASH_STATS:
-    return "KEYSTORE2_CRASH_STATS";
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-  case ::perfetto::protos::pbzero::AtomId::ACCESSIBILITY_SHORTCUT_STATS:
-    return "ACCESSIBILITY_SHORTCUT_STATS";
+enum SemanticType : int32_t {
+  SEMANTIC_TYPE_UNSPECIFIED = 0,
+  SEMANTIC_TYPE_ATRACE = 1,
+  SEMANTIC_TYPE_JOB = 2,
+  SEMANTIC_TYPE_WAKELOCK = 3,
+};
 
-  case ::perfetto::protos::pbzero::AtomId::ACCESSIBILITY_FLOATING_MENU_STATS:
-    return "ACCESSIBILITY_FLOATING_MENU_STATS";
+constexpr SemanticType SemanticType_MIN = SemanticType::SEMANTIC_TYPE_UNSPECIFIED;
+constexpr SemanticType SemanticType_MAX = SemanticType::SEMANTIC_TYPE_WAKELOCK;
 
-  case ::perfetto::protos::pbzero::AtomId::CAR_WATCHDOG_SYSTEM_IO_USAGE_SUMMARY:
-    return "CAR_WATCHDOG_SYSTEM_IO_USAGE_SUMMARY";
 
-  case ::perfetto::protos::pbzero::AtomId::CAR_WATCHDOG_UID_IO_USAGE_SUMMARY:
-    return "CAR_WATCHDOG_UID_IO_USAGE_SUMMARY";
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* SemanticType_Name(::perfetto::protos::pbzero::SemanticType value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::SemanticType::SEMANTIC_TYPE_UNSPECIFIED:
+    return "SEMANTIC_TYPE_UNSPECIFIED";
 
-  case ::perfetto::protos::pbzero::AtomId::IMS_REGISTRATION_FEATURE_TAG_STATS:
-    return "IMS_REGISTRATION_FEATURE_TAG_STATS";
+  case ::perfetto::protos::pbzero::SemanticType::SEMANTIC_TYPE_ATRACE:
+    return "SEMANTIC_TYPE_ATRACE";
 
-  case ::perfetto::protos::pbzero::AtomId::RCS_CLIENT_PROVISIONING_STATS:
-    return "RCS_CLIENT_PROVISIONING_STATS";
+  case ::perfetto::protos::pbzero::SemanticType::SEMANTIC_TYPE_JOB:
+    return "SEMANTIC_TYPE_JOB";
 
-  case ::perfetto::protos::pbzero::AtomId::RCS_ACS_PROVISIONING_STATS:
-    return "RCS_ACS_PROVISIONING_STATS";
+  case ::perfetto::protos::pbzero::SemanticType::SEMANTIC_TYPE_WAKELOCK:
+    return "SEMANTIC_TYPE_WAKELOCK";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
-  case ::perfetto::protos::pbzero::AtomId::SIP_DELEGATE_STATS:
-    return "SIP_DELEGATE_STATS";
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_game_intervention_list_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  case ::perfetto::protos::pbzero::AtomId::SIP_TRANSPORT_FEATURE_TAG_STATS:
-    return "SIP_TRANSPORT_FEATURE_TAG_STATS";
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_GAME_INTERVENTION_LIST_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_GAME_INTERVENTION_LIST_CONFIG_PROTO_H_
 
-  case ::perfetto::protos::pbzero::AtomId::SIP_MESSAGE_RESPONSE:
-    return "SIP_MESSAGE_RESPONSE";
+#include <stddef.h>
+#include <stdint.h>
 
-  case ::perfetto::protos::pbzero::AtomId::SIP_TRANSPORT_SESSION:
-    return "SIP_TRANSPORT_SESSION";
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  case ::perfetto::protos::pbzero::AtomId::IMS_DEDICATED_BEARER_LISTENER_EVENT:
-    return "IMS_DEDICATED_BEARER_LISTENER_EVENT";
 
-  case ::perfetto::protos::pbzero::AtomId::IMS_DEDICATED_BEARER_EVENT:
-    return "IMS_DEDICATED_BEARER_EVENT";
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-  case ::perfetto::protos::pbzero::AtomId::IMS_REGISTRATION_SERVICE_DESC_STATS:
-    return "IMS_REGISTRATION_SERVICE_DESC_STATS";
+class AndroidGameInterventionListConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  AndroidGameInterventionListConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidGameInterventionListConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidGameInterventionListConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_package_name_filter() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> package_name_filter() const { return GetRepeated<::protozero::ConstChars>(1); }
+};
 
-  case ::perfetto::protos::pbzero::AtomId::UCE_EVENT_STATS:
-    return "UCE_EVENT_STATS";
+class AndroidGameInterventionListConfig : public ::protozero::Message {
+ public:
+  using Decoder = AndroidGameInterventionListConfig_Decoder;
+  enum : int32_t {
+    kPackageNameFilterFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidGameInterventionListConfig"; }
 
-  case ::perfetto::protos::pbzero::AtomId::PRESENCE_NOTIFY_EVENT:
-    return "PRESENCE_NOTIFY_EVENT";
 
-  case ::perfetto::protos::pbzero::AtomId::GBA_EVENT:
-    return "GBA_EVENT";
+  using FieldMetadata_PackageNameFilter =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      AndroidGameInterventionListConfig>;
 
-  case ::perfetto::protos::pbzero::AtomId::REMOTE_KEY_PROVISIONING_ERROR_COUNTS:
-    return "REMOTE_KEY_PROVISIONING_ERROR_COUNTS";
+  static constexpr FieldMetadata_PackageNameFilter kPackageNameFilter{};
+  void add_package_name_filter(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_PackageNameFilter::kFieldId, data, size);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+  void add_package_name_filter(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_PackageNameFilter::kFieldId, chars.data, chars.size);
+  }
+  void add_package_name_filter(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_PackageNameFilter::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
 
 } // Namespace.
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/statsd/statsd_tracing_config.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_input_event_config.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_STATSD_TRACING_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_STATSD_TRACING_CONFIG_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_INPUT_EVENT_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_INPUT_EVENT_CONFIG_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -38412,55 +45995,131 @@ const char* AtomId_Name(::perfetto::protos::pbzero::AtomId value) {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
+class AndroidInputEventConfig_TraceRule;
+namespace perfetto_pbzero_enum_AndroidInputEventConfig {
+enum TraceLevel : int32_t;
+}  // namespace perfetto_pbzero_enum_AndroidInputEventConfig
+using AndroidInputEventConfig_TraceLevel = perfetto_pbzero_enum_AndroidInputEventConfig::TraceLevel;
+namespace perfetto_pbzero_enum_AndroidInputEventConfig {
+enum TraceMode : int32_t;
+}  // namespace perfetto_pbzero_enum_AndroidInputEventConfig
+using AndroidInputEventConfig_TraceMode = perfetto_pbzero_enum_AndroidInputEventConfig::TraceMode;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_AndroidInputEventConfig {
+enum TraceMode : int32_t {
+  TRACE_MODE_TRACE_ALL = 0,
+  TRACE_MODE_USE_RULES = 1,
+};
+} // namespace perfetto_pbzero_enum_AndroidInputEventConfig
+using AndroidInputEventConfig_TraceMode = perfetto_pbzero_enum_AndroidInputEventConfig::TraceMode;
+
+
+constexpr AndroidInputEventConfig_TraceMode AndroidInputEventConfig_TraceMode_MIN = AndroidInputEventConfig_TraceMode::TRACE_MODE_TRACE_ALL;
+constexpr AndroidInputEventConfig_TraceMode AndroidInputEventConfig_TraceMode_MAX = AndroidInputEventConfig_TraceMode::TRACE_MODE_USE_RULES;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* AndroidInputEventConfig_TraceMode_Name(::perfetto::protos::pbzero::AndroidInputEventConfig_TraceMode value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::AndroidInputEventConfig_TraceMode::TRACE_MODE_TRACE_ALL:
+    return "TRACE_MODE_TRACE_ALL";
+
+  case ::perfetto::protos::pbzero::AndroidInputEventConfig_TraceMode::TRACE_MODE_USE_RULES:
+    return "TRACE_MODE_USE_RULES";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_AndroidInputEventConfig {
+enum TraceLevel : int32_t {
+  TRACE_LEVEL_NONE = 0,
+  TRACE_LEVEL_REDACTED = 1,
+  TRACE_LEVEL_COMPLETE = 2,
+};
+} // namespace perfetto_pbzero_enum_AndroidInputEventConfig
+using AndroidInputEventConfig_TraceLevel = perfetto_pbzero_enum_AndroidInputEventConfig::TraceLevel;
+
+
+constexpr AndroidInputEventConfig_TraceLevel AndroidInputEventConfig_TraceLevel_MIN = AndroidInputEventConfig_TraceLevel::TRACE_LEVEL_NONE;
+constexpr AndroidInputEventConfig_TraceLevel AndroidInputEventConfig_TraceLevel_MAX = AndroidInputEventConfig_TraceLevel::TRACE_LEVEL_COMPLETE;
 
-class StatsdPullAtomConfig;
-enum AtomId : int32_t;
 
-class StatsdPullAtomConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* AndroidInputEventConfig_TraceLevel_Name(::perfetto::protos::pbzero::AndroidInputEventConfig_TraceLevel value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::AndroidInputEventConfig_TraceLevel::TRACE_LEVEL_NONE:
+    return "TRACE_LEVEL_NONE";
+
+  case ::perfetto::protos::pbzero::AndroidInputEventConfig_TraceLevel::TRACE_LEVEL_REDACTED:
+    return "TRACE_LEVEL_REDACTED";
+
+  case ::perfetto::protos::pbzero::AndroidInputEventConfig_TraceLevel::TRACE_LEVEL_COMPLETE:
+    return "TRACE_LEVEL_COMPLETE";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class AndroidInputEventConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  StatsdPullAtomConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit StatsdPullAtomConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit StatsdPullAtomConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pull_atom_id() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<int32_t> pull_atom_id() const { return GetRepeated<int32_t>(1); }
-  bool has_raw_pull_atom_id() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<int32_t> raw_pull_atom_id() const { return GetRepeated<int32_t>(2); }
-  bool has_pull_frequency_ms() const { return at<3>().valid(); }
-  int32_t pull_frequency_ms() const { return at<3>().as_int32(); }
-  bool has_packages() const { return at<4>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> packages() const { return GetRepeated<::protozero::ConstChars>(4); }
+  AndroidInputEventConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidInputEventConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidInputEventConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_mode() const { return at<1>().valid(); }
+  int32_t mode() const { return at<1>().as_int32(); }
+  bool has_rules() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> rules() const { return GetRepeated<::protozero::ConstBytes>(2); }
+  bool has_trace_dispatcher_input_events() const { return at<3>().valid(); }
+  bool trace_dispatcher_input_events() const { return at<3>().as_bool(); }
+  bool has_trace_dispatcher_window_dispatch() const { return at<4>().valid(); }
+  bool trace_dispatcher_window_dispatch() const { return at<4>().as_bool(); }
 };
 
-class StatsdPullAtomConfig : public ::protozero::Message {
+class AndroidInputEventConfig : public ::protozero::Message {
  public:
-  using Decoder = StatsdPullAtomConfig_Decoder;
+  using Decoder = AndroidInputEventConfig_Decoder;
   enum : int32_t {
-    kPullAtomIdFieldNumber = 1,
-    kRawPullAtomIdFieldNumber = 2,
-    kPullFrequencyMsFieldNumber = 3,
-    kPackagesFieldNumber = 4,
+    kModeFieldNumber = 1,
+    kRulesFieldNumber = 2,
+    kTraceDispatcherInputEventsFieldNumber = 3,
+    kTraceDispatcherWindowDispatchFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.StatsdPullAtomConfig"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidInputEventConfig"; }
 
+  using TraceRule = ::perfetto::protos::pbzero::AndroidInputEventConfig_TraceRule;
 
-  using FieldMetadata_PullAtomId =
+  using TraceMode = ::perfetto::protos::pbzero::AndroidInputEventConfig_TraceMode;
+  static inline const char* TraceMode_Name(TraceMode value) {
+    return ::perfetto::protos::pbzero::AndroidInputEventConfig_TraceMode_Name(value);
+  }
+
+  using TraceLevel = ::perfetto::protos::pbzero::AndroidInputEventConfig_TraceLevel;
+  static inline const char* TraceLevel_Name(TraceLevel value) {
+    return ::perfetto::protos::pbzero::AndroidInputEventConfig_TraceLevel_Name(value);
+  }
+  static inline const TraceMode TRACE_MODE_TRACE_ALL = TraceMode::TRACE_MODE_TRACE_ALL;
+  static inline const TraceMode TRACE_MODE_USE_RULES = TraceMode::TRACE_MODE_USE_RULES;
+  static inline const TraceLevel TRACE_LEVEL_NONE = TraceLevel::TRACE_LEVEL_NONE;
+  static inline const TraceLevel TRACE_LEVEL_REDACTED = TraceLevel::TRACE_LEVEL_REDACTED;
+  static inline const TraceLevel TRACE_LEVEL_COMPLETE = TraceLevel::TRACE_LEVEL_COMPLETE;
+
+  using FieldMetadata_Mode =
     ::protozero::proto_utils::FieldMetadata<
       1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::AtomId,
-      StatsdPullAtomConfig>;
+      AndroidInputEventConfig_TraceMode,
+      AndroidInputEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PullAtomId kPullAtomId() { return {}; }
-  void add_pull_atom_id(::perfetto::protos::pbzero::AtomId value) {
-    static constexpr uint32_t field_id = FieldMetadata_PullAtomId::kFieldId;
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(AndroidInputEventConfig_TraceMode value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -38468,130 +46127,98 @@ class StatsdPullAtomConfig : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_RawPullAtomId =
+  using FieldMetadata_Rules =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      StatsdPullAtomConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AndroidInputEventConfig_TraceRule,
+      AndroidInputEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RawPullAtomId kRawPullAtomId() { return {}; }
-  void add_raw_pull_atom_id(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RawPullAtomId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_Rules kRules{};
+  template <typename T = AndroidInputEventConfig_TraceRule> T* add_rules() {
+    return BeginNestedMessage<T>(2);
   }
 
-  using FieldMetadata_PullFrequencyMs =
+
+  using FieldMetadata_TraceDispatcherInputEvents =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      StatsdPullAtomConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      AndroidInputEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PullFrequencyMs kPullFrequencyMs() { return {}; }
-  void set_pull_frequency_ms(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PullFrequencyMs::kFieldId;
+  static constexpr FieldMetadata_TraceDispatcherInputEvents kTraceDispatcherInputEvents{};
+  void set_trace_dispatcher_input_events(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_TraceDispatcherInputEvents::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Packages =
+  using FieldMetadata_TraceDispatcherWindowDispatch =
     ::protozero::proto_utils::FieldMetadata<
       4,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      StatsdPullAtomConfig>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      AndroidInputEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Packages kPackages() { return {}; }
-  void add_packages(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Packages::kFieldId, data, size);
-  }
-  void add_packages(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Packages::kFieldId, chars.data, chars.size);
-  }
-  void add_packages(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Packages::kFieldId;
+  static constexpr FieldMetadata_TraceDispatcherWindowDispatch kTraceDispatcherWindowDispatch{};
+  void set_trace_dispatcher_window_dispatch(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_TraceDispatcherWindowDispatch::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 };
 
-class StatsdTracingConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class AndroidInputEventConfig_TraceRule_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  StatsdTracingConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit StatsdTracingConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit StatsdTracingConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_push_atom_id() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<int32_t> push_atom_id() const { return GetRepeated<int32_t>(1); }
-  bool has_raw_push_atom_id() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<int32_t> raw_push_atom_id() const { return GetRepeated<int32_t>(2); }
-  bool has_pull_config() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> pull_config() const { return GetRepeated<::protozero::ConstBytes>(3); }
+  AndroidInputEventConfig_TraceRule_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidInputEventConfig_TraceRule_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidInputEventConfig_TraceRule_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_trace_level() const { return at<1>().valid(); }
+  int32_t trace_level() const { return at<1>().as_int32(); }
+  bool has_match_all_packages() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> match_all_packages() const { return GetRepeated<::protozero::ConstChars>(2); }
+  bool has_match_any_packages() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> match_any_packages() const { return GetRepeated<::protozero::ConstChars>(3); }
+  bool has_match_secure() const { return at<4>().valid(); }
+  bool match_secure() const { return at<4>().as_bool(); }
+  bool has_match_ime_connection_active() const { return at<5>().valid(); }
+  bool match_ime_connection_active() const { return at<5>().as_bool(); }
 };
 
-class StatsdTracingConfig : public ::protozero::Message {
+class AndroidInputEventConfig_TraceRule : public ::protozero::Message {
  public:
-  using Decoder = StatsdTracingConfig_Decoder;
+  using Decoder = AndroidInputEventConfig_TraceRule_Decoder;
   enum : int32_t {
-    kPushAtomIdFieldNumber = 1,
-    kRawPushAtomIdFieldNumber = 2,
-    kPullConfigFieldNumber = 3,
+    kTraceLevelFieldNumber = 1,
+    kMatchAllPackagesFieldNumber = 2,
+    kMatchAnyPackagesFieldNumber = 3,
+    kMatchSecureFieldNumber = 4,
+    kMatchImeConnectionActiveFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.StatsdTracingConfig"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidInputEventConfig.TraceRule"; }
 
 
-  using FieldMetadata_PushAtomId =
+  using FieldMetadata_TraceLevel =
     ::protozero::proto_utils::FieldMetadata<
       1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::AtomId,
-      StatsdTracingConfig>;
+      AndroidInputEventConfig_TraceLevel,
+      AndroidInputEventConfig_TraceRule>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PushAtomId kPushAtomId() { return {}; }
-  void add_push_atom_id(::perfetto::protos::pbzero::AtomId value) {
-    static constexpr uint32_t field_id = FieldMetadata_PushAtomId::kFieldId;
+  static constexpr FieldMetadata_TraceLevel kTraceLevel{};
+  void set_trace_level(AndroidInputEventConfig_TraceLevel value) {
+    static constexpr uint32_t field_id = FieldMetadata_TraceLevel::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -38599,62 +46226,100 @@ class StatsdTracingConfig : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_RawPushAtomId =
+  using FieldMetadata_MatchAllPackages =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      StatsdTracingConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      AndroidInputEventConfig_TraceRule>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RawPushAtomId kRawPushAtomId() { return {}; }
-  void add_raw_push_atom_id(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RawPushAtomId::kFieldId;
+  static constexpr FieldMetadata_MatchAllPackages kMatchAllPackages{};
+  void add_match_all_packages(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_MatchAllPackages::kFieldId, data, size);
+  }
+  void add_match_all_packages(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_MatchAllPackages::kFieldId, chars.data, chars.size);
+  }
+  void add_match_all_packages(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_MatchAllPackages::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PullConfig =
+  using FieldMetadata_MatchAnyPackages =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      StatsdPullAtomConfig,
-      StatsdTracingConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      AndroidInputEventConfig_TraceRule>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PullConfig kPullConfig() { return {}; }
-  template <typename T = StatsdPullAtomConfig> T* add_pull_config() {
-    return BeginNestedMessage<T>(3);
+  static constexpr FieldMetadata_MatchAnyPackages kMatchAnyPackages{};
+  void add_match_any_packages(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_MatchAnyPackages::kFieldId, data, size);
+  }
+  void add_match_any_packages(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_MatchAnyPackages::kFieldId, chars.data, chars.size);
+  }
+  void add_match_any_packages(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_MatchAnyPackages::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MatchSecure =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      AndroidInputEventConfig_TraceRule>;
+
+  static constexpr FieldMetadata_MatchSecure kMatchSecure{};
+  void set_match_secure(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_MatchSecure::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
   }
 
+  using FieldMetadata_MatchImeConnectionActive =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      AndroidInputEventConfig_TraceRule>;
+
+  static constexpr FieldMetadata_MatchImeConnectionActive kMatchImeConnectionActive{};
+  void set_match_ime_connection_active(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_MatchImeConnectionActive::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 };
 
 } // Namespace.
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/sys_stats/sys_stats_config.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_log_config.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYS_STATS_SYS_STATS_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYS_STATS_SYS_STATS_CONFIG_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_LOG_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_LOG_CONFIG_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -38668,224 +46333,348 @@ class StatsdTracingConfig : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
+enum AndroidLogId : int32_t;
+enum AndroidLogPriority : int32_t;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-enum MeminfoCounters : int32_t;
-namespace perfetto_pbzero_enum_SysStatsConfig {
-enum StatCounters : int32_t;
-}  // namespace perfetto_pbzero_enum_SysStatsConfig
-using SysStatsConfig_StatCounters = perfetto_pbzero_enum_SysStatsConfig::StatCounters;
-enum VmstatCounters : int32_t;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-namespace perfetto_pbzero_enum_SysStatsConfig {
-enum StatCounters : int32_t {
-  STAT_UNSPECIFIED = 0,
-  STAT_CPU_TIMES = 1,
-  STAT_IRQ_COUNTS = 2,
-  STAT_SOFTIRQ_COUNTS = 3,
-  STAT_FORK_COUNT = 4,
+class AndroidLogConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  AndroidLogConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidLogConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidLogConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_log_ids() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> log_ids() const { return GetRepeated<int32_t>(1); }
+  bool has_min_prio() const { return at<3>().valid(); }
+  int32_t min_prio() const { return at<3>().as_int32(); }
+  bool has_filter_tags() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> filter_tags() const { return GetRepeated<::protozero::ConstChars>(4); }
+  bool has_preserve_log_buffer() const { return at<5>().valid(); }
+  bool preserve_log_buffer() const { return at<5>().as_bool(); }
 };
-} // namespace perfetto_pbzero_enum_SysStatsConfig
-using SysStatsConfig_StatCounters = perfetto_pbzero_enum_SysStatsConfig::StatCounters;
 
+class AndroidLogConfig : public ::protozero::Message {
+ public:
+  using Decoder = AndroidLogConfig_Decoder;
+  enum : int32_t {
+    kLogIdsFieldNumber = 1,
+    kMinPrioFieldNumber = 3,
+    kFilterTagsFieldNumber = 4,
+    kPreserveLogBufferFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidLogConfig"; }
 
-constexpr SysStatsConfig_StatCounters SysStatsConfig_StatCounters_MIN = SysStatsConfig_StatCounters::STAT_UNSPECIFIED;
-constexpr SysStatsConfig_StatCounters SysStatsConfig_StatCounters_MAX = SysStatsConfig_StatCounters::STAT_FORK_COUNT;
 
+  using FieldMetadata_LogIds =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      AndroidLogId,
+      AndroidLogConfig>;
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* SysStatsConfig_StatCounters_Name(::perfetto::protos::pbzero::SysStatsConfig_StatCounters value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::SysStatsConfig_StatCounters::STAT_UNSPECIFIED:
-    return "STAT_UNSPECIFIED";
+  static constexpr FieldMetadata_LogIds kLogIds{};
+  void add_log_ids(AndroidLogId value) {
+    static constexpr uint32_t field_id = FieldMetadata_LogIds::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
 
-  case ::perfetto::protos::pbzero::SysStatsConfig_StatCounters::STAT_CPU_TIMES:
-    return "STAT_CPU_TIMES";
+  using FieldMetadata_MinPrio =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      AndroidLogPriority,
+      AndroidLogConfig>;
 
-  case ::perfetto::protos::pbzero::SysStatsConfig_StatCounters::STAT_IRQ_COUNTS:
-    return "STAT_IRQ_COUNTS";
+  static constexpr FieldMetadata_MinPrio kMinPrio{};
+  void set_min_prio(AndroidLogPriority value) {
+    static constexpr uint32_t field_id = FieldMetadata_MinPrio::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
 
-  case ::perfetto::protos::pbzero::SysStatsConfig_StatCounters::STAT_SOFTIRQ_COUNTS:
-    return "STAT_SOFTIRQ_COUNTS";
+  using FieldMetadata_FilterTags =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      AndroidLogConfig>;
 
-  case ::perfetto::protos::pbzero::SysStatsConfig_StatCounters::STAT_FORK_COUNT:
-    return "STAT_FORK_COUNT";
+  static constexpr FieldMetadata_FilterTags kFilterTags{};
+  void add_filter_tags(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_FilterTags::kFieldId, data, size);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+  void add_filter_tags(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_FilterTags::kFieldId, chars.data, chars.size);
+  }
+  void add_filter_tags(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_FilterTags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PreserveLogBuffer =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      AndroidLogConfig>;
+
+  static constexpr FieldMetadata_PreserveLogBuffer kPreserveLogBuffer{};
+  void set_preserve_log_buffer(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_PreserveLogBuffer::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_polled_state_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_POLLED_STATE_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_POLLED_STATE_CONFIG_PROTO_H_
 
-class SysStatsConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class AndroidPolledStateConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  SysStatsConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SysStatsConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SysStatsConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_meminfo_period_ms() const { return at<1>().valid(); }
-  uint32_t meminfo_period_ms() const { return at<1>().as_uint32(); }
-  bool has_meminfo_counters() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<int32_t> meminfo_counters() const { return GetRepeated<int32_t>(2); }
-  bool has_vmstat_period_ms() const { return at<3>().valid(); }
-  uint32_t vmstat_period_ms() const { return at<3>().as_uint32(); }
-  bool has_vmstat_counters() const { return at<4>().valid(); }
-  ::protozero::RepeatedFieldIterator<int32_t> vmstat_counters() const { return GetRepeated<int32_t>(4); }
-  bool has_stat_period_ms() const { return at<5>().valid(); }
-  uint32_t stat_period_ms() const { return at<5>().as_uint32(); }
-  bool has_stat_counters() const { return at<6>().valid(); }
-  ::protozero::RepeatedFieldIterator<int32_t> stat_counters() const { return GetRepeated<int32_t>(6); }
-  bool has_devfreq_period_ms() const { return at<7>().valid(); }
-  uint32_t devfreq_period_ms() const { return at<7>().as_uint32(); }
-  bool has_cpufreq_period_ms() const { return at<8>().valid(); }
-  uint32_t cpufreq_period_ms() const { return at<8>().as_uint32(); }
-  bool has_buddyinfo_period_ms() const { return at<9>().valid(); }
-  uint32_t buddyinfo_period_ms() const { return at<9>().as_uint32(); }
-  bool has_diskstat_period_ms() const { return at<10>().valid(); }
-  uint32_t diskstat_period_ms() const { return at<10>().as_uint32(); }
+  AndroidPolledStateConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidPolledStateConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidPolledStateConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_poll_ms() const { return at<1>().valid(); }
+  uint32_t poll_ms() const { return at<1>().as_uint32(); }
 };
 
-class SysStatsConfig : public ::protozero::Message {
+class AndroidPolledStateConfig : public ::protozero::Message {
  public:
-  using Decoder = SysStatsConfig_Decoder;
+  using Decoder = AndroidPolledStateConfig_Decoder;
   enum : int32_t {
-    kMeminfoPeriodMsFieldNumber = 1,
-    kMeminfoCountersFieldNumber = 2,
-    kVmstatPeriodMsFieldNumber = 3,
-    kVmstatCountersFieldNumber = 4,
-    kStatPeriodMsFieldNumber = 5,
-    kStatCountersFieldNumber = 6,
-    kDevfreqPeriodMsFieldNumber = 7,
-    kCpufreqPeriodMsFieldNumber = 8,
-    kBuddyinfoPeriodMsFieldNumber = 9,
-    kDiskstatPeriodMsFieldNumber = 10,
+    kPollMsFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SysStatsConfig"; }
-
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidPolledStateConfig"; }
 
-  using StatCounters = ::perfetto::protos::pbzero::SysStatsConfig_StatCounters;
-  static inline const char* StatCounters_Name(StatCounters value) {
-    return ::perfetto::protos::pbzero::SysStatsConfig_StatCounters_Name(value);
-  }
-  static const StatCounters STAT_UNSPECIFIED = StatCounters::STAT_UNSPECIFIED;
-  static const StatCounters STAT_CPU_TIMES = StatCounters::STAT_CPU_TIMES;
-  static const StatCounters STAT_IRQ_COUNTS = StatCounters::STAT_IRQ_COUNTS;
-  static const StatCounters STAT_SOFTIRQ_COUNTS = StatCounters::STAT_SOFTIRQ_COUNTS;
-  static const StatCounters STAT_FORK_COUNT = StatCounters::STAT_FORK_COUNT;
 
-  using FieldMetadata_MeminfoPeriodMs =
+  using FieldMetadata_PollMs =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SysStatsConfig>;
+      AndroidPolledStateConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MeminfoPeriodMs kMeminfoPeriodMs() { return {}; }
-  void set_meminfo_period_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MeminfoPeriodMs::kFieldId;
+  static constexpr FieldMetadata_PollMs kPollMs{};
+  void set_poll_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PollMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_MeminfoCounters =
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_sdk_sysprop_guard_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_SDK_SYSPROP_GUARD_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_SDK_SYSPROP_GUARD_CONFIG_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class AndroidSdkSyspropGuardConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  AndroidSdkSyspropGuardConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidSdkSyspropGuardConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidSdkSyspropGuardConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_surfaceflinger_skia_track_events() const { return at<1>().valid(); }
+  bool surfaceflinger_skia_track_events() const { return at<1>().as_bool(); }
+  bool has_hwui_skia_track_events() const { return at<2>().valid(); }
+  bool hwui_skia_track_events() const { return at<2>().as_bool(); }
+  bool has_hwui_package_name_filter() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> hwui_package_name_filter() const { return GetRepeated<::protozero::ConstChars>(3); }
+};
+
+class AndroidSdkSyspropGuardConfig : public ::protozero::Message {
+ public:
+  using Decoder = AndroidSdkSyspropGuardConfig_Decoder;
+  enum : int32_t {
+    kSurfaceflingerSkiaTrackEventsFieldNumber = 1,
+    kHwuiSkiaTrackEventsFieldNumber = 2,
+    kHwuiPackageNameFilterFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidSdkSyspropGuardConfig"; }
+
+
+  using FieldMetadata_SurfaceflingerSkiaTrackEvents =
     ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::MeminfoCounters,
-      SysStatsConfig>;
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      AndroidSdkSyspropGuardConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MeminfoCounters kMeminfoCounters() { return {}; }
-  void add_meminfo_counters(::perfetto::protos::pbzero::MeminfoCounters value) {
-    static constexpr uint32_t field_id = FieldMetadata_MeminfoCounters::kFieldId;
+  static constexpr FieldMetadata_SurfaceflingerSkiaTrackEvents kSurfaceflingerSkiaTrackEvents{};
+  void set_surfaceflinger_skia_track_events(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_SurfaceflingerSkiaTrackEvents::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VmstatPeriodMs =
+  using FieldMetadata_HwuiSkiaTrackEvents =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SysStatsConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      AndroidSdkSyspropGuardConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VmstatPeriodMs kVmstatPeriodMs() { return {}; }
-  void set_vmstat_period_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VmstatPeriodMs::kFieldId;
+  static constexpr FieldMetadata_HwuiSkiaTrackEvents kHwuiSkiaTrackEvents{};
+  void set_hwui_skia_track_events(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_HwuiSkiaTrackEvents::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VmstatCounters =
+  using FieldMetadata_HwuiPackageNameFilter =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      3,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::VmstatCounters,
-      SysStatsConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      AndroidSdkSyspropGuardConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VmstatCounters kVmstatCounters() { return {}; }
-  void add_vmstat_counters(::perfetto::protos::pbzero::VmstatCounters value) {
-    static constexpr uint32_t field_id = FieldMetadata_VmstatCounters::kFieldId;
+  static constexpr FieldMetadata_HwuiPackageNameFilter kHwuiPackageNameFilter{};
+  void add_hwui_package_name_filter(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_HwuiPackageNameFilter::kFieldId, data, size);
+  }
+  void add_hwui_package_name_filter(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_HwuiPackageNameFilter::kFieldId, chars.data, chars.size);
+  }
+  void add_hwui_package_name_filter(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_HwuiPackageNameFilter::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_StatPeriodMs =
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_system_property_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_SYSTEM_PROPERTY_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_SYSTEM_PROPERTY_CONFIG_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class AndroidSystemPropertyConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  AndroidSystemPropertyConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidSystemPropertyConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidSystemPropertyConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_poll_ms() const { return at<1>().valid(); }
+  uint32_t poll_ms() const { return at<1>().as_uint32(); }
+  bool has_property_name() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> property_name() const { return GetRepeated<::protozero::ConstChars>(2); }
+};
+
+class AndroidSystemPropertyConfig : public ::protozero::Message {
+ public:
+  using Decoder = AndroidSystemPropertyConfig_Decoder;
+  enum : int32_t {
+    kPollMsFieldNumber = 1,
+    kPropertyNameFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidSystemPropertyConfig"; }
+
+
+  using FieldMetadata_PollMs =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SysStatsConfig>;
+      AndroidSystemPropertyConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StatPeriodMs kStatPeriodMs() { return {}; }
-  void set_stat_period_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StatPeriodMs::kFieldId;
+  static constexpr FieldMetadata_PollMs kPollMs{};
+  void set_poll_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PollMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -38893,128 +46682,130 @@ class SysStatsConfig : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_StatCounters =
+  using FieldMetadata_PropertyName =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      2,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::SysStatsConfig_StatCounters,
-      SysStatsConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      AndroidSystemPropertyConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StatCounters kStatCounters() { return {}; }
-  void add_stat_counters(::perfetto::protos::pbzero::SysStatsConfig_StatCounters value) {
-    static constexpr uint32_t field_id = FieldMetadata_StatCounters::kFieldId;
+  static constexpr FieldMetadata_PropertyName kPropertyName{};
+  void add_property_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_PropertyName::kFieldId, data, size);
+  }
+  void add_property_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_PropertyName::kFieldId, chars.data, chars.size);
+  }
+  void add_property_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_PropertyName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_DevfreqPeriodMs =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SysStatsConfig>;
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/app_wakelock_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DevfreqPeriodMs kDevfreqPeriodMs() { return {}; }
-  void set_devfreq_period_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DevfreqPeriodMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_APP_WAKELOCK_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_APP_WAKELOCK_CONFIG_PROTO_H_
 
-  using FieldMetadata_CpufreqPeriodMs =
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class AppWakelocksConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  AppWakelocksConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AppWakelocksConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AppWakelocksConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_write_delay_ms() const { return at<1>().valid(); }
+  int32_t write_delay_ms() const { return at<1>().as_int32(); }
+  bool has_filter_duration_below_ms() const { return at<2>().valid(); }
+  int32_t filter_duration_below_ms() const { return at<2>().as_int32(); }
+  bool has_drop_owner_pid() const { return at<3>().valid(); }
+  bool drop_owner_pid() const { return at<3>().as_bool(); }
+};
+
+class AppWakelocksConfig : public ::protozero::Message {
+ public:
+  using Decoder = AppWakelocksConfig_Decoder;
+  enum : int32_t {
+    kWriteDelayMsFieldNumber = 1,
+    kFilterDurationBelowMsFieldNumber = 2,
+    kDropOwnerPidFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AppWakelocksConfig"; }
+
+
+  using FieldMetadata_WriteDelayMs =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SysStatsConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      AppWakelocksConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpufreqPeriodMs kCpufreqPeriodMs() { return {}; }
-  void set_cpufreq_period_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CpufreqPeriodMs::kFieldId;
+  static constexpr FieldMetadata_WriteDelayMs kWriteDelayMs{};
+  void set_write_delay_ms(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_WriteDelayMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BuddyinfoPeriodMs =
+  using FieldMetadata_FilterDurationBelowMs =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SysStatsConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      AppWakelocksConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BuddyinfoPeriodMs kBuddyinfoPeriodMs() { return {}; }
-  void set_buddyinfo_period_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BuddyinfoPeriodMs::kFieldId;
+  static constexpr FieldMetadata_FilterDurationBelowMs kFilterDurationBelowMs{};
+  void set_filter_duration_below_ms(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FilterDurationBelowMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DiskstatPeriodMs =
+  using FieldMetadata_DropOwnerPid =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SysStatsConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      AppWakelocksConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DiskstatPeriodMs kDiskstatPeriodMs() { return {}; }
-  void set_diskstat_period_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DiskstatPeriodMs::kFieldId;
+  static constexpr FieldMetadata_DropOwnerPid kDropOwnerPid{};
+  void set_drop_owner_pid(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DropOwnerPid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 };
@@ -39023,11 +46814,11 @@ class SysStatsConfig : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/system_info/system_info.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/cpu_per_uid_config.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYSTEM_INFO_SYSTEM_INFO_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYSTEM_INFO_SYSTEM_INFO_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_CPU_PER_UID_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_CPU_PER_UID_CONFIG_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -39038,34 +46829,57 @@ class SysStatsConfig : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class SystemInfoConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class CpuPerUidConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  SystemInfoConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SystemInfoConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SystemInfoConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  CpuPerUidConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit CpuPerUidConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit CpuPerUidConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_poll_ms() const { return at<1>().valid(); }
+  uint32_t poll_ms() const { return at<1>().as_uint32(); }
 };
 
-class SystemInfoConfig : public ::protozero::Message {
+class CpuPerUidConfig : public ::protozero::Message {
  public:
-  using Decoder = SystemInfoConfig_Decoder;
-  static constexpr const char* GetName() { return ".perfetto.protos.SystemInfoConfig"; }
+  using Decoder = CpuPerUidConfig_Decoder;
+  enum : int32_t {
+    kPollMsFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.CpuPerUidConfig"; }
+
+
+  using FieldMetadata_PollMs =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      CpuPerUidConfig>;
 
+  static constexpr FieldMetadata_PollMs kPollMs{};
+  void set_poll_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PollMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 };
 
 } // Namespace.
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/track_event/track_event_config.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/inputmethod_config.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TRACK_EVENT_TRACK_EVENT_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TRACK_EVENT_TRACK_EVENT_CONFIG_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_INPUTMETHOD_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_INPUTMETHOD_CONFIG_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -39076,245 +46890,273 @@ class SystemInfoConfig : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class TrackEventConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class InputMethodConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  TrackEventConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrackEventConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrackEventConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_disabled_categories() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> disabled_categories() const { return GetRepeated<::protozero::ConstChars>(1); }
-  bool has_enabled_categories() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> enabled_categories() const { return GetRepeated<::protozero::ConstChars>(2); }
-  bool has_disabled_tags() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> disabled_tags() const { return GetRepeated<::protozero::ConstChars>(3); }
-  bool has_enabled_tags() const { return at<4>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> enabled_tags() const { return GetRepeated<::protozero::ConstChars>(4); }
-  bool has_disable_incremental_timestamps() const { return at<5>().valid(); }
-  bool disable_incremental_timestamps() const { return at<5>().as_bool(); }
-  bool has_timestamp_unit_multiplier() const { return at<6>().valid(); }
-  uint64_t timestamp_unit_multiplier() const { return at<6>().as_uint64(); }
-  bool has_filter_debug_annotations() const { return at<7>().valid(); }
-  bool filter_debug_annotations() const { return at<7>().as_bool(); }
-  bool has_enable_thread_time_sampling() const { return at<8>().valid(); }
-  bool enable_thread_time_sampling() const { return at<8>().as_bool(); }
-  bool has_filter_dynamic_event_names() const { return at<9>().valid(); }
-  bool filter_dynamic_event_names() const { return at<9>().as_bool(); }
+  InputMethodConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit InputMethodConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit InputMethodConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_client() const { return at<1>().valid(); }
+  bool client() const { return at<1>().as_bool(); }
+  bool has_service() const { return at<2>().valid(); }
+  bool service() const { return at<2>().as_bool(); }
+  bool has_manager_service() const { return at<3>().valid(); }
+  bool manager_service() const { return at<3>().as_bool(); }
 };
 
-class TrackEventConfig : public ::protozero::Message {
+class InputMethodConfig : public ::protozero::Message {
  public:
-  using Decoder = TrackEventConfig_Decoder;
+  using Decoder = InputMethodConfig_Decoder;
   enum : int32_t {
-    kDisabledCategoriesFieldNumber = 1,
-    kEnabledCategoriesFieldNumber = 2,
-    kDisabledTagsFieldNumber = 3,
-    kEnabledTagsFieldNumber = 4,
-    kDisableIncrementalTimestampsFieldNumber = 5,
-    kTimestampUnitMultiplierFieldNumber = 6,
-    kFilterDebugAnnotationsFieldNumber = 7,
-    kEnableThreadTimeSamplingFieldNumber = 8,
-    kFilterDynamicEventNamesFieldNumber = 9,
+    kClientFieldNumber = 1,
+    kServiceFieldNumber = 2,
+    kManagerServiceFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrackEventConfig"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.InputMethodConfig"; }
 
 
-  using FieldMetadata_DisabledCategories =
+  using FieldMetadata_Client =
     ::protozero::proto_utils::FieldMetadata<
       1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TrackEventConfig>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      InputMethodConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DisabledCategories kDisabledCategories() { return {}; }
-  void add_disabled_categories(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_DisabledCategories::kFieldId, data, size);
-  }
-  void add_disabled_categories(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_DisabledCategories::kFieldId, chars.data, chars.size);
-  }
-  void add_disabled_categories(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_DisabledCategories::kFieldId;
+  static constexpr FieldMetadata_Client kClient{};
+  void set_client(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_Client::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_EnabledCategories =
+  using FieldMetadata_Service =
     ::protozero::proto_utils::FieldMetadata<
       2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TrackEventConfig>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      InputMethodConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EnabledCategories kEnabledCategories() { return {}; }
-  void add_enabled_categories(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_EnabledCategories::kFieldId, data, size);
-  }
-  void add_enabled_categories(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_EnabledCategories::kFieldId, chars.data, chars.size);
-  }
-  void add_enabled_categories(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_EnabledCategories::kFieldId;
+  static constexpr FieldMetadata_Service kService{};
+  void set_service(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_Service::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DisabledTags =
+  using FieldMetadata_ManagerService =
     ::protozero::proto_utils::FieldMetadata<
       3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TrackEventConfig>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      InputMethodConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DisabledTags kDisabledTags() { return {}; }
-  void add_disabled_tags(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_DisabledTags::kFieldId, data, size);
-  }
-  void add_disabled_tags(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_DisabledTags::kFieldId, chars.data, chars.size);
-  }
-  void add_disabled_tags(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_DisabledTags::kFieldId;
+  static constexpr FieldMetadata_ManagerService kManagerService{};
+  void set_manager_service(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ManagerService::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_EnabledTags =
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/kernel_wakelocks_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_KERNEL_WAKELOCKS_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_KERNEL_WAKELOCKS_CONFIG_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class KernelWakelocksConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  KernelWakelocksConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KernelWakelocksConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KernelWakelocksConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_poll_ms() const { return at<1>().valid(); }
+  uint32_t poll_ms() const { return at<1>().as_uint32(); }
+};
+
+class KernelWakelocksConfig : public ::protozero::Message {
+ public:
+  using Decoder = KernelWakelocksConfig_Decoder;
+  enum : int32_t {
+    kPollMsFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KernelWakelocksConfig"; }
+
+
+  using FieldMetadata_PollMs =
     ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TrackEventConfig>;
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KernelWakelocksConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EnabledTags kEnabledTags() { return {}; }
-  void add_enabled_tags(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_EnabledTags::kFieldId, data, size);
-  }
-  void add_enabled_tags(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_EnabledTags::kFieldId, chars.data, chars.size);
+  static constexpr FieldMetadata_PollMs kPollMs{};
+  void set_poll_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PollMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
-  void add_enabled_tags(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_EnabledTags::kFieldId;
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/network_trace_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_NETWORK_TRACE_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_NETWORK_TRACE_CONFIG_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class NetworkPacketTraceConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
+ public:
+  NetworkPacketTraceConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit NetworkPacketTraceConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit NetworkPacketTraceConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_poll_ms() const { return at<1>().valid(); }
+  uint32_t poll_ms() const { return at<1>().as_uint32(); }
+  bool has_aggregation_threshold() const { return at<2>().valid(); }
+  uint32_t aggregation_threshold() const { return at<2>().as_uint32(); }
+  bool has_intern_limit() const { return at<3>().valid(); }
+  uint32_t intern_limit() const { return at<3>().as_uint32(); }
+  bool has_drop_local_port() const { return at<4>().valid(); }
+  bool drop_local_port() const { return at<4>().as_bool(); }
+  bool has_drop_remote_port() const { return at<5>().valid(); }
+  bool drop_remote_port() const { return at<5>().as_bool(); }
+  bool has_drop_tcp_flags() const { return at<6>().valid(); }
+  bool drop_tcp_flags() const { return at<6>().as_bool(); }
+};
+
+class NetworkPacketTraceConfig : public ::protozero::Message {
+ public:
+  using Decoder = NetworkPacketTraceConfig_Decoder;
+  enum : int32_t {
+    kPollMsFieldNumber = 1,
+    kAggregationThresholdFieldNumber = 2,
+    kInternLimitFieldNumber = 3,
+    kDropLocalPortFieldNumber = 4,
+    kDropRemotePortFieldNumber = 5,
+    kDropTcpFlagsFieldNumber = 6,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.NetworkPacketTraceConfig"; }
+
+
+  using FieldMetadata_PollMs =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      NetworkPacketTraceConfig>;
+
+  static constexpr FieldMetadata_PollMs kPollMs{};
+  void set_poll_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PollMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DisableIncrementalTimestamps =
+  using FieldMetadata_AggregationThreshold =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TrackEventConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      NetworkPacketTraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DisableIncrementalTimestamps kDisableIncrementalTimestamps() { return {}; }
-  void set_disable_incremental_timestamps(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DisableIncrementalTimestamps::kFieldId;
+  static constexpr FieldMetadata_AggregationThreshold kAggregationThreshold{};
+  void set_aggregation_threshold(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AggregationThreshold::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimestampUnitMultiplier =
+  using FieldMetadata_InternLimit =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TrackEventConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      NetworkPacketTraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimestampUnitMultiplier kTimestampUnitMultiplier() { return {}; }
-  void set_timestamp_unit_multiplier(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimestampUnitMultiplier::kFieldId;
+  static constexpr FieldMetadata_InternLimit kInternLimit{};
+  void set_intern_limit(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InternLimit::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FilterDebugAnnotations =
+  using FieldMetadata_DropLocalPort =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kBool,
       bool,
-      TrackEventConfig>;
+      NetworkPacketTraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FilterDebugAnnotations kFilterDebugAnnotations() { return {}; }
-  void set_filter_debug_annotations(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_FilterDebugAnnotations::kFieldId;
+  static constexpr FieldMetadata_DropLocalPort kDropLocalPort{};
+  void set_drop_local_port(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DropLocalPort::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -39322,24 +47164,17 @@ class TrackEventConfig : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_EnableThreadTimeSampling =
+  using FieldMetadata_DropRemotePort =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kBool,
       bool,
-      TrackEventConfig>;
+      NetworkPacketTraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EnableThreadTimeSampling kEnableThreadTimeSampling() { return {}; }
-  void set_enable_thread_time_sampling(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_EnableThreadTimeSampling::kFieldId;
+  static constexpr FieldMetadata_DropRemotePort kDropRemotePort{};
+  void set_drop_remote_port(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DropRemotePort::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -39347,24 +47182,17 @@ class TrackEventConfig : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FilterDynamicEventNames =
+  using FieldMetadata_DropTcpFlags =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kBool,
       bool,
-      TrackEventConfig>;
+      NetworkPacketTraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FilterDynamicEventNames kFilterDynamicEventNames() { return {}; }
-  void set_filter_dynamic_event_names(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_FilterDynamicEventNames::kFieldId;
+  static constexpr FieldMetadata_DropTcpFlags kDropTcpFlags{};
+  void set_drop_tcp_flags(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DropTcpFlags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -39377,11 +47205,11 @@ class TrackEventConfig : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/chrome/chrome_config.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/packages_list_config.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_CHROME_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_CHROME_CONFIG_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PACKAGES_LIST_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PACKAGES_LIST_CONFIG_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -39392,106 +47220,49 @@ class TrackEventConfig : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-namespace perfetto_pbzero_enum_ChromeConfig {
-enum ClientPriority : int32_t;
-}  // namespace perfetto_pbzero_enum_ChromeConfig
-using ChromeConfig_ClientPriority = perfetto_pbzero_enum_ChromeConfig::ClientPriority;
-
-namespace perfetto_pbzero_enum_ChromeConfig {
-enum ClientPriority : int32_t {
-  UNKNOWN = 0,
-  BACKGROUND = 1,
-  USER_INITIATED = 2,
-};
-} // namespace perfetto_pbzero_enum_ChromeConfig
-using ChromeConfig_ClientPriority = perfetto_pbzero_enum_ChromeConfig::ClientPriority;
-
-
-constexpr ChromeConfig_ClientPriority ChromeConfig_ClientPriority_MIN = ChromeConfig_ClientPriority::UNKNOWN;
-constexpr ChromeConfig_ClientPriority ChromeConfig_ClientPriority_MAX = ChromeConfig_ClientPriority::USER_INITIATED;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ChromeConfig_ClientPriority_Name(::perfetto::protos::pbzero::ChromeConfig_ClientPriority value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ChromeConfig_ClientPriority::UNKNOWN:
-    return "UNKNOWN";
-
-  case ::perfetto::protos::pbzero::ChromeConfig_ClientPriority::BACKGROUND:
-    return "BACKGROUND";
-
-  case ::perfetto::protos::pbzero::ChromeConfig_ClientPriority::USER_INITIATED:
-    return "USER_INITIATED";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-class ChromeConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class PackagesListConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  ChromeConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_trace_config() const { return at<1>().valid(); }
-  ::protozero::ConstChars trace_config() const { return at<1>().as_string(); }
-  bool has_privacy_filtering_enabled() const { return at<2>().valid(); }
-  bool privacy_filtering_enabled() const { return at<2>().as_bool(); }
-  bool has_convert_to_legacy_json() const { return at<3>().valid(); }
-  bool convert_to_legacy_json() const { return at<3>().as_bool(); }
-  bool has_client_priority() const { return at<4>().valid(); }
-  int32_t client_priority() const { return at<4>().as_int32(); }
-  bool has_json_agent_label_filter() const { return at<5>().valid(); }
-  ::protozero::ConstChars json_agent_label_filter() const { return at<5>().as_string(); }
+  PackagesListConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PackagesListConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PackagesListConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_package_name_filter() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> package_name_filter() const { return GetRepeated<::protozero::ConstChars>(1); }
+  bool has_only_write_on_cpu_use_every_ms() const { return at<2>().valid(); }
+  uint32_t only_write_on_cpu_use_every_ms() const { return at<2>().as_uint32(); }
 };
 
-class ChromeConfig : public ::protozero::Message {
+class PackagesListConfig : public ::protozero::Message {
  public:
-  using Decoder = ChromeConfig_Decoder;
+  using Decoder = PackagesListConfig_Decoder;
   enum : int32_t {
-    kTraceConfigFieldNumber = 1,
-    kPrivacyFilteringEnabledFieldNumber = 2,
-    kConvertToLegacyJsonFieldNumber = 3,
-    kClientPriorityFieldNumber = 4,
-    kJsonAgentLabelFilterFieldNumber = 5,
+    kPackageNameFilterFieldNumber = 1,
+    kOnlyWriteOnCpuUseEveryMsFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeConfig"; }
-
+  static constexpr const char* GetName() { return ".perfetto.protos.PackagesListConfig"; }
 
-  using ClientPriority = ::perfetto::protos::pbzero::ChromeConfig_ClientPriority;
-  static inline const char* ClientPriority_Name(ClientPriority value) {
-    return ::perfetto::protos::pbzero::ChromeConfig_ClientPriority_Name(value);
-  }
-  static const ClientPriority UNKNOWN = ClientPriority::UNKNOWN;
-  static const ClientPriority BACKGROUND = ClientPriority::BACKGROUND;
-  static const ClientPriority USER_INITIATED = ClientPriority::USER_INITIATED;
 
-  using FieldMetadata_TraceConfig =
+  using FieldMetadata_PackageNameFilter =
     ::protozero::proto_utils::FieldMetadata<
       1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      ChromeConfig>;
+      PackagesListConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceConfig kTraceConfig() { return {}; }
-  void set_trace_config(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_TraceConfig::kFieldId, data, size);
+  static constexpr FieldMetadata_PackageNameFilter kPackageNameFilter{};
+  void add_package_name_filter(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_PackageNameFilter::kFieldId, data, size);
   }
-  void set_trace_config(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_TraceConfig::kFieldId, chars.data, chars.size);
+  void add_package_name_filter(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_PackageNameFilter::kFieldId, chars.data, chars.size);
   }
-  void set_trace_config(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_TraceConfig::kFieldId;
+  void add_package_name_filter(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_PackageNameFilter::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -39499,109 +47270,171 @@ class ChromeConfig : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PrivacyFilteringEnabled =
+  using FieldMetadata_OnlyWriteOnCpuUseEveryMs =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      PackagesListConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PrivacyFilteringEnabled kPrivacyFilteringEnabled() { return {}; }
-  void set_privacy_filtering_enabled(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_PrivacyFilteringEnabled::kFieldId;
+  static constexpr FieldMetadata_OnlyWriteOnCpuUseEveryMs kOnlyWriteOnCpuUseEveryMs{};
+  void set_only_write_on_cpu_use_every_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OnlyWriteOnCpuUseEveryMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_ConvertToLegacyJson =
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/pixel_modem_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PIXEL_MODEM_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PIXEL_MODEM_CONFIG_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+namespace perfetto_pbzero_enum_PixelModemConfig {
+enum EventGroup : int32_t;
+}  // namespace perfetto_pbzero_enum_PixelModemConfig
+using PixelModemConfig_EventGroup = perfetto_pbzero_enum_PixelModemConfig::EventGroup;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_PixelModemConfig {
+enum EventGroup : int32_t {
+  EVENT_GROUP_UNKNOWN = 0,
+  EVENT_GROUP_LOW_BANDWIDTH = 1,
+  EVENT_GROUP_HIGH_AND_LOW_BANDWIDTH = 2,
+};
+} // namespace perfetto_pbzero_enum_PixelModemConfig
+using PixelModemConfig_EventGroup = perfetto_pbzero_enum_PixelModemConfig::EventGroup;
+
+
+constexpr PixelModemConfig_EventGroup PixelModemConfig_EventGroup_MIN = PixelModemConfig_EventGroup::EVENT_GROUP_UNKNOWN;
+constexpr PixelModemConfig_EventGroup PixelModemConfig_EventGroup_MAX = PixelModemConfig_EventGroup::EVENT_GROUP_HIGH_AND_LOW_BANDWIDTH;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* PixelModemConfig_EventGroup_Name(::perfetto::protos::pbzero::PixelModemConfig_EventGroup value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::PixelModemConfig_EventGroup::EVENT_GROUP_UNKNOWN:
+    return "EVENT_GROUP_UNKNOWN";
+
+  case ::perfetto::protos::pbzero::PixelModemConfig_EventGroup::EVENT_GROUP_LOW_BANDWIDTH:
+    return "EVENT_GROUP_LOW_BANDWIDTH";
+
+  case ::perfetto::protos::pbzero::PixelModemConfig_EventGroup::EVENT_GROUP_HIGH_AND_LOW_BANDWIDTH:
+    return "EVENT_GROUP_HIGH_AND_LOW_BANDWIDTH";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class PixelModemConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  PixelModemConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PixelModemConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PixelModemConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_event_group() const { return at<1>().valid(); }
+  int32_t event_group() const { return at<1>().as_int32(); }
+  bool has_pigweed_hash_allow_list() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<int64_t> pigweed_hash_allow_list() const { return GetRepeated<int64_t>(2); }
+  bool has_pigweed_hash_deny_list() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<int64_t> pigweed_hash_deny_list() const { return GetRepeated<int64_t>(3); }
+};
+
+class PixelModemConfig : public ::protozero::Message {
+ public:
+  using Decoder = PixelModemConfig_Decoder;
+  enum : int32_t {
+    kEventGroupFieldNumber = 1,
+    kPigweedHashAllowListFieldNumber = 2,
+    kPigweedHashDenyListFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.PixelModemConfig"; }
+
+
+  using EventGroup = ::perfetto::protos::pbzero::PixelModemConfig_EventGroup;
+  static inline const char* EventGroup_Name(EventGroup value) {
+    return ::perfetto::protos::pbzero::PixelModemConfig_EventGroup_Name(value);
+  }
+  static inline const EventGroup EVENT_GROUP_UNKNOWN = EventGroup::EVENT_GROUP_UNKNOWN;
+  static inline const EventGroup EVENT_GROUP_LOW_BANDWIDTH = EventGroup::EVENT_GROUP_LOW_BANDWIDTH;
+  static inline const EventGroup EVENT_GROUP_HIGH_AND_LOW_BANDWIDTH = EventGroup::EVENT_GROUP_HIGH_AND_LOW_BANDWIDTH;
+
+  using FieldMetadata_EventGroup =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      PixelModemConfig_EventGroup,
+      PixelModemConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ConvertToLegacyJson kConvertToLegacyJson() { return {}; }
-  void set_convert_to_legacy_json(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_ConvertToLegacyJson::kFieldId;
+  static constexpr FieldMetadata_EventGroup kEventGroup{};
+  void set_event_group(PixelModemConfig_EventGroup value) {
+    static constexpr uint32_t field_id = FieldMetadata_EventGroup::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ClientPriority =
+  using FieldMetadata_PigweedHashAllowList =
     ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ChromeConfig_ClientPriority,
-      ChromeConfig>;
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      PixelModemConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClientPriority kClientPriority() { return {}; }
-  void set_client_priority(::perfetto::protos::pbzero::ChromeConfig_ClientPriority value) {
-    static constexpr uint32_t field_id = FieldMetadata_ClientPriority::kFieldId;
+  static constexpr FieldMetadata_PigweedHashAllowList kPigweedHashAllowList{};
+  void add_pigweed_hash_allow_list(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PigweedHashAllowList::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_JsonAgentLabelFilter =
+  using FieldMetadata_PigweedHashDenyList =
     ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeConfig>;
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      PixelModemConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_JsonAgentLabelFilter kJsonAgentLabelFilter() { return {}; }
-  void set_json_agent_label_filter(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_JsonAgentLabelFilter::kFieldId, data, size);
-  }
-  void set_json_agent_label_filter(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_JsonAgentLabelFilter::kFieldId, chars.data, chars.size);
-  }
-  void set_json_agent_label_filter(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_JsonAgentLabelFilter::kFieldId;
+  static constexpr FieldMetadata_PigweedHashDenyList kPigweedHashDenyList{};
+  void add_pigweed_hash_deny_list(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PigweedHashDenyList::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 };
@@ -39610,11 +47443,11 @@ class ChromeConfig : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/data_source_config.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/protolog_config.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_DATA_SOURCE_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_DATA_SOURCE_CONFIG_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PROTOLOG_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PROTOLOG_CONFIG_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -39628,196 +47461,86 @@ class ChromeConfig : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
+class ProtoLogGroup;
+namespace perfetto_pbzero_enum_ProtoLogConfig {
+enum TracingMode : int32_t;
+}  // namespace perfetto_pbzero_enum_ProtoLogConfig
+using ProtoLogConfig_TracingMode = perfetto_pbzero_enum_ProtoLogConfig::TracingMode;
+enum ProtoLogLevel : int32_t;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-class AndroidGameInterventionListConfig;
-class AndroidLogConfig;
-class AndroidPolledStateConfig;
-class AndroidPowerConfig;
-class AndroidSystemPropertyConfig;
-class ChromeConfig;
-class FtraceConfig;
-class GpuCounterConfig;
-class HeapprofdConfig;
-class InodeFileConfig;
-class InterceptorConfig;
-class JavaHprofConfig;
-class NetworkPacketTraceConfig;
-class PackagesListConfig;
-class PerfEventConfig;
-class ProcessStatsConfig;
-class StatsdTracingConfig;
-class SysStatsConfig;
-class SystemInfoConfig;
-class TestConfig;
-class TrackEventConfig;
-class VulkanMemoryConfig;
-namespace perfetto_pbzero_enum_DataSourceConfig {
-enum SessionInitiator : int32_t;
-}  // namespace perfetto_pbzero_enum_DataSourceConfig
-using DataSourceConfig_SessionInitiator = perfetto_pbzero_enum_DataSourceConfig::SessionInitiator;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-namespace perfetto_pbzero_enum_DataSourceConfig {
-enum SessionInitiator : int32_t {
-  SESSION_INITIATOR_UNSPECIFIED = 0,
-  SESSION_INITIATOR_TRUSTED_SYSTEM = 1,
+namespace perfetto_pbzero_enum_ProtoLogConfig {
+enum TracingMode : int32_t {
+  DEFAULT = 0,
+  ENABLE_ALL = 1,
 };
-} // namespace perfetto_pbzero_enum_DataSourceConfig
-using DataSourceConfig_SessionInitiator = perfetto_pbzero_enum_DataSourceConfig::SessionInitiator;
+} // namespace perfetto_pbzero_enum_ProtoLogConfig
+using ProtoLogConfig_TracingMode = perfetto_pbzero_enum_ProtoLogConfig::TracingMode;
 
 
-constexpr DataSourceConfig_SessionInitiator DataSourceConfig_SessionInitiator_MIN = DataSourceConfig_SessionInitiator::SESSION_INITIATOR_UNSPECIFIED;
-constexpr DataSourceConfig_SessionInitiator DataSourceConfig_SessionInitiator_MAX = DataSourceConfig_SessionInitiator::SESSION_INITIATOR_TRUSTED_SYSTEM;
+constexpr ProtoLogConfig_TracingMode ProtoLogConfig_TracingMode_MIN = ProtoLogConfig_TracingMode::DEFAULT;
+constexpr ProtoLogConfig_TracingMode ProtoLogConfig_TracingMode_MAX = ProtoLogConfig_TracingMode::ENABLE_ALL;
 
 
 PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* DataSourceConfig_SessionInitiator_Name(::perfetto::protos::pbzero::DataSourceConfig_SessionInitiator value) {
+const char* ProtoLogConfig_TracingMode_Name(::perfetto::protos::pbzero::ProtoLogConfig_TracingMode value) {
   switch (value) {
-  case ::perfetto::protos::pbzero::DataSourceConfig_SessionInitiator::SESSION_INITIATOR_UNSPECIFIED:
-    return "SESSION_INITIATOR_UNSPECIFIED";
+  case ::perfetto::protos::pbzero::ProtoLogConfig_TracingMode::DEFAULT:
+    return "DEFAULT";
 
-  case ::perfetto::protos::pbzero::DataSourceConfig_SessionInitiator::SESSION_INITIATOR_TRUSTED_SYSTEM:
-    return "SESSION_INITIATOR_TRUSTED_SYSTEM";
+  case ::perfetto::protos::pbzero::ProtoLogConfig_TracingMode::ENABLE_ALL:
+    return "ENABLE_ALL";
   }
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-class DataSourceConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/122, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class ProtoLogGroup_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  DataSourceConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit DataSourceConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit DataSourceConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_target_buffer() const { return at<2>().valid(); }
-  uint32_t target_buffer() const { return at<2>().as_uint32(); }
-  bool has_trace_duration_ms() const { return at<3>().valid(); }
-  uint32_t trace_duration_ms() const { return at<3>().as_uint32(); }
-  bool has_prefer_suspend_clock_for_duration() const { return at<122>().valid(); }
-  bool prefer_suspend_clock_for_duration() const { return at<122>().as_bool(); }
-  bool has_stop_timeout_ms() const { return at<7>().valid(); }
-  uint32_t stop_timeout_ms() const { return at<7>().as_uint32(); }
-  bool has_enable_extra_guardrails() const { return at<6>().valid(); }
-  bool enable_extra_guardrails() const { return at<6>().as_bool(); }
-  bool has_session_initiator() const { return at<8>().valid(); }
-  int32_t session_initiator() const { return at<8>().as_int32(); }
-  bool has_tracing_session_id() const { return at<4>().valid(); }
-  uint64_t tracing_session_id() const { return at<4>().as_uint64(); }
-  bool has_ftrace_config() const { return at<100>().valid(); }
-  ::protozero::ConstBytes ftrace_config() const { return at<100>().as_bytes(); }
-  bool has_inode_file_config() const { return at<102>().valid(); }
-  ::protozero::ConstBytes inode_file_config() const { return at<102>().as_bytes(); }
-  bool has_process_stats_config() const { return at<103>().valid(); }
-  ::protozero::ConstBytes process_stats_config() const { return at<103>().as_bytes(); }
-  bool has_sys_stats_config() const { return at<104>().valid(); }
-  ::protozero::ConstBytes sys_stats_config() const { return at<104>().as_bytes(); }
-  bool has_heapprofd_config() const { return at<105>().valid(); }
-  ::protozero::ConstBytes heapprofd_config() const { return at<105>().as_bytes(); }
-  bool has_java_hprof_config() const { return at<110>().valid(); }
-  ::protozero::ConstBytes java_hprof_config() const { return at<110>().as_bytes(); }
-  bool has_android_power_config() const { return at<106>().valid(); }
-  ::protozero::ConstBytes android_power_config() const { return at<106>().as_bytes(); }
-  bool has_android_log_config() const { return at<107>().valid(); }
-  ::protozero::ConstBytes android_log_config() const { return at<107>().as_bytes(); }
-  bool has_gpu_counter_config() const { return at<108>().valid(); }
-  ::protozero::ConstBytes gpu_counter_config() const { return at<108>().as_bytes(); }
-  bool has_android_game_intervention_list_config() const { return at<116>().valid(); }
-  ::protozero::ConstBytes android_game_intervention_list_config() const { return at<116>().as_bytes(); }
-  bool has_packages_list_config() const { return at<109>().valid(); }
-  ::protozero::ConstBytes packages_list_config() const { return at<109>().as_bytes(); }
-  bool has_perf_event_config() const { return at<111>().valid(); }
-  ::protozero::ConstBytes perf_event_config() const { return at<111>().as_bytes(); }
-  bool has_vulkan_memory_config() const { return at<112>().valid(); }
-  ::protozero::ConstBytes vulkan_memory_config() const { return at<112>().as_bytes(); }
-  bool has_track_event_config() const { return at<113>().valid(); }
-  ::protozero::ConstBytes track_event_config() const { return at<113>().as_bytes(); }
-  bool has_android_polled_state_config() const { return at<114>().valid(); }
-  ::protozero::ConstBytes android_polled_state_config() const { return at<114>().as_bytes(); }
-  bool has_android_system_property_config() const { return at<118>().valid(); }
-  ::protozero::ConstBytes android_system_property_config() const { return at<118>().as_bytes(); }
-  bool has_statsd_tracing_config() const { return at<117>().valid(); }
-  ::protozero::ConstBytes statsd_tracing_config() const { return at<117>().as_bytes(); }
-  bool has_system_info_config() const { return at<119>().valid(); }
-  ::protozero::ConstBytes system_info_config() const { return at<119>().as_bytes(); }
-  bool has_chrome_config() const { return at<101>().valid(); }
-  ::protozero::ConstBytes chrome_config() const { return at<101>().as_bytes(); }
-  bool has_interceptor_config() const { return at<115>().valid(); }
-  ::protozero::ConstBytes interceptor_config() const { return at<115>().as_bytes(); }
-  bool has_network_packet_trace_config() const { return at<120>().valid(); }
-  ::protozero::ConstBytes network_packet_trace_config() const { return at<120>().as_bytes(); }
-  // field legacy_config omitted because its id is too high
-  // field for_testing omitted because its id is too high
+  ProtoLogGroup_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProtoLogGroup_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProtoLogGroup_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_group_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars group_name() const { return at<1>().as_string(); }
+  bool has_log_from() const { return at<2>().valid(); }
+  int32_t log_from() const { return at<2>().as_int32(); }
+  bool has_collect_stacktrace() const { return at<3>().valid(); }
+  bool collect_stacktrace() const { return at<3>().as_bool(); }
 };
 
-class DataSourceConfig : public ::protozero::Message {
+class ProtoLogGroup : public ::protozero::Message {
  public:
-  using Decoder = DataSourceConfig_Decoder;
+  using Decoder = ProtoLogGroup_Decoder;
   enum : int32_t {
-    kNameFieldNumber = 1,
-    kTargetBufferFieldNumber = 2,
-    kTraceDurationMsFieldNumber = 3,
-    kPreferSuspendClockForDurationFieldNumber = 122,
-    kStopTimeoutMsFieldNumber = 7,
-    kEnableExtraGuardrailsFieldNumber = 6,
-    kSessionInitiatorFieldNumber = 8,
-    kTracingSessionIdFieldNumber = 4,
-    kFtraceConfigFieldNumber = 100,
-    kInodeFileConfigFieldNumber = 102,
-    kProcessStatsConfigFieldNumber = 103,
-    kSysStatsConfigFieldNumber = 104,
-    kHeapprofdConfigFieldNumber = 105,
-    kJavaHprofConfigFieldNumber = 110,
-    kAndroidPowerConfigFieldNumber = 106,
-    kAndroidLogConfigFieldNumber = 107,
-    kGpuCounterConfigFieldNumber = 108,
-    kAndroidGameInterventionListConfigFieldNumber = 116,
-    kPackagesListConfigFieldNumber = 109,
-    kPerfEventConfigFieldNumber = 111,
-    kVulkanMemoryConfigFieldNumber = 112,
-    kTrackEventConfigFieldNumber = 113,
-    kAndroidPolledStateConfigFieldNumber = 114,
-    kAndroidSystemPropertyConfigFieldNumber = 118,
-    kStatsdTracingConfigFieldNumber = 117,
-    kSystemInfoConfigFieldNumber = 119,
-    kChromeConfigFieldNumber = 101,
-    kInterceptorConfigFieldNumber = 115,
-    kNetworkPacketTraceConfigFieldNumber = 120,
-    kLegacyConfigFieldNumber = 1000,
-    kForTestingFieldNumber = 1001,
+    kGroupNameFieldNumber = 1,
+    kLogFromFieldNumber = 2,
+    kCollectStacktraceFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.DataSourceConfig"; }
-
+  static constexpr const char* GetName() { return ".perfetto.protos.ProtoLogGroup"; }
 
-  using SessionInitiator = ::perfetto::protos::pbzero::DataSourceConfig_SessionInitiator;
-  static inline const char* SessionInitiator_Name(SessionInitiator value) {
-    return ::perfetto::protos::pbzero::DataSourceConfig_SessionInitiator_Name(value);
-  }
-  static const SessionInitiator SESSION_INITIATOR_UNSPECIFIED = SessionInitiator::SESSION_INITIATOR_UNSPECIFIED;
-  static const SessionInitiator SESSION_INITIATOR_TRUSTED_SYSTEM = SessionInitiator::SESSION_INITIATOR_TRUSTED_SYSTEM;
 
-  using FieldMetadata_Name =
+  using FieldMetadata_GroupName =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      DataSourceConfig>;
+      ProtoLogGroup>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  static constexpr FieldMetadata_GroupName kGroupName{};
+  void set_group_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_GroupName::kFieldId, data, size);
   }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  void set_group_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_GroupName::kFieldId, chars.data, chars.size);
   }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  void set_group_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_GroupName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -39825,149 +47548,99 @@ class DataSourceConfig : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TargetBuffer =
+  using FieldMetadata_LogFrom =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      DataSourceConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ProtoLogLevel,
+      ProtoLogGroup>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TargetBuffer kTargetBuffer() { return {}; }
-  void set_target_buffer(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TargetBuffer::kFieldId;
+  static constexpr FieldMetadata_LogFrom kLogFrom{};
+  void set_log_from(ProtoLogLevel value) {
+    static constexpr uint32_t field_id = FieldMetadata_LogFrom::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TraceDurationMs =
+  using FieldMetadata_CollectStacktrace =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      DataSourceConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ProtoLogGroup>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceDurationMs kTraceDurationMs() { return {}; }
-  void set_trace_duration_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TraceDurationMs::kFieldId;
+  static constexpr FieldMetadata_CollectStacktrace kCollectStacktrace{};
+  void set_collect_stacktrace(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_CollectStacktrace::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_PreferSuspendClockForDuration =
-    ::protozero::proto_utils::FieldMetadata<
-      122,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      DataSourceConfig>;
+class ProtoLogConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  ProtoLogConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProtoLogConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProtoLogConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_group_overrides() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> group_overrides() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  bool has_tracing_mode() const { return at<2>().valid(); }
+  int32_t tracing_mode() const { return at<2>().as_int32(); }
+  bool has_default_log_from_level() const { return at<3>().valid(); }
+  int32_t default_log_from_level() const { return at<3>().as_int32(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PreferSuspendClockForDuration kPreferSuspendClockForDuration() { return {}; }
-  void set_prefer_suspend_clock_for_duration(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_PreferSuspendClockForDuration::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+class ProtoLogConfig : public ::protozero::Message {
+ public:
+  using Decoder = ProtoLogConfig_Decoder;
+  enum : int32_t {
+    kGroupOverridesFieldNumber = 1,
+    kTracingModeFieldNumber = 2,
+    kDefaultLogFromLevelFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ProtoLogConfig"; }
 
-  using FieldMetadata_StopTimeoutMs =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      DataSourceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StopTimeoutMs kStopTimeoutMs() { return {}; }
-  void set_stop_timeout_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StopTimeoutMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
+  using TracingMode = ::perfetto::protos::pbzero::ProtoLogConfig_TracingMode;
+  static inline const char* TracingMode_Name(TracingMode value) {
+    return ::perfetto::protos::pbzero::ProtoLogConfig_TracingMode_Name(value);
   }
+  static inline const TracingMode DEFAULT = TracingMode::DEFAULT;
+  static inline const TracingMode ENABLE_ALL = TracingMode::ENABLE_ALL;
 
-  using FieldMetadata_EnableExtraGuardrails =
+  using FieldMetadata_GroupOverrides =
     ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      DataSourceConfig>;
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ProtoLogGroup,
+      ProtoLogConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EnableExtraGuardrails kEnableExtraGuardrails() { return {}; }
-  void set_enable_extra_guardrails(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_EnableExtraGuardrails::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_GroupOverrides kGroupOverrides{};
+  template <typename T = ProtoLogGroup> T* add_group_overrides() {
+    return BeginNestedMessage<T>(1);
   }
 
-  using FieldMetadata_SessionInitiator =
+
+  using FieldMetadata_TracingMode =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::DataSourceConfig_SessionInitiator,
-      DataSourceConfig>;
+      ProtoLogConfig_TracingMode,
+      ProtoLogConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SessionInitiator kSessionInitiator() { return {}; }
-  void set_session_initiator(::perfetto::protos::pbzero::DataSourceConfig_SessionInitiator value) {
-    static constexpr uint32_t field_id = FieldMetadata_SessionInitiator::kFieldId;
+  static constexpr FieldMetadata_TracingMode kTracingMode{};
+  void set_tracing_mode(ProtoLogConfig_TracingMode value) {
+    static constexpr uint32_t field_id = FieldMetadata_TracingMode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -39975,606 +47648,594 @@ class DataSourceConfig : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TracingSessionId =
+  using FieldMetadata_DefaultLogFromLevel =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      DataSourceConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ProtoLogLevel,
+      ProtoLogConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TracingSessionId kTracingSessionId() { return {}; }
-  void set_tracing_session_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TracingSessionId::kFieldId;
+  static constexpr FieldMetadata_DefaultLogFromLevel kDefaultLogFromLevel{};
+  void set_default_log_from_level(ProtoLogLevel value) {
+    static constexpr uint32_t field_id = FieldMetadata_DefaultLogFromLevel::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_FtraceConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      100,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      FtraceConfig,
-      DataSourceConfig>;
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/surfaceflinger_layers_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FtraceConfig kFtraceConfig() { return {}; }
-  template <typename T = FtraceConfig> T* set_ftrace_config() {
-    return BeginNestedMessage<T>(100);
-  }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_SURFACEFLINGER_LAYERS_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_SURFACEFLINGER_LAYERS_CONFIG_PROTO_H_
 
-  void set_ftrace_config_raw(const std::string& raw) {
-    return AppendBytes(100, raw.data(), raw.size());
-  }
+#include <stddef.h>
+#include <stdint.h>
 
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  using FieldMetadata_InodeFileConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      102,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      InodeFileConfig,
-      DataSourceConfig>;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+namespace perfetto_pbzero_enum_SurfaceFlingerLayersConfig {
+enum Mode : int32_t;
+}  // namespace perfetto_pbzero_enum_SurfaceFlingerLayersConfig
+using SurfaceFlingerLayersConfig_Mode = perfetto_pbzero_enum_SurfaceFlingerLayersConfig::Mode;
+namespace perfetto_pbzero_enum_SurfaceFlingerLayersConfig {
+enum TraceFlag : int32_t;
+}  // namespace perfetto_pbzero_enum_SurfaceFlingerLayersConfig
+using SurfaceFlingerLayersConfig_TraceFlag = perfetto_pbzero_enum_SurfaceFlingerLayersConfig::TraceFlag;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InodeFileConfig kInodeFileConfig() { return {}; }
-  template <typename T = InodeFileConfig> T* set_inode_file_config() {
-    return BeginNestedMessage<T>(102);
-  }
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-  void set_inode_file_config_raw(const std::string& raw) {
-    return AppendBytes(102, raw.data(), raw.size());
-  }
+namespace perfetto_pbzero_enum_SurfaceFlingerLayersConfig {
+enum Mode : int32_t {
+  MODE_UNSPECIFIED = 0,
+  MODE_ACTIVE = 1,
+  MODE_GENERATED = 2,
+  MODE_DUMP = 3,
+  MODE_GENERATED_BUGREPORT_ONLY = 4,
+};
+} // namespace perfetto_pbzero_enum_SurfaceFlingerLayersConfig
+using SurfaceFlingerLayersConfig_Mode = perfetto_pbzero_enum_SurfaceFlingerLayersConfig::Mode;
 
 
-  using FieldMetadata_ProcessStatsConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      103,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ProcessStatsConfig,
-      DataSourceConfig>;
+constexpr SurfaceFlingerLayersConfig_Mode SurfaceFlingerLayersConfig_Mode_MIN = SurfaceFlingerLayersConfig_Mode::MODE_UNSPECIFIED;
+constexpr SurfaceFlingerLayersConfig_Mode SurfaceFlingerLayersConfig_Mode_MAX = SurfaceFlingerLayersConfig_Mode::MODE_GENERATED_BUGREPORT_ONLY;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessStatsConfig kProcessStatsConfig() { return {}; }
-  template <typename T = ProcessStatsConfig> T* set_process_stats_config() {
-    return BeginNestedMessage<T>(103);
-  }
 
-  void set_process_stats_config_raw(const std::string& raw) {
-    return AppendBytes(103, raw.data(), raw.size());
-  }
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* SurfaceFlingerLayersConfig_Mode_Name(::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_Mode value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_Mode::MODE_UNSPECIFIED:
+    return "MODE_UNSPECIFIED";
 
+  case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_Mode::MODE_ACTIVE:
+    return "MODE_ACTIVE";
 
-  using FieldMetadata_SysStatsConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      104,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      SysStatsConfig,
-      DataSourceConfig>;
+  case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_Mode::MODE_GENERATED:
+    return "MODE_GENERATED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SysStatsConfig kSysStatsConfig() { return {}; }
-  template <typename T = SysStatsConfig> T* set_sys_stats_config() {
-    return BeginNestedMessage<T>(104);
-  }
+  case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_Mode::MODE_DUMP:
+    return "MODE_DUMP";
 
-  void set_sys_stats_config_raw(const std::string& raw) {
-    return AppendBytes(104, raw.data(), raw.size());
+  case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_Mode::MODE_GENERATED_BUGREPORT_ONLY:
+    return "MODE_GENERATED_BUGREPORT_ONLY";
   }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
+namespace perfetto_pbzero_enum_SurfaceFlingerLayersConfig {
+enum TraceFlag : int32_t {
+  TRACE_FLAG_UNSPECIFIED = 0,
+  TRACE_FLAG_INPUT = 2,
+  TRACE_FLAG_COMPOSITION = 4,
+  TRACE_FLAG_EXTRA = 8,
+  TRACE_FLAG_HWC = 16,
+  TRACE_FLAG_BUFFERS = 32,
+  TRACE_FLAG_VIRTUAL_DISPLAYS = 64,
+  TRACE_FLAG_ALL = 14,
+};
+} // namespace perfetto_pbzero_enum_SurfaceFlingerLayersConfig
+using SurfaceFlingerLayersConfig_TraceFlag = perfetto_pbzero_enum_SurfaceFlingerLayersConfig::TraceFlag;
 
-  using FieldMetadata_HeapprofdConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      105,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      HeapprofdConfig,
-      DataSourceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HeapprofdConfig kHeapprofdConfig() { return {}; }
-  template <typename T = HeapprofdConfig> T* set_heapprofd_config() {
-    return BeginNestedMessage<T>(105);
-  }
+constexpr SurfaceFlingerLayersConfig_TraceFlag SurfaceFlingerLayersConfig_TraceFlag_MIN = SurfaceFlingerLayersConfig_TraceFlag::TRACE_FLAG_UNSPECIFIED;
+constexpr SurfaceFlingerLayersConfig_TraceFlag SurfaceFlingerLayersConfig_TraceFlag_MAX = SurfaceFlingerLayersConfig_TraceFlag::TRACE_FLAG_VIRTUAL_DISPLAYS;
 
-  void set_heapprofd_config_raw(const std::string& raw) {
-    return AppendBytes(105, raw.data(), raw.size());
-  }
 
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* SurfaceFlingerLayersConfig_TraceFlag_Name(::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_TraceFlag value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_TraceFlag::TRACE_FLAG_UNSPECIFIED:
+    return "TRACE_FLAG_UNSPECIFIED";
 
-  using FieldMetadata_JavaHprofConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      110,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      JavaHprofConfig,
-      DataSourceConfig>;
+  case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_TraceFlag::TRACE_FLAG_INPUT:
+    return "TRACE_FLAG_INPUT";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_JavaHprofConfig kJavaHprofConfig() { return {}; }
-  template <typename T = JavaHprofConfig> T* set_java_hprof_config() {
-    return BeginNestedMessage<T>(110);
-  }
+  case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_TraceFlag::TRACE_FLAG_COMPOSITION:
+    return "TRACE_FLAG_COMPOSITION";
 
-  void set_java_hprof_config_raw(const std::string& raw) {
-    return AppendBytes(110, raw.data(), raw.size());
-  }
+  case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_TraceFlag::TRACE_FLAG_EXTRA:
+    return "TRACE_FLAG_EXTRA";
 
+  case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_TraceFlag::TRACE_FLAG_HWC:
+    return "TRACE_FLAG_HWC";
 
-  using FieldMetadata_AndroidPowerConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      106,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AndroidPowerConfig,
-      DataSourceConfig>;
+  case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_TraceFlag::TRACE_FLAG_BUFFERS:
+    return "TRACE_FLAG_BUFFERS";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidPowerConfig kAndroidPowerConfig() { return {}; }
-  template <typename T = AndroidPowerConfig> T* set_android_power_config() {
-    return BeginNestedMessage<T>(106);
-  }
+  case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_TraceFlag::TRACE_FLAG_VIRTUAL_DISPLAYS:
+    return "TRACE_FLAG_VIRTUAL_DISPLAYS";
 
-  void set_android_power_config_raw(const std::string& raw) {
-    return AppendBytes(106, raw.data(), raw.size());
+  case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_TraceFlag::TRACE_FLAG_ALL:
+    return "TRACE_FLAG_ALL";
   }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class SurfaceFlingerLayersConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  SurfaceFlingerLayersConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SurfaceFlingerLayersConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SurfaceFlingerLayersConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_mode() const { return at<1>().valid(); }
+  int32_t mode() const { return at<1>().as_int32(); }
+  bool has_trace_flags() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> trace_flags() const { return GetRepeated<int32_t>(2); }
+};
 
+class SurfaceFlingerLayersConfig : public ::protozero::Message {
+ public:
+  using Decoder = SurfaceFlingerLayersConfig_Decoder;
+  enum : int32_t {
+    kModeFieldNumber = 1,
+    kTraceFlagsFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SurfaceFlingerLayersConfig"; }
 
-  using FieldMetadata_AndroidLogConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      107,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AndroidLogConfig,
-      DataSourceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidLogConfig kAndroidLogConfig() { return {}; }
-  template <typename T = AndroidLogConfig> T* set_android_log_config() {
-    return BeginNestedMessage<T>(107);
+  using Mode = ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_Mode;
+  static inline const char* Mode_Name(Mode value) {
+    return ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_Mode_Name(value);
   }
 
-  void set_android_log_config_raw(const std::string& raw) {
-    return AppendBytes(107, raw.data(), raw.size());
+  using TraceFlag = ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_TraceFlag;
+  static inline const char* TraceFlag_Name(TraceFlag value) {
+    return ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_TraceFlag_Name(value);
   }
+  static inline const Mode MODE_UNSPECIFIED = Mode::MODE_UNSPECIFIED;
+  static inline const Mode MODE_ACTIVE = Mode::MODE_ACTIVE;
+  static inline const Mode MODE_GENERATED = Mode::MODE_GENERATED;
+  static inline const Mode MODE_DUMP = Mode::MODE_DUMP;
+  static inline const Mode MODE_GENERATED_BUGREPORT_ONLY = Mode::MODE_GENERATED_BUGREPORT_ONLY;
+  static inline const TraceFlag TRACE_FLAG_UNSPECIFIED = TraceFlag::TRACE_FLAG_UNSPECIFIED;
+  static inline const TraceFlag TRACE_FLAG_INPUT = TraceFlag::TRACE_FLAG_INPUT;
+  static inline const TraceFlag TRACE_FLAG_COMPOSITION = TraceFlag::TRACE_FLAG_COMPOSITION;
+  static inline const TraceFlag TRACE_FLAG_EXTRA = TraceFlag::TRACE_FLAG_EXTRA;
+  static inline const TraceFlag TRACE_FLAG_HWC = TraceFlag::TRACE_FLAG_HWC;
+  static inline const TraceFlag TRACE_FLAG_BUFFERS = TraceFlag::TRACE_FLAG_BUFFERS;
+  static inline const TraceFlag TRACE_FLAG_VIRTUAL_DISPLAYS = TraceFlag::TRACE_FLAG_VIRTUAL_DISPLAYS;
+  static inline const TraceFlag TRACE_FLAG_ALL = TraceFlag::TRACE_FLAG_ALL;
 
-
-  using FieldMetadata_GpuCounterConfig =
+  using FieldMetadata_Mode =
     ::protozero::proto_utils::FieldMetadata<
-      108,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      GpuCounterConfig,
-      DataSourceConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      SurfaceFlingerLayersConfig_Mode,
+      SurfaceFlingerLayersConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GpuCounterConfig kGpuCounterConfig() { return {}; }
-  template <typename T = GpuCounterConfig> T* set_gpu_counter_config() {
-    return BeginNestedMessage<T>(108);
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(SurfaceFlingerLayersConfig_Mode value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
   }
 
-  void set_gpu_counter_config_raw(const std::string& raw) {
-    return AppendBytes(108, raw.data(), raw.size());
+  using FieldMetadata_TraceFlags =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      SurfaceFlingerLayersConfig_TraceFlag,
+      SurfaceFlingerLayersConfig>;
+
+  static constexpr FieldMetadata_TraceFlags kTraceFlags{};
+  void add_trace_flags(SurfaceFlingerLayersConfig_TraceFlag value) {
+    static constexpr uint32_t field_id = FieldMetadata_TraceFlags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
   }
+};
 
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/surfaceflinger_transactions_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  using FieldMetadata_AndroidGameInterventionListConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      116,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AndroidGameInterventionListConfig,
-      DataSourceConfig>;
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_SURFACEFLINGER_TRANSACTIONS_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_SURFACEFLINGER_TRANSACTIONS_CONFIG_PROTO_H_
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidGameInterventionListConfig kAndroidGameInterventionListConfig() { return {}; }
-  template <typename T = AndroidGameInterventionListConfig> T* set_android_game_intervention_list_config() {
-    return BeginNestedMessage<T>(116);
-  }
+#include <stddef.h>
+#include <stdint.h>
 
-  void set_android_game_intervention_list_config_raw(const std::string& raw) {
-    return AppendBytes(116, raw.data(), raw.size());
-  }
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+namespace perfetto_pbzero_enum_SurfaceFlingerTransactionsConfig {
+enum Mode : int32_t;
+}  // namespace perfetto_pbzero_enum_SurfaceFlingerTransactionsConfig
+using SurfaceFlingerTransactionsConfig_Mode = perfetto_pbzero_enum_SurfaceFlingerTransactionsConfig::Mode;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-  using FieldMetadata_PackagesListConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      109,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      PackagesListConfig,
-      DataSourceConfig>;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PackagesListConfig kPackagesListConfig() { return {}; }
-  template <typename T = PackagesListConfig> T* set_packages_list_config() {
-    return BeginNestedMessage<T>(109);
-  }
+namespace perfetto_pbzero_enum_SurfaceFlingerTransactionsConfig {
+enum Mode : int32_t {
+  MODE_UNSPECIFIED = 0,
+  MODE_CONTINUOUS = 1,
+  MODE_ACTIVE = 2,
+};
+} // namespace perfetto_pbzero_enum_SurfaceFlingerTransactionsConfig
+using SurfaceFlingerTransactionsConfig_Mode = perfetto_pbzero_enum_SurfaceFlingerTransactionsConfig::Mode;
 
-  void set_packages_list_config_raw(const std::string& raw) {
-    return AppendBytes(109, raw.data(), raw.size());
-  }
 
+constexpr SurfaceFlingerTransactionsConfig_Mode SurfaceFlingerTransactionsConfig_Mode_MIN = SurfaceFlingerTransactionsConfig_Mode::MODE_UNSPECIFIED;
+constexpr SurfaceFlingerTransactionsConfig_Mode SurfaceFlingerTransactionsConfig_Mode_MAX = SurfaceFlingerTransactionsConfig_Mode::MODE_ACTIVE;
 
-  using FieldMetadata_PerfEventConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      111,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      PerfEventConfig,
-      DataSourceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PerfEventConfig kPerfEventConfig() { return {}; }
-  template <typename T = PerfEventConfig> T* set_perf_event_config() {
-    return BeginNestedMessage<T>(111);
-  }
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* SurfaceFlingerTransactionsConfig_Mode_Name(::perfetto::protos::pbzero::SurfaceFlingerTransactionsConfig_Mode value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::SurfaceFlingerTransactionsConfig_Mode::MODE_UNSPECIFIED:
+    return "MODE_UNSPECIFIED";
 
-  void set_perf_event_config_raw(const std::string& raw) {
-    return AppendBytes(111, raw.data(), raw.size());
+  case ::perfetto::protos::pbzero::SurfaceFlingerTransactionsConfig_Mode::MODE_CONTINUOUS:
+    return "MODE_CONTINUOUS";
+
+  case ::perfetto::protos::pbzero::SurfaceFlingerTransactionsConfig_Mode::MODE_ACTIVE:
+    return "MODE_ACTIVE";
   }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
+class SurfaceFlingerTransactionsConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  SurfaceFlingerTransactionsConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SurfaceFlingerTransactionsConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SurfaceFlingerTransactionsConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_mode() const { return at<1>().valid(); }
+  int32_t mode() const { return at<1>().as_int32(); }
+};
 
-  using FieldMetadata_VulkanMemoryConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      112,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      VulkanMemoryConfig,
-      DataSourceConfig>;
+class SurfaceFlingerTransactionsConfig : public ::protozero::Message {
+ public:
+  using Decoder = SurfaceFlingerTransactionsConfig_Decoder;
+  enum : int32_t {
+    kModeFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SurfaceFlingerTransactionsConfig"; }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VulkanMemoryConfig kVulkanMemoryConfig() { return {}; }
-  template <typename T = VulkanMemoryConfig> T* set_vulkan_memory_config() {
-    return BeginNestedMessage<T>(112);
-  }
 
-  void set_vulkan_memory_config_raw(const std::string& raw) {
-    return AppendBytes(112, raw.data(), raw.size());
+  using Mode = ::perfetto::protos::pbzero::SurfaceFlingerTransactionsConfig_Mode;
+  static inline const char* Mode_Name(Mode value) {
+    return ::perfetto::protos::pbzero::SurfaceFlingerTransactionsConfig_Mode_Name(value);
   }
+  static inline const Mode MODE_UNSPECIFIED = Mode::MODE_UNSPECIFIED;
+  static inline const Mode MODE_CONTINUOUS = Mode::MODE_CONTINUOUS;
+  static inline const Mode MODE_ACTIVE = Mode::MODE_ACTIVE;
 
-
-  using FieldMetadata_TrackEventConfig =
+  using FieldMetadata_Mode =
     ::protozero::proto_utils::FieldMetadata<
-      113,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TrackEventConfig,
-      DataSourceConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      SurfaceFlingerTransactionsConfig_Mode,
+      SurfaceFlingerTransactionsConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrackEventConfig kTrackEventConfig() { return {}; }
-  template <typename T = TrackEventConfig> T* set_track_event_config() {
-    return BeginNestedMessage<T>(113);
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(SurfaceFlingerTransactionsConfig_Mode value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
   }
+};
 
-  void set_track_event_config_raw(const std::string& raw) {
-    return AppendBytes(113, raw.data(), raw.size());
-  }
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/user_list_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_USER_LIST_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_USER_LIST_CONFIG_PROTO_H_
 
-  using FieldMetadata_AndroidPolledStateConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      114,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AndroidPolledStateConfig,
-      DataSourceConfig>;
+#include <stddef.h>
+#include <stdint.h>
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidPolledStateConfig kAndroidPolledStateConfig() { return {}; }
-  template <typename T = AndroidPolledStateConfig> T* set_android_polled_state_config() {
-    return BeginNestedMessage<T>(114);
-  }
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  void set_android_polled_state_config_raw(const std::string& raw) {
-    return AppendBytes(114, raw.data(), raw.size());
-  }
 
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-  using FieldMetadata_AndroidSystemPropertyConfig =
+class AndroidUserListConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  AndroidUserListConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidUserListConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidUserListConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_user_type_filter() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> user_type_filter() const { return GetRepeated<::protozero::ConstChars>(1); }
+};
+
+class AndroidUserListConfig : public ::protozero::Message {
+ public:
+  using Decoder = AndroidUserListConfig_Decoder;
+  enum : int32_t {
+    kUserTypeFilterFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidUserListConfig"; }
+
+
+  using FieldMetadata_UserTypeFilter =
     ::protozero::proto_utils::FieldMetadata<
-      118,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AndroidSystemPropertyConfig,
-      DataSourceConfig>;
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      AndroidUserListConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidSystemPropertyConfig kAndroidSystemPropertyConfig() { return {}; }
-  template <typename T = AndroidSystemPropertyConfig> T* set_android_system_property_config() {
-    return BeginNestedMessage<T>(118);
+  static constexpr FieldMetadata_UserTypeFilter kUserTypeFilter{};
+  void add_user_type_filter(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_UserTypeFilter::kFieldId, data, size);
   }
-
-  void set_android_system_property_config_raw(const std::string& raw) {
-    return AppendBytes(118, raw.data(), raw.size());
+  void add_user_type_filter(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_UserTypeFilter::kFieldId, chars.data, chars.size);
+  }
+  void add_user_type_filter(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_UserTypeFilter::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
   }
+};
 
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/windowmanager_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  using FieldMetadata_StatsdTracingConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      117,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      StatsdTracingConfig,
-      DataSourceConfig>;
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_WINDOWMANAGER_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_WINDOWMANAGER_CONFIG_PROTO_H_
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StatsdTracingConfig kStatsdTracingConfig() { return {}; }
-  template <typename T = StatsdTracingConfig> T* set_statsd_tracing_config() {
-    return BeginNestedMessage<T>(117);
-  }
+#include <stddef.h>
+#include <stdint.h>
 
-  void set_statsd_tracing_config_raw(const std::string& raw) {
-    return AppendBytes(117, raw.data(), raw.size());
-  }
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+namespace perfetto_pbzero_enum_WindowManagerConfig {
+enum LogFrequency : int32_t;
+}  // namespace perfetto_pbzero_enum_WindowManagerConfig
+using WindowManagerConfig_LogFrequency = perfetto_pbzero_enum_WindowManagerConfig::LogFrequency;
+namespace perfetto_pbzero_enum_WindowManagerConfig {
+enum LogLevel : int32_t;
+}  // namespace perfetto_pbzero_enum_WindowManagerConfig
+using WindowManagerConfig_LogLevel = perfetto_pbzero_enum_WindowManagerConfig::LogLevel;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-  using FieldMetadata_SystemInfoConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      119,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      SystemInfoConfig,
-      DataSourceConfig>;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SystemInfoConfig kSystemInfoConfig() { return {}; }
-  template <typename T = SystemInfoConfig> T* set_system_info_config() {
-    return BeginNestedMessage<T>(119);
-  }
+namespace perfetto_pbzero_enum_WindowManagerConfig {
+enum LogFrequency : int32_t {
+  LOG_FREQUENCY_UNSPECIFIED = 0,
+  LOG_FREQUENCY_FRAME = 1,
+  LOG_FREQUENCY_TRANSACTION = 2,
+  LOG_FREQUENCY_SINGLE_DUMP = 3,
+};
+} // namespace perfetto_pbzero_enum_WindowManagerConfig
+using WindowManagerConfig_LogFrequency = perfetto_pbzero_enum_WindowManagerConfig::LogFrequency;
 
 
-  using FieldMetadata_ChromeConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      101,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeConfig,
-      DataSourceConfig>;
+constexpr WindowManagerConfig_LogFrequency WindowManagerConfig_LogFrequency_MIN = WindowManagerConfig_LogFrequency::LOG_FREQUENCY_UNSPECIFIED;
+constexpr WindowManagerConfig_LogFrequency WindowManagerConfig_LogFrequency_MAX = WindowManagerConfig_LogFrequency::LOG_FREQUENCY_SINGLE_DUMP;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeConfig kChromeConfig() { return {}; }
-  template <typename T = ChromeConfig> T* set_chrome_config() {
-    return BeginNestedMessage<T>(101);
-  }
 
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* WindowManagerConfig_LogFrequency_Name(::perfetto::protos::pbzero::WindowManagerConfig_LogFrequency value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::WindowManagerConfig_LogFrequency::LOG_FREQUENCY_UNSPECIFIED:
+    return "LOG_FREQUENCY_UNSPECIFIED";
 
-  using FieldMetadata_InterceptorConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      115,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      InterceptorConfig,
-      DataSourceConfig>;
+  case ::perfetto::protos::pbzero::WindowManagerConfig_LogFrequency::LOG_FREQUENCY_FRAME:
+    return "LOG_FREQUENCY_FRAME";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InterceptorConfig kInterceptorConfig() { return {}; }
-  template <typename T = InterceptorConfig> T* set_interceptor_config() {
-    return BeginNestedMessage<T>(115);
+  case ::perfetto::protos::pbzero::WindowManagerConfig_LogFrequency::LOG_FREQUENCY_TRANSACTION:
+    return "LOG_FREQUENCY_TRANSACTION";
+
+  case ::perfetto::protos::pbzero::WindowManagerConfig_LogFrequency::LOG_FREQUENCY_SINGLE_DUMP:
+    return "LOG_FREQUENCY_SINGLE_DUMP";
   }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
+namespace perfetto_pbzero_enum_WindowManagerConfig {
+enum LogLevel : int32_t {
+  LOG_LEVEL_UNSPECIFIED = 0,
+  LOG_LEVEL_VERBOSE = 1,
+  LOG_LEVEL_DEBUG = 2,
+  LOG_LEVEL_CRITICAL = 3,
+};
+} // namespace perfetto_pbzero_enum_WindowManagerConfig
+using WindowManagerConfig_LogLevel = perfetto_pbzero_enum_WindowManagerConfig::LogLevel;
 
-  using FieldMetadata_NetworkPacketTraceConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      120,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      NetworkPacketTraceConfig,
-      DataSourceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NetworkPacketTraceConfig kNetworkPacketTraceConfig() { return {}; }
-  template <typename T = NetworkPacketTraceConfig> T* set_network_packet_trace_config() {
-    return BeginNestedMessage<T>(120);
+constexpr WindowManagerConfig_LogLevel WindowManagerConfig_LogLevel_MIN = WindowManagerConfig_LogLevel::LOG_LEVEL_UNSPECIFIED;
+constexpr WindowManagerConfig_LogLevel WindowManagerConfig_LogLevel_MAX = WindowManagerConfig_LogLevel::LOG_LEVEL_CRITICAL;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* WindowManagerConfig_LogLevel_Name(::perfetto::protos::pbzero::WindowManagerConfig_LogLevel value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::WindowManagerConfig_LogLevel::LOG_LEVEL_UNSPECIFIED:
+    return "LOG_LEVEL_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::WindowManagerConfig_LogLevel::LOG_LEVEL_VERBOSE:
+    return "LOG_LEVEL_VERBOSE";
+
+  case ::perfetto::protos::pbzero::WindowManagerConfig_LogLevel::LOG_LEVEL_DEBUG:
+    return "LOG_LEVEL_DEBUG";
+
+  case ::perfetto::protos::pbzero::WindowManagerConfig_LogLevel::LOG_LEVEL_CRITICAL:
+    return "LOG_LEVEL_CRITICAL";
   }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
-  void set_network_packet_trace_config_raw(const std::string& raw) {
-    return AppendBytes(120, raw.data(), raw.size());
+class WindowManagerConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  WindowManagerConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit WindowManagerConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit WindowManagerConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_log_frequency() const { return at<1>().valid(); }
+  int32_t log_frequency() const { return at<1>().as_int32(); }
+  bool has_log_level() const { return at<2>().valid(); }
+  int32_t log_level() const { return at<2>().as_int32(); }
+};
+
+class WindowManagerConfig : public ::protozero::Message {
+ public:
+  using Decoder = WindowManagerConfig_Decoder;
+  enum : int32_t {
+    kLogFrequencyFieldNumber = 1,
+    kLogLevelFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.WindowManagerConfig"; }
+
+
+  using LogFrequency = ::perfetto::protos::pbzero::WindowManagerConfig_LogFrequency;
+  static inline const char* LogFrequency_Name(LogFrequency value) {
+    return ::perfetto::protos::pbzero::WindowManagerConfig_LogFrequency_Name(value);
   }
 
+  using LogLevel = ::perfetto::protos::pbzero::WindowManagerConfig_LogLevel;
+  static inline const char* LogLevel_Name(LogLevel value) {
+    return ::perfetto::protos::pbzero::WindowManagerConfig_LogLevel_Name(value);
+  }
+  static inline const LogFrequency LOG_FREQUENCY_UNSPECIFIED = LogFrequency::LOG_FREQUENCY_UNSPECIFIED;
+  static inline const LogFrequency LOG_FREQUENCY_FRAME = LogFrequency::LOG_FREQUENCY_FRAME;
+  static inline const LogFrequency LOG_FREQUENCY_TRANSACTION = LogFrequency::LOG_FREQUENCY_TRANSACTION;
+  static inline const LogFrequency LOG_FREQUENCY_SINGLE_DUMP = LogFrequency::LOG_FREQUENCY_SINGLE_DUMP;
+  static inline const LogLevel LOG_LEVEL_UNSPECIFIED = LogLevel::LOG_LEVEL_UNSPECIFIED;
+  static inline const LogLevel LOG_LEVEL_VERBOSE = LogLevel::LOG_LEVEL_VERBOSE;
+  static inline const LogLevel LOG_LEVEL_DEBUG = LogLevel::LOG_LEVEL_DEBUG;
+  static inline const LogLevel LOG_LEVEL_CRITICAL = LogLevel::LOG_LEVEL_CRITICAL;
 
-  using FieldMetadata_LegacyConfig =
+  using FieldMetadata_LogFrequency =
     ::protozero::proto_utils::FieldMetadata<
-      1000,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      DataSourceConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      WindowManagerConfig_LogFrequency,
+      WindowManagerConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LegacyConfig kLegacyConfig() { return {}; }
-  void set_legacy_config(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_LegacyConfig::kFieldId, data, size);
-  }
-  void set_legacy_config(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_LegacyConfig::kFieldId, chars.data, chars.size);
-  }
-  void set_legacy_config(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_LegacyConfig::kFieldId;
+  static constexpr FieldMetadata_LogFrequency kLogFrequency{};
+  void set_log_frequency(WindowManagerConfig_LogFrequency value) {
+    static constexpr uint32_t field_id = FieldMetadata_LogFrequency::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ForTesting =
+  using FieldMetadata_LogLevel =
     ::protozero::proto_utils::FieldMetadata<
-      1001,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TestConfig,
-      DataSourceConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      WindowManagerConfig_LogLevel,
+      WindowManagerConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ForTesting kForTesting() { return {}; }
-  template <typename T = TestConfig> T* set_for_testing() {
-    return BeginNestedMessage<T>(1001);
+  static constexpr FieldMetadata_LogLevel kLogLevel{};
+  void set_log_level(WindowManagerConfig_LogLevel value) {
+    static constexpr uint32_t field_id = FieldMetadata_LogLevel::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
   }
-
 };
 
 } // Namespace.
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/interceptor_config.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/config/ftrace/frozen_ftrace_config.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTOR_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTOR_CONFIG_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_FTRACE_FROZEN_FTRACE_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_FTRACE_FROZEN_FTRACE_CONFIG_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -40585,99 +48246,63 @@ class DataSourceConfig : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-class ConsoleConfig;
-
-class InterceptorConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/100, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class FrozenFtraceConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  InterceptorConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit InterceptorConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit InterceptorConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_console_config() const { return at<100>().valid(); }
-  ::protozero::ConstBytes console_config() const { return at<100>().as_bytes(); }
+  FrozenFtraceConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FrozenFtraceConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FrozenFtraceConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_instance_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars instance_name() const { return at<1>().as_string(); }
 };
 
-class InterceptorConfig : public ::protozero::Message {
+class FrozenFtraceConfig : public ::protozero::Message {
  public:
-  using Decoder = InterceptorConfig_Decoder;
+  using Decoder = FrozenFtraceConfig_Decoder;
   enum : int32_t {
-    kNameFieldNumber = 1,
-    kConsoleConfigFieldNumber = 100,
+    kInstanceNameFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.InterceptorConfig"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.FrozenFtraceConfig"; }
 
 
-  using FieldMetadata_Name =
+  using FieldMetadata_InstanceName =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      InterceptorConfig>;
+      FrozenFtraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  static constexpr FieldMetadata_InstanceName kInstanceName{};
+  void set_instance_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_InstanceName::kFieldId, data, size);
   }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  void set_instance_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_InstanceName::kFieldId, chars.data, chars.size);
   }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  void set_instance_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_InstanceName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
-
-  using FieldMetadata_ConsoleConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      100,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ConsoleConfig,
-      InterceptorConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ConsoleConfig kConsoleConfig() { return {}; }
-  template <typename T = ConsoleConfig> T* set_console_config() {
-    return BeginNestedMessage<T>(100);
-  }
-
-  void set_console_config_raw(const std::string& raw) {
-    return AppendBytes(100, raw.data(), raw.size());
-  }
-
 };
 
 } // Namespace.
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/stress_test_config.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/config/ftrace/ftrace_config.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STRESS_TEST_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STRESS_TEST_CONFIG_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_FTRACE_FTRACE_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_FTRACE_FTRACE_CONFIG_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -40688,201 +48313,368 @@ class InterceptorConfig : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class FtraceConfig_CompactSchedConfig;
+class FtraceConfig_KprobeEvent;
+class FtraceConfig_PrintFilter;
+class FtraceConfig_PrintFilter_Rule;
+class FtraceConfig_PrintFilter_Rule_AtraceMessage;
+class FtraceConfig_TracefsOption;
+namespace perfetto_pbzero_enum_FtraceConfig_KprobeEvent {
+enum KprobeType : int32_t;
+}  // namespace perfetto_pbzero_enum_FtraceConfig_KprobeEvent
+using FtraceConfig_KprobeEvent_KprobeType = perfetto_pbzero_enum_FtraceConfig_KprobeEvent::KprobeType;
+namespace perfetto_pbzero_enum_FtraceConfig {
+enum KsymsMemPolicy : int32_t;
+}  // namespace perfetto_pbzero_enum_FtraceConfig
+using FtraceConfig_KsymsMemPolicy = perfetto_pbzero_enum_FtraceConfig::KsymsMemPolicy;
+namespace perfetto_pbzero_enum_FtraceConfig_TracefsOption {
+enum State : int32_t;
+}  // namespace perfetto_pbzero_enum_FtraceConfig_TracefsOption
+using FtraceConfig_TracefsOption_State = perfetto_pbzero_enum_FtraceConfig_TracefsOption::State;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-class StressTestConfig_WriterTiming;
-class TraceConfig;
+namespace perfetto_pbzero_enum_FtraceConfig {
+enum KsymsMemPolicy : int32_t {
+  KSYMS_UNSPECIFIED = 0,
+  KSYMS_CLEANUP_ON_STOP = 1,
+  KSYMS_RETAIN = 2,
+};
+} // namespace perfetto_pbzero_enum_FtraceConfig
+using FtraceConfig_KsymsMemPolicy = perfetto_pbzero_enum_FtraceConfig::KsymsMemPolicy;
+
+
+constexpr FtraceConfig_KsymsMemPolicy FtraceConfig_KsymsMemPolicy_MIN = FtraceConfig_KsymsMemPolicy::KSYMS_UNSPECIFIED;
+constexpr FtraceConfig_KsymsMemPolicy FtraceConfig_KsymsMemPolicy_MAX = FtraceConfig_KsymsMemPolicy::KSYMS_RETAIN;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* FtraceConfig_KsymsMemPolicy_Name(::perfetto::protos::pbzero::FtraceConfig_KsymsMemPolicy value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::FtraceConfig_KsymsMemPolicy::KSYMS_UNSPECIFIED:
+    return "KSYMS_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::FtraceConfig_KsymsMemPolicy::KSYMS_CLEANUP_ON_STOP:
+    return "KSYMS_CLEANUP_ON_STOP";
+
+  case ::perfetto::protos::pbzero::FtraceConfig_KsymsMemPolicy::KSYMS_RETAIN:
+    return "KSYMS_RETAIN";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_FtraceConfig_TracefsOption {
+enum State : int32_t {
+  STATE_UNKNOWN = 0,
+  STATE_ENABLED = 1,
+  STATE_DISABLED = 2,
+};
+} // namespace perfetto_pbzero_enum_FtraceConfig_TracefsOption
+using FtraceConfig_TracefsOption_State = perfetto_pbzero_enum_FtraceConfig_TracefsOption::State;
+
+
+constexpr FtraceConfig_TracefsOption_State FtraceConfig_TracefsOption_State_MIN = FtraceConfig_TracefsOption_State::STATE_UNKNOWN;
+constexpr FtraceConfig_TracefsOption_State FtraceConfig_TracefsOption_State_MAX = FtraceConfig_TracefsOption_State::STATE_DISABLED;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* FtraceConfig_TracefsOption_State_Name(::perfetto::protos::pbzero::FtraceConfig_TracefsOption_State value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::FtraceConfig_TracefsOption_State::STATE_UNKNOWN:
+    return "STATE_UNKNOWN";
+
+  case ::perfetto::protos::pbzero::FtraceConfig_TracefsOption_State::STATE_ENABLED:
+    return "STATE_ENABLED";
+
+  case ::perfetto::protos::pbzero::FtraceConfig_TracefsOption_State::STATE_DISABLED:
+    return "STATE_DISABLED";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_FtraceConfig_KprobeEvent {
+enum KprobeType : int32_t {
+  KPROBE_TYPE_UNKNOWN = 0,
+  KPROBE_TYPE_KPROBE = 1,
+  KPROBE_TYPE_KRETPROBE = 2,
+  KPROBE_TYPE_BOTH = 3,
+};
+} // namespace perfetto_pbzero_enum_FtraceConfig_KprobeEvent
+using FtraceConfig_KprobeEvent_KprobeType = perfetto_pbzero_enum_FtraceConfig_KprobeEvent::KprobeType;
+
+
+constexpr FtraceConfig_KprobeEvent_KprobeType FtraceConfig_KprobeEvent_KprobeType_MIN = FtraceConfig_KprobeEvent_KprobeType::KPROBE_TYPE_UNKNOWN;
+constexpr FtraceConfig_KprobeEvent_KprobeType FtraceConfig_KprobeEvent_KprobeType_MAX = FtraceConfig_KprobeEvent_KprobeType::KPROBE_TYPE_BOTH;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* FtraceConfig_KprobeEvent_KprobeType_Name(::perfetto::protos::pbzero::FtraceConfig_KprobeEvent_KprobeType value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::FtraceConfig_KprobeEvent_KprobeType::KPROBE_TYPE_UNKNOWN:
+    return "KPROBE_TYPE_UNKNOWN";
+
+  case ::perfetto::protos::pbzero::FtraceConfig_KprobeEvent_KprobeType::KPROBE_TYPE_KPROBE:
+    return "KPROBE_TYPE_KPROBE";
+
+  case ::perfetto::protos::pbzero::FtraceConfig_KprobeEvent_KprobeType::KPROBE_TYPE_KRETPROBE:
+    return "KPROBE_TYPE_KRETPROBE";
+
+  case ::perfetto::protos::pbzero::FtraceConfig_KprobeEvent_KprobeType::KPROBE_TYPE_BOTH:
+    return "KPROBE_TYPE_BOTH";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
-class StressTestConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class FtraceConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/37> {
  public:
-  StressTestConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit StressTestConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit StressTestConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_trace_config() const { return at<1>().valid(); }
-  ::protozero::ConstBytes trace_config() const { return at<1>().as_bytes(); }
-  bool has_shmem_size_kb() const { return at<2>().valid(); }
-  uint32_t shmem_size_kb() const { return at<2>().as_uint32(); }
-  bool has_shmem_page_size_kb() const { return at<3>().valid(); }
-  uint32_t shmem_page_size_kb() const { return at<3>().as_uint32(); }
-  bool has_num_processes() const { return at<4>().valid(); }
-  uint32_t num_processes() const { return at<4>().as_uint32(); }
-  bool has_num_threads() const { return at<5>().valid(); }
-  uint32_t num_threads() const { return at<5>().as_uint32(); }
-  bool has_max_events() const { return at<6>().valid(); }
-  uint32_t max_events() const { return at<6>().as_uint32(); }
-  bool has_nesting() const { return at<7>().valid(); }
-  uint32_t nesting() const { return at<7>().as_uint32(); }
-  bool has_steady_state_timings() const { return at<8>().valid(); }
-  ::protozero::ConstBytes steady_state_timings() const { return at<8>().as_bytes(); }
-  bool has_burst_period_ms() const { return at<9>().valid(); }
-  uint32_t burst_period_ms() const { return at<9>().as_uint32(); }
-  bool has_burst_duration_ms() const { return at<10>().valid(); }
-  uint32_t burst_duration_ms() const { return at<10>().as_uint32(); }
-  bool has_burst_timings() const { return at<11>().valid(); }
-  ::protozero::ConstBytes burst_timings() const { return at<11>().as_bytes(); }
+  FtraceConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FtraceConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FtraceConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_ftrace_events() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> ftrace_events() const { return GetRepeated<::protozero::ConstChars>(1); }
+  bool has_atrace_categories() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> atrace_categories() const { return GetRepeated<::protozero::ConstChars>(2); }
+  bool has_atrace_apps() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> atrace_apps() const { return GetRepeated<::protozero::ConstChars>(3); }
+  bool has_atrace_categories_prefer_sdk() const { return at<28>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> atrace_categories_prefer_sdk() const { return GetRepeated<::protozero::ConstChars>(28); }
+  bool has_atrace_userspace_only() const { return at<34>().valid(); }
+  bool atrace_userspace_only() const { return at<34>().as_bool(); }
+  bool has_buffer_size_kb() const { return at<10>().valid(); }
+  uint32_t buffer_size_kb() const { return at<10>().as_uint32(); }
+  bool has_buffer_size_lower_bound() const { return at<27>().valid(); }
+  bool buffer_size_lower_bound() const { return at<27>().as_bool(); }
+  bool has_drain_period_ms() const { return at<11>().valid(); }
+  uint32_t drain_period_ms() const { return at<11>().as_uint32(); }
+  bool has_drain_buffer_percent() const { return at<29>().valid(); }
+  uint32_t drain_buffer_percent() const { return at<29>().as_uint32(); }
+  bool has_compact_sched() const { return at<12>().valid(); }
+  ::protozero::ConstBytes compact_sched() const { return at<12>().as_bytes(); }
+  bool has_print_filter() const { return at<22>().valid(); }
+  ::protozero::ConstBytes print_filter() const { return at<22>().as_bytes(); }
+  bool has_symbolize_ksyms() const { return at<13>().valid(); }
+  bool symbolize_ksyms() const { return at<13>().as_bool(); }
+  bool has_ksyms_mem_policy() const { return at<17>().valid(); }
+  int32_t ksyms_mem_policy() const { return at<17>().as_int32(); }
+  bool has_throttle_rss_stat() const { return at<15>().valid(); }
+  bool throttle_rss_stat() const { return at<15>().as_bool(); }
+  bool has_denser_generic_event_encoding() const { return at<32>().valid(); }
+  bool denser_generic_event_encoding() const { return at<32>().as_bool(); }
+  bool has_disable_generic_events() const { return at<16>().valid(); }
+  bool disable_generic_events() const { return at<16>().as_bool(); }
+  bool has_syscall_events() const { return at<18>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> syscall_events() const { return GetRepeated<::protozero::ConstChars>(18); }
+  bool has_enable_function_graph() const { return at<19>().valid(); }
+  bool enable_function_graph() const { return at<19>().as_bool(); }
+  bool has_function_filters() const { return at<20>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> function_filters() const { return GetRepeated<::protozero::ConstChars>(20); }
+  bool has_function_graph_roots() const { return at<21>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> function_graph_roots() const { return GetRepeated<::protozero::ConstChars>(21); }
+  bool has_function_graph_max_depth() const { return at<33>().valid(); }
+  uint32_t function_graph_max_depth() const { return at<33>().as_uint32(); }
+  bool has_kprobe_events() const { return at<30>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> kprobe_events() const { return GetRepeated<::protozero::ConstBytes>(30); }
+  bool has_preserve_ftrace_buffer() const { return at<23>().valid(); }
+  bool preserve_ftrace_buffer() const { return at<23>().as_bool(); }
+  bool has_use_monotonic_raw_clock() const { return at<24>().valid(); }
+  bool use_monotonic_raw_clock() const { return at<24>().as_bool(); }
+  bool has_instance_name() const { return at<25>().valid(); }
+  ::protozero::ConstChars instance_name() const { return at<25>().as_string(); }
+  bool has_debug_ftrace_abi() const { return at<31>().valid(); }
+  bool debug_ftrace_abi() const { return at<31>().as_bool(); }
+  bool has_tids_to_trace() const { return at<35>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint32_t> tids_to_trace() const { return GetRepeated<uint32_t>(35); }
+  bool has_tracefs_options() const { return at<36>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> tracefs_options() const { return GetRepeated<::protozero::ConstBytes>(36); }
+  bool has_tracing_cpumask() const { return at<37>().valid(); }
+  ::protozero::ConstChars tracing_cpumask() const { return at<37>().as_string(); }
+  bool has_initialize_ksyms_synchronously_for_testing() const { return at<14>().valid(); }
+  bool initialize_ksyms_synchronously_for_testing() const { return at<14>().as_bool(); }
 };
 
-class StressTestConfig : public ::protozero::Message {
+class FtraceConfig : public ::protozero::Message {
  public:
-  using Decoder = StressTestConfig_Decoder;
+  using Decoder = FtraceConfig_Decoder;
   enum : int32_t {
-    kTraceConfigFieldNumber = 1,
-    kShmemSizeKbFieldNumber = 2,
-    kShmemPageSizeKbFieldNumber = 3,
-    kNumProcessesFieldNumber = 4,
-    kNumThreadsFieldNumber = 5,
-    kMaxEventsFieldNumber = 6,
-    kNestingFieldNumber = 7,
-    kSteadyStateTimingsFieldNumber = 8,
-    kBurstPeriodMsFieldNumber = 9,
-    kBurstDurationMsFieldNumber = 10,
-    kBurstTimingsFieldNumber = 11,
+    kFtraceEventsFieldNumber = 1,
+    kAtraceCategoriesFieldNumber = 2,
+    kAtraceAppsFieldNumber = 3,
+    kAtraceCategoriesPreferSdkFieldNumber = 28,
+    kAtraceUserspaceOnlyFieldNumber = 34,
+    kBufferSizeKbFieldNumber = 10,
+    kBufferSizeLowerBoundFieldNumber = 27,
+    kDrainPeriodMsFieldNumber = 11,
+    kDrainBufferPercentFieldNumber = 29,
+    kCompactSchedFieldNumber = 12,
+    kPrintFilterFieldNumber = 22,
+    kSymbolizeKsymsFieldNumber = 13,
+    kKsymsMemPolicyFieldNumber = 17,
+    kThrottleRssStatFieldNumber = 15,
+    kDenserGenericEventEncodingFieldNumber = 32,
+    kDisableGenericEventsFieldNumber = 16,
+    kSyscallEventsFieldNumber = 18,
+    kEnableFunctionGraphFieldNumber = 19,
+    kFunctionFiltersFieldNumber = 20,
+    kFunctionGraphRootsFieldNumber = 21,
+    kFunctionGraphMaxDepthFieldNumber = 33,
+    kKprobeEventsFieldNumber = 30,
+    kPreserveFtraceBufferFieldNumber = 23,
+    kUseMonotonicRawClockFieldNumber = 24,
+    kInstanceNameFieldNumber = 25,
+    kDebugFtraceAbiFieldNumber = 31,
+    kTidsToTraceFieldNumber = 35,
+    kTracefsOptionsFieldNumber = 36,
+    kTracingCpumaskFieldNumber = 37,
+    kInitializeKsymsSynchronouslyForTestingFieldNumber = 14,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.StressTestConfig"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.FtraceConfig"; }
 
-  using WriterTiming = ::perfetto::protos::pbzero::StressTestConfig_WriterTiming;
+  using CompactSchedConfig = ::perfetto::protos::pbzero::FtraceConfig_CompactSchedConfig;
+  using PrintFilter = ::perfetto::protos::pbzero::FtraceConfig_PrintFilter;
+  using KprobeEvent = ::perfetto::protos::pbzero::FtraceConfig_KprobeEvent;
+  using TracefsOption = ::perfetto::protos::pbzero::FtraceConfig_TracefsOption;
 
-  using FieldMetadata_TraceConfig =
+  using KsymsMemPolicy = ::perfetto::protos::pbzero::FtraceConfig_KsymsMemPolicy;
+  static inline const char* KsymsMemPolicy_Name(KsymsMemPolicy value) {
+    return ::perfetto::protos::pbzero::FtraceConfig_KsymsMemPolicy_Name(value);
+  }
+  static inline const KsymsMemPolicy KSYMS_UNSPECIFIED = KsymsMemPolicy::KSYMS_UNSPECIFIED;
+  static inline const KsymsMemPolicy KSYMS_CLEANUP_ON_STOP = KsymsMemPolicy::KSYMS_CLEANUP_ON_STOP;
+  static inline const KsymsMemPolicy KSYMS_RETAIN = KsymsMemPolicy::KSYMS_RETAIN;
+
+  using FieldMetadata_FtraceEvents =
     ::protozero::proto_utils::FieldMetadata<
       1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig,
-      StressTestConfig>;
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FtraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceConfig kTraceConfig() { return {}; }
-  template <typename T = TraceConfig> T* set_trace_config() {
-    return BeginNestedMessage<T>(1);
+  static constexpr FieldMetadata_FtraceEvents kFtraceEvents{};
+  void add_ftrace_events(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_FtraceEvents::kFieldId, data, size);
+  }
+  void add_ftrace_events(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_FtraceEvents::kFieldId, chars.data, chars.size);
+  }
+  void add_ftrace_events(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_FtraceEvents::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_ShmemSizeKb =
+  using FieldMetadata_AtraceCategories =
     ::protozero::proto_utils::FieldMetadata<
       2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      StressTestConfig>;
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FtraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ShmemSizeKb kShmemSizeKb() { return {}; }
-  void set_shmem_size_kb(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ShmemSizeKb::kFieldId;
+  static constexpr FieldMetadata_AtraceCategories kAtraceCategories{};
+  void add_atrace_categories(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_AtraceCategories::kFieldId, data, size);
+  }
+  void add_atrace_categories(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_AtraceCategories::kFieldId, chars.data, chars.size);
+  }
+  void add_atrace_categories(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_AtraceCategories::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ShmemPageSizeKb =
+  using FieldMetadata_AtraceApps =
     ::protozero::proto_utils::FieldMetadata<
       3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      StressTestConfig>;
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FtraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ShmemPageSizeKb kShmemPageSizeKb() { return {}; }
-  void set_shmem_page_size_kb(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ShmemPageSizeKb::kFieldId;
+  static constexpr FieldMetadata_AtraceApps kAtraceApps{};
+  void add_atrace_apps(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_AtraceApps::kFieldId, data, size);
+  }
+  void add_atrace_apps(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_AtraceApps::kFieldId, chars.data, chars.size);
+  }
+  void add_atrace_apps(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_AtraceApps::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NumProcesses =
+  using FieldMetadata_AtraceCategoriesPreferSdk =
     ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      StressTestConfig>;
+      28,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FtraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NumProcesses kNumProcesses() { return {}; }
-  void set_num_processes(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NumProcesses::kFieldId;
+  static constexpr FieldMetadata_AtraceCategoriesPreferSdk kAtraceCategoriesPreferSdk{};
+  void add_atrace_categories_prefer_sdk(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_AtraceCategoriesPreferSdk::kFieldId, data, size);
+  }
+  void add_atrace_categories_prefer_sdk(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_AtraceCategoriesPreferSdk::kFieldId, chars.data, chars.size);
+  }
+  void add_atrace_categories_prefer_sdk(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_AtraceCategoriesPreferSdk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NumThreads =
+  using FieldMetadata_AtraceUserspaceOnly =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      34,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      StressTestConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      FtraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NumThreads kNumThreads() { return {}; }
-  void set_num_threads(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NumThreads::kFieldId;
+  static constexpr FieldMetadata_AtraceUserspaceOnly kAtraceUserspaceOnly{};
+  void set_atrace_userspace_only(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_AtraceUserspaceOnly::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MaxEvents =
+  using FieldMetadata_BufferSizeKb =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      StressTestConfig>;
+      FtraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaxEvents kMaxEvents() { return {}; }
-  void set_max_events(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MaxEvents::kFieldId;
+  static constexpr FieldMetadata_BufferSizeKb kBufferSizeKb{};
+  void set_buffer_size_kb(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BufferSizeKb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -40890,70 +48682,35 @@ class StressTestConfig : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Nesting =
+  using FieldMetadata_BufferSizeLowerBound =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      27,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      StressTestConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      FtraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nesting kNesting() { return {}; }
-  void set_nesting(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Nesting::kFieldId;
+  static constexpr FieldMetadata_BufferSizeLowerBound kBufferSizeLowerBound{};
+  void set_buffer_size_lower_bound(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_BufferSizeLowerBound::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SteadyStateTimings =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      StressTestConfig_WriterTiming,
-      StressTestConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SteadyStateTimings kSteadyStateTimings() { return {}; }
-  template <typename T = StressTestConfig_WriterTiming> T* set_steady_state_timings() {
-    return BeginNestedMessage<T>(8);
-  }
-
-
-  using FieldMetadata_BurstPeriodMs =
+  using FieldMetadata_DrainPeriodMs =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      StressTestConfig>;
+      FtraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BurstPeriodMs kBurstPeriodMs() { return {}; }
-  void set_burst_period_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BurstPeriodMs::kFieldId;
+  static constexpr FieldMetadata_DrainPeriodMs kDrainPeriodMs{};
+  void set_drain_period_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DrainPeriodMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -40961,24 +48718,17 @@ class StressTestConfig : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BurstDurationMs =
+  using FieldMetadata_DrainBufferPercent =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      29,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      StressTestConfig>;
+      FtraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BurstDurationMs kBurstDurationMs() { return {}; }
-  void set_burst_duration_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BurstDurationMs::kFieldId;
+  static constexpr FieldMetadata_DrainBufferPercent kDrainBufferPercent{};
+  void set_drain_buffer_percent(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DrainBufferPercent::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -40986,261 +48736,225 @@ class StressTestConfig : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BurstTimings =
+  using FieldMetadata_CompactSched =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      12,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      StressTestConfig_WriterTiming,
-      StressTestConfig>;
+      FtraceConfig_CompactSchedConfig,
+      FtraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BurstTimings kBurstTimings() { return {}; }
-  template <typename T = StressTestConfig_WriterTiming> T* set_burst_timings() {
-    return BeginNestedMessage<T>(11);
+  static constexpr FieldMetadata_CompactSched kCompactSched{};
+  template <typename T = FtraceConfig_CompactSchedConfig> T* set_compact_sched() {
+    return BeginNestedMessage<T>(12);
   }
 
-};
 
-class StressTestConfig_WriterTiming_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  StressTestConfig_WriterTiming_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit StressTestConfig_WriterTiming_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit StressTestConfig_WriterTiming_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_payload_mean() const { return at<1>().valid(); }
-  double payload_mean() const { return at<1>().as_double(); }
-  bool has_payload_stddev() const { return at<2>().valid(); }
-  double payload_stddev() const { return at<2>().as_double(); }
-  bool has_rate_mean() const { return at<3>().valid(); }
-  double rate_mean() const { return at<3>().as_double(); }
-  bool has_rate_stddev() const { return at<4>().valid(); }
-  double rate_stddev() const { return at<4>().as_double(); }
-  bool has_payload_write_time_ms() const { return at<5>().valid(); }
-  uint32_t payload_write_time_ms() const { return at<5>().as_uint32(); }
-};
+  using FieldMetadata_PrintFilter =
+    ::protozero::proto_utils::FieldMetadata<
+      22,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FtraceConfig_PrintFilter,
+      FtraceConfig>;
 
-class StressTestConfig_WriterTiming : public ::protozero::Message {
- public:
-  using Decoder = StressTestConfig_WriterTiming_Decoder;
-  enum : int32_t {
-    kPayloadMeanFieldNumber = 1,
-    kPayloadStddevFieldNumber = 2,
-    kRateMeanFieldNumber = 3,
-    kRateStddevFieldNumber = 4,
-    kPayloadWriteTimeMsFieldNumber = 5,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.StressTestConfig.WriterTiming"; }
+  static constexpr FieldMetadata_PrintFilter kPrintFilter{};
+  template <typename T = FtraceConfig_PrintFilter> T* set_print_filter() {
+    return BeginNestedMessage<T>(22);
+  }
 
 
-  using FieldMetadata_PayloadMean =
+  using FieldMetadata_SymbolizeKsyms =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      13,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kDouble,
-      double,
-      StressTestConfig_WriterTiming>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      FtraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PayloadMean kPayloadMean() { return {}; }
-  void set_payload_mean(double value) {
-    static constexpr uint32_t field_id = FieldMetadata_PayloadMean::kFieldId;
+  static constexpr FieldMetadata_SymbolizeKsyms kSymbolizeKsyms{};
+  void set_symbolize_ksyms(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_SymbolizeKsyms::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PayloadStddev =
+  using FieldMetadata_KsymsMemPolicy =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      17,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kDouble,
-      double,
-      StressTestConfig_WriterTiming>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      FtraceConfig_KsymsMemPolicy,
+      FtraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PayloadStddev kPayloadStddev() { return {}; }
-  void set_payload_stddev(double value) {
-    static constexpr uint32_t field_id = FieldMetadata_PayloadStddev::kFieldId;
+  static constexpr FieldMetadata_KsymsMemPolicy kKsymsMemPolicy{};
+  void set_ksyms_mem_policy(FtraceConfig_KsymsMemPolicy value) {
+    static constexpr uint32_t field_id = FieldMetadata_KsymsMemPolicy::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_RateMean =
+  using FieldMetadata_ThrottleRssStat =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      15,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kDouble,
-      double,
-      StressTestConfig_WriterTiming>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      FtraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RateMean kRateMean() { return {}; }
-  void set_rate_mean(double value) {
-    static constexpr uint32_t field_id = FieldMetadata_RateMean::kFieldId;
+  static constexpr FieldMetadata_ThrottleRssStat kThrottleRssStat{};
+  void set_throttle_rss_stat(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ThrottleRssStat::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_RateStddev =
+  using FieldMetadata_DenserGenericEventEncoding =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      32,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kDouble,
-      double,
-      StressTestConfig_WriterTiming>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      FtraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RateStddev kRateStddev() { return {}; }
-  void set_rate_stddev(double value) {
-    static constexpr uint32_t field_id = FieldMetadata_RateStddev::kFieldId;
+  static constexpr FieldMetadata_DenserGenericEventEncoding kDenserGenericEventEncoding{};
+  void set_denser_generic_event_encoding(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DenserGenericEventEncoding::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PayloadWriteTimeMs =
+  using FieldMetadata_DisableGenericEvents =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      16,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      StressTestConfig_WriterTiming>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PayloadWriteTimeMs kPayloadWriteTimeMs() { return {}; }
-  void set_payload_write_time_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PayloadWriteTimeMs::kFieldId;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      FtraceConfig>;
+
+  static constexpr FieldMetadata_DisableGenericEvents kDisableGenericEvents{};
+  void set_disable_generic_events(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DisableGenericEvents::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/test_config.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TEST_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TEST_CONFIG_PROTO_H_
+  using FieldMetadata_SyscallEvents =
+    ::protozero::proto_utils::FieldMetadata<
+      18,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FtraceConfig>;
 
-#include <stddef.h>
-#include <stdint.h>
+  static constexpr FieldMetadata_SyscallEvents kSyscallEvents{};
+  void add_syscall_events(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_SyscallEvents::kFieldId, data, size);
+  }
+  void add_syscall_events(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_SyscallEvents::kFieldId, chars.data, chars.size);
+  }
+  void add_syscall_events(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_SyscallEvents::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  using FieldMetadata_EnableFunctionGraph =
+    ::protozero::proto_utils::FieldMetadata<
+      19,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      FtraceConfig>;
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  static constexpr FieldMetadata_EnableFunctionGraph kEnableFunctionGraph{};
+  void set_enable_function_graph(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_EnableFunctionGraph::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-class TestConfig_DummyFields;
+  using FieldMetadata_FunctionFilters =
+    ::protozero::proto_utils::FieldMetadata<
+      20,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FtraceConfig>;
 
-class TestConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TestConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TestConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TestConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_message_count() const { return at<1>().valid(); }
-  uint32_t message_count() const { return at<1>().as_uint32(); }
-  bool has_max_messages_per_second() const { return at<2>().valid(); }
-  uint32_t max_messages_per_second() const { return at<2>().as_uint32(); }
-  bool has_seed() const { return at<3>().valid(); }
-  uint32_t seed() const { return at<3>().as_uint32(); }
-  bool has_message_size() const { return at<4>().valid(); }
-  uint32_t message_size() const { return at<4>().as_uint32(); }
-  bool has_send_batch_on_register() const { return at<5>().valid(); }
-  bool send_batch_on_register() const { return at<5>().as_bool(); }
-  bool has_dummy_fields() const { return at<6>().valid(); }
-  ::protozero::ConstBytes dummy_fields() const { return at<6>().as_bytes(); }
-};
+  static constexpr FieldMetadata_FunctionFilters kFunctionFilters{};
+  void add_function_filters(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_FunctionFilters::kFieldId, data, size);
+  }
+  void add_function_filters(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_FunctionFilters::kFieldId, chars.data, chars.size);
+  }
+  void add_function_filters(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_FunctionFilters::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-class TestConfig : public ::protozero::Message {
- public:
-  using Decoder = TestConfig_Decoder;
-  enum : int32_t {
-    kMessageCountFieldNumber = 1,
-    kMaxMessagesPerSecondFieldNumber = 2,
-    kSeedFieldNumber = 3,
-    kMessageSizeFieldNumber = 4,
-    kSendBatchOnRegisterFieldNumber = 5,
-    kDummyFieldsFieldNumber = 6,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TestConfig"; }
+  using FieldMetadata_FunctionGraphRoots =
+    ::protozero::proto_utils::FieldMetadata<
+      21,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FtraceConfig>;
 
-  using DummyFields = ::perfetto::protos::pbzero::TestConfig_DummyFields;
+  static constexpr FieldMetadata_FunctionGraphRoots kFunctionGraphRoots{};
+  void add_function_graph_roots(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_FunctionGraphRoots::kFieldId, data, size);
+  }
+  void add_function_graph_roots(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_FunctionGraphRoots::kFieldId, chars.data, chars.size);
+  }
+  void add_function_graph_roots(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_FunctionGraphRoots::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_MessageCount =
+  using FieldMetadata_FunctionGraphMaxDepth =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      33,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      TestConfig>;
+      FtraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MessageCount kMessageCount() { return {}; }
-  void set_message_count(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MessageCount::kFieldId;
+  static constexpr FieldMetadata_FunctionGraphMaxDepth kFunctionGraphMaxDepth{};
+  void set_function_graph_max_depth(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FunctionGraphMaxDepth::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -41248,99 +48962,91 @@ class TestConfig : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MaxMessagesPerSecond =
+  using FieldMetadata_KprobeEvents =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      30,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FtraceConfig_KprobeEvent,
+      FtraceConfig>;
+
+  static constexpr FieldMetadata_KprobeEvents kKprobeEvents{};
+  template <typename T = FtraceConfig_KprobeEvent> T* add_kprobe_events() {
+    return BeginNestedMessage<T>(30);
+  }
+
+
+  using FieldMetadata_PreserveFtraceBuffer =
+    ::protozero::proto_utils::FieldMetadata<
+      23,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TestConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      FtraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaxMessagesPerSecond kMaxMessagesPerSecond() { return {}; }
-  void set_max_messages_per_second(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MaxMessagesPerSecond::kFieldId;
+  static constexpr FieldMetadata_PreserveFtraceBuffer kPreserveFtraceBuffer{};
+  void set_preserve_ftrace_buffer(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_PreserveFtraceBuffer::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Seed =
+  using FieldMetadata_UseMonotonicRawClock =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      24,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TestConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      FtraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Seed kSeed() { return {}; }
-  void set_seed(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Seed::kFieldId;
+  static constexpr FieldMetadata_UseMonotonicRawClock kUseMonotonicRawClock{};
+  void set_use_monotonic_raw_clock(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_UseMonotonicRawClock::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MessageSize =
+  using FieldMetadata_InstanceName =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      25,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TestConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FtraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MessageSize kMessageSize() { return {}; }
-  void set_message_size(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MessageSize::kFieldId;
+  static constexpr FieldMetadata_InstanceName kInstanceName{};
+  void set_instance_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_InstanceName::kFieldId, data, size);
+  }
+  void set_instance_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_InstanceName::kFieldId, chars.data, chars.size);
+  }
+  void set_instance_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_InstanceName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SendBatchOnRegister =
+  using FieldMetadata_DebugFtraceAbi =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      31,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kBool,
       bool,
-      TestConfig>;
+      FtraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SendBatchOnRegister kSendBatchOnRegister() { return {}; }
-  void set_send_batch_on_register(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_SendBatchOnRegister::kFieldId;
+  static constexpr FieldMetadata_DebugFtraceAbi kDebugFtraceAbi{};
+  void set_debug_ftrace_abi(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DebugFtraceAbi::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -41348,444 +49054,569 @@ class TestConfig : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DummyFields =
+  using FieldMetadata_TidsToTrace =
     ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      35,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FtraceConfig>;
+
+  static constexpr FieldMetadata_TidsToTrace kTidsToTrace{};
+  void add_tids_to_trace(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TidsToTrace::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TracefsOptions =
+    ::protozero::proto_utils::FieldMetadata<
+      36,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TestConfig_DummyFields,
-      TestConfig>;
+      FtraceConfig_TracefsOption,
+      FtraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DummyFields kDummyFields() { return {}; }
-  template <typename T = TestConfig_DummyFields> T* set_dummy_fields() {
-    return BeginNestedMessage<T>(6);
+  static constexpr FieldMetadata_TracefsOptions kTracefsOptions{};
+  template <typename T = FtraceConfig_TracefsOption> T* add_tracefs_options() {
+    return BeginNestedMessage<T>(36);
+  }
+
+
+  using FieldMetadata_TracingCpumask =
+    ::protozero::proto_utils::FieldMetadata<
+      37,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FtraceConfig>;
+
+  static constexpr FieldMetadata_TracingCpumask kTracingCpumask{};
+  void set_tracing_cpumask(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_TracingCpumask::kFieldId, data, size);
+  }
+  void set_tracing_cpumask(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_TracingCpumask::kFieldId, chars.data, chars.size);
+  }
+  void set_tracing_cpumask(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_TracingCpumask::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
   }
 
+  using FieldMetadata_InitializeKsymsSynchronouslyForTesting =
+    ::protozero::proto_utils::FieldMetadata<
+      14,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      FtraceConfig>;
+
+  static constexpr FieldMetadata_InitializeKsymsSynchronouslyForTesting kInitializeKsymsSynchronouslyForTesting{};
+  void set_initialize_ksyms_synchronously_for_testing(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_InitializeKsymsSynchronouslyForTesting::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class TestConfig_DummyFields_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/14, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class FtraceConfig_TracefsOption_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  TestConfig_DummyFields_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TestConfig_DummyFields_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TestConfig_DummyFields_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_field_uint32() const { return at<1>().valid(); }
-  uint32_t field_uint32() const { return at<1>().as_uint32(); }
-  bool has_field_int32() const { return at<2>().valid(); }
-  int32_t field_int32() const { return at<2>().as_int32(); }
-  bool has_field_uint64() const { return at<3>().valid(); }
-  uint64_t field_uint64() const { return at<3>().as_uint64(); }
-  bool has_field_int64() const { return at<4>().valid(); }
-  int64_t field_int64() const { return at<4>().as_int64(); }
-  bool has_field_fixed64() const { return at<5>().valid(); }
-  uint64_t field_fixed64() const { return at<5>().as_uint64(); }
-  bool has_field_sfixed64() const { return at<6>().valid(); }
-  int64_t field_sfixed64() const { return at<6>().as_int64(); }
-  bool has_field_fixed32() const { return at<7>().valid(); }
-  uint32_t field_fixed32() const { return at<7>().as_uint32(); }
-  bool has_field_sfixed32() const { return at<8>().valid(); }
-  int32_t field_sfixed32() const { return at<8>().as_int32(); }
-  bool has_field_double() const { return at<9>().valid(); }
-  double field_double() const { return at<9>().as_double(); }
-  bool has_field_float() const { return at<10>().valid(); }
-  float field_float() const { return at<10>().as_float(); }
-  bool has_field_sint64() const { return at<11>().valid(); }
-  int64_t field_sint64() const { return at<11>().as_int64(); }
-  bool has_field_sint32() const { return at<12>().valid(); }
-  int32_t field_sint32() const { return at<12>().as_int32(); }
-  bool has_field_string() const { return at<13>().valid(); }
-  ::protozero::ConstChars field_string() const { return at<13>().as_string(); }
-  bool has_field_bytes() const { return at<14>().valid(); }
-  ::protozero::ConstBytes field_bytes() const { return at<14>().as_bytes(); }
+  FtraceConfig_TracefsOption_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FtraceConfig_TracefsOption_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FtraceConfig_TracefsOption_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_state() const { return at<2>().valid(); }
+  int32_t state() const { return at<2>().as_int32(); }
 };
 
-class TestConfig_DummyFields : public ::protozero::Message {
+class FtraceConfig_TracefsOption : public ::protozero::Message {
  public:
-  using Decoder = TestConfig_DummyFields_Decoder;
+  using Decoder = FtraceConfig_TracefsOption_Decoder;
   enum : int32_t {
-    kFieldUint32FieldNumber = 1,
-    kFieldInt32FieldNumber = 2,
-    kFieldUint64FieldNumber = 3,
-    kFieldInt64FieldNumber = 4,
-    kFieldFixed64FieldNumber = 5,
-    kFieldSfixed64FieldNumber = 6,
-    kFieldFixed32FieldNumber = 7,
-    kFieldSfixed32FieldNumber = 8,
-    kFieldDoubleFieldNumber = 9,
-    kFieldFloatFieldNumber = 10,
-    kFieldSint64FieldNumber = 11,
-    kFieldSint32FieldNumber = 12,
-    kFieldStringFieldNumber = 13,
-    kFieldBytesFieldNumber = 14,
+    kNameFieldNumber = 1,
+    kStateFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TestConfig.DummyFields"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.FtraceConfig.TracefsOption"; }
 
 
-  using FieldMetadata_FieldUint32 =
+  using State = ::perfetto::protos::pbzero::FtraceConfig_TracefsOption_State;
+  static inline const char* State_Name(State value) {
+    return ::perfetto::protos::pbzero::FtraceConfig_TracefsOption_State_Name(value);
+  }
+  static inline const State STATE_UNKNOWN = State::STATE_UNKNOWN;
+  static inline const State STATE_ENABLED = State::STATE_ENABLED;
+  static inline const State STATE_DISABLED = State::STATE_DISABLED;
+
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TestConfig_DummyFields>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FtraceConfig_TracefsOption>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FieldUint32 kFieldUint32() { return {}; }
-  void set_field_uint32(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FieldUint32::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FieldInt32 =
+  using FieldMetadata_State =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TestConfig_DummyFields>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      FtraceConfig_TracefsOption_State,
+      FtraceConfig_TracefsOption>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FieldInt32 kFieldInt32() { return {}; }
-  void set_field_int32(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FieldInt32::kFieldId;
+  static constexpr FieldMetadata_State kState{};
+  void set_state(FtraceConfig_TracefsOption_State value) {
+    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_FieldUint64 =
+class FtraceConfig_KprobeEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  FtraceConfig_KprobeEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FtraceConfig_KprobeEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FtraceConfig_KprobeEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_probe() const { return at<1>().valid(); }
+  ::protozero::ConstChars probe() const { return at<1>().as_string(); }
+  bool has_type() const { return at<2>().valid(); }
+  int32_t type() const { return at<2>().as_int32(); }
+};
+
+class FtraceConfig_KprobeEvent : public ::protozero::Message {
+ public:
+  using Decoder = FtraceConfig_KprobeEvent_Decoder;
+  enum : int32_t {
+    kProbeFieldNumber = 1,
+    kTypeFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FtraceConfig.KprobeEvent"; }
+
+
+  using KprobeType = ::perfetto::protos::pbzero::FtraceConfig_KprobeEvent_KprobeType;
+  static inline const char* KprobeType_Name(KprobeType value) {
+    return ::perfetto::protos::pbzero::FtraceConfig_KprobeEvent_KprobeType_Name(value);
+  }
+  static inline const KprobeType KPROBE_TYPE_UNKNOWN = KprobeType::KPROBE_TYPE_UNKNOWN;
+  static inline const KprobeType KPROBE_TYPE_KPROBE = KprobeType::KPROBE_TYPE_KPROBE;
+  static inline const KprobeType KPROBE_TYPE_KRETPROBE = KprobeType::KPROBE_TYPE_KRETPROBE;
+  static inline const KprobeType KPROBE_TYPE_BOTH = KprobeType::KPROBE_TYPE_BOTH;
+
+  using FieldMetadata_Probe =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TestConfig_DummyFields>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FtraceConfig_KprobeEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FieldUint64 kFieldUint64() { return {}; }
-  void set_field_uint64(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FieldUint64::kFieldId;
+  static constexpr FieldMetadata_Probe kProbe{};
+  void set_probe(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Probe::kFieldId, data, size);
+  }
+  void set_probe(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Probe::kFieldId, chars.data, chars.size);
+  }
+  void set_probe(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Probe::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FieldInt64 =
+  using FieldMetadata_Type =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TestConfig_DummyFields>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      FtraceConfig_KprobeEvent_KprobeType,
+      FtraceConfig_KprobeEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FieldInt64 kFieldInt64() { return {}; }
-  void set_field_int64(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FieldInt64::kFieldId;
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(FtraceConfig_KprobeEvent_KprobeType value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_FieldFixed64 =
+class FtraceConfig_PrintFilter_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  FtraceConfig_PrintFilter_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FtraceConfig_PrintFilter_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FtraceConfig_PrintFilter_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_rules() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> rules() const { return GetRepeated<::protozero::ConstBytes>(1); }
+};
+
+class FtraceConfig_PrintFilter : public ::protozero::Message {
+ public:
+  using Decoder = FtraceConfig_PrintFilter_Decoder;
+  enum : int32_t {
+    kRulesFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FtraceConfig.PrintFilter"; }
+
+  using Rule = ::perfetto::protos::pbzero::FtraceConfig_PrintFilter_Rule;
+
+  using FieldMetadata_Rules =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FtraceConfig_PrintFilter_Rule,
+      FtraceConfig_PrintFilter>;
+
+  static constexpr FieldMetadata_Rules kRules{};
+  template <typename T = FtraceConfig_PrintFilter_Rule> T* add_rules() {
+    return BeginNestedMessage<T>(1);
+  }
+
+};
+
+class FtraceConfig_PrintFilter_Rule_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  FtraceConfig_PrintFilter_Rule_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FtraceConfig_PrintFilter_Rule_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FtraceConfig_PrintFilter_Rule_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_prefix() const { return at<1>().valid(); }
+  ::protozero::ConstChars prefix() const { return at<1>().as_string(); }
+  bool has_atrace_msg() const { return at<3>().valid(); }
+  ::protozero::ConstBytes atrace_msg() const { return at<3>().as_bytes(); }
+  bool has_allow() const { return at<2>().valid(); }
+  bool allow() const { return at<2>().as_bool(); }
+};
+
+class FtraceConfig_PrintFilter_Rule : public ::protozero::Message {
+ public:
+  using Decoder = FtraceConfig_PrintFilter_Rule_Decoder;
+  enum : int32_t {
+    kPrefixFieldNumber = 1,
+    kAtraceMsgFieldNumber = 3,
+    kAllowFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FtraceConfig.PrintFilter.Rule"; }
+
+  using AtraceMessage = ::perfetto::protos::pbzero::FtraceConfig_PrintFilter_Rule_AtraceMessage;
+
+  using FieldMetadata_Prefix =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
-      uint64_t,
-      TestConfig_DummyFields>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FtraceConfig_PrintFilter_Rule>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FieldFixed64 kFieldFixed64() { return {}; }
-  void set_field_fixed64(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FieldFixed64::kFieldId;
+  static constexpr FieldMetadata_Prefix kPrefix{};
+  void set_prefix(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Prefix::kFieldId, data, size);
+  }
+  void set_prefix(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Prefix::kFieldId, chars.data, chars.size);
+  }
+  void set_prefix(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prefix::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FieldSfixed64 =
+  using FieldMetadata_AtraceMsg =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kSfixed64,
-      int64_t,
-      TestConfig_DummyFields>;
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FtraceConfig_PrintFilter_Rule_AtraceMessage,
+      FtraceConfig_PrintFilter_Rule>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FieldSfixed64 kFieldSfixed64() { return {}; }
-  void set_field_sfixed64(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FieldSfixed64::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kSfixed64>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_AtraceMsg kAtraceMsg{};
+  template <typename T = FtraceConfig_PrintFilter_Rule_AtraceMessage> T* set_atrace_msg() {
+    return BeginNestedMessage<T>(3);
   }
 
-  using FieldMetadata_FieldFixed32 =
+
+  using FieldMetadata_Allow =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kFixed32,
-      uint32_t,
-      TestConfig_DummyFields>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      FtraceConfig_PrintFilter_Rule>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FieldFixed32 kFieldFixed32() { return {}; }
-  void set_field_fixed32(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FieldFixed32::kFieldId;
+  static constexpr FieldMetadata_Allow kAllow{};
+  void set_allow(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_Allow::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kFixed32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_FieldSfixed32 =
+class FtraceConfig_PrintFilter_Rule_AtraceMessage_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  FtraceConfig_PrintFilter_Rule_AtraceMessage_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FtraceConfig_PrintFilter_Rule_AtraceMessage_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FtraceConfig_PrintFilter_Rule_AtraceMessage_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_type() const { return at<1>().valid(); }
+  ::protozero::ConstChars type() const { return at<1>().as_string(); }
+  bool has_prefix() const { return at<2>().valid(); }
+  ::protozero::ConstChars prefix() const { return at<2>().as_string(); }
+};
+
+class FtraceConfig_PrintFilter_Rule_AtraceMessage : public ::protozero::Message {
+ public:
+  using Decoder = FtraceConfig_PrintFilter_Rule_AtraceMessage_Decoder;
+  enum : int32_t {
+    kTypeFieldNumber = 1,
+    kPrefixFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FtraceConfig.PrintFilter.Rule.AtraceMessage"; }
+
+
+  using FieldMetadata_Type =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kSfixed32,
-      int32_t,
-      TestConfig_DummyFields>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FtraceConfig_PrintFilter_Rule_AtraceMessage>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FieldSfixed32 kFieldSfixed32() { return {}; }
-  void set_field_sfixed32(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FieldSfixed32::kFieldId;
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Type::kFieldId, data, size);
+  }
+  void set_type(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Type::kFieldId, chars.data, chars.size);
+  }
+  void set_type(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kSfixed32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FieldDouble =
+  using FieldMetadata_Prefix =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kDouble,
-      double,
-      TestConfig_DummyFields>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FtraceConfig_PrintFilter_Rule_AtraceMessage>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FieldDouble kFieldDouble() { return {}; }
-  void set_field_double(double value) {
-    static constexpr uint32_t field_id = FieldMetadata_FieldDouble::kFieldId;
+  static constexpr FieldMetadata_Prefix kPrefix{};
+  void set_prefix(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Prefix::kFieldId, data, size);
+  }
+  void set_prefix(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Prefix::kFieldId, chars.data, chars.size);
+  }
+  void set_prefix(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prefix::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_FieldFloat =
+class FtraceConfig_CompactSchedConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  FtraceConfig_CompactSchedConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FtraceConfig_CompactSchedConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FtraceConfig_CompactSchedConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_enabled() const { return at<1>().valid(); }
+  bool enabled() const { return at<1>().as_bool(); }
+};
+
+class FtraceConfig_CompactSchedConfig : public ::protozero::Message {
+ public:
+  using Decoder = FtraceConfig_CompactSchedConfig_Decoder;
+  enum : int32_t {
+    kEnabledFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FtraceConfig.CompactSchedConfig"; }
+
+
+  using FieldMetadata_Enabled =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kFloat,
-      float,
-      TestConfig_DummyFields>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      FtraceConfig_CompactSchedConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FieldFloat kFieldFloat() { return {}; }
-  void set_field_float(float value) {
-    static constexpr uint32_t field_id = FieldMetadata_FieldFloat::kFieldId;
+  static constexpr FieldMetadata_Enabled kEnabled{};
+  void set_enabled(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_Enabled::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_FieldSint64 =
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/gpu/gpu_counter_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_GPU_COUNTER_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_GPU_COUNTER_CONFIG_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class GpuCounterConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  GpuCounterConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GpuCounterConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GpuCounterConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_counter_period_ns() const { return at<1>().valid(); }
+  uint64_t counter_period_ns() const { return at<1>().as_uint64(); }
+  bool has_counter_ids() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint32_t> counter_ids() const { return GetRepeated<uint32_t>(2); }
+  bool has_instrumented_sampling() const { return at<3>().valid(); }
+  bool instrumented_sampling() const { return at<3>().as_bool(); }
+  bool has_fix_gpu_clock() const { return at<4>().valid(); }
+  bool fix_gpu_clock() const { return at<4>().as_bool(); }
+};
+
+class GpuCounterConfig : public ::protozero::Message {
+ public:
+  using Decoder = GpuCounterConfig_Decoder;
+  enum : int32_t {
+    kCounterPeriodNsFieldNumber = 1,
+    kCounterIdsFieldNumber = 2,
+    kInstrumentedSamplingFieldNumber = 3,
+    kFixGpuClockFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.GpuCounterConfig"; }
+
+
+  using FieldMetadata_CounterPeriodNs =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kSint64,
-      int64_t,
-      TestConfig_DummyFields>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      GpuCounterConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FieldSint64 kFieldSint64() { return {}; }
-  void set_field_sint64(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FieldSint64::kFieldId;
+  static constexpr FieldMetadata_CounterPeriodNs kCounterPeriodNs{};
+  void set_counter_period_ns(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CounterPeriodNs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kSint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FieldSint32 =
+  using FieldMetadata_CounterIds =
     ::protozero::proto_utils::FieldMetadata<
-      12,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kSint32,
-      int32_t,
-      TestConfig_DummyFields>;
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      GpuCounterConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FieldSint32 kFieldSint32() { return {}; }
-  void set_field_sint32(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FieldSint32::kFieldId;
+  static constexpr FieldMetadata_CounterIds kCounterIds{};
+  void add_counter_ids(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CounterIds::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kSint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FieldString =
+  using FieldMetadata_InstrumentedSampling =
     ::protozero::proto_utils::FieldMetadata<
-      13,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TestConfig_DummyFields>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      GpuCounterConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FieldString kFieldString() { return {}; }
-  void set_field_string(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_FieldString::kFieldId, data, size);
-  }
-  void set_field_string(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_FieldString::kFieldId, chars.data, chars.size);
-  }
-  void set_field_string(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_FieldString::kFieldId;
+  static constexpr FieldMetadata_InstrumentedSampling kInstrumentedSampling{};
+  void set_instrumented_sampling(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_InstrumentedSampling::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FieldBytes =
+  using FieldMetadata_FixGpuClock =
     ::protozero::proto_utils::FieldMetadata<
-      14,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBytes,
-      std::string,
-      TestConfig_DummyFields>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      GpuCounterConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FieldBytes kFieldBytes() { return {}; }
-  void set_field_bytes(const uint8_t* data, size_t size) {
-    AppendBytes(FieldMetadata_FieldBytes::kFieldId, data, size);
-  }
-  void set_field_bytes(::protozero::ConstBytes bytes) {
-    AppendBytes(FieldMetadata_FieldBytes::kFieldId, bytes.data, bytes.size);
-  }
-  void set_field_bytes(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_FieldBytes::kFieldId;
+  static constexpr FieldMetadata_FixGpuClock kFixGpuClock{};
+  void set_fix_gpu_clock(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_FixGpuClock::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 };
@@ -41794,11 +49625,11 @@ class TestConfig_DummyFields : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/config/trace_config.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/config/gpu/gpu_renderstages_config.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TRACE_CONFIG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TRACE_CONFIG_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_GPU_RENDERSTAGES_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_GPU_RENDERSTAGES_CONFIG_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -41809,417 +49640,272 @@ class TestConfig_DummyFields : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-class DataSourceConfig;
-class TraceConfig_AndroidReportConfig;
-class TraceConfig_BufferConfig;
-class TraceConfig_BuiltinDataSource;
-class TraceConfig_CmdTraceStartDelay;
-class TraceConfig_DataSource;
-class TraceConfig_GuardrailOverrides;
-class TraceConfig_IncidentReportConfig;
-class TraceConfig_IncrementalStateConfig;
-class TraceConfig_ProducerConfig;
-class TraceConfig_StatsdMetadata;
-class TraceConfig_TraceFilter;
-class TraceConfig_TriggerConfig;
-class TraceConfig_TriggerConfig_Trigger;
-enum BuiltinClock : int32_t;
-namespace perfetto_pbzero_enum_TraceConfig_BufferConfig {
-enum FillPolicy : int32_t;
-}  // namespace perfetto_pbzero_enum_TraceConfig_BufferConfig
-using TraceConfig_BufferConfig_FillPolicy = perfetto_pbzero_enum_TraceConfig_BufferConfig::FillPolicy;
-namespace perfetto_pbzero_enum_TraceConfig {
-enum CompressionType : int32_t;
-}  // namespace perfetto_pbzero_enum_TraceConfig
-using TraceConfig_CompressionType = perfetto_pbzero_enum_TraceConfig::CompressionType;
-namespace perfetto_pbzero_enum_TraceConfig {
-enum LockdownModeOperation : int32_t;
-}  // namespace perfetto_pbzero_enum_TraceConfig
-using TraceConfig_LockdownModeOperation = perfetto_pbzero_enum_TraceConfig::LockdownModeOperation;
-namespace perfetto_pbzero_enum_TraceConfig {
-enum StatsdLogging : int32_t;
-}  // namespace perfetto_pbzero_enum_TraceConfig
-using TraceConfig_StatsdLogging = perfetto_pbzero_enum_TraceConfig::StatsdLogging;
-namespace perfetto_pbzero_enum_TraceConfig_TriggerConfig {
-enum TriggerMode : int32_t;
-}  // namespace perfetto_pbzero_enum_TraceConfig_TriggerConfig
-using TraceConfig_TriggerConfig_TriggerMode = perfetto_pbzero_enum_TraceConfig_TriggerConfig::TriggerMode;
-
-namespace perfetto_pbzero_enum_TraceConfig {
-enum LockdownModeOperation : int32_t {
-  LOCKDOWN_UNCHANGED = 0,
-  LOCKDOWN_CLEAR = 1,
-  LOCKDOWN_SET = 2,
+class GpuRenderStagesConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  GpuRenderStagesConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GpuRenderStagesConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GpuRenderStagesConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_full_loadstore() const { return at<1>().valid(); }
+  bool full_loadstore() const { return at<1>().as_bool(); }
+  bool has_low_overhead() const { return at<2>().valid(); }
+  bool low_overhead() const { return at<2>().as_bool(); }
+  bool has_trace_metrics() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> trace_metrics() const { return GetRepeated<::protozero::ConstChars>(3); }
 };
-} // namespace perfetto_pbzero_enum_TraceConfig
-using TraceConfig_LockdownModeOperation = perfetto_pbzero_enum_TraceConfig::LockdownModeOperation;
-
-
-constexpr TraceConfig_LockdownModeOperation TraceConfig_LockdownModeOperation_MIN = TraceConfig_LockdownModeOperation::LOCKDOWN_UNCHANGED;
-constexpr TraceConfig_LockdownModeOperation TraceConfig_LockdownModeOperation_MAX = TraceConfig_LockdownModeOperation::LOCKDOWN_SET;
 
+class GpuRenderStagesConfig : public ::protozero::Message {
+ public:
+  using Decoder = GpuRenderStagesConfig_Decoder;
+  enum : int32_t {
+    kFullLoadstoreFieldNumber = 1,
+    kLowOverheadFieldNumber = 2,
+    kTraceMetricsFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.GpuRenderStagesConfig"; }
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* TraceConfig_LockdownModeOperation_Name(::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation::LOCKDOWN_UNCHANGED:
-    return "LOCKDOWN_UNCHANGED";
 
-  case ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation::LOCKDOWN_CLEAR:
-    return "LOCKDOWN_CLEAR";
+  using FieldMetadata_FullLoadstore =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      GpuRenderStagesConfig>;
 
-  case ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation::LOCKDOWN_SET:
-    return "LOCKDOWN_SET";
+  static constexpr FieldMetadata_FullLoadstore kFullLoadstore{};
+  void set_full_loadstore(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_FullLoadstore::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-namespace perfetto_pbzero_enum_TraceConfig {
-enum CompressionType : int32_t {
-  COMPRESSION_TYPE_UNSPECIFIED = 0,
-  COMPRESSION_TYPE_DEFLATE = 1,
-};
-} // namespace perfetto_pbzero_enum_TraceConfig
-using TraceConfig_CompressionType = perfetto_pbzero_enum_TraceConfig::CompressionType;
-
 
-constexpr TraceConfig_CompressionType TraceConfig_CompressionType_MIN = TraceConfig_CompressionType::COMPRESSION_TYPE_UNSPECIFIED;
-constexpr TraceConfig_CompressionType TraceConfig_CompressionType_MAX = TraceConfig_CompressionType::COMPRESSION_TYPE_DEFLATE;
+  using FieldMetadata_LowOverhead =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      GpuRenderStagesConfig>;
 
+  static constexpr FieldMetadata_LowOverhead kLowOverhead{};
+  void set_low_overhead(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_LowOverhead::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* TraceConfig_CompressionType_Name(::perfetto::protos::pbzero::TraceConfig_CompressionType value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::TraceConfig_CompressionType::COMPRESSION_TYPE_UNSPECIFIED:
-    return "COMPRESSION_TYPE_UNSPECIFIED";
+  using FieldMetadata_TraceMetrics =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      GpuRenderStagesConfig>;
 
-  case ::perfetto::protos::pbzero::TraceConfig_CompressionType::COMPRESSION_TYPE_DEFLATE:
-    return "COMPRESSION_TYPE_DEFLATE";
+  static constexpr FieldMetadata_TraceMetrics kTraceMetrics{};
+  void add_trace_metrics(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_TraceMetrics::kFieldId, data, size);
+  }
+  void add_trace_metrics(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_TraceMetrics::kFieldId, chars.data, chars.size);
+  }
+  void add_trace_metrics(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_TraceMetrics::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-namespace perfetto_pbzero_enum_TraceConfig {
-enum StatsdLogging : int32_t {
-  STATSD_LOGGING_UNSPECIFIED = 0,
-  STATSD_LOGGING_ENABLED = 1,
-  STATSD_LOGGING_DISABLED = 2,
 };
-} // namespace perfetto_pbzero_enum_TraceConfig
-using TraceConfig_StatsdLogging = perfetto_pbzero_enum_TraceConfig::StatsdLogging;
 
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/gpu/vulkan_memory_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-constexpr TraceConfig_StatsdLogging TraceConfig_StatsdLogging_MIN = TraceConfig_StatsdLogging::STATSD_LOGGING_UNSPECIFIED;
-constexpr TraceConfig_StatsdLogging TraceConfig_StatsdLogging_MAX = TraceConfig_StatsdLogging::STATSD_LOGGING_DISABLED;
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_VULKAN_MEMORY_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_VULKAN_MEMORY_CONFIG_PROTO_H_
 
+#include <stddef.h>
+#include <stdint.h>
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* TraceConfig_StatsdLogging_Name(::perfetto::protos::pbzero::TraceConfig_StatsdLogging value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::TraceConfig_StatsdLogging::STATSD_LOGGING_UNSPECIFIED:
-    return "STATSD_LOGGING_UNSPECIFIED";
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  case ::perfetto::protos::pbzero::TraceConfig_StatsdLogging::STATSD_LOGGING_ENABLED:
-    return "STATSD_LOGGING_ENABLED";
 
-  case ::perfetto::protos::pbzero::TraceConfig_StatsdLogging::STATSD_LOGGING_DISABLED:
-    return "STATSD_LOGGING_DISABLED";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-namespace perfetto_pbzero_enum_TraceConfig_TriggerConfig {
-enum TriggerMode : int32_t {
-  UNSPECIFIED = 0,
-  START_TRACING = 1,
-  STOP_TRACING = 2,
+class VulkanMemoryConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  VulkanMemoryConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit VulkanMemoryConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit VulkanMemoryConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_track_driver_memory_usage() const { return at<1>().valid(); }
+  bool track_driver_memory_usage() const { return at<1>().as_bool(); }
+  bool has_track_device_memory_usage() const { return at<2>().valid(); }
+  bool track_device_memory_usage() const { return at<2>().as_bool(); }
 };
-} // namespace perfetto_pbzero_enum_TraceConfig_TriggerConfig
-using TraceConfig_TriggerConfig_TriggerMode = perfetto_pbzero_enum_TraceConfig_TriggerConfig::TriggerMode;
 
+class VulkanMemoryConfig : public ::protozero::Message {
+ public:
+  using Decoder = VulkanMemoryConfig_Decoder;
+  enum : int32_t {
+    kTrackDriverMemoryUsageFieldNumber = 1,
+    kTrackDeviceMemoryUsageFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.VulkanMemoryConfig"; }
 
-constexpr TraceConfig_TriggerConfig_TriggerMode TraceConfig_TriggerConfig_TriggerMode_MIN = TraceConfig_TriggerConfig_TriggerMode::UNSPECIFIED;
-constexpr TraceConfig_TriggerConfig_TriggerMode TraceConfig_TriggerConfig_TriggerMode_MAX = TraceConfig_TriggerConfig_TriggerMode::STOP_TRACING;
 
+  using FieldMetadata_TrackDriverMemoryUsage =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      VulkanMemoryConfig>;
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* TraceConfig_TriggerConfig_TriggerMode_Name(::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode::UNSPECIFIED:
-    return "UNSPECIFIED";
+  static constexpr FieldMetadata_TrackDriverMemoryUsage kTrackDriverMemoryUsage{};
+  void set_track_driver_memory_usage(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_TrackDriverMemoryUsage::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-  case ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode::START_TRACING:
-    return "START_TRACING";
+  using FieldMetadata_TrackDeviceMemoryUsage =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      VulkanMemoryConfig>;
 
-  case ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode::STOP_TRACING:
-    return "STOP_TRACING";
+  static constexpr FieldMetadata_TrackDeviceMemoryUsage kTrackDeviceMemoryUsage{};
+  void set_track_device_memory_usage(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_TrackDeviceMemoryUsage::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-namespace perfetto_pbzero_enum_TraceConfig_BufferConfig {
-enum FillPolicy : int32_t {
-  UNSPECIFIED = 0,
-  RING_BUFFER = 1,
-  DISCARD = 2,
 };
-} // namespace perfetto_pbzero_enum_TraceConfig_BufferConfig
-using TraceConfig_BufferConfig_FillPolicy = perfetto_pbzero_enum_TraceConfig_BufferConfig::FillPolicy;
 
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/inode_file/inode_file_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-constexpr TraceConfig_BufferConfig_FillPolicy TraceConfig_BufferConfig_FillPolicy_MIN = TraceConfig_BufferConfig_FillPolicy::UNSPECIFIED;
-constexpr TraceConfig_BufferConfig_FillPolicy TraceConfig_BufferConfig_FillPolicy_MAX = TraceConfig_BufferConfig_FillPolicy::DISCARD;
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INODE_FILE_INODE_FILE_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INODE_FILE_INODE_FILE_CONFIG_PROTO_H_
 
+#include <stddef.h>
+#include <stdint.h>
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* TraceConfig_BufferConfig_FillPolicy_Name(::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy::UNSPECIFIED:
-    return "UNSPECIFIED";
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  case ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy::RING_BUFFER:
-    return "RING_BUFFER";
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class InodeFileConfig_MountPointMappingEntry;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-  case ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy::DISCARD:
-    return "DISCARD";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-class TraceConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/36, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class InodeFileConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  TraceConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_buffers() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> buffers() const { return GetRepeated<::protozero::ConstBytes>(1); }
-  bool has_data_sources() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> data_sources() const { return GetRepeated<::protozero::ConstBytes>(2); }
-  bool has_builtin_data_sources() const { return at<20>().valid(); }
-  ::protozero::ConstBytes builtin_data_sources() const { return at<20>().as_bytes(); }
-  bool has_duration_ms() const { return at<3>().valid(); }
-  uint32_t duration_ms() const { return at<3>().as_uint32(); }
-  bool has_prefer_suspend_clock_for_duration() const { return at<36>().valid(); }
-  bool prefer_suspend_clock_for_duration() const { return at<36>().as_bool(); }
-  bool has_enable_extra_guardrails() const { return at<4>().valid(); }
-  bool enable_extra_guardrails() const { return at<4>().as_bool(); }
-  bool has_lockdown_mode() const { return at<5>().valid(); }
-  int32_t lockdown_mode() const { return at<5>().as_int32(); }
-  bool has_producers() const { return at<6>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> producers() const { return GetRepeated<::protozero::ConstBytes>(6); }
-  bool has_statsd_metadata() const { return at<7>().valid(); }
-  ::protozero::ConstBytes statsd_metadata() const { return at<7>().as_bytes(); }
-  bool has_write_into_file() const { return at<8>().valid(); }
-  bool write_into_file() const { return at<8>().as_bool(); }
-  bool has_output_path() const { return at<29>().valid(); }
-  ::protozero::ConstChars output_path() const { return at<29>().as_string(); }
-  bool has_file_write_period_ms() const { return at<9>().valid(); }
-  uint32_t file_write_period_ms() const { return at<9>().as_uint32(); }
-  bool has_max_file_size_bytes() const { return at<10>().valid(); }
-  uint64_t max_file_size_bytes() const { return at<10>().as_uint64(); }
-  bool has_guardrail_overrides() const { return at<11>().valid(); }
-  ::protozero::ConstBytes guardrail_overrides() const { return at<11>().as_bytes(); }
-  bool has_deferred_start() const { return at<12>().valid(); }
-  bool deferred_start() const { return at<12>().as_bool(); }
-  bool has_flush_period_ms() const { return at<13>().valid(); }
-  uint32_t flush_period_ms() const { return at<13>().as_uint32(); }
-  bool has_flush_timeout_ms() const { return at<14>().valid(); }
-  uint32_t flush_timeout_ms() const { return at<14>().as_uint32(); }
-  bool has_data_source_stop_timeout_ms() const { return at<23>().valid(); }
-  uint32_t data_source_stop_timeout_ms() const { return at<23>().as_uint32(); }
-  bool has_notify_traceur() const { return at<16>().valid(); }
-  bool notify_traceur() const { return at<16>().as_bool(); }
-  bool has_bugreport_score() const { return at<30>().valid(); }
-  int32_t bugreport_score() const { return at<30>().as_int32(); }
-  bool has_trigger_config() const { return at<17>().valid(); }
-  ::protozero::ConstBytes trigger_config() const { return at<17>().as_bytes(); }
-  bool has_activate_triggers() const { return at<18>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> activate_triggers() const { return GetRepeated<::protozero::ConstChars>(18); }
-  bool has_incremental_state_config() const { return at<21>().valid(); }
-  ::protozero::ConstBytes incremental_state_config() const { return at<21>().as_bytes(); }
-  bool has_allow_user_build_tracing() const { return at<19>().valid(); }
-  bool allow_user_build_tracing() const { return at<19>().as_bool(); }
-  bool has_unique_session_name() const { return at<22>().valid(); }
-  ::protozero::ConstChars unique_session_name() const { return at<22>().as_string(); }
-  bool has_compression_type() const { return at<24>().valid(); }
-  int32_t compression_type() const { return at<24>().as_int32(); }
-  bool has_incident_report_config() const { return at<25>().valid(); }
-  ::protozero::ConstBytes incident_report_config() const { return at<25>().as_bytes(); }
-  bool has_statsd_logging() const { return at<31>().valid(); }
-  int32_t statsd_logging() const { return at<31>().as_int32(); }
-  bool has_trace_uuid_msb() const { return at<27>().valid(); }
-  int64_t trace_uuid_msb() const { return at<27>().as_int64(); }
-  bool has_trace_uuid_lsb() const { return at<28>().valid(); }
-  int64_t trace_uuid_lsb() const { return at<28>().as_int64(); }
-  bool has_trace_filter() const { return at<33>().valid(); }
-  ::protozero::ConstBytes trace_filter() const { return at<33>().as_bytes(); }
-  bool has_android_report_config() const { return at<34>().valid(); }
-  ::protozero::ConstBytes android_report_config() const { return at<34>().as_bytes(); }
-  bool has_cmd_trace_start_delay() const { return at<35>().valid(); }
-  ::protozero::ConstBytes cmd_trace_start_delay() const { return at<35>().as_bytes(); }
+  InodeFileConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit InodeFileConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit InodeFileConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_scan_interval_ms() const { return at<1>().valid(); }
+  uint32_t scan_interval_ms() const { return at<1>().as_uint32(); }
+  bool has_scan_delay_ms() const { return at<2>().valid(); }
+  uint32_t scan_delay_ms() const { return at<2>().as_uint32(); }
+  bool has_scan_batch_size() const { return at<3>().valid(); }
+  uint32_t scan_batch_size() const { return at<3>().as_uint32(); }
+  bool has_do_not_scan() const { return at<4>().valid(); }
+  bool do_not_scan() const { return at<4>().as_bool(); }
+  bool has_scan_mount_points() const { return at<5>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> scan_mount_points() const { return GetRepeated<::protozero::ConstChars>(5); }
+  bool has_mount_point_mapping() const { return at<6>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> mount_point_mapping() const { return GetRepeated<::protozero::ConstBytes>(6); }
 };
 
-class TraceConfig : public ::protozero::Message {
+class InodeFileConfig : public ::protozero::Message {
  public:
-  using Decoder = TraceConfig_Decoder;
+  using Decoder = InodeFileConfig_Decoder;
   enum : int32_t {
-    kBuffersFieldNumber = 1,
-    kDataSourcesFieldNumber = 2,
-    kBuiltinDataSourcesFieldNumber = 20,
-    kDurationMsFieldNumber = 3,
-    kPreferSuspendClockForDurationFieldNumber = 36,
-    kEnableExtraGuardrailsFieldNumber = 4,
-    kLockdownModeFieldNumber = 5,
-    kProducersFieldNumber = 6,
-    kStatsdMetadataFieldNumber = 7,
-    kWriteIntoFileFieldNumber = 8,
-    kOutputPathFieldNumber = 29,
-    kFileWritePeriodMsFieldNumber = 9,
-    kMaxFileSizeBytesFieldNumber = 10,
-    kGuardrailOverridesFieldNumber = 11,
-    kDeferredStartFieldNumber = 12,
-    kFlushPeriodMsFieldNumber = 13,
-    kFlushTimeoutMsFieldNumber = 14,
-    kDataSourceStopTimeoutMsFieldNumber = 23,
-    kNotifyTraceurFieldNumber = 16,
-    kBugreportScoreFieldNumber = 30,
-    kTriggerConfigFieldNumber = 17,
-    kActivateTriggersFieldNumber = 18,
-    kIncrementalStateConfigFieldNumber = 21,
-    kAllowUserBuildTracingFieldNumber = 19,
-    kUniqueSessionNameFieldNumber = 22,
-    kCompressionTypeFieldNumber = 24,
-    kIncidentReportConfigFieldNumber = 25,
-    kStatsdLoggingFieldNumber = 31,
-    kTraceUuidMsbFieldNumber = 27,
-    kTraceUuidLsbFieldNumber = 28,
-    kTraceFilterFieldNumber = 33,
-    kAndroidReportConfigFieldNumber = 34,
-    kCmdTraceStartDelayFieldNumber = 35,
+    kScanIntervalMsFieldNumber = 1,
+    kScanDelayMsFieldNumber = 2,
+    kScanBatchSizeFieldNumber = 3,
+    kDoNotScanFieldNumber = 4,
+    kScanMountPointsFieldNumber = 5,
+    kMountPointMappingFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig"; }
-
-  using BufferConfig = ::perfetto::protos::pbzero::TraceConfig_BufferConfig;
-  using DataSource = ::perfetto::protos::pbzero::TraceConfig_DataSource;
-  using BuiltinDataSource = ::perfetto::protos::pbzero::TraceConfig_BuiltinDataSource;
-  using ProducerConfig = ::perfetto::protos::pbzero::TraceConfig_ProducerConfig;
-  using StatsdMetadata = ::perfetto::protos::pbzero::TraceConfig_StatsdMetadata;
-  using GuardrailOverrides = ::perfetto::protos::pbzero::TraceConfig_GuardrailOverrides;
-  using TriggerConfig = ::perfetto::protos::pbzero::TraceConfig_TriggerConfig;
-  using IncrementalStateConfig = ::perfetto::protos::pbzero::TraceConfig_IncrementalStateConfig;
-  using IncidentReportConfig = ::perfetto::protos::pbzero::TraceConfig_IncidentReportConfig;
-  using TraceFilter = ::perfetto::protos::pbzero::TraceConfig_TraceFilter;
-  using AndroidReportConfig = ::perfetto::protos::pbzero::TraceConfig_AndroidReportConfig;
-  using CmdTraceStartDelay = ::perfetto::protos::pbzero::TraceConfig_CmdTraceStartDelay;
-
-  using LockdownModeOperation = ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation;
-  static inline const char* LockdownModeOperation_Name(LockdownModeOperation value) {
-    return ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation_Name(value);
-  }
-
-  using CompressionType = ::perfetto::protos::pbzero::TraceConfig_CompressionType;
-  static inline const char* CompressionType_Name(CompressionType value) {
-    return ::perfetto::protos::pbzero::TraceConfig_CompressionType_Name(value);
-  }
+  static constexpr const char* GetName() { return ".perfetto.protos.InodeFileConfig"; }
 
-  using StatsdLogging = ::perfetto::protos::pbzero::TraceConfig_StatsdLogging;
-  static inline const char* StatsdLogging_Name(StatsdLogging value) {
-    return ::perfetto::protos::pbzero::TraceConfig_StatsdLogging_Name(value);
-  }
-  static const LockdownModeOperation LOCKDOWN_UNCHANGED = LockdownModeOperation::LOCKDOWN_UNCHANGED;
-  static const LockdownModeOperation LOCKDOWN_CLEAR = LockdownModeOperation::LOCKDOWN_CLEAR;
-  static const LockdownModeOperation LOCKDOWN_SET = LockdownModeOperation::LOCKDOWN_SET;
-  static const CompressionType COMPRESSION_TYPE_UNSPECIFIED = CompressionType::COMPRESSION_TYPE_UNSPECIFIED;
-  static const CompressionType COMPRESSION_TYPE_DEFLATE = CompressionType::COMPRESSION_TYPE_DEFLATE;
-  static const StatsdLogging STATSD_LOGGING_UNSPECIFIED = StatsdLogging::STATSD_LOGGING_UNSPECIFIED;
-  static const StatsdLogging STATSD_LOGGING_ENABLED = StatsdLogging::STATSD_LOGGING_ENABLED;
-  static const StatsdLogging STATSD_LOGGING_DISABLED = StatsdLogging::STATSD_LOGGING_DISABLED;
+  using MountPointMappingEntry = ::perfetto::protos::pbzero::InodeFileConfig_MountPointMappingEntry;
 
-  using FieldMetadata_Buffers =
+  using FieldMetadata_ScanIntervalMs =
     ::protozero::proto_utils::FieldMetadata<
       1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_BufferConfig,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Buffers kBuffers() { return {}; }
-  template <typename T = TraceConfig_BufferConfig> T* add_buffers() {
-    return BeginNestedMessage<T>(1);
-  }
-
-
-  using FieldMetadata_DataSources =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_DataSource,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DataSources kDataSources() { return {}; }
-  template <typename T = TraceConfig_DataSource> T* add_data_sources() {
-    return BeginNestedMessage<T>(2);
-  }
-
-
-  using FieldMetadata_BuiltinDataSources =
-    ::protozero::proto_utils::FieldMetadata<
-      20,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_BuiltinDataSource,
-      TraceConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      InodeFileConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BuiltinDataSources kBuiltinDataSources() { return {}; }
-  template <typename T = TraceConfig_BuiltinDataSource> T* set_builtin_data_sources() {
-    return BeginNestedMessage<T>(20);
+  static constexpr FieldMetadata_ScanIntervalMs kScanIntervalMs{};
+  void set_scan_interval_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ScanIntervalMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_DurationMs =
+  using FieldMetadata_ScanDelayMs =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      TraceConfig>;
+      InodeFileConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DurationMs kDurationMs() { return {}; }
-  void set_duration_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DurationMs::kFieldId;
+  static constexpr FieldMetadata_ScanDelayMs kScanDelayMs{};
+  void set_scan_delay_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ScanDelayMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -42227,49 +49913,35 @@ class TraceConfig : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PreferSuspendClockForDuration =
+  using FieldMetadata_ScanBatchSize =
     ::protozero::proto_utils::FieldMetadata<
-      36,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TraceConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      InodeFileConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PreferSuspendClockForDuration kPreferSuspendClockForDuration() { return {}; }
-  void set_prefer_suspend_clock_for_duration(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_PreferSuspendClockForDuration::kFieldId;
+  static constexpr FieldMetadata_ScanBatchSize kScanBatchSize{};
+  void set_scan_batch_size(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ScanBatchSize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_EnableExtraGuardrails =
+  using FieldMetadata_DoNotScan =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kBool,
       bool,
-      TraceConfig>;
+      InodeFileConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EnableExtraGuardrails kEnableExtraGuardrails() { return {}; }
-  void set_enable_extra_guardrails(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_EnableExtraGuardrails::kFieldId;
+  static constexpr FieldMetadata_DoNotScan kDoNotScan{};
+  void set_do_not_scan(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DoNotScan::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -42277,497 +49949,389 @@ class TraceConfig : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_LockdownMode =
+  using FieldMetadata_ScanMountPoints =
     ::protozero::proto_utils::FieldMetadata<
       5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation,
-      TraceConfig>;
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      InodeFileConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LockdownMode kLockdownMode() { return {}; }
-  void set_lockdown_mode(::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation value) {
-    static constexpr uint32_t field_id = FieldMetadata_LockdownMode::kFieldId;
+  static constexpr FieldMetadata_ScanMountPoints kScanMountPoints{};
+  void add_scan_mount_points(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ScanMountPoints::kFieldId, data, size);
+  }
+  void add_scan_mount_points(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ScanMountPoints::kFieldId, chars.data, chars.size);
+  }
+  void add_scan_mount_points(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ScanMountPoints::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Producers =
+  using FieldMetadata_MountPointMapping =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_ProducerConfig,
-      TraceConfig>;
+      InodeFileConfig_MountPointMappingEntry,
+      InodeFileConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Producers kProducers() { return {}; }
-  template <typename T = TraceConfig_ProducerConfig> T* add_producers() {
+  static constexpr FieldMetadata_MountPointMapping kMountPointMapping{};
+  template <typename T = InodeFileConfig_MountPointMappingEntry> T* add_mount_point_mapping() {
     return BeginNestedMessage<T>(6);
   }
 
+};
 
-  using FieldMetadata_StatsdMetadata =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_StatsdMetadata,
-      TraceConfig>;
+class InodeFileConfig_MountPointMappingEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  InodeFileConfig_MountPointMappingEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit InodeFileConfig_MountPointMappingEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit InodeFileConfig_MountPointMappingEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_mountpoint() const { return at<1>().valid(); }
+  ::protozero::ConstChars mountpoint() const { return at<1>().as_string(); }
+  bool has_scan_roots() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> scan_roots() const { return GetRepeated<::protozero::ConstChars>(2); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StatsdMetadata kStatsdMetadata() { return {}; }
-  template <typename T = TraceConfig_StatsdMetadata> T* set_statsd_metadata() {
-    return BeginNestedMessage<T>(7);
-  }
+class InodeFileConfig_MountPointMappingEntry : public ::protozero::Message {
+ public:
+  using Decoder = InodeFileConfig_MountPointMappingEntry_Decoder;
+  enum : int32_t {
+    kMountpointFieldNumber = 1,
+    kScanRootsFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.InodeFileConfig.MountPointMappingEntry"; }
 
 
-  using FieldMetadata_WriteIntoFile =
+  using FieldMetadata_Mountpoint =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TraceConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      InodeFileConfig_MountPointMappingEntry>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WriteIntoFile kWriteIntoFile() { return {}; }
-  void set_write_into_file(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_WriteIntoFile::kFieldId;
+  static constexpr FieldMetadata_Mountpoint kMountpoint{};
+  void set_mountpoint(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Mountpoint::kFieldId, data, size);
+  }
+  void set_mountpoint(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Mountpoint::kFieldId, chars.data, chars.size);
+  }
+  void set_mountpoint(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mountpoint::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_OutputPath =
+  using FieldMetadata_ScanRoots =
     ::protozero::proto_utils::FieldMetadata<
-      29,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      TraceConfig>;
+      InodeFileConfig_MountPointMappingEntry>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OutputPath kOutputPath() { return {}; }
-  void set_output_path(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_OutputPath::kFieldId, data, size);
+  static constexpr FieldMetadata_ScanRoots kScanRoots{};
+  void add_scan_roots(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ScanRoots::kFieldId, data, size);
   }
-  void set_output_path(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_OutputPath::kFieldId, chars.data, chars.size);
+  void add_scan_roots(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ScanRoots::kFieldId, chars.data, chars.size);
   }
-  void set_output_path(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_OutputPath::kFieldId;
+  void add_scan_roots(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ScanRoots::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_FileWritePeriodMs =
-    ::protozero::proto_utils::FieldMetadata<
-      9,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig>;
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/interceptors/console_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FileWritePeriodMs kFileWritePeriodMs() { return {}; }
-  void set_file_write_period_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FileWritePeriodMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTORS_CONSOLE_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTORS_CONSOLE_CONFIG_PROTO_H_
 
-  using FieldMetadata_MaxFileSizeBytes =
-    ::protozero::proto_utils::FieldMetadata<
-      10,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TraceConfig>;
+#include <stddef.h>
+#include <stdint.h>
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaxFileSizeBytes kMaxFileSizeBytes() { return {}; }
-  void set_max_file_size_bytes(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MaxFileSizeBytes::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  using FieldMetadata_GuardrailOverrides =
-    ::protozero::proto_utils::FieldMetadata<
-      11,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_GuardrailOverrides,
-      TraceConfig>;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+namespace perfetto_pbzero_enum_ConsoleConfig {
+enum Output : int32_t;
+}  // namespace perfetto_pbzero_enum_ConsoleConfig
+using ConsoleConfig_Output = perfetto_pbzero_enum_ConsoleConfig::Output;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GuardrailOverrides kGuardrailOverrides() { return {}; }
-  template <typename T = TraceConfig_GuardrailOverrides> T* set_guardrail_overrides() {
-    return BeginNestedMessage<T>(11);
-  }
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_ConsoleConfig {
+enum Output : int32_t {
+  OUTPUT_UNSPECIFIED = 0,
+  OUTPUT_STDOUT = 1,
+  OUTPUT_STDERR = 2,
+};
+} // namespace perfetto_pbzero_enum_ConsoleConfig
+using ConsoleConfig_Output = perfetto_pbzero_enum_ConsoleConfig::Output;
 
 
-  using FieldMetadata_DeferredStart =
-    ::protozero::proto_utils::FieldMetadata<
-      12,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TraceConfig>;
+constexpr ConsoleConfig_Output ConsoleConfig_Output_MIN = ConsoleConfig_Output::OUTPUT_UNSPECIFIED;
+constexpr ConsoleConfig_Output ConsoleConfig_Output_MAX = ConsoleConfig_Output::OUTPUT_STDERR;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DeferredStart kDeferredStart() { return {}; }
-  void set_deferred_start(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DeferredStart::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
 
-  using FieldMetadata_FlushPeriodMs =
-    ::protozero::proto_utils::FieldMetadata<
-      13,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig>;
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ConsoleConfig_Output_Name(::perfetto::protos::pbzero::ConsoleConfig_Output value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ConsoleConfig_Output::OUTPUT_UNSPECIFIED:
+    return "OUTPUT_UNSPECIFIED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FlushPeriodMs kFlushPeriodMs() { return {}; }
-  void set_flush_period_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FlushPeriodMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
+  case ::perfetto::protos::pbzero::ConsoleConfig_Output::OUTPUT_STDOUT:
+    return "OUTPUT_STDOUT";
+
+  case ::perfetto::protos::pbzero::ConsoleConfig_Output::OUTPUT_STDERR:
+    return "OUTPUT_STDERR";
   }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
-  using FieldMetadata_FlushTimeoutMs =
-    ::protozero::proto_utils::FieldMetadata<
-      14,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig>;
+class ConsoleConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  ConsoleConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ConsoleConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ConsoleConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_output() const { return at<1>().valid(); }
+  int32_t output() const { return at<1>().as_int32(); }
+  bool has_enable_colors() const { return at<2>().valid(); }
+  bool enable_colors() const { return at<2>().as_bool(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FlushTimeoutMs kFlushTimeoutMs() { return {}; }
-  void set_flush_timeout_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FlushTimeoutMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
+class ConsoleConfig : public ::protozero::Message {
+ public:
+  using Decoder = ConsoleConfig_Decoder;
+  enum : int32_t {
+    kOutputFieldNumber = 1,
+    kEnableColorsFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ConsoleConfig"; }
+
+
+  using Output = ::perfetto::protos::pbzero::ConsoleConfig_Output;
+  static inline const char* Output_Name(Output value) {
+    return ::perfetto::protos::pbzero::ConsoleConfig_Output_Name(value);
   }
+  static inline const Output OUTPUT_UNSPECIFIED = Output::OUTPUT_UNSPECIFIED;
+  static inline const Output OUTPUT_STDOUT = Output::OUTPUT_STDOUT;
+  static inline const Output OUTPUT_STDERR = Output::OUTPUT_STDERR;
 
-  using FieldMetadata_DataSourceStopTimeoutMs =
+  using FieldMetadata_Output =
     ::protozero::proto_utils::FieldMetadata<
-      23,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ConsoleConfig_Output,
+      ConsoleConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DataSourceStopTimeoutMs kDataSourceStopTimeoutMs() { return {}; }
-  void set_data_source_stop_timeout_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DataSourceStopTimeoutMs::kFieldId;
+  static constexpr FieldMetadata_Output kOutput{};
+  void set_output(ConsoleConfig_Output value) {
+    static constexpr uint32_t field_id = FieldMetadata_Output::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NotifyTraceur =
+  using FieldMetadata_EnableColors =
     ::protozero::proto_utils::FieldMetadata<
-      16,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kBool,
       bool,
-      TraceConfig>;
+      ConsoleConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NotifyTraceur kNotifyTraceur() { return {}; }
-  void set_notify_traceur(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_NotifyTraceur::kFieldId;
+  static constexpr FieldMetadata_EnableColors kEnableColors{};
+  void set_enable_colors(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_EnableColors::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_BugreportScore =
-    ::protozero::proto_utils::FieldMetadata<
-      30,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TraceConfig>;
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/power/android_power_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BugreportScore kBugreportScore() { return {}; }
-  void set_bugreport_score(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BugreportScore::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_POWER_ANDROID_POWER_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_POWER_ANDROID_POWER_CONFIG_PROTO_H_
 
-  using FieldMetadata_TriggerConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      17,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_TriggerConfig,
-      TraceConfig>;
+#include <stddef.h>
+#include <stdint.h>
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TriggerConfig kTriggerConfig() { return {}; }
-  template <typename T = TraceConfig_TriggerConfig> T* set_trigger_config() {
-    return BeginNestedMessage<T>(17);
-  }
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+namespace perfetto_pbzero_enum_AndroidPowerConfig {
+enum BatteryCounters : int32_t;
+}  // namespace perfetto_pbzero_enum_AndroidPowerConfig
+using AndroidPowerConfig_BatteryCounters = perfetto_pbzero_enum_AndroidPowerConfig::BatteryCounters;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-  using FieldMetadata_ActivateTriggers =
-    ::protozero::proto_utils::FieldMetadata<
-      18,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TraceConfig>;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ActivateTriggers kActivateTriggers() { return {}; }
-  void add_activate_triggers(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ActivateTriggers::kFieldId, data, size);
-  }
-  void add_activate_triggers(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ActivateTriggers::kFieldId, chars.data, chars.size);
-  }
-  void add_activate_triggers(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ActivateTriggers::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+namespace perfetto_pbzero_enum_AndroidPowerConfig {
+enum BatteryCounters : int32_t {
+  BATTERY_COUNTER_UNSPECIFIED = 0,
+  BATTERY_COUNTER_CHARGE = 1,
+  BATTERY_COUNTER_CAPACITY_PERCENT = 2,
+  BATTERY_COUNTER_CURRENT = 3,
+  BATTERY_COUNTER_CURRENT_AVG = 4,
+  BATTERY_COUNTER_VOLTAGE = 5,
+};
+} // namespace perfetto_pbzero_enum_AndroidPowerConfig
+using AndroidPowerConfig_BatteryCounters = perfetto_pbzero_enum_AndroidPowerConfig::BatteryCounters;
 
-  using FieldMetadata_IncrementalStateConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      21,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_IncrementalStateConfig,
-      TraceConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IncrementalStateConfig kIncrementalStateConfig() { return {}; }
-  template <typename T = TraceConfig_IncrementalStateConfig> T* set_incremental_state_config() {
-    return BeginNestedMessage<T>(21);
+constexpr AndroidPowerConfig_BatteryCounters AndroidPowerConfig_BatteryCounters_MIN = AndroidPowerConfig_BatteryCounters::BATTERY_COUNTER_UNSPECIFIED;
+constexpr AndroidPowerConfig_BatteryCounters AndroidPowerConfig_BatteryCounters_MAX = AndroidPowerConfig_BatteryCounters::BATTERY_COUNTER_VOLTAGE;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* AndroidPowerConfig_BatteryCounters_Name(::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters::BATTERY_COUNTER_UNSPECIFIED:
+    return "BATTERY_COUNTER_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters::BATTERY_COUNTER_CHARGE:
+    return "BATTERY_COUNTER_CHARGE";
+
+  case ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters::BATTERY_COUNTER_CAPACITY_PERCENT:
+    return "BATTERY_COUNTER_CAPACITY_PERCENT";
+
+  case ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters::BATTERY_COUNTER_CURRENT:
+    return "BATTERY_COUNTER_CURRENT";
+
+  case ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters::BATTERY_COUNTER_CURRENT_AVG:
+    return "BATTERY_COUNTER_CURRENT_AVG";
+
+  case ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters::BATTERY_COUNTER_VOLTAGE:
+    return "BATTERY_COUNTER_VOLTAGE";
   }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
+class AndroidPowerConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  AndroidPowerConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidPowerConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidPowerConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_battery_poll_ms() const { return at<1>().valid(); }
+  uint32_t battery_poll_ms() const { return at<1>().as_uint32(); }
+  bool has_battery_counters() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> battery_counters() const { return GetRepeated<int32_t>(2); }
+  bool has_collect_power_rails() const { return at<3>().valid(); }
+  bool collect_power_rails() const { return at<3>().as_bool(); }
+  bool has_collect_energy_estimation_breakdown() const { return at<4>().valid(); }
+  bool collect_energy_estimation_breakdown() const { return at<4>().as_bool(); }
+  bool has_collect_entity_state_residency() const { return at<5>().valid(); }
+  bool collect_entity_state_residency() const { return at<5>().as_bool(); }
+};
 
-  using FieldMetadata_AllowUserBuildTracing =
-    ::protozero::proto_utils::FieldMetadata<
-      19,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TraceConfig>;
+class AndroidPowerConfig : public ::protozero::Message {
+ public:
+  using Decoder = AndroidPowerConfig_Decoder;
+  enum : int32_t {
+    kBatteryPollMsFieldNumber = 1,
+    kBatteryCountersFieldNumber = 2,
+    kCollectPowerRailsFieldNumber = 3,
+    kCollectEnergyEstimationBreakdownFieldNumber = 4,
+    kCollectEntityStateResidencyFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidPowerConfig"; }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AllowUserBuildTracing kAllowUserBuildTracing() { return {}; }
-  void set_allow_user_build_tracing(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_AllowUserBuildTracing::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
+
+  using BatteryCounters = ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters;
+  static inline const char* BatteryCounters_Name(BatteryCounters value) {
+    return ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters_Name(value);
   }
+  static inline const BatteryCounters BATTERY_COUNTER_UNSPECIFIED = BatteryCounters::BATTERY_COUNTER_UNSPECIFIED;
+  static inline const BatteryCounters BATTERY_COUNTER_CHARGE = BatteryCounters::BATTERY_COUNTER_CHARGE;
+  static inline const BatteryCounters BATTERY_COUNTER_CAPACITY_PERCENT = BatteryCounters::BATTERY_COUNTER_CAPACITY_PERCENT;
+  static inline const BatteryCounters BATTERY_COUNTER_CURRENT = BatteryCounters::BATTERY_COUNTER_CURRENT;
+  static inline const BatteryCounters BATTERY_COUNTER_CURRENT_AVG = BatteryCounters::BATTERY_COUNTER_CURRENT_AVG;
+  static inline const BatteryCounters BATTERY_COUNTER_VOLTAGE = BatteryCounters::BATTERY_COUNTER_VOLTAGE;
 
-  using FieldMetadata_UniqueSessionName =
+  using FieldMetadata_BatteryPollMs =
     ::protozero::proto_utils::FieldMetadata<
-      22,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TraceConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      AndroidPowerConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UniqueSessionName kUniqueSessionName() { return {}; }
-  void set_unique_session_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_UniqueSessionName::kFieldId, data, size);
-  }
-  void set_unique_session_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_UniqueSessionName::kFieldId, chars.data, chars.size);
-  }
-  void set_unique_session_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_UniqueSessionName::kFieldId;
+  static constexpr FieldMetadata_BatteryPollMs kBatteryPollMs{};
+  void set_battery_poll_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BatteryPollMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CompressionType =
+  using FieldMetadata_BatteryCounters =
     ::protozero::proto_utils::FieldMetadata<
-      24,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::TraceConfig_CompressionType,
-      TraceConfig>;
+      AndroidPowerConfig_BatteryCounters,
+      AndroidPowerConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CompressionType kCompressionType() { return {}; }
-  void set_compression_type(::perfetto::protos::pbzero::TraceConfig_CompressionType value) {
-    static constexpr uint32_t field_id = FieldMetadata_CompressionType::kFieldId;
+  static constexpr FieldMetadata_BatteryCounters kBatteryCounters{};
+  void add_battery_counters(AndroidPowerConfig_BatteryCounters value) {
+    static constexpr uint32_t field_id = FieldMetadata_BatteryCounters::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -42775,230 +50339,182 @@ class TraceConfig : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IncidentReportConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      25,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_IncidentReportConfig,
-      TraceConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IncidentReportConfig kIncidentReportConfig() { return {}; }
-  template <typename T = TraceConfig_IncidentReportConfig> T* set_incident_report_config() {
-    return BeginNestedMessage<T>(25);
-  }
-
-
-  using FieldMetadata_StatsdLogging =
+  using FieldMetadata_CollectPowerRails =
     ::protozero::proto_utils::FieldMetadata<
-      31,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::TraceConfig_StatsdLogging,
-      TraceConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      AndroidPowerConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StatsdLogging kStatsdLogging() { return {}; }
-  void set_statsd_logging(::perfetto::protos::pbzero::TraceConfig_StatsdLogging value) {
-    static constexpr uint32_t field_id = FieldMetadata_StatsdLogging::kFieldId;
+  static constexpr FieldMetadata_CollectPowerRails kCollectPowerRails{};
+  void set_collect_power_rails(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_CollectPowerRails::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TraceUuidMsb =
+  using FieldMetadata_CollectEnergyEstimationBreakdown =
     ::protozero::proto_utils::FieldMetadata<
-      27,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TraceConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      AndroidPowerConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceUuidMsb kTraceUuidMsb() { return {}; }
-  void set_trace_uuid_msb(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TraceUuidMsb::kFieldId;
+  static constexpr FieldMetadata_CollectEnergyEstimationBreakdown kCollectEnergyEstimationBreakdown{};
+  void set_collect_energy_estimation_breakdown(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_CollectEnergyEstimationBreakdown::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TraceUuidLsb =
+  using FieldMetadata_CollectEntityStateResidency =
     ::protozero::proto_utils::FieldMetadata<
-      28,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TraceConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      AndroidPowerConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceUuidLsb kTraceUuidLsb() { return {}; }
-  void set_trace_uuid_lsb(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TraceUuidLsb::kFieldId;
+  static constexpr FieldMetadata_CollectEntityStateResidency kCollectEntityStateResidency{};
+  void set_collect_entity_state_residency(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_CollectEntityStateResidency::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TraceFilter =
-    ::protozero::proto_utils::FieldMetadata<
-      33,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_TraceFilter,
-      TraceConfig>;
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/priority_boost/priority_boost_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceFilter kTraceFilter() { return {}; }
-  template <typename T = TraceConfig_TraceFilter> T* set_trace_filter() {
-    return BeginNestedMessage<T>(33);
-  }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PRIORITY_BOOST_PRIORITY_BOOST_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PRIORITY_BOOST_PRIORITY_BOOST_CONFIG_PROTO_H_
 
+#include <stddef.h>
+#include <stdint.h>
 
-  using FieldMetadata_AndroidReportConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      34,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_AndroidReportConfig,
-      TraceConfig>;
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidReportConfig kAndroidReportConfig() { return {}; }
-  template <typename T = TraceConfig_AndroidReportConfig> T* set_android_report_config() {
-    return BeginNestedMessage<T>(34);
-  }
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+namespace perfetto_pbzero_enum_PriorityBoostConfig {
+enum BoostPolicy : int32_t;
+}  // namespace perfetto_pbzero_enum_PriorityBoostConfig
+using PriorityBoostConfig_BoostPolicy = perfetto_pbzero_enum_PriorityBoostConfig::BoostPolicy;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-  using FieldMetadata_CmdTraceStartDelay =
-    ::protozero::proto_utils::FieldMetadata<
-      35,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_CmdTraceStartDelay,
-      TraceConfig>;
+namespace perfetto_pbzero_enum_PriorityBoostConfig {
+enum BoostPolicy : int32_t {
+  POLICY_UNSPECIFIED = 0,
+  POLICY_SCHED_OTHER = 1,
+  POLICY_SCHED_FIFO = 2,
+};
+} // namespace perfetto_pbzero_enum_PriorityBoostConfig
+using PriorityBoostConfig_BoostPolicy = perfetto_pbzero_enum_PriorityBoostConfig::BoostPolicy;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CmdTraceStartDelay kCmdTraceStartDelay() { return {}; }
-  template <typename T = TraceConfig_CmdTraceStartDelay> T* set_cmd_trace_start_delay() {
-    return BeginNestedMessage<T>(35);
-  }
 
-};
+constexpr PriorityBoostConfig_BoostPolicy PriorityBoostConfig_BoostPolicy_MIN = PriorityBoostConfig_BoostPolicy::POLICY_UNSPECIFIED;
+constexpr PriorityBoostConfig_BoostPolicy PriorityBoostConfig_BoostPolicy_MAX = PriorityBoostConfig_BoostPolicy::POLICY_SCHED_FIFO;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* PriorityBoostConfig_BoostPolicy_Name(::perfetto::protos::pbzero::PriorityBoostConfig_BoostPolicy value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::PriorityBoostConfig_BoostPolicy::POLICY_UNSPECIFIED:
+    return "POLICY_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::PriorityBoostConfig_BoostPolicy::POLICY_SCHED_OTHER:
+    return "POLICY_SCHED_OTHER";
+
+  case ::perfetto::protos::pbzero::PriorityBoostConfig_BoostPolicy::POLICY_SCHED_FIFO:
+    return "POLICY_SCHED_FIFO";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
-class TraceConfig_CmdTraceStartDelay_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class PriorityBoostConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  TraceConfig_CmdTraceStartDelay_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_CmdTraceStartDelay_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_CmdTraceStartDelay_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_min_delay_ms() const { return at<1>().valid(); }
-  uint32_t min_delay_ms() const { return at<1>().as_uint32(); }
-  bool has_max_delay_ms() const { return at<2>().valid(); }
-  uint32_t max_delay_ms() const { return at<2>().as_uint32(); }
+  PriorityBoostConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PriorityBoostConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PriorityBoostConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_policy() const { return at<1>().valid(); }
+  int32_t policy() const { return at<1>().as_int32(); }
+  bool has_priority() const { return at<2>().valid(); }
+  uint32_t priority() const { return at<2>().as_uint32(); }
 };
 
-class TraceConfig_CmdTraceStartDelay : public ::protozero::Message {
+class PriorityBoostConfig : public ::protozero::Message {
  public:
-  using Decoder = TraceConfig_CmdTraceStartDelay_Decoder;
+  using Decoder = PriorityBoostConfig_Decoder;
   enum : int32_t {
-    kMinDelayMsFieldNumber = 1,
-    kMaxDelayMsFieldNumber = 2,
+    kPolicyFieldNumber = 1,
+    kPriorityFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.CmdTraceStartDelay"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.PriorityBoostConfig"; }
 
 
-  using FieldMetadata_MinDelayMs =
+  using BoostPolicy = ::perfetto::protos::pbzero::PriorityBoostConfig_BoostPolicy;
+  static inline const char* BoostPolicy_Name(BoostPolicy value) {
+    return ::perfetto::protos::pbzero::PriorityBoostConfig_BoostPolicy_Name(value);
+  }
+  static inline const BoostPolicy POLICY_UNSPECIFIED = BoostPolicy::POLICY_UNSPECIFIED;
+  static inline const BoostPolicy POLICY_SCHED_OTHER = BoostPolicy::POLICY_SCHED_OTHER;
+  static inline const BoostPolicy POLICY_SCHED_FIFO = BoostPolicy::POLICY_SCHED_FIFO;
+
+  using FieldMetadata_Policy =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig_CmdTraceStartDelay>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      PriorityBoostConfig_BoostPolicy,
+      PriorityBoostConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MinDelayMs kMinDelayMs() { return {}; }
-  void set_min_delay_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MinDelayMs::kFieldId;
+  static constexpr FieldMetadata_Policy kPolicy{};
+  void set_policy(PriorityBoostConfig_BoostPolicy value) {
+    static constexpr uint32_t field_id = FieldMetadata_Policy::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MaxDelayMs =
+  using FieldMetadata_Priority =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      TraceConfig_CmdTraceStartDelay>;
+      PriorityBoostConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaxDelayMs kMaxDelayMs() { return {}; }
-  void set_max_delay_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MaxDelayMs::kFieldId;
+  static constexpr FieldMetadata_Priority kPriority{};
+  void set_priority(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Priority::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -43007,113 +50523,169 @@ class TraceConfig_CmdTraceStartDelay : public ::protozero::Message {
   }
 };
 
-class TraceConfig_AndroidReportConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/process_stats/process_stats_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROCESS_STATS_PROCESS_STATS_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROCESS_STATS_PROCESS_STATS_CONFIG_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+namespace perfetto_pbzero_enum_ProcessStatsConfig {
+enum Quirks : int32_t;
+}  // namespace perfetto_pbzero_enum_ProcessStatsConfig
+using ProcessStatsConfig_Quirks = perfetto_pbzero_enum_ProcessStatsConfig::Quirks;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_ProcessStatsConfig {
+enum Quirks : int32_t {
+  QUIRKS_UNSPECIFIED = 0,
+  DISABLE_INITIAL_DUMP = 1,
+  DISABLE_ON_DEMAND = 2,
+};
+} // namespace perfetto_pbzero_enum_ProcessStatsConfig
+using ProcessStatsConfig_Quirks = perfetto_pbzero_enum_ProcessStatsConfig::Quirks;
+
+
+constexpr ProcessStatsConfig_Quirks ProcessStatsConfig_Quirks_MIN = ProcessStatsConfig_Quirks::QUIRKS_UNSPECIFIED;
+constexpr ProcessStatsConfig_Quirks ProcessStatsConfig_Quirks_MAX = ProcessStatsConfig_Quirks::DISABLE_ON_DEMAND;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ProcessStatsConfig_Quirks_Name(::perfetto::protos::pbzero::ProcessStatsConfig_Quirks value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ProcessStatsConfig_Quirks::QUIRKS_UNSPECIFIED:
+    return "QUIRKS_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::ProcessStatsConfig_Quirks::DISABLE_INITIAL_DUMP:
+    return "DISABLE_INITIAL_DUMP";
+
+  case ::perfetto::protos::pbzero::ProcessStatsConfig_Quirks::DISABLE_ON_DEMAND:
+    return "DISABLE_ON_DEMAND";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class ProcessStatsConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/13> {
  public:
-  TraceConfig_AndroidReportConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_AndroidReportConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_AndroidReportConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_reporter_service_package() const { return at<1>().valid(); }
-  ::protozero::ConstChars reporter_service_package() const { return at<1>().as_string(); }
-  bool has_reporter_service_class() const { return at<2>().valid(); }
-  ::protozero::ConstChars reporter_service_class() const { return at<2>().as_string(); }
-  bool has_skip_report() const { return at<3>().valid(); }
-  bool skip_report() const { return at<3>().as_bool(); }
-  bool has_use_pipe_in_framework_for_testing() const { return at<4>().valid(); }
-  bool use_pipe_in_framework_for_testing() const { return at<4>().as_bool(); }
+  ProcessStatsConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProcessStatsConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProcessStatsConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_quirks() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> quirks() const { return GetRepeated<int32_t>(1); }
+  bool has_scan_all_processes_on_start() const { return at<2>().valid(); }
+  bool scan_all_processes_on_start() const { return at<2>().as_bool(); }
+  bool has_record_thread_names() const { return at<3>().valid(); }
+  bool record_thread_names() const { return at<3>().as_bool(); }
+  bool has_proc_stats_poll_ms() const { return at<4>().valid(); }
+  uint32_t proc_stats_poll_ms() const { return at<4>().as_uint32(); }
+  bool has_proc_stats_cache_ttl_ms() const { return at<6>().valid(); }
+  uint32_t proc_stats_cache_ttl_ms() const { return at<6>().as_uint32(); }
+  bool has_scan_smaps_rollup() const { return at<10>().valid(); }
+  bool scan_smaps_rollup() const { return at<10>().as_bool(); }
+  bool has_record_process_age() const { return at<11>().valid(); }
+  bool record_process_age() const { return at<11>().as_bool(); }
+  bool has_record_process_runtime() const { return at<12>().valid(); }
+  bool record_process_runtime() const { return at<12>().as_bool(); }
+  bool has_record_process_dmabuf_rss() const { return at<13>().valid(); }
+  bool record_process_dmabuf_rss() const { return at<13>().as_bool(); }
+  bool has_resolve_process_fds() const { return at<9>().valid(); }
+  bool resolve_process_fds() const { return at<9>().as_bool(); }
 };
 
-class TraceConfig_AndroidReportConfig : public ::protozero::Message {
+class ProcessStatsConfig : public ::protozero::Message {
  public:
-  using Decoder = TraceConfig_AndroidReportConfig_Decoder;
+  using Decoder = ProcessStatsConfig_Decoder;
   enum : int32_t {
-    kReporterServicePackageFieldNumber = 1,
-    kReporterServiceClassFieldNumber = 2,
-    kSkipReportFieldNumber = 3,
-    kUsePipeInFrameworkForTestingFieldNumber = 4,
+    kQuirksFieldNumber = 1,
+    kScanAllProcessesOnStartFieldNumber = 2,
+    kRecordThreadNamesFieldNumber = 3,
+    kProcStatsPollMsFieldNumber = 4,
+    kProcStatsCacheTtlMsFieldNumber = 6,
+    kScanSmapsRollupFieldNumber = 10,
+    kRecordProcessAgeFieldNumber = 11,
+    kRecordProcessRuntimeFieldNumber = 12,
+    kRecordProcessDmabufRssFieldNumber = 13,
+    kResolveProcessFdsFieldNumber = 9,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.AndroidReportConfig"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.ProcessStatsConfig"; }
 
 
-  using FieldMetadata_ReporterServicePackage =
+  using Quirks = ::perfetto::protos::pbzero::ProcessStatsConfig_Quirks;
+  static inline const char* Quirks_Name(Quirks value) {
+    return ::perfetto::protos::pbzero::ProcessStatsConfig_Quirks_Name(value);
+  }
+  static inline const Quirks QUIRKS_UNSPECIFIED = Quirks::QUIRKS_UNSPECIFIED;
+  static inline const Quirks DISABLE_INITIAL_DUMP = Quirks::DISABLE_INITIAL_DUMP;
+  static inline const Quirks DISABLE_ON_DEMAND = Quirks::DISABLE_ON_DEMAND;
+
+  using FieldMetadata_Quirks =
     ::protozero::proto_utils::FieldMetadata<
       1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TraceConfig_AndroidReportConfig>;
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ProcessStatsConfig_Quirks,
+      ProcessStatsConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReporterServicePackage kReporterServicePackage() { return {}; }
-  void set_reporter_service_package(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ReporterServicePackage::kFieldId, data, size);
-  }
-  void set_reporter_service_package(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ReporterServicePackage::kFieldId, chars.data, chars.size);
-  }
-  void set_reporter_service_package(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReporterServicePackage::kFieldId;
+  static constexpr FieldMetadata_Quirks kQuirks{};
+  void add_quirks(ProcessStatsConfig_Quirks value) {
+    static constexpr uint32_t field_id = FieldMetadata_Quirks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ReporterServiceClass =
+  using FieldMetadata_ScanAllProcessesOnStart =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TraceConfig_AndroidReportConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ProcessStatsConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReporterServiceClass kReporterServiceClass() { return {}; }
-  void set_reporter_service_class(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ReporterServiceClass::kFieldId, data, size);
-  }
-  void set_reporter_service_class(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ReporterServiceClass::kFieldId, chars.data, chars.size);
-  }
-  void set_reporter_service_class(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReporterServiceClass::kFieldId;
+  static constexpr FieldMetadata_ScanAllProcessesOnStart kScanAllProcessesOnStart{};
+  void set_scan_all_processes_on_start(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ScanAllProcessesOnStart::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SkipReport =
+  using FieldMetadata_RecordThreadNames =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kBool,
       bool,
-      TraceConfig_AndroidReportConfig>;
+      ProcessStatsConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SkipReport kSkipReport() { return {}; }
-  void set_skip_report(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_SkipReport::kFieldId;
+  static constexpr FieldMetadata_RecordThreadNames kRecordThreadNames{};
+  void set_record_thread_names(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_RecordThreadNames::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -43121,217 +50693,107 @@ class TraceConfig_AndroidReportConfig : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_UsePipeInFrameworkForTesting =
+  using FieldMetadata_ProcStatsPollMs =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ProcessStatsConfig>;
+
+  static constexpr FieldMetadata_ProcStatsPollMs kProcStatsPollMs{};
+  void set_proc_stats_poll_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProcStatsPollMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ProcStatsCacheTtlMs =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ProcessStatsConfig>;
+
+  static constexpr FieldMetadata_ProcStatsCacheTtlMs kProcStatsCacheTtlMs{};
+  void set_proc_stats_cache_ttl_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProcStatsCacheTtlMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ScanSmapsRollup =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kBool,
       bool,
-      TraceConfig_AndroidReportConfig>;
+      ProcessStatsConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UsePipeInFrameworkForTesting kUsePipeInFrameworkForTesting() { return {}; }
-  void set_use_pipe_in_framework_for_testing(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_UsePipeInFrameworkForTesting::kFieldId;
+  static constexpr FieldMetadata_ScanSmapsRollup kScanSmapsRollup{};
+  void set_scan_smaps_rollup(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ScanSmapsRollup::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
-};
 
-class TraceConfig_TraceFilter_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TraceConfig_TraceFilter_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_TraceFilter_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_TraceFilter_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_bytecode() const { return at<1>().valid(); }
-  ::protozero::ConstBytes bytecode() const { return at<1>().as_bytes(); }
-};
-
-class TraceConfig_TraceFilter : public ::protozero::Message {
- public:
-  using Decoder = TraceConfig_TraceFilter_Decoder;
-  enum : int32_t {
-    kBytecodeFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.TraceFilter"; }
-
-
-  using FieldMetadata_Bytecode =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBytes,
-      std::string,
-      TraceConfig_TraceFilter>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Bytecode kBytecode() { return {}; }
-  void set_bytecode(const uint8_t* data, size_t size) {
-    AppendBytes(FieldMetadata_Bytecode::kFieldId, data, size);
-  }
-  void set_bytecode(::protozero::ConstBytes bytes) {
-    AppendBytes(FieldMetadata_Bytecode::kFieldId, bytes.data, bytes.size);
-  }
-  void set_bytecode(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Bytecode::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBytes>
-        ::Append(*this, field_id, value);
-  }
-};
-
-class TraceConfig_IncidentReportConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TraceConfig_IncidentReportConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_IncidentReportConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_IncidentReportConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_destination_package() const { return at<1>().valid(); }
-  ::protozero::ConstChars destination_package() const { return at<1>().as_string(); }
-  bool has_destination_class() const { return at<2>().valid(); }
-  ::protozero::ConstChars destination_class() const { return at<2>().as_string(); }
-  bool has_privacy_level() const { return at<3>().valid(); }
-  int32_t privacy_level() const { return at<3>().as_int32(); }
-  bool has_skip_incidentd() const { return at<5>().valid(); }
-  bool skip_incidentd() const { return at<5>().as_bool(); }
-  bool has_skip_dropbox() const { return at<4>().valid(); }
-  bool skip_dropbox() const { return at<4>().as_bool(); }
-};
-
-class TraceConfig_IncidentReportConfig : public ::protozero::Message {
- public:
-  using Decoder = TraceConfig_IncidentReportConfig_Decoder;
-  enum : int32_t {
-    kDestinationPackageFieldNumber = 1,
-    kDestinationClassFieldNumber = 2,
-    kPrivacyLevelFieldNumber = 3,
-    kSkipIncidentdFieldNumber = 5,
-    kSkipDropboxFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.IncidentReportConfig"; }
-
-
-  using FieldMetadata_DestinationPackage =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TraceConfig_IncidentReportConfig>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DestinationPackage kDestinationPackage() { return {}; }
-  void set_destination_package(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_DestinationPackage::kFieldId, data, size);
-  }
-  void set_destination_package(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_DestinationPackage::kFieldId, chars.data, chars.size);
-  }
-  void set_destination_package(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_DestinationPackage::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_DestinationClass =
+  using FieldMetadata_RecordProcessAge =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TraceConfig_IncidentReportConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ProcessStatsConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DestinationClass kDestinationClass() { return {}; }
-  void set_destination_class(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_DestinationClass::kFieldId, data, size);
-  }
-  void set_destination_class(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_DestinationClass::kFieldId, chars.data, chars.size);
-  }
-  void set_destination_class(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_DestinationClass::kFieldId;
+  static constexpr FieldMetadata_RecordProcessAge kRecordProcessAge{};
+  void set_record_process_age(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_RecordProcessAge::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PrivacyLevel =
+  using FieldMetadata_RecordProcessRuntime =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      12,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TraceConfig_IncidentReportConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ProcessStatsConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PrivacyLevel kPrivacyLevel() { return {}; }
-  void set_privacy_level(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PrivacyLevel::kFieldId;
+  static constexpr FieldMetadata_RecordProcessRuntime kRecordProcessRuntime{};
+  void set_record_process_runtime(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_RecordProcessRuntime::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SkipIncidentd =
+  using FieldMetadata_RecordProcessDmabufRss =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      13,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kBool,
       bool,
-      TraceConfig_IncidentReportConfig>;
+      ProcessStatsConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SkipIncidentd kSkipIncidentd() { return {}; }
-  void set_skip_incidentd(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_SkipIncidentd::kFieldId;
+  static constexpr FieldMetadata_RecordProcessDmabufRss kRecordProcessDmabufRss{};
+  void set_record_process_dmabuf_rss(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_RecordProcessDmabufRss::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -43339,24 +50801,17 @@ class TraceConfig_IncidentReportConfig : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SkipDropbox =
+  using FieldMetadata_ResolveProcessFds =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kBool,
       bool,
-      TraceConfig_IncidentReportConfig>;
+      ProcessStatsConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SkipDropbox kSkipDropbox() { return {}; }
-  void set_skip_dropbox(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_SkipDropbox::kFieldId;
+  static constexpr FieldMetadata_ResolveProcessFds kResolveProcessFds{};
+  void set_resolve_process_fds(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResolveProcessFds::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -43365,209 +50820,241 @@ class TraceConfig_IncidentReportConfig : public ::protozero::Message {
   }
 };
 
-class TraceConfig_IncrementalStateConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/profiling/heapprofd_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_HEAPPROFD_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_HEAPPROFD_CONFIG_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class HeapprofdConfig_ContinuousDumpConfig;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class HeapprofdConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/27> {
  public:
-  TraceConfig_IncrementalStateConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_IncrementalStateConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_IncrementalStateConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_clear_period_ms() const { return at<1>().valid(); }
-  uint32_t clear_period_ms() const { return at<1>().as_uint32(); }
+  HeapprofdConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HeapprofdConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HeapprofdConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_sampling_interval_bytes() const { return at<1>().valid(); }
+  uint64_t sampling_interval_bytes() const { return at<1>().as_uint64(); }
+  bool has_adaptive_sampling_shmem_threshold() const { return at<24>().valid(); }
+  uint64_t adaptive_sampling_shmem_threshold() const { return at<24>().as_uint64(); }
+  bool has_adaptive_sampling_max_sampling_interval_bytes() const { return at<25>().valid(); }
+  uint64_t adaptive_sampling_max_sampling_interval_bytes() const { return at<25>().as_uint64(); }
+  bool has_process_cmdline() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> process_cmdline() const { return GetRepeated<::protozero::ConstChars>(2); }
+  bool has_pid() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint64_t> pid() const { return GetRepeated<uint64_t>(4); }
+  bool has_target_installed_by() const { return at<26>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> target_installed_by() const { return GetRepeated<::protozero::ConstChars>(26); }
+  bool has_heaps() const { return at<20>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> heaps() const { return GetRepeated<::protozero::ConstChars>(20); }
+  bool has_exclude_heaps() const { return at<27>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> exclude_heaps() const { return GetRepeated<::protozero::ConstChars>(27); }
+  bool has_stream_allocations() const { return at<23>().valid(); }
+  bool stream_allocations() const { return at<23>().as_bool(); }
+  bool has_heap_sampling_intervals() const { return at<22>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint64_t> heap_sampling_intervals() const { return GetRepeated<uint64_t>(22); }
+  bool has_all_heaps() const { return at<21>().valid(); }
+  bool all_heaps() const { return at<21>().as_bool(); }
+  bool has_all() const { return at<5>().valid(); }
+  bool all() const { return at<5>().as_bool(); }
+  bool has_min_anonymous_memory_kb() const { return at<15>().valid(); }
+  uint32_t min_anonymous_memory_kb() const { return at<15>().as_uint32(); }
+  bool has_max_heapprofd_memory_kb() const { return at<16>().valid(); }
+  uint32_t max_heapprofd_memory_kb() const { return at<16>().as_uint32(); }
+  bool has_max_heapprofd_cpu_secs() const { return at<17>().valid(); }
+  uint64_t max_heapprofd_cpu_secs() const { return at<17>().as_uint64(); }
+  bool has_skip_symbol_prefix() const { return at<7>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> skip_symbol_prefix() const { return GetRepeated<::protozero::ConstChars>(7); }
+  bool has_continuous_dump_config() const { return at<6>().valid(); }
+  ::protozero::ConstBytes continuous_dump_config() const { return at<6>().as_bytes(); }
+  bool has_shmem_size_bytes() const { return at<8>().valid(); }
+  uint64_t shmem_size_bytes() const { return at<8>().as_uint64(); }
+  bool has_block_client() const { return at<9>().valid(); }
+  bool block_client() const { return at<9>().as_bool(); }
+  bool has_block_client_timeout_us() const { return at<14>().valid(); }
+  uint32_t block_client_timeout_us() const { return at<14>().as_uint32(); }
+  bool has_no_startup() const { return at<10>().valid(); }
+  bool no_startup() const { return at<10>().as_bool(); }
+  bool has_no_running() const { return at<11>().valid(); }
+  bool no_running() const { return at<11>().as_bool(); }
+  bool has_dump_at_max() const { return at<13>().valid(); }
+  bool dump_at_max() const { return at<13>().as_bool(); }
+  bool has_disable_fork_teardown() const { return at<18>().valid(); }
+  bool disable_fork_teardown() const { return at<18>().as_bool(); }
+  bool has_disable_vfork_detection() const { return at<19>().valid(); }
+  bool disable_vfork_detection() const { return at<19>().as_bool(); }
 };
 
-class TraceConfig_IncrementalStateConfig : public ::protozero::Message {
+class HeapprofdConfig : public ::protozero::Message {
  public:
-  using Decoder = TraceConfig_IncrementalStateConfig_Decoder;
+  using Decoder = HeapprofdConfig_Decoder;
   enum : int32_t {
-    kClearPeriodMsFieldNumber = 1,
+    kSamplingIntervalBytesFieldNumber = 1,
+    kAdaptiveSamplingShmemThresholdFieldNumber = 24,
+    kAdaptiveSamplingMaxSamplingIntervalBytesFieldNumber = 25,
+    kProcessCmdlineFieldNumber = 2,
+    kPidFieldNumber = 4,
+    kTargetInstalledByFieldNumber = 26,
+    kHeapsFieldNumber = 20,
+    kExcludeHeapsFieldNumber = 27,
+    kStreamAllocationsFieldNumber = 23,
+    kHeapSamplingIntervalsFieldNumber = 22,
+    kAllHeapsFieldNumber = 21,
+    kAllFieldNumber = 5,
+    kMinAnonymousMemoryKbFieldNumber = 15,
+    kMaxHeapprofdMemoryKbFieldNumber = 16,
+    kMaxHeapprofdCpuSecsFieldNumber = 17,
+    kSkipSymbolPrefixFieldNumber = 7,
+    kContinuousDumpConfigFieldNumber = 6,
+    kShmemSizeBytesFieldNumber = 8,
+    kBlockClientFieldNumber = 9,
+    kBlockClientTimeoutUsFieldNumber = 14,
+    kNoStartupFieldNumber = 10,
+    kNoRunningFieldNumber = 11,
+    kDumpAtMaxFieldNumber = 13,
+    kDisableForkTeardownFieldNumber = 18,
+    kDisableVforkDetectionFieldNumber = 19,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.IncrementalStateConfig"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.HeapprofdConfig"; }
 
+  using ContinuousDumpConfig = ::perfetto::protos::pbzero::HeapprofdConfig_ContinuousDumpConfig;
 
-  using FieldMetadata_ClearPeriodMs =
+  using FieldMetadata_SamplingIntervalBytes =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig_IncrementalStateConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClearPeriodMs kClearPeriodMs() { return {}; }
-  void set_clear_period_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ClearPeriodMs::kFieldId;
+  static constexpr FieldMetadata_SamplingIntervalBytes kSamplingIntervalBytes{};
+  void set_sampling_interval_bytes(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SamplingIntervalBytes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class TraceConfig_TriggerConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  TraceConfig_TriggerConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_TriggerConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_TriggerConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_trigger_mode() const { return at<1>().valid(); }
-  int32_t trigger_mode() const { return at<1>().as_int32(); }
-  bool has_triggers() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> triggers() const { return GetRepeated<::protozero::ConstBytes>(2); }
-  bool has_trigger_timeout_ms() const { return at<3>().valid(); }
-  uint32_t trigger_timeout_ms() const { return at<3>().as_uint32(); }
-};
 
-class TraceConfig_TriggerConfig : public ::protozero::Message {
- public:
-  using Decoder = TraceConfig_TriggerConfig_Decoder;
-  enum : int32_t {
-    kTriggerModeFieldNumber = 1,
-    kTriggersFieldNumber = 2,
-    kTriggerTimeoutMsFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.TriggerConfig"; }
-
-  using Trigger = ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_Trigger;
+  using FieldMetadata_AdaptiveSamplingShmemThreshold =
+    ::protozero::proto_utils::FieldMetadata<
+      24,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HeapprofdConfig>;
 
-  using TriggerMode = ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode;
-  static inline const char* TriggerMode_Name(TriggerMode value) {
-    return ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode_Name(value);
+  static constexpr FieldMetadata_AdaptiveSamplingShmemThreshold kAdaptiveSamplingShmemThreshold{};
+  void set_adaptive_sampling_shmem_threshold(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AdaptiveSamplingShmemThreshold::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
-  static const TriggerMode UNSPECIFIED = TriggerMode::UNSPECIFIED;
-  static const TriggerMode START_TRACING = TriggerMode::START_TRACING;
-  static const TriggerMode STOP_TRACING = TriggerMode::STOP_TRACING;
 
-  using FieldMetadata_TriggerMode =
+  using FieldMetadata_AdaptiveSamplingMaxSamplingIntervalBytes =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      25,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode,
-      TraceConfig_TriggerConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TriggerMode kTriggerMode() { return {}; }
-  void set_trigger_mode(::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode value) {
-    static constexpr uint32_t field_id = FieldMetadata_TriggerMode::kFieldId;
+  static constexpr FieldMetadata_AdaptiveSamplingMaxSamplingIntervalBytes kAdaptiveSamplingMaxSamplingIntervalBytes{};
+  void set_adaptive_sampling_max_sampling_interval_bytes(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AdaptiveSamplingMaxSamplingIntervalBytes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Triggers =
+  using FieldMetadata_ProcessCmdline =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig_TriggerConfig_Trigger,
-      TraceConfig_TriggerConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Triggers kTriggers() { return {}; }
-  template <typename T = TraceConfig_TriggerConfig_Trigger> T* add_triggers() {
-    return BeginNestedMessage<T>(2);
+  static constexpr FieldMetadata_ProcessCmdline kProcessCmdline{};
+  void add_process_cmdline(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ProcessCmdline::kFieldId, data, size);
+  }
+  void add_process_cmdline(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ProcessCmdline::kFieldId, chars.data, chars.size);
+  }
+  void add_process_cmdline(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProcessCmdline::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_TriggerTimeoutMs =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig_TriggerConfig>;
+      4,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TriggerTimeoutMs kTriggerTimeoutMs() { return {}; }
-  void set_trigger_timeout_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TriggerTimeoutMs::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void add_pid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class TraceConfig_TriggerConfig_Trigger_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TraceConfig_TriggerConfig_Trigger_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_TriggerConfig_Trigger_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_TriggerConfig_Trigger_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_producer_name_regex() const { return at<2>().valid(); }
-  ::protozero::ConstChars producer_name_regex() const { return at<2>().as_string(); }
-  bool has_stop_delay_ms() const { return at<3>().valid(); }
-  uint32_t stop_delay_ms() const { return at<3>().as_uint32(); }
-  bool has_max_per_24_h() const { return at<4>().valid(); }
-  uint32_t max_per_24_h() const { return at<4>().as_uint32(); }
-  bool has_skip_probability() const { return at<5>().valid(); }
-  double skip_probability() const { return at<5>().as_double(); }
-};
-
-class TraceConfig_TriggerConfig_Trigger : public ::protozero::Message {
- public:
-  using Decoder = TraceConfig_TriggerConfig_Trigger_Decoder;
-  enum : int32_t {
-    kNameFieldNumber = 1,
-    kProducerNameRegexFieldNumber = 2,
-    kStopDelayMsFieldNumber = 3,
-    kMaxPer24HFieldNumber = 4,
-    kSkipProbabilityFieldNumber = 5,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.TriggerConfig.Trigger"; }
-
 
-  using FieldMetadata_Name =
+  using FieldMetadata_TargetInstalledBy =
     ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      26,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      TraceConfig_TriggerConfig_Trigger>;
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  static constexpr FieldMetadata_TargetInstalledBy kTargetInstalledBy{};
+  void add_target_installed_by(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_TargetInstalledBy::kFieldId, data, size);
   }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  void add_target_installed_by(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_TargetInstalledBy::kFieldId, chars.data, chars.size);
   }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  void add_target_installed_by(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_TargetInstalledBy::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -43575,30 +51062,23 @@ class TraceConfig_TriggerConfig_Trigger : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ProducerNameRegex =
+  using FieldMetadata_Heaps =
     ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      20,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      TraceConfig_TriggerConfig_Trigger>;
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProducerNameRegex kProducerNameRegex() { return {}; }
-  void set_producer_name_regex(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ProducerNameRegex::kFieldId, data, size);
+  static constexpr FieldMetadata_Heaps kHeaps{};
+  void add_heaps(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Heaps::kFieldId, data, size);
   }
-  void set_producer_name_regex(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ProducerNameRegex::kFieldId, chars.data, chars.size);
+  void add_heaps(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Heaps::kFieldId, chars.data, chars.size);
   }
-  void set_producer_name_regex(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProducerNameRegex::kFieldId;
+  void add_heaps(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Heaps::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -43606,121 +51086,59 @@ class TraceConfig_TriggerConfig_Trigger : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_StopDelayMs =
+  using FieldMetadata_ExcludeHeaps =
     ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig_TriggerConfig_Trigger>;
+      27,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StopDelayMs kStopDelayMs() { return {}; }
-  void set_stop_delay_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StopDelayMs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_ExcludeHeaps kExcludeHeaps{};
+  void add_exclude_heaps(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ExcludeHeaps::kFieldId, data, size);
   }
-
-  using FieldMetadata_MaxPer24H =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig_TriggerConfig_Trigger>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaxPer24H kMaxPer24H() { return {}; }
-  void set_max_per_24_h(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MaxPer24H::kFieldId;
+  void add_exclude_heaps(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ExcludeHeaps::kFieldId, chars.data, chars.size);
+  }
+  void add_exclude_heaps(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ExcludeHeaps::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SkipProbability =
+  using FieldMetadata_StreamAllocations =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      23,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kDouble,
-      double,
-      TraceConfig_TriggerConfig_Trigger>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SkipProbability kSkipProbability() { return {}; }
-  void set_skip_probability(double value) {
-    static constexpr uint32_t field_id = FieldMetadata_SkipProbability::kFieldId;
+  static constexpr FieldMetadata_StreamAllocations kStreamAllocations{};
+  void set_stream_allocations(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_StreamAllocations::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
-};
-
-class TraceConfig_GuardrailOverrides_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TraceConfig_GuardrailOverrides_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_GuardrailOverrides_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_GuardrailOverrides_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_max_upload_per_day_bytes() const { return at<1>().valid(); }
-  uint64_t max_upload_per_day_bytes() const { return at<1>().as_uint64(); }
-  bool has_max_tracing_buffer_size_kb() const { return at<2>().valid(); }
-  uint32_t max_tracing_buffer_size_kb() const { return at<2>().as_uint32(); }
-};
-
-class TraceConfig_GuardrailOverrides : public ::protozero::Message {
- public:
-  using Decoder = TraceConfig_GuardrailOverrides_Decoder;
-  enum : int32_t {
-    kMaxUploadPerDayBytesFieldNumber = 1,
-    kMaxTracingBufferSizeKbFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.GuardrailOverrides"; }
-
 
-  using FieldMetadata_MaxUploadPerDayBytes =
+  using FieldMetadata_HeapSamplingIntervals =
     ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      22,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TraceConfig_GuardrailOverrides>;
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaxUploadPerDayBytes kMaxUploadPerDayBytes() { return {}; }
-  void set_max_upload_per_day_bytes(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MaxUploadPerDayBytes::kFieldId;
+  static constexpr FieldMetadata_HeapSamplingIntervals kHeapSamplingIntervals{};
+  void add_heap_sampling_intervals(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_HeapSamplingIntervals::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -43728,208 +51146,113 @@ class TraceConfig_GuardrailOverrides : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MaxTracingBufferSizeKb =
+  using FieldMetadata_AllHeaps =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      21,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig_GuardrailOverrides>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaxTracingBufferSizeKb kMaxTracingBufferSizeKb() { return {}; }
-  void set_max_tracing_buffer_size_kb(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MaxTracingBufferSizeKb::kFieldId;
+  static constexpr FieldMetadata_AllHeaps kAllHeaps{};
+  void set_all_heaps(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_AllHeaps::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
-};
-
-class TraceConfig_StatsdMetadata_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TraceConfig_StatsdMetadata_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_StatsdMetadata_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_StatsdMetadata_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_triggering_alert_id() const { return at<1>().valid(); }
-  int64_t triggering_alert_id() const { return at<1>().as_int64(); }
-  bool has_triggering_config_uid() const { return at<2>().valid(); }
-  int32_t triggering_config_uid() const { return at<2>().as_int32(); }
-  bool has_triggering_config_id() const { return at<3>().valid(); }
-  int64_t triggering_config_id() const { return at<3>().as_int64(); }
-  bool has_triggering_subscription_id() const { return at<4>().valid(); }
-  int64_t triggering_subscription_id() const { return at<4>().as_int64(); }
-};
-
-class TraceConfig_StatsdMetadata : public ::protozero::Message {
- public:
-  using Decoder = TraceConfig_StatsdMetadata_Decoder;
-  enum : int32_t {
-    kTriggeringAlertIdFieldNumber = 1,
-    kTriggeringConfigUidFieldNumber = 2,
-    kTriggeringConfigIdFieldNumber = 3,
-    kTriggeringSubscriptionIdFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.StatsdMetadata"; }
 
-
-  using FieldMetadata_TriggeringAlertId =
+  using FieldMetadata_All =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TraceConfig_StatsdMetadata>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TriggeringAlertId kTriggeringAlertId() { return {}; }
-  void set_triggering_alert_id(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TriggeringAlertId::kFieldId;
+  static constexpr FieldMetadata_All kAll{};
+  void set_all(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_All::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TriggeringConfigUid =
+  using FieldMetadata_MinAnonymousMemoryKb =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      15,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TraceConfig_StatsdMetadata>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TriggeringConfigUid kTriggeringConfigUid() { return {}; }
-  void set_triggering_config_uid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TriggeringConfigUid::kFieldId;
+  static constexpr FieldMetadata_MinAnonymousMemoryKb kMinAnonymousMemoryKb{};
+  void set_min_anonymous_memory_kb(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MinAnonymousMemoryKb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TriggeringConfigId =
+  using FieldMetadata_MaxHeapprofdMemoryKb =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      16,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TraceConfig_StatsdMetadata>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TriggeringConfigId kTriggeringConfigId() { return {}; }
-  void set_triggering_config_id(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TriggeringConfigId::kFieldId;
+  static constexpr FieldMetadata_MaxHeapprofdMemoryKb kMaxHeapprofdMemoryKb{};
+  void set_max_heapprofd_memory_kb(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MaxHeapprofdMemoryKb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TriggeringSubscriptionId =
+  using FieldMetadata_MaxHeapprofdCpuSecs =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      17,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TraceConfig_StatsdMetadata>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TriggeringSubscriptionId kTriggeringSubscriptionId() { return {}; }
-  void set_triggering_subscription_id(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TriggeringSubscriptionId::kFieldId;
+  static constexpr FieldMetadata_MaxHeapprofdCpuSecs kMaxHeapprofdCpuSecs{};
+  void set_max_heapprofd_cpu_secs(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MaxHeapprofdCpuSecs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class TraceConfig_ProducerConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TraceConfig_ProducerConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_ProducerConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_ProducerConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_producer_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars producer_name() const { return at<1>().as_string(); }
-  bool has_shm_size_kb() const { return at<2>().valid(); }
-  uint32_t shm_size_kb() const { return at<2>().as_uint32(); }
-  bool has_page_size_kb() const { return at<3>().valid(); }
-  uint32_t page_size_kb() const { return at<3>().as_uint32(); }
-};
-
-class TraceConfig_ProducerConfig : public ::protozero::Message {
- public:
-  using Decoder = TraceConfig_ProducerConfig_Decoder;
-  enum : int32_t {
-    kProducerNameFieldNumber = 1,
-    kShmSizeKbFieldNumber = 2,
-    kPageSizeKbFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.ProducerConfig"; }
 
-
-  using FieldMetadata_ProducerName =
+  using FieldMetadata_SkipSymbolPrefix =
     ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      7,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      TraceConfig_ProducerConfig>;
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProducerName kProducerName() { return {}; }
-  void set_producer_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ProducerName::kFieldId, data, size);
+  static constexpr FieldMetadata_SkipSymbolPrefix kSkipSymbolPrefix{};
+  void add_skip_symbol_prefix(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_SkipSymbolPrefix::kFieldId, data, size);
   }
-  void set_producer_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ProducerName::kFieldId, chars.data, chars.size);
+  void add_skip_symbol_prefix(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_SkipSymbolPrefix::kFieldId, chars.data, chars.size);
   }
-  void set_producer_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProducerName::kFieldId;
+  void add_skip_symbol_prefix(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_SkipSymbolPrefix::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -43937,111 +51260,49 @@ class TraceConfig_ProducerConfig : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ShmSizeKb =
+  using FieldMetadata_ContinuousDumpConfig =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig_ProducerConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HeapprofdConfig_ContinuousDumpConfig,
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ShmSizeKb kShmSizeKb() { return {}; }
-  void set_shm_size_kb(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ShmSizeKb::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_ContinuousDumpConfig kContinuousDumpConfig{};
+  template <typename T = HeapprofdConfig_ContinuousDumpConfig> T* set_continuous_dump_config() {
+    return BeginNestedMessage<T>(6);
   }
 
-  using FieldMetadata_PageSizeKb =
+
+  using FieldMetadata_ShmemSizeBytes =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig_ProducerConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PageSizeKb kPageSizeKb() { return {}; }
-  void set_page_size_kb(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PageSizeKb::kFieldId;
+  static constexpr FieldMetadata_ShmemSizeBytes kShmemSizeBytes{};
+  void set_shmem_size_bytes(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ShmemSizeBytes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class TraceConfig_BuiltinDataSource_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TraceConfig_BuiltinDataSource_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_BuiltinDataSource_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_BuiltinDataSource_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_disable_clock_snapshotting() const { return at<1>().valid(); }
-  bool disable_clock_snapshotting() const { return at<1>().as_bool(); }
-  bool has_disable_trace_config() const { return at<2>().valid(); }
-  bool disable_trace_config() const { return at<2>().as_bool(); }
-  bool has_disable_system_info() const { return at<3>().valid(); }
-  bool disable_system_info() const { return at<3>().as_bool(); }
-  bool has_disable_service_events() const { return at<4>().valid(); }
-  bool disable_service_events() const { return at<4>().as_bool(); }
-  bool has_primary_trace_clock() const { return at<5>().valid(); }
-  int32_t primary_trace_clock() const { return at<5>().as_int32(); }
-  bool has_snapshot_interval_ms() const { return at<6>().valid(); }
-  uint32_t snapshot_interval_ms() const { return at<6>().as_uint32(); }
-  bool has_prefer_suspend_clock_for_snapshot() const { return at<7>().valid(); }
-  bool prefer_suspend_clock_for_snapshot() const { return at<7>().as_bool(); }
-};
-
-class TraceConfig_BuiltinDataSource : public ::protozero::Message {
- public:
-  using Decoder = TraceConfig_BuiltinDataSource_Decoder;
-  enum : int32_t {
-    kDisableClockSnapshottingFieldNumber = 1,
-    kDisableTraceConfigFieldNumber = 2,
-    kDisableSystemInfoFieldNumber = 3,
-    kDisableServiceEventsFieldNumber = 4,
-    kPrimaryTraceClockFieldNumber = 5,
-    kSnapshotIntervalMsFieldNumber = 6,
-    kPreferSuspendClockForSnapshotFieldNumber = 7,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.BuiltinDataSource"; }
 
-
-  using FieldMetadata_DisableClockSnapshotting =
+  using FieldMetadata_BlockClient =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kBool,
       bool,
-      TraceConfig_BuiltinDataSource>;
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DisableClockSnapshotting kDisableClockSnapshotting() { return {}; }
-  void set_disable_clock_snapshotting(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DisableClockSnapshotting::kFieldId;
+  static constexpr FieldMetadata_BlockClient kBlockClient{};
+  void set_block_client(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_BlockClient::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -44049,49 +51310,35 @@ class TraceConfig_BuiltinDataSource : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DisableTraceConfig =
+  using FieldMetadata_BlockClientTimeoutUs =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      14,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TraceConfig_BuiltinDataSource>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DisableTraceConfig kDisableTraceConfig() { return {}; }
-  void set_disable_trace_config(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DisableTraceConfig::kFieldId;
+  static constexpr FieldMetadata_BlockClientTimeoutUs kBlockClientTimeoutUs{};
+  void set_block_client_timeout_us(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BlockClientTimeoutUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DisableSystemInfo =
+  using FieldMetadata_NoStartup =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kBool,
       bool,
-      TraceConfig_BuiltinDataSource>;
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DisableSystemInfo kDisableSystemInfo() { return {}; }
-  void set_disable_system_info(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DisableSystemInfo::kFieldId;
+  static constexpr FieldMetadata_NoStartup kNoStartup{};
+  void set_no_startup(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_NoStartup::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -44099,24 +51346,17 @@ class TraceConfig_BuiltinDataSource : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DisableServiceEvents =
+  using FieldMetadata_NoRunning =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kBool,
       bool,
-      TraceConfig_BuiltinDataSource>;
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DisableServiceEvents kDisableServiceEvents() { return {}; }
-  void set_disable_service_events(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DisableServiceEvents::kFieldId;
+  static constexpr FieldMetadata_NoRunning kNoRunning{};
+  void set_no_running(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_NoRunning::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -44124,237 +51364,93 @@ class TraceConfig_BuiltinDataSource : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PrimaryTraceClock =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::BuiltinClock,
-      TraceConfig_BuiltinDataSource>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PrimaryTraceClock kPrimaryTraceClock() { return {}; }
-  void set_primary_trace_clock(::perfetto::protos::pbzero::BuiltinClock value) {
-    static constexpr uint32_t field_id = FieldMetadata_PrimaryTraceClock::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_SnapshotIntervalMs =
+  using FieldMetadata_DumpAtMax =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      13,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TraceConfig_BuiltinDataSource>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SnapshotIntervalMs kSnapshotIntervalMs() { return {}; }
-  void set_snapshot_interval_ms(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SnapshotIntervalMs::kFieldId;
+  static constexpr FieldMetadata_DumpAtMax kDumpAtMax{};
+  void set_dump_at_max(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DumpAtMax::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PreferSuspendClockForSnapshot =
+  using FieldMetadata_DisableForkTeardown =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      18,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kBool,
       bool,
-      TraceConfig_BuiltinDataSource>;
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PreferSuspendClockForSnapshot kPreferSuspendClockForSnapshot() { return {}; }
-  void set_prefer_suspend_clock_for_snapshot(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_PreferSuspendClockForSnapshot::kFieldId;
+  static constexpr FieldMetadata_DisableForkTeardown kDisableForkTeardown{};
+  void set_disable_fork_teardown(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DisableForkTeardown::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
-};
-
-class TraceConfig_DataSource_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  TraceConfig_DataSource_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_DataSource_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_DataSource_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_config() const { return at<1>().valid(); }
-  ::protozero::ConstBytes config() const { return at<1>().as_bytes(); }
-  bool has_producer_name_filter() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> producer_name_filter() const { return GetRepeated<::protozero::ConstChars>(2); }
-  bool has_producer_name_regex_filter() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> producer_name_regex_filter() const { return GetRepeated<::protozero::ConstChars>(3); }
-};
-
-class TraceConfig_DataSource : public ::protozero::Message {
- public:
-  using Decoder = TraceConfig_DataSource_Decoder;
-  enum : int32_t {
-    kConfigFieldNumber = 1,
-    kProducerNameFilterFieldNumber = 2,
-    kProducerNameRegexFilterFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.DataSource"; }
-
 
-  using FieldMetadata_Config =
+  using FieldMetadata_DisableVforkDetection =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      19,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      DataSourceConfig,
-      TraceConfig_DataSource>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Config kConfig() { return {}; }
-  template <typename T = DataSourceConfig> T* set_config() {
-    return BeginNestedMessage<T>(1);
-  }
-
-
-  using FieldMetadata_ProducerNameFilter =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TraceConfig_DataSource>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProducerNameFilter kProducerNameFilter() { return {}; }
-  void add_producer_name_filter(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ProducerNameFilter::kFieldId, data, size);
-  }
-  void add_producer_name_filter(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ProducerNameFilter::kFieldId, chars.data, chars.size);
-  }
-  void add_producer_name_filter(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProducerNameFilter::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ProducerNameRegexFilter =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TraceConfig_DataSource>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      HeapprofdConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProducerNameRegexFilter kProducerNameRegexFilter() { return {}; }
-  void add_producer_name_regex_filter(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ProducerNameRegexFilter::kFieldId, data, size);
-  }
-  void add_producer_name_regex_filter(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ProducerNameRegexFilter::kFieldId, chars.data, chars.size);
-  }
-  void add_producer_name_regex_filter(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProducerNameRegexFilter::kFieldId;
+  static constexpr FieldMetadata_DisableVforkDetection kDisableVforkDetection{};
+  void set_disable_vfork_detection(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DisableVforkDetection::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 };
 
-class TraceConfig_BufferConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class HeapprofdConfig_ContinuousDumpConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  TraceConfig_BufferConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceConfig_BufferConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceConfig_BufferConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_size_kb() const { return at<1>().valid(); }
-  uint32_t size_kb() const { return at<1>().as_uint32(); }
-  bool has_fill_policy() const { return at<4>().valid(); }
-  int32_t fill_policy() const { return at<4>().as_int32(); }
+  HeapprofdConfig_ContinuousDumpConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HeapprofdConfig_ContinuousDumpConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HeapprofdConfig_ContinuousDumpConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dump_phase_ms() const { return at<5>().valid(); }
+  uint32_t dump_phase_ms() const { return at<5>().as_uint32(); }
+  bool has_dump_interval_ms() const { return at<6>().valid(); }
+  uint32_t dump_interval_ms() const { return at<6>().as_uint32(); }
 };
 
-class TraceConfig_BufferConfig : public ::protozero::Message {
+class HeapprofdConfig_ContinuousDumpConfig : public ::protozero::Message {
  public:
-  using Decoder = TraceConfig_BufferConfig_Decoder;
+  using Decoder = HeapprofdConfig_ContinuousDumpConfig_Decoder;
   enum : int32_t {
-    kSizeKbFieldNumber = 1,
-    kFillPolicyFieldNumber = 4,
+    kDumpPhaseMsFieldNumber = 5,
+    kDumpIntervalMsFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.BufferConfig"; }
-
+  static constexpr const char* GetName() { return ".perfetto.protos.HeapprofdConfig.ContinuousDumpConfig"; }
 
-  using FillPolicy = ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy;
-  static inline const char* FillPolicy_Name(FillPolicy value) {
-    return ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy_Name(value);
-  }
-  static const FillPolicy UNSPECIFIED = FillPolicy::UNSPECIFIED;
-  static const FillPolicy RING_BUFFER = FillPolicy::RING_BUFFER;
-  static const FillPolicy DISCARD = FillPolicy::DISCARD;
 
-  using FieldMetadata_SizeKb =
+  using FieldMetadata_DumpPhaseMs =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      TraceConfig_BufferConfig>;
+      HeapprofdConfig_ContinuousDumpConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SizeKb kSizeKb() { return {}; }
-  void set_size_kb(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SizeKb::kFieldId;
+  static constexpr FieldMetadata_DumpPhaseMs kDumpPhaseMs{};
+  void set_dump_phase_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DumpPhaseMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -44362,28 +51458,21 @@ class TraceConfig_BufferConfig : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FillPolicy =
+  using FieldMetadata_DumpIntervalMs =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy,
-      TraceConfig_BufferConfig>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      HeapprofdConfig_ContinuousDumpConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FillPolicy kFillPolicy() { return {}; }
-  void set_fill_policy(::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy value) {
-    static constexpr uint32_t field_id = FieldMetadata_FillPolicy::kFieldId;
+  static constexpr FieldMetadata_DumpIntervalMs kDumpIntervalMs{};
+  void set_dump_interval_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DumpIntervalMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
@@ -44392,11 +51481,11 @@ class TraceConfig_BufferConfig : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/clock_snapshot.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/config/profiling/java_hprof_config.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CLOCK_SNAPSHOT_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CLOCK_SNAPSHOT_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_JAVA_HPROF_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_JAVA_HPROF_CONFIG_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -44410,497 +51499,268 @@ class TraceConfig_BufferConfig : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
+class JavaHprofConfig_ContinuousDumpConfig;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-class ClockSnapshot_Clock;
-enum BuiltinClock : int32_t;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-namespace perfetto_pbzero_enum_ClockSnapshot_Clock {
-enum BuiltinClocks : int32_t {
-  UNKNOWN = 0,
-  REALTIME = 1,
-  REALTIME_COARSE = 2,
-  MONOTONIC = 3,
-  MONOTONIC_COARSE = 4,
-  MONOTONIC_RAW = 5,
-  BOOTTIME = 6,
-  BUILTIN_CLOCK_MAX_ID = 63,
+class JavaHprofConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
+ public:
+  JavaHprofConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit JavaHprofConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit JavaHprofConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_process_cmdline() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> process_cmdline() const { return GetRepeated<::protozero::ConstChars>(1); }
+  bool has_pid() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint64_t> pid() const { return GetRepeated<uint64_t>(2); }
+  bool has_target_installed_by() const { return at<7>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> target_installed_by() const { return GetRepeated<::protozero::ConstChars>(7); }
+  bool has_continuous_dump_config() const { return at<3>().valid(); }
+  ::protozero::ConstBytes continuous_dump_config() const { return at<3>().as_bytes(); }
+  bool has_min_anonymous_memory_kb() const { return at<4>().valid(); }
+  uint32_t min_anonymous_memory_kb() const { return at<4>().as_uint32(); }
+  bool has_dump_smaps() const { return at<5>().valid(); }
+  bool dump_smaps() const { return at<5>().as_bool(); }
+  bool has_ignored_types() const { return at<6>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> ignored_types() const { return GetRepeated<::protozero::ConstChars>(6); }
 };
-} // namespace perfetto_pbzero_enum_ClockSnapshot_Clock
-using ClockSnapshot_Clock_BuiltinClocks = perfetto_pbzero_enum_ClockSnapshot_Clock::BuiltinClocks;
-
-
-constexpr ClockSnapshot_Clock_BuiltinClocks ClockSnapshot_Clock_BuiltinClocks_MIN = ClockSnapshot_Clock_BuiltinClocks::UNKNOWN;
-constexpr ClockSnapshot_Clock_BuiltinClocks ClockSnapshot_Clock_BuiltinClocks_MAX = ClockSnapshot_Clock_BuiltinClocks::BUILTIN_CLOCK_MAX_ID;
-
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ClockSnapshot_Clock_BuiltinClocks_Name(::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::UNKNOWN:
-    return "UNKNOWN";
-
-  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::REALTIME:
-    return "REALTIME";
-
-  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::REALTIME_COARSE:
-    return "REALTIME_COARSE";
-
-  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::MONOTONIC:
-    return "MONOTONIC";
-
-  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::MONOTONIC_COARSE:
-    return "MONOTONIC_COARSE";
-
-  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::MONOTONIC_RAW:
-    return "MONOTONIC_RAW";
-
-  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::BOOTTIME:
-    return "BOOTTIME";
-
-  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::BUILTIN_CLOCK_MAX_ID:
-    return "BUILTIN_CLOCK_MAX_ID";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-class ClockSnapshot_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  ClockSnapshot_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ClockSnapshot_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ClockSnapshot_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_clocks() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> clocks() const { return GetRepeated<::protozero::ConstBytes>(1); }
-  bool has_primary_trace_clock() const { return at<2>().valid(); }
-  int32_t primary_trace_clock() const { return at<2>().as_int32(); }
-};
-
-class ClockSnapshot : public ::protozero::Message {
+class JavaHprofConfig : public ::protozero::Message {
  public:
-  using Decoder = ClockSnapshot_Decoder;
+  using Decoder = JavaHprofConfig_Decoder;
   enum : int32_t {
-    kClocksFieldNumber = 1,
-    kPrimaryTraceClockFieldNumber = 2,
+    kProcessCmdlineFieldNumber = 1,
+    kPidFieldNumber = 2,
+    kTargetInstalledByFieldNumber = 7,
+    kContinuousDumpConfigFieldNumber = 3,
+    kMinAnonymousMemoryKbFieldNumber = 4,
+    kDumpSmapsFieldNumber = 5,
+    kIgnoredTypesFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ClockSnapshot"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.JavaHprofConfig"; }
 
-  using Clock = ::perfetto::protos::pbzero::ClockSnapshot_Clock;
+  using ContinuousDumpConfig = ::perfetto::protos::pbzero::JavaHprofConfig_ContinuousDumpConfig;
 
-  using FieldMetadata_Clocks =
+  using FieldMetadata_ProcessCmdline =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ClockSnapshot_Clock,
-      ClockSnapshot>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      JavaHprofConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Clocks kClocks() { return {}; }
-  template <typename T = ClockSnapshot_Clock> T* add_clocks() {
-    return BeginNestedMessage<T>(1);
+  static constexpr FieldMetadata_ProcessCmdline kProcessCmdline{};
+  void add_process_cmdline(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ProcessCmdline::kFieldId, data, size);
   }
-
-
-  using FieldMetadata_PrimaryTraceClock =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::BuiltinClock,
-      ClockSnapshot>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PrimaryTraceClock kPrimaryTraceClock() { return {}; }
-  void set_primary_trace_clock(::perfetto::protos::pbzero::BuiltinClock value) {
-    static constexpr uint32_t field_id = FieldMetadata_PrimaryTraceClock::kFieldId;
+  void add_process_cmdline(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ProcessCmdline::kFieldId, chars.data, chars.size);
+  }
+  void add_process_cmdline(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProcessCmdline::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
-};
-
-class ClockSnapshot_Clock_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  ClockSnapshot_Clock_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ClockSnapshot_Clock_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ClockSnapshot_Clock_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_clock_id() const { return at<1>().valid(); }
-  uint32_t clock_id() const { return at<1>().as_uint32(); }
-  bool has_timestamp() const { return at<2>().valid(); }
-  uint64_t timestamp() const { return at<2>().as_uint64(); }
-  bool has_is_incremental() const { return at<3>().valid(); }
-  bool is_incremental() const { return at<3>().as_bool(); }
-  bool has_unit_multiplier_ns() const { return at<4>().valid(); }
-  uint64_t unit_multiplier_ns() const { return at<4>().as_uint64(); }
-};
-
-class ClockSnapshot_Clock : public ::protozero::Message {
- public:
-  using Decoder = ClockSnapshot_Clock_Decoder;
-  enum : int32_t {
-    kClockIdFieldNumber = 1,
-    kTimestampFieldNumber = 2,
-    kIsIncrementalFieldNumber = 3,
-    kUnitMultiplierNsFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ClockSnapshot.Clock"; }
-
-
-  using BuiltinClocks = ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks;
-  static inline const char* BuiltinClocks_Name(BuiltinClocks value) {
-    return ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks_Name(value);
-  }
-  static const BuiltinClocks UNKNOWN = BuiltinClocks::UNKNOWN;
-  static const BuiltinClocks REALTIME = BuiltinClocks::REALTIME;
-  static const BuiltinClocks REALTIME_COARSE = BuiltinClocks::REALTIME_COARSE;
-  static const BuiltinClocks MONOTONIC = BuiltinClocks::MONOTONIC;
-  static const BuiltinClocks MONOTONIC_COARSE = BuiltinClocks::MONOTONIC_COARSE;
-  static const BuiltinClocks MONOTONIC_RAW = BuiltinClocks::MONOTONIC_RAW;
-  static const BuiltinClocks BOOTTIME = BuiltinClocks::BOOTTIME;
-  static const BuiltinClocks BUILTIN_CLOCK_MAX_ID = BuiltinClocks::BUILTIN_CLOCK_MAX_ID;
 
-  using FieldMetadata_ClockId =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      ClockSnapshot_Clock>;
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      JavaHprofConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClockId kClockId() { return {}; }
-  void set_clock_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ClockId::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void add_pid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Timestamp =
+  using FieldMetadata_TargetInstalledBy =
     ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ClockSnapshot_Clock>;
+      7,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      JavaHprofConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timestamp kTimestamp() { return {}; }
-  void set_timestamp(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+  static constexpr FieldMetadata_TargetInstalledBy kTargetInstalledBy{};
+  void add_target_installed_by(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_TargetInstalledBy::kFieldId, data, size);
+  }
+  void add_target_installed_by(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_TargetInstalledBy::kFieldId, chars.data, chars.size);
+  }
+  void add_target_installed_by(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_TargetInstalledBy::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IsIncremental =
+  using FieldMetadata_ContinuousDumpConfig =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ClockSnapshot_Clock>;
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      JavaHprofConfig_ContinuousDumpConfig,
+      JavaHprofConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IsIncremental kIsIncremental() { return {}; }
-  void set_is_incremental(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_IsIncremental::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_ContinuousDumpConfig kContinuousDumpConfig{};
+  template <typename T = JavaHprofConfig_ContinuousDumpConfig> T* set_continuous_dump_config() {
+    return BeginNestedMessage<T>(3);
   }
 
-  using FieldMetadata_UnitMultiplierNs =
+
+  using FieldMetadata_MinAnonymousMemoryKb =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ClockSnapshot_Clock>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      JavaHprofConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UnitMultiplierNs kUnitMultiplierNs() { return {}; }
-  void set_unit_multiplier_ns(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_UnitMultiplierNs::kFieldId;
+  static constexpr FieldMetadata_MinAnonymousMemoryKb kMinAnonymousMemoryKb{};
+  void set_min_anonymous_memory_kb(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MinAnonymousMemoryKb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/trace_uuid.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACE_UUID_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACE_UUID_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class TraceUuid_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TraceUuid_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TraceUuid_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TraceUuid_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_msb() const { return at<1>().valid(); }
-  int64_t msb() const { return at<1>().as_int64(); }
-  bool has_lsb() const { return at<2>().valid(); }
-  int64_t lsb() const { return at<2>().as_int64(); }
-};
-
-class TraceUuid : public ::protozero::Message {
- public:
-  using Decoder = TraceUuid_Decoder;
-  enum : int32_t {
-    kMsbFieldNumber = 1,
-    kLsbFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TraceUuid"; }
 
-
-  using FieldMetadata_Msb =
+  using FieldMetadata_DumpSmaps =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TraceUuid>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      JavaHprofConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Msb kMsb() { return {}; }
-  void set_msb(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Msb::kFieldId;
+  static constexpr FieldMetadata_DumpSmaps kDumpSmaps{};
+  void set_dump_smaps(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DumpSmaps::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Lsb =
+  using FieldMetadata_IgnoredTypes =
     ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TraceUuid>;
+      6,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      JavaHprofConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lsb kLsb() { return {}; }
-  void set_lsb(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lsb::kFieldId;
+  static constexpr FieldMetadata_IgnoredTypes kIgnoredTypes{};
+  void add_ignored_types(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_IgnoredTypes::kFieldId, data, size);
+  }
+  void add_ignored_types(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_IgnoredTypes::kFieldId, chars.data, chars.size);
+  }
+  void add_ignored_types(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_IgnoredTypes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/trigger.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRIGGER_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRIGGER_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class Trigger_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class JavaHprofConfig_ContinuousDumpConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  Trigger_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Trigger_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Trigger_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_trigger_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars trigger_name() const { return at<1>().as_string(); }
-  bool has_producer_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars producer_name() const { return at<2>().as_string(); }
-  bool has_trusted_producer_uid() const { return at<3>().valid(); }
-  int32_t trusted_producer_uid() const { return at<3>().as_int32(); }
+  JavaHprofConfig_ContinuousDumpConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit JavaHprofConfig_ContinuousDumpConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit JavaHprofConfig_ContinuousDumpConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dump_phase_ms() const { return at<1>().valid(); }
+  uint32_t dump_phase_ms() const { return at<1>().as_uint32(); }
+  bool has_dump_interval_ms() const { return at<2>().valid(); }
+  uint32_t dump_interval_ms() const { return at<2>().as_uint32(); }
+  bool has_scan_pids_only_on_start() const { return at<3>().valid(); }
+  bool scan_pids_only_on_start() const { return at<3>().as_bool(); }
 };
 
-class Trigger : public ::protozero::Message {
+class JavaHprofConfig_ContinuousDumpConfig : public ::protozero::Message {
  public:
-  using Decoder = Trigger_Decoder;
+  using Decoder = JavaHprofConfig_ContinuousDumpConfig_Decoder;
   enum : int32_t {
-    kTriggerNameFieldNumber = 1,
-    kProducerNameFieldNumber = 2,
-    kTrustedProducerUidFieldNumber = 3,
+    kDumpPhaseMsFieldNumber = 1,
+    kDumpIntervalMsFieldNumber = 2,
+    kScanPidsOnlyOnStartFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Trigger"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.JavaHprofConfig.ContinuousDumpConfig"; }
 
 
-  using FieldMetadata_TriggerName =
+  using FieldMetadata_DumpPhaseMs =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      Trigger>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      JavaHprofConfig_ContinuousDumpConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TriggerName kTriggerName() { return {}; }
-  void set_trigger_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_TriggerName::kFieldId, data, size);
-  }
-  void set_trigger_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_TriggerName::kFieldId, chars.data, chars.size);
-  }
-  void set_trigger_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_TriggerName::kFieldId;
+  static constexpr FieldMetadata_DumpPhaseMs kDumpPhaseMs{};
+  void set_dump_phase_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DumpPhaseMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ProducerName =
+  using FieldMetadata_DumpIntervalMs =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      Trigger>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      JavaHprofConfig_ContinuousDumpConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProducerName kProducerName() { return {}; }
-  void set_producer_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ProducerName::kFieldId, data, size);
-  }
-  void set_producer_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ProducerName::kFieldId, chars.data, chars.size);
-  }
-  void set_producer_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProducerName::kFieldId;
+  static constexpr FieldMetadata_DumpIntervalMs kDumpIntervalMs{};
+  void set_dump_interval_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DumpIntervalMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TrustedProducerUid =
+  using FieldMetadata_ScanPidsOnlyOnStart =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Trigger>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      JavaHprofConfig_ContinuousDumpConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustedProducerUid kTrustedProducerUid() { return {}; }
-  void set_trusted_producer_uid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TrustedProducerUid::kFieldId;
+  static constexpr FieldMetadata_ScanPidsOnlyOnStart kScanPidsOnlyOnStart{};
+  void set_scan_pids_only_on_start(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ScanPidsOnlyOnStart::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 };
@@ -44909,11 +51769,11 @@ class Trigger : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/system_info.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/config/profiling/perf_event_config.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_SYSTEM_INFO_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_SYSTEM_INFO_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_PERF_EVENT_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_PERF_EVENT_CONFIG_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -44924,171 +51784,248 @@ class Trigger : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class FollowerEvent;
+class PerfEventConfig_CallstackSampling;
+class PerfEventConfig_Scope;
+class PerfEvents_Timebase;
+namespace perfetto_pbzero_enum_PerfEventConfig {
+enum UnwindMode : int32_t;
+}  // namespace perfetto_pbzero_enum_PerfEventConfig
+using PerfEventConfig_UnwindMode = perfetto_pbzero_enum_PerfEventConfig::UnwindMode;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-class Utsname;
+namespace perfetto_pbzero_enum_PerfEventConfig {
+enum UnwindMode : int32_t {
+  UNWIND_UNKNOWN = 0,
+  UNWIND_SKIP = 1,
+  UNWIND_DWARF = 2,
+  UNWIND_FRAME_POINTER = 3,
+};
+} // namespace perfetto_pbzero_enum_PerfEventConfig
+using PerfEventConfig_UnwindMode = perfetto_pbzero_enum_PerfEventConfig::UnwindMode;
+
+
+constexpr PerfEventConfig_UnwindMode PerfEventConfig_UnwindMode_MIN = PerfEventConfig_UnwindMode::UNWIND_UNKNOWN;
+constexpr PerfEventConfig_UnwindMode PerfEventConfig_UnwindMode_MAX = PerfEventConfig_UnwindMode::UNWIND_FRAME_POINTER;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* PerfEventConfig_UnwindMode_Name(::perfetto::protos::pbzero::PerfEventConfig_UnwindMode value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::PerfEventConfig_UnwindMode::UNWIND_UNKNOWN:
+    return "UNWIND_UNKNOWN";
 
-class SystemInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+  case ::perfetto::protos::pbzero::PerfEventConfig_UnwindMode::UNWIND_SKIP:
+    return "UNWIND_SKIP";
+
+  case ::perfetto::protos::pbzero::PerfEventConfig_UnwindMode::UNWIND_DWARF:
+    return "UNWIND_DWARF";
+
+  case ::perfetto::protos::pbzero::PerfEventConfig_UnwindMode::UNWIND_FRAME_POINTER:
+    return "UNWIND_FRAME_POINTER";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class PerfEventConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/20> {
  public:
-  SystemInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SystemInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SystemInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_utsname() const { return at<1>().valid(); }
-  ::protozero::ConstBytes utsname() const { return at<1>().as_bytes(); }
-  bool has_android_build_fingerprint() const { return at<2>().valid(); }
-  ::protozero::ConstChars android_build_fingerprint() const { return at<2>().as_string(); }
-  bool has_hz() const { return at<3>().valid(); }
-  int64_t hz() const { return at<3>().as_int64(); }
-  bool has_tracing_service_version() const { return at<4>().valid(); }
-  ::protozero::ConstChars tracing_service_version() const { return at<4>().as_string(); }
-  bool has_android_sdk_version() const { return at<5>().valid(); }
-  uint64_t android_sdk_version() const { return at<5>().as_uint64(); }
-  bool has_page_size() const { return at<6>().valid(); }
-  uint32_t page_size() const { return at<6>().as_uint32(); }
+  PerfEventConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PerfEventConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PerfEventConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_timebase() const { return at<15>().valid(); }
+  ::protozero::ConstBytes timebase() const { return at<15>().as_bytes(); }
+  bool has_followers() const { return at<19>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> followers() const { return GetRepeated<::protozero::ConstBytes>(19); }
+  bool has_callstack_sampling() const { return at<16>().valid(); }
+  ::protozero::ConstBytes callstack_sampling() const { return at<16>().as_bytes(); }
+  bool has_target_cpu() const { return at<20>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint32_t> target_cpu() const { return GetRepeated<uint32_t>(20); }
+  bool has_ring_buffer_read_period_ms() const { return at<8>().valid(); }
+  uint32_t ring_buffer_read_period_ms() const { return at<8>().as_uint32(); }
+  bool has_ring_buffer_pages() const { return at<3>().valid(); }
+  uint32_t ring_buffer_pages() const { return at<3>().as_uint32(); }
+  bool has_max_enqueued_footprint_kb() const { return at<17>().valid(); }
+  uint64_t max_enqueued_footprint_kb() const { return at<17>().as_uint64(); }
+  bool has_max_daemon_memory_kb() const { return at<13>().valid(); }
+  uint32_t max_daemon_memory_kb() const { return at<13>().as_uint32(); }
+  bool has_remote_descriptor_timeout_ms() const { return at<9>().valid(); }
+  uint32_t remote_descriptor_timeout_ms() const { return at<9>().as_uint32(); }
+  bool has_unwind_state_clear_period_ms() const { return at<10>().valid(); }
+  uint32_t unwind_state_clear_period_ms() const { return at<10>().as_uint32(); }
+  bool has_target_installed_by() const { return at<18>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> target_installed_by() const { return GetRepeated<::protozero::ConstChars>(18); }
+  bool has_all_cpus() const { return at<1>().valid(); }
+  bool all_cpus() const { return at<1>().as_bool(); }
+  bool has_sampling_frequency() const { return at<2>().valid(); }
+  uint32_t sampling_frequency() const { return at<2>().as_uint32(); }
+  bool has_kernel_frames() const { return at<12>().valid(); }
+  bool kernel_frames() const { return at<12>().as_bool(); }
+  bool has_target_pid() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> target_pid() const { return GetRepeated<int32_t>(4); }
+  bool has_target_cmdline() const { return at<5>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> target_cmdline() const { return GetRepeated<::protozero::ConstChars>(5); }
+  bool has_exclude_pid() const { return at<6>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> exclude_pid() const { return GetRepeated<int32_t>(6); }
+  bool has_exclude_cmdline() const { return at<7>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> exclude_cmdline() const { return GetRepeated<::protozero::ConstChars>(7); }
+  bool has_additional_cmdline_count() const { return at<11>().valid(); }
+  uint32_t additional_cmdline_count() const { return at<11>().as_uint32(); }
 };
 
-class SystemInfo : public ::protozero::Message {
+class PerfEventConfig : public ::protozero::Message {
  public:
-  using Decoder = SystemInfo_Decoder;
+  using Decoder = PerfEventConfig_Decoder;
   enum : int32_t {
-    kUtsnameFieldNumber = 1,
-    kAndroidBuildFingerprintFieldNumber = 2,
-    kHzFieldNumber = 3,
-    kTracingServiceVersionFieldNumber = 4,
-    kAndroidSdkVersionFieldNumber = 5,
-    kPageSizeFieldNumber = 6,
+    kTimebaseFieldNumber = 15,
+    kFollowersFieldNumber = 19,
+    kCallstackSamplingFieldNumber = 16,
+    kTargetCpuFieldNumber = 20,
+    kRingBufferReadPeriodMsFieldNumber = 8,
+    kRingBufferPagesFieldNumber = 3,
+    kMaxEnqueuedFootprintKbFieldNumber = 17,
+    kMaxDaemonMemoryKbFieldNumber = 13,
+    kRemoteDescriptorTimeoutMsFieldNumber = 9,
+    kUnwindStateClearPeriodMsFieldNumber = 10,
+    kTargetInstalledByFieldNumber = 18,
+    kAllCpusFieldNumber = 1,
+    kSamplingFrequencyFieldNumber = 2,
+    kKernelFramesFieldNumber = 12,
+    kTargetPidFieldNumber = 4,
+    kTargetCmdlineFieldNumber = 5,
+    kExcludePidFieldNumber = 6,
+    kExcludeCmdlineFieldNumber = 7,
+    kAdditionalCmdlineCountFieldNumber = 11,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SystemInfo"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.PerfEventConfig"; }
 
+  using CallstackSampling = ::perfetto::protos::pbzero::PerfEventConfig_CallstackSampling;
+  using Scope = ::perfetto::protos::pbzero::PerfEventConfig_Scope;
 
-  using FieldMetadata_Utsname =
+  using UnwindMode = ::perfetto::protos::pbzero::PerfEventConfig_UnwindMode;
+  static inline const char* UnwindMode_Name(UnwindMode value) {
+    return ::perfetto::protos::pbzero::PerfEventConfig_UnwindMode_Name(value);
+  }
+  static inline const UnwindMode UNWIND_UNKNOWN = UnwindMode::UNWIND_UNKNOWN;
+  static inline const UnwindMode UNWIND_SKIP = UnwindMode::UNWIND_SKIP;
+  static inline const UnwindMode UNWIND_DWARF = UnwindMode::UNWIND_DWARF;
+  static inline const UnwindMode UNWIND_FRAME_POINTER = UnwindMode::UNWIND_FRAME_POINTER;
+
+  using FieldMetadata_Timebase =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      15,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      Utsname,
-      SystemInfo>;
+      PerfEvents_Timebase,
+      PerfEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Utsname kUtsname() { return {}; }
-  template <typename T = Utsname> T* set_utsname() {
-    return BeginNestedMessage<T>(1);
+  static constexpr FieldMetadata_Timebase kTimebase{};
+  template <typename T = PerfEvents_Timebase> T* set_timebase() {
+    return BeginNestedMessage<T>(15);
   }
 
 
-  using FieldMetadata_AndroidBuildFingerprint =
+  using FieldMetadata_Followers =
     ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SystemInfo>;
+      19,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FollowerEvent,
+      PerfEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidBuildFingerprint kAndroidBuildFingerprint() { return {}; }
-  void set_android_build_fingerprint(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_AndroidBuildFingerprint::kFieldId, data, size);
+  static constexpr FieldMetadata_Followers kFollowers{};
+  template <typename T = FollowerEvent> T* add_followers() {
+    return BeginNestedMessage<T>(19);
   }
-  void set_android_build_fingerprint(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_AndroidBuildFingerprint::kFieldId, chars.data, chars.size);
+
+
+  using FieldMetadata_CallstackSampling =
+    ::protozero::proto_utils::FieldMetadata<
+      16,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PerfEventConfig_CallstackSampling,
+      PerfEventConfig>;
+
+  static constexpr FieldMetadata_CallstackSampling kCallstackSampling{};
+  template <typename T = PerfEventConfig_CallstackSampling> T* set_callstack_sampling() {
+    return BeginNestedMessage<T>(16);
   }
-  void set_android_build_fingerprint(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_AndroidBuildFingerprint::kFieldId;
+
+
+  using FieldMetadata_TargetCpu =
+    ::protozero::proto_utils::FieldMetadata<
+      20,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      PerfEventConfig>;
+
+  static constexpr FieldMetadata_TargetCpu kTargetCpu{};
+  void add_target_cpu(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TargetCpu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Hz =
+  using FieldMetadata_RingBufferReadPeriodMs =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      SystemInfo>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      PerfEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Hz kHz() { return {}; }
-  void set_hz(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Hz::kFieldId;
+  static constexpr FieldMetadata_RingBufferReadPeriodMs kRingBufferReadPeriodMs{};
+  void set_ring_buffer_read_period_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RingBufferReadPeriodMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TracingServiceVersion =
+  using FieldMetadata_RingBufferPages =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SystemInfo>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      PerfEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TracingServiceVersion kTracingServiceVersion() { return {}; }
-  void set_tracing_service_version(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_TracingServiceVersion::kFieldId, data, size);
-  }
-  void set_tracing_service_version(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_TracingServiceVersion::kFieldId, chars.data, chars.size);
-  }
-  void set_tracing_service_version(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_TracingServiceVersion::kFieldId;
+  static constexpr FieldMetadata_RingBufferPages kRingBufferPages{};
+  void set_ring_buffer_pages(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RingBufferPages::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_AndroidSdkVersion =
+  using FieldMetadata_MaxEnqueuedFootprintKb =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      17,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      SystemInfo>;
+      PerfEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidSdkVersion kAndroidSdkVersion() { return {}; }
-  void set_android_sdk_version(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AndroidSdkVersion::kFieldId;
+  static constexpr FieldMetadata_MaxEnqueuedFootprintKb kMaxEnqueuedFootprintKb{};
+  void set_max_enqueued_footprint_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MaxEnqueuedFootprintKb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -45096,145 +52033,77 @@ class SystemInfo : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PageSize =
+  using FieldMetadata_MaxDaemonMemoryKb =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      13,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SystemInfo>;
+      PerfEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PageSize kPageSize() { return {}; }
-  void set_page_size(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PageSize::kFieldId;
+  static constexpr FieldMetadata_MaxDaemonMemoryKb kMaxDaemonMemoryKb{};
+  void set_max_daemon_memory_kb(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MaxDaemonMemoryKb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class Utsname_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Utsname_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Utsname_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Utsname_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_sysname() const { return at<1>().valid(); }
-  ::protozero::ConstChars sysname() const { return at<1>().as_string(); }
-  bool has_version() const { return at<2>().valid(); }
-  ::protozero::ConstChars version() const { return at<2>().as_string(); }
-  bool has_release() const { return at<3>().valid(); }
-  ::protozero::ConstChars release() const { return at<3>().as_string(); }
-  bool has_machine() const { return at<4>().valid(); }
-  ::protozero::ConstChars machine() const { return at<4>().as_string(); }
-};
-
-class Utsname : public ::protozero::Message {
- public:
-  using Decoder = Utsname_Decoder;
-  enum : int32_t {
-    kSysnameFieldNumber = 1,
-    kVersionFieldNumber = 2,
-    kReleaseFieldNumber = 3,
-    kMachineFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.Utsname"; }
 
-
-  using FieldMetadata_Sysname =
+  using FieldMetadata_RemoteDescriptorTimeoutMs =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      Utsname>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      PerfEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sysname kSysname() { return {}; }
-  void set_sysname(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Sysname::kFieldId, data, size);
-  }
-  void set_sysname(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Sysname::kFieldId, chars.data, chars.size);
-  }
-  void set_sysname(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Sysname::kFieldId;
+  static constexpr FieldMetadata_RemoteDescriptorTimeoutMs kRemoteDescriptorTimeoutMs{};
+  void set_remote_descriptor_timeout_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RemoteDescriptorTimeoutMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Version =
+  using FieldMetadata_UnwindStateClearPeriodMs =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      Utsname>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      PerfEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Version kVersion() { return {}; }
-  void set_version(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Version::kFieldId, data, size);
-  }
-  void set_version(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Version::kFieldId, chars.data, chars.size);
-  }
-  void set_version(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Version::kFieldId;
+  static constexpr FieldMetadata_UnwindStateClearPeriodMs kUnwindStateClearPeriodMs{};
+  void set_unwind_state_clear_period_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_UnwindStateClearPeriodMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Release =
+  using FieldMetadata_TargetInstalledBy =
     ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      18,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      Utsname>;
+      PerfEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Release kRelease() { return {}; }
-  void set_release(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Release::kFieldId, data, size);
+  static constexpr FieldMetadata_TargetInstalledBy kTargetInstalledBy{};
+  void add_target_installed_by(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_TargetInstalledBy::kFieldId, data, size);
   }
-  void set_release(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Release::kFieldId, chars.data, chars.size);
+  void add_target_installed_by(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_TargetInstalledBy::kFieldId, chars.data, chars.size);
   }
-  void set_release(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Release::kFieldId;
+  void add_target_installed_by(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_TargetInstalledBy::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -45242,213 +52111,95 @@ class Utsname : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Machine =
+  using FieldMetadata_AllCpus =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      Utsname>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      PerfEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Machine kMachine() { return {}; }
-  void set_machine(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Machine::kFieldId, data, size);
-  }
-  void set_machine(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Machine::kFieldId, chars.data, chars.size);
-  }
-  void set_machine(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Machine::kFieldId;
+  static constexpr FieldMetadata_AllCpus kAllCpus{};
+  void set_all_cpus(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_AllCpus::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/android/android_game_intervention_list.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_GAME_INTERVENTION_LIST_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_GAME_INTERVENTION_LIST_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-class AndroidGameInterventionList_GameModeInfo;
-class AndroidGameInterventionList_GamePackageInfo;
-
-class AndroidGameInterventionList_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  AndroidGameInterventionList_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AndroidGameInterventionList_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AndroidGameInterventionList_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_game_packages() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> game_packages() const { return GetRepeated<::protozero::ConstBytes>(1); }
-  bool has_parse_error() const { return at<2>().valid(); }
-  bool parse_error() const { return at<2>().as_bool(); }
-  bool has_read_error() const { return at<3>().valid(); }
-  bool read_error() const { return at<3>().as_bool(); }
-};
-
-class AndroidGameInterventionList : public ::protozero::Message {
- public:
-  using Decoder = AndroidGameInterventionList_Decoder;
-  enum : int32_t {
-    kGamePackagesFieldNumber = 1,
-    kParseErrorFieldNumber = 2,
-    kReadErrorFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.AndroidGameInterventionList"; }
-
-  using GameModeInfo = ::perfetto::protos::pbzero::AndroidGameInterventionList_GameModeInfo;
-  using GamePackageInfo = ::perfetto::protos::pbzero::AndroidGameInterventionList_GamePackageInfo;
-
-  using FieldMetadata_GamePackages =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AndroidGameInterventionList_GamePackageInfo,
-      AndroidGameInterventionList>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GamePackages kGamePackages() { return {}; }
-  template <typename T = AndroidGameInterventionList_GamePackageInfo> T* add_game_packages() {
-    return BeginNestedMessage<T>(1);
-  }
-
 
-  using FieldMetadata_ParseError =
+  using FieldMetadata_SamplingFrequency =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      AndroidGameInterventionList>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      PerfEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ParseError kParseError() { return {}; }
-  void set_parse_error(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_ParseError::kFieldId;
+  static constexpr FieldMetadata_SamplingFrequency kSamplingFrequency{};
+  void set_sampling_frequency(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SamplingFrequency::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ReadError =
+  using FieldMetadata_KernelFrames =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      12,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kBool,
       bool,
-      AndroidGameInterventionList>;
+      PerfEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReadError kReadError() { return {}; }
-  void set_read_error(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReadError::kFieldId;
+  static constexpr FieldMetadata_KernelFrames kKernelFrames{};
+  void set_kernel_frames(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_KernelFrames::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
-};
-
-class AndroidGameInterventionList_GamePackageInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  AndroidGameInterventionList_GamePackageInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AndroidGameInterventionList_GamePackageInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AndroidGameInterventionList_GamePackageInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_uid() const { return at<2>().valid(); }
-  uint64_t uid() const { return at<2>().as_uint64(); }
-  bool has_current_mode() const { return at<3>().valid(); }
-  uint32_t current_mode() const { return at<3>().as_uint32(); }
-  bool has_game_mode_info() const { return at<4>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> game_mode_info() const { return GetRepeated<::protozero::ConstBytes>(4); }
-};
 
-class AndroidGameInterventionList_GamePackageInfo : public ::protozero::Message {
- public:
-  using Decoder = AndroidGameInterventionList_GamePackageInfo_Decoder;
-  enum : int32_t {
-    kNameFieldNumber = 1,
-    kUidFieldNumber = 2,
-    kCurrentModeFieldNumber = 3,
-    kGameModeInfoFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.AndroidGameInterventionList.GamePackageInfo"; }
+  using FieldMetadata_TargetPid =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      PerfEventConfig>;
 
+  static constexpr FieldMetadata_TargetPid kTargetPid{};
+  void add_target_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TargetPid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Name =
+  using FieldMetadata_TargetCmdline =
     ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      5,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      AndroidGameInterventionList_GamePackageInfo>;
+      PerfEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  static constexpr FieldMetadata_TargetCmdline kTargetCmdline{};
+  void add_target_cmdline(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_TargetCmdline::kFieldId, data, size);
   }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  void add_target_cmdline(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_TargetCmdline::kFieldId, chars.data, chars.size);
   }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  void add_target_cmdline(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_TargetCmdline::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -45456,814 +52207,519 @@ class AndroidGameInterventionList_GamePackageInfo : public ::protozero::Message
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Uid =
+  using FieldMetadata_ExcludePid =
     ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      AndroidGameInterventionList_GamePackageInfo>;
+      6,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      PerfEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Uid kUid() { return {}; }
-  void set_uid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId;
+  static constexpr FieldMetadata_ExcludePid kExcludePid{};
+  void add_exclude_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ExcludePid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CurrentMode =
+  using FieldMetadata_ExcludeCmdline =
     ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      AndroidGameInterventionList_GamePackageInfo>;
+      7,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      PerfEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CurrentMode kCurrentMode() { return {}; }
-  void set_current_mode(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CurrentMode::kFieldId;
+  static constexpr FieldMetadata_ExcludeCmdline kExcludeCmdline{};
+  void add_exclude_cmdline(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ExcludeCmdline::kFieldId, data, size);
+  }
+  void add_exclude_cmdline(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ExcludeCmdline::kFieldId, chars.data, chars.size);
+  }
+  void add_exclude_cmdline(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ExcludeCmdline::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_GameModeInfo =
+  using FieldMetadata_AdditionalCmdlineCount =
     ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AndroidGameInterventionList_GameModeInfo,
-      AndroidGameInterventionList_GamePackageInfo>;
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      PerfEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GameModeInfo kGameModeInfo() { return {}; }
-  template <typename T = AndroidGameInterventionList_GameModeInfo> T* add_game_mode_info() {
-    return BeginNestedMessage<T>(4);
+  static constexpr FieldMetadata_AdditionalCmdlineCount kAdditionalCmdlineCount{};
+  void set_additional_cmdline_count(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AdditionalCmdlineCount::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
-
 };
 
-class AndroidGameInterventionList_GameModeInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class PerfEventConfig_Scope_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  AndroidGameInterventionList_GameModeInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AndroidGameInterventionList_GameModeInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AndroidGameInterventionList_GameModeInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_mode() const { return at<1>().valid(); }
-  uint32_t mode() const { return at<1>().as_uint32(); }
-  bool has_use_angle() const { return at<2>().valid(); }
-  bool use_angle() const { return at<2>().as_bool(); }
-  bool has_resolution_downscale() const { return at<3>().valid(); }
-  float resolution_downscale() const { return at<3>().as_float(); }
-  bool has_fps() const { return at<4>().valid(); }
-  float fps() const { return at<4>().as_float(); }
+  PerfEventConfig_Scope_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PerfEventConfig_Scope_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PerfEventConfig_Scope_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_target_pid() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> target_pid() const { return GetRepeated<int32_t>(1); }
+  bool has_target_cmdline() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> target_cmdline() const { return GetRepeated<::protozero::ConstChars>(2); }
+  bool has_exclude_pid() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> exclude_pid() const { return GetRepeated<int32_t>(3); }
+  bool has_exclude_cmdline() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> exclude_cmdline() const { return GetRepeated<::protozero::ConstChars>(4); }
+  bool has_additional_cmdline_count() const { return at<5>().valid(); }
+  uint32_t additional_cmdline_count() const { return at<5>().as_uint32(); }
+  bool has_process_shard_count() const { return at<6>().valid(); }
+  uint32_t process_shard_count() const { return at<6>().as_uint32(); }
 };
 
-class AndroidGameInterventionList_GameModeInfo : public ::protozero::Message {
+class PerfEventConfig_Scope : public ::protozero::Message {
  public:
-  using Decoder = AndroidGameInterventionList_GameModeInfo_Decoder;
+  using Decoder = PerfEventConfig_Scope_Decoder;
   enum : int32_t {
-    kModeFieldNumber = 1,
-    kUseAngleFieldNumber = 2,
-    kResolutionDownscaleFieldNumber = 3,
-    kFpsFieldNumber = 4,
+    kTargetPidFieldNumber = 1,
+    kTargetCmdlineFieldNumber = 2,
+    kExcludePidFieldNumber = 3,
+    kExcludeCmdlineFieldNumber = 4,
+    kAdditionalCmdlineCountFieldNumber = 5,
+    kProcessShardCountFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.AndroidGameInterventionList.GameModeInfo"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.PerfEventConfig.Scope"; }
 
 
-  using FieldMetadata_Mode =
+  using FieldMetadata_TargetPid =
     ::protozero::proto_utils::FieldMetadata<
       1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      AndroidGameInterventionList_GameModeInfo>;
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      PerfEventConfig_Scope>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mode kMode() { return {}; }
-  void set_mode(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+  static constexpr FieldMetadata_TargetPid kTargetPid{};
+  void add_target_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TargetPid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_UseAngle =
+  using FieldMetadata_TargetCmdline =
     ::protozero::proto_utils::FieldMetadata<
       2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      AndroidGameInterventionList_GameModeInfo>;
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      PerfEventConfig_Scope>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UseAngle kUseAngle() { return {}; }
-  void set_use_angle(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_UseAngle::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_TargetCmdline kTargetCmdline{};
+  void add_target_cmdline(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_TargetCmdline::kFieldId, data, size);
   }
-
-  using FieldMetadata_ResolutionDownscale =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kFloat,
-      float,
-      AndroidGameInterventionList_GameModeInfo>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ResolutionDownscale kResolutionDownscale() { return {}; }
-  void set_resolution_downscale(float value) {
-    static constexpr uint32_t field_id = FieldMetadata_ResolutionDownscale::kFieldId;
+  void add_target_cmdline(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_TargetCmdline::kFieldId, chars.data, chars.size);
+  }
+  void add_target_cmdline(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_TargetCmdline::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Fps =
+  using FieldMetadata_ExcludePid =
     ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kFloat,
-      float,
-      AndroidGameInterventionList_GameModeInfo>;
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      PerfEventConfig_Scope>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Fps kFps() { return {}; }
-  void set_fps(float value) {
-    static constexpr uint32_t field_id = FieldMetadata_Fps::kFieldId;
+  static constexpr FieldMetadata_ExcludePid kExcludePid{};
+  void add_exclude_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ExcludePid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/android/android_log.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_LOG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_LOG_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-class AndroidLogPacket_LogEvent;
-class AndroidLogPacket_LogEvent_Arg;
-class AndroidLogPacket_Stats;
-enum AndroidLogId : int32_t;
-enum AndroidLogPriority : int32_t;
-
-class AndroidLogPacket_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  AndroidLogPacket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AndroidLogPacket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AndroidLogPacket_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_events() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> events() const { return GetRepeated<::protozero::ConstBytes>(1); }
-  bool has_stats() const { return at<2>().valid(); }
-  ::protozero::ConstBytes stats() const { return at<2>().as_bytes(); }
-};
-
-class AndroidLogPacket : public ::protozero::Message {
- public:
-  using Decoder = AndroidLogPacket_Decoder;
-  enum : int32_t {
-    kEventsFieldNumber = 1,
-    kStatsFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.AndroidLogPacket"; }
-
-  using LogEvent = ::perfetto::protos::pbzero::AndroidLogPacket_LogEvent;
-  using Stats = ::perfetto::protos::pbzero::AndroidLogPacket_Stats;
 
-  using FieldMetadata_Events =
+  using FieldMetadata_ExcludeCmdline =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      4,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AndroidLogPacket_LogEvent,
-      AndroidLogPacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      PerfEventConfig_Scope>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Events kEvents() { return {}; }
-  template <typename T = AndroidLogPacket_LogEvent> T* add_events() {
-    return BeginNestedMessage<T>(1);
+  static constexpr FieldMetadata_ExcludeCmdline kExcludeCmdline{};
+  void add_exclude_cmdline(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ExcludeCmdline::kFieldId, data, size);
   }
-
-
-  using FieldMetadata_Stats =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AndroidLogPacket_Stats,
-      AndroidLogPacket>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Stats kStats() { return {}; }
-  template <typename T = AndroidLogPacket_Stats> T* set_stats() {
-    return BeginNestedMessage<T>(2);
+  void add_exclude_cmdline(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ExcludeCmdline::kFieldId, chars.data, chars.size);
   }
-
-};
-
-class AndroidLogPacket_Stats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  AndroidLogPacket_Stats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AndroidLogPacket_Stats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AndroidLogPacket_Stats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_num_total() const { return at<1>().valid(); }
-  uint64_t num_total() const { return at<1>().as_uint64(); }
-  bool has_num_failed() const { return at<2>().valid(); }
-  uint64_t num_failed() const { return at<2>().as_uint64(); }
-  bool has_num_skipped() const { return at<3>().valid(); }
-  uint64_t num_skipped() const { return at<3>().as_uint64(); }
-};
-
-class AndroidLogPacket_Stats : public ::protozero::Message {
- public:
-  using Decoder = AndroidLogPacket_Stats_Decoder;
-  enum : int32_t {
-    kNumTotalFieldNumber = 1,
-    kNumFailedFieldNumber = 2,
-    kNumSkippedFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.AndroidLogPacket.Stats"; }
-
-
-  using FieldMetadata_NumTotal =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      AndroidLogPacket_Stats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NumTotal kNumTotal() { return {}; }
-  void set_num_total(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NumTotal::kFieldId;
+  void add_exclude_cmdline(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ExcludeCmdline::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NumFailed =
+  using FieldMetadata_AdditionalCmdlineCount =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      AndroidLogPacket_Stats>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      PerfEventConfig_Scope>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NumFailed kNumFailed() { return {}; }
-  void set_num_failed(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NumFailed::kFieldId;
+  static constexpr FieldMetadata_AdditionalCmdlineCount kAdditionalCmdlineCount{};
+  void set_additional_cmdline_count(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AdditionalCmdlineCount::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NumSkipped =
+  using FieldMetadata_ProcessShardCount =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      AndroidLogPacket_Stats>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      PerfEventConfig_Scope>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NumSkipped kNumSkipped() { return {}; }
-  void set_num_skipped(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NumSkipped::kFieldId;
+  static constexpr FieldMetadata_ProcessShardCount kProcessShardCount{};
+  void set_process_shard_count(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProcessShardCount::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class AndroidLogPacket_LogEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class PerfEventConfig_CallstackSampling_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  AndroidLogPacket_LogEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AndroidLogPacket_LogEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AndroidLogPacket_LogEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_log_id() const { return at<1>().valid(); }
-  int32_t log_id() const { return at<1>().as_int32(); }
-  bool has_pid() const { return at<2>().valid(); }
-  int32_t pid() const { return at<2>().as_int32(); }
-  bool has_tid() const { return at<3>().valid(); }
-  int32_t tid() const { return at<3>().as_int32(); }
-  bool has_uid() const { return at<4>().valid(); }
-  int32_t uid() const { return at<4>().as_int32(); }
-  bool has_timestamp() const { return at<5>().valid(); }
-  uint64_t timestamp() const { return at<5>().as_uint64(); }
-  bool has_tag() const { return at<6>().valid(); }
-  ::protozero::ConstChars tag() const { return at<6>().as_string(); }
-  bool has_prio() const { return at<7>().valid(); }
-  int32_t prio() const { return at<7>().as_int32(); }
-  bool has_message() const { return at<8>().valid(); }
-  ::protozero::ConstChars message() const { return at<8>().as_string(); }
-  bool has_args() const { return at<9>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> args() const { return GetRepeated<::protozero::ConstBytes>(9); }
+  PerfEventConfig_CallstackSampling_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PerfEventConfig_CallstackSampling_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PerfEventConfig_CallstackSampling_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_scope() const { return at<1>().valid(); }
+  ::protozero::ConstBytes scope() const { return at<1>().as_bytes(); }
+  bool has_kernel_frames() const { return at<2>().valid(); }
+  bool kernel_frames() const { return at<2>().as_bool(); }
+  bool has_user_frames() const { return at<3>().valid(); }
+  int32_t user_frames() const { return at<3>().as_int32(); }
 };
 
-class AndroidLogPacket_LogEvent : public ::protozero::Message {
+class PerfEventConfig_CallstackSampling : public ::protozero::Message {
  public:
-  using Decoder = AndroidLogPacket_LogEvent_Decoder;
+  using Decoder = PerfEventConfig_CallstackSampling_Decoder;
   enum : int32_t {
-    kLogIdFieldNumber = 1,
-    kPidFieldNumber = 2,
-    kTidFieldNumber = 3,
-    kUidFieldNumber = 4,
-    kTimestampFieldNumber = 5,
-    kTagFieldNumber = 6,
-    kPrioFieldNumber = 7,
-    kMessageFieldNumber = 8,
-    kArgsFieldNumber = 9,
+    kScopeFieldNumber = 1,
+    kKernelFramesFieldNumber = 2,
+    kUserFramesFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.AndroidLogPacket.LogEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.PerfEventConfig.CallstackSampling"; }
 
-  using Arg = ::perfetto::protos::pbzero::AndroidLogPacket_LogEvent_Arg;
 
-  using FieldMetadata_LogId =
+  using FieldMetadata_Scope =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::AndroidLogId,
-      AndroidLogPacket_LogEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PerfEventConfig_Scope,
+      PerfEventConfig_CallstackSampling>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LogId kLogId() { return {}; }
-  void set_log_id(::perfetto::protos::pbzero::AndroidLogId value) {
-    static constexpr uint32_t field_id = FieldMetadata_LogId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_Scope kScope{};
+  template <typename T = PerfEventConfig_Scope> T* set_scope() {
+    return BeginNestedMessage<T>(1);
   }
 
-  using FieldMetadata_Pid =
+
+  using FieldMetadata_KernelFrames =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      AndroidLogPacket_LogEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      PerfEventConfig_CallstackSampling>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_KernelFrames kKernelFrames{};
+  void set_kernel_frames(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_KernelFrames::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Tid =
+  using FieldMetadata_UserFrames =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      AndroidLogPacket_LogEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      PerfEventConfig_UnwindMode,
+      PerfEventConfig_CallstackSampling>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Tid kTid() { return {}; }
-  void set_tid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId;
+  static constexpr FieldMetadata_UserFrames kUserFrames{};
+  void set_user_frames(PerfEventConfig_UnwindMode value) {
+    static constexpr uint32_t field_id = FieldMetadata_UserFrames::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Uid =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      AndroidLogPacket_LogEvent>;
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/protovm/protovm_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Uid kUid() { return {}; }
-  void set_uid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROTOVM_PROTOVM_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROTOVM_PROTOVM_CONFIG_PROTO_H_
 
-  using FieldMetadata_Timestamp =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      AndroidLogPacket_LogEvent>;
+#include <stddef.h>
+#include <stdint.h>
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timestamp kTimestamp() { return {}; }
-  void set_timestamp(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  using FieldMetadata_Tag =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      AndroidLogPacket_LogEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Tag kTag() { return {}; }
-  void set_tag(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Tag::kFieldId, data, size);
-  }
-  void set_tag(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Tag::kFieldId, chars.data, chars.size);
-  }
-  void set_tag(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Tag::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-  using FieldMetadata_Prio =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::AndroidLogPriority,
-      AndroidLogPacket_LogEvent>;
+class ProtoVmConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  ProtoVmConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProtoVmConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProtoVmConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_memory_limit_kb() const { return at<1>().valid(); }
+  uint32_t memory_limit_kb() const { return at<1>().as_uint32(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Prio kPrio() { return {}; }
-  void set_prio(::perfetto::protos::pbzero::AndroidLogPriority value) {
-    static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
+class ProtoVmConfig : public ::protozero::Message {
+ public:
+  using Decoder = ProtoVmConfig_Decoder;
+  enum : int32_t {
+    kMemoryLimitKbFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ProtoVmConfig"; }
 
-  using FieldMetadata_Message =
+
+  using FieldMetadata_MemoryLimitKb =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      AndroidLogPacket_LogEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ProtoVmConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Message kMessage() { return {}; }
-  void set_message(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Message::kFieldId, data, size);
-  }
-  void set_message(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Message::kFieldId, chars.data, chars.size);
-  }
-  void set_message(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Message::kFieldId;
+  static constexpr FieldMetadata_MemoryLimitKb kMemoryLimitKb{};
+  void set_memory_limit_kb(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MemoryLimitKb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Args =
-    ::protozero::proto_utils::FieldMetadata<
-      9,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AndroidLogPacket_LogEvent_Arg,
-      AndroidLogPacket_LogEvent>;
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/qnx/qnx_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Args kArgs() { return {}; }
-  template <typename T = AndroidLogPacket_LogEvent_Arg> T* add_args() {
-    return BeginNestedMessage<T>(9);
-  }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_QNX_QNX_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_QNX_QNX_CONFIG_PROTO_H_
 
-};
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-class AndroidLogPacket_LogEvent_Arg_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class QnxConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  AndroidLogPacket_LogEvent_Arg_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AndroidLogPacket_LogEvent_Arg_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AndroidLogPacket_LogEvent_Arg_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_int_value() const { return at<2>().valid(); }
-  int64_t int_value() const { return at<2>().as_int64(); }
-  bool has_float_value() const { return at<3>().valid(); }
-  float float_value() const { return at<3>().as_float(); }
-  bool has_string_value() const { return at<4>().valid(); }
-  ::protozero::ConstChars string_value() const { return at<4>().as_string(); }
+  QnxConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit QnxConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit QnxConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_qnx_kernel_buffers() const { return at<1>().valid(); }
+  uint32_t qnx_kernel_buffers() const { return at<1>().as_uint32(); }
+  bool has_qnx_kernel_kbuffers() const { return at<2>().valid(); }
+  uint32_t qnx_kernel_kbuffers() const { return at<2>().as_uint32(); }
+  bool has_qnx_kernel_wide_events() const { return at<3>().valid(); }
+  bool qnx_kernel_wide_events() const { return at<3>().as_bool(); }
+  bool has_qnx_cache_pages() const { return at<4>().valid(); }
+  uint32_t qnx_cache_pages() const { return at<4>().as_uint32(); }
+  bool has_qnx_cache_max_pages() const { return at<5>().valid(); }
+  int32_t qnx_cache_max_pages() const { return at<5>().as_int32(); }
+  bool has_qnx_trace_buffer_init_bytes() const { return at<6>().valid(); }
+  uint32_t qnx_trace_buffer_init_bytes() const { return at<6>().as_uint32(); }
 };
 
-class AndroidLogPacket_LogEvent_Arg : public ::protozero::Message {
+class QnxConfig : public ::protozero::Message {
  public:
-  using Decoder = AndroidLogPacket_LogEvent_Arg_Decoder;
+  using Decoder = QnxConfig_Decoder;
   enum : int32_t {
-    kNameFieldNumber = 1,
-    kIntValueFieldNumber = 2,
-    kFloatValueFieldNumber = 3,
-    kStringValueFieldNumber = 4,
+    kQnxKernelBuffersFieldNumber = 1,
+    kQnxKernelKbuffersFieldNumber = 2,
+    kQnxKernelWideEventsFieldNumber = 3,
+    kQnxCachePagesFieldNumber = 4,
+    kQnxCacheMaxPagesFieldNumber = 5,
+    kQnxTraceBufferInitBytesFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.AndroidLogPacket.LogEvent.Arg"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.QnxConfig"; }
 
 
-  using FieldMetadata_Name =
+  using FieldMetadata_QnxKernelBuffers =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      AndroidLogPacket_LogEvent_Arg>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      QnxConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_QnxKernelBuffers kQnxKernelBuffers{};
+  void set_qnx_kernel_buffers(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_QnxKernelBuffers::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IntValue =
+  using FieldMetadata_QnxKernelKbuffers =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      AndroidLogPacket_LogEvent_Arg>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      QnxConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IntValue kIntValue() { return {}; }
-  void set_int_value(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId;
+  static constexpr FieldMetadata_QnxKernelKbuffers kQnxKernelKbuffers{};
+  void set_qnx_kernel_kbuffers(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_QnxKernelKbuffers::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FloatValue =
+  using FieldMetadata_QnxKernelWideEvents =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kFloat,
-      float,
-      AndroidLogPacket_LogEvent_Arg>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      QnxConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FloatValue kFloatValue() { return {}; }
-  void set_float_value(float value) {
-    static constexpr uint32_t field_id = FieldMetadata_FloatValue::kFieldId;
+  static constexpr FieldMetadata_QnxKernelWideEvents kQnxKernelWideEvents{};
+  void set_qnx_kernel_wide_events(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_QnxKernelWideEvents::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_StringValue =
+  using FieldMetadata_QnxCachePages =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      AndroidLogPacket_LogEvent_Arg>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      QnxConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StringValue kStringValue() { return {}; }
-  void set_string_value(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_StringValue::kFieldId, data, size);
+  static constexpr FieldMetadata_QnxCachePages kQnxCachePages{};
+  void set_qnx_cache_pages(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_QnxCachePages::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
-  void set_string_value(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_StringValue::kFieldId, chars.data, chars.size);
+
+  using FieldMetadata_QnxCacheMaxPages =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      QnxConfig>;
+
+  static constexpr FieldMetadata_QnxCacheMaxPages kQnxCacheMaxPages{};
+  void set_qnx_cache_max_pages(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_QnxCacheMaxPages::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
   }
-  void set_string_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_StringValue::kFieldId;
+
+  using FieldMetadata_QnxTraceBufferInitBytes =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      QnxConfig>;
+
+  static constexpr FieldMetadata_QnxTraceBufferInitBytes kQnxTraceBufferInitBytes{};
+  void set_qnx_trace_buffer_init_bytes(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_QnxTraceBufferInitBytes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
@@ -46272,11 +52728,11 @@ class AndroidLogPacket_LogEvent_Arg : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/android/android_system_property.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/config/statsd/atom_ids.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_SYSTEM_PROPERTY_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_SYSTEM_PROPERTY_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_ATOM_IDS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_ATOM_IDS_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -46287,6048 +52743,5390 @@ class AndroidLogPacket_LogEvent_Arg : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-class AndroidSystemProperty_PropertyValue;
+enum AtomId : int32_t {
+  ATOM_UNSPECIFIED = 0,
+  ATOM_BLE_SCAN_STATE_CHANGED = 2,
+  ATOM_PROCESS_STATE_CHANGED = 3,
+  ATOM_BLE_SCAN_RESULT_RECEIVED = 4,
+  ATOM_SENSOR_STATE_CHANGED = 5,
+  ATOM_GPS_SCAN_STATE_CHANGED = 6,
+  ATOM_SYNC_STATE_CHANGED = 7,
+  ATOM_SCHEDULED_JOB_STATE_CHANGED = 8,
+  ATOM_SCREEN_BRIGHTNESS_CHANGED = 9,
+  ATOM_WAKELOCK_STATE_CHANGED = 10,
+  ATOM_LONG_PARTIAL_WAKELOCK_STATE_CHANGED = 11,
+  ATOM_MOBILE_RADIO_POWER_STATE_CHANGED = 12,
+  ATOM_WIFI_RADIO_POWER_STATE_CHANGED = 13,
+  ATOM_ACTIVITY_MANAGER_SLEEP_STATE_CHANGED = 14,
+  ATOM_MEMORY_FACTOR_STATE_CHANGED = 15,
+  ATOM_EXCESSIVE_CPU_USAGE_REPORTED = 16,
+  ATOM_CACHED_KILL_REPORTED = 17,
+  ATOM_PROCESS_MEMORY_STAT_REPORTED = 18,
+  ATOM_LAUNCHER_EVENT = 19,
+  ATOM_BATTERY_SAVER_MODE_STATE_CHANGED = 20,
+  ATOM_DEVICE_IDLE_MODE_STATE_CHANGED = 21,
+  ATOM_DEVICE_IDLING_MODE_STATE_CHANGED = 22,
+  ATOM_AUDIO_STATE_CHANGED = 23,
+  ATOM_MEDIA_CODEC_STATE_CHANGED = 24,
+  ATOM_CAMERA_STATE_CHANGED = 25,
+  ATOM_FLASHLIGHT_STATE_CHANGED = 26,
+  ATOM_UID_PROCESS_STATE_CHANGED = 27,
+  ATOM_PROCESS_LIFE_CYCLE_STATE_CHANGED = 28,
+  ATOM_SCREEN_STATE_CHANGED = 29,
+  ATOM_BATTERY_LEVEL_CHANGED = 30,
+  ATOM_CHARGING_STATE_CHANGED = 31,
+  ATOM_PLUGGED_STATE_CHANGED = 32,
+  ATOM_INTERACTIVE_STATE_CHANGED = 33,
+  ATOM_TOUCH_EVENT_REPORTED = 34,
+  ATOM_WAKEUP_ALARM_OCCURRED = 35,
+  ATOM_KERNEL_WAKEUP_REPORTED = 36,
+  ATOM_WIFI_LOCK_STATE_CHANGED = 37,
+  ATOM_WIFI_SIGNAL_STRENGTH_CHANGED = 38,
+  ATOM_WIFI_SCAN_STATE_CHANGED = 39,
+  ATOM_PHONE_SIGNAL_STRENGTH_CHANGED = 40,
+  ATOM_SETTING_CHANGED = 41,
+  ATOM_ACTIVITY_FOREGROUND_STATE_CHANGED = 42,
+  ATOM_ISOLATED_UID_CHANGED = 43,
+  ATOM_PACKET_WAKEUP_OCCURRED = 44,
+  ATOM_WALL_CLOCK_TIME_SHIFTED = 45,
+  ATOM_ANOMALY_DETECTED = 46,
+  ATOM_APP_BREADCRUMB_REPORTED = 47,
+  ATOM_APP_START_OCCURRED = 48,
+  ATOM_APP_START_CANCELED = 49,
+  ATOM_APP_START_FULLY_DRAWN = 50,
+  ATOM_LMK_KILL_OCCURRED = 51,
+  ATOM_PICTURE_IN_PICTURE_STATE_CHANGED = 52,
+  ATOM_WIFI_MULTICAST_LOCK_STATE_CHANGED = 53,
+  ATOM_APP_START_MEMORY_STATE_CAPTURED = 55,
+  ATOM_SHUTDOWN_SEQUENCE_REPORTED = 56,
+  ATOM_BOOT_SEQUENCE_REPORTED = 57,
+  ATOM_OVERLAY_STATE_CHANGED = 59,
+  ATOM_FOREGROUND_SERVICE_STATE_CHANGED = 60,
+  ATOM_CALL_STATE_CHANGED = 61,
+  ATOM_KEYGUARD_STATE_CHANGED = 62,
+  ATOM_KEYGUARD_BOUNCER_STATE_CHANGED = 63,
+  ATOM_KEYGUARD_BOUNCER_PASSWORD_ENTERED = 64,
+  ATOM_APP_DIED = 65,
+  ATOM_RESOURCE_CONFIGURATION_CHANGED = 66,
+  ATOM_BLUETOOTH_ENABLED_STATE_CHANGED = 67,
+  ATOM_BLUETOOTH_CONNECTION_STATE_CHANGED = 68,
+  ATOM_GPS_SIGNAL_QUALITY_CHANGED = 69,
+  ATOM_USB_CONNECTOR_STATE_CHANGED = 70,
+  ATOM_SPEAKER_IMPEDANCE_REPORTED = 71,
+  ATOM_HARDWARE_FAILED = 72,
+  ATOM_PHYSICAL_DROP_DETECTED = 73,
+  ATOM_CHARGE_CYCLES_REPORTED = 74,
+  ATOM_MOBILE_CONNECTION_STATE_CHANGED = 75,
+  ATOM_MOBILE_RADIO_TECHNOLOGY_CHANGED = 76,
+  ATOM_USB_DEVICE_ATTACHED = 77,
+  ATOM_APP_CRASH_OCCURRED = 78,
+  ATOM_ANR_OCCURRED = 79,
+  ATOM_WTF_OCCURRED = 80,
+  ATOM_LOW_MEM_REPORTED = 81,
+  ATOM_GENERIC_ATOM = 82,
+  ATOM_VIBRATOR_STATE_CHANGED = 84,
+  ATOM_DEFERRED_JOB_STATS_REPORTED = 85,
+  ATOM_THERMAL_THROTTLING = 86,
+  ATOM_BIOMETRIC_ACQUIRED = 87,
+  ATOM_BIOMETRIC_AUTHENTICATED = 88,
+  ATOM_BIOMETRIC_ERROR_OCCURRED = 89,
+  ATOM_UI_EVENT_REPORTED = 90,
+  ATOM_BATTERY_HEALTH_SNAPSHOT = 91,
+  ATOM_SLOW_IO = 92,
+  ATOM_BATTERY_CAUSED_SHUTDOWN = 93,
+  ATOM_PHONE_SERVICE_STATE_CHANGED = 94,
+  ATOM_PHONE_STATE_CHANGED = 95,
+  ATOM_USER_RESTRICTION_CHANGED = 96,
+  ATOM_SETTINGS_UI_CHANGED = 97,
+  ATOM_CONNECTIVITY_STATE_CHANGED = 98,
+  ATOM_SERVICE_STATE_CHANGED = 99,
+  ATOM_SERVICE_LAUNCH_REPORTED = 100,
+  ATOM_FLAG_FLIP_UPDATE_OCCURRED = 101,
+  ATOM_BINARY_PUSH_STATE_CHANGED = 102,
+  ATOM_DEVICE_POLICY_EVENT = 103,
+  ATOM_DOCS_UI_FILE_OP_CANCELED = 104,
+  ATOM_DOCS_UI_FILE_OP_COPY_MOVE_MODE_REPORTED = 105,
+  ATOM_DOCS_UI_FILE_OP_FAILURE = 106,
+  ATOM_DOCS_UI_PROVIDER_FILE_OP = 107,
+  ATOM_DOCS_UI_INVALID_SCOPED_ACCESS_REQUEST = 108,
+  ATOM_DOCS_UI_LAUNCH_REPORTED = 109,
+  ATOM_DOCS_UI_ROOT_VISITED = 110,
+  ATOM_DOCS_UI_STARTUP_MS = 111,
+  ATOM_DOCS_UI_USER_ACTION_REPORTED = 112,
+  ATOM_WIFI_ENABLED_STATE_CHANGED = 113,
+  ATOM_WIFI_RUNNING_STATE_CHANGED = 114,
+  ATOM_APP_COMPACTED = 115,
+  ATOM_NETWORK_DNS_EVENT_REPORTED = 116,
+  ATOM_DOCS_UI_PICKER_LAUNCHED_FROM_REPORTED = 117,
+  ATOM_DOCS_UI_PICK_RESULT_REPORTED = 118,
+  ATOM_DOCS_UI_SEARCH_MODE_REPORTED = 119,
+  ATOM_DOCS_UI_SEARCH_TYPE_REPORTED = 120,
+  ATOM_DATA_STALL_EVENT = 121,
+  ATOM_RESCUE_PARTY_RESET_REPORTED = 122,
+  ATOM_SIGNED_CONFIG_REPORTED = 123,
+  ATOM_GNSS_NI_EVENT_REPORTED = 124,
+  ATOM_BLUETOOTH_LINK_LAYER_CONNECTION_EVENT = 125,
+  ATOM_BLUETOOTH_ACL_CONNECTION_STATE_CHANGED = 126,
+  ATOM_BLUETOOTH_SCO_CONNECTION_STATE_CHANGED = 127,
+  ATOM_APP_DOWNGRADED = 128,
+  ATOM_APP_OPTIMIZED_AFTER_DOWNGRADED = 129,
+  ATOM_LOW_STORAGE_STATE_CHANGED = 130,
+  ATOM_GNSS_NFW_NOTIFICATION_REPORTED = 131,
+  ATOM_GNSS_CONFIGURATION_REPORTED = 132,
+  ATOM_USB_PORT_OVERHEAT_EVENT_REPORTED = 133,
+  ATOM_NFC_ERROR_OCCURRED = 134,
+  ATOM_NFC_STATE_CHANGED = 135,
+  ATOM_NFC_BEAM_OCCURRED = 136,
+  ATOM_NFC_CARDEMULATION_OCCURRED = 137,
+  ATOM_NFC_TAG_OCCURRED = 138,
+  ATOM_NFC_HCE_TRANSACTION_OCCURRED = 139,
+  ATOM_SE_STATE_CHANGED = 140,
+  ATOM_SE_OMAPI_REPORTED = 141,
+  ATOM_BROADCAST_DISPATCH_LATENCY_REPORTED = 142,
+  ATOM_ATTENTION_MANAGER_SERVICE_RESULT_REPORTED = 143,
+  ATOM_ADB_CONNECTION_CHANGED = 144,
+  ATOM_SPEECH_DSP_STAT_REPORTED = 145,
+  ATOM_USB_CONTAMINANT_REPORTED = 146,
+  ATOM_WATCHDOG_ROLLBACK_OCCURRED = 147,
+  ATOM_BIOMETRIC_SYSTEM_HEALTH_ISSUE_DETECTED = 148,
+  ATOM_BUBBLE_UI_CHANGED = 149,
+  ATOM_SCHEDULED_JOB_CONSTRAINT_CHANGED = 150,
+  ATOM_BLUETOOTH_ACTIVE_DEVICE_CHANGED = 151,
+  ATOM_BLUETOOTH_A2DP_PLAYBACK_STATE_CHANGED = 152,
+  ATOM_BLUETOOTH_A2DP_CODEC_CONFIG_CHANGED = 153,
+  ATOM_BLUETOOTH_A2DP_CODEC_CAPABILITY_CHANGED = 154,
+  ATOM_BLUETOOTH_A2DP_AUDIO_UNDERRUN_REPORTED = 155,
+  ATOM_BLUETOOTH_A2DP_AUDIO_OVERRUN_REPORTED = 156,
+  ATOM_BLUETOOTH_DEVICE_RSSI_REPORTED = 157,
+  ATOM_BLUETOOTH_DEVICE_FAILED_CONTACT_COUNTER_REPORTED = 158,
+  ATOM_BLUETOOTH_DEVICE_TX_POWER_LEVEL_REPORTED = 159,
+  ATOM_BLUETOOTH_HCI_TIMEOUT_REPORTED = 160,
+  ATOM_BLUETOOTH_QUALITY_REPORT_REPORTED = 161,
+  ATOM_BLUETOOTH_DEVICE_INFO_REPORTED = 162,
+  ATOM_BLUETOOTH_REMOTE_VERSION_INFO_REPORTED = 163,
+  ATOM_BLUETOOTH_SDP_ATTRIBUTE_REPORTED = 164,
+  ATOM_BLUETOOTH_BOND_STATE_CHANGED = 165,
+  ATOM_BLUETOOTH_CLASSIC_PAIRING_EVENT_REPORTED = 166,
+  ATOM_BLUETOOTH_SMP_PAIRING_EVENT_REPORTED = 167,
+  ATOM_SCREEN_TIMEOUT_EXTENSION_REPORTED = 168,
+  ATOM_PROCESS_START_TIME = 169,
+  ATOM_PERMISSION_GRANT_REQUEST_RESULT_REPORTED = 170,
+  ATOM_BLUETOOTH_SOCKET_CONNECTION_STATE_CHANGED = 171,
+  ATOM_DEVICE_IDENTIFIER_ACCESS_DENIED = 172,
+  ATOM_BUBBLE_DEVELOPER_ERROR_REPORTED = 173,
+  ATOM_ASSIST_GESTURE_STAGE_REPORTED = 174,
+  ATOM_ASSIST_GESTURE_FEEDBACK_REPORTED = 175,
+  ATOM_ASSIST_GESTURE_PROGRESS_REPORTED = 176,
+  ATOM_TOUCH_GESTURE_CLASSIFIED = 177,
+  ATOM_HIDDEN_API_USED = 178,
+  ATOM_STYLE_UI_CHANGED = 179,
+  ATOM_PRIVACY_INDICATORS_INTERACTED = 180,
+  ATOM_APP_INSTALL_ON_EXTERNAL_STORAGE_REPORTED = 181,
+  ATOM_NETWORK_STACK_REPORTED = 182,
+  ATOM_APP_MOVED_STORAGE_REPORTED = 183,
+  ATOM_BIOMETRIC_ENROLLED = 184,
+  ATOM_SYSTEM_SERVER_WATCHDOG_OCCURRED = 185,
+  ATOM_TOMB_STONE_OCCURRED = 186,
+  ATOM_BLUETOOTH_CLASS_OF_DEVICE_REPORTED = 187,
+  ATOM_INTELLIGENCE_EVENT_REPORTED = 188,
+  ATOM_THERMAL_THROTTLING_SEVERITY_STATE_CHANGED = 189,
+  ATOM_ROLE_REQUEST_RESULT_REPORTED = 190,
+  ATOM_MEDIAMETRICS_AUDIOPOLICY_REPORTED = 191,
+  ATOM_MEDIAMETRICS_AUDIORECORD_REPORTED = 192,
+  ATOM_MEDIAMETRICS_AUDIOTHREAD_REPORTED = 193,
+  ATOM_MEDIAMETRICS_AUDIOTRACK_REPORTED = 194,
+  ATOM_MEDIAMETRICS_CODEC_REPORTED = 195,
+  ATOM_MEDIAMETRICS_DRM_WIDEVINE_REPORTED = 196,
+  ATOM_MEDIAMETRICS_EXTRACTOR_REPORTED = 197,
+  ATOM_MEDIAMETRICS_MEDIADRM_REPORTED = 198,
+  ATOM_MEDIAMETRICS_NUPLAYER_REPORTED = 199,
+  ATOM_MEDIAMETRICS_RECORDER_REPORTED = 200,
+  ATOM_MEDIAMETRICS_DRMMANAGER_REPORTED = 201,
+  ATOM_CAR_POWER_STATE_CHANGED = 203,
+  ATOM_GARAGE_MODE_INFO = 204,
+  ATOM_TEST_ATOM_REPORTED = 205,
+  ATOM_CONTENT_CAPTURE_CALLER_MISMATCH_REPORTED = 206,
+  ATOM_CONTENT_CAPTURE_SERVICE_EVENTS = 207,
+  ATOM_CONTENT_CAPTURE_SESSION_EVENTS = 208,
+  ATOM_CONTENT_CAPTURE_FLUSHED = 209,
+  ATOM_LOCATION_MANAGER_API_USAGE_REPORTED = 210,
+  ATOM_REVIEW_PERMISSIONS_FRAGMENT_RESULT_REPORTED = 211,
+  ATOM_RUNTIME_PERMISSIONS_UPGRADE_RESULT = 212,
+  ATOM_GRANT_PERMISSIONS_ACTIVITY_BUTTON_ACTIONS = 213,
+  ATOM_LOCATION_ACCESS_CHECK_NOTIFICATION_ACTION = 214,
+  ATOM_APP_PERMISSION_FRAGMENT_ACTION_REPORTED = 215,
+  ATOM_APP_PERMISSION_FRAGMENT_VIEWED = 216,
+  ATOM_APP_PERMISSIONS_FRAGMENT_VIEWED = 217,
+  ATOM_PERMISSION_APPS_FRAGMENT_VIEWED = 218,
+  ATOM_TEXT_SELECTION_EVENT = 219,
+  ATOM_TEXT_LINKIFY_EVENT = 220,
+  ATOM_CONVERSATION_ACTIONS_EVENT = 221,
+  ATOM_LANGUAGE_DETECTION_EVENT = 222,
+  ATOM_EXCLUSION_RECT_STATE_CHANGED = 223,
+  ATOM_BACK_GESTURE_REPORTED_REPORTED = 224,
+  ATOM_UPDATE_ENGINE_UPDATE_ATTEMPT_REPORTED = 225,
+  ATOM_UPDATE_ENGINE_SUCCESSFUL_UPDATE_REPORTED = 226,
+  ATOM_CAMERA_ACTION_EVENT = 227,
+  ATOM_APP_COMPATIBILITY_CHANGE_REPORTED = 228,
+  ATOM_PERFETTO_UPLOADED = 229,
+  ATOM_VMS_CLIENT_CONNECTION_STATE_CHANGED = 230,
+  ATOM_MEDIA_PROVIDER_SCAN_OCCURRED = 233,
+  ATOM_MEDIA_CONTENT_DELETED = 234,
+  ATOM_MEDIA_PROVIDER_PERMISSION_REQUESTED = 235,
+  ATOM_MEDIA_PROVIDER_SCHEMA_CHANGED = 236,
+  ATOM_MEDIA_PROVIDER_IDLE_MAINTENANCE_FINISHED = 237,
+  ATOM_REBOOT_ESCROW_RECOVERY_REPORTED = 238,
+  ATOM_BOOT_TIME_EVENT_DURATION_REPORTED = 239,
+  ATOM_BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED = 240,
+  ATOM_BOOT_TIME_EVENT_UTC_TIME_REPORTED = 241,
+  ATOM_BOOT_TIME_EVENT_ERROR_CODE_REPORTED = 242,
+  ATOM_USERSPACE_REBOOT_REPORTED = 243,
+  ATOM_NOTIFICATION_REPORTED = 244,
+  ATOM_NOTIFICATION_PANEL_REPORTED = 245,
+  ATOM_NOTIFICATION_CHANNEL_MODIFIED = 246,
+  ATOM_INTEGRITY_CHECK_RESULT_REPORTED = 247,
+  ATOM_INTEGRITY_RULES_PUSHED = 248,
+  ATOM_CB_MESSAGE_REPORTED = 249,
+  ATOM_CB_MESSAGE_ERROR = 250,
+  ATOM_WIFI_HEALTH_STAT_REPORTED = 251,
+  ATOM_WIFI_FAILURE_STAT_REPORTED = 252,
+  ATOM_WIFI_CONNECTION_RESULT_REPORTED = 253,
+  ATOM_APP_FREEZE_CHANGED = 254,
+  ATOM_SNAPSHOT_MERGE_REPORTED = 255,
+  ATOM_FOREGROUND_SERVICE_APP_OP_SESSION_ENDED = 256,
+  ATOM_DISPLAY_JANK_REPORTED = 257,
+  ATOM_APP_STANDBY_BUCKET_CHANGED = 258,
+  ATOM_SHARESHEET_STARTED = 259,
+  ATOM_RANKING_SELECTED = 260,
+  ATOM_TVSETTINGS_UI_INTERACTED = 261,
+  ATOM_LAUNCHER_SNAPSHOT = 262,
+  ATOM_PACKAGE_INSTALLER_V2_REPORTED = 263,
+  ATOM_USER_LIFECYCLE_JOURNEY_REPORTED = 264,
+  ATOM_USER_LIFECYCLE_EVENT_OCCURRED = 265,
+  ATOM_ACCESSIBILITY_SHORTCUT_REPORTED = 266,
+  ATOM_ACCESSIBILITY_SERVICE_REPORTED = 267,
+  ATOM_DOCS_UI_DRAG_AND_DROP_REPORTED = 268,
+  ATOM_APP_USAGE_EVENT_OCCURRED = 269,
+  ATOM_AUTO_REVOKE_NOTIFICATION_CLICKED = 270,
+  ATOM_AUTO_REVOKE_FRAGMENT_APP_VIEWED = 271,
+  ATOM_AUTO_REVOKED_APP_INTERACTION = 272,
+  ATOM_APP_PERMISSION_GROUPS_FRAGMENT_AUTO_REVOKE_ACTION = 273,
+  ATOM_EVS_USAGE_STATS_REPORTED = 274,
+  ATOM_AUDIO_POWER_USAGE_DATA_REPORTED = 275,
+  ATOM_TV_TUNER_STATE_CHANGED = 276,
+  ATOM_MEDIAOUTPUT_OP_SWITCH_REPORTED = 277,
+  ATOM_CB_MESSAGE_FILTERED = 278,
+  ATOM_TV_TUNER_DVR_STATUS = 279,
+  ATOM_TV_CAS_SESSION_OPEN_STATUS = 280,
+  ATOM_ASSISTANT_INVOCATION_REPORTED = 281,
+  ATOM_DISPLAY_WAKE_REPORTED = 282,
+  ATOM_CAR_USER_HAL_MODIFY_USER_REQUEST_REPORTED = 283,
+  ATOM_CAR_USER_HAL_MODIFY_USER_RESPONSE_REPORTED = 284,
+  ATOM_CAR_USER_HAL_POST_SWITCH_RESPONSE_REPORTED = 285,
+  ATOM_CAR_USER_HAL_INITIAL_USER_INFO_REQUEST_REPORTED = 286,
+  ATOM_CAR_USER_HAL_INITIAL_USER_INFO_RESPONSE_REPORTED = 287,
+  ATOM_CAR_USER_HAL_USER_ASSOCIATION_REQUEST_REPORTED = 288,
+  ATOM_CAR_USER_HAL_SET_USER_ASSOCIATION_RESPONSE_REPORTED = 289,
+  ATOM_NETWORK_IP_PROVISIONING_REPORTED = 290,
+  ATOM_NETWORK_DHCP_RENEW_REPORTED = 291,
+  ATOM_NETWORK_VALIDATION_REPORTED = 292,
+  ATOM_NETWORK_STACK_QUIRK_REPORTED = 293,
+  ATOM_MEDIAMETRICS_AUDIORECORDDEVICEUSAGE_REPORTED = 294,
+  ATOM_MEDIAMETRICS_AUDIOTHREADDEVICEUSAGE_REPORTED = 295,
+  ATOM_MEDIAMETRICS_AUDIOTRACKDEVICEUSAGE_REPORTED = 296,
+  ATOM_MEDIAMETRICS_AUDIODEVICECONNECTION_REPORTED = 297,
+  ATOM_BLOB_COMMITTED = 298,
+  ATOM_BLOB_LEASED = 299,
+  ATOM_BLOB_OPENED = 300,
+  ATOM_CONTACTS_PROVIDER_STATUS_REPORTED = 301,
+  ATOM_KEYSTORE_KEY_EVENT_REPORTED = 302,
+  ATOM_NETWORK_TETHERING_REPORTED = 303,
+  ATOM_IME_TOUCH_REPORTED = 304,
+  ATOM_UI_INTERACTION_FRAME_INFO_REPORTED = 305,
+  ATOM_UI_ACTION_LATENCY_REPORTED = 306,
+  ATOM_WIFI_DISCONNECT_REPORTED = 307,
+  ATOM_WIFI_CONNECTION_STATE_CHANGED = 308,
+  ATOM_HDMI_CEC_ACTIVE_SOURCE_CHANGED = 309,
+  ATOM_HDMI_CEC_MESSAGE_REPORTED = 310,
+  ATOM_AIRPLANE_MODE = 311,
+  ATOM_MODEM_RESTART = 312,
+  ATOM_CARRIER_ID_MISMATCH_REPORTED = 313,
+  ATOM_CARRIER_ID_TABLE_UPDATED = 314,
+  ATOM_DATA_STALL_RECOVERY_REPORTED = 315,
+  ATOM_MEDIAMETRICS_MEDIAPARSER_REPORTED = 316,
+  ATOM_TLS_HANDSHAKE_REPORTED = 317,
+  ATOM_TEXT_CLASSIFIER_API_USAGE_REPORTED = 318,
+  ATOM_CAR_WATCHDOG_KILL_STATS_REPORTED = 319,
+  ATOM_MEDIAMETRICS_PLAYBACK_REPORTED = 320,
+  ATOM_MEDIA_NETWORK_INFO_CHANGED = 321,
+  ATOM_MEDIA_PLAYBACK_STATE_CHANGED = 322,
+  ATOM_MEDIA_PLAYBACK_ERROR_REPORTED = 323,
+  ATOM_MEDIA_PLAYBACK_TRACK_CHANGED = 324,
+  ATOM_WIFI_SCAN_REPORTED = 325,
+  ATOM_WIFI_PNO_SCAN_REPORTED = 326,
+  ATOM_TIF_TUNE_CHANGED = 327,
+  ATOM_AUTO_ROTATE_REPORTED = 328,
+  ATOM_PERFETTO_TRIGGER = 329,
+  ATOM_TRANSCODING_DATA = 330,
+  ATOM_IMS_SERVICE_ENTITLEMENT_UPDATED = 331,
+  ATOM_DEVICE_ROTATED = 333,
+  ATOM_SIM_SPECIFIC_SETTINGS_RESTORED = 334,
+  ATOM_TEXT_CLASSIFIER_DOWNLOAD_REPORTED = 335,
+  ATOM_PIN_STORAGE_EVENT = 336,
+  ATOM_FACE_DOWN_REPORTED = 337,
+  ATOM_BLUETOOTH_HAL_CRASH_REASON_REPORTED = 338,
+  ATOM_REBOOT_ESCROW_PREPARATION_REPORTED = 339,
+  ATOM_REBOOT_ESCROW_LSKF_CAPTURE_REPORTED = 340,
+  ATOM_REBOOT_ESCROW_REBOOT_REPORTED = 341,
+  ATOM_BINDER_LATENCY_REPORTED = 342,
+  ATOM_MEDIAMETRICS_AAUDIOSTREAM_REPORTED = 343,
+  ATOM_MEDIA_TRANSCODING_SESSION_ENDED = 344,
+  ATOM_MAGNIFICATION_USAGE_REPORTED = 345,
+  ATOM_MAGNIFICATION_MODE_WITH_IME_ON_REPORTED = 346,
+  ATOM_APP_SEARCH_CALL_STATS_REPORTED = 347,
+  ATOM_APP_SEARCH_PUT_DOCUMENT_STATS_REPORTED = 348,
+  ATOM_DEVICE_CONTROL_CHANGED = 349,
+  ATOM_DEVICE_STATE_CHANGED = 350,
+  ATOM_INPUTDEVICE_REGISTERED = 351,
+  ATOM_SMARTSPACE_CARD_REPORTED = 352,
+  ATOM_AUTH_PROMPT_AUTHENTICATE_INVOKED = 353,
+  ATOM_AUTH_MANAGER_CAN_AUTHENTICATE_INVOKED = 354,
+  ATOM_AUTH_ENROLL_ACTION_INVOKED = 355,
+  ATOM_AUTH_DEPRECATED_API_USED = 356,
+  ATOM_UNATTENDED_REBOOT_OCCURRED = 357,
+  ATOM_LONG_REBOOT_BLOCKING_REPORTED = 358,
+  ATOM_LOCATION_TIME_ZONE_PROVIDER_STATE_CHANGED = 359,
+  ATOM_FDTRACK_EVENT_OCCURRED = 364,
+  ATOM_TIMEOUT_AUTO_EXTENDED_REPORTED = 365,
+  ATOM_ALARM_BATCH_DELIVERED = 367,
+  ATOM_ALARM_SCHEDULED = 368,
+  ATOM_CAR_WATCHDOG_IO_OVERUSE_STATS_REPORTED = 369,
+  ATOM_USER_LEVEL_HIBERNATION_STATE_CHANGED = 370,
+  ATOM_APP_SEARCH_INITIALIZE_STATS_REPORTED = 371,
+  ATOM_APP_SEARCH_QUERY_STATS_REPORTED = 372,
+  ATOM_APP_PROCESS_DIED = 373,
+  ATOM_NETWORK_IP_REACHABILITY_MONITOR_REPORTED = 374,
+  ATOM_SLOW_INPUT_EVENT_REPORTED = 375,
+  ATOM_ANR_OCCURRED_PROCESSING_STARTED = 376,
+  ATOM_APP_SEARCH_REMOVE_STATS_REPORTED = 377,
+  ATOM_MEDIA_CODEC_REPORTED = 378,
+  ATOM_PERMISSION_USAGE_FRAGMENT_INTERACTION = 379,
+  ATOM_PERMISSION_DETAILS_INTERACTION = 380,
+  ATOM_PRIVACY_SENSOR_TOGGLE_INTERACTION = 381,
+  ATOM_PRIVACY_TOGGLE_DIALOG_INTERACTION = 382,
+  ATOM_APP_SEARCH_OPTIMIZE_STATS_REPORTED = 383,
+  ATOM_NON_A11Y_TOOL_SERVICE_WARNING_REPORT = 384,
+  ATOM_APP_COMPAT_STATE_CHANGED = 386,
+  ATOM_SIZE_COMPAT_RESTART_BUTTON_EVENT_REPORTED = 387,
+  ATOM_SPLITSCREEN_UI_CHANGED = 388,
+  ATOM_NETWORK_DNS_HANDSHAKE_REPORTED = 389,
+  ATOM_BLUETOOTH_CODE_PATH_COUNTER = 390,
+  ATOM_BLUETOOTH_LE_BATCH_SCAN_REPORT_DELAY = 392,
+  ATOM_ACCESSIBILITY_FLOATING_MENU_UI_CHANGED = 393,
+  ATOM_NEURALNETWORKS_COMPILATION_COMPLETED = 394,
+  ATOM_NEURALNETWORKS_EXECUTION_COMPLETED = 395,
+  ATOM_NEURALNETWORKS_COMPILATION_FAILED = 396,
+  ATOM_NEURALNETWORKS_EXECUTION_FAILED = 397,
+  ATOM_CONTEXT_HUB_BOOTED = 398,
+  ATOM_CONTEXT_HUB_RESTARTED = 399,
+  ATOM_CONTEXT_HUB_LOADED_NANOAPP_SNAPSHOT_REPORTED = 400,
+  ATOM_CHRE_CODE_DOWNLOAD_TRANSACTED = 401,
+  ATOM_UWB_SESSION_INITED = 402,
+  ATOM_UWB_SESSION_CLOSED = 403,
+  ATOM_UWB_FIRST_RANGING_RECEIVED = 404,
+  ATOM_UWB_RANGING_MEASUREMENT_RECEIVED = 405,
+  ATOM_TEXT_CLASSIFIER_DOWNLOAD_WORK_SCHEDULED = 406,
+  ATOM_TEXT_CLASSIFIER_DOWNLOAD_WORK_COMPLETED = 407,
+  ATOM_CLIPBOARD_CLEARED = 408,
+  ATOM_VM_CREATION_REQUESTED = 409,
+  ATOM_NEARBY_DEVICE_SCAN_STATE_CHANGED = 410,
+  ATOM_APPLICATION_LOCALES_CHANGED = 412,
+  ATOM_MEDIAMETRICS_AUDIOTRACKSTATUS_REPORTED = 413,
+  ATOM_FOLD_STATE_DURATION_REPORTED = 414,
+  ATOM_LOCATION_TIME_ZONE_PROVIDER_CONTROLLER_STATE_CHANGED = 415,
+  ATOM_DISPLAY_HBM_STATE_CHANGED = 416,
+  ATOM_DISPLAY_HBM_BRIGHTNESS_CHANGED = 417,
+  ATOM_PERSISTENT_URI_PERMISSIONS_FLUSHED = 418,
+  ATOM_EARLY_BOOT_COMP_OS_ARTIFACTS_CHECK_REPORTED = 419,
+  ATOM_VBMETA_DIGEST_REPORTED = 420,
+  ATOM_APEX_INFO_GATHERED = 421,
+  ATOM_PVM_INFO_GATHERED = 422,
+  ATOM_WEAR_SETTINGS_UI_INTERACTED = 423,
+  ATOM_TRACING_SERVICE_REPORT_EVENT = 424,
+  ATOM_MEDIAMETRICS_AUDIORECORDSTATUS_REPORTED = 425,
+  ATOM_LAUNCHER_LATENCY = 426,
+  ATOM_DROPBOX_ENTRY_DROPPED = 427,
+  ATOM_WIFI_P2P_CONNECTION_REPORTED = 428,
+  ATOM_GAME_STATE_CHANGED = 429,
+  ATOM_HOTWORD_DETECTOR_CREATE_REQUESTED = 430,
+  ATOM_HOTWORD_DETECTION_SERVICE_INIT_RESULT_REPORTED = 431,
+  ATOM_HOTWORD_DETECTION_SERVICE_RESTARTED = 432,
+  ATOM_HOTWORD_DETECTOR_KEYPHRASE_TRIGGERED = 433,
+  ATOM_HOTWORD_DETECTOR_EVENTS = 434,
+  ATOM_BOOT_COMPLETED_BROADCAST_COMPLETION_LATENCY_REPORTED = 437,
+  ATOM_CONTACTS_INDEXER_UPDATE_STATS_REPORTED = 440,
+  ATOM_APP_BACKGROUND_RESTRICTIONS_INFO = 441,
+  ATOM_MMS_SMS_PROVIDER_GET_THREAD_ID_FAILED = 442,
+  ATOM_MMS_SMS_DATABASE_HELPER_ON_UPGRADE_FAILED = 443,
+  ATOM_PERMISSION_REMINDER_NOTIFICATION_INTERACTED = 444,
+  ATOM_RECENT_PERMISSION_DECISIONS_INTERACTED = 445,
+  ATOM_GNSS_PSDS_DOWNLOAD_REPORTED = 446,
+  ATOM_LE_AUDIO_CONNECTION_SESSION_REPORTED = 447,
+  ATOM_LE_AUDIO_BROADCAST_SESSION_REPORTED = 448,
+  ATOM_DREAM_UI_EVENT_REPORTED = 449,
+  ATOM_TASK_MANAGER_EVENT_REPORTED = 450,
+  ATOM_CDM_ASSOCIATION_ACTION = 451,
+  ATOM_MAGNIFICATION_TRIPLE_TAP_AND_HOLD_ACTIVATED_SESSION_REPORTED = 452,
+  ATOM_MAGNIFICATION_FOLLOW_TYPING_FOCUS_ACTIVATED_SESSION_REPORTED = 453,
+  ATOM_ACCESSIBILITY_TEXT_READING_OPTIONS_CHANGED = 454,
+  ATOM_WIFI_SETUP_FAILURE_CRASH_REPORTED = 455,
+  ATOM_UWB_DEVICE_ERROR_REPORTED = 456,
+  ATOM_ISOLATED_COMPILATION_SCHEDULED = 457,
+  ATOM_ISOLATED_COMPILATION_ENDED = 458,
+  ATOM_ONS_OPPORTUNISTIC_ESIM_PROVISIONING_COMPLETE = 459,
+  ATOM_SYSTEM_SERVER_PRE_WATCHDOG_OCCURRED = 460,
+  ATOM_TELEPHONY_ANOMALY_DETECTED = 461,
+  ATOM_LETTERBOX_POSITION_CHANGED = 462,
+  ATOM_REMOTE_KEY_PROVISIONING_ATTEMPT = 463,
+  ATOM_REMOTE_KEY_PROVISIONING_NETWORK_INFO = 464,
+  ATOM_REMOTE_KEY_PROVISIONING_TIMING = 465,
+  ATOM_MEDIAOUTPUT_OP_INTERACTION_REPORT = 466,
+  ATOM_SYNC_EXEMPTION_OCCURRED = 468,
+  ATOM_AUTOFILL_PRESENTATION_EVENT_REPORTED = 469,
+  ATOM_DOCK_STATE_CHANGED = 470,
+  ATOM_SAFETY_SOURCE_STATE_COLLECTED = 471,
+  ATOM_SAFETY_CENTER_SYSTEM_EVENT_REPORTED = 472,
+  ATOM_SAFETY_CENTER_INTERACTION_REPORTED = 473,
+  ATOM_SETTINGS_PROVIDER_SETTING_CHANGED = 474,
+  ATOM_BROADCAST_DELIVERY_EVENT_REPORTED = 475,
+  ATOM_SERVICE_REQUEST_EVENT_REPORTED = 476,
+  ATOM_PROVIDER_ACQUISITION_EVENT_REPORTED = 477,
+  ATOM_BLUETOOTH_DEVICE_NAME_REPORTED = 478,
+  ATOM_CB_CONFIG_UPDATED = 479,
+  ATOM_CB_MODULE_ERROR_REPORTED = 480,
+  ATOM_CB_SERVICE_FEATURE_CHANGED = 481,
+  ATOM_CB_RECEIVER_FEATURE_CHANGED = 482,
+  ATOM_PRIVACY_SIGNAL_NOTIFICATION_INTERACTION = 484,
+  ATOM_PRIVACY_SIGNAL_ISSUE_CARD_INTERACTION = 485,
+  ATOM_PRIVACY_SIGNALS_JOB_FAILURE = 486,
+  ATOM_VIBRATION_REPORTED = 487,
+  ATOM_UWB_RANGING_START = 489,
+  ATOM_APP_COMPACTED_V2 = 491,
+  ATOM_DISPLAY_BRIGHTNESS_CHANGED = 494,
+  ATOM_ACTIVITY_ACTION_BLOCKED = 495,
+  ATOM_NETWORK_DNS_SERVER_SUPPORT_REPORTED = 504,
+  ATOM_VM_BOOTED = 505,
+  ATOM_VM_EXITED = 506,
+  ATOM_AMBIENT_BRIGHTNESS_STATS_REPORTED = 507,
+  ATOM_MEDIAMETRICS_SPATIALIZERCAPABILITIES_REPORTED = 508,
+  ATOM_MEDIAMETRICS_SPATIALIZERDEVICEENABLED_REPORTED = 509,
+  ATOM_MEDIAMETRICS_HEADTRACKERDEVICEENABLED_REPORTED = 510,
+  ATOM_MEDIAMETRICS_HEADTRACKERDEVICESUPPORTED_REPORTED = 511,
+  ATOM_HEARING_AID_INFO_REPORTED = 513,
+  ATOM_DEVICE_WIDE_JOB_CONSTRAINT_CHANGED = 514,
+  ATOM_AMBIENT_MODE_CHANGED = 515,
+  ATOM_ANR_LATENCY_REPORTED = 516,
+  ATOM_RESOURCE_API_INFO = 517,
+  ATOM_SYSTEM_DEFAULT_NETWORK_CHANGED = 518,
+  ATOM_IWLAN_SETUP_DATA_CALL_RESULT_REPORTED = 519,
+  ATOM_IWLAN_PDN_DISCONNECTED_REASON_REPORTED = 520,
+  ATOM_AIRPLANE_MODE_SESSION_REPORTED = 521,
+  ATOM_VM_CPU_STATUS_REPORTED = 522,
+  ATOM_VM_MEM_STATUS_REPORTED = 523,
+  ATOM_PACKAGE_INSTALLATION_SESSION_REPORTED = 524,
+  ATOM_DEFAULT_NETWORK_REMATCH_INFO = 525,
+  ATOM_NETWORK_SELECTION_PERFORMANCE = 526,
+  ATOM_NETWORK_NSD_REPORTED = 527,
+  ATOM_BLUETOOTH_DISCONNECTION_REASON_REPORTED = 529,
+  ATOM_BLUETOOTH_LOCAL_VERSIONS_REPORTED = 530,
+  ATOM_BLUETOOTH_REMOTE_SUPPORTED_FEATURES_REPORTED = 531,
+  ATOM_BLUETOOTH_LOCAL_SUPPORTED_FEATURES_REPORTED = 532,
+  ATOM_BLUETOOTH_GATT_APP_INFO = 533,
+  ATOM_BRIGHTNESS_CONFIGURATION_UPDATED = 534,
+  ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_LAUNCHED = 538,
+  ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FINISHED = 539,
+  ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_CONNECTION_REPORTED = 540,
+  ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_DEVICE_SCAN_TRIGGERED = 541,
+  ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FIRST_DEVICE_SCAN_LATENCY = 542,
+  ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_CONNECT_DEVICE_LATENCY = 543,
+  ATOM_PACKAGE_MANAGER_SNAPSHOT_REPORTED = 544,
+  ATOM_PACKAGE_MANAGER_APPS_FILTER_CACHE_BUILD_REPORTED = 545,
+  ATOM_PACKAGE_MANAGER_APPS_FILTER_CACHE_UPDATE_REPORTED = 546,
+  ATOM_LAUNCHER_IMPRESSION_EVENT = 547,
+  ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_ALL_DEVICES_SCAN_LATENCY = 549,
+  ATOM_WS_WATCH_FACE_EDITED = 551,
+  ATOM_WS_WATCH_FACE_FAVORITE_ACTION_REPORTED = 552,
+  ATOM_WS_WATCH_FACE_SET_ACTION_REPORTED = 553,
+  ATOM_PACKAGE_UNINSTALLATION_REPORTED = 554,
+  ATOM_GAME_MODE_CHANGED = 555,
+  ATOM_GAME_MODE_CONFIGURATION_CHANGED = 556,
+  ATOM_BEDTIME_MODE_STATE_CHANGED = 557,
+  ATOM_NETWORK_SLICE_SESSION_ENDED = 558,
+  ATOM_NETWORK_SLICE_DAILY_DATA_USAGE_REPORTED = 559,
+  ATOM_NFC_TAG_TYPE_OCCURRED = 560,
+  ATOM_NFC_AID_CONFLICT_OCCURRED = 561,
+  ATOM_NFC_READER_CONFLICT_OCCURRED = 562,
+  ATOM_WS_TILE_LIST_CHANGED = 563,
+  ATOM_GET_TYPE_ACCESSED_WITHOUT_PERMISSION = 564,
+  ATOM_MOBILE_BUNDLED_APP_INFO_GATHERED = 566,
+  ATOM_WS_WATCH_FACE_COMPLICATION_SET_CHANGED = 567,
+  ATOM_MEDIA_DRM_CREATED = 568,
+  ATOM_MEDIA_DRM_ERRORED = 569,
+  ATOM_MEDIA_DRM_SESSION_OPENED = 570,
+  ATOM_MEDIA_DRM_SESSION_CLOSED = 571,
+  ATOM_USER_SELECTED_RESOLUTION = 572,
+  ATOM_UNSAFE_INTENT_EVENT_REPORTED = 573,
+  ATOM_PERFORMANCE_HINT_SESSION_REPORTED = 574,
+  ATOM_MEDIAMETRICS_MIDI_DEVICE_CLOSE_REPORTED = 576,
+  ATOM_BIOMETRIC_TOUCH_REPORTED = 577,
+  ATOM_HOTWORD_AUDIO_EGRESS_EVENT_REPORTED = 578,
+  ATOM_LOCATION_ENABLED_STATE_CHANGED = 580,
+  ATOM_IME_REQUEST_FINISHED = 581,
+  ATOM_USB_COMPLIANCE_WARNINGS_REPORTED = 582,
+  ATOM_APP_SUPPORTED_LOCALES_CHANGED = 583,
+  ATOM_MEDIA_PROVIDER_VOLUME_RECOVERY_REPORTED = 586,
+  ATOM_BIOMETRIC_PROPERTIES_COLLECTED = 587,
+  ATOM_KERNEL_WAKEUP_ATTRIBUTED = 588,
+  ATOM_SCREEN_STATE_CHANGED_V2 = 589,
+  ATOM_WS_BACKUP_ACTION_REPORTED = 590,
+  ATOM_WS_RESTORE_ACTION_REPORTED = 591,
+  ATOM_DEVICE_LOG_ACCESS_EVENT_REPORTED = 592,
+  ATOM_MEDIA_SESSION_UPDATED = 594,
+  ATOM_WEAR_OOBE_STATE_CHANGED = 595,
+  ATOM_WS_NOTIFICATION_UPDATED = 596,
+  ATOM_NETWORK_VALIDATION_FAILURE_STATS_DAILY_REPORTED = 601,
+  ATOM_WS_COMPLICATION_TAPPED = 602,
+  ATOM_WS_NOTIFICATION_BLOCKING = 780,
+  ATOM_WS_NOTIFICATION_BRIDGEMODE_UPDATED = 822,
+  ATOM_WS_NOTIFICATION_DISMISSAL_ACTIONED = 823,
+  ATOM_WS_NOTIFICATION_ACTIONED = 824,
+  ATOM_WS_NOTIFICATION_LATENCY = 880,
+  ATOM_WIFI_BYTES_TRANSFER = 10000,
+  ATOM_WIFI_BYTES_TRANSFER_BY_FG_BG = 10001,
+  ATOM_MOBILE_BYTES_TRANSFER = 10002,
+  ATOM_MOBILE_BYTES_TRANSFER_BY_FG_BG = 10003,
+  ATOM_BLUETOOTH_BYTES_TRANSFER = 10006,
+  ATOM_KERNEL_WAKELOCK = 10004,
+  ATOM_SUBSYSTEM_SLEEP_STATE = 10005,
+  ATOM_CPU_TIME_PER_UID = 10009,
+  ATOM_CPU_TIME_PER_UID_FREQ = 10010,
+  ATOM_WIFI_ACTIVITY_INFO = 10011,
+  ATOM_MODEM_ACTIVITY_INFO = 10012,
+  ATOM_BLUETOOTH_ACTIVITY_INFO = 10007,
+  ATOM_PROCESS_MEMORY_STATE = 10013,
+  ATOM_SYSTEM_ELAPSED_REALTIME = 10014,
+  ATOM_SYSTEM_UPTIME = 10015,
+  ATOM_CPU_ACTIVE_TIME = 10016,
+  ATOM_CPU_CLUSTER_TIME = 10017,
+  ATOM_DISK_SPACE = 10018,
+  ATOM_REMAINING_BATTERY_CAPACITY = 10019,
+  ATOM_FULL_BATTERY_CAPACITY = 10020,
+  ATOM_TEMPERATURE = 10021,
+  ATOM_BINDER_CALLS = 10022,
+  ATOM_BINDER_CALLS_EXCEPTIONS = 10023,
+  ATOM_LOOPER_STATS = 10024,
+  ATOM_DISK_STATS = 10025,
+  ATOM_DIRECTORY_USAGE = 10026,
+  ATOM_APP_SIZE = 10027,
+  ATOM_CATEGORY_SIZE = 10028,
+  ATOM_PROC_STATS = 10029,
+  ATOM_BATTERY_VOLTAGE = 10030,
+  ATOM_NUM_FINGERPRINTS_ENROLLED = 10031,
+  ATOM_DISK_IO = 10032,
+  ATOM_POWER_PROFILE = 10033,
+  ATOM_PROC_STATS_PKG_PROC = 10034,
+  ATOM_PROCESS_CPU_TIME = 10035,
+  ATOM_CPU_TIME_PER_THREAD_FREQ = 10037,
+  ATOM_ON_DEVICE_POWER_MEASUREMENT = 10038,
+  ATOM_DEVICE_CALCULATED_POWER_USE = 10039,
+  ATOM_PROCESS_MEMORY_HIGH_WATER_MARK = 10042,
+  ATOM_BATTERY_LEVEL = 10043,
+  ATOM_BUILD_INFORMATION = 10044,
+  ATOM_BATTERY_CYCLE_COUNT = 10045,
+  ATOM_DEBUG_ELAPSED_CLOCK = 10046,
+  ATOM_DEBUG_FAILING_ELAPSED_CLOCK = 10047,
+  ATOM_NUM_FACES_ENROLLED = 10048,
+  ATOM_ROLE_HOLDER = 10049,
+  ATOM_DANGEROUS_PERMISSION_STATE = 10050,
+  ATOM_TRAIN_INFO = 10051,
+  ATOM_TIME_ZONE_DATA_INFO = 10052,
+  ATOM_EXTERNAL_STORAGE_INFO = 10053,
+  ATOM_GPU_STATS_GLOBAL_INFO = 10054,
+  ATOM_GPU_STATS_APP_INFO = 10055,
+  ATOM_SYSTEM_ION_HEAP_SIZE = 10056,
+  ATOM_APPS_ON_EXTERNAL_STORAGE_INFO = 10057,
+  ATOM_FACE_SETTINGS = 10058,
+  ATOM_COOLING_DEVICE = 10059,
+  ATOM_APP_OPS = 10060,
+  ATOM_PROCESS_SYSTEM_ION_HEAP_SIZE = 10061,
+  ATOM_SURFACEFLINGER_STATS_GLOBAL_INFO = 10062,
+  ATOM_SURFACEFLINGER_STATS_LAYER_INFO = 10063,
+  ATOM_PROCESS_MEMORY_SNAPSHOT = 10064,
+  ATOM_VMS_CLIENT_STATS = 10065,
+  ATOM_NOTIFICATION_REMOTE_VIEWS = 10066,
+  ATOM_DANGEROUS_PERMISSION_STATE_SAMPLED = 10067,
+  ATOM_GRAPHICS_STATS = 10068,
+  ATOM_RUNTIME_APP_OP_ACCESS = 10069,
+  ATOM_ION_HEAP_SIZE = 10070,
+  ATOM_PACKAGE_NOTIFICATION_PREFERENCES = 10071,
+  ATOM_PACKAGE_NOTIFICATION_CHANNEL_PREFERENCES = 10072,
+  ATOM_PACKAGE_NOTIFICATION_CHANNEL_GROUP_PREFERENCES = 10073,
+  ATOM_GNSS_STATS = 10074,
+  ATOM_ATTRIBUTED_APP_OPS = 10075,
+  ATOM_VOICE_CALL_SESSION = 10076,
+  ATOM_VOICE_CALL_RAT_USAGE = 10077,
+  ATOM_SIM_SLOT_STATE = 10078,
+  ATOM_SUPPORTED_RADIO_ACCESS_FAMILY = 10079,
+  ATOM_SETTING_SNAPSHOT = 10080,
+  ATOM_BLOB_INFO = 10081,
+  ATOM_DATA_USAGE_BYTES_TRANSFER = 10082,
+  ATOM_BYTES_TRANSFER_BY_TAG_AND_METERED = 10083,
+  ATOM_DND_MODE_RULE = 10084,
+  ATOM_GENERAL_EXTERNAL_STORAGE_ACCESS_STATS = 10085,
+  ATOM_INCOMING_SMS = 10086,
+  ATOM_OUTGOING_SMS = 10087,
+  ATOM_CARRIER_ID_TABLE_VERSION = 10088,
+  ATOM_DATA_CALL_SESSION = 10089,
+  ATOM_CELLULAR_SERVICE_STATE = 10090,
+  ATOM_CELLULAR_DATA_SERVICE_SWITCH = 10091,
+  ATOM_SYSTEM_MEMORY = 10092,
+  ATOM_IMS_REGISTRATION_TERMINATION = 10093,
+  ATOM_IMS_REGISTRATION_STATS = 10094,
+  ATOM_CPU_TIME_PER_CLUSTER_FREQ = 10095,
+  ATOM_CPU_CYCLES_PER_UID_CLUSTER = 10096,
+  ATOM_DEVICE_ROTATED_DATA = 10097,
+  ATOM_CPU_CYCLES_PER_THREAD_GROUP_CLUSTER = 10098,
+  ATOM_MEDIA_DRM_ACTIVITY_INFO = 10099,
+  ATOM_OEM_MANAGED_BYTES_TRANSFER = 10100,
+  ATOM_GNSS_POWER_STATS = 10101,
+  ATOM_TIME_ZONE_DETECTOR_STATE = 10102,
+  ATOM_KEYSTORE2_STORAGE_STATS = 10103,
+  ATOM_RKP_POOL_STATS = 10104,
+  ATOM_PROCESS_DMABUF_MEMORY = 10105,
+  ATOM_PENDING_ALARM_INFO = 10106,
+  ATOM_USER_LEVEL_HIBERNATED_APPS = 10107,
+  ATOM_LAUNCHER_LAYOUT_SNAPSHOT = 10108,
+  ATOM_GLOBAL_HIBERNATED_APPS = 10109,
+  ATOM_INPUT_EVENT_LATENCY_SKETCH = 10110,
+  ATOM_BATTERY_USAGE_STATS_BEFORE_RESET = 10111,
+  ATOM_BATTERY_USAGE_STATS_SINCE_RESET = 10112,
+  ATOM_BATTERY_USAGE_STATS_SINCE_RESET_USING_POWER_PROFILE_MODEL = 10113,
+  ATOM_INSTALLED_INCREMENTAL_PACKAGE = 10114,
+  ATOM_TELEPHONY_NETWORK_REQUESTS = 10115,
+  ATOM_APP_SEARCH_STORAGE_INFO = 10116,
+  ATOM_VMSTAT = 10117,
+  ATOM_KEYSTORE2_KEY_CREATION_WITH_GENERAL_INFO = 10118,
+  ATOM_KEYSTORE2_KEY_CREATION_WITH_AUTH_INFO = 10119,
+  ATOM_KEYSTORE2_KEY_CREATION_WITH_PURPOSE_AND_MODES_INFO = 10120,
+  ATOM_KEYSTORE2_ATOM_WITH_OVERFLOW = 10121,
+  ATOM_KEYSTORE2_KEY_OPERATION_WITH_PURPOSE_AND_MODES_INFO = 10122,
+  ATOM_KEYSTORE2_KEY_OPERATION_WITH_GENERAL_INFO = 10123,
+  ATOM_RKP_ERROR_STATS = 10124,
+  ATOM_KEYSTORE2_CRASH_STATS = 10125,
+  ATOM_VENDOR_APEX_INFO = 10126,
+  ATOM_ACCESSIBILITY_SHORTCUT_STATS = 10127,
+  ATOM_ACCESSIBILITY_FLOATING_MENU_STATS = 10128,
+  ATOM_DATA_USAGE_BYTES_TRANSFER_V2 = 10129,
+  ATOM_MEDIA_CAPABILITIES = 10130,
+  ATOM_CAR_WATCHDOG_SYSTEM_IO_USAGE_SUMMARY = 10131,
+  ATOM_CAR_WATCHDOG_UID_IO_USAGE_SUMMARY = 10132,
+  ATOM_IMS_REGISTRATION_FEATURE_TAG_STATS = 10133,
+  ATOM_RCS_CLIENT_PROVISIONING_STATS = 10134,
+  ATOM_RCS_ACS_PROVISIONING_STATS = 10135,
+  ATOM_SIP_DELEGATE_STATS = 10136,
+  ATOM_SIP_TRANSPORT_FEATURE_TAG_STATS = 10137,
+  ATOM_SIP_MESSAGE_RESPONSE = 10138,
+  ATOM_SIP_TRANSPORT_SESSION = 10139,
+  ATOM_IMS_DEDICATED_BEARER_LISTENER_EVENT = 10140,
+  ATOM_IMS_DEDICATED_BEARER_EVENT = 10141,
+  ATOM_IMS_REGISTRATION_SERVICE_DESC_STATS = 10142,
+  ATOM_UCE_EVENT_STATS = 10143,
+  ATOM_PRESENCE_NOTIFY_EVENT = 10144,
+  ATOM_GBA_EVENT = 10145,
+  ATOM_PER_SIM_STATUS = 10146,
+  ATOM_GPU_WORK_PER_UID = 10147,
+  ATOM_PERSISTENT_URI_PERMISSIONS_AMOUNT_PER_PACKAGE = 10148,
+  ATOM_SIGNED_PARTITION_INFO = 10149,
+  ATOM_PINNED_FILE_SIZES_PER_PACKAGE = 10150,
+  ATOM_PENDING_INTENTS_PER_PACKAGE = 10151,
+  ATOM_USER_INFO = 10152,
+  ATOM_TELEPHONY_NETWORK_REQUESTS_V2 = 10153,
+  ATOM_DEVICE_TELEPHONY_PROPERTIES = 10154,
+  ATOM_REMOTE_KEY_PROVISIONING_ERROR_COUNTS = 10155,
+  ATOM_SAFETY_STATE = 10156,
+  ATOM_INCOMING_MMS = 10157,
+  ATOM_OUTGOING_MMS = 10158,
+  ATOM_MULTI_USER_INFO = 10160,
+  ATOM_NETWORK_BPF_MAP_INFO = 10161,
+  ATOM_OUTGOING_SHORT_CODE_SMS = 10162,
+  ATOM_CONNECTIVITY_STATE_SAMPLE = 10163,
+  ATOM_NETWORK_SELECTION_REMATCH_REASONS_INFO = 10164,
+  ATOM_GAME_MODE_INFO = 10165,
+  ATOM_GAME_MODE_CONFIGURATION = 10166,
+  ATOM_GAME_MODE_LISTENER = 10167,
+  ATOM_NETWORK_SLICE_REQUEST_COUNT = 10168,
+  ATOM_WS_TILE_SNAPSHOT = 10169,
+  ATOM_WS_ACTIVE_WATCH_FACE_COMPLICATION_SET_SNAPSHOT = 10170,
+  ATOM_PROCESS_STATE = 10171,
+  ATOM_PROCESS_ASSOCIATION = 10172,
+  ATOM_ADPF_SYSTEM_COMPONENT_INFO = 10173,
+  ATOM_NOTIFICATION_MEMORY_USE = 10174,
+  ATOM_HDR_CAPABILITIES = 10175,
+  ATOM_WS_FAVOURITE_WATCH_FACE_LIST_SNAPSHOT = 10176,
+  ATOM_ACCESSIBILITY_CHECK_RESULT_REPORTED = 910,
+  ATOM_ADAPTIVE_AUTH_UNLOCK_AFTER_LOCK_REPORTED = 820,
+  ATOM_THERMAL_STATUS_CALLED = 772,
+  ATOM_THERMAL_HEADROOM_CALLED = 773,
+  ATOM_THERMAL_HEADROOM_THRESHOLDS_CALLED = 774,
+  ATOM_ADPF_HINT_SESSION_TID_CLEANUP = 839,
+  ATOM_THERMAL_HEADROOM_THRESHOLDS = 10201,
+  ATOM_ADPF_SESSION_SNAPSHOT = 10218,
+  ATOM_JSSCRIPTENGINE_LATENCY_REPORTED = 483,
+  ATOM_AD_SERVICES_API_CALLED = 435,
+  ATOM_AD_SERVICES_MESUREMENT_REPORTS_UPLOADED = 436,
+  ATOM_MOBILE_DATA_DOWNLOAD_FILE_GROUP_STATUS_REPORTED = 490,
+  ATOM_MOBILE_DATA_DOWNLOAD_DOWNLOAD_RESULT_REPORTED = 502,
+  ATOM_AD_SERVICES_SETTINGS_USAGE_REPORTED = 493,
+  ATOM_BACKGROUND_FETCH_PROCESS_REPORTED = 496,
+  ATOM_UPDATE_CUSTOM_AUDIENCE_PROCESS_REPORTED = 497,
+  ATOM_RUN_AD_BIDDING_PROCESS_REPORTED = 498,
+  ATOM_RUN_AD_SCORING_PROCESS_REPORTED = 499,
+  ATOM_RUN_AD_SELECTION_PROCESS_REPORTED = 500,
+  ATOM_RUN_AD_BIDDING_PER_CA_PROCESS_REPORTED = 501,
+  ATOM_MOBILE_DATA_DOWNLOAD_FILE_GROUP_STORAGE_STATS_REPORTED = 503,
+  ATOM_AD_SERVICES_MEASUREMENT_REGISTRATIONS = 512,
+  ATOM_AD_SERVICES_GET_TOPICS_REPORTED = 535,
+  ATOM_AD_SERVICES_EPOCH_COMPUTATION_GET_TOP_TOPICS_REPORTED = 536,
+  ATOM_AD_SERVICES_EPOCH_COMPUTATION_CLASSIFIER_REPORTED = 537,
+  ATOM_AD_SERVICES_BACK_COMPAT_GET_TOPICS_REPORTED = 598,
+  ATOM_AD_SERVICES_BACK_COMPAT_EPOCH_COMPUTATION_CLASSIFIER_REPORTED = 599,
+  ATOM_AD_SERVICES_MEASUREMENT_DEBUG_KEYS = 640,
+  ATOM_AD_SERVICES_ERROR_REPORTED = 662,
+  ATOM_AD_SERVICES_BACKGROUND_JOBS_EXECUTION_REPORTED = 663,
+  ATOM_AD_SERVICES_MEASUREMENT_DELAYED_SOURCE_REGISTRATION = 673,
+  ATOM_AD_SERVICES_MEASUREMENT_ATTRIBUTION = 674,
+  ATOM_AD_SERVICES_MEASUREMENT_JOBS = 675,
+  ATOM_AD_SERVICES_MEASUREMENT_WIPEOUT = 676,
+  ATOM_AD_SERVICES_MEASUREMENT_AD_ID_MATCH_FOR_DEBUG_KEYS = 695,
+  ATOM_AD_SERVICES_ENROLLMENT_DATA_STORED = 697,
+  ATOM_AD_SERVICES_ENROLLMENT_FILE_DOWNLOADED = 698,
+  ATOM_AD_SERVICES_ENROLLMENT_MATCHED = 699,
+  ATOM_AD_SERVICES_CONSENT_MIGRATED = 702,
+  ATOM_AD_SERVICES_ENROLLMENT_FAILED = 714,
+  ATOM_AD_SERVICES_MEASUREMENT_CLICK_VERIFICATION = 756,
+  ATOM_AD_SERVICES_ENCRYPTION_KEY_FETCHED = 765,
+  ATOM_AD_SERVICES_ENCRYPTION_KEY_DB_TRANSACTION_ENDED = 766,
+  ATOM_DESTINATION_REGISTERED_BEACONS = 767,
+  ATOM_REPORT_INTERACTION_API_CALLED = 768,
+  ATOM_INTERACTION_REPORTING_TABLE_CLEARED = 769,
+  ATOM_APP_MANIFEST_CONFIG_HELPER_CALLED = 788,
+  ATOM_AD_FILTERING_PROCESS_JOIN_CA_REPORTED = 793,
+  ATOM_AD_FILTERING_PROCESS_AD_SELECTION_REPORTED = 794,
+  ATOM_AD_COUNTER_HISTOGRAM_UPDATER_REPORTED = 795,
+  ATOM_SIGNATURE_VERIFICATION = 807,
+  ATOM_K_ANON_IMMEDIATE_SIGN_JOIN_STATUS_REPORTED = 808,
+  ATOM_K_ANON_BACKGROUND_JOB_STATUS_REPORTED = 809,
+  ATOM_K_ANON_INITIALIZE_STATUS_REPORTED = 810,
+  ATOM_K_ANON_SIGN_STATUS_REPORTED = 811,
+  ATOM_K_ANON_JOIN_STATUS_REPORTED = 812,
+  ATOM_K_ANON_KEY_ATTESTATION_STATUS_REPORTED = 813,
+  ATOM_GET_AD_SELECTION_DATA_API_CALLED = 814,
+  ATOM_GET_AD_SELECTION_DATA_BUYER_INPUT_GENERATED = 815,
+  ATOM_BACKGROUND_JOB_SCHEDULING_REPORTED = 834,
+  ATOM_TOPICS_ENCRYPTION_EPOCH_COMPUTATION_REPORTED = 840,
+  ATOM_TOPICS_ENCRYPTION_GET_TOPICS_REPORTED = 841,
+  ATOM_ADSERVICES_SHELL_COMMAND_CALLED = 842,
+  ATOM_UPDATE_SIGNALS_API_CALLED = 843,
+  ATOM_ENCODING_JOB_RUN = 844,
+  ATOM_ENCODING_JS_FETCH = 845,
+  ATOM_ENCODING_JS_EXECUTION = 846,
+  ATOM_PERSIST_AD_SELECTION_RESULT_CALLED = 847,
+  ATOM_SERVER_AUCTION_KEY_FETCH_CALLED = 848,
+  ATOM_SERVER_AUCTION_BACKGROUND_KEY_FETCH_ENABLED = 849,
+  ATOM_AD_SERVICES_MEASUREMENT_PROCESS_ODP_REGISTRATION = 864,
+  ATOM_AD_SERVICES_MEASUREMENT_NOTIFY_REGISTRATION_TO_ODP = 865,
+  ATOM_SELECT_ADS_FROM_OUTCOMES_API_CALLED = 876,
+  ATOM_REPORT_IMPRESSION_API_CALLED = 877,
+  ATOM_AD_SERVICES_ENROLLMENT_TRANSACTION_STATS = 885,
+  ATOM_AD_SERVICES_COBALT_LOGGER_EVENT_REPORTED = 902,
+  ATOM_AD_SERVICES_COBALT_PERIODIC_JOB_EVENT_REPORTED = 903,
+  ATOM_UPDATE_SIGNALS_PROCESS_REPORTED = 905,
+  ATOM_TOPICS_SCHEDULE_EPOCH_JOB_SETTING_REPORTED = 930,
+  ATOM_AI_WALLPAPERS_BUTTON_PRESSED = 706,
+  ATOM_AI_WALLPAPERS_TEMPLATE_SELECTED = 707,
+  ATOM_AI_WALLPAPERS_TERM_SELECTED = 708,
+  ATOM_AI_WALLPAPERS_WALLPAPER_SET = 709,
+  ATOM_AI_WALLPAPERS_SESSION_SUMMARY = 710,
+  ATOM_APEX_INSTALLATION_REQUESTED = 732,
+  ATOM_APEX_INSTALLATION_STAGED = 733,
+  ATOM_APEX_INSTALLATION_ENDED = 734,
+  ATOM_APP_SEARCH_SET_SCHEMA_STATS_REPORTED = 385,
+  ATOM_APP_SEARCH_SCHEMA_MIGRATION_STATS_REPORTED = 579,
+  ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_STATS_REPORTED = 825,
+  ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_RAW_QUERY_STATS_REPORTED = 826,
+  ATOM_APP_SEARCH_APPS_INDEXER_STATS_REPORTED = 909,
+  ATOM_ART_DATUM_REPORTED = 332,
+  ATOM_ART_DEVICE_DATUM_REPORTED = 550,
+  ATOM_ART_DATUM_DELTA_REPORTED = 565,
+  ATOM_ART_DEX2OAT_REPORTED = 929,
+  ATOM_ART_DEVICE_STATUS = 10205,
+  ATOM_BACKGROUND_DEXOPT_JOB_ENDED = 467,
+  ATOM_PREREBOOT_DEXOPT_JOB_ENDED = 883,
+  ATOM_ODREFRESH_REPORTED = 366,
+  ATOM_ODSIGN_REPORTED = 548,
+  ATOM_AUTOFILL_UI_EVENT_REPORTED = 603,
+  ATOM_AUTOFILL_FILL_REQUEST_REPORTED = 604,
+  ATOM_AUTOFILL_FILL_RESPONSE_REPORTED = 605,
+  ATOM_AUTOFILL_SAVE_EVENT_REPORTED = 606,
+  ATOM_AUTOFILL_SESSION_COMMITTED = 607,
+  ATOM_AUTOFILL_FIELD_CLASSIFICATION_EVENT_REPORTED = 659,
+  ATOM_CAR_RECENTS_EVENT_REPORTED = 770,
+  ATOM_CAR_CALM_MODE_EVENT_REPORTED = 797,
+  ATOM_CAR_WAKEUP_FROM_SUSPEND_REPORTED = 852,
+  ATOM_PLUGIN_INITIALIZED = 655,
+  ATOM_BLUETOOTH_HASHED_DEVICE_NAME_REPORTED = 613,
+  ATOM_BLUETOOTH_L2CAP_COC_CLIENT_CONNECTION = 614,
+  ATOM_BLUETOOTH_L2CAP_COC_SERVER_CONNECTION = 615,
+  ATOM_BLUETOOTH_LE_SESSION_CONNECTED = 656,
+  ATOM_RESTRICTED_BLUETOOTH_DEVICE_NAME_REPORTED = 666,
+  ATOM_BLUETOOTH_PROFILE_CONNECTION_ATTEMPTED = 696,
+  ATOM_BLUETOOTH_CONTENT_PROFILE_ERROR_REPORTED = 781,
+  ATOM_BLUETOOTH_RFCOMM_CONNECTION_ATTEMPTED = 782,
+  ATOM_REMOTE_DEVICE_INFORMATION_WITH_METRIC_ID = 862,
+  ATOM_LE_APP_SCAN_STATE_CHANGED = 870,
+  ATOM_LE_RADIO_SCAN_STOPPED = 871,
+  ATOM_LE_SCAN_RESULT_RECEIVED = 872,
+  ATOM_LE_SCAN_ABUSED = 873,
+  ATOM_LE_ADV_STATE_CHANGED = 874,
+  ATOM_LE_ADV_ERROR_REPORTED = 875,
+  ATOM_A2DP_SESSION_REPORTED = 904,
+  ATOM_BLUETOOTH_CROSS_LAYER_EVENT_REPORTED = 916,
+  ATOM_BROADCAST_AUDIO_SESSION_REPORTED = 927,
+  ATOM_BROADCAST_AUDIO_SYNC_REPORTED = 928,
+  ATOM_BLUETOOTH_RFCOMM_CONNECTION_REPORTED_AT_CLOSE = 982,
+  ATOM_BLUETOOTH_LE_CONNECTION = 988,
+  ATOM_BROADCAST_SENT = 922,
+  ATOM_CAMERA_FEATURE_COMBINATION_QUERY_EVENT = 900,
+  ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_STATE_CHANGED = 934,
+  ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_UPDATE_FAILED = 972,
+  ATOM_DAILY_KEEPALIVE_INFO_REPORTED = 650,
+  ATOM_NETWORK_REQUEST_STATE_CHANGED = 779,
+  ATOM_TETHERING_ACTIVE_SESSIONS_REPORTED = 925,
+  ATOM_NETWORK_STATS_RECORDER_FILE_OPERATED = 783,
+  ATOM_CORE_NETWORKING_TERRIBLE_ERROR_OCCURRED = 979,
+  ATOM_APF_SESSION_INFO_REPORTED = 777,
+  ATOM_IP_CLIENT_RA_INFO_REPORTED = 778,
+  ATOM_VPN_CONNECTION_STATE_CHANGED = 850,
+  ATOM_VPN_CONNECTION_REPORTED = 851,
+  ATOM_CPU_POLICY = 10199,
+  ATOM_CREDENTIAL_MANAGER_API_CALLED = 585,
+  ATOM_CREDENTIAL_MANAGER_INIT_PHASE_REPORTED = 651,
+  ATOM_CREDENTIAL_MANAGER_CANDIDATE_PHASE_REPORTED = 652,
+  ATOM_CREDENTIAL_MANAGER_FINAL_PHASE_REPORTED = 653,
+  ATOM_CREDENTIAL_MANAGER_TOTAL_REPORTED = 667,
+  ATOM_CREDENTIAL_MANAGER_FINALNOUID_REPORTED = 668,
+  ATOM_CREDENTIAL_MANAGER_GET_REPORTED = 669,
+  ATOM_CREDENTIAL_MANAGER_AUTH_CLICK_REPORTED = 670,
+  ATOM_CREDENTIAL_MANAGER_APIV2_CALLED = 671,
+  ATOM_CRONET_ENGINE_CREATED = 703,
+  ATOM_CRONET_TRAFFIC_REPORTED = 704,
+  ATOM_CRONET_ENGINE_BUILDER_INITIALIZED = 762,
+  ATOM_CRONET_HTTP_FLAGS_INITIALIZED = 763,
+  ATOM_CRONET_INITIALIZED = 764,
+  ATOM_DESKTOP_MODE_UI_CHANGED = 818,
+  ATOM_DESKTOP_MODE_SESSION_TASK_UPDATE = 819,
+  ATOM_DESKTOP_MODE_TASK_SIZE_UPDATED = 935,
+  ATOM_DEVICE_LOCK_CHECK_IN_REQUEST_REPORTED = 726,
+  ATOM_DEVICE_LOCK_PROVISIONING_COMPLETE_REPORTED = 727,
+  ATOM_DEVICE_LOCK_KIOSK_APP_REQUEST_REPORTED = 728,
+  ATOM_DEVICE_LOCK_CHECK_IN_RETRY_REPORTED = 789,
+  ATOM_DEVICE_LOCK_PROVISION_FAILURE_REPORTED = 790,
+  ATOM_DEVICE_LOCK_LOCK_UNLOCK_DEVICE_FAILURE_REPORTED = 791,
+  ATOM_DEVICE_POLICY_MANAGEMENT_MODE = 10216,
+  ATOM_DEVICE_POLICY_STATE = 10217,
+  ATOM_DISPLAY_MODE_DIRECTOR_VOTE_CHANGED = 792,
+  ATOM_EXTERNAL_DISPLAY_STATE_CHANGED = 806,
+  ATOM_DND_STATE_CHANGED = 657,
+  ATOM_DREAM_SETTING_CHANGED = 705,
+  ATOM_DREAM_SETTING_SNAPSHOT = 10192,
+  ATOM_EXPRESS_EVENT_REPORTED = 528,
+  ATOM_EXPRESS_HISTOGRAM_SAMPLE_REPORTED = 593,
+  ATOM_EXPRESS_UID_EVENT_REPORTED = 644,
+  ATOM_EXPRESS_UID_HISTOGRAM_SAMPLE_REPORTED = 658,
+  ATOM_FEDERATED_COMPUTE_API_CALLED = 712,
+  ATOM_FEDERATED_COMPUTE_TRAINING_EVENT_REPORTED = 771,
+  ATOM_EXAMPLE_ITERATOR_NEXT_LATENCY_REPORTED = 838,
+  ATOM_FULL_SCREEN_INTENT_LAUNCHED = 631,
+  ATOM_BAL_ALLOWED = 632,
+  ATOM_IN_TASK_ACTIVITY_STARTED = 685,
+  ATOM_DEVICE_ORIENTATION_CHANGED = 906,
+  ATOM_CACHED_APPS_HIGH_WATERMARK = 10189,
+  ATOM_STYLUS_PREDICTION_METRICS_REPORTED = 718,
+  ATOM_USER_RISK_EVENT_REPORTED = 725,
+  ATOM_MEDIA_PROJECTION_STATE_CHANGED = 729,
+  ATOM_MEDIA_PROJECTION_TARGET_CHANGED = 730,
+  ATOM_EXCESSIVE_BINDER_PROXY_COUNT_REPORTED = 853,
+  ATOM_PROXY_BYTES_TRANSFER_BY_FG_BG = 10200,
+  ATOM_MOBILE_BYTES_TRANSFER_BY_PROC_STATE = 10204,
+  ATOM_BIOMETRIC_FRR_NOTIFICATION = 817,
+  ATOM_SENSITIVE_CONTENT_MEDIA_PROJECTION_SESSION = 830,
+  ATOM_SENSITIVE_NOTIFICATION_APP_PROTECTION_SESSION = 831,
+  ATOM_SENSITIVE_NOTIFICATION_APP_PROTECTION_APPLIED = 832,
+  ATOM_SENSITIVE_NOTIFICATION_REDACTION = 833,
+  ATOM_SENSITIVE_CONTENT_APP_PROTECTION = 835,
+  ATOM_APP_RESTRICTION_STATE_CHANGED = 866,
+  ATOM_BATTERY_USAGE_STATS_PER_UID = 10209,
+  ATOM_POSTGC_MEMORY_SNAPSHOT = 924,
+  ATOM_POWER_SAVE_TEMP_ALLOWLIST_CHANGED = 926,
+  ATOM_APP_OP_ACCESS_TRACKED = 931,
+  ATOM_CONTENT_OR_FILE_URI_EVENT_REPORTED = 933,
+  ATOM_APPLICATION_GRAMMATICAL_INFLECTION_CHANGED = 584,
+  ATOM_SYSTEM_GRAMMATICAL_INFLECTION_CHANGED = 816,
+  ATOM_BATTERY_HEALTH = 10220,
+  ATOM_HDMI_EARC_STATUS_REPORTED = 701,
+  ATOM_HDMI_SOUNDBAR_MODE_STATUS_REPORTED = 724,
+  ATOM_HEALTH_CONNECT_API_CALLED = 616,
+  ATOM_HEALTH_CONNECT_USAGE_STATS = 617,
+  ATOM_HEALTH_CONNECT_STORAGE_STATS = 618,
+  ATOM_HEALTH_CONNECT_API_INVOKED = 643,
+  ATOM_EXERCISE_ROUTE_API_CALLED = 654,
+  ATOM_HEALTH_CONNECT_EXPORT_INVOKED = 907,
+  ATOM_HEALTH_CONNECT_IMPORT_INVOKED = 918,
+  ATOM_HEALTH_CONNECT_EXPORT_IMPORT_STATS_REPORTED = 919,
+  ATOM_HEALTH_CONNECT_UI_IMPRESSION = 623,
+  ATOM_HEALTH_CONNECT_UI_INTERACTION = 624,
+  ATOM_HEALTH_CONNECT_APP_OPENED_REPORTED = 625,
+  ATOM_HOTWORD_EGRESS_SIZE_ATOM_REPORTED = 761,
+  ATOM_IKE_SESSION_TERMINATED = 678,
+  ATOM_IKE_LIVENESS_CHECK_SESSION_VALIDATED = 760,
+  ATOM_NEGOTIATED_SECURITY_ASSOCIATION = 821,
+  ATOM_KEYBOARD_CONFIGURED = 682,
+  ATOM_KEYBOARD_SYSTEMS_EVENT_REPORTED = 683,
+  ATOM_INPUTDEVICE_USAGE_REPORTED = 686,
+  ATOM_INPUT_EVENT_LATENCY_REPORTED = 932,
+  ATOM_TOUCHPAD_USAGE = 10191,
+  ATOM_KERNEL_OOM_KILL_OCCURRED = 754,
+  ATOM_EMERGENCY_STATE_CHANGED = 633,
+  ATOM_CHRE_SIGNIFICANT_MOTION_STATE_CHANGED = 868,
+  ATOM_POPULATION_DENSITY_PROVIDER_LOADING_REPORTED = 1002,
+  ATOM_DENSITY_BASED_COARSE_LOCATIONS_USAGE_REPORTED = 1003,
+  ATOM_DENSITY_BASED_COARSE_LOCATIONS_PROVIDER_QUERY_REPORTED = 1004,
+  ATOM_MEDIA_CODEC_RECLAIM_REQUEST_COMPLETED = 600,
+  ATOM_MEDIA_CODEC_STARTED = 641,
+  ATOM_MEDIA_CODEC_STOPPED = 642,
+  ATOM_MEDIA_CODEC_RENDERED = 684,
+  ATOM_MEDIA_EDITING_ENDED_REPORTED = 798,
+  ATOM_MTE_STATE = 10181,
+  ATOM_MICROXR_DEVICE_BOOT_COMPLETE_REPORTED = 901,
+  ATOM_NFC_OBSERVE_MODE_STATE_CHANGED = 855,
+  ATOM_NFC_FIELD_CHANGED = 856,
+  ATOM_NFC_POLLING_LOOP_NOTIFICATION_REPORTED = 857,
+  ATOM_NFC_PROPRIETARY_CAPABILITIES_REPORTED = 858,
+  ATOM_ONDEVICEPERSONALIZATION_API_CALLED = 711,
+  ATOM_COMPONENT_STATE_CHANGED_REPORTED = 863,
+  ATOM_PDF_LOAD_REPORTED = 859,
+  ATOM_PDF_API_USAGE_REPORTED = 860,
+  ATOM_PDF_SEARCH_REPORTED = 861,
+  ATOM_PRESSURE_STALL_INFORMATION = 10229,
+  ATOM_PERMISSION_RATIONALE_DIALOG_VIEWED = 645,
+  ATOM_PERMISSION_RATIONALE_DIALOG_ACTION_REPORTED = 646,
+  ATOM_APP_DATA_SHARING_UPDATES_NOTIFICATION_INTERACTION = 647,
+  ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_VIEWED = 648,
+  ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_ACTION_REPORTED = 649,
+  ATOM_ENHANCED_CONFIRMATION_DIALOG_RESULT_REPORTED = 827,
+  ATOM_ENHANCED_CONFIRMATION_RESTRICTION_CLEARED = 828,
+  ATOM_PHOTOPICKER_SESSION_INFO_REPORTED = 886,
+  ATOM_PHOTOPICKER_API_INFO_REPORTED = 887,
+  ATOM_PHOTOPICKER_UI_EVENT_LOGGED = 888,
+  ATOM_PHOTOPICKER_MEDIA_ITEM_STATUS_REPORTED = 889,
+  ATOM_PHOTOPICKER_PREVIEW_INFO_LOGGED = 890,
+  ATOM_PHOTOPICKER_MENU_INTERACTION_LOGGED = 891,
+  ATOM_PHOTOPICKER_BANNER_INTERACTION_LOGGED = 892,
+  ATOM_PHOTOPICKER_MEDIA_LIBRARY_INFO_LOGGED = 893,
+  ATOM_PHOTOPICKER_PAGE_INFO_LOGGED = 894,
+  ATOM_PHOTOPICKER_MEDIA_GRID_SYNC_INFO_REPORTED = 895,
+  ATOM_PHOTOPICKER_ALBUM_SYNC_INFO_REPORTED = 896,
+  ATOM_PHOTOPICKER_SEARCH_INFO_REPORTED = 897,
+  ATOM_SEARCH_DATA_EXTRACTION_DETAILS_REPORTED = 898,
+  ATOM_EMBEDDED_PHOTOPICKER_INFO_REPORTED = 899,
+  ATOM_ATOM_9999 = 9999,
+  ATOM_ATOM_99999 = 99999,
+  ATOM_SCREEN_OFF_REPORTED = 776,
+  ATOM_SCREEN_TIMEOUT_OVERRIDE_REPORTED = 836,
+  ATOM_SCREEN_INTERACTIVE_SESSION_REPORTED = 837,
+  ATOM_SCREEN_DIM_REPORTED = 867,
+  ATOM_MEDIA_PROVIDER_DATABASE_ROLLBACK_REPORTED = 784,
+  ATOM_BACKUP_SETUP_STATUS_REPORTED = 785,
+  ATOM_RANGING_SESSION_CONFIGURED = 993,
+  ATOM_RANGING_SESSION_STARTED = 994,
+  ATOM_RANGING_SESSION_CLOSED = 995,
+  ATOM_RANGING_TECHNOLOGY_STARTED = 996,
+  ATOM_RANGING_TECHNOLOGY_STOPPED = 997,
+  ATOM_RKPD_POOL_STATS = 664,
+  ATOM_RKPD_CLIENT_OPERATION = 665,
+  ATOM_SANDBOX_API_CALLED = 488,
+  ATOM_SANDBOX_ACTIVITY_EVENT_OCCURRED = 735,
+  ATOM_SDK_SANDBOX_RESTRICTED_ACCESS_IN_SESSION = 796,
+  ATOM_SANDBOX_SDK_STORAGE = 10159,
+  ATOM_SELINUX_AUDIT_LOG = 799,
+  ATOM_SETTINGS_SPA_REPORTED = 622,
+  ATOM_TEST_EXTENSION_ATOM_REPORTED = 660,
+  ATOM_TEST_RESTRICTED_ATOM_REPORTED = 672,
+  ATOM_STATS_SOCKET_LOSS_REPORTED = 752,
+  ATOM_LOCKSCREEN_SHORTCUT_SELECTED = 611,
+  ATOM_LOCKSCREEN_SHORTCUT_TRIGGERED = 612,
+  ATOM_LAUNCHER_IMPRESSION_EVENT_V2 = 716,
+  ATOM_DISPLAY_SWITCH_LATENCY_TRACKED = 753,
+  ATOM_NOTIFICATION_LISTENER_SERVICE = 829,
+  ATOM_NAV_HANDLE_TOUCH_POINTS = 869,
+  ATOM_COMMUNAL_HUB_WIDGET_EVENT_REPORTED = 908,
+  ATOM_COMMUNAL_HUB_SNAPSHOT = 10226,
+  ATOM_EMERGENCY_NUMBER_DIALED = 637,
+  ATOM_CALL_STATS = 10221,
+  ATOM_CALL_AUDIO_ROUTE_STATS = 10222,
+  ATOM_TELECOM_API_STATS = 10223,
+  ATOM_TELECOM_ERROR_STATS = 10224,
+  ATOM_CELLULAR_RADIO_POWER_STATE_CHANGED = 713,
+  ATOM_EMERGENCY_NUMBERS_INFO = 10180,
+  ATOM_DATA_NETWORK_VALIDATION = 10207,
+  ATOM_DATA_RAT_STATE_CHANGED = 854,
+  ATOM_CONNECTED_CHANNEL_CHANGED = 882,
+  ATOM_IWLAN_UNDERLYING_NETWORK_VALIDATION_RESULT_REPORTED = 923,
+  ATOM_QUALIFIED_RAT_LIST_CHANGED = 634,
+  ATOM_QNS_IMS_CALL_DROP_STATS = 635,
+  ATOM_QNS_FALLBACK_RESTRICTION_CHANGED = 636,
+  ATOM_QNS_RAT_PREFERENCE_MISMATCH_INFO = 10177,
+  ATOM_QNS_HANDOVER_TIME_MILLIS = 10178,
+  ATOM_QNS_HANDOVER_PINGPONG = 10179,
+  ATOM_SATELLITE_CONTROLLER = 10182,
+  ATOM_SATELLITE_SESSION = 10183,
+  ATOM_SATELLITE_INCOMING_DATAGRAM = 10184,
+  ATOM_SATELLITE_OUTGOING_DATAGRAM = 10185,
+  ATOM_SATELLITE_PROVISION = 10186,
+  ATOM_SATELLITE_SOS_MESSAGE_RECOMMENDER = 10187,
+  ATOM_CARRIER_ROAMING_SATELLITE_SESSION = 10211,
+  ATOM_CARRIER_ROAMING_SATELLITE_CONTROLLER_STATS = 10212,
+  ATOM_CONTROLLER_STATS_PER_PACKAGE = 10213,
+  ATOM_SATELLITE_ENTITLEMENT = 10214,
+  ATOM_SATELLITE_CONFIG_UPDATER = 10215,
+  ATOM_SATELLITE_ACCESS_CONTROLLER = 10219,
+  ATOM_CELLULAR_IDENTIFIER_DISCLOSED = 800,
+  ATOM_THREADNETWORK_TELEMETRY_DATA_REPORTED = 738,
+  ATOM_THREADNETWORK_TOPO_ENTRY_REPEATED = 739,
+  ATOM_THREADNETWORK_DEVICE_INFO_REPORTED = 740,
+  ATOM_BOOT_INTEGRITY_INFO_REPORTED = 775,
+  ATOM_TV_LOW_POWER_STANDBY_POLICY = 679,
+  ATOM_EXTERNAL_TV_INPUT_EVENT = 717,
+  ATOM_TEST_UPROBESTATS_ATOM_REPORTED = 915,
+  ATOM_UWB_ACTIVITY_INFO = 10188,
+  ATOM_MEDIATOR_UPDATED = 721,
+  ATOM_SYSPROXY_BLUETOOTH_BYTES_TRANSFER = 10196,
+  ATOM_SYSPROXY_CONNECTION_UPDATED = 786,
+  ATOM_WEAR_COMPANION_CONNECTION_STATE = 921,
+  ATOM_MEDIA_ACTION_REPORTED = 608,
+  ATOM_MEDIA_CONTROLS_LAUNCHED = 609,
+  ATOM_MEDIA_SESSION_STATE_CHANGED = 677,
+  ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_DEVICE_SCAN_API_LATENCY = 757,
+  ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_SASS_DEVICE_UNAVAILABLE = 758,
+  ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FASTPAIR_API_TIMEOUT = 759,
+  ATOM_WEAR_MODE_STATE_CHANGED = 715,
+  ATOM_RENDERER_INITIALIZED = 736,
+  ATOM_SCHEMA_VERSION_RECEIVED = 737,
+  ATOM_LAYOUT_INSPECTED = 741,
+  ATOM_LAYOUT_EXPRESSION_INSPECTED = 742,
+  ATOM_LAYOUT_ANIMATIONS_INSPECTED = 743,
+  ATOM_MATERIAL_COMPONENTS_INSPECTED = 744,
+  ATOM_TILE_REQUESTED = 745,
+  ATOM_STATE_RESPONSE_RECEIVED = 746,
+  ATOM_TILE_RESPONSE_RECEIVED = 747,
+  ATOM_INFLATION_FINISHED = 748,
+  ATOM_INFLATION_FAILED = 749,
+  ATOM_IGNORED_INFLATION_FAILURES_REPORTED = 750,
+  ATOM_DRAWABLE_RENDERED = 751,
+  ATOM_WEAR_TIME_SYNC_REQUESTED = 911,
+  ATOM_WEAR_TIME_UPDATE_STARTED = 912,
+  ATOM_WEAR_TIME_SYNC_ATTEMPT_COMPLETED = 913,
+  ATOM_WEAR_TIME_CHANGED = 914,
+  ATOM_WEAR_ADAPTIVE_SUSPEND_STATS_REPORTED = 619,
+  ATOM_WEAR_POWER_ANOMALY_SERVICE_OPERATIONAL_STATS_REPORTED = 620,
+  ATOM_WEAR_POWER_ANOMALY_SERVICE_EVENT_STATS_REPORTED = 621,
+  ATOM_WS_WEAR_TIME_SESSION = 610,
+  ATOM_WS_INCOMING_CALL_ACTION_REPORTED = 626,
+  ATOM_WS_CALL_DISCONNECTION_REPORTED = 627,
+  ATOM_WS_CALL_DURATION_REPORTED = 628,
+  ATOM_WS_CALL_USER_EXPERIENCE_LATENCY_REPORTED = 629,
+  ATOM_WS_CALL_INTERACTION_REPORTED = 630,
+  ATOM_WS_ON_BODY_STATE_CHANGED = 787,
+  ATOM_WS_WATCH_FACE_RESTRICTED_COMPLICATIONS_IMPACTED = 802,
+  ATOM_WS_WATCH_FACE_DEFAULT_RESTRICTED_COMPLICATIONS_REMOVED = 803,
+  ATOM_WS_COMPLICATIONS_IMPACTED_NOTIFICATION_EVENT_REPORTED = 804,
+  ATOM_WS_REMOTE_EVENT_USAGE_REPORTED = 920,
+  ATOM_WS_BUGREPORT_REQUESTED = 936,
+  ATOM_WS_BUGREPORT_TRIGGERED = 937,
+  ATOM_WS_BUGREPORT_FINISHED = 938,
+  ATOM_WS_BUGREPORT_RESULT_RECEIVED = 939,
+  ATOM_WS_STANDALONE_MODE_SNAPSHOT = 10197,
+  ATOM_WS_FAVORITE_WATCH_FACE_SNAPSHOT = 10206,
+  ATOM_WS_PHOTOS_WATCH_FACE_FEATURE_SNAPSHOT = 10225,
+  ATOM_WS_WATCH_FACE_CUSTOMIZATION_SNAPSHOT = 10227,
+  ATOM_WEAR_POWER_MENU_OPENED = 731,
+  ATOM_WEAR_ASSISTANT_OPENED = 755,
+  ATOM_FIRST_OVERLAY_STATE_CHANGED = 917,
+  ATOM_WIFI_AWARE_NDP_REPORTED = 638,
+  ATOM_WIFI_AWARE_ATTACH_REPORTED = 639,
+  ATOM_WIFI_SELF_RECOVERY_TRIGGERED = 661,
+  ATOM_SOFT_AP_STARTED = 680,
+  ATOM_SOFT_AP_STOPPED = 681,
+  ATOM_WIFI_LOCK_RELEASED = 687,
+  ATOM_WIFI_LOCK_DEACTIVATED = 688,
+  ATOM_WIFI_CONFIG_SAVED = 689,
+  ATOM_WIFI_AWARE_RESOURCE_USING_CHANGED = 690,
+  ATOM_WIFI_AWARE_HAL_API_CALLED = 691,
+  ATOM_WIFI_LOCAL_ONLY_REQUEST_RECEIVED = 692,
+  ATOM_WIFI_LOCAL_ONLY_REQUEST_SCAN_TRIGGERED = 693,
+  ATOM_WIFI_THREAD_TASK_EXECUTED = 694,
+  ATOM_WIFI_STATE_CHANGED = 700,
+  ATOM_PNO_SCAN_STARTED = 719,
+  ATOM_PNO_SCAN_STOPPED = 720,
+  ATOM_WIFI_IS_UNUSABLE_REPORTED = 722,
+  ATOM_WIFI_AP_CAPABILITIES_REPORTED = 723,
+  ATOM_SOFT_AP_STATE_CHANGED = 805,
+  ATOM_SCORER_PREDICTION_RESULT_REPORTED = 884,
+  ATOM_WIFI_AWARE_CAPABILITIES = 10190,
+  ATOM_WIFI_MODULE_INFO = 10193,
+  ATOM_WIFI_SETTING_INFO = 10194,
+  ATOM_WIFI_COMPLEX_SETTING_INFO = 10195,
+  ATOM_WIFI_CONFIGURED_NETWORK_INFO = 10198,
+};
+
+constexpr AtomId AtomId_MIN = AtomId::ATOM_UNSPECIFIED;
+constexpr AtomId AtomId_MAX = AtomId::ATOM_ATOM_99999;
 
-class AndroidSystemProperty_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  AndroidSystemProperty_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AndroidSystemProperty_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AndroidSystemProperty_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_values() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> values() const { return GetRepeated<::protozero::ConstBytes>(1); }
-};
 
-class AndroidSystemProperty : public ::protozero::Message {
- public:
-  using Decoder = AndroidSystemProperty_Decoder;
-  enum : int32_t {
-    kValuesFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.AndroidSystemProperty"; }
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* AtomId_Name(::perfetto::protos::pbzero::AtomId value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::AtomId::ATOM_UNSPECIFIED:
+    return "ATOM_UNSPECIFIED";
 
-  using PropertyValue = ::perfetto::protos::pbzero::AndroidSystemProperty_PropertyValue;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLE_SCAN_STATE_CHANGED:
+    return "ATOM_BLE_SCAN_STATE_CHANGED";
 
-  using FieldMetadata_Values =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AndroidSystemProperty_PropertyValue,
-      AndroidSystemProperty>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_STATE_CHANGED:
+    return "ATOM_PROCESS_STATE_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Values kValues() { return {}; }
-  template <typename T = AndroidSystemProperty_PropertyValue> T* add_values() {
-    return BeginNestedMessage<T>(1);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLE_SCAN_RESULT_RECEIVED:
+    return "ATOM_BLE_SCAN_RESULT_RECEIVED";
 
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SENSOR_STATE_CHANGED:
+    return "ATOM_SENSOR_STATE_CHANGED";
 
-class AndroidSystemProperty_PropertyValue_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  AndroidSystemProperty_PropertyValue_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AndroidSystemProperty_PropertyValue_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AndroidSystemProperty_PropertyValue_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_value() const { return at<2>().valid(); }
-  ::protozero::ConstChars value() const { return at<2>().as_string(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GPS_SCAN_STATE_CHANGED:
+    return "ATOM_GPS_SCAN_STATE_CHANGED";
 
-class AndroidSystemProperty_PropertyValue : public ::protozero::Message {
- public:
-  using Decoder = AndroidSystemProperty_PropertyValue_Decoder;
-  enum : int32_t {
-    kNameFieldNumber = 1,
-    kValueFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.AndroidSystemProperty.PropertyValue"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SYNC_STATE_CHANGED:
+    return "ATOM_SYNC_STATE_CHANGED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SCHEDULED_JOB_STATE_CHANGED:
+    return "ATOM_SCHEDULED_JOB_STATE_CHANGED";
 
-  using FieldMetadata_Name =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      AndroidSystemProperty_PropertyValue>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SCREEN_BRIGHTNESS_CHANGED:
+    return "ATOM_SCREEN_BRIGHTNESS_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WAKELOCK_STATE_CHANGED:
+    return "ATOM_WAKELOCK_STATE_CHANGED";
 
-  using FieldMetadata_Value =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      AndroidSystemProperty_PropertyValue>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LONG_PARTIAL_WAKELOCK_STATE_CHANGED:
+    return "ATOM_LONG_PARTIAL_WAKELOCK_STATE_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
-  }
-  void set_value(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
-  }
-  void set_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_RADIO_POWER_STATE_CHANGED:
+    return "ATOM_MOBILE_RADIO_POWER_STATE_CHANGED";
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/android/camera_event.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_RADIO_POWER_STATE_CHANGED:
+    return "ATOM_WIFI_RADIO_POWER_STATE_CHANGED";
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_CAMERA_EVENT_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_CAMERA_EVENT_PROTO_H_
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ACTIVITY_MANAGER_SLEEP_STATE_CHANGED:
+    return "ATOM_ACTIVITY_MANAGER_SLEEP_STATE_CHANGED";
 
-#include <stddef.h>
-#include <stdint.h>
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEMORY_FACTOR_STATE_CHANGED:
+    return "ATOM_MEMORY_FACTOR_STATE_CHANGED";
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  case ::perfetto::protos::pbzero::AtomId::ATOM_EXCESSIVE_CPU_USAGE_REPORTED:
+    return "ATOM_EXCESSIVE_CPU_USAGE_REPORTED";
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CACHED_KILL_REPORTED:
+    return "ATOM_CACHED_KILL_REPORTED";
 
-class AndroidCameraFrameEvent_CameraNodeProcessingDetails;
-class AndroidCameraSessionStats_CameraGraph;
-class AndroidCameraSessionStats_CameraGraph_CameraEdge;
-class AndroidCameraSessionStats_CameraGraph_CameraNode;
-namespace perfetto_pbzero_enum_AndroidCameraFrameEvent {
-enum CaptureResultStatus : int32_t;
-}  // namespace perfetto_pbzero_enum_AndroidCameraFrameEvent
-using AndroidCameraFrameEvent_CaptureResultStatus = perfetto_pbzero_enum_AndroidCameraFrameEvent::CaptureResultStatus;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_MEMORY_STAT_REPORTED:
+    return "ATOM_PROCESS_MEMORY_STAT_REPORTED";
 
-namespace perfetto_pbzero_enum_AndroidCameraFrameEvent {
-enum CaptureResultStatus : int32_t {
-  STATUS_UNSPECIFIED = 0,
-  STATUS_OK = 1,
-  STATUS_EARLY_METADATA_ERROR = 2,
-  STATUS_FINAL_METADATA_ERROR = 3,
-  STATUS_BUFFER_ERROR = 4,
-  STATUS_FLUSH_ERROR = 5,
-};
-} // namespace perfetto_pbzero_enum_AndroidCameraFrameEvent
-using AndroidCameraFrameEvent_CaptureResultStatus = perfetto_pbzero_enum_AndroidCameraFrameEvent::CaptureResultStatus;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LAUNCHER_EVENT:
+    return "ATOM_LAUNCHER_EVENT";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_SAVER_MODE_STATE_CHANGED:
+    return "ATOM_BATTERY_SAVER_MODE_STATE_CHANGED";
 
-constexpr AndroidCameraFrameEvent_CaptureResultStatus AndroidCameraFrameEvent_CaptureResultStatus_MIN = AndroidCameraFrameEvent_CaptureResultStatus::STATUS_UNSPECIFIED;
-constexpr AndroidCameraFrameEvent_CaptureResultStatus AndroidCameraFrameEvent_CaptureResultStatus_MAX = AndroidCameraFrameEvent_CaptureResultStatus::STATUS_FLUSH_ERROR;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_IDLE_MODE_STATE_CHANGED:
+    return "ATOM_DEVICE_IDLE_MODE_STATE_CHANGED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_IDLING_MODE_STATE_CHANGED:
+    return "ATOM_DEVICE_IDLING_MODE_STATE_CHANGED";
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* AndroidCameraFrameEvent_CaptureResultStatus_Name(::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_UNSPECIFIED:
-    return "STATUS_UNSPECIFIED";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AUDIO_STATE_CHANGED:
+    return "ATOM_AUDIO_STATE_CHANGED";
 
-  case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_OK:
-    return "STATUS_OK";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CODEC_STATE_CHANGED:
+    return "ATOM_MEDIA_CODEC_STATE_CHANGED";
 
-  case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_EARLY_METADATA_ERROR:
-    return "STATUS_EARLY_METADATA_ERROR";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CAMERA_STATE_CHANGED:
+    return "ATOM_CAMERA_STATE_CHANGED";
 
-  case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_FINAL_METADATA_ERROR:
-    return "STATUS_FINAL_METADATA_ERROR";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_FLASHLIGHT_STATE_CHANGED:
+    return "ATOM_FLASHLIGHT_STATE_CHANGED";
 
-  case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_BUFFER_ERROR:
-    return "STATUS_BUFFER_ERROR";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_UID_PROCESS_STATE_CHANGED:
+    return "ATOM_UID_PROCESS_STATE_CHANGED";
 
-  case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_FLUSH_ERROR:
-    return "STATUS_FLUSH_ERROR";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_LIFE_CYCLE_STATE_CHANGED:
+    return "ATOM_PROCESS_LIFE_CYCLE_STATE_CHANGED";
 
-class AndroidCameraSessionStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  AndroidCameraSessionStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AndroidCameraSessionStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AndroidCameraSessionStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_session_id() const { return at<1>().valid(); }
-  uint64_t session_id() const { return at<1>().as_uint64(); }
-  bool has_graph() const { return at<2>().valid(); }
-  ::protozero::ConstBytes graph() const { return at<2>().as_bytes(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SCREEN_STATE_CHANGED:
+    return "ATOM_SCREEN_STATE_CHANGED";
 
-class AndroidCameraSessionStats : public ::protozero::Message {
- public:
-  using Decoder = AndroidCameraSessionStats_Decoder;
-  enum : int32_t {
-    kSessionIdFieldNumber = 1,
-    kGraphFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraSessionStats"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_LEVEL_CHANGED:
+    return "ATOM_BATTERY_LEVEL_CHANGED";
 
-  using CameraGraph = ::perfetto::protos::pbzero::AndroidCameraSessionStats_CameraGraph;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CHARGING_STATE_CHANGED:
+    return "ATOM_CHARGING_STATE_CHANGED";
 
-  using FieldMetadata_SessionId =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      AndroidCameraSessionStats>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PLUGGED_STATE_CHANGED:
+    return "ATOM_PLUGGED_STATE_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SessionId kSessionId() { return {}; }
-  void set_session_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SessionId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_INTERACTIVE_STATE_CHANGED:
+    return "ATOM_INTERACTIVE_STATE_CHANGED";
 
-  using FieldMetadata_Graph =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AndroidCameraSessionStats_CameraGraph,
-      AndroidCameraSessionStats>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TOUCH_EVENT_REPORTED:
+    return "ATOM_TOUCH_EVENT_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Graph kGraph() { return {}; }
-  template <typename T = AndroidCameraSessionStats_CameraGraph> T* set_graph() {
-    return BeginNestedMessage<T>(2);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WAKEUP_ALARM_OCCURRED:
+    return "ATOM_WAKEUP_ALARM_OCCURRED";
 
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_KERNEL_WAKEUP_REPORTED:
+    return "ATOM_KERNEL_WAKEUP_REPORTED";
 
-class AndroidCameraSessionStats_CameraGraph_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  AndroidCameraSessionStats_CameraGraph_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AndroidCameraSessionStats_CameraGraph_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AndroidCameraSessionStats_CameraGraph_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_nodes() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> nodes() const { return GetRepeated<::protozero::ConstBytes>(1); }
-  bool has_edges() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> edges() const { return GetRepeated<::protozero::ConstBytes>(2); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_LOCK_STATE_CHANGED:
+    return "ATOM_WIFI_LOCK_STATE_CHANGED";
 
-class AndroidCameraSessionStats_CameraGraph : public ::protozero::Message {
- public:
-  using Decoder = AndroidCameraSessionStats_CameraGraph_Decoder;
-  enum : int32_t {
-    kNodesFieldNumber = 1,
-    kEdgesFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraSessionStats.CameraGraph"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_SIGNAL_STRENGTH_CHANGED:
+    return "ATOM_WIFI_SIGNAL_STRENGTH_CHANGED";
 
-  using CameraNode = ::perfetto::protos::pbzero::AndroidCameraSessionStats_CameraGraph_CameraNode;
-  using CameraEdge = ::perfetto::protos::pbzero::AndroidCameraSessionStats_CameraGraph_CameraEdge;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_SCAN_STATE_CHANGED:
+    return "ATOM_WIFI_SCAN_STATE_CHANGED";
 
-  using FieldMetadata_Nodes =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AndroidCameraSessionStats_CameraGraph_CameraNode,
-      AndroidCameraSessionStats_CameraGraph>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PHONE_SIGNAL_STRENGTH_CHANGED:
+    return "ATOM_PHONE_SIGNAL_STRENGTH_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nodes kNodes() { return {}; }
-  template <typename T = AndroidCameraSessionStats_CameraGraph_CameraNode> T* add_nodes() {
-    return BeginNestedMessage<T>(1);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SETTING_CHANGED:
+    return "ATOM_SETTING_CHANGED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ACTIVITY_FOREGROUND_STATE_CHANGED:
+    return "ATOM_ACTIVITY_FOREGROUND_STATE_CHANGED";
 
-  using FieldMetadata_Edges =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AndroidCameraSessionStats_CameraGraph_CameraEdge,
-      AndroidCameraSessionStats_CameraGraph>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ISOLATED_UID_CHANGED:
+    return "ATOM_ISOLATED_UID_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Edges kEdges() { return {}; }
-  template <typename T = AndroidCameraSessionStats_CameraGraph_CameraEdge> T* add_edges() {
-    return BeginNestedMessage<T>(2);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PACKET_WAKEUP_OCCURRED:
+    return "ATOM_PACKET_WAKEUP_OCCURRED";
 
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WALL_CLOCK_TIME_SHIFTED:
+    return "ATOM_WALL_CLOCK_TIME_SHIFTED";
 
-class AndroidCameraSessionStats_CameraGraph_CameraEdge_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  AndroidCameraSessionStats_CameraGraph_CameraEdge_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AndroidCameraSessionStats_CameraGraph_CameraEdge_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AndroidCameraSessionStats_CameraGraph_CameraEdge_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_output_node_id() const { return at<1>().valid(); }
-  int64_t output_node_id() const { return at<1>().as_int64(); }
-  bool has_output_id() const { return at<2>().valid(); }
-  int64_t output_id() const { return at<2>().as_int64(); }
-  bool has_input_node_id() const { return at<3>().valid(); }
-  int64_t input_node_id() const { return at<3>().as_int64(); }
-  bool has_input_id() const { return at<4>().valid(); }
-  int64_t input_id() const { return at<4>().as_int64(); }
-  bool has_vendor_data_version() const { return at<5>().valid(); }
-  int32_t vendor_data_version() const { return at<5>().as_int32(); }
-  bool has_vendor_data() const { return at<6>().valid(); }
-  ::protozero::ConstBytes vendor_data() const { return at<6>().as_bytes(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ANOMALY_DETECTED:
+    return "ATOM_ANOMALY_DETECTED";
 
-class AndroidCameraSessionStats_CameraGraph_CameraEdge : public ::protozero::Message {
- public:
-  using Decoder = AndroidCameraSessionStats_CameraGraph_CameraEdge_Decoder;
-  enum : int32_t {
-    kOutputNodeIdFieldNumber = 1,
-    kOutputIdFieldNumber = 2,
-    kInputNodeIdFieldNumber = 3,
-    kInputIdFieldNumber = 4,
-    kVendorDataVersionFieldNumber = 5,
-    kVendorDataFieldNumber = 6,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraEdge"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_BREADCRUMB_REPORTED:
+    return "ATOM_APP_BREADCRUMB_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_START_OCCURRED:
+    return "ATOM_APP_START_OCCURRED";
 
-  using FieldMetadata_OutputNodeId =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      AndroidCameraSessionStats_CameraGraph_CameraEdge>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_START_CANCELED:
+    return "ATOM_APP_START_CANCELED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OutputNodeId kOutputNodeId() { return {}; }
-  void set_output_node_id(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OutputNodeId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_START_FULLY_DRAWN:
+    return "ATOM_APP_START_FULLY_DRAWN";
 
-  using FieldMetadata_OutputId =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      AndroidCameraSessionStats_CameraGraph_CameraEdge>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LMK_KILL_OCCURRED:
+    return "ATOM_LMK_KILL_OCCURRED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OutputId kOutputId() { return {}; }
-  void set_output_id(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OutputId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PICTURE_IN_PICTURE_STATE_CHANGED:
+    return "ATOM_PICTURE_IN_PICTURE_STATE_CHANGED";
 
-  using FieldMetadata_InputNodeId =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      AndroidCameraSessionStats_CameraGraph_CameraEdge>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_MULTICAST_LOCK_STATE_CHANGED:
+    return "ATOM_WIFI_MULTICAST_LOCK_STATE_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InputNodeId kInputNodeId() { return {}; }
-  void set_input_node_id(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_InputNodeId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_START_MEMORY_STATE_CAPTURED:
+    return "ATOM_APP_START_MEMORY_STATE_CAPTURED";
 
-  using FieldMetadata_InputId =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      AndroidCameraSessionStats_CameraGraph_CameraEdge>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SHUTDOWN_SEQUENCE_REPORTED:
+    return "ATOM_SHUTDOWN_SEQUENCE_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InputId kInputId() { return {}; }
-  void set_input_id(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_InputId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BOOT_SEQUENCE_REPORTED:
+    return "ATOM_BOOT_SEQUENCE_REPORTED";
 
-  using FieldMetadata_VendorDataVersion =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      AndroidCameraSessionStats_CameraGraph_CameraEdge>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_OVERLAY_STATE_CHANGED:
+    return "ATOM_OVERLAY_STATE_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VendorDataVersion kVendorDataVersion() { return {}; }
-  void set_vendor_data_version(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VendorDataVersion::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_FOREGROUND_SERVICE_STATE_CHANGED:
+    return "ATOM_FOREGROUND_SERVICE_STATE_CHANGED";
 
-  using FieldMetadata_VendorData =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBytes,
-      std::string,
-      AndroidCameraSessionStats_CameraGraph_CameraEdge>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CALL_STATE_CHANGED:
+    return "ATOM_CALL_STATE_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VendorData kVendorData() { return {}; }
-  void set_vendor_data(const uint8_t* data, size_t size) {
-    AppendBytes(FieldMetadata_VendorData::kFieldId, data, size);
-  }
-  void set_vendor_data(::protozero::ConstBytes bytes) {
-    AppendBytes(FieldMetadata_VendorData::kFieldId, bytes.data, bytes.size);
-  }
-  void set_vendor_data(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_VendorData::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBytes>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_KEYGUARD_STATE_CHANGED:
+    return "ATOM_KEYGUARD_STATE_CHANGED";
 
-class AndroidCameraSessionStats_CameraGraph_CameraNode_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  AndroidCameraSessionStats_CameraGraph_CameraNode_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AndroidCameraSessionStats_CameraGraph_CameraNode_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AndroidCameraSessionStats_CameraGraph_CameraNode_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_node_id() const { return at<1>().valid(); }
-  int64_t node_id() const { return at<1>().as_int64(); }
-  bool has_input_ids() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<int64_t> input_ids() const { return GetRepeated<int64_t>(2); }
-  bool has_output_ids() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<int64_t> output_ids() const { return GetRepeated<int64_t>(3); }
-  bool has_vendor_data_version() const { return at<4>().valid(); }
-  int32_t vendor_data_version() const { return at<4>().as_int32(); }
-  bool has_vendor_data() const { return at<5>().valid(); }
-  ::protozero::ConstBytes vendor_data() const { return at<5>().as_bytes(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_KEYGUARD_BOUNCER_STATE_CHANGED:
+    return "ATOM_KEYGUARD_BOUNCER_STATE_CHANGED";
 
-class AndroidCameraSessionStats_CameraGraph_CameraNode : public ::protozero::Message {
- public:
-  using Decoder = AndroidCameraSessionStats_CameraGraph_CameraNode_Decoder;
-  enum : int32_t {
-    kNodeIdFieldNumber = 1,
-    kInputIdsFieldNumber = 2,
-    kOutputIdsFieldNumber = 3,
-    kVendorDataVersionFieldNumber = 4,
-    kVendorDataFieldNumber = 5,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraNode"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_KEYGUARD_BOUNCER_PASSWORD_ENTERED:
+    return "ATOM_KEYGUARD_BOUNCER_PASSWORD_ENTERED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_DIED:
+    return "ATOM_APP_DIED";
 
-  using FieldMetadata_NodeId =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      AndroidCameraSessionStats_CameraGraph_CameraNode>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RESOURCE_CONFIGURATION_CHANGED:
+    return "ATOM_RESOURCE_CONFIGURATION_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NodeId kNodeId() { return {}; }
-  void set_node_id(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NodeId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_ENABLED_STATE_CHANGED:
+    return "ATOM_BLUETOOTH_ENABLED_STATE_CHANGED";
 
-  using FieldMetadata_InputIds =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      AndroidCameraSessionStats_CameraGraph_CameraNode>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_CONNECTION_STATE_CHANGED:
+    return "ATOM_BLUETOOTH_CONNECTION_STATE_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InputIds kInputIds() { return {}; }
-  void add_input_ids(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_InputIds::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GPS_SIGNAL_QUALITY_CHANGED:
+    return "ATOM_GPS_SIGNAL_QUALITY_CHANGED";
 
-  using FieldMetadata_OutputIds =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      AndroidCameraSessionStats_CameraGraph_CameraNode>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_USB_CONNECTOR_STATE_CHANGED:
+    return "ATOM_USB_CONNECTOR_STATE_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OutputIds kOutputIds() { return {}; }
-  void add_output_ids(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OutputIds::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SPEAKER_IMPEDANCE_REPORTED:
+    return "ATOM_SPEAKER_IMPEDANCE_REPORTED";
 
-  using FieldMetadata_VendorDataVersion =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      AndroidCameraSessionStats_CameraGraph_CameraNode>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HARDWARE_FAILED:
+    return "ATOM_HARDWARE_FAILED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VendorDataVersion kVendorDataVersion() { return {}; }
-  void set_vendor_data_version(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VendorDataVersion::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PHYSICAL_DROP_DETECTED:
+    return "ATOM_PHYSICAL_DROP_DETECTED";
 
-  using FieldMetadata_VendorData =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBytes,
-      std::string,
-      AndroidCameraSessionStats_CameraGraph_CameraNode>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CHARGE_CYCLES_REPORTED:
+    return "ATOM_CHARGE_CYCLES_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VendorData kVendorData() { return {}; }
-  void set_vendor_data(const uint8_t* data, size_t size) {
-    AppendBytes(FieldMetadata_VendorData::kFieldId, data, size);
-  }
-  void set_vendor_data(::protozero::ConstBytes bytes) {
-    AppendBytes(FieldMetadata_VendorData::kFieldId, bytes.data, bytes.size);
-  }
-  void set_vendor_data(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_VendorData::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBytes>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_CONNECTION_STATE_CHANGED:
+    return "ATOM_MOBILE_CONNECTION_STATE_CHANGED";
 
-class AndroidCameraFrameEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/16, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  AndroidCameraFrameEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AndroidCameraFrameEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AndroidCameraFrameEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_session_id() const { return at<1>().valid(); }
-  uint64_t session_id() const { return at<1>().as_uint64(); }
-  bool has_camera_id() const { return at<2>().valid(); }
-  uint32_t camera_id() const { return at<2>().as_uint32(); }
-  bool has_frame_number() const { return at<3>().valid(); }
-  int64_t frame_number() const { return at<3>().as_int64(); }
-  bool has_request_id() const { return at<4>().valid(); }
-  int64_t request_id() const { return at<4>().as_int64(); }
-  bool has_request_received_ns() const { return at<5>().valid(); }
-  int64_t request_received_ns() const { return at<5>().as_int64(); }
-  bool has_request_processing_started_ns() const { return at<6>().valid(); }
-  int64_t request_processing_started_ns() const { return at<6>().as_int64(); }
-  bool has_start_of_exposure_ns() const { return at<7>().valid(); }
-  int64_t start_of_exposure_ns() const { return at<7>().as_int64(); }
-  bool has_start_of_frame_ns() const { return at<8>().valid(); }
-  int64_t start_of_frame_ns() const { return at<8>().as_int64(); }
-  bool has_responses_all_sent_ns() const { return at<9>().valid(); }
-  int64_t responses_all_sent_ns() const { return at<9>().as_int64(); }
-  bool has_capture_result_status() const { return at<10>().valid(); }
-  int32_t capture_result_status() const { return at<10>().as_int32(); }
-  bool has_skipped_sensor_frames() const { return at<11>().valid(); }
-  int32_t skipped_sensor_frames() const { return at<11>().as_int32(); }
-  bool has_capture_intent() const { return at<12>().valid(); }
-  int32_t capture_intent() const { return at<12>().as_int32(); }
-  bool has_num_streams() const { return at<13>().valid(); }
-  int32_t num_streams() const { return at<13>().as_int32(); }
-  bool has_node_processing_details() const { return at<14>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> node_processing_details() const { return GetRepeated<::protozero::ConstBytes>(14); }
-  bool has_vendor_data_version() const { return at<15>().valid(); }
-  int32_t vendor_data_version() const { return at<15>().as_int32(); }
-  bool has_vendor_data() const { return at<16>().valid(); }
-  ::protozero::ConstBytes vendor_data() const { return at<16>().as_bytes(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_RADIO_TECHNOLOGY_CHANGED:
+    return "ATOM_MOBILE_RADIO_TECHNOLOGY_CHANGED";
 
-class AndroidCameraFrameEvent : public ::protozero::Message {
- public:
-  using Decoder = AndroidCameraFrameEvent_Decoder;
-  enum : int32_t {
-    kSessionIdFieldNumber = 1,
-    kCameraIdFieldNumber = 2,
-    kFrameNumberFieldNumber = 3,
-    kRequestIdFieldNumber = 4,
-    kRequestReceivedNsFieldNumber = 5,
-    kRequestProcessingStartedNsFieldNumber = 6,
-    kStartOfExposureNsFieldNumber = 7,
-    kStartOfFrameNsFieldNumber = 8,
-    kResponsesAllSentNsFieldNumber = 9,
-    kCaptureResultStatusFieldNumber = 10,
-    kSkippedSensorFramesFieldNumber = 11,
-    kCaptureIntentFieldNumber = 12,
-    kNumStreamsFieldNumber = 13,
-    kNodeProcessingDetailsFieldNumber = 14,
-    kVendorDataVersionFieldNumber = 15,
-    kVendorDataFieldNumber = 16,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraFrameEvent"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_USB_DEVICE_ATTACHED:
+    return "ATOM_USB_DEVICE_ATTACHED";
 
-  using CameraNodeProcessingDetails = ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CameraNodeProcessingDetails;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_CRASH_OCCURRED:
+    return "ATOM_APP_CRASH_OCCURRED";
 
-  using CaptureResultStatus = ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus;
-  static inline const char* CaptureResultStatus_Name(CaptureResultStatus value) {
-    return ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus_Name(value);
-  }
-  static const CaptureResultStatus STATUS_UNSPECIFIED = CaptureResultStatus::STATUS_UNSPECIFIED;
-  static const CaptureResultStatus STATUS_OK = CaptureResultStatus::STATUS_OK;
-  static const CaptureResultStatus STATUS_EARLY_METADATA_ERROR = CaptureResultStatus::STATUS_EARLY_METADATA_ERROR;
-  static const CaptureResultStatus STATUS_FINAL_METADATA_ERROR = CaptureResultStatus::STATUS_FINAL_METADATA_ERROR;
-  static const CaptureResultStatus STATUS_BUFFER_ERROR = CaptureResultStatus::STATUS_BUFFER_ERROR;
-  static const CaptureResultStatus STATUS_FLUSH_ERROR = CaptureResultStatus::STATUS_FLUSH_ERROR;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ANR_OCCURRED:
+    return "ATOM_ANR_OCCURRED";
 
-  using FieldMetadata_SessionId =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      AndroidCameraFrameEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WTF_OCCURRED:
+    return "ATOM_WTF_OCCURRED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SessionId kSessionId() { return {}; }
-  void set_session_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SessionId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LOW_MEM_REPORTED:
+    return "ATOM_LOW_MEM_REPORTED";
 
-  using FieldMetadata_CameraId =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      AndroidCameraFrameEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GENERIC_ATOM:
+    return "ATOM_GENERIC_ATOM";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CameraId kCameraId() { return {}; }
-  void set_camera_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CameraId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_VIBRATOR_STATE_CHANGED:
+    return "ATOM_VIBRATOR_STATE_CHANGED";
 
-  using FieldMetadata_FrameNumber =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      AndroidCameraFrameEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEFERRED_JOB_STATS_REPORTED:
+    return "ATOM_DEFERRED_JOB_STATS_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FrameNumber kFrameNumber() { return {}; }
-  void set_frame_number(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FrameNumber::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_THERMAL_THROTTLING:
+    return "ATOM_THERMAL_THROTTLING";
 
-  using FieldMetadata_RequestId =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      AndroidCameraFrameEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BIOMETRIC_ACQUIRED:
+    return "ATOM_BIOMETRIC_ACQUIRED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RequestId kRequestId() { return {}; }
-  void set_request_id(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RequestId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BIOMETRIC_AUTHENTICATED:
+    return "ATOM_BIOMETRIC_AUTHENTICATED";
 
-  using FieldMetadata_RequestReceivedNs =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      AndroidCameraFrameEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BIOMETRIC_ERROR_OCCURRED:
+    return "ATOM_BIOMETRIC_ERROR_OCCURRED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RequestReceivedNs kRequestReceivedNs() { return {}; }
-  void set_request_received_ns(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RequestReceivedNs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_UI_EVENT_REPORTED:
+    return "ATOM_UI_EVENT_REPORTED";
 
-  using FieldMetadata_RequestProcessingStartedNs =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      AndroidCameraFrameEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_HEALTH_SNAPSHOT:
+    return "ATOM_BATTERY_HEALTH_SNAPSHOT";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RequestProcessingStartedNs kRequestProcessingStartedNs() { return {}; }
-  void set_request_processing_started_ns(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RequestProcessingStartedNs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SLOW_IO:
+    return "ATOM_SLOW_IO";
 
-  using FieldMetadata_StartOfExposureNs =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      AndroidCameraFrameEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_CAUSED_SHUTDOWN:
+    return "ATOM_BATTERY_CAUSED_SHUTDOWN";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StartOfExposureNs kStartOfExposureNs() { return {}; }
-  void set_start_of_exposure_ns(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StartOfExposureNs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PHONE_SERVICE_STATE_CHANGED:
+    return "ATOM_PHONE_SERVICE_STATE_CHANGED";
 
-  using FieldMetadata_StartOfFrameNs =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      AndroidCameraFrameEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PHONE_STATE_CHANGED:
+    return "ATOM_PHONE_STATE_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StartOfFrameNs kStartOfFrameNs() { return {}; }
-  void set_start_of_frame_ns(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StartOfFrameNs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_USER_RESTRICTION_CHANGED:
+    return "ATOM_USER_RESTRICTION_CHANGED";
 
-  using FieldMetadata_ResponsesAllSentNs =
-    ::protozero::proto_utils::FieldMetadata<
-      9,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      AndroidCameraFrameEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SETTINGS_UI_CHANGED:
+    return "ATOM_SETTINGS_UI_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ResponsesAllSentNs kResponsesAllSentNs() { return {}; }
-  void set_responses_all_sent_ns(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ResponsesAllSentNs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CONNECTIVITY_STATE_CHANGED:
+    return "ATOM_CONNECTIVITY_STATE_CHANGED";
 
-  using FieldMetadata_CaptureResultStatus =
-    ::protozero::proto_utils::FieldMetadata<
-      10,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus,
-      AndroidCameraFrameEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SERVICE_STATE_CHANGED:
+    return "ATOM_SERVICE_STATE_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CaptureResultStatus kCaptureResultStatus() { return {}; }
-  void set_capture_result_status(::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus value) {
-    static constexpr uint32_t field_id = FieldMetadata_CaptureResultStatus::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SERVICE_LAUNCH_REPORTED:
+    return "ATOM_SERVICE_LAUNCH_REPORTED";
 
-  using FieldMetadata_SkippedSensorFrames =
-    ::protozero::proto_utils::FieldMetadata<
-      11,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      AndroidCameraFrameEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_FLAG_FLIP_UPDATE_OCCURRED:
+    return "ATOM_FLAG_FLIP_UPDATE_OCCURRED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SkippedSensorFrames kSkippedSensorFrames() { return {}; }
-  void set_skipped_sensor_frames(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SkippedSensorFrames::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BINARY_PUSH_STATE_CHANGED:
+    return "ATOM_BINARY_PUSH_STATE_CHANGED";
 
-  using FieldMetadata_CaptureIntent =
-    ::protozero::proto_utils::FieldMetadata<
-      12,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      AndroidCameraFrameEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_POLICY_EVENT:
+    return "ATOM_DEVICE_POLICY_EVENT";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CaptureIntent kCaptureIntent() { return {}; }
-  void set_capture_intent(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CaptureIntent::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_FILE_OP_CANCELED:
+    return "ATOM_DOCS_UI_FILE_OP_CANCELED";
 
-  using FieldMetadata_NumStreams =
-    ::protozero::proto_utils::FieldMetadata<
-      13,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      AndroidCameraFrameEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_FILE_OP_COPY_MOVE_MODE_REPORTED:
+    return "ATOM_DOCS_UI_FILE_OP_COPY_MOVE_MODE_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NumStreams kNumStreams() { return {}; }
-  void set_num_streams(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NumStreams::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_FILE_OP_FAILURE:
+    return "ATOM_DOCS_UI_FILE_OP_FAILURE";
 
-  using FieldMetadata_NodeProcessingDetails =
-    ::protozero::proto_utils::FieldMetadata<
-      14,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AndroidCameraFrameEvent_CameraNodeProcessingDetails,
-      AndroidCameraFrameEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_PROVIDER_FILE_OP:
+    return "ATOM_DOCS_UI_PROVIDER_FILE_OP";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NodeProcessingDetails kNodeProcessingDetails() { return {}; }
-  template <typename T = AndroidCameraFrameEvent_CameraNodeProcessingDetails> T* add_node_processing_details() {
-    return BeginNestedMessage<T>(14);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_INVALID_SCOPED_ACCESS_REQUEST:
+    return "ATOM_DOCS_UI_INVALID_SCOPED_ACCESS_REQUEST";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_LAUNCH_REPORTED:
+    return "ATOM_DOCS_UI_LAUNCH_REPORTED";
 
-  using FieldMetadata_VendorDataVersion =
-    ::protozero::proto_utils::FieldMetadata<
-      15,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      AndroidCameraFrameEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_ROOT_VISITED:
+    return "ATOM_DOCS_UI_ROOT_VISITED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VendorDataVersion kVendorDataVersion() { return {}; }
-  void set_vendor_data_version(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VendorDataVersion::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_STARTUP_MS:
+    return "ATOM_DOCS_UI_STARTUP_MS";
 
-  using FieldMetadata_VendorData =
-    ::protozero::proto_utils::FieldMetadata<
-      16,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBytes,
-      std::string,
-      AndroidCameraFrameEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_USER_ACTION_REPORTED:
+    return "ATOM_DOCS_UI_USER_ACTION_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VendorData kVendorData() { return {}; }
-  void set_vendor_data(const uint8_t* data, size_t size) {
-    AppendBytes(FieldMetadata_VendorData::kFieldId, data, size);
-  }
-  void set_vendor_data(::protozero::ConstBytes bytes) {
-    AppendBytes(FieldMetadata_VendorData::kFieldId, bytes.data, bytes.size);
-  }
-  void set_vendor_data(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_VendorData::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBytes>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_ENABLED_STATE_CHANGED:
+    return "ATOM_WIFI_ENABLED_STATE_CHANGED";
 
-class AndroidCameraFrameEvent_CameraNodeProcessingDetails_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  AndroidCameraFrameEvent_CameraNodeProcessingDetails_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AndroidCameraFrameEvent_CameraNodeProcessingDetails_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AndroidCameraFrameEvent_CameraNodeProcessingDetails_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_node_id() const { return at<1>().valid(); }
-  int64_t node_id() const { return at<1>().as_int64(); }
-  bool has_start_processing_ns() const { return at<2>().valid(); }
-  int64_t start_processing_ns() const { return at<2>().as_int64(); }
-  bool has_end_processing_ns() const { return at<3>().valid(); }
-  int64_t end_processing_ns() const { return at<3>().as_int64(); }
-  bool has_scheduling_latency_ns() const { return at<4>().valid(); }
-  int64_t scheduling_latency_ns() const { return at<4>().as_int64(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_RUNNING_STATE_CHANGED:
+    return "ATOM_WIFI_RUNNING_STATE_CHANGED";
 
-class AndroidCameraFrameEvent_CameraNodeProcessingDetails : public ::protozero::Message {
- public:
-  using Decoder = AndroidCameraFrameEvent_CameraNodeProcessingDetails_Decoder;
-  enum : int32_t {
-    kNodeIdFieldNumber = 1,
-    kStartProcessingNsFieldNumber = 2,
-    kEndProcessingNsFieldNumber = 3,
-    kSchedulingLatencyNsFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraFrameEvent.CameraNodeProcessingDetails"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_COMPACTED:
+    return "ATOM_APP_COMPACTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_DNS_EVENT_REPORTED:
+    return "ATOM_NETWORK_DNS_EVENT_REPORTED";
 
-  using FieldMetadata_NodeId =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      AndroidCameraFrameEvent_CameraNodeProcessingDetails>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_PICKER_LAUNCHED_FROM_REPORTED:
+    return "ATOM_DOCS_UI_PICKER_LAUNCHED_FROM_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NodeId kNodeId() { return {}; }
-  void set_node_id(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NodeId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_PICK_RESULT_REPORTED:
+    return "ATOM_DOCS_UI_PICK_RESULT_REPORTED";
 
-  using FieldMetadata_StartProcessingNs =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      AndroidCameraFrameEvent_CameraNodeProcessingDetails>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_SEARCH_MODE_REPORTED:
+    return "ATOM_DOCS_UI_SEARCH_MODE_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StartProcessingNs kStartProcessingNs() { return {}; }
-  void set_start_processing_ns(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StartProcessingNs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_SEARCH_TYPE_REPORTED:
+    return "ATOM_DOCS_UI_SEARCH_TYPE_REPORTED";
 
-  using FieldMetadata_EndProcessingNs =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      AndroidCameraFrameEvent_CameraNodeProcessingDetails>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DATA_STALL_EVENT:
+    return "ATOM_DATA_STALL_EVENT";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EndProcessingNs kEndProcessingNs() { return {}; }
-  void set_end_processing_ns(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EndProcessingNs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RESCUE_PARTY_RESET_REPORTED:
+    return "ATOM_RESCUE_PARTY_RESET_REPORTED";
 
-  using FieldMetadata_SchedulingLatencyNs =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      AndroidCameraFrameEvent_CameraNodeProcessingDetails>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SIGNED_CONFIG_REPORTED:
+    return "ATOM_SIGNED_CONFIG_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SchedulingLatencyNs kSchedulingLatencyNs() { return {}; }
-  void set_scheduling_latency_ns(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SchedulingLatencyNs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GNSS_NI_EVENT_REPORTED:
+    return "ATOM_GNSS_NI_EVENT_REPORTED";
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/android/frame_timeline_event.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_LINK_LAYER_CONNECTION_EVENT:
+    return "ATOM_BLUETOOTH_LINK_LAYER_CONNECTION_EVENT";
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_FRAME_TIMELINE_EVENT_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_FRAME_TIMELINE_EVENT_PROTO_H_
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_ACL_CONNECTION_STATE_CHANGED:
+    return "ATOM_BLUETOOTH_ACL_CONNECTION_STATE_CHANGED";
 
-#include <stddef.h>
-#include <stdint.h>
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_SCO_CONNECTION_STATE_CHANGED:
+    return "ATOM_BLUETOOTH_SCO_CONNECTION_STATE_CHANGED";
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_DOWNGRADED:
+    return "ATOM_APP_DOWNGRADED";
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_OPTIMIZED_AFTER_DOWNGRADED:
+    return "ATOM_APP_OPTIMIZED_AFTER_DOWNGRADED";
 
-class FrameTimelineEvent_ActualDisplayFrameStart;
-class FrameTimelineEvent_ActualSurfaceFrameStart;
-class FrameTimelineEvent_ExpectedDisplayFrameStart;
-class FrameTimelineEvent_ExpectedSurfaceFrameStart;
-class FrameTimelineEvent_FrameEnd;
-namespace perfetto_pbzero_enum_FrameTimelineEvent {
-enum PredictionType : int32_t;
-}  // namespace perfetto_pbzero_enum_FrameTimelineEvent
-using FrameTimelineEvent_PredictionType = perfetto_pbzero_enum_FrameTimelineEvent::PredictionType;
-namespace perfetto_pbzero_enum_FrameTimelineEvent {
-enum PresentType : int32_t;
-}  // namespace perfetto_pbzero_enum_FrameTimelineEvent
-using FrameTimelineEvent_PresentType = perfetto_pbzero_enum_FrameTimelineEvent::PresentType;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LOW_STORAGE_STATE_CHANGED:
+    return "ATOM_LOW_STORAGE_STATE_CHANGED";
 
-namespace perfetto_pbzero_enum_FrameTimelineEvent {
-enum JankType : int32_t {
-  JANK_UNSPECIFIED = 0,
-  JANK_NONE = 1,
-  JANK_SF_SCHEDULING = 2,
-  JANK_PREDICTION_ERROR = 4,
-  JANK_DISPLAY_HAL = 8,
-  JANK_SF_CPU_DEADLINE_MISSED = 16,
-  JANK_SF_GPU_DEADLINE_MISSED = 32,
-  JANK_APP_DEADLINE_MISSED = 64,
-  JANK_BUFFER_STUFFING = 128,
-  JANK_UNKNOWN = 256,
-  JANK_SF_STUFFING = 512,
-};
-} // namespace perfetto_pbzero_enum_FrameTimelineEvent
-using FrameTimelineEvent_JankType = perfetto_pbzero_enum_FrameTimelineEvent::JankType;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GNSS_NFW_NOTIFICATION_REPORTED:
+    return "ATOM_GNSS_NFW_NOTIFICATION_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GNSS_CONFIGURATION_REPORTED:
+    return "ATOM_GNSS_CONFIGURATION_REPORTED";
 
-constexpr FrameTimelineEvent_JankType FrameTimelineEvent_JankType_MIN = FrameTimelineEvent_JankType::JANK_UNSPECIFIED;
-constexpr FrameTimelineEvent_JankType FrameTimelineEvent_JankType_MAX = FrameTimelineEvent_JankType::JANK_SF_STUFFING;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_USB_PORT_OVERHEAT_EVENT_REPORTED:
+    return "ATOM_USB_PORT_OVERHEAT_EVENT_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_ERROR_OCCURRED:
+    return "ATOM_NFC_ERROR_OCCURRED";
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* FrameTimelineEvent_JankType_Name(::perfetto::protos::pbzero::FrameTimelineEvent_JankType value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_UNSPECIFIED:
-    return "JANK_UNSPECIFIED";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_STATE_CHANGED:
+    return "ATOM_NFC_STATE_CHANGED";
 
-  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_NONE:
-    return "JANK_NONE";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_BEAM_OCCURRED:
+    return "ATOM_NFC_BEAM_OCCURRED";
 
-  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_SF_SCHEDULING:
-    return "JANK_SF_SCHEDULING";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_CARDEMULATION_OCCURRED:
+    return "ATOM_NFC_CARDEMULATION_OCCURRED";
 
-  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_PREDICTION_ERROR:
-    return "JANK_PREDICTION_ERROR";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_TAG_OCCURRED:
+    return "ATOM_NFC_TAG_OCCURRED";
 
-  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_DISPLAY_HAL:
-    return "JANK_DISPLAY_HAL";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_HCE_TRANSACTION_OCCURRED:
+    return "ATOM_NFC_HCE_TRANSACTION_OCCURRED";
 
-  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_SF_CPU_DEADLINE_MISSED:
-    return "JANK_SF_CPU_DEADLINE_MISSED";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SE_STATE_CHANGED:
+    return "ATOM_SE_STATE_CHANGED";
 
-  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_SF_GPU_DEADLINE_MISSED:
-    return "JANK_SF_GPU_DEADLINE_MISSED";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SE_OMAPI_REPORTED:
+    return "ATOM_SE_OMAPI_REPORTED";
 
-  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_APP_DEADLINE_MISSED:
-    return "JANK_APP_DEADLINE_MISSED";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BROADCAST_DISPATCH_LATENCY_REPORTED:
+    return "ATOM_BROADCAST_DISPATCH_LATENCY_REPORTED";
 
-  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_BUFFER_STUFFING:
-    return "JANK_BUFFER_STUFFING";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ATTENTION_MANAGER_SERVICE_RESULT_REPORTED:
+    return "ATOM_ATTENTION_MANAGER_SERVICE_RESULT_REPORTED";
 
-  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_UNKNOWN:
-    return "JANK_UNKNOWN";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ADB_CONNECTION_CHANGED:
+    return "ATOM_ADB_CONNECTION_CHANGED";
 
-  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_SF_STUFFING:
-    return "JANK_SF_STUFFING";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SPEECH_DSP_STAT_REPORTED:
+    return "ATOM_SPEECH_DSP_STAT_REPORTED";
 
-namespace perfetto_pbzero_enum_FrameTimelineEvent {
-enum PresentType : int32_t {
-  PRESENT_UNSPECIFIED = 0,
-  PRESENT_ON_TIME = 1,
-  PRESENT_LATE = 2,
-  PRESENT_EARLY = 3,
-  PRESENT_DROPPED = 4,
-  PRESENT_UNKNOWN = 5,
-};
-} // namespace perfetto_pbzero_enum_FrameTimelineEvent
-using FrameTimelineEvent_PresentType = perfetto_pbzero_enum_FrameTimelineEvent::PresentType;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_USB_CONTAMINANT_REPORTED:
+    return "ATOM_USB_CONTAMINANT_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WATCHDOG_ROLLBACK_OCCURRED:
+    return "ATOM_WATCHDOG_ROLLBACK_OCCURRED";
 
-constexpr FrameTimelineEvent_PresentType FrameTimelineEvent_PresentType_MIN = FrameTimelineEvent_PresentType::PRESENT_UNSPECIFIED;
-constexpr FrameTimelineEvent_PresentType FrameTimelineEvent_PresentType_MAX = FrameTimelineEvent_PresentType::PRESENT_UNKNOWN;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BIOMETRIC_SYSTEM_HEALTH_ISSUE_DETECTED:
+    return "ATOM_BIOMETRIC_SYSTEM_HEALTH_ISSUE_DETECTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BUBBLE_UI_CHANGED:
+    return "ATOM_BUBBLE_UI_CHANGED";
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* FrameTimelineEvent_PresentType_Name(::perfetto::protos::pbzero::FrameTimelineEvent_PresentType value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_UNSPECIFIED:
-    return "PRESENT_UNSPECIFIED";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SCHEDULED_JOB_CONSTRAINT_CHANGED:
+    return "ATOM_SCHEDULED_JOB_CONSTRAINT_CHANGED";
 
-  case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_ON_TIME:
-    return "PRESENT_ON_TIME";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_ACTIVE_DEVICE_CHANGED:
+    return "ATOM_BLUETOOTH_ACTIVE_DEVICE_CHANGED";
 
-  case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_LATE:
-    return "PRESENT_LATE";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_A2DP_PLAYBACK_STATE_CHANGED:
+    return "ATOM_BLUETOOTH_A2DP_PLAYBACK_STATE_CHANGED";
 
-  case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_EARLY:
-    return "PRESENT_EARLY";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_A2DP_CODEC_CONFIG_CHANGED:
+    return "ATOM_BLUETOOTH_A2DP_CODEC_CONFIG_CHANGED";
 
-  case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_DROPPED:
-    return "PRESENT_DROPPED";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_A2DP_CODEC_CAPABILITY_CHANGED:
+    return "ATOM_BLUETOOTH_A2DP_CODEC_CAPABILITY_CHANGED";
 
-  case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_UNKNOWN:
-    return "PRESENT_UNKNOWN";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_A2DP_AUDIO_UNDERRUN_REPORTED:
+    return "ATOM_BLUETOOTH_A2DP_AUDIO_UNDERRUN_REPORTED";
 
-namespace perfetto_pbzero_enum_FrameTimelineEvent {
-enum PredictionType : int32_t {
-  PREDICTION_UNSPECIFIED = 0,
-  PREDICTION_VALID = 1,
-  PREDICTION_EXPIRED = 2,
-  PREDICTION_UNKNOWN = 3,
-};
-} // namespace perfetto_pbzero_enum_FrameTimelineEvent
-using FrameTimelineEvent_PredictionType = perfetto_pbzero_enum_FrameTimelineEvent::PredictionType;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_A2DP_AUDIO_OVERRUN_REPORTED:
+    return "ATOM_BLUETOOTH_A2DP_AUDIO_OVERRUN_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_DEVICE_RSSI_REPORTED:
+    return "ATOM_BLUETOOTH_DEVICE_RSSI_REPORTED";
 
-constexpr FrameTimelineEvent_PredictionType FrameTimelineEvent_PredictionType_MIN = FrameTimelineEvent_PredictionType::PREDICTION_UNSPECIFIED;
-constexpr FrameTimelineEvent_PredictionType FrameTimelineEvent_PredictionType_MAX = FrameTimelineEvent_PredictionType::PREDICTION_UNKNOWN;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_DEVICE_FAILED_CONTACT_COUNTER_REPORTED:
+    return "ATOM_BLUETOOTH_DEVICE_FAILED_CONTACT_COUNTER_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_DEVICE_TX_POWER_LEVEL_REPORTED:
+    return "ATOM_BLUETOOTH_DEVICE_TX_POWER_LEVEL_REPORTED";
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* FrameTimelineEvent_PredictionType_Name(::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType::PREDICTION_UNSPECIFIED:
-    return "PREDICTION_UNSPECIFIED";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_HCI_TIMEOUT_REPORTED:
+    return "ATOM_BLUETOOTH_HCI_TIMEOUT_REPORTED";
 
-  case ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType::PREDICTION_VALID:
-    return "PREDICTION_VALID";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_QUALITY_REPORT_REPORTED:
+    return "ATOM_BLUETOOTH_QUALITY_REPORT_REPORTED";
 
-  case ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType::PREDICTION_EXPIRED:
-    return "PREDICTION_EXPIRED";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_DEVICE_INFO_REPORTED:
+    return "ATOM_BLUETOOTH_DEVICE_INFO_REPORTED";
 
-  case ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType::PREDICTION_UNKNOWN:
-    return "PREDICTION_UNKNOWN";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_REMOTE_VERSION_INFO_REPORTED:
+    return "ATOM_BLUETOOTH_REMOTE_VERSION_INFO_REPORTED";
 
-class FrameTimelineEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  FrameTimelineEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit FrameTimelineEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit FrameTimelineEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_expected_display_frame_start() const { return at<1>().valid(); }
-  ::protozero::ConstBytes expected_display_frame_start() const { return at<1>().as_bytes(); }
-  bool has_actual_display_frame_start() const { return at<2>().valid(); }
-  ::protozero::ConstBytes actual_display_frame_start() const { return at<2>().as_bytes(); }
-  bool has_expected_surface_frame_start() const { return at<3>().valid(); }
-  ::protozero::ConstBytes expected_surface_frame_start() const { return at<3>().as_bytes(); }
-  bool has_actual_surface_frame_start() const { return at<4>().valid(); }
-  ::protozero::ConstBytes actual_surface_frame_start() const { return at<4>().as_bytes(); }
-  bool has_frame_end() const { return at<5>().valid(); }
-  ::protozero::ConstBytes frame_end() const { return at<5>().as_bytes(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_SDP_ATTRIBUTE_REPORTED:
+    return "ATOM_BLUETOOTH_SDP_ATTRIBUTE_REPORTED";
 
-class FrameTimelineEvent : public ::protozero::Message {
- public:
-  using Decoder = FrameTimelineEvent_Decoder;
-  enum : int32_t {
-    kExpectedDisplayFrameStartFieldNumber = 1,
-    kActualDisplayFrameStartFieldNumber = 2,
-    kExpectedSurfaceFrameStartFieldNumber = 3,
-    kActualSurfaceFrameStartFieldNumber = 4,
-    kFrameEndFieldNumber = 5,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_BOND_STATE_CHANGED:
+    return "ATOM_BLUETOOTH_BOND_STATE_CHANGED";
 
-  using ExpectedSurfaceFrameStart = ::perfetto::protos::pbzero::FrameTimelineEvent_ExpectedSurfaceFrameStart;
-  using ActualSurfaceFrameStart = ::perfetto::protos::pbzero::FrameTimelineEvent_ActualSurfaceFrameStart;
-  using ExpectedDisplayFrameStart = ::perfetto::protos::pbzero::FrameTimelineEvent_ExpectedDisplayFrameStart;
-  using ActualDisplayFrameStart = ::perfetto::protos::pbzero::FrameTimelineEvent_ActualDisplayFrameStart;
-  using FrameEnd = ::perfetto::protos::pbzero::FrameTimelineEvent_FrameEnd;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_CLASSIC_PAIRING_EVENT_REPORTED:
+    return "ATOM_BLUETOOTH_CLASSIC_PAIRING_EVENT_REPORTED";
 
-  using JankType = ::perfetto::protos::pbzero::FrameTimelineEvent_JankType;
-  static inline const char* JankType_Name(JankType value) {
-    return ::perfetto::protos::pbzero::FrameTimelineEvent_JankType_Name(value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_SMP_PAIRING_EVENT_REPORTED:
+    return "ATOM_BLUETOOTH_SMP_PAIRING_EVENT_REPORTED";
 
-  using PresentType = ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType;
-  static inline const char* PresentType_Name(PresentType value) {
-    return ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType_Name(value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SCREEN_TIMEOUT_EXTENSION_REPORTED:
+    return "ATOM_SCREEN_TIMEOUT_EXTENSION_REPORTED";
 
-  using PredictionType = ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType;
-  static inline const char* PredictionType_Name(PredictionType value) {
-    return ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType_Name(value);
-  }
-  static const JankType JANK_UNSPECIFIED = JankType::JANK_UNSPECIFIED;
-  static const JankType JANK_NONE = JankType::JANK_NONE;
-  static const JankType JANK_SF_SCHEDULING = JankType::JANK_SF_SCHEDULING;
-  static const JankType JANK_PREDICTION_ERROR = JankType::JANK_PREDICTION_ERROR;
-  static const JankType JANK_DISPLAY_HAL = JankType::JANK_DISPLAY_HAL;
-  static const JankType JANK_SF_CPU_DEADLINE_MISSED = JankType::JANK_SF_CPU_DEADLINE_MISSED;
-  static const JankType JANK_SF_GPU_DEADLINE_MISSED = JankType::JANK_SF_GPU_DEADLINE_MISSED;
-  static const JankType JANK_APP_DEADLINE_MISSED = JankType::JANK_APP_DEADLINE_MISSED;
-  static const JankType JANK_BUFFER_STUFFING = JankType::JANK_BUFFER_STUFFING;
-  static const JankType JANK_UNKNOWN = JankType::JANK_UNKNOWN;
-  static const JankType JANK_SF_STUFFING = JankType::JANK_SF_STUFFING;
-  static const PresentType PRESENT_UNSPECIFIED = PresentType::PRESENT_UNSPECIFIED;
-  static const PresentType PRESENT_ON_TIME = PresentType::PRESENT_ON_TIME;
-  static const PresentType PRESENT_LATE = PresentType::PRESENT_LATE;
-  static const PresentType PRESENT_EARLY = PresentType::PRESENT_EARLY;
-  static const PresentType PRESENT_DROPPED = PresentType::PRESENT_DROPPED;
-  static const PresentType PRESENT_UNKNOWN = PresentType::PRESENT_UNKNOWN;
-  static const PredictionType PREDICTION_UNSPECIFIED = PredictionType::PREDICTION_UNSPECIFIED;
-  static const PredictionType PREDICTION_VALID = PredictionType::PREDICTION_VALID;
-  static const PredictionType PREDICTION_EXPIRED = PredictionType::PREDICTION_EXPIRED;
-  static const PredictionType PREDICTION_UNKNOWN = PredictionType::PREDICTION_UNKNOWN;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_START_TIME:
+    return "ATOM_PROCESS_START_TIME";
 
-  using FieldMetadata_ExpectedDisplayFrameStart =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      FrameTimelineEvent_ExpectedDisplayFrameStart,
-      FrameTimelineEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PERMISSION_GRANT_REQUEST_RESULT_REPORTED:
+    return "ATOM_PERMISSION_GRANT_REQUEST_RESULT_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExpectedDisplayFrameStart kExpectedDisplayFrameStart() { return {}; }
-  template <typename T = FrameTimelineEvent_ExpectedDisplayFrameStart> T* set_expected_display_frame_start() {
-    return BeginNestedMessage<T>(1);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_SOCKET_CONNECTION_STATE_CHANGED:
+    return "ATOM_BLUETOOTH_SOCKET_CONNECTION_STATE_CHANGED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_IDENTIFIER_ACCESS_DENIED:
+    return "ATOM_DEVICE_IDENTIFIER_ACCESS_DENIED";
 
-  using FieldMetadata_ActualDisplayFrameStart =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      FrameTimelineEvent_ActualDisplayFrameStart,
-      FrameTimelineEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BUBBLE_DEVELOPER_ERROR_REPORTED:
+    return "ATOM_BUBBLE_DEVELOPER_ERROR_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ActualDisplayFrameStart kActualDisplayFrameStart() { return {}; }
-  template <typename T = FrameTimelineEvent_ActualDisplayFrameStart> T* set_actual_display_frame_start() {
-    return BeginNestedMessage<T>(2);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ASSIST_GESTURE_STAGE_REPORTED:
+    return "ATOM_ASSIST_GESTURE_STAGE_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ASSIST_GESTURE_FEEDBACK_REPORTED:
+    return "ATOM_ASSIST_GESTURE_FEEDBACK_REPORTED";
 
-  using FieldMetadata_ExpectedSurfaceFrameStart =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      FrameTimelineEvent_ExpectedSurfaceFrameStart,
-      FrameTimelineEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ASSIST_GESTURE_PROGRESS_REPORTED:
+    return "ATOM_ASSIST_GESTURE_PROGRESS_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExpectedSurfaceFrameStart kExpectedSurfaceFrameStart() { return {}; }
-  template <typename T = FrameTimelineEvent_ExpectedSurfaceFrameStart> T* set_expected_surface_frame_start() {
-    return BeginNestedMessage<T>(3);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TOUCH_GESTURE_CLASSIFIED:
+    return "ATOM_TOUCH_GESTURE_CLASSIFIED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HIDDEN_API_USED:
+    return "ATOM_HIDDEN_API_USED";
 
-  using FieldMetadata_ActualSurfaceFrameStart =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      FrameTimelineEvent_ActualSurfaceFrameStart,
-      FrameTimelineEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_STYLE_UI_CHANGED:
+    return "ATOM_STYLE_UI_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ActualSurfaceFrameStart kActualSurfaceFrameStart() { return {}; }
-  template <typename T = FrameTimelineEvent_ActualSurfaceFrameStart> T* set_actual_surface_frame_start() {
-    return BeginNestedMessage<T>(4);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PRIVACY_INDICATORS_INTERACTED:
+    return "ATOM_PRIVACY_INDICATORS_INTERACTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_INSTALL_ON_EXTERNAL_STORAGE_REPORTED:
+    return "ATOM_APP_INSTALL_ON_EXTERNAL_STORAGE_REPORTED";
 
-  using FieldMetadata_FrameEnd =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      FrameTimelineEvent_FrameEnd,
-      FrameTimelineEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_STACK_REPORTED:
+    return "ATOM_NETWORK_STACK_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FrameEnd kFrameEnd() { return {}; }
-  template <typename T = FrameTimelineEvent_FrameEnd> T* set_frame_end() {
-    return BeginNestedMessage<T>(5);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_MOVED_STORAGE_REPORTED:
+    return "ATOM_APP_MOVED_STORAGE_REPORTED";
 
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BIOMETRIC_ENROLLED:
+    return "ATOM_BIOMETRIC_ENROLLED";
 
-class FrameTimelineEvent_FrameEnd_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  FrameTimelineEvent_FrameEnd_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit FrameTimelineEvent_FrameEnd_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit FrameTimelineEvent_FrameEnd_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_cookie() const { return at<1>().valid(); }
-  int64_t cookie() const { return at<1>().as_int64(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SYSTEM_SERVER_WATCHDOG_OCCURRED:
+    return "ATOM_SYSTEM_SERVER_WATCHDOG_OCCURRED";
 
-class FrameTimelineEvent_FrameEnd : public ::protozero::Message {
- public:
-  using Decoder = FrameTimelineEvent_FrameEnd_Decoder;
-  enum : int32_t {
-    kCookieFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent.FrameEnd"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TOMB_STONE_OCCURRED:
+    return "ATOM_TOMB_STONE_OCCURRED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_CLASS_OF_DEVICE_REPORTED:
+    return "ATOM_BLUETOOTH_CLASS_OF_DEVICE_REPORTED";
 
-  using FieldMetadata_Cookie =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      FrameTimelineEvent_FrameEnd>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_INTELLIGENCE_EVENT_REPORTED:
+    return "ATOM_INTELLIGENCE_EVENT_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cookie kCookie() { return {}; }
-  void set_cookie(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Cookie::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_THERMAL_THROTTLING_SEVERITY_STATE_CHANGED:
+    return "ATOM_THERMAL_THROTTLING_SEVERITY_STATE_CHANGED";
 
-class FrameTimelineEvent_ActualDisplayFrameStart_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  FrameTimelineEvent_ActualDisplayFrameStart_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit FrameTimelineEvent_ActualDisplayFrameStart_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit FrameTimelineEvent_ActualDisplayFrameStart_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_cookie() const { return at<1>().valid(); }
-  int64_t cookie() const { return at<1>().as_int64(); }
-  bool has_token() const { return at<2>().valid(); }
-  int64_t token() const { return at<2>().as_int64(); }
-  bool has_pid() const { return at<3>().valid(); }
-  int32_t pid() const { return at<3>().as_int32(); }
-  bool has_present_type() const { return at<4>().valid(); }
-  int32_t present_type() const { return at<4>().as_int32(); }
-  bool has_on_time_finish() const { return at<5>().valid(); }
-  bool on_time_finish() const { return at<5>().as_bool(); }
-  bool has_gpu_composition() const { return at<6>().valid(); }
-  bool gpu_composition() const { return at<6>().as_bool(); }
-  bool has_jank_type() const { return at<7>().valid(); }
-  int32_t jank_type() const { return at<7>().as_int32(); }
-  bool has_prediction_type() const { return at<8>().valid(); }
-  int32_t prediction_type() const { return at<8>().as_int32(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ROLE_REQUEST_RESULT_REPORTED:
+    return "ATOM_ROLE_REQUEST_RESULT_REPORTED";
 
-class FrameTimelineEvent_ActualDisplayFrameStart : public ::protozero::Message {
- public:
-  using Decoder = FrameTimelineEvent_ActualDisplayFrameStart_Decoder;
-  enum : int32_t {
-    kCookieFieldNumber = 1,
-    kTokenFieldNumber = 2,
-    kPidFieldNumber = 3,
-    kPresentTypeFieldNumber = 4,
-    kOnTimeFinishFieldNumber = 5,
-    kGpuCompositionFieldNumber = 6,
-    kJankTypeFieldNumber = 7,
-    kPredictionTypeFieldNumber = 8,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent.ActualDisplayFrameStart"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_AUDIOPOLICY_REPORTED:
+    return "ATOM_MEDIAMETRICS_AUDIOPOLICY_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_AUDIORECORD_REPORTED:
+    return "ATOM_MEDIAMETRICS_AUDIORECORD_REPORTED";
 
-  using FieldMetadata_Cookie =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      FrameTimelineEvent_ActualDisplayFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_AUDIOTHREAD_REPORTED:
+    return "ATOM_MEDIAMETRICS_AUDIOTHREAD_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cookie kCookie() { return {}; }
-  void set_cookie(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Cookie::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_AUDIOTRACK_REPORTED:
+    return "ATOM_MEDIAMETRICS_AUDIOTRACK_REPORTED";
 
-  using FieldMetadata_Token =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      FrameTimelineEvent_ActualDisplayFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_CODEC_REPORTED:
+    return "ATOM_MEDIAMETRICS_CODEC_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Token kToken() { return {}; }
-  void set_token(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Token::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_DRM_WIDEVINE_REPORTED:
+    return "ATOM_MEDIAMETRICS_DRM_WIDEVINE_REPORTED";
 
-  using FieldMetadata_Pid =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      FrameTimelineEvent_ActualDisplayFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_EXTRACTOR_REPORTED:
+    return "ATOM_MEDIAMETRICS_EXTRACTOR_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_MEDIADRM_REPORTED:
+    return "ATOM_MEDIAMETRICS_MEDIADRM_REPORTED";
 
-  using FieldMetadata_PresentType =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType,
-      FrameTimelineEvent_ActualDisplayFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_NUPLAYER_REPORTED:
+    return "ATOM_MEDIAMETRICS_NUPLAYER_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PresentType kPresentType() { return {}; }
-  void set_present_type(::perfetto::protos::pbzero::FrameTimelineEvent_PresentType value) {
-    static constexpr uint32_t field_id = FieldMetadata_PresentType::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_RECORDER_REPORTED:
+    return "ATOM_MEDIAMETRICS_RECORDER_REPORTED";
 
-  using FieldMetadata_OnTimeFinish =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      FrameTimelineEvent_ActualDisplayFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_DRMMANAGER_REPORTED:
+    return "ATOM_MEDIAMETRICS_DRMMANAGER_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OnTimeFinish kOnTimeFinish() { return {}; }
-  void set_on_time_finish(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_OnTimeFinish::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_POWER_STATE_CHANGED:
+    return "ATOM_CAR_POWER_STATE_CHANGED";
 
-  using FieldMetadata_GpuComposition =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      FrameTimelineEvent_ActualDisplayFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GARAGE_MODE_INFO:
+    return "ATOM_GARAGE_MODE_INFO";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GpuComposition kGpuComposition() { return {}; }
-  void set_gpu_composition(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_GpuComposition::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TEST_ATOM_REPORTED:
+    return "ATOM_TEST_ATOM_REPORTED";
 
-  using FieldMetadata_JankType =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      FrameTimelineEvent_ActualDisplayFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CONTENT_CAPTURE_CALLER_MISMATCH_REPORTED:
+    return "ATOM_CONTENT_CAPTURE_CALLER_MISMATCH_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_JankType kJankType() { return {}; }
-  void set_jank_type(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_JankType::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CONTENT_CAPTURE_SERVICE_EVENTS:
+    return "ATOM_CONTENT_CAPTURE_SERVICE_EVENTS";
 
-  using FieldMetadata_PredictionType =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType,
-      FrameTimelineEvent_ActualDisplayFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CONTENT_CAPTURE_SESSION_EVENTS:
+    return "ATOM_CONTENT_CAPTURE_SESSION_EVENTS";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PredictionType kPredictionType() { return {}; }
-  void set_prediction_type(::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType value) {
-    static constexpr uint32_t field_id = FieldMetadata_PredictionType::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CONTENT_CAPTURE_FLUSHED:
+    return "ATOM_CONTENT_CAPTURE_FLUSHED";
 
-class FrameTimelineEvent_ExpectedDisplayFrameStart_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  FrameTimelineEvent_ExpectedDisplayFrameStart_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit FrameTimelineEvent_ExpectedDisplayFrameStart_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit FrameTimelineEvent_ExpectedDisplayFrameStart_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_cookie() const { return at<1>().valid(); }
-  int64_t cookie() const { return at<1>().as_int64(); }
-  bool has_token() const { return at<2>().valid(); }
-  int64_t token() const { return at<2>().as_int64(); }
-  bool has_pid() const { return at<3>().valid(); }
-  int32_t pid() const { return at<3>().as_int32(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LOCATION_MANAGER_API_USAGE_REPORTED:
+    return "ATOM_LOCATION_MANAGER_API_USAGE_REPORTED";
 
-class FrameTimelineEvent_ExpectedDisplayFrameStart : public ::protozero::Message {
- public:
-  using Decoder = FrameTimelineEvent_ExpectedDisplayFrameStart_Decoder;
-  enum : int32_t {
-    kCookieFieldNumber = 1,
-    kTokenFieldNumber = 2,
-    kPidFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent.ExpectedDisplayFrameStart"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_REVIEW_PERMISSIONS_FRAGMENT_RESULT_REPORTED:
+    return "ATOM_REVIEW_PERMISSIONS_FRAGMENT_RESULT_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RUNTIME_PERMISSIONS_UPGRADE_RESULT:
+    return "ATOM_RUNTIME_PERMISSIONS_UPGRADE_RESULT";
 
-  using FieldMetadata_Cookie =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      FrameTimelineEvent_ExpectedDisplayFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GRANT_PERMISSIONS_ACTIVITY_BUTTON_ACTIONS:
+    return "ATOM_GRANT_PERMISSIONS_ACTIVITY_BUTTON_ACTIONS";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cookie kCookie() { return {}; }
-  void set_cookie(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Cookie::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LOCATION_ACCESS_CHECK_NOTIFICATION_ACTION:
+    return "ATOM_LOCATION_ACCESS_CHECK_NOTIFICATION_ACTION";
 
-  using FieldMetadata_Token =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      FrameTimelineEvent_ExpectedDisplayFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_PERMISSION_FRAGMENT_ACTION_REPORTED:
+    return "ATOM_APP_PERMISSION_FRAGMENT_ACTION_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Token kToken() { return {}; }
-  void set_token(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Token::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_PERMISSION_FRAGMENT_VIEWED:
+    return "ATOM_APP_PERMISSION_FRAGMENT_VIEWED";
 
-  using FieldMetadata_Pid =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      FrameTimelineEvent_ExpectedDisplayFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_PERMISSIONS_FRAGMENT_VIEWED:
+    return "ATOM_APP_PERMISSIONS_FRAGMENT_VIEWED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PERMISSION_APPS_FRAGMENT_VIEWED:
+    return "ATOM_PERMISSION_APPS_FRAGMENT_VIEWED";
 
-class FrameTimelineEvent_ActualSurfaceFrameStart_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  FrameTimelineEvent_ActualSurfaceFrameStart_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit FrameTimelineEvent_ActualSurfaceFrameStart_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit FrameTimelineEvent_ActualSurfaceFrameStart_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_cookie() const { return at<1>().valid(); }
-  int64_t cookie() const { return at<1>().as_int64(); }
-  bool has_token() const { return at<2>().valid(); }
-  int64_t token() const { return at<2>().as_int64(); }
-  bool has_display_frame_token() const { return at<3>().valid(); }
-  int64_t display_frame_token() const { return at<3>().as_int64(); }
-  bool has_pid() const { return at<4>().valid(); }
-  int32_t pid() const { return at<4>().as_int32(); }
-  bool has_layer_name() const { return at<5>().valid(); }
-  ::protozero::ConstChars layer_name() const { return at<5>().as_string(); }
-  bool has_present_type() const { return at<6>().valid(); }
-  int32_t present_type() const { return at<6>().as_int32(); }
-  bool has_on_time_finish() const { return at<7>().valid(); }
-  bool on_time_finish() const { return at<7>().as_bool(); }
-  bool has_gpu_composition() const { return at<8>().valid(); }
-  bool gpu_composition() const { return at<8>().as_bool(); }
-  bool has_jank_type() const { return at<9>().valid(); }
-  int32_t jank_type() const { return at<9>().as_int32(); }
-  bool has_prediction_type() const { return at<10>().valid(); }
-  int32_t prediction_type() const { return at<10>().as_int32(); }
-  bool has_is_buffer() const { return at<11>().valid(); }
-  bool is_buffer() const { return at<11>().as_bool(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TEXT_SELECTION_EVENT:
+    return "ATOM_TEXT_SELECTION_EVENT";
 
-class FrameTimelineEvent_ActualSurfaceFrameStart : public ::protozero::Message {
- public:
-  using Decoder = FrameTimelineEvent_ActualSurfaceFrameStart_Decoder;
-  enum : int32_t {
-    kCookieFieldNumber = 1,
-    kTokenFieldNumber = 2,
-    kDisplayFrameTokenFieldNumber = 3,
-    kPidFieldNumber = 4,
-    kLayerNameFieldNumber = 5,
-    kPresentTypeFieldNumber = 6,
-    kOnTimeFinishFieldNumber = 7,
-    kGpuCompositionFieldNumber = 8,
-    kJankTypeFieldNumber = 9,
-    kPredictionTypeFieldNumber = 10,
-    kIsBufferFieldNumber = 11,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent.ActualSurfaceFrameStart"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TEXT_LINKIFY_EVENT:
+    return "ATOM_TEXT_LINKIFY_EVENT";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CONVERSATION_ACTIONS_EVENT:
+    return "ATOM_CONVERSATION_ACTIONS_EVENT";
 
-  using FieldMetadata_Cookie =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      FrameTimelineEvent_ActualSurfaceFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LANGUAGE_DETECTION_EVENT:
+    return "ATOM_LANGUAGE_DETECTION_EVENT";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cookie kCookie() { return {}; }
-  void set_cookie(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Cookie::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_EXCLUSION_RECT_STATE_CHANGED:
+    return "ATOM_EXCLUSION_RECT_STATE_CHANGED";
 
-  using FieldMetadata_Token =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      FrameTimelineEvent_ActualSurfaceFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BACK_GESTURE_REPORTED_REPORTED:
+    return "ATOM_BACK_GESTURE_REPORTED_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Token kToken() { return {}; }
-  void set_token(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Token::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_UPDATE_ENGINE_UPDATE_ATTEMPT_REPORTED:
+    return "ATOM_UPDATE_ENGINE_UPDATE_ATTEMPT_REPORTED";
 
-  using FieldMetadata_DisplayFrameToken =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      FrameTimelineEvent_ActualSurfaceFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_UPDATE_ENGINE_SUCCESSFUL_UPDATE_REPORTED:
+    return "ATOM_UPDATE_ENGINE_SUCCESSFUL_UPDATE_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DisplayFrameToken kDisplayFrameToken() { return {}; }
-  void set_display_frame_token(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DisplayFrameToken::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CAMERA_ACTION_EVENT:
+    return "ATOM_CAMERA_ACTION_EVENT";
 
-  using FieldMetadata_Pid =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      FrameTimelineEvent_ActualSurfaceFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_COMPATIBILITY_CHANGE_REPORTED:
+    return "ATOM_APP_COMPATIBILITY_CHANGE_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PERFETTO_UPLOADED:
+    return "ATOM_PERFETTO_UPLOADED";
 
-  using FieldMetadata_LayerName =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      FrameTimelineEvent_ActualSurfaceFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_VMS_CLIENT_CONNECTION_STATE_CHANGED:
+    return "ATOM_VMS_CLIENT_CONNECTION_STATE_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LayerName kLayerName() { return {}; }
-  void set_layer_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_LayerName::kFieldId, data, size);
-  }
-  void set_layer_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_LayerName::kFieldId, chars.data, chars.size);
-  }
-  void set_layer_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_LayerName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_PROVIDER_SCAN_OCCURRED:
+    return "ATOM_MEDIA_PROVIDER_SCAN_OCCURRED";
 
-  using FieldMetadata_PresentType =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType,
-      FrameTimelineEvent_ActualSurfaceFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CONTENT_DELETED:
+    return "ATOM_MEDIA_CONTENT_DELETED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PresentType kPresentType() { return {}; }
-  void set_present_type(::perfetto::protos::pbzero::FrameTimelineEvent_PresentType value) {
-    static constexpr uint32_t field_id = FieldMetadata_PresentType::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_PROVIDER_PERMISSION_REQUESTED:
+    return "ATOM_MEDIA_PROVIDER_PERMISSION_REQUESTED";
 
-  using FieldMetadata_OnTimeFinish =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      FrameTimelineEvent_ActualSurfaceFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_PROVIDER_SCHEMA_CHANGED:
+    return "ATOM_MEDIA_PROVIDER_SCHEMA_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OnTimeFinish kOnTimeFinish() { return {}; }
-  void set_on_time_finish(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_OnTimeFinish::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_PROVIDER_IDLE_MAINTENANCE_FINISHED:
+    return "ATOM_MEDIA_PROVIDER_IDLE_MAINTENANCE_FINISHED";
 
-  using FieldMetadata_GpuComposition =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      FrameTimelineEvent_ActualSurfaceFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_REBOOT_ESCROW_RECOVERY_REPORTED:
+    return "ATOM_REBOOT_ESCROW_RECOVERY_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GpuComposition kGpuComposition() { return {}; }
-  void set_gpu_composition(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_GpuComposition::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BOOT_TIME_EVENT_DURATION_REPORTED:
+    return "ATOM_BOOT_TIME_EVENT_DURATION_REPORTED";
 
-  using FieldMetadata_JankType =
-    ::protozero::proto_utils::FieldMetadata<
-      9,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      FrameTimelineEvent_ActualSurfaceFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED:
+    return "ATOM_BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_JankType kJankType() { return {}; }
-  void set_jank_type(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_JankType::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BOOT_TIME_EVENT_UTC_TIME_REPORTED:
+    return "ATOM_BOOT_TIME_EVENT_UTC_TIME_REPORTED";
 
-  using FieldMetadata_PredictionType =
-    ::protozero::proto_utils::FieldMetadata<
-      10,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType,
-      FrameTimelineEvent_ActualSurfaceFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BOOT_TIME_EVENT_ERROR_CODE_REPORTED:
+    return "ATOM_BOOT_TIME_EVENT_ERROR_CODE_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PredictionType kPredictionType() { return {}; }
-  void set_prediction_type(::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType value) {
-    static constexpr uint32_t field_id = FieldMetadata_PredictionType::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_USERSPACE_REBOOT_REPORTED:
+    return "ATOM_USERSPACE_REBOOT_REPORTED";
 
-  using FieldMetadata_IsBuffer =
-    ::protozero::proto_utils::FieldMetadata<
-      11,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      FrameTimelineEvent_ActualSurfaceFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NOTIFICATION_REPORTED:
+    return "ATOM_NOTIFICATION_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IsBuffer kIsBuffer() { return {}; }
-  void set_is_buffer(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_IsBuffer::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NOTIFICATION_PANEL_REPORTED:
+    return "ATOM_NOTIFICATION_PANEL_REPORTED";
 
-class FrameTimelineEvent_ExpectedSurfaceFrameStart_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  FrameTimelineEvent_ExpectedSurfaceFrameStart_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit FrameTimelineEvent_ExpectedSurfaceFrameStart_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit FrameTimelineEvent_ExpectedSurfaceFrameStart_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_cookie() const { return at<1>().valid(); }
-  int64_t cookie() const { return at<1>().as_int64(); }
-  bool has_token() const { return at<2>().valid(); }
-  int64_t token() const { return at<2>().as_int64(); }
-  bool has_display_frame_token() const { return at<3>().valid(); }
-  int64_t display_frame_token() const { return at<3>().as_int64(); }
-  bool has_pid() const { return at<4>().valid(); }
-  int32_t pid() const { return at<4>().as_int32(); }
-  bool has_layer_name() const { return at<5>().valid(); }
-  ::protozero::ConstChars layer_name() const { return at<5>().as_string(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NOTIFICATION_CHANNEL_MODIFIED:
+    return "ATOM_NOTIFICATION_CHANNEL_MODIFIED";
 
-class FrameTimelineEvent_ExpectedSurfaceFrameStart : public ::protozero::Message {
- public:
-  using Decoder = FrameTimelineEvent_ExpectedSurfaceFrameStart_Decoder;
-  enum : int32_t {
-    kCookieFieldNumber = 1,
-    kTokenFieldNumber = 2,
-    kDisplayFrameTokenFieldNumber = 3,
-    kPidFieldNumber = 4,
-    kLayerNameFieldNumber = 5,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent.ExpectedSurfaceFrameStart"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_INTEGRITY_CHECK_RESULT_REPORTED:
+    return "ATOM_INTEGRITY_CHECK_RESULT_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_INTEGRITY_RULES_PUSHED:
+    return "ATOM_INTEGRITY_RULES_PUSHED";
 
-  using FieldMetadata_Cookie =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      FrameTimelineEvent_ExpectedSurfaceFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CB_MESSAGE_REPORTED:
+    return "ATOM_CB_MESSAGE_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cookie kCookie() { return {}; }
-  void set_cookie(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Cookie::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CB_MESSAGE_ERROR:
+    return "ATOM_CB_MESSAGE_ERROR";
 
-  using FieldMetadata_Token =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      FrameTimelineEvent_ExpectedSurfaceFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_HEALTH_STAT_REPORTED:
+    return "ATOM_WIFI_HEALTH_STAT_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Token kToken() { return {}; }
-  void set_token(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Token::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_FAILURE_STAT_REPORTED:
+    return "ATOM_WIFI_FAILURE_STAT_REPORTED";
 
-  using FieldMetadata_DisplayFrameToken =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      FrameTimelineEvent_ExpectedSurfaceFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_CONNECTION_RESULT_REPORTED:
+    return "ATOM_WIFI_CONNECTION_RESULT_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DisplayFrameToken kDisplayFrameToken() { return {}; }
-  void set_display_frame_token(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DisplayFrameToken::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_FREEZE_CHANGED:
+    return "ATOM_APP_FREEZE_CHANGED";
 
-  using FieldMetadata_Pid =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      FrameTimelineEvent_ExpectedSurfaceFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SNAPSHOT_MERGE_REPORTED:
+    return "ATOM_SNAPSHOT_MERGE_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_FOREGROUND_SERVICE_APP_OP_SESSION_ENDED:
+    return "ATOM_FOREGROUND_SERVICE_APP_OP_SESSION_ENDED";
 
-  using FieldMetadata_LayerName =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      FrameTimelineEvent_ExpectedSurfaceFrameStart>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DISPLAY_JANK_REPORTED:
+    return "ATOM_DISPLAY_JANK_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LayerName kLayerName() { return {}; }
-  void set_layer_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_LayerName::kFieldId, data, size);
-  }
-  void set_layer_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_LayerName::kFieldId, chars.data, chars.size);
-  }
-  void set_layer_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_LayerName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_STANDBY_BUCKET_CHANGED:
+    return "ATOM_APP_STANDBY_BUCKET_CHANGED";
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/android/gpu_mem_event.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SHARESHEET_STARTED:
+    return "ATOM_SHARESHEET_STARTED";
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_GPU_MEM_EVENT_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_GPU_MEM_EVENT_PROTO_H_
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RANKING_SELECTED:
+    return "ATOM_RANKING_SELECTED";
 
-#include <stddef.h>
-#include <stdint.h>
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TVSETTINGS_UI_INTERACTED:
+    return "ATOM_TVSETTINGS_UI_INTERACTED";
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LAUNCHER_SNAPSHOT:
+    return "ATOM_LAUNCHER_SNAPSHOT";
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PACKAGE_INSTALLER_V2_REPORTED:
+    return "ATOM_PACKAGE_INSTALLER_V2_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_USER_LIFECYCLE_JOURNEY_REPORTED:
+    return "ATOM_USER_LIFECYCLE_JOURNEY_REPORTED";
 
-class GpuMemTotalEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  GpuMemTotalEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit GpuMemTotalEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit GpuMemTotalEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_gpu_id() const { return at<1>().valid(); }
-  uint32_t gpu_id() const { return at<1>().as_uint32(); }
-  bool has_pid() const { return at<2>().valid(); }
-  uint32_t pid() const { return at<2>().as_uint32(); }
-  bool has_size() const { return at<3>().valid(); }
-  uint64_t size() const { return at<3>().as_uint64(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_USER_LIFECYCLE_EVENT_OCCURRED:
+    return "ATOM_USER_LIFECYCLE_EVENT_OCCURRED";
 
-class GpuMemTotalEvent : public ::protozero::Message {
- public:
-  using Decoder = GpuMemTotalEvent_Decoder;
-  enum : int32_t {
-    kGpuIdFieldNumber = 1,
-    kPidFieldNumber = 2,
-    kSizeFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.GpuMemTotalEvent"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ACCESSIBILITY_SHORTCUT_REPORTED:
+    return "ATOM_ACCESSIBILITY_SHORTCUT_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ACCESSIBILITY_SERVICE_REPORTED:
+    return "ATOM_ACCESSIBILITY_SERVICE_REPORTED";
 
-  using FieldMetadata_GpuId =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      GpuMemTotalEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_DRAG_AND_DROP_REPORTED:
+    return "ATOM_DOCS_UI_DRAG_AND_DROP_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GpuId kGpuId() { return {}; }
-  void set_gpu_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GpuId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_USAGE_EVENT_OCCURRED:
+    return "ATOM_APP_USAGE_EVENT_OCCURRED";
 
-  using FieldMetadata_Pid =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      GpuMemTotalEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AUTO_REVOKE_NOTIFICATION_CLICKED:
+    return "ATOM_AUTO_REVOKE_NOTIFICATION_CLICKED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AUTO_REVOKE_FRAGMENT_APP_VIEWED:
+    return "ATOM_AUTO_REVOKE_FRAGMENT_APP_VIEWED";
 
-  using FieldMetadata_Size =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      GpuMemTotalEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AUTO_REVOKED_APP_INTERACTION:
+    return "ATOM_AUTO_REVOKED_APP_INTERACTION";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Size kSize() { return {}; }
-  void set_size(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_PERMISSION_GROUPS_FRAGMENT_AUTO_REVOKE_ACTION:
+    return "ATOM_APP_PERMISSION_GROUPS_FRAGMENT_AUTO_REVOKE_ACTION";
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/android/graphics_frame_event.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+  case ::perfetto::protos::pbzero::AtomId::ATOM_EVS_USAGE_STATS_REPORTED:
+    return "ATOM_EVS_USAGE_STATS_REPORTED";
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_GRAPHICS_FRAME_EVENT_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_GRAPHICS_FRAME_EVENT_PROTO_H_
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AUDIO_POWER_USAGE_DATA_REPORTED:
+    return "ATOM_AUDIO_POWER_USAGE_DATA_REPORTED";
 
-#include <stddef.h>
-#include <stdint.h>
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TV_TUNER_STATE_CHANGED:
+    return "ATOM_TV_TUNER_STATE_CHANGED";
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAOUTPUT_OP_SWITCH_REPORTED:
+    return "ATOM_MEDIAOUTPUT_OP_SWITCH_REPORTED";
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CB_MESSAGE_FILTERED:
+    return "ATOM_CB_MESSAGE_FILTERED";
 
-class GraphicsFrameEvent_BufferEvent;
-namespace perfetto_pbzero_enum_GraphicsFrameEvent {
-enum BufferEventType : int32_t;
-}  // namespace perfetto_pbzero_enum_GraphicsFrameEvent
-using GraphicsFrameEvent_BufferEventType = perfetto_pbzero_enum_GraphicsFrameEvent::BufferEventType;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TV_TUNER_DVR_STATUS:
+    return "ATOM_TV_TUNER_DVR_STATUS";
 
-namespace perfetto_pbzero_enum_GraphicsFrameEvent {
-enum BufferEventType : int32_t {
-  UNSPECIFIED = 0,
-  DEQUEUE = 1,
-  QUEUE = 2,
-  POST = 3,
-  ACQUIRE_FENCE = 4,
-  LATCH = 5,
-  HWC_COMPOSITION_QUEUED = 6,
-  FALLBACK_COMPOSITION = 7,
-  PRESENT_FENCE = 8,
-  RELEASE_FENCE = 9,
-  MODIFY = 10,
-  DETACH = 11,
-  ATTACH = 12,
-  CANCEL = 13,
-};
-} // namespace perfetto_pbzero_enum_GraphicsFrameEvent
-using GraphicsFrameEvent_BufferEventType = perfetto_pbzero_enum_GraphicsFrameEvent::BufferEventType;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TV_CAS_SESSION_OPEN_STATUS:
+    return "ATOM_TV_CAS_SESSION_OPEN_STATUS";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ASSISTANT_INVOCATION_REPORTED:
+    return "ATOM_ASSISTANT_INVOCATION_REPORTED";
 
-constexpr GraphicsFrameEvent_BufferEventType GraphicsFrameEvent_BufferEventType_MIN = GraphicsFrameEvent_BufferEventType::UNSPECIFIED;
-constexpr GraphicsFrameEvent_BufferEventType GraphicsFrameEvent_BufferEventType_MAX = GraphicsFrameEvent_BufferEventType::CANCEL;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DISPLAY_WAKE_REPORTED:
+    return "ATOM_DISPLAY_WAKE_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_USER_HAL_MODIFY_USER_REQUEST_REPORTED:
+    return "ATOM_CAR_USER_HAL_MODIFY_USER_REQUEST_REPORTED";
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* GraphicsFrameEvent_BufferEventType_Name(::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::UNSPECIFIED:
-    return "UNSPECIFIED";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_USER_HAL_MODIFY_USER_RESPONSE_REPORTED:
+    return "ATOM_CAR_USER_HAL_MODIFY_USER_RESPONSE_REPORTED";
 
-  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::DEQUEUE:
-    return "DEQUEUE";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_USER_HAL_POST_SWITCH_RESPONSE_REPORTED:
+    return "ATOM_CAR_USER_HAL_POST_SWITCH_RESPONSE_REPORTED";
 
-  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::QUEUE:
-    return "QUEUE";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_USER_HAL_INITIAL_USER_INFO_REQUEST_REPORTED:
+    return "ATOM_CAR_USER_HAL_INITIAL_USER_INFO_REQUEST_REPORTED";
 
-  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::POST:
-    return "POST";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_USER_HAL_INITIAL_USER_INFO_RESPONSE_REPORTED:
+    return "ATOM_CAR_USER_HAL_INITIAL_USER_INFO_RESPONSE_REPORTED";
 
-  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::ACQUIRE_FENCE:
-    return "ACQUIRE_FENCE";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_USER_HAL_USER_ASSOCIATION_REQUEST_REPORTED:
+    return "ATOM_CAR_USER_HAL_USER_ASSOCIATION_REQUEST_REPORTED";
 
-  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::LATCH:
-    return "LATCH";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_USER_HAL_SET_USER_ASSOCIATION_RESPONSE_REPORTED:
+    return "ATOM_CAR_USER_HAL_SET_USER_ASSOCIATION_RESPONSE_REPORTED";
 
-  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::HWC_COMPOSITION_QUEUED:
-    return "HWC_COMPOSITION_QUEUED";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_IP_PROVISIONING_REPORTED:
+    return "ATOM_NETWORK_IP_PROVISIONING_REPORTED";
 
-  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::FALLBACK_COMPOSITION:
-    return "FALLBACK_COMPOSITION";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_DHCP_RENEW_REPORTED:
+    return "ATOM_NETWORK_DHCP_RENEW_REPORTED";
 
-  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::PRESENT_FENCE:
-    return "PRESENT_FENCE";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_VALIDATION_REPORTED:
+    return "ATOM_NETWORK_VALIDATION_REPORTED";
 
-  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::RELEASE_FENCE:
-    return "RELEASE_FENCE";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_STACK_QUIRK_REPORTED:
+    return "ATOM_NETWORK_STACK_QUIRK_REPORTED";
 
-  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::MODIFY:
-    return "MODIFY";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_AUDIORECORDDEVICEUSAGE_REPORTED:
+    return "ATOM_MEDIAMETRICS_AUDIORECORDDEVICEUSAGE_REPORTED";
 
-  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::DETACH:
-    return "DETACH";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_AUDIOTHREADDEVICEUSAGE_REPORTED:
+    return "ATOM_MEDIAMETRICS_AUDIOTHREADDEVICEUSAGE_REPORTED";
 
-  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::ATTACH:
-    return "ATTACH";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_AUDIOTRACKDEVICEUSAGE_REPORTED:
+    return "ATOM_MEDIAMETRICS_AUDIOTRACKDEVICEUSAGE_REPORTED";
 
-  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::CANCEL:
-    return "CANCEL";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_AUDIODEVICECONNECTION_REPORTED:
+    return "ATOM_MEDIAMETRICS_AUDIODEVICECONNECTION_REPORTED";
 
-class GraphicsFrameEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  GraphicsFrameEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit GraphicsFrameEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit GraphicsFrameEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_buffer_event() const { return at<1>().valid(); }
-  ::protozero::ConstBytes buffer_event() const { return at<1>().as_bytes(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLOB_COMMITTED:
+    return "ATOM_BLOB_COMMITTED";
 
-class GraphicsFrameEvent : public ::protozero::Message {
- public:
-  using Decoder = GraphicsFrameEvent_Decoder;
-  enum : int32_t {
-    kBufferEventFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.GraphicsFrameEvent"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLOB_LEASED:
+    return "ATOM_BLOB_LEASED";
 
-  using BufferEvent = ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEvent;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLOB_OPENED:
+    return "ATOM_BLOB_OPENED";
 
-  using BufferEventType = ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType;
-  static inline const char* BufferEventType_Name(BufferEventType value) {
-    return ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType_Name(value);
-  }
-  static const BufferEventType UNSPECIFIED = BufferEventType::UNSPECIFIED;
-  static const BufferEventType DEQUEUE = BufferEventType::DEQUEUE;
-  static const BufferEventType QUEUE = BufferEventType::QUEUE;
-  static const BufferEventType POST = BufferEventType::POST;
-  static const BufferEventType ACQUIRE_FENCE = BufferEventType::ACQUIRE_FENCE;
-  static const BufferEventType LATCH = BufferEventType::LATCH;
-  static const BufferEventType HWC_COMPOSITION_QUEUED = BufferEventType::HWC_COMPOSITION_QUEUED;
-  static const BufferEventType FALLBACK_COMPOSITION = BufferEventType::FALLBACK_COMPOSITION;
-  static const BufferEventType PRESENT_FENCE = BufferEventType::PRESENT_FENCE;
-  static const BufferEventType RELEASE_FENCE = BufferEventType::RELEASE_FENCE;
-  static const BufferEventType MODIFY = BufferEventType::MODIFY;
-  static const BufferEventType DETACH = BufferEventType::DETACH;
-  static const BufferEventType ATTACH = BufferEventType::ATTACH;
-  static const BufferEventType CANCEL = BufferEventType::CANCEL;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CONTACTS_PROVIDER_STATUS_REPORTED:
+    return "ATOM_CONTACTS_PROVIDER_STATUS_REPORTED";
 
-  using FieldMetadata_BufferEvent =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      GraphicsFrameEvent_BufferEvent,
-      GraphicsFrameEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_KEYSTORE_KEY_EVENT_REPORTED:
+    return "ATOM_KEYSTORE_KEY_EVENT_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BufferEvent kBufferEvent() { return {}; }
-  template <typename T = GraphicsFrameEvent_BufferEvent> T* set_buffer_event() {
-    return BeginNestedMessage<T>(1);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_TETHERING_REPORTED:
+    return "ATOM_NETWORK_TETHERING_REPORTED";
 
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_IME_TOUCH_REPORTED:
+    return "ATOM_IME_TOUCH_REPORTED";
 
-class GraphicsFrameEvent_BufferEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  GraphicsFrameEvent_BufferEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit GraphicsFrameEvent_BufferEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit GraphicsFrameEvent_BufferEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_frame_number() const { return at<1>().valid(); }
-  uint32_t frame_number() const { return at<1>().as_uint32(); }
-  bool has_type() const { return at<2>().valid(); }
-  int32_t type() const { return at<2>().as_int32(); }
-  bool has_layer_name() const { return at<3>().valid(); }
-  ::protozero::ConstChars layer_name() const { return at<3>().as_string(); }
-  bool has_duration_ns() const { return at<4>().valid(); }
-  uint64_t duration_ns() const { return at<4>().as_uint64(); }
-  bool has_buffer_id() const { return at<5>().valid(); }
-  uint32_t buffer_id() const { return at<5>().as_uint32(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_UI_INTERACTION_FRAME_INFO_REPORTED:
+    return "ATOM_UI_INTERACTION_FRAME_INFO_REPORTED";
 
-class GraphicsFrameEvent_BufferEvent : public ::protozero::Message {
- public:
-  using Decoder = GraphicsFrameEvent_BufferEvent_Decoder;
-  enum : int32_t {
-    kFrameNumberFieldNumber = 1,
-    kTypeFieldNumber = 2,
-    kLayerNameFieldNumber = 3,
-    kDurationNsFieldNumber = 4,
-    kBufferIdFieldNumber = 5,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.GraphicsFrameEvent.BufferEvent"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_UI_ACTION_LATENCY_REPORTED:
+    return "ATOM_UI_ACTION_LATENCY_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_DISCONNECT_REPORTED:
+    return "ATOM_WIFI_DISCONNECT_REPORTED";
 
-  using FieldMetadata_FrameNumber =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      GraphicsFrameEvent_BufferEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_CONNECTION_STATE_CHANGED:
+    return "ATOM_WIFI_CONNECTION_STATE_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FrameNumber kFrameNumber() { return {}; }
-  void set_frame_number(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FrameNumber::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HDMI_CEC_ACTIVE_SOURCE_CHANGED:
+    return "ATOM_HDMI_CEC_ACTIVE_SOURCE_CHANGED";
 
-  using FieldMetadata_Type =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType,
-      GraphicsFrameEvent_BufferEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HDMI_CEC_MESSAGE_REPORTED:
+    return "ATOM_HDMI_CEC_MESSAGE_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AIRPLANE_MODE:
+    return "ATOM_AIRPLANE_MODE";
 
-  using FieldMetadata_LayerName =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      GraphicsFrameEvent_BufferEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MODEM_RESTART:
+    return "ATOM_MODEM_RESTART";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LayerName kLayerName() { return {}; }
-  void set_layer_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_LayerName::kFieldId, data, size);
-  }
-  void set_layer_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_LayerName::kFieldId, chars.data, chars.size);
-  }
-  void set_layer_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_LayerName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CARRIER_ID_MISMATCH_REPORTED:
+    return "ATOM_CARRIER_ID_MISMATCH_REPORTED";
 
-  using FieldMetadata_DurationNs =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      GraphicsFrameEvent_BufferEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CARRIER_ID_TABLE_UPDATED:
+    return "ATOM_CARRIER_ID_TABLE_UPDATED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DurationNs kDurationNs() { return {}; }
-  void set_duration_ns(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DurationNs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DATA_STALL_RECOVERY_REPORTED:
+    return "ATOM_DATA_STALL_RECOVERY_REPORTED";
 
-  using FieldMetadata_BufferId =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      GraphicsFrameEvent_BufferEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_MEDIAPARSER_REPORTED:
+    return "ATOM_MEDIAMETRICS_MEDIAPARSER_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BufferId kBufferId() { return {}; }
-  void set_buffer_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BufferId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TLS_HANDSHAKE_REPORTED:
+    return "ATOM_TLS_HANDSHAKE_REPORTED";
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/android/initial_display_state.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TEXT_CLASSIFIER_API_USAGE_REPORTED:
+    return "ATOM_TEXT_CLASSIFIER_API_USAGE_REPORTED";
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_INITIAL_DISPLAY_STATE_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_INITIAL_DISPLAY_STATE_PROTO_H_
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_WATCHDOG_KILL_STATS_REPORTED:
+    return "ATOM_CAR_WATCHDOG_KILL_STATS_REPORTED";
 
-#include <stddef.h>
-#include <stdint.h>
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_PLAYBACK_REPORTED:
+    return "ATOM_MEDIAMETRICS_PLAYBACK_REPORTED";
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_NETWORK_INFO_CHANGED:
+    return "ATOM_MEDIA_NETWORK_INFO_CHANGED";
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_PLAYBACK_STATE_CHANGED:
+    return "ATOM_MEDIA_PLAYBACK_STATE_CHANGED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_PLAYBACK_ERROR_REPORTED:
+    return "ATOM_MEDIA_PLAYBACK_ERROR_REPORTED";
 
-class InitialDisplayState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  InitialDisplayState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit InitialDisplayState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit InitialDisplayState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_display_state() const { return at<1>().valid(); }
-  int32_t display_state() const { return at<1>().as_int32(); }
-  bool has_brightness() const { return at<2>().valid(); }
-  double brightness() const { return at<2>().as_double(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_PLAYBACK_TRACK_CHANGED:
+    return "ATOM_MEDIA_PLAYBACK_TRACK_CHANGED";
 
-class InitialDisplayState : public ::protozero::Message {
- public:
-  using Decoder = InitialDisplayState_Decoder;
-  enum : int32_t {
-    kDisplayStateFieldNumber = 1,
-    kBrightnessFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.InitialDisplayState"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_SCAN_REPORTED:
+    return "ATOM_WIFI_SCAN_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_PNO_SCAN_REPORTED:
+    return "ATOM_WIFI_PNO_SCAN_REPORTED";
 
-  using FieldMetadata_DisplayState =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      InitialDisplayState>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TIF_TUNE_CHANGED:
+    return "ATOM_TIF_TUNE_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DisplayState kDisplayState() { return {}; }
-  void set_display_state(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DisplayState::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AUTO_ROTATE_REPORTED:
+    return "ATOM_AUTO_ROTATE_REPORTED";
 
-  using FieldMetadata_Brightness =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kDouble,
-      double,
-      InitialDisplayState>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PERFETTO_TRIGGER:
+    return "ATOM_PERFETTO_TRIGGER";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Brightness kBrightness() { return {}; }
-  void set_brightness(double value) {
-    static constexpr uint32_t field_id = FieldMetadata_Brightness::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kDouble>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TRANSCODING_DATA:
+    return "ATOM_TRANSCODING_DATA";
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/android/network_trace.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+  case ::perfetto::protos::pbzero::AtomId::ATOM_IMS_SERVICE_ENTITLEMENT_UPDATED:
+    return "ATOM_IMS_SERVICE_ENTITLEMENT_UPDATED";
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_NETWORK_TRACE_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_NETWORK_TRACE_PROTO_H_
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_ROTATED:
+    return "ATOM_DEVICE_ROTATED";
 
-#include <stddef.h>
-#include <stdint.h>
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SIM_SPECIFIC_SETTINGS_RESTORED:
+    return "ATOM_SIM_SPECIFIC_SETTINGS_RESTORED";
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TEXT_CLASSIFIER_DOWNLOAD_REPORTED:
+    return "ATOM_TEXT_CLASSIFIER_DOWNLOAD_REPORTED";
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PIN_STORAGE_EVENT:
+    return "ATOM_PIN_STORAGE_EVENT";
 
-enum TrafficDirection : int32_t;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_FACE_DOWN_REPORTED:
+    return "ATOM_FACE_DOWN_REPORTED";
 
-enum TrafficDirection : int32_t {
-  DIR_UNSPECIFIED = 0,
-  DIR_INGRESS = 1,
-  DIR_EGRESS = 2,
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_HAL_CRASH_REASON_REPORTED:
+    return "ATOM_BLUETOOTH_HAL_CRASH_REASON_REPORTED";
 
-constexpr TrafficDirection TrafficDirection_MIN = TrafficDirection::DIR_UNSPECIFIED;
-constexpr TrafficDirection TrafficDirection_MAX = TrafficDirection::DIR_EGRESS;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_REBOOT_ESCROW_PREPARATION_REPORTED:
+    return "ATOM_REBOOT_ESCROW_PREPARATION_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_REBOOT_ESCROW_LSKF_CAPTURE_REPORTED:
+    return "ATOM_REBOOT_ESCROW_LSKF_CAPTURE_REPORTED";
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* TrafficDirection_Name(::perfetto::protos::pbzero::TrafficDirection value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::TrafficDirection::DIR_UNSPECIFIED:
-    return "DIR_UNSPECIFIED";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_REBOOT_ESCROW_REBOOT_REPORTED:
+    return "ATOM_REBOOT_ESCROW_REBOOT_REPORTED";
 
-  case ::perfetto::protos::pbzero::TrafficDirection::DIR_INGRESS:
-    return "DIR_INGRESS";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BINDER_LATENCY_REPORTED:
+    return "ATOM_BINDER_LATENCY_REPORTED";
 
-  case ::perfetto::protos::pbzero::TrafficDirection::DIR_EGRESS:
-    return "DIR_EGRESS";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_AAUDIOSTREAM_REPORTED:
+    return "ATOM_MEDIAMETRICS_AAUDIOSTREAM_REPORTED";
 
-class NetworkPacketEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  NetworkPacketEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit NetworkPacketEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit NetworkPacketEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_direction() const { return at<1>().valid(); }
-  int32_t direction() const { return at<1>().as_int32(); }
-  bool has_interface() const { return at<2>().valid(); }
-  ::protozero::ConstChars interface() const { return at<2>().as_string(); }
-  bool has_length() const { return at<3>().valid(); }
-  uint32_t length() const { return at<3>().as_uint32(); }
-  bool has_uid() const { return at<4>().valid(); }
-  uint32_t uid() const { return at<4>().as_uint32(); }
-  bool has_tag() const { return at<5>().valid(); }
-  uint32_t tag() const { return at<5>().as_uint32(); }
-  bool has_ip_proto() const { return at<6>().valid(); }
-  uint32_t ip_proto() const { return at<6>().as_uint32(); }
-  bool has_tcp_flags() const { return at<7>().valid(); }
-  uint32_t tcp_flags() const { return at<7>().as_uint32(); }
-  bool has_local_port() const { return at<8>().valid(); }
-  uint32_t local_port() const { return at<8>().as_uint32(); }
-  bool has_remote_port() const { return at<9>().valid(); }
-  uint32_t remote_port() const { return at<9>().as_uint32(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_TRANSCODING_SESSION_ENDED:
+    return "ATOM_MEDIA_TRANSCODING_SESSION_ENDED";
 
-class NetworkPacketEvent : public ::protozero::Message {
- public:
-  using Decoder = NetworkPacketEvent_Decoder;
-  enum : int32_t {
-    kDirectionFieldNumber = 1,
-    kInterfaceFieldNumber = 2,
-    kLengthFieldNumber = 3,
-    kUidFieldNumber = 4,
-    kTagFieldNumber = 5,
-    kIpProtoFieldNumber = 6,
-    kTcpFlagsFieldNumber = 7,
-    kLocalPortFieldNumber = 8,
-    kRemotePortFieldNumber = 9,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.NetworkPacketEvent"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MAGNIFICATION_USAGE_REPORTED:
+    return "ATOM_MAGNIFICATION_USAGE_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MAGNIFICATION_MODE_WITH_IME_ON_REPORTED:
+    return "ATOM_MAGNIFICATION_MODE_WITH_IME_ON_REPORTED";
 
-  using FieldMetadata_Direction =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::TrafficDirection,
-      NetworkPacketEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_CALL_STATS_REPORTED:
+    return "ATOM_APP_SEARCH_CALL_STATS_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Direction kDirection() { return {}; }
-  void set_direction(::perfetto::protos::pbzero::TrafficDirection value) {
-    static constexpr uint32_t field_id = FieldMetadata_Direction::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_PUT_DOCUMENT_STATS_REPORTED:
+    return "ATOM_APP_SEARCH_PUT_DOCUMENT_STATS_REPORTED";
 
-  using FieldMetadata_Interface =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      NetworkPacketEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_CONTROL_CHANGED:
+    return "ATOM_DEVICE_CONTROL_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Interface kInterface() { return {}; }
-  void set_interface(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Interface::kFieldId, data, size);
-  }
-  void set_interface(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Interface::kFieldId, chars.data, chars.size);
-  }
-  void set_interface(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Interface::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_STATE_CHANGED:
+    return "ATOM_DEVICE_STATE_CHANGED";
 
-  using FieldMetadata_Length =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      NetworkPacketEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_INPUTDEVICE_REGISTERED:
+    return "ATOM_INPUTDEVICE_REGISTERED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Length kLength() { return {}; }
-  void set_length(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Length::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SMARTSPACE_CARD_REPORTED:
+    return "ATOM_SMARTSPACE_CARD_REPORTED";
 
-  using FieldMetadata_Uid =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      NetworkPacketEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AUTH_PROMPT_AUTHENTICATE_INVOKED:
+    return "ATOM_AUTH_PROMPT_AUTHENTICATE_INVOKED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Uid kUid() { return {}; }
-  void set_uid(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AUTH_MANAGER_CAN_AUTHENTICATE_INVOKED:
+    return "ATOM_AUTH_MANAGER_CAN_AUTHENTICATE_INVOKED";
 
-  using FieldMetadata_Tag =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      NetworkPacketEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AUTH_ENROLL_ACTION_INVOKED:
+    return "ATOM_AUTH_ENROLL_ACTION_INVOKED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Tag kTag() { return {}; }
-  void set_tag(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Tag::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AUTH_DEPRECATED_API_USED:
+    return "ATOM_AUTH_DEPRECATED_API_USED";
 
-  using FieldMetadata_IpProto =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      NetworkPacketEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_UNATTENDED_REBOOT_OCCURRED:
+    return "ATOM_UNATTENDED_REBOOT_OCCURRED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IpProto kIpProto() { return {}; }
-  void set_ip_proto(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IpProto::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LONG_REBOOT_BLOCKING_REPORTED:
+    return "ATOM_LONG_REBOOT_BLOCKING_REPORTED";
 
-  using FieldMetadata_TcpFlags =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      NetworkPacketEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LOCATION_TIME_ZONE_PROVIDER_STATE_CHANGED:
+    return "ATOM_LOCATION_TIME_ZONE_PROVIDER_STATE_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TcpFlags kTcpFlags() { return {}; }
-  void set_tcp_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TcpFlags::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_FDTRACK_EVENT_OCCURRED:
+    return "ATOM_FDTRACK_EVENT_OCCURRED";
 
-  using FieldMetadata_LocalPort =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      NetworkPacketEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TIMEOUT_AUTO_EXTENDED_REPORTED:
+    return "ATOM_TIMEOUT_AUTO_EXTENDED_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LocalPort kLocalPort() { return {}; }
-  void set_local_port(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LocalPort::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ALARM_BATCH_DELIVERED:
+    return "ATOM_ALARM_BATCH_DELIVERED";
 
-  using FieldMetadata_RemotePort =
-    ::protozero::proto_utils::FieldMetadata<
-      9,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      NetworkPacketEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ALARM_SCHEDULED:
+    return "ATOM_ALARM_SCHEDULED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RemotePort kRemotePort() { return {}; }
-  void set_remote_port(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RemotePort::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_WATCHDOG_IO_OVERUSE_STATS_REPORTED:
+    return "ATOM_CAR_WATCHDOG_IO_OVERUSE_STATS_REPORTED";
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/android/packages_list.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+  case ::perfetto::protos::pbzero::AtomId::ATOM_USER_LEVEL_HIBERNATION_STATE_CHANGED:
+    return "ATOM_USER_LEVEL_HIBERNATION_STATE_CHANGED";
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_PACKAGES_LIST_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_PACKAGES_LIST_PROTO_H_
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_INITIALIZE_STATS_REPORTED:
+    return "ATOM_APP_SEARCH_INITIALIZE_STATS_REPORTED";
 
-#include <stddef.h>
-#include <stdint.h>
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_QUERY_STATS_REPORTED:
+    return "ATOM_APP_SEARCH_QUERY_STATS_REPORTED";
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_PROCESS_DIED:
+    return "ATOM_APP_PROCESS_DIED";
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_IP_REACHABILITY_MONITOR_REPORTED:
+    return "ATOM_NETWORK_IP_REACHABILITY_MONITOR_REPORTED";
 
-class PackagesList_PackageInfo;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SLOW_INPUT_EVENT_REPORTED:
+    return "ATOM_SLOW_INPUT_EVENT_REPORTED";
 
-class PackagesList_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  PackagesList_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit PackagesList_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit PackagesList_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_packages() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> packages() const { return GetRepeated<::protozero::ConstBytes>(1); }
-  bool has_parse_error() const { return at<2>().valid(); }
-  bool parse_error() const { return at<2>().as_bool(); }
-  bool has_read_error() const { return at<3>().valid(); }
-  bool read_error() const { return at<3>().as_bool(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ANR_OCCURRED_PROCESSING_STARTED:
+    return "ATOM_ANR_OCCURRED_PROCESSING_STARTED";
 
-class PackagesList : public ::protozero::Message {
- public:
-  using Decoder = PackagesList_Decoder;
-  enum : int32_t {
-    kPackagesFieldNumber = 1,
-    kParseErrorFieldNumber = 2,
-    kReadErrorFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.PackagesList"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_REMOVE_STATS_REPORTED:
+    return "ATOM_APP_SEARCH_REMOVE_STATS_REPORTED";
 
-  using PackageInfo = ::perfetto::protos::pbzero::PackagesList_PackageInfo;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CODEC_REPORTED:
+    return "ATOM_MEDIA_CODEC_REPORTED";
 
-  using FieldMetadata_Packages =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      PackagesList_PackageInfo,
-      PackagesList>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PERMISSION_USAGE_FRAGMENT_INTERACTION:
+    return "ATOM_PERMISSION_USAGE_FRAGMENT_INTERACTION";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Packages kPackages() { return {}; }
-  template <typename T = PackagesList_PackageInfo> T* add_packages() {
-    return BeginNestedMessage<T>(1);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PERMISSION_DETAILS_INTERACTION:
+    return "ATOM_PERMISSION_DETAILS_INTERACTION";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PRIVACY_SENSOR_TOGGLE_INTERACTION:
+    return "ATOM_PRIVACY_SENSOR_TOGGLE_INTERACTION";
 
-  using FieldMetadata_ParseError =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      PackagesList>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PRIVACY_TOGGLE_DIALOG_INTERACTION:
+    return "ATOM_PRIVACY_TOGGLE_DIALOG_INTERACTION";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ParseError kParseError() { return {}; }
-  void set_parse_error(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_ParseError::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_OPTIMIZE_STATS_REPORTED:
+    return "ATOM_APP_SEARCH_OPTIMIZE_STATS_REPORTED";
 
-  using FieldMetadata_ReadError =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      PackagesList>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NON_A11Y_TOOL_SERVICE_WARNING_REPORT:
+    return "ATOM_NON_A11Y_TOOL_SERVICE_WARNING_REPORT";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReadError kReadError() { return {}; }
-  void set_read_error(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReadError::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_COMPAT_STATE_CHANGED:
+    return "ATOM_APP_COMPAT_STATE_CHANGED";
 
-class PackagesList_PackageInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  PackagesList_PackageInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit PackagesList_PackageInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit PackagesList_PackageInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_uid() const { return at<2>().valid(); }
-  uint64_t uid() const { return at<2>().as_uint64(); }
-  bool has_debuggable() const { return at<3>().valid(); }
-  bool debuggable() const { return at<3>().as_bool(); }
-  bool has_profileable_from_shell() const { return at<4>().valid(); }
-  bool profileable_from_shell() const { return at<4>().as_bool(); }
-  bool has_version_code() const { return at<5>().valid(); }
-  int64_t version_code() const { return at<5>().as_int64(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SIZE_COMPAT_RESTART_BUTTON_EVENT_REPORTED:
+    return "ATOM_SIZE_COMPAT_RESTART_BUTTON_EVENT_REPORTED";
 
-class PackagesList_PackageInfo : public ::protozero::Message {
- public:
-  using Decoder = PackagesList_PackageInfo_Decoder;
-  enum : int32_t {
-    kNameFieldNumber = 1,
-    kUidFieldNumber = 2,
-    kDebuggableFieldNumber = 3,
-    kProfileableFromShellFieldNumber = 4,
-    kVersionCodeFieldNumber = 5,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.PackagesList.PackageInfo"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SPLITSCREEN_UI_CHANGED:
+    return "ATOM_SPLITSCREEN_UI_CHANGED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_DNS_HANDSHAKE_REPORTED:
+    return "ATOM_NETWORK_DNS_HANDSHAKE_REPORTED";
 
-  using FieldMetadata_Name =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      PackagesList_PackageInfo>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_CODE_PATH_COUNTER:
+    return "ATOM_BLUETOOTH_CODE_PATH_COUNTER";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_LE_BATCH_SCAN_REPORT_DELAY:
+    return "ATOM_BLUETOOTH_LE_BATCH_SCAN_REPORT_DELAY";
 
-  using FieldMetadata_Uid =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      PackagesList_PackageInfo>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ACCESSIBILITY_FLOATING_MENU_UI_CHANGED:
+    return "ATOM_ACCESSIBILITY_FLOATING_MENU_UI_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Uid kUid() { return {}; }
-  void set_uid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NEURALNETWORKS_COMPILATION_COMPLETED:
+    return "ATOM_NEURALNETWORKS_COMPILATION_COMPLETED";
 
-  using FieldMetadata_Debuggable =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      PackagesList_PackageInfo>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NEURALNETWORKS_EXECUTION_COMPLETED:
+    return "ATOM_NEURALNETWORKS_EXECUTION_COMPLETED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Debuggable kDebuggable() { return {}; }
-  void set_debuggable(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_Debuggable::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NEURALNETWORKS_COMPILATION_FAILED:
+    return "ATOM_NEURALNETWORKS_COMPILATION_FAILED";
 
-  using FieldMetadata_ProfileableFromShell =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      PackagesList_PackageInfo>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NEURALNETWORKS_EXECUTION_FAILED:
+    return "ATOM_NEURALNETWORKS_EXECUTION_FAILED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProfileableFromShell kProfileableFromShell() { return {}; }
-  void set_profileable_from_shell(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProfileableFromShell::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CONTEXT_HUB_BOOTED:
+    return "ATOM_CONTEXT_HUB_BOOTED";
 
-  using FieldMetadata_VersionCode =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      PackagesList_PackageInfo>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CONTEXT_HUB_RESTARTED:
+    return "ATOM_CONTEXT_HUB_RESTARTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VersionCode kVersionCode() { return {}; }
-  void set_version_code(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VersionCode::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CONTEXT_HUB_LOADED_NANOAPP_SNAPSHOT_REPORTED:
+    return "ATOM_CONTEXT_HUB_LOADED_NANOAPP_SNAPSHOT_REPORTED";
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/chrome/chrome_benchmark_metadata.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CHRE_CODE_DOWNLOAD_TRANSACTED:
+    return "ATOM_CHRE_CODE_DOWNLOAD_TRANSACTED";
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CHROME_CHROME_BENCHMARK_METADATA_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CHROME_CHROME_BENCHMARK_METADATA_PROTO_H_
+  case ::perfetto::protos::pbzero::AtomId::ATOM_UWB_SESSION_INITED:
+    return "ATOM_UWB_SESSION_INITED";
 
-#include <stddef.h>
-#include <stdint.h>
+  case ::perfetto::protos::pbzero::AtomId::ATOM_UWB_SESSION_CLOSED:
+    return "ATOM_UWB_SESSION_CLOSED";
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  case ::perfetto::protos::pbzero::AtomId::ATOM_UWB_FIRST_RANGING_RECEIVED:
+    return "ATOM_UWB_FIRST_RANGING_RECEIVED";
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  case ::perfetto::protos::pbzero::AtomId::ATOM_UWB_RANGING_MEASUREMENT_RECEIVED:
+    return "ATOM_UWB_RANGING_MEASUREMENT_RECEIVED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TEXT_CLASSIFIER_DOWNLOAD_WORK_SCHEDULED:
+    return "ATOM_TEXT_CLASSIFIER_DOWNLOAD_WORK_SCHEDULED";
 
-class ChromeBenchmarkMetadata_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  ChromeBenchmarkMetadata_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeBenchmarkMetadata_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeBenchmarkMetadata_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_benchmark_start_time_us() const { return at<1>().valid(); }
-  int64_t benchmark_start_time_us() const { return at<1>().as_int64(); }
-  bool has_story_run_time_us() const { return at<2>().valid(); }
-  int64_t story_run_time_us() const { return at<2>().as_int64(); }
-  bool has_benchmark_name() const { return at<3>().valid(); }
-  ::protozero::ConstChars benchmark_name() const { return at<3>().as_string(); }
-  bool has_benchmark_description() const { return at<4>().valid(); }
-  ::protozero::ConstChars benchmark_description() const { return at<4>().as_string(); }
-  bool has_label() const { return at<5>().valid(); }
-  ::protozero::ConstChars label() const { return at<5>().as_string(); }
-  bool has_story_name() const { return at<6>().valid(); }
-  ::protozero::ConstChars story_name() const { return at<6>().as_string(); }
-  bool has_story_tags() const { return at<7>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> story_tags() const { return GetRepeated<::protozero::ConstChars>(7); }
-  bool has_story_run_index() const { return at<8>().valid(); }
-  int32_t story_run_index() const { return at<8>().as_int32(); }
-  bool has_had_failures() const { return at<9>().valid(); }
-  bool had_failures() const { return at<9>().as_bool(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TEXT_CLASSIFIER_DOWNLOAD_WORK_COMPLETED:
+    return "ATOM_TEXT_CLASSIFIER_DOWNLOAD_WORK_COMPLETED";
 
-class ChromeBenchmarkMetadata : public ::protozero::Message {
- public:
-  using Decoder = ChromeBenchmarkMetadata_Decoder;
-  enum : int32_t {
-    kBenchmarkStartTimeUsFieldNumber = 1,
-    kStoryRunTimeUsFieldNumber = 2,
-    kBenchmarkNameFieldNumber = 3,
-    kBenchmarkDescriptionFieldNumber = 4,
-    kLabelFieldNumber = 5,
-    kStoryNameFieldNumber = 6,
-    kStoryTagsFieldNumber = 7,
-    kStoryRunIndexFieldNumber = 8,
-    kHadFailuresFieldNumber = 9,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeBenchmarkMetadata"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CLIPBOARD_CLEARED:
+    return "ATOM_CLIPBOARD_CLEARED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_VM_CREATION_REQUESTED:
+    return "ATOM_VM_CREATION_REQUESTED";
 
-  using FieldMetadata_BenchmarkStartTimeUs =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ChromeBenchmarkMetadata>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NEARBY_DEVICE_SCAN_STATE_CHANGED:
+    return "ATOM_NEARBY_DEVICE_SCAN_STATE_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BenchmarkStartTimeUs kBenchmarkStartTimeUs() { return {}; }
-  void set_benchmark_start_time_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BenchmarkStartTimeUs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APPLICATION_LOCALES_CHANGED:
+    return "ATOM_APPLICATION_LOCALES_CHANGED";
 
-  using FieldMetadata_StoryRunTimeUs =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ChromeBenchmarkMetadata>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_AUDIOTRACKSTATUS_REPORTED:
+    return "ATOM_MEDIAMETRICS_AUDIOTRACKSTATUS_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StoryRunTimeUs kStoryRunTimeUs() { return {}; }
-  void set_story_run_time_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StoryRunTimeUs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_FOLD_STATE_DURATION_REPORTED:
+    return "ATOM_FOLD_STATE_DURATION_REPORTED";
 
-  using FieldMetadata_BenchmarkName =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeBenchmarkMetadata>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LOCATION_TIME_ZONE_PROVIDER_CONTROLLER_STATE_CHANGED:
+    return "ATOM_LOCATION_TIME_ZONE_PROVIDER_CONTROLLER_STATE_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BenchmarkName kBenchmarkName() { return {}; }
-  void set_benchmark_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_BenchmarkName::kFieldId, data, size);
-  }
-  void set_benchmark_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_BenchmarkName::kFieldId, chars.data, chars.size);
-  }
-  void set_benchmark_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_BenchmarkName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DISPLAY_HBM_STATE_CHANGED:
+    return "ATOM_DISPLAY_HBM_STATE_CHANGED";
 
-  using FieldMetadata_BenchmarkDescription =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeBenchmarkMetadata>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DISPLAY_HBM_BRIGHTNESS_CHANGED:
+    return "ATOM_DISPLAY_HBM_BRIGHTNESS_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BenchmarkDescription kBenchmarkDescription() { return {}; }
-  void set_benchmark_description(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_BenchmarkDescription::kFieldId, data, size);
-  }
-  void set_benchmark_description(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_BenchmarkDescription::kFieldId, chars.data, chars.size);
-  }
-  void set_benchmark_description(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_BenchmarkDescription::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PERSISTENT_URI_PERMISSIONS_FLUSHED:
+    return "ATOM_PERSISTENT_URI_PERMISSIONS_FLUSHED";
 
-  using FieldMetadata_Label =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeBenchmarkMetadata>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_EARLY_BOOT_COMP_OS_ARTIFACTS_CHECK_REPORTED:
+    return "ATOM_EARLY_BOOT_COMP_OS_ARTIFACTS_CHECK_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Label kLabel() { return {}; }
-  void set_label(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Label::kFieldId, data, size);
-  }
-  void set_label(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Label::kFieldId, chars.data, chars.size);
-  }
-  void set_label(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Label::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_VBMETA_DIGEST_REPORTED:
+    return "ATOM_VBMETA_DIGEST_REPORTED";
 
-  using FieldMetadata_StoryName =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeBenchmarkMetadata>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APEX_INFO_GATHERED:
+    return "ATOM_APEX_INFO_GATHERED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StoryName kStoryName() { return {}; }
-  void set_story_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_StoryName::kFieldId, data, size);
-  }
-  void set_story_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_StoryName::kFieldId, chars.data, chars.size);
-  }
-  void set_story_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_StoryName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PVM_INFO_GATHERED:
+    return "ATOM_PVM_INFO_GATHERED";
 
-  using FieldMetadata_StoryTags =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeBenchmarkMetadata>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_SETTINGS_UI_INTERACTED:
+    return "ATOM_WEAR_SETTINGS_UI_INTERACTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StoryTags kStoryTags() { return {}; }
-  void add_story_tags(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_StoryTags::kFieldId, data, size);
-  }
-  void add_story_tags(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_StoryTags::kFieldId, chars.data, chars.size);
-  }
-  void add_story_tags(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_StoryTags::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TRACING_SERVICE_REPORT_EVENT:
+    return "ATOM_TRACING_SERVICE_REPORT_EVENT";
 
-  using FieldMetadata_StoryRunIndex =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ChromeBenchmarkMetadata>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_AUDIORECORDSTATUS_REPORTED:
+    return "ATOM_MEDIAMETRICS_AUDIORECORDSTATUS_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StoryRunIndex kStoryRunIndex() { return {}; }
-  void set_story_run_index(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StoryRunIndex::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LAUNCHER_LATENCY:
+    return "ATOM_LAUNCHER_LATENCY";
 
-  using FieldMetadata_HadFailures =
-    ::protozero::proto_utils::FieldMetadata<
-      9,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeBenchmarkMetadata>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DROPBOX_ENTRY_DROPPED:
+    return "ATOM_DROPBOX_ENTRY_DROPPED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HadFailures kHadFailures() { return {}; }
-  void set_had_failures(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_HadFailures::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_P2P_CONNECTION_REPORTED:
+    return "ATOM_WIFI_P2P_CONNECTION_REPORTED";
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/chrome/chrome_metadata.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GAME_STATE_CHANGED:
+    return "ATOM_GAME_STATE_CHANGED";
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CHROME_CHROME_METADATA_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CHROME_CHROME_METADATA_PROTO_H_
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HOTWORD_DETECTOR_CREATE_REQUESTED:
+    return "ATOM_HOTWORD_DETECTOR_CREATE_REQUESTED";
 
-#include <stddef.h>
-#include <stdint.h>
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HOTWORD_DETECTION_SERVICE_INIT_RESULT_REPORTED:
+    return "ATOM_HOTWORD_DETECTION_SERVICE_INIT_RESULT_REPORTED";
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HOTWORD_DETECTION_SERVICE_RESTARTED:
+    return "ATOM_HOTWORD_DETECTION_SERVICE_RESTARTED";
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HOTWORD_DETECTOR_KEYPHRASE_TRIGGERED:
+    return "ATOM_HOTWORD_DETECTOR_KEYPHRASE_TRIGGERED";
 
-class BackgroundTracingMetadata;
-class BackgroundTracingMetadata_TriggerRule;
-class BackgroundTracingMetadata_TriggerRule_HistogramRule;
-class BackgroundTracingMetadata_TriggerRule_NamedRule;
-namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule_NamedRule {
-enum EventType : int32_t;
-}  // namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule_NamedRule
-using BackgroundTracingMetadata_TriggerRule_NamedRule_EventType = perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule_NamedRule::EventType;
-namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule {
-enum TriggerType : int32_t;
-}  // namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule
-using BackgroundTracingMetadata_TriggerRule_TriggerType = perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule::TriggerType;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HOTWORD_DETECTOR_EVENTS:
+    return "ATOM_HOTWORD_DETECTOR_EVENTS";
 
-namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule {
-enum TriggerType : int32_t {
-  TRIGGER_UNSPECIFIED = 0,
-  MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE = 1,
-  MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED = 2,
-};
-} // namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule
-using BackgroundTracingMetadata_TriggerRule_TriggerType = perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule::TriggerType;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BOOT_COMPLETED_BROADCAST_COMPLETION_LATENCY_REPORTED:
+    return "ATOM_BOOT_COMPLETED_BROADCAST_COMPLETION_LATENCY_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CONTACTS_INDEXER_UPDATE_STATS_REPORTED:
+    return "ATOM_CONTACTS_INDEXER_UPDATE_STATS_REPORTED";
 
-constexpr BackgroundTracingMetadata_TriggerRule_TriggerType BackgroundTracingMetadata_TriggerRule_TriggerType_MIN = BackgroundTracingMetadata_TriggerRule_TriggerType::TRIGGER_UNSPECIFIED;
-constexpr BackgroundTracingMetadata_TriggerRule_TriggerType BackgroundTracingMetadata_TriggerRule_TriggerType_MAX = BackgroundTracingMetadata_TriggerRule_TriggerType::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_BACKGROUND_RESTRICTIONS_INFO:
+    return "ATOM_APP_BACKGROUND_RESTRICTIONS_INFO";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MMS_SMS_PROVIDER_GET_THREAD_ID_FAILED:
+    return "ATOM_MMS_SMS_PROVIDER_GET_THREAD_ID_FAILED";
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* BackgroundTracingMetadata_TriggerRule_TriggerType_Name(::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_TriggerType value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_TriggerType::TRIGGER_UNSPECIFIED:
-    return "TRIGGER_UNSPECIFIED";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MMS_SMS_DATABASE_HELPER_ON_UPGRADE_FAILED:
+    return "ATOM_MMS_SMS_DATABASE_HELPER_ON_UPGRADE_FAILED";
 
-  case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_TriggerType::MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE:
-    return "MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PERMISSION_REMINDER_NOTIFICATION_INTERACTED:
+    return "ATOM_PERMISSION_REMINDER_NOTIFICATION_INTERACTED";
 
-  case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_TriggerType::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED:
-    return "MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RECENT_PERMISSION_DECISIONS_INTERACTED:
+    return "ATOM_RECENT_PERMISSION_DECISIONS_INTERACTED";
 
-namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule_NamedRule {
-enum EventType : int32_t {
-  UNSPECIFIED = 0,
-  SESSION_RESTORE = 1,
-  NAVIGATION = 2,
-  STARTUP = 3,
-  REACHED_CODE = 4,
-  CONTENT_TRIGGER = 5,
-  TEST_RULE = 1000,
-};
-} // namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule_NamedRule
-using BackgroundTracingMetadata_TriggerRule_NamedRule_EventType = perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule_NamedRule::EventType;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GNSS_PSDS_DOWNLOAD_REPORTED:
+    return "ATOM_GNSS_PSDS_DOWNLOAD_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LE_AUDIO_CONNECTION_SESSION_REPORTED:
+    return "ATOM_LE_AUDIO_CONNECTION_SESSION_REPORTED";
 
-constexpr BackgroundTracingMetadata_TriggerRule_NamedRule_EventType BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_MIN = BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::UNSPECIFIED;
-constexpr BackgroundTracingMetadata_TriggerRule_NamedRule_EventType BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_MAX = BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::TEST_RULE;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LE_AUDIO_BROADCAST_SESSION_REPORTED:
+    return "ATOM_LE_AUDIO_BROADCAST_SESSION_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DREAM_UI_EVENT_REPORTED:
+    return "ATOM_DREAM_UI_EVENT_REPORTED";
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_Name(::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::UNSPECIFIED:
-    return "UNSPECIFIED";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TASK_MANAGER_EVENT_REPORTED:
+    return "ATOM_TASK_MANAGER_EVENT_REPORTED";
 
-  case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::SESSION_RESTORE:
-    return "SESSION_RESTORE";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CDM_ASSOCIATION_ACTION:
+    return "ATOM_CDM_ASSOCIATION_ACTION";
 
-  case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::NAVIGATION:
-    return "NAVIGATION";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MAGNIFICATION_TRIPLE_TAP_AND_HOLD_ACTIVATED_SESSION_REPORTED:
+    return "ATOM_MAGNIFICATION_TRIPLE_TAP_AND_HOLD_ACTIVATED_SESSION_REPORTED";
 
-  case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::STARTUP:
-    return "STARTUP";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MAGNIFICATION_FOLLOW_TYPING_FOCUS_ACTIVATED_SESSION_REPORTED:
+    return "ATOM_MAGNIFICATION_FOLLOW_TYPING_FOCUS_ACTIVATED_SESSION_REPORTED";
 
-  case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::REACHED_CODE:
-    return "REACHED_CODE";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ACCESSIBILITY_TEXT_READING_OPTIONS_CHANGED:
+    return "ATOM_ACCESSIBILITY_TEXT_READING_OPTIONS_CHANGED";
 
-  case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::CONTENT_TRIGGER:
-    return "CONTENT_TRIGGER";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_SETUP_FAILURE_CRASH_REPORTED:
+    return "ATOM_WIFI_SETUP_FAILURE_CRASH_REPORTED";
 
-  case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::TEST_RULE:
-    return "TEST_RULE";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+  case ::perfetto::protos::pbzero::AtomId::ATOM_UWB_DEVICE_ERROR_REPORTED:
+    return "ATOM_UWB_DEVICE_ERROR_REPORTED";
 
-class BackgroundTracingMetadata_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  BackgroundTracingMetadata_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit BackgroundTracingMetadata_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit BackgroundTracingMetadata_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_triggered_rule() const { return at<1>().valid(); }
-  ::protozero::ConstBytes triggered_rule() const { return at<1>().as_bytes(); }
-  bool has_active_rules() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> active_rules() const { return GetRepeated<::protozero::ConstBytes>(2); }
-  bool has_scenario_name_hash() const { return at<3>().valid(); }
-  uint32_t scenario_name_hash() const { return at<3>().as_uint32(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ISOLATED_COMPILATION_SCHEDULED:
+    return "ATOM_ISOLATED_COMPILATION_SCHEDULED";
 
-class BackgroundTracingMetadata : public ::protozero::Message {
- public:
-  using Decoder = BackgroundTracingMetadata_Decoder;
-  enum : int32_t {
-    kTriggeredRuleFieldNumber = 1,
-    kActiveRulesFieldNumber = 2,
-    kScenarioNameHashFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.BackgroundTracingMetadata"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ISOLATED_COMPILATION_ENDED:
+    return "ATOM_ISOLATED_COMPILATION_ENDED";
 
-  using TriggerRule = ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ONS_OPPORTUNISTIC_ESIM_PROVISIONING_COMPLETE:
+    return "ATOM_ONS_OPPORTUNISTIC_ESIM_PROVISIONING_COMPLETE";
 
-  using FieldMetadata_TriggeredRule =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      BackgroundTracingMetadata_TriggerRule,
-      BackgroundTracingMetadata>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SYSTEM_SERVER_PRE_WATCHDOG_OCCURRED:
+    return "ATOM_SYSTEM_SERVER_PRE_WATCHDOG_OCCURRED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TriggeredRule kTriggeredRule() { return {}; }
-  template <typename T = BackgroundTracingMetadata_TriggerRule> T* set_triggered_rule() {
-    return BeginNestedMessage<T>(1);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TELEPHONY_ANOMALY_DETECTED:
+    return "ATOM_TELEPHONY_ANOMALY_DETECTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LETTERBOX_POSITION_CHANGED:
+    return "ATOM_LETTERBOX_POSITION_CHANGED";
 
-  using FieldMetadata_ActiveRules =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      BackgroundTracingMetadata_TriggerRule,
-      BackgroundTracingMetadata>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_REMOTE_KEY_PROVISIONING_ATTEMPT:
+    return "ATOM_REMOTE_KEY_PROVISIONING_ATTEMPT";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ActiveRules kActiveRules() { return {}; }
-  template <typename T = BackgroundTracingMetadata_TriggerRule> T* add_active_rules() {
-    return BeginNestedMessage<T>(2);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_REMOTE_KEY_PROVISIONING_NETWORK_INFO:
+    return "ATOM_REMOTE_KEY_PROVISIONING_NETWORK_INFO";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_REMOTE_KEY_PROVISIONING_TIMING:
+    return "ATOM_REMOTE_KEY_PROVISIONING_TIMING";
 
-  using FieldMetadata_ScenarioNameHash =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kFixed32,
-      uint32_t,
-      BackgroundTracingMetadata>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAOUTPUT_OP_INTERACTION_REPORT:
+    return "ATOM_MEDIAOUTPUT_OP_INTERACTION_REPORT";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ScenarioNameHash kScenarioNameHash() { return {}; }
-  void set_scenario_name_hash(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ScenarioNameHash::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kFixed32>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SYNC_EXEMPTION_OCCURRED:
+    return "ATOM_SYNC_EXEMPTION_OCCURRED";
 
-class BackgroundTracingMetadata_TriggerRule_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  BackgroundTracingMetadata_TriggerRule_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit BackgroundTracingMetadata_TriggerRule_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit BackgroundTracingMetadata_TriggerRule_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_trigger_type() const { return at<1>().valid(); }
-  int32_t trigger_type() const { return at<1>().as_int32(); }
-  bool has_histogram_rule() const { return at<2>().valid(); }
-  ::protozero::ConstBytes histogram_rule() const { return at<2>().as_bytes(); }
-  bool has_named_rule() const { return at<3>().valid(); }
-  ::protozero::ConstBytes named_rule() const { return at<3>().as_bytes(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_PRESENTATION_EVENT_REPORTED:
+    return "ATOM_AUTOFILL_PRESENTATION_EVENT_REPORTED";
 
-class BackgroundTracingMetadata_TriggerRule : public ::protozero::Message {
- public:
-  using Decoder = BackgroundTracingMetadata_TriggerRule_Decoder;
-  enum : int32_t {
-    kTriggerTypeFieldNumber = 1,
-    kHistogramRuleFieldNumber = 2,
-    kNamedRuleFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.BackgroundTracingMetadata.TriggerRule"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DOCK_STATE_CHANGED:
+    return "ATOM_DOCK_STATE_CHANGED";
 
-  using HistogramRule = ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_HistogramRule;
-  using NamedRule = ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SAFETY_SOURCE_STATE_COLLECTED:
+    return "ATOM_SAFETY_SOURCE_STATE_COLLECTED";
 
-  using TriggerType = ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_TriggerType;
-  static inline const char* TriggerType_Name(TriggerType value) {
-    return ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_TriggerType_Name(value);
-  }
-  static const TriggerType TRIGGER_UNSPECIFIED = TriggerType::TRIGGER_UNSPECIFIED;
-  static const TriggerType MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE = TriggerType::MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE;
-  static const TriggerType MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED = TriggerType::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SAFETY_CENTER_SYSTEM_EVENT_REPORTED:
+    return "ATOM_SAFETY_CENTER_SYSTEM_EVENT_REPORTED";
 
-  using FieldMetadata_TriggerType =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_TriggerType,
-      BackgroundTracingMetadata_TriggerRule>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SAFETY_CENTER_INTERACTION_REPORTED:
+    return "ATOM_SAFETY_CENTER_INTERACTION_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TriggerType kTriggerType() { return {}; }
-  void set_trigger_type(::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_TriggerType value) {
-    static constexpr uint32_t field_id = FieldMetadata_TriggerType::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SETTINGS_PROVIDER_SETTING_CHANGED:
+    return "ATOM_SETTINGS_PROVIDER_SETTING_CHANGED";
 
-  using FieldMetadata_HistogramRule =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      BackgroundTracingMetadata_TriggerRule_HistogramRule,
-      BackgroundTracingMetadata_TriggerRule>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BROADCAST_DELIVERY_EVENT_REPORTED:
+    return "ATOM_BROADCAST_DELIVERY_EVENT_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HistogramRule kHistogramRule() { return {}; }
-  template <typename T = BackgroundTracingMetadata_TriggerRule_HistogramRule> T* set_histogram_rule() {
-    return BeginNestedMessage<T>(2);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SERVICE_REQUEST_EVENT_REPORTED:
+    return "ATOM_SERVICE_REQUEST_EVENT_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PROVIDER_ACQUISITION_EVENT_REPORTED:
+    return "ATOM_PROVIDER_ACQUISITION_EVENT_REPORTED";
 
-  using FieldMetadata_NamedRule =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      BackgroundTracingMetadata_TriggerRule_NamedRule,
-      BackgroundTracingMetadata_TriggerRule>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_DEVICE_NAME_REPORTED:
+    return "ATOM_BLUETOOTH_DEVICE_NAME_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NamedRule kNamedRule() { return {}; }
-  template <typename T = BackgroundTracingMetadata_TriggerRule_NamedRule> T* set_named_rule() {
-    return BeginNestedMessage<T>(3);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CB_CONFIG_UPDATED:
+    return "ATOM_CB_CONFIG_UPDATED";
 
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CB_MODULE_ERROR_REPORTED:
+    return "ATOM_CB_MODULE_ERROR_REPORTED";
 
-class BackgroundTracingMetadata_TriggerRule_NamedRule_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  BackgroundTracingMetadata_TriggerRule_NamedRule_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit BackgroundTracingMetadata_TriggerRule_NamedRule_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit BackgroundTracingMetadata_TriggerRule_NamedRule_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_event_type() const { return at<1>().valid(); }
-  int32_t event_type() const { return at<1>().as_int32(); }
-  bool has_content_trigger_name_hash() const { return at<2>().valid(); }
-  uint64_t content_trigger_name_hash() const { return at<2>().as_uint64(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CB_SERVICE_FEATURE_CHANGED:
+    return "ATOM_CB_SERVICE_FEATURE_CHANGED";
 
-class BackgroundTracingMetadata_TriggerRule_NamedRule : public ::protozero::Message {
- public:
-  using Decoder = BackgroundTracingMetadata_TriggerRule_NamedRule_Decoder;
-  enum : int32_t {
-    kEventTypeFieldNumber = 1,
-    kContentTriggerNameHashFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CB_RECEIVER_FEATURE_CHANGED:
+    return "ATOM_CB_RECEIVER_FEATURE_CHANGED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PRIVACY_SIGNAL_NOTIFICATION_INTERACTION:
+    return "ATOM_PRIVACY_SIGNAL_NOTIFICATION_INTERACTION";
 
-  using EventType = ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType;
-  static inline const char* EventType_Name(EventType value) {
-    return ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_Name(value);
-  }
-  static const EventType UNSPECIFIED = EventType::UNSPECIFIED;
-  static const EventType SESSION_RESTORE = EventType::SESSION_RESTORE;
-  static const EventType NAVIGATION = EventType::NAVIGATION;
-  static const EventType STARTUP = EventType::STARTUP;
-  static const EventType REACHED_CODE = EventType::REACHED_CODE;
-  static const EventType CONTENT_TRIGGER = EventType::CONTENT_TRIGGER;
-  static const EventType TEST_RULE = EventType::TEST_RULE;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PRIVACY_SIGNAL_ISSUE_CARD_INTERACTION:
+    return "ATOM_PRIVACY_SIGNAL_ISSUE_CARD_INTERACTION";
 
-  using FieldMetadata_EventType =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType,
-      BackgroundTracingMetadata_TriggerRule_NamedRule>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PRIVACY_SIGNALS_JOB_FAILURE:
+    return "ATOM_PRIVACY_SIGNALS_JOB_FAILURE";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EventType kEventType() { return {}; }
-  void set_event_type(::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType value) {
-    static constexpr uint32_t field_id = FieldMetadata_EventType::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_VIBRATION_REPORTED:
+    return "ATOM_VIBRATION_REPORTED";
 
-  using FieldMetadata_ContentTriggerNameHash =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
-      uint64_t,
-      BackgroundTracingMetadata_TriggerRule_NamedRule>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_UWB_RANGING_START:
+    return "ATOM_UWB_RANGING_START";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ContentTriggerNameHash kContentTriggerNameHash() { return {}; }
-  void set_content_trigger_name_hash(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ContentTriggerNameHash::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_COMPACTED_V2:
+    return "ATOM_APP_COMPACTED_V2";
 
-class BackgroundTracingMetadata_TriggerRule_HistogramRule_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  BackgroundTracingMetadata_TriggerRule_HistogramRule_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit BackgroundTracingMetadata_TriggerRule_HistogramRule_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit BackgroundTracingMetadata_TriggerRule_HistogramRule_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_histogram_name_hash() const { return at<1>().valid(); }
-  uint64_t histogram_name_hash() const { return at<1>().as_uint64(); }
-  bool has_histogram_min_trigger() const { return at<2>().valid(); }
-  int64_t histogram_min_trigger() const { return at<2>().as_int64(); }
-  bool has_histogram_max_trigger() const { return at<3>().valid(); }
-  int64_t histogram_max_trigger() const { return at<3>().as_int64(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DISPLAY_BRIGHTNESS_CHANGED:
+    return "ATOM_DISPLAY_BRIGHTNESS_CHANGED";
 
-class BackgroundTracingMetadata_TriggerRule_HistogramRule : public ::protozero::Message {
- public:
-  using Decoder = BackgroundTracingMetadata_TriggerRule_HistogramRule_Decoder;
-  enum : int32_t {
-    kHistogramNameHashFieldNumber = 1,
-    kHistogramMinTriggerFieldNumber = 2,
-    kHistogramMaxTriggerFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ACTIVITY_ACTION_BLOCKED:
+    return "ATOM_ACTIVITY_ACTION_BLOCKED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_DNS_SERVER_SUPPORT_REPORTED:
+    return "ATOM_NETWORK_DNS_SERVER_SUPPORT_REPORTED";
 
-  using FieldMetadata_HistogramNameHash =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
-      uint64_t,
-      BackgroundTracingMetadata_TriggerRule_HistogramRule>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_VM_BOOTED:
+    return "ATOM_VM_BOOTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HistogramNameHash kHistogramNameHash() { return {}; }
-  void set_histogram_name_hash(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_HistogramNameHash::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_VM_EXITED:
+    return "ATOM_VM_EXITED";
 
-  using FieldMetadata_HistogramMinTrigger =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      BackgroundTracingMetadata_TriggerRule_HistogramRule>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AMBIENT_BRIGHTNESS_STATS_REPORTED:
+    return "ATOM_AMBIENT_BRIGHTNESS_STATS_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HistogramMinTrigger kHistogramMinTrigger() { return {}; }
-  void set_histogram_min_trigger(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_HistogramMinTrigger::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_SPATIALIZERCAPABILITIES_REPORTED:
+    return "ATOM_MEDIAMETRICS_SPATIALIZERCAPABILITIES_REPORTED";
 
-  using FieldMetadata_HistogramMaxTrigger =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      BackgroundTracingMetadata_TriggerRule_HistogramRule>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_SPATIALIZERDEVICEENABLED_REPORTED:
+    return "ATOM_MEDIAMETRICS_SPATIALIZERDEVICEENABLED_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HistogramMaxTrigger kHistogramMaxTrigger() { return {}; }
-  void set_histogram_max_trigger(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_HistogramMaxTrigger::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_HEADTRACKERDEVICEENABLED_REPORTED:
+    return "ATOM_MEDIAMETRICS_HEADTRACKERDEVICEENABLED_REPORTED";
 
-class ChromeMetadataPacket_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  ChromeMetadataPacket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeMetadataPacket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeMetadataPacket_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_background_tracing_metadata() const { return at<1>().valid(); }
-  ::protozero::ConstBytes background_tracing_metadata() const { return at<1>().as_bytes(); }
-  bool has_chrome_version_code() const { return at<2>().valid(); }
-  int32_t chrome_version_code() const { return at<2>().as_int32(); }
-  bool has_enabled_categories() const { return at<3>().valid(); }
-  ::protozero::ConstChars enabled_categories() const { return at<3>().as_string(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_HEADTRACKERDEVICESUPPORTED_REPORTED:
+    return "ATOM_MEDIAMETRICS_HEADTRACKERDEVICESUPPORTED_REPORTED";
 
-class ChromeMetadataPacket : public ::protozero::Message {
- public:
-  using Decoder = ChromeMetadataPacket_Decoder;
-  enum : int32_t {
-    kBackgroundTracingMetadataFieldNumber = 1,
-    kChromeVersionCodeFieldNumber = 2,
-    kEnabledCategoriesFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeMetadataPacket"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HEARING_AID_INFO_REPORTED:
+    return "ATOM_HEARING_AID_INFO_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_WIDE_JOB_CONSTRAINT_CHANGED:
+    return "ATOM_DEVICE_WIDE_JOB_CONSTRAINT_CHANGED";
 
-  using FieldMetadata_BackgroundTracingMetadata =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      BackgroundTracingMetadata,
-      ChromeMetadataPacket>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AMBIENT_MODE_CHANGED:
+    return "ATOM_AMBIENT_MODE_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BackgroundTracingMetadata kBackgroundTracingMetadata() { return {}; }
-  template <typename T = BackgroundTracingMetadata> T* set_background_tracing_metadata() {
-    return BeginNestedMessage<T>(1);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ANR_LATENCY_REPORTED:
+    return "ATOM_ANR_LATENCY_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RESOURCE_API_INFO:
+    return "ATOM_RESOURCE_API_INFO";
 
-  using FieldMetadata_ChromeVersionCode =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ChromeMetadataPacket>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SYSTEM_DEFAULT_NETWORK_CHANGED:
+    return "ATOM_SYSTEM_DEFAULT_NETWORK_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeVersionCode kChromeVersionCode() { return {}; }
-  void set_chrome_version_code(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ChromeVersionCode::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_IWLAN_SETUP_DATA_CALL_RESULT_REPORTED:
+    return "ATOM_IWLAN_SETUP_DATA_CALL_RESULT_REPORTED";
 
-  using FieldMetadata_EnabledCategories =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeMetadataPacket>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_IWLAN_PDN_DISCONNECTED_REASON_REPORTED:
+    return "ATOM_IWLAN_PDN_DISCONNECTED_REASON_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EnabledCategories kEnabledCategories() { return {}; }
-  void set_enabled_categories(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_EnabledCategories::kFieldId, data, size);
-  }
-  void set_enabled_categories(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_EnabledCategories::kFieldId, chars.data, chars.size);
-  }
-  void set_enabled_categories(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_EnabledCategories::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AIRPLANE_MODE_SESSION_REPORTED:
+    return "ATOM_AIRPLANE_MODE_SESSION_REPORTED";
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/chrome/chrome_trace_event.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+  case ::perfetto::protos::pbzero::AtomId::ATOM_VM_CPU_STATUS_REPORTED:
+    return "ATOM_VM_CPU_STATUS_REPORTED";
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CHROME_CHROME_TRACE_EVENT_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CHROME_CHROME_TRACE_EVENT_PROTO_H_
+  case ::perfetto::protos::pbzero::AtomId::ATOM_VM_MEM_STATUS_REPORTED:
+    return "ATOM_VM_MEM_STATUS_REPORTED";
 
-#include <stddef.h>
-#include <stdint.h>
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PACKAGE_INSTALLATION_SESSION_REPORTED:
+    return "ATOM_PACKAGE_INSTALLATION_SESSION_REPORTED";
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEFAULT_NETWORK_REMATCH_INFO:
+    return "ATOM_DEFAULT_NETWORK_REMATCH_INFO";
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_SELECTION_PERFORMANCE:
+    return "ATOM_NETWORK_SELECTION_PERFORMANCE";
 
-class ChromeLegacyJsonTrace;
-class ChromeMetadata;
-class ChromeStringTableEntry;
-class ChromeTraceEvent;
-class ChromeTraceEvent_Arg;
-class ChromeTracedValue;
-namespace perfetto_pbzero_enum_ChromeLegacyJsonTrace {
-enum TraceType : int32_t;
-}  // namespace perfetto_pbzero_enum_ChromeLegacyJsonTrace
-using ChromeLegacyJsonTrace_TraceType = perfetto_pbzero_enum_ChromeLegacyJsonTrace::TraceType;
-namespace perfetto_pbzero_enum_ChromeTracedValue {
-enum NestedType : int32_t;
-}  // namespace perfetto_pbzero_enum_ChromeTracedValue
-using ChromeTracedValue_NestedType = perfetto_pbzero_enum_ChromeTracedValue::NestedType;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_NSD_REPORTED:
+    return "ATOM_NETWORK_NSD_REPORTED";
 
-namespace perfetto_pbzero_enum_ChromeLegacyJsonTrace {
-enum TraceType : int32_t {
-  USER_TRACE = 0,
-  SYSTEM_TRACE = 1,
-};
-} // namespace perfetto_pbzero_enum_ChromeLegacyJsonTrace
-using ChromeLegacyJsonTrace_TraceType = perfetto_pbzero_enum_ChromeLegacyJsonTrace::TraceType;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_DISCONNECTION_REASON_REPORTED:
+    return "ATOM_BLUETOOTH_DISCONNECTION_REASON_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_LOCAL_VERSIONS_REPORTED:
+    return "ATOM_BLUETOOTH_LOCAL_VERSIONS_REPORTED";
 
-constexpr ChromeLegacyJsonTrace_TraceType ChromeLegacyJsonTrace_TraceType_MIN = ChromeLegacyJsonTrace_TraceType::USER_TRACE;
-constexpr ChromeLegacyJsonTrace_TraceType ChromeLegacyJsonTrace_TraceType_MAX = ChromeLegacyJsonTrace_TraceType::SYSTEM_TRACE;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_REMOTE_SUPPORTED_FEATURES_REPORTED:
+    return "ATOM_BLUETOOTH_REMOTE_SUPPORTED_FEATURES_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_LOCAL_SUPPORTED_FEATURES_REPORTED:
+    return "ATOM_BLUETOOTH_LOCAL_SUPPORTED_FEATURES_REPORTED";
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ChromeLegacyJsonTrace_TraceType_Name(::perfetto::protos::pbzero::ChromeLegacyJsonTrace_TraceType value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ChromeLegacyJsonTrace_TraceType::USER_TRACE:
-    return "USER_TRACE";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_GATT_APP_INFO:
+    return "ATOM_BLUETOOTH_GATT_APP_INFO";
 
-  case ::perfetto::protos::pbzero::ChromeLegacyJsonTrace_TraceType::SYSTEM_TRACE:
-    return "SYSTEM_TRACE";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BRIGHTNESS_CONFIGURATION_UPDATED:
+    return "ATOM_BRIGHTNESS_CONFIGURATION_UPDATED";
 
-namespace perfetto_pbzero_enum_ChromeTracedValue {
-enum NestedType : int32_t {
-  DICT = 0,
-  ARRAY = 1,
-};
-} // namespace perfetto_pbzero_enum_ChromeTracedValue
-using ChromeTracedValue_NestedType = perfetto_pbzero_enum_ChromeTracedValue::NestedType;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_LAUNCHED:
+    return "ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_LAUNCHED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FINISHED:
+    return "ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FINISHED";
 
-constexpr ChromeTracedValue_NestedType ChromeTracedValue_NestedType_MIN = ChromeTracedValue_NestedType::DICT;
-constexpr ChromeTracedValue_NestedType ChromeTracedValue_NestedType_MAX = ChromeTracedValue_NestedType::ARRAY;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_CONNECTION_REPORTED:
+    return "ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_CONNECTION_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_DEVICE_SCAN_TRIGGERED:
+    return "ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_DEVICE_SCAN_TRIGGERED";
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ChromeTracedValue_NestedType_Name(::perfetto::protos::pbzero::ChromeTracedValue_NestedType value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ChromeTracedValue_NestedType::DICT:
-    return "DICT";
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FIRST_DEVICE_SCAN_LATENCY:
+    return "ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FIRST_DEVICE_SCAN_LATENCY";
 
-  case ::perfetto::protos::pbzero::ChromeTracedValue_NestedType::ARRAY:
-    return "ARRAY";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_CONNECT_DEVICE_LATENCY:
+    return "ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_CONNECT_DEVICE_LATENCY";
 
-class ChromeEventBundle_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  ChromeEventBundle_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeEventBundle_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeEventBundle_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_trace_events() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> trace_events() const { return GetRepeated<::protozero::ConstBytes>(1); }
-  bool has_metadata() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> metadata() const { return GetRepeated<::protozero::ConstBytes>(2); }
-  bool has_legacy_ftrace_output() const { return at<4>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> legacy_ftrace_output() const { return GetRepeated<::protozero::ConstChars>(4); }
-  bool has_legacy_json_trace() const { return at<5>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> legacy_json_trace() const { return GetRepeated<::protozero::ConstBytes>(5); }
-  bool has_string_table() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> string_table() const { return GetRepeated<::protozero::ConstBytes>(3); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PACKAGE_MANAGER_SNAPSHOT_REPORTED:
+    return "ATOM_PACKAGE_MANAGER_SNAPSHOT_REPORTED";
 
-class ChromeEventBundle : public ::protozero::Message {
- public:
-  using Decoder = ChromeEventBundle_Decoder;
-  enum : int32_t {
-    kTraceEventsFieldNumber = 1,
-    kMetadataFieldNumber = 2,
-    kLegacyFtraceOutputFieldNumber = 4,
-    kLegacyJsonTraceFieldNumber = 5,
-    kStringTableFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeEventBundle"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PACKAGE_MANAGER_APPS_FILTER_CACHE_BUILD_REPORTED:
+    return "ATOM_PACKAGE_MANAGER_APPS_FILTER_CACHE_BUILD_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PACKAGE_MANAGER_APPS_FILTER_CACHE_UPDATE_REPORTED:
+    return "ATOM_PACKAGE_MANAGER_APPS_FILTER_CACHE_UPDATE_REPORTED";
 
-  using FieldMetadata_TraceEvents =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeTraceEvent,
-      ChromeEventBundle>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LAUNCHER_IMPRESSION_EVENT:
+    return "ATOM_LAUNCHER_IMPRESSION_EVENT";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceEvents kTraceEvents() { return {}; }
-  template <typename T = ChromeTraceEvent> T* add_trace_events() {
-    return BeginNestedMessage<T>(1);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_ALL_DEVICES_SCAN_LATENCY:
+    return "ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_ALL_DEVICES_SCAN_LATENCY";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_WATCH_FACE_EDITED:
+    return "ATOM_WS_WATCH_FACE_EDITED";
 
-  using FieldMetadata_Metadata =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeMetadata,
-      ChromeEventBundle>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_WATCH_FACE_FAVORITE_ACTION_REPORTED:
+    return "ATOM_WS_WATCH_FACE_FAVORITE_ACTION_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Metadata kMetadata() { return {}; }
-  template <typename T = ChromeMetadata> T* add_metadata() {
-    return BeginNestedMessage<T>(2);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_WATCH_FACE_SET_ACTION_REPORTED:
+    return "ATOM_WS_WATCH_FACE_SET_ACTION_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PACKAGE_UNINSTALLATION_REPORTED:
+    return "ATOM_PACKAGE_UNINSTALLATION_REPORTED";
 
-  using FieldMetadata_LegacyFtraceOutput =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeEventBundle>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GAME_MODE_CHANGED:
+    return "ATOM_GAME_MODE_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LegacyFtraceOutput kLegacyFtraceOutput() { return {}; }
-  void add_legacy_ftrace_output(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_LegacyFtraceOutput::kFieldId, data, size);
-  }
-  void add_legacy_ftrace_output(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_LegacyFtraceOutput::kFieldId, chars.data, chars.size);
-  }
-  void add_legacy_ftrace_output(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_LegacyFtraceOutput::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GAME_MODE_CONFIGURATION_CHANGED:
+    return "ATOM_GAME_MODE_CONFIGURATION_CHANGED";
 
-  using FieldMetadata_LegacyJsonTrace =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeLegacyJsonTrace,
-      ChromeEventBundle>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BEDTIME_MODE_STATE_CHANGED:
+    return "ATOM_BEDTIME_MODE_STATE_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LegacyJsonTrace kLegacyJsonTrace() { return {}; }
-  template <typename T = ChromeLegacyJsonTrace> T* add_legacy_json_trace() {
-    return BeginNestedMessage<T>(5);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_SLICE_SESSION_ENDED:
+    return "ATOM_NETWORK_SLICE_SESSION_ENDED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_SLICE_DAILY_DATA_USAGE_REPORTED:
+    return "ATOM_NETWORK_SLICE_DAILY_DATA_USAGE_REPORTED";
 
-  using FieldMetadata_StringTable =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeStringTableEntry,
-      ChromeEventBundle>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_TAG_TYPE_OCCURRED:
+    return "ATOM_NFC_TAG_TYPE_OCCURRED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StringTable kStringTable() { return {}; }
-  template <typename T = ChromeStringTableEntry> T* add_string_table() {
-    return BeginNestedMessage<T>(3);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_AID_CONFLICT_OCCURRED:
+    return "ATOM_NFC_AID_CONFLICT_OCCURRED";
 
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_READER_CONFLICT_OCCURRED:
+    return "ATOM_NFC_READER_CONFLICT_OCCURRED";
 
-class ChromeLegacyJsonTrace_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  ChromeLegacyJsonTrace_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeLegacyJsonTrace_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeLegacyJsonTrace_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_type() const { return at<1>().valid(); }
-  int32_t type() const { return at<1>().as_int32(); }
-  bool has_data() const { return at<2>().valid(); }
-  ::protozero::ConstChars data() const { return at<2>().as_string(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_TILE_LIST_CHANGED:
+    return "ATOM_WS_TILE_LIST_CHANGED";
 
-class ChromeLegacyJsonTrace : public ::protozero::Message {
- public:
-  using Decoder = ChromeLegacyJsonTrace_Decoder;
-  enum : int32_t {
-    kTypeFieldNumber = 1,
-    kDataFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeLegacyJsonTrace"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GET_TYPE_ACCESSED_WITHOUT_PERMISSION:
+    return "ATOM_GET_TYPE_ACCESSED_WITHOUT_PERMISSION";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_BUNDLED_APP_INFO_GATHERED:
+    return "ATOM_MOBILE_BUNDLED_APP_INFO_GATHERED";
 
-  using TraceType = ::perfetto::protos::pbzero::ChromeLegacyJsonTrace_TraceType;
-  static inline const char* TraceType_Name(TraceType value) {
-    return ::perfetto::protos::pbzero::ChromeLegacyJsonTrace_TraceType_Name(value);
-  }
-  static const TraceType USER_TRACE = TraceType::USER_TRACE;
-  static const TraceType SYSTEM_TRACE = TraceType::SYSTEM_TRACE;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_WATCH_FACE_COMPLICATION_SET_CHANGED:
+    return "ATOM_WS_WATCH_FACE_COMPLICATION_SET_CHANGED";
 
-  using FieldMetadata_Type =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ChromeLegacyJsonTrace_TraceType,
-      ChromeLegacyJsonTrace>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_DRM_CREATED:
+    return "ATOM_MEDIA_DRM_CREATED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(::perfetto::protos::pbzero::ChromeLegacyJsonTrace_TraceType value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_DRM_ERRORED:
+    return "ATOM_MEDIA_DRM_ERRORED";
 
-  using FieldMetadata_Data =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeLegacyJsonTrace>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_DRM_SESSION_OPENED:
+    return "ATOM_MEDIA_DRM_SESSION_OPENED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Data kData() { return {}; }
-  void set_data(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Data::kFieldId, data, size);
-  }
-  void set_data(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Data::kFieldId, chars.data, chars.size);
-  }
-  void set_data(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Data::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_DRM_SESSION_CLOSED:
+    return "ATOM_MEDIA_DRM_SESSION_CLOSED";
 
-class ChromeMetadata_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  ChromeMetadata_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeMetadata_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeMetadata_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_string_value() const { return at<2>().valid(); }
-  ::protozero::ConstChars string_value() const { return at<2>().as_string(); }
-  bool has_bool_value() const { return at<3>().valid(); }
-  bool bool_value() const { return at<3>().as_bool(); }
-  bool has_int_value() const { return at<4>().valid(); }
-  int64_t int_value() const { return at<4>().as_int64(); }
-  bool has_json_value() const { return at<5>().valid(); }
-  ::protozero::ConstChars json_value() const { return at<5>().as_string(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_USER_SELECTED_RESOLUTION:
+    return "ATOM_USER_SELECTED_RESOLUTION";
 
-class ChromeMetadata : public ::protozero::Message {
- public:
-  using Decoder = ChromeMetadata_Decoder;
-  enum : int32_t {
-    kNameFieldNumber = 1,
-    kStringValueFieldNumber = 2,
-    kBoolValueFieldNumber = 3,
-    kIntValueFieldNumber = 4,
-    kJsonValueFieldNumber = 5,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeMetadata"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_UNSAFE_INTENT_EVENT_REPORTED:
+    return "ATOM_UNSAFE_INTENT_EVENT_REPORTED";
 
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PERFORMANCE_HINT_SESSION_REPORTED:
+    return "ATOM_PERFORMANCE_HINT_SESSION_REPORTED";
 
-  using FieldMetadata_Name =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeMetadata>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_MIDI_DEVICE_CLOSE_REPORTED:
+    return "ATOM_MEDIAMETRICS_MIDI_DEVICE_CLOSE_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BIOMETRIC_TOUCH_REPORTED:
+    return "ATOM_BIOMETRIC_TOUCH_REPORTED";
 
-  using FieldMetadata_StringValue =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeMetadata>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HOTWORD_AUDIO_EGRESS_EVENT_REPORTED:
+    return "ATOM_HOTWORD_AUDIO_EGRESS_EVENT_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StringValue kStringValue() { return {}; }
-  void set_string_value(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_StringValue::kFieldId, data, size);
-  }
-  void set_string_value(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_StringValue::kFieldId, chars.data, chars.size);
-  }
-  void set_string_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_StringValue::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LOCATION_ENABLED_STATE_CHANGED:
+    return "ATOM_LOCATION_ENABLED_STATE_CHANGED";
 
-  using FieldMetadata_BoolValue =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeMetadata>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_IME_REQUEST_FINISHED:
+    return "ATOM_IME_REQUEST_FINISHED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BoolValue kBoolValue() { return {}; }
-  void set_bool_value(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_BoolValue::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_USB_COMPLIANCE_WARNINGS_REPORTED:
+    return "ATOM_USB_COMPLIANCE_WARNINGS_REPORTED";
 
-  using FieldMetadata_IntValue =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ChromeMetadata>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SUPPORTED_LOCALES_CHANGED:
+    return "ATOM_APP_SUPPORTED_LOCALES_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IntValue kIntValue() { return {}; }
-  void set_int_value(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_PROVIDER_VOLUME_RECOVERY_REPORTED:
+    return "ATOM_MEDIA_PROVIDER_VOLUME_RECOVERY_REPORTED";
 
-  using FieldMetadata_JsonValue =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeMetadata>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BIOMETRIC_PROPERTIES_COLLECTED:
+    return "ATOM_BIOMETRIC_PROPERTIES_COLLECTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_JsonValue kJsonValue() { return {}; }
-  void set_json_value(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_JsonValue::kFieldId, data, size);
-  }
-  void set_json_value(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_JsonValue::kFieldId, chars.data, chars.size);
-  }
-  void set_json_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_JsonValue::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_KERNEL_WAKEUP_ATTRIBUTED:
+    return "ATOM_KERNEL_WAKEUP_ATTRIBUTED";
 
-class ChromeTraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/16, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  ChromeTraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeTraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeTraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_timestamp() const { return at<2>().valid(); }
-  int64_t timestamp() const { return at<2>().as_int64(); }
-  bool has_phase() const { return at<3>().valid(); }
-  int32_t phase() const { return at<3>().as_int32(); }
-  bool has_thread_id() const { return at<4>().valid(); }
-  int32_t thread_id() const { return at<4>().as_int32(); }
-  bool has_duration() const { return at<5>().valid(); }
-  int64_t duration() const { return at<5>().as_int64(); }
-  bool has_thread_duration() const { return at<6>().valid(); }
-  int64_t thread_duration() const { return at<6>().as_int64(); }
-  bool has_scope() const { return at<7>().valid(); }
-  ::protozero::ConstChars scope() const { return at<7>().as_string(); }
-  bool has_id() const { return at<8>().valid(); }
-  uint64_t id() const { return at<8>().as_uint64(); }
-  bool has_flags() const { return at<9>().valid(); }
-  uint32_t flags() const { return at<9>().as_uint32(); }
-  bool has_category_group_name() const { return at<10>().valid(); }
-  ::protozero::ConstChars category_group_name() const { return at<10>().as_string(); }
-  bool has_process_id() const { return at<11>().valid(); }
-  int32_t process_id() const { return at<11>().as_int32(); }
-  bool has_thread_timestamp() const { return at<12>().valid(); }
-  int64_t thread_timestamp() const { return at<12>().as_int64(); }
-  bool has_bind_id() const { return at<13>().valid(); }
-  uint64_t bind_id() const { return at<13>().as_uint64(); }
-  bool has_args() const { return at<14>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> args() const { return GetRepeated<::protozero::ConstBytes>(14); }
-  bool has_name_index() const { return at<15>().valid(); }
-  uint32_t name_index() const { return at<15>().as_uint32(); }
-  bool has_category_group_name_index() const { return at<16>().valid(); }
-  uint32_t category_group_name_index() const { return at<16>().as_uint32(); }
-};
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SCREEN_STATE_CHANGED_V2:
+    return "ATOM_SCREEN_STATE_CHANGED_V2";
 
-class ChromeTraceEvent : public ::protozero::Message {
- public:
-  using Decoder = ChromeTraceEvent_Decoder;
-  enum : int32_t {
-    kNameFieldNumber = 1,
-    kTimestampFieldNumber = 2,
-    kPhaseFieldNumber = 3,
-    kThreadIdFieldNumber = 4,
-    kDurationFieldNumber = 5,
-    kThreadDurationFieldNumber = 6,
-    kScopeFieldNumber = 7,
-    kIdFieldNumber = 8,
-    kFlagsFieldNumber = 9,
-    kCategoryGroupNameFieldNumber = 10,
-    kProcessIdFieldNumber = 11,
-    kThreadTimestampFieldNumber = 12,
-    kBindIdFieldNumber = 13,
-    kArgsFieldNumber = 14,
-    kNameIndexFieldNumber = 15,
-    kCategoryGroupNameIndexFieldNumber = 16,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeTraceEvent"; }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_BACKUP_ACTION_REPORTED:
+    return "ATOM_WS_BACKUP_ACTION_REPORTED";
 
-  using Arg = ::perfetto::protos::pbzero::ChromeTraceEvent_Arg;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_RESTORE_ACTION_REPORTED:
+    return "ATOM_WS_RESTORE_ACTION_REPORTED";
 
-  using FieldMetadata_Name =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeTraceEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_LOG_ACCESS_EVENT_REPORTED:
+    return "ATOM_DEVICE_LOG_ACCESS_EVENT_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_SESSION_UPDATED:
+    return "ATOM_MEDIA_SESSION_UPDATED";
 
-  using FieldMetadata_Timestamp =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ChromeTraceEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_OOBE_STATE_CHANGED:
+    return "ATOM_WEAR_OOBE_STATE_CHANGED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timestamp kTimestamp() { return {}; }
-  void set_timestamp(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_NOTIFICATION_UPDATED:
+    return "ATOM_WS_NOTIFICATION_UPDATED";
 
-  using FieldMetadata_Phase =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ChromeTraceEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_VALIDATION_FAILURE_STATS_DAILY_REPORTED:
+    return "ATOM_NETWORK_VALIDATION_FAILURE_STATS_DAILY_REPORTED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Phase kPhase() { return {}; }
-  void set_phase(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Phase::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_COMPLICATION_TAPPED:
+    return "ATOM_WS_COMPLICATION_TAPPED";
 
-  using FieldMetadata_ThreadId =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ChromeTraceEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_NOTIFICATION_BLOCKING:
+    return "ATOM_WS_NOTIFICATION_BLOCKING";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThreadId kThreadId() { return {}; }
-  void set_thread_id(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ThreadId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_NOTIFICATION_BRIDGEMODE_UPDATED:
+    return "ATOM_WS_NOTIFICATION_BRIDGEMODE_UPDATED";
 
-  using FieldMetadata_Duration =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ChromeTraceEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_NOTIFICATION_DISMISSAL_ACTIONED:
+    return "ATOM_WS_NOTIFICATION_DISMISSAL_ACTIONED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Duration kDuration() { return {}; }
-  void set_duration(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Duration::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_NOTIFICATION_ACTIONED:
+    return "ATOM_WS_NOTIFICATION_ACTIONED";
 
-  using FieldMetadata_ThreadDuration =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ChromeTraceEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_NOTIFICATION_LATENCY:
+    return "ATOM_WS_NOTIFICATION_LATENCY";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThreadDuration kThreadDuration() { return {}; }
-  void set_thread_duration(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ThreadDuration::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_BYTES_TRANSFER:
+    return "ATOM_WIFI_BYTES_TRANSFER";
 
-  using FieldMetadata_Scope =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeTraceEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_BYTES_TRANSFER_BY_FG_BG:
+    return "ATOM_WIFI_BYTES_TRANSFER_BY_FG_BG";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Scope kScope() { return {}; }
-  void set_scope(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Scope::kFieldId, data, size);
-  }
-  void set_scope(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Scope::kFieldId, chars.data, chars.size);
-  }
-  void set_scope(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Scope::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_BYTES_TRANSFER:
+    return "ATOM_MOBILE_BYTES_TRANSFER";
 
-  using FieldMetadata_Id =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ChromeTraceEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_BYTES_TRANSFER_BY_FG_BG:
+    return "ATOM_MOBILE_BYTES_TRANSFER_BY_FG_BG";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
-  void set_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_BYTES_TRANSFER:
+    return "ATOM_BLUETOOTH_BYTES_TRANSFER";
 
-  using FieldMetadata_Flags =
-    ::protozero::proto_utils::FieldMetadata<
-      9,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      ChromeTraceEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_KERNEL_WAKELOCK:
+    return "ATOM_KERNEL_WAKELOCK";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SUBSYSTEM_SLEEP_STATE:
+    return "ATOM_SUBSYSTEM_SLEEP_STATE";
 
-  using FieldMetadata_CategoryGroupName =
-    ::protozero::proto_utils::FieldMetadata<
-      10,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeTraceEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CPU_TIME_PER_UID:
+    return "ATOM_CPU_TIME_PER_UID";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CategoryGroupName kCategoryGroupName() { return {}; }
-  void set_category_group_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_CategoryGroupName::kFieldId, data, size);
-  }
-  void set_category_group_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_CategoryGroupName::kFieldId, chars.data, chars.size);
-  }
-  void set_category_group_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_CategoryGroupName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CPU_TIME_PER_UID_FREQ:
+    return "ATOM_CPU_TIME_PER_UID_FREQ";
 
-  using FieldMetadata_ProcessId =
-    ::protozero::proto_utils::FieldMetadata<
-      11,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ChromeTraceEvent>;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_ACTIVITY_INFO:
+    return "ATOM_WIFI_ACTIVITY_INFO";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessId kProcessId() { return {}; }
-  void set_process_id(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProcessId::kFieldId;
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MODEM_ACTIVITY_INFO:
+    return "ATOM_MODEM_ACTIVITY_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_ACTIVITY_INFO:
+    return "ATOM_BLUETOOTH_ACTIVITY_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_MEMORY_STATE:
+    return "ATOM_PROCESS_MEMORY_STATE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SYSTEM_ELAPSED_REALTIME:
+    return "ATOM_SYSTEM_ELAPSED_REALTIME";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SYSTEM_UPTIME:
+    return "ATOM_SYSTEM_UPTIME";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CPU_ACTIVE_TIME:
+    return "ATOM_CPU_ACTIVE_TIME";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CPU_CLUSTER_TIME:
+    return "ATOM_CPU_CLUSTER_TIME";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DISK_SPACE:
+    return "ATOM_DISK_SPACE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_REMAINING_BATTERY_CAPACITY:
+    return "ATOM_REMAINING_BATTERY_CAPACITY";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_FULL_BATTERY_CAPACITY:
+    return "ATOM_FULL_BATTERY_CAPACITY";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TEMPERATURE:
+    return "ATOM_TEMPERATURE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BINDER_CALLS:
+    return "ATOM_BINDER_CALLS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BINDER_CALLS_EXCEPTIONS:
+    return "ATOM_BINDER_CALLS_EXCEPTIONS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LOOPER_STATS:
+    return "ATOM_LOOPER_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DISK_STATS:
+    return "ATOM_DISK_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DIRECTORY_USAGE:
+    return "ATOM_DIRECTORY_USAGE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SIZE:
+    return "ATOM_APP_SIZE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CATEGORY_SIZE:
+    return "ATOM_CATEGORY_SIZE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PROC_STATS:
+    return "ATOM_PROC_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_VOLTAGE:
+    return "ATOM_BATTERY_VOLTAGE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NUM_FINGERPRINTS_ENROLLED:
+    return "ATOM_NUM_FINGERPRINTS_ENROLLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DISK_IO:
+    return "ATOM_DISK_IO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_POWER_PROFILE:
+    return "ATOM_POWER_PROFILE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PROC_STATS_PKG_PROC:
+    return "ATOM_PROC_STATS_PKG_PROC";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_CPU_TIME:
+    return "ATOM_PROCESS_CPU_TIME";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CPU_TIME_PER_THREAD_FREQ:
+    return "ATOM_CPU_TIME_PER_THREAD_FREQ";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ON_DEVICE_POWER_MEASUREMENT:
+    return "ATOM_ON_DEVICE_POWER_MEASUREMENT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_CALCULATED_POWER_USE:
+    return "ATOM_DEVICE_CALCULATED_POWER_USE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_MEMORY_HIGH_WATER_MARK:
+    return "ATOM_PROCESS_MEMORY_HIGH_WATER_MARK";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_LEVEL:
+    return "ATOM_BATTERY_LEVEL";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BUILD_INFORMATION:
+    return "ATOM_BUILD_INFORMATION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_CYCLE_COUNT:
+    return "ATOM_BATTERY_CYCLE_COUNT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEBUG_ELAPSED_CLOCK:
+    return "ATOM_DEBUG_ELAPSED_CLOCK";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEBUG_FAILING_ELAPSED_CLOCK:
+    return "ATOM_DEBUG_FAILING_ELAPSED_CLOCK";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NUM_FACES_ENROLLED:
+    return "ATOM_NUM_FACES_ENROLLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ROLE_HOLDER:
+    return "ATOM_ROLE_HOLDER";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DANGEROUS_PERMISSION_STATE:
+    return "ATOM_DANGEROUS_PERMISSION_STATE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TRAIN_INFO:
+    return "ATOM_TRAIN_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TIME_ZONE_DATA_INFO:
+    return "ATOM_TIME_ZONE_DATA_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_EXTERNAL_STORAGE_INFO:
+    return "ATOM_EXTERNAL_STORAGE_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GPU_STATS_GLOBAL_INFO:
+    return "ATOM_GPU_STATS_GLOBAL_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GPU_STATS_APP_INFO:
+    return "ATOM_GPU_STATS_APP_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SYSTEM_ION_HEAP_SIZE:
+    return "ATOM_SYSTEM_ION_HEAP_SIZE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APPS_ON_EXTERNAL_STORAGE_INFO:
+    return "ATOM_APPS_ON_EXTERNAL_STORAGE_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_FACE_SETTINGS:
+    return "ATOM_FACE_SETTINGS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_COOLING_DEVICE:
+    return "ATOM_COOLING_DEVICE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_OPS:
+    return "ATOM_APP_OPS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_SYSTEM_ION_HEAP_SIZE:
+    return "ATOM_PROCESS_SYSTEM_ION_HEAP_SIZE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SURFACEFLINGER_STATS_GLOBAL_INFO:
+    return "ATOM_SURFACEFLINGER_STATS_GLOBAL_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SURFACEFLINGER_STATS_LAYER_INFO:
+    return "ATOM_SURFACEFLINGER_STATS_LAYER_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_MEMORY_SNAPSHOT:
+    return "ATOM_PROCESS_MEMORY_SNAPSHOT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_VMS_CLIENT_STATS:
+    return "ATOM_VMS_CLIENT_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NOTIFICATION_REMOTE_VIEWS:
+    return "ATOM_NOTIFICATION_REMOTE_VIEWS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DANGEROUS_PERMISSION_STATE_SAMPLED:
+    return "ATOM_DANGEROUS_PERMISSION_STATE_SAMPLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GRAPHICS_STATS:
+    return "ATOM_GRAPHICS_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RUNTIME_APP_OP_ACCESS:
+    return "ATOM_RUNTIME_APP_OP_ACCESS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ION_HEAP_SIZE:
+    return "ATOM_ION_HEAP_SIZE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PACKAGE_NOTIFICATION_PREFERENCES:
+    return "ATOM_PACKAGE_NOTIFICATION_PREFERENCES";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PACKAGE_NOTIFICATION_CHANNEL_PREFERENCES:
+    return "ATOM_PACKAGE_NOTIFICATION_CHANNEL_PREFERENCES";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PACKAGE_NOTIFICATION_CHANNEL_GROUP_PREFERENCES:
+    return "ATOM_PACKAGE_NOTIFICATION_CHANNEL_GROUP_PREFERENCES";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GNSS_STATS:
+    return "ATOM_GNSS_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ATTRIBUTED_APP_OPS:
+    return "ATOM_ATTRIBUTED_APP_OPS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_VOICE_CALL_SESSION:
+    return "ATOM_VOICE_CALL_SESSION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_VOICE_CALL_RAT_USAGE:
+    return "ATOM_VOICE_CALL_RAT_USAGE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SIM_SLOT_STATE:
+    return "ATOM_SIM_SLOT_STATE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SUPPORTED_RADIO_ACCESS_FAMILY:
+    return "ATOM_SUPPORTED_RADIO_ACCESS_FAMILY";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SETTING_SNAPSHOT:
+    return "ATOM_SETTING_SNAPSHOT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLOB_INFO:
+    return "ATOM_BLOB_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DATA_USAGE_BYTES_TRANSFER:
+    return "ATOM_DATA_USAGE_BYTES_TRANSFER";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BYTES_TRANSFER_BY_TAG_AND_METERED:
+    return "ATOM_BYTES_TRANSFER_BY_TAG_AND_METERED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DND_MODE_RULE:
+    return "ATOM_DND_MODE_RULE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GENERAL_EXTERNAL_STORAGE_ACCESS_STATS:
+    return "ATOM_GENERAL_EXTERNAL_STORAGE_ACCESS_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_INCOMING_SMS:
+    return "ATOM_INCOMING_SMS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_OUTGOING_SMS:
+    return "ATOM_OUTGOING_SMS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CARRIER_ID_TABLE_VERSION:
+    return "ATOM_CARRIER_ID_TABLE_VERSION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DATA_CALL_SESSION:
+    return "ATOM_DATA_CALL_SESSION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CELLULAR_SERVICE_STATE:
+    return "ATOM_CELLULAR_SERVICE_STATE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CELLULAR_DATA_SERVICE_SWITCH:
+    return "ATOM_CELLULAR_DATA_SERVICE_SWITCH";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SYSTEM_MEMORY:
+    return "ATOM_SYSTEM_MEMORY";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_IMS_REGISTRATION_TERMINATION:
+    return "ATOM_IMS_REGISTRATION_TERMINATION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_IMS_REGISTRATION_STATS:
+    return "ATOM_IMS_REGISTRATION_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CPU_TIME_PER_CLUSTER_FREQ:
+    return "ATOM_CPU_TIME_PER_CLUSTER_FREQ";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CPU_CYCLES_PER_UID_CLUSTER:
+    return "ATOM_CPU_CYCLES_PER_UID_CLUSTER";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_ROTATED_DATA:
+    return "ATOM_DEVICE_ROTATED_DATA";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CPU_CYCLES_PER_THREAD_GROUP_CLUSTER:
+    return "ATOM_CPU_CYCLES_PER_THREAD_GROUP_CLUSTER";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_DRM_ACTIVITY_INFO:
+    return "ATOM_MEDIA_DRM_ACTIVITY_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_OEM_MANAGED_BYTES_TRANSFER:
+    return "ATOM_OEM_MANAGED_BYTES_TRANSFER";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GNSS_POWER_STATS:
+    return "ATOM_GNSS_POWER_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TIME_ZONE_DETECTOR_STATE:
+    return "ATOM_TIME_ZONE_DETECTOR_STATE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_KEYSTORE2_STORAGE_STATS:
+    return "ATOM_KEYSTORE2_STORAGE_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RKP_POOL_STATS:
+    return "ATOM_RKP_POOL_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_DMABUF_MEMORY:
+    return "ATOM_PROCESS_DMABUF_MEMORY";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PENDING_ALARM_INFO:
+    return "ATOM_PENDING_ALARM_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_USER_LEVEL_HIBERNATED_APPS:
+    return "ATOM_USER_LEVEL_HIBERNATED_APPS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LAUNCHER_LAYOUT_SNAPSHOT:
+    return "ATOM_LAUNCHER_LAYOUT_SNAPSHOT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GLOBAL_HIBERNATED_APPS:
+    return "ATOM_GLOBAL_HIBERNATED_APPS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_INPUT_EVENT_LATENCY_SKETCH:
+    return "ATOM_INPUT_EVENT_LATENCY_SKETCH";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_USAGE_STATS_BEFORE_RESET:
+    return "ATOM_BATTERY_USAGE_STATS_BEFORE_RESET";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_USAGE_STATS_SINCE_RESET:
+    return "ATOM_BATTERY_USAGE_STATS_SINCE_RESET";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_USAGE_STATS_SINCE_RESET_USING_POWER_PROFILE_MODEL:
+    return "ATOM_BATTERY_USAGE_STATS_SINCE_RESET_USING_POWER_PROFILE_MODEL";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_INSTALLED_INCREMENTAL_PACKAGE:
+    return "ATOM_INSTALLED_INCREMENTAL_PACKAGE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TELEPHONY_NETWORK_REQUESTS:
+    return "ATOM_TELEPHONY_NETWORK_REQUESTS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_STORAGE_INFO:
+    return "ATOM_APP_SEARCH_STORAGE_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_VMSTAT:
+    return "ATOM_VMSTAT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_KEYSTORE2_KEY_CREATION_WITH_GENERAL_INFO:
+    return "ATOM_KEYSTORE2_KEY_CREATION_WITH_GENERAL_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_KEYSTORE2_KEY_CREATION_WITH_AUTH_INFO:
+    return "ATOM_KEYSTORE2_KEY_CREATION_WITH_AUTH_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_KEYSTORE2_KEY_CREATION_WITH_PURPOSE_AND_MODES_INFO:
+    return "ATOM_KEYSTORE2_KEY_CREATION_WITH_PURPOSE_AND_MODES_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_KEYSTORE2_ATOM_WITH_OVERFLOW:
+    return "ATOM_KEYSTORE2_ATOM_WITH_OVERFLOW";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_KEYSTORE2_KEY_OPERATION_WITH_PURPOSE_AND_MODES_INFO:
+    return "ATOM_KEYSTORE2_KEY_OPERATION_WITH_PURPOSE_AND_MODES_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_KEYSTORE2_KEY_OPERATION_WITH_GENERAL_INFO:
+    return "ATOM_KEYSTORE2_KEY_OPERATION_WITH_GENERAL_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RKP_ERROR_STATS:
+    return "ATOM_RKP_ERROR_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_KEYSTORE2_CRASH_STATS:
+    return "ATOM_KEYSTORE2_CRASH_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_VENDOR_APEX_INFO:
+    return "ATOM_VENDOR_APEX_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ACCESSIBILITY_SHORTCUT_STATS:
+    return "ATOM_ACCESSIBILITY_SHORTCUT_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ACCESSIBILITY_FLOATING_MENU_STATS:
+    return "ATOM_ACCESSIBILITY_FLOATING_MENU_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DATA_USAGE_BYTES_TRANSFER_V2:
+    return "ATOM_DATA_USAGE_BYTES_TRANSFER_V2";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CAPABILITIES:
+    return "ATOM_MEDIA_CAPABILITIES";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_WATCHDOG_SYSTEM_IO_USAGE_SUMMARY:
+    return "ATOM_CAR_WATCHDOG_SYSTEM_IO_USAGE_SUMMARY";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_WATCHDOG_UID_IO_USAGE_SUMMARY:
+    return "ATOM_CAR_WATCHDOG_UID_IO_USAGE_SUMMARY";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_IMS_REGISTRATION_FEATURE_TAG_STATS:
+    return "ATOM_IMS_REGISTRATION_FEATURE_TAG_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RCS_CLIENT_PROVISIONING_STATS:
+    return "ATOM_RCS_CLIENT_PROVISIONING_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RCS_ACS_PROVISIONING_STATS:
+    return "ATOM_RCS_ACS_PROVISIONING_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SIP_DELEGATE_STATS:
+    return "ATOM_SIP_DELEGATE_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SIP_TRANSPORT_FEATURE_TAG_STATS:
+    return "ATOM_SIP_TRANSPORT_FEATURE_TAG_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SIP_MESSAGE_RESPONSE:
+    return "ATOM_SIP_MESSAGE_RESPONSE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SIP_TRANSPORT_SESSION:
+    return "ATOM_SIP_TRANSPORT_SESSION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_IMS_DEDICATED_BEARER_LISTENER_EVENT:
+    return "ATOM_IMS_DEDICATED_BEARER_LISTENER_EVENT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_IMS_DEDICATED_BEARER_EVENT:
+    return "ATOM_IMS_DEDICATED_BEARER_EVENT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_IMS_REGISTRATION_SERVICE_DESC_STATS:
+    return "ATOM_IMS_REGISTRATION_SERVICE_DESC_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_UCE_EVENT_STATS:
+    return "ATOM_UCE_EVENT_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PRESENCE_NOTIFY_EVENT:
+    return "ATOM_PRESENCE_NOTIFY_EVENT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GBA_EVENT:
+    return "ATOM_GBA_EVENT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PER_SIM_STATUS:
+    return "ATOM_PER_SIM_STATUS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GPU_WORK_PER_UID:
+    return "ATOM_GPU_WORK_PER_UID";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PERSISTENT_URI_PERMISSIONS_AMOUNT_PER_PACKAGE:
+    return "ATOM_PERSISTENT_URI_PERMISSIONS_AMOUNT_PER_PACKAGE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SIGNED_PARTITION_INFO:
+    return "ATOM_SIGNED_PARTITION_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PINNED_FILE_SIZES_PER_PACKAGE:
+    return "ATOM_PINNED_FILE_SIZES_PER_PACKAGE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PENDING_INTENTS_PER_PACKAGE:
+    return "ATOM_PENDING_INTENTS_PER_PACKAGE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_USER_INFO:
+    return "ATOM_USER_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TELEPHONY_NETWORK_REQUESTS_V2:
+    return "ATOM_TELEPHONY_NETWORK_REQUESTS_V2";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_TELEPHONY_PROPERTIES:
+    return "ATOM_DEVICE_TELEPHONY_PROPERTIES";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_REMOTE_KEY_PROVISIONING_ERROR_COUNTS:
+    return "ATOM_REMOTE_KEY_PROVISIONING_ERROR_COUNTS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SAFETY_STATE:
+    return "ATOM_SAFETY_STATE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_INCOMING_MMS:
+    return "ATOM_INCOMING_MMS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_OUTGOING_MMS:
+    return "ATOM_OUTGOING_MMS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MULTI_USER_INFO:
+    return "ATOM_MULTI_USER_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_BPF_MAP_INFO:
+    return "ATOM_NETWORK_BPF_MAP_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_OUTGOING_SHORT_CODE_SMS:
+    return "ATOM_OUTGOING_SHORT_CODE_SMS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CONNECTIVITY_STATE_SAMPLE:
+    return "ATOM_CONNECTIVITY_STATE_SAMPLE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_SELECTION_REMATCH_REASONS_INFO:
+    return "ATOM_NETWORK_SELECTION_REMATCH_REASONS_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GAME_MODE_INFO:
+    return "ATOM_GAME_MODE_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GAME_MODE_CONFIGURATION:
+    return "ATOM_GAME_MODE_CONFIGURATION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GAME_MODE_LISTENER:
+    return "ATOM_GAME_MODE_LISTENER";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_SLICE_REQUEST_COUNT:
+    return "ATOM_NETWORK_SLICE_REQUEST_COUNT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_TILE_SNAPSHOT:
+    return "ATOM_WS_TILE_SNAPSHOT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_ACTIVE_WATCH_FACE_COMPLICATION_SET_SNAPSHOT:
+    return "ATOM_WS_ACTIVE_WATCH_FACE_COMPLICATION_SET_SNAPSHOT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_STATE:
+    return "ATOM_PROCESS_STATE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_ASSOCIATION:
+    return "ATOM_PROCESS_ASSOCIATION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ADPF_SYSTEM_COMPONENT_INFO:
+    return "ATOM_ADPF_SYSTEM_COMPONENT_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NOTIFICATION_MEMORY_USE:
+    return "ATOM_NOTIFICATION_MEMORY_USE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HDR_CAPABILITIES:
+    return "ATOM_HDR_CAPABILITIES";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_FAVOURITE_WATCH_FACE_LIST_SNAPSHOT:
+    return "ATOM_WS_FAVOURITE_WATCH_FACE_LIST_SNAPSHOT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ACCESSIBILITY_CHECK_RESULT_REPORTED:
+    return "ATOM_ACCESSIBILITY_CHECK_RESULT_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ADAPTIVE_AUTH_UNLOCK_AFTER_LOCK_REPORTED:
+    return "ATOM_ADAPTIVE_AUTH_UNLOCK_AFTER_LOCK_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_THERMAL_STATUS_CALLED:
+    return "ATOM_THERMAL_STATUS_CALLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_THERMAL_HEADROOM_CALLED:
+    return "ATOM_THERMAL_HEADROOM_CALLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_THERMAL_HEADROOM_THRESHOLDS_CALLED:
+    return "ATOM_THERMAL_HEADROOM_THRESHOLDS_CALLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ADPF_HINT_SESSION_TID_CLEANUP:
+    return "ATOM_ADPF_HINT_SESSION_TID_CLEANUP";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_THERMAL_HEADROOM_THRESHOLDS:
+    return "ATOM_THERMAL_HEADROOM_THRESHOLDS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ADPF_SESSION_SNAPSHOT:
+    return "ATOM_ADPF_SESSION_SNAPSHOT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_JSSCRIPTENGINE_LATENCY_REPORTED:
+    return "ATOM_JSSCRIPTENGINE_LATENCY_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_API_CALLED:
+    return "ATOM_AD_SERVICES_API_CALLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MESUREMENT_REPORTS_UPLOADED:
+    return "ATOM_AD_SERVICES_MESUREMENT_REPORTS_UPLOADED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_DATA_DOWNLOAD_FILE_GROUP_STATUS_REPORTED:
+    return "ATOM_MOBILE_DATA_DOWNLOAD_FILE_GROUP_STATUS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_DATA_DOWNLOAD_DOWNLOAD_RESULT_REPORTED:
+    return "ATOM_MOBILE_DATA_DOWNLOAD_DOWNLOAD_RESULT_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_SETTINGS_USAGE_REPORTED:
+    return "ATOM_AD_SERVICES_SETTINGS_USAGE_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BACKGROUND_FETCH_PROCESS_REPORTED:
+    return "ATOM_BACKGROUND_FETCH_PROCESS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_UPDATE_CUSTOM_AUDIENCE_PROCESS_REPORTED:
+    return "ATOM_UPDATE_CUSTOM_AUDIENCE_PROCESS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RUN_AD_BIDDING_PROCESS_REPORTED:
+    return "ATOM_RUN_AD_BIDDING_PROCESS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RUN_AD_SCORING_PROCESS_REPORTED:
+    return "ATOM_RUN_AD_SCORING_PROCESS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RUN_AD_SELECTION_PROCESS_REPORTED:
+    return "ATOM_RUN_AD_SELECTION_PROCESS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RUN_AD_BIDDING_PER_CA_PROCESS_REPORTED:
+    return "ATOM_RUN_AD_BIDDING_PER_CA_PROCESS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_DATA_DOWNLOAD_FILE_GROUP_STORAGE_STATS_REPORTED:
+    return "ATOM_MOBILE_DATA_DOWNLOAD_FILE_GROUP_STORAGE_STATS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_REGISTRATIONS:
+    return "ATOM_AD_SERVICES_MEASUREMENT_REGISTRATIONS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_GET_TOPICS_REPORTED:
+    return "ATOM_AD_SERVICES_GET_TOPICS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_EPOCH_COMPUTATION_GET_TOP_TOPICS_REPORTED:
+    return "ATOM_AD_SERVICES_EPOCH_COMPUTATION_GET_TOP_TOPICS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_EPOCH_COMPUTATION_CLASSIFIER_REPORTED:
+    return "ATOM_AD_SERVICES_EPOCH_COMPUTATION_CLASSIFIER_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_BACK_COMPAT_GET_TOPICS_REPORTED:
+    return "ATOM_AD_SERVICES_BACK_COMPAT_GET_TOPICS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_BACK_COMPAT_EPOCH_COMPUTATION_CLASSIFIER_REPORTED:
+    return "ATOM_AD_SERVICES_BACK_COMPAT_EPOCH_COMPUTATION_CLASSIFIER_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_DEBUG_KEYS:
+    return "ATOM_AD_SERVICES_MEASUREMENT_DEBUG_KEYS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ERROR_REPORTED:
+    return "ATOM_AD_SERVICES_ERROR_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_BACKGROUND_JOBS_EXECUTION_REPORTED:
+    return "ATOM_AD_SERVICES_BACKGROUND_JOBS_EXECUTION_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_DELAYED_SOURCE_REGISTRATION:
+    return "ATOM_AD_SERVICES_MEASUREMENT_DELAYED_SOURCE_REGISTRATION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_ATTRIBUTION:
+    return "ATOM_AD_SERVICES_MEASUREMENT_ATTRIBUTION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_JOBS:
+    return "ATOM_AD_SERVICES_MEASUREMENT_JOBS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_WIPEOUT:
+    return "ATOM_AD_SERVICES_MEASUREMENT_WIPEOUT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_AD_ID_MATCH_FOR_DEBUG_KEYS:
+    return "ATOM_AD_SERVICES_MEASUREMENT_AD_ID_MATCH_FOR_DEBUG_KEYS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ENROLLMENT_DATA_STORED:
+    return "ATOM_AD_SERVICES_ENROLLMENT_DATA_STORED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ENROLLMENT_FILE_DOWNLOADED:
+    return "ATOM_AD_SERVICES_ENROLLMENT_FILE_DOWNLOADED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ENROLLMENT_MATCHED:
+    return "ATOM_AD_SERVICES_ENROLLMENT_MATCHED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_CONSENT_MIGRATED:
+    return "ATOM_AD_SERVICES_CONSENT_MIGRATED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ENROLLMENT_FAILED:
+    return "ATOM_AD_SERVICES_ENROLLMENT_FAILED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_CLICK_VERIFICATION:
+    return "ATOM_AD_SERVICES_MEASUREMENT_CLICK_VERIFICATION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ENCRYPTION_KEY_FETCHED:
+    return "ATOM_AD_SERVICES_ENCRYPTION_KEY_FETCHED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ENCRYPTION_KEY_DB_TRANSACTION_ENDED:
+    return "ATOM_AD_SERVICES_ENCRYPTION_KEY_DB_TRANSACTION_ENDED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DESTINATION_REGISTERED_BEACONS:
+    return "ATOM_DESTINATION_REGISTERED_BEACONS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_REPORT_INTERACTION_API_CALLED:
+    return "ATOM_REPORT_INTERACTION_API_CALLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_INTERACTION_REPORTING_TABLE_CLEARED:
+    return "ATOM_INTERACTION_REPORTING_TABLE_CLEARED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_MANIFEST_CONFIG_HELPER_CALLED:
+    return "ATOM_APP_MANIFEST_CONFIG_HELPER_CALLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_FILTERING_PROCESS_JOIN_CA_REPORTED:
+    return "ATOM_AD_FILTERING_PROCESS_JOIN_CA_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_FILTERING_PROCESS_AD_SELECTION_REPORTED:
+    return "ATOM_AD_FILTERING_PROCESS_AD_SELECTION_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_COUNTER_HISTOGRAM_UPDATER_REPORTED:
+    return "ATOM_AD_COUNTER_HISTOGRAM_UPDATER_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SIGNATURE_VERIFICATION:
+    return "ATOM_SIGNATURE_VERIFICATION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_K_ANON_IMMEDIATE_SIGN_JOIN_STATUS_REPORTED:
+    return "ATOM_K_ANON_IMMEDIATE_SIGN_JOIN_STATUS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_K_ANON_BACKGROUND_JOB_STATUS_REPORTED:
+    return "ATOM_K_ANON_BACKGROUND_JOB_STATUS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_K_ANON_INITIALIZE_STATUS_REPORTED:
+    return "ATOM_K_ANON_INITIALIZE_STATUS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_K_ANON_SIGN_STATUS_REPORTED:
+    return "ATOM_K_ANON_SIGN_STATUS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_K_ANON_JOIN_STATUS_REPORTED:
+    return "ATOM_K_ANON_JOIN_STATUS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_K_ANON_KEY_ATTESTATION_STATUS_REPORTED:
+    return "ATOM_K_ANON_KEY_ATTESTATION_STATUS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GET_AD_SELECTION_DATA_API_CALLED:
+    return "ATOM_GET_AD_SELECTION_DATA_API_CALLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_GET_AD_SELECTION_DATA_BUYER_INPUT_GENERATED:
+    return "ATOM_GET_AD_SELECTION_DATA_BUYER_INPUT_GENERATED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BACKGROUND_JOB_SCHEDULING_REPORTED:
+    return "ATOM_BACKGROUND_JOB_SCHEDULING_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TOPICS_ENCRYPTION_EPOCH_COMPUTATION_REPORTED:
+    return "ATOM_TOPICS_ENCRYPTION_EPOCH_COMPUTATION_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TOPICS_ENCRYPTION_GET_TOPICS_REPORTED:
+    return "ATOM_TOPICS_ENCRYPTION_GET_TOPICS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ADSERVICES_SHELL_COMMAND_CALLED:
+    return "ATOM_ADSERVICES_SHELL_COMMAND_CALLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_UPDATE_SIGNALS_API_CALLED:
+    return "ATOM_UPDATE_SIGNALS_API_CALLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ENCODING_JOB_RUN:
+    return "ATOM_ENCODING_JOB_RUN";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ENCODING_JS_FETCH:
+    return "ATOM_ENCODING_JS_FETCH";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ENCODING_JS_EXECUTION:
+    return "ATOM_ENCODING_JS_EXECUTION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PERSIST_AD_SELECTION_RESULT_CALLED:
+    return "ATOM_PERSIST_AD_SELECTION_RESULT_CALLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SERVER_AUCTION_KEY_FETCH_CALLED:
+    return "ATOM_SERVER_AUCTION_KEY_FETCH_CALLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SERVER_AUCTION_BACKGROUND_KEY_FETCH_ENABLED:
+    return "ATOM_SERVER_AUCTION_BACKGROUND_KEY_FETCH_ENABLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_PROCESS_ODP_REGISTRATION:
+    return "ATOM_AD_SERVICES_MEASUREMENT_PROCESS_ODP_REGISTRATION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_NOTIFY_REGISTRATION_TO_ODP:
+    return "ATOM_AD_SERVICES_MEASUREMENT_NOTIFY_REGISTRATION_TO_ODP";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SELECT_ADS_FROM_OUTCOMES_API_CALLED:
+    return "ATOM_SELECT_ADS_FROM_OUTCOMES_API_CALLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_REPORT_IMPRESSION_API_CALLED:
+    return "ATOM_REPORT_IMPRESSION_API_CALLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ENROLLMENT_TRANSACTION_STATS:
+    return "ATOM_AD_SERVICES_ENROLLMENT_TRANSACTION_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_COBALT_LOGGER_EVENT_REPORTED:
+    return "ATOM_AD_SERVICES_COBALT_LOGGER_EVENT_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_COBALT_PERIODIC_JOB_EVENT_REPORTED:
+    return "ATOM_AD_SERVICES_COBALT_PERIODIC_JOB_EVENT_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_UPDATE_SIGNALS_PROCESS_REPORTED:
+    return "ATOM_UPDATE_SIGNALS_PROCESS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TOPICS_SCHEDULE_EPOCH_JOB_SETTING_REPORTED:
+    return "ATOM_TOPICS_SCHEDULE_EPOCH_JOB_SETTING_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AI_WALLPAPERS_BUTTON_PRESSED:
+    return "ATOM_AI_WALLPAPERS_BUTTON_PRESSED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AI_WALLPAPERS_TEMPLATE_SELECTED:
+    return "ATOM_AI_WALLPAPERS_TEMPLATE_SELECTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AI_WALLPAPERS_TERM_SELECTED:
+    return "ATOM_AI_WALLPAPERS_TERM_SELECTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AI_WALLPAPERS_WALLPAPER_SET:
+    return "ATOM_AI_WALLPAPERS_WALLPAPER_SET";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AI_WALLPAPERS_SESSION_SUMMARY:
+    return "ATOM_AI_WALLPAPERS_SESSION_SUMMARY";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APEX_INSTALLATION_REQUESTED:
+    return "ATOM_APEX_INSTALLATION_REQUESTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APEX_INSTALLATION_STAGED:
+    return "ATOM_APEX_INSTALLATION_STAGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APEX_INSTALLATION_ENDED:
+    return "ATOM_APEX_INSTALLATION_ENDED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_SET_SCHEMA_STATS_REPORTED:
+    return "ATOM_APP_SEARCH_SET_SCHEMA_STATS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_SCHEMA_MIGRATION_STATS_REPORTED:
+    return "ATOM_APP_SEARCH_SCHEMA_MIGRATION_STATS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_STATS_REPORTED:
+    return "ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_STATS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_RAW_QUERY_STATS_REPORTED:
+    return "ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_RAW_QUERY_STATS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_APPS_INDEXER_STATS_REPORTED:
+    return "ATOM_APP_SEARCH_APPS_INDEXER_STATS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ART_DATUM_REPORTED:
+    return "ATOM_ART_DATUM_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ART_DEVICE_DATUM_REPORTED:
+    return "ATOM_ART_DEVICE_DATUM_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ART_DATUM_DELTA_REPORTED:
+    return "ATOM_ART_DATUM_DELTA_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ART_DEX2OAT_REPORTED:
+    return "ATOM_ART_DEX2OAT_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ART_DEVICE_STATUS:
+    return "ATOM_ART_DEVICE_STATUS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BACKGROUND_DEXOPT_JOB_ENDED:
+    return "ATOM_BACKGROUND_DEXOPT_JOB_ENDED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PREREBOOT_DEXOPT_JOB_ENDED:
+    return "ATOM_PREREBOOT_DEXOPT_JOB_ENDED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ODREFRESH_REPORTED:
+    return "ATOM_ODREFRESH_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ODSIGN_REPORTED:
+    return "ATOM_ODSIGN_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_UI_EVENT_REPORTED:
+    return "ATOM_AUTOFILL_UI_EVENT_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_FILL_REQUEST_REPORTED:
+    return "ATOM_AUTOFILL_FILL_REQUEST_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_FILL_RESPONSE_REPORTED:
+    return "ATOM_AUTOFILL_FILL_RESPONSE_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_SAVE_EVENT_REPORTED:
+    return "ATOM_AUTOFILL_SAVE_EVENT_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_SESSION_COMMITTED:
+    return "ATOM_AUTOFILL_SESSION_COMMITTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_FIELD_CLASSIFICATION_EVENT_REPORTED:
+    return "ATOM_AUTOFILL_FIELD_CLASSIFICATION_EVENT_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_RECENTS_EVENT_REPORTED:
+    return "ATOM_CAR_RECENTS_EVENT_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_CALM_MODE_EVENT_REPORTED:
+    return "ATOM_CAR_CALM_MODE_EVENT_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_WAKEUP_FROM_SUSPEND_REPORTED:
+    return "ATOM_CAR_WAKEUP_FROM_SUSPEND_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PLUGIN_INITIALIZED:
+    return "ATOM_PLUGIN_INITIALIZED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_HASHED_DEVICE_NAME_REPORTED:
+    return "ATOM_BLUETOOTH_HASHED_DEVICE_NAME_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_L2CAP_COC_CLIENT_CONNECTION:
+    return "ATOM_BLUETOOTH_L2CAP_COC_CLIENT_CONNECTION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_L2CAP_COC_SERVER_CONNECTION:
+    return "ATOM_BLUETOOTH_L2CAP_COC_SERVER_CONNECTION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_LE_SESSION_CONNECTED:
+    return "ATOM_BLUETOOTH_LE_SESSION_CONNECTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RESTRICTED_BLUETOOTH_DEVICE_NAME_REPORTED:
+    return "ATOM_RESTRICTED_BLUETOOTH_DEVICE_NAME_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_PROFILE_CONNECTION_ATTEMPTED:
+    return "ATOM_BLUETOOTH_PROFILE_CONNECTION_ATTEMPTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_CONTENT_PROFILE_ERROR_REPORTED:
+    return "ATOM_BLUETOOTH_CONTENT_PROFILE_ERROR_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_RFCOMM_CONNECTION_ATTEMPTED:
+    return "ATOM_BLUETOOTH_RFCOMM_CONNECTION_ATTEMPTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_REMOTE_DEVICE_INFORMATION_WITH_METRIC_ID:
+    return "ATOM_REMOTE_DEVICE_INFORMATION_WITH_METRIC_ID";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LE_APP_SCAN_STATE_CHANGED:
+    return "ATOM_LE_APP_SCAN_STATE_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LE_RADIO_SCAN_STOPPED:
+    return "ATOM_LE_RADIO_SCAN_STOPPED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LE_SCAN_RESULT_RECEIVED:
+    return "ATOM_LE_SCAN_RESULT_RECEIVED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LE_SCAN_ABUSED:
+    return "ATOM_LE_SCAN_ABUSED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LE_ADV_STATE_CHANGED:
+    return "ATOM_LE_ADV_STATE_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LE_ADV_ERROR_REPORTED:
+    return "ATOM_LE_ADV_ERROR_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_A2DP_SESSION_REPORTED:
+    return "ATOM_A2DP_SESSION_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_CROSS_LAYER_EVENT_REPORTED:
+    return "ATOM_BLUETOOTH_CROSS_LAYER_EVENT_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BROADCAST_AUDIO_SESSION_REPORTED:
+    return "ATOM_BROADCAST_AUDIO_SESSION_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BROADCAST_AUDIO_SYNC_REPORTED:
+    return "ATOM_BROADCAST_AUDIO_SYNC_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_RFCOMM_CONNECTION_REPORTED_AT_CLOSE:
+    return "ATOM_BLUETOOTH_RFCOMM_CONNECTION_REPORTED_AT_CLOSE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_LE_CONNECTION:
+    return "ATOM_BLUETOOTH_LE_CONNECTION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BROADCAST_SENT:
+    return "ATOM_BROADCAST_SENT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CAMERA_FEATURE_COMBINATION_QUERY_EVENT:
+    return "ATOM_CAMERA_FEATURE_COMBINATION_QUERY_EVENT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_STATE_CHANGED:
+    return "ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_STATE_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_UPDATE_FAILED:
+    return "ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_UPDATE_FAILED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DAILY_KEEPALIVE_INFO_REPORTED:
+    return "ATOM_DAILY_KEEPALIVE_INFO_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_REQUEST_STATE_CHANGED:
+    return "ATOM_NETWORK_REQUEST_STATE_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TETHERING_ACTIVE_SESSIONS_REPORTED:
+    return "ATOM_TETHERING_ACTIVE_SESSIONS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_STATS_RECORDER_FILE_OPERATED:
+    return "ATOM_NETWORK_STATS_RECORDER_FILE_OPERATED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CORE_NETWORKING_TERRIBLE_ERROR_OCCURRED:
+    return "ATOM_CORE_NETWORKING_TERRIBLE_ERROR_OCCURRED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APF_SESSION_INFO_REPORTED:
+    return "ATOM_APF_SESSION_INFO_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_IP_CLIENT_RA_INFO_REPORTED:
+    return "ATOM_IP_CLIENT_RA_INFO_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_VPN_CONNECTION_STATE_CHANGED:
+    return "ATOM_VPN_CONNECTION_STATE_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_VPN_CONNECTION_REPORTED:
+    return "ATOM_VPN_CONNECTION_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CPU_POLICY:
+    return "ATOM_CPU_POLICY";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_API_CALLED:
+    return "ATOM_CREDENTIAL_MANAGER_API_CALLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_INIT_PHASE_REPORTED:
+    return "ATOM_CREDENTIAL_MANAGER_INIT_PHASE_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_CANDIDATE_PHASE_REPORTED:
+    return "ATOM_CREDENTIAL_MANAGER_CANDIDATE_PHASE_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_FINAL_PHASE_REPORTED:
+    return "ATOM_CREDENTIAL_MANAGER_FINAL_PHASE_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_TOTAL_REPORTED:
+    return "ATOM_CREDENTIAL_MANAGER_TOTAL_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_FINALNOUID_REPORTED:
+    return "ATOM_CREDENTIAL_MANAGER_FINALNOUID_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_GET_REPORTED:
+    return "ATOM_CREDENTIAL_MANAGER_GET_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_AUTH_CLICK_REPORTED:
+    return "ATOM_CREDENTIAL_MANAGER_AUTH_CLICK_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_APIV2_CALLED:
+    return "ATOM_CREDENTIAL_MANAGER_APIV2_CALLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CRONET_ENGINE_CREATED:
+    return "ATOM_CRONET_ENGINE_CREATED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CRONET_TRAFFIC_REPORTED:
+    return "ATOM_CRONET_TRAFFIC_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CRONET_ENGINE_BUILDER_INITIALIZED:
+    return "ATOM_CRONET_ENGINE_BUILDER_INITIALIZED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CRONET_HTTP_FLAGS_INITIALIZED:
+    return "ATOM_CRONET_HTTP_FLAGS_INITIALIZED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CRONET_INITIALIZED:
+    return "ATOM_CRONET_INITIALIZED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DESKTOP_MODE_UI_CHANGED:
+    return "ATOM_DESKTOP_MODE_UI_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DESKTOP_MODE_SESSION_TASK_UPDATE:
+    return "ATOM_DESKTOP_MODE_SESSION_TASK_UPDATE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DESKTOP_MODE_TASK_SIZE_UPDATED:
+    return "ATOM_DESKTOP_MODE_TASK_SIZE_UPDATED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_LOCK_CHECK_IN_REQUEST_REPORTED:
+    return "ATOM_DEVICE_LOCK_CHECK_IN_REQUEST_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_LOCK_PROVISIONING_COMPLETE_REPORTED:
+    return "ATOM_DEVICE_LOCK_PROVISIONING_COMPLETE_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_LOCK_KIOSK_APP_REQUEST_REPORTED:
+    return "ATOM_DEVICE_LOCK_KIOSK_APP_REQUEST_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_LOCK_CHECK_IN_RETRY_REPORTED:
+    return "ATOM_DEVICE_LOCK_CHECK_IN_RETRY_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_LOCK_PROVISION_FAILURE_REPORTED:
+    return "ATOM_DEVICE_LOCK_PROVISION_FAILURE_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_LOCK_LOCK_UNLOCK_DEVICE_FAILURE_REPORTED:
+    return "ATOM_DEVICE_LOCK_LOCK_UNLOCK_DEVICE_FAILURE_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_POLICY_MANAGEMENT_MODE:
+    return "ATOM_DEVICE_POLICY_MANAGEMENT_MODE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_POLICY_STATE:
+    return "ATOM_DEVICE_POLICY_STATE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DISPLAY_MODE_DIRECTOR_VOTE_CHANGED:
+    return "ATOM_DISPLAY_MODE_DIRECTOR_VOTE_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_EXTERNAL_DISPLAY_STATE_CHANGED:
+    return "ATOM_EXTERNAL_DISPLAY_STATE_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DND_STATE_CHANGED:
+    return "ATOM_DND_STATE_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DREAM_SETTING_CHANGED:
+    return "ATOM_DREAM_SETTING_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DREAM_SETTING_SNAPSHOT:
+    return "ATOM_DREAM_SETTING_SNAPSHOT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_EXPRESS_EVENT_REPORTED:
+    return "ATOM_EXPRESS_EVENT_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_EXPRESS_HISTOGRAM_SAMPLE_REPORTED:
+    return "ATOM_EXPRESS_HISTOGRAM_SAMPLE_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_EXPRESS_UID_EVENT_REPORTED:
+    return "ATOM_EXPRESS_UID_EVENT_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_EXPRESS_UID_HISTOGRAM_SAMPLE_REPORTED:
+    return "ATOM_EXPRESS_UID_HISTOGRAM_SAMPLE_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_FEDERATED_COMPUTE_API_CALLED:
+    return "ATOM_FEDERATED_COMPUTE_API_CALLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_FEDERATED_COMPUTE_TRAINING_EVENT_REPORTED:
+    return "ATOM_FEDERATED_COMPUTE_TRAINING_EVENT_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_EXAMPLE_ITERATOR_NEXT_LATENCY_REPORTED:
+    return "ATOM_EXAMPLE_ITERATOR_NEXT_LATENCY_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_FULL_SCREEN_INTENT_LAUNCHED:
+    return "ATOM_FULL_SCREEN_INTENT_LAUNCHED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BAL_ALLOWED:
+    return "ATOM_BAL_ALLOWED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_IN_TASK_ACTIVITY_STARTED:
+    return "ATOM_IN_TASK_ACTIVITY_STARTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_ORIENTATION_CHANGED:
+    return "ATOM_DEVICE_ORIENTATION_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CACHED_APPS_HIGH_WATERMARK:
+    return "ATOM_CACHED_APPS_HIGH_WATERMARK";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_STYLUS_PREDICTION_METRICS_REPORTED:
+    return "ATOM_STYLUS_PREDICTION_METRICS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_USER_RISK_EVENT_REPORTED:
+    return "ATOM_USER_RISK_EVENT_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_PROJECTION_STATE_CHANGED:
+    return "ATOM_MEDIA_PROJECTION_STATE_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_PROJECTION_TARGET_CHANGED:
+    return "ATOM_MEDIA_PROJECTION_TARGET_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_EXCESSIVE_BINDER_PROXY_COUNT_REPORTED:
+    return "ATOM_EXCESSIVE_BINDER_PROXY_COUNT_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PROXY_BYTES_TRANSFER_BY_FG_BG:
+    return "ATOM_PROXY_BYTES_TRANSFER_BY_FG_BG";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_BYTES_TRANSFER_BY_PROC_STATE:
+    return "ATOM_MOBILE_BYTES_TRANSFER_BY_PROC_STATE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BIOMETRIC_FRR_NOTIFICATION:
+    return "ATOM_BIOMETRIC_FRR_NOTIFICATION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SENSITIVE_CONTENT_MEDIA_PROJECTION_SESSION:
+    return "ATOM_SENSITIVE_CONTENT_MEDIA_PROJECTION_SESSION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SENSITIVE_NOTIFICATION_APP_PROTECTION_SESSION:
+    return "ATOM_SENSITIVE_NOTIFICATION_APP_PROTECTION_SESSION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SENSITIVE_NOTIFICATION_APP_PROTECTION_APPLIED:
+    return "ATOM_SENSITIVE_NOTIFICATION_APP_PROTECTION_APPLIED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SENSITIVE_NOTIFICATION_REDACTION:
+    return "ATOM_SENSITIVE_NOTIFICATION_REDACTION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SENSITIVE_CONTENT_APP_PROTECTION:
+    return "ATOM_SENSITIVE_CONTENT_APP_PROTECTION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_RESTRICTION_STATE_CHANGED:
+    return "ATOM_APP_RESTRICTION_STATE_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_USAGE_STATS_PER_UID:
+    return "ATOM_BATTERY_USAGE_STATS_PER_UID";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_POSTGC_MEMORY_SNAPSHOT:
+    return "ATOM_POSTGC_MEMORY_SNAPSHOT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_POWER_SAVE_TEMP_ALLOWLIST_CHANGED:
+    return "ATOM_POWER_SAVE_TEMP_ALLOWLIST_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_OP_ACCESS_TRACKED:
+    return "ATOM_APP_OP_ACCESS_TRACKED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CONTENT_OR_FILE_URI_EVENT_REPORTED:
+    return "ATOM_CONTENT_OR_FILE_URI_EVENT_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APPLICATION_GRAMMATICAL_INFLECTION_CHANGED:
+    return "ATOM_APPLICATION_GRAMMATICAL_INFLECTION_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SYSTEM_GRAMMATICAL_INFLECTION_CHANGED:
+    return "ATOM_SYSTEM_GRAMMATICAL_INFLECTION_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_HEALTH:
+    return "ATOM_BATTERY_HEALTH";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HDMI_EARC_STATUS_REPORTED:
+    return "ATOM_HDMI_EARC_STATUS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HDMI_SOUNDBAR_MODE_STATUS_REPORTED:
+    return "ATOM_HDMI_SOUNDBAR_MODE_STATUS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_API_CALLED:
+    return "ATOM_HEALTH_CONNECT_API_CALLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_USAGE_STATS:
+    return "ATOM_HEALTH_CONNECT_USAGE_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_STORAGE_STATS:
+    return "ATOM_HEALTH_CONNECT_STORAGE_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_API_INVOKED:
+    return "ATOM_HEALTH_CONNECT_API_INVOKED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_EXERCISE_ROUTE_API_CALLED:
+    return "ATOM_EXERCISE_ROUTE_API_CALLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_EXPORT_INVOKED:
+    return "ATOM_HEALTH_CONNECT_EXPORT_INVOKED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_IMPORT_INVOKED:
+    return "ATOM_HEALTH_CONNECT_IMPORT_INVOKED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_EXPORT_IMPORT_STATS_REPORTED:
+    return "ATOM_HEALTH_CONNECT_EXPORT_IMPORT_STATS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_UI_IMPRESSION:
+    return "ATOM_HEALTH_CONNECT_UI_IMPRESSION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_UI_INTERACTION:
+    return "ATOM_HEALTH_CONNECT_UI_INTERACTION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_APP_OPENED_REPORTED:
+    return "ATOM_HEALTH_CONNECT_APP_OPENED_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_HOTWORD_EGRESS_SIZE_ATOM_REPORTED:
+    return "ATOM_HOTWORD_EGRESS_SIZE_ATOM_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_IKE_SESSION_TERMINATED:
+    return "ATOM_IKE_SESSION_TERMINATED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_IKE_LIVENESS_CHECK_SESSION_VALIDATED:
+    return "ATOM_IKE_LIVENESS_CHECK_SESSION_VALIDATED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NEGOTIATED_SECURITY_ASSOCIATION:
+    return "ATOM_NEGOTIATED_SECURITY_ASSOCIATION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_KEYBOARD_CONFIGURED:
+    return "ATOM_KEYBOARD_CONFIGURED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_KEYBOARD_SYSTEMS_EVENT_REPORTED:
+    return "ATOM_KEYBOARD_SYSTEMS_EVENT_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_INPUTDEVICE_USAGE_REPORTED:
+    return "ATOM_INPUTDEVICE_USAGE_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_INPUT_EVENT_LATENCY_REPORTED:
+    return "ATOM_INPUT_EVENT_LATENCY_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TOUCHPAD_USAGE:
+    return "ATOM_TOUCHPAD_USAGE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_KERNEL_OOM_KILL_OCCURRED:
+    return "ATOM_KERNEL_OOM_KILL_OCCURRED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_EMERGENCY_STATE_CHANGED:
+    return "ATOM_EMERGENCY_STATE_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CHRE_SIGNIFICANT_MOTION_STATE_CHANGED:
+    return "ATOM_CHRE_SIGNIFICANT_MOTION_STATE_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_POPULATION_DENSITY_PROVIDER_LOADING_REPORTED:
+    return "ATOM_POPULATION_DENSITY_PROVIDER_LOADING_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DENSITY_BASED_COARSE_LOCATIONS_USAGE_REPORTED:
+    return "ATOM_DENSITY_BASED_COARSE_LOCATIONS_USAGE_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DENSITY_BASED_COARSE_LOCATIONS_PROVIDER_QUERY_REPORTED:
+    return "ATOM_DENSITY_BASED_COARSE_LOCATIONS_PROVIDER_QUERY_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CODEC_RECLAIM_REQUEST_COMPLETED:
+    return "ATOM_MEDIA_CODEC_RECLAIM_REQUEST_COMPLETED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CODEC_STARTED:
+    return "ATOM_MEDIA_CODEC_STARTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CODEC_STOPPED:
+    return "ATOM_MEDIA_CODEC_STOPPED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CODEC_RENDERED:
+    return "ATOM_MEDIA_CODEC_RENDERED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_EDITING_ENDED_REPORTED:
+    return "ATOM_MEDIA_EDITING_ENDED_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MTE_STATE:
+    return "ATOM_MTE_STATE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MICROXR_DEVICE_BOOT_COMPLETE_REPORTED:
+    return "ATOM_MICROXR_DEVICE_BOOT_COMPLETE_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_OBSERVE_MODE_STATE_CHANGED:
+    return "ATOM_NFC_OBSERVE_MODE_STATE_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_FIELD_CHANGED:
+    return "ATOM_NFC_FIELD_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_POLLING_LOOP_NOTIFICATION_REPORTED:
+    return "ATOM_NFC_POLLING_LOOP_NOTIFICATION_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_PROPRIETARY_CAPABILITIES_REPORTED:
+    return "ATOM_NFC_PROPRIETARY_CAPABILITIES_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ONDEVICEPERSONALIZATION_API_CALLED:
+    return "ATOM_ONDEVICEPERSONALIZATION_API_CALLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_COMPONENT_STATE_CHANGED_REPORTED:
+    return "ATOM_COMPONENT_STATE_CHANGED_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PDF_LOAD_REPORTED:
+    return "ATOM_PDF_LOAD_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PDF_API_USAGE_REPORTED:
+    return "ATOM_PDF_API_USAGE_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PDF_SEARCH_REPORTED:
+    return "ATOM_PDF_SEARCH_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PRESSURE_STALL_INFORMATION:
+    return "ATOM_PRESSURE_STALL_INFORMATION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PERMISSION_RATIONALE_DIALOG_VIEWED:
+    return "ATOM_PERMISSION_RATIONALE_DIALOG_VIEWED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PERMISSION_RATIONALE_DIALOG_ACTION_REPORTED:
+    return "ATOM_PERMISSION_RATIONALE_DIALOG_ACTION_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_DATA_SHARING_UPDATES_NOTIFICATION_INTERACTION:
+    return "ATOM_APP_DATA_SHARING_UPDATES_NOTIFICATION_INTERACTION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_VIEWED:
+    return "ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_VIEWED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_ACTION_REPORTED:
+    return "ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_ACTION_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ENHANCED_CONFIRMATION_DIALOG_RESULT_REPORTED:
+    return "ATOM_ENHANCED_CONFIRMATION_DIALOG_RESULT_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ENHANCED_CONFIRMATION_RESTRICTION_CLEARED:
+    return "ATOM_ENHANCED_CONFIRMATION_RESTRICTION_CLEARED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_SESSION_INFO_REPORTED:
+    return "ATOM_PHOTOPICKER_SESSION_INFO_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_API_INFO_REPORTED:
+    return "ATOM_PHOTOPICKER_API_INFO_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_UI_EVENT_LOGGED:
+    return "ATOM_PHOTOPICKER_UI_EVENT_LOGGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_MEDIA_ITEM_STATUS_REPORTED:
+    return "ATOM_PHOTOPICKER_MEDIA_ITEM_STATUS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_PREVIEW_INFO_LOGGED:
+    return "ATOM_PHOTOPICKER_PREVIEW_INFO_LOGGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_MENU_INTERACTION_LOGGED:
+    return "ATOM_PHOTOPICKER_MENU_INTERACTION_LOGGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_BANNER_INTERACTION_LOGGED:
+    return "ATOM_PHOTOPICKER_BANNER_INTERACTION_LOGGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_MEDIA_LIBRARY_INFO_LOGGED:
+    return "ATOM_PHOTOPICKER_MEDIA_LIBRARY_INFO_LOGGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_PAGE_INFO_LOGGED:
+    return "ATOM_PHOTOPICKER_PAGE_INFO_LOGGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_MEDIA_GRID_SYNC_INFO_REPORTED:
+    return "ATOM_PHOTOPICKER_MEDIA_GRID_SYNC_INFO_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_ALBUM_SYNC_INFO_REPORTED:
+    return "ATOM_PHOTOPICKER_ALBUM_SYNC_INFO_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_SEARCH_INFO_REPORTED:
+    return "ATOM_PHOTOPICKER_SEARCH_INFO_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SEARCH_DATA_EXTRACTION_DETAILS_REPORTED:
+    return "ATOM_SEARCH_DATA_EXTRACTION_DETAILS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_EMBEDDED_PHOTOPICKER_INFO_REPORTED:
+    return "ATOM_EMBEDDED_PHOTOPICKER_INFO_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ATOM_9999:
+    return "ATOM_ATOM_9999";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_ATOM_99999:
+    return "ATOM_ATOM_99999";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SCREEN_OFF_REPORTED:
+    return "ATOM_SCREEN_OFF_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SCREEN_TIMEOUT_OVERRIDE_REPORTED:
+    return "ATOM_SCREEN_TIMEOUT_OVERRIDE_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SCREEN_INTERACTIVE_SESSION_REPORTED:
+    return "ATOM_SCREEN_INTERACTIVE_SESSION_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SCREEN_DIM_REPORTED:
+    return "ATOM_SCREEN_DIM_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_PROVIDER_DATABASE_ROLLBACK_REPORTED:
+    return "ATOM_MEDIA_PROVIDER_DATABASE_ROLLBACK_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BACKUP_SETUP_STATUS_REPORTED:
+    return "ATOM_BACKUP_SETUP_STATUS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RANGING_SESSION_CONFIGURED:
+    return "ATOM_RANGING_SESSION_CONFIGURED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RANGING_SESSION_STARTED:
+    return "ATOM_RANGING_SESSION_STARTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RANGING_SESSION_CLOSED:
+    return "ATOM_RANGING_SESSION_CLOSED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RANGING_TECHNOLOGY_STARTED:
+    return "ATOM_RANGING_TECHNOLOGY_STARTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RANGING_TECHNOLOGY_STOPPED:
+    return "ATOM_RANGING_TECHNOLOGY_STOPPED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RKPD_POOL_STATS:
+    return "ATOM_RKPD_POOL_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RKPD_CLIENT_OPERATION:
+    return "ATOM_RKPD_CLIENT_OPERATION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SANDBOX_API_CALLED:
+    return "ATOM_SANDBOX_API_CALLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SANDBOX_ACTIVITY_EVENT_OCCURRED:
+    return "ATOM_SANDBOX_ACTIVITY_EVENT_OCCURRED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SDK_SANDBOX_RESTRICTED_ACCESS_IN_SESSION:
+    return "ATOM_SDK_SANDBOX_RESTRICTED_ACCESS_IN_SESSION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SANDBOX_SDK_STORAGE:
+    return "ATOM_SANDBOX_SDK_STORAGE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SELINUX_AUDIT_LOG:
+    return "ATOM_SELINUX_AUDIT_LOG";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SETTINGS_SPA_REPORTED:
+    return "ATOM_SETTINGS_SPA_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TEST_EXTENSION_ATOM_REPORTED:
+    return "ATOM_TEST_EXTENSION_ATOM_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TEST_RESTRICTED_ATOM_REPORTED:
+    return "ATOM_TEST_RESTRICTED_ATOM_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_STATS_SOCKET_LOSS_REPORTED:
+    return "ATOM_STATS_SOCKET_LOSS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LOCKSCREEN_SHORTCUT_SELECTED:
+    return "ATOM_LOCKSCREEN_SHORTCUT_SELECTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LOCKSCREEN_SHORTCUT_TRIGGERED:
+    return "ATOM_LOCKSCREEN_SHORTCUT_TRIGGERED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LAUNCHER_IMPRESSION_EVENT_V2:
+    return "ATOM_LAUNCHER_IMPRESSION_EVENT_V2";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DISPLAY_SWITCH_LATENCY_TRACKED:
+    return "ATOM_DISPLAY_SWITCH_LATENCY_TRACKED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NOTIFICATION_LISTENER_SERVICE:
+    return "ATOM_NOTIFICATION_LISTENER_SERVICE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_NAV_HANDLE_TOUCH_POINTS:
+    return "ATOM_NAV_HANDLE_TOUCH_POINTS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_COMMUNAL_HUB_WIDGET_EVENT_REPORTED:
+    return "ATOM_COMMUNAL_HUB_WIDGET_EVENT_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_COMMUNAL_HUB_SNAPSHOT:
+    return "ATOM_COMMUNAL_HUB_SNAPSHOT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_EMERGENCY_NUMBER_DIALED:
+    return "ATOM_EMERGENCY_NUMBER_DIALED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CALL_STATS:
+    return "ATOM_CALL_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CALL_AUDIO_ROUTE_STATS:
+    return "ATOM_CALL_AUDIO_ROUTE_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TELECOM_API_STATS:
+    return "ATOM_TELECOM_API_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TELECOM_ERROR_STATS:
+    return "ATOM_TELECOM_ERROR_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CELLULAR_RADIO_POWER_STATE_CHANGED:
+    return "ATOM_CELLULAR_RADIO_POWER_STATE_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_EMERGENCY_NUMBERS_INFO:
+    return "ATOM_EMERGENCY_NUMBERS_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DATA_NETWORK_VALIDATION:
+    return "ATOM_DATA_NETWORK_VALIDATION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DATA_RAT_STATE_CHANGED:
+    return "ATOM_DATA_RAT_STATE_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CONNECTED_CHANNEL_CHANGED:
+    return "ATOM_CONNECTED_CHANNEL_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_IWLAN_UNDERLYING_NETWORK_VALIDATION_RESULT_REPORTED:
+    return "ATOM_IWLAN_UNDERLYING_NETWORK_VALIDATION_RESULT_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_QUALIFIED_RAT_LIST_CHANGED:
+    return "ATOM_QUALIFIED_RAT_LIST_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_QNS_IMS_CALL_DROP_STATS:
+    return "ATOM_QNS_IMS_CALL_DROP_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_QNS_FALLBACK_RESTRICTION_CHANGED:
+    return "ATOM_QNS_FALLBACK_RESTRICTION_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_QNS_RAT_PREFERENCE_MISMATCH_INFO:
+    return "ATOM_QNS_RAT_PREFERENCE_MISMATCH_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_QNS_HANDOVER_TIME_MILLIS:
+    return "ATOM_QNS_HANDOVER_TIME_MILLIS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_QNS_HANDOVER_PINGPONG:
+    return "ATOM_QNS_HANDOVER_PINGPONG";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_CONTROLLER:
+    return "ATOM_SATELLITE_CONTROLLER";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_SESSION:
+    return "ATOM_SATELLITE_SESSION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_INCOMING_DATAGRAM:
+    return "ATOM_SATELLITE_INCOMING_DATAGRAM";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_OUTGOING_DATAGRAM:
+    return "ATOM_SATELLITE_OUTGOING_DATAGRAM";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_PROVISION:
+    return "ATOM_SATELLITE_PROVISION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_SOS_MESSAGE_RECOMMENDER:
+    return "ATOM_SATELLITE_SOS_MESSAGE_RECOMMENDER";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CARRIER_ROAMING_SATELLITE_SESSION:
+    return "ATOM_CARRIER_ROAMING_SATELLITE_SESSION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CARRIER_ROAMING_SATELLITE_CONTROLLER_STATS:
+    return "ATOM_CARRIER_ROAMING_SATELLITE_CONTROLLER_STATS";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CONTROLLER_STATS_PER_PACKAGE:
+    return "ATOM_CONTROLLER_STATS_PER_PACKAGE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_ENTITLEMENT:
+    return "ATOM_SATELLITE_ENTITLEMENT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_CONFIG_UPDATER:
+    return "ATOM_SATELLITE_CONFIG_UPDATER";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_ACCESS_CONTROLLER:
+    return "ATOM_SATELLITE_ACCESS_CONTROLLER";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_CELLULAR_IDENTIFIER_DISCLOSED:
+    return "ATOM_CELLULAR_IDENTIFIER_DISCLOSED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_THREADNETWORK_TELEMETRY_DATA_REPORTED:
+    return "ATOM_THREADNETWORK_TELEMETRY_DATA_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_THREADNETWORK_TOPO_ENTRY_REPEATED:
+    return "ATOM_THREADNETWORK_TOPO_ENTRY_REPEATED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_THREADNETWORK_DEVICE_INFO_REPORTED:
+    return "ATOM_THREADNETWORK_DEVICE_INFO_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_BOOT_INTEGRITY_INFO_REPORTED:
+    return "ATOM_BOOT_INTEGRITY_INFO_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TV_LOW_POWER_STANDBY_POLICY:
+    return "ATOM_TV_LOW_POWER_STANDBY_POLICY";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_EXTERNAL_TV_INPUT_EVENT:
+    return "ATOM_EXTERNAL_TV_INPUT_EVENT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TEST_UPROBESTATS_ATOM_REPORTED:
+    return "ATOM_TEST_UPROBESTATS_ATOM_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_UWB_ACTIVITY_INFO:
+    return "ATOM_UWB_ACTIVITY_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIATOR_UPDATED:
+    return "ATOM_MEDIATOR_UPDATED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SYSPROXY_BLUETOOTH_BYTES_TRANSFER:
+    return "ATOM_SYSPROXY_BLUETOOTH_BYTES_TRANSFER";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SYSPROXY_CONNECTION_UPDATED:
+    return "ATOM_SYSPROXY_CONNECTION_UPDATED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_COMPANION_CONNECTION_STATE:
+    return "ATOM_WEAR_COMPANION_CONNECTION_STATE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_ACTION_REPORTED:
+    return "ATOM_MEDIA_ACTION_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CONTROLS_LAUNCHED:
+    return "ATOM_MEDIA_CONTROLS_LAUNCHED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_SESSION_STATE_CHANGED:
+    return "ATOM_MEDIA_SESSION_STATE_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_DEVICE_SCAN_API_LATENCY:
+    return "ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_DEVICE_SCAN_API_LATENCY";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_SASS_DEVICE_UNAVAILABLE:
+    return "ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_SASS_DEVICE_UNAVAILABLE";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FASTPAIR_API_TIMEOUT:
+    return "ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FASTPAIR_API_TIMEOUT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MODE_STATE_CHANGED:
+    return "ATOM_WEAR_MODE_STATE_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_RENDERER_INITIALIZED:
+    return "ATOM_RENDERER_INITIALIZED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SCHEMA_VERSION_RECEIVED:
+    return "ATOM_SCHEMA_VERSION_RECEIVED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LAYOUT_INSPECTED:
+    return "ATOM_LAYOUT_INSPECTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LAYOUT_EXPRESSION_INSPECTED:
+    return "ATOM_LAYOUT_EXPRESSION_INSPECTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_LAYOUT_ANIMATIONS_INSPECTED:
+    return "ATOM_LAYOUT_ANIMATIONS_INSPECTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_MATERIAL_COMPONENTS_INSPECTED:
+    return "ATOM_MATERIAL_COMPONENTS_INSPECTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TILE_REQUESTED:
+    return "ATOM_TILE_REQUESTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_STATE_RESPONSE_RECEIVED:
+    return "ATOM_STATE_RESPONSE_RECEIVED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_TILE_RESPONSE_RECEIVED:
+    return "ATOM_TILE_RESPONSE_RECEIVED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_INFLATION_FINISHED:
+    return "ATOM_INFLATION_FINISHED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_INFLATION_FAILED:
+    return "ATOM_INFLATION_FAILED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_IGNORED_INFLATION_FAILURES_REPORTED:
+    return "ATOM_IGNORED_INFLATION_FAILURES_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_DRAWABLE_RENDERED:
+    return "ATOM_DRAWABLE_RENDERED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_TIME_SYNC_REQUESTED:
+    return "ATOM_WEAR_TIME_SYNC_REQUESTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_TIME_UPDATE_STARTED:
+    return "ATOM_WEAR_TIME_UPDATE_STARTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_TIME_SYNC_ATTEMPT_COMPLETED:
+    return "ATOM_WEAR_TIME_SYNC_ATTEMPT_COMPLETED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_TIME_CHANGED:
+    return "ATOM_WEAR_TIME_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_ADAPTIVE_SUSPEND_STATS_REPORTED:
+    return "ATOM_WEAR_ADAPTIVE_SUSPEND_STATS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_POWER_ANOMALY_SERVICE_OPERATIONAL_STATS_REPORTED:
+    return "ATOM_WEAR_POWER_ANOMALY_SERVICE_OPERATIONAL_STATS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_POWER_ANOMALY_SERVICE_EVENT_STATS_REPORTED:
+    return "ATOM_WEAR_POWER_ANOMALY_SERVICE_EVENT_STATS_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_WEAR_TIME_SESSION:
+    return "ATOM_WS_WEAR_TIME_SESSION";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_INCOMING_CALL_ACTION_REPORTED:
+    return "ATOM_WS_INCOMING_CALL_ACTION_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_CALL_DISCONNECTION_REPORTED:
+    return "ATOM_WS_CALL_DISCONNECTION_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_CALL_DURATION_REPORTED:
+    return "ATOM_WS_CALL_DURATION_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_CALL_USER_EXPERIENCE_LATENCY_REPORTED:
+    return "ATOM_WS_CALL_USER_EXPERIENCE_LATENCY_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_CALL_INTERACTION_REPORTED:
+    return "ATOM_WS_CALL_INTERACTION_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_ON_BODY_STATE_CHANGED:
+    return "ATOM_WS_ON_BODY_STATE_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_WATCH_FACE_RESTRICTED_COMPLICATIONS_IMPACTED:
+    return "ATOM_WS_WATCH_FACE_RESTRICTED_COMPLICATIONS_IMPACTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_WATCH_FACE_DEFAULT_RESTRICTED_COMPLICATIONS_REMOVED:
+    return "ATOM_WS_WATCH_FACE_DEFAULT_RESTRICTED_COMPLICATIONS_REMOVED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_COMPLICATIONS_IMPACTED_NOTIFICATION_EVENT_REPORTED:
+    return "ATOM_WS_COMPLICATIONS_IMPACTED_NOTIFICATION_EVENT_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_REMOTE_EVENT_USAGE_REPORTED:
+    return "ATOM_WS_REMOTE_EVENT_USAGE_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_BUGREPORT_REQUESTED:
+    return "ATOM_WS_BUGREPORT_REQUESTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_BUGREPORT_TRIGGERED:
+    return "ATOM_WS_BUGREPORT_TRIGGERED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_BUGREPORT_FINISHED:
+    return "ATOM_WS_BUGREPORT_FINISHED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_BUGREPORT_RESULT_RECEIVED:
+    return "ATOM_WS_BUGREPORT_RESULT_RECEIVED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_STANDALONE_MODE_SNAPSHOT:
+    return "ATOM_WS_STANDALONE_MODE_SNAPSHOT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_FAVORITE_WATCH_FACE_SNAPSHOT:
+    return "ATOM_WS_FAVORITE_WATCH_FACE_SNAPSHOT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_PHOTOS_WATCH_FACE_FEATURE_SNAPSHOT:
+    return "ATOM_WS_PHOTOS_WATCH_FACE_FEATURE_SNAPSHOT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WS_WATCH_FACE_CUSTOMIZATION_SNAPSHOT:
+    return "ATOM_WS_WATCH_FACE_CUSTOMIZATION_SNAPSHOT";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_POWER_MENU_OPENED:
+    return "ATOM_WEAR_POWER_MENU_OPENED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_ASSISTANT_OPENED:
+    return "ATOM_WEAR_ASSISTANT_OPENED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_FIRST_OVERLAY_STATE_CHANGED:
+    return "ATOM_FIRST_OVERLAY_STATE_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_AWARE_NDP_REPORTED:
+    return "ATOM_WIFI_AWARE_NDP_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_AWARE_ATTACH_REPORTED:
+    return "ATOM_WIFI_AWARE_ATTACH_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_SELF_RECOVERY_TRIGGERED:
+    return "ATOM_WIFI_SELF_RECOVERY_TRIGGERED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SOFT_AP_STARTED:
+    return "ATOM_SOFT_AP_STARTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SOFT_AP_STOPPED:
+    return "ATOM_SOFT_AP_STOPPED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_LOCK_RELEASED:
+    return "ATOM_WIFI_LOCK_RELEASED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_LOCK_DEACTIVATED:
+    return "ATOM_WIFI_LOCK_DEACTIVATED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_CONFIG_SAVED:
+    return "ATOM_WIFI_CONFIG_SAVED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_AWARE_RESOURCE_USING_CHANGED:
+    return "ATOM_WIFI_AWARE_RESOURCE_USING_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_AWARE_HAL_API_CALLED:
+    return "ATOM_WIFI_AWARE_HAL_API_CALLED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_LOCAL_ONLY_REQUEST_RECEIVED:
+    return "ATOM_WIFI_LOCAL_ONLY_REQUEST_RECEIVED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_LOCAL_ONLY_REQUEST_SCAN_TRIGGERED:
+    return "ATOM_WIFI_LOCAL_ONLY_REQUEST_SCAN_TRIGGERED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_THREAD_TASK_EXECUTED:
+    return "ATOM_WIFI_THREAD_TASK_EXECUTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_STATE_CHANGED:
+    return "ATOM_WIFI_STATE_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PNO_SCAN_STARTED:
+    return "ATOM_PNO_SCAN_STARTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_PNO_SCAN_STOPPED:
+    return "ATOM_PNO_SCAN_STOPPED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_IS_UNUSABLE_REPORTED:
+    return "ATOM_WIFI_IS_UNUSABLE_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_AP_CAPABILITIES_REPORTED:
+    return "ATOM_WIFI_AP_CAPABILITIES_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SOFT_AP_STATE_CHANGED:
+    return "ATOM_SOFT_AP_STATE_CHANGED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_SCORER_PREDICTION_RESULT_REPORTED:
+    return "ATOM_SCORER_PREDICTION_RESULT_REPORTED";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_AWARE_CAPABILITIES:
+    return "ATOM_WIFI_AWARE_CAPABILITIES";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_MODULE_INFO:
+    return "ATOM_WIFI_MODULE_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_SETTING_INFO:
+    return "ATOM_WIFI_SETTING_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_COMPLEX_SETTING_INFO:
+    return "ATOM_WIFI_COMPLEX_SETTING_INFO";
+
+  case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_CONFIGURED_NETWORK_INFO:
+    return "ATOM_WIFI_CONFIGURED_NETWORK_INFO";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/statsd/statsd_tracing_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_STATSD_TRACING_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_STATSD_TRACING_CONFIG_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class StatsdPullAtomConfig;
+enum AtomId : int32_t;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class StatsdPullAtomConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  StatsdPullAtomConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit StatsdPullAtomConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit StatsdPullAtomConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pull_atom_id() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> pull_atom_id() const { return GetRepeated<int32_t>(1); }
+  bool has_raw_pull_atom_id() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> raw_pull_atom_id() const { return GetRepeated<int32_t>(2); }
+  bool has_pull_frequency_ms() const { return at<3>().valid(); }
+  int32_t pull_frequency_ms() const { return at<3>().as_int32(); }
+  bool has_packages() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> packages() const { return GetRepeated<::protozero::ConstChars>(4); }
+};
+
+class StatsdPullAtomConfig : public ::protozero::Message {
+ public:
+  using Decoder = StatsdPullAtomConfig_Decoder;
+  enum : int32_t {
+    kPullAtomIdFieldNumber = 1,
+    kRawPullAtomIdFieldNumber = 2,
+    kPullFrequencyMsFieldNumber = 3,
+    kPackagesFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.StatsdPullAtomConfig"; }
+
+
+  using FieldMetadata_PullAtomId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      AtomId,
+      StatsdPullAtomConfig>;
+
+  static constexpr FieldMetadata_PullAtomId kPullAtomId{};
+  void add_pull_atom_id(AtomId value) {
+    static constexpr uint32_t field_id = FieldMetadata_PullAtomId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ThreadTimestamp =
+  using FieldMetadata_RawPullAtomId =
     ::protozero::proto_utils::FieldMetadata<
-      12,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ChromeTraceEvent>;
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      StatsdPullAtomConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThreadTimestamp kThreadTimestamp() { return {}; }
-  void set_thread_timestamp(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ThreadTimestamp::kFieldId;
+  static constexpr FieldMetadata_RawPullAtomId kRawPullAtomId{};
+  void add_raw_pull_atom_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RawPullAtomId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BindId =
+  using FieldMetadata_PullFrequencyMs =
     ::protozero::proto_utils::FieldMetadata<
-      13,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ChromeTraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      StatsdPullAtomConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BindId kBindId() { return {}; }
-  void set_bind_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BindId::kFieldId;
+  static constexpr FieldMetadata_PullFrequencyMs kPullFrequencyMs{};
+  void set_pull_frequency_ms(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PullFrequencyMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Args =
+  using FieldMetadata_Packages =
     ::protozero::proto_utils::FieldMetadata<
-      14,
+      4,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeTraceEvent_Arg,
-      ChromeTraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      StatsdPullAtomConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Args kArgs() { return {}; }
-  template <typename T = ChromeTraceEvent_Arg> T* add_args() {
-    return BeginNestedMessage<T>(14);
+  static constexpr FieldMetadata_Packages kPackages{};
+  void add_packages(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Packages::kFieldId, data, size);
+  }
+  void add_packages(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Packages::kFieldId, chars.data, chars.size);
+  }
+  void add_packages(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Packages::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
   }
+};
 
+class StatsdTracingConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  StatsdTracingConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit StatsdTracingConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit StatsdTracingConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_push_atom_id() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> push_atom_id() const { return GetRepeated<int32_t>(1); }
+  bool has_raw_push_atom_id() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> raw_push_atom_id() const { return GetRepeated<int32_t>(2); }
+  bool has_pull_config() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> pull_config() const { return GetRepeated<::protozero::ConstBytes>(3); }
+};
 
-  using FieldMetadata_NameIndex =
+class StatsdTracingConfig : public ::protozero::Message {
+ public:
+  using Decoder = StatsdTracingConfig_Decoder;
+  enum : int32_t {
+    kPushAtomIdFieldNumber = 1,
+    kRawPushAtomIdFieldNumber = 2,
+    kPullConfigFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.StatsdTracingConfig"; }
+
+
+  using FieldMetadata_PushAtomId =
     ::protozero::proto_utils::FieldMetadata<
-      15,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      ChromeTraceEvent>;
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      AtomId,
+      StatsdTracingConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NameIndex kNameIndex() { return {}; }
-  void set_name_index(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NameIndex::kFieldId;
+  static constexpr FieldMetadata_PushAtomId kPushAtomId{};
+  void add_push_atom_id(AtomId value) {
+    static constexpr uint32_t field_id = FieldMetadata_PushAtomId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CategoryGroupNameIndex =
+  using FieldMetadata_RawPushAtomId =
     ::protozero::proto_utils::FieldMetadata<
-      16,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      ChromeTraceEvent>;
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      StatsdTracingConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CategoryGroupNameIndex kCategoryGroupNameIndex() { return {}; }
-  void set_category_group_name_index(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CategoryGroupNameIndex::kFieldId;
+  static constexpr FieldMetadata_RawPushAtomId kRawPushAtomId{};
+  void add_raw_push_atom_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RawPushAtomId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_PullConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      StatsdPullAtomConfig,
+      StatsdTracingConfig>;
+
+  static constexpr FieldMetadata_PullConfig kPullConfig{};
+  template <typename T = StatsdPullAtomConfig> T* add_pull_config() {
+    return BeginNestedMessage<T>(3);
+  }
+
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/sys_stats/sys_stats_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYS_STATS_SYS_STATS_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYS_STATS_SYS_STATS_CONFIG_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+enum MeminfoCounters : int32_t;
+namespace perfetto_pbzero_enum_SysStatsConfig {
+enum StatCounters : int32_t;
+}  // namespace perfetto_pbzero_enum_SysStatsConfig
+using SysStatsConfig_StatCounters = perfetto_pbzero_enum_SysStatsConfig::StatCounters;
+enum VmstatCounters : int32_t;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_SysStatsConfig {
+enum StatCounters : int32_t {
+  STAT_UNSPECIFIED = 0,
+  STAT_CPU_TIMES = 1,
+  STAT_IRQ_COUNTS = 2,
+  STAT_SOFTIRQ_COUNTS = 3,
+  STAT_FORK_COUNT = 4,
 };
+} // namespace perfetto_pbzero_enum_SysStatsConfig
+using SysStatsConfig_StatCounters = perfetto_pbzero_enum_SysStatsConfig::StatCounters;
+
+
+constexpr SysStatsConfig_StatCounters SysStatsConfig_StatCounters_MIN = SysStatsConfig_StatCounters::STAT_UNSPECIFIED;
+constexpr SysStatsConfig_StatCounters SysStatsConfig_StatCounters_MAX = SysStatsConfig_StatCounters::STAT_FORK_COUNT;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* SysStatsConfig_StatCounters_Name(::perfetto::protos::pbzero::SysStatsConfig_StatCounters value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::SysStatsConfig_StatCounters::STAT_UNSPECIFIED:
+    return "STAT_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::SysStatsConfig_StatCounters::STAT_CPU_TIMES:
+    return "STAT_CPU_TIMES";
 
-class ChromeTraceEvent_Arg_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+  case ::perfetto::protos::pbzero::SysStatsConfig_StatCounters::STAT_IRQ_COUNTS:
+    return "STAT_IRQ_COUNTS";
+
+  case ::perfetto::protos::pbzero::SysStatsConfig_StatCounters::STAT_SOFTIRQ_COUNTS:
+    return "STAT_SOFTIRQ_COUNTS";
+
+  case ::perfetto::protos::pbzero::SysStatsConfig_StatCounters::STAT_FORK_COUNT:
+    return "STAT_FORK_COUNT";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class SysStatsConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/14> {
  public:
-  ChromeTraceEvent_Arg_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeTraceEvent_Arg_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeTraceEvent_Arg_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_bool_value() const { return at<2>().valid(); }
-  bool bool_value() const { return at<2>().as_bool(); }
-  bool has_uint_value() const { return at<3>().valid(); }
-  uint64_t uint_value() const { return at<3>().as_uint64(); }
-  bool has_int_value() const { return at<4>().valid(); }
-  int64_t int_value() const { return at<4>().as_int64(); }
-  bool has_double_value() const { return at<5>().valid(); }
-  double double_value() const { return at<5>().as_double(); }
-  bool has_string_value() const { return at<6>().valid(); }
-  ::protozero::ConstChars string_value() const { return at<6>().as_string(); }
-  bool has_pointer_value() const { return at<7>().valid(); }
-  uint64_t pointer_value() const { return at<7>().as_uint64(); }
-  bool has_json_value() const { return at<8>().valid(); }
-  ::protozero::ConstChars json_value() const { return at<8>().as_string(); }
-  bool has_traced_value() const { return at<10>().valid(); }
-  ::protozero::ConstBytes traced_value() const { return at<10>().as_bytes(); }
-  bool has_name_index() const { return at<9>().valid(); }
-  uint32_t name_index() const { return at<9>().as_uint32(); }
+  SysStatsConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SysStatsConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SysStatsConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_meminfo_period_ms() const { return at<1>().valid(); }
+  uint32_t meminfo_period_ms() const { return at<1>().as_uint32(); }
+  bool has_meminfo_counters() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> meminfo_counters() const { return GetRepeated<int32_t>(2); }
+  bool has_vmstat_period_ms() const { return at<3>().valid(); }
+  uint32_t vmstat_period_ms() const { return at<3>().as_uint32(); }
+  bool has_vmstat_counters() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> vmstat_counters() const { return GetRepeated<int32_t>(4); }
+  bool has_stat_period_ms() const { return at<5>().valid(); }
+  uint32_t stat_period_ms() const { return at<5>().as_uint32(); }
+  bool has_stat_counters() const { return at<6>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> stat_counters() const { return GetRepeated<int32_t>(6); }
+  bool has_devfreq_period_ms() const { return at<7>().valid(); }
+  uint32_t devfreq_period_ms() const { return at<7>().as_uint32(); }
+  bool has_cpufreq_period_ms() const { return at<8>().valid(); }
+  uint32_t cpufreq_period_ms() const { return at<8>().as_uint32(); }
+  bool has_buddyinfo_period_ms() const { return at<9>().valid(); }
+  uint32_t buddyinfo_period_ms() const { return at<9>().as_uint32(); }
+  bool has_diskstat_period_ms() const { return at<10>().valid(); }
+  uint32_t diskstat_period_ms() const { return at<10>().as_uint32(); }
+  bool has_psi_period_ms() const { return at<11>().valid(); }
+  uint32_t psi_period_ms() const { return at<11>().as_uint32(); }
+  bool has_thermal_period_ms() const { return at<12>().valid(); }
+  uint32_t thermal_period_ms() const { return at<12>().as_uint32(); }
+  bool has_cpuidle_period_ms() const { return at<13>().valid(); }
+  uint32_t cpuidle_period_ms() const { return at<13>().as_uint32(); }
+  bool has_gpufreq_period_ms() const { return at<14>().valid(); }
+  uint32_t gpufreq_period_ms() const { return at<14>().as_uint32(); }
 };
 
-class ChromeTraceEvent_Arg : public ::protozero::Message {
+class SysStatsConfig : public ::protozero::Message {
  public:
-  using Decoder = ChromeTraceEvent_Arg_Decoder;
+  using Decoder = SysStatsConfig_Decoder;
   enum : int32_t {
-    kNameFieldNumber = 1,
-    kBoolValueFieldNumber = 2,
-    kUintValueFieldNumber = 3,
-    kIntValueFieldNumber = 4,
-    kDoubleValueFieldNumber = 5,
-    kStringValueFieldNumber = 6,
-    kPointerValueFieldNumber = 7,
-    kJsonValueFieldNumber = 8,
-    kTracedValueFieldNumber = 10,
-    kNameIndexFieldNumber = 9,
+    kMeminfoPeriodMsFieldNumber = 1,
+    kMeminfoCountersFieldNumber = 2,
+    kVmstatPeriodMsFieldNumber = 3,
+    kVmstatCountersFieldNumber = 4,
+    kStatPeriodMsFieldNumber = 5,
+    kStatCountersFieldNumber = 6,
+    kDevfreqPeriodMsFieldNumber = 7,
+    kCpufreqPeriodMsFieldNumber = 8,
+    kBuddyinfoPeriodMsFieldNumber = 9,
+    kDiskstatPeriodMsFieldNumber = 10,
+    kPsiPeriodMsFieldNumber = 11,
+    kThermalPeriodMsFieldNumber = 12,
+    kCpuidlePeriodMsFieldNumber = 13,
+    kGpufreqPeriodMsFieldNumber = 14,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeTraceEvent.Arg"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.SysStatsConfig"; }
 
 
-  using FieldMetadata_Name =
+  using StatCounters = ::perfetto::protos::pbzero::SysStatsConfig_StatCounters;
+  static inline const char* StatCounters_Name(StatCounters value) {
+    return ::perfetto::protos::pbzero::SysStatsConfig_StatCounters_Name(value);
+  }
+  static inline const StatCounters STAT_UNSPECIFIED = StatCounters::STAT_UNSPECIFIED;
+  static inline const StatCounters STAT_CPU_TIMES = StatCounters::STAT_CPU_TIMES;
+  static inline const StatCounters STAT_IRQ_COUNTS = StatCounters::STAT_IRQ_COUNTS;
+  static inline const StatCounters STAT_SOFTIRQ_COUNTS = StatCounters::STAT_SOFTIRQ_COUNTS;
+  static inline const StatCounters STAT_FORK_COUNT = StatCounters::STAT_FORK_COUNT;
+
+  using FieldMetadata_MeminfoPeriodMs =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeTraceEvent_Arg>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SysStatsConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_MeminfoPeriodMs kMeminfoPeriodMs{};
+  void set_meminfo_period_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MeminfoPeriodMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BoolValue =
+  using FieldMetadata_MeminfoCounters =
     ::protozero::proto_utils::FieldMetadata<
       2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeTraceEvent_Arg>;
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      MeminfoCounters,
+      SysStatsConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BoolValue kBoolValue() { return {}; }
-  void set_bool_value(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_BoolValue::kFieldId;
+  static constexpr FieldMetadata_MeminfoCounters kMeminfoCounters{};
+  void add_meminfo_counters(MeminfoCounters value) {
+    static constexpr uint32_t field_id = FieldMetadata_MeminfoCounters::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_UintValue =
+  using FieldMetadata_VmstatPeriodMs =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ChromeTraceEvent_Arg>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SysStatsConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UintValue kUintValue() { return {}; }
-  void set_uint_value(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_UintValue::kFieldId;
+  static constexpr FieldMetadata_VmstatPeriodMs kVmstatPeriodMs{};
+  void set_vmstat_period_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VmstatPeriodMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IntValue =
+  using FieldMetadata_VmstatCounters =
     ::protozero::proto_utils::FieldMetadata<
       4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ChromeTraceEvent_Arg>;
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      VmstatCounters,
+      SysStatsConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IntValue kIntValue() { return {}; }
-  void set_int_value(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId;
+  static constexpr FieldMetadata_VmstatCounters kVmstatCounters{};
+  void add_vmstat_counters(VmstatCounters value) {
+    static constexpr uint32_t field_id = FieldMetadata_VmstatCounters::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DoubleValue =
+  using FieldMetadata_StatPeriodMs =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kDouble,
-      double,
-      ChromeTraceEvent_Arg>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SysStatsConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DoubleValue kDoubleValue() { return {}; }
-  void set_double_value(double value) {
-    static constexpr uint32_t field_id = FieldMetadata_DoubleValue::kFieldId;
+  static constexpr FieldMetadata_StatPeriodMs kStatPeriodMs{};
+  void set_stat_period_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StatPeriodMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_StringValue =
+  using FieldMetadata_StatCounters =
     ::protozero::proto_utils::FieldMetadata<
       6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeTraceEvent_Arg>;
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      SysStatsConfig_StatCounters,
+      SysStatsConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StringValue kStringValue() { return {}; }
-  void set_string_value(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_StringValue::kFieldId, data, size);
-  }
-  void set_string_value(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_StringValue::kFieldId, chars.data, chars.size);
-  }
-  void set_string_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_StringValue::kFieldId;
+  static constexpr FieldMetadata_StatCounters kStatCounters{};
+  void add_stat_counters(SysStatsConfig_StatCounters value) {
+    static constexpr uint32_t field_id = FieldMetadata_StatCounters::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PointerValue =
+  using FieldMetadata_DevfreqPeriodMs =
     ::protozero::proto_utils::FieldMetadata<
       7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ChromeTraceEvent_Arg>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SysStatsConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PointerValue kPointerValue() { return {}; }
-  void set_pointer_value(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PointerValue::kFieldId;
+  static constexpr FieldMetadata_DevfreqPeriodMs kDevfreqPeriodMs{};
+  void set_devfreq_period_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DevfreqPeriodMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_JsonValue =
+  using FieldMetadata_CpufreqPeriodMs =
     ::protozero::proto_utils::FieldMetadata<
       8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeTraceEvent_Arg>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SysStatsConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_JsonValue kJsonValue() { return {}; }
-  void set_json_value(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_JsonValue::kFieldId, data, size);
-  }
-  void set_json_value(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_JsonValue::kFieldId, chars.data, chars.size);
+  static constexpr FieldMetadata_CpufreqPeriodMs kCpufreqPeriodMs{};
+  void set_cpufreq_period_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CpufreqPeriodMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
-  void set_json_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_JsonValue::kFieldId;
+
+  using FieldMetadata_BuddyinfoPeriodMs =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SysStatsConfig>;
+
+  static constexpr FieldMetadata_BuddyinfoPeriodMs kBuddyinfoPeriodMs{};
+  void set_buddyinfo_period_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BuddyinfoPeriodMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TracedValue =
+  using FieldMetadata_DiskstatPeriodMs =
     ::protozero::proto_utils::FieldMetadata<
       10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeTracedValue,
-      ChromeTraceEvent_Arg>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SysStatsConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TracedValue kTracedValue() { return {}; }
-  template <typename T = ChromeTracedValue> T* set_traced_value() {
-    return BeginNestedMessage<T>(10);
+  static constexpr FieldMetadata_DiskstatPeriodMs kDiskstatPeriodMs{};
+  void set_diskstat_period_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DiskstatPeriodMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_NameIndex =
+  using FieldMetadata_PsiPeriodMs =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      ChromeTraceEvent_Arg>;
+      SysStatsConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NameIndex kNameIndex() { return {}; }
-  void set_name_index(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NameIndex::kFieldId;
+  static constexpr FieldMetadata_PsiPeriodMs kPsiPeriodMs{};
+  void set_psi_period_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PsiPeriodMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class ChromeStringTableEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  ChromeStringTableEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeStringTableEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeStringTableEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_value() const { return at<1>().valid(); }
-  ::protozero::ConstChars value() const { return at<1>().as_string(); }
-  bool has_index() const { return at<2>().valid(); }
-  int32_t index() const { return at<2>().as_int32(); }
-};
 
-class ChromeStringTableEntry : public ::protozero::Message {
- public:
-  using Decoder = ChromeStringTableEntry_Decoder;
-  enum : int32_t {
-    kValueFieldNumber = 1,
-    kIndexFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeStringTableEntry"; }
+  using FieldMetadata_ThermalPeriodMs =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SysStatsConfig>;
 
+  static constexpr FieldMetadata_ThermalPeriodMs kThermalPeriodMs{};
+  void set_thermal_period_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ThermalPeriodMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Value =
+  using FieldMetadata_CpuidlePeriodMs =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      13,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeStringTableEntry>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SysStatsConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
-  }
-  void set_value(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
-  }
-  void set_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+  static constexpr FieldMetadata_CpuidlePeriodMs kCpuidlePeriodMs{};
+  void set_cpuidle_period_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CpuidlePeriodMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Index =
+  using FieldMetadata_GpufreqPeriodMs =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      14,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ChromeStringTableEntry>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SysStatsConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Index kIndex() { return {}; }
-  void set_index(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
+  static constexpr FieldMetadata_GpufreqPeriodMs kGpufreqPeriodMs{};
+  void set_gpufreq_period_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GpufreqPeriodMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class ChromeTracedValue_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/system_info/system_info_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYSTEM_INFO_SYSTEM_INFO_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYSTEM_INFO_SYSTEM_INFO_CONFIG_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class SystemInfoConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0> {
  public:
-  ChromeTracedValue_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeTracedValue_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeTracedValue_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_nested_type() const { return at<1>().valid(); }
-  int32_t nested_type() const { return at<1>().as_int32(); }
-  bool has_dict_keys() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> dict_keys() const { return GetRepeated<::protozero::ConstChars>(2); }
-  bool has_dict_values() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> dict_values() const { return GetRepeated<::protozero::ConstBytes>(3); }
-  bool has_array_values() const { return at<4>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> array_values() const { return GetRepeated<::protozero::ConstBytes>(4); }
-  bool has_int_value() const { return at<5>().valid(); }
-  int32_t int_value() const { return at<5>().as_int32(); }
-  bool has_double_value() const { return at<6>().valid(); }
-  double double_value() const { return at<6>().as_double(); }
-  bool has_bool_value() const { return at<7>().valid(); }
-  bool bool_value() const { return at<7>().as_bool(); }
-  bool has_string_value() const { return at<8>().valid(); }
-  ::protozero::ConstChars string_value() const { return at<8>().as_string(); }
+  SystemInfoConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SystemInfoConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SystemInfoConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
 };
 
-class ChromeTracedValue : public ::protozero::Message {
+class SystemInfoConfig : public ::protozero::Message {
  public:
-  using Decoder = ChromeTracedValue_Decoder;
+  using Decoder = SystemInfoConfig_Decoder;
+  static constexpr const char* GetName() { return ".perfetto.protos.SystemInfoConfig"; }
+
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/track_event/track_event_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TRACK_EVENT_TRACK_EVENT_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TRACK_EVENT_TRACK_EVENT_CONFIG_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class TrackEventConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10> {
+ public:
+  TrackEventConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TrackEventConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TrackEventConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_disabled_categories() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> disabled_categories() const { return GetRepeated<::protozero::ConstChars>(1); }
+  bool has_enabled_categories() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> enabled_categories() const { return GetRepeated<::protozero::ConstChars>(2); }
+  bool has_disabled_tags() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> disabled_tags() const { return GetRepeated<::protozero::ConstChars>(3); }
+  bool has_enabled_tags() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> enabled_tags() const { return GetRepeated<::protozero::ConstChars>(4); }
+  bool has_disable_incremental_timestamps() const { return at<5>().valid(); }
+  bool disable_incremental_timestamps() const { return at<5>().as_bool(); }
+  bool has_timestamp_unit_multiplier() const { return at<6>().valid(); }
+  uint64_t timestamp_unit_multiplier() const { return at<6>().as_uint64(); }
+  bool has_filter_debug_annotations() const { return at<7>().valid(); }
+  bool filter_debug_annotations() const { return at<7>().as_bool(); }
+  bool has_enable_thread_time_sampling() const { return at<8>().valid(); }
+  bool enable_thread_time_sampling() const { return at<8>().as_bool(); }
+  bool has_thread_time_subsampling_ns() const { return at<10>().valid(); }
+  uint64_t thread_time_subsampling_ns() const { return at<10>().as_uint64(); }
+  bool has_filter_dynamic_event_names() const { return at<9>().valid(); }
+  bool filter_dynamic_event_names() const { return at<9>().as_bool(); }
+};
+
+class TrackEventConfig : public ::protozero::Message {
+ public:
+  using Decoder = TrackEventConfig_Decoder;
   enum : int32_t {
-    kNestedTypeFieldNumber = 1,
-    kDictKeysFieldNumber = 2,
-    kDictValuesFieldNumber = 3,
-    kArrayValuesFieldNumber = 4,
-    kIntValueFieldNumber = 5,
-    kDoubleValueFieldNumber = 6,
-    kBoolValueFieldNumber = 7,
-    kStringValueFieldNumber = 8,
+    kDisabledCategoriesFieldNumber = 1,
+    kEnabledCategoriesFieldNumber = 2,
+    kDisabledTagsFieldNumber = 3,
+    kEnabledTagsFieldNumber = 4,
+    kDisableIncrementalTimestampsFieldNumber = 5,
+    kTimestampUnitMultiplierFieldNumber = 6,
+    kFilterDebugAnnotationsFieldNumber = 7,
+    kEnableThreadTimeSamplingFieldNumber = 8,
+    kThreadTimeSubsamplingNsFieldNumber = 10,
+    kFilterDynamicEventNamesFieldNumber = 9,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeTracedValue"; }
-
+  static constexpr const char* GetName() { return ".perfetto.protos.TrackEventConfig"; }
 
-  using NestedType = ::perfetto::protos::pbzero::ChromeTracedValue_NestedType;
-  static inline const char* NestedType_Name(NestedType value) {
-    return ::perfetto::protos::pbzero::ChromeTracedValue_NestedType_Name(value);
-  }
-  static const NestedType DICT = NestedType::DICT;
-  static const NestedType ARRAY = NestedType::ARRAY;
 
-  using FieldMetadata_NestedType =
+  using FieldMetadata_DisabledCategories =
     ::protozero::proto_utils::FieldMetadata<
       1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ChromeTracedValue_NestedType,
-      ChromeTracedValue>;
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TrackEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NestedType kNestedType() { return {}; }
-  void set_nested_type(::perfetto::protos::pbzero::ChromeTracedValue_NestedType value) {
-    static constexpr uint32_t field_id = FieldMetadata_NestedType::kFieldId;
+  static constexpr FieldMetadata_DisabledCategories kDisabledCategories{};
+  void add_disabled_categories(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_DisabledCategories::kFieldId, data, size);
+  }
+  void add_disabled_categories(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_DisabledCategories::kFieldId, chars.data, chars.size);
+  }
+  void add_disabled_categories(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_DisabledCategories::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DictKeys =
+  using FieldMetadata_EnabledCategories =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      ChromeTracedValue>;
+      TrackEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DictKeys kDictKeys() { return {}; }
-  void add_dict_keys(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_DictKeys::kFieldId, data, size);
+  static constexpr FieldMetadata_EnabledCategories kEnabledCategories{};
+  void add_enabled_categories(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_EnabledCategories::kFieldId, data, size);
   }
-  void add_dict_keys(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_DictKeys::kFieldId, chars.data, chars.size);
+  void add_enabled_categories(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_EnabledCategories::kFieldId, chars.data, chars.size);
   }
-  void add_dict_keys(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_DictKeys::kFieldId;
+  void add_enabled_categories(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_EnabledCategories::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -52336,116 +58134,101 @@ class ChromeTracedValue : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DictValues =
+  using FieldMetadata_DisabledTags =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeTracedValue,
-      ChromeTracedValue>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TrackEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DictValues kDictValues() { return {}; }
-  template <typename T = ChromeTracedValue> T* add_dict_values() {
-    return BeginNestedMessage<T>(3);
+  static constexpr FieldMetadata_DisabledTags kDisabledTags{};
+  void add_disabled_tags(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_DisabledTags::kFieldId, data, size);
+  }
+  void add_disabled_tags(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_DisabledTags::kFieldId, chars.data, chars.size);
+  }
+  void add_disabled_tags(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_DisabledTags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_ArrayValues =
+  using FieldMetadata_EnabledTags =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeTracedValue,
-      ChromeTracedValue>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TrackEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ArrayValues kArrayValues() { return {}; }
-  template <typename T = ChromeTracedValue> T* add_array_values() {
-    return BeginNestedMessage<T>(4);
+  static constexpr FieldMetadata_EnabledTags kEnabledTags{};
+  void add_enabled_tags(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_EnabledTags::kFieldId, data, size);
+  }
+  void add_enabled_tags(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_EnabledTags::kFieldId, chars.data, chars.size);
+  }
+  void add_enabled_tags(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_EnabledTags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_IntValue =
+  using FieldMetadata_DisableIncrementalTimestamps =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ChromeTracedValue>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TrackEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IntValue kIntValue() { return {}; }
-  void set_int_value(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId;
+  static constexpr FieldMetadata_DisableIncrementalTimestamps kDisableIncrementalTimestamps{};
+  void set_disable_incremental_timestamps(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DisableIncrementalTimestamps::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DoubleValue =
+  using FieldMetadata_TimestampUnitMultiplier =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kDouble,
-      double,
-      ChromeTracedValue>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TrackEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DoubleValue kDoubleValue() { return {}; }
-  void set_double_value(double value) {
-    static constexpr uint32_t field_id = FieldMetadata_DoubleValue::kFieldId;
+  static constexpr FieldMetadata_TimestampUnitMultiplier kTimestampUnitMultiplier{};
+  void set_timestamp_unit_multiplier(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimestampUnitMultiplier::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BoolValue =
+  using FieldMetadata_FilterDebugAnnotations =
     ::protozero::proto_utils::FieldMetadata<
       7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kBool,
       bool,
-      ChromeTracedValue>;
+      TrackEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BoolValue kBoolValue() { return {}; }
-  void set_bool_value(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_BoolValue::kFieldId;
+  static constexpr FieldMetadata_FilterDebugAnnotations kFilterDebugAnnotations{};
+  void set_filter_debug_annotations(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_FilterDebugAnnotations::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -52453,34 +58236,57 @@ class ChromeTracedValue : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_StringValue =
+  using FieldMetadata_EnableThreadTimeSampling =
     ::protozero::proto_utils::FieldMetadata<
       8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeTracedValue>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TrackEventConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StringValue kStringValue() { return {}; }
-  void set_string_value(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_StringValue::kFieldId, data, size);
+  static constexpr FieldMetadata_EnableThreadTimeSampling kEnableThreadTimeSampling{};
+  void set_enable_thread_time_sampling(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_EnableThreadTimeSampling::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
   }
-  void set_string_value(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_StringValue::kFieldId, chars.data, chars.size);
+
+  using FieldMetadata_ThreadTimeSubsamplingNs =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TrackEventConfig>;
+
+  static constexpr FieldMetadata_ThreadTimeSubsamplingNs kThreadTimeSubsamplingNs{};
+  void set_thread_time_subsampling_ns(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ThreadTimeSubsamplingNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
-  void set_string_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_StringValue::kFieldId;
+
+  using FieldMetadata_FilterDynamicEventNames =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TrackEventConfig>;
+
+  static constexpr FieldMetadata_FilterDynamicEventNames kFilterDynamicEventNames{};
+  void set_filter_dynamic_event_names(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_FilterDynamicEventNames::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 };
@@ -52489,11 +58295,11 @@ class ChromeTracedValue : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/filesystem/inode_file_map.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/config/chrome/chrome_config.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FILESYSTEM_INODE_FILE_MAP_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FILESYSTEM_INODE_FILE_MAP_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_CHROME_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_CHROME_CONFIG_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -52507,116 +58313,183 @@ class ChromeTracedValue : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
+namespace perfetto_pbzero_enum_ChromeConfig {
+enum ClientPriority : int32_t;
+}  // namespace perfetto_pbzero_enum_ChromeConfig
+using ChromeConfig_ClientPriority = perfetto_pbzero_enum_ChromeConfig::ClientPriority;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-class InodeFileMap_Entry;
-namespace perfetto_pbzero_enum_InodeFileMap_Entry {
-enum Type : int32_t;
-}  // namespace perfetto_pbzero_enum_InodeFileMap_Entry
-using InodeFileMap_Entry_Type = perfetto_pbzero_enum_InodeFileMap_Entry::Type;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-namespace perfetto_pbzero_enum_InodeFileMap_Entry {
-enum Type : int32_t {
+namespace perfetto_pbzero_enum_ChromeConfig {
+enum ClientPriority : int32_t {
   UNKNOWN = 0,
-  FILE = 1,
-  DIRECTORY = 2,
+  BACKGROUND = 1,
+  USER_INITIATED = 2,
 };
-} // namespace perfetto_pbzero_enum_InodeFileMap_Entry
-using InodeFileMap_Entry_Type = perfetto_pbzero_enum_InodeFileMap_Entry::Type;
+} // namespace perfetto_pbzero_enum_ChromeConfig
+using ChromeConfig_ClientPriority = perfetto_pbzero_enum_ChromeConfig::ClientPriority;
 
 
-constexpr InodeFileMap_Entry_Type InodeFileMap_Entry_Type_MIN = InodeFileMap_Entry_Type::UNKNOWN;
-constexpr InodeFileMap_Entry_Type InodeFileMap_Entry_Type_MAX = InodeFileMap_Entry_Type::DIRECTORY;
+constexpr ChromeConfig_ClientPriority ChromeConfig_ClientPriority_MIN = ChromeConfig_ClientPriority::UNKNOWN;
+constexpr ChromeConfig_ClientPriority ChromeConfig_ClientPriority_MAX = ChromeConfig_ClientPriority::USER_INITIATED;
 
 
 PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* InodeFileMap_Entry_Type_Name(::perfetto::protos::pbzero::InodeFileMap_Entry_Type value) {
+const char* ChromeConfig_ClientPriority_Name(::perfetto::protos::pbzero::ChromeConfig_ClientPriority value) {
   switch (value) {
-  case ::perfetto::protos::pbzero::InodeFileMap_Entry_Type::UNKNOWN:
+  case ::perfetto::protos::pbzero::ChromeConfig_ClientPriority::UNKNOWN:
     return "UNKNOWN";
 
-  case ::perfetto::protos::pbzero::InodeFileMap_Entry_Type::FILE:
-    return "FILE";
+  case ::perfetto::protos::pbzero::ChromeConfig_ClientPriority::BACKGROUND:
+    return "BACKGROUND";
 
-  case ::perfetto::protos::pbzero::InodeFileMap_Entry_Type::DIRECTORY:
-    return "DIRECTORY";
+  case ::perfetto::protos::pbzero::ChromeConfig_ClientPriority::USER_INITIATED:
+    return "USER_INITIATED";
   }
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-class InodeFileMap_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class ChromeConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  InodeFileMap_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit InodeFileMap_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit InodeFileMap_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_block_device_id() const { return at<1>().valid(); }
-  uint64_t block_device_id() const { return at<1>().as_uint64(); }
-  bool has_mount_points() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> mount_points() const { return GetRepeated<::protozero::ConstChars>(2); }
-  bool has_entries() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> entries() const { return GetRepeated<::protozero::ConstBytes>(3); }
+  ChromeConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_trace_config() const { return at<1>().valid(); }
+  ::protozero::ConstChars trace_config() const { return at<1>().as_string(); }
+  bool has_privacy_filtering_enabled() const { return at<2>().valid(); }
+  bool privacy_filtering_enabled() const { return at<2>().as_bool(); }
+  bool has_convert_to_legacy_json() const { return at<3>().valid(); }
+  bool convert_to_legacy_json() const { return at<3>().as_bool(); }
+  bool has_client_priority() const { return at<4>().valid(); }
+  int32_t client_priority() const { return at<4>().as_int32(); }
+  bool has_json_agent_label_filter() const { return at<5>().valid(); }
+  ::protozero::ConstChars json_agent_label_filter() const { return at<5>().as_string(); }
+  bool has_event_package_name_filter_enabled() const { return at<6>().valid(); }
+  bool event_package_name_filter_enabled() const { return at<6>().as_bool(); }
 };
 
-class InodeFileMap : public ::protozero::Message {
+class ChromeConfig : public ::protozero::Message {
  public:
-  using Decoder = InodeFileMap_Decoder;
+  using Decoder = ChromeConfig_Decoder;
   enum : int32_t {
-    kBlockDeviceIdFieldNumber = 1,
-    kMountPointsFieldNumber = 2,
-    kEntriesFieldNumber = 3,
+    kTraceConfigFieldNumber = 1,
+    kPrivacyFilteringEnabledFieldNumber = 2,
+    kConvertToLegacyJsonFieldNumber = 3,
+    kClientPriorityFieldNumber = 4,
+    kJsonAgentLabelFilterFieldNumber = 5,
+    kEventPackageNameFilterEnabledFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.InodeFileMap"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeConfig"; }
 
-  using Entry = ::perfetto::protos::pbzero::InodeFileMap_Entry;
 
-  using FieldMetadata_BlockDeviceId =
+  using ClientPriority = ::perfetto::protos::pbzero::ChromeConfig_ClientPriority;
+  static inline const char* ClientPriority_Name(ClientPriority value) {
+    return ::perfetto::protos::pbzero::ChromeConfig_ClientPriority_Name(value);
+  }
+  static inline const ClientPriority UNKNOWN = ClientPriority::UNKNOWN;
+  static inline const ClientPriority BACKGROUND = ClientPriority::BACKGROUND;
+  static inline const ClientPriority USER_INITIATED = ClientPriority::USER_INITIATED;
+
+  using FieldMetadata_TraceConfig =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      InodeFileMap>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockDeviceId kBlockDeviceId() { return {}; }
-  void set_block_device_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BlockDeviceId::kFieldId;
+  static constexpr FieldMetadata_TraceConfig kTraceConfig{};
+  void set_trace_config(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_TraceConfig::kFieldId, data, size);
+  }
+  void set_trace_config(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_TraceConfig::kFieldId, chars.data, chars.size);
+  }
+  void set_trace_config(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_TraceConfig::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MountPoints =
+  using FieldMetadata_PrivacyFilteringEnabled =
     ::protozero::proto_utils::FieldMetadata<
       2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeConfig>;
+
+  static constexpr FieldMetadata_PrivacyFilteringEnabled kPrivacyFilteringEnabled{};
+  void set_privacy_filtering_enabled(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_PrivacyFilteringEnabled::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ConvertToLegacyJson =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeConfig>;
+
+  static constexpr FieldMetadata_ConvertToLegacyJson kConvertToLegacyJson{};
+  void set_convert_to_legacy_json(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ConvertToLegacyJson::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ClientPriority =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ChromeConfig_ClientPriority,
+      ChromeConfig>;
+
+  static constexpr FieldMetadata_ClientPriority kClientPriority{};
+  void set_client_priority(ChromeConfig_ClientPriority value) {
+    static constexpr uint32_t field_id = FieldMetadata_ClientPriority::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_JsonAgentLabelFilter =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      InodeFileMap>;
+      ChromeConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MountPoints kMountPoints() { return {}; }
-  void add_mount_points(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_MountPoints::kFieldId, data, size);
+  static constexpr FieldMetadata_JsonAgentLabelFilter kJsonAgentLabelFilter{};
+  void set_json_agent_label_filter(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_JsonAgentLabelFilter::kFieldId, data, size);
   }
-  void add_mount_points(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_MountPoints::kFieldId, chars.data, chars.size);
+  void set_json_agent_label_filter(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_JsonAgentLabelFilter::kFieldId, chars.data, chars.size);
   }
-  void add_mount_points(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_MountPoints::kFieldId;
+  void set_json_agent_label_filter(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_JsonAgentLabelFilter::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -52624,109 +58497,152 @@ class InodeFileMap : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Entries =
+  using FieldMetadata_EventPackageNameFilterEnabled =
     ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      InodeFileMap_Entry,
-      InodeFileMap>;
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Entries kEntries() { return {}; }
-  template <typename T = InodeFileMap_Entry> T* add_entries() {
-    return BeginNestedMessage<T>(3);
+  static constexpr FieldMetadata_EventPackageNameFilterEnabled kEventPackageNameFilterEnabled{};
+  void set_event_package_name_filter_enabled(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_EventPackageNameFilterEnabled::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
   }
-
 };
 
-class InodeFileMap_Entry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/chrome/histogram_samples.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_HISTOGRAM_SAMPLES_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_HISTOGRAM_SAMPLES_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class ChromiumHistogramSamplesConfig_HistogramSample;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class ChromiumHistogramSamplesConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  InodeFileMap_Entry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit InodeFileMap_Entry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit InodeFileMap_Entry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_inode_number() const { return at<1>().valid(); }
-  uint64_t inode_number() const { return at<1>().as_uint64(); }
-  bool has_paths() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> paths() const { return GetRepeated<::protozero::ConstChars>(2); }
-  bool has_type() const { return at<3>().valid(); }
-  int32_t type() const { return at<3>().as_int32(); }
+  ChromiumHistogramSamplesConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromiumHistogramSamplesConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromiumHistogramSamplesConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_histograms() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> histograms() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  bool has_filter_histogram_names() const { return at<2>().valid(); }
+  bool filter_histogram_names() const { return at<2>().as_bool(); }
 };
 
-class InodeFileMap_Entry : public ::protozero::Message {
+class ChromiumHistogramSamplesConfig : public ::protozero::Message {
  public:
-  using Decoder = InodeFileMap_Entry_Decoder;
+  using Decoder = ChromiumHistogramSamplesConfig_Decoder;
   enum : int32_t {
-    kInodeNumberFieldNumber = 1,
-    kPathsFieldNumber = 2,
-    kTypeFieldNumber = 3,
+    kHistogramsFieldNumber = 1,
+    kFilterHistogramNamesFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.InodeFileMap.Entry"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromiumHistogramSamplesConfig"; }
 
+  using HistogramSample = ::perfetto::protos::pbzero::ChromiumHistogramSamplesConfig_HistogramSample;
 
-  using Type = ::perfetto::protos::pbzero::InodeFileMap_Entry_Type;
-  static inline const char* Type_Name(Type value) {
-    return ::perfetto::protos::pbzero::InodeFileMap_Entry_Type_Name(value);
+  using FieldMetadata_Histograms =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromiumHistogramSamplesConfig_HistogramSample,
+      ChromiumHistogramSamplesConfig>;
+
+  static constexpr FieldMetadata_Histograms kHistograms{};
+  template <typename T = ChromiumHistogramSamplesConfig_HistogramSample> T* add_histograms() {
+    return BeginNestedMessage<T>(1);
   }
-  static const Type UNKNOWN = Type::UNKNOWN;
-  static const Type FILE = Type::FILE;
-  static const Type DIRECTORY = Type::DIRECTORY;
 
-  using FieldMetadata_InodeNumber =
+
+  using FieldMetadata_FilterHistogramNames =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      InodeFileMap_Entry>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromiumHistogramSamplesConfig>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InodeNumber kInodeNumber() { return {}; }
-  void set_inode_number(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_InodeNumber::kFieldId;
+  static constexpr FieldMetadata_FilterHistogramNames kFilterHistogramNames{};
+  void set_filter_histogram_names(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_FilterHistogramNames::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Paths =
+class ChromiumHistogramSamplesConfig_HistogramSample_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  ChromiumHistogramSamplesConfig_HistogramSample_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromiumHistogramSamplesConfig_HistogramSample_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromiumHistogramSamplesConfig_HistogramSample_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_histogram_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars histogram_name() const { return at<1>().as_string(); }
+  bool has_min_value() const { return at<2>().valid(); }
+  int64_t min_value() const { return at<2>().as_int64(); }
+  bool has_max_value() const { return at<3>().valid(); }
+  int64_t max_value() const { return at<3>().as_int64(); }
+};
+
+class ChromiumHistogramSamplesConfig_HistogramSample : public ::protozero::Message {
+ public:
+  using Decoder = ChromiumHistogramSamplesConfig_HistogramSample_Decoder;
+  enum : int32_t {
+    kHistogramNameFieldNumber = 1,
+    kMinValueFieldNumber = 2,
+    kMaxValueFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromiumHistogramSamplesConfig.HistogramSample"; }
+
+
+  using FieldMetadata_HistogramName =
     ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      InodeFileMap_Entry>;
+      ChromiumHistogramSamplesConfig_HistogramSample>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Paths kPaths() { return {}; }
-  void add_paths(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Paths::kFieldId, data, size);
+  static constexpr FieldMetadata_HistogramName kHistogramName{};
+  void set_histogram_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_HistogramName::kFieldId, data, size);
   }
-  void add_paths(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Paths::kFieldId, chars.data, chars.size);
+  void set_histogram_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_HistogramName::kFieldId, chars.data, chars.size);
   }
-  void add_paths(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Paths::kFieldId;
+  void set_histogram_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_HistogramName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -52734,28 +58650,39 @@ class InodeFileMap_Entry : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Type =
+  using FieldMetadata_MinValue =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ChromiumHistogramSamplesConfig_HistogramSample>;
+
+  static constexpr FieldMetadata_MinValue kMinValue{};
+  void set_min_value(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MinValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MaxValue =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::InodeFileMap_Entry_Type,
-      InodeFileMap_Entry>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ChromiumHistogramSamplesConfig_HistogramSample>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(::perfetto::protos::pbzero::InodeFileMap_Entry_Type value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+  static constexpr FieldMetadata_MaxValue kMaxValue{};
+  void set_max_value(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MaxValue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 };
@@ -52764,11 +58691,11 @@ class InodeFileMap_Entry : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/ftrace_event.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/config/chrome/scenario_config.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FTRACE_EVENT_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FTRACE_EVENT_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_SCENARIO_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_SCENARIO_CONFIG_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -52782,291 +58709,28975 @@ class InodeFileMap_Entry : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
+class NestedScenarioConfig;
+class ScenarioConfig;
+class TraceConfig;
+class TriggerRule;
+class TriggerRule_HistogramTrigger;
+class TriggerRule_RepeatingInterval;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-class AllocPagesIommuEndFtraceEvent;
-class AllocPagesIommuFailFtraceEvent;
-class AllocPagesIommuStartFtraceEvent;
-class AllocPagesSysEndFtraceEvent;
-class AllocPagesSysFailFtraceEvent;
-class AllocPagesSysStartFtraceEvent;
-class AndroidFsDatareadEndFtraceEvent;
-class AndroidFsDatareadStartFtraceEvent;
-class AndroidFsDatawriteEndFtraceEvent;
-class AndroidFsDatawriteStartFtraceEvent;
-class AndroidFsFsyncEndFtraceEvent;
-class AndroidFsFsyncStartFtraceEvent;
-class BinderLockFtraceEvent;
-class BinderLockedFtraceEvent;
-class BinderSetPriorityFtraceEvent;
-class BinderTransactionAllocBufFtraceEvent;
-class BinderTransactionFtraceEvent;
-class BinderTransactionReceivedFtraceEvent;
-class BinderUnlockFtraceEvent;
-class BlockBioBackmergeFtraceEvent;
-class BlockBioBounceFtraceEvent;
-class BlockBioCompleteFtraceEvent;
-class BlockBioFrontmergeFtraceEvent;
-class BlockBioQueueFtraceEvent;
-class BlockBioRemapFtraceEvent;
-class BlockDirtyBufferFtraceEvent;
-class BlockGetrqFtraceEvent;
-class BlockPlugFtraceEvent;
-class BlockRqAbortFtraceEvent;
-class BlockRqCompleteFtraceEvent;
-class BlockRqInsertFtraceEvent;
-class BlockRqIssueFtraceEvent;
-class BlockRqRemapFtraceEvent;
-class BlockRqRequeueFtraceEvent;
-class BlockSleeprqFtraceEvent;
-class BlockSplitFtraceEvent;
-class BlockTouchBufferFtraceEvent;
-class BlockUnplugFtraceEvent;
-class CdevUpdateFtraceEvent;
-class CgroupAttachTaskFtraceEvent;
-class CgroupDestroyRootFtraceEvent;
-class CgroupMkdirFtraceEvent;
-class CgroupReleaseFtraceEvent;
-class CgroupRemountFtraceEvent;
-class CgroupRenameFtraceEvent;
-class CgroupRmdirFtraceEvent;
-class CgroupSetupRootFtraceEvent;
-class CgroupTransferTasksFtraceEvent;
-class ClkDisableFtraceEvent;
-class ClkEnableFtraceEvent;
-class ClkSetRateFtraceEvent;
-class ClockDisableFtraceEvent;
-class ClockEnableFtraceEvent;
-class ClockSetRateFtraceEvent;
-class CmaAllocInfoFtraceEvent;
-class CmaAllocStartFtraceEvent;
-class ConsoleFtraceEvent;
-class CpuFrequencyFtraceEvent;
-class CpuFrequencyLimitsFtraceEvent;
-class CpuIdleFtraceEvent;
-class CpuhpEnterFtraceEvent;
-class CpuhpExitFtraceEvent;
-class CpuhpLatencyFtraceEvent;
-class CpuhpMultiEnterFtraceEvent;
-class CpuhpPauseFtraceEvent;
-class CrosEcSensorhubDataFtraceEvent;
-class DmaAllocContiguousRetryFtraceEvent;
-class DmaFenceEmitFtraceEvent;
-class DmaFenceInitFtraceEvent;
-class DmaFenceSignaledFtraceEvent;
-class DmaFenceWaitEndFtraceEvent;
-class DmaFenceWaitStartFtraceEvent;
-class DmaHeapStatFtraceEvent;
-class DpuTracingMarkWriteFtraceEvent;
-class DrmRunJobFtraceEvent;
-class DrmSchedJobFtraceEvent;
-class DrmSchedProcessJobFtraceEvent;
-class DrmVblankEventDeliveredFtraceEvent;
-class DrmVblankEventFtraceEvent;
-class DsiCmdFifoStatusFtraceEvent;
-class DsiRxFtraceEvent;
-class DsiTxFtraceEvent;
-class Ext4AllocDaBlocksFtraceEvent;
-class Ext4AllocateBlocksFtraceEvent;
-class Ext4AllocateInodeFtraceEvent;
-class Ext4BeginOrderedTruncateFtraceEvent;
-class Ext4CollapseRangeFtraceEvent;
-class Ext4DaReleaseSpaceFtraceEvent;
-class Ext4DaReserveSpaceFtraceEvent;
-class Ext4DaUpdateReserveSpaceFtraceEvent;
-class Ext4DaWriteBeginFtraceEvent;
-class Ext4DaWriteEndFtraceEvent;
-class Ext4DaWritePagesExtentFtraceEvent;
-class Ext4DaWritePagesFtraceEvent;
-class Ext4DirectIOEnterFtraceEvent;
-class Ext4DirectIOExitFtraceEvent;
-class Ext4DiscardBlocksFtraceEvent;
-class Ext4DiscardPreallocationsFtraceEvent;
-class Ext4DropInodeFtraceEvent;
-class Ext4EsCacheExtentFtraceEvent;
-class Ext4EsFindDelayedExtentRangeEnterFtraceEvent;
-class Ext4EsFindDelayedExtentRangeExitFtraceEvent;
-class Ext4EsInsertExtentFtraceEvent;
-class Ext4EsLookupExtentEnterFtraceEvent;
-class Ext4EsLookupExtentExitFtraceEvent;
-class Ext4EsRemoveExtentFtraceEvent;
-class Ext4EsShrinkCountFtraceEvent;
-class Ext4EsShrinkFtraceEvent;
-class Ext4EsShrinkScanEnterFtraceEvent;
-class Ext4EsShrinkScanExitFtraceEvent;
-class Ext4EvictInodeFtraceEvent;
-class Ext4ExtConvertToInitializedEnterFtraceEvent;
-class Ext4ExtConvertToInitializedFastpathFtraceEvent;
-class Ext4ExtHandleUnwrittenExtentsFtraceEvent;
-class Ext4ExtInCacheFtraceEvent;
-class Ext4ExtLoadExtentFtraceEvent;
-class Ext4ExtMapBlocksEnterFtraceEvent;
-class Ext4ExtMapBlocksExitFtraceEvent;
-class Ext4ExtPutInCacheFtraceEvent;
-class Ext4ExtRemoveSpaceDoneFtraceEvent;
-class Ext4ExtRemoveSpaceFtraceEvent;
-class Ext4ExtRmIdxFtraceEvent;
-class Ext4ExtRmLeafFtraceEvent;
-class Ext4ExtShowExtentFtraceEvent;
-class Ext4FallocateEnterFtraceEvent;
-class Ext4FallocateExitFtraceEvent;
-class Ext4FindDelallocRangeFtraceEvent;
-class Ext4ForgetFtraceEvent;
-class Ext4FreeBlocksFtraceEvent;
-class Ext4FreeInodeFtraceEvent;
-class Ext4GetImpliedClusterAllocExitFtraceEvent;
-class Ext4GetReservedClusterAllocFtraceEvent;
-class Ext4IndMapBlocksEnterFtraceEvent;
-class Ext4IndMapBlocksExitFtraceEvent;
-class Ext4InsertRangeFtraceEvent;
-class Ext4InvalidatepageFtraceEvent;
-class Ext4JournalStartFtraceEvent;
-class Ext4JournalStartReservedFtraceEvent;
-class Ext4JournalledInvalidatepageFtraceEvent;
-class Ext4JournalledWriteEndFtraceEvent;
-class Ext4LoadInodeBitmapFtraceEvent;
-class Ext4LoadInodeFtraceEvent;
-class Ext4MarkInodeDirtyFtraceEvent;
-class Ext4MbBitmapLoadFtraceEvent;
-class Ext4MbBuddyBitmapLoadFtraceEvent;
-class Ext4MbDiscardPreallocationsFtraceEvent;
-class Ext4MbNewGroupPaFtraceEvent;
-class Ext4MbNewInodePaFtraceEvent;
-class Ext4MbReleaseGroupPaFtraceEvent;
-class Ext4MbReleaseInodePaFtraceEvent;
-class Ext4MballocAllocFtraceEvent;
-class Ext4MballocDiscardFtraceEvent;
-class Ext4MballocFreeFtraceEvent;
-class Ext4MballocPreallocFtraceEvent;
-class Ext4OtherInodeUpdateTimeFtraceEvent;
-class Ext4PunchHoleFtraceEvent;
-class Ext4ReadBlockBitmapLoadFtraceEvent;
-class Ext4ReadpageFtraceEvent;
-class Ext4ReleasepageFtraceEvent;
-class Ext4RemoveBlocksFtraceEvent;
-class Ext4RequestBlocksFtraceEvent;
-class Ext4RequestInodeFtraceEvent;
-class Ext4SyncFileEnterFtraceEvent;
-class Ext4SyncFileExitFtraceEvent;
-class Ext4SyncFsFtraceEvent;
-class Ext4TrimAllFreeFtraceEvent;
-class Ext4TrimExtentFtraceEvent;
-class Ext4TruncateEnterFtraceEvent;
-class Ext4TruncateExitFtraceEvent;
-class Ext4UnlinkEnterFtraceEvent;
-class Ext4UnlinkExitFtraceEvent;
-class Ext4WriteBeginFtraceEvent;
-class Ext4WriteEndFtraceEvent;
-class Ext4WritepageFtraceEvent;
-class Ext4WritepagesFtraceEvent;
-class Ext4WritepagesResultFtraceEvent;
-class Ext4ZeroRangeFtraceEvent;
-class F2fsDoSubmitBioFtraceEvent;
-class F2fsEvictInodeFtraceEvent;
-class F2fsFallocateFtraceEvent;
-class F2fsGetDataBlockFtraceEvent;
-class F2fsGetVictimFtraceEvent;
-class F2fsIgetExitFtraceEvent;
-class F2fsIgetFtraceEvent;
-class F2fsIostatFtraceEvent;
-class F2fsIostatLatencyFtraceEvent;
-class F2fsNewInodeFtraceEvent;
-class F2fsReadpageFtraceEvent;
-class F2fsReserveNewBlockFtraceEvent;
-class F2fsSetPageDirtyFtraceEvent;
-class F2fsSubmitWritePageFtraceEvent;
-class F2fsSyncFileEnterFtraceEvent;
-class F2fsSyncFileExitFtraceEvent;
-class F2fsSyncFsFtraceEvent;
-class F2fsTruncateBlocksEnterFtraceEvent;
-class F2fsTruncateBlocksExitFtraceEvent;
-class F2fsTruncateDataBlocksRangeFtraceEvent;
-class F2fsTruncateFtraceEvent;
-class F2fsTruncateInodeBlocksEnterFtraceEvent;
-class F2fsTruncateInodeBlocksExitFtraceEvent;
-class F2fsTruncateNodeFtraceEvent;
-class F2fsTruncateNodesEnterFtraceEvent;
-class F2fsTruncateNodesExitFtraceEvent;
-class F2fsTruncatePartialNodesFtraceEvent;
-class F2fsUnlinkEnterFtraceEvent;
-class F2fsUnlinkExitFtraceEvent;
-class F2fsVmPageMkwriteFtraceEvent;
-class F2fsWriteBeginFtraceEvent;
-class F2fsWriteCheckpointFtraceEvent;
-class F2fsWriteEndFtraceEvent;
-class FastrpcDmaStatFtraceEvent;
-class FenceDestroyFtraceEvent;
-class FenceEnableSignalFtraceEvent;
-class FenceInitFtraceEvent;
-class FenceSignaledFtraceEvent;
-class FuncgraphEntryFtraceEvent;
-class FuncgraphExitFtraceEvent;
-class G2dTracingMarkWriteFtraceEvent;
-class GenericFtraceEvent;
-class GpuFrequencyFtraceEvent;
-class GpuMemTotalFtraceEvent;
-class I2cReadFtraceEvent;
-class I2cReplyFtraceEvent;
-class I2cResultFtraceEvent;
-class I2cWriteFtraceEvent;
-class InetSockSetStateFtraceEvent;
-class IommuMapRangeFtraceEvent;
-class IommuSecPtblMapRangeEndFtraceEvent;
-class IommuSecPtblMapRangeStartFtraceEvent;
-class IonAllocBufferEndFtraceEvent;
-class IonAllocBufferFailFtraceEvent;
-class IonAllocBufferFallbackFtraceEvent;
-class IonAllocBufferStartFtraceEvent;
-class IonBufferCreateFtraceEvent;
-class IonBufferDestroyFtraceEvent;
-class IonCpAllocRetryFtraceEvent;
-class IonCpSecureBufferEndFtraceEvent;
-class IonCpSecureBufferStartFtraceEvent;
-class IonHeapGrowFtraceEvent;
-class IonHeapShrinkFtraceEvent;
-class IonPrefetchingFtraceEvent;
-class IonSecureCmaAddToPoolEndFtraceEvent;
-class IonSecureCmaAddToPoolStartFtraceEvent;
-class IonSecureCmaAllocateEndFtraceEvent;
-class IonSecureCmaAllocateStartFtraceEvent;
-class IonSecureCmaShrinkPoolEndFtraceEvent;
-class IonSecureCmaShrinkPoolStartFtraceEvent;
-class IonStatFtraceEvent;
-class IpiEntryFtraceEvent;
-class IpiExitFtraceEvent;
-class IpiRaiseFtraceEvent;
-class IrqHandlerEntryFtraceEvent;
-class IrqHandlerExitFtraceEvent;
-class KfreeFtraceEvent;
-class KfreeSkbFtraceEvent;
-class KmallocFtraceEvent;
-class KmallocNodeFtraceEvent;
-class KmemCacheAllocFtraceEvent;
-class KmemCacheAllocNodeFtraceEvent;
-class KmemCacheFreeFtraceEvent;
-class KvmAccessFaultFtraceEvent;
-class KvmAckIrqFtraceEvent;
-class KvmAgeHvaFtraceEvent;
-class KvmAgePageFtraceEvent;
-class KvmArmClearDebugFtraceEvent;
-class KvmArmSetDreg32FtraceEvent;
-class KvmArmSetRegsetFtraceEvent;
-class KvmArmSetupDebugFtraceEvent;
-class KvmEntryFtraceEvent;
-class KvmExitFtraceEvent;
-class KvmFpuFtraceEvent;
-class KvmGetTimerMapFtraceEvent;
-class KvmGuestFaultFtraceEvent;
-class KvmHandleSysRegFtraceEvent;
-class KvmHvcArm64FtraceEvent;
-class KvmIrqLineFtraceEvent;
-class KvmMmioEmulateFtraceEvent;
-class KvmMmioFtraceEvent;
-class KvmSetGuestDebugFtraceEvent;
-class KvmSetIrqFtraceEvent;
-class KvmSetSpteHvaFtraceEvent;
-class KvmSetWayFlushFtraceEvent;
-class KvmSysAccessFtraceEvent;
-class KvmTestAgeHvaFtraceEvent;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class TracingTriggerRulesConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  TracingTriggerRulesConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TracingTriggerRulesConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TracingTriggerRulesConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_rules() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> rules() const { return GetRepeated<::protozero::ConstBytes>(1); }
+};
+
+class TracingTriggerRulesConfig : public ::protozero::Message {
+ public:
+  using Decoder = TracingTriggerRulesConfig_Decoder;
+  enum : int32_t {
+    kRulesFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TracingTriggerRulesConfig"; }
+
+
+  using FieldMetadata_Rules =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TriggerRule,
+      TracingTriggerRulesConfig>;
+
+  static constexpr FieldMetadata_Rules kRules{};
+  template <typename T = TriggerRule> T* add_rules() {
+    return BeginNestedMessage<T>(1);
+  }
+
+};
+
+class ChromeFieldTracingConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  ChromeFieldTracingConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeFieldTracingConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeFieldTracingConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_scenarios() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> scenarios() const { return GetRepeated<::protozero::ConstBytes>(1); }
+};
+
+class ChromeFieldTracingConfig : public ::protozero::Message {
+ public:
+  using Decoder = ChromeFieldTracingConfig_Decoder;
+  enum : int32_t {
+    kScenariosFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeFieldTracingConfig"; }
+
+
+  using FieldMetadata_Scenarios =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ScenarioConfig,
+      ChromeFieldTracingConfig>;
+
+  static constexpr FieldMetadata_Scenarios kScenarios{};
+  template <typename T = ScenarioConfig> T* add_scenarios() {
+    return BeginNestedMessage<T>(1);
+  }
+
+};
+
+class ScenarioConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9> {
+ public:
+  ScenarioConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ScenarioConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ScenarioConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_scenario_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars scenario_name() const { return at<1>().as_string(); }
+  bool has_scenario_description() const { return at<9>().valid(); }
+  ::protozero::ConstChars scenario_description() const { return at<9>().as_string(); }
+  bool has_start_rules() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> start_rules() const { return GetRepeated<::protozero::ConstBytes>(2); }
+  bool has_stop_rules() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> stop_rules() const { return GetRepeated<::protozero::ConstBytes>(3); }
+  bool has_upload_rules() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> upload_rules() const { return GetRepeated<::protozero::ConstBytes>(4); }
+  bool has_setup_rules() const { return at<5>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> setup_rules() const { return GetRepeated<::protozero::ConstBytes>(5); }
+  bool has_trace_config() const { return at<6>().valid(); }
+  ::protozero::ConstBytes trace_config() const { return at<6>().as_bytes(); }
+  bool has_nested_scenarios() const { return at<7>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> nested_scenarios() const { return GetRepeated<::protozero::ConstBytes>(7); }
+  bool has_use_system_backend() const { return at<8>().valid(); }
+  bool use_system_backend() const { return at<8>().as_bool(); }
+};
+
+class ScenarioConfig : public ::protozero::Message {
+ public:
+  using Decoder = ScenarioConfig_Decoder;
+  enum : int32_t {
+    kScenarioNameFieldNumber = 1,
+    kScenarioDescriptionFieldNumber = 9,
+    kStartRulesFieldNumber = 2,
+    kStopRulesFieldNumber = 3,
+    kUploadRulesFieldNumber = 4,
+    kSetupRulesFieldNumber = 5,
+    kTraceConfigFieldNumber = 6,
+    kNestedScenariosFieldNumber = 7,
+    kUseSystemBackendFieldNumber = 8,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ScenarioConfig"; }
+
+
+  using FieldMetadata_ScenarioName =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ScenarioConfig>;
+
+  static constexpr FieldMetadata_ScenarioName kScenarioName{};
+  void set_scenario_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ScenarioName::kFieldId, data, size);
+  }
+  void set_scenario_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ScenarioName::kFieldId, chars.data, chars.size);
+  }
+  void set_scenario_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ScenarioName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ScenarioDescription =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ScenarioConfig>;
+
+  static constexpr FieldMetadata_ScenarioDescription kScenarioDescription{};
+  void set_scenario_description(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ScenarioDescription::kFieldId, data, size);
+  }
+  void set_scenario_description(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ScenarioDescription::kFieldId, chars.data, chars.size);
+  }
+  void set_scenario_description(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ScenarioDescription::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StartRules =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TriggerRule,
+      ScenarioConfig>;
+
+  static constexpr FieldMetadata_StartRules kStartRules{};
+  template <typename T = TriggerRule> T* add_start_rules() {
+    return BeginNestedMessage<T>(2);
+  }
+
+
+  using FieldMetadata_StopRules =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TriggerRule,
+      ScenarioConfig>;
+
+  static constexpr FieldMetadata_StopRules kStopRules{};
+  template <typename T = TriggerRule> T* add_stop_rules() {
+    return BeginNestedMessage<T>(3);
+  }
+
+
+  using FieldMetadata_UploadRules =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TriggerRule,
+      ScenarioConfig>;
+
+  static constexpr FieldMetadata_UploadRules kUploadRules{};
+  template <typename T = TriggerRule> T* add_upload_rules() {
+    return BeginNestedMessage<T>(4);
+  }
+
+
+  using FieldMetadata_SetupRules =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TriggerRule,
+      ScenarioConfig>;
+
+  static constexpr FieldMetadata_SetupRules kSetupRules{};
+  template <typename T = TriggerRule> T* add_setup_rules() {
+    return BeginNestedMessage<T>(5);
+  }
+
+
+  using FieldMetadata_TraceConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TraceConfig,
+      ScenarioConfig>;
+
+  static constexpr FieldMetadata_TraceConfig kTraceConfig{};
+  template <typename T = TraceConfig> T* set_trace_config() {
+    return BeginNestedMessage<T>(6);
+  }
+
+
+  using FieldMetadata_NestedScenarios =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      NestedScenarioConfig,
+      ScenarioConfig>;
+
+  static constexpr FieldMetadata_NestedScenarios kNestedScenarios{};
+  template <typename T = NestedScenarioConfig> T* add_nested_scenarios() {
+    return BeginNestedMessage<T>(7);
+  }
+
+
+  using FieldMetadata_UseSystemBackend =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ScenarioConfig>;
+
+  static constexpr FieldMetadata_UseSystemBackend kUseSystemBackend{};
+  void set_use_system_backend(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_UseSystemBackend::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class NestedScenarioConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  NestedScenarioConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit NestedScenarioConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit NestedScenarioConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_scenario_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars scenario_name() const { return at<1>().as_string(); }
+  bool has_start_rules() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> start_rules() const { return GetRepeated<::protozero::ConstBytes>(2); }
+  bool has_stop_rules() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> stop_rules() const { return GetRepeated<::protozero::ConstBytes>(3); }
+  bool has_upload_rules() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> upload_rules() const { return GetRepeated<::protozero::ConstBytes>(4); }
+};
+
+class NestedScenarioConfig : public ::protozero::Message {
+ public:
+  using Decoder = NestedScenarioConfig_Decoder;
+  enum : int32_t {
+    kScenarioNameFieldNumber = 1,
+    kStartRulesFieldNumber = 2,
+    kStopRulesFieldNumber = 3,
+    kUploadRulesFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.NestedScenarioConfig"; }
+
+
+  using FieldMetadata_ScenarioName =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      NestedScenarioConfig>;
+
+  static constexpr FieldMetadata_ScenarioName kScenarioName{};
+  void set_scenario_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ScenarioName::kFieldId, data, size);
+  }
+  void set_scenario_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ScenarioName::kFieldId, chars.data, chars.size);
+  }
+  void set_scenario_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ScenarioName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StartRules =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TriggerRule,
+      NestedScenarioConfig>;
+
+  static constexpr FieldMetadata_StartRules kStartRules{};
+  template <typename T = TriggerRule> T* add_start_rules() {
+    return BeginNestedMessage<T>(2);
+  }
+
+
+  using FieldMetadata_StopRules =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TriggerRule,
+      NestedScenarioConfig>;
+
+  static constexpr FieldMetadata_StopRules kStopRules{};
+  template <typename T = TriggerRule> T* add_stop_rules() {
+    return BeginNestedMessage<T>(3);
+  }
+
+
+  using FieldMetadata_UploadRules =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TriggerRule,
+      NestedScenarioConfig>;
+
+  static constexpr FieldMetadata_UploadRules kUploadRules{};
+  template <typename T = TriggerRule> T* add_upload_rules() {
+    return BeginNestedMessage<T>(4);
+  }
+
+};
+
+class TriggerRule_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
+ public:
+  TriggerRule_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TriggerRule_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TriggerRule_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_trigger_chance() const { return at<2>().valid(); }
+  float trigger_chance() const { return at<2>().as_float(); }
+  bool has_delay_ms() const { return at<3>().valid(); }
+  uint64_t delay_ms() const { return at<3>().as_uint64(); }
+  bool has_activation_delay_ms() const { return at<8>().valid(); }
+  uint64_t activation_delay_ms() const { return at<8>().as_uint64(); }
+  bool has_manual_trigger_name() const { return at<4>().valid(); }
+  ::protozero::ConstChars manual_trigger_name() const { return at<4>().as_string(); }
+  bool has_histogram() const { return at<5>().valid(); }
+  ::protozero::ConstBytes histogram() const { return at<5>().as_bytes(); }
+  bool has_repeating_interval() const { return at<6>().valid(); }
+  ::protozero::ConstBytes repeating_interval() const { return at<6>().as_bytes(); }
+};
+
+class TriggerRule : public ::protozero::Message {
+ public:
+  using Decoder = TriggerRule_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kTriggerChanceFieldNumber = 2,
+    kDelayMsFieldNumber = 3,
+    kActivationDelayMsFieldNumber = 8,
+    kManualTriggerNameFieldNumber = 4,
+    kHistogramFieldNumber = 5,
+    kRepeatingIntervalFieldNumber = 6,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TriggerRule"; }
+
+  using HistogramTrigger = ::perfetto::protos::pbzero::TriggerRule_HistogramTrigger;
+  using RepeatingInterval = ::perfetto::protos::pbzero::TriggerRule_RepeatingInterval;
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TriggerRule>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TriggerChance =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      TriggerRule>;
+
+  static constexpr FieldMetadata_TriggerChance kTriggerChance{};
+  void set_trigger_chance(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_TriggerChance::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DelayMs =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TriggerRule>;
+
+  static constexpr FieldMetadata_DelayMs kDelayMs{};
+  void set_delay_ms(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DelayMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ActivationDelayMs =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TriggerRule>;
+
+  static constexpr FieldMetadata_ActivationDelayMs kActivationDelayMs{};
+  void set_activation_delay_ms(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ActivationDelayMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ManualTriggerName =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TriggerRule>;
+
+  static constexpr FieldMetadata_ManualTriggerName kManualTriggerName{};
+  void set_manual_trigger_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ManualTriggerName::kFieldId, data, size);
+  }
+  void set_manual_trigger_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ManualTriggerName::kFieldId, chars.data, chars.size);
+  }
+  void set_manual_trigger_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ManualTriggerName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Histogram =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TriggerRule_HistogramTrigger,
+      TriggerRule>;
+
+  static constexpr FieldMetadata_Histogram kHistogram{};
+  template <typename T = TriggerRule_HistogramTrigger> T* set_histogram() {
+    return BeginNestedMessage<T>(5);
+  }
+
+
+  using FieldMetadata_RepeatingInterval =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TriggerRule_RepeatingInterval,
+      TriggerRule>;
+
+  static constexpr FieldMetadata_RepeatingInterval kRepeatingInterval{};
+  template <typename T = TriggerRule_RepeatingInterval> T* set_repeating_interval() {
+    return BeginNestedMessage<T>(6);
+  }
+
+};
+
+class TriggerRule_RepeatingInterval_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  TriggerRule_RepeatingInterval_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TriggerRule_RepeatingInterval_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TriggerRule_RepeatingInterval_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_period_ms() const { return at<1>().valid(); }
+  uint64_t period_ms() const { return at<1>().as_uint64(); }
+  bool has_randomized() const { return at<2>().valid(); }
+  bool randomized() const { return at<2>().as_bool(); }
+};
+
+class TriggerRule_RepeatingInterval : public ::protozero::Message {
+ public:
+  using Decoder = TriggerRule_RepeatingInterval_Decoder;
+  enum : int32_t {
+    kPeriodMsFieldNumber = 1,
+    kRandomizedFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TriggerRule.RepeatingInterval"; }
+
+
+  using FieldMetadata_PeriodMs =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TriggerRule_RepeatingInterval>;
+
+  static constexpr FieldMetadata_PeriodMs kPeriodMs{};
+  void set_period_ms(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PeriodMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Randomized =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TriggerRule_RepeatingInterval>;
+
+  static constexpr FieldMetadata_Randomized kRandomized{};
+  void set_randomized(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_Randomized::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class TriggerRule_HistogramTrigger_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  TriggerRule_HistogramTrigger_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TriggerRule_HistogramTrigger_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TriggerRule_HistogramTrigger_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_histogram_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars histogram_name() const { return at<1>().as_string(); }
+  bool has_min_value() const { return at<2>().valid(); }
+  int64_t min_value() const { return at<2>().as_int64(); }
+  bool has_max_value() const { return at<3>().valid(); }
+  int64_t max_value() const { return at<3>().as_int64(); }
+};
+
+class TriggerRule_HistogramTrigger : public ::protozero::Message {
+ public:
+  using Decoder = TriggerRule_HistogramTrigger_Decoder;
+  enum : int32_t {
+    kHistogramNameFieldNumber = 1,
+    kMinValueFieldNumber = 2,
+    kMaxValueFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TriggerRule.HistogramTrigger"; }
+
+
+  using FieldMetadata_HistogramName =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TriggerRule_HistogramTrigger>;
+
+  static constexpr FieldMetadata_HistogramName kHistogramName{};
+  void set_histogram_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_HistogramName::kFieldId, data, size);
+  }
+  void set_histogram_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_HistogramName::kFieldId, chars.data, chars.size);
+  }
+  void set_histogram_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_HistogramName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MinValue =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      TriggerRule_HistogramTrigger>;
+
+  static constexpr FieldMetadata_MinValue kMinValue{};
+  void set_min_value(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MinValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MaxValue =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      TriggerRule_HistogramTrigger>;
+
+  static constexpr FieldMetadata_MaxValue kMaxValue{};
+  void set_max_value(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MaxValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/chrome/system_metrics.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_SYSTEM_METRICS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_SYSTEM_METRICS_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class ChromiumSystemMetricsConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  ChromiumSystemMetricsConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromiumSystemMetricsConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromiumSystemMetricsConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_sampling_interval_ms() const { return at<1>().valid(); }
+  uint32_t sampling_interval_ms() const { return at<1>().as_uint32(); }
+};
+
+class ChromiumSystemMetricsConfig : public ::protozero::Message {
+ public:
+  using Decoder = ChromiumSystemMetricsConfig_Decoder;
+  enum : int32_t {
+    kSamplingIntervalMsFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromiumSystemMetricsConfig"; }
+
+
+  using FieldMetadata_SamplingIntervalMs =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ChromiumSystemMetricsConfig>;
+
+  static constexpr FieldMetadata_SamplingIntervalMs kSamplingIntervalMs{};
+  void set_sampling_interval_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SamplingIntervalMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/chrome/v8_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_V8_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_V8_CONFIG_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class V8Config_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  V8Config_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit V8Config_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit V8Config_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_log_script_sources() const { return at<1>().valid(); }
+  bool log_script_sources() const { return at<1>().as_bool(); }
+  bool has_log_instructions() const { return at<2>().valid(); }
+  bool log_instructions() const { return at<2>().as_bool(); }
+};
+
+class V8Config : public ::protozero::Message {
+ public:
+  using Decoder = V8Config_Decoder;
+  enum : int32_t {
+    kLogScriptSourcesFieldNumber = 1,
+    kLogInstructionsFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.V8Config"; }
+
+
+  using FieldMetadata_LogScriptSources =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      V8Config>;
+
+  static constexpr FieldMetadata_LogScriptSources kLogScriptSources{};
+  void set_log_script_sources(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_LogScriptSources::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_LogInstructions =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      V8Config>;
+
+  static constexpr FieldMetadata_LogInstructions kLogInstructions{};
+  void set_log_instructions(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_LogInstructions::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/data_source_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_DATA_SOURCE_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_DATA_SOURCE_CONFIG_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class AndroidGameInterventionListConfig;
+class AndroidInputEventConfig;
+class AndroidLogConfig;
+class AndroidPolledStateConfig;
+class AndroidPowerConfig;
+class AndroidSdkSyspropGuardConfig;
+class AndroidSystemPropertyConfig;
+class AndroidUserListConfig;
+class AppWakelocksConfig;
+class ChromeConfig;
+class ChromiumHistogramSamplesConfig;
+class ChromiumSystemMetricsConfig;
+class CpuPerUidConfig;
+class EtwConfig;
+class FrozenFtraceConfig;
+class FtraceConfig;
+class GpuCounterConfig;
+class GpuRenderStagesConfig;
+class HeapprofdConfig;
+class InodeFileConfig;
+class InputMethodConfig;
+class InterceptorConfig;
+class JavaHprofConfig;
+class KernelWakelocksConfig;
+class NetworkPacketTraceConfig;
+class PackagesListConfig;
+class PerfEventConfig;
+class PixelModemConfig;
+class PriorityBoostConfig;
+class ProcessStatsConfig;
+class ProtoLogConfig;
+class ProtoVmConfig;
+class QnxConfig;
+class StatsdTracingConfig;
+class SurfaceFlingerLayersConfig;
+class SurfaceFlingerTransactionsConfig;
+class SysStatsConfig;
+class SystemInfoConfig;
+class TestConfig;
+class TrackEventConfig;
+class V8Config;
+class VulkanMemoryConfig;
+class WindowManagerConfig;
+namespace perfetto_pbzero_enum_DataSourceConfig {
+enum BufferExhaustedPolicy : int32_t;
+}  // namespace perfetto_pbzero_enum_DataSourceConfig
+using DataSourceConfig_BufferExhaustedPolicy = perfetto_pbzero_enum_DataSourceConfig::BufferExhaustedPolicy;
+namespace perfetto_pbzero_enum_DataSourceConfig {
+enum SessionInitiator : int32_t;
+}  // namespace perfetto_pbzero_enum_DataSourceConfig
+using DataSourceConfig_SessionInitiator = perfetto_pbzero_enum_DataSourceConfig::SessionInitiator;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_DataSourceConfig {
+enum SessionInitiator : int32_t {
+  SESSION_INITIATOR_UNSPECIFIED = 0,
+  SESSION_INITIATOR_TRUSTED_SYSTEM = 1,
+};
+} // namespace perfetto_pbzero_enum_DataSourceConfig
+using DataSourceConfig_SessionInitiator = perfetto_pbzero_enum_DataSourceConfig::SessionInitiator;
+
+
+constexpr DataSourceConfig_SessionInitiator DataSourceConfig_SessionInitiator_MIN = DataSourceConfig_SessionInitiator::SESSION_INITIATOR_UNSPECIFIED;
+constexpr DataSourceConfig_SessionInitiator DataSourceConfig_SessionInitiator_MAX = DataSourceConfig_SessionInitiator::SESSION_INITIATOR_TRUSTED_SYSTEM;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* DataSourceConfig_SessionInitiator_Name(::perfetto::protos::pbzero::DataSourceConfig_SessionInitiator value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::DataSourceConfig_SessionInitiator::SESSION_INITIATOR_UNSPECIFIED:
+    return "SESSION_INITIATOR_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::DataSourceConfig_SessionInitiator::SESSION_INITIATOR_TRUSTED_SYSTEM:
+    return "SESSION_INITIATOR_TRUSTED_SYSTEM";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_DataSourceConfig {
+enum BufferExhaustedPolicy : int32_t {
+  BUFFER_EXHAUSTED_UNSPECIFIED = 0,
+  BUFFER_EXHAUSTED_DROP = 1,
+  BUFFER_EXHAUSTED_STALL_THEN_ABORT = 2,
+  BUFFER_EXHAUSTED_STALL_THEN_DROP = 3,
+};
+} // namespace perfetto_pbzero_enum_DataSourceConfig
+using DataSourceConfig_BufferExhaustedPolicy = perfetto_pbzero_enum_DataSourceConfig::BufferExhaustedPolicy;
+
+
+constexpr DataSourceConfig_BufferExhaustedPolicy DataSourceConfig_BufferExhaustedPolicy_MIN = DataSourceConfig_BufferExhaustedPolicy::BUFFER_EXHAUSTED_UNSPECIFIED;
+constexpr DataSourceConfig_BufferExhaustedPolicy DataSourceConfig_BufferExhaustedPolicy_MAX = DataSourceConfig_BufferExhaustedPolicy::BUFFER_EXHAUSTED_STALL_THEN_DROP;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* DataSourceConfig_BufferExhaustedPolicy_Name(::perfetto::protos::pbzero::DataSourceConfig_BufferExhaustedPolicy value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::DataSourceConfig_BufferExhaustedPolicy::BUFFER_EXHAUSTED_UNSPECIFIED:
+    return "BUFFER_EXHAUSTED_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::DataSourceConfig_BufferExhaustedPolicy::BUFFER_EXHAUSTED_DROP:
+    return "BUFFER_EXHAUSTED_DROP";
+
+  case ::perfetto::protos::pbzero::DataSourceConfig_BufferExhaustedPolicy::BUFFER_EXHAUSTED_STALL_THEN_ABORT:
+    return "BUFFER_EXHAUSTED_STALL_THEN_ABORT";
+
+  case ::perfetto::protos::pbzero::DataSourceConfig_BufferExhaustedPolicy::BUFFER_EXHAUSTED_STALL_THEN_DROP:
+    return "BUFFER_EXHAUSTED_STALL_THEN_DROP";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class DataSourceConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/150> {
+ public:
+  DataSourceConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DataSourceConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DataSourceConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_target_buffer() const { return at<2>().valid(); }
+  uint32_t target_buffer() const { return at<2>().as_uint32(); }
+  bool has_target_buffer_name() const { return at<11>().valid(); }
+  ::protozero::ConstChars target_buffer_name() const { return at<11>().as_string(); }
+  bool has_trace_duration_ms() const { return at<3>().valid(); }
+  uint32_t trace_duration_ms() const { return at<3>().as_uint32(); }
+  bool has_prefer_suspend_clock_for_duration() const { return at<122>().valid(); }
+  bool prefer_suspend_clock_for_duration() const { return at<122>().as_bool(); }
+  bool has_stop_timeout_ms() const { return at<7>().valid(); }
+  uint32_t stop_timeout_ms() const { return at<7>().as_uint32(); }
+  bool has_enable_extra_guardrails() const { return at<6>().valid(); }
+  bool enable_extra_guardrails() const { return at<6>().as_bool(); }
+  bool has_session_initiator() const { return at<8>().valid(); }
+  int32_t session_initiator() const { return at<8>().as_int32(); }
+  bool has_tracing_session_id() const { return at<4>().valid(); }
+  uint64_t tracing_session_id() const { return at<4>().as_uint64(); }
+  bool has_buffer_exhausted_policy() const { return at<9>().valid(); }
+  int32_t buffer_exhausted_policy() const { return at<9>().as_int32(); }
+  bool has_priority_boost() const { return at<10>().valid(); }
+  ::protozero::ConstBytes priority_boost() const { return at<10>().as_bytes(); }
+  bool has_protovm_config() const { return at<12>().valid(); }
+  ::protozero::ConstBytes protovm_config() const { return at<12>().as_bytes(); }
+  bool has_ftrace_config() const { return at<100>().valid(); }
+  ::protozero::ConstBytes ftrace_config() const { return at<100>().as_bytes(); }
+  bool has_inode_file_config() const { return at<102>().valid(); }
+  ::protozero::ConstBytes inode_file_config() const { return at<102>().as_bytes(); }
+  bool has_process_stats_config() const { return at<103>().valid(); }
+  ::protozero::ConstBytes process_stats_config() const { return at<103>().as_bytes(); }
+  bool has_sys_stats_config() const { return at<104>().valid(); }
+  ::protozero::ConstBytes sys_stats_config() const { return at<104>().as_bytes(); }
+  bool has_heapprofd_config() const { return at<105>().valid(); }
+  ::protozero::ConstBytes heapprofd_config() const { return at<105>().as_bytes(); }
+  bool has_java_hprof_config() const { return at<110>().valid(); }
+  ::protozero::ConstBytes java_hprof_config() const { return at<110>().as_bytes(); }
+  bool has_android_power_config() const { return at<106>().valid(); }
+  ::protozero::ConstBytes android_power_config() const { return at<106>().as_bytes(); }
+  bool has_android_log_config() const { return at<107>().valid(); }
+  ::protozero::ConstBytes android_log_config() const { return at<107>().as_bytes(); }
+  bool has_gpu_counter_config() const { return at<108>().valid(); }
+  ::protozero::ConstBytes gpu_counter_config() const { return at<108>().as_bytes(); }
+  bool has_android_game_intervention_list_config() const { return at<116>().valid(); }
+  ::protozero::ConstBytes android_game_intervention_list_config() const { return at<116>().as_bytes(); }
+  bool has_packages_list_config() const { return at<109>().valid(); }
+  ::protozero::ConstBytes packages_list_config() const { return at<109>().as_bytes(); }
+  bool has_perf_event_config() const { return at<111>().valid(); }
+  ::protozero::ConstBytes perf_event_config() const { return at<111>().as_bytes(); }
+  bool has_vulkan_memory_config() const { return at<112>().valid(); }
+  ::protozero::ConstBytes vulkan_memory_config() const { return at<112>().as_bytes(); }
+  bool has_track_event_config() const { return at<113>().valid(); }
+  ::protozero::ConstBytes track_event_config() const { return at<113>().as_bytes(); }
+  bool has_android_polled_state_config() const { return at<114>().valid(); }
+  ::protozero::ConstBytes android_polled_state_config() const { return at<114>().as_bytes(); }
+  bool has_android_system_property_config() const { return at<118>().valid(); }
+  ::protozero::ConstBytes android_system_property_config() const { return at<118>().as_bytes(); }
+  bool has_statsd_tracing_config() const { return at<117>().valid(); }
+  ::protozero::ConstBytes statsd_tracing_config() const { return at<117>().as_bytes(); }
+  bool has_system_info_config() const { return at<119>().valid(); }
+  ::protozero::ConstBytes system_info_config() const { return at<119>().as_bytes(); }
+  bool has_frozen_ftrace_config() const { return at<136>().valid(); }
+  ::protozero::ConstBytes frozen_ftrace_config() const { return at<136>().as_bytes(); }
+  bool has_chrome_config() const { return at<101>().valid(); }
+  ::protozero::ConstBytes chrome_config() const { return at<101>().as_bytes(); }
+  bool has_v8_config() const { return at<127>().valid(); }
+  ::protozero::ConstBytes v8_config() const { return at<127>().as_bytes(); }
+  bool has_interceptor_config() const { return at<115>().valid(); }
+  ::protozero::ConstBytes interceptor_config() const { return at<115>().as_bytes(); }
+  bool has_network_packet_trace_config() const { return at<120>().valid(); }
+  ::protozero::ConstBytes network_packet_trace_config() const { return at<120>().as_bytes(); }
+  bool has_surfaceflinger_layers_config() const { return at<121>().valid(); }
+  ::protozero::ConstBytes surfaceflinger_layers_config() const { return at<121>().as_bytes(); }
+  bool has_surfaceflinger_transactions_config() const { return at<123>().valid(); }
+  ::protozero::ConstBytes surfaceflinger_transactions_config() const { return at<123>().as_bytes(); }
+  bool has_android_sdk_sysprop_guard_config() const { return at<124>().valid(); }
+  ::protozero::ConstBytes android_sdk_sysprop_guard_config() const { return at<124>().as_bytes(); }
+  bool has_etw_config() const { return at<125>().valid(); }
+  ::protozero::ConstBytes etw_config() const { return at<125>().as_bytes(); }
+  bool has_protolog_config() const { return at<126>().valid(); }
+  ::protozero::ConstBytes protolog_config() const { return at<126>().as_bytes(); }
+  bool has_android_input_event_config() const { return at<128>().valid(); }
+  ::protozero::ConstBytes android_input_event_config() const { return at<128>().as_bytes(); }
+  bool has_pixel_modem_config() const { return at<129>().valid(); }
+  ::protozero::ConstBytes pixel_modem_config() const { return at<129>().as_bytes(); }
+  bool has_windowmanager_config() const { return at<130>().valid(); }
+  ::protozero::ConstBytes windowmanager_config() const { return at<130>().as_bytes(); }
+  bool has_chromium_system_metrics() const { return at<131>().valid(); }
+  ::protozero::ConstBytes chromium_system_metrics() const { return at<131>().as_bytes(); }
+  bool has_kernel_wakelocks_config() const { return at<132>().valid(); }
+  ::protozero::ConstBytes kernel_wakelocks_config() const { return at<132>().as_bytes(); }
+  bool has_gpu_renderstages_config() const { return at<133>().valid(); }
+  ::protozero::ConstBytes gpu_renderstages_config() const { return at<133>().as_bytes(); }
+  bool has_chromium_histogram_samples() const { return at<134>().valid(); }
+  ::protozero::ConstBytes chromium_histogram_samples() const { return at<134>().as_bytes(); }
+  bool has_app_wakelocks_config() const { return at<135>().valid(); }
+  ::protozero::ConstBytes app_wakelocks_config() const { return at<135>().as_bytes(); }
+  bool has_cpu_per_uid_config() const { return at<137>().valid(); }
+  ::protozero::ConstBytes cpu_per_uid_config() const { return at<137>().as_bytes(); }
+  bool has_user_list_config() const { return at<138>().valid(); }
+  ::protozero::ConstBytes user_list_config() const { return at<138>().as_bytes(); }
+  bool has_inputmethod_config() const { return at<139>().valid(); }
+  ::protozero::ConstBytes inputmethod_config() const { return at<139>().as_bytes(); }
+  bool has_qnx_config() const { return at<150>().valid(); }
+  ::protozero::ConstBytes qnx_config() const { return at<150>().as_bytes(); }
+  // field legacy_config omitted because its id is too high
+  // field for_testing omitted because its id is too high
+};
+
+class DataSourceConfig : public ::protozero::Message {
+ public:
+  using Decoder = DataSourceConfig_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kTargetBufferFieldNumber = 2,
+    kTargetBufferNameFieldNumber = 11,
+    kTraceDurationMsFieldNumber = 3,
+    kPreferSuspendClockForDurationFieldNumber = 122,
+    kStopTimeoutMsFieldNumber = 7,
+    kEnableExtraGuardrailsFieldNumber = 6,
+    kSessionInitiatorFieldNumber = 8,
+    kTracingSessionIdFieldNumber = 4,
+    kBufferExhaustedPolicyFieldNumber = 9,
+    kPriorityBoostFieldNumber = 10,
+    kProtovmConfigFieldNumber = 12,
+    kFtraceConfigFieldNumber = 100,
+    kInodeFileConfigFieldNumber = 102,
+    kProcessStatsConfigFieldNumber = 103,
+    kSysStatsConfigFieldNumber = 104,
+    kHeapprofdConfigFieldNumber = 105,
+    kJavaHprofConfigFieldNumber = 110,
+    kAndroidPowerConfigFieldNumber = 106,
+    kAndroidLogConfigFieldNumber = 107,
+    kGpuCounterConfigFieldNumber = 108,
+    kAndroidGameInterventionListConfigFieldNumber = 116,
+    kPackagesListConfigFieldNumber = 109,
+    kPerfEventConfigFieldNumber = 111,
+    kVulkanMemoryConfigFieldNumber = 112,
+    kTrackEventConfigFieldNumber = 113,
+    kAndroidPolledStateConfigFieldNumber = 114,
+    kAndroidSystemPropertyConfigFieldNumber = 118,
+    kStatsdTracingConfigFieldNumber = 117,
+    kSystemInfoConfigFieldNumber = 119,
+    kFrozenFtraceConfigFieldNumber = 136,
+    kChromeConfigFieldNumber = 101,
+    kV8ConfigFieldNumber = 127,
+    kInterceptorConfigFieldNumber = 115,
+    kNetworkPacketTraceConfigFieldNumber = 120,
+    kSurfaceflingerLayersConfigFieldNumber = 121,
+    kSurfaceflingerTransactionsConfigFieldNumber = 123,
+    kAndroidSdkSyspropGuardConfigFieldNumber = 124,
+    kEtwConfigFieldNumber = 125,
+    kProtologConfigFieldNumber = 126,
+    kAndroidInputEventConfigFieldNumber = 128,
+    kPixelModemConfigFieldNumber = 129,
+    kWindowmanagerConfigFieldNumber = 130,
+    kChromiumSystemMetricsFieldNumber = 131,
+    kKernelWakelocksConfigFieldNumber = 132,
+    kGpuRenderstagesConfigFieldNumber = 133,
+    kChromiumHistogramSamplesFieldNumber = 134,
+    kAppWakelocksConfigFieldNumber = 135,
+    kCpuPerUidConfigFieldNumber = 137,
+    kUserListConfigFieldNumber = 138,
+    kInputmethodConfigFieldNumber = 139,
+    kQnxConfigFieldNumber = 150,
+    kLegacyConfigFieldNumber = 1000,
+    kForTestingFieldNumber = 1001,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.DataSourceConfig"; }
+
+
+  using SessionInitiator = ::perfetto::protos::pbzero::DataSourceConfig_SessionInitiator;
+  static inline const char* SessionInitiator_Name(SessionInitiator value) {
+    return ::perfetto::protos::pbzero::DataSourceConfig_SessionInitiator_Name(value);
+  }
+
+  using BufferExhaustedPolicy = ::perfetto::protos::pbzero::DataSourceConfig_BufferExhaustedPolicy;
+  static inline const char* BufferExhaustedPolicy_Name(BufferExhaustedPolicy value) {
+    return ::perfetto::protos::pbzero::DataSourceConfig_BufferExhaustedPolicy_Name(value);
+  }
+  static inline const SessionInitiator SESSION_INITIATOR_UNSPECIFIED = SessionInitiator::SESSION_INITIATOR_UNSPECIFIED;
+  static inline const SessionInitiator SESSION_INITIATOR_TRUSTED_SYSTEM = SessionInitiator::SESSION_INITIATOR_TRUSTED_SYSTEM;
+  static inline const BufferExhaustedPolicy BUFFER_EXHAUSTED_UNSPECIFIED = BufferExhaustedPolicy::BUFFER_EXHAUSTED_UNSPECIFIED;
+  static inline const BufferExhaustedPolicy BUFFER_EXHAUSTED_DROP = BufferExhaustedPolicy::BUFFER_EXHAUSTED_DROP;
+  static inline const BufferExhaustedPolicy BUFFER_EXHAUSTED_STALL_THEN_ABORT = BufferExhaustedPolicy::BUFFER_EXHAUSTED_STALL_THEN_ABORT;
+  static inline const BufferExhaustedPolicy BUFFER_EXHAUSTED_STALL_THEN_DROP = BufferExhaustedPolicy::BUFFER_EXHAUSTED_STALL_THEN_DROP;
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TargetBuffer =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_TargetBuffer kTargetBuffer{};
+  void set_target_buffer(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TargetBuffer::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TargetBufferName =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_TargetBufferName kTargetBufferName{};
+  void set_target_buffer_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_TargetBufferName::kFieldId, data, size);
+  }
+  void set_target_buffer_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_TargetBufferName::kFieldId, chars.data, chars.size);
+  }
+  void set_target_buffer_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_TargetBufferName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TraceDurationMs =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_TraceDurationMs kTraceDurationMs{};
+  void set_trace_duration_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TraceDurationMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PreferSuspendClockForDuration =
+    ::protozero::proto_utils::FieldMetadata<
+      122,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_PreferSuspendClockForDuration kPreferSuspendClockForDuration{};
+  void set_prefer_suspend_clock_for_duration(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_PreferSuspendClockForDuration::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StopTimeoutMs =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_StopTimeoutMs kStopTimeoutMs{};
+  void set_stop_timeout_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StopTimeoutMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_EnableExtraGuardrails =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_EnableExtraGuardrails kEnableExtraGuardrails{};
+  void set_enable_extra_guardrails(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_EnableExtraGuardrails::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SessionInitiator =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      DataSourceConfig_SessionInitiator,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_SessionInitiator kSessionInitiator{};
+  void set_session_initiator(DataSourceConfig_SessionInitiator value) {
+    static constexpr uint32_t field_id = FieldMetadata_SessionInitiator::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TracingSessionId =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_TracingSessionId kTracingSessionId{};
+  void set_tracing_session_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TracingSessionId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BufferExhaustedPolicy =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      DataSourceConfig_BufferExhaustedPolicy,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_BufferExhaustedPolicy kBufferExhaustedPolicy{};
+  void set_buffer_exhausted_policy(DataSourceConfig_BufferExhaustedPolicy value) {
+    static constexpr uint32_t field_id = FieldMetadata_BufferExhaustedPolicy::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PriorityBoost =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PriorityBoostConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_PriorityBoost kPriorityBoost{};
+  template <typename T = PriorityBoostConfig> T* set_priority_boost() {
+    return BeginNestedMessage<T>(10);
+  }
+
+
+  using FieldMetadata_ProtovmConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ProtoVmConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_ProtovmConfig kProtovmConfig{};
+  template <typename T = ProtoVmConfig> T* set_protovm_config() {
+    return BeginNestedMessage<T>(12);
+  }
+
+
+  using FieldMetadata_FtraceConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      100,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FtraceConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_FtraceConfig kFtraceConfig{};
+  template <typename T = FtraceConfig> T* set_ftrace_config() {
+    return BeginNestedMessage<T>(100);
+  }
+
+  void set_ftrace_config_raw(const std::string& raw) {
+    return AppendBytes(100, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_InodeFileConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      102,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      InodeFileConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_InodeFileConfig kInodeFileConfig{};
+  template <typename T = InodeFileConfig> T* set_inode_file_config() {
+    return BeginNestedMessage<T>(102);
+  }
+
+  void set_inode_file_config_raw(const std::string& raw) {
+    return AppendBytes(102, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_ProcessStatsConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      103,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ProcessStatsConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_ProcessStatsConfig kProcessStatsConfig{};
+  template <typename T = ProcessStatsConfig> T* set_process_stats_config() {
+    return BeginNestedMessage<T>(103);
+  }
+
+  void set_process_stats_config_raw(const std::string& raw) {
+    return AppendBytes(103, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_SysStatsConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      104,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SysStatsConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_SysStatsConfig kSysStatsConfig{};
+  template <typename T = SysStatsConfig> T* set_sys_stats_config() {
+    return BeginNestedMessage<T>(104);
+  }
+
+  void set_sys_stats_config_raw(const std::string& raw) {
+    return AppendBytes(104, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_HeapprofdConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      105,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HeapprofdConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_HeapprofdConfig kHeapprofdConfig{};
+  template <typename T = HeapprofdConfig> T* set_heapprofd_config() {
+    return BeginNestedMessage<T>(105);
+  }
+
+  void set_heapprofd_config_raw(const std::string& raw) {
+    return AppendBytes(105, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_JavaHprofConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      110,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      JavaHprofConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_JavaHprofConfig kJavaHprofConfig{};
+  template <typename T = JavaHprofConfig> T* set_java_hprof_config() {
+    return BeginNestedMessage<T>(110);
+  }
+
+  void set_java_hprof_config_raw(const std::string& raw) {
+    return AppendBytes(110, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_AndroidPowerConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      106,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AndroidPowerConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_AndroidPowerConfig kAndroidPowerConfig{};
+  template <typename T = AndroidPowerConfig> T* set_android_power_config() {
+    return BeginNestedMessage<T>(106);
+  }
+
+  void set_android_power_config_raw(const std::string& raw) {
+    return AppendBytes(106, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_AndroidLogConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      107,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AndroidLogConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_AndroidLogConfig kAndroidLogConfig{};
+  template <typename T = AndroidLogConfig> T* set_android_log_config() {
+    return BeginNestedMessage<T>(107);
+  }
+
+  void set_android_log_config_raw(const std::string& raw) {
+    return AppendBytes(107, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_GpuCounterConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      108,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      GpuCounterConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_GpuCounterConfig kGpuCounterConfig{};
+  template <typename T = GpuCounterConfig> T* set_gpu_counter_config() {
+    return BeginNestedMessage<T>(108);
+  }
+
+  void set_gpu_counter_config_raw(const std::string& raw) {
+    return AppendBytes(108, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_AndroidGameInterventionListConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      116,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AndroidGameInterventionListConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_AndroidGameInterventionListConfig kAndroidGameInterventionListConfig{};
+  template <typename T = AndroidGameInterventionListConfig> T* set_android_game_intervention_list_config() {
+    return BeginNestedMessage<T>(116);
+  }
+
+  void set_android_game_intervention_list_config_raw(const std::string& raw) {
+    return AppendBytes(116, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_PackagesListConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      109,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PackagesListConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_PackagesListConfig kPackagesListConfig{};
+  template <typename T = PackagesListConfig> T* set_packages_list_config() {
+    return BeginNestedMessage<T>(109);
+  }
+
+  void set_packages_list_config_raw(const std::string& raw) {
+    return AppendBytes(109, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_PerfEventConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      111,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PerfEventConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_PerfEventConfig kPerfEventConfig{};
+  template <typename T = PerfEventConfig> T* set_perf_event_config() {
+    return BeginNestedMessage<T>(111);
+  }
+
+  void set_perf_event_config_raw(const std::string& raw) {
+    return AppendBytes(111, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_VulkanMemoryConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      112,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      VulkanMemoryConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_VulkanMemoryConfig kVulkanMemoryConfig{};
+  template <typename T = VulkanMemoryConfig> T* set_vulkan_memory_config() {
+    return BeginNestedMessage<T>(112);
+  }
+
+  void set_vulkan_memory_config_raw(const std::string& raw) {
+    return AppendBytes(112, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_TrackEventConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      113,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TrackEventConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_TrackEventConfig kTrackEventConfig{};
+  template <typename T = TrackEventConfig> T* set_track_event_config() {
+    return BeginNestedMessage<T>(113);
+  }
+
+  void set_track_event_config_raw(const std::string& raw) {
+    return AppendBytes(113, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_AndroidPolledStateConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      114,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AndroidPolledStateConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_AndroidPolledStateConfig kAndroidPolledStateConfig{};
+  template <typename T = AndroidPolledStateConfig> T* set_android_polled_state_config() {
+    return BeginNestedMessage<T>(114);
+  }
+
+  void set_android_polled_state_config_raw(const std::string& raw) {
+    return AppendBytes(114, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_AndroidSystemPropertyConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      118,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AndroidSystemPropertyConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_AndroidSystemPropertyConfig kAndroidSystemPropertyConfig{};
+  template <typename T = AndroidSystemPropertyConfig> T* set_android_system_property_config() {
+    return BeginNestedMessage<T>(118);
+  }
+
+  void set_android_system_property_config_raw(const std::string& raw) {
+    return AppendBytes(118, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_StatsdTracingConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      117,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      StatsdTracingConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_StatsdTracingConfig kStatsdTracingConfig{};
+  template <typename T = StatsdTracingConfig> T* set_statsd_tracing_config() {
+    return BeginNestedMessage<T>(117);
+  }
+
+  void set_statsd_tracing_config_raw(const std::string& raw) {
+    return AppendBytes(117, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_SystemInfoConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      119,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SystemInfoConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_SystemInfoConfig kSystemInfoConfig{};
+  template <typename T = SystemInfoConfig> T* set_system_info_config() {
+    return BeginNestedMessage<T>(119);
+  }
+
+
+  using FieldMetadata_FrozenFtraceConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      136,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FrozenFtraceConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_FrozenFtraceConfig kFrozenFtraceConfig{};
+  template <typename T = FrozenFtraceConfig> T* set_frozen_ftrace_config() {
+    return BeginNestedMessage<T>(136);
+  }
+
+  void set_frozen_ftrace_config_raw(const std::string& raw) {
+    return AppendBytes(136, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_ChromeConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      101,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromeConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_ChromeConfig kChromeConfig{};
+  template <typename T = ChromeConfig> T* set_chrome_config() {
+    return BeginNestedMessage<T>(101);
+  }
+
+
+  using FieldMetadata_V8Config =
+    ::protozero::proto_utils::FieldMetadata<
+      127,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      V8Config,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_V8Config kV8Config{};
+  template <typename T = V8Config> T* set_v8_config() {
+    return BeginNestedMessage<T>(127);
+  }
+
+  void set_v8_config_raw(const std::string& raw) {
+    return AppendBytes(127, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_InterceptorConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      115,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      InterceptorConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_InterceptorConfig kInterceptorConfig{};
+  template <typename T = InterceptorConfig> T* set_interceptor_config() {
+    return BeginNestedMessage<T>(115);
+  }
+
+
+  using FieldMetadata_NetworkPacketTraceConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      120,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      NetworkPacketTraceConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_NetworkPacketTraceConfig kNetworkPacketTraceConfig{};
+  template <typename T = NetworkPacketTraceConfig> T* set_network_packet_trace_config() {
+    return BeginNestedMessage<T>(120);
+  }
+
+  void set_network_packet_trace_config_raw(const std::string& raw) {
+    return AppendBytes(120, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_SurfaceflingerLayersConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      121,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SurfaceFlingerLayersConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_SurfaceflingerLayersConfig kSurfaceflingerLayersConfig{};
+  template <typename T = SurfaceFlingerLayersConfig> T* set_surfaceflinger_layers_config() {
+    return BeginNestedMessage<T>(121);
+  }
+
+  void set_surfaceflinger_layers_config_raw(const std::string& raw) {
+    return AppendBytes(121, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_SurfaceflingerTransactionsConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      123,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SurfaceFlingerTransactionsConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_SurfaceflingerTransactionsConfig kSurfaceflingerTransactionsConfig{};
+  template <typename T = SurfaceFlingerTransactionsConfig> T* set_surfaceflinger_transactions_config() {
+    return BeginNestedMessage<T>(123);
+  }
+
+  void set_surfaceflinger_transactions_config_raw(const std::string& raw) {
+    return AppendBytes(123, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_AndroidSdkSyspropGuardConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      124,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AndroidSdkSyspropGuardConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_AndroidSdkSyspropGuardConfig kAndroidSdkSyspropGuardConfig{};
+  template <typename T = AndroidSdkSyspropGuardConfig> T* set_android_sdk_sysprop_guard_config() {
+    return BeginNestedMessage<T>(124);
+  }
+
+  void set_android_sdk_sysprop_guard_config_raw(const std::string& raw) {
+    return AppendBytes(124, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_EtwConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      125,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      EtwConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_EtwConfig kEtwConfig{};
+  template <typename T = EtwConfig> T* set_etw_config() {
+    return BeginNestedMessage<T>(125);
+  }
+
+  void set_etw_config_raw(const std::string& raw) {
+    return AppendBytes(125, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_ProtologConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      126,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ProtoLogConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_ProtologConfig kProtologConfig{};
+  template <typename T = ProtoLogConfig> T* set_protolog_config() {
+    return BeginNestedMessage<T>(126);
+  }
+
+  void set_protolog_config_raw(const std::string& raw) {
+    return AppendBytes(126, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_AndroidInputEventConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      128,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AndroidInputEventConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_AndroidInputEventConfig kAndroidInputEventConfig{};
+  template <typename T = AndroidInputEventConfig> T* set_android_input_event_config() {
+    return BeginNestedMessage<T>(128);
+  }
+
+  void set_android_input_event_config_raw(const std::string& raw) {
+    return AppendBytes(128, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_PixelModemConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      129,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PixelModemConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_PixelModemConfig kPixelModemConfig{};
+  template <typename T = PixelModemConfig> T* set_pixel_modem_config() {
+    return BeginNestedMessage<T>(129);
+  }
+
+  void set_pixel_modem_config_raw(const std::string& raw) {
+    return AppendBytes(129, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_WindowmanagerConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      130,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      WindowManagerConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_WindowmanagerConfig kWindowmanagerConfig{};
+  template <typename T = WindowManagerConfig> T* set_windowmanager_config() {
+    return BeginNestedMessage<T>(130);
+  }
+
+  void set_windowmanager_config_raw(const std::string& raw) {
+    return AppendBytes(130, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_ChromiumSystemMetrics =
+    ::protozero::proto_utils::FieldMetadata<
+      131,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromiumSystemMetricsConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_ChromiumSystemMetrics kChromiumSystemMetrics{};
+  template <typename T = ChromiumSystemMetricsConfig> T* set_chromium_system_metrics() {
+    return BeginNestedMessage<T>(131);
+  }
+
+  void set_chromium_system_metrics_raw(const std::string& raw) {
+    return AppendBytes(131, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_KernelWakelocksConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      132,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      KernelWakelocksConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_KernelWakelocksConfig kKernelWakelocksConfig{};
+  template <typename T = KernelWakelocksConfig> T* set_kernel_wakelocks_config() {
+    return BeginNestedMessage<T>(132);
+  }
+
+  void set_kernel_wakelocks_config_raw(const std::string& raw) {
+    return AppendBytes(132, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_GpuRenderstagesConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      133,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      GpuRenderStagesConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_GpuRenderstagesConfig kGpuRenderstagesConfig{};
+  template <typename T = GpuRenderStagesConfig> T* set_gpu_renderstages_config() {
+    return BeginNestedMessage<T>(133);
+  }
+
+  void set_gpu_renderstages_config_raw(const std::string& raw) {
+    return AppendBytes(133, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_ChromiumHistogramSamples =
+    ::protozero::proto_utils::FieldMetadata<
+      134,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromiumHistogramSamplesConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_ChromiumHistogramSamples kChromiumHistogramSamples{};
+  template <typename T = ChromiumHistogramSamplesConfig> T* set_chromium_histogram_samples() {
+    return BeginNestedMessage<T>(134);
+  }
+
+  void set_chromium_histogram_samples_raw(const std::string& raw) {
+    return AppendBytes(134, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_AppWakelocksConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      135,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AppWakelocksConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_AppWakelocksConfig kAppWakelocksConfig{};
+  template <typename T = AppWakelocksConfig> T* set_app_wakelocks_config() {
+    return BeginNestedMessage<T>(135);
+  }
+
+  void set_app_wakelocks_config_raw(const std::string& raw) {
+    return AppendBytes(135, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_CpuPerUidConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      137,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      CpuPerUidConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_CpuPerUidConfig kCpuPerUidConfig{};
+  template <typename T = CpuPerUidConfig> T* set_cpu_per_uid_config() {
+    return BeginNestedMessage<T>(137);
+  }
+
+  void set_cpu_per_uid_config_raw(const std::string& raw) {
+    return AppendBytes(137, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_UserListConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      138,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AndroidUserListConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_UserListConfig kUserListConfig{};
+  template <typename T = AndroidUserListConfig> T* set_user_list_config() {
+    return BeginNestedMessage<T>(138);
+  }
+
+  void set_user_list_config_raw(const std::string& raw) {
+    return AppendBytes(138, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_InputmethodConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      139,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      InputMethodConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_InputmethodConfig kInputmethodConfig{};
+  template <typename T = InputMethodConfig> T* set_inputmethod_config() {
+    return BeginNestedMessage<T>(139);
+  }
+
+  void set_inputmethod_config_raw(const std::string& raw) {
+    return AppendBytes(139, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_QnxConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      150,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      QnxConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_QnxConfig kQnxConfig{};
+  template <typename T = QnxConfig> T* set_qnx_config() {
+    return BeginNestedMessage<T>(150);
+  }
+
+  void set_qnx_config_raw(const std::string& raw) {
+    return AppendBytes(150, raw.data(), raw.size());
+  }
+
+
+  using FieldMetadata_LegacyConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      1000,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_LegacyConfig kLegacyConfig{};
+  void set_legacy_config(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_LegacyConfig::kFieldId, data, size);
+  }
+  void set_legacy_config(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_LegacyConfig::kFieldId, chars.data, chars.size);
+  }
+  void set_legacy_config(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_LegacyConfig::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ForTesting =
+    ::protozero::proto_utils::FieldMetadata<
+      1001,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TestConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_ForTesting kForTesting{};
+  template <typename T = TestConfig> T* set_for_testing() {
+    return BeginNestedMessage<T>(1001);
+  }
+
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/etw/etw_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ETW_ETW_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ETW_ETW_CONFIG_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+namespace perfetto_pbzero_enum_EtwConfig {
+enum KernelFlag : int32_t;
+}  // namespace perfetto_pbzero_enum_EtwConfig
+using EtwConfig_KernelFlag = perfetto_pbzero_enum_EtwConfig::KernelFlag;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_EtwConfig {
+enum KernelFlag : int32_t {
+  CSWITCH = 0,
+  DISPATCHER = 1,
+};
+} // namespace perfetto_pbzero_enum_EtwConfig
+using EtwConfig_KernelFlag = perfetto_pbzero_enum_EtwConfig::KernelFlag;
+
+
+constexpr EtwConfig_KernelFlag EtwConfig_KernelFlag_MIN = EtwConfig_KernelFlag::CSWITCH;
+constexpr EtwConfig_KernelFlag EtwConfig_KernelFlag_MAX = EtwConfig_KernelFlag::DISPATCHER;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* EtwConfig_KernelFlag_Name(::perfetto::protos::pbzero::EtwConfig_KernelFlag value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::EtwConfig_KernelFlag::CSWITCH:
+    return "CSWITCH";
+
+  case ::perfetto::protos::pbzero::EtwConfig_KernelFlag::DISPATCHER:
+    return "DISPATCHER";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class EtwConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  EtwConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit EtwConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit EtwConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kernel_flags() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> kernel_flags() const { return GetRepeated<int32_t>(1); }
+  bool has_scheduler_provider_events() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> scheduler_provider_events() const { return GetRepeated<::protozero::ConstChars>(2); }
+  bool has_memory_provider_events() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> memory_provider_events() const { return GetRepeated<::protozero::ConstChars>(3); }
+  bool has_file_provider_events() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> file_provider_events() const { return GetRepeated<::protozero::ConstChars>(4); }
+};
+
+class EtwConfig : public ::protozero::Message {
+ public:
+  using Decoder = EtwConfig_Decoder;
+  enum : int32_t {
+    kKernelFlagsFieldNumber = 1,
+    kSchedulerProviderEventsFieldNumber = 2,
+    kMemoryProviderEventsFieldNumber = 3,
+    kFileProviderEventsFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.EtwConfig"; }
+
+
+  using KernelFlag = ::perfetto::protos::pbzero::EtwConfig_KernelFlag;
+  static inline const char* KernelFlag_Name(KernelFlag value) {
+    return ::perfetto::protos::pbzero::EtwConfig_KernelFlag_Name(value);
+  }
+  static inline const KernelFlag CSWITCH = KernelFlag::CSWITCH;
+  static inline const KernelFlag DISPATCHER = KernelFlag::DISPATCHER;
+
+  using FieldMetadata_KernelFlags =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      EtwConfig_KernelFlag,
+      EtwConfig>;
+
+  static constexpr FieldMetadata_KernelFlags kKernelFlags{};
+  void add_kernel_flags(EtwConfig_KernelFlag value) {
+    static constexpr uint32_t field_id = FieldMetadata_KernelFlags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SchedulerProviderEvents =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      EtwConfig>;
+
+  static constexpr FieldMetadata_SchedulerProviderEvents kSchedulerProviderEvents{};
+  void add_scheduler_provider_events(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_SchedulerProviderEvents::kFieldId, data, size);
+  }
+  void add_scheduler_provider_events(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_SchedulerProviderEvents::kFieldId, chars.data, chars.size);
+  }
+  void add_scheduler_provider_events(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_SchedulerProviderEvents::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MemoryProviderEvents =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      EtwConfig>;
+
+  static constexpr FieldMetadata_MemoryProviderEvents kMemoryProviderEvents{};
+  void add_memory_provider_events(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_MemoryProviderEvents::kFieldId, data, size);
+  }
+  void add_memory_provider_events(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_MemoryProviderEvents::kFieldId, chars.data, chars.size);
+  }
+  void add_memory_provider_events(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_MemoryProviderEvents::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FileProviderEvents =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      EtwConfig>;
+
+  static constexpr FieldMetadata_FileProviderEvents kFileProviderEvents{};
+  void add_file_provider_events(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_FileProviderEvents::kFieldId, data, size);
+  }
+  void add_file_provider_events(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_FileProviderEvents::kFieldId, chars.data, chars.size);
+  }
+  void add_file_provider_events(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_FileProviderEvents::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/interceptor_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTOR_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTOR_CONFIG_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class ConsoleConfig;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class InterceptorConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/100> {
+ public:
+  InterceptorConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit InterceptorConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit InterceptorConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_console_config() const { return at<100>().valid(); }
+  ::protozero::ConstBytes console_config() const { return at<100>().as_bytes(); }
+};
+
+class InterceptorConfig : public ::protozero::Message {
+ public:
+  using Decoder = InterceptorConfig_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kConsoleConfigFieldNumber = 100,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.InterceptorConfig"; }
+
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      InterceptorConfig>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ConsoleConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      100,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ConsoleConfig,
+      InterceptorConfig>;
+
+  static constexpr FieldMetadata_ConsoleConfig kConsoleConfig{};
+  template <typename T = ConsoleConfig> T* set_console_config() {
+    return BeginNestedMessage<T>(100);
+  }
+
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/stress_test_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STRESS_TEST_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STRESS_TEST_CONFIG_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class StressTestConfig_WriterTiming;
+class TraceConfig;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class StressTestConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11> {
+ public:
+  StressTestConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit StressTestConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit StressTestConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_trace_config() const { return at<1>().valid(); }
+  ::protozero::ConstBytes trace_config() const { return at<1>().as_bytes(); }
+  bool has_shmem_size_kb() const { return at<2>().valid(); }
+  uint32_t shmem_size_kb() const { return at<2>().as_uint32(); }
+  bool has_shmem_page_size_kb() const { return at<3>().valid(); }
+  uint32_t shmem_page_size_kb() const { return at<3>().as_uint32(); }
+  bool has_num_processes() const { return at<4>().valid(); }
+  uint32_t num_processes() const { return at<4>().as_uint32(); }
+  bool has_num_threads() const { return at<5>().valid(); }
+  uint32_t num_threads() const { return at<5>().as_uint32(); }
+  bool has_max_events() const { return at<6>().valid(); }
+  uint32_t max_events() const { return at<6>().as_uint32(); }
+  bool has_nesting() const { return at<7>().valid(); }
+  uint32_t nesting() const { return at<7>().as_uint32(); }
+  bool has_steady_state_timings() const { return at<8>().valid(); }
+  ::protozero::ConstBytes steady_state_timings() const { return at<8>().as_bytes(); }
+  bool has_burst_period_ms() const { return at<9>().valid(); }
+  uint32_t burst_period_ms() const { return at<9>().as_uint32(); }
+  bool has_burst_duration_ms() const { return at<10>().valid(); }
+  uint32_t burst_duration_ms() const { return at<10>().as_uint32(); }
+  bool has_burst_timings() const { return at<11>().valid(); }
+  ::protozero::ConstBytes burst_timings() const { return at<11>().as_bytes(); }
+};
+
+class StressTestConfig : public ::protozero::Message {
+ public:
+  using Decoder = StressTestConfig_Decoder;
+  enum : int32_t {
+    kTraceConfigFieldNumber = 1,
+    kShmemSizeKbFieldNumber = 2,
+    kShmemPageSizeKbFieldNumber = 3,
+    kNumProcessesFieldNumber = 4,
+    kNumThreadsFieldNumber = 5,
+    kMaxEventsFieldNumber = 6,
+    kNestingFieldNumber = 7,
+    kSteadyStateTimingsFieldNumber = 8,
+    kBurstPeriodMsFieldNumber = 9,
+    kBurstDurationMsFieldNumber = 10,
+    kBurstTimingsFieldNumber = 11,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.StressTestConfig"; }
+
+  using WriterTiming = ::perfetto::protos::pbzero::StressTestConfig_WriterTiming;
+
+  using FieldMetadata_TraceConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TraceConfig,
+      StressTestConfig>;
+
+  static constexpr FieldMetadata_TraceConfig kTraceConfig{};
+  template <typename T = TraceConfig> T* set_trace_config() {
+    return BeginNestedMessage<T>(1);
+  }
+
+
+  using FieldMetadata_ShmemSizeKb =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      StressTestConfig>;
+
+  static constexpr FieldMetadata_ShmemSizeKb kShmemSizeKb{};
+  void set_shmem_size_kb(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ShmemSizeKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ShmemPageSizeKb =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      StressTestConfig>;
+
+  static constexpr FieldMetadata_ShmemPageSizeKb kShmemPageSizeKb{};
+  void set_shmem_page_size_kb(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ShmemPageSizeKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NumProcesses =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      StressTestConfig>;
+
+  static constexpr FieldMetadata_NumProcesses kNumProcesses{};
+  void set_num_processes(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NumProcesses::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NumThreads =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      StressTestConfig>;
+
+  static constexpr FieldMetadata_NumThreads kNumThreads{};
+  void set_num_threads(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NumThreads::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MaxEvents =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      StressTestConfig>;
+
+  static constexpr FieldMetadata_MaxEvents kMaxEvents{};
+  void set_max_events(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MaxEvents::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Nesting =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      StressTestConfig>;
+
+  static constexpr FieldMetadata_Nesting kNesting{};
+  void set_nesting(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Nesting::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SteadyStateTimings =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      StressTestConfig_WriterTiming,
+      StressTestConfig>;
+
+  static constexpr FieldMetadata_SteadyStateTimings kSteadyStateTimings{};
+  template <typename T = StressTestConfig_WriterTiming> T* set_steady_state_timings() {
+    return BeginNestedMessage<T>(8);
+  }
+
+
+  using FieldMetadata_BurstPeriodMs =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      StressTestConfig>;
+
+  static constexpr FieldMetadata_BurstPeriodMs kBurstPeriodMs{};
+  void set_burst_period_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BurstPeriodMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BurstDurationMs =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      StressTestConfig>;
+
+  static constexpr FieldMetadata_BurstDurationMs kBurstDurationMs{};
+  void set_burst_duration_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BurstDurationMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BurstTimings =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      StressTestConfig_WriterTiming,
+      StressTestConfig>;
+
+  static constexpr FieldMetadata_BurstTimings kBurstTimings{};
+  template <typename T = StressTestConfig_WriterTiming> T* set_burst_timings() {
+    return BeginNestedMessage<T>(11);
+  }
+
+};
+
+class StressTestConfig_WriterTiming_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  StressTestConfig_WriterTiming_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit StressTestConfig_WriterTiming_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit StressTestConfig_WriterTiming_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_payload_mean() const { return at<1>().valid(); }
+  double payload_mean() const { return at<1>().as_double(); }
+  bool has_payload_stddev() const { return at<2>().valid(); }
+  double payload_stddev() const { return at<2>().as_double(); }
+  bool has_rate_mean() const { return at<3>().valid(); }
+  double rate_mean() const { return at<3>().as_double(); }
+  bool has_rate_stddev() const { return at<4>().valid(); }
+  double rate_stddev() const { return at<4>().as_double(); }
+  bool has_payload_write_time_ms() const { return at<5>().valid(); }
+  uint32_t payload_write_time_ms() const { return at<5>().as_uint32(); }
+};
+
+class StressTestConfig_WriterTiming : public ::protozero::Message {
+ public:
+  using Decoder = StressTestConfig_WriterTiming_Decoder;
+  enum : int32_t {
+    kPayloadMeanFieldNumber = 1,
+    kPayloadStddevFieldNumber = 2,
+    kRateMeanFieldNumber = 3,
+    kRateStddevFieldNumber = 4,
+    kPayloadWriteTimeMsFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.StressTestConfig.WriterTiming"; }
+
+
+  using FieldMetadata_PayloadMean =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kDouble,
+      double,
+      StressTestConfig_WriterTiming>;
+
+  static constexpr FieldMetadata_PayloadMean kPayloadMean{};
+  void set_payload_mean(double value) {
+    static constexpr uint32_t field_id = FieldMetadata_PayloadMean::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PayloadStddev =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kDouble,
+      double,
+      StressTestConfig_WriterTiming>;
+
+  static constexpr FieldMetadata_PayloadStddev kPayloadStddev{};
+  void set_payload_stddev(double value) {
+    static constexpr uint32_t field_id = FieldMetadata_PayloadStddev::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_RateMean =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kDouble,
+      double,
+      StressTestConfig_WriterTiming>;
+
+  static constexpr FieldMetadata_RateMean kRateMean{};
+  void set_rate_mean(double value) {
+    static constexpr uint32_t field_id = FieldMetadata_RateMean::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_RateStddev =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kDouble,
+      double,
+      StressTestConfig_WriterTiming>;
+
+  static constexpr FieldMetadata_RateStddev kRateStddev{};
+  void set_rate_stddev(double value) {
+    static constexpr uint32_t field_id = FieldMetadata_RateStddev::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PayloadWriteTimeMs =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      StressTestConfig_WriterTiming>;
+
+  static constexpr FieldMetadata_PayloadWriteTimeMs kPayloadWriteTimeMs{};
+  void set_payload_write_time_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PayloadWriteTimeMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/test_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TEST_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TEST_CONFIG_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class TestConfig_DummyFields;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class TestConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
+ public:
+  TestConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TestConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TestConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_message_count() const { return at<1>().valid(); }
+  uint32_t message_count() const { return at<1>().as_uint32(); }
+  bool has_max_messages_per_second() const { return at<2>().valid(); }
+  uint32_t max_messages_per_second() const { return at<2>().as_uint32(); }
+  bool has_seed() const { return at<3>().valid(); }
+  uint32_t seed() const { return at<3>().as_uint32(); }
+  bool has_message_size() const { return at<4>().valid(); }
+  uint32_t message_size() const { return at<4>().as_uint32(); }
+  bool has_send_batch_on_register() const { return at<5>().valid(); }
+  bool send_batch_on_register() const { return at<5>().as_bool(); }
+  bool has_dummy_fields() const { return at<6>().valid(); }
+  ::protozero::ConstBytes dummy_fields() const { return at<6>().as_bytes(); }
+};
+
+class TestConfig : public ::protozero::Message {
+ public:
+  using Decoder = TestConfig_Decoder;
+  enum : int32_t {
+    kMessageCountFieldNumber = 1,
+    kMaxMessagesPerSecondFieldNumber = 2,
+    kSeedFieldNumber = 3,
+    kMessageSizeFieldNumber = 4,
+    kSendBatchOnRegisterFieldNumber = 5,
+    kDummyFieldsFieldNumber = 6,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TestConfig"; }
+
+  using DummyFields = ::perfetto::protos::pbzero::TestConfig_DummyFields;
+
+  using FieldMetadata_MessageCount =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TestConfig>;
+
+  static constexpr FieldMetadata_MessageCount kMessageCount{};
+  void set_message_count(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MessageCount::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MaxMessagesPerSecond =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TestConfig>;
+
+  static constexpr FieldMetadata_MaxMessagesPerSecond kMaxMessagesPerSecond{};
+  void set_max_messages_per_second(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MaxMessagesPerSecond::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Seed =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TestConfig>;
+
+  static constexpr FieldMetadata_Seed kSeed{};
+  void set_seed(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Seed::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MessageSize =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TestConfig>;
+
+  static constexpr FieldMetadata_MessageSize kMessageSize{};
+  void set_message_size(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MessageSize::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SendBatchOnRegister =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TestConfig>;
+
+  static constexpr FieldMetadata_SendBatchOnRegister kSendBatchOnRegister{};
+  void set_send_batch_on_register(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_SendBatchOnRegister::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DummyFields =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TestConfig_DummyFields,
+      TestConfig>;
+
+  static constexpr FieldMetadata_DummyFields kDummyFields{};
+  template <typename T = TestConfig_DummyFields> T* set_dummy_fields() {
+    return BeginNestedMessage<T>(6);
+  }
+
+};
+
+class TestConfig_DummyFields_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/14> {
+ public:
+  TestConfig_DummyFields_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TestConfig_DummyFields_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TestConfig_DummyFields_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_field_uint32() const { return at<1>().valid(); }
+  uint32_t field_uint32() const { return at<1>().as_uint32(); }
+  bool has_field_int32() const { return at<2>().valid(); }
+  int32_t field_int32() const { return at<2>().as_int32(); }
+  bool has_field_uint64() const { return at<3>().valid(); }
+  uint64_t field_uint64() const { return at<3>().as_uint64(); }
+  bool has_field_int64() const { return at<4>().valid(); }
+  int64_t field_int64() const { return at<4>().as_int64(); }
+  bool has_field_fixed64() const { return at<5>().valid(); }
+  uint64_t field_fixed64() const { return at<5>().as_uint64(); }
+  bool has_field_sfixed64() const { return at<6>().valid(); }
+  int64_t field_sfixed64() const { return at<6>().as_int64(); }
+  bool has_field_fixed32() const { return at<7>().valid(); }
+  uint32_t field_fixed32() const { return at<7>().as_uint32(); }
+  bool has_field_sfixed32() const { return at<8>().valid(); }
+  int32_t field_sfixed32() const { return at<8>().as_int32(); }
+  bool has_field_double() const { return at<9>().valid(); }
+  double field_double() const { return at<9>().as_double(); }
+  bool has_field_float() const { return at<10>().valid(); }
+  float field_float() const { return at<10>().as_float(); }
+  bool has_field_sint64() const { return at<11>().valid(); }
+  int64_t field_sint64() const { return at<11>().as_sint64(); }
+  bool has_field_sint32() const { return at<12>().valid(); }
+  int32_t field_sint32() const { return at<12>().as_sint32(); }
+  bool has_field_string() const { return at<13>().valid(); }
+  ::protozero::ConstChars field_string() const { return at<13>().as_string(); }
+  bool has_field_bytes() const { return at<14>().valid(); }
+  ::protozero::ConstBytes field_bytes() const { return at<14>().as_bytes(); }
+};
+
+class TestConfig_DummyFields : public ::protozero::Message {
+ public:
+  using Decoder = TestConfig_DummyFields_Decoder;
+  enum : int32_t {
+    kFieldUint32FieldNumber = 1,
+    kFieldInt32FieldNumber = 2,
+    kFieldUint64FieldNumber = 3,
+    kFieldInt64FieldNumber = 4,
+    kFieldFixed64FieldNumber = 5,
+    kFieldSfixed64FieldNumber = 6,
+    kFieldFixed32FieldNumber = 7,
+    kFieldSfixed32FieldNumber = 8,
+    kFieldDoubleFieldNumber = 9,
+    kFieldFloatFieldNumber = 10,
+    kFieldSint64FieldNumber = 11,
+    kFieldSint32FieldNumber = 12,
+    kFieldStringFieldNumber = 13,
+    kFieldBytesFieldNumber = 14,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TestConfig.DummyFields"; }
+
+
+  using FieldMetadata_FieldUint32 =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TestConfig_DummyFields>;
+
+  static constexpr FieldMetadata_FieldUint32 kFieldUint32{};
+  void set_field_uint32(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FieldUint32::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FieldInt32 =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TestConfig_DummyFields>;
+
+  static constexpr FieldMetadata_FieldInt32 kFieldInt32{};
+  void set_field_int32(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FieldInt32::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FieldUint64 =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TestConfig_DummyFields>;
+
+  static constexpr FieldMetadata_FieldUint64 kFieldUint64{};
+  void set_field_uint64(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FieldUint64::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FieldInt64 =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      TestConfig_DummyFields>;
+
+  static constexpr FieldMetadata_FieldInt64 kFieldInt64{};
+  void set_field_int64(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FieldInt64::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FieldFixed64 =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
+      uint64_t,
+      TestConfig_DummyFields>;
+
+  static constexpr FieldMetadata_FieldFixed64 kFieldFixed64{};
+  void set_field_fixed64(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FieldFixed64::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FieldSfixed64 =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kSfixed64,
+      int64_t,
+      TestConfig_DummyFields>;
+
+  static constexpr FieldMetadata_FieldSfixed64 kFieldSfixed64{};
+  void set_field_sfixed64(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FieldSfixed64::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kSfixed64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FieldFixed32 =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFixed32,
+      uint32_t,
+      TestConfig_DummyFields>;
+
+  static constexpr FieldMetadata_FieldFixed32 kFieldFixed32{};
+  void set_field_fixed32(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FieldFixed32::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFixed32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FieldSfixed32 =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kSfixed32,
+      int32_t,
+      TestConfig_DummyFields>;
+
+  static constexpr FieldMetadata_FieldSfixed32 kFieldSfixed32{};
+  void set_field_sfixed32(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FieldSfixed32::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kSfixed32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FieldDouble =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kDouble,
+      double,
+      TestConfig_DummyFields>;
+
+  static constexpr FieldMetadata_FieldDouble kFieldDouble{};
+  void set_field_double(double value) {
+    static constexpr uint32_t field_id = FieldMetadata_FieldDouble::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FieldFloat =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      TestConfig_DummyFields>;
+
+  static constexpr FieldMetadata_FieldFloat kFieldFloat{};
+  void set_field_float(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_FieldFloat::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FieldSint64 =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kSint64,
+      int64_t,
+      TestConfig_DummyFields>;
+
+  static constexpr FieldMetadata_FieldSint64 kFieldSint64{};
+  void set_field_sint64(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FieldSint64::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kSint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FieldSint32 =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kSint32,
+      int32_t,
+      TestConfig_DummyFields>;
+
+  static constexpr FieldMetadata_FieldSint32 kFieldSint32{};
+  void set_field_sint32(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FieldSint32::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kSint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FieldString =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TestConfig_DummyFields>;
+
+  static constexpr FieldMetadata_FieldString kFieldString{};
+  void set_field_string(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_FieldString::kFieldId, data, size);
+  }
+  void set_field_string(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_FieldString::kFieldId, chars.data, chars.size);
+  }
+  void set_field_string(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_FieldString::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FieldBytes =
+    ::protozero::proto_utils::FieldMetadata<
+      14,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      TestConfig_DummyFields>;
+
+  static constexpr FieldMetadata_FieldBytes kFieldBytes{};
+  void set_field_bytes(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_FieldBytes::kFieldId, data, size);
+  }
+  void set_field_bytes(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_FieldBytes::kFieldId, bytes.data, bytes.size);
+  }
+  void set_field_bytes(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_FieldBytes::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/trace_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TRACE_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TRACE_CONFIG_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class DataSourceConfig;
+class PriorityBoostConfig;
+class TraceConfig_AndroidReportConfig;
+class TraceConfig_BufferConfig;
+class TraceConfig_BuiltinDataSource;
+class TraceConfig_CmdTraceStartDelay;
+class TraceConfig_DataSource;
+class TraceConfig_GuardrailOverrides;
+class TraceConfig_IncidentReportConfig;
+class TraceConfig_IncrementalStateConfig;
+class TraceConfig_Note;
+class TraceConfig_ProducerConfig;
+class TraceConfig_SessionSemaphore;
+class TraceConfig_StatsdMetadata;
+class TraceConfig_TraceFilter;
+class TraceConfig_TraceFilter_StringFilterChain;
+class TraceConfig_TraceFilter_StringFilterRule;
+class TraceConfig_TriggerConfig;
+class TraceConfig_TriggerConfig_Trigger;
+enum BuiltinClock : int32_t;
+enum SemanticType : int32_t;
+namespace perfetto_pbzero_enum_TraceConfig_BufferConfig {
+enum ExperimentalMode : int32_t;
+}  // namespace perfetto_pbzero_enum_TraceConfig_BufferConfig
+using TraceConfig_BufferConfig_ExperimentalMode = perfetto_pbzero_enum_TraceConfig_BufferConfig::ExperimentalMode;
+namespace perfetto_pbzero_enum_TraceConfig_BufferConfig {
+enum FillPolicy : int32_t;
+}  // namespace perfetto_pbzero_enum_TraceConfig_BufferConfig
+using TraceConfig_BufferConfig_FillPolicy = perfetto_pbzero_enum_TraceConfig_BufferConfig::FillPolicy;
+namespace perfetto_pbzero_enum_TraceConfig {
+enum CompressionType : int32_t;
+}  // namespace perfetto_pbzero_enum_TraceConfig
+using TraceConfig_CompressionType = perfetto_pbzero_enum_TraceConfig::CompressionType;
+namespace perfetto_pbzero_enum_TraceConfig {
+enum FFlushMode : int32_t;
+}  // namespace perfetto_pbzero_enum_TraceConfig
+using TraceConfig_FFlushMode = perfetto_pbzero_enum_TraceConfig::FFlushMode;
+namespace perfetto_pbzero_enum_TraceConfig {
+enum LockdownModeOperation : int32_t;
+}  // namespace perfetto_pbzero_enum_TraceConfig
+using TraceConfig_LockdownModeOperation = perfetto_pbzero_enum_TraceConfig::LockdownModeOperation;
+namespace perfetto_pbzero_enum_TraceConfig {
+enum StatsdLogging : int32_t;
+}  // namespace perfetto_pbzero_enum_TraceConfig
+using TraceConfig_StatsdLogging = perfetto_pbzero_enum_TraceConfig::StatsdLogging;
+namespace perfetto_pbzero_enum_TraceConfig_TraceFilter {
+enum StringFilterPolicy : int32_t;
+}  // namespace perfetto_pbzero_enum_TraceConfig_TraceFilter
+using TraceConfig_TraceFilter_StringFilterPolicy = perfetto_pbzero_enum_TraceConfig_TraceFilter::StringFilterPolicy;
+namespace perfetto_pbzero_enum_TraceConfig_TriggerConfig {
+enum TriggerMode : int32_t;
+}  // namespace perfetto_pbzero_enum_TraceConfig_TriggerConfig
+using TraceConfig_TriggerConfig_TriggerMode = perfetto_pbzero_enum_TraceConfig_TriggerConfig::TriggerMode;
+namespace perfetto_pbzero_enum_TraceConfig {
+enum WriteFlushMode : int32_t;
+}  // namespace perfetto_pbzero_enum_TraceConfig
+using TraceConfig_WriteFlushMode = perfetto_pbzero_enum_TraceConfig::WriteFlushMode;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_TraceConfig {
+enum LockdownModeOperation : int32_t {
+  LOCKDOWN_UNCHANGED = 0,
+  LOCKDOWN_CLEAR = 1,
+  LOCKDOWN_SET = 2,
+};
+} // namespace perfetto_pbzero_enum_TraceConfig
+using TraceConfig_LockdownModeOperation = perfetto_pbzero_enum_TraceConfig::LockdownModeOperation;
+
+
+constexpr TraceConfig_LockdownModeOperation TraceConfig_LockdownModeOperation_MIN = TraceConfig_LockdownModeOperation::LOCKDOWN_UNCHANGED;
+constexpr TraceConfig_LockdownModeOperation TraceConfig_LockdownModeOperation_MAX = TraceConfig_LockdownModeOperation::LOCKDOWN_SET;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* TraceConfig_LockdownModeOperation_Name(::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation::LOCKDOWN_UNCHANGED:
+    return "LOCKDOWN_UNCHANGED";
+
+  case ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation::LOCKDOWN_CLEAR:
+    return "LOCKDOWN_CLEAR";
+
+  case ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation::LOCKDOWN_SET:
+    return "LOCKDOWN_SET";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_TraceConfig {
+enum CompressionType : int32_t {
+  COMPRESSION_TYPE_UNSPECIFIED = 0,
+  COMPRESSION_TYPE_DEFLATE = 1,
+};
+} // namespace perfetto_pbzero_enum_TraceConfig
+using TraceConfig_CompressionType = perfetto_pbzero_enum_TraceConfig::CompressionType;
+
+
+constexpr TraceConfig_CompressionType TraceConfig_CompressionType_MIN = TraceConfig_CompressionType::COMPRESSION_TYPE_UNSPECIFIED;
+constexpr TraceConfig_CompressionType TraceConfig_CompressionType_MAX = TraceConfig_CompressionType::COMPRESSION_TYPE_DEFLATE;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* TraceConfig_CompressionType_Name(::perfetto::protos::pbzero::TraceConfig_CompressionType value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::TraceConfig_CompressionType::COMPRESSION_TYPE_UNSPECIFIED:
+    return "COMPRESSION_TYPE_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::TraceConfig_CompressionType::COMPRESSION_TYPE_DEFLATE:
+    return "COMPRESSION_TYPE_DEFLATE";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_TraceConfig {
+enum StatsdLogging : int32_t {
+  STATSD_LOGGING_UNSPECIFIED = 0,
+  STATSD_LOGGING_ENABLED = 1,
+  STATSD_LOGGING_DISABLED = 2,
+};
+} // namespace perfetto_pbzero_enum_TraceConfig
+using TraceConfig_StatsdLogging = perfetto_pbzero_enum_TraceConfig::StatsdLogging;
+
+
+constexpr TraceConfig_StatsdLogging TraceConfig_StatsdLogging_MIN = TraceConfig_StatsdLogging::STATSD_LOGGING_UNSPECIFIED;
+constexpr TraceConfig_StatsdLogging TraceConfig_StatsdLogging_MAX = TraceConfig_StatsdLogging::STATSD_LOGGING_DISABLED;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* TraceConfig_StatsdLogging_Name(::perfetto::protos::pbzero::TraceConfig_StatsdLogging value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::TraceConfig_StatsdLogging::STATSD_LOGGING_UNSPECIFIED:
+    return "STATSD_LOGGING_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::TraceConfig_StatsdLogging::STATSD_LOGGING_ENABLED:
+    return "STATSD_LOGGING_ENABLED";
+
+  case ::perfetto::protos::pbzero::TraceConfig_StatsdLogging::STATSD_LOGGING_DISABLED:
+    return "STATSD_LOGGING_DISABLED";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_TraceConfig {
+enum WriteFlushMode : int32_t {
+  WRITE_FLUSH_UNSPECIFIED = 0,
+  WRITE_FLUSH_AUTO = 1,
+  WRITE_FLUSH_DISABLED = 2,
+  WRITE_FLUSH_ENABLED = 3,
+};
+} // namespace perfetto_pbzero_enum_TraceConfig
+using TraceConfig_WriteFlushMode = perfetto_pbzero_enum_TraceConfig::WriteFlushMode;
+
+
+constexpr TraceConfig_WriteFlushMode TraceConfig_WriteFlushMode_MIN = TraceConfig_WriteFlushMode::WRITE_FLUSH_UNSPECIFIED;
+constexpr TraceConfig_WriteFlushMode TraceConfig_WriteFlushMode_MAX = TraceConfig_WriteFlushMode::WRITE_FLUSH_ENABLED;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* TraceConfig_WriteFlushMode_Name(::perfetto::protos::pbzero::TraceConfig_WriteFlushMode value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::TraceConfig_WriteFlushMode::WRITE_FLUSH_UNSPECIFIED:
+    return "WRITE_FLUSH_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::TraceConfig_WriteFlushMode::WRITE_FLUSH_AUTO:
+    return "WRITE_FLUSH_AUTO";
+
+  case ::perfetto::protos::pbzero::TraceConfig_WriteFlushMode::WRITE_FLUSH_DISABLED:
+    return "WRITE_FLUSH_DISABLED";
+
+  case ::perfetto::protos::pbzero::TraceConfig_WriteFlushMode::WRITE_FLUSH_ENABLED:
+    return "WRITE_FLUSH_ENABLED";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_TraceConfig {
+enum FFlushMode : int32_t {
+  FFLUSH_UNSPECIFIED = 0,
+  FFLUSH_DISABLED = 1,
+  FFLUSH_ENABLED = 2,
+};
+} // namespace perfetto_pbzero_enum_TraceConfig
+using TraceConfig_FFlushMode = perfetto_pbzero_enum_TraceConfig::FFlushMode;
+
+
+constexpr TraceConfig_FFlushMode TraceConfig_FFlushMode_MIN = TraceConfig_FFlushMode::FFLUSH_UNSPECIFIED;
+constexpr TraceConfig_FFlushMode TraceConfig_FFlushMode_MAX = TraceConfig_FFlushMode::FFLUSH_ENABLED;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* TraceConfig_FFlushMode_Name(::perfetto::protos::pbzero::TraceConfig_FFlushMode value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::TraceConfig_FFlushMode::FFLUSH_UNSPECIFIED:
+    return "FFLUSH_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::TraceConfig_FFlushMode::FFLUSH_DISABLED:
+    return "FFLUSH_DISABLED";
+
+  case ::perfetto::protos::pbzero::TraceConfig_FFlushMode::FFLUSH_ENABLED:
+    return "FFLUSH_ENABLED";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_TraceConfig_TraceFilter {
+enum StringFilterPolicy : int32_t {
+  SFP_UNSPECIFIED = 0,
+  SFP_MATCH_REDACT_GROUPS = 1,
+  SFP_ATRACE_MATCH_REDACT_GROUPS = 2,
+  SFP_MATCH_BREAK = 3,
+  SFP_ATRACE_MATCH_BREAK = 4,
+  SFP_ATRACE_REPEATED_SEARCH_REDACT_GROUPS = 5,
+};
+} // namespace perfetto_pbzero_enum_TraceConfig_TraceFilter
+using TraceConfig_TraceFilter_StringFilterPolicy = perfetto_pbzero_enum_TraceConfig_TraceFilter::StringFilterPolicy;
+
+
+constexpr TraceConfig_TraceFilter_StringFilterPolicy TraceConfig_TraceFilter_StringFilterPolicy_MIN = TraceConfig_TraceFilter_StringFilterPolicy::SFP_UNSPECIFIED;
+constexpr TraceConfig_TraceFilter_StringFilterPolicy TraceConfig_TraceFilter_StringFilterPolicy_MAX = TraceConfig_TraceFilter_StringFilterPolicy::SFP_ATRACE_REPEATED_SEARCH_REDACT_GROUPS;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* TraceConfig_TraceFilter_StringFilterPolicy_Name(::perfetto::protos::pbzero::TraceConfig_TraceFilter_StringFilterPolicy value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::TraceConfig_TraceFilter_StringFilterPolicy::SFP_UNSPECIFIED:
+    return "SFP_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::TraceConfig_TraceFilter_StringFilterPolicy::SFP_MATCH_REDACT_GROUPS:
+    return "SFP_MATCH_REDACT_GROUPS";
+
+  case ::perfetto::protos::pbzero::TraceConfig_TraceFilter_StringFilterPolicy::SFP_ATRACE_MATCH_REDACT_GROUPS:
+    return "SFP_ATRACE_MATCH_REDACT_GROUPS";
+
+  case ::perfetto::protos::pbzero::TraceConfig_TraceFilter_StringFilterPolicy::SFP_MATCH_BREAK:
+    return "SFP_MATCH_BREAK";
+
+  case ::perfetto::protos::pbzero::TraceConfig_TraceFilter_StringFilterPolicy::SFP_ATRACE_MATCH_BREAK:
+    return "SFP_ATRACE_MATCH_BREAK";
+
+  case ::perfetto::protos::pbzero::TraceConfig_TraceFilter_StringFilterPolicy::SFP_ATRACE_REPEATED_SEARCH_REDACT_GROUPS:
+    return "SFP_ATRACE_REPEATED_SEARCH_REDACT_GROUPS";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_TraceConfig_TriggerConfig {
+enum TriggerMode : int32_t {
+  UNSPECIFIED = 0,
+  START_TRACING = 1,
+  STOP_TRACING = 2,
+  CLONE_SNAPSHOT = 4,
+};
+} // namespace perfetto_pbzero_enum_TraceConfig_TriggerConfig
+using TraceConfig_TriggerConfig_TriggerMode = perfetto_pbzero_enum_TraceConfig_TriggerConfig::TriggerMode;
+
+
+constexpr TraceConfig_TriggerConfig_TriggerMode TraceConfig_TriggerConfig_TriggerMode_MIN = TraceConfig_TriggerConfig_TriggerMode::UNSPECIFIED;
+constexpr TraceConfig_TriggerConfig_TriggerMode TraceConfig_TriggerConfig_TriggerMode_MAX = TraceConfig_TriggerConfig_TriggerMode::CLONE_SNAPSHOT;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* TraceConfig_TriggerConfig_TriggerMode_Name(::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode::UNSPECIFIED:
+    return "UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode::START_TRACING:
+    return "START_TRACING";
+
+  case ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode::STOP_TRACING:
+    return "STOP_TRACING";
+
+  case ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode::CLONE_SNAPSHOT:
+    return "CLONE_SNAPSHOT";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_TraceConfig_BufferConfig {
+enum FillPolicy : int32_t {
+  UNSPECIFIED = 0,
+  RING_BUFFER = 1,
+  DISCARD = 2,
+};
+} // namespace perfetto_pbzero_enum_TraceConfig_BufferConfig
+using TraceConfig_BufferConfig_FillPolicy = perfetto_pbzero_enum_TraceConfig_BufferConfig::FillPolicy;
+
+
+constexpr TraceConfig_BufferConfig_FillPolicy TraceConfig_BufferConfig_FillPolicy_MIN = TraceConfig_BufferConfig_FillPolicy::UNSPECIFIED;
+constexpr TraceConfig_BufferConfig_FillPolicy TraceConfig_BufferConfig_FillPolicy_MAX = TraceConfig_BufferConfig_FillPolicy::DISCARD;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* TraceConfig_BufferConfig_FillPolicy_Name(::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy::UNSPECIFIED:
+    return "UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy::RING_BUFFER:
+    return "RING_BUFFER";
+
+  case ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy::DISCARD:
+    return "DISCARD";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_TraceConfig_BufferConfig {
+enum ExperimentalMode : int32_t {
+  MODE_UNSPECIFIED = 0,
+  TRACE_BUFFER_V2 = 1,
+  TRACE_BUFFER_V2_SHADOW_MODE = 2,
+};
+} // namespace perfetto_pbzero_enum_TraceConfig_BufferConfig
+using TraceConfig_BufferConfig_ExperimentalMode = perfetto_pbzero_enum_TraceConfig_BufferConfig::ExperimentalMode;
+
+
+constexpr TraceConfig_BufferConfig_ExperimentalMode TraceConfig_BufferConfig_ExperimentalMode_MIN = TraceConfig_BufferConfig_ExperimentalMode::MODE_UNSPECIFIED;
+constexpr TraceConfig_BufferConfig_ExperimentalMode TraceConfig_BufferConfig_ExperimentalMode_MAX = TraceConfig_BufferConfig_ExperimentalMode::TRACE_BUFFER_V2_SHADOW_MODE;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* TraceConfig_BufferConfig_ExperimentalMode_Name(::perfetto::protos::pbzero::TraceConfig_BufferConfig_ExperimentalMode value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::TraceConfig_BufferConfig_ExperimentalMode::MODE_UNSPECIFIED:
+    return "MODE_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::TraceConfig_BufferConfig_ExperimentalMode::TRACE_BUFFER_V2:
+    return "TRACE_BUFFER_V2";
+
+  case ::perfetto::protos::pbzero::TraceConfig_BufferConfig_ExperimentalMode::TRACE_BUFFER_V2_SHADOW_MODE:
+    return "TRACE_BUFFER_V2_SHADOW_MODE";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class TraceConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/46> {
+ public:
+  TraceConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_buffers() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> buffers() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  bool has_data_sources() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> data_sources() const { return GetRepeated<::protozero::ConstBytes>(2); }
+  bool has_builtin_data_sources() const { return at<20>().valid(); }
+  ::protozero::ConstBytes builtin_data_sources() const { return at<20>().as_bytes(); }
+  bool has_duration_ms() const { return at<3>().valid(); }
+  uint32_t duration_ms() const { return at<3>().as_uint32(); }
+  bool has_prefer_suspend_clock_for_duration() const { return at<36>().valid(); }
+  bool prefer_suspend_clock_for_duration() const { return at<36>().as_bool(); }
+  bool has_enable_extra_guardrails() const { return at<4>().valid(); }
+  bool enable_extra_guardrails() const { return at<4>().as_bool(); }
+  bool has_lockdown_mode() const { return at<5>().valid(); }
+  int32_t lockdown_mode() const { return at<5>().as_int32(); }
+  bool has_producers() const { return at<6>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> producers() const { return GetRepeated<::protozero::ConstBytes>(6); }
+  bool has_statsd_metadata() const { return at<7>().valid(); }
+  ::protozero::ConstBytes statsd_metadata() const { return at<7>().as_bytes(); }
+  bool has_write_into_file() const { return at<8>().valid(); }
+  bool write_into_file() const { return at<8>().as_bool(); }
+  bool has_output_path() const { return at<29>().valid(); }
+  ::protozero::ConstChars output_path() const { return at<29>().as_string(); }
+  bool has_file_write_period_ms() const { return at<9>().valid(); }
+  uint32_t file_write_period_ms() const { return at<9>().as_uint32(); }
+  bool has_max_file_size_bytes() const { return at<10>().valid(); }
+  uint64_t max_file_size_bytes() const { return at<10>().as_uint64(); }
+  bool has_guardrail_overrides() const { return at<11>().valid(); }
+  ::protozero::ConstBytes guardrail_overrides() const { return at<11>().as_bytes(); }
+  bool has_deferred_start() const { return at<12>().valid(); }
+  bool deferred_start() const { return at<12>().as_bool(); }
+  bool has_flush_period_ms() const { return at<13>().valid(); }
+  uint32_t flush_period_ms() const { return at<13>().as_uint32(); }
+  bool has_flush_timeout_ms() const { return at<14>().valid(); }
+  uint32_t flush_timeout_ms() const { return at<14>().as_uint32(); }
+  bool has_data_source_stop_timeout_ms() const { return at<23>().valid(); }
+  uint32_t data_source_stop_timeout_ms() const { return at<23>().as_uint32(); }
+  bool has_notify_traceur() const { return at<16>().valid(); }
+  bool notify_traceur() const { return at<16>().as_bool(); }
+  bool has_bugreport_score() const { return at<30>().valid(); }
+  int32_t bugreport_score() const { return at<30>().as_int32(); }
+  bool has_bugreport_filename() const { return at<38>().valid(); }
+  ::protozero::ConstChars bugreport_filename() const { return at<38>().as_string(); }
+  bool has_trigger_config() const { return at<17>().valid(); }
+  ::protozero::ConstBytes trigger_config() const { return at<17>().as_bytes(); }
+  bool has_activate_triggers() const { return at<18>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> activate_triggers() const { return GetRepeated<::protozero::ConstChars>(18); }
+  bool has_incremental_state_config() const { return at<21>().valid(); }
+  ::protozero::ConstBytes incremental_state_config() const { return at<21>().as_bytes(); }
+  bool has_allow_user_build_tracing() const { return at<19>().valid(); }
+  bool allow_user_build_tracing() const { return at<19>().as_bool(); }
+  bool has_unique_session_name() const { return at<22>().valid(); }
+  ::protozero::ConstChars unique_session_name() const { return at<22>().as_string(); }
+  bool has_compression_type() const { return at<24>().valid(); }
+  int32_t compression_type() const { return at<24>().as_int32(); }
+  bool has_incident_report_config() const { return at<25>().valid(); }
+  ::protozero::ConstBytes incident_report_config() const { return at<25>().as_bytes(); }
+  bool has_statsd_logging() const { return at<31>().valid(); }
+  int32_t statsd_logging() const { return at<31>().as_int32(); }
+  bool has_trace_uuid_msb() const { return at<27>().valid(); }
+  int64_t trace_uuid_msb() const { return at<27>().as_int64(); }
+  bool has_trace_uuid_lsb() const { return at<28>().valid(); }
+  int64_t trace_uuid_lsb() const { return at<28>().as_int64(); }
+  bool has_trace_filter() const { return at<33>().valid(); }
+  ::protozero::ConstBytes trace_filter() const { return at<33>().as_bytes(); }
+  bool has_android_report_config() const { return at<34>().valid(); }
+  ::protozero::ConstBytes android_report_config() const { return at<34>().as_bytes(); }
+  bool has_cmd_trace_start_delay() const { return at<35>().valid(); }
+  ::protozero::ConstBytes cmd_trace_start_delay() const { return at<35>().as_bytes(); }
+  bool has_session_semaphores() const { return at<39>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> session_semaphores() const { return GetRepeated<::protozero::ConstBytes>(39); }
+  bool has_priority_boost() const { return at<40>().valid(); }
+  ::protozero::ConstBytes priority_boost() const { return at<40>().as_bytes(); }
+  bool has_exclusive_prio() const { return at<41>().valid(); }
+  uint32_t exclusive_prio() const { return at<41>().as_uint32(); }
+  bool has_write_flush_mode() const { return at<44>().valid(); }
+  int32_t write_flush_mode() const { return at<44>().as_int32(); }
+  bool has_fflush_post_write() const { return at<45>().valid(); }
+  int32_t fflush_post_write() const { return at<45>().as_int32(); }
+  bool has_trace_all_machines() const { return at<43>().valid(); }
+  bool trace_all_machines() const { return at<43>().as_bool(); }
+  bool has_notes() const { return at<46>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> notes() const { return GetRepeated<::protozero::ConstBytes>(46); }
+};
+
+class TraceConfig : public ::protozero::Message {
+ public:
+  using Decoder = TraceConfig_Decoder;
+  enum : int32_t {
+    kBuffersFieldNumber = 1,
+    kDataSourcesFieldNumber = 2,
+    kBuiltinDataSourcesFieldNumber = 20,
+    kDurationMsFieldNumber = 3,
+    kPreferSuspendClockForDurationFieldNumber = 36,
+    kEnableExtraGuardrailsFieldNumber = 4,
+    kLockdownModeFieldNumber = 5,
+    kProducersFieldNumber = 6,
+    kStatsdMetadataFieldNumber = 7,
+    kWriteIntoFileFieldNumber = 8,
+    kOutputPathFieldNumber = 29,
+    kFileWritePeriodMsFieldNumber = 9,
+    kMaxFileSizeBytesFieldNumber = 10,
+    kGuardrailOverridesFieldNumber = 11,
+    kDeferredStartFieldNumber = 12,
+    kFlushPeriodMsFieldNumber = 13,
+    kFlushTimeoutMsFieldNumber = 14,
+    kDataSourceStopTimeoutMsFieldNumber = 23,
+    kNotifyTraceurFieldNumber = 16,
+    kBugreportScoreFieldNumber = 30,
+    kBugreportFilenameFieldNumber = 38,
+    kTriggerConfigFieldNumber = 17,
+    kActivateTriggersFieldNumber = 18,
+    kIncrementalStateConfigFieldNumber = 21,
+    kAllowUserBuildTracingFieldNumber = 19,
+    kUniqueSessionNameFieldNumber = 22,
+    kCompressionTypeFieldNumber = 24,
+    kIncidentReportConfigFieldNumber = 25,
+    kStatsdLoggingFieldNumber = 31,
+    kTraceUuidMsbFieldNumber = 27,
+    kTraceUuidLsbFieldNumber = 28,
+    kTraceFilterFieldNumber = 33,
+    kAndroidReportConfigFieldNumber = 34,
+    kCmdTraceStartDelayFieldNumber = 35,
+    kSessionSemaphoresFieldNumber = 39,
+    kPriorityBoostFieldNumber = 40,
+    kExclusivePrioFieldNumber = 41,
+    kWriteFlushModeFieldNumber = 44,
+    kFflushPostWriteFieldNumber = 45,
+    kTraceAllMachinesFieldNumber = 43,
+    kNotesFieldNumber = 46,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig"; }
+
+  using BufferConfig = ::perfetto::protos::pbzero::TraceConfig_BufferConfig;
+  using DataSource = ::perfetto::protos::pbzero::TraceConfig_DataSource;
+  using BuiltinDataSource = ::perfetto::protos::pbzero::TraceConfig_BuiltinDataSource;
+  using ProducerConfig = ::perfetto::protos::pbzero::TraceConfig_ProducerConfig;
+  using StatsdMetadata = ::perfetto::protos::pbzero::TraceConfig_StatsdMetadata;
+  using GuardrailOverrides = ::perfetto::protos::pbzero::TraceConfig_GuardrailOverrides;
+  using TriggerConfig = ::perfetto::protos::pbzero::TraceConfig_TriggerConfig;
+  using IncrementalStateConfig = ::perfetto::protos::pbzero::TraceConfig_IncrementalStateConfig;
+  using IncidentReportConfig = ::perfetto::protos::pbzero::TraceConfig_IncidentReportConfig;
+  using TraceFilter = ::perfetto::protos::pbzero::TraceConfig_TraceFilter;
+  using AndroidReportConfig = ::perfetto::protos::pbzero::TraceConfig_AndroidReportConfig;
+  using CmdTraceStartDelay = ::perfetto::protos::pbzero::TraceConfig_CmdTraceStartDelay;
+  using SessionSemaphore = ::perfetto::protos::pbzero::TraceConfig_SessionSemaphore;
+  using Note = ::perfetto::protos::pbzero::TraceConfig_Note;
+
+  using LockdownModeOperation = ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation;
+  static inline const char* LockdownModeOperation_Name(LockdownModeOperation value) {
+    return ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation_Name(value);
+  }
+
+  using CompressionType = ::perfetto::protos::pbzero::TraceConfig_CompressionType;
+  static inline const char* CompressionType_Name(CompressionType value) {
+    return ::perfetto::protos::pbzero::TraceConfig_CompressionType_Name(value);
+  }
+
+  using StatsdLogging = ::perfetto::protos::pbzero::TraceConfig_StatsdLogging;
+  static inline const char* StatsdLogging_Name(StatsdLogging value) {
+    return ::perfetto::protos::pbzero::TraceConfig_StatsdLogging_Name(value);
+  }
+
+  using WriteFlushMode = ::perfetto::protos::pbzero::TraceConfig_WriteFlushMode;
+  static inline const char* WriteFlushMode_Name(WriteFlushMode value) {
+    return ::perfetto::protos::pbzero::TraceConfig_WriteFlushMode_Name(value);
+  }
+
+  using FFlushMode = ::perfetto::protos::pbzero::TraceConfig_FFlushMode;
+  static inline const char* FFlushMode_Name(FFlushMode value) {
+    return ::perfetto::protos::pbzero::TraceConfig_FFlushMode_Name(value);
+  }
+  static inline const LockdownModeOperation LOCKDOWN_UNCHANGED = LockdownModeOperation::LOCKDOWN_UNCHANGED;
+  static inline const LockdownModeOperation LOCKDOWN_CLEAR = LockdownModeOperation::LOCKDOWN_CLEAR;
+  static inline const LockdownModeOperation LOCKDOWN_SET = LockdownModeOperation::LOCKDOWN_SET;
+  static inline const CompressionType COMPRESSION_TYPE_UNSPECIFIED = CompressionType::COMPRESSION_TYPE_UNSPECIFIED;
+  static inline const CompressionType COMPRESSION_TYPE_DEFLATE = CompressionType::COMPRESSION_TYPE_DEFLATE;
+  static inline const StatsdLogging STATSD_LOGGING_UNSPECIFIED = StatsdLogging::STATSD_LOGGING_UNSPECIFIED;
+  static inline const StatsdLogging STATSD_LOGGING_ENABLED = StatsdLogging::STATSD_LOGGING_ENABLED;
+  static inline const StatsdLogging STATSD_LOGGING_DISABLED = StatsdLogging::STATSD_LOGGING_DISABLED;
+  static inline const WriteFlushMode WRITE_FLUSH_UNSPECIFIED = WriteFlushMode::WRITE_FLUSH_UNSPECIFIED;
+  static inline const WriteFlushMode WRITE_FLUSH_AUTO = WriteFlushMode::WRITE_FLUSH_AUTO;
+  static inline const WriteFlushMode WRITE_FLUSH_DISABLED = WriteFlushMode::WRITE_FLUSH_DISABLED;
+  static inline const WriteFlushMode WRITE_FLUSH_ENABLED = WriteFlushMode::WRITE_FLUSH_ENABLED;
+  static inline const FFlushMode FFLUSH_UNSPECIFIED = FFlushMode::FFLUSH_UNSPECIFIED;
+  static inline const FFlushMode FFLUSH_DISABLED = FFlushMode::FFLUSH_DISABLED;
+  static inline const FFlushMode FFLUSH_ENABLED = FFlushMode::FFLUSH_ENABLED;
+
+  using FieldMetadata_Buffers =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TraceConfig_BufferConfig,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_Buffers kBuffers{};
+  template <typename T = TraceConfig_BufferConfig> T* add_buffers() {
+    return BeginNestedMessage<T>(1);
+  }
+
+
+  using FieldMetadata_DataSources =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TraceConfig_DataSource,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_DataSources kDataSources{};
+  template <typename T = TraceConfig_DataSource> T* add_data_sources() {
+    return BeginNestedMessage<T>(2);
+  }
+
+
+  using FieldMetadata_BuiltinDataSources =
+    ::protozero::proto_utils::FieldMetadata<
+      20,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TraceConfig_BuiltinDataSource,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_BuiltinDataSources kBuiltinDataSources{};
+  template <typename T = TraceConfig_BuiltinDataSource> T* set_builtin_data_sources() {
+    return BeginNestedMessage<T>(20);
+  }
+
+
+  using FieldMetadata_DurationMs =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_DurationMs kDurationMs{};
+  void set_duration_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DurationMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PreferSuspendClockForDuration =
+    ::protozero::proto_utils::FieldMetadata<
+      36,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_PreferSuspendClockForDuration kPreferSuspendClockForDuration{};
+  void set_prefer_suspend_clock_for_duration(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_PreferSuspendClockForDuration::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_EnableExtraGuardrails =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_EnableExtraGuardrails kEnableExtraGuardrails{};
+  void set_enable_extra_guardrails(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_EnableExtraGuardrails::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_LockdownMode =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      TraceConfig_LockdownModeOperation,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_LockdownMode kLockdownMode{};
+  void set_lockdown_mode(TraceConfig_LockdownModeOperation value) {
+    static constexpr uint32_t field_id = FieldMetadata_LockdownMode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Producers =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TraceConfig_ProducerConfig,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_Producers kProducers{};
+  template <typename T = TraceConfig_ProducerConfig> T* add_producers() {
+    return BeginNestedMessage<T>(6);
+  }
+
+
+  using FieldMetadata_StatsdMetadata =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TraceConfig_StatsdMetadata,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_StatsdMetadata kStatsdMetadata{};
+  template <typename T = TraceConfig_StatsdMetadata> T* set_statsd_metadata() {
+    return BeginNestedMessage<T>(7);
+  }
+
+
+  using FieldMetadata_WriteIntoFile =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_WriteIntoFile kWriteIntoFile{};
+  void set_write_into_file(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_WriteIntoFile::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OutputPath =
+    ::protozero::proto_utils::FieldMetadata<
+      29,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_OutputPath kOutputPath{};
+  void set_output_path(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_OutputPath::kFieldId, data, size);
+  }
+  void set_output_path(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_OutputPath::kFieldId, chars.data, chars.size);
+  }
+  void set_output_path(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_OutputPath::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FileWritePeriodMs =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_FileWritePeriodMs kFileWritePeriodMs{};
+  void set_file_write_period_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FileWritePeriodMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MaxFileSizeBytes =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_MaxFileSizeBytes kMaxFileSizeBytes{};
+  void set_max_file_size_bytes(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MaxFileSizeBytes::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_GuardrailOverrides =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TraceConfig_GuardrailOverrides,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_GuardrailOverrides kGuardrailOverrides{};
+  template <typename T = TraceConfig_GuardrailOverrides> T* set_guardrail_overrides() {
+    return BeginNestedMessage<T>(11);
+  }
+
+
+  using FieldMetadata_DeferredStart =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_DeferredStart kDeferredStart{};
+  void set_deferred_start(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DeferredStart::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FlushPeriodMs =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_FlushPeriodMs kFlushPeriodMs{};
+  void set_flush_period_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FlushPeriodMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FlushTimeoutMs =
+    ::protozero::proto_utils::FieldMetadata<
+      14,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_FlushTimeoutMs kFlushTimeoutMs{};
+  void set_flush_timeout_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FlushTimeoutMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DataSourceStopTimeoutMs =
+    ::protozero::proto_utils::FieldMetadata<
+      23,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_DataSourceStopTimeoutMs kDataSourceStopTimeoutMs{};
+  void set_data_source_stop_timeout_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DataSourceStopTimeoutMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NotifyTraceur =
+    ::protozero::proto_utils::FieldMetadata<
+      16,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_NotifyTraceur kNotifyTraceur{};
+  void set_notify_traceur(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_NotifyTraceur::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BugreportScore =
+    ::protozero::proto_utils::FieldMetadata<
+      30,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_BugreportScore kBugreportScore{};
+  void set_bugreport_score(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BugreportScore::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BugreportFilename =
+    ::protozero::proto_utils::FieldMetadata<
+      38,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_BugreportFilename kBugreportFilename{};
+  void set_bugreport_filename(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_BugreportFilename::kFieldId, data, size);
+  }
+  void set_bugreport_filename(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_BugreportFilename::kFieldId, chars.data, chars.size);
+  }
+  void set_bugreport_filename(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_BugreportFilename::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TriggerConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      17,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TraceConfig_TriggerConfig,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_TriggerConfig kTriggerConfig{};
+  template <typename T = TraceConfig_TriggerConfig> T* set_trigger_config() {
+    return BeginNestedMessage<T>(17);
+  }
+
+
+  using FieldMetadata_ActivateTriggers =
+    ::protozero::proto_utils::FieldMetadata<
+      18,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_ActivateTriggers kActivateTriggers{};
+  void add_activate_triggers(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ActivateTriggers::kFieldId, data, size);
+  }
+  void add_activate_triggers(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ActivateTriggers::kFieldId, chars.data, chars.size);
+  }
+  void add_activate_triggers(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ActivateTriggers::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IncrementalStateConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      21,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TraceConfig_IncrementalStateConfig,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_IncrementalStateConfig kIncrementalStateConfig{};
+  template <typename T = TraceConfig_IncrementalStateConfig> T* set_incremental_state_config() {
+    return BeginNestedMessage<T>(21);
+  }
+
+
+  using FieldMetadata_AllowUserBuildTracing =
+    ::protozero::proto_utils::FieldMetadata<
+      19,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_AllowUserBuildTracing kAllowUserBuildTracing{};
+  void set_allow_user_build_tracing(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_AllowUserBuildTracing::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_UniqueSessionName =
+    ::protozero::proto_utils::FieldMetadata<
+      22,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_UniqueSessionName kUniqueSessionName{};
+  void set_unique_session_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_UniqueSessionName::kFieldId, data, size);
+  }
+  void set_unique_session_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_UniqueSessionName::kFieldId, chars.data, chars.size);
+  }
+  void set_unique_session_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_UniqueSessionName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CompressionType =
+    ::protozero::proto_utils::FieldMetadata<
+      24,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      TraceConfig_CompressionType,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_CompressionType kCompressionType{};
+  void set_compression_type(TraceConfig_CompressionType value) {
+    static constexpr uint32_t field_id = FieldMetadata_CompressionType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IncidentReportConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      25,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TraceConfig_IncidentReportConfig,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_IncidentReportConfig kIncidentReportConfig{};
+  template <typename T = TraceConfig_IncidentReportConfig> T* set_incident_report_config() {
+    return BeginNestedMessage<T>(25);
+  }
+
+
+  using FieldMetadata_StatsdLogging =
+    ::protozero::proto_utils::FieldMetadata<
+      31,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      TraceConfig_StatsdLogging,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_StatsdLogging kStatsdLogging{};
+  void set_statsd_logging(TraceConfig_StatsdLogging value) {
+    static constexpr uint32_t field_id = FieldMetadata_StatsdLogging::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TraceUuidMsb =
+    ::protozero::proto_utils::FieldMetadata<
+      27,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_TraceUuidMsb kTraceUuidMsb{};
+  void set_trace_uuid_msb(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TraceUuidMsb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TraceUuidLsb =
+    ::protozero::proto_utils::FieldMetadata<
+      28,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_TraceUuidLsb kTraceUuidLsb{};
+  void set_trace_uuid_lsb(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TraceUuidLsb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TraceFilter =
+    ::protozero::proto_utils::FieldMetadata<
+      33,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TraceConfig_TraceFilter,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_TraceFilter kTraceFilter{};
+  template <typename T = TraceConfig_TraceFilter> T* set_trace_filter() {
+    return BeginNestedMessage<T>(33);
+  }
+
+
+  using FieldMetadata_AndroidReportConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      34,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TraceConfig_AndroidReportConfig,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_AndroidReportConfig kAndroidReportConfig{};
+  template <typename T = TraceConfig_AndroidReportConfig> T* set_android_report_config() {
+    return BeginNestedMessage<T>(34);
+  }
+
+
+  using FieldMetadata_CmdTraceStartDelay =
+    ::protozero::proto_utils::FieldMetadata<
+      35,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TraceConfig_CmdTraceStartDelay,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_CmdTraceStartDelay kCmdTraceStartDelay{};
+  template <typename T = TraceConfig_CmdTraceStartDelay> T* set_cmd_trace_start_delay() {
+    return BeginNestedMessage<T>(35);
+  }
+
+
+  using FieldMetadata_SessionSemaphores =
+    ::protozero::proto_utils::FieldMetadata<
+      39,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TraceConfig_SessionSemaphore,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_SessionSemaphores kSessionSemaphores{};
+  template <typename T = TraceConfig_SessionSemaphore> T* add_session_semaphores() {
+    return BeginNestedMessage<T>(39);
+  }
+
+
+  using FieldMetadata_PriorityBoost =
+    ::protozero::proto_utils::FieldMetadata<
+      40,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PriorityBoostConfig,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_PriorityBoost kPriorityBoost{};
+  template <typename T = PriorityBoostConfig> T* set_priority_boost() {
+    return BeginNestedMessage<T>(40);
+  }
+
+
+  using FieldMetadata_ExclusivePrio =
+    ::protozero::proto_utils::FieldMetadata<
+      41,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_ExclusivePrio kExclusivePrio{};
+  void set_exclusive_prio(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ExclusivePrio::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_WriteFlushMode =
+    ::protozero::proto_utils::FieldMetadata<
+      44,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      TraceConfig_WriteFlushMode,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_WriteFlushMode kWriteFlushMode{};
+  void set_write_flush_mode(TraceConfig_WriteFlushMode value) {
+    static constexpr uint32_t field_id = FieldMetadata_WriteFlushMode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FflushPostWrite =
+    ::protozero::proto_utils::FieldMetadata<
+      45,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      TraceConfig_FFlushMode,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_FflushPostWrite kFflushPostWrite{};
+  void set_fflush_post_write(TraceConfig_FFlushMode value) {
+    static constexpr uint32_t field_id = FieldMetadata_FflushPostWrite::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TraceAllMachines =
+    ::protozero::proto_utils::FieldMetadata<
+      43,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_TraceAllMachines kTraceAllMachines{};
+  void set_trace_all_machines(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_TraceAllMachines::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Notes =
+    ::protozero::proto_utils::FieldMetadata<
+      46,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TraceConfig_Note,
+      TraceConfig>;
+
+  static constexpr FieldMetadata_Notes kNotes{};
+  template <typename T = TraceConfig_Note> T* add_notes() {
+    return BeginNestedMessage<T>(46);
+  }
+
+};
+
+class TraceConfig_Note_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  TraceConfig_Note_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceConfig_Note_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceConfig_Note_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_key() const { return at<1>().valid(); }
+  ::protozero::ConstChars key() const { return at<1>().as_string(); }
+  bool has_value() const { return at<2>().valid(); }
+  ::protozero::ConstChars value() const { return at<2>().as_string(); }
+};
+
+class TraceConfig_Note : public ::protozero::Message {
+ public:
+  using Decoder = TraceConfig_Note_Decoder;
+  enum : int32_t {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.Note"; }
+
+
+  using FieldMetadata_Key =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TraceConfig_Note>;
+
+  static constexpr FieldMetadata_Key kKey{};
+  void set_key(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Key::kFieldId, data, size);
+  }
+  void set_key(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Key::kFieldId, chars.data, chars.size);
+  }
+  void set_key(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TraceConfig_Note>;
+
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
+  }
+  void set_value(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
+  }
+  void set_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class TraceConfig_SessionSemaphore_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  TraceConfig_SessionSemaphore_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceConfig_SessionSemaphore_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceConfig_SessionSemaphore_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_max_other_session_count() const { return at<2>().valid(); }
+  uint64_t max_other_session_count() const { return at<2>().as_uint64(); }
+};
+
+class TraceConfig_SessionSemaphore : public ::protozero::Message {
+ public:
+  using Decoder = TraceConfig_SessionSemaphore_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kMaxOtherSessionCountFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.SessionSemaphore"; }
+
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TraceConfig_SessionSemaphore>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MaxOtherSessionCount =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TraceConfig_SessionSemaphore>;
+
+  static constexpr FieldMetadata_MaxOtherSessionCount kMaxOtherSessionCount{};
+  void set_max_other_session_count(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MaxOtherSessionCount::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class TraceConfig_CmdTraceStartDelay_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  TraceConfig_CmdTraceStartDelay_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceConfig_CmdTraceStartDelay_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceConfig_CmdTraceStartDelay_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_min_delay_ms() const { return at<1>().valid(); }
+  uint32_t min_delay_ms() const { return at<1>().as_uint32(); }
+  bool has_max_delay_ms() const { return at<2>().valid(); }
+  uint32_t max_delay_ms() const { return at<2>().as_uint32(); }
+};
+
+class TraceConfig_CmdTraceStartDelay : public ::protozero::Message {
+ public:
+  using Decoder = TraceConfig_CmdTraceStartDelay_Decoder;
+  enum : int32_t {
+    kMinDelayMsFieldNumber = 1,
+    kMaxDelayMsFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.CmdTraceStartDelay"; }
+
+
+  using FieldMetadata_MinDelayMs =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TraceConfig_CmdTraceStartDelay>;
+
+  static constexpr FieldMetadata_MinDelayMs kMinDelayMs{};
+  void set_min_delay_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MinDelayMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MaxDelayMs =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TraceConfig_CmdTraceStartDelay>;
+
+  static constexpr FieldMetadata_MaxDelayMs kMaxDelayMs{};
+  void set_max_delay_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MaxDelayMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class TraceConfig_AndroidReportConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  TraceConfig_AndroidReportConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceConfig_AndroidReportConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceConfig_AndroidReportConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_reporter_service_package() const { return at<1>().valid(); }
+  ::protozero::ConstChars reporter_service_package() const { return at<1>().as_string(); }
+  bool has_reporter_service_class() const { return at<2>().valid(); }
+  ::protozero::ConstChars reporter_service_class() const { return at<2>().as_string(); }
+  bool has_skip_report() const { return at<3>().valid(); }
+  bool skip_report() const { return at<3>().as_bool(); }
+  bool has_use_pipe_in_framework_for_testing() const { return at<4>().valid(); }
+  bool use_pipe_in_framework_for_testing() const { return at<4>().as_bool(); }
+};
+
+class TraceConfig_AndroidReportConfig : public ::protozero::Message {
+ public:
+  using Decoder = TraceConfig_AndroidReportConfig_Decoder;
+  enum : int32_t {
+    kReporterServicePackageFieldNumber = 1,
+    kReporterServiceClassFieldNumber = 2,
+    kSkipReportFieldNumber = 3,
+    kUsePipeInFrameworkForTestingFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.AndroidReportConfig"; }
+
+
+  using FieldMetadata_ReporterServicePackage =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TraceConfig_AndroidReportConfig>;
+
+  static constexpr FieldMetadata_ReporterServicePackage kReporterServicePackage{};
+  void set_reporter_service_package(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ReporterServicePackage::kFieldId, data, size);
+  }
+  void set_reporter_service_package(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ReporterServicePackage::kFieldId, chars.data, chars.size);
+  }
+  void set_reporter_service_package(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReporterServicePackage::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ReporterServiceClass =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TraceConfig_AndroidReportConfig>;
+
+  static constexpr FieldMetadata_ReporterServiceClass kReporterServiceClass{};
+  void set_reporter_service_class(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ReporterServiceClass::kFieldId, data, size);
+  }
+  void set_reporter_service_class(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ReporterServiceClass::kFieldId, chars.data, chars.size);
+  }
+  void set_reporter_service_class(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReporterServiceClass::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SkipReport =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TraceConfig_AndroidReportConfig>;
+
+  static constexpr FieldMetadata_SkipReport kSkipReport{};
+  void set_skip_report(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_SkipReport::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_UsePipeInFrameworkForTesting =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TraceConfig_AndroidReportConfig>;
+
+  static constexpr FieldMetadata_UsePipeInFrameworkForTesting kUsePipeInFrameworkForTesting{};
+  void set_use_pipe_in_framework_for_testing(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_UsePipeInFrameworkForTesting::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class TraceConfig_TraceFilter_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  TraceConfig_TraceFilter_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceConfig_TraceFilter_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceConfig_TraceFilter_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_bytecode() const { return at<1>().valid(); }
+  ::protozero::ConstBytes bytecode() const { return at<1>().as_bytes(); }
+  bool has_bytecode_v2() const { return at<2>().valid(); }
+  ::protozero::ConstBytes bytecode_v2() const { return at<2>().as_bytes(); }
+  bool has_string_filter_chain() const { return at<3>().valid(); }
+  ::protozero::ConstBytes string_filter_chain() const { return at<3>().as_bytes(); }
+  bool has_bytecode_overlay_v54() const { return at<4>().valid(); }
+  ::protozero::ConstBytes bytecode_overlay_v54() const { return at<4>().as_bytes(); }
+  bool has_string_filter_chain_v54() const { return at<5>().valid(); }
+  ::protozero::ConstBytes string_filter_chain_v54() const { return at<5>().as_bytes(); }
+};
+
+class TraceConfig_TraceFilter : public ::protozero::Message {
+ public:
+  using Decoder = TraceConfig_TraceFilter_Decoder;
+  enum : int32_t {
+    kBytecodeFieldNumber = 1,
+    kBytecodeV2FieldNumber = 2,
+    kStringFilterChainFieldNumber = 3,
+    kBytecodeOverlayV54FieldNumber = 4,
+    kStringFilterChainV54FieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.TraceFilter"; }
+
+  using StringFilterRule = ::perfetto::protos::pbzero::TraceConfig_TraceFilter_StringFilterRule;
+  using StringFilterChain = ::perfetto::protos::pbzero::TraceConfig_TraceFilter_StringFilterChain;
+
+  using StringFilterPolicy = ::perfetto::protos::pbzero::TraceConfig_TraceFilter_StringFilterPolicy;
+  static inline const char* StringFilterPolicy_Name(StringFilterPolicy value) {
+    return ::perfetto::protos::pbzero::TraceConfig_TraceFilter_StringFilterPolicy_Name(value);
+  }
+  static inline const StringFilterPolicy SFP_UNSPECIFIED = StringFilterPolicy::SFP_UNSPECIFIED;
+  static inline const StringFilterPolicy SFP_MATCH_REDACT_GROUPS = StringFilterPolicy::SFP_MATCH_REDACT_GROUPS;
+  static inline const StringFilterPolicy SFP_ATRACE_MATCH_REDACT_GROUPS = StringFilterPolicy::SFP_ATRACE_MATCH_REDACT_GROUPS;
+  static inline const StringFilterPolicy SFP_MATCH_BREAK = StringFilterPolicy::SFP_MATCH_BREAK;
+  static inline const StringFilterPolicy SFP_ATRACE_MATCH_BREAK = StringFilterPolicy::SFP_ATRACE_MATCH_BREAK;
+  static inline const StringFilterPolicy SFP_ATRACE_REPEATED_SEARCH_REDACT_GROUPS = StringFilterPolicy::SFP_ATRACE_REPEATED_SEARCH_REDACT_GROUPS;
+
+  using FieldMetadata_Bytecode =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      TraceConfig_TraceFilter>;
+
+  static constexpr FieldMetadata_Bytecode kBytecode{};
+  void set_bytecode(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_Bytecode::kFieldId, data, size);
+  }
+  void set_bytecode(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_Bytecode::kFieldId, bytes.data, bytes.size);
+  }
+  void set_bytecode(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Bytecode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BytecodeV2 =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      TraceConfig_TraceFilter>;
+
+  static constexpr FieldMetadata_BytecodeV2 kBytecodeV2{};
+  void set_bytecode_v2(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_BytecodeV2::kFieldId, data, size);
+  }
+  void set_bytecode_v2(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_BytecodeV2::kFieldId, bytes.data, bytes.size);
+  }
+  void set_bytecode_v2(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_BytecodeV2::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StringFilterChain =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TraceConfig_TraceFilter_StringFilterChain,
+      TraceConfig_TraceFilter>;
+
+  static constexpr FieldMetadata_StringFilterChain kStringFilterChain{};
+  template <typename T = TraceConfig_TraceFilter_StringFilterChain> T* set_string_filter_chain() {
+    return BeginNestedMessage<T>(3);
+  }
+
+
+  using FieldMetadata_BytecodeOverlayV54 =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      TraceConfig_TraceFilter>;
+
+  static constexpr FieldMetadata_BytecodeOverlayV54 kBytecodeOverlayV54{};
+  void set_bytecode_overlay_v54(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_BytecodeOverlayV54::kFieldId, data, size);
+  }
+  void set_bytecode_overlay_v54(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_BytecodeOverlayV54::kFieldId, bytes.data, bytes.size);
+  }
+  void set_bytecode_overlay_v54(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_BytecodeOverlayV54::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StringFilterChainV54 =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TraceConfig_TraceFilter_StringFilterChain,
+      TraceConfig_TraceFilter>;
+
+  static constexpr FieldMetadata_StringFilterChainV54 kStringFilterChainV54{};
+  template <typename T = TraceConfig_TraceFilter_StringFilterChain> T* set_string_filter_chain_v54() {
+    return BeginNestedMessage<T>(5);
+  }
+
+};
+
+class TraceConfig_TraceFilter_StringFilterChain_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  TraceConfig_TraceFilter_StringFilterChain_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceConfig_TraceFilter_StringFilterChain_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceConfig_TraceFilter_StringFilterChain_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_rules() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> rules() const { return GetRepeated<::protozero::ConstBytes>(1); }
+};
+
+class TraceConfig_TraceFilter_StringFilterChain : public ::protozero::Message {
+ public:
+  using Decoder = TraceConfig_TraceFilter_StringFilterChain_Decoder;
+  enum : int32_t {
+    kRulesFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.TraceFilter.StringFilterChain"; }
+
+
+  using FieldMetadata_Rules =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TraceConfig_TraceFilter_StringFilterRule,
+      TraceConfig_TraceFilter_StringFilterChain>;
+
+  static constexpr FieldMetadata_Rules kRules{};
+  template <typename T = TraceConfig_TraceFilter_StringFilterRule> T* add_rules() {
+    return BeginNestedMessage<T>(1);
+  }
+
+};
+
+class TraceConfig_TraceFilter_StringFilterRule_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  TraceConfig_TraceFilter_StringFilterRule_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceConfig_TraceFilter_StringFilterRule_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceConfig_TraceFilter_StringFilterRule_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_policy() const { return at<1>().valid(); }
+  int32_t policy() const { return at<1>().as_int32(); }
+  bool has_regex_pattern() const { return at<2>().valid(); }
+  ::protozero::ConstChars regex_pattern() const { return at<2>().as_string(); }
+  bool has_atrace_payload_starts_with() const { return at<3>().valid(); }
+  ::protozero::ConstChars atrace_payload_starts_with() const { return at<3>().as_string(); }
+  bool has_name() const { return at<4>().valid(); }
+  ::protozero::ConstChars name() const { return at<4>().as_string(); }
+  bool has_semantic_type() const { return at<5>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> semantic_type() const { return GetRepeated<int32_t>(5); }
+};
+
+class TraceConfig_TraceFilter_StringFilterRule : public ::protozero::Message {
+ public:
+  using Decoder = TraceConfig_TraceFilter_StringFilterRule_Decoder;
+  enum : int32_t {
+    kPolicyFieldNumber = 1,
+    kRegexPatternFieldNumber = 2,
+    kAtracePayloadStartsWithFieldNumber = 3,
+    kNameFieldNumber = 4,
+    kSemanticTypeFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.TraceFilter.StringFilterRule"; }
+
+
+  using FieldMetadata_Policy =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      TraceConfig_TraceFilter_StringFilterPolicy,
+      TraceConfig_TraceFilter_StringFilterRule>;
+
+  static constexpr FieldMetadata_Policy kPolicy{};
+  void set_policy(TraceConfig_TraceFilter_StringFilterPolicy value) {
+    static constexpr uint32_t field_id = FieldMetadata_Policy::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_RegexPattern =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TraceConfig_TraceFilter_StringFilterRule>;
+
+  static constexpr FieldMetadata_RegexPattern kRegexPattern{};
+  void set_regex_pattern(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_RegexPattern::kFieldId, data, size);
+  }
+  void set_regex_pattern(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_RegexPattern::kFieldId, chars.data, chars.size);
+  }
+  void set_regex_pattern(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_RegexPattern::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_AtracePayloadStartsWith =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TraceConfig_TraceFilter_StringFilterRule>;
+
+  static constexpr FieldMetadata_AtracePayloadStartsWith kAtracePayloadStartsWith{};
+  void set_atrace_payload_starts_with(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_AtracePayloadStartsWith::kFieldId, data, size);
+  }
+  void set_atrace_payload_starts_with(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_AtracePayloadStartsWith::kFieldId, chars.data, chars.size);
+  }
+  void set_atrace_payload_starts_with(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_AtracePayloadStartsWith::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TraceConfig_TraceFilter_StringFilterRule>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SemanticType =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      SemanticType,
+      TraceConfig_TraceFilter_StringFilterRule>;
+
+  static constexpr FieldMetadata_SemanticType kSemanticType{};
+  void add_semantic_type(SemanticType value) {
+    static constexpr uint32_t field_id = FieldMetadata_SemanticType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class TraceConfig_IncidentReportConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  TraceConfig_IncidentReportConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceConfig_IncidentReportConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceConfig_IncidentReportConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_destination_package() const { return at<1>().valid(); }
+  ::protozero::ConstChars destination_package() const { return at<1>().as_string(); }
+  bool has_destination_class() const { return at<2>().valid(); }
+  ::protozero::ConstChars destination_class() const { return at<2>().as_string(); }
+  bool has_privacy_level() const { return at<3>().valid(); }
+  int32_t privacy_level() const { return at<3>().as_int32(); }
+  bool has_skip_incidentd() const { return at<5>().valid(); }
+  bool skip_incidentd() const { return at<5>().as_bool(); }
+  bool has_skip_dropbox() const { return at<4>().valid(); }
+  bool skip_dropbox() const { return at<4>().as_bool(); }
+};
+
+class TraceConfig_IncidentReportConfig : public ::protozero::Message {
+ public:
+  using Decoder = TraceConfig_IncidentReportConfig_Decoder;
+  enum : int32_t {
+    kDestinationPackageFieldNumber = 1,
+    kDestinationClassFieldNumber = 2,
+    kPrivacyLevelFieldNumber = 3,
+    kSkipIncidentdFieldNumber = 5,
+    kSkipDropboxFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.IncidentReportConfig"; }
+
+
+  using FieldMetadata_DestinationPackage =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TraceConfig_IncidentReportConfig>;
+
+  static constexpr FieldMetadata_DestinationPackage kDestinationPackage{};
+  void set_destination_package(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_DestinationPackage::kFieldId, data, size);
+  }
+  void set_destination_package(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_DestinationPackage::kFieldId, chars.data, chars.size);
+  }
+  void set_destination_package(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_DestinationPackage::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DestinationClass =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TraceConfig_IncidentReportConfig>;
+
+  static constexpr FieldMetadata_DestinationClass kDestinationClass{};
+  void set_destination_class(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_DestinationClass::kFieldId, data, size);
+  }
+  void set_destination_class(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_DestinationClass::kFieldId, chars.data, chars.size);
+  }
+  void set_destination_class(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_DestinationClass::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PrivacyLevel =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TraceConfig_IncidentReportConfig>;
+
+  static constexpr FieldMetadata_PrivacyLevel kPrivacyLevel{};
+  void set_privacy_level(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PrivacyLevel::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SkipIncidentd =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TraceConfig_IncidentReportConfig>;
+
+  static constexpr FieldMetadata_SkipIncidentd kSkipIncidentd{};
+  void set_skip_incidentd(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_SkipIncidentd::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SkipDropbox =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TraceConfig_IncidentReportConfig>;
+
+  static constexpr FieldMetadata_SkipDropbox kSkipDropbox{};
+  void set_skip_dropbox(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_SkipDropbox::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class TraceConfig_IncrementalStateConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  TraceConfig_IncrementalStateConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceConfig_IncrementalStateConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceConfig_IncrementalStateConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_clear_period_ms() const { return at<1>().valid(); }
+  uint32_t clear_period_ms() const { return at<1>().as_uint32(); }
+};
+
+class TraceConfig_IncrementalStateConfig : public ::protozero::Message {
+ public:
+  using Decoder = TraceConfig_IncrementalStateConfig_Decoder;
+  enum : int32_t {
+    kClearPeriodMsFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.IncrementalStateConfig"; }
+
+
+  using FieldMetadata_ClearPeriodMs =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TraceConfig_IncrementalStateConfig>;
+
+  static constexpr FieldMetadata_ClearPeriodMs kClearPeriodMs{};
+  void set_clear_period_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ClearPeriodMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class TraceConfig_TriggerConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  TraceConfig_TriggerConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceConfig_TriggerConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceConfig_TriggerConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_trigger_mode() const { return at<1>().valid(); }
+  int32_t trigger_mode() const { return at<1>().as_int32(); }
+  bool has_use_clone_snapshot_if_available() const { return at<5>().valid(); }
+  bool use_clone_snapshot_if_available() const { return at<5>().as_bool(); }
+  bool has_triggers() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> triggers() const { return GetRepeated<::protozero::ConstBytes>(2); }
+  bool has_trigger_timeout_ms() const { return at<3>().valid(); }
+  uint32_t trigger_timeout_ms() const { return at<3>().as_uint32(); }
+};
+
+class TraceConfig_TriggerConfig : public ::protozero::Message {
+ public:
+  using Decoder = TraceConfig_TriggerConfig_Decoder;
+  enum : int32_t {
+    kTriggerModeFieldNumber = 1,
+    kUseCloneSnapshotIfAvailableFieldNumber = 5,
+    kTriggersFieldNumber = 2,
+    kTriggerTimeoutMsFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.TriggerConfig"; }
+
+  using Trigger = ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_Trigger;
+
+  using TriggerMode = ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode;
+  static inline const char* TriggerMode_Name(TriggerMode value) {
+    return ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode_Name(value);
+  }
+  static inline const TriggerMode UNSPECIFIED = TriggerMode::UNSPECIFIED;
+  static inline const TriggerMode START_TRACING = TriggerMode::START_TRACING;
+  static inline const TriggerMode STOP_TRACING = TriggerMode::STOP_TRACING;
+  static inline const TriggerMode CLONE_SNAPSHOT = TriggerMode::CLONE_SNAPSHOT;
+
+  using FieldMetadata_TriggerMode =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      TraceConfig_TriggerConfig_TriggerMode,
+      TraceConfig_TriggerConfig>;
+
+  static constexpr FieldMetadata_TriggerMode kTriggerMode{};
+  void set_trigger_mode(TraceConfig_TriggerConfig_TriggerMode value) {
+    static constexpr uint32_t field_id = FieldMetadata_TriggerMode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_UseCloneSnapshotIfAvailable =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TraceConfig_TriggerConfig>;
+
+  static constexpr FieldMetadata_UseCloneSnapshotIfAvailable kUseCloneSnapshotIfAvailable{};
+  void set_use_clone_snapshot_if_available(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_UseCloneSnapshotIfAvailable::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Triggers =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TraceConfig_TriggerConfig_Trigger,
+      TraceConfig_TriggerConfig>;
+
+  static constexpr FieldMetadata_Triggers kTriggers{};
+  template <typename T = TraceConfig_TriggerConfig_Trigger> T* add_triggers() {
+    return BeginNestedMessage<T>(2);
+  }
+
+
+  using FieldMetadata_TriggerTimeoutMs =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TraceConfig_TriggerConfig>;
+
+  static constexpr FieldMetadata_TriggerTimeoutMs kTriggerTimeoutMs{};
+  void set_trigger_timeout_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TriggerTimeoutMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class TraceConfig_TriggerConfig_Trigger_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  TraceConfig_TriggerConfig_Trigger_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceConfig_TriggerConfig_Trigger_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceConfig_TriggerConfig_Trigger_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_producer_name_regex() const { return at<2>().valid(); }
+  ::protozero::ConstChars producer_name_regex() const { return at<2>().as_string(); }
+  bool has_stop_delay_ms() const { return at<3>().valid(); }
+  uint32_t stop_delay_ms() const { return at<3>().as_uint32(); }
+  bool has_max_per_24_h() const { return at<4>().valid(); }
+  uint32_t max_per_24_h() const { return at<4>().as_uint32(); }
+  bool has_skip_probability() const { return at<5>().valid(); }
+  double skip_probability() const { return at<5>().as_double(); }
+};
+
+class TraceConfig_TriggerConfig_Trigger : public ::protozero::Message {
+ public:
+  using Decoder = TraceConfig_TriggerConfig_Trigger_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kProducerNameRegexFieldNumber = 2,
+    kStopDelayMsFieldNumber = 3,
+    kMaxPer24HFieldNumber = 4,
+    kSkipProbabilityFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.TriggerConfig.Trigger"; }
+
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TraceConfig_TriggerConfig_Trigger>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ProducerNameRegex =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TraceConfig_TriggerConfig_Trigger>;
+
+  static constexpr FieldMetadata_ProducerNameRegex kProducerNameRegex{};
+  void set_producer_name_regex(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ProducerNameRegex::kFieldId, data, size);
+  }
+  void set_producer_name_regex(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ProducerNameRegex::kFieldId, chars.data, chars.size);
+  }
+  void set_producer_name_regex(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProducerNameRegex::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StopDelayMs =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TraceConfig_TriggerConfig_Trigger>;
+
+  static constexpr FieldMetadata_StopDelayMs kStopDelayMs{};
+  void set_stop_delay_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StopDelayMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MaxPer24H =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TraceConfig_TriggerConfig_Trigger>;
+
+  static constexpr FieldMetadata_MaxPer24H kMaxPer24H{};
+  void set_max_per_24_h(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MaxPer24H::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SkipProbability =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kDouble,
+      double,
+      TraceConfig_TriggerConfig_Trigger>;
+
+  static constexpr FieldMetadata_SkipProbability kSkipProbability{};
+  void set_skip_probability(double value) {
+    static constexpr uint32_t field_id = FieldMetadata_SkipProbability::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class TraceConfig_GuardrailOverrides_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  TraceConfig_GuardrailOverrides_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceConfig_GuardrailOverrides_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceConfig_GuardrailOverrides_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_max_upload_per_day_bytes() const { return at<1>().valid(); }
+  uint64_t max_upload_per_day_bytes() const { return at<1>().as_uint64(); }
+  bool has_max_tracing_buffer_size_kb() const { return at<2>().valid(); }
+  uint32_t max_tracing_buffer_size_kb() const { return at<2>().as_uint32(); }
+};
+
+class TraceConfig_GuardrailOverrides : public ::protozero::Message {
+ public:
+  using Decoder = TraceConfig_GuardrailOverrides_Decoder;
+  enum : int32_t {
+    kMaxUploadPerDayBytesFieldNumber = 1,
+    kMaxTracingBufferSizeKbFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.GuardrailOverrides"; }
+
+
+  using FieldMetadata_MaxUploadPerDayBytes =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TraceConfig_GuardrailOverrides>;
+
+  static constexpr FieldMetadata_MaxUploadPerDayBytes kMaxUploadPerDayBytes{};
+  void set_max_upload_per_day_bytes(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MaxUploadPerDayBytes::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MaxTracingBufferSizeKb =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TraceConfig_GuardrailOverrides>;
+
+  static constexpr FieldMetadata_MaxTracingBufferSizeKb kMaxTracingBufferSizeKb{};
+  void set_max_tracing_buffer_size_kb(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MaxTracingBufferSizeKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class TraceConfig_StatsdMetadata_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  TraceConfig_StatsdMetadata_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceConfig_StatsdMetadata_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceConfig_StatsdMetadata_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_triggering_alert_id() const { return at<1>().valid(); }
+  int64_t triggering_alert_id() const { return at<1>().as_int64(); }
+  bool has_triggering_config_uid() const { return at<2>().valid(); }
+  int32_t triggering_config_uid() const { return at<2>().as_int32(); }
+  bool has_triggering_config_id() const { return at<3>().valid(); }
+  int64_t triggering_config_id() const { return at<3>().as_int64(); }
+  bool has_triggering_subscription_id() const { return at<4>().valid(); }
+  int64_t triggering_subscription_id() const { return at<4>().as_int64(); }
+};
+
+class TraceConfig_StatsdMetadata : public ::protozero::Message {
+ public:
+  using Decoder = TraceConfig_StatsdMetadata_Decoder;
+  enum : int32_t {
+    kTriggeringAlertIdFieldNumber = 1,
+    kTriggeringConfigUidFieldNumber = 2,
+    kTriggeringConfigIdFieldNumber = 3,
+    kTriggeringSubscriptionIdFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.StatsdMetadata"; }
+
+
+  using FieldMetadata_TriggeringAlertId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      TraceConfig_StatsdMetadata>;
+
+  static constexpr FieldMetadata_TriggeringAlertId kTriggeringAlertId{};
+  void set_triggering_alert_id(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TriggeringAlertId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TriggeringConfigUid =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TraceConfig_StatsdMetadata>;
+
+  static constexpr FieldMetadata_TriggeringConfigUid kTriggeringConfigUid{};
+  void set_triggering_config_uid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TriggeringConfigUid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TriggeringConfigId =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      TraceConfig_StatsdMetadata>;
+
+  static constexpr FieldMetadata_TriggeringConfigId kTriggeringConfigId{};
+  void set_triggering_config_id(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TriggeringConfigId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TriggeringSubscriptionId =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      TraceConfig_StatsdMetadata>;
+
+  static constexpr FieldMetadata_TriggeringSubscriptionId kTriggeringSubscriptionId{};
+  void set_triggering_subscription_id(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TriggeringSubscriptionId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class TraceConfig_ProducerConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  TraceConfig_ProducerConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceConfig_ProducerConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceConfig_ProducerConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_producer_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars producer_name() const { return at<1>().as_string(); }
+  bool has_shm_size_kb() const { return at<2>().valid(); }
+  uint32_t shm_size_kb() const { return at<2>().as_uint32(); }
+  bool has_page_size_kb() const { return at<3>().valid(); }
+  uint32_t page_size_kb() const { return at<3>().as_uint32(); }
+};
+
+class TraceConfig_ProducerConfig : public ::protozero::Message {
+ public:
+  using Decoder = TraceConfig_ProducerConfig_Decoder;
+  enum : int32_t {
+    kProducerNameFieldNumber = 1,
+    kShmSizeKbFieldNumber = 2,
+    kPageSizeKbFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.ProducerConfig"; }
+
+
+  using FieldMetadata_ProducerName =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TraceConfig_ProducerConfig>;
+
+  static constexpr FieldMetadata_ProducerName kProducerName{};
+  void set_producer_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ProducerName::kFieldId, data, size);
+  }
+  void set_producer_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ProducerName::kFieldId, chars.data, chars.size);
+  }
+  void set_producer_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProducerName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ShmSizeKb =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TraceConfig_ProducerConfig>;
+
+  static constexpr FieldMetadata_ShmSizeKb kShmSizeKb{};
+  void set_shm_size_kb(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ShmSizeKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PageSizeKb =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TraceConfig_ProducerConfig>;
+
+  static constexpr FieldMetadata_PageSizeKb kPageSizeKb{};
+  void set_page_size_kb(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PageSizeKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class TraceConfig_BuiltinDataSource_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
+ public:
+  TraceConfig_BuiltinDataSource_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceConfig_BuiltinDataSource_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceConfig_BuiltinDataSource_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_disable_clock_snapshotting() const { return at<1>().valid(); }
+  bool disable_clock_snapshotting() const { return at<1>().as_bool(); }
+  bool has_disable_trace_config() const { return at<2>().valid(); }
+  bool disable_trace_config() const { return at<2>().as_bool(); }
+  bool has_disable_system_info() const { return at<3>().valid(); }
+  bool disable_system_info() const { return at<3>().as_bool(); }
+  bool has_disable_service_events() const { return at<4>().valid(); }
+  bool disable_service_events() const { return at<4>().as_bool(); }
+  bool has_primary_trace_clock() const { return at<5>().valid(); }
+  int32_t primary_trace_clock() const { return at<5>().as_int32(); }
+  bool has_snapshot_interval_ms() const { return at<6>().valid(); }
+  uint32_t snapshot_interval_ms() const { return at<6>().as_uint32(); }
+  bool has_prefer_suspend_clock_for_snapshot() const { return at<7>().valid(); }
+  bool prefer_suspend_clock_for_snapshot() const { return at<7>().as_bool(); }
+  bool has_disable_chunk_usage_histograms() const { return at<8>().valid(); }
+  bool disable_chunk_usage_histograms() const { return at<8>().as_bool(); }
+};
+
+class TraceConfig_BuiltinDataSource : public ::protozero::Message {
+ public:
+  using Decoder = TraceConfig_BuiltinDataSource_Decoder;
+  enum : int32_t {
+    kDisableClockSnapshottingFieldNumber = 1,
+    kDisableTraceConfigFieldNumber = 2,
+    kDisableSystemInfoFieldNumber = 3,
+    kDisableServiceEventsFieldNumber = 4,
+    kPrimaryTraceClockFieldNumber = 5,
+    kSnapshotIntervalMsFieldNumber = 6,
+    kPreferSuspendClockForSnapshotFieldNumber = 7,
+    kDisableChunkUsageHistogramsFieldNumber = 8,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.BuiltinDataSource"; }
+
+
+  using FieldMetadata_DisableClockSnapshotting =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TraceConfig_BuiltinDataSource>;
+
+  static constexpr FieldMetadata_DisableClockSnapshotting kDisableClockSnapshotting{};
+  void set_disable_clock_snapshotting(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DisableClockSnapshotting::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DisableTraceConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TraceConfig_BuiltinDataSource>;
+
+  static constexpr FieldMetadata_DisableTraceConfig kDisableTraceConfig{};
+  void set_disable_trace_config(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DisableTraceConfig::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DisableSystemInfo =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TraceConfig_BuiltinDataSource>;
+
+  static constexpr FieldMetadata_DisableSystemInfo kDisableSystemInfo{};
+  void set_disable_system_info(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DisableSystemInfo::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DisableServiceEvents =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TraceConfig_BuiltinDataSource>;
+
+  static constexpr FieldMetadata_DisableServiceEvents kDisableServiceEvents{};
+  void set_disable_service_events(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DisableServiceEvents::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PrimaryTraceClock =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      BuiltinClock,
+      TraceConfig_BuiltinDataSource>;
+
+  static constexpr FieldMetadata_PrimaryTraceClock kPrimaryTraceClock{};
+  void set_primary_trace_clock(BuiltinClock value) {
+    static constexpr uint32_t field_id = FieldMetadata_PrimaryTraceClock::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SnapshotIntervalMs =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TraceConfig_BuiltinDataSource>;
+
+  static constexpr FieldMetadata_SnapshotIntervalMs kSnapshotIntervalMs{};
+  void set_snapshot_interval_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SnapshotIntervalMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PreferSuspendClockForSnapshot =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TraceConfig_BuiltinDataSource>;
+
+  static constexpr FieldMetadata_PreferSuspendClockForSnapshot kPreferSuspendClockForSnapshot{};
+  void set_prefer_suspend_clock_for_snapshot(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_PreferSuspendClockForSnapshot::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DisableChunkUsageHistograms =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TraceConfig_BuiltinDataSource>;
+
+  static constexpr FieldMetadata_DisableChunkUsageHistograms kDisableChunkUsageHistograms{};
+  void set_disable_chunk_usage_histograms(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DisableChunkUsageHistograms::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class TraceConfig_DataSource_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  TraceConfig_DataSource_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceConfig_DataSource_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceConfig_DataSource_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_config() const { return at<1>().valid(); }
+  ::protozero::ConstBytes config() const { return at<1>().as_bytes(); }
+  bool has_producer_name_filter() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> producer_name_filter() const { return GetRepeated<::protozero::ConstChars>(2); }
+  bool has_producer_name_regex_filter() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> producer_name_regex_filter() const { return GetRepeated<::protozero::ConstChars>(3); }
+  bool has_machine_name_filter() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> machine_name_filter() const { return GetRepeated<::protozero::ConstChars>(4); }
+};
+
+class TraceConfig_DataSource : public ::protozero::Message {
+ public:
+  using Decoder = TraceConfig_DataSource_Decoder;
+  enum : int32_t {
+    kConfigFieldNumber = 1,
+    kProducerNameFilterFieldNumber = 2,
+    kProducerNameRegexFilterFieldNumber = 3,
+    kMachineNameFilterFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.DataSource"; }
+
+
+  using FieldMetadata_Config =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      DataSourceConfig,
+      TraceConfig_DataSource>;
+
+  static constexpr FieldMetadata_Config kConfig{};
+  template <typename T = DataSourceConfig> T* set_config() {
+    return BeginNestedMessage<T>(1);
+  }
+
+
+  using FieldMetadata_ProducerNameFilter =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TraceConfig_DataSource>;
+
+  static constexpr FieldMetadata_ProducerNameFilter kProducerNameFilter{};
+  void add_producer_name_filter(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ProducerNameFilter::kFieldId, data, size);
+  }
+  void add_producer_name_filter(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ProducerNameFilter::kFieldId, chars.data, chars.size);
+  }
+  void add_producer_name_filter(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProducerNameFilter::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ProducerNameRegexFilter =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TraceConfig_DataSource>;
+
+  static constexpr FieldMetadata_ProducerNameRegexFilter kProducerNameRegexFilter{};
+  void add_producer_name_regex_filter(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ProducerNameRegexFilter::kFieldId, data, size);
+  }
+  void add_producer_name_regex_filter(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ProducerNameRegexFilter::kFieldId, chars.data, chars.size);
+  }
+  void add_producer_name_regex_filter(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProducerNameRegexFilter::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MachineNameFilter =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TraceConfig_DataSource>;
+
+  static constexpr FieldMetadata_MachineNameFilter kMachineNameFilter{};
+  void add_machine_name_filter(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_MachineNameFilter::kFieldId, data, size);
+  }
+  void add_machine_name_filter(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_MachineNameFilter::kFieldId, chars.data, chars.size);
+  }
+  void add_machine_name_filter(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_MachineNameFilter::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class TraceConfig_BufferConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
+ public:
+  TraceConfig_BufferConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceConfig_BufferConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceConfig_BufferConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_size_kb() const { return at<1>().valid(); }
+  uint32_t size_kb() const { return at<1>().as_uint32(); }
+  bool has_fill_policy() const { return at<4>().valid(); }
+  int32_t fill_policy() const { return at<4>().as_int32(); }
+  bool has_transfer_on_clone() const { return at<5>().valid(); }
+  bool transfer_on_clone() const { return at<5>().as_bool(); }
+  bool has_clear_before_clone() const { return at<6>().valid(); }
+  bool clear_before_clone() const { return at<6>().as_bool(); }
+  bool has_name() const { return at<7>().valid(); }
+  ::protozero::ConstChars name() const { return at<7>().as_string(); }
+  bool has_experimental_mode() const { return at<8>().valid(); }
+  int32_t experimental_mode() const { return at<8>().as_int32(); }
+};
+
+class TraceConfig_BufferConfig : public ::protozero::Message {
+ public:
+  using Decoder = TraceConfig_BufferConfig_Decoder;
+  enum : int32_t {
+    kSizeKbFieldNumber = 1,
+    kFillPolicyFieldNumber = 4,
+    kTransferOnCloneFieldNumber = 5,
+    kClearBeforeCloneFieldNumber = 6,
+    kNameFieldNumber = 7,
+    kExperimentalModeFieldNumber = 8,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.BufferConfig"; }
+
+
+  using FillPolicy = ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy;
+  static inline const char* FillPolicy_Name(FillPolicy value) {
+    return ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy_Name(value);
+  }
+
+  using ExperimentalMode = ::perfetto::protos::pbzero::TraceConfig_BufferConfig_ExperimentalMode;
+  static inline const char* ExperimentalMode_Name(ExperimentalMode value) {
+    return ::perfetto::protos::pbzero::TraceConfig_BufferConfig_ExperimentalMode_Name(value);
+  }
+  static inline const FillPolicy UNSPECIFIED = FillPolicy::UNSPECIFIED;
+  static inline const FillPolicy RING_BUFFER = FillPolicy::RING_BUFFER;
+  static inline const FillPolicy DISCARD = FillPolicy::DISCARD;
+  static inline const ExperimentalMode MODE_UNSPECIFIED = ExperimentalMode::MODE_UNSPECIFIED;
+  static inline const ExperimentalMode TRACE_BUFFER_V2 = ExperimentalMode::TRACE_BUFFER_V2;
+  static inline const ExperimentalMode TRACE_BUFFER_V2_SHADOW_MODE = ExperimentalMode::TRACE_BUFFER_V2_SHADOW_MODE;
+
+  using FieldMetadata_SizeKb =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TraceConfig_BufferConfig>;
+
+  static constexpr FieldMetadata_SizeKb kSizeKb{};
+  void set_size_kb(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SizeKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FillPolicy =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      TraceConfig_BufferConfig_FillPolicy,
+      TraceConfig_BufferConfig>;
+
+  static constexpr FieldMetadata_FillPolicy kFillPolicy{};
+  void set_fill_policy(TraceConfig_BufferConfig_FillPolicy value) {
+    static constexpr uint32_t field_id = FieldMetadata_FillPolicy::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TransferOnClone =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TraceConfig_BufferConfig>;
+
+  static constexpr FieldMetadata_TransferOnClone kTransferOnClone{};
+  void set_transfer_on_clone(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_TransferOnClone::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ClearBeforeClone =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TraceConfig_BufferConfig>;
+
+  static constexpr FieldMetadata_ClearBeforeClone kClearBeforeClone{};
+  void set_clear_before_clone(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ClearBeforeClone::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TraceConfig_BufferConfig>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ExperimentalMode =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      TraceConfig_BufferConfig_ExperimentalMode,
+      TraceConfig_BufferConfig>;
+
+  static constexpr FieldMetadata_ExperimentalMode kExperimentalMode{};
+  void set_experimental_mode(TraceConfig_BufferConfig_ExperimentalMode value) {
+    static constexpr uint32_t field_id = FieldMetadata_ExperimentalMode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/clock_snapshot.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CLOCK_SNAPSHOT_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CLOCK_SNAPSHOT_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class ClockSnapshot_Clock;
+enum BuiltinClock : int32_t;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_ClockSnapshot_Clock {
+enum BuiltinClocks : int32_t {
+  UNKNOWN = 0,
+  REALTIME = 1,
+  REALTIME_COARSE = 2,
+  MONOTONIC = 3,
+  MONOTONIC_COARSE = 4,
+  MONOTONIC_RAW = 5,
+  BOOTTIME = 6,
+  BUILTIN_CLOCK_MAX_ID = 63,
+};
+} // namespace perfetto_pbzero_enum_ClockSnapshot_Clock
+using ClockSnapshot_Clock_BuiltinClocks = perfetto_pbzero_enum_ClockSnapshot_Clock::BuiltinClocks;
+
+
+constexpr ClockSnapshot_Clock_BuiltinClocks ClockSnapshot_Clock_BuiltinClocks_MIN = ClockSnapshot_Clock_BuiltinClocks::UNKNOWN;
+constexpr ClockSnapshot_Clock_BuiltinClocks ClockSnapshot_Clock_BuiltinClocks_MAX = ClockSnapshot_Clock_BuiltinClocks::BUILTIN_CLOCK_MAX_ID;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ClockSnapshot_Clock_BuiltinClocks_Name(::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::UNKNOWN:
+    return "UNKNOWN";
+
+  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::REALTIME:
+    return "REALTIME";
+
+  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::REALTIME_COARSE:
+    return "REALTIME_COARSE";
+
+  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::MONOTONIC:
+    return "MONOTONIC";
+
+  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::MONOTONIC_COARSE:
+    return "MONOTONIC_COARSE";
+
+  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::MONOTONIC_RAW:
+    return "MONOTONIC_RAW";
+
+  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::BOOTTIME:
+    return "BOOTTIME";
+
+  case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::BUILTIN_CLOCK_MAX_ID:
+    return "BUILTIN_CLOCK_MAX_ID";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class ClockSnapshot_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  ClockSnapshot_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ClockSnapshot_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ClockSnapshot_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_clocks() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> clocks() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  bool has_primary_trace_clock() const { return at<2>().valid(); }
+  int32_t primary_trace_clock() const { return at<2>().as_int32(); }
+};
+
+class ClockSnapshot : public ::protozero::Message {
+ public:
+  using Decoder = ClockSnapshot_Decoder;
+  enum : int32_t {
+    kClocksFieldNumber = 1,
+    kPrimaryTraceClockFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ClockSnapshot"; }
+
+  using Clock = ::perfetto::protos::pbzero::ClockSnapshot_Clock;
+
+  using FieldMetadata_Clocks =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ClockSnapshot_Clock,
+      ClockSnapshot>;
+
+  static constexpr FieldMetadata_Clocks kClocks{};
+  template <typename T = ClockSnapshot_Clock> T* add_clocks() {
+    return BeginNestedMessage<T>(1);
+  }
+
+
+  using FieldMetadata_PrimaryTraceClock =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      BuiltinClock,
+      ClockSnapshot>;
+
+  static constexpr FieldMetadata_PrimaryTraceClock kPrimaryTraceClock{};
+  void set_primary_trace_clock(BuiltinClock value) {
+    static constexpr uint32_t field_id = FieldMetadata_PrimaryTraceClock::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class ClockSnapshot_Clock_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  ClockSnapshot_Clock_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ClockSnapshot_Clock_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ClockSnapshot_Clock_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_clock_id() const { return at<1>().valid(); }
+  uint32_t clock_id() const { return at<1>().as_uint32(); }
+  bool has_timestamp() const { return at<2>().valid(); }
+  uint64_t timestamp() const { return at<2>().as_uint64(); }
+  bool has_is_incremental() const { return at<3>().valid(); }
+  bool is_incremental() const { return at<3>().as_bool(); }
+  bool has_unit_multiplier_ns() const { return at<4>().valid(); }
+  uint64_t unit_multiplier_ns() const { return at<4>().as_uint64(); }
+};
+
+class ClockSnapshot_Clock : public ::protozero::Message {
+ public:
+  using Decoder = ClockSnapshot_Clock_Decoder;
+  enum : int32_t {
+    kClockIdFieldNumber = 1,
+    kTimestampFieldNumber = 2,
+    kIsIncrementalFieldNumber = 3,
+    kUnitMultiplierNsFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ClockSnapshot.Clock"; }
+
+
+  using BuiltinClocks = ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks;
+  static inline const char* BuiltinClocks_Name(BuiltinClocks value) {
+    return ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks_Name(value);
+  }
+  static inline const BuiltinClocks UNKNOWN = BuiltinClocks::UNKNOWN;
+  static inline const BuiltinClocks REALTIME = BuiltinClocks::REALTIME;
+  static inline const BuiltinClocks REALTIME_COARSE = BuiltinClocks::REALTIME_COARSE;
+  static inline const BuiltinClocks MONOTONIC = BuiltinClocks::MONOTONIC;
+  static inline const BuiltinClocks MONOTONIC_COARSE = BuiltinClocks::MONOTONIC_COARSE;
+  static inline const BuiltinClocks MONOTONIC_RAW = BuiltinClocks::MONOTONIC_RAW;
+  static inline const BuiltinClocks BOOTTIME = BuiltinClocks::BOOTTIME;
+  static inline const BuiltinClocks BUILTIN_CLOCK_MAX_ID = BuiltinClocks::BUILTIN_CLOCK_MAX_ID;
+
+  using FieldMetadata_ClockId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ClockSnapshot_Clock>;
+
+  static constexpr FieldMetadata_ClockId kClockId{};
+  void set_clock_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ClockId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Timestamp =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ClockSnapshot_Clock>;
+
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IsIncremental =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ClockSnapshot_Clock>;
+
+  static constexpr FieldMetadata_IsIncremental kIsIncremental{};
+  void set_is_incremental(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsIncremental::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_UnitMultiplierNs =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ClockSnapshot_Clock>;
+
+  static constexpr FieldMetadata_UnitMultiplierNs kUnitMultiplierNs{};
+  void set_unit_multiplier_ns(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_UnitMultiplierNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/trace_uuid.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACE_UUID_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACE_UUID_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class TraceUuid_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  TraceUuid_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceUuid_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceUuid_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_msb() const { return at<1>().valid(); }
+  int64_t msb() const { return at<1>().as_int64(); }
+  bool has_lsb() const { return at<2>().valid(); }
+  int64_t lsb() const { return at<2>().as_int64(); }
+};
+
+class TraceUuid : public ::protozero::Message {
+ public:
+  using Decoder = TraceUuid_Decoder;
+  enum : int32_t {
+    kMsbFieldNumber = 1,
+    kLsbFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceUuid"; }
+
+
+  using FieldMetadata_Msb =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      TraceUuid>;
+
+  static constexpr FieldMetadata_Msb kMsb{};
+  void set_msb(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Msb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Lsb =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      TraceUuid>;
+
+  static constexpr FieldMetadata_Lsb kLsb{};
+  void set_lsb(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lsb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/trigger.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRIGGER_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRIGGER_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class Trigger_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  Trigger_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Trigger_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Trigger_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_trigger_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars trigger_name() const { return at<1>().as_string(); }
+  bool has_producer_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars producer_name() const { return at<2>().as_string(); }
+  bool has_trusted_producer_uid() const { return at<3>().valid(); }
+  int32_t trusted_producer_uid() const { return at<3>().as_int32(); }
+  bool has_stop_delay_ms() const { return at<4>().valid(); }
+  uint64_t stop_delay_ms() const { return at<4>().as_uint64(); }
+};
+
+class Trigger : public ::protozero::Message {
+ public:
+  using Decoder = Trigger_Decoder;
+  enum : int32_t {
+    kTriggerNameFieldNumber = 1,
+    kProducerNameFieldNumber = 2,
+    kTrustedProducerUidFieldNumber = 3,
+    kStopDelayMsFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Trigger"; }
+
+
+  using FieldMetadata_TriggerName =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      Trigger>;
+
+  static constexpr FieldMetadata_TriggerName kTriggerName{};
+  void set_trigger_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_TriggerName::kFieldId, data, size);
+  }
+  void set_trigger_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_TriggerName::kFieldId, chars.data, chars.size);
+  }
+  void set_trigger_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_TriggerName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ProducerName =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      Trigger>;
+
+  static constexpr FieldMetadata_ProducerName kProducerName{};
+  void set_producer_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ProducerName::kFieldId, data, size);
+  }
+  void set_producer_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ProducerName::kFieldId, chars.data, chars.size);
+  }
+  void set_producer_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProducerName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TrustedProducerUid =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Trigger>;
+
+  static constexpr FieldMetadata_TrustedProducerUid kTrustedProducerUid{};
+  void set_trusted_producer_uid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TrustedProducerUid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StopDelayMs =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Trigger>;
+
+  static constexpr FieldMetadata_StopDelayMs kStopDelayMs{};
+  void set_stop_delay_ms(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StopDelayMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/graphics/insets.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_GRAPHICS_INSETS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_GRAPHICS_INSETS_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class InsetsProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  InsetsProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit InsetsProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit InsetsProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_left() const { return at<1>().valid(); }
+  int32_t left() const { return at<1>().as_int32(); }
+  bool has_top() const { return at<2>().valid(); }
+  int32_t top() const { return at<2>().as_int32(); }
+  bool has_right() const { return at<3>().valid(); }
+  int32_t right() const { return at<3>().as_int32(); }
+  bool has_bottom() const { return at<4>().valid(); }
+  int32_t bottom() const { return at<4>().as_int32(); }
+};
+
+class InsetsProto : public ::protozero::Message {
+ public:
+  using Decoder = InsetsProto_Decoder;
+  enum : int32_t {
+    kLeftFieldNumber = 1,
+    kTopFieldNumber = 2,
+    kRightFieldNumber = 3,
+    kBottomFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.InsetsProto"; }
+
+
+  using FieldMetadata_Left =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      InsetsProto>;
+
+  static constexpr FieldMetadata_Left kLeft{};
+  void set_left(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Left::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Top =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      InsetsProto>;
+
+  static constexpr FieldMetadata_Top kTop{};
+  void set_top(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Top::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Right =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      InsetsProto>;
+
+  static constexpr FieldMetadata_Right kRight{};
+  void set_right(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Right::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Bottom =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      InsetsProto>;
+
+  static constexpr FieldMetadata_Bottom kBottom{};
+  void set_bottom(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Bottom::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/graphics/point.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_GRAPHICS_POINT_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_GRAPHICS_POINT_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class PointProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  PointProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PointProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PointProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_x() const { return at<1>().valid(); }
+  int32_t x() const { return at<1>().as_int32(); }
+  bool has_y() const { return at<2>().valid(); }
+  int32_t y() const { return at<2>().as_int32(); }
+};
+
+class PointProto : public ::protozero::Message {
+ public:
+  using Decoder = PointProto_Decoder;
+  enum : int32_t {
+    kXFieldNumber = 1,
+    kYFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.PointProto"; }
+
+
+  using FieldMetadata_X =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      PointProto>;
+
+  static constexpr FieldMetadata_X kX{};
+  void set_x(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_X::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Y =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      PointProto>;
+
+  static constexpr FieldMetadata_Y kY{};
+  void set_y(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Y::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/graphics/rect.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_GRAPHICS_RECT_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_GRAPHICS_RECT_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class RectProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  RectProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit RectProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit RectProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_left() const { return at<1>().valid(); }
+  int32_t left() const { return at<1>().as_int32(); }
+  bool has_top() const { return at<2>().valid(); }
+  int32_t top() const { return at<2>().as_int32(); }
+  bool has_right() const { return at<3>().valid(); }
+  int32_t right() const { return at<3>().as_int32(); }
+  bool has_bottom() const { return at<4>().valid(); }
+  int32_t bottom() const { return at<4>().as_int32(); }
+};
+
+class RectProto : public ::protozero::Message {
+ public:
+  using Decoder = RectProto_Decoder;
+  enum : int32_t {
+    kLeftFieldNumber = 1,
+    kTopFieldNumber = 2,
+    kRightFieldNumber = 3,
+    kBottomFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.RectProto"; }
+
+
+  using FieldMetadata_Left =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      RectProto>;
+
+  static constexpr FieldMetadata_Left kLeft{};
+  void set_left(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Left::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Top =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      RectProto>;
+
+  static constexpr FieldMetadata_Top kTop{};
+  void set_top(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Top::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Right =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      RectProto>;
+
+  static constexpr FieldMetadata_Right kRight{};
+  void set_right(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Right::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Bottom =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      RectProto>;
+
+  static constexpr FieldMetadata_Bottom kBottom{};
+  void set_bottom(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Bottom::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/winscope_extensions.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_WINSCOPE_EXTENSIONS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_WINSCOPE_EXTENSIONS_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class WinscopeExtensions_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
+ public:
+  WinscopeExtensions_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit WinscopeExtensions_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit WinscopeExtensions_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+};
+
+class WinscopeExtensions : public ::protozero::Message {
+ public:
+  using Decoder = WinscopeExtensions_Decoder;
+  static constexpr const char* GetName() { return ".perfetto.protos.WinscopeExtensions"; }
+
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/protolog.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_PROTOLOG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_PROTOLOG_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class ProtoLogViewerConfig_Group;
+class ProtoLogViewerConfig_MessageData;
+enum ProtoLogLevel : int32_t;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class ProtoLogViewerConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  ProtoLogViewerConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProtoLogViewerConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProtoLogViewerConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_messages() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> messages() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  bool has_groups() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> groups() const { return GetRepeated<::protozero::ConstBytes>(2); }
+};
+
+class ProtoLogViewerConfig : public ::protozero::Message {
+ public:
+  using Decoder = ProtoLogViewerConfig_Decoder;
+  enum : int32_t {
+    kMessagesFieldNumber = 1,
+    kGroupsFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ProtoLogViewerConfig"; }
+
+  using MessageData = ::perfetto::protos::pbzero::ProtoLogViewerConfig_MessageData;
+  using Group = ::perfetto::protos::pbzero::ProtoLogViewerConfig_Group;
+
+  using FieldMetadata_Messages =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ProtoLogViewerConfig_MessageData,
+      ProtoLogViewerConfig>;
+
+  static constexpr FieldMetadata_Messages kMessages{};
+  template <typename T = ProtoLogViewerConfig_MessageData> T* add_messages() {
+    return BeginNestedMessage<T>(1);
+  }
+
+
+  using FieldMetadata_Groups =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ProtoLogViewerConfig_Group,
+      ProtoLogViewerConfig>;
+
+  static constexpr FieldMetadata_Groups kGroups{};
+  template <typename T = ProtoLogViewerConfig_Group> T* add_groups() {
+    return BeginNestedMessage<T>(2);
+  }
+
+};
+
+class ProtoLogViewerConfig_Group_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  ProtoLogViewerConfig_Group_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProtoLogViewerConfig_Group_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProtoLogViewerConfig_Group_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  uint32_t id() const { return at<1>().as_uint32(); }
+  bool has_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars name() const { return at<2>().as_string(); }
+  bool has_tag() const { return at<3>().valid(); }
+  ::protozero::ConstChars tag() const { return at<3>().as_string(); }
+};
+
+class ProtoLogViewerConfig_Group : public ::protozero::Message {
+ public:
+  using Decoder = ProtoLogViewerConfig_Group_Decoder;
+  enum : int32_t {
+    kIdFieldNumber = 1,
+    kNameFieldNumber = 2,
+    kTagFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ProtoLogViewerConfig.Group"; }
+
+
+  using FieldMetadata_Id =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ProtoLogViewerConfig_Group>;
+
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ProtoLogViewerConfig_Group>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Tag =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ProtoLogViewerConfig_Group>;
+
+  static constexpr FieldMetadata_Tag kTag{};
+  void set_tag(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Tag::kFieldId, data, size);
+  }
+  void set_tag(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Tag::kFieldId, chars.data, chars.size);
+  }
+  void set_tag(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tag::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class ProtoLogViewerConfig_MessageData_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  ProtoLogViewerConfig_MessageData_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProtoLogViewerConfig_MessageData_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProtoLogViewerConfig_MessageData_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_message_id() const { return at<1>().valid(); }
+  uint64_t message_id() const { return at<1>().as_uint64(); }
+  bool has_message() const { return at<2>().valid(); }
+  ::protozero::ConstChars message() const { return at<2>().as_string(); }
+  bool has_level() const { return at<3>().valid(); }
+  int32_t level() const { return at<3>().as_int32(); }
+  bool has_group_id() const { return at<4>().valid(); }
+  uint32_t group_id() const { return at<4>().as_uint32(); }
+  bool has_location() const { return at<5>().valid(); }
+  ::protozero::ConstChars location() const { return at<5>().as_string(); }
+};
+
+class ProtoLogViewerConfig_MessageData : public ::protozero::Message {
+ public:
+  using Decoder = ProtoLogViewerConfig_MessageData_Decoder;
+  enum : int32_t {
+    kMessageIdFieldNumber = 1,
+    kMessageFieldNumber = 2,
+    kLevelFieldNumber = 3,
+    kGroupIdFieldNumber = 4,
+    kLocationFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ProtoLogViewerConfig.MessageData"; }
+
+
+  using FieldMetadata_MessageId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
+      uint64_t,
+      ProtoLogViewerConfig_MessageData>;
+
+  static constexpr FieldMetadata_MessageId kMessageId{};
+  void set_message_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MessageId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Message =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ProtoLogViewerConfig_MessageData>;
+
+  static constexpr FieldMetadata_Message kMessage{};
+  void set_message(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Message::kFieldId, data, size);
+  }
+  void set_message(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Message::kFieldId, chars.data, chars.size);
+  }
+  void set_message(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Message::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Level =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ProtoLogLevel,
+      ProtoLogViewerConfig_MessageData>;
+
+  static constexpr FieldMetadata_Level kLevel{};
+  void set_level(ProtoLogLevel value) {
+    static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_GroupId =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ProtoLogViewerConfig_MessageData>;
+
+  static constexpr FieldMetadata_GroupId kGroupId{};
+  void set_group_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GroupId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Location =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ProtoLogViewerConfig_MessageData>;
+
+  static constexpr FieldMetadata_Location kLocation{};
+  void set_location(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Location::kFieldId, data, size);
+  }
+  void set_location(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Location::kFieldId, chars.data, chars.size);
+  }
+  void set_location(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Location::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class ProtoLogMessage_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
+ public:
+  ProtoLogMessage_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProtoLogMessage_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProtoLogMessage_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_message_id() const { return at<1>().valid(); }
+  uint64_t message_id() const { return at<1>().as_uint64(); }
+  bool has_str_param_iids() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint32_t> str_param_iids() const { return GetRepeated<uint32_t>(2); }
+  bool has_sint64_params() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<int64_t> sint64_params() const { return GetRepeated<int64_t>(3); }
+  bool has_double_params() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<double> double_params() const { return GetRepeated<double>(4); }
+  bool has_boolean_params() const { return at<5>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> boolean_params() const { return GetRepeated<int32_t>(5); }
+  bool has_stacktrace_iid() const { return at<6>().valid(); }
+  uint32_t stacktrace_iid() const { return at<6>().as_uint32(); }
+};
+
+class ProtoLogMessage : public ::protozero::Message {
+ public:
+  using Decoder = ProtoLogMessage_Decoder;
+  enum : int32_t {
+    kMessageIdFieldNumber = 1,
+    kStrParamIidsFieldNumber = 2,
+    kSint64ParamsFieldNumber = 3,
+    kDoubleParamsFieldNumber = 4,
+    kBooleanParamsFieldNumber = 5,
+    kStacktraceIidFieldNumber = 6,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ProtoLogMessage"; }
+
+
+  using FieldMetadata_MessageId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
+      uint64_t,
+      ProtoLogMessage>;
+
+  static constexpr FieldMetadata_MessageId kMessageId{};
+  void set_message_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MessageId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StrParamIids =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ProtoLogMessage>;
+
+  static constexpr FieldMetadata_StrParamIids kStrParamIids{};
+  void add_str_param_iids(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StrParamIids::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Sint64Params =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kSint64,
+      int64_t,
+      ProtoLogMessage>;
+
+  static constexpr FieldMetadata_Sint64Params kSint64Params{};
+  void add_sint64_params(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Sint64Params::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kSint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DoubleParams =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kDouble,
+      double,
+      ProtoLogMessage>;
+
+  static constexpr FieldMetadata_DoubleParams kDoubleParams{};
+  void add_double_params(double value) {
+    static constexpr uint32_t field_id = FieldMetadata_DoubleParams::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BooleanParams =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ProtoLogMessage>;
+
+  static constexpr FieldMetadata_BooleanParams kBooleanParams{};
+  void add_boolean_params(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BooleanParams::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StacktraceIid =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ProtoLogMessage>;
+
+  static constexpr FieldMetadata_StacktraceIid kStacktraceIid{};
+  void set_stacktrace_iid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StacktraceIid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/shell_transition.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SHELL_TRANSITION_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SHELL_TRANSITION_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class ShellHandlerMapping;
+class ShellTransition_Target;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class ShellHandlerMapping_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  ShellHandlerMapping_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ShellHandlerMapping_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ShellHandlerMapping_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  int32_t id() const { return at<1>().as_int32(); }
+  bool has_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars name() const { return at<2>().as_string(); }
+};
+
+class ShellHandlerMapping : public ::protozero::Message {
+ public:
+  using Decoder = ShellHandlerMapping_Decoder;
+  enum : int32_t {
+    kIdFieldNumber = 1,
+    kNameFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ShellHandlerMapping"; }
+
+
+  using FieldMetadata_Id =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ShellHandlerMapping>;
+
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ShellHandlerMapping>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class ShellHandlerMappings_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  ShellHandlerMappings_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ShellHandlerMappings_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ShellHandlerMappings_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_mapping() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> mapping() const { return GetRepeated<::protozero::ConstBytes>(1); }
+};
+
+class ShellHandlerMappings : public ::protozero::Message {
+ public:
+  using Decoder = ShellHandlerMappings_Decoder;
+  enum : int32_t {
+    kMappingFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ShellHandlerMappings"; }
+
+
+  using FieldMetadata_Mapping =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ShellHandlerMapping,
+      ShellHandlerMappings>;
+
+  static constexpr FieldMetadata_Mapping kMapping{};
+  template <typename T = ShellHandlerMapping> T* add_mapping() {
+    return BeginNestedMessage<T>(1);
+  }
+
+};
+
+class ShellTransition_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/17> {
+ public:
+  ShellTransition_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ShellTransition_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ShellTransition_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  int32_t id() const { return at<1>().as_int32(); }
+  bool has_create_time_ns() const { return at<2>().valid(); }
+  int64_t create_time_ns() const { return at<2>().as_int64(); }
+  bool has_send_time_ns() const { return at<3>().valid(); }
+  int64_t send_time_ns() const { return at<3>().as_int64(); }
+  bool has_dispatch_time_ns() const { return at<4>().valid(); }
+  int64_t dispatch_time_ns() const { return at<4>().as_int64(); }
+  bool has_merge_time_ns() const { return at<5>().valid(); }
+  int64_t merge_time_ns() const { return at<5>().as_int64(); }
+  bool has_merge_request_time_ns() const { return at<6>().valid(); }
+  int64_t merge_request_time_ns() const { return at<6>().as_int64(); }
+  bool has_shell_abort_time_ns() const { return at<7>().valid(); }
+  int64_t shell_abort_time_ns() const { return at<7>().as_int64(); }
+  bool has_wm_abort_time_ns() const { return at<8>().valid(); }
+  int64_t wm_abort_time_ns() const { return at<8>().as_int64(); }
+  bool has_finish_time_ns() const { return at<9>().valid(); }
+  int64_t finish_time_ns() const { return at<9>().as_int64(); }
+  bool has_start_transaction_id() const { return at<10>().valid(); }
+  uint64_t start_transaction_id() const { return at<10>().as_uint64(); }
+  bool has_finish_transaction_id() const { return at<11>().valid(); }
+  uint64_t finish_transaction_id() const { return at<11>().as_uint64(); }
+  bool has_handler() const { return at<12>().valid(); }
+  int32_t handler() const { return at<12>().as_int32(); }
+  bool has_type() const { return at<13>().valid(); }
+  int32_t type() const { return at<13>().as_int32(); }
+  bool has_targets() const { return at<14>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> targets() const { return GetRepeated<::protozero::ConstBytes>(14); }
+  bool has_merge_target() const { return at<15>().valid(); }
+  int32_t merge_target() const { return at<15>().as_int32(); }
+  bool has_flags() const { return at<16>().valid(); }
+  int32_t flags() const { return at<16>().as_int32(); }
+  bool has_starting_window_remove_time_ns() const { return at<17>().valid(); }
+  int64_t starting_window_remove_time_ns() const { return at<17>().as_int64(); }
+};
+
+class ShellTransition : public ::protozero::Message {
+ public:
+  using Decoder = ShellTransition_Decoder;
+  enum : int32_t {
+    kIdFieldNumber = 1,
+    kCreateTimeNsFieldNumber = 2,
+    kSendTimeNsFieldNumber = 3,
+    kDispatchTimeNsFieldNumber = 4,
+    kMergeTimeNsFieldNumber = 5,
+    kMergeRequestTimeNsFieldNumber = 6,
+    kShellAbortTimeNsFieldNumber = 7,
+    kWmAbortTimeNsFieldNumber = 8,
+    kFinishTimeNsFieldNumber = 9,
+    kStartTransactionIdFieldNumber = 10,
+    kFinishTransactionIdFieldNumber = 11,
+    kHandlerFieldNumber = 12,
+    kTypeFieldNumber = 13,
+    kTargetsFieldNumber = 14,
+    kMergeTargetFieldNumber = 15,
+    kFlagsFieldNumber = 16,
+    kStartingWindowRemoveTimeNsFieldNumber = 17,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ShellTransition"; }
+
+  using Target = ::perfetto::protos::pbzero::ShellTransition_Target;
+
+  using FieldMetadata_Id =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ShellTransition>;
+
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CreateTimeNs =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ShellTransition>;
+
+  static constexpr FieldMetadata_CreateTimeNs kCreateTimeNs{};
+  void set_create_time_ns(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CreateTimeNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SendTimeNs =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ShellTransition>;
+
+  static constexpr FieldMetadata_SendTimeNs kSendTimeNs{};
+  void set_send_time_ns(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SendTimeNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DispatchTimeNs =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ShellTransition>;
+
+  static constexpr FieldMetadata_DispatchTimeNs kDispatchTimeNs{};
+  void set_dispatch_time_ns(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DispatchTimeNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MergeTimeNs =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ShellTransition>;
+
+  static constexpr FieldMetadata_MergeTimeNs kMergeTimeNs{};
+  void set_merge_time_ns(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MergeTimeNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MergeRequestTimeNs =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ShellTransition>;
+
+  static constexpr FieldMetadata_MergeRequestTimeNs kMergeRequestTimeNs{};
+  void set_merge_request_time_ns(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MergeRequestTimeNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ShellAbortTimeNs =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ShellTransition>;
+
+  static constexpr FieldMetadata_ShellAbortTimeNs kShellAbortTimeNs{};
+  void set_shell_abort_time_ns(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ShellAbortTimeNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_WmAbortTimeNs =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ShellTransition>;
+
+  static constexpr FieldMetadata_WmAbortTimeNs kWmAbortTimeNs{};
+  void set_wm_abort_time_ns(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_WmAbortTimeNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FinishTimeNs =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ShellTransition>;
+
+  static constexpr FieldMetadata_FinishTimeNs kFinishTimeNs{};
+  void set_finish_time_ns(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FinishTimeNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StartTransactionId =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ShellTransition>;
+
+  static constexpr FieldMetadata_StartTransactionId kStartTransactionId{};
+  void set_start_transaction_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StartTransactionId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FinishTransactionId =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ShellTransition>;
+
+  static constexpr FieldMetadata_FinishTransactionId kFinishTransactionId{};
+  void set_finish_transaction_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FinishTransactionId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Handler =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ShellTransition>;
+
+  static constexpr FieldMetadata_Handler kHandler{};
+  void set_handler(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Handler::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Type =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ShellTransition>;
+
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Targets =
+    ::protozero::proto_utils::FieldMetadata<
+      14,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ShellTransition_Target,
+      ShellTransition>;
+
+  static constexpr FieldMetadata_Targets kTargets{};
+  template <typename T = ShellTransition_Target> T* add_targets() {
+    return BeginNestedMessage<T>(14);
+  }
+
+
+  using FieldMetadata_MergeTarget =
+    ::protozero::proto_utils::FieldMetadata<
+      15,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ShellTransition>;
+
+  static constexpr FieldMetadata_MergeTarget kMergeTarget{};
+  void set_merge_target(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MergeTarget::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Flags =
+    ::protozero::proto_utils::FieldMetadata<
+      16,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ShellTransition>;
+
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StartingWindowRemoveTimeNs =
+    ::protozero::proto_utils::FieldMetadata<
+      17,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ShellTransition>;
+
+  static constexpr FieldMetadata_StartingWindowRemoveTimeNs kStartingWindowRemoveTimeNs{};
+  void set_starting_window_remove_time_ns(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StartingWindowRemoveTimeNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class ShellTransition_Target_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  ShellTransition_Target_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ShellTransition_Target_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ShellTransition_Target_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_mode() const { return at<1>().valid(); }
+  int32_t mode() const { return at<1>().as_int32(); }
+  bool has_layer_id() const { return at<2>().valid(); }
+  int32_t layer_id() const { return at<2>().as_int32(); }
+  bool has_window_id() const { return at<3>().valid(); }
+  int32_t window_id() const { return at<3>().as_int32(); }
+  bool has_flags() const { return at<4>().valid(); }
+  int32_t flags() const { return at<4>().as_int32(); }
+};
+
+class ShellTransition_Target : public ::protozero::Message {
+ public:
+  using Decoder = ShellTransition_Target_Decoder;
+  enum : int32_t {
+    kModeFieldNumber = 1,
+    kLayerIdFieldNumber = 2,
+    kWindowIdFieldNumber = 3,
+    kFlagsFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ShellTransition.Target"; }
+
+
+  using FieldMetadata_Mode =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ShellTransition_Target>;
+
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_LayerId =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ShellTransition_Target>;
+
+  static constexpr FieldMetadata_LayerId kLayerId{};
+  void set_layer_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LayerId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_WindowId =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ShellTransition_Target>;
+
+  static constexpr FieldMetadata_WindowId kWindowId{};
+  void set_window_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_WindowId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Flags =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ShellTransition_Target>;
+
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/surfaceflinger_common.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SURFACEFLINGER_COMMON_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SURFACEFLINGER_COMMON_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class BoxShadowSettings_BoxShadowParams;
+class RectProto;
+class RegionProto;
+class TransformProto;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+enum TrustedOverlay : int32_t {
+  UNSET = 0,
+  DISABLED = 1,
+  ENABLED = 2,
+};
+
+constexpr TrustedOverlay TrustedOverlay_MIN = TrustedOverlay::UNSET;
+constexpr TrustedOverlay TrustedOverlay_MAX = TrustedOverlay::ENABLED;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* TrustedOverlay_Name(::perfetto::protos::pbzero::TrustedOverlay value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::TrustedOverlay::UNSET:
+    return "UNSET";
+
+  case ::perfetto::protos::pbzero::TrustedOverlay::DISABLED:
+    return "DISABLED";
+
+  case ::perfetto::protos::pbzero::TrustedOverlay::ENABLED:
+    return "ENABLED";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class BorderSettings_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  BorderSettings_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit BorderSettings_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit BorderSettings_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_stroke_width() const { return at<1>().valid(); }
+  float stroke_width() const { return at<1>().as_float(); }
+  bool has_color() const { return at<2>().valid(); }
+  int32_t color() const { return at<2>().as_int32(); }
+};
+
+class BorderSettings : public ::protozero::Message {
+ public:
+  using Decoder = BorderSettings_Decoder;
+  enum : int32_t {
+    kStrokeWidthFieldNumber = 1,
+    kColorFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.BorderSettings"; }
+
+
+  using FieldMetadata_StrokeWidth =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      BorderSettings>;
+
+  static constexpr FieldMetadata_StrokeWidth kStrokeWidth{};
+  void set_stroke_width(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_StrokeWidth::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Color =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BorderSettings>;
+
+  static constexpr FieldMetadata_Color kColor{};
+  void set_color(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Color::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class BoxShadowSettings_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  BoxShadowSettings_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit BoxShadowSettings_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit BoxShadowSettings_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_box_shadows() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> box_shadows() const { return GetRepeated<::protozero::ConstBytes>(1); }
+};
+
+class BoxShadowSettings : public ::protozero::Message {
+ public:
+  using Decoder = BoxShadowSettings_Decoder;
+  enum : int32_t {
+    kBoxShadowsFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.BoxShadowSettings"; }
+
+  using BoxShadowParams = ::perfetto::protos::pbzero::BoxShadowSettings_BoxShadowParams;
+
+  using FieldMetadata_BoxShadows =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BoxShadowSettings_BoxShadowParams,
+      BoxShadowSettings>;
+
+  static constexpr FieldMetadata_BoxShadows kBoxShadows{};
+  template <typename T = BoxShadowSettings_BoxShadowParams> T* add_box_shadows() {
+    return BeginNestedMessage<T>(1);
+  }
+
+};
+
+class BoxShadowSettings_BoxShadowParams_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  BoxShadowSettings_BoxShadowParams_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit BoxShadowSettings_BoxShadowParams_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit BoxShadowSettings_BoxShadowParams_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_blur_radius() const { return at<1>().valid(); }
+  float blur_radius() const { return at<1>().as_float(); }
+  bool has_spread_radius() const { return at<2>().valid(); }
+  float spread_radius() const { return at<2>().as_float(); }
+  bool has_color() const { return at<3>().valid(); }
+  int32_t color() const { return at<3>().as_int32(); }
+  bool has_offset_x() const { return at<4>().valid(); }
+  float offset_x() const { return at<4>().as_float(); }
+  bool has_offset_y() const { return at<5>().valid(); }
+  float offset_y() const { return at<5>().as_float(); }
+};
+
+class BoxShadowSettings_BoxShadowParams : public ::protozero::Message {
+ public:
+  using Decoder = BoxShadowSettings_BoxShadowParams_Decoder;
+  enum : int32_t {
+    kBlurRadiusFieldNumber = 1,
+    kSpreadRadiusFieldNumber = 2,
+    kColorFieldNumber = 3,
+    kOffsetXFieldNumber = 4,
+    kOffsetYFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.BoxShadowSettings.BoxShadowParams"; }
+
+
+  using FieldMetadata_BlurRadius =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      BoxShadowSettings_BoxShadowParams>;
+
+  static constexpr FieldMetadata_BlurRadius kBlurRadius{};
+  void set_blur_radius(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_BlurRadius::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SpreadRadius =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      BoxShadowSettings_BoxShadowParams>;
+
+  static constexpr FieldMetadata_SpreadRadius kSpreadRadius{};
+  void set_spread_radius(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_SpreadRadius::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Color =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BoxShadowSettings_BoxShadowParams>;
+
+  static constexpr FieldMetadata_Color kColor{};
+  void set_color(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Color::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OffsetX =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      BoxShadowSettings_BoxShadowParams>;
+
+  static constexpr FieldMetadata_OffsetX kOffsetX{};
+  void set_offset_x(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_OffsetX::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OffsetY =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      BoxShadowSettings_BoxShadowParams>;
+
+  static constexpr FieldMetadata_OffsetY kOffsetY{};
+  void set_offset_y(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_OffsetY::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class ColorTransformProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  ColorTransformProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ColorTransformProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ColorTransformProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_val() const { return at<1>().valid(); }
+  ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kFixed32, float> val(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kFixed32, float>(1, parse_error_ptr); }
+};
+
+class ColorTransformProto : public ::protozero::Message {
+ public:
+  using Decoder = ColorTransformProto_Decoder;
+  enum : int32_t {
+    kValFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ColorTransformProto"; }
+
+
+  using FieldMetadata_Val =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      ColorTransformProto>;
+
+  static constexpr FieldMetadata_Val kVal{};
+  void set_val(const ::protozero::PackedFixedSizeInt<float>& packed_buffer) {
+    AppendBytes(FieldMetadata_Val::kFieldId, packed_buffer.data(),
+                packed_buffer.size());
+  }
+};
+
+class BlurRegion_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/18> {
+ public:
+  BlurRegion_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit BlurRegion_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit BlurRegion_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_blur_radius() const { return at<1>().valid(); }
+  uint32_t blur_radius() const { return at<1>().as_uint32(); }
+  bool has_corner_radius_tl() const { return at<2>().valid(); }
+  uint32_t corner_radius_tl() const { return at<2>().as_uint32(); }
+  bool has_corner_radius_tr() const { return at<3>().valid(); }
+  uint32_t corner_radius_tr() const { return at<3>().as_uint32(); }
+  bool has_corner_radius_bl() const { return at<4>().valid(); }
+  uint32_t corner_radius_bl() const { return at<4>().as_uint32(); }
+  bool has_corner_radius_br() const { return at<5>().valid(); }
+  float corner_radius_br() const { return at<5>().as_float(); }
+  bool has_corner_radius_tlx() const { return at<11>().valid(); }
+  float corner_radius_tlx() const { return at<11>().as_float(); }
+  bool has_corner_radius_tly() const { return at<12>().valid(); }
+  float corner_radius_tly() const { return at<12>().as_float(); }
+  bool has_corner_radius_trx() const { return at<13>().valid(); }
+  float corner_radius_trx() const { return at<13>().as_float(); }
+  bool has_corner_radius_try() const { return at<14>().valid(); }
+  float corner_radius_try() const { return at<14>().as_float(); }
+  bool has_corner_radius_blx() const { return at<15>().valid(); }
+  float corner_radius_blx() const { return at<15>().as_float(); }
+  bool has_corner_radius_bly() const { return at<16>().valid(); }
+  float corner_radius_bly() const { return at<16>().as_float(); }
+  bool has_corner_radius_brx() const { return at<17>().valid(); }
+  float corner_radius_brx() const { return at<17>().as_float(); }
+  bool has_corner_radius_bry() const { return at<18>().valid(); }
+  float corner_radius_bry() const { return at<18>().as_float(); }
+  bool has_alpha() const { return at<6>().valid(); }
+  float alpha() const { return at<6>().as_float(); }
+  bool has_left() const { return at<7>().valid(); }
+  int32_t left() const { return at<7>().as_int32(); }
+  bool has_top() const { return at<8>().valid(); }
+  int32_t top() const { return at<8>().as_int32(); }
+  bool has_right() const { return at<9>().valid(); }
+  int32_t right() const { return at<9>().as_int32(); }
+  bool has_bottom() const { return at<10>().valid(); }
+  int32_t bottom() const { return at<10>().as_int32(); }
+};
+
+class BlurRegion : public ::protozero::Message {
+ public:
+  using Decoder = BlurRegion_Decoder;
+  enum : int32_t {
+    kBlurRadiusFieldNumber = 1,
+    kCornerRadiusTlFieldNumber = 2,
+    kCornerRadiusTrFieldNumber = 3,
+    kCornerRadiusBlFieldNumber = 4,
+    kCornerRadiusBrFieldNumber = 5,
+    kCornerRadiusTlxFieldNumber = 11,
+    kCornerRadiusTlyFieldNumber = 12,
+    kCornerRadiusTrxFieldNumber = 13,
+    kCornerRadiusTryFieldNumber = 14,
+    kCornerRadiusBlxFieldNumber = 15,
+    kCornerRadiusBlyFieldNumber = 16,
+    kCornerRadiusBrxFieldNumber = 17,
+    kCornerRadiusBryFieldNumber = 18,
+    kAlphaFieldNumber = 6,
+    kLeftFieldNumber = 7,
+    kTopFieldNumber = 8,
+    kRightFieldNumber = 9,
+    kBottomFieldNumber = 10,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.BlurRegion"; }
+
+
+  using FieldMetadata_BlurRadius =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      BlurRegion>;
+
+  static constexpr FieldMetadata_BlurRadius kBlurRadius{};
+  void set_blur_radius(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BlurRadius::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CornerRadiusTl =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      BlurRegion>;
+
+  static constexpr FieldMetadata_CornerRadiusTl kCornerRadiusTl{};
+  void set_corner_radius_tl(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CornerRadiusTl::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CornerRadiusTr =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      BlurRegion>;
+
+  static constexpr FieldMetadata_CornerRadiusTr kCornerRadiusTr{};
+  void set_corner_radius_tr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CornerRadiusTr::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CornerRadiusBl =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      BlurRegion>;
+
+  static constexpr FieldMetadata_CornerRadiusBl kCornerRadiusBl{};
+  void set_corner_radius_bl(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CornerRadiusBl::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CornerRadiusBr =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      BlurRegion>;
+
+  static constexpr FieldMetadata_CornerRadiusBr kCornerRadiusBr{};
+  void set_corner_radius_br(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_CornerRadiusBr::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CornerRadiusTlx =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      BlurRegion>;
+
+  static constexpr FieldMetadata_CornerRadiusTlx kCornerRadiusTlx{};
+  void set_corner_radius_tlx(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_CornerRadiusTlx::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CornerRadiusTly =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      BlurRegion>;
+
+  static constexpr FieldMetadata_CornerRadiusTly kCornerRadiusTly{};
+  void set_corner_radius_tly(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_CornerRadiusTly::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CornerRadiusTrx =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      BlurRegion>;
+
+  static constexpr FieldMetadata_CornerRadiusTrx kCornerRadiusTrx{};
+  void set_corner_radius_trx(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_CornerRadiusTrx::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CornerRadiusTry =
+    ::protozero::proto_utils::FieldMetadata<
+      14,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      BlurRegion>;
+
+  static constexpr FieldMetadata_CornerRadiusTry kCornerRadiusTry{};
+  void set_corner_radius_try(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_CornerRadiusTry::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CornerRadiusBlx =
+    ::protozero::proto_utils::FieldMetadata<
+      15,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      BlurRegion>;
+
+  static constexpr FieldMetadata_CornerRadiusBlx kCornerRadiusBlx{};
+  void set_corner_radius_blx(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_CornerRadiusBlx::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CornerRadiusBly =
+    ::protozero::proto_utils::FieldMetadata<
+      16,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      BlurRegion>;
+
+  static constexpr FieldMetadata_CornerRadiusBly kCornerRadiusBly{};
+  void set_corner_radius_bly(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_CornerRadiusBly::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CornerRadiusBrx =
+    ::protozero::proto_utils::FieldMetadata<
+      17,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      BlurRegion>;
+
+  static constexpr FieldMetadata_CornerRadiusBrx kCornerRadiusBrx{};
+  void set_corner_radius_brx(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_CornerRadiusBrx::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CornerRadiusBry =
+    ::protozero::proto_utils::FieldMetadata<
+      18,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      BlurRegion>;
+
+  static constexpr FieldMetadata_CornerRadiusBry kCornerRadiusBry{};
+  void set_corner_radius_bry(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_CornerRadiusBry::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Alpha =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      BlurRegion>;
+
+  static constexpr FieldMetadata_Alpha kAlpha{};
+  void set_alpha(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Alpha::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Left =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BlurRegion>;
+
+  static constexpr FieldMetadata_Left kLeft{};
+  void set_left(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Left::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Top =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BlurRegion>;
+
+  static constexpr FieldMetadata_Top kTop{};
+  void set_top(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Top::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Right =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BlurRegion>;
+
+  static constexpr FieldMetadata_Right kRight{};
+  void set_right(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Right::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Bottom =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BlurRegion>;
+
+  static constexpr FieldMetadata_Bottom kBottom{};
+  void set_bottom(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Bottom::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class InputWindowInfoProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/17> {
+ public:
+  InputWindowInfoProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit InputWindowInfoProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit InputWindowInfoProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_layout_params_flags() const { return at<1>().valid(); }
+  uint32_t layout_params_flags() const { return at<1>().as_uint32(); }
+  bool has_layout_params_type() const { return at<2>().valid(); }
+  int32_t layout_params_type() const { return at<2>().as_int32(); }
+  bool has_frame() const { return at<3>().valid(); }
+  ::protozero::ConstBytes frame() const { return at<3>().as_bytes(); }
+  bool has_touchable_region() const { return at<4>().valid(); }
+  ::protozero::ConstBytes touchable_region() const { return at<4>().as_bytes(); }
+  bool has_surface_inset() const { return at<5>().valid(); }
+  int32_t surface_inset() const { return at<5>().as_int32(); }
+  bool has_visible() const { return at<6>().valid(); }
+  bool visible() const { return at<6>().as_bool(); }
+  bool has_can_receive_keys() const { return at<7>().valid(); }
+  bool can_receive_keys() const { return at<7>().as_bool(); }
+  bool has_focusable() const { return at<8>().valid(); }
+  bool focusable() const { return at<8>().as_bool(); }
+  bool has_has_wallpaper() const { return at<9>().valid(); }
+  bool has_wallpaper() const { return at<9>().as_bool(); }
+  bool has_global_scale_factor() const { return at<10>().valid(); }
+  float global_scale_factor() const { return at<10>().as_float(); }
+  bool has_window_x_scale() const { return at<11>().valid(); }
+  float window_x_scale() const { return at<11>().as_float(); }
+  bool has_window_y_scale() const { return at<12>().valid(); }
+  float window_y_scale() const { return at<12>().as_float(); }
+  bool has_crop_layer_id() const { return at<13>().valid(); }
+  int32_t crop_layer_id() const { return at<13>().as_int32(); }
+  bool has_replace_touchable_region_with_crop() const { return at<14>().valid(); }
+  bool replace_touchable_region_with_crop() const { return at<14>().as_bool(); }
+  bool has_touchable_region_crop() const { return at<15>().valid(); }
+  ::protozero::ConstBytes touchable_region_crop() const { return at<15>().as_bytes(); }
+  bool has_transform() const { return at<16>().valid(); }
+  ::protozero::ConstBytes transform() const { return at<16>().as_bytes(); }
+  bool has_input_config() const { return at<17>().valid(); }
+  uint32_t input_config() const { return at<17>().as_uint32(); }
+};
+
+class InputWindowInfoProto : public ::protozero::Message {
+ public:
+  using Decoder = InputWindowInfoProto_Decoder;
+  enum : int32_t {
+    kLayoutParamsFlagsFieldNumber = 1,
+    kLayoutParamsTypeFieldNumber = 2,
+    kFrameFieldNumber = 3,
+    kTouchableRegionFieldNumber = 4,
+    kSurfaceInsetFieldNumber = 5,
+    kVisibleFieldNumber = 6,
+    kCanReceiveKeysFieldNumber = 7,
+    kFocusableFieldNumber = 8,
+    kHasWallpaperFieldNumber = 9,
+    kGlobalScaleFactorFieldNumber = 10,
+    kWindowXScaleFieldNumber = 11,
+    kWindowYScaleFieldNumber = 12,
+    kCropLayerIdFieldNumber = 13,
+    kReplaceTouchableRegionWithCropFieldNumber = 14,
+    kTouchableRegionCropFieldNumber = 15,
+    kTransformFieldNumber = 16,
+    kInputConfigFieldNumber = 17,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.InputWindowInfoProto"; }
+
+
+  using FieldMetadata_LayoutParamsFlags =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      InputWindowInfoProto>;
+
+  static constexpr FieldMetadata_LayoutParamsFlags kLayoutParamsFlags{};
+  void set_layout_params_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LayoutParamsFlags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_LayoutParamsType =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      InputWindowInfoProto>;
+
+  static constexpr FieldMetadata_LayoutParamsType kLayoutParamsType{};
+  void set_layout_params_type(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LayoutParamsType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Frame =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      RectProto,
+      InputWindowInfoProto>;
+
+  static constexpr FieldMetadata_Frame kFrame{};
+  template <typename T = RectProto> T* set_frame() {
+    return BeginNestedMessage<T>(3);
+  }
+
+
+  using FieldMetadata_TouchableRegion =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      RegionProto,
+      InputWindowInfoProto>;
+
+  static constexpr FieldMetadata_TouchableRegion kTouchableRegion{};
+  template <typename T = RegionProto> T* set_touchable_region() {
+    return BeginNestedMessage<T>(4);
+  }
+
+
+  using FieldMetadata_SurfaceInset =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      InputWindowInfoProto>;
+
+  static constexpr FieldMetadata_SurfaceInset kSurfaceInset{};
+  void set_surface_inset(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SurfaceInset::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Visible =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      InputWindowInfoProto>;
+
+  static constexpr FieldMetadata_Visible kVisible{};
+  void set_visible(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_Visible::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CanReceiveKeys =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      InputWindowInfoProto>;
+
+  static constexpr FieldMetadata_CanReceiveKeys kCanReceiveKeys{};
+  void set_can_receive_keys(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_CanReceiveKeys::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Focusable =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      InputWindowInfoProto>;
+
+  static constexpr FieldMetadata_Focusable kFocusable{};
+  void set_focusable(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_Focusable::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_HasWallpaper =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      InputWindowInfoProto>;
+
+  static constexpr FieldMetadata_HasWallpaper kHasWallpaper{};
+  void set_has_wallpaper(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_HasWallpaper::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_GlobalScaleFactor =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      InputWindowInfoProto>;
+
+  static constexpr FieldMetadata_GlobalScaleFactor kGlobalScaleFactor{};
+  void set_global_scale_factor(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_GlobalScaleFactor::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_WindowXScale =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      InputWindowInfoProto>;
+
+  static constexpr FieldMetadata_WindowXScale kWindowXScale{};
+  void set_window_x_scale(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_WindowXScale::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_WindowYScale =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      InputWindowInfoProto>;
+
+  static constexpr FieldMetadata_WindowYScale kWindowYScale{};
+  void set_window_y_scale(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_WindowYScale::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CropLayerId =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      InputWindowInfoProto>;
+
+  static constexpr FieldMetadata_CropLayerId kCropLayerId{};
+  void set_crop_layer_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CropLayerId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ReplaceTouchableRegionWithCrop =
+    ::protozero::proto_utils::FieldMetadata<
+      14,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      InputWindowInfoProto>;
+
+  static constexpr FieldMetadata_ReplaceTouchableRegionWithCrop kReplaceTouchableRegionWithCrop{};
+  void set_replace_touchable_region_with_crop(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReplaceTouchableRegionWithCrop::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TouchableRegionCrop =
+    ::protozero::proto_utils::FieldMetadata<
+      15,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      RectProto,
+      InputWindowInfoProto>;
+
+  static constexpr FieldMetadata_TouchableRegionCrop kTouchableRegionCrop{};
+  template <typename T = RectProto> T* set_touchable_region_crop() {
+    return BeginNestedMessage<T>(15);
+  }
+
+
+  using FieldMetadata_Transform =
+    ::protozero::proto_utils::FieldMetadata<
+      16,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TransformProto,
+      InputWindowInfoProto>;
+
+  static constexpr FieldMetadata_Transform kTransform{};
+  template <typename T = TransformProto> T* set_transform() {
+    return BeginNestedMessage<T>(16);
+  }
+
+
+  using FieldMetadata_InputConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      17,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      InputWindowInfoProto>;
+
+  static constexpr FieldMetadata_InputConfig kInputConfig{};
+  void set_input_config(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InputConfig::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class ColorProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  ColorProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ColorProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ColorProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_r() const { return at<1>().valid(); }
+  float r() const { return at<1>().as_float(); }
+  bool has_g() const { return at<2>().valid(); }
+  float g() const { return at<2>().as_float(); }
+  bool has_b() const { return at<3>().valid(); }
+  float b() const { return at<3>().as_float(); }
+  bool has_a() const { return at<4>().valid(); }
+  float a() const { return at<4>().as_float(); }
+};
+
+class ColorProto : public ::protozero::Message {
+ public:
+  using Decoder = ColorProto_Decoder;
+  enum : int32_t {
+    kRFieldNumber = 1,
+    kGFieldNumber = 2,
+    kBFieldNumber = 3,
+    kAFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ColorProto"; }
+
+
+  using FieldMetadata_R =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      ColorProto>;
+
+  static constexpr FieldMetadata_R kR{};
+  void set_r(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_R::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_G =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      ColorProto>;
+
+  static constexpr FieldMetadata_G kG{};
+  void set_g(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_G::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_B =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      ColorProto>;
+
+  static constexpr FieldMetadata_B kB{};
+  void set_b(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_B::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_A =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      ColorProto>;
+
+  static constexpr FieldMetadata_A kA{};
+  void set_a(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_A::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class TransformProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  TransformProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TransformProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TransformProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dsdx() const { return at<1>().valid(); }
+  float dsdx() const { return at<1>().as_float(); }
+  bool has_dtdx() const { return at<2>().valid(); }
+  float dtdx() const { return at<2>().as_float(); }
+  bool has_dsdy() const { return at<3>().valid(); }
+  float dsdy() const { return at<3>().as_float(); }
+  bool has_dtdy() const { return at<4>().valid(); }
+  float dtdy() const { return at<4>().as_float(); }
+  bool has_type() const { return at<5>().valid(); }
+  int32_t type() const { return at<5>().as_int32(); }
+};
+
+class TransformProto : public ::protozero::Message {
+ public:
+  using Decoder = TransformProto_Decoder;
+  enum : int32_t {
+    kDsdxFieldNumber = 1,
+    kDtdxFieldNumber = 2,
+    kDsdyFieldNumber = 3,
+    kDtdyFieldNumber = 4,
+    kTypeFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TransformProto"; }
+
+
+  using FieldMetadata_Dsdx =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      TransformProto>;
+
+  static constexpr FieldMetadata_Dsdx kDsdx{};
+  void set_dsdx(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dsdx::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Dtdx =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      TransformProto>;
+
+  static constexpr FieldMetadata_Dtdx kDtdx{};
+  void set_dtdx(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dtdx::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Dsdy =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      TransformProto>;
+
+  static constexpr FieldMetadata_Dsdy kDsdy{};
+  void set_dsdy(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dsdy::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Dtdy =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      TransformProto>;
+
+  static constexpr FieldMetadata_Dtdy kDtdy{};
+  void set_dtdy(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dtdy::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Type =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TransformProto>;
+
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class SizeProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  SizeProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SizeProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SizeProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_w() const { return at<1>().valid(); }
+  int32_t w() const { return at<1>().as_int32(); }
+  bool has_h() const { return at<2>().valid(); }
+  int32_t h() const { return at<2>().as_int32(); }
+};
+
+class SizeProto : public ::protozero::Message {
+ public:
+  using Decoder = SizeProto_Decoder;
+  enum : int32_t {
+    kWFieldNumber = 1,
+    kHFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SizeProto"; }
+
+
+  using FieldMetadata_W =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SizeProto>;
+
+  static constexpr FieldMetadata_W kW{};
+  void set_w(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_W::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_H =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SizeProto>;
+
+  static constexpr FieldMetadata_H kH{};
+  void set_h(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_H::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class RegionProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  RegionProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit RegionProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit RegionProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_rect() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> rect() const { return GetRepeated<::protozero::ConstBytes>(2); }
+};
+
+class RegionProto : public ::protozero::Message {
+ public:
+  using Decoder = RegionProto_Decoder;
+  enum : int32_t {
+    kRectFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.RegionProto"; }
+
+
+  using FieldMetadata_Rect =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      RectProto,
+      RegionProto>;
+
+  static constexpr FieldMetadata_Rect kRect{};
+  template <typename T = RectProto> T* add_rect() {
+    return BeginNestedMessage<T>(2);
+  }
+
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/surfaceflinger_layers.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SURFACEFLINGER_LAYERS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SURFACEFLINGER_LAYERS_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class ActiveBufferProto;
+class BarrierLayerProto;
+class BlurRegion;
+class BorderSettings;
+class BoxShadowSettings;
+class ColorProto;
+class ColorTransformProto;
+class CornerRadiiProto;
+class DisplayProto;
+class FloatRectProto;
+class InputWindowInfoProto;
+class LayerProto;
+class LayerProto_MetadataEntry;
+class LayersProto;
+class LayersSnapshotProto;
+class PositionProto;
+class RectProto;
+class RegionProto;
+class SizeProto;
+class TransformProto;
+enum HwcCompositionType : int32_t;
+enum TrustedOverlay : int32_t;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+enum HwcCompositionType : int32_t {
+  HWC_TYPE_UNSPECIFIED = 0,
+  HWC_TYPE_CLIENT = 1,
+  HWC_TYPE_DEVICE = 2,
+  HWC_TYPE_SOLID_COLOR = 3,
+  HWC_TYPE_CURSOR = 4,
+  HWC_TYPE_SIDEBAND = 5,
+  HWC_TYPE_DISPLAY_DECORATION = 6,
+};
+
+constexpr HwcCompositionType HwcCompositionType_MIN = HwcCompositionType::HWC_TYPE_UNSPECIFIED;
+constexpr HwcCompositionType HwcCompositionType_MAX = HwcCompositionType::HWC_TYPE_DISPLAY_DECORATION;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* HwcCompositionType_Name(::perfetto::protos::pbzero::HwcCompositionType value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_UNSPECIFIED:
+    return "HWC_TYPE_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_CLIENT:
+    return "HWC_TYPE_CLIENT";
+
+  case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_DEVICE:
+    return "HWC_TYPE_DEVICE";
+
+  case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_SOLID_COLOR:
+    return "HWC_TYPE_SOLID_COLOR";
+
+  case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_CURSOR:
+    return "HWC_TYPE_CURSOR";
+
+  case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_SIDEBAND:
+    return "HWC_TYPE_SIDEBAND";
+
+  case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_DISPLAY_DECORATION:
+    return "HWC_TYPE_DISPLAY_DECORATION";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_LayersTraceFileProto {
+enum MagicNumber : int32_t {
+  INVALID = 0,
+  MAGIC_NUMBER_L = 1414682956,
+  MAGIC_NUMBER_H = 1162035538,
+};
+} // namespace perfetto_pbzero_enum_LayersTraceFileProto
+using LayersTraceFileProto_MagicNumber = perfetto_pbzero_enum_LayersTraceFileProto::MagicNumber;
+
+
+constexpr LayersTraceFileProto_MagicNumber LayersTraceFileProto_MagicNumber_MIN = LayersTraceFileProto_MagicNumber::INVALID;
+constexpr LayersTraceFileProto_MagicNumber LayersTraceFileProto_MagicNumber_MAX = LayersTraceFileProto_MagicNumber::MAGIC_NUMBER_L;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* LayersTraceFileProto_MagicNumber_Name(::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber::INVALID:
+    return "INVALID";
+
+  case ::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber::MAGIC_NUMBER_L:
+    return "MAGIC_NUMBER_L";
+
+  case ::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber::MAGIC_NUMBER_H:
+    return "MAGIC_NUMBER_H";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class BarrierLayerProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  BarrierLayerProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit BarrierLayerProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit BarrierLayerProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  int32_t id() const { return at<1>().as_int32(); }
+  bool has_frame_number() const { return at<2>().valid(); }
+  uint64_t frame_number() const { return at<2>().as_uint64(); }
+};
+
+class BarrierLayerProto : public ::protozero::Message {
+ public:
+  using Decoder = BarrierLayerProto_Decoder;
+  enum : int32_t {
+    kIdFieldNumber = 1,
+    kFrameNumberFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.BarrierLayerProto"; }
+
+
+  using FieldMetadata_Id =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BarrierLayerProto>;
+
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FrameNumber =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      BarrierLayerProto>;
+
+  static constexpr FieldMetadata_FrameNumber kFrameNumber{};
+  void set_frame_number(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FrameNumber::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class ActiveBufferProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  ActiveBufferProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ActiveBufferProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ActiveBufferProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_width() const { return at<1>().valid(); }
+  uint32_t width() const { return at<1>().as_uint32(); }
+  bool has_height() const { return at<2>().valid(); }
+  uint32_t height() const { return at<2>().as_uint32(); }
+  bool has_stride() const { return at<3>().valid(); }
+  uint32_t stride() const { return at<3>().as_uint32(); }
+  bool has_format() const { return at<4>().valid(); }
+  int32_t format() const { return at<4>().as_int32(); }
+  bool has_usage() const { return at<5>().valid(); }
+  uint64_t usage() const { return at<5>().as_uint64(); }
+};
+
+class ActiveBufferProto : public ::protozero::Message {
+ public:
+  using Decoder = ActiveBufferProto_Decoder;
+  enum : int32_t {
+    kWidthFieldNumber = 1,
+    kHeightFieldNumber = 2,
+    kStrideFieldNumber = 3,
+    kFormatFieldNumber = 4,
+    kUsageFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ActiveBufferProto"; }
+
+
+  using FieldMetadata_Width =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ActiveBufferProto>;
+
+  static constexpr FieldMetadata_Width kWidth{};
+  void set_width(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Width::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Height =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ActiveBufferProto>;
+
+  static constexpr FieldMetadata_Height kHeight{};
+  void set_height(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Height::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Stride =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ActiveBufferProto>;
+
+  static constexpr FieldMetadata_Stride kStride{};
+  void set_stride(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Stride::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Format =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ActiveBufferProto>;
+
+  static constexpr FieldMetadata_Format kFormat{};
+  void set_format(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Format::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Usage =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ActiveBufferProto>;
+
+  static constexpr FieldMetadata_Usage kUsage{};
+  void set_usage(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Usage::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class CornerRadiiProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  CornerRadiiProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit CornerRadiiProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit CornerRadiiProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_tl() const { return at<1>().valid(); }
+  float tl() const { return at<1>().as_float(); }
+  bool has_tr() const { return at<2>().valid(); }
+  float tr() const { return at<2>().as_float(); }
+  bool has_bl() const { return at<3>().valid(); }
+  float bl() const { return at<3>().as_float(); }
+  bool has_br() const { return at<4>().valid(); }
+  float br() const { return at<4>().as_float(); }
+};
+
+class CornerRadiiProto : public ::protozero::Message {
+ public:
+  using Decoder = CornerRadiiProto_Decoder;
+  enum : int32_t {
+    kTlFieldNumber = 1,
+    kTrFieldNumber = 2,
+    kBlFieldNumber = 3,
+    kBrFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.CornerRadiiProto"; }
+
+
+  using FieldMetadata_Tl =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      CornerRadiiProto>;
+
+  static constexpr FieldMetadata_Tl kTl{};
+  void set_tl(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tl::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Tr =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      CornerRadiiProto>;
+
+  static constexpr FieldMetadata_Tr kTr{};
+  void set_tr(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tr::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Bl =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      CornerRadiiProto>;
+
+  static constexpr FieldMetadata_Bl kBl{};
+  void set_bl(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Bl::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Br =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      CornerRadiiProto>;
+
+  static constexpr FieldMetadata_Br kBr{};
+  void set_br(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Br::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class FloatRectProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  FloatRectProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FloatRectProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FloatRectProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_left() const { return at<1>().valid(); }
+  float left() const { return at<1>().as_float(); }
+  bool has_top() const { return at<2>().valid(); }
+  float top() const { return at<2>().as_float(); }
+  bool has_right() const { return at<3>().valid(); }
+  float right() const { return at<3>().as_float(); }
+  bool has_bottom() const { return at<4>().valid(); }
+  float bottom() const { return at<4>().as_float(); }
+};
+
+class FloatRectProto : public ::protozero::Message {
+ public:
+  using Decoder = FloatRectProto_Decoder;
+  enum : int32_t {
+    kLeftFieldNumber = 1,
+    kTopFieldNumber = 2,
+    kRightFieldNumber = 3,
+    kBottomFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FloatRectProto"; }
+
+
+  using FieldMetadata_Left =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      FloatRectProto>;
+
+  static constexpr FieldMetadata_Left kLeft{};
+  void set_left(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Left::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Top =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      FloatRectProto>;
+
+  static constexpr FieldMetadata_Top kTop{};
+  void set_top(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Top::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Right =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      FloatRectProto>;
+
+  static constexpr FieldMetadata_Right kRight{};
+  void set_right(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Right::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Bottom =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      FloatRectProto>;
+
+  static constexpr FieldMetadata_Bottom kBottom{};
+  void set_bottom(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Bottom::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class PositionProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  PositionProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PositionProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PositionProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_x() const { return at<1>().valid(); }
+  float x() const { return at<1>().as_float(); }
+  bool has_y() const { return at<2>().valid(); }
+  float y() const { return at<2>().as_float(); }
+};
+
+class PositionProto : public ::protozero::Message {
+ public:
+  using Decoder = PositionProto_Decoder;
+  enum : int32_t {
+    kXFieldNumber = 1,
+    kYFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.PositionProto"; }
+
+
+  using FieldMetadata_X =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      PositionProto>;
+
+  static constexpr FieldMetadata_X kX{};
+  void set_x(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_X::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Y =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      PositionProto>;
+
+  static constexpr FieldMetadata_Y kY{};
+  void set_y(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Y::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class LayerProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/67> {
+ public:
+  LayerProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit LayerProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit LayerProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  int32_t id() const { return at<1>().as_int32(); }
+  bool has_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars name() const { return at<2>().as_string(); }
+  bool has_children() const { return at<3>().valid(); }
+  ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t> children(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t>(3, parse_error_ptr); }
+  bool has_relatives() const { return at<4>().valid(); }
+  ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t> relatives(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t>(4, parse_error_ptr); }
+  bool has_type() const { return at<5>().valid(); }
+  ::protozero::ConstChars type() const { return at<5>().as_string(); }
+  bool has_transparent_region() const { return at<6>().valid(); }
+  ::protozero::ConstBytes transparent_region() const { return at<6>().as_bytes(); }
+  bool has_visible_region() const { return at<7>().valid(); }
+  ::protozero::ConstBytes visible_region() const { return at<7>().as_bytes(); }
+  bool has_damage_region() const { return at<8>().valid(); }
+  ::protozero::ConstBytes damage_region() const { return at<8>().as_bytes(); }
+  bool has_layer_stack() const { return at<9>().valid(); }
+  uint32_t layer_stack() const { return at<9>().as_uint32(); }
+  bool has_z() const { return at<10>().valid(); }
+  int32_t z() const { return at<10>().as_int32(); }
+  bool has_position() const { return at<11>().valid(); }
+  ::protozero::ConstBytes position() const { return at<11>().as_bytes(); }
+  bool has_requested_position() const { return at<12>().valid(); }
+  ::protozero::ConstBytes requested_position() const { return at<12>().as_bytes(); }
+  bool has_size() const { return at<13>().valid(); }
+  ::protozero::ConstBytes size() const { return at<13>().as_bytes(); }
+  bool has_crop() const { return at<14>().valid(); }
+  ::protozero::ConstBytes crop() const { return at<14>().as_bytes(); }
+  bool has_final_crop() const { return at<15>().valid(); }
+  ::protozero::ConstBytes final_crop() const { return at<15>().as_bytes(); }
+  bool has_is_opaque() const { return at<16>().valid(); }
+  bool is_opaque() const { return at<16>().as_bool(); }
+  bool has_invalidate() const { return at<17>().valid(); }
+  bool invalidate() const { return at<17>().as_bool(); }
+  bool has_dataspace() const { return at<18>().valid(); }
+  ::protozero::ConstChars dataspace() const { return at<18>().as_string(); }
+  bool has_pixel_format() const { return at<19>().valid(); }
+  ::protozero::ConstChars pixel_format() const { return at<19>().as_string(); }
+  bool has_color() const { return at<20>().valid(); }
+  ::protozero::ConstBytes color() const { return at<20>().as_bytes(); }
+  bool has_requested_color() const { return at<21>().valid(); }
+  ::protozero::ConstBytes requested_color() const { return at<21>().as_bytes(); }
+  bool has_flags() const { return at<22>().valid(); }
+  uint32_t flags() const { return at<22>().as_uint32(); }
+  bool has_transform() const { return at<23>().valid(); }
+  ::protozero::ConstBytes transform() const { return at<23>().as_bytes(); }
+  bool has_requested_transform() const { return at<24>().valid(); }
+  ::protozero::ConstBytes requested_transform() const { return at<24>().as_bytes(); }
+  bool has_parent() const { return at<25>().valid(); }
+  int32_t parent() const { return at<25>().as_int32(); }
+  bool has_z_order_relative_of() const { return at<26>().valid(); }
+  int32_t z_order_relative_of() const { return at<26>().as_int32(); }
+  bool has_active_buffer() const { return at<27>().valid(); }
+  ::protozero::ConstBytes active_buffer() const { return at<27>().as_bytes(); }
+  bool has_queued_frames() const { return at<28>().valid(); }
+  int32_t queued_frames() const { return at<28>().as_int32(); }
+  bool has_refresh_pending() const { return at<29>().valid(); }
+  bool refresh_pending() const { return at<29>().as_bool(); }
+  bool has_hwc_frame() const { return at<30>().valid(); }
+  ::protozero::ConstBytes hwc_frame() const { return at<30>().as_bytes(); }
+  bool has_hwc_crop() const { return at<31>().valid(); }
+  ::protozero::ConstBytes hwc_crop() const { return at<31>().as_bytes(); }
+  bool has_hwc_transform() const { return at<32>().valid(); }
+  int32_t hwc_transform() const { return at<32>().as_int32(); }
+  bool has_window_type() const { return at<33>().valid(); }
+  int32_t window_type() const { return at<33>().as_int32(); }
+  bool has_app_id() const { return at<34>().valid(); }
+  int32_t app_id() const { return at<34>().as_int32(); }
+  bool has_hwc_composition_type() const { return at<35>().valid(); }
+  int32_t hwc_composition_type() const { return at<35>().as_int32(); }
+  bool has_is_protected() const { return at<36>().valid(); }
+  bool is_protected() const { return at<36>().as_bool(); }
+  bool has_curr_frame() const { return at<37>().valid(); }
+  uint64_t curr_frame() const { return at<37>().as_uint64(); }
+  bool has_barrier_layer() const { return at<38>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> barrier_layer() const { return GetRepeated<::protozero::ConstBytes>(38); }
+  bool has_buffer_transform() const { return at<39>().valid(); }
+  ::protozero::ConstBytes buffer_transform() const { return at<39>().as_bytes(); }
+  bool has_effective_scaling_mode() const { return at<40>().valid(); }
+  int32_t effective_scaling_mode() const { return at<40>().as_int32(); }
+  bool has_corner_radius() const { return at<41>().valid(); }
+  float corner_radius() const { return at<41>().as_float(); }
+  bool has_metadata() const { return at<42>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> metadata() const { return GetRepeated<::protozero::ConstBytes>(42); }
+  bool has_effective_transform() const { return at<43>().valid(); }
+  ::protozero::ConstBytes effective_transform() const { return at<43>().as_bytes(); }
+  bool has_source_bounds() const { return at<44>().valid(); }
+  ::protozero::ConstBytes source_bounds() const { return at<44>().as_bytes(); }
+  bool has_bounds() const { return at<45>().valid(); }
+  ::protozero::ConstBytes bounds() const { return at<45>().as_bytes(); }
+  bool has_screen_bounds() const { return at<46>().valid(); }
+  ::protozero::ConstBytes screen_bounds() const { return at<46>().as_bytes(); }
+  bool has_input_window_info() const { return at<47>().valid(); }
+  ::protozero::ConstBytes input_window_info() const { return at<47>().as_bytes(); }
+  bool has_corner_radius_crop() const { return at<48>().valid(); }
+  ::protozero::ConstBytes corner_radius_crop() const { return at<48>().as_bytes(); }
+  bool has_shadow_radius() const { return at<49>().valid(); }
+  float shadow_radius() const { return at<49>().as_float(); }
+  bool has_color_transform() const { return at<50>().valid(); }
+  ::protozero::ConstBytes color_transform() const { return at<50>().as_bytes(); }
+  bool has_is_relative_of() const { return at<51>().valid(); }
+  bool is_relative_of() const { return at<51>().as_bool(); }
+  bool has_background_blur_radius() const { return at<52>().valid(); }
+  int32_t background_blur_radius() const { return at<52>().as_int32(); }
+  bool has_owner_uid() const { return at<53>().valid(); }
+  uint32_t owner_uid() const { return at<53>().as_uint32(); }
+  bool has_blur_regions() const { return at<54>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> blur_regions() const { return GetRepeated<::protozero::ConstBytes>(54); }
+  bool has_is_trusted_overlay() const { return at<55>().valid(); }
+  bool is_trusted_overlay() const { return at<55>().as_bool(); }
+  bool has_requested_corner_radius() const { return at<56>().valid(); }
+  float requested_corner_radius() const { return at<56>().as_float(); }
+  bool has_destination_frame() const { return at<57>().valid(); }
+  ::protozero::ConstBytes destination_frame() const { return at<57>().as_bytes(); }
+  bool has_original_id() const { return at<58>().valid(); }
+  uint32_t original_id() const { return at<58>().as_uint32(); }
+  bool has_trusted_overlay() const { return at<59>().valid(); }
+  int32_t trusted_overlay() const { return at<59>().as_int32(); }
+  bool has_background_blur_scale() const { return at<60>().valid(); }
+  float background_blur_scale() const { return at<60>().as_float(); }
+  bool has_corner_radii() const { return at<61>().valid(); }
+  ::protozero::ConstBytes corner_radii() const { return at<61>().as_bytes(); }
+  bool has_requested_corner_radii() const { return at<62>().valid(); }
+  ::protozero::ConstBytes requested_corner_radii() const { return at<62>().as_bytes(); }
+  bool has_client_drawn_corner_radii() const { return at<63>().valid(); }
+  ::protozero::ConstBytes client_drawn_corner_radii() const { return at<63>().as_bytes(); }
+  bool has_system_content_priority() const { return at<64>().valid(); }
+  int32_t system_content_priority() const { return at<64>().as_int32(); }
+  bool has_box_shadow_settings() const { return at<65>().valid(); }
+  ::protozero::ConstBytes box_shadow_settings() const { return at<65>().as_bytes(); }
+  bool has_border_settings() const { return at<66>().valid(); }
+  ::protozero::ConstBytes border_settings() const { return at<66>().as_bytes(); }
+  bool has_effective_radii() const { return at<67>().valid(); }
+  ::protozero::ConstBytes effective_radii() const { return at<67>().as_bytes(); }
+};
+
+class LayerProto : public ::protozero::Message {
+ public:
+  using Decoder = LayerProto_Decoder;
+  enum : int32_t {
+    kIdFieldNumber = 1,
+    kNameFieldNumber = 2,
+    kChildrenFieldNumber = 3,
+    kRelativesFieldNumber = 4,
+    kTypeFieldNumber = 5,
+    kTransparentRegionFieldNumber = 6,
+    kVisibleRegionFieldNumber = 7,
+    kDamageRegionFieldNumber = 8,
+    kLayerStackFieldNumber = 9,
+    kZFieldNumber = 10,
+    kPositionFieldNumber = 11,
+    kRequestedPositionFieldNumber = 12,
+    kSizeFieldNumber = 13,
+    kCropFieldNumber = 14,
+    kFinalCropFieldNumber = 15,
+    kIsOpaqueFieldNumber = 16,
+    kInvalidateFieldNumber = 17,
+    kDataspaceFieldNumber = 18,
+    kPixelFormatFieldNumber = 19,
+    kColorFieldNumber = 20,
+    kRequestedColorFieldNumber = 21,
+    kFlagsFieldNumber = 22,
+    kTransformFieldNumber = 23,
+    kRequestedTransformFieldNumber = 24,
+    kParentFieldNumber = 25,
+    kZOrderRelativeOfFieldNumber = 26,
+    kActiveBufferFieldNumber = 27,
+    kQueuedFramesFieldNumber = 28,
+    kRefreshPendingFieldNumber = 29,
+    kHwcFrameFieldNumber = 30,
+    kHwcCropFieldNumber = 31,
+    kHwcTransformFieldNumber = 32,
+    kWindowTypeFieldNumber = 33,
+    kAppIdFieldNumber = 34,
+    kHwcCompositionTypeFieldNumber = 35,
+    kIsProtectedFieldNumber = 36,
+    kCurrFrameFieldNumber = 37,
+    kBarrierLayerFieldNumber = 38,
+    kBufferTransformFieldNumber = 39,
+    kEffectiveScalingModeFieldNumber = 40,
+    kCornerRadiusFieldNumber = 41,
+    kMetadataFieldNumber = 42,
+    kEffectiveTransformFieldNumber = 43,
+    kSourceBoundsFieldNumber = 44,
+    kBoundsFieldNumber = 45,
+    kScreenBoundsFieldNumber = 46,
+    kInputWindowInfoFieldNumber = 47,
+    kCornerRadiusCropFieldNumber = 48,
+    kShadowRadiusFieldNumber = 49,
+    kColorTransformFieldNumber = 50,
+    kIsRelativeOfFieldNumber = 51,
+    kBackgroundBlurRadiusFieldNumber = 52,
+    kOwnerUidFieldNumber = 53,
+    kBlurRegionsFieldNumber = 54,
+    kIsTrustedOverlayFieldNumber = 55,
+    kRequestedCornerRadiusFieldNumber = 56,
+    kDestinationFrameFieldNumber = 57,
+    kOriginalIdFieldNumber = 58,
+    kTrustedOverlayFieldNumber = 59,
+    kBackgroundBlurScaleFieldNumber = 60,
+    kCornerRadiiFieldNumber = 61,
+    kRequestedCornerRadiiFieldNumber = 62,
+    kClientDrawnCornerRadiiFieldNumber = 63,
+    kSystemContentPriorityFieldNumber = 64,
+    kBoxShadowSettingsFieldNumber = 65,
+    kBorderSettingsFieldNumber = 66,
+    kEffectiveRadiiFieldNumber = 67,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.LayerProto"; }
+
+  using MetadataEntry = ::perfetto::protos::pbzero::LayerProto_MetadataEntry;
+
+  using FieldMetadata_Id =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LayerProto>;
+
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      LayerProto>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Children =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LayerProto>;
+
+  static constexpr FieldMetadata_Children kChildren{};
+  void set_children(const ::protozero::PackedVarInt& packed_buffer) {
+    AppendBytes(FieldMetadata_Children::kFieldId, packed_buffer.data(),
+                packed_buffer.size());
+  }
+
+  using FieldMetadata_Relatives =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LayerProto>;
+
+  static constexpr FieldMetadata_Relatives kRelatives{};
+  void set_relatives(const ::protozero::PackedVarInt& packed_buffer) {
+    AppendBytes(FieldMetadata_Relatives::kFieldId, packed_buffer.data(),
+                packed_buffer.size());
+  }
+
+  using FieldMetadata_Type =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      LayerProto>;
+
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Type::kFieldId, data, size);
+  }
+  void set_type(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Type::kFieldId, chars.data, chars.size);
+  }
+  void set_type(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TransparentRegion =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      RegionProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_TransparentRegion kTransparentRegion{};
+  template <typename T = RegionProto> T* set_transparent_region() {
+    return BeginNestedMessage<T>(6);
+  }
+
+
+  using FieldMetadata_VisibleRegion =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      RegionProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_VisibleRegion kVisibleRegion{};
+  template <typename T = RegionProto> T* set_visible_region() {
+    return BeginNestedMessage<T>(7);
+  }
+
+
+  using FieldMetadata_DamageRegion =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      RegionProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_DamageRegion kDamageRegion{};
+  template <typename T = RegionProto> T* set_damage_region() {
+    return BeginNestedMessage<T>(8);
+  }
+
+
+  using FieldMetadata_LayerStack =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerProto>;
+
+  static constexpr FieldMetadata_LayerStack kLayerStack{};
+  void set_layer_stack(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LayerStack::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Z =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LayerProto>;
+
+  static constexpr FieldMetadata_Z kZ{};
+  void set_z(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Z::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Position =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PositionProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_Position kPosition{};
+  template <typename T = PositionProto> T* set_position() {
+    return BeginNestedMessage<T>(11);
+  }
+
+
+  using FieldMetadata_RequestedPosition =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PositionProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_RequestedPosition kRequestedPosition{};
+  template <typename T = PositionProto> T* set_requested_position() {
+    return BeginNestedMessage<T>(12);
+  }
+
+
+  using FieldMetadata_Size =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SizeProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_Size kSize{};
+  template <typename T = SizeProto> T* set_size() {
+    return BeginNestedMessage<T>(13);
+  }
+
+
+  using FieldMetadata_Crop =
+    ::protozero::proto_utils::FieldMetadata<
+      14,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      RectProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_Crop kCrop{};
+  template <typename T = RectProto> T* set_crop() {
+    return BeginNestedMessage<T>(14);
+  }
+
+
+  using FieldMetadata_FinalCrop =
+    ::protozero::proto_utils::FieldMetadata<
+      15,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      RectProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_FinalCrop kFinalCrop{};
+  template <typename T = RectProto> T* set_final_crop() {
+    return BeginNestedMessage<T>(15);
+  }
+
+
+  using FieldMetadata_IsOpaque =
+    ::protozero::proto_utils::FieldMetadata<
+      16,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      LayerProto>;
+
+  static constexpr FieldMetadata_IsOpaque kIsOpaque{};
+  void set_is_opaque(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsOpaque::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Invalidate =
+    ::protozero::proto_utils::FieldMetadata<
+      17,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      LayerProto>;
+
+  static constexpr FieldMetadata_Invalidate kInvalidate{};
+  void set_invalidate(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_Invalidate::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Dataspace =
+    ::protozero::proto_utils::FieldMetadata<
+      18,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      LayerProto>;
+
+  static constexpr FieldMetadata_Dataspace kDataspace{};
+  void set_dataspace(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Dataspace::kFieldId, data, size);
+  }
+  void set_dataspace(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Dataspace::kFieldId, chars.data, chars.size);
+  }
+  void set_dataspace(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dataspace::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PixelFormat =
+    ::protozero::proto_utils::FieldMetadata<
+      19,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      LayerProto>;
+
+  static constexpr FieldMetadata_PixelFormat kPixelFormat{};
+  void set_pixel_format(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_PixelFormat::kFieldId, data, size);
+  }
+  void set_pixel_format(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_PixelFormat::kFieldId, chars.data, chars.size);
+  }
+  void set_pixel_format(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_PixelFormat::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Color =
+    ::protozero::proto_utils::FieldMetadata<
+      20,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ColorProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_Color kColor{};
+  template <typename T = ColorProto> T* set_color() {
+    return BeginNestedMessage<T>(20);
+  }
+
+
+  using FieldMetadata_RequestedColor =
+    ::protozero::proto_utils::FieldMetadata<
+      21,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ColorProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_RequestedColor kRequestedColor{};
+  template <typename T = ColorProto> T* set_requested_color() {
+    return BeginNestedMessage<T>(21);
+  }
+
+
+  using FieldMetadata_Flags =
+    ::protozero::proto_utils::FieldMetadata<
+      22,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerProto>;
+
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Transform =
+    ::protozero::proto_utils::FieldMetadata<
+      23,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TransformProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_Transform kTransform{};
+  template <typename T = TransformProto> T* set_transform() {
+    return BeginNestedMessage<T>(23);
+  }
+
+
+  using FieldMetadata_RequestedTransform =
+    ::protozero::proto_utils::FieldMetadata<
+      24,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TransformProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_RequestedTransform kRequestedTransform{};
+  template <typename T = TransformProto> T* set_requested_transform() {
+    return BeginNestedMessage<T>(24);
+  }
+
+
+  using FieldMetadata_Parent =
+    ::protozero::proto_utils::FieldMetadata<
+      25,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LayerProto>;
+
+  static constexpr FieldMetadata_Parent kParent{};
+  void set_parent(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Parent::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ZOrderRelativeOf =
+    ::protozero::proto_utils::FieldMetadata<
+      26,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LayerProto>;
+
+  static constexpr FieldMetadata_ZOrderRelativeOf kZOrderRelativeOf{};
+  void set_z_order_relative_of(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ZOrderRelativeOf::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ActiveBuffer =
+    ::protozero::proto_utils::FieldMetadata<
+      27,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ActiveBufferProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_ActiveBuffer kActiveBuffer{};
+  template <typename T = ActiveBufferProto> T* set_active_buffer() {
+    return BeginNestedMessage<T>(27);
+  }
+
+
+  using FieldMetadata_QueuedFrames =
+    ::protozero::proto_utils::FieldMetadata<
+      28,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LayerProto>;
+
+  static constexpr FieldMetadata_QueuedFrames kQueuedFrames{};
+  void set_queued_frames(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_QueuedFrames::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_RefreshPending =
+    ::protozero::proto_utils::FieldMetadata<
+      29,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      LayerProto>;
+
+  static constexpr FieldMetadata_RefreshPending kRefreshPending{};
+  void set_refresh_pending(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_RefreshPending::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_HwcFrame =
+    ::protozero::proto_utils::FieldMetadata<
+      30,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      RectProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_HwcFrame kHwcFrame{};
+  template <typename T = RectProto> T* set_hwc_frame() {
+    return BeginNestedMessage<T>(30);
+  }
+
+
+  using FieldMetadata_HwcCrop =
+    ::protozero::proto_utils::FieldMetadata<
+      31,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FloatRectProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_HwcCrop kHwcCrop{};
+  template <typename T = FloatRectProto> T* set_hwc_crop() {
+    return BeginNestedMessage<T>(31);
+  }
+
+
+  using FieldMetadata_HwcTransform =
+    ::protozero::proto_utils::FieldMetadata<
+      32,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LayerProto>;
+
+  static constexpr FieldMetadata_HwcTransform kHwcTransform{};
+  void set_hwc_transform(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_HwcTransform::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_WindowType =
+    ::protozero::proto_utils::FieldMetadata<
+      33,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LayerProto>;
+
+  static constexpr FieldMetadata_WindowType kWindowType{};
+  void set_window_type(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_WindowType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_AppId =
+    ::protozero::proto_utils::FieldMetadata<
+      34,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LayerProto>;
+
+  static constexpr FieldMetadata_AppId kAppId{};
+  void set_app_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AppId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_HwcCompositionType =
+    ::protozero::proto_utils::FieldMetadata<
+      35,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      HwcCompositionType,
+      LayerProto>;
+
+  static constexpr FieldMetadata_HwcCompositionType kHwcCompositionType{};
+  void set_hwc_composition_type(HwcCompositionType value) {
+    static constexpr uint32_t field_id = FieldMetadata_HwcCompositionType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IsProtected =
+    ::protozero::proto_utils::FieldMetadata<
+      36,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      LayerProto>;
+
+  static constexpr FieldMetadata_IsProtected kIsProtected{};
+  void set_is_protected(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsProtected::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CurrFrame =
+    ::protozero::proto_utils::FieldMetadata<
+      37,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      LayerProto>;
+
+  static constexpr FieldMetadata_CurrFrame kCurrFrame{};
+  void set_curr_frame(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CurrFrame::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BarrierLayer =
+    ::protozero::proto_utils::FieldMetadata<
+      38,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BarrierLayerProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_BarrierLayer kBarrierLayer{};
+  template <typename T = BarrierLayerProto> T* add_barrier_layer() {
+    return BeginNestedMessage<T>(38);
+  }
+
+
+  using FieldMetadata_BufferTransform =
+    ::protozero::proto_utils::FieldMetadata<
+      39,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TransformProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_BufferTransform kBufferTransform{};
+  template <typename T = TransformProto> T* set_buffer_transform() {
+    return BeginNestedMessage<T>(39);
+  }
+
+
+  using FieldMetadata_EffectiveScalingMode =
+    ::protozero::proto_utils::FieldMetadata<
+      40,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LayerProto>;
+
+  static constexpr FieldMetadata_EffectiveScalingMode kEffectiveScalingMode{};
+  void set_effective_scaling_mode(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EffectiveScalingMode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CornerRadius =
+    ::protozero::proto_utils::FieldMetadata<
+      41,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerProto>;
+
+  static constexpr FieldMetadata_CornerRadius kCornerRadius{};
+  void set_corner_radius(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_CornerRadius::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Metadata =
+    ::protozero::proto_utils::FieldMetadata<
+      42,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      LayerProto_MetadataEntry,
+      LayerProto>;
+
+  static constexpr FieldMetadata_Metadata kMetadata{};
+  template <typename T = LayerProto_MetadataEntry> T* add_metadata() {
+    return BeginNestedMessage<T>(42);
+  }
+
+
+  using FieldMetadata_EffectiveTransform =
+    ::protozero::proto_utils::FieldMetadata<
+      43,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TransformProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_EffectiveTransform kEffectiveTransform{};
+  template <typename T = TransformProto> T* set_effective_transform() {
+    return BeginNestedMessage<T>(43);
+  }
+
+
+  using FieldMetadata_SourceBounds =
+    ::protozero::proto_utils::FieldMetadata<
+      44,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FloatRectProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_SourceBounds kSourceBounds{};
+  template <typename T = FloatRectProto> T* set_source_bounds() {
+    return BeginNestedMessage<T>(44);
+  }
+
+
+  using FieldMetadata_Bounds =
+    ::protozero::proto_utils::FieldMetadata<
+      45,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FloatRectProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_Bounds kBounds{};
+  template <typename T = FloatRectProto> T* set_bounds() {
+    return BeginNestedMessage<T>(45);
+  }
+
+
+  using FieldMetadata_ScreenBounds =
+    ::protozero::proto_utils::FieldMetadata<
+      46,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FloatRectProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_ScreenBounds kScreenBounds{};
+  template <typename T = FloatRectProto> T* set_screen_bounds() {
+    return BeginNestedMessage<T>(46);
+  }
+
+
+  using FieldMetadata_InputWindowInfo =
+    ::protozero::proto_utils::FieldMetadata<
+      47,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      InputWindowInfoProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_InputWindowInfo kInputWindowInfo{};
+  template <typename T = InputWindowInfoProto> T* set_input_window_info() {
+    return BeginNestedMessage<T>(47);
+  }
+
+
+  using FieldMetadata_CornerRadiusCrop =
+    ::protozero::proto_utils::FieldMetadata<
+      48,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FloatRectProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_CornerRadiusCrop kCornerRadiusCrop{};
+  template <typename T = FloatRectProto> T* set_corner_radius_crop() {
+    return BeginNestedMessage<T>(48);
+  }
+
+
+  using FieldMetadata_ShadowRadius =
+    ::protozero::proto_utils::FieldMetadata<
+      49,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerProto>;
+
+  static constexpr FieldMetadata_ShadowRadius kShadowRadius{};
+  void set_shadow_radius(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_ShadowRadius::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ColorTransform =
+    ::protozero::proto_utils::FieldMetadata<
+      50,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ColorTransformProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_ColorTransform kColorTransform{};
+  template <typename T = ColorTransformProto> T* set_color_transform() {
+    return BeginNestedMessage<T>(50);
+  }
+
+
+  using FieldMetadata_IsRelativeOf =
+    ::protozero::proto_utils::FieldMetadata<
+      51,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      LayerProto>;
+
+  static constexpr FieldMetadata_IsRelativeOf kIsRelativeOf{};
+  void set_is_relative_of(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsRelativeOf::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BackgroundBlurRadius =
+    ::protozero::proto_utils::FieldMetadata<
+      52,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LayerProto>;
+
+  static constexpr FieldMetadata_BackgroundBlurRadius kBackgroundBlurRadius{};
+  void set_background_blur_radius(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BackgroundBlurRadius::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OwnerUid =
+    ::protozero::proto_utils::FieldMetadata<
+      53,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerProto>;
+
+  static constexpr FieldMetadata_OwnerUid kOwnerUid{};
+  void set_owner_uid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OwnerUid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BlurRegions =
+    ::protozero::proto_utils::FieldMetadata<
+      54,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BlurRegion,
+      LayerProto>;
+
+  static constexpr FieldMetadata_BlurRegions kBlurRegions{};
+  template <typename T = BlurRegion> T* add_blur_regions() {
+    return BeginNestedMessage<T>(54);
+  }
+
+
+  using FieldMetadata_IsTrustedOverlay =
+    ::protozero::proto_utils::FieldMetadata<
+      55,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      LayerProto>;
+
+  static constexpr FieldMetadata_IsTrustedOverlay kIsTrustedOverlay{};
+  void set_is_trusted_overlay(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsTrustedOverlay::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_RequestedCornerRadius =
+    ::protozero::proto_utils::FieldMetadata<
+      56,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerProto>;
+
+  static constexpr FieldMetadata_RequestedCornerRadius kRequestedCornerRadius{};
+  void set_requested_corner_radius(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_RequestedCornerRadius::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DestinationFrame =
+    ::protozero::proto_utils::FieldMetadata<
+      57,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      RectProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_DestinationFrame kDestinationFrame{};
+  template <typename T = RectProto> T* set_destination_frame() {
+    return BeginNestedMessage<T>(57);
+  }
+
+
+  using FieldMetadata_OriginalId =
+    ::protozero::proto_utils::FieldMetadata<
+      58,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerProto>;
+
+  static constexpr FieldMetadata_OriginalId kOriginalId{};
+  void set_original_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OriginalId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TrustedOverlay =
+    ::protozero::proto_utils::FieldMetadata<
+      59,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      TrustedOverlay,
+      LayerProto>;
+
+  static constexpr FieldMetadata_TrustedOverlay kTrustedOverlay{};
+  void set_trusted_overlay(TrustedOverlay value) {
+    static constexpr uint32_t field_id = FieldMetadata_TrustedOverlay::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BackgroundBlurScale =
+    ::protozero::proto_utils::FieldMetadata<
+      60,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerProto>;
+
+  static constexpr FieldMetadata_BackgroundBlurScale kBackgroundBlurScale{};
+  void set_background_blur_scale(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_BackgroundBlurScale::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CornerRadii =
+    ::protozero::proto_utils::FieldMetadata<
+      61,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      CornerRadiiProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_CornerRadii kCornerRadii{};
+  template <typename T = CornerRadiiProto> T* set_corner_radii() {
+    return BeginNestedMessage<T>(61);
+  }
+
+
+  using FieldMetadata_RequestedCornerRadii =
+    ::protozero::proto_utils::FieldMetadata<
+      62,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      CornerRadiiProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_RequestedCornerRadii kRequestedCornerRadii{};
+  template <typename T = CornerRadiiProto> T* set_requested_corner_radii() {
+    return BeginNestedMessage<T>(62);
+  }
+
+
+  using FieldMetadata_ClientDrawnCornerRadii =
+    ::protozero::proto_utils::FieldMetadata<
+      63,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      CornerRadiiProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_ClientDrawnCornerRadii kClientDrawnCornerRadii{};
+  template <typename T = CornerRadiiProto> T* set_client_drawn_corner_radii() {
+    return BeginNestedMessage<T>(63);
+  }
+
+
+  using FieldMetadata_SystemContentPriority =
+    ::protozero::proto_utils::FieldMetadata<
+      64,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LayerProto>;
+
+  static constexpr FieldMetadata_SystemContentPriority kSystemContentPriority{};
+  void set_system_content_priority(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SystemContentPriority::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BoxShadowSettings =
+    ::protozero::proto_utils::FieldMetadata<
+      65,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BoxShadowSettings,
+      LayerProto>;
+
+  static constexpr FieldMetadata_BoxShadowSettings kBoxShadowSettings{};
+  template <typename T = BoxShadowSettings> T* set_box_shadow_settings() {
+    return BeginNestedMessage<T>(65);
+  }
+
+
+  using FieldMetadata_BorderSettings =
+    ::protozero::proto_utils::FieldMetadata<
+      66,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BorderSettings,
+      LayerProto>;
+
+  static constexpr FieldMetadata_BorderSettings kBorderSettings{};
+  template <typename T = BorderSettings> T* set_border_settings() {
+    return BeginNestedMessage<T>(66);
+  }
+
+
+  using FieldMetadata_EffectiveRadii =
+    ::protozero::proto_utils::FieldMetadata<
+      67,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      CornerRadiiProto,
+      LayerProto>;
+
+  static constexpr FieldMetadata_EffectiveRadii kEffectiveRadii{};
+  template <typename T = CornerRadiiProto> T* set_effective_radii() {
+    return BeginNestedMessage<T>(67);
+  }
+
+};
+
+class LayerProto_MetadataEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  LayerProto_MetadataEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit LayerProto_MetadataEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit LayerProto_MetadataEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_key() const { return at<1>().valid(); }
+  int32_t key() const { return at<1>().as_int32(); }
+  bool has_value() const { return at<2>().valid(); }
+  ::protozero::ConstBytes value() const { return at<2>().as_bytes(); }
+};
+
+class LayerProto_MetadataEntry : public ::protozero::Message {
+ public:
+  using Decoder = LayerProto_MetadataEntry_Decoder;
+  enum : int32_t {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.LayerProto.MetadataEntry"; }
+
+
+  using FieldMetadata_Key =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LayerProto_MetadataEntry>;
+
+  static constexpr FieldMetadata_Key kKey{};
+  void set_key(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      LayerProto_MetadataEntry>;
+
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
+  }
+  void set_value(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_Value::kFieldId, bytes.data, bytes.size);
+  }
+  void set_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class DisplayProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9> {
+ public:
+  DisplayProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DisplayProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DisplayProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  uint64_t id() const { return at<1>().as_uint64(); }
+  bool has_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars name() const { return at<2>().as_string(); }
+  bool has_layer_stack() const { return at<3>().valid(); }
+  uint32_t layer_stack() const { return at<3>().as_uint32(); }
+  bool has_size() const { return at<4>().valid(); }
+  ::protozero::ConstBytes size() const { return at<4>().as_bytes(); }
+  bool has_layer_stack_space_rect() const { return at<5>().valid(); }
+  ::protozero::ConstBytes layer_stack_space_rect() const { return at<5>().as_bytes(); }
+  bool has_transform() const { return at<6>().valid(); }
+  ::protozero::ConstBytes transform() const { return at<6>().as_bytes(); }
+  bool has_is_virtual() const { return at<7>().valid(); }
+  bool is_virtual() const { return at<7>().as_bool(); }
+  bool has_dpi_x() const { return at<8>().valid(); }
+  double dpi_x() const { return at<8>().as_double(); }
+  bool has_dpi_y() const { return at<9>().valid(); }
+  double dpi_y() const { return at<9>().as_double(); }
+};
+
+class DisplayProto : public ::protozero::Message {
+ public:
+  using Decoder = DisplayProto_Decoder;
+  enum : int32_t {
+    kIdFieldNumber = 1,
+    kNameFieldNumber = 2,
+    kLayerStackFieldNumber = 3,
+    kSizeFieldNumber = 4,
+    kLayerStackSpaceRectFieldNumber = 5,
+    kTransformFieldNumber = 6,
+    kIsVirtualFieldNumber = 7,
+    kDpiXFieldNumber = 8,
+    kDpiYFieldNumber = 9,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.DisplayProto"; }
+
+
+  using FieldMetadata_Id =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      DisplayProto>;
+
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      DisplayProto>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_LayerStack =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      DisplayProto>;
+
+  static constexpr FieldMetadata_LayerStack kLayerStack{};
+  void set_layer_stack(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LayerStack::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Size =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SizeProto,
+      DisplayProto>;
+
+  static constexpr FieldMetadata_Size kSize{};
+  template <typename T = SizeProto> T* set_size() {
+    return BeginNestedMessage<T>(4);
+  }
+
+
+  using FieldMetadata_LayerStackSpaceRect =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      RectProto,
+      DisplayProto>;
+
+  static constexpr FieldMetadata_LayerStackSpaceRect kLayerStackSpaceRect{};
+  template <typename T = RectProto> T* set_layer_stack_space_rect() {
+    return BeginNestedMessage<T>(5);
+  }
+
+
+  using FieldMetadata_Transform =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TransformProto,
+      DisplayProto>;
+
+  static constexpr FieldMetadata_Transform kTransform{};
+  template <typename T = TransformProto> T* set_transform() {
+    return BeginNestedMessage<T>(6);
+  }
+
+
+  using FieldMetadata_IsVirtual =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      DisplayProto>;
+
+  static constexpr FieldMetadata_IsVirtual kIsVirtual{};
+  void set_is_virtual(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsVirtual::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DpiX =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kDouble,
+      double,
+      DisplayProto>;
+
+  static constexpr FieldMetadata_DpiX kDpiX{};
+  void set_dpi_x(double value) {
+    static constexpr uint32_t field_id = FieldMetadata_DpiX::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DpiY =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kDouble,
+      double,
+      DisplayProto>;
+
+  static constexpr FieldMetadata_DpiY kDpiY{};
+  void set_dpi_y(double value) {
+    static constexpr uint32_t field_id = FieldMetadata_DpiY::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class LayersProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  LayersProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit LayersProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit LayersProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_layers() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> layers() const { return GetRepeated<::protozero::ConstBytes>(1); }
+};
+
+class LayersProto : public ::protozero::Message {
+ public:
+  using Decoder = LayersProto_Decoder;
+  enum : int32_t {
+    kLayersFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.LayersProto"; }
+
+
+  using FieldMetadata_Layers =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      LayerProto,
+      LayersProto>;
+
+  static constexpr FieldMetadata_Layers kLayers{};
+  template <typename T = LayerProto> T* add_layers() {
+    return BeginNestedMessage<T>(1);
+  }
+
+};
+
+class LayersSnapshotProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
+ public:
+  LayersSnapshotProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit LayersSnapshotProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit LayersSnapshotProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_elapsed_realtime_nanos() const { return at<1>().valid(); }
+  int64_t elapsed_realtime_nanos() const { return at<1>().as_int64(); }
+  bool has_where() const { return at<2>().valid(); }
+  ::protozero::ConstChars where() const { return at<2>().as_string(); }
+  bool has_layers() const { return at<3>().valid(); }
+  ::protozero::ConstBytes layers() const { return at<3>().as_bytes(); }
+  bool has_hwc_blob() const { return at<4>().valid(); }
+  ::protozero::ConstChars hwc_blob() const { return at<4>().as_string(); }
+  bool has_excludes_composition_state() const { return at<5>().valid(); }
+  bool excludes_composition_state() const { return at<5>().as_bool(); }
+  bool has_missed_entries() const { return at<6>().valid(); }
+  uint32_t missed_entries() const { return at<6>().as_uint32(); }
+  bool has_displays() const { return at<7>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> displays() const { return GetRepeated<::protozero::ConstBytes>(7); }
+  bool has_vsync_id() const { return at<8>().valid(); }
+  int64_t vsync_id() const { return at<8>().as_int64(); }
+};
+
+class LayersSnapshotProto : public ::protozero::Message {
+ public:
+  using Decoder = LayersSnapshotProto_Decoder;
+  enum : int32_t {
+    kElapsedRealtimeNanosFieldNumber = 1,
+    kWhereFieldNumber = 2,
+    kLayersFieldNumber = 3,
+    kHwcBlobFieldNumber = 4,
+    kExcludesCompositionStateFieldNumber = 5,
+    kMissedEntriesFieldNumber = 6,
+    kDisplaysFieldNumber = 7,
+    kVsyncIdFieldNumber = 8,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.LayersSnapshotProto"; }
+
+
+  using FieldMetadata_ElapsedRealtimeNanos =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kSfixed64,
+      int64_t,
+      LayersSnapshotProto>;
+
+  static constexpr FieldMetadata_ElapsedRealtimeNanos kElapsedRealtimeNanos{};
+  void set_elapsed_realtime_nanos(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ElapsedRealtimeNanos::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kSfixed64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Where =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      LayersSnapshotProto>;
+
+  static constexpr FieldMetadata_Where kWhere{};
+  void set_where(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Where::kFieldId, data, size);
+  }
+  void set_where(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Where::kFieldId, chars.data, chars.size);
+  }
+  void set_where(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Where::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Layers =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      LayersProto,
+      LayersSnapshotProto>;
+
+  static constexpr FieldMetadata_Layers kLayers{};
+  template <typename T = LayersProto> T* set_layers() {
+    return BeginNestedMessage<T>(3);
+  }
+
+
+  using FieldMetadata_HwcBlob =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      LayersSnapshotProto>;
+
+  static constexpr FieldMetadata_HwcBlob kHwcBlob{};
+  void set_hwc_blob(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_HwcBlob::kFieldId, data, size);
+  }
+  void set_hwc_blob(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_HwcBlob::kFieldId, chars.data, chars.size);
+  }
+  void set_hwc_blob(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_HwcBlob::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ExcludesCompositionState =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      LayersSnapshotProto>;
+
+  static constexpr FieldMetadata_ExcludesCompositionState kExcludesCompositionState{};
+  void set_excludes_composition_state(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ExcludesCompositionState::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MissedEntries =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayersSnapshotProto>;
+
+  static constexpr FieldMetadata_MissedEntries kMissedEntries{};
+  void set_missed_entries(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MissedEntries::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Displays =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      DisplayProto,
+      LayersSnapshotProto>;
+
+  static constexpr FieldMetadata_Displays kDisplays{};
+  template <typename T = DisplayProto> T* add_displays() {
+    return BeginNestedMessage<T>(7);
+  }
+
+
+  using FieldMetadata_VsyncId =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      LayersSnapshotProto>;
+
+  static constexpr FieldMetadata_VsyncId kVsyncId{};
+  void set_vsync_id(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VsyncId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class LayersTraceFileProto_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  LayersTraceFileProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit LayersTraceFileProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit LayersTraceFileProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_magic_number() const { return at<1>().valid(); }
+  uint64_t magic_number() const { return at<1>().as_uint64(); }
+  bool has_entry() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> entry() const { return GetRepeated<::protozero::ConstBytes>(2); }
+  bool has_real_to_elapsed_time_offset_nanos() const { return at<3>().valid(); }
+  uint64_t real_to_elapsed_time_offset_nanos() const { return at<3>().as_uint64(); }
+};
+
+class LayersTraceFileProto : public ::protozero::Message {
+ public:
+  using Decoder = LayersTraceFileProto_Decoder;
+  enum : int32_t {
+    kMagicNumberFieldNumber = 1,
+    kEntryFieldNumber = 2,
+    kRealToElapsedTimeOffsetNanosFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.LayersTraceFileProto"; }
+
+
+  using MagicNumber = ::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber;
+  static inline const char* MagicNumber_Name(MagicNumber value) {
+    return ::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber_Name(value);
+  }
+  static inline const MagicNumber INVALID = MagicNumber::INVALID;
+  static inline const MagicNumber MAGIC_NUMBER_L = MagicNumber::MAGIC_NUMBER_L;
+  static inline const MagicNumber MAGIC_NUMBER_H = MagicNumber::MAGIC_NUMBER_H;
+
+  using FieldMetadata_MagicNumber =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
+      uint64_t,
+      LayersTraceFileProto>;
+
+  static constexpr FieldMetadata_MagicNumber kMagicNumber{};
+  void set_magic_number(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MagicNumber::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Entry =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      LayersSnapshotProto,
+      LayersTraceFileProto>;
+
+  static constexpr FieldMetadata_Entry kEntry{};
+  template <typename T = LayersSnapshotProto> T* add_entry() {
+    return BeginNestedMessage<T>(2);
+  }
+
+
+  using FieldMetadata_RealToElapsedTimeOffsetNanos =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
+      uint64_t,
+      LayersTraceFileProto>;
+
+  static constexpr FieldMetadata_RealToElapsedTimeOffsetNanos kRealToElapsedTimeOffsetNanos{};
+  void set_real_to_elapsed_time_offset_nanos(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RealToElapsedTimeOffsetNanos::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/surfaceflinger_transactions.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SURFACEFLINGER_TRANSACTIONS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SURFACEFLINGER_TRANSACTIONS_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class BlurRegion;
+class BorderSettings;
+class BoxShadowSettings;
+class ColorTransformProto;
+class DisplayInfo;
+class DisplayState;
+class LayerCreationArgs;
+class LayerState;
+class LayerState_BufferData;
+class LayerState_Color3;
+class LayerState_CornerRadii;
+class LayerState_Matrix22;
+class LayerState_WindowInfo;
+class RectProto;
+class RegionProto;
+class TransactionBarrier;
+class TransactionState;
+class TransactionTraceEntry;
+class Transform;
+namespace perfetto_pbzero_enum_LayerState_BufferData {
+enum PixelFormat : int32_t;
+}  // namespace perfetto_pbzero_enum_LayerState_BufferData
+using LayerState_BufferData_PixelFormat = perfetto_pbzero_enum_LayerState_BufferData::PixelFormat;
+namespace perfetto_pbzero_enum_LayerState {
+enum DropInputMode : int32_t;
+}  // namespace perfetto_pbzero_enum_LayerState
+using LayerState_DropInputMode = perfetto_pbzero_enum_LayerState::DropInputMode;
+enum TrustedOverlay : int32_t;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_DisplayState {
+enum Changes : int32_t {
+  eChangesNone = 0,
+  eSurfaceChanged = 1,
+  eLayerStackChanged = 2,
+  eDisplayProjectionChanged = 4,
+  eDisplaySizeChanged = 8,
+  eFlagsChanged = 16,
+};
+} // namespace perfetto_pbzero_enum_DisplayState
+using DisplayState_Changes = perfetto_pbzero_enum_DisplayState::Changes;
+
+
+constexpr DisplayState_Changes DisplayState_Changes_MIN = DisplayState_Changes::eChangesNone;
+constexpr DisplayState_Changes DisplayState_Changes_MAX = DisplayState_Changes::eFlagsChanged;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* DisplayState_Changes_Name(::perfetto::protos::pbzero::DisplayState_Changes value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::DisplayState_Changes::eChangesNone:
+    return "eChangesNone";
+
+  case ::perfetto::protos::pbzero::DisplayState_Changes::eSurfaceChanged:
+    return "eSurfaceChanged";
+
+  case ::perfetto::protos::pbzero::DisplayState_Changes::eLayerStackChanged:
+    return "eLayerStackChanged";
+
+  case ::perfetto::protos::pbzero::DisplayState_Changes::eDisplayProjectionChanged:
+    return "eDisplayProjectionChanged";
+
+  case ::perfetto::protos::pbzero::DisplayState_Changes::eDisplaySizeChanged:
+    return "eDisplaySizeChanged";
+
+  case ::perfetto::protos::pbzero::DisplayState_Changes::eFlagsChanged:
+    return "eFlagsChanged";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_LayerState {
+enum ChangesLsb : int32_t {
+  eChangesLsbNone = 0,
+  ePositionChanged = 1,
+  eLayerChanged = 2,
+  eAlphaChanged = 8,
+  eMatrixChanged = 16,
+  eTransparentRegionChanged = 32,
+  eFlagsChanged = 64,
+  eLayerStackChanged = 128,
+  eReleaseBufferListenerChanged = 1024,
+  eShadowRadiusChanged = 2048,
+  eBufferCropChanged = 8192,
+  eRelativeLayerChanged = 16384,
+  eReparent = 32768,
+  eColorChanged = 65536,
+  eBufferTransformChanged = 262144,
+  eTransformToDisplayInverseChanged = 524288,
+  eCropChanged = 1048576,
+  eBufferChanged = 2097152,
+  eAcquireFenceChanged = 4194304,
+  eDataspaceChanged = 8388608,
+  eHdrMetadataChanged = 16777216,
+  eSurfaceDamageRegionChanged = 33554432,
+  eApiChanged = 67108864,
+  eSidebandStreamChanged = 134217728,
+  eColorTransformChanged = 268435456,
+  eHasListenerCallbacksChanged = 536870912,
+  eInputInfoChanged = 1073741824,
+  eCornerRadiusChanged = -2147483647 - 1,
+};
+} // namespace perfetto_pbzero_enum_LayerState
+using LayerState_ChangesLsb = perfetto_pbzero_enum_LayerState::ChangesLsb;
+
+
+constexpr LayerState_ChangesLsb LayerState_ChangesLsb_MIN = LayerState_ChangesLsb::eCornerRadiusChanged;
+constexpr LayerState_ChangesLsb LayerState_ChangesLsb_MAX = LayerState_ChangesLsb::eInputInfoChanged;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* LayerState_ChangesLsb_Name(::perfetto::protos::pbzero::LayerState_ChangesLsb value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eChangesLsbNone:
+    return "eChangesLsbNone";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::ePositionChanged:
+    return "ePositionChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eLayerChanged:
+    return "eLayerChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eAlphaChanged:
+    return "eAlphaChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eMatrixChanged:
+    return "eMatrixChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eTransparentRegionChanged:
+    return "eTransparentRegionChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eFlagsChanged:
+    return "eFlagsChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eLayerStackChanged:
+    return "eLayerStackChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eReleaseBufferListenerChanged:
+    return "eReleaseBufferListenerChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eShadowRadiusChanged:
+    return "eShadowRadiusChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eBufferCropChanged:
+    return "eBufferCropChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eRelativeLayerChanged:
+    return "eRelativeLayerChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eReparent:
+    return "eReparent";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eColorChanged:
+    return "eColorChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eBufferTransformChanged:
+    return "eBufferTransformChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eTransformToDisplayInverseChanged:
+    return "eTransformToDisplayInverseChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eCropChanged:
+    return "eCropChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eBufferChanged:
+    return "eBufferChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eAcquireFenceChanged:
+    return "eAcquireFenceChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eDataspaceChanged:
+    return "eDataspaceChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eHdrMetadataChanged:
+    return "eHdrMetadataChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eSurfaceDamageRegionChanged:
+    return "eSurfaceDamageRegionChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eApiChanged:
+    return "eApiChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eSidebandStreamChanged:
+    return "eSidebandStreamChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eColorTransformChanged:
+    return "eColorTransformChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eHasListenerCallbacksChanged:
+    return "eHasListenerCallbacksChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eInputInfoChanged:
+    return "eInputInfoChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eCornerRadiusChanged:
+    return "eCornerRadiusChanged";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_LayerState {
+enum ChangesMsb : int32_t {
+  eChangesMsbNone = 0,
+  eDestinationFrameChanged = 1,
+  eCachedBufferChanged = 2,
+  eBackgroundColorChanged = 4,
+  eMetadataChanged = 8,
+  eColorSpaceAgnosticChanged = 16,
+  eFrameRateSelectionPriority = 32,
+  eFrameRateChanged = 64,
+  eBackgroundBlurRadiusChanged = 128,
+  eProducerDisconnect = 256,
+  eFixedTransformHintChanged = 512,
+  eFrameNumberChanged = 1024,
+  eBlurRegionsChanged = 2048,
+  eAutoRefreshChanged = 4096,
+  eStretchChanged = 8192,
+  eTrustedOverlayChanged = 16384,
+  eDropInputModeChanged = 32768,
+  eClientDrawnCornerRadiusChanged = 65536,
+  eSystemContentPriorityChanged = 131072,
+  eBoxShadowSettingsChanged = 262144,
+  eBorderSettingsChanged = 524288,
+};
+} // namespace perfetto_pbzero_enum_LayerState
+using LayerState_ChangesMsb = perfetto_pbzero_enum_LayerState::ChangesMsb;
+
+
+constexpr LayerState_ChangesMsb LayerState_ChangesMsb_MIN = LayerState_ChangesMsb::eChangesMsbNone;
+constexpr LayerState_ChangesMsb LayerState_ChangesMsb_MAX = LayerState_ChangesMsb::eBorderSettingsChanged;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* LayerState_ChangesMsb_Name(::perfetto::protos::pbzero::LayerState_ChangesMsb value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eChangesMsbNone:
+    return "eChangesMsbNone";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eDestinationFrameChanged:
+    return "eDestinationFrameChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eCachedBufferChanged:
+    return "eCachedBufferChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eBackgroundColorChanged:
+    return "eBackgroundColorChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eMetadataChanged:
+    return "eMetadataChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eColorSpaceAgnosticChanged:
+    return "eColorSpaceAgnosticChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eFrameRateSelectionPriority:
+    return "eFrameRateSelectionPriority";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eFrameRateChanged:
+    return "eFrameRateChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eBackgroundBlurRadiusChanged:
+    return "eBackgroundBlurRadiusChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eProducerDisconnect:
+    return "eProducerDisconnect";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eFixedTransformHintChanged:
+    return "eFixedTransformHintChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eFrameNumberChanged:
+    return "eFrameNumberChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eBlurRegionsChanged:
+    return "eBlurRegionsChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eAutoRefreshChanged:
+    return "eAutoRefreshChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eStretchChanged:
+    return "eStretchChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eTrustedOverlayChanged:
+    return "eTrustedOverlayChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eDropInputModeChanged:
+    return "eDropInputModeChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eClientDrawnCornerRadiusChanged:
+    return "eClientDrawnCornerRadiusChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eSystemContentPriorityChanged:
+    return "eSystemContentPriorityChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eBoxShadowSettingsChanged:
+    return "eBoxShadowSettingsChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eBorderSettingsChanged:
+    return "eBorderSettingsChanged";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_LayerState {
+enum Flags : int32_t {
+  eFlagsNone = 0,
+  eLayerHidden = 1,
+  eLayerOpaque = 2,
+  eLayerSkipScreenshot = 64,
+  eLayerSecure = 128,
+  eEnableBackpressure = 256,
+  eLayerIsDisplayDecoration = 512,
+};
+} // namespace perfetto_pbzero_enum_LayerState
+using LayerState_Flags = perfetto_pbzero_enum_LayerState::Flags;
+
+
+constexpr LayerState_Flags LayerState_Flags_MIN = LayerState_Flags::eFlagsNone;
+constexpr LayerState_Flags LayerState_Flags_MAX = LayerState_Flags::eLayerIsDisplayDecoration;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* LayerState_Flags_Name(::perfetto::protos::pbzero::LayerState_Flags value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::LayerState_Flags::eFlagsNone:
+    return "eFlagsNone";
+
+  case ::perfetto::protos::pbzero::LayerState_Flags::eLayerHidden:
+    return "eLayerHidden";
+
+  case ::perfetto::protos::pbzero::LayerState_Flags::eLayerOpaque:
+    return "eLayerOpaque";
+
+  case ::perfetto::protos::pbzero::LayerState_Flags::eLayerSkipScreenshot:
+    return "eLayerSkipScreenshot";
+
+  case ::perfetto::protos::pbzero::LayerState_Flags::eLayerSecure:
+    return "eLayerSecure";
+
+  case ::perfetto::protos::pbzero::LayerState_Flags::eEnableBackpressure:
+    return "eEnableBackpressure";
+
+  case ::perfetto::protos::pbzero::LayerState_Flags::eLayerIsDisplayDecoration:
+    return "eLayerIsDisplayDecoration";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_LayerState {
+enum DropInputMode : int32_t {
+  NONE = 0,
+  ALL = 1,
+  OBSCURED = 2,
+};
+} // namespace perfetto_pbzero_enum_LayerState
+using LayerState_DropInputMode = perfetto_pbzero_enum_LayerState::DropInputMode;
+
+
+constexpr LayerState_DropInputMode LayerState_DropInputMode_MIN = LayerState_DropInputMode::NONE;
+constexpr LayerState_DropInputMode LayerState_DropInputMode_MAX = LayerState_DropInputMode::OBSCURED;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* LayerState_DropInputMode_Name(::perfetto::protos::pbzero::LayerState_DropInputMode value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::LayerState_DropInputMode::NONE:
+    return "NONE";
+
+  case ::perfetto::protos::pbzero::LayerState_DropInputMode::ALL:
+    return "ALL";
+
+  case ::perfetto::protos::pbzero::LayerState_DropInputMode::OBSCURED:
+    return "OBSCURED";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_LayerState_BufferData {
+enum BufferDataChange : int32_t {
+  BufferDataChangeNone = 0,
+  fenceChanged = 1,
+  frameNumberChanged = 2,
+  cachedBufferChanged = 4,
+};
+} // namespace perfetto_pbzero_enum_LayerState_BufferData
+using LayerState_BufferData_BufferDataChange = perfetto_pbzero_enum_LayerState_BufferData::BufferDataChange;
+
+
+constexpr LayerState_BufferData_BufferDataChange LayerState_BufferData_BufferDataChange_MIN = LayerState_BufferData_BufferDataChange::BufferDataChangeNone;
+constexpr LayerState_BufferData_BufferDataChange LayerState_BufferData_BufferDataChange_MAX = LayerState_BufferData_BufferDataChange::cachedBufferChanged;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* LayerState_BufferData_BufferDataChange_Name(::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange::BufferDataChangeNone:
+    return "BufferDataChangeNone";
+
+  case ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange::fenceChanged:
+    return "fenceChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange::frameNumberChanged:
+    return "frameNumberChanged";
+
+  case ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange::cachedBufferChanged:
+    return "cachedBufferChanged";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_LayerState_BufferData {
+enum PixelFormat : int32_t {
+  PIXEL_FORMAT_UNKNOWN = 0,
+  PIXEL_FORMAT_CUSTOM = -4,
+  PIXEL_FORMAT_TRANSLUCENT = -3,
+  PIXEL_FORMAT_TRANSPARENT = -2,
+  PIXEL_FORMAT_OPAQUE = -1,
+  PIXEL_FORMAT_RGBA_8888 = 1,
+  PIXEL_FORMAT_RGBX_8888 = 2,
+  PIXEL_FORMAT_RGB_888 = 3,
+  PIXEL_FORMAT_RGB_565 = 4,
+  PIXEL_FORMAT_BGRA_8888 = 5,
+  PIXEL_FORMAT_RGBA_5551 = 6,
+  PIXEL_FORMAT_RGBA_4444 = 7,
+  PIXEL_FORMAT_RGBA_FP16 = 22,
+  PIXEL_FORMAT_RGBA_1010102 = 43,
+  PIXEL_FORMAT_R_8 = 56,
+};
+} // namespace perfetto_pbzero_enum_LayerState_BufferData
+using LayerState_BufferData_PixelFormat = perfetto_pbzero_enum_LayerState_BufferData::PixelFormat;
+
+
+constexpr LayerState_BufferData_PixelFormat LayerState_BufferData_PixelFormat_MIN = LayerState_BufferData_PixelFormat::PIXEL_FORMAT_CUSTOM;
+constexpr LayerState_BufferData_PixelFormat LayerState_BufferData_PixelFormat_MAX = LayerState_BufferData_PixelFormat::PIXEL_FORMAT_R_8;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* LayerState_BufferData_PixelFormat_Name(::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_UNKNOWN:
+    return "PIXEL_FORMAT_UNKNOWN";
+
+  case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_CUSTOM:
+    return "PIXEL_FORMAT_CUSTOM";
+
+  case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_TRANSLUCENT:
+    return "PIXEL_FORMAT_TRANSLUCENT";
+
+  case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_TRANSPARENT:
+    return "PIXEL_FORMAT_TRANSPARENT";
+
+  case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_OPAQUE:
+    return "PIXEL_FORMAT_OPAQUE";
+
+  case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBA_8888:
+    return "PIXEL_FORMAT_RGBA_8888";
+
+  case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBX_8888:
+    return "PIXEL_FORMAT_RGBX_8888";
+
+  case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGB_888:
+    return "PIXEL_FORMAT_RGB_888";
+
+  case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGB_565:
+    return "PIXEL_FORMAT_RGB_565";
+
+  case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_BGRA_8888:
+    return "PIXEL_FORMAT_BGRA_8888";
+
+  case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBA_5551:
+    return "PIXEL_FORMAT_RGBA_5551";
+
+  case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBA_4444:
+    return "PIXEL_FORMAT_RGBA_4444";
+
+  case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBA_FP16:
+    return "PIXEL_FORMAT_RGBA_FP16";
+
+  case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBA_1010102:
+    return "PIXEL_FORMAT_RGBA_1010102";
+
+  case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_R_8:
+    return "PIXEL_FORMAT_R_8";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_TransactionTraceFile {
+enum MagicNumber : int32_t {
+  INVALID = 0,
+  MAGIC_NUMBER_L = 1415073364,
+  MAGIC_NUMBER_H = 1162035538,
+};
+} // namespace perfetto_pbzero_enum_TransactionTraceFile
+using TransactionTraceFile_MagicNumber = perfetto_pbzero_enum_TransactionTraceFile::MagicNumber;
+
+
+constexpr TransactionTraceFile_MagicNumber TransactionTraceFile_MagicNumber_MIN = TransactionTraceFile_MagicNumber::INVALID;
+constexpr TransactionTraceFile_MagicNumber TransactionTraceFile_MagicNumber_MAX = TransactionTraceFile_MagicNumber::MAGIC_NUMBER_L;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* TransactionTraceFile_MagicNumber_Name(::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber::INVALID:
+    return "INVALID";
+
+  case ::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber::MAGIC_NUMBER_L:
+    return "MAGIC_NUMBER_L";
+
+  case ::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber::MAGIC_NUMBER_H:
+    return "MAGIC_NUMBER_H";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class DisplayState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9> {
+ public:
+  DisplayState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DisplayState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DisplayState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  int32_t id() const { return at<1>().as_int32(); }
+  bool has_what() const { return at<2>().valid(); }
+  uint32_t what() const { return at<2>().as_uint32(); }
+  bool has_flags() const { return at<3>().valid(); }
+  uint32_t flags() const { return at<3>().as_uint32(); }
+  bool has_layer_stack() const { return at<4>().valid(); }
+  uint32_t layer_stack() const { return at<4>().as_uint32(); }
+  bool has_orientation() const { return at<5>().valid(); }
+  uint32_t orientation() const { return at<5>().as_uint32(); }
+  bool has_layer_stack_space_rect() const { return at<6>().valid(); }
+  ::protozero::ConstBytes layer_stack_space_rect() const { return at<6>().as_bytes(); }
+  bool has_oriented_display_space_rect() const { return at<7>().valid(); }
+  ::protozero::ConstBytes oriented_display_space_rect() const { return at<7>().as_bytes(); }
+  bool has_width() const { return at<8>().valid(); }
+  uint32_t width() const { return at<8>().as_uint32(); }
+  bool has_height() const { return at<9>().valid(); }
+  uint32_t height() const { return at<9>().as_uint32(); }
+};
+
+class DisplayState : public ::protozero::Message {
+ public:
+  using Decoder = DisplayState_Decoder;
+  enum : int32_t {
+    kIdFieldNumber = 1,
+    kWhatFieldNumber = 2,
+    kFlagsFieldNumber = 3,
+    kLayerStackFieldNumber = 4,
+    kOrientationFieldNumber = 5,
+    kLayerStackSpaceRectFieldNumber = 6,
+    kOrientedDisplaySpaceRectFieldNumber = 7,
+    kWidthFieldNumber = 8,
+    kHeightFieldNumber = 9,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.DisplayState"; }
+
+
+  using Changes = ::perfetto::protos::pbzero::DisplayState_Changes;
+  static inline const char* Changes_Name(Changes value) {
+    return ::perfetto::protos::pbzero::DisplayState_Changes_Name(value);
+  }
+  static inline const Changes eChangesNone = Changes::eChangesNone;
+  static inline const Changes eSurfaceChanged = Changes::eSurfaceChanged;
+  static inline const Changes eLayerStackChanged = Changes::eLayerStackChanged;
+  static inline const Changes eDisplayProjectionChanged = Changes::eDisplayProjectionChanged;
+  static inline const Changes eDisplaySizeChanged = Changes::eDisplaySizeChanged;
+  static inline const Changes eFlagsChanged = Changes::eFlagsChanged;
+
+  using FieldMetadata_Id =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      DisplayState>;
+
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_What =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      DisplayState>;
+
+  static constexpr FieldMetadata_What kWhat{};
+  void set_what(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_What::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Flags =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      DisplayState>;
+
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_LayerStack =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      DisplayState>;
+
+  static constexpr FieldMetadata_LayerStack kLayerStack{};
+  void set_layer_stack(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LayerStack::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Orientation =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      DisplayState>;
+
+  static constexpr FieldMetadata_Orientation kOrientation{};
+  void set_orientation(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Orientation::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_LayerStackSpaceRect =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      RectProto,
+      DisplayState>;
+
+  static constexpr FieldMetadata_LayerStackSpaceRect kLayerStackSpaceRect{};
+  template <typename T = RectProto> T* set_layer_stack_space_rect() {
+    return BeginNestedMessage<T>(6);
+  }
+
+
+  using FieldMetadata_OrientedDisplaySpaceRect =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      RectProto,
+      DisplayState>;
+
+  static constexpr FieldMetadata_OrientedDisplaySpaceRect kOrientedDisplaySpaceRect{};
+  template <typename T = RectProto> T* set_oriented_display_space_rect() {
+    return BeginNestedMessage<T>(7);
+  }
+
+
+  using FieldMetadata_Width =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      DisplayState>;
+
+  static constexpr FieldMetadata_Width kWidth{};
+  void set_width(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Width::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Height =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      DisplayState>;
+
+  static constexpr FieldMetadata_Height kHeight{};
+  void set_height(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Height::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class LayerState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/49> {
+ public:
+  LayerState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit LayerState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit LayerState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_layer_id() const { return at<1>().valid(); }
+  uint32_t layer_id() const { return at<1>().as_uint32(); }
+  bool has_what() const { return at<2>().valid(); }
+  uint64_t what() const { return at<2>().as_uint64(); }
+  bool has_x() const { return at<3>().valid(); }
+  float x() const { return at<3>().as_float(); }
+  bool has_y() const { return at<4>().valid(); }
+  float y() const { return at<4>().as_float(); }
+  bool has_z() const { return at<5>().valid(); }
+  int32_t z() const { return at<5>().as_int32(); }
+  bool has_w() const { return at<6>().valid(); }
+  uint32_t w() const { return at<6>().as_uint32(); }
+  bool has_h() const { return at<7>().valid(); }
+  uint32_t h() const { return at<7>().as_uint32(); }
+  bool has_layer_stack() const { return at<8>().valid(); }
+  uint32_t layer_stack() const { return at<8>().as_uint32(); }
+  bool has_flags() const { return at<9>().valid(); }
+  uint32_t flags() const { return at<9>().as_uint32(); }
+  bool has_mask() const { return at<10>().valid(); }
+  uint32_t mask() const { return at<10>().as_uint32(); }
+  bool has_matrix() const { return at<11>().valid(); }
+  ::protozero::ConstBytes matrix() const { return at<11>().as_bytes(); }
+  bool has_corner_radius() const { return at<12>().valid(); }
+  float corner_radius() const { return at<12>().as_float(); }
+  bool has_background_blur_radius() const { return at<13>().valid(); }
+  uint32_t background_blur_radius() const { return at<13>().as_uint32(); }
+  bool has_parent_id() const { return at<14>().valid(); }
+  uint32_t parent_id() const { return at<14>().as_uint32(); }
+  bool has_relative_parent_id() const { return at<15>().valid(); }
+  uint32_t relative_parent_id() const { return at<15>().as_uint32(); }
+  bool has_alpha() const { return at<16>().valid(); }
+  float alpha() const { return at<16>().as_float(); }
+  bool has_color() const { return at<17>().valid(); }
+  ::protozero::ConstBytes color() const { return at<17>().as_bytes(); }
+  bool has_transparent_region() const { return at<18>().valid(); }
+  ::protozero::ConstBytes transparent_region() const { return at<18>().as_bytes(); }
+  bool has_transform() const { return at<19>().valid(); }
+  uint32_t transform() const { return at<19>().as_uint32(); }
+  bool has_transform_to_display_inverse() const { return at<20>().valid(); }
+  bool transform_to_display_inverse() const { return at<20>().as_bool(); }
+  bool has_crop() const { return at<21>().valid(); }
+  ::protozero::ConstBytes crop() const { return at<21>().as_bytes(); }
+  bool has_buffer_data() const { return at<22>().valid(); }
+  ::protozero::ConstBytes buffer_data() const { return at<22>().as_bytes(); }
+  bool has_api() const { return at<23>().valid(); }
+  int32_t api() const { return at<23>().as_int32(); }
+  bool has_has_sideband_stream() const { return at<24>().valid(); }
+  bool has_sideband_stream() const { return at<24>().as_bool(); }
+  bool has_color_transform() const { return at<25>().valid(); }
+  ::protozero::ConstBytes color_transform() const { return at<25>().as_bytes(); }
+  bool has_blur_regions() const { return at<26>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> blur_regions() const { return GetRepeated<::protozero::ConstBytes>(26); }
+  bool has_window_info_handle() const { return at<27>().valid(); }
+  ::protozero::ConstBytes window_info_handle() const { return at<27>().as_bytes(); }
+  bool has_bg_color_alpha() const { return at<28>().valid(); }
+  float bg_color_alpha() const { return at<28>().as_float(); }
+  bool has_bg_color_dataspace() const { return at<29>().valid(); }
+  int32_t bg_color_dataspace() const { return at<29>().as_int32(); }
+  bool has_color_space_agnostic() const { return at<30>().valid(); }
+  bool color_space_agnostic() const { return at<30>().as_bool(); }
+  bool has_shadow_radius() const { return at<31>().valid(); }
+  float shadow_radius() const { return at<31>().as_float(); }
+  bool has_frame_rate_selection_priority() const { return at<32>().valid(); }
+  int32_t frame_rate_selection_priority() const { return at<32>().as_int32(); }
+  bool has_frame_rate() const { return at<33>().valid(); }
+  float frame_rate() const { return at<33>().as_float(); }
+  bool has_frame_rate_compatibility() const { return at<34>().valid(); }
+  int32_t frame_rate_compatibility() const { return at<34>().as_int32(); }
+  bool has_change_frame_rate_strategy() const { return at<35>().valid(); }
+  int32_t change_frame_rate_strategy() const { return at<35>().as_int32(); }
+  bool has_fixed_transform_hint() const { return at<36>().valid(); }
+  uint32_t fixed_transform_hint() const { return at<36>().as_uint32(); }
+  bool has_frame_number() const { return at<37>().valid(); }
+  uint64_t frame_number() const { return at<37>().as_uint64(); }
+  bool has_auto_refresh() const { return at<38>().valid(); }
+  bool auto_refresh() const { return at<38>().as_bool(); }
+  bool has_is_trusted_overlay() const { return at<39>().valid(); }
+  bool is_trusted_overlay() const { return at<39>().as_bool(); }
+  bool has_buffer_crop() const { return at<40>().valid(); }
+  ::protozero::ConstBytes buffer_crop() const { return at<40>().as_bytes(); }
+  bool has_destination_frame() const { return at<41>().valid(); }
+  ::protozero::ConstBytes destination_frame() const { return at<41>().as_bytes(); }
+  bool has_drop_input_mode() const { return at<42>().valid(); }
+  int32_t drop_input_mode() const { return at<42>().as_int32(); }
+  bool has_trusted_overlay() const { return at<43>().valid(); }
+  int32_t trusted_overlay() const { return at<43>().as_int32(); }
+  bool has_background_blur_scale() const { return at<44>().valid(); }
+  float background_blur_scale() const { return at<44>().as_float(); }
+  bool has_corner_radii() const { return at<45>().valid(); }
+  ::protozero::ConstBytes corner_radii() const { return at<45>().as_bytes(); }
+  bool has_client_drawn_corner_radii() const { return at<46>().valid(); }
+  ::protozero::ConstBytes client_drawn_corner_radii() const { return at<46>().as_bytes(); }
+  bool has_system_content_priority() const { return at<47>().valid(); }
+  int32_t system_content_priority() const { return at<47>().as_int32(); }
+  bool has_box_shadow_settings() const { return at<48>().valid(); }
+  ::protozero::ConstBytes box_shadow_settings() const { return at<48>().as_bytes(); }
+  bool has_border_settings() const { return at<49>().valid(); }
+  ::protozero::ConstBytes border_settings() const { return at<49>().as_bytes(); }
+};
+
+class LayerState : public ::protozero::Message {
+ public:
+  using Decoder = LayerState_Decoder;
+  enum : int32_t {
+    kLayerIdFieldNumber = 1,
+    kWhatFieldNumber = 2,
+    kXFieldNumber = 3,
+    kYFieldNumber = 4,
+    kZFieldNumber = 5,
+    kWFieldNumber = 6,
+    kHFieldNumber = 7,
+    kLayerStackFieldNumber = 8,
+    kFlagsFieldNumber = 9,
+    kMaskFieldNumber = 10,
+    kMatrixFieldNumber = 11,
+    kCornerRadiusFieldNumber = 12,
+    kBackgroundBlurRadiusFieldNumber = 13,
+    kParentIdFieldNumber = 14,
+    kRelativeParentIdFieldNumber = 15,
+    kAlphaFieldNumber = 16,
+    kColorFieldNumber = 17,
+    kTransparentRegionFieldNumber = 18,
+    kTransformFieldNumber = 19,
+    kTransformToDisplayInverseFieldNumber = 20,
+    kCropFieldNumber = 21,
+    kBufferDataFieldNumber = 22,
+    kApiFieldNumber = 23,
+    kHasSidebandStreamFieldNumber = 24,
+    kColorTransformFieldNumber = 25,
+    kBlurRegionsFieldNumber = 26,
+    kWindowInfoHandleFieldNumber = 27,
+    kBgColorAlphaFieldNumber = 28,
+    kBgColorDataspaceFieldNumber = 29,
+    kColorSpaceAgnosticFieldNumber = 30,
+    kShadowRadiusFieldNumber = 31,
+    kFrameRateSelectionPriorityFieldNumber = 32,
+    kFrameRateFieldNumber = 33,
+    kFrameRateCompatibilityFieldNumber = 34,
+    kChangeFrameRateStrategyFieldNumber = 35,
+    kFixedTransformHintFieldNumber = 36,
+    kFrameNumberFieldNumber = 37,
+    kAutoRefreshFieldNumber = 38,
+    kIsTrustedOverlayFieldNumber = 39,
+    kBufferCropFieldNumber = 40,
+    kDestinationFrameFieldNumber = 41,
+    kDropInputModeFieldNumber = 42,
+    kTrustedOverlayFieldNumber = 43,
+    kBackgroundBlurScaleFieldNumber = 44,
+    kCornerRadiiFieldNumber = 45,
+    kClientDrawnCornerRadiiFieldNumber = 46,
+    kSystemContentPriorityFieldNumber = 47,
+    kBoxShadowSettingsFieldNumber = 48,
+    kBorderSettingsFieldNumber = 49,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.LayerState"; }
+
+  using Matrix22 = ::perfetto::protos::pbzero::LayerState_Matrix22;
+  using CornerRadii = ::perfetto::protos::pbzero::LayerState_CornerRadii;
+  using Color3 = ::perfetto::protos::pbzero::LayerState_Color3;
+  using BufferData = ::perfetto::protos::pbzero::LayerState_BufferData;
+  using WindowInfo = ::perfetto::protos::pbzero::LayerState_WindowInfo;
+
+  using ChangesLsb = ::perfetto::protos::pbzero::LayerState_ChangesLsb;
+  static inline const char* ChangesLsb_Name(ChangesLsb value) {
+    return ::perfetto::protos::pbzero::LayerState_ChangesLsb_Name(value);
+  }
+
+  using ChangesMsb = ::perfetto::protos::pbzero::LayerState_ChangesMsb;
+  static inline const char* ChangesMsb_Name(ChangesMsb value) {
+    return ::perfetto::protos::pbzero::LayerState_ChangesMsb_Name(value);
+  }
+
+  using Flags = ::perfetto::protos::pbzero::LayerState_Flags;
+  static inline const char* Flags_Name(Flags value) {
+    return ::perfetto::protos::pbzero::LayerState_Flags_Name(value);
+  }
+
+  using DropInputMode = ::perfetto::protos::pbzero::LayerState_DropInputMode;
+  static inline const char* DropInputMode_Name(DropInputMode value) {
+    return ::perfetto::protos::pbzero::LayerState_DropInputMode_Name(value);
+  }
+  static inline const ChangesLsb eChangesLsbNone = ChangesLsb::eChangesLsbNone;
+  static inline const ChangesLsb ePositionChanged = ChangesLsb::ePositionChanged;
+  static inline const ChangesLsb eLayerChanged = ChangesLsb::eLayerChanged;
+  static inline const ChangesLsb eAlphaChanged = ChangesLsb::eAlphaChanged;
+  static inline const ChangesLsb eMatrixChanged = ChangesLsb::eMatrixChanged;
+  static inline const ChangesLsb eTransparentRegionChanged = ChangesLsb::eTransparentRegionChanged;
+  static inline const ChangesLsb eFlagsChanged = ChangesLsb::eFlagsChanged;
+  static inline const ChangesLsb eLayerStackChanged = ChangesLsb::eLayerStackChanged;
+  static inline const ChangesLsb eReleaseBufferListenerChanged = ChangesLsb::eReleaseBufferListenerChanged;
+  static inline const ChangesLsb eShadowRadiusChanged = ChangesLsb::eShadowRadiusChanged;
+  static inline const ChangesLsb eBufferCropChanged = ChangesLsb::eBufferCropChanged;
+  static inline const ChangesLsb eRelativeLayerChanged = ChangesLsb::eRelativeLayerChanged;
+  static inline const ChangesLsb eReparent = ChangesLsb::eReparent;
+  static inline const ChangesLsb eColorChanged = ChangesLsb::eColorChanged;
+  static inline const ChangesLsb eBufferTransformChanged = ChangesLsb::eBufferTransformChanged;
+  static inline const ChangesLsb eTransformToDisplayInverseChanged = ChangesLsb::eTransformToDisplayInverseChanged;
+  static inline const ChangesLsb eCropChanged = ChangesLsb::eCropChanged;
+  static inline const ChangesLsb eBufferChanged = ChangesLsb::eBufferChanged;
+  static inline const ChangesLsb eAcquireFenceChanged = ChangesLsb::eAcquireFenceChanged;
+  static inline const ChangesLsb eDataspaceChanged = ChangesLsb::eDataspaceChanged;
+  static inline const ChangesLsb eHdrMetadataChanged = ChangesLsb::eHdrMetadataChanged;
+  static inline const ChangesLsb eSurfaceDamageRegionChanged = ChangesLsb::eSurfaceDamageRegionChanged;
+  static inline const ChangesLsb eApiChanged = ChangesLsb::eApiChanged;
+  static inline const ChangesLsb eSidebandStreamChanged = ChangesLsb::eSidebandStreamChanged;
+  static inline const ChangesLsb eColorTransformChanged = ChangesLsb::eColorTransformChanged;
+  static inline const ChangesLsb eHasListenerCallbacksChanged = ChangesLsb::eHasListenerCallbacksChanged;
+  static inline const ChangesLsb eInputInfoChanged = ChangesLsb::eInputInfoChanged;
+  static inline const ChangesLsb eCornerRadiusChanged = ChangesLsb::eCornerRadiusChanged;
+  static inline const ChangesMsb eChangesMsbNone = ChangesMsb::eChangesMsbNone;
+  static inline const ChangesMsb eDestinationFrameChanged = ChangesMsb::eDestinationFrameChanged;
+  static inline const ChangesMsb eCachedBufferChanged = ChangesMsb::eCachedBufferChanged;
+  static inline const ChangesMsb eBackgroundColorChanged = ChangesMsb::eBackgroundColorChanged;
+  static inline const ChangesMsb eMetadataChanged = ChangesMsb::eMetadataChanged;
+  static inline const ChangesMsb eColorSpaceAgnosticChanged = ChangesMsb::eColorSpaceAgnosticChanged;
+  static inline const ChangesMsb eFrameRateSelectionPriority = ChangesMsb::eFrameRateSelectionPriority;
+  static inline const ChangesMsb eFrameRateChanged = ChangesMsb::eFrameRateChanged;
+  static inline const ChangesMsb eBackgroundBlurRadiusChanged = ChangesMsb::eBackgroundBlurRadiusChanged;
+  static inline const ChangesMsb eProducerDisconnect = ChangesMsb::eProducerDisconnect;
+  static inline const ChangesMsb eFixedTransformHintChanged = ChangesMsb::eFixedTransformHintChanged;
+  static inline const ChangesMsb eFrameNumberChanged = ChangesMsb::eFrameNumberChanged;
+  static inline const ChangesMsb eBlurRegionsChanged = ChangesMsb::eBlurRegionsChanged;
+  static inline const ChangesMsb eAutoRefreshChanged = ChangesMsb::eAutoRefreshChanged;
+  static inline const ChangesMsb eStretchChanged = ChangesMsb::eStretchChanged;
+  static inline const ChangesMsb eTrustedOverlayChanged = ChangesMsb::eTrustedOverlayChanged;
+  static inline const ChangesMsb eDropInputModeChanged = ChangesMsb::eDropInputModeChanged;
+  static inline const ChangesMsb eClientDrawnCornerRadiusChanged = ChangesMsb::eClientDrawnCornerRadiusChanged;
+  static inline const ChangesMsb eSystemContentPriorityChanged = ChangesMsb::eSystemContentPriorityChanged;
+  static inline const ChangesMsb eBoxShadowSettingsChanged = ChangesMsb::eBoxShadowSettingsChanged;
+  static inline const ChangesMsb eBorderSettingsChanged = ChangesMsb::eBorderSettingsChanged;
+  static inline const Flags eFlagsNone = Flags::eFlagsNone;
+  static inline const Flags eLayerHidden = Flags::eLayerHidden;
+  static inline const Flags eLayerOpaque = Flags::eLayerOpaque;
+  static inline const Flags eLayerSkipScreenshot = Flags::eLayerSkipScreenshot;
+  static inline const Flags eLayerSecure = Flags::eLayerSecure;
+  static inline const Flags eEnableBackpressure = Flags::eEnableBackpressure;
+  static inline const Flags eLayerIsDisplayDecoration = Flags::eLayerIsDisplayDecoration;
+  static inline const DropInputMode NONE = DropInputMode::NONE;
+  static inline const DropInputMode ALL = DropInputMode::ALL;
+  static inline const DropInputMode OBSCURED = DropInputMode::OBSCURED;
+
+  using FieldMetadata_LayerId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerState>;
+
+  static constexpr FieldMetadata_LayerId kLayerId{};
+  void set_layer_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LayerId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_What =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      LayerState>;
+
+  static constexpr FieldMetadata_What kWhat{};
+  void set_what(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_What::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_X =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerState>;
+
+  static constexpr FieldMetadata_X kX{};
+  void set_x(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_X::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Y =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerState>;
+
+  static constexpr FieldMetadata_Y kY{};
+  void set_y(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Y::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Z =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LayerState>;
+
+  static constexpr FieldMetadata_Z kZ{};
+  void set_z(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Z::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_W =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerState>;
+
+  static constexpr FieldMetadata_W kW{};
+  void set_w(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_W::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_H =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerState>;
+
+  static constexpr FieldMetadata_H kH{};
+  void set_h(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_H::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_LayerStack =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerState>;
+
+  static constexpr FieldMetadata_LayerStack kLayerStack{};
+  void set_layer_stack(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LayerStack::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Flags =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerState>;
+
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Mask =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerState>;
+
+  static constexpr FieldMetadata_Mask kMask{};
+  void set_mask(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mask::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Matrix =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      LayerState_Matrix22,
+      LayerState>;
+
+  static constexpr FieldMetadata_Matrix kMatrix{};
+  template <typename T = LayerState_Matrix22> T* set_matrix() {
+    return BeginNestedMessage<T>(11);
+  }
+
+
+  using FieldMetadata_CornerRadius =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerState>;
+
+  static constexpr FieldMetadata_CornerRadius kCornerRadius{};
+  void set_corner_radius(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_CornerRadius::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BackgroundBlurRadius =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerState>;
+
+  static constexpr FieldMetadata_BackgroundBlurRadius kBackgroundBlurRadius{};
+  void set_background_blur_radius(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BackgroundBlurRadius::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ParentId =
+    ::protozero::proto_utils::FieldMetadata<
+      14,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerState>;
+
+  static constexpr FieldMetadata_ParentId kParentId{};
+  void set_parent_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ParentId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_RelativeParentId =
+    ::protozero::proto_utils::FieldMetadata<
+      15,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerState>;
+
+  static constexpr FieldMetadata_RelativeParentId kRelativeParentId{};
+  void set_relative_parent_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RelativeParentId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Alpha =
+    ::protozero::proto_utils::FieldMetadata<
+      16,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerState>;
+
+  static constexpr FieldMetadata_Alpha kAlpha{};
+  void set_alpha(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Alpha::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Color =
+    ::protozero::proto_utils::FieldMetadata<
+      17,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      LayerState_Color3,
+      LayerState>;
+
+  static constexpr FieldMetadata_Color kColor{};
+  template <typename T = LayerState_Color3> T* set_color() {
+    return BeginNestedMessage<T>(17);
+  }
+
+
+  using FieldMetadata_TransparentRegion =
+    ::protozero::proto_utils::FieldMetadata<
+      18,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      RegionProto,
+      LayerState>;
+
+  static constexpr FieldMetadata_TransparentRegion kTransparentRegion{};
+  template <typename T = RegionProto> T* set_transparent_region() {
+    return BeginNestedMessage<T>(18);
+  }
+
+
+  using FieldMetadata_Transform =
+    ::protozero::proto_utils::FieldMetadata<
+      19,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerState>;
+
+  static constexpr FieldMetadata_Transform kTransform{};
+  void set_transform(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Transform::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TransformToDisplayInverse =
+    ::protozero::proto_utils::FieldMetadata<
+      20,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      LayerState>;
+
+  static constexpr FieldMetadata_TransformToDisplayInverse kTransformToDisplayInverse{};
+  void set_transform_to_display_inverse(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_TransformToDisplayInverse::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Crop =
+    ::protozero::proto_utils::FieldMetadata<
+      21,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      RectProto,
+      LayerState>;
+
+  static constexpr FieldMetadata_Crop kCrop{};
+  template <typename T = RectProto> T* set_crop() {
+    return BeginNestedMessage<T>(21);
+  }
+
+
+  using FieldMetadata_BufferData =
+    ::protozero::proto_utils::FieldMetadata<
+      22,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      LayerState_BufferData,
+      LayerState>;
+
+  static constexpr FieldMetadata_BufferData kBufferData{};
+  template <typename T = LayerState_BufferData> T* set_buffer_data() {
+    return BeginNestedMessage<T>(22);
+  }
+
+
+  using FieldMetadata_Api =
+    ::protozero::proto_utils::FieldMetadata<
+      23,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LayerState>;
+
+  static constexpr FieldMetadata_Api kApi{};
+  void set_api(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Api::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_HasSidebandStream =
+    ::protozero::proto_utils::FieldMetadata<
+      24,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      LayerState>;
+
+  static constexpr FieldMetadata_HasSidebandStream kHasSidebandStream{};
+  void set_has_sideband_stream(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_HasSidebandStream::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ColorTransform =
+    ::protozero::proto_utils::FieldMetadata<
+      25,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ColorTransformProto,
+      LayerState>;
+
+  static constexpr FieldMetadata_ColorTransform kColorTransform{};
+  template <typename T = ColorTransformProto> T* set_color_transform() {
+    return BeginNestedMessage<T>(25);
+  }
+
+
+  using FieldMetadata_BlurRegions =
+    ::protozero::proto_utils::FieldMetadata<
+      26,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BlurRegion,
+      LayerState>;
+
+  static constexpr FieldMetadata_BlurRegions kBlurRegions{};
+  template <typename T = BlurRegion> T* add_blur_regions() {
+    return BeginNestedMessage<T>(26);
+  }
+
+
+  using FieldMetadata_WindowInfoHandle =
+    ::protozero::proto_utils::FieldMetadata<
+      27,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      LayerState_WindowInfo,
+      LayerState>;
+
+  static constexpr FieldMetadata_WindowInfoHandle kWindowInfoHandle{};
+  template <typename T = LayerState_WindowInfo> T* set_window_info_handle() {
+    return BeginNestedMessage<T>(27);
+  }
+
+
+  using FieldMetadata_BgColorAlpha =
+    ::protozero::proto_utils::FieldMetadata<
+      28,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerState>;
+
+  static constexpr FieldMetadata_BgColorAlpha kBgColorAlpha{};
+  void set_bg_color_alpha(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_BgColorAlpha::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BgColorDataspace =
+    ::protozero::proto_utils::FieldMetadata<
+      29,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LayerState>;
+
+  static constexpr FieldMetadata_BgColorDataspace kBgColorDataspace{};
+  void set_bg_color_dataspace(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BgColorDataspace::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ColorSpaceAgnostic =
+    ::protozero::proto_utils::FieldMetadata<
+      30,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      LayerState>;
+
+  static constexpr FieldMetadata_ColorSpaceAgnostic kColorSpaceAgnostic{};
+  void set_color_space_agnostic(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ColorSpaceAgnostic::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ShadowRadius =
+    ::protozero::proto_utils::FieldMetadata<
+      31,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerState>;
+
+  static constexpr FieldMetadata_ShadowRadius kShadowRadius{};
+  void set_shadow_radius(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_ShadowRadius::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FrameRateSelectionPriority =
+    ::protozero::proto_utils::FieldMetadata<
+      32,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LayerState>;
+
+  static constexpr FieldMetadata_FrameRateSelectionPriority kFrameRateSelectionPriority{};
+  void set_frame_rate_selection_priority(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FrameRateSelectionPriority::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FrameRate =
+    ::protozero::proto_utils::FieldMetadata<
+      33,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerState>;
+
+  static constexpr FieldMetadata_FrameRate kFrameRate{};
+  void set_frame_rate(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_FrameRate::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FrameRateCompatibility =
+    ::protozero::proto_utils::FieldMetadata<
+      34,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LayerState>;
+
+  static constexpr FieldMetadata_FrameRateCompatibility kFrameRateCompatibility{};
+  void set_frame_rate_compatibility(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FrameRateCompatibility::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ChangeFrameRateStrategy =
+    ::protozero::proto_utils::FieldMetadata<
+      35,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LayerState>;
+
+  static constexpr FieldMetadata_ChangeFrameRateStrategy kChangeFrameRateStrategy{};
+  void set_change_frame_rate_strategy(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ChangeFrameRateStrategy::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FixedTransformHint =
+    ::protozero::proto_utils::FieldMetadata<
+      36,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerState>;
+
+  static constexpr FieldMetadata_FixedTransformHint kFixedTransformHint{};
+  void set_fixed_transform_hint(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FixedTransformHint::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FrameNumber =
+    ::protozero::proto_utils::FieldMetadata<
+      37,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      LayerState>;
+
+  static constexpr FieldMetadata_FrameNumber kFrameNumber{};
+  void set_frame_number(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FrameNumber::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_AutoRefresh =
+    ::protozero::proto_utils::FieldMetadata<
+      38,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      LayerState>;
+
+  static constexpr FieldMetadata_AutoRefresh kAutoRefresh{};
+  void set_auto_refresh(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_AutoRefresh::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IsTrustedOverlay =
+    ::protozero::proto_utils::FieldMetadata<
+      39,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      LayerState>;
+
+  static constexpr FieldMetadata_IsTrustedOverlay kIsTrustedOverlay{};
+  void set_is_trusted_overlay(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsTrustedOverlay::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BufferCrop =
+    ::protozero::proto_utils::FieldMetadata<
+      40,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      RectProto,
+      LayerState>;
+
+  static constexpr FieldMetadata_BufferCrop kBufferCrop{};
+  template <typename T = RectProto> T* set_buffer_crop() {
+    return BeginNestedMessage<T>(40);
+  }
+
+
+  using FieldMetadata_DestinationFrame =
+    ::protozero::proto_utils::FieldMetadata<
+      41,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      RectProto,
+      LayerState>;
+
+  static constexpr FieldMetadata_DestinationFrame kDestinationFrame{};
+  template <typename T = RectProto> T* set_destination_frame() {
+    return BeginNestedMessage<T>(41);
+  }
+
+
+  using FieldMetadata_DropInputMode =
+    ::protozero::proto_utils::FieldMetadata<
+      42,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      LayerState_DropInputMode,
+      LayerState>;
+
+  static constexpr FieldMetadata_DropInputMode kDropInputMode{};
+  void set_drop_input_mode(LayerState_DropInputMode value) {
+    static constexpr uint32_t field_id = FieldMetadata_DropInputMode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TrustedOverlay =
+    ::protozero::proto_utils::FieldMetadata<
+      43,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      TrustedOverlay,
+      LayerState>;
+
+  static constexpr FieldMetadata_TrustedOverlay kTrustedOverlay{};
+  void set_trusted_overlay(TrustedOverlay value) {
+    static constexpr uint32_t field_id = FieldMetadata_TrustedOverlay::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BackgroundBlurScale =
+    ::protozero::proto_utils::FieldMetadata<
+      44,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerState>;
+
+  static constexpr FieldMetadata_BackgroundBlurScale kBackgroundBlurScale{};
+  void set_background_blur_scale(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_BackgroundBlurScale::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CornerRadii =
+    ::protozero::proto_utils::FieldMetadata<
+      45,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      LayerState_CornerRadii,
+      LayerState>;
+
+  static constexpr FieldMetadata_CornerRadii kCornerRadii{};
+  template <typename T = LayerState_CornerRadii> T* set_corner_radii() {
+    return BeginNestedMessage<T>(45);
+  }
+
+
+  using FieldMetadata_ClientDrawnCornerRadii =
+    ::protozero::proto_utils::FieldMetadata<
+      46,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      LayerState_CornerRadii,
+      LayerState>;
+
+  static constexpr FieldMetadata_ClientDrawnCornerRadii kClientDrawnCornerRadii{};
+  template <typename T = LayerState_CornerRadii> T* set_client_drawn_corner_radii() {
+    return BeginNestedMessage<T>(46);
+  }
+
+
+  using FieldMetadata_SystemContentPriority =
+    ::protozero::proto_utils::FieldMetadata<
+      47,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LayerState>;
+
+  static constexpr FieldMetadata_SystemContentPriority kSystemContentPriority{};
+  void set_system_content_priority(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SystemContentPriority::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BoxShadowSettings =
+    ::protozero::proto_utils::FieldMetadata<
+      48,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BoxShadowSettings,
+      LayerState>;
+
+  static constexpr FieldMetadata_BoxShadowSettings kBoxShadowSettings{};
+  template <typename T = BoxShadowSettings> T* set_box_shadow_settings() {
+    return BeginNestedMessage<T>(48);
+  }
+
+
+  using FieldMetadata_BorderSettings =
+    ::protozero::proto_utils::FieldMetadata<
+      49,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BorderSettings,
+      LayerState>;
+
+  static constexpr FieldMetadata_BorderSettings kBorderSettings{};
+  template <typename T = BorderSettings> T* set_border_settings() {
+    return BeginNestedMessage<T>(49);
+  }
+
+};
+
+class LayerState_WindowInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/12> {
+ public:
+  LayerState_WindowInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit LayerState_WindowInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit LayerState_WindowInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_layout_params_flags() const { return at<1>().valid(); }
+  uint32_t layout_params_flags() const { return at<1>().as_uint32(); }
+  bool has_layout_params_type() const { return at<2>().valid(); }
+  int32_t layout_params_type() const { return at<2>().as_int32(); }
+  bool has_touchable_region() const { return at<3>().valid(); }
+  ::protozero::ConstBytes touchable_region() const { return at<3>().as_bytes(); }
+  bool has_surface_inset() const { return at<4>().valid(); }
+  int32_t surface_inset() const { return at<4>().as_int32(); }
+  bool has_focusable() const { return at<5>().valid(); }
+  bool focusable() const { return at<5>().as_bool(); }
+  bool has_has_wallpaper() const { return at<6>().valid(); }
+  bool has_wallpaper() const { return at<6>().as_bool(); }
+  bool has_global_scale_factor() const { return at<7>().valid(); }
+  float global_scale_factor() const { return at<7>().as_float(); }
+  bool has_crop_layer_id() const { return at<8>().valid(); }
+  uint32_t crop_layer_id() const { return at<8>().as_uint32(); }
+  bool has_replace_touchable_region_with_crop() const { return at<9>().valid(); }
+  bool replace_touchable_region_with_crop() const { return at<9>().as_bool(); }
+  bool has_touchable_region_crop() const { return at<10>().valid(); }
+  ::protozero::ConstBytes touchable_region_crop() const { return at<10>().as_bytes(); }
+  bool has_transform() const { return at<11>().valid(); }
+  ::protozero::ConstBytes transform() const { return at<11>().as_bytes(); }
+  bool has_input_config() const { return at<12>().valid(); }
+  uint32_t input_config() const { return at<12>().as_uint32(); }
+};
+
+class LayerState_WindowInfo : public ::protozero::Message {
+ public:
+  using Decoder = LayerState_WindowInfo_Decoder;
+  enum : int32_t {
+    kLayoutParamsFlagsFieldNumber = 1,
+    kLayoutParamsTypeFieldNumber = 2,
+    kTouchableRegionFieldNumber = 3,
+    kSurfaceInsetFieldNumber = 4,
+    kFocusableFieldNumber = 5,
+    kHasWallpaperFieldNumber = 6,
+    kGlobalScaleFactorFieldNumber = 7,
+    kCropLayerIdFieldNumber = 8,
+    kReplaceTouchableRegionWithCropFieldNumber = 9,
+    kTouchableRegionCropFieldNumber = 10,
+    kTransformFieldNumber = 11,
+    kInputConfigFieldNumber = 12,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.LayerState.WindowInfo"; }
+
+
+  using FieldMetadata_LayoutParamsFlags =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerState_WindowInfo>;
+
+  static constexpr FieldMetadata_LayoutParamsFlags kLayoutParamsFlags{};
+  void set_layout_params_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LayoutParamsFlags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_LayoutParamsType =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LayerState_WindowInfo>;
+
+  static constexpr FieldMetadata_LayoutParamsType kLayoutParamsType{};
+  void set_layout_params_type(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LayoutParamsType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TouchableRegion =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      RegionProto,
+      LayerState_WindowInfo>;
+
+  static constexpr FieldMetadata_TouchableRegion kTouchableRegion{};
+  template <typename T = RegionProto> T* set_touchable_region() {
+    return BeginNestedMessage<T>(3);
+  }
+
+
+  using FieldMetadata_SurfaceInset =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LayerState_WindowInfo>;
+
+  static constexpr FieldMetadata_SurfaceInset kSurfaceInset{};
+  void set_surface_inset(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SurfaceInset::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Focusable =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      LayerState_WindowInfo>;
+
+  static constexpr FieldMetadata_Focusable kFocusable{};
+  void set_focusable(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_Focusable::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_HasWallpaper =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      LayerState_WindowInfo>;
+
+  static constexpr FieldMetadata_HasWallpaper kHasWallpaper{};
+  void set_has_wallpaper(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_HasWallpaper::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_GlobalScaleFactor =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerState_WindowInfo>;
+
+  static constexpr FieldMetadata_GlobalScaleFactor kGlobalScaleFactor{};
+  void set_global_scale_factor(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_GlobalScaleFactor::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CropLayerId =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerState_WindowInfo>;
+
+  static constexpr FieldMetadata_CropLayerId kCropLayerId{};
+  void set_crop_layer_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CropLayerId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ReplaceTouchableRegionWithCrop =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      LayerState_WindowInfo>;
+
+  static constexpr FieldMetadata_ReplaceTouchableRegionWithCrop kReplaceTouchableRegionWithCrop{};
+  void set_replace_touchable_region_with_crop(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReplaceTouchableRegionWithCrop::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TouchableRegionCrop =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      RectProto,
+      LayerState_WindowInfo>;
+
+  static constexpr FieldMetadata_TouchableRegionCrop kTouchableRegionCrop{};
+  template <typename T = RectProto> T* set_touchable_region_crop() {
+    return BeginNestedMessage<T>(10);
+  }
+
+
+  using FieldMetadata_Transform =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      Transform,
+      LayerState_WindowInfo>;
+
+  static constexpr FieldMetadata_Transform kTransform{};
+  template <typename T = Transform> T* set_transform() {
+    return BeginNestedMessage<T>(11);
+  }
+
+
+  using FieldMetadata_InputConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerState_WindowInfo>;
+
+  static constexpr FieldMetadata_InputConfig kInputConfig{};
+  void set_input_config(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InputConfig::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class LayerState_BufferData_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
+ public:
+  LayerState_BufferData_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit LayerState_BufferData_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit LayerState_BufferData_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_buffer_id() const { return at<1>().valid(); }
+  uint64_t buffer_id() const { return at<1>().as_uint64(); }
+  bool has_width() const { return at<2>().valid(); }
+  uint32_t width() const { return at<2>().as_uint32(); }
+  bool has_height() const { return at<3>().valid(); }
+  uint32_t height() const { return at<3>().as_uint32(); }
+  bool has_frame_number() const { return at<4>().valid(); }
+  uint64_t frame_number() const { return at<4>().as_uint64(); }
+  bool has_flags() const { return at<5>().valid(); }
+  uint32_t flags() const { return at<5>().as_uint32(); }
+  bool has_cached_buffer_id() const { return at<6>().valid(); }
+  uint64_t cached_buffer_id() const { return at<6>().as_uint64(); }
+  bool has_pixel_format() const { return at<7>().valid(); }
+  int32_t pixel_format() const { return at<7>().as_int32(); }
+  bool has_usage() const { return at<8>().valid(); }
+  uint64_t usage() const { return at<8>().as_uint64(); }
+};
+
+class LayerState_BufferData : public ::protozero::Message {
+ public:
+  using Decoder = LayerState_BufferData_Decoder;
+  enum : int32_t {
+    kBufferIdFieldNumber = 1,
+    kWidthFieldNumber = 2,
+    kHeightFieldNumber = 3,
+    kFrameNumberFieldNumber = 4,
+    kFlagsFieldNumber = 5,
+    kCachedBufferIdFieldNumber = 6,
+    kPixelFormatFieldNumber = 7,
+    kUsageFieldNumber = 8,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.LayerState.BufferData"; }
+
+
+  using BufferDataChange = ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange;
+  static inline const char* BufferDataChange_Name(BufferDataChange value) {
+    return ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange_Name(value);
+  }
+
+  using PixelFormat = ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat;
+  static inline const char* PixelFormat_Name(PixelFormat value) {
+    return ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat_Name(value);
+  }
+  static inline const BufferDataChange BufferDataChangeNone = BufferDataChange::BufferDataChangeNone;
+  static inline const BufferDataChange fenceChanged = BufferDataChange::fenceChanged;
+  static inline const BufferDataChange frameNumberChanged = BufferDataChange::frameNumberChanged;
+  static inline const BufferDataChange cachedBufferChanged = BufferDataChange::cachedBufferChanged;
+  static inline const PixelFormat PIXEL_FORMAT_UNKNOWN = PixelFormat::PIXEL_FORMAT_UNKNOWN;
+  static inline const PixelFormat PIXEL_FORMAT_CUSTOM = PixelFormat::PIXEL_FORMAT_CUSTOM;
+  static inline const PixelFormat PIXEL_FORMAT_TRANSLUCENT = PixelFormat::PIXEL_FORMAT_TRANSLUCENT;
+  static inline const PixelFormat PIXEL_FORMAT_TRANSPARENT = PixelFormat::PIXEL_FORMAT_TRANSPARENT;
+  static inline const PixelFormat PIXEL_FORMAT_OPAQUE = PixelFormat::PIXEL_FORMAT_OPAQUE;
+  static inline const PixelFormat PIXEL_FORMAT_RGBA_8888 = PixelFormat::PIXEL_FORMAT_RGBA_8888;
+  static inline const PixelFormat PIXEL_FORMAT_RGBX_8888 = PixelFormat::PIXEL_FORMAT_RGBX_8888;
+  static inline const PixelFormat PIXEL_FORMAT_RGB_888 = PixelFormat::PIXEL_FORMAT_RGB_888;
+  static inline const PixelFormat PIXEL_FORMAT_RGB_565 = PixelFormat::PIXEL_FORMAT_RGB_565;
+  static inline const PixelFormat PIXEL_FORMAT_BGRA_8888 = PixelFormat::PIXEL_FORMAT_BGRA_8888;
+  static inline const PixelFormat PIXEL_FORMAT_RGBA_5551 = PixelFormat::PIXEL_FORMAT_RGBA_5551;
+  static inline const PixelFormat PIXEL_FORMAT_RGBA_4444 = PixelFormat::PIXEL_FORMAT_RGBA_4444;
+  static inline const PixelFormat PIXEL_FORMAT_RGBA_FP16 = PixelFormat::PIXEL_FORMAT_RGBA_FP16;
+  static inline const PixelFormat PIXEL_FORMAT_RGBA_1010102 = PixelFormat::PIXEL_FORMAT_RGBA_1010102;
+  static inline const PixelFormat PIXEL_FORMAT_R_8 = PixelFormat::PIXEL_FORMAT_R_8;
+
+  using FieldMetadata_BufferId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      LayerState_BufferData>;
+
+  static constexpr FieldMetadata_BufferId kBufferId{};
+  void set_buffer_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BufferId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Width =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerState_BufferData>;
+
+  static constexpr FieldMetadata_Width kWidth{};
+  void set_width(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Width::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Height =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerState_BufferData>;
+
+  static constexpr FieldMetadata_Height kHeight{};
+  void set_height(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Height::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FrameNumber =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      LayerState_BufferData>;
+
+  static constexpr FieldMetadata_FrameNumber kFrameNumber{};
+  void set_frame_number(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FrameNumber::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Flags =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerState_BufferData>;
+
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CachedBufferId =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      LayerState_BufferData>;
+
+  static constexpr FieldMetadata_CachedBufferId kCachedBufferId{};
+  void set_cached_buffer_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CachedBufferId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PixelFormat =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      LayerState_BufferData_PixelFormat,
+      LayerState_BufferData>;
+
+  static constexpr FieldMetadata_PixelFormat kPixelFormat{};
+  void set_pixel_format(LayerState_BufferData_PixelFormat value) {
+    static constexpr uint32_t field_id = FieldMetadata_PixelFormat::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Usage =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      LayerState_BufferData>;
+
+  static constexpr FieldMetadata_Usage kUsage{};
+  void set_usage(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Usage::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class LayerState_Color3_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  LayerState_Color3_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit LayerState_Color3_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit LayerState_Color3_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_r() const { return at<1>().valid(); }
+  float r() const { return at<1>().as_float(); }
+  bool has_g() const { return at<2>().valid(); }
+  float g() const { return at<2>().as_float(); }
+  bool has_b() const { return at<3>().valid(); }
+  float b() const { return at<3>().as_float(); }
+};
+
+class LayerState_Color3 : public ::protozero::Message {
+ public:
+  using Decoder = LayerState_Color3_Decoder;
+  enum : int32_t {
+    kRFieldNumber = 1,
+    kGFieldNumber = 2,
+    kBFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.LayerState.Color3"; }
+
+
+  using FieldMetadata_R =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerState_Color3>;
+
+  static constexpr FieldMetadata_R kR{};
+  void set_r(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_R::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_G =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerState_Color3>;
+
+  static constexpr FieldMetadata_G kG{};
+  void set_g(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_G::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_B =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerState_Color3>;
+
+  static constexpr FieldMetadata_B kB{};
+  void set_b(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_B::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class LayerState_CornerRadii_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  LayerState_CornerRadii_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit LayerState_CornerRadii_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit LayerState_CornerRadii_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_tl() const { return at<1>().valid(); }
+  float tl() const { return at<1>().as_float(); }
+  bool has_tr() const { return at<2>().valid(); }
+  float tr() const { return at<2>().as_float(); }
+  bool has_bl() const { return at<3>().valid(); }
+  float bl() const { return at<3>().as_float(); }
+  bool has_br() const { return at<4>().valid(); }
+  float br() const { return at<4>().as_float(); }
+};
+
+class LayerState_CornerRadii : public ::protozero::Message {
+ public:
+  using Decoder = LayerState_CornerRadii_Decoder;
+  enum : int32_t {
+    kTlFieldNumber = 1,
+    kTrFieldNumber = 2,
+    kBlFieldNumber = 3,
+    kBrFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.LayerState.CornerRadii"; }
+
+
+  using FieldMetadata_Tl =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerState_CornerRadii>;
+
+  static constexpr FieldMetadata_Tl kTl{};
+  void set_tl(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tl::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Tr =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerState_CornerRadii>;
+
+  static constexpr FieldMetadata_Tr kTr{};
+  void set_tr(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tr::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Bl =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerState_CornerRadii>;
+
+  static constexpr FieldMetadata_Bl kBl{};
+  void set_bl(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Bl::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Br =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerState_CornerRadii>;
+
+  static constexpr FieldMetadata_Br kBr{};
+  void set_br(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Br::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class LayerState_Matrix22_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  LayerState_Matrix22_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit LayerState_Matrix22_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit LayerState_Matrix22_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dsdx() const { return at<1>().valid(); }
+  float dsdx() const { return at<1>().as_float(); }
+  bool has_dtdx() const { return at<2>().valid(); }
+  float dtdx() const { return at<2>().as_float(); }
+  bool has_dtdy() const { return at<3>().valid(); }
+  float dtdy() const { return at<3>().as_float(); }
+  bool has_dsdy() const { return at<4>().valid(); }
+  float dsdy() const { return at<4>().as_float(); }
+};
+
+class LayerState_Matrix22 : public ::protozero::Message {
+ public:
+  using Decoder = LayerState_Matrix22_Decoder;
+  enum : int32_t {
+    kDsdxFieldNumber = 1,
+    kDtdxFieldNumber = 2,
+    kDtdyFieldNumber = 3,
+    kDsdyFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.LayerState.Matrix22"; }
+
+
+  using FieldMetadata_Dsdx =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerState_Matrix22>;
+
+  static constexpr FieldMetadata_Dsdx kDsdx{};
+  void set_dsdx(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dsdx::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Dtdx =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerState_Matrix22>;
+
+  static constexpr FieldMetadata_Dtdx kDtdx{};
+  void set_dtdx(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dtdx::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Dtdy =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerState_Matrix22>;
+
+  static constexpr FieldMetadata_Dtdy kDtdy{};
+  void set_dtdy(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dtdy::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Dsdy =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      LayerState_Matrix22>;
+
+  static constexpr FieldMetadata_Dsdy kDsdy{};
+  void set_dsdy(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dsdy::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class TransactionState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11> {
+ public:
+  TransactionState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TransactionState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TransactionState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  int32_t pid() const { return at<1>().as_int32(); }
+  bool has_uid() const { return at<2>().valid(); }
+  int32_t uid() const { return at<2>().as_int32(); }
+  bool has_vsync_id() const { return at<3>().valid(); }
+  int64_t vsync_id() const { return at<3>().as_int64(); }
+  bool has_input_event_id() const { return at<4>().valid(); }
+  int32_t input_event_id() const { return at<4>().as_int32(); }
+  bool has_post_time() const { return at<5>().valid(); }
+  int64_t post_time() const { return at<5>().as_int64(); }
+  bool has_transaction_id() const { return at<6>().valid(); }
+  uint64_t transaction_id() const { return at<6>().as_uint64(); }
+  bool has_layer_changes() const { return at<7>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> layer_changes() const { return GetRepeated<::protozero::ConstBytes>(7); }
+  bool has_display_changes() const { return at<8>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> display_changes() const { return GetRepeated<::protozero::ConstBytes>(8); }
+  bool has_merged_transaction_ids() const { return at<9>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint64_t> merged_transaction_ids() const { return GetRepeated<uint64_t>(9); }
+  bool has_apply_token() const { return at<10>().valid(); }
+  uint64_t apply_token() const { return at<10>().as_uint64(); }
+  bool has_transaction_barriers() const { return at<11>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> transaction_barriers() const { return GetRepeated<::protozero::ConstBytes>(11); }
+};
+
+class TransactionState : public ::protozero::Message {
+ public:
+  using Decoder = TransactionState_Decoder;
+  enum : int32_t {
+    kPidFieldNumber = 1,
+    kUidFieldNumber = 2,
+    kVsyncIdFieldNumber = 3,
+    kInputEventIdFieldNumber = 4,
+    kPostTimeFieldNumber = 5,
+    kTransactionIdFieldNumber = 6,
+    kLayerChangesFieldNumber = 7,
+    kDisplayChangesFieldNumber = 8,
+    kMergedTransactionIdsFieldNumber = 9,
+    kApplyTokenFieldNumber = 10,
+    kTransactionBarriersFieldNumber = 11,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TransactionState"; }
+
+
+  using FieldMetadata_Pid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TransactionState>;
+
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Uid =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TransactionState>;
+
+  static constexpr FieldMetadata_Uid kUid{};
+  void set_uid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_VsyncId =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      TransactionState>;
+
+  static constexpr FieldMetadata_VsyncId kVsyncId{};
+  void set_vsync_id(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VsyncId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_InputEventId =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TransactionState>;
+
+  static constexpr FieldMetadata_InputEventId kInputEventId{};
+  void set_input_event_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InputEventId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PostTime =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      TransactionState>;
+
+  static constexpr FieldMetadata_PostTime kPostTime{};
+  void set_post_time(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PostTime::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TransactionId =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TransactionState>;
+
+  static constexpr FieldMetadata_TransactionId kTransactionId{};
+  void set_transaction_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TransactionId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_LayerChanges =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      LayerState,
+      TransactionState>;
+
+  static constexpr FieldMetadata_LayerChanges kLayerChanges{};
+  template <typename T = LayerState> T* add_layer_changes() {
+    return BeginNestedMessage<T>(7);
+  }
+
+
+  using FieldMetadata_DisplayChanges =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      DisplayState,
+      TransactionState>;
+
+  static constexpr FieldMetadata_DisplayChanges kDisplayChanges{};
+  template <typename T = DisplayState> T* add_display_changes() {
+    return BeginNestedMessage<T>(8);
+  }
+
+
+  using FieldMetadata_MergedTransactionIds =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TransactionState>;
+
+  static constexpr FieldMetadata_MergedTransactionIds kMergedTransactionIds{};
+  void add_merged_transaction_ids(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MergedTransactionIds::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ApplyToken =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TransactionState>;
+
+  static constexpr FieldMetadata_ApplyToken kApplyToken{};
+  void set_apply_token(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ApplyToken::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TransactionBarriers =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TransactionBarrier,
+      TransactionState>;
+
+  static constexpr FieldMetadata_TransactionBarriers kTransactionBarriers{};
+  template <typename T = TransactionBarrier> T* add_transaction_barriers() {
+    return BeginNestedMessage<T>(11);
+  }
+
+};
+
+class TransactionBarrier_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  TransactionBarrier_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TransactionBarrier_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TransactionBarrier_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_barrier_token() const { return at<1>().valid(); }
+  ::protozero::ConstChars barrier_token() const { return at<1>().as_string(); }
+  bool has_kind() const { return at<2>().valid(); }
+  uint32_t kind() const { return at<2>().as_uint32(); }
+};
+
+class TransactionBarrier : public ::protozero::Message {
+ public:
+  using Decoder = TransactionBarrier_Decoder;
+  enum : int32_t {
+    kBarrierTokenFieldNumber = 1,
+    kKindFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TransactionBarrier"; }
+
+
+  using FieldMetadata_BarrierToken =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TransactionBarrier>;
+
+  static constexpr FieldMetadata_BarrierToken kBarrierToken{};
+  void set_barrier_token(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_BarrierToken::kFieldId, data, size);
+  }
+  void set_barrier_token(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_BarrierToken::kFieldId, chars.data, chars.size);
+  }
+  void set_barrier_token(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_BarrierToken::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Kind =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TransactionBarrier>;
+
+  static constexpr FieldMetadata_Kind kKind{};
+  void set_kind(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Kind::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class Transform_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
+ public:
+  Transform_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Transform_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Transform_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dsdx() const { return at<1>().valid(); }
+  float dsdx() const { return at<1>().as_float(); }
+  bool has_dtdx() const { return at<2>().valid(); }
+  float dtdx() const { return at<2>().as_float(); }
+  bool has_dtdy() const { return at<3>().valid(); }
+  float dtdy() const { return at<3>().as_float(); }
+  bool has_dsdy() const { return at<4>().valid(); }
+  float dsdy() const { return at<4>().as_float(); }
+  bool has_tx() const { return at<5>().valid(); }
+  float tx() const { return at<5>().as_float(); }
+  bool has_ty() const { return at<6>().valid(); }
+  float ty() const { return at<6>().as_float(); }
+};
+
+class Transform : public ::protozero::Message {
+ public:
+  using Decoder = Transform_Decoder;
+  enum : int32_t {
+    kDsdxFieldNumber = 1,
+    kDtdxFieldNumber = 2,
+    kDtdyFieldNumber = 3,
+    kDsdyFieldNumber = 4,
+    kTxFieldNumber = 5,
+    kTyFieldNumber = 6,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Transform"; }
+
+
+  using FieldMetadata_Dsdx =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      Transform>;
+
+  static constexpr FieldMetadata_Dsdx kDsdx{};
+  void set_dsdx(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dsdx::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Dtdx =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      Transform>;
+
+  static constexpr FieldMetadata_Dtdx kDtdx{};
+  void set_dtdx(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dtdx::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Dtdy =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      Transform>;
+
+  static constexpr FieldMetadata_Dtdy kDtdy{};
+  void set_dtdy(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dtdy::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Dsdy =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      Transform>;
+
+  static constexpr FieldMetadata_Dsdy kDsdy{};
+  void set_dsdy(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dsdy::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Tx =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      Transform>;
+
+  static constexpr FieldMetadata_Tx kTx{};
+  void set_tx(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tx::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ty =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      Transform>;
+
+  static constexpr FieldMetadata_Ty kTy{};
+  void set_ty(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ty::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class LayerCreationArgs_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
+ public:
+  LayerCreationArgs_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit LayerCreationArgs_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit LayerCreationArgs_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_layer_id() const { return at<1>().valid(); }
+  uint32_t layer_id() const { return at<1>().as_uint32(); }
+  bool has_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars name() const { return at<2>().as_string(); }
+  bool has_flags() const { return at<3>().valid(); }
+  uint32_t flags() const { return at<3>().as_uint32(); }
+  bool has_parent_id() const { return at<4>().valid(); }
+  uint32_t parent_id() const { return at<4>().as_uint32(); }
+  bool has_mirror_from_id() const { return at<5>().valid(); }
+  uint32_t mirror_from_id() const { return at<5>().as_uint32(); }
+  bool has_add_to_root() const { return at<6>().valid(); }
+  bool add_to_root() const { return at<6>().as_bool(); }
+  bool has_layer_stack_to_mirror() const { return at<7>().valid(); }
+  uint32_t layer_stack_to_mirror() const { return at<7>().as_uint32(); }
+};
+
+class LayerCreationArgs : public ::protozero::Message {
+ public:
+  using Decoder = LayerCreationArgs_Decoder;
+  enum : int32_t {
+    kLayerIdFieldNumber = 1,
+    kNameFieldNumber = 2,
+    kFlagsFieldNumber = 3,
+    kParentIdFieldNumber = 4,
+    kMirrorFromIdFieldNumber = 5,
+    kAddToRootFieldNumber = 6,
+    kLayerStackToMirrorFieldNumber = 7,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.LayerCreationArgs"; }
+
+
+  using FieldMetadata_LayerId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerCreationArgs>;
+
+  static constexpr FieldMetadata_LayerId kLayerId{};
+  void set_layer_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LayerId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      LayerCreationArgs>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Flags =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerCreationArgs>;
+
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ParentId =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerCreationArgs>;
+
+  static constexpr FieldMetadata_ParentId kParentId{};
+  void set_parent_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ParentId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MirrorFromId =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerCreationArgs>;
+
+  static constexpr FieldMetadata_MirrorFromId kMirrorFromId{};
+  void set_mirror_from_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MirrorFromId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_AddToRoot =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      LayerCreationArgs>;
+
+  static constexpr FieldMetadata_AddToRoot kAddToRoot{};
+  void set_add_to_root(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_AddToRoot::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_LayerStackToMirror =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      LayerCreationArgs>;
+
+  static constexpr FieldMetadata_LayerStackToMirror kLayerStackToMirror{};
+  void set_layer_stack_to_mirror(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LayerStackToMirror::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class DisplayInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/12> {
+ public:
+  DisplayInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DisplayInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DisplayInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_layer_stack() const { return at<1>().valid(); }
+  uint32_t layer_stack() const { return at<1>().as_uint32(); }
+  bool has_display_id() const { return at<2>().valid(); }
+  int32_t display_id() const { return at<2>().as_int32(); }
+  bool has_logical_width() const { return at<3>().valid(); }
+  int32_t logical_width() const { return at<3>().as_int32(); }
+  bool has_logical_height() const { return at<4>().valid(); }
+  int32_t logical_height() const { return at<4>().as_int32(); }
+  bool has_transform_inverse() const { return at<5>().valid(); }
+  ::protozero::ConstBytes transform_inverse() const { return at<5>().as_bytes(); }
+  bool has_transform() const { return at<6>().valid(); }
+  ::protozero::ConstBytes transform() const { return at<6>().as_bytes(); }
+  bool has_receives_input() const { return at<7>().valid(); }
+  bool receives_input() const { return at<7>().as_bool(); }
+  bool has_is_secure() const { return at<8>().valid(); }
+  bool is_secure() const { return at<8>().as_bool(); }
+  bool has_is_primary() const { return at<9>().valid(); }
+  bool is_primary() const { return at<9>().as_bool(); }
+  bool has_is_virtual() const { return at<10>().valid(); }
+  bool is_virtual() const { return at<10>().as_bool(); }
+  bool has_rotation_flags() const { return at<11>().valid(); }
+  int32_t rotation_flags() const { return at<11>().as_int32(); }
+  bool has_transform_hint() const { return at<12>().valid(); }
+  int32_t transform_hint() const { return at<12>().as_int32(); }
+};
+
+class DisplayInfo : public ::protozero::Message {
+ public:
+  using Decoder = DisplayInfo_Decoder;
+  enum : int32_t {
+    kLayerStackFieldNumber = 1,
+    kDisplayIdFieldNumber = 2,
+    kLogicalWidthFieldNumber = 3,
+    kLogicalHeightFieldNumber = 4,
+    kTransformInverseFieldNumber = 5,
+    kTransformFieldNumber = 6,
+    kReceivesInputFieldNumber = 7,
+    kIsSecureFieldNumber = 8,
+    kIsPrimaryFieldNumber = 9,
+    kIsVirtualFieldNumber = 10,
+    kRotationFlagsFieldNumber = 11,
+    kTransformHintFieldNumber = 12,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.DisplayInfo"; }
+
+
+  using FieldMetadata_LayerStack =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      DisplayInfo>;
+
+  static constexpr FieldMetadata_LayerStack kLayerStack{};
+  void set_layer_stack(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LayerStack::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DisplayId =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      DisplayInfo>;
+
+  static constexpr FieldMetadata_DisplayId kDisplayId{};
+  void set_display_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DisplayId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_LogicalWidth =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      DisplayInfo>;
+
+  static constexpr FieldMetadata_LogicalWidth kLogicalWidth{};
+  void set_logical_width(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LogicalWidth::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_LogicalHeight =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      DisplayInfo>;
+
+  static constexpr FieldMetadata_LogicalHeight kLogicalHeight{};
+  void set_logical_height(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LogicalHeight::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TransformInverse =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      Transform,
+      DisplayInfo>;
+
+  static constexpr FieldMetadata_TransformInverse kTransformInverse{};
+  template <typename T = Transform> T* set_transform_inverse() {
+    return BeginNestedMessage<T>(5);
+  }
+
+
+  using FieldMetadata_Transform =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      Transform,
+      DisplayInfo>;
+
+  static constexpr FieldMetadata_Transform kTransform{};
+  template <typename T = Transform> T* set_transform() {
+    return BeginNestedMessage<T>(6);
+  }
+
+
+  using FieldMetadata_ReceivesInput =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      DisplayInfo>;
+
+  static constexpr FieldMetadata_ReceivesInput kReceivesInput{};
+  void set_receives_input(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReceivesInput::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IsSecure =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      DisplayInfo>;
+
+  static constexpr FieldMetadata_IsSecure kIsSecure{};
+  void set_is_secure(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsSecure::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IsPrimary =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      DisplayInfo>;
+
+  static constexpr FieldMetadata_IsPrimary kIsPrimary{};
+  void set_is_primary(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsPrimary::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IsVirtual =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      DisplayInfo>;
+
+  static constexpr FieldMetadata_IsVirtual kIsVirtual{};
+  void set_is_virtual(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsVirtual::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_RotationFlags =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      DisplayInfo>;
+
+  static constexpr FieldMetadata_RotationFlags kRotationFlags{};
+  void set_rotation_flags(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RotationFlags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TransformHint =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      DisplayInfo>;
+
+  static constexpr FieldMetadata_TransformHint kTransformHint{};
+  void set_transform_hint(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TransformHint::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class TransactionTraceEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10> {
+ public:
+  TransactionTraceEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TransactionTraceEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TransactionTraceEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_elapsed_realtime_nanos() const { return at<1>().valid(); }
+  int64_t elapsed_realtime_nanos() const { return at<1>().as_int64(); }
+  bool has_vsync_id() const { return at<2>().valid(); }
+  int64_t vsync_id() const { return at<2>().as_int64(); }
+  bool has_transactions() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> transactions() const { return GetRepeated<::protozero::ConstBytes>(3); }
+  bool has_added_layers() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> added_layers() const { return GetRepeated<::protozero::ConstBytes>(4); }
+  bool has_destroyed_layers() const { return at<5>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint32_t> destroyed_layers() const { return GetRepeated<uint32_t>(5); }
+  bool has_added_displays() const { return at<6>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> added_displays() const { return GetRepeated<::protozero::ConstBytes>(6); }
+  bool has_removed_displays() const { return at<7>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> removed_displays() const { return GetRepeated<int32_t>(7); }
+  bool has_destroyed_layer_handles() const { return at<8>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint32_t> destroyed_layer_handles() const { return GetRepeated<uint32_t>(8); }
+  bool has_displays_changed() const { return at<9>().valid(); }
+  bool displays_changed() const { return at<9>().as_bool(); }
+  bool has_displays() const { return at<10>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> displays() const { return GetRepeated<::protozero::ConstBytes>(10); }
+};
+
+class TransactionTraceEntry : public ::protozero::Message {
+ public:
+  using Decoder = TransactionTraceEntry_Decoder;
+  enum : int32_t {
+    kElapsedRealtimeNanosFieldNumber = 1,
+    kVsyncIdFieldNumber = 2,
+    kTransactionsFieldNumber = 3,
+    kAddedLayersFieldNumber = 4,
+    kDestroyedLayersFieldNumber = 5,
+    kAddedDisplaysFieldNumber = 6,
+    kRemovedDisplaysFieldNumber = 7,
+    kDestroyedLayerHandlesFieldNumber = 8,
+    kDisplaysChangedFieldNumber = 9,
+    kDisplaysFieldNumber = 10,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TransactionTraceEntry"; }
+
+
+  using FieldMetadata_ElapsedRealtimeNanos =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      TransactionTraceEntry>;
+
+  static constexpr FieldMetadata_ElapsedRealtimeNanos kElapsedRealtimeNanos{};
+  void set_elapsed_realtime_nanos(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ElapsedRealtimeNanos::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_VsyncId =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      TransactionTraceEntry>;
+
+  static constexpr FieldMetadata_VsyncId kVsyncId{};
+  void set_vsync_id(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VsyncId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Transactions =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TransactionState,
+      TransactionTraceEntry>;
+
+  static constexpr FieldMetadata_Transactions kTransactions{};
+  template <typename T = TransactionState> T* add_transactions() {
+    return BeginNestedMessage<T>(3);
+  }
+
+
+  using FieldMetadata_AddedLayers =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      LayerCreationArgs,
+      TransactionTraceEntry>;
+
+  static constexpr FieldMetadata_AddedLayers kAddedLayers{};
+  template <typename T = LayerCreationArgs> T* add_added_layers() {
+    return BeginNestedMessage<T>(4);
+  }
+
+
+  using FieldMetadata_DestroyedLayers =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TransactionTraceEntry>;
+
+  static constexpr FieldMetadata_DestroyedLayers kDestroyedLayers{};
+  void add_destroyed_layers(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DestroyedLayers::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_AddedDisplays =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      DisplayState,
+      TransactionTraceEntry>;
+
+  static constexpr FieldMetadata_AddedDisplays kAddedDisplays{};
+  template <typename T = DisplayState> T* add_added_displays() {
+    return BeginNestedMessage<T>(6);
+  }
+
+
+  using FieldMetadata_RemovedDisplays =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TransactionTraceEntry>;
+
+  static constexpr FieldMetadata_RemovedDisplays kRemovedDisplays{};
+  void add_removed_displays(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RemovedDisplays::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DestroyedLayerHandles =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TransactionTraceEntry>;
+
+  static constexpr FieldMetadata_DestroyedLayerHandles kDestroyedLayerHandles{};
+  void add_destroyed_layer_handles(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DestroyedLayerHandles::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DisplaysChanged =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TransactionTraceEntry>;
+
+  static constexpr FieldMetadata_DisplaysChanged kDisplaysChanged{};
+  void set_displays_changed(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DisplaysChanged::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Displays =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      DisplayInfo,
+      TransactionTraceEntry>;
+
+  static constexpr FieldMetadata_Displays kDisplays{};
+  template <typename T = DisplayInfo> T* add_displays() {
+    return BeginNestedMessage<T>(10);
+  }
+
+};
+
+class TransactionTraceFile_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  TransactionTraceFile_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TransactionTraceFile_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TransactionTraceFile_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_magic_number() const { return at<1>().valid(); }
+  uint64_t magic_number() const { return at<1>().as_uint64(); }
+  bool has_entry() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> entry() const { return GetRepeated<::protozero::ConstBytes>(2); }
+  bool has_real_to_elapsed_time_offset_nanos() const { return at<3>().valid(); }
+  uint64_t real_to_elapsed_time_offset_nanos() const { return at<3>().as_uint64(); }
+  bool has_version() const { return at<4>().valid(); }
+  uint32_t version() const { return at<4>().as_uint32(); }
+};
+
+class TransactionTraceFile : public ::protozero::Message {
+ public:
+  using Decoder = TransactionTraceFile_Decoder;
+  enum : int32_t {
+    kMagicNumberFieldNumber = 1,
+    kEntryFieldNumber = 2,
+    kRealToElapsedTimeOffsetNanosFieldNumber = 3,
+    kVersionFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TransactionTraceFile"; }
+
+
+  using MagicNumber = ::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber;
+  static inline const char* MagicNumber_Name(MagicNumber value) {
+    return ::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber_Name(value);
+  }
+  static inline const MagicNumber INVALID = MagicNumber::INVALID;
+  static inline const MagicNumber MAGIC_NUMBER_L = MagicNumber::MAGIC_NUMBER_L;
+  static inline const MagicNumber MAGIC_NUMBER_H = MagicNumber::MAGIC_NUMBER_H;
+
+  using FieldMetadata_MagicNumber =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
+      uint64_t,
+      TransactionTraceFile>;
+
+  static constexpr FieldMetadata_MagicNumber kMagicNumber{};
+  void set_magic_number(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MagicNumber::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Entry =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TransactionTraceEntry,
+      TransactionTraceFile>;
+
+  static constexpr FieldMetadata_Entry kEntry{};
+  template <typename T = TransactionTraceEntry> T* add_entry() {
+    return BeginNestedMessage<T>(2);
+  }
+
+
+  using FieldMetadata_RealToElapsedTimeOffsetNanos =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
+      uint64_t,
+      TransactionTraceFile>;
+
+  static constexpr FieldMetadata_RealToElapsedTimeOffsetNanos kRealToElapsedTimeOffsetNanos{};
+  void set_real_to_elapsed_time_offset_nanos(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RealToElapsedTimeOffsetNanos::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Version =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TransactionTraceFile>;
+
+  static constexpr FieldMetadata_Version kVersion{};
+  void set_version(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Version::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/android_game_intervention_list.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_GAME_INTERVENTION_LIST_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_GAME_INTERVENTION_LIST_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class AndroidGameInterventionList_GameModeInfo;
+class AndroidGameInterventionList_GamePackageInfo;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class AndroidGameInterventionList_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  AndroidGameInterventionList_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidGameInterventionList_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidGameInterventionList_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_game_packages() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> game_packages() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  bool has_parse_error() const { return at<2>().valid(); }
+  bool parse_error() const { return at<2>().as_bool(); }
+  bool has_read_error() const { return at<3>().valid(); }
+  bool read_error() const { return at<3>().as_bool(); }
+};
+
+class AndroidGameInterventionList : public ::protozero::Message {
+ public:
+  using Decoder = AndroidGameInterventionList_Decoder;
+  enum : int32_t {
+    kGamePackagesFieldNumber = 1,
+    kParseErrorFieldNumber = 2,
+    kReadErrorFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidGameInterventionList"; }
+
+  using GameModeInfo = ::perfetto::protos::pbzero::AndroidGameInterventionList_GameModeInfo;
+  using GamePackageInfo = ::perfetto::protos::pbzero::AndroidGameInterventionList_GamePackageInfo;
+
+  using FieldMetadata_GamePackages =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AndroidGameInterventionList_GamePackageInfo,
+      AndroidGameInterventionList>;
+
+  static constexpr FieldMetadata_GamePackages kGamePackages{};
+  template <typename T = AndroidGameInterventionList_GamePackageInfo> T* add_game_packages() {
+    return BeginNestedMessage<T>(1);
+  }
+
+
+  using FieldMetadata_ParseError =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      AndroidGameInterventionList>;
+
+  static constexpr FieldMetadata_ParseError kParseError{};
+  void set_parse_error(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ParseError::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ReadError =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      AndroidGameInterventionList>;
+
+  static constexpr FieldMetadata_ReadError kReadError{};
+  void set_read_error(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReadError::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class AndroidGameInterventionList_GamePackageInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  AndroidGameInterventionList_GamePackageInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidGameInterventionList_GamePackageInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidGameInterventionList_GamePackageInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_uid() const { return at<2>().valid(); }
+  uint64_t uid() const { return at<2>().as_uint64(); }
+  bool has_current_mode() const { return at<3>().valid(); }
+  uint32_t current_mode() const { return at<3>().as_uint32(); }
+  bool has_game_mode_info() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> game_mode_info() const { return GetRepeated<::protozero::ConstBytes>(4); }
+};
+
+class AndroidGameInterventionList_GamePackageInfo : public ::protozero::Message {
+ public:
+  using Decoder = AndroidGameInterventionList_GamePackageInfo_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kUidFieldNumber = 2,
+    kCurrentModeFieldNumber = 3,
+    kGameModeInfoFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidGameInterventionList.GamePackageInfo"; }
+
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      AndroidGameInterventionList_GamePackageInfo>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Uid =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      AndroidGameInterventionList_GamePackageInfo>;
+
+  static constexpr FieldMetadata_Uid kUid{};
+  void set_uid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CurrentMode =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      AndroidGameInterventionList_GamePackageInfo>;
+
+  static constexpr FieldMetadata_CurrentMode kCurrentMode{};
+  void set_current_mode(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CurrentMode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_GameModeInfo =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AndroidGameInterventionList_GameModeInfo,
+      AndroidGameInterventionList_GamePackageInfo>;
+
+  static constexpr FieldMetadata_GameModeInfo kGameModeInfo{};
+  template <typename T = AndroidGameInterventionList_GameModeInfo> T* add_game_mode_info() {
+    return BeginNestedMessage<T>(4);
+  }
+
+};
+
+class AndroidGameInterventionList_GameModeInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  AndroidGameInterventionList_GameModeInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidGameInterventionList_GameModeInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidGameInterventionList_GameModeInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_mode() const { return at<1>().valid(); }
+  uint32_t mode() const { return at<1>().as_uint32(); }
+  bool has_use_angle() const { return at<2>().valid(); }
+  bool use_angle() const { return at<2>().as_bool(); }
+  bool has_resolution_downscale() const { return at<3>().valid(); }
+  float resolution_downscale() const { return at<3>().as_float(); }
+  bool has_fps() const { return at<4>().valid(); }
+  float fps() const { return at<4>().as_float(); }
+};
+
+class AndroidGameInterventionList_GameModeInfo : public ::protozero::Message {
+ public:
+  using Decoder = AndroidGameInterventionList_GameModeInfo_Decoder;
+  enum : int32_t {
+    kModeFieldNumber = 1,
+    kUseAngleFieldNumber = 2,
+    kResolutionDownscaleFieldNumber = 3,
+    kFpsFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidGameInterventionList.GameModeInfo"; }
+
+
+  using FieldMetadata_Mode =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      AndroidGameInterventionList_GameModeInfo>;
+
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_UseAngle =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      AndroidGameInterventionList_GameModeInfo>;
+
+  static constexpr FieldMetadata_UseAngle kUseAngle{};
+  void set_use_angle(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_UseAngle::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ResolutionDownscale =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      AndroidGameInterventionList_GameModeInfo>;
+
+  static constexpr FieldMetadata_ResolutionDownscale kResolutionDownscale{};
+  void set_resolution_downscale(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResolutionDownscale::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Fps =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      AndroidGameInterventionList_GameModeInfo>;
+
+  static constexpr FieldMetadata_Fps kFps{};
+  void set_fps(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_Fps::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/android_log.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_LOG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_LOG_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class AndroidLogPacket_LogEvent;
+class AndroidLogPacket_LogEvent_Arg;
+class AndroidLogPacket_Stats;
+enum AndroidLogId : int32_t;
+enum AndroidLogPriority : int32_t;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class AndroidLogPacket_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  AndroidLogPacket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidLogPacket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidLogPacket_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_events() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> events() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  bool has_stats() const { return at<2>().valid(); }
+  ::protozero::ConstBytes stats() const { return at<2>().as_bytes(); }
+};
+
+class AndroidLogPacket : public ::protozero::Message {
+ public:
+  using Decoder = AndroidLogPacket_Decoder;
+  enum : int32_t {
+    kEventsFieldNumber = 1,
+    kStatsFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidLogPacket"; }
+
+  using LogEvent = ::perfetto::protos::pbzero::AndroidLogPacket_LogEvent;
+  using Stats = ::perfetto::protos::pbzero::AndroidLogPacket_Stats;
+
+  using FieldMetadata_Events =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AndroidLogPacket_LogEvent,
+      AndroidLogPacket>;
+
+  static constexpr FieldMetadata_Events kEvents{};
+  template <typename T = AndroidLogPacket_LogEvent> T* add_events() {
+    return BeginNestedMessage<T>(1);
+  }
+
+
+  using FieldMetadata_Stats =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AndroidLogPacket_Stats,
+      AndroidLogPacket>;
+
+  static constexpr FieldMetadata_Stats kStats{};
+  template <typename T = AndroidLogPacket_Stats> T* set_stats() {
+    return BeginNestedMessage<T>(2);
+  }
+
+};
+
+class AndroidLogPacket_Stats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  AndroidLogPacket_Stats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidLogPacket_Stats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidLogPacket_Stats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_num_total() const { return at<1>().valid(); }
+  uint64_t num_total() const { return at<1>().as_uint64(); }
+  bool has_num_failed() const { return at<2>().valid(); }
+  uint64_t num_failed() const { return at<2>().as_uint64(); }
+  bool has_num_skipped() const { return at<3>().valid(); }
+  uint64_t num_skipped() const { return at<3>().as_uint64(); }
+};
+
+class AndroidLogPacket_Stats : public ::protozero::Message {
+ public:
+  using Decoder = AndroidLogPacket_Stats_Decoder;
+  enum : int32_t {
+    kNumTotalFieldNumber = 1,
+    kNumFailedFieldNumber = 2,
+    kNumSkippedFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidLogPacket.Stats"; }
+
+
+  using FieldMetadata_NumTotal =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      AndroidLogPacket_Stats>;
+
+  static constexpr FieldMetadata_NumTotal kNumTotal{};
+  void set_num_total(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NumTotal::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NumFailed =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      AndroidLogPacket_Stats>;
+
+  static constexpr FieldMetadata_NumFailed kNumFailed{};
+  void set_num_failed(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NumFailed::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NumSkipped =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      AndroidLogPacket_Stats>;
+
+  static constexpr FieldMetadata_NumSkipped kNumSkipped{};
+  void set_num_skipped(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NumSkipped::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class AndroidLogPacket_LogEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9> {
+ public:
+  AndroidLogPacket_LogEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidLogPacket_LogEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidLogPacket_LogEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_log_id() const { return at<1>().valid(); }
+  int32_t log_id() const { return at<1>().as_int32(); }
+  bool has_pid() const { return at<2>().valid(); }
+  int32_t pid() const { return at<2>().as_int32(); }
+  bool has_tid() const { return at<3>().valid(); }
+  int32_t tid() const { return at<3>().as_int32(); }
+  bool has_uid() const { return at<4>().valid(); }
+  int32_t uid() const { return at<4>().as_int32(); }
+  bool has_timestamp() const { return at<5>().valid(); }
+  uint64_t timestamp() const { return at<5>().as_uint64(); }
+  bool has_tag() const { return at<6>().valid(); }
+  ::protozero::ConstChars tag() const { return at<6>().as_string(); }
+  bool has_prio() const { return at<7>().valid(); }
+  int32_t prio() const { return at<7>().as_int32(); }
+  bool has_message() const { return at<8>().valid(); }
+  ::protozero::ConstChars message() const { return at<8>().as_string(); }
+  bool has_args() const { return at<9>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> args() const { return GetRepeated<::protozero::ConstBytes>(9); }
+};
+
+class AndroidLogPacket_LogEvent : public ::protozero::Message {
+ public:
+  using Decoder = AndroidLogPacket_LogEvent_Decoder;
+  enum : int32_t {
+    kLogIdFieldNumber = 1,
+    kPidFieldNumber = 2,
+    kTidFieldNumber = 3,
+    kUidFieldNumber = 4,
+    kTimestampFieldNumber = 5,
+    kTagFieldNumber = 6,
+    kPrioFieldNumber = 7,
+    kMessageFieldNumber = 8,
+    kArgsFieldNumber = 9,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidLogPacket.LogEvent"; }
+
+  using Arg = ::perfetto::protos::pbzero::AndroidLogPacket_LogEvent_Arg;
+
+  using FieldMetadata_LogId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      AndroidLogId,
+      AndroidLogPacket_LogEvent>;
+
+  static constexpr FieldMetadata_LogId kLogId{};
+  void set_log_id(AndroidLogId value) {
+    static constexpr uint32_t field_id = FieldMetadata_LogId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Pid =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      AndroidLogPacket_LogEvent>;
+
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Tid =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      AndroidLogPacket_LogEvent>;
+
+  static constexpr FieldMetadata_Tid kTid{};
+  void set_tid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Uid =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      AndroidLogPacket_LogEvent>;
+
+  static constexpr FieldMetadata_Uid kUid{};
+  void set_uid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Timestamp =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      AndroidLogPacket_LogEvent>;
+
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Tag =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      AndroidLogPacket_LogEvent>;
+
+  static constexpr FieldMetadata_Tag kTag{};
+  void set_tag(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Tag::kFieldId, data, size);
+  }
+  void set_tag(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Tag::kFieldId, chars.data, chars.size);
+  }
+  void set_tag(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tag::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Prio =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      AndroidLogPriority,
+      AndroidLogPacket_LogEvent>;
+
+  static constexpr FieldMetadata_Prio kPrio{};
+  void set_prio(AndroidLogPriority value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Message =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      AndroidLogPacket_LogEvent>;
+
+  static constexpr FieldMetadata_Message kMessage{};
+  void set_message(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Message::kFieldId, data, size);
+  }
+  void set_message(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Message::kFieldId, chars.data, chars.size);
+  }
+  void set_message(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Message::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Args =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AndroidLogPacket_LogEvent_Arg,
+      AndroidLogPacket_LogEvent>;
+
+  static constexpr FieldMetadata_Args kArgs{};
+  template <typename T = AndroidLogPacket_LogEvent_Arg> T* add_args() {
+    return BeginNestedMessage<T>(9);
+  }
+
+};
+
+class AndroidLogPacket_LogEvent_Arg_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  AndroidLogPacket_LogEvent_Arg_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidLogPacket_LogEvent_Arg_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidLogPacket_LogEvent_Arg_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_int_value() const { return at<2>().valid(); }
+  int64_t int_value() const { return at<2>().as_int64(); }
+  bool has_float_value() const { return at<3>().valid(); }
+  float float_value() const { return at<3>().as_float(); }
+  bool has_string_value() const { return at<4>().valid(); }
+  ::protozero::ConstChars string_value() const { return at<4>().as_string(); }
+};
+
+class AndroidLogPacket_LogEvent_Arg : public ::protozero::Message {
+ public:
+  using Decoder = AndroidLogPacket_LogEvent_Arg_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kIntValueFieldNumber = 2,
+    kFloatValueFieldNumber = 3,
+    kStringValueFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidLogPacket.LogEvent.Arg"; }
+
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      AndroidLogPacket_LogEvent_Arg>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IntValue =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      AndroidLogPacket_LogEvent_Arg>;
+
+  static constexpr FieldMetadata_IntValue kIntValue{};
+  void set_int_value(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FloatValue =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      AndroidLogPacket_LogEvent_Arg>;
+
+  static constexpr FieldMetadata_FloatValue kFloatValue{};
+  void set_float_value(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_FloatValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StringValue =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      AndroidLogPacket_LogEvent_Arg>;
+
+  static constexpr FieldMetadata_StringValue kStringValue{};
+  void set_string_value(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_StringValue::kFieldId, data, size);
+  }
+  void set_string_value(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_StringValue::kFieldId, chars.data, chars.size);
+  }
+  void set_string_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_StringValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/android_system_property.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_SYSTEM_PROPERTY_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_SYSTEM_PROPERTY_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class AndroidSystemProperty_PropertyValue;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class AndroidSystemProperty_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  AndroidSystemProperty_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidSystemProperty_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidSystemProperty_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_values() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> values() const { return GetRepeated<::protozero::ConstBytes>(1); }
+};
+
+class AndroidSystemProperty : public ::protozero::Message {
+ public:
+  using Decoder = AndroidSystemProperty_Decoder;
+  enum : int32_t {
+    kValuesFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidSystemProperty"; }
+
+  using PropertyValue = ::perfetto::protos::pbzero::AndroidSystemProperty_PropertyValue;
+
+  using FieldMetadata_Values =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AndroidSystemProperty_PropertyValue,
+      AndroidSystemProperty>;
+
+  static constexpr FieldMetadata_Values kValues{};
+  template <typename T = AndroidSystemProperty_PropertyValue> T* add_values() {
+    return BeginNestedMessage<T>(1);
+  }
+
+};
+
+class AndroidSystemProperty_PropertyValue_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  AndroidSystemProperty_PropertyValue_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidSystemProperty_PropertyValue_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidSystemProperty_PropertyValue_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_value() const { return at<2>().valid(); }
+  ::protozero::ConstChars value() const { return at<2>().as_string(); }
+};
+
+class AndroidSystemProperty_PropertyValue : public ::protozero::Message {
+ public:
+  using Decoder = AndroidSystemProperty_PropertyValue_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidSystemProperty.PropertyValue"; }
+
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      AndroidSystemProperty_PropertyValue>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      AndroidSystemProperty_PropertyValue>;
+
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
+  }
+  void set_value(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
+  }
+  void set_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/app_wakelock_data.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_APP_WAKELOCK_DATA_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_APP_WAKELOCK_DATA_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class AppWakelockInfo;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class AppWakelockBundle_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  AppWakelockBundle_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AppWakelockBundle_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AppWakelockBundle_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_intern_id() const { return at<1>().valid(); }
+  ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t> intern_id(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t>(1, parse_error_ptr); }
+  bool has_encoded_ts() const { return at<2>().valid(); }
+  ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> encoded_ts(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(2, parse_error_ptr); }
+  bool has_info() const { return at<3>().valid(); }
+  ::protozero::ConstBytes info() const { return at<3>().as_bytes(); }
+  bool has_acquired() const { return at<4>().valid(); }
+  bool acquired() const { return at<4>().as_bool(); }
+};
+
+class AppWakelockBundle : public ::protozero::Message {
+ public:
+  using Decoder = AppWakelockBundle_Decoder;
+  enum : int32_t {
+    kInternIdFieldNumber = 1,
+    kEncodedTsFieldNumber = 2,
+    kInfoFieldNumber = 3,
+    kAcquiredFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AppWakelockBundle"; }
+
+
+  using FieldMetadata_InternId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      AppWakelockBundle>;
+
+  static constexpr FieldMetadata_InternId kInternId{};
+  void set_intern_id(const ::protozero::PackedVarInt& packed_buffer) {
+    AppendBytes(FieldMetadata_InternId::kFieldId, packed_buffer.data(),
+                packed_buffer.size());
+  }
+
+  using FieldMetadata_EncodedTs =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      AppWakelockBundle>;
+
+  static constexpr FieldMetadata_EncodedTs kEncodedTs{};
+  void set_encoded_ts(const ::protozero::PackedVarInt& packed_buffer) {
+    AppendBytes(FieldMetadata_EncodedTs::kFieldId, packed_buffer.data(),
+                packed_buffer.size());
+  }
+
+  using FieldMetadata_Info =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AppWakelockInfo,
+      AppWakelockBundle>;
+
+  static constexpr FieldMetadata_Info kInfo{};
+  template <typename T = AppWakelockInfo> T* set_info() {
+    return BeginNestedMessage<T>(3);
+  }
+
+
+  using FieldMetadata_Acquired =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      AppWakelockBundle>;
+
+  static constexpr FieldMetadata_Acquired kAcquired{};
+  void set_acquired(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_Acquired::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class AppWakelockInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
+ public:
+  AppWakelockInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AppWakelockInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AppWakelockInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_iid() const { return at<1>().valid(); }
+  int32_t iid() const { return at<1>().as_int32(); }
+  bool has_tag() const { return at<2>().valid(); }
+  ::protozero::ConstChars tag() const { return at<2>().as_string(); }
+  bool has_flags() const { return at<3>().valid(); }
+  int32_t flags() const { return at<3>().as_int32(); }
+  bool has_owner_pid() const { return at<4>().valid(); }
+  int32_t owner_pid() const { return at<4>().as_int32(); }
+  bool has_owner_uid() const { return at<5>().valid(); }
+  int32_t owner_uid() const { return at<5>().as_int32(); }
+  bool has_work_uid() const { return at<6>().valid(); }
+  int32_t work_uid() const { return at<6>().as_int32(); }
+};
+
+class AppWakelockInfo : public ::protozero::Message {
+ public:
+  using Decoder = AppWakelockInfo_Decoder;
+  enum : int32_t {
+    kIidFieldNumber = 1,
+    kTagFieldNumber = 2,
+    kFlagsFieldNumber = 3,
+    kOwnerPidFieldNumber = 4,
+    kOwnerUidFieldNumber = 5,
+    kWorkUidFieldNumber = 6,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AppWakelockInfo"; }
+
+
+  using FieldMetadata_Iid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      AppWakelockInfo>;
+
+  static constexpr FieldMetadata_Iid kIid{};
+  void set_iid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Tag =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      AppWakelockInfo>;
+
+  static constexpr FieldMetadata_Tag kTag{};
+  void set_tag(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Tag::kFieldId, data, size);
+  }
+  void set_tag(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Tag::kFieldId, chars.data, chars.size);
+  }
+  void set_tag(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tag::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Flags =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      AppWakelockInfo>;
+
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OwnerPid =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      AppWakelockInfo>;
+
+  static constexpr FieldMetadata_OwnerPid kOwnerPid{};
+  void set_owner_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OwnerPid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OwnerUid =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      AppWakelockInfo>;
+
+  static constexpr FieldMetadata_OwnerUid kOwnerUid{};
+  void set_owner_uid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OwnerUid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_WorkUid =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      AppWakelockInfo>;
+
+  static constexpr FieldMetadata_WorkUid kWorkUid{};
+  void set_work_uid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_WorkUid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/bluetooth_trace.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_BLUETOOTH_TRACE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_BLUETOOTH_TRACE_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+enum BluetoothTracePacketType : int32_t;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+enum BluetoothTracePacketType : int32_t {
+  HCI_CMD = 1,
+  HCI_EVT = 2,
+  HCI_ACL_RX = 3,
+  HCI_ACL_TX = 4,
+  HCI_SCO_RX = 5,
+  HCI_SCO_TX = 6,
+  HCI_ISO_RX = 7,
+  HCI_ISO_TX = 8,
+};
+
+constexpr BluetoothTracePacketType BluetoothTracePacketType_MIN = BluetoothTracePacketType::HCI_CMD;
+constexpr BluetoothTracePacketType BluetoothTracePacketType_MAX = BluetoothTracePacketType::HCI_ISO_TX;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* BluetoothTracePacketType_Name(::perfetto::protos::pbzero::BluetoothTracePacketType value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::BluetoothTracePacketType::HCI_CMD:
+    return "HCI_CMD";
+
+  case ::perfetto::protos::pbzero::BluetoothTracePacketType::HCI_EVT:
+    return "HCI_EVT";
+
+  case ::perfetto::protos::pbzero::BluetoothTracePacketType::HCI_ACL_RX:
+    return "HCI_ACL_RX";
+
+  case ::perfetto::protos::pbzero::BluetoothTracePacketType::HCI_ACL_TX:
+    return "HCI_ACL_TX";
+
+  case ::perfetto::protos::pbzero::BluetoothTracePacketType::HCI_SCO_RX:
+    return "HCI_SCO_RX";
+
+  case ::perfetto::protos::pbzero::BluetoothTracePacketType::HCI_SCO_TX:
+    return "HCI_SCO_TX";
+
+  case ::perfetto::protos::pbzero::BluetoothTracePacketType::HCI_ISO_RX:
+    return "HCI_ISO_RX";
+
+  case ::perfetto::protos::pbzero::BluetoothTracePacketType::HCI_ISO_TX:
+    return "HCI_ISO_TX";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class BluetoothTraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
+ public:
+  BluetoothTraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit BluetoothTraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit BluetoothTraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_packet_type() const { return at<1>().valid(); }
+  int32_t packet_type() const { return at<1>().as_int32(); }
+  bool has_count() const { return at<2>().valid(); }
+  uint32_t count() const { return at<2>().as_uint32(); }
+  bool has_length() const { return at<3>().valid(); }
+  uint32_t length() const { return at<3>().as_uint32(); }
+  bool has_duration() const { return at<4>().valid(); }
+  uint32_t duration() const { return at<4>().as_uint32(); }
+  bool has_op_code() const { return at<5>().valid(); }
+  uint32_t op_code() const { return at<5>().as_uint32(); }
+  bool has_event_code() const { return at<6>().valid(); }
+  uint32_t event_code() const { return at<6>().as_uint32(); }
+  bool has_subevent_code() const { return at<7>().valid(); }
+  uint32_t subevent_code() const { return at<7>().as_uint32(); }
+  bool has_connection_handle() const { return at<8>().valid(); }
+  uint32_t connection_handle() const { return at<8>().as_uint32(); }
+};
+
+class BluetoothTraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = BluetoothTraceEvent_Decoder;
+  enum : int32_t {
+    kPacketTypeFieldNumber = 1,
+    kCountFieldNumber = 2,
+    kLengthFieldNumber = 3,
+    kDurationFieldNumber = 4,
+    kOpCodeFieldNumber = 5,
+    kEventCodeFieldNumber = 6,
+    kSubeventCodeFieldNumber = 7,
+    kConnectionHandleFieldNumber = 8,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.BluetoothTraceEvent"; }
+
+
+  using FieldMetadata_PacketType =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      BluetoothTracePacketType,
+      BluetoothTraceEvent>;
+
+  static constexpr FieldMetadata_PacketType kPacketType{};
+  void set_packet_type(BluetoothTracePacketType value) {
+    static constexpr uint32_t field_id = FieldMetadata_PacketType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Count =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      BluetoothTraceEvent>;
+
+  static constexpr FieldMetadata_Count kCount{};
+  void set_count(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Length =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      BluetoothTraceEvent>;
+
+  static constexpr FieldMetadata_Length kLength{};
+  void set_length(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Length::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Duration =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      BluetoothTraceEvent>;
+
+  static constexpr FieldMetadata_Duration kDuration{};
+  void set_duration(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Duration::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OpCode =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      BluetoothTraceEvent>;
+
+  static constexpr FieldMetadata_OpCode kOpCode{};
+  void set_op_code(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OpCode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_EventCode =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      BluetoothTraceEvent>;
+
+  static constexpr FieldMetadata_EventCode kEventCode{};
+  void set_event_code(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EventCode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SubeventCode =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      BluetoothTraceEvent>;
+
+  static constexpr FieldMetadata_SubeventCode kSubeventCode{};
+  void set_subevent_code(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SubeventCode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ConnectionHandle =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      BluetoothTraceEvent>;
+
+  static constexpr FieldMetadata_ConnectionHandle kConnectionHandle{};
+  void set_connection_handle(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ConnectionHandle::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/camera_event.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_CAMERA_EVENT_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_CAMERA_EVENT_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class AndroidCameraFrameEvent_CameraNodeProcessingDetails;
+class AndroidCameraSessionStats_CameraGraph;
+class AndroidCameraSessionStats_CameraGraph_CameraEdge;
+class AndroidCameraSessionStats_CameraGraph_CameraNode;
+namespace perfetto_pbzero_enum_AndroidCameraFrameEvent {
+enum CaptureResultStatus : int32_t;
+}  // namespace perfetto_pbzero_enum_AndroidCameraFrameEvent
+using AndroidCameraFrameEvent_CaptureResultStatus = perfetto_pbzero_enum_AndroidCameraFrameEvent::CaptureResultStatus;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_AndroidCameraFrameEvent {
+enum CaptureResultStatus : int32_t {
+  STATUS_UNSPECIFIED = 0,
+  STATUS_OK = 1,
+  STATUS_EARLY_METADATA_ERROR = 2,
+  STATUS_FINAL_METADATA_ERROR = 3,
+  STATUS_BUFFER_ERROR = 4,
+  STATUS_FLUSH_ERROR = 5,
+};
+} // namespace perfetto_pbzero_enum_AndroidCameraFrameEvent
+using AndroidCameraFrameEvent_CaptureResultStatus = perfetto_pbzero_enum_AndroidCameraFrameEvent::CaptureResultStatus;
+
+
+constexpr AndroidCameraFrameEvent_CaptureResultStatus AndroidCameraFrameEvent_CaptureResultStatus_MIN = AndroidCameraFrameEvent_CaptureResultStatus::STATUS_UNSPECIFIED;
+constexpr AndroidCameraFrameEvent_CaptureResultStatus AndroidCameraFrameEvent_CaptureResultStatus_MAX = AndroidCameraFrameEvent_CaptureResultStatus::STATUS_FLUSH_ERROR;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* AndroidCameraFrameEvent_CaptureResultStatus_Name(::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_UNSPECIFIED:
+    return "STATUS_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_OK:
+    return "STATUS_OK";
+
+  case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_EARLY_METADATA_ERROR:
+    return "STATUS_EARLY_METADATA_ERROR";
+
+  case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_FINAL_METADATA_ERROR:
+    return "STATUS_FINAL_METADATA_ERROR";
+
+  case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_BUFFER_ERROR:
+    return "STATUS_BUFFER_ERROR";
+
+  case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_FLUSH_ERROR:
+    return "STATUS_FLUSH_ERROR";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class AndroidCameraSessionStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  AndroidCameraSessionStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidCameraSessionStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidCameraSessionStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_session_id() const { return at<1>().valid(); }
+  uint64_t session_id() const { return at<1>().as_uint64(); }
+  bool has_graph() const { return at<2>().valid(); }
+  ::protozero::ConstBytes graph() const { return at<2>().as_bytes(); }
+};
+
+class AndroidCameraSessionStats : public ::protozero::Message {
+ public:
+  using Decoder = AndroidCameraSessionStats_Decoder;
+  enum : int32_t {
+    kSessionIdFieldNumber = 1,
+    kGraphFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraSessionStats"; }
+
+  using CameraGraph = ::perfetto::protos::pbzero::AndroidCameraSessionStats_CameraGraph;
+
+  using FieldMetadata_SessionId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      AndroidCameraSessionStats>;
+
+  static constexpr FieldMetadata_SessionId kSessionId{};
+  void set_session_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SessionId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Graph =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AndroidCameraSessionStats_CameraGraph,
+      AndroidCameraSessionStats>;
+
+  static constexpr FieldMetadata_Graph kGraph{};
+  template <typename T = AndroidCameraSessionStats_CameraGraph> T* set_graph() {
+    return BeginNestedMessage<T>(2);
+  }
+
+};
+
+class AndroidCameraSessionStats_CameraGraph_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  AndroidCameraSessionStats_CameraGraph_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidCameraSessionStats_CameraGraph_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidCameraSessionStats_CameraGraph_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_nodes() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> nodes() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  bool has_edges() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> edges() const { return GetRepeated<::protozero::ConstBytes>(2); }
+};
+
+class AndroidCameraSessionStats_CameraGraph : public ::protozero::Message {
+ public:
+  using Decoder = AndroidCameraSessionStats_CameraGraph_Decoder;
+  enum : int32_t {
+    kNodesFieldNumber = 1,
+    kEdgesFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraSessionStats.CameraGraph"; }
+
+  using CameraNode = ::perfetto::protos::pbzero::AndroidCameraSessionStats_CameraGraph_CameraNode;
+  using CameraEdge = ::perfetto::protos::pbzero::AndroidCameraSessionStats_CameraGraph_CameraEdge;
+
+  using FieldMetadata_Nodes =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AndroidCameraSessionStats_CameraGraph_CameraNode,
+      AndroidCameraSessionStats_CameraGraph>;
+
+  static constexpr FieldMetadata_Nodes kNodes{};
+  template <typename T = AndroidCameraSessionStats_CameraGraph_CameraNode> T* add_nodes() {
+    return BeginNestedMessage<T>(1);
+  }
+
+
+  using FieldMetadata_Edges =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AndroidCameraSessionStats_CameraGraph_CameraEdge,
+      AndroidCameraSessionStats_CameraGraph>;
+
+  static constexpr FieldMetadata_Edges kEdges{};
+  template <typename T = AndroidCameraSessionStats_CameraGraph_CameraEdge> T* add_edges() {
+    return BeginNestedMessage<T>(2);
+  }
+
+};
+
+class AndroidCameraSessionStats_CameraGraph_CameraEdge_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
+ public:
+  AndroidCameraSessionStats_CameraGraph_CameraEdge_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidCameraSessionStats_CameraGraph_CameraEdge_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidCameraSessionStats_CameraGraph_CameraEdge_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_output_node_id() const { return at<1>().valid(); }
+  int64_t output_node_id() const { return at<1>().as_int64(); }
+  bool has_output_id() const { return at<2>().valid(); }
+  int64_t output_id() const { return at<2>().as_int64(); }
+  bool has_input_node_id() const { return at<3>().valid(); }
+  int64_t input_node_id() const { return at<3>().as_int64(); }
+  bool has_input_id() const { return at<4>().valid(); }
+  int64_t input_id() const { return at<4>().as_int64(); }
+  bool has_vendor_data_version() const { return at<5>().valid(); }
+  int32_t vendor_data_version() const { return at<5>().as_int32(); }
+  bool has_vendor_data() const { return at<6>().valid(); }
+  ::protozero::ConstBytes vendor_data() const { return at<6>().as_bytes(); }
+};
+
+class AndroidCameraSessionStats_CameraGraph_CameraEdge : public ::protozero::Message {
+ public:
+  using Decoder = AndroidCameraSessionStats_CameraGraph_CameraEdge_Decoder;
+  enum : int32_t {
+    kOutputNodeIdFieldNumber = 1,
+    kOutputIdFieldNumber = 2,
+    kInputNodeIdFieldNumber = 3,
+    kInputIdFieldNumber = 4,
+    kVendorDataVersionFieldNumber = 5,
+    kVendorDataFieldNumber = 6,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraEdge"; }
+
+
+  using FieldMetadata_OutputNodeId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      AndroidCameraSessionStats_CameraGraph_CameraEdge>;
+
+  static constexpr FieldMetadata_OutputNodeId kOutputNodeId{};
+  void set_output_node_id(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OutputNodeId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OutputId =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      AndroidCameraSessionStats_CameraGraph_CameraEdge>;
+
+  static constexpr FieldMetadata_OutputId kOutputId{};
+  void set_output_id(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OutputId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_InputNodeId =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      AndroidCameraSessionStats_CameraGraph_CameraEdge>;
+
+  static constexpr FieldMetadata_InputNodeId kInputNodeId{};
+  void set_input_node_id(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InputNodeId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_InputId =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      AndroidCameraSessionStats_CameraGraph_CameraEdge>;
+
+  static constexpr FieldMetadata_InputId kInputId{};
+  void set_input_id(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InputId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_VendorDataVersion =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      AndroidCameraSessionStats_CameraGraph_CameraEdge>;
+
+  static constexpr FieldMetadata_VendorDataVersion kVendorDataVersion{};
+  void set_vendor_data_version(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VendorDataVersion::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_VendorData =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      AndroidCameraSessionStats_CameraGraph_CameraEdge>;
+
+  static constexpr FieldMetadata_VendorData kVendorData{};
+  void set_vendor_data(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_VendorData::kFieldId, data, size);
+  }
+  void set_vendor_data(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_VendorData::kFieldId, bytes.data, bytes.size);
+  }
+  void set_vendor_data(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_VendorData::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class AndroidCameraSessionStats_CameraGraph_CameraNode_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  AndroidCameraSessionStats_CameraGraph_CameraNode_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidCameraSessionStats_CameraGraph_CameraNode_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidCameraSessionStats_CameraGraph_CameraNode_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_node_id() const { return at<1>().valid(); }
+  int64_t node_id() const { return at<1>().as_int64(); }
+  bool has_input_ids() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<int64_t> input_ids() const { return GetRepeated<int64_t>(2); }
+  bool has_output_ids() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<int64_t> output_ids() const { return GetRepeated<int64_t>(3); }
+  bool has_vendor_data_version() const { return at<4>().valid(); }
+  int32_t vendor_data_version() const { return at<4>().as_int32(); }
+  bool has_vendor_data() const { return at<5>().valid(); }
+  ::protozero::ConstBytes vendor_data() const { return at<5>().as_bytes(); }
+};
+
+class AndroidCameraSessionStats_CameraGraph_CameraNode : public ::protozero::Message {
+ public:
+  using Decoder = AndroidCameraSessionStats_CameraGraph_CameraNode_Decoder;
+  enum : int32_t {
+    kNodeIdFieldNumber = 1,
+    kInputIdsFieldNumber = 2,
+    kOutputIdsFieldNumber = 3,
+    kVendorDataVersionFieldNumber = 4,
+    kVendorDataFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraNode"; }
+
+
+  using FieldMetadata_NodeId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      AndroidCameraSessionStats_CameraGraph_CameraNode>;
+
+  static constexpr FieldMetadata_NodeId kNodeId{};
+  void set_node_id(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NodeId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_InputIds =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      AndroidCameraSessionStats_CameraGraph_CameraNode>;
+
+  static constexpr FieldMetadata_InputIds kInputIds{};
+  void add_input_ids(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InputIds::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OutputIds =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      AndroidCameraSessionStats_CameraGraph_CameraNode>;
+
+  static constexpr FieldMetadata_OutputIds kOutputIds{};
+  void add_output_ids(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OutputIds::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_VendorDataVersion =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      AndroidCameraSessionStats_CameraGraph_CameraNode>;
+
+  static constexpr FieldMetadata_VendorDataVersion kVendorDataVersion{};
+  void set_vendor_data_version(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VendorDataVersion::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_VendorData =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      AndroidCameraSessionStats_CameraGraph_CameraNode>;
+
+  static constexpr FieldMetadata_VendorData kVendorData{};
+  void set_vendor_data(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_VendorData::kFieldId, data, size);
+  }
+  void set_vendor_data(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_VendorData::kFieldId, bytes.data, bytes.size);
+  }
+  void set_vendor_data(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_VendorData::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class AndroidCameraFrameEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/16> {
+ public:
+  AndroidCameraFrameEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidCameraFrameEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidCameraFrameEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_session_id() const { return at<1>().valid(); }
+  uint64_t session_id() const { return at<1>().as_uint64(); }
+  bool has_camera_id() const { return at<2>().valid(); }
+  uint32_t camera_id() const { return at<2>().as_uint32(); }
+  bool has_frame_number() const { return at<3>().valid(); }
+  int64_t frame_number() const { return at<3>().as_int64(); }
+  bool has_request_id() const { return at<4>().valid(); }
+  int64_t request_id() const { return at<4>().as_int64(); }
+  bool has_request_received_ns() const { return at<5>().valid(); }
+  int64_t request_received_ns() const { return at<5>().as_int64(); }
+  bool has_request_processing_started_ns() const { return at<6>().valid(); }
+  int64_t request_processing_started_ns() const { return at<6>().as_int64(); }
+  bool has_start_of_exposure_ns() const { return at<7>().valid(); }
+  int64_t start_of_exposure_ns() const { return at<7>().as_int64(); }
+  bool has_start_of_frame_ns() const { return at<8>().valid(); }
+  int64_t start_of_frame_ns() const { return at<8>().as_int64(); }
+  bool has_responses_all_sent_ns() const { return at<9>().valid(); }
+  int64_t responses_all_sent_ns() const { return at<9>().as_int64(); }
+  bool has_capture_result_status() const { return at<10>().valid(); }
+  int32_t capture_result_status() const { return at<10>().as_int32(); }
+  bool has_skipped_sensor_frames() const { return at<11>().valid(); }
+  int32_t skipped_sensor_frames() const { return at<11>().as_int32(); }
+  bool has_capture_intent() const { return at<12>().valid(); }
+  int32_t capture_intent() const { return at<12>().as_int32(); }
+  bool has_num_streams() const { return at<13>().valid(); }
+  int32_t num_streams() const { return at<13>().as_int32(); }
+  bool has_node_processing_details() const { return at<14>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> node_processing_details() const { return GetRepeated<::protozero::ConstBytes>(14); }
+  bool has_vendor_data_version() const { return at<15>().valid(); }
+  int32_t vendor_data_version() const { return at<15>().as_int32(); }
+  bool has_vendor_data() const { return at<16>().valid(); }
+  ::protozero::ConstBytes vendor_data() const { return at<16>().as_bytes(); }
+};
+
+class AndroidCameraFrameEvent : public ::protozero::Message {
+ public:
+  using Decoder = AndroidCameraFrameEvent_Decoder;
+  enum : int32_t {
+    kSessionIdFieldNumber = 1,
+    kCameraIdFieldNumber = 2,
+    kFrameNumberFieldNumber = 3,
+    kRequestIdFieldNumber = 4,
+    kRequestReceivedNsFieldNumber = 5,
+    kRequestProcessingStartedNsFieldNumber = 6,
+    kStartOfExposureNsFieldNumber = 7,
+    kStartOfFrameNsFieldNumber = 8,
+    kResponsesAllSentNsFieldNumber = 9,
+    kCaptureResultStatusFieldNumber = 10,
+    kSkippedSensorFramesFieldNumber = 11,
+    kCaptureIntentFieldNumber = 12,
+    kNumStreamsFieldNumber = 13,
+    kNodeProcessingDetailsFieldNumber = 14,
+    kVendorDataVersionFieldNumber = 15,
+    kVendorDataFieldNumber = 16,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraFrameEvent"; }
+
+  using CameraNodeProcessingDetails = ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CameraNodeProcessingDetails;
+
+  using CaptureResultStatus = ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus;
+  static inline const char* CaptureResultStatus_Name(CaptureResultStatus value) {
+    return ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus_Name(value);
+  }
+  static inline const CaptureResultStatus STATUS_UNSPECIFIED = CaptureResultStatus::STATUS_UNSPECIFIED;
+  static inline const CaptureResultStatus STATUS_OK = CaptureResultStatus::STATUS_OK;
+  static inline const CaptureResultStatus STATUS_EARLY_METADATA_ERROR = CaptureResultStatus::STATUS_EARLY_METADATA_ERROR;
+  static inline const CaptureResultStatus STATUS_FINAL_METADATA_ERROR = CaptureResultStatus::STATUS_FINAL_METADATA_ERROR;
+  static inline const CaptureResultStatus STATUS_BUFFER_ERROR = CaptureResultStatus::STATUS_BUFFER_ERROR;
+  static inline const CaptureResultStatus STATUS_FLUSH_ERROR = CaptureResultStatus::STATUS_FLUSH_ERROR;
+
+  using FieldMetadata_SessionId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      AndroidCameraFrameEvent>;
+
+  static constexpr FieldMetadata_SessionId kSessionId{};
+  void set_session_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SessionId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CameraId =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      AndroidCameraFrameEvent>;
+
+  static constexpr FieldMetadata_CameraId kCameraId{};
+  void set_camera_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CameraId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FrameNumber =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      AndroidCameraFrameEvent>;
+
+  static constexpr FieldMetadata_FrameNumber kFrameNumber{};
+  void set_frame_number(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FrameNumber::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_RequestId =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      AndroidCameraFrameEvent>;
+
+  static constexpr FieldMetadata_RequestId kRequestId{};
+  void set_request_id(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RequestId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_RequestReceivedNs =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      AndroidCameraFrameEvent>;
+
+  static constexpr FieldMetadata_RequestReceivedNs kRequestReceivedNs{};
+  void set_request_received_ns(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RequestReceivedNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_RequestProcessingStartedNs =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      AndroidCameraFrameEvent>;
+
+  static constexpr FieldMetadata_RequestProcessingStartedNs kRequestProcessingStartedNs{};
+  void set_request_processing_started_ns(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RequestProcessingStartedNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StartOfExposureNs =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      AndroidCameraFrameEvent>;
+
+  static constexpr FieldMetadata_StartOfExposureNs kStartOfExposureNs{};
+  void set_start_of_exposure_ns(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StartOfExposureNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StartOfFrameNs =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      AndroidCameraFrameEvent>;
+
+  static constexpr FieldMetadata_StartOfFrameNs kStartOfFrameNs{};
+  void set_start_of_frame_ns(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StartOfFrameNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ResponsesAllSentNs =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      AndroidCameraFrameEvent>;
+
+  static constexpr FieldMetadata_ResponsesAllSentNs kResponsesAllSentNs{};
+  void set_responses_all_sent_ns(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResponsesAllSentNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CaptureResultStatus =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      AndroidCameraFrameEvent_CaptureResultStatus,
+      AndroidCameraFrameEvent>;
+
+  static constexpr FieldMetadata_CaptureResultStatus kCaptureResultStatus{};
+  void set_capture_result_status(AndroidCameraFrameEvent_CaptureResultStatus value) {
+    static constexpr uint32_t field_id = FieldMetadata_CaptureResultStatus::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SkippedSensorFrames =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      AndroidCameraFrameEvent>;
+
+  static constexpr FieldMetadata_SkippedSensorFrames kSkippedSensorFrames{};
+  void set_skipped_sensor_frames(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SkippedSensorFrames::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CaptureIntent =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      AndroidCameraFrameEvent>;
+
+  static constexpr FieldMetadata_CaptureIntent kCaptureIntent{};
+  void set_capture_intent(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CaptureIntent::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NumStreams =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      AndroidCameraFrameEvent>;
+
+  static constexpr FieldMetadata_NumStreams kNumStreams{};
+  void set_num_streams(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NumStreams::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NodeProcessingDetails =
+    ::protozero::proto_utils::FieldMetadata<
+      14,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AndroidCameraFrameEvent_CameraNodeProcessingDetails,
+      AndroidCameraFrameEvent>;
+
+  static constexpr FieldMetadata_NodeProcessingDetails kNodeProcessingDetails{};
+  template <typename T = AndroidCameraFrameEvent_CameraNodeProcessingDetails> T* add_node_processing_details() {
+    return BeginNestedMessage<T>(14);
+  }
+
+
+  using FieldMetadata_VendorDataVersion =
+    ::protozero::proto_utils::FieldMetadata<
+      15,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      AndroidCameraFrameEvent>;
+
+  static constexpr FieldMetadata_VendorDataVersion kVendorDataVersion{};
+  void set_vendor_data_version(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VendorDataVersion::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_VendorData =
+    ::protozero::proto_utils::FieldMetadata<
+      16,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      AndroidCameraFrameEvent>;
+
+  static constexpr FieldMetadata_VendorData kVendorData{};
+  void set_vendor_data(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_VendorData::kFieldId, data, size);
+  }
+  void set_vendor_data(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_VendorData::kFieldId, bytes.data, bytes.size);
+  }
+  void set_vendor_data(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_VendorData::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class AndroidCameraFrameEvent_CameraNodeProcessingDetails_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  AndroidCameraFrameEvent_CameraNodeProcessingDetails_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidCameraFrameEvent_CameraNodeProcessingDetails_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidCameraFrameEvent_CameraNodeProcessingDetails_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_node_id() const { return at<1>().valid(); }
+  int64_t node_id() const { return at<1>().as_int64(); }
+  bool has_start_processing_ns() const { return at<2>().valid(); }
+  int64_t start_processing_ns() const { return at<2>().as_int64(); }
+  bool has_end_processing_ns() const { return at<3>().valid(); }
+  int64_t end_processing_ns() const { return at<3>().as_int64(); }
+  bool has_scheduling_latency_ns() const { return at<4>().valid(); }
+  int64_t scheduling_latency_ns() const { return at<4>().as_int64(); }
+};
+
+class AndroidCameraFrameEvent_CameraNodeProcessingDetails : public ::protozero::Message {
+ public:
+  using Decoder = AndroidCameraFrameEvent_CameraNodeProcessingDetails_Decoder;
+  enum : int32_t {
+    kNodeIdFieldNumber = 1,
+    kStartProcessingNsFieldNumber = 2,
+    kEndProcessingNsFieldNumber = 3,
+    kSchedulingLatencyNsFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraFrameEvent.CameraNodeProcessingDetails"; }
+
+
+  using FieldMetadata_NodeId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      AndroidCameraFrameEvent_CameraNodeProcessingDetails>;
+
+  static constexpr FieldMetadata_NodeId kNodeId{};
+  void set_node_id(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NodeId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StartProcessingNs =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      AndroidCameraFrameEvent_CameraNodeProcessingDetails>;
+
+  static constexpr FieldMetadata_StartProcessingNs kStartProcessingNs{};
+  void set_start_processing_ns(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StartProcessingNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_EndProcessingNs =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      AndroidCameraFrameEvent_CameraNodeProcessingDetails>;
+
+  static constexpr FieldMetadata_EndProcessingNs kEndProcessingNs{};
+  void set_end_processing_ns(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EndProcessingNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SchedulingLatencyNs =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      AndroidCameraFrameEvent_CameraNodeProcessingDetails>;
+
+  static constexpr FieldMetadata_SchedulingLatencyNs kSchedulingLatencyNs{};
+  void set_scheduling_latency_ns(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SchedulingLatencyNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/cpu_per_uid_data.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_CPU_PER_UID_DATA_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_CPU_PER_UID_DATA_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class CpuPerUidData_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  CpuPerUidData_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit CpuPerUidData_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit CpuPerUidData_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cluster_count() const { return at<1>().valid(); }
+  uint32_t cluster_count() const { return at<1>().as_uint32(); }
+  bool has_uid() const { return at<2>().valid(); }
+  ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t> uid(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t>(2, parse_error_ptr); }
+  bool has_total_time_ms() const { return at<3>().valid(); }
+  ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> total_time_ms(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(3, parse_error_ptr); }
+};
+
+class CpuPerUidData : public ::protozero::Message {
+ public:
+  using Decoder = CpuPerUidData_Decoder;
+  enum : int32_t {
+    kClusterCountFieldNumber = 1,
+    kUidFieldNumber = 2,
+    kTotalTimeMsFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.CpuPerUidData"; }
+
+
+  using FieldMetadata_ClusterCount =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      CpuPerUidData>;
+
+  static constexpr FieldMetadata_ClusterCount kClusterCount{};
+  void set_cluster_count(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ClusterCount::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Uid =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      CpuPerUidData>;
+
+  static constexpr FieldMetadata_Uid kUid{};
+  void set_uid(const ::protozero::PackedVarInt& packed_buffer) {
+    AppendBytes(FieldMetadata_Uid::kFieldId, packed_buffer.data(),
+                packed_buffer.size());
+  }
+
+  using FieldMetadata_TotalTimeMs =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      CpuPerUidData>;
+
+  static constexpr FieldMetadata_TotalTimeMs kTotalTimeMs{};
+  void set_total_time_ms(const ::protozero::PackedVarInt& packed_buffer) {
+    AppendBytes(FieldMetadata_TotalTimeMs::kFieldId, packed_buffer.data(),
+                packed_buffer.size());
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/frame_timeline_event.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_FRAME_TIMELINE_EVENT_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_FRAME_TIMELINE_EVENT_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class FrameTimelineEvent_ActualDisplayFrameStart;
+class FrameTimelineEvent_ActualSurfaceFrameStart;
+class FrameTimelineEvent_ExpectedDisplayFrameStart;
+class FrameTimelineEvent_ExpectedSurfaceFrameStart;
+class FrameTimelineEvent_FrameEnd;
+namespace perfetto_pbzero_enum_FrameTimelineEvent {
+enum JankSeverityType : int32_t;
+}  // namespace perfetto_pbzero_enum_FrameTimelineEvent
+using FrameTimelineEvent_JankSeverityType = perfetto_pbzero_enum_FrameTimelineEvent::JankSeverityType;
+namespace perfetto_pbzero_enum_FrameTimelineEvent {
+enum PredictionType : int32_t;
+}  // namespace perfetto_pbzero_enum_FrameTimelineEvent
+using FrameTimelineEvent_PredictionType = perfetto_pbzero_enum_FrameTimelineEvent::PredictionType;
+namespace perfetto_pbzero_enum_FrameTimelineEvent {
+enum PresentType : int32_t;
+}  // namespace perfetto_pbzero_enum_FrameTimelineEvent
+using FrameTimelineEvent_PresentType = perfetto_pbzero_enum_FrameTimelineEvent::PresentType;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_FrameTimelineEvent {
+enum JankType : int32_t {
+  JANK_UNSPECIFIED = 0,
+  JANK_NONE = 1,
+  JANK_SF_SCHEDULING = 2,
+  JANK_PREDICTION_ERROR = 4,
+  JANK_DISPLAY_HAL = 8,
+  JANK_SF_CPU_DEADLINE_MISSED = 16,
+  JANK_SF_GPU_DEADLINE_MISSED = 32,
+  JANK_APP_DEADLINE_MISSED = 64,
+  JANK_BUFFER_STUFFING = 128,
+  JANK_UNKNOWN = 256,
+  JANK_SF_STUFFING = 512,
+  JANK_DROPPED = 1024,
+  JANK_NON_ANIMATING = 2048,
+  JANK_APP_RESYNCED_JITTER = 4096,
+  JANK_DISPLAY_NOT_ON = 8192,
+  JANK_DISPLAY_MODE_CHANGE_IN_PROGRESS = 16384,
+  JANK_DISPLAY_POWER_MODE_CHANGE_IN_PROGRESS = 32768,
+};
+} // namespace perfetto_pbzero_enum_FrameTimelineEvent
+using FrameTimelineEvent_JankType = perfetto_pbzero_enum_FrameTimelineEvent::JankType;
+
+
+constexpr FrameTimelineEvent_JankType FrameTimelineEvent_JankType_MIN = FrameTimelineEvent_JankType::JANK_UNSPECIFIED;
+constexpr FrameTimelineEvent_JankType FrameTimelineEvent_JankType_MAX = FrameTimelineEvent_JankType::JANK_DISPLAY_POWER_MODE_CHANGE_IN_PROGRESS;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* FrameTimelineEvent_JankType_Name(::perfetto::protos::pbzero::FrameTimelineEvent_JankType value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_UNSPECIFIED:
+    return "JANK_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_NONE:
+    return "JANK_NONE";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_SF_SCHEDULING:
+    return "JANK_SF_SCHEDULING";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_PREDICTION_ERROR:
+    return "JANK_PREDICTION_ERROR";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_DISPLAY_HAL:
+    return "JANK_DISPLAY_HAL";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_SF_CPU_DEADLINE_MISSED:
+    return "JANK_SF_CPU_DEADLINE_MISSED";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_SF_GPU_DEADLINE_MISSED:
+    return "JANK_SF_GPU_DEADLINE_MISSED";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_APP_DEADLINE_MISSED:
+    return "JANK_APP_DEADLINE_MISSED";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_BUFFER_STUFFING:
+    return "JANK_BUFFER_STUFFING";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_UNKNOWN:
+    return "JANK_UNKNOWN";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_SF_STUFFING:
+    return "JANK_SF_STUFFING";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_DROPPED:
+    return "JANK_DROPPED";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_NON_ANIMATING:
+    return "JANK_NON_ANIMATING";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_APP_RESYNCED_JITTER:
+    return "JANK_APP_RESYNCED_JITTER";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_DISPLAY_NOT_ON:
+    return "JANK_DISPLAY_NOT_ON";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_DISPLAY_MODE_CHANGE_IN_PROGRESS:
+    return "JANK_DISPLAY_MODE_CHANGE_IN_PROGRESS";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_DISPLAY_POWER_MODE_CHANGE_IN_PROGRESS:
+    return "JANK_DISPLAY_POWER_MODE_CHANGE_IN_PROGRESS";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_FrameTimelineEvent {
+enum JankSeverityType : int32_t {
+  SEVERITY_UNKNOWN = 0,
+  SEVERITY_NONE = 1,
+  SEVERITY_PARTIAL = 2,
+  SEVERITY_FULL = 3,
+};
+} // namespace perfetto_pbzero_enum_FrameTimelineEvent
+using FrameTimelineEvent_JankSeverityType = perfetto_pbzero_enum_FrameTimelineEvent::JankSeverityType;
+
+
+constexpr FrameTimelineEvent_JankSeverityType FrameTimelineEvent_JankSeverityType_MIN = FrameTimelineEvent_JankSeverityType::SEVERITY_UNKNOWN;
+constexpr FrameTimelineEvent_JankSeverityType FrameTimelineEvent_JankSeverityType_MAX = FrameTimelineEvent_JankSeverityType::SEVERITY_FULL;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* FrameTimelineEvent_JankSeverityType_Name(::perfetto::protos::pbzero::FrameTimelineEvent_JankSeverityType value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankSeverityType::SEVERITY_UNKNOWN:
+    return "SEVERITY_UNKNOWN";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankSeverityType::SEVERITY_NONE:
+    return "SEVERITY_NONE";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankSeverityType::SEVERITY_PARTIAL:
+    return "SEVERITY_PARTIAL";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_JankSeverityType::SEVERITY_FULL:
+    return "SEVERITY_FULL";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_FrameTimelineEvent {
+enum PresentType : int32_t {
+  PRESENT_UNSPECIFIED = 0,
+  PRESENT_ON_TIME = 1,
+  PRESENT_LATE = 2,
+  PRESENT_EARLY = 3,
+  PRESENT_DROPPED = 4,
+  PRESENT_UNKNOWN = 5,
+};
+} // namespace perfetto_pbzero_enum_FrameTimelineEvent
+using FrameTimelineEvent_PresentType = perfetto_pbzero_enum_FrameTimelineEvent::PresentType;
+
+
+constexpr FrameTimelineEvent_PresentType FrameTimelineEvent_PresentType_MIN = FrameTimelineEvent_PresentType::PRESENT_UNSPECIFIED;
+constexpr FrameTimelineEvent_PresentType FrameTimelineEvent_PresentType_MAX = FrameTimelineEvent_PresentType::PRESENT_UNKNOWN;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* FrameTimelineEvent_PresentType_Name(::perfetto::protos::pbzero::FrameTimelineEvent_PresentType value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_UNSPECIFIED:
+    return "PRESENT_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_ON_TIME:
+    return "PRESENT_ON_TIME";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_LATE:
+    return "PRESENT_LATE";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_EARLY:
+    return "PRESENT_EARLY";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_DROPPED:
+    return "PRESENT_DROPPED";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_UNKNOWN:
+    return "PRESENT_UNKNOWN";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_FrameTimelineEvent {
+enum PredictionType : int32_t {
+  PREDICTION_UNSPECIFIED = 0,
+  PREDICTION_VALID = 1,
+  PREDICTION_EXPIRED = 2,
+  PREDICTION_UNKNOWN = 3,
+};
+} // namespace perfetto_pbzero_enum_FrameTimelineEvent
+using FrameTimelineEvent_PredictionType = perfetto_pbzero_enum_FrameTimelineEvent::PredictionType;
+
+
+constexpr FrameTimelineEvent_PredictionType FrameTimelineEvent_PredictionType_MIN = FrameTimelineEvent_PredictionType::PREDICTION_UNSPECIFIED;
+constexpr FrameTimelineEvent_PredictionType FrameTimelineEvent_PredictionType_MAX = FrameTimelineEvent_PredictionType::PREDICTION_UNKNOWN;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* FrameTimelineEvent_PredictionType_Name(::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType::PREDICTION_UNSPECIFIED:
+    return "PREDICTION_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType::PREDICTION_VALID:
+    return "PREDICTION_VALID";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType::PREDICTION_EXPIRED:
+    return "PREDICTION_EXPIRED";
+
+  case ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType::PREDICTION_UNKNOWN:
+    return "PREDICTION_UNKNOWN";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class FrameTimelineEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  FrameTimelineEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FrameTimelineEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FrameTimelineEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_expected_display_frame_start() const { return at<1>().valid(); }
+  ::protozero::ConstBytes expected_display_frame_start() const { return at<1>().as_bytes(); }
+  bool has_actual_display_frame_start() const { return at<2>().valid(); }
+  ::protozero::ConstBytes actual_display_frame_start() const { return at<2>().as_bytes(); }
+  bool has_expected_surface_frame_start() const { return at<3>().valid(); }
+  ::protozero::ConstBytes expected_surface_frame_start() const { return at<3>().as_bytes(); }
+  bool has_actual_surface_frame_start() const { return at<4>().valid(); }
+  ::protozero::ConstBytes actual_surface_frame_start() const { return at<4>().as_bytes(); }
+  bool has_frame_end() const { return at<5>().valid(); }
+  ::protozero::ConstBytes frame_end() const { return at<5>().as_bytes(); }
+};
+
+class FrameTimelineEvent : public ::protozero::Message {
+ public:
+  using Decoder = FrameTimelineEvent_Decoder;
+  enum : int32_t {
+    kExpectedDisplayFrameStartFieldNumber = 1,
+    kActualDisplayFrameStartFieldNumber = 2,
+    kExpectedSurfaceFrameStartFieldNumber = 3,
+    kActualSurfaceFrameStartFieldNumber = 4,
+    kFrameEndFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent"; }
+
+  using ExpectedSurfaceFrameStart = ::perfetto::protos::pbzero::FrameTimelineEvent_ExpectedSurfaceFrameStart;
+  using ActualSurfaceFrameStart = ::perfetto::protos::pbzero::FrameTimelineEvent_ActualSurfaceFrameStart;
+  using ExpectedDisplayFrameStart = ::perfetto::protos::pbzero::FrameTimelineEvent_ExpectedDisplayFrameStart;
+  using ActualDisplayFrameStart = ::perfetto::protos::pbzero::FrameTimelineEvent_ActualDisplayFrameStart;
+  using FrameEnd = ::perfetto::protos::pbzero::FrameTimelineEvent_FrameEnd;
+
+  using JankType = ::perfetto::protos::pbzero::FrameTimelineEvent_JankType;
+  static inline const char* JankType_Name(JankType value) {
+    return ::perfetto::protos::pbzero::FrameTimelineEvent_JankType_Name(value);
+  }
+
+  using JankSeverityType = ::perfetto::protos::pbzero::FrameTimelineEvent_JankSeverityType;
+  static inline const char* JankSeverityType_Name(JankSeverityType value) {
+    return ::perfetto::protos::pbzero::FrameTimelineEvent_JankSeverityType_Name(value);
+  }
+
+  using PresentType = ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType;
+  static inline const char* PresentType_Name(PresentType value) {
+    return ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType_Name(value);
+  }
+
+  using PredictionType = ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType;
+  static inline const char* PredictionType_Name(PredictionType value) {
+    return ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType_Name(value);
+  }
+  static inline const JankType JANK_UNSPECIFIED = JankType::JANK_UNSPECIFIED;
+  static inline const JankType JANK_NONE = JankType::JANK_NONE;
+  static inline const JankType JANK_SF_SCHEDULING = JankType::JANK_SF_SCHEDULING;
+  static inline const JankType JANK_PREDICTION_ERROR = JankType::JANK_PREDICTION_ERROR;
+  static inline const JankType JANK_DISPLAY_HAL = JankType::JANK_DISPLAY_HAL;
+  static inline const JankType JANK_SF_CPU_DEADLINE_MISSED = JankType::JANK_SF_CPU_DEADLINE_MISSED;
+  static inline const JankType JANK_SF_GPU_DEADLINE_MISSED = JankType::JANK_SF_GPU_DEADLINE_MISSED;
+  static inline const JankType JANK_APP_DEADLINE_MISSED = JankType::JANK_APP_DEADLINE_MISSED;
+  static inline const JankType JANK_BUFFER_STUFFING = JankType::JANK_BUFFER_STUFFING;
+  static inline const JankType JANK_UNKNOWN = JankType::JANK_UNKNOWN;
+  static inline const JankType JANK_SF_STUFFING = JankType::JANK_SF_STUFFING;
+  static inline const JankType JANK_DROPPED = JankType::JANK_DROPPED;
+  static inline const JankType JANK_NON_ANIMATING = JankType::JANK_NON_ANIMATING;
+  static inline const JankType JANK_APP_RESYNCED_JITTER = JankType::JANK_APP_RESYNCED_JITTER;
+  static inline const JankType JANK_DISPLAY_NOT_ON = JankType::JANK_DISPLAY_NOT_ON;
+  static inline const JankType JANK_DISPLAY_MODE_CHANGE_IN_PROGRESS = JankType::JANK_DISPLAY_MODE_CHANGE_IN_PROGRESS;
+  static inline const JankType JANK_DISPLAY_POWER_MODE_CHANGE_IN_PROGRESS = JankType::JANK_DISPLAY_POWER_MODE_CHANGE_IN_PROGRESS;
+  static inline const JankSeverityType SEVERITY_UNKNOWN = JankSeverityType::SEVERITY_UNKNOWN;
+  static inline const JankSeverityType SEVERITY_NONE = JankSeverityType::SEVERITY_NONE;
+  static inline const JankSeverityType SEVERITY_PARTIAL = JankSeverityType::SEVERITY_PARTIAL;
+  static inline const JankSeverityType SEVERITY_FULL = JankSeverityType::SEVERITY_FULL;
+  static inline const PresentType PRESENT_UNSPECIFIED = PresentType::PRESENT_UNSPECIFIED;
+  static inline const PresentType PRESENT_ON_TIME = PresentType::PRESENT_ON_TIME;
+  static inline const PresentType PRESENT_LATE = PresentType::PRESENT_LATE;
+  static inline const PresentType PRESENT_EARLY = PresentType::PRESENT_EARLY;
+  static inline const PresentType PRESENT_DROPPED = PresentType::PRESENT_DROPPED;
+  static inline const PresentType PRESENT_UNKNOWN = PresentType::PRESENT_UNKNOWN;
+  static inline const PredictionType PREDICTION_UNSPECIFIED = PredictionType::PREDICTION_UNSPECIFIED;
+  static inline const PredictionType PREDICTION_VALID = PredictionType::PREDICTION_VALID;
+  static inline const PredictionType PREDICTION_EXPIRED = PredictionType::PREDICTION_EXPIRED;
+  static inline const PredictionType PREDICTION_UNKNOWN = PredictionType::PREDICTION_UNKNOWN;
+
+  using FieldMetadata_ExpectedDisplayFrameStart =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FrameTimelineEvent_ExpectedDisplayFrameStart,
+      FrameTimelineEvent>;
+
+  static constexpr FieldMetadata_ExpectedDisplayFrameStart kExpectedDisplayFrameStart{};
+  template <typename T = FrameTimelineEvent_ExpectedDisplayFrameStart> T* set_expected_display_frame_start() {
+    return BeginNestedMessage<T>(1);
+  }
+
+
+  using FieldMetadata_ActualDisplayFrameStart =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FrameTimelineEvent_ActualDisplayFrameStart,
+      FrameTimelineEvent>;
+
+  static constexpr FieldMetadata_ActualDisplayFrameStart kActualDisplayFrameStart{};
+  template <typename T = FrameTimelineEvent_ActualDisplayFrameStart> T* set_actual_display_frame_start() {
+    return BeginNestedMessage<T>(2);
+  }
+
+
+  using FieldMetadata_ExpectedSurfaceFrameStart =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FrameTimelineEvent_ExpectedSurfaceFrameStart,
+      FrameTimelineEvent>;
+
+  static constexpr FieldMetadata_ExpectedSurfaceFrameStart kExpectedSurfaceFrameStart{};
+  template <typename T = FrameTimelineEvent_ExpectedSurfaceFrameStart> T* set_expected_surface_frame_start() {
+    return BeginNestedMessage<T>(3);
+  }
+
+
+  using FieldMetadata_ActualSurfaceFrameStart =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FrameTimelineEvent_ActualSurfaceFrameStart,
+      FrameTimelineEvent>;
+
+  static constexpr FieldMetadata_ActualSurfaceFrameStart kActualSurfaceFrameStart{};
+  template <typename T = FrameTimelineEvent_ActualSurfaceFrameStart> T* set_actual_surface_frame_start() {
+    return BeginNestedMessage<T>(4);
+  }
+
+
+  using FieldMetadata_FrameEnd =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FrameTimelineEvent_FrameEnd,
+      FrameTimelineEvent>;
+
+  static constexpr FieldMetadata_FrameEnd kFrameEnd{};
+  template <typename T = FrameTimelineEvent_FrameEnd> T* set_frame_end() {
+    return BeginNestedMessage<T>(5);
+  }
+
+};
+
+class FrameTimelineEvent_FrameEnd_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  FrameTimelineEvent_FrameEnd_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FrameTimelineEvent_FrameEnd_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FrameTimelineEvent_FrameEnd_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cookie() const { return at<1>().valid(); }
+  int64_t cookie() const { return at<1>().as_int64(); }
+};
+
+class FrameTimelineEvent_FrameEnd : public ::protozero::Message {
+ public:
+  using Decoder = FrameTimelineEvent_FrameEnd_Decoder;
+  enum : int32_t {
+    kCookieFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent.FrameEnd"; }
+
+
+  using FieldMetadata_Cookie =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      FrameTimelineEvent_FrameEnd>;
+
+  static constexpr FieldMetadata_Cookie kCookie{};
+  void set_cookie(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cookie::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class FrameTimelineEvent_ActualDisplayFrameStart_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/14> {
+ public:
+  FrameTimelineEvent_ActualDisplayFrameStart_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FrameTimelineEvent_ActualDisplayFrameStart_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FrameTimelineEvent_ActualDisplayFrameStart_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cookie() const { return at<1>().valid(); }
+  int64_t cookie() const { return at<1>().as_int64(); }
+  bool has_token() const { return at<2>().valid(); }
+  int64_t token() const { return at<2>().as_int64(); }
+  bool has_pid() const { return at<3>().valid(); }
+  int32_t pid() const { return at<3>().as_int32(); }
+  bool has_present_type() const { return at<4>().valid(); }
+  int32_t present_type() const { return at<4>().as_int32(); }
+  bool has_on_time_finish() const { return at<5>().valid(); }
+  bool on_time_finish() const { return at<5>().as_bool(); }
+  bool has_gpu_composition() const { return at<6>().valid(); }
+  bool gpu_composition() const { return at<6>().as_bool(); }
+  bool has_jank_type() const { return at<7>().valid(); }
+  int32_t jank_type() const { return at<7>().as_int32(); }
+  bool has_prediction_type() const { return at<8>().valid(); }
+  int32_t prediction_type() const { return at<8>().as_int32(); }
+  bool has_jank_severity_type() const { return at<9>().valid(); }
+  int32_t jank_severity_type() const { return at<9>().as_int32(); }
+  bool has_present_delay_millis() const { return at<10>().valid(); }
+  float present_delay_millis() const { return at<10>().as_float(); }
+  bool has_jank_severity_score() const { return at<11>().valid(); }
+  float jank_severity_score() const { return at<11>().as_float(); }
+  bool has_jank_type_experimental() const { return at<12>().valid(); }
+  int32_t jank_type_experimental() const { return at<12>().as_int32(); }
+  bool has_present_type_experimental() const { return at<13>().valid(); }
+  int32_t present_type_experimental() const { return at<13>().as_int32(); }
+  bool has_jank_debug_metadata() const { return at<14>().valid(); }
+  float jank_debug_metadata() const { return at<14>().as_float(); }
+};
+
+class FrameTimelineEvent_ActualDisplayFrameStart : public ::protozero::Message {
+ public:
+  using Decoder = FrameTimelineEvent_ActualDisplayFrameStart_Decoder;
+  enum : int32_t {
+    kCookieFieldNumber = 1,
+    kTokenFieldNumber = 2,
+    kPidFieldNumber = 3,
+    kPresentTypeFieldNumber = 4,
+    kOnTimeFinishFieldNumber = 5,
+    kGpuCompositionFieldNumber = 6,
+    kJankTypeFieldNumber = 7,
+    kPredictionTypeFieldNumber = 8,
+    kJankSeverityTypeFieldNumber = 9,
+    kPresentDelayMillisFieldNumber = 10,
+    kJankSeverityScoreFieldNumber = 11,
+    kJankTypeExperimentalFieldNumber = 12,
+    kPresentTypeExperimentalFieldNumber = 13,
+    kJankDebugMetadataFieldNumber = 14,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent.ActualDisplayFrameStart"; }
+
+
+  using FieldMetadata_Cookie =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      FrameTimelineEvent_ActualDisplayFrameStart>;
+
+  static constexpr FieldMetadata_Cookie kCookie{};
+  void set_cookie(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cookie::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Token =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      FrameTimelineEvent_ActualDisplayFrameStart>;
+
+  static constexpr FieldMetadata_Token kToken{};
+  void set_token(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Token::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Pid =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      FrameTimelineEvent_ActualDisplayFrameStart>;
+
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PresentType =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      FrameTimelineEvent_PresentType,
+      FrameTimelineEvent_ActualDisplayFrameStart>;
+
+  static constexpr FieldMetadata_PresentType kPresentType{};
+  void set_present_type(FrameTimelineEvent_PresentType value) {
+    static constexpr uint32_t field_id = FieldMetadata_PresentType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OnTimeFinish =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      FrameTimelineEvent_ActualDisplayFrameStart>;
+
+  static constexpr FieldMetadata_OnTimeFinish kOnTimeFinish{};
+  void set_on_time_finish(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_OnTimeFinish::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_GpuComposition =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      FrameTimelineEvent_ActualDisplayFrameStart>;
+
+  static constexpr FieldMetadata_GpuComposition kGpuComposition{};
+  void set_gpu_composition(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_GpuComposition::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_JankType =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      FrameTimelineEvent_ActualDisplayFrameStart>;
+
+  static constexpr FieldMetadata_JankType kJankType{};
+  void set_jank_type(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_JankType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PredictionType =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      FrameTimelineEvent_PredictionType,
+      FrameTimelineEvent_ActualDisplayFrameStart>;
+
+  static constexpr FieldMetadata_PredictionType kPredictionType{};
+  void set_prediction_type(FrameTimelineEvent_PredictionType value) {
+    static constexpr uint32_t field_id = FieldMetadata_PredictionType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_JankSeverityType =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      FrameTimelineEvent_JankSeverityType,
+      FrameTimelineEvent_ActualDisplayFrameStart>;
+
+  static constexpr FieldMetadata_JankSeverityType kJankSeverityType{};
+  void set_jank_severity_type(FrameTimelineEvent_JankSeverityType value) {
+    static constexpr uint32_t field_id = FieldMetadata_JankSeverityType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PresentDelayMillis =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      FrameTimelineEvent_ActualDisplayFrameStart>;
+
+  static constexpr FieldMetadata_PresentDelayMillis kPresentDelayMillis{};
+  void set_present_delay_millis(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_PresentDelayMillis::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_JankSeverityScore =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      FrameTimelineEvent_ActualDisplayFrameStart>;
+
+  static constexpr FieldMetadata_JankSeverityScore kJankSeverityScore{};
+  void set_jank_severity_score(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_JankSeverityScore::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_JankTypeExperimental =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      FrameTimelineEvent_ActualDisplayFrameStart>;
+
+  static constexpr FieldMetadata_JankTypeExperimental kJankTypeExperimental{};
+  void set_jank_type_experimental(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_JankTypeExperimental::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PresentTypeExperimental =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      FrameTimelineEvent_PresentType,
+      FrameTimelineEvent_ActualDisplayFrameStart>;
+
+  static constexpr FieldMetadata_PresentTypeExperimental kPresentTypeExperimental{};
+  void set_present_type_experimental(FrameTimelineEvent_PresentType value) {
+    static constexpr uint32_t field_id = FieldMetadata_PresentTypeExperimental::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_JankDebugMetadata =
+    ::protozero::proto_utils::FieldMetadata<
+      14,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      FrameTimelineEvent_ActualDisplayFrameStart>;
+
+  static constexpr FieldMetadata_JankDebugMetadata kJankDebugMetadata{};
+  void set_jank_debug_metadata(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_JankDebugMetadata::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class FrameTimelineEvent_ExpectedDisplayFrameStart_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  FrameTimelineEvent_ExpectedDisplayFrameStart_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FrameTimelineEvent_ExpectedDisplayFrameStart_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FrameTimelineEvent_ExpectedDisplayFrameStart_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cookie() const { return at<1>().valid(); }
+  int64_t cookie() const { return at<1>().as_int64(); }
+  bool has_token() const { return at<2>().valid(); }
+  int64_t token() const { return at<2>().as_int64(); }
+  bool has_pid() const { return at<3>().valid(); }
+  int32_t pid() const { return at<3>().as_int32(); }
+};
+
+class FrameTimelineEvent_ExpectedDisplayFrameStart : public ::protozero::Message {
+ public:
+  using Decoder = FrameTimelineEvent_ExpectedDisplayFrameStart_Decoder;
+  enum : int32_t {
+    kCookieFieldNumber = 1,
+    kTokenFieldNumber = 2,
+    kPidFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent.ExpectedDisplayFrameStart"; }
+
+
+  using FieldMetadata_Cookie =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      FrameTimelineEvent_ExpectedDisplayFrameStart>;
+
+  static constexpr FieldMetadata_Cookie kCookie{};
+  void set_cookie(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cookie::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Token =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      FrameTimelineEvent_ExpectedDisplayFrameStart>;
+
+  static constexpr FieldMetadata_Token kToken{};
+  void set_token(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Token::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Pid =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      FrameTimelineEvent_ExpectedDisplayFrameStart>;
+
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class FrameTimelineEvent_ActualSurfaceFrameStart_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/18> {
+ public:
+  FrameTimelineEvent_ActualSurfaceFrameStart_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FrameTimelineEvent_ActualSurfaceFrameStart_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FrameTimelineEvent_ActualSurfaceFrameStart_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cookie() const { return at<1>().valid(); }
+  int64_t cookie() const { return at<1>().as_int64(); }
+  bool has_token() const { return at<2>().valid(); }
+  int64_t token() const { return at<2>().as_int64(); }
+  bool has_display_frame_token() const { return at<3>().valid(); }
+  int64_t display_frame_token() const { return at<3>().as_int64(); }
+  bool has_pid() const { return at<4>().valid(); }
+  int32_t pid() const { return at<4>().as_int32(); }
+  bool has_layer_name() const { return at<5>().valid(); }
+  ::protozero::ConstChars layer_name() const { return at<5>().as_string(); }
+  bool has_present_type() const { return at<6>().valid(); }
+  int32_t present_type() const { return at<6>().as_int32(); }
+  bool has_on_time_finish() const { return at<7>().valid(); }
+  bool on_time_finish() const { return at<7>().as_bool(); }
+  bool has_gpu_composition() const { return at<8>().valid(); }
+  bool gpu_composition() const { return at<8>().as_bool(); }
+  bool has_jank_type() const { return at<9>().valid(); }
+  int32_t jank_type() const { return at<9>().as_int32(); }
+  bool has_prediction_type() const { return at<10>().valid(); }
+  int32_t prediction_type() const { return at<10>().as_int32(); }
+  bool has_is_buffer() const { return at<11>().valid(); }
+  bool is_buffer() const { return at<11>().as_bool(); }
+  bool has_jank_severity_type() const { return at<12>().valid(); }
+  int32_t jank_severity_type() const { return at<12>().as_int32(); }
+  bool has_present_delay_millis() const { return at<13>().valid(); }
+  float present_delay_millis() const { return at<13>().as_float(); }
+  bool has_vsync_resynced_jitter_millis() const { return at<14>().valid(); }
+  float vsync_resynced_jitter_millis() const { return at<14>().as_float(); }
+  bool has_jank_severity_score() const { return at<15>().valid(); }
+  float jank_severity_score() const { return at<15>().as_float(); }
+  bool has_jank_type_experimental() const { return at<16>().valid(); }
+  int32_t jank_type_experimental() const { return at<16>().as_int32(); }
+  bool has_present_type_experimental() const { return at<17>().valid(); }
+  int32_t present_type_experimental() const { return at<17>().as_int32(); }
+  bool has_jank_debug_metadata() const { return at<18>().valid(); }
+  float jank_debug_metadata() const { return at<18>().as_float(); }
+};
+
+class FrameTimelineEvent_ActualSurfaceFrameStart : public ::protozero::Message {
+ public:
+  using Decoder = FrameTimelineEvent_ActualSurfaceFrameStart_Decoder;
+  enum : int32_t {
+    kCookieFieldNumber = 1,
+    kTokenFieldNumber = 2,
+    kDisplayFrameTokenFieldNumber = 3,
+    kPidFieldNumber = 4,
+    kLayerNameFieldNumber = 5,
+    kPresentTypeFieldNumber = 6,
+    kOnTimeFinishFieldNumber = 7,
+    kGpuCompositionFieldNumber = 8,
+    kJankTypeFieldNumber = 9,
+    kPredictionTypeFieldNumber = 10,
+    kIsBufferFieldNumber = 11,
+    kJankSeverityTypeFieldNumber = 12,
+    kPresentDelayMillisFieldNumber = 13,
+    kVsyncResyncedJitterMillisFieldNumber = 14,
+    kJankSeverityScoreFieldNumber = 15,
+    kJankTypeExperimentalFieldNumber = 16,
+    kPresentTypeExperimentalFieldNumber = 17,
+    kJankDebugMetadataFieldNumber = 18,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent.ActualSurfaceFrameStart"; }
+
+
+  using FieldMetadata_Cookie =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      FrameTimelineEvent_ActualSurfaceFrameStart>;
+
+  static constexpr FieldMetadata_Cookie kCookie{};
+  void set_cookie(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cookie::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Token =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      FrameTimelineEvent_ActualSurfaceFrameStart>;
+
+  static constexpr FieldMetadata_Token kToken{};
+  void set_token(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Token::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DisplayFrameToken =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      FrameTimelineEvent_ActualSurfaceFrameStart>;
+
+  static constexpr FieldMetadata_DisplayFrameToken kDisplayFrameToken{};
+  void set_display_frame_token(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DisplayFrameToken::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Pid =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      FrameTimelineEvent_ActualSurfaceFrameStart>;
+
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_LayerName =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FrameTimelineEvent_ActualSurfaceFrameStart>;
+
+  static constexpr FieldMetadata_LayerName kLayerName{};
+  void set_layer_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_LayerName::kFieldId, data, size);
+  }
+  void set_layer_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_LayerName::kFieldId, chars.data, chars.size);
+  }
+  void set_layer_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_LayerName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PresentType =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      FrameTimelineEvent_PresentType,
+      FrameTimelineEvent_ActualSurfaceFrameStart>;
+
+  static constexpr FieldMetadata_PresentType kPresentType{};
+  void set_present_type(FrameTimelineEvent_PresentType value) {
+    static constexpr uint32_t field_id = FieldMetadata_PresentType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OnTimeFinish =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      FrameTimelineEvent_ActualSurfaceFrameStart>;
+
+  static constexpr FieldMetadata_OnTimeFinish kOnTimeFinish{};
+  void set_on_time_finish(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_OnTimeFinish::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_GpuComposition =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      FrameTimelineEvent_ActualSurfaceFrameStart>;
+
+  static constexpr FieldMetadata_GpuComposition kGpuComposition{};
+  void set_gpu_composition(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_GpuComposition::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_JankType =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      FrameTimelineEvent_ActualSurfaceFrameStart>;
+
+  static constexpr FieldMetadata_JankType kJankType{};
+  void set_jank_type(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_JankType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PredictionType =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      FrameTimelineEvent_PredictionType,
+      FrameTimelineEvent_ActualSurfaceFrameStart>;
+
+  static constexpr FieldMetadata_PredictionType kPredictionType{};
+  void set_prediction_type(FrameTimelineEvent_PredictionType value) {
+    static constexpr uint32_t field_id = FieldMetadata_PredictionType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IsBuffer =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      FrameTimelineEvent_ActualSurfaceFrameStart>;
+
+  static constexpr FieldMetadata_IsBuffer kIsBuffer{};
+  void set_is_buffer(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsBuffer::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_JankSeverityType =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      FrameTimelineEvent_JankSeverityType,
+      FrameTimelineEvent_ActualSurfaceFrameStart>;
+
+  static constexpr FieldMetadata_JankSeverityType kJankSeverityType{};
+  void set_jank_severity_type(FrameTimelineEvent_JankSeverityType value) {
+    static constexpr uint32_t field_id = FieldMetadata_JankSeverityType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PresentDelayMillis =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      FrameTimelineEvent_ActualSurfaceFrameStart>;
+
+  static constexpr FieldMetadata_PresentDelayMillis kPresentDelayMillis{};
+  void set_present_delay_millis(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_PresentDelayMillis::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_VsyncResyncedJitterMillis =
+    ::protozero::proto_utils::FieldMetadata<
+      14,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      FrameTimelineEvent_ActualSurfaceFrameStart>;
+
+  static constexpr FieldMetadata_VsyncResyncedJitterMillis kVsyncResyncedJitterMillis{};
+  void set_vsync_resynced_jitter_millis(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_VsyncResyncedJitterMillis::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_JankSeverityScore =
+    ::protozero::proto_utils::FieldMetadata<
+      15,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      FrameTimelineEvent_ActualSurfaceFrameStart>;
+
+  static constexpr FieldMetadata_JankSeverityScore kJankSeverityScore{};
+  void set_jank_severity_score(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_JankSeverityScore::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_JankTypeExperimental =
+    ::protozero::proto_utils::FieldMetadata<
+      16,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      FrameTimelineEvent_ActualSurfaceFrameStart>;
+
+  static constexpr FieldMetadata_JankTypeExperimental kJankTypeExperimental{};
+  void set_jank_type_experimental(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_JankTypeExperimental::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PresentTypeExperimental =
+    ::protozero::proto_utils::FieldMetadata<
+      17,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      FrameTimelineEvent_PresentType,
+      FrameTimelineEvent_ActualSurfaceFrameStart>;
+
+  static constexpr FieldMetadata_PresentTypeExperimental kPresentTypeExperimental{};
+  void set_present_type_experimental(FrameTimelineEvent_PresentType value) {
+    static constexpr uint32_t field_id = FieldMetadata_PresentTypeExperimental::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_JankDebugMetadata =
+    ::protozero::proto_utils::FieldMetadata<
+      18,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      FrameTimelineEvent_ActualSurfaceFrameStart>;
+
+  static constexpr FieldMetadata_JankDebugMetadata kJankDebugMetadata{};
+  void set_jank_debug_metadata(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_JankDebugMetadata::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class FrameTimelineEvent_ExpectedSurfaceFrameStart_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  FrameTimelineEvent_ExpectedSurfaceFrameStart_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FrameTimelineEvent_ExpectedSurfaceFrameStart_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FrameTimelineEvent_ExpectedSurfaceFrameStart_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cookie() const { return at<1>().valid(); }
+  int64_t cookie() const { return at<1>().as_int64(); }
+  bool has_token() const { return at<2>().valid(); }
+  int64_t token() const { return at<2>().as_int64(); }
+  bool has_display_frame_token() const { return at<3>().valid(); }
+  int64_t display_frame_token() const { return at<3>().as_int64(); }
+  bool has_pid() const { return at<4>().valid(); }
+  int32_t pid() const { return at<4>().as_int32(); }
+  bool has_layer_name() const { return at<5>().valid(); }
+  ::protozero::ConstChars layer_name() const { return at<5>().as_string(); }
+};
+
+class FrameTimelineEvent_ExpectedSurfaceFrameStart : public ::protozero::Message {
+ public:
+  using Decoder = FrameTimelineEvent_ExpectedSurfaceFrameStart_Decoder;
+  enum : int32_t {
+    kCookieFieldNumber = 1,
+    kTokenFieldNumber = 2,
+    kDisplayFrameTokenFieldNumber = 3,
+    kPidFieldNumber = 4,
+    kLayerNameFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent.ExpectedSurfaceFrameStart"; }
+
+
+  using FieldMetadata_Cookie =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      FrameTimelineEvent_ExpectedSurfaceFrameStart>;
+
+  static constexpr FieldMetadata_Cookie kCookie{};
+  void set_cookie(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cookie::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Token =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      FrameTimelineEvent_ExpectedSurfaceFrameStart>;
+
+  static constexpr FieldMetadata_Token kToken{};
+  void set_token(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Token::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DisplayFrameToken =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      FrameTimelineEvent_ExpectedSurfaceFrameStart>;
+
+  static constexpr FieldMetadata_DisplayFrameToken kDisplayFrameToken{};
+  void set_display_frame_token(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DisplayFrameToken::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Pid =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      FrameTimelineEvent_ExpectedSurfaceFrameStart>;
+
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_LayerName =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FrameTimelineEvent_ExpectedSurfaceFrameStart>;
+
+  static constexpr FieldMetadata_LayerName kLayerName{};
+  void set_layer_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_LayerName::kFieldId, data, size);
+  }
+  void set_layer_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_LayerName::kFieldId, chars.data, chars.size);
+  }
+  void set_layer_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_LayerName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/gpu_mem_event.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_GPU_MEM_EVENT_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_GPU_MEM_EVENT_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class GpuMemTotalEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  GpuMemTotalEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GpuMemTotalEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GpuMemTotalEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_gpu_id() const { return at<1>().valid(); }
+  uint32_t gpu_id() const { return at<1>().as_uint32(); }
+  bool has_pid() const { return at<2>().valid(); }
+  uint32_t pid() const { return at<2>().as_uint32(); }
+  bool has_size() const { return at<3>().valid(); }
+  uint64_t size() const { return at<3>().as_uint64(); }
+};
+
+class GpuMemTotalEvent : public ::protozero::Message {
+ public:
+  using Decoder = GpuMemTotalEvent_Decoder;
+  enum : int32_t {
+    kGpuIdFieldNumber = 1,
+    kPidFieldNumber = 2,
+    kSizeFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.GpuMemTotalEvent"; }
+
+
+  using FieldMetadata_GpuId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      GpuMemTotalEvent>;
+
+  static constexpr FieldMetadata_GpuId kGpuId{};
+  void set_gpu_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GpuId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Pid =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      GpuMemTotalEvent>;
+
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Size =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      GpuMemTotalEvent>;
+
+  static constexpr FieldMetadata_Size kSize{};
+  void set_size(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/graphics_frame_event.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_GRAPHICS_FRAME_EVENT_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_GRAPHICS_FRAME_EVENT_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class GraphicsFrameEvent_BufferEvent;
+namespace perfetto_pbzero_enum_GraphicsFrameEvent {
+enum BufferEventType : int32_t;
+}  // namespace perfetto_pbzero_enum_GraphicsFrameEvent
+using GraphicsFrameEvent_BufferEventType = perfetto_pbzero_enum_GraphicsFrameEvent::BufferEventType;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_GraphicsFrameEvent {
+enum BufferEventType : int32_t {
+  UNSPECIFIED = 0,
+  DEQUEUE = 1,
+  QUEUE = 2,
+  POST = 3,
+  ACQUIRE_FENCE = 4,
+  LATCH = 5,
+  HWC_COMPOSITION_QUEUED = 6,
+  FALLBACK_COMPOSITION = 7,
+  PRESENT_FENCE = 8,
+  RELEASE_FENCE = 9,
+  MODIFY = 10,
+  DETACH = 11,
+  ATTACH = 12,
+  CANCEL = 13,
+};
+} // namespace perfetto_pbzero_enum_GraphicsFrameEvent
+using GraphicsFrameEvent_BufferEventType = perfetto_pbzero_enum_GraphicsFrameEvent::BufferEventType;
+
+
+constexpr GraphicsFrameEvent_BufferEventType GraphicsFrameEvent_BufferEventType_MIN = GraphicsFrameEvent_BufferEventType::UNSPECIFIED;
+constexpr GraphicsFrameEvent_BufferEventType GraphicsFrameEvent_BufferEventType_MAX = GraphicsFrameEvent_BufferEventType::CANCEL;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* GraphicsFrameEvent_BufferEventType_Name(::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::UNSPECIFIED:
+    return "UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::DEQUEUE:
+    return "DEQUEUE";
+
+  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::QUEUE:
+    return "QUEUE";
+
+  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::POST:
+    return "POST";
+
+  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::ACQUIRE_FENCE:
+    return "ACQUIRE_FENCE";
+
+  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::LATCH:
+    return "LATCH";
+
+  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::HWC_COMPOSITION_QUEUED:
+    return "HWC_COMPOSITION_QUEUED";
+
+  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::FALLBACK_COMPOSITION:
+    return "FALLBACK_COMPOSITION";
+
+  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::PRESENT_FENCE:
+    return "PRESENT_FENCE";
+
+  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::RELEASE_FENCE:
+    return "RELEASE_FENCE";
+
+  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::MODIFY:
+    return "MODIFY";
+
+  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::DETACH:
+    return "DETACH";
+
+  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::ATTACH:
+    return "ATTACH";
+
+  case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::CANCEL:
+    return "CANCEL";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class GraphicsFrameEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  GraphicsFrameEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GraphicsFrameEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GraphicsFrameEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_buffer_event() const { return at<1>().valid(); }
+  ::protozero::ConstBytes buffer_event() const { return at<1>().as_bytes(); }
+};
+
+class GraphicsFrameEvent : public ::protozero::Message {
+ public:
+  using Decoder = GraphicsFrameEvent_Decoder;
+  enum : int32_t {
+    kBufferEventFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.GraphicsFrameEvent"; }
+
+  using BufferEvent = ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEvent;
+
+  using BufferEventType = ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType;
+  static inline const char* BufferEventType_Name(BufferEventType value) {
+    return ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType_Name(value);
+  }
+  static inline const BufferEventType UNSPECIFIED = BufferEventType::UNSPECIFIED;
+  static inline const BufferEventType DEQUEUE = BufferEventType::DEQUEUE;
+  static inline const BufferEventType QUEUE = BufferEventType::QUEUE;
+  static inline const BufferEventType POST = BufferEventType::POST;
+  static inline const BufferEventType ACQUIRE_FENCE = BufferEventType::ACQUIRE_FENCE;
+  static inline const BufferEventType LATCH = BufferEventType::LATCH;
+  static inline const BufferEventType HWC_COMPOSITION_QUEUED = BufferEventType::HWC_COMPOSITION_QUEUED;
+  static inline const BufferEventType FALLBACK_COMPOSITION = BufferEventType::FALLBACK_COMPOSITION;
+  static inline const BufferEventType PRESENT_FENCE = BufferEventType::PRESENT_FENCE;
+  static inline const BufferEventType RELEASE_FENCE = BufferEventType::RELEASE_FENCE;
+  static inline const BufferEventType MODIFY = BufferEventType::MODIFY;
+  static inline const BufferEventType DETACH = BufferEventType::DETACH;
+  static inline const BufferEventType ATTACH = BufferEventType::ATTACH;
+  static inline const BufferEventType CANCEL = BufferEventType::CANCEL;
+
+  using FieldMetadata_BufferEvent =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      GraphicsFrameEvent_BufferEvent,
+      GraphicsFrameEvent>;
+
+  static constexpr FieldMetadata_BufferEvent kBufferEvent{};
+  template <typename T = GraphicsFrameEvent_BufferEvent> T* set_buffer_event() {
+    return BeginNestedMessage<T>(1);
+  }
+
+};
+
+class GraphicsFrameEvent_BufferEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  GraphicsFrameEvent_BufferEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GraphicsFrameEvent_BufferEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GraphicsFrameEvent_BufferEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_frame_number() const { return at<1>().valid(); }
+  uint32_t frame_number() const { return at<1>().as_uint32(); }
+  bool has_type() const { return at<2>().valid(); }
+  int32_t type() const { return at<2>().as_int32(); }
+  bool has_layer_name() const { return at<3>().valid(); }
+  ::protozero::ConstChars layer_name() const { return at<3>().as_string(); }
+  bool has_duration_ns() const { return at<4>().valid(); }
+  uint64_t duration_ns() const { return at<4>().as_uint64(); }
+  bool has_buffer_id() const { return at<5>().valid(); }
+  uint32_t buffer_id() const { return at<5>().as_uint32(); }
+};
+
+class GraphicsFrameEvent_BufferEvent : public ::protozero::Message {
+ public:
+  using Decoder = GraphicsFrameEvent_BufferEvent_Decoder;
+  enum : int32_t {
+    kFrameNumberFieldNumber = 1,
+    kTypeFieldNumber = 2,
+    kLayerNameFieldNumber = 3,
+    kDurationNsFieldNumber = 4,
+    kBufferIdFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.GraphicsFrameEvent.BufferEvent"; }
+
+
+  using FieldMetadata_FrameNumber =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      GraphicsFrameEvent_BufferEvent>;
+
+  static constexpr FieldMetadata_FrameNumber kFrameNumber{};
+  void set_frame_number(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FrameNumber::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Type =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      GraphicsFrameEvent_BufferEventType,
+      GraphicsFrameEvent_BufferEvent>;
+
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(GraphicsFrameEvent_BufferEventType value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_LayerName =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      GraphicsFrameEvent_BufferEvent>;
+
+  static constexpr FieldMetadata_LayerName kLayerName{};
+  void set_layer_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_LayerName::kFieldId, data, size);
+  }
+  void set_layer_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_LayerName::kFieldId, chars.data, chars.size);
+  }
+  void set_layer_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_LayerName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DurationNs =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      GraphicsFrameEvent_BufferEvent>;
+
+  static constexpr FieldMetadata_DurationNs kDurationNs{};
+  void set_duration_ns(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DurationNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BufferId =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      GraphicsFrameEvent_BufferEvent>;
+
+  static constexpr FieldMetadata_BufferId kBufferId{};
+  void set_buffer_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BufferId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/initial_display_state.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_INITIAL_DISPLAY_STATE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_INITIAL_DISPLAY_STATE_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class InitialDisplayState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  InitialDisplayState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit InitialDisplayState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit InitialDisplayState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_display_state() const { return at<1>().valid(); }
+  int32_t display_state() const { return at<1>().as_int32(); }
+  bool has_brightness() const { return at<2>().valid(); }
+  double brightness() const { return at<2>().as_double(); }
+};
+
+class InitialDisplayState : public ::protozero::Message {
+ public:
+  using Decoder = InitialDisplayState_Decoder;
+  enum : int32_t {
+    kDisplayStateFieldNumber = 1,
+    kBrightnessFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.InitialDisplayState"; }
+
+
+  using FieldMetadata_DisplayState =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      InitialDisplayState>;
+
+  static constexpr FieldMetadata_DisplayState kDisplayState{};
+  void set_display_state(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DisplayState::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Brightness =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kDouble,
+      double,
+      InitialDisplayState>;
+
+  static constexpr FieldMetadata_Brightness kBrightness{};
+  void set_brightness(double value) {
+    static constexpr uint32_t field_id = FieldMetadata_Brightness::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/kernel_wakelock_data.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_KERNEL_WAKELOCK_DATA_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_KERNEL_WAKELOCK_DATA_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class KernelWakelockData_Wakelock;
+namespace perfetto_pbzero_enum_KernelWakelockData_Wakelock {
+enum Type : int32_t;
+}  // namespace perfetto_pbzero_enum_KernelWakelockData_Wakelock
+using KernelWakelockData_Wakelock_Type = perfetto_pbzero_enum_KernelWakelockData_Wakelock::Type;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_KernelWakelockData_Wakelock {
+enum Type : int32_t {
+  WAKELOCK_TYPE_UNKNOWN = 0,
+  WAKELOCK_TYPE_KERNEL = 1,
+  WAKELOCK_TYPE_NATIVE = 2,
+};
+} // namespace perfetto_pbzero_enum_KernelWakelockData_Wakelock
+using KernelWakelockData_Wakelock_Type = perfetto_pbzero_enum_KernelWakelockData_Wakelock::Type;
+
+
+constexpr KernelWakelockData_Wakelock_Type KernelWakelockData_Wakelock_Type_MIN = KernelWakelockData_Wakelock_Type::WAKELOCK_TYPE_UNKNOWN;
+constexpr KernelWakelockData_Wakelock_Type KernelWakelockData_Wakelock_Type_MAX = KernelWakelockData_Wakelock_Type::WAKELOCK_TYPE_NATIVE;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* KernelWakelockData_Wakelock_Type_Name(::perfetto::protos::pbzero::KernelWakelockData_Wakelock_Type value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::KernelWakelockData_Wakelock_Type::WAKELOCK_TYPE_UNKNOWN:
+    return "WAKELOCK_TYPE_UNKNOWN";
+
+  case ::perfetto::protos::pbzero::KernelWakelockData_Wakelock_Type::WAKELOCK_TYPE_KERNEL:
+    return "WAKELOCK_TYPE_KERNEL";
+
+  case ::perfetto::protos::pbzero::KernelWakelockData_Wakelock_Type::WAKELOCK_TYPE_NATIVE:
+    return "WAKELOCK_TYPE_NATIVE";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class KernelWakelockData_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  KernelWakelockData_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KernelWakelockData_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KernelWakelockData_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_wakelock() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> wakelock() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  bool has_wakelock_id() const { return at<2>().valid(); }
+  ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t> wakelock_id(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t>(2, parse_error_ptr); }
+  bool has_time_held_millis() const { return at<3>().valid(); }
+  ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> time_held_millis(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(3, parse_error_ptr); }
+  bool has_error_flags() const { return at<4>().valid(); }
+  uint64_t error_flags() const { return at<4>().as_uint64(); }
+};
+
+class KernelWakelockData : public ::protozero::Message {
+ public:
+  using Decoder = KernelWakelockData_Decoder;
+  enum : int32_t {
+    kWakelockFieldNumber = 1,
+    kWakelockIdFieldNumber = 2,
+    kTimeHeldMillisFieldNumber = 3,
+    kErrorFlagsFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KernelWakelockData"; }
+
+  using Wakelock = ::perfetto::protos::pbzero::KernelWakelockData_Wakelock;
+
+  using FieldMetadata_Wakelock =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      KernelWakelockData_Wakelock,
+      KernelWakelockData>;
+
+  static constexpr FieldMetadata_Wakelock kWakelock{};
+  template <typename T = KernelWakelockData_Wakelock> T* add_wakelock() {
+    return BeginNestedMessage<T>(1);
+  }
+
+
+  using FieldMetadata_WakelockId =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KernelWakelockData>;
+
+  static constexpr FieldMetadata_WakelockId kWakelockId{};
+  void set_wakelock_id(const ::protozero::PackedVarInt& packed_buffer) {
+    AppendBytes(FieldMetadata_WakelockId::kFieldId, packed_buffer.data(),
+                packed_buffer.size());
+  }
+
+  using FieldMetadata_TimeHeldMillis =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KernelWakelockData>;
+
+  static constexpr FieldMetadata_TimeHeldMillis kTimeHeldMillis{};
+  void set_time_held_millis(const ::protozero::PackedVarInt& packed_buffer) {
+    AppendBytes(FieldMetadata_TimeHeldMillis::kFieldId, packed_buffer.data(),
+                packed_buffer.size());
+  }
+
+  using FieldMetadata_ErrorFlags =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KernelWakelockData>;
+
+  static constexpr FieldMetadata_ErrorFlags kErrorFlags{};
+  void set_error_flags(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ErrorFlags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class KernelWakelockData_Wakelock_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  KernelWakelockData_Wakelock_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KernelWakelockData_Wakelock_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KernelWakelockData_Wakelock_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_wakelock_id() const { return at<1>().valid(); }
+  uint32_t wakelock_id() const { return at<1>().as_uint32(); }
+  bool has_wakelock_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars wakelock_name() const { return at<2>().as_string(); }
+  bool has_wakelock_type() const { return at<3>().valid(); }
+  int32_t wakelock_type() const { return at<3>().as_int32(); }
+};
+
+class KernelWakelockData_Wakelock : public ::protozero::Message {
+ public:
+  using Decoder = KernelWakelockData_Wakelock_Decoder;
+  enum : int32_t {
+    kWakelockIdFieldNumber = 1,
+    kWakelockNameFieldNumber = 2,
+    kWakelockTypeFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KernelWakelockData.Wakelock"; }
+
+
+  using Type = ::perfetto::protos::pbzero::KernelWakelockData_Wakelock_Type;
+  static inline const char* Type_Name(Type value) {
+    return ::perfetto::protos::pbzero::KernelWakelockData_Wakelock_Type_Name(value);
+  }
+  static inline const Type WAKELOCK_TYPE_UNKNOWN = Type::WAKELOCK_TYPE_UNKNOWN;
+  static inline const Type WAKELOCK_TYPE_KERNEL = Type::WAKELOCK_TYPE_KERNEL;
+  static inline const Type WAKELOCK_TYPE_NATIVE = Type::WAKELOCK_TYPE_NATIVE;
+
+  using FieldMetadata_WakelockId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KernelWakelockData_Wakelock>;
+
+  static constexpr FieldMetadata_WakelockId kWakelockId{};
+  void set_wakelock_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_WakelockId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_WakelockName =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      KernelWakelockData_Wakelock>;
+
+  static constexpr FieldMetadata_WakelockName kWakelockName{};
+  void set_wakelock_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_WakelockName::kFieldId, data, size);
+  }
+  void set_wakelock_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_WakelockName::kFieldId, chars.data, chars.size);
+  }
+  void set_wakelock_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_WakelockName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_WakelockType =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      KernelWakelockData_Wakelock_Type,
+      KernelWakelockData_Wakelock>;
+
+  static constexpr FieldMetadata_WakelockType kWakelockType{};
+  void set_wakelock_type(KernelWakelockData_Wakelock_Type value) {
+    static constexpr uint32_t field_id = FieldMetadata_WakelockType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/network_trace.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_NETWORK_TRACE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_NETWORK_TRACE_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class NetworkPacketEvent;
+enum TrafficDirection : int32_t;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+enum TrafficDirection : int32_t {
+  DIR_UNSPECIFIED = 0,
+  DIR_INGRESS = 1,
+  DIR_EGRESS = 2,
+};
+
+constexpr TrafficDirection TrafficDirection_MIN = TrafficDirection::DIR_UNSPECIFIED;
+constexpr TrafficDirection TrafficDirection_MAX = TrafficDirection::DIR_EGRESS;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* TrafficDirection_Name(::perfetto::protos::pbzero::TrafficDirection value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::TrafficDirection::DIR_UNSPECIFIED:
+    return "DIR_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::TrafficDirection::DIR_INGRESS:
+    return "DIR_INGRESS";
+
+  case ::perfetto::protos::pbzero::TrafficDirection::DIR_EGRESS:
+    return "DIR_EGRESS";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class NetworkPacketContext_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  NetworkPacketContext_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit NetworkPacketContext_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit NetworkPacketContext_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_iid() const { return at<1>().valid(); }
+  uint64_t iid() const { return at<1>().as_uint64(); }
+  bool has_ctx() const { return at<2>().valid(); }
+  ::protozero::ConstBytes ctx() const { return at<2>().as_bytes(); }
+};
+
+class NetworkPacketContext : public ::protozero::Message {
+ public:
+  using Decoder = NetworkPacketContext_Decoder;
+  enum : int32_t {
+    kIidFieldNumber = 1,
+    kCtxFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.NetworkPacketContext"; }
+
+
+  using FieldMetadata_Iid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      NetworkPacketContext>;
+
+  static constexpr FieldMetadata_Iid kIid{};
+  void set_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ctx =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      NetworkPacketEvent,
+      NetworkPacketContext>;
+
+  static constexpr FieldMetadata_Ctx kCtx{};
+  template <typename T = NetworkPacketEvent> T* set_ctx() {
+    return BeginNestedMessage<T>(2);
+  }
+
+};
+
+class NetworkPacketBundle_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
+ public:
+  NetworkPacketBundle_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit NetworkPacketBundle_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit NetworkPacketBundle_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_iid() const { return at<1>().valid(); }
+  uint64_t iid() const { return at<1>().as_uint64(); }
+  bool has_ctx() const { return at<2>().valid(); }
+  ::protozero::ConstBytes ctx() const { return at<2>().as_bytes(); }
+  bool has_packet_timestamps() const { return at<3>().valid(); }
+  ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> packet_timestamps(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(3, parse_error_ptr); }
+  bool has_packet_lengths() const { return at<4>().valid(); }
+  ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t> packet_lengths(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t>(4, parse_error_ptr); }
+  bool has_total_packets() const { return at<5>().valid(); }
+  uint32_t total_packets() const { return at<5>().as_uint32(); }
+  bool has_total_duration() const { return at<6>().valid(); }
+  uint64_t total_duration() const { return at<6>().as_uint64(); }
+  bool has_total_length() const { return at<7>().valid(); }
+  uint64_t total_length() const { return at<7>().as_uint64(); }
+};
+
+class NetworkPacketBundle : public ::protozero::Message {
+ public:
+  using Decoder = NetworkPacketBundle_Decoder;
+  enum : int32_t {
+    kIidFieldNumber = 1,
+    kCtxFieldNumber = 2,
+    kPacketTimestampsFieldNumber = 3,
+    kPacketLengthsFieldNumber = 4,
+    kTotalPacketsFieldNumber = 5,
+    kTotalDurationFieldNumber = 6,
+    kTotalLengthFieldNumber = 7,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.NetworkPacketBundle"; }
+
+
+  using FieldMetadata_Iid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      NetworkPacketBundle>;
+
+  static constexpr FieldMetadata_Iid kIid{};
+  void set_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ctx =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      NetworkPacketEvent,
+      NetworkPacketBundle>;
+
+  static constexpr FieldMetadata_Ctx kCtx{};
+  template <typename T = NetworkPacketEvent> T* set_ctx() {
+    return BeginNestedMessage<T>(2);
+  }
+
+
+  using FieldMetadata_PacketTimestamps =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      NetworkPacketBundle>;
+
+  static constexpr FieldMetadata_PacketTimestamps kPacketTimestamps{};
+  void set_packet_timestamps(const ::protozero::PackedVarInt& packed_buffer) {
+    AppendBytes(FieldMetadata_PacketTimestamps::kFieldId, packed_buffer.data(),
+                packed_buffer.size());
+  }
+
+  using FieldMetadata_PacketLengths =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      NetworkPacketBundle>;
+
+  static constexpr FieldMetadata_PacketLengths kPacketLengths{};
+  void set_packet_lengths(const ::protozero::PackedVarInt& packed_buffer) {
+    AppendBytes(FieldMetadata_PacketLengths::kFieldId, packed_buffer.data(),
+                packed_buffer.size());
+  }
+
+  using FieldMetadata_TotalPackets =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      NetworkPacketBundle>;
+
+  static constexpr FieldMetadata_TotalPackets kTotalPackets{};
+  void set_total_packets(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TotalPackets::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TotalDuration =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      NetworkPacketBundle>;
+
+  static constexpr FieldMetadata_TotalDuration kTotalDuration{};
+  void set_total_duration(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TotalDuration::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TotalLength =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      NetworkPacketBundle>;
+
+  static constexpr FieldMetadata_TotalLength kTotalLength{};
+  void set_total_length(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TotalLength::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class NetworkPacketEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11> {
+ public:
+  NetworkPacketEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit NetworkPacketEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit NetworkPacketEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_direction() const { return at<1>().valid(); }
+  int32_t direction() const { return at<1>().as_int32(); }
+  bool has_network_interface() const { return at<2>().valid(); }
+  ::protozero::ConstChars network_interface() const { return at<2>().as_string(); }
+  bool has_length() const { return at<3>().valid(); }
+  uint32_t length() const { return at<3>().as_uint32(); }
+  bool has_uid() const { return at<4>().valid(); }
+  uint32_t uid() const { return at<4>().as_uint32(); }
+  bool has_tag() const { return at<5>().valid(); }
+  uint32_t tag() const { return at<5>().as_uint32(); }
+  bool has_ip_proto() const { return at<6>().valid(); }
+  uint32_t ip_proto() const { return at<6>().as_uint32(); }
+  bool has_tcp_flags() const { return at<7>().valid(); }
+  uint32_t tcp_flags() const { return at<7>().as_uint32(); }
+  bool has_local_port() const { return at<8>().valid(); }
+  uint32_t local_port() const { return at<8>().as_uint32(); }
+  bool has_remote_port() const { return at<9>().valid(); }
+  uint32_t remote_port() const { return at<9>().as_uint32(); }
+  bool has_icmp_type() const { return at<10>().valid(); }
+  uint32_t icmp_type() const { return at<10>().as_uint32(); }
+  bool has_icmp_code() const { return at<11>().valid(); }
+  uint32_t icmp_code() const { return at<11>().as_uint32(); }
+};
+
+class NetworkPacketEvent : public ::protozero::Message {
+ public:
+  using Decoder = NetworkPacketEvent_Decoder;
+  enum : int32_t {
+    kDirectionFieldNumber = 1,
+    kNetworkInterfaceFieldNumber = 2,
+    kLengthFieldNumber = 3,
+    kUidFieldNumber = 4,
+    kTagFieldNumber = 5,
+    kIpProtoFieldNumber = 6,
+    kTcpFlagsFieldNumber = 7,
+    kLocalPortFieldNumber = 8,
+    kRemotePortFieldNumber = 9,
+    kIcmpTypeFieldNumber = 10,
+    kIcmpCodeFieldNumber = 11,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.NetworkPacketEvent"; }
+
+
+  using FieldMetadata_Direction =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      TrafficDirection,
+      NetworkPacketEvent>;
+
+  static constexpr FieldMetadata_Direction kDirection{};
+  void set_direction(TrafficDirection value) {
+    static constexpr uint32_t field_id = FieldMetadata_Direction::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NetworkInterface =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      NetworkPacketEvent>;
+
+  static constexpr FieldMetadata_NetworkInterface kNetworkInterface{};
+  void set_network_interface(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_NetworkInterface::kFieldId, data, size);
+  }
+  void set_network_interface(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_NetworkInterface::kFieldId, chars.data, chars.size);
+  }
+  void set_network_interface(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_NetworkInterface::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Length =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      NetworkPacketEvent>;
+
+  static constexpr FieldMetadata_Length kLength{};
+  void set_length(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Length::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Uid =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      NetworkPacketEvent>;
+
+  static constexpr FieldMetadata_Uid kUid{};
+  void set_uid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Tag =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      NetworkPacketEvent>;
+
+  static constexpr FieldMetadata_Tag kTag{};
+  void set_tag(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tag::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IpProto =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      NetworkPacketEvent>;
+
+  static constexpr FieldMetadata_IpProto kIpProto{};
+  void set_ip_proto(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IpProto::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TcpFlags =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      NetworkPacketEvent>;
+
+  static constexpr FieldMetadata_TcpFlags kTcpFlags{};
+  void set_tcp_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TcpFlags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_LocalPort =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      NetworkPacketEvent>;
+
+  static constexpr FieldMetadata_LocalPort kLocalPort{};
+  void set_local_port(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LocalPort::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_RemotePort =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      NetworkPacketEvent>;
+
+  static constexpr FieldMetadata_RemotePort kRemotePort{};
+  void set_remote_port(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RemotePort::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IcmpType =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      NetworkPacketEvent>;
+
+  static constexpr FieldMetadata_IcmpType kIcmpType{};
+  void set_icmp_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IcmpType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IcmpCode =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      NetworkPacketEvent>;
+
+  static constexpr FieldMetadata_IcmpCode kIcmpCode{};
+  void set_icmp_code(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IcmpCode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/packages_list.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_PACKAGES_LIST_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_PACKAGES_LIST_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class PackagesList_PackageInfo;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class PackagesList_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  PackagesList_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PackagesList_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PackagesList_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_packages() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> packages() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  bool has_parse_error() const { return at<2>().valid(); }
+  bool parse_error() const { return at<2>().as_bool(); }
+  bool has_read_error() const { return at<3>().valid(); }
+  bool read_error() const { return at<3>().as_bool(); }
+};
+
+class PackagesList : public ::protozero::Message {
+ public:
+  using Decoder = PackagesList_Decoder;
+  enum : int32_t {
+    kPackagesFieldNumber = 1,
+    kParseErrorFieldNumber = 2,
+    kReadErrorFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.PackagesList"; }
+
+  using PackageInfo = ::perfetto::protos::pbzero::PackagesList_PackageInfo;
+
+  using FieldMetadata_Packages =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PackagesList_PackageInfo,
+      PackagesList>;
+
+  static constexpr FieldMetadata_Packages kPackages{};
+  template <typename T = PackagesList_PackageInfo> T* add_packages() {
+    return BeginNestedMessage<T>(1);
+  }
+
+
+  using FieldMetadata_ParseError =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      PackagesList>;
+
+  static constexpr FieldMetadata_ParseError kParseError{};
+  void set_parse_error(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ParseError::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ReadError =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      PackagesList>;
+
+  static constexpr FieldMetadata_ReadError kReadError{};
+  void set_read_error(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReadError::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class PackagesList_PackageInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  PackagesList_PackageInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PackagesList_PackageInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PackagesList_PackageInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_uid() const { return at<2>().valid(); }
+  uint64_t uid() const { return at<2>().as_uint64(); }
+  bool has_debuggable() const { return at<3>().valid(); }
+  bool debuggable() const { return at<3>().as_bool(); }
+  bool has_profileable_from_shell() const { return at<4>().valid(); }
+  bool profileable_from_shell() const { return at<4>().as_bool(); }
+  bool has_version_code() const { return at<5>().valid(); }
+  int64_t version_code() const { return at<5>().as_int64(); }
+};
+
+class PackagesList_PackageInfo : public ::protozero::Message {
+ public:
+  using Decoder = PackagesList_PackageInfo_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kUidFieldNumber = 2,
+    kDebuggableFieldNumber = 3,
+    kProfileableFromShellFieldNumber = 4,
+    kVersionCodeFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.PackagesList.PackageInfo"; }
+
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      PackagesList_PackageInfo>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Uid =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      PackagesList_PackageInfo>;
+
+  static constexpr FieldMetadata_Uid kUid{};
+  void set_uid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Debuggable =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      PackagesList_PackageInfo>;
+
+  static constexpr FieldMetadata_Debuggable kDebuggable{};
+  void set_debuggable(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_Debuggable::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ProfileableFromShell =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      PackagesList_PackageInfo>;
+
+  static constexpr FieldMetadata_ProfileableFromShell kProfileableFromShell{};
+  void set_profileable_from_shell(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProfileableFromShell::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_VersionCode =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      PackagesList_PackageInfo>;
+
+  static constexpr FieldMetadata_VersionCode kVersionCode{};
+  void set_version_code(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VersionCode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/pixel_modem_events.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_PIXEL_MODEM_EVENTS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_PIXEL_MODEM_EVENTS_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class PixelModemTokenDatabase_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  PixelModemTokenDatabase_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PixelModemTokenDatabase_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PixelModemTokenDatabase_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_database() const { return at<1>().valid(); }
+  ::protozero::ConstBytes database() const { return at<1>().as_bytes(); }
+};
+
+class PixelModemTokenDatabase : public ::protozero::Message {
+ public:
+  using Decoder = PixelModemTokenDatabase_Decoder;
+  enum : int32_t {
+    kDatabaseFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.PixelModemTokenDatabase"; }
+
+
+  using FieldMetadata_Database =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      PixelModemTokenDatabase>;
+
+  static constexpr FieldMetadata_Database kDatabase{};
+  void set_database(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_Database::kFieldId, data, size);
+  }
+  void set_database(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_Database::kFieldId, bytes.data, bytes.size);
+  }
+  void set_database(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Database::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class PixelModemEvents_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  PixelModemEvents_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PixelModemEvents_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PixelModemEvents_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_events() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> events() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  bool has_event_time_nanos() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint64_t> event_time_nanos() const { return GetRepeated<uint64_t>(2); }
+};
+
+class PixelModemEvents : public ::protozero::Message {
+ public:
+  using Decoder = PixelModemEvents_Decoder;
+  enum : int32_t {
+    kEventsFieldNumber = 1,
+    kEventTimeNanosFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.PixelModemEvents"; }
+
+
+  using FieldMetadata_Events =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      PixelModemEvents>;
+
+  static constexpr FieldMetadata_Events kEvents{};
+  void add_events(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_Events::kFieldId, data, size);
+  }
+  void add_events(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_Events::kFieldId, bytes.data, bytes.size);
+  }
+  void add_events(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Events::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_EventTimeNanos =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      PixelModemEvents>;
+
+  static constexpr FieldMetadata_EventTimeNanos kEventTimeNanos{};
+  void add_event_time_nanos(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EventTimeNanos::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/android/user_list.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_USER_LIST_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_USER_LIST_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class AndroidUserList_UserInfo;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class AndroidUserList_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  AndroidUserList_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidUserList_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidUserList_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_users() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> users() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  bool has_error() const { return at<2>().valid(); }
+  int32_t error() const { return at<2>().as_int32(); }
+};
+
+class AndroidUserList : public ::protozero::Message {
+ public:
+  using Decoder = AndroidUserList_Decoder;
+  enum : int32_t {
+    kUsersFieldNumber = 1,
+    kErrorFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidUserList"; }
+
+  using UserInfo = ::perfetto::protos::pbzero::AndroidUserList_UserInfo;
+
+  using FieldMetadata_Users =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AndroidUserList_UserInfo,
+      AndroidUserList>;
+
+  static constexpr FieldMetadata_Users kUsers{};
+  template <typename T = AndroidUserList_UserInfo> T* add_users() {
+    return BeginNestedMessage<T>(1);
+  }
+
+
+  using FieldMetadata_Error =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      AndroidUserList>;
+
+  static constexpr FieldMetadata_Error kError{};
+  void set_error(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class AndroidUserList_UserInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  AndroidUserList_UserInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidUserList_UserInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidUserList_UserInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_type() const { return at<1>().valid(); }
+  ::protozero::ConstChars type() const { return at<1>().as_string(); }
+  bool has_uid() const { return at<2>().valid(); }
+  int32_t uid() const { return at<2>().as_int32(); }
+};
+
+class AndroidUserList_UserInfo : public ::protozero::Message {
+ public:
+  using Decoder = AndroidUserList_UserInfo_Decoder;
+  enum : int32_t {
+    kTypeFieldNumber = 1,
+    kUidFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidUserList.UserInfo"; }
+
+
+  using FieldMetadata_Type =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      AndroidUserList_UserInfo>;
+
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Type::kFieldId, data, size);
+  }
+  void set_type(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Type::kFieldId, chars.data, chars.size);
+  }
+  void set_type(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Uid =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      AndroidUserList_UserInfo>;
+
+  static constexpr FieldMetadata_Uid kUid{};
+  void set_uid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/chrome/chrome_benchmark_metadata.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CHROME_CHROME_BENCHMARK_METADATA_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CHROME_CHROME_BENCHMARK_METADATA_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class ChromeBenchmarkMetadata_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9> {
+ public:
+  ChromeBenchmarkMetadata_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeBenchmarkMetadata_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeBenchmarkMetadata_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_benchmark_start_time_us() const { return at<1>().valid(); }
+  int64_t benchmark_start_time_us() const { return at<1>().as_int64(); }
+  bool has_story_run_time_us() const { return at<2>().valid(); }
+  int64_t story_run_time_us() const { return at<2>().as_int64(); }
+  bool has_benchmark_name() const { return at<3>().valid(); }
+  ::protozero::ConstChars benchmark_name() const { return at<3>().as_string(); }
+  bool has_benchmark_description() const { return at<4>().valid(); }
+  ::protozero::ConstChars benchmark_description() const { return at<4>().as_string(); }
+  bool has_label() const { return at<5>().valid(); }
+  ::protozero::ConstChars label() const { return at<5>().as_string(); }
+  bool has_story_name() const { return at<6>().valid(); }
+  ::protozero::ConstChars story_name() const { return at<6>().as_string(); }
+  bool has_story_tags() const { return at<7>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> story_tags() const { return GetRepeated<::protozero::ConstChars>(7); }
+  bool has_story_run_index() const { return at<8>().valid(); }
+  int32_t story_run_index() const { return at<8>().as_int32(); }
+  bool has_had_failures() const { return at<9>().valid(); }
+  bool had_failures() const { return at<9>().as_bool(); }
+};
+
+class ChromeBenchmarkMetadata : public ::protozero::Message {
+ public:
+  using Decoder = ChromeBenchmarkMetadata_Decoder;
+  enum : int32_t {
+    kBenchmarkStartTimeUsFieldNumber = 1,
+    kStoryRunTimeUsFieldNumber = 2,
+    kBenchmarkNameFieldNumber = 3,
+    kBenchmarkDescriptionFieldNumber = 4,
+    kLabelFieldNumber = 5,
+    kStoryNameFieldNumber = 6,
+    kStoryTagsFieldNumber = 7,
+    kStoryRunIndexFieldNumber = 8,
+    kHadFailuresFieldNumber = 9,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeBenchmarkMetadata"; }
+
+
+  using FieldMetadata_BenchmarkStartTimeUs =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ChromeBenchmarkMetadata>;
+
+  static constexpr FieldMetadata_BenchmarkStartTimeUs kBenchmarkStartTimeUs{};
+  void set_benchmark_start_time_us(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BenchmarkStartTimeUs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StoryRunTimeUs =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ChromeBenchmarkMetadata>;
+
+  static constexpr FieldMetadata_StoryRunTimeUs kStoryRunTimeUs{};
+  void set_story_run_time_us(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StoryRunTimeUs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BenchmarkName =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeBenchmarkMetadata>;
+
+  static constexpr FieldMetadata_BenchmarkName kBenchmarkName{};
+  void set_benchmark_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_BenchmarkName::kFieldId, data, size);
+  }
+  void set_benchmark_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_BenchmarkName::kFieldId, chars.data, chars.size);
+  }
+  void set_benchmark_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_BenchmarkName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BenchmarkDescription =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeBenchmarkMetadata>;
+
+  static constexpr FieldMetadata_BenchmarkDescription kBenchmarkDescription{};
+  void set_benchmark_description(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_BenchmarkDescription::kFieldId, data, size);
+  }
+  void set_benchmark_description(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_BenchmarkDescription::kFieldId, chars.data, chars.size);
+  }
+  void set_benchmark_description(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_BenchmarkDescription::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Label =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeBenchmarkMetadata>;
+
+  static constexpr FieldMetadata_Label kLabel{};
+  void set_label(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Label::kFieldId, data, size);
+  }
+  void set_label(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Label::kFieldId, chars.data, chars.size);
+  }
+  void set_label(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Label::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StoryName =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeBenchmarkMetadata>;
+
+  static constexpr FieldMetadata_StoryName kStoryName{};
+  void set_story_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_StoryName::kFieldId, data, size);
+  }
+  void set_story_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_StoryName::kFieldId, chars.data, chars.size);
+  }
+  void set_story_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_StoryName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StoryTags =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeBenchmarkMetadata>;
+
+  static constexpr FieldMetadata_StoryTags kStoryTags{};
+  void add_story_tags(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_StoryTags::kFieldId, data, size);
+  }
+  void add_story_tags(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_StoryTags::kFieldId, chars.data, chars.size);
+  }
+  void add_story_tags(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_StoryTags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StoryRunIndex =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ChromeBenchmarkMetadata>;
+
+  static constexpr FieldMetadata_StoryRunIndex kStoryRunIndex{};
+  void set_story_run_index(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StoryRunIndex::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_HadFailures =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeBenchmarkMetadata>;
+
+  static constexpr FieldMetadata_HadFailures kHadFailures{};
+  void set_had_failures(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_HadFailures::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/chrome/chrome_metadata.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CHROME_CHROME_METADATA_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CHROME_CHROME_METADATA_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class BackgroundTracingMetadata;
+class BackgroundTracingMetadata_TriggerRule;
+class BackgroundTracingMetadata_TriggerRule_HistogramRule;
+class BackgroundTracingMetadata_TriggerRule_NamedRule;
+class ChromeMetadataPacket_FinchHash;
+namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule_NamedRule {
+enum EventType : int32_t;
+}  // namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule_NamedRule
+using BackgroundTracingMetadata_TriggerRule_NamedRule_EventType = perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule_NamedRule::EventType;
+namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule {
+enum TriggerType : int32_t;
+}  // namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule
+using BackgroundTracingMetadata_TriggerRule_TriggerType = perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule::TriggerType;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule {
+enum TriggerType : int32_t {
+  TRIGGER_UNSPECIFIED = 0,
+  MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE = 1,
+  MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED = 2,
+};
+} // namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule
+using BackgroundTracingMetadata_TriggerRule_TriggerType = perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule::TriggerType;
+
+
+constexpr BackgroundTracingMetadata_TriggerRule_TriggerType BackgroundTracingMetadata_TriggerRule_TriggerType_MIN = BackgroundTracingMetadata_TriggerRule_TriggerType::TRIGGER_UNSPECIFIED;
+constexpr BackgroundTracingMetadata_TriggerRule_TriggerType BackgroundTracingMetadata_TriggerRule_TriggerType_MAX = BackgroundTracingMetadata_TriggerRule_TriggerType::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* BackgroundTracingMetadata_TriggerRule_TriggerType_Name(::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_TriggerType value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_TriggerType::TRIGGER_UNSPECIFIED:
+    return "TRIGGER_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_TriggerType::MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE:
+    return "MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE";
+
+  case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_TriggerType::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED:
+    return "MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule_NamedRule {
+enum EventType : int32_t {
+  UNSPECIFIED = 0,
+  SESSION_RESTORE = 1,
+  NAVIGATION = 2,
+  STARTUP = 3,
+  REACHED_CODE = 4,
+  CONTENT_TRIGGER = 5,
+  TEST_RULE = 1000,
+};
+} // namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule_NamedRule
+using BackgroundTracingMetadata_TriggerRule_NamedRule_EventType = perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule_NamedRule::EventType;
+
+
+constexpr BackgroundTracingMetadata_TriggerRule_NamedRule_EventType BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_MIN = BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::UNSPECIFIED;
+constexpr BackgroundTracingMetadata_TriggerRule_NamedRule_EventType BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_MAX = BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::TEST_RULE;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_Name(::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::UNSPECIFIED:
+    return "UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::SESSION_RESTORE:
+    return "SESSION_RESTORE";
+
+  case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::NAVIGATION:
+    return "NAVIGATION";
+
+  case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::STARTUP:
+    return "STARTUP";
+
+  case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::REACHED_CODE:
+    return "REACHED_CODE";
+
+  case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::CONTENT_TRIGGER:
+    return "CONTENT_TRIGGER";
+
+  case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::TEST_RULE:
+    return "TEST_RULE";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class BackgroundTracingMetadata_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  BackgroundTracingMetadata_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit BackgroundTracingMetadata_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit BackgroundTracingMetadata_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_triggered_rule() const { return at<1>().valid(); }
+  ::protozero::ConstBytes triggered_rule() const { return at<1>().as_bytes(); }
+  bool has_active_rules() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> active_rules() const { return GetRepeated<::protozero::ConstBytes>(2); }
+  bool has_scenario_name_hash() const { return at<3>().valid(); }
+  uint32_t scenario_name_hash() const { return at<3>().as_uint32(); }
+};
+
+class BackgroundTracingMetadata : public ::protozero::Message {
+ public:
+  using Decoder = BackgroundTracingMetadata_Decoder;
+  enum : int32_t {
+    kTriggeredRuleFieldNumber = 1,
+    kActiveRulesFieldNumber = 2,
+    kScenarioNameHashFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.BackgroundTracingMetadata"; }
+
+  using TriggerRule = ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule;
+
+  using FieldMetadata_TriggeredRule =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BackgroundTracingMetadata_TriggerRule,
+      BackgroundTracingMetadata>;
+
+  static constexpr FieldMetadata_TriggeredRule kTriggeredRule{};
+  template <typename T = BackgroundTracingMetadata_TriggerRule> T* set_triggered_rule() {
+    return BeginNestedMessage<T>(1);
+  }
+
+
+  using FieldMetadata_ActiveRules =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BackgroundTracingMetadata_TriggerRule,
+      BackgroundTracingMetadata>;
+
+  static constexpr FieldMetadata_ActiveRules kActiveRules{};
+  template <typename T = BackgroundTracingMetadata_TriggerRule> T* add_active_rules() {
+    return BeginNestedMessage<T>(2);
+  }
+
+
+  using FieldMetadata_ScenarioNameHash =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFixed32,
+      uint32_t,
+      BackgroundTracingMetadata>;
+
+  static constexpr FieldMetadata_ScenarioNameHash kScenarioNameHash{};
+  void set_scenario_name_hash(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ScenarioNameHash::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFixed32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class BackgroundTracingMetadata_TriggerRule_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  BackgroundTracingMetadata_TriggerRule_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit BackgroundTracingMetadata_TriggerRule_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit BackgroundTracingMetadata_TriggerRule_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_trigger_type() const { return at<1>().valid(); }
+  int32_t trigger_type() const { return at<1>().as_int32(); }
+  bool has_histogram_rule() const { return at<2>().valid(); }
+  ::protozero::ConstBytes histogram_rule() const { return at<2>().as_bytes(); }
+  bool has_named_rule() const { return at<3>().valid(); }
+  ::protozero::ConstBytes named_rule() const { return at<3>().as_bytes(); }
+  bool has_name_hash() const { return at<4>().valid(); }
+  uint32_t name_hash() const { return at<4>().as_uint32(); }
+};
+
+class BackgroundTracingMetadata_TriggerRule : public ::protozero::Message {
+ public:
+  using Decoder = BackgroundTracingMetadata_TriggerRule_Decoder;
+  enum : int32_t {
+    kTriggerTypeFieldNumber = 1,
+    kHistogramRuleFieldNumber = 2,
+    kNamedRuleFieldNumber = 3,
+    kNameHashFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.BackgroundTracingMetadata.TriggerRule"; }
+
+  using HistogramRule = ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_HistogramRule;
+  using NamedRule = ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule;
+
+  using TriggerType = ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_TriggerType;
+  static inline const char* TriggerType_Name(TriggerType value) {
+    return ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_TriggerType_Name(value);
+  }
+  static inline const TriggerType TRIGGER_UNSPECIFIED = TriggerType::TRIGGER_UNSPECIFIED;
+  static inline const TriggerType MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE = TriggerType::MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE;
+  static inline const TriggerType MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED = TriggerType::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED;
+
+  using FieldMetadata_TriggerType =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      BackgroundTracingMetadata_TriggerRule_TriggerType,
+      BackgroundTracingMetadata_TriggerRule>;
+
+  static constexpr FieldMetadata_TriggerType kTriggerType{};
+  void set_trigger_type(BackgroundTracingMetadata_TriggerRule_TriggerType value) {
+    static constexpr uint32_t field_id = FieldMetadata_TriggerType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_HistogramRule =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BackgroundTracingMetadata_TriggerRule_HistogramRule,
+      BackgroundTracingMetadata_TriggerRule>;
+
+  static constexpr FieldMetadata_HistogramRule kHistogramRule{};
+  template <typename T = BackgroundTracingMetadata_TriggerRule_HistogramRule> T* set_histogram_rule() {
+    return BeginNestedMessage<T>(2);
+  }
+
+
+  using FieldMetadata_NamedRule =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BackgroundTracingMetadata_TriggerRule_NamedRule,
+      BackgroundTracingMetadata_TriggerRule>;
+
+  static constexpr FieldMetadata_NamedRule kNamedRule{};
+  template <typename T = BackgroundTracingMetadata_TriggerRule_NamedRule> T* set_named_rule() {
+    return BeginNestedMessage<T>(3);
+  }
+
+
+  using FieldMetadata_NameHash =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFixed32,
+      uint32_t,
+      BackgroundTracingMetadata_TriggerRule>;
+
+  static constexpr FieldMetadata_NameHash kNameHash{};
+  void set_name_hash(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NameHash::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFixed32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class BackgroundTracingMetadata_TriggerRule_NamedRule_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  BackgroundTracingMetadata_TriggerRule_NamedRule_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit BackgroundTracingMetadata_TriggerRule_NamedRule_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit BackgroundTracingMetadata_TriggerRule_NamedRule_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_event_type() const { return at<1>().valid(); }
+  int32_t event_type() const { return at<1>().as_int32(); }
+  bool has_content_trigger_name_hash() const { return at<2>().valid(); }
+  uint64_t content_trigger_name_hash() const { return at<2>().as_uint64(); }
+};
+
+class BackgroundTracingMetadata_TriggerRule_NamedRule : public ::protozero::Message {
+ public:
+  using Decoder = BackgroundTracingMetadata_TriggerRule_NamedRule_Decoder;
+  enum : int32_t {
+    kEventTypeFieldNumber = 1,
+    kContentTriggerNameHashFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule"; }
+
+
+  using EventType = ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType;
+  static inline const char* EventType_Name(EventType value) {
+    return ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_Name(value);
+  }
+  static inline const EventType UNSPECIFIED = EventType::UNSPECIFIED;
+  static inline const EventType SESSION_RESTORE = EventType::SESSION_RESTORE;
+  static inline const EventType NAVIGATION = EventType::NAVIGATION;
+  static inline const EventType STARTUP = EventType::STARTUP;
+  static inline const EventType REACHED_CODE = EventType::REACHED_CODE;
+  static inline const EventType CONTENT_TRIGGER = EventType::CONTENT_TRIGGER;
+  static inline const EventType TEST_RULE = EventType::TEST_RULE;
+
+  using FieldMetadata_EventType =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      BackgroundTracingMetadata_TriggerRule_NamedRule_EventType,
+      BackgroundTracingMetadata_TriggerRule_NamedRule>;
+
+  static constexpr FieldMetadata_EventType kEventType{};
+  void set_event_type(BackgroundTracingMetadata_TriggerRule_NamedRule_EventType value) {
+    static constexpr uint32_t field_id = FieldMetadata_EventType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ContentTriggerNameHash =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
+      uint64_t,
+      BackgroundTracingMetadata_TriggerRule_NamedRule>;
+
+  static constexpr FieldMetadata_ContentTriggerNameHash kContentTriggerNameHash{};
+  void set_content_trigger_name_hash(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ContentTriggerNameHash::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class BackgroundTracingMetadata_TriggerRule_HistogramRule_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  BackgroundTracingMetadata_TriggerRule_HistogramRule_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit BackgroundTracingMetadata_TriggerRule_HistogramRule_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit BackgroundTracingMetadata_TriggerRule_HistogramRule_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_histogram_name_hash() const { return at<1>().valid(); }
+  uint64_t histogram_name_hash() const { return at<1>().as_uint64(); }
+  bool has_histogram_min_trigger() const { return at<2>().valid(); }
+  int64_t histogram_min_trigger() const { return at<2>().as_int64(); }
+  bool has_histogram_max_trigger() const { return at<3>().valid(); }
+  int64_t histogram_max_trigger() const { return at<3>().as_int64(); }
+};
+
+class BackgroundTracingMetadata_TriggerRule_HistogramRule : public ::protozero::Message {
+ public:
+  using Decoder = BackgroundTracingMetadata_TriggerRule_HistogramRule_Decoder;
+  enum : int32_t {
+    kHistogramNameHashFieldNumber = 1,
+    kHistogramMinTriggerFieldNumber = 2,
+    kHistogramMaxTriggerFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule"; }
+
+
+  using FieldMetadata_HistogramNameHash =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
+      uint64_t,
+      BackgroundTracingMetadata_TriggerRule_HistogramRule>;
+
+  static constexpr FieldMetadata_HistogramNameHash kHistogramNameHash{};
+  void set_histogram_name_hash(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_HistogramNameHash::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_HistogramMinTrigger =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      BackgroundTracingMetadata_TriggerRule_HistogramRule>;
+
+  static constexpr FieldMetadata_HistogramMinTrigger kHistogramMinTrigger{};
+  void set_histogram_min_trigger(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_HistogramMinTrigger::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_HistogramMaxTrigger =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      BackgroundTracingMetadata_TriggerRule_HistogramRule>;
+
+  static constexpr FieldMetadata_HistogramMaxTrigger kHistogramMaxTrigger{};
+  void set_histogram_max_trigger(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_HistogramMaxTrigger::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class ChromeMetadataPacket_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  ChromeMetadataPacket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeMetadataPacket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeMetadataPacket_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_background_tracing_metadata() const { return at<1>().valid(); }
+  ::protozero::ConstBytes background_tracing_metadata() const { return at<1>().as_bytes(); }
+  bool has_chrome_version_code() const { return at<2>().valid(); }
+  int32_t chrome_version_code() const { return at<2>().as_int32(); }
+  bool has_enabled_categories() const { return at<3>().valid(); }
+  ::protozero::ConstChars enabled_categories() const { return at<3>().as_string(); }
+  bool has_field_trial_hashes() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> field_trial_hashes() const { return GetRepeated<::protozero::ConstBytes>(4); }
+  bool has_app_package_name() const { return at<5>().valid(); }
+  ::protozero::ConstChars app_package_name() const { return at<5>().as_string(); }
+};
+
+class ChromeMetadataPacket : public ::protozero::Message {
+ public:
+  using Decoder = ChromeMetadataPacket_Decoder;
+  enum : int32_t {
+    kBackgroundTracingMetadataFieldNumber = 1,
+    kChromeVersionCodeFieldNumber = 2,
+    kEnabledCategoriesFieldNumber = 3,
+    kFieldTrialHashesFieldNumber = 4,
+    kAppPackageNameFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeMetadataPacket"; }
+
+  using FinchHash = ::perfetto::protos::pbzero::ChromeMetadataPacket_FinchHash;
+
+  using FieldMetadata_BackgroundTracingMetadata =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BackgroundTracingMetadata,
+      ChromeMetadataPacket>;
+
+  static constexpr FieldMetadata_BackgroundTracingMetadata kBackgroundTracingMetadata{};
+  template <typename T = BackgroundTracingMetadata> T* set_background_tracing_metadata() {
+    return BeginNestedMessage<T>(1);
+  }
+
+
+  using FieldMetadata_ChromeVersionCode =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ChromeMetadataPacket>;
+
+  static constexpr FieldMetadata_ChromeVersionCode kChromeVersionCode{};
+  void set_chrome_version_code(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ChromeVersionCode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_EnabledCategories =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeMetadataPacket>;
+
+  static constexpr FieldMetadata_EnabledCategories kEnabledCategories{};
+  void set_enabled_categories(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_EnabledCategories::kFieldId, data, size);
+  }
+  void set_enabled_categories(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_EnabledCategories::kFieldId, chars.data, chars.size);
+  }
+  void set_enabled_categories(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_EnabledCategories::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FieldTrialHashes =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromeMetadataPacket_FinchHash,
+      ChromeMetadataPacket>;
+
+  static constexpr FieldMetadata_FieldTrialHashes kFieldTrialHashes{};
+  template <typename T = ChromeMetadataPacket_FinchHash> T* add_field_trial_hashes() {
+    return BeginNestedMessage<T>(4);
+  }
+
+
+  using FieldMetadata_AppPackageName =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeMetadataPacket>;
+
+  static constexpr FieldMetadata_AppPackageName kAppPackageName{};
+  void set_app_package_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_AppPackageName::kFieldId, data, size);
+  }
+  void set_app_package_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_AppPackageName::kFieldId, chars.data, chars.size);
+  }
+  void set_app_package_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_AppPackageName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class ChromeMetadataPacket_FinchHash_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  ChromeMetadataPacket_FinchHash_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeMetadataPacket_FinchHash_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeMetadataPacket_FinchHash_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  uint32_t name() const { return at<1>().as_uint32(); }
+  bool has_group() const { return at<2>().valid(); }
+  uint32_t group() const { return at<2>().as_uint32(); }
+};
+
+class ChromeMetadataPacket_FinchHash : public ::protozero::Message {
+ public:
+  using Decoder = ChromeMetadataPacket_FinchHash_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kGroupFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeMetadataPacket.FinchHash"; }
+
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ChromeMetadataPacket_FinchHash>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Group =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ChromeMetadataPacket_FinchHash>;
+
+  static constexpr FieldMetadata_Group kGroup{};
+  void set_group(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Group::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/chrome/chrome_trace_event.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CHROME_CHROME_TRACE_EVENT_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CHROME_CHROME_TRACE_EVENT_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class ChromeLegacyJsonTrace;
+class ChromeMetadata;
+class ChromeStringTableEntry;
+class ChromeTraceEvent;
+class ChromeTraceEvent_Arg;
+class ChromeTracedValue;
+namespace perfetto_pbzero_enum_ChromeLegacyJsonTrace {
+enum TraceType : int32_t;
+}  // namespace perfetto_pbzero_enum_ChromeLegacyJsonTrace
+using ChromeLegacyJsonTrace_TraceType = perfetto_pbzero_enum_ChromeLegacyJsonTrace::TraceType;
+namespace perfetto_pbzero_enum_ChromeTracedValue {
+enum NestedType : int32_t;
+}  // namespace perfetto_pbzero_enum_ChromeTracedValue
+using ChromeTracedValue_NestedType = perfetto_pbzero_enum_ChromeTracedValue::NestedType;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_ChromeLegacyJsonTrace {
+enum TraceType : int32_t {
+  USER_TRACE = 0,
+  SYSTEM_TRACE = 1,
+};
+} // namespace perfetto_pbzero_enum_ChromeLegacyJsonTrace
+using ChromeLegacyJsonTrace_TraceType = perfetto_pbzero_enum_ChromeLegacyJsonTrace::TraceType;
+
+
+constexpr ChromeLegacyJsonTrace_TraceType ChromeLegacyJsonTrace_TraceType_MIN = ChromeLegacyJsonTrace_TraceType::USER_TRACE;
+constexpr ChromeLegacyJsonTrace_TraceType ChromeLegacyJsonTrace_TraceType_MAX = ChromeLegacyJsonTrace_TraceType::SYSTEM_TRACE;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ChromeLegacyJsonTrace_TraceType_Name(::perfetto::protos::pbzero::ChromeLegacyJsonTrace_TraceType value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ChromeLegacyJsonTrace_TraceType::USER_TRACE:
+    return "USER_TRACE";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyJsonTrace_TraceType::SYSTEM_TRACE:
+    return "SYSTEM_TRACE";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_ChromeTracedValue {
+enum NestedType : int32_t {
+  DICT = 0,
+  ARRAY = 1,
+};
+} // namespace perfetto_pbzero_enum_ChromeTracedValue
+using ChromeTracedValue_NestedType = perfetto_pbzero_enum_ChromeTracedValue::NestedType;
+
+
+constexpr ChromeTracedValue_NestedType ChromeTracedValue_NestedType_MIN = ChromeTracedValue_NestedType::DICT;
+constexpr ChromeTracedValue_NestedType ChromeTracedValue_NestedType_MAX = ChromeTracedValue_NestedType::ARRAY;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ChromeTracedValue_NestedType_Name(::perfetto::protos::pbzero::ChromeTracedValue_NestedType value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ChromeTracedValue_NestedType::DICT:
+    return "DICT";
+
+  case ::perfetto::protos::pbzero::ChromeTracedValue_NestedType::ARRAY:
+    return "ARRAY";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class ChromeEventBundle_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  ChromeEventBundle_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeEventBundle_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeEventBundle_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_trace_events() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> trace_events() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  bool has_metadata() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> metadata() const { return GetRepeated<::protozero::ConstBytes>(2); }
+  bool has_legacy_ftrace_output() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> legacy_ftrace_output() const { return GetRepeated<::protozero::ConstChars>(4); }
+  bool has_legacy_json_trace() const { return at<5>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> legacy_json_trace() const { return GetRepeated<::protozero::ConstBytes>(5); }
+  bool has_string_table() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> string_table() const { return GetRepeated<::protozero::ConstBytes>(3); }
+};
+
+class ChromeEventBundle : public ::protozero::Message {
+ public:
+  using Decoder = ChromeEventBundle_Decoder;
+  enum : int32_t {
+    kTraceEventsFieldNumber = 1,
+    kMetadataFieldNumber = 2,
+    kLegacyFtraceOutputFieldNumber = 4,
+    kLegacyJsonTraceFieldNumber = 5,
+    kStringTableFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeEventBundle"; }
+
+
+  using FieldMetadata_TraceEvents =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromeTraceEvent,
+      ChromeEventBundle>;
+
+  static constexpr FieldMetadata_TraceEvents kTraceEvents{};
+  template <typename T = ChromeTraceEvent> T* add_trace_events() {
+    return BeginNestedMessage<T>(1);
+  }
+
+
+  using FieldMetadata_Metadata =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromeMetadata,
+      ChromeEventBundle>;
+
+  static constexpr FieldMetadata_Metadata kMetadata{};
+  template <typename T = ChromeMetadata> T* add_metadata() {
+    return BeginNestedMessage<T>(2);
+  }
+
+
+  using FieldMetadata_LegacyFtraceOutput =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeEventBundle>;
+
+  static constexpr FieldMetadata_LegacyFtraceOutput kLegacyFtraceOutput{};
+  void add_legacy_ftrace_output(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_LegacyFtraceOutput::kFieldId, data, size);
+  }
+  void add_legacy_ftrace_output(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_LegacyFtraceOutput::kFieldId, chars.data, chars.size);
+  }
+  void add_legacy_ftrace_output(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_LegacyFtraceOutput::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_LegacyJsonTrace =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromeLegacyJsonTrace,
+      ChromeEventBundle>;
+
+  static constexpr FieldMetadata_LegacyJsonTrace kLegacyJsonTrace{};
+  template <typename T = ChromeLegacyJsonTrace> T* add_legacy_json_trace() {
+    return BeginNestedMessage<T>(5);
+  }
+
+
+  using FieldMetadata_StringTable =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromeStringTableEntry,
+      ChromeEventBundle>;
+
+  static constexpr FieldMetadata_StringTable kStringTable{};
+  template <typename T = ChromeStringTableEntry> T* add_string_table() {
+    return BeginNestedMessage<T>(3);
+  }
+
+};
+
+class ChromeLegacyJsonTrace_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  ChromeLegacyJsonTrace_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeLegacyJsonTrace_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeLegacyJsonTrace_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_type() const { return at<1>().valid(); }
+  int32_t type() const { return at<1>().as_int32(); }
+  bool has_data() const { return at<2>().valid(); }
+  ::protozero::ConstChars data() const { return at<2>().as_string(); }
+};
+
+class ChromeLegacyJsonTrace : public ::protozero::Message {
+ public:
+  using Decoder = ChromeLegacyJsonTrace_Decoder;
+  enum : int32_t {
+    kTypeFieldNumber = 1,
+    kDataFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeLegacyJsonTrace"; }
+
+
+  using TraceType = ::perfetto::protos::pbzero::ChromeLegacyJsonTrace_TraceType;
+  static inline const char* TraceType_Name(TraceType value) {
+    return ::perfetto::protos::pbzero::ChromeLegacyJsonTrace_TraceType_Name(value);
+  }
+  static inline const TraceType USER_TRACE = TraceType::USER_TRACE;
+  static inline const TraceType SYSTEM_TRACE = TraceType::SYSTEM_TRACE;
+
+  using FieldMetadata_Type =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ChromeLegacyJsonTrace_TraceType,
+      ChromeLegacyJsonTrace>;
+
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(ChromeLegacyJsonTrace_TraceType value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Data =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeLegacyJsonTrace>;
+
+  static constexpr FieldMetadata_Data kData{};
+  void set_data(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Data::kFieldId, data, size);
+  }
+  void set_data(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Data::kFieldId, chars.data, chars.size);
+  }
+  void set_data(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Data::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class ChromeMetadata_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  ChromeMetadata_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeMetadata_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeMetadata_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_string_value() const { return at<2>().valid(); }
+  ::protozero::ConstChars string_value() const { return at<2>().as_string(); }
+  bool has_bool_value() const { return at<3>().valid(); }
+  bool bool_value() const { return at<3>().as_bool(); }
+  bool has_int_value() const { return at<4>().valid(); }
+  int64_t int_value() const { return at<4>().as_int64(); }
+  bool has_json_value() const { return at<5>().valid(); }
+  ::protozero::ConstChars json_value() const { return at<5>().as_string(); }
+};
+
+class ChromeMetadata : public ::protozero::Message {
+ public:
+  using Decoder = ChromeMetadata_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kStringValueFieldNumber = 2,
+    kBoolValueFieldNumber = 3,
+    kIntValueFieldNumber = 4,
+    kJsonValueFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeMetadata"; }
+
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeMetadata>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StringValue =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeMetadata>;
+
+  static constexpr FieldMetadata_StringValue kStringValue{};
+  void set_string_value(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_StringValue::kFieldId, data, size);
+  }
+  void set_string_value(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_StringValue::kFieldId, chars.data, chars.size);
+  }
+  void set_string_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_StringValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BoolValue =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeMetadata>;
+
+  static constexpr FieldMetadata_BoolValue kBoolValue{};
+  void set_bool_value(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_BoolValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IntValue =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ChromeMetadata>;
+
+  static constexpr FieldMetadata_IntValue kIntValue{};
+  void set_int_value(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_JsonValue =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeMetadata>;
+
+  static constexpr FieldMetadata_JsonValue kJsonValue{};
+  void set_json_value(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_JsonValue::kFieldId, data, size);
+  }
+  void set_json_value(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_JsonValue::kFieldId, chars.data, chars.size);
+  }
+  void set_json_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_JsonValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class ChromeTraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/16> {
+ public:
+  ChromeTraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeTraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeTraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_timestamp() const { return at<2>().valid(); }
+  int64_t timestamp() const { return at<2>().as_int64(); }
+  bool has_phase() const { return at<3>().valid(); }
+  int32_t phase() const { return at<3>().as_int32(); }
+  bool has_thread_id() const { return at<4>().valid(); }
+  int32_t thread_id() const { return at<4>().as_int32(); }
+  bool has_duration() const { return at<5>().valid(); }
+  int64_t duration() const { return at<5>().as_int64(); }
+  bool has_thread_duration() const { return at<6>().valid(); }
+  int64_t thread_duration() const { return at<6>().as_int64(); }
+  bool has_scope() const { return at<7>().valid(); }
+  ::protozero::ConstChars scope() const { return at<7>().as_string(); }
+  bool has_id() const { return at<8>().valid(); }
+  uint64_t id() const { return at<8>().as_uint64(); }
+  bool has_flags() const { return at<9>().valid(); }
+  uint32_t flags() const { return at<9>().as_uint32(); }
+  bool has_category_group_name() const { return at<10>().valid(); }
+  ::protozero::ConstChars category_group_name() const { return at<10>().as_string(); }
+  bool has_process_id() const { return at<11>().valid(); }
+  int32_t process_id() const { return at<11>().as_int32(); }
+  bool has_thread_timestamp() const { return at<12>().valid(); }
+  int64_t thread_timestamp() const { return at<12>().as_int64(); }
+  bool has_bind_id() const { return at<13>().valid(); }
+  uint64_t bind_id() const { return at<13>().as_uint64(); }
+  bool has_args() const { return at<14>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> args() const { return GetRepeated<::protozero::ConstBytes>(14); }
+  bool has_name_index() const { return at<15>().valid(); }
+  uint32_t name_index() const { return at<15>().as_uint32(); }
+  bool has_category_group_name_index() const { return at<16>().valid(); }
+  uint32_t category_group_name_index() const { return at<16>().as_uint32(); }
+};
+
+class ChromeTraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = ChromeTraceEvent_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kTimestampFieldNumber = 2,
+    kPhaseFieldNumber = 3,
+    kThreadIdFieldNumber = 4,
+    kDurationFieldNumber = 5,
+    kThreadDurationFieldNumber = 6,
+    kScopeFieldNumber = 7,
+    kIdFieldNumber = 8,
+    kFlagsFieldNumber = 9,
+    kCategoryGroupNameFieldNumber = 10,
+    kProcessIdFieldNumber = 11,
+    kThreadTimestampFieldNumber = 12,
+    kBindIdFieldNumber = 13,
+    kArgsFieldNumber = 14,
+    kNameIndexFieldNumber = 15,
+    kCategoryGroupNameIndexFieldNumber = 16,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeTraceEvent"; }
+
+  using Arg = ::perfetto::protos::pbzero::ChromeTraceEvent_Arg;
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeTraceEvent>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Timestamp =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ChromeTraceEvent>;
+
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Phase =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ChromeTraceEvent>;
+
+  static constexpr FieldMetadata_Phase kPhase{};
+  void set_phase(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Phase::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ThreadId =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ChromeTraceEvent>;
+
+  static constexpr FieldMetadata_ThreadId kThreadId{};
+  void set_thread_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ThreadId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Duration =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ChromeTraceEvent>;
+
+  static constexpr FieldMetadata_Duration kDuration{};
+  void set_duration(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Duration::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ThreadDuration =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ChromeTraceEvent>;
+
+  static constexpr FieldMetadata_ThreadDuration kThreadDuration{};
+  void set_thread_duration(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ThreadDuration::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Scope =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeTraceEvent>;
+
+  static constexpr FieldMetadata_Scope kScope{};
+  void set_scope(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Scope::kFieldId, data, size);
+  }
+  void set_scope(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Scope::kFieldId, chars.data, chars.size);
+  }
+  void set_scope(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Scope::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Id =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ChromeTraceEvent>;
+
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Flags =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ChromeTraceEvent>;
+
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CategoryGroupName =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeTraceEvent>;
+
+  static constexpr FieldMetadata_CategoryGroupName kCategoryGroupName{};
+  void set_category_group_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_CategoryGroupName::kFieldId, data, size);
+  }
+  void set_category_group_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_CategoryGroupName::kFieldId, chars.data, chars.size);
+  }
+  void set_category_group_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_CategoryGroupName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ProcessId =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ChromeTraceEvent>;
+
+  static constexpr FieldMetadata_ProcessId kProcessId{};
+  void set_process_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProcessId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ThreadTimestamp =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ChromeTraceEvent>;
+
+  static constexpr FieldMetadata_ThreadTimestamp kThreadTimestamp{};
+  void set_thread_timestamp(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ThreadTimestamp::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BindId =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ChromeTraceEvent>;
+
+  static constexpr FieldMetadata_BindId kBindId{};
+  void set_bind_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BindId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Args =
+    ::protozero::proto_utils::FieldMetadata<
+      14,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromeTraceEvent_Arg,
+      ChromeTraceEvent>;
+
+  static constexpr FieldMetadata_Args kArgs{};
+  template <typename T = ChromeTraceEvent_Arg> T* add_args() {
+    return BeginNestedMessage<T>(14);
+  }
+
+
+  using FieldMetadata_NameIndex =
+    ::protozero::proto_utils::FieldMetadata<
+      15,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ChromeTraceEvent>;
+
+  static constexpr FieldMetadata_NameIndex kNameIndex{};
+  void set_name_index(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NameIndex::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CategoryGroupNameIndex =
+    ::protozero::proto_utils::FieldMetadata<
+      16,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ChromeTraceEvent>;
+
+  static constexpr FieldMetadata_CategoryGroupNameIndex kCategoryGroupNameIndex{};
+  void set_category_group_name_index(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CategoryGroupNameIndex::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class ChromeTraceEvent_Arg_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10> {
+ public:
+  ChromeTraceEvent_Arg_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeTraceEvent_Arg_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeTraceEvent_Arg_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_bool_value() const { return at<2>().valid(); }
+  bool bool_value() const { return at<2>().as_bool(); }
+  bool has_uint_value() const { return at<3>().valid(); }
+  uint64_t uint_value() const { return at<3>().as_uint64(); }
+  bool has_int_value() const { return at<4>().valid(); }
+  int64_t int_value() const { return at<4>().as_int64(); }
+  bool has_double_value() const { return at<5>().valid(); }
+  double double_value() const { return at<5>().as_double(); }
+  bool has_string_value() const { return at<6>().valid(); }
+  ::protozero::ConstChars string_value() const { return at<6>().as_string(); }
+  bool has_pointer_value() const { return at<7>().valid(); }
+  uint64_t pointer_value() const { return at<7>().as_uint64(); }
+  bool has_json_value() const { return at<8>().valid(); }
+  ::protozero::ConstChars json_value() const { return at<8>().as_string(); }
+  bool has_traced_value() const { return at<10>().valid(); }
+  ::protozero::ConstBytes traced_value() const { return at<10>().as_bytes(); }
+  bool has_name_index() const { return at<9>().valid(); }
+  uint32_t name_index() const { return at<9>().as_uint32(); }
+};
+
+class ChromeTraceEvent_Arg : public ::protozero::Message {
+ public:
+  using Decoder = ChromeTraceEvent_Arg_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kBoolValueFieldNumber = 2,
+    kUintValueFieldNumber = 3,
+    kIntValueFieldNumber = 4,
+    kDoubleValueFieldNumber = 5,
+    kStringValueFieldNumber = 6,
+    kPointerValueFieldNumber = 7,
+    kJsonValueFieldNumber = 8,
+    kTracedValueFieldNumber = 10,
+    kNameIndexFieldNumber = 9,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeTraceEvent.Arg"; }
+
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeTraceEvent_Arg>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BoolValue =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeTraceEvent_Arg>;
+
+  static constexpr FieldMetadata_BoolValue kBoolValue{};
+  void set_bool_value(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_BoolValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_UintValue =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ChromeTraceEvent_Arg>;
+
+  static constexpr FieldMetadata_UintValue kUintValue{};
+  void set_uint_value(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_UintValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IntValue =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ChromeTraceEvent_Arg>;
+
+  static constexpr FieldMetadata_IntValue kIntValue{};
+  void set_int_value(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DoubleValue =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kDouble,
+      double,
+      ChromeTraceEvent_Arg>;
+
+  static constexpr FieldMetadata_DoubleValue kDoubleValue{};
+  void set_double_value(double value) {
+    static constexpr uint32_t field_id = FieldMetadata_DoubleValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StringValue =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeTraceEvent_Arg>;
+
+  static constexpr FieldMetadata_StringValue kStringValue{};
+  void set_string_value(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_StringValue::kFieldId, data, size);
+  }
+  void set_string_value(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_StringValue::kFieldId, chars.data, chars.size);
+  }
+  void set_string_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_StringValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PointerValue =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ChromeTraceEvent_Arg>;
+
+  static constexpr FieldMetadata_PointerValue kPointerValue{};
+  void set_pointer_value(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PointerValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_JsonValue =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeTraceEvent_Arg>;
+
+  static constexpr FieldMetadata_JsonValue kJsonValue{};
+  void set_json_value(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_JsonValue::kFieldId, data, size);
+  }
+  void set_json_value(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_JsonValue::kFieldId, chars.data, chars.size);
+  }
+  void set_json_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_JsonValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TracedValue =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromeTracedValue,
+      ChromeTraceEvent_Arg>;
+
+  static constexpr FieldMetadata_TracedValue kTracedValue{};
+  template <typename T = ChromeTracedValue> T* set_traced_value() {
+    return BeginNestedMessage<T>(10);
+  }
+
+
+  using FieldMetadata_NameIndex =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ChromeTraceEvent_Arg>;
+
+  static constexpr FieldMetadata_NameIndex kNameIndex{};
+  void set_name_index(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NameIndex::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class ChromeStringTableEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  ChromeStringTableEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeStringTableEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeStringTableEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_value() const { return at<1>().valid(); }
+  ::protozero::ConstChars value() const { return at<1>().as_string(); }
+  bool has_index() const { return at<2>().valid(); }
+  int32_t index() const { return at<2>().as_int32(); }
+};
+
+class ChromeStringTableEntry : public ::protozero::Message {
+ public:
+  using Decoder = ChromeStringTableEntry_Decoder;
+  enum : int32_t {
+    kValueFieldNumber = 1,
+    kIndexFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeStringTableEntry"; }
+
+
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeStringTableEntry>;
+
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
+  }
+  void set_value(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
+  }
+  void set_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Index =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ChromeStringTableEntry>;
+
+  static constexpr FieldMetadata_Index kIndex{};
+  void set_index(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class ChromeTracedValue_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
+ public:
+  ChromeTracedValue_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeTracedValue_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeTracedValue_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_nested_type() const { return at<1>().valid(); }
+  int32_t nested_type() const { return at<1>().as_int32(); }
+  bool has_dict_keys() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> dict_keys() const { return GetRepeated<::protozero::ConstChars>(2); }
+  bool has_dict_values() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> dict_values() const { return GetRepeated<::protozero::ConstBytes>(3); }
+  bool has_array_values() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> array_values() const { return GetRepeated<::protozero::ConstBytes>(4); }
+  bool has_int_value() const { return at<5>().valid(); }
+  int32_t int_value() const { return at<5>().as_int32(); }
+  bool has_double_value() const { return at<6>().valid(); }
+  double double_value() const { return at<6>().as_double(); }
+  bool has_bool_value() const { return at<7>().valid(); }
+  bool bool_value() const { return at<7>().as_bool(); }
+  bool has_string_value() const { return at<8>().valid(); }
+  ::protozero::ConstChars string_value() const { return at<8>().as_string(); }
+};
+
+class ChromeTracedValue : public ::protozero::Message {
+ public:
+  using Decoder = ChromeTracedValue_Decoder;
+  enum : int32_t {
+    kNestedTypeFieldNumber = 1,
+    kDictKeysFieldNumber = 2,
+    kDictValuesFieldNumber = 3,
+    kArrayValuesFieldNumber = 4,
+    kIntValueFieldNumber = 5,
+    kDoubleValueFieldNumber = 6,
+    kBoolValueFieldNumber = 7,
+    kStringValueFieldNumber = 8,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeTracedValue"; }
+
+
+  using NestedType = ::perfetto::protos::pbzero::ChromeTracedValue_NestedType;
+  static inline const char* NestedType_Name(NestedType value) {
+    return ::perfetto::protos::pbzero::ChromeTracedValue_NestedType_Name(value);
+  }
+  static inline const NestedType DICT = NestedType::DICT;
+  static inline const NestedType ARRAY = NestedType::ARRAY;
+
+  using FieldMetadata_NestedType =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ChromeTracedValue_NestedType,
+      ChromeTracedValue>;
+
+  static constexpr FieldMetadata_NestedType kNestedType{};
+  void set_nested_type(ChromeTracedValue_NestedType value) {
+    static constexpr uint32_t field_id = FieldMetadata_NestedType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DictKeys =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeTracedValue>;
+
+  static constexpr FieldMetadata_DictKeys kDictKeys{};
+  void add_dict_keys(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_DictKeys::kFieldId, data, size);
+  }
+  void add_dict_keys(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_DictKeys::kFieldId, chars.data, chars.size);
+  }
+  void add_dict_keys(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_DictKeys::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DictValues =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromeTracedValue,
+      ChromeTracedValue>;
+
+  static constexpr FieldMetadata_DictValues kDictValues{};
+  template <typename T = ChromeTracedValue> T* add_dict_values() {
+    return BeginNestedMessage<T>(3);
+  }
+
+
+  using FieldMetadata_ArrayValues =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromeTracedValue,
+      ChromeTracedValue>;
+
+  static constexpr FieldMetadata_ArrayValues kArrayValues{};
+  template <typename T = ChromeTracedValue> T* add_array_values() {
+    return BeginNestedMessage<T>(4);
+  }
+
+
+  using FieldMetadata_IntValue =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ChromeTracedValue>;
+
+  static constexpr FieldMetadata_IntValue kIntValue{};
+  void set_int_value(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DoubleValue =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kDouble,
+      double,
+      ChromeTracedValue>;
+
+  static constexpr FieldMetadata_DoubleValue kDoubleValue{};
+  void set_double_value(double value) {
+    static constexpr uint32_t field_id = FieldMetadata_DoubleValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BoolValue =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeTracedValue>;
+
+  static constexpr FieldMetadata_BoolValue kBoolValue{};
+  void set_bool_value(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_BoolValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StringValue =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeTracedValue>;
+
+  static constexpr FieldMetadata_StringValue kStringValue{};
+  void set_string_value(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_StringValue::kFieldId, data, size);
+  }
+  void set_string_value(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_StringValue::kFieldId, chars.data, chars.size);
+  }
+  void set_string_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_StringValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/chrome/chrome_trigger.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CHROME_CHROME_TRIGGER_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CHROME_CHROME_TRIGGER_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class ChromeTrigger_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  ChromeTrigger_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeTrigger_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeTrigger_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_trigger_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars trigger_name() const { return at<1>().as_string(); }
+  bool has_trigger_name_hash() const { return at<2>().valid(); }
+  uint32_t trigger_name_hash() const { return at<2>().as_uint32(); }
+  bool has_flow_id() const { return at<3>().valid(); }
+  uint64_t flow_id() const { return at<3>().as_uint64(); }
+};
+
+class ChromeTrigger : public ::protozero::Message {
+ public:
+  using Decoder = ChromeTrigger_Decoder;
+  enum : int32_t {
+    kTriggerNameFieldNumber = 1,
+    kTriggerNameHashFieldNumber = 2,
+    kFlowIdFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeTrigger"; }
+
+
+  using FieldMetadata_TriggerName =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeTrigger>;
+
+  static constexpr FieldMetadata_TriggerName kTriggerName{};
+  void set_trigger_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_TriggerName::kFieldId, data, size);
+  }
+  void set_trigger_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_TriggerName::kFieldId, chars.data, chars.size);
+  }
+  void set_trigger_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_TriggerName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TriggerNameHash =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFixed32,
+      uint32_t,
+      ChromeTrigger>;
+
+  static constexpr FieldMetadata_TriggerNameHash kTriggerNameHash{};
+  void set_trigger_name_hash(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TriggerNameHash::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFixed32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FlowId =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
+      uint64_t,
+      ChromeTrigger>;
+
+  static constexpr FieldMetadata_FlowId kFlowId{};
+  void set_flow_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FlowId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/chrome/v8.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CHROME_V8_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CHROME_V8_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class InternedV8Isolate_CodeRange;
+class V8String;
+namespace perfetto_pbzero_enum_InternedV8JsFunction {
+enum Kind : int32_t;
+}  // namespace perfetto_pbzero_enum_InternedV8JsFunction
+using InternedV8JsFunction_Kind = perfetto_pbzero_enum_InternedV8JsFunction::Kind;
+namespace perfetto_pbzero_enum_InternedV8JsScript {
+enum Type : int32_t;
+}  // namespace perfetto_pbzero_enum_InternedV8JsScript
+using InternedV8JsScript_Type = perfetto_pbzero_enum_InternedV8JsScript::Type;
+namespace perfetto_pbzero_enum_V8InternalCode {
+enum Type : int32_t;
+}  // namespace perfetto_pbzero_enum_V8InternalCode
+using V8InternalCode_Type = perfetto_pbzero_enum_V8InternalCode::Type;
+namespace perfetto_pbzero_enum_V8JsCode {
+enum Tier : int32_t;
+}  // namespace perfetto_pbzero_enum_V8JsCode
+using V8JsCode_Tier = perfetto_pbzero_enum_V8JsCode::Tier;
+namespace perfetto_pbzero_enum_V8WasmCode {
+enum Tier : int32_t;
+}  // namespace perfetto_pbzero_enum_V8WasmCode
+using V8WasmCode_Tier = perfetto_pbzero_enum_V8WasmCode::Tier;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_V8WasmCode {
+enum Tier : int32_t {
+  TIER_UNKNOWN = 0,
+  TIER_LIFTOFF = 1,
+  TIER_TURBOFAN = 2,
+};
+} // namespace perfetto_pbzero_enum_V8WasmCode
+using V8WasmCode_Tier = perfetto_pbzero_enum_V8WasmCode::Tier;
+
+
+constexpr V8WasmCode_Tier V8WasmCode_Tier_MIN = V8WasmCode_Tier::TIER_UNKNOWN;
+constexpr V8WasmCode_Tier V8WasmCode_Tier_MAX = V8WasmCode_Tier::TIER_TURBOFAN;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* V8WasmCode_Tier_Name(::perfetto::protos::pbzero::V8WasmCode_Tier value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::V8WasmCode_Tier::TIER_UNKNOWN:
+    return "TIER_UNKNOWN";
+
+  case ::perfetto::protos::pbzero::V8WasmCode_Tier::TIER_LIFTOFF:
+    return "TIER_LIFTOFF";
+
+  case ::perfetto::protos::pbzero::V8WasmCode_Tier::TIER_TURBOFAN:
+    return "TIER_TURBOFAN";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_V8InternalCode {
+enum Type : int32_t {
+  TYPE_UNKNOWN = 0,
+  TYPE_BYTECODE_HANDLER = 1,
+  TYPE_FOR_TESTING = 2,
+  TYPE_BUILTIN = 3,
+  TYPE_WASM_FUNCTION = 4,
+  TYPE_WASM_TO_CAPI_FUNCTION = 5,
+  TYPE_WASM_TO_JS_FUNCTION = 6,
+  TYPE_JS_TO_WASM_FUNCTION = 7,
+  TYPE_JS_TO_JS_FUNCTION = 8,
+  TYPE_C_WASM_ENTRY = 9,
+};
+} // namespace perfetto_pbzero_enum_V8InternalCode
+using V8InternalCode_Type = perfetto_pbzero_enum_V8InternalCode::Type;
+
+
+constexpr V8InternalCode_Type V8InternalCode_Type_MIN = V8InternalCode_Type::TYPE_UNKNOWN;
+constexpr V8InternalCode_Type V8InternalCode_Type_MAX = V8InternalCode_Type::TYPE_C_WASM_ENTRY;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* V8InternalCode_Type_Name(::perfetto::protos::pbzero::V8InternalCode_Type value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::V8InternalCode_Type::TYPE_UNKNOWN:
+    return "TYPE_UNKNOWN";
+
+  case ::perfetto::protos::pbzero::V8InternalCode_Type::TYPE_BYTECODE_HANDLER:
+    return "TYPE_BYTECODE_HANDLER";
+
+  case ::perfetto::protos::pbzero::V8InternalCode_Type::TYPE_FOR_TESTING:
+    return "TYPE_FOR_TESTING";
+
+  case ::perfetto::protos::pbzero::V8InternalCode_Type::TYPE_BUILTIN:
+    return "TYPE_BUILTIN";
+
+  case ::perfetto::protos::pbzero::V8InternalCode_Type::TYPE_WASM_FUNCTION:
+    return "TYPE_WASM_FUNCTION";
+
+  case ::perfetto::protos::pbzero::V8InternalCode_Type::TYPE_WASM_TO_CAPI_FUNCTION:
+    return "TYPE_WASM_TO_CAPI_FUNCTION";
+
+  case ::perfetto::protos::pbzero::V8InternalCode_Type::TYPE_WASM_TO_JS_FUNCTION:
+    return "TYPE_WASM_TO_JS_FUNCTION";
+
+  case ::perfetto::protos::pbzero::V8InternalCode_Type::TYPE_JS_TO_WASM_FUNCTION:
+    return "TYPE_JS_TO_WASM_FUNCTION";
+
+  case ::perfetto::protos::pbzero::V8InternalCode_Type::TYPE_JS_TO_JS_FUNCTION:
+    return "TYPE_JS_TO_JS_FUNCTION";
+
+  case ::perfetto::protos::pbzero::V8InternalCode_Type::TYPE_C_WASM_ENTRY:
+    return "TYPE_C_WASM_ENTRY";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_V8JsCode {
+enum Tier : int32_t {
+  TIER_UNKNOWN = 0,
+  TIER_IGNITION = 1,
+  TIER_SPARKPLUG = 2,
+  TIER_MAGLEV = 3,
+  TIER_TURBOSHAFT = 4,
+  TIER_TURBOFAN = 5,
+};
+} // namespace perfetto_pbzero_enum_V8JsCode
+using V8JsCode_Tier = perfetto_pbzero_enum_V8JsCode::Tier;
+
+
+constexpr V8JsCode_Tier V8JsCode_Tier_MIN = V8JsCode_Tier::TIER_UNKNOWN;
+constexpr V8JsCode_Tier V8JsCode_Tier_MAX = V8JsCode_Tier::TIER_TURBOFAN;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* V8JsCode_Tier_Name(::perfetto::protos::pbzero::V8JsCode_Tier value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::V8JsCode_Tier::TIER_UNKNOWN:
+    return "TIER_UNKNOWN";
+
+  case ::perfetto::protos::pbzero::V8JsCode_Tier::TIER_IGNITION:
+    return "TIER_IGNITION";
+
+  case ::perfetto::protos::pbzero::V8JsCode_Tier::TIER_SPARKPLUG:
+    return "TIER_SPARKPLUG";
+
+  case ::perfetto::protos::pbzero::V8JsCode_Tier::TIER_MAGLEV:
+    return "TIER_MAGLEV";
+
+  case ::perfetto::protos::pbzero::V8JsCode_Tier::TIER_TURBOSHAFT:
+    return "TIER_TURBOSHAFT";
+
+  case ::perfetto::protos::pbzero::V8JsCode_Tier::TIER_TURBOFAN:
+    return "TIER_TURBOFAN";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_InternedV8JsFunction {
+enum Kind : int32_t {
+  KIND_UNKNOWN = 0,
+  KIND_NORMAL_FUNCTION = 1,
+  KIND_MODULE = 2,
+  KIND_ASYNC_MODULE = 3,
+  KIND_BASE_CONSTRUCTOR = 4,
+  KIND_DEFAULT_BASE_CONSTRUCTOR = 5,
+  KIND_DEFAULT_DERIVED_CONSTRUCTOR = 6,
+  KIND_DERIVED_CONSTRUCTOR = 7,
+  KIND_GETTER_FUNCTION = 8,
+  KIND_STATIC_GETTER_FUNCTION = 9,
+  KIND_SETTER_FUNCTION = 10,
+  KIND_STATIC_SETTER_FUNCTION = 11,
+  KIND_ARROW_FUNCTION = 12,
+  KIND_ASYNC_ARROW_FUNCTION = 13,
+  KIND_ASYNC_FUNCTION = 14,
+  KIND_ASYNC_CONCISE_METHOD = 15,
+  KIND_STATIC_ASYNC_CONCISE_METHOD = 16,
+  KIND_ASYNC_CONCISE_GENERATOR_METHOD = 17,
+  KIND_STATIC_ASYNC_CONCISE_GENERATOR_METHOD = 18,
+  KIND_ASYNC_GENERATOR_FUNCTION = 19,
+  KIND_GENERATOR_FUNCTION = 20,
+  KIND_CONCISE_GENERATOR_METHOD = 21,
+  KIND_STATIC_CONCISE_GENERATOR_METHOD = 22,
+  KIND_CONCISE_METHOD = 23,
+  KIND_STATIC_CONCISE_METHOD = 24,
+  KIND_CLASS_MEMBERS_INITIALIZER_FUNCTION = 25,
+  KIND_CLASS_STATIC_INITIALIZER_FUNCTION = 26,
+  KIND_INVALID = 27,
+};
+} // namespace perfetto_pbzero_enum_InternedV8JsFunction
+using InternedV8JsFunction_Kind = perfetto_pbzero_enum_InternedV8JsFunction::Kind;
+
+
+constexpr InternedV8JsFunction_Kind InternedV8JsFunction_Kind_MIN = InternedV8JsFunction_Kind::KIND_UNKNOWN;
+constexpr InternedV8JsFunction_Kind InternedV8JsFunction_Kind_MAX = InternedV8JsFunction_Kind::KIND_INVALID;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* InternedV8JsFunction_Kind_Name(::perfetto::protos::pbzero::InternedV8JsFunction_Kind value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_UNKNOWN:
+    return "KIND_UNKNOWN";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_NORMAL_FUNCTION:
+    return "KIND_NORMAL_FUNCTION";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_MODULE:
+    return "KIND_MODULE";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_ASYNC_MODULE:
+    return "KIND_ASYNC_MODULE";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_BASE_CONSTRUCTOR:
+    return "KIND_BASE_CONSTRUCTOR";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_DEFAULT_BASE_CONSTRUCTOR:
+    return "KIND_DEFAULT_BASE_CONSTRUCTOR";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_DEFAULT_DERIVED_CONSTRUCTOR:
+    return "KIND_DEFAULT_DERIVED_CONSTRUCTOR";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_DERIVED_CONSTRUCTOR:
+    return "KIND_DERIVED_CONSTRUCTOR";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_GETTER_FUNCTION:
+    return "KIND_GETTER_FUNCTION";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_STATIC_GETTER_FUNCTION:
+    return "KIND_STATIC_GETTER_FUNCTION";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_SETTER_FUNCTION:
+    return "KIND_SETTER_FUNCTION";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_STATIC_SETTER_FUNCTION:
+    return "KIND_STATIC_SETTER_FUNCTION";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_ARROW_FUNCTION:
+    return "KIND_ARROW_FUNCTION";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_ASYNC_ARROW_FUNCTION:
+    return "KIND_ASYNC_ARROW_FUNCTION";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_ASYNC_FUNCTION:
+    return "KIND_ASYNC_FUNCTION";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_ASYNC_CONCISE_METHOD:
+    return "KIND_ASYNC_CONCISE_METHOD";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_STATIC_ASYNC_CONCISE_METHOD:
+    return "KIND_STATIC_ASYNC_CONCISE_METHOD";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_ASYNC_CONCISE_GENERATOR_METHOD:
+    return "KIND_ASYNC_CONCISE_GENERATOR_METHOD";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_STATIC_ASYNC_CONCISE_GENERATOR_METHOD:
+    return "KIND_STATIC_ASYNC_CONCISE_GENERATOR_METHOD";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_ASYNC_GENERATOR_FUNCTION:
+    return "KIND_ASYNC_GENERATOR_FUNCTION";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_GENERATOR_FUNCTION:
+    return "KIND_GENERATOR_FUNCTION";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_CONCISE_GENERATOR_METHOD:
+    return "KIND_CONCISE_GENERATOR_METHOD";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_STATIC_CONCISE_GENERATOR_METHOD:
+    return "KIND_STATIC_CONCISE_GENERATOR_METHOD";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_CONCISE_METHOD:
+    return "KIND_CONCISE_METHOD";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_STATIC_CONCISE_METHOD:
+    return "KIND_STATIC_CONCISE_METHOD";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_CLASS_MEMBERS_INITIALIZER_FUNCTION:
+    return "KIND_CLASS_MEMBERS_INITIALIZER_FUNCTION";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_CLASS_STATIC_INITIALIZER_FUNCTION:
+    return "KIND_CLASS_STATIC_INITIALIZER_FUNCTION";
+
+  case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_INVALID:
+    return "KIND_INVALID";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_InternedV8JsScript {
+enum Type : int32_t {
+  TYPE_UNKNOWN = 0,
+  TYPE_NORMAL = 1,
+  TYPE_EVAL = 2,
+  TYPE_MODULE = 3,
+  TYPE_NATIVE = 4,
+  TYPE_EXTENSION = 5,
+  TYPE_INSPECTOR = 6,
+};
+} // namespace perfetto_pbzero_enum_InternedV8JsScript
+using InternedV8JsScript_Type = perfetto_pbzero_enum_InternedV8JsScript::Type;
+
+
+constexpr InternedV8JsScript_Type InternedV8JsScript_Type_MIN = InternedV8JsScript_Type::TYPE_UNKNOWN;
+constexpr InternedV8JsScript_Type InternedV8JsScript_Type_MAX = InternedV8JsScript_Type::TYPE_INSPECTOR;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* InternedV8JsScript_Type_Name(::perfetto::protos::pbzero::InternedV8JsScript_Type value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::InternedV8JsScript_Type::TYPE_UNKNOWN:
+    return "TYPE_UNKNOWN";
+
+  case ::perfetto::protos::pbzero::InternedV8JsScript_Type::TYPE_NORMAL:
+    return "TYPE_NORMAL";
+
+  case ::perfetto::protos::pbzero::InternedV8JsScript_Type::TYPE_EVAL:
+    return "TYPE_EVAL";
+
+  case ::perfetto::protos::pbzero::InternedV8JsScript_Type::TYPE_MODULE:
+    return "TYPE_MODULE";
+
+  case ::perfetto::protos::pbzero::InternedV8JsScript_Type::TYPE_NATIVE:
+    return "TYPE_NATIVE";
+
+  case ::perfetto::protos::pbzero::InternedV8JsScript_Type::TYPE_EXTENSION:
+    return "TYPE_EXTENSION";
+
+  case ::perfetto::protos::pbzero::InternedV8JsScript_Type::TYPE_INSPECTOR:
+    return "TYPE_INSPECTOR";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class V8CodeDefaults_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  V8CodeDefaults_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit V8CodeDefaults_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit V8CodeDefaults_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_tid() const { return at<1>().valid(); }
+  uint32_t tid() const { return at<1>().as_uint32(); }
+};
+
+class V8CodeDefaults : public ::protozero::Message {
+ public:
+  using Decoder = V8CodeDefaults_Decoder;
+  enum : int32_t {
+    kTidFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.V8CodeDefaults"; }
+
+
+  using FieldMetadata_Tid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V8CodeDefaults>;
+
+  static constexpr FieldMetadata_Tid kTid{};
+  void set_tid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class V8CodeMove_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
+ public:
+  V8CodeMove_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit V8CodeMove_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit V8CodeMove_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_isolate_iid() const { return at<1>().valid(); }
+  uint64_t isolate_iid() const { return at<1>().as_uint64(); }
+  bool has_tid() const { return at<2>().valid(); }
+  uint32_t tid() const { return at<2>().as_uint32(); }
+  bool has_from_instruction_start_address() const { return at<3>().valid(); }
+  uint64_t from_instruction_start_address() const { return at<3>().as_uint64(); }
+  bool has_to_instruction_start_address() const { return at<4>().valid(); }
+  uint64_t to_instruction_start_address() const { return at<4>().as_uint64(); }
+  bool has_instruction_size_bytes() const { return at<5>().valid(); }
+  uint64_t instruction_size_bytes() const { return at<5>().as_uint64(); }
+  bool has_to_machine_code() const { return at<6>().valid(); }
+  ::protozero::ConstBytes to_machine_code() const { return at<6>().as_bytes(); }
+  bool has_to_bytecode() const { return at<7>().valid(); }
+  ::protozero::ConstBytes to_bytecode() const { return at<7>().as_bytes(); }
+};
+
+class V8CodeMove : public ::protozero::Message {
+ public:
+  using Decoder = V8CodeMove_Decoder;
+  enum : int32_t {
+    kIsolateIidFieldNumber = 1,
+    kTidFieldNumber = 2,
+    kFromInstructionStartAddressFieldNumber = 3,
+    kToInstructionStartAddressFieldNumber = 4,
+    kInstructionSizeBytesFieldNumber = 5,
+    kToMachineCodeFieldNumber = 6,
+    kToBytecodeFieldNumber = 7,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.V8CodeMove"; }
+
+
+  using FieldMetadata_IsolateIid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      V8CodeMove>;
+
+  static constexpr FieldMetadata_IsolateIid kIsolateIid{};
+  void set_isolate_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsolateIid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Tid =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V8CodeMove>;
+
+  static constexpr FieldMetadata_Tid kTid{};
+  void set_tid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FromInstructionStartAddress =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      V8CodeMove>;
+
+  static constexpr FieldMetadata_FromInstructionStartAddress kFromInstructionStartAddress{};
+  void set_from_instruction_start_address(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FromInstructionStartAddress::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ToInstructionStartAddress =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      V8CodeMove>;
+
+  static constexpr FieldMetadata_ToInstructionStartAddress kToInstructionStartAddress{};
+  void set_to_instruction_start_address(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ToInstructionStartAddress::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_InstructionSizeBytes =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      V8CodeMove>;
+
+  static constexpr FieldMetadata_InstructionSizeBytes kInstructionSizeBytes{};
+  void set_instruction_size_bytes(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InstructionSizeBytes::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ToMachineCode =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      V8CodeMove>;
+
+  static constexpr FieldMetadata_ToMachineCode kToMachineCode{};
+  void set_to_machine_code(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_ToMachineCode::kFieldId, data, size);
+  }
+  void set_to_machine_code(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_ToMachineCode::kFieldId, bytes.data, bytes.size);
+  }
+  void set_to_machine_code(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ToMachineCode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ToBytecode =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      V8CodeMove>;
+
+  static constexpr FieldMetadata_ToBytecode kToBytecode{};
+  void set_to_bytecode(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_ToBytecode::kFieldId, data, size);
+  }
+  void set_to_bytecode(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_ToBytecode::kFieldId, bytes.data, bytes.size);
+  }
+  void set_to_bytecode(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ToBytecode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class V8RegExpCode_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
+ public:
+  V8RegExpCode_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit V8RegExpCode_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit V8RegExpCode_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_v8_isolate_iid() const { return at<1>().valid(); }
+  uint64_t v8_isolate_iid() const { return at<1>().as_uint64(); }
+  bool has_tid() const { return at<2>().valid(); }
+  uint32_t tid() const { return at<2>().as_uint32(); }
+  bool has_pattern() const { return at<3>().valid(); }
+  ::protozero::ConstBytes pattern() const { return at<3>().as_bytes(); }
+  bool has_instruction_start() const { return at<4>().valid(); }
+  uint64_t instruction_start() const { return at<4>().as_uint64(); }
+  bool has_instruction_size_bytes() const { return at<5>().valid(); }
+  uint64_t instruction_size_bytes() const { return at<5>().as_uint64(); }
+  bool has_machine_code() const { return at<6>().valid(); }
+  ::protozero::ConstBytes machine_code() const { return at<6>().as_bytes(); }
+};
+
+class V8RegExpCode : public ::protozero::Message {
+ public:
+  using Decoder = V8RegExpCode_Decoder;
+  enum : int32_t {
+    kV8IsolateIidFieldNumber = 1,
+    kTidFieldNumber = 2,
+    kPatternFieldNumber = 3,
+    kInstructionStartFieldNumber = 4,
+    kInstructionSizeBytesFieldNumber = 5,
+    kMachineCodeFieldNumber = 6,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.V8RegExpCode"; }
+
+
+  using FieldMetadata_V8IsolateIid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      V8RegExpCode>;
+
+  static constexpr FieldMetadata_V8IsolateIid kV8IsolateIid{};
+  void set_v8_isolate_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_V8IsolateIid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Tid =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V8RegExpCode>;
+
+  static constexpr FieldMetadata_Tid kTid{};
+  void set_tid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Pattern =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      V8String,
+      V8RegExpCode>;
+
+  static constexpr FieldMetadata_Pattern kPattern{};
+  template <typename T = V8String> T* set_pattern() {
+    return BeginNestedMessage<T>(3);
+  }
+
+
+  using FieldMetadata_InstructionStart =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      V8RegExpCode>;
+
+  static constexpr FieldMetadata_InstructionStart kInstructionStart{};
+  void set_instruction_start(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InstructionStart::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_InstructionSizeBytes =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      V8RegExpCode>;
+
+  static constexpr FieldMetadata_InstructionSizeBytes kInstructionSizeBytes{};
+  void set_instruction_size_bytes(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InstructionSizeBytes::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MachineCode =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      V8RegExpCode>;
+
+  static constexpr FieldMetadata_MachineCode kMachineCode{};
+  void set_machine_code(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_MachineCode::kFieldId, data, size);
+  }
+  void set_machine_code(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_MachineCode::kFieldId, bytes.data, bytes.size);
+  }
+  void set_machine_code(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_MachineCode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class V8WasmCode_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9> {
+ public:
+  V8WasmCode_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit V8WasmCode_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit V8WasmCode_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_v8_isolate_iid() const { return at<1>().valid(); }
+  uint64_t v8_isolate_iid() const { return at<1>().as_uint64(); }
+  bool has_tid() const { return at<2>().valid(); }
+  uint32_t tid() const { return at<2>().as_uint32(); }
+  bool has_v8_wasm_script_iid() const { return at<3>().valid(); }
+  uint64_t v8_wasm_script_iid() const { return at<3>().as_uint64(); }
+  bool has_function_name() const { return at<4>().valid(); }
+  ::protozero::ConstChars function_name() const { return at<4>().as_string(); }
+  bool has_tier() const { return at<5>().valid(); }
+  int32_t tier() const { return at<5>().as_int32(); }
+  bool has_code_offset_in_module() const { return at<6>().valid(); }
+  int32_t code_offset_in_module() const { return at<6>().as_int32(); }
+  bool has_instruction_start() const { return at<7>().valid(); }
+  uint64_t instruction_start() const { return at<7>().as_uint64(); }
+  bool has_instruction_size_bytes() const { return at<8>().valid(); }
+  uint64_t instruction_size_bytes() const { return at<8>().as_uint64(); }
+  bool has_machine_code() const { return at<9>().valid(); }
+  ::protozero::ConstBytes machine_code() const { return at<9>().as_bytes(); }
+};
+
+class V8WasmCode : public ::protozero::Message {
+ public:
+  using Decoder = V8WasmCode_Decoder;
+  enum : int32_t {
+    kV8IsolateIidFieldNumber = 1,
+    kTidFieldNumber = 2,
+    kV8WasmScriptIidFieldNumber = 3,
+    kFunctionNameFieldNumber = 4,
+    kTierFieldNumber = 5,
+    kCodeOffsetInModuleFieldNumber = 6,
+    kInstructionStartFieldNumber = 7,
+    kInstructionSizeBytesFieldNumber = 8,
+    kMachineCodeFieldNumber = 9,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.V8WasmCode"; }
+
+
+  using Tier = ::perfetto::protos::pbzero::V8WasmCode_Tier;
+  static inline const char* Tier_Name(Tier value) {
+    return ::perfetto::protos::pbzero::V8WasmCode_Tier_Name(value);
+  }
+  static inline const Tier TIER_UNKNOWN = Tier::TIER_UNKNOWN;
+  static inline const Tier TIER_LIFTOFF = Tier::TIER_LIFTOFF;
+  static inline const Tier TIER_TURBOFAN = Tier::TIER_TURBOFAN;
+
+  using FieldMetadata_V8IsolateIid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      V8WasmCode>;
+
+  static constexpr FieldMetadata_V8IsolateIid kV8IsolateIid{};
+  void set_v8_isolate_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_V8IsolateIid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Tid =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V8WasmCode>;
+
+  static constexpr FieldMetadata_Tid kTid{};
+  void set_tid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_V8WasmScriptIid =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      V8WasmCode>;
+
+  static constexpr FieldMetadata_V8WasmScriptIid kV8WasmScriptIid{};
+  void set_v8_wasm_script_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_V8WasmScriptIid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FunctionName =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      V8WasmCode>;
+
+  static constexpr FieldMetadata_FunctionName kFunctionName{};
+  void set_function_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_FunctionName::kFieldId, data, size);
+  }
+  void set_function_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_FunctionName::kFieldId, chars.data, chars.size);
+  }
+  void set_function_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_FunctionName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Tier =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      V8WasmCode_Tier,
+      V8WasmCode>;
+
+  static constexpr FieldMetadata_Tier kTier{};
+  void set_tier(V8WasmCode_Tier value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tier::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CodeOffsetInModule =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      V8WasmCode>;
+
+  static constexpr FieldMetadata_CodeOffsetInModule kCodeOffsetInModule{};
+  void set_code_offset_in_module(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CodeOffsetInModule::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_InstructionStart =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      V8WasmCode>;
+
+  static constexpr FieldMetadata_InstructionStart kInstructionStart{};
+  void set_instruction_start(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InstructionStart::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_InstructionSizeBytes =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      V8WasmCode>;
+
+  static constexpr FieldMetadata_InstructionSizeBytes kInstructionSizeBytes{};
+  void set_instruction_size_bytes(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InstructionSizeBytes::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MachineCode =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      V8WasmCode>;
+
+  static constexpr FieldMetadata_MachineCode kMachineCode{};
+  void set_machine_code(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_MachineCode::kFieldId, data, size);
+  }
+  void set_machine_code(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_MachineCode::kFieldId, bytes.data, bytes.size);
+  }
+  void set_machine_code(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_MachineCode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class V8InternalCode_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
+ public:
+  V8InternalCode_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit V8InternalCode_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit V8InternalCode_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_v8_isolate_iid() const { return at<1>().valid(); }
+  uint64_t v8_isolate_iid() const { return at<1>().as_uint64(); }
+  bool has_tid() const { return at<2>().valid(); }
+  uint32_t tid() const { return at<2>().as_uint32(); }
+  bool has_name() const { return at<3>().valid(); }
+  ::protozero::ConstChars name() const { return at<3>().as_string(); }
+  bool has_type() const { return at<4>().valid(); }
+  int32_t type() const { return at<4>().as_int32(); }
+  bool has_builtin_id() const { return at<5>().valid(); }
+  int32_t builtin_id() const { return at<5>().as_int32(); }
+  bool has_instruction_start() const { return at<6>().valid(); }
+  uint64_t instruction_start() const { return at<6>().as_uint64(); }
+  bool has_instruction_size_bytes() const { return at<7>().valid(); }
+  uint64_t instruction_size_bytes() const { return at<7>().as_uint64(); }
+  bool has_machine_code() const { return at<8>().valid(); }
+  ::protozero::ConstBytes machine_code() const { return at<8>().as_bytes(); }
+};
+
+class V8InternalCode : public ::protozero::Message {
+ public:
+  using Decoder = V8InternalCode_Decoder;
+  enum : int32_t {
+    kV8IsolateIidFieldNumber = 1,
+    kTidFieldNumber = 2,
+    kNameFieldNumber = 3,
+    kTypeFieldNumber = 4,
+    kBuiltinIdFieldNumber = 5,
+    kInstructionStartFieldNumber = 6,
+    kInstructionSizeBytesFieldNumber = 7,
+    kMachineCodeFieldNumber = 8,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.V8InternalCode"; }
+
+
+  using Type = ::perfetto::protos::pbzero::V8InternalCode_Type;
+  static inline const char* Type_Name(Type value) {
+    return ::perfetto::protos::pbzero::V8InternalCode_Type_Name(value);
+  }
+  static inline const Type TYPE_UNKNOWN = Type::TYPE_UNKNOWN;
+  static inline const Type TYPE_BYTECODE_HANDLER = Type::TYPE_BYTECODE_HANDLER;
+  static inline const Type TYPE_FOR_TESTING = Type::TYPE_FOR_TESTING;
+  static inline const Type TYPE_BUILTIN = Type::TYPE_BUILTIN;
+  static inline const Type TYPE_WASM_FUNCTION = Type::TYPE_WASM_FUNCTION;
+  static inline const Type TYPE_WASM_TO_CAPI_FUNCTION = Type::TYPE_WASM_TO_CAPI_FUNCTION;
+  static inline const Type TYPE_WASM_TO_JS_FUNCTION = Type::TYPE_WASM_TO_JS_FUNCTION;
+  static inline const Type TYPE_JS_TO_WASM_FUNCTION = Type::TYPE_JS_TO_WASM_FUNCTION;
+  static inline const Type TYPE_JS_TO_JS_FUNCTION = Type::TYPE_JS_TO_JS_FUNCTION;
+  static inline const Type TYPE_C_WASM_ENTRY = Type::TYPE_C_WASM_ENTRY;
+
+  using FieldMetadata_V8IsolateIid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      V8InternalCode>;
+
+  static constexpr FieldMetadata_V8IsolateIid kV8IsolateIid{};
+  void set_v8_isolate_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_V8IsolateIid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Tid =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V8InternalCode>;
+
+  static constexpr FieldMetadata_Tid kTid{};
+  void set_tid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      V8InternalCode>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Type =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      V8InternalCode_Type,
+      V8InternalCode>;
+
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(V8InternalCode_Type value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BuiltinId =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      V8InternalCode>;
+
+  static constexpr FieldMetadata_BuiltinId kBuiltinId{};
+  void set_builtin_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BuiltinId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_InstructionStart =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      V8InternalCode>;
+
+  static constexpr FieldMetadata_InstructionStart kInstructionStart{};
+  void set_instruction_start(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InstructionStart::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_InstructionSizeBytes =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      V8InternalCode>;
+
+  static constexpr FieldMetadata_InstructionSizeBytes kInstructionSizeBytes{};
+  void set_instruction_size_bytes(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InstructionSizeBytes::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MachineCode =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      V8InternalCode>;
+
+  static constexpr FieldMetadata_MachineCode kMachineCode{};
+  void set_machine_code(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_MachineCode::kFieldId, data, size);
+  }
+  void set_machine_code(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_MachineCode::kFieldId, bytes.data, bytes.size);
+  }
+  void set_machine_code(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_MachineCode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class V8JsCode_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11> {
+ public:
+  V8JsCode_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit V8JsCode_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit V8JsCode_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_v8_isolate_iid() const { return at<1>().valid(); }
+  uint64_t v8_isolate_iid() const { return at<1>().as_uint64(); }
+  bool has_tid() const { return at<2>().valid(); }
+  uint32_t tid() const { return at<2>().as_uint32(); }
+  bool has_v8_js_function_iid() const { return at<3>().valid(); }
+  uint64_t v8_js_function_iid() const { return at<3>().as_uint64(); }
+  bool has_tier() const { return at<4>().valid(); }
+  int32_t tier() const { return at<4>().as_int32(); }
+  bool has_instruction_start() const { return at<5>().valid(); }
+  uint64_t instruction_start() const { return at<5>().as_uint64(); }
+  bool has_instruction_size_bytes() const { return at<6>().valid(); }
+  uint64_t instruction_size_bytes() const { return at<6>().as_uint64(); }
+  bool has_machine_code() const { return at<7>().valid(); }
+  ::protozero::ConstBytes machine_code() const { return at<7>().as_bytes(); }
+  bool has_bytecode() const { return at<8>().valid(); }
+  ::protozero::ConstBytes bytecode() const { return at<8>().as_bytes(); }
+  bool has_source_positions() const { return at<9>().valid(); }
+  ::protozero::ConstBytes source_positions() const { return at<9>().as_bytes(); }
+  bool has_bytecode_positions() const { return at<10>().valid(); }
+  ::protozero::ConstBytes bytecode_positions() const { return at<10>().as_bytes(); }
+  bool has_inlined_bytecode_positions() const { return at<11>().valid(); }
+  ::protozero::ConstBytes inlined_bytecode_positions() const { return at<11>().as_bytes(); }
+};
+
+class V8JsCode : public ::protozero::Message {
+ public:
+  using Decoder = V8JsCode_Decoder;
+  enum : int32_t {
+    kV8IsolateIidFieldNumber = 1,
+    kTidFieldNumber = 2,
+    kV8JsFunctionIidFieldNumber = 3,
+    kTierFieldNumber = 4,
+    kInstructionStartFieldNumber = 5,
+    kInstructionSizeBytesFieldNumber = 6,
+    kMachineCodeFieldNumber = 7,
+    kBytecodeFieldNumber = 8,
+    kSourcePositionsFieldNumber = 9,
+    kBytecodePositionsFieldNumber = 10,
+    kInlinedBytecodePositionsFieldNumber = 11,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.V8JsCode"; }
+
+
+  using Tier = ::perfetto::protos::pbzero::V8JsCode_Tier;
+  static inline const char* Tier_Name(Tier value) {
+    return ::perfetto::protos::pbzero::V8JsCode_Tier_Name(value);
+  }
+  static inline const Tier TIER_UNKNOWN = Tier::TIER_UNKNOWN;
+  static inline const Tier TIER_IGNITION = Tier::TIER_IGNITION;
+  static inline const Tier TIER_SPARKPLUG = Tier::TIER_SPARKPLUG;
+  static inline const Tier TIER_MAGLEV = Tier::TIER_MAGLEV;
+  static inline const Tier TIER_TURBOSHAFT = Tier::TIER_TURBOSHAFT;
+  static inline const Tier TIER_TURBOFAN = Tier::TIER_TURBOFAN;
+
+  using FieldMetadata_V8IsolateIid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      V8JsCode>;
+
+  static constexpr FieldMetadata_V8IsolateIid kV8IsolateIid{};
+  void set_v8_isolate_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_V8IsolateIid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Tid =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V8JsCode>;
+
+  static constexpr FieldMetadata_Tid kTid{};
+  void set_tid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_V8JsFunctionIid =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      V8JsCode>;
+
+  static constexpr FieldMetadata_V8JsFunctionIid kV8JsFunctionIid{};
+  void set_v8_js_function_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_V8JsFunctionIid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Tier =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      V8JsCode_Tier,
+      V8JsCode>;
+
+  static constexpr FieldMetadata_Tier kTier{};
+  void set_tier(V8JsCode_Tier value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tier::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_InstructionStart =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      V8JsCode>;
+
+  static constexpr FieldMetadata_InstructionStart kInstructionStart{};
+  void set_instruction_start(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InstructionStart::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_InstructionSizeBytes =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      V8JsCode>;
+
+  static constexpr FieldMetadata_InstructionSizeBytes kInstructionSizeBytes{};
+  void set_instruction_size_bytes(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InstructionSizeBytes::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MachineCode =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      V8JsCode>;
+
+  static constexpr FieldMetadata_MachineCode kMachineCode{};
+  void set_machine_code(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_MachineCode::kFieldId, data, size);
+  }
+  void set_machine_code(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_MachineCode::kFieldId, bytes.data, bytes.size);
+  }
+  void set_machine_code(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_MachineCode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Bytecode =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      V8JsCode>;
+
+  static constexpr FieldMetadata_Bytecode kBytecode{};
+  void set_bytecode(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_Bytecode::kFieldId, data, size);
+  }
+  void set_bytecode(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_Bytecode::kFieldId, bytes.data, bytes.size);
+  }
+  void set_bytecode(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Bytecode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SourcePositions =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      V8JsCode>;
+
+  static constexpr FieldMetadata_SourcePositions kSourcePositions{};
+  void set_source_positions(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_SourcePositions::kFieldId, data, size);
+  }
+  void set_source_positions(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_SourcePositions::kFieldId, bytes.data, bytes.size);
+  }
+  void set_source_positions(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_SourcePositions::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BytecodePositions =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      V8JsCode>;
+
+  static constexpr FieldMetadata_BytecodePositions kBytecodePositions{};
+  void set_bytecode_positions(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_BytecodePositions::kFieldId, data, size);
+  }
+  void set_bytecode_positions(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_BytecodePositions::kFieldId, bytes.data, bytes.size);
+  }
+  void set_bytecode_positions(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_BytecodePositions::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_InlinedBytecodePositions =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      V8JsCode>;
+
+  static constexpr FieldMetadata_InlinedBytecodePositions kInlinedBytecodePositions{};
+  void set_inlined_bytecode_positions(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_InlinedBytecodePositions::kFieldId, data, size);
+  }
+  void set_inlined_bytecode_positions(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_InlinedBytecodePositions::kFieldId, bytes.data, bytes.size);
+  }
+  void set_inlined_bytecode_positions(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_InlinedBytecodePositions::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class InternedV8Isolate_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
+ public:
+  InternedV8Isolate_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit InternedV8Isolate_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit InternedV8Isolate_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_iid() const { return at<1>().valid(); }
+  uint64_t iid() const { return at<1>().as_uint64(); }
+  bool has_pid() const { return at<2>().valid(); }
+  uint32_t pid() const { return at<2>().as_uint32(); }
+  bool has_isolate_id() const { return at<3>().valid(); }
+  int32_t isolate_id() const { return at<3>().as_int32(); }
+  bool has_code_range() const { return at<4>().valid(); }
+  ::protozero::ConstBytes code_range() const { return at<4>().as_bytes(); }
+  bool has_embedded_blob_code_start_address() const { return at<5>().valid(); }
+  uint64_t embedded_blob_code_start_address() const { return at<5>().as_uint64(); }
+  bool has_embedded_blob_code_size() const { return at<6>().valid(); }
+  uint64_t embedded_blob_code_size() const { return at<6>().as_uint64(); }
+};
+
+class InternedV8Isolate : public ::protozero::Message {
+ public:
+  using Decoder = InternedV8Isolate_Decoder;
+  enum : int32_t {
+    kIidFieldNumber = 1,
+    kPidFieldNumber = 2,
+    kIsolateIdFieldNumber = 3,
+    kCodeRangeFieldNumber = 4,
+    kEmbeddedBlobCodeStartAddressFieldNumber = 5,
+    kEmbeddedBlobCodeSizeFieldNumber = 6,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.InternedV8Isolate"; }
+
+  using CodeRange = ::perfetto::protos::pbzero::InternedV8Isolate_CodeRange;
+
+  using FieldMetadata_Iid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      InternedV8Isolate>;
+
+  static constexpr FieldMetadata_Iid kIid{};
+  void set_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Pid =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      InternedV8Isolate>;
+
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IsolateId =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      InternedV8Isolate>;
+
+  static constexpr FieldMetadata_IsolateId kIsolateId{};
+  void set_isolate_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsolateId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CodeRange =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      InternedV8Isolate_CodeRange,
+      InternedV8Isolate>;
+
+  static constexpr FieldMetadata_CodeRange kCodeRange{};
+  template <typename T = InternedV8Isolate_CodeRange> T* set_code_range() {
+    return BeginNestedMessage<T>(4);
+  }
+
+
+  using FieldMetadata_EmbeddedBlobCodeStartAddress =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      InternedV8Isolate>;
+
+  static constexpr FieldMetadata_EmbeddedBlobCodeStartAddress kEmbeddedBlobCodeStartAddress{};
+  void set_embedded_blob_code_start_address(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EmbeddedBlobCodeStartAddress::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_EmbeddedBlobCodeSize =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      InternedV8Isolate>;
+
+  static constexpr FieldMetadata_EmbeddedBlobCodeSize kEmbeddedBlobCodeSize{};
+  void set_embedded_blob_code_size(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EmbeddedBlobCodeSize::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class InternedV8Isolate_CodeRange_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  InternedV8Isolate_CodeRange_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit InternedV8Isolate_CodeRange_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit InternedV8Isolate_CodeRange_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_base_address() const { return at<1>().valid(); }
+  uint64_t base_address() const { return at<1>().as_uint64(); }
+  bool has_size() const { return at<2>().valid(); }
+  uint64_t size() const { return at<2>().as_uint64(); }
+  bool has_embedded_blob_code_copy_start_address() const { return at<3>().valid(); }
+  uint64_t embedded_blob_code_copy_start_address() const { return at<3>().as_uint64(); }
+  bool has_is_process_wide() const { return at<4>().valid(); }
+  bool is_process_wide() const { return at<4>().as_bool(); }
+};
+
+class InternedV8Isolate_CodeRange : public ::protozero::Message {
+ public:
+  using Decoder = InternedV8Isolate_CodeRange_Decoder;
+  enum : int32_t {
+    kBaseAddressFieldNumber = 1,
+    kSizeFieldNumber = 2,
+    kEmbeddedBlobCodeCopyStartAddressFieldNumber = 3,
+    kIsProcessWideFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.InternedV8Isolate.CodeRange"; }
+
+
+  using FieldMetadata_BaseAddress =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      InternedV8Isolate_CodeRange>;
+
+  static constexpr FieldMetadata_BaseAddress kBaseAddress{};
+  void set_base_address(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BaseAddress::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Size =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      InternedV8Isolate_CodeRange>;
+
+  static constexpr FieldMetadata_Size kSize{};
+  void set_size(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_EmbeddedBlobCodeCopyStartAddress =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      InternedV8Isolate_CodeRange>;
+
+  static constexpr FieldMetadata_EmbeddedBlobCodeCopyStartAddress kEmbeddedBlobCodeCopyStartAddress{};
+  void set_embedded_blob_code_copy_start_address(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EmbeddedBlobCodeCopyStartAddress::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IsProcessWide =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      InternedV8Isolate_CodeRange>;
+
+  static constexpr FieldMetadata_IsProcessWide kIsProcessWide{};
+  void set_is_process_wide(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsProcessWide::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class InternedV8JsFunction_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
+ public:
+  InternedV8JsFunction_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit InternedV8JsFunction_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit InternedV8JsFunction_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_iid() const { return at<1>().valid(); }
+  uint64_t iid() const { return at<1>().as_uint64(); }
+  bool has_v8_js_function_name_iid() const { return at<2>().valid(); }
+  uint64_t v8_js_function_name_iid() const { return at<2>().as_uint64(); }
+  bool has_v8_js_script_iid() const { return at<3>().valid(); }
+  uint64_t v8_js_script_iid() const { return at<3>().as_uint64(); }
+  bool has_is_toplevel() const { return at<4>().valid(); }
+  bool is_toplevel() const { return at<4>().as_bool(); }
+  bool has_kind() const { return at<5>().valid(); }
+  int32_t kind() const { return at<5>().as_int32(); }
+  bool has_byte_offset() const { return at<6>().valid(); }
+  uint32_t byte_offset() const { return at<6>().as_uint32(); }
+  bool has_line() const { return at<7>().valid(); }
+  uint32_t line() const { return at<7>().as_uint32(); }
+  bool has_column() const { return at<8>().valid(); }
+  uint32_t column() const { return at<8>().as_uint32(); }
+};
+
+class InternedV8JsFunction : public ::protozero::Message {
+ public:
+  using Decoder = InternedV8JsFunction_Decoder;
+  enum : int32_t {
+    kIidFieldNumber = 1,
+    kV8JsFunctionNameIidFieldNumber = 2,
+    kV8JsScriptIidFieldNumber = 3,
+    kIsToplevelFieldNumber = 4,
+    kKindFieldNumber = 5,
+    kByteOffsetFieldNumber = 6,
+    kLineFieldNumber = 7,
+    kColumnFieldNumber = 8,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.InternedV8JsFunction"; }
+
+
+  using Kind = ::perfetto::protos::pbzero::InternedV8JsFunction_Kind;
+  static inline const char* Kind_Name(Kind value) {
+    return ::perfetto::protos::pbzero::InternedV8JsFunction_Kind_Name(value);
+  }
+  static inline const Kind KIND_UNKNOWN = Kind::KIND_UNKNOWN;
+  static inline const Kind KIND_NORMAL_FUNCTION = Kind::KIND_NORMAL_FUNCTION;
+  static inline const Kind KIND_MODULE = Kind::KIND_MODULE;
+  static inline const Kind KIND_ASYNC_MODULE = Kind::KIND_ASYNC_MODULE;
+  static inline const Kind KIND_BASE_CONSTRUCTOR = Kind::KIND_BASE_CONSTRUCTOR;
+  static inline const Kind KIND_DEFAULT_BASE_CONSTRUCTOR = Kind::KIND_DEFAULT_BASE_CONSTRUCTOR;
+  static inline const Kind KIND_DEFAULT_DERIVED_CONSTRUCTOR = Kind::KIND_DEFAULT_DERIVED_CONSTRUCTOR;
+  static inline const Kind KIND_DERIVED_CONSTRUCTOR = Kind::KIND_DERIVED_CONSTRUCTOR;
+  static inline const Kind KIND_GETTER_FUNCTION = Kind::KIND_GETTER_FUNCTION;
+  static inline const Kind KIND_STATIC_GETTER_FUNCTION = Kind::KIND_STATIC_GETTER_FUNCTION;
+  static inline const Kind KIND_SETTER_FUNCTION = Kind::KIND_SETTER_FUNCTION;
+  static inline const Kind KIND_STATIC_SETTER_FUNCTION = Kind::KIND_STATIC_SETTER_FUNCTION;
+  static inline const Kind KIND_ARROW_FUNCTION = Kind::KIND_ARROW_FUNCTION;
+  static inline const Kind KIND_ASYNC_ARROW_FUNCTION = Kind::KIND_ASYNC_ARROW_FUNCTION;
+  static inline const Kind KIND_ASYNC_FUNCTION = Kind::KIND_ASYNC_FUNCTION;
+  static inline const Kind KIND_ASYNC_CONCISE_METHOD = Kind::KIND_ASYNC_CONCISE_METHOD;
+  static inline const Kind KIND_STATIC_ASYNC_CONCISE_METHOD = Kind::KIND_STATIC_ASYNC_CONCISE_METHOD;
+  static inline const Kind KIND_ASYNC_CONCISE_GENERATOR_METHOD = Kind::KIND_ASYNC_CONCISE_GENERATOR_METHOD;
+  static inline const Kind KIND_STATIC_ASYNC_CONCISE_GENERATOR_METHOD = Kind::KIND_STATIC_ASYNC_CONCISE_GENERATOR_METHOD;
+  static inline const Kind KIND_ASYNC_GENERATOR_FUNCTION = Kind::KIND_ASYNC_GENERATOR_FUNCTION;
+  static inline const Kind KIND_GENERATOR_FUNCTION = Kind::KIND_GENERATOR_FUNCTION;
+  static inline const Kind KIND_CONCISE_GENERATOR_METHOD = Kind::KIND_CONCISE_GENERATOR_METHOD;
+  static inline const Kind KIND_STATIC_CONCISE_GENERATOR_METHOD = Kind::KIND_STATIC_CONCISE_GENERATOR_METHOD;
+  static inline const Kind KIND_CONCISE_METHOD = Kind::KIND_CONCISE_METHOD;
+  static inline const Kind KIND_STATIC_CONCISE_METHOD = Kind::KIND_STATIC_CONCISE_METHOD;
+  static inline const Kind KIND_CLASS_MEMBERS_INITIALIZER_FUNCTION = Kind::KIND_CLASS_MEMBERS_INITIALIZER_FUNCTION;
+  static inline const Kind KIND_CLASS_STATIC_INITIALIZER_FUNCTION = Kind::KIND_CLASS_STATIC_INITIALIZER_FUNCTION;
+  static inline const Kind KIND_INVALID = Kind::KIND_INVALID;
+
+  using FieldMetadata_Iid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      InternedV8JsFunction>;
+
+  static constexpr FieldMetadata_Iid kIid{};
+  void set_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_V8JsFunctionNameIid =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      InternedV8JsFunction>;
+
+  static constexpr FieldMetadata_V8JsFunctionNameIid kV8JsFunctionNameIid{};
+  void set_v8_js_function_name_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_V8JsFunctionNameIid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_V8JsScriptIid =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      InternedV8JsFunction>;
+
+  static constexpr FieldMetadata_V8JsScriptIid kV8JsScriptIid{};
+  void set_v8_js_script_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_V8JsScriptIid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IsToplevel =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      InternedV8JsFunction>;
+
+  static constexpr FieldMetadata_IsToplevel kIsToplevel{};
+  void set_is_toplevel(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsToplevel::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Kind =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      InternedV8JsFunction_Kind,
+      InternedV8JsFunction>;
+
+  static constexpr FieldMetadata_Kind kKind{};
+  void set_kind(InternedV8JsFunction_Kind value) {
+    static constexpr uint32_t field_id = FieldMetadata_Kind::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ByteOffset =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      InternedV8JsFunction>;
+
+  static constexpr FieldMetadata_ByteOffset kByteOffset{};
+  void set_byte_offset(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ByteOffset::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Line =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      InternedV8JsFunction>;
+
+  static constexpr FieldMetadata_Line kLine{};
+  void set_line(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Line::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Column =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      InternedV8JsFunction>;
+
+  static constexpr FieldMetadata_Column kColumn{};
+  void set_column(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Column::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class InternedV8WasmScript_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  InternedV8WasmScript_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit InternedV8WasmScript_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit InternedV8WasmScript_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_iid() const { return at<1>().valid(); }
+  uint64_t iid() const { return at<1>().as_uint64(); }
+  bool has_script_id() const { return at<2>().valid(); }
+  int32_t script_id() const { return at<2>().as_int32(); }
+  bool has_url() const { return at<3>().valid(); }
+  ::protozero::ConstChars url() const { return at<3>().as_string(); }
+  bool has_wire_bytes() const { return at<4>().valid(); }
+  ::protozero::ConstBytes wire_bytes() const { return at<4>().as_bytes(); }
+};
+
+class InternedV8WasmScript : public ::protozero::Message {
+ public:
+  using Decoder = InternedV8WasmScript_Decoder;
+  enum : int32_t {
+    kIidFieldNumber = 1,
+    kScriptIdFieldNumber = 2,
+    kUrlFieldNumber = 3,
+    kWireBytesFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.InternedV8WasmScript"; }
+
+
+  using FieldMetadata_Iid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      InternedV8WasmScript>;
+
+  static constexpr FieldMetadata_Iid kIid{};
+  void set_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ScriptId =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      InternedV8WasmScript>;
+
+  static constexpr FieldMetadata_ScriptId kScriptId{};
+  void set_script_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ScriptId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Url =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      InternedV8WasmScript>;
+
+  static constexpr FieldMetadata_Url kUrl{};
+  void set_url(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Url::kFieldId, data, size);
+  }
+  void set_url(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Url::kFieldId, chars.data, chars.size);
+  }
+  void set_url(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Url::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_WireBytes =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      InternedV8WasmScript>;
+
+  static constexpr FieldMetadata_WireBytes kWireBytes{};
+  void set_wire_bytes(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_WireBytes::kFieldId, data, size);
+  }
+  void set_wire_bytes(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_WireBytes::kFieldId, bytes.data, bytes.size);
+  }
+  void set_wire_bytes(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_WireBytes::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class InternedV8JsScript_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  InternedV8JsScript_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit InternedV8JsScript_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit InternedV8JsScript_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_iid() const { return at<1>().valid(); }
+  uint64_t iid() const { return at<1>().as_uint64(); }
+  bool has_script_id() const { return at<2>().valid(); }
+  int32_t script_id() const { return at<2>().as_int32(); }
+  bool has_type() const { return at<3>().valid(); }
+  int32_t type() const { return at<3>().as_int32(); }
+  bool has_name() const { return at<4>().valid(); }
+  ::protozero::ConstBytes name() const { return at<4>().as_bytes(); }
+  bool has_source() const { return at<5>().valid(); }
+  ::protozero::ConstBytes source() const { return at<5>().as_bytes(); }
+};
+
+class InternedV8JsScript : public ::protozero::Message {
+ public:
+  using Decoder = InternedV8JsScript_Decoder;
+  enum : int32_t {
+    kIidFieldNumber = 1,
+    kScriptIdFieldNumber = 2,
+    kTypeFieldNumber = 3,
+    kNameFieldNumber = 4,
+    kSourceFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.InternedV8JsScript"; }
+
+
+  using Type = ::perfetto::protos::pbzero::InternedV8JsScript_Type;
+  static inline const char* Type_Name(Type value) {
+    return ::perfetto::protos::pbzero::InternedV8JsScript_Type_Name(value);
+  }
+  static inline const Type TYPE_UNKNOWN = Type::TYPE_UNKNOWN;
+  static inline const Type TYPE_NORMAL = Type::TYPE_NORMAL;
+  static inline const Type TYPE_EVAL = Type::TYPE_EVAL;
+  static inline const Type TYPE_MODULE = Type::TYPE_MODULE;
+  static inline const Type TYPE_NATIVE = Type::TYPE_NATIVE;
+  static inline const Type TYPE_EXTENSION = Type::TYPE_EXTENSION;
+  static inline const Type TYPE_INSPECTOR = Type::TYPE_INSPECTOR;
+
+  using FieldMetadata_Iid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      InternedV8JsScript>;
+
+  static constexpr FieldMetadata_Iid kIid{};
+  void set_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ScriptId =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      InternedV8JsScript>;
+
+  static constexpr FieldMetadata_ScriptId kScriptId{};
+  void set_script_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ScriptId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Type =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      InternedV8JsScript_Type,
+      InternedV8JsScript>;
+
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(InternedV8JsScript_Type value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      V8String,
+      InternedV8JsScript>;
+
+  static constexpr FieldMetadata_Name kName{};
+  template <typename T = V8String> T* set_name() {
+    return BeginNestedMessage<T>(4);
+  }
+
+
+  using FieldMetadata_Source =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      V8String,
+      InternedV8JsScript>;
+
+  static constexpr FieldMetadata_Source kSource{};
+  template <typename T = V8String> T* set_source() {
+    return BeginNestedMessage<T>(5);
+  }
+
+};
+
+class InternedV8String_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  InternedV8String_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit InternedV8String_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit InternedV8String_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_iid() const { return at<1>().valid(); }
+  uint64_t iid() const { return at<1>().as_uint64(); }
+  bool has_latin1() const { return at<2>().valid(); }
+  ::protozero::ConstBytes latin1() const { return at<2>().as_bytes(); }
+  bool has_utf16_le() const { return at<3>().valid(); }
+  ::protozero::ConstBytes utf16_le() const { return at<3>().as_bytes(); }
+  bool has_utf16_be() const { return at<4>().valid(); }
+  ::protozero::ConstBytes utf16_be() const { return at<4>().as_bytes(); }
+};
+
+class InternedV8String : public ::protozero::Message {
+ public:
+  using Decoder = InternedV8String_Decoder;
+  enum : int32_t {
+    kIidFieldNumber = 1,
+    kLatin1FieldNumber = 2,
+    kUtf16LeFieldNumber = 3,
+    kUtf16BeFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.InternedV8String"; }
+
+
+  using FieldMetadata_Iid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      InternedV8String>;
+
+  static constexpr FieldMetadata_Iid kIid{};
+  void set_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Latin1 =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      InternedV8String>;
+
+  static constexpr FieldMetadata_Latin1 kLatin1{};
+  void set_latin1(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_Latin1::kFieldId, data, size);
+  }
+  void set_latin1(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_Latin1::kFieldId, bytes.data, bytes.size);
+  }
+  void set_latin1(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Latin1::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Utf16Le =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      InternedV8String>;
+
+  static constexpr FieldMetadata_Utf16Le kUtf16Le{};
+  void set_utf16_le(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_Utf16Le::kFieldId, data, size);
+  }
+  void set_utf16_le(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_Utf16Le::kFieldId, bytes.data, bytes.size);
+  }
+  void set_utf16_le(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Utf16Le::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Utf16Be =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      InternedV8String>;
+
+  static constexpr FieldMetadata_Utf16Be kUtf16Be{};
+  void set_utf16_be(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_Utf16Be::kFieldId, data, size);
+  }
+  void set_utf16_be(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_Utf16Be::kFieldId, bytes.data, bytes.size);
+  }
+  void set_utf16_be(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Utf16Be::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class V8String_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  V8String_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit V8String_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit V8String_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_latin1() const { return at<1>().valid(); }
+  ::protozero::ConstBytes latin1() const { return at<1>().as_bytes(); }
+  bool has_utf16_le() const { return at<2>().valid(); }
+  ::protozero::ConstBytes utf16_le() const { return at<2>().as_bytes(); }
+  bool has_utf16_be() const { return at<3>().valid(); }
+  ::protozero::ConstBytes utf16_be() const { return at<3>().as_bytes(); }
+};
+
+class V8String : public ::protozero::Message {
+ public:
+  using Decoder = V8String_Decoder;
+  enum : int32_t {
+    kLatin1FieldNumber = 1,
+    kUtf16LeFieldNumber = 2,
+    kUtf16BeFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.V8String"; }
+
+
+  using FieldMetadata_Latin1 =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      V8String>;
+
+  static constexpr FieldMetadata_Latin1 kLatin1{};
+  void set_latin1(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_Latin1::kFieldId, data, size);
+  }
+  void set_latin1(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_Latin1::kFieldId, bytes.data, bytes.size);
+  }
+  void set_latin1(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Latin1::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Utf16Le =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      V8String>;
+
+  static constexpr FieldMetadata_Utf16Le kUtf16Le{};
+  void set_utf16_le(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_Utf16Le::kFieldId, data, size);
+  }
+  void set_utf16_le(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_Utf16Le::kFieldId, bytes.data, bytes.size);
+  }
+  void set_utf16_le(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Utf16Le::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Utf16Be =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      V8String>;
+
+  static constexpr FieldMetadata_Utf16Be kUtf16Be{};
+  void set_utf16_be(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_Utf16Be::kFieldId, data, size);
+  }
+  void set_utf16_be(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_Utf16Be::kFieldId, bytes.data, bytes.size);
+  }
+  void set_utf16_be(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Utf16Be::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/etw/etw.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ETW_ETW_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ETW_ETW_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+namespace perfetto_pbzero_enum_CSwitchEtwEvent {
+enum OldThreadState : int32_t;
+}  // namespace perfetto_pbzero_enum_CSwitchEtwEvent
+using CSwitchEtwEvent_OldThreadState = perfetto_pbzero_enum_CSwitchEtwEvent::OldThreadState;
+namespace perfetto_pbzero_enum_CSwitchEtwEvent {
+enum OldThreadWaitMode : int32_t;
+}  // namespace perfetto_pbzero_enum_CSwitchEtwEvent
+using CSwitchEtwEvent_OldThreadWaitMode = perfetto_pbzero_enum_CSwitchEtwEvent::OldThreadWaitMode;
+namespace perfetto_pbzero_enum_CSwitchEtwEvent {
+enum OldThreadWaitReason : int32_t;
+}  // namespace perfetto_pbzero_enum_CSwitchEtwEvent
+using CSwitchEtwEvent_OldThreadWaitReason = perfetto_pbzero_enum_CSwitchEtwEvent::OldThreadWaitReason;
+namespace perfetto_pbzero_enum_ReadyThreadEtwEvent {
+enum AdjustReason : int32_t;
+}  // namespace perfetto_pbzero_enum_ReadyThreadEtwEvent
+using ReadyThreadEtwEvent_AdjustReason = perfetto_pbzero_enum_ReadyThreadEtwEvent::AdjustReason;
+namespace perfetto_pbzero_enum_ReadyThreadEtwEvent {
+enum TraceFlag : int32_t;
+}  // namespace perfetto_pbzero_enum_ReadyThreadEtwEvent
+using ReadyThreadEtwEvent_TraceFlag = perfetto_pbzero_enum_ReadyThreadEtwEvent::TraceFlag;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_ReadyThreadEtwEvent {
+enum AdjustReason : int32_t {
+  IGNORE_THE_INCREMENT = 0,
+  APPLY_INCREMENT = 1,
+  APPLY_INCREMENT_BOOST = 2,
+};
+} // namespace perfetto_pbzero_enum_ReadyThreadEtwEvent
+using ReadyThreadEtwEvent_AdjustReason = perfetto_pbzero_enum_ReadyThreadEtwEvent::AdjustReason;
+
+
+constexpr ReadyThreadEtwEvent_AdjustReason ReadyThreadEtwEvent_AdjustReason_MIN = ReadyThreadEtwEvent_AdjustReason::IGNORE_THE_INCREMENT;
+constexpr ReadyThreadEtwEvent_AdjustReason ReadyThreadEtwEvent_AdjustReason_MAX = ReadyThreadEtwEvent_AdjustReason::APPLY_INCREMENT_BOOST;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ReadyThreadEtwEvent_AdjustReason_Name(::perfetto::protos::pbzero::ReadyThreadEtwEvent_AdjustReason value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ReadyThreadEtwEvent_AdjustReason::IGNORE_THE_INCREMENT:
+    return "IGNORE_THE_INCREMENT";
+
+  case ::perfetto::protos::pbzero::ReadyThreadEtwEvent_AdjustReason::APPLY_INCREMENT:
+    return "APPLY_INCREMENT";
+
+  case ::perfetto::protos::pbzero::ReadyThreadEtwEvent_AdjustReason::APPLY_INCREMENT_BOOST:
+    return "APPLY_INCREMENT_BOOST";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_ReadyThreadEtwEvent {
+enum TraceFlag : int32_t {
+  TRACE_FLAG_UNSPECIFIED = 0,
+  THREAD_READIED = 1,
+  KERNEL_STACK_SWAPPED_OUT = 2,
+  PROCESS_ADDRESS_SWAPPED_OUT = 4,
+};
+} // namespace perfetto_pbzero_enum_ReadyThreadEtwEvent
+using ReadyThreadEtwEvent_TraceFlag = perfetto_pbzero_enum_ReadyThreadEtwEvent::TraceFlag;
+
+
+constexpr ReadyThreadEtwEvent_TraceFlag ReadyThreadEtwEvent_TraceFlag_MIN = ReadyThreadEtwEvent_TraceFlag::TRACE_FLAG_UNSPECIFIED;
+constexpr ReadyThreadEtwEvent_TraceFlag ReadyThreadEtwEvent_TraceFlag_MAX = ReadyThreadEtwEvent_TraceFlag::PROCESS_ADDRESS_SWAPPED_OUT;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ReadyThreadEtwEvent_TraceFlag_Name(::perfetto::protos::pbzero::ReadyThreadEtwEvent_TraceFlag value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ReadyThreadEtwEvent_TraceFlag::TRACE_FLAG_UNSPECIFIED:
+    return "TRACE_FLAG_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::ReadyThreadEtwEvent_TraceFlag::THREAD_READIED:
+    return "THREAD_READIED";
+
+  case ::perfetto::protos::pbzero::ReadyThreadEtwEvent_TraceFlag::KERNEL_STACK_SWAPPED_OUT:
+    return "KERNEL_STACK_SWAPPED_OUT";
+
+  case ::perfetto::protos::pbzero::ReadyThreadEtwEvent_TraceFlag::PROCESS_ADDRESS_SWAPPED_OUT:
+    return "PROCESS_ADDRESS_SWAPPED_OUT";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_CSwitchEtwEvent {
+enum OldThreadWaitReason : int32_t {
+  EXECUTIVE = 0,
+  FREE_PAGE = 1,
+  PAGE_IN = 2,
+  POOL_ALLOCATION = 3,
+  DELAY_EXECUTION = 4,
+  SUSPEND = 5,
+  USER_REQUEST = 6,
+  WR_EXECUTIVE = 7,
+  WR_FREE_PAGE = 8,
+  WR_PAGE_IN = 9,
+  WR_POOL_ALLOCATION = 10,
+  WR_DELAY_EXECUTION = 11,
+  WR_SUSPENDED = 12,
+  WR_USER_REQUEST = 13,
+  WR_EVENT_PAIR = 14,
+  WR_QUEUE = 15,
+  WR_LPC_RECEIVER = 16,
+  WR_LPC_REPLY = 17,
+  WR_VIRTUAL_MEMORY = 18,
+  WR_PAGE_OUT = 19,
+  WR_RENDEZ_VOUS = 20,
+  WR_KEYED_EVENT = 21,
+  WR_TERMINATED = 22,
+  WR_PROCESS_IN_SWAP = 23,
+  WR_CPU_RATE_CONTROL = 24,
+  WR_CALLOUT_STACK = 25,
+  WR_KERNEL = 26,
+  WR_RESOURCE = 27,
+  WR_PUSH_LOCK = 28,
+  WR_MUTEX = 29,
+  WR_QUANTUM_END = 30,
+  WR_DISPATCH_INT = 31,
+  WR_PREEMPTED = 32,
+  WR_YIELD_EXECUTION = 33,
+  WR_FAST_MUTEX = 34,
+  WR_GUARD_MUTEX = 35,
+  WR_RUNDOWN = 36,
+  MAXIMUM_WAIT_REASON = 37,
+};
+} // namespace perfetto_pbzero_enum_CSwitchEtwEvent
+using CSwitchEtwEvent_OldThreadWaitReason = perfetto_pbzero_enum_CSwitchEtwEvent::OldThreadWaitReason;
+
+
+constexpr CSwitchEtwEvent_OldThreadWaitReason CSwitchEtwEvent_OldThreadWaitReason_MIN = CSwitchEtwEvent_OldThreadWaitReason::EXECUTIVE;
+constexpr CSwitchEtwEvent_OldThreadWaitReason CSwitchEtwEvent_OldThreadWaitReason_MAX = CSwitchEtwEvent_OldThreadWaitReason::MAXIMUM_WAIT_REASON;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* CSwitchEtwEvent_OldThreadWaitReason_Name(::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::EXECUTIVE:
+    return "EXECUTIVE";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::FREE_PAGE:
+    return "FREE_PAGE";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::PAGE_IN:
+    return "PAGE_IN";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::POOL_ALLOCATION:
+    return "POOL_ALLOCATION";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::DELAY_EXECUTION:
+    return "DELAY_EXECUTION";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::SUSPEND:
+    return "SUSPEND";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::USER_REQUEST:
+    return "USER_REQUEST";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_EXECUTIVE:
+    return "WR_EXECUTIVE";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_FREE_PAGE:
+    return "WR_FREE_PAGE";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_PAGE_IN:
+    return "WR_PAGE_IN";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_POOL_ALLOCATION:
+    return "WR_POOL_ALLOCATION";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_DELAY_EXECUTION:
+    return "WR_DELAY_EXECUTION";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_SUSPENDED:
+    return "WR_SUSPENDED";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_USER_REQUEST:
+    return "WR_USER_REQUEST";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_EVENT_PAIR:
+    return "WR_EVENT_PAIR";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_QUEUE:
+    return "WR_QUEUE";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_LPC_RECEIVER:
+    return "WR_LPC_RECEIVER";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_LPC_REPLY:
+    return "WR_LPC_REPLY";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_VIRTUAL_MEMORY:
+    return "WR_VIRTUAL_MEMORY";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_PAGE_OUT:
+    return "WR_PAGE_OUT";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_RENDEZ_VOUS:
+    return "WR_RENDEZ_VOUS";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_KEYED_EVENT:
+    return "WR_KEYED_EVENT";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_TERMINATED:
+    return "WR_TERMINATED";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_PROCESS_IN_SWAP:
+    return "WR_PROCESS_IN_SWAP";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_CPU_RATE_CONTROL:
+    return "WR_CPU_RATE_CONTROL";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_CALLOUT_STACK:
+    return "WR_CALLOUT_STACK";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_KERNEL:
+    return "WR_KERNEL";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_RESOURCE:
+    return "WR_RESOURCE";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_PUSH_LOCK:
+    return "WR_PUSH_LOCK";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_MUTEX:
+    return "WR_MUTEX";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_QUANTUM_END:
+    return "WR_QUANTUM_END";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_DISPATCH_INT:
+    return "WR_DISPATCH_INT";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_PREEMPTED:
+    return "WR_PREEMPTED";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_YIELD_EXECUTION:
+    return "WR_YIELD_EXECUTION";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_FAST_MUTEX:
+    return "WR_FAST_MUTEX";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_GUARD_MUTEX:
+    return "WR_GUARD_MUTEX";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_RUNDOWN:
+    return "WR_RUNDOWN";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::MAXIMUM_WAIT_REASON:
+    return "MAXIMUM_WAIT_REASON";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_CSwitchEtwEvent {
+enum OldThreadWaitMode : int32_t {
+  KERNEL_MODE = 0,
+  USER_MODE = 1,
+};
+} // namespace perfetto_pbzero_enum_CSwitchEtwEvent
+using CSwitchEtwEvent_OldThreadWaitMode = perfetto_pbzero_enum_CSwitchEtwEvent::OldThreadWaitMode;
+
+
+constexpr CSwitchEtwEvent_OldThreadWaitMode CSwitchEtwEvent_OldThreadWaitMode_MIN = CSwitchEtwEvent_OldThreadWaitMode::KERNEL_MODE;
+constexpr CSwitchEtwEvent_OldThreadWaitMode CSwitchEtwEvent_OldThreadWaitMode_MAX = CSwitchEtwEvent_OldThreadWaitMode::USER_MODE;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* CSwitchEtwEvent_OldThreadWaitMode_Name(::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitMode value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitMode::KERNEL_MODE:
+    return "KERNEL_MODE";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitMode::USER_MODE:
+    return "USER_MODE";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_CSwitchEtwEvent {
+enum OldThreadState : int32_t {
+  INITIALIZED = 0,
+  READY = 1,
+  RUNNING = 2,
+  STANDBY = 3,
+  TERMINATED = 4,
+  WAITING = 5,
+  TRANSITION = 6,
+  DEFERRED_READY = 7,
+};
+} // namespace perfetto_pbzero_enum_CSwitchEtwEvent
+using CSwitchEtwEvent_OldThreadState = perfetto_pbzero_enum_CSwitchEtwEvent::OldThreadState;
+
+
+constexpr CSwitchEtwEvent_OldThreadState CSwitchEtwEvent_OldThreadState_MIN = CSwitchEtwEvent_OldThreadState::INITIALIZED;
+constexpr CSwitchEtwEvent_OldThreadState CSwitchEtwEvent_OldThreadState_MAX = CSwitchEtwEvent_OldThreadState::DEFERRED_READY;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* CSwitchEtwEvent_OldThreadState_Name(::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadState value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadState::INITIALIZED:
+    return "INITIALIZED";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadState::READY:
+    return "READY";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadState::RUNNING:
+    return "RUNNING";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadState::STANDBY:
+    return "STANDBY";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadState::TERMINATED:
+    return "TERMINATED";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadState::WAITING:
+    return "WAITING";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadState::TRANSITION:
+    return "TRANSITION";
+
+  case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadState::DEFERRED_READY:
+    return "DEFERRED_READY";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class FileIoOpEndEtwEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  FileIoOpEndEtwEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FileIoOpEndEtwEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FileIoOpEndEtwEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_irp_ptr() const { return at<1>().valid(); }
+  uint64_t irp_ptr() const { return at<1>().as_uint64(); }
+  bool has_extra_info() const { return at<2>().valid(); }
+  uint64_t extra_info() const { return at<2>().as_uint64(); }
+  bool has_nt_status() const { return at<3>().valid(); }
+  uint32_t nt_status() const { return at<3>().as_uint32(); }
+};
+
+class FileIoOpEndEtwEvent : public ::protozero::Message {
+ public:
+  using Decoder = FileIoOpEndEtwEvent_Decoder;
+  enum : int32_t {
+    kIrpPtrFieldNumber = 1,
+    kExtraInfoFieldNumber = 2,
+    kNtStatusFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FileIoOpEndEtwEvent"; }
+
+
+  using FieldMetadata_IrpPtr =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FileIoOpEndEtwEvent>;
+
+  static constexpr FieldMetadata_IrpPtr kIrpPtr{};
+  void set_irp_ptr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IrpPtr::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ExtraInfo =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FileIoOpEndEtwEvent>;
+
+  static constexpr FieldMetadata_ExtraInfo kExtraInfo{};
+  void set_extra_info(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ExtraInfo::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NtStatus =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FileIoOpEndEtwEvent>;
+
+  static constexpr FieldMetadata_NtStatus kNtStatus{};
+  void set_nt_status(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NtStatus::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class FileIoSimpleOpEtwEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  FileIoSimpleOpEtwEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FileIoSimpleOpEtwEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FileIoSimpleOpEtwEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_irp_ptr() const { return at<1>().valid(); }
+  uint64_t irp_ptr() const { return at<1>().as_uint64(); }
+  bool has_file_object() const { return at<2>().valid(); }
+  uint64_t file_object() const { return at<2>().as_uint64(); }
+  bool has_file_key() const { return at<3>().valid(); }
+  uint64_t file_key() const { return at<3>().as_uint64(); }
+  bool has_ttid() const { return at<4>().valid(); }
+  uint32_t ttid() const { return at<4>().as_uint32(); }
+  bool has_opcode() const { return at<5>().valid(); }
+  uint32_t opcode() const { return at<5>().as_uint32(); }
+};
+
+class FileIoSimpleOpEtwEvent : public ::protozero::Message {
+ public:
+  using Decoder = FileIoSimpleOpEtwEvent_Decoder;
+  enum : int32_t {
+    kIrpPtrFieldNumber = 1,
+    kFileObjectFieldNumber = 2,
+    kFileKeyFieldNumber = 3,
+    kTtidFieldNumber = 4,
+    kOpcodeFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FileIoSimpleOpEtwEvent"; }
+
+
+  using FieldMetadata_IrpPtr =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FileIoSimpleOpEtwEvent>;
+
+  static constexpr FieldMetadata_IrpPtr kIrpPtr{};
+  void set_irp_ptr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IrpPtr::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FileObject =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FileIoSimpleOpEtwEvent>;
+
+  static constexpr FieldMetadata_FileObject kFileObject{};
+  void set_file_object(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FileObject::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FileKey =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FileIoSimpleOpEtwEvent>;
+
+  static constexpr FieldMetadata_FileKey kFileKey{};
+  void set_file_key(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FileKey::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ttid =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FileIoSimpleOpEtwEvent>;
+
+  static constexpr FieldMetadata_Ttid kTtid{};
+  void set_ttid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ttid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Opcode =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FileIoSimpleOpEtwEvent>;
+
+  static constexpr FieldMetadata_Opcode kOpcode{};
+  void set_opcode(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Opcode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class FileIoReadWriteEtwEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
+ public:
+  FileIoReadWriteEtwEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FileIoReadWriteEtwEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FileIoReadWriteEtwEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_offset() const { return at<1>().valid(); }
+  uint64_t offset() const { return at<1>().as_uint64(); }
+  bool has_irp_ptr() const { return at<2>().valid(); }
+  uint64_t irp_ptr() const { return at<2>().as_uint64(); }
+  bool has_file_object() const { return at<3>().valid(); }
+  uint64_t file_object() const { return at<3>().as_uint64(); }
+  bool has_file_key() const { return at<4>().valid(); }
+  uint64_t file_key() const { return at<4>().as_uint64(); }
+  bool has_ttid() const { return at<5>().valid(); }
+  uint32_t ttid() const { return at<5>().as_uint32(); }
+  bool has_io_size() const { return at<6>().valid(); }
+  uint32_t io_size() const { return at<6>().as_uint32(); }
+  bool has_io_flags() const { return at<7>().valid(); }
+  uint32_t io_flags() const { return at<7>().as_uint32(); }
+  bool has_opcode() const { return at<8>().valid(); }
+  uint32_t opcode() const { return at<8>().as_uint32(); }
+};
+
+class FileIoReadWriteEtwEvent : public ::protozero::Message {
+ public:
+  using Decoder = FileIoReadWriteEtwEvent_Decoder;
+  enum : int32_t {
+    kOffsetFieldNumber = 1,
+    kIrpPtrFieldNumber = 2,
+    kFileObjectFieldNumber = 3,
+    kFileKeyFieldNumber = 4,
+    kTtidFieldNumber = 5,
+    kIoSizeFieldNumber = 6,
+    kIoFlagsFieldNumber = 7,
+    kOpcodeFieldNumber = 8,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FileIoReadWriteEtwEvent"; }
+
+
+  using FieldMetadata_Offset =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FileIoReadWriteEtwEvent>;
+
+  static constexpr FieldMetadata_Offset kOffset{};
+  void set_offset(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IrpPtr =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FileIoReadWriteEtwEvent>;
+
+  static constexpr FieldMetadata_IrpPtr kIrpPtr{};
+  void set_irp_ptr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IrpPtr::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FileObject =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FileIoReadWriteEtwEvent>;
+
+  static constexpr FieldMetadata_FileObject kFileObject{};
+  void set_file_object(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FileObject::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FileKey =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FileIoReadWriteEtwEvent>;
+
+  static constexpr FieldMetadata_FileKey kFileKey{};
+  void set_file_key(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FileKey::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ttid =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FileIoReadWriteEtwEvent>;
+
+  static constexpr FieldMetadata_Ttid kTtid{};
+  void set_ttid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ttid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IoSize =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FileIoReadWriteEtwEvent>;
+
+  static constexpr FieldMetadata_IoSize kIoSize{};
+  void set_io_size(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IoSize::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IoFlags =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FileIoReadWriteEtwEvent>;
+
+  static constexpr FieldMetadata_IoFlags kIoFlags{};
+  void set_io_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IoFlags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Opcode =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FileIoReadWriteEtwEvent>;
+
+  static constexpr FieldMetadata_Opcode kOpcode{};
+  void set_opcode(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Opcode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class FileIoInfoEtwEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
+ public:
+  FileIoInfoEtwEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FileIoInfoEtwEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FileIoInfoEtwEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_irp_ptr() const { return at<1>().valid(); }
+  uint64_t irp_ptr() const { return at<1>().as_uint64(); }
+  bool has_file_object() const { return at<2>().valid(); }
+  uint64_t file_object() const { return at<2>().as_uint64(); }
+  bool has_file_key() const { return at<3>().valid(); }
+  uint64_t file_key() const { return at<3>().as_uint64(); }
+  bool has_extra_info() const { return at<4>().valid(); }
+  uint64_t extra_info() const { return at<4>().as_uint64(); }
+  bool has_ttid() const { return at<5>().valid(); }
+  uint32_t ttid() const { return at<5>().as_uint32(); }
+  bool has_info_class() const { return at<6>().valid(); }
+  uint32_t info_class() const { return at<6>().as_uint32(); }
+  bool has_opcode() const { return at<7>().valid(); }
+  uint32_t opcode() const { return at<7>().as_uint32(); }
+};
+
+class FileIoInfoEtwEvent : public ::protozero::Message {
+ public:
+  using Decoder = FileIoInfoEtwEvent_Decoder;
+  enum : int32_t {
+    kIrpPtrFieldNumber = 1,
+    kFileObjectFieldNumber = 2,
+    kFileKeyFieldNumber = 3,
+    kExtraInfoFieldNumber = 4,
+    kTtidFieldNumber = 5,
+    kInfoClassFieldNumber = 6,
+    kOpcodeFieldNumber = 7,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FileIoInfoEtwEvent"; }
+
+
+  using FieldMetadata_IrpPtr =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FileIoInfoEtwEvent>;
+
+  static constexpr FieldMetadata_IrpPtr kIrpPtr{};
+  void set_irp_ptr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IrpPtr::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FileObject =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FileIoInfoEtwEvent>;
+
+  static constexpr FieldMetadata_FileObject kFileObject{};
+  void set_file_object(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FileObject::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FileKey =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FileIoInfoEtwEvent>;
+
+  static constexpr FieldMetadata_FileKey kFileKey{};
+  void set_file_key(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FileKey::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ExtraInfo =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FileIoInfoEtwEvent>;
+
+  static constexpr FieldMetadata_ExtraInfo kExtraInfo{};
+  void set_extra_info(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ExtraInfo::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ttid =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FileIoInfoEtwEvent>;
+
+  static constexpr FieldMetadata_Ttid kTtid{};
+  void set_ttid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ttid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_InfoClass =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FileIoInfoEtwEvent>;
+
+  static constexpr FieldMetadata_InfoClass kInfoClass{};
+  void set_info_class(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoClass::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Opcode =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FileIoInfoEtwEvent>;
+
+  static constexpr FieldMetadata_Opcode kOpcode{};
+  void set_opcode(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Opcode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class FileIoDirEnumEtwEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9> {
+ public:
+  FileIoDirEnumEtwEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FileIoDirEnumEtwEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FileIoDirEnumEtwEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_irp_ptr() const { return at<1>().valid(); }
+  uint64_t irp_ptr() const { return at<1>().as_uint64(); }
+  bool has_file_object() const { return at<2>().valid(); }
+  uint64_t file_object() const { return at<2>().as_uint64(); }
+  bool has_file_key() const { return at<3>().valid(); }
+  uint64_t file_key() const { return at<3>().as_uint64(); }
+  bool has_ttid() const { return at<4>().valid(); }
+  uint32_t ttid() const { return at<4>().as_uint32(); }
+  bool has_length() const { return at<5>().valid(); }
+  uint32_t length() const { return at<5>().as_uint32(); }
+  bool has_info_class() const { return at<6>().valid(); }
+  uint32_t info_class() const { return at<6>().as_uint32(); }
+  bool has_file_index() const { return at<7>().valid(); }
+  uint32_t file_index() const { return at<7>().as_uint32(); }
+  bool has_file_name() const { return at<8>().valid(); }
+  ::protozero::ConstChars file_name() const { return at<8>().as_string(); }
+  bool has_opcode() const { return at<9>().valid(); }
+  uint32_t opcode() const { return at<9>().as_uint32(); }
+};
+
+class FileIoDirEnumEtwEvent : public ::protozero::Message {
+ public:
+  using Decoder = FileIoDirEnumEtwEvent_Decoder;
+  enum : int32_t {
+    kIrpPtrFieldNumber = 1,
+    kFileObjectFieldNumber = 2,
+    kFileKeyFieldNumber = 3,
+    kTtidFieldNumber = 4,
+    kLengthFieldNumber = 5,
+    kInfoClassFieldNumber = 6,
+    kFileIndexFieldNumber = 7,
+    kFileNameFieldNumber = 8,
+    kOpcodeFieldNumber = 9,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FileIoDirEnumEtwEvent"; }
+
+
+  using FieldMetadata_IrpPtr =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FileIoDirEnumEtwEvent>;
+
+  static constexpr FieldMetadata_IrpPtr kIrpPtr{};
+  void set_irp_ptr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IrpPtr::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FileObject =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FileIoDirEnumEtwEvent>;
+
+  static constexpr FieldMetadata_FileObject kFileObject{};
+  void set_file_object(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FileObject::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FileKey =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FileIoDirEnumEtwEvent>;
+
+  static constexpr FieldMetadata_FileKey kFileKey{};
+  void set_file_key(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FileKey::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ttid =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FileIoDirEnumEtwEvent>;
+
+  static constexpr FieldMetadata_Ttid kTtid{};
+  void set_ttid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ttid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Length =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FileIoDirEnumEtwEvent>;
+
+  static constexpr FieldMetadata_Length kLength{};
+  void set_length(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Length::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_InfoClass =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FileIoDirEnumEtwEvent>;
+
+  static constexpr FieldMetadata_InfoClass kInfoClass{};
+  void set_info_class(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoClass::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FileIndex =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FileIoDirEnumEtwEvent>;
+
+  static constexpr FieldMetadata_FileIndex kFileIndex{};
+  void set_file_index(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FileIndex::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FileName =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FileIoDirEnumEtwEvent>;
+
+  static constexpr FieldMetadata_FileName kFileName{};
+  void set_file_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_FileName::kFieldId, data, size);
+  }
+  void set_file_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_FileName::kFieldId, chars.data, chars.size);
+  }
+  void set_file_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_FileName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Opcode =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FileIoDirEnumEtwEvent>;
+
+  static constexpr FieldMetadata_Opcode kOpcode{};
+  void set_opcode(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Opcode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class FileIoCreateEtwEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
+ public:
+  FileIoCreateEtwEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FileIoCreateEtwEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FileIoCreateEtwEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_irp_ptr() const { return at<1>().valid(); }
+  uint64_t irp_ptr() const { return at<1>().as_uint64(); }
+  bool has_file_object() const { return at<2>().valid(); }
+  uint64_t file_object() const { return at<2>().as_uint64(); }
+  bool has_ttid() const { return at<3>().valid(); }
+  uint32_t ttid() const { return at<3>().as_uint32(); }
+  bool has_create_options() const { return at<4>().valid(); }
+  uint32_t create_options() const { return at<4>().as_uint32(); }
+  bool has_file_attributes() const { return at<5>().valid(); }
+  uint32_t file_attributes() const { return at<5>().as_uint32(); }
+  bool has_share_access() const { return at<6>().valid(); }
+  uint32_t share_access() const { return at<6>().as_uint32(); }
+  bool has_open_path() const { return at<7>().valid(); }
+  ::protozero::ConstChars open_path() const { return at<7>().as_string(); }
+};
+
+class FileIoCreateEtwEvent : public ::protozero::Message {
+ public:
+  using Decoder = FileIoCreateEtwEvent_Decoder;
+  enum : int32_t {
+    kIrpPtrFieldNumber = 1,
+    kFileObjectFieldNumber = 2,
+    kTtidFieldNumber = 3,
+    kCreateOptionsFieldNumber = 4,
+    kFileAttributesFieldNumber = 5,
+    kShareAccessFieldNumber = 6,
+    kOpenPathFieldNumber = 7,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FileIoCreateEtwEvent"; }
+
+
+  using FieldMetadata_IrpPtr =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FileIoCreateEtwEvent>;
+
+  static constexpr FieldMetadata_IrpPtr kIrpPtr{};
+  void set_irp_ptr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IrpPtr::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FileObject =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FileIoCreateEtwEvent>;
+
+  static constexpr FieldMetadata_FileObject kFileObject{};
+  void set_file_object(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FileObject::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ttid =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FileIoCreateEtwEvent>;
+
+  static constexpr FieldMetadata_Ttid kTtid{};
+  void set_ttid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ttid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CreateOptions =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FileIoCreateEtwEvent>;
+
+  static constexpr FieldMetadata_CreateOptions kCreateOptions{};
+  void set_create_options(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CreateOptions::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FileAttributes =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FileIoCreateEtwEvent>;
+
+  static constexpr FieldMetadata_FileAttributes kFileAttributes{};
+  void set_file_attributes(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FileAttributes::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ShareAccess =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FileIoCreateEtwEvent>;
+
+  static constexpr FieldMetadata_ShareAccess kShareAccess{};
+  void set_share_access(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ShareAccess::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OpenPath =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FileIoCreateEtwEvent>;
+
+  static constexpr FieldMetadata_OpenPath kOpenPath{};
+  void set_open_path(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_OpenPath::kFieldId, data, size);
+  }
+  void set_open_path(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_OpenPath::kFieldId, chars.data, chars.size);
+  }
+  void set_open_path(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_OpenPath::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class MemInfoEtwEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/13> {
+ public:
+  MemInfoEtwEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MemInfoEtwEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MemInfoEtwEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_priority_levels() const { return at<1>().valid(); }
+  uint32_t priority_levels() const { return at<1>().as_uint32(); }
+  bool has_zero_page_count() const { return at<2>().valid(); }
+  uint64_t zero_page_count() const { return at<2>().as_uint64(); }
+  bool has_free_page_count() const { return at<3>().valid(); }
+  uint64_t free_page_count() const { return at<3>().as_uint64(); }
+  bool has_modified_page_count() const { return at<4>().valid(); }
+  uint64_t modified_page_count() const { return at<4>().as_uint64(); }
+  bool has_modified_no_write_page_count() const { return at<5>().valid(); }
+  uint64_t modified_no_write_page_count() const { return at<5>().as_uint64(); }
+  bool has_bad_page_count() const { return at<6>().valid(); }
+  uint64_t bad_page_count() const { return at<6>().as_uint64(); }
+  bool has_standby_page_counts() const { return at<7>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint64_t> standby_page_counts() const { return GetRepeated<uint64_t>(7); }
+  bool has_repurposed_page_counts() const { return at<8>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint64_t> repurposed_page_counts() const { return GetRepeated<uint64_t>(8); }
+  bool has_modified_page_count_page_file() const { return at<9>().valid(); }
+  uint64_t modified_page_count_page_file() const { return at<9>().as_uint64(); }
+  bool has_paged_pool_page_count() const { return at<10>().valid(); }
+  uint64_t paged_pool_page_count() const { return at<10>().as_uint64(); }
+  bool has_non_paged_pool_page_count() const { return at<11>().valid(); }
+  uint64_t non_paged_pool_page_count() const { return at<11>().as_uint64(); }
+  bool has_mdl_page_count() const { return at<12>().valid(); }
+  uint64_t mdl_page_count() const { return at<12>().as_uint64(); }
+  bool has_commit_page_count() const { return at<13>().valid(); }
+  uint64_t commit_page_count() const { return at<13>().as_uint64(); }
+};
+
+class MemInfoEtwEvent : public ::protozero::Message {
+ public:
+  using Decoder = MemInfoEtwEvent_Decoder;
+  enum : int32_t {
+    kPriorityLevelsFieldNumber = 1,
+    kZeroPageCountFieldNumber = 2,
+    kFreePageCountFieldNumber = 3,
+    kModifiedPageCountFieldNumber = 4,
+    kModifiedNoWritePageCountFieldNumber = 5,
+    kBadPageCountFieldNumber = 6,
+    kStandbyPageCountsFieldNumber = 7,
+    kRepurposedPageCountsFieldNumber = 8,
+    kModifiedPageCountPageFileFieldNumber = 9,
+    kPagedPoolPageCountFieldNumber = 10,
+    kNonPagedPoolPageCountFieldNumber = 11,
+    kMdlPageCountFieldNumber = 12,
+    kCommitPageCountFieldNumber = 13,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.MemInfoEtwEvent"; }
+
+
+  using FieldMetadata_PriorityLevels =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MemInfoEtwEvent>;
+
+  static constexpr FieldMetadata_PriorityLevels kPriorityLevels{};
+  void set_priority_levels(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PriorityLevels::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ZeroPageCount =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MemInfoEtwEvent>;
+
+  static constexpr FieldMetadata_ZeroPageCount kZeroPageCount{};
+  void set_zero_page_count(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ZeroPageCount::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FreePageCount =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MemInfoEtwEvent>;
+
+  static constexpr FieldMetadata_FreePageCount kFreePageCount{};
+  void set_free_page_count(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FreePageCount::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ModifiedPageCount =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MemInfoEtwEvent>;
+
+  static constexpr FieldMetadata_ModifiedPageCount kModifiedPageCount{};
+  void set_modified_page_count(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ModifiedPageCount::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ModifiedNoWritePageCount =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MemInfoEtwEvent>;
+
+  static constexpr FieldMetadata_ModifiedNoWritePageCount kModifiedNoWritePageCount{};
+  void set_modified_no_write_page_count(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ModifiedNoWritePageCount::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BadPageCount =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MemInfoEtwEvent>;
+
+  static constexpr FieldMetadata_BadPageCount kBadPageCount{};
+  void set_bad_page_count(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BadPageCount::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StandbyPageCounts =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MemInfoEtwEvent>;
+
+  static constexpr FieldMetadata_StandbyPageCounts kStandbyPageCounts{};
+  void add_standby_page_counts(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StandbyPageCounts::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_RepurposedPageCounts =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MemInfoEtwEvent>;
+
+  static constexpr FieldMetadata_RepurposedPageCounts kRepurposedPageCounts{};
+  void add_repurposed_page_counts(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RepurposedPageCounts::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ModifiedPageCountPageFile =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MemInfoEtwEvent>;
+
+  static constexpr FieldMetadata_ModifiedPageCountPageFile kModifiedPageCountPageFile{};
+  void set_modified_page_count_page_file(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ModifiedPageCountPageFile::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PagedPoolPageCount =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MemInfoEtwEvent>;
+
+  static constexpr FieldMetadata_PagedPoolPageCount kPagedPoolPageCount{};
+  void set_paged_pool_page_count(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PagedPoolPageCount::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NonPagedPoolPageCount =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MemInfoEtwEvent>;
+
+  static constexpr FieldMetadata_NonPagedPoolPageCount kNonPagedPoolPageCount{};
+  void set_non_paged_pool_page_count(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NonPagedPoolPageCount::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MdlPageCount =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MemInfoEtwEvent>;
+
+  static constexpr FieldMetadata_MdlPageCount kMdlPageCount{};
+  void set_mdl_page_count(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MdlPageCount::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CommitPageCount =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MemInfoEtwEvent>;
+
+  static constexpr FieldMetadata_CommitPageCount kCommitPageCount{};
+  void set_commit_page_count(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CommitPageCount::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class ReadyThreadEtwEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
+ public:
+  ReadyThreadEtwEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ReadyThreadEtwEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ReadyThreadEtwEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_t_thread_id() const { return at<1>().valid(); }
+  uint32_t t_thread_id() const { return at<1>().as_uint32(); }
+  bool has_adjust_reason() const { return at<2>().valid(); }
+  int32_t adjust_reason() const { return at<2>().as_int32(); }
+  bool has_adjust_reason_int() const { return at<5>().valid(); }
+  int32_t adjust_reason_int() const { return at<5>().as_int32(); }
+  bool has_adjust_increment() const { return at<3>().valid(); }
+  int32_t adjust_increment() const { return at<3>().as_sint32(); }
+  bool has_flag() const { return at<4>().valid(); }
+  int32_t flag() const { return at<4>().as_int32(); }
+  bool has_flag_int() const { return at<6>().valid(); }
+  int32_t flag_int() const { return at<6>().as_int32(); }
+};
+
+class ReadyThreadEtwEvent : public ::protozero::Message {
+ public:
+  using Decoder = ReadyThreadEtwEvent_Decoder;
+  enum : int32_t {
+    kTThreadIdFieldNumber = 1,
+    kAdjustReasonFieldNumber = 2,
+    kAdjustReasonIntFieldNumber = 5,
+    kAdjustIncrementFieldNumber = 3,
+    kFlagFieldNumber = 4,
+    kFlagIntFieldNumber = 6,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ReadyThreadEtwEvent"; }
+
+
+  using AdjustReason = ::perfetto::protos::pbzero::ReadyThreadEtwEvent_AdjustReason;
+  static inline const char* AdjustReason_Name(AdjustReason value) {
+    return ::perfetto::protos::pbzero::ReadyThreadEtwEvent_AdjustReason_Name(value);
+  }
+
+  using TraceFlag = ::perfetto::protos::pbzero::ReadyThreadEtwEvent_TraceFlag;
+  static inline const char* TraceFlag_Name(TraceFlag value) {
+    return ::perfetto::protos::pbzero::ReadyThreadEtwEvent_TraceFlag_Name(value);
+  }
+  static inline const AdjustReason IGNORE_THE_INCREMENT = AdjustReason::IGNORE_THE_INCREMENT;
+  static inline const AdjustReason APPLY_INCREMENT = AdjustReason::APPLY_INCREMENT;
+  static inline const AdjustReason APPLY_INCREMENT_BOOST = AdjustReason::APPLY_INCREMENT_BOOST;
+  static inline const TraceFlag TRACE_FLAG_UNSPECIFIED = TraceFlag::TRACE_FLAG_UNSPECIFIED;
+  static inline const TraceFlag THREAD_READIED = TraceFlag::THREAD_READIED;
+  static inline const TraceFlag KERNEL_STACK_SWAPPED_OUT = TraceFlag::KERNEL_STACK_SWAPPED_OUT;
+  static inline const TraceFlag PROCESS_ADDRESS_SWAPPED_OUT = TraceFlag::PROCESS_ADDRESS_SWAPPED_OUT;
+
+  using FieldMetadata_TThreadId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ReadyThreadEtwEvent>;
+
+  static constexpr FieldMetadata_TThreadId kTThreadId{};
+  void set_t_thread_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TThreadId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_AdjustReason =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ReadyThreadEtwEvent_AdjustReason,
+      ReadyThreadEtwEvent>;
+
+  static constexpr FieldMetadata_AdjustReason kAdjustReason{};
+  void set_adjust_reason(ReadyThreadEtwEvent_AdjustReason value) {
+    static constexpr uint32_t field_id = FieldMetadata_AdjustReason::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_AdjustReasonInt =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ReadyThreadEtwEvent>;
+
+  static constexpr FieldMetadata_AdjustReasonInt kAdjustReasonInt{};
+  void set_adjust_reason_int(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AdjustReasonInt::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_AdjustIncrement =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kSint32,
+      int32_t,
+      ReadyThreadEtwEvent>;
+
+  static constexpr FieldMetadata_AdjustIncrement kAdjustIncrement{};
+  void set_adjust_increment(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AdjustIncrement::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kSint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Flag =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ReadyThreadEtwEvent_TraceFlag,
+      ReadyThreadEtwEvent>;
+
+  static constexpr FieldMetadata_Flag kFlag{};
+  void set_flag(ReadyThreadEtwEvent_TraceFlag value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flag::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FlagInt =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ReadyThreadEtwEvent>;
+
+  static constexpr FieldMetadata_FlagInt kFlagInt{};
+  void set_flag_int(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FlagInt::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class CSwitchEtwEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/13> {
+ public:
+  CSwitchEtwEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit CSwitchEtwEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit CSwitchEtwEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_new_thread_id() const { return at<1>().valid(); }
+  uint32_t new_thread_id() const { return at<1>().as_uint32(); }
+  bool has_old_thread_id() const { return at<2>().valid(); }
+  uint32_t old_thread_id() const { return at<2>().as_uint32(); }
+  bool has_new_thread_priority() const { return at<3>().valid(); }
+  int32_t new_thread_priority() const { return at<3>().as_sint32(); }
+  bool has_old_thread_priority() const { return at<4>().valid(); }
+  int32_t old_thread_priority() const { return at<4>().as_sint32(); }
+  bool has_previous_c_state() const { return at<5>().valid(); }
+  uint32_t previous_c_state() const { return at<5>().as_uint32(); }
+  bool has_old_thread_wait_reason() const { return at<6>().valid(); }
+  int32_t old_thread_wait_reason() const { return at<6>().as_int32(); }
+  bool has_old_thread_wait_reason_int() const { return at<11>().valid(); }
+  int32_t old_thread_wait_reason_int() const { return at<11>().as_int32(); }
+  bool has_old_thread_wait_mode() const { return at<7>().valid(); }
+  int32_t old_thread_wait_mode() const { return at<7>().as_int32(); }
+  bool has_old_thread_wait_mode_int() const { return at<12>().valid(); }
+  int32_t old_thread_wait_mode_int() const { return at<12>().as_int32(); }
+  bool has_old_thread_state() const { return at<8>().valid(); }
+  int32_t old_thread_state() const { return at<8>().as_int32(); }
+  bool has_old_thread_state_int() const { return at<13>().valid(); }
+  int32_t old_thread_state_int() const { return at<13>().as_sint32(); }
+  bool has_old_thread_wait_ideal_processor() const { return at<9>().valid(); }
+  int32_t old_thread_wait_ideal_processor() const { return at<9>().as_sint32(); }
+  bool has_new_thread_wait_time() const { return at<10>().valid(); }
+  uint32_t new_thread_wait_time() const { return at<10>().as_uint32(); }
+};
+
+class CSwitchEtwEvent : public ::protozero::Message {
+ public:
+  using Decoder = CSwitchEtwEvent_Decoder;
+  enum : int32_t {
+    kNewThreadIdFieldNumber = 1,
+    kOldThreadIdFieldNumber = 2,
+    kNewThreadPriorityFieldNumber = 3,
+    kOldThreadPriorityFieldNumber = 4,
+    kPreviousCStateFieldNumber = 5,
+    kOldThreadWaitReasonFieldNumber = 6,
+    kOldThreadWaitReasonIntFieldNumber = 11,
+    kOldThreadWaitModeFieldNumber = 7,
+    kOldThreadWaitModeIntFieldNumber = 12,
+    kOldThreadStateFieldNumber = 8,
+    kOldThreadStateIntFieldNumber = 13,
+    kOldThreadWaitIdealProcessorFieldNumber = 9,
+    kNewThreadWaitTimeFieldNumber = 10,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.CSwitchEtwEvent"; }
+
+
+  using OldThreadWaitReason = ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason;
+  static inline const char* OldThreadWaitReason_Name(OldThreadWaitReason value) {
+    return ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason_Name(value);
+  }
+
+  using OldThreadWaitMode = ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitMode;
+  static inline const char* OldThreadWaitMode_Name(OldThreadWaitMode value) {
+    return ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitMode_Name(value);
+  }
+
+  using OldThreadState = ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadState;
+  static inline const char* OldThreadState_Name(OldThreadState value) {
+    return ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadState_Name(value);
+  }
+  static inline const OldThreadWaitReason EXECUTIVE = OldThreadWaitReason::EXECUTIVE;
+  static inline const OldThreadWaitReason FREE_PAGE = OldThreadWaitReason::FREE_PAGE;
+  static inline const OldThreadWaitReason PAGE_IN = OldThreadWaitReason::PAGE_IN;
+  static inline const OldThreadWaitReason POOL_ALLOCATION = OldThreadWaitReason::POOL_ALLOCATION;
+  static inline const OldThreadWaitReason DELAY_EXECUTION = OldThreadWaitReason::DELAY_EXECUTION;
+  static inline const OldThreadWaitReason SUSPEND = OldThreadWaitReason::SUSPEND;
+  static inline const OldThreadWaitReason USER_REQUEST = OldThreadWaitReason::USER_REQUEST;
+  static inline const OldThreadWaitReason WR_EXECUTIVE = OldThreadWaitReason::WR_EXECUTIVE;
+  static inline const OldThreadWaitReason WR_FREE_PAGE = OldThreadWaitReason::WR_FREE_PAGE;
+  static inline const OldThreadWaitReason WR_PAGE_IN = OldThreadWaitReason::WR_PAGE_IN;
+  static inline const OldThreadWaitReason WR_POOL_ALLOCATION = OldThreadWaitReason::WR_POOL_ALLOCATION;
+  static inline const OldThreadWaitReason WR_DELAY_EXECUTION = OldThreadWaitReason::WR_DELAY_EXECUTION;
+  static inline const OldThreadWaitReason WR_SUSPENDED = OldThreadWaitReason::WR_SUSPENDED;
+  static inline const OldThreadWaitReason WR_USER_REQUEST = OldThreadWaitReason::WR_USER_REQUEST;
+  static inline const OldThreadWaitReason WR_EVENT_PAIR = OldThreadWaitReason::WR_EVENT_PAIR;
+  static inline const OldThreadWaitReason WR_QUEUE = OldThreadWaitReason::WR_QUEUE;
+  static inline const OldThreadWaitReason WR_LPC_RECEIVER = OldThreadWaitReason::WR_LPC_RECEIVER;
+  static inline const OldThreadWaitReason WR_LPC_REPLY = OldThreadWaitReason::WR_LPC_REPLY;
+  static inline const OldThreadWaitReason WR_VIRTUAL_MEMORY = OldThreadWaitReason::WR_VIRTUAL_MEMORY;
+  static inline const OldThreadWaitReason WR_PAGE_OUT = OldThreadWaitReason::WR_PAGE_OUT;
+  static inline const OldThreadWaitReason WR_RENDEZ_VOUS = OldThreadWaitReason::WR_RENDEZ_VOUS;
+  static inline const OldThreadWaitReason WR_KEYED_EVENT = OldThreadWaitReason::WR_KEYED_EVENT;
+  static inline const OldThreadWaitReason WR_TERMINATED = OldThreadWaitReason::WR_TERMINATED;
+  static inline const OldThreadWaitReason WR_PROCESS_IN_SWAP = OldThreadWaitReason::WR_PROCESS_IN_SWAP;
+  static inline const OldThreadWaitReason WR_CPU_RATE_CONTROL = OldThreadWaitReason::WR_CPU_RATE_CONTROL;
+  static inline const OldThreadWaitReason WR_CALLOUT_STACK = OldThreadWaitReason::WR_CALLOUT_STACK;
+  static inline const OldThreadWaitReason WR_KERNEL = OldThreadWaitReason::WR_KERNEL;
+  static inline const OldThreadWaitReason WR_RESOURCE = OldThreadWaitReason::WR_RESOURCE;
+  static inline const OldThreadWaitReason WR_PUSH_LOCK = OldThreadWaitReason::WR_PUSH_LOCK;
+  static inline const OldThreadWaitReason WR_MUTEX = OldThreadWaitReason::WR_MUTEX;
+  static inline const OldThreadWaitReason WR_QUANTUM_END = OldThreadWaitReason::WR_QUANTUM_END;
+  static inline const OldThreadWaitReason WR_DISPATCH_INT = OldThreadWaitReason::WR_DISPATCH_INT;
+  static inline const OldThreadWaitReason WR_PREEMPTED = OldThreadWaitReason::WR_PREEMPTED;
+  static inline const OldThreadWaitReason WR_YIELD_EXECUTION = OldThreadWaitReason::WR_YIELD_EXECUTION;
+  static inline const OldThreadWaitReason WR_FAST_MUTEX = OldThreadWaitReason::WR_FAST_MUTEX;
+  static inline const OldThreadWaitReason WR_GUARD_MUTEX = OldThreadWaitReason::WR_GUARD_MUTEX;
+  static inline const OldThreadWaitReason WR_RUNDOWN = OldThreadWaitReason::WR_RUNDOWN;
+  static inline const OldThreadWaitReason MAXIMUM_WAIT_REASON = OldThreadWaitReason::MAXIMUM_WAIT_REASON;
+  static inline const OldThreadWaitMode KERNEL_MODE = OldThreadWaitMode::KERNEL_MODE;
+  static inline const OldThreadWaitMode USER_MODE = OldThreadWaitMode::USER_MODE;
+  static inline const OldThreadState INITIALIZED = OldThreadState::INITIALIZED;
+  static inline const OldThreadState READY = OldThreadState::READY;
+  static inline const OldThreadState RUNNING = OldThreadState::RUNNING;
+  static inline const OldThreadState STANDBY = OldThreadState::STANDBY;
+  static inline const OldThreadState TERMINATED = OldThreadState::TERMINATED;
+  static inline const OldThreadState WAITING = OldThreadState::WAITING;
+  static inline const OldThreadState TRANSITION = OldThreadState::TRANSITION;
+  static inline const OldThreadState DEFERRED_READY = OldThreadState::DEFERRED_READY;
+
+  using FieldMetadata_NewThreadId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      CSwitchEtwEvent>;
+
+  static constexpr FieldMetadata_NewThreadId kNewThreadId{};
+  void set_new_thread_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NewThreadId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OldThreadId =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      CSwitchEtwEvent>;
+
+  static constexpr FieldMetadata_OldThreadId kOldThreadId{};
+  void set_old_thread_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OldThreadId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NewThreadPriority =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kSint32,
+      int32_t,
+      CSwitchEtwEvent>;
+
+  static constexpr FieldMetadata_NewThreadPriority kNewThreadPriority{};
+  void set_new_thread_priority(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NewThreadPriority::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kSint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OldThreadPriority =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kSint32,
+      int32_t,
+      CSwitchEtwEvent>;
+
+  static constexpr FieldMetadata_OldThreadPriority kOldThreadPriority{};
+  void set_old_thread_priority(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OldThreadPriority::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kSint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PreviousCState =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      CSwitchEtwEvent>;
+
+  static constexpr FieldMetadata_PreviousCState kPreviousCState{};
+  void set_previous_c_state(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PreviousCState::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OldThreadWaitReason =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      CSwitchEtwEvent_OldThreadWaitReason,
+      CSwitchEtwEvent>;
+
+  static constexpr FieldMetadata_OldThreadWaitReason kOldThreadWaitReason{};
+  void set_old_thread_wait_reason(CSwitchEtwEvent_OldThreadWaitReason value) {
+    static constexpr uint32_t field_id = FieldMetadata_OldThreadWaitReason::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OldThreadWaitReasonInt =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      CSwitchEtwEvent>;
+
+  static constexpr FieldMetadata_OldThreadWaitReasonInt kOldThreadWaitReasonInt{};
+  void set_old_thread_wait_reason_int(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OldThreadWaitReasonInt::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OldThreadWaitMode =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      CSwitchEtwEvent_OldThreadWaitMode,
+      CSwitchEtwEvent>;
+
+  static constexpr FieldMetadata_OldThreadWaitMode kOldThreadWaitMode{};
+  void set_old_thread_wait_mode(CSwitchEtwEvent_OldThreadWaitMode value) {
+    static constexpr uint32_t field_id = FieldMetadata_OldThreadWaitMode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OldThreadWaitModeInt =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      CSwitchEtwEvent>;
+
+  static constexpr FieldMetadata_OldThreadWaitModeInt kOldThreadWaitModeInt{};
+  void set_old_thread_wait_mode_int(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OldThreadWaitModeInt::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OldThreadState =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      CSwitchEtwEvent_OldThreadState,
+      CSwitchEtwEvent>;
+
+  static constexpr FieldMetadata_OldThreadState kOldThreadState{};
+  void set_old_thread_state(CSwitchEtwEvent_OldThreadState value) {
+    static constexpr uint32_t field_id = FieldMetadata_OldThreadState::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OldThreadStateInt =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kSint32,
+      int32_t,
+      CSwitchEtwEvent>;
+
+  static constexpr FieldMetadata_OldThreadStateInt kOldThreadStateInt{};
+  void set_old_thread_state_int(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OldThreadStateInt::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kSint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OldThreadWaitIdealProcessor =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kSint32,
+      int32_t,
+      CSwitchEtwEvent>;
+
+  static constexpr FieldMetadata_OldThreadWaitIdealProcessor kOldThreadWaitIdealProcessor{};
+  void set_old_thread_wait_ideal_processor(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OldThreadWaitIdealProcessor::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kSint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NewThreadWaitTime =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      CSwitchEtwEvent>;
+
+  static constexpr FieldMetadata_NewThreadWaitTime kNewThreadWaitTime{};
+  void set_new_thread_wait_time(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NewThreadWaitTime::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/etw/etw_event.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ETW_ETW_EVENT_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ETW_ETW_EVENT_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class CSwitchEtwEvent;
+class FileIoCreateEtwEvent;
+class FileIoDirEnumEtwEvent;
+class FileIoInfoEtwEvent;
+class FileIoOpEndEtwEvent;
+class FileIoReadWriteEtwEvent;
+class FileIoSimpleOpEtwEvent;
+class MemInfoEtwEvent;
+class ReadyThreadEtwEvent;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class EtwTraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/12> {
+ public:
+  EtwTraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit EtwTraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit EtwTraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_timestamp() const { return at<1>().valid(); }
+  uint64_t timestamp() const { return at<1>().as_uint64(); }
+  bool has_cpu() const { return at<4>().valid(); }
+  uint32_t cpu() const { return at<4>().as_uint32(); }
+  bool has_thread_id() const { return at<5>().valid(); }
+  uint32_t thread_id() const { return at<5>().as_uint32(); }
+  bool has_c_switch() const { return at<2>().valid(); }
+  ::protozero::ConstBytes c_switch() const { return at<2>().as_bytes(); }
+  bool has_ready_thread() const { return at<3>().valid(); }
+  ::protozero::ConstBytes ready_thread() const { return at<3>().as_bytes(); }
+  bool has_mem_info() const { return at<6>().valid(); }
+  ::protozero::ConstBytes mem_info() const { return at<6>().as_bytes(); }
+  bool has_file_io_create() const { return at<7>().valid(); }
+  ::protozero::ConstBytes file_io_create() const { return at<7>().as_bytes(); }
+  bool has_file_io_dir_enum() const { return at<8>().valid(); }
+  ::protozero::ConstBytes file_io_dir_enum() const { return at<8>().as_bytes(); }
+  bool has_file_io_info() const { return at<9>().valid(); }
+  ::protozero::ConstBytes file_io_info() const { return at<9>().as_bytes(); }
+  bool has_file_io_read_write() const { return at<10>().valid(); }
+  ::protozero::ConstBytes file_io_read_write() const { return at<10>().as_bytes(); }
+  bool has_file_io_simple_op() const { return at<11>().valid(); }
+  ::protozero::ConstBytes file_io_simple_op() const { return at<11>().as_bytes(); }
+  bool has_file_io_op_end() const { return at<12>().valid(); }
+  ::protozero::ConstBytes file_io_op_end() const { return at<12>().as_bytes(); }
+};
+
+class EtwTraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = EtwTraceEvent_Decoder;
+  enum : int32_t {
+    kTimestampFieldNumber = 1,
+    kCpuFieldNumber = 4,
+    kThreadIdFieldNumber = 5,
+    kCSwitchFieldNumber = 2,
+    kReadyThreadFieldNumber = 3,
+    kMemInfoFieldNumber = 6,
+    kFileIoCreateFieldNumber = 7,
+    kFileIoDirEnumFieldNumber = 8,
+    kFileIoInfoFieldNumber = 9,
+    kFileIoReadWriteFieldNumber = 10,
+    kFileIoSimpleOpFieldNumber = 11,
+    kFileIoOpEndFieldNumber = 12,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.EtwTraceEvent"; }
+
+
+  using FieldMetadata_Timestamp =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      EtwTraceEvent>;
+
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Cpu =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      EtwTraceEvent>;
+
+  static constexpr FieldMetadata_Cpu kCpu{};
+  void set_cpu(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ThreadId =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      EtwTraceEvent>;
+
+  static constexpr FieldMetadata_ThreadId kThreadId{};
+  void set_thread_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ThreadId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CSwitch =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      CSwitchEtwEvent,
+      EtwTraceEvent>;
+
+  static constexpr FieldMetadata_CSwitch kCSwitch{};
+  template <typename T = CSwitchEtwEvent> T* set_c_switch() {
+    return BeginNestedMessage<T>(2);
+  }
+
+
+  using FieldMetadata_ReadyThread =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ReadyThreadEtwEvent,
+      EtwTraceEvent>;
+
+  static constexpr FieldMetadata_ReadyThread kReadyThread{};
+  template <typename T = ReadyThreadEtwEvent> T* set_ready_thread() {
+    return BeginNestedMessage<T>(3);
+  }
+
+
+  using FieldMetadata_MemInfo =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MemInfoEtwEvent,
+      EtwTraceEvent>;
+
+  static constexpr FieldMetadata_MemInfo kMemInfo{};
+  template <typename T = MemInfoEtwEvent> T* set_mem_info() {
+    return BeginNestedMessage<T>(6);
+  }
+
+
+  using FieldMetadata_FileIoCreate =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FileIoCreateEtwEvent,
+      EtwTraceEvent>;
+
+  static constexpr FieldMetadata_FileIoCreate kFileIoCreate{};
+  template <typename T = FileIoCreateEtwEvent> T* set_file_io_create() {
+    return BeginNestedMessage<T>(7);
+  }
+
+
+  using FieldMetadata_FileIoDirEnum =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FileIoDirEnumEtwEvent,
+      EtwTraceEvent>;
+
+  static constexpr FieldMetadata_FileIoDirEnum kFileIoDirEnum{};
+  template <typename T = FileIoDirEnumEtwEvent> T* set_file_io_dir_enum() {
+    return BeginNestedMessage<T>(8);
+  }
+
+
+  using FieldMetadata_FileIoInfo =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FileIoInfoEtwEvent,
+      EtwTraceEvent>;
+
+  static constexpr FieldMetadata_FileIoInfo kFileIoInfo{};
+  template <typename T = FileIoInfoEtwEvent> T* set_file_io_info() {
+    return BeginNestedMessage<T>(9);
+  }
+
+
+  using FieldMetadata_FileIoReadWrite =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FileIoReadWriteEtwEvent,
+      EtwTraceEvent>;
+
+  static constexpr FieldMetadata_FileIoReadWrite kFileIoReadWrite{};
+  template <typename T = FileIoReadWriteEtwEvent> T* set_file_io_read_write() {
+    return BeginNestedMessage<T>(10);
+  }
+
+
+  using FieldMetadata_FileIoSimpleOp =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FileIoSimpleOpEtwEvent,
+      EtwTraceEvent>;
+
+  static constexpr FieldMetadata_FileIoSimpleOp kFileIoSimpleOp{};
+  template <typename T = FileIoSimpleOpEtwEvent> T* set_file_io_simple_op() {
+    return BeginNestedMessage<T>(11);
+  }
+
+
+  using FieldMetadata_FileIoOpEnd =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FileIoOpEndEtwEvent,
+      EtwTraceEvent>;
+
+  static constexpr FieldMetadata_FileIoOpEnd kFileIoOpEnd{};
+  template <typename T = FileIoOpEndEtwEvent> T* set_file_io_op_end() {
+    return BeginNestedMessage<T>(12);
+  }
+
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/etw/etw_event_bundle.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ETW_ETW_EVENT_BUNDLE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ETW_ETW_EVENT_BUNDLE_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class EtwTraceEvent;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class EtwTraceEventBundle_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  EtwTraceEventBundle_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit EtwTraceEventBundle_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit EtwTraceEventBundle_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cpu() const { return at<1>().valid(); }
+  uint32_t cpu() const { return at<1>().as_uint32(); }
+  bool has_event() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> event() const { return GetRepeated<::protozero::ConstBytes>(2); }
+};
+
+class EtwTraceEventBundle : public ::protozero::Message {
+ public:
+  using Decoder = EtwTraceEventBundle_Decoder;
+  enum : int32_t {
+    kCpuFieldNumber = 1,
+    kEventFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.EtwTraceEventBundle"; }
+
+
+  using FieldMetadata_Cpu =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      EtwTraceEventBundle>;
+
+  static constexpr FieldMetadata_Cpu kCpu{};
+  void set_cpu(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Event =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      EtwTraceEvent,
+      EtwTraceEventBundle>;
+
+  static constexpr FieldMetadata_Event kEvent{};
+  template <typename T = EtwTraceEvent> T* add_event() {
+    return BeginNestedMessage<T>(2);
+  }
+
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/filesystem/inode_file_map.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FILESYSTEM_INODE_FILE_MAP_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FILESYSTEM_INODE_FILE_MAP_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class InodeFileMap_Entry;
+namespace perfetto_pbzero_enum_InodeFileMap_Entry {
+enum Type : int32_t;
+}  // namespace perfetto_pbzero_enum_InodeFileMap_Entry
+using InodeFileMap_Entry_Type = perfetto_pbzero_enum_InodeFileMap_Entry::Type;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_InodeFileMap_Entry {
+enum Type : int32_t {
+  UNKNOWN = 0,
+  FILE = 1,
+  DIRECTORY = 2,
+};
+} // namespace perfetto_pbzero_enum_InodeFileMap_Entry
+using InodeFileMap_Entry_Type = perfetto_pbzero_enum_InodeFileMap_Entry::Type;
+
+
+constexpr InodeFileMap_Entry_Type InodeFileMap_Entry_Type_MIN = InodeFileMap_Entry_Type::UNKNOWN;
+constexpr InodeFileMap_Entry_Type InodeFileMap_Entry_Type_MAX = InodeFileMap_Entry_Type::DIRECTORY;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* InodeFileMap_Entry_Type_Name(::perfetto::protos::pbzero::InodeFileMap_Entry_Type value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::InodeFileMap_Entry_Type::UNKNOWN:
+    return "UNKNOWN";
+
+  case ::perfetto::protos::pbzero::InodeFileMap_Entry_Type::FILE:
+    return "FILE";
+
+  case ::perfetto::protos::pbzero::InodeFileMap_Entry_Type::DIRECTORY:
+    return "DIRECTORY";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class InodeFileMap_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  InodeFileMap_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit InodeFileMap_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit InodeFileMap_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_block_device_id() const { return at<1>().valid(); }
+  uint64_t block_device_id() const { return at<1>().as_uint64(); }
+  bool has_mount_points() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> mount_points() const { return GetRepeated<::protozero::ConstChars>(2); }
+  bool has_entries() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> entries() const { return GetRepeated<::protozero::ConstBytes>(3); }
+};
+
+class InodeFileMap : public ::protozero::Message {
+ public:
+  using Decoder = InodeFileMap_Decoder;
+  enum : int32_t {
+    kBlockDeviceIdFieldNumber = 1,
+    kMountPointsFieldNumber = 2,
+    kEntriesFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.InodeFileMap"; }
+
+  using Entry = ::perfetto::protos::pbzero::InodeFileMap_Entry;
+
+  using FieldMetadata_BlockDeviceId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      InodeFileMap>;
+
+  static constexpr FieldMetadata_BlockDeviceId kBlockDeviceId{};
+  void set_block_device_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BlockDeviceId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MountPoints =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      InodeFileMap>;
+
+  static constexpr FieldMetadata_MountPoints kMountPoints{};
+  void add_mount_points(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_MountPoints::kFieldId, data, size);
+  }
+  void add_mount_points(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_MountPoints::kFieldId, chars.data, chars.size);
+  }
+  void add_mount_points(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_MountPoints::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Entries =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      InodeFileMap_Entry,
+      InodeFileMap>;
+
+  static constexpr FieldMetadata_Entries kEntries{};
+  template <typename T = InodeFileMap_Entry> T* add_entries() {
+    return BeginNestedMessage<T>(3);
+  }
+
+};
+
+class InodeFileMap_Entry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  InodeFileMap_Entry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit InodeFileMap_Entry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit InodeFileMap_Entry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_inode_number() const { return at<1>().valid(); }
+  uint64_t inode_number() const { return at<1>().as_uint64(); }
+  bool has_paths() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> paths() const { return GetRepeated<::protozero::ConstChars>(2); }
+  bool has_type() const { return at<3>().valid(); }
+  int32_t type() const { return at<3>().as_int32(); }
+};
+
+class InodeFileMap_Entry : public ::protozero::Message {
+ public:
+  using Decoder = InodeFileMap_Entry_Decoder;
+  enum : int32_t {
+    kInodeNumberFieldNumber = 1,
+    kPathsFieldNumber = 2,
+    kTypeFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.InodeFileMap.Entry"; }
+
+
+  using Type = ::perfetto::protos::pbzero::InodeFileMap_Entry_Type;
+  static inline const char* Type_Name(Type value) {
+    return ::perfetto::protos::pbzero::InodeFileMap_Entry_Type_Name(value);
+  }
+  static inline const Type UNKNOWN = Type::UNKNOWN;
+  static inline const Type FILE = Type::FILE;
+  static inline const Type DIRECTORY = Type::DIRECTORY;
+
+  using FieldMetadata_InodeNumber =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      InodeFileMap_Entry>;
+
+  static constexpr FieldMetadata_InodeNumber kInodeNumber{};
+  void set_inode_number(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InodeNumber::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Paths =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      InodeFileMap_Entry>;
+
+  static constexpr FieldMetadata_Paths kPaths{};
+  void add_paths(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Paths::kFieldId, data, size);
+  }
+  void add_paths(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Paths::kFieldId, chars.data, chars.size);
+  }
+  void add_paths(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Paths::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Type =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      InodeFileMap_Entry_Type,
+      InodeFileMap_Entry>;
+
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(InodeFileMap_Entry_Type value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/ftrace_event.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FTRACE_EVENT_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FTRACE_EVENT_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class AllocPagesIommuEndFtraceEvent;
+class AllocPagesIommuFailFtraceEvent;
+class AllocPagesIommuStartFtraceEvent;
+class AllocPagesSysEndFtraceEvent;
+class AllocPagesSysFailFtraceEvent;
+class AllocPagesSysStartFtraceEvent;
+class AndroidFsDatareadEndFtraceEvent;
+class AndroidFsDatareadStartFtraceEvent;
+class AndroidFsDatawriteEndFtraceEvent;
+class AndroidFsDatawriteStartFtraceEvent;
+class AndroidFsFsyncEndFtraceEvent;
+class AndroidFsFsyncStartFtraceEvent;
+class BclIrqTriggerFtraceEvent;
+class BinderCommandFtraceEvent;
+class BinderLockFtraceEvent;
+class BinderLockedFtraceEvent;
+class BinderReturnFtraceEvent;
+class BinderSetPriorityFtraceEvent;
+class BinderTransactionAllocBufFtraceEvent;
+class BinderTransactionFtraceEvent;
+class BinderTransactionReceivedFtraceEvent;
+class BinderUnlockFtraceEvent;
+class BlockBioBackmergeFtraceEvent;
+class BlockBioBounceFtraceEvent;
+class BlockBioCompleteFtraceEvent;
+class BlockBioFrontmergeFtraceEvent;
+class BlockBioQueueFtraceEvent;
+class BlockBioRemapFtraceEvent;
+class BlockDirtyBufferFtraceEvent;
+class BlockGetrqFtraceEvent;
+class BlockIoDoneFtraceEvent;
+class BlockIoStartFtraceEvent;
+class BlockPlugFtraceEvent;
+class BlockRqAbortFtraceEvent;
+class BlockRqCompleteFtraceEvent;
+class BlockRqInsertFtraceEvent;
+class BlockRqIssueFtraceEvent;
+class BlockRqRemapFtraceEvent;
+class BlockRqRequeueFtraceEvent;
+class BlockSleeprqFtraceEvent;
+class BlockSplitFtraceEvent;
+class BlockTouchBufferFtraceEvent;
+class BlockUnplugFtraceEvent;
+class CdevUpdateFtraceEvent;
+class CgroupAttachTaskFtraceEvent;
+class CgroupDestroyRootFtraceEvent;
+class CgroupMkdirFtraceEvent;
+class CgroupReleaseFtraceEvent;
+class CgroupRemountFtraceEvent;
+class CgroupRenameFtraceEvent;
+class CgroupRmdirFtraceEvent;
+class CgroupSetupRootFtraceEvent;
+class CgroupTransferTasksFtraceEvent;
+class ClkDisableFtraceEvent;
+class ClkEnableFtraceEvent;
+class ClkSetRateFtraceEvent;
+class ClockDisableFtraceEvent;
+class ClockEnableFtraceEvent;
+class ClockSetRateFtraceEvent;
+class CmaAllocFinishFtraceEvent;
+class CmaAllocInfoFtraceEvent;
+class CmaAllocStartFtraceEvent;
+class ConsoleFtraceEvent;
+class CpuFrequencyFtraceEvent;
+class CpuFrequencyLimitsFtraceEvent;
+class CpuIdleFtraceEvent;
+class CpuhpEnterFtraceEvent;
+class CpuhpExitFtraceEvent;
+class CpuhpLatencyFtraceEvent;
+class CpuhpMultiEnterFtraceEvent;
+class CpuhpPauseFtraceEvent;
+class CrosEcSensorhubDataFtraceEvent;
+class DcvshFreqFtraceEvent;
+class DevfreqFrequencyFtraceEvent;
+class DevicePmCallbackEndFtraceEvent;
+class DevicePmCallbackStartFtraceEvent;
+class DmaAllocContiguousRetryFtraceEvent;
+class DmaFenceEmitFtraceEvent;
+class DmaFenceInitFtraceEvent;
+class DmaFenceSignaledFtraceEvent;
+class DmaFenceWaitEndFtraceEvent;
+class DmaFenceWaitStartFtraceEvent;
+class DmaHeapStatFtraceEvent;
+class DmabufRssStatFtraceEvent;
+class DoSysOpenFtraceEvent;
+class DpuDispDpuUnderrunFtraceEvent;
+class DpuDispVblankIrqEnableFtraceEvent;
+class DpuDsiCmdFifoStatusFtraceEvent;
+class DpuDsiRxFtraceEvent;
+class DpuDsiTxFtraceEvent;
+class DpuTracingMarkWriteFtraceEvent;
+class DrmRunJobFtraceEvent;
+class DrmSchedJobAddDepFtraceEvent;
+class DrmSchedJobDoneFtraceEvent;
+class DrmSchedJobFtraceEvent;
+class DrmSchedJobQueueFtraceEvent;
+class DrmSchedJobRunFtraceEvent;
+class DrmSchedJobUnschedulableFtraceEvent;
+class DrmSchedProcessJobFtraceEvent;
+class DrmVblankEventDeliveredFtraceEvent;
+class DrmVblankEventFtraceEvent;
+class DsiCmdFifoStatusFtraceEvent;
+class DsiRxFtraceEvent;
+class DsiTxFtraceEvent;
+class Dwc3AllocRequestFtraceEvent;
+class Dwc3CompleteTrbFtraceEvent;
+class Dwc3CtrlReqFtraceEvent;
+class Dwc3EpDequeueFtraceEvent;
+class Dwc3EpQueueFtraceEvent;
+class Dwc3EventFtraceEvent;
+class Dwc3FreeRequestFtraceEvent;
+class Dwc3GadgetEpCmdFtraceEvent;
+class Dwc3GadgetEpDisableFtraceEvent;
+class Dwc3GadgetEpEnableFtraceEvent;
+class Dwc3GadgetGenericCmdFtraceEvent;
+class Dwc3GadgetGivebackFtraceEvent;
+class Dwc3PrepareTrbFtraceEvent;
+class Dwc3ReadlFtraceEvent;
+class Dwc3WritelFtraceEvent;
+class Ext4AllocDaBlocksFtraceEvent;
+class Ext4AllocateBlocksFtraceEvent;
+class Ext4AllocateInodeFtraceEvent;
+class Ext4BeginOrderedTruncateFtraceEvent;
+class Ext4CollapseRangeFtraceEvent;
+class Ext4DaReleaseSpaceFtraceEvent;
+class Ext4DaReserveSpaceFtraceEvent;
+class Ext4DaUpdateReserveSpaceFtraceEvent;
+class Ext4DaWriteBeginFtraceEvent;
+class Ext4DaWriteEndFtraceEvent;
+class Ext4DaWritePagesExtentFtraceEvent;
+class Ext4DaWritePagesFtraceEvent;
+class Ext4DirectIOEnterFtraceEvent;
+class Ext4DirectIOExitFtraceEvent;
+class Ext4DiscardBlocksFtraceEvent;
+class Ext4DiscardPreallocationsFtraceEvent;
+class Ext4DropInodeFtraceEvent;
+class Ext4EsCacheExtentFtraceEvent;
+class Ext4EsFindDelayedExtentRangeEnterFtraceEvent;
+class Ext4EsFindDelayedExtentRangeExitFtraceEvent;
+class Ext4EsInsertExtentFtraceEvent;
+class Ext4EsLookupExtentEnterFtraceEvent;
+class Ext4EsLookupExtentExitFtraceEvent;
+class Ext4EsRemoveExtentFtraceEvent;
+class Ext4EsShrinkCountFtraceEvent;
+class Ext4EsShrinkFtraceEvent;
+class Ext4EsShrinkScanEnterFtraceEvent;
+class Ext4EsShrinkScanExitFtraceEvent;
+class Ext4EvictInodeFtraceEvent;
+class Ext4ExtConvertToInitializedEnterFtraceEvent;
+class Ext4ExtConvertToInitializedFastpathFtraceEvent;
+class Ext4ExtHandleUnwrittenExtentsFtraceEvent;
+class Ext4ExtInCacheFtraceEvent;
+class Ext4ExtLoadExtentFtraceEvent;
+class Ext4ExtMapBlocksEnterFtraceEvent;
+class Ext4ExtMapBlocksExitFtraceEvent;
+class Ext4ExtPutInCacheFtraceEvent;
+class Ext4ExtRemoveSpaceDoneFtraceEvent;
+class Ext4ExtRemoveSpaceFtraceEvent;
+class Ext4ExtRmIdxFtraceEvent;
+class Ext4ExtRmLeafFtraceEvent;
+class Ext4ExtShowExtentFtraceEvent;
+class Ext4FallocateEnterFtraceEvent;
+class Ext4FallocateExitFtraceEvent;
+class Ext4FindDelallocRangeFtraceEvent;
+class Ext4ForgetFtraceEvent;
+class Ext4FreeBlocksFtraceEvent;
+class Ext4FreeInodeFtraceEvent;
+class Ext4GetImpliedClusterAllocExitFtraceEvent;
+class Ext4GetReservedClusterAllocFtraceEvent;
+class Ext4IndMapBlocksEnterFtraceEvent;
+class Ext4IndMapBlocksExitFtraceEvent;
+class Ext4InsertRangeFtraceEvent;
+class Ext4InvalidatepageFtraceEvent;
+class Ext4JournalStartFtraceEvent;
+class Ext4JournalStartReservedFtraceEvent;
+class Ext4JournalledInvalidatepageFtraceEvent;
+class Ext4JournalledWriteEndFtraceEvent;
+class Ext4LoadInodeBitmapFtraceEvent;
+class Ext4LoadInodeFtraceEvent;
+class Ext4MarkInodeDirtyFtraceEvent;
+class Ext4MbBitmapLoadFtraceEvent;
+class Ext4MbBuddyBitmapLoadFtraceEvent;
+class Ext4MbDiscardPreallocationsFtraceEvent;
+class Ext4MbNewGroupPaFtraceEvent;
+class Ext4MbNewInodePaFtraceEvent;
+class Ext4MbReleaseGroupPaFtraceEvent;
+class Ext4MbReleaseInodePaFtraceEvent;
+class Ext4MballocAllocFtraceEvent;
+class Ext4MballocDiscardFtraceEvent;
+class Ext4MballocFreeFtraceEvent;
+class Ext4MballocPreallocFtraceEvent;
+class Ext4OtherInodeUpdateTimeFtraceEvent;
+class Ext4PunchHoleFtraceEvent;
+class Ext4ReadBlockBitmapLoadFtraceEvent;
+class Ext4ReadpageFtraceEvent;
+class Ext4ReleasepageFtraceEvent;
+class Ext4RemoveBlocksFtraceEvent;
+class Ext4RequestBlocksFtraceEvent;
+class Ext4RequestInodeFtraceEvent;
+class Ext4SyncFileEnterFtraceEvent;
+class Ext4SyncFileExitFtraceEvent;
+class Ext4SyncFsFtraceEvent;
+class Ext4TrimAllFreeFtraceEvent;
+class Ext4TrimExtentFtraceEvent;
+class Ext4TruncateEnterFtraceEvent;
+class Ext4TruncateExitFtraceEvent;
+class Ext4UnlinkEnterFtraceEvent;
+class Ext4UnlinkExitFtraceEvent;
+class Ext4WriteBeginFtraceEvent;
+class Ext4WriteEndFtraceEvent;
+class Ext4WritepageFtraceEvent;
+class Ext4WritepagesFtraceEvent;
+class Ext4WritepagesResultFtraceEvent;
+class Ext4ZeroRangeFtraceEvent;
+class F2fsBackgroundGcFtraceEvent;
+class F2fsDoSubmitBioFtraceEvent;
+class F2fsEvictInodeFtraceEvent;
+class F2fsFallocateFtraceEvent;
+class F2fsGcBeginFtraceEvent;
+class F2fsGcEndFtraceEvent;
+class F2fsGetDataBlockFtraceEvent;
+class F2fsGetVictimFtraceEvent;
+class F2fsIgetExitFtraceEvent;
+class F2fsIgetFtraceEvent;
+class F2fsIostatFtraceEvent;
+class F2fsIostatLatencyFtraceEvent;
+class F2fsNewInodeFtraceEvent;
+class F2fsReadpageFtraceEvent;
+class F2fsReserveNewBlockFtraceEvent;
+class F2fsSetPageDirtyFtraceEvent;
+class F2fsSubmitWritePageFtraceEvent;
+class F2fsSyncFileEnterFtraceEvent;
+class F2fsSyncFileExitFtraceEvent;
+class F2fsSyncFsFtraceEvent;
+class F2fsTruncateBlocksEnterFtraceEvent;
+class F2fsTruncateBlocksExitFtraceEvent;
+class F2fsTruncateDataBlocksRangeFtraceEvent;
+class F2fsTruncateFtraceEvent;
+class F2fsTruncateInodeBlocksEnterFtraceEvent;
+class F2fsTruncateInodeBlocksExitFtraceEvent;
+class F2fsTruncateNodeFtraceEvent;
+class F2fsTruncateNodesEnterFtraceEvent;
+class F2fsTruncateNodesExitFtraceEvent;
+class F2fsTruncatePartialNodesFtraceEvent;
+class F2fsUnlinkEnterFtraceEvent;
+class F2fsUnlinkExitFtraceEvent;
+class F2fsVmPageMkwriteFtraceEvent;
+class F2fsWriteBeginFtraceEvent;
+class F2fsWriteCheckpointFtraceEvent;
+class F2fsWriteEndFtraceEvent;
+class FastrpcDmaAllocFtraceEvent;
+class FastrpcDmaFreeFtraceEvent;
+class FastrpcDmaMapFtraceEvent;
+class FastrpcDmaStatFtraceEvent;
+class FastrpcDmaUnmapFtraceEvent;
+class FenceDestroyFtraceEvent;
+class FenceEnableSignalFtraceEvent;
+class FenceInitFtraceEvent;
+class FenceSignaledFtraceEvent;
+class FuncgraphEntryFtraceEvent;
+class FuncgraphExitFtraceEvent;
+class FwtpPerfettoCounterFtraceEvent;
+class FwtpPerfettoSliceFtraceEvent;
+class G2dTracingMarkWriteFtraceEvent;
+class GenericFtraceEvent;
+class GoogleIccEventFtraceEvent;
+class GoogleIrmEventFtraceEvent;
+class GpuFrequencyFtraceEvent;
+class GpuMemTotalFtraceEvent;
+class GpuPowerStateFtraceEvent;
+class GpuWorkPeriodFtraceEvent;
+class GramCollisionFtraceEvent;
+class HostFfaCallFtraceEvent;
+class HostHcallFtraceEvent;
+class HostMemAbortFtraceEvent;
+class HostSmcFtraceEvent;
+class HrtimerCancelFtraceEvent;
+class HrtimerExpireEntryFtraceEvent;
+class HrtimerExpireExitFtraceEvent;
+class HrtimerStartFtraceEvent;
+class HypEnterFtraceEvent;
+class HypExitFtraceEvent;
+class HypervisorHostHcallFtraceEvent;
+class HypervisorHostMemAbortFtraceEvent;
+class HypervisorHostSmcFtraceEvent;
+class HypervisorHypEnterFtraceEvent;
+class HypervisorHypExitFtraceEvent;
+class HypervisorIommuIdmapCompleteFtraceEvent;
+class HypervisorIommuIdmapFtraceEvent;
+class HypervisorPsciMemProtectFtraceEvent;
+class HypervisorVcpuIllegalTrapFtraceEvent;
+class I2cReadFtraceEvent;
+class I2cReplyFtraceEvent;
+class I2cResultFtraceEvent;
+class I2cWriteFtraceEvent;
+class InetSockSetStateFtraceEvent;
+class IommuIdmapFtraceEvent;
+class IommuMapRangeFtraceEvent;
+class IommuSecPtblMapRangeEndFtraceEvent;
+class IommuSecPtblMapRangeStartFtraceEvent;
+class IonAllocBufferEndFtraceEvent;
+class IonAllocBufferFailFtraceEvent;
+class IonAllocBufferFallbackFtraceEvent;
+class IonAllocBufferStartFtraceEvent;
+class IonBufferCreateFtraceEvent;
+class IonBufferDestroyFtraceEvent;
+class IonCpAllocRetryFtraceEvent;
+class IonCpSecureBufferEndFtraceEvent;
+class IonCpSecureBufferStartFtraceEvent;
+class IonHeapGrowFtraceEvent;
+class IonHeapShrinkFtraceEvent;
+class IonPrefetchingFtraceEvent;
+class IonSecureCmaAddToPoolEndFtraceEvent;
+class IonSecureCmaAddToPoolStartFtraceEvent;
+class IonSecureCmaAllocateEndFtraceEvent;
+class IonSecureCmaAllocateStartFtraceEvent;
+class IonSecureCmaShrinkPoolEndFtraceEvent;
+class IonSecureCmaShrinkPoolStartFtraceEvent;
+class IonStatFtraceEvent;
+class IpiEntryFtraceEvent;
+class IpiExitFtraceEvent;
+class IpiRaiseFtraceEvent;
+class IrqHandlerEntryFtraceEvent;
+class IrqHandlerExitFtraceEvent;
+class KfreeFtraceEvent;
+class KfreeSkbFtraceEvent;
+class KgslAdrenoCmdbatchQueuedFtraceEvent;
+class KgslAdrenoCmdbatchRetiredFtraceEvent;
+class KgslAdrenoCmdbatchSubmittedFtraceEvent;
+class KgslAdrenoCmdbatchSyncFtraceEvent;
+class KgslGpuFrequencyFtraceEvent;
+class KmallocFtraceEvent;
+class KmallocNodeFtraceEvent;
+class KmemCacheAllocFtraceEvent;
+class KmemCacheAllocNodeFtraceEvent;
+class KmemCacheFreeFtraceEvent;
+class KprobeEvent;
+class KvmAccessFaultFtraceEvent;
+class KvmAckIrqFtraceEvent;
+class KvmAgeHvaFtraceEvent;
+class KvmAgePageFtraceEvent;
+class KvmArmClearDebugFtraceEvent;
+class KvmArmSetDreg32FtraceEvent;
+class KvmArmSetRegsetFtraceEvent;
+class KvmArmSetupDebugFtraceEvent;
+class KvmEntryFtraceEvent;
+class KvmExitFtraceEvent;
+class KvmFpuFtraceEvent;
+class KvmGetTimerMapFtraceEvent;
+class KvmGuestFaultFtraceEvent;
+class KvmHandleSysRegFtraceEvent;
+class KvmHvcArm64FtraceEvent;
+class KvmIrqLineFtraceEvent;
+class KvmMmioEmulateFtraceEvent;
+class KvmMmioFtraceEvent;
+class KvmSetGuestDebugFtraceEvent;
+class KvmSetIrqFtraceEvent;
+class KvmSetSpteHvaFtraceEvent;
+class KvmSetWayFlushFtraceEvent;
+class KvmSysAccessFtraceEvent;
+class KvmTestAgeHvaFtraceEvent;
 class KvmTimerEmulateFtraceEvent;
 class KvmTimerHrtimerExpireFtraceEvent;
 class KvmTimerRestoreStateFtraceEvent;
@@ -53077,14 +87688,42 @@ class KvmUnmapHvaRangeFtraceEvent;
 class KvmUserspaceExitFtraceEvent;
 class KvmVcpuWakeupFtraceEvent;
 class KvmWfxArm64FtraceEvent;
+class LocalTimerEntryFtraceEvent;
+class LocalTimerExitFtraceEvent;
 class LowmemoryKillFtraceEvent;
 class LwisTracingMarkWriteFtraceEvent;
+class MaliGpuPowerStateFtraceEvent;
+class MaliMaliCSFINTERRUPTENDFtraceEvent;
+class MaliMaliCSFINTERRUPTSTARTFtraceEvent;
 class MaliMaliKCPUCQSSETFtraceEvent;
 class MaliMaliKCPUCQSWAITENDFtraceEvent;
 class MaliMaliKCPUCQSWAITSTARTFtraceEvent;
 class MaliMaliKCPUFENCESIGNALFtraceEvent;
 class MaliMaliKCPUFENCEWAITENDFtraceEvent;
 class MaliMaliKCPUFENCEWAITSTARTFtraceEvent;
+class MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent;
+class MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent;
+class MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent;
+class MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent;
+class MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent;
+class MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent;
+class MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent;
+class MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent;
+class MaliMaliPMMCUINSLEEPFtraceEvent;
+class MaliMaliPMMCUOFFFtraceEvent;
+class MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent;
+class MaliMaliPMMCUONFtraceEvent;
+class MaliMaliPMMCUONGLBREINITPENDFtraceEvent;
+class MaliMaliPMMCUONHALTFtraceEvent;
+class MaliMaliPMMCUONHWCNTDISABLEFtraceEvent;
+class MaliMaliPMMCUONHWCNTENABLEFtraceEvent;
+class MaliMaliPMMCUONPENDHALTFtraceEvent;
+class MaliMaliPMMCUONPENDSLEEPFtraceEvent;
+class MaliMaliPMMCUONSLEEPINITIATEFtraceEvent;
+class MaliMaliPMMCUPENDOFFFtraceEvent;
+class MaliMaliPMMCUPENDONRELOADFtraceEvent;
+class MaliMaliPMMCUPOWERDOWNFtraceEvent;
+class MaliMaliPMMCURESETWAITFtraceEvent;
 class MaliTracingMarkWriteFtraceEvent;
 class MarkVictimFtraceEvent;
 class MdpCmdKickoffFtraceEvent;
@@ -53109,6 +87748,7 @@ class MdpVideoUnderrunDoneFtraceEvent;
 class MigratePagesEndFtraceEvent;
 class MigratePagesStartFtraceEvent;
 class MigrateRetryFtraceEvent;
+class MmAllocContigMigrateRangeInfoFtraceEvent;
 class MmCompactionBeginFtraceEvent;
 class MmCompactionDeferCompactionFtraceEvent;
 class MmCompactionDeferResetFtraceEvent;
@@ -53143,7 +87783,13 @@ class NapiGroReceiveExitFtraceEvent;
 class NetDevXmitFtraceEvent;
 class NetifReceiveSkbFtraceEvent;
 class OomScoreAdjUpdateFtraceEvent;
+class OpenExecFtraceEvent;
+class PanelWriteGenericFtraceEvent;
+class ParamSetValueCpmFtraceEvent;
+class PixelMmKswapdDoneFtraceEvent;
+class PixelMmKswapdWakeFtraceEvent;
 class PrintFtraceEvent;
+class PsciMemProtectFtraceEvent;
 class RegulatorDisableCompleteFtraceEvent;
 class RegulatorDisableFtraceEvent;
 class RegulatorEnableCompleteFtraceEvent;
@@ -53152,11 +87798,14 @@ class RegulatorEnableFtraceEvent;
 class RegulatorSetVoltageCompleteFtraceEvent;
 class RegulatorSetVoltageFtraceEvent;
 class RotatorBwAoAsContextFtraceEvent;
+class RpmStatusFtraceEvent;
 class RssStatFtraceEvent;
 class RssStatThrottledFtraceEvent;
+class SamsungTracingMarkWriteFtraceEvent;
 class SchedBlockedReasonFtraceEvent;
 class SchedCpuHotplugFtraceEvent;
 class SchedCpuUtilCfsFtraceEvent;
+class SchedMigrateTaskFtraceEvent;
 class SchedPiSetprioFtraceEvent;
 class SchedProcessExecFtraceEvent;
 class SchedProcessExitFtraceEvent;
@@ -53165,11 +87814,16 @@ class SchedProcessFreeFtraceEvent;
 class SchedProcessHangFtraceEvent;
 class SchedProcessWaitFtraceEvent;
 class SchedSwitchFtraceEvent;
+class SchedSwitchWithCtrsFtraceEvent;
 class SchedWakeupFtraceEvent;
 class SchedWakeupNewFtraceEvent;
+class SchedWakeupTaskAttrFtraceEvent;
 class SchedWakingFtraceEvent;
 class ScmCallEndFtraceEvent;
 class ScmCallStartFtraceEvent;
+class ScsiDispatchCmdErrorFtraceEvent;
+class ScsiDispatchCmdTimeoutFtraceEvent;
+class ScsiEhWakeupFtraceEvent;
 class SdeSdeEvtlogFtraceEvent;
 class SdeSdePerfCalcCrtcFtraceEvent;
 class SdeSdePerfCrtcUpdateFtraceEvent;
@@ -53186,6 +87840,7 @@ class SoftirqEntryFtraceEvent;
 class SoftirqExitFtraceEvent;
 class SoftirqRaiseFtraceEvent;
 class SuspendResumeFtraceEvent;
+class SuspendResumeMinimalFtraceEvent;
 class SyncPtFtraceEvent;
 class SyncTimelineFtraceEvent;
 class SyncWaitFtraceEvent;
@@ -53194,7 +87849,13 @@ class SysExitFtraceEvent;
 class TaskNewtaskFtraceEvent;
 class TaskRenameFtraceEvent;
 class TcpRetransmitSkbFtraceEvent;
+class ThermalExynosAcpmBulkFtraceEvent;
+class ThermalExynosAcpmHighOverheadFtraceEvent;
 class ThermalTemperatureFtraceEvent;
+class TimerCancelFtraceEvent;
+class TimerExpireEntryFtraceEvent;
+class TimerExpireExitFtraceEvent;
+class TimerStartFtraceEvent;
 class TracingMarkWriteFtraceEvent;
 class TrapRegFtraceEvent;
 class TrustyEnqueueNopFtraceEvent;
@@ -53237,8 +87898,15 @@ class WorkqueueExecuteEndFtraceEvent;
 class WorkqueueExecuteStartFtraceEvent;
 class WorkqueueQueueWorkFtraceEvent;
 class ZeroFtraceEvent;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-class FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/475, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/602> {
  public:
   FtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit FtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -53247,6 +87915,8 @@ class FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID
   uint64_t timestamp() const { return at<1>().as_uint64(); }
   bool has_pid() const { return at<2>().valid(); }
   uint32_t pid() const { return at<2>().as_uint32(); }
+  bool has_common_flags() const { return at<5>().valid(); }
+  uint32_t common_flags() const { return at<5>().as_uint32(); }
   bool has_print() const { return at<3>().valid(); }
   ::protozero::ConstBytes print() const { return at<3>().as_bytes(); }
   bool has_sched_switch() const { return at<4>().valid(); }
@@ -54155,6 +88825,260 @@ class FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID
   ::protozero::ConstBytes mali_mali_kcpu_fence_wait_start() const { return at<474>().as_bytes(); }
   bool has_mali_mali_kcpu_fence_wait_end() const { return at<475>().valid(); }
   ::protozero::ConstBytes mali_mali_kcpu_fence_wait_end() const { return at<475>().as_bytes(); }
+  bool has_hyp_enter() const { return at<476>().valid(); }
+  ::protozero::ConstBytes hyp_enter() const { return at<476>().as_bytes(); }
+  bool has_hyp_exit() const { return at<477>().valid(); }
+  ::protozero::ConstBytes hyp_exit() const { return at<477>().as_bytes(); }
+  bool has_host_hcall() const { return at<478>().valid(); }
+  ::protozero::ConstBytes host_hcall() const { return at<478>().as_bytes(); }
+  bool has_host_smc() const { return at<479>().valid(); }
+  ::protozero::ConstBytes host_smc() const { return at<479>().as_bytes(); }
+  bool has_host_mem_abort() const { return at<480>().valid(); }
+  ::protozero::ConstBytes host_mem_abort() const { return at<480>().as_bytes(); }
+  bool has_suspend_resume_minimal() const { return at<481>().valid(); }
+  ::protozero::ConstBytes suspend_resume_minimal() const { return at<481>().as_bytes(); }
+  bool has_mali_mali_csf_interrupt_start() const { return at<482>().valid(); }
+  ::protozero::ConstBytes mali_mali_csf_interrupt_start() const { return at<482>().as_bytes(); }
+  bool has_mali_mali_csf_interrupt_end() const { return at<483>().valid(); }
+  ::protozero::ConstBytes mali_mali_csf_interrupt_end() const { return at<483>().as_bytes(); }
+  bool has_samsung_tracing_mark_write() const { return at<484>().valid(); }
+  ::protozero::ConstBytes samsung_tracing_mark_write() const { return at<484>().as_bytes(); }
+  bool has_binder_command() const { return at<485>().valid(); }
+  ::protozero::ConstBytes binder_command() const { return at<485>().as_bytes(); }
+  bool has_binder_return() const { return at<486>().valid(); }
+  ::protozero::ConstBytes binder_return() const { return at<486>().as_bytes(); }
+  bool has_sched_switch_with_ctrs() const { return at<487>().valid(); }
+  ::protozero::ConstBytes sched_switch_with_ctrs() const { return at<487>().as_bytes(); }
+  bool has_gpu_work_period() const { return at<488>().valid(); }
+  ::protozero::ConstBytes gpu_work_period() const { return at<488>().as_bytes(); }
+  bool has_rpm_status() const { return at<489>().valid(); }
+  ::protozero::ConstBytes rpm_status() const { return at<489>().as_bytes(); }
+  bool has_panel_write_generic() const { return at<490>().valid(); }
+  ::protozero::ConstBytes panel_write_generic() const { return at<490>().as_bytes(); }
+  bool has_sched_migrate_task() const { return at<491>().valid(); }
+  ::protozero::ConstBytes sched_migrate_task() const { return at<491>().as_bytes(); }
+  bool has_dpu_dsi_cmd_fifo_status() const { return at<492>().valid(); }
+  ::protozero::ConstBytes dpu_dsi_cmd_fifo_status() const { return at<492>().as_bytes(); }
+  bool has_dpu_dsi_rx() const { return at<493>().valid(); }
+  ::protozero::ConstBytes dpu_dsi_rx() const { return at<493>().as_bytes(); }
+  bool has_dpu_dsi_tx() const { return at<494>().valid(); }
+  ::protozero::ConstBytes dpu_dsi_tx() const { return at<494>().as_bytes(); }
+  bool has_f2fs_background_gc() const { return at<495>().valid(); }
+  ::protozero::ConstBytes f2fs_background_gc() const { return at<495>().as_bytes(); }
+  bool has_f2fs_gc_begin() const { return at<496>().valid(); }
+  ::protozero::ConstBytes f2fs_gc_begin() const { return at<496>().as_bytes(); }
+  bool has_f2fs_gc_end() const { return at<497>().valid(); }
+  ::protozero::ConstBytes f2fs_gc_end() const { return at<497>().as_bytes(); }
+  bool has_fastrpc_dma_free() const { return at<498>().valid(); }
+  ::protozero::ConstBytes fastrpc_dma_free() const { return at<498>().as_bytes(); }
+  bool has_fastrpc_dma_alloc() const { return at<499>().valid(); }
+  ::protozero::ConstBytes fastrpc_dma_alloc() const { return at<499>().as_bytes(); }
+  bool has_fastrpc_dma_unmap() const { return at<500>().valid(); }
+  ::protozero::ConstBytes fastrpc_dma_unmap() const { return at<500>().as_bytes(); }
+  bool has_fastrpc_dma_map() const { return at<501>().valid(); }
+  ::protozero::ConstBytes fastrpc_dma_map() const { return at<501>().as_bytes(); }
+  bool has_google_icc_event() const { return at<502>().valid(); }
+  ::protozero::ConstBytes google_icc_event() const { return at<502>().as_bytes(); }
+  bool has_google_irm_event() const { return at<503>().valid(); }
+  ::protozero::ConstBytes google_irm_event() const { return at<503>().as_bytes(); }
+  bool has_device_pm_callback_start() const { return at<504>().valid(); }
+  ::protozero::ConstBytes device_pm_callback_start() const { return at<504>().as_bytes(); }
+  bool has_device_pm_callback_end() const { return at<505>().valid(); }
+  ::protozero::ConstBytes device_pm_callback_end() const { return at<505>().as_bytes(); }
+  bool has_thermal_exynos_acpm_bulk() const { return at<506>().valid(); }
+  ::protozero::ConstBytes thermal_exynos_acpm_bulk() const { return at<506>().as_bytes(); }
+  bool has_thermal_exynos_acpm_high_overhead() const { return at<507>().valid(); }
+  ::protozero::ConstBytes thermal_exynos_acpm_high_overhead() const { return at<507>().as_bytes(); }
+  bool has_dcvsh_freq() const { return at<508>().valid(); }
+  ::protozero::ConstBytes dcvsh_freq() const { return at<508>().as_bytes(); }
+  bool has_kgsl_gpu_frequency() const { return at<509>().valid(); }
+  ::protozero::ConstBytes kgsl_gpu_frequency() const { return at<509>().as_bytes(); }
+  bool has_mali_mali_pm_mcu_hctl_cores_down_scale_notify_pend() const { return at<510>().valid(); }
+  ::protozero::ConstBytes mali_mali_pm_mcu_hctl_cores_down_scale_notify_pend() const { return at<510>().as_bytes(); }
+  bool has_mali_mali_pm_mcu_hctl_cores_notify_pend() const { return at<511>().valid(); }
+  ::protozero::ConstBytes mali_mali_pm_mcu_hctl_cores_notify_pend() const { return at<511>().as_bytes(); }
+  bool has_mali_mali_pm_mcu_hctl_core_inactive_pend() const { return at<512>().valid(); }
+  ::protozero::ConstBytes mali_mali_pm_mcu_hctl_core_inactive_pend() const { return at<512>().as_bytes(); }
+  bool has_mali_mali_pm_mcu_hctl_mcu_on_recheck() const { return at<513>().valid(); }
+  ::protozero::ConstBytes mali_mali_pm_mcu_hctl_mcu_on_recheck() const { return at<513>().as_bytes(); }
+  bool has_mali_mali_pm_mcu_hctl_shaders_core_off_pend() const { return at<514>().valid(); }
+  ::protozero::ConstBytes mali_mali_pm_mcu_hctl_shaders_core_off_pend() const { return at<514>().as_bytes(); }
+  bool has_mali_mali_pm_mcu_hctl_shaders_pend_off() const { return at<515>().valid(); }
+  ::protozero::ConstBytes mali_mali_pm_mcu_hctl_shaders_pend_off() const { return at<515>().as_bytes(); }
+  bool has_mali_mali_pm_mcu_hctl_shaders_pend_on() const { return at<516>().valid(); }
+  ::protozero::ConstBytes mali_mali_pm_mcu_hctl_shaders_pend_on() const { return at<516>().as_bytes(); }
+  bool has_mali_mali_pm_mcu_hctl_shaders_ready_off() const { return at<517>().valid(); }
+  ::protozero::ConstBytes mali_mali_pm_mcu_hctl_shaders_ready_off() const { return at<517>().as_bytes(); }
+  bool has_mali_mali_pm_mcu_in_sleep() const { return at<518>().valid(); }
+  ::protozero::ConstBytes mali_mali_pm_mcu_in_sleep() const { return at<518>().as_bytes(); }
+  bool has_mali_mali_pm_mcu_off() const { return at<519>().valid(); }
+  ::protozero::ConstBytes mali_mali_pm_mcu_off() const { return at<519>().as_bytes(); }
+  bool has_mali_mali_pm_mcu_on() const { return at<520>().valid(); }
+  ::protozero::ConstBytes mali_mali_pm_mcu_on() const { return at<520>().as_bytes(); }
+  bool has_mali_mali_pm_mcu_on_core_attr_update_pend() const { return at<521>().valid(); }
+  ::protozero::ConstBytes mali_mali_pm_mcu_on_core_attr_update_pend() const { return at<521>().as_bytes(); }
+  bool has_mali_mali_pm_mcu_on_glb_reinit_pend() const { return at<522>().valid(); }
+  ::protozero::ConstBytes mali_mali_pm_mcu_on_glb_reinit_pend() const { return at<522>().as_bytes(); }
+  bool has_mali_mali_pm_mcu_on_halt() const { return at<523>().valid(); }
+  ::protozero::ConstBytes mali_mali_pm_mcu_on_halt() const { return at<523>().as_bytes(); }
+  bool has_mali_mali_pm_mcu_on_hwcnt_disable() const { return at<524>().valid(); }
+  ::protozero::ConstBytes mali_mali_pm_mcu_on_hwcnt_disable() const { return at<524>().as_bytes(); }
+  bool has_mali_mali_pm_mcu_on_hwcnt_enable() const { return at<525>().valid(); }
+  ::protozero::ConstBytes mali_mali_pm_mcu_on_hwcnt_enable() const { return at<525>().as_bytes(); }
+  bool has_mali_mali_pm_mcu_on_pend_halt() const { return at<526>().valid(); }
+  ::protozero::ConstBytes mali_mali_pm_mcu_on_pend_halt() const { return at<526>().as_bytes(); }
+  bool has_mali_mali_pm_mcu_on_pend_sleep() const { return at<527>().valid(); }
+  ::protozero::ConstBytes mali_mali_pm_mcu_on_pend_sleep() const { return at<527>().as_bytes(); }
+  bool has_mali_mali_pm_mcu_on_sleep_initiate() const { return at<528>().valid(); }
+  ::protozero::ConstBytes mali_mali_pm_mcu_on_sleep_initiate() const { return at<528>().as_bytes(); }
+  bool has_mali_mali_pm_mcu_pend_off() const { return at<529>().valid(); }
+  ::protozero::ConstBytes mali_mali_pm_mcu_pend_off() const { return at<529>().as_bytes(); }
+  bool has_mali_mali_pm_mcu_pend_on_reload() const { return at<530>().valid(); }
+  ::protozero::ConstBytes mali_mali_pm_mcu_pend_on_reload() const { return at<530>().as_bytes(); }
+  bool has_mali_mali_pm_mcu_power_down() const { return at<531>().valid(); }
+  ::protozero::ConstBytes mali_mali_pm_mcu_power_down() const { return at<531>().as_bytes(); }
+  bool has_mali_mali_pm_mcu_reset_wait() const { return at<532>().valid(); }
+  ::protozero::ConstBytes mali_mali_pm_mcu_reset_wait() const { return at<532>().as_bytes(); }
+  bool has_bcl_irq_trigger() const { return at<533>().valid(); }
+  ::protozero::ConstBytes bcl_irq_trigger() const { return at<533>().as_bytes(); }
+  bool has_kgsl_adreno_cmdbatch_queued() const { return at<534>().valid(); }
+  ::protozero::ConstBytes kgsl_adreno_cmdbatch_queued() const { return at<534>().as_bytes(); }
+  bool has_kgsl_adreno_cmdbatch_submitted() const { return at<535>().valid(); }
+  ::protozero::ConstBytes kgsl_adreno_cmdbatch_submitted() const { return at<535>().as_bytes(); }
+  bool has_kgsl_adreno_cmdbatch_sync() const { return at<536>().valid(); }
+  ::protozero::ConstBytes kgsl_adreno_cmdbatch_sync() const { return at<536>().as_bytes(); }
+  bool has_kgsl_adreno_cmdbatch_retired() const { return at<537>().valid(); }
+  ::protozero::ConstBytes kgsl_adreno_cmdbatch_retired() const { return at<537>().as_bytes(); }
+  bool has_pixel_mm_kswapd_wake() const { return at<538>().valid(); }
+  ::protozero::ConstBytes pixel_mm_kswapd_wake() const { return at<538>().as_bytes(); }
+  bool has_pixel_mm_kswapd_done() const { return at<539>().valid(); }
+  ::protozero::ConstBytes pixel_mm_kswapd_done() const { return at<539>().as_bytes(); }
+  bool has_sched_wakeup_task_attr() const { return at<540>().valid(); }
+  ::protozero::ConstBytes sched_wakeup_task_attr() const { return at<540>().as_bytes(); }
+  bool has_devfreq_frequency() const { return at<541>().valid(); }
+  ::protozero::ConstBytes devfreq_frequency() const { return at<541>().as_bytes(); }
+  bool has_kprobe_event() const { return at<542>().valid(); }
+  ::protozero::ConstBytes kprobe_event() const { return at<542>().as_bytes(); }
+  bool has_param_set_value_cpm() const { return at<543>().valid(); }
+  ::protozero::ConstBytes param_set_value_cpm() const { return at<543>().as_bytes(); }
+  bool has_do_sys_open() const { return at<544>().valid(); }
+  ::protozero::ConstBytes do_sys_open() const { return at<544>().as_bytes(); }
+  bool has_open_exec() const { return at<545>().valid(); }
+  ::protozero::ConstBytes open_exec() const { return at<545>().as_bytes(); }
+  bool has_block_io_start() const { return at<546>().valid(); }
+  ::protozero::ConstBytes block_io_start() const { return at<546>().as_bytes(); }
+  bool has_block_io_done() const { return at<547>().valid(); }
+  ::protozero::ConstBytes block_io_done() const { return at<547>().as_bytes(); }
+  bool has_mali_gpu_power_state() const { return at<548>().valid(); }
+  ::protozero::ConstBytes mali_gpu_power_state() const { return at<548>().as_bytes(); }
+  bool has_dpu_disp_dpu_underrun() const { return at<549>().valid(); }
+  ::protozero::ConstBytes dpu_disp_dpu_underrun() const { return at<549>().as_bytes(); }
+  bool has_dpu_disp_vblank_irq_enable() const { return at<550>().valid(); }
+  ::protozero::ConstBytes dpu_disp_vblank_irq_enable() const { return at<550>().as_bytes(); }
+  bool has_hrtimer_start() const { return at<551>().valid(); }
+  ::protozero::ConstBytes hrtimer_start() const { return at<551>().as_bytes(); }
+  bool has_hrtimer_cancel() const { return at<552>().valid(); }
+  ::protozero::ConstBytes hrtimer_cancel() const { return at<552>().as_bytes(); }
+  bool has_hrtimer_expire_entry() const { return at<553>().valid(); }
+  ::protozero::ConstBytes hrtimer_expire_entry() const { return at<553>().as_bytes(); }
+  bool has_hrtimer_expire_exit() const { return at<554>().valid(); }
+  ::protozero::ConstBytes hrtimer_expire_exit() const { return at<554>().as_bytes(); }
+  bool has_timer_start() const { return at<555>().valid(); }
+  ::protozero::ConstBytes timer_start() const { return at<555>().as_bytes(); }
+  bool has_timer_cancel() const { return at<556>().valid(); }
+  ::protozero::ConstBytes timer_cancel() const { return at<556>().as_bytes(); }
+  bool has_timer_expire_entry() const { return at<557>().valid(); }
+  ::protozero::ConstBytes timer_expire_entry() const { return at<557>().as_bytes(); }
+  bool has_timer_expire_exit() const { return at<558>().valid(); }
+  ::protozero::ConstBytes timer_expire_exit() const { return at<558>().as_bytes(); }
+  bool has_local_timer_entry() const { return at<559>().valid(); }
+  ::protozero::ConstBytes local_timer_entry() const { return at<559>().as_bytes(); }
+  bool has_local_timer_exit() const { return at<560>().valid(); }
+  ::protozero::ConstBytes local_timer_exit() const { return at<560>().as_bytes(); }
+  bool has_dwc3_alloc_request() const { return at<561>().valid(); }
+  ::protozero::ConstBytes dwc3_alloc_request() const { return at<561>().as_bytes(); }
+  bool has_dwc3_complete_trb() const { return at<562>().valid(); }
+  ::protozero::ConstBytes dwc3_complete_trb() const { return at<562>().as_bytes(); }
+  bool has_dwc3_ctrl_req() const { return at<563>().valid(); }
+  ::protozero::ConstBytes dwc3_ctrl_req() const { return at<563>().as_bytes(); }
+  bool has_dwc3_ep_dequeue() const { return at<564>().valid(); }
+  ::protozero::ConstBytes dwc3_ep_dequeue() const { return at<564>().as_bytes(); }
+  bool has_dwc3_ep_queue() const { return at<565>().valid(); }
+  ::protozero::ConstBytes dwc3_ep_queue() const { return at<565>().as_bytes(); }
+  bool has_dwc3_event() const { return at<566>().valid(); }
+  ::protozero::ConstBytes dwc3_event() const { return at<566>().as_bytes(); }
+  bool has_dwc3_free_request() const { return at<567>().valid(); }
+  ::protozero::ConstBytes dwc3_free_request() const { return at<567>().as_bytes(); }
+  bool has_dwc3_gadget_ep_cmd() const { return at<568>().valid(); }
+  ::protozero::ConstBytes dwc3_gadget_ep_cmd() const { return at<568>().as_bytes(); }
+  bool has_dwc3_gadget_ep_disable() const { return at<569>().valid(); }
+  ::protozero::ConstBytes dwc3_gadget_ep_disable() const { return at<569>().as_bytes(); }
+  bool has_dwc3_gadget_ep_enable() const { return at<570>().valid(); }
+  ::protozero::ConstBytes dwc3_gadget_ep_enable() const { return at<570>().as_bytes(); }
+  bool has_dwc3_gadget_generic_cmd() const { return at<571>().valid(); }
+  ::protozero::ConstBytes dwc3_gadget_generic_cmd() const { return at<571>().as_bytes(); }
+  bool has_dwc3_gadget_giveback() const { return at<572>().valid(); }
+  ::protozero::ConstBytes dwc3_gadget_giveback() const { return at<572>().as_bytes(); }
+  bool has_dwc3_prepare_trb() const { return at<573>().valid(); }
+  ::protozero::ConstBytes dwc3_prepare_trb() const { return at<573>().as_bytes(); }
+  bool has_dwc3_readl() const { return at<574>().valid(); }
+  ::protozero::ConstBytes dwc3_readl() const { return at<574>().as_bytes(); }
+  bool has_dwc3_writel() const { return at<575>().valid(); }
+  ::protozero::ConstBytes dwc3_writel() const { return at<575>().as_bytes(); }
+  bool has_cma_alloc_finish() const { return at<576>().valid(); }
+  ::protozero::ConstBytes cma_alloc_finish() const { return at<576>().as_bytes(); }
+  bool has_mm_alloc_contig_migrate_range_info() const { return at<577>().valid(); }
+  ::protozero::ConstBytes mm_alloc_contig_migrate_range_info() const { return at<577>().as_bytes(); }
+  bool has_host_ffa_call() const { return at<578>().valid(); }
+  ::protozero::ConstBytes host_ffa_call() const { return at<578>().as_bytes(); }
+  bool has_dmabuf_rss_stat() const { return at<579>().valid(); }
+  ::protozero::ConstBytes dmabuf_rss_stat() const { return at<579>().as_bytes(); }
+  bool has_iommu_idmap() const { return at<580>().valid(); }
+  ::protozero::ConstBytes iommu_idmap() const { return at<580>().as_bytes(); }
+  bool has_psci_mem_protect() const { return at<581>().valid(); }
+  ::protozero::ConstBytes psci_mem_protect() const { return at<581>().as_bytes(); }
+  bool has_hypervisor_host_hcall() const { return at<582>().valid(); }
+  ::protozero::ConstBytes hypervisor_host_hcall() const { return at<582>().as_bytes(); }
+  bool has_hypervisor_host_smc() const { return at<583>().valid(); }
+  ::protozero::ConstBytes hypervisor_host_smc() const { return at<583>().as_bytes(); }
+  bool has_hypervisor_hyp_exit() const { return at<584>().valid(); }
+  ::protozero::ConstBytes hypervisor_hyp_exit() const { return at<584>().as_bytes(); }
+  bool has_hypervisor_iommu_idmap() const { return at<585>().valid(); }
+  ::protozero::ConstBytes hypervisor_iommu_idmap() const { return at<585>().as_bytes(); }
+  bool has_hypervisor_psci_mem_protect() const { return at<586>().valid(); }
+  ::protozero::ConstBytes hypervisor_psci_mem_protect() const { return at<586>().as_bytes(); }
+  bool has_hypervisor_host_mem_abort() const { return at<587>().valid(); }
+  ::protozero::ConstBytes hypervisor_host_mem_abort() const { return at<587>().as_bytes(); }
+  bool has_hypervisor_hyp_enter() const { return at<588>().valid(); }
+  ::protozero::ConstBytes hypervisor_hyp_enter() const { return at<588>().as_bytes(); }
+  bool has_hypervisor_iommu_idmap_complete() const { return at<589>().valid(); }
+  ::protozero::ConstBytes hypervisor_iommu_idmap_complete() const { return at<589>().as_bytes(); }
+  bool has_hypervisor_vcpu_illegal_trap() const { return at<590>().valid(); }
+  ::protozero::ConstBytes hypervisor_vcpu_illegal_trap() const { return at<590>().as_bytes(); }
+  bool has_drm_sched_job_add_dep() const { return at<591>().valid(); }
+  ::protozero::ConstBytes drm_sched_job_add_dep() const { return at<591>().as_bytes(); }
+  bool has_drm_sched_job_done() const { return at<592>().valid(); }
+  ::protozero::ConstBytes drm_sched_job_done() const { return at<592>().as_bytes(); }
+  bool has_drm_sched_job_queue() const { return at<593>().valid(); }
+  ::protozero::ConstBytes drm_sched_job_queue() const { return at<593>().as_bytes(); }
+  bool has_drm_sched_job_run() const { return at<594>().valid(); }
+  ::protozero::ConstBytes drm_sched_job_run() const { return at<594>().as_bytes(); }
+  bool has_drm_sched_job_unschedulable() const { return at<595>().valid(); }
+  ::protozero::ConstBytes drm_sched_job_unschedulable() const { return at<595>().as_bytes(); }
+  bool has_fwtp_perfetto_counter() const { return at<596>().valid(); }
+  ::protozero::ConstBytes fwtp_perfetto_counter() const { return at<596>().as_bytes(); }
+  bool has_scsi_dispatch_cmd_error() const { return at<597>().valid(); }
+  ::protozero::ConstBytes scsi_dispatch_cmd_error() const { return at<597>().as_bytes(); }
+  bool has_scsi_dispatch_cmd_timeout() const { return at<598>().valid(); }
+  ::protozero::ConstBytes scsi_dispatch_cmd_timeout() const { return at<598>().as_bytes(); }
+  bool has_scsi_eh_wakeup() const { return at<599>().valid(); }
+  ::protozero::ConstBytes scsi_eh_wakeup() const { return at<599>().as_bytes(); }
+  bool has_fwtp_perfetto_slice() const { return at<600>().valid(); }
+  ::protozero::ConstBytes fwtp_perfetto_slice() const { return at<600>().as_bytes(); }
+  bool has_gpu_power_state() const { return at<601>().valid(); }
+  ::protozero::ConstBytes gpu_power_state() const { return at<601>().as_bytes(); }
+  bool has_gram_collision() const { return at<602>().valid(); }
+  ::protozero::ConstBytes gram_collision() const { return at<602>().as_bytes(); }
 };
 
 class FtraceEvent : public ::protozero::Message {
@@ -54163,6 +89087,7 @@ class FtraceEvent : public ::protozero::Message {
   enum : int32_t {
     kTimestampFieldNumber = 1,
     kPidFieldNumber = 2,
+    kCommonFlagsFieldNumber = 5,
     kPrintFieldNumber = 3,
     kSchedSwitchFieldNumber = 4,
     kCpuFrequencyFieldNumber = 11,
@@ -54617,6 +89542,133 @@ class FtraceEvent : public ::protozero::Message {
     kMaliMaliKCPUFENCESIGNALFieldNumber = 473,
     kMaliMaliKCPUFENCEWAITSTARTFieldNumber = 474,
     kMaliMaliKCPUFENCEWAITENDFieldNumber = 475,
+    kHypEnterFieldNumber = 476,
+    kHypExitFieldNumber = 477,
+    kHostHcallFieldNumber = 478,
+    kHostSmcFieldNumber = 479,
+    kHostMemAbortFieldNumber = 480,
+    kSuspendResumeMinimalFieldNumber = 481,
+    kMaliMaliCSFINTERRUPTSTARTFieldNumber = 482,
+    kMaliMaliCSFINTERRUPTENDFieldNumber = 483,
+    kSamsungTracingMarkWriteFieldNumber = 484,
+    kBinderCommandFieldNumber = 485,
+    kBinderReturnFieldNumber = 486,
+    kSchedSwitchWithCtrsFieldNumber = 487,
+    kGpuWorkPeriodFieldNumber = 488,
+    kRpmStatusFieldNumber = 489,
+    kPanelWriteGenericFieldNumber = 490,
+    kSchedMigrateTaskFieldNumber = 491,
+    kDpuDsiCmdFifoStatusFieldNumber = 492,
+    kDpuDsiRxFieldNumber = 493,
+    kDpuDsiTxFieldNumber = 494,
+    kF2fsBackgroundGcFieldNumber = 495,
+    kF2fsGcBeginFieldNumber = 496,
+    kF2fsGcEndFieldNumber = 497,
+    kFastrpcDmaFreeFieldNumber = 498,
+    kFastrpcDmaAllocFieldNumber = 499,
+    kFastrpcDmaUnmapFieldNumber = 500,
+    kFastrpcDmaMapFieldNumber = 501,
+    kGoogleIccEventFieldNumber = 502,
+    kGoogleIrmEventFieldNumber = 503,
+    kDevicePmCallbackStartFieldNumber = 504,
+    kDevicePmCallbackEndFieldNumber = 505,
+    kThermalExynosAcpmBulkFieldNumber = 506,
+    kThermalExynosAcpmHighOverheadFieldNumber = 507,
+    kDcvshFreqFieldNumber = 508,
+    kKgslGpuFrequencyFieldNumber = 509,
+    kMaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFieldNumber = 510,
+    kMaliMaliPMMCUHCTLCORESNOTIFYPENDFieldNumber = 511,
+    kMaliMaliPMMCUHCTLCOREINACTIVEPENDFieldNumber = 512,
+    kMaliMaliPMMCUHCTLMCUONRECHECKFieldNumber = 513,
+    kMaliMaliPMMCUHCTLSHADERSCOREOFFPENDFieldNumber = 514,
+    kMaliMaliPMMCUHCTLSHADERSPENDOFFFieldNumber = 515,
+    kMaliMaliPMMCUHCTLSHADERSPENDONFieldNumber = 516,
+    kMaliMaliPMMCUHCTLSHADERSREADYOFFFieldNumber = 517,
+    kMaliMaliPMMCUINSLEEPFieldNumber = 518,
+    kMaliMaliPMMCUOFFFieldNumber = 519,
+    kMaliMaliPMMCUONFieldNumber = 520,
+    kMaliMaliPMMCUONCOREATTRUPDATEPENDFieldNumber = 521,
+    kMaliMaliPMMCUONGLBREINITPENDFieldNumber = 522,
+    kMaliMaliPMMCUONHALTFieldNumber = 523,
+    kMaliMaliPMMCUONHWCNTDISABLEFieldNumber = 524,
+    kMaliMaliPMMCUONHWCNTENABLEFieldNumber = 525,
+    kMaliMaliPMMCUONPENDHALTFieldNumber = 526,
+    kMaliMaliPMMCUONPENDSLEEPFieldNumber = 527,
+    kMaliMaliPMMCUONSLEEPINITIATEFieldNumber = 528,
+    kMaliMaliPMMCUPENDOFFFieldNumber = 529,
+    kMaliMaliPMMCUPENDONRELOADFieldNumber = 530,
+    kMaliMaliPMMCUPOWERDOWNFieldNumber = 531,
+    kMaliMaliPMMCURESETWAITFieldNumber = 532,
+    kBclIrqTriggerFieldNumber = 533,
+    kKgslAdrenoCmdbatchQueuedFieldNumber = 534,
+    kKgslAdrenoCmdbatchSubmittedFieldNumber = 535,
+    kKgslAdrenoCmdbatchSyncFieldNumber = 536,
+    kKgslAdrenoCmdbatchRetiredFieldNumber = 537,
+    kPixelMmKswapdWakeFieldNumber = 538,
+    kPixelMmKswapdDoneFieldNumber = 539,
+    kSchedWakeupTaskAttrFieldNumber = 540,
+    kDevfreqFrequencyFieldNumber = 541,
+    kKprobeEventFieldNumber = 542,
+    kParamSetValueCpmFieldNumber = 543,
+    kDoSysOpenFieldNumber = 544,
+    kOpenExecFieldNumber = 545,
+    kBlockIoStartFieldNumber = 546,
+    kBlockIoDoneFieldNumber = 547,
+    kMaliGpuPowerStateFieldNumber = 548,
+    kDpuDispDpuUnderrunFieldNumber = 549,
+    kDpuDispVblankIrqEnableFieldNumber = 550,
+    kHrtimerStartFieldNumber = 551,
+    kHrtimerCancelFieldNumber = 552,
+    kHrtimerExpireEntryFieldNumber = 553,
+    kHrtimerExpireExitFieldNumber = 554,
+    kTimerStartFieldNumber = 555,
+    kTimerCancelFieldNumber = 556,
+    kTimerExpireEntryFieldNumber = 557,
+    kTimerExpireExitFieldNumber = 558,
+    kLocalTimerEntryFieldNumber = 559,
+    kLocalTimerExitFieldNumber = 560,
+    kDwc3AllocRequestFieldNumber = 561,
+    kDwc3CompleteTrbFieldNumber = 562,
+    kDwc3CtrlReqFieldNumber = 563,
+    kDwc3EpDequeueFieldNumber = 564,
+    kDwc3EpQueueFieldNumber = 565,
+    kDwc3EventFieldNumber = 566,
+    kDwc3FreeRequestFieldNumber = 567,
+    kDwc3GadgetEpCmdFieldNumber = 568,
+    kDwc3GadgetEpDisableFieldNumber = 569,
+    kDwc3GadgetEpEnableFieldNumber = 570,
+    kDwc3GadgetGenericCmdFieldNumber = 571,
+    kDwc3GadgetGivebackFieldNumber = 572,
+    kDwc3PrepareTrbFieldNumber = 573,
+    kDwc3ReadlFieldNumber = 574,
+    kDwc3WritelFieldNumber = 575,
+    kCmaAllocFinishFieldNumber = 576,
+    kMmAllocContigMigrateRangeInfoFieldNumber = 577,
+    kHostFfaCallFieldNumber = 578,
+    kDmabufRssStatFieldNumber = 579,
+    kIommuIdmapFieldNumber = 580,
+    kPsciMemProtectFieldNumber = 581,
+    kHypervisorHostHcallFieldNumber = 582,
+    kHypervisorHostSmcFieldNumber = 583,
+    kHypervisorHypExitFieldNumber = 584,
+    kHypervisorIommuIdmapFieldNumber = 585,
+    kHypervisorPsciMemProtectFieldNumber = 586,
+    kHypervisorHostMemAbortFieldNumber = 587,
+    kHypervisorHypEnterFieldNumber = 588,
+    kHypervisorIommuIdmapCompleteFieldNumber = 589,
+    kHypervisorVcpuIllegalTrapFieldNumber = 590,
+    kDrmSchedJobAddDepFieldNumber = 591,
+    kDrmSchedJobDoneFieldNumber = 592,
+    kDrmSchedJobQueueFieldNumber = 593,
+    kDrmSchedJobRunFieldNumber = 594,
+    kDrmSchedJobUnschedulableFieldNumber = 595,
+    kFwtpPerfettoCounterFieldNumber = 596,
+    kScsiDispatchCmdErrorFieldNumber = 597,
+    kScsiDispatchCmdTimeoutFieldNumber = 598,
+    kScsiEhWakeupFieldNumber = 599,
+    kFwtpPerfettoSliceFieldNumber = 600,
+    kGpuPowerStateFieldNumber = 601,
+    kGramCollisionFieldNumber = 602,
   };
   static constexpr const char* GetName() { return ".perfetto.protos.FtraceEvent"; }
 
@@ -54629,14 +89681,7 @@ class FtraceEvent : public ::protozero::Message {
       uint64_t,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timestamp kTimestamp() { return {}; }
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
   void set_timestamp(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -54654,14 +89699,7 @@ class FtraceEvent : public ::protozero::Message {
       uint32_t,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
+  static constexpr FieldMetadata_Pid kPid{};
   void set_pid(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -54671,6 +89709,24 @@ class FtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
+  using FieldMetadata_CommonFlags =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_CommonFlags kCommonFlags{};
+  void set_common_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CommonFlags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
   using FieldMetadata_Print =
     ::protozero::proto_utils::FieldMetadata<
       3,
@@ -54679,14 +89735,7 @@ class FtraceEvent : public ::protozero::Message {
       PrintFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Print kPrint() { return {}; }
+  static constexpr FieldMetadata_Print kPrint{};
   template <typename T = PrintFtraceEvent> T* set_print() {
     return BeginNestedMessage<T>(3);
   }
@@ -54700,14 +89749,7 @@ class FtraceEvent : public ::protozero::Message {
       SchedSwitchFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SchedSwitch kSchedSwitch() { return {}; }
+  static constexpr FieldMetadata_SchedSwitch kSchedSwitch{};
   template <typename T = SchedSwitchFtraceEvent> T* set_sched_switch() {
     return BeginNestedMessage<T>(4);
   }
@@ -54721,14 +89763,7 @@ class FtraceEvent : public ::protozero::Message {
       CpuFrequencyFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpuFrequency kCpuFrequency() { return {}; }
+  static constexpr FieldMetadata_CpuFrequency kCpuFrequency{};
   template <typename T = CpuFrequencyFtraceEvent> T* set_cpu_frequency() {
     return BeginNestedMessage<T>(11);
   }
@@ -54742,14 +89777,7 @@ class FtraceEvent : public ::protozero::Message {
       CpuFrequencyLimitsFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpuFrequencyLimits kCpuFrequencyLimits() { return {}; }
+  static constexpr FieldMetadata_CpuFrequencyLimits kCpuFrequencyLimits{};
   template <typename T = CpuFrequencyLimitsFtraceEvent> T* set_cpu_frequency_limits() {
     return BeginNestedMessage<T>(12);
   }
@@ -54763,14 +89791,7 @@ class FtraceEvent : public ::protozero::Message {
       CpuIdleFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpuIdle kCpuIdle() { return {}; }
+  static constexpr FieldMetadata_CpuIdle kCpuIdle{};
   template <typename T = CpuIdleFtraceEvent> T* set_cpu_idle() {
     return BeginNestedMessage<T>(13);
   }
@@ -54784,14 +89805,7 @@ class FtraceEvent : public ::protozero::Message {
       ClockEnableFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClockEnable kClockEnable() { return {}; }
+  static constexpr FieldMetadata_ClockEnable kClockEnable{};
   template <typename T = ClockEnableFtraceEvent> T* set_clock_enable() {
     return BeginNestedMessage<T>(14);
   }
@@ -54805,14 +89819,7 @@ class FtraceEvent : public ::protozero::Message {
       ClockDisableFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClockDisable kClockDisable() { return {}; }
+  static constexpr FieldMetadata_ClockDisable kClockDisable{};
   template <typename T = ClockDisableFtraceEvent> T* set_clock_disable() {
     return BeginNestedMessage<T>(15);
   }
@@ -54826,14 +89833,7 @@ class FtraceEvent : public ::protozero::Message {
       ClockSetRateFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClockSetRate kClockSetRate() { return {}; }
+  static constexpr FieldMetadata_ClockSetRate kClockSetRate{};
   template <typename T = ClockSetRateFtraceEvent> T* set_clock_set_rate() {
     return BeginNestedMessage<T>(16);
   }
@@ -54847,14 +89847,7 @@ class FtraceEvent : public ::protozero::Message {
       SchedWakeupFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SchedWakeup kSchedWakeup() { return {}; }
+  static constexpr FieldMetadata_SchedWakeup kSchedWakeup{};
   template <typename T = SchedWakeupFtraceEvent> T* set_sched_wakeup() {
     return BeginNestedMessage<T>(17);
   }
@@ -54868,14 +89861,7 @@ class FtraceEvent : public ::protozero::Message {
       SchedBlockedReasonFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SchedBlockedReason kSchedBlockedReason() { return {}; }
+  static constexpr FieldMetadata_SchedBlockedReason kSchedBlockedReason{};
   template <typename T = SchedBlockedReasonFtraceEvent> T* set_sched_blocked_reason() {
     return BeginNestedMessage<T>(18);
   }
@@ -54889,14 +89875,7 @@ class FtraceEvent : public ::protozero::Message {
       SchedCpuHotplugFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SchedCpuHotplug kSchedCpuHotplug() { return {}; }
+  static constexpr FieldMetadata_SchedCpuHotplug kSchedCpuHotplug{};
   template <typename T = SchedCpuHotplugFtraceEvent> T* set_sched_cpu_hotplug() {
     return BeginNestedMessage<T>(19);
   }
@@ -54910,14 +89889,7 @@ class FtraceEvent : public ::protozero::Message {
       SchedWakingFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SchedWaking kSchedWaking() { return {}; }
+  static constexpr FieldMetadata_SchedWaking kSchedWaking{};
   template <typename T = SchedWakingFtraceEvent> T* set_sched_waking() {
     return BeginNestedMessage<T>(20);
   }
@@ -54931,14 +89903,7 @@ class FtraceEvent : public ::protozero::Message {
       IpiEntryFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IpiEntry kIpiEntry() { return {}; }
+  static constexpr FieldMetadata_IpiEntry kIpiEntry{};
   template <typename T = IpiEntryFtraceEvent> T* set_ipi_entry() {
     return BeginNestedMessage<T>(21);
   }
@@ -54952,14 +89917,7 @@ class FtraceEvent : public ::protozero::Message {
       IpiExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IpiExit kIpiExit() { return {}; }
+  static constexpr FieldMetadata_IpiExit kIpiExit{};
   template <typename T = IpiExitFtraceEvent> T* set_ipi_exit() {
     return BeginNestedMessage<T>(22);
   }
@@ -54973,14 +89931,7 @@ class FtraceEvent : public ::protozero::Message {
       IpiRaiseFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IpiRaise kIpiRaise() { return {}; }
+  static constexpr FieldMetadata_IpiRaise kIpiRaise{};
   template <typename T = IpiRaiseFtraceEvent> T* set_ipi_raise() {
     return BeginNestedMessage<T>(23);
   }
@@ -54994,14 +89945,7 @@ class FtraceEvent : public ::protozero::Message {
       SoftirqEntryFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SoftirqEntry kSoftirqEntry() { return {}; }
+  static constexpr FieldMetadata_SoftirqEntry kSoftirqEntry{};
   template <typename T = SoftirqEntryFtraceEvent> T* set_softirq_entry() {
     return BeginNestedMessage<T>(24);
   }
@@ -55015,14 +89959,7 @@ class FtraceEvent : public ::protozero::Message {
       SoftirqExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SoftirqExit kSoftirqExit() { return {}; }
+  static constexpr FieldMetadata_SoftirqExit kSoftirqExit{};
   template <typename T = SoftirqExitFtraceEvent> T* set_softirq_exit() {
     return BeginNestedMessage<T>(25);
   }
@@ -55036,14 +89973,7 @@ class FtraceEvent : public ::protozero::Message {
       SoftirqRaiseFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SoftirqRaise kSoftirqRaise() { return {}; }
+  static constexpr FieldMetadata_SoftirqRaise kSoftirqRaise{};
   template <typename T = SoftirqRaiseFtraceEvent> T* set_softirq_raise() {
     return BeginNestedMessage<T>(26);
   }
@@ -55057,14 +89987,7 @@ class FtraceEvent : public ::protozero::Message {
       I2cReadFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_I2cRead kI2cRead() { return {}; }
+  static constexpr FieldMetadata_I2cRead kI2cRead{};
   template <typename T = I2cReadFtraceEvent> T* set_i2c_read() {
     return BeginNestedMessage<T>(27);
   }
@@ -55078,14 +90001,7 @@ class FtraceEvent : public ::protozero::Message {
       I2cWriteFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_I2cWrite kI2cWrite() { return {}; }
+  static constexpr FieldMetadata_I2cWrite kI2cWrite{};
   template <typename T = I2cWriteFtraceEvent> T* set_i2c_write() {
     return BeginNestedMessage<T>(28);
   }
@@ -55099,14 +90015,7 @@ class FtraceEvent : public ::protozero::Message {
       I2cResultFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_I2cResult kI2cResult() { return {}; }
+  static constexpr FieldMetadata_I2cResult kI2cResult{};
   template <typename T = I2cResultFtraceEvent> T* set_i2c_result() {
     return BeginNestedMessage<T>(29);
   }
@@ -55120,14 +90029,7 @@ class FtraceEvent : public ::protozero::Message {
       I2cReplyFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_I2cReply kI2cReply() { return {}; }
+  static constexpr FieldMetadata_I2cReply kI2cReply{};
   template <typename T = I2cReplyFtraceEvent> T* set_i2c_reply() {
     return BeginNestedMessage<T>(30);
   }
@@ -55141,14 +90043,7 @@ class FtraceEvent : public ::protozero::Message {
       SmbusReadFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SmbusRead kSmbusRead() { return {}; }
+  static constexpr FieldMetadata_SmbusRead kSmbusRead{};
   template <typename T = SmbusReadFtraceEvent> T* set_smbus_read() {
     return BeginNestedMessage<T>(31);
   }
@@ -55162,14 +90057,7 @@ class FtraceEvent : public ::protozero::Message {
       SmbusWriteFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SmbusWrite kSmbusWrite() { return {}; }
+  static constexpr FieldMetadata_SmbusWrite kSmbusWrite{};
   template <typename T = SmbusWriteFtraceEvent> T* set_smbus_write() {
     return BeginNestedMessage<T>(32);
   }
@@ -55183,14 +90071,7 @@ class FtraceEvent : public ::protozero::Message {
       SmbusResultFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SmbusResult kSmbusResult() { return {}; }
+  static constexpr FieldMetadata_SmbusResult kSmbusResult{};
   template <typename T = SmbusResultFtraceEvent> T* set_smbus_result() {
     return BeginNestedMessage<T>(33);
   }
@@ -55204,14 +90085,7 @@ class FtraceEvent : public ::protozero::Message {
       SmbusReplyFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SmbusReply kSmbusReply() { return {}; }
+  static constexpr FieldMetadata_SmbusReply kSmbusReply{};
   template <typename T = SmbusReplyFtraceEvent> T* set_smbus_reply() {
     return BeginNestedMessage<T>(34);
   }
@@ -55225,14 +90099,7 @@ class FtraceEvent : public ::protozero::Message {
       LowmemoryKillFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LowmemoryKill kLowmemoryKill() { return {}; }
+  static constexpr FieldMetadata_LowmemoryKill kLowmemoryKill{};
   template <typename T = LowmemoryKillFtraceEvent> T* set_lowmemory_kill() {
     return BeginNestedMessage<T>(35);
   }
@@ -55246,14 +90113,7 @@ class FtraceEvent : public ::protozero::Message {
       IrqHandlerEntryFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IrqHandlerEntry kIrqHandlerEntry() { return {}; }
+  static constexpr FieldMetadata_IrqHandlerEntry kIrqHandlerEntry{};
   template <typename T = IrqHandlerEntryFtraceEvent> T* set_irq_handler_entry() {
     return BeginNestedMessage<T>(36);
   }
@@ -55267,14 +90127,7 @@ class FtraceEvent : public ::protozero::Message {
       IrqHandlerExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IrqHandlerExit kIrqHandlerExit() { return {}; }
+  static constexpr FieldMetadata_IrqHandlerExit kIrqHandlerExit{};
   template <typename T = IrqHandlerExitFtraceEvent> T* set_irq_handler_exit() {
     return BeginNestedMessage<T>(37);
   }
@@ -55288,14 +90141,7 @@ class FtraceEvent : public ::protozero::Message {
       SyncPtFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SyncPt kSyncPt() { return {}; }
+  static constexpr FieldMetadata_SyncPt kSyncPt{};
   template <typename T = SyncPtFtraceEvent> T* set_sync_pt() {
     return BeginNestedMessage<T>(38);
   }
@@ -55309,14 +90155,7 @@ class FtraceEvent : public ::protozero::Message {
       SyncTimelineFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SyncTimeline kSyncTimeline() { return {}; }
+  static constexpr FieldMetadata_SyncTimeline kSyncTimeline{};
   template <typename T = SyncTimelineFtraceEvent> T* set_sync_timeline() {
     return BeginNestedMessage<T>(39);
   }
@@ -55330,14 +90169,7 @@ class FtraceEvent : public ::protozero::Message {
       SyncWaitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SyncWait kSyncWait() { return {}; }
+  static constexpr FieldMetadata_SyncWait kSyncWait{};
   template <typename T = SyncWaitFtraceEvent> T* set_sync_wait() {
     return BeginNestedMessage<T>(40);
   }
@@ -55351,14 +90183,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4DaWriteBeginFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4DaWriteBegin kExt4DaWriteBegin() { return {}; }
+  static constexpr FieldMetadata_Ext4DaWriteBegin kExt4DaWriteBegin{};
   template <typename T = Ext4DaWriteBeginFtraceEvent> T* set_ext4_da_write_begin() {
     return BeginNestedMessage<T>(41);
   }
@@ -55372,14 +90197,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4DaWriteEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4DaWriteEnd kExt4DaWriteEnd() { return {}; }
+  static constexpr FieldMetadata_Ext4DaWriteEnd kExt4DaWriteEnd{};
   template <typename T = Ext4DaWriteEndFtraceEvent> T* set_ext4_da_write_end() {
     return BeginNestedMessage<T>(42);
   }
@@ -55393,14 +90211,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4SyncFileEnterFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4SyncFileEnter kExt4SyncFileEnter() { return {}; }
+  static constexpr FieldMetadata_Ext4SyncFileEnter kExt4SyncFileEnter{};
   template <typename T = Ext4SyncFileEnterFtraceEvent> T* set_ext4_sync_file_enter() {
     return BeginNestedMessage<T>(43);
   }
@@ -55414,14 +90225,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4SyncFileExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4SyncFileExit kExt4SyncFileExit() { return {}; }
+  static constexpr FieldMetadata_Ext4SyncFileExit kExt4SyncFileExit{};
   template <typename T = Ext4SyncFileExitFtraceEvent> T* set_ext4_sync_file_exit() {
     return BeginNestedMessage<T>(44);
   }
@@ -55435,14 +90239,7 @@ class FtraceEvent : public ::protozero::Message {
       BlockRqIssueFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockRqIssue kBlockRqIssue() { return {}; }
+  static constexpr FieldMetadata_BlockRqIssue kBlockRqIssue{};
   template <typename T = BlockRqIssueFtraceEvent> T* set_block_rq_issue() {
     return BeginNestedMessage<T>(45);
   }
@@ -55456,14 +90253,7 @@ class FtraceEvent : public ::protozero::Message {
       MmVmscanDirectReclaimBeginFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmVmscanDirectReclaimBegin kMmVmscanDirectReclaimBegin() { return {}; }
+  static constexpr FieldMetadata_MmVmscanDirectReclaimBegin kMmVmscanDirectReclaimBegin{};
   template <typename T = MmVmscanDirectReclaimBeginFtraceEvent> T* set_mm_vmscan_direct_reclaim_begin() {
     return BeginNestedMessage<T>(46);
   }
@@ -55477,14 +90267,7 @@ class FtraceEvent : public ::protozero::Message {
       MmVmscanDirectReclaimEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmVmscanDirectReclaimEnd kMmVmscanDirectReclaimEnd() { return {}; }
+  static constexpr FieldMetadata_MmVmscanDirectReclaimEnd kMmVmscanDirectReclaimEnd{};
   template <typename T = MmVmscanDirectReclaimEndFtraceEvent> T* set_mm_vmscan_direct_reclaim_end() {
     return BeginNestedMessage<T>(47);
   }
@@ -55498,14 +90281,7 @@ class FtraceEvent : public ::protozero::Message {
       MmVmscanKswapdWakeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmVmscanKswapdWake kMmVmscanKswapdWake() { return {}; }
+  static constexpr FieldMetadata_MmVmscanKswapdWake kMmVmscanKswapdWake{};
   template <typename T = MmVmscanKswapdWakeFtraceEvent> T* set_mm_vmscan_kswapd_wake() {
     return BeginNestedMessage<T>(48);
   }
@@ -55519,14 +90295,7 @@ class FtraceEvent : public ::protozero::Message {
       MmVmscanKswapdSleepFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmVmscanKswapdSleep kMmVmscanKswapdSleep() { return {}; }
+  static constexpr FieldMetadata_MmVmscanKswapdSleep kMmVmscanKswapdSleep{};
   template <typename T = MmVmscanKswapdSleepFtraceEvent> T* set_mm_vmscan_kswapd_sleep() {
     return BeginNestedMessage<T>(49);
   }
@@ -55540,14 +90309,7 @@ class FtraceEvent : public ::protozero::Message {
       BinderTransactionFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BinderTransaction kBinderTransaction() { return {}; }
+  static constexpr FieldMetadata_BinderTransaction kBinderTransaction{};
   template <typename T = BinderTransactionFtraceEvent> T* set_binder_transaction() {
     return BeginNestedMessage<T>(50);
   }
@@ -55561,14 +90323,7 @@ class FtraceEvent : public ::protozero::Message {
       BinderTransactionReceivedFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BinderTransactionReceived kBinderTransactionReceived() { return {}; }
+  static constexpr FieldMetadata_BinderTransactionReceived kBinderTransactionReceived{};
   template <typename T = BinderTransactionReceivedFtraceEvent> T* set_binder_transaction_received() {
     return BeginNestedMessage<T>(51);
   }
@@ -55582,14 +90337,7 @@ class FtraceEvent : public ::protozero::Message {
       BinderSetPriorityFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BinderSetPriority kBinderSetPriority() { return {}; }
+  static constexpr FieldMetadata_BinderSetPriority kBinderSetPriority{};
   template <typename T = BinderSetPriorityFtraceEvent> T* set_binder_set_priority() {
     return BeginNestedMessage<T>(52);
   }
@@ -55603,14 +90351,7 @@ class FtraceEvent : public ::protozero::Message {
       BinderLockFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BinderLock kBinderLock() { return {}; }
+  static constexpr FieldMetadata_BinderLock kBinderLock{};
   template <typename T = BinderLockFtraceEvent> T* set_binder_lock() {
     return BeginNestedMessage<T>(53);
   }
@@ -55624,14 +90365,7 @@ class FtraceEvent : public ::protozero::Message {
       BinderLockedFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BinderLocked kBinderLocked() { return {}; }
+  static constexpr FieldMetadata_BinderLocked kBinderLocked{};
   template <typename T = BinderLockedFtraceEvent> T* set_binder_locked() {
     return BeginNestedMessage<T>(54);
   }
@@ -55645,14 +90379,7 @@ class FtraceEvent : public ::protozero::Message {
       BinderUnlockFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BinderUnlock kBinderUnlock() { return {}; }
+  static constexpr FieldMetadata_BinderUnlock kBinderUnlock{};
   template <typename T = BinderUnlockFtraceEvent> T* set_binder_unlock() {
     return BeginNestedMessage<T>(55);
   }
@@ -55666,14 +90393,7 @@ class FtraceEvent : public ::protozero::Message {
       WorkqueueActivateWorkFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WorkqueueActivateWork kWorkqueueActivateWork() { return {}; }
+  static constexpr FieldMetadata_WorkqueueActivateWork kWorkqueueActivateWork{};
   template <typename T = WorkqueueActivateWorkFtraceEvent> T* set_workqueue_activate_work() {
     return BeginNestedMessage<T>(56);
   }
@@ -55687,14 +90407,7 @@ class FtraceEvent : public ::protozero::Message {
       WorkqueueExecuteEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WorkqueueExecuteEnd kWorkqueueExecuteEnd() { return {}; }
+  static constexpr FieldMetadata_WorkqueueExecuteEnd kWorkqueueExecuteEnd{};
   template <typename T = WorkqueueExecuteEndFtraceEvent> T* set_workqueue_execute_end() {
     return BeginNestedMessage<T>(57);
   }
@@ -55708,14 +90421,7 @@ class FtraceEvent : public ::protozero::Message {
       WorkqueueExecuteStartFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WorkqueueExecuteStart kWorkqueueExecuteStart() { return {}; }
+  static constexpr FieldMetadata_WorkqueueExecuteStart kWorkqueueExecuteStart{};
   template <typename T = WorkqueueExecuteStartFtraceEvent> T* set_workqueue_execute_start() {
     return BeginNestedMessage<T>(58);
   }
@@ -55729,14 +90435,7 @@ class FtraceEvent : public ::protozero::Message {
       WorkqueueQueueWorkFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WorkqueueQueueWork kWorkqueueQueueWork() { return {}; }
+  static constexpr FieldMetadata_WorkqueueQueueWork kWorkqueueQueueWork{};
   template <typename T = WorkqueueQueueWorkFtraceEvent> T* set_workqueue_queue_work() {
     return BeginNestedMessage<T>(59);
   }
@@ -55750,14 +90449,7 @@ class FtraceEvent : public ::protozero::Message {
       RegulatorDisableFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RegulatorDisable kRegulatorDisable() { return {}; }
+  static constexpr FieldMetadata_RegulatorDisable kRegulatorDisable{};
   template <typename T = RegulatorDisableFtraceEvent> T* set_regulator_disable() {
     return BeginNestedMessage<T>(60);
   }
@@ -55771,14 +90463,7 @@ class FtraceEvent : public ::protozero::Message {
       RegulatorDisableCompleteFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RegulatorDisableComplete kRegulatorDisableComplete() { return {}; }
+  static constexpr FieldMetadata_RegulatorDisableComplete kRegulatorDisableComplete{};
   template <typename T = RegulatorDisableCompleteFtraceEvent> T* set_regulator_disable_complete() {
     return BeginNestedMessage<T>(61);
   }
@@ -55792,14 +90477,7 @@ class FtraceEvent : public ::protozero::Message {
       RegulatorEnableFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RegulatorEnable kRegulatorEnable() { return {}; }
+  static constexpr FieldMetadata_RegulatorEnable kRegulatorEnable{};
   template <typename T = RegulatorEnableFtraceEvent> T* set_regulator_enable() {
     return BeginNestedMessage<T>(62);
   }
@@ -55813,14 +90491,7 @@ class FtraceEvent : public ::protozero::Message {
       RegulatorEnableCompleteFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RegulatorEnableComplete kRegulatorEnableComplete() { return {}; }
+  static constexpr FieldMetadata_RegulatorEnableComplete kRegulatorEnableComplete{};
   template <typename T = RegulatorEnableCompleteFtraceEvent> T* set_regulator_enable_complete() {
     return BeginNestedMessage<T>(63);
   }
@@ -55834,14 +90505,7 @@ class FtraceEvent : public ::protozero::Message {
       RegulatorEnableDelayFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RegulatorEnableDelay kRegulatorEnableDelay() { return {}; }
+  static constexpr FieldMetadata_RegulatorEnableDelay kRegulatorEnableDelay{};
   template <typename T = RegulatorEnableDelayFtraceEvent> T* set_regulator_enable_delay() {
     return BeginNestedMessage<T>(64);
   }
@@ -55855,14 +90519,7 @@ class FtraceEvent : public ::protozero::Message {
       RegulatorSetVoltageFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RegulatorSetVoltage kRegulatorSetVoltage() { return {}; }
+  static constexpr FieldMetadata_RegulatorSetVoltage kRegulatorSetVoltage{};
   template <typename T = RegulatorSetVoltageFtraceEvent> T* set_regulator_set_voltage() {
     return BeginNestedMessage<T>(65);
   }
@@ -55876,14 +90533,7 @@ class FtraceEvent : public ::protozero::Message {
       RegulatorSetVoltageCompleteFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RegulatorSetVoltageComplete kRegulatorSetVoltageComplete() { return {}; }
+  static constexpr FieldMetadata_RegulatorSetVoltageComplete kRegulatorSetVoltageComplete{};
   template <typename T = RegulatorSetVoltageCompleteFtraceEvent> T* set_regulator_set_voltage_complete() {
     return BeginNestedMessage<T>(66);
   }
@@ -55897,14 +90547,7 @@ class FtraceEvent : public ::protozero::Message {
       CgroupAttachTaskFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CgroupAttachTask kCgroupAttachTask() { return {}; }
+  static constexpr FieldMetadata_CgroupAttachTask kCgroupAttachTask{};
   template <typename T = CgroupAttachTaskFtraceEvent> T* set_cgroup_attach_task() {
     return BeginNestedMessage<T>(67);
   }
@@ -55918,14 +90561,7 @@ class FtraceEvent : public ::protozero::Message {
       CgroupMkdirFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CgroupMkdir kCgroupMkdir() { return {}; }
+  static constexpr FieldMetadata_CgroupMkdir kCgroupMkdir{};
   template <typename T = CgroupMkdirFtraceEvent> T* set_cgroup_mkdir() {
     return BeginNestedMessage<T>(68);
   }
@@ -55939,14 +90575,7 @@ class FtraceEvent : public ::protozero::Message {
       CgroupRemountFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CgroupRemount kCgroupRemount() { return {}; }
+  static constexpr FieldMetadata_CgroupRemount kCgroupRemount{};
   template <typename T = CgroupRemountFtraceEvent> T* set_cgroup_remount() {
     return BeginNestedMessage<T>(69);
   }
@@ -55960,14 +90589,7 @@ class FtraceEvent : public ::protozero::Message {
       CgroupRmdirFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CgroupRmdir kCgroupRmdir() { return {}; }
+  static constexpr FieldMetadata_CgroupRmdir kCgroupRmdir{};
   template <typename T = CgroupRmdirFtraceEvent> T* set_cgroup_rmdir() {
     return BeginNestedMessage<T>(70);
   }
@@ -55981,14 +90603,7 @@ class FtraceEvent : public ::protozero::Message {
       CgroupTransferTasksFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CgroupTransferTasks kCgroupTransferTasks() { return {}; }
+  static constexpr FieldMetadata_CgroupTransferTasks kCgroupTransferTasks{};
   template <typename T = CgroupTransferTasksFtraceEvent> T* set_cgroup_transfer_tasks() {
     return BeginNestedMessage<T>(71);
   }
@@ -56002,14 +90617,7 @@ class FtraceEvent : public ::protozero::Message {
       CgroupDestroyRootFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CgroupDestroyRoot kCgroupDestroyRoot() { return {}; }
+  static constexpr FieldMetadata_CgroupDestroyRoot kCgroupDestroyRoot{};
   template <typename T = CgroupDestroyRootFtraceEvent> T* set_cgroup_destroy_root() {
     return BeginNestedMessage<T>(72);
   }
@@ -56023,14 +90631,7 @@ class FtraceEvent : public ::protozero::Message {
       CgroupReleaseFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CgroupRelease kCgroupRelease() { return {}; }
+  static constexpr FieldMetadata_CgroupRelease kCgroupRelease{};
   template <typename T = CgroupReleaseFtraceEvent> T* set_cgroup_release() {
     return BeginNestedMessage<T>(73);
   }
@@ -56044,14 +90645,7 @@ class FtraceEvent : public ::protozero::Message {
       CgroupRenameFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CgroupRename kCgroupRename() { return {}; }
+  static constexpr FieldMetadata_CgroupRename kCgroupRename{};
   template <typename T = CgroupRenameFtraceEvent> T* set_cgroup_rename() {
     return BeginNestedMessage<T>(74);
   }
@@ -56065,14 +90659,7 @@ class FtraceEvent : public ::protozero::Message {
       CgroupSetupRootFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CgroupSetupRoot kCgroupSetupRoot() { return {}; }
+  static constexpr FieldMetadata_CgroupSetupRoot kCgroupSetupRoot{};
   template <typename T = CgroupSetupRootFtraceEvent> T* set_cgroup_setup_root() {
     return BeginNestedMessage<T>(75);
   }
@@ -56086,14 +90673,7 @@ class FtraceEvent : public ::protozero::Message {
       MdpCmdKickoffFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MdpCmdKickoff kMdpCmdKickoff() { return {}; }
+  static constexpr FieldMetadata_MdpCmdKickoff kMdpCmdKickoff{};
   template <typename T = MdpCmdKickoffFtraceEvent> T* set_mdp_cmd_kickoff() {
     return BeginNestedMessage<T>(76);
   }
@@ -56107,14 +90687,7 @@ class FtraceEvent : public ::protozero::Message {
       MdpCommitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MdpCommit kMdpCommit() { return {}; }
+  static constexpr FieldMetadata_MdpCommit kMdpCommit{};
   template <typename T = MdpCommitFtraceEvent> T* set_mdp_commit() {
     return BeginNestedMessage<T>(77);
   }
@@ -56128,14 +90701,7 @@ class FtraceEvent : public ::protozero::Message {
       MdpPerfSetOtFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MdpPerfSetOt kMdpPerfSetOt() { return {}; }
+  static constexpr FieldMetadata_MdpPerfSetOt kMdpPerfSetOt{};
   template <typename T = MdpPerfSetOtFtraceEvent> T* set_mdp_perf_set_ot() {
     return BeginNestedMessage<T>(78);
   }
@@ -56149,14 +90715,7 @@ class FtraceEvent : public ::protozero::Message {
       MdpSsppChangeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MdpSsppChange kMdpSsppChange() { return {}; }
+  static constexpr FieldMetadata_MdpSsppChange kMdpSsppChange{};
   template <typename T = MdpSsppChangeFtraceEvent> T* set_mdp_sspp_change() {
     return BeginNestedMessage<T>(79);
   }
@@ -56170,14 +90729,7 @@ class FtraceEvent : public ::protozero::Message {
       TracingMarkWriteFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TracingMarkWrite kTracingMarkWrite() { return {}; }
+  static constexpr FieldMetadata_TracingMarkWrite kTracingMarkWrite{};
   template <typename T = TracingMarkWriteFtraceEvent> T* set_tracing_mark_write() {
     return BeginNestedMessage<T>(80);
   }
@@ -56191,14 +90743,7 @@ class FtraceEvent : public ::protozero::Message {
       MdpCmdPingpongDoneFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MdpCmdPingpongDone kMdpCmdPingpongDone() { return {}; }
+  static constexpr FieldMetadata_MdpCmdPingpongDone kMdpCmdPingpongDone{};
   template <typename T = MdpCmdPingpongDoneFtraceEvent> T* set_mdp_cmd_pingpong_done() {
     return BeginNestedMessage<T>(81);
   }
@@ -56212,14 +90757,7 @@ class FtraceEvent : public ::protozero::Message {
       MdpCompareBwFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MdpCompareBw kMdpCompareBw() { return {}; }
+  static constexpr FieldMetadata_MdpCompareBw kMdpCompareBw{};
   template <typename T = MdpCompareBwFtraceEvent> T* set_mdp_compare_bw() {
     return BeginNestedMessage<T>(82);
   }
@@ -56233,14 +90771,7 @@ class FtraceEvent : public ::protozero::Message {
       MdpPerfSetPanicLutsFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MdpPerfSetPanicLuts kMdpPerfSetPanicLuts() { return {}; }
+  static constexpr FieldMetadata_MdpPerfSetPanicLuts kMdpPerfSetPanicLuts{};
   template <typename T = MdpPerfSetPanicLutsFtraceEvent> T* set_mdp_perf_set_panic_luts() {
     return BeginNestedMessage<T>(83);
   }
@@ -56254,14 +90785,7 @@ class FtraceEvent : public ::protozero::Message {
       MdpSsppSetFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MdpSsppSet kMdpSsppSet() { return {}; }
+  static constexpr FieldMetadata_MdpSsppSet kMdpSsppSet{};
   template <typename T = MdpSsppSetFtraceEvent> T* set_mdp_sspp_set() {
     return BeginNestedMessage<T>(84);
   }
@@ -56275,14 +90799,7 @@ class FtraceEvent : public ::protozero::Message {
       MdpCmdReadptrDoneFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MdpCmdReadptrDone kMdpCmdReadptrDone() { return {}; }
+  static constexpr FieldMetadata_MdpCmdReadptrDone kMdpCmdReadptrDone{};
   template <typename T = MdpCmdReadptrDoneFtraceEvent> T* set_mdp_cmd_readptr_done() {
     return BeginNestedMessage<T>(85);
   }
@@ -56296,14 +90813,7 @@ class FtraceEvent : public ::protozero::Message {
       MdpMisrCrcFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MdpMisrCrc kMdpMisrCrc() { return {}; }
+  static constexpr FieldMetadata_MdpMisrCrc kMdpMisrCrc{};
   template <typename T = MdpMisrCrcFtraceEvent> T* set_mdp_misr_crc() {
     return BeginNestedMessage<T>(86);
   }
@@ -56317,14 +90827,7 @@ class FtraceEvent : public ::protozero::Message {
       MdpPerfSetQosLutsFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MdpPerfSetQosLuts kMdpPerfSetQosLuts() { return {}; }
+  static constexpr FieldMetadata_MdpPerfSetQosLuts kMdpPerfSetQosLuts{};
   template <typename T = MdpPerfSetQosLutsFtraceEvent> T* set_mdp_perf_set_qos_luts() {
     return BeginNestedMessage<T>(87);
   }
@@ -56338,14 +90841,7 @@ class FtraceEvent : public ::protozero::Message {
       MdpTraceCounterFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MdpTraceCounter kMdpTraceCounter() { return {}; }
+  static constexpr FieldMetadata_MdpTraceCounter kMdpTraceCounter{};
   template <typename T = MdpTraceCounterFtraceEvent> T* set_mdp_trace_counter() {
     return BeginNestedMessage<T>(88);
   }
@@ -56359,14 +90855,7 @@ class FtraceEvent : public ::protozero::Message {
       MdpCmdReleaseBwFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MdpCmdReleaseBw kMdpCmdReleaseBw() { return {}; }
+  static constexpr FieldMetadata_MdpCmdReleaseBw kMdpCmdReleaseBw{};
   template <typename T = MdpCmdReleaseBwFtraceEvent> T* set_mdp_cmd_release_bw() {
     return BeginNestedMessage<T>(89);
   }
@@ -56380,14 +90869,7 @@ class FtraceEvent : public ::protozero::Message {
       MdpMixerUpdateFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MdpMixerUpdate kMdpMixerUpdate() { return {}; }
+  static constexpr FieldMetadata_MdpMixerUpdate kMdpMixerUpdate{};
   template <typename T = MdpMixerUpdateFtraceEvent> T* set_mdp_mixer_update() {
     return BeginNestedMessage<T>(90);
   }
@@ -56401,14 +90883,7 @@ class FtraceEvent : public ::protozero::Message {
       MdpPerfSetWmLevelsFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MdpPerfSetWmLevels kMdpPerfSetWmLevels() { return {}; }
+  static constexpr FieldMetadata_MdpPerfSetWmLevels kMdpPerfSetWmLevels{};
   template <typename T = MdpPerfSetWmLevelsFtraceEvent> T* set_mdp_perf_set_wm_levels() {
     return BeginNestedMessage<T>(91);
   }
@@ -56422,14 +90897,7 @@ class FtraceEvent : public ::protozero::Message {
       MdpVideoUnderrunDoneFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MdpVideoUnderrunDone kMdpVideoUnderrunDone() { return {}; }
+  static constexpr FieldMetadata_MdpVideoUnderrunDone kMdpVideoUnderrunDone{};
   template <typename T = MdpVideoUnderrunDoneFtraceEvent> T* set_mdp_video_underrun_done() {
     return BeginNestedMessage<T>(92);
   }
@@ -56443,14 +90911,7 @@ class FtraceEvent : public ::protozero::Message {
       MdpCmdWaitPingpongFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MdpCmdWaitPingpong kMdpCmdWaitPingpong() { return {}; }
+  static constexpr FieldMetadata_MdpCmdWaitPingpong kMdpCmdWaitPingpong{};
   template <typename T = MdpCmdWaitPingpongFtraceEvent> T* set_mdp_cmd_wait_pingpong() {
     return BeginNestedMessage<T>(93);
   }
@@ -56464,14 +90925,7 @@ class FtraceEvent : public ::protozero::Message {
       MdpPerfPrefillCalcFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MdpPerfPrefillCalc kMdpPerfPrefillCalc() { return {}; }
+  static constexpr FieldMetadata_MdpPerfPrefillCalc kMdpPerfPrefillCalc{};
   template <typename T = MdpPerfPrefillCalcFtraceEvent> T* set_mdp_perf_prefill_calc() {
     return BeginNestedMessage<T>(94);
   }
@@ -56485,14 +90939,7 @@ class FtraceEvent : public ::protozero::Message {
       MdpPerfUpdateBusFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MdpPerfUpdateBus kMdpPerfUpdateBus() { return {}; }
+  static constexpr FieldMetadata_MdpPerfUpdateBus kMdpPerfUpdateBus{};
   template <typename T = MdpPerfUpdateBusFtraceEvent> T* set_mdp_perf_update_bus() {
     return BeginNestedMessage<T>(95);
   }
@@ -56506,14 +90953,7 @@ class FtraceEvent : public ::protozero::Message {
       RotatorBwAoAsContextFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RotatorBwAoAsContext kRotatorBwAoAsContext() { return {}; }
+  static constexpr FieldMetadata_RotatorBwAoAsContext kRotatorBwAoAsContext{};
   template <typename T = RotatorBwAoAsContextFtraceEvent> T* set_rotator_bw_ao_as_context() {
     return BeginNestedMessage<T>(96);
   }
@@ -56527,14 +90967,7 @@ class FtraceEvent : public ::protozero::Message {
       MmFilemapAddToPageCacheFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmFilemapAddToPageCache kMmFilemapAddToPageCache() { return {}; }
+  static constexpr FieldMetadata_MmFilemapAddToPageCache kMmFilemapAddToPageCache{};
   template <typename T = MmFilemapAddToPageCacheFtraceEvent> T* set_mm_filemap_add_to_page_cache() {
     return BeginNestedMessage<T>(97);
   }
@@ -56548,14 +90981,7 @@ class FtraceEvent : public ::protozero::Message {
       MmFilemapDeleteFromPageCacheFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmFilemapDeleteFromPageCache kMmFilemapDeleteFromPageCache() { return {}; }
+  static constexpr FieldMetadata_MmFilemapDeleteFromPageCache kMmFilemapDeleteFromPageCache{};
   template <typename T = MmFilemapDeleteFromPageCacheFtraceEvent> T* set_mm_filemap_delete_from_page_cache() {
     return BeginNestedMessage<T>(98);
   }
@@ -56569,14 +90995,7 @@ class FtraceEvent : public ::protozero::Message {
       MmCompactionBeginFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmCompactionBegin kMmCompactionBegin() { return {}; }
+  static constexpr FieldMetadata_MmCompactionBegin kMmCompactionBegin{};
   template <typename T = MmCompactionBeginFtraceEvent> T* set_mm_compaction_begin() {
     return BeginNestedMessage<T>(99);
   }
@@ -56590,14 +91009,7 @@ class FtraceEvent : public ::protozero::Message {
       MmCompactionDeferCompactionFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmCompactionDeferCompaction kMmCompactionDeferCompaction() { return {}; }
+  static constexpr FieldMetadata_MmCompactionDeferCompaction kMmCompactionDeferCompaction{};
   template <typename T = MmCompactionDeferCompactionFtraceEvent> T* set_mm_compaction_defer_compaction() {
     return BeginNestedMessage<T>(100);
   }
@@ -56611,14 +91023,7 @@ class FtraceEvent : public ::protozero::Message {
       MmCompactionDeferredFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmCompactionDeferred kMmCompactionDeferred() { return {}; }
+  static constexpr FieldMetadata_MmCompactionDeferred kMmCompactionDeferred{};
   template <typename T = MmCompactionDeferredFtraceEvent> T* set_mm_compaction_deferred() {
     return BeginNestedMessage<T>(101);
   }
@@ -56632,14 +91037,7 @@ class FtraceEvent : public ::protozero::Message {
       MmCompactionDeferResetFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmCompactionDeferReset kMmCompactionDeferReset() { return {}; }
+  static constexpr FieldMetadata_MmCompactionDeferReset kMmCompactionDeferReset{};
   template <typename T = MmCompactionDeferResetFtraceEvent> T* set_mm_compaction_defer_reset() {
     return BeginNestedMessage<T>(102);
   }
@@ -56653,14 +91051,7 @@ class FtraceEvent : public ::protozero::Message {
       MmCompactionEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmCompactionEnd kMmCompactionEnd() { return {}; }
+  static constexpr FieldMetadata_MmCompactionEnd kMmCompactionEnd{};
   template <typename T = MmCompactionEndFtraceEvent> T* set_mm_compaction_end() {
     return BeginNestedMessage<T>(103);
   }
@@ -56674,14 +91065,7 @@ class FtraceEvent : public ::protozero::Message {
       MmCompactionFinishedFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmCompactionFinished kMmCompactionFinished() { return {}; }
+  static constexpr FieldMetadata_MmCompactionFinished kMmCompactionFinished{};
   template <typename T = MmCompactionFinishedFtraceEvent> T* set_mm_compaction_finished() {
     return BeginNestedMessage<T>(104);
   }
@@ -56695,14 +91079,7 @@ class FtraceEvent : public ::protozero::Message {
       MmCompactionIsolateFreepagesFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmCompactionIsolateFreepages kMmCompactionIsolateFreepages() { return {}; }
+  static constexpr FieldMetadata_MmCompactionIsolateFreepages kMmCompactionIsolateFreepages{};
   template <typename T = MmCompactionIsolateFreepagesFtraceEvent> T* set_mm_compaction_isolate_freepages() {
     return BeginNestedMessage<T>(105);
   }
@@ -56716,14 +91093,7 @@ class FtraceEvent : public ::protozero::Message {
       MmCompactionIsolateMigratepagesFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmCompactionIsolateMigratepages kMmCompactionIsolateMigratepages() { return {}; }
+  static constexpr FieldMetadata_MmCompactionIsolateMigratepages kMmCompactionIsolateMigratepages{};
   template <typename T = MmCompactionIsolateMigratepagesFtraceEvent> T* set_mm_compaction_isolate_migratepages() {
     return BeginNestedMessage<T>(106);
   }
@@ -56737,14 +91107,7 @@ class FtraceEvent : public ::protozero::Message {
       MmCompactionKcompactdSleepFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmCompactionKcompactdSleep kMmCompactionKcompactdSleep() { return {}; }
+  static constexpr FieldMetadata_MmCompactionKcompactdSleep kMmCompactionKcompactdSleep{};
   template <typename T = MmCompactionKcompactdSleepFtraceEvent> T* set_mm_compaction_kcompactd_sleep() {
     return BeginNestedMessage<T>(107);
   }
@@ -56758,14 +91121,7 @@ class FtraceEvent : public ::protozero::Message {
       MmCompactionKcompactdWakeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmCompactionKcompactdWake kMmCompactionKcompactdWake() { return {}; }
+  static constexpr FieldMetadata_MmCompactionKcompactdWake kMmCompactionKcompactdWake{};
   template <typename T = MmCompactionKcompactdWakeFtraceEvent> T* set_mm_compaction_kcompactd_wake() {
     return BeginNestedMessage<T>(108);
   }
@@ -56779,14 +91135,7 @@ class FtraceEvent : public ::protozero::Message {
       MmCompactionMigratepagesFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmCompactionMigratepages kMmCompactionMigratepages() { return {}; }
+  static constexpr FieldMetadata_MmCompactionMigratepages kMmCompactionMigratepages{};
   template <typename T = MmCompactionMigratepagesFtraceEvent> T* set_mm_compaction_migratepages() {
     return BeginNestedMessage<T>(109);
   }
@@ -56800,14 +91149,7 @@ class FtraceEvent : public ::protozero::Message {
       MmCompactionSuitableFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmCompactionSuitable kMmCompactionSuitable() { return {}; }
+  static constexpr FieldMetadata_MmCompactionSuitable kMmCompactionSuitable{};
   template <typename T = MmCompactionSuitableFtraceEvent> T* set_mm_compaction_suitable() {
     return BeginNestedMessage<T>(110);
   }
@@ -56821,14 +91163,7 @@ class FtraceEvent : public ::protozero::Message {
       MmCompactionTryToCompactPagesFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmCompactionTryToCompactPages kMmCompactionTryToCompactPages() { return {}; }
+  static constexpr FieldMetadata_MmCompactionTryToCompactPages kMmCompactionTryToCompactPages{};
   template <typename T = MmCompactionTryToCompactPagesFtraceEvent> T* set_mm_compaction_try_to_compact_pages() {
     return BeginNestedMessage<T>(111);
   }
@@ -56842,14 +91177,7 @@ class FtraceEvent : public ::protozero::Message {
       MmCompactionWakeupKcompactdFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmCompactionWakeupKcompactd kMmCompactionWakeupKcompactd() { return {}; }
+  static constexpr FieldMetadata_MmCompactionWakeupKcompactd kMmCompactionWakeupKcompactd{};
   template <typename T = MmCompactionWakeupKcompactdFtraceEvent> T* set_mm_compaction_wakeup_kcompactd() {
     return BeginNestedMessage<T>(112);
   }
@@ -56863,14 +91191,7 @@ class FtraceEvent : public ::protozero::Message {
       SuspendResumeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SuspendResume kSuspendResume() { return {}; }
+  static constexpr FieldMetadata_SuspendResume kSuspendResume{};
   template <typename T = SuspendResumeFtraceEvent> T* set_suspend_resume() {
     return BeginNestedMessage<T>(113);
   }
@@ -56884,14 +91205,7 @@ class FtraceEvent : public ::protozero::Message {
       SchedWakeupNewFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SchedWakeupNew kSchedWakeupNew() { return {}; }
+  static constexpr FieldMetadata_SchedWakeupNew kSchedWakeupNew{};
   template <typename T = SchedWakeupNewFtraceEvent> T* set_sched_wakeup_new() {
     return BeginNestedMessage<T>(114);
   }
@@ -56905,14 +91219,7 @@ class FtraceEvent : public ::protozero::Message {
       BlockBioBackmergeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockBioBackmerge kBlockBioBackmerge() { return {}; }
+  static constexpr FieldMetadata_BlockBioBackmerge kBlockBioBackmerge{};
   template <typename T = BlockBioBackmergeFtraceEvent> T* set_block_bio_backmerge() {
     return BeginNestedMessage<T>(115);
   }
@@ -56926,14 +91233,7 @@ class FtraceEvent : public ::protozero::Message {
       BlockBioBounceFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockBioBounce kBlockBioBounce() { return {}; }
+  static constexpr FieldMetadata_BlockBioBounce kBlockBioBounce{};
   template <typename T = BlockBioBounceFtraceEvent> T* set_block_bio_bounce() {
     return BeginNestedMessage<T>(116);
   }
@@ -56947,14 +91247,7 @@ class FtraceEvent : public ::protozero::Message {
       BlockBioCompleteFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockBioComplete kBlockBioComplete() { return {}; }
+  static constexpr FieldMetadata_BlockBioComplete kBlockBioComplete{};
   template <typename T = BlockBioCompleteFtraceEvent> T* set_block_bio_complete() {
     return BeginNestedMessage<T>(117);
   }
@@ -56968,14 +91261,7 @@ class FtraceEvent : public ::protozero::Message {
       BlockBioFrontmergeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockBioFrontmerge kBlockBioFrontmerge() { return {}; }
+  static constexpr FieldMetadata_BlockBioFrontmerge kBlockBioFrontmerge{};
   template <typename T = BlockBioFrontmergeFtraceEvent> T* set_block_bio_frontmerge() {
     return BeginNestedMessage<T>(118);
   }
@@ -56989,14 +91275,7 @@ class FtraceEvent : public ::protozero::Message {
       BlockBioQueueFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockBioQueue kBlockBioQueue() { return {}; }
+  static constexpr FieldMetadata_BlockBioQueue kBlockBioQueue{};
   template <typename T = BlockBioQueueFtraceEvent> T* set_block_bio_queue() {
     return BeginNestedMessage<T>(119);
   }
@@ -57010,14 +91289,7 @@ class FtraceEvent : public ::protozero::Message {
       BlockBioRemapFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockBioRemap kBlockBioRemap() { return {}; }
+  static constexpr FieldMetadata_BlockBioRemap kBlockBioRemap{};
   template <typename T = BlockBioRemapFtraceEvent> T* set_block_bio_remap() {
     return BeginNestedMessage<T>(120);
   }
@@ -57031,14 +91303,7 @@ class FtraceEvent : public ::protozero::Message {
       BlockDirtyBufferFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockDirtyBuffer kBlockDirtyBuffer() { return {}; }
+  static constexpr FieldMetadata_BlockDirtyBuffer kBlockDirtyBuffer{};
   template <typename T = BlockDirtyBufferFtraceEvent> T* set_block_dirty_buffer() {
     return BeginNestedMessage<T>(121);
   }
@@ -57052,14 +91317,7 @@ class FtraceEvent : public ::protozero::Message {
       BlockGetrqFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockGetrq kBlockGetrq() { return {}; }
+  static constexpr FieldMetadata_BlockGetrq kBlockGetrq{};
   template <typename T = BlockGetrqFtraceEvent> T* set_block_getrq() {
     return BeginNestedMessage<T>(122);
   }
@@ -57073,14 +91331,7 @@ class FtraceEvent : public ::protozero::Message {
       BlockPlugFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockPlug kBlockPlug() { return {}; }
+  static constexpr FieldMetadata_BlockPlug kBlockPlug{};
   template <typename T = BlockPlugFtraceEvent> T* set_block_plug() {
     return BeginNestedMessage<T>(123);
   }
@@ -57094,14 +91345,7 @@ class FtraceEvent : public ::protozero::Message {
       BlockRqAbortFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockRqAbort kBlockRqAbort() { return {}; }
+  static constexpr FieldMetadata_BlockRqAbort kBlockRqAbort{};
   template <typename T = BlockRqAbortFtraceEvent> T* set_block_rq_abort() {
     return BeginNestedMessage<T>(124);
   }
@@ -57115,14 +91359,7 @@ class FtraceEvent : public ::protozero::Message {
       BlockRqCompleteFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockRqComplete kBlockRqComplete() { return {}; }
+  static constexpr FieldMetadata_BlockRqComplete kBlockRqComplete{};
   template <typename T = BlockRqCompleteFtraceEvent> T* set_block_rq_complete() {
     return BeginNestedMessage<T>(125);
   }
@@ -57136,14 +91373,7 @@ class FtraceEvent : public ::protozero::Message {
       BlockRqInsertFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockRqInsert kBlockRqInsert() { return {}; }
+  static constexpr FieldMetadata_BlockRqInsert kBlockRqInsert{};
   template <typename T = BlockRqInsertFtraceEvent> T* set_block_rq_insert() {
     return BeginNestedMessage<T>(126);
   }
@@ -57157,14 +91387,7 @@ class FtraceEvent : public ::protozero::Message {
       BlockRqRemapFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockRqRemap kBlockRqRemap() { return {}; }
+  static constexpr FieldMetadata_BlockRqRemap kBlockRqRemap{};
   template <typename T = BlockRqRemapFtraceEvent> T* set_block_rq_remap() {
     return BeginNestedMessage<T>(128);
   }
@@ -57178,14 +91401,7 @@ class FtraceEvent : public ::protozero::Message {
       BlockRqRequeueFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockRqRequeue kBlockRqRequeue() { return {}; }
+  static constexpr FieldMetadata_BlockRqRequeue kBlockRqRequeue{};
   template <typename T = BlockRqRequeueFtraceEvent> T* set_block_rq_requeue() {
     return BeginNestedMessage<T>(129);
   }
@@ -57199,14 +91415,7 @@ class FtraceEvent : public ::protozero::Message {
       BlockSleeprqFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockSleeprq kBlockSleeprq() { return {}; }
+  static constexpr FieldMetadata_BlockSleeprq kBlockSleeprq{};
   template <typename T = BlockSleeprqFtraceEvent> T* set_block_sleeprq() {
     return BeginNestedMessage<T>(130);
   }
@@ -57220,14 +91429,7 @@ class FtraceEvent : public ::protozero::Message {
       BlockSplitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockSplit kBlockSplit() { return {}; }
+  static constexpr FieldMetadata_BlockSplit kBlockSplit{};
   template <typename T = BlockSplitFtraceEvent> T* set_block_split() {
     return BeginNestedMessage<T>(131);
   }
@@ -57241,14 +91443,7 @@ class FtraceEvent : public ::protozero::Message {
       BlockTouchBufferFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockTouchBuffer kBlockTouchBuffer() { return {}; }
+  static constexpr FieldMetadata_BlockTouchBuffer kBlockTouchBuffer{};
   template <typename T = BlockTouchBufferFtraceEvent> T* set_block_touch_buffer() {
     return BeginNestedMessage<T>(132);
   }
@@ -57262,14 +91457,7 @@ class FtraceEvent : public ::protozero::Message {
       BlockUnplugFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockUnplug kBlockUnplug() { return {}; }
+  static constexpr FieldMetadata_BlockUnplug kBlockUnplug{};
   template <typename T = BlockUnplugFtraceEvent> T* set_block_unplug() {
     return BeginNestedMessage<T>(133);
   }
@@ -57283,14 +91471,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4AllocDaBlocksFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4AllocDaBlocks kExt4AllocDaBlocks() { return {}; }
+  static constexpr FieldMetadata_Ext4AllocDaBlocks kExt4AllocDaBlocks{};
   template <typename T = Ext4AllocDaBlocksFtraceEvent> T* set_ext4_alloc_da_blocks() {
     return BeginNestedMessage<T>(134);
   }
@@ -57304,14 +91485,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4AllocateBlocksFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4AllocateBlocks kExt4AllocateBlocks() { return {}; }
+  static constexpr FieldMetadata_Ext4AllocateBlocks kExt4AllocateBlocks{};
   template <typename T = Ext4AllocateBlocksFtraceEvent> T* set_ext4_allocate_blocks() {
     return BeginNestedMessage<T>(135);
   }
@@ -57325,14 +91499,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4AllocateInodeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4AllocateInode kExt4AllocateInode() { return {}; }
+  static constexpr FieldMetadata_Ext4AllocateInode kExt4AllocateInode{};
   template <typename T = Ext4AllocateInodeFtraceEvent> T* set_ext4_allocate_inode() {
     return BeginNestedMessage<T>(136);
   }
@@ -57346,14 +91513,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4BeginOrderedTruncateFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4BeginOrderedTruncate kExt4BeginOrderedTruncate() { return {}; }
+  static constexpr FieldMetadata_Ext4BeginOrderedTruncate kExt4BeginOrderedTruncate{};
   template <typename T = Ext4BeginOrderedTruncateFtraceEvent> T* set_ext4_begin_ordered_truncate() {
     return BeginNestedMessage<T>(137);
   }
@@ -57367,14 +91527,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4CollapseRangeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4CollapseRange kExt4CollapseRange() { return {}; }
+  static constexpr FieldMetadata_Ext4CollapseRange kExt4CollapseRange{};
   template <typename T = Ext4CollapseRangeFtraceEvent> T* set_ext4_collapse_range() {
     return BeginNestedMessage<T>(138);
   }
@@ -57388,14 +91541,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4DaReleaseSpaceFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4DaReleaseSpace kExt4DaReleaseSpace() { return {}; }
+  static constexpr FieldMetadata_Ext4DaReleaseSpace kExt4DaReleaseSpace{};
   template <typename T = Ext4DaReleaseSpaceFtraceEvent> T* set_ext4_da_release_space() {
     return BeginNestedMessage<T>(139);
   }
@@ -57409,14 +91555,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4DaReserveSpaceFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4DaReserveSpace kExt4DaReserveSpace() { return {}; }
+  static constexpr FieldMetadata_Ext4DaReserveSpace kExt4DaReserveSpace{};
   template <typename T = Ext4DaReserveSpaceFtraceEvent> T* set_ext4_da_reserve_space() {
     return BeginNestedMessage<T>(140);
   }
@@ -57430,14 +91569,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4DaUpdateReserveSpaceFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4DaUpdateReserveSpace kExt4DaUpdateReserveSpace() { return {}; }
+  static constexpr FieldMetadata_Ext4DaUpdateReserveSpace kExt4DaUpdateReserveSpace{};
   template <typename T = Ext4DaUpdateReserveSpaceFtraceEvent> T* set_ext4_da_update_reserve_space() {
     return BeginNestedMessage<T>(141);
   }
@@ -57451,14 +91583,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4DaWritePagesFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4DaWritePages kExt4DaWritePages() { return {}; }
+  static constexpr FieldMetadata_Ext4DaWritePages kExt4DaWritePages{};
   template <typename T = Ext4DaWritePagesFtraceEvent> T* set_ext4_da_write_pages() {
     return BeginNestedMessage<T>(142);
   }
@@ -57472,14 +91597,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4DaWritePagesExtentFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4DaWritePagesExtent kExt4DaWritePagesExtent() { return {}; }
+  static constexpr FieldMetadata_Ext4DaWritePagesExtent kExt4DaWritePagesExtent{};
   template <typename T = Ext4DaWritePagesExtentFtraceEvent> T* set_ext4_da_write_pages_extent() {
     return BeginNestedMessage<T>(143);
   }
@@ -57493,14 +91611,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4DirectIOEnterFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4DirectIOEnter kExt4DirectIOEnter() { return {}; }
+  static constexpr FieldMetadata_Ext4DirectIOEnter kExt4DirectIOEnter{};
   template <typename T = Ext4DirectIOEnterFtraceEvent> T* set_ext4_direct_io_enter() {
     return BeginNestedMessage<T>(144);
   }
@@ -57514,14 +91625,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4DirectIOExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4DirectIOExit kExt4DirectIOExit() { return {}; }
+  static constexpr FieldMetadata_Ext4DirectIOExit kExt4DirectIOExit{};
   template <typename T = Ext4DirectIOExitFtraceEvent> T* set_ext4_direct_io_exit() {
     return BeginNestedMessage<T>(145);
   }
@@ -57535,14 +91639,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4DiscardBlocksFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4DiscardBlocks kExt4DiscardBlocks() { return {}; }
+  static constexpr FieldMetadata_Ext4DiscardBlocks kExt4DiscardBlocks{};
   template <typename T = Ext4DiscardBlocksFtraceEvent> T* set_ext4_discard_blocks() {
     return BeginNestedMessage<T>(146);
   }
@@ -57556,14 +91653,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4DiscardPreallocationsFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4DiscardPreallocations kExt4DiscardPreallocations() { return {}; }
+  static constexpr FieldMetadata_Ext4DiscardPreallocations kExt4DiscardPreallocations{};
   template <typename T = Ext4DiscardPreallocationsFtraceEvent> T* set_ext4_discard_preallocations() {
     return BeginNestedMessage<T>(147);
   }
@@ -57577,14 +91667,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4DropInodeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4DropInode kExt4DropInode() { return {}; }
+  static constexpr FieldMetadata_Ext4DropInode kExt4DropInode{};
   template <typename T = Ext4DropInodeFtraceEvent> T* set_ext4_drop_inode() {
     return BeginNestedMessage<T>(148);
   }
@@ -57598,14 +91681,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4EsCacheExtentFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4EsCacheExtent kExt4EsCacheExtent() { return {}; }
+  static constexpr FieldMetadata_Ext4EsCacheExtent kExt4EsCacheExtent{};
   template <typename T = Ext4EsCacheExtentFtraceEvent> T* set_ext4_es_cache_extent() {
     return BeginNestedMessage<T>(149);
   }
@@ -57619,14 +91695,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4EsFindDelayedExtentRangeEnterFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4EsFindDelayedExtentRangeEnter kExt4EsFindDelayedExtentRangeEnter() { return {}; }
+  static constexpr FieldMetadata_Ext4EsFindDelayedExtentRangeEnter kExt4EsFindDelayedExtentRangeEnter{};
   template <typename T = Ext4EsFindDelayedExtentRangeEnterFtraceEvent> T* set_ext4_es_find_delayed_extent_range_enter() {
     return BeginNestedMessage<T>(150);
   }
@@ -57640,14 +91709,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4EsFindDelayedExtentRangeExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4EsFindDelayedExtentRangeExit kExt4EsFindDelayedExtentRangeExit() { return {}; }
+  static constexpr FieldMetadata_Ext4EsFindDelayedExtentRangeExit kExt4EsFindDelayedExtentRangeExit{};
   template <typename T = Ext4EsFindDelayedExtentRangeExitFtraceEvent> T* set_ext4_es_find_delayed_extent_range_exit() {
     return BeginNestedMessage<T>(151);
   }
@@ -57661,14 +91723,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4EsInsertExtentFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4EsInsertExtent kExt4EsInsertExtent() { return {}; }
+  static constexpr FieldMetadata_Ext4EsInsertExtent kExt4EsInsertExtent{};
   template <typename T = Ext4EsInsertExtentFtraceEvent> T* set_ext4_es_insert_extent() {
     return BeginNestedMessage<T>(152);
   }
@@ -57682,14 +91737,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4EsLookupExtentEnterFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4EsLookupExtentEnter kExt4EsLookupExtentEnter() { return {}; }
+  static constexpr FieldMetadata_Ext4EsLookupExtentEnter kExt4EsLookupExtentEnter{};
   template <typename T = Ext4EsLookupExtentEnterFtraceEvent> T* set_ext4_es_lookup_extent_enter() {
     return BeginNestedMessage<T>(153);
   }
@@ -57703,14 +91751,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4EsLookupExtentExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4EsLookupExtentExit kExt4EsLookupExtentExit() { return {}; }
+  static constexpr FieldMetadata_Ext4EsLookupExtentExit kExt4EsLookupExtentExit{};
   template <typename T = Ext4EsLookupExtentExitFtraceEvent> T* set_ext4_es_lookup_extent_exit() {
     return BeginNestedMessage<T>(154);
   }
@@ -57724,14 +91765,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4EsRemoveExtentFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4EsRemoveExtent kExt4EsRemoveExtent() { return {}; }
+  static constexpr FieldMetadata_Ext4EsRemoveExtent kExt4EsRemoveExtent{};
   template <typename T = Ext4EsRemoveExtentFtraceEvent> T* set_ext4_es_remove_extent() {
     return BeginNestedMessage<T>(155);
   }
@@ -57745,14 +91779,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4EsShrinkFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4EsShrink kExt4EsShrink() { return {}; }
+  static constexpr FieldMetadata_Ext4EsShrink kExt4EsShrink{};
   template <typename T = Ext4EsShrinkFtraceEvent> T* set_ext4_es_shrink() {
     return BeginNestedMessage<T>(156);
   }
@@ -57766,14 +91793,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4EsShrinkCountFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4EsShrinkCount kExt4EsShrinkCount() { return {}; }
+  static constexpr FieldMetadata_Ext4EsShrinkCount kExt4EsShrinkCount{};
   template <typename T = Ext4EsShrinkCountFtraceEvent> T* set_ext4_es_shrink_count() {
     return BeginNestedMessage<T>(157);
   }
@@ -57787,14 +91807,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4EsShrinkScanEnterFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4EsShrinkScanEnter kExt4EsShrinkScanEnter() { return {}; }
+  static constexpr FieldMetadata_Ext4EsShrinkScanEnter kExt4EsShrinkScanEnter{};
   template <typename T = Ext4EsShrinkScanEnterFtraceEvent> T* set_ext4_es_shrink_scan_enter() {
     return BeginNestedMessage<T>(158);
   }
@@ -57808,14 +91821,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4EsShrinkScanExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4EsShrinkScanExit kExt4EsShrinkScanExit() { return {}; }
+  static constexpr FieldMetadata_Ext4EsShrinkScanExit kExt4EsShrinkScanExit{};
   template <typename T = Ext4EsShrinkScanExitFtraceEvent> T* set_ext4_es_shrink_scan_exit() {
     return BeginNestedMessage<T>(159);
   }
@@ -57829,14 +91835,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4EvictInodeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4EvictInode kExt4EvictInode() { return {}; }
+  static constexpr FieldMetadata_Ext4EvictInode kExt4EvictInode{};
   template <typename T = Ext4EvictInodeFtraceEvent> T* set_ext4_evict_inode() {
     return BeginNestedMessage<T>(160);
   }
@@ -57850,14 +91849,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4ExtConvertToInitializedEnterFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4ExtConvertToInitializedEnter kExt4ExtConvertToInitializedEnter() { return {}; }
+  static constexpr FieldMetadata_Ext4ExtConvertToInitializedEnter kExt4ExtConvertToInitializedEnter{};
   template <typename T = Ext4ExtConvertToInitializedEnterFtraceEvent> T* set_ext4_ext_convert_to_initialized_enter() {
     return BeginNestedMessage<T>(161);
   }
@@ -57871,14 +91863,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4ExtConvertToInitializedFastpathFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4ExtConvertToInitializedFastpath kExt4ExtConvertToInitializedFastpath() { return {}; }
+  static constexpr FieldMetadata_Ext4ExtConvertToInitializedFastpath kExt4ExtConvertToInitializedFastpath{};
   template <typename T = Ext4ExtConvertToInitializedFastpathFtraceEvent> T* set_ext4_ext_convert_to_initialized_fastpath() {
     return BeginNestedMessage<T>(162);
   }
@@ -57892,14 +91877,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4ExtHandleUnwrittenExtentsFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4ExtHandleUnwrittenExtents kExt4ExtHandleUnwrittenExtents() { return {}; }
+  static constexpr FieldMetadata_Ext4ExtHandleUnwrittenExtents kExt4ExtHandleUnwrittenExtents{};
   template <typename T = Ext4ExtHandleUnwrittenExtentsFtraceEvent> T* set_ext4_ext_handle_unwritten_extents() {
     return BeginNestedMessage<T>(163);
   }
@@ -57913,14 +91891,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4ExtInCacheFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4ExtInCache kExt4ExtInCache() { return {}; }
+  static constexpr FieldMetadata_Ext4ExtInCache kExt4ExtInCache{};
   template <typename T = Ext4ExtInCacheFtraceEvent> T* set_ext4_ext_in_cache() {
     return BeginNestedMessage<T>(164);
   }
@@ -57934,14 +91905,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4ExtLoadExtentFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4ExtLoadExtent kExt4ExtLoadExtent() { return {}; }
+  static constexpr FieldMetadata_Ext4ExtLoadExtent kExt4ExtLoadExtent{};
   template <typename T = Ext4ExtLoadExtentFtraceEvent> T* set_ext4_ext_load_extent() {
     return BeginNestedMessage<T>(165);
   }
@@ -57955,14 +91919,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4ExtMapBlocksEnterFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4ExtMapBlocksEnter kExt4ExtMapBlocksEnter() { return {}; }
+  static constexpr FieldMetadata_Ext4ExtMapBlocksEnter kExt4ExtMapBlocksEnter{};
   template <typename T = Ext4ExtMapBlocksEnterFtraceEvent> T* set_ext4_ext_map_blocks_enter() {
     return BeginNestedMessage<T>(166);
   }
@@ -57976,14 +91933,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4ExtMapBlocksExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4ExtMapBlocksExit kExt4ExtMapBlocksExit() { return {}; }
+  static constexpr FieldMetadata_Ext4ExtMapBlocksExit kExt4ExtMapBlocksExit{};
   template <typename T = Ext4ExtMapBlocksExitFtraceEvent> T* set_ext4_ext_map_blocks_exit() {
     return BeginNestedMessage<T>(167);
   }
@@ -57997,14 +91947,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4ExtPutInCacheFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4ExtPutInCache kExt4ExtPutInCache() { return {}; }
+  static constexpr FieldMetadata_Ext4ExtPutInCache kExt4ExtPutInCache{};
   template <typename T = Ext4ExtPutInCacheFtraceEvent> T* set_ext4_ext_put_in_cache() {
     return BeginNestedMessage<T>(168);
   }
@@ -58018,14 +91961,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4ExtRemoveSpaceFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4ExtRemoveSpace kExt4ExtRemoveSpace() { return {}; }
+  static constexpr FieldMetadata_Ext4ExtRemoveSpace kExt4ExtRemoveSpace{};
   template <typename T = Ext4ExtRemoveSpaceFtraceEvent> T* set_ext4_ext_remove_space() {
     return BeginNestedMessage<T>(169);
   }
@@ -58039,14 +91975,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4ExtRemoveSpaceDoneFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4ExtRemoveSpaceDone kExt4ExtRemoveSpaceDone() { return {}; }
+  static constexpr FieldMetadata_Ext4ExtRemoveSpaceDone kExt4ExtRemoveSpaceDone{};
   template <typename T = Ext4ExtRemoveSpaceDoneFtraceEvent> T* set_ext4_ext_remove_space_done() {
     return BeginNestedMessage<T>(170);
   }
@@ -58060,14 +91989,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4ExtRmIdxFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4ExtRmIdx kExt4ExtRmIdx() { return {}; }
+  static constexpr FieldMetadata_Ext4ExtRmIdx kExt4ExtRmIdx{};
   template <typename T = Ext4ExtRmIdxFtraceEvent> T* set_ext4_ext_rm_idx() {
     return BeginNestedMessage<T>(171);
   }
@@ -58081,14 +92003,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4ExtRmLeafFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4ExtRmLeaf kExt4ExtRmLeaf() { return {}; }
+  static constexpr FieldMetadata_Ext4ExtRmLeaf kExt4ExtRmLeaf{};
   template <typename T = Ext4ExtRmLeafFtraceEvent> T* set_ext4_ext_rm_leaf() {
     return BeginNestedMessage<T>(172);
   }
@@ -58102,14 +92017,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4ExtShowExtentFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4ExtShowExtent kExt4ExtShowExtent() { return {}; }
+  static constexpr FieldMetadata_Ext4ExtShowExtent kExt4ExtShowExtent{};
   template <typename T = Ext4ExtShowExtentFtraceEvent> T* set_ext4_ext_show_extent() {
     return BeginNestedMessage<T>(173);
   }
@@ -58123,14 +92031,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4FallocateEnterFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4FallocateEnter kExt4FallocateEnter() { return {}; }
+  static constexpr FieldMetadata_Ext4FallocateEnter kExt4FallocateEnter{};
   template <typename T = Ext4FallocateEnterFtraceEvent> T* set_ext4_fallocate_enter() {
     return BeginNestedMessage<T>(174);
   }
@@ -58144,14 +92045,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4FallocateExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4FallocateExit kExt4FallocateExit() { return {}; }
+  static constexpr FieldMetadata_Ext4FallocateExit kExt4FallocateExit{};
   template <typename T = Ext4FallocateExitFtraceEvent> T* set_ext4_fallocate_exit() {
     return BeginNestedMessage<T>(175);
   }
@@ -58165,14 +92059,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4FindDelallocRangeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4FindDelallocRange kExt4FindDelallocRange() { return {}; }
+  static constexpr FieldMetadata_Ext4FindDelallocRange kExt4FindDelallocRange{};
   template <typename T = Ext4FindDelallocRangeFtraceEvent> T* set_ext4_find_delalloc_range() {
     return BeginNestedMessage<T>(176);
   }
@@ -58186,14 +92073,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4ForgetFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4Forget kExt4Forget() { return {}; }
+  static constexpr FieldMetadata_Ext4Forget kExt4Forget{};
   template <typename T = Ext4ForgetFtraceEvent> T* set_ext4_forget() {
     return BeginNestedMessage<T>(177);
   }
@@ -58207,14 +92087,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4FreeBlocksFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4FreeBlocks kExt4FreeBlocks() { return {}; }
+  static constexpr FieldMetadata_Ext4FreeBlocks kExt4FreeBlocks{};
   template <typename T = Ext4FreeBlocksFtraceEvent> T* set_ext4_free_blocks() {
     return BeginNestedMessage<T>(178);
   }
@@ -58228,14 +92101,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4FreeInodeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4FreeInode kExt4FreeInode() { return {}; }
+  static constexpr FieldMetadata_Ext4FreeInode kExt4FreeInode{};
   template <typename T = Ext4FreeInodeFtraceEvent> T* set_ext4_free_inode() {
     return BeginNestedMessage<T>(179);
   }
@@ -58249,14 +92115,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4GetImpliedClusterAllocExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4GetImpliedClusterAllocExit kExt4GetImpliedClusterAllocExit() { return {}; }
+  static constexpr FieldMetadata_Ext4GetImpliedClusterAllocExit kExt4GetImpliedClusterAllocExit{};
   template <typename T = Ext4GetImpliedClusterAllocExitFtraceEvent> T* set_ext4_get_implied_cluster_alloc_exit() {
     return BeginNestedMessage<T>(180);
   }
@@ -58270,14 +92129,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4GetReservedClusterAllocFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4GetReservedClusterAlloc kExt4GetReservedClusterAlloc() { return {}; }
+  static constexpr FieldMetadata_Ext4GetReservedClusterAlloc kExt4GetReservedClusterAlloc{};
   template <typename T = Ext4GetReservedClusterAllocFtraceEvent> T* set_ext4_get_reserved_cluster_alloc() {
     return BeginNestedMessage<T>(181);
   }
@@ -58291,14 +92143,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4IndMapBlocksEnterFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4IndMapBlocksEnter kExt4IndMapBlocksEnter() { return {}; }
+  static constexpr FieldMetadata_Ext4IndMapBlocksEnter kExt4IndMapBlocksEnter{};
   template <typename T = Ext4IndMapBlocksEnterFtraceEvent> T* set_ext4_ind_map_blocks_enter() {
     return BeginNestedMessage<T>(182);
   }
@@ -58312,14 +92157,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4IndMapBlocksExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4IndMapBlocksExit kExt4IndMapBlocksExit() { return {}; }
+  static constexpr FieldMetadata_Ext4IndMapBlocksExit kExt4IndMapBlocksExit{};
   template <typename T = Ext4IndMapBlocksExitFtraceEvent> T* set_ext4_ind_map_blocks_exit() {
     return BeginNestedMessage<T>(183);
   }
@@ -58333,14 +92171,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4InsertRangeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4InsertRange kExt4InsertRange() { return {}; }
+  static constexpr FieldMetadata_Ext4InsertRange kExt4InsertRange{};
   template <typename T = Ext4InsertRangeFtraceEvent> T* set_ext4_insert_range() {
     return BeginNestedMessage<T>(184);
   }
@@ -58354,14 +92185,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4InvalidatepageFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4Invalidatepage kExt4Invalidatepage() { return {}; }
+  static constexpr FieldMetadata_Ext4Invalidatepage kExt4Invalidatepage{};
   template <typename T = Ext4InvalidatepageFtraceEvent> T* set_ext4_invalidatepage() {
     return BeginNestedMessage<T>(185);
   }
@@ -58375,14 +92199,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4JournalStartFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4JournalStart kExt4JournalStart() { return {}; }
+  static constexpr FieldMetadata_Ext4JournalStart kExt4JournalStart{};
   template <typename T = Ext4JournalStartFtraceEvent> T* set_ext4_journal_start() {
     return BeginNestedMessage<T>(186);
   }
@@ -58396,14 +92213,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4JournalStartReservedFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4JournalStartReserved kExt4JournalStartReserved() { return {}; }
+  static constexpr FieldMetadata_Ext4JournalStartReserved kExt4JournalStartReserved{};
   template <typename T = Ext4JournalStartReservedFtraceEvent> T* set_ext4_journal_start_reserved() {
     return BeginNestedMessage<T>(187);
   }
@@ -58417,14 +92227,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4JournalledInvalidatepageFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4JournalledInvalidatepage kExt4JournalledInvalidatepage() { return {}; }
+  static constexpr FieldMetadata_Ext4JournalledInvalidatepage kExt4JournalledInvalidatepage{};
   template <typename T = Ext4JournalledInvalidatepageFtraceEvent> T* set_ext4_journalled_invalidatepage() {
     return BeginNestedMessage<T>(188);
   }
@@ -58438,14 +92241,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4JournalledWriteEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4JournalledWriteEnd kExt4JournalledWriteEnd() { return {}; }
+  static constexpr FieldMetadata_Ext4JournalledWriteEnd kExt4JournalledWriteEnd{};
   template <typename T = Ext4JournalledWriteEndFtraceEvent> T* set_ext4_journalled_write_end() {
     return BeginNestedMessage<T>(189);
   }
@@ -58459,14 +92255,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4LoadInodeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4LoadInode kExt4LoadInode() { return {}; }
+  static constexpr FieldMetadata_Ext4LoadInode kExt4LoadInode{};
   template <typename T = Ext4LoadInodeFtraceEvent> T* set_ext4_load_inode() {
     return BeginNestedMessage<T>(190);
   }
@@ -58480,14 +92269,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4LoadInodeBitmapFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4LoadInodeBitmap kExt4LoadInodeBitmap() { return {}; }
+  static constexpr FieldMetadata_Ext4LoadInodeBitmap kExt4LoadInodeBitmap{};
   template <typename T = Ext4LoadInodeBitmapFtraceEvent> T* set_ext4_load_inode_bitmap() {
     return BeginNestedMessage<T>(191);
   }
@@ -58501,14 +92283,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4MarkInodeDirtyFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4MarkInodeDirty kExt4MarkInodeDirty() { return {}; }
+  static constexpr FieldMetadata_Ext4MarkInodeDirty kExt4MarkInodeDirty{};
   template <typename T = Ext4MarkInodeDirtyFtraceEvent> T* set_ext4_mark_inode_dirty() {
     return BeginNestedMessage<T>(192);
   }
@@ -58522,14 +92297,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4MbBitmapLoadFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4MbBitmapLoad kExt4MbBitmapLoad() { return {}; }
+  static constexpr FieldMetadata_Ext4MbBitmapLoad kExt4MbBitmapLoad{};
   template <typename T = Ext4MbBitmapLoadFtraceEvent> T* set_ext4_mb_bitmap_load() {
     return BeginNestedMessage<T>(193);
   }
@@ -58543,14 +92311,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4MbBuddyBitmapLoadFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4MbBuddyBitmapLoad kExt4MbBuddyBitmapLoad() { return {}; }
+  static constexpr FieldMetadata_Ext4MbBuddyBitmapLoad kExt4MbBuddyBitmapLoad{};
   template <typename T = Ext4MbBuddyBitmapLoadFtraceEvent> T* set_ext4_mb_buddy_bitmap_load() {
     return BeginNestedMessage<T>(194);
   }
@@ -58564,14 +92325,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4MbDiscardPreallocationsFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4MbDiscardPreallocations kExt4MbDiscardPreallocations() { return {}; }
+  static constexpr FieldMetadata_Ext4MbDiscardPreallocations kExt4MbDiscardPreallocations{};
   template <typename T = Ext4MbDiscardPreallocationsFtraceEvent> T* set_ext4_mb_discard_preallocations() {
     return BeginNestedMessage<T>(195);
   }
@@ -58585,14 +92339,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4MbNewGroupPaFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4MbNewGroupPa kExt4MbNewGroupPa() { return {}; }
+  static constexpr FieldMetadata_Ext4MbNewGroupPa kExt4MbNewGroupPa{};
   template <typename T = Ext4MbNewGroupPaFtraceEvent> T* set_ext4_mb_new_group_pa() {
     return BeginNestedMessage<T>(196);
   }
@@ -58606,14 +92353,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4MbNewInodePaFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4MbNewInodePa kExt4MbNewInodePa() { return {}; }
+  static constexpr FieldMetadata_Ext4MbNewInodePa kExt4MbNewInodePa{};
   template <typename T = Ext4MbNewInodePaFtraceEvent> T* set_ext4_mb_new_inode_pa() {
     return BeginNestedMessage<T>(197);
   }
@@ -58627,14 +92367,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4MbReleaseGroupPaFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4MbReleaseGroupPa kExt4MbReleaseGroupPa() { return {}; }
+  static constexpr FieldMetadata_Ext4MbReleaseGroupPa kExt4MbReleaseGroupPa{};
   template <typename T = Ext4MbReleaseGroupPaFtraceEvent> T* set_ext4_mb_release_group_pa() {
     return BeginNestedMessage<T>(198);
   }
@@ -58648,14 +92381,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4MbReleaseInodePaFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4MbReleaseInodePa kExt4MbReleaseInodePa() { return {}; }
+  static constexpr FieldMetadata_Ext4MbReleaseInodePa kExt4MbReleaseInodePa{};
   template <typename T = Ext4MbReleaseInodePaFtraceEvent> T* set_ext4_mb_release_inode_pa() {
     return BeginNestedMessage<T>(199);
   }
@@ -58669,14 +92395,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4MballocAllocFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4MballocAlloc kExt4MballocAlloc() { return {}; }
+  static constexpr FieldMetadata_Ext4MballocAlloc kExt4MballocAlloc{};
   template <typename T = Ext4MballocAllocFtraceEvent> T* set_ext4_mballoc_alloc() {
     return BeginNestedMessage<T>(200);
   }
@@ -58690,14 +92409,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4MballocDiscardFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4MballocDiscard kExt4MballocDiscard() { return {}; }
+  static constexpr FieldMetadata_Ext4MballocDiscard kExt4MballocDiscard{};
   template <typename T = Ext4MballocDiscardFtraceEvent> T* set_ext4_mballoc_discard() {
     return BeginNestedMessage<T>(201);
   }
@@ -58711,14 +92423,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4MballocFreeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4MballocFree kExt4MballocFree() { return {}; }
+  static constexpr FieldMetadata_Ext4MballocFree kExt4MballocFree{};
   template <typename T = Ext4MballocFreeFtraceEvent> T* set_ext4_mballoc_free() {
     return BeginNestedMessage<T>(202);
   }
@@ -58732,14 +92437,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4MballocPreallocFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4MballocPrealloc kExt4MballocPrealloc() { return {}; }
+  static constexpr FieldMetadata_Ext4MballocPrealloc kExt4MballocPrealloc{};
   template <typename T = Ext4MballocPreallocFtraceEvent> T* set_ext4_mballoc_prealloc() {
     return BeginNestedMessage<T>(203);
   }
@@ -58753,14 +92451,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4OtherInodeUpdateTimeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4OtherInodeUpdateTime kExt4OtherInodeUpdateTime() { return {}; }
+  static constexpr FieldMetadata_Ext4OtherInodeUpdateTime kExt4OtherInodeUpdateTime{};
   template <typename T = Ext4OtherInodeUpdateTimeFtraceEvent> T* set_ext4_other_inode_update_time() {
     return BeginNestedMessage<T>(204);
   }
@@ -58774,14 +92465,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4PunchHoleFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4PunchHole kExt4PunchHole() { return {}; }
+  static constexpr FieldMetadata_Ext4PunchHole kExt4PunchHole{};
   template <typename T = Ext4PunchHoleFtraceEvent> T* set_ext4_punch_hole() {
     return BeginNestedMessage<T>(205);
   }
@@ -58795,14 +92479,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4ReadBlockBitmapLoadFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4ReadBlockBitmapLoad kExt4ReadBlockBitmapLoad() { return {}; }
+  static constexpr FieldMetadata_Ext4ReadBlockBitmapLoad kExt4ReadBlockBitmapLoad{};
   template <typename T = Ext4ReadBlockBitmapLoadFtraceEvent> T* set_ext4_read_block_bitmap_load() {
     return BeginNestedMessage<T>(206);
   }
@@ -58816,14 +92493,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4ReadpageFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4Readpage kExt4Readpage() { return {}; }
+  static constexpr FieldMetadata_Ext4Readpage kExt4Readpage{};
   template <typename T = Ext4ReadpageFtraceEvent> T* set_ext4_readpage() {
     return BeginNestedMessage<T>(207);
   }
@@ -58837,14 +92507,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4ReleasepageFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4Releasepage kExt4Releasepage() { return {}; }
+  static constexpr FieldMetadata_Ext4Releasepage kExt4Releasepage{};
   template <typename T = Ext4ReleasepageFtraceEvent> T* set_ext4_releasepage() {
     return BeginNestedMessage<T>(208);
   }
@@ -58858,14 +92521,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4RemoveBlocksFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4RemoveBlocks kExt4RemoveBlocks() { return {}; }
+  static constexpr FieldMetadata_Ext4RemoveBlocks kExt4RemoveBlocks{};
   template <typename T = Ext4RemoveBlocksFtraceEvent> T* set_ext4_remove_blocks() {
     return BeginNestedMessage<T>(209);
   }
@@ -58879,14 +92535,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4RequestBlocksFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4RequestBlocks kExt4RequestBlocks() { return {}; }
+  static constexpr FieldMetadata_Ext4RequestBlocks kExt4RequestBlocks{};
   template <typename T = Ext4RequestBlocksFtraceEvent> T* set_ext4_request_blocks() {
     return BeginNestedMessage<T>(210);
   }
@@ -58900,14 +92549,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4RequestInodeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4RequestInode kExt4RequestInode() { return {}; }
+  static constexpr FieldMetadata_Ext4RequestInode kExt4RequestInode{};
   template <typename T = Ext4RequestInodeFtraceEvent> T* set_ext4_request_inode() {
     return BeginNestedMessage<T>(211);
   }
@@ -58921,14 +92563,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4SyncFsFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4SyncFs kExt4SyncFs() { return {}; }
+  static constexpr FieldMetadata_Ext4SyncFs kExt4SyncFs{};
   template <typename T = Ext4SyncFsFtraceEvent> T* set_ext4_sync_fs() {
     return BeginNestedMessage<T>(212);
   }
@@ -58942,14 +92577,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4TrimAllFreeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4TrimAllFree kExt4TrimAllFree() { return {}; }
+  static constexpr FieldMetadata_Ext4TrimAllFree kExt4TrimAllFree{};
   template <typename T = Ext4TrimAllFreeFtraceEvent> T* set_ext4_trim_all_free() {
     return BeginNestedMessage<T>(213);
   }
@@ -58963,14 +92591,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4TrimExtentFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4TrimExtent kExt4TrimExtent() { return {}; }
+  static constexpr FieldMetadata_Ext4TrimExtent kExt4TrimExtent{};
   template <typename T = Ext4TrimExtentFtraceEvent> T* set_ext4_trim_extent() {
     return BeginNestedMessage<T>(214);
   }
@@ -58984,14 +92605,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4TruncateEnterFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4TruncateEnter kExt4TruncateEnter() { return {}; }
+  static constexpr FieldMetadata_Ext4TruncateEnter kExt4TruncateEnter{};
   template <typename T = Ext4TruncateEnterFtraceEvent> T* set_ext4_truncate_enter() {
     return BeginNestedMessage<T>(215);
   }
@@ -59005,14 +92619,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4TruncateExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4TruncateExit kExt4TruncateExit() { return {}; }
+  static constexpr FieldMetadata_Ext4TruncateExit kExt4TruncateExit{};
   template <typename T = Ext4TruncateExitFtraceEvent> T* set_ext4_truncate_exit() {
     return BeginNestedMessage<T>(216);
   }
@@ -59026,14 +92633,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4UnlinkEnterFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4UnlinkEnter kExt4UnlinkEnter() { return {}; }
+  static constexpr FieldMetadata_Ext4UnlinkEnter kExt4UnlinkEnter{};
   template <typename T = Ext4UnlinkEnterFtraceEvent> T* set_ext4_unlink_enter() {
     return BeginNestedMessage<T>(217);
   }
@@ -59047,14 +92647,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4UnlinkExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4UnlinkExit kExt4UnlinkExit() { return {}; }
+  static constexpr FieldMetadata_Ext4UnlinkExit kExt4UnlinkExit{};
   template <typename T = Ext4UnlinkExitFtraceEvent> T* set_ext4_unlink_exit() {
     return BeginNestedMessage<T>(218);
   }
@@ -59068,14 +92661,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4WriteBeginFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4WriteBegin kExt4WriteBegin() { return {}; }
+  static constexpr FieldMetadata_Ext4WriteBegin kExt4WriteBegin{};
   template <typename T = Ext4WriteBeginFtraceEvent> T* set_ext4_write_begin() {
     return BeginNestedMessage<T>(219);
   }
@@ -59089,14 +92675,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4WriteEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4WriteEnd kExt4WriteEnd() { return {}; }
+  static constexpr FieldMetadata_Ext4WriteEnd kExt4WriteEnd{};
   template <typename T = Ext4WriteEndFtraceEvent> T* set_ext4_write_end() {
     return BeginNestedMessage<T>(230);
   }
@@ -59110,14 +92689,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4WritepageFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4Writepage kExt4Writepage() { return {}; }
+  static constexpr FieldMetadata_Ext4Writepage kExt4Writepage{};
   template <typename T = Ext4WritepageFtraceEvent> T* set_ext4_writepage() {
     return BeginNestedMessage<T>(231);
   }
@@ -59131,14 +92703,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4WritepagesFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4Writepages kExt4Writepages() { return {}; }
+  static constexpr FieldMetadata_Ext4Writepages kExt4Writepages{};
   template <typename T = Ext4WritepagesFtraceEvent> T* set_ext4_writepages() {
     return BeginNestedMessage<T>(232);
   }
@@ -59152,14 +92717,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4WritepagesResultFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4WritepagesResult kExt4WritepagesResult() { return {}; }
+  static constexpr FieldMetadata_Ext4WritepagesResult kExt4WritepagesResult{};
   template <typename T = Ext4WritepagesResultFtraceEvent> T* set_ext4_writepages_result() {
     return BeginNestedMessage<T>(233);
   }
@@ -59173,14 +92731,7 @@ class FtraceEvent : public ::protozero::Message {
       Ext4ZeroRangeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ext4ZeroRange kExt4ZeroRange() { return {}; }
+  static constexpr FieldMetadata_Ext4ZeroRange kExt4ZeroRange{};
   template <typename T = Ext4ZeroRangeFtraceEvent> T* set_ext4_zero_range() {
     return BeginNestedMessage<T>(234);
   }
@@ -59194,14 +92745,7 @@ class FtraceEvent : public ::protozero::Message {
       TaskNewtaskFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TaskNewtask kTaskNewtask() { return {}; }
+  static constexpr FieldMetadata_TaskNewtask kTaskNewtask{};
   template <typename T = TaskNewtaskFtraceEvent> T* set_task_newtask() {
     return BeginNestedMessage<T>(235);
   }
@@ -59215,14 +92759,7 @@ class FtraceEvent : public ::protozero::Message {
       TaskRenameFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TaskRename kTaskRename() { return {}; }
+  static constexpr FieldMetadata_TaskRename kTaskRename{};
   template <typename T = TaskRenameFtraceEvent> T* set_task_rename() {
     return BeginNestedMessage<T>(236);
   }
@@ -59236,14 +92773,7 @@ class FtraceEvent : public ::protozero::Message {
       SchedProcessExecFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SchedProcessExec kSchedProcessExec() { return {}; }
+  static constexpr FieldMetadata_SchedProcessExec kSchedProcessExec{};
   template <typename T = SchedProcessExecFtraceEvent> T* set_sched_process_exec() {
     return BeginNestedMessage<T>(237);
   }
@@ -59257,14 +92787,7 @@ class FtraceEvent : public ::protozero::Message {
       SchedProcessExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SchedProcessExit kSchedProcessExit() { return {}; }
+  static constexpr FieldMetadata_SchedProcessExit kSchedProcessExit{};
   template <typename T = SchedProcessExitFtraceEvent> T* set_sched_process_exit() {
     return BeginNestedMessage<T>(238);
   }
@@ -59278,14 +92801,7 @@ class FtraceEvent : public ::protozero::Message {
       SchedProcessForkFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SchedProcessFork kSchedProcessFork() { return {}; }
+  static constexpr FieldMetadata_SchedProcessFork kSchedProcessFork{};
   template <typename T = SchedProcessForkFtraceEvent> T* set_sched_process_fork() {
     return BeginNestedMessage<T>(239);
   }
@@ -59299,14 +92815,7 @@ class FtraceEvent : public ::protozero::Message {
       SchedProcessFreeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SchedProcessFree kSchedProcessFree() { return {}; }
+  static constexpr FieldMetadata_SchedProcessFree kSchedProcessFree{};
   template <typename T = SchedProcessFreeFtraceEvent> T* set_sched_process_free() {
     return BeginNestedMessage<T>(240);
   }
@@ -59320,14 +92829,7 @@ class FtraceEvent : public ::protozero::Message {
       SchedProcessHangFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SchedProcessHang kSchedProcessHang() { return {}; }
+  static constexpr FieldMetadata_SchedProcessHang kSchedProcessHang{};
   template <typename T = SchedProcessHangFtraceEvent> T* set_sched_process_hang() {
     return BeginNestedMessage<T>(241);
   }
@@ -59341,14 +92843,7 @@ class FtraceEvent : public ::protozero::Message {
       SchedProcessWaitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SchedProcessWait kSchedProcessWait() { return {}; }
+  static constexpr FieldMetadata_SchedProcessWait kSchedProcessWait{};
   template <typename T = SchedProcessWaitFtraceEvent> T* set_sched_process_wait() {
     return BeginNestedMessage<T>(242);
   }
@@ -59362,14 +92857,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsDoSubmitBioFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsDoSubmitBio kF2fsDoSubmitBio() { return {}; }
+  static constexpr FieldMetadata_F2fsDoSubmitBio kF2fsDoSubmitBio{};
   template <typename T = F2fsDoSubmitBioFtraceEvent> T* set_f2fs_do_submit_bio() {
     return BeginNestedMessage<T>(243);
   }
@@ -59383,14 +92871,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsEvictInodeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsEvictInode kF2fsEvictInode() { return {}; }
+  static constexpr FieldMetadata_F2fsEvictInode kF2fsEvictInode{};
   template <typename T = F2fsEvictInodeFtraceEvent> T* set_f2fs_evict_inode() {
     return BeginNestedMessage<T>(244);
   }
@@ -59404,14 +92885,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsFallocateFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsFallocate kF2fsFallocate() { return {}; }
+  static constexpr FieldMetadata_F2fsFallocate kF2fsFallocate{};
   template <typename T = F2fsFallocateFtraceEvent> T* set_f2fs_fallocate() {
     return BeginNestedMessage<T>(245);
   }
@@ -59425,14 +92899,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsGetDataBlockFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsGetDataBlock kF2fsGetDataBlock() { return {}; }
+  static constexpr FieldMetadata_F2fsGetDataBlock kF2fsGetDataBlock{};
   template <typename T = F2fsGetDataBlockFtraceEvent> T* set_f2fs_get_data_block() {
     return BeginNestedMessage<T>(246);
   }
@@ -59446,14 +92913,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsGetVictimFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsGetVictim kF2fsGetVictim() { return {}; }
+  static constexpr FieldMetadata_F2fsGetVictim kF2fsGetVictim{};
   template <typename T = F2fsGetVictimFtraceEvent> T* set_f2fs_get_victim() {
     return BeginNestedMessage<T>(247);
   }
@@ -59467,14 +92927,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsIgetFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsIget kF2fsIget() { return {}; }
+  static constexpr FieldMetadata_F2fsIget kF2fsIget{};
   template <typename T = F2fsIgetFtraceEvent> T* set_f2fs_iget() {
     return BeginNestedMessage<T>(248);
   }
@@ -59488,14 +92941,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsIgetExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsIgetExit kF2fsIgetExit() { return {}; }
+  static constexpr FieldMetadata_F2fsIgetExit kF2fsIgetExit{};
   template <typename T = F2fsIgetExitFtraceEvent> T* set_f2fs_iget_exit() {
     return BeginNestedMessage<T>(249);
   }
@@ -59509,14 +92955,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsNewInodeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsNewInode kF2fsNewInode() { return {}; }
+  static constexpr FieldMetadata_F2fsNewInode kF2fsNewInode{};
   template <typename T = F2fsNewInodeFtraceEvent> T* set_f2fs_new_inode() {
     return BeginNestedMessage<T>(250);
   }
@@ -59530,14 +92969,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsReadpageFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsReadpage kF2fsReadpage() { return {}; }
+  static constexpr FieldMetadata_F2fsReadpage kF2fsReadpage{};
   template <typename T = F2fsReadpageFtraceEvent> T* set_f2fs_readpage() {
     return BeginNestedMessage<T>(251);
   }
@@ -59551,14 +92983,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsReserveNewBlockFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsReserveNewBlock kF2fsReserveNewBlock() { return {}; }
+  static constexpr FieldMetadata_F2fsReserveNewBlock kF2fsReserveNewBlock{};
   template <typename T = F2fsReserveNewBlockFtraceEvent> T* set_f2fs_reserve_new_block() {
     return BeginNestedMessage<T>(252);
   }
@@ -59572,14 +92997,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsSetPageDirtyFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsSetPageDirty kF2fsSetPageDirty() { return {}; }
+  static constexpr FieldMetadata_F2fsSetPageDirty kF2fsSetPageDirty{};
   template <typename T = F2fsSetPageDirtyFtraceEvent> T* set_f2fs_set_page_dirty() {
     return BeginNestedMessage<T>(253);
   }
@@ -59593,14 +93011,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsSubmitWritePageFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsSubmitWritePage kF2fsSubmitWritePage() { return {}; }
+  static constexpr FieldMetadata_F2fsSubmitWritePage kF2fsSubmitWritePage{};
   template <typename T = F2fsSubmitWritePageFtraceEvent> T* set_f2fs_submit_write_page() {
     return BeginNestedMessage<T>(254);
   }
@@ -59614,14 +93025,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsSyncFileEnterFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsSyncFileEnter kF2fsSyncFileEnter() { return {}; }
+  static constexpr FieldMetadata_F2fsSyncFileEnter kF2fsSyncFileEnter{};
   template <typename T = F2fsSyncFileEnterFtraceEvent> T* set_f2fs_sync_file_enter() {
     return BeginNestedMessage<T>(255);
   }
@@ -59635,14 +93039,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsSyncFileExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsSyncFileExit kF2fsSyncFileExit() { return {}; }
+  static constexpr FieldMetadata_F2fsSyncFileExit kF2fsSyncFileExit{};
   template <typename T = F2fsSyncFileExitFtraceEvent> T* set_f2fs_sync_file_exit() {
     return BeginNestedMessage<T>(256);
   }
@@ -59656,14 +93053,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsSyncFsFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsSyncFs kF2fsSyncFs() { return {}; }
+  static constexpr FieldMetadata_F2fsSyncFs kF2fsSyncFs{};
   template <typename T = F2fsSyncFsFtraceEvent> T* set_f2fs_sync_fs() {
     return BeginNestedMessage<T>(257);
   }
@@ -59677,14 +93067,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsTruncateFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsTruncate kF2fsTruncate() { return {}; }
+  static constexpr FieldMetadata_F2fsTruncate kF2fsTruncate{};
   template <typename T = F2fsTruncateFtraceEvent> T* set_f2fs_truncate() {
     return BeginNestedMessage<T>(258);
   }
@@ -59698,14 +93081,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsTruncateBlocksEnterFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsTruncateBlocksEnter kF2fsTruncateBlocksEnter() { return {}; }
+  static constexpr FieldMetadata_F2fsTruncateBlocksEnter kF2fsTruncateBlocksEnter{};
   template <typename T = F2fsTruncateBlocksEnterFtraceEvent> T* set_f2fs_truncate_blocks_enter() {
     return BeginNestedMessage<T>(259);
   }
@@ -59719,14 +93095,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsTruncateBlocksExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsTruncateBlocksExit kF2fsTruncateBlocksExit() { return {}; }
+  static constexpr FieldMetadata_F2fsTruncateBlocksExit kF2fsTruncateBlocksExit{};
   template <typename T = F2fsTruncateBlocksExitFtraceEvent> T* set_f2fs_truncate_blocks_exit() {
     return BeginNestedMessage<T>(260);
   }
@@ -59740,14 +93109,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsTruncateDataBlocksRangeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsTruncateDataBlocksRange kF2fsTruncateDataBlocksRange() { return {}; }
+  static constexpr FieldMetadata_F2fsTruncateDataBlocksRange kF2fsTruncateDataBlocksRange{};
   template <typename T = F2fsTruncateDataBlocksRangeFtraceEvent> T* set_f2fs_truncate_data_blocks_range() {
     return BeginNestedMessage<T>(261);
   }
@@ -59761,14 +93123,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsTruncateInodeBlocksEnterFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsTruncateInodeBlocksEnter kF2fsTruncateInodeBlocksEnter() { return {}; }
+  static constexpr FieldMetadata_F2fsTruncateInodeBlocksEnter kF2fsTruncateInodeBlocksEnter{};
   template <typename T = F2fsTruncateInodeBlocksEnterFtraceEvent> T* set_f2fs_truncate_inode_blocks_enter() {
     return BeginNestedMessage<T>(262);
   }
@@ -59782,14 +93137,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsTruncateInodeBlocksExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsTruncateInodeBlocksExit kF2fsTruncateInodeBlocksExit() { return {}; }
+  static constexpr FieldMetadata_F2fsTruncateInodeBlocksExit kF2fsTruncateInodeBlocksExit{};
   template <typename T = F2fsTruncateInodeBlocksExitFtraceEvent> T* set_f2fs_truncate_inode_blocks_exit() {
     return BeginNestedMessage<T>(263);
   }
@@ -59803,14 +93151,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsTruncateNodeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsTruncateNode kF2fsTruncateNode() { return {}; }
+  static constexpr FieldMetadata_F2fsTruncateNode kF2fsTruncateNode{};
   template <typename T = F2fsTruncateNodeFtraceEvent> T* set_f2fs_truncate_node() {
     return BeginNestedMessage<T>(264);
   }
@@ -59824,14 +93165,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsTruncateNodesEnterFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsTruncateNodesEnter kF2fsTruncateNodesEnter() { return {}; }
+  static constexpr FieldMetadata_F2fsTruncateNodesEnter kF2fsTruncateNodesEnter{};
   template <typename T = F2fsTruncateNodesEnterFtraceEvent> T* set_f2fs_truncate_nodes_enter() {
     return BeginNestedMessage<T>(265);
   }
@@ -59845,14 +93179,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsTruncateNodesExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsTruncateNodesExit kF2fsTruncateNodesExit() { return {}; }
+  static constexpr FieldMetadata_F2fsTruncateNodesExit kF2fsTruncateNodesExit{};
   template <typename T = F2fsTruncateNodesExitFtraceEvent> T* set_f2fs_truncate_nodes_exit() {
     return BeginNestedMessage<T>(266);
   }
@@ -59866,14 +93193,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsTruncatePartialNodesFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsTruncatePartialNodes kF2fsTruncatePartialNodes() { return {}; }
+  static constexpr FieldMetadata_F2fsTruncatePartialNodes kF2fsTruncatePartialNodes{};
   template <typename T = F2fsTruncatePartialNodesFtraceEvent> T* set_f2fs_truncate_partial_nodes() {
     return BeginNestedMessage<T>(267);
   }
@@ -59887,14 +93207,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsUnlinkEnterFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsUnlinkEnter kF2fsUnlinkEnter() { return {}; }
+  static constexpr FieldMetadata_F2fsUnlinkEnter kF2fsUnlinkEnter{};
   template <typename T = F2fsUnlinkEnterFtraceEvent> T* set_f2fs_unlink_enter() {
     return BeginNestedMessage<T>(268);
   }
@@ -59908,14 +93221,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsUnlinkExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsUnlinkExit kF2fsUnlinkExit() { return {}; }
+  static constexpr FieldMetadata_F2fsUnlinkExit kF2fsUnlinkExit{};
   template <typename T = F2fsUnlinkExitFtraceEvent> T* set_f2fs_unlink_exit() {
     return BeginNestedMessage<T>(269);
   }
@@ -59929,14 +93235,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsVmPageMkwriteFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsVmPageMkwrite kF2fsVmPageMkwrite() { return {}; }
+  static constexpr FieldMetadata_F2fsVmPageMkwrite kF2fsVmPageMkwrite{};
   template <typename T = F2fsVmPageMkwriteFtraceEvent> T* set_f2fs_vm_page_mkwrite() {
     return BeginNestedMessage<T>(270);
   }
@@ -59950,14 +93249,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsWriteBeginFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsWriteBegin kF2fsWriteBegin() { return {}; }
+  static constexpr FieldMetadata_F2fsWriteBegin kF2fsWriteBegin{};
   template <typename T = F2fsWriteBeginFtraceEvent> T* set_f2fs_write_begin() {
     return BeginNestedMessage<T>(271);
   }
@@ -59971,14 +93263,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsWriteCheckpointFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsWriteCheckpoint kF2fsWriteCheckpoint() { return {}; }
+  static constexpr FieldMetadata_F2fsWriteCheckpoint kF2fsWriteCheckpoint{};
   template <typename T = F2fsWriteCheckpointFtraceEvent> T* set_f2fs_write_checkpoint() {
     return BeginNestedMessage<T>(272);
   }
@@ -59992,14 +93277,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsWriteEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsWriteEnd kF2fsWriteEnd() { return {}; }
+  static constexpr FieldMetadata_F2fsWriteEnd kF2fsWriteEnd{};
   template <typename T = F2fsWriteEndFtraceEvent> T* set_f2fs_write_end() {
     return BeginNestedMessage<T>(273);
   }
@@ -60013,14 +93291,7 @@ class FtraceEvent : public ::protozero::Message {
       AllocPagesIommuEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AllocPagesIommuEnd kAllocPagesIommuEnd() { return {}; }
+  static constexpr FieldMetadata_AllocPagesIommuEnd kAllocPagesIommuEnd{};
   template <typename T = AllocPagesIommuEndFtraceEvent> T* set_alloc_pages_iommu_end() {
     return BeginNestedMessage<T>(274);
   }
@@ -60034,14 +93305,7 @@ class FtraceEvent : public ::protozero::Message {
       AllocPagesIommuFailFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AllocPagesIommuFail kAllocPagesIommuFail() { return {}; }
+  static constexpr FieldMetadata_AllocPagesIommuFail kAllocPagesIommuFail{};
   template <typename T = AllocPagesIommuFailFtraceEvent> T* set_alloc_pages_iommu_fail() {
     return BeginNestedMessage<T>(275);
   }
@@ -60055,14 +93319,7 @@ class FtraceEvent : public ::protozero::Message {
       AllocPagesIommuStartFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AllocPagesIommuStart kAllocPagesIommuStart() { return {}; }
+  static constexpr FieldMetadata_AllocPagesIommuStart kAllocPagesIommuStart{};
   template <typename T = AllocPagesIommuStartFtraceEvent> T* set_alloc_pages_iommu_start() {
     return BeginNestedMessage<T>(276);
   }
@@ -60076,14 +93333,7 @@ class FtraceEvent : public ::protozero::Message {
       AllocPagesSysEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AllocPagesSysEnd kAllocPagesSysEnd() { return {}; }
+  static constexpr FieldMetadata_AllocPagesSysEnd kAllocPagesSysEnd{};
   template <typename T = AllocPagesSysEndFtraceEvent> T* set_alloc_pages_sys_end() {
     return BeginNestedMessage<T>(277);
   }
@@ -60097,14 +93347,7 @@ class FtraceEvent : public ::protozero::Message {
       AllocPagesSysFailFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AllocPagesSysFail kAllocPagesSysFail() { return {}; }
+  static constexpr FieldMetadata_AllocPagesSysFail kAllocPagesSysFail{};
   template <typename T = AllocPagesSysFailFtraceEvent> T* set_alloc_pages_sys_fail() {
     return BeginNestedMessage<T>(278);
   }
@@ -60118,14 +93361,7 @@ class FtraceEvent : public ::protozero::Message {
       AllocPagesSysStartFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AllocPagesSysStart kAllocPagesSysStart() { return {}; }
+  static constexpr FieldMetadata_AllocPagesSysStart kAllocPagesSysStart{};
   template <typename T = AllocPagesSysStartFtraceEvent> T* set_alloc_pages_sys_start() {
     return BeginNestedMessage<T>(279);
   }
@@ -60139,14 +93375,7 @@ class FtraceEvent : public ::protozero::Message {
       DmaAllocContiguousRetryFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DmaAllocContiguousRetry kDmaAllocContiguousRetry() { return {}; }
+  static constexpr FieldMetadata_DmaAllocContiguousRetry kDmaAllocContiguousRetry{};
   template <typename T = DmaAllocContiguousRetryFtraceEvent> T* set_dma_alloc_contiguous_retry() {
     return BeginNestedMessage<T>(280);
   }
@@ -60160,14 +93389,7 @@ class FtraceEvent : public ::protozero::Message {
       IommuMapRangeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IommuMapRange kIommuMapRange() { return {}; }
+  static constexpr FieldMetadata_IommuMapRange kIommuMapRange{};
   template <typename T = IommuMapRangeFtraceEvent> T* set_iommu_map_range() {
     return BeginNestedMessage<T>(281);
   }
@@ -60181,14 +93403,7 @@ class FtraceEvent : public ::protozero::Message {
       IommuSecPtblMapRangeEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IommuSecPtblMapRangeEnd kIommuSecPtblMapRangeEnd() { return {}; }
+  static constexpr FieldMetadata_IommuSecPtblMapRangeEnd kIommuSecPtblMapRangeEnd{};
   template <typename T = IommuSecPtblMapRangeEndFtraceEvent> T* set_iommu_sec_ptbl_map_range_end() {
     return BeginNestedMessage<T>(282);
   }
@@ -60202,14 +93417,7 @@ class FtraceEvent : public ::protozero::Message {
       IommuSecPtblMapRangeStartFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IommuSecPtblMapRangeStart kIommuSecPtblMapRangeStart() { return {}; }
+  static constexpr FieldMetadata_IommuSecPtblMapRangeStart kIommuSecPtblMapRangeStart{};
   template <typename T = IommuSecPtblMapRangeStartFtraceEvent> T* set_iommu_sec_ptbl_map_range_start() {
     return BeginNestedMessage<T>(283);
   }
@@ -60223,14 +93431,7 @@ class FtraceEvent : public ::protozero::Message {
       IonAllocBufferEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IonAllocBufferEnd kIonAllocBufferEnd() { return {}; }
+  static constexpr FieldMetadata_IonAllocBufferEnd kIonAllocBufferEnd{};
   template <typename T = IonAllocBufferEndFtraceEvent> T* set_ion_alloc_buffer_end() {
     return BeginNestedMessage<T>(284);
   }
@@ -60244,14 +93445,7 @@ class FtraceEvent : public ::protozero::Message {
       IonAllocBufferFailFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IonAllocBufferFail kIonAllocBufferFail() { return {}; }
+  static constexpr FieldMetadata_IonAllocBufferFail kIonAllocBufferFail{};
   template <typename T = IonAllocBufferFailFtraceEvent> T* set_ion_alloc_buffer_fail() {
     return BeginNestedMessage<T>(285);
   }
@@ -60265,14 +93459,7 @@ class FtraceEvent : public ::protozero::Message {
       IonAllocBufferFallbackFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IonAllocBufferFallback kIonAllocBufferFallback() { return {}; }
+  static constexpr FieldMetadata_IonAllocBufferFallback kIonAllocBufferFallback{};
   template <typename T = IonAllocBufferFallbackFtraceEvent> T* set_ion_alloc_buffer_fallback() {
     return BeginNestedMessage<T>(286);
   }
@@ -60286,14 +93473,7 @@ class FtraceEvent : public ::protozero::Message {
       IonAllocBufferStartFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IonAllocBufferStart kIonAllocBufferStart() { return {}; }
+  static constexpr FieldMetadata_IonAllocBufferStart kIonAllocBufferStart{};
   template <typename T = IonAllocBufferStartFtraceEvent> T* set_ion_alloc_buffer_start() {
     return BeginNestedMessage<T>(287);
   }
@@ -60307,14 +93487,7 @@ class FtraceEvent : public ::protozero::Message {
       IonCpAllocRetryFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IonCpAllocRetry kIonCpAllocRetry() { return {}; }
+  static constexpr FieldMetadata_IonCpAllocRetry kIonCpAllocRetry{};
   template <typename T = IonCpAllocRetryFtraceEvent> T* set_ion_cp_alloc_retry() {
     return BeginNestedMessage<T>(288);
   }
@@ -60328,14 +93501,7 @@ class FtraceEvent : public ::protozero::Message {
       IonCpSecureBufferEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IonCpSecureBufferEnd kIonCpSecureBufferEnd() { return {}; }
+  static constexpr FieldMetadata_IonCpSecureBufferEnd kIonCpSecureBufferEnd{};
   template <typename T = IonCpSecureBufferEndFtraceEvent> T* set_ion_cp_secure_buffer_end() {
     return BeginNestedMessage<T>(289);
   }
@@ -60349,14 +93515,7 @@ class FtraceEvent : public ::protozero::Message {
       IonCpSecureBufferStartFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IonCpSecureBufferStart kIonCpSecureBufferStart() { return {}; }
+  static constexpr FieldMetadata_IonCpSecureBufferStart kIonCpSecureBufferStart{};
   template <typename T = IonCpSecureBufferStartFtraceEvent> T* set_ion_cp_secure_buffer_start() {
     return BeginNestedMessage<T>(290);
   }
@@ -60370,14 +93529,7 @@ class FtraceEvent : public ::protozero::Message {
       IonPrefetchingFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IonPrefetching kIonPrefetching() { return {}; }
+  static constexpr FieldMetadata_IonPrefetching kIonPrefetching{};
   template <typename T = IonPrefetchingFtraceEvent> T* set_ion_prefetching() {
     return BeginNestedMessage<T>(291);
   }
@@ -60391,14 +93543,7 @@ class FtraceEvent : public ::protozero::Message {
       IonSecureCmaAddToPoolEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IonSecureCmaAddToPoolEnd kIonSecureCmaAddToPoolEnd() { return {}; }
+  static constexpr FieldMetadata_IonSecureCmaAddToPoolEnd kIonSecureCmaAddToPoolEnd{};
   template <typename T = IonSecureCmaAddToPoolEndFtraceEvent> T* set_ion_secure_cma_add_to_pool_end() {
     return BeginNestedMessage<T>(292);
   }
@@ -60412,14 +93557,7 @@ class FtraceEvent : public ::protozero::Message {
       IonSecureCmaAddToPoolStartFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IonSecureCmaAddToPoolStart kIonSecureCmaAddToPoolStart() { return {}; }
+  static constexpr FieldMetadata_IonSecureCmaAddToPoolStart kIonSecureCmaAddToPoolStart{};
   template <typename T = IonSecureCmaAddToPoolStartFtraceEvent> T* set_ion_secure_cma_add_to_pool_start() {
     return BeginNestedMessage<T>(293);
   }
@@ -60433,14 +93571,7 @@ class FtraceEvent : public ::protozero::Message {
       IonSecureCmaAllocateEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IonSecureCmaAllocateEnd kIonSecureCmaAllocateEnd() { return {}; }
+  static constexpr FieldMetadata_IonSecureCmaAllocateEnd kIonSecureCmaAllocateEnd{};
   template <typename T = IonSecureCmaAllocateEndFtraceEvent> T* set_ion_secure_cma_allocate_end() {
     return BeginNestedMessage<T>(294);
   }
@@ -60454,14 +93585,7 @@ class FtraceEvent : public ::protozero::Message {
       IonSecureCmaAllocateStartFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IonSecureCmaAllocateStart kIonSecureCmaAllocateStart() { return {}; }
+  static constexpr FieldMetadata_IonSecureCmaAllocateStart kIonSecureCmaAllocateStart{};
   template <typename T = IonSecureCmaAllocateStartFtraceEvent> T* set_ion_secure_cma_allocate_start() {
     return BeginNestedMessage<T>(295);
   }
@@ -60475,14 +93599,7 @@ class FtraceEvent : public ::protozero::Message {
       IonSecureCmaShrinkPoolEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IonSecureCmaShrinkPoolEnd kIonSecureCmaShrinkPoolEnd() { return {}; }
+  static constexpr FieldMetadata_IonSecureCmaShrinkPoolEnd kIonSecureCmaShrinkPoolEnd{};
   template <typename T = IonSecureCmaShrinkPoolEndFtraceEvent> T* set_ion_secure_cma_shrink_pool_end() {
     return BeginNestedMessage<T>(296);
   }
@@ -60496,14 +93613,7 @@ class FtraceEvent : public ::protozero::Message {
       IonSecureCmaShrinkPoolStartFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IonSecureCmaShrinkPoolStart kIonSecureCmaShrinkPoolStart() { return {}; }
+  static constexpr FieldMetadata_IonSecureCmaShrinkPoolStart kIonSecureCmaShrinkPoolStart{};
   template <typename T = IonSecureCmaShrinkPoolStartFtraceEvent> T* set_ion_secure_cma_shrink_pool_start() {
     return BeginNestedMessage<T>(297);
   }
@@ -60517,14 +93627,7 @@ class FtraceEvent : public ::protozero::Message {
       KfreeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Kfree kKfree() { return {}; }
+  static constexpr FieldMetadata_Kfree kKfree{};
   template <typename T = KfreeFtraceEvent> T* set_kfree() {
     return BeginNestedMessage<T>(298);
   }
@@ -60538,14 +93641,7 @@ class FtraceEvent : public ::protozero::Message {
       KmallocFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Kmalloc kKmalloc() { return {}; }
+  static constexpr FieldMetadata_Kmalloc kKmalloc{};
   template <typename T = KmallocFtraceEvent> T* set_kmalloc() {
     return BeginNestedMessage<T>(299);
   }
@@ -60559,14 +93655,7 @@ class FtraceEvent : public ::protozero::Message {
       KmallocNodeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KmallocNode kKmallocNode() { return {}; }
+  static constexpr FieldMetadata_KmallocNode kKmallocNode{};
   template <typename T = KmallocNodeFtraceEvent> T* set_kmalloc_node() {
     return BeginNestedMessage<T>(300);
   }
@@ -60580,14 +93669,7 @@ class FtraceEvent : public ::protozero::Message {
       KmemCacheAllocFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KmemCacheAlloc kKmemCacheAlloc() { return {}; }
+  static constexpr FieldMetadata_KmemCacheAlloc kKmemCacheAlloc{};
   template <typename T = KmemCacheAllocFtraceEvent> T* set_kmem_cache_alloc() {
     return BeginNestedMessage<T>(301);
   }
@@ -60601,14 +93683,7 @@ class FtraceEvent : public ::protozero::Message {
       KmemCacheAllocNodeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KmemCacheAllocNode kKmemCacheAllocNode() { return {}; }
+  static constexpr FieldMetadata_KmemCacheAllocNode kKmemCacheAllocNode{};
   template <typename T = KmemCacheAllocNodeFtraceEvent> T* set_kmem_cache_alloc_node() {
     return BeginNestedMessage<T>(302);
   }
@@ -60622,14 +93697,7 @@ class FtraceEvent : public ::protozero::Message {
       KmemCacheFreeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KmemCacheFree kKmemCacheFree() { return {}; }
+  static constexpr FieldMetadata_KmemCacheFree kKmemCacheFree{};
   template <typename T = KmemCacheFreeFtraceEvent> T* set_kmem_cache_free() {
     return BeginNestedMessage<T>(303);
   }
@@ -60643,14 +93711,7 @@ class FtraceEvent : public ::protozero::Message {
       MigratePagesEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MigratePagesEnd kMigratePagesEnd() { return {}; }
+  static constexpr FieldMetadata_MigratePagesEnd kMigratePagesEnd{};
   template <typename T = MigratePagesEndFtraceEvent> T* set_migrate_pages_end() {
     return BeginNestedMessage<T>(304);
   }
@@ -60664,14 +93725,7 @@ class FtraceEvent : public ::protozero::Message {
       MigratePagesStartFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MigratePagesStart kMigratePagesStart() { return {}; }
+  static constexpr FieldMetadata_MigratePagesStart kMigratePagesStart{};
   template <typename T = MigratePagesStartFtraceEvent> T* set_migrate_pages_start() {
     return BeginNestedMessage<T>(305);
   }
@@ -60685,14 +93739,7 @@ class FtraceEvent : public ::protozero::Message {
       MigrateRetryFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MigrateRetry kMigrateRetry() { return {}; }
+  static constexpr FieldMetadata_MigrateRetry kMigrateRetry{};
   template <typename T = MigrateRetryFtraceEvent> T* set_migrate_retry() {
     return BeginNestedMessage<T>(306);
   }
@@ -60706,14 +93753,7 @@ class FtraceEvent : public ::protozero::Message {
       MmPageAllocFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmPageAlloc kMmPageAlloc() { return {}; }
+  static constexpr FieldMetadata_MmPageAlloc kMmPageAlloc{};
   template <typename T = MmPageAllocFtraceEvent> T* set_mm_page_alloc() {
     return BeginNestedMessage<T>(307);
   }
@@ -60727,14 +93767,7 @@ class FtraceEvent : public ::protozero::Message {
       MmPageAllocExtfragFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmPageAllocExtfrag kMmPageAllocExtfrag() { return {}; }
+  static constexpr FieldMetadata_MmPageAllocExtfrag kMmPageAllocExtfrag{};
   template <typename T = MmPageAllocExtfragFtraceEvent> T* set_mm_page_alloc_extfrag() {
     return BeginNestedMessage<T>(308);
   }
@@ -60748,14 +93781,7 @@ class FtraceEvent : public ::protozero::Message {
       MmPageAllocZoneLockedFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmPageAllocZoneLocked kMmPageAllocZoneLocked() { return {}; }
+  static constexpr FieldMetadata_MmPageAllocZoneLocked kMmPageAllocZoneLocked{};
   template <typename T = MmPageAllocZoneLockedFtraceEvent> T* set_mm_page_alloc_zone_locked() {
     return BeginNestedMessage<T>(309);
   }
@@ -60769,14 +93795,7 @@ class FtraceEvent : public ::protozero::Message {
       MmPageFreeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmPageFree kMmPageFree() { return {}; }
+  static constexpr FieldMetadata_MmPageFree kMmPageFree{};
   template <typename T = MmPageFreeFtraceEvent> T* set_mm_page_free() {
     return BeginNestedMessage<T>(310);
   }
@@ -60790,14 +93809,7 @@ class FtraceEvent : public ::protozero::Message {
       MmPageFreeBatchedFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmPageFreeBatched kMmPageFreeBatched() { return {}; }
+  static constexpr FieldMetadata_MmPageFreeBatched kMmPageFreeBatched{};
   template <typename T = MmPageFreeBatchedFtraceEvent> T* set_mm_page_free_batched() {
     return BeginNestedMessage<T>(311);
   }
@@ -60811,14 +93823,7 @@ class FtraceEvent : public ::protozero::Message {
       MmPagePcpuDrainFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmPagePcpuDrain kMmPagePcpuDrain() { return {}; }
+  static constexpr FieldMetadata_MmPagePcpuDrain kMmPagePcpuDrain{};
   template <typename T = MmPagePcpuDrainFtraceEvent> T* set_mm_page_pcpu_drain() {
     return BeginNestedMessage<T>(312);
   }
@@ -60832,14 +93837,7 @@ class FtraceEvent : public ::protozero::Message {
       RssStatFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RssStat kRssStat() { return {}; }
+  static constexpr FieldMetadata_RssStat kRssStat{};
   template <typename T = RssStatFtraceEvent> T* set_rss_stat() {
     return BeginNestedMessage<T>(313);
   }
@@ -60853,14 +93851,7 @@ class FtraceEvent : public ::protozero::Message {
       IonHeapShrinkFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IonHeapShrink kIonHeapShrink() { return {}; }
+  static constexpr FieldMetadata_IonHeapShrink kIonHeapShrink{};
   template <typename T = IonHeapShrinkFtraceEvent> T* set_ion_heap_shrink() {
     return BeginNestedMessage<T>(314);
   }
@@ -60874,14 +93865,7 @@ class FtraceEvent : public ::protozero::Message {
       IonHeapGrowFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IonHeapGrow kIonHeapGrow() { return {}; }
+  static constexpr FieldMetadata_IonHeapGrow kIonHeapGrow{};
   template <typename T = IonHeapGrowFtraceEvent> T* set_ion_heap_grow() {
     return BeginNestedMessage<T>(315);
   }
@@ -60895,14 +93879,7 @@ class FtraceEvent : public ::protozero::Message {
       FenceInitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FenceInit kFenceInit() { return {}; }
+  static constexpr FieldMetadata_FenceInit kFenceInit{};
   template <typename T = FenceInitFtraceEvent> T* set_fence_init() {
     return BeginNestedMessage<T>(316);
   }
@@ -60916,14 +93893,7 @@ class FtraceEvent : public ::protozero::Message {
       FenceDestroyFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FenceDestroy kFenceDestroy() { return {}; }
+  static constexpr FieldMetadata_FenceDestroy kFenceDestroy{};
   template <typename T = FenceDestroyFtraceEvent> T* set_fence_destroy() {
     return BeginNestedMessage<T>(317);
   }
@@ -60937,14 +93907,7 @@ class FtraceEvent : public ::protozero::Message {
       FenceEnableSignalFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FenceEnableSignal kFenceEnableSignal() { return {}; }
+  static constexpr FieldMetadata_FenceEnableSignal kFenceEnableSignal{};
   template <typename T = FenceEnableSignalFtraceEvent> T* set_fence_enable_signal() {
     return BeginNestedMessage<T>(318);
   }
@@ -60958,14 +93921,7 @@ class FtraceEvent : public ::protozero::Message {
       FenceSignaledFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FenceSignaled kFenceSignaled() { return {}; }
+  static constexpr FieldMetadata_FenceSignaled kFenceSignaled{};
   template <typename T = FenceSignaledFtraceEvent> T* set_fence_signaled() {
     return BeginNestedMessage<T>(319);
   }
@@ -60979,14 +93935,7 @@ class FtraceEvent : public ::protozero::Message {
       ClkEnableFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClkEnable kClkEnable() { return {}; }
+  static constexpr FieldMetadata_ClkEnable kClkEnable{};
   template <typename T = ClkEnableFtraceEvent> T* set_clk_enable() {
     return BeginNestedMessage<T>(320);
   }
@@ -61000,14 +93949,7 @@ class FtraceEvent : public ::protozero::Message {
       ClkDisableFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClkDisable kClkDisable() { return {}; }
+  static constexpr FieldMetadata_ClkDisable kClkDisable{};
   template <typename T = ClkDisableFtraceEvent> T* set_clk_disable() {
     return BeginNestedMessage<T>(321);
   }
@@ -61021,14 +93963,7 @@ class FtraceEvent : public ::protozero::Message {
       ClkSetRateFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClkSetRate kClkSetRate() { return {}; }
+  static constexpr FieldMetadata_ClkSetRate kClkSetRate{};
   template <typename T = ClkSetRateFtraceEvent> T* set_clk_set_rate() {
     return BeginNestedMessage<T>(322);
   }
@@ -61042,14 +93977,7 @@ class FtraceEvent : public ::protozero::Message {
       BinderTransactionAllocBufFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BinderTransactionAllocBuf kBinderTransactionAllocBuf() { return {}; }
+  static constexpr FieldMetadata_BinderTransactionAllocBuf kBinderTransactionAllocBuf{};
   template <typename T = BinderTransactionAllocBufFtraceEvent> T* set_binder_transaction_alloc_buf() {
     return BeginNestedMessage<T>(323);
   }
@@ -61063,14 +93991,7 @@ class FtraceEvent : public ::protozero::Message {
       SignalDeliverFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SignalDeliver kSignalDeliver() { return {}; }
+  static constexpr FieldMetadata_SignalDeliver kSignalDeliver{};
   template <typename T = SignalDeliverFtraceEvent> T* set_signal_deliver() {
     return BeginNestedMessage<T>(324);
   }
@@ -61084,14 +94005,7 @@ class FtraceEvent : public ::protozero::Message {
       SignalGenerateFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SignalGenerate kSignalGenerate() { return {}; }
+  static constexpr FieldMetadata_SignalGenerate kSignalGenerate{};
   template <typename T = SignalGenerateFtraceEvent> T* set_signal_generate() {
     return BeginNestedMessage<T>(325);
   }
@@ -61105,14 +94019,7 @@ class FtraceEvent : public ::protozero::Message {
       OomScoreAdjUpdateFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OomScoreAdjUpdate kOomScoreAdjUpdate() { return {}; }
+  static constexpr FieldMetadata_OomScoreAdjUpdate kOomScoreAdjUpdate{};
   template <typename T = OomScoreAdjUpdateFtraceEvent> T* set_oom_score_adj_update() {
     return BeginNestedMessage<T>(326);
   }
@@ -61126,14 +94033,7 @@ class FtraceEvent : public ::protozero::Message {
       GenericFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Generic kGeneric() { return {}; }
+  static constexpr FieldMetadata_Generic kGeneric{};
   template <typename T = GenericFtraceEvent> T* set_generic() {
     return BeginNestedMessage<T>(327);
   }
@@ -61147,14 +94047,7 @@ class FtraceEvent : public ::protozero::Message {
       MmEventRecordFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmEventRecord kMmEventRecord() { return {}; }
+  static constexpr FieldMetadata_MmEventRecord kMmEventRecord{};
   template <typename T = MmEventRecordFtraceEvent> T* set_mm_event_record() {
     return BeginNestedMessage<T>(328);
   }
@@ -61168,14 +94061,7 @@ class FtraceEvent : public ::protozero::Message {
       SysEnterFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SysEnter kSysEnter() { return {}; }
+  static constexpr FieldMetadata_SysEnter kSysEnter{};
   template <typename T = SysEnterFtraceEvent> T* set_sys_enter() {
     return BeginNestedMessage<T>(329);
   }
@@ -61189,14 +94075,7 @@ class FtraceEvent : public ::protozero::Message {
       SysExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SysExit kSysExit() { return {}; }
+  static constexpr FieldMetadata_SysExit kSysExit{};
   template <typename T = SysExitFtraceEvent> T* set_sys_exit() {
     return BeginNestedMessage<T>(330);
   }
@@ -61210,14 +94089,7 @@ class FtraceEvent : public ::protozero::Message {
       ZeroFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Zero kZero() { return {}; }
+  static constexpr FieldMetadata_Zero kZero{};
   template <typename T = ZeroFtraceEvent> T* set_zero() {
     return BeginNestedMessage<T>(331);
   }
@@ -61231,14 +94103,7 @@ class FtraceEvent : public ::protozero::Message {
       GpuFrequencyFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GpuFrequency kGpuFrequency() { return {}; }
+  static constexpr FieldMetadata_GpuFrequency kGpuFrequency{};
   template <typename T = GpuFrequencyFtraceEvent> T* set_gpu_frequency() {
     return BeginNestedMessage<T>(332);
   }
@@ -61252,14 +94117,7 @@ class FtraceEvent : public ::protozero::Message {
       SdeTracingMarkWriteFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SdeTracingMarkWrite kSdeTracingMarkWrite() { return {}; }
+  static constexpr FieldMetadata_SdeTracingMarkWrite kSdeTracingMarkWrite{};
   template <typename T = SdeTracingMarkWriteFtraceEvent> T* set_sde_tracing_mark_write() {
     return BeginNestedMessage<T>(333);
   }
@@ -61273,14 +94131,7 @@ class FtraceEvent : public ::protozero::Message {
       MarkVictimFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MarkVictim kMarkVictim() { return {}; }
+  static constexpr FieldMetadata_MarkVictim kMarkVictim{};
   template <typename T = MarkVictimFtraceEvent> T* set_mark_victim() {
     return BeginNestedMessage<T>(334);
   }
@@ -61294,14 +94145,7 @@ class FtraceEvent : public ::protozero::Message {
       IonStatFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IonStat kIonStat() { return {}; }
+  static constexpr FieldMetadata_IonStat kIonStat{};
   template <typename T = IonStatFtraceEvent> T* set_ion_stat() {
     return BeginNestedMessage<T>(335);
   }
@@ -61315,14 +94159,7 @@ class FtraceEvent : public ::protozero::Message {
       IonBufferCreateFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IonBufferCreate kIonBufferCreate() { return {}; }
+  static constexpr FieldMetadata_IonBufferCreate kIonBufferCreate{};
   template <typename T = IonBufferCreateFtraceEvent> T* set_ion_buffer_create() {
     return BeginNestedMessage<T>(336);
   }
@@ -61336,14 +94173,7 @@ class FtraceEvent : public ::protozero::Message {
       IonBufferDestroyFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IonBufferDestroy kIonBufferDestroy() { return {}; }
+  static constexpr FieldMetadata_IonBufferDestroy kIonBufferDestroy{};
   template <typename T = IonBufferDestroyFtraceEvent> T* set_ion_buffer_destroy() {
     return BeginNestedMessage<T>(337);
   }
@@ -61357,14 +94187,7 @@ class FtraceEvent : public ::protozero::Message {
       ScmCallStartFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ScmCallStart kScmCallStart() { return {}; }
+  static constexpr FieldMetadata_ScmCallStart kScmCallStart{};
   template <typename T = ScmCallStartFtraceEvent> T* set_scm_call_start() {
     return BeginNestedMessage<T>(338);
   }
@@ -61378,14 +94201,7 @@ class FtraceEvent : public ::protozero::Message {
       ScmCallEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ScmCallEnd kScmCallEnd() { return {}; }
+  static constexpr FieldMetadata_ScmCallEnd kScmCallEnd{};
   template <typename T = ScmCallEndFtraceEvent> T* set_scm_call_end() {
     return BeginNestedMessage<T>(339);
   }
@@ -61399,14 +94215,7 @@ class FtraceEvent : public ::protozero::Message {
       GpuMemTotalFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GpuMemTotal kGpuMemTotal() { return {}; }
+  static constexpr FieldMetadata_GpuMemTotal kGpuMemTotal{};
   template <typename T = GpuMemTotalFtraceEvent> T* set_gpu_mem_total() {
     return BeginNestedMessage<T>(340);
   }
@@ -61420,14 +94229,7 @@ class FtraceEvent : public ::protozero::Message {
       ThermalTemperatureFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThermalTemperature kThermalTemperature() { return {}; }
+  static constexpr FieldMetadata_ThermalTemperature kThermalTemperature{};
   template <typename T = ThermalTemperatureFtraceEvent> T* set_thermal_temperature() {
     return BeginNestedMessage<T>(341);
   }
@@ -61441,14 +94243,7 @@ class FtraceEvent : public ::protozero::Message {
       CdevUpdateFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CdevUpdate kCdevUpdate() { return {}; }
+  static constexpr FieldMetadata_CdevUpdate kCdevUpdate{};
   template <typename T = CdevUpdateFtraceEvent> T* set_cdev_update() {
     return BeginNestedMessage<T>(342);
   }
@@ -61462,14 +94257,7 @@ class FtraceEvent : public ::protozero::Message {
       CpuhpExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpuhpExit kCpuhpExit() { return {}; }
+  static constexpr FieldMetadata_CpuhpExit kCpuhpExit{};
   template <typename T = CpuhpExitFtraceEvent> T* set_cpuhp_exit() {
     return BeginNestedMessage<T>(343);
   }
@@ -61483,14 +94271,7 @@ class FtraceEvent : public ::protozero::Message {
       CpuhpMultiEnterFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpuhpMultiEnter kCpuhpMultiEnter() { return {}; }
+  static constexpr FieldMetadata_CpuhpMultiEnter kCpuhpMultiEnter{};
   template <typename T = CpuhpMultiEnterFtraceEvent> T* set_cpuhp_multi_enter() {
     return BeginNestedMessage<T>(344);
   }
@@ -61504,14 +94285,7 @@ class FtraceEvent : public ::protozero::Message {
       CpuhpEnterFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpuhpEnter kCpuhpEnter() { return {}; }
+  static constexpr FieldMetadata_CpuhpEnter kCpuhpEnter{};
   template <typename T = CpuhpEnterFtraceEvent> T* set_cpuhp_enter() {
     return BeginNestedMessage<T>(345);
   }
@@ -61525,14 +94299,7 @@ class FtraceEvent : public ::protozero::Message {
       CpuhpLatencyFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpuhpLatency kCpuhpLatency() { return {}; }
+  static constexpr FieldMetadata_CpuhpLatency kCpuhpLatency{};
   template <typename T = CpuhpLatencyFtraceEvent> T* set_cpuhp_latency() {
     return BeginNestedMessage<T>(346);
   }
@@ -61546,14 +94313,7 @@ class FtraceEvent : public ::protozero::Message {
       FastrpcDmaStatFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FastrpcDmaStat kFastrpcDmaStat() { return {}; }
+  static constexpr FieldMetadata_FastrpcDmaStat kFastrpcDmaStat{};
   template <typename T = FastrpcDmaStatFtraceEvent> T* set_fastrpc_dma_stat() {
     return BeginNestedMessage<T>(347);
   }
@@ -61567,14 +94327,7 @@ class FtraceEvent : public ::protozero::Message {
       DpuTracingMarkWriteFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DpuTracingMarkWrite kDpuTracingMarkWrite() { return {}; }
+  static constexpr FieldMetadata_DpuTracingMarkWrite kDpuTracingMarkWrite{};
   template <typename T = DpuTracingMarkWriteFtraceEvent> T* set_dpu_tracing_mark_write() {
     return BeginNestedMessage<T>(348);
   }
@@ -61588,14 +94341,7 @@ class FtraceEvent : public ::protozero::Message {
       G2dTracingMarkWriteFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_G2dTracingMarkWrite kG2dTracingMarkWrite() { return {}; }
+  static constexpr FieldMetadata_G2dTracingMarkWrite kG2dTracingMarkWrite{};
   template <typename T = G2dTracingMarkWriteFtraceEvent> T* set_g2d_tracing_mark_write() {
     return BeginNestedMessage<T>(349);
   }
@@ -61609,14 +94355,7 @@ class FtraceEvent : public ::protozero::Message {
       MaliTracingMarkWriteFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaliTracingMarkWrite kMaliTracingMarkWrite() { return {}; }
+  static constexpr FieldMetadata_MaliTracingMarkWrite kMaliTracingMarkWrite{};
   template <typename T = MaliTracingMarkWriteFtraceEvent> T* set_mali_tracing_mark_write() {
     return BeginNestedMessage<T>(350);
   }
@@ -61630,14 +94369,7 @@ class FtraceEvent : public ::protozero::Message {
       DmaHeapStatFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DmaHeapStat kDmaHeapStat() { return {}; }
+  static constexpr FieldMetadata_DmaHeapStat kDmaHeapStat{};
   template <typename T = DmaHeapStatFtraceEvent> T* set_dma_heap_stat() {
     return BeginNestedMessage<T>(351);
   }
@@ -61651,14 +94383,7 @@ class FtraceEvent : public ::protozero::Message {
       CpuhpPauseFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpuhpPause kCpuhpPause() { return {}; }
+  static constexpr FieldMetadata_CpuhpPause kCpuhpPause{};
   template <typename T = CpuhpPauseFtraceEvent> T* set_cpuhp_pause() {
     return BeginNestedMessage<T>(352);
   }
@@ -61672,14 +94397,7 @@ class FtraceEvent : public ::protozero::Message {
       SchedPiSetprioFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SchedPiSetprio kSchedPiSetprio() { return {}; }
+  static constexpr FieldMetadata_SchedPiSetprio kSchedPiSetprio{};
   template <typename T = SchedPiSetprioFtraceEvent> T* set_sched_pi_setprio() {
     return BeginNestedMessage<T>(353);
   }
@@ -61693,14 +94411,7 @@ class FtraceEvent : public ::protozero::Message {
       SdeSdeEvtlogFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SdeSdeEvtlog kSdeSdeEvtlog() { return {}; }
+  static constexpr FieldMetadata_SdeSdeEvtlog kSdeSdeEvtlog{};
   template <typename T = SdeSdeEvtlogFtraceEvent> T* set_sde_sde_evtlog() {
     return BeginNestedMessage<T>(354);
   }
@@ -61714,14 +94425,7 @@ class FtraceEvent : public ::protozero::Message {
       SdeSdePerfCalcCrtcFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SdeSdePerfCalcCrtc kSdeSdePerfCalcCrtc() { return {}; }
+  static constexpr FieldMetadata_SdeSdePerfCalcCrtc kSdeSdePerfCalcCrtc{};
   template <typename T = SdeSdePerfCalcCrtcFtraceEvent> T* set_sde_sde_perf_calc_crtc() {
     return BeginNestedMessage<T>(355);
   }
@@ -61735,14 +94439,7 @@ class FtraceEvent : public ::protozero::Message {
       SdeSdePerfCrtcUpdateFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SdeSdePerfCrtcUpdate kSdeSdePerfCrtcUpdate() { return {}; }
+  static constexpr FieldMetadata_SdeSdePerfCrtcUpdate kSdeSdePerfCrtcUpdate{};
   template <typename T = SdeSdePerfCrtcUpdateFtraceEvent> T* set_sde_sde_perf_crtc_update() {
     return BeginNestedMessage<T>(356);
   }
@@ -61756,14 +94453,7 @@ class FtraceEvent : public ::protozero::Message {
       SdeSdePerfSetQosLutsFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SdeSdePerfSetQosLuts kSdeSdePerfSetQosLuts() { return {}; }
+  static constexpr FieldMetadata_SdeSdePerfSetQosLuts kSdeSdePerfSetQosLuts{};
   template <typename T = SdeSdePerfSetQosLutsFtraceEvent> T* set_sde_sde_perf_set_qos_luts() {
     return BeginNestedMessage<T>(357);
   }
@@ -61777,14 +94467,7 @@ class FtraceEvent : public ::protozero::Message {
       SdeSdePerfUpdateBusFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SdeSdePerfUpdateBus kSdeSdePerfUpdateBus() { return {}; }
+  static constexpr FieldMetadata_SdeSdePerfUpdateBus kSdeSdePerfUpdateBus{};
   template <typename T = SdeSdePerfUpdateBusFtraceEvent> T* set_sde_sde_perf_update_bus() {
     return BeginNestedMessage<T>(358);
   }
@@ -61798,14 +94481,7 @@ class FtraceEvent : public ::protozero::Message {
       RssStatThrottledFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RssStatThrottled kRssStatThrottled() { return {}; }
+  static constexpr FieldMetadata_RssStatThrottled kRssStatThrottled{};
   template <typename T = RssStatThrottledFtraceEvent> T* set_rss_stat_throttled() {
     return BeginNestedMessage<T>(359);
   }
@@ -61819,14 +94495,7 @@ class FtraceEvent : public ::protozero::Message {
       NetifReceiveSkbFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NetifReceiveSkb kNetifReceiveSkb() { return {}; }
+  static constexpr FieldMetadata_NetifReceiveSkb kNetifReceiveSkb{};
   template <typename T = NetifReceiveSkbFtraceEvent> T* set_netif_receive_skb() {
     return BeginNestedMessage<T>(360);
   }
@@ -61840,14 +94509,7 @@ class FtraceEvent : public ::protozero::Message {
       NetDevXmitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NetDevXmit kNetDevXmit() { return {}; }
+  static constexpr FieldMetadata_NetDevXmit kNetDevXmit{};
   template <typename T = NetDevXmitFtraceEvent> T* set_net_dev_xmit() {
     return BeginNestedMessage<T>(361);
   }
@@ -61861,14 +94523,7 @@ class FtraceEvent : public ::protozero::Message {
       InetSockSetStateFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InetSockSetState kInetSockSetState() { return {}; }
+  static constexpr FieldMetadata_InetSockSetState kInetSockSetState{};
   template <typename T = InetSockSetStateFtraceEvent> T* set_inet_sock_set_state() {
     return BeginNestedMessage<T>(362);
   }
@@ -61882,14 +94537,7 @@ class FtraceEvent : public ::protozero::Message {
       TcpRetransmitSkbFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TcpRetransmitSkb kTcpRetransmitSkb() { return {}; }
+  static constexpr FieldMetadata_TcpRetransmitSkb kTcpRetransmitSkb{};
   template <typename T = TcpRetransmitSkbFtraceEvent> T* set_tcp_retransmit_skb() {
     return BeginNestedMessage<T>(363);
   }
@@ -61903,14 +94551,7 @@ class FtraceEvent : public ::protozero::Message {
       CrosEcSensorhubDataFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CrosEcSensorhubData kCrosEcSensorhubData() { return {}; }
+  static constexpr FieldMetadata_CrosEcSensorhubData kCrosEcSensorhubData{};
   template <typename T = CrosEcSensorhubDataFtraceEvent> T* set_cros_ec_sensorhub_data() {
     return BeginNestedMessage<T>(364);
   }
@@ -61924,14 +94565,7 @@ class FtraceEvent : public ::protozero::Message {
       NapiGroReceiveEntryFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NapiGroReceiveEntry kNapiGroReceiveEntry() { return {}; }
+  static constexpr FieldMetadata_NapiGroReceiveEntry kNapiGroReceiveEntry{};
   template <typename T = NapiGroReceiveEntryFtraceEvent> T* set_napi_gro_receive_entry() {
     return BeginNestedMessage<T>(365);
   }
@@ -61945,14 +94579,7 @@ class FtraceEvent : public ::protozero::Message {
       NapiGroReceiveExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NapiGroReceiveExit kNapiGroReceiveExit() { return {}; }
+  static constexpr FieldMetadata_NapiGroReceiveExit kNapiGroReceiveExit{};
   template <typename T = NapiGroReceiveExitFtraceEvent> T* set_napi_gro_receive_exit() {
     return BeginNestedMessage<T>(366);
   }
@@ -61966,14 +94593,7 @@ class FtraceEvent : public ::protozero::Message {
       KfreeSkbFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KfreeSkb kKfreeSkb() { return {}; }
+  static constexpr FieldMetadata_KfreeSkb kKfreeSkb{};
   template <typename T = KfreeSkbFtraceEvent> T* set_kfree_skb() {
     return BeginNestedMessage<T>(367);
   }
@@ -61987,14 +94607,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmAccessFaultFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmAccessFault kKvmAccessFault() { return {}; }
+  static constexpr FieldMetadata_KvmAccessFault kKvmAccessFault{};
   template <typename T = KvmAccessFaultFtraceEvent> T* set_kvm_access_fault() {
     return BeginNestedMessage<T>(368);
   }
@@ -62008,14 +94621,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmAckIrqFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmAckIrq kKvmAckIrq() { return {}; }
+  static constexpr FieldMetadata_KvmAckIrq kKvmAckIrq{};
   template <typename T = KvmAckIrqFtraceEvent> T* set_kvm_ack_irq() {
     return BeginNestedMessage<T>(369);
   }
@@ -62029,14 +94635,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmAgeHvaFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmAgeHva kKvmAgeHva() { return {}; }
+  static constexpr FieldMetadata_KvmAgeHva kKvmAgeHva{};
   template <typename T = KvmAgeHvaFtraceEvent> T* set_kvm_age_hva() {
     return BeginNestedMessage<T>(370);
   }
@@ -62050,14 +94649,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmAgePageFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmAgePage kKvmAgePage() { return {}; }
+  static constexpr FieldMetadata_KvmAgePage kKvmAgePage{};
   template <typename T = KvmAgePageFtraceEvent> T* set_kvm_age_page() {
     return BeginNestedMessage<T>(371);
   }
@@ -62071,14 +94663,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmArmClearDebugFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmArmClearDebug kKvmArmClearDebug() { return {}; }
+  static constexpr FieldMetadata_KvmArmClearDebug kKvmArmClearDebug{};
   template <typename T = KvmArmClearDebugFtraceEvent> T* set_kvm_arm_clear_debug() {
     return BeginNestedMessage<T>(372);
   }
@@ -62092,14 +94677,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmArmSetDreg32FtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmArmSetDreg32 kKvmArmSetDreg32() { return {}; }
+  static constexpr FieldMetadata_KvmArmSetDreg32 kKvmArmSetDreg32{};
   template <typename T = KvmArmSetDreg32FtraceEvent> T* set_kvm_arm_set_dreg32() {
     return BeginNestedMessage<T>(373);
   }
@@ -62113,14 +94691,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmArmSetRegsetFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmArmSetRegset kKvmArmSetRegset() { return {}; }
+  static constexpr FieldMetadata_KvmArmSetRegset kKvmArmSetRegset{};
   template <typename T = KvmArmSetRegsetFtraceEvent> T* set_kvm_arm_set_regset() {
     return BeginNestedMessage<T>(374);
   }
@@ -62134,14 +94705,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmArmSetupDebugFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmArmSetupDebug kKvmArmSetupDebug() { return {}; }
+  static constexpr FieldMetadata_KvmArmSetupDebug kKvmArmSetupDebug{};
   template <typename T = KvmArmSetupDebugFtraceEvent> T* set_kvm_arm_setup_debug() {
     return BeginNestedMessage<T>(375);
   }
@@ -62155,14 +94719,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmEntryFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmEntry kKvmEntry() { return {}; }
+  static constexpr FieldMetadata_KvmEntry kKvmEntry{};
   template <typename T = KvmEntryFtraceEvent> T* set_kvm_entry() {
     return BeginNestedMessage<T>(376);
   }
@@ -62176,14 +94733,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmExit kKvmExit() { return {}; }
+  static constexpr FieldMetadata_KvmExit kKvmExit{};
   template <typename T = KvmExitFtraceEvent> T* set_kvm_exit() {
     return BeginNestedMessage<T>(377);
   }
@@ -62197,14 +94747,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmFpuFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmFpu kKvmFpu() { return {}; }
+  static constexpr FieldMetadata_KvmFpu kKvmFpu{};
   template <typename T = KvmFpuFtraceEvent> T* set_kvm_fpu() {
     return BeginNestedMessage<T>(378);
   }
@@ -62218,14 +94761,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmGetTimerMapFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmGetTimerMap kKvmGetTimerMap() { return {}; }
+  static constexpr FieldMetadata_KvmGetTimerMap kKvmGetTimerMap{};
   template <typename T = KvmGetTimerMapFtraceEvent> T* set_kvm_get_timer_map() {
     return BeginNestedMessage<T>(379);
   }
@@ -62239,14 +94775,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmGuestFaultFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmGuestFault kKvmGuestFault() { return {}; }
+  static constexpr FieldMetadata_KvmGuestFault kKvmGuestFault{};
   template <typename T = KvmGuestFaultFtraceEvent> T* set_kvm_guest_fault() {
     return BeginNestedMessage<T>(380);
   }
@@ -62260,14 +94789,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmHandleSysRegFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmHandleSysReg kKvmHandleSysReg() { return {}; }
+  static constexpr FieldMetadata_KvmHandleSysReg kKvmHandleSysReg{};
   template <typename T = KvmHandleSysRegFtraceEvent> T* set_kvm_handle_sys_reg() {
     return BeginNestedMessage<T>(381);
   }
@@ -62281,14 +94803,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmHvcArm64FtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmHvcArm64 kKvmHvcArm64() { return {}; }
+  static constexpr FieldMetadata_KvmHvcArm64 kKvmHvcArm64{};
   template <typename T = KvmHvcArm64FtraceEvent> T* set_kvm_hvc_arm64() {
     return BeginNestedMessage<T>(382);
   }
@@ -62302,14 +94817,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmIrqLineFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmIrqLine kKvmIrqLine() { return {}; }
+  static constexpr FieldMetadata_KvmIrqLine kKvmIrqLine{};
   template <typename T = KvmIrqLineFtraceEvent> T* set_kvm_irq_line() {
     return BeginNestedMessage<T>(383);
   }
@@ -62323,14 +94831,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmMmioFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmMmio kKvmMmio() { return {}; }
+  static constexpr FieldMetadata_KvmMmio kKvmMmio{};
   template <typename T = KvmMmioFtraceEvent> T* set_kvm_mmio() {
     return BeginNestedMessage<T>(384);
   }
@@ -62344,14 +94845,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmMmioEmulateFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmMmioEmulate kKvmMmioEmulate() { return {}; }
+  static constexpr FieldMetadata_KvmMmioEmulate kKvmMmioEmulate{};
   template <typename T = KvmMmioEmulateFtraceEvent> T* set_kvm_mmio_emulate() {
     return BeginNestedMessage<T>(385);
   }
@@ -62365,14 +94859,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmSetGuestDebugFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmSetGuestDebug kKvmSetGuestDebug() { return {}; }
+  static constexpr FieldMetadata_KvmSetGuestDebug kKvmSetGuestDebug{};
   template <typename T = KvmSetGuestDebugFtraceEvent> T* set_kvm_set_guest_debug() {
     return BeginNestedMessage<T>(386);
   }
@@ -62386,14 +94873,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmSetIrqFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmSetIrq kKvmSetIrq() { return {}; }
+  static constexpr FieldMetadata_KvmSetIrq kKvmSetIrq{};
   template <typename T = KvmSetIrqFtraceEvent> T* set_kvm_set_irq() {
     return BeginNestedMessage<T>(387);
   }
@@ -62407,14 +94887,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmSetSpteHvaFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmSetSpteHva kKvmSetSpteHva() { return {}; }
+  static constexpr FieldMetadata_KvmSetSpteHva kKvmSetSpteHva{};
   template <typename T = KvmSetSpteHvaFtraceEvent> T* set_kvm_set_spte_hva() {
     return BeginNestedMessage<T>(388);
   }
@@ -62428,14 +94901,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmSetWayFlushFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmSetWayFlush kKvmSetWayFlush() { return {}; }
+  static constexpr FieldMetadata_KvmSetWayFlush kKvmSetWayFlush{};
   template <typename T = KvmSetWayFlushFtraceEvent> T* set_kvm_set_way_flush() {
     return BeginNestedMessage<T>(389);
   }
@@ -62449,14 +94915,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmSysAccessFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmSysAccess kKvmSysAccess() { return {}; }
+  static constexpr FieldMetadata_KvmSysAccess kKvmSysAccess{};
   template <typename T = KvmSysAccessFtraceEvent> T* set_kvm_sys_access() {
     return BeginNestedMessage<T>(390);
   }
@@ -62470,14 +94929,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmTestAgeHvaFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmTestAgeHva kKvmTestAgeHva() { return {}; }
+  static constexpr FieldMetadata_KvmTestAgeHva kKvmTestAgeHva{};
   template <typename T = KvmTestAgeHvaFtraceEvent> T* set_kvm_test_age_hva() {
     return BeginNestedMessage<T>(391);
   }
@@ -62491,14 +94943,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmTimerEmulateFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmTimerEmulate kKvmTimerEmulate() { return {}; }
+  static constexpr FieldMetadata_KvmTimerEmulate kKvmTimerEmulate{};
   template <typename T = KvmTimerEmulateFtraceEvent> T* set_kvm_timer_emulate() {
     return BeginNestedMessage<T>(392);
   }
@@ -62512,14 +94957,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmTimerHrtimerExpireFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmTimerHrtimerExpire kKvmTimerHrtimerExpire() { return {}; }
+  static constexpr FieldMetadata_KvmTimerHrtimerExpire kKvmTimerHrtimerExpire{};
   template <typename T = KvmTimerHrtimerExpireFtraceEvent> T* set_kvm_timer_hrtimer_expire() {
     return BeginNestedMessage<T>(393);
   }
@@ -62533,14 +94971,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmTimerRestoreStateFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmTimerRestoreState kKvmTimerRestoreState() { return {}; }
+  static constexpr FieldMetadata_KvmTimerRestoreState kKvmTimerRestoreState{};
   template <typename T = KvmTimerRestoreStateFtraceEvent> T* set_kvm_timer_restore_state() {
     return BeginNestedMessage<T>(394);
   }
@@ -62554,14 +94985,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmTimerSaveStateFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmTimerSaveState kKvmTimerSaveState() { return {}; }
+  static constexpr FieldMetadata_KvmTimerSaveState kKvmTimerSaveState{};
   template <typename T = KvmTimerSaveStateFtraceEvent> T* set_kvm_timer_save_state() {
     return BeginNestedMessage<T>(395);
   }
@@ -62575,14 +94999,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmTimerUpdateIrqFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmTimerUpdateIrq kKvmTimerUpdateIrq() { return {}; }
+  static constexpr FieldMetadata_KvmTimerUpdateIrq kKvmTimerUpdateIrq{};
   template <typename T = KvmTimerUpdateIrqFtraceEvent> T* set_kvm_timer_update_irq() {
     return BeginNestedMessage<T>(396);
   }
@@ -62596,14 +95013,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmToggleCacheFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmToggleCache kKvmToggleCache() { return {}; }
+  static constexpr FieldMetadata_KvmToggleCache kKvmToggleCache{};
   template <typename T = KvmToggleCacheFtraceEvent> T* set_kvm_toggle_cache() {
     return BeginNestedMessage<T>(397);
   }
@@ -62617,14 +95027,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmUnmapHvaRangeFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmUnmapHvaRange kKvmUnmapHvaRange() { return {}; }
+  static constexpr FieldMetadata_KvmUnmapHvaRange kKvmUnmapHvaRange{};
   template <typename T = KvmUnmapHvaRangeFtraceEvent> T* set_kvm_unmap_hva_range() {
     return BeginNestedMessage<T>(398);
   }
@@ -62638,14 +95041,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmUserspaceExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmUserspaceExit kKvmUserspaceExit() { return {}; }
+  static constexpr FieldMetadata_KvmUserspaceExit kKvmUserspaceExit{};
   template <typename T = KvmUserspaceExitFtraceEvent> T* set_kvm_userspace_exit() {
     return BeginNestedMessage<T>(399);
   }
@@ -62659,14 +95055,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmVcpuWakeupFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmVcpuWakeup kKvmVcpuWakeup() { return {}; }
+  static constexpr FieldMetadata_KvmVcpuWakeup kKvmVcpuWakeup{};
   template <typename T = KvmVcpuWakeupFtraceEvent> T* set_kvm_vcpu_wakeup() {
     return BeginNestedMessage<T>(400);
   }
@@ -62680,14 +95069,7 @@ class FtraceEvent : public ::protozero::Message {
       KvmWfxArm64FtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KvmWfxArm64 kKvmWfxArm64() { return {}; }
+  static constexpr FieldMetadata_KvmWfxArm64 kKvmWfxArm64{};
   template <typename T = KvmWfxArm64FtraceEvent> T* set_kvm_wfx_arm64() {
     return BeginNestedMessage<T>(401);
   }
@@ -62701,14 +95083,7 @@ class FtraceEvent : public ::protozero::Message {
       TrapRegFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrapReg kTrapReg() { return {}; }
+  static constexpr FieldMetadata_TrapReg kTrapReg{};
   template <typename T = TrapRegFtraceEvent> T* set_trap_reg() {
     return BeginNestedMessage<T>(402);
   }
@@ -62722,14 +95097,7 @@ class FtraceEvent : public ::protozero::Message {
       VgicUpdateIrqPendingFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VgicUpdateIrqPending kVgicUpdateIrqPending() { return {}; }
+  static constexpr FieldMetadata_VgicUpdateIrqPending kVgicUpdateIrqPending{};
   template <typename T = VgicUpdateIrqPendingFtraceEvent> T* set_vgic_update_irq_pending() {
     return BeginNestedMessage<T>(403);
   }
@@ -62743,14 +95111,7 @@ class FtraceEvent : public ::protozero::Message {
       WakeupSourceActivateFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WakeupSourceActivate kWakeupSourceActivate() { return {}; }
+  static constexpr FieldMetadata_WakeupSourceActivate kWakeupSourceActivate{};
   template <typename T = WakeupSourceActivateFtraceEvent> T* set_wakeup_source_activate() {
     return BeginNestedMessage<T>(404);
   }
@@ -62764,14 +95125,7 @@ class FtraceEvent : public ::protozero::Message {
       WakeupSourceDeactivateFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WakeupSourceDeactivate kWakeupSourceDeactivate() { return {}; }
+  static constexpr FieldMetadata_WakeupSourceDeactivate kWakeupSourceDeactivate{};
   template <typename T = WakeupSourceDeactivateFtraceEvent> T* set_wakeup_source_deactivate() {
     return BeginNestedMessage<T>(405);
   }
@@ -62785,14 +95139,7 @@ class FtraceEvent : public ::protozero::Message {
       UfshcdCommandFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UfshcdCommand kUfshcdCommand() { return {}; }
+  static constexpr FieldMetadata_UfshcdCommand kUfshcdCommand{};
   template <typename T = UfshcdCommandFtraceEvent> T* set_ufshcd_command() {
     return BeginNestedMessage<T>(406);
   }
@@ -62806,14 +95153,7 @@ class FtraceEvent : public ::protozero::Message {
       UfshcdClkGatingFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UfshcdClkGating kUfshcdClkGating() { return {}; }
+  static constexpr FieldMetadata_UfshcdClkGating kUfshcdClkGating{};
   template <typename T = UfshcdClkGatingFtraceEvent> T* set_ufshcd_clk_gating() {
     return BeginNestedMessage<T>(407);
   }
@@ -62827,14 +95167,7 @@ class FtraceEvent : public ::protozero::Message {
       ConsoleFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Console kConsole() { return {}; }
+  static constexpr FieldMetadata_Console kConsole{};
   template <typename T = ConsoleFtraceEvent> T* set_console() {
     return BeginNestedMessage<T>(408);
   }
@@ -62848,14 +95181,7 @@ class FtraceEvent : public ::protozero::Message {
       DrmVblankEventFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DrmVblankEvent kDrmVblankEvent() { return {}; }
+  static constexpr FieldMetadata_DrmVblankEvent kDrmVblankEvent{};
   template <typename T = DrmVblankEventFtraceEvent> T* set_drm_vblank_event() {
     return BeginNestedMessage<T>(409);
   }
@@ -62869,14 +95195,7 @@ class FtraceEvent : public ::protozero::Message {
       DrmVblankEventDeliveredFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DrmVblankEventDelivered kDrmVblankEventDelivered() { return {}; }
+  static constexpr FieldMetadata_DrmVblankEventDelivered kDrmVblankEventDelivered{};
   template <typename T = DrmVblankEventDeliveredFtraceEvent> T* set_drm_vblank_event_delivered() {
     return BeginNestedMessage<T>(410);
   }
@@ -62890,14 +95209,7 @@ class FtraceEvent : public ::protozero::Message {
       DrmSchedJobFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DrmSchedJob kDrmSchedJob() { return {}; }
+  static constexpr FieldMetadata_DrmSchedJob kDrmSchedJob{};
   template <typename T = DrmSchedJobFtraceEvent> T* set_drm_sched_job() {
     return BeginNestedMessage<T>(411);
   }
@@ -62911,14 +95223,7 @@ class FtraceEvent : public ::protozero::Message {
       DrmRunJobFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DrmRunJob kDrmRunJob() { return {}; }
+  static constexpr FieldMetadata_DrmRunJob kDrmRunJob{};
   template <typename T = DrmRunJobFtraceEvent> T* set_drm_run_job() {
     return BeginNestedMessage<T>(412);
   }
@@ -62932,14 +95237,7 @@ class FtraceEvent : public ::protozero::Message {
       DrmSchedProcessJobFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DrmSchedProcessJob kDrmSchedProcessJob() { return {}; }
+  static constexpr FieldMetadata_DrmSchedProcessJob kDrmSchedProcessJob{};
   template <typename T = DrmSchedProcessJobFtraceEvent> T* set_drm_sched_process_job() {
     return BeginNestedMessage<T>(413);
   }
@@ -62953,14 +95251,7 @@ class FtraceEvent : public ::protozero::Message {
       DmaFenceInitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DmaFenceInit kDmaFenceInit() { return {}; }
+  static constexpr FieldMetadata_DmaFenceInit kDmaFenceInit{};
   template <typename T = DmaFenceInitFtraceEvent> T* set_dma_fence_init() {
     return BeginNestedMessage<T>(414);
   }
@@ -62974,14 +95265,7 @@ class FtraceEvent : public ::protozero::Message {
       DmaFenceEmitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DmaFenceEmit kDmaFenceEmit() { return {}; }
+  static constexpr FieldMetadata_DmaFenceEmit kDmaFenceEmit{};
   template <typename T = DmaFenceEmitFtraceEvent> T* set_dma_fence_emit() {
     return BeginNestedMessage<T>(415);
   }
@@ -62995,14 +95279,7 @@ class FtraceEvent : public ::protozero::Message {
       DmaFenceSignaledFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DmaFenceSignaled kDmaFenceSignaled() { return {}; }
+  static constexpr FieldMetadata_DmaFenceSignaled kDmaFenceSignaled{};
   template <typename T = DmaFenceSignaledFtraceEvent> T* set_dma_fence_signaled() {
     return BeginNestedMessage<T>(416);
   }
@@ -63016,14 +95293,7 @@ class FtraceEvent : public ::protozero::Message {
       DmaFenceWaitStartFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DmaFenceWaitStart kDmaFenceWaitStart() { return {}; }
+  static constexpr FieldMetadata_DmaFenceWaitStart kDmaFenceWaitStart{};
   template <typename T = DmaFenceWaitStartFtraceEvent> T* set_dma_fence_wait_start() {
     return BeginNestedMessage<T>(417);
   }
@@ -63037,14 +95307,7 @@ class FtraceEvent : public ::protozero::Message {
       DmaFenceWaitEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DmaFenceWaitEnd kDmaFenceWaitEnd() { return {}; }
+  static constexpr FieldMetadata_DmaFenceWaitEnd kDmaFenceWaitEnd{};
   template <typename T = DmaFenceWaitEndFtraceEvent> T* set_dma_fence_wait_end() {
     return BeginNestedMessage<T>(418);
   }
@@ -63058,14 +95321,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsIostatFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsIostat kF2fsIostat() { return {}; }
+  static constexpr FieldMetadata_F2fsIostat kF2fsIostat{};
   template <typename T = F2fsIostatFtraceEvent> T* set_f2fs_iostat() {
     return BeginNestedMessage<T>(419);
   }
@@ -63079,14 +95335,7 @@ class FtraceEvent : public ::protozero::Message {
       F2fsIostatLatencyFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_F2fsIostatLatency kF2fsIostatLatency() { return {}; }
+  static constexpr FieldMetadata_F2fsIostatLatency kF2fsIostatLatency{};
   template <typename T = F2fsIostatLatencyFtraceEvent> T* set_f2fs_iostat_latency() {
     return BeginNestedMessage<T>(420);
   }
@@ -63100,14 +95349,7 @@ class FtraceEvent : public ::protozero::Message {
       SchedCpuUtilCfsFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SchedCpuUtilCfs kSchedCpuUtilCfs() { return {}; }
+  static constexpr FieldMetadata_SchedCpuUtilCfs kSchedCpuUtilCfs{};
   template <typename T = SchedCpuUtilCfsFtraceEvent> T* set_sched_cpu_util_cfs() {
     return BeginNestedMessage<T>(421);
   }
@@ -63121,14 +95363,7 @@ class FtraceEvent : public ::protozero::Message {
       V4l2QbufFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_V4l2Qbuf kV4l2Qbuf() { return {}; }
+  static constexpr FieldMetadata_V4l2Qbuf kV4l2Qbuf{};
   template <typename T = V4l2QbufFtraceEvent> T* set_v4l2_qbuf() {
     return BeginNestedMessage<T>(422);
   }
@@ -63142,14 +95377,7 @@ class FtraceEvent : public ::protozero::Message {
       V4l2DqbufFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_V4l2Dqbuf kV4l2Dqbuf() { return {}; }
+  static constexpr FieldMetadata_V4l2Dqbuf kV4l2Dqbuf{};
   template <typename T = V4l2DqbufFtraceEvent> T* set_v4l2_dqbuf() {
     return BeginNestedMessage<T>(423);
   }
@@ -63163,14 +95391,7 @@ class FtraceEvent : public ::protozero::Message {
       Vb2V4l2BufQueueFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Vb2V4l2BufQueue kVb2V4l2BufQueue() { return {}; }
+  static constexpr FieldMetadata_Vb2V4l2BufQueue kVb2V4l2BufQueue{};
   template <typename T = Vb2V4l2BufQueueFtraceEvent> T* set_vb2_v4l2_buf_queue() {
     return BeginNestedMessage<T>(424);
   }
@@ -63184,14 +95405,7 @@ class FtraceEvent : public ::protozero::Message {
       Vb2V4l2BufDoneFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Vb2V4l2BufDone kVb2V4l2BufDone() { return {}; }
+  static constexpr FieldMetadata_Vb2V4l2BufDone kVb2V4l2BufDone{};
   template <typename T = Vb2V4l2BufDoneFtraceEvent> T* set_vb2_v4l2_buf_done() {
     return BeginNestedMessage<T>(425);
   }
@@ -63205,14 +95419,7 @@ class FtraceEvent : public ::protozero::Message {
       Vb2V4l2QbufFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Vb2V4l2Qbuf kVb2V4l2Qbuf() { return {}; }
+  static constexpr FieldMetadata_Vb2V4l2Qbuf kVb2V4l2Qbuf{};
   template <typename T = Vb2V4l2QbufFtraceEvent> T* set_vb2_v4l2_qbuf() {
     return BeginNestedMessage<T>(426);
   }
@@ -63226,14 +95433,7 @@ class FtraceEvent : public ::protozero::Message {
       Vb2V4l2DqbufFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Vb2V4l2Dqbuf kVb2V4l2Dqbuf() { return {}; }
+  static constexpr FieldMetadata_Vb2V4l2Dqbuf kVb2V4l2Dqbuf{};
   template <typename T = Vb2V4l2DqbufFtraceEvent> T* set_vb2_v4l2_dqbuf() {
     return BeginNestedMessage<T>(427);
   }
@@ -63247,14 +95447,7 @@ class FtraceEvent : public ::protozero::Message {
       DsiCmdFifoStatusFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DsiCmdFifoStatus kDsiCmdFifoStatus() { return {}; }
+  static constexpr FieldMetadata_DsiCmdFifoStatus kDsiCmdFifoStatus{};
   template <typename T = DsiCmdFifoStatusFtraceEvent> T* set_dsi_cmd_fifo_status() {
     return BeginNestedMessage<T>(428);
   }
@@ -63268,14 +95461,7 @@ class FtraceEvent : public ::protozero::Message {
       DsiRxFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DsiRx kDsiRx() { return {}; }
+  static constexpr FieldMetadata_DsiRx kDsiRx{};
   template <typename T = DsiRxFtraceEvent> T* set_dsi_rx() {
     return BeginNestedMessage<T>(429);
   }
@@ -63289,14 +95475,7 @@ class FtraceEvent : public ::protozero::Message {
       DsiTxFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DsiTx kDsiTx() { return {}; }
+  static constexpr FieldMetadata_DsiTx kDsiTx{};
   template <typename T = DsiTxFtraceEvent> T* set_dsi_tx() {
     return BeginNestedMessage<T>(430);
   }
@@ -63310,14 +95489,7 @@ class FtraceEvent : public ::protozero::Message {
       AndroidFsDatareadEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidFsDatareadEnd kAndroidFsDatareadEnd() { return {}; }
+  static constexpr FieldMetadata_AndroidFsDatareadEnd kAndroidFsDatareadEnd{};
   template <typename T = AndroidFsDatareadEndFtraceEvent> T* set_android_fs_dataread_end() {
     return BeginNestedMessage<T>(431);
   }
@@ -63331,14 +95503,7 @@ class FtraceEvent : public ::protozero::Message {
       AndroidFsDatareadStartFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidFsDatareadStart kAndroidFsDatareadStart() { return {}; }
+  static constexpr FieldMetadata_AndroidFsDatareadStart kAndroidFsDatareadStart{};
   template <typename T = AndroidFsDatareadStartFtraceEvent> T* set_android_fs_dataread_start() {
     return BeginNestedMessage<T>(432);
   }
@@ -63352,14 +95517,7 @@ class FtraceEvent : public ::protozero::Message {
       AndroidFsDatawriteEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidFsDatawriteEnd kAndroidFsDatawriteEnd() { return {}; }
+  static constexpr FieldMetadata_AndroidFsDatawriteEnd kAndroidFsDatawriteEnd{};
   template <typename T = AndroidFsDatawriteEndFtraceEvent> T* set_android_fs_datawrite_end() {
     return BeginNestedMessage<T>(433);
   }
@@ -63373,14 +95531,7 @@ class FtraceEvent : public ::protozero::Message {
       AndroidFsDatawriteStartFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidFsDatawriteStart kAndroidFsDatawriteStart() { return {}; }
+  static constexpr FieldMetadata_AndroidFsDatawriteStart kAndroidFsDatawriteStart{};
   template <typename T = AndroidFsDatawriteStartFtraceEvent> T* set_android_fs_datawrite_start() {
     return BeginNestedMessage<T>(434);
   }
@@ -63394,14 +95545,7 @@ class FtraceEvent : public ::protozero::Message {
       AndroidFsFsyncEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidFsFsyncEnd kAndroidFsFsyncEnd() { return {}; }
+  static constexpr FieldMetadata_AndroidFsFsyncEnd kAndroidFsFsyncEnd{};
   template <typename T = AndroidFsFsyncEndFtraceEvent> T* set_android_fs_fsync_end() {
     return BeginNestedMessage<T>(435);
   }
@@ -63415,14 +95559,7 @@ class FtraceEvent : public ::protozero::Message {
       AndroidFsFsyncStartFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidFsFsyncStart kAndroidFsFsyncStart() { return {}; }
+  static constexpr FieldMetadata_AndroidFsFsyncStart kAndroidFsFsyncStart{};
   template <typename T = AndroidFsFsyncStartFtraceEvent> T* set_android_fs_fsync_start() {
     return BeginNestedMessage<T>(436);
   }
@@ -63436,14 +95573,7 @@ class FtraceEvent : public ::protozero::Message {
       FuncgraphEntryFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FuncgraphEntry kFuncgraphEntry() { return {}; }
+  static constexpr FieldMetadata_FuncgraphEntry kFuncgraphEntry{};
   template <typename T = FuncgraphEntryFtraceEvent> T* set_funcgraph_entry() {
     return BeginNestedMessage<T>(437);
   }
@@ -63457,14 +95587,7 @@ class FtraceEvent : public ::protozero::Message {
       FuncgraphExitFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FuncgraphExit kFuncgraphExit() { return {}; }
+  static constexpr FieldMetadata_FuncgraphExit kFuncgraphExit{};
   template <typename T = FuncgraphExitFtraceEvent> T* set_funcgraph_exit() {
     return BeginNestedMessage<T>(438);
   }
@@ -63478,14 +95601,7 @@ class FtraceEvent : public ::protozero::Message {
       VirtioVideoCmdFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VirtioVideoCmd kVirtioVideoCmd() { return {}; }
+  static constexpr FieldMetadata_VirtioVideoCmd kVirtioVideoCmd{};
   template <typename T = VirtioVideoCmdFtraceEvent> T* set_virtio_video_cmd() {
     return BeginNestedMessage<T>(439);
   }
@@ -63499,14 +95615,7 @@ class FtraceEvent : public ::protozero::Message {
       VirtioVideoCmdDoneFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VirtioVideoCmdDone kVirtioVideoCmdDone() { return {}; }
+  static constexpr FieldMetadata_VirtioVideoCmdDone kVirtioVideoCmdDone{};
   template <typename T = VirtioVideoCmdDoneFtraceEvent> T* set_virtio_video_cmd_done() {
     return BeginNestedMessage<T>(440);
   }
@@ -63520,14 +95629,7 @@ class FtraceEvent : public ::protozero::Message {
       VirtioVideoResourceQueueFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VirtioVideoResourceQueue kVirtioVideoResourceQueue() { return {}; }
+  static constexpr FieldMetadata_VirtioVideoResourceQueue kVirtioVideoResourceQueue{};
   template <typename T = VirtioVideoResourceQueueFtraceEvent> T* set_virtio_video_resource_queue() {
     return BeginNestedMessage<T>(441);
   }
@@ -63541,14 +95643,7 @@ class FtraceEvent : public ::protozero::Message {
       VirtioVideoResourceQueueDoneFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VirtioVideoResourceQueueDone kVirtioVideoResourceQueueDone() { return {}; }
+  static constexpr FieldMetadata_VirtioVideoResourceQueueDone kVirtioVideoResourceQueueDone{};
   template <typename T = VirtioVideoResourceQueueDoneFtraceEvent> T* set_virtio_video_resource_queue_done() {
     return BeginNestedMessage<T>(442);
   }
@@ -63562,14 +95657,7 @@ class FtraceEvent : public ::protozero::Message {
       MmShrinkSlabStartFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmShrinkSlabStart kMmShrinkSlabStart() { return {}; }
+  static constexpr FieldMetadata_MmShrinkSlabStart kMmShrinkSlabStart{};
   template <typename T = MmShrinkSlabStartFtraceEvent> T* set_mm_shrink_slab_start() {
     return BeginNestedMessage<T>(443);
   }
@@ -63583,14 +95671,7 @@ class FtraceEvent : public ::protozero::Message {
       MmShrinkSlabEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmShrinkSlabEnd kMmShrinkSlabEnd() { return {}; }
+  static constexpr FieldMetadata_MmShrinkSlabEnd kMmShrinkSlabEnd{};
   template <typename T = MmShrinkSlabEndFtraceEvent> T* set_mm_shrink_slab_end() {
     return BeginNestedMessage<T>(444);
   }
@@ -63604,14 +95685,7 @@ class FtraceEvent : public ::protozero::Message {
       TrustySmcFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustySmc kTrustySmc() { return {}; }
+  static constexpr FieldMetadata_TrustySmc kTrustySmc{};
   template <typename T = TrustySmcFtraceEvent> T* set_trusty_smc() {
     return BeginNestedMessage<T>(445);
   }
@@ -63625,14 +95699,7 @@ class FtraceEvent : public ::protozero::Message {
       TrustySmcDoneFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustySmcDone kTrustySmcDone() { return {}; }
+  static constexpr FieldMetadata_TrustySmcDone kTrustySmcDone{};
   template <typename T = TrustySmcDoneFtraceEvent> T* set_trusty_smc_done() {
     return BeginNestedMessage<T>(446);
   }
@@ -63646,14 +95713,7 @@ class FtraceEvent : public ::protozero::Message {
       TrustyStdCall32FtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustyStdCall32 kTrustyStdCall32() { return {}; }
+  static constexpr FieldMetadata_TrustyStdCall32 kTrustyStdCall32{};
   template <typename T = TrustyStdCall32FtraceEvent> T* set_trusty_std_call32() {
     return BeginNestedMessage<T>(447);
   }
@@ -63667,14 +95727,7 @@ class FtraceEvent : public ::protozero::Message {
       TrustyStdCall32DoneFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustyStdCall32Done kTrustyStdCall32Done() { return {}; }
+  static constexpr FieldMetadata_TrustyStdCall32Done kTrustyStdCall32Done{};
   template <typename T = TrustyStdCall32DoneFtraceEvent> T* set_trusty_std_call32_done() {
     return BeginNestedMessage<T>(448);
   }
@@ -63688,14 +95741,7 @@ class FtraceEvent : public ::protozero::Message {
       TrustyShareMemoryFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustyShareMemory kTrustyShareMemory() { return {}; }
+  static constexpr FieldMetadata_TrustyShareMemory kTrustyShareMemory{};
   template <typename T = TrustyShareMemoryFtraceEvent> T* set_trusty_share_memory() {
     return BeginNestedMessage<T>(449);
   }
@@ -63709,14 +95755,7 @@ class FtraceEvent : public ::protozero::Message {
       TrustyShareMemoryDoneFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustyShareMemoryDone kTrustyShareMemoryDone() { return {}; }
+  static constexpr FieldMetadata_TrustyShareMemoryDone kTrustyShareMemoryDone{};
   template <typename T = TrustyShareMemoryDoneFtraceEvent> T* set_trusty_share_memory_done() {
     return BeginNestedMessage<T>(450);
   }
@@ -63730,14 +95769,7 @@ class FtraceEvent : public ::protozero::Message {
       TrustyReclaimMemoryFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustyReclaimMemory kTrustyReclaimMemory() { return {}; }
+  static constexpr FieldMetadata_TrustyReclaimMemory kTrustyReclaimMemory{};
   template <typename T = TrustyReclaimMemoryFtraceEvent> T* set_trusty_reclaim_memory() {
     return BeginNestedMessage<T>(451);
   }
@@ -63751,14 +95783,7 @@ class FtraceEvent : public ::protozero::Message {
       TrustyReclaimMemoryDoneFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustyReclaimMemoryDone kTrustyReclaimMemoryDone() { return {}; }
+  static constexpr FieldMetadata_TrustyReclaimMemoryDone kTrustyReclaimMemoryDone{};
   template <typename T = TrustyReclaimMemoryDoneFtraceEvent> T* set_trusty_reclaim_memory_done() {
     return BeginNestedMessage<T>(452);
   }
@@ -63772,14 +95797,7 @@ class FtraceEvent : public ::protozero::Message {
       TrustyIrqFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustyIrq kTrustyIrq() { return {}; }
+  static constexpr FieldMetadata_TrustyIrq kTrustyIrq{};
   template <typename T = TrustyIrqFtraceEvent> T* set_trusty_irq() {
     return BeginNestedMessage<T>(453);
   }
@@ -63793,14 +95811,7 @@ class FtraceEvent : public ::protozero::Message {
       TrustyIpcHandleEventFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustyIpcHandleEvent kTrustyIpcHandleEvent() { return {}; }
+  static constexpr FieldMetadata_TrustyIpcHandleEvent kTrustyIpcHandleEvent{};
   template <typename T = TrustyIpcHandleEventFtraceEvent> T* set_trusty_ipc_handle_event() {
     return BeginNestedMessage<T>(454);
   }
@@ -63814,14 +95825,7 @@ class FtraceEvent : public ::protozero::Message {
       TrustyIpcConnectFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustyIpcConnect kTrustyIpcConnect() { return {}; }
+  static constexpr FieldMetadata_TrustyIpcConnect kTrustyIpcConnect{};
   template <typename T = TrustyIpcConnectFtraceEvent> T* set_trusty_ipc_connect() {
     return BeginNestedMessage<T>(455);
   }
@@ -63835,14 +95839,7 @@ class FtraceEvent : public ::protozero::Message {
       TrustyIpcConnectEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustyIpcConnectEnd kTrustyIpcConnectEnd() { return {}; }
+  static constexpr FieldMetadata_TrustyIpcConnectEnd kTrustyIpcConnectEnd{};
   template <typename T = TrustyIpcConnectEndFtraceEvent> T* set_trusty_ipc_connect_end() {
     return BeginNestedMessage<T>(456);
   }
@@ -63856,14 +95853,7 @@ class FtraceEvent : public ::protozero::Message {
       TrustyIpcWriteFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustyIpcWrite kTrustyIpcWrite() { return {}; }
+  static constexpr FieldMetadata_TrustyIpcWrite kTrustyIpcWrite{};
   template <typename T = TrustyIpcWriteFtraceEvent> T* set_trusty_ipc_write() {
     return BeginNestedMessage<T>(457);
   }
@@ -63877,14 +95867,7 @@ class FtraceEvent : public ::protozero::Message {
       TrustyIpcPollFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustyIpcPoll kTrustyIpcPoll() { return {}; }
+  static constexpr FieldMetadata_TrustyIpcPoll kTrustyIpcPoll{};
   template <typename T = TrustyIpcPollFtraceEvent> T* set_trusty_ipc_poll() {
     return BeginNestedMessage<T>(458);
   }
@@ -63898,14 +95881,7 @@ class FtraceEvent : public ::protozero::Message {
       TrustyIpcReadFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustyIpcRead kTrustyIpcRead() { return {}; }
+  static constexpr FieldMetadata_TrustyIpcRead kTrustyIpcRead{};
   template <typename T = TrustyIpcReadFtraceEvent> T* set_trusty_ipc_read() {
     return BeginNestedMessage<T>(460);
   }
@@ -63919,14 +95895,7 @@ class FtraceEvent : public ::protozero::Message {
       TrustyIpcReadEndFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustyIpcReadEnd kTrustyIpcReadEnd() { return {}; }
+  static constexpr FieldMetadata_TrustyIpcReadEnd kTrustyIpcReadEnd{};
   template <typename T = TrustyIpcReadEndFtraceEvent> T* set_trusty_ipc_read_end() {
     return BeginNestedMessage<T>(461);
   }
@@ -63940,14 +95909,7 @@ class FtraceEvent : public ::protozero::Message {
       TrustyIpcRxFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustyIpcRx kTrustyIpcRx() { return {}; }
+  static constexpr FieldMetadata_TrustyIpcRx kTrustyIpcRx{};
   template <typename T = TrustyIpcRxFtraceEvent> T* set_trusty_ipc_rx() {
     return BeginNestedMessage<T>(462);
   }
@@ -63961,14 +95923,7 @@ class FtraceEvent : public ::protozero::Message {
       TrustyEnqueueNopFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustyEnqueueNop kTrustyEnqueueNop() { return {}; }
+  static constexpr FieldMetadata_TrustyEnqueueNop kTrustyEnqueueNop{};
   template <typename T = TrustyEnqueueNopFtraceEvent> T* set_trusty_enqueue_nop() {
     return BeginNestedMessage<T>(464);
   }
@@ -63982,14 +95937,7 @@ class FtraceEvent : public ::protozero::Message {
       CmaAllocStartFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CmaAllocStart kCmaAllocStart() { return {}; }
+  static constexpr FieldMetadata_CmaAllocStart kCmaAllocStart{};
   template <typename T = CmaAllocStartFtraceEvent> T* set_cma_alloc_start() {
     return BeginNestedMessage<T>(465);
   }
@@ -64003,14 +95951,7 @@ class FtraceEvent : public ::protozero::Message {
       CmaAllocInfoFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CmaAllocInfo kCmaAllocInfo() { return {}; }
+  static constexpr FieldMetadata_CmaAllocInfo kCmaAllocInfo{};
   template <typename T = CmaAllocInfoFtraceEvent> T* set_cma_alloc_info() {
     return BeginNestedMessage<T>(466);
   }
@@ -64024,14 +95965,7 @@ class FtraceEvent : public ::protozero::Message {
       LwisTracingMarkWriteFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LwisTracingMarkWrite kLwisTracingMarkWrite() { return {}; }
+  static constexpr FieldMetadata_LwisTracingMarkWrite kLwisTracingMarkWrite{};
   template <typename T = LwisTracingMarkWriteFtraceEvent> T* set_lwis_tracing_mark_write() {
     return BeginNestedMessage<T>(467);
   }
@@ -64045,14 +95979,7 @@ class FtraceEvent : public ::protozero::Message {
       VirtioGpuCmdQueueFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VirtioGpuCmdQueue kVirtioGpuCmdQueue() { return {}; }
+  static constexpr FieldMetadata_VirtioGpuCmdQueue kVirtioGpuCmdQueue{};
   template <typename T = VirtioGpuCmdQueueFtraceEvent> T* set_virtio_gpu_cmd_queue() {
     return BeginNestedMessage<T>(468);
   }
@@ -64066,14 +95993,7 @@ class FtraceEvent : public ::protozero::Message {
       VirtioGpuCmdResponseFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VirtioGpuCmdResponse kVirtioGpuCmdResponse() { return {}; }
+  static constexpr FieldMetadata_VirtioGpuCmdResponse kVirtioGpuCmdResponse{};
   template <typename T = VirtioGpuCmdResponseFtraceEvent> T* set_virtio_gpu_cmd_response() {
     return BeginNestedMessage<T>(469);
   }
@@ -64087,14 +96007,7 @@ class FtraceEvent : public ::protozero::Message {
       MaliMaliKCPUCQSSETFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaliMaliKCPUCQSSET kMaliMaliKCPUCQSSET() { return {}; }
+  static constexpr FieldMetadata_MaliMaliKCPUCQSSET kMaliMaliKCPUCQSSET{};
   template <typename T = MaliMaliKCPUCQSSETFtraceEvent> T* set_mali_mali_kcpu_cqs_set() {
     return BeginNestedMessage<T>(470);
   }
@@ -64108,14 +96021,7 @@ class FtraceEvent : public ::protozero::Message {
       MaliMaliKCPUCQSWAITSTARTFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaliMaliKCPUCQSWAITSTART kMaliMaliKCPUCQSWAITSTART() { return {}; }
+  static constexpr FieldMetadata_MaliMaliKCPUCQSWAITSTART kMaliMaliKCPUCQSWAITSTART{};
   template <typename T = MaliMaliKCPUCQSWAITSTARTFtraceEvent> T* set_mali_mali_kcpu_cqs_wait_start() {
     return BeginNestedMessage<T>(471);
   }
@@ -64129,14 +96035,7 @@ class FtraceEvent : public ::protozero::Message {
       MaliMaliKCPUCQSWAITENDFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaliMaliKCPUCQSWAITEND kMaliMaliKCPUCQSWAITEND() { return {}; }
+  static constexpr FieldMetadata_MaliMaliKCPUCQSWAITEND kMaliMaliKCPUCQSWAITEND{};
   template <typename T = MaliMaliKCPUCQSWAITENDFtraceEvent> T* set_mali_mali_kcpu_cqs_wait_end() {
     return BeginNestedMessage<T>(472);
   }
@@ -64150,14 +96049,7 @@ class FtraceEvent : public ::protozero::Message {
       MaliMaliKCPUFENCESIGNALFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaliMaliKCPUFENCESIGNAL kMaliMaliKCPUFENCESIGNAL() { return {}; }
+  static constexpr FieldMetadata_MaliMaliKCPUFENCESIGNAL kMaliMaliKCPUFENCESIGNAL{};
   template <typename T = MaliMaliKCPUFENCESIGNALFtraceEvent> T* set_mali_mali_kcpu_fence_signal() {
     return BeginNestedMessage<T>(473);
   }
@@ -64171,14 +96063,7 @@ class FtraceEvent : public ::protozero::Message {
       MaliMaliKCPUFENCEWAITSTARTFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaliMaliKCPUFENCEWAITSTART kMaliMaliKCPUFENCEWAITSTART() { return {}; }
+  static constexpr FieldMetadata_MaliMaliKCPUFENCEWAITSTART kMaliMaliKCPUFENCEWAITSTART{};
   template <typename T = MaliMaliKCPUFENCEWAITSTARTFtraceEvent> T* set_mali_mali_kcpu_fence_wait_start() {
     return BeginNestedMessage<T>(474);
   }
@@ -64192,18 +96077,1789 @@ class FtraceEvent : public ::protozero::Message {
       MaliMaliKCPUFENCEWAITENDFtraceEvent,
       FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaliMaliKCPUFENCEWAITEND kMaliMaliKCPUFENCEWAITEND() { return {}; }
+  static constexpr FieldMetadata_MaliMaliKCPUFENCEWAITEND kMaliMaliKCPUFENCEWAITEND{};
   template <typename T = MaliMaliKCPUFENCEWAITENDFtraceEvent> T* set_mali_mali_kcpu_fence_wait_end() {
     return BeginNestedMessage<T>(475);
   }
 
+
+  using FieldMetadata_HypEnter =
+    ::protozero::proto_utils::FieldMetadata<
+      476,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HypEnterFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_HypEnter kHypEnter{};
+  template <typename T = HypEnterFtraceEvent> T* set_hyp_enter() {
+    return BeginNestedMessage<T>(476);
+  }
+
+
+  using FieldMetadata_HypExit =
+    ::protozero::proto_utils::FieldMetadata<
+      477,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HypExitFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_HypExit kHypExit{};
+  template <typename T = HypExitFtraceEvent> T* set_hyp_exit() {
+    return BeginNestedMessage<T>(477);
+  }
+
+
+  using FieldMetadata_HostHcall =
+    ::protozero::proto_utils::FieldMetadata<
+      478,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HostHcallFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_HostHcall kHostHcall{};
+  template <typename T = HostHcallFtraceEvent> T* set_host_hcall() {
+    return BeginNestedMessage<T>(478);
+  }
+
+
+  using FieldMetadata_HostSmc =
+    ::protozero::proto_utils::FieldMetadata<
+      479,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HostSmcFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_HostSmc kHostSmc{};
+  template <typename T = HostSmcFtraceEvent> T* set_host_smc() {
+    return BeginNestedMessage<T>(479);
+  }
+
+
+  using FieldMetadata_HostMemAbort =
+    ::protozero::proto_utils::FieldMetadata<
+      480,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HostMemAbortFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_HostMemAbort kHostMemAbort{};
+  template <typename T = HostMemAbortFtraceEvent> T* set_host_mem_abort() {
+    return BeginNestedMessage<T>(480);
+  }
+
+
+  using FieldMetadata_SuspendResumeMinimal =
+    ::protozero::proto_utils::FieldMetadata<
+      481,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SuspendResumeMinimalFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_SuspendResumeMinimal kSuspendResumeMinimal{};
+  template <typename T = SuspendResumeMinimalFtraceEvent> T* set_suspend_resume_minimal() {
+    return BeginNestedMessage<T>(481);
+  }
+
+
+  using FieldMetadata_MaliMaliCSFINTERRUPTSTART =
+    ::protozero::proto_utils::FieldMetadata<
+      482,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliCSFINTERRUPTSTARTFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliCSFINTERRUPTSTART kMaliMaliCSFINTERRUPTSTART{};
+  template <typename T = MaliMaliCSFINTERRUPTSTARTFtraceEvent> T* set_mali_mali_csf_interrupt_start() {
+    return BeginNestedMessage<T>(482);
+  }
+
+
+  using FieldMetadata_MaliMaliCSFINTERRUPTEND =
+    ::protozero::proto_utils::FieldMetadata<
+      483,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliCSFINTERRUPTENDFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliCSFINTERRUPTEND kMaliMaliCSFINTERRUPTEND{};
+  template <typename T = MaliMaliCSFINTERRUPTENDFtraceEvent> T* set_mali_mali_csf_interrupt_end() {
+    return BeginNestedMessage<T>(483);
+  }
+
+
+  using FieldMetadata_SamsungTracingMarkWrite =
+    ::protozero::proto_utils::FieldMetadata<
+      484,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SamsungTracingMarkWriteFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_SamsungTracingMarkWrite kSamsungTracingMarkWrite{};
+  template <typename T = SamsungTracingMarkWriteFtraceEvent> T* set_samsung_tracing_mark_write() {
+    return BeginNestedMessage<T>(484);
+  }
+
+
+  using FieldMetadata_BinderCommand =
+    ::protozero::proto_utils::FieldMetadata<
+      485,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BinderCommandFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_BinderCommand kBinderCommand{};
+  template <typename T = BinderCommandFtraceEvent> T* set_binder_command() {
+    return BeginNestedMessage<T>(485);
+  }
+
+
+  using FieldMetadata_BinderReturn =
+    ::protozero::proto_utils::FieldMetadata<
+      486,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BinderReturnFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_BinderReturn kBinderReturn{};
+  template <typename T = BinderReturnFtraceEvent> T* set_binder_return() {
+    return BeginNestedMessage<T>(486);
+  }
+
+
+  using FieldMetadata_SchedSwitchWithCtrs =
+    ::protozero::proto_utils::FieldMetadata<
+      487,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SchedSwitchWithCtrsFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_SchedSwitchWithCtrs kSchedSwitchWithCtrs{};
+  template <typename T = SchedSwitchWithCtrsFtraceEvent> T* set_sched_switch_with_ctrs() {
+    return BeginNestedMessage<T>(487);
+  }
+
+
+  using FieldMetadata_GpuWorkPeriod =
+    ::protozero::proto_utils::FieldMetadata<
+      488,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      GpuWorkPeriodFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_GpuWorkPeriod kGpuWorkPeriod{};
+  template <typename T = GpuWorkPeriodFtraceEvent> T* set_gpu_work_period() {
+    return BeginNestedMessage<T>(488);
+  }
+
+
+  using FieldMetadata_RpmStatus =
+    ::protozero::proto_utils::FieldMetadata<
+      489,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      RpmStatusFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_RpmStatus kRpmStatus{};
+  template <typename T = RpmStatusFtraceEvent> T* set_rpm_status() {
+    return BeginNestedMessage<T>(489);
+  }
+
+
+  using FieldMetadata_PanelWriteGeneric =
+    ::protozero::proto_utils::FieldMetadata<
+      490,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PanelWriteGenericFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_PanelWriteGeneric kPanelWriteGeneric{};
+  template <typename T = PanelWriteGenericFtraceEvent> T* set_panel_write_generic() {
+    return BeginNestedMessage<T>(490);
+  }
+
+
+  using FieldMetadata_SchedMigrateTask =
+    ::protozero::proto_utils::FieldMetadata<
+      491,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SchedMigrateTaskFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_SchedMigrateTask kSchedMigrateTask{};
+  template <typename T = SchedMigrateTaskFtraceEvent> T* set_sched_migrate_task() {
+    return BeginNestedMessage<T>(491);
+  }
+
+
+  using FieldMetadata_DpuDsiCmdFifoStatus =
+    ::protozero::proto_utils::FieldMetadata<
+      492,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      DpuDsiCmdFifoStatusFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_DpuDsiCmdFifoStatus kDpuDsiCmdFifoStatus{};
+  template <typename T = DpuDsiCmdFifoStatusFtraceEvent> T* set_dpu_dsi_cmd_fifo_status() {
+    return BeginNestedMessage<T>(492);
+  }
+
+
+  using FieldMetadata_DpuDsiRx =
+    ::protozero::proto_utils::FieldMetadata<
+      493,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      DpuDsiRxFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_DpuDsiRx kDpuDsiRx{};
+  template <typename T = DpuDsiRxFtraceEvent> T* set_dpu_dsi_rx() {
+    return BeginNestedMessage<T>(493);
+  }
+
+
+  using FieldMetadata_DpuDsiTx =
+    ::protozero::proto_utils::FieldMetadata<
+      494,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      DpuDsiTxFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_DpuDsiTx kDpuDsiTx{};
+  template <typename T = DpuDsiTxFtraceEvent> T* set_dpu_dsi_tx() {
+    return BeginNestedMessage<T>(494);
+  }
+
+
+  using FieldMetadata_F2fsBackgroundGc =
+    ::protozero::proto_utils::FieldMetadata<
+      495,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      F2fsBackgroundGcFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_F2fsBackgroundGc kF2fsBackgroundGc{};
+  template <typename T = F2fsBackgroundGcFtraceEvent> T* set_f2fs_background_gc() {
+    return BeginNestedMessage<T>(495);
+  }
+
+
+  using FieldMetadata_F2fsGcBegin =
+    ::protozero::proto_utils::FieldMetadata<
+      496,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      F2fsGcBeginFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_F2fsGcBegin kF2fsGcBegin{};
+  template <typename T = F2fsGcBeginFtraceEvent> T* set_f2fs_gc_begin() {
+    return BeginNestedMessage<T>(496);
+  }
+
+
+  using FieldMetadata_F2fsGcEnd =
+    ::protozero::proto_utils::FieldMetadata<
+      497,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      F2fsGcEndFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_F2fsGcEnd kF2fsGcEnd{};
+  template <typename T = F2fsGcEndFtraceEvent> T* set_f2fs_gc_end() {
+    return BeginNestedMessage<T>(497);
+  }
+
+
+  using FieldMetadata_FastrpcDmaFree =
+    ::protozero::proto_utils::FieldMetadata<
+      498,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FastrpcDmaFreeFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_FastrpcDmaFree kFastrpcDmaFree{};
+  template <typename T = FastrpcDmaFreeFtraceEvent> T* set_fastrpc_dma_free() {
+    return BeginNestedMessage<T>(498);
+  }
+
+
+  using FieldMetadata_FastrpcDmaAlloc =
+    ::protozero::proto_utils::FieldMetadata<
+      499,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FastrpcDmaAllocFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_FastrpcDmaAlloc kFastrpcDmaAlloc{};
+  template <typename T = FastrpcDmaAllocFtraceEvent> T* set_fastrpc_dma_alloc() {
+    return BeginNestedMessage<T>(499);
+  }
+
+
+  using FieldMetadata_FastrpcDmaUnmap =
+    ::protozero::proto_utils::FieldMetadata<
+      500,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FastrpcDmaUnmapFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_FastrpcDmaUnmap kFastrpcDmaUnmap{};
+  template <typename T = FastrpcDmaUnmapFtraceEvent> T* set_fastrpc_dma_unmap() {
+    return BeginNestedMessage<T>(500);
+  }
+
+
+  using FieldMetadata_FastrpcDmaMap =
+    ::protozero::proto_utils::FieldMetadata<
+      501,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FastrpcDmaMapFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_FastrpcDmaMap kFastrpcDmaMap{};
+  template <typename T = FastrpcDmaMapFtraceEvent> T* set_fastrpc_dma_map() {
+    return BeginNestedMessage<T>(501);
+  }
+
+
+  using FieldMetadata_GoogleIccEvent =
+    ::protozero::proto_utils::FieldMetadata<
+      502,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      GoogleIccEventFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_GoogleIccEvent kGoogleIccEvent{};
+  template <typename T = GoogleIccEventFtraceEvent> T* set_google_icc_event() {
+    return BeginNestedMessage<T>(502);
+  }
+
+
+  using FieldMetadata_GoogleIrmEvent =
+    ::protozero::proto_utils::FieldMetadata<
+      503,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      GoogleIrmEventFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_GoogleIrmEvent kGoogleIrmEvent{};
+  template <typename T = GoogleIrmEventFtraceEvent> T* set_google_irm_event() {
+    return BeginNestedMessage<T>(503);
+  }
+
+
+  using FieldMetadata_DevicePmCallbackStart =
+    ::protozero::proto_utils::FieldMetadata<
+      504,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      DevicePmCallbackStartFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_DevicePmCallbackStart kDevicePmCallbackStart{};
+  template <typename T = DevicePmCallbackStartFtraceEvent> T* set_device_pm_callback_start() {
+    return BeginNestedMessage<T>(504);
+  }
+
+
+  using FieldMetadata_DevicePmCallbackEnd =
+    ::protozero::proto_utils::FieldMetadata<
+      505,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      DevicePmCallbackEndFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_DevicePmCallbackEnd kDevicePmCallbackEnd{};
+  template <typename T = DevicePmCallbackEndFtraceEvent> T* set_device_pm_callback_end() {
+    return BeginNestedMessage<T>(505);
+  }
+
+
+  using FieldMetadata_ThermalExynosAcpmBulk =
+    ::protozero::proto_utils::FieldMetadata<
+      506,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ThermalExynosAcpmBulkFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_ThermalExynosAcpmBulk kThermalExynosAcpmBulk{};
+  template <typename T = ThermalExynosAcpmBulkFtraceEvent> T* set_thermal_exynos_acpm_bulk() {
+    return BeginNestedMessage<T>(506);
+  }
+
+
+  using FieldMetadata_ThermalExynosAcpmHighOverhead =
+    ::protozero::proto_utils::FieldMetadata<
+      507,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ThermalExynosAcpmHighOverheadFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_ThermalExynosAcpmHighOverhead kThermalExynosAcpmHighOverhead{};
+  template <typename T = ThermalExynosAcpmHighOverheadFtraceEvent> T* set_thermal_exynos_acpm_high_overhead() {
+    return BeginNestedMessage<T>(507);
+  }
+
+
+  using FieldMetadata_DcvshFreq =
+    ::protozero::proto_utils::FieldMetadata<
+      508,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      DcvshFreqFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_DcvshFreq kDcvshFreq{};
+  template <typename T = DcvshFreqFtraceEvent> T* set_dcvsh_freq() {
+    return BeginNestedMessage<T>(508);
+  }
+
+
+  using FieldMetadata_KgslGpuFrequency =
+    ::protozero::proto_utils::FieldMetadata<
+      509,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      KgslGpuFrequencyFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_KgslGpuFrequency kKgslGpuFrequency{};
+  template <typename T = KgslGpuFrequencyFtraceEvent> T* set_kgsl_gpu_frequency() {
+    return BeginNestedMessage<T>(509);
+  }
+
+
+  using FieldMetadata_MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPEND =
+    ::protozero::proto_utils::FieldMetadata<
+      510,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPEND kMaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPEND{};
+  template <typename T = MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent> T* set_mali_mali_pm_mcu_hctl_cores_down_scale_notify_pend() {
+    return BeginNestedMessage<T>(510);
+  }
+
+
+  using FieldMetadata_MaliMaliPMMCUHCTLCORESNOTIFYPEND =
+    ::protozero::proto_utils::FieldMetadata<
+      511,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliPMMCUHCTLCORESNOTIFYPEND kMaliMaliPMMCUHCTLCORESNOTIFYPEND{};
+  template <typename T = MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent> T* set_mali_mali_pm_mcu_hctl_cores_notify_pend() {
+    return BeginNestedMessage<T>(511);
+  }
+
+
+  using FieldMetadata_MaliMaliPMMCUHCTLCOREINACTIVEPEND =
+    ::protozero::proto_utils::FieldMetadata<
+      512,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliPMMCUHCTLCOREINACTIVEPEND kMaliMaliPMMCUHCTLCOREINACTIVEPEND{};
+  template <typename T = MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent> T* set_mali_mali_pm_mcu_hctl_core_inactive_pend() {
+    return BeginNestedMessage<T>(512);
+  }
+
+
+  using FieldMetadata_MaliMaliPMMCUHCTLMCUONRECHECK =
+    ::protozero::proto_utils::FieldMetadata<
+      513,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliPMMCUHCTLMCUONRECHECK kMaliMaliPMMCUHCTLMCUONRECHECK{};
+  template <typename T = MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent> T* set_mali_mali_pm_mcu_hctl_mcu_on_recheck() {
+    return BeginNestedMessage<T>(513);
+  }
+
+
+  using FieldMetadata_MaliMaliPMMCUHCTLSHADERSCOREOFFPEND =
+    ::protozero::proto_utils::FieldMetadata<
+      514,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliPMMCUHCTLSHADERSCOREOFFPEND kMaliMaliPMMCUHCTLSHADERSCOREOFFPEND{};
+  template <typename T = MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent> T* set_mali_mali_pm_mcu_hctl_shaders_core_off_pend() {
+    return BeginNestedMessage<T>(514);
+  }
+
+
+  using FieldMetadata_MaliMaliPMMCUHCTLSHADERSPENDOFF =
+    ::protozero::proto_utils::FieldMetadata<
+      515,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliPMMCUHCTLSHADERSPENDOFF kMaliMaliPMMCUHCTLSHADERSPENDOFF{};
+  template <typename T = MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent> T* set_mali_mali_pm_mcu_hctl_shaders_pend_off() {
+    return BeginNestedMessage<T>(515);
+  }
+
+
+  using FieldMetadata_MaliMaliPMMCUHCTLSHADERSPENDON =
+    ::protozero::proto_utils::FieldMetadata<
+      516,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliPMMCUHCTLSHADERSPENDON kMaliMaliPMMCUHCTLSHADERSPENDON{};
+  template <typename T = MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent> T* set_mali_mali_pm_mcu_hctl_shaders_pend_on() {
+    return BeginNestedMessage<T>(516);
+  }
+
+
+  using FieldMetadata_MaliMaliPMMCUHCTLSHADERSREADYOFF =
+    ::protozero::proto_utils::FieldMetadata<
+      517,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliPMMCUHCTLSHADERSREADYOFF kMaliMaliPMMCUHCTLSHADERSREADYOFF{};
+  template <typename T = MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent> T* set_mali_mali_pm_mcu_hctl_shaders_ready_off() {
+    return BeginNestedMessage<T>(517);
+  }
+
+
+  using FieldMetadata_MaliMaliPMMCUINSLEEP =
+    ::protozero::proto_utils::FieldMetadata<
+      518,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliPMMCUINSLEEPFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliPMMCUINSLEEP kMaliMaliPMMCUINSLEEP{};
+  template <typename T = MaliMaliPMMCUINSLEEPFtraceEvent> T* set_mali_mali_pm_mcu_in_sleep() {
+    return BeginNestedMessage<T>(518);
+  }
+
+
+  using FieldMetadata_MaliMaliPMMCUOFF =
+    ::protozero::proto_utils::FieldMetadata<
+      519,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliPMMCUOFFFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliPMMCUOFF kMaliMaliPMMCUOFF{};
+  template <typename T = MaliMaliPMMCUOFFFtraceEvent> T* set_mali_mali_pm_mcu_off() {
+    return BeginNestedMessage<T>(519);
+  }
+
+
+  using FieldMetadata_MaliMaliPMMCUON =
+    ::protozero::proto_utils::FieldMetadata<
+      520,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliPMMCUONFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliPMMCUON kMaliMaliPMMCUON{};
+  template <typename T = MaliMaliPMMCUONFtraceEvent> T* set_mali_mali_pm_mcu_on() {
+    return BeginNestedMessage<T>(520);
+  }
+
+
+  using FieldMetadata_MaliMaliPMMCUONCOREATTRUPDATEPEND =
+    ::protozero::proto_utils::FieldMetadata<
+      521,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliPMMCUONCOREATTRUPDATEPEND kMaliMaliPMMCUONCOREATTRUPDATEPEND{};
+  template <typename T = MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent> T* set_mali_mali_pm_mcu_on_core_attr_update_pend() {
+    return BeginNestedMessage<T>(521);
+  }
+
+
+  using FieldMetadata_MaliMaliPMMCUONGLBREINITPEND =
+    ::protozero::proto_utils::FieldMetadata<
+      522,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliPMMCUONGLBREINITPENDFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliPMMCUONGLBREINITPEND kMaliMaliPMMCUONGLBREINITPEND{};
+  template <typename T = MaliMaliPMMCUONGLBREINITPENDFtraceEvent> T* set_mali_mali_pm_mcu_on_glb_reinit_pend() {
+    return BeginNestedMessage<T>(522);
+  }
+
+
+  using FieldMetadata_MaliMaliPMMCUONHALT =
+    ::protozero::proto_utils::FieldMetadata<
+      523,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliPMMCUONHALTFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliPMMCUONHALT kMaliMaliPMMCUONHALT{};
+  template <typename T = MaliMaliPMMCUONHALTFtraceEvent> T* set_mali_mali_pm_mcu_on_halt() {
+    return BeginNestedMessage<T>(523);
+  }
+
+
+  using FieldMetadata_MaliMaliPMMCUONHWCNTDISABLE =
+    ::protozero::proto_utils::FieldMetadata<
+      524,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliPMMCUONHWCNTDISABLEFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliPMMCUONHWCNTDISABLE kMaliMaliPMMCUONHWCNTDISABLE{};
+  template <typename T = MaliMaliPMMCUONHWCNTDISABLEFtraceEvent> T* set_mali_mali_pm_mcu_on_hwcnt_disable() {
+    return BeginNestedMessage<T>(524);
+  }
+
+
+  using FieldMetadata_MaliMaliPMMCUONHWCNTENABLE =
+    ::protozero::proto_utils::FieldMetadata<
+      525,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliPMMCUONHWCNTENABLEFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliPMMCUONHWCNTENABLE kMaliMaliPMMCUONHWCNTENABLE{};
+  template <typename T = MaliMaliPMMCUONHWCNTENABLEFtraceEvent> T* set_mali_mali_pm_mcu_on_hwcnt_enable() {
+    return BeginNestedMessage<T>(525);
+  }
+
+
+  using FieldMetadata_MaliMaliPMMCUONPENDHALT =
+    ::protozero::proto_utils::FieldMetadata<
+      526,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliPMMCUONPENDHALTFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliPMMCUONPENDHALT kMaliMaliPMMCUONPENDHALT{};
+  template <typename T = MaliMaliPMMCUONPENDHALTFtraceEvent> T* set_mali_mali_pm_mcu_on_pend_halt() {
+    return BeginNestedMessage<T>(526);
+  }
+
+
+  using FieldMetadata_MaliMaliPMMCUONPENDSLEEP =
+    ::protozero::proto_utils::FieldMetadata<
+      527,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliPMMCUONPENDSLEEPFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliPMMCUONPENDSLEEP kMaliMaliPMMCUONPENDSLEEP{};
+  template <typename T = MaliMaliPMMCUONPENDSLEEPFtraceEvent> T* set_mali_mali_pm_mcu_on_pend_sleep() {
+    return BeginNestedMessage<T>(527);
+  }
+
+
+  using FieldMetadata_MaliMaliPMMCUONSLEEPINITIATE =
+    ::protozero::proto_utils::FieldMetadata<
+      528,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliPMMCUONSLEEPINITIATEFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliPMMCUONSLEEPINITIATE kMaliMaliPMMCUONSLEEPINITIATE{};
+  template <typename T = MaliMaliPMMCUONSLEEPINITIATEFtraceEvent> T* set_mali_mali_pm_mcu_on_sleep_initiate() {
+    return BeginNestedMessage<T>(528);
+  }
+
+
+  using FieldMetadata_MaliMaliPMMCUPENDOFF =
+    ::protozero::proto_utils::FieldMetadata<
+      529,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliPMMCUPENDOFFFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliPMMCUPENDOFF kMaliMaliPMMCUPENDOFF{};
+  template <typename T = MaliMaliPMMCUPENDOFFFtraceEvent> T* set_mali_mali_pm_mcu_pend_off() {
+    return BeginNestedMessage<T>(529);
+  }
+
+
+  using FieldMetadata_MaliMaliPMMCUPENDONRELOAD =
+    ::protozero::proto_utils::FieldMetadata<
+      530,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliPMMCUPENDONRELOADFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliPMMCUPENDONRELOAD kMaliMaliPMMCUPENDONRELOAD{};
+  template <typename T = MaliMaliPMMCUPENDONRELOADFtraceEvent> T* set_mali_mali_pm_mcu_pend_on_reload() {
+    return BeginNestedMessage<T>(530);
+  }
+
+
+  using FieldMetadata_MaliMaliPMMCUPOWERDOWN =
+    ::protozero::proto_utils::FieldMetadata<
+      531,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliPMMCUPOWERDOWNFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliPMMCUPOWERDOWN kMaliMaliPMMCUPOWERDOWN{};
+  template <typename T = MaliMaliPMMCUPOWERDOWNFtraceEvent> T* set_mali_mali_pm_mcu_power_down() {
+    return BeginNestedMessage<T>(531);
+  }
+
+
+  using FieldMetadata_MaliMaliPMMCURESETWAIT =
+    ::protozero::proto_utils::FieldMetadata<
+      532,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliMaliPMMCURESETWAITFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliMaliPMMCURESETWAIT kMaliMaliPMMCURESETWAIT{};
+  template <typename T = MaliMaliPMMCURESETWAITFtraceEvent> T* set_mali_mali_pm_mcu_reset_wait() {
+    return BeginNestedMessage<T>(532);
+  }
+
+
+  using FieldMetadata_BclIrqTrigger =
+    ::protozero::proto_utils::FieldMetadata<
+      533,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BclIrqTriggerFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_BclIrqTrigger kBclIrqTrigger{};
+  template <typename T = BclIrqTriggerFtraceEvent> T* set_bcl_irq_trigger() {
+    return BeginNestedMessage<T>(533);
+  }
+
+
+  using FieldMetadata_KgslAdrenoCmdbatchQueued =
+    ::protozero::proto_utils::FieldMetadata<
+      534,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      KgslAdrenoCmdbatchQueuedFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_KgslAdrenoCmdbatchQueued kKgslAdrenoCmdbatchQueued{};
+  template <typename T = KgslAdrenoCmdbatchQueuedFtraceEvent> T* set_kgsl_adreno_cmdbatch_queued() {
+    return BeginNestedMessage<T>(534);
+  }
+
+
+  using FieldMetadata_KgslAdrenoCmdbatchSubmitted =
+    ::protozero::proto_utils::FieldMetadata<
+      535,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      KgslAdrenoCmdbatchSubmittedFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_KgslAdrenoCmdbatchSubmitted kKgslAdrenoCmdbatchSubmitted{};
+  template <typename T = KgslAdrenoCmdbatchSubmittedFtraceEvent> T* set_kgsl_adreno_cmdbatch_submitted() {
+    return BeginNestedMessage<T>(535);
+  }
+
+
+  using FieldMetadata_KgslAdrenoCmdbatchSync =
+    ::protozero::proto_utils::FieldMetadata<
+      536,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      KgslAdrenoCmdbatchSyncFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_KgslAdrenoCmdbatchSync kKgslAdrenoCmdbatchSync{};
+  template <typename T = KgslAdrenoCmdbatchSyncFtraceEvent> T* set_kgsl_adreno_cmdbatch_sync() {
+    return BeginNestedMessage<T>(536);
+  }
+
+
+  using FieldMetadata_KgslAdrenoCmdbatchRetired =
+    ::protozero::proto_utils::FieldMetadata<
+      537,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      KgslAdrenoCmdbatchRetiredFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_KgslAdrenoCmdbatchRetired kKgslAdrenoCmdbatchRetired{};
+  template <typename T = KgslAdrenoCmdbatchRetiredFtraceEvent> T* set_kgsl_adreno_cmdbatch_retired() {
+    return BeginNestedMessage<T>(537);
+  }
+
+
+  using FieldMetadata_PixelMmKswapdWake =
+    ::protozero::proto_utils::FieldMetadata<
+      538,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PixelMmKswapdWakeFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_PixelMmKswapdWake kPixelMmKswapdWake{};
+  template <typename T = PixelMmKswapdWakeFtraceEvent> T* set_pixel_mm_kswapd_wake() {
+    return BeginNestedMessage<T>(538);
+  }
+
+
+  using FieldMetadata_PixelMmKswapdDone =
+    ::protozero::proto_utils::FieldMetadata<
+      539,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PixelMmKswapdDoneFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_PixelMmKswapdDone kPixelMmKswapdDone{};
+  template <typename T = PixelMmKswapdDoneFtraceEvent> T* set_pixel_mm_kswapd_done() {
+    return BeginNestedMessage<T>(539);
+  }
+
+
+  using FieldMetadata_SchedWakeupTaskAttr =
+    ::protozero::proto_utils::FieldMetadata<
+      540,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SchedWakeupTaskAttrFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_SchedWakeupTaskAttr kSchedWakeupTaskAttr{};
+  template <typename T = SchedWakeupTaskAttrFtraceEvent> T* set_sched_wakeup_task_attr() {
+    return BeginNestedMessage<T>(540);
+  }
+
+
+  using FieldMetadata_DevfreqFrequency =
+    ::protozero::proto_utils::FieldMetadata<
+      541,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      DevfreqFrequencyFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_DevfreqFrequency kDevfreqFrequency{};
+  template <typename T = DevfreqFrequencyFtraceEvent> T* set_devfreq_frequency() {
+    return BeginNestedMessage<T>(541);
+  }
+
+
+  using FieldMetadata_KprobeEvent =
+    ::protozero::proto_utils::FieldMetadata<
+      542,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      KprobeEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_KprobeEvent kKprobeEvent{};
+  template <typename T = KprobeEvent> T* set_kprobe_event() {
+    return BeginNestedMessage<T>(542);
+  }
+
+
+  using FieldMetadata_ParamSetValueCpm =
+    ::protozero::proto_utils::FieldMetadata<
+      543,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ParamSetValueCpmFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_ParamSetValueCpm kParamSetValueCpm{};
+  template <typename T = ParamSetValueCpmFtraceEvent> T* set_param_set_value_cpm() {
+    return BeginNestedMessage<T>(543);
+  }
+
+
+  using FieldMetadata_DoSysOpen =
+    ::protozero::proto_utils::FieldMetadata<
+      544,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      DoSysOpenFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_DoSysOpen kDoSysOpen{};
+  template <typename T = DoSysOpenFtraceEvent> T* set_do_sys_open() {
+    return BeginNestedMessage<T>(544);
+  }
+
+
+  using FieldMetadata_OpenExec =
+    ::protozero::proto_utils::FieldMetadata<
+      545,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      OpenExecFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_OpenExec kOpenExec{};
+  template <typename T = OpenExecFtraceEvent> T* set_open_exec() {
+    return BeginNestedMessage<T>(545);
+  }
+
+
+  using FieldMetadata_BlockIoStart =
+    ::protozero::proto_utils::FieldMetadata<
+      546,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BlockIoStartFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_BlockIoStart kBlockIoStart{};
+  template <typename T = BlockIoStartFtraceEvent> T* set_block_io_start() {
+    return BeginNestedMessage<T>(546);
+  }
+
+
+  using FieldMetadata_BlockIoDone =
+    ::protozero::proto_utils::FieldMetadata<
+      547,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BlockIoDoneFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_BlockIoDone kBlockIoDone{};
+  template <typename T = BlockIoDoneFtraceEvent> T* set_block_io_done() {
+    return BeginNestedMessage<T>(547);
+  }
+
+
+  using FieldMetadata_MaliGpuPowerState =
+    ::protozero::proto_utils::FieldMetadata<
+      548,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MaliGpuPowerStateFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MaliGpuPowerState kMaliGpuPowerState{};
+  template <typename T = MaliGpuPowerStateFtraceEvent> T* set_mali_gpu_power_state() {
+    return BeginNestedMessage<T>(548);
+  }
+
+
+  using FieldMetadata_DpuDispDpuUnderrun =
+    ::protozero::proto_utils::FieldMetadata<
+      549,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      DpuDispDpuUnderrunFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_DpuDispDpuUnderrun kDpuDispDpuUnderrun{};
+  template <typename T = DpuDispDpuUnderrunFtraceEvent> T* set_dpu_disp_dpu_underrun() {
+    return BeginNestedMessage<T>(549);
+  }
+
+
+  using FieldMetadata_DpuDispVblankIrqEnable =
+    ::protozero::proto_utils::FieldMetadata<
+      550,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      DpuDispVblankIrqEnableFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_DpuDispVblankIrqEnable kDpuDispVblankIrqEnable{};
+  template <typename T = DpuDispVblankIrqEnableFtraceEvent> T* set_dpu_disp_vblank_irq_enable() {
+    return BeginNestedMessage<T>(550);
+  }
+
+
+  using FieldMetadata_HrtimerStart =
+    ::protozero::proto_utils::FieldMetadata<
+      551,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HrtimerStartFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_HrtimerStart kHrtimerStart{};
+  template <typename T = HrtimerStartFtraceEvent> T* set_hrtimer_start() {
+    return BeginNestedMessage<T>(551);
+  }
+
+
+  using FieldMetadata_HrtimerCancel =
+    ::protozero::proto_utils::FieldMetadata<
+      552,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HrtimerCancelFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_HrtimerCancel kHrtimerCancel{};
+  template <typename T = HrtimerCancelFtraceEvent> T* set_hrtimer_cancel() {
+    return BeginNestedMessage<T>(552);
+  }
+
+
+  using FieldMetadata_HrtimerExpireEntry =
+    ::protozero::proto_utils::FieldMetadata<
+      553,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HrtimerExpireEntryFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_HrtimerExpireEntry kHrtimerExpireEntry{};
+  template <typename T = HrtimerExpireEntryFtraceEvent> T* set_hrtimer_expire_entry() {
+    return BeginNestedMessage<T>(553);
+  }
+
+
+  using FieldMetadata_HrtimerExpireExit =
+    ::protozero::proto_utils::FieldMetadata<
+      554,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HrtimerExpireExitFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_HrtimerExpireExit kHrtimerExpireExit{};
+  template <typename T = HrtimerExpireExitFtraceEvent> T* set_hrtimer_expire_exit() {
+    return BeginNestedMessage<T>(554);
+  }
+
+
+  using FieldMetadata_TimerStart =
+    ::protozero::proto_utils::FieldMetadata<
+      555,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TimerStartFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_TimerStart kTimerStart{};
+  template <typename T = TimerStartFtraceEvent> T* set_timer_start() {
+    return BeginNestedMessage<T>(555);
+  }
+
+
+  using FieldMetadata_TimerCancel =
+    ::protozero::proto_utils::FieldMetadata<
+      556,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TimerCancelFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_TimerCancel kTimerCancel{};
+  template <typename T = TimerCancelFtraceEvent> T* set_timer_cancel() {
+    return BeginNestedMessage<T>(556);
+  }
+
+
+  using FieldMetadata_TimerExpireEntry =
+    ::protozero::proto_utils::FieldMetadata<
+      557,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TimerExpireEntryFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_TimerExpireEntry kTimerExpireEntry{};
+  template <typename T = TimerExpireEntryFtraceEvent> T* set_timer_expire_entry() {
+    return BeginNestedMessage<T>(557);
+  }
+
+
+  using FieldMetadata_TimerExpireExit =
+    ::protozero::proto_utils::FieldMetadata<
+      558,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TimerExpireExitFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_TimerExpireExit kTimerExpireExit{};
+  template <typename T = TimerExpireExitFtraceEvent> T* set_timer_expire_exit() {
+    return BeginNestedMessage<T>(558);
+  }
+
+
+  using FieldMetadata_LocalTimerEntry =
+    ::protozero::proto_utils::FieldMetadata<
+      559,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      LocalTimerEntryFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_LocalTimerEntry kLocalTimerEntry{};
+  template <typename T = LocalTimerEntryFtraceEvent> T* set_local_timer_entry() {
+    return BeginNestedMessage<T>(559);
+  }
+
+
+  using FieldMetadata_LocalTimerExit =
+    ::protozero::proto_utils::FieldMetadata<
+      560,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      LocalTimerExitFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_LocalTimerExit kLocalTimerExit{};
+  template <typename T = LocalTimerExitFtraceEvent> T* set_local_timer_exit() {
+    return BeginNestedMessage<T>(560);
+  }
+
+
+  using FieldMetadata_Dwc3AllocRequest =
+    ::protozero::proto_utils::FieldMetadata<
+      561,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      Dwc3AllocRequestFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_Dwc3AllocRequest kDwc3AllocRequest{};
+  template <typename T = Dwc3AllocRequestFtraceEvent> T* set_dwc3_alloc_request() {
+    return BeginNestedMessage<T>(561);
+  }
+
+
+  using FieldMetadata_Dwc3CompleteTrb =
+    ::protozero::proto_utils::FieldMetadata<
+      562,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      Dwc3CompleteTrbFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_Dwc3CompleteTrb kDwc3CompleteTrb{};
+  template <typename T = Dwc3CompleteTrbFtraceEvent> T* set_dwc3_complete_trb() {
+    return BeginNestedMessage<T>(562);
+  }
+
+
+  using FieldMetadata_Dwc3CtrlReq =
+    ::protozero::proto_utils::FieldMetadata<
+      563,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      Dwc3CtrlReqFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_Dwc3CtrlReq kDwc3CtrlReq{};
+  template <typename T = Dwc3CtrlReqFtraceEvent> T* set_dwc3_ctrl_req() {
+    return BeginNestedMessage<T>(563);
+  }
+
+
+  using FieldMetadata_Dwc3EpDequeue =
+    ::protozero::proto_utils::FieldMetadata<
+      564,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      Dwc3EpDequeueFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_Dwc3EpDequeue kDwc3EpDequeue{};
+  template <typename T = Dwc3EpDequeueFtraceEvent> T* set_dwc3_ep_dequeue() {
+    return BeginNestedMessage<T>(564);
+  }
+
+
+  using FieldMetadata_Dwc3EpQueue =
+    ::protozero::proto_utils::FieldMetadata<
+      565,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      Dwc3EpQueueFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_Dwc3EpQueue kDwc3EpQueue{};
+  template <typename T = Dwc3EpQueueFtraceEvent> T* set_dwc3_ep_queue() {
+    return BeginNestedMessage<T>(565);
+  }
+
+
+  using FieldMetadata_Dwc3Event =
+    ::protozero::proto_utils::FieldMetadata<
+      566,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      Dwc3EventFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_Dwc3Event kDwc3Event{};
+  template <typename T = Dwc3EventFtraceEvent> T* set_dwc3_event() {
+    return BeginNestedMessage<T>(566);
+  }
+
+
+  using FieldMetadata_Dwc3FreeRequest =
+    ::protozero::proto_utils::FieldMetadata<
+      567,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      Dwc3FreeRequestFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_Dwc3FreeRequest kDwc3FreeRequest{};
+  template <typename T = Dwc3FreeRequestFtraceEvent> T* set_dwc3_free_request() {
+    return BeginNestedMessage<T>(567);
+  }
+
+
+  using FieldMetadata_Dwc3GadgetEpCmd =
+    ::protozero::proto_utils::FieldMetadata<
+      568,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      Dwc3GadgetEpCmdFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_Dwc3GadgetEpCmd kDwc3GadgetEpCmd{};
+  template <typename T = Dwc3GadgetEpCmdFtraceEvent> T* set_dwc3_gadget_ep_cmd() {
+    return BeginNestedMessage<T>(568);
+  }
+
+
+  using FieldMetadata_Dwc3GadgetEpDisable =
+    ::protozero::proto_utils::FieldMetadata<
+      569,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      Dwc3GadgetEpDisableFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_Dwc3GadgetEpDisable kDwc3GadgetEpDisable{};
+  template <typename T = Dwc3GadgetEpDisableFtraceEvent> T* set_dwc3_gadget_ep_disable() {
+    return BeginNestedMessage<T>(569);
+  }
+
+
+  using FieldMetadata_Dwc3GadgetEpEnable =
+    ::protozero::proto_utils::FieldMetadata<
+      570,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      Dwc3GadgetEpEnableFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_Dwc3GadgetEpEnable kDwc3GadgetEpEnable{};
+  template <typename T = Dwc3GadgetEpEnableFtraceEvent> T* set_dwc3_gadget_ep_enable() {
+    return BeginNestedMessage<T>(570);
+  }
+
+
+  using FieldMetadata_Dwc3GadgetGenericCmd =
+    ::protozero::proto_utils::FieldMetadata<
+      571,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      Dwc3GadgetGenericCmdFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_Dwc3GadgetGenericCmd kDwc3GadgetGenericCmd{};
+  template <typename T = Dwc3GadgetGenericCmdFtraceEvent> T* set_dwc3_gadget_generic_cmd() {
+    return BeginNestedMessage<T>(571);
+  }
+
+
+  using FieldMetadata_Dwc3GadgetGiveback =
+    ::protozero::proto_utils::FieldMetadata<
+      572,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      Dwc3GadgetGivebackFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_Dwc3GadgetGiveback kDwc3GadgetGiveback{};
+  template <typename T = Dwc3GadgetGivebackFtraceEvent> T* set_dwc3_gadget_giveback() {
+    return BeginNestedMessage<T>(572);
+  }
+
+
+  using FieldMetadata_Dwc3PrepareTrb =
+    ::protozero::proto_utils::FieldMetadata<
+      573,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      Dwc3PrepareTrbFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_Dwc3PrepareTrb kDwc3PrepareTrb{};
+  template <typename T = Dwc3PrepareTrbFtraceEvent> T* set_dwc3_prepare_trb() {
+    return BeginNestedMessage<T>(573);
+  }
+
+
+  using FieldMetadata_Dwc3Readl =
+    ::protozero::proto_utils::FieldMetadata<
+      574,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      Dwc3ReadlFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_Dwc3Readl kDwc3Readl{};
+  template <typename T = Dwc3ReadlFtraceEvent> T* set_dwc3_readl() {
+    return BeginNestedMessage<T>(574);
+  }
+
+
+  using FieldMetadata_Dwc3Writel =
+    ::protozero::proto_utils::FieldMetadata<
+      575,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      Dwc3WritelFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_Dwc3Writel kDwc3Writel{};
+  template <typename T = Dwc3WritelFtraceEvent> T* set_dwc3_writel() {
+    return BeginNestedMessage<T>(575);
+  }
+
+
+  using FieldMetadata_CmaAllocFinish =
+    ::protozero::proto_utils::FieldMetadata<
+      576,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      CmaAllocFinishFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_CmaAllocFinish kCmaAllocFinish{};
+  template <typename T = CmaAllocFinishFtraceEvent> T* set_cma_alloc_finish() {
+    return BeginNestedMessage<T>(576);
+  }
+
+
+  using FieldMetadata_MmAllocContigMigrateRangeInfo =
+    ::protozero::proto_utils::FieldMetadata<
+      577,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MmAllocContigMigrateRangeInfoFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_MmAllocContigMigrateRangeInfo kMmAllocContigMigrateRangeInfo{};
+  template <typename T = MmAllocContigMigrateRangeInfoFtraceEvent> T* set_mm_alloc_contig_migrate_range_info() {
+    return BeginNestedMessage<T>(577);
+  }
+
+
+  using FieldMetadata_HostFfaCall =
+    ::protozero::proto_utils::FieldMetadata<
+      578,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HostFfaCallFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_HostFfaCall kHostFfaCall{};
+  template <typename T = HostFfaCallFtraceEvent> T* set_host_ffa_call() {
+    return BeginNestedMessage<T>(578);
+  }
+
+
+  using FieldMetadata_DmabufRssStat =
+    ::protozero::proto_utils::FieldMetadata<
+      579,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      DmabufRssStatFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_DmabufRssStat kDmabufRssStat{};
+  template <typename T = DmabufRssStatFtraceEvent> T* set_dmabuf_rss_stat() {
+    return BeginNestedMessage<T>(579);
+  }
+
+
+  using FieldMetadata_IommuIdmap =
+    ::protozero::proto_utils::FieldMetadata<
+      580,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      IommuIdmapFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_IommuIdmap kIommuIdmap{};
+  template <typename T = IommuIdmapFtraceEvent> T* set_iommu_idmap() {
+    return BeginNestedMessage<T>(580);
+  }
+
+
+  using FieldMetadata_PsciMemProtect =
+    ::protozero::proto_utils::FieldMetadata<
+      581,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PsciMemProtectFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_PsciMemProtect kPsciMemProtect{};
+  template <typename T = PsciMemProtectFtraceEvent> T* set_psci_mem_protect() {
+    return BeginNestedMessage<T>(581);
+  }
+
+
+  using FieldMetadata_HypervisorHostHcall =
+    ::protozero::proto_utils::FieldMetadata<
+      582,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HypervisorHostHcallFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_HypervisorHostHcall kHypervisorHostHcall{};
+  template <typename T = HypervisorHostHcallFtraceEvent> T* set_hypervisor_host_hcall() {
+    return BeginNestedMessage<T>(582);
+  }
+
+
+  using FieldMetadata_HypervisorHostSmc =
+    ::protozero::proto_utils::FieldMetadata<
+      583,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HypervisorHostSmcFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_HypervisorHostSmc kHypervisorHostSmc{};
+  template <typename T = HypervisorHostSmcFtraceEvent> T* set_hypervisor_host_smc() {
+    return BeginNestedMessage<T>(583);
+  }
+
+
+  using FieldMetadata_HypervisorHypExit =
+    ::protozero::proto_utils::FieldMetadata<
+      584,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HypervisorHypExitFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_HypervisorHypExit kHypervisorHypExit{};
+  template <typename T = HypervisorHypExitFtraceEvent> T* set_hypervisor_hyp_exit() {
+    return BeginNestedMessage<T>(584);
+  }
+
+
+  using FieldMetadata_HypervisorIommuIdmap =
+    ::protozero::proto_utils::FieldMetadata<
+      585,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HypervisorIommuIdmapFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_HypervisorIommuIdmap kHypervisorIommuIdmap{};
+  template <typename T = HypervisorIommuIdmapFtraceEvent> T* set_hypervisor_iommu_idmap() {
+    return BeginNestedMessage<T>(585);
+  }
+
+
+  using FieldMetadata_HypervisorPsciMemProtect =
+    ::protozero::proto_utils::FieldMetadata<
+      586,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HypervisorPsciMemProtectFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_HypervisorPsciMemProtect kHypervisorPsciMemProtect{};
+  template <typename T = HypervisorPsciMemProtectFtraceEvent> T* set_hypervisor_psci_mem_protect() {
+    return BeginNestedMessage<T>(586);
+  }
+
+
+  using FieldMetadata_HypervisorHostMemAbort =
+    ::protozero::proto_utils::FieldMetadata<
+      587,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HypervisorHostMemAbortFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_HypervisorHostMemAbort kHypervisorHostMemAbort{};
+  template <typename T = HypervisorHostMemAbortFtraceEvent> T* set_hypervisor_host_mem_abort() {
+    return BeginNestedMessage<T>(587);
+  }
+
+
+  using FieldMetadata_HypervisorHypEnter =
+    ::protozero::proto_utils::FieldMetadata<
+      588,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HypervisorHypEnterFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_HypervisorHypEnter kHypervisorHypEnter{};
+  template <typename T = HypervisorHypEnterFtraceEvent> T* set_hypervisor_hyp_enter() {
+    return BeginNestedMessage<T>(588);
+  }
+
+
+  using FieldMetadata_HypervisorIommuIdmapComplete =
+    ::protozero::proto_utils::FieldMetadata<
+      589,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HypervisorIommuIdmapCompleteFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_HypervisorIommuIdmapComplete kHypervisorIommuIdmapComplete{};
+  template <typename T = HypervisorIommuIdmapCompleteFtraceEvent> T* set_hypervisor_iommu_idmap_complete() {
+    return BeginNestedMessage<T>(589);
+  }
+
+
+  using FieldMetadata_HypervisorVcpuIllegalTrap =
+    ::protozero::proto_utils::FieldMetadata<
+      590,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HypervisorVcpuIllegalTrapFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_HypervisorVcpuIllegalTrap kHypervisorVcpuIllegalTrap{};
+  template <typename T = HypervisorVcpuIllegalTrapFtraceEvent> T* set_hypervisor_vcpu_illegal_trap() {
+    return BeginNestedMessage<T>(590);
+  }
+
+
+  using FieldMetadata_DrmSchedJobAddDep =
+    ::protozero::proto_utils::FieldMetadata<
+      591,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      DrmSchedJobAddDepFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_DrmSchedJobAddDep kDrmSchedJobAddDep{};
+  template <typename T = DrmSchedJobAddDepFtraceEvent> T* set_drm_sched_job_add_dep() {
+    return BeginNestedMessage<T>(591);
+  }
+
+
+  using FieldMetadata_DrmSchedJobDone =
+    ::protozero::proto_utils::FieldMetadata<
+      592,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      DrmSchedJobDoneFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_DrmSchedJobDone kDrmSchedJobDone{};
+  template <typename T = DrmSchedJobDoneFtraceEvent> T* set_drm_sched_job_done() {
+    return BeginNestedMessage<T>(592);
+  }
+
+
+  using FieldMetadata_DrmSchedJobQueue =
+    ::protozero::proto_utils::FieldMetadata<
+      593,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      DrmSchedJobQueueFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_DrmSchedJobQueue kDrmSchedJobQueue{};
+  template <typename T = DrmSchedJobQueueFtraceEvent> T* set_drm_sched_job_queue() {
+    return BeginNestedMessage<T>(593);
+  }
+
+
+  using FieldMetadata_DrmSchedJobRun =
+    ::protozero::proto_utils::FieldMetadata<
+      594,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      DrmSchedJobRunFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_DrmSchedJobRun kDrmSchedJobRun{};
+  template <typename T = DrmSchedJobRunFtraceEvent> T* set_drm_sched_job_run() {
+    return BeginNestedMessage<T>(594);
+  }
+
+
+  using FieldMetadata_DrmSchedJobUnschedulable =
+    ::protozero::proto_utils::FieldMetadata<
+      595,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      DrmSchedJobUnschedulableFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_DrmSchedJobUnschedulable kDrmSchedJobUnschedulable{};
+  template <typename T = DrmSchedJobUnschedulableFtraceEvent> T* set_drm_sched_job_unschedulable() {
+    return BeginNestedMessage<T>(595);
+  }
+
+
+  using FieldMetadata_FwtpPerfettoCounter =
+    ::protozero::proto_utils::FieldMetadata<
+      596,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FwtpPerfettoCounterFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_FwtpPerfettoCounter kFwtpPerfettoCounter{};
+  template <typename T = FwtpPerfettoCounterFtraceEvent> T* set_fwtp_perfetto_counter() {
+    return BeginNestedMessage<T>(596);
+  }
+
+
+  using FieldMetadata_ScsiDispatchCmdError =
+    ::protozero::proto_utils::FieldMetadata<
+      597,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ScsiDispatchCmdErrorFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_ScsiDispatchCmdError kScsiDispatchCmdError{};
+  template <typename T = ScsiDispatchCmdErrorFtraceEvent> T* set_scsi_dispatch_cmd_error() {
+    return BeginNestedMessage<T>(597);
+  }
+
+
+  using FieldMetadata_ScsiDispatchCmdTimeout =
+    ::protozero::proto_utils::FieldMetadata<
+      598,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ScsiDispatchCmdTimeoutFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_ScsiDispatchCmdTimeout kScsiDispatchCmdTimeout{};
+  template <typename T = ScsiDispatchCmdTimeoutFtraceEvent> T* set_scsi_dispatch_cmd_timeout() {
+    return BeginNestedMessage<T>(598);
+  }
+
+
+  using FieldMetadata_ScsiEhWakeup =
+    ::protozero::proto_utils::FieldMetadata<
+      599,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ScsiEhWakeupFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_ScsiEhWakeup kScsiEhWakeup{};
+  template <typename T = ScsiEhWakeupFtraceEvent> T* set_scsi_eh_wakeup() {
+    return BeginNestedMessage<T>(599);
+  }
+
+
+  using FieldMetadata_FwtpPerfettoSlice =
+    ::protozero::proto_utils::FieldMetadata<
+      600,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FwtpPerfettoSliceFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_FwtpPerfettoSlice kFwtpPerfettoSlice{};
+  template <typename T = FwtpPerfettoSliceFtraceEvent> T* set_fwtp_perfetto_slice() {
+    return BeginNestedMessage<T>(600);
+  }
+
+
+  using FieldMetadata_GpuPowerState =
+    ::protozero::proto_utils::FieldMetadata<
+      601,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      GpuPowerStateFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_GpuPowerState kGpuPowerState{};
+  template <typename T = GpuPowerStateFtraceEvent> T* set_gpu_power_state() {
+    return BeginNestedMessage<T>(601);
+  }
+
+
+  using FieldMetadata_GramCollision =
+    ::protozero::proto_utils::FieldMetadata<
+      602,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      GramCollisionFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_GramCollision kGramCollision{};
+  template <typename T = GramCollisionFtraceEvent> T* set_gram_collision() {
+    return BeginNestedMessage<T>(602);
+  }
+
 };
 
 } // Namespace.
@@ -64228,10 +97884,19 @@ class FtraceEvent : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
-
 class FtraceEvent;
 class FtraceEventBundle_CompactSched;
+class FtraceEventBundle_FtraceError;
+class FtraceEventBundle_GenericEventDescriptor;
 enum FtraceClock : int32_t;
+enum FtraceParseStatus : int32_t;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
 enum FtraceClock : int32_t {
   FTRACE_CLOCK_UNSPECIFIED = 0,
@@ -64266,7 +97931,7 @@ const char* FtraceClock_Name(::perfetto::protos::pbzero::FtraceClock value) {
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-class FtraceEventBundle_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class FtraceEventBundle_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/512> {
  public:
   FtraceEventBundle_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit FtraceEventBundle_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -64285,6 +97950,16 @@ class FtraceEventBundle_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FI
   int64_t ftrace_timestamp() const { return at<6>().as_int64(); }
   bool has_boot_timestamp() const { return at<7>().valid(); }
   int64_t boot_timestamp() const { return at<7>().as_int64(); }
+  bool has_error() const { return at<8>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> error() const { return GetRepeated<::protozero::ConstBytes>(8); }
+  bool has_last_read_event_timestamp() const { return at<9>().valid(); }
+  uint64_t last_read_event_timestamp() const { return at<9>().as_uint64(); }
+  bool has_previous_bundle_end_timestamp() const { return at<10>().valid(); }
+  uint64_t previous_bundle_end_timestamp() const { return at<10>().as_uint64(); }
+  bool has_generic_event_descriptors() const { return at<11>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> generic_event_descriptors() const { return GetRepeated<::protozero::ConstBytes>(11); }
+  bool has_broken_abi_trace_page() const { return at<512>().valid(); }
+  ::protozero::ConstBytes broken_abi_trace_page() const { return at<512>().as_bytes(); }
 };
 
 class FtraceEventBundle : public ::protozero::Message {
@@ -64298,10 +97973,17 @@ class FtraceEventBundle : public ::protozero::Message {
     kFtraceClockFieldNumber = 5,
     kFtraceTimestampFieldNumber = 6,
     kBootTimestampFieldNumber = 7,
+    kErrorFieldNumber = 8,
+    kLastReadEventTimestampFieldNumber = 9,
+    kPreviousBundleEndTimestampFieldNumber = 10,
+    kGenericEventDescriptorsFieldNumber = 11,
+    kBrokenAbiTracePageFieldNumber = 512,
   };
   static constexpr const char* GetName() { return ".perfetto.protos.FtraceEventBundle"; }
 
   using CompactSched = ::perfetto::protos::pbzero::FtraceEventBundle_CompactSched;
+  using FtraceError = ::perfetto::protos::pbzero::FtraceEventBundle_FtraceError;
+  using GenericEventDescriptor = ::perfetto::protos::pbzero::FtraceEventBundle_GenericEventDescriptor;
 
   using FieldMetadata_Cpu =
     ::protozero::proto_utils::FieldMetadata<
@@ -64311,14 +97993,7 @@ class FtraceEventBundle : public ::protozero::Message {
       uint32_t,
       FtraceEventBundle>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cpu kCpu() { return {}; }
+  static constexpr FieldMetadata_Cpu kCpu{};
   void set_cpu(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -64336,14 +98011,7 @@ class FtraceEventBundle : public ::protozero::Message {
       FtraceEvent,
       FtraceEventBundle>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Event kEvent() { return {}; }
+  static constexpr FieldMetadata_Event kEvent{};
   template <typename T = FtraceEvent> T* add_event() {
     return BeginNestedMessage<T>(2);
   }
@@ -64357,14 +98025,7 @@ class FtraceEventBundle : public ::protozero::Message {
       bool,
       FtraceEventBundle>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LostEvents kLostEvents() { return {}; }
+  static constexpr FieldMetadata_LostEvents kLostEvents{};
   void set_lost_events(bool value) {
     static constexpr uint32_t field_id = FieldMetadata_LostEvents::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -64382,14 +98043,7 @@ class FtraceEventBundle : public ::protozero::Message {
       FtraceEventBundle_CompactSched,
       FtraceEventBundle>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CompactSched kCompactSched() { return {}; }
+  static constexpr FieldMetadata_CompactSched kCompactSched{};
   template <typename T = FtraceEventBundle_CompactSched> T* set_compact_sched() {
     return BeginNestedMessage<T>(4);
   }
@@ -64400,18 +98054,11 @@ class FtraceEventBundle : public ::protozero::Message {
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::FtraceClock,
+      FtraceClock,
       FtraceEventBundle>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FtraceClock kFtraceClock() { return {}; }
-  void set_ftrace_clock(::perfetto::protos::pbzero::FtraceClock value) {
+  static constexpr FieldMetadata_FtraceClock kFtraceClock{};
+  void set_ftrace_clock(FtraceClock value) {
     static constexpr uint32_t field_id = FieldMetadata_FtraceClock::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
@@ -64428,14 +98075,7 @@ class FtraceEventBundle : public ::protozero::Message {
       int64_t,
       FtraceEventBundle>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FtraceTimestamp kFtraceTimestamp() { return {}; }
+  static constexpr FieldMetadata_FtraceTimestamp kFtraceTimestamp{};
   void set_ftrace_timestamp(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_FtraceTimestamp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -64453,14 +98093,7 @@ class FtraceEventBundle : public ::protozero::Message {
       int64_t,
       FtraceEventBundle>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BootTimestamp kBootTimestamp() { return {}; }
+  static constexpr FieldMetadata_BootTimestamp kBootTimestamp{};
   void set_boot_timestamp(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_BootTimestamp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -64469,9 +98102,246 @@ class FtraceEventBundle : public ::protozero::Message {
       ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_Error =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FtraceEventBundle_FtraceError,
+      FtraceEventBundle>;
+
+  static constexpr FieldMetadata_Error kError{};
+  template <typename T = FtraceEventBundle_FtraceError> T* add_error() {
+    return BeginNestedMessage<T>(8);
+  }
+
+
+  using FieldMetadata_LastReadEventTimestamp =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FtraceEventBundle>;
+
+  static constexpr FieldMetadata_LastReadEventTimestamp kLastReadEventTimestamp{};
+  void set_last_read_event_timestamp(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LastReadEventTimestamp::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PreviousBundleEndTimestamp =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FtraceEventBundle>;
+
+  static constexpr FieldMetadata_PreviousBundleEndTimestamp kPreviousBundleEndTimestamp{};
+  void set_previous_bundle_end_timestamp(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PreviousBundleEndTimestamp::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_GenericEventDescriptors =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FtraceEventBundle_GenericEventDescriptor,
+      FtraceEventBundle>;
+
+  static constexpr FieldMetadata_GenericEventDescriptors kGenericEventDescriptors{};
+  template <typename T = FtraceEventBundle_GenericEventDescriptor> T* add_generic_event_descriptors() {
+    return BeginNestedMessage<T>(11);
+  }
+
+
+  using FieldMetadata_BrokenAbiTracePage =
+    ::protozero::proto_utils::FieldMetadata<
+      512,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      FtraceEventBundle>;
+
+  static constexpr FieldMetadata_BrokenAbiTracePage kBrokenAbiTracePage{};
+  void set_broken_abi_trace_page(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_BrokenAbiTracePage::kFieldId, data, size);
+  }
+  void set_broken_abi_trace_page(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_BrokenAbiTracePage::kFieldId, bytes.data, bytes.size);
+  }
+  void set_broken_abi_trace_page(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_BrokenAbiTracePage::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class FtraceEventBundle_GenericEventDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  FtraceEventBundle_GenericEventDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FtraceEventBundle_GenericEventDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FtraceEventBundle_GenericEventDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_field_id() const { return at<1>().valid(); }
+  int32_t field_id() const { return at<1>().as_int32(); }
+  bool has_group_name() const { return at<3>().valid(); }
+  ::protozero::ConstChars group_name() const { return at<3>().as_string(); }
+  bool has_event_descriptor() const { return at<2>().valid(); }
+  ::protozero::ConstBytes event_descriptor() const { return at<2>().as_bytes(); }
+};
+
+class FtraceEventBundle_GenericEventDescriptor : public ::protozero::Message {
+ public:
+  using Decoder = FtraceEventBundle_GenericEventDescriptor_Decoder;
+  enum : int32_t {
+    kFieldIdFieldNumber = 1,
+    kGroupNameFieldNumber = 3,
+    kEventDescriptorFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FtraceEventBundle.GenericEventDescriptor"; }
+
+
+  using FieldMetadata_FieldId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      FtraceEventBundle_GenericEventDescriptor>;
+
+  static constexpr FieldMetadata_FieldId kFieldId{};
+  void set_field_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FieldId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_GroupName =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FtraceEventBundle_GenericEventDescriptor>;
+
+  static constexpr FieldMetadata_GroupName kGroupName{};
+  void set_group_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_GroupName::kFieldId, data, size);
+  }
+  void set_group_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_GroupName::kFieldId, chars.data, chars.size);
+  }
+  void set_group_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_GroupName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_EventDescriptor =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      FtraceEventBundle_GenericEventDescriptor>;
+
+  static constexpr FieldMetadata_EventDescriptor kEventDescriptor{};
+  void set_event_descriptor(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_EventDescriptor::kFieldId, data, size);
+  }
+  void set_event_descriptor(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_EventDescriptor::kFieldId, bytes.data, bytes.size);
+  }
+  void set_event_descriptor(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_EventDescriptor::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class FtraceEventBundle_FtraceError_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  FtraceEventBundle_FtraceError_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FtraceEventBundle_FtraceError_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FtraceEventBundle_FtraceError_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_timestamp() const { return at<1>().valid(); }
+  uint64_t timestamp() const { return at<1>().as_uint64(); }
+  bool has_status() const { return at<2>().valid(); }
+  int32_t status() const { return at<2>().as_int32(); }
+};
+
+class FtraceEventBundle_FtraceError : public ::protozero::Message {
+ public:
+  using Decoder = FtraceEventBundle_FtraceError_Decoder;
+  enum : int32_t {
+    kTimestampFieldNumber = 1,
+    kStatusFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FtraceEventBundle.FtraceError"; }
+
+
+  using FieldMetadata_Timestamp =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FtraceEventBundle_FtraceError>;
+
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Status =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      FtraceParseStatus,
+      FtraceEventBundle_FtraceError>;
+
+  static constexpr FieldMetadata_Status kStatus{};
+  void set_status(FtraceParseStatus value) {
+    static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class FtraceEventBundle_CompactSched_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class FtraceEventBundle_CompactSched_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/12> {
  public:
   FtraceEventBundle_CompactSched_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit FtraceEventBundle_CompactSched_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -64498,6 +98368,8 @@ class FtraceEventBundle_CompactSched_Decoder : public ::protozero::TypedProtoDec
   ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t> waking_prio(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t>(10, parse_error_ptr); }
   bool has_waking_comm_index() const { return at<11>().valid(); }
   ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t> waking_comm_index(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t>(11, parse_error_ptr); }
+  bool has_waking_common_flags() const { return at<12>().valid(); }
+  ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t> waking_common_flags(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t>(12, parse_error_ptr); }
 };
 
 class FtraceEventBundle_CompactSched : public ::protozero::Message {
@@ -64515,6 +98387,7 @@ class FtraceEventBundle_CompactSched : public ::protozero::Message {
     kWakingTargetCpuFieldNumber = 9,
     kWakingPrioFieldNumber = 10,
     kWakingCommIndexFieldNumber = 11,
+    kWakingCommonFlagsFieldNumber = 12,
   };
   static constexpr const char* GetName() { return ".perfetto.protos.FtraceEventBundle.CompactSched"; }
 
@@ -64527,14 +98400,7 @@ class FtraceEventBundle_CompactSched : public ::protozero::Message {
       std::string,
       FtraceEventBundle_CompactSched>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InternTable kInternTable() { return {}; }
+  static constexpr FieldMetadata_InternTable kInternTable{};
   void add_intern_table(const char* data, size_t size) {
     AppendBytes(FieldMetadata_InternTable::kFieldId, data, size);
   }
@@ -64558,14 +98424,7 @@ class FtraceEventBundle_CompactSched : public ::protozero::Message {
       uint64_t,
       FtraceEventBundle_CompactSched>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SwitchTimestamp kSwitchTimestamp() { return {}; }
+  static constexpr FieldMetadata_SwitchTimestamp kSwitchTimestamp{};
   void set_switch_timestamp(const ::protozero::PackedVarInt& packed_buffer) {
     AppendBytes(FieldMetadata_SwitchTimestamp::kFieldId, packed_buffer.data(),
                 packed_buffer.size());
@@ -64579,14 +98438,7 @@ class FtraceEventBundle_CompactSched : public ::protozero::Message {
       int64_t,
       FtraceEventBundle_CompactSched>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SwitchPrevState kSwitchPrevState() { return {}; }
+  static constexpr FieldMetadata_SwitchPrevState kSwitchPrevState{};
   void set_switch_prev_state(const ::protozero::PackedVarInt& packed_buffer) {
     AppendBytes(FieldMetadata_SwitchPrevState::kFieldId, packed_buffer.data(),
                 packed_buffer.size());
@@ -64600,14 +98452,7 @@ class FtraceEventBundle_CompactSched : public ::protozero::Message {
       int32_t,
       FtraceEventBundle_CompactSched>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SwitchNextPid kSwitchNextPid() { return {}; }
+  static constexpr FieldMetadata_SwitchNextPid kSwitchNextPid{};
   void set_switch_next_pid(const ::protozero::PackedVarInt& packed_buffer) {
     AppendBytes(FieldMetadata_SwitchNextPid::kFieldId, packed_buffer.data(),
                 packed_buffer.size());
@@ -64621,14 +98466,7 @@ class FtraceEventBundle_CompactSched : public ::protozero::Message {
       int32_t,
       FtraceEventBundle_CompactSched>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SwitchNextPrio kSwitchNextPrio() { return {}; }
+  static constexpr FieldMetadata_SwitchNextPrio kSwitchNextPrio{};
   void set_switch_next_prio(const ::protozero::PackedVarInt& packed_buffer) {
     AppendBytes(FieldMetadata_SwitchNextPrio::kFieldId, packed_buffer.data(),
                 packed_buffer.size());
@@ -64642,14 +98480,7 @@ class FtraceEventBundle_CompactSched : public ::protozero::Message {
       uint32_t,
       FtraceEventBundle_CompactSched>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SwitchNextCommIndex kSwitchNextCommIndex() { return {}; }
+  static constexpr FieldMetadata_SwitchNextCommIndex kSwitchNextCommIndex{};
   void set_switch_next_comm_index(const ::protozero::PackedVarInt& packed_buffer) {
     AppendBytes(FieldMetadata_SwitchNextCommIndex::kFieldId, packed_buffer.data(),
                 packed_buffer.size());
@@ -64663,14 +98494,7 @@ class FtraceEventBundle_CompactSched : public ::protozero::Message {
       uint64_t,
       FtraceEventBundle_CompactSched>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WakingTimestamp kWakingTimestamp() { return {}; }
+  static constexpr FieldMetadata_WakingTimestamp kWakingTimestamp{};
   void set_waking_timestamp(const ::protozero::PackedVarInt& packed_buffer) {
     AppendBytes(FieldMetadata_WakingTimestamp::kFieldId, packed_buffer.data(),
                 packed_buffer.size());
@@ -64684,14 +98508,7 @@ class FtraceEventBundle_CompactSched : public ::protozero::Message {
       int32_t,
       FtraceEventBundle_CompactSched>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WakingPid kWakingPid() { return {}; }
+  static constexpr FieldMetadata_WakingPid kWakingPid{};
   void set_waking_pid(const ::protozero::PackedVarInt& packed_buffer) {
     AppendBytes(FieldMetadata_WakingPid::kFieldId, packed_buffer.data(),
                 packed_buffer.size());
@@ -64705,14 +98522,7 @@ class FtraceEventBundle_CompactSched : public ::protozero::Message {
       int32_t,
       FtraceEventBundle_CompactSched>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WakingTargetCpu kWakingTargetCpu() { return {}; }
+  static constexpr FieldMetadata_WakingTargetCpu kWakingTargetCpu{};
   void set_waking_target_cpu(const ::protozero::PackedVarInt& packed_buffer) {
     AppendBytes(FieldMetadata_WakingTargetCpu::kFieldId, packed_buffer.data(),
                 packed_buffer.size());
@@ -64726,14 +98536,7 @@ class FtraceEventBundle_CompactSched : public ::protozero::Message {
       int32_t,
       FtraceEventBundle_CompactSched>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WakingPrio kWakingPrio() { return {}; }
+  static constexpr FieldMetadata_WakingPrio kWakingPrio{};
   void set_waking_prio(const ::protozero::PackedVarInt& packed_buffer) {
     AppendBytes(FieldMetadata_WakingPrio::kFieldId, packed_buffer.data(),
                 packed_buffer.size());
@@ -64747,18 +98550,25 @@ class FtraceEventBundle_CompactSched : public ::protozero::Message {
       uint32_t,
       FtraceEventBundle_CompactSched>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WakingCommIndex kWakingCommIndex() { return {}; }
+  static constexpr FieldMetadata_WakingCommIndex kWakingCommIndex{};
   void set_waking_comm_index(const ::protozero::PackedVarInt& packed_buffer) {
     AppendBytes(FieldMetadata_WakingCommIndex::kFieldId, packed_buffer.data(),
                 packed_buffer.size());
   }
+
+  using FieldMetadata_WakingCommonFlags =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FtraceEventBundle_CompactSched>;
+
+  static constexpr FieldMetadata_WakingCommonFlags kWakingCommonFlags{};
+  void set_waking_common_flags(const ::protozero::PackedVarInt& packed_buffer) {
+    AppendBytes(FieldMetadata_WakingCommonFlags::kFieldId, packed_buffer.data(),
+                packed_buffer.size());
+  }
 };
 
 } // Namespace.
@@ -64783,12 +98593,105 @@ class FtraceEventBundle_CompactSched : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
-
 class FtraceCpuStats;
+class FtraceKprobeStats;
+enum FtraceParseStatus : int32_t;
 namespace perfetto_pbzero_enum_FtraceStats {
 enum Phase : int32_t;
 }  // namespace perfetto_pbzero_enum_FtraceStats
 using FtraceStats_Phase = perfetto_pbzero_enum_FtraceStats::Phase;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+enum FtraceParseStatus : int32_t {
+  FTRACE_STATUS_UNSPECIFIED = 0,
+  FTRACE_STATUS_OK = 1,
+  FTRACE_STATUS_UNEXPECTED_READ_ERROR = 2,
+  FTRACE_STATUS_PARTIAL_PAGE_READ = 3,
+  FTRACE_STATUS_ABI_INVALID_PAGE_HEADER = 4,
+  FTRACE_STATUS_ABI_SHORT_EVENT_HEADER = 5,
+  FTRACE_STATUS_ABI_NULL_PADDING = 6,
+  FTRACE_STATUS_ABI_SHORT_PADDING_LENGTH = 7,
+  FTRACE_STATUS_ABI_INVALID_PADDING_LENGTH = 8,
+  FTRACE_STATUS_ABI_SHORT_TIME_EXTEND = 9,
+  FTRACE_STATUS_ABI_SHORT_TIME_STAMP = 10,
+  FTRACE_STATUS_ABI_SHORT_DATA_LENGTH = 11,
+  FTRACE_STATUS_ABI_ZERO_DATA_LENGTH = 12,
+  FTRACE_STATUS_ABI_INVALID_DATA_LENGTH = 13,
+  FTRACE_STATUS_ABI_SHORT_EVENT_ID = 14,
+  FTRACE_STATUS_ABI_END_OVERFLOW = 15,
+  FTRACE_STATUS_SHORT_COMPACT_EVENT = 16,
+  FTRACE_STATUS_INVALID_EVENT = 17,
+};
+
+constexpr FtraceParseStatus FtraceParseStatus_MIN = FtraceParseStatus::FTRACE_STATUS_UNSPECIFIED;
+constexpr FtraceParseStatus FtraceParseStatus_MAX = FtraceParseStatus::FTRACE_STATUS_INVALID_EVENT;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* FtraceParseStatus_Name(::perfetto::protos::pbzero::FtraceParseStatus value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_UNSPECIFIED:
+    return "FTRACE_STATUS_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_OK:
+    return "FTRACE_STATUS_OK";
+
+  case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_UNEXPECTED_READ_ERROR:
+    return "FTRACE_STATUS_UNEXPECTED_READ_ERROR";
+
+  case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_PARTIAL_PAGE_READ:
+    return "FTRACE_STATUS_PARTIAL_PAGE_READ";
+
+  case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_INVALID_PAGE_HEADER:
+    return "FTRACE_STATUS_ABI_INVALID_PAGE_HEADER";
+
+  case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_SHORT_EVENT_HEADER:
+    return "FTRACE_STATUS_ABI_SHORT_EVENT_HEADER";
+
+  case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_NULL_PADDING:
+    return "FTRACE_STATUS_ABI_NULL_PADDING";
+
+  case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_SHORT_PADDING_LENGTH:
+    return "FTRACE_STATUS_ABI_SHORT_PADDING_LENGTH";
+
+  case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_INVALID_PADDING_LENGTH:
+    return "FTRACE_STATUS_ABI_INVALID_PADDING_LENGTH";
+
+  case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_SHORT_TIME_EXTEND:
+    return "FTRACE_STATUS_ABI_SHORT_TIME_EXTEND";
+
+  case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_SHORT_TIME_STAMP:
+    return "FTRACE_STATUS_ABI_SHORT_TIME_STAMP";
+
+  case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_SHORT_DATA_LENGTH:
+    return "FTRACE_STATUS_ABI_SHORT_DATA_LENGTH";
+
+  case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_ZERO_DATA_LENGTH:
+    return "FTRACE_STATUS_ABI_ZERO_DATA_LENGTH";
+
+  case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_INVALID_DATA_LENGTH:
+    return "FTRACE_STATUS_ABI_INVALID_DATA_LENGTH";
+
+  case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_SHORT_EVENT_ID:
+    return "FTRACE_STATUS_ABI_SHORT_EVENT_ID";
+
+  case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_END_OVERFLOW:
+    return "FTRACE_STATUS_ABI_END_OVERFLOW";
+
+  case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_SHORT_COMPACT_EVENT:
+    return "FTRACE_STATUS_SHORT_COMPACT_EVENT";
+
+  case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_INVALID_EVENT:
+    return "FTRACE_STATUS_INVALID_EVENT";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
 namespace perfetto_pbzero_enum_FtraceStats {
 enum Phase : int32_t {
@@ -64819,7 +98722,7 @@ const char* FtraceStats_Phase_Name(::perfetto::protos::pbzero::FtraceStats_Phase
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-class FtraceStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class FtraceStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/13> {
  public:
   FtraceStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit FtraceStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -64834,12 +98737,22 @@ class FtraceStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID
   uint32_t kernel_symbols_mem_kb() const { return at<4>().as_uint32(); }
   bool has_atrace_errors() const { return at<5>().valid(); }
   ::protozero::ConstChars atrace_errors() const { return at<5>().as_string(); }
+  bool has_exclusive_feature_error() const { return at<13>().valid(); }
+  ::protozero::ConstChars exclusive_feature_error() const { return at<13>().as_string(); }
   bool has_unknown_ftrace_events() const { return at<6>().valid(); }
   ::protozero::RepeatedFieldIterator<::protozero::ConstChars> unknown_ftrace_events() const { return GetRepeated<::protozero::ConstChars>(6); }
   bool has_failed_ftrace_events() const { return at<7>().valid(); }
   ::protozero::RepeatedFieldIterator<::protozero::ConstChars> failed_ftrace_events() const { return GetRepeated<::protozero::ConstChars>(7); }
   bool has_preserve_ftrace_buffer() const { return at<8>().valid(); }
   bool preserve_ftrace_buffer() const { return at<8>().as_bool(); }
+  bool has_ftrace_parse_errors() const { return at<9>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> ftrace_parse_errors() const { return GetRepeated<int32_t>(9); }
+  bool has_kprobe_stats() const { return at<10>().valid(); }
+  ::protozero::ConstBytes kprobe_stats() const { return at<10>().as_bytes(); }
+  bool has_cpu_buffer_size_pages() const { return at<11>().valid(); }
+  uint32_t cpu_buffer_size_pages() const { return at<11>().as_uint32(); }
+  bool has_cached_cpu_buffer_size_pages() const { return at<12>().valid(); }
+  uint32_t cached_cpu_buffer_size_pages() const { return at<12>().as_uint32(); }
 };
 
 class FtraceStats : public ::protozero::Message {
@@ -64851,9 +98764,14 @@ class FtraceStats : public ::protozero::Message {
     kKernelSymbolsParsedFieldNumber = 3,
     kKernelSymbolsMemKbFieldNumber = 4,
     kAtraceErrorsFieldNumber = 5,
+    kExclusiveFeatureErrorFieldNumber = 13,
     kUnknownFtraceEventsFieldNumber = 6,
     kFailedFtraceEventsFieldNumber = 7,
     kPreserveFtraceBufferFieldNumber = 8,
+    kFtraceParseErrorsFieldNumber = 9,
+    kKprobeStatsFieldNumber = 10,
+    kCpuBufferSizePagesFieldNumber = 11,
+    kCachedCpuBufferSizePagesFieldNumber = 12,
   };
   static constexpr const char* GetName() { return ".perfetto.protos.FtraceStats"; }
 
@@ -64862,27 +98780,20 @@ class FtraceStats : public ::protozero::Message {
   static inline const char* Phase_Name(Phase value) {
     return ::perfetto::protos::pbzero::FtraceStats_Phase_Name(value);
   }
-  static const Phase UNSPECIFIED = Phase::UNSPECIFIED;
-  static const Phase START_OF_TRACE = Phase::START_OF_TRACE;
-  static const Phase END_OF_TRACE = Phase::END_OF_TRACE;
+  static inline const Phase UNSPECIFIED = Phase::UNSPECIFIED;
+  static inline const Phase START_OF_TRACE = Phase::START_OF_TRACE;
+  static inline const Phase END_OF_TRACE = Phase::END_OF_TRACE;
 
   using FieldMetadata_Phase =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::FtraceStats_Phase,
+      FtraceStats_Phase,
       FtraceStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Phase kPhase() { return {}; }
-  void set_phase(::perfetto::protos::pbzero::FtraceStats_Phase value) {
+  static constexpr FieldMetadata_Phase kPhase{};
+  void set_phase(FtraceStats_Phase value) {
     static constexpr uint32_t field_id = FieldMetadata_Phase::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
@@ -64899,14 +98810,7 @@ class FtraceStats : public ::protozero::Message {
       FtraceCpuStats,
       FtraceStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpuStats kCpuStats() { return {}; }
+  static constexpr FieldMetadata_CpuStats kCpuStats{};
   template <typename T = FtraceCpuStats> T* add_cpu_stats() {
     return BeginNestedMessage<T>(2);
   }
@@ -64920,14 +98824,7 @@ class FtraceStats : public ::protozero::Message {
       uint32_t,
       FtraceStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KernelSymbolsParsed kKernelSymbolsParsed() { return {}; }
+  static constexpr FieldMetadata_KernelSymbolsParsed kKernelSymbolsParsed{};
   void set_kernel_symbols_parsed(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_KernelSymbolsParsed::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -64945,14 +98842,7 @@ class FtraceStats : public ::protozero::Message {
       uint32_t,
       FtraceStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KernelSymbolsMemKb kKernelSymbolsMemKb() { return {}; }
+  static constexpr FieldMetadata_KernelSymbolsMemKb kKernelSymbolsMemKb{};
   void set_kernel_symbols_mem_kb(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_KernelSymbolsMemKb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -64970,14 +98860,7 @@ class FtraceStats : public ::protozero::Message {
       std::string,
       FtraceStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AtraceErrors kAtraceErrors() { return {}; }
+  static constexpr FieldMetadata_AtraceErrors kAtraceErrors{};
   void set_atrace_errors(const char* data, size_t size) {
     AppendBytes(FieldMetadata_AtraceErrors::kFieldId, data, size);
   }
@@ -64993,6 +98876,30 @@ class FtraceStats : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
+  using FieldMetadata_ExclusiveFeatureError =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FtraceStats>;
+
+  static constexpr FieldMetadata_ExclusiveFeatureError kExclusiveFeatureError{};
+  void set_exclusive_feature_error(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ExclusiveFeatureError::kFieldId, data, size);
+  }
+  void set_exclusive_feature_error(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ExclusiveFeatureError::kFieldId, chars.data, chars.size);
+  }
+  void set_exclusive_feature_error(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ExclusiveFeatureError::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
   using FieldMetadata_UnknownFtraceEvents =
     ::protozero::proto_utils::FieldMetadata<
       6,
@@ -65001,14 +98908,7 @@ class FtraceStats : public ::protozero::Message {
       std::string,
       FtraceStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UnknownFtraceEvents kUnknownFtraceEvents() { return {}; }
+  static constexpr FieldMetadata_UnknownFtraceEvents kUnknownFtraceEvents{};
   void add_unknown_ftrace_events(const char* data, size_t size) {
     AppendBytes(FieldMetadata_UnknownFtraceEvents::kFieldId, data, size);
   }
@@ -65032,14 +98932,7 @@ class FtraceStats : public ::protozero::Message {
       std::string,
       FtraceStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FailedFtraceEvents kFailedFtraceEvents() { return {}; }
+  static constexpr FieldMetadata_FailedFtraceEvents kFailedFtraceEvents{};
   void add_failed_ftrace_events(const char* data, size_t size) {
     AppendBytes(FieldMetadata_FailedFtraceEvents::kFieldId, data, size);
   }
@@ -65063,14 +98956,7 @@ class FtraceStats : public ::protozero::Message {
       bool,
       FtraceStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PreserveFtraceBuffer kPreserveFtraceBuffer() { return {}; }
+  static constexpr FieldMetadata_PreserveFtraceBuffer kPreserveFtraceBuffer{};
   void set_preserve_ftrace_buffer(bool value) {
     static constexpr uint32_t field_id = FieldMetadata_PreserveFtraceBuffer::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -65079,9 +98965,135 @@ class FtraceStats : public ::protozero::Message {
       ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_FtraceParseErrors =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      FtraceParseStatus,
+      FtraceStats>;
+
+  static constexpr FieldMetadata_FtraceParseErrors kFtraceParseErrors{};
+  void add_ftrace_parse_errors(FtraceParseStatus value) {
+    static constexpr uint32_t field_id = FieldMetadata_FtraceParseErrors::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_KprobeStats =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FtraceKprobeStats,
+      FtraceStats>;
+
+  static constexpr FieldMetadata_KprobeStats kKprobeStats{};
+  template <typename T = FtraceKprobeStats> T* set_kprobe_stats() {
+    return BeginNestedMessage<T>(10);
+  }
+
+
+  using FieldMetadata_CpuBufferSizePages =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FtraceStats>;
+
+  static constexpr FieldMetadata_CpuBufferSizePages kCpuBufferSizePages{};
+  void set_cpu_buffer_size_pages(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CpuBufferSizePages::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CachedCpuBufferSizePages =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FtraceStats>;
+
+  static constexpr FieldMetadata_CachedCpuBufferSizePages kCachedCpuBufferSizePages{};
+  void set_cached_cpu_buffer_size_pages(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CachedCpuBufferSizePages::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class FtraceCpuStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class FtraceKprobeStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  FtraceKprobeStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FtraceKprobeStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FtraceKprobeStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_hits() const { return at<1>().valid(); }
+  int64_t hits() const { return at<1>().as_int64(); }
+  bool has_misses() const { return at<2>().valid(); }
+  int64_t misses() const { return at<2>().as_int64(); }
+};
+
+class FtraceKprobeStats : public ::protozero::Message {
+ public:
+  using Decoder = FtraceKprobeStats_Decoder;
+  enum : int32_t {
+    kHitsFieldNumber = 1,
+    kMissesFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FtraceKprobeStats"; }
+
+
+  using FieldMetadata_Hits =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      FtraceKprobeStats>;
+
+  static constexpr FieldMetadata_Hits kHits{};
+  void set_hits(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Hits::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Misses =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      FtraceKprobeStats>;
+
+  static constexpr FieldMetadata_Misses kMisses{};
+  void set_misses(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Misses::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class FtraceCpuStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9> {
  public:
   FtraceCpuStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit FtraceCpuStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -65131,14 +99143,7 @@ class FtraceCpuStats : public ::protozero::Message {
       uint64_t,
       FtraceCpuStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cpu kCpu() { return {}; }
+  static constexpr FieldMetadata_Cpu kCpu{};
   void set_cpu(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -65156,14 +99161,7 @@ class FtraceCpuStats : public ::protozero::Message {
       uint64_t,
       FtraceCpuStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Entries kEntries() { return {}; }
+  static constexpr FieldMetadata_Entries kEntries{};
   void set_entries(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Entries::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -65181,14 +99179,7 @@ class FtraceCpuStats : public ::protozero::Message {
       uint64_t,
       FtraceCpuStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Overrun kOverrun() { return {}; }
+  static constexpr FieldMetadata_Overrun kOverrun{};
   void set_overrun(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Overrun::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -65206,14 +99197,7 @@ class FtraceCpuStats : public ::protozero::Message {
       uint64_t,
       FtraceCpuStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CommitOverrun kCommitOverrun() { return {}; }
+  static constexpr FieldMetadata_CommitOverrun kCommitOverrun{};
   void set_commit_overrun(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_CommitOverrun::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -65231,14 +99215,7 @@ class FtraceCpuStats : public ::protozero::Message {
       uint64_t,
       FtraceCpuStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BytesRead kBytesRead() { return {}; }
+  static constexpr FieldMetadata_BytesRead kBytesRead{};
   void set_bytes_read(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_BytesRead::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -65256,14 +99233,7 @@ class FtraceCpuStats : public ::protozero::Message {
       double,
       FtraceCpuStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OldestEventTs kOldestEventTs() { return {}; }
+  static constexpr FieldMetadata_OldestEventTs kOldestEventTs{};
   void set_oldest_event_ts(double value) {
     static constexpr uint32_t field_id = FieldMetadata_OldestEventTs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -65281,14 +99251,7 @@ class FtraceCpuStats : public ::protozero::Message {
       double,
       FtraceCpuStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NowTs kNowTs() { return {}; }
+  static constexpr FieldMetadata_NowTs kNowTs{};
   void set_now_ts(double value) {
     static constexpr uint32_t field_id = FieldMetadata_NowTs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -65306,14 +99269,7 @@ class FtraceCpuStats : public ::protozero::Message {
       uint64_t,
       FtraceCpuStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DroppedEvents kDroppedEvents() { return {}; }
+  static constexpr FieldMetadata_DroppedEvents kDroppedEvents{};
   void set_dropped_events(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_DroppedEvents::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -65331,14 +99287,7 @@ class FtraceCpuStats : public ::protozero::Message {
       uint64_t,
       FtraceCpuStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReadEvents kReadEvents() { return {}; }
+  static constexpr FieldMetadata_ReadEvents kReadEvents{};
   void set_read_events(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ReadEvents::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -65371,10 +99320,16 @@ class FtraceCpuStats : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
-
 class FtraceEventBundle;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-class TestBundleWrapper_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class TestBundleWrapper_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
   TestBundleWrapper_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit TestBundleWrapper_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -65406,14 +99361,7 @@ class TestBundleWrapper : public ::protozero::Message {
       std::string,
       TestBundleWrapper>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Before kBefore() { return {}; }
+  static constexpr FieldMetadata_Before kBefore{};
   void set_before(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Before::kFieldId, data, size);
   }
@@ -65437,14 +99385,7 @@ class TestBundleWrapper : public ::protozero::Message {
       FtraceEventBundle,
       TestBundleWrapper>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Bundle kBundle() { return {}; }
+  static constexpr FieldMetadata_Bundle kBundle{};
   template <typename T = FtraceEventBundle> T* add_bundle() {
     return BeginNestedMessage<T>(2);
   }
@@ -65458,14 +99399,7 @@ class TestBundleWrapper : public ::protozero::Message {
       std::string,
       TestBundleWrapper>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_After kAfter() { return {}; }
+  static constexpr FieldMetadata_After kAfter{};
   void set_after(const char* data, size_t size) {
     AppendBytes(FieldMetadata_After::kFieldId, data, size);
   }
@@ -65504,10 +99438,126 @@ class TestBundleWrapper : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
-
 class GenericFtraceEvent_Field;
+namespace perfetto_pbzero_enum_KprobeEvent {
+enum KprobeType : int32_t;
+}  // namespace perfetto_pbzero_enum_KprobeEvent
+using KprobeEvent_KprobeType = perfetto_pbzero_enum_KprobeEvent::KprobeType;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_KprobeEvent {
+enum KprobeType : int32_t {
+  KPROBE_TYPE_UNKNOWN = 0,
+  KPROBE_TYPE_BEGIN = 1,
+  KPROBE_TYPE_END = 2,
+  KPROBE_TYPE_INSTANT = 3,
+};
+} // namespace perfetto_pbzero_enum_KprobeEvent
+using KprobeEvent_KprobeType = perfetto_pbzero_enum_KprobeEvent::KprobeType;
+
+
+constexpr KprobeEvent_KprobeType KprobeEvent_KprobeType_MIN = KprobeEvent_KprobeType::KPROBE_TYPE_UNKNOWN;
+constexpr KprobeEvent_KprobeType KprobeEvent_KprobeType_MAX = KprobeEvent_KprobeType::KPROBE_TYPE_INSTANT;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* KprobeEvent_KprobeType_Name(::perfetto::protos::pbzero::KprobeEvent_KprobeType value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::KprobeEvent_KprobeType::KPROBE_TYPE_UNKNOWN:
+    return "KPROBE_TYPE_UNKNOWN";
+
+  case ::perfetto::protos::pbzero::KprobeEvent_KprobeType::KPROBE_TYPE_BEGIN:
+    return "KPROBE_TYPE_BEGIN";
+
+  case ::perfetto::protos::pbzero::KprobeEvent_KprobeType::KPROBE_TYPE_END:
+    return "KPROBE_TYPE_END";
+
+  case ::perfetto::protos::pbzero::KprobeEvent_KprobeType::KPROBE_TYPE_INSTANT:
+    return "KPROBE_TYPE_INSTANT";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
-class GenericFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class KprobeEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  KprobeEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KprobeEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KprobeEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_type() const { return at<2>().valid(); }
+  int32_t type() const { return at<2>().as_int32(); }
+};
+
+class KprobeEvent : public ::protozero::Message {
+ public:
+  using Decoder = KprobeEvent_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kTypeFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KprobeEvent"; }
+
+
+  using KprobeType = ::perfetto::protos::pbzero::KprobeEvent_KprobeType;
+  static inline const char* KprobeType_Name(KprobeType value) {
+    return ::perfetto::protos::pbzero::KprobeEvent_KprobeType_Name(value);
+  }
+  static inline const KprobeType KPROBE_TYPE_UNKNOWN = KprobeType::KPROBE_TYPE_UNKNOWN;
+  static inline const KprobeType KPROBE_TYPE_BEGIN = KprobeType::KPROBE_TYPE_BEGIN;
+  static inline const KprobeType KPROBE_TYPE_END = KprobeType::KPROBE_TYPE_END;
+  static inline const KprobeType KPROBE_TYPE_INSTANT = KprobeType::KPROBE_TYPE_INSTANT;
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      KprobeEvent>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Type =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      KprobeEvent_KprobeType,
+      KprobeEvent>;
+
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(KprobeEvent_KprobeType value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class GenericFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
   GenericFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit GenericFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -65537,14 +99587,7 @@ class GenericFtraceEvent : public ::protozero::Message {
       std::string,
       GenericFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EventName kEventName() { return {}; }
+  static constexpr FieldMetadata_EventName kEventName{};
   void set_event_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_EventName::kFieldId, data, size);
   }
@@ -65568,21 +99611,14 @@ class GenericFtraceEvent : public ::protozero::Message {
       GenericFtraceEvent_Field,
       GenericFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Field kField() { return {}; }
+  static constexpr FieldMetadata_Field kField{};
   template <typename T = GenericFtraceEvent_Field> T* add_field() {
     return BeginNestedMessage<T>(2);
   }
 
 };
 
-class GenericFtraceEvent_Field_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class GenericFtraceEvent_Field_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
   GenericFtraceEvent_Field_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit GenericFtraceEvent_Field_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -65617,14 +99653,7 @@ class GenericFtraceEvent_Field : public ::protozero::Message {
       std::string,
       GenericFtraceEvent_Field>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -65648,14 +99677,7 @@ class GenericFtraceEvent_Field : public ::protozero::Message {
       std::string,
       GenericFtraceEvent_Field>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StrValue kStrValue() { return {}; }
+  static constexpr FieldMetadata_StrValue kStrValue{};
   void set_str_value(const char* data, size_t size) {
     AppendBytes(FieldMetadata_StrValue::kFieldId, data, size);
   }
@@ -65679,14 +99701,7 @@ class GenericFtraceEvent_Field : public ::protozero::Message {
       int64_t,
       GenericFtraceEvent_Field>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IntValue kIntValue() { return {}; }
+  static constexpr FieldMetadata_IntValue kIntValue{};
   void set_int_value(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -65704,14 +99719,7 @@ class GenericFtraceEvent_Field : public ::protozero::Message {
       uint64_t,
       GenericFtraceEvent_Field>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UintValue kUintValue() { return {}; }
+  static constexpr FieldMetadata_UintValue kUintValue{};
   void set_uint_value(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_UintValue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -65741,12 +99749,12 @@ class GenericFtraceEvent_Field : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class AndroidFsFsyncStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class AndroidFsFsyncStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
   AndroidFsFsyncStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit AndroidFsFsyncStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -65784,14 +99792,7 @@ class AndroidFsFsyncStartFtraceEvent : public ::protozero::Message {
       std::string,
       AndroidFsFsyncStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cmdline kCmdline() { return {}; }
+  static constexpr FieldMetadata_Cmdline kCmdline{};
   void set_cmdline(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Cmdline::kFieldId, data, size);
   }
@@ -65815,14 +99816,7 @@ class AndroidFsFsyncStartFtraceEvent : public ::protozero::Message {
       int64_t,
       AndroidFsFsyncStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ISize kISize() { return {}; }
+  static constexpr FieldMetadata_ISize kISize{};
   void set_i_size(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ISize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -65840,14 +99834,7 @@ class AndroidFsFsyncStartFtraceEvent : public ::protozero::Message {
       uint64_t,
       AndroidFsFsyncStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -65865,14 +99852,7 @@ class AndroidFsFsyncStartFtraceEvent : public ::protozero::Message {
       std::string,
       AndroidFsFsyncStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pathbuf kPathbuf() { return {}; }
+  static constexpr FieldMetadata_Pathbuf kPathbuf{};
   void set_pathbuf(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Pathbuf::kFieldId, data, size);
   }
@@ -65896,14 +99876,7 @@ class AndroidFsFsyncStartFtraceEvent : public ::protozero::Message {
       int32_t,
       AndroidFsFsyncStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
+  static constexpr FieldMetadata_Pid kPid{};
   void set_pid(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -65914,7 +99887,7 @@ class AndroidFsFsyncStartFtraceEvent : public ::protozero::Message {
   }
 };
 
-class AndroidFsFsyncEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class AndroidFsFsyncEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
   AndroidFsFsyncEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit AndroidFsFsyncEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -65946,14 +99919,7 @@ class AndroidFsFsyncEndFtraceEvent : public ::protozero::Message {
       int32_t,
       AndroidFsFsyncEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Bytes kBytes() { return {}; }
+  static constexpr FieldMetadata_Bytes kBytes{};
   void set_bytes(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Bytes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -65971,14 +99937,7 @@ class AndroidFsFsyncEndFtraceEvent : public ::protozero::Message {
       uint64_t,
       AndroidFsFsyncEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -65996,14 +99955,7 @@ class AndroidFsFsyncEndFtraceEvent : public ::protozero::Message {
       int64_t,
       AndroidFsFsyncEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Offset kOffset() { return {}; }
+  static constexpr FieldMetadata_Offset kOffset{};
   void set_offset(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -66014,7 +99966,7 @@ class AndroidFsFsyncEndFtraceEvent : public ::protozero::Message {
   }
 };
 
-class AndroidFsDatawriteStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class AndroidFsDatawriteStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
   AndroidFsDatawriteStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit AndroidFsDatawriteStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -66058,14 +100010,7 @@ class AndroidFsDatawriteStartFtraceEvent : public ::protozero::Message {
       int32_t,
       AndroidFsDatawriteStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Bytes kBytes() { return {}; }
+  static constexpr FieldMetadata_Bytes kBytes{};
   void set_bytes(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Bytes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -66083,14 +100028,7 @@ class AndroidFsDatawriteStartFtraceEvent : public ::protozero::Message {
       std::string,
       AndroidFsDatawriteStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cmdline kCmdline() { return {}; }
+  static constexpr FieldMetadata_Cmdline kCmdline{};
   void set_cmdline(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Cmdline::kFieldId, data, size);
   }
@@ -66114,14 +100052,7 @@ class AndroidFsDatawriteStartFtraceEvent : public ::protozero::Message {
       int64_t,
       AndroidFsDatawriteStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ISize kISize() { return {}; }
+  static constexpr FieldMetadata_ISize kISize{};
   void set_i_size(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ISize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -66139,14 +100070,7 @@ class AndroidFsDatawriteStartFtraceEvent : public ::protozero::Message {
       uint64_t,
       AndroidFsDatawriteStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -66164,14 +100088,7 @@ class AndroidFsDatawriteStartFtraceEvent : public ::protozero::Message {
       int64_t,
       AndroidFsDatawriteStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Offset kOffset() { return {}; }
+  static constexpr FieldMetadata_Offset kOffset{};
   void set_offset(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -66189,14 +100106,7 @@ class AndroidFsDatawriteStartFtraceEvent : public ::protozero::Message {
       std::string,
       AndroidFsDatawriteStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pathbuf kPathbuf() { return {}; }
+  static constexpr FieldMetadata_Pathbuf kPathbuf{};
   void set_pathbuf(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Pathbuf::kFieldId, data, size);
   }
@@ -66220,14 +100130,7 @@ class AndroidFsDatawriteStartFtraceEvent : public ::protozero::Message {
       int32_t,
       AndroidFsDatawriteStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
+  static constexpr FieldMetadata_Pid kPid{};
   void set_pid(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -66238,7 +100141,7 @@ class AndroidFsDatawriteStartFtraceEvent : public ::protozero::Message {
   }
 };
 
-class AndroidFsDatawriteEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class AndroidFsDatawriteEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
   AndroidFsDatawriteEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit AndroidFsDatawriteEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -66270,14 +100173,7 @@ class AndroidFsDatawriteEndFtraceEvent : public ::protozero::Message {
       int32_t,
       AndroidFsDatawriteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Bytes kBytes() { return {}; }
+  static constexpr FieldMetadata_Bytes kBytes{};
   void set_bytes(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Bytes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -66295,14 +100191,7 @@ class AndroidFsDatawriteEndFtraceEvent : public ::protozero::Message {
       uint64_t,
       AndroidFsDatawriteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -66320,14 +100209,7 @@ class AndroidFsDatawriteEndFtraceEvent : public ::protozero::Message {
       int64_t,
       AndroidFsDatawriteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Offset kOffset() { return {}; }
+  static constexpr FieldMetadata_Offset kOffset{};
   void set_offset(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -66338,7 +100220,7 @@ class AndroidFsDatawriteEndFtraceEvent : public ::protozero::Message {
   }
 };
 
-class AndroidFsDatareadStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class AndroidFsDatareadStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
   AndroidFsDatareadStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit AndroidFsDatareadStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -66382,14 +100264,7 @@ class AndroidFsDatareadStartFtraceEvent : public ::protozero::Message {
       int32_t,
       AndroidFsDatareadStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Bytes kBytes() { return {}; }
+  static constexpr FieldMetadata_Bytes kBytes{};
   void set_bytes(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Bytes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -66407,14 +100282,7 @@ class AndroidFsDatareadStartFtraceEvent : public ::protozero::Message {
       std::string,
       AndroidFsDatareadStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cmdline kCmdline() { return {}; }
+  static constexpr FieldMetadata_Cmdline kCmdline{};
   void set_cmdline(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Cmdline::kFieldId, data, size);
   }
@@ -66438,14 +100306,7 @@ class AndroidFsDatareadStartFtraceEvent : public ::protozero::Message {
       int64_t,
       AndroidFsDatareadStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ISize kISize() { return {}; }
+  static constexpr FieldMetadata_ISize kISize{};
   void set_i_size(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ISize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -66463,14 +100324,7 @@ class AndroidFsDatareadStartFtraceEvent : public ::protozero::Message {
       uint64_t,
       AndroidFsDatareadStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -66488,14 +100342,7 @@ class AndroidFsDatareadStartFtraceEvent : public ::protozero::Message {
       int64_t,
       AndroidFsDatareadStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Offset kOffset() { return {}; }
+  static constexpr FieldMetadata_Offset kOffset{};
   void set_offset(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -66513,14 +100360,7 @@ class AndroidFsDatareadStartFtraceEvent : public ::protozero::Message {
       std::string,
       AndroidFsDatareadStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pathbuf kPathbuf() { return {}; }
+  static constexpr FieldMetadata_Pathbuf kPathbuf{};
   void set_pathbuf(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Pathbuf::kFieldId, data, size);
   }
@@ -66544,14 +100384,7 @@ class AndroidFsDatareadStartFtraceEvent : public ::protozero::Message {
       int32_t,
       AndroidFsDatareadStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
+  static constexpr FieldMetadata_Pid kPid{};
   void set_pid(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -66562,7 +100395,7 @@ class AndroidFsDatareadStartFtraceEvent : public ::protozero::Message {
   }
 };
 
-class AndroidFsDatareadEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class AndroidFsDatareadEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
   AndroidFsDatareadEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit AndroidFsDatareadEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -66594,14 +100427,7 @@ class AndroidFsDatareadEndFtraceEvent : public ::protozero::Message {
       int32_t,
       AndroidFsDatareadEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Bytes kBytes() { return {}; }
+  static constexpr FieldMetadata_Bytes kBytes{};
   void set_bytes(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Bytes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -66619,14 +100445,7 @@ class AndroidFsDatareadEndFtraceEvent : public ::protozero::Message {
       uint64_t,
       AndroidFsDatareadEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -66644,14 +100463,7 @@ class AndroidFsDatareadEndFtraceEvent : public ::protozero::Message {
       int64_t,
       AndroidFsDatareadEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Offset kOffset() { return {}; }
+  static constexpr FieldMetadata_Offset kOffset{};
   void set_offset(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -66662,6 +100474,235 @@ class AndroidFsDatareadEndFtraceEvent : public ::protozero::Message {
   }
 };
 
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/bcl_exynos.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_BCL_EXYNOS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_BCL_EXYNOS_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class BclIrqTriggerFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9> {
+ public:
+  BclIrqTriggerFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit BclIrqTriggerFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit BclIrqTriggerFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  int32_t id() const { return at<1>().as_int32(); }
+  bool has_throttle() const { return at<2>().valid(); }
+  int32_t throttle() const { return at<2>().as_int32(); }
+  bool has_cpu0_limit() const { return at<3>().valid(); }
+  int32_t cpu0_limit() const { return at<3>().as_int32(); }
+  bool has_cpu1_limit() const { return at<4>().valid(); }
+  int32_t cpu1_limit() const { return at<4>().as_int32(); }
+  bool has_cpu2_limit() const { return at<5>().valid(); }
+  int32_t cpu2_limit() const { return at<5>().as_int32(); }
+  bool has_tpu_limit() const { return at<6>().valid(); }
+  int32_t tpu_limit() const { return at<6>().as_int32(); }
+  bool has_gpu_limit() const { return at<7>().valid(); }
+  int32_t gpu_limit() const { return at<7>().as_int32(); }
+  bool has_voltage() const { return at<8>().valid(); }
+  int32_t voltage() const { return at<8>().as_int32(); }
+  bool has_capacity() const { return at<9>().valid(); }
+  int32_t capacity() const { return at<9>().as_int32(); }
+};
+
+class BclIrqTriggerFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = BclIrqTriggerFtraceEvent_Decoder;
+  enum : int32_t {
+    kIdFieldNumber = 1,
+    kThrottleFieldNumber = 2,
+    kCpu0LimitFieldNumber = 3,
+    kCpu1LimitFieldNumber = 4,
+    kCpu2LimitFieldNumber = 5,
+    kTpuLimitFieldNumber = 6,
+    kGpuLimitFieldNumber = 7,
+    kVoltageFieldNumber = 8,
+    kCapacityFieldNumber = 9,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.BclIrqTriggerFtraceEvent"; }
+
+
+  using FieldMetadata_Id =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BclIrqTriggerFtraceEvent>;
+
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Throttle =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BclIrqTriggerFtraceEvent>;
+
+  static constexpr FieldMetadata_Throttle kThrottle{};
+  void set_throttle(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Throttle::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Cpu0Limit =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BclIrqTriggerFtraceEvent>;
+
+  static constexpr FieldMetadata_Cpu0Limit kCpu0Limit{};
+  void set_cpu0_limit(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cpu0Limit::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Cpu1Limit =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BclIrqTriggerFtraceEvent>;
+
+  static constexpr FieldMetadata_Cpu1Limit kCpu1Limit{};
+  void set_cpu1_limit(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cpu1Limit::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Cpu2Limit =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BclIrqTriggerFtraceEvent>;
+
+  static constexpr FieldMetadata_Cpu2Limit kCpu2Limit{};
+  void set_cpu2_limit(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cpu2Limit::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TpuLimit =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BclIrqTriggerFtraceEvent>;
+
+  static constexpr FieldMetadata_TpuLimit kTpuLimit{};
+  void set_tpu_limit(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TpuLimit::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_GpuLimit =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BclIrqTriggerFtraceEvent>;
+
+  static constexpr FieldMetadata_GpuLimit kGpuLimit{};
+  void set_gpu_limit(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GpuLimit::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Voltage =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BclIrqTriggerFtraceEvent>;
+
+  static constexpr FieldMetadata_Voltage kVoltage{};
+  void set_voltage(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Voltage::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Capacity =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BclIrqTriggerFtraceEvent>;
+
+  static constexpr FieldMetadata_Capacity kCapacity{};
+  void set_capacity(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Capacity::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
 } // Namespace.
 } // Namespace.
 } // Namespace.
@@ -66681,12 +100722,86 @@ class AndroidFsDatareadEndFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
+class BinderReturnFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  BinderReturnFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit BinderReturnFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit BinderReturnFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cmd() const { return at<1>().valid(); }
+  uint32_t cmd() const { return at<1>().as_uint32(); }
+};
+
+class BinderReturnFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = BinderReturnFtraceEvent_Decoder;
+  enum : int32_t {
+    kCmdFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.BinderReturnFtraceEvent"; }
+
+
+  using FieldMetadata_Cmd =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      BinderReturnFtraceEvent>;
+
+  static constexpr FieldMetadata_Cmd kCmd{};
+  void set_cmd(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cmd::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class BinderCommandFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  BinderCommandFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit BinderCommandFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit BinderCommandFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cmd() const { return at<1>().valid(); }
+  uint32_t cmd() const { return at<1>().as_uint32(); }
+};
+
+class BinderCommandFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = BinderCommandFtraceEvent_Decoder;
+  enum : int32_t {
+    kCmdFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.BinderCommandFtraceEvent"; }
+
+
+  using FieldMetadata_Cmd =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      BinderCommandFtraceEvent>;
+
+  static constexpr FieldMetadata_Cmd kCmd{};
+  void set_cmd(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cmd::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
 
-class BinderTransactionAllocBufFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BinderTransactionAllocBufFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
   BinderTransactionAllocBufFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BinderTransactionAllocBufFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -66721,14 +100836,7 @@ class BinderTransactionAllocBufFtraceEvent : public ::protozero::Message {
       uint64_t,
       BinderTransactionAllocBufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DataSize kDataSize() { return {}; }
+  static constexpr FieldMetadata_DataSize kDataSize{};
   void set_data_size(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_DataSize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -66746,14 +100854,7 @@ class BinderTransactionAllocBufFtraceEvent : public ::protozero::Message {
       int32_t,
       BinderTransactionAllocBufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DebugId kDebugId() { return {}; }
+  static constexpr FieldMetadata_DebugId kDebugId{};
   void set_debug_id(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_DebugId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -66771,14 +100872,7 @@ class BinderTransactionAllocBufFtraceEvent : public ::protozero::Message {
       uint64_t,
       BinderTransactionAllocBufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OffsetsSize kOffsetsSize() { return {}; }
+  static constexpr FieldMetadata_OffsetsSize kOffsetsSize{};
   void set_offsets_size(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_OffsetsSize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -66796,14 +100890,7 @@ class BinderTransactionAllocBufFtraceEvent : public ::protozero::Message {
       uint64_t,
       BinderTransactionAllocBufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExtraBuffersSize kExtraBuffersSize() { return {}; }
+  static constexpr FieldMetadata_ExtraBuffersSize kExtraBuffersSize{};
   void set_extra_buffers_size(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ExtraBuffersSize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -66814,7 +100901,7 @@ class BinderTransactionAllocBufFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BinderUnlockFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BinderUnlockFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
   BinderUnlockFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BinderUnlockFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -66840,14 +100927,7 @@ class BinderUnlockFtraceEvent : public ::protozero::Message {
       std::string,
       BinderUnlockFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Tag kTag() { return {}; }
+  static constexpr FieldMetadata_Tag kTag{};
   void set_tag(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Tag::kFieldId, data, size);
   }
@@ -66864,7 +100944,7 @@ class BinderUnlockFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BinderLockedFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BinderLockedFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
   BinderLockedFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BinderLockedFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -66890,14 +100970,7 @@ class BinderLockedFtraceEvent : public ::protozero::Message {
       std::string,
       BinderLockedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Tag kTag() { return {}; }
+  static constexpr FieldMetadata_Tag kTag{};
   void set_tag(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Tag::kFieldId, data, size);
   }
@@ -66914,7 +100987,7 @@ class BinderLockedFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BinderLockFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BinderLockFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
   BinderLockFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BinderLockFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -66940,14 +101013,7 @@ class BinderLockFtraceEvent : public ::protozero::Message {
       std::string,
       BinderLockFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Tag kTag() { return {}; }
+  static constexpr FieldMetadata_Tag kTag{};
   void set_tag(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Tag::kFieldId, data, size);
   }
@@ -66964,7 +101030,7 @@ class BinderLockFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BinderSetPriorityFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BinderSetPriorityFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
   BinderSetPriorityFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BinderSetPriorityFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -67002,14 +101068,7 @@ class BinderSetPriorityFtraceEvent : public ::protozero::Message {
       int32_t,
       BinderSetPriorityFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Proc kProc() { return {}; }
+  static constexpr FieldMetadata_Proc kProc{};
   void set_proc(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Proc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67027,14 +101086,7 @@ class BinderSetPriorityFtraceEvent : public ::protozero::Message {
       int32_t,
       BinderSetPriorityFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Thread kThread() { return {}; }
+  static constexpr FieldMetadata_Thread kThread{};
   void set_thread(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Thread::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67052,14 +101104,7 @@ class BinderSetPriorityFtraceEvent : public ::protozero::Message {
       uint32_t,
       BinderSetPriorityFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OldPrio kOldPrio() { return {}; }
+  static constexpr FieldMetadata_OldPrio kOldPrio{};
   void set_old_prio(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_OldPrio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67077,14 +101122,7 @@ class BinderSetPriorityFtraceEvent : public ::protozero::Message {
       uint32_t,
       BinderSetPriorityFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NewPrio kNewPrio() { return {}; }
+  static constexpr FieldMetadata_NewPrio kNewPrio{};
   void set_new_prio(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NewPrio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67102,14 +101140,7 @@ class BinderSetPriorityFtraceEvent : public ::protozero::Message {
       uint32_t,
       BinderSetPriorityFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DesiredPrio kDesiredPrio() { return {}; }
+  static constexpr FieldMetadata_DesiredPrio kDesiredPrio{};
   void set_desired_prio(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_DesiredPrio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67120,7 +101151,7 @@ class BinderSetPriorityFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BinderTransactionReceivedFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BinderTransactionReceivedFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
   BinderTransactionReceivedFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BinderTransactionReceivedFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -67146,14 +101177,7 @@ class BinderTransactionReceivedFtraceEvent : public ::protozero::Message {
       int32_t,
       BinderTransactionReceivedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DebugId kDebugId() { return {}; }
+  static constexpr FieldMetadata_DebugId kDebugId{};
   void set_debug_id(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_DebugId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67164,7 +101188,7 @@ class BinderTransactionReceivedFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BinderTransactionFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BinderTransactionFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
   BinderTransactionFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BinderTransactionFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -67208,14 +101232,7 @@ class BinderTransactionFtraceEvent : public ::protozero::Message {
       int32_t,
       BinderTransactionFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DebugId kDebugId() { return {}; }
+  static constexpr FieldMetadata_DebugId kDebugId{};
   void set_debug_id(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_DebugId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67233,14 +101250,7 @@ class BinderTransactionFtraceEvent : public ::protozero::Message {
       int32_t,
       BinderTransactionFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TargetNode kTargetNode() { return {}; }
+  static constexpr FieldMetadata_TargetNode kTargetNode{};
   void set_target_node(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_TargetNode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67258,14 +101268,7 @@ class BinderTransactionFtraceEvent : public ::protozero::Message {
       int32_t,
       BinderTransactionFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ToProc kToProc() { return {}; }
+  static constexpr FieldMetadata_ToProc kToProc{};
   void set_to_proc(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ToProc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67283,14 +101286,7 @@ class BinderTransactionFtraceEvent : public ::protozero::Message {
       int32_t,
       BinderTransactionFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ToThread kToThread() { return {}; }
+  static constexpr FieldMetadata_ToThread kToThread{};
   void set_to_thread(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ToThread::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67308,14 +101304,7 @@ class BinderTransactionFtraceEvent : public ::protozero::Message {
       int32_t,
       BinderTransactionFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Reply kReply() { return {}; }
+  static constexpr FieldMetadata_Reply kReply{};
   void set_reply(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Reply::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67333,14 +101322,7 @@ class BinderTransactionFtraceEvent : public ::protozero::Message {
       uint32_t,
       BinderTransactionFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Code kCode() { return {}; }
+  static constexpr FieldMetadata_Code kCode{};
   void set_code(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Code::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67358,14 +101340,7 @@ class BinderTransactionFtraceEvent : public ::protozero::Message {
       uint32_t,
       BinderTransactionFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
+  static constexpr FieldMetadata_Flags kFlags{};
   void set_flags(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67395,12 +101370,416 @@ class BinderTransactionFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
+class BlockIoDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
+ public:
+  BlockIoDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit BlockIoDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit BlockIoDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_sector() const { return at<2>().valid(); }
+  uint64_t sector() const { return at<2>().as_uint64(); }
+  bool has_nr_sector() const { return at<3>().valid(); }
+  uint32_t nr_sector() const { return at<3>().as_uint32(); }
+  bool has_bytes() const { return at<4>().valid(); }
+  uint32_t bytes() const { return at<4>().as_uint32(); }
+  bool has_ioprio() const { return at<5>().valid(); }
+  uint32_t ioprio() const { return at<5>().as_uint32(); }
+  bool has_rwbs() const { return at<6>().valid(); }
+  ::protozero::ConstChars rwbs() const { return at<6>().as_string(); }
+  bool has_comm() const { return at<7>().valid(); }
+  ::protozero::ConstChars comm() const { return at<7>().as_string(); }
+  bool has_cmd() const { return at<8>().valid(); }
+  ::protozero::ConstChars cmd() const { return at<8>().as_string(); }
+};
 
-class BlockUnplugFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BlockIoDoneFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = BlockIoDoneFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kSectorFieldNumber = 2,
+    kNrSectorFieldNumber = 3,
+    kBytesFieldNumber = 4,
+    kIoprioFieldNumber = 5,
+    kRwbsFieldNumber = 6,
+    kCommFieldNumber = 7,
+    kCmdFieldNumber = 8,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.BlockIoDoneFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      BlockIoDoneFtraceEvent>;
+
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Sector =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      BlockIoDoneFtraceEvent>;
+
+  static constexpr FieldMetadata_Sector kSector{};
+  void set_sector(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NrSector =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      BlockIoDoneFtraceEvent>;
+
+  static constexpr FieldMetadata_NrSector kNrSector{};
+  void set_nr_sector(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Bytes =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      BlockIoDoneFtraceEvent>;
+
+  static constexpr FieldMetadata_Bytes kBytes{};
+  void set_bytes(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Bytes::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ioprio =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      BlockIoDoneFtraceEvent>;
+
+  static constexpr FieldMetadata_Ioprio kIoprio{};
+  void set_ioprio(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ioprio::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Rwbs =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      BlockIoDoneFtraceEvent>;
+
+  static constexpr FieldMetadata_Rwbs kRwbs{};
+  void set_rwbs(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size);
+  }
+  void set_rwbs(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Rwbs::kFieldId, chars.data, chars.size);
+  }
+  void set_rwbs(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Rwbs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Comm =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      BlockIoDoneFtraceEvent>;
+
+  static constexpr FieldMetadata_Comm kComm{};
+  void set_comm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
+  }
+  void set_comm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
+  }
+  void set_comm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Cmd =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      BlockIoDoneFtraceEvent>;
+
+  static constexpr FieldMetadata_Cmd kCmd{};
+  void set_cmd(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Cmd::kFieldId, data, size);
+  }
+  void set_cmd(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Cmd::kFieldId, chars.data, chars.size);
+  }
+  void set_cmd(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cmd::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class BlockIoStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
+ public:
+  BlockIoStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit BlockIoStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit BlockIoStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_sector() const { return at<2>().valid(); }
+  uint64_t sector() const { return at<2>().as_uint64(); }
+  bool has_nr_sector() const { return at<3>().valid(); }
+  uint32_t nr_sector() const { return at<3>().as_uint32(); }
+  bool has_bytes() const { return at<4>().valid(); }
+  uint32_t bytes() const { return at<4>().as_uint32(); }
+  bool has_ioprio() const { return at<5>().valid(); }
+  uint32_t ioprio() const { return at<5>().as_uint32(); }
+  bool has_rwbs() const { return at<6>().valid(); }
+  ::protozero::ConstChars rwbs() const { return at<6>().as_string(); }
+  bool has_comm() const { return at<7>().valid(); }
+  ::protozero::ConstChars comm() const { return at<7>().as_string(); }
+  bool has_cmd() const { return at<8>().valid(); }
+  ::protozero::ConstChars cmd() const { return at<8>().as_string(); }
+};
+
+class BlockIoStartFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = BlockIoStartFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kSectorFieldNumber = 2,
+    kNrSectorFieldNumber = 3,
+    kBytesFieldNumber = 4,
+    kIoprioFieldNumber = 5,
+    kRwbsFieldNumber = 6,
+    kCommFieldNumber = 7,
+    kCmdFieldNumber = 8,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.BlockIoStartFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      BlockIoStartFtraceEvent>;
+
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Sector =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      BlockIoStartFtraceEvent>;
+
+  static constexpr FieldMetadata_Sector kSector{};
+  void set_sector(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NrSector =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      BlockIoStartFtraceEvent>;
+
+  static constexpr FieldMetadata_NrSector kNrSector{};
+  void set_nr_sector(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Bytes =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      BlockIoStartFtraceEvent>;
+
+  static constexpr FieldMetadata_Bytes kBytes{};
+  void set_bytes(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Bytes::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ioprio =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      BlockIoStartFtraceEvent>;
+
+  static constexpr FieldMetadata_Ioprio kIoprio{};
+  void set_ioprio(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ioprio::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Rwbs =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      BlockIoStartFtraceEvent>;
+
+  static constexpr FieldMetadata_Rwbs kRwbs{};
+  void set_rwbs(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size);
+  }
+  void set_rwbs(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Rwbs::kFieldId, chars.data, chars.size);
+  }
+  void set_rwbs(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Rwbs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Comm =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      BlockIoStartFtraceEvent>;
+
+  static constexpr FieldMetadata_Comm kComm{};
+  void set_comm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
+  }
+  void set_comm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
+  }
+  void set_comm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Cmd =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      BlockIoStartFtraceEvent>;
+
+  static constexpr FieldMetadata_Cmd kCmd{};
+  void set_cmd(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Cmd::kFieldId, data, size);
+  }
+  void set_cmd(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Cmd::kFieldId, chars.data, chars.size);
+  }
+  void set_cmd(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cmd::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class BlockUnplugFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
   BlockUnplugFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BlockUnplugFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -67429,14 +101808,7 @@ class BlockUnplugFtraceEvent : public ::protozero::Message {
       int32_t,
       BlockUnplugFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrRq kNrRq() { return {}; }
+  static constexpr FieldMetadata_NrRq kNrRq{};
   void set_nr_rq(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrRq::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67454,14 +101826,7 @@ class BlockUnplugFtraceEvent : public ::protozero::Message {
       std::string,
       BlockUnplugFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
+  static constexpr FieldMetadata_Comm kComm{};
   void set_comm(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
   }
@@ -67478,7 +101843,7 @@ class BlockUnplugFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BlockTouchBufferFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BlockTouchBufferFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
   BlockTouchBufferFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BlockTouchBufferFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -67510,14 +101875,7 @@ class BlockTouchBufferFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockTouchBufferFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67535,14 +101893,7 @@ class BlockTouchBufferFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockTouchBufferFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sector kSector() { return {}; }
+  static constexpr FieldMetadata_Sector kSector{};
   void set_sector(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67560,14 +101911,7 @@ class BlockTouchBufferFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockTouchBufferFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Size kSize() { return {}; }
+  static constexpr FieldMetadata_Size kSize{};
   void set_size(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67578,7 +101922,7 @@ class BlockTouchBufferFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BlockSplitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BlockSplitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
   BlockSplitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BlockSplitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -67616,14 +101960,7 @@ class BlockSplitFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockSplitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67641,14 +101978,7 @@ class BlockSplitFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockSplitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sector kSector() { return {}; }
+  static constexpr FieldMetadata_Sector kSector{};
   void set_sector(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67666,14 +101996,7 @@ class BlockSplitFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockSplitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NewSector kNewSector() { return {}; }
+  static constexpr FieldMetadata_NewSector kNewSector{};
   void set_new_sector(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NewSector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67691,14 +102014,7 @@ class BlockSplitFtraceEvent : public ::protozero::Message {
       std::string,
       BlockSplitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Rwbs kRwbs() { return {}; }
+  static constexpr FieldMetadata_Rwbs kRwbs{};
   void set_rwbs(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size);
   }
@@ -67722,14 +102038,7 @@ class BlockSplitFtraceEvent : public ::protozero::Message {
       std::string,
       BlockSplitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
+  static constexpr FieldMetadata_Comm kComm{};
   void set_comm(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
   }
@@ -67746,7 +102055,7 @@ class BlockSplitFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BlockSleeprqFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BlockSleeprqFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
   BlockSleeprqFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BlockSleeprqFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -67784,14 +102093,7 @@ class BlockSleeprqFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockSleeprqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67809,14 +102111,7 @@ class BlockSleeprqFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockSleeprqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sector kSector() { return {}; }
+  static constexpr FieldMetadata_Sector kSector{};
   void set_sector(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67834,14 +102129,7 @@ class BlockSleeprqFtraceEvent : public ::protozero::Message {
       uint32_t,
       BlockSleeprqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrSector kNrSector() { return {}; }
+  static constexpr FieldMetadata_NrSector kNrSector{};
   void set_nr_sector(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67859,14 +102147,7 @@ class BlockSleeprqFtraceEvent : public ::protozero::Message {
       std::string,
       BlockSleeprqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Rwbs kRwbs() { return {}; }
+  static constexpr FieldMetadata_Rwbs kRwbs{};
   void set_rwbs(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size);
   }
@@ -67890,14 +102171,7 @@ class BlockSleeprqFtraceEvent : public ::protozero::Message {
       std::string,
       BlockSleeprqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
+  static constexpr FieldMetadata_Comm kComm{};
   void set_comm(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
   }
@@ -67914,7 +102188,7 @@ class BlockSleeprqFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BlockRqRequeueFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BlockRqRequeueFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
   BlockRqRequeueFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BlockRqRequeueFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -67955,14 +102229,7 @@ class BlockRqRequeueFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockRqRequeueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -67980,14 +102247,7 @@ class BlockRqRequeueFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockRqRequeueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sector kSector() { return {}; }
+  static constexpr FieldMetadata_Sector kSector{};
   void set_sector(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -68005,14 +102265,7 @@ class BlockRqRequeueFtraceEvent : public ::protozero::Message {
       uint32_t,
       BlockRqRequeueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrSector kNrSector() { return {}; }
+  static constexpr FieldMetadata_NrSector kNrSector{};
   void set_nr_sector(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -68030,14 +102283,7 @@ class BlockRqRequeueFtraceEvent : public ::protozero::Message {
       int32_t,
       BlockRqRequeueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Errors kErrors() { return {}; }
+  static constexpr FieldMetadata_Errors kErrors{};
   void set_errors(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Errors::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -68055,14 +102301,7 @@ class BlockRqRequeueFtraceEvent : public ::protozero::Message {
       std::string,
       BlockRqRequeueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Rwbs kRwbs() { return {}; }
+  static constexpr FieldMetadata_Rwbs kRwbs{};
   void set_rwbs(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size);
   }
@@ -68086,14 +102325,7 @@ class BlockRqRequeueFtraceEvent : public ::protozero::Message {
       std::string,
       BlockRqRequeueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cmd kCmd() { return {}; }
+  static constexpr FieldMetadata_Cmd kCmd{};
   void set_cmd(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Cmd::kFieldId, data, size);
   }
@@ -68110,7 +102342,7 @@ class BlockRqRequeueFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BlockRqRemapFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BlockRqRemapFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
   BlockRqRemapFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BlockRqRemapFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -68154,14 +102386,7 @@ class BlockRqRemapFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockRqRemapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -68179,14 +102404,7 @@ class BlockRqRemapFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockRqRemapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sector kSector() { return {}; }
+  static constexpr FieldMetadata_Sector kSector{};
   void set_sector(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -68204,14 +102422,7 @@ class BlockRqRemapFtraceEvent : public ::protozero::Message {
       uint32_t,
       BlockRqRemapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrSector kNrSector() { return {}; }
+  static constexpr FieldMetadata_NrSector kNrSector{};
   void set_nr_sector(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -68229,14 +102440,7 @@ class BlockRqRemapFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockRqRemapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OldDev kOldDev() { return {}; }
+  static constexpr FieldMetadata_OldDev kOldDev{};
   void set_old_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_OldDev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -68254,14 +102458,7 @@ class BlockRqRemapFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockRqRemapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OldSector kOldSector() { return {}; }
+  static constexpr FieldMetadata_OldSector kOldSector{};
   void set_old_sector(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_OldSector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -68279,14 +102476,7 @@ class BlockRqRemapFtraceEvent : public ::protozero::Message {
       uint32_t,
       BlockRqRemapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrBios kNrBios() { return {}; }
+  static constexpr FieldMetadata_NrBios kNrBios{};
   void set_nr_bios(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrBios::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -68304,14 +102494,7 @@ class BlockRqRemapFtraceEvent : public ::protozero::Message {
       std::string,
       BlockRqRemapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Rwbs kRwbs() { return {}; }
+  static constexpr FieldMetadata_Rwbs kRwbs{};
   void set_rwbs(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size);
   }
@@ -68328,7 +102511,7 @@ class BlockRqRemapFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BlockRqInsertFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BlockRqInsertFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
   BlockRqInsertFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BlockRqInsertFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -68372,14 +102555,7 @@ class BlockRqInsertFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockRqInsertFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -68397,14 +102573,7 @@ class BlockRqInsertFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockRqInsertFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sector kSector() { return {}; }
+  static constexpr FieldMetadata_Sector kSector{};
   void set_sector(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -68422,14 +102591,7 @@ class BlockRqInsertFtraceEvent : public ::protozero::Message {
       uint32_t,
       BlockRqInsertFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrSector kNrSector() { return {}; }
+  static constexpr FieldMetadata_NrSector kNrSector{};
   void set_nr_sector(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -68447,14 +102609,7 @@ class BlockRqInsertFtraceEvent : public ::protozero::Message {
       uint32_t,
       BlockRqInsertFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Bytes kBytes() { return {}; }
+  static constexpr FieldMetadata_Bytes kBytes{};
   void set_bytes(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Bytes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -68472,14 +102627,7 @@ class BlockRqInsertFtraceEvent : public ::protozero::Message {
       std::string,
       BlockRqInsertFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Rwbs kRwbs() { return {}; }
+  static constexpr FieldMetadata_Rwbs kRwbs{};
   void set_rwbs(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size);
   }
@@ -68503,14 +102651,7 @@ class BlockRqInsertFtraceEvent : public ::protozero::Message {
       std::string,
       BlockRqInsertFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
+  static constexpr FieldMetadata_Comm kComm{};
   void set_comm(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
   }
@@ -68534,14 +102675,7 @@ class BlockRqInsertFtraceEvent : public ::protozero::Message {
       std::string,
       BlockRqInsertFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cmd kCmd() { return {}; }
+  static constexpr FieldMetadata_Cmd kCmd{};
   void set_cmd(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Cmd::kFieldId, data, size);
   }
@@ -68558,7 +102692,7 @@ class BlockRqInsertFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BlockRqCompleteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BlockRqCompleteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
   BlockRqCompleteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BlockRqCompleteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -68602,14 +102736,7 @@ class BlockRqCompleteFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockRqCompleteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -68627,14 +102754,7 @@ class BlockRqCompleteFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockRqCompleteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sector kSector() { return {}; }
+  static constexpr FieldMetadata_Sector kSector{};
   void set_sector(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -68652,14 +102772,7 @@ class BlockRqCompleteFtraceEvent : public ::protozero::Message {
       uint32_t,
       BlockRqCompleteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrSector kNrSector() { return {}; }
+  static constexpr FieldMetadata_NrSector kNrSector{};
   void set_nr_sector(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -68677,14 +102790,7 @@ class BlockRqCompleteFtraceEvent : public ::protozero::Message {
       int32_t,
       BlockRqCompleteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Errors kErrors() { return {}; }
+  static constexpr FieldMetadata_Errors kErrors{};
   void set_errors(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Errors::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -68702,14 +102808,7 @@ class BlockRqCompleteFtraceEvent : public ::protozero::Message {
       std::string,
       BlockRqCompleteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Rwbs kRwbs() { return {}; }
+  static constexpr FieldMetadata_Rwbs kRwbs{};
   void set_rwbs(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size);
   }
@@ -68733,14 +102832,7 @@ class BlockRqCompleteFtraceEvent : public ::protozero::Message {
       std::string,
       BlockRqCompleteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cmd kCmd() { return {}; }
+  static constexpr FieldMetadata_Cmd kCmd{};
   void set_cmd(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Cmd::kFieldId, data, size);
   }
@@ -68764,14 +102856,7 @@ class BlockRqCompleteFtraceEvent : public ::protozero::Message {
       int32_t,
       BlockRqCompleteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Error kError() { return {}; }
+  static constexpr FieldMetadata_Error kError{};
   void set_error(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -68782,7 +102867,7 @@ class BlockRqCompleteFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BlockRqAbortFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BlockRqAbortFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
   BlockRqAbortFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BlockRqAbortFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -68823,14 +102908,7 @@ class BlockRqAbortFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockRqAbortFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -68848,14 +102926,7 @@ class BlockRqAbortFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockRqAbortFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sector kSector() { return {}; }
+  static constexpr FieldMetadata_Sector kSector{};
   void set_sector(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -68873,14 +102944,7 @@ class BlockRqAbortFtraceEvent : public ::protozero::Message {
       uint32_t,
       BlockRqAbortFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrSector kNrSector() { return {}; }
+  static constexpr FieldMetadata_NrSector kNrSector{};
   void set_nr_sector(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -68898,14 +102962,7 @@ class BlockRqAbortFtraceEvent : public ::protozero::Message {
       int32_t,
       BlockRqAbortFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Errors kErrors() { return {}; }
+  static constexpr FieldMetadata_Errors kErrors{};
   void set_errors(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Errors::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -68923,14 +102980,7 @@ class BlockRqAbortFtraceEvent : public ::protozero::Message {
       std::string,
       BlockRqAbortFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Rwbs kRwbs() { return {}; }
+  static constexpr FieldMetadata_Rwbs kRwbs{};
   void set_rwbs(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size);
   }
@@ -68954,14 +103004,7 @@ class BlockRqAbortFtraceEvent : public ::protozero::Message {
       std::string,
       BlockRqAbortFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cmd kCmd() { return {}; }
+  static constexpr FieldMetadata_Cmd kCmd{};
   void set_cmd(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Cmd::kFieldId, data, size);
   }
@@ -68978,7 +103021,7 @@ class BlockRqAbortFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BlockPlugFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BlockPlugFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
   BlockPlugFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BlockPlugFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -69004,14 +103047,7 @@ class BlockPlugFtraceEvent : public ::protozero::Message {
       std::string,
       BlockPlugFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
+  static constexpr FieldMetadata_Comm kComm{};
   void set_comm(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
   }
@@ -69028,7 +103064,7 @@ class BlockPlugFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BlockGetrqFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BlockGetrqFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
   BlockGetrqFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BlockGetrqFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -69066,14 +103102,7 @@ class BlockGetrqFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockGetrqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -69091,14 +103120,7 @@ class BlockGetrqFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockGetrqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sector kSector() { return {}; }
+  static constexpr FieldMetadata_Sector kSector{};
   void set_sector(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -69116,14 +103138,7 @@ class BlockGetrqFtraceEvent : public ::protozero::Message {
       uint32_t,
       BlockGetrqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrSector kNrSector() { return {}; }
+  static constexpr FieldMetadata_NrSector kNrSector{};
   void set_nr_sector(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -69141,14 +103156,7 @@ class BlockGetrqFtraceEvent : public ::protozero::Message {
       std::string,
       BlockGetrqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Rwbs kRwbs() { return {}; }
+  static constexpr FieldMetadata_Rwbs kRwbs{};
   void set_rwbs(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size);
   }
@@ -69172,14 +103180,7 @@ class BlockGetrqFtraceEvent : public ::protozero::Message {
       std::string,
       BlockGetrqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
+  static constexpr FieldMetadata_Comm kComm{};
   void set_comm(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
   }
@@ -69196,7 +103197,7 @@ class BlockGetrqFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BlockDirtyBufferFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BlockDirtyBufferFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
   BlockDirtyBufferFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BlockDirtyBufferFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -69228,14 +103229,7 @@ class BlockDirtyBufferFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockDirtyBufferFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -69253,14 +103247,7 @@ class BlockDirtyBufferFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockDirtyBufferFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sector kSector() { return {}; }
+  static constexpr FieldMetadata_Sector kSector{};
   void set_sector(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -69278,14 +103265,7 @@ class BlockDirtyBufferFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockDirtyBufferFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Size kSize() { return {}; }
+  static constexpr FieldMetadata_Size kSize{};
   void set_size(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -69296,7 +103276,7 @@ class BlockDirtyBufferFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BlockBioRemapFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BlockBioRemapFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
   BlockBioRemapFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BlockBioRemapFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -69337,14 +103317,7 @@ class BlockBioRemapFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockBioRemapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -69362,14 +103335,7 @@ class BlockBioRemapFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockBioRemapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sector kSector() { return {}; }
+  static constexpr FieldMetadata_Sector kSector{};
   void set_sector(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -69387,14 +103353,7 @@ class BlockBioRemapFtraceEvent : public ::protozero::Message {
       uint32_t,
       BlockBioRemapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrSector kNrSector() { return {}; }
+  static constexpr FieldMetadata_NrSector kNrSector{};
   void set_nr_sector(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -69412,14 +103371,7 @@ class BlockBioRemapFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockBioRemapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OldDev kOldDev() { return {}; }
+  static constexpr FieldMetadata_OldDev kOldDev{};
   void set_old_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_OldDev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -69437,14 +103389,7 @@ class BlockBioRemapFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockBioRemapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OldSector kOldSector() { return {}; }
+  static constexpr FieldMetadata_OldSector kOldSector{};
   void set_old_sector(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_OldSector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -69462,14 +103407,7 @@ class BlockBioRemapFtraceEvent : public ::protozero::Message {
       std::string,
       BlockBioRemapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Rwbs kRwbs() { return {}; }
+  static constexpr FieldMetadata_Rwbs kRwbs{};
   void set_rwbs(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size);
   }
@@ -69486,7 +103424,7 @@ class BlockBioRemapFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BlockBioQueueFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BlockBioQueueFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
   BlockBioQueueFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BlockBioQueueFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -69524,14 +103462,7 @@ class BlockBioQueueFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockBioQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -69549,14 +103480,7 @@ class BlockBioQueueFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockBioQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sector kSector() { return {}; }
+  static constexpr FieldMetadata_Sector kSector{};
   void set_sector(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -69574,14 +103498,7 @@ class BlockBioQueueFtraceEvent : public ::protozero::Message {
       uint32_t,
       BlockBioQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrSector kNrSector() { return {}; }
+  static constexpr FieldMetadata_NrSector kNrSector{};
   void set_nr_sector(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -69599,14 +103516,7 @@ class BlockBioQueueFtraceEvent : public ::protozero::Message {
       std::string,
       BlockBioQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Rwbs kRwbs() { return {}; }
+  static constexpr FieldMetadata_Rwbs kRwbs{};
   void set_rwbs(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size);
   }
@@ -69630,14 +103540,7 @@ class BlockBioQueueFtraceEvent : public ::protozero::Message {
       std::string,
       BlockBioQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
+  static constexpr FieldMetadata_Comm kComm{};
   void set_comm(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
   }
@@ -69654,7 +103557,7 @@ class BlockBioQueueFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BlockBioFrontmergeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BlockBioFrontmergeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
   BlockBioFrontmergeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BlockBioFrontmergeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -69692,14 +103595,7 @@ class BlockBioFrontmergeFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockBioFrontmergeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -69717,14 +103613,7 @@ class BlockBioFrontmergeFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockBioFrontmergeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sector kSector() { return {}; }
+  static constexpr FieldMetadata_Sector kSector{};
   void set_sector(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -69742,14 +103631,7 @@ class BlockBioFrontmergeFtraceEvent : public ::protozero::Message {
       uint32_t,
       BlockBioFrontmergeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrSector kNrSector() { return {}; }
+  static constexpr FieldMetadata_NrSector kNrSector{};
   void set_nr_sector(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -69767,14 +103649,7 @@ class BlockBioFrontmergeFtraceEvent : public ::protozero::Message {
       std::string,
       BlockBioFrontmergeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Rwbs kRwbs() { return {}; }
+  static constexpr FieldMetadata_Rwbs kRwbs{};
   void set_rwbs(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size);
   }
@@ -69798,14 +103673,7 @@ class BlockBioFrontmergeFtraceEvent : public ::protozero::Message {
       std::string,
       BlockBioFrontmergeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
+  static constexpr FieldMetadata_Comm kComm{};
   void set_comm(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
   }
@@ -69822,7 +103690,7 @@ class BlockBioFrontmergeFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BlockBioCompleteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BlockBioCompleteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
   BlockBioCompleteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BlockBioCompleteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -69860,14 +103728,7 @@ class BlockBioCompleteFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockBioCompleteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -69885,14 +103746,7 @@ class BlockBioCompleteFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockBioCompleteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sector kSector() { return {}; }
+  static constexpr FieldMetadata_Sector kSector{};
   void set_sector(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -69910,14 +103764,7 @@ class BlockBioCompleteFtraceEvent : public ::protozero::Message {
       uint32_t,
       BlockBioCompleteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrSector kNrSector() { return {}; }
+  static constexpr FieldMetadata_NrSector kNrSector{};
   void set_nr_sector(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -69935,14 +103782,7 @@ class BlockBioCompleteFtraceEvent : public ::protozero::Message {
       int32_t,
       BlockBioCompleteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Error kError() { return {}; }
+  static constexpr FieldMetadata_Error kError{};
   void set_error(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -69960,14 +103800,7 @@ class BlockBioCompleteFtraceEvent : public ::protozero::Message {
       std::string,
       BlockBioCompleteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Rwbs kRwbs() { return {}; }
+  static constexpr FieldMetadata_Rwbs kRwbs{};
   void set_rwbs(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size);
   }
@@ -69984,7 +103817,7 @@ class BlockBioCompleteFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BlockBioBounceFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BlockBioBounceFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
   BlockBioBounceFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BlockBioBounceFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -70022,14 +103855,7 @@ class BlockBioBounceFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockBioBounceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -70047,14 +103873,7 @@ class BlockBioBounceFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockBioBounceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sector kSector() { return {}; }
+  static constexpr FieldMetadata_Sector kSector{};
   void set_sector(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -70072,14 +103891,7 @@ class BlockBioBounceFtraceEvent : public ::protozero::Message {
       uint32_t,
       BlockBioBounceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrSector kNrSector() { return {}; }
+  static constexpr FieldMetadata_NrSector kNrSector{};
   void set_nr_sector(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -70097,14 +103909,7 @@ class BlockBioBounceFtraceEvent : public ::protozero::Message {
       std::string,
       BlockBioBounceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Rwbs kRwbs() { return {}; }
+  static constexpr FieldMetadata_Rwbs kRwbs{};
   void set_rwbs(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size);
   }
@@ -70128,14 +103933,7 @@ class BlockBioBounceFtraceEvent : public ::protozero::Message {
       std::string,
       BlockBioBounceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
+  static constexpr FieldMetadata_Comm kComm{};
   void set_comm(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
   }
@@ -70152,7 +103950,7 @@ class BlockBioBounceFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BlockBioBackmergeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BlockBioBackmergeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
   BlockBioBackmergeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BlockBioBackmergeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -70190,14 +103988,7 @@ class BlockBioBackmergeFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockBioBackmergeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -70215,14 +104006,7 @@ class BlockBioBackmergeFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockBioBackmergeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sector kSector() { return {}; }
+  static constexpr FieldMetadata_Sector kSector{};
   void set_sector(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -70240,14 +104024,7 @@ class BlockBioBackmergeFtraceEvent : public ::protozero::Message {
       uint32_t,
       BlockBioBackmergeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrSector kNrSector() { return {}; }
+  static constexpr FieldMetadata_NrSector kNrSector{};
   void set_nr_sector(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -70265,14 +104042,7 @@ class BlockBioBackmergeFtraceEvent : public ::protozero::Message {
       std::string,
       BlockBioBackmergeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Rwbs kRwbs() { return {}; }
+  static constexpr FieldMetadata_Rwbs kRwbs{};
   void set_rwbs(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size);
   }
@@ -70296,14 +104066,7 @@ class BlockBioBackmergeFtraceEvent : public ::protozero::Message {
       std::string,
       BlockBioBackmergeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
+  static constexpr FieldMetadata_Comm kComm{};
   void set_comm(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
   }
@@ -70320,7 +104083,7 @@ class BlockBioBackmergeFtraceEvent : public ::protozero::Message {
   }
 };
 
-class BlockRqIssueFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BlockRqIssueFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
   BlockRqIssueFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit BlockRqIssueFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -70364,14 +104127,7 @@ class BlockRqIssueFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockRqIssueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -70389,14 +104145,7 @@ class BlockRqIssueFtraceEvent : public ::protozero::Message {
       uint64_t,
       BlockRqIssueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sector kSector() { return {}; }
+  static constexpr FieldMetadata_Sector kSector{};
   void set_sector(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -70414,14 +104163,7 @@ class BlockRqIssueFtraceEvent : public ::protozero::Message {
       uint32_t,
       BlockRqIssueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrSector kNrSector() { return {}; }
+  static constexpr FieldMetadata_NrSector kNrSector{};
   void set_nr_sector(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -70439,14 +104181,7 @@ class BlockRqIssueFtraceEvent : public ::protozero::Message {
       uint32_t,
       BlockRqIssueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Bytes kBytes() { return {}; }
+  static constexpr FieldMetadata_Bytes kBytes{};
   void set_bytes(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Bytes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -70464,14 +104199,7 @@ class BlockRqIssueFtraceEvent : public ::protozero::Message {
       std::string,
       BlockRqIssueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Rwbs kRwbs() { return {}; }
+  static constexpr FieldMetadata_Rwbs kRwbs{};
   void set_rwbs(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size);
   }
@@ -70495,14 +104223,7 @@ class BlockRqIssueFtraceEvent : public ::protozero::Message {
       std::string,
       BlockRqIssueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
+  static constexpr FieldMetadata_Comm kComm{};
   void set_comm(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
   }
@@ -70526,14 +104247,7 @@ class BlockRqIssueFtraceEvent : public ::protozero::Message {
       std::string,
       BlockRqIssueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cmd kCmd() { return {}; }
+  static constexpr FieldMetadata_Cmd kCmd{};
   void set_cmd(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Cmd::kFieldId, data, size);
   }
@@ -70569,12 +104283,12 @@ class BlockRqIssueFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class CgroupSetupRootFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class CgroupSetupRootFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
   CgroupSetupRootFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit CgroupSetupRootFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -70606,14 +104320,7 @@ class CgroupSetupRootFtraceEvent : public ::protozero::Message {
       int32_t,
       CgroupSetupRootFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Root kRoot() { return {}; }
+  static constexpr FieldMetadata_Root kRoot{};
   void set_root(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Root::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -70631,14 +104338,7 @@ class CgroupSetupRootFtraceEvent : public ::protozero::Message {
       uint32_t,
       CgroupSetupRootFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SsMask kSsMask() { return {}; }
+  static constexpr FieldMetadata_SsMask kSsMask{};
   void set_ss_mask(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_SsMask::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -70656,14 +104356,7 @@ class CgroupSetupRootFtraceEvent : public ::protozero::Message {
       std::string,
       CgroupSetupRootFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -70680,7 +104373,7 @@ class CgroupSetupRootFtraceEvent : public ::protozero::Message {
   }
 };
 
-class CgroupRenameFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class CgroupRenameFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
   CgroupRenameFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit CgroupRenameFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -70718,14 +104411,7 @@ class CgroupRenameFtraceEvent : public ::protozero::Message {
       int32_t,
       CgroupRenameFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Root kRoot() { return {}; }
+  static constexpr FieldMetadata_Root kRoot{};
   void set_root(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Root::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -70743,14 +104429,7 @@ class CgroupRenameFtraceEvent : public ::protozero::Message {
       int32_t,
       CgroupRenameFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
+  static constexpr FieldMetadata_Id kId{};
   void set_id(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -70768,14 +104447,7 @@ class CgroupRenameFtraceEvent : public ::protozero::Message {
       std::string,
       CgroupRenameFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cname kCname() { return {}; }
+  static constexpr FieldMetadata_Cname kCname{};
   void set_cname(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Cname::kFieldId, data, size);
   }
@@ -70799,14 +104471,7 @@ class CgroupRenameFtraceEvent : public ::protozero::Message {
       int32_t,
       CgroupRenameFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Level kLevel() { return {}; }
+  static constexpr FieldMetadata_Level kLevel{};
   void set_level(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -70824,14 +104489,7 @@ class CgroupRenameFtraceEvent : public ::protozero::Message {
       std::string,
       CgroupRenameFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Path kPath() { return {}; }
+  static constexpr FieldMetadata_Path kPath{};
   void set_path(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Path::kFieldId, data, size);
   }
@@ -70848,7 +104506,7 @@ class CgroupRenameFtraceEvent : public ::protozero::Message {
   }
 };
 
-class CgroupReleaseFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class CgroupReleaseFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
   CgroupReleaseFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit CgroupReleaseFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -70886,14 +104544,7 @@ class CgroupReleaseFtraceEvent : public ::protozero::Message {
       int32_t,
       CgroupReleaseFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Root kRoot() { return {}; }
+  static constexpr FieldMetadata_Root kRoot{};
   void set_root(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Root::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -70911,14 +104562,7 @@ class CgroupReleaseFtraceEvent : public ::protozero::Message {
       int32_t,
       CgroupReleaseFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
+  static constexpr FieldMetadata_Id kId{};
   void set_id(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -70936,14 +104580,7 @@ class CgroupReleaseFtraceEvent : public ::protozero::Message {
       std::string,
       CgroupReleaseFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cname kCname() { return {}; }
+  static constexpr FieldMetadata_Cname kCname{};
   void set_cname(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Cname::kFieldId, data, size);
   }
@@ -70967,14 +104604,7 @@ class CgroupReleaseFtraceEvent : public ::protozero::Message {
       int32_t,
       CgroupReleaseFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Level kLevel() { return {}; }
+  static constexpr FieldMetadata_Level kLevel{};
   void set_level(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -70992,14 +104622,7 @@ class CgroupReleaseFtraceEvent : public ::protozero::Message {
       std::string,
       CgroupReleaseFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Path kPath() { return {}; }
+  static constexpr FieldMetadata_Path kPath{};
   void set_path(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Path::kFieldId, data, size);
   }
@@ -71016,7 +104639,7 @@ class CgroupReleaseFtraceEvent : public ::protozero::Message {
   }
 };
 
-class CgroupDestroyRootFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class CgroupDestroyRootFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
   CgroupDestroyRootFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit CgroupDestroyRootFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -71048,14 +104671,7 @@ class CgroupDestroyRootFtraceEvent : public ::protozero::Message {
       int32_t,
       CgroupDestroyRootFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Root kRoot() { return {}; }
+  static constexpr FieldMetadata_Root kRoot{};
   void set_root(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Root::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -71073,14 +104689,7 @@ class CgroupDestroyRootFtraceEvent : public ::protozero::Message {
       uint32_t,
       CgroupDestroyRootFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SsMask kSsMask() { return {}; }
+  static constexpr FieldMetadata_SsMask kSsMask{};
   void set_ss_mask(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_SsMask::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -71098,14 +104707,7 @@ class CgroupDestroyRootFtraceEvent : public ::protozero::Message {
       std::string,
       CgroupDestroyRootFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -71122,7 +104724,7 @@ class CgroupDestroyRootFtraceEvent : public ::protozero::Message {
   }
 };
 
-class CgroupTransferTasksFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class CgroupTransferTasksFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
   CgroupTransferTasksFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit CgroupTransferTasksFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -71166,14 +104768,7 @@ class CgroupTransferTasksFtraceEvent : public ::protozero::Message {
       int32_t,
       CgroupTransferTasksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DstRoot kDstRoot() { return {}; }
+  static constexpr FieldMetadata_DstRoot kDstRoot{};
   void set_dst_root(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_DstRoot::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -71191,14 +104786,7 @@ class CgroupTransferTasksFtraceEvent : public ::protozero::Message {
       int32_t,
       CgroupTransferTasksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DstId kDstId() { return {}; }
+  static constexpr FieldMetadata_DstId kDstId{};
   void set_dst_id(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_DstId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -71216,14 +104804,7 @@ class CgroupTransferTasksFtraceEvent : public ::protozero::Message {
       int32_t,
       CgroupTransferTasksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
+  static constexpr FieldMetadata_Pid kPid{};
   void set_pid(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -71241,14 +104822,7 @@ class CgroupTransferTasksFtraceEvent : public ::protozero::Message {
       std::string,
       CgroupTransferTasksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
+  static constexpr FieldMetadata_Comm kComm{};
   void set_comm(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
   }
@@ -71272,14 +104846,7 @@ class CgroupTransferTasksFtraceEvent : public ::protozero::Message {
       std::string,
       CgroupTransferTasksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cname kCname() { return {}; }
+  static constexpr FieldMetadata_Cname kCname{};
   void set_cname(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Cname::kFieldId, data, size);
   }
@@ -71303,14 +104870,7 @@ class CgroupTransferTasksFtraceEvent : public ::protozero::Message {
       int32_t,
       CgroupTransferTasksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DstLevel kDstLevel() { return {}; }
+  static constexpr FieldMetadata_DstLevel kDstLevel{};
   void set_dst_level(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_DstLevel::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -71328,14 +104888,7 @@ class CgroupTransferTasksFtraceEvent : public ::protozero::Message {
       std::string,
       CgroupTransferTasksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DstPath kDstPath() { return {}; }
+  static constexpr FieldMetadata_DstPath kDstPath{};
   void set_dst_path(const char* data, size_t size) {
     AppendBytes(FieldMetadata_DstPath::kFieldId, data, size);
   }
@@ -71352,7 +104905,7 @@ class CgroupTransferTasksFtraceEvent : public ::protozero::Message {
   }
 };
 
-class CgroupRmdirFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class CgroupRmdirFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
   CgroupRmdirFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit CgroupRmdirFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -71390,14 +104943,7 @@ class CgroupRmdirFtraceEvent : public ::protozero::Message {
       int32_t,
       CgroupRmdirFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Root kRoot() { return {}; }
+  static constexpr FieldMetadata_Root kRoot{};
   void set_root(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Root::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -71415,14 +104961,7 @@ class CgroupRmdirFtraceEvent : public ::protozero::Message {
       int32_t,
       CgroupRmdirFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
+  static constexpr FieldMetadata_Id kId{};
   void set_id(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -71440,14 +104979,7 @@ class CgroupRmdirFtraceEvent : public ::protozero::Message {
       std::string,
       CgroupRmdirFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cname kCname() { return {}; }
+  static constexpr FieldMetadata_Cname kCname{};
   void set_cname(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Cname::kFieldId, data, size);
   }
@@ -71471,14 +105003,7 @@ class CgroupRmdirFtraceEvent : public ::protozero::Message {
       int32_t,
       CgroupRmdirFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Level kLevel() { return {}; }
+  static constexpr FieldMetadata_Level kLevel{};
   void set_level(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -71496,14 +105021,7 @@ class CgroupRmdirFtraceEvent : public ::protozero::Message {
       std::string,
       CgroupRmdirFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Path kPath() { return {}; }
+  static constexpr FieldMetadata_Path kPath{};
   void set_path(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Path::kFieldId, data, size);
   }
@@ -71520,7 +105038,7 @@ class CgroupRmdirFtraceEvent : public ::protozero::Message {
   }
 };
 
-class CgroupRemountFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class CgroupRemountFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
   CgroupRemountFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit CgroupRemountFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -71552,14 +105070,7 @@ class CgroupRemountFtraceEvent : public ::protozero::Message {
       int32_t,
       CgroupRemountFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Root kRoot() { return {}; }
+  static constexpr FieldMetadata_Root kRoot{};
   void set_root(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Root::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -71577,14 +105088,7 @@ class CgroupRemountFtraceEvent : public ::protozero::Message {
       uint32_t,
       CgroupRemountFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SsMask kSsMask() { return {}; }
+  static constexpr FieldMetadata_SsMask kSsMask{};
   void set_ss_mask(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_SsMask::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -71602,14 +105106,7 @@ class CgroupRemountFtraceEvent : public ::protozero::Message {
       std::string,
       CgroupRemountFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -71626,7 +105123,7 @@ class CgroupRemountFtraceEvent : public ::protozero::Message {
   }
 };
 
-class CgroupMkdirFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class CgroupMkdirFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
   CgroupMkdirFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit CgroupMkdirFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -71664,14 +105161,7 @@ class CgroupMkdirFtraceEvent : public ::protozero::Message {
       int32_t,
       CgroupMkdirFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Root kRoot() { return {}; }
+  static constexpr FieldMetadata_Root kRoot{};
   void set_root(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Root::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -71689,14 +105179,7 @@ class CgroupMkdirFtraceEvent : public ::protozero::Message {
       int32_t,
       CgroupMkdirFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
+  static constexpr FieldMetadata_Id kId{};
   void set_id(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -71714,14 +105197,7 @@ class CgroupMkdirFtraceEvent : public ::protozero::Message {
       std::string,
       CgroupMkdirFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cname kCname() { return {}; }
+  static constexpr FieldMetadata_Cname kCname{};
   void set_cname(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Cname::kFieldId, data, size);
   }
@@ -71745,14 +105221,7 @@ class CgroupMkdirFtraceEvent : public ::protozero::Message {
       int32_t,
       CgroupMkdirFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Level kLevel() { return {}; }
+  static constexpr FieldMetadata_Level kLevel{};
   void set_level(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -71770,14 +105239,7 @@ class CgroupMkdirFtraceEvent : public ::protozero::Message {
       std::string,
       CgroupMkdirFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Path kPath() { return {}; }
+  static constexpr FieldMetadata_Path kPath{};
   void set_path(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Path::kFieldId, data, size);
   }
@@ -71794,7 +105256,7 @@ class CgroupMkdirFtraceEvent : public ::protozero::Message {
   }
 };
 
-class CgroupAttachTaskFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class CgroupAttachTaskFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
   CgroupAttachTaskFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit CgroupAttachTaskFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -71838,14 +105300,7 @@ class CgroupAttachTaskFtraceEvent : public ::protozero::Message {
       int32_t,
       CgroupAttachTaskFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DstRoot kDstRoot() { return {}; }
+  static constexpr FieldMetadata_DstRoot kDstRoot{};
   void set_dst_root(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_DstRoot::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -71863,14 +105318,7 @@ class CgroupAttachTaskFtraceEvent : public ::protozero::Message {
       int32_t,
       CgroupAttachTaskFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DstId kDstId() { return {}; }
+  static constexpr FieldMetadata_DstId kDstId{};
   void set_dst_id(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_DstId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -71888,14 +105336,7 @@ class CgroupAttachTaskFtraceEvent : public ::protozero::Message {
       int32_t,
       CgroupAttachTaskFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
+  static constexpr FieldMetadata_Pid kPid{};
   void set_pid(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -71913,14 +105354,7 @@ class CgroupAttachTaskFtraceEvent : public ::protozero::Message {
       std::string,
       CgroupAttachTaskFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
+  static constexpr FieldMetadata_Comm kComm{};
   void set_comm(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
   }
@@ -71944,14 +105378,7 @@ class CgroupAttachTaskFtraceEvent : public ::protozero::Message {
       std::string,
       CgroupAttachTaskFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cname kCname() { return {}; }
+  static constexpr FieldMetadata_Cname kCname{};
   void set_cname(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Cname::kFieldId, data, size);
   }
@@ -71975,14 +105402,7 @@ class CgroupAttachTaskFtraceEvent : public ::protozero::Message {
       int32_t,
       CgroupAttachTaskFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DstLevel kDstLevel() { return {}; }
+  static constexpr FieldMetadata_DstLevel kDstLevel{};
   void set_dst_level(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_DstLevel::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -72000,14 +105420,7 @@ class CgroupAttachTaskFtraceEvent : public ::protozero::Message {
       std::string,
       CgroupAttachTaskFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DstPath kDstPath() { return {}; }
+  static constexpr FieldMetadata_DstPath kDstPath{};
   void set_dst_path(const char* data, size_t size) {
     AppendBytes(FieldMetadata_DstPath::kFieldId, data, size);
   }
@@ -72043,12 +105456,12 @@ class CgroupAttachTaskFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class ClkSetRateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class ClkSetRateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
   ClkSetRateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit ClkSetRateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -72077,14 +105490,7 @@ class ClkSetRateFtraceEvent : public ::protozero::Message {
       std::string,
       ClkSetRateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -72108,14 +105514,7 @@ class ClkSetRateFtraceEvent : public ::protozero::Message {
       uint64_t,
       ClkSetRateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Rate kRate() { return {}; }
+  static constexpr FieldMetadata_Rate kRate{};
   void set_rate(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Rate::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -72126,7 +105525,7 @@ class ClkSetRateFtraceEvent : public ::protozero::Message {
   }
 };
 
-class ClkDisableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class ClkDisableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
   ClkDisableFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit ClkDisableFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -72152,14 +105551,7 @@ class ClkDisableFtraceEvent : public ::protozero::Message {
       std::string,
       ClkDisableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -72176,7 +105568,7 @@ class ClkDisableFtraceEvent : public ::protozero::Message {
   }
 };
 
-class ClkEnableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class ClkEnableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
   ClkEnableFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit ClkEnableFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -72202,14 +105594,7 @@ class ClkEnableFtraceEvent : public ::protozero::Message {
       std::string,
       ClkEnableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -72245,12 +105630,160 @@ class ClkEnableFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
+class CmaAllocFinishFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
+ public:
+  CmaAllocFinishFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit CmaAllocFinishFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit CmaAllocFinishFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_pfn() const { return at<2>().valid(); }
+  uint64_t pfn() const { return at<2>().as_uint64(); }
+  bool has_page() const { return at<3>().valid(); }
+  uint64_t page() const { return at<3>().as_uint64(); }
+  bool has_count() const { return at<4>().valid(); }
+  uint64_t count() const { return at<4>().as_uint64(); }
+  bool has_align() const { return at<5>().valid(); }
+  uint32_t align() const { return at<5>().as_uint32(); }
+  bool has_errorno() const { return at<6>().valid(); }
+  int32_t errorno() const { return at<6>().as_int32(); }
+};
+
+class CmaAllocFinishFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = CmaAllocFinishFtraceEvent_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kPfnFieldNumber = 2,
+    kPageFieldNumber = 3,
+    kCountFieldNumber = 4,
+    kAlignFieldNumber = 5,
+    kErrornoFieldNumber = 6,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.CmaAllocFinishFtraceEvent"; }
+
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      CmaAllocFinishFtraceEvent>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Pfn =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      CmaAllocFinishFtraceEvent>;
+
+  static constexpr FieldMetadata_Pfn kPfn{};
+  void set_pfn(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Page =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      CmaAllocFinishFtraceEvent>;
+
+  static constexpr FieldMetadata_Page kPage{};
+  void set_page(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Count =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      CmaAllocFinishFtraceEvent>;
+
+  static constexpr FieldMetadata_Count kCount{};
+  void set_count(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Align =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      CmaAllocFinishFtraceEvent>;
+
+  static constexpr FieldMetadata_Align kAlign{};
+  void set_align(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Align::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Errorno =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      CmaAllocFinishFtraceEvent>;
 
-class CmaAllocInfoFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+  static constexpr FieldMetadata_Errorno kErrorno{};
+  void set_errorno(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Errorno::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class CmaAllocInfoFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10> {
  public:
   CmaAllocInfoFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit CmaAllocInfoFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -72303,14 +105836,7 @@ class CmaAllocInfoFtraceEvent : public ::protozero::Message {
       uint32_t,
       CmaAllocInfoFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Align kAlign() { return {}; }
+  static constexpr FieldMetadata_Align kAlign{};
   void set_align(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Align::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -72328,14 +105854,7 @@ class CmaAllocInfoFtraceEvent : public ::protozero::Message {
       uint32_t,
       CmaAllocInfoFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Count kCount() { return {}; }
+  static constexpr FieldMetadata_Count kCount{};
   void set_count(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -72353,14 +105872,7 @@ class CmaAllocInfoFtraceEvent : public ::protozero::Message {
       uint32_t,
       CmaAllocInfoFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ErrIso kErrIso() { return {}; }
+  static constexpr FieldMetadata_ErrIso kErrIso{};
   void set_err_iso(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ErrIso::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -72378,14 +105890,7 @@ class CmaAllocInfoFtraceEvent : public ::protozero::Message {
       uint32_t,
       CmaAllocInfoFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ErrMig kErrMig() { return {}; }
+  static constexpr FieldMetadata_ErrMig kErrMig{};
   void set_err_mig(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ErrMig::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -72403,14 +105908,7 @@ class CmaAllocInfoFtraceEvent : public ::protozero::Message {
       uint32_t,
       CmaAllocInfoFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ErrTest kErrTest() { return {}; }
+  static constexpr FieldMetadata_ErrTest kErrTest{};
   void set_err_test(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ErrTest::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -72428,14 +105926,7 @@ class CmaAllocInfoFtraceEvent : public ::protozero::Message {
       std::string,
       CmaAllocInfoFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -72459,14 +105950,7 @@ class CmaAllocInfoFtraceEvent : public ::protozero::Message {
       uint64_t,
       CmaAllocInfoFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrMapped kNrMapped() { return {}; }
+  static constexpr FieldMetadata_NrMapped kNrMapped{};
   void set_nr_mapped(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrMapped::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -72484,14 +105968,7 @@ class CmaAllocInfoFtraceEvent : public ::protozero::Message {
       uint64_t,
       CmaAllocInfoFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrMigrated kNrMigrated() { return {}; }
+  static constexpr FieldMetadata_NrMigrated kNrMigrated{};
   void set_nr_migrated(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrMigrated::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -72509,14 +105986,7 @@ class CmaAllocInfoFtraceEvent : public ::protozero::Message {
       uint64_t,
       CmaAllocInfoFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrReclaimed kNrReclaimed() { return {}; }
+  static constexpr FieldMetadata_NrReclaimed kNrReclaimed{};
   void set_nr_reclaimed(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrReclaimed::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -72534,14 +106004,7 @@ class CmaAllocInfoFtraceEvent : public ::protozero::Message {
       uint64_t,
       CmaAllocInfoFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pfn kPfn() { return {}; }
+  static constexpr FieldMetadata_Pfn kPfn{};
   void set_pfn(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -72552,7 +106015,7 @@ class CmaAllocInfoFtraceEvent : public ::protozero::Message {
   }
 };
 
-class CmaAllocStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class CmaAllocStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
   CmaAllocStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit CmaAllocStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -72584,14 +106047,7 @@ class CmaAllocStartFtraceEvent : public ::protozero::Message {
       uint32_t,
       CmaAllocStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Align kAlign() { return {}; }
+  static constexpr FieldMetadata_Align kAlign{};
   void set_align(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Align::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -72609,14 +106065,7 @@ class CmaAllocStartFtraceEvent : public ::protozero::Message {
       uint32_t,
       CmaAllocStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Count kCount() { return {}; }
+  static constexpr FieldMetadata_Count kCount{};
   void set_count(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -72634,14 +106083,7 @@ class CmaAllocStartFtraceEvent : public ::protozero::Message {
       std::string,
       CmaAllocStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -72677,12 +106119,12 @@ class CmaAllocStartFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class MmCompactionWakeupKcompactdFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmCompactionWakeupKcompactdFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
   MmCompactionWakeupKcompactdFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit MmCompactionWakeupKcompactdFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -72717,14 +106159,7 @@ class MmCompactionWakeupKcompactdFtraceEvent : public ::protozero::Message {
       int32_t,
       MmCompactionWakeupKcompactdFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nid kNid() { return {}; }
+  static constexpr FieldMetadata_Nid kNid{};
   void set_nid(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -72742,14 +106177,7 @@ class MmCompactionWakeupKcompactdFtraceEvent : public ::protozero::Message {
       int32_t,
       MmCompactionWakeupKcompactdFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Order kOrder() { return {}; }
+  static constexpr FieldMetadata_Order kOrder{};
   void set_order(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -72767,14 +106195,7 @@ class MmCompactionWakeupKcompactdFtraceEvent : public ::protozero::Message {
       uint32_t,
       MmCompactionWakeupKcompactdFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClasszoneIdx kClasszoneIdx() { return {}; }
+  static constexpr FieldMetadata_ClasszoneIdx kClasszoneIdx{};
   void set_classzone_idx(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ClasszoneIdx::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -72792,14 +106213,7 @@ class MmCompactionWakeupKcompactdFtraceEvent : public ::protozero::Message {
       uint32_t,
       MmCompactionWakeupKcompactdFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HighestZoneidx kHighestZoneidx() { return {}; }
+  static constexpr FieldMetadata_HighestZoneidx kHighestZoneidx{};
   void set_highest_zoneidx(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_HighestZoneidx::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -72810,7 +106224,7 @@ class MmCompactionWakeupKcompactdFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MmCompactionTryToCompactPagesFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmCompactionTryToCompactPagesFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
   MmCompactionTryToCompactPagesFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit MmCompactionTryToCompactPagesFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -72845,14 +106259,7 @@ class MmCompactionTryToCompactPagesFtraceEvent : public ::protozero::Message {
       int32_t,
       MmCompactionTryToCompactPagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Order kOrder() { return {}; }
+  static constexpr FieldMetadata_Order kOrder{};
   void set_order(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -72870,14 +106277,7 @@ class MmCompactionTryToCompactPagesFtraceEvent : public ::protozero::Message {
       uint32_t,
       MmCompactionTryToCompactPagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GfpMask kGfpMask() { return {}; }
+  static constexpr FieldMetadata_GfpMask kGfpMask{};
   void set_gfp_mask(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_GfpMask::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -72895,14 +106295,7 @@ class MmCompactionTryToCompactPagesFtraceEvent : public ::protozero::Message {
       uint32_t,
       MmCompactionTryToCompactPagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mode kMode() { return {}; }
+  static constexpr FieldMetadata_Mode kMode{};
   void set_mode(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -72920,14 +106313,7 @@ class MmCompactionTryToCompactPagesFtraceEvent : public ::protozero::Message {
       int32_t,
       MmCompactionTryToCompactPagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Prio kPrio() { return {}; }
+  static constexpr FieldMetadata_Prio kPrio{};
   void set_prio(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -72938,7 +106324,7 @@ class MmCompactionTryToCompactPagesFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MmCompactionSuitableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmCompactionSuitableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
   MmCompactionSuitableFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit MmCompactionSuitableFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -72973,14 +106359,7 @@ class MmCompactionSuitableFtraceEvent : public ::protozero::Message {
       int32_t,
       MmCompactionSuitableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nid kNid() { return {}; }
+  static constexpr FieldMetadata_Nid kNid{};
   void set_nid(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -72998,14 +106377,7 @@ class MmCompactionSuitableFtraceEvent : public ::protozero::Message {
       uint32_t,
       MmCompactionSuitableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Idx kIdx() { return {}; }
+  static constexpr FieldMetadata_Idx kIdx{};
   void set_idx(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Idx::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73023,14 +106395,7 @@ class MmCompactionSuitableFtraceEvent : public ::protozero::Message {
       int32_t,
       MmCompactionSuitableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Order kOrder() { return {}; }
+  static constexpr FieldMetadata_Order kOrder{};
   void set_order(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73048,14 +106413,7 @@ class MmCompactionSuitableFtraceEvent : public ::protozero::Message {
       int32_t,
       MmCompactionSuitableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
+  static constexpr FieldMetadata_Ret kRet{};
   void set_ret(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73066,7 +106424,7 @@ class MmCompactionSuitableFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MmCompactionMigratepagesFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmCompactionMigratepagesFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
   MmCompactionMigratepagesFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit MmCompactionMigratepagesFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -73095,14 +106453,7 @@ class MmCompactionMigratepagesFtraceEvent : public ::protozero::Message {
       uint64_t,
       MmCompactionMigratepagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrMigrated kNrMigrated() { return {}; }
+  static constexpr FieldMetadata_NrMigrated kNrMigrated{};
   void set_nr_migrated(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrMigrated::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73120,14 +106471,7 @@ class MmCompactionMigratepagesFtraceEvent : public ::protozero::Message {
       uint64_t,
       MmCompactionMigratepagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrFailed kNrFailed() { return {}; }
+  static constexpr FieldMetadata_NrFailed kNrFailed{};
   void set_nr_failed(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrFailed::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73138,7 +106482,7 @@ class MmCompactionMigratepagesFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MmCompactionKcompactdWakeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmCompactionKcompactdWakeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
   MmCompactionKcompactdWakeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit MmCompactionKcompactdWakeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -73173,14 +106517,7 @@ class MmCompactionKcompactdWakeFtraceEvent : public ::protozero::Message {
       int32_t,
       MmCompactionKcompactdWakeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nid kNid() { return {}; }
+  static constexpr FieldMetadata_Nid kNid{};
   void set_nid(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73198,14 +106535,7 @@ class MmCompactionKcompactdWakeFtraceEvent : public ::protozero::Message {
       int32_t,
       MmCompactionKcompactdWakeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Order kOrder() { return {}; }
+  static constexpr FieldMetadata_Order kOrder{};
   void set_order(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73223,14 +106553,7 @@ class MmCompactionKcompactdWakeFtraceEvent : public ::protozero::Message {
       uint32_t,
       MmCompactionKcompactdWakeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClasszoneIdx kClasszoneIdx() { return {}; }
+  static constexpr FieldMetadata_ClasszoneIdx kClasszoneIdx{};
   void set_classzone_idx(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ClasszoneIdx::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73248,14 +106571,7 @@ class MmCompactionKcompactdWakeFtraceEvent : public ::protozero::Message {
       uint32_t,
       MmCompactionKcompactdWakeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HighestZoneidx kHighestZoneidx() { return {}; }
+  static constexpr FieldMetadata_HighestZoneidx kHighestZoneidx{};
   void set_highest_zoneidx(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_HighestZoneidx::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73266,7 +106582,7 @@ class MmCompactionKcompactdWakeFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MmCompactionKcompactdSleepFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmCompactionKcompactdSleepFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
   MmCompactionKcompactdSleepFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit MmCompactionKcompactdSleepFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -73292,14 +106608,7 @@ class MmCompactionKcompactdSleepFtraceEvent : public ::protozero::Message {
       int32_t,
       MmCompactionKcompactdSleepFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nid kNid() { return {}; }
+  static constexpr FieldMetadata_Nid kNid{};
   void set_nid(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73310,7 +106619,7 @@ class MmCompactionKcompactdSleepFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MmCompactionIsolateMigratepagesFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmCompactionIsolateMigratepagesFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
   MmCompactionIsolateMigratepagesFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit MmCompactionIsolateMigratepagesFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -73345,14 +106654,7 @@ class MmCompactionIsolateMigratepagesFtraceEvent : public ::protozero::Message {
       uint64_t,
       MmCompactionIsolateMigratepagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StartPfn kStartPfn() { return {}; }
+  static constexpr FieldMetadata_StartPfn kStartPfn{};
   void set_start_pfn(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_StartPfn::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73370,14 +106672,7 @@ class MmCompactionIsolateMigratepagesFtraceEvent : public ::protozero::Message {
       uint64_t,
       MmCompactionIsolateMigratepagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EndPfn kEndPfn() { return {}; }
+  static constexpr FieldMetadata_EndPfn kEndPfn{};
   void set_end_pfn(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_EndPfn::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73395,14 +106690,7 @@ class MmCompactionIsolateMigratepagesFtraceEvent : public ::protozero::Message {
       uint64_t,
       MmCompactionIsolateMigratepagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrScanned kNrScanned() { return {}; }
+  static constexpr FieldMetadata_NrScanned kNrScanned{};
   void set_nr_scanned(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrScanned::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73420,14 +106708,7 @@ class MmCompactionIsolateMigratepagesFtraceEvent : public ::protozero::Message {
       uint64_t,
       MmCompactionIsolateMigratepagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrTaken kNrTaken() { return {}; }
+  static constexpr FieldMetadata_NrTaken kNrTaken{};
   void set_nr_taken(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrTaken::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73438,7 +106719,7 @@ class MmCompactionIsolateMigratepagesFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MmCompactionIsolateFreepagesFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmCompactionIsolateFreepagesFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
   MmCompactionIsolateFreepagesFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit MmCompactionIsolateFreepagesFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -73473,14 +106754,7 @@ class MmCompactionIsolateFreepagesFtraceEvent : public ::protozero::Message {
       uint64_t,
       MmCompactionIsolateFreepagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StartPfn kStartPfn() { return {}; }
+  static constexpr FieldMetadata_StartPfn kStartPfn{};
   void set_start_pfn(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_StartPfn::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73498,14 +106772,7 @@ class MmCompactionIsolateFreepagesFtraceEvent : public ::protozero::Message {
       uint64_t,
       MmCompactionIsolateFreepagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EndPfn kEndPfn() { return {}; }
+  static constexpr FieldMetadata_EndPfn kEndPfn{};
   void set_end_pfn(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_EndPfn::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73523,14 +106790,7 @@ class MmCompactionIsolateFreepagesFtraceEvent : public ::protozero::Message {
       uint64_t,
       MmCompactionIsolateFreepagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrScanned kNrScanned() { return {}; }
+  static constexpr FieldMetadata_NrScanned kNrScanned{};
   void set_nr_scanned(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrScanned::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73548,14 +106808,7 @@ class MmCompactionIsolateFreepagesFtraceEvent : public ::protozero::Message {
       uint64_t,
       MmCompactionIsolateFreepagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrTaken kNrTaken() { return {}; }
+  static constexpr FieldMetadata_NrTaken kNrTaken{};
   void set_nr_taken(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_NrTaken::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73566,7 +106819,7 @@ class MmCompactionIsolateFreepagesFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MmCompactionFinishedFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmCompactionFinishedFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
   MmCompactionFinishedFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit MmCompactionFinishedFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -73601,14 +106854,7 @@ class MmCompactionFinishedFtraceEvent : public ::protozero::Message {
       int32_t,
       MmCompactionFinishedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nid kNid() { return {}; }
+  static constexpr FieldMetadata_Nid kNid{};
   void set_nid(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73626,14 +106872,7 @@ class MmCompactionFinishedFtraceEvent : public ::protozero::Message {
       uint32_t,
       MmCompactionFinishedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Idx kIdx() { return {}; }
+  static constexpr FieldMetadata_Idx kIdx{};
   void set_idx(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Idx::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73651,14 +106890,7 @@ class MmCompactionFinishedFtraceEvent : public ::protozero::Message {
       int32_t,
       MmCompactionFinishedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Order kOrder() { return {}; }
+  static constexpr FieldMetadata_Order kOrder{};
   void set_order(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73676,14 +106908,7 @@ class MmCompactionFinishedFtraceEvent : public ::protozero::Message {
       int32_t,
       MmCompactionFinishedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
+  static constexpr FieldMetadata_Ret kRet{};
   void set_ret(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73694,7 +106919,7 @@ class MmCompactionFinishedFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MmCompactionEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmCompactionEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
   MmCompactionEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit MmCompactionEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -73735,14 +106960,7 @@ class MmCompactionEndFtraceEvent : public ::protozero::Message {
       uint64_t,
       MmCompactionEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ZoneStart kZoneStart() { return {}; }
+  static constexpr FieldMetadata_ZoneStart kZoneStart{};
   void set_zone_start(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ZoneStart::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73760,14 +106978,7 @@ class MmCompactionEndFtraceEvent : public ::protozero::Message {
       uint64_t,
       MmCompactionEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MigratePfn kMigratePfn() { return {}; }
+  static constexpr FieldMetadata_MigratePfn kMigratePfn{};
   void set_migrate_pfn(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_MigratePfn::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73785,14 +106996,7 @@ class MmCompactionEndFtraceEvent : public ::protozero::Message {
       uint64_t,
       MmCompactionEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FreePfn kFreePfn() { return {}; }
+  static constexpr FieldMetadata_FreePfn kFreePfn{};
   void set_free_pfn(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_FreePfn::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73810,14 +107014,7 @@ class MmCompactionEndFtraceEvent : public ::protozero::Message {
       uint64_t,
       MmCompactionEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ZoneEnd kZoneEnd() { return {}; }
+  static constexpr FieldMetadata_ZoneEnd kZoneEnd{};
   void set_zone_end(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ZoneEnd::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73835,14 +107032,7 @@ class MmCompactionEndFtraceEvent : public ::protozero::Message {
       uint32_t,
       MmCompactionEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sync kSync() { return {}; }
+  static constexpr FieldMetadata_Sync kSync{};
   void set_sync(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Sync::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73860,14 +107050,7 @@ class MmCompactionEndFtraceEvent : public ::protozero::Message {
       int32_t,
       MmCompactionEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Status kStatus() { return {}; }
+  static constexpr FieldMetadata_Status kStatus{};
   void set_status(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73878,7 +107061,7 @@ class MmCompactionEndFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MmCompactionDeferResetFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmCompactionDeferResetFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
   MmCompactionDeferResetFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit MmCompactionDeferResetFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -73919,14 +107102,7 @@ class MmCompactionDeferResetFtraceEvent : public ::protozero::Message {
       int32_t,
       MmCompactionDeferResetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nid kNid() { return {}; }
+  static constexpr FieldMetadata_Nid kNid{};
   void set_nid(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73944,14 +107120,7 @@ class MmCompactionDeferResetFtraceEvent : public ::protozero::Message {
       uint32_t,
       MmCompactionDeferResetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Idx kIdx() { return {}; }
+  static constexpr FieldMetadata_Idx kIdx{};
   void set_idx(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Idx::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73969,14 +107138,7 @@ class MmCompactionDeferResetFtraceEvent : public ::protozero::Message {
       int32_t,
       MmCompactionDeferResetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Order kOrder() { return {}; }
+  static constexpr FieldMetadata_Order kOrder{};
   void set_order(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -73994,14 +107156,7 @@ class MmCompactionDeferResetFtraceEvent : public ::protozero::Message {
       uint32_t,
       MmCompactionDeferResetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Considered kConsidered() { return {}; }
+  static constexpr FieldMetadata_Considered kConsidered{};
   void set_considered(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Considered::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74019,14 +107174,7 @@ class MmCompactionDeferResetFtraceEvent : public ::protozero::Message {
       uint32_t,
       MmCompactionDeferResetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DeferShift kDeferShift() { return {}; }
+  static constexpr FieldMetadata_DeferShift kDeferShift{};
   void set_defer_shift(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_DeferShift::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74044,14 +107192,7 @@ class MmCompactionDeferResetFtraceEvent : public ::protozero::Message {
       int32_t,
       MmCompactionDeferResetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OrderFailed kOrderFailed() { return {}; }
+  static constexpr FieldMetadata_OrderFailed kOrderFailed{};
   void set_order_failed(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_OrderFailed::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74062,7 +107203,7 @@ class MmCompactionDeferResetFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MmCompactionDeferredFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmCompactionDeferredFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
   MmCompactionDeferredFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit MmCompactionDeferredFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -74103,14 +107244,7 @@ class MmCompactionDeferredFtraceEvent : public ::protozero::Message {
       int32_t,
       MmCompactionDeferredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nid kNid() { return {}; }
+  static constexpr FieldMetadata_Nid kNid{};
   void set_nid(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74128,14 +107262,7 @@ class MmCompactionDeferredFtraceEvent : public ::protozero::Message {
       uint32_t,
       MmCompactionDeferredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Idx kIdx() { return {}; }
+  static constexpr FieldMetadata_Idx kIdx{};
   void set_idx(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Idx::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74153,14 +107280,7 @@ class MmCompactionDeferredFtraceEvent : public ::protozero::Message {
       int32_t,
       MmCompactionDeferredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Order kOrder() { return {}; }
+  static constexpr FieldMetadata_Order kOrder{};
   void set_order(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74178,14 +107298,7 @@ class MmCompactionDeferredFtraceEvent : public ::protozero::Message {
       uint32_t,
       MmCompactionDeferredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Considered kConsidered() { return {}; }
+  static constexpr FieldMetadata_Considered kConsidered{};
   void set_considered(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Considered::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74203,14 +107316,7 @@ class MmCompactionDeferredFtraceEvent : public ::protozero::Message {
       uint32_t,
       MmCompactionDeferredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DeferShift kDeferShift() { return {}; }
+  static constexpr FieldMetadata_DeferShift kDeferShift{};
   void set_defer_shift(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_DeferShift::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74228,14 +107334,7 @@ class MmCompactionDeferredFtraceEvent : public ::protozero::Message {
       int32_t,
       MmCompactionDeferredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OrderFailed kOrderFailed() { return {}; }
+  static constexpr FieldMetadata_OrderFailed kOrderFailed{};
   void set_order_failed(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_OrderFailed::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74246,7 +107345,7 @@ class MmCompactionDeferredFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MmCompactionDeferCompactionFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmCompactionDeferCompactionFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
   MmCompactionDeferCompactionFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit MmCompactionDeferCompactionFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -74287,14 +107386,7 @@ class MmCompactionDeferCompactionFtraceEvent : public ::protozero::Message {
       int32_t,
       MmCompactionDeferCompactionFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nid kNid() { return {}; }
+  static constexpr FieldMetadata_Nid kNid{};
   void set_nid(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74312,14 +107404,7 @@ class MmCompactionDeferCompactionFtraceEvent : public ::protozero::Message {
       uint32_t,
       MmCompactionDeferCompactionFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Idx kIdx() { return {}; }
+  static constexpr FieldMetadata_Idx kIdx{};
   void set_idx(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Idx::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74337,14 +107422,7 @@ class MmCompactionDeferCompactionFtraceEvent : public ::protozero::Message {
       int32_t,
       MmCompactionDeferCompactionFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Order kOrder() { return {}; }
+  static constexpr FieldMetadata_Order kOrder{};
   void set_order(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74362,14 +107440,7 @@ class MmCompactionDeferCompactionFtraceEvent : public ::protozero::Message {
       uint32_t,
       MmCompactionDeferCompactionFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Considered kConsidered() { return {}; }
+  static constexpr FieldMetadata_Considered kConsidered{};
   void set_considered(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Considered::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74387,14 +107458,7 @@ class MmCompactionDeferCompactionFtraceEvent : public ::protozero::Message {
       uint32_t,
       MmCompactionDeferCompactionFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DeferShift kDeferShift() { return {}; }
+  static constexpr FieldMetadata_DeferShift kDeferShift{};
   void set_defer_shift(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_DeferShift::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74412,14 +107476,7 @@ class MmCompactionDeferCompactionFtraceEvent : public ::protozero::Message {
       int32_t,
       MmCompactionDeferCompactionFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OrderFailed kOrderFailed() { return {}; }
+  static constexpr FieldMetadata_OrderFailed kOrderFailed{};
   void set_order_failed(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_OrderFailed::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74430,7 +107487,7 @@ class MmCompactionDeferCompactionFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MmCompactionBeginFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmCompactionBeginFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
   MmCompactionBeginFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit MmCompactionBeginFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -74468,14 +107525,7 @@ class MmCompactionBeginFtraceEvent : public ::protozero::Message {
       uint64_t,
       MmCompactionBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ZoneStart kZoneStart() { return {}; }
+  static constexpr FieldMetadata_ZoneStart kZoneStart{};
   void set_zone_start(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ZoneStart::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74493,14 +107543,7 @@ class MmCompactionBeginFtraceEvent : public ::protozero::Message {
       uint64_t,
       MmCompactionBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MigratePfn kMigratePfn() { return {}; }
+  static constexpr FieldMetadata_MigratePfn kMigratePfn{};
   void set_migrate_pfn(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_MigratePfn::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74518,14 +107561,7 @@ class MmCompactionBeginFtraceEvent : public ::protozero::Message {
       uint64_t,
       MmCompactionBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FreePfn kFreePfn() { return {}; }
+  static constexpr FieldMetadata_FreePfn kFreePfn{};
   void set_free_pfn(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_FreePfn::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74543,14 +107579,7 @@ class MmCompactionBeginFtraceEvent : public ::protozero::Message {
       uint64_t,
       MmCompactionBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ZoneEnd kZoneEnd() { return {}; }
+  static constexpr FieldMetadata_ZoneEnd kZoneEnd{};
   void set_zone_end(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ZoneEnd::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74568,14 +107597,7 @@ class MmCompactionBeginFtraceEvent : public ::protozero::Message {
       uint32_t,
       MmCompactionBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sync kSync() { return {}; }
+  static constexpr FieldMetadata_Sync kSync{};
   void set_sync(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Sync::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74586,6 +107608,115 @@ class MmCompactionBeginFtraceEvent : public ::protozero::Message {
   }
 };
 
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/cpm_trace.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_CPM_TRACE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_CPM_TRACE_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class ParamSetValueCpmFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  ParamSetValueCpmFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ParamSetValueCpmFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ParamSetValueCpmFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_body() const { return at<1>().valid(); }
+  ::protozero::ConstChars body() const { return at<1>().as_string(); }
+  bool has_value() const { return at<2>().valid(); }
+  uint32_t value() const { return at<2>().as_uint32(); }
+  bool has_timestamp() const { return at<3>().valid(); }
+  int64_t timestamp() const { return at<3>().as_int64(); }
+};
+
+class ParamSetValueCpmFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = ParamSetValueCpmFtraceEvent_Decoder;
+  enum : int32_t {
+    kBodyFieldNumber = 1,
+    kValueFieldNumber = 2,
+    kTimestampFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ParamSetValueCpmFtraceEvent"; }
+
+
+  using FieldMetadata_Body =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ParamSetValueCpmFtraceEvent>;
+
+  static constexpr FieldMetadata_Body kBody{};
+  void set_body(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Body::kFieldId, data, size);
+  }
+  void set_body(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Body::kFieldId, chars.data, chars.size);
+  }
+  void set_body(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Body::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ParamSetValueCpmFtraceEvent>;
+
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Timestamp =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ParamSetValueCpmFtraceEvent>;
+
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+};
+
 } // Namespace.
 } // Namespace.
 } // Namespace.
@@ -74605,12 +107736,12 @@ class MmCompactionBeginFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class CpuhpPauseFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class CpuhpPauseFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
   CpuhpPauseFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit CpuhpPauseFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -74645,14 +107776,7 @@ class CpuhpPauseFtraceEvent : public ::protozero::Message {
       uint32_t,
       CpuhpPauseFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ActiveCpus kActiveCpus() { return {}; }
+  static constexpr FieldMetadata_ActiveCpus kActiveCpus{};
   void set_active_cpus(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_ActiveCpus::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74670,14 +107794,7 @@ class CpuhpPauseFtraceEvent : public ::protozero::Message {
       uint32_t,
       CpuhpPauseFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cpus kCpus() { return {}; }
+  static constexpr FieldMetadata_Cpus kCpus{};
   void set_cpus(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Cpus::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74695,14 +107812,7 @@ class CpuhpPauseFtraceEvent : public ::protozero::Message {
       uint32_t,
       CpuhpPauseFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pause kPause() { return {}; }
+  static constexpr FieldMetadata_Pause kPause{};
   void set_pause(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Pause::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74720,14 +107830,7 @@ class CpuhpPauseFtraceEvent : public ::protozero::Message {
       uint32_t,
       CpuhpPauseFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Time kTime() { return {}; }
+  static constexpr FieldMetadata_Time kTime{};
   void set_time(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Time::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74738,7 +107841,7 @@ class CpuhpPauseFtraceEvent : public ::protozero::Message {
   }
 };
 
-class CpuhpLatencyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class CpuhpLatencyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
   CpuhpLatencyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit CpuhpLatencyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -74773,14 +107876,7 @@ class CpuhpLatencyFtraceEvent : public ::protozero::Message {
       uint32_t,
       CpuhpLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cpu kCpu() { return {}; }
+  static constexpr FieldMetadata_Cpu kCpu{};
   void set_cpu(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74798,14 +107894,7 @@ class CpuhpLatencyFtraceEvent : public ::protozero::Message {
       int32_t,
       CpuhpLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
+  static constexpr FieldMetadata_Ret kRet{};
   void set_ret(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74823,14 +107912,7 @@ class CpuhpLatencyFtraceEvent : public ::protozero::Message {
       uint32_t,
       CpuhpLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_State kState() { return {}; }
+  static constexpr FieldMetadata_State kState{};
   void set_state(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74848,14 +107930,7 @@ class CpuhpLatencyFtraceEvent : public ::protozero::Message {
       uint64_t,
       CpuhpLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Time kTime() { return {}; }
+  static constexpr FieldMetadata_Time kTime{};
   void set_time(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Time::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74866,7 +107941,7 @@ class CpuhpLatencyFtraceEvent : public ::protozero::Message {
   }
 };
 
-class CpuhpEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class CpuhpEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
   CpuhpEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit CpuhpEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -74901,14 +107976,7 @@ class CpuhpEnterFtraceEvent : public ::protozero::Message {
       uint32_t,
       CpuhpEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cpu kCpu() { return {}; }
+  static constexpr FieldMetadata_Cpu kCpu{};
   void set_cpu(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74926,14 +107994,7 @@ class CpuhpEnterFtraceEvent : public ::protozero::Message {
       uint64_t,
       CpuhpEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Fun kFun() { return {}; }
+  static constexpr FieldMetadata_Fun kFun{};
   void set_fun(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Fun::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74951,14 +108012,7 @@ class CpuhpEnterFtraceEvent : public ::protozero::Message {
       int32_t,
       CpuhpEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Idx kIdx() { return {}; }
+  static constexpr FieldMetadata_Idx kIdx{};
   void set_idx(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Idx::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74976,14 +108030,7 @@ class CpuhpEnterFtraceEvent : public ::protozero::Message {
       int32_t,
       CpuhpEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Target kTarget() { return {}; }
+  static constexpr FieldMetadata_Target kTarget{};
   void set_target(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Target::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -74994,7 +108041,7 @@ class CpuhpEnterFtraceEvent : public ::protozero::Message {
   }
 };
 
-class CpuhpMultiEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class CpuhpMultiEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
   CpuhpMultiEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit CpuhpMultiEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -75029,14 +108076,7 @@ class CpuhpMultiEnterFtraceEvent : public ::protozero::Message {
       uint32_t,
       CpuhpMultiEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cpu kCpu() { return {}; }
+  static constexpr FieldMetadata_Cpu kCpu{};
   void set_cpu(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -75054,14 +108094,7 @@ class CpuhpMultiEnterFtraceEvent : public ::protozero::Message {
       uint64_t,
       CpuhpMultiEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Fun kFun() { return {}; }
+  static constexpr FieldMetadata_Fun kFun{};
   void set_fun(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Fun::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -75079,14 +108112,7 @@ class CpuhpMultiEnterFtraceEvent : public ::protozero::Message {
       int32_t,
       CpuhpMultiEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Idx kIdx() { return {}; }
+  static constexpr FieldMetadata_Idx kIdx{};
   void set_idx(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Idx::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -75104,14 +108130,7 @@ class CpuhpMultiEnterFtraceEvent : public ::protozero::Message {
       int32_t,
       CpuhpMultiEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Target kTarget() { return {}; }
+  static constexpr FieldMetadata_Target kTarget{};
   void set_target(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Target::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -75122,7 +108141,7 @@ class CpuhpMultiEnterFtraceEvent : public ::protozero::Message {
   }
 };
 
-class CpuhpExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class CpuhpExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
   CpuhpExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit CpuhpExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -75157,14 +108176,7 @@ class CpuhpExitFtraceEvent : public ::protozero::Message {
       uint32_t,
       CpuhpExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cpu kCpu() { return {}; }
+  static constexpr FieldMetadata_Cpu kCpu{};
   void set_cpu(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -75182,14 +108194,7 @@ class CpuhpExitFtraceEvent : public ::protozero::Message {
       int32_t,
       CpuhpExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Idx kIdx() { return {}; }
+  static constexpr FieldMetadata_Idx kIdx{};
   void set_idx(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Idx::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -75207,14 +108212,7 @@ class CpuhpExitFtraceEvent : public ::protozero::Message {
       int32_t,
       CpuhpExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
+  static constexpr FieldMetadata_Ret kRet{};
   void set_ret(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -75232,14 +108230,7 @@ class CpuhpExitFtraceEvent : public ::protozero::Message {
       int32_t,
       CpuhpExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_State kState() { return {}; }
+  static constexpr FieldMetadata_State kState{};
   void set_state(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -75269,12 +108260,12 @@ class CpuhpExitFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class CrosEcSensorhubDataFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class CrosEcSensorhubDataFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
   CrosEcSensorhubDataFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit CrosEcSensorhubDataFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -75315,14 +108306,7 @@ class CrosEcSensorhubDataFtraceEvent : public ::protozero::Message {
       int64_t,
       CrosEcSensorhubDataFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CurrentTime kCurrentTime() { return {}; }
+  static constexpr FieldMetadata_CurrentTime kCurrentTime{};
   void set_current_time(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_CurrentTime::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -75340,14 +108324,7 @@ class CrosEcSensorhubDataFtraceEvent : public ::protozero::Message {
       int64_t,
       CrosEcSensorhubDataFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CurrentTimestamp kCurrentTimestamp() { return {}; }
+  static constexpr FieldMetadata_CurrentTimestamp kCurrentTimestamp{};
   void set_current_timestamp(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_CurrentTimestamp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -75365,14 +108342,7 @@ class CrosEcSensorhubDataFtraceEvent : public ::protozero::Message {
       int64_t,
       CrosEcSensorhubDataFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Delta kDelta() { return {}; }
+  static constexpr FieldMetadata_Delta kDelta{};
   void set_delta(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Delta::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -75390,14 +108360,7 @@ class CrosEcSensorhubDataFtraceEvent : public ::protozero::Message {
       uint32_t,
       CrosEcSensorhubDataFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EcFifoTimestamp kEcFifoTimestamp() { return {}; }
+  static constexpr FieldMetadata_EcFifoTimestamp kEcFifoTimestamp{};
   void set_ec_fifo_timestamp(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_EcFifoTimestamp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -75415,14 +108378,7 @@ class CrosEcSensorhubDataFtraceEvent : public ::protozero::Message {
       uint32_t,
       CrosEcSensorhubDataFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EcSensorNum kEcSensorNum() { return {}; }
+  static constexpr FieldMetadata_EcSensorNum kEcSensorNum{};
   void set_ec_sensor_num(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_EcSensorNum::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -75440,14 +108396,7 @@ class CrosEcSensorhubDataFtraceEvent : public ::protozero::Message {
       int64_t,
       CrosEcSensorhubDataFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FifoTimestamp kFifoTimestamp() { return {}; }
+  static constexpr FieldMetadata_FifoTimestamp kFifoTimestamp{};
   void set_fifo_timestamp(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_FifoTimestamp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -75458,6 +108407,239 @@ class CrosEcSensorhubDataFtraceEvent : public ::protozero::Message {
   }
 };
 
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/dcvsh.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_DCVSH_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_DCVSH_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class DcvshFreqFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  DcvshFreqFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DcvshFreqFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DcvshFreqFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cpu() const { return at<1>().valid(); }
+  uint64_t cpu() const { return at<1>().as_uint64(); }
+  bool has_freq() const { return at<2>().valid(); }
+  uint64_t freq() const { return at<2>().as_uint64(); }
+};
+
+class DcvshFreqFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = DcvshFreqFtraceEvent_Decoder;
+  enum : int32_t {
+    kCpuFieldNumber = 1,
+    kFreqFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.DcvshFreqFtraceEvent"; }
+
+
+  using FieldMetadata_Cpu =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      DcvshFreqFtraceEvent>;
+
+  static constexpr FieldMetadata_Cpu kCpu{};
+  void set_cpu(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Freq =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      DcvshFreqFtraceEvent>;
+
+  static constexpr FieldMetadata_Freq kFreq{};
+  void set_freq(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Freq::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/devfreq.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_DEVFREQ_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_DEVFREQ_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class DevfreqFrequencyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  DevfreqFrequencyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DevfreqFrequencyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DevfreqFrequencyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars dev_name() const { return at<1>().as_string(); }
+  bool has_freq() const { return at<2>().valid(); }
+  uint64_t freq() const { return at<2>().as_uint64(); }
+  bool has_prev_freq() const { return at<3>().valid(); }
+  uint64_t prev_freq() const { return at<3>().as_uint64(); }
+  bool has_busy_time() const { return at<4>().valid(); }
+  uint64_t busy_time() const { return at<4>().as_uint64(); }
+  bool has_total_time() const { return at<5>().valid(); }
+  uint64_t total_time() const { return at<5>().as_uint64(); }
+};
+
+class DevfreqFrequencyFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = DevfreqFrequencyFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevNameFieldNumber = 1,
+    kFreqFieldNumber = 2,
+    kPrevFreqFieldNumber = 3,
+    kBusyTimeFieldNumber = 4,
+    kTotalTimeFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.DevfreqFrequencyFtraceEvent"; }
+
+
+  using FieldMetadata_DevName =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      DevfreqFrequencyFtraceEvent>;
+
+  static constexpr FieldMetadata_DevName kDevName{};
+  void set_dev_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_DevName::kFieldId, data, size);
+  }
+  void set_dev_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_DevName::kFieldId, chars.data, chars.size);
+  }
+  void set_dev_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_DevName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Freq =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      DevfreqFrequencyFtraceEvent>;
+
+  static constexpr FieldMetadata_Freq kFreq{};
+  void set_freq(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Freq::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PrevFreq =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      DevfreqFrequencyFtraceEvent>;
+
+  static constexpr FieldMetadata_PrevFreq kPrevFreq{};
+  void set_prev_freq(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PrevFreq::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BusyTime =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      DevfreqFrequencyFtraceEvent>;
+
+  static constexpr FieldMetadata_BusyTime kBusyTime{};
+  void set_busy_time(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BusyTime::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TotalTime =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      DevfreqFrequencyFtraceEvent>;
+
+  static constexpr FieldMetadata_TotalTime kTotalTime{};
+  void set_total_time(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TotalTime::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
+
 } // Namespace.
 } // Namespace.
 } // Namespace.
@@ -75477,12 +108659,12 @@ class CrosEcSensorhubDataFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class DmaFenceWaitEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DmaFenceWaitEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
   DmaFenceWaitEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit DmaFenceWaitEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -75517,14 +108699,7 @@ class DmaFenceWaitEndFtraceEvent : public ::protozero::Message {
       uint32_t,
       DmaFenceWaitEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Context kContext() { return {}; }
+  static constexpr FieldMetadata_Context kContext{};
   void set_context(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -75542,14 +108717,7 @@ class DmaFenceWaitEndFtraceEvent : public ::protozero::Message {
       std::string,
       DmaFenceWaitEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Driver kDriver() { return {}; }
+  static constexpr FieldMetadata_Driver kDriver{};
   void set_driver(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Driver::kFieldId, data, size);
   }
@@ -75573,14 +108741,7 @@ class DmaFenceWaitEndFtraceEvent : public ::protozero::Message {
       uint32_t,
       DmaFenceWaitEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Seqno kSeqno() { return {}; }
+  static constexpr FieldMetadata_Seqno kSeqno{};
   void set_seqno(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -75598,14 +108759,7 @@ class DmaFenceWaitEndFtraceEvent : public ::protozero::Message {
       std::string,
       DmaFenceWaitEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timeline kTimeline() { return {}; }
+  static constexpr FieldMetadata_Timeline kTimeline{};
   void set_timeline(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Timeline::kFieldId, data, size);
   }
@@ -75622,7 +108776,7 @@ class DmaFenceWaitEndFtraceEvent : public ::protozero::Message {
   }
 };
 
-class DmaFenceWaitStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DmaFenceWaitStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
   DmaFenceWaitStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit DmaFenceWaitStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -75657,14 +108811,7 @@ class DmaFenceWaitStartFtraceEvent : public ::protozero::Message {
       uint32_t,
       DmaFenceWaitStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Context kContext() { return {}; }
+  static constexpr FieldMetadata_Context kContext{};
   void set_context(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -75682,14 +108829,7 @@ class DmaFenceWaitStartFtraceEvent : public ::protozero::Message {
       std::string,
       DmaFenceWaitStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Driver kDriver() { return {}; }
+  static constexpr FieldMetadata_Driver kDriver{};
   void set_driver(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Driver::kFieldId, data, size);
   }
@@ -75713,14 +108853,7 @@ class DmaFenceWaitStartFtraceEvent : public ::protozero::Message {
       uint32_t,
       DmaFenceWaitStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Seqno kSeqno() { return {}; }
+  static constexpr FieldMetadata_Seqno kSeqno{};
   void set_seqno(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -75738,14 +108871,7 @@ class DmaFenceWaitStartFtraceEvent : public ::protozero::Message {
       std::string,
       DmaFenceWaitStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timeline kTimeline() { return {}; }
+  static constexpr FieldMetadata_Timeline kTimeline{};
   void set_timeline(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Timeline::kFieldId, data, size);
   }
@@ -75762,7 +108888,7 @@ class DmaFenceWaitStartFtraceEvent : public ::protozero::Message {
   }
 };
 
-class DmaFenceSignaledFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DmaFenceSignaledFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
   DmaFenceSignaledFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit DmaFenceSignaledFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -75797,14 +108923,7 @@ class DmaFenceSignaledFtraceEvent : public ::protozero::Message {
       uint32_t,
       DmaFenceSignaledFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Context kContext() { return {}; }
+  static constexpr FieldMetadata_Context kContext{};
   void set_context(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -75822,14 +108941,7 @@ class DmaFenceSignaledFtraceEvent : public ::protozero::Message {
       std::string,
       DmaFenceSignaledFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Driver kDriver() { return {}; }
+  static constexpr FieldMetadata_Driver kDriver{};
   void set_driver(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Driver::kFieldId, data, size);
   }
@@ -75853,14 +108965,7 @@ class DmaFenceSignaledFtraceEvent : public ::protozero::Message {
       uint32_t,
       DmaFenceSignaledFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Seqno kSeqno() { return {}; }
+  static constexpr FieldMetadata_Seqno kSeqno{};
   void set_seqno(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -75878,14 +108983,7 @@ class DmaFenceSignaledFtraceEvent : public ::protozero::Message {
       std::string,
       DmaFenceSignaledFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timeline kTimeline() { return {}; }
+  static constexpr FieldMetadata_Timeline kTimeline{};
   void set_timeline(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Timeline::kFieldId, data, size);
   }
@@ -75902,7 +109000,7 @@ class DmaFenceSignaledFtraceEvent : public ::protozero::Message {
   }
 };
 
-class DmaFenceEmitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DmaFenceEmitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
   DmaFenceEmitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit DmaFenceEmitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -75937,14 +109035,7 @@ class DmaFenceEmitFtraceEvent : public ::protozero::Message {
       uint32_t,
       DmaFenceEmitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Context kContext() { return {}; }
+  static constexpr FieldMetadata_Context kContext{};
   void set_context(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -75962,14 +109053,7 @@ class DmaFenceEmitFtraceEvent : public ::protozero::Message {
       std::string,
       DmaFenceEmitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Driver kDriver() { return {}; }
+  static constexpr FieldMetadata_Driver kDriver{};
   void set_driver(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Driver::kFieldId, data, size);
   }
@@ -75993,14 +109077,7 @@ class DmaFenceEmitFtraceEvent : public ::protozero::Message {
       uint32_t,
       DmaFenceEmitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Seqno kSeqno() { return {}; }
+  static constexpr FieldMetadata_Seqno kSeqno{};
   void set_seqno(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -76018,14 +109095,7 @@ class DmaFenceEmitFtraceEvent : public ::protozero::Message {
       std::string,
       DmaFenceEmitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timeline kTimeline() { return {}; }
+  static constexpr FieldMetadata_Timeline kTimeline{};
   void set_timeline(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Timeline::kFieldId, data, size);
   }
@@ -76042,7 +109112,7 @@ class DmaFenceEmitFtraceEvent : public ::protozero::Message {
   }
 };
 
-class DmaFenceInitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DmaFenceInitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
   DmaFenceInitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit DmaFenceInitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -76077,14 +109147,7 @@ class DmaFenceInitFtraceEvent : public ::protozero::Message {
       uint32_t,
       DmaFenceInitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Context kContext() { return {}; }
+  static constexpr FieldMetadata_Context kContext{};
   void set_context(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -76102,14 +109165,7 @@ class DmaFenceInitFtraceEvent : public ::protozero::Message {
       std::string,
       DmaFenceInitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Driver kDriver() { return {}; }
+  static constexpr FieldMetadata_Driver kDriver{};
   void set_driver(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Driver::kFieldId, data, size);
   }
@@ -76133,14 +109189,7 @@ class DmaFenceInitFtraceEvent : public ::protozero::Message {
       uint32_t,
       DmaFenceInitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Seqno kSeqno() { return {}; }
+  static constexpr FieldMetadata_Seqno kSeqno{};
   void set_seqno(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -76158,14 +109207,7 @@ class DmaFenceInitFtraceEvent : public ::protozero::Message {
       std::string,
       DmaFenceInitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timeline kTimeline() { return {}; }
+  static constexpr FieldMetadata_Timeline kTimeline{};
   void set_timeline(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Timeline::kFieldId, data, size);
   }
@@ -76201,12 +109243,12 @@ class DmaFenceInitFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class DmaHeapStatFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DmaHeapStatFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
   DmaHeapStatFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit DmaHeapStatFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -76238,14 +109280,7 @@ class DmaHeapStatFtraceEvent : public ::protozero::Message {
       uint64_t,
       DmaHeapStatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Inode kInode() { return {}; }
+  static constexpr FieldMetadata_Inode kInode{};
   void set_inode(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Inode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -76263,14 +109298,7 @@ class DmaHeapStatFtraceEvent : public ::protozero::Message {
       int64_t,
       DmaHeapStatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
+  static constexpr FieldMetadata_Len kLen{};
   void set_len(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -76288,14 +109316,7 @@ class DmaHeapStatFtraceEvent : public ::protozero::Message {
       uint64_t,
       DmaHeapStatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TotalAllocated kTotalAllocated() { return {}; }
+  static constexpr FieldMetadata_TotalAllocated kTotalAllocated{};
   void set_total_allocated(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_TotalAllocated::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -76325,12 +109346,398 @@ class DmaHeapStatFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
+class DpuDispVblankIrqEnableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  DpuDispVblankIrqEnableFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DpuDispVblankIrqEnableFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DpuDispVblankIrqEnableFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  int32_t id() const { return at<1>().as_int32(); }
+  bool has_output_id() const { return at<2>().valid(); }
+  int32_t output_id() const { return at<2>().as_int32(); }
+  bool has_enable() const { return at<3>().valid(); }
+  int32_t enable() const { return at<3>().as_int32(); }
+};
+
+class DpuDispVblankIrqEnableFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = DpuDispVblankIrqEnableFtraceEvent_Decoder;
+  enum : int32_t {
+    kIdFieldNumber = 1,
+    kOutputIdFieldNumber = 2,
+    kEnableFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.DpuDispVblankIrqEnableFtraceEvent"; }
+
+
+  using FieldMetadata_Id =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      DpuDispVblankIrqEnableFtraceEvent>;
+
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OutputId =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      DpuDispVblankIrqEnableFtraceEvent>;
+
+  static constexpr FieldMetadata_OutputId kOutputId{};
+  void set_output_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OutputId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Enable =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      DpuDispVblankIrqEnableFtraceEvent>;
+
+  static constexpr FieldMetadata_Enable kEnable{};
+  void set_enable(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Enable::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class DpuDispDpuUnderrunFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  DpuDispDpuUnderrunFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DpuDispDpuUnderrunFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DpuDispDpuUnderrunFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  int32_t id() const { return at<1>().as_int32(); }
+  bool has_frames_pending() const { return at<2>().valid(); }
+  int32_t frames_pending() const { return at<2>().as_int32(); }
+  bool has_vsync_count() const { return at<3>().valid(); }
+  int32_t vsync_count() const { return at<3>().as_int32(); }
+};
+
+class DpuDispDpuUnderrunFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = DpuDispDpuUnderrunFtraceEvent_Decoder;
+  enum : int32_t {
+    kIdFieldNumber = 1,
+    kFramesPendingFieldNumber = 2,
+    kVsyncCountFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.DpuDispDpuUnderrunFtraceEvent"; }
+
+
+  using FieldMetadata_Id =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      DpuDispDpuUnderrunFtraceEvent>;
+
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FramesPending =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      DpuDispDpuUnderrunFtraceEvent>;
+
+  static constexpr FieldMetadata_FramesPending kFramesPending{};
+  void set_frames_pending(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FramesPending::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_VsyncCount =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      DpuDispDpuUnderrunFtraceEvent>;
+
+  static constexpr FieldMetadata_VsyncCount kVsyncCount{};
+  void set_vsync_count(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VsyncCount::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class DpuDsiTxFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  DpuDsiTxFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DpuDsiTxFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DpuDsiTxFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_type() const { return at<1>().valid(); }
+  uint32_t type() const { return at<1>().as_uint32(); }
+  bool has_last() const { return at<3>().valid(); }
+  uint32_t last() const { return at<3>().as_uint32(); }
+  bool has_delay_ms() const { return at<4>().valid(); }
+  uint32_t delay_ms() const { return at<4>().as_uint32(); }
+  bool has_tx_buf() const { return at<5>().valid(); }
+  ::protozero::ConstBytes tx_buf() const { return at<5>().as_bytes(); }
+};
+
+class DpuDsiTxFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = DpuDsiTxFtraceEvent_Decoder;
+  enum : int32_t {
+    kTypeFieldNumber = 1,
+    kLastFieldNumber = 3,
+    kDelayMsFieldNumber = 4,
+    kTxBufFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.DpuDsiTxFtraceEvent"; }
+
+
+  using FieldMetadata_Type =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      DpuDsiTxFtraceEvent>;
+
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Last =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      DpuDsiTxFtraceEvent>;
+
+  static constexpr FieldMetadata_Last kLast{};
+  void set_last(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Last::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DelayMs =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      DpuDsiTxFtraceEvent>;
+
+  static constexpr FieldMetadata_DelayMs kDelayMs{};
+  void set_delay_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DelayMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-class DpuTracingMarkWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+  using FieldMetadata_TxBuf =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      DpuDsiTxFtraceEvent>;
+
+  static constexpr FieldMetadata_TxBuf kTxBuf{};
+  void set_tx_buf(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_TxBuf::kFieldId, data, size);
+  }
+  void set_tx_buf(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_TxBuf::kFieldId, bytes.data, bytes.size);
+  }
+  void set_tx_buf(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_TxBuf::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class DpuDsiRxFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  DpuDsiRxFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DpuDsiRxFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DpuDsiRxFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cmd() const { return at<1>().valid(); }
+  uint32_t cmd() const { return at<1>().as_uint32(); }
+  bool has_rx_buf() const { return at<3>().valid(); }
+  ::protozero::ConstBytes rx_buf() const { return at<3>().as_bytes(); }
+};
+
+class DpuDsiRxFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = DpuDsiRxFtraceEvent_Decoder;
+  enum : int32_t {
+    kCmdFieldNumber = 1,
+    kRxBufFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.DpuDsiRxFtraceEvent"; }
+
+
+  using FieldMetadata_Cmd =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      DpuDsiRxFtraceEvent>;
+
+  static constexpr FieldMetadata_Cmd kCmd{};
+  void set_cmd(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cmd::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_RxBuf =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      DpuDsiRxFtraceEvent>;
+
+  static constexpr FieldMetadata_RxBuf kRxBuf{};
+  void set_rx_buf(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_RxBuf::kFieldId, data, size);
+  }
+  void set_rx_buf(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_RxBuf::kFieldId, bytes.data, bytes.size);
+  }
+  void set_rx_buf(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_RxBuf::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class DpuDsiCmdFifoStatusFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  DpuDsiCmdFifoStatusFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DpuDsiCmdFifoStatusFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DpuDsiCmdFifoStatusFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_header() const { return at<1>().valid(); }
+  uint32_t header() const { return at<1>().as_uint32(); }
+  bool has_payload() const { return at<2>().valid(); }
+  uint32_t payload() const { return at<2>().as_uint32(); }
+};
+
+class DpuDsiCmdFifoStatusFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = DpuDsiCmdFifoStatusFtraceEvent_Decoder;
+  enum : int32_t {
+    kHeaderFieldNumber = 1,
+    kPayloadFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.DpuDsiCmdFifoStatusFtraceEvent"; }
+
+
+  using FieldMetadata_Header =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      DpuDsiCmdFifoStatusFtraceEvent>;
+
+  static constexpr FieldMetadata_Header kHeader{};
+  void set_header(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Header::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Payload =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      DpuDsiCmdFifoStatusFtraceEvent>;
+
+  static constexpr FieldMetadata_Payload kPayload{};
+  void set_payload(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Payload::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class DpuTracingMarkWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
   DpuTracingMarkWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit DpuTracingMarkWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -76371,14 +109778,7 @@ class DpuTracingMarkWriteFtraceEvent : public ::protozero::Message {
       int32_t,
       DpuTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
+  static constexpr FieldMetadata_Pid kPid{};
   void set_pid(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -76396,14 +109796,7 @@ class DpuTracingMarkWriteFtraceEvent : public ::protozero::Message {
       std::string,
       DpuTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceName kTraceName() { return {}; }
+  static constexpr FieldMetadata_TraceName kTraceName{};
   void set_trace_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_TraceName::kFieldId, data, size);
   }
@@ -76427,14 +109820,7 @@ class DpuTracingMarkWriteFtraceEvent : public ::protozero::Message {
       uint32_t,
       DpuTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceBegin kTraceBegin() { return {}; }
+  static constexpr FieldMetadata_TraceBegin kTraceBegin{};
   void set_trace_begin(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_TraceBegin::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -76452,14 +109838,7 @@ class DpuTracingMarkWriteFtraceEvent : public ::protozero::Message {
       std::string,
       DpuTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -76483,14 +109862,7 @@ class DpuTracingMarkWriteFtraceEvent : public ::protozero::Message {
       uint32_t,
       DpuTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
+  static constexpr FieldMetadata_Type kType{};
   void set_type(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -76508,14 +109880,7 @@ class DpuTracingMarkWriteFtraceEvent : public ::protozero::Message {
       int32_t,
       DpuTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
+  static constexpr FieldMetadata_Value kValue{};
   void set_value(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -76545,12 +109910,12 @@ class DpuTracingMarkWriteFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class DrmVblankEventDeliveredFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DrmVblankEventDeliveredFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
   DrmVblankEventDeliveredFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit DrmVblankEventDeliveredFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -76582,14 +109947,7 @@ class DrmVblankEventDeliveredFtraceEvent : public ::protozero::Message {
       int32_t,
       DrmVblankEventDeliveredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Crtc kCrtc() { return {}; }
+  static constexpr FieldMetadata_Crtc kCrtc{};
   void set_crtc(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Crtc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -76607,14 +109965,7 @@ class DrmVblankEventDeliveredFtraceEvent : public ::protozero::Message {
       uint64_t,
       DrmVblankEventDeliveredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_File kFile() { return {}; }
+  static constexpr FieldMetadata_File kFile{};
   void set_file(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_File::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -76632,14 +109983,7 @@ class DrmVblankEventDeliveredFtraceEvent : public ::protozero::Message {
       uint32_t,
       DrmVblankEventDeliveredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Seq kSeq() { return {}; }
+  static constexpr FieldMetadata_Seq kSeq{};
   void set_seq(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Seq::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -76650,7 +109994,7 @@ class DrmVblankEventDeliveredFtraceEvent : public ::protozero::Message {
   }
 };
 
-class DrmVblankEventFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DrmVblankEventFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
   DrmVblankEventFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit DrmVblankEventFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -76685,14 +110029,7 @@ class DrmVblankEventFtraceEvent : public ::protozero::Message {
       int32_t,
       DrmVblankEventFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Crtc kCrtc() { return {}; }
+  static constexpr FieldMetadata_Crtc kCrtc{};
   void set_crtc(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Crtc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -76710,14 +110047,7 @@ class DrmVblankEventFtraceEvent : public ::protozero::Message {
       uint32_t,
       DrmVblankEventFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HighPrec kHighPrec() { return {}; }
+  static constexpr FieldMetadata_HighPrec kHighPrec{};
   void set_high_prec(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_HighPrec::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -76735,14 +110065,7 @@ class DrmVblankEventFtraceEvent : public ::protozero::Message {
       uint32_t,
       DrmVblankEventFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Seq kSeq() { return {}; }
+  static constexpr FieldMetadata_Seq kSeq{};
   void set_seq(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Seq::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -76760,14 +110083,7 @@ class DrmVblankEventFtraceEvent : public ::protozero::Message {
       int64_t,
       DrmVblankEventFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Time kTime() { return {}; }
+  static constexpr FieldMetadata_Time kTime{};
   void set_time(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Time::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -76782,11 +110098,11 @@ class DrmVblankEventFtraceEvent : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/ext4.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/dwc3.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_EXT4_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_EXT4_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_DWC3_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_DWC3_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -76797,59 +110113,49 @@ class DrmVblankEventFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class Ext4ZeroRangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Dwc3WritelFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  Ext4ZeroRangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4ZeroRangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4ZeroRangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_offset() const { return at<3>().valid(); }
-  int64_t offset() const { return at<3>().as_int64(); }
-  bool has_len() const { return at<4>().valid(); }
-  int64_t len() const { return at<4>().as_int64(); }
-  bool has_mode() const { return at<5>().valid(); }
-  int32_t mode() const { return at<5>().as_int32(); }
+  Dwc3WritelFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Dwc3WritelFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Dwc3WritelFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_base() const { return at<1>().valid(); }
+  uint64_t base() const { return at<1>().as_uint64(); }
+  bool has_offset() const { return at<2>().valid(); }
+  uint32_t offset() const { return at<2>().as_uint32(); }
+  bool has_value() const { return at<3>().valid(); }
+  uint32_t value() const { return at<3>().as_uint32(); }
+  bool has_msg() const { return at<4>().valid(); }
+  ::protozero::ConstChars msg() const { return at<4>().as_string(); }
 };
 
-class Ext4ZeroRangeFtraceEvent : public ::protozero::Message {
+class Dwc3WritelFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4ZeroRangeFtraceEvent_Decoder;
+  using Decoder = Dwc3WritelFtraceEvent_Decoder;
   enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kOffsetFieldNumber = 3,
-    kLenFieldNumber = 4,
-    kModeFieldNumber = 5,
+    kBaseFieldNumber = 1,
+    kOffsetFieldNumber = 2,
+    kValueFieldNumber = 3,
+    kMsgFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ZeroRangeFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Dwc3WritelFtraceEvent"; }
 
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_Base =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ZeroRangeFtraceEvent>;
+      Dwc3WritelFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_Base kBase{};
+  void set_base(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Base::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -76857,24 +110163,105 @@ class Ext4ZeroRangeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_Offset =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3WritelFtraceEvent>;
+
+  static constexpr FieldMetadata_Offset kOffset{};
+  void set_offset(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3WritelFtraceEvent>;
+
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Msg =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      Dwc3WritelFtraceEvent>;
+
+  static constexpr FieldMetadata_Msg kMsg{};
+  void set_msg(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Msg::kFieldId, data, size);
+  }
+  void set_msg(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Msg::kFieldId, chars.data, chars.size);
+  }
+  void set_msg(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Msg::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class Dwc3ReadlFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  Dwc3ReadlFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Dwc3ReadlFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Dwc3ReadlFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_base() const { return at<1>().valid(); }
+  uint64_t base() const { return at<1>().as_uint64(); }
+  bool has_offset() const { return at<2>().valid(); }
+  uint32_t offset() const { return at<2>().as_uint32(); }
+  bool has_value() const { return at<3>().valid(); }
+  uint32_t value() const { return at<3>().as_uint32(); }
+  bool has_msg() const { return at<4>().valid(); }
+  ::protozero::ConstChars msg() const { return at<4>().as_string(); }
+};
+
+class Dwc3ReadlFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Dwc3ReadlFtraceEvent_Decoder;
+  enum : int32_t {
+    kBaseFieldNumber = 1,
+    kOffsetFieldNumber = 2,
+    kValueFieldNumber = 3,
+    kMsgFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Dwc3ReadlFtraceEvent"; }
+
+
+  using FieldMetadata_Base =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ZeroRangeFtraceEvent>;
+      Dwc3ReadlFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_Base kBase{};
+  void set_base(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Base::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -76884,159 +110271,148 @@ class Ext4ZeroRangeFtraceEvent : public ::protozero::Message {
 
   using FieldMetadata_Offset =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4ZeroRangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3ReadlFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Offset kOffset() { return {}; }
-  void set_offset(int64_t value) {
+  static constexpr FieldMetadata_Offset kOffset{};
+  void set_offset(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_Value =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4ZeroRangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3ReadlFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Mode =
+  using FieldMetadata_Msg =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4ZeroRangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      Dwc3ReadlFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mode kMode() { return {}; }
-  void set_mode(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+  static constexpr FieldMetadata_Msg kMsg{};
+  void set_msg(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Msg::kFieldId, data, size);
+  }
+  void set_msg(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Msg::kFieldId, chars.data, chars.size);
+  }
+  void set_msg(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Msg::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4WritepagesResultFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Dwc3PrepareTrbFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11> {
  public:
-  Ext4WritepagesResultFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4WritepagesResultFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4WritepagesResultFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_ret() const { return at<3>().valid(); }
-  int32_t ret() const { return at<3>().as_int32(); }
-  bool has_pages_written() const { return at<4>().valid(); }
-  int32_t pages_written() const { return at<4>().as_int32(); }
-  bool has_pages_skipped() const { return at<5>().valid(); }
-  int64_t pages_skipped() const { return at<5>().as_int64(); }
-  bool has_writeback_index() const { return at<6>().valid(); }
-  uint64_t writeback_index() const { return at<6>().as_uint64(); }
-  bool has_sync_mode() const { return at<7>().valid(); }
-  int32_t sync_mode() const { return at<7>().as_int32(); }
+  Dwc3PrepareTrbFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Dwc3PrepareTrbFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Dwc3PrepareTrbFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_trb() const { return at<2>().valid(); }
+  uint64_t trb() const { return at<2>().as_uint64(); }
+  bool has_allocated() const { return at<3>().valid(); }
+  uint32_t allocated() const { return at<3>().as_uint32(); }
+  bool has_queued() const { return at<4>().valid(); }
+  uint32_t queued() const { return at<4>().as_uint32(); }
+  bool has_bpl() const { return at<5>().valid(); }
+  uint32_t bpl() const { return at<5>().as_uint32(); }
+  bool has_bph() const { return at<6>().valid(); }
+  uint32_t bph() const { return at<6>().as_uint32(); }
+  bool has_size() const { return at<7>().valid(); }
+  uint32_t size() const { return at<7>().as_uint32(); }
+  bool has_ctrl() const { return at<8>().valid(); }
+  uint32_t ctrl() const { return at<8>().as_uint32(); }
+  bool has_type() const { return at<9>().valid(); }
+  uint32_t type() const { return at<9>().as_uint32(); }
+  bool has_enqueue() const { return at<10>().valid(); }
+  uint32_t enqueue() const { return at<10>().as_uint32(); }
+  bool has_dequeue() const { return at<11>().valid(); }
+  uint32_t dequeue() const { return at<11>().as_uint32(); }
 };
 
-class Ext4WritepagesResultFtraceEvent : public ::protozero::Message {
+class Dwc3PrepareTrbFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4WritepagesResultFtraceEvent_Decoder;
+  using Decoder = Dwc3PrepareTrbFtraceEvent_Decoder;
   enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kRetFieldNumber = 3,
-    kPagesWrittenFieldNumber = 4,
-    kPagesSkippedFieldNumber = 5,
-    kWritebackIndexFieldNumber = 6,
-    kSyncModeFieldNumber = 7,
+    kNameFieldNumber = 1,
+    kTrbFieldNumber = 2,
+    kAllocatedFieldNumber = 3,
+    kQueuedFieldNumber = 4,
+    kBplFieldNumber = 5,
+    kBphFieldNumber = 6,
+    kSizeFieldNumber = 7,
+    kCtrlFieldNumber = 8,
+    kTypeFieldNumber = 9,
+    kEnqueueFieldNumber = 10,
+    kDequeueFieldNumber = 11,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4WritepagesResultFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Dwc3PrepareTrbFtraceEvent"; }
 
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4WritepagesResultFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      Dwc3PrepareTrbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_Trb =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4WritepagesResultFtraceEvent>;
+      Dwc3PrepareTrbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_Trb kTrb{};
+  void set_trb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Trb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -77044,99 +110420,243 @@ class Ext4WritepagesResultFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ret =
+  using FieldMetadata_Allocated =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4WritepagesResultFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3PrepareTrbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+  static constexpr FieldMetadata_Allocated kAllocated{};
+  void set_allocated(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Allocated::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PagesWritten =
+  using FieldMetadata_Queued =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4WritepagesResultFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3PrepareTrbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PagesWritten kPagesWritten() { return {}; }
-  void set_pages_written(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PagesWritten::kFieldId;
+  static constexpr FieldMetadata_Queued kQueued{};
+  void set_queued(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Queued::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PagesSkipped =
+  using FieldMetadata_Bpl =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4WritepagesResultFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3PrepareTrbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PagesSkipped kPagesSkipped() { return {}; }
-  void set_pages_skipped(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PagesSkipped::kFieldId;
+  static constexpr FieldMetadata_Bpl kBpl{};
+  void set_bpl(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Bpl::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_WritebackIndex =
+  using FieldMetadata_Bph =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3PrepareTrbFtraceEvent>;
+
+  static constexpr FieldMetadata_Bph kBph{};
+  void set_bph(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Bph::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Size =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3PrepareTrbFtraceEvent>;
+
+  static constexpr FieldMetadata_Size kSize{};
+  void set_size(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ctrl =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3PrepareTrbFtraceEvent>;
+
+  static constexpr FieldMetadata_Ctrl kCtrl{};
+  void set_ctrl(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ctrl::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Type =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3PrepareTrbFtraceEvent>;
+
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Enqueue =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3PrepareTrbFtraceEvent>;
+
+  static constexpr FieldMetadata_Enqueue kEnqueue{};
+  void set_enqueue(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Enqueue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Dequeue =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3PrepareTrbFtraceEvent>;
+
+  static constexpr FieldMetadata_Dequeue kDequeue{};
+  void set_dequeue(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dequeue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class Dwc3GadgetGivebackFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
+ public:
+  Dwc3GadgetGivebackFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Dwc3GadgetGivebackFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Dwc3GadgetGivebackFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_req() const { return at<2>().valid(); }
+  uint64_t req() const { return at<2>().as_uint64(); }
+  bool has_actual() const { return at<3>().valid(); }
+  uint32_t actual() const { return at<3>().as_uint32(); }
+  bool has_length() const { return at<4>().valid(); }
+  uint32_t length() const { return at<4>().as_uint32(); }
+  bool has_status() const { return at<5>().valid(); }
+  int32_t status() const { return at<5>().as_int32(); }
+  bool has_zero() const { return at<6>().valid(); }
+  int32_t zero() const { return at<6>().as_int32(); }
+  bool has_short_not_ok() const { return at<7>().valid(); }
+  int32_t short_not_ok() const { return at<7>().as_int32(); }
+  bool has_no_interrupt() const { return at<8>().valid(); }
+  int32_t no_interrupt() const { return at<8>().as_int32(); }
+};
+
+class Dwc3GadgetGivebackFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Dwc3GadgetGivebackFtraceEvent_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kReqFieldNumber = 2,
+    kActualFieldNumber = 3,
+    kLengthFieldNumber = 4,
+    kStatusFieldNumber = 5,
+    kZeroFieldNumber = 6,
+    kShortNotOkFieldNumber = 7,
+    kNoInterruptFieldNumber = 8,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Dwc3GadgetGivebackFtraceEvent"; }
+
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      Dwc3GadgetGivebackFtraceEvent>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Req =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4WritepagesResultFtraceEvent>;
+      Dwc3GadgetGivebackFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WritebackIndex kWritebackIndex() { return {}; }
-  void set_writeback_index(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_WritebackIndex::kFieldId;
+  static constexpr FieldMetadata_Req kReq{};
+  void set_req(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Req::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -77144,24 +110664,107 @@ class Ext4WritepagesResultFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SyncMode =
+  using FieldMetadata_Actual =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3GadgetGivebackFtraceEvent>;
+
+  static constexpr FieldMetadata_Actual kActual{};
+  void set_actual(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Actual::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Length =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3GadgetGivebackFtraceEvent>;
+
+  static constexpr FieldMetadata_Length kLength{};
+  void set_length(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Length::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Status =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Dwc3GadgetGivebackFtraceEvent>;
+
+  static constexpr FieldMetadata_Status kStatus{};
+  void set_status(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Zero =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Dwc3GadgetGivebackFtraceEvent>;
+
+  static constexpr FieldMetadata_Zero kZero{};
+  void set_zero(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Zero::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ShortNotOk =
     ::protozero::proto_utils::FieldMetadata<
       7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4WritepagesResultFtraceEvent>;
+      Dwc3GadgetGivebackFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SyncMode kSyncMode() { return {}; }
-  void set_sync_mode(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SyncMode::kFieldId;
+  static constexpr FieldMetadata_ShortNotOk kShortNotOk{};
+  void set_short_not_ok(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ShortNotOk::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NoInterrupt =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Dwc3GadgetGivebackFtraceEvent>;
+
+  static constexpr FieldMetadata_NoInterrupt kNoInterrupt{};
+  void set_no_interrupt(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NoInterrupt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -77170,269 +110773,270 @@ class Ext4WritepagesResultFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4WritepagesFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Dwc3GadgetGenericCmdFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  Ext4WritepagesFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4WritepagesFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4WritepagesFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_nr_to_write() const { return at<3>().valid(); }
-  int64_t nr_to_write() const { return at<3>().as_int64(); }
-  bool has_pages_skipped() const { return at<4>().valid(); }
-  int64_t pages_skipped() const { return at<4>().as_int64(); }
-  bool has_range_start() const { return at<5>().valid(); }
-  int64_t range_start() const { return at<5>().as_int64(); }
-  bool has_range_end() const { return at<6>().valid(); }
-  int64_t range_end() const { return at<6>().as_int64(); }
-  bool has_writeback_index() const { return at<7>().valid(); }
-  uint64_t writeback_index() const { return at<7>().as_uint64(); }
-  bool has_sync_mode() const { return at<8>().valid(); }
-  int32_t sync_mode() const { return at<8>().as_int32(); }
-  bool has_for_kupdate() const { return at<9>().valid(); }
-  uint32_t for_kupdate() const { return at<9>().as_uint32(); }
-  bool has_range_cyclic() const { return at<10>().valid(); }
-  uint32_t range_cyclic() const { return at<10>().as_uint32(); }
+  Dwc3GadgetGenericCmdFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Dwc3GadgetGenericCmdFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Dwc3GadgetGenericCmdFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cmd() const { return at<1>().valid(); }
+  uint32_t cmd() const { return at<1>().as_uint32(); }
+  bool has_param() const { return at<2>().valid(); }
+  uint32_t param() const { return at<2>().as_uint32(); }
+  bool has_status() const { return at<3>().valid(); }
+  int32_t status() const { return at<3>().as_int32(); }
 };
 
-class Ext4WritepagesFtraceEvent : public ::protozero::Message {
+class Dwc3GadgetGenericCmdFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4WritepagesFtraceEvent_Decoder;
+  using Decoder = Dwc3GadgetGenericCmdFtraceEvent_Decoder;
   enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kNrToWriteFieldNumber = 3,
-    kPagesSkippedFieldNumber = 4,
-    kRangeStartFieldNumber = 5,
-    kRangeEndFieldNumber = 6,
-    kWritebackIndexFieldNumber = 7,
-    kSyncModeFieldNumber = 8,
-    kForKupdateFieldNumber = 9,
-    kRangeCyclicFieldNumber = 10,
+    kCmdFieldNumber = 1,
+    kParamFieldNumber = 2,
+    kStatusFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4WritepagesFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Dwc3GadgetGenericCmdFtraceEvent"; }
 
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_Cmd =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4WritepagesFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3GadgetGenericCmdFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_Cmd kCmd{};
+  void set_cmd(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cmd::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_Param =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4WritepagesFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3GadgetGenericCmdFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_Param kParam{};
+  void set_param(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Param::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NrToWrite =
+  using FieldMetadata_Status =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4WritepagesFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Dwc3GadgetGenericCmdFtraceEvent>;
+
+  static constexpr FieldMetadata_Status kStatus{};
+  void set_status(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class Dwc3GadgetEpEnableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9> {
+ public:
+  Dwc3GadgetEpEnableFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Dwc3GadgetEpEnableFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Dwc3GadgetEpEnableFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_maxpacket() const { return at<2>().valid(); }
+  uint32_t maxpacket() const { return at<2>().as_uint32(); }
+  bool has_maxpacket_limit() const { return at<3>().valid(); }
+  uint32_t maxpacket_limit() const { return at<3>().as_uint32(); }
+  bool has_max_streams() const { return at<4>().valid(); }
+  uint32_t max_streams() const { return at<4>().as_uint32(); }
+  bool has_maxburst() const { return at<5>().valid(); }
+  uint32_t maxburst() const { return at<5>().as_uint32(); }
+  bool has_flags() const { return at<6>().valid(); }
+  uint32_t flags() const { return at<6>().as_uint32(); }
+  bool has_direction() const { return at<7>().valid(); }
+  uint32_t direction() const { return at<7>().as_uint32(); }
+  bool has_trb_enqueue() const { return at<8>().valid(); }
+  uint32_t trb_enqueue() const { return at<8>().as_uint32(); }
+  bool has_trb_dequeue() const { return at<9>().valid(); }
+  uint32_t trb_dequeue() const { return at<9>().as_uint32(); }
+};
+
+class Dwc3GadgetEpEnableFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Dwc3GadgetEpEnableFtraceEvent_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kMaxpacketFieldNumber = 2,
+    kMaxpacketLimitFieldNumber = 3,
+    kMaxStreamsFieldNumber = 4,
+    kMaxburstFieldNumber = 5,
+    kFlagsFieldNumber = 6,
+    kDirectionFieldNumber = 7,
+    kTrbEnqueueFieldNumber = 8,
+    kTrbDequeueFieldNumber = 9,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Dwc3GadgetEpEnableFtraceEvent"; }
+
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      Dwc3GadgetEpEnableFtraceEvent>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Maxpacket =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3GadgetEpEnableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrToWrite kNrToWrite() { return {}; }
-  void set_nr_to_write(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NrToWrite::kFieldId;
+  static constexpr FieldMetadata_Maxpacket kMaxpacket{};
+  void set_maxpacket(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Maxpacket::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PagesSkipped =
+  using FieldMetadata_MaxpacketLimit =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4WritepagesFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3GadgetEpEnableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PagesSkipped kPagesSkipped() { return {}; }
-  void set_pages_skipped(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PagesSkipped::kFieldId;
+  static constexpr FieldMetadata_MaxpacketLimit kMaxpacketLimit{};
+  void set_maxpacket_limit(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MaxpacketLimit::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_RangeStart =
+  using FieldMetadata_MaxStreams =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4WritepagesFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3GadgetEpEnableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RangeStart kRangeStart() { return {}; }
-  void set_range_start(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RangeStart::kFieldId;
+  static constexpr FieldMetadata_MaxStreams kMaxStreams{};
+  void set_max_streams(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MaxStreams::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_RangeEnd =
+  using FieldMetadata_Maxburst =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4WritepagesFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3GadgetEpEnableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RangeEnd kRangeEnd() { return {}; }
-  void set_range_end(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RangeEnd::kFieldId;
+  static constexpr FieldMetadata_Maxburst kMaxburst{};
+  void set_maxburst(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Maxburst::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_WritebackIndex =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4WritepagesFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3GadgetEpEnableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WritebackIndex kWritebackIndex() { return {}; }
-  void set_writeback_index(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_WritebackIndex::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SyncMode =
+  using FieldMetadata_Direction =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4WritepagesFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3GadgetEpEnableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SyncMode kSyncMode() { return {}; }
-  void set_sync_mode(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SyncMode::kFieldId;
+  static constexpr FieldMetadata_Direction kDirection{};
+  void set_direction(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Direction::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ForKupdate =
+  using FieldMetadata_TrbEnqueue =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4WritepagesFtraceEvent>;
+      Dwc3GadgetEpEnableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ForKupdate kForKupdate() { return {}; }
-  void set_for_kupdate(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ForKupdate::kFieldId;
+  static constexpr FieldMetadata_TrbEnqueue kTrbEnqueue{};
+  void set_trb_enqueue(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TrbEnqueue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -77440,24 +111044,17 @@ class Ext4WritepagesFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_RangeCyclic =
+  using FieldMetadata_TrbDequeue =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4WritepagesFtraceEvent>;
+      Dwc3GadgetEpEnableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RangeCyclic kRangeCyclic() { return {}; }
-  void set_range_cyclic(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RangeCyclic::kFieldId;
+  static constexpr FieldMetadata_TrbDequeue kTrbDequeue{};
+  void set_trb_dequeue(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TrbDequeue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -77466,229 +111063,191 @@ class Ext4WritepagesFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4WritepageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Ext4WritepageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4WritepageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4WritepageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_index() const { return at<3>().valid(); }
-  uint64_t index() const { return at<3>().as_uint64(); }
-};
-
-class Ext4WritepageFtraceEvent : public ::protozero::Message {
+class Dwc3GadgetEpDisableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9> {
  public:
-  using Decoder = Ext4WritepageFtraceEvent_Decoder;
+  Dwc3GadgetEpDisableFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Dwc3GadgetEpDisableFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Dwc3GadgetEpDisableFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_maxpacket() const { return at<2>().valid(); }
+  uint32_t maxpacket() const { return at<2>().as_uint32(); }
+  bool has_maxpacket_limit() const { return at<3>().valid(); }
+  uint32_t maxpacket_limit() const { return at<3>().as_uint32(); }
+  bool has_max_streams() const { return at<4>().valid(); }
+  uint32_t max_streams() const { return at<4>().as_uint32(); }
+  bool has_maxburst() const { return at<5>().valid(); }
+  uint32_t maxburst() const { return at<5>().as_uint32(); }
+  bool has_flags() const { return at<6>().valid(); }
+  uint32_t flags() const { return at<6>().as_uint32(); }
+  bool has_direction() const { return at<7>().valid(); }
+  uint32_t direction() const { return at<7>().as_uint32(); }
+  bool has_trb_enqueue() const { return at<8>().valid(); }
+  uint32_t trb_enqueue() const { return at<8>().as_uint32(); }
+  bool has_trb_dequeue() const { return at<9>().valid(); }
+  uint32_t trb_dequeue() const { return at<9>().as_uint32(); }
+};
+
+class Dwc3GadgetEpDisableFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Dwc3GadgetEpDisableFtraceEvent_Decoder;
   enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kIndexFieldNumber = 3,
+    kNameFieldNumber = 1,
+    kMaxpacketFieldNumber = 2,
+    kMaxpacketLimitFieldNumber = 3,
+    kMaxStreamsFieldNumber = 4,
+    kMaxburstFieldNumber = 5,
+    kFlagsFieldNumber = 6,
+    kDirectionFieldNumber = 7,
+    kTrbEnqueueFieldNumber = 8,
+    kTrbDequeueFieldNumber = 9,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4WritepageFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Dwc3GadgetEpDisableFtraceEvent"; }
 
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4WritepageFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      Dwc3GadgetEpDisableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_Maxpacket =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4WritepageFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3GadgetEpDisableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_Maxpacket kMaxpacket{};
+  void set_maxpacket(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Maxpacket::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Index =
+  using FieldMetadata_MaxpacketLimit =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4WritepageFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3GadgetEpDisableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Index kIndex() { return {}; }
-  void set_index(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
+  static constexpr FieldMetadata_MaxpacketLimit kMaxpacketLimit{};
+  void set_maxpacket_limit(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MaxpacketLimit::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class Ext4WriteEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Ext4WriteEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4WriteEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4WriteEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_pos() const { return at<3>().valid(); }
-  int64_t pos() const { return at<3>().as_int64(); }
-  bool has_len() const { return at<4>().valid(); }
-  uint32_t len() const { return at<4>().as_uint32(); }
-  bool has_copied() const { return at<5>().valid(); }
-  uint32_t copied() const { return at<5>().as_uint32(); }
-};
 
-class Ext4WriteEndFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = Ext4WriteEndFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kPosFieldNumber = 3,
-    kLenFieldNumber = 4,
-    kCopiedFieldNumber = 5,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4WriteEndFtraceEvent"; }
+  using FieldMetadata_MaxStreams =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3GadgetEpDisableFtraceEvent>;
 
+  static constexpr FieldMetadata_MaxStreams kMaxStreams{};
+  void set_max_streams(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MaxStreams::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_Maxburst =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4WriteEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3GadgetEpDisableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_Maxburst kMaxburst{};
+  void set_maxburst(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Maxburst::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4WriteEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3GadgetEpDisableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pos =
+  using FieldMetadata_Direction =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4WriteEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3GadgetEpDisableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pos kPos() { return {}; }
-  void set_pos(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId;
+  static constexpr FieldMetadata_Direction kDirection{};
+  void set_direction(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Direction::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_TrbEnqueue =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4WriteEndFtraceEvent>;
+      Dwc3GadgetEpDisableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_TrbEnqueue kTrbEnqueue{};
+  void set_trb_enqueue(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TrbEnqueue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -77696,24 +111255,17 @@ class Ext4WriteEndFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Copied =
+  using FieldMetadata_TrbDequeue =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4WriteEndFtraceEvent>;
+      Dwc3GadgetEpDisableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Copied kCopied() { return {}; }
-  void set_copied(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Copied::kFieldId;
+  static constexpr FieldMetadata_TrbDequeue kTrbDequeue{};
+  void set_trb_dequeue(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TrbDequeue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -77722,129 +111274,110 @@ class Ext4WriteEndFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4WriteBeginFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Dwc3GadgetEpCmdFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  Ext4WriteBeginFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4WriteBeginFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4WriteBeginFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_pos() const { return at<3>().valid(); }
-  int64_t pos() const { return at<3>().as_int64(); }
-  bool has_len() const { return at<4>().valid(); }
-  uint32_t len() const { return at<4>().as_uint32(); }
-  bool has_flags() const { return at<5>().valid(); }
-  uint32_t flags() const { return at<5>().as_uint32(); }
+  Dwc3GadgetEpCmdFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Dwc3GadgetEpCmdFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Dwc3GadgetEpCmdFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_cmd() const { return at<2>().valid(); }
+  uint32_t cmd() const { return at<2>().as_uint32(); }
+  bool has_param0() const { return at<3>().valid(); }
+  uint32_t param0() const { return at<3>().as_uint32(); }
+  bool has_param1() const { return at<4>().valid(); }
+  uint32_t param1() const { return at<4>().as_uint32(); }
+  bool has_param2() const { return at<5>().valid(); }
+  uint32_t param2() const { return at<5>().as_uint32(); }
+  bool has_cmd_status() const { return at<6>().valid(); }
+  int32_t cmd_status() const { return at<6>().as_int32(); }
 };
 
-class Ext4WriteBeginFtraceEvent : public ::protozero::Message {
+class Dwc3GadgetEpCmdFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4WriteBeginFtraceEvent_Decoder;
+  using Decoder = Dwc3GadgetEpCmdFtraceEvent_Decoder;
   enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kPosFieldNumber = 3,
-    kLenFieldNumber = 4,
-    kFlagsFieldNumber = 5,
+    kNameFieldNumber = 1,
+    kCmdFieldNumber = 2,
+    kParam0FieldNumber = 3,
+    kParam1FieldNumber = 4,
+    kParam2FieldNumber = 5,
+    kCmdStatusFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4WriteBeginFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Dwc3GadgetEpCmdFtraceEvent"; }
 
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4WriteBeginFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      Dwc3GadgetEpCmdFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_Cmd =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4WriteBeginFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3GadgetEpCmdFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_Cmd kCmd{};
+  void set_cmd(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cmd::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pos =
+  using FieldMetadata_Param0 =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4WriteBeginFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3GadgetEpCmdFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pos kPos() { return {}; }
-  void set_pos(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId;
+  static constexpr FieldMetadata_Param0 kParam0{};
+  void set_param0(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Param0::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_Param1 =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4WriteBeginFtraceEvent>;
+      Dwc3GadgetEpCmdFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_Param1 kParam1{};
+  void set_param1(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Param1::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -77852,99 +111385,117 @@ class Ext4WriteBeginFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_Param2 =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4WriteBeginFtraceEvent>;
+      Dwc3GadgetEpCmdFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_Param2 kParam2{};
+  void set_param2(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Param2::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
 
-class Ext4UnlinkExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Ext4UnlinkExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4UnlinkExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4UnlinkExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_ret() const { return at<3>().valid(); }
-  int32_t ret() const { return at<3>().as_int32(); }
+  using FieldMetadata_CmdStatus =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Dwc3GadgetEpCmdFtraceEvent>;
+
+  static constexpr FieldMetadata_CmdStatus kCmdStatus{};
+  void set_cmd_status(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CmdStatus::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class Ext4UnlinkExitFtraceEvent : public ::protozero::Message {
+class Dwc3FreeRequestFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
  public:
-  using Decoder = Ext4UnlinkExitFtraceEvent_Decoder;
+  Dwc3FreeRequestFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Dwc3FreeRequestFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Dwc3FreeRequestFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_req() const { return at<2>().valid(); }
+  uint64_t req() const { return at<2>().as_uint64(); }
+  bool has_actual() const { return at<3>().valid(); }
+  uint32_t actual() const { return at<3>().as_uint32(); }
+  bool has_length() const { return at<4>().valid(); }
+  uint32_t length() const { return at<4>().as_uint32(); }
+  bool has_status() const { return at<5>().valid(); }
+  int32_t status() const { return at<5>().as_int32(); }
+  bool has_zero() const { return at<6>().valid(); }
+  int32_t zero() const { return at<6>().as_int32(); }
+  bool has_short_not_ok() const { return at<7>().valid(); }
+  int32_t short_not_ok() const { return at<7>().as_int32(); }
+  bool has_no_interrupt() const { return at<8>().valid(); }
+  int32_t no_interrupt() const { return at<8>().as_int32(); }
+};
+
+class Dwc3FreeRequestFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Dwc3FreeRequestFtraceEvent_Decoder;
   enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kRetFieldNumber = 3,
+    kNameFieldNumber = 1,
+    kReqFieldNumber = 2,
+    kActualFieldNumber = 3,
+    kLengthFieldNumber = 4,
+    kStatusFieldNumber = 5,
+    kZeroFieldNumber = 6,
+    kShortNotOkFieldNumber = 7,
+    kNoInterruptFieldNumber = 8,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4UnlinkExitFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Dwc3FreeRequestFtraceEvent"; }
 
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4UnlinkExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      Dwc3FreeRequestFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_Req =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4UnlinkExitFtraceEvent>;
+      Dwc3FreeRequestFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_Req kReq{};
+  void set_req(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Req::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -77952,327 +111503,274 @@ class Ext4UnlinkExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ret =
+  using FieldMetadata_Actual =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4UnlinkExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3FreeRequestFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+  static constexpr FieldMetadata_Actual kActual{};
+  void set_actual(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Actual::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class Ext4UnlinkEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Ext4UnlinkEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4UnlinkEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4UnlinkEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_parent() const { return at<3>().valid(); }
-  uint64_t parent() const { return at<3>().as_uint64(); }
-  bool has_size() const { return at<4>().valid(); }
-  int64_t size() const { return at<4>().as_int64(); }
-};
 
-class Ext4UnlinkEnterFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = Ext4UnlinkEnterFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kParentFieldNumber = 3,
-    kSizeFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4UnlinkEnterFtraceEvent"; }
+  using FieldMetadata_Length =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3FreeRequestFtraceEvent>;
 
+  static constexpr FieldMetadata_Length kLength{};
+  void set_length(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Length::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_Status =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4UnlinkEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Dwc3FreeRequestFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_Status kStatus{};
+  void set_status(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_Zero =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4UnlinkEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Dwc3FreeRequestFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_Zero kZero{};
+  void set_zero(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Zero::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Parent =
+  using FieldMetadata_ShortNotOk =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4UnlinkEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Dwc3FreeRequestFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Parent kParent() { return {}; }
-  void set_parent(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Parent::kFieldId;
+  static constexpr FieldMetadata_ShortNotOk kShortNotOk{};
+  void set_short_not_ok(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ShortNotOk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Size =
+  using FieldMetadata_NoInterrupt =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4UnlinkEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Dwc3FreeRequestFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Size kSize() { return {}; }
-  void set_size(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
+  static constexpr FieldMetadata_NoInterrupt kNoInterrupt{};
+  void set_no_interrupt(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NoInterrupt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4TruncateExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Dwc3EventFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  Ext4TruncateExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4TruncateExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4TruncateExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_blocks() const { return at<3>().valid(); }
-  uint64_t blocks() const { return at<3>().as_uint64(); }
+  Dwc3EventFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Dwc3EventFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Dwc3EventFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_event() const { return at<1>().valid(); }
+  uint32_t event() const { return at<1>().as_uint32(); }
+  bool has_ep0state() const { return at<2>().valid(); }
+  uint32_t ep0state() const { return at<2>().as_uint32(); }
+  bool has_str() const { return at<3>().valid(); }
+  ::protozero::ConstChars str() const { return at<3>().as_string(); }
 };
 
-class Ext4TruncateExitFtraceEvent : public ::protozero::Message {
+class Dwc3EventFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4TruncateExitFtraceEvent_Decoder;
+  using Decoder = Dwc3EventFtraceEvent_Decoder;
   enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kBlocksFieldNumber = 3,
+    kEventFieldNumber = 1,
+    kEp0stateFieldNumber = 2,
+    kStrFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4TruncateExitFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Dwc3EventFtraceEvent"; }
 
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_Event =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4TruncateExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3EventFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_Event kEvent{};
+  void set_event(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Event::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_Ep0state =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4TruncateExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3EventFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_Ep0state kEp0state{};
+  void set_ep0state(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ep0state::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Blocks =
+  using FieldMetadata_Str =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4TruncateExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      Dwc3EventFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Blocks kBlocks() { return {}; }
-  void set_blocks(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
+  static constexpr FieldMetadata_Str kStr{};
+  void set_str(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Str::kFieldId, data, size);
+  }
+  void set_str(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Str::kFieldId, chars.data, chars.size);
+  }
+  void set_str(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Str::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4TruncateEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Ext4TruncateEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4TruncateEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4TruncateEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_blocks() const { return at<3>().valid(); }
-  uint64_t blocks() const { return at<3>().as_uint64(); }
-};
-
-class Ext4TruncateEnterFtraceEvent : public ::protozero::Message {
+class Dwc3EpQueueFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
  public:
-  using Decoder = Ext4TruncateEnterFtraceEvent_Decoder;
+  Dwc3EpQueueFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Dwc3EpQueueFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Dwc3EpQueueFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_req() const { return at<2>().valid(); }
+  uint64_t req() const { return at<2>().as_uint64(); }
+  bool has_actual() const { return at<3>().valid(); }
+  uint32_t actual() const { return at<3>().as_uint32(); }
+  bool has_length() const { return at<4>().valid(); }
+  uint32_t length() const { return at<4>().as_uint32(); }
+  bool has_status() const { return at<5>().valid(); }
+  int32_t status() const { return at<5>().as_int32(); }
+  bool has_zero() const { return at<6>().valid(); }
+  int32_t zero() const { return at<6>().as_int32(); }
+  bool has_short_not_ok() const { return at<7>().valid(); }
+  int32_t short_not_ok() const { return at<7>().as_int32(); }
+  bool has_no_interrupt() const { return at<8>().valid(); }
+  int32_t no_interrupt() const { return at<8>().as_int32(); }
+};
+
+class Dwc3EpQueueFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Dwc3EpQueueFtraceEvent_Decoder;
   enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kBlocksFieldNumber = 3,
+    kNameFieldNumber = 1,
+    kReqFieldNumber = 2,
+    kActualFieldNumber = 3,
+    kLengthFieldNumber = 4,
+    kStatusFieldNumber = 5,
+    kZeroFieldNumber = 6,
+    kShortNotOkFieldNumber = 7,
+    kNoInterruptFieldNumber = 8,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4TruncateEnterFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Dwc3EpQueueFtraceEvent"; }
 
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4TruncateEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      Dwc3EpQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_Req =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4TruncateEnterFtraceEvent>;
+      Dwc3EpQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_Req kReq{};
+  void set_req(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Req::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -78280,105 +111778,53 @@ class Ext4TruncateEnterFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Blocks =
+  using FieldMetadata_Actual =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4TruncateEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3EpQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Blocks kBlocks() { return {}; }
-  void set_blocks(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
+  static constexpr FieldMetadata_Actual kActual{};
+  void set_actual(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Actual::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class Ext4TrimExtentFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Ext4TrimExtentFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4TrimExtentFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4TrimExtentFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev_major() const { return at<1>().valid(); }
-  int32_t dev_major() const { return at<1>().as_int32(); }
-  bool has_dev_minor() const { return at<2>().valid(); }
-  int32_t dev_minor() const { return at<2>().as_int32(); }
-  bool has_group() const { return at<3>().valid(); }
-  uint32_t group() const { return at<3>().as_uint32(); }
-  bool has_start() const { return at<4>().valid(); }
-  int32_t start() const { return at<4>().as_int32(); }
-  bool has_len() const { return at<5>().valid(); }
-  int32_t len() const { return at<5>().as_int32(); }
-};
-
-class Ext4TrimExtentFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = Ext4TrimExtentFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevMajorFieldNumber = 1,
-    kDevMinorFieldNumber = 2,
-    kGroupFieldNumber = 3,
-    kStartFieldNumber = 4,
-    kLenFieldNumber = 5,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4TrimExtentFtraceEvent"; }
-
 
-  using FieldMetadata_DevMajor =
+  using FieldMetadata_Length =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4TrimExtentFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3EpQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DevMajor kDevMajor() { return {}; }
-  void set_dev_major(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DevMajor::kFieldId;
+  static constexpr FieldMetadata_Length kLength{};
+  void set_length(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Length::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DevMinor =
+  using FieldMetadata_Status =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4TrimExtentFtraceEvent>;
+      Dwc3EpQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DevMinor kDevMinor() { return {}; }
-  void set_dev_minor(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DevMinor::kFieldId;
+  static constexpr FieldMetadata_Status kStatus{};
+  void set_status(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -78386,49 +111832,35 @@ class Ext4TrimExtentFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Group =
+  using FieldMetadata_Zero =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4TrimExtentFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Dwc3EpQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Group kGroup() { return {}; }
-  void set_group(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Group::kFieldId;
+  static constexpr FieldMetadata_Zero kZero{};
+  void set_zero(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Zero::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Start =
+  using FieldMetadata_ShortNotOk =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4TrimExtentFtraceEvent>;
+      Dwc3EpQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Start kStart() { return {}; }
-  void set_start(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
+  static constexpr FieldMetadata_ShortNotOk kShortNotOk{};
+  void set_short_not_ok(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ShortNotOk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -78436,24 +111868,17 @@ class Ext4TrimExtentFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_NoInterrupt =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4TrimExtentFtraceEvent>;
+      Dwc3EpQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_NoInterrupt kNoInterrupt{};
+  void set_no_interrupt(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NoInterrupt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -78462,104 +111887,98 @@ class Ext4TrimExtentFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4TrimAllFreeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Ext4TrimAllFreeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4TrimAllFreeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4TrimAllFreeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev_major() const { return at<1>().valid(); }
-  int32_t dev_major() const { return at<1>().as_int32(); }
-  bool has_dev_minor() const { return at<2>().valid(); }
-  int32_t dev_minor() const { return at<2>().as_int32(); }
-  bool has_group() const { return at<3>().valid(); }
-  uint32_t group() const { return at<3>().as_uint32(); }
-  bool has_start() const { return at<4>().valid(); }
-  int32_t start() const { return at<4>().as_int32(); }
-  bool has_len() const { return at<5>().valid(); }
-  int32_t len() const { return at<5>().as_int32(); }
-};
-
-class Ext4TrimAllFreeFtraceEvent : public ::protozero::Message {
+class Dwc3EpDequeueFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
  public:
-  using Decoder = Ext4TrimAllFreeFtraceEvent_Decoder;
+  Dwc3EpDequeueFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Dwc3EpDequeueFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Dwc3EpDequeueFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_req() const { return at<2>().valid(); }
+  uint64_t req() const { return at<2>().as_uint64(); }
+  bool has_actual() const { return at<3>().valid(); }
+  uint32_t actual() const { return at<3>().as_uint32(); }
+  bool has_length() const { return at<4>().valid(); }
+  uint32_t length() const { return at<4>().as_uint32(); }
+  bool has_status() const { return at<5>().valid(); }
+  int32_t status() const { return at<5>().as_int32(); }
+  bool has_zero() const { return at<6>().valid(); }
+  int32_t zero() const { return at<6>().as_int32(); }
+  bool has_short_not_ok() const { return at<7>().valid(); }
+  int32_t short_not_ok() const { return at<7>().as_int32(); }
+  bool has_no_interrupt() const { return at<8>().valid(); }
+  int32_t no_interrupt() const { return at<8>().as_int32(); }
+};
+
+class Dwc3EpDequeueFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Dwc3EpDequeueFtraceEvent_Decoder;
   enum : int32_t {
-    kDevMajorFieldNumber = 1,
-    kDevMinorFieldNumber = 2,
-    kGroupFieldNumber = 3,
-    kStartFieldNumber = 4,
-    kLenFieldNumber = 5,
+    kNameFieldNumber = 1,
+    kReqFieldNumber = 2,
+    kActualFieldNumber = 3,
+    kLengthFieldNumber = 4,
+    kStatusFieldNumber = 5,
+    kZeroFieldNumber = 6,
+    kShortNotOkFieldNumber = 7,
+    kNoInterruptFieldNumber = 8,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4TrimAllFreeFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Dwc3EpDequeueFtraceEvent"; }
 
 
-  using FieldMetadata_DevMajor =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4TrimAllFreeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      Dwc3EpDequeueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DevMajor kDevMajor() { return {}; }
-  void set_dev_major(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DevMajor::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DevMinor =
+  using FieldMetadata_Req =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4TrimAllFreeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Dwc3EpDequeueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DevMinor kDevMinor() { return {}; }
-  void set_dev_minor(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DevMinor::kFieldId;
+  static constexpr FieldMetadata_Req kReq{};
+  void set_req(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Req::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Group =
+  using FieldMetadata_Actual =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4TrimAllFreeFtraceEvent>;
+      Dwc3EpDequeueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Group kGroup() { return {}; }
-  void set_group(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Group::kFieldId;
+  static constexpr FieldMetadata_Actual kActual{};
+  void set_actual(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Actual::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -78567,342 +111986,177 @@ class Ext4TrimAllFreeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Start =
+  using FieldMetadata_Length =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4TrimAllFreeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3EpDequeueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Start kStart() { return {}; }
-  void set_start(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
+  static constexpr FieldMetadata_Length kLength{};
+  void set_length(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Length::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_Status =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4TrimAllFreeFtraceEvent>;
+      Dwc3EpDequeueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_Status kStatus{};
+  void set_status(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-class Ext4SyncFsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Ext4SyncFsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4SyncFsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4SyncFsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_wait() const { return at<2>().valid(); }
-  int32_t wait() const { return at<2>().as_int32(); }
-};
-
-class Ext4SyncFsFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = Ext4SyncFsFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kWaitFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4SyncFsFtraceEvent"; }
-
-
-  using FieldMetadata_Dev =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4SyncFsFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
 
-  using FieldMetadata_Wait =
+  using FieldMetadata_Zero =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4SyncFsFtraceEvent>;
+      Dwc3EpDequeueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Wait kWait() { return {}; }
-  void set_wait(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Wait::kFieldId;
+  static constexpr FieldMetadata_Zero kZero{};
+  void set_zero(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Zero::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-class Ext4RequestInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Ext4RequestInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4RequestInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4RequestInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_dir() const { return at<2>().valid(); }
-  uint64_t dir() const { return at<2>().as_uint64(); }
-  bool has_mode() const { return at<3>().valid(); }
-  uint32_t mode() const { return at<3>().as_uint32(); }
-};
-
-class Ext4RequestInodeFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = Ext4RequestInodeFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kDirFieldNumber = 2,
-    kModeFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4RequestInodeFtraceEvent"; }
-
-
-  using FieldMetadata_Dev =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4RequestInodeFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
 
-  using FieldMetadata_Dir =
+  using FieldMetadata_ShortNotOk =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4RequestInodeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Dwc3EpDequeueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dir kDir() { return {}; }
-  void set_dir(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dir::kFieldId;
+  static constexpr FieldMetadata_ShortNotOk kShortNotOk{};
+  void set_short_not_ok(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ShortNotOk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Mode =
+  using FieldMetadata_NoInterrupt =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4RequestInodeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Dwc3EpDequeueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mode kMode() { return {}; }
-  void set_mode(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+  static constexpr FieldMetadata_NoInterrupt kNoInterrupt{};
+  void set_no_interrupt(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NoInterrupt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4RequestBlocksFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Dwc3CtrlReqFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  Ext4RequestBlocksFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4RequestBlocksFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4RequestBlocksFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_len() const { return at<3>().valid(); }
-  uint32_t len() const { return at<3>().as_uint32(); }
-  bool has_logical() const { return at<4>().valid(); }
-  uint32_t logical() const { return at<4>().as_uint32(); }
-  bool has_lleft() const { return at<5>().valid(); }
-  uint32_t lleft() const { return at<5>().as_uint32(); }
-  bool has_lright() const { return at<6>().valid(); }
-  uint32_t lright() const { return at<6>().as_uint32(); }
-  bool has_goal() const { return at<7>().valid(); }
-  uint64_t goal() const { return at<7>().as_uint64(); }
-  bool has_pleft() const { return at<8>().valid(); }
-  uint64_t pleft() const { return at<8>().as_uint64(); }
-  bool has_pright() const { return at<9>().valid(); }
-  uint64_t pright() const { return at<9>().as_uint64(); }
-  bool has_flags() const { return at<10>().valid(); }
-  uint32_t flags() const { return at<10>().as_uint32(); }
+  Dwc3CtrlReqFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Dwc3CtrlReqFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Dwc3CtrlReqFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_brequesttype() const { return at<1>().valid(); }
+  uint32_t brequesttype() const { return at<1>().as_uint32(); }
+  bool has_brequest() const { return at<2>().valid(); }
+  uint32_t brequest() const { return at<2>().as_uint32(); }
+  bool has_wvalue() const { return at<3>().valid(); }
+  uint32_t wvalue() const { return at<3>().as_uint32(); }
+  bool has_windex() const { return at<4>().valid(); }
+  uint32_t windex() const { return at<4>().as_uint32(); }
+  bool has_wlength() const { return at<5>().valid(); }
+  uint32_t wlength() const { return at<5>().as_uint32(); }
+  bool has_str() const { return at<6>().valid(); }
+  ::protozero::ConstChars str() const { return at<6>().as_string(); }
 };
 
-class Ext4RequestBlocksFtraceEvent : public ::protozero::Message {
+class Dwc3CtrlReqFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4RequestBlocksFtraceEvent_Decoder;
+  using Decoder = Dwc3CtrlReqFtraceEvent_Decoder;
   enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kLenFieldNumber = 3,
-    kLogicalFieldNumber = 4,
-    kLleftFieldNumber = 5,
-    kLrightFieldNumber = 6,
-    kGoalFieldNumber = 7,
-    kPleftFieldNumber = 8,
-    kPrightFieldNumber = 9,
-    kFlagsFieldNumber = 10,
+    kBRequestTypeFieldNumber = 1,
+    kBRequestFieldNumber = 2,
+    kWValueFieldNumber = 3,
+    kWIndexFieldNumber = 4,
+    kWLengthFieldNumber = 5,
+    kStrFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4RequestBlocksFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Dwc3CtrlReqFtraceEvent"; }
 
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_BRequestType =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4RequestBlocksFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3CtrlReqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_BRequestType kBRequestType{};
+  void set_brequesttype(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BRequestType::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_BRequest =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4RequestBlocksFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3CtrlReqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_BRequest kBRequest{};
+  void set_brequest(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BRequest::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_WValue =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4RequestBlocksFtraceEvent>;
+      Dwc3CtrlReqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_WValue kWValue{};
+  void set_wvalue(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_WValue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -78910,24 +112164,17 @@ class Ext4RequestBlocksFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Logical =
+  using FieldMetadata_WIndex =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4RequestBlocksFtraceEvent>;
+      Dwc3CtrlReqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Logical kLogical() { return {}; }
-  void set_logical(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Logical::kFieldId;
+  static constexpr FieldMetadata_WIndex kWIndex{};
+  void set_windex(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_WIndex::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -78935,24 +112182,17 @@ class Ext4RequestBlocksFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Lleft =
+  using FieldMetadata_WLength =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4RequestBlocksFtraceEvent>;
+      Dwc3CtrlReqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lleft kLleft() { return {}; }
-  void set_lleft(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lleft::kFieldId;
+  static constexpr FieldMetadata_WLength kWLength{};
+  void set_wlength(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_WLength::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -78960,223 +112200,114 @@ class Ext4RequestBlocksFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Lright =
+  using FieldMetadata_Str =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4RequestBlocksFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lright kLright() { return {}; }
-  void set_lright(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lright::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Goal =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4RequestBlocksFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Goal kGoal() { return {}; }
-  void set_goal(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Goal::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Pleft =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4RequestBlocksFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pleft kPleft() { return {}; }
-  void set_pleft(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pleft::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Pright =
-    ::protozero::proto_utils::FieldMetadata<
-      9,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4RequestBlocksFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pright kPright() { return {}; }
-  void set_pright(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pright::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Flags =
-    ::protozero::proto_utils::FieldMetadata<
-      10,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4RequestBlocksFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      Dwc3CtrlReqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_Str kStr{};
+  void set_str(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Str::kFieldId, data, size);
+  }
+  void set_str(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Str::kFieldId, chars.data, chars.size);
+  }
+  void set_str(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Str::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
   }
 };
 
-class Ext4RemoveBlocksFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Ext4RemoveBlocksFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4RemoveBlocksFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4RemoveBlocksFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_from() const { return at<3>().valid(); }
-  uint32_t from() const { return at<3>().as_uint32(); }
-  bool has_to() const { return at<4>().valid(); }
-  uint32_t to() const { return at<4>().as_uint32(); }
-  bool has_partial() const { return at<5>().valid(); }
-  int64_t partial() const { return at<5>().as_int64(); }
-  bool has_ee_pblk() const { return at<6>().valid(); }
-  uint64_t ee_pblk() const { return at<6>().as_uint64(); }
-  bool has_ee_lblk() const { return at<7>().valid(); }
-  uint32_t ee_lblk() const { return at<7>().as_uint32(); }
-  bool has_ee_len() const { return at<8>().valid(); }
-  uint32_t ee_len() const { return at<8>().as_uint32(); }
-  bool has_pc_lblk() const { return at<9>().valid(); }
-  uint32_t pc_lblk() const { return at<9>().as_uint32(); }
-  bool has_pc_pclu() const { return at<10>().valid(); }
-  uint64_t pc_pclu() const { return at<10>().as_uint64(); }
-  bool has_pc_state() const { return at<11>().valid(); }
-  int32_t pc_state() const { return at<11>().as_int32(); }
-};
-
-class Ext4RemoveBlocksFtraceEvent : public ::protozero::Message {
+class Dwc3CompleteTrbFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11> {
  public:
-  using Decoder = Ext4RemoveBlocksFtraceEvent_Decoder;
+  Dwc3CompleteTrbFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Dwc3CompleteTrbFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Dwc3CompleteTrbFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_trb() const { return at<2>().valid(); }
+  uint64_t trb() const { return at<2>().as_uint64(); }
+  bool has_allocated() const { return at<3>().valid(); }
+  uint32_t allocated() const { return at<3>().as_uint32(); }
+  bool has_queued() const { return at<4>().valid(); }
+  uint32_t queued() const { return at<4>().as_uint32(); }
+  bool has_bpl() const { return at<5>().valid(); }
+  uint32_t bpl() const { return at<5>().as_uint32(); }
+  bool has_bph() const { return at<6>().valid(); }
+  uint32_t bph() const { return at<6>().as_uint32(); }
+  bool has_size() const { return at<7>().valid(); }
+  uint32_t size() const { return at<7>().as_uint32(); }
+  bool has_ctrl() const { return at<8>().valid(); }
+  uint32_t ctrl() const { return at<8>().as_uint32(); }
+  bool has_type() const { return at<9>().valid(); }
+  uint32_t type() const { return at<9>().as_uint32(); }
+  bool has_enqueue() const { return at<10>().valid(); }
+  uint32_t enqueue() const { return at<10>().as_uint32(); }
+  bool has_dequeue() const { return at<11>().valid(); }
+  uint32_t dequeue() const { return at<11>().as_uint32(); }
+};
+
+class Dwc3CompleteTrbFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Dwc3CompleteTrbFtraceEvent_Decoder;
   enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kFromFieldNumber = 3,
-    kToFieldNumber = 4,
-    kPartialFieldNumber = 5,
-    kEePblkFieldNumber = 6,
-    kEeLblkFieldNumber = 7,
-    kEeLenFieldNumber = 8,
-    kPcLblkFieldNumber = 9,
-    kPcPcluFieldNumber = 10,
-    kPcStateFieldNumber = 11,
+    kNameFieldNumber = 1,
+    kTrbFieldNumber = 2,
+    kAllocatedFieldNumber = 3,
+    kQueuedFieldNumber = 4,
+    kBplFieldNumber = 5,
+    kBphFieldNumber = 6,
+    kSizeFieldNumber = 7,
+    kCtrlFieldNumber = 8,
+    kTypeFieldNumber = 9,
+    kEnqueueFieldNumber = 10,
+    kDequeueFieldNumber = 11,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4RemoveBlocksFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Dwc3CompleteTrbFtraceEvent"; }
 
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4RemoveBlocksFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      Dwc3CompleteTrbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_Trb =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4RemoveBlocksFtraceEvent>;
+      Dwc3CompleteTrbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_Trb kTrb{};
+  void set_trb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Trb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -79184,24 +112315,17 @@ class Ext4RemoveBlocksFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_From =
+  using FieldMetadata_Allocated =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4RemoveBlocksFtraceEvent>;
+      Dwc3CompleteTrbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_From kFrom() { return {}; }
-  void set_from(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_From::kFieldId;
+  static constexpr FieldMetadata_Allocated kAllocated{};
+  void set_allocated(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Allocated::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -79209,24 +112333,17 @@ class Ext4RemoveBlocksFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_To =
+  using FieldMetadata_Queued =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4RemoveBlocksFtraceEvent>;
+      Dwc3CompleteTrbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_To kTo() { return {}; }
-  void set_to(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_To::kFieldId;
+  static constexpr FieldMetadata_Queued kQueued{};
+  void set_queued(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Queued::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -79234,74 +112351,53 @@ class Ext4RemoveBlocksFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Partial =
+  using FieldMetadata_Bpl =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4RemoveBlocksFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3CompleteTrbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Partial kPartial() { return {}; }
-  void set_partial(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Partial::kFieldId;
+  static constexpr FieldMetadata_Bpl kBpl{};
+  void set_bpl(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Bpl::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_EePblk =
+  using FieldMetadata_Bph =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4RemoveBlocksFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3CompleteTrbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EePblk kEePblk() { return {}; }
-  void set_ee_pblk(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EePblk::kFieldId;
+  static constexpr FieldMetadata_Bph kBph{};
+  void set_bph(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Bph::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_EeLblk =
+  using FieldMetadata_Size =
     ::protozero::proto_utils::FieldMetadata<
       7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4RemoveBlocksFtraceEvent>;
+      Dwc3CompleteTrbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EeLblk kEeLblk() { return {}; }
-  void set_ee_lblk(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EeLblk::kFieldId;
+  static constexpr FieldMetadata_Size kSize{};
+  void set_size(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -79309,24 +112405,17 @@ class Ext4RemoveBlocksFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_EeLen =
+  using FieldMetadata_Ctrl =
     ::protozero::proto_utils::FieldMetadata<
       8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4RemoveBlocksFtraceEvent>;
+      Dwc3CompleteTrbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EeLen kEeLen() { return {}; }
-  void set_ee_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EeLen::kFieldId;
+  static constexpr FieldMetadata_Ctrl kCtrl{};
+  void set_ctrl(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ctrl::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -79334,24 +112423,17 @@ class Ext4RemoveBlocksFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PcLblk =
+  using FieldMetadata_Type =
     ::protozero::proto_utils::FieldMetadata<
       9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4RemoveBlocksFtraceEvent>;
+      Dwc3CompleteTrbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PcLblk kPcLblk() { return {}; }
-  void set_pc_lblk(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PcLblk::kFieldId;
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -79359,124 +112441,117 @@ class Ext4RemoveBlocksFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PcPclu =
+  using FieldMetadata_Enqueue =
     ::protozero::proto_utils::FieldMetadata<
       10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4RemoveBlocksFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3CompleteTrbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PcPclu kPcPclu() { return {}; }
-  void set_pc_pclu(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PcPclu::kFieldId;
+  static constexpr FieldMetadata_Enqueue kEnqueue{};
+  void set_enqueue(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Enqueue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PcState =
+  using FieldMetadata_Dequeue =
     ::protozero::proto_utils::FieldMetadata<
       11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4RemoveBlocksFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3CompleteTrbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PcState kPcState() { return {}; }
-  void set_pc_state(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PcState::kFieldId;
+  static constexpr FieldMetadata_Dequeue kDequeue{};
+  void set_dequeue(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dequeue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4ReleasepageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Ext4ReleasepageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4ReleasepageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4ReleasepageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_index() const { return at<3>().valid(); }
-  uint64_t index() const { return at<3>().as_uint64(); }
-};
-
-class Ext4ReleasepageFtraceEvent : public ::protozero::Message {
+class Dwc3AllocRequestFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
  public:
-  using Decoder = Ext4ReleasepageFtraceEvent_Decoder;
+  Dwc3AllocRequestFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Dwc3AllocRequestFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Dwc3AllocRequestFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_req() const { return at<2>().valid(); }
+  uint64_t req() const { return at<2>().as_uint64(); }
+  bool has_actual() const { return at<3>().valid(); }
+  uint32_t actual() const { return at<3>().as_uint32(); }
+  bool has_length() const { return at<4>().valid(); }
+  uint32_t length() const { return at<4>().as_uint32(); }
+  bool has_status() const { return at<5>().valid(); }
+  int32_t status() const { return at<5>().as_int32(); }
+  bool has_zero() const { return at<6>().valid(); }
+  int32_t zero() const { return at<6>().as_int32(); }
+  bool has_short_not_ok() const { return at<7>().valid(); }
+  int32_t short_not_ok() const { return at<7>().as_int32(); }
+  bool has_no_interrupt() const { return at<8>().valid(); }
+  int32_t no_interrupt() const { return at<8>().as_int32(); }
+};
+
+class Dwc3AllocRequestFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Dwc3AllocRequestFtraceEvent_Decoder;
   enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kIndexFieldNumber = 3,
+    kNameFieldNumber = 1,
+    kReqFieldNumber = 2,
+    kActualFieldNumber = 3,
+    kLengthFieldNumber = 4,
+    kStatusFieldNumber = 5,
+    kZeroFieldNumber = 6,
+    kShortNotOkFieldNumber = 7,
+    kNoInterruptFieldNumber = 8,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ReleasepageFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Dwc3AllocRequestFtraceEvent"; }
 
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4ReleasepageFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      Dwc3AllocRequestFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_Req =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ReleasepageFtraceEvent>;
+      Dwc3AllocRequestFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_Req kReq{};
+  void set_req(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Req::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -79484,237 +112559,144 @@ class Ext4ReleasepageFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Index =
+  using FieldMetadata_Actual =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4ReleasepageFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3AllocRequestFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Index kIndex() { return {}; }
-  void set_index(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
+  static constexpr FieldMetadata_Actual kActual{};
+  void set_actual(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Actual::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class Ext4ReadpageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Ext4ReadpageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4ReadpageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4ReadpageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_index() const { return at<3>().valid(); }
-  uint64_t index() const { return at<3>().as_uint64(); }
-};
 
-class Ext4ReadpageFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = Ext4ReadpageFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kIndexFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ReadpageFtraceEvent"; }
-
-
-  using FieldMetadata_Dev =
+  using FieldMetadata_Length =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4ReadpageFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Dwc3AllocRequestFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_Length kLength{};
+  void set_length(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Length::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_Status =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4ReadpageFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Dwc3AllocRequestFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_Status kStatus{};
+  void set_status(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Index =
+  using FieldMetadata_Zero =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4ReadpageFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Dwc3AllocRequestFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Index kIndex() { return {}; }
-  void set_index(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
+  static constexpr FieldMetadata_Zero kZero{};
+  void set_zero(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Zero::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-class Ext4ReadBlockBitmapLoadFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Ext4ReadBlockBitmapLoadFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4ReadBlockBitmapLoadFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4ReadBlockBitmapLoadFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_group() const { return at<2>().valid(); }
-  uint32_t group() const { return at<2>().as_uint32(); }
-  bool has_prefetch() const { return at<3>().valid(); }
-  uint32_t prefetch() const { return at<3>().as_uint32(); }
-};
-
-class Ext4ReadBlockBitmapLoadFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = Ext4ReadBlockBitmapLoadFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kGroupFieldNumber = 2,
-    kPrefetchFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ReadBlockBitmapLoadFtraceEvent"; }
-
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_ShortNotOk =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4ReadBlockBitmapLoadFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Dwc3AllocRequestFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_ShortNotOk kShortNotOk{};
+  void set_short_not_ok(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ShortNotOk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Group =
+  using FieldMetadata_NoInterrupt =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4ReadBlockBitmapLoadFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Dwc3AllocRequestFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Group kGroup() { return {}; }
-  void set_group(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Group::kFieldId;
+  static constexpr FieldMetadata_NoInterrupt kNoInterrupt{};
+  void set_no_interrupt(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NoInterrupt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Prefetch =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4ReadBlockBitmapLoadFtraceEvent>;
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/ext4.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Prefetch kPrefetch() { return {}; }
-  void set_prefetch(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Prefetch::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-};
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_EXT4_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_EXT4_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-class Ext4PunchHoleFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class Ext4ZeroRangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  Ext4PunchHoleFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4PunchHoleFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4PunchHoleFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4ZeroRangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4ZeroRangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4ZeroRangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
@@ -79727,9 +112709,9 @@ class Ext4PunchHoleFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</
   int32_t mode() const { return at<5>().as_int32(); }
 };
 
-class Ext4PunchHoleFtraceEvent : public ::protozero::Message {
+class Ext4ZeroRangeFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4PunchHoleFtraceEvent_Decoder;
+  using Decoder = Ext4ZeroRangeFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
@@ -79737,7 +112719,7 @@ class Ext4PunchHoleFtraceEvent : public ::protozero::Message {
     kLenFieldNumber = 4,
     kModeFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4PunchHoleFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ZeroRangeFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -79746,16 +112728,9 @@ class Ext4PunchHoleFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4PunchHoleFtraceEvent>;
+      Ext4ZeroRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -79771,16 +112746,9 @@ class Ext4PunchHoleFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4PunchHoleFtraceEvent>;
+      Ext4ZeroRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -79796,16 +112764,9 @@ class Ext4PunchHoleFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt64,
       int64_t,
-      Ext4PunchHoleFtraceEvent>;
+      Ext4ZeroRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Offset kOffset() { return {}; }
+  static constexpr FieldMetadata_Offset kOffset{};
   void set_offset(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -79821,16 +112782,9 @@ class Ext4PunchHoleFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt64,
       int64_t,
-      Ext4PunchHoleFtraceEvent>;
+      Ext4ZeroRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
+  static constexpr FieldMetadata_Len kLen{};
   void set_len(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -79846,16 +112800,9 @@ class Ext4PunchHoleFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4PunchHoleFtraceEvent>;
+      Ext4ZeroRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mode kMode() { return {}; }
+  static constexpr FieldMetadata_Mode kMode{};
   void set_mode(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -79866,37 +112813,40 @@ class Ext4PunchHoleFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4OtherInodeUpdateTimeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4WritepagesResultFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
-  Ext4OtherInodeUpdateTimeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4OtherInodeUpdateTimeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4OtherInodeUpdateTimeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4WritepagesResultFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4WritepagesResultFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4WritepagesResultFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_orig_ino() const { return at<3>().valid(); }
-  uint64_t orig_ino() const { return at<3>().as_uint64(); }
-  bool has_uid() const { return at<4>().valid(); }
-  uint32_t uid() const { return at<4>().as_uint32(); }
-  bool has_gid() const { return at<5>().valid(); }
-  uint32_t gid() const { return at<5>().as_uint32(); }
-  bool has_mode() const { return at<6>().valid(); }
-  uint32_t mode() const { return at<6>().as_uint32(); }
+  bool has_ret() const { return at<3>().valid(); }
+  int32_t ret() const { return at<3>().as_int32(); }
+  bool has_pages_written() const { return at<4>().valid(); }
+  int32_t pages_written() const { return at<4>().as_int32(); }
+  bool has_pages_skipped() const { return at<5>().valid(); }
+  int64_t pages_skipped() const { return at<5>().as_int64(); }
+  bool has_writeback_index() const { return at<6>().valid(); }
+  uint64_t writeback_index() const { return at<6>().as_uint64(); }
+  bool has_sync_mode() const { return at<7>().valid(); }
+  int32_t sync_mode() const { return at<7>().as_int32(); }
 };
 
-class Ext4OtherInodeUpdateTimeFtraceEvent : public ::protozero::Message {
+class Ext4WritepagesResultFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4OtherInodeUpdateTimeFtraceEvent_Decoder;
+  using Decoder = Ext4WritepagesResultFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kOrigInoFieldNumber = 3,
-    kUidFieldNumber = 4,
-    kGidFieldNumber = 5,
-    kModeFieldNumber = 6,
+    kRetFieldNumber = 3,
+    kPagesWrittenFieldNumber = 4,
+    kPagesSkippedFieldNumber = 5,
+    kWritebackIndexFieldNumber = 6,
+    kSyncModeFieldNumber = 7,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4OtherInodeUpdateTimeFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4WritepagesResultFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -79905,16 +112855,9 @@ class Ext4OtherInodeUpdateTimeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4OtherInodeUpdateTimeFtraceEvent>;
+      Ext4WritepagesResultFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -79930,16 +112873,9 @@ class Ext4OtherInodeUpdateTimeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4OtherInodeUpdateTimeFtraceEvent>;
+      Ext4WritepagesResultFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -79949,150 +112885,140 @@ class Ext4OtherInodeUpdateTimeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_OrigIno =
+  using FieldMetadata_Ret =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4OtherInodeUpdateTimeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4WritepagesResultFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OrigIno kOrigIno() { return {}; }
-  void set_orig_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OrigIno::kFieldId;
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Uid =
+  using FieldMetadata_PagesWritten =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4OtherInodeUpdateTimeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4WritepagesResultFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Uid kUid() { return {}; }
-  void set_uid(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId;
+  static constexpr FieldMetadata_PagesWritten kPagesWritten{};
+  void set_pages_written(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PagesWritten::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Gid =
+  using FieldMetadata_PagesSkipped =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4OtherInodeUpdateTimeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4WritepagesResultFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Gid kGid() { return {}; }
-  void set_gid(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Gid::kFieldId;
+  static constexpr FieldMetadata_PagesSkipped kPagesSkipped{};
+  void set_pages_skipped(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PagesSkipped::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Mode =
+  using FieldMetadata_WritebackIndex =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4OtherInodeUpdateTimeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4WritepagesResultFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mode kMode() { return {}; }
-  void set_mode(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+  static constexpr FieldMetadata_WritebackIndex kWritebackIndex{};
+  void set_writeback_index(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_WritebackIndex::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SyncMode =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4WritepagesResultFtraceEvent>;
+
+  static constexpr FieldMetadata_SyncMode kSyncMode{};
+  void set_sync_mode(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SyncMode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4MballocPreallocFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4WritepagesFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10> {
  public:
-  Ext4MballocPreallocFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4MballocPreallocFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4MballocPreallocFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4WritepagesFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4WritepagesFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4WritepagesFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_orig_logical() const { return at<3>().valid(); }
-  uint32_t orig_logical() const { return at<3>().as_uint32(); }
-  bool has_orig_start() const { return at<4>().valid(); }
-  int32_t orig_start() const { return at<4>().as_int32(); }
-  bool has_orig_group() const { return at<5>().valid(); }
-  uint32_t orig_group() const { return at<5>().as_uint32(); }
-  bool has_orig_len() const { return at<6>().valid(); }
-  int32_t orig_len() const { return at<6>().as_int32(); }
-  bool has_result_logical() const { return at<7>().valid(); }
-  uint32_t result_logical() const { return at<7>().as_uint32(); }
-  bool has_result_start() const { return at<8>().valid(); }
-  int32_t result_start() const { return at<8>().as_int32(); }
-  bool has_result_group() const { return at<9>().valid(); }
-  uint32_t result_group() const { return at<9>().as_uint32(); }
-  bool has_result_len() const { return at<10>().valid(); }
-  int32_t result_len() const { return at<10>().as_int32(); }
+  bool has_nr_to_write() const { return at<3>().valid(); }
+  int64_t nr_to_write() const { return at<3>().as_int64(); }
+  bool has_pages_skipped() const { return at<4>().valid(); }
+  int64_t pages_skipped() const { return at<4>().as_int64(); }
+  bool has_range_start() const { return at<5>().valid(); }
+  int64_t range_start() const { return at<5>().as_int64(); }
+  bool has_range_end() const { return at<6>().valid(); }
+  int64_t range_end() const { return at<6>().as_int64(); }
+  bool has_writeback_index() const { return at<7>().valid(); }
+  uint64_t writeback_index() const { return at<7>().as_uint64(); }
+  bool has_sync_mode() const { return at<8>().valid(); }
+  int32_t sync_mode() const { return at<8>().as_int32(); }
+  bool has_for_kupdate() const { return at<9>().valid(); }
+  uint32_t for_kupdate() const { return at<9>().as_uint32(); }
+  bool has_range_cyclic() const { return at<10>().valid(); }
+  uint32_t range_cyclic() const { return at<10>().as_uint32(); }
 };
 
-class Ext4MballocPreallocFtraceEvent : public ::protozero::Message {
+class Ext4WritepagesFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4MballocPreallocFtraceEvent_Decoder;
+  using Decoder = Ext4WritepagesFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kOrigLogicalFieldNumber = 3,
-    kOrigStartFieldNumber = 4,
-    kOrigGroupFieldNumber = 5,
-    kOrigLenFieldNumber = 6,
-    kResultLogicalFieldNumber = 7,
-    kResultStartFieldNumber = 8,
-    kResultGroupFieldNumber = 9,
-    kResultLenFieldNumber = 10,
+    kNrToWriteFieldNumber = 3,
+    kPagesSkippedFieldNumber = 4,
+    kRangeStartFieldNumber = 5,
+    kRangeEndFieldNumber = 6,
+    kWritebackIndexFieldNumber = 7,
+    kSyncModeFieldNumber = 8,
+    kForKupdateFieldNumber = 9,
+    kRangeCyclicFieldNumber = 10,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MballocPreallocFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4WritepagesFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -80101,16 +113027,9 @@ class Ext4MballocPreallocFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4MballocPreallocFtraceEvent>;
+      Ext4WritepagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -80126,16 +113045,9 @@ class Ext4MballocPreallocFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4MballocPreallocFtraceEvent>;
+      Ext4WritepagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -80145,149 +113057,107 @@ class Ext4MballocPreallocFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_OrigLogical =
+  using FieldMetadata_NrToWrite =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4MballocPreallocFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4WritepagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OrigLogical kOrigLogical() { return {}; }
-  void set_orig_logical(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OrigLogical::kFieldId;
+  static constexpr FieldMetadata_NrToWrite kNrToWrite{};
+  void set_nr_to_write(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NrToWrite::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_OrigStart =
+  using FieldMetadata_PagesSkipped =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4MballocPreallocFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4WritepagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OrigStart kOrigStart() { return {}; }
-  void set_orig_start(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OrigStart::kFieldId;
+  static constexpr FieldMetadata_PagesSkipped kPagesSkipped{};
+  void set_pages_skipped(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PagesSkipped::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_OrigGroup =
+  using FieldMetadata_RangeStart =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4MballocPreallocFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4WritepagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OrigGroup kOrigGroup() { return {}; }
-  void set_orig_group(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OrigGroup::kFieldId;
+  static constexpr FieldMetadata_RangeStart kRangeStart{};
+  void set_range_start(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RangeStart::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_OrigLen =
+  using FieldMetadata_RangeEnd =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4MballocPreallocFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4WritepagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OrigLen kOrigLen() { return {}; }
-  void set_orig_len(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OrigLen::kFieldId;
+  static constexpr FieldMetadata_RangeEnd kRangeEnd{};
+  void set_range_end(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RangeEnd::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ResultLogical =
+  using FieldMetadata_WritebackIndex =
     ::protozero::proto_utils::FieldMetadata<
       7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4MballocPreallocFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4WritepagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ResultLogical kResultLogical() { return {}; }
-  void set_result_logical(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ResultLogical::kFieldId;
+  static constexpr FieldMetadata_WritebackIndex kWritebackIndex{};
+  void set_writeback_index(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_WritebackIndex::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ResultStart =
+  using FieldMetadata_SyncMode =
     ::protozero::proto_utils::FieldMetadata<
       8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4MballocPreallocFtraceEvent>;
+      Ext4WritepagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ResultStart kResultStart() { return {}; }
-  void set_result_start(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ResultStart::kFieldId;
+  static constexpr FieldMetadata_SyncMode kSyncMode{};
+  void set_sync_mode(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SyncMode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -80295,24 +113165,17 @@ class Ext4MballocPreallocFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ResultGroup =
+  using FieldMetadata_ForKupdate =
     ::protozero::proto_utils::FieldMetadata<
       9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4MballocPreallocFtraceEvent>;
+      Ext4WritepagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ResultGroup kResultGroup() { return {}; }
-  void set_result_group(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ResultGroup::kFieldId;
+  static constexpr FieldMetadata_ForKupdate kForKupdate{};
+  void set_for_kupdate(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ForKupdate::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -80320,216 +113183,47 @@ class Ext4MballocPreallocFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ResultLen =
+  using FieldMetadata_RangeCyclic =
     ::protozero::proto_utils::FieldMetadata<
       10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4MballocPreallocFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ResultLen kResultLen() { return {}; }
-  void set_result_len(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ResultLen::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-};
-
-class Ext4MballocFreeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Ext4MballocFreeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4MballocFreeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4MballocFreeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_result_start() const { return at<3>().valid(); }
-  int32_t result_start() const { return at<3>().as_int32(); }
-  bool has_result_group() const { return at<4>().valid(); }
-  uint32_t result_group() const { return at<4>().as_uint32(); }
-  bool has_result_len() const { return at<5>().valid(); }
-  int32_t result_len() const { return at<5>().as_int32(); }
-};
-
-class Ext4MballocFreeFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = Ext4MballocFreeFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kResultStartFieldNumber = 3,
-    kResultGroupFieldNumber = 4,
-    kResultLenFieldNumber = 5,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MballocFreeFtraceEvent"; }
-
-
-  using FieldMetadata_Dev =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4MballocFreeFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Ino =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4MballocFreeFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ResultStart =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4MballocFreeFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ResultStart kResultStart() { return {}; }
-  void set_result_start(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ResultStart::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ResultGroup =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4MballocFreeFtraceEvent>;
+      Ext4WritepagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ResultGroup kResultGroup() { return {}; }
-  void set_result_group(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ResultGroup::kFieldId;
+  static constexpr FieldMetadata_RangeCyclic kRangeCyclic{};
+  void set_range_cyclic(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RangeCyclic::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-
-  using FieldMetadata_ResultLen =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4MballocFreeFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ResultLen kResultLen() { return {}; }
-  void set_result_len(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ResultLen::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
 };
 
-class Ext4MballocDiscardFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4WritepageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  Ext4MballocDiscardFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4MballocDiscardFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4MballocDiscardFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4WritepageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4WritepageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4WritepageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_result_start() const { return at<3>().valid(); }
-  int32_t result_start() const { return at<3>().as_int32(); }
-  bool has_result_group() const { return at<4>().valid(); }
-  uint32_t result_group() const { return at<4>().as_uint32(); }
-  bool has_result_len() const { return at<5>().valid(); }
-  int32_t result_len() const { return at<5>().as_int32(); }
+  bool has_index() const { return at<3>().valid(); }
+  uint64_t index() const { return at<3>().as_uint64(); }
 };
 
-class Ext4MballocDiscardFtraceEvent : public ::protozero::Message {
+class Ext4WritepageFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4MballocDiscardFtraceEvent_Decoder;
+  using Decoder = Ext4WritepageFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kResultStartFieldNumber = 3,
-    kResultGroupFieldNumber = 4,
-    kResultLenFieldNumber = 5,
+    kIndexFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MballocDiscardFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4WritepageFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -80538,16 +113232,9 @@ class Ext4MballocDiscardFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4MballocDiscardFtraceEvent>;
+      Ext4WritepageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -80563,16 +113250,9 @@ class Ext4MballocDiscardFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4MballocDiscardFtraceEvent>;
+      Ext4WritepageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -80582,155 +113262,53 @@ class Ext4MballocDiscardFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ResultStart =
+  using FieldMetadata_Index =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4MballocDiscardFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ResultStart kResultStart() { return {}; }
-  void set_result_start(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ResultStart::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ResultGroup =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4MballocDiscardFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ResultGroup kResultGroup() { return {}; }
-  void set_result_group(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ResultGroup::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ResultLen =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4MballocDiscardFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4WritepageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ResultLen kResultLen() { return {}; }
-  void set_result_len(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ResultLen::kFieldId;
+  static constexpr FieldMetadata_Index kIndex{};
+  void set_index(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4MballocAllocFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/20, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4WriteEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  Ext4MballocAllocFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4MballocAllocFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4MballocAllocFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4WriteEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4WriteEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4WriteEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_orig_logical() const { return at<3>().valid(); }
-  uint32_t orig_logical() const { return at<3>().as_uint32(); }
-  bool has_orig_start() const { return at<4>().valid(); }
-  int32_t orig_start() const { return at<4>().as_int32(); }
-  bool has_orig_group() const { return at<5>().valid(); }
-  uint32_t orig_group() const { return at<5>().as_uint32(); }
-  bool has_orig_len() const { return at<6>().valid(); }
-  int32_t orig_len() const { return at<6>().as_int32(); }
-  bool has_goal_logical() const { return at<7>().valid(); }
-  uint32_t goal_logical() const { return at<7>().as_uint32(); }
-  bool has_goal_start() const { return at<8>().valid(); }
-  int32_t goal_start() const { return at<8>().as_int32(); }
-  bool has_goal_group() const { return at<9>().valid(); }
-  uint32_t goal_group() const { return at<9>().as_uint32(); }
-  bool has_goal_len() const { return at<10>().valid(); }
-  int32_t goal_len() const { return at<10>().as_int32(); }
-  bool has_result_logical() const { return at<11>().valid(); }
-  uint32_t result_logical() const { return at<11>().as_uint32(); }
-  bool has_result_start() const { return at<12>().valid(); }
-  int32_t result_start() const { return at<12>().as_int32(); }
-  bool has_result_group() const { return at<13>().valid(); }
-  uint32_t result_group() const { return at<13>().as_uint32(); }
-  bool has_result_len() const { return at<14>().valid(); }
-  int32_t result_len() const { return at<14>().as_int32(); }
-  bool has_found() const { return at<15>().valid(); }
-  uint32_t found() const { return at<15>().as_uint32(); }
-  bool has_groups() const { return at<16>().valid(); }
-  uint32_t groups() const { return at<16>().as_uint32(); }
-  bool has_buddy() const { return at<17>().valid(); }
-  uint32_t buddy() const { return at<17>().as_uint32(); }
-  bool has_flags() const { return at<18>().valid(); }
-  uint32_t flags() const { return at<18>().as_uint32(); }
-  bool has_tail() const { return at<19>().valid(); }
-  uint32_t tail() const { return at<19>().as_uint32(); }
-  bool has_cr() const { return at<20>().valid(); }
-  uint32_t cr() const { return at<20>().as_uint32(); }
+  bool has_pos() const { return at<3>().valid(); }
+  int64_t pos() const { return at<3>().as_int64(); }
+  bool has_len() const { return at<4>().valid(); }
+  uint32_t len() const { return at<4>().as_uint32(); }
+  bool has_copied() const { return at<5>().valid(); }
+  uint32_t copied() const { return at<5>().as_uint32(); }
 };
 
-class Ext4MballocAllocFtraceEvent : public ::protozero::Message {
+class Ext4WriteEndFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4MballocAllocFtraceEvent_Decoder;
+  using Decoder = Ext4WriteEndFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kOrigLogicalFieldNumber = 3,
-    kOrigStartFieldNumber = 4,
-    kOrigGroupFieldNumber = 5,
-    kOrigLenFieldNumber = 6,
-    kGoalLogicalFieldNumber = 7,
-    kGoalStartFieldNumber = 8,
-    kGoalGroupFieldNumber = 9,
-    kGoalLenFieldNumber = 10,
-    kResultLogicalFieldNumber = 11,
-    kResultStartFieldNumber = 12,
-    kResultGroupFieldNumber = 13,
-    kResultLenFieldNumber = 14,
-    kFoundFieldNumber = 15,
-    kGroupsFieldNumber = 16,
-    kBuddyFieldNumber = 17,
-    kFlagsFieldNumber = 18,
-    kTailFieldNumber = 19,
-    kCrFieldNumber = 20,
+    kPosFieldNumber = 3,
+    kLenFieldNumber = 4,
+    kCopiedFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MballocAllocFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4WriteEndFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -80739,16 +113317,9 @@ class Ext4MballocAllocFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4MballocAllocFtraceEvent>;
+      Ext4WriteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -80764,16 +113335,9 @@ class Ext4MballocAllocFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4MballocAllocFtraceEvent>;
+      Ext4WriteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -80783,224 +113347,35 @@ class Ext4MballocAllocFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_OrigLogical =
+  using FieldMetadata_Pos =
     ::protozero::proto_utils::FieldMetadata<
       3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4MballocAllocFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OrigLogical kOrigLogical() { return {}; }
-  void set_orig_logical(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OrigLogical::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_OrigStart =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4MballocAllocFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OrigStart kOrigStart() { return {}; }
-  void set_orig_start(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OrigStart::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_OrigGroup =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4MballocAllocFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OrigGroup kOrigGroup() { return {}; }
-  void set_orig_group(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OrigGroup::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_OrigLen =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4MballocAllocFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OrigLen kOrigLen() { return {}; }
-  void set_orig_len(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OrigLen::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_GoalLogical =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4MballocAllocFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GoalLogical kGoalLogical() { return {}; }
-  void set_goal_logical(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GoalLogical::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_GoalStart =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4MballocAllocFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GoalStart kGoalStart() { return {}; }
-  void set_goal_start(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GoalStart::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_GoalGroup =
-    ::protozero::proto_utils::FieldMetadata<
-      9,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4MballocAllocFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GoalGroup kGoalGroup() { return {}; }
-  void set_goal_group(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GoalGroup::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_GoalLen =
-    ::protozero::proto_utils::FieldMetadata<
-      10,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4MballocAllocFtraceEvent>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4WriteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GoalLen kGoalLen() { return {}; }
-  void set_goal_len(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GoalLen::kFieldId;
+  static constexpr FieldMetadata_Pos kPos{};
+  void set_pos(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ResultLogical =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4MballocAllocFtraceEvent>;
+      Ext4WriteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ResultLogical kResultLogical() { return {}; }
-  void set_result_logical(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ResultLogical::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -81008,124 +113383,120 @@ class Ext4MballocAllocFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ResultStart =
+  using FieldMetadata_Copied =
     ::protozero::proto_utils::FieldMetadata<
-      12,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4MballocAllocFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4WriteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ResultStart kResultStart() { return {}; }
-  void set_result_start(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ResultStart::kFieldId;
+  static constexpr FieldMetadata_Copied kCopied{};
+  void set_copied(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Copied::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_ResultGroup =
+class Ext4WriteBeginFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  Ext4WriteBeginFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4WriteBeginFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4WriteBeginFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_pos() const { return at<3>().valid(); }
+  int64_t pos() const { return at<3>().as_int64(); }
+  bool has_len() const { return at<4>().valid(); }
+  uint32_t len() const { return at<4>().as_uint32(); }
+  bool has_flags() const { return at<5>().valid(); }
+  uint32_t flags() const { return at<5>().as_uint32(); }
+};
+
+class Ext4WriteBeginFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4WriteBeginFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kPosFieldNumber = 3,
+    kLenFieldNumber = 4,
+    kFlagsFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4WriteBeginFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      13,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4MballocAllocFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4WriteBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ResultGroup kResultGroup() { return {}; }
-  void set_result_group(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ResultGroup::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ResultLen =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
-      14,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4MballocAllocFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4WriteBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ResultLen kResultLen() { return {}; }
-  void set_result_len(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ResultLen::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Found =
+  using FieldMetadata_Pos =
     ::protozero::proto_utils::FieldMetadata<
-      15,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4MballocAllocFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4WriteBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Found kFound() { return {}; }
-  void set_found(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Found::kFieldId;
+  static constexpr FieldMetadata_Pos kPos{};
+  void set_pos(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Groups =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
-      16,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4MballocAllocFtraceEvent>;
+      Ext4WriteBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Groups kGroups() { return {}; }
-  void set_groups(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Groups::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -81133,132 +113504,129 @@ class Ext4MballocAllocFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Buddy =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
-      17,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4MballocAllocFtraceEvent>;
+      Ext4WriteBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Buddy kBuddy() { return {}; }
-  void set_buddy(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Buddy::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Flags =
+class Ext4UnlinkExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  Ext4UnlinkExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4UnlinkExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4UnlinkExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_ret() const { return at<3>().valid(); }
+  int32_t ret() const { return at<3>().as_int32(); }
+};
+
+class Ext4UnlinkExitFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4UnlinkExitFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kRetFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4UnlinkExitFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      18,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4MballocAllocFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4UnlinkExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Tail =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
-      19,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4MballocAllocFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4UnlinkExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Tail kTail() { return {}; }
-  void set_tail(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Tail::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Cr =
+  using FieldMetadata_Ret =
     ::protozero::proto_utils::FieldMetadata<
-      20,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4MballocAllocFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4UnlinkExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cr kCr() { return {}; }
-  void set_cr(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Cr::kFieldId;
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4MbReleaseInodePaFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4UnlinkEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  Ext4MbReleaseInodePaFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4MbReleaseInodePaFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4MbReleaseInodePaFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4UnlinkEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4UnlinkEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4UnlinkEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_block() const { return at<3>().valid(); }
-  uint64_t block() const { return at<3>().as_uint64(); }
-  bool has_count() const { return at<4>().valid(); }
-  uint32_t count() const { return at<4>().as_uint32(); }
+  bool has_parent() const { return at<3>().valid(); }
+  uint64_t parent() const { return at<3>().as_uint64(); }
+  bool has_size() const { return at<4>().valid(); }
+  int64_t size() const { return at<4>().as_int64(); }
 };
 
-class Ext4MbReleaseInodePaFtraceEvent : public ::protozero::Message {
+class Ext4UnlinkEnterFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4MbReleaseInodePaFtraceEvent_Decoder;
+  using Decoder = Ext4UnlinkEnterFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kBlockFieldNumber = 3,
-    kCountFieldNumber = 4,
+    kParentFieldNumber = 3,
+    kSizeFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MbReleaseInodePaFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4UnlinkEnterFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -81267,16 +113635,9 @@ class Ext4MbReleaseInodePaFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4MbReleaseInodePaFtraceEvent>;
+      Ext4UnlinkEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -81292,16 +113653,9 @@ class Ext4MbReleaseInodePaFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4MbReleaseInodePaFtraceEvent>;
+      Ext4UnlinkEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -81311,24 +113665,17 @@ class Ext4MbReleaseInodePaFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Block =
+  using FieldMetadata_Parent =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4MbReleaseInodePaFtraceEvent>;
+      Ext4UnlinkEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Block kBlock() { return {}; }
-  void set_block(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Block::kFieldId;
+  static constexpr FieldMetadata_Parent kParent{};
+  void set_parent(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Parent::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -81336,54 +113683,47 @@ class Ext4MbReleaseInodePaFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Count =
+  using FieldMetadata_Size =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4MbReleaseInodePaFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4UnlinkEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Count kCount() { return {}; }
-  void set_count(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId;
+  static constexpr FieldMetadata_Size kSize{};
+  void set_size(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4MbReleaseGroupPaFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4TruncateExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  Ext4MbReleaseGroupPaFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4MbReleaseGroupPaFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4MbReleaseGroupPaFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4TruncateExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4TruncateExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4TruncateExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_pa_pstart() const { return at<2>().valid(); }
-  uint64_t pa_pstart() const { return at<2>().as_uint64(); }
-  bool has_pa_len() const { return at<3>().valid(); }
-  uint32_t pa_len() const { return at<3>().as_uint32(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_blocks() const { return at<3>().valid(); }
+  uint64_t blocks() const { return at<3>().as_uint64(); }
 };
 
-class Ext4MbReleaseGroupPaFtraceEvent : public ::protozero::Message {
+class Ext4TruncateExitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4MbReleaseGroupPaFtraceEvent_Decoder;
+  using Decoder = Ext4TruncateExitFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
-    kPaPstartFieldNumber = 2,
-    kPaLenFieldNumber = 3,
+    kInoFieldNumber = 2,
+    kBlocksFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MbReleaseGroupPaFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4TruncateExitFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -81392,16 +113732,9 @@ class Ext4MbReleaseGroupPaFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4MbReleaseGroupPaFtraceEvent>;
+      Ext4TruncateExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -81411,24 +113744,17 @@ class Ext4MbReleaseGroupPaFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PaPstart =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4MbReleaseGroupPaFtraceEvent>;
+      Ext4TruncateExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PaPstart kPaPstart() { return {}; }
-  void set_pa_pstart(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PaPstart::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -81436,60 +113762,47 @@ class Ext4MbReleaseGroupPaFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PaLen =
+  using FieldMetadata_Blocks =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4MbReleaseGroupPaFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4TruncateExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PaLen kPaLen() { return {}; }
-  void set_pa_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PaLen::kFieldId;
+  static constexpr FieldMetadata_Blocks kBlocks{};
+  void set_blocks(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4MbNewInodePaFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4TruncateEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  Ext4MbNewInodePaFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4MbNewInodePaFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4MbNewInodePaFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4TruncateEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4TruncateEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4TruncateEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_pa_pstart() const { return at<3>().valid(); }
-  uint64_t pa_pstart() const { return at<3>().as_uint64(); }
-  bool has_pa_lstart() const { return at<4>().valid(); }
-  uint64_t pa_lstart() const { return at<4>().as_uint64(); }
-  bool has_pa_len() const { return at<5>().valid(); }
-  uint32_t pa_len() const { return at<5>().as_uint32(); }
+  bool has_blocks() const { return at<3>().valid(); }
+  uint64_t blocks() const { return at<3>().as_uint64(); }
 };
 
-class Ext4MbNewInodePaFtraceEvent : public ::protozero::Message {
+class Ext4TruncateEnterFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4MbNewInodePaFtraceEvent_Decoder;
+  using Decoder = Ext4TruncateEnterFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kPaPstartFieldNumber = 3,
-    kPaLstartFieldNumber = 4,
-    kPaLenFieldNumber = 5,
+    kBlocksFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MbNewInodePaFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4TruncateEnterFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -81498,16 +113811,9 @@ class Ext4MbNewInodePaFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4MbNewInodePaFtraceEvent>;
+      Ext4TruncateEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -81523,16 +113829,9 @@ class Ext4MbNewInodePaFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4MbNewInodePaFtraceEvent>;
+      Ext4TruncateEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -81542,257 +113841,286 @@ class Ext4MbNewInodePaFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PaPstart =
+  using FieldMetadata_Blocks =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4MbNewInodePaFtraceEvent>;
+      Ext4TruncateEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PaPstart kPaPstart() { return {}; }
-  void set_pa_pstart(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PaPstart::kFieldId;
+  static constexpr FieldMetadata_Blocks kBlocks{};
+  void set_blocks(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_PaLstart =
+class Ext4TrimExtentFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  Ext4TrimExtentFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4TrimExtentFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4TrimExtentFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev_major() const { return at<1>().valid(); }
+  int32_t dev_major() const { return at<1>().as_int32(); }
+  bool has_dev_minor() const { return at<2>().valid(); }
+  int32_t dev_minor() const { return at<2>().as_int32(); }
+  bool has_group() const { return at<3>().valid(); }
+  uint32_t group() const { return at<3>().as_uint32(); }
+  bool has_start() const { return at<4>().valid(); }
+  int32_t start() const { return at<4>().as_int32(); }
+  bool has_len() const { return at<5>().valid(); }
+  int32_t len() const { return at<5>().as_int32(); }
+};
+
+class Ext4TrimExtentFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4TrimExtentFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevMajorFieldNumber = 1,
+    kDevMinorFieldNumber = 2,
+    kGroupFieldNumber = 3,
+    kStartFieldNumber = 4,
+    kLenFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4TrimExtentFtraceEvent"; }
+
+
+  using FieldMetadata_DevMajor =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4MbNewInodePaFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4TrimExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PaLstart kPaLstart() { return {}; }
-  void set_pa_lstart(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PaLstart::kFieldId;
+  static constexpr FieldMetadata_DevMajor kDevMajor{};
+  void set_dev_major(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DevMajor::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PaLen =
+  using FieldMetadata_DevMinor =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4TrimExtentFtraceEvent>;
+
+  static constexpr FieldMetadata_DevMinor kDevMinor{};
+  void set_dev_minor(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DevMinor::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Group =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4MbNewInodePaFtraceEvent>;
+      Ext4TrimExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PaLen kPaLen() { return {}; }
-  void set_pa_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PaLen::kFieldId;
+  static constexpr FieldMetadata_Group kGroup{};
+  void set_group(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Group::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_Start =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4TrimExtentFtraceEvent>;
+
+  static constexpr FieldMetadata_Start kStart{};
+  void set_start(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Len =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4TrimExtentFtraceEvent>;
+
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class Ext4MbNewGroupPaFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4TrimAllFreeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  Ext4MbNewGroupPaFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4MbNewGroupPaFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4MbNewGroupPaFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_pa_pstart() const { return at<3>().valid(); }
-  uint64_t pa_pstart() const { return at<3>().as_uint64(); }
-  bool has_pa_lstart() const { return at<4>().valid(); }
-  uint64_t pa_lstart() const { return at<4>().as_uint64(); }
-  bool has_pa_len() const { return at<5>().valid(); }
-  uint32_t pa_len() const { return at<5>().as_uint32(); }
+  Ext4TrimAllFreeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4TrimAllFreeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4TrimAllFreeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev_major() const { return at<1>().valid(); }
+  int32_t dev_major() const { return at<1>().as_int32(); }
+  bool has_dev_minor() const { return at<2>().valid(); }
+  int32_t dev_minor() const { return at<2>().as_int32(); }
+  bool has_group() const { return at<3>().valid(); }
+  uint32_t group() const { return at<3>().as_uint32(); }
+  bool has_start() const { return at<4>().valid(); }
+  int32_t start() const { return at<4>().as_int32(); }
+  bool has_len() const { return at<5>().valid(); }
+  int32_t len() const { return at<5>().as_int32(); }
 };
 
-class Ext4MbNewGroupPaFtraceEvent : public ::protozero::Message {
+class Ext4TrimAllFreeFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4MbNewGroupPaFtraceEvent_Decoder;
+  using Decoder = Ext4TrimAllFreeFtraceEvent_Decoder;
   enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kPaPstartFieldNumber = 3,
-    kPaLstartFieldNumber = 4,
-    kPaLenFieldNumber = 5,
+    kDevMajorFieldNumber = 1,
+    kDevMinorFieldNumber = 2,
+    kGroupFieldNumber = 3,
+    kStartFieldNumber = 4,
+    kLenFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MbNewGroupPaFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4TrimAllFreeFtraceEvent"; }
 
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_DevMajor =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4MbNewGroupPaFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4TrimAllFreeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_DevMajor kDevMajor{};
+  void set_dev_major(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DevMajor::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_DevMinor =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4MbNewGroupPaFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4TrimAllFreeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_DevMinor kDevMinor{};
+  void set_dev_minor(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DevMinor::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PaPstart =
+  using FieldMetadata_Group =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4MbNewGroupPaFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4TrimAllFreeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PaPstart kPaPstart() { return {}; }
-  void set_pa_pstart(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PaPstart::kFieldId;
+  static constexpr FieldMetadata_Group kGroup{};
+  void set_group(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Group::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PaLstart =
+  using FieldMetadata_Start =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4MbNewGroupPaFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4TrimAllFreeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PaLstart kPaLstart() { return {}; }
-  void set_pa_lstart(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PaLstart::kFieldId;
+  static constexpr FieldMetadata_Start kStart{};
+  void set_start(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PaLen =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4MbNewGroupPaFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4TrimAllFreeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PaLen kPaLen() { return {}; }
-  void set_pa_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PaLen::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4MbDiscardPreallocationsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4SyncFsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  Ext4MbDiscardPreallocationsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4MbDiscardPreallocationsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4MbDiscardPreallocationsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4SyncFsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4SyncFsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4SyncFsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_needed() const { return at<2>().valid(); }
-  int32_t needed() const { return at<2>().as_int32(); }
+  bool has_wait() const { return at<2>().valid(); }
+  int32_t wait() const { return at<2>().as_int32(); }
 };
 
-class Ext4MbDiscardPreallocationsFtraceEvent : public ::protozero::Message {
+class Ext4SyncFsFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4MbDiscardPreallocationsFtraceEvent_Decoder;
+  using Decoder = Ext4SyncFsFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
-    kNeededFieldNumber = 2,
+    kWaitFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MbDiscardPreallocationsFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4SyncFsFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -81801,16 +114129,9 @@ class Ext4MbDiscardPreallocationsFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4MbDiscardPreallocationsFtraceEvent>;
+      Ext4SyncFsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -81820,24 +114141,17 @@ class Ext4MbDiscardPreallocationsFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Needed =
+  using FieldMetadata_Wait =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4MbDiscardPreallocationsFtraceEvent>;
+      Ext4SyncFsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Needed kNeeded() { return {}; }
-  void set_needed(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Needed::kFieldId;
+  static constexpr FieldMetadata_Wait kWait{};
+  void set_wait(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Wait::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -81846,25 +114160,28 @@ class Ext4MbDiscardPreallocationsFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4MbBuddyBitmapLoadFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4RequestInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  Ext4MbBuddyBitmapLoadFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4MbBuddyBitmapLoadFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4MbBuddyBitmapLoadFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4RequestInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4RequestInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4RequestInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_group() const { return at<2>().valid(); }
-  uint32_t group() const { return at<2>().as_uint32(); }
+  bool has_dir() const { return at<2>().valid(); }
+  uint64_t dir() const { return at<2>().as_uint64(); }
+  bool has_mode() const { return at<3>().valid(); }
+  uint32_t mode() const { return at<3>().as_uint32(); }
 };
 
-class Ext4MbBuddyBitmapLoadFtraceEvent : public ::protozero::Message {
+class Ext4RequestInodeFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4MbBuddyBitmapLoadFtraceEvent_Decoder;
+  using Decoder = Ext4RequestInodeFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
-    kGroupFieldNumber = 2,
+    kDirFieldNumber = 2,
+    kModeFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MbBuddyBitmapLoadFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4RequestInodeFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -81873,16 +114190,9 @@ class Ext4MbBuddyBitmapLoadFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4MbBuddyBitmapLoadFtraceEvent>;
+      Ext4RequestInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -81892,24 +114202,35 @@ class Ext4MbBuddyBitmapLoadFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Group =
+  using FieldMetadata_Dir =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4RequestInodeFtraceEvent>;
+
+  static constexpr FieldMetadata_Dir kDir{};
+  void set_dir(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dir::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Mode =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4MbBuddyBitmapLoadFtraceEvent>;
+      Ext4RequestInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Group kGroup() { return {}; }
-  void set_group(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Group::kFieldId;
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -81918,25 +114239,49 @@ class Ext4MbBuddyBitmapLoadFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4MbBitmapLoadFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4RequestBlocksFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10> {
  public:
-  Ext4MbBitmapLoadFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4MbBitmapLoadFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4MbBitmapLoadFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4RequestBlocksFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4RequestBlocksFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4RequestBlocksFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_group() const { return at<2>().valid(); }
-  uint32_t group() const { return at<2>().as_uint32(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_len() const { return at<3>().valid(); }
+  uint32_t len() const { return at<3>().as_uint32(); }
+  bool has_logical() const { return at<4>().valid(); }
+  uint32_t logical() const { return at<4>().as_uint32(); }
+  bool has_lleft() const { return at<5>().valid(); }
+  uint32_t lleft() const { return at<5>().as_uint32(); }
+  bool has_lright() const { return at<6>().valid(); }
+  uint32_t lright() const { return at<6>().as_uint32(); }
+  bool has_goal() const { return at<7>().valid(); }
+  uint64_t goal() const { return at<7>().as_uint64(); }
+  bool has_pleft() const { return at<8>().valid(); }
+  uint64_t pleft() const { return at<8>().as_uint64(); }
+  bool has_pright() const { return at<9>().valid(); }
+  uint64_t pright() const { return at<9>().as_uint64(); }
+  bool has_flags() const { return at<10>().valid(); }
+  uint32_t flags() const { return at<10>().as_uint32(); }
 };
 
-class Ext4MbBitmapLoadFtraceEvent : public ::protozero::Message {
+class Ext4RequestBlocksFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4MbBitmapLoadFtraceEvent_Decoder;
+  using Decoder = Ext4RequestBlocksFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
-    kGroupFieldNumber = 2,
+    kInoFieldNumber = 2,
+    kLenFieldNumber = 3,
+    kLogicalFieldNumber = 4,
+    kLleftFieldNumber = 5,
+    kLrightFieldNumber = 6,
+    kGoalFieldNumber = 7,
+    kPleftFieldNumber = 8,
+    kPrightFieldNumber = 9,
+    kFlagsFieldNumber = 10,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MbBitmapLoadFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4RequestBlocksFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -81945,16 +114290,9 @@ class Ext4MbBitmapLoadFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4MbBitmapLoadFtraceEvent>;
+      Ext4RequestBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -81964,24 +114302,161 @@ class Ext4MbBitmapLoadFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Group =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4RequestBlocksFtraceEvent>;
+
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Len =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4MbBitmapLoadFtraceEvent>;
+      Ext4RequestBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Group kGroup() { return {}; }
-  void set_group(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Group::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Logical =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4RequestBlocksFtraceEvent>;
+
+  static constexpr FieldMetadata_Logical kLogical{};
+  void set_logical(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Logical::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Lleft =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4RequestBlocksFtraceEvent>;
+
+  static constexpr FieldMetadata_Lleft kLleft{};
+  void set_lleft(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lleft::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Lright =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4RequestBlocksFtraceEvent>;
+
+  static constexpr FieldMetadata_Lright kLright{};
+  void set_lright(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lright::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Goal =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4RequestBlocksFtraceEvent>;
+
+  static constexpr FieldMetadata_Goal kGoal{};
+  void set_goal(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Goal::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Pleft =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4RequestBlocksFtraceEvent>;
+
+  static constexpr FieldMetadata_Pleft kPleft{};
+  void set_pleft(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pleft::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Pright =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4RequestBlocksFtraceEvent>;
+
+  static constexpr FieldMetadata_Pright kPright{};
+  void set_pright(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pright::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Flags =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4RequestBlocksFtraceEvent>;
+
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -81990,28 +114465,52 @@ class Ext4MbBitmapLoadFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4MarkInodeDirtyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4RemoveBlocksFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11> {
  public:
-  Ext4MarkInodeDirtyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4MarkInodeDirtyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4MarkInodeDirtyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4RemoveBlocksFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4RemoveBlocksFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4RemoveBlocksFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_ip() const { return at<3>().valid(); }
-  uint64_t ip() const { return at<3>().as_uint64(); }
+  bool has_from() const { return at<3>().valid(); }
+  uint32_t from() const { return at<3>().as_uint32(); }
+  bool has_to() const { return at<4>().valid(); }
+  uint32_t to() const { return at<4>().as_uint32(); }
+  bool has_partial() const { return at<5>().valid(); }
+  int64_t partial() const { return at<5>().as_int64(); }
+  bool has_ee_pblk() const { return at<6>().valid(); }
+  uint64_t ee_pblk() const { return at<6>().as_uint64(); }
+  bool has_ee_lblk() const { return at<7>().valid(); }
+  uint32_t ee_lblk() const { return at<7>().as_uint32(); }
+  bool has_ee_len() const { return at<8>().valid(); }
+  uint32_t ee_len() const { return at<8>().as_uint32(); }
+  bool has_pc_lblk() const { return at<9>().valid(); }
+  uint32_t pc_lblk() const { return at<9>().as_uint32(); }
+  bool has_pc_pclu() const { return at<10>().valid(); }
+  uint64_t pc_pclu() const { return at<10>().as_uint64(); }
+  bool has_pc_state() const { return at<11>().valid(); }
+  int32_t pc_state() const { return at<11>().as_int32(); }
 };
 
-class Ext4MarkInodeDirtyFtraceEvent : public ::protozero::Message {
+class Ext4RemoveBlocksFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4MarkInodeDirtyFtraceEvent_Decoder;
+  using Decoder = Ext4RemoveBlocksFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kIpFieldNumber = 3,
+    kFromFieldNumber = 3,
+    kToFieldNumber = 4,
+    kPartialFieldNumber = 5,
+    kEePblkFieldNumber = 6,
+    kEeLblkFieldNumber = 7,
+    kEeLenFieldNumber = 8,
+    kPcLblkFieldNumber = 9,
+    kPcPcluFieldNumber = 10,
+    kPcStateFieldNumber = 11,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MarkInodeDirtyFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4RemoveBlocksFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -82020,16 +114519,9 @@ class Ext4MarkInodeDirtyFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4MarkInodeDirtyFtraceEvent>;
+      Ext4RemoveBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -82045,16 +114537,9 @@ class Ext4MarkInodeDirtyFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4MarkInodeDirtyFtraceEvent>;
+      Ext4RemoveBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -82064,71 +114549,71 @@ class Ext4MarkInodeDirtyFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ip =
+  using FieldMetadata_From =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4MarkInodeDirtyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4RemoveBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ip kIp() { return {}; }
-  void set_ip(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ip::kFieldId;
+  static constexpr FieldMetadata_From kFrom{};
+  void set_from(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_From::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
 
-class Ext4LoadInodeBitmapFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Ext4LoadInodeBitmapFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4LoadInodeBitmapFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4LoadInodeBitmapFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_group() const { return at<2>().valid(); }
-  uint32_t group() const { return at<2>().as_uint32(); }
-};
+  using FieldMetadata_To =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4RemoveBlocksFtraceEvent>;
 
-class Ext4LoadInodeBitmapFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = Ext4LoadInodeBitmapFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kGroupFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4LoadInodeBitmapFtraceEvent"; }
+  static constexpr FieldMetadata_To kTo{};
+  void set_to(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_To::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
+  using FieldMetadata_Partial =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4RemoveBlocksFtraceEvent>;
 
-  using FieldMetadata_Dev =
+  static constexpr FieldMetadata_Partial kPartial{};
+  void set_partial(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Partial::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_EePblk =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4LoadInodeBitmapFtraceEvent>;
+      Ext4RemoveBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_EePblk kEePblk{};
+  void set_ee_pblk(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EePblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -82136,71 +114621,71 @@ class Ext4LoadInodeBitmapFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Group =
+  using FieldMetadata_EeLblk =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4LoadInodeBitmapFtraceEvent>;
+      Ext4RemoveBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Group kGroup() { return {}; }
-  void set_group(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Group::kFieldId;
+  static constexpr FieldMetadata_EeLblk kEeLblk{};
+  void set_ee_lblk(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EeLblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
 
-class Ext4LoadInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Ext4LoadInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4LoadInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4LoadInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-};
+  using FieldMetadata_EeLen =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4RemoveBlocksFtraceEvent>;
 
-class Ext4LoadInodeFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = Ext4LoadInodeFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4LoadInodeFtraceEvent"; }
+  static constexpr FieldMetadata_EeLen kEeLen{};
+  void set_ee_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EeLen::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PcLblk =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4RemoveBlocksFtraceEvent>;
 
+  static constexpr FieldMetadata_PcLblk kPcLblk{};
+  void set_pc_lblk(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PcLblk::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_PcPclu =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4LoadInodeFtraceEvent>;
+      Ext4RemoveBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_PcPclu kPcPclu{};
+  void set_pc_pclu(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PcPclu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -82208,60 +114693,47 @@ class Ext4LoadInodeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_PcState =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4LoadInodeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4RemoveBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_PcState kPcState{};
+  void set_pc_state(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PcState::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4JournalledWriteEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4ReleasepageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  Ext4JournalledWriteEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4JournalledWriteEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4JournalledWriteEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4ReleasepageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4ReleasepageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4ReleasepageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_pos() const { return at<3>().valid(); }
-  int64_t pos() const { return at<3>().as_int64(); }
-  bool has_len() const { return at<4>().valid(); }
-  uint32_t len() const { return at<4>().as_uint32(); }
-  bool has_copied() const { return at<5>().valid(); }
-  uint32_t copied() const { return at<5>().as_uint32(); }
+  bool has_index() const { return at<3>().valid(); }
+  uint64_t index() const { return at<3>().as_uint64(); }
 };
 
-class Ext4JournalledWriteEndFtraceEvent : public ::protozero::Message {
+class Ext4ReleasepageFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4JournalledWriteEndFtraceEvent_Decoder;
+  using Decoder = Ext4ReleasepageFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kPosFieldNumber = 3,
-    kLenFieldNumber = 4,
-    kCopiedFieldNumber = 5,
+    kIndexFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4JournalledWriteEndFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ReleasepageFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -82270,16 +114742,9 @@ class Ext4JournalledWriteEndFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4JournalledWriteEndFtraceEvent>;
+      Ext4ReleasepageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -82295,16 +114760,9 @@ class Ext4JournalledWriteEndFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4JournalledWriteEndFtraceEvent>;
+      Ext4ReleasepageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -82314,110 +114772,47 @@ class Ext4JournalledWriteEndFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pos =
+  using FieldMetadata_Index =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4JournalledWriteEndFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pos kPos() { return {}; }
-  void set_pos(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Len =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4JournalledWriteEndFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Copied =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4JournalledWriteEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4ReleasepageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Copied kCopied() { return {}; }
-  void set_copied(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Copied::kFieldId;
+  static constexpr FieldMetadata_Index kIndex{};
+  void set_index(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4JournalledInvalidatepageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4ReadpageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  Ext4JournalledInvalidatepageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4JournalledInvalidatepageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4JournalledInvalidatepageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4ReadpageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4ReadpageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4ReadpageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
   bool has_index() const { return at<3>().valid(); }
   uint64_t index() const { return at<3>().as_uint64(); }
-  bool has_offset() const { return at<4>().valid(); }
-  uint64_t offset() const { return at<4>().as_uint64(); }
-  bool has_length() const { return at<5>().valid(); }
-  uint32_t length() const { return at<5>().as_uint32(); }
 };
 
-class Ext4JournalledInvalidatepageFtraceEvent : public ::protozero::Message {
+class Ext4ReadpageFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4JournalledInvalidatepageFtraceEvent_Decoder;
+  using Decoder = Ext4ReadpageFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
     kIndexFieldNumber = 3,
-    kOffsetFieldNumber = 4,
-    kLengthFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4JournalledInvalidatepageFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ReadpageFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -82426,16 +114821,9 @@ class Ext4JournalledInvalidatepageFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4JournalledInvalidatepageFtraceEvent>;
+      Ext4ReadpageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -82451,16 +114839,9 @@ class Ext4JournalledInvalidatepageFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4JournalledInvalidatepageFtraceEvent>;
+      Ext4ReadpageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -82476,16 +114857,9 @@ class Ext4JournalledInvalidatepageFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4JournalledInvalidatepageFtraceEvent>;
+      Ext4ReadpageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Index kIndex() { return {}; }
+  static constexpr FieldMetadata_Index kIndex{};
   void set_index(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -82494,80 +114868,30 @@ class Ext4JournalledInvalidatepageFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-
-  using FieldMetadata_Offset =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4JournalledInvalidatepageFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Offset kOffset() { return {}; }
-  void set_offset(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Length =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4JournalledInvalidatepageFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Length kLength() { return {}; }
-  void set_length(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Length::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
 };
 
-class Ext4JournalStartReservedFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4ReadBlockBitmapLoadFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  Ext4JournalStartReservedFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4JournalStartReservedFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4JournalStartReservedFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4ReadBlockBitmapLoadFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4ReadBlockBitmapLoadFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4ReadBlockBitmapLoadFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ip() const { return at<2>().valid(); }
-  uint64_t ip() const { return at<2>().as_uint64(); }
-  bool has_blocks() const { return at<3>().valid(); }
-  int32_t blocks() const { return at<3>().as_int32(); }
+  bool has_group() const { return at<2>().valid(); }
+  uint32_t group() const { return at<2>().as_uint32(); }
+  bool has_prefetch() const { return at<3>().valid(); }
+  uint32_t prefetch() const { return at<3>().as_uint32(); }
 };
 
-class Ext4JournalStartReservedFtraceEvent : public ::protozero::Message {
+class Ext4ReadBlockBitmapLoadFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4JournalStartReservedFtraceEvent_Decoder;
+  using Decoder = Ext4ReadBlockBitmapLoadFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
-    kIpFieldNumber = 2,
-    kBlocksFieldNumber = 3,
+    kGroupFieldNumber = 2,
+    kPrefetchFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4JournalStartReservedFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ReadBlockBitmapLoadFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -82576,16 +114900,9 @@ class Ext4JournalStartReservedFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4JournalStartReservedFtraceEvent>;
+      Ext4ReadBlockBitmapLoadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -82595,88 +114912,71 @@ class Ext4JournalStartReservedFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ip =
+  using FieldMetadata_Group =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4JournalStartReservedFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ReadBlockBitmapLoadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ip kIp() { return {}; }
-  void set_ip(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ip::kFieldId;
+  static constexpr FieldMetadata_Group kGroup{};
+  void set_group(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Group::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Blocks =
+  using FieldMetadata_Prefetch =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4JournalStartReservedFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ReadBlockBitmapLoadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Blocks kBlocks() { return {}; }
-  void set_blocks(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
+  static constexpr FieldMetadata_Prefetch kPrefetch{};
+  void set_prefetch(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prefetch::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4JournalStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4PunchHoleFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  Ext4JournalStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4JournalStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4JournalStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4PunchHoleFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4PunchHoleFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4PunchHoleFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ip() const { return at<2>().valid(); }
-  uint64_t ip() const { return at<2>().as_uint64(); }
-  bool has_blocks() const { return at<3>().valid(); }
-  int32_t blocks() const { return at<3>().as_int32(); }
-  bool has_rsv_blocks() const { return at<4>().valid(); }
-  int32_t rsv_blocks() const { return at<4>().as_int32(); }
-  bool has_nblocks() const { return at<5>().valid(); }
-  int32_t nblocks() const { return at<5>().as_int32(); }
-  bool has_revoke_creds() const { return at<6>().valid(); }
-  int32_t revoke_creds() const { return at<6>().as_int32(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_offset() const { return at<3>().valid(); }
+  int64_t offset() const { return at<3>().as_int64(); }
+  bool has_len() const { return at<4>().valid(); }
+  int64_t len() const { return at<4>().as_int64(); }
+  bool has_mode() const { return at<5>().valid(); }
+  int32_t mode() const { return at<5>().as_int32(); }
 };
 
-class Ext4JournalStartFtraceEvent : public ::protozero::Message {
+class Ext4PunchHoleFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4JournalStartFtraceEvent_Decoder;
+  using Decoder = Ext4PunchHoleFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
-    kIpFieldNumber = 2,
-    kBlocksFieldNumber = 3,
-    kRsvBlocksFieldNumber = 4,
-    kNblocksFieldNumber = 5,
-    kRevokeCredsFieldNumber = 6,
+    kInoFieldNumber = 2,
+    kOffsetFieldNumber = 3,
+    kLenFieldNumber = 4,
+    kModeFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4JournalStartFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4PunchHoleFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -82685,16 +114985,9 @@ class Ext4JournalStartFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4JournalStartFtraceEvent>;
+      Ext4PunchHoleFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -82704,24 +114997,17 @@ class Ext4JournalStartFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ip =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4JournalStartFtraceEvent>;
+      Ext4PunchHoleFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ip kIp() { return {}; }
-  void set_ip(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ip::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -82729,99 +115015,53 @@ class Ext4JournalStartFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Blocks =
+  using FieldMetadata_Offset =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4JournalStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4PunchHoleFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Blocks kBlocks() { return {}; }
-  void set_blocks(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
+  static constexpr FieldMetadata_Offset kOffset{};
+  void set_offset(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_RsvBlocks =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4JournalStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4PunchHoleFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RsvBlocks kRsvBlocks() { return {}; }
-  void set_rsv_blocks(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RsvBlocks::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Nblocks =
+  using FieldMetadata_Mode =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4JournalStartFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nblocks kNblocks() { return {}; }
-  void set_nblocks(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Nblocks::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_RevokeCreds =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4JournalStartFtraceEvent>;
+      Ext4PunchHoleFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RevokeCreds kRevokeCreds() { return {}; }
-  void set_revoke_creds(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RevokeCreds::kFieldId;
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -82830,34 +115070,37 @@ class Ext4JournalStartFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4InvalidatepageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4OtherInodeUpdateTimeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  Ext4InvalidatepageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4InvalidatepageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4InvalidatepageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4OtherInodeUpdateTimeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4OtherInodeUpdateTimeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4OtherInodeUpdateTimeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_index() const { return at<3>().valid(); }
-  uint64_t index() const { return at<3>().as_uint64(); }
-  bool has_offset() const { return at<4>().valid(); }
-  uint64_t offset() const { return at<4>().as_uint64(); }
-  bool has_length() const { return at<5>().valid(); }
-  uint32_t length() const { return at<5>().as_uint32(); }
+  bool has_orig_ino() const { return at<3>().valid(); }
+  uint64_t orig_ino() const { return at<3>().as_uint64(); }
+  bool has_uid() const { return at<4>().valid(); }
+  uint32_t uid() const { return at<4>().as_uint32(); }
+  bool has_gid() const { return at<5>().valid(); }
+  uint32_t gid() const { return at<5>().as_uint32(); }
+  bool has_mode() const { return at<6>().valid(); }
+  uint32_t mode() const { return at<6>().as_uint32(); }
 };
 
-class Ext4InvalidatepageFtraceEvent : public ::protozero::Message {
+class Ext4OtherInodeUpdateTimeFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4InvalidatepageFtraceEvent_Decoder;
+  using Decoder = Ext4OtherInodeUpdateTimeFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kIndexFieldNumber = 3,
-    kOffsetFieldNumber = 4,
-    kLengthFieldNumber = 5,
+    kOrigInoFieldNumber = 3,
+    kUidFieldNumber = 4,
+    kGidFieldNumber = 5,
+    kModeFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4InvalidatepageFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4OtherInodeUpdateTimeFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -82866,16 +115109,9 @@ class Ext4InvalidatepageFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4InvalidatepageFtraceEvent>;
+      Ext4OtherInodeUpdateTimeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -82891,16 +115127,9 @@ class Ext4InvalidatepageFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4InvalidatepageFtraceEvent>;
+      Ext4OtherInodeUpdateTimeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -82910,24 +115139,17 @@ class Ext4InvalidatepageFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Index =
+  using FieldMetadata_OrigIno =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4InvalidatepageFtraceEvent>;
+      Ext4OtherInodeUpdateTimeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Index kIndex() { return {}; }
-  void set_index(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
+  static constexpr FieldMetadata_OrigIno kOrigIno{};
+  void set_orig_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OrigIno::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -82935,49 +115157,53 @@ class Ext4InvalidatepageFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Offset =
+  using FieldMetadata_Uid =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4InvalidatepageFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4OtherInodeUpdateTimeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Offset kOffset() { return {}; }
-  void set_offset(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId;
+  static constexpr FieldMetadata_Uid kUid{};
+  void set_uid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Length =
+  using FieldMetadata_Gid =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4InvalidatepageFtraceEvent>;
+      Ext4OtherInodeUpdateTimeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Length kLength() { return {}; }
-  void set_length(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Length::kFieldId;
+  static constexpr FieldMetadata_Gid kGid{};
+  void set_gid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Gid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Mode =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4OtherInodeUpdateTimeFtraceEvent>;
+
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -82986,31 +115212,49 @@ class Ext4InvalidatepageFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4InsertRangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4MballocPreallocFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10> {
  public:
-  Ext4InsertRangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4InsertRangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4InsertRangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4MballocPreallocFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4MballocPreallocFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4MballocPreallocFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_offset() const { return at<3>().valid(); }
-  int64_t offset() const { return at<3>().as_int64(); }
-  bool has_len() const { return at<4>().valid(); }
-  int64_t len() const { return at<4>().as_int64(); }
+  bool has_orig_logical() const { return at<3>().valid(); }
+  uint32_t orig_logical() const { return at<3>().as_uint32(); }
+  bool has_orig_start() const { return at<4>().valid(); }
+  int32_t orig_start() const { return at<4>().as_int32(); }
+  bool has_orig_group() const { return at<5>().valid(); }
+  uint32_t orig_group() const { return at<5>().as_uint32(); }
+  bool has_orig_len() const { return at<6>().valid(); }
+  int32_t orig_len() const { return at<6>().as_int32(); }
+  bool has_result_logical() const { return at<7>().valid(); }
+  uint32_t result_logical() const { return at<7>().as_uint32(); }
+  bool has_result_start() const { return at<8>().valid(); }
+  int32_t result_start() const { return at<8>().as_int32(); }
+  bool has_result_group() const { return at<9>().valid(); }
+  uint32_t result_group() const { return at<9>().as_uint32(); }
+  bool has_result_len() const { return at<10>().valid(); }
+  int32_t result_len() const { return at<10>().as_int32(); }
 };
 
-class Ext4InsertRangeFtraceEvent : public ::protozero::Message {
+class Ext4MballocPreallocFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4InsertRangeFtraceEvent_Decoder;
+  using Decoder = Ext4MballocPreallocFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kOffsetFieldNumber = 3,
-    kLenFieldNumber = 4,
+    kOrigLogicalFieldNumber = 3,
+    kOrigStartFieldNumber = 4,
+    kOrigGroupFieldNumber = 5,
+    kOrigLenFieldNumber = 6,
+    kResultLogicalFieldNumber = 7,
+    kResultStartFieldNumber = 8,
+    kResultGroupFieldNumber = 9,
+    kResultLenFieldNumber = 10,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4InsertRangeFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MballocPreallocFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -83019,16 +115263,9 @@ class Ext4InsertRangeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4InsertRangeFtraceEvent>;
+      Ext4MballocPreallocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -83044,16 +115281,9 @@ class Ext4InsertRangeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4InsertRangeFtraceEvent>;
+      Ext4MballocPreallocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -83063,164 +115293,125 @@ class Ext4InsertRangeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Offset =
+  using FieldMetadata_OrigLogical =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4InsertRangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4MballocPreallocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Offset kOffset() { return {}; }
-  void set_offset(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId;
+  static constexpr FieldMetadata_OrigLogical kOrigLogical{};
+  void set_orig_logical(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OrigLogical::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_OrigStart =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4InsertRangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4MballocPreallocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_OrigStart kOrigStart{};
+  void set_orig_start(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OrigStart::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
 
-class Ext4IndMapBlocksExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Ext4IndMapBlocksExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4IndMapBlocksExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4IndMapBlocksExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_flags() const { return at<3>().valid(); }
-  uint32_t flags() const { return at<3>().as_uint32(); }
-  bool has_pblk() const { return at<4>().valid(); }
-  uint64_t pblk() const { return at<4>().as_uint64(); }
-  bool has_lblk() const { return at<5>().valid(); }
-  uint32_t lblk() const { return at<5>().as_uint32(); }
-  bool has_len() const { return at<6>().valid(); }
-  uint32_t len() const { return at<6>().as_uint32(); }
-  bool has_mflags() const { return at<7>().valid(); }
-  uint32_t mflags() const { return at<7>().as_uint32(); }
-  bool has_ret() const { return at<8>().valid(); }
-  int32_t ret() const { return at<8>().as_int32(); }
-};
+  using FieldMetadata_OrigGroup =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4MballocPreallocFtraceEvent>;
 
-class Ext4IndMapBlocksExitFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = Ext4IndMapBlocksExitFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kFlagsFieldNumber = 3,
-    kPblkFieldNumber = 4,
-    kLblkFieldNumber = 5,
-    kLenFieldNumber = 6,
-    kMflagsFieldNumber = 7,
-    kRetFieldNumber = 8,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4IndMapBlocksExitFtraceEvent"; }
+  static constexpr FieldMetadata_OrigGroup kOrigGroup{};
+  void set_orig_group(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OrigGroup::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
+  using FieldMetadata_OrigLen =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4MballocPreallocFtraceEvent>;
 
-  using FieldMetadata_Dev =
+  static constexpr FieldMetadata_OrigLen kOrigLen{};
+  void set_orig_len(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OrigLen::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ResultLogical =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4IndMapBlocksExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4MballocPreallocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_ResultLogical kResultLogical{};
+  void set_result_logical(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResultLogical::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_ResultStart =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4IndMapBlocksExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4MballocPreallocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_ResultStart kResultStart{};
+  void set_result_start(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResultStart::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_ResultGroup =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4IndMapBlocksExitFtraceEvent>;
+      Ext4MballocPreallocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_ResultGroup kResultGroup{};
+  void set_result_group(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResultGroup::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -83228,24 +115419,66 @@ class Ext4IndMapBlocksExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pblk =
+  using FieldMetadata_ResultLen =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4MballocPreallocFtraceEvent>;
+
+  static constexpr FieldMetadata_ResultLen kResultLen{};
+  void set_result_len(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResultLen::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class Ext4MballocFreeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  Ext4MballocFreeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4MballocFreeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4MballocFreeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_result_start() const { return at<3>().valid(); }
+  int32_t result_start() const { return at<3>().as_int32(); }
+  bool has_result_group() const { return at<4>().valid(); }
+  uint32_t result_group() const { return at<4>().as_uint32(); }
+  bool has_result_len() const { return at<5>().valid(); }
+  int32_t result_len() const { return at<5>().as_int32(); }
+};
+
+class Ext4MballocFreeFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4MballocFreeFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kResultStartFieldNumber = 3,
+    kResultGroupFieldNumber = 4,
+    kResultLenFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MballocFreeFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4IndMapBlocksExitFtraceEvent>;
+      Ext4MballocFreeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pblk kPblk() { return {}; }
-  void set_pblk(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -83253,74 +115486,53 @@ class Ext4IndMapBlocksExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Lblk =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4IndMapBlocksExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4MballocFreeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lblk kLblk() { return {}; }
-  void set_lblk(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_ResultStart =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4IndMapBlocksExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4MballocFreeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_ResultStart kResultStart{};
+  void set_result_start(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResultStart::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Mflags =
+  using FieldMetadata_ResultGroup =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4IndMapBlocksExitFtraceEvent>;
+      Ext4MballocFreeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mflags kMflags() { return {}; }
-  void set_mflags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mflags::kFieldId;
+  static constexpr FieldMetadata_ResultGroup kResultGroup{};
+  void set_result_group(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResultGroup::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -83328,24 +115540,17 @@ class Ext4IndMapBlocksExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ret =
+  using FieldMetadata_ResultLen =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4IndMapBlocksExitFtraceEvent>;
+      Ext4MballocFreeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+  static constexpr FieldMetadata_ResultLen kResultLen{};
+  void set_result_len(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResultLen::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -83354,34 +115559,34 @@ class Ext4IndMapBlocksExitFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4IndMapBlocksEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4MballocDiscardFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  Ext4IndMapBlocksEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4IndMapBlocksEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4IndMapBlocksEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4MballocDiscardFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4MballocDiscardFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4MballocDiscardFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_lblk() const { return at<3>().valid(); }
-  uint32_t lblk() const { return at<3>().as_uint32(); }
-  bool has_len() const { return at<4>().valid(); }
-  uint32_t len() const { return at<4>().as_uint32(); }
-  bool has_flags() const { return at<5>().valid(); }
-  uint32_t flags() const { return at<5>().as_uint32(); }
+  bool has_result_start() const { return at<3>().valid(); }
+  int32_t result_start() const { return at<3>().as_int32(); }
+  bool has_result_group() const { return at<4>().valid(); }
+  uint32_t result_group() const { return at<4>().as_uint32(); }
+  bool has_result_len() const { return at<5>().valid(); }
+  int32_t result_len() const { return at<5>().as_int32(); }
 };
 
-class Ext4IndMapBlocksEnterFtraceEvent : public ::protozero::Message {
+class Ext4MballocDiscardFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4IndMapBlocksEnterFtraceEvent_Decoder;
+  using Decoder = Ext4MballocDiscardFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kLblkFieldNumber = 3,
-    kLenFieldNumber = 4,
-    kFlagsFieldNumber = 5,
+    kResultStartFieldNumber = 3,
+    kResultGroupFieldNumber = 4,
+    kResultLenFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4IndMapBlocksEnterFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MballocDiscardFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -83390,16 +115595,9 @@ class Ext4IndMapBlocksEnterFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4IndMapBlocksEnterFtraceEvent>;
+      Ext4MballocDiscardFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -83415,16 +115613,9 @@ class Ext4IndMapBlocksEnterFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4IndMapBlocksEnterFtraceEvent>;
+      Ext4MballocDiscardFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -83434,49 +115625,35 @@ class Ext4IndMapBlocksEnterFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Lblk =
+  using FieldMetadata_ResultStart =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4IndMapBlocksEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4MballocDiscardFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lblk kLblk() { return {}; }
-  void set_lblk(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
+  static constexpr FieldMetadata_ResultStart kResultStart{};
+  void set_result_start(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResultStart::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_ResultGroup =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4IndMapBlocksEnterFtraceEvent>;
+      Ext4MballocDiscardFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_ResultGroup kResultGroup{};
+  void set_result_group(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResultGroup::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -83484,57 +115661,98 @@ class Ext4IndMapBlocksEnterFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_ResultLen =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4IndMapBlocksEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4MballocDiscardFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_ResultLen kResultLen{};
+  void set_result_len(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResultLen::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4GetReservedClusterAllocFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4MballocAllocFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/20> {
  public:
-  Ext4GetReservedClusterAllocFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4GetReservedClusterAllocFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4GetReservedClusterAllocFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4MballocAllocFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4MballocAllocFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4MballocAllocFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_lblk() const { return at<3>().valid(); }
-  uint32_t lblk() const { return at<3>().as_uint32(); }
-  bool has_len() const { return at<4>().valid(); }
-  uint32_t len() const { return at<4>().as_uint32(); }
+  bool has_orig_logical() const { return at<3>().valid(); }
+  uint32_t orig_logical() const { return at<3>().as_uint32(); }
+  bool has_orig_start() const { return at<4>().valid(); }
+  int32_t orig_start() const { return at<4>().as_int32(); }
+  bool has_orig_group() const { return at<5>().valid(); }
+  uint32_t orig_group() const { return at<5>().as_uint32(); }
+  bool has_orig_len() const { return at<6>().valid(); }
+  int32_t orig_len() const { return at<6>().as_int32(); }
+  bool has_goal_logical() const { return at<7>().valid(); }
+  uint32_t goal_logical() const { return at<7>().as_uint32(); }
+  bool has_goal_start() const { return at<8>().valid(); }
+  int32_t goal_start() const { return at<8>().as_int32(); }
+  bool has_goal_group() const { return at<9>().valid(); }
+  uint32_t goal_group() const { return at<9>().as_uint32(); }
+  bool has_goal_len() const { return at<10>().valid(); }
+  int32_t goal_len() const { return at<10>().as_int32(); }
+  bool has_result_logical() const { return at<11>().valid(); }
+  uint32_t result_logical() const { return at<11>().as_uint32(); }
+  bool has_result_start() const { return at<12>().valid(); }
+  int32_t result_start() const { return at<12>().as_int32(); }
+  bool has_result_group() const { return at<13>().valid(); }
+  uint32_t result_group() const { return at<13>().as_uint32(); }
+  bool has_result_len() const { return at<14>().valid(); }
+  int32_t result_len() const { return at<14>().as_int32(); }
+  bool has_found() const { return at<15>().valid(); }
+  uint32_t found() const { return at<15>().as_uint32(); }
+  bool has_groups() const { return at<16>().valid(); }
+  uint32_t groups() const { return at<16>().as_uint32(); }
+  bool has_buddy() const { return at<17>().valid(); }
+  uint32_t buddy() const { return at<17>().as_uint32(); }
+  bool has_flags() const { return at<18>().valid(); }
+  uint32_t flags() const { return at<18>().as_uint32(); }
+  bool has_tail() const { return at<19>().valid(); }
+  uint32_t tail() const { return at<19>().as_uint32(); }
+  bool has_cr() const { return at<20>().valid(); }
+  uint32_t cr() const { return at<20>().as_uint32(); }
 };
 
-class Ext4GetReservedClusterAllocFtraceEvent : public ::protozero::Message {
+class Ext4MballocAllocFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4GetReservedClusterAllocFtraceEvent_Decoder;
+  using Decoder = Ext4MballocAllocFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kLblkFieldNumber = 3,
-    kLenFieldNumber = 4,
+    kOrigLogicalFieldNumber = 3,
+    kOrigStartFieldNumber = 4,
+    kOrigGroupFieldNumber = 5,
+    kOrigLenFieldNumber = 6,
+    kGoalLogicalFieldNumber = 7,
+    kGoalStartFieldNumber = 8,
+    kGoalGroupFieldNumber = 9,
+    kGoalLenFieldNumber = 10,
+    kResultLogicalFieldNumber = 11,
+    kResultStartFieldNumber = 12,
+    kResultGroupFieldNumber = 13,
+    kResultLenFieldNumber = 14,
+    kFoundFieldNumber = 15,
+    kGroupsFieldNumber = 16,
+    kBuddyFieldNumber = 17,
+    kFlagsFieldNumber = 18,
+    kTailFieldNumber = 19,
+    kCrFieldNumber = 20,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4GetReservedClusterAllocFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MballocAllocFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -83543,16 +115761,9 @@ class Ext4GetReservedClusterAllocFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4GetReservedClusterAllocFtraceEvent>;
+      Ext4MballocAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -83568,16 +115779,9 @@ class Ext4GetReservedClusterAllocFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4GetReservedClusterAllocFtraceEvent>;
+      Ext4MballocAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -83587,24 +115791,17 @@ class Ext4GetReservedClusterAllocFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Lblk =
+  using FieldMetadata_OrigLogical =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4GetReservedClusterAllocFtraceEvent>;
+      Ext4MballocAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lblk kLblk() { return {}; }
-  void set_lblk(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
+  static constexpr FieldMetadata_OrigLogical kOrigLogical{};
+  void set_orig_logical(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OrigLogical::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -83612,108 +115809,71 @@ class Ext4GetReservedClusterAllocFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_OrigStart =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4MballocAllocFtraceEvent>;
+
+  static constexpr FieldMetadata_OrigStart kOrigStart{};
+  void set_orig_start(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OrigStart::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OrigGroup =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4GetReservedClusterAllocFtraceEvent>;
+      Ext4MballocAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_OrigGroup kOrigGroup{};
+  void set_orig_group(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OrigGroup::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class Ext4GetImpliedClusterAllocExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Ext4GetImpliedClusterAllocExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4GetImpliedClusterAllocExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4GetImpliedClusterAllocExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_flags() const { return at<2>().valid(); }
-  uint32_t flags() const { return at<2>().as_uint32(); }
-  bool has_lblk() const { return at<3>().valid(); }
-  uint32_t lblk() const { return at<3>().as_uint32(); }
-  bool has_pblk() const { return at<4>().valid(); }
-  uint64_t pblk() const { return at<4>().as_uint64(); }
-  bool has_len() const { return at<5>().valid(); }
-  uint32_t len() const { return at<5>().as_uint32(); }
-  bool has_ret() const { return at<6>().valid(); }
-  int32_t ret() const { return at<6>().as_int32(); }
-};
-
-class Ext4GetImpliedClusterAllocExitFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = Ext4GetImpliedClusterAllocExitFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kFlagsFieldNumber = 2,
-    kLblkFieldNumber = 3,
-    kPblkFieldNumber = 4,
-    kLenFieldNumber = 5,
-    kRetFieldNumber = 6,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4GetImpliedClusterAllocExitFtraceEvent"; }
 
-
-  using FieldMetadata_Dev =
+  using FieldMetadata_OrigLen =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4GetImpliedClusterAllocExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4MballocAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_OrigLen kOrigLen{};
+  void set_orig_len(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OrigLen::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_GoalLogical =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4GetImpliedClusterAllocExitFtraceEvent>;
+      Ext4MballocAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_GoalLogical kGoalLogical{};
+  void set_goal_logical(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GoalLogical::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -83721,24 +115881,35 @@ class Ext4GetImpliedClusterAllocExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Lblk =
+  using FieldMetadata_GoalStart =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4MballocAllocFtraceEvent>;
+
+  static constexpr FieldMetadata_GoalStart kGoalStart{};
+  void set_goal_start(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GoalStart::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_GoalGroup =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4GetImpliedClusterAllocExitFtraceEvent>;
+      Ext4MballocAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lblk kLblk() { return {}; }
-  void set_lblk(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
+  static constexpr FieldMetadata_GoalGroup kGoalGroup{};
+  void set_goal_group(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GoalGroup::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -83746,49 +115917,35 @@ class Ext4GetImpliedClusterAllocExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pblk =
+  using FieldMetadata_GoalLen =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4GetImpliedClusterAllocExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4MballocAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pblk kPblk() { return {}; }
-  void set_pblk(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId;
+  static constexpr FieldMetadata_GoalLen kGoalLen{};
+  void set_goal_len(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GoalLen::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_ResultLogical =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4GetImpliedClusterAllocExitFtraceEvent>;
+      Ext4MballocAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_ResultLogical kResultLogical{};
+  void set_result_logical(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResultLogical::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -83796,133 +115953,107 @@ class Ext4GetImpliedClusterAllocExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ret =
+  using FieldMetadata_ResultStart =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      12,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4GetImpliedClusterAllocExitFtraceEvent>;
+      Ext4MballocAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+  static constexpr FieldMetadata_ResultStart kResultStart{};
+  void set_result_start(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResultStart::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
 
-class Ext4FreeInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Ext4FreeInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4FreeInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4FreeInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_uid() const { return at<3>().valid(); }
-  uint32_t uid() const { return at<3>().as_uint32(); }
-  bool has_gid() const { return at<4>().valid(); }
-  uint32_t gid() const { return at<4>().as_uint32(); }
-  bool has_blocks() const { return at<5>().valid(); }
-  uint64_t blocks() const { return at<5>().as_uint64(); }
-  bool has_mode() const { return at<6>().valid(); }
-  uint32_t mode() const { return at<6>().as_uint32(); }
-};
+  using FieldMetadata_ResultGroup =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4MballocAllocFtraceEvent>;
 
-class Ext4FreeInodeFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = Ext4FreeInodeFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kUidFieldNumber = 3,
-    kGidFieldNumber = 4,
-    kBlocksFieldNumber = 5,
-    kModeFieldNumber = 6,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4FreeInodeFtraceEvent"; }
+  static constexpr FieldMetadata_ResultGroup kResultGroup{};
+  void set_result_group(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResultGroup::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ResultLen =
+    ::protozero::proto_utils::FieldMetadata<
+      14,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4MballocAllocFtraceEvent>;
 
+  static constexpr FieldMetadata_ResultLen kResultLen{};
+  void set_result_len(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResultLen::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_Found =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      15,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4FreeInodeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4MballocAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_Found kFound{};
+  void set_found(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Found::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_Groups =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      16,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4FreeInodeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4MballocAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_Groups kGroups{};
+  void set_groups(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Groups::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Uid =
+  using FieldMetadata_Buddy =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      17,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4FreeInodeFtraceEvent>;
+      Ext4MballocAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Uid kUid() { return {}; }
-  void set_uid(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId;
+  static constexpr FieldMetadata_Buddy kBuddy{};
+  void set_buddy(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Buddy::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -83930,24 +116061,17 @@ class Ext4FreeInodeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Gid =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      18,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4FreeInodeFtraceEvent>;
+      Ext4MballocAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Gid kGid() { return {}; }
-  void set_gid(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Gid::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -83955,49 +116079,35 @@ class Ext4FreeInodeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Blocks =
+  using FieldMetadata_Tail =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      19,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4FreeInodeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4MballocAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Blocks kBlocks() { return {}; }
-  void set_blocks(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
+  static constexpr FieldMetadata_Tail kTail{};
+  void set_tail(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tail::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Mode =
+  using FieldMetadata_Cr =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      20,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4FreeInodeFtraceEvent>;
+      Ext4MballocAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mode kMode() { return {}; }
-  void set_mode(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+  static constexpr FieldMetadata_Cr kCr{};
+  void set_cr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -84006,11 +116116,11 @@ class Ext4FreeInodeFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4FreeBlocksFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4MbReleaseInodePaFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  Ext4FreeBlocksFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4FreeBlocksFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4FreeBlocksFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4MbReleaseInodePaFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4MbReleaseInodePaFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4MbReleaseInodePaFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
@@ -84018,25 +116128,19 @@ class Ext4FreeBlocksFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder<
   bool has_block() const { return at<3>().valid(); }
   uint64_t block() const { return at<3>().as_uint64(); }
   bool has_count() const { return at<4>().valid(); }
-  uint64_t count() const { return at<4>().as_uint64(); }
-  bool has_flags() const { return at<5>().valid(); }
-  int32_t flags() const { return at<5>().as_int32(); }
-  bool has_mode() const { return at<6>().valid(); }
-  uint32_t mode() const { return at<6>().as_uint32(); }
+  uint32_t count() const { return at<4>().as_uint32(); }
 };
 
-class Ext4FreeBlocksFtraceEvent : public ::protozero::Message {
+class Ext4MbReleaseInodePaFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4FreeBlocksFtraceEvent_Decoder;
+  using Decoder = Ext4MbReleaseInodePaFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
     kBlockFieldNumber = 3,
     kCountFieldNumber = 4,
-    kFlagsFieldNumber = 5,
-    kModeFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4FreeBlocksFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MbReleaseInodePaFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -84045,16 +116149,9 @@ class Ext4FreeBlocksFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4FreeBlocksFtraceEvent>;
+      Ext4MbReleaseInodePaFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -84070,16 +116167,9 @@ class Ext4FreeBlocksFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4FreeBlocksFtraceEvent>;
+      Ext4MbReleaseInodePaFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -84095,16 +116185,9 @@ class Ext4FreeBlocksFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4FreeBlocksFtraceEvent>;
+      Ext4MbReleaseInodePaFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Block kBlock() { return {}; }
+  static constexpr FieldMetadata_Block kBlock{};
   void set_block(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Block::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -84118,20 +116201,56 @@ class Ext4FreeBlocksFtraceEvent : public ::protozero::Message {
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4MbReleaseInodePaFtraceEvent>;
+
+  static constexpr FieldMetadata_Count kCount{};
+  void set_count(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class Ext4MbReleaseGroupPaFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  Ext4MbReleaseGroupPaFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4MbReleaseGroupPaFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4MbReleaseGroupPaFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_pa_pstart() const { return at<2>().valid(); }
+  uint64_t pa_pstart() const { return at<2>().as_uint64(); }
+  bool has_pa_len() const { return at<3>().valid(); }
+  uint32_t pa_len() const { return at<3>().as_uint32(); }
+};
+
+class Ext4MbReleaseGroupPaFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4MbReleaseGroupPaFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kPaPstartFieldNumber = 2,
+    kPaLenFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MbReleaseGroupPaFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4FreeBlocksFtraceEvent>;
+      Ext4MbReleaseGroupPaFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Count kCount() { return {}; }
-  void set_count(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -84139,49 +116258,35 @@ class Ext4FreeBlocksFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_PaPstart =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4FreeBlocksFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4MbReleaseGroupPaFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_PaPstart kPaPstart{};
+  void set_pa_pstart(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PaPstart::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Mode =
+  using FieldMetadata_PaLen =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4FreeBlocksFtraceEvent>;
+      Ext4MbReleaseGroupPaFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mode kMode() { return {}; }
-  void set_mode(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+  static constexpr FieldMetadata_PaLen kPaLen{};
+  void set_pa_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PaLen::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -84190,34 +116295,34 @@ class Ext4FreeBlocksFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4ForgetFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4MbNewInodePaFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  Ext4ForgetFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4ForgetFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4ForgetFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4MbNewInodePaFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4MbNewInodePaFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4MbNewInodePaFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_block() const { return at<3>().valid(); }
-  uint64_t block() const { return at<3>().as_uint64(); }
-  bool has_is_metadata() const { return at<4>().valid(); }
-  int32_t is_metadata() const { return at<4>().as_int32(); }
-  bool has_mode() const { return at<5>().valid(); }
-  uint32_t mode() const { return at<5>().as_uint32(); }
+  bool has_pa_pstart() const { return at<3>().valid(); }
+  uint64_t pa_pstart() const { return at<3>().as_uint64(); }
+  bool has_pa_lstart() const { return at<4>().valid(); }
+  uint64_t pa_lstart() const { return at<4>().as_uint64(); }
+  bool has_pa_len() const { return at<5>().valid(); }
+  uint32_t pa_len() const { return at<5>().as_uint32(); }
 };
 
-class Ext4ForgetFtraceEvent : public ::protozero::Message {
+class Ext4MbNewInodePaFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4ForgetFtraceEvent_Decoder;
+  using Decoder = Ext4MbNewInodePaFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kBlockFieldNumber = 3,
-    kIsMetadataFieldNumber = 4,
-    kModeFieldNumber = 5,
+    kPaPstartFieldNumber = 3,
+    kPaLstartFieldNumber = 4,
+    kPaLenFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ForgetFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MbNewInodePaFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -84226,16 +116331,9 @@ class Ext4ForgetFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ForgetFtraceEvent>;
+      Ext4MbNewInodePaFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -84251,16 +116349,9 @@ class Ext4ForgetFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ForgetFtraceEvent>;
+      Ext4MbNewInodePaFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -84270,24 +116361,17 @@ class Ext4ForgetFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Block =
+  using FieldMetadata_PaPstart =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ForgetFtraceEvent>;
+      Ext4MbNewInodePaFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Block kBlock() { return {}; }
-  void set_block(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Block::kFieldId;
+  static constexpr FieldMetadata_PaPstart kPaPstart{};
+  void set_pa_pstart(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PaPstart::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -84295,49 +116379,35 @@ class Ext4ForgetFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IsMetadata =
+  using FieldMetadata_PaLstart =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4ForgetFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4MbNewInodePaFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IsMetadata kIsMetadata() { return {}; }
-  void set_is_metadata(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IsMetadata::kFieldId;
+  static constexpr FieldMetadata_PaLstart kPaLstart{};
+  void set_pa_lstart(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PaLstart::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Mode =
+  using FieldMetadata_PaLen =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4ForgetFtraceEvent>;
+      Ext4MbNewInodePaFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mode kMode() { return {}; }
-  void set_mode(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+  static constexpr FieldMetadata_PaLen kPaLen{};
+  void set_pa_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PaLen::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -84346,40 +116416,34 @@ class Ext4ForgetFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4FindDelallocRangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4MbNewGroupPaFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  Ext4FindDelallocRangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4FindDelallocRangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4FindDelallocRangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4MbNewGroupPaFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4MbNewGroupPaFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4MbNewGroupPaFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_from() const { return at<3>().valid(); }
-  uint32_t from() const { return at<3>().as_uint32(); }
-  bool has_to() const { return at<4>().valid(); }
-  uint32_t to() const { return at<4>().as_uint32(); }
-  bool has_reverse() const { return at<5>().valid(); }
-  int32_t reverse() const { return at<5>().as_int32(); }
-  bool has_found() const { return at<6>().valid(); }
-  int32_t found() const { return at<6>().as_int32(); }
-  bool has_found_blk() const { return at<7>().valid(); }
-  uint32_t found_blk() const { return at<7>().as_uint32(); }
+  bool has_pa_pstart() const { return at<3>().valid(); }
+  uint64_t pa_pstart() const { return at<3>().as_uint64(); }
+  bool has_pa_lstart() const { return at<4>().valid(); }
+  uint64_t pa_lstart() const { return at<4>().as_uint64(); }
+  bool has_pa_len() const { return at<5>().valid(); }
+  uint32_t pa_len() const { return at<5>().as_uint32(); }
 };
 
-class Ext4FindDelallocRangeFtraceEvent : public ::protozero::Message {
+class Ext4MbNewGroupPaFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4FindDelallocRangeFtraceEvent_Decoder;
+  using Decoder = Ext4MbNewGroupPaFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kFromFieldNumber = 3,
-    kToFieldNumber = 4,
-    kReverseFieldNumber = 5,
-    kFoundFieldNumber = 6,
-    kFoundBlkFieldNumber = 7,
+    kPaPstartFieldNumber = 3,
+    kPaLstartFieldNumber = 4,
+    kPaLenFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4FindDelallocRangeFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MbNewGroupPaFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -84388,16 +116452,9 @@ class Ext4FindDelallocRangeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4FindDelallocRangeFtraceEvent>;
+      Ext4MbNewGroupPaFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -84413,16 +116470,9 @@ class Ext4FindDelallocRangeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4FindDelallocRangeFtraceEvent>;
+      Ext4MbNewGroupPaFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -84432,160 +116482,138 @@ class Ext4FindDelallocRangeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_From =
+  using FieldMetadata_PaPstart =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4FindDelallocRangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4MbNewGroupPaFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_From kFrom() { return {}; }
-  void set_from(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_From::kFieldId;
+  static constexpr FieldMetadata_PaPstart kPaPstart{};
+  void set_pa_pstart(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PaPstart::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_To =
+  using FieldMetadata_PaLstart =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4FindDelallocRangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4MbNewGroupPaFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_To kTo() { return {}; }
-  void set_to(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_To::kFieldId;
+  static constexpr FieldMetadata_PaLstart kPaLstart{};
+  void set_pa_lstart(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PaLstart::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Reverse =
+  using FieldMetadata_PaLen =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4FindDelallocRangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4MbNewGroupPaFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Reverse kReverse() { return {}; }
-  void set_reverse(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Reverse::kFieldId;
+  static constexpr FieldMetadata_PaLen kPaLen{};
+  void set_pa_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PaLen::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Found =
+class Ext4MbDiscardPreallocationsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  Ext4MbDiscardPreallocationsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4MbDiscardPreallocationsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4MbDiscardPreallocationsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_needed() const { return at<2>().valid(); }
+  int32_t needed() const { return at<2>().as_int32(); }
+};
+
+class Ext4MbDiscardPreallocationsFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4MbDiscardPreallocationsFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kNeededFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MbDiscardPreallocationsFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4FindDelallocRangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4MbDiscardPreallocationsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Found kFound() { return {}; }
-  void set_found(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Found::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FoundBlk =
+  using FieldMetadata_Needed =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4FindDelallocRangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4MbDiscardPreallocationsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FoundBlk kFoundBlk() { return {}; }
-  void set_found_blk(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FoundBlk::kFieldId;
+  static constexpr FieldMetadata_Needed kNeeded{};
+  void set_needed(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Needed::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4FallocateExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4MbBuddyBitmapLoadFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  Ext4FallocateExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4FallocateExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4FallocateExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4MbBuddyBitmapLoadFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4MbBuddyBitmapLoadFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4MbBuddyBitmapLoadFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_pos() const { return at<3>().valid(); }
-  int64_t pos() const { return at<3>().as_int64(); }
-  bool has_blocks() const { return at<4>().valid(); }
-  uint32_t blocks() const { return at<4>().as_uint32(); }
-  bool has_ret() const { return at<5>().valid(); }
-  int32_t ret() const { return at<5>().as_int32(); }
+  bool has_group() const { return at<2>().valid(); }
+  uint32_t group() const { return at<2>().as_uint32(); }
 };
 
-class Ext4FallocateExitFtraceEvent : public ::protozero::Message {
+class Ext4MbBuddyBitmapLoadFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4FallocateExitFtraceEvent_Decoder;
+  using Decoder = Ext4MbBuddyBitmapLoadFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kPosFieldNumber = 3,
-    kBlocksFieldNumber = 4,
-    kRetFieldNumber = 5,
+    kGroupFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4FallocateExitFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MbBuddyBitmapLoadFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -84594,16 +116622,9 @@ class Ext4FallocateExitFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4FallocateExitFtraceEvent>;
+      Ext4MbBuddyBitmapLoadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -84613,138 +116634,105 @@ class Ext4FallocateExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_Group =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4FallocateExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4MbBuddyBitmapLoadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_Group kGroup{};
+  void set_group(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Group::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Pos =
+class Ext4MbBitmapLoadFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  Ext4MbBitmapLoadFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4MbBitmapLoadFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4MbBitmapLoadFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_group() const { return at<2>().valid(); }
+  uint32_t group() const { return at<2>().as_uint32(); }
+};
+
+class Ext4MbBitmapLoadFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4MbBitmapLoadFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kGroupFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MbBitmapLoadFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4FallocateExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4MbBitmapLoadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pos kPos() { return {}; }
-  void set_pos(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Blocks =
+  using FieldMetadata_Group =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4FallocateExitFtraceEvent>;
+      Ext4MbBitmapLoadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Blocks kBlocks() { return {}; }
-  void set_blocks(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
+  static constexpr FieldMetadata_Group kGroup{};
+  void set_group(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Group::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-
-  using FieldMetadata_Ret =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4FallocateExitFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
 };
 
-class Ext4FallocateEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4MarkInodeDirtyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  Ext4FallocateEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4FallocateEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4FallocateEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4MarkInodeDirtyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4MarkInodeDirtyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4MarkInodeDirtyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_offset() const { return at<3>().valid(); }
-  int64_t offset() const { return at<3>().as_int64(); }
-  bool has_len() const { return at<4>().valid(); }
-  int64_t len() const { return at<4>().as_int64(); }
-  bool has_mode() const { return at<5>().valid(); }
-  int32_t mode() const { return at<5>().as_int32(); }
-  bool has_pos() const { return at<6>().valid(); }
-  int64_t pos() const { return at<6>().as_int64(); }
+  bool has_ip() const { return at<3>().valid(); }
+  uint64_t ip() const { return at<3>().as_uint64(); }
 };
 
-class Ext4FallocateEnterFtraceEvent : public ::protozero::Message {
+class Ext4MarkInodeDirtyFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4FallocateEnterFtraceEvent_Decoder;
+  using Decoder = Ext4MarkInodeDirtyFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kOffsetFieldNumber = 3,
-    kLenFieldNumber = 4,
-    kModeFieldNumber = 5,
-    kPosFieldNumber = 6,
+    kIpFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4FallocateEnterFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4MarkInodeDirtyFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -84753,16 +116741,9 @@ class Ext4FallocateEnterFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4FallocateEnterFtraceEvent>;
+      Ext4MarkInodeDirtyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -84778,16 +116759,9 @@ class Ext4FallocateEnterFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4FallocateEnterFtraceEvent>;
+      Ext4MarkInodeDirtyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -84797,135 +116771,102 @@ class Ext4FallocateEnterFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Offset =
+  using FieldMetadata_Ip =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4FallocateEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4MarkInodeDirtyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Offset kOffset() { return {}; }
-  void set_offset(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId;
+  static constexpr FieldMetadata_Ip kIp{};
+  void set_ip(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ip::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Len =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4FallocateEnterFtraceEvent>;
+class Ext4LoadInodeBitmapFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  Ext4LoadInodeBitmapFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4LoadInodeBitmapFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4LoadInodeBitmapFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_group() const { return at<2>().valid(); }
+  uint32_t group() const { return at<2>().as_uint32(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+class Ext4LoadInodeBitmapFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4LoadInodeBitmapFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kGroupFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4LoadInodeBitmapFtraceEvent"; }
 
-  using FieldMetadata_Mode =
+
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4FallocateEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4LoadInodeBitmapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mode kMode() { return {}; }
-  void set_mode(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pos =
+  using FieldMetadata_Group =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4FallocateEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4LoadInodeBitmapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pos kPos() { return {}; }
-  void set_pos(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId;
+  static constexpr FieldMetadata_Group kGroup{};
+  void set_group(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Group::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4ExtShowExtentFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4LoadInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  Ext4ExtShowExtentFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4ExtShowExtentFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4ExtShowExtentFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4LoadInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4LoadInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4LoadInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_pblk() const { return at<3>().valid(); }
-  uint64_t pblk() const { return at<3>().as_uint64(); }
-  bool has_lblk() const { return at<4>().valid(); }
-  uint32_t lblk() const { return at<4>().as_uint32(); }
-  bool has_len() const { return at<5>().valid(); }
-  uint32_t len() const { return at<5>().as_uint32(); }
 };
 
-class Ext4ExtShowExtentFtraceEvent : public ::protozero::Message {
+class Ext4LoadInodeFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4ExtShowExtentFtraceEvent_Decoder;
+  using Decoder = Ext4LoadInodeFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kPblkFieldNumber = 3,
-    kLblkFieldNumber = 4,
-    kLenFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtShowExtentFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4LoadInodeFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -84934,16 +116875,9 @@ class Ext4ExtShowExtentFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtShowExtentFtraceEvent>;
+      Ext4LoadInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -84959,16 +116893,9 @@ class Ext4ExtShowExtentFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtShowExtentFtraceEvent>;
+      Ext4LoadInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -84977,126 +116904,36 @@ class Ext4ExtShowExtentFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-
-  using FieldMetadata_Pblk =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4ExtShowExtentFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pblk kPblk() { return {}; }
-  void set_pblk(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Lblk =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4ExtShowExtentFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lblk kLblk() { return {}; }
-  void set_lblk(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Len =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4ExtShowExtentFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
 };
 
-class Ext4ExtRmLeafFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4JournalledWriteEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  Ext4ExtRmLeafFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4ExtRmLeafFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4ExtRmLeafFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4JournalledWriteEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4JournalledWriteEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4JournalledWriteEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_partial() const { return at<3>().valid(); }
-  int64_t partial() const { return at<3>().as_int64(); }
-  bool has_start() const { return at<4>().valid(); }
-  uint32_t start() const { return at<4>().as_uint32(); }
-  bool has_ee_lblk() const { return at<5>().valid(); }
-  uint32_t ee_lblk() const { return at<5>().as_uint32(); }
-  bool has_ee_pblk() const { return at<6>().valid(); }
-  uint64_t ee_pblk() const { return at<6>().as_uint64(); }
-  bool has_ee_len() const { return at<7>().valid(); }
-  int32_t ee_len() const { return at<7>().as_int32(); }
-  bool has_pc_lblk() const { return at<8>().valid(); }
-  uint32_t pc_lblk() const { return at<8>().as_uint32(); }
-  bool has_pc_pclu() const { return at<9>().valid(); }
-  uint64_t pc_pclu() const { return at<9>().as_uint64(); }
-  bool has_pc_state() const { return at<10>().valid(); }
-  int32_t pc_state() const { return at<10>().as_int32(); }
+  bool has_pos() const { return at<3>().valid(); }
+  int64_t pos() const { return at<3>().as_int64(); }
+  bool has_len() const { return at<4>().valid(); }
+  uint32_t len() const { return at<4>().as_uint32(); }
+  bool has_copied() const { return at<5>().valid(); }
+  uint32_t copied() const { return at<5>().as_uint32(); }
 };
 
-class Ext4ExtRmLeafFtraceEvent : public ::protozero::Message {
+class Ext4JournalledWriteEndFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4ExtRmLeafFtraceEvent_Decoder;
+  using Decoder = Ext4JournalledWriteEndFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kPartialFieldNumber = 3,
-    kStartFieldNumber = 4,
-    kEeLblkFieldNumber = 5,
-    kEePblkFieldNumber = 6,
-    kEeLenFieldNumber = 7,
-    kPcLblkFieldNumber = 8,
-    kPcPcluFieldNumber = 9,
-    kPcStateFieldNumber = 10,
+    kPosFieldNumber = 3,
+    kLenFieldNumber = 4,
+    kCopiedFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtRmLeafFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4JournalledWriteEndFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -85105,16 +116942,9 @@ class Ext4ExtRmLeafFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtRmLeafFtraceEvent>;
+      Ext4JournalledWriteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -85130,16 +116960,9 @@ class Ext4ExtRmLeafFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtRmLeafFtraceEvent>;
+      Ext4JournalledWriteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -85149,24 +116972,17 @@ class Ext4ExtRmLeafFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Partial =
+  using FieldMetadata_Pos =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt64,
       int64_t,
-      Ext4ExtRmLeafFtraceEvent>;
+      Ext4JournalledWriteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Partial kPartial() { return {}; }
-  void set_partial(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Partial::kFieldId;
+  static constexpr FieldMetadata_Pos kPos{};
+  void set_pos(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -85174,24 +116990,17 @@ class Ext4ExtRmLeafFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Start =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4ExtRmLeafFtraceEvent>;
+      Ext4JournalledWriteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Start kStart() { return {}; }
-  void set_start(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -85199,49 +117008,66 @@ class Ext4ExtRmLeafFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_EeLblk =
+  using FieldMetadata_Copied =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4ExtRmLeafFtraceEvent>;
+      Ext4JournalledWriteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EeLblk kEeLblk() { return {}; }
-  void set_ee_lblk(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EeLblk::kFieldId;
+  static constexpr FieldMetadata_Copied kCopied{};
+  void set_copied(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Copied::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_EePblk =
+class Ext4JournalledInvalidatepageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  Ext4JournalledInvalidatepageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4JournalledInvalidatepageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4JournalledInvalidatepageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_index() const { return at<3>().valid(); }
+  uint64_t index() const { return at<3>().as_uint64(); }
+  bool has_offset() const { return at<4>().valid(); }
+  uint64_t offset() const { return at<4>().as_uint64(); }
+  bool has_length() const { return at<5>().valid(); }
+  uint32_t length() const { return at<5>().as_uint32(); }
+};
+
+class Ext4JournalledInvalidatepageFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4JournalledInvalidatepageFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kIndexFieldNumber = 3,
+    kOffsetFieldNumber = 4,
+    kLengthFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4JournalledInvalidatepageFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtRmLeafFtraceEvent>;
+      Ext4JournalledInvalidatepageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EePblk kEePblk() { return {}; }
-  void set_ee_pblk(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EePblk::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -85249,74 +117075,53 @@ class Ext4ExtRmLeafFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_EeLen =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4ExtRmLeafFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4JournalledInvalidatepageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EeLen kEeLen() { return {}; }
-  void set_ee_len(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EeLen::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PcLblk =
+  using FieldMetadata_Index =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4ExtRmLeafFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4JournalledInvalidatepageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PcLblk kPcLblk() { return {}; }
-  void set_pc_lblk(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PcLblk::kFieldId;
+  static constexpr FieldMetadata_Index kIndex{};
+  void set_index(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PcPclu =
+  using FieldMetadata_Offset =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtRmLeafFtraceEvent>;
+      Ext4JournalledInvalidatepageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PcPclu kPcPclu() { return {}; }
-  void set_pc_pclu(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PcPclu::kFieldId;
+  static constexpr FieldMetadata_Offset kOffset{};
+  void set_offset(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -85324,54 +117129,47 @@ class Ext4ExtRmLeafFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PcState =
+  using FieldMetadata_Length =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4ExtRmLeafFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4JournalledInvalidatepageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PcState kPcState() { return {}; }
-  void set_pc_state(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PcState::kFieldId;
+  static constexpr FieldMetadata_Length kLength{};
+  void set_length(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Length::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4ExtRmIdxFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4JournalStartReservedFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  Ext4ExtRmIdxFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4ExtRmIdxFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4ExtRmIdxFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4JournalStartReservedFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4JournalStartReservedFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4JournalStartReservedFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_pblk() const { return at<3>().valid(); }
-  uint64_t pblk() const { return at<3>().as_uint64(); }
+  bool has_ip() const { return at<2>().valid(); }
+  uint64_t ip() const { return at<2>().as_uint64(); }
+  bool has_blocks() const { return at<3>().valid(); }
+  int32_t blocks() const { return at<3>().as_int32(); }
 };
 
-class Ext4ExtRmIdxFtraceEvent : public ::protozero::Message {
+class Ext4JournalStartReservedFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4ExtRmIdxFtraceEvent_Decoder;
+  using Decoder = Ext4JournalStartReservedFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kPblkFieldNumber = 3,
+    kIpFieldNumber = 2,
+    kBlocksFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtRmIdxFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4JournalStartReservedFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -85380,16 +117178,9 @@ class Ext4ExtRmIdxFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtRmIdxFtraceEvent>;
+      Ext4JournalStartReservedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -85399,24 +117190,17 @@ class Ext4ExtRmIdxFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_Ip =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtRmIdxFtraceEvent>;
+      Ext4JournalStartReservedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_Ip kIp{};
+  void set_ip(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ip::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -85424,75 +117208,56 @@ class Ext4ExtRmIdxFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pblk =
+  using FieldMetadata_Blocks =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4ExtRmIdxFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4JournalStartReservedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pblk kPblk() { return {}; }
-  void set_pblk(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId;
+  static constexpr FieldMetadata_Blocks kBlocks{};
+  void set_blocks(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4ExtRemoveSpaceDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4JournalStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  Ext4ExtRemoveSpaceDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4ExtRemoveSpaceDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4ExtRemoveSpaceDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4JournalStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4JournalStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4JournalStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_start() const { return at<3>().valid(); }
-  uint32_t start() const { return at<3>().as_uint32(); }
-  bool has_end() const { return at<4>().valid(); }
-  uint32_t end() const { return at<4>().as_uint32(); }
-  bool has_depth() const { return at<5>().valid(); }
-  int32_t depth() const { return at<5>().as_int32(); }
-  bool has_partial() const { return at<6>().valid(); }
-  int64_t partial() const { return at<6>().as_int64(); }
-  bool has_eh_entries() const { return at<7>().valid(); }
-  uint32_t eh_entries() const { return at<7>().as_uint32(); }
-  bool has_pc_lblk() const { return at<8>().valid(); }
-  uint32_t pc_lblk() const { return at<8>().as_uint32(); }
-  bool has_pc_pclu() const { return at<9>().valid(); }
-  uint64_t pc_pclu() const { return at<9>().as_uint64(); }
-  bool has_pc_state() const { return at<10>().valid(); }
-  int32_t pc_state() const { return at<10>().as_int32(); }
+  bool has_ip() const { return at<2>().valid(); }
+  uint64_t ip() const { return at<2>().as_uint64(); }
+  bool has_blocks() const { return at<3>().valid(); }
+  int32_t blocks() const { return at<3>().as_int32(); }
+  bool has_rsv_blocks() const { return at<4>().valid(); }
+  int32_t rsv_blocks() const { return at<4>().as_int32(); }
+  bool has_nblocks() const { return at<5>().valid(); }
+  int32_t nblocks() const { return at<5>().as_int32(); }
+  bool has_revoke_creds() const { return at<6>().valid(); }
+  int32_t revoke_creds() const { return at<6>().as_int32(); }
 };
 
-class Ext4ExtRemoveSpaceDoneFtraceEvent : public ::protozero::Message {
+class Ext4JournalStartFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4ExtRemoveSpaceDoneFtraceEvent_Decoder;
+  using Decoder = Ext4JournalStartFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kStartFieldNumber = 3,
-    kEndFieldNumber = 4,
-    kDepthFieldNumber = 5,
-    kPartialFieldNumber = 6,
-    kEhEntriesFieldNumber = 7,
-    kPcLblkFieldNumber = 8,
-    kPcPcluFieldNumber = 9,
-    kPcStateFieldNumber = 10,
+    kIpFieldNumber = 2,
+    kBlocksFieldNumber = 3,
+    kRsvBlocksFieldNumber = 4,
+    kNblocksFieldNumber = 5,
+    kRevokeCredsFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtRemoveSpaceDoneFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4JournalStartFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -85501,16 +117266,9 @@ class Ext4ExtRemoveSpaceDoneFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtRemoveSpaceDoneFtraceEvent>;
+      Ext4JournalStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -85520,224 +117278,89 @@ class Ext4ExtRemoveSpaceDoneFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_Ip =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4ExtRemoveSpaceDoneFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Start =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4ExtRemoveSpaceDoneFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Start kStart() { return {}; }
-  void set_start(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_End =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4ExtRemoveSpaceDoneFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_End kEnd() { return {}; }
-  void set_end(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_End::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Depth =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4ExtRemoveSpaceDoneFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Depth kDepth() { return {}; }
-  void set_depth(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Depth::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Partial =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4ExtRemoveSpaceDoneFtraceEvent>;
+      uint64_t,
+      Ext4JournalStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Partial kPartial() { return {}; }
-  void set_partial(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Partial::kFieldId;
+  static constexpr FieldMetadata_Ip kIp{};
+  void set_ip(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ip::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_EhEntries =
+  using FieldMetadata_Blocks =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4ExtRemoveSpaceDoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4JournalStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EhEntries kEhEntries() { return {}; }
-  void set_eh_entries(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EhEntries::kFieldId;
+  static constexpr FieldMetadata_Blocks kBlocks{};
+  void set_blocks(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PcLblk =
+  using FieldMetadata_RsvBlocks =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4ExtRemoveSpaceDoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4JournalStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PcLblk kPcLblk() { return {}; }
-  void set_pc_lblk(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PcLblk::kFieldId;
+  static constexpr FieldMetadata_RsvBlocks kRsvBlocks{};
+  void set_rsv_blocks(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RsvBlocks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PcPclu =
+  using FieldMetadata_Nblocks =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4ExtRemoveSpaceDoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4JournalStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PcPclu kPcPclu() { return {}; }
-  void set_pc_pclu(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PcPclu::kFieldId;
+  static constexpr FieldMetadata_Nblocks kNblocks{};
+  void set_nblocks(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Nblocks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PcState =
+  using FieldMetadata_RevokeCreds =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4ExtRemoveSpaceDoneFtraceEvent>;
+      Ext4JournalStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PcState kPcState() { return {}; }
-  void set_pc_state(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PcState::kFieldId;
+  static constexpr FieldMetadata_RevokeCreds kRevokeCreds{};
+  void set_revoke_creds(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RevokeCreds::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -85746,34 +117369,34 @@ class Ext4ExtRemoveSpaceDoneFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4ExtRemoveSpaceFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4InvalidatepageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  Ext4ExtRemoveSpaceFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4ExtRemoveSpaceFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4ExtRemoveSpaceFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4InvalidatepageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4InvalidatepageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4InvalidatepageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_start() const { return at<3>().valid(); }
-  uint32_t start() const { return at<3>().as_uint32(); }
-  bool has_end() const { return at<4>().valid(); }
-  uint32_t end() const { return at<4>().as_uint32(); }
-  bool has_depth() const { return at<5>().valid(); }
-  int32_t depth() const { return at<5>().as_int32(); }
+  bool has_index() const { return at<3>().valid(); }
+  uint64_t index() const { return at<3>().as_uint64(); }
+  bool has_offset() const { return at<4>().valid(); }
+  uint64_t offset() const { return at<4>().as_uint64(); }
+  bool has_length() const { return at<5>().valid(); }
+  uint32_t length() const { return at<5>().as_uint32(); }
 };
 
-class Ext4ExtRemoveSpaceFtraceEvent : public ::protozero::Message {
+class Ext4InvalidatepageFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4ExtRemoveSpaceFtraceEvent_Decoder;
+  using Decoder = Ext4InvalidatepageFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kStartFieldNumber = 3,
-    kEndFieldNumber = 4,
-    kDepthFieldNumber = 5,
+    kIndexFieldNumber = 3,
+    kOffsetFieldNumber = 4,
+    kLengthFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtRemoveSpaceFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4InvalidatepageFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -85782,16 +117405,9 @@ class Ext4ExtRemoveSpaceFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtRemoveSpaceFtraceEvent>;
+      Ext4InvalidatepageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -85807,16 +117423,9 @@ class Ext4ExtRemoveSpaceFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtRemoveSpaceFtraceEvent>;
+      Ext4InvalidatepageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -85826,110 +117435,86 @@ class Ext4ExtRemoveSpaceFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Start =
+  using FieldMetadata_Index =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4ExtRemoveSpaceFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4InvalidatepageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Start kStart() { return {}; }
-  void set_start(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
+  static constexpr FieldMetadata_Index kIndex{};
+  void set_index(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_End =
+  using FieldMetadata_Offset =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4ExtRemoveSpaceFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4InvalidatepageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_End kEnd() { return {}; }
-  void set_end(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_End::kFieldId;
+  static constexpr FieldMetadata_Offset kOffset{};
+  void set_offset(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Depth =
+  using FieldMetadata_Length =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4ExtRemoveSpaceFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4InvalidatepageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Depth kDepth() { return {}; }
-  void set_depth(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Depth::kFieldId;
+  static constexpr FieldMetadata_Length kLength{};
+  void set_length(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Length::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4ExtPutInCacheFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4InsertRangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  Ext4ExtPutInCacheFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4ExtPutInCacheFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4ExtPutInCacheFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4InsertRangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4InsertRangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4InsertRangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_lblk() const { return at<3>().valid(); }
-  uint32_t lblk() const { return at<3>().as_uint32(); }
+  bool has_offset() const { return at<3>().valid(); }
+  int64_t offset() const { return at<3>().as_int64(); }
   bool has_len() const { return at<4>().valid(); }
-  uint32_t len() const { return at<4>().as_uint32(); }
-  bool has_start() const { return at<5>().valid(); }
-  uint64_t start() const { return at<5>().as_uint64(); }
+  int64_t len() const { return at<4>().as_int64(); }
 };
 
-class Ext4ExtPutInCacheFtraceEvent : public ::protozero::Message {
+class Ext4InsertRangeFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4ExtPutInCacheFtraceEvent_Decoder;
+  using Decoder = Ext4InsertRangeFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kLblkFieldNumber = 3,
+    kOffsetFieldNumber = 3,
     kLenFieldNumber = 4,
-    kStartFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtPutInCacheFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4InsertRangeFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -85938,16 +117523,9 @@ class Ext4ExtPutInCacheFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtPutInCacheFtraceEvent>;
+      Ext4InsertRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -85963,16 +117541,9 @@ class Ext4ExtPutInCacheFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtPutInCacheFtraceEvent>;
+      Ext4InsertRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -85982,28 +117553,21 @@ class Ext4ExtPutInCacheFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Lblk =
+  using FieldMetadata_Offset =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4ExtPutInCacheFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4InsertRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lblk kLblk() { return {}; }
-  void set_lblk(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
+  static constexpr FieldMetadata_Offset kOffset{};
+  void set_offset(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
@@ -86011,58 +117575,26 @@ class Ext4ExtPutInCacheFtraceEvent : public ::protozero::Message {
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4ExtPutInCacheFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4InsertRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Start =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4ExtPutInCacheFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Start kStart() { return {}; }
-  void set_start(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4ExtMapBlocksExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4IndMapBlocksExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
  public:
-  Ext4ExtMapBlocksExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4ExtMapBlocksExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4ExtMapBlocksExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4IndMapBlocksExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4IndMapBlocksExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4IndMapBlocksExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
@@ -86081,9 +117613,9 @@ class Ext4ExtMapBlocksExitFtraceEvent_Decoder : public ::protozero::TypedProtoDe
   int32_t ret() const { return at<8>().as_int32(); }
 };
 
-class Ext4ExtMapBlocksExitFtraceEvent : public ::protozero::Message {
+class Ext4IndMapBlocksExitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4ExtMapBlocksExitFtraceEvent_Decoder;
+  using Decoder = Ext4IndMapBlocksExitFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
@@ -86094,7 +117626,7 @@ class Ext4ExtMapBlocksExitFtraceEvent : public ::protozero::Message {
     kMflagsFieldNumber = 7,
     kRetFieldNumber = 8,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtMapBlocksExitFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4IndMapBlocksExitFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -86103,16 +117635,9 @@ class Ext4ExtMapBlocksExitFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtMapBlocksExitFtraceEvent>;
+      Ext4IndMapBlocksExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -86128,16 +117653,9 @@ class Ext4ExtMapBlocksExitFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtMapBlocksExitFtraceEvent>;
+      Ext4IndMapBlocksExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -86153,16 +117671,9 @@ class Ext4ExtMapBlocksExitFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4ExtMapBlocksExitFtraceEvent>;
+      Ext4IndMapBlocksExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
+  static constexpr FieldMetadata_Flags kFlags{};
   void set_flags(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -86178,16 +117689,9 @@ class Ext4ExtMapBlocksExitFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtMapBlocksExitFtraceEvent>;
+      Ext4IndMapBlocksExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pblk kPblk() { return {}; }
+  static constexpr FieldMetadata_Pblk kPblk{};
   void set_pblk(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -86203,16 +117707,9 @@ class Ext4ExtMapBlocksExitFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4ExtMapBlocksExitFtraceEvent>;
+      Ext4IndMapBlocksExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lblk kLblk() { return {}; }
+  static constexpr FieldMetadata_Lblk kLblk{};
   void set_lblk(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -86228,16 +117725,9 @@ class Ext4ExtMapBlocksExitFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4ExtMapBlocksExitFtraceEvent>;
+      Ext4IndMapBlocksExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
+  static constexpr FieldMetadata_Len kLen{};
   void set_len(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -86253,16 +117743,9 @@ class Ext4ExtMapBlocksExitFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4ExtMapBlocksExitFtraceEvent>;
+      Ext4IndMapBlocksExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mflags kMflags() { return {}; }
+  static constexpr FieldMetadata_Mflags kMflags{};
   void set_mflags(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Mflags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -86278,16 +117761,9 @@ class Ext4ExtMapBlocksExitFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4ExtMapBlocksExitFtraceEvent>;
+      Ext4IndMapBlocksExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
+  static constexpr FieldMetadata_Ret kRet{};
   void set_ret(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -86298,11 +117774,11 @@ class Ext4ExtMapBlocksExitFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4ExtMapBlocksEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4IndMapBlocksEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  Ext4ExtMapBlocksEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4ExtMapBlocksEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4ExtMapBlocksEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4IndMapBlocksEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4IndMapBlocksEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4IndMapBlocksEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
@@ -86315,9 +117791,9 @@ class Ext4ExtMapBlocksEnterFtraceEvent_Decoder : public ::protozero::TypedProtoD
   uint32_t flags() const { return at<5>().as_uint32(); }
 };
 
-class Ext4ExtMapBlocksEnterFtraceEvent : public ::protozero::Message {
+class Ext4IndMapBlocksEnterFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4ExtMapBlocksEnterFtraceEvent_Decoder;
+  using Decoder = Ext4IndMapBlocksEnterFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
@@ -86325,7 +117801,7 @@ class Ext4ExtMapBlocksEnterFtraceEvent : public ::protozero::Message {
     kLenFieldNumber = 4,
     kFlagsFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtMapBlocksEnterFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4IndMapBlocksEnterFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -86334,16 +117810,9 @@ class Ext4ExtMapBlocksEnterFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtMapBlocksEnterFtraceEvent>;
+      Ext4IndMapBlocksEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -86359,16 +117828,9 @@ class Ext4ExtMapBlocksEnterFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtMapBlocksEnterFtraceEvent>;
+      Ext4IndMapBlocksEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -86384,16 +117846,9 @@ class Ext4ExtMapBlocksEnterFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4ExtMapBlocksEnterFtraceEvent>;
+      Ext4IndMapBlocksEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lblk kLblk() { return {}; }
+  static constexpr FieldMetadata_Lblk kLblk{};
   void set_lblk(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -86409,16 +117864,9 @@ class Ext4ExtMapBlocksEnterFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4ExtMapBlocksEnterFtraceEvent>;
+      Ext4IndMapBlocksEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
+  static constexpr FieldMetadata_Len kLen{};
   void set_len(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -86434,16 +117882,9 @@ class Ext4ExtMapBlocksEnterFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4ExtMapBlocksEnterFtraceEvent>;
+      Ext4IndMapBlocksEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
+  static constexpr FieldMetadata_Flags kFlags{};
   void set_flags(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -86454,31 +117895,31 @@ class Ext4ExtMapBlocksEnterFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4ExtLoadExtentFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4GetReservedClusterAllocFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  Ext4ExtLoadExtentFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4ExtLoadExtentFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4ExtLoadExtentFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4GetReservedClusterAllocFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4GetReservedClusterAllocFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4GetReservedClusterAllocFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_pblk() const { return at<3>().valid(); }
-  uint64_t pblk() const { return at<3>().as_uint64(); }
-  bool has_lblk() const { return at<4>().valid(); }
-  uint32_t lblk() const { return at<4>().as_uint32(); }
+  bool has_lblk() const { return at<3>().valid(); }
+  uint32_t lblk() const { return at<3>().as_uint32(); }
+  bool has_len() const { return at<4>().valid(); }
+  uint32_t len() const { return at<4>().as_uint32(); }
 };
 
-class Ext4ExtLoadExtentFtraceEvent : public ::protozero::Message {
+class Ext4GetReservedClusterAllocFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4ExtLoadExtentFtraceEvent_Decoder;
+  using Decoder = Ext4GetReservedClusterAllocFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kPblkFieldNumber = 3,
-    kLblkFieldNumber = 4,
+    kLblkFieldNumber = 3,
+    kLenFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtLoadExtentFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4GetReservedClusterAllocFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -86487,16 +117928,9 @@ class Ext4ExtLoadExtentFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtLoadExtentFtraceEvent>;
+      Ext4GetReservedClusterAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -86512,16 +117946,9 @@ class Ext4ExtLoadExtentFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtLoadExtentFtraceEvent>;
+      Ext4GetReservedClusterAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -86531,49 +117958,35 @@ class Ext4ExtLoadExtentFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pblk =
+  using FieldMetadata_Lblk =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4ExtLoadExtentFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4GetReservedClusterAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pblk kPblk() { return {}; }
-  void set_pblk(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId;
+  static constexpr FieldMetadata_Lblk kLblk{};
+  void set_lblk(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Lblk =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4ExtLoadExtentFtraceEvent>;
+      Ext4GetReservedClusterAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lblk kLblk() { return {}; }
-  void set_lblk(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -86582,31 +117995,37 @@ class Ext4ExtLoadExtentFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4ExtInCacheFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4GetImpliedClusterAllocExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  Ext4ExtInCacheFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4ExtInCacheFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4ExtInCacheFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4GetImpliedClusterAllocExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4GetImpliedClusterAllocExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4GetImpliedClusterAllocExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_flags() const { return at<2>().valid(); }
+  uint32_t flags() const { return at<2>().as_uint32(); }
   bool has_lblk() const { return at<3>().valid(); }
   uint32_t lblk() const { return at<3>().as_uint32(); }
-  bool has_ret() const { return at<4>().valid(); }
-  int32_t ret() const { return at<4>().as_int32(); }
+  bool has_pblk() const { return at<4>().valid(); }
+  uint64_t pblk() const { return at<4>().as_uint64(); }
+  bool has_len() const { return at<5>().valid(); }
+  uint32_t len() const { return at<5>().as_uint32(); }
+  bool has_ret() const { return at<6>().valid(); }
+  int32_t ret() const { return at<6>().as_int32(); }
 };
 
-class Ext4ExtInCacheFtraceEvent : public ::protozero::Message {
+class Ext4GetImpliedClusterAllocExitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4ExtInCacheFtraceEvent_Decoder;
+  using Decoder = Ext4GetImpliedClusterAllocExitFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
+    kFlagsFieldNumber = 2,
     kLblkFieldNumber = 3,
-    kRetFieldNumber = 4,
+    kPblkFieldNumber = 4,
+    kLenFieldNumber = 5,
+    kRetFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtInCacheFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4GetImpliedClusterAllocExitFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -86615,16 +118034,9 @@ class Ext4ExtInCacheFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtInCacheFtraceEvent>;
+      Ext4GetImpliedClusterAllocExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -86634,28 +118046,21 @@ class Ext4ExtInCacheFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4ExtInCacheFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4GetImpliedClusterAllocExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
@@ -86665,16 +118070,9 @@ class Ext4ExtInCacheFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4ExtInCacheFtraceEvent>;
+      Ext4GetImpliedClusterAllocExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lblk kLblk() { return {}; }
+  static constexpr FieldMetadata_Lblk kLblk{};
   void set_lblk(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -86684,22 +118082,51 @@ class Ext4ExtInCacheFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ret =
+  using FieldMetadata_Pblk =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4GetImpliedClusterAllocExitFtraceEvent>;
+
+  static constexpr FieldMetadata_Pblk kPblk{};
+  void set_pblk(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Len =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4GetImpliedClusterAllocExitFtraceEvent>;
+
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ret =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4ExtInCacheFtraceEvent>;
+      Ext4GetImpliedClusterAllocExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
+  static constexpr FieldMetadata_Ret kRet{};
   void set_ret(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -86710,43 +118137,37 @@ class Ext4ExtInCacheFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4ExtHandleUnwrittenExtentsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4FreeInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  Ext4ExtHandleUnwrittenExtentsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4ExtHandleUnwrittenExtentsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4ExtHandleUnwrittenExtentsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4FreeInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4FreeInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4FreeInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_flags() const { return at<3>().valid(); }
-  int32_t flags() const { return at<3>().as_int32(); }
-  bool has_lblk() const { return at<4>().valid(); }
-  uint32_t lblk() const { return at<4>().as_uint32(); }
-  bool has_pblk() const { return at<5>().valid(); }
-  uint64_t pblk() const { return at<5>().as_uint64(); }
-  bool has_len() const { return at<6>().valid(); }
-  uint32_t len() const { return at<6>().as_uint32(); }
-  bool has_allocated() const { return at<7>().valid(); }
-  uint32_t allocated() const { return at<7>().as_uint32(); }
-  bool has_newblk() const { return at<8>().valid(); }
-  uint64_t newblk() const { return at<8>().as_uint64(); }
+  bool has_uid() const { return at<3>().valid(); }
+  uint32_t uid() const { return at<3>().as_uint32(); }
+  bool has_gid() const { return at<4>().valid(); }
+  uint32_t gid() const { return at<4>().as_uint32(); }
+  bool has_blocks() const { return at<5>().valid(); }
+  uint64_t blocks() const { return at<5>().as_uint64(); }
+  bool has_mode() const { return at<6>().valid(); }
+  uint32_t mode() const { return at<6>().as_uint32(); }
 };
 
-class Ext4ExtHandleUnwrittenExtentsFtraceEvent : public ::protozero::Message {
+class Ext4FreeInodeFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4ExtHandleUnwrittenExtentsFtraceEvent_Decoder;
+  using Decoder = Ext4FreeInodeFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kFlagsFieldNumber = 3,
-    kLblkFieldNumber = 4,
-    kPblkFieldNumber = 5,
-    kLenFieldNumber = 6,
-    kAllocatedFieldNumber = 7,
-    kNewblkFieldNumber = 8,
+    kUidFieldNumber = 3,
+    kGidFieldNumber = 4,
+    kBlocksFieldNumber = 5,
+    kModeFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtHandleUnwrittenExtentsFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4FreeInodeFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -86755,16 +118176,9 @@ class Ext4ExtHandleUnwrittenExtentsFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtHandleUnwrittenExtentsFtraceEvent>;
+      Ext4FreeInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -86780,16 +118194,9 @@ class Ext4ExtHandleUnwrittenExtentsFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtHandleUnwrittenExtentsFtraceEvent>;
+      Ext4FreeInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -86799,49 +118206,35 @@ class Ext4ExtHandleUnwrittenExtentsFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_Uid =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4ExtHandleUnwrittenExtentsFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4FreeInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_Uid kUid{};
+  void set_uid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Lblk =
+  using FieldMetadata_Gid =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4ExtHandleUnwrittenExtentsFtraceEvent>;
+      Ext4FreeInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lblk kLblk() { return {}; }
-  void set_lblk(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
+  static constexpr FieldMetadata_Gid kGid{};
+  void set_gid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Gid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -86849,24 +118242,17 @@ class Ext4ExtHandleUnwrittenExtentsFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pblk =
+  using FieldMetadata_Blocks =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtHandleUnwrittenExtentsFtraceEvent>;
+      Ext4FreeInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pblk kPblk() { return {}; }
-  void set_pblk(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId;
+  static constexpr FieldMetadata_Blocks kBlocks{};
+  void set_blocks(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -86874,125 +118260,56 @@ class Ext4ExtHandleUnwrittenExtentsFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_Mode =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4ExtHandleUnwrittenExtentsFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Allocated =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4ExtHandleUnwrittenExtentsFtraceEvent>;
+      Ext4FreeInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Allocated kAllocated() { return {}; }
-  void set_allocated(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Allocated::kFieldId;
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-
-  using FieldMetadata_Newblk =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4ExtHandleUnwrittenExtentsFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Newblk kNewblk() { return {}; }
-  void set_newblk(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Newblk::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
 };
 
-class Ext4ExtConvertToInitializedFastpathFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4FreeBlocksFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  Ext4ExtConvertToInitializedFastpathFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4ExtConvertToInitializedFastpathFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4ExtConvertToInitializedFastpathFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4FreeBlocksFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4FreeBlocksFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4FreeBlocksFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_m_lblk() const { return at<3>().valid(); }
-  uint32_t m_lblk() const { return at<3>().as_uint32(); }
-  bool has_m_len() const { return at<4>().valid(); }
-  uint32_t m_len() const { return at<4>().as_uint32(); }
-  bool has_u_lblk() const { return at<5>().valid(); }
-  uint32_t u_lblk() const { return at<5>().as_uint32(); }
-  bool has_u_len() const { return at<6>().valid(); }
-  uint32_t u_len() const { return at<6>().as_uint32(); }
-  bool has_u_pblk() const { return at<7>().valid(); }
-  uint64_t u_pblk() const { return at<7>().as_uint64(); }
-  bool has_i_lblk() const { return at<8>().valid(); }
-  uint32_t i_lblk() const { return at<8>().as_uint32(); }
-  bool has_i_len() const { return at<9>().valid(); }
-  uint32_t i_len() const { return at<9>().as_uint32(); }
-  bool has_i_pblk() const { return at<10>().valid(); }
-  uint64_t i_pblk() const { return at<10>().as_uint64(); }
+  bool has_block() const { return at<3>().valid(); }
+  uint64_t block() const { return at<3>().as_uint64(); }
+  bool has_count() const { return at<4>().valid(); }
+  uint64_t count() const { return at<4>().as_uint64(); }
+  bool has_flags() const { return at<5>().valid(); }
+  int32_t flags() const { return at<5>().as_int32(); }
+  bool has_mode() const { return at<6>().valid(); }
+  uint32_t mode() const { return at<6>().as_uint32(); }
 };
 
-class Ext4ExtConvertToInitializedFastpathFtraceEvent : public ::protozero::Message {
+class Ext4FreeBlocksFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4ExtConvertToInitializedFastpathFtraceEvent_Decoder;
+  using Decoder = Ext4FreeBlocksFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kMLblkFieldNumber = 3,
-    kMLenFieldNumber = 4,
-    kULblkFieldNumber = 5,
-    kULenFieldNumber = 6,
-    kUPblkFieldNumber = 7,
-    kILblkFieldNumber = 8,
-    kILenFieldNumber = 9,
-    kIPblkFieldNumber = 10,
+    kBlockFieldNumber = 3,
+    kCountFieldNumber = 4,
+    kFlagsFieldNumber = 5,
+    kModeFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtConvertToInitializedFastpathFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4FreeBlocksFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -87001,16 +118318,9 @@ class Ext4ExtConvertToInitializedFastpathFtraceEvent : public ::protozero::Messa
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtConvertToInitializedFastpathFtraceEvent>;
+      Ext4FreeBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -87026,16 +118336,9 @@ class Ext4ExtConvertToInitializedFastpathFtraceEvent : public ::protozero::Messa
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtConvertToInitializedFastpathFtraceEvent>;
+      Ext4FreeBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -87045,124 +118348,120 @@ class Ext4ExtConvertToInitializedFastpathFtraceEvent : public ::protozero::Messa
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MLblk =
+  using FieldMetadata_Block =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4ExtConvertToInitializedFastpathFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4FreeBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MLblk kMLblk() { return {}; }
-  void set_m_lblk(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MLblk::kFieldId;
+  static constexpr FieldMetadata_Block kBlock{};
+  void set_block(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Block::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MLen =
+  using FieldMetadata_Count =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4ExtConvertToInitializedFastpathFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4FreeBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MLen kMLen() { return {}; }
-  void set_m_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MLen::kFieldId;
+  static constexpr FieldMetadata_Count kCount{};
+  void set_count(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ULblk =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4ExtConvertToInitializedFastpathFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4FreeBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ULblk kULblk() { return {}; }
-  void set_u_lblk(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ULblk::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ULen =
+  using FieldMetadata_Mode =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4ExtConvertToInitializedFastpathFtraceEvent>;
+      Ext4FreeBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ULen kULen() { return {}; }
-  void set_u_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ULen::kFieldId;
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_UPblk =
+class Ext4ForgetFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  Ext4ForgetFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4ForgetFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4ForgetFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_block() const { return at<3>().valid(); }
+  uint64_t block() const { return at<3>().as_uint64(); }
+  bool has_is_metadata() const { return at<4>().valid(); }
+  int32_t is_metadata() const { return at<4>().as_int32(); }
+  bool has_mode() const { return at<5>().valid(); }
+  uint32_t mode() const { return at<5>().as_uint32(); }
+};
+
+class Ext4ForgetFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4ForgetFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kBlockFieldNumber = 3,
+    kIsMetadataFieldNumber = 4,
+    kModeFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ForgetFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtConvertToInitializedFastpathFtraceEvent>;
+      Ext4ForgetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UPblk kUPblk() { return {}; }
-  void set_u_pblk(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_UPblk::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -87170,116 +118469,113 @@ class Ext4ExtConvertToInitializedFastpathFtraceEvent : public ::protozero::Messa
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ILblk =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4ExtConvertToInitializedFastpathFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4ForgetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ILblk kILblk() { return {}; }
-  void set_i_lblk(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ILblk::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ILen =
+  using FieldMetadata_Block =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4ExtConvertToInitializedFastpathFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4ForgetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ILen kILen() { return {}; }
-  void set_i_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ILen::kFieldId;
+  static constexpr FieldMetadata_Block kBlock{};
+  void set_block(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Block::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IPblk =
+  using FieldMetadata_IsMetadata =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4ExtConvertToInitializedFastpathFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4ForgetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IPblk kIPblk() { return {}; }
-  void set_i_pblk(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IPblk::kFieldId;
+  static constexpr FieldMetadata_IsMetadata kIsMetadata{};
+  void set_is_metadata(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsMetadata::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Mode =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ForgetFtraceEvent>;
+
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4ExtConvertToInitializedEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4FindDelallocRangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
-  Ext4ExtConvertToInitializedEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4ExtConvertToInitializedEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4ExtConvertToInitializedEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4FindDelallocRangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4FindDelallocRangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4FindDelallocRangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_m_lblk() const { return at<3>().valid(); }
-  uint32_t m_lblk() const { return at<3>().as_uint32(); }
-  bool has_m_len() const { return at<4>().valid(); }
-  uint32_t m_len() const { return at<4>().as_uint32(); }
-  bool has_u_lblk() const { return at<5>().valid(); }
-  uint32_t u_lblk() const { return at<5>().as_uint32(); }
-  bool has_u_len() const { return at<6>().valid(); }
-  uint32_t u_len() const { return at<6>().as_uint32(); }
-  bool has_u_pblk() const { return at<7>().valid(); }
-  uint64_t u_pblk() const { return at<7>().as_uint64(); }
+  bool has_from() const { return at<3>().valid(); }
+  uint32_t from() const { return at<3>().as_uint32(); }
+  bool has_to() const { return at<4>().valid(); }
+  uint32_t to() const { return at<4>().as_uint32(); }
+  bool has_reverse() const { return at<5>().valid(); }
+  int32_t reverse() const { return at<5>().as_int32(); }
+  bool has_found() const { return at<6>().valid(); }
+  int32_t found() const { return at<6>().as_int32(); }
+  bool has_found_blk() const { return at<7>().valid(); }
+  uint32_t found_blk() const { return at<7>().as_uint32(); }
 };
 
-class Ext4ExtConvertToInitializedEnterFtraceEvent : public ::protozero::Message {
+class Ext4FindDelallocRangeFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4ExtConvertToInitializedEnterFtraceEvent_Decoder;
+  using Decoder = Ext4FindDelallocRangeFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kMLblkFieldNumber = 3,
-    kMLenFieldNumber = 4,
-    kULblkFieldNumber = 5,
-    kULenFieldNumber = 6,
-    kUPblkFieldNumber = 7,
+    kFromFieldNumber = 3,
+    kToFieldNumber = 4,
+    kReverseFieldNumber = 5,
+    kFoundFieldNumber = 6,
+    kFoundBlkFieldNumber = 7,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtConvertToInitializedEnterFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4FindDelallocRangeFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -87288,16 +118584,9 @@ class Ext4ExtConvertToInitializedEnterFtraceEvent : public ::protozero::Message
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtConvertToInitializedEnterFtraceEvent>;
+      Ext4FindDelallocRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -87313,16 +118602,9 @@ class Ext4ExtConvertToInitializedEnterFtraceEvent : public ::protozero::Message
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4ExtConvertToInitializedEnterFtraceEvent>;
+      Ext4FindDelallocRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -87332,24 +118614,17 @@ class Ext4ExtConvertToInitializedEnterFtraceEvent : public ::protozero::Message
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MLblk =
+  using FieldMetadata_From =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4ExtConvertToInitializedEnterFtraceEvent>;
+      Ext4FindDelallocRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MLblk kMLblk() { return {}; }
-  void set_m_lblk(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MLblk::kFieldId;
+  static constexpr FieldMetadata_From kFrom{};
+  void set_from(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_From::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -87357,24 +118632,17 @@ class Ext4ExtConvertToInitializedEnterFtraceEvent : public ::protozero::Message
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MLen =
+  using FieldMetadata_To =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4ExtConvertToInitializedEnterFtraceEvent>;
+      Ext4FindDelallocRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MLen kMLen() { return {}; }
-  void set_m_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MLen::kFieldId;
+  static constexpr FieldMetadata_To kTo{};
+  void set_to(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_To::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -87382,104 +118650,89 @@ class Ext4ExtConvertToInitializedEnterFtraceEvent : public ::protozero::Message
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ULblk =
+  using FieldMetadata_Reverse =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4ExtConvertToInitializedEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4FindDelallocRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ULblk kULblk() { return {}; }
-  void set_u_lblk(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ULblk::kFieldId;
+  static constexpr FieldMetadata_Reverse kReverse{};
+  void set_reverse(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Reverse::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ULen =
+  using FieldMetadata_Found =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4ExtConvertToInitializedEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4FindDelallocRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ULen kULen() { return {}; }
-  void set_u_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ULen::kFieldId;
+  static constexpr FieldMetadata_Found kFound{};
+  void set_found(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Found::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_UPblk =
+  using FieldMetadata_FoundBlk =
     ::protozero::proto_utils::FieldMetadata<
       7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4ExtConvertToInitializedEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4FindDelallocRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UPblk kUPblk() { return {}; }
-  void set_u_pblk(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_UPblk::kFieldId;
+  static constexpr FieldMetadata_FoundBlk kFoundBlk{};
+  void set_found_blk(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FoundBlk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4EvictInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4FallocateExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  Ext4EvictInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4EvictInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4EvictInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4FallocateExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4FallocateExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4FallocateExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_nlink() const { return at<3>().valid(); }
-  int32_t nlink() const { return at<3>().as_int32(); }
+  bool has_pos() const { return at<3>().valid(); }
+  int64_t pos() const { return at<3>().as_int64(); }
+  bool has_blocks() const { return at<4>().valid(); }
+  uint32_t blocks() const { return at<4>().as_uint32(); }
+  bool has_ret() const { return at<5>().valid(); }
+  int32_t ret() const { return at<5>().as_int32(); }
 };
 
-class Ext4EvictInodeFtraceEvent : public ::protozero::Message {
+class Ext4FallocateExitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4EvictInodeFtraceEvent_Decoder;
+  using Decoder = Ext4FallocateExitFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kNlinkFieldNumber = 3,
+    kPosFieldNumber = 3,
+    kBlocksFieldNumber = 4,
+    kRetFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EvictInodeFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4FallocateExitFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -87488,16 +118741,9 @@ class Ext4EvictInodeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4EvictInodeFtraceEvent>;
+      Ext4FallocateExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -87513,16 +118759,9 @@ class Ext4EvictInodeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4EvictInodeFtraceEvent>;
+      Ext4FallocateExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -87532,24 +118771,53 @@ class Ext4EvictInodeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Nlink =
+  using FieldMetadata_Pos =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4FallocateExitFtraceEvent>;
+
+  static constexpr FieldMetadata_Pos kPos{};
+  void set_pos(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Blocks =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4FallocateExitFtraceEvent>;
+
+  static constexpr FieldMetadata_Blocks kBlocks{};
+  void set_blocks(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ret =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4EvictInodeFtraceEvent>;
+      Ext4FallocateExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nlink kNlink() { return {}; }
-  void set_nlink(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Nlink::kFieldId;
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -87558,28 +118826,37 @@ class Ext4EvictInodeFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4EsShrinkScanExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4FallocateEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  Ext4EsShrinkScanExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4EsShrinkScanExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4EsShrinkScanExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4FallocateEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4FallocateEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4FallocateEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_nr_shrunk() const { return at<2>().valid(); }
-  int32_t nr_shrunk() const { return at<2>().as_int32(); }
-  bool has_cache_cnt() const { return at<3>().valid(); }
-  int32_t cache_cnt() const { return at<3>().as_int32(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_offset() const { return at<3>().valid(); }
+  int64_t offset() const { return at<3>().as_int64(); }
+  bool has_len() const { return at<4>().valid(); }
+  int64_t len() const { return at<4>().as_int64(); }
+  bool has_mode() const { return at<5>().valid(); }
+  int32_t mode() const { return at<5>().as_int32(); }
+  bool has_pos() const { return at<6>().valid(); }
+  int64_t pos() const { return at<6>().as_int64(); }
 };
 
-class Ext4EsShrinkScanExitFtraceEvent : public ::protozero::Message {
+class Ext4FallocateEnterFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4EsShrinkScanExitFtraceEvent_Decoder;
+  using Decoder = Ext4FallocateEnterFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
-    kNrShrunkFieldNumber = 2,
-    kCacheCntFieldNumber = 3,
+    kInoFieldNumber = 2,
+    kOffsetFieldNumber = 3,
+    kLenFieldNumber = 4,
+    kModeFieldNumber = 5,
+    kPosFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsShrinkScanExitFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4FallocateEnterFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -87588,16 +118865,9 @@ class Ext4EsShrinkScanExitFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4EsShrinkScanExitFtraceEvent>;
+      Ext4FallocateEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -87607,79 +118877,125 @@ class Ext4EsShrinkScanExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NrShrunk =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4EsShrinkScanExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4FallocateEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrShrunk kNrShrunk() { return {}; }
-  void set_nr_shrunk(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NrShrunk::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CacheCnt =
+  using FieldMetadata_Offset =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4FallocateEnterFtraceEvent>;
+
+  static constexpr FieldMetadata_Offset kOffset{};
+  void set_offset(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Len =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4FallocateEnterFtraceEvent>;
+
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Mode =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4EsShrinkScanExitFtraceEvent>;
+      Ext4FallocateEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CacheCnt kCacheCnt() { return {}; }
-  void set_cache_cnt(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CacheCnt::kFieldId;
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_Pos =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4FallocateEnterFtraceEvent>;
+
+  static constexpr FieldMetadata_Pos kPos{};
+  void set_pos(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class Ext4EsShrinkScanEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4ExtShowExtentFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  Ext4EsShrinkScanEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4EsShrinkScanEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4EsShrinkScanEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4ExtShowExtentFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4ExtShowExtentFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4ExtShowExtentFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_nr_to_scan() const { return at<2>().valid(); }
-  int32_t nr_to_scan() const { return at<2>().as_int32(); }
-  bool has_cache_cnt() const { return at<3>().valid(); }
-  int32_t cache_cnt() const { return at<3>().as_int32(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_pblk() const { return at<3>().valid(); }
+  uint64_t pblk() const { return at<3>().as_uint64(); }
+  bool has_lblk() const { return at<4>().valid(); }
+  uint32_t lblk() const { return at<4>().as_uint32(); }
+  bool has_len() const { return at<5>().valid(); }
+  uint32_t len() const { return at<5>().as_uint32(); }
 };
 
-class Ext4EsShrinkScanEnterFtraceEvent : public ::protozero::Message {
+class Ext4ExtShowExtentFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4EsShrinkScanEnterFtraceEvent_Decoder;
+  using Decoder = Ext4ExtShowExtentFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
-    kNrToScanFieldNumber = 2,
-    kCacheCntFieldNumber = 3,
+    kInoFieldNumber = 2,
+    kPblkFieldNumber = 3,
+    kLblkFieldNumber = 4,
+    kLenFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsShrinkScanEnterFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtShowExtentFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -87688,16 +119004,9 @@ class Ext4EsShrinkScanEnterFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4EsShrinkScanEnterFtraceEvent>;
+      Ext4ExtShowExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -87707,79 +119016,122 @@ class Ext4EsShrinkScanEnterFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NrToScan =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4EsShrinkScanEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4ExtShowExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrToScan kNrToScan() { return {}; }
-  void set_nr_to_scan(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NrToScan::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CacheCnt =
+  using FieldMetadata_Pblk =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4EsShrinkScanEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4ExtShowExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CacheCnt kCacheCnt() { return {}; }
-  void set_cache_cnt(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CacheCnt::kFieldId;
+  static constexpr FieldMetadata_Pblk kPblk{};
+  void set_pblk(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Lblk =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ExtShowExtentFtraceEvent>;
+
+  static constexpr FieldMetadata_Lblk kLblk{};
+  void set_lblk(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Len =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ExtShowExtentFtraceEvent>;
+
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4EsShrinkCountFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4ExtRmLeafFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10> {
  public:
-  Ext4EsShrinkCountFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4EsShrinkCountFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4EsShrinkCountFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4ExtRmLeafFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4ExtRmLeafFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4ExtRmLeafFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_nr_to_scan() const { return at<2>().valid(); }
-  int32_t nr_to_scan() const { return at<2>().as_int32(); }
-  bool has_cache_cnt() const { return at<3>().valid(); }
-  int32_t cache_cnt() const { return at<3>().as_int32(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_partial() const { return at<3>().valid(); }
+  int64_t partial() const { return at<3>().as_int64(); }
+  bool has_start() const { return at<4>().valid(); }
+  uint32_t start() const { return at<4>().as_uint32(); }
+  bool has_ee_lblk() const { return at<5>().valid(); }
+  uint32_t ee_lblk() const { return at<5>().as_uint32(); }
+  bool has_ee_pblk() const { return at<6>().valid(); }
+  uint64_t ee_pblk() const { return at<6>().as_uint64(); }
+  bool has_ee_len() const { return at<7>().valid(); }
+  int32_t ee_len() const { return at<7>().as_int32(); }
+  bool has_pc_lblk() const { return at<8>().valid(); }
+  uint32_t pc_lblk() const { return at<8>().as_uint32(); }
+  bool has_pc_pclu() const { return at<9>().valid(); }
+  uint64_t pc_pclu() const { return at<9>().as_uint64(); }
+  bool has_pc_state() const { return at<10>().valid(); }
+  int32_t pc_state() const { return at<10>().as_int32(); }
 };
 
-class Ext4EsShrinkCountFtraceEvent : public ::protozero::Message {
+class Ext4ExtRmLeafFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4EsShrinkCountFtraceEvent_Decoder;
+  using Decoder = Ext4ExtRmLeafFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
-    kNrToScanFieldNumber = 2,
-    kCacheCntFieldNumber = 3,
+    kInoFieldNumber = 2,
+    kPartialFieldNumber = 3,
+    kStartFieldNumber = 4,
+    kEeLblkFieldNumber = 5,
+    kEePblkFieldNumber = 6,
+    kEeLenFieldNumber = 7,
+    kPcLblkFieldNumber = 8,
+    kPcPcluFieldNumber = 9,
+    kPcStateFieldNumber = 10,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsShrinkCountFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtRmLeafFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -87788,16 +119140,9 @@ class Ext4EsShrinkCountFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4EsShrinkCountFtraceEvent>;
+      Ext4ExtRmLeafFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -87807,105 +119152,89 @@ class Ext4EsShrinkCountFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NrToScan =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4EsShrinkCountFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4ExtRmLeafFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrToScan kNrToScan() { return {}; }
-  void set_nr_to_scan(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NrToScan::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CacheCnt =
+  using FieldMetadata_Partial =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4EsShrinkCountFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4ExtRmLeafFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CacheCnt kCacheCnt() { return {}; }
-  void set_cache_cnt(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CacheCnt::kFieldId;
+  static constexpr FieldMetadata_Partial kPartial{};
+  void set_partial(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Partial::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
-};
 
-class Ext4EsShrinkFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Ext4EsShrinkFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4EsShrinkFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4EsShrinkFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_nr_shrunk() const { return at<2>().valid(); }
-  int32_t nr_shrunk() const { return at<2>().as_int32(); }
-  bool has_scan_time() const { return at<3>().valid(); }
-  uint64_t scan_time() const { return at<3>().as_uint64(); }
-  bool has_nr_skipped() const { return at<4>().valid(); }
-  int32_t nr_skipped() const { return at<4>().as_int32(); }
-  bool has_retried() const { return at<5>().valid(); }
-  int32_t retried() const { return at<5>().as_int32(); }
-};
+  using FieldMetadata_Start =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ExtRmLeafFtraceEvent>;
 
-class Ext4EsShrinkFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = Ext4EsShrinkFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kNrShrunkFieldNumber = 2,
-    kScanTimeFieldNumber = 3,
-    kNrSkippedFieldNumber = 4,
-    kRetriedFieldNumber = 5,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsShrinkFtraceEvent"; }
+  static constexpr FieldMetadata_Start kStart{};
+  void set_start(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_EeLblk =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ExtRmLeafFtraceEvent>;
 
+  static constexpr FieldMetadata_EeLblk kEeLblk{};
+  void set_ee_lblk(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EeLblk::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_EePblk =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4EsShrinkFtraceEvent>;
+      Ext4ExtRmLeafFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_EePblk kEePblk{};
+  void set_ee_pblk(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EePblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -87913,24 +119242,17 @@ class Ext4EsShrinkFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NrShrunk =
+  using FieldMetadata_EeLen =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4EsShrinkFtraceEvent>;
+      Ext4ExtRmLeafFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrShrunk kNrShrunk() { return {}; }
-  void set_nr_shrunk(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NrShrunk::kFieldId;
+  static constexpr FieldMetadata_EeLen kEeLen{};
+  void set_ee_len(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EeLen::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -87938,74 +119260,53 @@ class Ext4EsShrinkFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ScanTime =
+  using FieldMetadata_PcLblk =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4EsShrinkFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ExtRmLeafFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ScanTime kScanTime() { return {}; }
-  void set_scan_time(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ScanTime::kFieldId;
+  static constexpr FieldMetadata_PcLblk kPcLblk{};
+  void set_pc_lblk(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PcLblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NrSkipped =
+  using FieldMetadata_PcPclu =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4EsShrinkFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4ExtRmLeafFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrSkipped kNrSkipped() { return {}; }
-  void set_nr_skipped(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NrSkipped::kFieldId;
+  static constexpr FieldMetadata_PcPclu kPcPclu{};
+  void set_pc_pclu(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PcPclu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Retried =
+  using FieldMetadata_PcState =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4EsShrinkFtraceEvent>;
+      Ext4ExtRmLeafFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Retried kRetried() { return {}; }
-  void set_retried(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Retried::kFieldId;
+  static constexpr FieldMetadata_PcState kPcState{};
+  void set_pc_state(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PcState::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -88014,31 +119315,28 @@ class Ext4EsShrinkFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4EsRemoveExtentFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4ExtRmIdxFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  Ext4EsRemoveExtentFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4EsRemoveExtentFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4EsRemoveExtentFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4ExtRmIdxFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4ExtRmIdxFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4ExtRmIdxFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_lblk() const { return at<3>().valid(); }
-  int64_t lblk() const { return at<3>().as_int64(); }
-  bool has_len() const { return at<4>().valid(); }
-  int64_t len() const { return at<4>().as_int64(); }
+  bool has_pblk() const { return at<3>().valid(); }
+  uint64_t pblk() const { return at<3>().as_uint64(); }
 };
 
-class Ext4EsRemoveExtentFtraceEvent : public ::protozero::Message {
+class Ext4ExtRmIdxFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4EsRemoveExtentFtraceEvent_Decoder;
+  using Decoder = Ext4ExtRmIdxFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kLblkFieldNumber = 3,
-    kLenFieldNumber = 4,
+    kPblkFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsRemoveExtentFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtRmIdxFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -88047,16 +119345,9 @@ class Ext4EsRemoveExtentFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4EsRemoveExtentFtraceEvent>;
+      Ext4ExtRmIdxFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -88072,16 +119363,9 @@ class Ext4EsRemoveExtentFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4EsRemoveExtentFtraceEvent>;
+      Ext4ExtRmIdxFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -88091,91 +119375,68 @@ class Ext4EsRemoveExtentFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Lblk =
+  using FieldMetadata_Pblk =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4EsRemoveExtentFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lblk kLblk() { return {}; }
-  void set_lblk(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Len =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4EsRemoveExtentFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4ExtRmIdxFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_Pblk kPblk{};
+  void set_pblk(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4EsLookupExtentExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4ExtRemoveSpaceDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10> {
  public:
-  Ext4EsLookupExtentExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4EsLookupExtentExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4EsLookupExtentExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4ExtRemoveSpaceDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4ExtRemoveSpaceDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4ExtRemoveSpaceDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_lblk() const { return at<3>().valid(); }
-  uint32_t lblk() const { return at<3>().as_uint32(); }
-  bool has_len() const { return at<4>().valid(); }
-  uint32_t len() const { return at<4>().as_uint32(); }
-  bool has_pblk() const { return at<5>().valid(); }
-  uint64_t pblk() const { return at<5>().as_uint64(); }
-  bool has_status() const { return at<6>().valid(); }
-  uint64_t status() const { return at<6>().as_uint64(); }
-  bool has_found() const { return at<7>().valid(); }
-  int32_t found() const { return at<7>().as_int32(); }
+  bool has_start() const { return at<3>().valid(); }
+  uint32_t start() const { return at<3>().as_uint32(); }
+  bool has_end() const { return at<4>().valid(); }
+  uint32_t end() const { return at<4>().as_uint32(); }
+  bool has_depth() const { return at<5>().valid(); }
+  int32_t depth() const { return at<5>().as_int32(); }
+  bool has_partial() const { return at<6>().valid(); }
+  int64_t partial() const { return at<6>().as_int64(); }
+  bool has_eh_entries() const { return at<7>().valid(); }
+  uint32_t eh_entries() const { return at<7>().as_uint32(); }
+  bool has_pc_lblk() const { return at<8>().valid(); }
+  uint32_t pc_lblk() const { return at<8>().as_uint32(); }
+  bool has_pc_pclu() const { return at<9>().valid(); }
+  uint64_t pc_pclu() const { return at<9>().as_uint64(); }
+  bool has_pc_state() const { return at<10>().valid(); }
+  int32_t pc_state() const { return at<10>().as_int32(); }
 };
 
-class Ext4EsLookupExtentExitFtraceEvent : public ::protozero::Message {
+class Ext4ExtRemoveSpaceDoneFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4EsLookupExtentExitFtraceEvent_Decoder;
+  using Decoder = Ext4ExtRemoveSpaceDoneFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kLblkFieldNumber = 3,
-    kLenFieldNumber = 4,
-    kPblkFieldNumber = 5,
-    kStatusFieldNumber = 6,
-    kFoundFieldNumber = 7,
+    kStartFieldNumber = 3,
+    kEndFieldNumber = 4,
+    kDepthFieldNumber = 5,
+    kPartialFieldNumber = 6,
+    kEhEntriesFieldNumber = 7,
+    kPcLblkFieldNumber = 8,
+    kPcPcluFieldNumber = 9,
+    kPcStateFieldNumber = 10,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsLookupExtentExitFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtRemoveSpaceDoneFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -88184,16 +119445,9 @@ class Ext4EsLookupExtentExitFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4EsLookupExtentExitFtraceEvent>;
+      Ext4ExtRemoveSpaceDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -88209,16 +119463,9 @@ class Ext4EsLookupExtentExitFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4EsLookupExtentExitFtraceEvent>;
+      Ext4ExtRemoveSpaceDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -88228,24 +119475,17 @@ class Ext4EsLookupExtentExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Lblk =
+  using FieldMetadata_Start =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4EsLookupExtentExitFtraceEvent>;
+      Ext4ExtRemoveSpaceDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lblk kLblk() { return {}; }
-  void set_lblk(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
+  static constexpr FieldMetadata_Start kStart{};
+  void set_start(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -88253,24 +119493,17 @@ class Ext4EsLookupExtentExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_End =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4EsLookupExtentExitFtraceEvent>;
+      Ext4ExtRemoveSpaceDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_End kEnd{};
+  void set_end(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_End::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -88278,49 +119511,89 @@ class Ext4EsLookupExtentExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pblk =
+  using FieldMetadata_Depth =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4EsLookupExtentExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4ExtRemoveSpaceDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pblk kPblk() { return {}; }
-  void set_pblk(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId;
+  static constexpr FieldMetadata_Depth kDepth{};
+  void set_depth(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Depth::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Status =
+  using FieldMetadata_Partial =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4ExtRemoveSpaceDoneFtraceEvent>;
+
+  static constexpr FieldMetadata_Partial kPartial{};
+  void set_partial(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Partial::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_EhEntries =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ExtRemoveSpaceDoneFtraceEvent>;
+
+  static constexpr FieldMetadata_EhEntries kEhEntries{};
+  void set_eh_entries(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EhEntries::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PcLblk =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ExtRemoveSpaceDoneFtraceEvent>;
+
+  static constexpr FieldMetadata_PcLblk kPcLblk{};
+  void set_pc_lblk(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PcLblk::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PcPclu =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4EsLookupExtentExitFtraceEvent>;
+      Ext4ExtRemoveSpaceDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Status kStatus() { return {}; }
-  void set_status(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId;
+  static constexpr FieldMetadata_PcPclu kPcPclu{};
+  void set_pc_pclu(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PcPclu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -88328,24 +119601,17 @@ class Ext4EsLookupExtentExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Found =
+  using FieldMetadata_PcState =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4EsLookupExtentExitFtraceEvent>;
+      Ext4ExtRemoveSpaceDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Found kFound() { return {}; }
-  void set_found(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Found::kFieldId;
+  static constexpr FieldMetadata_PcState kPcState{};
+  void set_pc_state(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PcState::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -88354,28 +119620,34 @@ class Ext4EsLookupExtentExitFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4EsLookupExtentEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4ExtRemoveSpaceFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  Ext4EsLookupExtentEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4EsLookupExtentEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4EsLookupExtentEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4ExtRemoveSpaceFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4ExtRemoveSpaceFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4ExtRemoveSpaceFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_lblk() const { return at<3>().valid(); }
-  uint32_t lblk() const { return at<3>().as_uint32(); }
+  bool has_start() const { return at<3>().valid(); }
+  uint32_t start() const { return at<3>().as_uint32(); }
+  bool has_end() const { return at<4>().valid(); }
+  uint32_t end() const { return at<4>().as_uint32(); }
+  bool has_depth() const { return at<5>().valid(); }
+  int32_t depth() const { return at<5>().as_int32(); }
 };
 
-class Ext4EsLookupExtentEnterFtraceEvent : public ::protozero::Message {
+class Ext4ExtRemoveSpaceFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4EsLookupExtentEnterFtraceEvent_Decoder;
+  using Decoder = Ext4ExtRemoveSpaceFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kLblkFieldNumber = 3,
+    kStartFieldNumber = 3,
+    kEndFieldNumber = 4,
+    kDepthFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsLookupExtentEnterFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtRemoveSpaceFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -88384,16 +119656,9 @@ class Ext4EsLookupExtentEnterFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4EsLookupExtentEnterFtraceEvent>;
+      Ext4ExtRemoveSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -88409,16 +119674,9 @@ class Ext4EsLookupExtentEnterFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4EsLookupExtentEnterFtraceEvent>;
+      Ext4ExtRemoveSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -88428,37 +119686,66 @@ class Ext4EsLookupExtentEnterFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Lblk =
+  using FieldMetadata_Start =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4EsLookupExtentEnterFtraceEvent>;
+      Ext4ExtRemoveSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lblk kLblk() { return {}; }
-  void set_lblk(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
+  static constexpr FieldMetadata_Start kStart{};
+  void set_start(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_End =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ExtRemoveSpaceFtraceEvent>;
+
+  static constexpr FieldMetadata_End kEnd{};
+  void set_end(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_End::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_Depth =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4ExtRemoveSpaceFtraceEvent>;
+
+  static constexpr FieldMetadata_Depth kDepth{};
+  void set_depth(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Depth::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class Ext4EsInsertExtentFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4ExtPutInCacheFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  Ext4EsInsertExtentFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4EsInsertExtentFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4EsInsertExtentFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4ExtPutInCacheFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4ExtPutInCacheFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4ExtPutInCacheFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
@@ -88467,24 +119754,21 @@ class Ext4EsInsertExtentFtraceEvent_Decoder : public ::protozero::TypedProtoDeco
   uint32_t lblk() const { return at<3>().as_uint32(); }
   bool has_len() const { return at<4>().valid(); }
   uint32_t len() const { return at<4>().as_uint32(); }
-  bool has_pblk() const { return at<5>().valid(); }
-  uint64_t pblk() const { return at<5>().as_uint64(); }
-  bool has_status() const { return at<6>().valid(); }
-  uint64_t status() const { return at<6>().as_uint64(); }
+  bool has_start() const { return at<5>().valid(); }
+  uint64_t start() const { return at<5>().as_uint64(); }
 };
 
-class Ext4EsInsertExtentFtraceEvent : public ::protozero::Message {
+class Ext4ExtPutInCacheFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4EsInsertExtentFtraceEvent_Decoder;
+  using Decoder = Ext4ExtPutInCacheFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
     kLblkFieldNumber = 3,
     kLenFieldNumber = 4,
-    kPblkFieldNumber = 5,
-    kStatusFieldNumber = 6,
+    kStartFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsInsertExtentFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtPutInCacheFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -88493,16 +119777,9 @@ class Ext4EsInsertExtentFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4EsInsertExtentFtraceEvent>;
+      Ext4ExtPutInCacheFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -88518,16 +119795,9 @@ class Ext4EsInsertExtentFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4EsInsertExtentFtraceEvent>;
+      Ext4ExtPutInCacheFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -88543,16 +119813,9 @@ class Ext4EsInsertExtentFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4EsInsertExtentFtraceEvent>;
+      Ext4ExtPutInCacheFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lblk kLblk() { return {}; }
+  static constexpr FieldMetadata_Lblk kLblk{};
   void set_lblk(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -88568,16 +119831,9 @@ class Ext4EsInsertExtentFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4EsInsertExtentFtraceEvent>;
+      Ext4ExtPutInCacheFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
+  static constexpr FieldMetadata_Len kLen{};
   void set_len(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -88587,49 +119843,17 @@ class Ext4EsInsertExtentFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pblk =
+  using FieldMetadata_Start =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4EsInsertExtentFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pblk kPblk() { return {}; }
-  void set_pblk(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Status =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4EsInsertExtentFtraceEvent>;
+      Ext4ExtPutInCacheFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Status kStatus() { return {}; }
-  void set_status(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId;
+  static constexpr FieldMetadata_Start kStart{};
+  void set_start(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -88638,37 +119862,43 @@ class Ext4EsInsertExtentFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4EsFindDelayedExtentRangeExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4ExtMapBlocksExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
  public:
-  Ext4EsFindDelayedExtentRangeExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4EsFindDelayedExtentRangeExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4EsFindDelayedExtentRangeExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4ExtMapBlocksExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4ExtMapBlocksExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4ExtMapBlocksExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_lblk() const { return at<3>().valid(); }
-  uint32_t lblk() const { return at<3>().as_uint32(); }
-  bool has_len() const { return at<4>().valid(); }
-  uint32_t len() const { return at<4>().as_uint32(); }
-  bool has_pblk() const { return at<5>().valid(); }
-  uint64_t pblk() const { return at<5>().as_uint64(); }
-  bool has_status() const { return at<6>().valid(); }
-  uint64_t status() const { return at<6>().as_uint64(); }
+  bool has_flags() const { return at<3>().valid(); }
+  uint32_t flags() const { return at<3>().as_uint32(); }
+  bool has_pblk() const { return at<4>().valid(); }
+  uint64_t pblk() const { return at<4>().as_uint64(); }
+  bool has_lblk() const { return at<5>().valid(); }
+  uint32_t lblk() const { return at<5>().as_uint32(); }
+  bool has_len() const { return at<6>().valid(); }
+  uint32_t len() const { return at<6>().as_uint32(); }
+  bool has_mflags() const { return at<7>().valid(); }
+  uint32_t mflags() const { return at<7>().as_uint32(); }
+  bool has_ret() const { return at<8>().valid(); }
+  int32_t ret() const { return at<8>().as_int32(); }
 };
 
-class Ext4EsFindDelayedExtentRangeExitFtraceEvent : public ::protozero::Message {
+class Ext4ExtMapBlocksExitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4EsFindDelayedExtentRangeExitFtraceEvent_Decoder;
+  using Decoder = Ext4ExtMapBlocksExitFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kLblkFieldNumber = 3,
-    kLenFieldNumber = 4,
-    kPblkFieldNumber = 5,
-    kStatusFieldNumber = 6,
+    kFlagsFieldNumber = 3,
+    kPblkFieldNumber = 4,
+    kLblkFieldNumber = 5,
+    kLenFieldNumber = 6,
+    kMflagsFieldNumber = 7,
+    kRetFieldNumber = 8,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsFindDelayedExtentRangeExitFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtMapBlocksExitFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -88677,16 +119907,9 @@ class Ext4EsFindDelayedExtentRangeExitFtraceEvent : public ::protozero::Message
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4EsFindDelayedExtentRangeExitFtraceEvent>;
+      Ext4ExtMapBlocksExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -88702,16 +119925,9 @@ class Ext4EsFindDelayedExtentRangeExitFtraceEvent : public ::protozero::Message
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4EsFindDelayedExtentRangeExitFtraceEvent>;
+      Ext4ExtMapBlocksExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -88721,22 +119937,51 @@ class Ext4EsFindDelayedExtentRangeExitFtraceEvent : public ::protozero::Message
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Lblk =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4EsFindDelayedExtentRangeExitFtraceEvent>;
+      Ext4ExtMapBlocksExitFtraceEvent>;
+
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Pblk =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4ExtMapBlocksExitFtraceEvent>;
+
+  static constexpr FieldMetadata_Pblk kPblk{};
+  void set_pblk(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Lblk =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ExtMapBlocksExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lblk kLblk() { return {}; }
+  static constexpr FieldMetadata_Lblk kLblk{};
   void set_lblk(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -88748,20 +119993,13 @@ class Ext4EsFindDelayedExtentRangeExitFtraceEvent : public ::protozero::Message
 
   using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4EsFindDelayedExtentRangeExitFtraceEvent>;
+      Ext4ExtMapBlocksExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
+  static constexpr FieldMetadata_Len kLen{};
   void set_len(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -88771,79 +120009,71 @@ class Ext4EsFindDelayedExtentRangeExitFtraceEvent : public ::protozero::Message
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pblk =
+  using FieldMetadata_Mflags =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4EsFindDelayedExtentRangeExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ExtMapBlocksExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pblk kPblk() { return {}; }
-  void set_pblk(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId;
+  static constexpr FieldMetadata_Mflags kMflags{};
+  void set_mflags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mflags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Status =
+  using FieldMetadata_Ret =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4EsFindDelayedExtentRangeExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4ExtMapBlocksExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Status kStatus() { return {}; }
-  void set_status(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId;
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4EsFindDelayedExtentRangeEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4ExtMapBlocksEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  Ext4EsFindDelayedExtentRangeEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4EsFindDelayedExtentRangeEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4EsFindDelayedExtentRangeEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4ExtMapBlocksEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4ExtMapBlocksEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4ExtMapBlocksEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
   bool has_lblk() const { return at<3>().valid(); }
   uint32_t lblk() const { return at<3>().as_uint32(); }
+  bool has_len() const { return at<4>().valid(); }
+  uint32_t len() const { return at<4>().as_uint32(); }
+  bool has_flags() const { return at<5>().valid(); }
+  uint32_t flags() const { return at<5>().as_uint32(); }
 };
 
-class Ext4EsFindDelayedExtentRangeEnterFtraceEvent : public ::protozero::Message {
+class Ext4ExtMapBlocksEnterFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4EsFindDelayedExtentRangeEnterFtraceEvent_Decoder;
+  using Decoder = Ext4ExtMapBlocksEnterFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
     kLblkFieldNumber = 3,
+    kLenFieldNumber = 4,
+    kFlagsFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsFindDelayedExtentRangeEnterFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtMapBlocksEnterFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -88852,16 +120082,9 @@ class Ext4EsFindDelayedExtentRangeEnterFtraceEvent : public ::protozero::Message
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4EsFindDelayedExtentRangeEnterFtraceEvent>;
+      Ext4ExtMapBlocksEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -88877,16 +120100,9 @@ class Ext4EsFindDelayedExtentRangeEnterFtraceEvent : public ::protozero::Message
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4EsFindDelayedExtentRangeEnterFtraceEvent>;
+      Ext4ExtMapBlocksEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -88902,16 +120118,9 @@ class Ext4EsFindDelayedExtentRangeEnterFtraceEvent : public ::protozero::Message
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4EsFindDelayedExtentRangeEnterFtraceEvent>;
+      Ext4ExtMapBlocksEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lblk kLblk() { return {}; }
+  static constexpr FieldMetadata_Lblk kLblk{};
   void set_lblk(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -88920,39 +120129,69 @@ class Ext4EsFindDelayedExtentRangeEnterFtraceEvent : public ::protozero::Message
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_Len =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ExtMapBlocksEnterFtraceEvent>;
+
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Flags =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ExtMapBlocksEnterFtraceEvent>;
+
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class Ext4EsCacheExtentFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4ExtLoadExtentFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  Ext4EsCacheExtentFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4EsCacheExtentFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4EsCacheExtentFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4ExtLoadExtentFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4ExtLoadExtentFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4ExtLoadExtentFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_lblk() const { return at<3>().valid(); }
-  uint32_t lblk() const { return at<3>().as_uint32(); }
-  bool has_len() const { return at<4>().valid(); }
-  uint32_t len() const { return at<4>().as_uint32(); }
-  bool has_pblk() const { return at<5>().valid(); }
-  uint64_t pblk() const { return at<5>().as_uint64(); }
-  bool has_status() const { return at<6>().valid(); }
-  uint32_t status() const { return at<6>().as_uint32(); }
+  bool has_pblk() const { return at<3>().valid(); }
+  uint64_t pblk() const { return at<3>().as_uint64(); }
+  bool has_lblk() const { return at<4>().valid(); }
+  uint32_t lblk() const { return at<4>().as_uint32(); }
 };
 
-class Ext4EsCacheExtentFtraceEvent : public ::protozero::Message {
+class Ext4ExtLoadExtentFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4EsCacheExtentFtraceEvent_Decoder;
+  using Decoder = Ext4ExtLoadExtentFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kLblkFieldNumber = 3,
-    kLenFieldNumber = 4,
-    kPblkFieldNumber = 5,
-    kStatusFieldNumber = 6,
+    kPblkFieldNumber = 3,
+    kLblkFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsCacheExtentFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtLoadExtentFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -88961,16 +120200,9 @@ class Ext4EsCacheExtentFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4EsCacheExtentFtraceEvent>;
+      Ext4ExtLoadExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -88986,16 +120218,9 @@ class Ext4EsCacheExtentFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4EsCacheExtentFtraceEvent>;
+      Ext4ExtLoadExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -89005,72 +120230,15 @@ class Ext4EsCacheExtentFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Lblk =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4EsCacheExtentFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lblk kLblk() { return {}; }
-  void set_lblk(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Len =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4EsCacheExtentFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
   using FieldMetadata_Pblk =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4EsCacheExtentFtraceEvent>;
+      Ext4ExtLoadExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pblk kPblk() { return {}; }
+  static constexpr FieldMetadata_Pblk kPblk{};
   void set_pblk(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -89080,24 +120248,17 @@ class Ext4EsCacheExtentFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Status =
+  using FieldMetadata_Lblk =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4EsCacheExtentFtraceEvent>;
+      Ext4ExtLoadExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Status kStatus() { return {}; }
-  void set_status(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId;
+  static constexpr FieldMetadata_Lblk kLblk{};
+  void set_lblk(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -89106,28 +120267,31 @@ class Ext4EsCacheExtentFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4DropInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4ExtInCacheFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  Ext4DropInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4DropInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4DropInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4ExtInCacheFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4ExtInCacheFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4ExtInCacheFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_drop() const { return at<3>().valid(); }
-  int32_t drop() const { return at<3>().as_int32(); }
+  bool has_lblk() const { return at<3>().valid(); }
+  uint32_t lblk() const { return at<3>().as_uint32(); }
+  bool has_ret() const { return at<4>().valid(); }
+  int32_t ret() const { return at<4>().as_int32(); }
 };
 
-class Ext4DropInodeFtraceEvent : public ::protozero::Message {
+class Ext4ExtInCacheFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4DropInodeFtraceEvent_Decoder;
+  using Decoder = Ext4ExtInCacheFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kDropFieldNumber = 3,
+    kLblkFieldNumber = 3,
+    kRetFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DropInodeFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtInCacheFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -89136,16 +120300,9 @@ class Ext4DropInodeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DropInodeFtraceEvent>;
+      Ext4ExtInCacheFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -89161,16 +120318,9 @@ class Ext4DropInodeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DropInodeFtraceEvent>;
+      Ext4ExtInCacheFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -89180,24 +120330,35 @@ class Ext4DropInodeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Drop =
+  using FieldMetadata_Lblk =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ExtInCacheFtraceEvent>;
+
+  static constexpr FieldMetadata_Lblk kLblk{};
+  void set_lblk(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ret =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4DropInodeFtraceEvent>;
+      Ext4ExtInCacheFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Drop kDrop() { return {}; }
-  void set_drop(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Drop::kFieldId;
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -89206,31 +120367,43 @@ class Ext4DropInodeFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4DiscardPreallocationsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4ExtHandleUnwrittenExtentsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
  public:
-  Ext4DiscardPreallocationsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4DiscardPreallocationsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4DiscardPreallocationsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4ExtHandleUnwrittenExtentsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4ExtHandleUnwrittenExtentsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4ExtHandleUnwrittenExtentsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_len() const { return at<3>().valid(); }
-  uint32_t len() const { return at<3>().as_uint32(); }
-  bool has_needed() const { return at<4>().valid(); }
-  uint32_t needed() const { return at<4>().as_uint32(); }
+  bool has_flags() const { return at<3>().valid(); }
+  int32_t flags() const { return at<3>().as_int32(); }
+  bool has_lblk() const { return at<4>().valid(); }
+  uint32_t lblk() const { return at<4>().as_uint32(); }
+  bool has_pblk() const { return at<5>().valid(); }
+  uint64_t pblk() const { return at<5>().as_uint64(); }
+  bool has_len() const { return at<6>().valid(); }
+  uint32_t len() const { return at<6>().as_uint32(); }
+  bool has_allocated() const { return at<7>().valid(); }
+  uint32_t allocated() const { return at<7>().as_uint32(); }
+  bool has_newblk() const { return at<8>().valid(); }
+  uint64_t newblk() const { return at<8>().as_uint64(); }
 };
 
-class Ext4DiscardPreallocationsFtraceEvent : public ::protozero::Message {
+class Ext4ExtHandleUnwrittenExtentsFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4DiscardPreallocationsFtraceEvent_Decoder;
+  using Decoder = Ext4ExtHandleUnwrittenExtentsFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kLenFieldNumber = 3,
-    kNeededFieldNumber = 4,
+    kFlagsFieldNumber = 3,
+    kLblkFieldNumber = 4,
+    kPblkFieldNumber = 5,
+    kLenFieldNumber = 6,
+    kAllocatedFieldNumber = 7,
+    kNewblkFieldNumber = 8,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DiscardPreallocationsFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtHandleUnwrittenExtentsFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -89239,16 +120412,9 @@ class Ext4DiscardPreallocationsFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DiscardPreallocationsFtraceEvent>;
+      Ext4ExtHandleUnwrittenExtentsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -89264,16 +120430,9 @@ class Ext4DiscardPreallocationsFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DiscardPreallocationsFtraceEvent>;
+      Ext4ExtHandleUnwrittenExtentsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -89283,99 +120442,53 @@ class Ext4DiscardPreallocationsFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4DiscardPreallocationsFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4ExtHandleUnwrittenExtentsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Needed =
+  using FieldMetadata_Lblk =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4DiscardPreallocationsFtraceEvent>;
+      Ext4ExtHandleUnwrittenExtentsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Needed kNeeded() { return {}; }
-  void set_needed(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Needed::kFieldId;
+  static constexpr FieldMetadata_Lblk kLblk{};
+  void set_lblk(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class Ext4DiscardBlocksFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Ext4DiscardBlocksFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4DiscardBlocksFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4DiscardBlocksFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_blk() const { return at<2>().valid(); }
-  uint64_t blk() const { return at<2>().as_uint64(); }
-  bool has_count() const { return at<3>().valid(); }
-  uint64_t count() const { return at<3>().as_uint64(); }
-};
-
-class Ext4DiscardBlocksFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = Ext4DiscardBlocksFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kBlkFieldNumber = 2,
-    kCountFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DiscardBlocksFtraceEvent"; }
-
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_Pblk =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DiscardBlocksFtraceEvent>;
+      Ext4ExtHandleUnwrittenExtentsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_Pblk kPblk{};
+  void set_pblk(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -89383,49 +120496,53 @@ class Ext4DiscardBlocksFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Blk =
+  using FieldMetadata_Len =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ExtHandleUnwrittenExtentsFtraceEvent>;
+
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Allocated =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4DiscardBlocksFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ExtHandleUnwrittenExtentsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Blk kBlk() { return {}; }
-  void set_blk(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Blk::kFieldId;
+  static constexpr FieldMetadata_Allocated kAllocated{};
+  void set_allocated(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Allocated::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Count =
+  using FieldMetadata_Newblk =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DiscardBlocksFtraceEvent>;
+      Ext4ExtHandleUnwrittenExtentsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Count kCount() { return {}; }
-  void set_count(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId;
+  static constexpr FieldMetadata_Newblk kNewblk{};
+  void set_newblk(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Newblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -89434,37 +120551,49 @@ class Ext4DiscardBlocksFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4DirectIOExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4ExtConvertToInitializedFastpathFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10> {
  public:
-  Ext4DirectIOExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4DirectIOExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4DirectIOExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4ExtConvertToInitializedFastpathFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4ExtConvertToInitializedFastpathFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4ExtConvertToInitializedFastpathFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_pos() const { return at<3>().valid(); }
-  int64_t pos() const { return at<3>().as_int64(); }
-  bool has_len() const { return at<4>().valid(); }
-  uint64_t len() const { return at<4>().as_uint64(); }
-  bool has_rw() const { return at<5>().valid(); }
-  int32_t rw() const { return at<5>().as_int32(); }
-  bool has_ret() const { return at<6>().valid(); }
-  int32_t ret() const { return at<6>().as_int32(); }
+  bool has_m_lblk() const { return at<3>().valid(); }
+  uint32_t m_lblk() const { return at<3>().as_uint32(); }
+  bool has_m_len() const { return at<4>().valid(); }
+  uint32_t m_len() const { return at<4>().as_uint32(); }
+  bool has_u_lblk() const { return at<5>().valid(); }
+  uint32_t u_lblk() const { return at<5>().as_uint32(); }
+  bool has_u_len() const { return at<6>().valid(); }
+  uint32_t u_len() const { return at<6>().as_uint32(); }
+  bool has_u_pblk() const { return at<7>().valid(); }
+  uint64_t u_pblk() const { return at<7>().as_uint64(); }
+  bool has_i_lblk() const { return at<8>().valid(); }
+  uint32_t i_lblk() const { return at<8>().as_uint32(); }
+  bool has_i_len() const { return at<9>().valid(); }
+  uint32_t i_len() const { return at<9>().as_uint32(); }
+  bool has_i_pblk() const { return at<10>().valid(); }
+  uint64_t i_pblk() const { return at<10>().as_uint64(); }
 };
 
-class Ext4DirectIOExitFtraceEvent : public ::protozero::Message {
+class Ext4ExtConvertToInitializedFastpathFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4DirectIOExitFtraceEvent_Decoder;
+  using Decoder = Ext4ExtConvertToInitializedFastpathFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kPosFieldNumber = 3,
-    kLenFieldNumber = 4,
-    kRwFieldNumber = 5,
-    kRetFieldNumber = 6,
+    kMLblkFieldNumber = 3,
+    kMLenFieldNumber = 4,
+    kULblkFieldNumber = 5,
+    kULenFieldNumber = 6,
+    kUPblkFieldNumber = 7,
+    kILblkFieldNumber = 8,
+    kILenFieldNumber = 9,
+    kIPblkFieldNumber = 10,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DirectIOExitFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtConvertToInitializedFastpathFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -89473,16 +120602,9 @@ class Ext4DirectIOExitFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DirectIOExitFtraceEvent>;
+      Ext4ExtConvertToInitializedFastpathFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -89498,16 +120620,9 @@ class Ext4DirectIOExitFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DirectIOExitFtraceEvent>;
+      Ext4ExtConvertToInitializedFastpathFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -89517,155 +120632,89 @@ class Ext4DirectIOExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pos =
+  using FieldMetadata_MLblk =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4DirectIOExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ExtConvertToInitializedFastpathFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pos kPos() { return {}; }
-  void set_pos(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId;
+  static constexpr FieldMetadata_MLblk kMLblk{};
+  void set_m_lblk(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MLblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_MLen =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4DirectIOExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ExtConvertToInitializedFastpathFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_MLen kMLen{};
+  void set_m_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MLen::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Rw =
+  using FieldMetadata_ULblk =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4DirectIOExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ExtConvertToInitializedFastpathFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Rw kRw() { return {}; }
-  void set_rw(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Rw::kFieldId;
+  static constexpr FieldMetadata_ULblk kULblk{};
+  void set_u_lblk(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ULblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ret =
+  using FieldMetadata_ULen =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4DirectIOExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ExtConvertToInitializedFastpathFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+  static constexpr FieldMetadata_ULen kULen{};
+  void set_u_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ULen::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class Ext4DirectIOEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Ext4DirectIOEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4DirectIOEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4DirectIOEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_pos() const { return at<3>().valid(); }
-  int64_t pos() const { return at<3>().as_int64(); }
-  bool has_len() const { return at<4>().valid(); }
-  uint64_t len() const { return at<4>().as_uint64(); }
-  bool has_rw() const { return at<5>().valid(); }
-  int32_t rw() const { return at<5>().as_int32(); }
-};
-
-class Ext4DirectIOEnterFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = Ext4DirectIOEnterFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kPosFieldNumber = 3,
-    kLenFieldNumber = 4,
-    kRwFieldNumber = 5,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DirectIOEnterFtraceEvent"; }
 
-
-  using FieldMetadata_Dev =
+  using FieldMetadata_UPblk =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DirectIOEnterFtraceEvent>;
+      Ext4ExtConvertToInitializedFastpathFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_UPblk kUPblk{};
+  void set_u_pblk(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_UPblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -89673,135 +120722,95 @@ class Ext4DirectIOEnterFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_ILblk =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4DirectIOEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ExtConvertToInitializedFastpathFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_ILblk kILblk{};
+  void set_i_lblk(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ILblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pos =
+  using FieldMetadata_ILen =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4DirectIOEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ExtConvertToInitializedFastpathFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pos kPos() { return {}; }
-  void set_pos(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId;
+  static constexpr FieldMetadata_ILen kILen{};
+  void set_i_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ILen::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_IPblk =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DirectIOEnterFtraceEvent>;
+      Ext4ExtConvertToInitializedFastpathFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_IPblk kIPblk{};
+  void set_i_pblk(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IPblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-
-  using FieldMetadata_Rw =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4DirectIOEnterFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Rw kRw() { return {}; }
-  void set_rw(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Rw::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
 };
 
-class Ext4DaWritePagesExtentFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4ExtConvertToInitializedEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
-  Ext4DaWritePagesExtentFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4DaWritePagesExtentFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4DaWritePagesExtentFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4ExtConvertToInitializedEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4ExtConvertToInitializedEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4ExtConvertToInitializedEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_lblk() const { return at<3>().valid(); }
-  uint64_t lblk() const { return at<3>().as_uint64(); }
-  bool has_len() const { return at<4>().valid(); }
-  uint32_t len() const { return at<4>().as_uint32(); }
-  bool has_flags() const { return at<5>().valid(); }
-  uint32_t flags() const { return at<5>().as_uint32(); }
+  bool has_m_lblk() const { return at<3>().valid(); }
+  uint32_t m_lblk() const { return at<3>().as_uint32(); }
+  bool has_m_len() const { return at<4>().valid(); }
+  uint32_t m_len() const { return at<4>().as_uint32(); }
+  bool has_u_lblk() const { return at<5>().valid(); }
+  uint32_t u_lblk() const { return at<5>().as_uint32(); }
+  bool has_u_len() const { return at<6>().valid(); }
+  uint32_t u_len() const { return at<6>().as_uint32(); }
+  bool has_u_pblk() const { return at<7>().valid(); }
+  uint64_t u_pblk() const { return at<7>().as_uint64(); }
 };
 
-class Ext4DaWritePagesExtentFtraceEvent : public ::protozero::Message {
+class Ext4ExtConvertToInitializedEnterFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4DaWritePagesExtentFtraceEvent_Decoder;
+  using Decoder = Ext4ExtConvertToInitializedEnterFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kLblkFieldNumber = 3,
-    kLenFieldNumber = 4,
-    kFlagsFieldNumber = 5,
+    kMLblkFieldNumber = 3,
+    kMLenFieldNumber = 4,
+    kULblkFieldNumber = 5,
+    kULenFieldNumber = 6,
+    kUPblkFieldNumber = 7,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DaWritePagesExtentFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtConvertToInitializedEnterFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -89810,16 +120819,9 @@ class Ext4DaWritePagesExtentFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DaWritePagesExtentFtraceEvent>;
+      Ext4ExtConvertToInitializedEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -89835,16 +120837,9 @@ class Ext4DaWritePagesExtentFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DaWritePagesExtentFtraceEvent>;
+      Ext4ExtConvertToInitializedEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -89854,49 +120849,35 @@ class Ext4DaWritePagesExtentFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Lblk =
+  using FieldMetadata_MLblk =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4DaWritePagesExtentFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ExtConvertToInitializedEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lblk kLblk() { return {}; }
-  void set_lblk(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
+  static constexpr FieldMetadata_MLblk kMLblk{};
+  void set_m_lblk(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MLblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_MLen =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4DaWritePagesExtentFtraceEvent>;
+      Ext4ExtConvertToInitializedEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_MLen kMLen{};
+  void set_m_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MLen::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -89904,75 +120885,83 @@ class Ext4DaWritePagesExtentFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_ULblk =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4DaWritePagesExtentFtraceEvent>;
+      Ext4ExtConvertToInitializedEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_ULblk kULblk{};
+  void set_u_lblk(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ULblk::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ULen =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4ExtConvertToInitializedEnterFtraceEvent>;
+
+  static constexpr FieldMetadata_ULen kULen{};
+  void set_u_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ULen::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_UPblk =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4ExtConvertToInitializedEnterFtraceEvent>;
+
+  static constexpr FieldMetadata_UPblk kUPblk{};
+  void set_u_pblk(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_UPblk::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class Ext4DaWritePagesFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4EvictInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  Ext4DaWritePagesFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4DaWritePagesFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4DaWritePagesFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4EvictInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4EvictInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4EvictInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_first_page() const { return at<3>().valid(); }
-  uint64_t first_page() const { return at<3>().as_uint64(); }
-  bool has_nr_to_write() const { return at<4>().valid(); }
-  int64_t nr_to_write() const { return at<4>().as_int64(); }
-  bool has_sync_mode() const { return at<5>().valid(); }
-  int32_t sync_mode() const { return at<5>().as_int32(); }
-  bool has_b_blocknr() const { return at<6>().valid(); }
-  uint64_t b_blocknr() const { return at<6>().as_uint64(); }
-  bool has_b_size() const { return at<7>().valid(); }
-  uint32_t b_size() const { return at<7>().as_uint32(); }
-  bool has_b_state() const { return at<8>().valid(); }
-  uint32_t b_state() const { return at<8>().as_uint32(); }
-  bool has_io_done() const { return at<9>().valid(); }
-  int32_t io_done() const { return at<9>().as_int32(); }
-  bool has_pages_written() const { return at<10>().valid(); }
-  int32_t pages_written() const { return at<10>().as_int32(); }
+  bool has_nlink() const { return at<3>().valid(); }
+  int32_t nlink() const { return at<3>().as_int32(); }
 };
 
-class Ext4DaWritePagesFtraceEvent : public ::protozero::Message {
+class Ext4EvictInodeFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4DaWritePagesFtraceEvent_Decoder;
+  using Decoder = Ext4EvictInodeFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kFirstPageFieldNumber = 3,
-    kNrToWriteFieldNumber = 4,
-    kSyncModeFieldNumber = 5,
-    kBBlocknrFieldNumber = 6,
-    kBSizeFieldNumber = 7,
-    kBStateFieldNumber = 8,
-    kIoDoneFieldNumber = 9,
-    kPagesWrittenFieldNumber = 10,
+    kNlinkFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DaWritePagesFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EvictInodeFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -89981,16 +120970,9 @@ class Ext4DaWritePagesFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DaWritePagesFtraceEvent>;
+      Ext4EvictInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -90006,16 +120988,9 @@ class Ext4DaWritePagesFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DaWritePagesFtraceEvent>;
+      Ext4EvictInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -90025,24 +121000,60 @@ class Ext4DaWritePagesFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FirstPage =
+  using FieldMetadata_Nlink =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4EvictInodeFtraceEvent>;
+
+  static constexpr FieldMetadata_Nlink kNlink{};
+  void set_nlink(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Nlink::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class Ext4EsShrinkScanExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  Ext4EsShrinkScanExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4EsShrinkScanExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4EsShrinkScanExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_nr_shrunk() const { return at<2>().valid(); }
+  int32_t nr_shrunk() const { return at<2>().as_int32(); }
+  bool has_cache_cnt() const { return at<3>().valid(); }
+  int32_t cache_cnt() const { return at<3>().as_int32(); }
+};
+
+class Ext4EsShrinkScanExitFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4EsShrinkScanExitFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kNrShrunkFieldNumber = 2,
+    kCacheCntFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsShrinkScanExitFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DaWritePagesFtraceEvent>;
+      Ext4EsShrinkScanExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FirstPage kFirstPage() { return {}; }
-  void set_first_page(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FirstPage::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -90050,74 +121061,78 @@ class Ext4DaWritePagesFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NrToWrite =
+  using FieldMetadata_NrShrunk =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4DaWritePagesFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4EsShrinkScanExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrToWrite kNrToWrite() { return {}; }
-  void set_nr_to_write(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NrToWrite::kFieldId;
+  static constexpr FieldMetadata_NrShrunk kNrShrunk{};
+  void set_nr_shrunk(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NrShrunk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SyncMode =
+  using FieldMetadata_CacheCnt =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4DaWritePagesFtraceEvent>;
+      Ext4EsShrinkScanExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SyncMode kSyncMode() { return {}; }
-  void set_sync_mode(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SyncMode::kFieldId;
+  static constexpr FieldMetadata_CacheCnt kCacheCnt{};
+  void set_cache_cnt(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CacheCnt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_BBlocknr =
+class Ext4EsShrinkScanEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  Ext4EsShrinkScanEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4EsShrinkScanEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4EsShrinkScanEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_nr_to_scan() const { return at<2>().valid(); }
+  int32_t nr_to_scan() const { return at<2>().as_int32(); }
+  bool has_cache_cnt() const { return at<3>().valid(); }
+  int32_t cache_cnt() const { return at<3>().as_int32(); }
+};
+
+class Ext4EsShrinkScanEnterFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4EsShrinkScanEnterFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kNrToScanFieldNumber = 2,
+    kCacheCntFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsShrinkScanEnterFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DaWritePagesFtraceEvent>;
+      Ext4EsShrinkScanEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BBlocknr kBBlocknr() { return {}; }
-  void set_b_blocknr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BBlocknr::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -90125,74 +121140,96 @@ class Ext4DaWritePagesFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BSize =
+  using FieldMetadata_NrToScan =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4DaWritePagesFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4EsShrinkScanEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BSize kBSize() { return {}; }
-  void set_b_size(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BSize::kFieldId;
+  static constexpr FieldMetadata_NrToScan kNrToScan{};
+  void set_nr_to_scan(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NrToScan::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BState =
+  using FieldMetadata_CacheCnt =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4DaWritePagesFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4EsShrinkScanEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BState kBState() { return {}; }
-  void set_b_state(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BState::kFieldId;
+  static constexpr FieldMetadata_CacheCnt kCacheCnt{};
+  void set_cache_cnt(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CacheCnt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_IoDone =
+class Ext4EsShrinkCountFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  Ext4EsShrinkCountFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4EsShrinkCountFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4EsShrinkCountFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_nr_to_scan() const { return at<2>().valid(); }
+  int32_t nr_to_scan() const { return at<2>().as_int32(); }
+  bool has_cache_cnt() const { return at<3>().valid(); }
+  int32_t cache_cnt() const { return at<3>().as_int32(); }
+};
+
+class Ext4EsShrinkCountFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4EsShrinkCountFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kNrToScanFieldNumber = 2,
+    kCacheCntFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsShrinkCountFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4EsShrinkCountFtraceEvent>;
+
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NrToScan =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4DaWritePagesFtraceEvent>;
+      Ext4EsShrinkCountFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IoDone kIoDone() { return {}; }
-  void set_io_done(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IoDone::kFieldId;
+  static constexpr FieldMetadata_NrToScan kNrToScan{};
+  void set_nr_to_scan(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NrToScan::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -90200,24 +121237,17 @@ class Ext4DaWritePagesFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PagesWritten =
+  using FieldMetadata_CacheCnt =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4DaWritePagesFtraceEvent>;
+      Ext4EsShrinkCountFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PagesWritten kPagesWritten() { return {}; }
-  void set_pages_written(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PagesWritten::kFieldId;
+  static constexpr FieldMetadata_CacheCnt kCacheCnt{};
+  void set_cache_cnt(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CacheCnt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -90226,46 +121256,34 @@ class Ext4DaWritePagesFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4DaUpdateReserveSpaceFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4EsShrinkFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  Ext4DaUpdateReserveSpaceFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4DaUpdateReserveSpaceFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4DaUpdateReserveSpaceFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4EsShrinkFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4EsShrinkFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4EsShrinkFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_i_blocks() const { return at<3>().valid(); }
-  uint64_t i_blocks() const { return at<3>().as_uint64(); }
-  bool has_used_blocks() const { return at<4>().valid(); }
-  int32_t used_blocks() const { return at<4>().as_int32(); }
-  bool has_reserved_data_blocks() const { return at<5>().valid(); }
-  int32_t reserved_data_blocks() const { return at<5>().as_int32(); }
-  bool has_reserved_meta_blocks() const { return at<6>().valid(); }
-  int32_t reserved_meta_blocks() const { return at<6>().as_int32(); }
-  bool has_allocated_meta_blocks() const { return at<7>().valid(); }
-  int32_t allocated_meta_blocks() const { return at<7>().as_int32(); }
-  bool has_quota_claim() const { return at<8>().valid(); }
-  int32_t quota_claim() const { return at<8>().as_int32(); }
-  bool has_mode() const { return at<9>().valid(); }
-  uint32_t mode() const { return at<9>().as_uint32(); }
+  bool has_nr_shrunk() const { return at<2>().valid(); }
+  int32_t nr_shrunk() const { return at<2>().as_int32(); }
+  bool has_scan_time() const { return at<3>().valid(); }
+  uint64_t scan_time() const { return at<3>().as_uint64(); }
+  bool has_nr_skipped() const { return at<4>().valid(); }
+  int32_t nr_skipped() const { return at<4>().as_int32(); }
+  bool has_retried() const { return at<5>().valid(); }
+  int32_t retried() const { return at<5>().as_int32(); }
 };
 
-class Ext4DaUpdateReserveSpaceFtraceEvent : public ::protozero::Message {
+class Ext4EsShrinkFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4DaUpdateReserveSpaceFtraceEvent_Decoder;
+  using Decoder = Ext4EsShrinkFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kIBlocksFieldNumber = 3,
-    kUsedBlocksFieldNumber = 4,
-    kReservedDataBlocksFieldNumber = 5,
-    kReservedMetaBlocksFieldNumber = 6,
-    kAllocatedMetaBlocksFieldNumber = 7,
-    kQuotaClaimFieldNumber = 8,
-    kModeFieldNumber = 9,
+    kNrShrunkFieldNumber = 2,
+    kScanTimeFieldNumber = 3,
+    kNrSkippedFieldNumber = 4,
+    kRetriedFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DaUpdateReserveSpaceFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsShrinkFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -90274,16 +121292,9 @@ class Ext4DaUpdateReserveSpaceFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DaUpdateReserveSpaceFtraceEvent>;
+      Ext4EsShrinkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -90293,49 +121304,35 @@ class Ext4DaUpdateReserveSpaceFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_NrShrunk =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4DaUpdateReserveSpaceFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4EsShrinkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_NrShrunk kNrShrunk{};
+  void set_nr_shrunk(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NrShrunk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IBlocks =
+  using FieldMetadata_ScanTime =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DaUpdateReserveSpaceFtraceEvent>;
+      Ext4EsShrinkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IBlocks kIBlocks() { return {}; }
-  void set_i_blocks(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IBlocks::kFieldId;
+  static constexpr FieldMetadata_ScanTime kScanTime{};
+  void set_scan_time(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ScanTime::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -90343,24 +121340,17 @@ class Ext4DaUpdateReserveSpaceFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_UsedBlocks =
+  using FieldMetadata_NrSkipped =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4DaUpdateReserveSpaceFtraceEvent>;
+      Ext4EsShrinkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UsedBlocks kUsedBlocks() { return {}; }
-  void set_used_blocks(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_UsedBlocks::kFieldId;
+  static constexpr FieldMetadata_NrSkipped kNrSkipped{};
+  void set_nr_skipped(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NrSkipped::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -90368,166 +121358,159 @@ class Ext4DaUpdateReserveSpaceFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ReservedDataBlocks =
+  using FieldMetadata_Retried =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4DaUpdateReserveSpaceFtraceEvent>;
+      Ext4EsShrinkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReservedDataBlocks kReservedDataBlocks() { return {}; }
-  void set_reserved_data_blocks(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReservedDataBlocks::kFieldId;
+  static constexpr FieldMetadata_Retried kRetried{};
+  void set_retried(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Retried::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_ReservedMetaBlocks =
+class Ext4EsRemoveExtentFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  Ext4EsRemoveExtentFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4EsRemoveExtentFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4EsRemoveExtentFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_lblk() const { return at<3>().valid(); }
+  int64_t lblk() const { return at<3>().as_int64(); }
+  bool has_len() const { return at<4>().valid(); }
+  int64_t len() const { return at<4>().as_int64(); }
+};
+
+class Ext4EsRemoveExtentFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4EsRemoveExtentFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kLblkFieldNumber = 3,
+    kLenFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsRemoveExtentFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4DaUpdateReserveSpaceFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4EsRemoveExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReservedMetaBlocks kReservedMetaBlocks() { return {}; }
-  void set_reserved_meta_blocks(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReservedMetaBlocks::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_AllocatedMetaBlocks =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4DaUpdateReserveSpaceFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4EsRemoveExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AllocatedMetaBlocks kAllocatedMetaBlocks() { return {}; }
-  void set_allocated_meta_blocks(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AllocatedMetaBlocks::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_QuotaClaim =
+  using FieldMetadata_Lblk =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4DaUpdateReserveSpaceFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4EsRemoveExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_QuotaClaim kQuotaClaim() { return {}; }
-  void set_quota_claim(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_QuotaClaim::kFieldId;
+  static constexpr FieldMetadata_Lblk kLblk{};
+  void set_lblk(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Mode =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4DaUpdateReserveSpaceFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4EsRemoveExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mode kMode() { return {}; }
-  void set_mode(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4DaReserveSpaceFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4EsLookupExtentExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
-  Ext4DaReserveSpaceFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4DaReserveSpaceFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4DaReserveSpaceFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4EsLookupExtentExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4EsLookupExtentExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4EsLookupExtentExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_i_blocks() const { return at<3>().valid(); }
-  uint64_t i_blocks() const { return at<3>().as_uint64(); }
-  bool has_reserved_data_blocks() const { return at<4>().valid(); }
-  int32_t reserved_data_blocks() const { return at<4>().as_int32(); }
-  bool has_reserved_meta_blocks() const { return at<5>().valid(); }
-  int32_t reserved_meta_blocks() const { return at<5>().as_int32(); }
-  bool has_mode() const { return at<6>().valid(); }
-  uint32_t mode() const { return at<6>().as_uint32(); }
-  bool has_md_needed() const { return at<7>().valid(); }
-  int32_t md_needed() const { return at<7>().as_int32(); }
+  bool has_lblk() const { return at<3>().valid(); }
+  uint32_t lblk() const { return at<3>().as_uint32(); }
+  bool has_len() const { return at<4>().valid(); }
+  uint32_t len() const { return at<4>().as_uint32(); }
+  bool has_pblk() const { return at<5>().valid(); }
+  uint64_t pblk() const { return at<5>().as_uint64(); }
+  bool has_status() const { return at<6>().valid(); }
+  uint64_t status() const { return at<6>().as_uint64(); }
+  bool has_found() const { return at<7>().valid(); }
+  int32_t found() const { return at<7>().as_int32(); }
 };
 
-class Ext4DaReserveSpaceFtraceEvent : public ::protozero::Message {
+class Ext4EsLookupExtentExitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4DaReserveSpaceFtraceEvent_Decoder;
+  using Decoder = Ext4EsLookupExtentExitFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kIBlocksFieldNumber = 3,
-    kReservedDataBlocksFieldNumber = 4,
-    kReservedMetaBlocksFieldNumber = 5,
-    kModeFieldNumber = 6,
-    kMdNeededFieldNumber = 7,
+    kLblkFieldNumber = 3,
+    kLenFieldNumber = 4,
+    kPblkFieldNumber = 5,
+    kStatusFieldNumber = 6,
+    kFoundFieldNumber = 7,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DaReserveSpaceFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsLookupExtentExitFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -90536,16 +121519,9 @@ class Ext4DaReserveSpaceFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DaReserveSpaceFtraceEvent>;
+      Ext4EsLookupExtentExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -90561,16 +121537,9 @@ class Ext4DaReserveSpaceFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DaReserveSpaceFtraceEvent>;
+      Ext4EsLookupExtentExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -90580,124 +121549,89 @@ class Ext4DaReserveSpaceFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IBlocks =
+  using FieldMetadata_Lblk =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4DaReserveSpaceFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4EsLookupExtentExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IBlocks kIBlocks() { return {}; }
-  void set_i_blocks(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IBlocks::kFieldId;
+  static constexpr FieldMetadata_Lblk kLblk{};
+  void set_lblk(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ReservedDataBlocks =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4DaReserveSpaceFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4EsLookupExtentExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReservedDataBlocks kReservedDataBlocks() { return {}; }
-  void set_reserved_data_blocks(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReservedDataBlocks::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ReservedMetaBlocks =
+  using FieldMetadata_Pblk =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4DaReserveSpaceFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4EsLookupExtentExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReservedMetaBlocks kReservedMetaBlocks() { return {}; }
-  void set_reserved_meta_blocks(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReservedMetaBlocks::kFieldId;
+  static constexpr FieldMetadata_Pblk kPblk{};
+  void set_pblk(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Mode =
+  using FieldMetadata_Status =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4DaReserveSpaceFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4EsLookupExtentExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mode kMode() { return {}; }
-  void set_mode(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+  static constexpr FieldMetadata_Status kStatus{};
+  void set_status(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MdNeeded =
+  using FieldMetadata_Found =
     ::protozero::proto_utils::FieldMetadata<
       7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4DaReserveSpaceFtraceEvent>;
+      Ext4EsLookupExtentExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MdNeeded kMdNeeded() { return {}; }
-  void set_md_needed(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MdNeeded::kFieldId;
+  static constexpr FieldMetadata_Found kFound{};
+  void set_found(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Found::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -90706,43 +121640,28 @@ class Ext4DaReserveSpaceFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4DaReleaseSpaceFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4EsLookupExtentEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  Ext4DaReleaseSpaceFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4DaReleaseSpaceFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4DaReleaseSpaceFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4EsLookupExtentEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4EsLookupExtentEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4EsLookupExtentEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_i_blocks() const { return at<3>().valid(); }
-  uint64_t i_blocks() const { return at<3>().as_uint64(); }
-  bool has_freed_blocks() const { return at<4>().valid(); }
-  int32_t freed_blocks() const { return at<4>().as_int32(); }
-  bool has_reserved_data_blocks() const { return at<5>().valid(); }
-  int32_t reserved_data_blocks() const { return at<5>().as_int32(); }
-  bool has_reserved_meta_blocks() const { return at<6>().valid(); }
-  int32_t reserved_meta_blocks() const { return at<6>().as_int32(); }
-  bool has_allocated_meta_blocks() const { return at<7>().valid(); }
-  int32_t allocated_meta_blocks() const { return at<7>().as_int32(); }
-  bool has_mode() const { return at<8>().valid(); }
-  uint32_t mode() const { return at<8>().as_uint32(); }
+  bool has_lblk() const { return at<3>().valid(); }
+  uint32_t lblk() const { return at<3>().as_uint32(); }
 };
 
-class Ext4DaReleaseSpaceFtraceEvent : public ::protozero::Message {
+class Ext4EsLookupExtentEnterFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4DaReleaseSpaceFtraceEvent_Decoder;
+  using Decoder = Ext4EsLookupExtentEnterFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kIBlocksFieldNumber = 3,
-    kFreedBlocksFieldNumber = 4,
-    kReservedDataBlocksFieldNumber = 5,
-    kReservedMetaBlocksFieldNumber = 6,
-    kAllocatedMetaBlocksFieldNumber = 7,
-    kModeFieldNumber = 8,
+    kLblkFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DaReleaseSpaceFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsLookupExtentEnterFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -90751,16 +121670,9 @@ class Ext4DaReleaseSpaceFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DaReleaseSpaceFtraceEvent>;
+      Ext4EsLookupExtentEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -90776,16 +121688,9 @@ class Ext4DaReleaseSpaceFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DaReleaseSpaceFtraceEvent>;
+      Ext4EsLookupExtentEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -90795,24 +121700,69 @@ class Ext4DaReleaseSpaceFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IBlocks =
+  using FieldMetadata_Lblk =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4EsLookupExtentEnterFtraceEvent>;
+
+  static constexpr FieldMetadata_Lblk kLblk{};
+  void set_lblk(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class Ext4EsInsertExtentFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
+ public:
+  Ext4EsInsertExtentFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4EsInsertExtentFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4EsInsertExtentFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_lblk() const { return at<3>().valid(); }
+  uint32_t lblk() const { return at<3>().as_uint32(); }
+  bool has_len() const { return at<4>().valid(); }
+  uint32_t len() const { return at<4>().as_uint32(); }
+  bool has_pblk() const { return at<5>().valid(); }
+  uint64_t pblk() const { return at<5>().as_uint64(); }
+  bool has_status() const { return at<6>().valid(); }
+  uint64_t status() const { return at<6>().as_uint64(); }
+};
+
+class Ext4EsInsertExtentFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4EsInsertExtentFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kLblkFieldNumber = 3,
+    kLenFieldNumber = 4,
+    kPblkFieldNumber = 5,
+    kStatusFieldNumber = 6,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsInsertExtentFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DaReleaseSpaceFtraceEvent>;
+      Ext4EsInsertExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IBlocks kIBlocks() { return {}; }
-  void set_i_blocks(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IBlocks::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -90820,157 +121770,128 @@ class Ext4DaReleaseSpaceFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FreedBlocks =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4DaReleaseSpaceFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4EsInsertExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FreedBlocks kFreedBlocks() { return {}; }
-  void set_freed_blocks(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FreedBlocks::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ReservedDataBlocks =
+  using FieldMetadata_Lblk =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4DaReleaseSpaceFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4EsInsertExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReservedDataBlocks kReservedDataBlocks() { return {}; }
-  void set_reserved_data_blocks(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReservedDataBlocks::kFieldId;
+  static constexpr FieldMetadata_Lblk kLblk{};
+  void set_lblk(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ReservedMetaBlocks =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4DaReleaseSpaceFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4EsInsertExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReservedMetaBlocks kReservedMetaBlocks() { return {}; }
-  void set_reserved_meta_blocks(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReservedMetaBlocks::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_AllocatedMetaBlocks =
+  using FieldMetadata_Pblk =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4DaReleaseSpaceFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4EsInsertExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AllocatedMetaBlocks kAllocatedMetaBlocks() { return {}; }
-  void set_allocated_meta_blocks(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AllocatedMetaBlocks::kFieldId;
+  static constexpr FieldMetadata_Pblk kPblk{};
+  void set_pblk(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Mode =
+  using FieldMetadata_Status =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4DaReleaseSpaceFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4EsInsertExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mode kMode() { return {}; }
-  void set_mode(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+  static constexpr FieldMetadata_Status kStatus{};
+  void set_status(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4CollapseRangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4EsFindDelayedExtentRangeExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  Ext4CollapseRangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4CollapseRangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4CollapseRangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4EsFindDelayedExtentRangeExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4EsFindDelayedExtentRangeExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4EsFindDelayedExtentRangeExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_offset() const { return at<3>().valid(); }
-  int64_t offset() const { return at<3>().as_int64(); }
+  bool has_lblk() const { return at<3>().valid(); }
+  uint32_t lblk() const { return at<3>().as_uint32(); }
   bool has_len() const { return at<4>().valid(); }
-  int64_t len() const { return at<4>().as_int64(); }
+  uint32_t len() const { return at<4>().as_uint32(); }
+  bool has_pblk() const { return at<5>().valid(); }
+  uint64_t pblk() const { return at<5>().as_uint64(); }
+  bool has_status() const { return at<6>().valid(); }
+  uint64_t status() const { return at<6>().as_uint64(); }
 };
 
-class Ext4CollapseRangeFtraceEvent : public ::protozero::Message {
+class Ext4EsFindDelayedExtentRangeExitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4CollapseRangeFtraceEvent_Decoder;
+  using Decoder = Ext4EsFindDelayedExtentRangeExitFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kOffsetFieldNumber = 3,
+    kLblkFieldNumber = 3,
     kLenFieldNumber = 4,
+    kPblkFieldNumber = 5,
+    kStatusFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4CollapseRangeFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsFindDelayedExtentRangeExitFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -90979,16 +121900,9 @@ class Ext4CollapseRangeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4CollapseRangeFtraceEvent>;
+      Ext4EsFindDelayedExtentRangeExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -91004,16 +121918,9 @@ class Ext4CollapseRangeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4CollapseRangeFtraceEvent>;
+      Ext4EsFindDelayedExtentRangeExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -91023,28 +121930,21 @@ class Ext4CollapseRangeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Offset =
+  using FieldMetadata_Lblk =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4CollapseRangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4EsFindDelayedExtentRangeExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Offset kOffset() { return {}; }
-  void set_offset(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId;
+  static constexpr FieldMetadata_Lblk kLblk{};
+  void set_lblk(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
@@ -91052,50 +121952,79 @@ class Ext4CollapseRangeFtraceEvent : public ::protozero::Message {
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4CollapseRangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4EsFindDelayedExtentRangeExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(int64_t value) {
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Pblk =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4EsFindDelayedExtentRangeExitFtraceEvent>;
+
+  static constexpr FieldMetadata_Pblk kPblk{};
+  void set_pblk(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Status =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4EsFindDelayedExtentRangeExitFtraceEvent>;
+
+  static constexpr FieldMetadata_Status kStatus{};
+  void set_status(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4BeginOrderedTruncateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4EsFindDelayedExtentRangeEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  Ext4BeginOrderedTruncateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4BeginOrderedTruncateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4BeginOrderedTruncateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4EsFindDelayedExtentRangeEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4EsFindDelayedExtentRangeEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4EsFindDelayedExtentRangeEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_new_size() const { return at<3>().valid(); }
-  int64_t new_size() const { return at<3>().as_int64(); }
+  bool has_lblk() const { return at<3>().valid(); }
+  uint32_t lblk() const { return at<3>().as_uint32(); }
 };
 
-class Ext4BeginOrderedTruncateFtraceEvent : public ::protozero::Message {
+class Ext4EsFindDelayedExtentRangeEnterFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4BeginOrderedTruncateFtraceEvent_Decoder;
+  using Decoder = Ext4EsFindDelayedExtentRangeEnterFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kNewSizeFieldNumber = 3,
+    kLblkFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4BeginOrderedTruncateFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsFindDelayedExtentRangeEnterFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -91104,16 +122033,9 @@ class Ext4BeginOrderedTruncateFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4BeginOrderedTruncateFtraceEvent>;
+      Ext4EsFindDelayedExtentRangeEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -91129,16 +122051,9 @@ class Ext4BeginOrderedTruncateFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4BeginOrderedTruncateFtraceEvent>;
+      Ext4EsFindDelayedExtentRangeEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -91148,57 +122063,56 @@ class Ext4BeginOrderedTruncateFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NewSize =
+  using FieldMetadata_Lblk =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4BeginOrderedTruncateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4EsFindDelayedExtentRangeEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NewSize kNewSize() { return {}; }
-  void set_new_size(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NewSize::kFieldId;
+  static constexpr FieldMetadata_Lblk kLblk{};
+  void set_lblk(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4AllocateInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4EsCacheExtentFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  Ext4AllocateInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4AllocateInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4AllocateInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4EsCacheExtentFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4EsCacheExtentFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4EsCacheExtentFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_dir() const { return at<3>().valid(); }
-  uint64_t dir() const { return at<3>().as_uint64(); }
-  bool has_mode() const { return at<4>().valid(); }
-  uint32_t mode() const { return at<4>().as_uint32(); }
+  bool has_lblk() const { return at<3>().valid(); }
+  uint32_t lblk() const { return at<3>().as_uint32(); }
+  bool has_len() const { return at<4>().valid(); }
+  uint32_t len() const { return at<4>().as_uint32(); }
+  bool has_pblk() const { return at<5>().valid(); }
+  uint64_t pblk() const { return at<5>().as_uint64(); }
+  bool has_status() const { return at<6>().valid(); }
+  uint32_t status() const { return at<6>().as_uint32(); }
 };
 
-class Ext4AllocateInodeFtraceEvent : public ::protozero::Message {
+class Ext4EsCacheExtentFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4AllocateInodeFtraceEvent_Decoder;
+  using Decoder = Ext4EsCacheExtentFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kDirFieldNumber = 3,
-    kModeFieldNumber = 4,
+    kLblkFieldNumber = 3,
+    kLenFieldNumber = 4,
+    kPblkFieldNumber = 5,
+    kStatusFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4AllocateInodeFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsCacheExtentFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -91207,16 +122121,9 @@ class Ext4AllocateInodeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4AllocateInodeFtraceEvent>;
+      Ext4EsCacheExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -91232,16 +122139,9 @@ class Ext4AllocateInodeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4AllocateInodeFtraceEvent>;
+      Ext4EsCacheExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -91251,24 +122151,53 @@ class Ext4AllocateInodeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Dir =
+  using FieldMetadata_Lblk =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4EsCacheExtentFtraceEvent>;
+
+  static constexpr FieldMetadata_Lblk kLblk{};
+  void set_lblk(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Len =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4EsCacheExtentFtraceEvent>;
+
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Pblk =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4AllocateInodeFtraceEvent>;
+      Ext4EsCacheExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dir kDir() { return {}; }
-  void set_dir(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dir::kFieldId;
+  static constexpr FieldMetadata_Pblk kPblk{};
+  void set_pblk(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -91276,24 +122205,17 @@ class Ext4AllocateInodeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Mode =
+  using FieldMetadata_Status =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4AllocateInodeFtraceEvent>;
+      Ext4EsCacheExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mode kMode() { return {}; }
-  void set_mode(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+  static constexpr FieldMetadata_Status kStatus{};
+  void set_status(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -91302,52 +122224,28 @@ class Ext4AllocateInodeFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4AllocateBlocksFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4DropInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  Ext4AllocateBlocksFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4AllocateBlocksFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4AllocateBlocksFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4DropInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4DropInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4DropInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_block() const { return at<3>().valid(); }
-  uint64_t block() const { return at<3>().as_uint64(); }
-  bool has_len() const { return at<4>().valid(); }
-  uint32_t len() const { return at<4>().as_uint32(); }
-  bool has_logical() const { return at<5>().valid(); }
-  uint32_t logical() const { return at<5>().as_uint32(); }
-  bool has_lleft() const { return at<6>().valid(); }
-  uint32_t lleft() const { return at<6>().as_uint32(); }
-  bool has_lright() const { return at<7>().valid(); }
-  uint32_t lright() const { return at<7>().as_uint32(); }
-  bool has_goal() const { return at<8>().valid(); }
-  uint64_t goal() const { return at<8>().as_uint64(); }
-  bool has_pleft() const { return at<9>().valid(); }
-  uint64_t pleft() const { return at<9>().as_uint64(); }
-  bool has_pright() const { return at<10>().valid(); }
-  uint64_t pright() const { return at<10>().as_uint64(); }
-  bool has_flags() const { return at<11>().valid(); }
-  uint32_t flags() const { return at<11>().as_uint32(); }
+  bool has_drop() const { return at<3>().valid(); }
+  int32_t drop() const { return at<3>().as_int32(); }
 };
 
-class Ext4AllocateBlocksFtraceEvent : public ::protozero::Message {
+class Ext4DropInodeFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4AllocateBlocksFtraceEvent_Decoder;
+  using Decoder = Ext4DropInodeFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kBlockFieldNumber = 3,
-    kLenFieldNumber = 4,
-    kLogicalFieldNumber = 5,
-    kLleftFieldNumber = 6,
-    kLrightFieldNumber = 7,
-    kGoalFieldNumber = 8,
-    kPleftFieldNumber = 9,
-    kPrightFieldNumber = 10,
-    kFlagsFieldNumber = 11,
+    kDropFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4AllocateBlocksFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DropInodeFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -91356,16 +122254,9 @@ class Ext4AllocateBlocksFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4AllocateBlocksFtraceEvent>;
+      Ext4DropInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -91381,16 +122272,9 @@ class Ext4AllocateBlocksFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4AllocateBlocksFtraceEvent>;
+      Ext4DropInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -91400,99 +122284,99 @@ class Ext4AllocateBlocksFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Block =
+  using FieldMetadata_Drop =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Ext4AllocateBlocksFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4DropInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Block kBlock() { return {}; }
-  void set_block(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Block::kFieldId;
+  static constexpr FieldMetadata_Drop kDrop{};
+  void set_drop(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Drop::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Len =
+class Ext4DiscardPreallocationsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  Ext4DiscardPreallocationsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4DiscardPreallocationsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4DiscardPreallocationsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_len() const { return at<3>().valid(); }
+  uint32_t len() const { return at<3>().as_uint32(); }
+  bool has_needed() const { return at<4>().valid(); }
+  uint32_t needed() const { return at<4>().as_uint32(); }
+};
+
+class Ext4DiscardPreallocationsFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4DiscardPreallocationsFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kLenFieldNumber = 3,
+    kNeededFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DiscardPreallocationsFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4AllocateBlocksFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4DiscardPreallocationsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Logical =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4AllocateBlocksFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4DiscardPreallocationsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Logical kLogical() { return {}; }
-  void set_logical(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Logical::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Lleft =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4AllocateBlocksFtraceEvent>;
+      Ext4DiscardPreallocationsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lleft kLleft() { return {}; }
-  void set_lleft(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lleft::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -91500,49 +122384,60 @@ class Ext4AllocateBlocksFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Lright =
+  using FieldMetadata_Needed =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4AllocateBlocksFtraceEvent>;
+      Ext4DiscardPreallocationsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lright kLright() { return {}; }
-  void set_lright(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lright::kFieldId;
+  static constexpr FieldMetadata_Needed kNeeded{};
+  void set_needed(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Needed::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Goal =
+class Ext4DiscardBlocksFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  Ext4DiscardBlocksFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4DiscardBlocksFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4DiscardBlocksFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_blk() const { return at<2>().valid(); }
+  uint64_t blk() const { return at<2>().as_uint64(); }
+  bool has_count() const { return at<3>().valid(); }
+  uint64_t count() const { return at<3>().as_uint64(); }
+};
+
+class Ext4DiscardBlocksFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4DiscardBlocksFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kBlkFieldNumber = 2,
+    kCountFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DiscardBlocksFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4AllocateBlocksFtraceEvent>;
+      Ext4DiscardBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Goal kGoal() { return {}; }
-  void set_goal(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Goal::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -91550,24 +122445,17 @@ class Ext4AllocateBlocksFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pleft =
+  using FieldMetadata_Blk =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4AllocateBlocksFtraceEvent>;
+      Ext4DiscardBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pleft kPleft() { return {}; }
-  void set_pleft(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pleft::kFieldId;
+  static constexpr FieldMetadata_Blk kBlk{};
+  void set_blk(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Blk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -91575,82 +122463,56 @@ class Ext4AllocateBlocksFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pright =
+  using FieldMetadata_Count =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4AllocateBlocksFtraceEvent>;
+      Ext4DiscardBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pright kPright() { return {}; }
-  void set_pright(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pright::kFieldId;
+  static constexpr FieldMetadata_Count kCount{};
+  void set_count(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-
-  using FieldMetadata_Flags =
-    ::protozero::proto_utils::FieldMetadata<
-      11,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4AllocateBlocksFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
 };
 
-class Ext4AllocDaBlocksFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4DirectIOExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  Ext4AllocDaBlocksFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4AllocDaBlocksFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4AllocDaBlocksFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4DirectIOExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4DirectIOExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4DirectIOExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_data_blocks() const { return at<3>().valid(); }
-  uint32_t data_blocks() const { return at<3>().as_uint32(); }
-  bool has_meta_blocks() const { return at<4>().valid(); }
-  uint32_t meta_blocks() const { return at<4>().as_uint32(); }
+  bool has_pos() const { return at<3>().valid(); }
+  int64_t pos() const { return at<3>().as_int64(); }
+  bool has_len() const { return at<4>().valid(); }
+  uint64_t len() const { return at<4>().as_uint64(); }
+  bool has_rw() const { return at<5>().valid(); }
+  int32_t rw() const { return at<5>().as_int32(); }
+  bool has_ret() const { return at<6>().valid(); }
+  int32_t ret() const { return at<6>().as_int32(); }
 };
 
-class Ext4AllocDaBlocksFtraceEvent : public ::protozero::Message {
+class Ext4DirectIOExitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4AllocDaBlocksFtraceEvent_Decoder;
+  using Decoder = Ext4DirectIOExitFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kDataBlocksFieldNumber = 3,
-    kMetaBlocksFieldNumber = 4,
+    kPosFieldNumber = 3,
+    kLenFieldNumber = 4,
+    kRwFieldNumber = 5,
+    kRetFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4AllocDaBlocksFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DirectIOExitFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -91659,16 +122521,9 @@ class Ext4AllocDaBlocksFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4AllocDaBlocksFtraceEvent>;
+      Ext4DirectIOExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -91684,16 +122539,9 @@ class Ext4AllocDaBlocksFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4AllocDaBlocksFtraceEvent>;
+      Ext4DirectIOExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -91703,79 +122551,107 @@ class Ext4AllocDaBlocksFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DataBlocks =
+  using FieldMetadata_Pos =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4AllocDaBlocksFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4DirectIOExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DataBlocks kDataBlocks() { return {}; }
-  void set_data_blocks(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DataBlocks::kFieldId;
+  static constexpr FieldMetadata_Pos kPos{};
+  void set_pos(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MetaBlocks =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4AllocDaBlocksFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4DirectIOExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MetaBlocks kMetaBlocks() { return {}; }
-  void set_meta_blocks(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MetaBlocks::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Rw =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4DirectIOExitFtraceEvent>;
+
+  static constexpr FieldMetadata_Rw kRw{};
+  void set_rw(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Rw::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ret =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4DirectIOExitFtraceEvent>;
+
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4SyncFileExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4DirectIOEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  Ext4SyncFileExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4SyncFileExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4SyncFileExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4DirectIOEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4DirectIOEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4DirectIOEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_ret() const { return at<3>().valid(); }
-  int32_t ret() const { return at<3>().as_int32(); }
+  bool has_pos() const { return at<3>().valid(); }
+  int64_t pos() const { return at<3>().as_int64(); }
+  bool has_len() const { return at<4>().valid(); }
+  uint64_t len() const { return at<4>().as_uint64(); }
+  bool has_rw() const { return at<5>().valid(); }
+  int32_t rw() const { return at<5>().as_int32(); }
 };
 
-class Ext4SyncFileExitFtraceEvent : public ::protozero::Message {
+class Ext4DirectIOEnterFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4SyncFileExitFtraceEvent_Decoder;
+  using Decoder = Ext4DirectIOEnterFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kRetFieldNumber = 3,
+    kPosFieldNumber = 3,
+    kLenFieldNumber = 4,
+    kRwFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4SyncFileExitFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DirectIOEnterFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -91784,16 +122660,9 @@ class Ext4SyncFileExitFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4SyncFileExitFtraceEvent>;
+      Ext4DirectIOEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -91809,16 +122678,9 @@ class Ext4SyncFileExitFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4SyncFileExitFtraceEvent>;
+      Ext4DirectIOEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -91828,24 +122690,53 @@ class Ext4SyncFileExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ret =
+  using FieldMetadata_Pos =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4DirectIOEnterFtraceEvent>;
+
+  static constexpr FieldMetadata_Pos kPos{};
+  void set_pos(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Len =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4DirectIOEnterFtraceEvent>;
+
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Rw =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Ext4SyncFileExitFtraceEvent>;
+      Ext4DirectIOEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+  static constexpr FieldMetadata_Rw kRw{};
+  void set_rw(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Rw::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -91854,31 +122745,34 @@ class Ext4SyncFileExitFtraceEvent : public ::protozero::Message {
   }
 };
 
-class Ext4SyncFileEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4DaWritePagesExtentFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  Ext4SyncFileEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4SyncFileEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4SyncFileEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4DaWritePagesExtentFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4DaWritePagesExtentFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4DaWritePagesExtentFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_parent() const { return at<3>().valid(); }
-  uint64_t parent() const { return at<3>().as_uint64(); }
-  bool has_datasync() const { return at<4>().valid(); }
-  int32_t datasync() const { return at<4>().as_int32(); }
+  bool has_lblk() const { return at<3>().valid(); }
+  uint64_t lblk() const { return at<3>().as_uint64(); }
+  bool has_len() const { return at<4>().valid(); }
+  uint32_t len() const { return at<4>().as_uint32(); }
+  bool has_flags() const { return at<5>().valid(); }
+  uint32_t flags() const { return at<5>().as_uint32(); }
 };
 
-class Ext4SyncFileEnterFtraceEvent : public ::protozero::Message {
+class Ext4DaWritePagesExtentFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4SyncFileEnterFtraceEvent_Decoder;
+  using Decoder = Ext4DaWritePagesExtentFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kParentFieldNumber = 3,
-    kDatasyncFieldNumber = 4,
+    kLblkFieldNumber = 3,
+    kLenFieldNumber = 4,
+    kFlagsFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4SyncFileEnterFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DaWritePagesExtentFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -91887,16 +122781,9 @@ class Ext4SyncFileEnterFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4SyncFileEnterFtraceEvent>;
+      Ext4DaWritePagesExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -91912,16 +122799,9 @@ class Ext4SyncFileEnterFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4SyncFileEnterFtraceEvent>;
+      Ext4DaWritePagesExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -91931,24 +122811,17 @@ class Ext4SyncFileEnterFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Parent =
+  using FieldMetadata_Lblk =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4SyncFileEnterFtraceEvent>;
+      Ext4DaWritePagesExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Parent kParent() { return {}; }
-  void set_parent(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Parent::kFieldId;
+  static constexpr FieldMetadata_Lblk kLblk{};
+  void set_lblk(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -91956,60 +122829,86 @@ class Ext4SyncFileEnterFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Datasync =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Ext4SyncFileEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4DaWritePagesExtentFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Datasync kDatasync() { return {}; }
-  void set_datasync(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Datasync::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Flags =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4DaWritePagesExtentFtraceEvent>;
+
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class Ext4DaWriteEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4DaWritePagesFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10> {
  public:
-  Ext4DaWriteEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4DaWriteEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4DaWriteEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4DaWritePagesFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4DaWritePagesFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4DaWritePagesFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_pos() const { return at<3>().valid(); }
-  int64_t pos() const { return at<3>().as_int64(); }
-  bool has_len() const { return at<4>().valid(); }
-  uint32_t len() const { return at<4>().as_uint32(); }
-  bool has_copied() const { return at<5>().valid(); }
-  uint32_t copied() const { return at<5>().as_uint32(); }
+  bool has_first_page() const { return at<3>().valid(); }
+  uint64_t first_page() const { return at<3>().as_uint64(); }
+  bool has_nr_to_write() const { return at<4>().valid(); }
+  int64_t nr_to_write() const { return at<4>().as_int64(); }
+  bool has_sync_mode() const { return at<5>().valid(); }
+  int32_t sync_mode() const { return at<5>().as_int32(); }
+  bool has_b_blocknr() const { return at<6>().valid(); }
+  uint64_t b_blocknr() const { return at<6>().as_uint64(); }
+  bool has_b_size() const { return at<7>().valid(); }
+  uint32_t b_size() const { return at<7>().as_uint32(); }
+  bool has_b_state() const { return at<8>().valid(); }
+  uint32_t b_state() const { return at<8>().as_uint32(); }
+  bool has_io_done() const { return at<9>().valid(); }
+  int32_t io_done() const { return at<9>().as_int32(); }
+  bool has_pages_written() const { return at<10>().valid(); }
+  int32_t pages_written() const { return at<10>().as_int32(); }
 };
 
-class Ext4DaWriteEndFtraceEvent : public ::protozero::Message {
+class Ext4DaWritePagesFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4DaWriteEndFtraceEvent_Decoder;
+  using Decoder = Ext4DaWritePagesFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kPosFieldNumber = 3,
-    kLenFieldNumber = 4,
-    kCopiedFieldNumber = 5,
+    kFirstPageFieldNumber = 3,
+    kNrToWriteFieldNumber = 4,
+    kSyncModeFieldNumber = 5,
+    kBBlocknrFieldNumber = 6,
+    kBSizeFieldNumber = 7,
+    kBStateFieldNumber = 8,
+    kIoDoneFieldNumber = 9,
+    kPagesWrittenFieldNumber = 10,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DaWriteEndFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DaWritePagesFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -92018,16 +122917,9 @@ class Ext4DaWriteEndFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DaWriteEndFtraceEvent>;
+      Ext4DaWritePagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -92043,16 +122935,9 @@ class Ext4DaWriteEndFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DaWriteEndFtraceEvent>;
+      Ext4DaWritePagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -92062,24 +122947,35 @@ class Ext4DaWriteEndFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pos =
+  using FieldMetadata_FirstPage =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4DaWritePagesFtraceEvent>;
+
+  static constexpr FieldMetadata_FirstPage kFirstPage{};
+  void set_first_page(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FirstPage::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NrToWrite =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt64,
       int64_t,
-      Ext4DaWriteEndFtraceEvent>;
+      Ext4DaWritePagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pos kPos() { return {}; }
-  void set_pos(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId;
+  static constexpr FieldMetadata_NrToWrite kNrToWrite{};
+  void set_nr_to_write(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NrToWrite::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -92087,24 +122983,53 @@ class Ext4DaWriteEndFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_SyncMode =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4DaWritePagesFtraceEvent>;
+
+  static constexpr FieldMetadata_SyncMode kSyncMode{};
+  void set_sync_mode(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SyncMode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BBlocknr =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4DaWritePagesFtraceEvent>;
+
+  static constexpr FieldMetadata_BBlocknr kBBlocknr{};
+  void set_b_blocknr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BBlocknr::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BSize =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4DaWriteEndFtraceEvent>;
+      Ext4DaWritePagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_BSize kBSize{};
+  void set_b_size(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BSize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -92112,60 +123037,101 @@ class Ext4DaWriteEndFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Copied =
+  using FieldMetadata_BState =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Ext4DaWriteEndFtraceEvent>;
+      Ext4DaWritePagesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Copied kCopied() { return {}; }
-  void set_copied(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Copied::kFieldId;
+  static constexpr FieldMetadata_BState kBState{};
+  void set_b_state(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BState::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_IoDone =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4DaWritePagesFtraceEvent>;
+
+  static constexpr FieldMetadata_IoDone kIoDone{};
+  void set_io_done(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IoDone::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PagesWritten =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4DaWritePagesFtraceEvent>;
+
+  static constexpr FieldMetadata_PagesWritten kPagesWritten{};
+  void set_pages_written(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PagesWritten::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class Ext4DaWriteBeginFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4DaUpdateReserveSpaceFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9> {
  public:
-  Ext4DaWriteBeginFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Ext4DaWriteBeginFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Ext4DaWriteBeginFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4DaUpdateReserveSpaceFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4DaUpdateReserveSpaceFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4DaUpdateReserveSpaceFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_pos() const { return at<3>().valid(); }
-  int64_t pos() const { return at<3>().as_int64(); }
-  bool has_len() const { return at<4>().valid(); }
-  uint32_t len() const { return at<4>().as_uint32(); }
-  bool has_flags() const { return at<5>().valid(); }
-  uint32_t flags() const { return at<5>().as_uint32(); }
+  bool has_i_blocks() const { return at<3>().valid(); }
+  uint64_t i_blocks() const { return at<3>().as_uint64(); }
+  bool has_used_blocks() const { return at<4>().valid(); }
+  int32_t used_blocks() const { return at<4>().as_int32(); }
+  bool has_reserved_data_blocks() const { return at<5>().valid(); }
+  int32_t reserved_data_blocks() const { return at<5>().as_int32(); }
+  bool has_reserved_meta_blocks() const { return at<6>().valid(); }
+  int32_t reserved_meta_blocks() const { return at<6>().as_int32(); }
+  bool has_allocated_meta_blocks() const { return at<7>().valid(); }
+  int32_t allocated_meta_blocks() const { return at<7>().as_int32(); }
+  bool has_quota_claim() const { return at<8>().valid(); }
+  int32_t quota_claim() const { return at<8>().as_int32(); }
+  bool has_mode() const { return at<9>().valid(); }
+  uint32_t mode() const { return at<9>().as_uint32(); }
 };
 
-class Ext4DaWriteBeginFtraceEvent : public ::protozero::Message {
+class Ext4DaUpdateReserveSpaceFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Ext4DaWriteBeginFtraceEvent_Decoder;
+  using Decoder = Ext4DaUpdateReserveSpaceFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kPosFieldNumber = 3,
-    kLenFieldNumber = 4,
-    kFlagsFieldNumber = 5,
+    kIBlocksFieldNumber = 3,
+    kUsedBlocksFieldNumber = 4,
+    kReservedDataBlocksFieldNumber = 5,
+    kReservedMetaBlocksFieldNumber = 6,
+    kAllocatedMetaBlocksFieldNumber = 7,
+    kQuotaClaimFieldNumber = 8,
+    kModeFieldNumber = 9,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DaWriteBeginFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DaUpdateReserveSpaceFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -92174,16 +123140,9 @@ class Ext4DaWriteBeginFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DaWriteBeginFtraceEvent>;
+      Ext4DaUpdateReserveSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -92199,16 +123158,9 @@ class Ext4DaWriteBeginFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Ext4DaWriteBeginFtraceEvent>;
+      Ext4DaUpdateReserveSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -92218,398 +123170,270 @@ class Ext4DaWriteBeginFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pos =
+  using FieldMetadata_IBlocks =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Ext4DaWriteBeginFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4DaUpdateReserveSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pos kPos() { return {}; }
-  void set_pos(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId;
+  static constexpr FieldMetadata_IBlocks kIBlocks{};
+  void set_i_blocks(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IBlocks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_UsedBlocks =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4DaWriteBeginFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4DaUpdateReserveSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_UsedBlocks kUsedBlocks{};
+  void set_used_blocks(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_UsedBlocks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_ReservedDataBlocks =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Ext4DaWriteBeginFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4DaUpdateReserveSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_ReservedDataBlocks kReservedDataBlocks{};
+  void set_reserved_data_blocks(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReservedDataBlocks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/f2fs.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_F2FS_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_F2FS_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
 
+  using FieldMetadata_ReservedMetaBlocks =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4DaUpdateReserveSpaceFtraceEvent>;
 
-class F2fsIostatLatencyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/28, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  F2fsIostatLatencyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsIostatLatencyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsIostatLatencyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_d_rd_avg() const { return at<1>().valid(); }
-  uint32_t d_rd_avg() const { return at<1>().as_uint32(); }
-  bool has_d_rd_cnt() const { return at<2>().valid(); }
-  uint32_t d_rd_cnt() const { return at<2>().as_uint32(); }
-  bool has_d_rd_peak() const { return at<3>().valid(); }
-  uint32_t d_rd_peak() const { return at<3>().as_uint32(); }
-  bool has_d_wr_as_avg() const { return at<4>().valid(); }
-  uint32_t d_wr_as_avg() const { return at<4>().as_uint32(); }
-  bool has_d_wr_as_cnt() const { return at<5>().valid(); }
-  uint32_t d_wr_as_cnt() const { return at<5>().as_uint32(); }
-  bool has_d_wr_as_peak() const { return at<6>().valid(); }
-  uint32_t d_wr_as_peak() const { return at<6>().as_uint32(); }
-  bool has_d_wr_s_avg() const { return at<7>().valid(); }
-  uint32_t d_wr_s_avg() const { return at<7>().as_uint32(); }
-  bool has_d_wr_s_cnt() const { return at<8>().valid(); }
-  uint32_t d_wr_s_cnt() const { return at<8>().as_uint32(); }
-  bool has_d_wr_s_peak() const { return at<9>().valid(); }
-  uint32_t d_wr_s_peak() const { return at<9>().as_uint32(); }
-  bool has_dev() const { return at<10>().valid(); }
-  uint64_t dev() const { return at<10>().as_uint64(); }
-  bool has_m_rd_avg() const { return at<11>().valid(); }
-  uint32_t m_rd_avg() const { return at<11>().as_uint32(); }
-  bool has_m_rd_cnt() const { return at<12>().valid(); }
-  uint32_t m_rd_cnt() const { return at<12>().as_uint32(); }
-  bool has_m_rd_peak() const { return at<13>().valid(); }
-  uint32_t m_rd_peak() const { return at<13>().as_uint32(); }
-  bool has_m_wr_as_avg() const { return at<14>().valid(); }
-  uint32_t m_wr_as_avg() const { return at<14>().as_uint32(); }
-  bool has_m_wr_as_cnt() const { return at<15>().valid(); }
-  uint32_t m_wr_as_cnt() const { return at<15>().as_uint32(); }
-  bool has_m_wr_as_peak() const { return at<16>().valid(); }
-  uint32_t m_wr_as_peak() const { return at<16>().as_uint32(); }
-  bool has_m_wr_s_avg() const { return at<17>().valid(); }
-  uint32_t m_wr_s_avg() const { return at<17>().as_uint32(); }
-  bool has_m_wr_s_cnt() const { return at<18>().valid(); }
-  uint32_t m_wr_s_cnt() const { return at<18>().as_uint32(); }
-  bool has_m_wr_s_peak() const { return at<19>().valid(); }
-  uint32_t m_wr_s_peak() const { return at<19>().as_uint32(); }
-  bool has_n_rd_avg() const { return at<20>().valid(); }
-  uint32_t n_rd_avg() const { return at<20>().as_uint32(); }
-  bool has_n_rd_cnt() const { return at<21>().valid(); }
-  uint32_t n_rd_cnt() const { return at<21>().as_uint32(); }
-  bool has_n_rd_peak() const { return at<22>().valid(); }
-  uint32_t n_rd_peak() const { return at<22>().as_uint32(); }
-  bool has_n_wr_as_avg() const { return at<23>().valid(); }
-  uint32_t n_wr_as_avg() const { return at<23>().as_uint32(); }
-  bool has_n_wr_as_cnt() const { return at<24>().valid(); }
-  uint32_t n_wr_as_cnt() const { return at<24>().as_uint32(); }
-  bool has_n_wr_as_peak() const { return at<25>().valid(); }
-  uint32_t n_wr_as_peak() const { return at<25>().as_uint32(); }
-  bool has_n_wr_s_avg() const { return at<26>().valid(); }
-  uint32_t n_wr_s_avg() const { return at<26>().as_uint32(); }
-  bool has_n_wr_s_cnt() const { return at<27>().valid(); }
-  uint32_t n_wr_s_cnt() const { return at<27>().as_uint32(); }
-  bool has_n_wr_s_peak() const { return at<28>().valid(); }
-  uint32_t n_wr_s_peak() const { return at<28>().as_uint32(); }
-};
+  static constexpr FieldMetadata_ReservedMetaBlocks kReservedMetaBlocks{};
+  void set_reserved_meta_blocks(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReservedMetaBlocks::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-class F2fsIostatLatencyFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = F2fsIostatLatencyFtraceEvent_Decoder;
-  enum : int32_t {
-    kDRdAvgFieldNumber = 1,
-    kDRdCntFieldNumber = 2,
-    kDRdPeakFieldNumber = 3,
-    kDWrAsAvgFieldNumber = 4,
-    kDWrAsCntFieldNumber = 5,
-    kDWrAsPeakFieldNumber = 6,
-    kDWrSAvgFieldNumber = 7,
-    kDWrSCntFieldNumber = 8,
-    kDWrSPeakFieldNumber = 9,
-    kDevFieldNumber = 10,
-    kMRdAvgFieldNumber = 11,
-    kMRdCntFieldNumber = 12,
-    kMRdPeakFieldNumber = 13,
-    kMWrAsAvgFieldNumber = 14,
-    kMWrAsCntFieldNumber = 15,
-    kMWrAsPeakFieldNumber = 16,
-    kMWrSAvgFieldNumber = 17,
-    kMWrSCntFieldNumber = 18,
-    kMWrSPeakFieldNumber = 19,
-    kNRdAvgFieldNumber = 20,
-    kNRdCntFieldNumber = 21,
-    kNRdPeakFieldNumber = 22,
-    kNWrAsAvgFieldNumber = 23,
-    kNWrAsCntFieldNumber = 24,
-    kNWrAsPeakFieldNumber = 25,
-    kNWrSAvgFieldNumber = 26,
-    kNWrSCntFieldNumber = 27,
-    kNWrSPeakFieldNumber = 28,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsIostatLatencyFtraceEvent"; }
+  using FieldMetadata_AllocatedMetaBlocks =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4DaUpdateReserveSpaceFtraceEvent>;
 
+  static constexpr FieldMetadata_AllocatedMetaBlocks kAllocatedMetaBlocks{};
+  void set_allocated_meta_blocks(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AllocatedMetaBlocks::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_DRdAvg =
+  using FieldMetadata_QuotaClaim =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4DaUpdateReserveSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DRdAvg kDRdAvg() { return {}; }
-  void set_d_rd_avg(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DRdAvg::kFieldId;
+  static constexpr FieldMetadata_QuotaClaim kQuotaClaim{};
+  void set_quota_claim(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_QuotaClaim::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DRdCnt =
+  using FieldMetadata_Mode =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      Ext4DaUpdateReserveSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DRdCnt kDRdCnt() { return {}; }
-  void set_d_rd_cnt(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DRdCnt::kFieldId;
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_DRdPeak =
+class Ext4DaReserveSpaceFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
+ public:
+  Ext4DaReserveSpaceFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4DaReserveSpaceFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4DaReserveSpaceFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_i_blocks() const { return at<3>().valid(); }
+  uint64_t i_blocks() const { return at<3>().as_uint64(); }
+  bool has_reserved_data_blocks() const { return at<4>().valid(); }
+  int32_t reserved_data_blocks() const { return at<4>().as_int32(); }
+  bool has_reserved_meta_blocks() const { return at<5>().valid(); }
+  int32_t reserved_meta_blocks() const { return at<5>().as_int32(); }
+  bool has_mode() const { return at<6>().valid(); }
+  uint32_t mode() const { return at<6>().as_uint32(); }
+  bool has_md_needed() const { return at<7>().valid(); }
+  int32_t md_needed() const { return at<7>().as_int32(); }
+};
+
+class Ext4DaReserveSpaceFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4DaReserveSpaceFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kIBlocksFieldNumber = 3,
+    kReservedDataBlocksFieldNumber = 4,
+    kReservedMetaBlocksFieldNumber = 5,
+    kModeFieldNumber = 6,
+    kMdNeededFieldNumber = 7,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DaReserveSpaceFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4DaReserveSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DRdPeak kDRdPeak() { return {}; }
-  void set_d_rd_peak(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DRdPeak::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DWrAsAvg =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4DaReserveSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DWrAsAvg kDWrAsAvg() { return {}; }
-  void set_d_wr_as_avg(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DWrAsAvg::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DWrAsCnt =
+  using FieldMetadata_IBlocks =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4DaReserveSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DWrAsCnt kDWrAsCnt() { return {}; }
-  void set_d_wr_as_cnt(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DWrAsCnt::kFieldId;
+  static constexpr FieldMetadata_IBlocks kIBlocks{};
+  void set_i_blocks(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IBlocks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DWrAsPeak =
+  using FieldMetadata_ReservedDataBlocks =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4DaReserveSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DWrAsPeak kDWrAsPeak() { return {}; }
-  void set_d_wr_as_peak(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DWrAsPeak::kFieldId;
+  static constexpr FieldMetadata_ReservedDataBlocks kReservedDataBlocks{};
+  void set_reserved_data_blocks(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReservedDataBlocks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DWrSAvg =
+  using FieldMetadata_ReservedMetaBlocks =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4DaReserveSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DWrSAvg kDWrSAvg() { return {}; }
-  void set_d_wr_s_avg(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DWrSAvg::kFieldId;
+  static constexpr FieldMetadata_ReservedMetaBlocks kReservedMetaBlocks{};
+  void set_reserved_meta_blocks(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReservedMetaBlocks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DWrSCnt =
+  using FieldMetadata_Mode =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      Ext4DaReserveSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DWrSCnt kDWrSCnt() { return {}; }
-  void set_d_wr_s_cnt(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DWrSCnt::kFieldId;
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -92617,47 +123441,73 @@ class F2fsIostatLatencyFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DWrSPeak =
+  using FieldMetadata_MdNeeded =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4DaReserveSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DWrSPeak kDWrSPeak() { return {}; }
-  void set_d_wr_s_peak(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DWrSPeak::kFieldId;
+  static constexpr FieldMetadata_MdNeeded kMdNeeded{};
+  void set_md_needed(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MdNeeded::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
+
+class Ext4DaReleaseSpaceFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
+ public:
+  Ext4DaReleaseSpaceFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4DaReleaseSpaceFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4DaReleaseSpaceFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_i_blocks() const { return at<3>().valid(); }
+  uint64_t i_blocks() const { return at<3>().as_uint64(); }
+  bool has_freed_blocks() const { return at<4>().valid(); }
+  int32_t freed_blocks() const { return at<4>().as_int32(); }
+  bool has_reserved_data_blocks() const { return at<5>().valid(); }
+  int32_t reserved_data_blocks() const { return at<5>().as_int32(); }
+  bool has_reserved_meta_blocks() const { return at<6>().valid(); }
+  int32_t reserved_meta_blocks() const { return at<6>().as_int32(); }
+  bool has_allocated_meta_blocks() const { return at<7>().valid(); }
+  int32_t allocated_meta_blocks() const { return at<7>().as_int32(); }
+  bool has_mode() const { return at<8>().valid(); }
+  uint32_t mode() const { return at<8>().as_uint32(); }
+};
+
+class Ext4DaReleaseSpaceFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4DaReleaseSpaceFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kIBlocksFieldNumber = 3,
+    kFreedBlocksFieldNumber = 4,
+    kReservedDataBlocksFieldNumber = 5,
+    kReservedMetaBlocksFieldNumber = 6,
+    kAllocatedMetaBlocksFieldNumber = 7,
+    kModeFieldNumber = 8,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DaReleaseSpaceFtraceEvent"; }
+
 
   using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsIostatLatencyFtraceEvent>;
+      Ext4DaReleaseSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -92667,449 +123517,404 @@ class F2fsIostatLatencyFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MRdAvg =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4DaReleaseSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MRdAvg kMRdAvg() { return {}; }
-  void set_m_rd_avg(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MRdAvg::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MRdCnt =
+  using FieldMetadata_IBlocks =
     ::protozero::proto_utils::FieldMetadata<
-      12,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4DaReleaseSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MRdCnt kMRdCnt() { return {}; }
-  void set_m_rd_cnt(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MRdCnt::kFieldId;
+  static constexpr FieldMetadata_IBlocks kIBlocks{};
+  void set_i_blocks(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IBlocks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MRdPeak =
+  using FieldMetadata_FreedBlocks =
     ::protozero::proto_utils::FieldMetadata<
-      13,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4DaReleaseSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MRdPeak kMRdPeak() { return {}; }
-  void set_m_rd_peak(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MRdPeak::kFieldId;
+  static constexpr FieldMetadata_FreedBlocks kFreedBlocks{};
+  void set_freed_blocks(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FreedBlocks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MWrAsAvg =
+  using FieldMetadata_ReservedDataBlocks =
     ::protozero::proto_utils::FieldMetadata<
-      14,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4DaReleaseSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MWrAsAvg kMWrAsAvg() { return {}; }
-  void set_m_wr_as_avg(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MWrAsAvg::kFieldId;
+  static constexpr FieldMetadata_ReservedDataBlocks kReservedDataBlocks{};
+  void set_reserved_data_blocks(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReservedDataBlocks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MWrAsCnt =
+  using FieldMetadata_ReservedMetaBlocks =
     ::protozero::proto_utils::FieldMetadata<
-      15,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4DaReleaseSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MWrAsCnt kMWrAsCnt() { return {}; }
-  void set_m_wr_as_cnt(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MWrAsCnt::kFieldId;
+  static constexpr FieldMetadata_ReservedMetaBlocks kReservedMetaBlocks{};
+  void set_reserved_meta_blocks(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReservedMetaBlocks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MWrAsPeak =
+  using FieldMetadata_AllocatedMetaBlocks =
     ::protozero::proto_utils::FieldMetadata<
-      16,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4DaReleaseSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MWrAsPeak kMWrAsPeak() { return {}; }
-  void set_m_wr_as_peak(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MWrAsPeak::kFieldId;
+  static constexpr FieldMetadata_AllocatedMetaBlocks kAllocatedMetaBlocks{};
+  void set_allocated_meta_blocks(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AllocatedMetaBlocks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MWrSAvg =
+  using FieldMetadata_Mode =
     ::protozero::proto_utils::FieldMetadata<
-      17,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      Ext4DaReleaseSpaceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MWrSAvg kMWrSAvg() { return {}; }
-  void set_m_wr_s_avg(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MWrSAvg::kFieldId;
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_MWrSCnt =
+class Ext4CollapseRangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  Ext4CollapseRangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4CollapseRangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4CollapseRangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_offset() const { return at<3>().valid(); }
+  int64_t offset() const { return at<3>().as_int64(); }
+  bool has_len() const { return at<4>().valid(); }
+  int64_t len() const { return at<4>().as_int64(); }
+};
+
+class Ext4CollapseRangeFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4CollapseRangeFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kOffsetFieldNumber = 3,
+    kLenFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4CollapseRangeFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      18,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4CollapseRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MWrSCnt kMWrSCnt() { return {}; }
-  void set_m_wr_s_cnt(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MWrSCnt::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MWrSPeak =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
-      19,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4CollapseRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MWrSPeak kMWrSPeak() { return {}; }
-  void set_m_wr_s_peak(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MWrSPeak::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NRdAvg =
+  using FieldMetadata_Offset =
     ::protozero::proto_utils::FieldMetadata<
-      20,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4CollapseRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NRdAvg kNRdAvg() { return {}; }
-  void set_n_rd_avg(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NRdAvg::kFieldId;
+  static constexpr FieldMetadata_Offset kOffset{};
+  void set_offset(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NRdCnt =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
-      21,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4CollapseRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NRdCnt kNRdCnt() { return {}; }
-  void set_n_rd_cnt(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NRdCnt::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_NRdPeak =
+class Ext4BeginOrderedTruncateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  Ext4BeginOrderedTruncateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4BeginOrderedTruncateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4BeginOrderedTruncateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_new_size() const { return at<3>().valid(); }
+  int64_t new_size() const { return at<3>().as_int64(); }
+};
+
+class Ext4BeginOrderedTruncateFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4BeginOrderedTruncateFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kNewSizeFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4BeginOrderedTruncateFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      22,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4BeginOrderedTruncateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NRdPeak kNRdPeak() { return {}; }
-  void set_n_rd_peak(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NRdPeak::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NWrAsAvg =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
-      23,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4BeginOrderedTruncateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NWrAsAvg kNWrAsAvg() { return {}; }
-  void set_n_wr_as_avg(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NWrAsAvg::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NWrAsCnt =
+  using FieldMetadata_NewSize =
     ::protozero::proto_utils::FieldMetadata<
-      24,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4BeginOrderedTruncateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NWrAsCnt kNWrAsCnt() { return {}; }
-  void set_n_wr_as_cnt(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NWrAsCnt::kFieldId;
+  static constexpr FieldMetadata_NewSize kNewSize{};
+  void set_new_size(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NewSize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_NWrAsPeak =
+class Ext4AllocateInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  Ext4AllocateInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4AllocateInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4AllocateInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_dir() const { return at<3>().valid(); }
+  uint64_t dir() const { return at<3>().as_uint64(); }
+  bool has_mode() const { return at<4>().valid(); }
+  uint32_t mode() const { return at<4>().as_uint32(); }
+};
+
+class Ext4AllocateInodeFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4AllocateInodeFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kDirFieldNumber = 3,
+    kModeFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4AllocateInodeFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      25,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4AllocateInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NWrAsPeak kNWrAsPeak() { return {}; }
-  void set_n_wr_as_peak(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NWrAsPeak::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NWrSAvg =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
-      26,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4AllocateInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NWrSAvg kNWrSAvg() { return {}; }
-  void set_n_wr_s_avg(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NWrSAvg::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NWrSCnt =
+  using FieldMetadata_Dir =
     ::protozero::proto_utils::FieldMetadata<
-      27,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Ext4AllocateInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NWrSCnt kNWrSCnt() { return {}; }
-  void set_n_wr_s_cnt(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NWrSCnt::kFieldId;
+  static constexpr FieldMetadata_Dir kDir{};
+  void set_dir(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dir::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NWrSPeak =
+  using FieldMetadata_Mode =
     ::protozero::proto_utils::FieldMetadata<
-      28,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      F2fsIostatLatencyFtraceEvent>;
+      Ext4AllocateInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NWrSPeak kNWrSPeak() { return {}; }
-  void set_n_wr_s_peak(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NWrSPeak::kFieldId;
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -93118,108 +123923,65 @@ class F2fsIostatLatencyFtraceEvent : public ::protozero::Message {
   }
 };
 
-class F2fsIostatFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/23, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4AllocateBlocksFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11> {
  public:
-  F2fsIostatFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsIostatFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsIostatFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_app_bio() const { return at<1>().valid(); }
-  uint64_t app_bio() const { return at<1>().as_uint64(); }
-  bool has_app_brio() const { return at<2>().valid(); }
-  uint64_t app_brio() const { return at<2>().as_uint64(); }
-  bool has_app_dio() const { return at<3>().valid(); }
-  uint64_t app_dio() const { return at<3>().as_uint64(); }
-  bool has_app_drio() const { return at<4>().valid(); }
-  uint64_t app_drio() const { return at<4>().as_uint64(); }
-  bool has_app_mio() const { return at<5>().valid(); }
-  uint64_t app_mio() const { return at<5>().as_uint64(); }
-  bool has_app_mrio() const { return at<6>().valid(); }
-  uint64_t app_mrio() const { return at<6>().as_uint64(); }
-  bool has_app_rio() const { return at<7>().valid(); }
-  uint64_t app_rio() const { return at<7>().as_uint64(); }
-  bool has_app_wio() const { return at<8>().valid(); }
-  uint64_t app_wio() const { return at<8>().as_uint64(); }
-  bool has_dev() const { return at<9>().valid(); }
-  uint64_t dev() const { return at<9>().as_uint64(); }
-  bool has_fs_cdrio() const { return at<10>().valid(); }
-  uint64_t fs_cdrio() const { return at<10>().as_uint64(); }
-  bool has_fs_cp_dio() const { return at<11>().valid(); }
-  uint64_t fs_cp_dio() const { return at<11>().as_uint64(); }
-  bool has_fs_cp_mio() const { return at<12>().valid(); }
-  uint64_t fs_cp_mio() const { return at<12>().as_uint64(); }
-  bool has_fs_cp_nio() const { return at<13>().valid(); }
-  uint64_t fs_cp_nio() const { return at<13>().as_uint64(); }
-  bool has_fs_dio() const { return at<14>().valid(); }
-  uint64_t fs_dio() const { return at<14>().as_uint64(); }
-  bool has_fs_discard() const { return at<15>().valid(); }
-  uint64_t fs_discard() const { return at<15>().as_uint64(); }
-  bool has_fs_drio() const { return at<16>().valid(); }
-  uint64_t fs_drio() const { return at<16>().as_uint64(); }
-  bool has_fs_gc_dio() const { return at<17>().valid(); }
-  uint64_t fs_gc_dio() const { return at<17>().as_uint64(); }
-  bool has_fs_gc_nio() const { return at<18>().valid(); }
-  uint64_t fs_gc_nio() const { return at<18>().as_uint64(); }
-  bool has_fs_gdrio() const { return at<19>().valid(); }
-  uint64_t fs_gdrio() const { return at<19>().as_uint64(); }
-  bool has_fs_mio() const { return at<20>().valid(); }
-  uint64_t fs_mio() const { return at<20>().as_uint64(); }
-  bool has_fs_mrio() const { return at<21>().valid(); }
-  uint64_t fs_mrio() const { return at<21>().as_uint64(); }
-  bool has_fs_nio() const { return at<22>().valid(); }
-  uint64_t fs_nio() const { return at<22>().as_uint64(); }
-  bool has_fs_nrio() const { return at<23>().valid(); }
-  uint64_t fs_nrio() const { return at<23>().as_uint64(); }
+  Ext4AllocateBlocksFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4AllocateBlocksFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4AllocateBlocksFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_block() const { return at<3>().valid(); }
+  uint64_t block() const { return at<3>().as_uint64(); }
+  bool has_len() const { return at<4>().valid(); }
+  uint32_t len() const { return at<4>().as_uint32(); }
+  bool has_logical() const { return at<5>().valid(); }
+  uint32_t logical() const { return at<5>().as_uint32(); }
+  bool has_lleft() const { return at<6>().valid(); }
+  uint32_t lleft() const { return at<6>().as_uint32(); }
+  bool has_lright() const { return at<7>().valid(); }
+  uint32_t lright() const { return at<7>().as_uint32(); }
+  bool has_goal() const { return at<8>().valid(); }
+  uint64_t goal() const { return at<8>().as_uint64(); }
+  bool has_pleft() const { return at<9>().valid(); }
+  uint64_t pleft() const { return at<9>().as_uint64(); }
+  bool has_pright() const { return at<10>().valid(); }
+  uint64_t pright() const { return at<10>().as_uint64(); }
+  bool has_flags() const { return at<11>().valid(); }
+  uint32_t flags() const { return at<11>().as_uint32(); }
 };
 
-class F2fsIostatFtraceEvent : public ::protozero::Message {
+class Ext4AllocateBlocksFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = F2fsIostatFtraceEvent_Decoder;
+  using Decoder = Ext4AllocateBlocksFtraceEvent_Decoder;
   enum : int32_t {
-    kAppBioFieldNumber = 1,
-    kAppBrioFieldNumber = 2,
-    kAppDioFieldNumber = 3,
-    kAppDrioFieldNumber = 4,
-    kAppMioFieldNumber = 5,
-    kAppMrioFieldNumber = 6,
-    kAppRioFieldNumber = 7,
-    kAppWioFieldNumber = 8,
-    kDevFieldNumber = 9,
-    kFsCdrioFieldNumber = 10,
-    kFsCpDioFieldNumber = 11,
-    kFsCpMioFieldNumber = 12,
-    kFsCpNioFieldNumber = 13,
-    kFsDioFieldNumber = 14,
-    kFsDiscardFieldNumber = 15,
-    kFsDrioFieldNumber = 16,
-    kFsGcDioFieldNumber = 17,
-    kFsGcNioFieldNumber = 18,
-    kFsGdrioFieldNumber = 19,
-    kFsMioFieldNumber = 20,
-    kFsMrioFieldNumber = 21,
-    kFsNioFieldNumber = 22,
-    kFsNrioFieldNumber = 23,
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kBlockFieldNumber = 3,
+    kLenFieldNumber = 4,
+    kLogicalFieldNumber = 5,
+    kLleftFieldNumber = 6,
+    kLrightFieldNumber = 7,
+    kGoalFieldNumber = 8,
+    kPleftFieldNumber = 9,
+    kPrightFieldNumber = 10,
+    kFlagsFieldNumber = 11,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsIostatFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4AllocateBlocksFtraceEvent"; }
 
 
-  using FieldMetadata_AppBio =
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsIostatFtraceEvent>;
+      Ext4AllocateBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AppBio kAppBio() { return {}; }
-  void set_app_bio(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AppBio::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -93227,24 +123989,17 @@ class F2fsIostatFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_AppBrio =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsIostatFtraceEvent>;
+      Ext4AllocateBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AppBrio kAppBrio() { return {}; }
-  void set_app_brio(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AppBrio::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -93252,24 +124007,17 @@ class F2fsIostatFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_AppDio =
+  using FieldMetadata_Block =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsIostatFtraceEvent>;
+      Ext4AllocateBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AppDio kAppDio() { return {}; }
-  void set_app_dio(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AppDio::kFieldId;
+  static constexpr FieldMetadata_Block kBlock{};
+  void set_block(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Block::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -93277,124 +124025,89 @@ class F2fsIostatFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_AppDrio =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsIostatFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4AllocateBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AppDrio kAppDrio() { return {}; }
-  void set_app_drio(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AppDrio::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_AppMio =
+  using FieldMetadata_Logical =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsIostatFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4AllocateBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AppMio kAppMio() { return {}; }
-  void set_app_mio(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AppMio::kFieldId;
+  static constexpr FieldMetadata_Logical kLogical{};
+  void set_logical(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Logical::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_AppMrio =
+  using FieldMetadata_Lleft =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsIostatFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4AllocateBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AppMrio kAppMrio() { return {}; }
-  void set_app_mrio(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AppMrio::kFieldId;
+  static constexpr FieldMetadata_Lleft kLleft{};
+  void set_lleft(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lleft::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_AppRio =
+  using FieldMetadata_Lright =
     ::protozero::proto_utils::FieldMetadata<
       7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsIostatFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4AllocateBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AppRio kAppRio() { return {}; }
-  void set_app_rio(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AppRio::kFieldId;
+  static constexpr FieldMetadata_Lright kLright{};
+  void set_lright(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lright::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_AppWio =
+  using FieldMetadata_Goal =
     ::protozero::proto_utils::FieldMetadata<
       8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsIostatFtraceEvent>;
+      Ext4AllocateBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AppWio kAppWio() { return {}; }
-  void set_app_wio(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AppWio::kFieldId;
+  static constexpr FieldMetadata_Goal kGoal{};
+  void set_goal(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Goal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -93402,24 +124115,17 @@ class F2fsIostatFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_Pleft =
     ::protozero::proto_utils::FieldMetadata<
       9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsIostatFtraceEvent>;
+      Ext4AllocateBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_Pleft kPleft{};
+  void set_pleft(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pleft::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -93427,24 +124133,17 @@ class F2fsIostatFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FsCdrio =
+  using FieldMetadata_Pright =
     ::protozero::proto_utils::FieldMetadata<
       10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsIostatFtraceEvent>;
+      Ext4AllocateBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FsCdrio kFsCdrio() { return {}; }
-  void set_fs_cdrio(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FsCdrio::kFieldId;
+  static constexpr FieldMetadata_Pright kPright{};
+  void set_pright(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pright::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -93452,24 +124151,63 @@ class F2fsIostatFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FsCpDio =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4AllocateBlocksFtraceEvent>;
+
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class Ext4AllocDaBlocksFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  Ext4AllocDaBlocksFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4AllocDaBlocksFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4AllocDaBlocksFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_data_blocks() const { return at<3>().valid(); }
+  uint32_t data_blocks() const { return at<3>().as_uint32(); }
+  bool has_meta_blocks() const { return at<4>().valid(); }
+  uint32_t meta_blocks() const { return at<4>().as_uint32(); }
+};
+
+class Ext4AllocDaBlocksFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4AllocDaBlocksFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kDataBlocksFieldNumber = 3,
+    kMetaBlocksFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4AllocDaBlocksFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsIostatFtraceEvent>;
+      Ext4AllocDaBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FsCpDio kFsCpDio() { return {}; }
-  void set_fs_cp_dio(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FsCpDio::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -93477,24 +124215,17 @@ class F2fsIostatFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FsCpMio =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
-      12,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsIostatFtraceEvent>;
+      Ext4AllocDaBlocksFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FsCpMio kFsCpMio() { return {}; }
-  void set_fs_cp_mio(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FsCpMio::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -93502,24 +124233,78 @@ class F2fsIostatFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FsCpNio =
+  using FieldMetadata_DataBlocks =
     ::protozero::proto_utils::FieldMetadata<
-      13,
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4AllocDaBlocksFtraceEvent>;
+
+  static constexpr FieldMetadata_DataBlocks kDataBlocks{};
+  void set_data_blocks(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DataBlocks::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MetaBlocks =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4AllocDaBlocksFtraceEvent>;
+
+  static constexpr FieldMetadata_MetaBlocks kMetaBlocks{};
+  void set_meta_blocks(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MetaBlocks::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class Ext4SyncFileExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  Ext4SyncFileExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4SyncFileExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4SyncFileExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_ret() const { return at<3>().valid(); }
+  int32_t ret() const { return at<3>().as_int32(); }
+};
+
+class Ext4SyncFileExitFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4SyncFileExitFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kRetFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4SyncFileExitFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsIostatFtraceEvent>;
+      Ext4SyncFileExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FsCpNio kFsCpNio() { return {}; }
-  void set_fs_cp_nio(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FsCpNio::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -93527,49 +124312,81 @@ class F2fsIostatFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FsDio =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
-      14,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsIostatFtraceEvent>;
+      Ext4SyncFileExitFtraceEvent>;
+
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ret =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4SyncFileExitFtraceEvent>;
+
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class Ext4SyncFileEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  Ext4SyncFileEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4SyncFileEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4SyncFileEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_parent() const { return at<3>().valid(); }
+  uint64_t parent() const { return at<3>().as_uint64(); }
+  bool has_datasync() const { return at<4>().valid(); }
+  int32_t datasync() const { return at<4>().as_int32(); }
+};
+
+class Ext4SyncFileEnterFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4SyncFileEnterFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kParentFieldNumber = 3,
+    kDatasyncFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4SyncFileEnterFtraceEvent"; }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FsDio kFsDio() { return {}; }
-  void set_fs_dio(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FsDio::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
 
-  using FieldMetadata_FsDiscard =
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      15,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsIostatFtraceEvent>;
+      Ext4SyncFileEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FsDiscard kFsDiscard() { return {}; }
-  void set_fs_discard(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FsDiscard::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -93577,24 +124394,17 @@ class F2fsIostatFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FsDrio =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
-      16,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsIostatFtraceEvent>;
+      Ext4SyncFileEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FsDrio kFsDrio() { return {}; }
-  void set_fs_drio(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FsDrio::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -93602,24 +124412,17 @@ class F2fsIostatFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FsGcDio =
+  using FieldMetadata_Parent =
     ::protozero::proto_utils::FieldMetadata<
-      17,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsIostatFtraceEvent>;
+      Ext4SyncFileEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FsGcDio kFsGcDio() { return {}; }
-  void set_fs_gc_dio(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FsGcDio::kFieldId;
+  static constexpr FieldMetadata_Parent kParent{};
+  void set_parent(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Parent::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -93627,49 +124430,66 @@ class F2fsIostatFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FsGcNio =
+  using FieldMetadata_Datasync =
     ::protozero::proto_utils::FieldMetadata<
-      18,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsIostatFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Ext4SyncFileEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FsGcNio kFsGcNio() { return {}; }
-  void set_fs_gc_nio(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FsGcNio::kFieldId;
+  static constexpr FieldMetadata_Datasync kDatasync{};
+  void set_datasync(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Datasync::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_FsGdrio =
+class Ext4DaWriteEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  Ext4DaWriteEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4DaWriteEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4DaWriteEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_pos() const { return at<3>().valid(); }
+  int64_t pos() const { return at<3>().as_int64(); }
+  bool has_len() const { return at<4>().valid(); }
+  uint32_t len() const { return at<4>().as_uint32(); }
+  bool has_copied() const { return at<5>().valid(); }
+  uint32_t copied() const { return at<5>().as_uint32(); }
+};
+
+class Ext4DaWriteEndFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = Ext4DaWriteEndFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kPosFieldNumber = 3,
+    kLenFieldNumber = 4,
+    kCopiedFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DaWriteEndFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      19,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsIostatFtraceEvent>;
+      Ext4DaWriteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FsGdrio kFsGdrio() { return {}; }
-  void set_fs_gdrio(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FsGdrio::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -93677,24 +124497,17 @@ class F2fsIostatFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FsMio =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
-      20,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsIostatFtraceEvent>;
+      Ext4DaWriteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FsMio kFsMio() { return {}; }
-  void set_fs_mio(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FsMio::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -93702,87 +124515,66 @@ class F2fsIostatFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FsMrio =
+  using FieldMetadata_Pos =
     ::protozero::proto_utils::FieldMetadata<
-      21,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsIostatFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Ext4DaWriteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FsMrio kFsMrio() { return {}; }
-  void set_fs_mrio(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FsMrio::kFieldId;
+  static constexpr FieldMetadata_Pos kPos{};
+  void set_pos(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FsNio =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
-      22,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsIostatFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4DaWriteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FsNio kFsNio() { return {}; }
-  void set_fs_nio(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FsNio::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FsNrio =
+  using FieldMetadata_Copied =
     ::protozero::proto_utils::FieldMetadata<
-      23,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsIostatFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Ext4DaWriteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FsNrio kFsNrio() { return {}; }
-  void set_fs_nrio(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FsNrio::kFieldId;
+  static constexpr FieldMetadata_Copied kCopied{};
+  void set_copied(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Copied::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class F2fsWriteEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Ext4DaWriteBeginFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  F2fsWriteEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsWriteEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsWriteEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Ext4DaWriteBeginFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Ext4DaWriteBeginFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Ext4DaWriteBeginFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
@@ -93791,21 +124583,21 @@ class F2fsWriteEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*
   int64_t pos() const { return at<3>().as_int64(); }
   bool has_len() const { return at<4>().valid(); }
   uint32_t len() const { return at<4>().as_uint32(); }
-  bool has_copied() const { return at<5>().valid(); }
-  uint32_t copied() const { return at<5>().as_uint32(); }
+  bool has_flags() const { return at<5>().valid(); }
+  uint32_t flags() const { return at<5>().as_uint32(); }
 };
 
-class F2fsWriteEndFtraceEvent : public ::protozero::Message {
+class Ext4DaWriteBeginFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = F2fsWriteEndFtraceEvent_Decoder;
+  using Decoder = Ext4DaWriteBeginFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
     kPosFieldNumber = 3,
     kLenFieldNumber = 4,
-    kCopiedFieldNumber = 5,
+    kFlagsFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsWriteEndFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Ext4DaWriteBeginFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -93814,16 +124606,9 @@ class F2fsWriteEndFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsWriteEndFtraceEvent>;
+      Ext4DaWriteBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -93839,16 +124624,9 @@ class F2fsWriteEndFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsWriteEndFtraceEvent>;
+      Ext4DaWriteBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -93864,16 +124642,9 @@ class F2fsWriteEndFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt64,
       int64_t,
-      F2fsWriteEndFtraceEvent>;
+      Ext4DaWriteBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pos kPos() { return {}; }
+  static constexpr FieldMetadata_Pos kPos{};
   void set_pos(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -93889,16 +124660,9 @@ class F2fsWriteEndFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      F2fsWriteEndFtraceEvent>;
+      Ext4DaWriteBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
+  static constexpr FieldMetadata_Len kLen{};
   void set_len(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -93908,24 +124672,17 @@ class F2fsWriteEndFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Copied =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      F2fsWriteEndFtraceEvent>;
+      Ext4DaWriteBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Copied kCopied() { return {}; }
-  void set_copied(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Copied::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -93934,31 +124691,76 @@ class F2fsWriteEndFtraceEvent : public ::protozero::Message {
   }
 };
 
-class F2fsWriteCheckpointFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/f2fs.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_F2FS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_F2FS_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class F2fsGcEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11> {
  public:
-  F2fsWriteCheckpointFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsWriteCheckpointFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsWriteCheckpointFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  F2fsGcEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsGcEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsGcEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_is_umount() const { return at<2>().valid(); }
-  uint32_t is_umount() const { return at<2>().as_uint32(); }
-  bool has_msg() const { return at<3>().valid(); }
-  ::protozero::ConstChars msg() const { return at<3>().as_string(); }
-  bool has_reason() const { return at<4>().valid(); }
-  int32_t reason() const { return at<4>().as_int32(); }
-};
-
-class F2fsWriteCheckpointFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = F2fsWriteCheckpointFtraceEvent_Decoder;
+  bool has_ret() const { return at<2>().valid(); }
+  int32_t ret() const { return at<2>().as_int32(); }
+  bool has_seg_freed() const { return at<3>().valid(); }
+  int32_t seg_freed() const { return at<3>().as_int32(); }
+  bool has_sec_freed() const { return at<4>().valid(); }
+  int32_t sec_freed() const { return at<4>().as_int32(); }
+  bool has_dirty_nodes() const { return at<5>().valid(); }
+  int64_t dirty_nodes() const { return at<5>().as_int64(); }
+  bool has_dirty_dents() const { return at<6>().valid(); }
+  int64_t dirty_dents() const { return at<6>().as_int64(); }
+  bool has_dirty_imeta() const { return at<7>().valid(); }
+  int64_t dirty_imeta() const { return at<7>().as_int64(); }
+  bool has_free_sec() const { return at<8>().valid(); }
+  uint32_t free_sec() const { return at<8>().as_uint32(); }
+  bool has_free_seg() const { return at<9>().valid(); }
+  uint32_t free_seg() const { return at<9>().as_uint32(); }
+  bool has_reserved_seg() const { return at<10>().valid(); }
+  int32_t reserved_seg() const { return at<10>().as_int32(); }
+  bool has_prefree_seg() const { return at<11>().valid(); }
+  uint32_t prefree_seg() const { return at<11>().as_uint32(); }
+};
+
+class F2fsGcEndFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = F2fsGcEndFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
-    kIsUmountFieldNumber = 2,
-    kMsgFieldNumber = 3,
-    kReasonFieldNumber = 4,
+    kRetFieldNumber = 2,
+    kSegFreedFieldNumber = 3,
+    kSecFreedFieldNumber = 4,
+    kDirtyNodesFieldNumber = 5,
+    kDirtyDentsFieldNumber = 6,
+    kDirtyImetaFieldNumber = 7,
+    kFreeSecFieldNumber = 8,
+    kFreeSegFieldNumber = 9,
+    kReservedSegFieldNumber = 10,
+    kPrefreeSegFieldNumber = 11,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsWriteCheckpointFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsGcEndFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -93967,16 +124769,9 @@ class F2fsWriteCheckpointFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsWriteCheckpointFtraceEvent>;
+      F2fsGcEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -93986,186 +124781,107 @@ class F2fsWriteCheckpointFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IsUmount =
+  using FieldMetadata_Ret =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsWriteCheckpointFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsGcEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IsUmount kIsUmount() { return {}; }
-  void set_is_umount(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IsUmount::kFieldId;
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Msg =
+  using FieldMetadata_SegFreed =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      F2fsWriteCheckpointFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsGcEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Msg kMsg() { return {}; }
-  void set_msg(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Msg::kFieldId, data, size);
-  }
-  void set_msg(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Msg::kFieldId, chars.data, chars.size);
-  }
-  void set_msg(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Msg::kFieldId;
+  static constexpr FieldMetadata_SegFreed kSegFreed{};
+  void set_seg_freed(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SegFreed::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Reason =
+  using FieldMetadata_SecFreed =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      F2fsWriteCheckpointFtraceEvent>;
+      F2fsGcEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Reason kReason() { return {}; }
-  void set_reason(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Reason::kFieldId;
+  static constexpr FieldMetadata_SecFreed kSecFreed{};
+  void set_sec_freed(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SecFreed::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-class F2fsWriteBeginFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  F2fsWriteBeginFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsWriteBeginFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsWriteBeginFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_pos() const { return at<3>().valid(); }
-  int64_t pos() const { return at<3>().as_int64(); }
-  bool has_len() const { return at<4>().valid(); }
-  uint32_t len() const { return at<4>().as_uint32(); }
-  bool has_flags() const { return at<5>().valid(); }
-  uint32_t flags() const { return at<5>().as_uint32(); }
-};
-
-class F2fsWriteBeginFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = F2fsWriteBeginFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kPosFieldNumber = 3,
-    kLenFieldNumber = 4,
-    kFlagsFieldNumber = 5,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsWriteBeginFtraceEvent"; }
-
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_DirtyNodes =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsWriteBeginFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      F2fsGcEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_DirtyNodes kDirtyNodes{};
+  void set_dirty_nodes(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DirtyNodes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_DirtyDents =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsWriteBeginFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      F2fsGcEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_DirtyDents kDirtyDents{};
+  void set_dirty_dents(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DirtyDents::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pos =
+  using FieldMetadata_DirtyImeta =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt64,
       int64_t,
-      F2fsWriteBeginFtraceEvent>;
+      F2fsGcEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pos kPos() { return {}; }
-  void set_pos(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId;
+  static constexpr FieldMetadata_DirtyImeta kDirtyImeta{};
+  void set_dirty_imeta(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DirtyImeta::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -94173,24 +124889,17 @@ class F2fsWriteBeginFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_FreeSec =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      F2fsWriteBeginFtraceEvent>;
+      F2fsGcEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_FreeSec kFreeSec{};
+  void set_free_sec(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FreeSec::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -94198,24 +124907,53 @@ class F2fsWriteBeginFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_FreeSeg =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      F2fsWriteBeginFtraceEvent>;
+      F2fsGcEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_FreeSeg kFreeSeg{};
+  void set_free_seg(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FreeSeg::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ReservedSeg =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsGcEndFtraceEvent>;
+
+  static constexpr FieldMetadata_ReservedSeg kReservedSeg{};
+  void set_reserved_seg(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReservedSeg::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PrefreeSeg =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsGcEndFtraceEvent>;
+
+  static constexpr FieldMetadata_PrefreeSeg kPrefreeSeg{};
+  void set_prefree_seg(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PrefreeSeg::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -94224,40 +124962,58 @@ class F2fsWriteBeginFtraceEvent : public ::protozero::Message {
   }
 };
 
-class F2fsVmPageMkwriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsGcBeginFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/13> {
  public:
-  F2fsVmPageMkwriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsVmPageMkwriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsVmPageMkwriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  F2fsGcBeginFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsGcBeginFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsGcBeginFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_type() const { return at<3>().valid(); }
-  int32_t type() const { return at<3>().as_int32(); }
-  bool has_dir() const { return at<4>().valid(); }
-  int32_t dir() const { return at<4>().as_int32(); }
-  bool has_index() const { return at<5>().valid(); }
-  uint64_t index() const { return at<5>().as_uint64(); }
-  bool has_dirty() const { return at<6>().valid(); }
-  int32_t dirty() const { return at<6>().as_int32(); }
-  bool has_uptodate() const { return at<7>().valid(); }
-  int32_t uptodate() const { return at<7>().as_int32(); }
-};
-
-class F2fsVmPageMkwriteFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = F2fsVmPageMkwriteFtraceEvent_Decoder;
+  bool has_sync() const { return at<2>().valid(); }
+  uint32_t sync() const { return at<2>().as_uint32(); }
+  bool has_background() const { return at<3>().valid(); }
+  uint32_t background() const { return at<3>().as_uint32(); }
+  bool has_dirty_nodes() const { return at<4>().valid(); }
+  int64_t dirty_nodes() const { return at<4>().as_int64(); }
+  bool has_dirty_dents() const { return at<5>().valid(); }
+  int64_t dirty_dents() const { return at<5>().as_int64(); }
+  bool has_dirty_imeta() const { return at<6>().valid(); }
+  int64_t dirty_imeta() const { return at<6>().as_int64(); }
+  bool has_free_sec() const { return at<7>().valid(); }
+  uint32_t free_sec() const { return at<7>().as_uint32(); }
+  bool has_free_seg() const { return at<8>().valid(); }
+  uint32_t free_seg() const { return at<8>().as_uint32(); }
+  bool has_reserved_seg() const { return at<9>().valid(); }
+  int32_t reserved_seg() const { return at<9>().as_int32(); }
+  bool has_prefree_seg() const { return at<10>().valid(); }
+  uint32_t prefree_seg() const { return at<10>().as_uint32(); }
+  bool has_gc_type() const { return at<11>().valid(); }
+  int32_t gc_type() const { return at<11>().as_int32(); }
+  bool has_no_bg_gc() const { return at<12>().valid(); }
+  uint32_t no_bg_gc() const { return at<12>().as_uint32(); }
+  bool has_nr_free_secs() const { return at<13>().valid(); }
+  uint32_t nr_free_secs() const { return at<13>().as_uint32(); }
+};
+
+class F2fsGcBeginFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = F2fsGcBeginFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kTypeFieldNumber = 3,
-    kDirFieldNumber = 4,
-    kIndexFieldNumber = 5,
-    kDirtyFieldNumber = 6,
-    kUptodateFieldNumber = 7,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsVmPageMkwriteFtraceEvent"; }
+    kSyncFieldNumber = 2,
+    kBackgroundFieldNumber = 3,
+    kDirtyNodesFieldNumber = 4,
+    kDirtyDentsFieldNumber = 5,
+    kDirtyImetaFieldNumber = 6,
+    kFreeSecFieldNumber = 7,
+    kFreeSegFieldNumber = 8,
+    kReservedSegFieldNumber = 9,
+    kPrefreeSegFieldNumber = 10,
+    kGcTypeFieldNumber = 11,
+    kNoBgGcFieldNumber = 12,
+    kNrFreeSecsFieldNumber = 13,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsGcBeginFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -94266,16 +125022,9 @@ class F2fsVmPageMkwriteFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsVmPageMkwriteFtraceEvent>;
+      F2fsGcBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -94285,285 +125034,248 @@ class F2fsVmPageMkwriteFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_Sync =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsVmPageMkwriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsGcBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_Sync kSync{};
+  void set_sync(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Sync::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Type =
+  using FieldMetadata_Background =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsVmPageMkwriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsGcBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+  static constexpr FieldMetadata_Background kBackground{};
+  void set_background(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Background::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Dir =
+  using FieldMetadata_DirtyNodes =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsVmPageMkwriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      F2fsGcBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dir kDir() { return {}; }
-  void set_dir(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dir::kFieldId;
+  static constexpr FieldMetadata_DirtyNodes kDirtyNodes{};
+  void set_dirty_nodes(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DirtyNodes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Index =
+  using FieldMetadata_DirtyDents =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsVmPageMkwriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      F2fsGcBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Index kIndex() { return {}; }
-  void set_index(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
+  static constexpr FieldMetadata_DirtyDents kDirtyDents{};
+  void set_dirty_dents(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DirtyDents::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Dirty =
+  using FieldMetadata_DirtyImeta =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsVmPageMkwriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      F2fsGcBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dirty kDirty() { return {}; }
-  void set_dirty(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dirty::kFieldId;
+  static constexpr FieldMetadata_DirtyImeta kDirtyImeta{};
+  void set_dirty_imeta(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DirtyImeta::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Uptodate =
+  using FieldMetadata_FreeSec =
     ::protozero::proto_utils::FieldMetadata<
       7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsVmPageMkwriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsGcBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Uptodate kUptodate() { return {}; }
-  void set_uptodate(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Uptodate::kFieldId;
+  static constexpr FieldMetadata_FreeSec kFreeSec{};
+  void set_free_sec(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FreeSec::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class F2fsUnlinkExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  F2fsUnlinkExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsUnlinkExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsUnlinkExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_ret() const { return at<3>().valid(); }
-  int32_t ret() const { return at<3>().as_int32(); }
-};
 
-class F2fsUnlinkExitFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = F2fsUnlinkExitFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kRetFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsUnlinkExitFtraceEvent"; }
+  using FieldMetadata_FreeSeg =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsGcBeginFtraceEvent>;
 
+  static constexpr FieldMetadata_FreeSeg kFreeSeg{};
+  void set_free_seg(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FreeSeg::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_ReservedSeg =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsUnlinkExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsGcBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_ReservedSeg kReservedSeg{};
+  void set_reserved_seg(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReservedSeg::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_PrefreeSeg =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsUnlinkExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsGcBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_PrefreeSeg kPrefreeSeg{};
+  void set_prefree_seg(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PrefreeSeg::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ret =
+  using FieldMetadata_GcType =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      F2fsUnlinkExitFtraceEvent>;
+      F2fsGcBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+  static constexpr FieldMetadata_GcType kGcType{};
+  void set_gc_type(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GcType::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_NoBgGc =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsGcBeginFtraceEvent>;
+
+  static constexpr FieldMetadata_NoBgGc kNoBgGc{};
+  void set_no_bg_gc(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NoBgGc::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NrFreeSecs =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsGcBeginFtraceEvent>;
+
+  static constexpr FieldMetadata_NrFreeSecs kNrFreeSecs{};
+  void set_nr_free_secs(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NrFreeSecs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class F2fsUnlinkEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsBackgroundGcFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  F2fsUnlinkEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsUnlinkEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsUnlinkEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  F2fsBackgroundGcFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsBackgroundGcFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsBackgroundGcFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_size() const { return at<3>().valid(); }
-  int64_t size() const { return at<3>().as_int64(); }
-  bool has_blocks() const { return at<4>().valid(); }
-  uint64_t blocks() const { return at<4>().as_uint64(); }
-  bool has_name() const { return at<5>().valid(); }
-  ::protozero::ConstChars name() const { return at<5>().as_string(); }
+  bool has_wait_ms() const { return at<2>().valid(); }
+  uint32_t wait_ms() const { return at<2>().as_uint32(); }
+  bool has_prefree() const { return at<3>().valid(); }
+  uint32_t prefree() const { return at<3>().as_uint32(); }
+  bool has_free() const { return at<4>().valid(); }
+  uint32_t free() const { return at<4>().as_uint32(); }
 };
 
-class F2fsUnlinkEnterFtraceEvent : public ::protozero::Message {
+class F2fsBackgroundGcFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = F2fsUnlinkEnterFtraceEvent_Decoder;
+  using Decoder = F2fsBackgroundGcFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kSizeFieldNumber = 3,
-    kBlocksFieldNumber = 4,
-    kNameFieldNumber = 5,
+    kWaitMsFieldNumber = 2,
+    kPrefreeFieldNumber = 3,
+    kFreeFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsUnlinkEnterFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsBackgroundGcFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -94572,16 +125284,9 @@ class F2fsUnlinkEnterFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsUnlinkEnterFtraceEvent>;
+      F2fsBackgroundGcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -94591,211 +125296,207 @@ class F2fsUnlinkEnterFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_WaitMs =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsUnlinkEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsBackgroundGcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_WaitMs kWaitMs{};
+  void set_wait_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_WaitMs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Size =
+  using FieldMetadata_Prefree =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      F2fsUnlinkEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsBackgroundGcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Size kSize() { return {}; }
-  void set_size(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
+  static constexpr FieldMetadata_Prefree kPrefree{};
+  void set_prefree(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prefree::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Blocks =
+  using FieldMetadata_Free =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsUnlinkEnterFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Blocks kBlocks() { return {}; }
-  void set_blocks(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Name =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      F2fsUnlinkEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsBackgroundGcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_Free kFree{};
+  void set_free(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Free::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class F2fsTruncatePartialNodesFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsIostatLatencyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/28> {
  public:
-  F2fsTruncatePartialNodesFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsTruncatePartialNodesFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsTruncatePartialNodesFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_nid() const { return at<3>().valid(); }
-  uint32_t nid() const { return at<3>().as_uint32(); }
-  bool has_depth() const { return at<4>().valid(); }
-  int32_t depth() const { return at<4>().as_int32(); }
-  bool has_err() const { return at<5>().valid(); }
-  int32_t err() const { return at<5>().as_int32(); }
+  F2fsIostatLatencyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsIostatLatencyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsIostatLatencyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_d_rd_avg() const { return at<1>().valid(); }
+  uint32_t d_rd_avg() const { return at<1>().as_uint32(); }
+  bool has_d_rd_cnt() const { return at<2>().valid(); }
+  uint32_t d_rd_cnt() const { return at<2>().as_uint32(); }
+  bool has_d_rd_peak() const { return at<3>().valid(); }
+  uint32_t d_rd_peak() const { return at<3>().as_uint32(); }
+  bool has_d_wr_as_avg() const { return at<4>().valid(); }
+  uint32_t d_wr_as_avg() const { return at<4>().as_uint32(); }
+  bool has_d_wr_as_cnt() const { return at<5>().valid(); }
+  uint32_t d_wr_as_cnt() const { return at<5>().as_uint32(); }
+  bool has_d_wr_as_peak() const { return at<6>().valid(); }
+  uint32_t d_wr_as_peak() const { return at<6>().as_uint32(); }
+  bool has_d_wr_s_avg() const { return at<7>().valid(); }
+  uint32_t d_wr_s_avg() const { return at<7>().as_uint32(); }
+  bool has_d_wr_s_cnt() const { return at<8>().valid(); }
+  uint32_t d_wr_s_cnt() const { return at<8>().as_uint32(); }
+  bool has_d_wr_s_peak() const { return at<9>().valid(); }
+  uint32_t d_wr_s_peak() const { return at<9>().as_uint32(); }
+  bool has_dev() const { return at<10>().valid(); }
+  uint64_t dev() const { return at<10>().as_uint64(); }
+  bool has_m_rd_avg() const { return at<11>().valid(); }
+  uint32_t m_rd_avg() const { return at<11>().as_uint32(); }
+  bool has_m_rd_cnt() const { return at<12>().valid(); }
+  uint32_t m_rd_cnt() const { return at<12>().as_uint32(); }
+  bool has_m_rd_peak() const { return at<13>().valid(); }
+  uint32_t m_rd_peak() const { return at<13>().as_uint32(); }
+  bool has_m_wr_as_avg() const { return at<14>().valid(); }
+  uint32_t m_wr_as_avg() const { return at<14>().as_uint32(); }
+  bool has_m_wr_as_cnt() const { return at<15>().valid(); }
+  uint32_t m_wr_as_cnt() const { return at<15>().as_uint32(); }
+  bool has_m_wr_as_peak() const { return at<16>().valid(); }
+  uint32_t m_wr_as_peak() const { return at<16>().as_uint32(); }
+  bool has_m_wr_s_avg() const { return at<17>().valid(); }
+  uint32_t m_wr_s_avg() const { return at<17>().as_uint32(); }
+  bool has_m_wr_s_cnt() const { return at<18>().valid(); }
+  uint32_t m_wr_s_cnt() const { return at<18>().as_uint32(); }
+  bool has_m_wr_s_peak() const { return at<19>().valid(); }
+  uint32_t m_wr_s_peak() const { return at<19>().as_uint32(); }
+  bool has_n_rd_avg() const { return at<20>().valid(); }
+  uint32_t n_rd_avg() const { return at<20>().as_uint32(); }
+  bool has_n_rd_cnt() const { return at<21>().valid(); }
+  uint32_t n_rd_cnt() const { return at<21>().as_uint32(); }
+  bool has_n_rd_peak() const { return at<22>().valid(); }
+  uint32_t n_rd_peak() const { return at<22>().as_uint32(); }
+  bool has_n_wr_as_avg() const { return at<23>().valid(); }
+  uint32_t n_wr_as_avg() const { return at<23>().as_uint32(); }
+  bool has_n_wr_as_cnt() const { return at<24>().valid(); }
+  uint32_t n_wr_as_cnt() const { return at<24>().as_uint32(); }
+  bool has_n_wr_as_peak() const { return at<25>().valid(); }
+  uint32_t n_wr_as_peak() const { return at<25>().as_uint32(); }
+  bool has_n_wr_s_avg() const { return at<26>().valid(); }
+  uint32_t n_wr_s_avg() const { return at<26>().as_uint32(); }
+  bool has_n_wr_s_cnt() const { return at<27>().valid(); }
+  uint32_t n_wr_s_cnt() const { return at<27>().as_uint32(); }
+  bool has_n_wr_s_peak() const { return at<28>().valid(); }
+  uint32_t n_wr_s_peak() const { return at<28>().as_uint32(); }
 };
 
-class F2fsTruncatePartialNodesFtraceEvent : public ::protozero::Message {
+class F2fsIostatLatencyFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = F2fsTruncatePartialNodesFtraceEvent_Decoder;
+  using Decoder = F2fsIostatLatencyFtraceEvent_Decoder;
   enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kNidFieldNumber = 3,
-    kDepthFieldNumber = 4,
-    kErrFieldNumber = 5,
+    kDRdAvgFieldNumber = 1,
+    kDRdCntFieldNumber = 2,
+    kDRdPeakFieldNumber = 3,
+    kDWrAsAvgFieldNumber = 4,
+    kDWrAsCntFieldNumber = 5,
+    kDWrAsPeakFieldNumber = 6,
+    kDWrSAvgFieldNumber = 7,
+    kDWrSCntFieldNumber = 8,
+    kDWrSPeakFieldNumber = 9,
+    kDevFieldNumber = 10,
+    kMRdAvgFieldNumber = 11,
+    kMRdCntFieldNumber = 12,
+    kMRdPeakFieldNumber = 13,
+    kMWrAsAvgFieldNumber = 14,
+    kMWrAsCntFieldNumber = 15,
+    kMWrAsPeakFieldNumber = 16,
+    kMWrSAvgFieldNumber = 17,
+    kMWrSCntFieldNumber = 18,
+    kMWrSPeakFieldNumber = 19,
+    kNRdAvgFieldNumber = 20,
+    kNRdCntFieldNumber = 21,
+    kNRdPeakFieldNumber = 22,
+    kNWrAsAvgFieldNumber = 23,
+    kNWrAsCntFieldNumber = 24,
+    kNWrAsPeakFieldNumber = 25,
+    kNWrSAvgFieldNumber = 26,
+    kNWrSCntFieldNumber = 27,
+    kNWrSPeakFieldNumber = 28,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncatePartialNodesFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsIostatLatencyFtraceEvent"; }
 
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_DRdAvg =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsTruncatePartialNodesFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_DRdAvg kDRdAvg{};
+  void set_d_rd_avg(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DRdAvg::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_DRdCnt =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsTruncatePartialNodesFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_DRdCnt kDRdCnt{};
+  void set_d_rd_cnt(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DRdCnt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Nid =
+  using FieldMetadata_DRdPeak =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      F2fsTruncatePartialNodesFtraceEvent>;
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nid kNid() { return {}; }
-  void set_nid(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
+  static constexpr FieldMetadata_DRdPeak kDRdPeak{};
+  void set_d_rd_peak(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DRdPeak::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -94803,200 +125504,123 @@ class F2fsTruncatePartialNodesFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Depth =
+  using FieldMetadata_DWrAsAvg =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsTruncatePartialNodesFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Depth kDepth() { return {}; }
-  void set_depth(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Depth::kFieldId;
+  static constexpr FieldMetadata_DWrAsAvg kDWrAsAvg{};
+  void set_d_wr_as_avg(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DWrAsAvg::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Err =
+  using FieldMetadata_DWrAsCnt =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsTruncatePartialNodesFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Err kErr() { return {}; }
-  void set_err(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Err::kFieldId;
+  static constexpr FieldMetadata_DWrAsCnt kDWrAsCnt{};
+  void set_d_wr_as_cnt(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DWrAsCnt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class F2fsTruncateNodesExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  F2fsTruncateNodesExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsTruncateNodesExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsTruncateNodesExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_ret() const { return at<3>().valid(); }
-  int32_t ret() const { return at<3>().as_int32(); }
-};
-
-class F2fsTruncateNodesExitFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = F2fsTruncateNodesExitFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kRetFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateNodesExitFtraceEvent"; }
 
-
-  using FieldMetadata_Dev =
+  using FieldMetadata_DWrAsPeak =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsTruncateNodesExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_DWrAsPeak kDWrAsPeak{};
+  void set_d_wr_as_peak(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DWrAsPeak::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_DWrSAvg =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsTruncateNodesExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_DWrSAvg kDWrSAvg{};
+  void set_d_wr_s_avg(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DWrSAvg::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ret =
+  using FieldMetadata_DWrSCnt =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsTruncateNodesExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+  static constexpr FieldMetadata_DWrSCnt kDWrSCnt{};
+  void set_d_wr_s_cnt(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DWrSCnt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class F2fsTruncateNodesEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  F2fsTruncateNodesEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsTruncateNodesEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsTruncateNodesEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_nid() const { return at<3>().valid(); }
-  uint32_t nid() const { return at<3>().as_uint32(); }
-  bool has_blk_addr() const { return at<4>().valid(); }
-  uint32_t blk_addr() const { return at<4>().as_uint32(); }
-};
 
-class F2fsTruncateNodesEnterFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = F2fsTruncateNodesEnterFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kNidFieldNumber = 3,
-    kBlkAddrFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateNodesEnterFtraceEvent"; }
+  using FieldMetadata_DWrSPeak =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsIostatLatencyFtraceEvent>;
 
+  static constexpr FieldMetadata_DWrSPeak kDWrSPeak{};
+  void set_d_wr_s_peak(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DWrSPeak::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
   using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsTruncateNodesEnterFtraceEvent>;
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -95006,49 +125630,35 @@ class F2fsTruncateNodesEnterFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_MRdAvg =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsTruncateNodesEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_MRdAvg kMRdAvg{};
+  void set_m_rd_avg(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MRdAvg::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Nid =
+  using FieldMetadata_MRdCnt =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      12,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      F2fsTruncateNodesEnterFtraceEvent>;
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nid kNid() { return {}; }
-  void set_nid(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
+  static constexpr FieldMetadata_MRdCnt kMRdCnt{};
+  void set_m_rd_cnt(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MRdCnt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -95056,127 +125666,125 @@ class F2fsTruncateNodesEnterFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BlkAddr =
+  using FieldMetadata_MRdPeak =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      13,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      F2fsTruncateNodesEnterFtraceEvent>;
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlkAddr kBlkAddr() { return {}; }
-  void set_blk_addr(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BlkAddr::kFieldId;
+  static constexpr FieldMetadata_MRdPeak kMRdPeak{};
+  void set_m_rd_peak(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MRdPeak::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
 
-class F2fsTruncateNodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  F2fsTruncateNodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsTruncateNodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsTruncateNodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_nid() const { return at<3>().valid(); }
-  uint32_t nid() const { return at<3>().as_uint32(); }
-  bool has_blk_addr() const { return at<4>().valid(); }
-  uint32_t blk_addr() const { return at<4>().as_uint32(); }
-};
+  using FieldMetadata_MWrAsAvg =
+    ::protozero::proto_utils::FieldMetadata<
+      14,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsIostatLatencyFtraceEvent>;
 
-class F2fsTruncateNodeFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = F2fsTruncateNodeFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kNidFieldNumber = 3,
-    kBlkAddrFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateNodeFtraceEvent"; }
+  static constexpr FieldMetadata_MWrAsAvg kMWrAsAvg{};
+  void set_m_wr_as_avg(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MWrAsAvg::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
+  using FieldMetadata_MWrAsCnt =
+    ::protozero::proto_utils::FieldMetadata<
+      15,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsIostatLatencyFtraceEvent>;
+
+  static constexpr FieldMetadata_MWrAsCnt kMWrAsCnt{};
+  void set_m_wr_as_cnt(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MWrAsCnt::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MWrAsPeak =
+    ::protozero::proto_utils::FieldMetadata<
+      16,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsIostatLatencyFtraceEvent>;
+
+  static constexpr FieldMetadata_MWrAsPeak kMWrAsPeak{};
+  void set_m_wr_as_peak(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MWrAsPeak::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_MWrSAvg =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      17,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsTruncateNodeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_MWrSAvg kMWrSAvg{};
+  void set_m_wr_s_avg(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MWrSAvg::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_MWrSCnt =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      18,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsTruncateNodeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_MWrSCnt kMWrSCnt{};
+  void set_m_wr_s_cnt(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MWrSCnt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Nid =
+  using FieldMetadata_MWrSPeak =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      19,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      F2fsTruncateNodeFtraceEvent>;
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nid kNid() { return {}; }
-  void set_nid(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
+  static constexpr FieldMetadata_MWrSPeak kMWrSPeak{};
+  void set_m_wr_s_peak(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MWrSPeak::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -95184,336 +125792,264 @@ class F2fsTruncateNodeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BlkAddr =
+  using FieldMetadata_NRdAvg =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      20,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      F2fsTruncateNodeFtraceEvent>;
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlkAddr kBlkAddr() { return {}; }
-  void set_blk_addr(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BlkAddr::kFieldId;
+  static constexpr FieldMetadata_NRdAvg kNRdAvg{};
+  void set_n_rd_avg(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NRdAvg::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class F2fsTruncateInodeBlocksExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  F2fsTruncateInodeBlocksExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsTruncateInodeBlocksExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsTruncateInodeBlocksExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_ret() const { return at<3>().valid(); }
-  int32_t ret() const { return at<3>().as_int32(); }
-};
-
-class F2fsTruncateInodeBlocksExitFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = F2fsTruncateInodeBlocksExitFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kRetFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateInodeBlocksExitFtraceEvent"; }
 
-
-  using FieldMetadata_Dev =
+  using FieldMetadata_NRdCnt =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      21,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsTruncateInodeBlocksExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_NRdCnt kNRdCnt{};
+  void set_n_rd_cnt(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NRdCnt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_NRdPeak =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      22,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsTruncateInodeBlocksExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_NRdPeak kNRdPeak{};
+  void set_n_rd_peak(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NRdPeak::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ret =
+  using FieldMetadata_NWrAsAvg =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      23,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsTruncateInodeBlocksExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+  static constexpr FieldMetadata_NWrAsAvg kNWrAsAvg{};
+  void set_n_wr_as_avg(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NWrAsAvg::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class F2fsTruncateInodeBlocksEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  F2fsTruncateInodeBlocksEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsTruncateInodeBlocksEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsTruncateInodeBlocksEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_size() const { return at<3>().valid(); }
-  int64_t size() const { return at<3>().as_int64(); }
-  bool has_blocks() const { return at<4>().valid(); }
-  uint64_t blocks() const { return at<4>().as_uint64(); }
-  bool has_from() const { return at<5>().valid(); }
-  uint64_t from() const { return at<5>().as_uint64(); }
-};
-
-class F2fsTruncateInodeBlocksEnterFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = F2fsTruncateInodeBlocksEnterFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kSizeFieldNumber = 3,
-    kBlocksFieldNumber = 4,
-    kFromFieldNumber = 5,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateInodeBlocksEnterFtraceEvent"; }
 
-
-  using FieldMetadata_Dev =
+  using FieldMetadata_NWrAsCnt =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      24,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsTruncateInodeBlocksEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_NWrAsCnt kNWrAsCnt{};
+  void set_n_wr_as_cnt(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NWrAsCnt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_NWrAsPeak =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      25,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsTruncateInodeBlocksEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_NWrAsPeak kNWrAsPeak{};
+  void set_n_wr_as_peak(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NWrAsPeak::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Size =
+  using FieldMetadata_NWrSAvg =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      26,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      F2fsTruncateInodeBlocksEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Size kSize() { return {}; }
-  void set_size(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
+  static constexpr FieldMetadata_NWrSAvg kNWrSAvg{};
+  void set_n_wr_s_avg(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NWrSAvg::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Blocks =
+  using FieldMetadata_NWrSCnt =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      27,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsTruncateInodeBlocksEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Blocks kBlocks() { return {}; }
-  void set_blocks(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
+  static constexpr FieldMetadata_NWrSCnt kNWrSCnt{};
+  void set_n_wr_s_cnt(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NWrSCnt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_From =
+  using FieldMetadata_NWrSPeak =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      28,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsTruncateInodeBlocksEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsIostatLatencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_From kFrom() { return {}; }
-  void set_from(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_From::kFieldId;
+  static constexpr FieldMetadata_NWrSPeak kNWrSPeak{};
+  void set_n_wr_s_peak(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NWrSPeak::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class F2fsTruncateDataBlocksRangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsIostatFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/23> {
  public:
-  F2fsTruncateDataBlocksRangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsTruncateDataBlocksRangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsTruncateDataBlocksRangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_nid() const { return at<3>().valid(); }
-  uint32_t nid() const { return at<3>().as_uint32(); }
-  bool has_ofs() const { return at<4>().valid(); }
-  uint32_t ofs() const { return at<4>().as_uint32(); }
-  bool has_free() const { return at<5>().valid(); }
-  int32_t free() const { return at<5>().as_int32(); }
+  F2fsIostatFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsIostatFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsIostatFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_app_bio() const { return at<1>().valid(); }
+  uint64_t app_bio() const { return at<1>().as_uint64(); }
+  bool has_app_brio() const { return at<2>().valid(); }
+  uint64_t app_brio() const { return at<2>().as_uint64(); }
+  bool has_app_dio() const { return at<3>().valid(); }
+  uint64_t app_dio() const { return at<3>().as_uint64(); }
+  bool has_app_drio() const { return at<4>().valid(); }
+  uint64_t app_drio() const { return at<4>().as_uint64(); }
+  bool has_app_mio() const { return at<5>().valid(); }
+  uint64_t app_mio() const { return at<5>().as_uint64(); }
+  bool has_app_mrio() const { return at<6>().valid(); }
+  uint64_t app_mrio() const { return at<6>().as_uint64(); }
+  bool has_app_rio() const { return at<7>().valid(); }
+  uint64_t app_rio() const { return at<7>().as_uint64(); }
+  bool has_app_wio() const { return at<8>().valid(); }
+  uint64_t app_wio() const { return at<8>().as_uint64(); }
+  bool has_dev() const { return at<9>().valid(); }
+  uint64_t dev() const { return at<9>().as_uint64(); }
+  bool has_fs_cdrio() const { return at<10>().valid(); }
+  uint64_t fs_cdrio() const { return at<10>().as_uint64(); }
+  bool has_fs_cp_dio() const { return at<11>().valid(); }
+  uint64_t fs_cp_dio() const { return at<11>().as_uint64(); }
+  bool has_fs_cp_mio() const { return at<12>().valid(); }
+  uint64_t fs_cp_mio() const { return at<12>().as_uint64(); }
+  bool has_fs_cp_nio() const { return at<13>().valid(); }
+  uint64_t fs_cp_nio() const { return at<13>().as_uint64(); }
+  bool has_fs_dio() const { return at<14>().valid(); }
+  uint64_t fs_dio() const { return at<14>().as_uint64(); }
+  bool has_fs_discard() const { return at<15>().valid(); }
+  uint64_t fs_discard() const { return at<15>().as_uint64(); }
+  bool has_fs_drio() const { return at<16>().valid(); }
+  uint64_t fs_drio() const { return at<16>().as_uint64(); }
+  bool has_fs_gc_dio() const { return at<17>().valid(); }
+  uint64_t fs_gc_dio() const { return at<17>().as_uint64(); }
+  bool has_fs_gc_nio() const { return at<18>().valid(); }
+  uint64_t fs_gc_nio() const { return at<18>().as_uint64(); }
+  bool has_fs_gdrio() const { return at<19>().valid(); }
+  uint64_t fs_gdrio() const { return at<19>().as_uint64(); }
+  bool has_fs_mio() const { return at<20>().valid(); }
+  uint64_t fs_mio() const { return at<20>().as_uint64(); }
+  bool has_fs_mrio() const { return at<21>().valid(); }
+  uint64_t fs_mrio() const { return at<21>().as_uint64(); }
+  bool has_fs_nio() const { return at<22>().valid(); }
+  uint64_t fs_nio() const { return at<22>().as_uint64(); }
+  bool has_fs_nrio() const { return at<23>().valid(); }
+  uint64_t fs_nrio() const { return at<23>().as_uint64(); }
 };
 
-class F2fsTruncateDataBlocksRangeFtraceEvent : public ::protozero::Message {
+class F2fsIostatFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = F2fsTruncateDataBlocksRangeFtraceEvent_Decoder;
+  using Decoder = F2fsIostatFtraceEvent_Decoder;
   enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kNidFieldNumber = 3,
-    kOfsFieldNumber = 4,
-    kFreeFieldNumber = 5,
+    kAppBioFieldNumber = 1,
+    kAppBrioFieldNumber = 2,
+    kAppDioFieldNumber = 3,
+    kAppDrioFieldNumber = 4,
+    kAppMioFieldNumber = 5,
+    kAppMrioFieldNumber = 6,
+    kAppRioFieldNumber = 7,
+    kAppWioFieldNumber = 8,
+    kDevFieldNumber = 9,
+    kFsCdrioFieldNumber = 10,
+    kFsCpDioFieldNumber = 11,
+    kFsCpMioFieldNumber = 12,
+    kFsCpNioFieldNumber = 13,
+    kFsDioFieldNumber = 14,
+    kFsDiscardFieldNumber = 15,
+    kFsDrioFieldNumber = 16,
+    kFsGcDioFieldNumber = 17,
+    kFsGcNioFieldNumber = 18,
+    kFsGdrioFieldNumber = 19,
+    kFsMioFieldNumber = 20,
+    kFsMrioFieldNumber = 21,
+    kFsNioFieldNumber = 22,
+    kFsNrioFieldNumber = 23,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateDataBlocksRangeFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsIostatFtraceEvent"; }
 
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_AppBio =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsTruncateDataBlocksRangeFtraceEvent>;
+      F2fsIostatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_AppBio kAppBio{};
+  void set_app_bio(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AppBio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -95521,24 +126057,17 @@ class F2fsTruncateDataBlocksRangeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_AppBrio =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsTruncateDataBlocksRangeFtraceEvent>;
+      F2fsIostatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_AppBrio kAppBrio{};
+  void set_app_brio(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AppBrio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -95546,124 +126075,71 @@ class F2fsTruncateDataBlocksRangeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Nid =
+  using FieldMetadata_AppDio =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsTruncateDataBlocksRangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsIostatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nid kNid() { return {}; }
-  void set_nid(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
+  static constexpr FieldMetadata_AppDio kAppDio{};
+  void set_app_dio(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AppDio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ofs =
+  using FieldMetadata_AppDrio =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsTruncateDataBlocksRangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsIostatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ofs kOfs() { return {}; }
-  void set_ofs(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ofs::kFieldId;
+  static constexpr FieldMetadata_AppDrio kAppDrio{};
+  void set_app_drio(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AppDrio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Free =
+  using FieldMetadata_AppMio =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsTruncateDataBlocksRangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsIostatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Free kFree() { return {}; }
-  void set_free(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Free::kFieldId;
+  static constexpr FieldMetadata_AppMio kAppMio{};
+  void set_app_mio(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AppMio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class F2fsTruncateBlocksExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  F2fsTruncateBlocksExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsTruncateBlocksExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsTruncateBlocksExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_ret() const { return at<3>().valid(); }
-  int32_t ret() const { return at<3>().as_int32(); }
-};
-
-class F2fsTruncateBlocksExitFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = F2fsTruncateBlocksExitFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kRetFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateBlocksExitFtraceEvent"; }
 
-
-  using FieldMetadata_Dev =
+  using FieldMetadata_AppMrio =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsTruncateBlocksExitFtraceEvent>;
+      F2fsIostatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_AppMrio kAppMrio{};
+  void set_app_mrio(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AppMrio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -95671,24 +126147,17 @@ class F2fsTruncateBlocksExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_AppRio =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsTruncateBlocksExitFtraceEvent>;
+      F2fsIostatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_AppRio kAppRio{};
+  void set_app_rio(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AppRio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -95696,78 +126165,33 @@ class F2fsTruncateBlocksExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ret =
+  using FieldMetadata_AppWio =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsTruncateBlocksExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsIostatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+  static constexpr FieldMetadata_AppWio kAppWio{};
+  void set_app_wio(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AppWio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class F2fsTruncateBlocksEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  F2fsTruncateBlocksEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsTruncateBlocksEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsTruncateBlocksEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_size() const { return at<3>().valid(); }
-  int64_t size() const { return at<3>().as_int64(); }
-  bool has_blocks() const { return at<4>().valid(); }
-  uint64_t blocks() const { return at<4>().as_uint64(); }
-  bool has_from() const { return at<5>().valid(); }
-  uint64_t from() const { return at<5>().as_uint64(); }
-};
-
-class F2fsTruncateBlocksEnterFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = F2fsTruncateBlocksEnterFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kSizeFieldNumber = 3,
-    kBlocksFieldNumber = 4,
-    kFromFieldNumber = 5,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateBlocksEnterFtraceEvent"; }
-
 
   using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsTruncateBlocksEnterFtraceEvent>;
+      F2fsIostatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -95777,24 +126201,17 @@ class F2fsTruncateBlocksEnterFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_FsCdrio =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsTruncateBlocksEnterFtraceEvent>;
+      F2fsIostatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_FsCdrio kFsCdrio{};
+  void set_fs_cdrio(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FsCdrio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -95802,49 +126219,17 @@ class F2fsTruncateBlocksEnterFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Size =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      F2fsTruncateBlocksEnterFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Size kSize() { return {}; }
-  void set_size(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Blocks =
+  using FieldMetadata_FsCpDio =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsTruncateBlocksEnterFtraceEvent>;
+      F2fsIostatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Blocks kBlocks() { return {}; }
-  void set_blocks(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
+  static constexpr FieldMetadata_FsCpDio kFsCpDio{};
+  void set_fs_cp_dio(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FsCpDio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -95852,89 +126237,35 @@ class F2fsTruncateBlocksEnterFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_From =
+  using FieldMetadata_FsCpMio =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      12,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsTruncateBlocksEnterFtraceEvent>;
+      F2fsIostatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_From kFrom() { return {}; }
-  void set_from(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_From::kFieldId;
+  static constexpr FieldMetadata_FsCpMio kFsCpMio{};
+  void set_fs_cp_mio(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FsCpMio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class F2fsTruncateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  F2fsTruncateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsTruncateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsTruncateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_pino() const { return at<3>().valid(); }
-  uint64_t pino() const { return at<3>().as_uint64(); }
-  bool has_mode() const { return at<4>().valid(); }
-  uint32_t mode() const { return at<4>().as_uint32(); }
-  bool has_size() const { return at<5>().valid(); }
-  int64_t size() const { return at<5>().as_int64(); }
-  bool has_nlink() const { return at<6>().valid(); }
-  uint32_t nlink() const { return at<6>().as_uint32(); }
-  bool has_blocks() const { return at<7>().valid(); }
-  uint64_t blocks() const { return at<7>().as_uint64(); }
-  bool has_advise() const { return at<8>().valid(); }
-  uint32_t advise() const { return at<8>().as_uint32(); }
-};
-
-class F2fsTruncateFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = F2fsTruncateFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kPinoFieldNumber = 3,
-    kModeFieldNumber = 4,
-    kSizeFieldNumber = 5,
-    kNlinkFieldNumber = 6,
-    kBlocksFieldNumber = 7,
-    kAdviseFieldNumber = 8,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateFtraceEvent"; }
 
-
-  using FieldMetadata_Dev =
+  using FieldMetadata_FsCpNio =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      13,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsTruncateFtraceEvent>;
+      F2fsIostatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_FsCpNio kFsCpNio{};
+  void set_fs_cp_nio(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FsCpNio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -95942,24 +126273,17 @@ class F2fsTruncateFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_FsDio =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      14,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsTruncateFtraceEvent>;
+      F2fsIostatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+  static constexpr FieldMetadata_FsDio kFsDio{};
+  void set_fs_dio(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FsDio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -95967,24 +126291,17 @@ class F2fsTruncateFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pino =
+  using FieldMetadata_FsDiscard =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      15,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsTruncateFtraceEvent>;
+      F2fsIostatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pino kPino() { return {}; }
-  void set_pino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pino::kFieldId;
+  static constexpr FieldMetadata_FsDiscard kFsDiscard{};
+  void set_fs_discard(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FsDiscard::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -95992,99 +126309,71 @@ class F2fsTruncateFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Mode =
+  using FieldMetadata_FsDrio =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      16,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsTruncateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsIostatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mode kMode() { return {}; }
-  void set_mode(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+  static constexpr FieldMetadata_FsDrio kFsDrio{};
+  void set_fs_drio(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FsDrio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Size =
+  using FieldMetadata_FsGcDio =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      17,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      F2fsTruncateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsIostatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Size kSize() { return {}; }
-  void set_size(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
+  static constexpr FieldMetadata_FsGcDio kFsGcDio{};
+  void set_fs_gc_dio(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FsGcDio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Nlink =
+  using FieldMetadata_FsGcNio =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      18,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsTruncateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsIostatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nlink kNlink() { return {}; }
-  void set_nlink(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Nlink::kFieldId;
+  static constexpr FieldMetadata_FsGcNio kFsGcNio{};
+  void set_fs_gc_nio(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FsGcNio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Blocks =
+  using FieldMetadata_FsGdrio =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      19,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsTruncateFtraceEvent>;
+      F2fsIostatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Blocks kBlocks() { return {}; }
-  void set_blocks(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
+  static constexpr FieldMetadata_FsGdrio kFsGdrio{};
+  void set_fs_gdrio(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FsGdrio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -96092,74 +126381,35 @@ class F2fsTruncateFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Advise =
+  using FieldMetadata_FsMio =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      20,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsTruncateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsIostatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Advise kAdvise() { return {}; }
-  void set_advise(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Advise::kFieldId;
+  static constexpr FieldMetadata_FsMio kFsMio{};
+  void set_fs_mio(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FsMio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class F2fsSyncFsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  F2fsSyncFsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsSyncFsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsSyncFsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev() const { return at<1>().valid(); }
-  uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_dirty() const { return at<2>().valid(); }
-  int32_t dirty() const { return at<2>().as_int32(); }
-  bool has_wait() const { return at<3>().valid(); }
-  int32_t wait() const { return at<3>().as_int32(); }
-};
-
-class F2fsSyncFsFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = F2fsSyncFsFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevFieldNumber = 1,
-    kDirtyFieldNumber = 2,
-    kWaitFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsSyncFsFtraceEvent"; }
 
-
-  using FieldMetadata_Dev =
+  using FieldMetadata_FsMrio =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      21,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsSyncFsFtraceEvent>;
+      F2fsIostatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_FsMrio kFsMrio{};
+  void set_fs_mrio(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FsMrio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -96167,88 +126417,71 @@ class F2fsSyncFsFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Dirty =
+  using FieldMetadata_FsNio =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      22,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsSyncFsFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsIostatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dirty kDirty() { return {}; }
-  void set_dirty(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dirty::kFieldId;
+  static constexpr FieldMetadata_FsNio kFsNio{};
+  void set_fs_nio(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FsNio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Wait =
+  using FieldMetadata_FsNrio =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      23,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsSyncFsFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsIostatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Wait kWait() { return {}; }
-  void set_wait(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Wait::kFieldId;
+  static constexpr FieldMetadata_FsNrio kFsNrio{};
+  void set_fs_nrio(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FsNrio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class F2fsSyncFileExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsWriteEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  F2fsSyncFileExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsSyncFileExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsSyncFileExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  F2fsWriteEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsWriteEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsWriteEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_need_cp() const { return at<3>().valid(); }
-  uint32_t need_cp() const { return at<3>().as_uint32(); }
-  bool has_datasync() const { return at<4>().valid(); }
-  int32_t datasync() const { return at<4>().as_int32(); }
-  bool has_ret() const { return at<5>().valid(); }
-  int32_t ret() const { return at<5>().as_int32(); }
-  bool has_cp_reason() const { return at<6>().valid(); }
-  int32_t cp_reason() const { return at<6>().as_int32(); }
+  bool has_pos() const { return at<3>().valid(); }
+  int64_t pos() const { return at<3>().as_int64(); }
+  bool has_len() const { return at<4>().valid(); }
+  uint32_t len() const { return at<4>().as_uint32(); }
+  bool has_copied() const { return at<5>().valid(); }
+  uint32_t copied() const { return at<5>().as_uint32(); }
 };
 
-class F2fsSyncFileExitFtraceEvent : public ::protozero::Message {
+class F2fsWriteEndFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = F2fsSyncFileExitFtraceEvent_Decoder;
+  using Decoder = F2fsWriteEndFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kNeedCpFieldNumber = 3,
-    kDatasyncFieldNumber = 4,
-    kRetFieldNumber = 5,
-    kCpReasonFieldNumber = 6,
+    kPosFieldNumber = 3,
+    kLenFieldNumber = 4,
+    kCopiedFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsSyncFileExitFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsWriteEndFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -96257,16 +126490,9 @@ class F2fsSyncFileExitFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsSyncFileExitFtraceEvent>;
+      F2fsWriteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -96282,16 +126508,9 @@ class F2fsSyncFileExitFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsSyncFileExitFtraceEvent>;
+      F2fsWriteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -96301,144 +126520,89 @@ class F2fsSyncFileExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NeedCp =
+  using FieldMetadata_Pos =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsSyncFileExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      F2fsWriteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NeedCp kNeedCp() { return {}; }
-  void set_need_cp(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NeedCp::kFieldId;
+  static constexpr FieldMetadata_Pos kPos{};
+  void set_pos(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Datasync =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsSyncFileExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsWriteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Datasync kDatasync() { return {}; }
-  void set_datasync(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Datasync::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ret =
+  using FieldMetadata_Copied =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsSyncFileExitFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_CpReason =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsSyncFileExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsWriteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpReason kCpReason() { return {}; }
-  void set_cp_reason(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CpReason::kFieldId;
+  static constexpr FieldMetadata_Copied kCopied{};
+  void set_copied(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Copied::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class F2fsSyncFileEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsWriteCheckpointFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  F2fsSyncFileEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsSyncFileEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsSyncFileEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  F2fsWriteCheckpointFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsWriteCheckpointFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsWriteCheckpointFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_ino() const { return at<2>().valid(); }
-  uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_pino() const { return at<3>().valid(); }
-  uint64_t pino() const { return at<3>().as_uint64(); }
-  bool has_mode() const { return at<4>().valid(); }
-  uint32_t mode() const { return at<4>().as_uint32(); }
-  bool has_size() const { return at<5>().valid(); }
-  int64_t size() const { return at<5>().as_int64(); }
-  bool has_nlink() const { return at<6>().valid(); }
-  uint32_t nlink() const { return at<6>().as_uint32(); }
-  bool has_blocks() const { return at<7>().valid(); }
-  uint64_t blocks() const { return at<7>().as_uint64(); }
-  bool has_advise() const { return at<8>().valid(); }
-  uint32_t advise() const { return at<8>().as_uint32(); }
+  bool has_is_umount() const { return at<2>().valid(); }
+  uint32_t is_umount() const { return at<2>().as_uint32(); }
+  bool has_msg() const { return at<3>().valid(); }
+  ::protozero::ConstChars msg() const { return at<3>().as_string(); }
+  bool has_reason() const { return at<4>().valid(); }
+  int32_t reason() const { return at<4>().as_int32(); }
+  bool has_phase() const { return at<5>().valid(); }
+  uint32_t phase() const { return at<5>().as_uint32(); }
 };
 
-class F2fsSyncFileEnterFtraceEvent : public ::protozero::Message {
+class F2fsWriteCheckpointFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = F2fsSyncFileEnterFtraceEvent_Decoder;
+  using Decoder = F2fsWriteCheckpointFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
-    kInoFieldNumber = 2,
-    kPinoFieldNumber = 3,
-    kModeFieldNumber = 4,
-    kSizeFieldNumber = 5,
-    kNlinkFieldNumber = 6,
-    kBlocksFieldNumber = 7,
-    kAdviseFieldNumber = 8,
+    kIsUmountFieldNumber = 2,
+    kMsgFieldNumber = 3,
+    kReasonFieldNumber = 4,
+    kPhaseFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsSyncFileEnterFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsWriteCheckpointFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -96447,16 +126611,9 @@ class F2fsSyncFileEnterFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsSyncFileEnterFtraceEvent>;
+      F2fsWriteCheckpointFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -96466,74 +126623,17 @@ class F2fsSyncFileEnterFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ino =
+  using FieldMetadata_IsUmount =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsSyncFileEnterFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
-  void set_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Pino =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsSyncFileEnterFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pino kPino() { return {}; }
-  void set_pino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pino::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Mode =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      F2fsSyncFileEnterFtraceEvent>;
+      F2fsWriteCheckpointFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mode kMode() { return {}; }
-  void set_mode(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+  static constexpr FieldMetadata_IsUmount kIsUmount{};
+  void set_is_umount(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsUmount::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -96541,99 +126641,59 @@ class F2fsSyncFileEnterFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Size =
+  using FieldMetadata_Msg =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      F2fsSyncFileEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      F2fsWriteCheckpointFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Size kSize() { return {}; }
-  void set_size(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_Msg kMsg{};
+  void set_msg(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Msg::kFieldId, data, size);
   }
-
-  using FieldMetadata_Nlink =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsSyncFileEnterFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nlink kNlink() { return {}; }
-  void set_nlink(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Nlink::kFieldId;
+  void set_msg(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Msg::kFieldId, chars.data, chars.size);
+  }
+  void set_msg(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Msg::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Blocks =
+  using FieldMetadata_Reason =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsSyncFileEnterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsWriteCheckpointFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Blocks kBlocks() { return {}; }
-  void set_blocks(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
+  static constexpr FieldMetadata_Reason kReason{};
+  void set_reason(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Reason::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Advise =
+  using FieldMetadata_Phase =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      F2fsSyncFileEnterFtraceEvent>;
+      F2fsWriteCheckpointFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Advise kAdvise() { return {}; }
-  void set_advise(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Advise::kFieldId;
+  static constexpr FieldMetadata_Phase kPhase{};
+  void set_phase(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Phase::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -96642,34 +126702,34 @@ class F2fsSyncFileEnterFtraceEvent : public ::protozero::Message {
   }
 };
 
-class F2fsSubmitWritePageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsWriteBeginFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  F2fsSubmitWritePageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsSubmitWritePageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsSubmitWritePageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  F2fsWriteBeginFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsWriteBeginFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsWriteBeginFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_type() const { return at<3>().valid(); }
-  int32_t type() const { return at<3>().as_int32(); }
-  bool has_index() const { return at<4>().valid(); }
-  uint64_t index() const { return at<4>().as_uint64(); }
-  bool has_block() const { return at<5>().valid(); }
-  uint32_t block() const { return at<5>().as_uint32(); }
+  bool has_pos() const { return at<3>().valid(); }
+  int64_t pos() const { return at<3>().as_int64(); }
+  bool has_len() const { return at<4>().valid(); }
+  uint32_t len() const { return at<4>().as_uint32(); }
+  bool has_flags() const { return at<5>().valid(); }
+  uint32_t flags() const { return at<5>().as_uint32(); }
 };
 
-class F2fsSubmitWritePageFtraceEvent : public ::protozero::Message {
+class F2fsWriteBeginFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = F2fsSubmitWritePageFtraceEvent_Decoder;
+  using Decoder = F2fsWriteBeginFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kTypeFieldNumber = 3,
-    kIndexFieldNumber = 4,
-    kBlockFieldNumber = 5,
+    kPosFieldNumber = 3,
+    kLenFieldNumber = 4,
+    kFlagsFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsSubmitWritePageFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsWriteBeginFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -96678,16 +126738,9 @@ class F2fsSubmitWritePageFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsSubmitWritePageFtraceEvent>;
+      F2fsWriteBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -96703,16 +126756,9 @@ class F2fsSubmitWritePageFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsSubmitWritePageFtraceEvent>;
+      F2fsWriteBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -96722,74 +126768,53 @@ class F2fsSubmitWritePageFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Type =
+  using FieldMetadata_Pos =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsSubmitWritePageFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      F2fsWriteBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+  static constexpr FieldMetadata_Pos kPos{};
+  void set_pos(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Index =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsSubmitWritePageFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsWriteBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Index kIndex() { return {}; }
-  void set_index(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Block =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      F2fsSubmitWritePageFtraceEvent>;
+      F2fsWriteBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Block kBlock() { return {}; }
-  void set_block(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Block::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -96798,11 +126823,11 @@ class F2fsSubmitWritePageFtraceEvent : public ::protozero::Message {
   }
 };
 
-class F2fsSetPageDirtyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsVmPageMkwriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
-  F2fsSetPageDirtyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsSetPageDirtyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsSetPageDirtyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  F2fsVmPageMkwriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsVmPageMkwriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsVmPageMkwriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
@@ -96819,9 +126844,9 @@ class F2fsSetPageDirtyFtraceEvent_Decoder : public ::protozero::TypedProtoDecode
   int32_t uptodate() const { return at<7>().as_int32(); }
 };
 
-class F2fsSetPageDirtyFtraceEvent : public ::protozero::Message {
+class F2fsVmPageMkwriteFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = F2fsSetPageDirtyFtraceEvent_Decoder;
+  using Decoder = F2fsVmPageMkwriteFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
@@ -96831,7 +126856,7 @@ class F2fsSetPageDirtyFtraceEvent : public ::protozero::Message {
     kDirtyFieldNumber = 6,
     kUptodateFieldNumber = 7,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsSetPageDirtyFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsVmPageMkwriteFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -96840,16 +126865,9 @@ class F2fsSetPageDirtyFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsSetPageDirtyFtraceEvent>;
+      F2fsVmPageMkwriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -96865,16 +126883,9 @@ class F2fsSetPageDirtyFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsSetPageDirtyFtraceEvent>;
+      F2fsVmPageMkwriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -96890,16 +126901,9 @@ class F2fsSetPageDirtyFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      F2fsSetPageDirtyFtraceEvent>;
+      F2fsVmPageMkwriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
+  static constexpr FieldMetadata_Type kType{};
   void set_type(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -96915,16 +126919,9 @@ class F2fsSetPageDirtyFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      F2fsSetPageDirtyFtraceEvent>;
+      F2fsVmPageMkwriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dir kDir() { return {}; }
+  static constexpr FieldMetadata_Dir kDir{};
   void set_dir(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dir::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -96940,16 +126937,9 @@ class F2fsSetPageDirtyFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsSetPageDirtyFtraceEvent>;
+      F2fsVmPageMkwriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Index kIndex() { return {}; }
+  static constexpr FieldMetadata_Index kIndex{};
   void set_index(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -96965,16 +126955,9 @@ class F2fsSetPageDirtyFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      F2fsSetPageDirtyFtraceEvent>;
+      F2fsVmPageMkwriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dirty kDirty() { return {}; }
+  static constexpr FieldMetadata_Dirty kDirty{};
   void set_dirty(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dirty::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -96990,16 +126973,9 @@ class F2fsSetPageDirtyFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      F2fsSetPageDirtyFtraceEvent>;
+      F2fsVmPageMkwriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Uptodate kUptodate() { return {}; }
+  static constexpr FieldMetadata_Uptodate kUptodate{};
   void set_uptodate(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Uptodate::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -97010,28 +126986,28 @@ class F2fsSetPageDirtyFtraceEvent : public ::protozero::Message {
   }
 };
 
-class F2fsReserveNewBlockFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsUnlinkExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  F2fsReserveNewBlockFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsReserveNewBlockFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsReserveNewBlockFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  F2fsUnlinkExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsUnlinkExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsUnlinkExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_nid() const { return at<2>().valid(); }
-  uint32_t nid() const { return at<2>().as_uint32(); }
-  bool has_ofs_in_node() const { return at<3>().valid(); }
-  uint32_t ofs_in_node() const { return at<3>().as_uint32(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_ret() const { return at<3>().valid(); }
+  int32_t ret() const { return at<3>().as_int32(); }
 };
 
-class F2fsReserveNewBlockFtraceEvent : public ::protozero::Message {
+class F2fsUnlinkExitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = F2fsReserveNewBlockFtraceEvent_Decoder;
+  using Decoder = F2fsUnlinkExitFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
-    kNidFieldNumber = 2,
-    kOfsInNodeFieldNumber = 3,
+    kInoFieldNumber = 2,
+    kRetFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsReserveNewBlockFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsUnlinkExitFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -97040,16 +127016,9 @@ class F2fsReserveNewBlockFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsReserveNewBlockFtraceEvent>;
+      F2fsUnlinkExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -97059,94 +127028,71 @@ class F2fsReserveNewBlockFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Nid =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsReserveNewBlockFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsUnlinkExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nid kNid() { return {}; }
-  void set_nid(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_OfsInNode =
+  using FieldMetadata_Ret =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsReserveNewBlockFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsUnlinkExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OfsInNode kOfsInNode() { return {}; }
-  void set_ofs_in_node(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OfsInNode::kFieldId;
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class F2fsReadpageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsUnlinkEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  F2fsReadpageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsReadpageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsReadpageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  F2fsUnlinkEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsUnlinkEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsUnlinkEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_index() const { return at<3>().valid(); }
-  uint64_t index() const { return at<3>().as_uint64(); }
-  bool has_blkaddr() const { return at<4>().valid(); }
-  uint64_t blkaddr() const { return at<4>().as_uint64(); }
-  bool has_type() const { return at<5>().valid(); }
-  int32_t type() const { return at<5>().as_int32(); }
-  bool has_dir() const { return at<6>().valid(); }
-  int32_t dir() const { return at<6>().as_int32(); }
-  bool has_dirty() const { return at<7>().valid(); }
-  int32_t dirty() const { return at<7>().as_int32(); }
-  bool has_uptodate() const { return at<8>().valid(); }
-  int32_t uptodate() const { return at<8>().as_int32(); }
+  bool has_size() const { return at<3>().valid(); }
+  int64_t size() const { return at<3>().as_int64(); }
+  bool has_blocks() const { return at<4>().valid(); }
+  uint64_t blocks() const { return at<4>().as_uint64(); }
+  bool has_name() const { return at<5>().valid(); }
+  ::protozero::ConstChars name() const { return at<5>().as_string(); }
 };
 
-class F2fsReadpageFtraceEvent : public ::protozero::Message {
+class F2fsUnlinkEnterFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = F2fsReadpageFtraceEvent_Decoder;
+  using Decoder = F2fsUnlinkEnterFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kIndexFieldNumber = 3,
-    kBlkaddrFieldNumber = 4,
-    kTypeFieldNumber = 5,
-    kDirFieldNumber = 6,
-    kDirtyFieldNumber = 7,
-    kUptodateFieldNumber = 8,
+    kSizeFieldNumber = 3,
+    kBlocksFieldNumber = 4,
+    kNameFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsReadpageFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsUnlinkEnterFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -97155,16 +127101,9 @@ class F2fsReadpageFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsReadpageFtraceEvent>;
+      F2fsUnlinkEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -97180,16 +127119,9 @@ class F2fsReadpageFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsReadpageFtraceEvent>;
+      F2fsUnlinkEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -97199,24 +127131,35 @@ class F2fsReadpageFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Index =
+  using FieldMetadata_Size =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      F2fsUnlinkEnterFtraceEvent>;
+
+  static constexpr FieldMetadata_Size kSize{};
+  void set_size(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Blocks =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsReadpageFtraceEvent>;
+      F2fsUnlinkEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Index kIndex() { return {}; }
-  void set_index(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
+  static constexpr FieldMetadata_Blocks kBlocks{};
+  void set_blocks(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -97224,24 +127167,72 @@ class F2fsReadpageFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Blkaddr =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      F2fsUnlinkEnterFtraceEvent>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class F2fsTruncatePartialNodesFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  F2fsTruncatePartialNodesFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsTruncatePartialNodesFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsTruncatePartialNodesFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_nid() const { return at<3>().valid(); }
+  uint32_t nid() const { return at<3>().as_uint32(); }
+  bool has_depth() const { return at<4>().valid(); }
+  int32_t depth() const { return at<4>().as_int32(); }
+  bool has_err() const { return at<5>().valid(); }
+  int32_t err() const { return at<5>().as_int32(); }
+};
+
+class F2fsTruncatePartialNodesFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = F2fsTruncatePartialNodesFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kNidFieldNumber = 3,
+    kDepthFieldNumber = 4,
+    kErrFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncatePartialNodesFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsReadpageFtraceEvent>;
+      F2fsTruncatePartialNodesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Blkaddr kBlkaddr() { return {}; }
-  void set_blkaddr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Blkaddr::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -97249,74 +127240,53 @@ class F2fsReadpageFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Type =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsReadpageFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsTruncatePartialNodesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Dir =
+  using FieldMetadata_Nid =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsReadpageFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsTruncatePartialNodesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dir kDir() { return {}; }
-  void set_dir(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dir::kFieldId;
+  static constexpr FieldMetadata_Nid kNid{};
+  void set_nid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Dirty =
+  using FieldMetadata_Depth =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      F2fsReadpageFtraceEvent>;
+      F2fsTruncatePartialNodesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dirty kDirty() { return {}; }
-  void set_dirty(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dirty::kFieldId;
+  static constexpr FieldMetadata_Depth kDepth{};
+  void set_depth(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Depth::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -97324,24 +127294,17 @@ class F2fsReadpageFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Uptodate =
+  using FieldMetadata_Err =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      F2fsReadpageFtraceEvent>;
+      F2fsTruncatePartialNodesFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Uptodate kUptodate() { return {}; }
-  void set_uptodate(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Uptodate::kFieldId;
+  static constexpr FieldMetadata_Err kErr{};
+  void set_err(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Err::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -97350,11 +127313,11 @@ class F2fsReadpageFtraceEvent : public ::protozero::Message {
   }
 };
 
-class F2fsNewInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsTruncateNodesExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  F2fsNewInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsNewInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsNewInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  F2fsTruncateNodesExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsTruncateNodesExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsTruncateNodesExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
@@ -97363,15 +127326,15 @@ class F2fsNewInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*
   int32_t ret() const { return at<3>().as_int32(); }
 };
 
-class F2fsNewInodeFtraceEvent : public ::protozero::Message {
+class F2fsTruncateNodesExitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = F2fsNewInodeFtraceEvent_Decoder;
+  using Decoder = F2fsTruncateNodesExitFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
     kRetFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsNewInodeFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateNodesExitFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -97380,16 +127343,9 @@ class F2fsNewInodeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsNewInodeFtraceEvent>;
+      F2fsTruncateNodesExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -97405,16 +127361,9 @@ class F2fsNewInodeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsNewInodeFtraceEvent>;
+      F2fsTruncateNodesExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -97430,16 +127379,9 @@ class F2fsNewInodeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      F2fsNewInodeFtraceEvent>;
+      F2fsTruncateNodesExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
+  static constexpr FieldMetadata_Ret kRet{};
   void set_ret(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -97450,28 +127392,31 @@ class F2fsNewInodeFtraceEvent : public ::protozero::Message {
   }
 };
 
-class F2fsIgetExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsTruncateNodesEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  F2fsIgetExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsIgetExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsIgetExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  F2fsTruncateNodesEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsTruncateNodesEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsTruncateNodesEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_ret() const { return at<3>().valid(); }
-  int32_t ret() const { return at<3>().as_int32(); }
+  bool has_nid() const { return at<3>().valid(); }
+  uint32_t nid() const { return at<3>().as_uint32(); }
+  bool has_blk_addr() const { return at<4>().valid(); }
+  uint32_t blk_addr() const { return at<4>().as_uint32(); }
 };
 
-class F2fsIgetExitFtraceEvent : public ::protozero::Message {
+class F2fsTruncateNodesEnterFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = F2fsIgetExitFtraceEvent_Decoder;
+  using Decoder = F2fsTruncateNodesEnterFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kRetFieldNumber = 3,
+    kNidFieldNumber = 3,
+    kBlkAddrFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsIgetExitFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateNodesEnterFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -97480,16 +127425,9 @@ class F2fsIgetExitFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsIgetExitFtraceEvent>;
+      F2fsTruncateNodesEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -97505,16 +127443,9 @@ class F2fsIgetExitFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsIgetExitFtraceEvent>;
+      F2fsTruncateNodesEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -97524,69 +127455,68 @@ class F2fsIgetExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ret =
+  using FieldMetadata_Nid =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsIgetExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsTruncateNodesEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+  static constexpr FieldMetadata_Nid kNid{};
+  void set_nid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BlkAddr =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsTruncateNodesEnterFtraceEvent>;
+
+  static constexpr FieldMetadata_BlkAddr kBlkAddr{};
+  void set_blk_addr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BlkAddr::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class F2fsIgetFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsTruncateNodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  F2fsIgetFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsIgetFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsIgetFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  F2fsTruncateNodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsTruncateNodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsTruncateNodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_pino() const { return at<3>().valid(); }
-  uint64_t pino() const { return at<3>().as_uint64(); }
-  bool has_mode() const { return at<4>().valid(); }
-  uint32_t mode() const { return at<4>().as_uint32(); }
-  bool has_size() const { return at<5>().valid(); }
-  int64_t size() const { return at<5>().as_int64(); }
-  bool has_nlink() const { return at<6>().valid(); }
-  uint32_t nlink() const { return at<6>().as_uint32(); }
-  bool has_blocks() const { return at<7>().valid(); }
-  uint64_t blocks() const { return at<7>().as_uint64(); }
-  bool has_advise() const { return at<8>().valid(); }
-  uint32_t advise() const { return at<8>().as_uint32(); }
+  bool has_nid() const { return at<3>().valid(); }
+  uint32_t nid() const { return at<3>().as_uint32(); }
+  bool has_blk_addr() const { return at<4>().valid(); }
+  uint32_t blk_addr() const { return at<4>().as_uint32(); }
 };
 
-class F2fsIgetFtraceEvent : public ::protozero::Message {
+class F2fsTruncateNodeFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = F2fsIgetFtraceEvent_Decoder;
+  using Decoder = F2fsTruncateNodeFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kPinoFieldNumber = 3,
-    kModeFieldNumber = 4,
-    kSizeFieldNumber = 5,
-    kNlinkFieldNumber = 6,
-    kBlocksFieldNumber = 7,
-    kAdviseFieldNumber = 8,
+    kNidFieldNumber = 3,
+    kBlkAddrFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsIgetFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateNodeFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -97595,16 +127525,9 @@ class F2fsIgetFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsIgetFtraceEvent>;
+      F2fsTruncateNodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -97620,16 +127543,9 @@ class F2fsIgetFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsIgetFtraceEvent>;
+      F2fsTruncateNodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -97639,122 +127555,215 @@ class F2fsIgetFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pino =
+  using FieldMetadata_Nid =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsIgetFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsTruncateNodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pino kPino() { return {}; }
-  void set_pino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pino::kFieldId;
+  static constexpr FieldMetadata_Nid kNid{};
+  void set_nid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Mode =
+  using FieldMetadata_BlkAddr =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      F2fsIgetFtraceEvent>;
+      F2fsTruncateNodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mode kMode() { return {}; }
-  void set_mode(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+  static constexpr FieldMetadata_BlkAddr kBlkAddr{};
+  void set_blk_addr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BlkAddr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Size =
+class F2fsTruncateInodeBlocksExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  F2fsTruncateInodeBlocksExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsTruncateInodeBlocksExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsTruncateInodeBlocksExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_ret() const { return at<3>().valid(); }
+  int32_t ret() const { return at<3>().as_int32(); }
+};
+
+class F2fsTruncateInodeBlocksExitFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = F2fsTruncateInodeBlocksExitFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kRetFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateInodeBlocksExitFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      F2fsIgetFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsTruncateInodeBlocksExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Size kSize() { return {}; }
-  void set_size(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Nlink =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIgetFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsTruncateInodeBlocksExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nlink kNlink() { return {}; }
-  void set_nlink(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Nlink::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ret =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsTruncateInodeBlocksExitFtraceEvent>;
+
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class F2fsTruncateInodeBlocksEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  F2fsTruncateInodeBlocksEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsTruncateInodeBlocksEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsTruncateInodeBlocksEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_size() const { return at<3>().valid(); }
+  int64_t size() const { return at<3>().as_int64(); }
+  bool has_blocks() const { return at<4>().valid(); }
+  uint64_t blocks() const { return at<4>().as_uint64(); }
+  bool has_from() const { return at<5>().valid(); }
+  uint64_t from() const { return at<5>().as_uint64(); }
+};
+
+class F2fsTruncateInodeBlocksEnterFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = F2fsTruncateInodeBlocksEnterFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kSizeFieldNumber = 3,
+    kBlocksFieldNumber = 4,
+    kFromFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateInodeBlocksEnterFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsTruncateInodeBlocksEnterFtraceEvent>;
+
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ino =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsTruncateInodeBlocksEnterFtraceEvent>;
+
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Size =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      F2fsTruncateInodeBlocksEnterFtraceEvent>;
+
+  static constexpr FieldMetadata_Size kSize{};
+  void set_size(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
   using FieldMetadata_Blocks =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsIgetFtraceEvent>;
+      F2fsTruncateInodeBlocksEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Blocks kBlocks() { return {}; }
+  static constexpr FieldMetadata_Blocks kBlocks{};
   void set_blocks(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -97764,78 +127773,53 @@ class F2fsIgetFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Advise =
+  using FieldMetadata_From =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsIgetFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsTruncateInodeBlocksEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Advise kAdvise() { return {}; }
-  void set_advise(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Advise::kFieldId;
+  static constexpr FieldMetadata_From kFrom{};
+  void set_from(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_From::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class F2fsGetVictimFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsTruncateDataBlocksRangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  F2fsGetVictimFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsGetVictimFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsGetVictimFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  F2fsTruncateDataBlocksRangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsTruncateDataBlocksRangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsTruncateDataBlocksRangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_type() const { return at<2>().valid(); }
-  int32_t type() const { return at<2>().as_int32(); }
-  bool has_gc_type() const { return at<3>().valid(); }
-  int32_t gc_type() const { return at<3>().as_int32(); }
-  bool has_alloc_mode() const { return at<4>().valid(); }
-  int32_t alloc_mode() const { return at<4>().as_int32(); }
-  bool has_gc_mode() const { return at<5>().valid(); }
-  int32_t gc_mode() const { return at<5>().as_int32(); }
-  bool has_victim() const { return at<6>().valid(); }
-  uint32_t victim() const { return at<6>().as_uint32(); }
-  bool has_ofs_unit() const { return at<7>().valid(); }
-  uint32_t ofs_unit() const { return at<7>().as_uint32(); }
-  bool has_pre_victim() const { return at<8>().valid(); }
-  uint32_t pre_victim() const { return at<8>().as_uint32(); }
-  bool has_prefree() const { return at<9>().valid(); }
-  uint32_t prefree() const { return at<9>().as_uint32(); }
-  bool has_free() const { return at<10>().valid(); }
-  uint32_t free() const { return at<10>().as_uint32(); }
-  bool has_cost() const { return at<11>().valid(); }
-  uint32_t cost() const { return at<11>().as_uint32(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_nid() const { return at<3>().valid(); }
+  uint32_t nid() const { return at<3>().as_uint32(); }
+  bool has_ofs() const { return at<4>().valid(); }
+  uint32_t ofs() const { return at<4>().as_uint32(); }
+  bool has_free() const { return at<5>().valid(); }
+  int32_t free() const { return at<5>().as_int32(); }
 };
 
-class F2fsGetVictimFtraceEvent : public ::protozero::Message {
+class F2fsTruncateDataBlocksRangeFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = F2fsGetVictimFtraceEvent_Decoder;
+  using Decoder = F2fsTruncateDataBlocksRangeFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
-    kTypeFieldNumber = 2,
-    kGcTypeFieldNumber = 3,
-    kAllocModeFieldNumber = 4,
-    kGcModeFieldNumber = 5,
-    kVictimFieldNumber = 6,
-    kOfsUnitFieldNumber = 7,
-    kPreVictimFieldNumber = 8,
-    kPrefreeFieldNumber = 9,
-    kFreeFieldNumber = 10,
-    kCostFieldNumber = 11,
+    kInoFieldNumber = 2,
+    kNidFieldNumber = 3,
+    kOfsFieldNumber = 4,
+    kFreeFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsGetVictimFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateDataBlocksRangeFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -97844,16 +127828,9 @@ class F2fsGetVictimFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsGetVictimFtraceEvent>;
+      F2fsTruncateDataBlocksRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -97863,288 +127840,316 @@ class F2fsGetVictimFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Type =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsGetVictimFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsTruncateDataBlocksRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_GcType =
+  using FieldMetadata_Nid =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsGetVictimFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsTruncateDataBlocksRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GcType kGcType() { return {}; }
-  void set_gc_type(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GcType::kFieldId;
+  static constexpr FieldMetadata_Nid kNid{};
+  void set_nid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_AllocMode =
+  using FieldMetadata_Ofs =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsGetVictimFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsTruncateDataBlocksRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AllocMode kAllocMode() { return {}; }
-  void set_alloc_mode(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AllocMode::kFieldId;
+  static constexpr FieldMetadata_Ofs kOfs{};
+  void set_ofs(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ofs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_GcMode =
+  using FieldMetadata_Free =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      F2fsGetVictimFtraceEvent>;
+      F2fsTruncateDataBlocksRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GcMode kGcMode() { return {}; }
-  void set_gc_mode(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GcMode::kFieldId;
+  static constexpr FieldMetadata_Free kFree{};
+  void set_free(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Free::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Victim =
+class F2fsTruncateBlocksExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  F2fsTruncateBlocksExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsTruncateBlocksExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsTruncateBlocksExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_ret() const { return at<3>().valid(); }
+  int32_t ret() const { return at<3>().as_int32(); }
+};
+
+class F2fsTruncateBlocksExitFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = F2fsTruncateBlocksExitFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kRetFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateBlocksExitFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsGetVictimFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsTruncateBlocksExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Victim kVictim() { return {}; }
-  void set_victim(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Victim::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_OfsUnit =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsGetVictimFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsTruncateBlocksExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OfsUnit kOfsUnit() { return {}; }
-  void set_ofs_unit(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OfsUnit::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PreVictim =
+  using FieldMetadata_Ret =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsGetVictimFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsTruncateBlocksExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PreVictim kPreVictim() { return {}; }
-  void set_pre_victim(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PreVictim::kFieldId;
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Prefree =
+class F2fsTruncateBlocksEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  F2fsTruncateBlocksEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsTruncateBlocksEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsTruncateBlocksEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_size() const { return at<3>().valid(); }
+  int64_t size() const { return at<3>().as_int64(); }
+  bool has_blocks() const { return at<4>().valid(); }
+  uint64_t blocks() const { return at<4>().as_uint64(); }
+  bool has_from() const { return at<5>().valid(); }
+  uint64_t from() const { return at<5>().as_uint64(); }
+};
+
+class F2fsTruncateBlocksEnterFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = F2fsTruncateBlocksEnterFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kSizeFieldNumber = 3,
+    kBlocksFieldNumber = 4,
+    kFromFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateBlocksEnterFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsGetVictimFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsTruncateBlocksEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Prefree kPrefree() { return {}; }
-  void set_prefree(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Prefree::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Free =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsGetVictimFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsTruncateBlocksEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Free kFree() { return {}; }
-  void set_free(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Free::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Cost =
+  using FieldMetadata_Size =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsGetVictimFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      F2fsTruncateBlocksEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cost kCost() { return {}; }
-  void set_cost(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Cost::kFieldId;
+  static constexpr FieldMetadata_Size kSize{};
+  void set_size(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Blocks =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsTruncateBlocksEnterFtraceEvent>;
+
+  static constexpr FieldMetadata_Blocks kBlocks{};
+  void set_blocks(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_From =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsTruncateBlocksEnterFtraceEvent>;
+
+  static constexpr FieldMetadata_From kFrom{};
+  void set_from(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_From::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class F2fsGetDataBlockFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsTruncateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
  public:
-  F2fsGetDataBlockFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsGetDataBlockFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsGetDataBlockFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  F2fsTruncateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsTruncateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsTruncateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_iblock() const { return at<3>().valid(); }
-  uint64_t iblock() const { return at<3>().as_uint64(); }
-  bool has_bh_start() const { return at<4>().valid(); }
-  uint64_t bh_start() const { return at<4>().as_uint64(); }
-  bool has_bh_size() const { return at<5>().valid(); }
-  uint64_t bh_size() const { return at<5>().as_uint64(); }
-  bool has_ret() const { return at<6>().valid(); }
-  int32_t ret() const { return at<6>().as_int32(); }
+  bool has_pino() const { return at<3>().valid(); }
+  uint64_t pino() const { return at<3>().as_uint64(); }
+  bool has_mode() const { return at<4>().valid(); }
+  uint32_t mode() const { return at<4>().as_uint32(); }
+  bool has_size() const { return at<5>().valid(); }
+  int64_t size() const { return at<5>().as_int64(); }
+  bool has_nlink() const { return at<6>().valid(); }
+  uint32_t nlink() const { return at<6>().as_uint32(); }
+  bool has_blocks() const { return at<7>().valid(); }
+  uint64_t blocks() const { return at<7>().as_uint64(); }
+  bool has_advise() const { return at<8>().valid(); }
+  uint32_t advise() const { return at<8>().as_uint32(); }
 };
 
-class F2fsGetDataBlockFtraceEvent : public ::protozero::Message {
+class F2fsTruncateFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = F2fsGetDataBlockFtraceEvent_Decoder;
+  using Decoder = F2fsTruncateFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kIblockFieldNumber = 3,
-    kBhStartFieldNumber = 4,
-    kBhSizeFieldNumber = 5,
-    kRetFieldNumber = 6,
+    kPinoFieldNumber = 3,
+    kModeFieldNumber = 4,
+    kSizeFieldNumber = 5,
+    kNlinkFieldNumber = 6,
+    kBlocksFieldNumber = 7,
+    kAdviseFieldNumber = 8,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsGetDataBlockFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -98153,16 +128158,9 @@ class F2fsGetDataBlockFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsGetDataBlockFtraceEvent>;
+      F2fsTruncateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -98178,16 +128176,9 @@ class F2fsGetDataBlockFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsGetDataBlockFtraceEvent>;
+      F2fsTruncateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -98197,49 +128188,150 @@ class F2fsGetDataBlockFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Iblock =
+  using FieldMetadata_Pino =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsGetDataBlockFtraceEvent>;
+      F2fsTruncateFtraceEvent>;
+
+  static constexpr FieldMetadata_Pino kPino{};
+  void set_pino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pino::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Mode =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsTruncateFtraceEvent>;
+
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Size =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      F2fsTruncateFtraceEvent>;
+
+  static constexpr FieldMetadata_Size kSize{};
+  void set_size(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Nlink =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsTruncateFtraceEvent>;
+
+  static constexpr FieldMetadata_Nlink kNlink{};
+  void set_nlink(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Nlink::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Blocks =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsTruncateFtraceEvent>;
+
+  static constexpr FieldMetadata_Blocks kBlocks{};
+  void set_blocks(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Advise =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsTruncateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Iblock kIblock() { return {}; }
-  void set_iblock(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Iblock::kFieldId;
+  static constexpr FieldMetadata_Advise kAdvise{};
+  void set_advise(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Advise::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_BhStart =
+class F2fsSyncFsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  F2fsSyncFsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsSyncFsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsSyncFsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_dirty() const { return at<2>().valid(); }
+  int32_t dirty() const { return at<2>().as_int32(); }
+  bool has_wait() const { return at<3>().valid(); }
+  int32_t wait() const { return at<3>().as_int32(); }
+};
+
+class F2fsSyncFsFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = F2fsSyncFsFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kDirtyFieldNumber = 2,
+    kWaitFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsSyncFsFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsGetDataBlockFtraceEvent>;
+      F2fsSyncFsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BhStart kBhStart() { return {}; }
-  void set_bh_start(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BhStart::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -98247,49 +128339,35 @@ class F2fsGetDataBlockFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BhSize =
+  using FieldMetadata_Dirty =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsGetDataBlockFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsSyncFsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BhSize kBhSize() { return {}; }
-  void set_bh_size(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BhSize::kFieldId;
+  static constexpr FieldMetadata_Dirty kDirty{};
+  void set_dirty(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dirty::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ret =
+  using FieldMetadata_Wait =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      F2fsGetDataBlockFtraceEvent>;
+      F2fsSyncFsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+  static constexpr FieldMetadata_Wait kWait{};
+  void set_wait(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Wait::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -98298,43 +128376,37 @@ class F2fsGetDataBlockFtraceEvent : public ::protozero::Message {
   }
 };
 
-class F2fsFallocateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsSyncFileExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  F2fsFallocateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsFallocateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsFallocateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  F2fsSyncFileExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsSyncFileExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsSyncFileExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
   uint64_t ino() const { return at<2>().as_uint64(); }
-  bool has_mode() const { return at<3>().valid(); }
-  int32_t mode() const { return at<3>().as_int32(); }
-  bool has_offset() const { return at<4>().valid(); }
-  int64_t offset() const { return at<4>().as_int64(); }
-  bool has_len() const { return at<5>().valid(); }
-  int64_t len() const { return at<5>().as_int64(); }
-  bool has_size() const { return at<6>().valid(); }
-  int64_t size() const { return at<6>().as_int64(); }
-  bool has_blocks() const { return at<7>().valid(); }
-  uint64_t blocks() const { return at<7>().as_uint64(); }
-  bool has_ret() const { return at<8>().valid(); }
-  int32_t ret() const { return at<8>().as_int32(); }
+  bool has_need_cp() const { return at<3>().valid(); }
+  uint32_t need_cp() const { return at<3>().as_uint32(); }
+  bool has_datasync() const { return at<4>().valid(); }
+  int32_t datasync() const { return at<4>().as_int32(); }
+  bool has_ret() const { return at<5>().valid(); }
+  int32_t ret() const { return at<5>().as_int32(); }
+  bool has_cp_reason() const { return at<6>().valid(); }
+  int32_t cp_reason() const { return at<6>().as_int32(); }
 };
 
-class F2fsFallocateFtraceEvent : public ::protozero::Message {
+class F2fsSyncFileExitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = F2fsFallocateFtraceEvent_Decoder;
+  using Decoder = F2fsSyncFileExitFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
-    kModeFieldNumber = 3,
-    kOffsetFieldNumber = 4,
-    kLenFieldNumber = 5,
-    kSizeFieldNumber = 6,
-    kBlocksFieldNumber = 7,
-    kRetFieldNumber = 8,
+    kNeedCpFieldNumber = 3,
+    kDatasyncFieldNumber = 4,
+    kRetFieldNumber = 5,
+    kCpReasonFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsFallocateFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsSyncFileExitFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -98343,16 +128415,9 @@ class F2fsFallocateFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsFallocateFtraceEvent>;
+      F2fsSyncFileExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -98368,16 +128433,9 @@ class F2fsFallocateFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsFallocateFtraceEvent>;
+      F2fsSyncFileExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -98387,149 +128445,71 @@ class F2fsFallocateFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Mode =
+  using FieldMetadata_NeedCp =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsFallocateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsSyncFileExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mode kMode() { return {}; }
-  void set_mode(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+  static constexpr FieldMetadata_NeedCp kNeedCp{};
+  void set_need_cp(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NeedCp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Offset =
+  using FieldMetadata_Datasync =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      F2fsFallocateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsSyncFileExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Offset kOffset() { return {}; }
-  void set_offset(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId;
+  static constexpr FieldMetadata_Datasync kDatasync{};
+  void set_datasync(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Datasync::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_Ret =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      F2fsFallocateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsSyncFileExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Size =
+  using FieldMetadata_CpReason =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      F2fsFallocateFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Size kSize() { return {}; }
-  void set_size(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Blocks =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      F2fsFallocateFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Blocks kBlocks() { return {}; }
-  void set_blocks(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Ret =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      F2fsFallocateFtraceEvent>;
+      F2fsSyncFileExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+  static constexpr FieldMetadata_CpReason kCpReason{};
+  void set_cp_reason(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CpReason::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -98538,11 +128518,11 @@ class F2fsFallocateFtraceEvent : public ::protozero::Message {
   }
 };
 
-class F2fsEvictInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsSyncFileEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
  public:
-  F2fsEvictInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsEvictInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsEvictInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  F2fsSyncFileEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsSyncFileEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsSyncFileEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
   bool has_ino() const { return at<2>().valid(); }
@@ -98561,9 +128541,9 @@ class F2fsEvictInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder<
   uint32_t advise() const { return at<8>().as_uint32(); }
 };
 
-class F2fsEvictInodeFtraceEvent : public ::protozero::Message {
+class F2fsSyncFileEnterFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = F2fsEvictInodeFtraceEvent_Decoder;
+  using Decoder = F2fsSyncFileEnterFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
     kInoFieldNumber = 2,
@@ -98574,7 +128554,7 @@ class F2fsEvictInodeFtraceEvent : public ::protozero::Message {
     kBlocksFieldNumber = 7,
     kAdviseFieldNumber = 8,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsEvictInodeFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsSyncFileEnterFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -98583,16 +128563,9 @@ class F2fsEvictInodeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsEvictInodeFtraceEvent>;
+      F2fsSyncFileEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -98608,16 +128581,9 @@ class F2fsEvictInodeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsEvictInodeFtraceEvent>;
+      F2fsSyncFileEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ino kIno() { return {}; }
+  static constexpr FieldMetadata_Ino kIno{};
   void set_ino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -98633,16 +128599,9 @@ class F2fsEvictInodeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsEvictInodeFtraceEvent>;
+      F2fsSyncFileEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pino kPino() { return {}; }
+  static constexpr FieldMetadata_Pino kPino{};
   void set_pino(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Pino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -98658,16 +128617,9 @@ class F2fsEvictInodeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      F2fsEvictInodeFtraceEvent>;
+      F2fsSyncFileEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mode kMode() { return {}; }
+  static constexpr FieldMetadata_Mode kMode{};
   void set_mode(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -98683,16 +128635,9 @@ class F2fsEvictInodeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt64,
       int64_t,
-      F2fsEvictInodeFtraceEvent>;
+      F2fsSyncFileEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Size kSize() { return {}; }
+  static constexpr FieldMetadata_Size kSize{};
   void set_size(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -98708,16 +128653,9 @@ class F2fsEvictInodeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      F2fsEvictInodeFtraceEvent>;
+      F2fsSyncFileEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nlink kNlink() { return {}; }
+  static constexpr FieldMetadata_Nlink kNlink{};
   void set_nlink(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Nlink::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -98733,16 +128671,9 @@ class F2fsEvictInodeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsEvictInodeFtraceEvent>;
+      F2fsSyncFileEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Blocks kBlocks() { return {}; }
+  static constexpr FieldMetadata_Blocks kBlocks{};
   void set_blocks(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -98758,16 +128689,9 @@ class F2fsEvictInodeFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      F2fsEvictInodeFtraceEvent>;
+      F2fsSyncFileEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Advise kAdvise() { return {}; }
+  static constexpr FieldMetadata_Advise kAdvise{};
   void set_advise(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Advise::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -98778,34 +128702,34 @@ class F2fsEvictInodeFtraceEvent : public ::protozero::Message {
   }
 };
 
-class F2fsDoSubmitBioFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsSubmitWritePageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  F2fsDoSubmitBioFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit F2fsDoSubmitBioFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit F2fsDoSubmitBioFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  F2fsSubmitWritePageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsSubmitWritePageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsSubmitWritePageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_dev() const { return at<1>().valid(); }
   uint64_t dev() const { return at<1>().as_uint64(); }
-  bool has_btype() const { return at<2>().valid(); }
-  int32_t btype() const { return at<2>().as_int32(); }
-  bool has_sync() const { return at<3>().valid(); }
-  uint32_t sync() const { return at<3>().as_uint32(); }
-  bool has_sector() const { return at<4>().valid(); }
-  uint64_t sector() const { return at<4>().as_uint64(); }
-  bool has_size() const { return at<5>().valid(); }
-  uint32_t size() const { return at<5>().as_uint32(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_type() const { return at<3>().valid(); }
+  int32_t type() const { return at<3>().as_int32(); }
+  bool has_index() const { return at<4>().valid(); }
+  uint64_t index() const { return at<4>().as_uint64(); }
+  bool has_block() const { return at<5>().valid(); }
+  uint32_t block() const { return at<5>().as_uint32(); }
 };
 
-class F2fsDoSubmitBioFtraceEvent : public ::protozero::Message {
+class F2fsSubmitWritePageFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = F2fsDoSubmitBioFtraceEvent_Decoder;
+  using Decoder = F2fsSubmitWritePageFtraceEvent_Decoder;
   enum : int32_t {
     kDevFieldNumber = 1,
-    kBtypeFieldNumber = 2,
-    kSyncFieldNumber = 3,
-    kSectorFieldNumber = 4,
-    kSizeFieldNumber = 5,
+    kInoFieldNumber = 2,
+    kTypeFieldNumber = 3,
+    kIndexFieldNumber = 4,
+    kBlockFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.F2fsDoSubmitBioFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsSubmitWritePageFtraceEvent"; }
 
 
   using FieldMetadata_Dev =
@@ -98814,16 +128738,9 @@ class F2fsDoSubmitBioFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsDoSubmitBioFtraceEvent>;
+      F2fsSubmitWritePageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
+  static constexpr FieldMetadata_Dev kDev{};
   void set_dev(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -98833,74 +128750,53 @@ class F2fsDoSubmitBioFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Btype =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      F2fsDoSubmitBioFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsSubmitWritePageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Btype kBtype() { return {}; }
-  void set_btype(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Btype::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Sync =
+  using FieldMetadata_Type =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      F2fsDoSubmitBioFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsSubmitWritePageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sync kSync() { return {}; }
-  void set_sync(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Sync::kFieldId;
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Sector =
+  using FieldMetadata_Index =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      F2fsDoSubmitBioFtraceEvent>;
+      F2fsSubmitWritePageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sector kSector() { return {}; }
-  void set_sector(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId;
+  static constexpr FieldMetadata_Index kIndex{};
+  void set_index(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -98908,24 +128804,17 @@ class F2fsDoSubmitBioFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Size =
+  using FieldMetadata_Block =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      F2fsDoSubmitBioFtraceEvent>;
+      F2fsSubmitWritePageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Size kSize() { return {}; }
-  void set_size(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
+  static constexpr FieldMetadata_Block kBlock{};
+  void set_block(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Block::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -98934,72 +128823,89 @@ class F2fsDoSubmitBioFtraceEvent : public ::protozero::Message {
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/fastrpc.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FASTRPC_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FASTRPC_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class FastrpcDmaStatFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsSetPageDirtyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
-  FastrpcDmaStatFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit FastrpcDmaStatFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit FastrpcDmaStatFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_cid() const { return at<1>().valid(); }
-  int32_t cid() const { return at<1>().as_int32(); }
-  bool has_len() const { return at<2>().valid(); }
-  int64_t len() const { return at<2>().as_int64(); }
-  bool has_total_allocated() const { return at<3>().valid(); }
-  uint64_t total_allocated() const { return at<3>().as_uint64(); }
+  F2fsSetPageDirtyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsSetPageDirtyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsSetPageDirtyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_type() const { return at<3>().valid(); }
+  int32_t type() const { return at<3>().as_int32(); }
+  bool has_dir() const { return at<4>().valid(); }
+  int32_t dir() const { return at<4>().as_int32(); }
+  bool has_index() const { return at<5>().valid(); }
+  uint64_t index() const { return at<5>().as_uint64(); }
+  bool has_dirty() const { return at<6>().valid(); }
+  int32_t dirty() const { return at<6>().as_int32(); }
+  bool has_uptodate() const { return at<7>().valid(); }
+  int32_t uptodate() const { return at<7>().as_int32(); }
 };
 
-class FastrpcDmaStatFtraceEvent : public ::protozero::Message {
+class F2fsSetPageDirtyFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = FastrpcDmaStatFtraceEvent_Decoder;
+  using Decoder = F2fsSetPageDirtyFtraceEvent_Decoder;
   enum : int32_t {
-    kCidFieldNumber = 1,
-    kLenFieldNumber = 2,
-    kTotalAllocatedFieldNumber = 3,
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kTypeFieldNumber = 3,
+    kDirFieldNumber = 4,
+    kIndexFieldNumber = 5,
+    kDirtyFieldNumber = 6,
+    kUptodateFieldNumber = 7,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.FastrpcDmaStatFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsSetPageDirtyFtraceEvent"; }
 
 
-  using FieldMetadata_Cid =
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsSetPageDirtyFtraceEvent>;
+
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ino =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsSetPageDirtyFtraceEvent>;
+
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Type =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      FastrpcDmaStatFtraceEvent>;
+      F2fsSetPageDirtyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cid kCid() { return {}; }
-  void set_cid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Cid::kFieldId;
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -99007,546 +128913,604 @@ class FastrpcDmaStatFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_Dir =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      FastrpcDmaStatFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsSetPageDirtyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_Dir kDir{};
+  void set_dir(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dir::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TotalAllocated =
+  using FieldMetadata_Index =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      FastrpcDmaStatFtraceEvent>;
+      F2fsSetPageDirtyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TotalAllocated kTotalAllocated() { return {}; }
-  void set_total_allocated(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TotalAllocated::kFieldId;
+  static constexpr FieldMetadata_Index kIndex{};
+  void set_index(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/fence.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FENCE_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FENCE_PROTO_H_
 
-#include <stddef.h>
-#include <stdint.h>
+  using FieldMetadata_Dirty =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsSetPageDirtyFtraceEvent>;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  static constexpr FieldMetadata_Dirty kDirty{};
+  void set_dirty(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dirty::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  using FieldMetadata_Uptodate =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsSetPageDirtyFtraceEvent>;
 
+  static constexpr FieldMetadata_Uptodate kUptodate{};
+  void set_uptodate(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Uptodate::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
 
-class FenceSignaledFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsReserveNewBlockFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  FenceSignaledFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit FenceSignaledFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit FenceSignaledFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_context() const { return at<1>().valid(); }
-  uint32_t context() const { return at<1>().as_uint32(); }
-  bool has_driver() const { return at<2>().valid(); }
-  ::protozero::ConstChars driver() const { return at<2>().as_string(); }
-  bool has_seqno() const { return at<3>().valid(); }
-  uint32_t seqno() const { return at<3>().as_uint32(); }
-  bool has_timeline() const { return at<4>().valid(); }
-  ::protozero::ConstChars timeline() const { return at<4>().as_string(); }
+  F2fsReserveNewBlockFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsReserveNewBlockFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsReserveNewBlockFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_nid() const { return at<2>().valid(); }
+  uint32_t nid() const { return at<2>().as_uint32(); }
+  bool has_ofs_in_node() const { return at<3>().valid(); }
+  uint32_t ofs_in_node() const { return at<3>().as_uint32(); }
 };
 
-class FenceSignaledFtraceEvent : public ::protozero::Message {
+class F2fsReserveNewBlockFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = FenceSignaledFtraceEvent_Decoder;
+  using Decoder = F2fsReserveNewBlockFtraceEvent_Decoder;
   enum : int32_t {
-    kContextFieldNumber = 1,
-    kDriverFieldNumber = 2,
-    kSeqnoFieldNumber = 3,
-    kTimelineFieldNumber = 4,
+    kDevFieldNumber = 1,
+    kNidFieldNumber = 2,
+    kOfsInNodeFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.FenceSignaledFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsReserveNewBlockFtraceEvent"; }
 
 
-  using FieldMetadata_Context =
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      FenceSignaledFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsReserveNewBlockFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Context kContext() { return {}; }
-  void set_context(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Driver =
+  using FieldMetadata_Nid =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      FenceSignaledFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsReserveNewBlockFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Driver kDriver() { return {}; }
-  void set_driver(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Driver::kFieldId, data, size);
-  }
-  void set_driver(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Driver::kFieldId, chars.data, chars.size);
-  }
-  void set_driver(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Driver::kFieldId;
+  static constexpr FieldMetadata_Nid kNid{};
+  void set_nid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Seqno =
+  using FieldMetadata_OfsInNode =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      FenceSignaledFtraceEvent>;
+      F2fsReserveNewBlockFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Seqno kSeqno() { return {}; }
-  void set_seqno(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId;
+  static constexpr FieldMetadata_OfsInNode kOfsInNode{};
+  void set_ofs_in_node(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OfsInNode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-
-  using FieldMetadata_Timeline =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      FenceSignaledFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timeline kTimeline() { return {}; }
-  void set_timeline(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Timeline::kFieldId, data, size);
-  }
-  void set_timeline(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Timeline::kFieldId, chars.data, chars.size);
-  }
-  void set_timeline(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Timeline::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
 };
 
-class FenceEnableSignalFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsReadpageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
  public:
-  FenceEnableSignalFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit FenceEnableSignalFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit FenceEnableSignalFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_context() const { return at<1>().valid(); }
-  uint32_t context() const { return at<1>().as_uint32(); }
-  bool has_driver() const { return at<2>().valid(); }
-  ::protozero::ConstChars driver() const { return at<2>().as_string(); }
-  bool has_seqno() const { return at<3>().valid(); }
-  uint32_t seqno() const { return at<3>().as_uint32(); }
-  bool has_timeline() const { return at<4>().valid(); }
-  ::protozero::ConstChars timeline() const { return at<4>().as_string(); }
+  F2fsReadpageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsReadpageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsReadpageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_index() const { return at<3>().valid(); }
+  uint64_t index() const { return at<3>().as_uint64(); }
+  bool has_blkaddr() const { return at<4>().valid(); }
+  uint64_t blkaddr() const { return at<4>().as_uint64(); }
+  bool has_type() const { return at<5>().valid(); }
+  int32_t type() const { return at<5>().as_int32(); }
+  bool has_dir() const { return at<6>().valid(); }
+  int32_t dir() const { return at<6>().as_int32(); }
+  bool has_dirty() const { return at<7>().valid(); }
+  int32_t dirty() const { return at<7>().as_int32(); }
+  bool has_uptodate() const { return at<8>().valid(); }
+  int32_t uptodate() const { return at<8>().as_int32(); }
 };
 
-class FenceEnableSignalFtraceEvent : public ::protozero::Message {
+class F2fsReadpageFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = FenceEnableSignalFtraceEvent_Decoder;
+  using Decoder = F2fsReadpageFtraceEvent_Decoder;
   enum : int32_t {
-    kContextFieldNumber = 1,
-    kDriverFieldNumber = 2,
-    kSeqnoFieldNumber = 3,
-    kTimelineFieldNumber = 4,
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kIndexFieldNumber = 3,
+    kBlkaddrFieldNumber = 4,
+    kTypeFieldNumber = 5,
+    kDirFieldNumber = 6,
+    kDirtyFieldNumber = 7,
+    kUptodateFieldNumber = 8,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.FenceEnableSignalFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsReadpageFtraceEvent"; }
 
 
-  using FieldMetadata_Context =
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      FenceEnableSignalFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsReadpageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Context kContext() { return {}; }
-  void set_context(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Driver =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      FenceEnableSignalFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsReadpageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Driver kDriver() { return {}; }
-  void set_driver(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Driver::kFieldId, data, size);
-  }
-  void set_driver(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Driver::kFieldId, chars.data, chars.size);
-  }
-  void set_driver(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Driver::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Seqno =
+  using FieldMetadata_Index =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      FenceEnableSignalFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsReadpageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Seqno kSeqno() { return {}; }
-  void set_seqno(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId;
+  static constexpr FieldMetadata_Index kIndex{};
+  void set_index(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Timeline =
+  using FieldMetadata_Blkaddr =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      FenceEnableSignalFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsReadpageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timeline kTimeline() { return {}; }
-  void set_timeline(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Timeline::kFieldId, data, size);
+  static constexpr FieldMetadata_Blkaddr kBlkaddr{};
+  void set_blkaddr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Blkaddr::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
-  void set_timeline(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Timeline::kFieldId, chars.data, chars.size);
+
+  using FieldMetadata_Type =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsReadpageFtraceEvent>;
+
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
   }
-  void set_timeline(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Timeline::kFieldId;
+
+  using FieldMetadata_Dir =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsReadpageFtraceEvent>;
+
+  static constexpr FieldMetadata_Dir kDir{};
+  void set_dir(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dir::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Dirty =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsReadpageFtraceEvent>;
+
+  static constexpr FieldMetadata_Dirty kDirty{};
+  void set_dirty(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dirty::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Uptodate =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsReadpageFtraceEvent>;
+
+  static constexpr FieldMetadata_Uptodate kUptodate{};
+  void set_uptodate(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Uptodate::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class FenceDestroyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsNewInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  FenceDestroyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit FenceDestroyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit FenceDestroyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_context() const { return at<1>().valid(); }
-  uint32_t context() const { return at<1>().as_uint32(); }
-  bool has_driver() const { return at<2>().valid(); }
-  ::protozero::ConstChars driver() const { return at<2>().as_string(); }
-  bool has_seqno() const { return at<3>().valid(); }
-  uint32_t seqno() const { return at<3>().as_uint32(); }
-  bool has_timeline() const { return at<4>().valid(); }
-  ::protozero::ConstChars timeline() const { return at<4>().as_string(); }
+  F2fsNewInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsNewInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsNewInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_ret() const { return at<3>().valid(); }
+  int32_t ret() const { return at<3>().as_int32(); }
 };
 
-class FenceDestroyFtraceEvent : public ::protozero::Message {
+class F2fsNewInodeFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = FenceDestroyFtraceEvent_Decoder;
+  using Decoder = F2fsNewInodeFtraceEvent_Decoder;
   enum : int32_t {
-    kContextFieldNumber = 1,
-    kDriverFieldNumber = 2,
-    kSeqnoFieldNumber = 3,
-    kTimelineFieldNumber = 4,
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kRetFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.FenceDestroyFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsNewInodeFtraceEvent"; }
 
 
-  using FieldMetadata_Context =
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      FenceDestroyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsNewInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Context kContext() { return {}; }
-  void set_context(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Driver =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      FenceDestroyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsNewInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Driver kDriver() { return {}; }
-  void set_driver(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Driver::kFieldId, data, size);
-  }
-  void set_driver(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Driver::kFieldId, chars.data, chars.size);
-  }
-  void set_driver(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Driver::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Seqno =
+  using FieldMetadata_Ret =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      FenceDestroyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsNewInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Seqno kSeqno() { return {}; }
-  void set_seqno(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId;
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Timeline =
+class F2fsIgetExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  F2fsIgetExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsIgetExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsIgetExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_ret() const { return at<3>().valid(); }
+  int32_t ret() const { return at<3>().as_int32(); }
+};
+
+class F2fsIgetExitFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = F2fsIgetExitFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kRetFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsIgetExitFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      FenceDestroyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsIgetExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timeline kTimeline() { return {}; }
-  void set_timeline(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Timeline::kFieldId, data, size);
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
-  void set_timeline(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Timeline::kFieldId, chars.data, chars.size);
+
+  using FieldMetadata_Ino =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsIgetExitFtraceEvent>;
+
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
-  void set_timeline(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Timeline::kFieldId;
+
+  using FieldMetadata_Ret =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsIgetExitFtraceEvent>;
+
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class FenceInitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsIgetFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
  public:
-  FenceInitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit FenceInitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit FenceInitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_context() const { return at<1>().valid(); }
-  uint32_t context() const { return at<1>().as_uint32(); }
-  bool has_driver() const { return at<2>().valid(); }
-  ::protozero::ConstChars driver() const { return at<2>().as_string(); }
-  bool has_seqno() const { return at<3>().valid(); }
-  uint32_t seqno() const { return at<3>().as_uint32(); }
-  bool has_timeline() const { return at<4>().valid(); }
-  ::protozero::ConstChars timeline() const { return at<4>().as_string(); }
+  F2fsIgetFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsIgetFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsIgetFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_pino() const { return at<3>().valid(); }
+  uint64_t pino() const { return at<3>().as_uint64(); }
+  bool has_mode() const { return at<4>().valid(); }
+  uint32_t mode() const { return at<4>().as_uint32(); }
+  bool has_size() const { return at<5>().valid(); }
+  int64_t size() const { return at<5>().as_int64(); }
+  bool has_nlink() const { return at<6>().valid(); }
+  uint32_t nlink() const { return at<6>().as_uint32(); }
+  bool has_blocks() const { return at<7>().valid(); }
+  uint64_t blocks() const { return at<7>().as_uint64(); }
+  bool has_advise() const { return at<8>().valid(); }
+  uint32_t advise() const { return at<8>().as_uint32(); }
 };
 
-class FenceInitFtraceEvent : public ::protozero::Message {
+class F2fsIgetFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = FenceInitFtraceEvent_Decoder;
+  using Decoder = F2fsIgetFtraceEvent_Decoder;
   enum : int32_t {
-    kContextFieldNumber = 1,
-    kDriverFieldNumber = 2,
-    kSeqnoFieldNumber = 3,
-    kTimelineFieldNumber = 4,
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kPinoFieldNumber = 3,
+    kModeFieldNumber = 4,
+    kSizeFieldNumber = 5,
+    kNlinkFieldNumber = 6,
+    kBlocksFieldNumber = 7,
+    kAdviseFieldNumber = 8,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.FenceInitFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsIgetFtraceEvent"; }
+
+
+  using FieldMetadata_Dev =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsIgetFtraceEvent>;
+
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ino =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsIgetFtraceEvent>;
+
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Pino =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsIgetFtraceEvent>;
 
+  static constexpr FieldMetadata_Pino kPino{};
+  void set_pino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pino::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Context =
+  using FieldMetadata_Mode =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      FenceInitFtraceEvent>;
+      F2fsIgetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Context kContext() { return {}; }
-  void set_context(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId;
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -99554,55 +129518,35 @@ class FenceInitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Driver =
+  using FieldMetadata_Size =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      FenceInitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      F2fsIgetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Driver kDriver() { return {}; }
-  void set_driver(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Driver::kFieldId, data, size);
-  }
-  void set_driver(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Driver::kFieldId, chars.data, chars.size);
-  }
-  void set_driver(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Driver::kFieldId;
+  static constexpr FieldMetadata_Size kSize{};
+  void set_size(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Seqno =
+  using FieldMetadata_Nlink =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      FenceInitFtraceEvent>;
+      F2fsIgetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Seqno kSeqno() { return {}; }
-  void set_seqno(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId;
+  static constexpr FieldMetadata_Nlink kNlink{};
+  void set_nlink(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Nlink::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -99610,110 +129554,102 @@ class FenceInitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Timeline =
+  using FieldMetadata_Blocks =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      FenceInitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsIgetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timeline kTimeline() { return {}; }
-  void set_timeline(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Timeline::kFieldId, data, size);
-  }
-  void set_timeline(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Timeline::kFieldId, chars.data, chars.size);
-  }
-  void set_timeline(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Timeline::kFieldId;
+  static constexpr FieldMetadata_Blocks kBlocks{};
+  void set_blocks(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/filemap.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FILEMAP_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FILEMAP_PROTO_H_
 
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  using FieldMetadata_Advise =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsIgetFtraceEvent>;
 
+  static constexpr FieldMetadata_Advise kAdvise{};
+  void set_advise(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Advise::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
 
-class MmFilemapDeleteFromPageCacheFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsGetVictimFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11> {
  public:
-  MmFilemapDeleteFromPageCacheFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MmFilemapDeleteFromPageCacheFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MmFilemapDeleteFromPageCacheFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pfn() const { return at<1>().valid(); }
-  uint64_t pfn() const { return at<1>().as_uint64(); }
-  bool has_i_ino() const { return at<2>().valid(); }
-  uint64_t i_ino() const { return at<2>().as_uint64(); }
-  bool has_index() const { return at<3>().valid(); }
-  uint64_t index() const { return at<3>().as_uint64(); }
-  bool has_s_dev() const { return at<4>().valid(); }
-  uint64_t s_dev() const { return at<4>().as_uint64(); }
-  bool has_page() const { return at<5>().valid(); }
-  uint64_t page() const { return at<5>().as_uint64(); }
+  F2fsGetVictimFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsGetVictimFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsGetVictimFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_type() const { return at<2>().valid(); }
+  int32_t type() const { return at<2>().as_int32(); }
+  bool has_gc_type() const { return at<3>().valid(); }
+  int32_t gc_type() const { return at<3>().as_int32(); }
+  bool has_alloc_mode() const { return at<4>().valid(); }
+  int32_t alloc_mode() const { return at<4>().as_int32(); }
+  bool has_gc_mode() const { return at<5>().valid(); }
+  int32_t gc_mode() const { return at<5>().as_int32(); }
+  bool has_victim() const { return at<6>().valid(); }
+  uint32_t victim() const { return at<6>().as_uint32(); }
+  bool has_ofs_unit() const { return at<7>().valid(); }
+  uint32_t ofs_unit() const { return at<7>().as_uint32(); }
+  bool has_pre_victim() const { return at<8>().valid(); }
+  uint32_t pre_victim() const { return at<8>().as_uint32(); }
+  bool has_prefree() const { return at<9>().valid(); }
+  uint32_t prefree() const { return at<9>().as_uint32(); }
+  bool has_free() const { return at<10>().valid(); }
+  uint32_t free() const { return at<10>().as_uint32(); }
+  bool has_cost() const { return at<11>().valid(); }
+  uint32_t cost() const { return at<11>().as_uint32(); }
 };
 
-class MmFilemapDeleteFromPageCacheFtraceEvent : public ::protozero::Message {
+class F2fsGetVictimFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MmFilemapDeleteFromPageCacheFtraceEvent_Decoder;
+  using Decoder = F2fsGetVictimFtraceEvent_Decoder;
   enum : int32_t {
-    kPfnFieldNumber = 1,
-    kIInoFieldNumber = 2,
-    kIndexFieldNumber = 3,
-    kSDevFieldNumber = 4,
-    kPageFieldNumber = 5,
+    kDevFieldNumber = 1,
+    kTypeFieldNumber = 2,
+    kGcTypeFieldNumber = 3,
+    kAllocModeFieldNumber = 4,
+    kGcModeFieldNumber = 5,
+    kVictimFieldNumber = 6,
+    kOfsUnitFieldNumber = 7,
+    kPreVictimFieldNumber = 8,
+    kPrefreeFieldNumber = 9,
+    kFreeFieldNumber = 10,
+    kCostFieldNumber = 11,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MmFilemapDeleteFromPageCacheFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsGetVictimFtraceEvent"; }
 
 
-  using FieldMetadata_Pfn =
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MmFilemapDeleteFromPageCacheFtraceEvent>;
+      F2fsGetVictimFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pfn kPfn() { return {}; }
-  void set_pfn(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -99721,335 +129657,231 @@ class MmFilemapDeleteFromPageCacheFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IIno =
+  using FieldMetadata_Type =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MmFilemapDeleteFromPageCacheFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsGetVictimFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IIno kIIno() { return {}; }
-  void set_i_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IIno::kFieldId;
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Index =
+  using FieldMetadata_GcType =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MmFilemapDeleteFromPageCacheFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsGetVictimFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Index kIndex() { return {}; }
-  void set_index(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
+  static constexpr FieldMetadata_GcType kGcType{};
+  void set_gc_type(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GcType::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SDev =
+  using FieldMetadata_AllocMode =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MmFilemapDeleteFromPageCacheFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsGetVictimFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SDev kSDev() { return {}; }
-  void set_s_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SDev::kFieldId;
+  static constexpr FieldMetadata_AllocMode kAllocMode{};
+  void set_alloc_mode(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AllocMode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Page =
+  using FieldMetadata_GcMode =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MmFilemapDeleteFromPageCacheFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsGetVictimFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Page kPage() { return {}; }
-  void set_page(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId;
+  static constexpr FieldMetadata_GcMode kGcMode{};
+  void set_gc_mode(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GcMode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-class MmFilemapAddToPageCacheFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  MmFilemapAddToPageCacheFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MmFilemapAddToPageCacheFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MmFilemapAddToPageCacheFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pfn() const { return at<1>().valid(); }
-  uint64_t pfn() const { return at<1>().as_uint64(); }
-  bool has_i_ino() const { return at<2>().valid(); }
-  uint64_t i_ino() const { return at<2>().as_uint64(); }
-  bool has_index() const { return at<3>().valid(); }
-  uint64_t index() const { return at<3>().as_uint64(); }
-  bool has_s_dev() const { return at<4>().valid(); }
-  uint64_t s_dev() const { return at<4>().as_uint64(); }
-  bool has_page() const { return at<5>().valid(); }
-  uint64_t page() const { return at<5>().as_uint64(); }
-};
 
-class MmFilemapAddToPageCacheFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = MmFilemapAddToPageCacheFtraceEvent_Decoder;
-  enum : int32_t {
-    kPfnFieldNumber = 1,
-    kIInoFieldNumber = 2,
-    kIndexFieldNumber = 3,
-    kSDevFieldNumber = 4,
-    kPageFieldNumber = 5,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.MmFilemapAddToPageCacheFtraceEvent"; }
+  using FieldMetadata_Victim =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsGetVictimFtraceEvent>;
 
+  static constexpr FieldMetadata_Victim kVictim{};
+  void set_victim(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Victim::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Pfn =
+  using FieldMetadata_OfsUnit =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MmFilemapAddToPageCacheFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsGetVictimFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pfn kPfn() { return {}; }
-  void set_pfn(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId;
+  static constexpr FieldMetadata_OfsUnit kOfsUnit{};
+  void set_ofs_unit(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OfsUnit::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IIno =
+  using FieldMetadata_PreVictim =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MmFilemapAddToPageCacheFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsGetVictimFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IIno kIIno() { return {}; }
-  void set_i_ino(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IIno::kFieldId;
+  static constexpr FieldMetadata_PreVictim kPreVictim{};
+  void set_pre_victim(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PreVictim::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Index =
+  using FieldMetadata_Prefree =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MmFilemapAddToPageCacheFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsGetVictimFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Index kIndex() { return {}; }
-  void set_index(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
+  static constexpr FieldMetadata_Prefree kPrefree{};
+  void set_prefree(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prefree::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SDev =
+  using FieldMetadata_Free =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MmFilemapAddToPageCacheFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsGetVictimFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SDev kSDev() { return {}; }
-  void set_s_dev(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SDev::kFieldId;
+  static constexpr FieldMetadata_Free kFree{};
+  void set_free(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Free::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Page =
+  using FieldMetadata_Cost =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MmFilemapAddToPageCacheFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsGetVictimFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Page kPage() { return {}; }
-  void set_page(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId;
+  static constexpr FieldMetadata_Cost kCost{};
+  void set_cost(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cost::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/ftrace.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FTRACE_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FTRACE_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class FuncgraphExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsGetDataBlockFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  FuncgraphExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit FuncgraphExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit FuncgraphExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_calltime() const { return at<1>().valid(); }
-  uint64_t calltime() const { return at<1>().as_uint64(); }
-  bool has_depth() const { return at<2>().valid(); }
-  int32_t depth() const { return at<2>().as_int32(); }
-  bool has_func() const { return at<3>().valid(); }
-  uint64_t func() const { return at<3>().as_uint64(); }
-  bool has_overrun() const { return at<4>().valid(); }
-  uint64_t overrun() const { return at<4>().as_uint64(); }
-  bool has_rettime() const { return at<5>().valid(); }
-  uint64_t rettime() const { return at<5>().as_uint64(); }
+  F2fsGetDataBlockFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsGetDataBlockFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsGetDataBlockFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_iblock() const { return at<3>().valid(); }
+  uint64_t iblock() const { return at<3>().as_uint64(); }
+  bool has_bh_start() const { return at<4>().valid(); }
+  uint64_t bh_start() const { return at<4>().as_uint64(); }
+  bool has_bh_size() const { return at<5>().valid(); }
+  uint64_t bh_size() const { return at<5>().as_uint64(); }
+  bool has_ret() const { return at<6>().valid(); }
+  int32_t ret() const { return at<6>().as_int32(); }
 };
 
-class FuncgraphExitFtraceEvent : public ::protozero::Message {
+class F2fsGetDataBlockFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = FuncgraphExitFtraceEvent_Decoder;
+  using Decoder = F2fsGetDataBlockFtraceEvent_Decoder;
   enum : int32_t {
-    kCalltimeFieldNumber = 1,
-    kDepthFieldNumber = 2,
-    kFuncFieldNumber = 3,
-    kOverrunFieldNumber = 4,
-    kRettimeFieldNumber = 5,
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kIblockFieldNumber = 3,
+    kBhStartFieldNumber = 4,
+    kBhSizeFieldNumber = 5,
+    kRetFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.FuncgraphExitFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsGetDataBlockFtraceEvent"; }
 
 
-  using FieldMetadata_Calltime =
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      FuncgraphExitFtraceEvent>;
+      F2fsGetDataBlockFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Calltime kCalltime() { return {}; }
-  void set_calltime(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Calltime::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -100057,49 +129889,35 @@ class FuncgraphExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Depth =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      FuncgraphExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsGetDataBlockFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Depth kDepth() { return {}; }
-  void set_depth(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Depth::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Func =
+  using FieldMetadata_Iblock =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      FuncgraphExitFtraceEvent>;
+      F2fsGetDataBlockFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Func kFunc() { return {}; }
-  void set_func(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Func::kFieldId;
+  static constexpr FieldMetadata_Iblock kIblock{};
+  void set_iblock(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Iblock::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -100107,24 +129925,17 @@ class FuncgraphExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Overrun =
+  using FieldMetadata_BhStart =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      FuncgraphExitFtraceEvent>;
+      F2fsGetDataBlockFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Overrun kOverrun() { return {}; }
-  void set_overrun(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Overrun::kFieldId;
+  static constexpr FieldMetadata_BhStart kBhStart{};
+  void set_bh_start(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BhStart::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -100132,143 +129943,93 @@ class FuncgraphExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Rettime =
+  using FieldMetadata_BhSize =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      FuncgraphExitFtraceEvent>;
+      F2fsGetDataBlockFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Rettime kRettime() { return {}; }
-  void set_rettime(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Rettime::kFieldId;
+  static constexpr FieldMetadata_BhSize kBhSize{};
+  void set_bh_size(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BhSize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class FuncgraphEntryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  FuncgraphEntryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit FuncgraphEntryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit FuncgraphEntryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_depth() const { return at<1>().valid(); }
-  int32_t depth() const { return at<1>().as_int32(); }
-  bool has_func() const { return at<2>().valid(); }
-  uint64_t func() const { return at<2>().as_uint64(); }
-};
-
-class FuncgraphEntryFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = FuncgraphEntryFtraceEvent_Decoder;
-  enum : int32_t {
-    kDepthFieldNumber = 1,
-    kFuncFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.FuncgraphEntryFtraceEvent"; }
 
-
-  using FieldMetadata_Depth =
+  using FieldMetadata_Ret =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      FuncgraphEntryFtraceEvent>;
+      F2fsGetDataBlockFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Depth kDepth() { return {}; }
-  void set_depth(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Depth::kFieldId;
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-
-  using FieldMetadata_Func =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      FuncgraphEntryFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Func kFunc() { return {}; }
-  void set_func(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Func::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
 };
 
-class PrintFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsFallocateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
  public:
-  PrintFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit PrintFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit PrintFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_ip() const { return at<1>().valid(); }
-  uint64_t ip() const { return at<1>().as_uint64(); }
-  bool has_buf() const { return at<2>().valid(); }
-  ::protozero::ConstChars buf() const { return at<2>().as_string(); }
+  F2fsFallocateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsFallocateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsFallocateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_mode() const { return at<3>().valid(); }
+  int32_t mode() const { return at<3>().as_int32(); }
+  bool has_offset() const { return at<4>().valid(); }
+  int64_t offset() const { return at<4>().as_int64(); }
+  bool has_len() const { return at<5>().valid(); }
+  int64_t len() const { return at<5>().as_int64(); }
+  bool has_size() const { return at<6>().valid(); }
+  int64_t size() const { return at<6>().as_int64(); }
+  bool has_blocks() const { return at<7>().valid(); }
+  uint64_t blocks() const { return at<7>().as_uint64(); }
+  bool has_ret() const { return at<8>().valid(); }
+  int32_t ret() const { return at<8>().as_int32(); }
 };
 
-class PrintFtraceEvent : public ::protozero::Message {
+class F2fsFallocateFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = PrintFtraceEvent_Decoder;
+  using Decoder = F2fsFallocateFtraceEvent_Decoder;
   enum : int32_t {
-    kIpFieldNumber = 1,
-    kBufFieldNumber = 2,
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kModeFieldNumber = 3,
+    kOffsetFieldNumber = 4,
+    kLenFieldNumber = 5,
+    kSizeFieldNumber = 6,
+    kBlocksFieldNumber = 7,
+    kRetFieldNumber = 8,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.PrintFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsFallocateFtraceEvent"; }
 
 
-  using FieldMetadata_Ip =
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      PrintFtraceEvent>;
+      F2fsFallocateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ip kIp() { return {}; }
-  void set_ip(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ip::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -100276,107 +130037,35 @@ class PrintFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Buf =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      PrintFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsFallocateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Buf kBuf() { return {}; }
-  void set_buf(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Buf::kFieldId, data, size);
-  }
-  void set_buf(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Buf::kFieldId, chars.data, chars.size);
-  }
-  void set_buf(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Buf::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/g2d.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_G2D_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_G2D_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class G2dTracingMarkWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  G2dTracingMarkWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit G2dTracingMarkWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit G2dTracingMarkWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pid() const { return at<1>().valid(); }
-  int32_t pid() const { return at<1>().as_int32(); }
-  bool has_name() const { return at<4>().valid(); }
-  ::protozero::ConstChars name() const { return at<4>().as_string(); }
-  bool has_type() const { return at<5>().valid(); }
-  uint32_t type() const { return at<5>().as_uint32(); }
-  bool has_value() const { return at<6>().valid(); }
-  int32_t value() const { return at<6>().as_int32(); }
-};
-
-class G2dTracingMarkWriteFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = G2dTracingMarkWriteFtraceEvent_Decoder;
-  enum : int32_t {
-    kPidFieldNumber = 1,
-    kNameFieldNumber = 4,
-    kTypeFieldNumber = 5,
-    kValueFieldNumber = 6,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.G2dTracingMarkWriteFtraceEvent"; }
-
-
-  using FieldMetadata_Pid =
+  using FieldMetadata_Mode =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      G2dTracingMarkWriteFtraceEvent>;
+      F2fsFallocateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -100384,331 +130073,165 @@ class G2dTracingMarkWriteFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Name =
+  using FieldMetadata_Offset =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      G2dTracingMarkWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      F2fsFallocateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_Offset kOffset{};
+  void set_offset(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Type =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      G2dTracingMarkWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      F2fsFallocateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Value =
+  using FieldMetadata_Size =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      G2dTracingMarkWriteFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/gpu_mem.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_GPU_MEM_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_GPU_MEM_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class GpuMemTotalFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  GpuMemTotalFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit GpuMemTotalFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit GpuMemTotalFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_gpu_id() const { return at<1>().valid(); }
-  uint32_t gpu_id() const { return at<1>().as_uint32(); }
-  bool has_pid() const { return at<2>().valid(); }
-  uint32_t pid() const { return at<2>().as_uint32(); }
-  bool has_size() const { return at<3>().valid(); }
-  uint64_t size() const { return at<3>().as_uint64(); }
-};
-
-class GpuMemTotalFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = GpuMemTotalFtraceEvent_Decoder;
-  enum : int32_t {
-    kGpuIdFieldNumber = 1,
-    kPidFieldNumber = 2,
-    kSizeFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.GpuMemTotalFtraceEvent"; }
-
-
-  using FieldMetadata_GpuId =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      GpuMemTotalFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      F2fsFallocateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GpuId kGpuId() { return {}; }
-  void set_gpu_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GpuId::kFieldId;
+  static constexpr FieldMetadata_Size kSize{};
+  void set_size(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_Blocks =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      GpuMemTotalFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsFallocateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_Blocks kBlocks{};
+  void set_blocks(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Size =
+  using FieldMetadata_Ret =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      GpuMemTotalFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsFallocateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Size kSize() { return {}; }
-  void set_size(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/gpu_scheduler.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_GPU_SCHEDULER_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_GPU_SCHEDULER_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class DrmSchedProcessJobFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsEvictInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
  public:
-  DrmSchedProcessJobFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit DrmSchedProcessJobFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit DrmSchedProcessJobFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_fence() const { return at<1>().valid(); }
-  uint64_t fence() const { return at<1>().as_uint64(); }
+  F2fsEvictInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsEvictInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsEvictInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_ino() const { return at<2>().valid(); }
+  uint64_t ino() const { return at<2>().as_uint64(); }
+  bool has_pino() const { return at<3>().valid(); }
+  uint64_t pino() const { return at<3>().as_uint64(); }
+  bool has_mode() const { return at<4>().valid(); }
+  uint32_t mode() const { return at<4>().as_uint32(); }
+  bool has_size() const { return at<5>().valid(); }
+  int64_t size() const { return at<5>().as_int64(); }
+  bool has_nlink() const { return at<6>().valid(); }
+  uint32_t nlink() const { return at<6>().as_uint32(); }
+  bool has_blocks() const { return at<7>().valid(); }
+  uint64_t blocks() const { return at<7>().as_uint64(); }
+  bool has_advise() const { return at<8>().valid(); }
+  uint32_t advise() const { return at<8>().as_uint32(); }
 };
 
-class DrmSchedProcessJobFtraceEvent : public ::protozero::Message {
+class F2fsEvictInodeFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = DrmSchedProcessJobFtraceEvent_Decoder;
+  using Decoder = F2fsEvictInodeFtraceEvent_Decoder;
   enum : int32_t {
-    kFenceFieldNumber = 1,
+    kDevFieldNumber = 1,
+    kInoFieldNumber = 2,
+    kPinoFieldNumber = 3,
+    kModeFieldNumber = 4,
+    kSizeFieldNumber = 5,
+    kNlinkFieldNumber = 6,
+    kBlocksFieldNumber = 7,
+    kAdviseFieldNumber = 8,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.DrmSchedProcessJobFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsEvictInodeFtraceEvent"; }
 
 
-  using FieldMetadata_Fence =
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      DrmSchedProcessJobFtraceEvent>;
+      F2fsEvictInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Fence kFence() { return {}; }
-  void set_fence(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Fence::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class DrmRunJobFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  DrmRunJobFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit DrmRunJobFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit DrmRunJobFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_entity() const { return at<1>().valid(); }
-  uint64_t entity() const { return at<1>().as_uint64(); }
-  bool has_fence() const { return at<2>().valid(); }
-  uint64_t fence() const { return at<2>().as_uint64(); }
-  bool has_hw_job_count() const { return at<3>().valid(); }
-  int32_t hw_job_count() const { return at<3>().as_int32(); }
-  bool has_id() const { return at<4>().valid(); }
-  uint64_t id() const { return at<4>().as_uint64(); }
-  bool has_job_count() const { return at<5>().valid(); }
-  uint32_t job_count() const { return at<5>().as_uint32(); }
-  bool has_name() const { return at<6>().valid(); }
-  ::protozero::ConstChars name() const { return at<6>().as_string(); }
-};
-
-class DrmRunJobFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = DrmRunJobFtraceEvent_Decoder;
-  enum : int32_t {
-    kEntityFieldNumber = 1,
-    kFenceFieldNumber = 2,
-    kHwJobCountFieldNumber = 3,
-    kIdFieldNumber = 4,
-    kJobCountFieldNumber = 5,
-    kNameFieldNumber = 6,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.DrmRunJobFtraceEvent"; }
-
 
-  using FieldMetadata_Entity =
+  using FieldMetadata_Ino =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      DrmRunJobFtraceEvent>;
+      F2fsEvictInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Entity kEntity() { return {}; }
-  void set_entity(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Entity::kFieldId;
+  static constexpr FieldMetadata_Ino kIno{};
+  void set_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -100716,24 +130239,17 @@ class DrmRunJobFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Fence =
+  using FieldMetadata_Pino =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      DrmRunJobFtraceEvent>;
+      F2fsEvictInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Fence kFence() { return {}; }
-  void set_fence(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Fence::kFieldId;
+  static constexpr FieldMetadata_Pino kPino{};
+  void set_pino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pino::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -100741,74 +130257,53 @@ class DrmRunJobFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_HwJobCount =
+  using FieldMetadata_Mode =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      DrmRunJobFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsEvictInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HwJobCount kHwJobCount() { return {}; }
-  void set_hw_job_count(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_HwJobCount::kFieldId;
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Id =
+  using FieldMetadata_Size =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      DrmRunJobFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      F2fsEvictInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
-  void set_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+  static constexpr FieldMetadata_Size kSize{};
+  void set_size(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_JobCount =
+  using FieldMetadata_Nlink =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      DrmRunJobFtraceEvent>;
+      F2fsEvictInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_JobCount kJobCount() { return {}; }
-  void set_job_count(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_JobCount::kFieldId;
+  static constexpr FieldMetadata_Nlink kNlink{};
+  void set_nlink(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Nlink::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -100816,89 +130311,84 @@ class DrmRunJobFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Name =
+  using FieldMetadata_Blocks =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      DrmRunJobFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      F2fsEvictInodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  static constexpr FieldMetadata_Blocks kBlocks{};
+  void set_blocks(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+
+  using FieldMetadata_Advise =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsEvictInodeFtraceEvent>;
+
+  static constexpr FieldMetadata_Advise kAdvise{};
+  void set_advise(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Advise::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class DrmSchedJobFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class F2fsDoSubmitBioFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  DrmSchedJobFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit DrmSchedJobFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit DrmSchedJobFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_entity() const { return at<1>().valid(); }
-  uint64_t entity() const { return at<1>().as_uint64(); }
-  bool has_fence() const { return at<2>().valid(); }
-  uint64_t fence() const { return at<2>().as_uint64(); }
-  bool has_hw_job_count() const { return at<3>().valid(); }
-  int32_t hw_job_count() const { return at<3>().as_int32(); }
-  bool has_id() const { return at<4>().valid(); }
-  uint64_t id() const { return at<4>().as_uint64(); }
-  bool has_job_count() const { return at<5>().valid(); }
-  uint32_t job_count() const { return at<5>().as_uint32(); }
-  bool has_name() const { return at<6>().valid(); }
-  ::protozero::ConstChars name() const { return at<6>().as_string(); }
+  F2fsDoSubmitBioFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit F2fsDoSubmitBioFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit F2fsDoSubmitBioFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev() const { return at<1>().valid(); }
+  uint64_t dev() const { return at<1>().as_uint64(); }
+  bool has_btype() const { return at<2>().valid(); }
+  int32_t btype() const { return at<2>().as_int32(); }
+  bool has_sync() const { return at<3>().valid(); }
+  uint32_t sync() const { return at<3>().as_uint32(); }
+  bool has_sector() const { return at<4>().valid(); }
+  uint64_t sector() const { return at<4>().as_uint64(); }
+  bool has_size() const { return at<5>().valid(); }
+  uint32_t size() const { return at<5>().as_uint32(); }
 };
 
-class DrmSchedJobFtraceEvent : public ::protozero::Message {
+class F2fsDoSubmitBioFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = DrmSchedJobFtraceEvent_Decoder;
+  using Decoder = F2fsDoSubmitBioFtraceEvent_Decoder;
   enum : int32_t {
-    kEntityFieldNumber = 1,
-    kFenceFieldNumber = 2,
-    kHwJobCountFieldNumber = 3,
-    kIdFieldNumber = 4,
-    kJobCountFieldNumber = 5,
-    kNameFieldNumber = 6,
+    kDevFieldNumber = 1,
+    kBtypeFieldNumber = 2,
+    kSyncFieldNumber = 3,
+    kSectorFieldNumber = 4,
+    kSizeFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.DrmSchedJobFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.F2fsDoSubmitBioFtraceEvent"; }
 
 
-  using FieldMetadata_Entity =
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      DrmSchedJobFtraceEvent>;
+      F2fsDoSubmitBioFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Entity kEntity() { return {}; }
-  void set_entity(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Entity::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -100906,74 +130396,53 @@ class DrmSchedJobFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Fence =
+  using FieldMetadata_Btype =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      DrmSchedJobFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      F2fsDoSubmitBioFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Fence kFence() { return {}; }
-  void set_fence(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Fence::kFieldId;
+  static constexpr FieldMetadata_Btype kBtype{};
+  void set_btype(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Btype::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_HwJobCount =
+  using FieldMetadata_Sync =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      DrmSchedJobFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      F2fsDoSubmitBioFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HwJobCount kHwJobCount() { return {}; }
-  void set_hw_job_count(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_HwJobCount::kFieldId;
+  static constexpr FieldMetadata_Sync kSync{};
+  void set_sync(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Sync::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Id =
+  using FieldMetadata_Sector =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      DrmSchedJobFtraceEvent>;
+      F2fsDoSubmitBioFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
-  void set_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+  static constexpr FieldMetadata_Sector kSector{};
+  void set_sector(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -100981,72 +130450,34 @@ class DrmSchedJobFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_JobCount =
+  using FieldMetadata_Size =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      DrmSchedJobFtraceEvent>;
+      F2fsDoSubmitBioFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_JobCount kJobCount() { return {}; }
-  void set_job_count(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_JobCount::kFieldId;
+  static constexpr FieldMetadata_Size kSize{};
+  void set_size(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-
-  using FieldMetadata_Name =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      DrmSchedJobFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
 };
 
 } // Namespace.
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/i2c.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/fastrpc.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_I2C_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_I2C_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FASTRPC_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FASTRPC_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -101057,62 +130488,58 @@ class DrmSchedJobFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class SmbusReplyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class FastrpcDmaMapFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
-  SmbusReplyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SmbusReplyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SmbusReplyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_adapter_nr() const { return at<1>().valid(); }
-  int32_t adapter_nr() const { return at<1>().as_int32(); }
-  bool has_addr() const { return at<2>().valid(); }
-  uint32_t addr() const { return at<2>().as_uint32(); }
-  bool has_flags() const { return at<3>().valid(); }
-  uint32_t flags() const { return at<3>().as_uint32(); }
-  bool has_command() const { return at<4>().valid(); }
-  uint32_t command() const { return at<4>().as_uint32(); }
+  FastrpcDmaMapFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FastrpcDmaMapFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FastrpcDmaMapFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cid() const { return at<1>().valid(); }
+  int32_t cid() const { return at<1>().as_int32(); }
+  bool has_fd() const { return at<2>().valid(); }
+  int32_t fd() const { return at<2>().as_int32(); }
+  bool has_phys() const { return at<3>().valid(); }
+  uint64_t phys() const { return at<3>().as_uint64(); }
+  bool has_size() const { return at<4>().valid(); }
+  uint64_t size() const { return at<4>().as_uint64(); }
   bool has_len() const { return at<5>().valid(); }
-  uint32_t len() const { return at<5>().as_uint32(); }
-  bool has_protocol() const { return at<6>().valid(); }
-  uint32_t protocol() const { return at<6>().as_uint32(); }
+  uint64_t len() const { return at<5>().as_uint64(); }
+  bool has_attr() const { return at<6>().valid(); }
+  uint32_t attr() const { return at<6>().as_uint32(); }
+  bool has_mflags() const { return at<7>().valid(); }
+  int32_t mflags() const { return at<7>().as_int32(); }
 };
 
-class SmbusReplyFtraceEvent : public ::protozero::Message {
+class FastrpcDmaMapFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SmbusReplyFtraceEvent_Decoder;
+  using Decoder = FastrpcDmaMapFtraceEvent_Decoder;
   enum : int32_t {
-    kAdapterNrFieldNumber = 1,
-    kAddrFieldNumber = 2,
-    kFlagsFieldNumber = 3,
-    kCommandFieldNumber = 4,
+    kCidFieldNumber = 1,
+    kFdFieldNumber = 2,
+    kPhysFieldNumber = 3,
+    kSizeFieldNumber = 4,
     kLenFieldNumber = 5,
-    kProtocolFieldNumber = 6,
+    kAttrFieldNumber = 6,
+    kMflagsFieldNumber = 7,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SmbusReplyFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.FastrpcDmaMapFtraceEvent"; }
 
 
-  using FieldMetadata_AdapterNr =
+  using FieldMetadata_Cid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      SmbusReplyFtraceEvent>;
+      FastrpcDmaMapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AdapterNr kAdapterNr() { return {}; }
-  void set_adapter_nr(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId;
+  static constexpr FieldMetadata_Cid kCid{};
+  void set_cid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -101120,78 +130547,57 @@ class SmbusReplyFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Addr =
+  using FieldMetadata_Fd =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SmbusReplyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      FastrpcDmaMapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Addr kAddr() { return {}; }
-  void set_addr(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId;
+  static constexpr FieldMetadata_Fd kFd{};
+  void set_fd(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Fd::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_Phys =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SmbusReplyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FastrpcDmaMapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_Phys kPhys{};
+  void set_phys(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Phys::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Command =
+  using FieldMetadata_Size =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SmbusReplyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FastrpcDmaMapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Command kCommand() { return {}; }
-  void set_command(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Command::kFieldId;
+  static constexpr FieldMetadata_Size kSize{};
+  void set_size(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
@@ -101199,107 +130605,92 @@ class SmbusReplyFtraceEvent : public ::protozero::Message {
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SmbusReplyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FastrpcDmaMapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Protocol =
+  using FieldMetadata_Attr =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SmbusReplyFtraceEvent>;
+      FastrpcDmaMapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Protocol kProtocol() { return {}; }
-  void set_protocol(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Protocol::kFieldId;
+  static constexpr FieldMetadata_Attr kAttr{};
+  void set_attr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Attr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_Mflags =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      FastrpcDmaMapFtraceEvent>;
+
+  static constexpr FieldMetadata_Mflags kMflags{};
+  void set_mflags(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mflags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class SmbusResultFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class FastrpcDmaUnmapFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  SmbusResultFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SmbusResultFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SmbusResultFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_adapter_nr() const { return at<1>().valid(); }
-  int32_t adapter_nr() const { return at<1>().as_int32(); }
-  bool has_addr() const { return at<2>().valid(); }
-  uint32_t addr() const { return at<2>().as_uint32(); }
-  bool has_flags() const { return at<3>().valid(); }
-  uint32_t flags() const { return at<3>().as_uint32(); }
-  bool has_read_write() const { return at<4>().valid(); }
-  uint32_t read_write() const { return at<4>().as_uint32(); }
-  bool has_command() const { return at<5>().valid(); }
-  uint32_t command() const { return at<5>().as_uint32(); }
-  bool has_res() const { return at<6>().valid(); }
-  int32_t res() const { return at<6>().as_int32(); }
-  bool has_protocol() const { return at<7>().valid(); }
-  uint32_t protocol() const { return at<7>().as_uint32(); }
+  FastrpcDmaUnmapFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FastrpcDmaUnmapFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FastrpcDmaUnmapFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cid() const { return at<1>().valid(); }
+  int32_t cid() const { return at<1>().as_int32(); }
+  bool has_phys() const { return at<2>().valid(); }
+  uint64_t phys() const { return at<2>().as_uint64(); }
+  bool has_size() const { return at<3>().valid(); }
+  uint64_t size() const { return at<3>().as_uint64(); }
 };
 
-class SmbusResultFtraceEvent : public ::protozero::Message {
+class FastrpcDmaUnmapFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SmbusResultFtraceEvent_Decoder;
+  using Decoder = FastrpcDmaUnmapFtraceEvent_Decoder;
   enum : int32_t {
-    kAdapterNrFieldNumber = 1,
-    kAddrFieldNumber = 2,
-    kFlagsFieldNumber = 3,
-    kReadWriteFieldNumber = 4,
-    kCommandFieldNumber = 5,
-    kResFieldNumber = 6,
-    kProtocolFieldNumber = 7,
+    kCidFieldNumber = 1,
+    kPhysFieldNumber = 2,
+    kSizeFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SmbusResultFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.FastrpcDmaUnmapFtraceEvent"; }
 
 
-  using FieldMetadata_AdapterNr =
+  using FieldMetadata_Cid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      SmbusResultFtraceEvent>;
+      FastrpcDmaUnmapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AdapterNr kAdapterNr() { return {}; }
-  void set_adapter_nr(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId;
+  static constexpr FieldMetadata_Cid kCid{};
+  void set_cid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -101307,208 +130698,199 @@ class SmbusResultFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Addr =
+  using FieldMetadata_Phys =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SmbusResultFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FastrpcDmaUnmapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Addr kAddr() { return {}; }
-  void set_addr(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId;
+  static constexpr FieldMetadata_Phys kPhys{};
+  void set_phys(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Phys::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_Size =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SmbusResultFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FastrpcDmaUnmapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_Size kSize{};
+  void set_size(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_ReadWrite =
+class FastrpcDmaAllocFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  FastrpcDmaAllocFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FastrpcDmaAllocFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FastrpcDmaAllocFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cid() const { return at<1>().valid(); }
+  int32_t cid() const { return at<1>().as_int32(); }
+  bool has_phys() const { return at<2>().valid(); }
+  uint64_t phys() const { return at<2>().as_uint64(); }
+  bool has_size() const { return at<3>().valid(); }
+  uint64_t size() const { return at<3>().as_uint64(); }
+  bool has_attr() const { return at<4>().valid(); }
+  uint64_t attr() const { return at<4>().as_uint64(); }
+  bool has_mflags() const { return at<5>().valid(); }
+  int32_t mflags() const { return at<5>().as_int32(); }
+};
+
+class FastrpcDmaAllocFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = FastrpcDmaAllocFtraceEvent_Decoder;
+  enum : int32_t {
+    kCidFieldNumber = 1,
+    kPhysFieldNumber = 2,
+    kSizeFieldNumber = 3,
+    kAttrFieldNumber = 4,
+    kMflagsFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FastrpcDmaAllocFtraceEvent"; }
+
+
+  using FieldMetadata_Cid =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SmbusResultFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      FastrpcDmaAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReadWrite kReadWrite() { return {}; }
-  void set_read_write(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReadWrite::kFieldId;
+  static constexpr FieldMetadata_Cid kCid{};
+  void set_cid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Command =
+  using FieldMetadata_Phys =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SmbusResultFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FastrpcDmaAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Command kCommand() { return {}; }
-  void set_command(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Command::kFieldId;
+  static constexpr FieldMetadata_Phys kPhys{};
+  void set_phys(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Phys::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Res =
+  using FieldMetadata_Size =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SmbusResultFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FastrpcDmaAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Res kRes() { return {}; }
-  void set_res(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Res::kFieldId;
+  static constexpr FieldMetadata_Size kSize{};
+  void set_size(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Protocol =
+  using FieldMetadata_Attr =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SmbusResultFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FastrpcDmaAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Protocol kProtocol() { return {}; }
-  void set_protocol(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Protocol::kFieldId;
+  static constexpr FieldMetadata_Attr kAttr{};
+  void set_attr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Attr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Mflags =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      FastrpcDmaAllocFtraceEvent>;
+
+  static constexpr FieldMetadata_Mflags kMflags{};
+  void set_mflags(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mflags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class SmbusWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class FastrpcDmaFreeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  SmbusWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SmbusWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SmbusWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_adapter_nr() const { return at<1>().valid(); }
-  int32_t adapter_nr() const { return at<1>().as_int32(); }
-  bool has_addr() const { return at<2>().valid(); }
-  uint32_t addr() const { return at<2>().as_uint32(); }
-  bool has_flags() const { return at<3>().valid(); }
-  uint32_t flags() const { return at<3>().as_uint32(); }
-  bool has_command() const { return at<4>().valid(); }
-  uint32_t command() const { return at<4>().as_uint32(); }
-  bool has_len() const { return at<5>().valid(); }
-  uint32_t len() const { return at<5>().as_uint32(); }
-  bool has_protocol() const { return at<6>().valid(); }
-  uint32_t protocol() const { return at<6>().as_uint32(); }
+  FastrpcDmaFreeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FastrpcDmaFreeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FastrpcDmaFreeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cid() const { return at<1>().valid(); }
+  int32_t cid() const { return at<1>().as_int32(); }
+  bool has_phys() const { return at<2>().valid(); }
+  uint64_t phys() const { return at<2>().as_uint64(); }
+  bool has_size() const { return at<3>().valid(); }
+  uint64_t size() const { return at<3>().as_uint64(); }
 };
 
-class SmbusWriteFtraceEvent : public ::protozero::Message {
+class FastrpcDmaFreeFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SmbusWriteFtraceEvent_Decoder;
+  using Decoder = FastrpcDmaFreeFtraceEvent_Decoder;
   enum : int32_t {
-    kAdapterNrFieldNumber = 1,
-    kAddrFieldNumber = 2,
-    kFlagsFieldNumber = 3,
-    kCommandFieldNumber = 4,
-    kLenFieldNumber = 5,
-    kProtocolFieldNumber = 6,
+    kCidFieldNumber = 1,
+    kPhysFieldNumber = 2,
+    kSizeFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SmbusWriteFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.FastrpcDmaFreeFtraceEvent"; }
 
 
-  using FieldMetadata_AdapterNr =
+  using FieldMetadata_Cid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      SmbusWriteFtraceEvent>;
+      FastrpcDmaFreeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AdapterNr kAdapterNr() { return {}; }
-  void set_adapter_nr(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId;
+  static constexpr FieldMetadata_Cid kCid{};
+  void set_cid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -101516,230 +130898,226 @@ class SmbusWriteFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Addr =
+  using FieldMetadata_Phys =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SmbusWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FastrpcDmaFreeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Addr kAddr() { return {}; }
-  void set_addr(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId;
+  static constexpr FieldMetadata_Phys kPhys{};
+  void set_phys(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Phys::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_Size =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SmbusWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FastrpcDmaFreeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_Size kSize{};
+  void set_size(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Command =
+class FastrpcDmaStatFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  FastrpcDmaStatFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FastrpcDmaStatFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FastrpcDmaStatFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cid() const { return at<1>().valid(); }
+  int32_t cid() const { return at<1>().as_int32(); }
+  bool has_len() const { return at<2>().valid(); }
+  int64_t len() const { return at<2>().as_int64(); }
+  bool has_total_allocated() const { return at<3>().valid(); }
+  uint64_t total_allocated() const { return at<3>().as_uint64(); }
+};
+
+class FastrpcDmaStatFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = FastrpcDmaStatFtraceEvent_Decoder;
+  enum : int32_t {
+    kCidFieldNumber = 1,
+    kLenFieldNumber = 2,
+    kTotalAllocatedFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FastrpcDmaStatFtraceEvent"; }
+
+
+  using FieldMetadata_Cid =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SmbusWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      FastrpcDmaStatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Command kCommand() { return {}; }
-  void set_command(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Command::kFieldId;
+  static constexpr FieldMetadata_Cid kCid{};
+  void set_cid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
   using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SmbusWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      FastrpcDmaStatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Protocol =
+  using FieldMetadata_TotalAllocated =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SmbusWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FastrpcDmaStatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Protocol kProtocol() { return {}; }
-  void set_protocol(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Protocol::kFieldId;
+  static constexpr FieldMetadata_TotalAllocated kTotalAllocated{};
+  void set_total_allocated(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TotalAllocated::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class SmbusReadFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/fence.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FENCE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FENCE_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class FenceSignaledFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  SmbusReadFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SmbusReadFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SmbusReadFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_adapter_nr() const { return at<1>().valid(); }
-  int32_t adapter_nr() const { return at<1>().as_int32(); }
-  bool has_flags() const { return at<2>().valid(); }
-  uint32_t flags() const { return at<2>().as_uint32(); }
-  bool has_addr() const { return at<3>().valid(); }
-  uint32_t addr() const { return at<3>().as_uint32(); }
-  bool has_command() const { return at<4>().valid(); }
-  uint32_t command() const { return at<4>().as_uint32(); }
-  bool has_protocol() const { return at<5>().valid(); }
-  uint32_t protocol() const { return at<5>().as_uint32(); }
+  FenceSignaledFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FenceSignaledFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FenceSignaledFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_context() const { return at<1>().valid(); }
+  uint32_t context() const { return at<1>().as_uint32(); }
+  bool has_driver() const { return at<2>().valid(); }
+  ::protozero::ConstChars driver() const { return at<2>().as_string(); }
+  bool has_seqno() const { return at<3>().valid(); }
+  uint32_t seqno() const { return at<3>().as_uint32(); }
+  bool has_timeline() const { return at<4>().valid(); }
+  ::protozero::ConstChars timeline() const { return at<4>().as_string(); }
 };
 
-class SmbusReadFtraceEvent : public ::protozero::Message {
+class FenceSignaledFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SmbusReadFtraceEvent_Decoder;
+  using Decoder = FenceSignaledFtraceEvent_Decoder;
   enum : int32_t {
-    kAdapterNrFieldNumber = 1,
-    kFlagsFieldNumber = 2,
-    kAddrFieldNumber = 3,
-    kCommandFieldNumber = 4,
-    kProtocolFieldNumber = 5,
+    kContextFieldNumber = 1,
+    kDriverFieldNumber = 2,
+    kSeqnoFieldNumber = 3,
+    kTimelineFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SmbusReadFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.FenceSignaledFtraceEvent"; }
 
 
-  using FieldMetadata_AdapterNr =
+  using FieldMetadata_Context =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SmbusReadFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FenceSignaledFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AdapterNr kAdapterNr() { return {}; }
-  void set_adapter_nr(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId;
+  static constexpr FieldMetadata_Context kContext{};
+  void set_context(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_Driver =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SmbusReadFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FenceSignaledFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_Driver kDriver{};
+  void set_driver(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Driver::kFieldId, data, size);
+  }
+  void set_driver(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Driver::kFieldId, chars.data, chars.size);
+  }
+  void set_driver(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Driver::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Addr =
+  using FieldMetadata_Seqno =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SmbusReadFtraceEvent>;
+      FenceSignaledFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Addr kAddr() { return {}; }
-  void set_addr(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId;
+  static constexpr FieldMetadata_Seqno kSeqno{};
+  void set_seqno(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -101747,158 +131125,111 @@ class SmbusReadFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Command =
+  using FieldMetadata_Timeline =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SmbusReadFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FenceSignaledFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Command kCommand() { return {}; }
-  void set_command(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Command::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_Timeline kTimeline{};
+  void set_timeline(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Timeline::kFieldId, data, size);
   }
-
-  using FieldMetadata_Protocol =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SmbusReadFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Protocol kProtocol() { return {}; }
-  void set_protocol(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Protocol::kFieldId;
+  void set_timeline(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Timeline::kFieldId, chars.data, chars.size);
+  }
+  void set_timeline(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timeline::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 };
 
-class I2cReplyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class FenceEnableSignalFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  I2cReplyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit I2cReplyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit I2cReplyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_adapter_nr() const { return at<1>().valid(); }
-  int32_t adapter_nr() const { return at<1>().as_int32(); }
-  bool has_msg_nr() const { return at<2>().valid(); }
-  uint32_t msg_nr() const { return at<2>().as_uint32(); }
-  bool has_addr() const { return at<3>().valid(); }
-  uint32_t addr() const { return at<3>().as_uint32(); }
-  bool has_flags() const { return at<4>().valid(); }
-  uint32_t flags() const { return at<4>().as_uint32(); }
-  bool has_len() const { return at<5>().valid(); }
-  uint32_t len() const { return at<5>().as_uint32(); }
-  bool has_buf() const { return at<6>().valid(); }
-  uint32_t buf() const { return at<6>().as_uint32(); }
+  FenceEnableSignalFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FenceEnableSignalFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FenceEnableSignalFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_context() const { return at<1>().valid(); }
+  uint32_t context() const { return at<1>().as_uint32(); }
+  bool has_driver() const { return at<2>().valid(); }
+  ::protozero::ConstChars driver() const { return at<2>().as_string(); }
+  bool has_seqno() const { return at<3>().valid(); }
+  uint32_t seqno() const { return at<3>().as_uint32(); }
+  bool has_timeline() const { return at<4>().valid(); }
+  ::protozero::ConstChars timeline() const { return at<4>().as_string(); }
 };
 
-class I2cReplyFtraceEvent : public ::protozero::Message {
+class FenceEnableSignalFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = I2cReplyFtraceEvent_Decoder;
+  using Decoder = FenceEnableSignalFtraceEvent_Decoder;
   enum : int32_t {
-    kAdapterNrFieldNumber = 1,
-    kMsgNrFieldNumber = 2,
-    kAddrFieldNumber = 3,
-    kFlagsFieldNumber = 4,
-    kLenFieldNumber = 5,
-    kBufFieldNumber = 6,
+    kContextFieldNumber = 1,
+    kDriverFieldNumber = 2,
+    kSeqnoFieldNumber = 3,
+    kTimelineFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.I2cReplyFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.FenceEnableSignalFtraceEvent"; }
 
 
-  using FieldMetadata_AdapterNr =
+  using FieldMetadata_Context =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      I2cReplyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FenceEnableSignalFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AdapterNr kAdapterNr() { return {}; }
-  void set_adapter_nr(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId;
+  static constexpr FieldMetadata_Context kContext{};
+  void set_context(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MsgNr =
+  using FieldMetadata_Driver =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      I2cReplyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FenceEnableSignalFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MsgNr kMsgNr() { return {}; }
-  void set_msg_nr(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MsgNr::kFieldId;
+  static constexpr FieldMetadata_Driver kDriver{};
+  void set_driver(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Driver::kFieldId, data, size);
+  }
+  void set_driver(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Driver::kFieldId, chars.data, chars.size);
+  }
+  void set_driver(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Driver::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Addr =
+  using FieldMetadata_Seqno =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      I2cReplyFtraceEvent>;
+      FenceEnableSignalFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Addr kAddr() { return {}; }
-  void set_addr(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId;
+  static constexpr FieldMetadata_Seqno kSeqno{};
+  void set_seqno(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -101906,149 +131237,111 @@ class I2cReplyFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_Timeline =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      I2cReplyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FenceEnableSignalFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_Timeline kTimeline{};
+  void set_timeline(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Timeline::kFieldId, data, size);
+  }
+  void set_timeline(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Timeline::kFieldId, chars.data, chars.size);
+  }
+  void set_timeline(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timeline::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Len =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      I2cReplyFtraceEvent>;
+class FenceDestroyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  FenceDestroyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FenceDestroyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FenceDestroyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_context() const { return at<1>().valid(); }
+  uint32_t context() const { return at<1>().as_uint32(); }
+  bool has_driver() const { return at<2>().valid(); }
+  ::protozero::ConstChars driver() const { return at<2>().as_string(); }
+  bool has_seqno() const { return at<3>().valid(); }
+  uint32_t seqno() const { return at<3>().as_uint32(); }
+  bool has_timeline() const { return at<4>().valid(); }
+  ::protozero::ConstChars timeline() const { return at<4>().as_string(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+class FenceDestroyFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = FenceDestroyFtraceEvent_Decoder;
+  enum : int32_t {
+    kContextFieldNumber = 1,
+    kDriverFieldNumber = 2,
+    kSeqnoFieldNumber = 3,
+    kTimelineFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.FenceDestroyFtraceEvent"; }
 
-  using FieldMetadata_Buf =
+
+  using FieldMetadata_Context =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      I2cReplyFtraceEvent>;
+      FenceDestroyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Buf kBuf() { return {}; }
-  void set_buf(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Buf::kFieldId;
+  static constexpr FieldMetadata_Context kContext{};
+  void set_context(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class I2cResultFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  I2cResultFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit I2cResultFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit I2cResultFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_adapter_nr() const { return at<1>().valid(); }
-  int32_t adapter_nr() const { return at<1>().as_int32(); }
-  bool has_nr_msgs() const { return at<2>().valid(); }
-  uint32_t nr_msgs() const { return at<2>().as_uint32(); }
-  bool has_ret() const { return at<3>().valid(); }
-  int32_t ret() const { return at<3>().as_int32(); }
-};
-
-class I2cResultFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = I2cResultFtraceEvent_Decoder;
-  enum : int32_t {
-    kAdapterNrFieldNumber = 1,
-    kNrMsgsFieldNumber = 2,
-    kRetFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.I2cResultFtraceEvent"; }
-
 
-  using FieldMetadata_AdapterNr =
+  using FieldMetadata_Driver =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      I2cResultFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FenceDestroyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AdapterNr kAdapterNr() { return {}; }
-  void set_adapter_nr(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId;
+  static constexpr FieldMetadata_Driver kDriver{};
+  void set_driver(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Driver::kFieldId, data, size);
+  }
+  void set_driver(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Driver::kFieldId, chars.data, chars.size);
+  }
+  void set_driver(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Driver::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NrMsgs =
+  using FieldMetadata_Seqno =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      I2cResultFtraceEvent>;
+      FenceDestroyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrMsgs kNrMsgs() { return {}; }
-  void set_nr_msgs(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NrMsgs::kFieldId;
+  static constexpr FieldMetadata_Seqno kSeqno{};
+  void set_seqno(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -102056,133 +131349,111 @@ class I2cResultFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ret =
+  using FieldMetadata_Timeline =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      I2cResultFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FenceDestroyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+  static constexpr FieldMetadata_Timeline kTimeline{};
+  void set_timeline(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Timeline::kFieldId, data, size);
+  }
+  void set_timeline(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Timeline::kFieldId, chars.data, chars.size);
+  }
+  void set_timeline(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timeline::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 };
 
-class I2cWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class FenceInitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  I2cWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit I2cWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit I2cWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_adapter_nr() const { return at<1>().valid(); }
-  int32_t adapter_nr() const { return at<1>().as_int32(); }
-  bool has_msg_nr() const { return at<2>().valid(); }
-  uint32_t msg_nr() const { return at<2>().as_uint32(); }
-  bool has_addr() const { return at<3>().valid(); }
-  uint32_t addr() const { return at<3>().as_uint32(); }
-  bool has_flags() const { return at<4>().valid(); }
-  uint32_t flags() const { return at<4>().as_uint32(); }
-  bool has_len() const { return at<5>().valid(); }
-  uint32_t len() const { return at<5>().as_uint32(); }
-  bool has_buf() const { return at<6>().valid(); }
-  uint32_t buf() const { return at<6>().as_uint32(); }
+  FenceInitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FenceInitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FenceInitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_context() const { return at<1>().valid(); }
+  uint32_t context() const { return at<1>().as_uint32(); }
+  bool has_driver() const { return at<2>().valid(); }
+  ::protozero::ConstChars driver() const { return at<2>().as_string(); }
+  bool has_seqno() const { return at<3>().valid(); }
+  uint32_t seqno() const { return at<3>().as_uint32(); }
+  bool has_timeline() const { return at<4>().valid(); }
+  ::protozero::ConstChars timeline() const { return at<4>().as_string(); }
 };
 
-class I2cWriteFtraceEvent : public ::protozero::Message {
+class FenceInitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = I2cWriteFtraceEvent_Decoder;
+  using Decoder = FenceInitFtraceEvent_Decoder;
   enum : int32_t {
-    kAdapterNrFieldNumber = 1,
-    kMsgNrFieldNumber = 2,
-    kAddrFieldNumber = 3,
-    kFlagsFieldNumber = 4,
-    kLenFieldNumber = 5,
-    kBufFieldNumber = 6,
+    kContextFieldNumber = 1,
+    kDriverFieldNumber = 2,
+    kSeqnoFieldNumber = 3,
+    kTimelineFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.I2cWriteFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.FenceInitFtraceEvent"; }
 
 
-  using FieldMetadata_AdapterNr =
+  using FieldMetadata_Context =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      I2cWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FenceInitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AdapterNr kAdapterNr() { return {}; }
-  void set_adapter_nr(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId;
+  static constexpr FieldMetadata_Context kContext{};
+  void set_context(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MsgNr =
+  using FieldMetadata_Driver =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      I2cWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FenceInitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MsgNr kMsgNr() { return {}; }
-  void set_msg_nr(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MsgNr::kFieldId;
+  static constexpr FieldMetadata_Driver kDriver{};
+  void set_driver(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Driver::kFieldId, data, size);
+  }
+  void set_driver(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Driver::kFieldId, chars.data, chars.size);
+  }
+  void set_driver(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Driver::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Addr =
+  using FieldMetadata_Seqno =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      I2cWriteFtraceEvent>;
+      FenceInitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Addr kAddr() { return {}; }
-  void set_addr(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId;
+  static constexpr FieldMetadata_Seqno kSeqno{};
+  void set_seqno(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -102190,354 +131461,289 @@ class I2cWriteFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_Timeline =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      I2cWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FenceInitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_Timeline kTimeline{};
+  void set_timeline(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Timeline::kFieldId, data, size);
+  }
+  void set_timeline(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Timeline::kFieldId, chars.data, chars.size);
+  }
+  void set_timeline(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timeline::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Len =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      I2cWriteFtraceEvent>;
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/filemap.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FILEMAP_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FILEMAP_PROTO_H_
 
-  using FieldMetadata_Buf =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      I2cWriteFtraceEvent>;
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Buf kBuf() { return {}; }
-  void set_buf(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Buf::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-};
 
-class I2cReadFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class MmFilemapDeleteFromPageCacheFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  I2cReadFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit I2cReadFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit I2cReadFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_adapter_nr() const { return at<1>().valid(); }
-  int32_t adapter_nr() const { return at<1>().as_int32(); }
-  bool has_msg_nr() const { return at<2>().valid(); }
-  uint32_t msg_nr() const { return at<2>().as_uint32(); }
-  bool has_addr() const { return at<3>().valid(); }
-  uint32_t addr() const { return at<3>().as_uint32(); }
-  bool has_flags() const { return at<4>().valid(); }
-  uint32_t flags() const { return at<4>().as_uint32(); }
-  bool has_len() const { return at<5>().valid(); }
-  uint32_t len() const { return at<5>().as_uint32(); }
+  MmFilemapDeleteFromPageCacheFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MmFilemapDeleteFromPageCacheFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MmFilemapDeleteFromPageCacheFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pfn() const { return at<1>().valid(); }
+  uint64_t pfn() const { return at<1>().as_uint64(); }
+  bool has_i_ino() const { return at<2>().valid(); }
+  uint64_t i_ino() const { return at<2>().as_uint64(); }
+  bool has_index() const { return at<3>().valid(); }
+  uint64_t index() const { return at<3>().as_uint64(); }
+  bool has_s_dev() const { return at<4>().valid(); }
+  uint64_t s_dev() const { return at<4>().as_uint64(); }
+  bool has_page() const { return at<5>().valid(); }
+  uint64_t page() const { return at<5>().as_uint64(); }
 };
 
-class I2cReadFtraceEvent : public ::protozero::Message {
+class MmFilemapDeleteFromPageCacheFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = I2cReadFtraceEvent_Decoder;
+  using Decoder = MmFilemapDeleteFromPageCacheFtraceEvent_Decoder;
   enum : int32_t {
-    kAdapterNrFieldNumber = 1,
-    kMsgNrFieldNumber = 2,
-    kAddrFieldNumber = 3,
-    kFlagsFieldNumber = 4,
-    kLenFieldNumber = 5,
+    kPfnFieldNumber = 1,
+    kIInoFieldNumber = 2,
+    kIndexFieldNumber = 3,
+    kSDevFieldNumber = 4,
+    kPageFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.I2cReadFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MmFilemapDeleteFromPageCacheFtraceEvent"; }
 
 
-  using FieldMetadata_AdapterNr =
+  using FieldMetadata_Pfn =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      I2cReadFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmFilemapDeleteFromPageCacheFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AdapterNr kAdapterNr() { return {}; }
-  void set_adapter_nr(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId;
+  static constexpr FieldMetadata_Pfn kPfn{};
+  void set_pfn(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MsgNr =
+  using FieldMetadata_IIno =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      I2cReadFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmFilemapDeleteFromPageCacheFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MsgNr kMsgNr() { return {}; }
-  void set_msg_nr(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MsgNr::kFieldId;
+  static constexpr FieldMetadata_IIno kIIno{};
+  void set_i_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IIno::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Addr =
+  using FieldMetadata_Index =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      I2cReadFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmFilemapDeleteFromPageCacheFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Addr kAddr() { return {}; }
-  void set_addr(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId;
+  static constexpr FieldMetadata_Index kIndex{};
+  void set_index(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_SDev =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      I2cReadFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmFilemapDeleteFromPageCacheFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_SDev kSDev{};
+  void set_s_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SDev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_Page =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      I2cReadFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmFilemapDeleteFromPageCacheFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_Page kPage{};
+  void set_page(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/ion.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_ION_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_ION_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class IonStatFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmFilemapAddToPageCacheFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  IonStatFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IonStatFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IonStatFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_buffer_id() const { return at<1>().valid(); }
-  uint32_t buffer_id() const { return at<1>().as_uint32(); }
-  bool has_len() const { return at<2>().valid(); }
-  int64_t len() const { return at<2>().as_int64(); }
-  bool has_total_allocated() const { return at<3>().valid(); }
-  uint64_t total_allocated() const { return at<3>().as_uint64(); }
+  MmFilemapAddToPageCacheFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MmFilemapAddToPageCacheFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MmFilemapAddToPageCacheFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pfn() const { return at<1>().valid(); }
+  uint64_t pfn() const { return at<1>().as_uint64(); }
+  bool has_i_ino() const { return at<2>().valid(); }
+  uint64_t i_ino() const { return at<2>().as_uint64(); }
+  bool has_index() const { return at<3>().valid(); }
+  uint64_t index() const { return at<3>().as_uint64(); }
+  bool has_s_dev() const { return at<4>().valid(); }
+  uint64_t s_dev() const { return at<4>().as_uint64(); }
+  bool has_page() const { return at<5>().valid(); }
+  uint64_t page() const { return at<5>().as_uint64(); }
 };
 
-class IonStatFtraceEvent : public ::protozero::Message {
+class MmFilemapAddToPageCacheFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = IonStatFtraceEvent_Decoder;
+  using Decoder = MmFilemapAddToPageCacheFtraceEvent_Decoder;
   enum : int32_t {
-    kBufferIdFieldNumber = 1,
-    kLenFieldNumber = 2,
-    kTotalAllocatedFieldNumber = 3,
+    kPfnFieldNumber = 1,
+    kIInoFieldNumber = 2,
+    kIndexFieldNumber = 3,
+    kSDevFieldNumber = 4,
+    kPageFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.IonStatFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MmFilemapAddToPageCacheFtraceEvent"; }
 
 
-  using FieldMetadata_BufferId =
+  using FieldMetadata_Pfn =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      IonStatFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmFilemapAddToPageCacheFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BufferId kBufferId() { return {}; }
-  void set_buffer_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BufferId::kFieldId;
+  static constexpr FieldMetadata_Pfn kPfn{};
+  void set_pfn(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_IIno =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      IonStatFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmFilemapAddToPageCacheFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_IIno kIIno{};
+  void set_i_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IIno::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TotalAllocated =
+  using FieldMetadata_Index =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      IonStatFtraceEvent>;
+      MmFilemapAddToPageCacheFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TotalAllocated kTotalAllocated() { return {}; }
-  void set_total_allocated(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TotalAllocated::kFieldId;
+  static constexpr FieldMetadata_Index kIndex{};
+  void set_index(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SDev =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmFilemapAddToPageCacheFtraceEvent>;
+
+  static constexpr FieldMetadata_SDev kSDev{};
+  void set_s_dev(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SDev::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Page =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmFilemapAddToPageCacheFtraceEvent>;
+
+  static constexpr FieldMetadata_Page kPage{};
+  void set_page(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -102550,11 +131756,11 @@ class IonStatFtraceEvent : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/ipi.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/fs.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_IPI_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_IPI_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FS_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -102565,81 +131771,46 @@ class IonStatFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class IpiRaiseFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class OpenExecFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  IpiRaiseFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IpiRaiseFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IpiRaiseFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_target_cpus() const { return at<1>().valid(); }
-  uint32_t target_cpus() const { return at<1>().as_uint32(); }
-  bool has_reason() const { return at<2>().valid(); }
-  ::protozero::ConstChars reason() const { return at<2>().as_string(); }
+  OpenExecFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit OpenExecFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit OpenExecFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_filename() const { return at<1>().valid(); }
+  ::protozero::ConstChars filename() const { return at<1>().as_string(); }
 };
 
-class IpiRaiseFtraceEvent : public ::protozero::Message {
+class OpenExecFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = IpiRaiseFtraceEvent_Decoder;
+  using Decoder = OpenExecFtraceEvent_Decoder;
   enum : int32_t {
-    kTargetCpusFieldNumber = 1,
-    kReasonFieldNumber = 2,
+    kFilenameFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.IpiRaiseFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.OpenExecFtraceEvent"; }
 
 
-  using FieldMetadata_TargetCpus =
+  using FieldMetadata_Filename =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      IpiRaiseFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TargetCpus kTargetCpus() { return {}; }
-  void set_target_cpus(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TargetCpus::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Reason =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      IpiRaiseFtraceEvent>;
+      OpenExecFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Reason kReason() { return {}; }
-  void set_reason(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Reason::kFieldId, data, size);
+  static constexpr FieldMetadata_Filename kFilename{};
+  void set_filename(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Filename::kFieldId, data, size);
   }
-  void set_reason(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Reason::kFieldId, chars.data, chars.size);
+  void set_filename(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Filename::kFieldId, chars.data, chars.size);
   }
-  void set_reason(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Reason::kFieldId;
+  void set_filename(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Filename::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -102648,102 +131819,87 @@ class IpiRaiseFtraceEvent : public ::protozero::Message {
   }
 };
 
-class IpiExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DoSysOpenFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  IpiExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IpiExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IpiExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_reason() const { return at<1>().valid(); }
-  ::protozero::ConstChars reason() const { return at<1>().as_string(); }
+  DoSysOpenFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DoSysOpenFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DoSysOpenFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_filename() const { return at<1>().valid(); }
+  ::protozero::ConstChars filename() const { return at<1>().as_string(); }
+  bool has_flags() const { return at<2>().valid(); }
+  int32_t flags() const { return at<2>().as_int32(); }
+  bool has_mode() const { return at<3>().valid(); }
+  int32_t mode() const { return at<3>().as_int32(); }
 };
 
-class IpiExitFtraceEvent : public ::protozero::Message {
+class DoSysOpenFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = IpiExitFtraceEvent_Decoder;
+  using Decoder = DoSysOpenFtraceEvent_Decoder;
   enum : int32_t {
-    kReasonFieldNumber = 1,
+    kFilenameFieldNumber = 1,
+    kFlagsFieldNumber = 2,
+    kModeFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.IpiExitFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.DoSysOpenFtraceEvent"; }
 
 
-  using FieldMetadata_Reason =
+  using FieldMetadata_Filename =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      IpiExitFtraceEvent>;
+      DoSysOpenFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Reason kReason() { return {}; }
-  void set_reason(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Reason::kFieldId, data, size);
+  static constexpr FieldMetadata_Filename kFilename{};
+  void set_filename(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Filename::kFieldId, data, size);
   }
-  void set_reason(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Reason::kFieldId, chars.data, chars.size);
+  void set_filename(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Filename::kFieldId, chars.data, chars.size);
   }
-  void set_reason(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Reason::kFieldId;
+  void set_filename(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Filename::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
-};
-
-class IpiEntryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  IpiEntryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IpiEntryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IpiEntryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_reason() const { return at<1>().valid(); }
-  ::protozero::ConstChars reason() const { return at<1>().as_string(); }
-};
 
-class IpiEntryFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = IpiEntryFtraceEvent_Decoder;
-  enum : int32_t {
-    kReasonFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.IpiEntryFtraceEvent"; }
+  using FieldMetadata_Flags =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      DoSysOpenFtraceEvent>;
 
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Reason =
+  using FieldMetadata_Mode =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      IpiEntryFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      DoSysOpenFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Reason kReason() { return {}; }
-  void set_reason(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Reason::kFieldId, data, size);
-  }
-  void set_reason(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Reason::kFieldId, chars.data, chars.size);
-  }
-  void set_reason(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Reason::kFieldId;
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
@@ -102752,11 +131908,11 @@ class IpiEntryFtraceEvent : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/irq.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/ftrace.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_IRQ_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_IRQ_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FTRACE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FTRACE_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -102767,317 +131923,250 @@ class IpiEntryFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class IrqHandlerExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class FuncgraphExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  IrqHandlerExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IrqHandlerExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IrqHandlerExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_irq() const { return at<1>().valid(); }
-  int32_t irq() const { return at<1>().as_int32(); }
-  bool has_ret() const { return at<2>().valid(); }
-  int32_t ret() const { return at<2>().as_int32(); }
+  FuncgraphExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FuncgraphExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FuncgraphExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_calltime() const { return at<1>().valid(); }
+  uint64_t calltime() const { return at<1>().as_uint64(); }
+  bool has_depth() const { return at<2>().valid(); }
+  int32_t depth() const { return at<2>().as_int32(); }
+  bool has_func() const { return at<3>().valid(); }
+  uint64_t func() const { return at<3>().as_uint64(); }
+  bool has_overrun() const { return at<4>().valid(); }
+  uint64_t overrun() const { return at<4>().as_uint64(); }
+  bool has_rettime() const { return at<5>().valid(); }
+  uint64_t rettime() const { return at<5>().as_uint64(); }
 };
 
-class IrqHandlerExitFtraceEvent : public ::protozero::Message {
+class FuncgraphExitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = IrqHandlerExitFtraceEvent_Decoder;
+  using Decoder = FuncgraphExitFtraceEvent_Decoder;
   enum : int32_t {
-    kIrqFieldNumber = 1,
-    kRetFieldNumber = 2,
+    kCalltimeFieldNumber = 1,
+    kDepthFieldNumber = 2,
+    kFuncFieldNumber = 3,
+    kOverrunFieldNumber = 4,
+    kRettimeFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.IrqHandlerExitFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.FuncgraphExitFtraceEvent"; }
 
 
-  using FieldMetadata_Irq =
+  using FieldMetadata_Calltime =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      IrqHandlerExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FuncgraphExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Irq kIrq() { return {}; }
-  void set_irq(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Irq::kFieldId;
+  static constexpr FieldMetadata_Calltime kCalltime{};
+  void set_calltime(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Calltime::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ret =
+  using FieldMetadata_Depth =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      IrqHandlerExitFtraceEvent>;
+      FuncgraphExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+  static constexpr FieldMetadata_Depth kDepth{};
+  void set_depth(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Depth::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-class IrqHandlerEntryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  IrqHandlerEntryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IrqHandlerEntryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IrqHandlerEntryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_irq() const { return at<1>().valid(); }
-  int32_t irq() const { return at<1>().as_int32(); }
-  bool has_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars name() const { return at<2>().as_string(); }
-  bool has_handler() const { return at<3>().valid(); }
-  uint32_t handler() const { return at<3>().as_uint32(); }
-};
-
-class IrqHandlerEntryFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = IrqHandlerEntryFtraceEvent_Decoder;
-  enum : int32_t {
-    kIrqFieldNumber = 1,
-    kNameFieldNumber = 2,
-    kHandlerFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.IrqHandlerEntryFtraceEvent"; }
-
 
-  using FieldMetadata_Irq =
+  using FieldMetadata_Func =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      IrqHandlerEntryFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FuncgraphExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Irq kIrq() { return {}; }
-  void set_irq(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Irq::kFieldId;
+  static constexpr FieldMetadata_Func kFunc{};
+  void set_func(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Func::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Name =
+  using FieldMetadata_Overrun =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      IrqHandlerEntryFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FuncgraphExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_Overrun kOverrun{};
+  void set_overrun(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Overrun::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Handler =
+  using FieldMetadata_Rettime =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      IrqHandlerEntryFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FuncgraphExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Handler kHandler() { return {}; }
-  void set_handler(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Handler::kFieldId;
+  static constexpr FieldMetadata_Rettime kRettime{};
+  void set_rettime(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Rettime::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class SoftirqRaiseFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class FuncgraphEntryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  SoftirqRaiseFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SoftirqRaiseFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SoftirqRaiseFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_vec() const { return at<1>().valid(); }
-  uint32_t vec() const { return at<1>().as_uint32(); }
+  FuncgraphEntryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FuncgraphEntryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FuncgraphEntryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_depth() const { return at<1>().valid(); }
+  int32_t depth() const { return at<1>().as_int32(); }
+  bool has_func() const { return at<2>().valid(); }
+  uint64_t func() const { return at<2>().as_uint64(); }
 };
 
-class SoftirqRaiseFtraceEvent : public ::protozero::Message {
+class FuncgraphEntryFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SoftirqRaiseFtraceEvent_Decoder;
+  using Decoder = FuncgraphEntryFtraceEvent_Decoder;
   enum : int32_t {
-    kVecFieldNumber = 1,
+    kDepthFieldNumber = 1,
+    kFuncFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SoftirqRaiseFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.FuncgraphEntryFtraceEvent"; }
 
 
-  using FieldMetadata_Vec =
+  using FieldMetadata_Depth =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SoftirqRaiseFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      FuncgraphEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Vec kVec() { return {}; }
-  void set_vec(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Vec::kFieldId;
+  static constexpr FieldMetadata_Depth kDepth{};
+  void set_depth(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Depth::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-class SoftirqExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  SoftirqExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SoftirqExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SoftirqExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_vec() const { return at<1>().valid(); }
-  uint32_t vec() const { return at<1>().as_uint32(); }
-};
-
-class SoftirqExitFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = SoftirqExitFtraceEvent_Decoder;
-  enum : int32_t {
-    kVecFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.SoftirqExitFtraceEvent"; }
 
-
-  using FieldMetadata_Vec =
+  using FieldMetadata_Func =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SoftirqExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      FuncgraphEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Vec kVec() { return {}; }
-  void set_vec(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Vec::kFieldId;
+  static constexpr FieldMetadata_Func kFunc{};
+  void set_func(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Func::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class SoftirqEntryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class PrintFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  SoftirqEntryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SoftirqEntryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SoftirqEntryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_vec() const { return at<1>().valid(); }
-  uint32_t vec() const { return at<1>().as_uint32(); }
+  PrintFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PrintFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PrintFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_ip() const { return at<1>().valid(); }
+  uint64_t ip() const { return at<1>().as_uint64(); }
+  bool has_buf() const { return at<2>().valid(); }
+  ::protozero::ConstChars buf() const { return at<2>().as_string(); }
 };
 
-class SoftirqEntryFtraceEvent : public ::protozero::Message {
+class PrintFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SoftirqEntryFtraceEvent_Decoder;
+  using Decoder = PrintFtraceEvent_Decoder;
   enum : int32_t {
-    kVecFieldNumber = 1,
+    kIpFieldNumber = 1,
+    kBufFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SoftirqEntryFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.PrintFtraceEvent"; }
 
 
-  using FieldMetadata_Vec =
+  using FieldMetadata_Ip =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SoftirqEntryFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      PrintFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Vec kVec() { return {}; }
-  void set_vec(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Vec::kFieldId;
+  static constexpr FieldMetadata_Ip kIp{};
+  void set_ip(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ip::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Buf =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      PrintFtraceEvent>;
+
+  static constexpr FieldMetadata_Buf kBuf{};
+  void set_buf(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Buf::kFieldId, data, size);
+  }
+  void set_buf(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Buf::kFieldId, chars.data, chars.size);
+  }
+  void set_buf(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Buf::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 };
@@ -103086,11 +132175,11 @@ class SoftirqEntryFtraceEvent : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/kmem.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/fwtp_ftrace.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_KMEM_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_KMEM_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FWTP_FTRACE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_FWTP_FTRACE_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -103101,50 +132190,52 @@ class SoftirqEntryFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class IonBufferDestroyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class FwtpPerfettoSliceFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  IonBufferDestroyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IonBufferDestroyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IonBufferDestroyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_addr() const { return at<1>().valid(); }
-  uint64_t addr() const { return at<1>().as_uint64(); }
-  bool has_len() const { return at<2>().valid(); }
-  uint64_t len() const { return at<2>().as_uint64(); }
+  FwtpPerfettoSliceFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FwtpPerfettoSliceFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FwtpPerfettoSliceFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_timestamp() const { return at<1>().valid(); }
+  uint64_t timestamp() const { return at<1>().as_uint64(); }
+  bool has_track_id() const { return at<2>().valid(); }
+  uint32_t track_id() const { return at<2>().as_uint32(); }
+  bool has_category() const { return at<3>().valid(); }
+  ::protozero::ConstChars category() const { return at<3>().as_string(); }
+  bool has_name() const { return at<4>().valid(); }
+  ::protozero::ConstChars name() const { return at<4>().as_string(); }
+  bool has_begin() const { return at<5>().valid(); }
+  uint32_t begin() const { return at<5>().as_uint32(); }
 };
 
-class IonBufferDestroyFtraceEvent : public ::protozero::Message {
+class FwtpPerfettoSliceFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = IonBufferDestroyFtraceEvent_Decoder;
+  using Decoder = FwtpPerfettoSliceFtraceEvent_Decoder;
   enum : int32_t {
-    kAddrFieldNumber = 1,
-    kLenFieldNumber = 2,
+    kTimestampFieldNumber = 1,
+    kTrackIdFieldNumber = 2,
+    kCategoryFieldNumber = 3,
+    kNameFieldNumber = 4,
+    kBeginFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.IonBufferDestroyFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.FwtpPerfettoSliceFtraceEvent"; }
 
 
-  using FieldMetadata_Addr =
+  using FieldMetadata_Timestamp =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      IonBufferDestroyFtraceEvent>;
+      FwtpPerfettoSliceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Addr kAddr() { return {}; }
-  void set_addr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId;
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -103152,152 +132243,65 @@ class IonBufferDestroyFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_TrackId =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IonBufferDestroyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FwtpPerfettoSliceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_TrackId kTrackId{};
+  void set_track_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TrackId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class IonBufferCreateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  IonBufferCreateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IonBufferCreateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IonBufferCreateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_addr() const { return at<1>().valid(); }
-  uint64_t addr() const { return at<1>().as_uint64(); }
-  bool has_len() const { return at<2>().valid(); }
-  uint64_t len() const { return at<2>().as_uint64(); }
-};
-
-class IonBufferCreateFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = IonBufferCreateFtraceEvent_Decoder;
-  enum : int32_t {
-    kAddrFieldNumber = 1,
-    kLenFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.IonBufferCreateFtraceEvent"; }
-
 
-  using FieldMetadata_Addr =
+  using FieldMetadata_Category =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IonBufferCreateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FwtpPerfettoSliceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Addr kAddr() { return {}; }
-  void set_addr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_Category kCategory{};
+  void set_category(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Category::kFieldId, data, size);
   }
-
-  using FieldMetadata_Len =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IonBufferCreateFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  void set_category(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Category::kFieldId, chars.data, chars.size);
+  }
+  void set_category(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Category::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
-};
-
-class IonHeapGrowFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  IonHeapGrowFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IonHeapGrowFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IonHeapGrowFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_heap_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars heap_name() const { return at<1>().as_string(); }
-  bool has_len() const { return at<2>().valid(); }
-  uint64_t len() const { return at<2>().as_uint64(); }
-  bool has_total_allocated() const { return at<3>().valid(); }
-  int64_t total_allocated() const { return at<3>().as_int64(); }
-};
-
-class IonHeapGrowFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = IonHeapGrowFtraceEvent_Decoder;
-  enum : int32_t {
-    kHeapNameFieldNumber = 1,
-    kLenFieldNumber = 2,
-    kTotalAllocatedFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.IonHeapGrowFtraceEvent"; }
 
-
-  using FieldMetadata_HeapName =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      IonHeapGrowFtraceEvent>;
+      FwtpPerfettoSliceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HeapName kHeapName() { return {}; }
-  void set_heap_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_HeapName::kFieldId, data, size);
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
-  void set_heap_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size);
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
   }
-  void set_heap_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId;
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -103305,130 +132309,66 @@ class IonHeapGrowFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IonHeapGrowFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_TotalAllocated =
+  using FieldMetadata_Begin =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      IonHeapGrowFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FwtpPerfettoSliceFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TotalAllocated kTotalAllocated() { return {}; }
-  void set_total_allocated(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TotalAllocated::kFieldId;
+  static constexpr FieldMetadata_Begin kBegin{};
+  void set_begin(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Begin::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class IonHeapShrinkFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class FwtpPerfettoCounterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  IonHeapShrinkFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IonHeapShrinkFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IonHeapShrinkFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_heap_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars heap_name() const { return at<1>().as_string(); }
-  bool has_len() const { return at<2>().valid(); }
-  uint64_t len() const { return at<2>().as_uint64(); }
-  bool has_total_allocated() const { return at<3>().valid(); }
-  int64_t total_allocated() const { return at<3>().as_int64(); }
+  FwtpPerfettoCounterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit FwtpPerfettoCounterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit FwtpPerfettoCounterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_timestamp() const { return at<1>().valid(); }
+  uint64_t timestamp() const { return at<1>().as_uint64(); }
+  bool has_track_id() const { return at<2>().valid(); }
+  uint32_t track_id() const { return at<2>().as_uint32(); }
+  bool has_category() const { return at<3>().valid(); }
+  ::protozero::ConstChars category() const { return at<3>().as_string(); }
+  bool has_name() const { return at<4>().valid(); }
+  ::protozero::ConstChars name() const { return at<4>().as_string(); }
+  bool has_value() const { return at<5>().valid(); }
+  uint32_t value() const { return at<5>().as_uint32(); }
 };
 
-class IonHeapShrinkFtraceEvent : public ::protozero::Message {
+class FwtpPerfettoCounterFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = IonHeapShrinkFtraceEvent_Decoder;
+  using Decoder = FwtpPerfettoCounterFtraceEvent_Decoder;
   enum : int32_t {
-    kHeapNameFieldNumber = 1,
-    kLenFieldNumber = 2,
-    kTotalAllocatedFieldNumber = 3,
+    kTimestampFieldNumber = 1,
+    kTrackIdFieldNumber = 2,
+    kCategoryFieldNumber = 3,
+    kNameFieldNumber = 4,
+    kValueFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.IonHeapShrinkFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.FwtpPerfettoCounterFtraceEvent"; }
 
 
-  using FieldMetadata_HeapName =
+  using FieldMetadata_Timestamp =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      IonHeapShrinkFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HeapName kHeapName() { return {}; }
-  void set_heap_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_HeapName::kFieldId, data, size);
-  }
-  void set_heap_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size);
-  }
-  void set_heap_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Len =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      IonHeapShrinkFtraceEvent>;
+      FwtpPerfettoCounterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -103436,152 +132376,83 @@ class IonHeapShrinkFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TotalAllocated =
+  using FieldMetadata_TrackId =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      IonHeapShrinkFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      FwtpPerfettoCounterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TotalAllocated kTotalAllocated() { return {}; }
-  void set_total_allocated(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TotalAllocated::kFieldId;
+  static constexpr FieldMetadata_TrackId kTrackId{};
+  void set_track_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TrackId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class RssStatFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  RssStatFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit RssStatFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit RssStatFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_member() const { return at<1>().valid(); }
-  int32_t member() const { return at<1>().as_int32(); }
-  bool has_size() const { return at<2>().valid(); }
-  int64_t size() const { return at<2>().as_int64(); }
-  bool has_curr() const { return at<3>().valid(); }
-  uint32_t curr() const { return at<3>().as_uint32(); }
-  bool has_mm_id() const { return at<4>().valid(); }
-  uint32_t mm_id() const { return at<4>().as_uint32(); }
-};
-
-class RssStatFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = RssStatFtraceEvent_Decoder;
-  enum : int32_t {
-    kMemberFieldNumber = 1,
-    kSizeFieldNumber = 2,
-    kCurrFieldNumber = 3,
-    kMmIdFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.RssStatFtraceEvent"; }
-
 
-  using FieldMetadata_Member =
+  using FieldMetadata_Category =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      RssStatFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FwtpPerfettoCounterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Member kMember() { return {}; }
-  void set_member(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Member::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_Category kCategory{};
+  void set_category(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Category::kFieldId, data, size);
   }
-
-  using FieldMetadata_Size =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      RssStatFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Size kSize() { return {}; }
-  void set_size(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
+  void set_category(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Category::kFieldId, chars.data, chars.size);
+  }
+  void set_category(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Category::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Curr =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      RssStatFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FwtpPerfettoCounterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Curr kCurr() { return {}; }
-  void set_curr(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Curr::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MmId =
+  using FieldMetadata_Value =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      RssStatFtraceEvent>;
+      FwtpPerfettoCounterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmId kMmId() { return {}; }
-  void set_mm_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MmId::kFieldId;
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -103590,76 +132461,110 @@ class RssStatFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MmPagePcpuDrainFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/g2d.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_G2D_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_G2D_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class G2dTracingMarkWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  MmPagePcpuDrainFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MmPagePcpuDrainFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MmPagePcpuDrainFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_migratetype() const { return at<1>().valid(); }
-  int32_t migratetype() const { return at<1>().as_int32(); }
-  bool has_order() const { return at<2>().valid(); }
-  uint32_t order() const { return at<2>().as_uint32(); }
-  bool has_page() const { return at<3>().valid(); }
-  uint64_t page() const { return at<3>().as_uint64(); }
-  bool has_pfn() const { return at<4>().valid(); }
-  uint64_t pfn() const { return at<4>().as_uint64(); }
+  G2dTracingMarkWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit G2dTracingMarkWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit G2dTracingMarkWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  int32_t pid() const { return at<1>().as_int32(); }
+  bool has_name() const { return at<4>().valid(); }
+  ::protozero::ConstChars name() const { return at<4>().as_string(); }
+  bool has_type() const { return at<5>().valid(); }
+  uint32_t type() const { return at<5>().as_uint32(); }
+  bool has_value() const { return at<6>().valid(); }
+  int32_t value() const { return at<6>().as_int32(); }
 };
 
-class MmPagePcpuDrainFtraceEvent : public ::protozero::Message {
+class G2dTracingMarkWriteFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MmPagePcpuDrainFtraceEvent_Decoder;
+  using Decoder = G2dTracingMarkWriteFtraceEvent_Decoder;
   enum : int32_t {
-    kMigratetypeFieldNumber = 1,
-    kOrderFieldNumber = 2,
-    kPageFieldNumber = 3,
-    kPfnFieldNumber = 4,
+    kPidFieldNumber = 1,
+    kNameFieldNumber = 4,
+    kTypeFieldNumber = 5,
+    kValueFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MmPagePcpuDrainFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.G2dTracingMarkWriteFtraceEvent"; }
 
 
-  using FieldMetadata_Migratetype =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      MmPagePcpuDrainFtraceEvent>;
+      G2dTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Migratetype kMigratetype() { return {}; }
-  void set_migratetype(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Migratetype::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      G2dTracingMarkWriteFtraceEvent>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Order =
+  using FieldMetadata_Type =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MmPagePcpuDrainFtraceEvent>;
+      G2dTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Order kOrder() { return {}; }
-  void set_order(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -103667,149 +132572,193 @@ class MmPagePcpuDrainFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Page =
+  using FieldMetadata_Value =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MmPagePcpuDrainFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      G2dTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Page kPage() { return {}; }
-  void set_page(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId;
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Pfn =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MmPagePcpuDrainFtraceEvent>;
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/google_icc_trace.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pfn kPfn() { return {}; }
-  void set_pfn(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-};
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_GOOGLE_ICC_TRACE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_GOOGLE_ICC_TRACE_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-class MmPageFreeBatchedFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class GoogleIccEventFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  MmPageFreeBatchedFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MmPageFreeBatchedFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MmPageFreeBatchedFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_cold() const { return at<1>().valid(); }
-  int32_t cold() const { return at<1>().as_int32(); }
-  bool has_page() const { return at<2>().valid(); }
-  uint64_t page() const { return at<2>().as_uint64(); }
-  bool has_pfn() const { return at<3>().valid(); }
-  uint64_t pfn() const { return at<3>().as_uint64(); }
+  GoogleIccEventFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GoogleIccEventFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GoogleIccEventFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_event() const { return at<1>().valid(); }
+  ::protozero::ConstChars event() const { return at<1>().as_string(); }
+  bool has_timestamp() const { return at<2>().valid(); }
+  uint64_t timestamp() const { return at<2>().as_uint64(); }
 };
 
-class MmPageFreeBatchedFtraceEvent : public ::protozero::Message {
+class GoogleIccEventFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MmPageFreeBatchedFtraceEvent_Decoder;
+  using Decoder = GoogleIccEventFtraceEvent_Decoder;
   enum : int32_t {
-    kColdFieldNumber = 1,
-    kPageFieldNumber = 2,
-    kPfnFieldNumber = 3,
+    kEventFieldNumber = 1,
+    kTimestampFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MmPageFreeBatchedFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.GoogleIccEventFtraceEvent"; }
 
 
-  using FieldMetadata_Cold =
+  using FieldMetadata_Event =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MmPageFreeBatchedFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      GoogleIccEventFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cold kCold() { return {}; }
-  void set_cold(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Cold::kFieldId;
+  static constexpr FieldMetadata_Event kEvent{};
+  void set_event(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Event::kFieldId, data, size);
+  }
+  void set_event(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Event::kFieldId, chars.data, chars.size);
+  }
+  void set_event(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Event::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Page =
+  using FieldMetadata_Timestamp =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MmPageFreeBatchedFtraceEvent>;
+      GoogleIccEventFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Page kPage() { return {}; }
-  void set_page(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId;
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Pfn =
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/google_irm_trace.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_GOOGLE_IRM_TRACE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_GOOGLE_IRM_TRACE_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class GoogleIrmEventFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  GoogleIrmEventFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GoogleIrmEventFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GoogleIrmEventFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_event() const { return at<1>().valid(); }
+  ::protozero::ConstChars event() const { return at<1>().as_string(); }
+  bool has_timestamp() const { return at<2>().valid(); }
+  uint64_t timestamp() const { return at<2>().as_uint64(); }
+};
+
+class GoogleIrmEventFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = GoogleIrmEventFtraceEvent_Decoder;
+  enum : int32_t {
+    kEventFieldNumber = 1,
+    kTimestampFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.GoogleIrmEventFtraceEvent"; }
+
+
+  using FieldMetadata_Event =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      GoogleIrmEventFtraceEvent>;
+
+  static constexpr FieldMetadata_Event kEvent{};
+  void set_event(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Event::kFieldId, data, size);
+  }
+  void set_event(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Event::kFieldId, chars.data, chars.size);
+  }
+  void set_event(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Event::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Timestamp =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MmPageFreeBatchedFtraceEvent>;
+      GoogleIrmEventFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pfn kPfn() { return {}; }
-  void set_pfn(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId;
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -103818,48 +132767,65 @@ class MmPageFreeBatchedFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MmPageFreeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/gpu_mem.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_GPU_MEM_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_GPU_MEM_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class GpuMemTotalFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  MmPageFreeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MmPageFreeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MmPageFreeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_order() const { return at<1>().valid(); }
-  uint32_t order() const { return at<1>().as_uint32(); }
-  bool has_page() const { return at<2>().valid(); }
-  uint64_t page() const { return at<2>().as_uint64(); }
-  bool has_pfn() const { return at<3>().valid(); }
-  uint64_t pfn() const { return at<3>().as_uint64(); }
+  GpuMemTotalFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GpuMemTotalFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GpuMemTotalFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_gpu_id() const { return at<1>().valid(); }
+  uint32_t gpu_id() const { return at<1>().as_uint32(); }
+  bool has_pid() const { return at<2>().valid(); }
+  uint32_t pid() const { return at<2>().as_uint32(); }
+  bool has_size() const { return at<3>().valid(); }
+  uint64_t size() const { return at<3>().as_uint64(); }
 };
 
-class MmPageFreeFtraceEvent : public ::protozero::Message {
+class GpuMemTotalFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MmPageFreeFtraceEvent_Decoder;
+  using Decoder = GpuMemTotalFtraceEvent_Decoder;
   enum : int32_t {
-    kOrderFieldNumber = 1,
-    kPageFieldNumber = 2,
-    kPfnFieldNumber = 3,
+    kGpuIdFieldNumber = 1,
+    kPidFieldNumber = 2,
+    kSizeFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MmPageFreeFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.GpuMemTotalFtraceEvent"; }
 
 
-  using FieldMetadata_Order =
+  using FieldMetadata_GpuId =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MmPageFreeFtraceEvent>;
+      GpuMemTotalFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Order kOrder() { return {}; }
-  void set_order(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
+  static constexpr FieldMetadata_GpuId kGpuId{};
+  void set_gpu_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GpuId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -103867,49 +132833,35 @@ class MmPageFreeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Page =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MmPageFreeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      GpuMemTotalFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Page kPage() { return {}; }
-  void set_page(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pfn =
+  using FieldMetadata_Size =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MmPageFreeFtraceEvent>;
+      GpuMemTotalFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pfn kPfn() { return {}; }
-  void set_pfn(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId;
+  static constexpr FieldMetadata_Size kSize{};
+  void set_size(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -103918,101 +132870,104 @@ class MmPageFreeFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MmPageAllocZoneLockedFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/gpu_scheduler.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_GPU_SCHEDULER_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_GPU_SCHEDULER_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class DrmSchedJobUnschedulableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  MmPageAllocZoneLockedFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MmPageAllocZoneLockedFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MmPageAllocZoneLockedFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_migratetype() const { return at<1>().valid(); }
-  int32_t migratetype() const { return at<1>().as_int32(); }
-  bool has_order() const { return at<2>().valid(); }
-  uint32_t order() const { return at<2>().as_uint32(); }
-  bool has_page() const { return at<3>().valid(); }
-  uint64_t page() const { return at<3>().as_uint64(); }
-  bool has_pfn() const { return at<4>().valid(); }
-  uint64_t pfn() const { return at<4>().as_uint64(); }
+  DrmSchedJobUnschedulableFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DrmSchedJobUnschedulableFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DrmSchedJobUnschedulableFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_fence_context() const { return at<1>().valid(); }
+  uint64_t fence_context() const { return at<1>().as_uint64(); }
+  bool has_fence_seqno() const { return at<2>().valid(); }
+  uint64_t fence_seqno() const { return at<2>().as_uint64(); }
+  bool has_ctx() const { return at<3>().valid(); }
+  uint64_t ctx() const { return at<3>().as_uint64(); }
+  bool has_seqno() const { return at<4>().valid(); }
+  uint64_t seqno() const { return at<4>().as_uint64(); }
 };
 
-class MmPageAllocZoneLockedFtraceEvent : public ::protozero::Message {
+class DrmSchedJobUnschedulableFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MmPageAllocZoneLockedFtraceEvent_Decoder;
+  using Decoder = DrmSchedJobUnschedulableFtraceEvent_Decoder;
   enum : int32_t {
-    kMigratetypeFieldNumber = 1,
-    kOrderFieldNumber = 2,
-    kPageFieldNumber = 3,
-    kPfnFieldNumber = 4,
+    kFenceContextFieldNumber = 1,
+    kFenceSeqnoFieldNumber = 2,
+    kCtxFieldNumber = 3,
+    kSeqnoFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MmPageAllocZoneLockedFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.DrmSchedJobUnschedulableFtraceEvent"; }
 
 
-  using FieldMetadata_Migratetype =
+  using FieldMetadata_FenceContext =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MmPageAllocZoneLockedFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      DrmSchedJobUnschedulableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Migratetype kMigratetype() { return {}; }
-  void set_migratetype(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Migratetype::kFieldId;
+  static constexpr FieldMetadata_FenceContext kFenceContext{};
+  void set_fence_context(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FenceContext::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Order =
+  using FieldMetadata_FenceSeqno =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MmPageAllocZoneLockedFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      DrmSchedJobUnschedulableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Order kOrder() { return {}; }
-  void set_order(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
+  static constexpr FieldMetadata_FenceSeqno kFenceSeqno{};
+  void set_fence_seqno(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FenceSeqno::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Page =
+  using FieldMetadata_Ctx =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MmPageAllocZoneLockedFtraceEvent>;
+      DrmSchedJobUnschedulableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Page kPage() { return {}; }
-  void set_page(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId;
+  static constexpr FieldMetadata_Ctx kCtx{};
+  void set_ctx(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ctx::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -104020,24 +132975,17 @@ class MmPageAllocZoneLockedFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pfn =
+  using FieldMetadata_Seqno =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MmPageAllocZoneLockedFtraceEvent>;
+      DrmSchedJobUnschedulableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pfn kPfn() { return {}; }
-  void set_pfn(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId;
+  static constexpr FieldMetadata_Seqno kSeqno{};
+  void set_seqno(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -104046,110 +132994,95 @@ class MmPageAllocZoneLockedFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MmPageAllocExtfragFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DrmSchedJobRunFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
-  MmPageAllocExtfragFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MmPageAllocExtfragFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MmPageAllocExtfragFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_alloc_migratetype() const { return at<1>().valid(); }
-  int32_t alloc_migratetype() const { return at<1>().as_int32(); }
-  bool has_alloc_order() const { return at<2>().valid(); }
-  int32_t alloc_order() const { return at<2>().as_int32(); }
-  bool has_fallback_migratetype() const { return at<3>().valid(); }
-  int32_t fallback_migratetype() const { return at<3>().as_int32(); }
-  bool has_fallback_order() const { return at<4>().valid(); }
-  int32_t fallback_order() const { return at<4>().as_int32(); }
-  bool has_page() const { return at<5>().valid(); }
-  uint64_t page() const { return at<5>().as_uint64(); }
-  bool has_change_ownership() const { return at<6>().valid(); }
-  int32_t change_ownership() const { return at<6>().as_int32(); }
-  bool has_pfn() const { return at<7>().valid(); }
-  uint64_t pfn() const { return at<7>().as_uint64(); }
+  DrmSchedJobRunFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DrmSchedJobRunFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DrmSchedJobRunFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_job_count() const { return at<2>().valid(); }
+  uint32_t job_count() const { return at<2>().as_uint32(); }
+  bool has_hw_job_count() const { return at<3>().valid(); }
+  int32_t hw_job_count() const { return at<3>().as_int32(); }
+  bool has_dev() const { return at<4>().valid(); }
+  ::protozero::ConstChars dev() const { return at<4>().as_string(); }
+  bool has_fence_context() const { return at<5>().valid(); }
+  uint64_t fence_context() const { return at<5>().as_uint64(); }
+  bool has_fence_seqno() const { return at<6>().valid(); }
+  uint64_t fence_seqno() const { return at<6>().as_uint64(); }
+  bool has_client_id() const { return at<7>().valid(); }
+  uint64_t client_id() const { return at<7>().as_uint64(); }
 };
 
-class MmPageAllocExtfragFtraceEvent : public ::protozero::Message {
+class DrmSchedJobRunFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MmPageAllocExtfragFtraceEvent_Decoder;
+  using Decoder = DrmSchedJobRunFtraceEvent_Decoder;
   enum : int32_t {
-    kAllocMigratetypeFieldNumber = 1,
-    kAllocOrderFieldNumber = 2,
-    kFallbackMigratetypeFieldNumber = 3,
-    kFallbackOrderFieldNumber = 4,
-    kPageFieldNumber = 5,
-    kChangeOwnershipFieldNumber = 6,
-    kPfnFieldNumber = 7,
+    kNameFieldNumber = 1,
+    kJobCountFieldNumber = 2,
+    kHwJobCountFieldNumber = 3,
+    kDevFieldNumber = 4,
+    kFenceContextFieldNumber = 5,
+    kFenceSeqnoFieldNumber = 6,
+    kClientIdFieldNumber = 7,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MmPageAllocExtfragFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.DrmSchedJobRunFtraceEvent"; }
 
 
-  using FieldMetadata_AllocMigratetype =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MmPageAllocExtfragFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      DrmSchedJobRunFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AllocMigratetype kAllocMigratetype() { return {}; }
-  void set_alloc_migratetype(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AllocMigratetype::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_AllocOrder =
+  using FieldMetadata_JobCount =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MmPageAllocExtfragFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      DrmSchedJobRunFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AllocOrder kAllocOrder() { return {}; }
-  void set_alloc_order(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AllocOrder::kFieldId;
+  static constexpr FieldMetadata_JobCount kJobCount{};
+  void set_job_count(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_JobCount::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FallbackMigratetype =
+  using FieldMetadata_HwJobCount =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      MmPageAllocExtfragFtraceEvent>;
+      DrmSchedJobRunFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FallbackMigratetype kFallbackMigratetype() { return {}; }
-  void set_fallback_migratetype(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FallbackMigratetype::kFieldId;
+  static constexpr FieldMetadata_HwJobCount kHwJobCount{};
+  void set_hw_job_count(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_HwJobCount::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -104157,49 +133090,41 @@ class MmPageAllocExtfragFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FallbackOrder =
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MmPageAllocExtfragFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      DrmSchedJobRunFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FallbackOrder kFallbackOrder() { return {}; }
-  void set_fallback_order(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FallbackOrder::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Dev::kFieldId, data, size);
+  }
+  void set_dev(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Dev::kFieldId, chars.data, chars.size);
+  }
+  void set_dev(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Page =
+  using FieldMetadata_FenceContext =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MmPageAllocExtfragFtraceEvent>;
+      DrmSchedJobRunFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Page kPage() { return {}; }
-  void set_page(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId;
+  static constexpr FieldMetadata_FenceContext kFenceContext{};
+  void set_fence_context(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FenceContext::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -104207,49 +133132,35 @@ class MmPageAllocExtfragFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ChangeOwnership =
+  using FieldMetadata_FenceSeqno =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MmPageAllocExtfragFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      DrmSchedJobRunFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChangeOwnership kChangeOwnership() { return {}; }
-  void set_change_ownership(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ChangeOwnership::kFieldId;
+  static constexpr FieldMetadata_FenceSeqno kFenceSeqno{};
+  void set_fence_seqno(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FenceSeqno::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pfn =
+  using FieldMetadata_ClientId =
     ::protozero::proto_utils::FieldMetadata<
       7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MmPageAllocExtfragFtraceEvent>;
+      DrmSchedJobRunFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pfn kPfn() { return {}; }
-  void set_pfn(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId;
+  static constexpr FieldMetadata_ClientId kClientId{};
+  void set_client_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ClientId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -104258,54 +133169,77 @@ class MmPageAllocExtfragFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MmPageAllocFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DrmSchedJobQueueFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
-  MmPageAllocFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MmPageAllocFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MmPageAllocFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_gfp_flags() const { return at<1>().valid(); }
-  uint32_t gfp_flags() const { return at<1>().as_uint32(); }
-  bool has_migratetype() const { return at<2>().valid(); }
-  int32_t migratetype() const { return at<2>().as_int32(); }
-  bool has_order() const { return at<3>().valid(); }
-  uint32_t order() const { return at<3>().as_uint32(); }
-  bool has_page() const { return at<4>().valid(); }
-  uint64_t page() const { return at<4>().as_uint64(); }
-  bool has_pfn() const { return at<5>().valid(); }
-  uint64_t pfn() const { return at<5>().as_uint64(); }
+  DrmSchedJobQueueFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DrmSchedJobQueueFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DrmSchedJobQueueFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_job_count() const { return at<2>().valid(); }
+  uint32_t job_count() const { return at<2>().as_uint32(); }
+  bool has_hw_job_count() const { return at<3>().valid(); }
+  int32_t hw_job_count() const { return at<3>().as_int32(); }
+  bool has_dev() const { return at<4>().valid(); }
+  ::protozero::ConstChars dev() const { return at<4>().as_string(); }
+  bool has_fence_context() const { return at<5>().valid(); }
+  uint64_t fence_context() const { return at<5>().as_uint64(); }
+  bool has_fence_seqno() const { return at<6>().valid(); }
+  uint64_t fence_seqno() const { return at<6>().as_uint64(); }
+  bool has_client_id() const { return at<7>().valid(); }
+  uint64_t client_id() const { return at<7>().as_uint64(); }
 };
 
-class MmPageAllocFtraceEvent : public ::protozero::Message {
+class DrmSchedJobQueueFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MmPageAllocFtraceEvent_Decoder;
+  using Decoder = DrmSchedJobQueueFtraceEvent_Decoder;
   enum : int32_t {
-    kGfpFlagsFieldNumber = 1,
-    kMigratetypeFieldNumber = 2,
-    kOrderFieldNumber = 3,
-    kPageFieldNumber = 4,
-    kPfnFieldNumber = 5,
+    kNameFieldNumber = 1,
+    kJobCountFieldNumber = 2,
+    kHwJobCountFieldNumber = 3,
+    kDevFieldNumber = 4,
+    kFenceContextFieldNumber = 5,
+    kFenceSeqnoFieldNumber = 6,
+    kClientIdFieldNumber = 7,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MmPageAllocFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.DrmSchedJobQueueFtraceEvent"; }
 
 
-  using FieldMetadata_GfpFlags =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      DrmSchedJobQueueFtraceEvent>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_JobCount =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MmPageAllocFtraceEvent>;
+      DrmSchedJobQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GfpFlags kGfpFlags() { return {}; }
-  void set_gfp_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
+  static constexpr FieldMetadata_JobCount kJobCount{};
+  void set_job_count(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_JobCount::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -104313,24 +133247,17 @@ class MmPageAllocFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Migratetype =
+  using FieldMetadata_HwJobCount =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      MmPageAllocFtraceEvent>;
+      DrmSchedJobQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Migratetype kMigratetype() { return {}; }
-  void set_migratetype(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Migratetype::kFieldId;
+  static constexpr FieldMetadata_HwJobCount kHwJobCount{};
+  void set_hw_job_count(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_HwJobCount::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -104338,49 +133265,41 @@ class MmPageAllocFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Order =
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MmPageAllocFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      DrmSchedJobQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Order kOrder() { return {}; }
-  void set_order(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Dev::kFieldId, data, size);
+  }
+  void set_dev(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Dev::kFieldId, chars.data, chars.size);
+  }
+  void set_dev(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Page =
+  using FieldMetadata_FenceContext =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MmPageAllocFtraceEvent>;
+      DrmSchedJobQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Page kPage() { return {}; }
-  void set_page(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId;
+  static constexpr FieldMetadata_FenceContext kFenceContext{};
+  void set_fence_context(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FenceContext::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -104388,203 +133307,175 @@ class MmPageAllocFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pfn =
+  using FieldMetadata_FenceSeqno =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MmPageAllocFtraceEvent>;
+      DrmSchedJobQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pfn kPfn() { return {}; }
-  void set_pfn(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId;
+  static constexpr FieldMetadata_FenceSeqno kFenceSeqno{};
+  void set_fence_seqno(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FenceSeqno::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class MigrateRetryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  MigrateRetryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MigrateRetryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MigrateRetryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_tries() const { return at<1>().valid(); }
-  int32_t tries() const { return at<1>().as_int32(); }
-};
-
-class MigrateRetryFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = MigrateRetryFtraceEvent_Decoder;
-  enum : int32_t {
-    kTriesFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.MigrateRetryFtraceEvent"; }
 
-
-  using FieldMetadata_Tries =
+  using FieldMetadata_ClientId =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MigrateRetryFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      DrmSchedJobQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Tries kTries() { return {}; }
-  void set_tries(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Tries::kFieldId;
+  static constexpr FieldMetadata_ClientId kClientId{};
+  void set_client_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ClientId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class MigratePagesStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DrmSchedJobDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  MigratePagesStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MigratePagesStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MigratePagesStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_mode() const { return at<1>().valid(); }
-  int32_t mode() const { return at<1>().as_int32(); }
+  DrmSchedJobDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DrmSchedJobDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DrmSchedJobDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_fence_context() const { return at<1>().valid(); }
+  uint64_t fence_context() const { return at<1>().as_uint64(); }
+  bool has_fence_seqno() const { return at<2>().valid(); }
+  uint64_t fence_seqno() const { return at<2>().as_uint64(); }
 };
 
-class MigratePagesStartFtraceEvent : public ::protozero::Message {
+class DrmSchedJobDoneFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MigratePagesStartFtraceEvent_Decoder;
+  using Decoder = DrmSchedJobDoneFtraceEvent_Decoder;
   enum : int32_t {
-    kModeFieldNumber = 1,
+    kFenceContextFieldNumber = 1,
+    kFenceSeqnoFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MigratePagesStartFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.DrmSchedJobDoneFtraceEvent"; }
 
 
-  using FieldMetadata_Mode =
+  using FieldMetadata_FenceContext =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MigratePagesStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      DrmSchedJobDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mode kMode() { return {}; }
-  void set_mode(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+  static constexpr FieldMetadata_FenceContext kFenceContext{};
+  void set_fence_context(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FenceContext::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FenceSeqno =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      DrmSchedJobDoneFtraceEvent>;
+
+  static constexpr FieldMetadata_FenceSeqno kFenceSeqno{};
+  void set_fence_seqno(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FenceSeqno::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class MigratePagesEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DrmSchedJobAddDepFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  MigratePagesEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MigratePagesEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MigratePagesEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_mode() const { return at<1>().valid(); }
-  int32_t mode() const { return at<1>().as_int32(); }
+  DrmSchedJobAddDepFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DrmSchedJobAddDepFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DrmSchedJobAddDepFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_fence_context() const { return at<1>().valid(); }
+  uint64_t fence_context() const { return at<1>().as_uint64(); }
+  bool has_fence_seqno() const { return at<2>().valid(); }
+  uint64_t fence_seqno() const { return at<2>().as_uint64(); }
+  bool has_ctx() const { return at<3>().valid(); }
+  uint64_t ctx() const { return at<3>().as_uint64(); }
+  bool has_seqno() const { return at<4>().valid(); }
+  uint64_t seqno() const { return at<4>().as_uint64(); }
 };
 
-class MigratePagesEndFtraceEvent : public ::protozero::Message {
+class DrmSchedJobAddDepFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MigratePagesEndFtraceEvent_Decoder;
+  using Decoder = DrmSchedJobAddDepFtraceEvent_Decoder;
   enum : int32_t {
-    kModeFieldNumber = 1,
+    kFenceContextFieldNumber = 1,
+    kFenceSeqnoFieldNumber = 2,
+    kCtxFieldNumber = 3,
+    kSeqnoFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MigratePagesEndFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.DrmSchedJobAddDepFtraceEvent"; }
 
 
-  using FieldMetadata_Mode =
+  using FieldMetadata_FenceContext =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MigratePagesEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      DrmSchedJobAddDepFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mode kMode() { return {}; }
-  void set_mode(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+  static constexpr FieldMetadata_FenceContext kFenceContext{};
+  void set_fence_context(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FenceContext::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class KmemCacheFreeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  KmemCacheFreeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KmemCacheFreeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KmemCacheFreeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_call_site() const { return at<1>().valid(); }
-  uint64_t call_site() const { return at<1>().as_uint64(); }
-  bool has_ptr() const { return at<2>().valid(); }
-  uint64_t ptr() const { return at<2>().as_uint64(); }
-};
 
-class KmemCacheFreeFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = KmemCacheFreeFtraceEvent_Decoder;
-  enum : int32_t {
-    kCallSiteFieldNumber = 1,
-    kPtrFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.KmemCacheFreeFtraceEvent"; }
+  using FieldMetadata_FenceSeqno =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      DrmSchedJobAddDepFtraceEvent>;
 
+  static constexpr FieldMetadata_FenceSeqno kFenceSeqno{};
+  void set_fence_seqno(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FenceSeqno::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_CallSite =
+  using FieldMetadata_Ctx =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KmemCacheFreeFtraceEvent>;
+      DrmSchedJobAddDepFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CallSite kCallSite() { return {}; }
-  void set_call_site(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CallSite::kFieldId;
+  static constexpr FieldMetadata_Ctx kCtx{};
+  void set_ctx(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ctx::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -104592,24 +133483,17 @@ class KmemCacheFreeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ptr =
+  using FieldMetadata_Seqno =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KmemCacheFreeFtraceEvent>;
+      DrmSchedJobAddDepFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ptr kPtr() { return {}; }
-  void set_ptr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ptr::kFieldId;
+  static constexpr FieldMetadata_Seqno kSeqno{};
+  void set_seqno(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -104618,82 +133502,87 @@ class KmemCacheFreeFtraceEvent : public ::protozero::Message {
   }
 };
 
-class KmemCacheAllocNodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DrmSchedProcessJobFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  KmemCacheAllocNodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KmemCacheAllocNodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KmemCacheAllocNodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_bytes_alloc() const { return at<1>().valid(); }
-  uint64_t bytes_alloc() const { return at<1>().as_uint64(); }
-  bool has_bytes_req() const { return at<2>().valid(); }
-  uint64_t bytes_req() const { return at<2>().as_uint64(); }
-  bool has_call_site() const { return at<3>().valid(); }
-  uint64_t call_site() const { return at<3>().as_uint64(); }
-  bool has_gfp_flags() const { return at<4>().valid(); }
-  uint32_t gfp_flags() const { return at<4>().as_uint32(); }
-  bool has_node() const { return at<5>().valid(); }
-  int32_t node() const { return at<5>().as_int32(); }
-  bool has_ptr() const { return at<6>().valid(); }
-  uint64_t ptr() const { return at<6>().as_uint64(); }
+  DrmSchedProcessJobFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DrmSchedProcessJobFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DrmSchedProcessJobFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_fence() const { return at<1>().valid(); }
+  uint64_t fence() const { return at<1>().as_uint64(); }
 };
 
-class KmemCacheAllocNodeFtraceEvent : public ::protozero::Message {
+class DrmSchedProcessJobFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KmemCacheAllocNodeFtraceEvent_Decoder;
+  using Decoder = DrmSchedProcessJobFtraceEvent_Decoder;
   enum : int32_t {
-    kBytesAllocFieldNumber = 1,
-    kBytesReqFieldNumber = 2,
-    kCallSiteFieldNumber = 3,
-    kGfpFlagsFieldNumber = 4,
-    kNodeFieldNumber = 5,
-    kPtrFieldNumber = 6,
+    kFenceFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KmemCacheAllocNodeFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.DrmSchedProcessJobFtraceEvent"; }
 
 
-  using FieldMetadata_BytesAlloc =
+  using FieldMetadata_Fence =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KmemCacheAllocNodeFtraceEvent>;
+      DrmSchedProcessJobFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BytesAlloc kBytesAlloc() { return {}; }
-  void set_bytes_alloc(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BytesAlloc::kFieldId;
+  static constexpr FieldMetadata_Fence kFence{};
+  void set_fence(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Fence::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_BytesReq =
+class DrmRunJobFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
+ public:
+  DrmRunJobFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DrmRunJobFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DrmRunJobFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_entity() const { return at<1>().valid(); }
+  uint64_t entity() const { return at<1>().as_uint64(); }
+  bool has_fence() const { return at<2>().valid(); }
+  uint64_t fence() const { return at<2>().as_uint64(); }
+  bool has_hw_job_count() const { return at<3>().valid(); }
+  int32_t hw_job_count() const { return at<3>().as_int32(); }
+  bool has_id() const { return at<4>().valid(); }
+  uint64_t id() const { return at<4>().as_uint64(); }
+  bool has_job_count() const { return at<5>().valid(); }
+  uint32_t job_count() const { return at<5>().as_uint32(); }
+  bool has_name() const { return at<6>().valid(); }
+  ::protozero::ConstChars name() const { return at<6>().as_string(); }
+};
+
+class DrmRunJobFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = DrmRunJobFtraceEvent_Decoder;
+  enum : int32_t {
+    kEntityFieldNumber = 1,
+    kFenceFieldNumber = 2,
+    kHwJobCountFieldNumber = 3,
+    kIdFieldNumber = 4,
+    kJobCountFieldNumber = 5,
+    kNameFieldNumber = 6,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.DrmRunJobFtraceEvent"; }
+
+
+  using FieldMetadata_Entity =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KmemCacheAllocNodeFtraceEvent>;
+      DrmRunJobFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BytesReq kBytesReq() { return {}; }
-  void set_bytes_req(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BytesReq::kFieldId;
+  static constexpr FieldMetadata_Entity kEntity{};
+  void set_entity(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Entity::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -104701,24 +133590,17 @@ class KmemCacheAllocNodeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CallSite =
+  using FieldMetadata_Fence =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KmemCacheAllocNodeFtraceEvent>;
+      DrmRunJobFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CallSite kCallSite() { return {}; }
-  void set_call_site(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CallSite::kFieldId;
+  static constexpr FieldMetadata_Fence kFence{};
+  void set_fence(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Fence::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -104726,130 +133608,129 @@ class KmemCacheAllocNodeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_GfpFlags =
+  using FieldMetadata_HwJobCount =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      DrmRunJobFtraceEvent>;
+
+  static constexpr FieldMetadata_HwJobCount kHwJobCount{};
+  void set_hw_job_count(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_HwJobCount::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      KmemCacheAllocNodeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      DrmRunJobFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GfpFlags kGfpFlags() { return {}; }
-  void set_gfp_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Node =
+  using FieldMetadata_JobCount =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      KmemCacheAllocNodeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      DrmRunJobFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Node kNode() { return {}; }
-  void set_node(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Node::kFieldId;
+  static constexpr FieldMetadata_JobCount kJobCount{};
+  void set_job_count(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_JobCount::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ptr =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      KmemCacheAllocNodeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      DrmRunJobFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ptr kPtr() { return {}; }
-  void set_ptr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ptr::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 };
 
-class KmemCacheAllocFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DrmSchedJobFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  KmemCacheAllocFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KmemCacheAllocFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KmemCacheAllocFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_bytes_alloc() const { return at<1>().valid(); }
-  uint64_t bytes_alloc() const { return at<1>().as_uint64(); }
-  bool has_bytes_req() const { return at<2>().valid(); }
-  uint64_t bytes_req() const { return at<2>().as_uint64(); }
-  bool has_call_site() const { return at<3>().valid(); }
-  uint64_t call_site() const { return at<3>().as_uint64(); }
-  bool has_gfp_flags() const { return at<4>().valid(); }
-  uint32_t gfp_flags() const { return at<4>().as_uint32(); }
-  bool has_ptr() const { return at<5>().valid(); }
-  uint64_t ptr() const { return at<5>().as_uint64(); }
+  DrmSchedJobFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DrmSchedJobFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DrmSchedJobFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_entity() const { return at<1>().valid(); }
+  uint64_t entity() const { return at<1>().as_uint64(); }
+  bool has_fence() const { return at<2>().valid(); }
+  uint64_t fence() const { return at<2>().as_uint64(); }
+  bool has_hw_job_count() const { return at<3>().valid(); }
+  int32_t hw_job_count() const { return at<3>().as_int32(); }
+  bool has_id() const { return at<4>().valid(); }
+  uint64_t id() const { return at<4>().as_uint64(); }
+  bool has_job_count() const { return at<5>().valid(); }
+  uint32_t job_count() const { return at<5>().as_uint32(); }
+  bool has_name() const { return at<6>().valid(); }
+  ::protozero::ConstChars name() const { return at<6>().as_string(); }
 };
 
-class KmemCacheAllocFtraceEvent : public ::protozero::Message {
+class DrmSchedJobFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KmemCacheAllocFtraceEvent_Decoder;
+  using Decoder = DrmSchedJobFtraceEvent_Decoder;
   enum : int32_t {
-    kBytesAllocFieldNumber = 1,
-    kBytesReqFieldNumber = 2,
-    kCallSiteFieldNumber = 3,
-    kGfpFlagsFieldNumber = 4,
-    kPtrFieldNumber = 5,
+    kEntityFieldNumber = 1,
+    kFenceFieldNumber = 2,
+    kHwJobCountFieldNumber = 3,
+    kIdFieldNumber = 4,
+    kJobCountFieldNumber = 5,
+    kNameFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KmemCacheAllocFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.DrmSchedJobFtraceEvent"; }
 
 
-  using FieldMetadata_BytesAlloc =
+  using FieldMetadata_Entity =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KmemCacheAllocFtraceEvent>;
+      DrmSchedJobFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BytesAlloc kBytesAlloc() { return {}; }
-  void set_bytes_alloc(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BytesAlloc::kFieldId;
+  static constexpr FieldMetadata_Entity kEntity{};
+  void set_entity(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Entity::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -104857,24 +133738,17 @@ class KmemCacheAllocFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BytesReq =
+  using FieldMetadata_Fence =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KmemCacheAllocFtraceEvent>;
+      DrmSchedJobFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BytesReq kBytesReq() { return {}; }
-  void set_bytes_req(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BytesReq::kFieldId;
+  static constexpr FieldMetadata_Fence kFence{};
+  void set_fence(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Fence::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -104882,24 +133756,35 @@ class KmemCacheAllocFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CallSite =
+  using FieldMetadata_HwJobCount =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      DrmSchedJobFtraceEvent>;
+
+  static constexpr FieldMetadata_HwJobCount kHwJobCount{};
+  void set_hw_job_count(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_HwJobCount::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Id =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KmemCacheAllocFtraceEvent>;
+      DrmSchedJobFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CallSite kCallSite() { return {}; }
-  void set_call_site(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CallSite::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -104907,24 +133792,17 @@ class KmemCacheAllocFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_GfpFlags =
+  using FieldMetadata_JobCount =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      KmemCacheAllocFtraceEvent>;
+      DrmSchedJobFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GfpFlags kGfpFlags() { return {}; }
-  void set_gfp_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
+  static constexpr FieldMetadata_JobCount kJobCount{};
+  void set_job_count(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_JobCount::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -104932,83 +133810,87 @@ class KmemCacheAllocFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ptr =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      KmemCacheAllocFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      DrmSchedJobFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ptr kPtr() { return {}; }
-  void set_ptr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ptr::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 };
 
-class KmallocNodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/hyp.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_HYP_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_HYP_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class PsciMemProtectFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  KmallocNodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KmallocNodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KmallocNodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_bytes_alloc() const { return at<1>().valid(); }
-  uint64_t bytes_alloc() const { return at<1>().as_uint64(); }
-  bool has_bytes_req() const { return at<2>().valid(); }
-  uint64_t bytes_req() const { return at<2>().as_uint64(); }
-  bool has_call_site() const { return at<3>().valid(); }
-  uint64_t call_site() const { return at<3>().as_uint64(); }
-  bool has_gfp_flags() const { return at<4>().valid(); }
-  uint32_t gfp_flags() const { return at<4>().as_uint32(); }
-  bool has_node() const { return at<5>().valid(); }
-  int32_t node() const { return at<5>().as_int32(); }
-  bool has_ptr() const { return at<6>().valid(); }
-  uint64_t ptr() const { return at<6>().as_uint64(); }
+  PsciMemProtectFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PsciMemProtectFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PsciMemProtectFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_count() const { return at<1>().valid(); }
+  uint64_t count() const { return at<1>().as_uint64(); }
+  bool has_was() const { return at<2>().valid(); }
+  uint64_t was() const { return at<2>().as_uint64(); }
 };
 
-class KmallocNodeFtraceEvent : public ::protozero::Message {
+class PsciMemProtectFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KmallocNodeFtraceEvent_Decoder;
+  using Decoder = PsciMemProtectFtraceEvent_Decoder;
   enum : int32_t {
-    kBytesAllocFieldNumber = 1,
-    kBytesReqFieldNumber = 2,
-    kCallSiteFieldNumber = 3,
-    kGfpFlagsFieldNumber = 4,
-    kNodeFieldNumber = 5,
-    kPtrFieldNumber = 6,
+    kCountFieldNumber = 1,
+    kWasFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KmallocNodeFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.PsciMemProtectFtraceEvent"; }
 
 
-  using FieldMetadata_BytesAlloc =
+  using FieldMetadata_Count =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KmallocNodeFtraceEvent>;
+      PsciMemProtectFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BytesAlloc kBytesAlloc() { return {}; }
-  void set_bytes_alloc(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BytesAlloc::kFieldId;
+  static constexpr FieldMetadata_Count kCount{};
+  void set_count(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -105016,49 +133898,60 @@ class KmallocNodeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BytesReq =
+  using FieldMetadata_Was =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KmallocNodeFtraceEvent>;
+      PsciMemProtectFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BytesReq kBytesReq() { return {}; }
-  void set_bytes_req(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BytesReq::kFieldId;
+  static constexpr FieldMetadata_Was kWas{};
+  void set_was(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Was::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_CallSite =
+class IommuIdmapFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  IommuIdmapFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IommuIdmapFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IommuIdmapFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_from() const { return at<1>().valid(); }
+  uint64_t from() const { return at<1>().as_uint64(); }
+  bool has_to() const { return at<2>().valid(); }
+  uint64_t to() const { return at<2>().as_uint64(); }
+  bool has_prot() const { return at<3>().valid(); }
+  int32_t prot() const { return at<3>().as_int32(); }
+};
+
+class IommuIdmapFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = IommuIdmapFtraceEvent_Decoder;
+  enum : int32_t {
+    kFromFieldNumber = 1,
+    kToFieldNumber = 2,
+    kProtFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.IommuIdmapFtraceEvent"; }
+
+
+  using FieldMetadata_From =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KmallocNodeFtraceEvent>;
+      IommuIdmapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CallSite kCallSite() { return {}; }
-  void set_call_site(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CallSite::kFieldId;
+  static constexpr FieldMetadata_From kFrom{};
+  void set_from(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_From::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -105066,130 +133959,90 @@ class KmallocNodeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_GfpFlags =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      KmallocNodeFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GfpFlags kGfpFlags() { return {}; }
-  void set_gfp_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Node =
+  using FieldMetadata_To =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      KmallocNodeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IommuIdmapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Node kNode() { return {}; }
-  void set_node(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Node::kFieldId;
+  static constexpr FieldMetadata_To kTo{};
+  void set_to(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_To::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ptr =
+  using FieldMetadata_Prot =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      KmallocNodeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      IommuIdmapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ptr kPtr() { return {}; }
-  void set_ptr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ptr::kFieldId;
+  static constexpr FieldMetadata_Prot kProt{};
+  void set_prot(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prot::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class KmallocFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class HostFfaCallFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
-  KmallocFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KmallocFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KmallocFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_bytes_alloc() const { return at<1>().valid(); }
-  uint64_t bytes_alloc() const { return at<1>().as_uint64(); }
-  bool has_bytes_req() const { return at<2>().valid(); }
-  uint64_t bytes_req() const { return at<2>().as_uint64(); }
-  bool has_call_site() const { return at<3>().valid(); }
-  uint64_t call_site() const { return at<3>().as_uint64(); }
-  bool has_gfp_flags() const { return at<4>().valid(); }
-  uint32_t gfp_flags() const { return at<4>().as_uint32(); }
-  bool has_ptr() const { return at<5>().valid(); }
-  uint64_t ptr() const { return at<5>().as_uint64(); }
+  HostFfaCallFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HostFfaCallFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HostFfaCallFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_func_id() const { return at<1>().valid(); }
+  uint64_t func_id() const { return at<1>().as_uint64(); }
+  bool has_res_a1() const { return at<2>().valid(); }
+  uint64_t res_a1() const { return at<2>().as_uint64(); }
+  bool has_res_a2() const { return at<3>().valid(); }
+  uint64_t res_a2() const { return at<3>().as_uint64(); }
+  bool has_res_a3() const { return at<4>().valid(); }
+  uint64_t res_a3() const { return at<4>().as_uint64(); }
+  bool has_res_a4() const { return at<5>().valid(); }
+  uint64_t res_a4() const { return at<5>().as_uint64(); }
+  bool has_handled() const { return at<6>().valid(); }
+  int32_t handled() const { return at<6>().as_int32(); }
+  bool has_err() const { return at<7>().valid(); }
+  int32_t err() const { return at<7>().as_int32(); }
 };
 
-class KmallocFtraceEvent : public ::protozero::Message {
+class HostFfaCallFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KmallocFtraceEvent_Decoder;
+  using Decoder = HostFfaCallFtraceEvent_Decoder;
   enum : int32_t {
-    kBytesAllocFieldNumber = 1,
-    kBytesReqFieldNumber = 2,
-    kCallSiteFieldNumber = 3,
-    kGfpFlagsFieldNumber = 4,
-    kPtrFieldNumber = 5,
+    kFuncIdFieldNumber = 1,
+    kResA1FieldNumber = 2,
+    kResA2FieldNumber = 3,
+    kResA3FieldNumber = 4,
+    kResA4FieldNumber = 5,
+    kHandledFieldNumber = 6,
+    kErrFieldNumber = 7,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KmallocFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.HostFfaCallFtraceEvent"; }
 
 
-  using FieldMetadata_BytesAlloc =
+  using FieldMetadata_FuncId =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KmallocFtraceEvent>;
+      HostFfaCallFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BytesAlloc kBytesAlloc() { return {}; }
-  void set_bytes_alloc(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BytesAlloc::kFieldId;
+  static constexpr FieldMetadata_FuncId kFuncId{};
+  void set_func_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FuncId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -105197,24 +134050,17 @@ class KmallocFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BytesReq =
+  using FieldMetadata_ResA1 =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KmallocFtraceEvent>;
+      HostFfaCallFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BytesReq kBytesReq() { return {}; }
-  void set_bytes_req(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BytesReq::kFieldId;
+  static constexpr FieldMetadata_ResA1 kResA1{};
+  void set_res_a1(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResA1::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -105222,24 +134068,17 @@ class KmallocFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CallSite =
+  using FieldMetadata_ResA2 =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KmallocFtraceEvent>;
+      HostFfaCallFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CallSite kCallSite() { return {}; }
-  void set_call_site(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CallSite::kFieldId;
+  static constexpr FieldMetadata_ResA2 kResA2{};
+  void set_res_a2(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResA2::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -105247,168 +134086,111 @@ class KmallocFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_GfpFlags =
+  using FieldMetadata_ResA3 =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      KmallocFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HostFfaCallFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GfpFlags kGfpFlags() { return {}; }
-  void set_gfp_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
+  static constexpr FieldMetadata_ResA3 kResA3{};
+  void set_res_a3(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResA3::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ptr =
+  using FieldMetadata_ResA4 =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KmallocFtraceEvent>;
+      HostFfaCallFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ptr kPtr() { return {}; }
-  void set_ptr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ptr::kFieldId;
+  static constexpr FieldMetadata_ResA4 kResA4{};
+  void set_res_a4(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResA4::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class KfreeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  KfreeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KfreeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KfreeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_call_site() const { return at<1>().valid(); }
-  uint64_t call_site() const { return at<1>().as_uint64(); }
-  bool has_ptr() const { return at<2>().valid(); }
-  uint64_t ptr() const { return at<2>().as_uint64(); }
-};
-
-class KfreeFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = KfreeFtraceEvent_Decoder;
-  enum : int32_t {
-    kCallSiteFieldNumber = 1,
-    kPtrFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.KfreeFtraceEvent"; }
-
 
-  using FieldMetadata_CallSite =
+  using FieldMetadata_Handled =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      KfreeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      HostFfaCallFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CallSite kCallSite() { return {}; }
-  void set_call_site(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CallSite::kFieldId;
+  static constexpr FieldMetadata_Handled kHandled{};
+  void set_handled(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Handled::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ptr =
+  using FieldMetadata_Err =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      KfreeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      HostFfaCallFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ptr kPtr() { return {}; }
-  void set_ptr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ptr::kFieldId;
+  static constexpr FieldMetadata_Err kErr{};
+  void set_err(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Err::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class IonSecureCmaShrinkPoolStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class HostMemAbortFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  IonSecureCmaShrinkPoolStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IonSecureCmaShrinkPoolStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IonSecureCmaShrinkPoolStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_drained_size() const { return at<1>().valid(); }
-  uint64_t drained_size() const { return at<1>().as_uint64(); }
-  bool has_skipped_size() const { return at<2>().valid(); }
-  uint64_t skipped_size() const { return at<2>().as_uint64(); }
+  HostMemAbortFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HostMemAbortFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HostMemAbortFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_esr() const { return at<1>().valid(); }
+  uint64_t esr() const { return at<1>().as_uint64(); }
+  bool has_addr() const { return at<2>().valid(); }
+  uint64_t addr() const { return at<2>().as_uint64(); }
 };
 
-class IonSecureCmaShrinkPoolStartFtraceEvent : public ::protozero::Message {
+class HostMemAbortFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = IonSecureCmaShrinkPoolStartFtraceEvent_Decoder;
+  using Decoder = HostMemAbortFtraceEvent_Decoder;
   enum : int32_t {
-    kDrainedSizeFieldNumber = 1,
-    kSkippedSizeFieldNumber = 2,
+    kEsrFieldNumber = 1,
+    kAddrFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.IonSecureCmaShrinkPoolStartFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.HostMemAbortFtraceEvent"; }
 
 
-  using FieldMetadata_DrainedSize =
+  using FieldMetadata_Esr =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      IonSecureCmaShrinkPoolStartFtraceEvent>;
+      HostMemAbortFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DrainedSize kDrainedSize() { return {}; }
-  void set_drained_size(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DrainedSize::kFieldId;
+  static constexpr FieldMetadata_Esr kEsr{};
+  void set_esr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Esr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -105416,24 +134198,17 @@ class IonSecureCmaShrinkPoolStartFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SkippedSize =
+  using FieldMetadata_Addr =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      IonSecureCmaShrinkPoolStartFtraceEvent>;
+      HostMemAbortFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SkippedSize kSkippedSize() { return {}; }
-  void set_skipped_size(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SkippedSize::kFieldId;
+  static constexpr FieldMetadata_Addr kAddr{};
+  void set_addr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -105442,45 +134217,38 @@ class IonSecureCmaShrinkPoolStartFtraceEvent : public ::protozero::Message {
   }
 };
 
-class IonSecureCmaShrinkPoolEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class HostSmcFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  IonSecureCmaShrinkPoolEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IonSecureCmaShrinkPoolEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IonSecureCmaShrinkPoolEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_drained_size() const { return at<1>().valid(); }
-  uint64_t drained_size() const { return at<1>().as_uint64(); }
-  bool has_skipped_size() const { return at<2>().valid(); }
-  uint64_t skipped_size() const { return at<2>().as_uint64(); }
+  HostSmcFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HostSmcFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HostSmcFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  uint64_t id() const { return at<1>().as_uint64(); }
+  bool has_forwarded() const { return at<2>().valid(); }
+  uint32_t forwarded() const { return at<2>().as_uint32(); }
 };
 
-class IonSecureCmaShrinkPoolEndFtraceEvent : public ::protozero::Message {
+class HostSmcFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = IonSecureCmaShrinkPoolEndFtraceEvent_Decoder;
+  using Decoder = HostSmcFtraceEvent_Decoder;
   enum : int32_t {
-    kDrainedSizeFieldNumber = 1,
-    kSkippedSizeFieldNumber = 2,
+    kIdFieldNumber = 1,
+    kForwardedFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.IonSecureCmaShrinkPoolEndFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.HostSmcFtraceEvent"; }
 
 
-  using FieldMetadata_DrainedSize =
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      IonSecureCmaShrinkPoolEndFtraceEvent>;
+      HostSmcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DrainedSize kDrainedSize() { return {}; }
-  void set_drained_size(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DrainedSize::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -105488,211 +134256,255 @@ class IonSecureCmaShrinkPoolEndFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SkippedSize =
+  using FieldMetadata_Forwarded =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IonSecureCmaShrinkPoolEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      HostSmcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SkippedSize kSkippedSize() { return {}; }
-  void set_skipped_size(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SkippedSize::kFieldId;
+  static constexpr FieldMetadata_Forwarded kForwarded{};
+  void set_forwarded(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Forwarded::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class IonSecureCmaAllocateStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class HostHcallFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  IonSecureCmaAllocateStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IonSecureCmaAllocateStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IonSecureCmaAllocateStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_align() const { return at<1>().valid(); }
-  uint64_t align() const { return at<1>().as_uint64(); }
-  bool has_flags() const { return at<2>().valid(); }
-  uint64_t flags() const { return at<2>().as_uint64(); }
-  bool has_heap_name() const { return at<3>().valid(); }
-  ::protozero::ConstChars heap_name() const { return at<3>().as_string(); }
-  bool has_len() const { return at<4>().valid(); }
-  uint64_t len() const { return at<4>().as_uint64(); }
+  HostHcallFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HostHcallFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HostHcallFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  uint32_t id() const { return at<1>().as_uint32(); }
+  bool has_invalid() const { return at<2>().valid(); }
+  uint32_t invalid() const { return at<2>().as_uint32(); }
 };
 
-class IonSecureCmaAllocateStartFtraceEvent : public ::protozero::Message {
+class HostHcallFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = IonSecureCmaAllocateStartFtraceEvent_Decoder;
+  using Decoder = HostHcallFtraceEvent_Decoder;
   enum : int32_t {
-    kAlignFieldNumber = 1,
-    kFlagsFieldNumber = 2,
-    kHeapNameFieldNumber = 3,
-    kLenFieldNumber = 4,
+    kIdFieldNumber = 1,
+    kInvalidFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.IonSecureCmaAllocateStartFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.HostHcallFtraceEvent"; }
 
 
-  using FieldMetadata_Align =
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IonSecureCmaAllocateStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      HostHcallFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Align kAlign() { return {}; }
-  void set_align(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Align::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_Invalid =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IonSecureCmaAllocateStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      HostHcallFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_Invalid kInvalid{};
+  void set_invalid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Invalid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_HeapName =
+class HypExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0> {
+ public:
+  HypExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HypExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HypExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+};
+
+class HypExitFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = HypExitFtraceEvent_Decoder;
+  static constexpr const char* GetName() { return ".perfetto.protos.HypExitFtraceEvent"; }
+
+};
+
+class HypEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0> {
+ public:
+  HypEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HypEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HypEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+};
+
+class HypEnterFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = HypEnterFtraceEvent_Decoder;
+  static constexpr const char* GetName() { return ".perfetto.protos.HypEnterFtraceEvent"; }
+
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/hypervisor.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_HYPERVISOR_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_HYPERVISOR_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class HypervisorVcpuIllegalTrapFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  HypervisorVcpuIllegalTrapFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HypervisorVcpuIllegalTrapFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HypervisorVcpuIllegalTrapFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_esr() const { return at<1>().valid(); }
+  uint64_t esr() const { return at<1>().as_uint64(); }
+};
+
+class HypervisorVcpuIllegalTrapFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = HypervisorVcpuIllegalTrapFtraceEvent_Decoder;
+  enum : int32_t {
+    kEsrFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.HypervisorVcpuIllegalTrapFtraceEvent"; }
+
+
+  using FieldMetadata_Esr =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      IonSecureCmaAllocateStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HypervisorVcpuIllegalTrapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HeapName kHeapName() { return {}; }
-  void set_heap_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_HeapName::kFieldId, data, size);
-  }
-  void set_heap_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size);
-  }
-  void set_heap_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId;
+  static constexpr FieldMetadata_Esr kEsr{};
+  void set_esr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Esr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Len =
+class HypervisorIommuIdmapCompleteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  HypervisorIommuIdmapCompleteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HypervisorIommuIdmapCompleteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HypervisorIommuIdmapCompleteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_map() const { return at<1>().valid(); }
+  uint32_t map() const { return at<1>().as_uint32(); }
+};
+
+class HypervisorIommuIdmapCompleteFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = HypervisorIommuIdmapCompleteFtraceEvent_Decoder;
+  enum : int32_t {
+    kMapFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.HypervisorIommuIdmapCompleteFtraceEvent"; }
+
+
+  using FieldMetadata_Map =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IonSecureCmaAllocateStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      HypervisorIommuIdmapCompleteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_Map kMap{};
+  void set_map(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Map::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class IonSecureCmaAllocateEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class HypervisorHypEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0> {
  public:
-  IonSecureCmaAllocateEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IonSecureCmaAllocateEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IonSecureCmaAllocateEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_align() const { return at<1>().valid(); }
-  uint64_t align() const { return at<1>().as_uint64(); }
-  bool has_flags() const { return at<2>().valid(); }
-  uint64_t flags() const { return at<2>().as_uint64(); }
-  bool has_heap_name() const { return at<3>().valid(); }
-  ::protozero::ConstChars heap_name() const { return at<3>().as_string(); }
-  bool has_len() const { return at<4>().valid(); }
-  uint64_t len() const { return at<4>().as_uint64(); }
+  HypervisorHypEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HypervisorHypEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HypervisorHypEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
 };
 
-class IonSecureCmaAllocateEndFtraceEvent : public ::protozero::Message {
+class HypervisorHypEnterFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = IonSecureCmaAllocateEndFtraceEvent_Decoder;
+  using Decoder = HypervisorHypEnterFtraceEvent_Decoder;
+  static constexpr const char* GetName() { return ".perfetto.protos.HypervisorHypEnterFtraceEvent"; }
+
+};
+
+class HypervisorHostMemAbortFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  HypervisorHostMemAbortFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HypervisorHostMemAbortFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HypervisorHostMemAbortFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_esr() const { return at<1>().valid(); }
+  uint64_t esr() const { return at<1>().as_uint64(); }
+  bool has_addr() const { return at<2>().valid(); }
+  uint64_t addr() const { return at<2>().as_uint64(); }
+};
+
+class HypervisorHostMemAbortFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = HypervisorHostMemAbortFtraceEvent_Decoder;
   enum : int32_t {
-    kAlignFieldNumber = 1,
-    kFlagsFieldNumber = 2,
-    kHeapNameFieldNumber = 3,
-    kLenFieldNumber = 4,
+    kEsrFieldNumber = 1,
+    kAddrFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.IonSecureCmaAllocateEndFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.HypervisorHostMemAbortFtraceEvent"; }
 
 
-  using FieldMetadata_Align =
+  using FieldMetadata_Esr =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      IonSecureCmaAllocateEndFtraceEvent>;
+      HypervisorHostMemAbortFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Align kAlign() { return {}; }
-  void set_align(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Align::kFieldId;
+  static constexpr FieldMetadata_Esr kEsr{};
+  void set_esr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Esr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -105700,80 +134512,75 @@ class IonSecureCmaAllocateEndFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_Addr =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      IonSecureCmaAllocateEndFtraceEvent>;
+      HypervisorHostMemAbortFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_Addr kAddr{};
+  void set_addr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_HeapName =
+class HypervisorPsciMemProtectFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  HypervisorPsciMemProtectFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HypervisorPsciMemProtectFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HypervisorPsciMemProtectFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_count() const { return at<1>().valid(); }
+  uint64_t count() const { return at<1>().as_uint64(); }
+  bool has_was() const { return at<2>().valid(); }
+  uint64_t was() const { return at<2>().as_uint64(); }
+};
+
+class HypervisorPsciMemProtectFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = HypervisorPsciMemProtectFtraceEvent_Decoder;
+  enum : int32_t {
+    kCountFieldNumber = 1,
+    kWasFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.HypervisorPsciMemProtectFtraceEvent"; }
+
+
+  using FieldMetadata_Count =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      IonSecureCmaAllocateEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HypervisorPsciMemProtectFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HeapName kHeapName() { return {}; }
-  void set_heap_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_HeapName::kFieldId, data, size);
-  }
-  void set_heap_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size);
-  }
-  void set_heap_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId;
+  static constexpr FieldMetadata_Count kCount{};
+  void set_count(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_Was =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      IonSecureCmaAllocateEndFtraceEvent>;
+      HypervisorPsciMemProtectFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_Was kWas{};
+  void set_was(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Was::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -105782,73 +134589,59 @@ class IonSecureCmaAllocateEndFtraceEvent : public ::protozero::Message {
   }
 };
 
-class IonSecureCmaAddToPoolStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class HypervisorIommuIdmapFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  IonSecureCmaAddToPoolStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IonSecureCmaAddToPoolStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IonSecureCmaAddToPoolStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_is_prefetch() const { return at<1>().valid(); }
-  uint32_t is_prefetch() const { return at<1>().as_uint32(); }
-  bool has_len() const { return at<2>().valid(); }
-  uint64_t len() const { return at<2>().as_uint64(); }
-  bool has_pool_total() const { return at<3>().valid(); }
-  int32_t pool_total() const { return at<3>().as_int32(); }
+  HypervisorIommuIdmapFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HypervisorIommuIdmapFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HypervisorIommuIdmapFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_from() const { return at<1>().valid(); }
+  uint64_t from() const { return at<1>().as_uint64(); }
+  bool has_to() const { return at<2>().valid(); }
+  uint64_t to() const { return at<2>().as_uint64(); }
+  bool has_prot() const { return at<3>().valid(); }
+  int32_t prot() const { return at<3>().as_int32(); }
 };
 
-class IonSecureCmaAddToPoolStartFtraceEvent : public ::protozero::Message {
+class HypervisorIommuIdmapFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = IonSecureCmaAddToPoolStartFtraceEvent_Decoder;
+  using Decoder = HypervisorIommuIdmapFtraceEvent_Decoder;
   enum : int32_t {
-    kIsPrefetchFieldNumber = 1,
-    kLenFieldNumber = 2,
-    kPoolTotalFieldNumber = 3,
+    kFromFieldNumber = 1,
+    kToFieldNumber = 2,
+    kProtFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.IonSecureCmaAddToPoolStartFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.HypervisorIommuIdmapFtraceEvent"; }
 
 
-  using FieldMetadata_IsPrefetch =
+  using FieldMetadata_From =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      IonSecureCmaAddToPoolStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HypervisorIommuIdmapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IsPrefetch kIsPrefetch() { return {}; }
-  void set_is_prefetch(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IsPrefetch::kFieldId;
+  static constexpr FieldMetadata_From kFrom{};
+  void set_from(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_From::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_To =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      IonSecureCmaAddToPoolStartFtraceEvent>;
+      HypervisorIommuIdmapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_To kTo{};
+  void set_to(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_To::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -105856,24 +134649,17 @@ class IonSecureCmaAddToPoolStartFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PoolTotal =
+  using FieldMetadata_Prot =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      IonSecureCmaAddToPoolStartFtraceEvent>;
+      HypervisorIommuIdmapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PoolTotal kPoolTotal() { return {}; }
-  void set_pool_total(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PoolTotal::kFieldId;
+  static constexpr FieldMetadata_Prot kProt{};
+  void set_prot(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prot::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -105882,73 +134668,52 @@ class IonSecureCmaAddToPoolStartFtraceEvent : public ::protozero::Message {
   }
 };
 
-class IonSecureCmaAddToPoolEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class HypervisorHypExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0> {
  public:
-  IonSecureCmaAddToPoolEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IonSecureCmaAddToPoolEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IonSecureCmaAddToPoolEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_is_prefetch() const { return at<1>().valid(); }
-  uint32_t is_prefetch() const { return at<1>().as_uint32(); }
-  bool has_len() const { return at<2>().valid(); }
-  uint64_t len() const { return at<2>().as_uint64(); }
-  bool has_pool_total() const { return at<3>().valid(); }
-  int32_t pool_total() const { return at<3>().as_int32(); }
+  HypervisorHypExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HypervisorHypExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HypervisorHypExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
 };
 
-class IonSecureCmaAddToPoolEndFtraceEvent : public ::protozero::Message {
+class HypervisorHypExitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = IonSecureCmaAddToPoolEndFtraceEvent_Decoder;
+  using Decoder = HypervisorHypExitFtraceEvent_Decoder;
+  static constexpr const char* GetName() { return ".perfetto.protos.HypervisorHypExitFtraceEvent"; }
+
+};
+
+class HypervisorHostSmcFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  HypervisorHostSmcFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HypervisorHostSmcFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HypervisorHostSmcFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  uint64_t id() const { return at<1>().as_uint64(); }
+  bool has_forwarded() const { return at<2>().valid(); }
+  uint32_t forwarded() const { return at<2>().as_uint32(); }
+};
+
+class HypervisorHostSmcFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = HypervisorHostSmcFtraceEvent_Decoder;
   enum : int32_t {
-    kIsPrefetchFieldNumber = 1,
-    kLenFieldNumber = 2,
-    kPoolTotalFieldNumber = 3,
+    kIdFieldNumber = 1,
+    kForwardedFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.IonSecureCmaAddToPoolEndFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.HypervisorHostSmcFtraceEvent"; }
 
 
-  using FieldMetadata_IsPrefetch =
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      IonSecureCmaAddToPoolEndFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IsPrefetch kIsPrefetch() { return {}; }
-  void set_is_prefetch(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IsPrefetch::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Len =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      IonSecureCmaAddToPoolEndFtraceEvent>;
+      HypervisorHostSmcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -105956,465 +134721,490 @@ class IonSecureCmaAddToPoolEndFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PoolTotal =
+  using FieldMetadata_Forwarded =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      IonSecureCmaAddToPoolEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      HypervisorHostSmcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PoolTotal kPoolTotal() { return {}; }
-  void set_pool_total(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PoolTotal::kFieldId;
+  static constexpr FieldMetadata_Forwarded kForwarded{};
+  void set_forwarded(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Forwarded::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class IonPrefetchingFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class HypervisorHostHcallFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  IonPrefetchingFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IonPrefetchingFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IonPrefetchingFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_len() const { return at<1>().valid(); }
-  uint64_t len() const { return at<1>().as_uint64(); }
+  HypervisorHostHcallFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HypervisorHostHcallFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HypervisorHostHcallFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  uint32_t id() const { return at<1>().as_uint32(); }
+  bool has_invalid() const { return at<2>().valid(); }
+  uint32_t invalid() const { return at<2>().as_uint32(); }
 };
 
-class IonPrefetchingFtraceEvent : public ::protozero::Message {
+class HypervisorHostHcallFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = IonPrefetchingFtraceEvent_Decoder;
+  using Decoder = HypervisorHostHcallFtraceEvent_Decoder;
   enum : int32_t {
-    kLenFieldNumber = 1,
+    kIdFieldNumber = 1,
+    kInvalidFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.IonPrefetchingFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.HypervisorHostHcallFtraceEvent"; }
 
 
-  using FieldMetadata_Len =
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IonPrefetchingFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      HypervisorHostHcallFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Invalid =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      HypervisorHostHcallFtraceEvent>;
+
+  static constexpr FieldMetadata_Invalid kInvalid{};
+  void set_invalid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Invalid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class IonCpSecureBufferStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/i2c.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_I2C_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_I2C_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class SmbusReplyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  IonCpSecureBufferStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IonCpSecureBufferStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IonCpSecureBufferStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_align() const { return at<1>().valid(); }
-  uint64_t align() const { return at<1>().as_uint64(); }
-  bool has_flags() const { return at<2>().valid(); }
-  uint64_t flags() const { return at<2>().as_uint64(); }
-  bool has_heap_name() const { return at<3>().valid(); }
-  ::protozero::ConstChars heap_name() const { return at<3>().as_string(); }
-  bool has_len() const { return at<4>().valid(); }
-  uint64_t len() const { return at<4>().as_uint64(); }
+  SmbusReplyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SmbusReplyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SmbusReplyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_adapter_nr() const { return at<1>().valid(); }
+  int32_t adapter_nr() const { return at<1>().as_int32(); }
+  bool has_addr() const { return at<2>().valid(); }
+  uint32_t addr() const { return at<2>().as_uint32(); }
+  bool has_flags() const { return at<3>().valid(); }
+  uint32_t flags() const { return at<3>().as_uint32(); }
+  bool has_command() const { return at<4>().valid(); }
+  uint32_t command() const { return at<4>().as_uint32(); }
+  bool has_len() const { return at<5>().valid(); }
+  uint32_t len() const { return at<5>().as_uint32(); }
+  bool has_protocol() const { return at<6>().valid(); }
+  uint32_t protocol() const { return at<6>().as_uint32(); }
 };
 
-class IonCpSecureBufferStartFtraceEvent : public ::protozero::Message {
+class SmbusReplyFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = IonCpSecureBufferStartFtraceEvent_Decoder;
+  using Decoder = SmbusReplyFtraceEvent_Decoder;
   enum : int32_t {
-    kAlignFieldNumber = 1,
-    kFlagsFieldNumber = 2,
-    kHeapNameFieldNumber = 3,
-    kLenFieldNumber = 4,
+    kAdapterNrFieldNumber = 1,
+    kAddrFieldNumber = 2,
+    kFlagsFieldNumber = 3,
+    kCommandFieldNumber = 4,
+    kLenFieldNumber = 5,
+    kProtocolFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.IonCpSecureBufferStartFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.SmbusReplyFtraceEvent"; }
 
 
-  using FieldMetadata_Align =
+  using FieldMetadata_AdapterNr =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IonCpSecureBufferStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SmbusReplyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Align kAlign() { return {}; }
-  void set_align(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Align::kFieldId;
+  static constexpr FieldMetadata_AdapterNr kAdapterNr{};
+  void set_adapter_nr(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_Addr =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IonCpSecureBufferStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SmbusReplyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_Addr kAddr{};
+  void set_addr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_HeapName =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      IonCpSecureBufferStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SmbusReplyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HeapName kHeapName() { return {}; }
-  void set_heap_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_HeapName::kFieldId, data, size);
-  }
-  void set_heap_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size);
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
-  void set_heap_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId;
+
+  using FieldMetadata_Command =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SmbusReplyFtraceEvent>;
+
+  static constexpr FieldMetadata_Command kCommand{};
+  void set_command(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Command::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
   using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IonCpSecureBufferStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SmbusReplyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint64_t value) {
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Protocol =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SmbusReplyFtraceEvent>;
+
+  static constexpr FieldMetadata_Protocol kProtocol{};
+  void set_protocol(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Protocol::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class IonCpSecureBufferEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class SmbusResultFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
-  IonCpSecureBufferEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IonCpSecureBufferEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IonCpSecureBufferEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_align() const { return at<1>().valid(); }
-  uint64_t align() const { return at<1>().as_uint64(); }
-  bool has_flags() const { return at<2>().valid(); }
-  uint64_t flags() const { return at<2>().as_uint64(); }
-  bool has_heap_name() const { return at<3>().valid(); }
-  ::protozero::ConstChars heap_name() const { return at<3>().as_string(); }
-  bool has_len() const { return at<4>().valid(); }
-  uint64_t len() const { return at<4>().as_uint64(); }
+  SmbusResultFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SmbusResultFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SmbusResultFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_adapter_nr() const { return at<1>().valid(); }
+  int32_t adapter_nr() const { return at<1>().as_int32(); }
+  bool has_addr() const { return at<2>().valid(); }
+  uint32_t addr() const { return at<2>().as_uint32(); }
+  bool has_flags() const { return at<3>().valid(); }
+  uint32_t flags() const { return at<3>().as_uint32(); }
+  bool has_read_write() const { return at<4>().valid(); }
+  uint32_t read_write() const { return at<4>().as_uint32(); }
+  bool has_command() const { return at<5>().valid(); }
+  uint32_t command() const { return at<5>().as_uint32(); }
+  bool has_res() const { return at<6>().valid(); }
+  int32_t res() const { return at<6>().as_int32(); }
+  bool has_protocol() const { return at<7>().valid(); }
+  uint32_t protocol() const { return at<7>().as_uint32(); }
 };
 
-class IonCpSecureBufferEndFtraceEvent : public ::protozero::Message {
+class SmbusResultFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = IonCpSecureBufferEndFtraceEvent_Decoder;
+  using Decoder = SmbusResultFtraceEvent_Decoder;
   enum : int32_t {
-    kAlignFieldNumber = 1,
-    kFlagsFieldNumber = 2,
-    kHeapNameFieldNumber = 3,
-    kLenFieldNumber = 4,
+    kAdapterNrFieldNumber = 1,
+    kAddrFieldNumber = 2,
+    kFlagsFieldNumber = 3,
+    kReadWriteFieldNumber = 4,
+    kCommandFieldNumber = 5,
+    kResFieldNumber = 6,
+    kProtocolFieldNumber = 7,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.IonCpSecureBufferEndFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.SmbusResultFtraceEvent"; }
 
 
-  using FieldMetadata_Align =
+  using FieldMetadata_AdapterNr =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IonCpSecureBufferEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SmbusResultFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Align kAlign() { return {}; }
-  void set_align(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Align::kFieldId;
+  static constexpr FieldMetadata_AdapterNr kAdapterNr{};
+  void set_adapter_nr(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_Addr =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IonCpSecureBufferEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SmbusResultFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_Addr kAddr{};
+  void set_addr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_HeapName =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      IonCpSecureBufferEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SmbusResultFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HeapName kHeapName() { return {}; }
-  void set_heap_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_HeapName::kFieldId, data, size);
-  }
-  void set_heap_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size);
-  }
-  void set_heap_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_ReadWrite =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IonCpSecureBufferEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SmbusResultFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_ReadWrite kReadWrite{};
+  void set_read_write(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReadWrite::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class IonCpAllocRetryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  IonCpAllocRetryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IonCpAllocRetryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IonCpAllocRetryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_tries() const { return at<1>().valid(); }
-  int32_t tries() const { return at<1>().as_int32(); }
-};
 
-class IonCpAllocRetryFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = IonCpAllocRetryFtraceEvent_Decoder;
-  enum : int32_t {
-    kTriesFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.IonCpAllocRetryFtraceEvent"; }
+  using FieldMetadata_Command =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SmbusResultFtraceEvent>;
 
+  static constexpr FieldMetadata_Command kCommand{};
+  void set_command(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Command::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Tries =
+  using FieldMetadata_Res =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      IonCpAllocRetryFtraceEvent>;
+      SmbusResultFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Tries kTries() { return {}; }
-  void set_tries(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Tries::kFieldId;
+  static constexpr FieldMetadata_Res kRes{};
+  void set_res(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Res::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_Protocol =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SmbusResultFtraceEvent>;
+
+  static constexpr FieldMetadata_Protocol kProtocol{};
+  void set_protocol(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Protocol::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class IonAllocBufferStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class SmbusWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  IonAllocBufferStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IonAllocBufferStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IonAllocBufferStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_client_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars client_name() const { return at<1>().as_string(); }
-  bool has_flags() const { return at<2>().valid(); }
-  uint32_t flags() const { return at<2>().as_uint32(); }
-  bool has_heap_name() const { return at<3>().valid(); }
-  ::protozero::ConstChars heap_name() const { return at<3>().as_string(); }
-  bool has_len() const { return at<4>().valid(); }
-  uint64_t len() const { return at<4>().as_uint64(); }
-  bool has_mask() const { return at<5>().valid(); }
-  uint32_t mask() const { return at<5>().as_uint32(); }
+  SmbusWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SmbusWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SmbusWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_adapter_nr() const { return at<1>().valid(); }
+  int32_t adapter_nr() const { return at<1>().as_int32(); }
+  bool has_addr() const { return at<2>().valid(); }
+  uint32_t addr() const { return at<2>().as_uint32(); }
+  bool has_flags() const { return at<3>().valid(); }
+  uint32_t flags() const { return at<3>().as_uint32(); }
+  bool has_command() const { return at<4>().valid(); }
+  uint32_t command() const { return at<4>().as_uint32(); }
+  bool has_len() const { return at<5>().valid(); }
+  uint32_t len() const { return at<5>().as_uint32(); }
+  bool has_protocol() const { return at<6>().valid(); }
+  uint32_t protocol() const { return at<6>().as_uint32(); }
 };
 
-class IonAllocBufferStartFtraceEvent : public ::protozero::Message {
+class SmbusWriteFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = IonAllocBufferStartFtraceEvent_Decoder;
+  using Decoder = SmbusWriteFtraceEvent_Decoder;
   enum : int32_t {
-    kClientNameFieldNumber = 1,
-    kFlagsFieldNumber = 2,
-    kHeapNameFieldNumber = 3,
-    kLenFieldNumber = 4,
-    kMaskFieldNumber = 5,
+    kAdapterNrFieldNumber = 1,
+    kAddrFieldNumber = 2,
+    kFlagsFieldNumber = 3,
+    kCommandFieldNumber = 4,
+    kLenFieldNumber = 5,
+    kProtocolFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.IonAllocBufferStartFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.SmbusWriteFtraceEvent"; }
 
 
-  using FieldMetadata_ClientName =
+  using FieldMetadata_AdapterNr =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      IonAllocBufferStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SmbusWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClientName kClientName() { return {}; }
-  void set_client_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ClientName::kFieldId, data, size);
-  }
-  void set_client_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ClientName::kFieldId, chars.data, chars.size);
+  static constexpr FieldMetadata_AdapterNr kAdapterNr{};
+  void set_adapter_nr(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
   }
-  void set_client_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ClientName::kFieldId;
+
+  using FieldMetadata_Addr =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SmbusWriteFtraceEvent>;
+
+  static constexpr FieldMetadata_Addr kAddr{};
+  void set_addr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
   using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      IonAllocBufferStartFtraceEvent>;
+      SmbusWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
+  static constexpr FieldMetadata_Flags kFlags{};
   void set_flags(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -106424,80 +135214,53 @@ class IonAllocBufferStartFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_HeapName =
+  using FieldMetadata_Command =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      IonAllocBufferStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SmbusWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HeapName kHeapName() { return {}; }
-  void set_heap_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_HeapName::kFieldId, data, size);
-  }
-  void set_heap_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size);
-  }
-  void set_heap_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId;
+  static constexpr FieldMetadata_Command kCommand{};
+  void set_command(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Command::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
   using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IonAllocBufferStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SmbusWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint64_t value) {
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Mask =
+  using FieldMetadata_Protocol =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      IonAllocBufferStartFtraceEvent>;
+      SmbusWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mask kMask() { return {}; }
-  void set_mask(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mask::kFieldId;
+  static constexpr FieldMetadata_Protocol kProtocol{};
+  void set_protocol(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Protocol::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -106506,111 +135269,63 @@ class IonAllocBufferStartFtraceEvent : public ::protozero::Message {
   }
 };
 
-class IonAllocBufferFallbackFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class SmbusReadFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  IonAllocBufferFallbackFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IonAllocBufferFallbackFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IonAllocBufferFallbackFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_client_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars client_name() const { return at<1>().as_string(); }
-  bool has_error() const { return at<2>().valid(); }
-  int64_t error() const { return at<2>().as_int64(); }
-  bool has_flags() const { return at<3>().valid(); }
-  uint32_t flags() const { return at<3>().as_uint32(); }
-  bool has_heap_name() const { return at<4>().valid(); }
-  ::protozero::ConstChars heap_name() const { return at<4>().as_string(); }
-  bool has_len() const { return at<5>().valid(); }
-  uint64_t len() const { return at<5>().as_uint64(); }
-  bool has_mask() const { return at<6>().valid(); }
-  uint32_t mask() const { return at<6>().as_uint32(); }
+  SmbusReadFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SmbusReadFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SmbusReadFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_adapter_nr() const { return at<1>().valid(); }
+  int32_t adapter_nr() const { return at<1>().as_int32(); }
+  bool has_flags() const { return at<2>().valid(); }
+  uint32_t flags() const { return at<2>().as_uint32(); }
+  bool has_addr() const { return at<3>().valid(); }
+  uint32_t addr() const { return at<3>().as_uint32(); }
+  bool has_command() const { return at<4>().valid(); }
+  uint32_t command() const { return at<4>().as_uint32(); }
+  bool has_protocol() const { return at<5>().valid(); }
+  uint32_t protocol() const { return at<5>().as_uint32(); }
 };
 
-class IonAllocBufferFallbackFtraceEvent : public ::protozero::Message {
+class SmbusReadFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = IonAllocBufferFallbackFtraceEvent_Decoder;
+  using Decoder = SmbusReadFtraceEvent_Decoder;
   enum : int32_t {
-    kClientNameFieldNumber = 1,
-    kErrorFieldNumber = 2,
-    kFlagsFieldNumber = 3,
-    kHeapNameFieldNumber = 4,
-    kLenFieldNumber = 5,
-    kMaskFieldNumber = 6,
+    kAdapterNrFieldNumber = 1,
+    kFlagsFieldNumber = 2,
+    kAddrFieldNumber = 3,
+    kCommandFieldNumber = 4,
+    kProtocolFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.IonAllocBufferFallbackFtraceEvent"; }
-
-
-  using FieldMetadata_ClientName =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      IonAllocBufferFallbackFtraceEvent>;
+  static constexpr const char* GetName() { return ".perfetto.protos.SmbusReadFtraceEvent"; }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClientName kClientName() { return {}; }
-  void set_client_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ClientName::kFieldId, data, size);
-  }
-  void set_client_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ClientName::kFieldId, chars.data, chars.size);
-  }
-  void set_client_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ClientName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
 
-  using FieldMetadata_Error =
+  using FieldMetadata_AdapterNr =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      IonAllocBufferFallbackFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SmbusReadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Error kError() { return {}; }
-  void set_error(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId;
+  static constexpr FieldMetadata_AdapterNr kAdapterNr{};
+  void set_adapter_nr(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
   using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      IonAllocBufferFallbackFtraceEvent>;
+      SmbusReadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
+  static constexpr FieldMetadata_Flags kFlags{};
   void set_flags(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -106620,80 +135335,53 @@ class IonAllocBufferFallbackFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_HeapName =
+  using FieldMetadata_Addr =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      IonAllocBufferFallbackFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SmbusReadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HeapName kHeapName() { return {}; }
-  void set_heap_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_HeapName::kFieldId, data, size);
-  }
-  void set_heap_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size);
-  }
-  void set_heap_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId;
+  static constexpr FieldMetadata_Addr kAddr{};
+  void set_addr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_Command =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IonAllocBufferFallbackFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SmbusReadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_Command kCommand{};
+  void set_command(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Command::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Mask =
+  using FieldMetadata_Protocol =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      IonAllocBufferFallbackFtraceEvent>;
+      SmbusReadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mask kMask() { return {}; }
-  void set_mask(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mask::kFieldId;
+  static constexpr FieldMetadata_Protocol kProtocol{};
+  void set_protocol(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Protocol::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -106702,113 +135390,86 @@ class IonAllocBufferFallbackFtraceEvent : public ::protozero::Message {
   }
 };
 
-class IonAllocBufferFailFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class I2cReplyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
-  IonAllocBufferFailFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IonAllocBufferFailFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IonAllocBufferFailFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_client_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars client_name() const { return at<1>().as_string(); }
-  bool has_error() const { return at<2>().valid(); }
-  int64_t error() const { return at<2>().as_int64(); }
-  bool has_flags() const { return at<3>().valid(); }
-  uint32_t flags() const { return at<3>().as_uint32(); }
-  bool has_heap_name() const { return at<4>().valid(); }
-  ::protozero::ConstChars heap_name() const { return at<4>().as_string(); }
+  I2cReplyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit I2cReplyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit I2cReplyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_adapter_nr() const { return at<1>().valid(); }
+  int32_t adapter_nr() const { return at<1>().as_int32(); }
+  bool has_msg_nr() const { return at<2>().valid(); }
+  uint32_t msg_nr() const { return at<2>().as_uint32(); }
+  bool has_addr() const { return at<3>().valid(); }
+  uint32_t addr() const { return at<3>().as_uint32(); }
+  bool has_flags() const { return at<4>().valid(); }
+  uint32_t flags() const { return at<4>().as_uint32(); }
   bool has_len() const { return at<5>().valid(); }
-  uint64_t len() const { return at<5>().as_uint64(); }
-  bool has_mask() const { return at<6>().valid(); }
-  uint32_t mask() const { return at<6>().as_uint32(); }
+  uint32_t len() const { return at<5>().as_uint32(); }
+  bool has_buf() const { return at<7>().valid(); }
+  ::protozero::ConstBytes buf() const { return at<7>().as_bytes(); }
 };
 
-class IonAllocBufferFailFtraceEvent : public ::protozero::Message {
+class I2cReplyFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = IonAllocBufferFailFtraceEvent_Decoder;
+  using Decoder = I2cReplyFtraceEvent_Decoder;
   enum : int32_t {
-    kClientNameFieldNumber = 1,
-    kErrorFieldNumber = 2,
-    kFlagsFieldNumber = 3,
-    kHeapNameFieldNumber = 4,
+    kAdapterNrFieldNumber = 1,
+    kMsgNrFieldNumber = 2,
+    kAddrFieldNumber = 3,
+    kFlagsFieldNumber = 4,
     kLenFieldNumber = 5,
-    kMaskFieldNumber = 6,
+    kBufFieldNumber = 7,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.IonAllocBufferFailFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.I2cReplyFtraceEvent"; }
 
 
-  using FieldMetadata_ClientName =
+  using FieldMetadata_AdapterNr =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      IonAllocBufferFailFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      I2cReplyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClientName kClientName() { return {}; }
-  void set_client_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ClientName::kFieldId, data, size);
-  }
-  void set_client_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ClientName::kFieldId, chars.data, chars.size);
-  }
-  void set_client_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ClientName::kFieldId;
+  static constexpr FieldMetadata_AdapterNr kAdapterNr{};
+  void set_adapter_nr(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Error =
+  using FieldMetadata_MsgNr =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      IonAllocBufferFailFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      I2cReplyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Error kError() { return {}; }
-  void set_error(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId;
+  static constexpr FieldMetadata_MsgNr kMsgNr{};
+  void set_msg_nr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MsgNr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_Addr =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      IonAllocBufferFailFtraceEvent>;
+      I2cReplyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_Addr kAddr{};
+  void set_addr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -106816,34 +135477,21 @@ class IonAllocBufferFailFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_HeapName =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      IonAllocBufferFailFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      I2cReplyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HeapName kHeapName() { return {}; }
-  void set_heap_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_HeapName::kFieldId, data, size);
-  }
-  void set_heap_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size);
-  }
-  void set_heap_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
@@ -106851,132 +135499,98 @@ class IonAllocBufferFailFtraceEvent : public ::protozero::Message {
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IonAllocBufferFailFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      I2cReplyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint64_t value) {
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Mask =
+  using FieldMetadata_Buf =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      IonAllocBufferFailFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      I2cReplyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mask kMask() { return {}; }
-  void set_mask(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mask::kFieldId;
+  static constexpr FieldMetadata_Buf kBuf{};
+  void set_buf(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_Buf::kFieldId, data, size);
+  }
+  void set_buf(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_Buf::kFieldId, bytes.data, bytes.size);
+  }
+  void set_buf(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Buf::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
         ::Append(*this, field_id, value);
   }
 };
 
-class IonAllocBufferEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class I2cResultFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  IonAllocBufferEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IonAllocBufferEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IonAllocBufferEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_client_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars client_name() const { return at<1>().as_string(); }
-  bool has_flags() const { return at<2>().valid(); }
-  uint32_t flags() const { return at<2>().as_uint32(); }
-  bool has_heap_name() const { return at<3>().valid(); }
-  ::protozero::ConstChars heap_name() const { return at<3>().as_string(); }
-  bool has_len() const { return at<4>().valid(); }
-  uint64_t len() const { return at<4>().as_uint64(); }
-  bool has_mask() const { return at<5>().valid(); }
-  uint32_t mask() const { return at<5>().as_uint32(); }
+  I2cResultFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit I2cResultFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit I2cResultFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_adapter_nr() const { return at<1>().valid(); }
+  int32_t adapter_nr() const { return at<1>().as_int32(); }
+  bool has_nr_msgs() const { return at<2>().valid(); }
+  uint32_t nr_msgs() const { return at<2>().as_uint32(); }
+  bool has_ret() const { return at<3>().valid(); }
+  int32_t ret() const { return at<3>().as_int32(); }
 };
 
-class IonAllocBufferEndFtraceEvent : public ::protozero::Message {
+class I2cResultFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = IonAllocBufferEndFtraceEvent_Decoder;
+  using Decoder = I2cResultFtraceEvent_Decoder;
   enum : int32_t {
-    kClientNameFieldNumber = 1,
-    kFlagsFieldNumber = 2,
-    kHeapNameFieldNumber = 3,
-    kLenFieldNumber = 4,
-    kMaskFieldNumber = 5,
+    kAdapterNrFieldNumber = 1,
+    kNrMsgsFieldNumber = 2,
+    kRetFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.IonAllocBufferEndFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.I2cResultFtraceEvent"; }
 
 
-  using FieldMetadata_ClientName =
+  using FieldMetadata_AdapterNr =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      IonAllocBufferEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      I2cResultFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClientName kClientName() { return {}; }
-  void set_client_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ClientName::kFieldId, data, size);
-  }
-  void set_client_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ClientName::kFieldId, chars.data, chars.size);
-  }
-  void set_client_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ClientName::kFieldId;
+  static constexpr FieldMetadata_AdapterNr kAdapterNr{};
+  void set_adapter_nr(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_NrMsgs =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      IonAllocBufferEndFtraceEvent>;
+      I2cResultFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_NrMsgs kNrMsgs{};
+  void set_nr_msgs(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NrMsgs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -106984,186 +135598,105 @@ class IonAllocBufferEndFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_HeapName =
+  using FieldMetadata_Ret =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      IonAllocBufferEndFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HeapName kHeapName() { return {}; }
-  void set_heap_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_HeapName::kFieldId, data, size);
-  }
-  void set_heap_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size);
-  }
-  void set_heap_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Len =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IonAllocBufferEndFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Mask =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      IonAllocBufferEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      I2cResultFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mask kMask() { return {}; }
-  void set_mask(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mask::kFieldId;
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class IommuSecPtblMapRangeStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class I2cWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
-  IommuSecPtblMapRangeStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IommuSecPtblMapRangeStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IommuSecPtblMapRangeStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_len() const { return at<1>().valid(); }
-  uint64_t len() const { return at<1>().as_uint64(); }
-  bool has_num() const { return at<2>().valid(); }
-  int32_t num() const { return at<2>().as_int32(); }
-  bool has_pa() const { return at<3>().valid(); }
-  uint32_t pa() const { return at<3>().as_uint32(); }
-  bool has_sec_id() const { return at<4>().valid(); }
-  int32_t sec_id() const { return at<4>().as_int32(); }
-  bool has_va() const { return at<5>().valid(); }
-  uint64_t va() const { return at<5>().as_uint64(); }
+  I2cWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit I2cWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit I2cWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_adapter_nr() const { return at<1>().valid(); }
+  int32_t adapter_nr() const { return at<1>().as_int32(); }
+  bool has_msg_nr() const { return at<2>().valid(); }
+  uint32_t msg_nr() const { return at<2>().as_uint32(); }
+  bool has_addr() const { return at<3>().valid(); }
+  uint32_t addr() const { return at<3>().as_uint32(); }
+  bool has_flags() const { return at<4>().valid(); }
+  uint32_t flags() const { return at<4>().as_uint32(); }
+  bool has_len() const { return at<5>().valid(); }
+  uint32_t len() const { return at<5>().as_uint32(); }
+  bool has_buf() const { return at<7>().valid(); }
+  ::protozero::ConstBytes buf() const { return at<7>().as_bytes(); }
 };
 
-class IommuSecPtblMapRangeStartFtraceEvent : public ::protozero::Message {
+class I2cWriteFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = IommuSecPtblMapRangeStartFtraceEvent_Decoder;
+  using Decoder = I2cWriteFtraceEvent_Decoder;
   enum : int32_t {
-    kLenFieldNumber = 1,
-    kNumFieldNumber = 2,
-    kPaFieldNumber = 3,
-    kSecIdFieldNumber = 4,
-    kVaFieldNumber = 5,
+    kAdapterNrFieldNumber = 1,
+    kMsgNrFieldNumber = 2,
+    kAddrFieldNumber = 3,
+    kFlagsFieldNumber = 4,
+    kLenFieldNumber = 5,
+    kBufFieldNumber = 7,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.IommuSecPtblMapRangeStartFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.I2cWriteFtraceEvent"; }
 
 
-  using FieldMetadata_Len =
+  using FieldMetadata_AdapterNr =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IommuSecPtblMapRangeStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      I2cWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_AdapterNr kAdapterNr{};
+  void set_adapter_nr(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Num =
+  using FieldMetadata_MsgNr =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      IommuSecPtblMapRangeStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      I2cWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Num kNum() { return {}; }
-  void set_num(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Num::kFieldId;
+  static constexpr FieldMetadata_MsgNr kMsgNr{};
+  void set_msg_nr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MsgNr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pa =
+  using FieldMetadata_Addr =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      IommuSecPtblMapRangeStartFtraceEvent>;
+      I2cWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pa kPa() { return {}; }
-  void set_pa(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pa::kFieldId;
+  static constexpr FieldMetadata_Addr kAddr{};
+  void set_addr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -107171,155 +135704,144 @@ class IommuSecPtblMapRangeStartFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SecId =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      IommuSecPtblMapRangeStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      I2cWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SecId kSecId() { return {}; }
-  void set_sec_id(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SecId::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Va =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IommuSecPtblMapRangeStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      I2cWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Va kVa() { return {}; }
-  void set_va(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Va::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Buf =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      I2cWriteFtraceEvent>;
+
+  static constexpr FieldMetadata_Buf kBuf{};
+  void set_buf(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_Buf::kFieldId, data, size);
+  }
+  void set_buf(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_Buf::kFieldId, bytes.data, bytes.size);
+  }
+  void set_buf(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Buf::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
         ::Append(*this, field_id, value);
   }
 };
 
-class IommuSecPtblMapRangeEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class I2cReadFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  IommuSecPtblMapRangeEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IommuSecPtblMapRangeEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IommuSecPtblMapRangeEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_len() const { return at<1>().valid(); }
-  uint64_t len() const { return at<1>().as_uint64(); }
-  bool has_num() const { return at<2>().valid(); }
-  int32_t num() const { return at<2>().as_int32(); }
-  bool has_pa() const { return at<3>().valid(); }
-  uint32_t pa() const { return at<3>().as_uint32(); }
-  bool has_sec_id() const { return at<4>().valid(); }
-  int32_t sec_id() const { return at<4>().as_int32(); }
-  bool has_va() const { return at<5>().valid(); }
-  uint64_t va() const { return at<5>().as_uint64(); }
+  I2cReadFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit I2cReadFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit I2cReadFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_adapter_nr() const { return at<1>().valid(); }
+  int32_t adapter_nr() const { return at<1>().as_int32(); }
+  bool has_msg_nr() const { return at<2>().valid(); }
+  uint32_t msg_nr() const { return at<2>().as_uint32(); }
+  bool has_addr() const { return at<3>().valid(); }
+  uint32_t addr() const { return at<3>().as_uint32(); }
+  bool has_flags() const { return at<4>().valid(); }
+  uint32_t flags() const { return at<4>().as_uint32(); }
+  bool has_len() const { return at<5>().valid(); }
+  uint32_t len() const { return at<5>().as_uint32(); }
 };
 
-class IommuSecPtblMapRangeEndFtraceEvent : public ::protozero::Message {
+class I2cReadFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = IommuSecPtblMapRangeEndFtraceEvent_Decoder;
+  using Decoder = I2cReadFtraceEvent_Decoder;
   enum : int32_t {
-    kLenFieldNumber = 1,
-    kNumFieldNumber = 2,
-    kPaFieldNumber = 3,
-    kSecIdFieldNumber = 4,
-    kVaFieldNumber = 5,
+    kAdapterNrFieldNumber = 1,
+    kMsgNrFieldNumber = 2,
+    kAddrFieldNumber = 3,
+    kFlagsFieldNumber = 4,
+    kLenFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.IommuSecPtblMapRangeEndFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.I2cReadFtraceEvent"; }
 
 
-  using FieldMetadata_Len =
+  using FieldMetadata_AdapterNr =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IommuSecPtblMapRangeEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      I2cReadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_AdapterNr kAdapterNr{};
+  void set_adapter_nr(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Num =
+  using FieldMetadata_MsgNr =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      IommuSecPtblMapRangeEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      I2cReadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Num kNum() { return {}; }
-  void set_num(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Num::kFieldId;
+  static constexpr FieldMetadata_MsgNr kMsgNr{};
+  void set_msg_nr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MsgNr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pa =
+  using FieldMetadata_Addr =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      IommuSecPtblMapRangeEndFtraceEvent>;
+      I2cReadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pa kPa() { return {}; }
-  void set_pa(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pa::kFieldId;
+  static constexpr FieldMetadata_Addr kAddr{};
+  void set_addr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -107327,106 +135849,106 @@ class IommuSecPtblMapRangeEndFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SecId =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      IommuSecPtblMapRangeEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      I2cReadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SecId kSecId() { return {}; }
-  void set_sec_id(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SecId::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Va =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IommuSecPtblMapRangeEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      I2cReadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Va kVa() { return {}; }
-  void set_va(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Va::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class IommuMapRangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/ion.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_ION_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_ION_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class IonStatFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  IommuMapRangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit IommuMapRangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit IommuMapRangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_chunk_size() const { return at<1>().valid(); }
-  uint64_t chunk_size() const { return at<1>().as_uint64(); }
+  IonStatFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IonStatFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IonStatFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_buffer_id() const { return at<1>().valid(); }
+  uint32_t buffer_id() const { return at<1>().as_uint32(); }
   bool has_len() const { return at<2>().valid(); }
-  uint64_t len() const { return at<2>().as_uint64(); }
-  bool has_pa() const { return at<3>().valid(); }
-  uint64_t pa() const { return at<3>().as_uint64(); }
-  bool has_va() const { return at<4>().valid(); }
-  uint64_t va() const { return at<4>().as_uint64(); }
+  int64_t len() const { return at<2>().as_int64(); }
+  bool has_total_allocated() const { return at<3>().valid(); }
+  uint64_t total_allocated() const { return at<3>().as_uint64(); }
 };
 
-class IommuMapRangeFtraceEvent : public ::protozero::Message {
+class IonStatFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = IommuMapRangeFtraceEvent_Decoder;
+  using Decoder = IonStatFtraceEvent_Decoder;
   enum : int32_t {
-    kChunkSizeFieldNumber = 1,
+    kBufferIdFieldNumber = 1,
     kLenFieldNumber = 2,
-    kPaFieldNumber = 3,
-    kVaFieldNumber = 4,
+    kTotalAllocatedFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.IommuMapRangeFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.IonStatFtraceEvent"; }
 
 
-  using FieldMetadata_ChunkSize =
+  using FieldMetadata_BufferId =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IommuMapRangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      IonStatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChunkSize kChunkSize() { return {}; }
-  void set_chunk_size(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ChunkSize::kFieldId;
+  static constexpr FieldMetadata_BufferId kBufferId{};
+  void set_buffer_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BufferId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
@@ -107434,330 +135956,372 @@ class IommuMapRangeFtraceEvent : public ::protozero::Message {
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IommuMapRangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      IonStatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint64_t value) {
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pa =
+  using FieldMetadata_TotalAllocated =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      IommuMapRangeFtraceEvent>;
+      IonStatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pa kPa() { return {}; }
-  void set_pa(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pa::kFieldId;
+  static constexpr FieldMetadata_TotalAllocated kTotalAllocated{};
+  void set_total_allocated(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TotalAllocated::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Va =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      IommuMapRangeFtraceEvent>;
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/ipi.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Va kVa() { return {}; }
-  void set_va(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Va::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-};
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_IPI_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_IPI_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-class DmaAllocContiguousRetryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class IpiRaiseFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  DmaAllocContiguousRetryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit DmaAllocContiguousRetryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit DmaAllocContiguousRetryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_tries() const { return at<1>().valid(); }
-  int32_t tries() const { return at<1>().as_int32(); }
+  IpiRaiseFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IpiRaiseFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IpiRaiseFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_target_cpus() const { return at<1>().valid(); }
+  uint32_t target_cpus() const { return at<1>().as_uint32(); }
+  bool has_reason() const { return at<2>().valid(); }
+  ::protozero::ConstChars reason() const { return at<2>().as_string(); }
 };
 
-class DmaAllocContiguousRetryFtraceEvent : public ::protozero::Message {
+class IpiRaiseFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = DmaAllocContiguousRetryFtraceEvent_Decoder;
+  using Decoder = IpiRaiseFtraceEvent_Decoder;
   enum : int32_t {
-    kTriesFieldNumber = 1,
+    kTargetCpusFieldNumber = 1,
+    kReasonFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.DmaAllocContiguousRetryFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.IpiRaiseFtraceEvent"; }
 
 
-  using FieldMetadata_Tries =
+  using FieldMetadata_TargetCpus =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      DmaAllocContiguousRetryFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      IpiRaiseFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Tries kTries() { return {}; }
-  void set_tries(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Tries::kFieldId;
+  static constexpr FieldMetadata_TargetCpus kTargetCpus{};
+  void set_target_cpus(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TargetCpus::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Reason =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      IpiRaiseFtraceEvent>;
+
+  static constexpr FieldMetadata_Reason kReason{};
+  void set_reason(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Reason::kFieldId, data, size);
+  }
+  void set_reason(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Reason::kFieldId, chars.data, chars.size);
+  }
+  void set_reason(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Reason::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 };
 
-class AllocPagesSysStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class IpiExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  AllocPagesSysStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AllocPagesSysStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AllocPagesSysStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_gfp_flags() const { return at<1>().valid(); }
-  uint32_t gfp_flags() const { return at<1>().as_uint32(); }
-  bool has_order() const { return at<2>().valid(); }
-  uint32_t order() const { return at<2>().as_uint32(); }
+  IpiExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IpiExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IpiExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_reason() const { return at<1>().valid(); }
+  ::protozero::ConstChars reason() const { return at<1>().as_string(); }
 };
 
-class AllocPagesSysStartFtraceEvent : public ::protozero::Message {
+class IpiExitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = AllocPagesSysStartFtraceEvent_Decoder;
+  using Decoder = IpiExitFtraceEvent_Decoder;
   enum : int32_t {
-    kGfpFlagsFieldNumber = 1,
-    kOrderFieldNumber = 2,
+    kReasonFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.AllocPagesSysStartFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.IpiExitFtraceEvent"; }
 
 
-  using FieldMetadata_GfpFlags =
+  using FieldMetadata_Reason =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      AllocPagesSysStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      IpiExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GfpFlags kGfpFlags() { return {}; }
-  void set_gfp_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
+  static constexpr FieldMetadata_Reason kReason{};
+  void set_reason(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Reason::kFieldId, data, size);
+  }
+  void set_reason(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Reason::kFieldId, chars.data, chars.size);
+  }
+  void set_reason(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Reason::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Order =
+class IpiEntryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  IpiEntryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IpiEntryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IpiEntryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_reason() const { return at<1>().valid(); }
+  ::protozero::ConstChars reason() const { return at<1>().as_string(); }
+};
+
+class IpiEntryFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = IpiEntryFtraceEvent_Decoder;
+  enum : int32_t {
+    kReasonFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.IpiEntryFtraceEvent"; }
+
+
+  using FieldMetadata_Reason =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      AllocPagesSysStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      IpiEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Order kOrder() { return {}; }
-  void set_order(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
+  static constexpr FieldMetadata_Reason kReason{};
+  void set_reason(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Reason::kFieldId, data, size);
+  }
+  void set_reason(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Reason::kFieldId, chars.data, chars.size);
+  }
+  void set_reason(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Reason::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 };
 
-class AllocPagesSysFailFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/irq.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_IRQ_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_IRQ_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class IrqHandlerExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  AllocPagesSysFailFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AllocPagesSysFailFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AllocPagesSysFailFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_gfp_flags() const { return at<1>().valid(); }
-  uint32_t gfp_flags() const { return at<1>().as_uint32(); }
-  bool has_order() const { return at<2>().valid(); }
-  uint32_t order() const { return at<2>().as_uint32(); }
+  IrqHandlerExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IrqHandlerExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IrqHandlerExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_irq() const { return at<1>().valid(); }
+  int32_t irq() const { return at<1>().as_int32(); }
+  bool has_ret() const { return at<2>().valid(); }
+  int32_t ret() const { return at<2>().as_int32(); }
 };
 
-class AllocPagesSysFailFtraceEvent : public ::protozero::Message {
+class IrqHandlerExitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = AllocPagesSysFailFtraceEvent_Decoder;
+  using Decoder = IrqHandlerExitFtraceEvent_Decoder;
   enum : int32_t {
-    kGfpFlagsFieldNumber = 1,
-    kOrderFieldNumber = 2,
+    kIrqFieldNumber = 1,
+    kRetFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.AllocPagesSysFailFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.IrqHandlerExitFtraceEvent"; }
 
 
-  using FieldMetadata_GfpFlags =
+  using FieldMetadata_Irq =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      AllocPagesSysFailFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      IrqHandlerExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GfpFlags kGfpFlags() { return {}; }
-  void set_gfp_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
+  static constexpr FieldMetadata_Irq kIrq{};
+  void set_irq(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Irq::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Order =
+  using FieldMetadata_Ret =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      AllocPagesSysFailFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      IrqHandlerExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Order kOrder() { return {}; }
-  void set_order(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class AllocPagesSysEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class IrqHandlerEntryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  AllocPagesSysEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AllocPagesSysEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AllocPagesSysEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_gfp_flags() const { return at<1>().valid(); }
-  uint32_t gfp_flags() const { return at<1>().as_uint32(); }
-  bool has_order() const { return at<2>().valid(); }
-  uint32_t order() const { return at<2>().as_uint32(); }
+  IrqHandlerEntryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IrqHandlerEntryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IrqHandlerEntryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_irq() const { return at<1>().valid(); }
+  int32_t irq() const { return at<1>().as_int32(); }
+  bool has_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars name() const { return at<2>().as_string(); }
+  bool has_handler() const { return at<3>().valid(); }
+  uint32_t handler() const { return at<3>().as_uint32(); }
 };
 
-class AllocPagesSysEndFtraceEvent : public ::protozero::Message {
+class IrqHandlerEntryFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = AllocPagesSysEndFtraceEvent_Decoder;
+  using Decoder = IrqHandlerEntryFtraceEvent_Decoder;
   enum : int32_t {
-    kGfpFlagsFieldNumber = 1,
-    kOrderFieldNumber = 2,
+    kIrqFieldNumber = 1,
+    kNameFieldNumber = 2,
+    kHandlerFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.AllocPagesSysEndFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.IrqHandlerEntryFtraceEvent"; }
 
 
-  using FieldMetadata_GfpFlags =
+  using FieldMetadata_Irq =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      AllocPagesSysEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      IrqHandlerEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GfpFlags kGfpFlags() { return {}; }
-  void set_gfp_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
+  static constexpr FieldMetadata_Irq kIrq{};
+  void set_irq(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Irq::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Order =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      IrqHandlerEntryFtraceEvent>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Handler =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      AllocPagesSysEndFtraceEvent>;
+      IrqHandlerEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Order kOrder() { return {}; }
-  void set_order(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
+  static constexpr FieldMetadata_Handler kHandler{};
+  void set_handler(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Handler::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -107766,70 +136330,35 @@ class AllocPagesSysEndFtraceEvent : public ::protozero::Message {
   }
 };
 
-class AllocPagesIommuStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class SoftirqRaiseFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  AllocPagesIommuStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AllocPagesIommuStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AllocPagesIommuStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_gfp_flags() const { return at<1>().valid(); }
-  uint32_t gfp_flags() const { return at<1>().as_uint32(); }
-  bool has_order() const { return at<2>().valid(); }
-  uint32_t order() const { return at<2>().as_uint32(); }
+  SoftirqRaiseFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SoftirqRaiseFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SoftirqRaiseFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_vec() const { return at<1>().valid(); }
+  uint32_t vec() const { return at<1>().as_uint32(); }
 };
 
-class AllocPagesIommuStartFtraceEvent : public ::protozero::Message {
+class SoftirqRaiseFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = AllocPagesIommuStartFtraceEvent_Decoder;
+  using Decoder = SoftirqRaiseFtraceEvent_Decoder;
   enum : int32_t {
-    kGfpFlagsFieldNumber = 1,
-    kOrderFieldNumber = 2,
+    kVecFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.AllocPagesIommuStartFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.SoftirqRaiseFtraceEvent"; }
 
 
-  using FieldMetadata_GfpFlags =
+  using FieldMetadata_Vec =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      AllocPagesIommuStartFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GfpFlags kGfpFlags() { return {}; }
-  void set_gfp_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Order =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      AllocPagesIommuStartFtraceEvent>;
+      SoftirqRaiseFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Order kOrder() { return {}; }
-  void set_order(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
+  static constexpr FieldMetadata_Vec kVec{};
+  void set_vec(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Vec::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -107838,70 +136367,72 @@ class AllocPagesIommuStartFtraceEvent : public ::protozero::Message {
   }
 };
 
-class AllocPagesIommuFailFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class SoftirqExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  AllocPagesIommuFailFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AllocPagesIommuFailFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AllocPagesIommuFailFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_gfp_flags() const { return at<1>().valid(); }
-  uint32_t gfp_flags() const { return at<1>().as_uint32(); }
-  bool has_order() const { return at<2>().valid(); }
-  uint32_t order() const { return at<2>().as_uint32(); }
+  SoftirqExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SoftirqExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SoftirqExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_vec() const { return at<1>().valid(); }
+  uint32_t vec() const { return at<1>().as_uint32(); }
 };
 
-class AllocPagesIommuFailFtraceEvent : public ::protozero::Message {
+class SoftirqExitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = AllocPagesIommuFailFtraceEvent_Decoder;
+  using Decoder = SoftirqExitFtraceEvent_Decoder;
   enum : int32_t {
-    kGfpFlagsFieldNumber = 1,
-    kOrderFieldNumber = 2,
+    kVecFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.AllocPagesIommuFailFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.SoftirqExitFtraceEvent"; }
 
 
-  using FieldMetadata_GfpFlags =
+  using FieldMetadata_Vec =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      AllocPagesIommuFailFtraceEvent>;
+      SoftirqExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GfpFlags kGfpFlags() { return {}; }
-  void set_gfp_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
+  static constexpr FieldMetadata_Vec kVec{};
+  void set_vec(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Vec::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Order =
+class SoftirqEntryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  SoftirqEntryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SoftirqEntryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SoftirqEntryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_vec() const { return at<1>().valid(); }
+  uint32_t vec() const { return at<1>().as_uint32(); }
+};
+
+class SoftirqEntryFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = SoftirqEntryFtraceEvent_Decoder;
+  enum : int32_t {
+    kVecFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SoftirqEntryFtraceEvent"; }
+
+
+  using FieldMetadata_Vec =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      AllocPagesIommuFailFtraceEvent>;
+      SoftirqEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Order kOrder() { return {}; }
-  void set_order(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
+  static constexpr FieldMetadata_Vec kVec{};
+  void set_vec(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Vec::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -107910,74 +136441,100 @@ class AllocPagesIommuFailFtraceEvent : public ::protozero::Message {
   }
 };
 
-class AllocPagesIommuEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/irq_vectors.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_IRQ_VECTORS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_IRQ_VECTORS_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class LocalTimerExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  AllocPagesIommuEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AllocPagesIommuEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AllocPagesIommuEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_gfp_flags() const { return at<1>().valid(); }
-  uint32_t gfp_flags() const { return at<1>().as_uint32(); }
-  bool has_order() const { return at<2>().valid(); }
-  uint32_t order() const { return at<2>().as_uint32(); }
+  LocalTimerExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit LocalTimerExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit LocalTimerExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_vector() const { return at<1>().valid(); }
+  int32_t vector() const { return at<1>().as_int32(); }
 };
 
-class AllocPagesIommuEndFtraceEvent : public ::protozero::Message {
+class LocalTimerExitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = AllocPagesIommuEndFtraceEvent_Decoder;
+  using Decoder = LocalTimerExitFtraceEvent_Decoder;
   enum : int32_t {
-    kGfpFlagsFieldNumber = 1,
-    kOrderFieldNumber = 2,
+    kVectorFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.AllocPagesIommuEndFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.LocalTimerExitFtraceEvent"; }
 
 
-  using FieldMetadata_GfpFlags =
+  using FieldMetadata_Vector =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      AllocPagesIommuEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LocalTimerExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GfpFlags kGfpFlags() { return {}; }
-  void set_gfp_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
+  static constexpr FieldMetadata_Vector kVector{};
+  void set_vector(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Vector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Order =
+class LocalTimerEntryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  LocalTimerEntryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit LocalTimerEntryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit LocalTimerEntryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_vector() const { return at<1>().valid(); }
+  int32_t vector() const { return at<1>().as_int32(); }
+};
+
+class LocalTimerEntryFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = LocalTimerEntryFtraceEvent_Decoder;
+  enum : int32_t {
+    kVectorFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.LocalTimerEntryFtraceEvent"; }
+
+
+  using FieldMetadata_Vector =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      AllocPagesIommuEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LocalTimerEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Order kOrder() { return {}; }
-  void set_order(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
+  static constexpr FieldMetadata_Vector kVector{};
+  void set_vector(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Vector::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
@@ -107986,11 +136543,11 @@ class AllocPagesIommuEndFtraceEvent : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/kvm.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/kgsl.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_KVM_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_KVM_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_KGSL_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_KGSL_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -108001,53 +136558,88 @@ class AllocPagesIommuEndFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class VgicUpdateIrqPendingFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  VgicUpdateIrqPendingFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit VgicUpdateIrqPendingFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit VgicUpdateIrqPendingFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_irq() const { return at<1>().valid(); }
-  uint32_t irq() const { return at<1>().as_uint32(); }
-  bool has_level() const { return at<2>().valid(); }
-  uint32_t level() const { return at<2>().as_uint32(); }
-  bool has_vcpu_id() const { return at<3>().valid(); }
-  uint64_t vcpu_id() const { return at<3>().as_uint64(); }
-};
-
-class VgicUpdateIrqPendingFtraceEvent : public ::protozero::Message {
+class KgslAdrenoCmdbatchRetiredFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/17> {
  public:
-  using Decoder = VgicUpdateIrqPendingFtraceEvent_Decoder;
+  KgslAdrenoCmdbatchRetiredFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KgslAdrenoCmdbatchRetiredFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KgslAdrenoCmdbatchRetiredFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  uint32_t id() const { return at<1>().as_uint32(); }
+  bool has_timestamp() const { return at<2>().valid(); }
+  uint32_t timestamp() const { return at<2>().as_uint32(); }
+  bool has_inflight() const { return at<3>().valid(); }
+  int64_t inflight() const { return at<3>().as_int64(); }
+  bool has_recovery() const { return at<4>().valid(); }
+  uint32_t recovery() const { return at<4>().as_uint32(); }
+  bool has_flags() const { return at<5>().valid(); }
+  uint32_t flags() const { return at<5>().as_uint32(); }
+  bool has_start() const { return at<6>().valid(); }
+  uint64_t start() const { return at<6>().as_uint64(); }
+  bool has_retire() const { return at<7>().valid(); }
+  uint64_t retire() const { return at<7>().as_uint64(); }
+  bool has_prio() const { return at<8>().valid(); }
+  int32_t prio() const { return at<8>().as_int32(); }
+  bool has_rb_id() const { return at<9>().valid(); }
+  int32_t rb_id() const { return at<9>().as_int32(); }
+  bool has_rptr() const { return at<10>().valid(); }
+  uint32_t rptr() const { return at<10>().as_uint32(); }
+  bool has_wptr() const { return at<11>().valid(); }
+  uint32_t wptr() const { return at<11>().as_uint32(); }
+  bool has_q_inflight() const { return at<12>().valid(); }
+  int32_t q_inflight() const { return at<12>().as_int32(); }
+  bool has_fault_recovery() const { return at<13>().valid(); }
+  uint64_t fault_recovery() const { return at<13>().as_uint64(); }
+  bool has_dispatch_queue() const { return at<14>().valid(); }
+  uint32_t dispatch_queue() const { return at<14>().as_uint32(); }
+  bool has_submitted_to_rb() const { return at<15>().valid(); }
+  uint64_t submitted_to_rb() const { return at<15>().as_uint64(); }
+  bool has_retired_on_gmu() const { return at<16>().valid(); }
+  uint64_t retired_on_gmu() const { return at<16>().as_uint64(); }
+  bool has_active() const { return at<17>().valid(); }
+  uint64_t active() const { return at<17>().as_uint64(); }
+};
+
+class KgslAdrenoCmdbatchRetiredFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KgslAdrenoCmdbatchRetiredFtraceEvent_Decoder;
   enum : int32_t {
-    kIrqFieldNumber = 1,
-    kLevelFieldNumber = 2,
-    kVcpuIdFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.VgicUpdateIrqPendingFtraceEvent"; }
+    kIdFieldNumber = 1,
+    kTimestampFieldNumber = 2,
+    kInflightFieldNumber = 3,
+    kRecoveryFieldNumber = 4,
+    kFlagsFieldNumber = 5,
+    kStartFieldNumber = 6,
+    kRetireFieldNumber = 7,
+    kPrioFieldNumber = 8,
+    kRbIdFieldNumber = 9,
+    kRptrFieldNumber = 10,
+    kWptrFieldNumber = 11,
+    kQInflightFieldNumber = 12,
+    kFaultRecoveryFieldNumber = 13,
+    kDispatchQueueFieldNumber = 14,
+    kSubmittedToRbFieldNumber = 15,
+    kRetiredOnGmuFieldNumber = 16,
+    kActiveFieldNumber = 17,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KgslAdrenoCmdbatchRetiredFtraceEvent"; }
 
 
-  using FieldMetadata_Irq =
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      VgicUpdateIrqPendingFtraceEvent>;
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Irq kIrq() { return {}; }
-  void set_irq(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Irq::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -108055,24 +136647,17 @@ class VgicUpdateIrqPendingFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Level =
+  using FieldMetadata_Timestamp =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      VgicUpdateIrqPendingFtraceEvent>;
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Level kLevel() { return {}; }
-  void set_level(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId;
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -108080,108 +136665,53 @@ class VgicUpdateIrqPendingFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VcpuId =
+  using FieldMetadata_Inflight =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      VgicUpdateIrqPendingFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VcpuId kVcpuId() { return {}; }
-  void set_vcpu_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VcpuId::kFieldId;
+  static constexpr FieldMetadata_Inflight kInflight{};
+  void set_inflight(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Inflight::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
-};
-
-class TrapRegFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TrapRegFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrapRegFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrapRegFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_fn() const { return at<1>().valid(); }
-  ::protozero::ConstChars fn() const { return at<1>().as_string(); }
-  bool has_is_write() const { return at<2>().valid(); }
-  uint32_t is_write() const { return at<2>().as_uint32(); }
-  bool has_reg() const { return at<3>().valid(); }
-  int32_t reg() const { return at<3>().as_int32(); }
-  bool has_write_value() const { return at<4>().valid(); }
-  uint64_t write_value() const { return at<4>().as_uint64(); }
-};
-
-class TrapRegFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = TrapRegFtraceEvent_Decoder;
-  enum : int32_t {
-    kFnFieldNumber = 1,
-    kIsWriteFieldNumber = 2,
-    kRegFieldNumber = 3,
-    kWriteValueFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrapRegFtraceEvent"; }
 
-
-  using FieldMetadata_Fn =
+  using FieldMetadata_Recovery =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TrapRegFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Fn kFn() { return {}; }
-  void set_fn(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Fn::kFieldId, data, size);
-  }
-  void set_fn(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Fn::kFieldId, chars.data, chars.size);
-  }
-  void set_fn(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Fn::kFieldId;
+  static constexpr FieldMetadata_Recovery kRecovery{};
+  void set_recovery(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Recovery::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IsWrite =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      TrapRegFtraceEvent>;
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IsWrite kIsWrite() { return {}; }
-  void set_is_write(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IsWrite::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -108189,196 +136719,107 @@ class TrapRegFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Reg =
+  using FieldMetadata_Start =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TrapRegFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Reg kReg() { return {}; }
-  void set_reg(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Reg::kFieldId;
+  static constexpr FieldMetadata_Start kStart{};
+  void set_start(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_WriteValue =
+  using FieldMetadata_Retire =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TrapRegFtraceEvent>;
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WriteValue kWriteValue() { return {}; }
-  void set_write_value(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_WriteValue::kFieldId;
+  static constexpr FieldMetadata_Retire kRetire{};
+  void set_retire(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Retire::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class KvmWfxArm64FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  KvmWfxArm64FtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmWfxArm64FtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmWfxArm64FtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_is_wfe() const { return at<1>().valid(); }
-  uint32_t is_wfe() const { return at<1>().as_uint32(); }
-  bool has_vcpu_pc() const { return at<2>().valid(); }
-  uint64_t vcpu_pc() const { return at<2>().as_uint64(); }
-};
-
-class KvmWfxArm64FtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = KvmWfxArm64FtraceEvent_Decoder;
-  enum : int32_t {
-    kIsWfeFieldNumber = 1,
-    kVcpuPcFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmWfxArm64FtraceEvent"; }
-
 
-  using FieldMetadata_IsWfe =
+  using FieldMetadata_Prio =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      KvmWfxArm64FtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IsWfe kIsWfe() { return {}; }
-  void set_is_wfe(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IsWfe::kFieldId;
+  static constexpr FieldMetadata_Prio kPrio{};
+  void set_prio(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VcpuPc =
+  using FieldMetadata_RbId =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      KvmWfxArm64FtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VcpuPc kVcpuPc() { return {}; }
-  void set_vcpu_pc(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId;
+  static constexpr FieldMetadata_RbId kRbId{};
+  void set_rb_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RbId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-class KvmVcpuWakeupFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  KvmVcpuWakeupFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmVcpuWakeupFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmVcpuWakeupFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_ns() const { return at<1>().valid(); }
-  uint64_t ns() const { return at<1>().as_uint64(); }
-  bool has_valid() const { return at<2>().valid(); }
-  uint32_t valid() const { return at<2>().as_uint32(); }
-  bool has_waited() const { return at<3>().valid(); }
-  uint32_t waited() const { return at<3>().as_uint32(); }
-};
-
-class KvmVcpuWakeupFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = KvmVcpuWakeupFtraceEvent_Decoder;
-  enum : int32_t {
-    kNsFieldNumber = 1,
-    kValidFieldNumber = 2,
-    kWaitedFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmVcpuWakeupFtraceEvent"; }
 
-
-  using FieldMetadata_Ns =
+  using FieldMetadata_Rptr =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      KvmVcpuWakeupFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ns kNs() { return {}; }
-  void set_ns(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ns::kFieldId;
+  static constexpr FieldMetadata_Rptr kRptr{};
+  void set_rptr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Rptr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Valid =
+  using FieldMetadata_Wptr =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      KvmVcpuWakeupFtraceEvent>;
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Valid kValid() { return {}; }
-  void set_valid(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Valid::kFieldId;
+  static constexpr FieldMetadata_Wptr kWptr{};
+  void set_wptr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Wptr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -108386,115 +136827,89 @@ class KvmVcpuWakeupFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Waited =
+  using FieldMetadata_QInflight =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      12,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      KvmVcpuWakeupFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Waited kWaited() { return {}; }
-  void set_waited(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Waited::kFieldId;
+  static constexpr FieldMetadata_QInflight kQInflight{};
+  void set_q_inflight(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_QInflight::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
 
-class KvmUserspaceExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  KvmUserspaceExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmUserspaceExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmUserspaceExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_reason() const { return at<1>().valid(); }
-  uint32_t reason() const { return at<1>().as_uint32(); }
-};
-
-class KvmUserspaceExitFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = KvmUserspaceExitFtraceEvent_Decoder;
-  enum : int32_t {
-    kReasonFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmUserspaceExitFtraceEvent"; }
+  using FieldMetadata_FaultRecovery =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
 
+  static constexpr FieldMetadata_FaultRecovery kFaultRecovery{};
+  void set_fault_recovery(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FaultRecovery::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Reason =
+  using FieldMetadata_DispatchQueue =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      14,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      KvmUserspaceExitFtraceEvent>;
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Reason kReason() { return {}; }
-  void set_reason(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Reason::kFieldId;
+  static constexpr FieldMetadata_DispatchQueue kDispatchQueue{};
+  void set_dispatch_queue(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DispatchQueue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class KvmUnmapHvaRangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  KvmUnmapHvaRangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmUnmapHvaRangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmUnmapHvaRangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_end() const { return at<1>().valid(); }
-  uint64_t end() const { return at<1>().as_uint64(); }
-  bool has_start() const { return at<2>().valid(); }
-  uint64_t start() const { return at<2>().as_uint64(); }
-};
 
-class KvmUnmapHvaRangeFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = KvmUnmapHvaRangeFtraceEvent_Decoder;
-  enum : int32_t {
-    kEndFieldNumber = 1,
-    kStartFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmUnmapHvaRangeFtraceEvent"; }
+  using FieldMetadata_SubmittedToRb =
+    ::protozero::proto_utils::FieldMetadata<
+      15,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
 
+  static constexpr FieldMetadata_SubmittedToRb kSubmittedToRb{};
+  void set_submitted_to_rb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SubmittedToRb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_End =
+  using FieldMetadata_RetiredOnGmu =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      16,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KvmUnmapHvaRangeFtraceEvent>;
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_End kEnd() { return {}; }
-  void set_end(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_End::kFieldId;
+  static constexpr FieldMetadata_RetiredOnGmu kRetiredOnGmu{};
+  void set_retired_on_gmu(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RetiredOnGmu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -108502,24 +136917,17 @@ class KvmUnmapHvaRangeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Start =
+  using FieldMetadata_Active =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      17,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KvmUnmapHvaRangeFtraceEvent>;
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Start kStart() { return {}; }
-  void set_start(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
+  static constexpr FieldMetadata_Active kActive{};
+  void set_active(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Active::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -108528,48 +136936,44 @@ class KvmUnmapHvaRangeFtraceEvent : public ::protozero::Message {
   }
 };
 
-class KvmToggleCacheFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class KgslAdrenoCmdbatchSyncFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  KvmToggleCacheFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmToggleCacheFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmToggleCacheFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_now() const { return at<1>().valid(); }
-  uint32_t now() const { return at<1>().as_uint32(); }
-  bool has_vcpu_pc() const { return at<2>().valid(); }
-  uint64_t vcpu_pc() const { return at<2>().as_uint64(); }
-  bool has_was() const { return at<3>().valid(); }
-  uint32_t was() const { return at<3>().as_uint32(); }
+  KgslAdrenoCmdbatchSyncFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KgslAdrenoCmdbatchSyncFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KgslAdrenoCmdbatchSyncFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  uint32_t id() const { return at<1>().as_uint32(); }
+  bool has_timestamp() const { return at<2>().valid(); }
+  uint32_t timestamp() const { return at<2>().as_uint32(); }
+  bool has_ticks() const { return at<3>().valid(); }
+  uint64_t ticks() const { return at<3>().as_uint64(); }
+  bool has_prio() const { return at<4>().valid(); }
+  int32_t prio() const { return at<4>().as_int32(); }
 };
 
-class KvmToggleCacheFtraceEvent : public ::protozero::Message {
+class KgslAdrenoCmdbatchSyncFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KvmToggleCacheFtraceEvent_Decoder;
+  using Decoder = KgslAdrenoCmdbatchSyncFtraceEvent_Decoder;
   enum : int32_t {
-    kNowFieldNumber = 1,
-    kVcpuPcFieldNumber = 2,
-    kWasFieldNumber = 3,
+    kIdFieldNumber = 1,
+    kTimestampFieldNumber = 2,
+    kTicksFieldNumber = 3,
+    kPrioFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmToggleCacheFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.KgslAdrenoCmdbatchSyncFtraceEvent"; }
 
 
-  using FieldMetadata_Now =
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      KvmToggleCacheFtraceEvent>;
+      KgslAdrenoCmdbatchSyncFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Now kNow() { return {}; }
-  void set_now(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Now::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -108577,24 +136981,35 @@ class KvmToggleCacheFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VcpuPc =
+  using FieldMetadata_Timestamp =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchSyncFtraceEvent>;
+
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ticks =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KvmToggleCacheFtraceEvent>;
+      KgslAdrenoCmdbatchSyncFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VcpuPc kVcpuPc() { return {}; }
-  void set_vcpu_pc(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId;
+  static constexpr FieldMetadata_Ticks kTicks{};
+  void set_ticks(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ticks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -108602,74 +137017,90 @@ class KvmToggleCacheFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Was =
+  using FieldMetadata_Prio =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      KvmToggleCacheFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KgslAdrenoCmdbatchSyncFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Was kWas() { return {}; }
-  void set_was(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Was::kFieldId;
+  static constexpr FieldMetadata_Prio kPrio{};
+  void set_prio(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class KvmTimerUpdateIrqFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  KvmTimerUpdateIrqFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmTimerUpdateIrqFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmTimerUpdateIrqFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_irq() const { return at<1>().valid(); }
-  uint32_t irq() const { return at<1>().as_uint32(); }
-  bool has_level() const { return at<2>().valid(); }
-  int32_t level() const { return at<2>().as_int32(); }
-  bool has_vcpu_id() const { return at<3>().valid(); }
-  uint64_t vcpu_id() const { return at<3>().as_uint64(); }
-};
-
-class KvmTimerUpdateIrqFtraceEvent : public ::protozero::Message {
+class KgslAdrenoCmdbatchSubmittedFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/13> {
  public:
-  using Decoder = KvmTimerUpdateIrqFtraceEvent_Decoder;
+  KgslAdrenoCmdbatchSubmittedFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KgslAdrenoCmdbatchSubmittedFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KgslAdrenoCmdbatchSubmittedFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  uint32_t id() const { return at<1>().as_uint32(); }
+  bool has_timestamp() const { return at<2>().valid(); }
+  uint32_t timestamp() const { return at<2>().as_uint32(); }
+  bool has_inflight() const { return at<3>().valid(); }
+  int64_t inflight() const { return at<3>().as_int64(); }
+  bool has_flags() const { return at<4>().valid(); }
+  uint32_t flags() const { return at<4>().as_uint32(); }
+  bool has_ticks() const { return at<5>().valid(); }
+  uint64_t ticks() const { return at<5>().as_uint64(); }
+  bool has_secs() const { return at<6>().valid(); }
+  uint64_t secs() const { return at<6>().as_uint64(); }
+  bool has_usecs() const { return at<7>().valid(); }
+  uint64_t usecs() const { return at<7>().as_uint64(); }
+  bool has_prio() const { return at<8>().valid(); }
+  int32_t prio() const { return at<8>().as_int32(); }
+  bool has_rb_id() const { return at<9>().valid(); }
+  int32_t rb_id() const { return at<9>().as_int32(); }
+  bool has_rptr() const { return at<10>().valid(); }
+  uint32_t rptr() const { return at<10>().as_uint32(); }
+  bool has_wptr() const { return at<11>().valid(); }
+  uint32_t wptr() const { return at<11>().as_uint32(); }
+  bool has_q_inflight() const { return at<12>().valid(); }
+  int32_t q_inflight() const { return at<12>().as_int32(); }
+  bool has_dispatch_queue() const { return at<13>().valid(); }
+  int32_t dispatch_queue() const { return at<13>().as_int32(); }
+};
+
+class KgslAdrenoCmdbatchSubmittedFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KgslAdrenoCmdbatchSubmittedFtraceEvent_Decoder;
   enum : int32_t {
-    kIrqFieldNumber = 1,
-    kLevelFieldNumber = 2,
-    kVcpuIdFieldNumber = 3,
+    kIdFieldNumber = 1,
+    kTimestampFieldNumber = 2,
+    kInflightFieldNumber = 3,
+    kFlagsFieldNumber = 4,
+    kTicksFieldNumber = 5,
+    kSecsFieldNumber = 6,
+    kUsecsFieldNumber = 7,
+    kPrioFieldNumber = 8,
+    kRbIdFieldNumber = 9,
+    kRptrFieldNumber = 10,
+    kWptrFieldNumber = 11,
+    kQInflightFieldNumber = 12,
+    kDispatchQueueFieldNumber = 13,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmTimerUpdateIrqFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.KgslAdrenoCmdbatchSubmittedFtraceEvent"; }
 
 
-  using FieldMetadata_Irq =
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      KvmTimerUpdateIrqFtraceEvent>;
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Irq kIrq() { return {}; }
-  void set_irq(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Irq::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -108677,124 +137108,71 @@ class KvmTimerUpdateIrqFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Level =
+  using FieldMetadata_Timestamp =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      KvmTimerUpdateIrqFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Level kLevel() { return {}; }
-  void set_level(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId;
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VcpuId =
+  using FieldMetadata_Inflight =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      KvmTimerUpdateIrqFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VcpuId kVcpuId() { return {}; }
-  void set_vcpu_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VcpuId::kFieldId;
+  static constexpr FieldMetadata_Inflight kInflight{};
+  void set_inflight(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Inflight::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
-};
-
-class KvmTimerSaveStateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  KvmTimerSaveStateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmTimerSaveStateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmTimerSaveStateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_ctl() const { return at<1>().valid(); }
-  uint64_t ctl() const { return at<1>().as_uint64(); }
-  bool has_cval() const { return at<2>().valid(); }
-  uint64_t cval() const { return at<2>().as_uint64(); }
-  bool has_timer_idx() const { return at<3>().valid(); }
-  int32_t timer_idx() const { return at<3>().as_int32(); }
-};
 
-class KvmTimerSaveStateFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = KvmTimerSaveStateFtraceEvent_Decoder;
-  enum : int32_t {
-    kCtlFieldNumber = 1,
-    kCvalFieldNumber = 2,
-    kTimerIdxFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmTimerSaveStateFtraceEvent"; }
-
-
-  using FieldMetadata_Ctl =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      KvmTimerSaveStateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ctl kCtl() { return {}; }
-  void set_ctl(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ctl::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Cval =
+  using FieldMetadata_Ticks =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KvmTimerSaveStateFtraceEvent>;
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cval kCval() { return {}; }
-  void set_cval(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Cval::kFieldId;
+  static constexpr FieldMetadata_Ticks kTicks{};
+  void set_ticks(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ticks::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -108802,74 +137180,35 @@ class KvmTimerSaveStateFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimerIdx =
+  using FieldMetadata_Secs =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      KvmTimerSaveStateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimerIdx kTimerIdx() { return {}; }
-  void set_timer_idx(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimerIdx::kFieldId;
+  static constexpr FieldMetadata_Secs kSecs{};
+  void set_secs(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Secs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class KvmTimerRestoreStateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  KvmTimerRestoreStateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmTimerRestoreStateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmTimerRestoreStateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_ctl() const { return at<1>().valid(); }
-  uint64_t ctl() const { return at<1>().as_uint64(); }
-  bool has_cval() const { return at<2>().valid(); }
-  uint64_t cval() const { return at<2>().as_uint64(); }
-  bool has_timer_idx() const { return at<3>().valid(); }
-  int32_t timer_idx() const { return at<3>().as_int32(); }
-};
-
-class KvmTimerRestoreStateFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = KvmTimerRestoreStateFtraceEvent_Decoder;
-  enum : int32_t {
-    kCtlFieldNumber = 1,
-    kCvalFieldNumber = 2,
-    kTimerIdxFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmTimerRestoreStateFtraceEvent"; }
-
 
-  using FieldMetadata_Ctl =
+  using FieldMetadata_Usecs =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KvmTimerRestoreStateFtraceEvent>;
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ctl kCtl() { return {}; }
-  void set_ctl(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ctl::kFieldId;
+  static constexpr FieldMetadata_Usecs kUsecs{};
+  void set_usecs(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Usecs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -108877,140 +137216,71 @@ class KvmTimerRestoreStateFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Cval =
+  using FieldMetadata_Prio =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      KvmTimerRestoreStateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cval kCval() { return {}; }
-  void set_cval(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Cval::kFieldId;
+  static constexpr FieldMetadata_Prio kPrio{};
+  void set_prio(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimerIdx =
+  using FieldMetadata_RbId =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      KvmTimerRestoreStateFtraceEvent>;
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimerIdx kTimerIdx() { return {}; }
-  void set_timer_idx(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimerIdx::kFieldId;
+  static constexpr FieldMetadata_RbId kRbId{};
+  void set_rb_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RbId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
 
-class KvmTimerHrtimerExpireFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  KvmTimerHrtimerExpireFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmTimerHrtimerExpireFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmTimerHrtimerExpireFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_timer_idx() const { return at<1>().valid(); }
-  int32_t timer_idx() const { return at<1>().as_int32(); }
-};
-
-class KvmTimerHrtimerExpireFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = KvmTimerHrtimerExpireFtraceEvent_Decoder;
-  enum : int32_t {
-    kTimerIdxFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmTimerHrtimerExpireFtraceEvent"; }
-
-
-  using FieldMetadata_TimerIdx =
+  using FieldMetadata_Rptr =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      KvmTimerHrtimerExpireFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimerIdx kTimerIdx() { return {}; }
-  void set_timer_idx(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimerIdx::kFieldId;
+  static constexpr FieldMetadata_Rptr kRptr{};
+  void set_rptr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Rptr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class KvmTimerEmulateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  KvmTimerEmulateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmTimerEmulateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmTimerEmulateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_should_fire() const { return at<1>().valid(); }
-  uint32_t should_fire() const { return at<1>().as_uint32(); }
-  bool has_timer_idx() const { return at<2>().valid(); }
-  int32_t timer_idx() const { return at<2>().as_int32(); }
-};
-
-class KvmTimerEmulateFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = KvmTimerEmulateFtraceEvent_Decoder;
-  enum : int32_t {
-    kShouldFireFieldNumber = 1,
-    kTimerIdxFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmTimerEmulateFtraceEvent"; }
-
 
-  using FieldMetadata_ShouldFire =
+  using FieldMetadata_Wptr =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      KvmTimerEmulateFtraceEvent>;
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ShouldFire kShouldFire() { return {}; }
-  void set_should_fire(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ShouldFire::kFieldId;
+  static constexpr FieldMetadata_Wptr kWptr{};
+  void set_wptr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Wptr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -109018,133 +137288,84 @@ class KvmTimerEmulateFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimerIdx =
+  using FieldMetadata_QInflight =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      12,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      KvmTimerEmulateFtraceEvent>;
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimerIdx kTimerIdx() { return {}; }
-  void set_timer_idx(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimerIdx::kFieldId;
+  static constexpr FieldMetadata_QInflight kQInflight{};
+  void set_q_inflight(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_QInflight::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-class KvmTestAgeHvaFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  KvmTestAgeHvaFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmTestAgeHvaFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmTestAgeHvaFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_hva() const { return at<1>().valid(); }
-  uint64_t hva() const { return at<1>().as_uint64(); }
-};
-
-class KvmTestAgeHvaFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = KvmTestAgeHvaFtraceEvent_Decoder;
-  enum : int32_t {
-    kHvaFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmTestAgeHvaFtraceEvent"; }
-
 
-  using FieldMetadata_Hva =
+  using FieldMetadata_DispatchQueue =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      13,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      KvmTestAgeHvaFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Hva kHva() { return {}; }
-  void set_hva(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Hva::kFieldId;
+  static constexpr FieldMetadata_DispatchQueue kDispatchQueue{};
+  void set_dispatch_queue(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DispatchQueue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class KvmSysAccessFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class KgslAdrenoCmdbatchQueuedFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  KvmSysAccessFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmSysAccessFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmSysAccessFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_crm() const { return at<1>().valid(); }
-  uint32_t crm() const { return at<1>().as_uint32(); }
-  bool has_crn() const { return at<2>().valid(); }
-  uint32_t crn() const { return at<2>().as_uint32(); }
-  bool has_op0() const { return at<3>().valid(); }
-  uint32_t op0() const { return at<3>().as_uint32(); }
-  bool has_op1() const { return at<4>().valid(); }
-  uint32_t op1() const { return at<4>().as_uint32(); }
-  bool has_op2() const { return at<5>().valid(); }
-  uint32_t op2() const { return at<5>().as_uint32(); }
-  bool has_is_write() const { return at<6>().valid(); }
-  uint32_t is_write() const { return at<6>().as_uint32(); }
-  bool has_name() const { return at<7>().valid(); }
-  ::protozero::ConstChars name() const { return at<7>().as_string(); }
-  bool has_vcpu_pc() const { return at<8>().valid(); }
-  uint64_t vcpu_pc() const { return at<8>().as_uint64(); }
+  KgslAdrenoCmdbatchQueuedFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KgslAdrenoCmdbatchQueuedFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KgslAdrenoCmdbatchQueuedFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  uint32_t id() const { return at<1>().as_uint32(); }
+  bool has_timestamp() const { return at<2>().valid(); }
+  uint32_t timestamp() const { return at<2>().as_uint32(); }
+  bool has_queued() const { return at<3>().valid(); }
+  uint32_t queued() const { return at<3>().as_uint32(); }
+  bool has_flags() const { return at<4>().valid(); }
+  uint32_t flags() const { return at<4>().as_uint32(); }
+  bool has_prio() const { return at<5>().valid(); }
+  uint32_t prio() const { return at<5>().as_uint32(); }
 };
 
-class KvmSysAccessFtraceEvent : public ::protozero::Message {
+class KgslAdrenoCmdbatchQueuedFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KvmSysAccessFtraceEvent_Decoder;
+  using Decoder = KgslAdrenoCmdbatchQueuedFtraceEvent_Decoder;
   enum : int32_t {
-    kCRmFieldNumber = 1,
-    kCRnFieldNumber = 2,
-    kOp0FieldNumber = 3,
-    kOp1FieldNumber = 4,
-    kOp2FieldNumber = 5,
-    kIsWriteFieldNumber = 6,
-    kNameFieldNumber = 7,
-    kVcpuPcFieldNumber = 8,
+    kIdFieldNumber = 1,
+    kTimestampFieldNumber = 2,
+    kQueuedFieldNumber = 3,
+    kFlagsFieldNumber = 4,
+    kPrioFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmSysAccessFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.KgslAdrenoCmdbatchQueuedFtraceEvent"; }
 
 
-  using FieldMetadata_CRm =
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      KvmSysAccessFtraceEvent>;
+      KgslAdrenoCmdbatchQueuedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CRm kCRm() { return {}; }
-  void set_crm(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CRm::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -109152,24 +137373,17 @@ class KvmSysAccessFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CRn =
+  using FieldMetadata_Timestamp =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      KvmSysAccessFtraceEvent>;
+      KgslAdrenoCmdbatchQueuedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CRn kCRn() { return {}; }
-  void set_crn(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CRn::kFieldId;
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -109177,24 +137391,17 @@ class KvmSysAccessFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Op0 =
+  using FieldMetadata_Queued =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      KvmSysAccessFtraceEvent>;
+      KgslAdrenoCmdbatchQueuedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Op0 kOp0() { return {}; }
-  void set_op0(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Op0::kFieldId;
+  static constexpr FieldMetadata_Queued kQueued{};
+  void set_queued(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Queued::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -109202,24 +137409,17 @@ class KvmSysAccessFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Op1 =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      KvmSysAccessFtraceEvent>;
+      KgslAdrenoCmdbatchQueuedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Op1 kOp1() { return {}; }
-  void set_op1(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Op1::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -109227,49 +137427,57 @@ class KvmSysAccessFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Op2 =
+  using FieldMetadata_Prio =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      KvmSysAccessFtraceEvent>;
+      KgslAdrenoCmdbatchQueuedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Op2 kOp2() { return {}; }
-  void set_op2(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Op2::kFieldId;
+  static constexpr FieldMetadata_Prio kPrio{};
+  void set_prio(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_IsWrite =
+class KgslGpuFrequencyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  KgslGpuFrequencyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KgslGpuFrequencyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KgslGpuFrequencyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_gpu_freq() const { return at<1>().valid(); }
+  uint32_t gpu_freq() const { return at<1>().as_uint32(); }
+  bool has_gpu_id() const { return at<2>().valid(); }
+  uint32_t gpu_id() const { return at<2>().as_uint32(); }
+};
+
+class KgslGpuFrequencyFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KgslGpuFrequencyFtraceEvent_Decoder;
+  enum : int32_t {
+    kGpuFreqFieldNumber = 1,
+    kGpuIdFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KgslGpuFrequencyFtraceEvent"; }
+
+
+  using FieldMetadata_GpuFreq =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      KvmSysAccessFtraceEvent>;
+      KgslGpuFrequencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IsWrite kIsWrite() { return {}; }
-  void set_is_write(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IsWrite::kFieldId;
+  static constexpr FieldMetadata_GpuFreq kGpuFreq{};
+  void set_gpu_freq(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GpuFreq::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -109277,55 +137485,120 @@ class KvmSysAccessFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Name =
+  using FieldMetadata_GpuId =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      KvmSysAccessFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslGpuFrequencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  static constexpr FieldMetadata_GpuId kGpuId{};
+  void set_gpu_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GpuId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/kmem.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_KMEM_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_KMEM_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class DmabufRssStatFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  DmabufRssStatFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DmabufRssStatFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DmabufRssStatFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_rss() const { return at<1>().valid(); }
+  uint64_t rss() const { return at<1>().as_uint64(); }
+  bool has_rss_delta() const { return at<2>().valid(); }
+  int64_t rss_delta() const { return at<2>().as_int64(); }
+  bool has_i_ino() const { return at<3>().valid(); }
+  uint64_t i_ino() const { return at<3>().as_uint64(); }
+};
+
+class DmabufRssStatFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = DmabufRssStatFtraceEvent_Decoder;
+  enum : int32_t {
+    kRssFieldNumber = 1,
+    kRssDeltaFieldNumber = 2,
+    kIInoFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.DmabufRssStatFtraceEvent"; }
+
+
+  using FieldMetadata_Rss =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      DmabufRssStatFtraceEvent>;
+
+  static constexpr FieldMetadata_Rss kRss{};
+  void set_rss(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Rss::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+
+  using FieldMetadata_RssDelta =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      DmabufRssStatFtraceEvent>;
+
+  static constexpr FieldMetadata_RssDelta kRssDelta{};
+  void set_rss_delta(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RssDelta::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VcpuPc =
+  using FieldMetadata_IIno =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KvmSysAccessFtraceEvent>;
+      DmabufRssStatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VcpuPc kVcpuPc() { return {}; }
-  void set_vcpu_pc(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId;
+  static constexpr FieldMetadata_IIno kIIno{};
+  void set_i_ino(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IIno::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -109334,114 +137607,198 @@ class KvmSysAccessFtraceEvent : public ::protozero::Message {
   }
 };
 
-class KvmSetWayFlushFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmAllocContigMigrateRangeInfoFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  KvmSetWayFlushFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmSetWayFlushFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmSetWayFlushFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_cache() const { return at<1>().valid(); }
-  uint32_t cache() const { return at<1>().as_uint32(); }
-  bool has_vcpu_pc() const { return at<2>().valid(); }
-  uint64_t vcpu_pc() const { return at<2>().as_uint64(); }
+  MmAllocContigMigrateRangeInfoFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MmAllocContigMigrateRangeInfoFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MmAllocContigMigrateRangeInfoFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_start() const { return at<1>().valid(); }
+  uint64_t start() const { return at<1>().as_uint64(); }
+  bool has_end() const { return at<2>().valid(); }
+  uint64_t end() const { return at<2>().as_uint64(); }
+  bool has_nr_migrated() const { return at<3>().valid(); }
+  uint64_t nr_migrated() const { return at<3>().as_uint64(); }
+  bool has_nr_reclaimed() const { return at<4>().valid(); }
+  uint64_t nr_reclaimed() const { return at<4>().as_uint64(); }
+  bool has_nr_mapped() const { return at<5>().valid(); }
+  uint64_t nr_mapped() const { return at<5>().as_uint64(); }
+  bool has_migratetype() const { return at<6>().valid(); }
+  int32_t migratetype() const { return at<6>().as_int32(); }
 };
 
-class KvmSetWayFlushFtraceEvent : public ::protozero::Message {
+class MmAllocContigMigrateRangeInfoFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KvmSetWayFlushFtraceEvent_Decoder;
+  using Decoder = MmAllocContigMigrateRangeInfoFtraceEvent_Decoder;
   enum : int32_t {
-    kCacheFieldNumber = 1,
-    kVcpuPcFieldNumber = 2,
+    kStartFieldNumber = 1,
+    kEndFieldNumber = 2,
+    kNrMigratedFieldNumber = 3,
+    kNrReclaimedFieldNumber = 4,
+    kNrMappedFieldNumber = 5,
+    kMigratetypeFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmSetWayFlushFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MmAllocContigMigrateRangeInfoFtraceEvent"; }
 
 
-  using FieldMetadata_Cache =
+  using FieldMetadata_Start =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      KvmSetWayFlushFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmAllocContigMigrateRangeInfoFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cache kCache() { return {}; }
-  void set_cache(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Cache::kFieldId;
+  static constexpr FieldMetadata_Start kStart{};
+  void set_start(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VcpuPc =
+  using FieldMetadata_End =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KvmSetWayFlushFtraceEvent>;
+      MmAllocContigMigrateRangeInfoFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VcpuPc kVcpuPc() { return {}; }
-  void set_vcpu_pc(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId;
+  static constexpr FieldMetadata_End kEnd{};
+  void set_end(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_End::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NrMigrated =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmAllocContigMigrateRangeInfoFtraceEvent>;
+
+  static constexpr FieldMetadata_NrMigrated kNrMigrated{};
+  void set_nr_migrated(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NrMigrated::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NrReclaimed =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmAllocContigMigrateRangeInfoFtraceEvent>;
+
+  static constexpr FieldMetadata_NrReclaimed kNrReclaimed{};
+  void set_nr_reclaimed(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NrReclaimed::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NrMapped =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmAllocContigMigrateRangeInfoFtraceEvent>;
+
+  static constexpr FieldMetadata_NrMapped kNrMapped{};
+  void set_nr_mapped(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NrMapped::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_Migratetype =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MmAllocContigMigrateRangeInfoFtraceEvent>;
+
+  static constexpr FieldMetadata_Migratetype kMigratetype{};
+  void set_migratetype(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Migratetype::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class KvmSetSpteHvaFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class IonBufferDestroyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  KvmSetSpteHvaFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmSetSpteHvaFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmSetSpteHvaFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_hva() const { return at<1>().valid(); }
-  uint64_t hva() const { return at<1>().as_uint64(); }
+  IonBufferDestroyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IonBufferDestroyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IonBufferDestroyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_addr() const { return at<1>().valid(); }
+  uint64_t addr() const { return at<1>().as_uint64(); }
+  bool has_len() const { return at<2>().valid(); }
+  uint64_t len() const { return at<2>().as_uint64(); }
 };
 
-class KvmSetSpteHvaFtraceEvent : public ::protozero::Message {
+class IonBufferDestroyFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KvmSetSpteHvaFtraceEvent_Decoder;
+  using Decoder = IonBufferDestroyFtraceEvent_Decoder;
   enum : int32_t {
-    kHvaFieldNumber = 1,
+    kAddrFieldNumber = 1,
+    kLenFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmSetSpteHvaFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.IonBufferDestroyFtraceEvent"; }
+
+
+  using FieldMetadata_Addr =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IonBufferDestroyFtraceEvent>;
 
+  static constexpr FieldMetadata_Addr kAddr{};
+  void set_addr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Hva =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KvmSetSpteHvaFtraceEvent>;
+      IonBufferDestroyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Hva kHva() { return {}; }
-  void set_hva(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Hva::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -109450,245 +137807,208 @@ class KvmSetSpteHvaFtraceEvent : public ::protozero::Message {
   }
 };
 
-class KvmSetIrqFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class IonBufferCreateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  KvmSetIrqFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmSetIrqFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmSetIrqFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_gsi() const { return at<1>().valid(); }
-  uint32_t gsi() const { return at<1>().as_uint32(); }
-  bool has_irq_source_id() const { return at<2>().valid(); }
-  int32_t irq_source_id() const { return at<2>().as_int32(); }
-  bool has_level() const { return at<3>().valid(); }
-  int32_t level() const { return at<3>().as_int32(); }
+  IonBufferCreateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IonBufferCreateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IonBufferCreateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_addr() const { return at<1>().valid(); }
+  uint64_t addr() const { return at<1>().as_uint64(); }
+  bool has_len() const { return at<2>().valid(); }
+  uint64_t len() const { return at<2>().as_uint64(); }
 };
 
-class KvmSetIrqFtraceEvent : public ::protozero::Message {
+class IonBufferCreateFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KvmSetIrqFtraceEvent_Decoder;
+  using Decoder = IonBufferCreateFtraceEvent_Decoder;
   enum : int32_t {
-    kGsiFieldNumber = 1,
-    kIrqSourceIdFieldNumber = 2,
-    kLevelFieldNumber = 3,
+    kAddrFieldNumber = 1,
+    kLenFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmSetIrqFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.IonBufferCreateFtraceEvent"; }
 
 
-  using FieldMetadata_Gsi =
+  using FieldMetadata_Addr =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      KvmSetIrqFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IonBufferCreateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Gsi kGsi() { return {}; }
-  void set_gsi(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Gsi::kFieldId;
+  static constexpr FieldMetadata_Addr kAddr{};
+  void set_addr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IrqSourceId =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      KvmSetIrqFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IrqSourceId kIrqSourceId() { return {}; }
-  void set_irq_source_id(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IrqSourceId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Level =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      KvmSetIrqFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IonBufferCreateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Level kLevel() { return {}; }
-  void set_level(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class KvmSetGuestDebugFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class IonHeapGrowFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  KvmSetGuestDebugFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmSetGuestDebugFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmSetGuestDebugFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_guest_debug() const { return at<1>().valid(); }
-  uint32_t guest_debug() const { return at<1>().as_uint32(); }
-  bool has_vcpu() const { return at<2>().valid(); }
-  uint64_t vcpu() const { return at<2>().as_uint64(); }
+  IonHeapGrowFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IonHeapGrowFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IonHeapGrowFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_heap_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars heap_name() const { return at<1>().as_string(); }
+  bool has_len() const { return at<2>().valid(); }
+  uint64_t len() const { return at<2>().as_uint64(); }
+  bool has_total_allocated() const { return at<3>().valid(); }
+  int64_t total_allocated() const { return at<3>().as_int64(); }
 };
 
-class KvmSetGuestDebugFtraceEvent : public ::protozero::Message {
+class IonHeapGrowFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KvmSetGuestDebugFtraceEvent_Decoder;
+  using Decoder = IonHeapGrowFtraceEvent_Decoder;
   enum : int32_t {
-    kGuestDebugFieldNumber = 1,
-    kVcpuFieldNumber = 2,
+    kHeapNameFieldNumber = 1,
+    kLenFieldNumber = 2,
+    kTotalAllocatedFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmSetGuestDebugFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.IonHeapGrowFtraceEvent"; }
 
 
-  using FieldMetadata_GuestDebug =
+  using FieldMetadata_HeapName =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      KvmSetGuestDebugFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      IonHeapGrowFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GuestDebug kGuestDebug() { return {}; }
-  void set_guest_debug(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GuestDebug::kFieldId;
+  static constexpr FieldMetadata_HeapName kHeapName{};
+  void set_heap_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_HeapName::kFieldId, data, size);
+  }
+  void set_heap_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size);
+  }
+  void set_heap_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Vcpu =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KvmSetGuestDebugFtraceEvent>;
+      IonHeapGrowFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Vcpu kVcpu() { return {}; }
-  void set_vcpu(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Vcpu::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_TotalAllocated =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      IonHeapGrowFtraceEvent>;
+
+  static constexpr FieldMetadata_TotalAllocated kTotalAllocated{};
+  void set_total_allocated(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TotalAllocated::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class KvmMmioEmulateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class IonHeapShrinkFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  KvmMmioEmulateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmMmioEmulateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmMmioEmulateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_cpsr() const { return at<1>().valid(); }
-  uint64_t cpsr() const { return at<1>().as_uint64(); }
-  bool has_instr() const { return at<2>().valid(); }
-  uint64_t instr() const { return at<2>().as_uint64(); }
-  bool has_vcpu_pc() const { return at<3>().valid(); }
-  uint64_t vcpu_pc() const { return at<3>().as_uint64(); }
+  IonHeapShrinkFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IonHeapShrinkFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IonHeapShrinkFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_heap_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars heap_name() const { return at<1>().as_string(); }
+  bool has_len() const { return at<2>().valid(); }
+  uint64_t len() const { return at<2>().as_uint64(); }
+  bool has_total_allocated() const { return at<3>().valid(); }
+  int64_t total_allocated() const { return at<3>().as_int64(); }
 };
 
-class KvmMmioEmulateFtraceEvent : public ::protozero::Message {
+class IonHeapShrinkFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KvmMmioEmulateFtraceEvent_Decoder;
+  using Decoder = IonHeapShrinkFtraceEvent_Decoder;
   enum : int32_t {
-    kCpsrFieldNumber = 1,
-    kInstrFieldNumber = 2,
-    kVcpuPcFieldNumber = 3,
+    kHeapNameFieldNumber = 1,
+    kLenFieldNumber = 2,
+    kTotalAllocatedFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmMmioEmulateFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.IonHeapShrinkFtraceEvent"; }
 
 
-  using FieldMetadata_Cpsr =
+  using FieldMetadata_HeapName =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      KvmMmioEmulateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      IonHeapShrinkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cpsr kCpsr() { return {}; }
-  void set_cpsr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Cpsr::kFieldId;
+  static constexpr FieldMetadata_HeapName kHeapName{};
+  void set_heap_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_HeapName::kFieldId, data, size);
+  }
+  void set_heap_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size);
+  }
+  void set_heap_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Instr =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KvmMmioEmulateFtraceEvent>;
+      IonHeapShrinkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Instr kInstr() { return {}; }
-  void set_instr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Instr::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -109696,127 +138016,99 @@ class KvmMmioEmulateFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VcpuPc =
+  using FieldMetadata_TotalAllocated =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      KvmMmioEmulateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      IonHeapShrinkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VcpuPc kVcpuPc() { return {}; }
-  void set_vcpu_pc(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId;
+  static constexpr FieldMetadata_TotalAllocated kTotalAllocated{};
+  void set_total_allocated(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TotalAllocated::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 };
 
-class KvmMmioFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class RssStatFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  KvmMmioFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmMmioFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmMmioFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_gpa() const { return at<1>().valid(); }
-  uint64_t gpa() const { return at<1>().as_uint64(); }
-  bool has_len() const { return at<2>().valid(); }
-  uint32_t len() const { return at<2>().as_uint32(); }
-  bool has_type() const { return at<3>().valid(); }
-  uint32_t type() const { return at<3>().as_uint32(); }
-  bool has_val() const { return at<4>().valid(); }
-  uint64_t val() const { return at<4>().as_uint64(); }
+  RssStatFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit RssStatFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit RssStatFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_member() const { return at<1>().valid(); }
+  int32_t member() const { return at<1>().as_int32(); }
+  bool has_size() const { return at<2>().valid(); }
+  int64_t size() const { return at<2>().as_int64(); }
+  bool has_curr() const { return at<3>().valid(); }
+  uint32_t curr() const { return at<3>().as_uint32(); }
+  bool has_mm_id() const { return at<4>().valid(); }
+  uint32_t mm_id() const { return at<4>().as_uint32(); }
 };
 
-class KvmMmioFtraceEvent : public ::protozero::Message {
+class RssStatFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KvmMmioFtraceEvent_Decoder;
+  using Decoder = RssStatFtraceEvent_Decoder;
   enum : int32_t {
-    kGpaFieldNumber = 1,
-    kLenFieldNumber = 2,
-    kTypeFieldNumber = 3,
-    kValFieldNumber = 4,
+    kMemberFieldNumber = 1,
+    kSizeFieldNumber = 2,
+    kCurrFieldNumber = 3,
+    kMmIdFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmMmioFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.RssStatFtraceEvent"; }
 
 
-  using FieldMetadata_Gpa =
+  using FieldMetadata_Member =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      KvmMmioFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      RssStatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Gpa kGpa() { return {}; }
-  void set_gpa(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Gpa::kFieldId;
+  static constexpr FieldMetadata_Member kMember{};
+  void set_member(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Member::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_Size =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      KvmMmioFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      RssStatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_Size kSize{};
+  void set_size(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Type =
+  using FieldMetadata_Curr =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      KvmMmioFtraceEvent>;
+      RssStatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+  static constexpr FieldMetadata_Curr kCurr{};
+  void set_curr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Curr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -109824,77 +138116,63 @@ class KvmMmioFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Val =
+  using FieldMetadata_MmId =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      KvmMmioFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      RssStatFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Val kVal() { return {}; }
-  void set_val(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Val::kFieldId;
+  static constexpr FieldMetadata_MmId kMmId{};
+  void set_mm_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MmId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class KvmIrqLineFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmPagePcpuDrainFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  KvmIrqLineFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmIrqLineFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmIrqLineFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_irq_num() const { return at<1>().valid(); }
-  int32_t irq_num() const { return at<1>().as_int32(); }
-  bool has_level() const { return at<2>().valid(); }
-  int32_t level() const { return at<2>().as_int32(); }
-  bool has_type() const { return at<3>().valid(); }
-  uint32_t type() const { return at<3>().as_uint32(); }
-  bool has_vcpu_idx() const { return at<4>().valid(); }
-  int32_t vcpu_idx() const { return at<4>().as_int32(); }
+  MmPagePcpuDrainFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MmPagePcpuDrainFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MmPagePcpuDrainFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_migratetype() const { return at<1>().valid(); }
+  int32_t migratetype() const { return at<1>().as_int32(); }
+  bool has_order() const { return at<2>().valid(); }
+  uint32_t order() const { return at<2>().as_uint32(); }
+  bool has_page() const { return at<3>().valid(); }
+  uint64_t page() const { return at<3>().as_uint64(); }
+  bool has_pfn() const { return at<4>().valid(); }
+  uint64_t pfn() const { return at<4>().as_uint64(); }
 };
 
-class KvmIrqLineFtraceEvent : public ::protozero::Message {
+class MmPagePcpuDrainFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KvmIrqLineFtraceEvent_Decoder;
+  using Decoder = MmPagePcpuDrainFtraceEvent_Decoder;
   enum : int32_t {
-    kIrqNumFieldNumber = 1,
-    kLevelFieldNumber = 2,
-    kTypeFieldNumber = 3,
-    kVcpuIdxFieldNumber = 4,
+    kMigratetypeFieldNumber = 1,
+    kOrderFieldNumber = 2,
+    kPageFieldNumber = 3,
+    kPfnFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmIrqLineFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MmPagePcpuDrainFtraceEvent"; }
 
 
-  using FieldMetadata_IrqNum =
+  using FieldMetadata_Migratetype =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      KvmIrqLineFtraceEvent>;
+      MmPagePcpuDrainFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IrqNum kIrqNum() { return {}; }
-  void set_irq_num(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IrqNum::kFieldId;
+  static constexpr FieldMetadata_Migratetype kMigratetype{};
+  void set_migratetype(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Migratetype::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -109902,149 +138180,114 @@ class KvmIrqLineFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Level =
+  using FieldMetadata_Order =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      KvmIrqLineFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MmPagePcpuDrainFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Level kLevel() { return {}; }
-  void set_level(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId;
+  static constexpr FieldMetadata_Order kOrder{};
+  void set_order(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Type =
+  using FieldMetadata_Page =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      KvmIrqLineFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmPagePcpuDrainFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+  static constexpr FieldMetadata_Page kPage{};
+  void set_page(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VcpuIdx =
+  using FieldMetadata_Pfn =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      KvmIrqLineFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmPagePcpuDrainFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VcpuIdx kVcpuIdx() { return {}; }
-  void set_vcpu_idx(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VcpuIdx::kFieldId;
+  static constexpr FieldMetadata_Pfn kPfn{};
+  void set_pfn(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class KvmHvcArm64FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmPageFreeBatchedFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  KvmHvcArm64FtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmHvcArm64FtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmHvcArm64FtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_imm() const { return at<1>().valid(); }
-  uint64_t imm() const { return at<1>().as_uint64(); }
-  bool has_r0() const { return at<2>().valid(); }
-  uint64_t r0() const { return at<2>().as_uint64(); }
-  bool has_vcpu_pc() const { return at<3>().valid(); }
-  uint64_t vcpu_pc() const { return at<3>().as_uint64(); }
+  MmPageFreeBatchedFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MmPageFreeBatchedFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MmPageFreeBatchedFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cold() const { return at<1>().valid(); }
+  int32_t cold() const { return at<1>().as_int32(); }
+  bool has_page() const { return at<2>().valid(); }
+  uint64_t page() const { return at<2>().as_uint64(); }
+  bool has_pfn() const { return at<3>().valid(); }
+  uint64_t pfn() const { return at<3>().as_uint64(); }
 };
 
-class KvmHvcArm64FtraceEvent : public ::protozero::Message {
+class MmPageFreeBatchedFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KvmHvcArm64FtraceEvent_Decoder;
+  using Decoder = MmPageFreeBatchedFtraceEvent_Decoder;
   enum : int32_t {
-    kImmFieldNumber = 1,
-    kR0FieldNumber = 2,
-    kVcpuPcFieldNumber = 3,
+    kColdFieldNumber = 1,
+    kPageFieldNumber = 2,
+    kPfnFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmHvcArm64FtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MmPageFreeBatchedFtraceEvent"; }
 
 
-  using FieldMetadata_Imm =
+  using FieldMetadata_Cold =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      KvmHvcArm64FtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MmPageFreeBatchedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Imm kImm() { return {}; }
-  void set_imm(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Imm::kFieldId;
+  static constexpr FieldMetadata_Cold kCold{};
+  void set_cold(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cold::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_R0 =
+  using FieldMetadata_Page =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KvmHvcArm64FtraceEvent>;
+      MmPageFreeBatchedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_R0 kR0() { return {}; }
-  void set_r0(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_R0::kFieldId;
+  static constexpr FieldMetadata_Page kPage{};
+  void set_page(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -110052,24 +138295,17 @@ class KvmHvcArm64FtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VcpuPc =
+  using FieldMetadata_Pfn =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KvmHvcArm64FtraceEvent>;
+      MmPageFreeBatchedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VcpuPc kVcpuPc() { return {}; }
-  void set_vcpu_pc(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId;
+  static constexpr FieldMetadata_Pfn kPfn{};
+  void set_pfn(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -110078,42 +138314,77 @@ class KvmHvcArm64FtraceEvent : public ::protozero::Message {
   }
 };
 
-class KvmHandleSysRegFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmPageFreeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  KvmHandleSysRegFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmHandleSysRegFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmHandleSysRegFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_hsr() const { return at<1>().valid(); }
-  uint64_t hsr() const { return at<1>().as_uint64(); }
+  MmPageFreeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MmPageFreeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MmPageFreeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_order() const { return at<1>().valid(); }
+  uint32_t order() const { return at<1>().as_uint32(); }
+  bool has_page() const { return at<2>().valid(); }
+  uint64_t page() const { return at<2>().as_uint64(); }
+  bool has_pfn() const { return at<3>().valid(); }
+  uint64_t pfn() const { return at<3>().as_uint64(); }
 };
 
-class KvmHandleSysRegFtraceEvent : public ::protozero::Message {
+class MmPageFreeFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KvmHandleSysRegFtraceEvent_Decoder;
+  using Decoder = MmPageFreeFtraceEvent_Decoder;
   enum : int32_t {
-    kHsrFieldNumber = 1,
+    kOrderFieldNumber = 1,
+    kPageFieldNumber = 2,
+    kPfnFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmHandleSysRegFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MmPageFreeFtraceEvent"; }
 
 
-  using FieldMetadata_Hsr =
+  using FieldMetadata_Order =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MmPageFreeFtraceEvent>;
+
+  static constexpr FieldMetadata_Order kOrder{};
+  void set_order(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Page =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KvmHandleSysRegFtraceEvent>;
+      MmPageFreeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Hsr kHsr() { return {}; }
-  void set_hsr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Hsr::kFieldId;
+  static constexpr FieldMetadata_Page kPage{};
+  void set_page(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Pfn =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmPageFreeFtraceEvent>;
+
+  static constexpr FieldMetadata_Pfn kPfn{};
+  void set_pfn(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -110122,101 +138393,80 @@ class KvmHandleSysRegFtraceEvent : public ::protozero::Message {
   }
 };
 
-class KvmGuestFaultFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmPageAllocZoneLockedFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  KvmGuestFaultFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmGuestFaultFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmGuestFaultFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_hsr() const { return at<1>().valid(); }
-  uint64_t hsr() const { return at<1>().as_uint64(); }
-  bool has_hxfar() const { return at<2>().valid(); }
-  uint64_t hxfar() const { return at<2>().as_uint64(); }
-  bool has_ipa() const { return at<3>().valid(); }
-  uint64_t ipa() const { return at<3>().as_uint64(); }
-  bool has_vcpu_pc() const { return at<4>().valid(); }
-  uint64_t vcpu_pc() const { return at<4>().as_uint64(); }
+  MmPageAllocZoneLockedFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MmPageAllocZoneLockedFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MmPageAllocZoneLockedFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_migratetype() const { return at<1>().valid(); }
+  int32_t migratetype() const { return at<1>().as_int32(); }
+  bool has_order() const { return at<2>().valid(); }
+  uint32_t order() const { return at<2>().as_uint32(); }
+  bool has_page() const { return at<3>().valid(); }
+  uint64_t page() const { return at<3>().as_uint64(); }
+  bool has_pfn() const { return at<4>().valid(); }
+  uint64_t pfn() const { return at<4>().as_uint64(); }
 };
 
-class KvmGuestFaultFtraceEvent : public ::protozero::Message {
+class MmPageAllocZoneLockedFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KvmGuestFaultFtraceEvent_Decoder;
+  using Decoder = MmPageAllocZoneLockedFtraceEvent_Decoder;
   enum : int32_t {
-    kHsrFieldNumber = 1,
-    kHxfarFieldNumber = 2,
-    kIpaFieldNumber = 3,
-    kVcpuPcFieldNumber = 4,
+    kMigratetypeFieldNumber = 1,
+    kOrderFieldNumber = 2,
+    kPageFieldNumber = 3,
+    kPfnFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmGuestFaultFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MmPageAllocZoneLockedFtraceEvent"; }
 
 
-  using FieldMetadata_Hsr =
+  using FieldMetadata_Migratetype =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      KvmGuestFaultFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MmPageAllocZoneLockedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Hsr kHsr() { return {}; }
-  void set_hsr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Hsr::kFieldId;
+  static constexpr FieldMetadata_Migratetype kMigratetype{};
+  void set_migratetype(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Migratetype::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Hxfar =
+  using FieldMetadata_Order =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      KvmGuestFaultFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MmPageAllocZoneLockedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Hxfar kHxfar() { return {}; }
-  void set_hxfar(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Hxfar::kFieldId;
+  static constexpr FieldMetadata_Order kOrder{};
+  void set_order(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ipa =
+  using FieldMetadata_Page =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KvmGuestFaultFtraceEvent>;
+      MmPageAllocZoneLockedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ipa kIpa() { return {}; }
-  void set_ipa(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ipa::kFieldId;
+  static constexpr FieldMetadata_Page kPage{};
+  void set_page(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -110224,24 +138474,17 @@ class KvmGuestFaultFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VcpuPc =
+  using FieldMetadata_Pfn =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KvmGuestFaultFtraceEvent>;
+      MmPageAllocZoneLockedFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VcpuPc kVcpuPc() { return {}; }
-  void set_vcpu_pc(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId;
+  static constexpr FieldMetadata_Pfn kPfn{};
+  void set_pfn(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -110250,51 +138493,53 @@ class KvmGuestFaultFtraceEvent : public ::protozero::Message {
   }
 };
 
-class KvmGetTimerMapFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmPageAllocExtfragFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
-  KvmGetTimerMapFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmGetTimerMapFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmGetTimerMapFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_direct_ptimer() const { return at<1>().valid(); }
-  int32_t direct_ptimer() const { return at<1>().as_int32(); }
-  bool has_direct_vtimer() const { return at<2>().valid(); }
-  int32_t direct_vtimer() const { return at<2>().as_int32(); }
-  bool has_emul_ptimer() const { return at<3>().valid(); }
-  int32_t emul_ptimer() const { return at<3>().as_int32(); }
-  bool has_vcpu_id() const { return at<4>().valid(); }
-  uint64_t vcpu_id() const { return at<4>().as_uint64(); }
+  MmPageAllocExtfragFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MmPageAllocExtfragFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MmPageAllocExtfragFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_alloc_migratetype() const { return at<1>().valid(); }
+  int32_t alloc_migratetype() const { return at<1>().as_int32(); }
+  bool has_alloc_order() const { return at<2>().valid(); }
+  int32_t alloc_order() const { return at<2>().as_int32(); }
+  bool has_fallback_migratetype() const { return at<3>().valid(); }
+  int32_t fallback_migratetype() const { return at<3>().as_int32(); }
+  bool has_fallback_order() const { return at<4>().valid(); }
+  int32_t fallback_order() const { return at<4>().as_int32(); }
+  bool has_page() const { return at<5>().valid(); }
+  uint64_t page() const { return at<5>().as_uint64(); }
+  bool has_change_ownership() const { return at<6>().valid(); }
+  int32_t change_ownership() const { return at<6>().as_int32(); }
+  bool has_pfn() const { return at<7>().valid(); }
+  uint64_t pfn() const { return at<7>().as_uint64(); }
 };
 
-class KvmGetTimerMapFtraceEvent : public ::protozero::Message {
+class MmPageAllocExtfragFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KvmGetTimerMapFtraceEvent_Decoder;
+  using Decoder = MmPageAllocExtfragFtraceEvent_Decoder;
   enum : int32_t {
-    kDirectPtimerFieldNumber = 1,
-    kDirectVtimerFieldNumber = 2,
-    kEmulPtimerFieldNumber = 3,
-    kVcpuIdFieldNumber = 4,
+    kAllocMigratetypeFieldNumber = 1,
+    kAllocOrderFieldNumber = 2,
+    kFallbackMigratetypeFieldNumber = 3,
+    kFallbackOrderFieldNumber = 4,
+    kPageFieldNumber = 5,
+    kChangeOwnershipFieldNumber = 6,
+    kPfnFieldNumber = 7,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmGetTimerMapFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MmPageAllocExtfragFtraceEvent"; }
 
 
-  using FieldMetadata_DirectPtimer =
+  using FieldMetadata_AllocMigratetype =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      KvmGetTimerMapFtraceEvent>;
+      MmPageAllocExtfragFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DirectPtimer kDirectPtimer() { return {}; }
-  void set_direct_ptimer(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DirectPtimer::kFieldId;
+  static constexpr FieldMetadata_AllocMigratetype kAllocMigratetype{};
+  void set_alloc_migratetype(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AllocMigratetype::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -110302,24 +138547,17 @@ class KvmGetTimerMapFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DirectVtimer =
+  using FieldMetadata_AllocOrder =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      KvmGetTimerMapFtraceEvent>;
+      MmPageAllocExtfragFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DirectVtimer kDirectVtimer() { return {}; }
-  void set_direct_vtimer(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DirectVtimer::kFieldId;
+  static constexpr FieldMetadata_AllocOrder kAllocOrder{};
+  void set_alloc_order(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AllocOrder::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -110327,24 +138565,17 @@ class KvmGetTimerMapFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_EmulPtimer =
+  using FieldMetadata_FallbackMigratetype =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      KvmGetTimerMapFtraceEvent>;
+      MmPageAllocExtfragFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EmulPtimer kEmulPtimer() { return {}; }
-  void set_emul_ptimer(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EmulPtimer::kFieldId;
+  static constexpr FieldMetadata_FallbackMigratetype kFallbackMigratetype{};
+  void set_fallback_migratetype(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FallbackMigratetype::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -110352,118 +138583,120 @@ class KvmGetTimerMapFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VcpuId =
+  using FieldMetadata_FallbackOrder =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MmPageAllocExtfragFtraceEvent>;
+
+  static constexpr FieldMetadata_FallbackOrder kFallbackOrder{};
+  void set_fallback_order(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FallbackOrder::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Page =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KvmGetTimerMapFtraceEvent>;
+      MmPageAllocExtfragFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VcpuId kVcpuId() { return {}; }
-  void set_vcpu_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VcpuId::kFieldId;
+  static constexpr FieldMetadata_Page kPage{};
+  void set_page(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class KvmFpuFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  KvmFpuFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmFpuFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmFpuFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_load() const { return at<1>().valid(); }
-  uint32_t load() const { return at<1>().as_uint32(); }
-};
 
-class KvmFpuFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = KvmFpuFtraceEvent_Decoder;
-  enum : int32_t {
-    kLoadFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmFpuFtraceEvent"; }
+  using FieldMetadata_ChangeOwnership =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MmPageAllocExtfragFtraceEvent>;
 
+  static constexpr FieldMetadata_ChangeOwnership kChangeOwnership{};
+  void set_change_ownership(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ChangeOwnership::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Load =
+  using FieldMetadata_Pfn =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      KvmFpuFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmPageAllocExtfragFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Load kLoad() { return {}; }
-  void set_load(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Load::kFieldId;
+  static constexpr FieldMetadata_Pfn kPfn{};
+  void set_pfn(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class KvmExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmPageAllocFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  KvmExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_esr_ec() const { return at<1>().valid(); }
-  uint32_t esr_ec() const { return at<1>().as_uint32(); }
-  bool has_ret() const { return at<2>().valid(); }
-  int32_t ret() const { return at<2>().as_int32(); }
-  bool has_vcpu_pc() const { return at<3>().valid(); }
-  uint64_t vcpu_pc() const { return at<3>().as_uint64(); }
+  MmPageAllocFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MmPageAllocFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MmPageAllocFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_gfp_flags() const { return at<1>().valid(); }
+  uint32_t gfp_flags() const { return at<1>().as_uint32(); }
+  bool has_migratetype() const { return at<2>().valid(); }
+  int32_t migratetype() const { return at<2>().as_int32(); }
+  bool has_order() const { return at<3>().valid(); }
+  uint32_t order() const { return at<3>().as_uint32(); }
+  bool has_page() const { return at<4>().valid(); }
+  uint64_t page() const { return at<4>().as_uint64(); }
+  bool has_pfn() const { return at<5>().valid(); }
+  uint64_t pfn() const { return at<5>().as_uint64(); }
 };
 
-class KvmExitFtraceEvent : public ::protozero::Message {
+class MmPageAllocFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KvmExitFtraceEvent_Decoder;
+  using Decoder = MmPageAllocFtraceEvent_Decoder;
   enum : int32_t {
-    kEsrEcFieldNumber = 1,
-    kRetFieldNumber = 2,
-    kVcpuPcFieldNumber = 3,
+    kGfpFlagsFieldNumber = 1,
+    kMigratetypeFieldNumber = 2,
+    kOrderFieldNumber = 3,
+    kPageFieldNumber = 4,
+    kPfnFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmExitFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MmPageAllocFtraceEvent"; }
 
 
-  using FieldMetadata_EsrEc =
+  using FieldMetadata_GfpFlags =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      KvmExitFtraceEvent>;
+      MmPageAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EsrEc kEsrEc() { return {}; }
-  void set_esr_ec(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EsrEc::kFieldId;
+  static constexpr FieldMetadata_GfpFlags kGfpFlags{};
+  void set_gfp_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -110471,24 +138704,17 @@ class KvmExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ret =
+  using FieldMetadata_Migratetype =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      KvmExitFtraceEvent>;
+      MmPageAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+  static constexpr FieldMetadata_Migratetype kMigratetype{};
+  void set_migratetype(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Migratetype::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -110496,68 +138722,53 @@ class KvmExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VcpuPc =
+  using FieldMetadata_Order =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MmPageAllocFtraceEvent>;
+
+  static constexpr FieldMetadata_Order kOrder{};
+  void set_order(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Page =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KvmExitFtraceEvent>;
+      MmPageAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VcpuPc kVcpuPc() { return {}; }
-  void set_vcpu_pc(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId;
+  static constexpr FieldMetadata_Page kPage{};
+  void set_page(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class KvmEntryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  KvmEntryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmEntryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmEntryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_vcpu_pc() const { return at<1>().valid(); }
-  uint64_t vcpu_pc() const { return at<1>().as_uint64(); }
-};
-
-class KvmEntryFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = KvmEntryFtraceEvent_Decoder;
-  enum : int32_t {
-    kVcpuPcFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmEntryFtraceEvent"; }
-
 
-  using FieldMetadata_VcpuPc =
+  using FieldMetadata_Pfn =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KvmEntryFtraceEvent>;
+      MmPageAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VcpuPc kVcpuPc() { return {}; }
-  void set_vcpu_pc(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId;
+  static constexpr FieldMetadata_Pfn kPfn{};
+  void set_pfn(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -110566,323 +138777,237 @@ class KvmEntryFtraceEvent : public ::protozero::Message {
   }
 };
 
-class KvmArmSetupDebugFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MigrateRetryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  KvmArmSetupDebugFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmArmSetupDebugFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmArmSetupDebugFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_guest_debug() const { return at<1>().valid(); }
-  uint32_t guest_debug() const { return at<1>().as_uint32(); }
-  bool has_vcpu() const { return at<2>().valid(); }
-  uint64_t vcpu() const { return at<2>().as_uint64(); }
+  MigrateRetryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MigrateRetryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MigrateRetryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_tries() const { return at<1>().valid(); }
+  int32_t tries() const { return at<1>().as_int32(); }
 };
 
-class KvmArmSetupDebugFtraceEvent : public ::protozero::Message {
+class MigrateRetryFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KvmArmSetupDebugFtraceEvent_Decoder;
+  using Decoder = MigrateRetryFtraceEvent_Decoder;
   enum : int32_t {
-    kGuestDebugFieldNumber = 1,
-    kVcpuFieldNumber = 2,
+    kTriesFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmArmSetupDebugFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MigrateRetryFtraceEvent"; }
 
 
-  using FieldMetadata_GuestDebug =
+  using FieldMetadata_Tries =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      KvmArmSetupDebugFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GuestDebug kGuestDebug() { return {}; }
-  void set_guest_debug(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GuestDebug::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Vcpu =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      KvmArmSetupDebugFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MigrateRetryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Vcpu kVcpu() { return {}; }
-  void set_vcpu(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Vcpu::kFieldId;
+  static constexpr FieldMetadata_Tries kTries{};
+  void set_tries(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tries::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class KvmArmSetRegsetFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MigratePagesStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  KvmArmSetRegsetFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmArmSetRegsetFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmArmSetRegsetFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_len() const { return at<1>().valid(); }
-  int32_t len() const { return at<1>().as_int32(); }
-  bool has_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars name() const { return at<2>().as_string(); }
+  MigratePagesStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MigratePagesStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MigratePagesStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_mode() const { return at<1>().valid(); }
+  int32_t mode() const { return at<1>().as_int32(); }
 };
 
-class KvmArmSetRegsetFtraceEvent : public ::protozero::Message {
+class MigratePagesStartFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KvmArmSetRegsetFtraceEvent_Decoder;
+  using Decoder = MigratePagesStartFtraceEvent_Decoder;
   enum : int32_t {
-    kLenFieldNumber = 1,
-    kNameFieldNumber = 2,
+    kModeFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmArmSetRegsetFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MigratePagesStartFtraceEvent"; }
 
 
-  using FieldMetadata_Len =
+  using FieldMetadata_Mode =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      KvmArmSetRegsetFtraceEvent>;
+      MigratePagesStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Name =
+class MigratePagesEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  MigratePagesEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MigratePagesEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MigratePagesEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_mode() const { return at<1>().valid(); }
+  int32_t mode() const { return at<1>().as_int32(); }
+};
+
+class MigratePagesEndFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = MigratePagesEndFtraceEvent_Decoder;
+  enum : int32_t {
+    kModeFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.MigratePagesEndFtraceEvent"; }
+
+
+  using FieldMetadata_Mode =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      KvmArmSetRegsetFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MigratePagesEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class KvmArmSetDreg32FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class KmemCacheFreeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  KvmArmSetDreg32FtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmArmSetDreg32FtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmArmSetDreg32FtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_value() const { return at<2>().valid(); }
-  uint32_t value() const { return at<2>().as_uint32(); }
+  KmemCacheFreeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KmemCacheFreeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KmemCacheFreeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_call_site() const { return at<1>().valid(); }
+  uint64_t call_site() const { return at<1>().as_uint64(); }
+  bool has_ptr() const { return at<2>().valid(); }
+  uint64_t ptr() const { return at<2>().as_uint64(); }
 };
 
-class KvmArmSetDreg32FtraceEvent : public ::protozero::Message {
+class KmemCacheFreeFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KvmArmSetDreg32FtraceEvent_Decoder;
+  using Decoder = KmemCacheFreeFtraceEvent_Decoder;
   enum : int32_t {
-    kNameFieldNumber = 1,
-    kValueFieldNumber = 2,
+    kCallSiteFieldNumber = 1,
+    kPtrFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmArmSetDreg32FtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.KmemCacheFreeFtraceEvent"; }
 
 
-  using FieldMetadata_Name =
+  using FieldMetadata_CallSite =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      KvmArmSetDreg32FtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KmemCacheFreeFtraceEvent>;
+
+  static constexpr FieldMetadata_CallSite kCallSite{};
+  void set_call_site(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CallSite::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Value =
+  using FieldMetadata_Ptr =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      KvmArmSetDreg32FtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KmemCacheFreeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+  static constexpr FieldMetadata_Ptr kPtr{};
+  void set_ptr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ptr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class KvmArmClearDebugFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class KmemCacheAllocNodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  KvmArmClearDebugFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmArmClearDebugFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmArmClearDebugFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_guest_debug() const { return at<1>().valid(); }
-  uint32_t guest_debug() const { return at<1>().as_uint32(); }
+  KmemCacheAllocNodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KmemCacheAllocNodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KmemCacheAllocNodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_bytes_alloc() const { return at<1>().valid(); }
+  uint64_t bytes_alloc() const { return at<1>().as_uint64(); }
+  bool has_bytes_req() const { return at<2>().valid(); }
+  uint64_t bytes_req() const { return at<2>().as_uint64(); }
+  bool has_call_site() const { return at<3>().valid(); }
+  uint64_t call_site() const { return at<3>().as_uint64(); }
+  bool has_gfp_flags() const { return at<4>().valid(); }
+  uint32_t gfp_flags() const { return at<4>().as_uint32(); }
+  bool has_node() const { return at<5>().valid(); }
+  int32_t node() const { return at<5>().as_int32(); }
+  bool has_ptr() const { return at<6>().valid(); }
+  uint64_t ptr() const { return at<6>().as_uint64(); }
 };
 
-class KvmArmClearDebugFtraceEvent : public ::protozero::Message {
+class KmemCacheAllocNodeFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KvmArmClearDebugFtraceEvent_Decoder;
+  using Decoder = KmemCacheAllocNodeFtraceEvent_Decoder;
   enum : int32_t {
-    kGuestDebugFieldNumber = 1,
+    kBytesAllocFieldNumber = 1,
+    kBytesReqFieldNumber = 2,
+    kCallSiteFieldNumber = 3,
+    kGfpFlagsFieldNumber = 4,
+    kNodeFieldNumber = 5,
+    kPtrFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmArmClearDebugFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.KmemCacheAllocNodeFtraceEvent"; }
 
 
-  using FieldMetadata_GuestDebug =
+  using FieldMetadata_BytesAlloc =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      KvmArmClearDebugFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KmemCacheAllocNodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GuestDebug kGuestDebug() { return {}; }
-  void set_guest_debug(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GuestDebug::kFieldId;
+  static constexpr FieldMetadata_BytesAlloc kBytesAlloc{};
+  void set_bytes_alloc(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BytesAlloc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class KvmAgePageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  KvmAgePageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmAgePageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmAgePageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_gfn() const { return at<1>().valid(); }
-  uint64_t gfn() const { return at<1>().as_uint64(); }
-  bool has_hva() const { return at<2>().valid(); }
-  uint64_t hva() const { return at<2>().as_uint64(); }
-  bool has_level() const { return at<3>().valid(); }
-  uint32_t level() const { return at<3>().as_uint32(); }
-  bool has_referenced() const { return at<4>().valid(); }
-  uint32_t referenced() const { return at<4>().as_uint32(); }
-};
-
-class KvmAgePageFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = KvmAgePageFtraceEvent_Decoder;
-  enum : int32_t {
-    kGfnFieldNumber = 1,
-    kHvaFieldNumber = 2,
-    kLevelFieldNumber = 3,
-    kReferencedFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmAgePageFtraceEvent"; }
 
-
-  using FieldMetadata_Gfn =
+  using FieldMetadata_BytesReq =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KvmAgePageFtraceEvent>;
+      KmemCacheAllocNodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Gfn kGfn() { return {}; }
-  void set_gfn(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Gfn::kFieldId;
+  static constexpr FieldMetadata_BytesReq kBytesReq{};
+  void set_bytes_req(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BytesReq::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -110890,24 +139015,17 @@ class KvmAgePageFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Hva =
+  using FieldMetadata_CallSite =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KvmAgePageFtraceEvent>;
+      KmemCacheAllocNodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Hva kHva() { return {}; }
-  void set_hva(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Hva::kFieldId;
+  static constexpr FieldMetadata_CallSite kCallSite{};
+  void set_call_site(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CallSite::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -110915,24 +139033,17 @@ class KvmAgePageFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Level =
+  using FieldMetadata_GfpFlags =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      KvmAgePageFtraceEvent>;
+      KmemCacheAllocNodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Level kLevel() { return {}; }
-  void set_level(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId;
+  static constexpr FieldMetadata_GfpFlags kGfpFlags{};
+  void set_gfp_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -110940,71 +139051,84 @@ class KvmAgePageFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Referenced =
+  using FieldMetadata_Node =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      KvmAgePageFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KmemCacheAllocNodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Referenced kReferenced() { return {}; }
-  void set_referenced(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Referenced::kFieldId;
+  static constexpr FieldMetadata_Node kNode{};
+  void set_node(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Node::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ptr =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KmemCacheAllocNodeFtraceEvent>;
+
+  static constexpr FieldMetadata_Ptr kPtr{};
+  void set_ptr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ptr::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class KvmAgeHvaFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class KmemCacheAllocFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  KvmAgeHvaFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmAgeHvaFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmAgeHvaFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_end() const { return at<1>().valid(); }
-  uint64_t end() const { return at<1>().as_uint64(); }
-  bool has_start() const { return at<2>().valid(); }
-  uint64_t start() const { return at<2>().as_uint64(); }
+  KmemCacheAllocFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KmemCacheAllocFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KmemCacheAllocFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_bytes_alloc() const { return at<1>().valid(); }
+  uint64_t bytes_alloc() const { return at<1>().as_uint64(); }
+  bool has_bytes_req() const { return at<2>().valid(); }
+  uint64_t bytes_req() const { return at<2>().as_uint64(); }
+  bool has_call_site() const { return at<3>().valid(); }
+  uint64_t call_site() const { return at<3>().as_uint64(); }
+  bool has_gfp_flags() const { return at<4>().valid(); }
+  uint32_t gfp_flags() const { return at<4>().as_uint32(); }
+  bool has_ptr() const { return at<5>().valid(); }
+  uint64_t ptr() const { return at<5>().as_uint64(); }
 };
 
-class KvmAgeHvaFtraceEvent : public ::protozero::Message {
+class KmemCacheAllocFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KvmAgeHvaFtraceEvent_Decoder;
+  using Decoder = KmemCacheAllocFtraceEvent_Decoder;
   enum : int32_t {
-    kEndFieldNumber = 1,
-    kStartFieldNumber = 2,
+    kBytesAllocFieldNumber = 1,
+    kBytesReqFieldNumber = 2,
+    kCallSiteFieldNumber = 3,
+    kGfpFlagsFieldNumber = 4,
+    kPtrFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmAgeHvaFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.KmemCacheAllocFtraceEvent"; }
 
 
-  using FieldMetadata_End =
+  using FieldMetadata_BytesAlloc =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KvmAgeHvaFtraceEvent>;
+      KmemCacheAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_End kEnd() { return {}; }
-  void set_end(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_End::kFieldId;
+  static constexpr FieldMetadata_BytesAlloc kBytesAlloc{};
+  void set_bytes_alloc(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BytesAlloc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -111012,140 +139136,71 @@ class KvmAgeHvaFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Start =
+  using FieldMetadata_BytesReq =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KvmAgeHvaFtraceEvent>;
+      KmemCacheAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Start kStart() { return {}; }
-  void set_start(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
+  static constexpr FieldMetadata_BytesReq kBytesReq{};
+  void set_bytes_req(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BytesReq::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class KvmAckIrqFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  KvmAckIrqFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmAckIrqFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmAckIrqFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_irqchip() const { return at<1>().valid(); }
-  uint32_t irqchip() const { return at<1>().as_uint32(); }
-  bool has_pin() const { return at<2>().valid(); }
-  uint32_t pin() const { return at<2>().as_uint32(); }
-};
-
-class KvmAckIrqFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = KvmAckIrqFtraceEvent_Decoder;
-  enum : int32_t {
-    kIrqchipFieldNumber = 1,
-    kPinFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmAckIrqFtraceEvent"; }
-
 
-  using FieldMetadata_Irqchip =
+  using FieldMetadata_CallSite =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      KvmAckIrqFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KmemCacheAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Irqchip kIrqchip() { return {}; }
-  void set_irqchip(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Irqchip::kFieldId;
+  static constexpr FieldMetadata_CallSite kCallSite{};
+  void set_call_site(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CallSite::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pin =
+  using FieldMetadata_GfpFlags =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      KvmAckIrqFtraceEvent>;
+      KmemCacheAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pin kPin() { return {}; }
-  void set_pin(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pin::kFieldId;
+  static constexpr FieldMetadata_GfpFlags kGfpFlags{};
+  void set_gfp_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class KvmAccessFaultFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  KvmAccessFaultFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KvmAccessFaultFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KvmAccessFaultFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_ipa() const { return at<1>().valid(); }
-  uint64_t ipa() const { return at<1>().as_uint64(); }
-};
-
-class KvmAccessFaultFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = KvmAccessFaultFtraceEvent_Decoder;
-  enum : int32_t {
-    kIpaFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.KvmAccessFaultFtraceEvent"; }
-
 
-  using FieldMetadata_Ipa =
+  using FieldMetadata_Ptr =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      KvmAccessFaultFtraceEvent>;
+      KmemCacheAllocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ipa kIpa() { return {}; }
-  void set_ipa(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ipa::kFieldId;
+  static constexpr FieldMetadata_Ptr kPtr{};
+  void set_ptr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ptr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -111154,456 +139209,301 @@ class KvmAccessFaultFtraceEvent : public ::protozero::Message {
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/lowmemorykiller.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_LOWMEMORYKILLER_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_LOWMEMORYKILLER_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class LowmemoryKillFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class KmallocNodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  LowmemoryKillFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit LowmemoryKillFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit LowmemoryKillFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_comm() const { return at<1>().valid(); }
-  ::protozero::ConstChars comm() const { return at<1>().as_string(); }
-  bool has_pid() const { return at<2>().valid(); }
-  int32_t pid() const { return at<2>().as_int32(); }
-  bool has_pagecache_size() const { return at<3>().valid(); }
-  int64_t pagecache_size() const { return at<3>().as_int64(); }
-  bool has_pagecache_limit() const { return at<4>().valid(); }
-  int64_t pagecache_limit() const { return at<4>().as_int64(); }
-  bool has_free() const { return at<5>().valid(); }
-  int64_t free() const { return at<5>().as_int64(); }
+  KmallocNodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KmallocNodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KmallocNodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_bytes_alloc() const { return at<1>().valid(); }
+  uint64_t bytes_alloc() const { return at<1>().as_uint64(); }
+  bool has_bytes_req() const { return at<2>().valid(); }
+  uint64_t bytes_req() const { return at<2>().as_uint64(); }
+  bool has_call_site() const { return at<3>().valid(); }
+  uint64_t call_site() const { return at<3>().as_uint64(); }
+  bool has_gfp_flags() const { return at<4>().valid(); }
+  uint32_t gfp_flags() const { return at<4>().as_uint32(); }
+  bool has_node() const { return at<5>().valid(); }
+  int32_t node() const { return at<5>().as_int32(); }
+  bool has_ptr() const { return at<6>().valid(); }
+  uint64_t ptr() const { return at<6>().as_uint64(); }
 };
 
-class LowmemoryKillFtraceEvent : public ::protozero::Message {
+class KmallocNodeFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = LowmemoryKillFtraceEvent_Decoder;
+  using Decoder = KmallocNodeFtraceEvent_Decoder;
   enum : int32_t {
-    kCommFieldNumber = 1,
-    kPidFieldNumber = 2,
-    kPagecacheSizeFieldNumber = 3,
-    kPagecacheLimitFieldNumber = 4,
-    kFreeFieldNumber = 5,
+    kBytesAllocFieldNumber = 1,
+    kBytesReqFieldNumber = 2,
+    kCallSiteFieldNumber = 3,
+    kGfpFlagsFieldNumber = 4,
+    kNodeFieldNumber = 5,
+    kPtrFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.LowmemoryKillFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.KmallocNodeFtraceEvent"; }
 
 
-  using FieldMetadata_Comm =
+  using FieldMetadata_BytesAlloc =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      LowmemoryKillFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KmallocNodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
-  void set_comm(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
-  }
-  void set_comm(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
-  }
-  void set_comm(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
+  static constexpr FieldMetadata_BytesAlloc kBytesAlloc{};
+  void set_bytes_alloc(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BytesAlloc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_BytesReq =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      LowmemoryKillFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KmallocNodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_BytesReq kBytesReq{};
+  void set_bytes_req(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BytesReq::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PagecacheSize =
+  using FieldMetadata_CallSite =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      LowmemoryKillFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KmallocNodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PagecacheSize kPagecacheSize() { return {}; }
-  void set_pagecache_size(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PagecacheSize::kFieldId;
+  static constexpr FieldMetadata_CallSite kCallSite{};
+  void set_call_site(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CallSite::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PagecacheLimit =
+  using FieldMetadata_GfpFlags =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      LowmemoryKillFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KmallocNodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PagecacheLimit kPagecacheLimit() { return {}; }
-  void set_pagecache_limit(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PagecacheLimit::kFieldId;
+  static constexpr FieldMetadata_GfpFlags kGfpFlags{};
+  void set_gfp_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Free =
+  using FieldMetadata_Node =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      LowmemoryKillFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KmallocNodeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Free kFree() { return {}; }
-  void set_free(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Free::kFieldId;
+  static constexpr FieldMetadata_Node kNode{};
+  void set_node(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Node::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/lwis.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_LWIS_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_LWIS_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  using FieldMetadata_Ptr =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KmallocNodeFtraceEvent>;
 
+  static constexpr FieldMetadata_Ptr kPtr{};
+  void set_ptr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ptr::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
 
-class LwisTracingMarkWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class KmallocFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  LwisTracingMarkWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit LwisTracingMarkWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit LwisTracingMarkWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_lwis_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars lwis_name() const { return at<1>().as_string(); }
-  bool has_type() const { return at<2>().valid(); }
-  uint32_t type() const { return at<2>().as_uint32(); }
-  bool has_pid() const { return at<3>().valid(); }
-  int32_t pid() const { return at<3>().as_int32(); }
-  bool has_func_name() const { return at<4>().valid(); }
-  ::protozero::ConstChars func_name() const { return at<4>().as_string(); }
-  bool has_value() const { return at<5>().valid(); }
-  int64_t value() const { return at<5>().as_int64(); }
+  KmallocFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KmallocFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KmallocFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_bytes_alloc() const { return at<1>().valid(); }
+  uint64_t bytes_alloc() const { return at<1>().as_uint64(); }
+  bool has_bytes_req() const { return at<2>().valid(); }
+  uint64_t bytes_req() const { return at<2>().as_uint64(); }
+  bool has_call_site() const { return at<3>().valid(); }
+  uint64_t call_site() const { return at<3>().as_uint64(); }
+  bool has_gfp_flags() const { return at<4>().valid(); }
+  uint32_t gfp_flags() const { return at<4>().as_uint32(); }
+  bool has_ptr() const { return at<5>().valid(); }
+  uint64_t ptr() const { return at<5>().as_uint64(); }
 };
 
-class LwisTracingMarkWriteFtraceEvent : public ::protozero::Message {
+class KmallocFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = LwisTracingMarkWriteFtraceEvent_Decoder;
+  using Decoder = KmallocFtraceEvent_Decoder;
   enum : int32_t {
-    kLwisNameFieldNumber = 1,
-    kTypeFieldNumber = 2,
-    kPidFieldNumber = 3,
-    kFuncNameFieldNumber = 4,
-    kValueFieldNumber = 5,
+    kBytesAllocFieldNumber = 1,
+    kBytesReqFieldNumber = 2,
+    kCallSiteFieldNumber = 3,
+    kGfpFlagsFieldNumber = 4,
+    kPtrFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.LwisTracingMarkWriteFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.KmallocFtraceEvent"; }
 
 
-  using FieldMetadata_LwisName =
+  using FieldMetadata_BytesAlloc =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      LwisTracingMarkWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KmallocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LwisName kLwisName() { return {}; }
-  void set_lwis_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_LwisName::kFieldId, data, size);
-  }
-  void set_lwis_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_LwisName::kFieldId, chars.data, chars.size);
-  }
-  void set_lwis_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_LwisName::kFieldId;
+  static constexpr FieldMetadata_BytesAlloc kBytesAlloc{};
+  void set_bytes_alloc(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BytesAlloc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Type =
+  using FieldMetadata_BytesReq =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      LwisTracingMarkWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KmallocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+  static constexpr FieldMetadata_BytesReq kBytesReq{};
+  void set_bytes_req(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BytesReq::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_CallSite =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      LwisTracingMarkWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KmallocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_CallSite kCallSite{};
+  void set_call_site(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CallSite::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FuncName =
+  using FieldMetadata_GfpFlags =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      LwisTracingMarkWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KmallocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FuncName kFuncName() { return {}; }
-  void set_func_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_FuncName::kFieldId, data, size);
-  }
-  void set_func_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_FuncName::kFieldId, chars.data, chars.size);
-  }
-  void set_func_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_FuncName::kFieldId;
+  static constexpr FieldMetadata_GfpFlags kGfpFlags{};
+  void set_gfp_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Value =
+  using FieldMetadata_Ptr =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      LwisTracingMarkWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KmallocFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+  static constexpr FieldMetadata_Ptr kPtr{};
+  void set_ptr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ptr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/mali.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_MALI_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_MALI_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class MaliMaliKCPUFENCEWAITENDFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class KfreeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  MaliMaliKCPUFENCEWAITENDFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MaliMaliKCPUFENCEWAITENDFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MaliMaliKCPUFENCEWAITENDFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_info_val1() const { return at<1>().valid(); }
-  uint64_t info_val1() const { return at<1>().as_uint64(); }
-  bool has_info_val2() const { return at<2>().valid(); }
-  uint64_t info_val2() const { return at<2>().as_uint64(); }
-  bool has_kctx_tgid() const { return at<3>().valid(); }
-  int32_t kctx_tgid() const { return at<3>().as_int32(); }
-  bool has_kctx_id() const { return at<4>().valid(); }
-  uint32_t kctx_id() const { return at<4>().as_uint32(); }
-  bool has_id() const { return at<5>().valid(); }
-  uint32_t id() const { return at<5>().as_uint32(); }
+  KfreeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KfreeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KfreeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_call_site() const { return at<1>().valid(); }
+  uint64_t call_site() const { return at<1>().as_uint64(); }
+  bool has_ptr() const { return at<2>().valid(); }
+  uint64_t ptr() const { return at<2>().as_uint64(); }
 };
 
-class MaliMaliKCPUFENCEWAITENDFtraceEvent : public ::protozero::Message {
+class KfreeFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MaliMaliKCPUFENCEWAITENDFtraceEvent_Decoder;
+  using Decoder = KfreeFtraceEvent_Decoder;
   enum : int32_t {
-    kInfoVal1FieldNumber = 1,
-    kInfoVal2FieldNumber = 2,
-    kKctxTgidFieldNumber = 3,
-    kKctxIdFieldNumber = 4,
-    kIdFieldNumber = 5,
+    kCallSiteFieldNumber = 1,
+    kPtrFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliKCPUFENCEWAITENDFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.KfreeFtraceEvent"; }
 
 
-  using FieldMetadata_InfoVal1 =
+  using FieldMetadata_CallSite =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MaliMaliKCPUFENCEWAITENDFtraceEvent>;
+      KfreeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InfoVal1 kInfoVal1() { return {}; }
-  void set_info_val1(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_InfoVal1::kFieldId;
+  static constexpr FieldMetadata_CallSite kCallSite{};
+  void set_call_site(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CallSite::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -111611,155 +139511,115 @@ class MaliMaliKCPUFENCEWAITENDFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_InfoVal2 =
+  using FieldMetadata_Ptr =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MaliMaliKCPUFENCEWAITENDFtraceEvent>;
+      KfreeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InfoVal2 kInfoVal2() { return {}; }
-  void set_info_val2(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_InfoVal2::kFieldId;
+  static constexpr FieldMetadata_Ptr kPtr{};
+  void set_ptr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ptr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_KctxTgid =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MaliMaliKCPUFENCEWAITENDFtraceEvent>;
+class IonSecureCmaShrinkPoolStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  IonSecureCmaShrinkPoolStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IonSecureCmaShrinkPoolStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IonSecureCmaShrinkPoolStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_drained_size() const { return at<1>().valid(); }
+  uint64_t drained_size() const { return at<1>().as_uint64(); }
+  bool has_skipped_size() const { return at<2>().valid(); }
+  uint64_t skipped_size() const { return at<2>().as_uint64(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KctxTgid kKctxTgid() { return {}; }
-  void set_kctx_tgid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+class IonSecureCmaShrinkPoolStartFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = IonSecureCmaShrinkPoolStartFtraceEvent_Decoder;
+  enum : int32_t {
+    kDrainedSizeFieldNumber = 1,
+    kSkippedSizeFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.IonSecureCmaShrinkPoolStartFtraceEvent"; }
 
-  using FieldMetadata_KctxId =
+
+  using FieldMetadata_DrainedSize =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MaliMaliKCPUFENCEWAITENDFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IonSecureCmaShrinkPoolStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KctxId kKctxId() { return {}; }
-  void set_kctx_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
+  static constexpr FieldMetadata_DrainedSize kDrainedSize{};
+  void set_drained_size(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DrainedSize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Id =
+  using FieldMetadata_SkippedSize =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MaliMaliKCPUFENCEWAITENDFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IonSecureCmaShrinkPoolStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
-  void set_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+  static constexpr FieldMetadata_SkippedSize kSkippedSize{};
+  void set_skipped_size(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SkippedSize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class MaliMaliKCPUFENCEWAITSTARTFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class IonSecureCmaShrinkPoolEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  MaliMaliKCPUFENCEWAITSTARTFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MaliMaliKCPUFENCEWAITSTARTFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MaliMaliKCPUFENCEWAITSTARTFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_info_val1() const { return at<1>().valid(); }
-  uint64_t info_val1() const { return at<1>().as_uint64(); }
-  bool has_info_val2() const { return at<2>().valid(); }
-  uint64_t info_val2() const { return at<2>().as_uint64(); }
-  bool has_kctx_tgid() const { return at<3>().valid(); }
-  int32_t kctx_tgid() const { return at<3>().as_int32(); }
-  bool has_kctx_id() const { return at<4>().valid(); }
-  uint32_t kctx_id() const { return at<4>().as_uint32(); }
-  bool has_id() const { return at<5>().valid(); }
-  uint32_t id() const { return at<5>().as_uint32(); }
+  IonSecureCmaShrinkPoolEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IonSecureCmaShrinkPoolEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IonSecureCmaShrinkPoolEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_drained_size() const { return at<1>().valid(); }
+  uint64_t drained_size() const { return at<1>().as_uint64(); }
+  bool has_skipped_size() const { return at<2>().valid(); }
+  uint64_t skipped_size() const { return at<2>().as_uint64(); }
 };
 
-class MaliMaliKCPUFENCEWAITSTARTFtraceEvent : public ::protozero::Message {
+class IonSecureCmaShrinkPoolEndFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MaliMaliKCPUFENCEWAITSTARTFtraceEvent_Decoder;
+  using Decoder = IonSecureCmaShrinkPoolEndFtraceEvent_Decoder;
   enum : int32_t {
-    kInfoVal1FieldNumber = 1,
-    kInfoVal2FieldNumber = 2,
-    kKctxTgidFieldNumber = 3,
-    kKctxIdFieldNumber = 4,
-    kIdFieldNumber = 5,
+    kDrainedSizeFieldNumber = 1,
+    kSkippedSizeFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliKCPUFENCEWAITSTARTFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.IonSecureCmaShrinkPoolEndFtraceEvent"; }
 
 
-  using FieldMetadata_InfoVal1 =
+  using FieldMetadata_DrainedSize =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MaliMaliKCPUFENCEWAITSTARTFtraceEvent>;
+      IonSecureCmaShrinkPoolEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InfoVal1 kInfoVal1() { return {}; }
-  void set_info_val1(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_InfoVal1::kFieldId;
+  static constexpr FieldMetadata_DrainedSize kDrainedSize{};
+  void set_drained_size(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DrainedSize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -111767,155 +139627,169 @@ class MaliMaliKCPUFENCEWAITSTARTFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_InfoVal2 =
+  using FieldMetadata_SkippedSize =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MaliMaliKCPUFENCEWAITSTARTFtraceEvent>;
+      IonSecureCmaShrinkPoolEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InfoVal2 kInfoVal2() { return {}; }
-  void set_info_val2(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_InfoVal2::kFieldId;
+  static constexpr FieldMetadata_SkippedSize kSkippedSize{};
+  void set_skipped_size(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SkippedSize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_KctxTgid =
+class IonSecureCmaAllocateStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  IonSecureCmaAllocateStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IonSecureCmaAllocateStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IonSecureCmaAllocateStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_align() const { return at<1>().valid(); }
+  uint64_t align() const { return at<1>().as_uint64(); }
+  bool has_flags() const { return at<2>().valid(); }
+  uint64_t flags() const { return at<2>().as_uint64(); }
+  bool has_heap_name() const { return at<3>().valid(); }
+  ::protozero::ConstChars heap_name() const { return at<3>().as_string(); }
+  bool has_len() const { return at<4>().valid(); }
+  uint64_t len() const { return at<4>().as_uint64(); }
+};
+
+class IonSecureCmaAllocateStartFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = IonSecureCmaAllocateStartFtraceEvent_Decoder;
+  enum : int32_t {
+    kAlignFieldNumber = 1,
+    kFlagsFieldNumber = 2,
+    kHeapNameFieldNumber = 3,
+    kLenFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.IonSecureCmaAllocateStartFtraceEvent"; }
+
+
+  using FieldMetadata_Align =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MaliMaliKCPUFENCEWAITSTARTFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IonSecureCmaAllocateStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KctxTgid kKctxTgid() { return {}; }
-  void set_kctx_tgid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
+  static constexpr FieldMetadata_Align kAlign{};
+  void set_align(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Align::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_KctxId =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MaliMaliKCPUFENCEWAITSTARTFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IonSecureCmaAllocateStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KctxId kKctxId() { return {}; }
-  void set_kctx_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Id =
+  using FieldMetadata_HeapName =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MaliMaliKCPUFENCEWAITSTARTFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      IonSecureCmaAllocateStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
-  void set_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+  static constexpr FieldMetadata_HeapName kHeapName{};
+  void set_heap_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_HeapName::kFieldId, data, size);
+  }
+  void set_heap_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size);
+  }
+  void set_heap_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Len =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IonSecureCmaAllocateStartFtraceEvent>;
+
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class MaliMaliKCPUFENCESIGNALFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class IonSecureCmaAllocateEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  MaliMaliKCPUFENCESIGNALFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MaliMaliKCPUFENCESIGNALFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MaliMaliKCPUFENCESIGNALFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_info_val1() const { return at<1>().valid(); }
-  uint64_t info_val1() const { return at<1>().as_uint64(); }
-  bool has_info_val2() const { return at<2>().valid(); }
-  uint64_t info_val2() const { return at<2>().as_uint64(); }
-  bool has_kctx_tgid() const { return at<3>().valid(); }
-  int32_t kctx_tgid() const { return at<3>().as_int32(); }
-  bool has_kctx_id() const { return at<4>().valid(); }
-  uint32_t kctx_id() const { return at<4>().as_uint32(); }
-  bool has_id() const { return at<5>().valid(); }
-  uint32_t id() const { return at<5>().as_uint32(); }
+  IonSecureCmaAllocateEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IonSecureCmaAllocateEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IonSecureCmaAllocateEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_align() const { return at<1>().valid(); }
+  uint64_t align() const { return at<1>().as_uint64(); }
+  bool has_flags() const { return at<2>().valid(); }
+  uint64_t flags() const { return at<2>().as_uint64(); }
+  bool has_heap_name() const { return at<3>().valid(); }
+  ::protozero::ConstChars heap_name() const { return at<3>().as_string(); }
+  bool has_len() const { return at<4>().valid(); }
+  uint64_t len() const { return at<4>().as_uint64(); }
 };
 
-class MaliMaliKCPUFENCESIGNALFtraceEvent : public ::protozero::Message {
+class IonSecureCmaAllocateEndFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MaliMaliKCPUFENCESIGNALFtraceEvent_Decoder;
+  using Decoder = IonSecureCmaAllocateEndFtraceEvent_Decoder;
   enum : int32_t {
-    kInfoVal1FieldNumber = 1,
-    kInfoVal2FieldNumber = 2,
-    kKctxTgidFieldNumber = 3,
-    kKctxIdFieldNumber = 4,
-    kIdFieldNumber = 5,
+    kAlignFieldNumber = 1,
+    kFlagsFieldNumber = 2,
+    kHeapNameFieldNumber = 3,
+    kLenFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliKCPUFENCESIGNALFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.IonSecureCmaAllocateEndFtraceEvent"; }
 
 
-  using FieldMetadata_InfoVal1 =
+  using FieldMetadata_Align =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MaliMaliKCPUFENCESIGNALFtraceEvent>;
+      IonSecureCmaAllocateEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InfoVal1 kInfoVal1() { return {}; }
-  void set_info_val1(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_InfoVal1::kFieldId;
+  static constexpr FieldMetadata_Align kAlign{};
+  void set_align(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Align::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -111923,24 +139797,17 @@ class MaliMaliKCPUFENCESIGNALFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_InfoVal2 =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MaliMaliKCPUFENCESIGNALFtraceEvent>;
+      IonSecureCmaAllocateEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InfoVal2 kInfoVal2() { return {}; }
-  void set_info_val2(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_InfoVal2::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -111948,130 +139815,84 @@ class MaliMaliKCPUFENCESIGNALFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_KctxTgid =
+  using FieldMetadata_HeapName =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MaliMaliKCPUFENCESIGNALFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      IonSecureCmaAllocateEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KctxTgid kKctxTgid() { return {}; }
-  void set_kctx_tgid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_HeapName kHeapName{};
+  void set_heap_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_HeapName::kFieldId, data, size);
   }
-
-  using FieldMetadata_KctxId =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MaliMaliKCPUFENCESIGNALFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KctxId kKctxId() { return {}; }
-  void set_kctx_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
+  void set_heap_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size);
+  }
+  void set_heap_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Id =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MaliMaliKCPUFENCESIGNALFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IonSecureCmaAllocateEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
-  void set_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class MaliMaliKCPUCQSWAITENDFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class IonSecureCmaAddToPoolStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  MaliMaliKCPUCQSWAITENDFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MaliMaliKCPUCQSWAITENDFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MaliMaliKCPUCQSWAITENDFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_id() const { return at<1>().valid(); }
-  uint32_t id() const { return at<1>().as_uint32(); }
-  bool has_info_val1() const { return at<2>().valid(); }
-  uint64_t info_val1() const { return at<2>().as_uint64(); }
-  bool has_info_val2() const { return at<3>().valid(); }
-  uint64_t info_val2() const { return at<3>().as_uint64(); }
-  bool has_kctx_id() const { return at<4>().valid(); }
-  uint32_t kctx_id() const { return at<4>().as_uint32(); }
-  bool has_kctx_tgid() const { return at<5>().valid(); }
-  int32_t kctx_tgid() const { return at<5>().as_int32(); }
+  IonSecureCmaAddToPoolStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IonSecureCmaAddToPoolStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IonSecureCmaAddToPoolStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_is_prefetch() const { return at<1>().valid(); }
+  uint32_t is_prefetch() const { return at<1>().as_uint32(); }
+  bool has_len() const { return at<2>().valid(); }
+  uint64_t len() const { return at<2>().as_uint64(); }
+  bool has_pool_total() const { return at<3>().valid(); }
+  int32_t pool_total() const { return at<3>().as_int32(); }
 };
 
-class MaliMaliKCPUCQSWAITENDFtraceEvent : public ::protozero::Message {
+class IonSecureCmaAddToPoolStartFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MaliMaliKCPUCQSWAITENDFtraceEvent_Decoder;
+  using Decoder = IonSecureCmaAddToPoolStartFtraceEvent_Decoder;
   enum : int32_t {
-    kIdFieldNumber = 1,
-    kInfoVal1FieldNumber = 2,
-    kInfoVal2FieldNumber = 3,
-    kKctxIdFieldNumber = 4,
-    kKctxTgidFieldNumber = 5,
+    kIsPrefetchFieldNumber = 1,
+    kLenFieldNumber = 2,
+    kPoolTotalFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliKCPUCQSWAITENDFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.IonSecureCmaAddToPoolStartFtraceEvent"; }
 
 
-  using FieldMetadata_Id =
+  using FieldMetadata_IsPrefetch =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MaliMaliKCPUCQSWAITENDFtraceEvent>;
+      IonSecureCmaAddToPoolStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
-  void set_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+  static constexpr FieldMetadata_IsPrefetch kIsPrefetch{};
+  void set_is_prefetch(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsPrefetch::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -112079,24 +139900,17 @@ class MaliMaliKCPUCQSWAITENDFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_InfoVal1 =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MaliMaliKCPUCQSWAITENDFtraceEvent>;
+      IonSecureCmaAddToPoolStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InfoVal1 kInfoVal1() { return {}; }
-  void set_info_val1(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_InfoVal1::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -112104,49 +139918,60 @@ class MaliMaliKCPUCQSWAITENDFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_InfoVal2 =
+  using FieldMetadata_PoolTotal =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MaliMaliKCPUCQSWAITENDFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      IonSecureCmaAddToPoolStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InfoVal2 kInfoVal2() { return {}; }
-  void set_info_val2(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_InfoVal2::kFieldId;
+  static constexpr FieldMetadata_PoolTotal kPoolTotal{};
+  void set_pool_total(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PoolTotal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_KctxId =
+class IonSecureCmaAddToPoolEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  IonSecureCmaAddToPoolEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IonSecureCmaAddToPoolEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IonSecureCmaAddToPoolEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_is_prefetch() const { return at<1>().valid(); }
+  uint32_t is_prefetch() const { return at<1>().as_uint32(); }
+  bool has_len() const { return at<2>().valid(); }
+  uint64_t len() const { return at<2>().as_uint64(); }
+  bool has_pool_total() const { return at<3>().valid(); }
+  int32_t pool_total() const { return at<3>().as_int32(); }
+};
+
+class IonSecureCmaAddToPoolEndFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = IonSecureCmaAddToPoolEndFtraceEvent_Decoder;
+  enum : int32_t {
+    kIsPrefetchFieldNumber = 1,
+    kLenFieldNumber = 2,
+    kPoolTotalFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.IonSecureCmaAddToPoolEndFtraceEvent"; }
+
+
+  using FieldMetadata_IsPrefetch =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MaliMaliKCPUCQSWAITENDFtraceEvent>;
+      IonSecureCmaAddToPoolEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KctxId kKctxId() { return {}; }
-  void set_kctx_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
+  static constexpr FieldMetadata_IsPrefetch kIsPrefetch{};
+  void set_is_prefetch(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsPrefetch::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -112154,24 +139979,35 @@ class MaliMaliKCPUCQSWAITENDFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_KctxTgid =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IonSecureCmaAddToPoolEndFtraceEvent>;
+
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PoolTotal =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      MaliMaliKCPUCQSWAITENDFtraceEvent>;
+      IonSecureCmaAddToPoolEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KctxTgid kKctxTgid() { return {}; }
-  void set_kctx_tgid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
+  static constexpr FieldMetadata_PoolTotal kPoolTotal{};
+  void set_pool_total(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PoolTotal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -112180,79 +140016,81 @@ class MaliMaliKCPUCQSWAITENDFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MaliMaliKCPUCQSWAITSTARTFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class IonPrefetchingFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  MaliMaliKCPUCQSWAITSTARTFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MaliMaliKCPUCQSWAITSTARTFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MaliMaliKCPUCQSWAITSTARTFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_id() const { return at<1>().valid(); }
-  uint32_t id() const { return at<1>().as_uint32(); }
-  bool has_info_val1() const { return at<2>().valid(); }
-  uint64_t info_val1() const { return at<2>().as_uint64(); }
-  bool has_info_val2() const { return at<3>().valid(); }
-  uint64_t info_val2() const { return at<3>().as_uint64(); }
-  bool has_kctx_id() const { return at<4>().valid(); }
-  uint32_t kctx_id() const { return at<4>().as_uint32(); }
-  bool has_kctx_tgid() const { return at<5>().valid(); }
-  int32_t kctx_tgid() const { return at<5>().as_int32(); }
+  IonPrefetchingFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IonPrefetchingFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IonPrefetchingFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_len() const { return at<1>().valid(); }
+  uint64_t len() const { return at<1>().as_uint64(); }
 };
 
-class MaliMaliKCPUCQSWAITSTARTFtraceEvent : public ::protozero::Message {
+class IonPrefetchingFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MaliMaliKCPUCQSWAITSTARTFtraceEvent_Decoder;
+  using Decoder = IonPrefetchingFtraceEvent_Decoder;
   enum : int32_t {
-    kIdFieldNumber = 1,
-    kInfoVal1FieldNumber = 2,
-    kInfoVal2FieldNumber = 3,
-    kKctxIdFieldNumber = 4,
-    kKctxTgidFieldNumber = 5,
+    kLenFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliKCPUCQSWAITSTARTFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.IonPrefetchingFtraceEvent"; }
 
 
-  using FieldMetadata_Id =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MaliMaliKCPUCQSWAITSTARTFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IonPrefetchingFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
-  void set_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_InfoVal1 =
+class IonCpSecureBufferStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  IonCpSecureBufferStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IonCpSecureBufferStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IonCpSecureBufferStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_align() const { return at<1>().valid(); }
+  uint64_t align() const { return at<1>().as_uint64(); }
+  bool has_flags() const { return at<2>().valid(); }
+  uint64_t flags() const { return at<2>().as_uint64(); }
+  bool has_heap_name() const { return at<3>().valid(); }
+  ::protozero::ConstChars heap_name() const { return at<3>().as_string(); }
+  bool has_len() const { return at<4>().valid(); }
+  uint64_t len() const { return at<4>().as_uint64(); }
+};
+
+class IonCpSecureBufferStartFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = IonCpSecureBufferStartFtraceEvent_Decoder;
+  enum : int32_t {
+    kAlignFieldNumber = 1,
+    kFlagsFieldNumber = 2,
+    kHeapNameFieldNumber = 3,
+    kLenFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.IonCpSecureBufferStartFtraceEvent"; }
+
+
+  using FieldMetadata_Align =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MaliMaliKCPUCQSWAITSTARTFtraceEvent>;
+      IonCpSecureBufferStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InfoVal1 kInfoVal1() { return {}; }
-  void set_info_val1(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_InfoVal1::kFieldId;
+  static constexpr FieldMetadata_Align kAlign{};
+  void set_align(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Align::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -112260,24 +140098,17 @@ class MaliMaliKCPUCQSWAITSTARTFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_InfoVal2 =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MaliMaliKCPUCQSWAITSTARTFtraceEvent>;
+      IonCpSecureBufferStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InfoVal2 kInfoVal2() { return {}; }
-  void set_info_val2(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_InfoVal2::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -112285,130 +140116,105 @@ class MaliMaliKCPUCQSWAITSTARTFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_KctxId =
+  using FieldMetadata_HeapName =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MaliMaliKCPUCQSWAITSTARTFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      IonCpSecureBufferStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KctxId kKctxId() { return {}; }
-  void set_kctx_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
+  static constexpr FieldMetadata_HeapName kHeapName{};
+  void set_heap_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_HeapName::kFieldId, data, size);
+  }
+  void set_heap_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size);
+  }
+  void set_heap_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_KctxTgid =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MaliMaliKCPUCQSWAITSTARTFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IonCpSecureBufferStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KctxTgid kKctxTgid() { return {}; }
-  void set_kctx_tgid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class MaliMaliKCPUCQSSETFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class IonCpSecureBufferEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  MaliMaliKCPUCQSSETFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MaliMaliKCPUCQSSETFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MaliMaliKCPUCQSSETFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_id() const { return at<1>().valid(); }
-  uint32_t id() const { return at<1>().as_uint32(); }
-  bool has_info_val1() const { return at<2>().valid(); }
-  uint64_t info_val1() const { return at<2>().as_uint64(); }
-  bool has_info_val2() const { return at<3>().valid(); }
-  uint64_t info_val2() const { return at<3>().as_uint64(); }
-  bool has_kctx_id() const { return at<4>().valid(); }
-  uint32_t kctx_id() const { return at<4>().as_uint32(); }
-  bool has_kctx_tgid() const { return at<5>().valid(); }
-  int32_t kctx_tgid() const { return at<5>().as_int32(); }
+  IonCpSecureBufferEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IonCpSecureBufferEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IonCpSecureBufferEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_align() const { return at<1>().valid(); }
+  uint64_t align() const { return at<1>().as_uint64(); }
+  bool has_flags() const { return at<2>().valid(); }
+  uint64_t flags() const { return at<2>().as_uint64(); }
+  bool has_heap_name() const { return at<3>().valid(); }
+  ::protozero::ConstChars heap_name() const { return at<3>().as_string(); }
+  bool has_len() const { return at<4>().valid(); }
+  uint64_t len() const { return at<4>().as_uint64(); }
 };
 
-class MaliMaliKCPUCQSSETFtraceEvent : public ::protozero::Message {
+class IonCpSecureBufferEndFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MaliMaliKCPUCQSSETFtraceEvent_Decoder;
+  using Decoder = IonCpSecureBufferEndFtraceEvent_Decoder;
   enum : int32_t {
-    kIdFieldNumber = 1,
-    kInfoVal1FieldNumber = 2,
-    kInfoVal2FieldNumber = 3,
-    kKctxIdFieldNumber = 4,
-    kKctxTgidFieldNumber = 5,
+    kAlignFieldNumber = 1,
+    kFlagsFieldNumber = 2,
+    kHeapNameFieldNumber = 3,
+    kLenFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliKCPUCQSSETFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.IonCpSecureBufferEndFtraceEvent"; }
 
 
-  using FieldMetadata_Id =
+  using FieldMetadata_Align =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MaliMaliKCPUCQSSETFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IonCpSecureBufferEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
-  void set_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+  static constexpr FieldMetadata_Align kAlign{};
+  void set_align(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Align::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_InfoVal1 =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MaliMaliKCPUCQSSETFtraceEvent>;
+      IonCpSecureBufferEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InfoVal1 kInfoVal1() { return {}; }
-  void set_info_val1(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_InfoVal1::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -112416,74 +140222,78 @@ class MaliMaliKCPUCQSSETFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_InfoVal2 =
+  using FieldMetadata_HeapName =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MaliMaliKCPUCQSSETFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      IonCpSecureBufferEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InfoVal2 kInfoVal2() { return {}; }
-  void set_info_val2(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_InfoVal2::kFieldId;
+  static constexpr FieldMetadata_HeapName kHeapName{};
+  void set_heap_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_HeapName::kFieldId, data, size);
+  }
+  void set_heap_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size);
+  }
+  void set_heap_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_KctxId =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MaliMaliKCPUCQSSETFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IonCpSecureBufferEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KctxId kKctxId() { return {}; }
-  void set_kctx_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_KctxTgid =
+class IonCpAllocRetryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  IonCpAllocRetryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IonCpAllocRetryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IonCpAllocRetryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_tries() const { return at<1>().valid(); }
+  int32_t tries() const { return at<1>().as_int32(); }
+};
+
+class IonCpAllocRetryFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = IonCpAllocRetryFtraceEvent_Decoder;
+  enum : int32_t {
+    kTriesFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.IonCpAllocRetryFtraceEvent"; }
+
+
+  using FieldMetadata_Tries =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      MaliMaliKCPUCQSSETFtraceEvent>;
+      IonCpAllocRetryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KctxTgid kKctxTgid() { return {}; }
-  void set_kctx_tgid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
+  static constexpr FieldMetadata_Tries kTries{};
+  void set_tries(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tries::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -112492,57 +140302,53 @@ class MaliMaliKCPUCQSSETFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MaliTracingMarkWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class IonAllocBufferStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  MaliTracingMarkWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MaliTracingMarkWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MaliTracingMarkWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_pid() const { return at<2>().valid(); }
-  int32_t pid() const { return at<2>().as_int32(); }
-  bool has_type() const { return at<3>().valid(); }
-  uint32_t type() const { return at<3>().as_uint32(); }
-  bool has_value() const { return at<4>().valid(); }
-  int32_t value() const { return at<4>().as_int32(); }
+  IonAllocBufferStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IonAllocBufferStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IonAllocBufferStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_client_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars client_name() const { return at<1>().as_string(); }
+  bool has_flags() const { return at<2>().valid(); }
+  uint32_t flags() const { return at<2>().as_uint32(); }
+  bool has_heap_name() const { return at<3>().valid(); }
+  ::protozero::ConstChars heap_name() const { return at<3>().as_string(); }
+  bool has_len() const { return at<4>().valid(); }
+  uint64_t len() const { return at<4>().as_uint64(); }
+  bool has_mask() const { return at<5>().valid(); }
+  uint32_t mask() const { return at<5>().as_uint32(); }
 };
 
-class MaliTracingMarkWriteFtraceEvent : public ::protozero::Message {
+class IonAllocBufferStartFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MaliTracingMarkWriteFtraceEvent_Decoder;
+  using Decoder = IonAllocBufferStartFtraceEvent_Decoder;
   enum : int32_t {
-    kNameFieldNumber = 1,
-    kPidFieldNumber = 2,
-    kTypeFieldNumber = 3,
-    kValueFieldNumber = 4,
+    kClientNameFieldNumber = 1,
+    kFlagsFieldNumber = 2,
+    kHeapNameFieldNumber = 3,
+    kLenFieldNumber = 4,
+    kMaskFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MaliTracingMarkWriteFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.IonAllocBufferStartFtraceEvent"; }
 
 
-  using FieldMetadata_Name =
+  using FieldMetadata_ClientName =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      MaliTracingMarkWriteFtraceEvent>;
+      IonAllocBufferStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  static constexpr FieldMetadata_ClientName kClientName{};
+  void set_client_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ClientName::kFieldId, data, size);
   }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  void set_client_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ClientName::kFieldId, chars.data, chars.size);
   }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  void set_client_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ClientName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -112550,142 +140356,77 @@ class MaliTracingMarkWriteFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MaliTracingMarkWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      IonAllocBufferStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Type =
+  using FieldMetadata_HeapName =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MaliTracingMarkWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      IonAllocBufferStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+  static constexpr FieldMetadata_HeapName kHeapName{};
+  void set_heap_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_HeapName::kFieldId, data, size);
+  }
+  void set_heap_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size);
+  }
+  void set_heap_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Value =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MaliTracingMarkWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IonAllocBufferStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/mdss.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_MDSS_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_MDSS_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class RotatorBwAoAsContextFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  RotatorBwAoAsContextFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit RotatorBwAoAsContextFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit RotatorBwAoAsContextFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_state() const { return at<1>().valid(); }
-  uint32_t state() const { return at<1>().as_uint32(); }
-};
-
-class RotatorBwAoAsContextFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = RotatorBwAoAsContextFtraceEvent_Decoder;
-  enum : int32_t {
-    kStateFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.RotatorBwAoAsContextFtraceEvent"; }
-
-
-  using FieldMetadata_State =
+  using FieldMetadata_Mask =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      RotatorBwAoAsContextFtraceEvent>;
+      IonAllocBufferStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_State kState() { return {}; }
-  void set_state(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
+  static constexpr FieldMetadata_Mask kMask{};
+  void set_mask(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mask::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -112694,219 +140435,246 @@ class RotatorBwAoAsContextFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MdpPerfUpdateBusFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class IonAllocBufferFallbackFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  MdpPerfUpdateBusFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MdpPerfUpdateBusFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MdpPerfUpdateBusFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_client() const { return at<1>().valid(); }
-  int32_t client() const { return at<1>().as_int32(); }
-  bool has_ab_quota() const { return at<2>().valid(); }
-  uint64_t ab_quota() const { return at<2>().as_uint64(); }
-  bool has_ib_quota() const { return at<3>().valid(); }
-  uint64_t ib_quota() const { return at<3>().as_uint64(); }
+  IonAllocBufferFallbackFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IonAllocBufferFallbackFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IonAllocBufferFallbackFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_client_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars client_name() const { return at<1>().as_string(); }
+  bool has_error() const { return at<2>().valid(); }
+  int64_t error() const { return at<2>().as_int64(); }
+  bool has_flags() const { return at<3>().valid(); }
+  uint32_t flags() const { return at<3>().as_uint32(); }
+  bool has_heap_name() const { return at<4>().valid(); }
+  ::protozero::ConstChars heap_name() const { return at<4>().as_string(); }
+  bool has_len() const { return at<5>().valid(); }
+  uint64_t len() const { return at<5>().as_uint64(); }
+  bool has_mask() const { return at<6>().valid(); }
+  uint32_t mask() const { return at<6>().as_uint32(); }
 };
 
-class MdpPerfUpdateBusFtraceEvent : public ::protozero::Message {
+class IonAllocBufferFallbackFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MdpPerfUpdateBusFtraceEvent_Decoder;
+  using Decoder = IonAllocBufferFallbackFtraceEvent_Decoder;
   enum : int32_t {
-    kClientFieldNumber = 1,
-    kAbQuotaFieldNumber = 2,
-    kIbQuotaFieldNumber = 3,
+    kClientNameFieldNumber = 1,
+    kErrorFieldNumber = 2,
+    kFlagsFieldNumber = 3,
+    kHeapNameFieldNumber = 4,
+    kLenFieldNumber = 5,
+    kMaskFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MdpPerfUpdateBusFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.IonAllocBufferFallbackFtraceEvent"; }
 
 
-  using FieldMetadata_Client =
+  using FieldMetadata_ClientName =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MdpPerfUpdateBusFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      IonAllocBufferFallbackFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Client kClient() { return {}; }
-  void set_client(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Client::kFieldId;
+  static constexpr FieldMetadata_ClientName kClientName{};
+  void set_client_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ClientName::kFieldId, data, size);
+  }
+  void set_client_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ClientName::kFieldId, chars.data, chars.size);
+  }
+  void set_client_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ClientName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_AbQuota =
+  using FieldMetadata_Error =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MdpPerfUpdateBusFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      IonAllocBufferFallbackFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AbQuota kAbQuota() { return {}; }
-  void set_ab_quota(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AbQuota::kFieldId;
+  static constexpr FieldMetadata_Error kError{};
+  void set_error(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IbQuota =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      IonAllocBufferFallbackFtraceEvent>;
+
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_HeapName =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      IonAllocBufferFallbackFtraceEvent>;
+
+  static constexpr FieldMetadata_HeapName kHeapName{};
+  void set_heap_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_HeapName::kFieldId, data, size);
+  }
+  void set_heap_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size);
+  }
+  void set_heap_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Len =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MdpPerfUpdateBusFtraceEvent>;
+      IonAllocBufferFallbackFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IbQuota kIbQuota() { return {}; }
-  void set_ib_quota(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IbQuota::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_Mask =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      IonAllocBufferFallbackFtraceEvent>;
+
+  static constexpr FieldMetadata_Mask kMask{};
+  void set_mask(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mask::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class MdpPerfPrefillCalcFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class IonAllocBufferFailFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  MdpPerfPrefillCalcFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MdpPerfPrefillCalcFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MdpPerfPrefillCalcFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pnum() const { return at<1>().valid(); }
-  uint32_t pnum() const { return at<1>().as_uint32(); }
-  bool has_latency_buf() const { return at<2>().valid(); }
-  uint32_t latency_buf() const { return at<2>().as_uint32(); }
-  bool has_ot() const { return at<3>().valid(); }
-  uint32_t ot() const { return at<3>().as_uint32(); }
-  bool has_y_buf() const { return at<4>().valid(); }
-  uint32_t y_buf() const { return at<4>().as_uint32(); }
-  bool has_y_scaler() const { return at<5>().valid(); }
-  uint32_t y_scaler() const { return at<5>().as_uint32(); }
-  bool has_pp_lines() const { return at<6>().valid(); }
-  uint32_t pp_lines() const { return at<6>().as_uint32(); }
-  bool has_pp_bytes() const { return at<7>().valid(); }
-  uint32_t pp_bytes() const { return at<7>().as_uint32(); }
-  bool has_post_sc() const { return at<8>().valid(); }
-  uint32_t post_sc() const { return at<8>().as_uint32(); }
-  bool has_fbc_bytes() const { return at<9>().valid(); }
-  uint32_t fbc_bytes() const { return at<9>().as_uint32(); }
-  bool has_prefill_bytes() const { return at<10>().valid(); }
-  uint32_t prefill_bytes() const { return at<10>().as_uint32(); }
+  IonAllocBufferFailFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IonAllocBufferFailFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IonAllocBufferFailFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_client_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars client_name() const { return at<1>().as_string(); }
+  bool has_error() const { return at<2>().valid(); }
+  int64_t error() const { return at<2>().as_int64(); }
+  bool has_flags() const { return at<3>().valid(); }
+  uint32_t flags() const { return at<3>().as_uint32(); }
+  bool has_heap_name() const { return at<4>().valid(); }
+  ::protozero::ConstChars heap_name() const { return at<4>().as_string(); }
+  bool has_len() const { return at<5>().valid(); }
+  uint64_t len() const { return at<5>().as_uint64(); }
+  bool has_mask() const { return at<6>().valid(); }
+  uint32_t mask() const { return at<6>().as_uint32(); }
 };
 
-class MdpPerfPrefillCalcFtraceEvent : public ::protozero::Message {
+class IonAllocBufferFailFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MdpPerfPrefillCalcFtraceEvent_Decoder;
+  using Decoder = IonAllocBufferFailFtraceEvent_Decoder;
   enum : int32_t {
-    kPnumFieldNumber = 1,
-    kLatencyBufFieldNumber = 2,
-    kOtFieldNumber = 3,
-    kYBufFieldNumber = 4,
-    kYScalerFieldNumber = 5,
-    kPpLinesFieldNumber = 6,
-    kPpBytesFieldNumber = 7,
-    kPostScFieldNumber = 8,
-    kFbcBytesFieldNumber = 9,
-    kPrefillBytesFieldNumber = 10,
+    kClientNameFieldNumber = 1,
+    kErrorFieldNumber = 2,
+    kFlagsFieldNumber = 3,
+    kHeapNameFieldNumber = 4,
+    kLenFieldNumber = 5,
+    kMaskFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MdpPerfPrefillCalcFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.IonAllocBufferFailFtraceEvent"; }
 
 
-  using FieldMetadata_Pnum =
+  using FieldMetadata_ClientName =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpPerfPrefillCalcFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      IonAllocBufferFailFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pnum kPnum() { return {}; }
-  void set_pnum(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pnum::kFieldId;
+  static constexpr FieldMetadata_ClientName kClientName{};
+  void set_client_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ClientName::kFieldId, data, size);
+  }
+  void set_client_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ClientName::kFieldId, chars.data, chars.size);
+  }
+  void set_client_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ClientName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_LatencyBuf =
+  using FieldMetadata_Error =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpPerfPrefillCalcFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      IonAllocBufferFailFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LatencyBuf kLatencyBuf() { return {}; }
-  void set_latency_buf(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LatencyBuf::kFieldId;
+  static constexpr FieldMetadata_Error kError{};
+  void set_error(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ot =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpPerfPrefillCalcFtraceEvent>;
+      IonAllocBufferFailFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ot kOt() { return {}; }
-  void set_ot(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ot::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -112914,124 +140682,132 @@ class MdpPerfPrefillCalcFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_YBuf =
+  using FieldMetadata_HeapName =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpPerfPrefillCalcFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      IonAllocBufferFailFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_YBuf kYBuf() { return {}; }
-  void set_y_buf(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_YBuf::kFieldId;
+  static constexpr FieldMetadata_HeapName kHeapName{};
+  void set_heap_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_HeapName::kFieldId, data, size);
+  }
+  void set_heap_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size);
+  }
+  void set_heap_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_YScaler =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpPerfPrefillCalcFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IonAllocBufferFailFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_YScaler kYScaler() { return {}; }
-  void set_y_scaler(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_YScaler::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PpLines =
+  using FieldMetadata_Mask =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpPerfPrefillCalcFtraceEvent>;
+      IonAllocBufferFailFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PpLines kPpLines() { return {}; }
-  void set_pp_lines(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PpLines::kFieldId;
+  static constexpr FieldMetadata_Mask kMask{};
+  void set_mask(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mask::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_PpBytes =
+class IonAllocBufferEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  IonAllocBufferEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IonAllocBufferEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IonAllocBufferEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_client_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars client_name() const { return at<1>().as_string(); }
+  bool has_flags() const { return at<2>().valid(); }
+  uint32_t flags() const { return at<2>().as_uint32(); }
+  bool has_heap_name() const { return at<3>().valid(); }
+  ::protozero::ConstChars heap_name() const { return at<3>().as_string(); }
+  bool has_len() const { return at<4>().valid(); }
+  uint64_t len() const { return at<4>().as_uint64(); }
+  bool has_mask() const { return at<5>().valid(); }
+  uint32_t mask() const { return at<5>().as_uint32(); }
+};
+
+class IonAllocBufferEndFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = IonAllocBufferEndFtraceEvent_Decoder;
+  enum : int32_t {
+    kClientNameFieldNumber = 1,
+    kFlagsFieldNumber = 2,
+    kHeapNameFieldNumber = 3,
+    kLenFieldNumber = 4,
+    kMaskFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.IonAllocBufferEndFtraceEvent"; }
+
+
+  using FieldMetadata_ClientName =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpPerfPrefillCalcFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      IonAllocBufferEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PpBytes kPpBytes() { return {}; }
-  void set_pp_bytes(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PpBytes::kFieldId;
+  static constexpr FieldMetadata_ClientName kClientName{};
+  void set_client_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ClientName::kFieldId, data, size);
+  }
+  void set_client_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ClientName::kFieldId, chars.data, chars.size);
+  }
+  void set_client_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ClientName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PostSc =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpPerfPrefillCalcFtraceEvent>;
+      IonAllocBufferEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PostSc kPostSc() { return {}; }
-  void set_post_sc(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PostSc::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -113039,49 +140815,59 @@ class MdpPerfPrefillCalcFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FbcBytes =
+  using FieldMetadata_HeapName =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpPerfPrefillCalcFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      IonAllocBufferEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FbcBytes kFbcBytes() { return {}; }
-  void set_fbc_bytes(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FbcBytes::kFieldId;
+  static constexpr FieldMetadata_HeapName kHeapName{};
+  void set_heap_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_HeapName::kFieldId, data, size);
+  }
+  void set_heap_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size);
+  }
+  void set_heap_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PrefillBytes =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IonAllocBufferEndFtraceEvent>;
+
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Mask =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpPerfPrefillCalcFtraceEvent>;
+      IonAllocBufferEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PrefillBytes kPrefillBytes() { return {}; }
-  void set_prefill_bytes(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PrefillBytes::kFieldId;
+  static constexpr FieldMetadata_Mask kMask{};
+  void set_mask(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mask::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -113090,117 +140876,83 @@ class MdpPerfPrefillCalcFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MdpCmdWaitPingpongFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class IommuSecPtblMapRangeStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  MdpCmdWaitPingpongFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MdpCmdWaitPingpongFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MdpCmdWaitPingpongFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_ctl_num() const { return at<1>().valid(); }
-  uint32_t ctl_num() const { return at<1>().as_uint32(); }
-  bool has_kickoff_cnt() const { return at<2>().valid(); }
-  int32_t kickoff_cnt() const { return at<2>().as_int32(); }
+  IommuSecPtblMapRangeStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IommuSecPtblMapRangeStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IommuSecPtblMapRangeStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_len() const { return at<1>().valid(); }
+  uint64_t len() const { return at<1>().as_uint64(); }
+  bool has_num() const { return at<2>().valid(); }
+  int32_t num() const { return at<2>().as_int32(); }
+  bool has_pa() const { return at<3>().valid(); }
+  uint32_t pa() const { return at<3>().as_uint32(); }
+  bool has_sec_id() const { return at<4>().valid(); }
+  int32_t sec_id() const { return at<4>().as_int32(); }
+  bool has_va() const { return at<5>().valid(); }
+  uint64_t va() const { return at<5>().as_uint64(); }
 };
 
-class MdpCmdWaitPingpongFtraceEvent : public ::protozero::Message {
+class IommuSecPtblMapRangeStartFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MdpCmdWaitPingpongFtraceEvent_Decoder;
+  using Decoder = IommuSecPtblMapRangeStartFtraceEvent_Decoder;
   enum : int32_t {
-    kCtlNumFieldNumber = 1,
-    kKickoffCntFieldNumber = 2,
+    kLenFieldNumber = 1,
+    kNumFieldNumber = 2,
+    kPaFieldNumber = 3,
+    kSecIdFieldNumber = 4,
+    kVaFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MdpCmdWaitPingpongFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.IommuSecPtblMapRangeStartFtraceEvent"; }
 
 
-  using FieldMetadata_CtlNum =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpCmdWaitPingpongFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IommuSecPtblMapRangeStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CtlNum kCtlNum() { return {}; }
-  void set_ctl_num(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CtlNum::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_KickoffCnt =
+  using FieldMetadata_Num =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      MdpCmdWaitPingpongFtraceEvent>;
+      IommuSecPtblMapRangeStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KickoffCnt kKickoffCnt() { return {}; }
-  void set_kickoff_cnt(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_KickoffCnt::kFieldId;
+  static constexpr FieldMetadata_Num kNum{};
+  void set_num(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Num::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-class MdpVideoUnderrunDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  MdpVideoUnderrunDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MdpVideoUnderrunDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MdpVideoUnderrunDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_ctl_num() const { return at<1>().valid(); }
-  uint32_t ctl_num() const { return at<1>().as_uint32(); }
-  bool has_underrun_cnt() const { return at<2>().valid(); }
-  uint32_t underrun_cnt() const { return at<2>().as_uint32(); }
-};
-
-class MdpVideoUnderrunDoneFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = MdpVideoUnderrunDoneFtraceEvent_Decoder;
-  enum : int32_t {
-    kCtlNumFieldNumber = 1,
-    kUnderrunCntFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.MdpVideoUnderrunDoneFtraceEvent"; }
 
-
-  using FieldMetadata_CtlNum =
+  using FieldMetadata_Pa =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpVideoUnderrunDoneFtraceEvent>;
+      IommuSecPtblMapRangeStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CtlNum kCtlNum() { return {}; }
-  void set_ctl_num(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CtlNum::kFieldId;
+  static constexpr FieldMetadata_Pa kPa{};
+  void set_pa(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pa::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -113208,139 +140960,120 @@ class MdpVideoUnderrunDoneFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_UnderrunCnt =
+  using FieldMetadata_SecId =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpVideoUnderrunDoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      IommuSecPtblMapRangeStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UnderrunCnt kUnderrunCnt() { return {}; }
-  void set_underrun_cnt(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_UnderrunCnt::kFieldId;
+  static constexpr FieldMetadata_SecId kSecId{};
+  void set_sec_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SecId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Va =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IommuSecPtblMapRangeStartFtraceEvent>;
+
+  static constexpr FieldMetadata_Va kVa{};
+  void set_va(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Va::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class MdpPerfSetWmLevelsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class IommuSecPtblMapRangeEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  MdpPerfSetWmLevelsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MdpPerfSetWmLevelsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MdpPerfSetWmLevelsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pnum() const { return at<1>().valid(); }
-  uint32_t pnum() const { return at<1>().as_uint32(); }
-  bool has_use_space() const { return at<2>().valid(); }
-  uint32_t use_space() const { return at<2>().as_uint32(); }
-  bool has_priority_bytes() const { return at<3>().valid(); }
-  uint32_t priority_bytes() const { return at<3>().as_uint32(); }
-  bool has_wm0() const { return at<4>().valid(); }
-  uint32_t wm0() const { return at<4>().as_uint32(); }
-  bool has_wm1() const { return at<5>().valid(); }
-  uint32_t wm1() const { return at<5>().as_uint32(); }
-  bool has_wm2() const { return at<6>().valid(); }
-  uint32_t wm2() const { return at<6>().as_uint32(); }
-  bool has_mb_cnt() const { return at<7>().valid(); }
-  uint32_t mb_cnt() const { return at<7>().as_uint32(); }
-  bool has_mb_size() const { return at<8>().valid(); }
-  uint32_t mb_size() const { return at<8>().as_uint32(); }
+  IommuSecPtblMapRangeEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IommuSecPtblMapRangeEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IommuSecPtblMapRangeEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_len() const { return at<1>().valid(); }
+  uint64_t len() const { return at<1>().as_uint64(); }
+  bool has_num() const { return at<2>().valid(); }
+  int32_t num() const { return at<2>().as_int32(); }
+  bool has_pa() const { return at<3>().valid(); }
+  uint32_t pa() const { return at<3>().as_uint32(); }
+  bool has_sec_id() const { return at<4>().valid(); }
+  int32_t sec_id() const { return at<4>().as_int32(); }
+  bool has_va() const { return at<5>().valid(); }
+  uint64_t va() const { return at<5>().as_uint64(); }
 };
 
-class MdpPerfSetWmLevelsFtraceEvent : public ::protozero::Message {
+class IommuSecPtblMapRangeEndFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MdpPerfSetWmLevelsFtraceEvent_Decoder;
+  using Decoder = IommuSecPtblMapRangeEndFtraceEvent_Decoder;
   enum : int32_t {
-    kPnumFieldNumber = 1,
-    kUseSpaceFieldNumber = 2,
-    kPriorityBytesFieldNumber = 3,
-    kWm0FieldNumber = 4,
-    kWm1FieldNumber = 5,
-    kWm2FieldNumber = 6,
-    kMbCntFieldNumber = 7,
-    kMbSizeFieldNumber = 8,
+    kLenFieldNumber = 1,
+    kNumFieldNumber = 2,
+    kPaFieldNumber = 3,
+    kSecIdFieldNumber = 4,
+    kVaFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MdpPerfSetWmLevelsFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.IommuSecPtblMapRangeEndFtraceEvent"; }
 
 
-  using FieldMetadata_Pnum =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpPerfSetWmLevelsFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IommuSecPtblMapRangeEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pnum kPnum() { return {}; }
-  void set_pnum(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pnum::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_UseSpace =
+  using FieldMetadata_Num =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpPerfSetWmLevelsFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      IommuSecPtblMapRangeEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UseSpace kUseSpace() { return {}; }
-  void set_use_space(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_UseSpace::kFieldId;
+  static constexpr FieldMetadata_Num kNum{};
+  void set_num(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Num::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PriorityBytes =
+  using FieldMetadata_Pa =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpPerfSetWmLevelsFtraceEvent>;
+      IommuSecPtblMapRangeEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PriorityBytes kPriorityBytes() { return {}; }
-  void set_priority_bytes(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PriorityBytes::kFieldId;
+  static constexpr FieldMetadata_Pa kPa{};
+  void set_pa(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pa::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -113348,380 +141081,270 @@ class MdpPerfSetWmLevelsFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Wm0 =
+  using FieldMetadata_SecId =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpPerfSetWmLevelsFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      IommuSecPtblMapRangeEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Wm0 kWm0() { return {}; }
-  void set_wm0(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Wm0::kFieldId;
+  static constexpr FieldMetadata_SecId kSecId{};
+  void set_sec_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SecId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Wm1 =
+  using FieldMetadata_Va =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpPerfSetWmLevelsFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IommuSecPtblMapRangeEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Wm1 kWm1() { return {}; }
-  void set_wm1(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Wm1::kFieldId;
+  static constexpr FieldMetadata_Va kVa{};
+  void set_va(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Va::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Wm2 =
+class IommuMapRangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  IommuMapRangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit IommuMapRangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit IommuMapRangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_chunk_size() const { return at<1>().valid(); }
+  uint64_t chunk_size() const { return at<1>().as_uint64(); }
+  bool has_len() const { return at<2>().valid(); }
+  uint64_t len() const { return at<2>().as_uint64(); }
+  bool has_pa() const { return at<3>().valid(); }
+  uint64_t pa() const { return at<3>().as_uint64(); }
+  bool has_va() const { return at<4>().valid(); }
+  uint64_t va() const { return at<4>().as_uint64(); }
+};
+
+class IommuMapRangeFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = IommuMapRangeFtraceEvent_Decoder;
+  enum : int32_t {
+    kChunkSizeFieldNumber = 1,
+    kLenFieldNumber = 2,
+    kPaFieldNumber = 3,
+    kVaFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.IommuMapRangeFtraceEvent"; }
+
+
+  using FieldMetadata_ChunkSize =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpPerfSetWmLevelsFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IommuMapRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Wm2 kWm2() { return {}; }
-  void set_wm2(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Wm2::kFieldId;
+  static constexpr FieldMetadata_ChunkSize kChunkSize{};
+  void set_chunk_size(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ChunkSize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MbCnt =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpPerfSetWmLevelsFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IommuMapRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MbCnt kMbCnt() { return {}; }
-  void set_mb_cnt(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MbCnt::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MbSize =
+  using FieldMetadata_Pa =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpPerfSetWmLevelsFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IommuMapRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MbSize kMbSize() { return {}; }
-  void set_mb_size(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MbSize::kFieldId;
+  static constexpr FieldMetadata_Pa kPa{};
+  void set_pa(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pa::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class MdpMixerUpdateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  MdpMixerUpdateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MdpMixerUpdateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MdpMixerUpdateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_mixer_num() const { return at<1>().valid(); }
-  uint32_t mixer_num() const { return at<1>().as_uint32(); }
-};
-
-class MdpMixerUpdateFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = MdpMixerUpdateFtraceEvent_Decoder;
-  enum : int32_t {
-    kMixerNumFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.MdpMixerUpdateFtraceEvent"; }
-
 
-  using FieldMetadata_MixerNum =
+  using FieldMetadata_Va =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpMixerUpdateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      IommuMapRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MixerNum kMixerNum() { return {}; }
-  void set_mixer_num(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MixerNum::kFieldId;
+  static constexpr FieldMetadata_Va kVa{};
+  void set_va(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Va::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class MdpCmdReleaseBwFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DmaAllocContiguousRetryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  MdpCmdReleaseBwFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MdpCmdReleaseBwFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MdpCmdReleaseBwFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_ctl_num() const { return at<1>().valid(); }
-  uint32_t ctl_num() const { return at<1>().as_uint32(); }
+  DmaAllocContiguousRetryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DmaAllocContiguousRetryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DmaAllocContiguousRetryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_tries() const { return at<1>().valid(); }
+  int32_t tries() const { return at<1>().as_int32(); }
 };
 
-class MdpCmdReleaseBwFtraceEvent : public ::protozero::Message {
+class DmaAllocContiguousRetryFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MdpCmdReleaseBwFtraceEvent_Decoder;
+  using Decoder = DmaAllocContiguousRetryFtraceEvent_Decoder;
   enum : int32_t {
-    kCtlNumFieldNumber = 1,
+    kTriesFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MdpCmdReleaseBwFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.DmaAllocContiguousRetryFtraceEvent"; }
 
 
-  using FieldMetadata_CtlNum =
+  using FieldMetadata_Tries =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpCmdReleaseBwFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      DmaAllocContiguousRetryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CtlNum kCtlNum() { return {}; }
-  void set_ctl_num(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CtlNum::kFieldId;
+  static constexpr FieldMetadata_Tries kTries{};
+  void set_tries(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tries::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class MdpTraceCounterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class AllocPagesSysStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  MdpTraceCounterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MdpTraceCounterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MdpTraceCounterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pid() const { return at<1>().valid(); }
-  int32_t pid() const { return at<1>().as_int32(); }
-  bool has_counter_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars counter_name() const { return at<2>().as_string(); }
-  bool has_value() const { return at<3>().valid(); }
-  int32_t value() const { return at<3>().as_int32(); }
+  AllocPagesSysStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AllocPagesSysStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AllocPagesSysStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_gfp_flags() const { return at<1>().valid(); }
+  uint32_t gfp_flags() const { return at<1>().as_uint32(); }
+  bool has_order() const { return at<2>().valid(); }
+  uint32_t order() const { return at<2>().as_uint32(); }
 };
 
-class MdpTraceCounterFtraceEvent : public ::protozero::Message {
+class AllocPagesSysStartFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MdpTraceCounterFtraceEvent_Decoder;
+  using Decoder = AllocPagesSysStartFtraceEvent_Decoder;
   enum : int32_t {
-    kPidFieldNumber = 1,
-    kCounterNameFieldNumber = 2,
-    kValueFieldNumber = 3,
+    kGfpFlagsFieldNumber = 1,
+    kOrderFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MdpTraceCounterFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.AllocPagesSysStartFtraceEvent"; }
 
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_GfpFlags =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MdpTraceCounterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      AllocPagesSysStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_GfpFlags kGfpFlags{};
+  void set_gfp_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CounterName =
+  using FieldMetadata_Order =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      MdpTraceCounterFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CounterName kCounterName() { return {}; }
-  void set_counter_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_CounterName::kFieldId, data, size);
-  }
-  void set_counter_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_CounterName::kFieldId, chars.data, chars.size);
-  }
-  void set_counter_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_CounterName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Value =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MdpTraceCounterFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      AllocPagesSysStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+  static constexpr FieldMetadata_Order kOrder{};
+  void set_order(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class MdpPerfSetQosLutsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class AllocPagesSysFailFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  MdpPerfSetQosLutsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MdpPerfSetQosLutsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MdpPerfSetQosLutsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pnum() const { return at<1>().valid(); }
-  uint32_t pnum() const { return at<1>().as_uint32(); }
-  bool has_fmt() const { return at<2>().valid(); }
-  uint32_t fmt() const { return at<2>().as_uint32(); }
-  bool has_intf() const { return at<3>().valid(); }
-  uint32_t intf() const { return at<3>().as_uint32(); }
-  bool has_rot() const { return at<4>().valid(); }
-  uint32_t rot() const { return at<4>().as_uint32(); }
-  bool has_fl() const { return at<5>().valid(); }
-  uint32_t fl() const { return at<5>().as_uint32(); }
-  bool has_lut() const { return at<6>().valid(); }
-  uint32_t lut() const { return at<6>().as_uint32(); }
-  bool has_linear() const { return at<7>().valid(); }
-  uint32_t linear() const { return at<7>().as_uint32(); }
+  AllocPagesSysFailFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AllocPagesSysFailFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AllocPagesSysFailFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_gfp_flags() const { return at<1>().valid(); }
+  uint32_t gfp_flags() const { return at<1>().as_uint32(); }
+  bool has_order() const { return at<2>().valid(); }
+  uint32_t order() const { return at<2>().as_uint32(); }
 };
 
-class MdpPerfSetQosLutsFtraceEvent : public ::protozero::Message {
+class AllocPagesSysFailFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MdpPerfSetQosLutsFtraceEvent_Decoder;
+  using Decoder = AllocPagesSysFailFtraceEvent_Decoder;
   enum : int32_t {
-    kPnumFieldNumber = 1,
-    kFmtFieldNumber = 2,
-    kIntfFieldNumber = 3,
-    kRotFieldNumber = 4,
-    kFlFieldNumber = 5,
-    kLutFieldNumber = 6,
-    kLinearFieldNumber = 7,
+    kGfpFlagsFieldNumber = 1,
+    kOrderFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MdpPerfSetQosLutsFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.AllocPagesSysFailFtraceEvent"; }
 
 
-  using FieldMetadata_Pnum =
+  using FieldMetadata_GfpFlags =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpPerfSetQosLutsFtraceEvent>;
+      AllocPagesSysFailFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pnum kPnum() { return {}; }
-  void set_pnum(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pnum::kFieldId;
+  static constexpr FieldMetadata_GfpFlags kGfpFlags{};
+  void set_gfp_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -113729,74 +141352,57 @@ class MdpPerfSetQosLutsFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Fmt =
+  using FieldMetadata_Order =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpPerfSetQosLutsFtraceEvent>;
+      AllocPagesSysFailFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Fmt kFmt() { return {}; }
-  void set_fmt(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Fmt::kFieldId;
+  static constexpr FieldMetadata_Order kOrder{};
+  void set_order(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Intf =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpPerfSetQosLutsFtraceEvent>;
+class AllocPagesSysEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  AllocPagesSysEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AllocPagesSysEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AllocPagesSysEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_gfp_flags() const { return at<1>().valid(); }
+  uint32_t gfp_flags() const { return at<1>().as_uint32(); }
+  bool has_order() const { return at<2>().valid(); }
+  uint32_t order() const { return at<2>().as_uint32(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Intf kIntf() { return {}; }
-  void set_intf(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Intf::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+class AllocPagesSysEndFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = AllocPagesSysEndFtraceEvent_Decoder;
+  enum : int32_t {
+    kGfpFlagsFieldNumber = 1,
+    kOrderFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AllocPagesSysEndFtraceEvent"; }
 
-  using FieldMetadata_Rot =
+
+  using FieldMetadata_GfpFlags =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpPerfSetQosLutsFtraceEvent>;
+      AllocPagesSysEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Rot kRot() { return {}; }
-  void set_rot(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Rot::kFieldId;
+  static constexpr FieldMetadata_GfpFlags kGfpFlags{};
+  void set_gfp_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -113804,49 +141410,57 @@ class MdpPerfSetQosLutsFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Fl =
+  using FieldMetadata_Order =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpPerfSetQosLutsFtraceEvent>;
+      AllocPagesSysEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Fl kFl() { return {}; }
-  void set_fl(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Fl::kFieldId;
+  static constexpr FieldMetadata_Order kOrder{};
+  void set_order(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Lut =
+class AllocPagesIommuStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  AllocPagesIommuStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AllocPagesIommuStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AllocPagesIommuStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_gfp_flags() const { return at<1>().valid(); }
+  uint32_t gfp_flags() const { return at<1>().as_uint32(); }
+  bool has_order() const { return at<2>().valid(); }
+  uint32_t order() const { return at<2>().as_uint32(); }
+};
+
+class AllocPagesIommuStartFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = AllocPagesIommuStartFtraceEvent_Decoder;
+  enum : int32_t {
+    kGfpFlagsFieldNumber = 1,
+    kOrderFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.AllocPagesIommuStartFtraceEvent"; }
+
+
+  using FieldMetadata_GfpFlags =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpPerfSetQosLutsFtraceEvent>;
+      AllocPagesIommuStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lut kLut() { return {}; }
-  void set_lut(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lut::kFieldId;
+  static constexpr FieldMetadata_GfpFlags kGfpFlags{};
+  void set_gfp_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -113854,24 +141468,17 @@ class MdpPerfSetQosLutsFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Linear =
+  using FieldMetadata_Order =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpPerfSetQosLutsFtraceEvent>;
+      AllocPagesIommuStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Linear kLinear() { return {}; }
-  void set_linear(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Linear::kFieldId;
+  static constexpr FieldMetadata_Order kOrder{};
+  void set_order(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -113880,48 +141487,38 @@ class MdpPerfSetQosLutsFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MdpMisrCrcFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class AllocPagesIommuFailFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  MdpMisrCrcFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MdpMisrCrcFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MdpMisrCrcFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_block_id() const { return at<1>().valid(); }
-  uint32_t block_id() const { return at<1>().as_uint32(); }
-  bool has_vsync_cnt() const { return at<2>().valid(); }
-  uint32_t vsync_cnt() const { return at<2>().as_uint32(); }
-  bool has_crc() const { return at<3>().valid(); }
-  uint32_t crc() const { return at<3>().as_uint32(); }
+  AllocPagesIommuFailFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AllocPagesIommuFailFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AllocPagesIommuFailFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_gfp_flags() const { return at<1>().valid(); }
+  uint32_t gfp_flags() const { return at<1>().as_uint32(); }
+  bool has_order() const { return at<2>().valid(); }
+  uint32_t order() const { return at<2>().as_uint32(); }
 };
 
-class MdpMisrCrcFtraceEvent : public ::protozero::Message {
+class AllocPagesIommuFailFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MdpMisrCrcFtraceEvent_Decoder;
+  using Decoder = AllocPagesIommuFailFtraceEvent_Decoder;
   enum : int32_t {
-    kBlockIdFieldNumber = 1,
-    kVsyncCntFieldNumber = 2,
-    kCrcFieldNumber = 3,
+    kGfpFlagsFieldNumber = 1,
+    kOrderFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MdpMisrCrcFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.AllocPagesIommuFailFtraceEvent"; }
 
 
-  using FieldMetadata_BlockId =
+  using FieldMetadata_GfpFlags =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpMisrCrcFtraceEvent>;
+      AllocPagesIommuFailFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BlockId kBlockId() { return {}; }
-  void set_block_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BlockId::kFieldId;
+  static constexpr FieldMetadata_GfpFlags kGfpFlags{};
+  void set_gfp_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -113929,49 +141526,17 @@ class MdpMisrCrcFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VsyncCnt =
+  using FieldMetadata_Order =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpMisrCrcFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VsyncCnt kVsyncCnt() { return {}; }
-  void set_vsync_cnt(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VsyncCnt::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Crc =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpMisrCrcFtraceEvent>;
+      AllocPagesIommuFailFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Crc kCrc() { return {}; }
-  void set_crc(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Crc::kFieldId;
+  static constexpr FieldMetadata_Order kOrder{};
+  void set_order(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -113980,45 +141545,38 @@ class MdpMisrCrcFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MdpCmdReadptrDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class AllocPagesIommuEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  MdpCmdReadptrDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MdpCmdReadptrDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MdpCmdReadptrDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_ctl_num() const { return at<1>().valid(); }
-  uint32_t ctl_num() const { return at<1>().as_uint32(); }
-  bool has_koff_cnt() const { return at<2>().valid(); }
-  int32_t koff_cnt() const { return at<2>().as_int32(); }
+  AllocPagesIommuEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AllocPagesIommuEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AllocPagesIommuEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_gfp_flags() const { return at<1>().valid(); }
+  uint32_t gfp_flags() const { return at<1>().as_uint32(); }
+  bool has_order() const { return at<2>().valid(); }
+  uint32_t order() const { return at<2>().as_uint32(); }
 };
 
-class MdpCmdReadptrDoneFtraceEvent : public ::protozero::Message {
+class AllocPagesIommuEndFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MdpCmdReadptrDoneFtraceEvent_Decoder;
+  using Decoder = AllocPagesIommuEndFtraceEvent_Decoder;
   enum : int32_t {
-    kCtlNumFieldNumber = 1,
-    kKoffCntFieldNumber = 2,
+    kGfpFlagsFieldNumber = 1,
+    kOrderFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MdpCmdReadptrDoneFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.AllocPagesIommuEndFtraceEvent"; }
 
 
-  using FieldMetadata_CtlNum =
+  using FieldMetadata_GfpFlags =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpCmdReadptrDoneFtraceEvent>;
+      AllocPagesIommuEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CtlNum kCtlNum() { return {}; }
-  void set_ctl_num(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CtlNum::kFieldId;
+  static constexpr FieldMetadata_GfpFlags kGfpFlags{};
+  void set_gfp_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -114026,113 +141584,84 @@ class MdpCmdReadptrDoneFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_KoffCnt =
+  using FieldMetadata_Order =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MdpCmdReadptrDoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      AllocPagesIommuEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KoffCnt kKoffCnt() { return {}; }
-  void set_koff_cnt(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_KoffCnt::kFieldId;
+  static constexpr FieldMetadata_Order kOrder{};
+  void set_order(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class MdpSsppSetFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/16, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/kvm.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_KVM_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_KVM_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class VgicUpdateIrqPendingFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  MdpSsppSetFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MdpSsppSetFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MdpSsppSetFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_num() const { return at<1>().valid(); }
-  uint32_t num() const { return at<1>().as_uint32(); }
-  bool has_play_cnt() const { return at<2>().valid(); }
-  uint32_t play_cnt() const { return at<2>().as_uint32(); }
-  bool has_mixer() const { return at<3>().valid(); }
-  uint32_t mixer() const { return at<3>().as_uint32(); }
-  bool has_stage() const { return at<4>().valid(); }
-  uint32_t stage() const { return at<4>().as_uint32(); }
-  bool has_flags() const { return at<5>().valid(); }
-  uint32_t flags() const { return at<5>().as_uint32(); }
-  bool has_format() const { return at<6>().valid(); }
-  uint32_t format() const { return at<6>().as_uint32(); }
-  bool has_img_w() const { return at<7>().valid(); }
-  uint32_t img_w() const { return at<7>().as_uint32(); }
-  bool has_img_h() const { return at<8>().valid(); }
-  uint32_t img_h() const { return at<8>().as_uint32(); }
-  bool has_src_x() const { return at<9>().valid(); }
-  uint32_t src_x() const { return at<9>().as_uint32(); }
-  bool has_src_y() const { return at<10>().valid(); }
-  uint32_t src_y() const { return at<10>().as_uint32(); }
-  bool has_src_w() const { return at<11>().valid(); }
-  uint32_t src_w() const { return at<11>().as_uint32(); }
-  bool has_src_h() const { return at<12>().valid(); }
-  uint32_t src_h() const { return at<12>().as_uint32(); }
-  bool has_dst_x() const { return at<13>().valid(); }
-  uint32_t dst_x() const { return at<13>().as_uint32(); }
-  bool has_dst_y() const { return at<14>().valid(); }
-  uint32_t dst_y() const { return at<14>().as_uint32(); }
-  bool has_dst_w() const { return at<15>().valid(); }
-  uint32_t dst_w() const { return at<15>().as_uint32(); }
-  bool has_dst_h() const { return at<16>().valid(); }
-  uint32_t dst_h() const { return at<16>().as_uint32(); }
+  VgicUpdateIrqPendingFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit VgicUpdateIrqPendingFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit VgicUpdateIrqPendingFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_irq() const { return at<1>().valid(); }
+  uint32_t irq() const { return at<1>().as_uint32(); }
+  bool has_level() const { return at<2>().valid(); }
+  uint32_t level() const { return at<2>().as_uint32(); }
+  bool has_vcpu_id() const { return at<3>().valid(); }
+  uint64_t vcpu_id() const { return at<3>().as_uint64(); }
 };
 
-class MdpSsppSetFtraceEvent : public ::protozero::Message {
+class VgicUpdateIrqPendingFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MdpSsppSetFtraceEvent_Decoder;
+  using Decoder = VgicUpdateIrqPendingFtraceEvent_Decoder;
   enum : int32_t {
-    kNumFieldNumber = 1,
-    kPlayCntFieldNumber = 2,
-    kMixerFieldNumber = 3,
-    kStageFieldNumber = 4,
-    kFlagsFieldNumber = 5,
-    kFormatFieldNumber = 6,
-    kImgWFieldNumber = 7,
-    kImgHFieldNumber = 8,
-    kSrcXFieldNumber = 9,
-    kSrcYFieldNumber = 10,
-    kSrcWFieldNumber = 11,
-    kSrcHFieldNumber = 12,
-    kDstXFieldNumber = 13,
-    kDstYFieldNumber = 14,
-    kDstWFieldNumber = 15,
-    kDstHFieldNumber = 16,
+    kIrqFieldNumber = 1,
+    kLevelFieldNumber = 2,
+    kVcpuIdFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MdpSsppSetFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.VgicUpdateIrqPendingFtraceEvent"; }
 
 
-  using FieldMetadata_Num =
+  using FieldMetadata_Irq =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpSsppSetFtraceEvent>;
+      VgicUpdateIrqPendingFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Num kNum() { return {}; }
-  void set_num(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Num::kFieldId;
+  static constexpr FieldMetadata_Irq kIrq{};
+  void set_irq(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Irq::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -114140,24 +141669,17 @@ class MdpSsppSetFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PlayCnt =
+  using FieldMetadata_Level =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpSsppSetFtraceEvent>;
+      VgicUpdateIrqPendingFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PlayCnt kPlayCnt() { return {}; }
-  void set_play_cnt(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PlayCnt::kFieldId;
+  static constexpr FieldMetadata_Level kLevel{};
+  void set_level(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -114165,99 +141687,87 @@ class MdpSsppSetFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Mixer =
+  using FieldMetadata_VcpuId =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpSsppSetFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      VgicUpdateIrqPendingFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mixer kMixer() { return {}; }
-  void set_mixer(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mixer::kFieldId;
+  static constexpr FieldMetadata_VcpuId kVcpuId{};
+  void set_vcpu_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VcpuId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Stage =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpSsppSetFtraceEvent>;
+class TrapRegFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  TrapRegFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TrapRegFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TrapRegFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_fn() const { return at<1>().valid(); }
+  ::protozero::ConstChars fn() const { return at<1>().as_string(); }
+  bool has_is_write() const { return at<2>().valid(); }
+  uint32_t is_write() const { return at<2>().as_uint32(); }
+  bool has_reg() const { return at<3>().valid(); }
+  int32_t reg() const { return at<3>().as_int32(); }
+  bool has_write_value() const { return at<4>().valid(); }
+  uint64_t write_value() const { return at<4>().as_uint64(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Stage kStage() { return {}; }
-  void set_stage(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Stage::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+class TrapRegFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = TrapRegFtraceEvent_Decoder;
+  enum : int32_t {
+    kFnFieldNumber = 1,
+    kIsWriteFieldNumber = 2,
+    kRegFieldNumber = 3,
+    kWriteValueFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TrapRegFtraceEvent"; }
 
-  using FieldMetadata_Flags =
+
+  using FieldMetadata_Fn =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpSsppSetFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TrapRegFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_Fn kFn{};
+  void set_fn(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Fn::kFieldId, data, size);
+  }
+  void set_fn(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Fn::kFieldId, chars.data, chars.size);
+  }
+  void set_fn(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Fn::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Format =
+  using FieldMetadata_IsWrite =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpSsppSetFtraceEvent>;
+      TrapRegFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Format kFormat() { return {}; }
-  void set_format(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Format::kFieldId;
+  static constexpr FieldMetadata_IsWrite kIsWrite{};
+  void set_is_write(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsWrite::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -114265,74 +141775,75 @@ class MdpSsppSetFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ImgW =
+  using FieldMetadata_Reg =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpSsppSetFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TrapRegFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ImgW kImgW() { return {}; }
-  void set_img_w(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ImgW::kFieldId;
+  static constexpr FieldMetadata_Reg kReg{};
+  void set_reg(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Reg::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ImgH =
+  using FieldMetadata_WriteValue =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpSsppSetFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TrapRegFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ImgH kImgH() { return {}; }
-  void set_img_h(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ImgH::kFieldId;
+  static constexpr FieldMetadata_WriteValue kWriteValue{};
+  void set_write_value(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_WriteValue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_SrcX =
+class KvmWfxArm64FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  KvmWfxArm64FtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmWfxArm64FtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmWfxArm64FtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_is_wfe() const { return at<1>().valid(); }
+  uint32_t is_wfe() const { return at<1>().as_uint32(); }
+  bool has_vcpu_pc() const { return at<2>().valid(); }
+  uint64_t vcpu_pc() const { return at<2>().as_uint64(); }
+};
+
+class KvmWfxArm64FtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KvmWfxArm64FtraceEvent_Decoder;
+  enum : int32_t {
+    kIsWfeFieldNumber = 1,
+    kVcpuPcFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmWfxArm64FtraceEvent"; }
+
+
+  using FieldMetadata_IsWfe =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpSsppSetFtraceEvent>;
+      KvmWfxArm64FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SrcX kSrcX() { return {}; }
-  void set_src_x(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SrcX::kFieldId;
+  static constexpr FieldMetadata_IsWfe kIsWfe{};
+  void set_is_wfe(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsWfe::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -114340,74 +141851,78 @@ class MdpSsppSetFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SrcY =
+  using FieldMetadata_VcpuPc =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpSsppSetFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmWfxArm64FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SrcY kSrcY() { return {}; }
-  void set_src_y(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SrcY::kFieldId;
+  static constexpr FieldMetadata_VcpuPc kVcpuPc{};
+  void set_vcpu_pc(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_SrcW =
+class KvmVcpuWakeupFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  KvmVcpuWakeupFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmVcpuWakeupFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmVcpuWakeupFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_ns() const { return at<1>().valid(); }
+  uint64_t ns() const { return at<1>().as_uint64(); }
+  bool has_valid() const { return at<2>().valid(); }
+  uint32_t valid() const { return at<2>().as_uint32(); }
+  bool has_waited() const { return at<3>().valid(); }
+  uint32_t waited() const { return at<3>().as_uint32(); }
+};
+
+class KvmVcpuWakeupFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KvmVcpuWakeupFtraceEvent_Decoder;
+  enum : int32_t {
+    kNsFieldNumber = 1,
+    kValidFieldNumber = 2,
+    kWaitedFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmVcpuWakeupFtraceEvent"; }
+
+
+  using FieldMetadata_Ns =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpSsppSetFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmVcpuWakeupFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SrcW kSrcW() { return {}; }
-  void set_src_w(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SrcW::kFieldId;
+  static constexpr FieldMetadata_Ns kNs{};
+  void set_ns(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ns::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SrcH =
+  using FieldMetadata_Valid =
     ::protozero::proto_utils::FieldMetadata<
-      12,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpSsppSetFtraceEvent>;
+      KvmVcpuWakeupFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SrcH kSrcH() { return {}; }
-  void set_src_h(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SrcH::kFieldId;
+  static constexpr FieldMetadata_Valid kValid{};
+  void set_valid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Valid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -114415,155 +141930,155 @@ class MdpSsppSetFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DstX =
+  using FieldMetadata_Waited =
     ::protozero::proto_utils::FieldMetadata<
-      13,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpSsppSetFtraceEvent>;
+      KvmVcpuWakeupFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DstX kDstX() { return {}; }
-  void set_dst_x(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DstX::kFieldId;
+  static constexpr FieldMetadata_Waited kWaited{};
+  void set_waited(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Waited::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_DstY =
+class KvmUserspaceExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  KvmUserspaceExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmUserspaceExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmUserspaceExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_reason() const { return at<1>().valid(); }
+  uint32_t reason() const { return at<1>().as_uint32(); }
+};
+
+class KvmUserspaceExitFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KvmUserspaceExitFtraceEvent_Decoder;
+  enum : int32_t {
+    kReasonFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmUserspaceExitFtraceEvent"; }
+
+
+  using FieldMetadata_Reason =
     ::protozero::proto_utils::FieldMetadata<
-      14,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpSsppSetFtraceEvent>;
+      KvmUserspaceExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DstY kDstY() { return {}; }
-  void set_dst_y(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DstY::kFieldId;
+  static constexpr FieldMetadata_Reason kReason{};
+  void set_reason(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Reason::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_DstW =
+class KvmUnmapHvaRangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  KvmUnmapHvaRangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmUnmapHvaRangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmUnmapHvaRangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_end() const { return at<1>().valid(); }
+  uint64_t end() const { return at<1>().as_uint64(); }
+  bool has_start() const { return at<2>().valid(); }
+  uint64_t start() const { return at<2>().as_uint64(); }
+};
+
+class KvmUnmapHvaRangeFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KvmUnmapHvaRangeFtraceEvent_Decoder;
+  enum : int32_t {
+    kEndFieldNumber = 1,
+    kStartFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmUnmapHvaRangeFtraceEvent"; }
+
+
+  using FieldMetadata_End =
     ::protozero::proto_utils::FieldMetadata<
-      15,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpSsppSetFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmUnmapHvaRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DstW kDstW() { return {}; }
-  void set_dst_w(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DstW::kFieldId;
+  static constexpr FieldMetadata_End kEnd{};
+  void set_end(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_End::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DstH =
+  using FieldMetadata_Start =
     ::protozero::proto_utils::FieldMetadata<
-      16,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpSsppSetFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmUnmapHvaRangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DstH kDstH() { return {}; }
-  void set_dst_h(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DstH::kFieldId;
+  static constexpr FieldMetadata_Start kStart{};
+  void set_start(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class MdpPerfSetPanicLutsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class KvmToggleCacheFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  MdpPerfSetPanicLutsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MdpPerfSetPanicLutsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MdpPerfSetPanicLutsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pnum() const { return at<1>().valid(); }
-  uint32_t pnum() const { return at<1>().as_uint32(); }
-  bool has_fmt() const { return at<2>().valid(); }
-  uint32_t fmt() const { return at<2>().as_uint32(); }
-  bool has_mode() const { return at<3>().valid(); }
-  uint32_t mode() const { return at<3>().as_uint32(); }
-  bool has_panic_lut() const { return at<4>().valid(); }
-  uint32_t panic_lut() const { return at<4>().as_uint32(); }
-  bool has_robust_lut() const { return at<5>().valid(); }
-  uint32_t robust_lut() const { return at<5>().as_uint32(); }
+  KvmToggleCacheFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmToggleCacheFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmToggleCacheFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_now() const { return at<1>().valid(); }
+  uint32_t now() const { return at<1>().as_uint32(); }
+  bool has_vcpu_pc() const { return at<2>().valid(); }
+  uint64_t vcpu_pc() const { return at<2>().as_uint64(); }
+  bool has_was() const { return at<3>().valid(); }
+  uint32_t was() const { return at<3>().as_uint32(); }
 };
 
-class MdpPerfSetPanicLutsFtraceEvent : public ::protozero::Message {
+class KvmToggleCacheFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MdpPerfSetPanicLutsFtraceEvent_Decoder;
+  using Decoder = KvmToggleCacheFtraceEvent_Decoder;
   enum : int32_t {
-    kPnumFieldNumber = 1,
-    kFmtFieldNumber = 2,
-    kModeFieldNumber = 3,
-    kPanicLutFieldNumber = 4,
-    kRobustLutFieldNumber = 5,
+    kNowFieldNumber = 1,
+    kVcpuPcFieldNumber = 2,
+    kWasFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MdpPerfSetPanicLutsFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmToggleCacheFtraceEvent"; }
 
 
-  using FieldMetadata_Pnum =
+  using FieldMetadata_Now =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpPerfSetPanicLutsFtraceEvent>;
+      KvmToggleCacheFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pnum kPnum() { return {}; }
-  void set_pnum(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pnum::kFieldId;
+  static constexpr FieldMetadata_Now kNow{};
+  void set_now(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Now::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -114571,74 +142086,78 @@ class MdpPerfSetPanicLutsFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Fmt =
+  using FieldMetadata_VcpuPc =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpPerfSetPanicLutsFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmToggleCacheFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Fmt kFmt() { return {}; }
-  void set_fmt(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Fmt::kFieldId;
+  static constexpr FieldMetadata_VcpuPc kVcpuPc{};
+  void set_vcpu_pc(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Mode =
+  using FieldMetadata_Was =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpPerfSetPanicLutsFtraceEvent>;
+      KvmToggleCacheFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mode kMode() { return {}; }
-  void set_mode(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
+  static constexpr FieldMetadata_Was kWas{};
+  void set_was(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Was::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_PanicLut =
+class KvmTimerUpdateIrqFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  KvmTimerUpdateIrqFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmTimerUpdateIrqFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmTimerUpdateIrqFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_irq() const { return at<1>().valid(); }
+  uint32_t irq() const { return at<1>().as_uint32(); }
+  bool has_level() const { return at<2>().valid(); }
+  int32_t level() const { return at<2>().as_int32(); }
+  bool has_vcpu_id() const { return at<3>().valid(); }
+  uint64_t vcpu_id() const { return at<3>().as_uint64(); }
+};
+
+class KvmTimerUpdateIrqFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KvmTimerUpdateIrqFtraceEvent_Decoder;
+  enum : int32_t {
+    kIrqFieldNumber = 1,
+    kLevelFieldNumber = 2,
+    kVcpuIdFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmTimerUpdateIrqFtraceEvent"; }
+
+
+  using FieldMetadata_Irq =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpPerfSetPanicLutsFtraceEvent>;
+      KvmTimerUpdateIrqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PanicLut kPanicLut() { return {}; }
-  void set_panic_lut(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PanicLut::kFieldId;
+  static constexpr FieldMetadata_Irq kIrq{};
+  void set_irq(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Irq::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -114646,89 +142165,78 @@ class MdpPerfSetPanicLutsFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_RobustLut =
+  using FieldMetadata_Level =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpPerfSetPanicLutsFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KvmTimerUpdateIrqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RobustLut kRobustLut() { return {}; }
-  void set_robust_lut(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RobustLut::kFieldId;
+  static constexpr FieldMetadata_Level kLevel{};
+  void set_level(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_VcpuId =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmTimerUpdateIrqFtraceEvent>;
+
+  static constexpr FieldMetadata_VcpuId kVcpuId{};
+  void set_vcpu_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VcpuId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class MdpCompareBwFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class KvmTimerSaveStateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  MdpCompareBwFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MdpCompareBwFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MdpCompareBwFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_new_ab() const { return at<1>().valid(); }
-  uint64_t new_ab() const { return at<1>().as_uint64(); }
-  bool has_new_ib() const { return at<2>().valid(); }
-  uint64_t new_ib() const { return at<2>().as_uint64(); }
-  bool has_new_wb() const { return at<3>().valid(); }
-  uint64_t new_wb() const { return at<3>().as_uint64(); }
-  bool has_old_ab() const { return at<4>().valid(); }
-  uint64_t old_ab() const { return at<4>().as_uint64(); }
-  bool has_old_ib() const { return at<5>().valid(); }
-  uint64_t old_ib() const { return at<5>().as_uint64(); }
-  bool has_old_wb() const { return at<6>().valid(); }
-  uint64_t old_wb() const { return at<6>().as_uint64(); }
-  bool has_params_changed() const { return at<7>().valid(); }
-  uint32_t params_changed() const { return at<7>().as_uint32(); }
-  bool has_update_bw() const { return at<8>().valid(); }
-  uint32_t update_bw() const { return at<8>().as_uint32(); }
+  KvmTimerSaveStateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmTimerSaveStateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmTimerSaveStateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_ctl() const { return at<1>().valid(); }
+  uint64_t ctl() const { return at<1>().as_uint64(); }
+  bool has_cval() const { return at<2>().valid(); }
+  uint64_t cval() const { return at<2>().as_uint64(); }
+  bool has_timer_idx() const { return at<3>().valid(); }
+  int32_t timer_idx() const { return at<3>().as_int32(); }
 };
 
-class MdpCompareBwFtraceEvent : public ::protozero::Message {
+class KvmTimerSaveStateFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MdpCompareBwFtraceEvent_Decoder;
+  using Decoder = KvmTimerSaveStateFtraceEvent_Decoder;
   enum : int32_t {
-    kNewAbFieldNumber = 1,
-    kNewIbFieldNumber = 2,
-    kNewWbFieldNumber = 3,
-    kOldAbFieldNumber = 4,
-    kOldIbFieldNumber = 5,
-    kOldWbFieldNumber = 6,
-    kParamsChangedFieldNumber = 7,
-    kUpdateBwFieldNumber = 8,
+    kCtlFieldNumber = 1,
+    kCvalFieldNumber = 2,
+    kTimerIdxFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MdpCompareBwFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmTimerSaveStateFtraceEvent"; }
 
 
-  using FieldMetadata_NewAb =
+  using FieldMetadata_Ctl =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MdpCompareBwFtraceEvent>;
+      KvmTimerSaveStateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NewAb kNewAb() { return {}; }
-  void set_new_ab(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NewAb::kFieldId;
+  static constexpr FieldMetadata_Ctl kCtl{};
+  void set_ctl(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ctl::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -114736,24 +142244,17 @@ class MdpCompareBwFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NewIb =
+  using FieldMetadata_Cval =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MdpCompareBwFtraceEvent>;
+      KvmTimerSaveStateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NewIb kNewIb() { return {}; }
-  void set_new_ib(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NewIb::kFieldId;
+  static constexpr FieldMetadata_Cval kCval{};
+  void set_cval(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cval::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -114761,49 +142262,60 @@ class MdpCompareBwFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NewWb =
+  using FieldMetadata_TimerIdx =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MdpCompareBwFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KvmTimerSaveStateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NewWb kNewWb() { return {}; }
-  void set_new_wb(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NewWb::kFieldId;
+  static constexpr FieldMetadata_TimerIdx kTimerIdx{};
+  void set_timer_idx(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimerIdx::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_OldAb =
+class KvmTimerRestoreStateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  KvmTimerRestoreStateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmTimerRestoreStateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmTimerRestoreStateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_ctl() const { return at<1>().valid(); }
+  uint64_t ctl() const { return at<1>().as_uint64(); }
+  bool has_cval() const { return at<2>().valid(); }
+  uint64_t cval() const { return at<2>().as_uint64(); }
+  bool has_timer_idx() const { return at<3>().valid(); }
+  int32_t timer_idx() const { return at<3>().as_int32(); }
+};
+
+class KvmTimerRestoreStateFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KvmTimerRestoreStateFtraceEvent_Decoder;
+  enum : int32_t {
+    kCtlFieldNumber = 1,
+    kCvalFieldNumber = 2,
+    kTimerIdxFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmTimerRestoreStateFtraceEvent"; }
+
+
+  using FieldMetadata_Ctl =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MdpCompareBwFtraceEvent>;
+      KvmTimerRestoreStateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OldAb kOldAb() { return {}; }
-  void set_old_ab(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OldAb::kFieldId;
+  static constexpr FieldMetadata_Ctl kCtl{};
+  void set_ctl(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ctl::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -114811,24 +142323,17 @@ class MdpCompareBwFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_OldIb =
+  using FieldMetadata_Cval =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MdpCompareBwFtraceEvent>;
+      KvmTimerRestoreStateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OldIb kOldIb() { return {}; }
-  void set_old_ib(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OldIb::kFieldId;
+  static constexpr FieldMetadata_Cval kCval{};
+  void set_cval(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cval::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -114836,127 +142341,207 @@ class MdpCompareBwFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_OldWb =
+  using FieldMetadata_TimerIdx =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MdpCompareBwFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KvmTimerRestoreStateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OldWb kOldWb() { return {}; }
-  void set_old_wb(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OldWb::kFieldId;
+  static constexpr FieldMetadata_TimerIdx kTimerIdx{};
+  void set_timer_idx(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimerIdx::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_ParamsChanged =
+class KvmTimerHrtimerExpireFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  KvmTimerHrtimerExpireFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmTimerHrtimerExpireFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmTimerHrtimerExpireFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_timer_idx() const { return at<1>().valid(); }
+  int32_t timer_idx() const { return at<1>().as_int32(); }
+};
+
+class KvmTimerHrtimerExpireFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KvmTimerHrtimerExpireFtraceEvent_Decoder;
+  enum : int32_t {
+    kTimerIdxFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmTimerHrtimerExpireFtraceEvent"; }
+
+
+  using FieldMetadata_TimerIdx =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpCompareBwFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KvmTimerHrtimerExpireFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ParamsChanged kParamsChanged() { return {}; }
-  void set_params_changed(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ParamsChanged::kFieldId;
+  static constexpr FieldMetadata_TimerIdx kTimerIdx{};
+  void set_timer_idx(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimerIdx::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_UpdateBw =
+class KvmTimerEmulateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  KvmTimerEmulateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmTimerEmulateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmTimerEmulateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_should_fire() const { return at<1>().valid(); }
+  uint32_t should_fire() const { return at<1>().as_uint32(); }
+  bool has_timer_idx() const { return at<2>().valid(); }
+  int32_t timer_idx() const { return at<2>().as_int32(); }
+};
+
+class KvmTimerEmulateFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KvmTimerEmulateFtraceEvent_Decoder;
+  enum : int32_t {
+    kShouldFireFieldNumber = 1,
+    kTimerIdxFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmTimerEmulateFtraceEvent"; }
+
+
+  using FieldMetadata_ShouldFire =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpCompareBwFtraceEvent>;
+      KvmTimerEmulateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UpdateBw kUpdateBw() { return {}; }
-  void set_update_bw(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_UpdateBw::kFieldId;
+  static constexpr FieldMetadata_ShouldFire kShouldFire{};
+  void set_should_fire(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ShouldFire::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_TimerIdx =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KvmTimerEmulateFtraceEvent>;
+
+  static constexpr FieldMetadata_TimerIdx kTimerIdx{};
+  void set_timer_idx(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimerIdx::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class MdpCmdPingpongDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class KvmTestAgeHvaFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  MdpCmdPingpongDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MdpCmdPingpongDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MdpCmdPingpongDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_ctl_num() const { return at<1>().valid(); }
-  uint32_t ctl_num() const { return at<1>().as_uint32(); }
-  bool has_intf_num() const { return at<2>().valid(); }
-  uint32_t intf_num() const { return at<2>().as_uint32(); }
-  bool has_pp_num() const { return at<3>().valid(); }
-  uint32_t pp_num() const { return at<3>().as_uint32(); }
-  bool has_koff_cnt() const { return at<4>().valid(); }
-  int32_t koff_cnt() const { return at<4>().as_int32(); }
+  KvmTestAgeHvaFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmTestAgeHvaFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmTestAgeHvaFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_hva() const { return at<1>().valid(); }
+  uint64_t hva() const { return at<1>().as_uint64(); }
 };
 
-class MdpCmdPingpongDoneFtraceEvent : public ::protozero::Message {
+class KvmTestAgeHvaFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MdpCmdPingpongDoneFtraceEvent_Decoder;
+  using Decoder = KvmTestAgeHvaFtraceEvent_Decoder;
   enum : int32_t {
-    kCtlNumFieldNumber = 1,
-    kIntfNumFieldNumber = 2,
-    kPpNumFieldNumber = 3,
-    kKoffCntFieldNumber = 4,
+    kHvaFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MdpCmdPingpongDoneFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmTestAgeHvaFtraceEvent"; }
 
 
-  using FieldMetadata_CtlNum =
+  using FieldMetadata_Hva =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmTestAgeHvaFtraceEvent>;
+
+  static constexpr FieldMetadata_Hva kHva{};
+  void set_hva(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Hva::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class KvmSysAccessFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
+ public:
+  KvmSysAccessFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmSysAccessFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmSysAccessFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_crm() const { return at<1>().valid(); }
+  uint32_t crm() const { return at<1>().as_uint32(); }
+  bool has_crn() const { return at<2>().valid(); }
+  uint32_t crn() const { return at<2>().as_uint32(); }
+  bool has_op0() const { return at<3>().valid(); }
+  uint32_t op0() const { return at<3>().as_uint32(); }
+  bool has_op1() const { return at<4>().valid(); }
+  uint32_t op1() const { return at<4>().as_uint32(); }
+  bool has_op2() const { return at<5>().valid(); }
+  uint32_t op2() const { return at<5>().as_uint32(); }
+  bool has_is_write() const { return at<6>().valid(); }
+  uint32_t is_write() const { return at<6>().as_uint32(); }
+  bool has_name() const { return at<7>().valid(); }
+  ::protozero::ConstChars name() const { return at<7>().as_string(); }
+  bool has_vcpu_pc() const { return at<8>().valid(); }
+  uint64_t vcpu_pc() const { return at<8>().as_uint64(); }
+};
+
+class KvmSysAccessFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KvmSysAccessFtraceEvent_Decoder;
+  enum : int32_t {
+    kCRmFieldNumber = 1,
+    kCRnFieldNumber = 2,
+    kOp0FieldNumber = 3,
+    kOp1FieldNumber = 4,
+    kOp2FieldNumber = 5,
+    kIsWriteFieldNumber = 6,
+    kNameFieldNumber = 7,
+    kVcpuPcFieldNumber = 8,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmSysAccessFtraceEvent"; }
+
+
+  using FieldMetadata_CRm =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpCmdPingpongDoneFtraceEvent>;
+      KvmSysAccessFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CtlNum kCtlNum() { return {}; }
-  void set_ctl_num(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CtlNum::kFieldId;
+  static constexpr FieldMetadata_CRm kCRm{};
+  void set_crm(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CRm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -114964,24 +142549,17 @@ class MdpCmdPingpongDoneFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IntfNum =
+  using FieldMetadata_CRn =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpCmdPingpongDoneFtraceEvent>;
+      KvmSysAccessFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IntfNum kIntfNum() { return {}; }
-  void set_intf_num(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IntfNum::kFieldId;
+  static constexpr FieldMetadata_CRn kCRn{};
+  void set_crn(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CRn::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -114989,24 +142567,17 @@ class MdpCmdPingpongDoneFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PpNum =
+  using FieldMetadata_Op0 =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpCmdPingpongDoneFtraceEvent>;
+      KvmSysAccessFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PpNum kPpNum() { return {}; }
-  void set_pp_num(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PpNum::kFieldId;
+  static constexpr FieldMetadata_Op0 kOp0{};
+  void set_op0(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Op0::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -115014,105 +142585,77 @@ class MdpCmdPingpongDoneFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_KoffCnt =
+  using FieldMetadata_Op1 =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MdpCmdPingpongDoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KvmSysAccessFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KoffCnt kKoffCnt() { return {}; }
-  void set_koff_cnt(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_KoffCnt::kFieldId;
+  static constexpr FieldMetadata_Op1 kOp1{};
+  void set_op1(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Op1::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class TracingMarkWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TracingMarkWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TracingMarkWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TracingMarkWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pid() const { return at<1>().valid(); }
-  int32_t pid() const { return at<1>().as_int32(); }
-  bool has_trace_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars trace_name() const { return at<2>().as_string(); }
-  bool has_trace_begin() const { return at<3>().valid(); }
-  uint32_t trace_begin() const { return at<3>().as_uint32(); }
-};
 
-class TracingMarkWriteFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = TracingMarkWriteFtraceEvent_Decoder;
-  enum : int32_t {
-    kPidFieldNumber = 1,
-    kTraceNameFieldNumber = 2,
-    kTraceBeginFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TracingMarkWriteFtraceEvent"; }
+  using FieldMetadata_Op2 =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KvmSysAccessFtraceEvent>;
 
+  static constexpr FieldMetadata_Op2 kOp2{};
+  void set_op2(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Op2::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_IsWrite =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TracingMarkWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KvmSysAccessFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_IsWrite kIsWrite{};
+  void set_is_write(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsWrite::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TraceName =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      TracingMarkWriteFtraceEvent>;
+      KvmSysAccessFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceName kTraceName() { return {}; }
-  void set_trace_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_TraceName::kFieldId, data, size);
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
-  void set_trace_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_TraceName::kFieldId, chars.data, chars.size);
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
   }
-  void set_trace_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_TraceName::kFieldId;
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -115120,113 +142663,57 @@ class TracingMarkWriteFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TraceBegin =
+  using FieldMetadata_VcpuPc =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TracingMarkWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmSysAccessFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceBegin kTraceBegin() { return {}; }
-  void set_trace_begin(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TraceBegin::kFieldId;
+  static constexpr FieldMetadata_VcpuPc kVcpuPc{};
+  void set_vcpu_pc(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class MdpSsppChangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/16, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class KvmSetWayFlushFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  MdpSsppChangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MdpSsppChangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MdpSsppChangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_num() const { return at<1>().valid(); }
-  uint32_t num() const { return at<1>().as_uint32(); }
-  bool has_play_cnt() const { return at<2>().valid(); }
-  uint32_t play_cnt() const { return at<2>().as_uint32(); }
-  bool has_mixer() const { return at<3>().valid(); }
-  uint32_t mixer() const { return at<3>().as_uint32(); }
-  bool has_stage() const { return at<4>().valid(); }
-  uint32_t stage() const { return at<4>().as_uint32(); }
-  bool has_flags() const { return at<5>().valid(); }
-  uint32_t flags() const { return at<5>().as_uint32(); }
-  bool has_format() const { return at<6>().valid(); }
-  uint32_t format() const { return at<6>().as_uint32(); }
-  bool has_img_w() const { return at<7>().valid(); }
-  uint32_t img_w() const { return at<7>().as_uint32(); }
-  bool has_img_h() const { return at<8>().valid(); }
-  uint32_t img_h() const { return at<8>().as_uint32(); }
-  bool has_src_x() const { return at<9>().valid(); }
-  uint32_t src_x() const { return at<9>().as_uint32(); }
-  bool has_src_y() const { return at<10>().valid(); }
-  uint32_t src_y() const { return at<10>().as_uint32(); }
-  bool has_src_w() const { return at<11>().valid(); }
-  uint32_t src_w() const { return at<11>().as_uint32(); }
-  bool has_src_h() const { return at<12>().valid(); }
-  uint32_t src_h() const { return at<12>().as_uint32(); }
-  bool has_dst_x() const { return at<13>().valid(); }
-  uint32_t dst_x() const { return at<13>().as_uint32(); }
-  bool has_dst_y() const { return at<14>().valid(); }
-  uint32_t dst_y() const { return at<14>().as_uint32(); }
-  bool has_dst_w() const { return at<15>().valid(); }
-  uint32_t dst_w() const { return at<15>().as_uint32(); }
-  bool has_dst_h() const { return at<16>().valid(); }
-  uint32_t dst_h() const { return at<16>().as_uint32(); }
+  KvmSetWayFlushFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmSetWayFlushFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmSetWayFlushFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cache() const { return at<1>().valid(); }
+  uint32_t cache() const { return at<1>().as_uint32(); }
+  bool has_vcpu_pc() const { return at<2>().valid(); }
+  uint64_t vcpu_pc() const { return at<2>().as_uint64(); }
 };
 
-class MdpSsppChangeFtraceEvent : public ::protozero::Message {
+class KvmSetWayFlushFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MdpSsppChangeFtraceEvent_Decoder;
+  using Decoder = KvmSetWayFlushFtraceEvent_Decoder;
   enum : int32_t {
-    kNumFieldNumber = 1,
-    kPlayCntFieldNumber = 2,
-    kMixerFieldNumber = 3,
-    kStageFieldNumber = 4,
-    kFlagsFieldNumber = 5,
-    kFormatFieldNumber = 6,
-    kImgWFieldNumber = 7,
-    kImgHFieldNumber = 8,
-    kSrcXFieldNumber = 9,
-    kSrcYFieldNumber = 10,
-    kSrcWFieldNumber = 11,
-    kSrcHFieldNumber = 12,
-    kDstXFieldNumber = 13,
-    kDstYFieldNumber = 14,
-    kDstWFieldNumber = 15,
-    kDstHFieldNumber = 16,
+    kCacheFieldNumber = 1,
+    kVcpuPcFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MdpSsppChangeFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmSetWayFlushFtraceEvent"; }
 
 
-  using FieldMetadata_Num =
+  using FieldMetadata_Cache =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpSsppChangeFtraceEvent>;
+      KvmSetWayFlushFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Num kNum() { return {}; }
-  void set_num(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Num::kFieldId;
+  static constexpr FieldMetadata_Cache kCache{};
+  void set_cache(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cache::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -115234,99 +142721,97 @@ class MdpSsppChangeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PlayCnt =
+  using FieldMetadata_VcpuPc =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpSsppChangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmSetWayFlushFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PlayCnt kPlayCnt() { return {}; }
-  void set_play_cnt(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PlayCnt::kFieldId;
+  static constexpr FieldMetadata_VcpuPc kVcpuPc{};
+  void set_vcpu_pc(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Mixer =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpSsppChangeFtraceEvent>;
+class KvmSetSpteHvaFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  KvmSetSpteHvaFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmSetSpteHvaFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmSetSpteHvaFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_hva() const { return at<1>().valid(); }
+  uint64_t hva() const { return at<1>().as_uint64(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mixer kMixer() { return {}; }
-  void set_mixer(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Mixer::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+class KvmSetSpteHvaFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KvmSetSpteHvaFtraceEvent_Decoder;
+  enum : int32_t {
+    kHvaFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmSetSpteHvaFtraceEvent"; }
 
-  using FieldMetadata_Stage =
+
+  using FieldMetadata_Hva =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpSsppChangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmSetSpteHvaFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Stage kStage() { return {}; }
-  void set_stage(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Stage::kFieldId;
+  static constexpr FieldMetadata_Hva kHva{};
+  void set_hva(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Hva::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Flags =
+class KvmSetIrqFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  KvmSetIrqFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmSetIrqFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmSetIrqFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_gsi() const { return at<1>().valid(); }
+  uint32_t gsi() const { return at<1>().as_uint32(); }
+  bool has_irq_source_id() const { return at<2>().valid(); }
+  int32_t irq_source_id() const { return at<2>().as_int32(); }
+  bool has_level() const { return at<3>().valid(); }
+  int32_t level() const { return at<3>().as_int32(); }
+};
+
+class KvmSetIrqFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KvmSetIrqFtraceEvent_Decoder;
+  enum : int32_t {
+    kGsiFieldNumber = 1,
+    kIrqSourceIdFieldNumber = 2,
+    kLevelFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmSetIrqFtraceEvent"; }
+
+
+  using FieldMetadata_Gsi =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpSsppChangeFtraceEvent>;
+      KvmSetIrqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_Gsi kGsi{};
+  void set_gsi(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Gsi::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -115334,74 +142819,75 @@ class MdpSsppChangeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Format =
+  using FieldMetadata_IrqSourceId =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpSsppChangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KvmSetIrqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Format kFormat() { return {}; }
-  void set_format(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Format::kFieldId;
+  static constexpr FieldMetadata_IrqSourceId kIrqSourceId{};
+  void set_irq_source_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IrqSourceId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ImgW =
+  using FieldMetadata_Level =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpSsppChangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KvmSetIrqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ImgW kImgW() { return {}; }
-  void set_img_w(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ImgW::kFieldId;
+  static constexpr FieldMetadata_Level kLevel{};
+  void set_level(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_ImgH =
+class KvmSetGuestDebugFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  KvmSetGuestDebugFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmSetGuestDebugFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmSetGuestDebugFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_guest_debug() const { return at<1>().valid(); }
+  uint32_t guest_debug() const { return at<1>().as_uint32(); }
+  bool has_vcpu() const { return at<2>().valid(); }
+  uint64_t vcpu() const { return at<2>().as_uint64(); }
+};
+
+class KvmSetGuestDebugFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KvmSetGuestDebugFtraceEvent_Decoder;
+  enum : int32_t {
+    kGuestDebugFieldNumber = 1,
+    kVcpuFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmSetGuestDebugFtraceEvent"; }
+
+
+  using FieldMetadata_GuestDebug =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpSsppChangeFtraceEvent>;
+      KvmSetGuestDebugFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ImgH kImgH() { return {}; }
-  void set_img_h(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ImgH::kFieldId;
+  static constexpr FieldMetadata_GuestDebug kGuestDebug{};
+  void set_guest_debug(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GuestDebug::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -115409,149 +142895,160 @@ class MdpSsppChangeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SrcX =
+  using FieldMetadata_Vcpu =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpSsppChangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmSetGuestDebugFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SrcX kSrcX() { return {}; }
-  void set_src_x(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SrcX::kFieldId;
+  static constexpr FieldMetadata_Vcpu kVcpu{};
+  void set_vcpu(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Vcpu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_SrcY =
+class KvmMmioEmulateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  KvmMmioEmulateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmMmioEmulateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmMmioEmulateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cpsr() const { return at<1>().valid(); }
+  uint64_t cpsr() const { return at<1>().as_uint64(); }
+  bool has_instr() const { return at<2>().valid(); }
+  uint64_t instr() const { return at<2>().as_uint64(); }
+  bool has_vcpu_pc() const { return at<3>().valid(); }
+  uint64_t vcpu_pc() const { return at<3>().as_uint64(); }
+};
+
+class KvmMmioEmulateFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KvmMmioEmulateFtraceEvent_Decoder;
+  enum : int32_t {
+    kCpsrFieldNumber = 1,
+    kInstrFieldNumber = 2,
+    kVcpuPcFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmMmioEmulateFtraceEvent"; }
+
+
+  using FieldMetadata_Cpsr =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpSsppChangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmMmioEmulateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SrcY kSrcY() { return {}; }
-  void set_src_y(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SrcY::kFieldId;
+  static constexpr FieldMetadata_Cpsr kCpsr{};
+  void set_cpsr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cpsr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SrcW =
+  using FieldMetadata_Instr =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpSsppChangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmMmioEmulateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SrcW kSrcW() { return {}; }
-  void set_src_w(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SrcW::kFieldId;
+  static constexpr FieldMetadata_Instr kInstr{};
+  void set_instr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Instr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SrcH =
+  using FieldMetadata_VcpuPc =
     ::protozero::proto_utils::FieldMetadata<
-      12,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpSsppChangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmMmioEmulateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SrcH kSrcH() { return {}; }
-  void set_src_h(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SrcH::kFieldId;
+  static constexpr FieldMetadata_VcpuPc kVcpuPc{};
+  void set_vcpu_pc(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_DstX =
+class KvmMmioFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  KvmMmioFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmMmioFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmMmioFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_gpa() const { return at<1>().valid(); }
+  uint64_t gpa() const { return at<1>().as_uint64(); }
+  bool has_len() const { return at<2>().valid(); }
+  uint32_t len() const { return at<2>().as_uint32(); }
+  bool has_type() const { return at<3>().valid(); }
+  uint32_t type() const { return at<3>().as_uint32(); }
+  bool has_val() const { return at<4>().valid(); }
+  uint64_t val() const { return at<4>().as_uint64(); }
+};
+
+class KvmMmioFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KvmMmioFtraceEvent_Decoder;
+  enum : int32_t {
+    kGpaFieldNumber = 1,
+    kLenFieldNumber = 2,
+    kTypeFieldNumber = 3,
+    kValFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmMmioFtraceEvent"; }
+
+
+  using FieldMetadata_Gpa =
     ::protozero::proto_utils::FieldMetadata<
-      13,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpSsppChangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmMmioFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DstX kDstX() { return {}; }
-  void set_dst_x(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DstX::kFieldId;
+  static constexpr FieldMetadata_Gpa kGpa{};
+  void set_gpa(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Gpa::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DstY =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
-      14,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpSsppChangeFtraceEvent>;
+      KvmMmioFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DstY kDstY() { return {}; }
-  void set_dst_y(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DstY::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -115559,24 +143056,17 @@ class MdpSsppChangeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DstW =
+  using FieldMetadata_Type =
     ::protozero::proto_utils::FieldMetadata<
-      15,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpSsppChangeFtraceEvent>;
+      KvmMmioFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DstW kDstW() { return {}; }
-  void set_dst_w(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DstW::kFieldId;
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -115584,127 +143074,99 @@ class MdpSsppChangeFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DstH =
+  using FieldMetadata_Val =
     ::protozero::proto_utils::FieldMetadata<
-      16,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpSsppChangeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmMmioFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DstH kDstH() { return {}; }
-  void set_dst_h(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DstH::kFieldId;
+  static constexpr FieldMetadata_Val kVal{};
+  void set_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Val::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class MdpPerfSetOtFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class KvmIrqLineFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  MdpPerfSetOtFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MdpPerfSetOtFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MdpPerfSetOtFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pnum() const { return at<1>().valid(); }
-  uint32_t pnum() const { return at<1>().as_uint32(); }
-  bool has_xin_id() const { return at<2>().valid(); }
-  uint32_t xin_id() const { return at<2>().as_uint32(); }
-  bool has_rd_lim() const { return at<3>().valid(); }
-  uint32_t rd_lim() const { return at<3>().as_uint32(); }
-  bool has_is_vbif_rt() const { return at<4>().valid(); }
-  uint32_t is_vbif_rt() const { return at<4>().as_uint32(); }
+  KvmIrqLineFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmIrqLineFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmIrqLineFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_irq_num() const { return at<1>().valid(); }
+  int32_t irq_num() const { return at<1>().as_int32(); }
+  bool has_level() const { return at<2>().valid(); }
+  int32_t level() const { return at<2>().as_int32(); }
+  bool has_type() const { return at<3>().valid(); }
+  uint32_t type() const { return at<3>().as_uint32(); }
+  bool has_vcpu_idx() const { return at<4>().valid(); }
+  int32_t vcpu_idx() const { return at<4>().as_int32(); }
 };
 
-class MdpPerfSetOtFtraceEvent : public ::protozero::Message {
+class KvmIrqLineFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MdpPerfSetOtFtraceEvent_Decoder;
+  using Decoder = KvmIrqLineFtraceEvent_Decoder;
   enum : int32_t {
-    kPnumFieldNumber = 1,
-    kXinIdFieldNumber = 2,
-    kRdLimFieldNumber = 3,
-    kIsVbifRtFieldNumber = 4,
+    kIrqNumFieldNumber = 1,
+    kLevelFieldNumber = 2,
+    kTypeFieldNumber = 3,
+    kVcpuIdxFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MdpPerfSetOtFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmIrqLineFtraceEvent"; }
 
 
-  using FieldMetadata_Pnum =
+  using FieldMetadata_IrqNum =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpPerfSetOtFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KvmIrqLineFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pnum kPnum() { return {}; }
-  void set_pnum(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pnum::kFieldId;
+  static constexpr FieldMetadata_IrqNum kIrqNum{};
+  void set_irq_num(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IrqNum::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_XinId =
+  using FieldMetadata_Level =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpPerfSetOtFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KvmIrqLineFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_XinId kXinId() { return {}; }
-  void set_xin_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_XinId::kFieldId;
+  static constexpr FieldMetadata_Level kLevel{};
+  void set_level(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_RdLim =
+  using FieldMetadata_Type =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MdpPerfSetOtFtraceEvent>;
+      KvmIrqLineFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RdLim kRdLim() { return {}; }
-  void set_rd_lim(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RdLim::kFieldId;
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -115712,152 +143174,133 @@ class MdpPerfSetOtFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IsVbifRt =
+  using FieldMetadata_VcpuIdx =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpPerfSetOtFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KvmIrqLineFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IsVbifRt kIsVbifRt() { return {}; }
-  void set_is_vbif_rt(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IsVbifRt::kFieldId;
+  static constexpr FieldMetadata_VcpuIdx kVcpuIdx{};
+  void set_vcpu_idx(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VcpuIdx::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class MdpCommitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class KvmHvcArm64FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  MdpCommitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MdpCommitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MdpCommitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_num() const { return at<1>().valid(); }
-  uint32_t num() const { return at<1>().as_uint32(); }
-  bool has_play_cnt() const { return at<2>().valid(); }
-  uint32_t play_cnt() const { return at<2>().as_uint32(); }
-  bool has_clk_rate() const { return at<3>().valid(); }
-  uint32_t clk_rate() const { return at<3>().as_uint32(); }
-  bool has_bandwidth() const { return at<4>().valid(); }
-  uint64_t bandwidth() const { return at<4>().as_uint64(); }
+  KvmHvcArm64FtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmHvcArm64FtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmHvcArm64FtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_imm() const { return at<1>().valid(); }
+  uint64_t imm() const { return at<1>().as_uint64(); }
+  bool has_r0() const { return at<2>().valid(); }
+  uint64_t r0() const { return at<2>().as_uint64(); }
+  bool has_vcpu_pc() const { return at<3>().valid(); }
+  uint64_t vcpu_pc() const { return at<3>().as_uint64(); }
 };
 
-class MdpCommitFtraceEvent : public ::protozero::Message {
+class KvmHvcArm64FtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MdpCommitFtraceEvent_Decoder;
+  using Decoder = KvmHvcArm64FtraceEvent_Decoder;
   enum : int32_t {
-    kNumFieldNumber = 1,
-    kPlayCntFieldNumber = 2,
-    kClkRateFieldNumber = 3,
-    kBandwidthFieldNumber = 4,
+    kImmFieldNumber = 1,
+    kR0FieldNumber = 2,
+    kVcpuPcFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MdpCommitFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmHvcArm64FtraceEvent"; }
 
 
-  using FieldMetadata_Num =
+  using FieldMetadata_Imm =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpCommitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmHvcArm64FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Num kNum() { return {}; }
-  void set_num(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Num::kFieldId;
+  static constexpr FieldMetadata_Imm kImm{};
+  void set_imm(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Imm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PlayCnt =
+  using FieldMetadata_R0 =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpCommitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmHvcArm64FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PlayCnt kPlayCnt() { return {}; }
-  void set_play_cnt(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PlayCnt::kFieldId;
+  static constexpr FieldMetadata_R0 kR0{};
+  void set_r0(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_R0::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ClkRate =
+  using FieldMetadata_VcpuPc =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpCommitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmHvcArm64FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClkRate kClkRate() { return {}; }
-  void set_clk_rate(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ClkRate::kFieldId;
+  static constexpr FieldMetadata_VcpuPc kVcpuPc{};
+  void set_vcpu_pc(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Bandwidth =
+class KvmHandleSysRegFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  KvmHandleSysRegFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmHandleSysRegFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmHandleSysRegFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_hsr() const { return at<1>().valid(); }
+  uint64_t hsr() const { return at<1>().as_uint64(); }
+};
+
+class KvmHandleSysRegFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KvmHandleSysRegFtraceEvent_Decoder;
+  enum : int32_t {
+    kHsrFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmHandleSysRegFtraceEvent"; }
+
+
+  using FieldMetadata_Hsr =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MdpCommitFtraceEvent>;
+      KvmHandleSysRegFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Bandwidth kBandwidth() { return {}; }
-  void set_bandwidth(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Bandwidth::kFieldId;
+  static constexpr FieldMetadata_Hsr kHsr{};
+  void set_hsr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Hsr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -115866,388 +143309,278 @@ class MdpCommitFtraceEvent : public ::protozero::Message {
   }
 };
 
-class MdpCmdKickoffFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class KvmGuestFaultFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  MdpCmdKickoffFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MdpCmdKickoffFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MdpCmdKickoffFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_ctl_num() const { return at<1>().valid(); }
-  uint32_t ctl_num() const { return at<1>().as_uint32(); }
-  bool has_kickoff_cnt() const { return at<2>().valid(); }
-  int32_t kickoff_cnt() const { return at<2>().as_int32(); }
+  KvmGuestFaultFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmGuestFaultFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmGuestFaultFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_hsr() const { return at<1>().valid(); }
+  uint64_t hsr() const { return at<1>().as_uint64(); }
+  bool has_hxfar() const { return at<2>().valid(); }
+  uint64_t hxfar() const { return at<2>().as_uint64(); }
+  bool has_ipa() const { return at<3>().valid(); }
+  uint64_t ipa() const { return at<3>().as_uint64(); }
+  bool has_vcpu_pc() const { return at<4>().valid(); }
+  uint64_t vcpu_pc() const { return at<4>().as_uint64(); }
 };
 
-class MdpCmdKickoffFtraceEvent : public ::protozero::Message {
+class KvmGuestFaultFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MdpCmdKickoffFtraceEvent_Decoder;
+  using Decoder = KvmGuestFaultFtraceEvent_Decoder;
   enum : int32_t {
-    kCtlNumFieldNumber = 1,
-    kKickoffCntFieldNumber = 2,
+    kHsrFieldNumber = 1,
+    kHxfarFieldNumber = 2,
+    kIpaFieldNumber = 3,
+    kVcpuPcFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MdpCmdKickoffFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmGuestFaultFtraceEvent"; }
 
 
-  using FieldMetadata_CtlNum =
+  using FieldMetadata_Hsr =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MdpCmdKickoffFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmGuestFaultFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CtlNum kCtlNum() { return {}; }
-  void set_ctl_num(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CtlNum::kFieldId;
+  static constexpr FieldMetadata_Hsr kHsr{};
+  void set_hsr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Hsr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_KickoffCnt =
+  using FieldMetadata_Hxfar =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MdpCmdKickoffFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmGuestFaultFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KickoffCnt kKickoffCnt() { return {}; }
-  void set_kickoff_cnt(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_KickoffCnt::kFieldId;
+  static constexpr FieldMetadata_Hxfar kHxfar{};
+  void set_hxfar(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Hxfar::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/mm_event.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_MM_EVENT_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_MM_EVENT_PROTO_H_
 
-#include <stddef.h>
-#include <stdint.h>
+  using FieldMetadata_Ipa =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmGuestFaultFtraceEvent>;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  static constexpr FieldMetadata_Ipa kIpa{};
+  void set_ipa(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ipa::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  using FieldMetadata_VcpuPc =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmGuestFaultFtraceEvent>;
 
+  static constexpr FieldMetadata_VcpuPc kVcpuPc{};
+  void set_vcpu_pc(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
 
-class MmEventRecordFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class KvmGetTimerMapFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  MmEventRecordFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MmEventRecordFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MmEventRecordFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_avg_lat() const { return at<1>().valid(); }
-  uint32_t avg_lat() const { return at<1>().as_uint32(); }
-  bool has_count() const { return at<2>().valid(); }
-  uint32_t count() const { return at<2>().as_uint32(); }
-  bool has_max_lat() const { return at<3>().valid(); }
-  uint32_t max_lat() const { return at<3>().as_uint32(); }
-  bool has_type() const { return at<4>().valid(); }
-  uint32_t type() const { return at<4>().as_uint32(); }
+  KvmGetTimerMapFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmGetTimerMapFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmGetTimerMapFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_direct_ptimer() const { return at<1>().valid(); }
+  int32_t direct_ptimer() const { return at<1>().as_int32(); }
+  bool has_direct_vtimer() const { return at<2>().valid(); }
+  int32_t direct_vtimer() const { return at<2>().as_int32(); }
+  bool has_emul_ptimer() const { return at<3>().valid(); }
+  int32_t emul_ptimer() const { return at<3>().as_int32(); }
+  bool has_vcpu_id() const { return at<4>().valid(); }
+  uint64_t vcpu_id() const { return at<4>().as_uint64(); }
 };
 
-class MmEventRecordFtraceEvent : public ::protozero::Message {
+class KvmGetTimerMapFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MmEventRecordFtraceEvent_Decoder;
+  using Decoder = KvmGetTimerMapFtraceEvent_Decoder;
   enum : int32_t {
-    kAvgLatFieldNumber = 1,
-    kCountFieldNumber = 2,
-    kMaxLatFieldNumber = 3,
-    kTypeFieldNumber = 4,
+    kDirectPtimerFieldNumber = 1,
+    kDirectVtimerFieldNumber = 2,
+    kEmulPtimerFieldNumber = 3,
+    kVcpuIdFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MmEventRecordFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmGetTimerMapFtraceEvent"; }
 
 
-  using FieldMetadata_AvgLat =
+  using FieldMetadata_DirectPtimer =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MmEventRecordFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KvmGetTimerMapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AvgLat kAvgLat() { return {}; }
-  void set_avg_lat(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AvgLat::kFieldId;
+  static constexpr FieldMetadata_DirectPtimer kDirectPtimer{};
+  void set_direct_ptimer(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DirectPtimer::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Count =
+  using FieldMetadata_DirectVtimer =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MmEventRecordFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KvmGetTimerMapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Count kCount() { return {}; }
-  void set_count(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId;
+  static constexpr FieldMetadata_DirectVtimer kDirectVtimer{};
+  void set_direct_vtimer(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DirectVtimer::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MaxLat =
+  using FieldMetadata_EmulPtimer =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MmEventRecordFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KvmGetTimerMapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaxLat kMaxLat() { return {}; }
-  void set_max_lat(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MaxLat::kFieldId;
+  static constexpr FieldMetadata_EmulPtimer kEmulPtimer{};
+  void set_emul_ptimer(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EmulPtimer::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Type =
+  using FieldMetadata_VcpuId =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MmEventRecordFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmGetTimerMapFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+  static constexpr FieldMetadata_VcpuId kVcpuId{};
+  void set_vcpu_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VcpuId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/net.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_NET_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_NET_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class NapiGroReceiveExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class KvmFpuFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  NapiGroReceiveExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit NapiGroReceiveExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit NapiGroReceiveExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_ret() const { return at<1>().valid(); }
-  int32_t ret() const { return at<1>().as_int32(); }
+  KvmFpuFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmFpuFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmFpuFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_load() const { return at<1>().valid(); }
+  uint32_t load() const { return at<1>().as_uint32(); }
 };
 
-class NapiGroReceiveExitFtraceEvent : public ::protozero::Message {
+class KvmFpuFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = NapiGroReceiveExitFtraceEvent_Decoder;
+  using Decoder = KvmFpuFtraceEvent_Decoder;
   enum : int32_t {
-    kRetFieldNumber = 1,
+    kLoadFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.NapiGroReceiveExitFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmFpuFtraceEvent"; }
 
 
-  using FieldMetadata_Ret =
+  using FieldMetadata_Load =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      NapiGroReceiveExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KvmFpuFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+  static constexpr FieldMetadata_Load kLoad{};
+  void set_load(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Load::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class NapiGroReceiveEntryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/19, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class KvmExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  NapiGroReceiveEntryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit NapiGroReceiveEntryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit NapiGroReceiveEntryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_data_len() const { return at<1>().valid(); }
-  uint32_t data_len() const { return at<1>().as_uint32(); }
-  bool has_gso_size() const { return at<2>().valid(); }
-  uint32_t gso_size() const { return at<2>().as_uint32(); }
-  bool has_gso_type() const { return at<3>().valid(); }
-  uint32_t gso_type() const { return at<3>().as_uint32(); }
-  bool has_hash() const { return at<4>().valid(); }
-  uint32_t hash() const { return at<4>().as_uint32(); }
-  bool has_ip_summed() const { return at<5>().valid(); }
-  uint32_t ip_summed() const { return at<5>().as_uint32(); }
-  bool has_l4_hash() const { return at<6>().valid(); }
-  uint32_t l4_hash() const { return at<6>().as_uint32(); }
-  bool has_len() const { return at<7>().valid(); }
-  uint32_t len() const { return at<7>().as_uint32(); }
-  bool has_mac_header() const { return at<8>().valid(); }
-  int32_t mac_header() const { return at<8>().as_int32(); }
-  bool has_mac_header_valid() const { return at<9>().valid(); }
-  uint32_t mac_header_valid() const { return at<9>().as_uint32(); }
-  bool has_name() const { return at<10>().valid(); }
-  ::protozero::ConstChars name() const { return at<10>().as_string(); }
-  bool has_napi_id() const { return at<11>().valid(); }
-  uint32_t napi_id() const { return at<11>().as_uint32(); }
-  bool has_nr_frags() const { return at<12>().valid(); }
-  uint32_t nr_frags() const { return at<12>().as_uint32(); }
-  bool has_protocol() const { return at<13>().valid(); }
-  uint32_t protocol() const { return at<13>().as_uint32(); }
-  bool has_queue_mapping() const { return at<14>().valid(); }
-  uint32_t queue_mapping() const { return at<14>().as_uint32(); }
-  bool has_skbaddr() const { return at<15>().valid(); }
-  uint64_t skbaddr() const { return at<15>().as_uint64(); }
-  bool has_truesize() const { return at<16>().valid(); }
-  uint32_t truesize() const { return at<16>().as_uint32(); }
-  bool has_vlan_proto() const { return at<17>().valid(); }
-  uint32_t vlan_proto() const { return at<17>().as_uint32(); }
-  bool has_vlan_tagged() const { return at<18>().valid(); }
-  uint32_t vlan_tagged() const { return at<18>().as_uint32(); }
-  bool has_vlan_tci() const { return at<19>().valid(); }
-  uint32_t vlan_tci() const { return at<19>().as_uint32(); }
+  KvmExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_esr_ec() const { return at<1>().valid(); }
+  uint32_t esr_ec() const { return at<1>().as_uint32(); }
+  bool has_ret() const { return at<2>().valid(); }
+  int32_t ret() const { return at<2>().as_int32(); }
+  bool has_vcpu_pc() const { return at<3>().valid(); }
+  uint64_t vcpu_pc() const { return at<3>().as_uint64(); }
 };
 
-class NapiGroReceiveEntryFtraceEvent : public ::protozero::Message {
+class KvmExitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = NapiGroReceiveEntryFtraceEvent_Decoder;
+  using Decoder = KvmExitFtraceEvent_Decoder;
   enum : int32_t {
-    kDataLenFieldNumber = 1,
-    kGsoSizeFieldNumber = 2,
-    kGsoTypeFieldNumber = 3,
-    kHashFieldNumber = 4,
-    kIpSummedFieldNumber = 5,
-    kL4HashFieldNumber = 6,
-    kLenFieldNumber = 7,
-    kMacHeaderFieldNumber = 8,
-    kMacHeaderValidFieldNumber = 9,
-    kNameFieldNumber = 10,
-    kNapiIdFieldNumber = 11,
-    kNrFragsFieldNumber = 12,
-    kProtocolFieldNumber = 13,
-    kQueueMappingFieldNumber = 14,
-    kSkbaddrFieldNumber = 15,
-    kTruesizeFieldNumber = 16,
-    kVlanProtoFieldNumber = 17,
-    kVlanTaggedFieldNumber = 18,
-    kVlanTciFieldNumber = 19,
+    kEsrEcFieldNumber = 1,
+    kRetFieldNumber = 2,
+    kVcpuPcFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.NapiGroReceiveEntryFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmExitFtraceEvent"; }
 
 
-  using FieldMetadata_DataLen =
+  using FieldMetadata_EsrEc =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      NapiGroReceiveEntryFtraceEvent>;
+      KvmExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DataLen kDataLen() { return {}; }
-  void set_data_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DataLen::kFieldId;
+  static constexpr FieldMetadata_EsrEc kEsrEc{};
+  void set_esr_ec(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EsrEc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -116255,124 +143588,112 @@ class NapiGroReceiveEntryFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_GsoSize =
+  using FieldMetadata_Ret =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      NapiGroReceiveEntryFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KvmExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GsoSize kGsoSize() { return {}; }
-  void set_gso_size(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GsoSize::kFieldId;
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_GsoType =
+  using FieldMetadata_VcpuPc =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      NapiGroReceiveEntryFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GsoType kGsoType() { return {}; }
-  void set_gso_type(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GsoType::kFieldId;
+  static constexpr FieldMetadata_VcpuPc kVcpuPc{};
+  void set_vcpu_pc(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Hash =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      NapiGroReceiveEntryFtraceEvent>;
+class KvmEntryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  KvmEntryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmEntryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmEntryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_vcpu_pc() const { return at<1>().valid(); }
+  uint64_t vcpu_pc() const { return at<1>().as_uint64(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Hash kHash() { return {}; }
-  void set_hash(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Hash::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+class KvmEntryFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KvmEntryFtraceEvent_Decoder;
+  enum : int32_t {
+    kVcpuPcFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmEntryFtraceEvent"; }
 
-  using FieldMetadata_IpSummed =
+
+  using FieldMetadata_VcpuPc =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      NapiGroReceiveEntryFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IpSummed kIpSummed() { return {}; }
-  void set_ip_summed(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IpSummed::kFieldId;
+  static constexpr FieldMetadata_VcpuPc kVcpuPc{};
+  void set_vcpu_pc(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_L4Hash =
+class KvmArmSetupDebugFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  KvmArmSetupDebugFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmArmSetupDebugFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmArmSetupDebugFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_guest_debug() const { return at<1>().valid(); }
+  uint32_t guest_debug() const { return at<1>().as_uint32(); }
+  bool has_vcpu() const { return at<2>().valid(); }
+  uint64_t vcpu() const { return at<2>().as_uint64(); }
+};
+
+class KvmArmSetupDebugFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KvmArmSetupDebugFtraceEvent_Decoder;
+  enum : int32_t {
+    kGuestDebugFieldNumber = 1,
+    kVcpuFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmArmSetupDebugFtraceEvent"; }
+
+
+  using FieldMetadata_GuestDebug =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      NapiGroReceiveEntryFtraceEvent>;
+      KvmArmSetupDebugFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_L4Hash kL4Hash() { return {}; }
-  void set_l4_hash(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_L4Hash::kFieldId;
+  static constexpr FieldMetadata_GuestDebug kGuestDebug{};
+  void set_guest_debug(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GuestDebug::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -116380,49 +143701,57 @@ class NapiGroReceiveEntryFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_Vcpu =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      NapiGroReceiveEntryFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmArmSetupDebugFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_Vcpu kVcpu{};
+  void set_vcpu(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Vcpu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_MacHeader =
+class KvmArmSetRegsetFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  KvmArmSetRegsetFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmArmSetRegsetFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmArmSetRegsetFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_len() const { return at<1>().valid(); }
+  int32_t len() const { return at<1>().as_int32(); }
+  bool has_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars name() const { return at<2>().as_string(); }
+};
+
+class KvmArmSetRegsetFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KvmArmSetRegsetFtraceEvent_Decoder;
+  enum : int32_t {
+    kLenFieldNumber = 1,
+    kNameFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmArmSetRegsetFtraceEvent"; }
+
+
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      NapiGroReceiveEntryFtraceEvent>;
+      KvmArmSetRegsetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MacHeader kMacHeader() { return {}; }
-  void set_mac_header(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MacHeader::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -116430,47 +143759,61 @@ class NapiGroReceiveEntryFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MacHeaderValid =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      NapiGroReceiveEntryFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      KvmArmSetRegsetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MacHeaderValid kMacHeaderValid() { return {}; }
-  void set_mac_header_valid(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MacHeaderValid::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+};
+
+class KvmArmSetDreg32FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  KvmArmSetDreg32FtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmArmSetDreg32FtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmArmSetDreg32FtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_value() const { return at<2>().valid(); }
+  uint32_t value() const { return at<2>().as_uint32(); }
+};
+
+class KvmArmSetDreg32FtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KvmArmSetDreg32FtraceEvent_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmArmSetDreg32FtraceEvent"; }
+
 
   using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      NapiGroReceiveEntryFtraceEvent>;
+      KvmArmSetDreg32FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
+  static constexpr FieldMetadata_Name kName{};
   void set_name(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
@@ -116486,124 +143829,100 @@ class NapiGroReceiveEntryFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NapiId =
+  using FieldMetadata_Value =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      NapiGroReceiveEntryFtraceEvent>;
+      KvmArmSetDreg32FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NapiId kNapiId() { return {}; }
-  void set_napi_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NapiId::kFieldId;
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_NrFrags =
-    ::protozero::proto_utils::FieldMetadata<
-      12,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      NapiGroReceiveEntryFtraceEvent>;
+class KvmArmClearDebugFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  KvmArmClearDebugFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmArmClearDebugFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmArmClearDebugFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_guest_debug() const { return at<1>().valid(); }
+  uint32_t guest_debug() const { return at<1>().as_uint32(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrFrags kNrFrags() { return {}; }
-  void set_nr_frags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NrFrags::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+class KvmArmClearDebugFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KvmArmClearDebugFtraceEvent_Decoder;
+  enum : int32_t {
+    kGuestDebugFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmArmClearDebugFtraceEvent"; }
 
-  using FieldMetadata_Protocol =
+
+  using FieldMetadata_GuestDebug =
     ::protozero::proto_utils::FieldMetadata<
-      13,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      NapiGroReceiveEntryFtraceEvent>;
+      KvmArmClearDebugFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Protocol kProtocol() { return {}; }
-  void set_protocol(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Protocol::kFieldId;
+  static constexpr FieldMetadata_GuestDebug kGuestDebug{};
+  void set_guest_debug(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GuestDebug::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_QueueMapping =
-    ::protozero::proto_utils::FieldMetadata<
-      14,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      NapiGroReceiveEntryFtraceEvent>;
+class KvmAgePageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  KvmAgePageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmAgePageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmAgePageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_gfn() const { return at<1>().valid(); }
+  uint64_t gfn() const { return at<1>().as_uint64(); }
+  bool has_hva() const { return at<2>().valid(); }
+  uint64_t hva() const { return at<2>().as_uint64(); }
+  bool has_level() const { return at<3>().valid(); }
+  uint32_t level() const { return at<3>().as_uint32(); }
+  bool has_referenced() const { return at<4>().valid(); }
+  uint32_t referenced() const { return at<4>().as_uint32(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_QueueMapping kQueueMapping() { return {}; }
-  void set_queue_mapping(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_QueueMapping::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+class KvmAgePageFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KvmAgePageFtraceEvent_Decoder;
+  enum : int32_t {
+    kGfnFieldNumber = 1,
+    kHvaFieldNumber = 2,
+    kLevelFieldNumber = 3,
+    kReferencedFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmAgePageFtraceEvent"; }
 
-  using FieldMetadata_Skbaddr =
+
+  using FieldMetadata_Gfn =
     ::protozero::proto_utils::FieldMetadata<
-      15,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      NapiGroReceiveEntryFtraceEvent>;
+      KvmAgePageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Skbaddr kSkbaddr() { return {}; }
-  void set_skbaddr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Skbaddr::kFieldId;
+  static constexpr FieldMetadata_Gfn kGfn{};
+  void set_gfn(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Gfn::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -116611,74 +143930,35 @@ class NapiGroReceiveEntryFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Truesize =
-    ::protozero::proto_utils::FieldMetadata<
-      16,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      NapiGroReceiveEntryFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Truesize kTruesize() { return {}; }
-  void set_truesize(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Truesize::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_VlanProto =
+  using FieldMetadata_Hva =
     ::protozero::proto_utils::FieldMetadata<
-      17,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      NapiGroReceiveEntryFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmAgePageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VlanProto kVlanProto() { return {}; }
-  void set_vlan_proto(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VlanProto::kFieldId;
+  static constexpr FieldMetadata_Hva kHva{};
+  void set_hva(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Hva::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VlanTagged =
+  using FieldMetadata_Level =
     ::protozero::proto_utils::FieldMetadata<
-      18,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      NapiGroReceiveEntryFtraceEvent>;
+      KvmAgePageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VlanTagged kVlanTagged() { return {}; }
-  void set_vlan_tagged(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VlanTagged::kFieldId;
+  static constexpr FieldMetadata_Level kLevel{};
+  void set_level(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -116686,24 +143966,17 @@ class NapiGroReceiveEntryFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VlanTci =
+  using FieldMetadata_Referenced =
     ::protozero::proto_utils::FieldMetadata<
-      19,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      NapiGroReceiveEntryFtraceEvent>;
+      KvmAgePageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VlanTci kVlanTci() { return {}; }
-  void set_vlan_tci(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VlanTci::kFieldId;
+  static constexpr FieldMetadata_Referenced kReferenced{};
+  void set_referenced(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Referenced::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -116712,132 +143985,56 @@ class NapiGroReceiveEntryFtraceEvent : public ::protozero::Message {
   }
 };
 
-class NetDevXmitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class KvmAgeHvaFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  NetDevXmitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit NetDevXmitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit NetDevXmitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_len() const { return at<1>().valid(); }
-  uint32_t len() const { return at<1>().as_uint32(); }
-  bool has_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars name() const { return at<2>().as_string(); }
-  bool has_rc() const { return at<3>().valid(); }
-  int32_t rc() const { return at<3>().as_int32(); }
-  bool has_skbaddr() const { return at<4>().valid(); }
-  uint64_t skbaddr() const { return at<4>().as_uint64(); }
+  KvmAgeHvaFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmAgeHvaFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmAgeHvaFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_end() const { return at<1>().valid(); }
+  uint64_t end() const { return at<1>().as_uint64(); }
+  bool has_start() const { return at<2>().valid(); }
+  uint64_t start() const { return at<2>().as_uint64(); }
 };
 
-class NetDevXmitFtraceEvent : public ::protozero::Message {
+class KvmAgeHvaFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = NetDevXmitFtraceEvent_Decoder;
+  using Decoder = KvmAgeHvaFtraceEvent_Decoder;
   enum : int32_t {
-    kLenFieldNumber = 1,
-    kNameFieldNumber = 2,
-    kRcFieldNumber = 3,
-    kSkbaddrFieldNumber = 4,
+    kEndFieldNumber = 1,
+    kStartFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.NetDevXmitFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmAgeHvaFtraceEvent"; }
 
 
-  using FieldMetadata_Len =
+  using FieldMetadata_End =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      NetDevXmitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KvmAgeHvaFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_End kEnd{};
+  void set_end(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_End::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Name =
+  using FieldMetadata_Start =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      NetDevXmitFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Rc =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      NetDevXmitFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Rc kRc() { return {}; }
-  void set_rc(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Rc::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Skbaddr =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      NetDevXmitFtraceEvent>;
+      KvmAgeHvaFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Skbaddr kSkbaddr() { return {}; }
-  void set_skbaddr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Skbaddr::kFieldId;
+  static constexpr FieldMetadata_Start kStart{};
+  void set_start(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -116846,48 +144043,38 @@ class NetDevXmitFtraceEvent : public ::protozero::Message {
   }
 };
 
-class NetifReceiveSkbFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class KvmAckIrqFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  NetifReceiveSkbFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit NetifReceiveSkbFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit NetifReceiveSkbFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_len() const { return at<1>().valid(); }
-  uint32_t len() const { return at<1>().as_uint32(); }
-  bool has_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars name() const { return at<2>().as_string(); }
-  bool has_skbaddr() const { return at<3>().valid(); }
-  uint64_t skbaddr() const { return at<3>().as_uint64(); }
+  KvmAckIrqFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmAckIrqFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmAckIrqFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_irqchip() const { return at<1>().valid(); }
+  uint32_t irqchip() const { return at<1>().as_uint32(); }
+  bool has_pin() const { return at<2>().valid(); }
+  uint32_t pin() const { return at<2>().as_uint32(); }
 };
 
-class NetifReceiveSkbFtraceEvent : public ::protozero::Message {
+class KvmAckIrqFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = NetifReceiveSkbFtraceEvent_Decoder;
+  using Decoder = KvmAckIrqFtraceEvent_Decoder;
   enum : int32_t {
-    kLenFieldNumber = 1,
-    kNameFieldNumber = 2,
-    kSkbaddrFieldNumber = 3,
+    kIrqchipFieldNumber = 1,
+    kPinFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.NetifReceiveSkbFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmAckIrqFtraceEvent"; }
 
 
-  using FieldMetadata_Len =
+  using FieldMetadata_Irqchip =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      NetifReceiveSkbFtraceEvent>;
+      KvmAckIrqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_Irqchip kIrqchip{};
+  void set_irqchip(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Irqchip::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -116895,55 +144082,54 @@ class NetifReceiveSkbFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Name =
+  using FieldMetadata_Pin =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      NetifReceiveSkbFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KvmAckIrqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_Pin kPin{};
+  void set_pin(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pin::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Skbaddr =
+class KvmAccessFaultFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  KvmAccessFaultFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KvmAccessFaultFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KvmAccessFaultFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_ipa() const { return at<1>().valid(); }
+  uint64_t ipa() const { return at<1>().as_uint64(); }
+};
+
+class KvmAccessFaultFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KvmAccessFaultFtraceEvent_Decoder;
+  enum : int32_t {
+    kIpaFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KvmAccessFaultFtraceEvent"; }
+
+
+  using FieldMetadata_Ipa =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      NetifReceiveSkbFtraceEvent>;
+      KvmAccessFaultFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Skbaddr kSkbaddr() { return {}; }
-  void set_skbaddr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Skbaddr::kFieldId;
+  static constexpr FieldMetadata_Ipa kIpa{};
+  void set_ipa(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ipa::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -116956,11 +144142,11 @@ class NetifReceiveSkbFtraceEvent : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/oom.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/lowmemorykiller.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_OOM_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_OOM_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_LOWMEMORYKILLER_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_LOWMEMORYKILLER_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -116971,77 +144157,39 @@ class NetifReceiveSkbFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class MarkVictimFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  MarkVictimFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MarkVictimFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MarkVictimFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pid() const { return at<1>().valid(); }
-  int32_t pid() const { return at<1>().as_int32(); }
-};
-
-class MarkVictimFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = MarkVictimFtraceEvent_Decoder;
-  enum : int32_t {
-    kPidFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.MarkVictimFtraceEvent"; }
-
-
-  using FieldMetadata_Pid =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MarkVictimFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-};
-
-class OomScoreAdjUpdateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class LowmemoryKillFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  OomScoreAdjUpdateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit OomScoreAdjUpdateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit OomScoreAdjUpdateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  LowmemoryKillFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit LowmemoryKillFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit LowmemoryKillFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_comm() const { return at<1>().valid(); }
   ::protozero::ConstChars comm() const { return at<1>().as_string(); }
-  bool has_oom_score_adj() const { return at<2>().valid(); }
-  int32_t oom_score_adj() const { return at<2>().as_int32(); }
-  bool has_pid() const { return at<3>().valid(); }
-  int32_t pid() const { return at<3>().as_int32(); }
+  bool has_pid() const { return at<2>().valid(); }
+  int32_t pid() const { return at<2>().as_int32(); }
+  bool has_pagecache_size() const { return at<3>().valid(); }
+  int64_t pagecache_size() const { return at<3>().as_int64(); }
+  bool has_pagecache_limit() const { return at<4>().valid(); }
+  int64_t pagecache_limit() const { return at<4>().as_int64(); }
+  bool has_free() const { return at<5>().valid(); }
+  int64_t free() const { return at<5>().as_int64(); }
 };
 
-class OomScoreAdjUpdateFtraceEvent : public ::protozero::Message {
+class LowmemoryKillFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = OomScoreAdjUpdateFtraceEvent_Decoder;
+  using Decoder = LowmemoryKillFtraceEvent_Decoder;
   enum : int32_t {
-    kCommFieldNumber = 1,
-    kOomScoreAdjFieldNumber = 2,
-    kPidFieldNumber = 3,
+    kCommFieldNumber = 1,
+    kPidFieldNumber = 2,
+    kPagecacheSizeFieldNumber = 3,
+    kPagecacheLimitFieldNumber = 4,
+    kFreeFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.OomScoreAdjUpdateFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.LowmemoryKillFtraceEvent"; }
 
 
   using FieldMetadata_Comm =
@@ -117050,16 +144198,9 @@ class OomScoreAdjUpdateFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      OomScoreAdjUpdateFtraceEvent>;
+      LowmemoryKillFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
+  static constexpr FieldMetadata_Comm kComm{};
   void set_comm(const char* data, size_t size) {
     AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
   }
@@ -117075,24 +144216,17 @@ class OomScoreAdjUpdateFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_OomScoreAdj =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      OomScoreAdjUpdateFtraceEvent>;
+      LowmemoryKillFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OomScoreAdj kOomScoreAdj() { return {}; }
-  void set_oom_score_adj(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OomScoreAdj::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -117100,28 +144234,57 @@ class OomScoreAdjUpdateFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_PagecacheSize =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      OomScoreAdjUpdateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      LowmemoryKillFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_PagecacheSize kPagecacheSize{};
+  void set_pagecache_size(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PagecacheSize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PagecacheLimit =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      LowmemoryKillFtraceEvent>;
+
+  static constexpr FieldMetadata_PagecacheLimit kPagecacheLimit{};
+  void set_pagecache_limit(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PagecacheLimit::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Free =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      LowmemoryKillFtraceEvent>;
+
+  static constexpr FieldMetadata_Free kFree{};
+  void set_free(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Free::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 };
@@ -117130,11 +144293,11 @@ class OomScoreAdjUpdateFtraceEvent : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/panel.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/lwis.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_PANEL_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_PANEL_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_LWIS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_LWIS_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -117145,101 +144308,74 @@ class OomScoreAdjUpdateFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class DsiTxFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class LwisTracingMarkWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  DsiTxFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit DsiTxFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit DsiTxFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_last() const { return at<1>().valid(); }
-  uint32_t last() const { return at<1>().as_uint32(); }
-  bool has_tx_buf() const { return at<2>().valid(); }
-  uint32_t tx_buf() const { return at<2>().as_uint32(); }
-  bool has_type() const { return at<3>().valid(); }
-  uint32_t type() const { return at<3>().as_uint32(); }
+  LwisTracingMarkWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit LwisTracingMarkWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit LwisTracingMarkWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_lwis_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars lwis_name() const { return at<1>().as_string(); }
+  bool has_type() const { return at<2>().valid(); }
+  uint32_t type() const { return at<2>().as_uint32(); }
+  bool has_pid() const { return at<3>().valid(); }
+  int32_t pid() const { return at<3>().as_int32(); }
+  bool has_func_name() const { return at<4>().valid(); }
+  ::protozero::ConstChars func_name() const { return at<4>().as_string(); }
+  bool has_value() const { return at<5>().valid(); }
+  int64_t value() const { return at<5>().as_int64(); }
 };
 
-class DsiTxFtraceEvent : public ::protozero::Message {
+class LwisTracingMarkWriteFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = DsiTxFtraceEvent_Decoder;
+  using Decoder = LwisTracingMarkWriteFtraceEvent_Decoder;
   enum : int32_t {
-    kLastFieldNumber = 1,
-    kTxBufFieldNumber = 2,
-    kTypeFieldNumber = 3,
+    kLwisNameFieldNumber = 1,
+    kTypeFieldNumber = 2,
+    kPidFieldNumber = 3,
+    kFuncNameFieldNumber = 4,
+    kValueFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.DsiTxFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.LwisTracingMarkWriteFtraceEvent"; }
 
 
-  using FieldMetadata_Last =
+  using FieldMetadata_LwisName =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      DsiTxFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      LwisTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Last kLast() { return {}; }
-  void set_last(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Last::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_LwisName kLwisName{};
+  void set_lwis_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_LwisName::kFieldId, data, size);
   }
-
-  using FieldMetadata_TxBuf =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      DsiTxFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TxBuf kTxBuf() { return {}; }
-  void set_tx_buf(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TxBuf::kFieldId;
+  void set_lwis_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_LwisName::kFieldId, chars.data, chars.size);
+  }
+  void set_lwis_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_LwisName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
   using FieldMetadata_Type =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      DsiTxFtraceEvent>;
+      LwisTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
+  static constexpr FieldMetadata_Type kType{};
   void set_type(uint32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -117248,148 +144384,64 @@ class DsiTxFtraceEvent : public ::protozero::Message {
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class DsiRxFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  DsiRxFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit DsiRxFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit DsiRxFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_cmd() const { return at<1>().valid(); }
-  uint32_t cmd() const { return at<1>().as_uint32(); }
-  bool has_rx_buf() const { return at<2>().valid(); }
-  uint32_t rx_buf() const { return at<2>().as_uint32(); }
-};
-
-class DsiRxFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = DsiRxFtraceEvent_Decoder;
-  enum : int32_t {
-    kCmdFieldNumber = 1,
-    kRxBufFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.DsiRxFtraceEvent"; }
-
 
-  using FieldMetadata_Cmd =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      DsiRxFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      LwisTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cmd kCmd() { return {}; }
-  void set_cmd(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Cmd::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_RxBuf =
+  using FieldMetadata_FuncName =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      DsiRxFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      LwisTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RxBuf kRxBuf() { return {}; }
-  void set_rx_buf(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RxBuf::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_FuncName kFuncName{};
+  void set_func_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_FuncName::kFieldId, data, size);
   }
-};
-
-class DsiCmdFifoStatusFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  DsiCmdFifoStatusFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit DsiCmdFifoStatusFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit DsiCmdFifoStatusFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_header() const { return at<1>().valid(); }
-  uint32_t header() const { return at<1>().as_uint32(); }
-  bool has_payload() const { return at<2>().valid(); }
-  uint32_t payload() const { return at<2>().as_uint32(); }
-};
-
-class DsiCmdFifoStatusFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = DsiCmdFifoStatusFtraceEvent_Decoder;
-  enum : int32_t {
-    kHeaderFieldNumber = 1,
-    kPayloadFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.DsiCmdFifoStatusFtraceEvent"; }
-
-
-  using FieldMetadata_Header =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      DsiCmdFifoStatusFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Header kHeader() { return {}; }
-  void set_header(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Header::kFieldId;
+  void set_func_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_FuncName::kFieldId, chars.data, chars.size);
+  }
+  void set_func_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_FuncName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Payload =
+  using FieldMetadata_Value =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      DsiCmdFifoStatusFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      LwisTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Payload kPayload() { return {}; }
-  void set_payload(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Payload::kFieldId;
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 };
@@ -117398,11 +144450,11 @@ class DsiCmdFifoStatusFtraceEvent : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/power.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/mali.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_POWER_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_POWER_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_MALI_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_MALI_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -117413,159 +144465,161 @@ class DsiCmdFifoStatusFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class WakeupSourceDeactivateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliGpuPowerStateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  WakeupSourceDeactivateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit WakeupSourceDeactivateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit WakeupSourceDeactivateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_state() const { return at<2>().valid(); }
-  uint64_t state() const { return at<2>().as_uint64(); }
+  MaliGpuPowerStateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliGpuPowerStateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliGpuPowerStateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_change_ns() const { return at<1>().valid(); }
+  uint64_t change_ns() const { return at<1>().as_uint64(); }
+  bool has_from_state() const { return at<2>().valid(); }
+  int32_t from_state() const { return at<2>().as_int32(); }
+  bool has_to_state() const { return at<3>().valid(); }
+  int32_t to_state() const { return at<3>().as_int32(); }
 };
 
-class WakeupSourceDeactivateFtraceEvent : public ::protozero::Message {
+class MaliGpuPowerStateFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = WakeupSourceDeactivateFtraceEvent_Decoder;
+  using Decoder = MaliGpuPowerStateFtraceEvent_Decoder;
   enum : int32_t {
-    kNameFieldNumber = 1,
-    kStateFieldNumber = 2,
+    kChangeNsFieldNumber = 1,
+    kFromStateFieldNumber = 2,
+    kToStateFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.WakeupSourceDeactivateFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliGpuPowerStateFtraceEvent"; }
 
 
-  using FieldMetadata_Name =
+  using FieldMetadata_ChangeNs =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      WakeupSourceDeactivateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliGpuPowerStateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_ChangeNs kChangeNs{};
+  void set_change_ns(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ChangeNs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_State =
+  using FieldMetadata_FromState =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      WakeupSourceDeactivateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliGpuPowerStateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_State kState() { return {}; }
-  void set_state(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
+  static constexpr FieldMetadata_FromState kFromState{};
+  void set_from_state(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FromState::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ToState =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliGpuPowerStateFtraceEvent>;
+
+  static constexpr FieldMetadata_ToState kToState{};
+  void set_to_state(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ToState::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class WakeupSourceActivateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliPMMCURESETWAITFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  WakeupSourceActivateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit WakeupSourceActivateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit WakeupSourceActivateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_state() const { return at<2>().valid(); }
-  uint64_t state() const { return at<2>().as_uint64(); }
+  MaliMaliPMMCURESETWAITFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliPMMCURESETWAITFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliPMMCURESETWAITFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
 };
 
-class WakeupSourceActivateFtraceEvent : public ::protozero::Message {
+class MaliMaliPMMCURESETWAITFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = WakeupSourceActivateFtraceEvent_Decoder;
+  using Decoder = MaliMaliPMMCURESETWAITFtraceEvent_Decoder;
   enum : int32_t {
-    kNameFieldNumber = 1,
-    kStateFieldNumber = 2,
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.WakeupSourceActivateFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCURESETWAITFtraceEvent"; }
 
 
-  using FieldMetadata_Name =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      WakeupSourceActivateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliMaliPMMCURESETWAITFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_State =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliPMMCURESETWAITFtraceEvent>;
+
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_InfoVal =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      WakeupSourceActivateFtraceEvent>;
+      MaliMaliPMMCURESETWAITFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_State kState() { return {}; }
-  void set_state(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -117574,282 +144628,235 @@ class WakeupSourceActivateFtraceEvent : public ::protozero::Message {
   }
 };
 
-class GpuFrequencyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliPMMCUPOWERDOWNFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  GpuFrequencyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit GpuFrequencyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit GpuFrequencyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_gpu_id() const { return at<1>().valid(); }
-  uint32_t gpu_id() const { return at<1>().as_uint32(); }
-  bool has_state() const { return at<2>().valid(); }
-  uint32_t state() const { return at<2>().as_uint32(); }
+  MaliMaliPMMCUPOWERDOWNFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliPMMCUPOWERDOWNFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliPMMCUPOWERDOWNFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
 };
 
-class GpuFrequencyFtraceEvent : public ::protozero::Message {
+class MaliMaliPMMCUPOWERDOWNFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = GpuFrequencyFtraceEvent_Decoder;
+  using Decoder = MaliMaliPMMCUPOWERDOWNFtraceEvent_Decoder;
   enum : int32_t {
-    kGpuIdFieldNumber = 1,
-    kStateFieldNumber = 2,
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.GpuFrequencyFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUPOWERDOWNFtraceEvent"; }
 
 
-  using FieldMetadata_GpuId =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      GpuFrequencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliMaliPMMCUPOWERDOWNFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GpuId kGpuId() { return {}; }
-  void set_gpu_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GpuId::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_State =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      GpuFrequencyFtraceEvent>;
+      MaliMaliPMMCUPOWERDOWNFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_State kState() { return {}; }
-  void set_state(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_InfoVal =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliPMMCUPOWERDOWNFtraceEvent>;
+
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class SuspendResumeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliPMMCUPENDONRELOADFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  SuspendResumeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SuspendResumeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SuspendResumeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_action() const { return at<1>().valid(); }
-  ::protozero::ConstChars action() const { return at<1>().as_string(); }
-  bool has_val() const { return at<2>().valid(); }
-  int32_t val() const { return at<2>().as_int32(); }
-  bool has_start() const { return at<3>().valid(); }
-  uint32_t start() const { return at<3>().as_uint32(); }
+  MaliMaliPMMCUPENDONRELOADFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliPMMCUPENDONRELOADFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliPMMCUPENDONRELOADFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
 };
 
-class SuspendResumeFtraceEvent : public ::protozero::Message {
+class MaliMaliPMMCUPENDONRELOADFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SuspendResumeFtraceEvent_Decoder;
+  using Decoder = MaliMaliPMMCUPENDONRELOADFtraceEvent_Decoder;
   enum : int32_t {
-    kActionFieldNumber = 1,
-    kValFieldNumber = 2,
-    kStartFieldNumber = 3,
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SuspendResumeFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUPENDONRELOADFtraceEvent"; }
 
 
-  using FieldMetadata_Action =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SuspendResumeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliMaliPMMCUPENDONRELOADFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Action kAction() { return {}; }
-  void set_action(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Action::kFieldId, data, size);
-  }
-  void set_action(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Action::kFieldId, chars.data, chars.size);
-  }
-  void set_action(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Action::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Val =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SuspendResumeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliPMMCUPENDONRELOADFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Val kVal() { return {}; }
-  void set_val(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Val::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Start =
+  using FieldMetadata_InfoVal =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SuspendResumeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliPMMCUPENDONRELOADFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Start kStart() { return {}; }
-  void set_start(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class ClockSetRateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliPMMCUPENDOFFFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  ClockSetRateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ClockSetRateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ClockSetRateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_state() const { return at<2>().valid(); }
-  uint64_t state() const { return at<2>().as_uint64(); }
-  bool has_cpu_id() const { return at<3>().valid(); }
-  uint64_t cpu_id() const { return at<3>().as_uint64(); }
+  MaliMaliPMMCUPENDOFFFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliPMMCUPENDOFFFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliPMMCUPENDOFFFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
 };
 
-class ClockSetRateFtraceEvent : public ::protozero::Message {
+class MaliMaliPMMCUPENDOFFFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = ClockSetRateFtraceEvent_Decoder;
+  using Decoder = MaliMaliPMMCUPENDOFFFtraceEvent_Decoder;
   enum : int32_t {
-    kNameFieldNumber = 1,
-    kStateFieldNumber = 2,
-    kCpuIdFieldNumber = 3,
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ClockSetRateFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUPENDOFFFtraceEvent"; }
 
 
-  using FieldMetadata_Name =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ClockSetRateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliMaliPMMCUPENDOFFFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_State =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ClockSetRateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliPMMCUPENDOFFFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_State kState() { return {}; }
-  void set_state(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CpuId =
+  using FieldMetadata_InfoVal =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      ClockSetRateFtraceEvent>;
+      MaliMaliPMMCUPENDOFFFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpuId kCpuId() { return {}; }
-  void set_cpu_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CpuId::kFieldId;
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -117858,104 +144865,77 @@ class ClockSetRateFtraceEvent : public ::protozero::Message {
   }
 };
 
-class ClockDisableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliPMMCUONSLEEPINITIATEFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  ClockDisableFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ClockDisableFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ClockDisableFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_state() const { return at<2>().valid(); }
-  uint64_t state() const { return at<2>().as_uint64(); }
-  bool has_cpu_id() const { return at<3>().valid(); }
-  uint64_t cpu_id() const { return at<3>().as_uint64(); }
+  MaliMaliPMMCUONSLEEPINITIATEFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliPMMCUONSLEEPINITIATEFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliPMMCUONSLEEPINITIATEFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
 };
 
-class ClockDisableFtraceEvent : public ::protozero::Message {
+class MaliMaliPMMCUONSLEEPINITIATEFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = ClockDisableFtraceEvent_Decoder;
+  using Decoder = MaliMaliPMMCUONSLEEPINITIATEFtraceEvent_Decoder;
   enum : int32_t {
-    kNameFieldNumber = 1,
-    kStateFieldNumber = 2,
-    kCpuIdFieldNumber = 3,
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ClockDisableFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUONSLEEPINITIATEFtraceEvent"; }
 
 
-  using FieldMetadata_Name =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ClockDisableFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliMaliPMMCUONSLEEPINITIATEFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_State =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ClockDisableFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliPMMCUONSLEEPINITIATEFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_State kState() { return {}; }
-  void set_state(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CpuId =
+  using FieldMetadata_InfoVal =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      ClockDisableFtraceEvent>;
+      MaliMaliPMMCUONSLEEPINITIATEFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpuId kCpuId() { return {}; }
-  void set_cpu_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CpuId::kFieldId;
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -117964,104 +144944,77 @@ class ClockDisableFtraceEvent : public ::protozero::Message {
   }
 };
 
-class ClockEnableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliPMMCUONPENDSLEEPFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  ClockEnableFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ClockEnableFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ClockEnableFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_state() const { return at<2>().valid(); }
-  uint64_t state() const { return at<2>().as_uint64(); }
-  bool has_cpu_id() const { return at<3>().valid(); }
-  uint64_t cpu_id() const { return at<3>().as_uint64(); }
+  MaliMaliPMMCUONPENDSLEEPFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliPMMCUONPENDSLEEPFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliPMMCUONPENDSLEEPFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
 };
 
-class ClockEnableFtraceEvent : public ::protozero::Message {
+class MaliMaliPMMCUONPENDSLEEPFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = ClockEnableFtraceEvent_Decoder;
+  using Decoder = MaliMaliPMMCUONPENDSLEEPFtraceEvent_Decoder;
   enum : int32_t {
-    kNameFieldNumber = 1,
-    kStateFieldNumber = 2,
-    kCpuIdFieldNumber = 3,
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ClockEnableFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUONPENDSLEEPFtraceEvent"; }
 
 
-  using FieldMetadata_Name =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ClockEnableFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliMaliPMMCUONPENDSLEEPFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_State =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ClockEnableFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliPMMCUONPENDSLEEPFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_State kState() { return {}; }
-  void set_state(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CpuId =
+  using FieldMetadata_InfoVal =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      ClockEnableFtraceEvent>;
+      MaliMaliPMMCUONPENDSLEEPFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpuId kCpuId() { return {}; }
-  void set_cpu_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CpuId::kFieldId;
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -118070,145 +145023,138 @@ class ClockEnableFtraceEvent : public ::protozero::Message {
   }
 };
 
-class CpuIdleFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliPMMCUONPENDHALTFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  CpuIdleFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit CpuIdleFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit CpuIdleFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_state() const { return at<1>().valid(); }
-  uint32_t state() const { return at<1>().as_uint32(); }
-  bool has_cpu_id() const { return at<2>().valid(); }
-  uint32_t cpu_id() const { return at<2>().as_uint32(); }
+  MaliMaliPMMCUONPENDHALTFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliPMMCUONPENDHALTFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliPMMCUONPENDHALTFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
 };
 
-class CpuIdleFtraceEvent : public ::protozero::Message {
+class MaliMaliPMMCUONPENDHALTFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = CpuIdleFtraceEvent_Decoder;
+  using Decoder = MaliMaliPMMCUONPENDHALTFtraceEvent_Decoder;
   enum : int32_t {
-    kStateFieldNumber = 1,
-    kCpuIdFieldNumber = 2,
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.CpuIdleFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUONPENDHALTFtraceEvent"; }
 
 
-  using FieldMetadata_State =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      CpuIdleFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliMaliPMMCUONPENDHALTFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_State kState() { return {}; }
-  void set_state(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CpuId =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      CpuIdleFtraceEvent>;
+      MaliMaliPMMCUONPENDHALTFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpuId kCpuId() { return {}; }
-  void set_cpu_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CpuId::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_InfoVal =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliPMMCUONPENDHALTFtraceEvent>;
+
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class CpuFrequencyLimitsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliPMMCUONHWCNTENABLEFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  CpuFrequencyLimitsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit CpuFrequencyLimitsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit CpuFrequencyLimitsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_min_freq() const { return at<1>().valid(); }
-  uint32_t min_freq() const { return at<1>().as_uint32(); }
-  bool has_max_freq() const { return at<2>().valid(); }
-  uint32_t max_freq() const { return at<2>().as_uint32(); }
-  bool has_cpu_id() const { return at<3>().valid(); }
-  uint32_t cpu_id() const { return at<3>().as_uint32(); }
+  MaliMaliPMMCUONHWCNTENABLEFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliPMMCUONHWCNTENABLEFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliPMMCUONHWCNTENABLEFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
 };
 
-class CpuFrequencyLimitsFtraceEvent : public ::protozero::Message {
+class MaliMaliPMMCUONHWCNTENABLEFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = CpuFrequencyLimitsFtraceEvent_Decoder;
+  using Decoder = MaliMaliPMMCUONHWCNTENABLEFtraceEvent_Decoder;
   enum : int32_t {
-    kMinFreqFieldNumber = 1,
-    kMaxFreqFieldNumber = 2,
-    kCpuIdFieldNumber = 3,
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.CpuFrequencyLimitsFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUONHWCNTENABLEFtraceEvent"; }
 
 
-  using FieldMetadata_MinFreq =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      CpuFrequencyLimitsFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliMaliPMMCUONHWCNTENABLEFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MinFreq kMinFreq() { return {}; }
-  void set_min_freq(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MinFreq::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MaxFreq =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      CpuFrequencyLimitsFtraceEvent>;
+      MaliMaliPMMCUONHWCNTENABLEFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaxFreq kMaxFreq() { return {}; }
-  void set_max_freq(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MaxFreq::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -118216,338 +145162,175 @@ class CpuFrequencyLimitsFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CpuId =
+  using FieldMetadata_InfoVal =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      CpuFrequencyLimitsFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliPMMCUONHWCNTENABLEFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpuId kCpuId() { return {}; }
-  void set_cpu_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CpuId::kFieldId;
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class CpuFrequencyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliPMMCUONHWCNTDISABLEFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  CpuFrequencyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit CpuFrequencyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit CpuFrequencyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_state() const { return at<1>().valid(); }
-  uint32_t state() const { return at<1>().as_uint32(); }
-  bool has_cpu_id() const { return at<2>().valid(); }
-  uint32_t cpu_id() const { return at<2>().as_uint32(); }
+  MaliMaliPMMCUONHWCNTDISABLEFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliPMMCUONHWCNTDISABLEFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliPMMCUONHWCNTDISABLEFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
 };
 
-class CpuFrequencyFtraceEvent : public ::protozero::Message {
+class MaliMaliPMMCUONHWCNTDISABLEFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = CpuFrequencyFtraceEvent_Decoder;
+  using Decoder = MaliMaliPMMCUONHWCNTDISABLEFtraceEvent_Decoder;
   enum : int32_t {
-    kStateFieldNumber = 1,
-    kCpuIdFieldNumber = 2,
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.CpuFrequencyFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUONHWCNTDISABLEFtraceEvent"; }
 
 
-  using FieldMetadata_State =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      CpuFrequencyFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliMaliPMMCUONHWCNTDISABLEFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_State kState() { return {}; }
-  void set_state(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CpuId =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      CpuFrequencyFtraceEvent>;
+      MaliMaliPMMCUONHWCNTDISABLEFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpuId kCpuId() { return {}; }
-  void set_cpu_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CpuId::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/printk.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_PRINTK_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_PRINTK_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class ConsoleFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  ConsoleFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ConsoleFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ConsoleFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_msg() const { return at<1>().valid(); }
-  ::protozero::ConstChars msg() const { return at<1>().as_string(); }
-};
-
-class ConsoleFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = ConsoleFtraceEvent_Decoder;
-  enum : int32_t {
-    kMsgFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ConsoleFtraceEvent"; }
-
 
-  using FieldMetadata_Msg =
+  using FieldMetadata_InfoVal =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ConsoleFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliPMMCUONHWCNTDISABLEFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Msg kMsg() { return {}; }
-  void set_msg(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Msg::kFieldId, data, size);
-  }
-  void set_msg(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Msg::kFieldId, chars.data, chars.size);
-  }
-  void set_msg(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Msg::kFieldId;
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/raw_syscalls.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_RAW_SYSCALLS_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_RAW_SYSCALLS_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class SysExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliPMMCUONHALTFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  SysExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SysExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SysExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_id() const { return at<1>().valid(); }
-  int64_t id() const { return at<1>().as_int64(); }
-  bool has_ret() const { return at<2>().valid(); }
-  int64_t ret() const { return at<2>().as_int64(); }
+  MaliMaliPMMCUONHALTFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliPMMCUONHALTFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliPMMCUONHALTFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
 };
 
-class SysExitFtraceEvent : public ::protozero::Message {
+class MaliMaliPMMCUONHALTFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SysExitFtraceEvent_Decoder;
+  using Decoder = MaliMaliPMMCUONHALTFtraceEvent_Decoder;
   enum : int32_t {
-    kIdFieldNumber = 1,
-    kRetFieldNumber = 2,
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SysExitFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUONHALTFtraceEvent"; }
 
 
-  using FieldMetadata_Id =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      SysExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliMaliPMMCUONHALTFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
-  void set_id(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ret =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      SysExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliPMMCUONHALTFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class SysEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  SysEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SysEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SysEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_id() const { return at<1>().valid(); }
-  int64_t id() const { return at<1>().as_int64(); }
-  bool has_args() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> args() const { return GetRepeated<uint64_t>(2); }
-};
-
-class SysEnterFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = SysEnterFtraceEvent_Decoder;
-  enum : int32_t {
-    kIdFieldNumber = 1,
-    kArgsFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.SysEnterFtraceEvent"; }
 
-
-  using FieldMetadata_Id =
+  using FieldMetadata_InfoVal =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      SysEnterFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
-  void set_id(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Args =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      SysEnterFtraceEvent>;
+      MaliMaliPMMCUONHALTFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Args kArgs() { return {}; }
-  void add_args(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Args::kFieldId;
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -118556,566 +145339,357 @@ class SysEnterFtraceEvent : public ::protozero::Message {
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/regulator.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_REGULATOR_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_REGULATOR_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class RegulatorSetVoltageCompleteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliPMMCUONGLBREINITPENDFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  RegulatorSetVoltageCompleteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit RegulatorSetVoltageCompleteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit RegulatorSetVoltageCompleteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_val() const { return at<2>().valid(); }
-  uint32_t val() const { return at<2>().as_uint32(); }
+  MaliMaliPMMCUONGLBREINITPENDFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliPMMCUONGLBREINITPENDFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliPMMCUONGLBREINITPENDFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
 };
 
-class RegulatorSetVoltageCompleteFtraceEvent : public ::protozero::Message {
+class MaliMaliPMMCUONGLBREINITPENDFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = RegulatorSetVoltageCompleteFtraceEvent_Decoder;
+  using Decoder = MaliMaliPMMCUONGLBREINITPENDFtraceEvent_Decoder;
   enum : int32_t {
-    kNameFieldNumber = 1,
-    kValFieldNumber = 2,
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.RegulatorSetVoltageCompleteFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUONGLBREINITPENDFtraceEvent"; }
 
 
-  using FieldMetadata_Name =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      RegulatorSetVoltageCompleteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliMaliPMMCUONGLBREINITPENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Val =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      RegulatorSetVoltageCompleteFtraceEvent>;
+      MaliMaliPMMCUONGLBREINITPENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Val kVal() { return {}; }
-  void set_val(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Val::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_InfoVal =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliPMMCUONGLBREINITPENDFtraceEvent>;
+
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class RegulatorSetVoltageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  RegulatorSetVoltageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit RegulatorSetVoltageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit RegulatorSetVoltageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_min() const { return at<2>().valid(); }
-  int32_t min() const { return at<2>().as_int32(); }
-  bool has_max() const { return at<3>().valid(); }
-  int32_t max() const { return at<3>().as_int32(); }
+  MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
 };
 
-class RegulatorSetVoltageFtraceEvent : public ::protozero::Message {
+class MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = RegulatorSetVoltageFtraceEvent_Decoder;
+  using Decoder = MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent_Decoder;
   enum : int32_t {
-    kNameFieldNumber = 1,
-    kMinFieldNumber = 2,
-    kMaxFieldNumber = 3,
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.RegulatorSetVoltageFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent"; }
 
 
-  using FieldMetadata_Name =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      RegulatorSetVoltageFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Min =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      RegulatorSetVoltageFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Min kMin() { return {}; }
-  void set_min(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Min::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Max =
+  using FieldMetadata_InfoVal =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      RegulatorSetVoltageFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Max kMax() { return {}; }
-  void set_max(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Max::kFieldId;
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class RegulatorEnableDelayFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliPMMCUONFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  RegulatorEnableDelayFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit RegulatorEnableDelayFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit RegulatorEnableDelayFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  MaliMaliPMMCUONFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliPMMCUONFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliPMMCUONFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
 };
 
-class RegulatorEnableDelayFtraceEvent : public ::protozero::Message {
+class MaliMaliPMMCUONFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = RegulatorEnableDelayFtraceEvent_Decoder;
+  using Decoder = MaliMaliPMMCUONFtraceEvent_Decoder;
   enum : int32_t {
-    kNameFieldNumber = 1,
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.RegulatorEnableDelayFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUONFtraceEvent"; }
 
 
-  using FieldMetadata_Name =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      RegulatorEnableDelayFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliMaliPMMCUONFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-class RegulatorEnableCompleteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  RegulatorEnableCompleteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit RegulatorEnableCompleteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit RegulatorEnableCompleteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-};
-
-class RegulatorEnableCompleteFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = RegulatorEnableCompleteFtraceEvent_Decoder;
-  enum : int32_t {
-    kNameFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.RegulatorEnableCompleteFtraceEvent"; }
-
 
-  using FieldMetadata_Name =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      RegulatorEnableCompleteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliPMMCUONFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class RegulatorEnableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  RegulatorEnableFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit RegulatorEnableFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit RegulatorEnableFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-};
-
-class RegulatorEnableFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = RegulatorEnableFtraceEvent_Decoder;
-  enum : int32_t {
-    kNameFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.RegulatorEnableFtraceEvent"; }
 
-
-  using FieldMetadata_Name =
+  using FieldMetadata_InfoVal =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      RegulatorEnableFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliPMMCUONFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class RegulatorDisableCompleteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliPMMCUOFFFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  RegulatorDisableCompleteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit RegulatorDisableCompleteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit RegulatorDisableCompleteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  MaliMaliPMMCUOFFFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliPMMCUOFFFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliPMMCUOFFFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
 };
 
-class RegulatorDisableCompleteFtraceEvent : public ::protozero::Message {
+class MaliMaliPMMCUOFFFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = RegulatorDisableCompleteFtraceEvent_Decoder;
+  using Decoder = MaliMaliPMMCUOFFFtraceEvent_Decoder;
   enum : int32_t {
-    kNameFieldNumber = 1,
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.RegulatorDisableCompleteFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUOFFFtraceEvent"; }
 
 
-  using FieldMetadata_Name =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      RegulatorDisableCompleteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliMaliPMMCUOFFFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
 
-class RegulatorDisableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  RegulatorDisableFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit RegulatorDisableFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit RegulatorDisableFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-};
-
-class RegulatorDisableFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = RegulatorDisableFtraceEvent_Decoder;
-  enum : int32_t {
-    kNameFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.RegulatorDisableFtraceEvent"; }
+  using FieldMetadata_KctxId =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliPMMCUOFFFtraceEvent>;
 
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Name =
+  using FieldMetadata_InfoVal =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      RegulatorDisableFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliPMMCUOFFFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/sched.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SCHED_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SCHED_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class SchedCpuUtilCfsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/15, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliPMMCUINSLEEPFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  SchedCpuUtilCfsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SchedCpuUtilCfsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SchedCpuUtilCfsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_active() const { return at<1>().valid(); }
-  int32_t active() const { return at<1>().as_int32(); }
-  bool has_capacity() const { return at<2>().valid(); }
-  uint64_t capacity() const { return at<2>().as_uint64(); }
-  bool has_capacity_orig() const { return at<3>().valid(); }
-  uint64_t capacity_orig() const { return at<3>().as_uint64(); }
-  bool has_cpu() const { return at<4>().valid(); }
-  uint32_t cpu() const { return at<4>().as_uint32(); }
-  bool has_cpu_importance() const { return at<5>().valid(); }
-  uint64_t cpu_importance() const { return at<5>().as_uint64(); }
-  bool has_cpu_util() const { return at<6>().valid(); }
-  uint64_t cpu_util() const { return at<6>().as_uint64(); }
-  bool has_exit_lat() const { return at<7>().valid(); }
-  uint32_t exit_lat() const { return at<7>().as_uint32(); }
-  bool has_group_capacity() const { return at<8>().valid(); }
-  uint64_t group_capacity() const { return at<8>().as_uint64(); }
-  bool has_grp_overutilized() const { return at<9>().valid(); }
-  uint32_t grp_overutilized() const { return at<9>().as_uint32(); }
-  bool has_idle_cpu() const { return at<10>().valid(); }
-  uint32_t idle_cpu() const { return at<10>().as_uint32(); }
-  bool has_nr_running() const { return at<11>().valid(); }
-  uint32_t nr_running() const { return at<11>().as_uint32(); }
-  bool has_spare_cap() const { return at<12>().valid(); }
-  int64_t spare_cap() const { return at<12>().as_int64(); }
-  bool has_task_fits() const { return at<13>().valid(); }
-  uint32_t task_fits() const { return at<13>().as_uint32(); }
-  bool has_wake_group_util() const { return at<14>().valid(); }
-  uint64_t wake_group_util() const { return at<14>().as_uint64(); }
-  bool has_wake_util() const { return at<15>().valid(); }
-  uint64_t wake_util() const { return at<15>().as_uint64(); }
+  MaliMaliPMMCUINSLEEPFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliPMMCUINSLEEPFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliPMMCUINSLEEPFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
 };
 
-class SchedCpuUtilCfsFtraceEvent : public ::protozero::Message {
+class MaliMaliPMMCUINSLEEPFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SchedCpuUtilCfsFtraceEvent_Decoder;
+  using Decoder = MaliMaliPMMCUINSLEEPFtraceEvent_Decoder;
   enum : int32_t {
-    kActiveFieldNumber = 1,
-    kCapacityFieldNumber = 2,
-    kCapacityOrigFieldNumber = 3,
-    kCpuFieldNumber = 4,
-    kCpuImportanceFieldNumber = 5,
-    kCpuUtilFieldNumber = 6,
-    kExitLatFieldNumber = 7,
-    kGroupCapacityFieldNumber = 8,
-    kGrpOverutilizedFieldNumber = 9,
-    kIdleCpuFieldNumber = 10,
-    kNrRunningFieldNumber = 11,
-    kSpareCapFieldNumber = 12,
-    kTaskFitsFieldNumber = 13,
-    kWakeGroupUtilFieldNumber = 14,
-    kWakeUtilFieldNumber = 15,
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SchedCpuUtilCfsFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUINSLEEPFtraceEvent"; }
 
 
-  using FieldMetadata_Active =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      SchedCpuUtilCfsFtraceEvent>;
+      MaliMaliPMMCUINSLEEPFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Active kActive() { return {}; }
-  void set_active(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Active::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -119123,74 +145697,96 @@ class SchedCpuUtilCfsFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Capacity =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SchedCpuUtilCfsFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliPMMCUINSLEEPFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Capacity kCapacity() { return {}; }
-  void set_capacity(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Capacity::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CapacityOrig =
+  using FieldMetadata_InfoVal =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      SchedCpuUtilCfsFtraceEvent>;
+      MaliMaliPMMCUINSLEEPFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CapacityOrig kCapacityOrig() { return {}; }
-  void set_capacity_orig(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CapacityOrig::kFieldId;
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Cpu =
+class MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
+};
+
+class MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent_Decoder;
+  enum : int32_t {
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent"; }
+
+
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent>;
+
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_KctxId =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SchedCpuUtilCfsFtraceEvent>;
+      MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cpu kCpu() { return {}; }
-  void set_cpu(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -119198,74 +145794,78 @@ class SchedCpuUtilCfsFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CpuImportance =
+  using FieldMetadata_InfoVal =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      SchedCpuUtilCfsFtraceEvent>;
+      MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpuImportance kCpuImportance() { return {}; }
-  void set_cpu_importance(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CpuImportance::kFieldId;
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_CpuUtil =
+class MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
+};
+
+class MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent_Decoder;
+  enum : int32_t {
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent"; }
+
+
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SchedCpuUtilCfsFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpuUtil kCpuUtil() { return {}; }
-  void set_cpu_util(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CpuUtil::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ExitLat =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SchedCpuUtilCfsFtraceEvent>;
+      MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExitLat kExitLat() { return {}; }
-  void set_exit_lat(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ExitLat::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -119273,74 +145873,78 @@ class SchedCpuUtilCfsFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_GroupCapacity =
+  using FieldMetadata_InfoVal =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      SchedCpuUtilCfsFtraceEvent>;
+      MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GroupCapacity kGroupCapacity() { return {}; }
-  void set_group_capacity(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GroupCapacity::kFieldId;
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_GrpOverutilized =
+class MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
+};
+
+class MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent_Decoder;
+  enum : int32_t {
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent"; }
+
+
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SchedCpuUtilCfsFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GrpOverutilized kGrpOverutilized() { return {}; }
-  void set_grp_overutilized(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GrpOverutilized::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IdleCpu =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SchedCpuUtilCfsFtraceEvent>;
+      MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IdleCpu kIdleCpu() { return {}; }
-  void set_idle_cpu(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IdleCpu::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -119348,74 +145952,78 @@ class SchedCpuUtilCfsFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NrRunning =
+  using FieldMetadata_InfoVal =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SchedCpuUtilCfsFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrRunning kNrRunning() { return {}; }
-  void set_nr_running(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NrRunning::kFieldId;
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_SpareCap =
+class MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
+};
+
+class MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent_Decoder;
+  enum : int32_t {
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent"; }
+
+
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
-      12,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      SchedCpuUtilCfsFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SpareCap kSpareCap() { return {}; }
-  void set_spare_cap(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SpareCap::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TaskFits =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
-      13,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SchedCpuUtilCfsFtraceEvent>;
+      MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TaskFits kTaskFits() { return {}; }
-  void set_task_fits(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TaskFits::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -119423,49 +146031,17 @@ class SchedCpuUtilCfsFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_WakeGroupUtil =
-    ::protozero::proto_utils::FieldMetadata<
-      14,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SchedCpuUtilCfsFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WakeGroupUtil kWakeGroupUtil() { return {}; }
-  void set_wake_group_util(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_WakeGroupUtil::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_WakeUtil =
+  using FieldMetadata_InfoVal =
     ::protozero::proto_utils::FieldMetadata<
-      15,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      SchedCpuUtilCfsFtraceEvent>;
+      MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WakeUtil kWakeUtil() { return {}; }
-  void set_wake_util(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_WakeUtil::kFieldId;
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -119474,82 +146050,41 @@ class SchedCpuUtilCfsFtraceEvent : public ::protozero::Message {
   }
 };
 
-class SchedPiSetprioFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  SchedPiSetprioFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SchedPiSetprioFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SchedPiSetprioFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_comm() const { return at<1>().valid(); }
-  ::protozero::ConstChars comm() const { return at<1>().as_string(); }
-  bool has_newprio() const { return at<2>().valid(); }
-  int32_t newprio() const { return at<2>().as_int32(); }
-  bool has_oldprio() const { return at<3>().valid(); }
-  int32_t oldprio() const { return at<3>().as_int32(); }
-  bool has_pid() const { return at<4>().valid(); }
-  int32_t pid() const { return at<4>().as_int32(); }
+  MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
 };
 
-class SchedPiSetprioFtraceEvent : public ::protozero::Message {
+class MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SchedPiSetprioFtraceEvent_Decoder;
+  using Decoder = MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent_Decoder;
   enum : int32_t {
-    kCommFieldNumber = 1,
-    kNewprioFieldNumber = 2,
-    kOldprioFieldNumber = 3,
-    kPidFieldNumber = 4,
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SchedPiSetprioFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent"; }
 
 
-  using FieldMetadata_Comm =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SchedPiSetprioFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
-  void set_comm(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
-  }
-  void set_comm(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
-  }
-  void set_comm(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Newprio =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      SchedPiSetprioFtraceEvent>;
+      MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Newprio kNewprio() { return {}; }
-  void set_newprio(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Newprio::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -119557,423 +146092,315 @@ class SchedPiSetprioFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Oldprio =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedPiSetprioFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Oldprio kOldprio() { return {}; }
-  void set_oldprio(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Oldprio::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_InfoVal =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedPiSetprioFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class SchedProcessWaitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  SchedProcessWaitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SchedProcessWaitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SchedProcessWaitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_comm() const { return at<1>().valid(); }
-  ::protozero::ConstChars comm() const { return at<1>().as_string(); }
-  bool has_pid() const { return at<2>().valid(); }
-  int32_t pid() const { return at<2>().as_int32(); }
-  bool has_prio() const { return at<3>().valid(); }
-  int32_t prio() const { return at<3>().as_int32(); }
+  MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
 };
 
-class SchedProcessWaitFtraceEvent : public ::protozero::Message {
+class MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SchedProcessWaitFtraceEvent_Decoder;
+  using Decoder = MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent_Decoder;
   enum : int32_t {
-    kCommFieldNumber = 1,
-    kPidFieldNumber = 2,
-    kPrioFieldNumber = 3,
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SchedProcessWaitFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent"; }
 
 
-  using FieldMetadata_Comm =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SchedProcessWaitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
-  void set_comm(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
-  }
-  void set_comm(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
-  }
-  void set_comm(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedProcessWaitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Prio =
+  using FieldMetadata_InfoVal =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedProcessWaitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Prio kPrio() { return {}; }
-  void set_prio(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId;
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class SchedProcessHangFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  SchedProcessHangFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SchedProcessHangFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SchedProcessHangFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_comm() const { return at<1>().valid(); }
-  ::protozero::ConstChars comm() const { return at<1>().as_string(); }
-  bool has_pid() const { return at<2>().valid(); }
-  int32_t pid() const { return at<2>().as_int32(); }
+  MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
 };
 
-class SchedProcessHangFtraceEvent : public ::protozero::Message {
+class MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SchedProcessHangFtraceEvent_Decoder;
+  using Decoder = MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent_Decoder;
   enum : int32_t {
-    kCommFieldNumber = 1,
-    kPidFieldNumber = 2,
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SchedProcessHangFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent"; }
 
 
-  using FieldMetadata_Comm =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SchedProcessHangFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
-  void set_comm(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
-  }
-  void set_comm(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
-  }
-  void set_comm(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedProcessHangFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_InfoVal =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent>;
+
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class SchedProcessFreeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  SchedProcessFreeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SchedProcessFreeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SchedProcessFreeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_comm() const { return at<1>().valid(); }
-  ::protozero::ConstChars comm() const { return at<1>().as_string(); }
-  bool has_pid() const { return at<2>().valid(); }
-  int32_t pid() const { return at<2>().as_int32(); }
-  bool has_prio() const { return at<3>().valid(); }
-  int32_t prio() const { return at<3>().as_int32(); }
+  MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
 };
 
-class SchedProcessFreeFtraceEvent : public ::protozero::Message {
+class MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SchedProcessFreeFtraceEvent_Decoder;
+  using Decoder = MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent_Decoder;
   enum : int32_t {
-    kCommFieldNumber = 1,
-    kPidFieldNumber = 2,
-    kPrioFieldNumber = 3,
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SchedProcessFreeFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent"; }
 
 
-  using FieldMetadata_Comm =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SchedProcessFreeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
-  void set_comm(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
-  }
-  void set_comm(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
-  }
-  void set_comm(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedProcessFreeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Prio =
+  using FieldMetadata_InfoVal =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedProcessFreeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Prio kPrio() { return {}; }
-  void set_prio(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId;
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class SchedProcessForkFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliCSFINTERRUPTENDFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  SchedProcessForkFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SchedProcessForkFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SchedProcessForkFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_parent_comm() const { return at<1>().valid(); }
-  ::protozero::ConstChars parent_comm() const { return at<1>().as_string(); }
-  bool has_parent_pid() const { return at<2>().valid(); }
-  int32_t parent_pid() const { return at<2>().as_int32(); }
-  bool has_child_comm() const { return at<3>().valid(); }
-  ::protozero::ConstChars child_comm() const { return at<3>().as_string(); }
-  bool has_child_pid() const { return at<4>().valid(); }
-  int32_t child_pid() const { return at<4>().as_int32(); }
+  MaliMaliCSFINTERRUPTENDFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliCSFINTERRUPTENDFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliCSFINTERRUPTENDFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
 };
 
-class SchedProcessForkFtraceEvent : public ::protozero::Message {
+class MaliMaliCSFINTERRUPTENDFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SchedProcessForkFtraceEvent_Decoder;
+  using Decoder = MaliMaliCSFINTERRUPTENDFtraceEvent_Decoder;
   enum : int32_t {
-    kParentCommFieldNumber = 1,
-    kParentPidFieldNumber = 2,
-    kChildCommFieldNumber = 3,
-    kChildPidFieldNumber = 4,
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SchedProcessForkFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliCSFINTERRUPTENDFtraceEvent"; }
 
 
-  using FieldMetadata_ParentComm =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SchedProcessForkFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ParentComm kParentComm() { return {}; }
-  void set_parent_comm(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ParentComm::kFieldId, data, size);
-  }
-  void set_parent_comm(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ParentComm::kFieldId, chars.data, chars.size);
-  }
-  void set_parent_comm(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ParentComm::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ParentPid =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      SchedProcessForkFtraceEvent>;
+      MaliMaliCSFINTERRUPTENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ParentPid kParentPid() { return {}; }
-  void set_parent_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ParentPid::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -119981,139 +146408,78 @@ class SchedProcessForkFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ChildComm =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SchedProcessForkFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliCSFINTERRUPTENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChildComm kChildComm() { return {}; }
-  void set_child_comm(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ChildComm::kFieldId, data, size);
-  }
-  void set_child_comm(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ChildComm::kFieldId, chars.data, chars.size);
-  }
-  void set_child_comm(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ChildComm::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ChildPid =
+  using FieldMetadata_InfoVal =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedProcessForkFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliCSFINTERRUPTENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChildPid kChildPid() { return {}; }
-  void set_child_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ChildPid::kFieldId;
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class SchedProcessExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliCSFINTERRUPTSTARTFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  SchedProcessExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SchedProcessExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SchedProcessExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_comm() const { return at<1>().valid(); }
-  ::protozero::ConstChars comm() const { return at<1>().as_string(); }
-  bool has_pid() const { return at<2>().valid(); }
-  int32_t pid() const { return at<2>().as_int32(); }
-  bool has_tgid() const { return at<3>().valid(); }
-  int32_t tgid() const { return at<3>().as_int32(); }
-  bool has_prio() const { return at<4>().valid(); }
-  int32_t prio() const { return at<4>().as_int32(); }
+  MaliMaliCSFINTERRUPTSTARTFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliCSFINTERRUPTSTARTFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliCSFINTERRUPTSTARTFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kctx_tgid() const { return at<1>().valid(); }
+  int32_t kctx_tgid() const { return at<1>().as_int32(); }
+  bool has_kctx_id() const { return at<2>().valid(); }
+  uint32_t kctx_id() const { return at<2>().as_uint32(); }
+  bool has_info_val() const { return at<3>().valid(); }
+  uint64_t info_val() const { return at<3>().as_uint64(); }
 };
 
-class SchedProcessExitFtraceEvent : public ::protozero::Message {
+class MaliMaliCSFINTERRUPTSTARTFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SchedProcessExitFtraceEvent_Decoder;
+  using Decoder = MaliMaliCSFINTERRUPTSTARTFtraceEvent_Decoder;
   enum : int32_t {
-    kCommFieldNumber = 1,
-    kPidFieldNumber = 2,
-    kTgidFieldNumber = 3,
-    kPrioFieldNumber = 4,
+    kKctxTgidFieldNumber = 1,
+    kKctxIdFieldNumber = 2,
+    kInfoValFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SchedProcessExitFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliCSFINTERRUPTSTARTFtraceEvent"; }
 
 
-  using FieldMetadata_Comm =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SchedProcessExitFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
-  void set_comm(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
-  }
-  void set_comm(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
-  }
-  void set_comm(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Pid =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      SchedProcessExitFtraceEvent>;
+      MaliMaliCSFINTERRUPTSTARTFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -120121,267 +146487,241 @@ class SchedProcessExitFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Tgid =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedProcessExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliCSFINTERRUPTSTARTFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Tgid kTgid() { return {}; }
-  void set_tgid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Tgid::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Prio =
+  using FieldMetadata_InfoVal =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedProcessExitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliCSFINTERRUPTSTARTFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Prio kPrio() { return {}; }
-  void set_prio(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId;
+  static constexpr FieldMetadata_InfoVal kInfoVal{};
+  void set_info_val(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class SchedProcessExecFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliKCPUFENCEWAITENDFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  SchedProcessExecFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SchedProcessExecFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SchedProcessExecFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_filename() const { return at<1>().valid(); }
-  ::protozero::ConstChars filename() const { return at<1>().as_string(); }
-  bool has_pid() const { return at<2>().valid(); }
-  int32_t pid() const { return at<2>().as_int32(); }
-  bool has_old_pid() const { return at<3>().valid(); }
-  int32_t old_pid() const { return at<3>().as_int32(); }
+  MaliMaliKCPUFENCEWAITENDFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliKCPUFENCEWAITENDFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliKCPUFENCEWAITENDFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_info_val1() const { return at<1>().valid(); }
+  uint64_t info_val1() const { return at<1>().as_uint64(); }
+  bool has_info_val2() const { return at<2>().valid(); }
+  uint64_t info_val2() const { return at<2>().as_uint64(); }
+  bool has_kctx_tgid() const { return at<3>().valid(); }
+  int32_t kctx_tgid() const { return at<3>().as_int32(); }
+  bool has_kctx_id() const { return at<4>().valid(); }
+  uint32_t kctx_id() const { return at<4>().as_uint32(); }
+  bool has_id() const { return at<5>().valid(); }
+  uint32_t id() const { return at<5>().as_uint32(); }
 };
 
-class SchedProcessExecFtraceEvent : public ::protozero::Message {
+class MaliMaliKCPUFENCEWAITENDFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SchedProcessExecFtraceEvent_Decoder;
+  using Decoder = MaliMaliKCPUFENCEWAITENDFtraceEvent_Decoder;
   enum : int32_t {
-    kFilenameFieldNumber = 1,
-    kPidFieldNumber = 2,
-    kOldPidFieldNumber = 3,
+    kInfoVal1FieldNumber = 1,
+    kInfoVal2FieldNumber = 2,
+    kKctxTgidFieldNumber = 3,
+    kKctxIdFieldNumber = 4,
+    kIdFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SchedProcessExecFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliKCPUFENCEWAITENDFtraceEvent"; }
 
 
-  using FieldMetadata_Filename =
+  using FieldMetadata_InfoVal1 =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SchedProcessExecFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliKCPUFENCEWAITENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Filename kFilename() { return {}; }
-  void set_filename(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Filename::kFieldId, data, size);
-  }
-  void set_filename(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Filename::kFieldId, chars.data, chars.size);
-  }
-  void set_filename(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Filename::kFieldId;
+  static constexpr FieldMetadata_InfoVal1 kInfoVal1{};
+  void set_info_val1(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal1::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_InfoVal2 =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedProcessExecFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliKCPUFENCEWAITENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_InfoVal2 kInfoVal2{};
+  void set_info_val2(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal2::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_OldPid =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      SchedProcessExecFtraceEvent>;
+      MaliMaliKCPUFENCEWAITENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OldPid kOldPid() { return {}; }
-  void set_old_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OldPid::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_KctxId =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliKCPUFENCEWAITENDFtraceEvent>;
+
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Id =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliKCPUFENCEWAITENDFtraceEvent>;
+
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class SchedWakeupNewFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliKCPUFENCEWAITSTARTFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  SchedWakeupNewFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SchedWakeupNewFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SchedWakeupNewFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_comm() const { return at<1>().valid(); }
-  ::protozero::ConstChars comm() const { return at<1>().as_string(); }
-  bool has_pid() const { return at<2>().valid(); }
-  int32_t pid() const { return at<2>().as_int32(); }
-  bool has_prio() const { return at<3>().valid(); }
-  int32_t prio() const { return at<3>().as_int32(); }
-  bool has_success() const { return at<4>().valid(); }
-  int32_t success() const { return at<4>().as_int32(); }
-  bool has_target_cpu() const { return at<5>().valid(); }
-  int32_t target_cpu() const { return at<5>().as_int32(); }
+  MaliMaliKCPUFENCEWAITSTARTFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliKCPUFENCEWAITSTARTFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliKCPUFENCEWAITSTARTFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_info_val1() const { return at<1>().valid(); }
+  uint64_t info_val1() const { return at<1>().as_uint64(); }
+  bool has_info_val2() const { return at<2>().valid(); }
+  uint64_t info_val2() const { return at<2>().as_uint64(); }
+  bool has_kctx_tgid() const { return at<3>().valid(); }
+  int32_t kctx_tgid() const { return at<3>().as_int32(); }
+  bool has_kctx_id() const { return at<4>().valid(); }
+  uint32_t kctx_id() const { return at<4>().as_uint32(); }
+  bool has_id() const { return at<5>().valid(); }
+  uint32_t id() const { return at<5>().as_uint32(); }
 };
 
-class SchedWakeupNewFtraceEvent : public ::protozero::Message {
+class MaliMaliKCPUFENCEWAITSTARTFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SchedWakeupNewFtraceEvent_Decoder;
+  using Decoder = MaliMaliKCPUFENCEWAITSTARTFtraceEvent_Decoder;
   enum : int32_t {
-    kCommFieldNumber = 1,
-    kPidFieldNumber = 2,
-    kPrioFieldNumber = 3,
-    kSuccessFieldNumber = 4,
-    kTargetCpuFieldNumber = 5,
+    kInfoVal1FieldNumber = 1,
+    kInfoVal2FieldNumber = 2,
+    kKctxTgidFieldNumber = 3,
+    kKctxIdFieldNumber = 4,
+    kIdFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SchedWakeupNewFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliKCPUFENCEWAITSTARTFtraceEvent"; }
 
 
-  using FieldMetadata_Comm =
+  using FieldMetadata_InfoVal1 =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SchedWakeupNewFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliKCPUFENCEWAITSTARTFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
-  void set_comm(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
-  }
-  void set_comm(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
-  }
-  void set_comm(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
+  static constexpr FieldMetadata_InfoVal1 kInfoVal1{};
+  void set_info_val1(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal1::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_InfoVal2 =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedWakeupNewFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliKCPUFENCEWAITSTARTFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_InfoVal2 kInfoVal2{};
+  void set_info_val2(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal2::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Prio =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      SchedWakeupNewFtraceEvent>;
+      MaliMaliKCPUFENCEWAITSTARTFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Prio kPrio() { return {}; }
-  void set_prio(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -120389,161 +146729,120 @@ class SchedWakeupNewFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Success =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedWakeupNewFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliKCPUFENCEWAITSTARTFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Success kSuccess() { return {}; }
-  void set_success(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Success::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TargetCpu =
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedWakeupNewFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliKCPUFENCEWAITSTARTFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TargetCpu kTargetCpu() { return {}; }
-  void set_target_cpu(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TargetCpu::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class SchedWakingFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliKCPUFENCESIGNALFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  SchedWakingFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SchedWakingFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SchedWakingFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_comm() const { return at<1>().valid(); }
-  ::protozero::ConstChars comm() const { return at<1>().as_string(); }
-  bool has_pid() const { return at<2>().valid(); }
-  int32_t pid() const { return at<2>().as_int32(); }
-  bool has_prio() const { return at<3>().valid(); }
-  int32_t prio() const { return at<3>().as_int32(); }
-  bool has_success() const { return at<4>().valid(); }
-  int32_t success() const { return at<4>().as_int32(); }
-  bool has_target_cpu() const { return at<5>().valid(); }
-  int32_t target_cpu() const { return at<5>().as_int32(); }
+  MaliMaliKCPUFENCESIGNALFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliKCPUFENCESIGNALFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliKCPUFENCESIGNALFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_info_val1() const { return at<1>().valid(); }
+  uint64_t info_val1() const { return at<1>().as_uint64(); }
+  bool has_info_val2() const { return at<2>().valid(); }
+  uint64_t info_val2() const { return at<2>().as_uint64(); }
+  bool has_kctx_tgid() const { return at<3>().valid(); }
+  int32_t kctx_tgid() const { return at<3>().as_int32(); }
+  bool has_kctx_id() const { return at<4>().valid(); }
+  uint32_t kctx_id() const { return at<4>().as_uint32(); }
+  bool has_id() const { return at<5>().valid(); }
+  uint32_t id() const { return at<5>().as_uint32(); }
 };
 
-class SchedWakingFtraceEvent : public ::protozero::Message {
+class MaliMaliKCPUFENCESIGNALFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SchedWakingFtraceEvent_Decoder;
+  using Decoder = MaliMaliKCPUFENCESIGNALFtraceEvent_Decoder;
   enum : int32_t {
-    kCommFieldNumber = 1,
-    kPidFieldNumber = 2,
-    kPrioFieldNumber = 3,
-    kSuccessFieldNumber = 4,
-    kTargetCpuFieldNumber = 5,
+    kInfoVal1FieldNumber = 1,
+    kInfoVal2FieldNumber = 2,
+    kKctxTgidFieldNumber = 3,
+    kKctxIdFieldNumber = 4,
+    kIdFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SchedWakingFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliKCPUFENCESIGNALFtraceEvent"; }
 
 
-  using FieldMetadata_Comm =
+  using FieldMetadata_InfoVal1 =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SchedWakingFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliKCPUFENCESIGNALFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
-  void set_comm(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
-  }
-  void set_comm(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
-  }
-  void set_comm(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
+  static constexpr FieldMetadata_InfoVal1 kInfoVal1{};
+  void set_info_val1(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal1::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_InfoVal2 =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedWakingFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliKCPUFENCESIGNALFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_InfoVal2 kInfoVal2{};
+  void set_info_val2(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal2::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Prio =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      SchedWakingFtraceEvent>;
+      MaliMaliKCPUFENCESIGNALFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Prio kPrio() { return {}; }
-  void set_prio(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -120551,149 +146850,156 @@ class SchedWakingFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Success =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedWakingFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliKCPUFENCESIGNALFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Success kSuccess() { return {}; }
-  void set_success(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Success::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TargetCpu =
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedWakingFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliKCPUFENCESIGNALFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TargetCpu kTargetCpu() { return {}; }
-  void set_target_cpu(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TargetCpu::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class SchedCpuHotplugFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliKCPUCQSWAITENDFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  SchedCpuHotplugFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SchedCpuHotplugFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SchedCpuHotplugFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_affected_cpu() const { return at<1>().valid(); }
-  int32_t affected_cpu() const { return at<1>().as_int32(); }
-  bool has_error() const { return at<2>().valid(); }
-  int32_t error() const { return at<2>().as_int32(); }
-  bool has_status() const { return at<3>().valid(); }
-  int32_t status() const { return at<3>().as_int32(); }
+  MaliMaliKCPUCQSWAITENDFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliKCPUCQSWAITENDFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliKCPUCQSWAITENDFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  uint32_t id() const { return at<1>().as_uint32(); }
+  bool has_info_val1() const { return at<2>().valid(); }
+  uint64_t info_val1() const { return at<2>().as_uint64(); }
+  bool has_info_val2() const { return at<3>().valid(); }
+  uint64_t info_val2() const { return at<3>().as_uint64(); }
+  bool has_kctx_id() const { return at<4>().valid(); }
+  uint32_t kctx_id() const { return at<4>().as_uint32(); }
+  bool has_kctx_tgid() const { return at<5>().valid(); }
+  int32_t kctx_tgid() const { return at<5>().as_int32(); }
 };
 
-class SchedCpuHotplugFtraceEvent : public ::protozero::Message {
+class MaliMaliKCPUCQSWAITENDFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SchedCpuHotplugFtraceEvent_Decoder;
+  using Decoder = MaliMaliKCPUCQSWAITENDFtraceEvent_Decoder;
   enum : int32_t {
-    kAffectedCpuFieldNumber = 1,
-    kErrorFieldNumber = 2,
-    kStatusFieldNumber = 3,
+    kIdFieldNumber = 1,
+    kInfoVal1FieldNumber = 2,
+    kInfoVal2FieldNumber = 3,
+    kKctxIdFieldNumber = 4,
+    kKctxTgidFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SchedCpuHotplugFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliKCPUCQSWAITENDFtraceEvent"; }
 
 
-  using FieldMetadata_AffectedCpu =
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedCpuHotplugFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliKCPUCQSWAITENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AffectedCpu kAffectedCpu() { return {}; }
-  void set_affected_cpu(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AffectedCpu::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Error =
+  using FieldMetadata_InfoVal1 =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedCpuHotplugFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliKCPUCQSWAITENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Error kError() { return {}; }
-  void set_error(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId;
+  static constexpr FieldMetadata_InfoVal1 kInfoVal1{};
+  void set_info_val1(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal1::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Status =
+  using FieldMetadata_InfoVal2 =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliKCPUCQSWAITENDFtraceEvent>;
+
+  static constexpr FieldMetadata_InfoVal2 kInfoVal2{};
+  void set_info_val2(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal2::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_KctxId =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliKCPUCQSWAITENDFtraceEvent>;
+
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_KctxTgid =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      SchedCpuHotplugFtraceEvent>;
+      MaliMaliKCPUCQSWAITENDFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Status kStatus() { return {}; }
-  void set_status(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -120702,73 +147008,65 @@ class SchedCpuHotplugFtraceEvent : public ::protozero::Message {
   }
 };
 
-class SchedBlockedReasonFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliKCPUCQSWAITSTARTFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  SchedBlockedReasonFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SchedBlockedReasonFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SchedBlockedReasonFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pid() const { return at<1>().valid(); }
-  int32_t pid() const { return at<1>().as_int32(); }
-  bool has_caller() const { return at<2>().valid(); }
-  uint64_t caller() const { return at<2>().as_uint64(); }
-  bool has_io_wait() const { return at<3>().valid(); }
-  uint32_t io_wait() const { return at<3>().as_uint32(); }
+  MaliMaliKCPUCQSWAITSTARTFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliKCPUCQSWAITSTARTFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliKCPUCQSWAITSTARTFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  uint32_t id() const { return at<1>().as_uint32(); }
+  bool has_info_val1() const { return at<2>().valid(); }
+  uint64_t info_val1() const { return at<2>().as_uint64(); }
+  bool has_info_val2() const { return at<3>().valid(); }
+  uint64_t info_val2() const { return at<3>().as_uint64(); }
+  bool has_kctx_id() const { return at<4>().valid(); }
+  uint32_t kctx_id() const { return at<4>().as_uint32(); }
+  bool has_kctx_tgid() const { return at<5>().valid(); }
+  int32_t kctx_tgid() const { return at<5>().as_int32(); }
 };
 
-class SchedBlockedReasonFtraceEvent : public ::protozero::Message {
+class MaliMaliKCPUCQSWAITSTARTFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SchedBlockedReasonFtraceEvent_Decoder;
+  using Decoder = MaliMaliKCPUCQSWAITSTARTFtraceEvent_Decoder;
   enum : int32_t {
-    kPidFieldNumber = 1,
-    kCallerFieldNumber = 2,
-    kIoWaitFieldNumber = 3,
+    kIdFieldNumber = 1,
+    kInfoVal1FieldNumber = 2,
+    kInfoVal2FieldNumber = 3,
+    kKctxIdFieldNumber = 4,
+    kKctxTgidFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SchedBlockedReasonFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliKCPUCQSWAITSTARTFtraceEvent"; }
 
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedBlockedReasonFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliKCPUCQSWAITSTARTFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Caller =
+  using FieldMetadata_InfoVal1 =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      SchedBlockedReasonFtraceEvent>;
+      MaliMaliKCPUCQSWAITSTARTFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Caller kCaller() { return {}; }
-  void set_caller(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Caller::kFieldId;
+  static constexpr FieldMetadata_InfoVal1 kInfoVal1{};
+  void set_info_val1(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal1::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -120776,186 +147074,174 @@ class SchedBlockedReasonFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IoWait =
+  using FieldMetadata_InfoVal2 =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliKCPUCQSWAITSTARTFtraceEvent>;
+
+  static constexpr FieldMetadata_InfoVal2 kInfoVal2{};
+  void set_info_val2(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal2::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_KctxId =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SchedBlockedReasonFtraceEvent>;
+      MaliMaliKCPUCQSWAITSTARTFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IoWait kIoWait() { return {}; }
-  void set_io_wait(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IoWait::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_KctxTgid =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MaliMaliKCPUCQSWAITSTARTFtraceEvent>;
+
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class SchedWakeupFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliMaliKCPUCQSSETFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  SchedWakeupFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SchedWakeupFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SchedWakeupFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_comm() const { return at<1>().valid(); }
-  ::protozero::ConstChars comm() const { return at<1>().as_string(); }
-  bool has_pid() const { return at<2>().valid(); }
-  int32_t pid() const { return at<2>().as_int32(); }
-  bool has_prio() const { return at<3>().valid(); }
-  int32_t prio() const { return at<3>().as_int32(); }
-  bool has_success() const { return at<4>().valid(); }
-  int32_t success() const { return at<4>().as_int32(); }
-  bool has_target_cpu() const { return at<5>().valid(); }
-  int32_t target_cpu() const { return at<5>().as_int32(); }
+  MaliMaliKCPUCQSSETFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliMaliKCPUCQSSETFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliMaliKCPUCQSSETFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  uint32_t id() const { return at<1>().as_uint32(); }
+  bool has_info_val1() const { return at<2>().valid(); }
+  uint64_t info_val1() const { return at<2>().as_uint64(); }
+  bool has_info_val2() const { return at<3>().valid(); }
+  uint64_t info_val2() const { return at<3>().as_uint64(); }
+  bool has_kctx_id() const { return at<4>().valid(); }
+  uint32_t kctx_id() const { return at<4>().as_uint32(); }
+  bool has_kctx_tgid() const { return at<5>().valid(); }
+  int32_t kctx_tgid() const { return at<5>().as_int32(); }
 };
 
-class SchedWakeupFtraceEvent : public ::protozero::Message {
+class MaliMaliKCPUCQSSETFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SchedWakeupFtraceEvent_Decoder;
+  using Decoder = MaliMaliKCPUCQSSETFtraceEvent_Decoder;
   enum : int32_t {
-    kCommFieldNumber = 1,
-    kPidFieldNumber = 2,
-    kPrioFieldNumber = 3,
-    kSuccessFieldNumber = 4,
-    kTargetCpuFieldNumber = 5,
+    kIdFieldNumber = 1,
+    kInfoVal1FieldNumber = 2,
+    kInfoVal2FieldNumber = 3,
+    kKctxIdFieldNumber = 4,
+    kKctxTgidFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SchedWakeupFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliKCPUCQSSETFtraceEvent"; }
 
 
-  using FieldMetadata_Comm =
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SchedWakeupFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliKCPUCQSSETFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
-  void set_comm(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
-  }
-  void set_comm(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
-  }
-  void set_comm(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_InfoVal1 =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedWakeupFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliKCPUCQSSETFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_InfoVal1 kInfoVal1{};
+  void set_info_val1(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal1::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Prio =
+  using FieldMetadata_InfoVal2 =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedWakeupFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MaliMaliKCPUCQSSETFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Prio kPrio() { return {}; }
-  void set_prio(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId;
+  static constexpr FieldMetadata_InfoVal2 kInfoVal2{};
+  void set_info_val2(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_InfoVal2::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Success =
+  using FieldMetadata_KctxId =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedWakeupFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliMaliKCPUCQSSETFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Success kSuccess() { return {}; }
-  void set_success(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Success::kFieldId;
+  static constexpr FieldMetadata_KctxId kKctxId{};
+  void set_kctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TargetCpu =
+  using FieldMetadata_KctxTgid =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      SchedWakeupFtraceEvent>;
+      MaliMaliKCPUCQSSETFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TargetCpu kTargetCpu() { return {}; }
-  void set_target_cpu(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TargetCpu::kFieldId;
+  static constexpr FieldMetadata_KctxTgid kKctxTgid{};
+  void set_kctx_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -120964,66 +147250,50 @@ class SchedWakeupFtraceEvent : public ::protozero::Message {
   }
 };
 
-class SchedSwitchFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MaliTracingMarkWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  SchedSwitchFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SchedSwitchFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SchedSwitchFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_prev_comm() const { return at<1>().valid(); }
-  ::protozero::ConstChars prev_comm() const { return at<1>().as_string(); }
-  bool has_prev_pid() const { return at<2>().valid(); }
-  int32_t prev_pid() const { return at<2>().as_int32(); }
-  bool has_prev_prio() const { return at<3>().valid(); }
-  int32_t prev_prio() const { return at<3>().as_int32(); }
-  bool has_prev_state() const { return at<4>().valid(); }
-  int64_t prev_state() const { return at<4>().as_int64(); }
-  bool has_next_comm() const { return at<5>().valid(); }
-  ::protozero::ConstChars next_comm() const { return at<5>().as_string(); }
-  bool has_next_pid() const { return at<6>().valid(); }
-  int32_t next_pid() const { return at<6>().as_int32(); }
-  bool has_next_prio() const { return at<7>().valid(); }
-  int32_t next_prio() const { return at<7>().as_int32(); }
+  MaliTracingMarkWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MaliTracingMarkWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MaliTracingMarkWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_pid() const { return at<2>().valid(); }
+  int32_t pid() const { return at<2>().as_int32(); }
+  bool has_type() const { return at<3>().valid(); }
+  uint32_t type() const { return at<3>().as_uint32(); }
+  bool has_value() const { return at<4>().valid(); }
+  int32_t value() const { return at<4>().as_int32(); }
 };
 
-class SchedSwitchFtraceEvent : public ::protozero::Message {
+class MaliTracingMarkWriteFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SchedSwitchFtraceEvent_Decoder;
+  using Decoder = MaliTracingMarkWriteFtraceEvent_Decoder;
   enum : int32_t {
-    kPrevCommFieldNumber = 1,
-    kPrevPidFieldNumber = 2,
-    kPrevPrioFieldNumber = 3,
-    kPrevStateFieldNumber = 4,
-    kNextCommFieldNumber = 5,
-    kNextPidFieldNumber = 6,
-    kNextPrioFieldNumber = 7,
+    kNameFieldNumber = 1,
+    kPidFieldNumber = 2,
+    kTypeFieldNumber = 3,
+    kValueFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SchedSwitchFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MaliTracingMarkWriteFtraceEvent"; }
 
 
-  using FieldMetadata_PrevComm =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      SchedSwitchFtraceEvent>;
+      MaliTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PrevComm kPrevComm() { return {}; }
-  void set_prev_comm(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_PrevComm::kFieldId, data, size);
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
-  void set_prev_comm(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_PrevComm::kFieldId, chars.data, chars.size);
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
   }
-  void set_prev_comm(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_PrevComm::kFieldId;
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -121031,24 +147301,17 @@ class SchedSwitchFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PrevPid =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      SchedSwitchFtraceEvent>;
+      MaliTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PrevPid kPrevPid() { return {}; }
-  void set_prev_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PrevPid::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -121056,130 +147319,35 @@ class SchedSwitchFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PrevPrio =
+  using FieldMetadata_Type =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedSwitchFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MaliTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PrevPrio kPrevPrio() { return {}; }
-  void set_prev_prio(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PrevPrio::kFieldId;
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PrevState =
+  using FieldMetadata_Value =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      SchedSwitchFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PrevState kPrevState() { return {}; }
-  void set_prev_state(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PrevState::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_NextComm =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SchedSwitchFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NextComm kNextComm() { return {}; }
-  void set_next_comm(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_NextComm::kFieldId, data, size);
-  }
-  void set_next_comm(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_NextComm::kFieldId, chars.data, chars.size);
-  }
-  void set_next_comm(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_NextComm::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_NextPid =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SchedSwitchFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NextPid kNextPid() { return {}; }
-  void set_next_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NextPid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_NextPrio =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      SchedSwitchFtraceEvent>;
+      MaliTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NextPrio kNextPrio() { return {}; }
-  void set_next_prio(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NextPrio::kFieldId;
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -121192,11 +147360,11 @@ class SchedSwitchFtraceEvent : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/scm.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/mdss.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SCM_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SCM_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_MDSS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_MDSS_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -121207,92 +147375,101 @@ class SchedSwitchFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class ScmCallEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class RotatorBwAoAsContextFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  ScmCallEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ScmCallEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ScmCallEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  RotatorBwAoAsContextFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit RotatorBwAoAsContextFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit RotatorBwAoAsContextFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_state() const { return at<1>().valid(); }
+  uint32_t state() const { return at<1>().as_uint32(); }
 };
 
-class ScmCallEndFtraceEvent : public ::protozero::Message {
+class RotatorBwAoAsContextFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = ScmCallEndFtraceEvent_Decoder;
-  static constexpr const char* GetName() { return ".perfetto.protos.ScmCallEndFtraceEvent"; }
+  using Decoder = RotatorBwAoAsContextFtraceEvent_Decoder;
+  enum : int32_t {
+    kStateFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.RotatorBwAoAsContextFtraceEvent"; }
+
+
+  using FieldMetadata_State =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      RotatorBwAoAsContextFtraceEvent>;
 
+  static constexpr FieldMetadata_State kState{};
+  void set_state(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class ScmCallStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MdpPerfUpdateBusFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  ScmCallStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ScmCallStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ScmCallStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_arginfo() const { return at<1>().valid(); }
-  uint32_t arginfo() const { return at<1>().as_uint32(); }
-  bool has_x0() const { return at<2>().valid(); }
-  uint64_t x0() const { return at<2>().as_uint64(); }
-  bool has_x5() const { return at<3>().valid(); }
-  uint64_t x5() const { return at<3>().as_uint64(); }
+  MdpPerfUpdateBusFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MdpPerfUpdateBusFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MdpPerfUpdateBusFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_client() const { return at<1>().valid(); }
+  int32_t client() const { return at<1>().as_int32(); }
+  bool has_ab_quota() const { return at<2>().valid(); }
+  uint64_t ab_quota() const { return at<2>().as_uint64(); }
+  bool has_ib_quota() const { return at<3>().valid(); }
+  uint64_t ib_quota() const { return at<3>().as_uint64(); }
 };
 
-class ScmCallStartFtraceEvent : public ::protozero::Message {
+class MdpPerfUpdateBusFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = ScmCallStartFtraceEvent_Decoder;
+  using Decoder = MdpPerfUpdateBusFtraceEvent_Decoder;
   enum : int32_t {
-    kArginfoFieldNumber = 1,
-    kX0FieldNumber = 2,
-    kX5FieldNumber = 3,
+    kClientFieldNumber = 1,
+    kAbQuotaFieldNumber = 2,
+    kIbQuotaFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ScmCallStartFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MdpPerfUpdateBusFtraceEvent"; }
 
 
-  using FieldMetadata_Arginfo =
+  using FieldMetadata_Client =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      ScmCallStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MdpPerfUpdateBusFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Arginfo kArginfo() { return {}; }
-  void set_arginfo(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Arginfo::kFieldId;
+  static constexpr FieldMetadata_Client kClient{};
+  void set_client(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Client::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_X0 =
+  using FieldMetadata_AbQuota =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      ScmCallStartFtraceEvent>;
+      MdpPerfUpdateBusFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_X0 kX0() { return {}; }
-  void set_x0(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_X0::kFieldId;
+  static constexpr FieldMetadata_AbQuota kAbQuota{};
+  void set_ab_quota(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AbQuota::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -121300,24 +147477,17 @@ class ScmCallStartFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_X5 =
+  using FieldMetadata_IbQuota =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      ScmCallStartFtraceEvent>;
+      MdpPerfUpdateBusFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_X5 kX5() { return {}; }
-  void set_x5(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_X5::kFieldId;
+  static constexpr FieldMetadata_IbQuota kIbQuota{};
+  void set_ib_quota(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IbQuota::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -121326,100 +147496,80 @@ class ScmCallStartFtraceEvent : public ::protozero::Message {
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/sde.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SDE_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SDE_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class SdeSdePerfUpdateBusFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MdpPerfPrefillCalcFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10> {
  public:
-  SdeSdePerfUpdateBusFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SdeSdePerfUpdateBusFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SdeSdePerfUpdateBusFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_ab_quota() const { return at<1>().valid(); }
-  uint64_t ab_quota() const { return at<1>().as_uint64(); }
-  bool has_bus_id() const { return at<2>().valid(); }
-  uint32_t bus_id() const { return at<2>().as_uint32(); }
-  bool has_client() const { return at<3>().valid(); }
-  int32_t client() const { return at<3>().as_int32(); }
-  bool has_ib_quota() const { return at<4>().valid(); }
-  uint64_t ib_quota() const { return at<4>().as_uint64(); }
+  MdpPerfPrefillCalcFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MdpPerfPrefillCalcFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MdpPerfPrefillCalcFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pnum() const { return at<1>().valid(); }
+  uint32_t pnum() const { return at<1>().as_uint32(); }
+  bool has_latency_buf() const { return at<2>().valid(); }
+  uint32_t latency_buf() const { return at<2>().as_uint32(); }
+  bool has_ot() const { return at<3>().valid(); }
+  uint32_t ot() const { return at<3>().as_uint32(); }
+  bool has_y_buf() const { return at<4>().valid(); }
+  uint32_t y_buf() const { return at<4>().as_uint32(); }
+  bool has_y_scaler() const { return at<5>().valid(); }
+  uint32_t y_scaler() const { return at<5>().as_uint32(); }
+  bool has_pp_lines() const { return at<6>().valid(); }
+  uint32_t pp_lines() const { return at<6>().as_uint32(); }
+  bool has_pp_bytes() const { return at<7>().valid(); }
+  uint32_t pp_bytes() const { return at<7>().as_uint32(); }
+  bool has_post_sc() const { return at<8>().valid(); }
+  uint32_t post_sc() const { return at<8>().as_uint32(); }
+  bool has_fbc_bytes() const { return at<9>().valid(); }
+  uint32_t fbc_bytes() const { return at<9>().as_uint32(); }
+  bool has_prefill_bytes() const { return at<10>().valid(); }
+  uint32_t prefill_bytes() const { return at<10>().as_uint32(); }
 };
 
-class SdeSdePerfUpdateBusFtraceEvent : public ::protozero::Message {
+class MdpPerfPrefillCalcFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SdeSdePerfUpdateBusFtraceEvent_Decoder;
+  using Decoder = MdpPerfPrefillCalcFtraceEvent_Decoder;
   enum : int32_t {
-    kAbQuotaFieldNumber = 1,
-    kBusIdFieldNumber = 2,
-    kClientFieldNumber = 3,
-    kIbQuotaFieldNumber = 4,
+    kPnumFieldNumber = 1,
+    kLatencyBufFieldNumber = 2,
+    kOtFieldNumber = 3,
+    kYBufFieldNumber = 4,
+    kYScalerFieldNumber = 5,
+    kPpLinesFieldNumber = 6,
+    kPpBytesFieldNumber = 7,
+    kPostScFieldNumber = 8,
+    kFbcBytesFieldNumber = 9,
+    kPrefillBytesFieldNumber = 10,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SdeSdePerfUpdateBusFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MdpPerfPrefillCalcFtraceEvent"; }
 
 
-  using FieldMetadata_AbQuota =
+  using FieldMetadata_Pnum =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SdeSdePerfUpdateBusFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfPrefillCalcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AbQuota kAbQuota() { return {}; }
-  void set_ab_quota(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AbQuota::kFieldId;
+  static constexpr FieldMetadata_Pnum kPnum{};
+  void set_pnum(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pnum::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BusId =
+  using FieldMetadata_LatencyBuf =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SdeSdePerfUpdateBusFtraceEvent>;
+      MdpPerfPrefillCalcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BusId kBusId() { return {}; }
-  void set_bus_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BusId::kFieldId;
+  static constexpr FieldMetadata_LatencyBuf kLatencyBuf{};
+  void set_latency_buf(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LatencyBuf::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -121427,108 +147577,89 @@ class SdeSdePerfUpdateBusFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Client =
+  using FieldMetadata_Ot =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SdeSdePerfUpdateBusFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfPrefillCalcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Client kClient() { return {}; }
-  void set_client(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Client::kFieldId;
+  static constexpr FieldMetadata_Ot kOt{};
+  void set_ot(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ot::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IbQuota =
+  using FieldMetadata_YBuf =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SdeSdePerfUpdateBusFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfPrefillCalcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IbQuota kIbQuota() { return {}; }
-  void set_ib_quota(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IbQuota::kFieldId;
+  static constexpr FieldMetadata_YBuf kYBuf{};
+  void set_y_buf(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_YBuf::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
 
-class SdeSdePerfSetQosLutsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  SdeSdePerfSetQosLutsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SdeSdePerfSetQosLutsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SdeSdePerfSetQosLutsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_fl() const { return at<1>().valid(); }
-  uint32_t fl() const { return at<1>().as_uint32(); }
-  bool has_fmt() const { return at<2>().valid(); }
-  uint32_t fmt() const { return at<2>().as_uint32(); }
-  bool has_lut() const { return at<3>().valid(); }
-  uint64_t lut() const { return at<3>().as_uint64(); }
-  bool has_lut_usage() const { return at<4>().valid(); }
-  uint32_t lut_usage() const { return at<4>().as_uint32(); }
-  bool has_pnum() const { return at<5>().valid(); }
-  uint32_t pnum() const { return at<5>().as_uint32(); }
-  bool has_rt() const { return at<6>().valid(); }
-  uint32_t rt() const { return at<6>().as_uint32(); }
-};
+  using FieldMetadata_YScaler =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfPrefillCalcFtraceEvent>;
 
-class SdeSdePerfSetQosLutsFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = SdeSdePerfSetQosLutsFtraceEvent_Decoder;
-  enum : int32_t {
-    kFlFieldNumber = 1,
-    kFmtFieldNumber = 2,
-    kLutFieldNumber = 3,
-    kLutUsageFieldNumber = 4,
-    kPnumFieldNumber = 5,
-    kRtFieldNumber = 6,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.SdeSdePerfSetQosLutsFtraceEvent"; }
+  static constexpr FieldMetadata_YScaler kYScaler{};
+  void set_y_scaler(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_YScaler::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PpLines =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfPrefillCalcFtraceEvent>;
 
+  static constexpr FieldMetadata_PpLines kPpLines{};
+  void set_pp_lines(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PpLines::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Fl =
+  using FieldMetadata_PpBytes =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SdeSdePerfSetQosLutsFtraceEvent>;
+      MdpPerfPrefillCalcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Fl kFl() { return {}; }
-  void set_fl(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Fl::kFieldId;
+  static constexpr FieldMetadata_PpBytes kPpBytes{};
+  void set_pp_bytes(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PpBytes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -121536,24 +147667,93 @@ class SdeSdePerfSetQosLutsFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Fmt =
+  using FieldMetadata_PostSc =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfPrefillCalcFtraceEvent>;
+
+  static constexpr FieldMetadata_PostSc kPostSc{};
+  void set_post_sc(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PostSc::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FbcBytes =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfPrefillCalcFtraceEvent>;
+
+  static constexpr FieldMetadata_FbcBytes kFbcBytes{};
+  void set_fbc_bytes(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FbcBytes::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PrefillBytes =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfPrefillCalcFtraceEvent>;
+
+  static constexpr FieldMetadata_PrefillBytes kPrefillBytes{};
+  void set_prefill_bytes(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PrefillBytes::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class MdpCmdWaitPingpongFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  MdpCmdWaitPingpongFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MdpCmdWaitPingpongFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MdpCmdWaitPingpongFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_ctl_num() const { return at<1>().valid(); }
+  uint32_t ctl_num() const { return at<1>().as_uint32(); }
+  bool has_kickoff_cnt() const { return at<2>().valid(); }
+  int32_t kickoff_cnt() const { return at<2>().as_int32(); }
+};
+
+class MdpCmdWaitPingpongFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = MdpCmdWaitPingpongFtraceEvent_Decoder;
+  enum : int32_t {
+    kCtlNumFieldNumber = 1,
+    kKickoffCntFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.MdpCmdWaitPingpongFtraceEvent"; }
+
+
+  using FieldMetadata_CtlNum =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SdeSdePerfSetQosLutsFtraceEvent>;
+      MdpCmdWaitPingpongFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Fmt kFmt() { return {}; }
-  void set_fmt(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Fmt::kFieldId;
+  static constexpr FieldMetadata_CtlNum kCtlNum{};
+  void set_ctl_num(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CtlNum::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -121561,74 +147761,57 @@ class SdeSdePerfSetQosLutsFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Lut =
+  using FieldMetadata_KickoffCnt =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SdeSdePerfSetQosLutsFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MdpCmdWaitPingpongFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lut kLut() { return {}; }
-  void set_lut(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lut::kFieldId;
+  static constexpr FieldMetadata_KickoffCnt kKickoffCnt{};
+  void set_kickoff_cnt(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KickoffCnt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_LutUsage =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SdeSdePerfSetQosLutsFtraceEvent>;
+class MdpVideoUnderrunDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  MdpVideoUnderrunDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MdpVideoUnderrunDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MdpVideoUnderrunDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_ctl_num() const { return at<1>().valid(); }
+  uint32_t ctl_num() const { return at<1>().as_uint32(); }
+  bool has_underrun_cnt() const { return at<2>().valid(); }
+  uint32_t underrun_cnt() const { return at<2>().as_uint32(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LutUsage kLutUsage() { return {}; }
-  void set_lut_usage(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LutUsage::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+class MdpVideoUnderrunDoneFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = MdpVideoUnderrunDoneFtraceEvent_Decoder;
+  enum : int32_t {
+    kCtlNumFieldNumber = 1,
+    kUnderrunCntFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.MdpVideoUnderrunDoneFtraceEvent"; }
 
-  using FieldMetadata_Pnum =
+
+  using FieldMetadata_CtlNum =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SdeSdePerfSetQosLutsFtraceEvent>;
+      MdpVideoUnderrunDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pnum kPnum() { return {}; }
-  void set_pnum(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pnum::kFieldId;
+  static constexpr FieldMetadata_CtlNum kCtlNum{};
+  void set_ctl_num(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CtlNum::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -121636,24 +147819,17 @@ class SdeSdePerfSetQosLutsFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Rt =
+  using FieldMetadata_UnderrunCnt =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SdeSdePerfSetQosLutsFtraceEvent>;
+      MdpVideoUnderrunDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Rt kRt() { return {}; }
-  void set_rt(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Rt::kFieldId;
+  static constexpr FieldMetadata_UnderrunCnt kUnderrunCnt{};
+  void set_underrun_cnt(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_UnderrunCnt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -121662,150 +147838,110 @@ class SdeSdePerfSetQosLutsFtraceEvent : public ::protozero::Message {
   }
 };
 
-class SdeSdePerfCrtcUpdateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/12, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MdpPerfSetWmLevelsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
  public:
-  SdeSdePerfCrtcUpdateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SdeSdePerfCrtcUpdateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SdeSdePerfCrtcUpdateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_bw_ctl_ebi() const { return at<1>().valid(); }
-  uint64_t bw_ctl_ebi() const { return at<1>().as_uint64(); }
-  bool has_bw_ctl_llcc() const { return at<2>().valid(); }
-  uint64_t bw_ctl_llcc() const { return at<2>().as_uint64(); }
-  bool has_bw_ctl_mnoc() const { return at<3>().valid(); }
-  uint64_t bw_ctl_mnoc() const { return at<3>().as_uint64(); }
-  bool has_core_clk_rate() const { return at<4>().valid(); }
-  uint32_t core_clk_rate() const { return at<4>().as_uint32(); }
-  bool has_crtc() const { return at<5>().valid(); }
-  uint32_t crtc() const { return at<5>().as_uint32(); }
-  bool has_params() const { return at<6>().valid(); }
-  int32_t params() const { return at<6>().as_int32(); }
-  bool has_per_pipe_ib_ebi() const { return at<7>().valid(); }
-  uint64_t per_pipe_ib_ebi() const { return at<7>().as_uint64(); }
-  bool has_per_pipe_ib_llcc() const { return at<8>().valid(); }
-  uint64_t per_pipe_ib_llcc() const { return at<8>().as_uint64(); }
-  bool has_per_pipe_ib_mnoc() const { return at<9>().valid(); }
-  uint64_t per_pipe_ib_mnoc() const { return at<9>().as_uint64(); }
-  bool has_stop_req() const { return at<10>().valid(); }
-  uint32_t stop_req() const { return at<10>().as_uint32(); }
-  bool has_update_bus() const { return at<11>().valid(); }
-  uint32_t update_bus() const { return at<11>().as_uint32(); }
-  bool has_update_clk() const { return at<12>().valid(); }
-  uint32_t update_clk() const { return at<12>().as_uint32(); }
+  MdpPerfSetWmLevelsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MdpPerfSetWmLevelsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MdpPerfSetWmLevelsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pnum() const { return at<1>().valid(); }
+  uint32_t pnum() const { return at<1>().as_uint32(); }
+  bool has_use_space() const { return at<2>().valid(); }
+  uint32_t use_space() const { return at<2>().as_uint32(); }
+  bool has_priority_bytes() const { return at<3>().valid(); }
+  uint32_t priority_bytes() const { return at<3>().as_uint32(); }
+  bool has_wm0() const { return at<4>().valid(); }
+  uint32_t wm0() const { return at<4>().as_uint32(); }
+  bool has_wm1() const { return at<5>().valid(); }
+  uint32_t wm1() const { return at<5>().as_uint32(); }
+  bool has_wm2() const { return at<6>().valid(); }
+  uint32_t wm2() const { return at<6>().as_uint32(); }
+  bool has_mb_cnt() const { return at<7>().valid(); }
+  uint32_t mb_cnt() const { return at<7>().as_uint32(); }
+  bool has_mb_size() const { return at<8>().valid(); }
+  uint32_t mb_size() const { return at<8>().as_uint32(); }
 };
 
-class SdeSdePerfCrtcUpdateFtraceEvent : public ::protozero::Message {
+class MdpPerfSetWmLevelsFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SdeSdePerfCrtcUpdateFtraceEvent_Decoder;
+  using Decoder = MdpPerfSetWmLevelsFtraceEvent_Decoder;
   enum : int32_t {
-    kBwCtlEbiFieldNumber = 1,
-    kBwCtlLlccFieldNumber = 2,
-    kBwCtlMnocFieldNumber = 3,
-    kCoreClkRateFieldNumber = 4,
-    kCrtcFieldNumber = 5,
-    kParamsFieldNumber = 6,
-    kPerPipeIbEbiFieldNumber = 7,
-    kPerPipeIbLlccFieldNumber = 8,
-    kPerPipeIbMnocFieldNumber = 9,
-    kStopReqFieldNumber = 10,
-    kUpdateBusFieldNumber = 11,
-    kUpdateClkFieldNumber = 12,
+    kPnumFieldNumber = 1,
+    kUseSpaceFieldNumber = 2,
+    kPriorityBytesFieldNumber = 3,
+    kWm0FieldNumber = 4,
+    kWm1FieldNumber = 5,
+    kWm2FieldNumber = 6,
+    kMbCntFieldNumber = 7,
+    kMbSizeFieldNumber = 8,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SdeSdePerfCrtcUpdateFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MdpPerfSetWmLevelsFtraceEvent"; }
 
 
-  using FieldMetadata_BwCtlEbi =
+  using FieldMetadata_Pnum =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SdeSdePerfCrtcUpdateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfSetWmLevelsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BwCtlEbi kBwCtlEbi() { return {}; }
-  void set_bw_ctl_ebi(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BwCtlEbi::kFieldId;
+  static constexpr FieldMetadata_Pnum kPnum{};
+  void set_pnum(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pnum::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BwCtlLlcc =
+  using FieldMetadata_UseSpace =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SdeSdePerfCrtcUpdateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfSetWmLevelsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BwCtlLlcc kBwCtlLlcc() { return {}; }
-  void set_bw_ctl_llcc(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BwCtlLlcc::kFieldId;
+  static constexpr FieldMetadata_UseSpace kUseSpace{};
+  void set_use_space(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_UseSpace::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BwCtlMnoc =
+  using FieldMetadata_PriorityBytes =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SdeSdePerfCrtcUpdateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfSetWmLevelsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BwCtlMnoc kBwCtlMnoc() { return {}; }
-  void set_bw_ctl_mnoc(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BwCtlMnoc::kFieldId;
+  static constexpr FieldMetadata_PriorityBytes kPriorityBytes{};
+  void set_priority_bytes(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PriorityBytes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CoreClkRate =
+  using FieldMetadata_Wm0 =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SdeSdePerfCrtcUpdateFtraceEvent>;
+      MdpPerfSetWmLevelsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CoreClkRate kCoreClkRate() { return {}; }
-  void set_core_clk_rate(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CoreClkRate::kFieldId;
+  static constexpr FieldMetadata_Wm0 kWm0{};
+  void set_wm0(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Wm0::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -121813,24 +147949,17 @@ class SdeSdePerfCrtcUpdateFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Crtc =
+  using FieldMetadata_Wm1 =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SdeSdePerfCrtcUpdateFtraceEvent>;
+      MdpPerfSetWmLevelsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Crtc kCrtc() { return {}; }
-  void set_crtc(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Crtc::kFieldId;
+  static constexpr FieldMetadata_Wm1 kWm1{};
+  void set_wm1(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Wm1::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -121838,314 +147967,321 @@ class SdeSdePerfCrtcUpdateFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Params =
+  using FieldMetadata_Wm2 =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SdeSdePerfCrtcUpdateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfSetWmLevelsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Params kParams() { return {}; }
-  void set_params(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Params::kFieldId;
+  static constexpr FieldMetadata_Wm2 kWm2{};
+  void set_wm2(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Wm2::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PerPipeIbEbi =
+  using FieldMetadata_MbCnt =
     ::protozero::proto_utils::FieldMetadata<
       7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SdeSdePerfCrtcUpdateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfSetWmLevelsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PerPipeIbEbi kPerPipeIbEbi() { return {}; }
-  void set_per_pipe_ib_ebi(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PerPipeIbEbi::kFieldId;
+  static constexpr FieldMetadata_MbCnt kMbCnt{};
+  void set_mb_cnt(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MbCnt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PerPipeIbLlcc =
+  using FieldMetadata_MbSize =
     ::protozero::proto_utils::FieldMetadata<
       8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SdeSdePerfCrtcUpdateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfSetWmLevelsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PerPipeIbLlcc kPerPipeIbLlcc() { return {}; }
-  void set_per_pipe_ib_llcc(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PerPipeIbLlcc::kFieldId;
+  static constexpr FieldMetadata_MbSize kMbSize{};
+  void set_mb_size(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MbSize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_PerPipeIbMnoc =
+class MdpMixerUpdateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  MdpMixerUpdateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MdpMixerUpdateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MdpMixerUpdateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_mixer_num() const { return at<1>().valid(); }
+  uint32_t mixer_num() const { return at<1>().as_uint32(); }
+};
+
+class MdpMixerUpdateFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = MdpMixerUpdateFtraceEvent_Decoder;
+  enum : int32_t {
+    kMixerNumFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.MdpMixerUpdateFtraceEvent"; }
+
+
+  using FieldMetadata_MixerNum =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SdeSdePerfCrtcUpdateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpMixerUpdateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PerPipeIbMnoc kPerPipeIbMnoc() { return {}; }
-  void set_per_pipe_ib_mnoc(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PerPipeIbMnoc::kFieldId;
+  static constexpr FieldMetadata_MixerNum kMixerNum{};
+  void set_mixer_num(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MixerNum::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_StopReq =
+class MdpCmdReleaseBwFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  MdpCmdReleaseBwFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MdpCmdReleaseBwFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MdpCmdReleaseBwFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_ctl_num() const { return at<1>().valid(); }
+  uint32_t ctl_num() const { return at<1>().as_uint32(); }
+};
+
+class MdpCmdReleaseBwFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = MdpCmdReleaseBwFtraceEvent_Decoder;
+  enum : int32_t {
+    kCtlNumFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.MdpCmdReleaseBwFtraceEvent"; }
+
+
+  using FieldMetadata_CtlNum =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SdeSdePerfCrtcUpdateFtraceEvent>;
+      MdpCmdReleaseBwFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StopReq kStopReq() { return {}; }
-  void set_stop_req(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StopReq::kFieldId;
+  static constexpr FieldMetadata_CtlNum kCtlNum{};
+  void set_ctl_num(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CtlNum::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_UpdateBus =
+class MdpTraceCounterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  MdpTraceCounterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MdpTraceCounterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MdpTraceCounterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  int32_t pid() const { return at<1>().as_int32(); }
+  bool has_counter_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars counter_name() const { return at<2>().as_string(); }
+  bool has_value() const { return at<3>().valid(); }
+  int32_t value() const { return at<3>().as_int32(); }
+};
+
+class MdpTraceCounterFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = MdpTraceCounterFtraceEvent_Decoder;
+  enum : int32_t {
+    kPidFieldNumber = 1,
+    kCounterNameFieldNumber = 2,
+    kValueFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.MdpTraceCounterFtraceEvent"; }
+
+
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SdeSdePerfCrtcUpdateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MdpTraceCounterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UpdateBus kUpdateBus() { return {}; }
-  void set_update_bus(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_UpdateBus::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_UpdateClk =
+  using FieldMetadata_CounterName =
     ::protozero::proto_utils::FieldMetadata<
-      12,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SdeSdePerfCrtcUpdateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      MdpTraceCounterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UpdateClk kUpdateClk() { return {}; }
-  void set_update_clk(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_UpdateClk::kFieldId;
+  static constexpr FieldMetadata_CounterName kCounterName{};
+  void set_counter_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_CounterName::kFieldId, data, size);
+  }
+  void set_counter_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_CounterName::kFieldId, chars.data, chars.size);
+  }
+  void set_counter_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_CounterName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MdpTraceCounterFtraceEvent>;
+
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class SdeSdePerfCalcCrtcFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MdpPerfSetQosLutsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
-  SdeSdePerfCalcCrtcFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SdeSdePerfCalcCrtcFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SdeSdePerfCalcCrtcFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_bw_ctl_ebi() const { return at<1>().valid(); }
-  uint64_t bw_ctl_ebi() const { return at<1>().as_uint64(); }
-  bool has_bw_ctl_llcc() const { return at<2>().valid(); }
-  uint64_t bw_ctl_llcc() const { return at<2>().as_uint64(); }
-  bool has_bw_ctl_mnoc() const { return at<3>().valid(); }
-  uint64_t bw_ctl_mnoc() const { return at<3>().as_uint64(); }
-  bool has_core_clk_rate() const { return at<4>().valid(); }
-  uint32_t core_clk_rate() const { return at<4>().as_uint32(); }
-  bool has_crtc() const { return at<5>().valid(); }
-  uint32_t crtc() const { return at<5>().as_uint32(); }
-  bool has_ib_ebi() const { return at<6>().valid(); }
-  uint64_t ib_ebi() const { return at<6>().as_uint64(); }
-  bool has_ib_llcc() const { return at<7>().valid(); }
-  uint64_t ib_llcc() const { return at<7>().as_uint64(); }
-  bool has_ib_mnoc() const { return at<8>().valid(); }
-  uint64_t ib_mnoc() const { return at<8>().as_uint64(); }
+  MdpPerfSetQosLutsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MdpPerfSetQosLutsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MdpPerfSetQosLutsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pnum() const { return at<1>().valid(); }
+  uint32_t pnum() const { return at<1>().as_uint32(); }
+  bool has_fmt() const { return at<2>().valid(); }
+  uint32_t fmt() const { return at<2>().as_uint32(); }
+  bool has_intf() const { return at<3>().valid(); }
+  uint32_t intf() const { return at<3>().as_uint32(); }
+  bool has_rot() const { return at<4>().valid(); }
+  uint32_t rot() const { return at<4>().as_uint32(); }
+  bool has_fl() const { return at<5>().valid(); }
+  uint32_t fl() const { return at<5>().as_uint32(); }
+  bool has_lut() const { return at<6>().valid(); }
+  uint32_t lut() const { return at<6>().as_uint32(); }
+  bool has_linear() const { return at<7>().valid(); }
+  uint32_t linear() const { return at<7>().as_uint32(); }
 };
 
-class SdeSdePerfCalcCrtcFtraceEvent : public ::protozero::Message {
+class MdpPerfSetQosLutsFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SdeSdePerfCalcCrtcFtraceEvent_Decoder;
+  using Decoder = MdpPerfSetQosLutsFtraceEvent_Decoder;
   enum : int32_t {
-    kBwCtlEbiFieldNumber = 1,
-    kBwCtlLlccFieldNumber = 2,
-    kBwCtlMnocFieldNumber = 3,
-    kCoreClkRateFieldNumber = 4,
-    kCrtcFieldNumber = 5,
-    kIbEbiFieldNumber = 6,
-    kIbLlccFieldNumber = 7,
-    kIbMnocFieldNumber = 8,
+    kPnumFieldNumber = 1,
+    kFmtFieldNumber = 2,
+    kIntfFieldNumber = 3,
+    kRotFieldNumber = 4,
+    kFlFieldNumber = 5,
+    kLutFieldNumber = 6,
+    kLinearFieldNumber = 7,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SdeSdePerfCalcCrtcFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MdpPerfSetQosLutsFtraceEvent"; }
 
 
-  using FieldMetadata_BwCtlEbi =
+  using FieldMetadata_Pnum =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SdeSdePerfCalcCrtcFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfSetQosLutsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BwCtlEbi kBwCtlEbi() { return {}; }
-  void set_bw_ctl_ebi(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BwCtlEbi::kFieldId;
+  static constexpr FieldMetadata_Pnum kPnum{};
+  void set_pnum(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pnum::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BwCtlLlcc =
+  using FieldMetadata_Fmt =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SdeSdePerfCalcCrtcFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfSetQosLutsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BwCtlLlcc kBwCtlLlcc() { return {}; }
-  void set_bw_ctl_llcc(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BwCtlLlcc::kFieldId;
+  static constexpr FieldMetadata_Fmt kFmt{};
+  void set_fmt(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Fmt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BwCtlMnoc =
+  using FieldMetadata_Intf =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SdeSdePerfCalcCrtcFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfSetQosLutsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BwCtlMnoc kBwCtlMnoc() { return {}; }
-  void set_bw_ctl_mnoc(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BwCtlMnoc::kFieldId;
+  static constexpr FieldMetadata_Intf kIntf{};
+  void set_intf(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Intf::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CoreClkRate =
+  using FieldMetadata_Rot =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SdeSdePerfCalcCrtcFtraceEvent>;
+      MdpPerfSetQosLutsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CoreClkRate kCoreClkRate() { return {}; }
-  void set_core_clk_rate(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CoreClkRate::kFieldId;
+  static constexpr FieldMetadata_Rot kRot{};
+  void set_rot(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Rot::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -122153,24 +148289,17 @@ class SdeSdePerfCalcCrtcFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Crtc =
+  using FieldMetadata_Fl =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SdeSdePerfCalcCrtcFtraceEvent>;
+      MdpPerfSetQosLutsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Crtc kCrtc() { return {}; }
-  void set_crtc(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Crtc::kFieldId;
+  static constexpr FieldMetadata_Fl kFl{};
+  void set_fl(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Fl::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -122178,180 +148307,114 @@ class SdeSdePerfCalcCrtcFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IbEbi =
+  using FieldMetadata_Lut =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SdeSdePerfCalcCrtcFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfSetQosLutsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IbEbi kIbEbi() { return {}; }
-  void set_ib_ebi(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IbEbi::kFieldId;
+  static constexpr FieldMetadata_Lut kLut{};
+  void set_lut(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lut::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IbLlcc =
+  using FieldMetadata_Linear =
     ::protozero::proto_utils::FieldMetadata<
       7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SdeSdePerfCalcCrtcFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IbLlcc kIbLlcc() { return {}; }
-  void set_ib_llcc(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IbLlcc::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_IbMnoc =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SdeSdePerfCalcCrtcFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfSetQosLutsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IbMnoc kIbMnoc() { return {}; }
-  void set_ib_mnoc(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IbMnoc::kFieldId;
+  static constexpr FieldMetadata_Linear kLinear{};
+  void set_linear(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Linear::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class SdeSdeEvtlogFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MdpMisrCrcFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  SdeSdeEvtlogFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SdeSdeEvtlogFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SdeSdeEvtlogFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_evtlog_tag() const { return at<1>().valid(); }
-  ::protozero::ConstChars evtlog_tag() const { return at<1>().as_string(); }
-  bool has_pid() const { return at<2>().valid(); }
-  int32_t pid() const { return at<2>().as_int32(); }
-  bool has_tag_id() const { return at<3>().valid(); }
-  uint32_t tag_id() const { return at<3>().as_uint32(); }
+  MdpMisrCrcFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MdpMisrCrcFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MdpMisrCrcFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_block_id() const { return at<1>().valid(); }
+  uint32_t block_id() const { return at<1>().as_uint32(); }
+  bool has_vsync_cnt() const { return at<2>().valid(); }
+  uint32_t vsync_cnt() const { return at<2>().as_uint32(); }
+  bool has_crc() const { return at<3>().valid(); }
+  uint32_t crc() const { return at<3>().as_uint32(); }
 };
 
-class SdeSdeEvtlogFtraceEvent : public ::protozero::Message {
+class MdpMisrCrcFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SdeSdeEvtlogFtraceEvent_Decoder;
+  using Decoder = MdpMisrCrcFtraceEvent_Decoder;
   enum : int32_t {
-    kEvtlogTagFieldNumber = 1,
-    kPidFieldNumber = 2,
-    kTagIdFieldNumber = 3,
+    kBlockIdFieldNumber = 1,
+    kVsyncCntFieldNumber = 2,
+    kCrcFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SdeSdeEvtlogFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MdpMisrCrcFtraceEvent"; }
 
 
-  using FieldMetadata_EvtlogTag =
+  using FieldMetadata_BlockId =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SdeSdeEvtlogFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpMisrCrcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EvtlogTag kEvtlogTag() { return {}; }
-  void set_evtlog_tag(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_EvtlogTag::kFieldId, data, size);
-  }
-  void set_evtlog_tag(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_EvtlogTag::kFieldId, chars.data, chars.size);
-  }
-  void set_evtlog_tag(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_EvtlogTag::kFieldId;
+  static constexpr FieldMetadata_BlockId kBlockId{};
+  void set_block_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BlockId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_VsyncCnt =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SdeSdeEvtlogFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpMisrCrcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_VsyncCnt kVsyncCnt{};
+  void set_vsync_cnt(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VsyncCnt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TagId =
+  using FieldMetadata_Crc =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SdeSdeEvtlogFtraceEvent>;
+      MdpMisrCrcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TagId kTagId() { return {}; }
-  void set_tag_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TagId::kFieldId;
+  static constexpr FieldMetadata_Crc kCrc{};
+  void set_crc(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Crc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -122360,110 +148423,174 @@ class SdeSdeEvtlogFtraceEvent : public ::protozero::Message {
   }
 };
 
-class SdeTracingMarkWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MdpCmdReadptrDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  SdeTracingMarkWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SdeTracingMarkWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SdeTracingMarkWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pid() const { return at<1>().valid(); }
-  int32_t pid() const { return at<1>().as_int32(); }
-  bool has_trace_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars trace_name() const { return at<2>().as_string(); }
-  bool has_trace_type() const { return at<3>().valid(); }
-  uint32_t trace_type() const { return at<3>().as_uint32(); }
-  bool has_value() const { return at<4>().valid(); }
-  int32_t value() const { return at<4>().as_int32(); }
-  bool has_trace_begin() const { return at<5>().valid(); }
-  uint32_t trace_begin() const { return at<5>().as_uint32(); }
+  MdpCmdReadptrDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MdpCmdReadptrDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MdpCmdReadptrDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_ctl_num() const { return at<1>().valid(); }
+  uint32_t ctl_num() const { return at<1>().as_uint32(); }
+  bool has_koff_cnt() const { return at<2>().valid(); }
+  int32_t koff_cnt() const { return at<2>().as_int32(); }
 };
 
-class SdeTracingMarkWriteFtraceEvent : public ::protozero::Message {
+class MdpCmdReadptrDoneFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SdeTracingMarkWriteFtraceEvent_Decoder;
+  using Decoder = MdpCmdReadptrDoneFtraceEvent_Decoder;
   enum : int32_t {
-    kPidFieldNumber = 1,
-    kTraceNameFieldNumber = 2,
-    kTraceTypeFieldNumber = 3,
-    kValueFieldNumber = 4,
-    kTraceBeginFieldNumber = 5,
+    kCtlNumFieldNumber = 1,
+    kKoffCntFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SdeTracingMarkWriteFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MdpCmdReadptrDoneFtraceEvent"; }
 
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_CtlNum =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpCmdReadptrDoneFtraceEvent>;
+
+  static constexpr FieldMetadata_CtlNum kCtlNum{};
+  void set_ctl_num(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CtlNum::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_KoffCnt =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      SdeTracingMarkWriteFtraceEvent>;
+      MdpCmdReadptrDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_KoffCnt kKoffCnt{};
+  void set_koff_cnt(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KoffCnt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TraceName =
+class MdpSsppSetFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/16> {
+ public:
+  MdpSsppSetFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MdpSsppSetFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MdpSsppSetFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_num() const { return at<1>().valid(); }
+  uint32_t num() const { return at<1>().as_uint32(); }
+  bool has_play_cnt() const { return at<2>().valid(); }
+  uint32_t play_cnt() const { return at<2>().as_uint32(); }
+  bool has_mixer() const { return at<3>().valid(); }
+  uint32_t mixer() const { return at<3>().as_uint32(); }
+  bool has_stage() const { return at<4>().valid(); }
+  uint32_t stage() const { return at<4>().as_uint32(); }
+  bool has_flags() const { return at<5>().valid(); }
+  uint32_t flags() const { return at<5>().as_uint32(); }
+  bool has_format() const { return at<6>().valid(); }
+  uint32_t format() const { return at<6>().as_uint32(); }
+  bool has_img_w() const { return at<7>().valid(); }
+  uint32_t img_w() const { return at<7>().as_uint32(); }
+  bool has_img_h() const { return at<8>().valid(); }
+  uint32_t img_h() const { return at<8>().as_uint32(); }
+  bool has_src_x() const { return at<9>().valid(); }
+  uint32_t src_x() const { return at<9>().as_uint32(); }
+  bool has_src_y() const { return at<10>().valid(); }
+  uint32_t src_y() const { return at<10>().as_uint32(); }
+  bool has_src_w() const { return at<11>().valid(); }
+  uint32_t src_w() const { return at<11>().as_uint32(); }
+  bool has_src_h() const { return at<12>().valid(); }
+  uint32_t src_h() const { return at<12>().as_uint32(); }
+  bool has_dst_x() const { return at<13>().valid(); }
+  uint32_t dst_x() const { return at<13>().as_uint32(); }
+  bool has_dst_y() const { return at<14>().valid(); }
+  uint32_t dst_y() const { return at<14>().as_uint32(); }
+  bool has_dst_w() const { return at<15>().valid(); }
+  uint32_t dst_w() const { return at<15>().as_uint32(); }
+  bool has_dst_h() const { return at<16>().valid(); }
+  uint32_t dst_h() const { return at<16>().as_uint32(); }
+};
+
+class MdpSsppSetFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = MdpSsppSetFtraceEvent_Decoder;
+  enum : int32_t {
+    kNumFieldNumber = 1,
+    kPlayCntFieldNumber = 2,
+    kMixerFieldNumber = 3,
+    kStageFieldNumber = 4,
+    kFlagsFieldNumber = 5,
+    kFormatFieldNumber = 6,
+    kImgWFieldNumber = 7,
+    kImgHFieldNumber = 8,
+    kSrcXFieldNumber = 9,
+    kSrcYFieldNumber = 10,
+    kSrcWFieldNumber = 11,
+    kSrcHFieldNumber = 12,
+    kDstXFieldNumber = 13,
+    kDstYFieldNumber = 14,
+    kDstWFieldNumber = 15,
+    kDstHFieldNumber = 16,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.MdpSsppSetFtraceEvent"; }
+
+
+  using FieldMetadata_Num =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SdeTracingMarkWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppSetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceName kTraceName() { return {}; }
-  void set_trace_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_TraceName::kFieldId, data, size);
-  }
-  void set_trace_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_TraceName::kFieldId, chars.data, chars.size);
+  static constexpr FieldMetadata_Num kNum{};
+  void set_num(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Num::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
-  void set_trace_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_TraceName::kFieldId;
+
+  using FieldMetadata_PlayCnt =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppSetFtraceEvent>;
+
+  static constexpr FieldMetadata_PlayCnt kPlayCnt{};
+  void set_play_cnt(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PlayCnt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TraceType =
+  using FieldMetadata_Mixer =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SdeTracingMarkWriteFtraceEvent>;
+      MdpSsppSetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceType kTraceType() { return {}; }
-  void set_trace_type(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TraceType::kFieldId;
+  static constexpr FieldMetadata_Mixer kMixer{};
+  void set_mixer(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mixer::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -122471,462 +148598,300 @@ class SdeTracingMarkWriteFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Value =
+  using FieldMetadata_Stage =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SdeTracingMarkWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppSetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+  static constexpr FieldMetadata_Stage kStage{};
+  void set_stage(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Stage::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TraceBegin =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SdeTracingMarkWriteFtraceEvent>;
+      MdpSsppSetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceBegin kTraceBegin() { return {}; }
-  void set_trace_begin(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TraceBegin::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/signal.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SIGNAL_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SIGNAL_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class SignalGenerateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  SignalGenerateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SignalGenerateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SignalGenerateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_code() const { return at<1>().valid(); }
-  int32_t code() const { return at<1>().as_int32(); }
-  bool has_comm() const { return at<2>().valid(); }
-  ::protozero::ConstChars comm() const { return at<2>().as_string(); }
-  bool has_group() const { return at<3>().valid(); }
-  int32_t group() const { return at<3>().as_int32(); }
-  bool has_pid() const { return at<4>().valid(); }
-  int32_t pid() const { return at<4>().as_int32(); }
-  bool has_result() const { return at<5>().valid(); }
-  int32_t result() const { return at<5>().as_int32(); }
-  bool has_sig() const { return at<6>().valid(); }
-  int32_t sig() const { return at<6>().as_int32(); }
-};
-
-class SignalGenerateFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = SignalGenerateFtraceEvent_Decoder;
-  enum : int32_t {
-    kCodeFieldNumber = 1,
-    kCommFieldNumber = 2,
-    kGroupFieldNumber = 3,
-    kPidFieldNumber = 4,
-    kResultFieldNumber = 5,
-    kSigFieldNumber = 6,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.SignalGenerateFtraceEvent"; }
+  using FieldMetadata_Format =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppSetFtraceEvent>;
 
+  static constexpr FieldMetadata_Format kFormat{};
+  void set_format(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Format::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Code =
+  using FieldMetadata_ImgW =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SignalGenerateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppSetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Code kCode() { return {}; }
-  void set_code(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Code::kFieldId;
+  static constexpr FieldMetadata_ImgW kImgW{};
+  void set_img_w(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ImgW::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Comm =
+  using FieldMetadata_ImgH =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SignalGenerateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppSetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
-  void set_comm(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
-  }
-  void set_comm(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
-  }
-  void set_comm(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
+  static constexpr FieldMetadata_ImgH kImgH{};
+  void set_img_h(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ImgH::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Group =
+  using FieldMetadata_SrcX =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SignalGenerateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppSetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Group kGroup() { return {}; }
-  void set_group(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Group::kFieldId;
+  static constexpr FieldMetadata_SrcX kSrcX{};
+  void set_src_x(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SrcX::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_SrcY =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SignalGenerateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppSetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_SrcY kSrcY{};
+  void set_src_y(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SrcY::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Result =
+  using FieldMetadata_SrcW =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SignalGenerateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppSetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Result kResult() { return {}; }
-  void set_result(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Result::kFieldId;
+  static constexpr FieldMetadata_SrcW kSrcW{};
+  void set_src_w(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SrcW::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Sig =
+  using FieldMetadata_SrcH =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      12,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SignalGenerateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppSetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sig kSig() { return {}; }
-  void set_sig(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Sig::kFieldId;
+  static constexpr FieldMetadata_SrcH kSrcH{};
+  void set_src_h(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SrcH::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class SignalDeliverFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  SignalDeliverFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SignalDeliverFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SignalDeliverFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_code() const { return at<1>().valid(); }
-  int32_t code() const { return at<1>().as_int32(); }
-  bool has_sa_flags() const { return at<2>().valid(); }
-  uint64_t sa_flags() const { return at<2>().as_uint64(); }
-  bool has_sig() const { return at<3>().valid(); }
-  int32_t sig() const { return at<3>().as_int32(); }
-};
 
-class SignalDeliverFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = SignalDeliverFtraceEvent_Decoder;
-  enum : int32_t {
-    kCodeFieldNumber = 1,
-    kSaFlagsFieldNumber = 2,
-    kSigFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.SignalDeliverFtraceEvent"; }
+  using FieldMetadata_DstX =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppSetFtraceEvent>;
 
+  static constexpr FieldMetadata_DstX kDstX{};
+  void set_dst_x(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DstX::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Code =
+  using FieldMetadata_DstY =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      14,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SignalDeliverFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppSetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Code kCode() { return {}; }
-  void set_code(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Code::kFieldId;
+  static constexpr FieldMetadata_DstY kDstY{};
+  void set_dst_y(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DstY::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SaFlags =
+  using FieldMetadata_DstW =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      15,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SignalDeliverFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppSetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SaFlags kSaFlags() { return {}; }
-  void set_sa_flags(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SaFlags::kFieldId;
+  static constexpr FieldMetadata_DstW kDstW{};
+  void set_dst_w(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DstW::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Sig =
+  using FieldMetadata_DstH =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      16,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SignalDeliverFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppSetFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sig kSig() { return {}; }
-  void set_sig(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Sig::kFieldId;
+  static constexpr FieldMetadata_DstH kDstH{};
+  void set_dst_h(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DstH::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/skb.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SKB_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SKB_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class KfreeSkbFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MdpPerfSetPanicLutsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  KfreeSkbFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit KfreeSkbFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit KfreeSkbFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_location() const { return at<1>().valid(); }
-  uint64_t location() const { return at<1>().as_uint64(); }
-  bool has_protocol() const { return at<2>().valid(); }
-  uint32_t protocol() const { return at<2>().as_uint32(); }
-  bool has_skbaddr() const { return at<3>().valid(); }
-  uint64_t skbaddr() const { return at<3>().as_uint64(); }
+  MdpPerfSetPanicLutsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MdpPerfSetPanicLutsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MdpPerfSetPanicLutsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pnum() const { return at<1>().valid(); }
+  uint32_t pnum() const { return at<1>().as_uint32(); }
+  bool has_fmt() const { return at<2>().valid(); }
+  uint32_t fmt() const { return at<2>().as_uint32(); }
+  bool has_mode() const { return at<3>().valid(); }
+  uint32_t mode() const { return at<3>().as_uint32(); }
+  bool has_panic_lut() const { return at<4>().valid(); }
+  uint32_t panic_lut() const { return at<4>().as_uint32(); }
+  bool has_robust_lut() const { return at<5>().valid(); }
+  uint32_t robust_lut() const { return at<5>().as_uint32(); }
 };
 
-class KfreeSkbFtraceEvent : public ::protozero::Message {
+class MdpPerfSetPanicLutsFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = KfreeSkbFtraceEvent_Decoder;
+  using Decoder = MdpPerfSetPanicLutsFtraceEvent_Decoder;
   enum : int32_t {
-    kLocationFieldNumber = 1,
-    kProtocolFieldNumber = 2,
-    kSkbaddrFieldNumber = 3,
+    kPnumFieldNumber = 1,
+    kFmtFieldNumber = 2,
+    kModeFieldNumber = 3,
+    kPanicLutFieldNumber = 4,
+    kRobustLutFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.KfreeSkbFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MdpPerfSetPanicLutsFtraceEvent"; }
 
 
-  using FieldMetadata_Location =
+  using FieldMetadata_Pnum =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      KfreeSkbFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfSetPanicLutsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Location kLocation() { return {}; }
-  void set_location(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Location::kFieldId;
+  static constexpr FieldMetadata_Pnum kPnum{};
+  void set_pnum(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pnum::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Protocol =
+  using FieldMetadata_Fmt =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      KfreeSkbFtraceEvent>;
+      MdpPerfSetPanicLutsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Protocol kProtocol() { return {}; }
-  void set_protocol(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Protocol::kFieldId;
+  static constexpr FieldMetadata_Fmt kFmt{};
+  void set_fmt(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Fmt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -122934,266 +148899,219 @@ class KfreeSkbFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Skbaddr =
+  using FieldMetadata_Mode =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      KfreeSkbFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfSetPanicLutsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Skbaddr kSkbaddr() { return {}; }
-  void set_skbaddr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Skbaddr::kFieldId;
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/sock.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SOCK_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SOCK_PROTO_H_
 
-#include <stddef.h>
-#include <stdint.h>
+  using FieldMetadata_PanicLut =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfSetPanicLutsFtraceEvent>;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  static constexpr FieldMetadata_PanicLut kPanicLut{};
+  void set_panic_lut(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PanicLut::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  using FieldMetadata_RobustLut =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfSetPanicLutsFtraceEvent>;
 
+  static constexpr FieldMetadata_RobustLut kRobustLut{};
+  void set_robust_lut(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RobustLut::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
 
-class InetSockSetStateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MdpCompareBwFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
  public:
-  InetSockSetStateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit InetSockSetStateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit InetSockSetStateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_daddr() const { return at<1>().valid(); }
-  uint32_t daddr() const { return at<1>().as_uint32(); }
-  bool has_dport() const { return at<2>().valid(); }
-  uint32_t dport() const { return at<2>().as_uint32(); }
-  bool has_family() const { return at<3>().valid(); }
-  uint32_t family() const { return at<3>().as_uint32(); }
-  bool has_newstate() const { return at<4>().valid(); }
-  int32_t newstate() const { return at<4>().as_int32(); }
-  bool has_oldstate() const { return at<5>().valid(); }
-  int32_t oldstate() const { return at<5>().as_int32(); }
-  bool has_protocol() const { return at<6>().valid(); }
-  uint32_t protocol() const { return at<6>().as_uint32(); }
-  bool has_saddr() const { return at<7>().valid(); }
-  uint32_t saddr() const { return at<7>().as_uint32(); }
-  bool has_skaddr() const { return at<8>().valid(); }
-  uint64_t skaddr() const { return at<8>().as_uint64(); }
-  bool has_sport() const { return at<9>().valid(); }
-  uint32_t sport() const { return at<9>().as_uint32(); }
+  MdpCompareBwFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MdpCompareBwFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MdpCompareBwFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_new_ab() const { return at<1>().valid(); }
+  uint64_t new_ab() const { return at<1>().as_uint64(); }
+  bool has_new_ib() const { return at<2>().valid(); }
+  uint64_t new_ib() const { return at<2>().as_uint64(); }
+  bool has_new_wb() const { return at<3>().valid(); }
+  uint64_t new_wb() const { return at<3>().as_uint64(); }
+  bool has_old_ab() const { return at<4>().valid(); }
+  uint64_t old_ab() const { return at<4>().as_uint64(); }
+  bool has_old_ib() const { return at<5>().valid(); }
+  uint64_t old_ib() const { return at<5>().as_uint64(); }
+  bool has_old_wb() const { return at<6>().valid(); }
+  uint64_t old_wb() const { return at<6>().as_uint64(); }
+  bool has_params_changed() const { return at<7>().valid(); }
+  uint32_t params_changed() const { return at<7>().as_uint32(); }
+  bool has_update_bw() const { return at<8>().valid(); }
+  uint32_t update_bw() const { return at<8>().as_uint32(); }
 };
 
-class InetSockSetStateFtraceEvent : public ::protozero::Message {
+class MdpCompareBwFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = InetSockSetStateFtraceEvent_Decoder;
+  using Decoder = MdpCompareBwFtraceEvent_Decoder;
   enum : int32_t {
-    kDaddrFieldNumber = 1,
-    kDportFieldNumber = 2,
-    kFamilyFieldNumber = 3,
-    kNewstateFieldNumber = 4,
-    kOldstateFieldNumber = 5,
-    kProtocolFieldNumber = 6,
-    kSaddrFieldNumber = 7,
-    kSkaddrFieldNumber = 8,
-    kSportFieldNumber = 9,
+    kNewAbFieldNumber = 1,
+    kNewIbFieldNumber = 2,
+    kNewWbFieldNumber = 3,
+    kOldAbFieldNumber = 4,
+    kOldIbFieldNumber = 5,
+    kOldWbFieldNumber = 6,
+    kParamsChangedFieldNumber = 7,
+    kUpdateBwFieldNumber = 8,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.InetSockSetStateFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MdpCompareBwFtraceEvent"; }
 
 
-  using FieldMetadata_Daddr =
+  using FieldMetadata_NewAb =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      InetSockSetStateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MdpCompareBwFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Daddr kDaddr() { return {}; }
-  void set_daddr(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Daddr::kFieldId;
+  static constexpr FieldMetadata_NewAb kNewAb{};
+  void set_new_ab(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NewAb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Dport =
+  using FieldMetadata_NewIb =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      InetSockSetStateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MdpCompareBwFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dport kDport() { return {}; }
-  void set_dport(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dport::kFieldId;
+  static constexpr FieldMetadata_NewIb kNewIb{};
+  void set_new_ib(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NewIb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Family =
+  using FieldMetadata_NewWb =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      InetSockSetStateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MdpCompareBwFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Family kFamily() { return {}; }
-  void set_family(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Family::kFieldId;
+  static constexpr FieldMetadata_NewWb kNewWb{};
+  void set_new_wb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NewWb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Newstate =
+  using FieldMetadata_OldAb =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      InetSockSetStateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MdpCompareBwFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Newstate kNewstate() { return {}; }
-  void set_newstate(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Newstate::kFieldId;
+  static constexpr FieldMetadata_OldAb kOldAb{};
+  void set_old_ab(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OldAb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Oldstate =
+  using FieldMetadata_OldIb =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      InetSockSetStateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MdpCompareBwFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Oldstate kOldstate() { return {}; }
-  void set_oldstate(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Oldstate::kFieldId;
+  static constexpr FieldMetadata_OldIb kOldIb{};
+  void set_old_ib(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OldIb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Protocol =
+  using FieldMetadata_OldWb =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      InetSockSetStateFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MdpCompareBwFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Protocol kProtocol() { return {}; }
-  void set_protocol(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Protocol::kFieldId;
+  static constexpr FieldMetadata_OldWb kOldWb{};
+  void set_old_wb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OldWb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Saddr =
+  using FieldMetadata_ParamsChanged =
     ::protozero::proto_utils::FieldMetadata<
       7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      InetSockSetStateFtraceEvent>;
+      MdpCompareBwFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Saddr kSaddr() { return {}; }
-  void set_saddr(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Saddr::kFieldId;
+  static constexpr FieldMetadata_ParamsChanged kParamsChanged{};
+  void set_params_changed(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ParamsChanged::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -123201,49 +149119,17 @@ class InetSockSetStateFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Skaddr =
+  using FieldMetadata_UpdateBw =
     ::protozero::proto_utils::FieldMetadata<
       8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      InetSockSetStateFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Skaddr kSkaddr() { return {}; }
-  void set_skaddr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Skaddr::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Sport =
-    ::protozero::proto_utils::FieldMetadata<
-      9,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      InetSockSetStateFtraceEvent>;
+      MdpCompareBwFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sport kSport() { return {}; }
-  void set_sport(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Sport::kFieldId;
+  static constexpr FieldMetadata_UpdateBw kUpdateBw{};
+  void set_update_bw(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_UpdateBw::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -123252,373 +149138,301 @@ class InetSockSetStateFtraceEvent : public ::protozero::Message {
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/sync.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SYNC_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SYNC_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class SyncWaitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MdpCmdPingpongDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  SyncWaitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SyncWaitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SyncWaitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_status() const { return at<2>().valid(); }
-  int32_t status() const { return at<2>().as_int32(); }
-  bool has_begin() const { return at<3>().valid(); }
-  uint32_t begin() const { return at<3>().as_uint32(); }
+  MdpCmdPingpongDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MdpCmdPingpongDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MdpCmdPingpongDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_ctl_num() const { return at<1>().valid(); }
+  uint32_t ctl_num() const { return at<1>().as_uint32(); }
+  bool has_intf_num() const { return at<2>().valid(); }
+  uint32_t intf_num() const { return at<2>().as_uint32(); }
+  bool has_pp_num() const { return at<3>().valid(); }
+  uint32_t pp_num() const { return at<3>().as_uint32(); }
+  bool has_koff_cnt() const { return at<4>().valid(); }
+  int32_t koff_cnt() const { return at<4>().as_int32(); }
 };
 
-class SyncWaitFtraceEvent : public ::protozero::Message {
+class MdpCmdPingpongDoneFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SyncWaitFtraceEvent_Decoder;
+  using Decoder = MdpCmdPingpongDoneFtraceEvent_Decoder;
   enum : int32_t {
-    kNameFieldNumber = 1,
-    kStatusFieldNumber = 2,
-    kBeginFieldNumber = 3,
+    kCtlNumFieldNumber = 1,
+    kIntfNumFieldNumber = 2,
+    kPpNumFieldNumber = 3,
+    kKoffCntFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SyncWaitFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MdpCmdPingpongDoneFtraceEvent"; }
 
 
-  using FieldMetadata_Name =
+  using FieldMetadata_CtlNum =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SyncWaitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpCmdPingpongDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_CtlNum kCtlNum{};
+  void set_ctl_num(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CtlNum::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Status =
+  using FieldMetadata_IntfNum =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SyncWaitFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpCmdPingpongDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Status kStatus() { return {}; }
-  void set_status(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId;
+  static constexpr FieldMetadata_IntfNum kIntfNum{};
+  void set_intf_num(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IntfNum::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Begin =
+  using FieldMetadata_PpNum =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SyncWaitFtraceEvent>;
+      MdpCmdPingpongDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Begin kBegin() { return {}; }
-  void set_begin(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Begin::kFieldId;
+  static constexpr FieldMetadata_PpNum kPpNum{};
+  void set_pp_num(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PpNum::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_KoffCnt =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MdpCmdPingpongDoneFtraceEvent>;
+
+  static constexpr FieldMetadata_KoffCnt kKoffCnt{};
+  void set_koff_cnt(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KoffCnt::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class SyncTimelineFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class TracingMarkWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  SyncTimelineFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SyncTimelineFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SyncTimelineFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_value() const { return at<2>().valid(); }
-  ::protozero::ConstChars value() const { return at<2>().as_string(); }
+  TracingMarkWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TracingMarkWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TracingMarkWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  int32_t pid() const { return at<1>().as_int32(); }
+  bool has_trace_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars trace_name() const { return at<2>().as_string(); }
+  bool has_trace_begin() const { return at<3>().valid(); }
+  uint32_t trace_begin() const { return at<3>().as_uint32(); }
 };
 
-class SyncTimelineFtraceEvent : public ::protozero::Message {
+class TracingMarkWriteFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SyncTimelineFtraceEvent_Decoder;
+  using Decoder = TracingMarkWriteFtraceEvent_Decoder;
   enum : int32_t {
-    kNameFieldNumber = 1,
-    kValueFieldNumber = 2,
+    kPidFieldNumber = 1,
+    kTraceNameFieldNumber = 2,
+    kTraceBeginFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SyncTimelineFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.TracingMarkWriteFtraceEvent"; }
 
 
-  using FieldMetadata_Name =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SyncTimelineFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Value =
+  using FieldMetadata_TraceName =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      SyncTimelineFtraceEvent>;
+      TracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
+  static constexpr FieldMetadata_TraceName kTraceName{};
+  void set_trace_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_TraceName::kFieldId, data, size);
   }
-  void set_value(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
+  void set_trace_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_TraceName::kFieldId, chars.data, chars.size);
   }
-  void set_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+  void set_trace_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_TraceName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_TraceBegin =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TracingMarkWriteFtraceEvent>;
+
+  static constexpr FieldMetadata_TraceBegin kTraceBegin{};
+  void set_trace_begin(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TraceBegin::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class SyncPtFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MdpSsppChangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/16> {
  public:
-  SyncPtFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SyncPtFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SyncPtFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_timeline() const { return at<1>().valid(); }
-  ::protozero::ConstChars timeline() const { return at<1>().as_string(); }
-  bool has_value() const { return at<2>().valid(); }
-  ::protozero::ConstChars value() const { return at<2>().as_string(); }
+  MdpSsppChangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MdpSsppChangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MdpSsppChangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_num() const { return at<1>().valid(); }
+  uint32_t num() const { return at<1>().as_uint32(); }
+  bool has_play_cnt() const { return at<2>().valid(); }
+  uint32_t play_cnt() const { return at<2>().as_uint32(); }
+  bool has_mixer() const { return at<3>().valid(); }
+  uint32_t mixer() const { return at<3>().as_uint32(); }
+  bool has_stage() const { return at<4>().valid(); }
+  uint32_t stage() const { return at<4>().as_uint32(); }
+  bool has_flags() const { return at<5>().valid(); }
+  uint32_t flags() const { return at<5>().as_uint32(); }
+  bool has_format() const { return at<6>().valid(); }
+  uint32_t format() const { return at<6>().as_uint32(); }
+  bool has_img_w() const { return at<7>().valid(); }
+  uint32_t img_w() const { return at<7>().as_uint32(); }
+  bool has_img_h() const { return at<8>().valid(); }
+  uint32_t img_h() const { return at<8>().as_uint32(); }
+  bool has_src_x() const { return at<9>().valid(); }
+  uint32_t src_x() const { return at<9>().as_uint32(); }
+  bool has_src_y() const { return at<10>().valid(); }
+  uint32_t src_y() const { return at<10>().as_uint32(); }
+  bool has_src_w() const { return at<11>().valid(); }
+  uint32_t src_w() const { return at<11>().as_uint32(); }
+  bool has_src_h() const { return at<12>().valid(); }
+  uint32_t src_h() const { return at<12>().as_uint32(); }
+  bool has_dst_x() const { return at<13>().valid(); }
+  uint32_t dst_x() const { return at<13>().as_uint32(); }
+  bool has_dst_y() const { return at<14>().valid(); }
+  uint32_t dst_y() const { return at<14>().as_uint32(); }
+  bool has_dst_w() const { return at<15>().valid(); }
+  uint32_t dst_w() const { return at<15>().as_uint32(); }
+  bool has_dst_h() const { return at<16>().valid(); }
+  uint32_t dst_h() const { return at<16>().as_uint32(); }
 };
 
-class SyncPtFtraceEvent : public ::protozero::Message {
+class MdpSsppChangeFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SyncPtFtraceEvent_Decoder;
+  using Decoder = MdpSsppChangeFtraceEvent_Decoder;
   enum : int32_t {
-    kTimelineFieldNumber = 1,
-    kValueFieldNumber = 2,
+    kNumFieldNumber = 1,
+    kPlayCntFieldNumber = 2,
+    kMixerFieldNumber = 3,
+    kStageFieldNumber = 4,
+    kFlagsFieldNumber = 5,
+    kFormatFieldNumber = 6,
+    kImgWFieldNumber = 7,
+    kImgHFieldNumber = 8,
+    kSrcXFieldNumber = 9,
+    kSrcYFieldNumber = 10,
+    kSrcWFieldNumber = 11,
+    kSrcHFieldNumber = 12,
+    kDstXFieldNumber = 13,
+    kDstYFieldNumber = 14,
+    kDstWFieldNumber = 15,
+    kDstHFieldNumber = 16,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SyncPtFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MdpSsppChangeFtraceEvent"; }
 
 
-  using FieldMetadata_Timeline =
+  using FieldMetadata_Num =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SyncPtFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppChangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timeline kTimeline() { return {}; }
-  void set_timeline(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Timeline::kFieldId, data, size);
-  }
-  void set_timeline(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Timeline::kFieldId, chars.data, chars.size);
-  }
-  void set_timeline(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Timeline::kFieldId;
+  static constexpr FieldMetadata_Num kNum{};
+  void set_num(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Num::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Value =
+  using FieldMetadata_PlayCnt =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SyncPtFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppChangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
-  }
-  void set_value(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
-  }
-  void set_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+  static constexpr FieldMetadata_PlayCnt kPlayCnt{};
+  void set_play_cnt(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PlayCnt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/synthetic.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SYNTHETIC_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SYNTHETIC_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class RssStatThrottledFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  RssStatThrottledFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit RssStatThrottledFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit RssStatThrottledFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_curr() const { return at<1>().valid(); }
-  uint32_t curr() const { return at<1>().as_uint32(); }
-  bool has_member() const { return at<2>().valid(); }
-  int32_t member() const { return at<2>().as_int32(); }
-  bool has_mm_id() const { return at<3>().valid(); }
-  uint32_t mm_id() const { return at<3>().as_uint32(); }
-  bool has_size() const { return at<4>().valid(); }
-  int64_t size() const { return at<4>().as_int64(); }
-};
-
-class RssStatThrottledFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = RssStatThrottledFtraceEvent_Decoder;
-  enum : int32_t {
-    kCurrFieldNumber = 1,
-    kMemberFieldNumber = 2,
-    kMmIdFieldNumber = 3,
-    kSizeFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.RssStatThrottledFtraceEvent"; }
-
 
-  using FieldMetadata_Curr =
+  using FieldMetadata_Mixer =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      RssStatThrottledFtraceEvent>;
+      MdpSsppChangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Curr kCurr() { return {}; }
-  void set_curr(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Curr::kFieldId;
+  static constexpr FieldMetadata_Mixer kMixer{};
+  void set_mixer(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mixer::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -123626,49 +149440,35 @@ class RssStatThrottledFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Member =
+  using FieldMetadata_Stage =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      RssStatThrottledFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppChangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Member kMember() { return {}; }
-  void set_member(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Member::kFieldId;
+  static constexpr FieldMetadata_Stage kStage{};
+  void set_stage(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Stage::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MmId =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      RssStatThrottledFtraceEvent>;
+      MdpSsppChangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MmId kMmId() { return {}; }
-  void set_mm_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MmId::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -123676,566 +149476,343 @@ class RssStatThrottledFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Size =
+  using FieldMetadata_Format =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      RssStatThrottledFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppChangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Size kSize() { return {}; }
-  void set_size(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
+  static constexpr FieldMetadata_Format kFormat{};
+  void set_format(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Format::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/systrace.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SYSTRACE_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SYSTRACE_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class ZeroFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  ZeroFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ZeroFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ZeroFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_flag() const { return at<1>().valid(); }
-  int32_t flag() const { return at<1>().as_int32(); }
-  bool has_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars name() const { return at<2>().as_string(); }
-  bool has_pid() const { return at<3>().valid(); }
-  int32_t pid() const { return at<3>().as_int32(); }
-  bool has_value() const { return at<4>().valid(); }
-  int64_t value() const { return at<4>().as_int64(); }
-};
-
-class ZeroFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = ZeroFtraceEvent_Decoder;
-  enum : int32_t {
-    kFlagFieldNumber = 1,
-    kNameFieldNumber = 2,
-    kPidFieldNumber = 3,
-    kValueFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ZeroFtraceEvent"; }
 
-
-  using FieldMetadata_Flag =
+  using FieldMetadata_ImgW =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ZeroFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppChangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flag kFlag() { return {}; }
-  void set_flag(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flag::kFieldId;
+  static constexpr FieldMetadata_ImgW kImgW{};
+  void set_img_w(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ImgW::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Name =
+  using FieldMetadata_ImgH =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ZeroFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppChangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_ImgH kImgH{};
+  void set_img_h(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ImgH::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_SrcX =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ZeroFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppChangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_SrcX kSrcX{};
+  void set_src_x(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SrcX::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Value =
+  using FieldMetadata_SrcY =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ZeroFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppChangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+  static constexpr FieldMetadata_SrcY kSrcY{};
+  void set_src_y(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SrcY::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/task.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_TASK_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_TASK_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
 
+  using FieldMetadata_SrcW =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppChangeFtraceEvent>;
 
-class TaskRenameFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TaskRenameFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TaskRenameFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TaskRenameFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pid() const { return at<1>().valid(); }
-  int32_t pid() const { return at<1>().as_int32(); }
-  bool has_oldcomm() const { return at<2>().valid(); }
-  ::protozero::ConstChars oldcomm() const { return at<2>().as_string(); }
-  bool has_newcomm() const { return at<3>().valid(); }
-  ::protozero::ConstChars newcomm() const { return at<3>().as_string(); }
-  bool has_oom_score_adj() const { return at<4>().valid(); }
-  int32_t oom_score_adj() const { return at<4>().as_int32(); }
-};
+  static constexpr FieldMetadata_SrcW kSrcW{};
+  void set_src_w(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SrcW::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-class TaskRenameFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = TaskRenameFtraceEvent_Decoder;
-  enum : int32_t {
-    kPidFieldNumber = 1,
-    kOldcommFieldNumber = 2,
-    kNewcommFieldNumber = 3,
-    kOomScoreAdjFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TaskRenameFtraceEvent"; }
+  using FieldMetadata_SrcH =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppChangeFtraceEvent>;
 
+  static constexpr FieldMetadata_SrcH kSrcH{};
+  void set_src_h(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SrcH::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_DstX =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      13,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TaskRenameFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppChangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_DstX kDstX{};
+  void set_dst_x(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DstX::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Oldcomm =
+  using FieldMetadata_DstY =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      14,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TaskRenameFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppChangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Oldcomm kOldcomm() { return {}; }
-  void set_oldcomm(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Oldcomm::kFieldId, data, size);
-  }
-  void set_oldcomm(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Oldcomm::kFieldId, chars.data, chars.size);
-  }
-  void set_oldcomm(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Oldcomm::kFieldId;
+  static constexpr FieldMetadata_DstY kDstY{};
+  void set_dst_y(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DstY::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Newcomm =
+  using FieldMetadata_DstW =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      15,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TaskRenameFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppChangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Newcomm kNewcomm() { return {}; }
-  void set_newcomm(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Newcomm::kFieldId, data, size);
-  }
-  void set_newcomm(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Newcomm::kFieldId, chars.data, chars.size);
-  }
-  void set_newcomm(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Newcomm::kFieldId;
+  static constexpr FieldMetadata_DstW kDstW{};
+  void set_dst_w(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DstW::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_OomScoreAdj =
+  using FieldMetadata_DstH =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      16,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TaskRenameFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpSsppChangeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OomScoreAdj kOomScoreAdj() { return {}; }
-  void set_oom_score_adj(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OomScoreAdj::kFieldId;
+  static constexpr FieldMetadata_DstH kDstH{};
+  void set_dst_h(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DstH::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class TaskNewtaskFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MdpPerfSetOtFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  TaskNewtaskFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TaskNewtaskFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TaskNewtaskFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pid() const { return at<1>().valid(); }
-  int32_t pid() const { return at<1>().as_int32(); }
-  bool has_comm() const { return at<2>().valid(); }
-  ::protozero::ConstChars comm() const { return at<2>().as_string(); }
-  bool has_clone_flags() const { return at<3>().valid(); }
-  uint64_t clone_flags() const { return at<3>().as_uint64(); }
-  bool has_oom_score_adj() const { return at<4>().valid(); }
-  int32_t oom_score_adj() const { return at<4>().as_int32(); }
+  MdpPerfSetOtFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MdpPerfSetOtFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MdpPerfSetOtFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pnum() const { return at<1>().valid(); }
+  uint32_t pnum() const { return at<1>().as_uint32(); }
+  bool has_xin_id() const { return at<2>().valid(); }
+  uint32_t xin_id() const { return at<2>().as_uint32(); }
+  bool has_rd_lim() const { return at<3>().valid(); }
+  uint32_t rd_lim() const { return at<3>().as_uint32(); }
+  bool has_is_vbif_rt() const { return at<4>().valid(); }
+  uint32_t is_vbif_rt() const { return at<4>().as_uint32(); }
 };
 
-class TaskNewtaskFtraceEvent : public ::protozero::Message {
+class MdpPerfSetOtFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = TaskNewtaskFtraceEvent_Decoder;
+  using Decoder = MdpPerfSetOtFtraceEvent_Decoder;
   enum : int32_t {
-    kPidFieldNumber = 1,
-    kCommFieldNumber = 2,
-    kCloneFlagsFieldNumber = 3,
-    kOomScoreAdjFieldNumber = 4,
+    kPnumFieldNumber = 1,
+    kXinIdFieldNumber = 2,
+    kRdLimFieldNumber = 3,
+    kIsVbifRtFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TaskNewtaskFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MdpPerfSetOtFtraceEvent"; }
 
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_Pnum =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TaskNewtaskFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfSetOtFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_Pnum kPnum{};
+  void set_pnum(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pnum::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Comm =
+  using FieldMetadata_XinId =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TaskNewtaskFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfSetOtFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Comm kComm() { return {}; }
-  void set_comm(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
-  }
-  void set_comm(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
-  }
-  void set_comm(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
+  static constexpr FieldMetadata_XinId kXinId{};
+  void set_xin_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_XinId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CloneFlags =
+  using FieldMetadata_RdLim =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TaskNewtaskFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfSetOtFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CloneFlags kCloneFlags() { return {}; }
-  void set_clone_flags(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CloneFlags::kFieldId;
+  static constexpr FieldMetadata_RdLim kRdLim{};
+  void set_rd_lim(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RdLim::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_OomScoreAdj =
+  using FieldMetadata_IsVbifRt =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TaskNewtaskFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MdpPerfSetOtFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OomScoreAdj kOomScoreAdj() { return {}; }
-  void set_oom_score_adj(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OomScoreAdj::kFieldId;
+  static constexpr FieldMetadata_IsVbifRt kIsVbifRt{};
+  void set_is_vbif_rt(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsVbifRt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/tcp.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_TCP_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_TCP_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class TcpRetransmitSkbFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MdpCommitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  TcpRetransmitSkbFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TcpRetransmitSkbFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TcpRetransmitSkbFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_daddr() const { return at<1>().valid(); }
-  uint32_t daddr() const { return at<1>().as_uint32(); }
-  bool has_dport() const { return at<2>().valid(); }
-  uint32_t dport() const { return at<2>().as_uint32(); }
-  bool has_saddr() const { return at<3>().valid(); }
-  uint32_t saddr() const { return at<3>().as_uint32(); }
-  bool has_skaddr() const { return at<4>().valid(); }
-  uint64_t skaddr() const { return at<4>().as_uint64(); }
-  bool has_skbaddr() const { return at<5>().valid(); }
-  uint64_t skbaddr() const { return at<5>().as_uint64(); }
-  bool has_sport() const { return at<6>().valid(); }
-  uint32_t sport() const { return at<6>().as_uint32(); }
-  bool has_state() const { return at<7>().valid(); }
-  int32_t state() const { return at<7>().as_int32(); }
+  MdpCommitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MdpCommitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MdpCommitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_num() const { return at<1>().valid(); }
+  uint32_t num() const { return at<1>().as_uint32(); }
+  bool has_play_cnt() const { return at<2>().valid(); }
+  uint32_t play_cnt() const { return at<2>().as_uint32(); }
+  bool has_clk_rate() const { return at<3>().valid(); }
+  uint32_t clk_rate() const { return at<3>().as_uint32(); }
+  bool has_bandwidth() const { return at<4>().valid(); }
+  uint64_t bandwidth() const { return at<4>().as_uint64(); }
 };
 
-class TcpRetransmitSkbFtraceEvent : public ::protozero::Message {
+class MdpCommitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = TcpRetransmitSkbFtraceEvent_Decoder;
+  using Decoder = MdpCommitFtraceEvent_Decoder;
   enum : int32_t {
-    kDaddrFieldNumber = 1,
-    kDportFieldNumber = 2,
-    kSaddrFieldNumber = 3,
-    kSkaddrFieldNumber = 4,
-    kSkbaddrFieldNumber = 5,
-    kSportFieldNumber = 6,
-    kStateFieldNumber = 7,
+    kNumFieldNumber = 1,
+    kPlayCntFieldNumber = 2,
+    kClkRateFieldNumber = 3,
+    kBandwidthFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TcpRetransmitSkbFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MdpCommitFtraceEvent"; }
 
 
-  using FieldMetadata_Daddr =
+  using FieldMetadata_Num =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      TcpRetransmitSkbFtraceEvent>;
+      MdpCommitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Daddr kDaddr() { return {}; }
-  void set_daddr(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Daddr::kFieldId;
+  static constexpr FieldMetadata_Num kNum{};
+  void set_num(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Num::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -124243,24 +149820,17 @@ class TcpRetransmitSkbFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Dport =
+  using FieldMetadata_PlayCnt =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      TcpRetransmitSkbFtraceEvent>;
+      MdpCommitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dport kDport() { return {}; }
-  void set_dport(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dport::kFieldId;
+  static constexpr FieldMetadata_PlayCnt kPlayCnt{};
+  void set_play_cnt(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PlayCnt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -124268,24 +149838,17 @@ class TcpRetransmitSkbFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Saddr =
+  using FieldMetadata_ClkRate =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      TcpRetransmitSkbFtraceEvent>;
+      MdpCommitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Saddr kSaddr() { return {}; }
-  void set_saddr(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Saddr::kFieldId;
+  static constexpr FieldMetadata_ClkRate kClkRate{};
+  void set_clk_rate(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ClkRate::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -124293,74 +149856,57 @@ class TcpRetransmitSkbFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Skaddr =
+  using FieldMetadata_Bandwidth =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TcpRetransmitSkbFtraceEvent>;
+      MdpCommitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Skaddr kSkaddr() { return {}; }
-  void set_skaddr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Skaddr::kFieldId;
+  static constexpr FieldMetadata_Bandwidth kBandwidth{};
+  void set_bandwidth(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Bandwidth::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Skbaddr =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TcpRetransmitSkbFtraceEvent>;
+class MdpCmdKickoffFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  MdpCmdKickoffFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MdpCmdKickoffFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MdpCmdKickoffFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_ctl_num() const { return at<1>().valid(); }
+  uint32_t ctl_num() const { return at<1>().as_uint32(); }
+  bool has_kickoff_cnt() const { return at<2>().valid(); }
+  int32_t kickoff_cnt() const { return at<2>().as_int32(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Skbaddr kSkbaddr() { return {}; }
-  void set_skbaddr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Skbaddr::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
+class MdpCmdKickoffFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = MdpCmdKickoffFtraceEvent_Decoder;
+  enum : int32_t {
+    kCtlNumFieldNumber = 1,
+    kKickoffCntFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.MdpCmdKickoffFtraceEvent"; }
 
-  using FieldMetadata_Sport =
+
+  using FieldMetadata_CtlNum =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      TcpRetransmitSkbFtraceEvent>;
+      MdpCmdKickoffFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sport kSport() { return {}; }
-  void set_sport(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Sport::kFieldId;
+  static constexpr FieldMetadata_CtlNum kCtlNum{};
+  void set_ctl_num(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CtlNum::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -124368,24 +149914,17 @@ class TcpRetransmitSkbFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_State =
+  using FieldMetadata_KickoffCnt =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      TcpRetransmitSkbFtraceEvent>;
+      MdpCmdKickoffFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_State kState() { return {}; }
-  void set_state(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
+  static constexpr FieldMetadata_KickoffCnt kKickoffCnt{};
+  void set_kickoff_cnt(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KickoffCnt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -124398,11 +149937,11 @@ class TcpRetransmitSkbFtraceEvent : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/thermal.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/mm_event.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_THERMAL_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_THERMAL_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_MM_EVENT_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_MM_EVENT_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -124413,219 +149952,107 @@ class TcpRetransmitSkbFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class CdevUpdateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  CdevUpdateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit CdevUpdateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit CdevUpdateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_target() const { return at<1>().valid(); }
-  uint64_t target() const { return at<1>().as_uint64(); }
-  bool has_type() const { return at<2>().valid(); }
-  ::protozero::ConstChars type() const { return at<2>().as_string(); }
-};
-
-class CdevUpdateFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = CdevUpdateFtraceEvent_Decoder;
-  enum : int32_t {
-    kTargetFieldNumber = 1,
-    kTypeFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.CdevUpdateFtraceEvent"; }
-
-
-  using FieldMetadata_Target =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      CdevUpdateFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Target kTarget() { return {}; }
-  void set_target(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Target::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Type =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      CdevUpdateFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Type::kFieldId, data, size);
-  }
-  void set_type(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Type::kFieldId, chars.data, chars.size);
-  }
-  void set_type(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-};
-
-class ThermalTemperatureFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmEventRecordFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  ThermalTemperatureFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ThermalTemperatureFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ThermalTemperatureFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_id() const { return at<1>().valid(); }
-  int32_t id() const { return at<1>().as_int32(); }
-  bool has_temp() const { return at<2>().valid(); }
-  int32_t temp() const { return at<2>().as_int32(); }
-  bool has_temp_prev() const { return at<3>().valid(); }
-  int32_t temp_prev() const { return at<3>().as_int32(); }
-  bool has_thermal_zone() const { return at<4>().valid(); }
-  ::protozero::ConstChars thermal_zone() const { return at<4>().as_string(); }
+  MmEventRecordFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MmEventRecordFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MmEventRecordFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_avg_lat() const { return at<1>().valid(); }
+  uint32_t avg_lat() const { return at<1>().as_uint32(); }
+  bool has_count() const { return at<2>().valid(); }
+  uint32_t count() const { return at<2>().as_uint32(); }
+  bool has_max_lat() const { return at<3>().valid(); }
+  uint32_t max_lat() const { return at<3>().as_uint32(); }
+  bool has_type() const { return at<4>().valid(); }
+  uint32_t type() const { return at<4>().as_uint32(); }
 };
 
-class ThermalTemperatureFtraceEvent : public ::protozero::Message {
+class MmEventRecordFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = ThermalTemperatureFtraceEvent_Decoder;
+  using Decoder = MmEventRecordFtraceEvent_Decoder;
   enum : int32_t {
-    kIdFieldNumber = 1,
-    kTempFieldNumber = 2,
-    kTempPrevFieldNumber = 3,
-    kThermalZoneFieldNumber = 4,
+    kAvgLatFieldNumber = 1,
+    kCountFieldNumber = 2,
+    kMaxLatFieldNumber = 3,
+    kTypeFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ThermalTemperatureFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MmEventRecordFtraceEvent"; }
 
 
-  using FieldMetadata_Id =
+  using FieldMetadata_AvgLat =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ThermalTemperatureFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MmEventRecordFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
-  void set_id(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+  static constexpr FieldMetadata_AvgLat kAvgLat{};
+  void set_avg_lat(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AvgLat::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Temp =
+  using FieldMetadata_Count =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ThermalTemperatureFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MmEventRecordFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Temp kTemp() { return {}; }
-  void set_temp(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Temp::kFieldId;
+  static constexpr FieldMetadata_Count kCount{};
+  void set_count(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TempPrev =
+  using FieldMetadata_MaxLat =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ThermalTemperatureFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MmEventRecordFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TempPrev kTempPrev() { return {}; }
-  void set_temp_prev(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TempPrev::kFieldId;
+  static constexpr FieldMetadata_MaxLat kMaxLat{};
+  void set_max_lat(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MaxLat::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ThermalZone =
+  using FieldMetadata_Type =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ThermalTemperatureFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MmEventRecordFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThermalZone kThermalZone() { return {}; }
-  void set_thermal_zone(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ThermalZone::kFieldId, data, size);
-  }
-  void set_thermal_zone(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ThermalZone::kFieldId, chars.data, chars.size);
-  }
-  void set_thermal_zone(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ThermalZone::kFieldId;
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
@@ -124634,11 +150061,11 @@ class ThermalTemperatureFtraceEvent : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/trusty.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/net.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_TRUSTY_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_TRUSTY_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_NET_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_NET_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -124649,178 +150076,149 @@ class ThermalTemperatureFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class TrustyEnqueueNopFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class NapiGroReceiveExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  TrustyEnqueueNopFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrustyEnqueueNopFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrustyEnqueueNopFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_arg1() const { return at<1>().valid(); }
-  uint32_t arg1() const { return at<1>().as_uint32(); }
-  bool has_arg2() const { return at<2>().valid(); }
-  uint32_t arg2() const { return at<2>().as_uint32(); }
-  bool has_arg3() const { return at<3>().valid(); }
-  uint32_t arg3() const { return at<3>().as_uint32(); }
+  NapiGroReceiveExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit NapiGroReceiveExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit NapiGroReceiveExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_ret() const { return at<1>().valid(); }
+  int32_t ret() const { return at<1>().as_int32(); }
 };
 
-class TrustyEnqueueNopFtraceEvent : public ::protozero::Message {
+class NapiGroReceiveExitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = TrustyEnqueueNopFtraceEvent_Decoder;
+  using Decoder = NapiGroReceiveExitFtraceEvent_Decoder;
   enum : int32_t {
-    kArg1FieldNumber = 1,
-    kArg2FieldNumber = 2,
-    kArg3FieldNumber = 3,
+    kRetFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrustyEnqueueNopFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.NapiGroReceiveExitFtraceEvent"; }
 
 
-  using FieldMetadata_Arg1 =
+  using FieldMetadata_Ret =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TrustyEnqueueNopFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Arg1 kArg1() { return {}; }
-  void set_arg1(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Arg1::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Arg2 =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TrustyEnqueueNopFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Arg2 kArg2() { return {}; }
-  void set_arg2(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Arg2::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Arg3 =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TrustyEnqueueNopFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      NapiGroReceiveExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Arg3 kArg3() { return {}; }
-  void set_arg3(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Arg3::kFieldId;
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class TrustyIpcRxFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class NapiGroReceiveEntryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/19> {
  public:
-  TrustyIpcRxFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrustyIpcRxFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrustyIpcRxFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_buf_id() const { return at<1>().valid(); }
-  uint64_t buf_id() const { return at<1>().as_uint64(); }
-  bool has_chan() const { return at<2>().valid(); }
-  uint32_t chan() const { return at<2>().as_uint32(); }
-  bool has_srv_name() const { return at<3>().valid(); }
-  ::protozero::ConstChars srv_name() const { return at<3>().as_string(); }
+  NapiGroReceiveEntryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit NapiGroReceiveEntryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit NapiGroReceiveEntryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_data_len() const { return at<1>().valid(); }
+  uint32_t data_len() const { return at<1>().as_uint32(); }
+  bool has_gso_size() const { return at<2>().valid(); }
+  uint32_t gso_size() const { return at<2>().as_uint32(); }
+  bool has_gso_type() const { return at<3>().valid(); }
+  uint32_t gso_type() const { return at<3>().as_uint32(); }
+  bool has_hash() const { return at<4>().valid(); }
+  uint32_t hash() const { return at<4>().as_uint32(); }
+  bool has_ip_summed() const { return at<5>().valid(); }
+  uint32_t ip_summed() const { return at<5>().as_uint32(); }
+  bool has_l4_hash() const { return at<6>().valid(); }
+  uint32_t l4_hash() const { return at<6>().as_uint32(); }
+  bool has_len() const { return at<7>().valid(); }
+  uint32_t len() const { return at<7>().as_uint32(); }
+  bool has_mac_header() const { return at<8>().valid(); }
+  int32_t mac_header() const { return at<8>().as_int32(); }
+  bool has_mac_header_valid() const { return at<9>().valid(); }
+  uint32_t mac_header_valid() const { return at<9>().as_uint32(); }
+  bool has_name() const { return at<10>().valid(); }
+  ::protozero::ConstChars name() const { return at<10>().as_string(); }
+  bool has_napi_id() const { return at<11>().valid(); }
+  uint32_t napi_id() const { return at<11>().as_uint32(); }
+  bool has_nr_frags() const { return at<12>().valid(); }
+  uint32_t nr_frags() const { return at<12>().as_uint32(); }
+  bool has_protocol() const { return at<13>().valid(); }
+  uint32_t protocol() const { return at<13>().as_uint32(); }
+  bool has_queue_mapping() const { return at<14>().valid(); }
+  uint32_t queue_mapping() const { return at<14>().as_uint32(); }
+  bool has_skbaddr() const { return at<15>().valid(); }
+  uint64_t skbaddr() const { return at<15>().as_uint64(); }
+  bool has_truesize() const { return at<16>().valid(); }
+  uint32_t truesize() const { return at<16>().as_uint32(); }
+  bool has_vlan_proto() const { return at<17>().valid(); }
+  uint32_t vlan_proto() const { return at<17>().as_uint32(); }
+  bool has_vlan_tagged() const { return at<18>().valid(); }
+  uint32_t vlan_tagged() const { return at<18>().as_uint32(); }
+  bool has_vlan_tci() const { return at<19>().valid(); }
+  uint32_t vlan_tci() const { return at<19>().as_uint32(); }
 };
 
-class TrustyIpcRxFtraceEvent : public ::protozero::Message {
+class NapiGroReceiveEntryFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = TrustyIpcRxFtraceEvent_Decoder;
+  using Decoder = NapiGroReceiveEntryFtraceEvent_Decoder;
   enum : int32_t {
-    kBufIdFieldNumber = 1,
-    kChanFieldNumber = 2,
-    kSrvNameFieldNumber = 3,
+    kDataLenFieldNumber = 1,
+    kGsoSizeFieldNumber = 2,
+    kGsoTypeFieldNumber = 3,
+    kHashFieldNumber = 4,
+    kIpSummedFieldNumber = 5,
+    kL4HashFieldNumber = 6,
+    kLenFieldNumber = 7,
+    kMacHeaderFieldNumber = 8,
+    kMacHeaderValidFieldNumber = 9,
+    kNameFieldNumber = 10,
+    kNapiIdFieldNumber = 11,
+    kNrFragsFieldNumber = 12,
+    kProtocolFieldNumber = 13,
+    kQueueMappingFieldNumber = 14,
+    kSkbaddrFieldNumber = 15,
+    kTruesizeFieldNumber = 16,
+    kVlanProtoFieldNumber = 17,
+    kVlanTaggedFieldNumber = 18,
+    kVlanTciFieldNumber = 19,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcRxFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.NapiGroReceiveEntryFtraceEvent"; }
 
 
-  using FieldMetadata_BufId =
+  using FieldMetadata_DataLen =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TrustyIpcRxFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      NapiGroReceiveEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BufId kBufId() { return {}; }
-  void set_buf_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BufId::kFieldId;
+  static constexpr FieldMetadata_DataLen kDataLen{};
+  void set_data_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DataLen::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Chan =
+  using FieldMetadata_GsoSize =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      TrustyIpcRxFtraceEvent>;
+      NapiGroReceiveEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Chan kChan() { return {}; }
-  void set_chan(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId;
+  static constexpr FieldMetadata_GsoSize kGsoSize{};
+  void set_gso_size(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GsoSize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -124828,111 +150226,53 @@ class TrustyIpcRxFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SrvName =
+  using FieldMetadata_GsoType =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TrustyIpcRxFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      NapiGroReceiveEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SrvName kSrvName() { return {}; }
-  void set_srv_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_SrvName::kFieldId, data, size);
-  }
-  void set_srv_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_SrvName::kFieldId, chars.data, chars.size);
-  }
-  void set_srv_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_SrvName::kFieldId;
+  static constexpr FieldMetadata_GsoType kGsoType{};
+  void set_gso_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GsoType::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class TrustyIpcReadEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TrustyIpcReadEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrustyIpcReadEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrustyIpcReadEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_buf_id() const { return at<1>().valid(); }
-  uint64_t buf_id() const { return at<1>().as_uint64(); }
-  bool has_chan() const { return at<2>().valid(); }
-  uint32_t chan() const { return at<2>().as_uint32(); }
-  bool has_len_or_err() const { return at<3>().valid(); }
-  int32_t len_or_err() const { return at<3>().as_int32(); }
-  bool has_shm_cnt() const { return at<4>().valid(); }
-  uint64_t shm_cnt() const { return at<4>().as_uint64(); }
-  bool has_srv_name() const { return at<5>().valid(); }
-  ::protozero::ConstChars srv_name() const { return at<5>().as_string(); }
-};
-
-class TrustyIpcReadEndFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = TrustyIpcReadEndFtraceEvent_Decoder;
-  enum : int32_t {
-    kBufIdFieldNumber = 1,
-    kChanFieldNumber = 2,
-    kLenOrErrFieldNumber = 3,
-    kShmCntFieldNumber = 4,
-    kSrvNameFieldNumber = 5,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcReadEndFtraceEvent"; }
-
 
-  using FieldMetadata_BufId =
+  using FieldMetadata_Hash =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TrustyIpcReadEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      NapiGroReceiveEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BufId kBufId() { return {}; }
-  void set_buf_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BufId::kFieldId;
+  static constexpr FieldMetadata_Hash kHash{};
+  void set_hash(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Hash::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Chan =
+  using FieldMetadata_IpSummed =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      TrustyIpcReadEndFtraceEvent>;
+      NapiGroReceiveEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Chan kChan() { return {}; }
-  void set_chan(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId;
+  static constexpr FieldMetadata_IpSummed kIpSummed{};
+  void set_ip_summed(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IpSummed::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -124940,127 +150280,71 @@ class TrustyIpcReadEndFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_LenOrErr =
+  using FieldMetadata_L4Hash =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TrustyIpcReadEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      NapiGroReceiveEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LenOrErr kLenOrErr() { return {}; }
-  void set_len_or_err(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LenOrErr::kFieldId;
+  static constexpr FieldMetadata_L4Hash kL4Hash{};
+  void set_l4_hash(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_L4Hash::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ShmCnt =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TrustyIpcReadEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      NapiGroReceiveEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ShmCnt kShmCnt() { return {}; }
-  void set_shm_cnt(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ShmCnt::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SrvName =
+  using FieldMetadata_MacHeader =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TrustyIpcReadEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      NapiGroReceiveEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SrvName kSrvName() { return {}; }
-  void set_srv_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_SrvName::kFieldId, data, size);
-  }
-  void set_srv_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_SrvName::kFieldId, chars.data, chars.size);
-  }
-  void set_srv_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_SrvName::kFieldId;
+  static constexpr FieldMetadata_MacHeader kMacHeader{};
+  void set_mac_header(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MacHeader::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-class TrustyIpcReadFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TrustyIpcReadFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrustyIpcReadFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrustyIpcReadFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_chan() const { return at<1>().valid(); }
-  uint32_t chan() const { return at<1>().as_uint32(); }
-  bool has_srv_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars srv_name() const { return at<2>().as_string(); }
-};
-
-class TrustyIpcReadFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = TrustyIpcReadFtraceEvent_Decoder;
-  enum : int32_t {
-    kChanFieldNumber = 1,
-    kSrvNameFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcReadFtraceEvent"; }
 
-
-  using FieldMetadata_Chan =
+  using FieldMetadata_MacHeaderValid =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      TrustyIpcReadFtraceEvent>;
+      NapiGroReceiveEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Chan kChan() { return {}; }
-  void set_chan(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId;
+  static constexpr FieldMetadata_MacHeaderValid kMacHeaderValid{};
+  void set_mac_header_valid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MacHeaderValid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -125068,80 +150352,41 @@ class TrustyIpcReadFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SrvName =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      TrustyIpcReadFtraceEvent>;
+      NapiGroReceiveEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SrvName kSrvName() { return {}; }
-  void set_srv_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_SrvName::kFieldId, data, size);
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
-  void set_srv_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_SrvName::kFieldId, chars.data, chars.size);
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
   }
-  void set_srv_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_SrvName::kFieldId;
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
-};
-
-class TrustyIpcPollFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TrustyIpcPollFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrustyIpcPollFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrustyIpcPollFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_chan() const { return at<1>().valid(); }
-  uint32_t chan() const { return at<1>().as_uint32(); }
-  bool has_poll_mask() const { return at<2>().valid(); }
-  uint32_t poll_mask() const { return at<2>().as_uint32(); }
-  bool has_srv_name() const { return at<3>().valid(); }
-  ::protozero::ConstChars srv_name() const { return at<3>().as_string(); }
-};
-
-class TrustyIpcPollFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = TrustyIpcPollFtraceEvent_Decoder;
-  enum : int32_t {
-    kChanFieldNumber = 1,
-    kPollMaskFieldNumber = 2,
-    kSrvNameFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcPollFtraceEvent"; }
 
-
-  using FieldMetadata_Chan =
+  using FieldMetadata_NapiId =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      TrustyIpcPollFtraceEvent>;
+      NapiGroReceiveEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Chan kChan() { return {}; }
-  void set_chan(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId;
+  static constexpr FieldMetadata_NapiId kNapiId{};
+  void set_napi_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NapiId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -125149,24 +150394,17 @@ class TrustyIpcPollFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PollMask =
+  using FieldMetadata_NrFrags =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      12,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      TrustyIpcPollFtraceEvent>;
+      NapiGroReceiveEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PollMask kPollMask() { return {}; }
-  void set_poll_mask(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PollMask::kFieldId;
+  static constexpr FieldMetadata_NrFrags kNrFrags{};
+  void set_nr_frags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NrFrags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -125174,114 +150412,17 @@ class TrustyIpcPollFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SrvName =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TrustyIpcPollFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SrvName kSrvName() { return {}; }
-  void set_srv_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_SrvName::kFieldId, data, size);
-  }
-  void set_srv_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_SrvName::kFieldId, chars.data, chars.size);
-  }
-  void set_srv_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_SrvName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-};
-
-class TrustyIpcWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TrustyIpcWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrustyIpcWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrustyIpcWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_buf_id() const { return at<1>().valid(); }
-  uint64_t buf_id() const { return at<1>().as_uint64(); }
-  bool has_chan() const { return at<2>().valid(); }
-  uint32_t chan() const { return at<2>().as_uint32(); }
-  bool has_kind_shm() const { return at<3>().valid(); }
-  int32_t kind_shm() const { return at<3>().as_int32(); }
-  bool has_len_or_err() const { return at<4>().valid(); }
-  int32_t len_or_err() const { return at<4>().as_int32(); }
-  bool has_shm_cnt() const { return at<5>().valid(); }
-  uint64_t shm_cnt() const { return at<5>().as_uint64(); }
-  bool has_srv_name() const { return at<6>().valid(); }
-  ::protozero::ConstChars srv_name() const { return at<6>().as_string(); }
-};
-
-class TrustyIpcWriteFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = TrustyIpcWriteFtraceEvent_Decoder;
-  enum : int32_t {
-    kBufIdFieldNumber = 1,
-    kChanFieldNumber = 2,
-    kKindShmFieldNumber = 3,
-    kLenOrErrFieldNumber = 4,
-    kShmCntFieldNumber = 5,
-    kSrvNameFieldNumber = 6,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcWriteFtraceEvent"; }
-
-
-  using FieldMetadata_BufId =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TrustyIpcWriteFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BufId kBufId() { return {}; }
-  void set_buf_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BufId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Chan =
+  using FieldMetadata_Protocol =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      13,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      TrustyIpcWriteFtraceEvent>;
+      NapiGroReceiveEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Chan kChan() { return {}; }
-  void set_chan(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId;
+  static constexpr FieldMetadata_Protocol kProtocol{};
+  void set_protocol(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Protocol::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -125289,74 +150430,35 @@ class TrustyIpcWriteFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_KindShm =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TrustyIpcWriteFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KindShm kKindShm() { return {}; }
-  void set_kind_shm(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_KindShm::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_LenOrErr =
+  using FieldMetadata_QueueMapping =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      14,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TrustyIpcWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      NapiGroReceiveEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LenOrErr kLenOrErr() { return {}; }
-  void set_len_or_err(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LenOrErr::kFieldId;
+  static constexpr FieldMetadata_QueueMapping kQueueMapping{};
+  void set_queue_mapping(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_QueueMapping::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ShmCnt =
+  using FieldMetadata_Skbaddr =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      15,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TrustyIpcWriteFtraceEvent>;
+      NapiGroReceiveEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ShmCnt kShmCnt() { return {}; }
-  void set_shm_cnt(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ShmCnt::kFieldId;
+  static constexpr FieldMetadata_Skbaddr kSkbaddr{};
+  void set_skbaddr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Skbaddr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -125364,80 +150466,35 @@ class TrustyIpcWriteFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SrvName =
+  using FieldMetadata_Truesize =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      16,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TrustyIpcWriteFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      NapiGroReceiveEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SrvName kSrvName() { return {}; }
-  void set_srv_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_SrvName::kFieldId, data, size);
-  }
-  void set_srv_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_SrvName::kFieldId, chars.data, chars.size);
-  }
-  void set_srv_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_SrvName::kFieldId;
+  static constexpr FieldMetadata_Truesize kTruesize{};
+  void set_truesize(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Truesize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
-  }
-};
-
-class TrustyIpcConnectEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TrustyIpcConnectEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrustyIpcConnectEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrustyIpcConnectEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_chan() const { return at<1>().valid(); }
-  uint32_t chan() const { return at<1>().as_uint32(); }
-  bool has_err() const { return at<2>().valid(); }
-  int32_t err() const { return at<2>().as_int32(); }
-  bool has_state() const { return at<3>().valid(); }
-  int32_t state() const { return at<3>().as_int32(); }
-};
-
-class TrustyIpcConnectEndFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = TrustyIpcConnectEndFtraceEvent_Decoder;
-  enum : int32_t {
-    kChanFieldNumber = 1,
-    kErrFieldNumber = 2,
-    kStateFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcConnectEndFtraceEvent"; }
-
+  }
 
-  using FieldMetadata_Chan =
+  using FieldMetadata_VlanProto =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      17,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      TrustyIpcConnectEndFtraceEvent>;
+      NapiGroReceiveEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Chan kChan() { return {}; }
-  void set_chan(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId;
+  static constexpr FieldMetadata_VlanProto kVlanProto{};
+  void set_vlan_proto(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VlanProto::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -125445,99 +150502,81 @@ class TrustyIpcConnectEndFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Err =
+  using FieldMetadata_VlanTagged =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      18,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TrustyIpcConnectEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      NapiGroReceiveEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Err kErr() { return {}; }
-  void set_err(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Err::kFieldId;
+  static constexpr FieldMetadata_VlanTagged kVlanTagged{};
+  void set_vlan_tagged(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VlanTagged::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_State =
+  using FieldMetadata_VlanTci =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      19,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TrustyIpcConnectEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      NapiGroReceiveEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_State kState() { return {}; }
-  void set_state(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
+  static constexpr FieldMetadata_VlanTci kVlanTci{};
+  void set_vlan_tci(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VlanTci::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class TrustyIpcConnectFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class NetDevXmitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  TrustyIpcConnectFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrustyIpcConnectFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrustyIpcConnectFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_chan() const { return at<1>().valid(); }
-  uint32_t chan() const { return at<1>().as_uint32(); }
-  bool has_port() const { return at<2>().valid(); }
-  ::protozero::ConstChars port() const { return at<2>().as_string(); }
-  bool has_state() const { return at<3>().valid(); }
-  int32_t state() const { return at<3>().as_int32(); }
+  NetDevXmitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit NetDevXmitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit NetDevXmitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_len() const { return at<1>().valid(); }
+  uint32_t len() const { return at<1>().as_uint32(); }
+  bool has_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars name() const { return at<2>().as_string(); }
+  bool has_rc() const { return at<3>().valid(); }
+  int32_t rc() const { return at<3>().as_int32(); }
+  bool has_skbaddr() const { return at<4>().valid(); }
+  uint64_t skbaddr() const { return at<4>().as_uint64(); }
 };
 
-class TrustyIpcConnectFtraceEvent : public ::protozero::Message {
+class NetDevXmitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = TrustyIpcConnectFtraceEvent_Decoder;
+  using Decoder = NetDevXmitFtraceEvent_Decoder;
   enum : int32_t {
-    kChanFieldNumber = 1,
-    kPortFieldNumber = 2,
-    kStateFieldNumber = 3,
+    kLenFieldNumber = 1,
+    kNameFieldNumber = 2,
+    kRcFieldNumber = 3,
+    kSkbaddrFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcConnectFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.NetDevXmitFtraceEvent"; }
 
 
-  using FieldMetadata_Chan =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      TrustyIpcConnectFtraceEvent>;
+      NetDevXmitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Chan kChan() { return {}; }
-  void set_chan(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -125545,30 +150584,23 @@ class TrustyIpcConnectFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Port =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      TrustyIpcConnectFtraceEvent>;
+      NetDevXmitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Port kPort() { return {}; }
-  void set_port(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Port::kFieldId, data, size);
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
-  void set_port(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Port::kFieldId, chars.data, chars.size);
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
   }
-  void set_port(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Port::kFieldId;
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -125576,74 +150608,78 @@ class TrustyIpcConnectFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_State =
+  using FieldMetadata_Rc =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      TrustyIpcConnectFtraceEvent>;
+      NetDevXmitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_State kState() { return {}; }
-  void set_state(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
+  static constexpr FieldMetadata_Rc kRc{};
+  void set_rc(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Rc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_Skbaddr =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      NetDevXmitFtraceEvent>;
+
+  static constexpr FieldMetadata_Skbaddr kSkbaddr{};
+  void set_skbaddr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Skbaddr::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class TrustyIpcHandleEventFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class NetifReceiveSkbFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  TrustyIpcHandleEventFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrustyIpcHandleEventFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrustyIpcHandleEventFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_chan() const { return at<1>().valid(); }
-  uint32_t chan() const { return at<1>().as_uint32(); }
-  bool has_event_id() const { return at<2>().valid(); }
-  uint32_t event_id() const { return at<2>().as_uint32(); }
-  bool has_srv_name() const { return at<3>().valid(); }
-  ::protozero::ConstChars srv_name() const { return at<3>().as_string(); }
+  NetifReceiveSkbFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit NetifReceiveSkbFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit NetifReceiveSkbFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_len() const { return at<1>().valid(); }
+  uint32_t len() const { return at<1>().as_uint32(); }
+  bool has_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars name() const { return at<2>().as_string(); }
+  bool has_skbaddr() const { return at<3>().valid(); }
+  uint64_t skbaddr() const { return at<3>().as_uint64(); }
 };
 
-class TrustyIpcHandleEventFtraceEvent : public ::protozero::Message {
+class NetifReceiveSkbFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = TrustyIpcHandleEventFtraceEvent_Decoder;
+  using Decoder = NetifReceiveSkbFtraceEvent_Decoder;
   enum : int32_t {
-    kChanFieldNumber = 1,
-    kEventIdFieldNumber = 2,
-    kSrvNameFieldNumber = 3,
+    kLenFieldNumber = 1,
+    kNameFieldNumber = 2,
+    kSkbaddrFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcHandleEventFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.NetifReceiveSkbFtraceEvent"; }
 
 
-  using FieldMetadata_Chan =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      TrustyIpcHandleEventFtraceEvent>;
+      NetifReceiveSkbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Chan kChan() { return {}; }
-  void set_chan(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -125651,99 +150687,102 @@ class TrustyIpcHandleEventFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_EventId =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TrustyIpcHandleEventFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      NetifReceiveSkbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EventId kEventId() { return {}; }
-  void set_event_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EventId::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SrvName =
+  using FieldMetadata_Skbaddr =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TrustyIpcHandleEventFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      NetifReceiveSkbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SrvName kSrvName() { return {}; }
-  void set_srv_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_SrvName::kFieldId, data, size);
-  }
-  void set_srv_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_SrvName::kFieldId, chars.data, chars.size);
-  }
-  void set_srv_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_SrvName::kFieldId;
+  static constexpr FieldMetadata_Skbaddr kSkbaddr{};
+  void set_skbaddr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Skbaddr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class TrustyIrqFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/oom.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_OOM_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_OOM_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class MarkVictimFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  TrustyIrqFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrustyIrqFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrustyIrqFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_irq() const { return at<1>().valid(); }
-  int32_t irq() const { return at<1>().as_int32(); }
+  MarkVictimFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MarkVictimFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MarkVictimFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  int32_t pid() const { return at<1>().as_int32(); }
 };
 
-class TrustyIrqFtraceEvent : public ::protozero::Message {
+class MarkVictimFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = TrustyIrqFtraceEvent_Decoder;
+  using Decoder = MarkVictimFtraceEvent_Decoder;
   enum : int32_t {
-    kIrqFieldNumber = 1,
+    kPidFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrustyIrqFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MarkVictimFtraceEvent"; }
 
 
-  using FieldMetadata_Irq =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      TrustyIrqFtraceEvent>;
+      MarkVictimFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Irq kIrq() { return {}; }
-  void set_irq(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Irq::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -125752,70 +150791,83 @@ class TrustyIrqFtraceEvent : public ::protozero::Message {
   }
 };
 
-class TrustyReclaimMemoryDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class OomScoreAdjUpdateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  TrustyReclaimMemoryDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrustyReclaimMemoryDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrustyReclaimMemoryDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_id() const { return at<1>().valid(); }
-  uint64_t id() const { return at<1>().as_uint64(); }
-  bool has_ret() const { return at<2>().valid(); }
-  int32_t ret() const { return at<2>().as_int32(); }
+  OomScoreAdjUpdateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit OomScoreAdjUpdateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit OomScoreAdjUpdateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_comm() const { return at<1>().valid(); }
+  ::protozero::ConstChars comm() const { return at<1>().as_string(); }
+  bool has_oom_score_adj() const { return at<2>().valid(); }
+  int32_t oom_score_adj() const { return at<2>().as_int32(); }
+  bool has_pid() const { return at<3>().valid(); }
+  int32_t pid() const { return at<3>().as_int32(); }
 };
 
-class TrustyReclaimMemoryDoneFtraceEvent : public ::protozero::Message {
+class OomScoreAdjUpdateFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = TrustyReclaimMemoryDoneFtraceEvent_Decoder;
+  using Decoder = OomScoreAdjUpdateFtraceEvent_Decoder;
   enum : int32_t {
-    kIdFieldNumber = 1,
-    kRetFieldNumber = 2,
+    kCommFieldNumber = 1,
+    kOomScoreAdjFieldNumber = 2,
+    kPidFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrustyReclaimMemoryDoneFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.OomScoreAdjUpdateFtraceEvent"; }
 
 
-  using FieldMetadata_Id =
+  using FieldMetadata_Comm =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TrustyReclaimMemoryDoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      OomScoreAdjUpdateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
-  void set_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+  static constexpr FieldMetadata_Comm kComm{};
+  void set_comm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
+  }
+  void set_comm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
+  }
+  void set_comm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ret =
+  using FieldMetadata_OomScoreAdj =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      TrustyReclaimMemoryDoneFtraceEvent>;
+      OomScoreAdjUpdateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+  static constexpr FieldMetadata_OomScoreAdj kOomScoreAdj{};
+  void set_oom_score_adj(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OomScoreAdj::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Pid =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      OomScoreAdjUpdateFtraceEvent>;
+
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -125824,148 +150876,174 @@ class TrustyReclaimMemoryDoneFtraceEvent : public ::protozero::Message {
   }
 };
 
-class TrustyReclaimMemoryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/panel.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_PANEL_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_PANEL_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class GramCollisionFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  TrustyReclaimMemoryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrustyReclaimMemoryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrustyReclaimMemoryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_id() const { return at<1>().valid(); }
-  uint64_t id() const { return at<1>().as_uint64(); }
+  GramCollisionFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GramCollisionFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GramCollisionFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_panel_index() const { return at<1>().valid(); }
+  int32_t panel_index() const { return at<1>().as_int32(); }
+  bool has_collision_cnt() const { return at<2>().valid(); }
+  uint32_t collision_cnt() const { return at<2>().as_uint32(); }
 };
 
-class TrustyReclaimMemoryFtraceEvent : public ::protozero::Message {
+class GramCollisionFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = TrustyReclaimMemoryFtraceEvent_Decoder;
+  using Decoder = GramCollisionFtraceEvent_Decoder;
   enum : int32_t {
-    kIdFieldNumber = 1,
+    kPanelIndexFieldNumber = 1,
+    kCollisionCntFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrustyReclaimMemoryFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.GramCollisionFtraceEvent"; }
 
 
-  using FieldMetadata_Id =
+  using FieldMetadata_PanelIndex =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TrustyReclaimMemoryFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      GramCollisionFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
-  void set_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+  static constexpr FieldMetadata_PanelIndex kPanelIndex{};
+  void set_panel_index(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PanelIndex::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CollisionCnt =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      GramCollisionFtraceEvent>;
+
+  static constexpr FieldMetadata_CollisionCnt kCollisionCnt{};
+  void set_collision_cnt(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CollisionCnt::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class TrustyShareMemoryDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class PanelWriteGenericFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  TrustyShareMemoryDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrustyShareMemoryDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrustyShareMemoryDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_handle() const { return at<1>().valid(); }
-  uint64_t handle() const { return at<1>().as_uint64(); }
-  bool has_len() const { return at<2>().valid(); }
-  uint64_t len() const { return at<2>().as_uint64(); }
-  bool has_lend() const { return at<3>().valid(); }
-  uint32_t lend() const { return at<3>().as_uint32(); }
-  bool has_nents() const { return at<4>().valid(); }
-  uint32_t nents() const { return at<4>().as_uint32(); }
-  bool has_ret() const { return at<5>().valid(); }
-  int32_t ret() const { return at<5>().as_int32(); }
+  PanelWriteGenericFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PanelWriteGenericFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PanelWriteGenericFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  int32_t pid() const { return at<1>().as_int32(); }
+  bool has_trace_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars trace_name() const { return at<2>().as_string(); }
+  bool has_trace_begin() const { return at<3>().valid(); }
+  uint32_t trace_begin() const { return at<3>().as_uint32(); }
+  bool has_name() const { return at<4>().valid(); }
+  ::protozero::ConstChars name() const { return at<4>().as_string(); }
+  bool has_type() const { return at<5>().valid(); }
+  uint32_t type() const { return at<5>().as_uint32(); }
+  bool has_value() const { return at<6>().valid(); }
+  int32_t value() const { return at<6>().as_int32(); }
 };
 
-class TrustyShareMemoryDoneFtraceEvent : public ::protozero::Message {
+class PanelWriteGenericFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = TrustyShareMemoryDoneFtraceEvent_Decoder;
+  using Decoder = PanelWriteGenericFtraceEvent_Decoder;
   enum : int32_t {
-    kHandleFieldNumber = 1,
-    kLenFieldNumber = 2,
-    kLendFieldNumber = 3,
-    kNentsFieldNumber = 4,
-    kRetFieldNumber = 5,
+    kPidFieldNumber = 1,
+    kTraceNameFieldNumber = 2,
+    kTraceBeginFieldNumber = 3,
+    kNameFieldNumber = 4,
+    kTypeFieldNumber = 5,
+    kValueFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrustyShareMemoryDoneFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.PanelWriteGenericFtraceEvent"; }
 
 
-  using FieldMetadata_Handle =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TrustyShareMemoryDoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      PanelWriteGenericFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Handle kHandle() { return {}; }
-  void set_handle(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Handle::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Len =
+  using FieldMetadata_TraceName =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TrustyShareMemoryDoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      PanelWriteGenericFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_TraceName kTraceName{};
+  void set_trace_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_TraceName::kFieldId, data, size);
+  }
+  void set_trace_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_TraceName::kFieldId, chars.data, chars.size);
+  }
+  void set_trace_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_TraceName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Lend =
+  using FieldMetadata_TraceBegin =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      TrustyShareMemoryDoneFtraceEvent>;
+      PanelWriteGenericFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lend kLend() { return {}; }
-  void set_lend(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lend::kFieldId;
+  static constexpr FieldMetadata_TraceBegin kTraceBegin{};
+  void set_trace_begin(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TraceBegin::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -125973,24 +151051,41 @@ class TrustyShareMemoryDoneFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Nents =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      PanelWriteGenericFtraceEvent>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Type =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      TrustyShareMemoryDoneFtraceEvent>;
+      PanelWriteGenericFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nents kNents() { return {}; }
-  void set_nents(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Nents::kFieldId;
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -125998,24 +151093,17 @@ class TrustyShareMemoryDoneFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ret =
+  using FieldMetadata_Value =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      TrustyShareMemoryDoneFtraceEvent>;
+      PanelWriteGenericFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -126024,73 +151112,59 @@ class TrustyShareMemoryDoneFtraceEvent : public ::protozero::Message {
   }
 };
 
-class TrustyShareMemoryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DsiTxFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  TrustyShareMemoryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrustyShareMemoryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrustyShareMemoryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_len() const { return at<1>().valid(); }
-  uint64_t len() const { return at<1>().as_uint64(); }
-  bool has_lend() const { return at<2>().valid(); }
-  uint32_t lend() const { return at<2>().as_uint32(); }
-  bool has_nents() const { return at<3>().valid(); }
-  uint32_t nents() const { return at<3>().as_uint32(); }
+  DsiTxFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DsiTxFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DsiTxFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_last() const { return at<1>().valid(); }
+  uint32_t last() const { return at<1>().as_uint32(); }
+  bool has_type() const { return at<3>().valid(); }
+  uint32_t type() const { return at<3>().as_uint32(); }
+  bool has_tx_buf() const { return at<4>().valid(); }
+  ::protozero::ConstBytes tx_buf() const { return at<4>().as_bytes(); }
 };
 
-class TrustyShareMemoryFtraceEvent : public ::protozero::Message {
+class DsiTxFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = TrustyShareMemoryFtraceEvent_Decoder;
+  using Decoder = DsiTxFtraceEvent_Decoder;
   enum : int32_t {
-    kLenFieldNumber = 1,
-    kLendFieldNumber = 2,
-    kNentsFieldNumber = 3,
+    kLastFieldNumber = 1,
+    kTypeFieldNumber = 3,
+    kTxBufFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrustyShareMemoryFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.DsiTxFtraceEvent"; }
 
 
-  using FieldMetadata_Len =
+  using FieldMetadata_Last =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TrustyShareMemoryFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      DsiTxFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Len kLen() { return {}; }
-  void set_len(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
+  static constexpr FieldMetadata_Last kLast{};
+  void set_last(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Last::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Lend =
+  using FieldMetadata_Type =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      TrustyShareMemoryFtraceEvent>;
+      DsiTxFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lend kLend() { return {}; }
-  void set_lend(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lend::kFieldId;
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -126098,171 +151172,308 @@ class TrustyShareMemoryFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Nents =
+  using FieldMetadata_TxBuf =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TrustyShareMemoryFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      DsiTxFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nents kNents() { return {}; }
-  void set_nents(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Nents::kFieldId;
+  static constexpr FieldMetadata_TxBuf kTxBuf{};
+  void set_tx_buf(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_TxBuf::kFieldId, data, size);
+  }
+  void set_tx_buf(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_TxBuf::kFieldId, bytes.data, bytes.size);
+  }
+  void set_tx_buf(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_TxBuf::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
         ::Append(*this, field_id, value);
   }
 };
 
-class TrustyStdCall32DoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DsiRxFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  TrustyStdCall32DoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrustyStdCall32DoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrustyStdCall32DoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_ret() const { return at<1>().valid(); }
-  int64_t ret() const { return at<1>().as_int64(); }
+  DsiRxFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DsiRxFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DsiRxFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cmd() const { return at<1>().valid(); }
+  uint32_t cmd() const { return at<1>().as_uint32(); }
+  bool has_rx_buf() const { return at<3>().valid(); }
+  ::protozero::ConstBytes rx_buf() const { return at<3>().as_bytes(); }
 };
 
-class TrustyStdCall32DoneFtraceEvent : public ::protozero::Message {
+class DsiRxFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = TrustyStdCall32DoneFtraceEvent_Decoder;
+  using Decoder = DsiRxFtraceEvent_Decoder;
   enum : int32_t {
-    kRetFieldNumber = 1,
+    kCmdFieldNumber = 1,
+    kRxBufFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrustyStdCall32DoneFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.DsiRxFtraceEvent"; }
 
 
-  using FieldMetadata_Ret =
+  using FieldMetadata_Cmd =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TrustyStdCall32DoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      DsiRxFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+  static constexpr FieldMetadata_Cmd kCmd{};
+  void set_cmd(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cmd::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_RxBuf =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      DsiRxFtraceEvent>;
+
+  static constexpr FieldMetadata_RxBuf kRxBuf{};
+  void set_rx_buf(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_RxBuf::kFieldId, data, size);
+  }
+  void set_rx_buf(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_RxBuf::kFieldId, bytes.data, bytes.size);
+  }
+  void set_rx_buf(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_RxBuf::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
         ::Append(*this, field_id, value);
   }
 };
 
-class TrustyStdCall32FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DsiCmdFifoStatusFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  TrustyStdCall32FtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrustyStdCall32FtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrustyStdCall32FtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_r0() const { return at<1>().valid(); }
-  uint64_t r0() const { return at<1>().as_uint64(); }
-  bool has_r1() const { return at<2>().valid(); }
-  uint64_t r1() const { return at<2>().as_uint64(); }
-  bool has_r2() const { return at<3>().valid(); }
-  uint64_t r2() const { return at<3>().as_uint64(); }
-  bool has_r3() const { return at<4>().valid(); }
-  uint64_t r3() const { return at<4>().as_uint64(); }
+  DsiCmdFifoStatusFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DsiCmdFifoStatusFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DsiCmdFifoStatusFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_header() const { return at<1>().valid(); }
+  uint32_t header() const { return at<1>().as_uint32(); }
+  bool has_payload() const { return at<2>().valid(); }
+  uint32_t payload() const { return at<2>().as_uint32(); }
 };
 
-class TrustyStdCall32FtraceEvent : public ::protozero::Message {
+class DsiCmdFifoStatusFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = TrustyStdCall32FtraceEvent_Decoder;
+  using Decoder = DsiCmdFifoStatusFtraceEvent_Decoder;
   enum : int32_t {
-    kR0FieldNumber = 1,
-    kR1FieldNumber = 2,
-    kR2FieldNumber = 3,
-    kR3FieldNumber = 4,
+    kHeaderFieldNumber = 1,
+    kPayloadFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrustyStdCall32FtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.DsiCmdFifoStatusFtraceEvent"; }
 
 
-  using FieldMetadata_R0 =
+  using FieldMetadata_Header =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TrustyStdCall32FtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      DsiCmdFifoStatusFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_R0 kR0() { return {}; }
-  void set_r0(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_R0::kFieldId;
+  static constexpr FieldMetadata_Header kHeader{};
+  void set_header(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Header::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_R1 =
+  using FieldMetadata_Payload =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TrustyStdCall32FtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      DsiCmdFifoStatusFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_R1 kR1() { return {}; }
-  void set_r1(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_R1::kFieldId;
+  static constexpr FieldMetadata_Payload kPayload{};
+  void set_payload(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Payload::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_R2 =
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/perf_trace_counters.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_PERF_TRACE_COUNTERS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_PERF_TRACE_COUNTERS_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class SchedSwitchWithCtrsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/23> {
+ public:
+  SchedSwitchWithCtrsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SchedSwitchWithCtrsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SchedSwitchWithCtrsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_old_pid() const { return at<1>().valid(); }
+  int32_t old_pid() const { return at<1>().as_int32(); }
+  bool has_new_pid() const { return at<2>().valid(); }
+  int32_t new_pid() const { return at<2>().as_int32(); }
+  bool has_cctr() const { return at<3>().valid(); }
+  uint64_t cctr() const { return at<3>().as_uint64(); }
+  bool has_ctr0() const { return at<4>().valid(); }
+  uint64_t ctr0() const { return at<4>().as_uint64(); }
+  bool has_ctr1() const { return at<5>().valid(); }
+  uint64_t ctr1() const { return at<5>().as_uint64(); }
+  bool has_ctr2() const { return at<6>().valid(); }
+  uint64_t ctr2() const { return at<6>().as_uint64(); }
+  bool has_ctr3() const { return at<7>().valid(); }
+  uint64_t ctr3() const { return at<7>().as_uint64(); }
+  bool has_lctr0() const { return at<8>().valid(); }
+  uint32_t lctr0() const { return at<8>().as_uint32(); }
+  bool has_lctr1() const { return at<9>().valid(); }
+  uint32_t lctr1() const { return at<9>().as_uint32(); }
+  bool has_ctr4() const { return at<10>().valid(); }
+  uint64_t ctr4() const { return at<10>().as_uint64(); }
+  bool has_ctr5() const { return at<11>().valid(); }
+  uint64_t ctr5() const { return at<11>().as_uint64(); }
+  bool has_prev_comm() const { return at<12>().valid(); }
+  ::protozero::ConstChars prev_comm() const { return at<12>().as_string(); }
+  bool has_prev_pid() const { return at<13>().valid(); }
+  int32_t prev_pid() const { return at<13>().as_int32(); }
+  bool has_cyc() const { return at<14>().valid(); }
+  uint32_t cyc() const { return at<14>().as_uint32(); }
+  bool has_inst() const { return at<15>().valid(); }
+  uint32_t inst() const { return at<15>().as_uint32(); }
+  bool has_stallbm() const { return at<16>().valid(); }
+  uint32_t stallbm() const { return at<16>().as_uint32(); }
+  bool has_l3dm() const { return at<17>().valid(); }
+  uint32_t l3dm() const { return at<17>().as_uint32(); }
+  bool has_next_pid() const { return at<18>().valid(); }
+  int32_t next_pid() const { return at<18>().as_int32(); }
+  bool has_next_comm() const { return at<19>().valid(); }
+  ::protozero::ConstChars next_comm() const { return at<19>().as_string(); }
+  bool has_prev_state() const { return at<20>().valid(); }
+  int64_t prev_state() const { return at<20>().as_int64(); }
+  bool has_amu0() const { return at<21>().valid(); }
+  uint64_t amu0() const { return at<21>().as_uint64(); }
+  bool has_amu1() const { return at<22>().valid(); }
+  uint64_t amu1() const { return at<22>().as_uint64(); }
+  bool has_amu2() const { return at<23>().valid(); }
+  uint64_t amu2() const { return at<23>().as_uint64(); }
+};
+
+class SchedSwitchWithCtrsFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = SchedSwitchWithCtrsFtraceEvent_Decoder;
+  enum : int32_t {
+    kOldPidFieldNumber = 1,
+    kNewPidFieldNumber = 2,
+    kCctrFieldNumber = 3,
+    kCtr0FieldNumber = 4,
+    kCtr1FieldNumber = 5,
+    kCtr2FieldNumber = 6,
+    kCtr3FieldNumber = 7,
+    kLctr0FieldNumber = 8,
+    kLctr1FieldNumber = 9,
+    kCtr4FieldNumber = 10,
+    kCtr5FieldNumber = 11,
+    kPrevCommFieldNumber = 12,
+    kPrevPidFieldNumber = 13,
+    kCycFieldNumber = 14,
+    kInstFieldNumber = 15,
+    kStallbmFieldNumber = 16,
+    kL3dmFieldNumber = 17,
+    kNextPidFieldNumber = 18,
+    kNextCommFieldNumber = 19,
+    kPrevStateFieldNumber = 20,
+    kAmu0FieldNumber = 21,
+    kAmu1FieldNumber = 22,
+    kAmu2FieldNumber = 23,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SchedSwitchWithCtrsFtraceEvent"; }
+
+
+  using FieldMetadata_OldPid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedSwitchWithCtrsFtraceEvent>;
+
+  static constexpr FieldMetadata_OldPid kOldPid{};
+  void set_old_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OldPid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NewPid =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedSwitchWithCtrsFtraceEvent>;
+
+  static constexpr FieldMetadata_NewPid kNewPid{};
+  void set_new_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NewPid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Cctr =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TrustyStdCall32FtraceEvent>;
+      SchedSwitchWithCtrsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_R2 kR2() { return {}; }
-  void set_r2(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_R2::kFieldId;
+  static constexpr FieldMetadata_Cctr kCctr{};
+  void set_cctr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cctr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -126270,121 +151481,53 @@ class TrustyStdCall32FtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_R3 =
+  using FieldMetadata_Ctr0 =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TrustyStdCall32FtraceEvent>;
+      SchedSwitchWithCtrsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_R3 kR3() { return {}; }
-  void set_r3(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_R3::kFieldId;
+  static constexpr FieldMetadata_Ctr0 kCtr0{};
+  void set_ctr0(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ctr0::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class TrustySmcDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TrustySmcDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrustySmcDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrustySmcDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_ret() const { return at<1>().valid(); }
-  uint64_t ret() const { return at<1>().as_uint64(); }
-};
-
-class TrustySmcDoneFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = TrustySmcDoneFtraceEvent_Decoder;
-  enum : int32_t {
-    kRetFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrustySmcDoneFtraceEvent"; }
-
 
-  using FieldMetadata_Ret =
+  using FieldMetadata_Ctr1 =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TrustySmcDoneFtraceEvent>;
+      SchedSwitchWithCtrsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ret kRet() { return {}; }
-  void set_ret(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+  static constexpr FieldMetadata_Ctr1 kCtr1{};
+  void set_ctr1(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ctr1::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class TrustySmcFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TrustySmcFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrustySmcFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrustySmcFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_r0() const { return at<1>().valid(); }
-  uint64_t r0() const { return at<1>().as_uint64(); }
-  bool has_r1() const { return at<2>().valid(); }
-  uint64_t r1() const { return at<2>().as_uint64(); }
-  bool has_r2() const { return at<3>().valid(); }
-  uint64_t r2() const { return at<3>().as_uint64(); }
-  bool has_r3() const { return at<4>().valid(); }
-  uint64_t r3() const { return at<4>().as_uint64(); }
-};
-
-class TrustySmcFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = TrustySmcFtraceEvent_Decoder;
-  enum : int32_t {
-    kR0FieldNumber = 1,
-    kR1FieldNumber = 2,
-    kR2FieldNumber = 3,
-    kR3FieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrustySmcFtraceEvent"; }
 
-
-  using FieldMetadata_R0 =
+  using FieldMetadata_Ctr2 =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TrustySmcFtraceEvent>;
+      SchedSwitchWithCtrsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_R0 kR0() { return {}; }
-  void set_r0(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_R0::kFieldId;
+  static constexpr FieldMetadata_Ctr2 kCtr2{};
+  void set_ctr2(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ctr2::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -126392,24 +151535,17 @@ class TrustySmcFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_R1 =
+  using FieldMetadata_Ctr3 =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TrustySmcFtraceEvent>;
+      SchedSwitchWithCtrsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_R1 kR1() { return {}; }
-  void set_r1(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_R1::kFieldId;
+  static constexpr FieldMetadata_Ctr3 kCtr3{};
+  void set_ctr3(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ctr3::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -126417,24 +151553,53 @@ class TrustySmcFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_R2 =
+  using FieldMetadata_Lctr0 =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SchedSwitchWithCtrsFtraceEvent>;
+
+  static constexpr FieldMetadata_Lctr0 kLctr0{};
+  void set_lctr0(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lctr0::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Lctr1 =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SchedSwitchWithCtrsFtraceEvent>;
+
+  static constexpr FieldMetadata_Lctr1 kLctr1{};
+  void set_lctr1(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lctr1::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ctr4 =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TrustySmcFtraceEvent>;
+      SchedSwitchWithCtrsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_R2 kR2() { return {}; }
-  void set_r2(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_R2::kFieldId;
+  static constexpr FieldMetadata_Ctr4 kCtr4{};
+  void set_ctr4(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ctr4::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -126442,203 +151607,173 @@ class TrustySmcFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_R3 =
+  using FieldMetadata_Ctr5 =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TrustySmcFtraceEvent>;
+      SchedSwitchWithCtrsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_R3 kR3() { return {}; }
-  void set_r3(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_R3::kFieldId;
+  static constexpr FieldMetadata_Ctr5 kCtr5{};
+  void set_ctr5(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ctr5::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/ufs.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_UFS_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_UFS_PROTO_H_
+  using FieldMetadata_PrevComm =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SchedSwitchWithCtrsFtraceEvent>;
 
-#include <stddef.h>
-#include <stdint.h>
+  static constexpr FieldMetadata_PrevComm kPrevComm{};
+  void set_prev_comm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_PrevComm::kFieldId, data, size);
+  }
+  void set_prev_comm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_PrevComm::kFieldId, chars.data, chars.size);
+  }
+  void set_prev_comm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_PrevComm::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  using FieldMetadata_PrevPid =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedSwitchWithCtrsFtraceEvent>;
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  static constexpr FieldMetadata_PrevPid kPrevPid{};
+  void set_prev_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PrevPid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
+  using FieldMetadata_Cyc =
+    ::protozero::proto_utils::FieldMetadata<
+      14,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SchedSwitchWithCtrsFtraceEvent>;
 
-class UfshcdClkGatingFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  UfshcdClkGatingFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit UfshcdClkGatingFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit UfshcdClkGatingFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars dev_name() const { return at<1>().as_string(); }
-  bool has_state() const { return at<2>().valid(); }
-  int32_t state() const { return at<2>().as_int32(); }
-};
+  static constexpr FieldMetadata_Cyc kCyc{};
+  void set_cyc(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cyc::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-class UfshcdClkGatingFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = UfshcdClkGatingFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevNameFieldNumber = 1,
-    kStateFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.UfshcdClkGatingFtraceEvent"; }
+  using FieldMetadata_Inst =
+    ::protozero::proto_utils::FieldMetadata<
+      15,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SchedSwitchWithCtrsFtraceEvent>;
 
+  static constexpr FieldMetadata_Inst kInst{};
+  void set_inst(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Inst::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_DevName =
+  using FieldMetadata_Stallbm =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      16,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      UfshcdClkGatingFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SchedSwitchWithCtrsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DevName kDevName() { return {}; }
-  void set_dev_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_DevName::kFieldId, data, size);
-  }
-  void set_dev_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_DevName::kFieldId, chars.data, chars.size);
+  static constexpr FieldMetadata_Stallbm kStallbm{};
+  void set_stallbm(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Stallbm::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
-  void set_dev_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_DevName::kFieldId;
+
+  using FieldMetadata_L3dm =
+    ::protozero::proto_utils::FieldMetadata<
+      17,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SchedSwitchWithCtrsFtraceEvent>;
+
+  static constexpr FieldMetadata_L3dm kL3dm{};
+  void set_l3dm(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_L3dm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_State =
+  using FieldMetadata_NextPid =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      18,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      UfshcdClkGatingFtraceEvent>;
+      SchedSwitchWithCtrsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_State kState() { return {}; }
-  void set_state(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
+  static constexpr FieldMetadata_NextPid kNextPid{};
+  void set_next_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NextPid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-class UfshcdCommandFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  UfshcdCommandFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit UfshcdCommandFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit UfshcdCommandFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dev_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars dev_name() const { return at<1>().as_string(); }
-  bool has_doorbell() const { return at<2>().valid(); }
-  uint32_t doorbell() const { return at<2>().as_uint32(); }
-  bool has_intr() const { return at<3>().valid(); }
-  uint32_t intr() const { return at<3>().as_uint32(); }
-  bool has_lba() const { return at<4>().valid(); }
-  uint64_t lba() const { return at<4>().as_uint64(); }
-  bool has_opcode() const { return at<5>().valid(); }
-  uint32_t opcode() const { return at<5>().as_uint32(); }
-  bool has_str() const { return at<6>().valid(); }
-  ::protozero::ConstChars str() const { return at<6>().as_string(); }
-  bool has_tag() const { return at<7>().valid(); }
-  uint32_t tag() const { return at<7>().as_uint32(); }
-  bool has_transfer_len() const { return at<8>().valid(); }
-  int32_t transfer_len() const { return at<8>().as_int32(); }
-  bool has_group_id() const { return at<9>().valid(); }
-  uint32_t group_id() const { return at<9>().as_uint32(); }
-  bool has_str_t() const { return at<10>().valid(); }
-  uint32_t str_t() const { return at<10>().as_uint32(); }
-};
-
-class UfshcdCommandFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = UfshcdCommandFtraceEvent_Decoder;
-  enum : int32_t {
-    kDevNameFieldNumber = 1,
-    kDoorbellFieldNumber = 2,
-    kIntrFieldNumber = 3,
-    kLbaFieldNumber = 4,
-    kOpcodeFieldNumber = 5,
-    kStrFieldNumber = 6,
-    kTagFieldNumber = 7,
-    kTransferLenFieldNumber = 8,
-    kGroupIdFieldNumber = 9,
-    kStrTFieldNumber = 10,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.UfshcdCommandFtraceEvent"; }
 
-
-  using FieldMetadata_DevName =
+  using FieldMetadata_NextComm =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      19,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      UfshcdCommandFtraceEvent>;
+      SchedSwitchWithCtrsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DevName kDevName() { return {}; }
-  void set_dev_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_DevName::kFieldId, data, size);
+  static constexpr FieldMetadata_NextComm kNextComm{};
+  void set_next_comm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_NextComm::kFieldId, data, size);
   }
-  void set_dev_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_DevName::kFieldId, chars.data, chars.size);
+  void set_next_comm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_NextComm::kFieldId, chars.data, chars.size);
   }
-  void set_dev_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_DevName::kFieldId;
+  void set_next_comm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_NextComm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -126646,74 +151781,53 @@ class UfshcdCommandFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Doorbell =
+  using FieldMetadata_PrevState =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      20,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      UfshcdCommandFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      SchedSwitchWithCtrsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Doorbell kDoorbell() { return {}; }
-  void set_doorbell(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Doorbell::kFieldId;
+  static constexpr FieldMetadata_PrevState kPrevState{};
+  void set_prev_state(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PrevState::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Intr =
+  using FieldMetadata_Amu0 =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      21,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      UfshcdCommandFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SchedSwitchWithCtrsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Intr kIntr() { return {}; }
-  void set_intr(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Intr::kFieldId;
+  static constexpr FieldMetadata_Amu0 kAmu0{};
+  void set_amu0(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Amu0::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Lba =
+  using FieldMetadata_Amu1 =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      22,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      UfshcdCommandFtraceEvent>;
+      SchedSwitchWithCtrsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lba kLba() { return {}; }
-  void set_lba(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Lba::kFieldId;
+  static constexpr FieldMetadata_Amu1 kAmu1{};
+  void set_amu1(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Amu1::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -126721,159 +151835,182 @@ class UfshcdCommandFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Opcode =
+  using FieldMetadata_Amu2 =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      23,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      UfshcdCommandFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SchedSwitchWithCtrsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Opcode kOpcode() { return {}; }
-  void set_opcode(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Opcode::kFieldId;
+  static constexpr FieldMetadata_Amu2 kAmu2{};
+  void set_amu2(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Amu2::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Str =
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/pixel_mm.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_PIXEL_MM_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_PIXEL_MM_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class PixelMmKswapdDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  PixelMmKswapdDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PixelMmKswapdDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PixelMmKswapdDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_delta_nr_scanned() const { return at<1>().valid(); }
+  uint64_t delta_nr_scanned() const { return at<1>().as_uint64(); }
+  bool has_delta_nr_reclaimed() const { return at<2>().valid(); }
+  uint64_t delta_nr_reclaimed() const { return at<2>().as_uint64(); }
+  bool has_delta_nr_allocated() const { return at<3>().valid(); }
+  uint64_t delta_nr_allocated() const { return at<3>().as_uint64(); }
+  bool has_duration_ns() const { return at<4>().valid(); }
+  uint64_t duration_ns() const { return at<4>().as_uint64(); }
+};
+
+class PixelMmKswapdDoneFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = PixelMmKswapdDoneFtraceEvent_Decoder;
+  enum : int32_t {
+    kDeltaNrScannedFieldNumber = 1,
+    kDeltaNrReclaimedFieldNumber = 2,
+    kDeltaNrAllocatedFieldNumber = 3,
+    kDurationNsFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.PixelMmKswapdDoneFtraceEvent"; }
+
+
+  using FieldMetadata_DeltaNrScanned =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      UfshcdCommandFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      PixelMmKswapdDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Str kStr() { return {}; }
-  void set_str(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Str::kFieldId, data, size);
-  }
-  void set_str(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Str::kFieldId, chars.data, chars.size);
-  }
-  void set_str(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Str::kFieldId;
+  static constexpr FieldMetadata_DeltaNrScanned kDeltaNrScanned{};
+  void set_delta_nr_scanned(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DeltaNrScanned::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Tag =
+  using FieldMetadata_DeltaNrReclaimed =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      UfshcdCommandFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      PixelMmKswapdDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Tag kTag() { return {}; }
-  void set_tag(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Tag::kFieldId;
+  static constexpr FieldMetadata_DeltaNrReclaimed kDeltaNrReclaimed{};
+  void set_delta_nr_reclaimed(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DeltaNrReclaimed::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TransferLen =
+  using FieldMetadata_DeltaNrAllocated =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      UfshcdCommandFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      PixelMmKswapdDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TransferLen kTransferLen() { return {}; }
-  void set_transfer_len(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TransferLen::kFieldId;
+  static constexpr FieldMetadata_DeltaNrAllocated kDeltaNrAllocated{};
+  void set_delta_nr_allocated(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DeltaNrAllocated::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_GroupId =
+  using FieldMetadata_DurationNs =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      UfshcdCommandFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      PixelMmKswapdDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GroupId kGroupId() { return {}; }
-  void set_group_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GroupId::kFieldId;
+  static constexpr FieldMetadata_DurationNs kDurationNs{};
+  void set_duration_ns(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DurationNs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_StrT =
+class PixelMmKswapdWakeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  PixelMmKswapdWakeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PixelMmKswapdWakeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PixelMmKswapdWakeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_whatever() const { return at<1>().valid(); }
+  int32_t whatever() const { return at<1>().as_int32(); }
+};
+
+class PixelMmKswapdWakeFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = PixelMmKswapdWakeFtraceEvent_Decoder;
+  enum : int32_t {
+    kWhateverFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.PixelMmKswapdWakeFtraceEvent"; }
+
+
+  using FieldMetadata_Whatever =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      UfshcdCommandFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      PixelMmKswapdWakeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StrT kStrT() { return {}; }
-  void set_str_t(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StrT::kFieldId;
+  static constexpr FieldMetadata_Whatever kWhatever{};
+  void set_whatever(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Whatever::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
@@ -126882,11 +152019,11 @@ class UfshcdCommandFtraceEvent : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/v4l2.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/power.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_V4L2_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_V4L2_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_POWER_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_POWER_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -126897,339 +152034,346 @@ class UfshcdCommandFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class Vb2V4l2DqbufFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/15, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class GpuPowerStateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  Vb2V4l2DqbufFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Vb2V4l2DqbufFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Vb2V4l2DqbufFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_field() const { return at<1>().valid(); }
-  uint32_t field() const { return at<1>().as_uint32(); }
-  bool has_flags() const { return at<2>().valid(); }
-  uint32_t flags() const { return at<2>().as_uint32(); }
-  bool has_minor() const { return at<3>().valid(); }
-  int32_t minor() const { return at<3>().as_int32(); }
-  bool has_sequence() const { return at<4>().valid(); }
-  uint32_t sequence() const { return at<4>().as_uint32(); }
-  bool has_timecode_flags() const { return at<5>().valid(); }
-  uint32_t timecode_flags() const { return at<5>().as_uint32(); }
-  bool has_timecode_frames() const { return at<6>().valid(); }
-  uint32_t timecode_frames() const { return at<6>().as_uint32(); }
-  bool has_timecode_hours() const { return at<7>().valid(); }
-  uint32_t timecode_hours() const { return at<7>().as_uint32(); }
-  bool has_timecode_minutes() const { return at<8>().valid(); }
-  uint32_t timecode_minutes() const { return at<8>().as_uint32(); }
-  bool has_timecode_seconds() const { return at<9>().valid(); }
-  uint32_t timecode_seconds() const { return at<9>().as_uint32(); }
-  bool has_timecode_type() const { return at<10>().valid(); }
-  uint32_t timecode_type() const { return at<10>().as_uint32(); }
-  bool has_timecode_userbits0() const { return at<11>().valid(); }
-  uint32_t timecode_userbits0() const { return at<11>().as_uint32(); }
-  bool has_timecode_userbits1() const { return at<12>().valid(); }
-  uint32_t timecode_userbits1() const { return at<12>().as_uint32(); }
-  bool has_timecode_userbits2() const { return at<13>().valid(); }
-  uint32_t timecode_userbits2() const { return at<13>().as_uint32(); }
-  bool has_timecode_userbits3() const { return at<14>().valid(); }
-  uint32_t timecode_userbits3() const { return at<14>().as_uint32(); }
-  bool has_timestamp() const { return at<15>().valid(); }
-  int64_t timestamp() const { return at<15>().as_int64(); }
+  GpuPowerStateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GpuPowerStateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GpuPowerStateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_old_state() const { return at<1>().valid(); }
+  int32_t old_state() const { return at<1>().as_int32(); }
+  bool has_new_state() const { return at<2>().valid(); }
+  int32_t new_state() const { return at<2>().as_int32(); }
 };
 
-class Vb2V4l2DqbufFtraceEvent : public ::protozero::Message {
+class GpuPowerStateFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Vb2V4l2DqbufFtraceEvent_Decoder;
+  using Decoder = GpuPowerStateFtraceEvent_Decoder;
   enum : int32_t {
-    kFieldFieldNumber = 1,
-    kFlagsFieldNumber = 2,
-    kMinorFieldNumber = 3,
-    kSequenceFieldNumber = 4,
-    kTimecodeFlagsFieldNumber = 5,
-    kTimecodeFramesFieldNumber = 6,
-    kTimecodeHoursFieldNumber = 7,
-    kTimecodeMinutesFieldNumber = 8,
-    kTimecodeSecondsFieldNumber = 9,
-    kTimecodeTypeFieldNumber = 10,
-    kTimecodeUserbits0FieldNumber = 11,
-    kTimecodeUserbits1FieldNumber = 12,
-    kTimecodeUserbits2FieldNumber = 13,
-    kTimecodeUserbits3FieldNumber = 14,
-    kTimestampFieldNumber = 15,
+    kOldStateFieldNumber = 1,
+    kNewStateFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Vb2V4l2DqbufFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.GpuPowerStateFtraceEvent"; }
 
 
-  using FieldMetadata_Field =
+  using FieldMetadata_OldState =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      GpuPowerStateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Field kField() { return {}; }
-  void set_field(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Field::kFieldId;
+  static constexpr FieldMetadata_OldState kOldState{};
+  void set_old_state(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OldState::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_NewState =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      GpuPowerStateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_NewState kNewState{};
+  void set_new_state(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NewState::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Minor =
+class DevicePmCallbackEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  DevicePmCallbackEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DevicePmCallbackEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DevicePmCallbackEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_device() const { return at<1>().valid(); }
+  ::protozero::ConstChars device() const { return at<1>().as_string(); }
+  bool has_driver() const { return at<2>().valid(); }
+  ::protozero::ConstChars driver() const { return at<2>().as_string(); }
+  bool has_error() const { return at<3>().valid(); }
+  int32_t error() const { return at<3>().as_int32(); }
+};
+
+class DevicePmCallbackEndFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = DevicePmCallbackEndFtraceEvent_Decoder;
+  enum : int32_t {
+    kDeviceFieldNumber = 1,
+    kDriverFieldNumber = 2,
+    kErrorFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.DevicePmCallbackEndFtraceEvent"; }
+
+
+  using FieldMetadata_Device =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Vb2V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      DevicePmCallbackEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Minor kMinor() { return {}; }
-  void set_minor(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Minor::kFieldId;
+  static constexpr FieldMetadata_Device kDevice{};
+  void set_device(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Device::kFieldId, data, size);
+  }
+  void set_device(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Device::kFieldId, chars.data, chars.size);
+  }
+  void set_device(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Device::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Sequence =
+  using FieldMetadata_Driver =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      DevicePmCallbackEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sequence kSequence() { return {}; }
-  void set_sequence(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Sequence::kFieldId;
+  static constexpr FieldMetadata_Driver kDriver{};
+  void set_driver(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Driver::kFieldId, data, size);
+  }
+  void set_driver(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Driver::kFieldId, chars.data, chars.size);
+  }
+  void set_driver(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Driver::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeFlags =
+  using FieldMetadata_Error =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      DevicePmCallbackEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeFlags kTimecodeFlags() { return {}; }
-  void set_timecode_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeFlags::kFieldId;
+  static constexpr FieldMetadata_Error kError{};
+  void set_error(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TimecodeFrames =
+class DevicePmCallbackStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  DevicePmCallbackStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DevicePmCallbackStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DevicePmCallbackStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_device() const { return at<1>().valid(); }
+  ::protozero::ConstChars device() const { return at<1>().as_string(); }
+  bool has_driver() const { return at<2>().valid(); }
+  ::protozero::ConstChars driver() const { return at<2>().as_string(); }
+  bool has_parent() const { return at<3>().valid(); }
+  ::protozero::ConstChars parent() const { return at<3>().as_string(); }
+  bool has_pm_ops() const { return at<4>().valid(); }
+  ::protozero::ConstChars pm_ops() const { return at<4>().as_string(); }
+  bool has_event() const { return at<5>().valid(); }
+  int32_t event() const { return at<5>().as_int32(); }
+};
+
+class DevicePmCallbackStartFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = DevicePmCallbackStartFtraceEvent_Decoder;
+  enum : int32_t {
+    kDeviceFieldNumber = 1,
+    kDriverFieldNumber = 2,
+    kParentFieldNumber = 3,
+    kPmOpsFieldNumber = 4,
+    kEventFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.DevicePmCallbackStartFtraceEvent"; }
+
+
+  using FieldMetadata_Device =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      DevicePmCallbackStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeFrames kTimecodeFrames() { return {}; }
-  void set_timecode_frames(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeFrames::kFieldId;
+  static constexpr FieldMetadata_Device kDevice{};
+  void set_device(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Device::kFieldId, data, size);
+  }
+  void set_device(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Device::kFieldId, chars.data, chars.size);
+  }
+  void set_device(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Device::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeHours =
+  using FieldMetadata_Driver =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      DevicePmCallbackStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeHours kTimecodeHours() { return {}; }
-  void set_timecode_hours(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeHours::kFieldId;
+  static constexpr FieldMetadata_Driver kDriver{};
+  void set_driver(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Driver::kFieldId, data, size);
+  }
+  void set_driver(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Driver::kFieldId, chars.data, chars.size);
+  }
+  void set_driver(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Driver::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeMinutes =
+  using FieldMetadata_Parent =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      DevicePmCallbackStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeMinutes kTimecodeMinutes() { return {}; }
-  void set_timecode_minutes(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeMinutes::kFieldId;
+  static constexpr FieldMetadata_Parent kParent{};
+  void set_parent(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Parent::kFieldId, data, size);
+  }
+  void set_parent(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Parent::kFieldId, chars.data, chars.size);
+  }
+  void set_parent(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Parent::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeSeconds =
+  using FieldMetadata_PmOps =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      DevicePmCallbackStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeSeconds kTimecodeSeconds() { return {}; }
-  void set_timecode_seconds(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeSeconds::kFieldId;
+  static constexpr FieldMetadata_PmOps kPmOps{};
+  void set_pm_ops(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_PmOps::kFieldId, data, size);
+  }
+  void set_pm_ops(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_PmOps::kFieldId, chars.data, chars.size);
+  }
+  void set_pm_ops(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_PmOps::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeType =
+  using FieldMetadata_Event =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      DevicePmCallbackStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeType kTimecodeType() { return {}; }
-  void set_timecode_type(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeType::kFieldId;
+  static constexpr FieldMetadata_Event kEvent{};
+  void set_event(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Event::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TimecodeUserbits0 =
+class GpuWorkPeriodFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  GpuWorkPeriodFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GpuWorkPeriodFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GpuWorkPeriodFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_gpu_id() const { return at<1>().valid(); }
+  uint32_t gpu_id() const { return at<1>().as_uint32(); }
+  bool has_uid() const { return at<2>().valid(); }
+  uint32_t uid() const { return at<2>().as_uint32(); }
+  bool has_start_time_ns() const { return at<3>().valid(); }
+  uint64_t start_time_ns() const { return at<3>().as_uint64(); }
+  bool has_end_time_ns() const { return at<4>().valid(); }
+  uint64_t end_time_ns() const { return at<4>().as_uint64(); }
+  bool has_total_active_duration_ns() const { return at<5>().valid(); }
+  uint64_t total_active_duration_ns() const { return at<5>().as_uint64(); }
+};
+
+class GpuWorkPeriodFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = GpuWorkPeriodFtraceEvent_Decoder;
+  enum : int32_t {
+    kGpuIdFieldNumber = 1,
+    kUidFieldNumber = 2,
+    kStartTimeNsFieldNumber = 3,
+    kEndTimeNsFieldNumber = 4,
+    kTotalActiveDurationNsFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.GpuWorkPeriodFtraceEvent"; }
+
+
+  using FieldMetadata_GpuId =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Vb2V4l2DqbufFtraceEvent>;
+      GpuWorkPeriodFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits0 kTimecodeUserbits0() { return {}; }
-  void set_timecode_userbits0(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits0::kFieldId;
+  static constexpr FieldMetadata_GpuId kGpuId{};
+  void set_gpu_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GpuId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -127237,24 +152381,17 @@ class Vb2V4l2DqbufFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeUserbits1 =
+  using FieldMetadata_Uid =
     ::protozero::proto_utils::FieldMetadata<
-      12,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Vb2V4l2DqbufFtraceEvent>;
+      GpuWorkPeriodFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits1 kTimecodeUserbits1() { return {}; }
-  void set_timecode_userbits1(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits1::kFieldId;
+  static constexpr FieldMetadata_Uid kUid{};
+  void set_uid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -127262,260 +152399,221 @@ class Vb2V4l2DqbufFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeUserbits2 =
+  using FieldMetadata_StartTimeNs =
     ::protozero::proto_utils::FieldMetadata<
-      13,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      GpuWorkPeriodFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits2 kTimecodeUserbits2() { return {}; }
-  void set_timecode_userbits2(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits2::kFieldId;
+  static constexpr FieldMetadata_StartTimeNs kStartTimeNs{};
+  void set_start_time_ns(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StartTimeNs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeUserbits3 =
+  using FieldMetadata_EndTimeNs =
     ::protozero::proto_utils::FieldMetadata<
-      14,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      GpuWorkPeriodFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits3 kTimecodeUserbits3() { return {}; }
-  void set_timecode_userbits3(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits3::kFieldId;
+  static constexpr FieldMetadata_EndTimeNs kEndTimeNs{};
+  void set_end_time_ns(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EndTimeNs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Timestamp =
+  using FieldMetadata_TotalActiveDurationNs =
     ::protozero::proto_utils::FieldMetadata<
-      15,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Vb2V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      GpuWorkPeriodFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timestamp kTimestamp() { return {}; }
-  void set_timestamp(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+  static constexpr FieldMetadata_TotalActiveDurationNs kTotalActiveDurationNs{};
+  void set_total_active_duration_ns(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TotalActiveDurationNs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class Vb2V4l2QbufFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/15, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class WakeupSourceDeactivateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  Vb2V4l2QbufFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Vb2V4l2QbufFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Vb2V4l2QbufFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_field() const { return at<1>().valid(); }
-  uint32_t field() const { return at<1>().as_uint32(); }
-  bool has_flags() const { return at<2>().valid(); }
-  uint32_t flags() const { return at<2>().as_uint32(); }
-  bool has_minor() const { return at<3>().valid(); }
-  int32_t minor() const { return at<3>().as_int32(); }
-  bool has_sequence() const { return at<4>().valid(); }
-  uint32_t sequence() const { return at<4>().as_uint32(); }
-  bool has_timecode_flags() const { return at<5>().valid(); }
-  uint32_t timecode_flags() const { return at<5>().as_uint32(); }
-  bool has_timecode_frames() const { return at<6>().valid(); }
-  uint32_t timecode_frames() const { return at<6>().as_uint32(); }
-  bool has_timecode_hours() const { return at<7>().valid(); }
-  uint32_t timecode_hours() const { return at<7>().as_uint32(); }
-  bool has_timecode_minutes() const { return at<8>().valid(); }
-  uint32_t timecode_minutes() const { return at<8>().as_uint32(); }
-  bool has_timecode_seconds() const { return at<9>().valid(); }
-  uint32_t timecode_seconds() const { return at<9>().as_uint32(); }
-  bool has_timecode_type() const { return at<10>().valid(); }
-  uint32_t timecode_type() const { return at<10>().as_uint32(); }
-  bool has_timecode_userbits0() const { return at<11>().valid(); }
-  uint32_t timecode_userbits0() const { return at<11>().as_uint32(); }
-  bool has_timecode_userbits1() const { return at<12>().valid(); }
-  uint32_t timecode_userbits1() const { return at<12>().as_uint32(); }
-  bool has_timecode_userbits2() const { return at<13>().valid(); }
-  uint32_t timecode_userbits2() const { return at<13>().as_uint32(); }
-  bool has_timecode_userbits3() const { return at<14>().valid(); }
-  uint32_t timecode_userbits3() const { return at<14>().as_uint32(); }
-  bool has_timestamp() const { return at<15>().valid(); }
-  int64_t timestamp() const { return at<15>().as_int64(); }
+  WakeupSourceDeactivateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit WakeupSourceDeactivateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit WakeupSourceDeactivateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_state() const { return at<2>().valid(); }
+  uint64_t state() const { return at<2>().as_uint64(); }
 };
 
-class Vb2V4l2QbufFtraceEvent : public ::protozero::Message {
+class WakeupSourceDeactivateFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Vb2V4l2QbufFtraceEvent_Decoder;
+  using Decoder = WakeupSourceDeactivateFtraceEvent_Decoder;
   enum : int32_t {
-    kFieldFieldNumber = 1,
-    kFlagsFieldNumber = 2,
-    kMinorFieldNumber = 3,
-    kSequenceFieldNumber = 4,
-    kTimecodeFlagsFieldNumber = 5,
-    kTimecodeFramesFieldNumber = 6,
-    kTimecodeHoursFieldNumber = 7,
-    kTimecodeMinutesFieldNumber = 8,
-    kTimecodeSecondsFieldNumber = 9,
-    kTimecodeTypeFieldNumber = 10,
-    kTimecodeUserbits0FieldNumber = 11,
-    kTimecodeUserbits1FieldNumber = 12,
-    kTimecodeUserbits2FieldNumber = 13,
-    kTimecodeUserbits3FieldNumber = 14,
-    kTimestampFieldNumber = 15,
+    kNameFieldNumber = 1,
+    kStateFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Vb2V4l2QbufFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.WakeupSourceDeactivateFtraceEvent"; }
 
 
-  using FieldMetadata_Field =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      WakeupSourceDeactivateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Field kField() { return {}; }
-  void set_field(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Field::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_State =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      WakeupSourceDeactivateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_State kState{};
+  void set_state(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Minor =
+class WakeupSourceActivateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  WakeupSourceActivateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit WakeupSourceActivateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit WakeupSourceActivateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_state() const { return at<2>().valid(); }
+  uint64_t state() const { return at<2>().as_uint64(); }
+};
+
+class WakeupSourceActivateFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = WakeupSourceActivateFtraceEvent_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kStateFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.WakeupSourceActivateFtraceEvent"; }
+
+
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Vb2V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      WakeupSourceActivateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Minor kMinor() { return {}; }
-  void set_minor(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Minor::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Sequence =
+  using FieldMetadata_State =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      WakeupSourceActivateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sequence kSequence() { return {}; }
-  void set_sequence(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Sequence::kFieldId;
+  static constexpr FieldMetadata_State kState{};
+  void set_state(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TimecodeFlags =
+class GpuFrequencyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  GpuFrequencyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GpuFrequencyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GpuFrequencyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_gpu_id() const { return at<1>().valid(); }
+  uint32_t gpu_id() const { return at<1>().as_uint32(); }
+  bool has_state() const { return at<2>().valid(); }
+  uint32_t state() const { return at<2>().as_uint32(); }
+};
+
+class GpuFrequencyFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = GpuFrequencyFtraceEvent_Decoder;
+  enum : int32_t {
+    kGpuIdFieldNumber = 1,
+    kStateFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.GpuFrequencyFtraceEvent"; }
+
+
+  using FieldMetadata_GpuId =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Vb2V4l2QbufFtraceEvent>;
+      GpuFrequencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeFlags kTimecodeFlags() { return {}; }
-  void set_timecode_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeFlags::kFieldId;
+  static constexpr FieldMetadata_GpuId kGpuId{};
+  void set_gpu_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GpuId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -127523,335 +152621,397 @@ class Vb2V4l2QbufFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeFrames =
+  using FieldMetadata_State =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Vb2V4l2QbufFtraceEvent>;
+      GpuFrequencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeFrames kTimecodeFrames() { return {}; }
-  void set_timecode_frames(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeFrames::kFieldId;
+  static constexpr FieldMetadata_State kState{};
+  void set_state(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TimecodeHours =
+class SuspendResumeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  SuspendResumeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SuspendResumeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SuspendResumeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_action() const { return at<1>().valid(); }
+  ::protozero::ConstChars action() const { return at<1>().as_string(); }
+  bool has_val() const { return at<2>().valid(); }
+  int32_t val() const { return at<2>().as_int32(); }
+  bool has_start() const { return at<3>().valid(); }
+  uint32_t start() const { return at<3>().as_uint32(); }
+};
+
+class SuspendResumeFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = SuspendResumeFtraceEvent_Decoder;
+  enum : int32_t {
+    kActionFieldNumber = 1,
+    kValFieldNumber = 2,
+    kStartFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SuspendResumeFtraceEvent"; }
+
+
+  using FieldMetadata_Action =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SuspendResumeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeHours kTimecodeHours() { return {}; }
-  void set_timecode_hours(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeHours::kFieldId;
+  static constexpr FieldMetadata_Action kAction{};
+  void set_action(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Action::kFieldId, data, size);
+  }
+  void set_action(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Action::kFieldId, chars.data, chars.size);
+  }
+  void set_action(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Action::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeMinutes =
+  using FieldMetadata_Val =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SuspendResumeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeMinutes kTimecodeMinutes() { return {}; }
-  void set_timecode_minutes(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeMinutes::kFieldId;
+  static constexpr FieldMetadata_Val kVal{};
+  void set_val(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Val::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeSeconds =
+  using FieldMetadata_Start =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Vb2V4l2QbufFtraceEvent>;
+      SuspendResumeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeSeconds kTimecodeSeconds() { return {}; }
-  void set_timecode_seconds(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeSeconds::kFieldId;
+  static constexpr FieldMetadata_Start kStart{};
+  void set_start(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TimecodeType =
+class ClockSetRateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  ClockSetRateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ClockSetRateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ClockSetRateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_state() const { return at<2>().valid(); }
+  uint64_t state() const { return at<2>().as_uint64(); }
+  bool has_cpu_id() const { return at<3>().valid(); }
+  uint64_t cpu_id() const { return at<3>().as_uint64(); }
+};
+
+class ClockSetRateFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = ClockSetRateFtraceEvent_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kStateFieldNumber = 2,
+    kCpuIdFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ClockSetRateFtraceEvent"; }
+
+
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ClockSetRateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeType kTimecodeType() { return {}; }
-  void set_timecode_type(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeType::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeUserbits0 =
+  using FieldMetadata_State =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ClockSetRateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits0 kTimecodeUserbits0() { return {}; }
-  void set_timecode_userbits0(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits0::kFieldId;
+  static constexpr FieldMetadata_State kState{};
+  void set_state(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeUserbits1 =
+  using FieldMetadata_CpuId =
     ::protozero::proto_utils::FieldMetadata<
-      12,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ClockSetRateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits1 kTimecodeUserbits1() { return {}; }
-  void set_timecode_userbits1(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits1::kFieldId;
+  static constexpr FieldMetadata_CpuId kCpuId{};
+  void set_cpu_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CpuId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TimecodeUserbits2 =
+class ClockDisableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  ClockDisableFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ClockDisableFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ClockDisableFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_state() const { return at<2>().valid(); }
+  uint64_t state() const { return at<2>().as_uint64(); }
+  bool has_cpu_id() const { return at<3>().valid(); }
+  uint64_t cpu_id() const { return at<3>().as_uint64(); }
+};
+
+class ClockDisableFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = ClockDisableFtraceEvent_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kStateFieldNumber = 2,
+    kCpuIdFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ClockDisableFtraceEvent"; }
+
+
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
-      13,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ClockDisableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits2 kTimecodeUserbits2() { return {}; }
-  void set_timecode_userbits2(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits2::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeUserbits3 =
+  using FieldMetadata_State =
     ::protozero::proto_utils::FieldMetadata<
-      14,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ClockDisableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits3 kTimecodeUserbits3() { return {}; }
-  void set_timecode_userbits3(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits3::kFieldId;
+  static constexpr FieldMetadata_State kState{};
+  void set_state(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Timestamp =
+  using FieldMetadata_CpuId =
     ::protozero::proto_utils::FieldMetadata<
-      15,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Vb2V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ClockDisableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timestamp kTimestamp() { return {}; }
-  void set_timestamp(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+  static constexpr FieldMetadata_CpuId kCpuId{};
+  void set_cpu_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CpuId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class Vb2V4l2BufDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/15, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class ClockEnableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  Vb2V4l2BufDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Vb2V4l2BufDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Vb2V4l2BufDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_field() const { return at<1>().valid(); }
-  uint32_t field() const { return at<1>().as_uint32(); }
-  bool has_flags() const { return at<2>().valid(); }
-  uint32_t flags() const { return at<2>().as_uint32(); }
-  bool has_minor() const { return at<3>().valid(); }
-  int32_t minor() const { return at<3>().as_int32(); }
-  bool has_sequence() const { return at<4>().valid(); }
-  uint32_t sequence() const { return at<4>().as_uint32(); }
-  bool has_timecode_flags() const { return at<5>().valid(); }
-  uint32_t timecode_flags() const { return at<5>().as_uint32(); }
-  bool has_timecode_frames() const { return at<6>().valid(); }
-  uint32_t timecode_frames() const { return at<6>().as_uint32(); }
-  bool has_timecode_hours() const { return at<7>().valid(); }
-  uint32_t timecode_hours() const { return at<7>().as_uint32(); }
-  bool has_timecode_minutes() const { return at<8>().valid(); }
-  uint32_t timecode_minutes() const { return at<8>().as_uint32(); }
-  bool has_timecode_seconds() const { return at<9>().valid(); }
-  uint32_t timecode_seconds() const { return at<9>().as_uint32(); }
-  bool has_timecode_type() const { return at<10>().valid(); }
-  uint32_t timecode_type() const { return at<10>().as_uint32(); }
-  bool has_timecode_userbits0() const { return at<11>().valid(); }
-  uint32_t timecode_userbits0() const { return at<11>().as_uint32(); }
-  bool has_timecode_userbits1() const { return at<12>().valid(); }
-  uint32_t timecode_userbits1() const { return at<12>().as_uint32(); }
-  bool has_timecode_userbits2() const { return at<13>().valid(); }
-  uint32_t timecode_userbits2() const { return at<13>().as_uint32(); }
-  bool has_timecode_userbits3() const { return at<14>().valid(); }
-  uint32_t timecode_userbits3() const { return at<14>().as_uint32(); }
-  bool has_timestamp() const { return at<15>().valid(); }
-  int64_t timestamp() const { return at<15>().as_int64(); }
+  ClockEnableFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ClockEnableFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ClockEnableFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_state() const { return at<2>().valid(); }
+  uint64_t state() const { return at<2>().as_uint64(); }
+  bool has_cpu_id() const { return at<3>().valid(); }
+  uint64_t cpu_id() const { return at<3>().as_uint64(); }
 };
 
-class Vb2V4l2BufDoneFtraceEvent : public ::protozero::Message {
+class ClockEnableFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Vb2V4l2BufDoneFtraceEvent_Decoder;
+  using Decoder = ClockEnableFtraceEvent_Decoder;
   enum : int32_t {
-    kFieldFieldNumber = 1,
-    kFlagsFieldNumber = 2,
-    kMinorFieldNumber = 3,
-    kSequenceFieldNumber = 4,
-    kTimecodeFlagsFieldNumber = 5,
-    kTimecodeFramesFieldNumber = 6,
-    kTimecodeHoursFieldNumber = 7,
-    kTimecodeMinutesFieldNumber = 8,
-    kTimecodeSecondsFieldNumber = 9,
-    kTimecodeTypeFieldNumber = 10,
-    kTimecodeUserbits0FieldNumber = 11,
-    kTimecodeUserbits1FieldNumber = 12,
-    kTimecodeUserbits2FieldNumber = 13,
-    kTimecodeUserbits3FieldNumber = 14,
-    kTimestampFieldNumber = 15,
+    kNameFieldNumber = 1,
+    kStateFieldNumber = 2,
+    kCpuIdFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ClockEnableFtraceEvent"; }
+
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ClockEnableFtraceEvent>;
+
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_State =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ClockEnableFtraceEvent>;
+
+  static constexpr FieldMetadata_State kState{};
+  void set_state(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CpuId =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ClockEnableFtraceEvent>;
+
+  static constexpr FieldMetadata_CpuId kCpuId{};
+  void set_cpu_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CpuId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class CpuIdleFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  CpuIdleFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit CpuIdleFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit CpuIdleFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_state() const { return at<1>().valid(); }
+  uint32_t state() const { return at<1>().as_uint32(); }
+  bool has_cpu_id() const { return at<2>().valid(); }
+  uint32_t cpu_id() const { return at<2>().as_uint32(); }
+};
+
+class CpuIdleFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = CpuIdleFtraceEvent_Decoder;
+  enum : int32_t {
+    kStateFieldNumber = 1,
+    kCpuIdFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Vb2V4l2BufDoneFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.CpuIdleFtraceEvent"; }
 
 
-  using FieldMetadata_Field =
+  using FieldMetadata_State =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Vb2V4l2BufDoneFtraceEvent>;
+      CpuIdleFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Field kField() { return {}; }
-  void set_field(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Field::kFieldId;
+  static constexpr FieldMetadata_State kState{};
+  void set_state(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -127859,74 +153019,60 @@ class Vb2V4l2BufDoneFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_CpuId =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Vb2V4l2BufDoneFtraceEvent>;
+      CpuIdleFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_CpuId kCpuId{};
+  void set_cpu_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CpuId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Minor =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      Vb2V4l2BufDoneFtraceEvent>;
+class CpuFrequencyLimitsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  CpuFrequencyLimitsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit CpuFrequencyLimitsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit CpuFrequencyLimitsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_min_freq() const { return at<1>().valid(); }
+  uint32_t min_freq() const { return at<1>().as_uint32(); }
+  bool has_max_freq() const { return at<2>().valid(); }
+  uint32_t max_freq() const { return at<2>().as_uint32(); }
+  bool has_cpu_id() const { return at<3>().valid(); }
+  uint32_t cpu_id() const { return at<3>().as_uint32(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Minor kMinor() { return {}; }
-  void set_minor(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Minor::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+class CpuFrequencyLimitsFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = CpuFrequencyLimitsFtraceEvent_Decoder;
+  enum : int32_t {
+    kMinFreqFieldNumber = 1,
+    kMaxFreqFieldNumber = 2,
+    kCpuIdFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.CpuFrequencyLimitsFtraceEvent"; }
 
-  using FieldMetadata_Sequence =
+
+  using FieldMetadata_MinFreq =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Vb2V4l2BufDoneFtraceEvent>;
+      CpuFrequencyLimitsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sequence kSequence() { return {}; }
-  void set_sequence(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Sequence::kFieldId;
+  static constexpr FieldMetadata_MinFreq kMinFreq{};
+  void set_min_freq(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MinFreq::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -127934,24 +153080,17 @@ class Vb2V4l2BufDoneFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeFlags =
+  using FieldMetadata_MaxFreq =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Vb2V4l2BufDoneFtraceEvent>;
+      CpuFrequencyLimitsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeFlags kTimecodeFlags() { return {}; }
-  void set_timecode_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeFlags::kFieldId;
+  static constexpr FieldMetadata_MaxFreq kMaxFreq{};
+  void set_max_freq(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MaxFreq::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -127959,49 +153098,57 @@ class Vb2V4l2BufDoneFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeFrames =
+  using FieldMetadata_CpuId =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Vb2V4l2BufDoneFtraceEvent>;
+      CpuFrequencyLimitsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeFrames kTimecodeFrames() { return {}; }
-  void set_timecode_frames(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeFrames::kFieldId;
+  static constexpr FieldMetadata_CpuId kCpuId{};
+  void set_cpu_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CpuId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TimecodeHours =
+class CpuFrequencyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  CpuFrequencyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit CpuFrequencyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit CpuFrequencyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_state() const { return at<1>().valid(); }
+  uint32_t state() const { return at<1>().as_uint32(); }
+  bool has_cpu_id() const { return at<2>().valid(); }
+  uint32_t cpu_id() const { return at<2>().as_uint32(); }
+};
+
+class CpuFrequencyFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = CpuFrequencyFtraceEvent_Decoder;
+  enum : int32_t {
+    kStateFieldNumber = 1,
+    kCpuIdFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.CpuFrequencyFtraceEvent"; }
+
+
+  using FieldMetadata_State =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Vb2V4l2BufDoneFtraceEvent>;
+      CpuFrequencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeHours kTimecodeHours() { return {}; }
-  void set_timecode_hours(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeHours::kFieldId;
+  static constexpr FieldMetadata_State kState{};
+  void set_state(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -128009,585 +153156,815 @@ class Vb2V4l2BufDoneFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeMinutes =
+  using FieldMetadata_CpuId =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Vb2V4l2BufDoneFtraceEvent>;
+      CpuFrequencyFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeMinutes kTimecodeMinutes() { return {}; }
-  void set_timecode_minutes(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeMinutes::kFieldId;
+  static constexpr FieldMetadata_CpuId kCpuId{};
+  void set_cpu_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CpuId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TimecodeSeconds =
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/printk.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_PRINTK_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_PRINTK_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class ConsoleFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  ConsoleFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ConsoleFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ConsoleFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_msg() const { return at<1>().valid(); }
+  ::protozero::ConstChars msg() const { return at<1>().as_string(); }
+};
+
+class ConsoleFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = ConsoleFtraceEvent_Decoder;
+  enum : int32_t {
+    kMsgFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ConsoleFtraceEvent"; }
+
+
+  using FieldMetadata_Msg =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2BufDoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ConsoleFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeSeconds kTimecodeSeconds() { return {}; }
-  void set_timecode_seconds(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeSeconds::kFieldId;
+  static constexpr FieldMetadata_Msg kMsg{};
+  void set_msg(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Msg::kFieldId, data, size);
+  }
+  void set_msg(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Msg::kFieldId, chars.data, chars.size);
+  }
+  void set_msg(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Msg::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TimecodeType =
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/raw_syscalls.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_RAW_SYSCALLS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_RAW_SYSCALLS_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class SysExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  SysExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SysExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SysExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  int64_t id() const { return at<1>().as_int64(); }
+  bool has_ret() const { return at<2>().valid(); }
+  int64_t ret() const { return at<2>().as_int64(); }
+};
+
+class SysExitFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = SysExitFtraceEvent_Decoder;
+  enum : int32_t {
+    kIdFieldNumber = 1,
+    kRetFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SysExitFtraceEvent"; }
+
+
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2BufDoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      SysExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeType kTimecodeType() { return {}; }
-  void set_timecode_type(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeType::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeUserbits0 =
+  using FieldMetadata_Ret =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2BufDoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      SysExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits0 kTimecodeUserbits0() { return {}; }
-  void set_timecode_userbits0(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits0::kFieldId;
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TimecodeUserbits1 =
+class SysEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  SysEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SysEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SysEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  int64_t id() const { return at<1>().as_int64(); }
+  bool has_args() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint64_t> args() const { return GetRepeated<uint64_t>(2); }
+};
+
+class SysEnterFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = SysEnterFtraceEvent_Decoder;
+  enum : int32_t {
+    kIdFieldNumber = 1,
+    kArgsFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SysEnterFtraceEvent"; }
+
+
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
-      12,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2BufDoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      SysEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits1 kTimecodeUserbits1() { return {}; }
-  void set_timecode_userbits1(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits1::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeUserbits2 =
+  using FieldMetadata_Args =
     ::protozero::proto_utils::FieldMetadata<
-      13,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2BufDoneFtraceEvent>;
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysEnterFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits2 kTimecodeUserbits2() { return {}; }
-  void set_timecode_userbits2(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits2::kFieldId;
+  static constexpr FieldMetadata_Args kArgs{};
+  void add_args(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Args::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TimecodeUserbits3 =
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/regulator.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_REGULATOR_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_REGULATOR_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class RegulatorSetVoltageCompleteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  RegulatorSetVoltageCompleteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit RegulatorSetVoltageCompleteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit RegulatorSetVoltageCompleteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_val() const { return at<2>().valid(); }
+  uint32_t val() const { return at<2>().as_uint32(); }
+};
+
+class RegulatorSetVoltageCompleteFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = RegulatorSetVoltageCompleteFtraceEvent_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kValFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.RegulatorSetVoltageCompleteFtraceEvent"; }
+
+
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
-      14,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2BufDoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      RegulatorSetVoltageCompleteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits3 kTimecodeUserbits3() { return {}; }
-  void set_timecode_userbits3(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits3::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Timestamp =
+  using FieldMetadata_Val =
     ::protozero::proto_utils::FieldMetadata<
-      15,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Vb2V4l2BufDoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      RegulatorSetVoltageCompleteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timestamp kTimestamp() { return {}; }
-  void set_timestamp(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+  static constexpr FieldMetadata_Val kVal{};
+  void set_val(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Val::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class Vb2V4l2BufQueueFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/15, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class RegulatorSetVoltageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  Vb2V4l2BufQueueFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Vb2V4l2BufQueueFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Vb2V4l2BufQueueFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_field() const { return at<1>().valid(); }
-  uint32_t field() const { return at<1>().as_uint32(); }
-  bool has_flags() const { return at<2>().valid(); }
-  uint32_t flags() const { return at<2>().as_uint32(); }
-  bool has_minor() const { return at<3>().valid(); }
-  int32_t minor() const { return at<3>().as_int32(); }
-  bool has_sequence() const { return at<4>().valid(); }
-  uint32_t sequence() const { return at<4>().as_uint32(); }
-  bool has_timecode_flags() const { return at<5>().valid(); }
-  uint32_t timecode_flags() const { return at<5>().as_uint32(); }
-  bool has_timecode_frames() const { return at<6>().valid(); }
-  uint32_t timecode_frames() const { return at<6>().as_uint32(); }
-  bool has_timecode_hours() const { return at<7>().valid(); }
-  uint32_t timecode_hours() const { return at<7>().as_uint32(); }
-  bool has_timecode_minutes() const { return at<8>().valid(); }
-  uint32_t timecode_minutes() const { return at<8>().as_uint32(); }
-  bool has_timecode_seconds() const { return at<9>().valid(); }
-  uint32_t timecode_seconds() const { return at<9>().as_uint32(); }
-  bool has_timecode_type() const { return at<10>().valid(); }
-  uint32_t timecode_type() const { return at<10>().as_uint32(); }
-  bool has_timecode_userbits0() const { return at<11>().valid(); }
-  uint32_t timecode_userbits0() const { return at<11>().as_uint32(); }
-  bool has_timecode_userbits1() const { return at<12>().valid(); }
-  uint32_t timecode_userbits1() const { return at<12>().as_uint32(); }
-  bool has_timecode_userbits2() const { return at<13>().valid(); }
-  uint32_t timecode_userbits2() const { return at<13>().as_uint32(); }
-  bool has_timecode_userbits3() const { return at<14>().valid(); }
-  uint32_t timecode_userbits3() const { return at<14>().as_uint32(); }
-  bool has_timestamp() const { return at<15>().valid(); }
-  int64_t timestamp() const { return at<15>().as_int64(); }
+  RegulatorSetVoltageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit RegulatorSetVoltageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit RegulatorSetVoltageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_min() const { return at<2>().valid(); }
+  int32_t min() const { return at<2>().as_int32(); }
+  bool has_max() const { return at<3>().valid(); }
+  int32_t max() const { return at<3>().as_int32(); }
 };
 
-class Vb2V4l2BufQueueFtraceEvent : public ::protozero::Message {
+class RegulatorSetVoltageFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Vb2V4l2BufQueueFtraceEvent_Decoder;
+  using Decoder = RegulatorSetVoltageFtraceEvent_Decoder;
   enum : int32_t {
-    kFieldFieldNumber = 1,
-    kFlagsFieldNumber = 2,
-    kMinorFieldNumber = 3,
-    kSequenceFieldNumber = 4,
-    kTimecodeFlagsFieldNumber = 5,
-    kTimecodeFramesFieldNumber = 6,
-    kTimecodeHoursFieldNumber = 7,
-    kTimecodeMinutesFieldNumber = 8,
-    kTimecodeSecondsFieldNumber = 9,
-    kTimecodeTypeFieldNumber = 10,
-    kTimecodeUserbits0FieldNumber = 11,
-    kTimecodeUserbits1FieldNumber = 12,
-    kTimecodeUserbits2FieldNumber = 13,
-    kTimecodeUserbits3FieldNumber = 14,
-    kTimestampFieldNumber = 15,
+    kNameFieldNumber = 1,
+    kMinFieldNumber = 2,
+    kMaxFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Vb2V4l2BufQueueFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.RegulatorSetVoltageFtraceEvent"; }
 
 
-  using FieldMetadata_Field =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2BufQueueFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      RegulatorSetVoltageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Field kField() { return {}; }
-  void set_field(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Field::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_Min =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2BufQueueFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      RegulatorSetVoltageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_Min kMin{};
+  void set_min(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Min::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Minor =
+  using FieldMetadata_Max =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      Vb2V4l2BufQueueFtraceEvent>;
+      RegulatorSetVoltageFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Minor kMinor() { return {}; }
-  void set_minor(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Minor::kFieldId;
+  static constexpr FieldMetadata_Max kMax{};
+  void set_max(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Max::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Sequence =
+class RegulatorEnableDelayFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  RegulatorEnableDelayFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit RegulatorEnableDelayFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit RegulatorEnableDelayFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+};
+
+class RegulatorEnableDelayFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = RegulatorEnableDelayFtraceEvent_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.RegulatorEnableDelayFtraceEvent"; }
+
+
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2BufQueueFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      RegulatorEnableDelayFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sequence kSequence() { return {}; }
-  void set_sequence(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Sequence::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TimecodeFlags =
+class RegulatorEnableCompleteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  RegulatorEnableCompleteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit RegulatorEnableCompleteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit RegulatorEnableCompleteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+};
+
+class RegulatorEnableCompleteFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = RegulatorEnableCompleteFtraceEvent_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.RegulatorEnableCompleteFtraceEvent"; }
+
+
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2BufQueueFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      RegulatorEnableCompleteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeFlags kTimecodeFlags() { return {}; }
-  void set_timecode_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeFlags::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TimecodeFrames =
+class RegulatorEnableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  RegulatorEnableFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit RegulatorEnableFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit RegulatorEnableFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+};
+
+class RegulatorEnableFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = RegulatorEnableFtraceEvent_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.RegulatorEnableFtraceEvent"; }
+
+
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2BufQueueFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      RegulatorEnableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeFrames kTimecodeFrames() { return {}; }
-  void set_timecode_frames(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeFrames::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TimecodeHours =
+class RegulatorDisableCompleteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  RegulatorDisableCompleteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit RegulatorDisableCompleteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit RegulatorDisableCompleteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+};
+
+class RegulatorDisableCompleteFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = RegulatorDisableCompleteFtraceEvent_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.RegulatorDisableCompleteFtraceEvent"; }
+
+
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2BufQueueFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      RegulatorDisableCompleteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeHours kTimecodeHours() { return {}; }
-  void set_timecode_hours(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeHours::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TimecodeMinutes =
+class RegulatorDisableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  RegulatorDisableFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit RegulatorDisableFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit RegulatorDisableFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+};
+
+class RegulatorDisableFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = RegulatorDisableFtraceEvent_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.RegulatorDisableFtraceEvent"; }
+
+
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2BufQueueFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      RegulatorDisableFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeMinutes kTimecodeMinutes() { return {}; }
-  void set_timecode_minutes(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeMinutes::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TimecodeSeconds =
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/rpm.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_RPM_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_RPM_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class RpmStatusFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  RpmStatusFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit RpmStatusFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit RpmStatusFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_status() const { return at<2>().valid(); }
+  int32_t status() const { return at<2>().as_int32(); }
+};
+
+class RpmStatusFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = RpmStatusFtraceEvent_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kStatusFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.RpmStatusFtraceEvent"; }
+
+
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2BufQueueFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      RpmStatusFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeSeconds kTimecodeSeconds() { return {}; }
-  void set_timecode_seconds(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeSeconds::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeType =
+  using FieldMetadata_Status =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2BufQueueFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      RpmStatusFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeType kTimecodeType() { return {}; }
-  void set_timecode_type(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeType::kFieldId;
+  static constexpr FieldMetadata_Status kStatus{};
+  void set_status(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TimecodeUserbits0 =
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/samsung.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SAMSUNG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SAMSUNG_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class SamsungTracingMarkWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  SamsungTracingMarkWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SamsungTracingMarkWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SamsungTracingMarkWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  int32_t pid() const { return at<1>().as_int32(); }
+  bool has_trace_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars trace_name() const { return at<2>().as_string(); }
+  bool has_trace_begin() const { return at<3>().valid(); }
+  uint32_t trace_begin() const { return at<3>().as_uint32(); }
+  bool has_trace_type() const { return at<4>().valid(); }
+  uint32_t trace_type() const { return at<4>().as_uint32(); }
+  bool has_value() const { return at<5>().valid(); }
+  int32_t value() const { return at<5>().as_int32(); }
+};
+
+class SamsungTracingMarkWriteFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = SamsungTracingMarkWriteFtraceEvent_Decoder;
+  enum : int32_t {
+    kPidFieldNumber = 1,
+    kTraceNameFieldNumber = 2,
+    kTraceBeginFieldNumber = 3,
+    kTraceTypeFieldNumber = 4,
+    kValueFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SamsungTracingMarkWriteFtraceEvent"; }
+
+
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2BufQueueFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SamsungTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits0 kTimecodeUserbits0() { return {}; }
-  void set_timecode_userbits0(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits0::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeUserbits1 =
+  using FieldMetadata_TraceName =
     ::protozero::proto_utils::FieldMetadata<
-      12,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      Vb2V4l2BufQueueFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SamsungTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits1 kTimecodeUserbits1() { return {}; }
-  void set_timecode_userbits1(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits1::kFieldId;
+  static constexpr FieldMetadata_TraceName kTraceName{};
+  void set_trace_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_TraceName::kFieldId, data, size);
+  }
+  void set_trace_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_TraceName::kFieldId, chars.data, chars.size);
+  }
+  void set_trace_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_TraceName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeUserbits2 =
+  using FieldMetadata_TraceBegin =
     ::protozero::proto_utils::FieldMetadata<
-      13,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Vb2V4l2BufQueueFtraceEvent>;
+      SamsungTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits2 kTimecodeUserbits2() { return {}; }
-  void set_timecode_userbits2(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits2::kFieldId;
+  static constexpr FieldMetadata_TraceBegin kTraceBegin{};
+  void set_trace_begin(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TraceBegin::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -128595,24 +153972,17 @@ class Vb2V4l2BufQueueFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeUserbits3 =
+  using FieldMetadata_TraceType =
     ::protozero::proto_utils::FieldMetadata<
-      14,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Vb2V4l2BufQueueFtraceEvent>;
+      SamsungTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits3 kTimecodeUserbits3() { return {}; }
-  void set_timecode_userbits3(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits3::kFieldId;
+  static constexpr FieldMetadata_TraceType kTraceType{};
+  void set_trace_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TraceType::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -128620,219 +153990,259 @@ class Vb2V4l2BufQueueFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Timestamp =
+  using FieldMetadata_Value =
     ::protozero::proto_utils::FieldMetadata<
-      15,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      Vb2V4l2BufQueueFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SamsungTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timestamp kTimestamp() { return {}; }
-  void set_timestamp(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class V4l2DqbufFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/18, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/sched.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SCHED_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SCHED_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class SchedWakeupTaskAttrFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  V4l2DqbufFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit V4l2DqbufFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit V4l2DqbufFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_bytesused() const { return at<1>().valid(); }
-  uint32_t bytesused() const { return at<1>().as_uint32(); }
-  bool has_field() const { return at<2>().valid(); }
-  uint32_t field() const { return at<2>().as_uint32(); }
-  bool has_flags() const { return at<3>().valid(); }
-  uint32_t flags() const { return at<3>().as_uint32(); }
-  bool has_index() const { return at<4>().valid(); }
-  uint32_t index() const { return at<4>().as_uint32(); }
-  bool has_minor() const { return at<5>().valid(); }
-  int32_t minor() const { return at<5>().as_int32(); }
-  bool has_sequence() const { return at<6>().valid(); }
-  uint32_t sequence() const { return at<6>().as_uint32(); }
-  bool has_timecode_flags() const { return at<7>().valid(); }
-  uint32_t timecode_flags() const { return at<7>().as_uint32(); }
-  bool has_timecode_frames() const { return at<8>().valid(); }
-  uint32_t timecode_frames() const { return at<8>().as_uint32(); }
-  bool has_timecode_hours() const { return at<9>().valid(); }
-  uint32_t timecode_hours() const { return at<9>().as_uint32(); }
-  bool has_timecode_minutes() const { return at<10>().valid(); }
-  uint32_t timecode_minutes() const { return at<10>().as_uint32(); }
-  bool has_timecode_seconds() const { return at<11>().valid(); }
-  uint32_t timecode_seconds() const { return at<11>().as_uint32(); }
-  bool has_timecode_type() const { return at<12>().valid(); }
-  uint32_t timecode_type() const { return at<12>().as_uint32(); }
-  bool has_timecode_userbits0() const { return at<13>().valid(); }
-  uint32_t timecode_userbits0() const { return at<13>().as_uint32(); }
-  bool has_timecode_userbits1() const { return at<14>().valid(); }
-  uint32_t timecode_userbits1() const { return at<14>().as_uint32(); }
-  bool has_timecode_userbits2() const { return at<15>().valid(); }
-  uint32_t timecode_userbits2() const { return at<15>().as_uint32(); }
-  bool has_timecode_userbits3() const { return at<16>().valid(); }
-  uint32_t timecode_userbits3() const { return at<16>().as_uint32(); }
-  bool has_timestamp() const { return at<17>().valid(); }
-  int64_t timestamp() const { return at<17>().as_int64(); }
-  bool has_type() const { return at<18>().valid(); }
-  uint32_t type() const { return at<18>().as_uint32(); }
+  SchedWakeupTaskAttrFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SchedWakeupTaskAttrFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SchedWakeupTaskAttrFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  int32_t pid() const { return at<1>().as_int32(); }
+  bool has_cpu_affinity() const { return at<2>().valid(); }
+  uint64_t cpu_affinity() const { return at<2>().as_uint64(); }
+  bool has_task_util() const { return at<3>().valid(); }
+  uint64_t task_util() const { return at<3>().as_uint64(); }
+  bool has_uclamp_min() const { return at<4>().valid(); }
+  uint64_t uclamp_min() const { return at<4>().as_uint64(); }
+  bool has_vruntime() const { return at<5>().valid(); }
+  uint64_t vruntime() const { return at<5>().as_uint64(); }
 };
 
-class V4l2DqbufFtraceEvent : public ::protozero::Message {
+class SchedWakeupTaskAttrFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = V4l2DqbufFtraceEvent_Decoder;
+  using Decoder = SchedWakeupTaskAttrFtraceEvent_Decoder;
   enum : int32_t {
-    kBytesusedFieldNumber = 1,
-    kFieldFieldNumber = 2,
-    kFlagsFieldNumber = 3,
-    kIndexFieldNumber = 4,
-    kMinorFieldNumber = 5,
-    kSequenceFieldNumber = 6,
-    kTimecodeFlagsFieldNumber = 7,
-    kTimecodeFramesFieldNumber = 8,
-    kTimecodeHoursFieldNumber = 9,
-    kTimecodeMinutesFieldNumber = 10,
-    kTimecodeSecondsFieldNumber = 11,
-    kTimecodeTypeFieldNumber = 12,
-    kTimecodeUserbits0FieldNumber = 13,
-    kTimecodeUserbits1FieldNumber = 14,
-    kTimecodeUserbits2FieldNumber = 15,
-    kTimecodeUserbits3FieldNumber = 16,
-    kTimestampFieldNumber = 17,
-    kTypeFieldNumber = 18,
+    kPidFieldNumber = 1,
+    kCpuAffinityFieldNumber = 2,
+    kTaskUtilFieldNumber = 3,
+    kUclampMinFieldNumber = 4,
+    kVruntimeFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.V4l2DqbufFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.SchedWakeupTaskAttrFtraceEvent"; }
+
+
+  using FieldMetadata_Pid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedWakeupTaskAttrFtraceEvent>;
+
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_CpuAffinity =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SchedWakeupTaskAttrFtraceEvent>;
+
+  static constexpr FieldMetadata_CpuAffinity kCpuAffinity{};
+  void set_cpu_affinity(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CpuAffinity::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TaskUtil =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SchedWakeupTaskAttrFtraceEvent>;
 
+  static constexpr FieldMetadata_TaskUtil kTaskUtil{};
+  void set_task_util(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TaskUtil::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Bytesused =
+  using FieldMetadata_UclampMin =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SchedWakeupTaskAttrFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Bytesused kBytesused() { return {}; }
-  void set_bytesused(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Bytesused::kFieldId;
+  static constexpr FieldMetadata_UclampMin kUclampMin{};
+  void set_uclamp_min(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_UclampMin::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Field =
+  using FieldMetadata_Vruntime =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SchedWakeupTaskAttrFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Field kField() { return {}; }
-  void set_field(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Field::kFieldId;
+  static constexpr FieldMetadata_Vruntime kVruntime{};
+  void set_vruntime(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Vruntime::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Flags =
+class SchedMigrateTaskFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
+ public:
+  SchedMigrateTaskFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SchedMigrateTaskFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SchedMigrateTaskFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_comm() const { return at<1>().valid(); }
+  ::protozero::ConstChars comm() const { return at<1>().as_string(); }
+  bool has_pid() const { return at<2>().valid(); }
+  int32_t pid() const { return at<2>().as_int32(); }
+  bool has_prio() const { return at<3>().valid(); }
+  int32_t prio() const { return at<3>().as_int32(); }
+  bool has_orig_cpu() const { return at<4>().valid(); }
+  int32_t orig_cpu() const { return at<4>().as_int32(); }
+  bool has_dest_cpu() const { return at<5>().valid(); }
+  int32_t dest_cpu() const { return at<5>().as_int32(); }
+  bool has_running() const { return at<6>().valid(); }
+  int32_t running() const { return at<6>().as_int32(); }
+  bool has_load() const { return at<7>().valid(); }
+  uint32_t load() const { return at<7>().as_uint32(); }
+};
+
+class SchedMigrateTaskFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = SchedMigrateTaskFtraceEvent_Decoder;
+  enum : int32_t {
+    kCommFieldNumber = 1,
+    kPidFieldNumber = 2,
+    kPrioFieldNumber = 3,
+    kOrigCpuFieldNumber = 4,
+    kDestCpuFieldNumber = 5,
+    kRunningFieldNumber = 6,
+    kLoadFieldNumber = 7,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SchedMigrateTaskFtraceEvent"; }
+
+
+  using FieldMetadata_Comm =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SchedMigrateTaskFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_Comm kComm{};
+  void set_comm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
+  }
+  void set_comm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
+  }
+  void set_comm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Index =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedMigrateTaskFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Index kIndex() { return {}; }
-  void set_index(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Minor =
+  using FieldMetadata_Prio =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      V4l2DqbufFtraceEvent>;
+      SchedMigrateTaskFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Minor kMinor() { return {}; }
-  void set_minor(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Minor::kFieldId;
+  static constexpr FieldMetadata_Prio kPrio{};
+  void set_prio(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -128840,199 +154250,204 @@ class V4l2DqbufFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Sequence =
+  using FieldMetadata_OrigCpu =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedMigrateTaskFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sequence kSequence() { return {}; }
-  void set_sequence(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Sequence::kFieldId;
+  static constexpr FieldMetadata_OrigCpu kOrigCpu{};
+  void set_orig_cpu(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OrigCpu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeFlags =
+  using FieldMetadata_DestCpu =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedMigrateTaskFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeFlags kTimecodeFlags() { return {}; }
-  void set_timecode_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeFlags::kFieldId;
+  static constexpr FieldMetadata_DestCpu kDestCpu{};
+  void set_dest_cpu(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DestCpu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeFrames =
+  using FieldMetadata_Running =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedMigrateTaskFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeFrames kTimecodeFrames() { return {}; }
-  void set_timecode_frames(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeFrames::kFieldId;
+  static constexpr FieldMetadata_Running kRunning{};
+  void set_running(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Running::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeHours =
+  using FieldMetadata_Load =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      V4l2DqbufFtraceEvent>;
+      SchedMigrateTaskFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeHours kTimecodeHours() { return {}; }
-  void set_timecode_hours(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeHours::kFieldId;
+  static constexpr FieldMetadata_Load kLoad{};
+  void set_load(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Load::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TimecodeMinutes =
+class SchedCpuUtilCfsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/15> {
+ public:
+  SchedCpuUtilCfsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SchedCpuUtilCfsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SchedCpuUtilCfsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_active() const { return at<1>().valid(); }
+  int32_t active() const { return at<1>().as_int32(); }
+  bool has_capacity() const { return at<2>().valid(); }
+  uint64_t capacity() const { return at<2>().as_uint64(); }
+  bool has_capacity_orig() const { return at<3>().valid(); }
+  uint64_t capacity_orig() const { return at<3>().as_uint64(); }
+  bool has_cpu() const { return at<4>().valid(); }
+  uint32_t cpu() const { return at<4>().as_uint32(); }
+  bool has_cpu_importance() const { return at<5>().valid(); }
+  uint64_t cpu_importance() const { return at<5>().as_uint64(); }
+  bool has_cpu_util() const { return at<6>().valid(); }
+  uint64_t cpu_util() const { return at<6>().as_uint64(); }
+  bool has_exit_lat() const { return at<7>().valid(); }
+  uint32_t exit_lat() const { return at<7>().as_uint32(); }
+  bool has_group_capacity() const { return at<8>().valid(); }
+  uint64_t group_capacity() const { return at<8>().as_uint64(); }
+  bool has_grp_overutilized() const { return at<9>().valid(); }
+  uint32_t grp_overutilized() const { return at<9>().as_uint32(); }
+  bool has_idle_cpu() const { return at<10>().valid(); }
+  uint32_t idle_cpu() const { return at<10>().as_uint32(); }
+  bool has_nr_running() const { return at<11>().valid(); }
+  uint32_t nr_running() const { return at<11>().as_uint32(); }
+  bool has_spare_cap() const { return at<12>().valid(); }
+  int64_t spare_cap() const { return at<12>().as_int64(); }
+  bool has_task_fits() const { return at<13>().valid(); }
+  uint32_t task_fits() const { return at<13>().as_uint32(); }
+  bool has_wake_group_util() const { return at<14>().valid(); }
+  uint64_t wake_group_util() const { return at<14>().as_uint64(); }
+  bool has_wake_util() const { return at<15>().valid(); }
+  uint64_t wake_util() const { return at<15>().as_uint64(); }
+};
+
+class SchedCpuUtilCfsFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = SchedCpuUtilCfsFtraceEvent_Decoder;
+  enum : int32_t {
+    kActiveFieldNumber = 1,
+    kCapacityFieldNumber = 2,
+    kCapacityOrigFieldNumber = 3,
+    kCpuFieldNumber = 4,
+    kCpuImportanceFieldNumber = 5,
+    kCpuUtilFieldNumber = 6,
+    kExitLatFieldNumber = 7,
+    kGroupCapacityFieldNumber = 8,
+    kGrpOverutilizedFieldNumber = 9,
+    kIdleCpuFieldNumber = 10,
+    kNrRunningFieldNumber = 11,
+    kSpareCapFieldNumber = 12,
+    kTaskFitsFieldNumber = 13,
+    kWakeGroupUtilFieldNumber = 14,
+    kWakeUtilFieldNumber = 15,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SchedCpuUtilCfsFtraceEvent"; }
+
+
+  using FieldMetadata_Active =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedCpuUtilCfsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeMinutes kTimecodeMinutes() { return {}; }
-  void set_timecode_minutes(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeMinutes::kFieldId;
+  static constexpr FieldMetadata_Active kActive{};
+  void set_active(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Active::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeSeconds =
+  using FieldMetadata_Capacity =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SchedCpuUtilCfsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeSeconds kTimecodeSeconds() { return {}; }
-  void set_timecode_seconds(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeSeconds::kFieldId;
+  static constexpr FieldMetadata_Capacity kCapacity{};
+  void set_capacity(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Capacity::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeType =
+  using FieldMetadata_CapacityOrig =
     ::protozero::proto_utils::FieldMetadata<
-      12,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SchedCpuUtilCfsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeType kTimecodeType() { return {}; }
-  void set_timecode_type(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeType::kFieldId;
+  static constexpr FieldMetadata_CapacityOrig kCapacityOrig{};
+  void set_capacity_orig(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CapacityOrig::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeUserbits0 =
+  using FieldMetadata_Cpu =
     ::protozero::proto_utils::FieldMetadata<
-      13,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      V4l2DqbufFtraceEvent>;
+      SchedCpuUtilCfsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits0 kTimecodeUserbits0() { return {}; }
-  void set_timecode_userbits0(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits0::kFieldId;
+  static constexpr FieldMetadata_Cpu kCpu{};
+  void set_cpu(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -129040,74 +154455,53 @@ class V4l2DqbufFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeUserbits1 =
+  using FieldMetadata_CpuImportance =
     ::protozero::proto_utils::FieldMetadata<
-      14,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SchedCpuUtilCfsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits1 kTimecodeUserbits1() { return {}; }
-  void set_timecode_userbits1(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits1::kFieldId;
+  static constexpr FieldMetadata_CpuImportance kCpuImportance{};
+  void set_cpu_importance(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CpuImportance::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeUserbits2 =
+  using FieldMetadata_CpuUtil =
     ::protozero::proto_utils::FieldMetadata<
-      15,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SchedCpuUtilCfsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits2 kTimecodeUserbits2() { return {}; }
-  void set_timecode_userbits2(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits2::kFieldId;
+  static constexpr FieldMetadata_CpuUtil kCpuUtil{};
+  void set_cpu_util(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CpuUtil::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeUserbits3 =
+  using FieldMetadata_ExitLat =
     ::protozero::proto_utils::FieldMetadata<
-      16,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      V4l2DqbufFtraceEvent>;
+      SchedCpuUtilCfsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits3 kTimecodeUserbits3() { return {}; }
-  void set_timecode_userbits3(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits3::kFieldId;
+  static constexpr FieldMetadata_ExitLat kExitLat{};
+  void set_exit_lat(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ExitLat::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -129115,144 +154509,53 @@ class V4l2DqbufFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Timestamp =
+  using FieldMetadata_GroupCapacity =
     ::protozero::proto_utils::FieldMetadata<
-      17,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      V4l2DqbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SchedCpuUtilCfsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timestamp kTimestamp() { return {}; }
-  void set_timestamp(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+  static constexpr FieldMetadata_GroupCapacity kGroupCapacity{};
+  void set_group_capacity(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GroupCapacity::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Type =
+  using FieldMetadata_GrpOverutilized =
     ::protozero::proto_utils::FieldMetadata<
-      18,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      V4l2DqbufFtraceEvent>;
+      SchedCpuUtilCfsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+  static constexpr FieldMetadata_GrpOverutilized kGrpOverutilized{};
+  void set_grp_overutilized(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GrpOverutilized::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class V4l2QbufFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/18, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  V4l2QbufFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit V4l2QbufFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit V4l2QbufFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_bytesused() const { return at<1>().valid(); }
-  uint32_t bytesused() const { return at<1>().as_uint32(); }
-  bool has_field() const { return at<2>().valid(); }
-  uint32_t field() const { return at<2>().as_uint32(); }
-  bool has_flags() const { return at<3>().valid(); }
-  uint32_t flags() const { return at<3>().as_uint32(); }
-  bool has_index() const { return at<4>().valid(); }
-  uint32_t index() const { return at<4>().as_uint32(); }
-  bool has_minor() const { return at<5>().valid(); }
-  int32_t minor() const { return at<5>().as_int32(); }
-  bool has_sequence() const { return at<6>().valid(); }
-  uint32_t sequence() const { return at<6>().as_uint32(); }
-  bool has_timecode_flags() const { return at<7>().valid(); }
-  uint32_t timecode_flags() const { return at<7>().as_uint32(); }
-  bool has_timecode_frames() const { return at<8>().valid(); }
-  uint32_t timecode_frames() const { return at<8>().as_uint32(); }
-  bool has_timecode_hours() const { return at<9>().valid(); }
-  uint32_t timecode_hours() const { return at<9>().as_uint32(); }
-  bool has_timecode_minutes() const { return at<10>().valid(); }
-  uint32_t timecode_minutes() const { return at<10>().as_uint32(); }
-  bool has_timecode_seconds() const { return at<11>().valid(); }
-  uint32_t timecode_seconds() const { return at<11>().as_uint32(); }
-  bool has_timecode_type() const { return at<12>().valid(); }
-  uint32_t timecode_type() const { return at<12>().as_uint32(); }
-  bool has_timecode_userbits0() const { return at<13>().valid(); }
-  uint32_t timecode_userbits0() const { return at<13>().as_uint32(); }
-  bool has_timecode_userbits1() const { return at<14>().valid(); }
-  uint32_t timecode_userbits1() const { return at<14>().as_uint32(); }
-  bool has_timecode_userbits2() const { return at<15>().valid(); }
-  uint32_t timecode_userbits2() const { return at<15>().as_uint32(); }
-  bool has_timecode_userbits3() const { return at<16>().valid(); }
-  uint32_t timecode_userbits3() const { return at<16>().as_uint32(); }
-  bool has_timestamp() const { return at<17>().valid(); }
-  int64_t timestamp() const { return at<17>().as_int64(); }
-  bool has_type() const { return at<18>().valid(); }
-  uint32_t type() const { return at<18>().as_uint32(); }
-};
-
-class V4l2QbufFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = V4l2QbufFtraceEvent_Decoder;
-  enum : int32_t {
-    kBytesusedFieldNumber = 1,
-    kFieldFieldNumber = 2,
-    kFlagsFieldNumber = 3,
-    kIndexFieldNumber = 4,
-    kMinorFieldNumber = 5,
-    kSequenceFieldNumber = 6,
-    kTimecodeFlagsFieldNumber = 7,
-    kTimecodeFramesFieldNumber = 8,
-    kTimecodeHoursFieldNumber = 9,
-    kTimecodeMinutesFieldNumber = 10,
-    kTimecodeSecondsFieldNumber = 11,
-    kTimecodeTypeFieldNumber = 12,
-    kTimecodeUserbits0FieldNumber = 13,
-    kTimecodeUserbits1FieldNumber = 14,
-    kTimecodeUserbits2FieldNumber = 15,
-    kTimecodeUserbits3FieldNumber = 16,
-    kTimestampFieldNumber = 17,
-    kTypeFieldNumber = 18,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.V4l2QbufFtraceEvent"; }
 
-
-  using FieldMetadata_Bytesused =
+  using FieldMetadata_IdleCpu =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      V4l2QbufFtraceEvent>;
+      SchedCpuUtilCfsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Bytesused kBytesused() { return {}; }
-  void set_bytesused(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Bytesused::kFieldId;
+  static constexpr FieldMetadata_IdleCpu kIdleCpu{};
+  void set_idle_cpu(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IdleCpu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -129260,24 +154563,17 @@ class V4l2QbufFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Field =
+  using FieldMetadata_NrRunning =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      V4l2QbufFtraceEvent>;
+      SchedCpuUtilCfsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Field kField() { return {}; }
-  void set_field(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Field::kFieldId;
+  static constexpr FieldMetadata_NrRunning kNrRunning{};
+  void set_nr_running(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NrRunning::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -129285,49 +154581,35 @@ class V4l2QbufFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_SpareCap =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      12,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      SchedCpuUtilCfsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_SpareCap kSpareCap{};
+  void set_spare_cap(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SpareCap::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Index =
+  using FieldMetadata_TaskFits =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      13,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      V4l2QbufFtraceEvent>;
+      SchedCpuUtilCfsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Index kIndex() { return {}; }
-  void set_index(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
+  static constexpr FieldMetadata_TaskFits kTaskFits{};
+  void set_task_fits(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TaskFits::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -129335,466 +154617,445 @@ class V4l2QbufFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Minor =
+  using FieldMetadata_WakeGroupUtil =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      14,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SchedCpuUtilCfsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Minor kMinor() { return {}; }
-  void set_minor(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Minor::kFieldId;
+  static constexpr FieldMetadata_WakeGroupUtil kWakeGroupUtil{};
+  void set_wake_group_util(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_WakeGroupUtil::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Sequence =
+  using FieldMetadata_WakeUtil =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      15,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SchedCpuUtilCfsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sequence kSequence() { return {}; }
-  void set_sequence(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Sequence::kFieldId;
+  static constexpr FieldMetadata_WakeUtil kWakeUtil{};
+  void set_wake_util(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_WakeUtil::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TimecodeFlags =
+class SchedPiSetprioFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  SchedPiSetprioFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SchedPiSetprioFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SchedPiSetprioFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_comm() const { return at<1>().valid(); }
+  ::protozero::ConstChars comm() const { return at<1>().as_string(); }
+  bool has_newprio() const { return at<2>().valid(); }
+  int32_t newprio() const { return at<2>().as_int32(); }
+  bool has_oldprio() const { return at<3>().valid(); }
+  int32_t oldprio() const { return at<3>().as_int32(); }
+  bool has_pid() const { return at<4>().valid(); }
+  int32_t pid() const { return at<4>().as_int32(); }
+};
+
+class SchedPiSetprioFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = SchedPiSetprioFtraceEvent_Decoder;
+  enum : int32_t {
+    kCommFieldNumber = 1,
+    kNewprioFieldNumber = 2,
+    kOldprioFieldNumber = 3,
+    kPidFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SchedPiSetprioFtraceEvent"; }
+
+
+  using FieldMetadata_Comm =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SchedPiSetprioFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeFlags kTimecodeFlags() { return {}; }
-  void set_timecode_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeFlags::kFieldId;
+  static constexpr FieldMetadata_Comm kComm{};
+  void set_comm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
+  }
+  void set_comm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
+  }
+  void set_comm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeFrames =
+  using FieldMetadata_Newprio =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedPiSetprioFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeFrames kTimecodeFrames() { return {}; }
-  void set_timecode_frames(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeFrames::kFieldId;
+  static constexpr FieldMetadata_Newprio kNewprio{};
+  void set_newprio(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Newprio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeHours =
+  using FieldMetadata_Oldprio =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedPiSetprioFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeHours kTimecodeHours() { return {}; }
-  void set_timecode_hours(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeHours::kFieldId;
+  static constexpr FieldMetadata_Oldprio kOldprio{};
+  void set_oldprio(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Oldprio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeMinutes =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedPiSetprioFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeMinutes kTimecodeMinutes() { return {}; }
-  void set_timecode_minutes(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeMinutes::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TimecodeSeconds =
+class SchedProcessWaitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  SchedProcessWaitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SchedProcessWaitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SchedProcessWaitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_comm() const { return at<1>().valid(); }
+  ::protozero::ConstChars comm() const { return at<1>().as_string(); }
+  bool has_pid() const { return at<2>().valid(); }
+  int32_t pid() const { return at<2>().as_int32(); }
+  bool has_prio() const { return at<3>().valid(); }
+  int32_t prio() const { return at<3>().as_int32(); }
+};
+
+class SchedProcessWaitFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = SchedProcessWaitFtraceEvent_Decoder;
+  enum : int32_t {
+    kCommFieldNumber = 1,
+    kPidFieldNumber = 2,
+    kPrioFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SchedProcessWaitFtraceEvent"; }
+
+
+  using FieldMetadata_Comm =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SchedProcessWaitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeSeconds kTimecodeSeconds() { return {}; }
-  void set_timecode_seconds(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeSeconds::kFieldId;
+  static constexpr FieldMetadata_Comm kComm{};
+  void set_comm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
+  }
+  void set_comm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
+  }
+  void set_comm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeType =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
-      12,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedProcessWaitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeType kTimecodeType() { return {}; }
-  void set_timecode_type(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeType::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeUserbits0 =
+  using FieldMetadata_Prio =
     ::protozero::proto_utils::FieldMetadata<
-      13,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedProcessWaitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits0 kTimecodeUserbits0() { return {}; }
-  void set_timecode_userbits0(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits0::kFieldId;
+  static constexpr FieldMetadata_Prio kPrio{};
+  void set_prio(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TimecodeUserbits1 =
+class SchedProcessHangFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  SchedProcessHangFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SchedProcessHangFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SchedProcessHangFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_comm() const { return at<1>().valid(); }
+  ::protozero::ConstChars comm() const { return at<1>().as_string(); }
+  bool has_pid() const { return at<2>().valid(); }
+  int32_t pid() const { return at<2>().as_int32(); }
+};
+
+class SchedProcessHangFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = SchedProcessHangFtraceEvent_Decoder;
+  enum : int32_t {
+    kCommFieldNumber = 1,
+    kPidFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SchedProcessHangFtraceEvent"; }
+
+
+  using FieldMetadata_Comm =
     ::protozero::proto_utils::FieldMetadata<
-      14,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SchedProcessHangFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits1 kTimecodeUserbits1() { return {}; }
-  void set_timecode_userbits1(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits1::kFieldId;
+  static constexpr FieldMetadata_Comm kComm{};
+  void set_comm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
+  }
+  void set_comm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
+  }
+  void set_comm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimecodeUserbits2 =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
-      15,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedProcessHangFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits2 kTimecodeUserbits2() { return {}; }
-  void set_timecode_userbits2(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits2::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TimecodeUserbits3 =
+class SchedProcessFreeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  SchedProcessFreeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SchedProcessFreeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SchedProcessFreeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_comm() const { return at<1>().valid(); }
+  ::protozero::ConstChars comm() const { return at<1>().as_string(); }
+  bool has_pid() const { return at<2>().valid(); }
+  int32_t pid() const { return at<2>().as_int32(); }
+  bool has_prio() const { return at<3>().valid(); }
+  int32_t prio() const { return at<3>().as_int32(); }
+};
+
+class SchedProcessFreeFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = SchedProcessFreeFtraceEvent_Decoder;
+  enum : int32_t {
+    kCommFieldNumber = 1,
+    kPidFieldNumber = 2,
+    kPrioFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SchedProcessFreeFtraceEvent"; }
+
+
+  using FieldMetadata_Comm =
     ::protozero::proto_utils::FieldMetadata<
-      16,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SchedProcessFreeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimecodeUserbits3 kTimecodeUserbits3() { return {}; }
-  void set_timecode_userbits3(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits3::kFieldId;
+  static constexpr FieldMetadata_Comm kComm{};
+  void set_comm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
+  }
+  void set_comm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
+  }
+  void set_comm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Timestamp =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
-      17,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedProcessFreeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timestamp kTimestamp() { return {}; }
-  void set_timestamp(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Type =
+  using FieldMetadata_Prio =
     ::protozero::proto_utils::FieldMetadata<
-      18,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      V4l2QbufFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedProcessFreeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+  static constexpr FieldMetadata_Prio kPrio{};
+  void set_prio(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/virtio_gpu.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_VIRTIO_GPU_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_VIRTIO_GPU_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class VirtioGpuCmdResponseFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class SchedProcessForkFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  VirtioGpuCmdResponseFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit VirtioGpuCmdResponseFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit VirtioGpuCmdResponseFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_ctx_id() const { return at<1>().valid(); }
-  uint32_t ctx_id() const { return at<1>().as_uint32(); }
-  bool has_dev() const { return at<2>().valid(); }
-  int32_t dev() const { return at<2>().as_int32(); }
-  bool has_fence_id() const { return at<3>().valid(); }
-  uint64_t fence_id() const { return at<3>().as_uint64(); }
-  bool has_flags() const { return at<4>().valid(); }
-  uint32_t flags() const { return at<4>().as_uint32(); }
-  bool has_name() const { return at<5>().valid(); }
-  ::protozero::ConstChars name() const { return at<5>().as_string(); }
-  bool has_num_free() const { return at<6>().valid(); }
-  uint32_t num_free() const { return at<6>().as_uint32(); }
-  bool has_seqno() const { return at<7>().valid(); }
-  uint32_t seqno() const { return at<7>().as_uint32(); }
-  bool has_type() const { return at<8>().valid(); }
-  uint32_t type() const { return at<8>().as_uint32(); }
-  bool has_vq() const { return at<9>().valid(); }
-  uint32_t vq() const { return at<9>().as_uint32(); }
+  SchedProcessForkFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SchedProcessForkFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SchedProcessForkFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_parent_comm() const { return at<1>().valid(); }
+  ::protozero::ConstChars parent_comm() const { return at<1>().as_string(); }
+  bool has_parent_pid() const { return at<2>().valid(); }
+  int32_t parent_pid() const { return at<2>().as_int32(); }
+  bool has_child_comm() const { return at<3>().valid(); }
+  ::protozero::ConstChars child_comm() const { return at<3>().as_string(); }
+  bool has_child_pid() const { return at<4>().valid(); }
+  int32_t child_pid() const { return at<4>().as_int32(); }
 };
 
-class VirtioGpuCmdResponseFtraceEvent : public ::protozero::Message {
+class SchedProcessForkFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = VirtioGpuCmdResponseFtraceEvent_Decoder;
+  using Decoder = SchedProcessForkFtraceEvent_Decoder;
   enum : int32_t {
-    kCtxIdFieldNumber = 1,
-    kDevFieldNumber = 2,
-    kFenceIdFieldNumber = 3,
-    kFlagsFieldNumber = 4,
-    kNameFieldNumber = 5,
-    kNumFreeFieldNumber = 6,
-    kSeqnoFieldNumber = 7,
-    kTypeFieldNumber = 8,
-    kVqFieldNumber = 9,
+    kParentCommFieldNumber = 1,
+    kParentPidFieldNumber = 2,
+    kChildCommFieldNumber = 3,
+    kChildPidFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.VirtioGpuCmdResponseFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.SchedProcessForkFtraceEvent"; }
 
 
-  using FieldMetadata_CtxId =
+  using FieldMetadata_ParentComm =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioGpuCmdResponseFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SchedProcessForkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CtxId kCtxId() { return {}; }
-  void set_ctx_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CtxId::kFieldId;
+  static constexpr FieldMetadata_ParentComm kParentComm{};
+  void set_parent_comm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ParentComm::kFieldId, data, size);
+  }
+  void set_parent_comm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ParentComm::kFieldId, chars.data, chars.size);
+  }
+  void set_parent_comm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ParentComm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_ParentPid =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      VirtioGpuCmdResponseFtraceEvent>;
+      SchedProcessForkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_ParentPid kParentPid{};
+  void set_parent_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ParentPid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -129802,80 +155063,93 @@ class VirtioGpuCmdResponseFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FenceId =
+  using FieldMetadata_ChildComm =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      VirtioGpuCmdResponseFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SchedProcessForkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FenceId kFenceId() { return {}; }
-  void set_fence_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FenceId::kFieldId;
+  static constexpr FieldMetadata_ChildComm kChildComm{};
+  void set_child_comm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ChildComm::kFieldId, data, size);
+  }
+  void set_child_comm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ChildComm::kFieldId, chars.data, chars.size);
+  }
+  void set_child_comm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ChildComm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Flags =
+  using FieldMetadata_ChildPid =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioGpuCmdResponseFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedProcessForkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+  static constexpr FieldMetadata_ChildPid kChildPid{};
+  void set_child_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ChildPid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Name =
+class SchedProcessExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  SchedProcessExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SchedProcessExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SchedProcessExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_comm() const { return at<1>().valid(); }
+  ::protozero::ConstChars comm() const { return at<1>().as_string(); }
+  bool has_pid() const { return at<2>().valid(); }
+  int32_t pid() const { return at<2>().as_int32(); }
+  bool has_tgid() const { return at<3>().valid(); }
+  int32_t tgid() const { return at<3>().as_int32(); }
+  bool has_prio() const { return at<4>().valid(); }
+  int32_t prio() const { return at<4>().as_int32(); }
+};
+
+class SchedProcessExitFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = SchedProcessExitFtraceEvent_Decoder;
+  enum : int32_t {
+    kCommFieldNumber = 1,
+    kPidFieldNumber = 2,
+    kTgidFieldNumber = 3,
+    kPrioFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SchedProcessExitFtraceEvent"; }
+
+
+  using FieldMetadata_Comm =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      VirtioGpuCmdResponseFtraceEvent>;
+      SchedProcessExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  static constexpr FieldMetadata_Comm kComm{};
+  void set_comm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
   }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  void set_comm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
   }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  void set_comm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -129883,192 +155157,120 @@ class VirtioGpuCmdResponseFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NumFree =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioGpuCmdResponseFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NumFree kNumFree() { return {}; }
-  void set_num_free(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NumFree::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Seqno =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioGpuCmdResponseFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedProcessExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Seqno kSeqno() { return {}; }
-  void set_seqno(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Type =
+  using FieldMetadata_Tgid =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioGpuCmdResponseFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedProcessExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+  static constexpr FieldMetadata_Tgid kTgid{};
+  void set_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tgid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Vq =
+  using FieldMetadata_Prio =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioGpuCmdResponseFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedProcessExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Vq kVq() { return {}; }
-  void set_vq(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Vq::kFieldId;
+  static constexpr FieldMetadata_Prio kPrio{};
+  void set_prio(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class VirtioGpuCmdQueueFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class SchedProcessExecFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  VirtioGpuCmdQueueFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit VirtioGpuCmdQueueFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit VirtioGpuCmdQueueFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_ctx_id() const { return at<1>().valid(); }
-  uint32_t ctx_id() const { return at<1>().as_uint32(); }
-  bool has_dev() const { return at<2>().valid(); }
-  int32_t dev() const { return at<2>().as_int32(); }
-  bool has_fence_id() const { return at<3>().valid(); }
-  uint64_t fence_id() const { return at<3>().as_uint64(); }
-  bool has_flags() const { return at<4>().valid(); }
-  uint32_t flags() const { return at<4>().as_uint32(); }
-  bool has_name() const { return at<5>().valid(); }
-  ::protozero::ConstChars name() const { return at<5>().as_string(); }
-  bool has_num_free() const { return at<6>().valid(); }
-  uint32_t num_free() const { return at<6>().as_uint32(); }
-  bool has_seqno() const { return at<7>().valid(); }
-  uint32_t seqno() const { return at<7>().as_uint32(); }
-  bool has_type() const { return at<8>().valid(); }
-  uint32_t type() const { return at<8>().as_uint32(); }
-  bool has_vq() const { return at<9>().valid(); }
-  uint32_t vq() const { return at<9>().as_uint32(); }
+  SchedProcessExecFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SchedProcessExecFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SchedProcessExecFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_filename() const { return at<1>().valid(); }
+  ::protozero::ConstChars filename() const { return at<1>().as_string(); }
+  bool has_pid() const { return at<2>().valid(); }
+  int32_t pid() const { return at<2>().as_int32(); }
+  bool has_old_pid() const { return at<3>().valid(); }
+  int32_t old_pid() const { return at<3>().as_int32(); }
 };
 
-class VirtioGpuCmdQueueFtraceEvent : public ::protozero::Message {
+class SchedProcessExecFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = VirtioGpuCmdQueueFtraceEvent_Decoder;
+  using Decoder = SchedProcessExecFtraceEvent_Decoder;
   enum : int32_t {
-    kCtxIdFieldNumber = 1,
-    kDevFieldNumber = 2,
-    kFenceIdFieldNumber = 3,
-    kFlagsFieldNumber = 4,
-    kNameFieldNumber = 5,
-    kNumFreeFieldNumber = 6,
-    kSeqnoFieldNumber = 7,
-    kTypeFieldNumber = 8,
-    kVqFieldNumber = 9,
+    kFilenameFieldNumber = 1,
+    kPidFieldNumber = 2,
+    kOldPidFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.VirtioGpuCmdQueueFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.SchedProcessExecFtraceEvent"; }
 
 
-  using FieldMetadata_CtxId =
+  using FieldMetadata_Filename =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioGpuCmdQueueFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SchedProcessExecFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CtxId kCtxId() { return {}; }
-  void set_ctx_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CtxId::kFieldId;
+  static constexpr FieldMetadata_Filename kFilename{};
+  void set_filename(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Filename::kFieldId, data, size);
+  }
+  void set_filename(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Filename::kFieldId, chars.data, chars.size);
+  }
+  void set_filename(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Filename::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Dev =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      VirtioGpuCmdQueueFtraceEvent>;
+      SchedProcessExecFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dev kDev() { return {}; }
-  void set_dev(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -130076,80 +155278,72 @@ class VirtioGpuCmdQueueFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FenceId =
+  using FieldMetadata_OldPid =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      VirtioGpuCmdQueueFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedProcessExecFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FenceId kFenceId() { return {}; }
-  void set_fence_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FenceId::kFieldId;
+  static constexpr FieldMetadata_OldPid kOldPid{};
+  void set_old_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OldPid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Flags =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioGpuCmdQueueFtraceEvent>;
+class SchedWakeupNewFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  SchedWakeupNewFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SchedWakeupNewFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SchedWakeupNewFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_comm() const { return at<1>().valid(); }
+  ::protozero::ConstChars comm() const { return at<1>().as_string(); }
+  bool has_pid() const { return at<2>().valid(); }
+  int32_t pid() const { return at<2>().as_int32(); }
+  bool has_prio() const { return at<3>().valid(); }
+  int32_t prio() const { return at<3>().as_int32(); }
+  bool has_success() const { return at<4>().valid(); }
+  int32_t success() const { return at<4>().as_int32(); }
+  bool has_target_cpu() const { return at<5>().valid(); }
+  int32_t target_cpu() const { return at<5>().as_int32(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Flags kFlags() { return {}; }
-  void set_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+class SchedWakeupNewFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = SchedWakeupNewFtraceEvent_Decoder;
+  enum : int32_t {
+    kCommFieldNumber = 1,
+    kPidFieldNumber = 2,
+    kPrioFieldNumber = 3,
+    kSuccessFieldNumber = 4,
+    kTargetCpuFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SchedWakeupNewFtraceEvent"; }
 
-  using FieldMetadata_Name =
+
+  using FieldMetadata_Comm =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      VirtioGpuCmdQueueFtraceEvent>;
+      SchedWakeupNewFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  static constexpr FieldMetadata_Comm kComm{};
+  void set_comm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
   }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  void set_comm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
   }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  void set_comm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -130157,313 +155351,241 @@ class VirtioGpuCmdQueueFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NumFree =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioGpuCmdQueueFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedWakeupNewFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NumFree kNumFree() { return {}; }
-  void set_num_free(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NumFree::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Seqno =
+  using FieldMetadata_Prio =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioGpuCmdQueueFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedWakeupNewFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Seqno kSeqno() { return {}; }
-  void set_seqno(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId;
+  static constexpr FieldMetadata_Prio kPrio{};
+  void set_prio(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Type =
+  using FieldMetadata_Success =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioGpuCmdQueueFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedWakeupNewFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+  static constexpr FieldMetadata_Success kSuccess{};
+  void set_success(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Success::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Vq =
+  using FieldMetadata_TargetCpu =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioGpuCmdQueueFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedWakeupNewFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Vq kVq() { return {}; }
-  void set_vq(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Vq::kFieldId;
+  static constexpr FieldMetadata_TargetCpu kTargetCpu{};
+  void set_target_cpu(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TargetCpu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/virtio_video.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_VIRTIO_VIDEO_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_VIRTIO_VIDEO_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class VirtioVideoResourceQueueDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class SchedWakingFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  VirtioVideoResourceQueueDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit VirtioVideoResourceQueueDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit VirtioVideoResourceQueueDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_data_size0() const { return at<1>().valid(); }
-  uint32_t data_size0() const { return at<1>().as_uint32(); }
-  bool has_data_size1() const { return at<2>().valid(); }
-  uint32_t data_size1() const { return at<2>().as_uint32(); }
-  bool has_data_size2() const { return at<3>().valid(); }
-  uint32_t data_size2() const { return at<3>().as_uint32(); }
-  bool has_data_size3() const { return at<4>().valid(); }
-  uint32_t data_size3() const { return at<4>().as_uint32(); }
-  bool has_queue_type() const { return at<5>().valid(); }
-  uint32_t queue_type() const { return at<5>().as_uint32(); }
-  bool has_resource_id() const { return at<6>().valid(); }
-  int32_t resource_id() const { return at<6>().as_int32(); }
-  bool has_stream_id() const { return at<7>().valid(); }
-  int32_t stream_id() const { return at<7>().as_int32(); }
-  bool has_timestamp() const { return at<8>().valid(); }
-  uint64_t timestamp() const { return at<8>().as_uint64(); }
+  SchedWakingFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SchedWakingFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SchedWakingFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_comm() const { return at<1>().valid(); }
+  ::protozero::ConstChars comm() const { return at<1>().as_string(); }
+  bool has_pid() const { return at<2>().valid(); }
+  int32_t pid() const { return at<2>().as_int32(); }
+  bool has_prio() const { return at<3>().valid(); }
+  int32_t prio() const { return at<3>().as_int32(); }
+  bool has_success() const { return at<4>().valid(); }
+  int32_t success() const { return at<4>().as_int32(); }
+  bool has_target_cpu() const { return at<5>().valid(); }
+  int32_t target_cpu() const { return at<5>().as_int32(); }
 };
 
-class VirtioVideoResourceQueueDoneFtraceEvent : public ::protozero::Message {
+class SchedWakingFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = VirtioVideoResourceQueueDoneFtraceEvent_Decoder;
+  using Decoder = SchedWakingFtraceEvent_Decoder;
   enum : int32_t {
-    kDataSize0FieldNumber = 1,
-    kDataSize1FieldNumber = 2,
-    kDataSize2FieldNumber = 3,
-    kDataSize3FieldNumber = 4,
-    kQueueTypeFieldNumber = 5,
-    kResourceIdFieldNumber = 6,
-    kStreamIdFieldNumber = 7,
-    kTimestampFieldNumber = 8,
+    kCommFieldNumber = 1,
+    kPidFieldNumber = 2,
+    kPrioFieldNumber = 3,
+    kSuccessFieldNumber = 4,
+    kTargetCpuFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.VirtioVideoResourceQueueDoneFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.SchedWakingFtraceEvent"; }
 
 
-  using FieldMetadata_DataSize0 =
+  using FieldMetadata_Comm =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioVideoResourceQueueDoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SchedWakingFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DataSize0 kDataSize0() { return {}; }
-  void set_data_size0(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DataSize0::kFieldId;
+  static constexpr FieldMetadata_Comm kComm{};
+  void set_comm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
+  }
+  void set_comm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
+  }
+  void set_comm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DataSize1 =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioVideoResourceQueueDoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedWakingFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DataSize1 kDataSize1() { return {}; }
-  void set_data_size1(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DataSize1::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DataSize2 =
+  using FieldMetadata_Prio =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioVideoResourceQueueDoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedWakingFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DataSize2 kDataSize2() { return {}; }
-  void set_data_size2(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DataSize2::kFieldId;
+  static constexpr FieldMetadata_Prio kPrio{};
+  void set_prio(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DataSize3 =
+  using FieldMetadata_Success =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioVideoResourceQueueDoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedWakingFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DataSize3 kDataSize3() { return {}; }
-  void set_data_size3(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DataSize3::kFieldId;
+  static constexpr FieldMetadata_Success kSuccess{};
+  void set_success(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Success::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_QueueType =
+  using FieldMetadata_TargetCpu =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioVideoResourceQueueDoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedWakingFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_QueueType kQueueType() { return {}; }
-  void set_queue_type(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_QueueType::kFieldId;
+  static constexpr FieldMetadata_TargetCpu kTargetCpu{};
+  void set_target_cpu(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TargetCpu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_ResourceId =
+class SchedCpuHotplugFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  SchedCpuHotplugFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SchedCpuHotplugFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SchedCpuHotplugFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_affected_cpu() const { return at<1>().valid(); }
+  int32_t affected_cpu() const { return at<1>().as_int32(); }
+  bool has_error() const { return at<2>().valid(); }
+  int32_t error() const { return at<2>().as_int32(); }
+  bool has_status() const { return at<3>().valid(); }
+  int32_t status() const { return at<3>().as_int32(); }
+};
+
+class SchedCpuHotplugFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = SchedCpuHotplugFtraceEvent_Decoder;
+  enum : int32_t {
+    kAffectedCpuFieldNumber = 1,
+    kErrorFieldNumber = 2,
+    kStatusFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SchedCpuHotplugFtraceEvent"; }
+
+
+  using FieldMetadata_AffectedCpu =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      VirtioVideoResourceQueueDoneFtraceEvent>;
+      SchedCpuHotplugFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ResourceId kResourceId() { return {}; }
-  void set_resource_id(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ResourceId::kFieldId;
+  static constexpr FieldMetadata_AffectedCpu kAffectedCpu{};
+  void set_affected_cpu(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AffectedCpu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -130471,24 +155593,17 @@ class VirtioVideoResourceQueueDoneFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_StreamId =
+  using FieldMetadata_Error =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      VirtioVideoResourceQueueDoneFtraceEvent>;
+      SchedCpuHotplugFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StreamId kStreamId() { return {}; }
-  void set_stream_id(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StreamId::kFieldId;
+  static constexpr FieldMetadata_Error kError{};
+  void set_error(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -130496,214 +155611,187 @@ class VirtioVideoResourceQueueDoneFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Timestamp =
+  using FieldMetadata_Status =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      VirtioVideoResourceQueueDoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedCpuHotplugFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timestamp kTimestamp() { return {}; }
-  void set_timestamp(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+  static constexpr FieldMetadata_Status kStatus{};
+  void set_status(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class VirtioVideoResourceQueueFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class SchedBlockedReasonFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  VirtioVideoResourceQueueFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit VirtioVideoResourceQueueFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit VirtioVideoResourceQueueFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_data_size0() const { return at<1>().valid(); }
-  uint32_t data_size0() const { return at<1>().as_uint32(); }
-  bool has_data_size1() const { return at<2>().valid(); }
-  uint32_t data_size1() const { return at<2>().as_uint32(); }
-  bool has_data_size2() const { return at<3>().valid(); }
-  uint32_t data_size2() const { return at<3>().as_uint32(); }
-  bool has_data_size3() const { return at<4>().valid(); }
-  uint32_t data_size3() const { return at<4>().as_uint32(); }
-  bool has_queue_type() const { return at<5>().valid(); }
-  uint32_t queue_type() const { return at<5>().as_uint32(); }
-  bool has_resource_id() const { return at<6>().valid(); }
-  int32_t resource_id() const { return at<6>().as_int32(); }
-  bool has_stream_id() const { return at<7>().valid(); }
-  int32_t stream_id() const { return at<7>().as_int32(); }
-  bool has_timestamp() const { return at<8>().valid(); }
-  uint64_t timestamp() const { return at<8>().as_uint64(); }
+  SchedBlockedReasonFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SchedBlockedReasonFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SchedBlockedReasonFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  int32_t pid() const { return at<1>().as_int32(); }
+  bool has_caller() const { return at<2>().valid(); }
+  uint64_t caller() const { return at<2>().as_uint64(); }
+  bool has_io_wait() const { return at<3>().valid(); }
+  uint32_t io_wait() const { return at<3>().as_uint32(); }
 };
 
-class VirtioVideoResourceQueueFtraceEvent : public ::protozero::Message {
+class SchedBlockedReasonFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = VirtioVideoResourceQueueFtraceEvent_Decoder;
+  using Decoder = SchedBlockedReasonFtraceEvent_Decoder;
   enum : int32_t {
-    kDataSize0FieldNumber = 1,
-    kDataSize1FieldNumber = 2,
-    kDataSize2FieldNumber = 3,
-    kDataSize3FieldNumber = 4,
-    kQueueTypeFieldNumber = 5,
-    kResourceIdFieldNumber = 6,
-    kStreamIdFieldNumber = 7,
-    kTimestampFieldNumber = 8,
+    kPidFieldNumber = 1,
+    kCallerFieldNumber = 2,
+    kIoWaitFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.VirtioVideoResourceQueueFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.SchedBlockedReasonFtraceEvent"; }
 
 
-  using FieldMetadata_DataSize0 =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioVideoResourceQueueFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedBlockedReasonFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DataSize0 kDataSize0() { return {}; }
-  void set_data_size0(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DataSize0::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DataSize1 =
+  using FieldMetadata_Caller =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioVideoResourceQueueFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SchedBlockedReasonFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DataSize1 kDataSize1() { return {}; }
-  void set_data_size1(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DataSize1::kFieldId;
+  static constexpr FieldMetadata_Caller kCaller{};
+  void set_caller(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Caller::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DataSize2 =
+  using FieldMetadata_IoWait =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      VirtioVideoResourceQueueFtraceEvent>;
+      SchedBlockedReasonFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DataSize2 kDataSize2() { return {}; }
-  void set_data_size2(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DataSize2::kFieldId;
+  static constexpr FieldMetadata_IoWait kIoWait{};
+  void set_io_wait(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IoWait::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_DataSize3 =
+class SchedWakeupFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  SchedWakeupFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SchedWakeupFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SchedWakeupFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_comm() const { return at<1>().valid(); }
+  ::protozero::ConstChars comm() const { return at<1>().as_string(); }
+  bool has_pid() const { return at<2>().valid(); }
+  int32_t pid() const { return at<2>().as_int32(); }
+  bool has_prio() const { return at<3>().valid(); }
+  int32_t prio() const { return at<3>().as_int32(); }
+  bool has_success() const { return at<4>().valid(); }
+  int32_t success() const { return at<4>().as_int32(); }
+  bool has_target_cpu() const { return at<5>().valid(); }
+  int32_t target_cpu() const { return at<5>().as_int32(); }
+};
+
+class SchedWakeupFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = SchedWakeupFtraceEvent_Decoder;
+  enum : int32_t {
+    kCommFieldNumber = 1,
+    kPidFieldNumber = 2,
+    kPrioFieldNumber = 3,
+    kSuccessFieldNumber = 4,
+    kTargetCpuFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SchedWakeupFtraceEvent"; }
+
+
+  using FieldMetadata_Comm =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioVideoResourceQueueFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SchedWakeupFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DataSize3 kDataSize3() { return {}; }
-  void set_data_size3(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DataSize3::kFieldId;
+  static constexpr FieldMetadata_Comm kComm{};
+  void set_comm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
+  }
+  void set_comm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
+  }
+  void set_comm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_QueueType =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioVideoResourceQueueFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedWakeupFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_QueueType kQueueType() { return {}; }
-  void set_queue_type(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_QueueType::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ResourceId =
+  using FieldMetadata_Prio =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      VirtioVideoResourceQueueFtraceEvent>;
+      SchedWakeupFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ResourceId kResourceId() { return {}; }
-  void set_resource_id(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ResourceId::kFieldId;
+  static constexpr FieldMetadata_Prio kPrio{};
+  void set_prio(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -130711,24 +155799,17 @@ class VirtioVideoResourceQueueFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_StreamId =
+  using FieldMetadata_Success =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      VirtioVideoResourceQueueFtraceEvent>;
+      SchedWakeupFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StreamId kStreamId() { return {}; }
-  void set_stream_id(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StreamId::kFieldId;
+  static constexpr FieldMetadata_Success kSuccess{};
+  void set_success(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Success::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -130736,172 +155817,196 @@ class VirtioVideoResourceQueueFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Timestamp =
+  using FieldMetadata_TargetCpu =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      VirtioVideoResourceQueueFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedWakeupFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timestamp kTimestamp() { return {}; }
-  void set_timestamp(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+  static constexpr FieldMetadata_TargetCpu kTargetCpu{};
+  void set_target_cpu(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TargetCpu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class VirtioVideoCmdDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class SchedSwitchFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
-  VirtioVideoCmdDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit VirtioVideoCmdDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit VirtioVideoCmdDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_stream_id() const { return at<1>().valid(); }
-  uint32_t stream_id() const { return at<1>().as_uint32(); }
-  bool has_type() const { return at<2>().valid(); }
-  uint32_t type() const { return at<2>().as_uint32(); }
+  SchedSwitchFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SchedSwitchFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SchedSwitchFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_prev_comm() const { return at<1>().valid(); }
+  ::protozero::ConstChars prev_comm() const { return at<1>().as_string(); }
+  bool has_prev_pid() const { return at<2>().valid(); }
+  int32_t prev_pid() const { return at<2>().as_int32(); }
+  bool has_prev_prio() const { return at<3>().valid(); }
+  int32_t prev_prio() const { return at<3>().as_int32(); }
+  bool has_prev_state() const { return at<4>().valid(); }
+  int64_t prev_state() const { return at<4>().as_int64(); }
+  bool has_next_comm() const { return at<5>().valid(); }
+  ::protozero::ConstChars next_comm() const { return at<5>().as_string(); }
+  bool has_next_pid() const { return at<6>().valid(); }
+  int32_t next_pid() const { return at<6>().as_int32(); }
+  bool has_next_prio() const { return at<7>().valid(); }
+  int32_t next_prio() const { return at<7>().as_int32(); }
 };
 
-class VirtioVideoCmdDoneFtraceEvent : public ::protozero::Message {
+class SchedSwitchFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = VirtioVideoCmdDoneFtraceEvent_Decoder;
+  using Decoder = SchedSwitchFtraceEvent_Decoder;
   enum : int32_t {
-    kStreamIdFieldNumber = 1,
-    kTypeFieldNumber = 2,
+    kPrevCommFieldNumber = 1,
+    kPrevPidFieldNumber = 2,
+    kPrevPrioFieldNumber = 3,
+    kPrevStateFieldNumber = 4,
+    kNextCommFieldNumber = 5,
+    kNextPidFieldNumber = 6,
+    kNextPrioFieldNumber = 7,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.VirtioVideoCmdDoneFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.SchedSwitchFtraceEvent"; }
 
 
-  using FieldMetadata_StreamId =
+  using FieldMetadata_PrevComm =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioVideoCmdDoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SchedSwitchFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StreamId kStreamId() { return {}; }
-  void set_stream_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StreamId::kFieldId;
+  static constexpr FieldMetadata_PrevComm kPrevComm{};
+  void set_prev_comm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_PrevComm::kFieldId, data, size);
+  }
+  void set_prev_comm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_PrevComm::kFieldId, chars.data, chars.size);
+  }
+  void set_prev_comm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_PrevComm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Type =
+  using FieldMetadata_PrevPid =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioVideoCmdDoneFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedSwitchFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+  static constexpr FieldMetadata_PrevPid kPrevPid{};
+  void set_prev_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PrevPid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
 
-class VirtioVideoCmdFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  VirtioVideoCmdFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit VirtioVideoCmdFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit VirtioVideoCmdFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_stream_id() const { return at<1>().valid(); }
-  uint32_t stream_id() const { return at<1>().as_uint32(); }
-  bool has_type() const { return at<2>().valid(); }
-  uint32_t type() const { return at<2>().as_uint32(); }
-};
+  using FieldMetadata_PrevPrio =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedSwitchFtraceEvent>;
 
-class VirtioVideoCmdFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = VirtioVideoCmdFtraceEvent_Decoder;
-  enum : int32_t {
-    kStreamIdFieldNumber = 1,
-    kTypeFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.VirtioVideoCmdFtraceEvent"; }
+  static constexpr FieldMetadata_PrevPrio kPrevPrio{};
+  void set_prev_prio(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PrevPrio::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
+  using FieldMetadata_PrevState =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      SchedSwitchFtraceEvent>;
 
-  using FieldMetadata_StreamId =
+  static constexpr FieldMetadata_PrevState kPrevState{};
+  void set_prev_state(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PrevState::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NextComm =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioVideoCmdFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SchedSwitchFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StreamId kStreamId() { return {}; }
-  void set_stream_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StreamId::kFieldId;
+  static constexpr FieldMetadata_NextComm kNextComm{};
+  void set_next_comm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_NextComm::kFieldId, data, size);
+  }
+  void set_next_comm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_NextComm::kFieldId, chars.data, chars.size);
+  }
+  void set_next_comm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_NextComm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Type =
+  using FieldMetadata_NextPid =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VirtioVideoCmdFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedSwitchFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+  static constexpr FieldMetadata_NextPid kNextPid{};
+  void set_next_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NextPid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_NextPrio =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SchedSwitchFtraceEvent>;
+
+  static constexpr FieldMetadata_NextPrio kNextPrio{};
+  void set_next_prio(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NextPrio::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
@@ -130910,11 +156015,11 @@ class VirtioVideoCmdFtraceEvent : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/vmscan.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/scm.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_VMSCAN_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_VMSCAN_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SCM_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SCM_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -130925,115 +156030,78 @@ class VirtioVideoCmdFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
+class ScmCallEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0> {
+ public:
+  ScmCallEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ScmCallEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ScmCallEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+};
 
-class MmShrinkSlabEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class ScmCallEndFtraceEvent : public ::protozero::Message {
  public:
-  MmShrinkSlabEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MmShrinkSlabEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MmShrinkSlabEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_new_scan() const { return at<1>().valid(); }
-  int64_t new_scan() const { return at<1>().as_int64(); }
-  bool has_retval() const { return at<2>().valid(); }
-  int32_t retval() const { return at<2>().as_int32(); }
-  bool has_shr() const { return at<3>().valid(); }
-  uint64_t shr() const { return at<3>().as_uint64(); }
-  bool has_shrink() const { return at<4>().valid(); }
-  uint64_t shrink() const { return at<4>().as_uint64(); }
-  bool has_total_scan() const { return at<5>().valid(); }
-  int64_t total_scan() const { return at<5>().as_int64(); }
-  bool has_unused_scan() const { return at<6>().valid(); }
-  int64_t unused_scan() const { return at<6>().as_int64(); }
-  bool has_nid() const { return at<7>().valid(); }
-  int32_t nid() const { return at<7>().as_int32(); }
+  using Decoder = ScmCallEndFtraceEvent_Decoder;
+  static constexpr const char* GetName() { return ".perfetto.protos.ScmCallEndFtraceEvent"; }
+
 };
 
-class MmShrinkSlabEndFtraceEvent : public ::protozero::Message {
+class ScmCallStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  using Decoder = MmShrinkSlabEndFtraceEvent_Decoder;
+  ScmCallStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ScmCallStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ScmCallStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_arginfo() const { return at<1>().valid(); }
+  uint32_t arginfo() const { return at<1>().as_uint32(); }
+  bool has_x0() const { return at<2>().valid(); }
+  uint64_t x0() const { return at<2>().as_uint64(); }
+  bool has_x5() const { return at<3>().valid(); }
+  uint64_t x5() const { return at<3>().as_uint64(); }
+};
+
+class ScmCallStartFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = ScmCallStartFtraceEvent_Decoder;
   enum : int32_t {
-    kNewScanFieldNumber = 1,
-    kRetvalFieldNumber = 2,
-    kShrFieldNumber = 3,
-    kShrinkFieldNumber = 4,
-    kTotalScanFieldNumber = 5,
-    kUnusedScanFieldNumber = 6,
-    kNidFieldNumber = 7,
+    kArginfoFieldNumber = 1,
+    kX0FieldNumber = 2,
+    kX5FieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MmShrinkSlabEndFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.ScmCallStartFtraceEvent"; }
 
 
-  using FieldMetadata_NewScan =
+  using FieldMetadata_Arginfo =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      MmShrinkSlabEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ScmCallStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NewScan kNewScan() { return {}; }
-  void set_new_scan(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NewScan::kFieldId;
+  static constexpr FieldMetadata_Arginfo kArginfo{};
+  void set_arginfo(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Arginfo::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Retval =
+  using FieldMetadata_X0 =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MmShrinkSlabEndFtraceEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Retval kRetval() { return {}; }
-  void set_retval(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Retval::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Shr =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MmShrinkSlabEndFtraceEvent>;
+      ScmCallStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Shr kShr() { return {}; }
-  void set_shr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Shr::kFieldId;
+  static constexpr FieldMetadata_X0 kX0{};
+  void set_x0(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_X0::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -131041,223 +156109,196 @@ class MmShrinkSlabEndFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Shrink =
+  using FieldMetadata_X5 =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MmShrinkSlabEndFtraceEvent>;
+      ScmCallStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Shrink kShrink() { return {}; }
-  void set_shrink(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Shrink::kFieldId;
+  static constexpr FieldMetadata_X5 kX5{};
+  void set_x5(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_X5::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_TotalScan =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      MmShrinkSlabEndFtraceEvent>;
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/scsi.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TotalScan kTotalScan() { return {}; }
-  void set_total_scan(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TotalScan::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SCSI_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SCSI_PROTO_H_
 
-  using FieldMetadata_UnusedScan =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      MmShrinkSlabEndFtraceEvent>;
+#include <stddef.h>
+#include <stdint.h>
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UnusedScan kUnusedScan() { return {}; }
-  void set_unused_scan(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_UnusedScan::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  using FieldMetadata_Nid =
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class ScsiEhWakeupFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  ScsiEhWakeupFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ScsiEhWakeupFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ScsiEhWakeupFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_host_no() const { return at<1>().valid(); }
+  uint32_t host_no() const { return at<1>().as_uint32(); }
+};
+
+class ScsiEhWakeupFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = ScsiEhWakeupFtraceEvent_Decoder;
+  enum : int32_t {
+    kHostNoFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ScsiEhWakeupFtraceEvent"; }
+
+
+  using FieldMetadata_HostNo =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MmShrinkSlabEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ScsiEhWakeupFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nid kNid() { return {}; }
-  void set_nid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
+  static constexpr FieldMetadata_HostNo kHostNo{};
+  void set_host_no(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_HostNo::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class MmShrinkSlabStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  MmShrinkSlabStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MmShrinkSlabStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MmShrinkSlabStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_cache_items() const { return at<1>().valid(); }
-  uint64_t cache_items() const { return at<1>().as_uint64(); }
-  bool has_delta() const { return at<2>().valid(); }
-  uint64_t delta() const { return at<2>().as_uint64(); }
-  bool has_gfp_flags() const { return at<3>().valid(); }
-  uint32_t gfp_flags() const { return at<3>().as_uint32(); }
-  bool has_lru_pgs() const { return at<4>().valid(); }
-  uint64_t lru_pgs() const { return at<4>().as_uint64(); }
-  bool has_nr_objects_to_shrink() const { return at<5>().valid(); }
-  int64_t nr_objects_to_shrink() const { return at<5>().as_int64(); }
-  bool has_pgs_scanned() const { return at<6>().valid(); }
-  uint64_t pgs_scanned() const { return at<6>().as_uint64(); }
-  bool has_shr() const { return at<7>().valid(); }
-  uint64_t shr() const { return at<7>().as_uint64(); }
-  bool has_shrink() const { return at<8>().valid(); }
-  uint64_t shrink() const { return at<8>().as_uint64(); }
-  bool has_total_scan() const { return at<9>().valid(); }
-  uint64_t total_scan() const { return at<9>().as_uint64(); }
-  bool has_nid() const { return at<10>().valid(); }
-  int32_t nid() const { return at<10>().as_int32(); }
-  bool has_priority() const { return at<11>().valid(); }
-  int32_t priority() const { return at<11>().as_int32(); }
-};
-
-class MmShrinkSlabStartFtraceEvent : public ::protozero::Message {
+class ScsiDispatchCmdTimeoutFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/17> {
  public:
-  using Decoder = MmShrinkSlabStartFtraceEvent_Decoder;
-  enum : int32_t {
-    kCacheItemsFieldNumber = 1,
-    kDeltaFieldNumber = 2,
-    kGfpFlagsFieldNumber = 3,
-    kLruPgsFieldNumber = 4,
-    kNrObjectsToShrinkFieldNumber = 5,
-    kPgsScannedFieldNumber = 6,
-    kShrFieldNumber = 7,
-    kShrinkFieldNumber = 8,
-    kTotalScanFieldNumber = 9,
-    kNidFieldNumber = 10,
-    kPriorityFieldNumber = 11,
+  ScsiDispatchCmdTimeoutFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ScsiDispatchCmdTimeoutFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ScsiDispatchCmdTimeoutFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_host_no() const { return at<1>().valid(); }
+  uint32_t host_no() const { return at<1>().as_uint32(); }
+  bool has_channel() const { return at<2>().valid(); }
+  uint32_t channel() const { return at<2>().as_uint32(); }
+  bool has_id() const { return at<3>().valid(); }
+  uint32_t id() const { return at<3>().as_uint32(); }
+  bool has_lun() const { return at<4>().valid(); }
+  uint32_t lun() const { return at<4>().as_uint32(); }
+  bool has_result() const { return at<5>().valid(); }
+  int32_t result() const { return at<5>().as_int32(); }
+  bool has_opcode() const { return at<6>().valid(); }
+  uint32_t opcode() const { return at<6>().as_uint32(); }
+  bool has_cmd_len() const { return at<7>().valid(); }
+  uint32_t cmd_len() const { return at<7>().as_uint32(); }
+  bool has_data_sglen() const { return at<8>().valid(); }
+  uint32_t data_sglen() const { return at<8>().as_uint32(); }
+  bool has_prot_sglen() const { return at<9>().valid(); }
+  uint32_t prot_sglen() const { return at<9>().as_uint32(); }
+  bool has_prot_op() const { return at<10>().valid(); }
+  uint32_t prot_op() const { return at<10>().as_uint32(); }
+  bool has_driver_tag() const { return at<12>().valid(); }
+  int32_t driver_tag() const { return at<12>().as_int32(); }
+  bool has_scheduler_tag() const { return at<13>().valid(); }
+  int32_t scheduler_tag() const { return at<13>().as_int32(); }
+  bool has_sense_key() const { return at<14>().valid(); }
+  uint32_t sense_key() const { return at<14>().as_uint32(); }
+  bool has_asc() const { return at<15>().valid(); }
+  uint32_t asc() const { return at<15>().as_uint32(); }
+  bool has_ascq() const { return at<16>().valid(); }
+  uint32_t ascq() const { return at<16>().as_uint32(); }
+  bool has_cmnd() const { return at<17>().valid(); }
+  ::protozero::ConstBytes cmnd() const { return at<17>().as_bytes(); }
+};
+
+class ScsiDispatchCmdTimeoutFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = ScsiDispatchCmdTimeoutFtraceEvent_Decoder;
+  enum : int32_t {
+    kHostNoFieldNumber = 1,
+    kChannelFieldNumber = 2,
+    kIdFieldNumber = 3,
+    kLunFieldNumber = 4,
+    kResultFieldNumber = 5,
+    kOpcodeFieldNumber = 6,
+    kCmdLenFieldNumber = 7,
+    kDataSglenFieldNumber = 8,
+    kProtSglenFieldNumber = 9,
+    kProtOpFieldNumber = 10,
+    kDriverTagFieldNumber = 12,
+    kSchedulerTagFieldNumber = 13,
+    kSenseKeyFieldNumber = 14,
+    kAscFieldNumber = 15,
+    kAscqFieldNumber = 16,
+    kCmndFieldNumber = 17,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MmShrinkSlabStartFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.ScsiDispatchCmdTimeoutFtraceEvent"; }
 
 
-  using FieldMetadata_CacheItems =
+  using FieldMetadata_HostNo =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MmShrinkSlabStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ScsiDispatchCmdTimeoutFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CacheItems kCacheItems() { return {}; }
-  void set_cache_items(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CacheItems::kFieldId;
+  static constexpr FieldMetadata_HostNo kHostNo{};
+  void set_host_no(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_HostNo::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Delta =
+  using FieldMetadata_Channel =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MmShrinkSlabStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ScsiDispatchCmdTimeoutFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Delta kDelta() { return {}; }
-  void set_delta(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Delta::kFieldId;
+  static constexpr FieldMetadata_Channel kChannel{};
+  void set_channel(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Channel::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_GfpFlags =
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MmShrinkSlabStartFtraceEvent>;
+      ScsiDispatchCmdTimeoutFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GfpFlags kGfpFlags() { return {}; }
-  void set_gfp_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -131265,642 +156306,420 @@ class MmShrinkSlabStartFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_LruPgs =
+  using FieldMetadata_Lun =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MmShrinkSlabStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ScsiDispatchCmdTimeoutFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LruPgs kLruPgs() { return {}; }
-  void set_lru_pgs(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LruPgs::kFieldId;
+  static constexpr FieldMetadata_Lun kLun{};
+  void set_lun(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lun::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NrObjectsToShrink =
+  using FieldMetadata_Result =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      MmShrinkSlabStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ScsiDispatchCmdTimeoutFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrObjectsToShrink kNrObjectsToShrink() { return {}; }
-  void set_nr_objects_to_shrink(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NrObjectsToShrink::kFieldId;
+  static constexpr FieldMetadata_Result kResult{};
+  void set_result(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Result::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PgsScanned =
+  using FieldMetadata_Opcode =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MmShrinkSlabStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ScsiDispatchCmdTimeoutFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PgsScanned kPgsScanned() { return {}; }
-  void set_pgs_scanned(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PgsScanned::kFieldId;
+  static constexpr FieldMetadata_Opcode kOpcode{};
+  void set_opcode(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Opcode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Shr =
+  using FieldMetadata_CmdLen =
     ::protozero::proto_utils::FieldMetadata<
       7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MmShrinkSlabStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ScsiDispatchCmdTimeoutFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Shr kShr() { return {}; }
-  void set_shr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Shr::kFieldId;
+  static constexpr FieldMetadata_CmdLen kCmdLen{};
+  void set_cmd_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CmdLen::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Shrink =
+  using FieldMetadata_DataSglen =
     ::protozero::proto_utils::FieldMetadata<
       8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MmShrinkSlabStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ScsiDispatchCmdTimeoutFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Shrink kShrink() { return {}; }
-  void set_shrink(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Shrink::kFieldId;
+  static constexpr FieldMetadata_DataSglen kDataSglen{};
+  void set_data_sglen(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DataSglen::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TotalScan =
+  using FieldMetadata_ProtSglen =
     ::protozero::proto_utils::FieldMetadata<
       9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MmShrinkSlabStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ScsiDispatchCmdTimeoutFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TotalScan kTotalScan() { return {}; }
-  void set_total_scan(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TotalScan::kFieldId;
+  static constexpr FieldMetadata_ProtSglen kProtSglen{};
+  void set_prot_sglen(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProtSglen::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Nid =
+  using FieldMetadata_ProtOp =
     ::protozero::proto_utils::FieldMetadata<
       10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MmShrinkSlabStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ScsiDispatchCmdTimeoutFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nid kNid() { return {}; }
-  void set_nid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
+  static constexpr FieldMetadata_ProtOp kProtOp{};
+  void set_prot_op(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProtOp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Priority =
+  using FieldMetadata_DriverTag =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      12,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      MmShrinkSlabStartFtraceEvent>;
+      ScsiDispatchCmdTimeoutFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Priority kPriority() { return {}; }
-  void set_priority(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Priority::kFieldId;
+  static constexpr FieldMetadata_DriverTag kDriverTag{};
+  void set_driver_tag(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DriverTag::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-class MmVmscanKswapdSleepFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  MmVmscanKswapdSleepFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MmVmscanKswapdSleepFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MmVmscanKswapdSleepFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_nid() const { return at<1>().valid(); }
-  int32_t nid() const { return at<1>().as_int32(); }
-};
-
-class MmVmscanKswapdSleepFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = MmVmscanKswapdSleepFtraceEvent_Decoder;
-  enum : int32_t {
-    kNidFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.MmVmscanKswapdSleepFtraceEvent"; }
 
-
-  using FieldMetadata_Nid =
+  using FieldMetadata_SchedulerTag =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      13,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      MmVmscanKswapdSleepFtraceEvent>;
+      ScsiDispatchCmdTimeoutFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nid kNid() { return {}; }
-  void set_nid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
+  static constexpr FieldMetadata_SchedulerTag kSchedulerTag{};
+  void set_scheduler_tag(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SchedulerTag::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-class MmVmscanKswapdWakeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  MmVmscanKswapdWakeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MmVmscanKswapdWakeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MmVmscanKswapdWakeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_nid() const { return at<1>().valid(); }
-  int32_t nid() const { return at<1>().as_int32(); }
-  bool has_order() const { return at<2>().valid(); }
-  int32_t order() const { return at<2>().as_int32(); }
-  bool has_zid() const { return at<3>().valid(); }
-  int32_t zid() const { return at<3>().as_int32(); }
-};
-
-class MmVmscanKswapdWakeFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = MmVmscanKswapdWakeFtraceEvent_Decoder;
-  enum : int32_t {
-    kNidFieldNumber = 1,
-    kOrderFieldNumber = 2,
-    kZidFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.MmVmscanKswapdWakeFtraceEvent"; }
 
-
-  using FieldMetadata_Nid =
+  using FieldMetadata_SenseKey =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      14,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MmVmscanKswapdWakeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ScsiDispatchCmdTimeoutFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nid kNid() { return {}; }
-  void set_nid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
+  static constexpr FieldMetadata_SenseKey kSenseKey{};
+  void set_sense_key(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SenseKey::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Order =
+  using FieldMetadata_Asc =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      15,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MmVmscanKswapdWakeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ScsiDispatchCmdTimeoutFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Order kOrder() { return {}; }
-  void set_order(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
+  static constexpr FieldMetadata_Asc kAsc{};
+  void set_asc(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Asc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Zid =
+  using FieldMetadata_Ascq =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      16,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MmVmscanKswapdWakeFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ScsiDispatchCmdTimeoutFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Zid kZid() { return {}; }
-  void set_zid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Zid::kFieldId;
+  static constexpr FieldMetadata_Ascq kAscq{};
+  void set_ascq(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ascq::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class MmVmscanDirectReclaimEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  MmVmscanDirectReclaimEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MmVmscanDirectReclaimEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MmVmscanDirectReclaimEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_nr_reclaimed() const { return at<1>().valid(); }
-  uint64_t nr_reclaimed() const { return at<1>().as_uint64(); }
-};
-
-class MmVmscanDirectReclaimEndFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = MmVmscanDirectReclaimEndFtraceEvent_Decoder;
-  enum : int32_t {
-    kNrReclaimedFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.MmVmscanDirectReclaimEndFtraceEvent"; }
 
-
-  using FieldMetadata_NrReclaimed =
+  using FieldMetadata_Cmnd =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      17,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MmVmscanDirectReclaimEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      ScsiDispatchCmdTimeoutFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NrReclaimed kNrReclaimed() { return {}; }
-  void set_nr_reclaimed(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NrReclaimed::kFieldId;
+  static constexpr FieldMetadata_Cmnd kCmnd{};
+  void set_cmnd(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_Cmnd::kFieldId, data, size);
+  }
+  void set_cmnd(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_Cmnd::kFieldId, bytes.data, bytes.size);
+  }
+  void set_cmnd(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cmnd::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
         ::Append(*this, field_id, value);
   }
 };
 
-class MmVmscanDirectReclaimBeginFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class ScsiDispatchCmdErrorFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/14> {
  public:
-  MmVmscanDirectReclaimBeginFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MmVmscanDirectReclaimBeginFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MmVmscanDirectReclaimBeginFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_order() const { return at<1>().valid(); }
-  int32_t order() const { return at<1>().as_int32(); }
-  bool has_may_writepage() const { return at<2>().valid(); }
-  int32_t may_writepage() const { return at<2>().as_int32(); }
-  bool has_gfp_flags() const { return at<3>().valid(); }
-  uint32_t gfp_flags() const { return at<3>().as_uint32(); }
+  ScsiDispatchCmdErrorFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ScsiDispatchCmdErrorFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ScsiDispatchCmdErrorFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_host_no() const { return at<1>().valid(); }
+  uint32_t host_no() const { return at<1>().as_uint32(); }
+  bool has_channel() const { return at<2>().valid(); }
+  uint32_t channel() const { return at<2>().as_uint32(); }
+  bool has_id() const { return at<3>().valid(); }
+  uint32_t id() const { return at<3>().as_uint32(); }
+  bool has_lun() const { return at<4>().valid(); }
+  uint32_t lun() const { return at<4>().as_uint32(); }
+  bool has_rtn() const { return at<5>().valid(); }
+  int32_t rtn() const { return at<5>().as_int32(); }
+  bool has_opcode() const { return at<6>().valid(); }
+  uint32_t opcode() const { return at<6>().as_uint32(); }
+  bool has_cmd_len() const { return at<7>().valid(); }
+  uint32_t cmd_len() const { return at<7>().as_uint32(); }
+  bool has_data_sglen() const { return at<8>().valid(); }
+  uint32_t data_sglen() const { return at<8>().as_uint32(); }
+  bool has_prot_sglen() const { return at<9>().valid(); }
+  uint32_t prot_sglen() const { return at<9>().as_uint32(); }
+  bool has_prot_op() const { return at<10>().valid(); }
+  uint32_t prot_op() const { return at<10>().as_uint32(); }
+  bool has_driver_tag() const { return at<12>().valid(); }
+  int32_t driver_tag() const { return at<12>().as_int32(); }
+  bool has_scheduler_tag() const { return at<13>().valid(); }
+  int32_t scheduler_tag() const { return at<13>().as_int32(); }
+  bool has_cmnd() const { return at<14>().valid(); }
+  ::protozero::ConstBytes cmnd() const { return at<14>().as_bytes(); }
 };
 
-class MmVmscanDirectReclaimBeginFtraceEvent : public ::protozero::Message {
+class ScsiDispatchCmdErrorFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = MmVmscanDirectReclaimBeginFtraceEvent_Decoder;
+  using Decoder = ScsiDispatchCmdErrorFtraceEvent_Decoder;
   enum : int32_t {
-    kOrderFieldNumber = 1,
-    kMayWritepageFieldNumber = 2,
-    kGfpFlagsFieldNumber = 3,
+    kHostNoFieldNumber = 1,
+    kChannelFieldNumber = 2,
+    kIdFieldNumber = 3,
+    kLunFieldNumber = 4,
+    kRtnFieldNumber = 5,
+    kOpcodeFieldNumber = 6,
+    kCmdLenFieldNumber = 7,
+    kDataSglenFieldNumber = 8,
+    kProtSglenFieldNumber = 9,
+    kProtOpFieldNumber = 10,
+    kDriverTagFieldNumber = 12,
+    kSchedulerTagFieldNumber = 13,
+    kCmndFieldNumber = 14,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MmVmscanDirectReclaimBeginFtraceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.ScsiDispatchCmdErrorFtraceEvent"; }
 
 
-  using FieldMetadata_Order =
+  using FieldMetadata_HostNo =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MmVmscanDirectReclaimBeginFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ScsiDispatchCmdErrorFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Order kOrder() { return {}; }
-  void set_order(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
+  static constexpr FieldMetadata_HostNo kHostNo{};
+  void set_host_no(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_HostNo::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MayWritepage =
+  using FieldMetadata_Channel =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MmVmscanDirectReclaimBeginFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ScsiDispatchCmdErrorFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MayWritepage kMayWritepage() { return {}; }
-  void set_may_writepage(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MayWritepage::kFieldId;
+  static constexpr FieldMetadata_Channel kChannel{};
+  void set_channel(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Channel::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_GfpFlags =
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      MmVmscanDirectReclaimBeginFtraceEvent>;
+      ScsiDispatchCmdErrorFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GfpFlags kGfpFlags() { return {}; }
-  void set_gfp_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/workqueue.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_WORKQUEUE_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_WORKQUEUE_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
 
-class WorkqueueQueueWorkFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  WorkqueueQueueWorkFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit WorkqueueQueueWorkFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit WorkqueueQueueWorkFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_work() const { return at<1>().valid(); }
-  uint64_t work() const { return at<1>().as_uint64(); }
-  bool has_function() const { return at<2>().valid(); }
-  uint64_t function() const { return at<2>().as_uint64(); }
-  bool has_workqueue() const { return at<3>().valid(); }
-  uint64_t workqueue() const { return at<3>().as_uint64(); }
-  bool has_req_cpu() const { return at<4>().valid(); }
-  uint32_t req_cpu() const { return at<4>().as_uint32(); }
-  bool has_cpu() const { return at<5>().valid(); }
-  uint32_t cpu() const { return at<5>().as_uint32(); }
-};
-
-class WorkqueueQueueWorkFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = WorkqueueQueueWorkFtraceEvent_Decoder;
-  enum : int32_t {
-    kWorkFieldNumber = 1,
-    kFunctionFieldNumber = 2,
-    kWorkqueueFieldNumber = 3,
-    kReqCpuFieldNumber = 4,
-    kCpuFieldNumber = 5,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.WorkqueueQueueWorkFtraceEvent"; }
-
-
-  using FieldMetadata_Work =
+  using FieldMetadata_Lun =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      WorkqueueQueueWorkFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ScsiDispatchCmdErrorFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Work kWork() { return {}; }
-  void set_work(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Work::kFieldId;
+  static constexpr FieldMetadata_Lun kLun{};
+  void set_lun(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lun::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Function =
+  using FieldMetadata_Rtn =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      WorkqueueQueueWorkFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ScsiDispatchCmdErrorFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Function kFunction() { return {}; }
-  void set_function(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Function::kFieldId;
+  static constexpr FieldMetadata_Rtn kRtn{};
+  void set_rtn(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Rtn::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Workqueue =
+  using FieldMetadata_Opcode =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      WorkqueueQueueWorkFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ScsiDispatchCmdErrorFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Workqueue kWorkqueue() { return {}; }
-  void set_workqueue(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Workqueue::kFieldId;
+  static constexpr FieldMetadata_Opcode kOpcode{};
+  void set_opcode(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Opcode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ReqCpu =
+  using FieldMetadata_CmdLen =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      WorkqueueQueueWorkFtraceEvent>;
+      ScsiDispatchCmdErrorFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReqCpu kReqCpu() { return {}; }
-  void set_req_cpu(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReqCpu::kFieldId;
+  static constexpr FieldMetadata_CmdLen kCmdLen{};
+  void set_cmd_len(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CmdLen::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -131908,216 +156727,117 @@ class WorkqueueQueueWorkFtraceEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Cpu =
+  using FieldMetadata_DataSglen =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      WorkqueueQueueWorkFtraceEvent>;
+      ScsiDispatchCmdErrorFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cpu kCpu() { return {}; }
-  void set_cpu(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId;
+  static constexpr FieldMetadata_DataSglen kDataSglen{};
+  void set_data_sglen(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DataSglen::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class WorkqueueExecuteStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  WorkqueueExecuteStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit WorkqueueExecuteStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit WorkqueueExecuteStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_work() const { return at<1>().valid(); }
-  uint64_t work() const { return at<1>().as_uint64(); }
-  bool has_function() const { return at<2>().valid(); }
-  uint64_t function() const { return at<2>().as_uint64(); }
-};
-
-class WorkqueueExecuteStartFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = WorkqueueExecuteStartFtraceEvent_Decoder;
-  enum : int32_t {
-    kWorkFieldNumber = 1,
-    kFunctionFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.WorkqueueExecuteStartFtraceEvent"; }
-
 
-  using FieldMetadata_Work =
+  using FieldMetadata_ProtSglen =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      WorkqueueExecuteStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ScsiDispatchCmdErrorFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Work kWork() { return {}; }
-  void set_work(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Work::kFieldId;
+  static constexpr FieldMetadata_ProtSglen kProtSglen{};
+  void set_prot_sglen(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProtSglen::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Function =
+  using FieldMetadata_ProtOp =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      WorkqueueExecuteStartFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ScsiDispatchCmdErrorFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Function kFunction() { return {}; }
-  void set_function(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Function::kFieldId;
+  static constexpr FieldMetadata_ProtOp kProtOp{};
+  void set_prot_op(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProtOp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class WorkqueueExecuteEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  WorkqueueExecuteEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit WorkqueueExecuteEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit WorkqueueExecuteEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_work() const { return at<1>().valid(); }
-  uint64_t work() const { return at<1>().as_uint64(); }
-  bool has_function() const { return at<2>().valid(); }
-  uint64_t function() const { return at<2>().as_uint64(); }
-};
-
-class WorkqueueExecuteEndFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = WorkqueueExecuteEndFtraceEvent_Decoder;
-  enum : int32_t {
-    kWorkFieldNumber = 1,
-    kFunctionFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.WorkqueueExecuteEndFtraceEvent"; }
 
-
-  using FieldMetadata_Work =
+  using FieldMetadata_DriverTag =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      12,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      WorkqueueExecuteEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ScsiDispatchCmdErrorFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Work kWork() { return {}; }
-  void set_work(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Work::kFieldId;
+  static constexpr FieldMetadata_DriverTag kDriverTag{};
+  void set_driver_tag(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DriverTag::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Function =
+  using FieldMetadata_SchedulerTag =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      13,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      WorkqueueExecuteEndFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ScsiDispatchCmdErrorFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Function kFunction() { return {}; }
-  void set_function(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Function::kFieldId;
+  static constexpr FieldMetadata_SchedulerTag kSchedulerTag{};
+  void set_scheduler_tag(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SchedulerTag::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-class WorkqueueActivateWorkFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  WorkqueueActivateWorkFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit WorkqueueActivateWorkFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit WorkqueueActivateWorkFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_work() const { return at<1>().valid(); }
-  uint64_t work() const { return at<1>().as_uint64(); }
-};
-
-class WorkqueueActivateWorkFtraceEvent : public ::protozero::Message {
- public:
-  using Decoder = WorkqueueActivateWorkFtraceEvent_Decoder;
-  enum : int32_t {
-    kWorkFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.WorkqueueActivateWorkFtraceEvent"; }
 
-
-  using FieldMetadata_Work =
+  using FieldMetadata_Cmnd =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      14,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      WorkqueueActivateWorkFtraceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      ScsiDispatchCmdErrorFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Work kWork() { return {}; }
-  void set_work(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Work::kFieldId;
+  static constexpr FieldMetadata_Cmnd kCmnd{};
+  void set_cmnd(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_Cmnd::kFieldId, data, size);
+  }
+  void set_cmnd(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_Cmnd::kFieldId, bytes.data, bytes.size);
+  }
+  void set_cmnd(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cmnd::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
         ::Append(*this, field_id, value);
   }
 };
@@ -132126,11 +156846,11 @@ class WorkqueueActivateWorkFtraceEvent : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/gpu/gpu_counter_event.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/sde.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GPU_GPU_COUNTER_EVENT_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GPU_GPU_COUNTER_EVENT_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SDE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SDE_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -132141,148 +156861,155 @@ class WorkqueueActivateWorkFtraceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-class GpuCounterDescriptor;
-class GpuCounterEvent_GpuCounter;
-
-class GpuCounterEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class SdeSdePerfUpdateBusFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  GpuCounterEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit GpuCounterEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit GpuCounterEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_counter_descriptor() const { return at<1>().valid(); }
-  ::protozero::ConstBytes counter_descriptor() const { return at<1>().as_bytes(); }
-  bool has_counters() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> counters() const { return GetRepeated<::protozero::ConstBytes>(2); }
-  bool has_gpu_id() const { return at<3>().valid(); }
-  int32_t gpu_id() const { return at<3>().as_int32(); }
+  SdeSdePerfUpdateBusFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SdeSdePerfUpdateBusFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SdeSdePerfUpdateBusFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_ab_quota() const { return at<1>().valid(); }
+  uint64_t ab_quota() const { return at<1>().as_uint64(); }
+  bool has_bus_id() const { return at<2>().valid(); }
+  uint32_t bus_id() const { return at<2>().as_uint32(); }
+  bool has_client() const { return at<3>().valid(); }
+  int32_t client() const { return at<3>().as_int32(); }
+  bool has_ib_quota() const { return at<4>().valid(); }
+  uint64_t ib_quota() const { return at<4>().as_uint64(); }
 };
 
-class GpuCounterEvent : public ::protozero::Message {
+class SdeSdePerfUpdateBusFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = GpuCounterEvent_Decoder;
+  using Decoder = SdeSdePerfUpdateBusFtraceEvent_Decoder;
   enum : int32_t {
-    kCounterDescriptorFieldNumber = 1,
-    kCountersFieldNumber = 2,
-    kGpuIdFieldNumber = 3,
+    kAbQuotaFieldNumber = 1,
+    kBusIdFieldNumber = 2,
+    kClientFieldNumber = 3,
+    kIbQuotaFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.GpuCounterEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.SdeSdePerfUpdateBusFtraceEvent"; }
 
-  using GpuCounter = ::perfetto::protos::pbzero::GpuCounterEvent_GpuCounter;
 
-  using FieldMetadata_CounterDescriptor =
+  using FieldMetadata_AbQuota =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      GpuCounterDescriptor,
-      GpuCounterEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SdeSdePerfUpdateBusFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CounterDescriptor kCounterDescriptor() { return {}; }
-  template <typename T = GpuCounterDescriptor> T* set_counter_descriptor() {
-    return BeginNestedMessage<T>(1);
+  static constexpr FieldMetadata_AbQuota kAbQuota{};
+  void set_ab_quota(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AbQuota::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_Counters =
+  using FieldMetadata_BusId =
     ::protozero::proto_utils::FieldMetadata<
       2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      GpuCounterEvent_GpuCounter,
-      GpuCounterEvent>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SdeSdePerfUpdateBusFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Counters kCounters() { return {}; }
-  template <typename T = GpuCounterEvent_GpuCounter> T* add_counters() {
-    return BeginNestedMessage<T>(2);
+  static constexpr FieldMetadata_BusId kBusId{};
+  void set_bus_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BusId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_GpuId =
+  using FieldMetadata_Client =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      GpuCounterEvent>;
+      SdeSdePerfUpdateBusFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GpuId kGpuId() { return {}; }
-  void set_gpu_id(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GpuId::kFieldId;
+  static constexpr FieldMetadata_Client kClient{};
+  void set_client(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Client::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_IbQuota =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SdeSdePerfUpdateBusFtraceEvent>;
+
+  static constexpr FieldMetadata_IbQuota kIbQuota{};
+  void set_ib_quota(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IbQuota::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class GpuCounterEvent_GpuCounter_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class SdeSdePerfSetQosLutsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  GpuCounterEvent_GpuCounter_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit GpuCounterEvent_GpuCounter_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit GpuCounterEvent_GpuCounter_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_counter_id() const { return at<1>().valid(); }
-  uint32_t counter_id() const { return at<1>().as_uint32(); }
-  bool has_int_value() const { return at<2>().valid(); }
-  int64_t int_value() const { return at<2>().as_int64(); }
-  bool has_double_value() const { return at<3>().valid(); }
-  double double_value() const { return at<3>().as_double(); }
+  SdeSdePerfSetQosLutsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SdeSdePerfSetQosLutsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SdeSdePerfSetQosLutsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_fl() const { return at<1>().valid(); }
+  uint32_t fl() const { return at<1>().as_uint32(); }
+  bool has_fmt() const { return at<2>().valid(); }
+  uint32_t fmt() const { return at<2>().as_uint32(); }
+  bool has_lut() const { return at<3>().valid(); }
+  uint64_t lut() const { return at<3>().as_uint64(); }
+  bool has_lut_usage() const { return at<4>().valid(); }
+  uint32_t lut_usage() const { return at<4>().as_uint32(); }
+  bool has_pnum() const { return at<5>().valid(); }
+  uint32_t pnum() const { return at<5>().as_uint32(); }
+  bool has_rt() const { return at<6>().valid(); }
+  uint32_t rt() const { return at<6>().as_uint32(); }
 };
 
-class GpuCounterEvent_GpuCounter : public ::protozero::Message {
+class SdeSdePerfSetQosLutsFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = GpuCounterEvent_GpuCounter_Decoder;
+  using Decoder = SdeSdePerfSetQosLutsFtraceEvent_Decoder;
   enum : int32_t {
-    kCounterIdFieldNumber = 1,
-    kIntValueFieldNumber = 2,
-    kDoubleValueFieldNumber = 3,
+    kFlFieldNumber = 1,
+    kFmtFieldNumber = 2,
+    kLutFieldNumber = 3,
+    kLutUsageFieldNumber = 4,
+    kPnumFieldNumber = 5,
+    kRtFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.GpuCounterEvent.GpuCounter"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.SdeSdePerfSetQosLutsFtraceEvent"; }
 
 
-  using FieldMetadata_CounterId =
+  using FieldMetadata_Fl =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      GpuCounterEvent_GpuCounter>;
+      SdeSdePerfSetQosLutsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CounterId kCounterId() { return {}; }
-  void set_counter_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CounterId::kFieldId;
+  static constexpr FieldMetadata_Fl kFl{};
+  void set_fl(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Fl::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -132290,400 +157017,195 @@ class GpuCounterEvent_GpuCounter : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IntValue =
+  using FieldMetadata_Fmt =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      GpuCounterEvent_GpuCounter>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SdeSdePerfSetQosLutsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IntValue kIntValue() { return {}; }
-  void set_int_value(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId;
+  static constexpr FieldMetadata_Fmt kFmt{};
+  void set_fmt(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Fmt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DoubleValue =
+  using FieldMetadata_Lut =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kDouble,
-      double,
-      GpuCounterEvent_GpuCounter>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SdeSdePerfSetQosLutsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DoubleValue kDoubleValue() { return {}; }
-  void set_double_value(double value) {
-    static constexpr uint32_t field_id = FieldMetadata_DoubleValue::kFieldId;
+  static constexpr FieldMetadata_Lut kLut{};
+  void set_lut(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lut::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/gpu/gpu_log.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GPU_GPU_LOG_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GPU_GPU_LOG_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-namespace perfetto_pbzero_enum_GpuLog {
-enum Severity : int32_t;
-}  // namespace perfetto_pbzero_enum_GpuLog
-using GpuLog_Severity = perfetto_pbzero_enum_GpuLog::Severity;
-
-namespace perfetto_pbzero_enum_GpuLog {
-enum Severity : int32_t {
-  LOG_SEVERITY_UNSPECIFIED = 0,
-  LOG_SEVERITY_VERBOSE = 1,
-  LOG_SEVERITY_DEBUG = 2,
-  LOG_SEVERITY_INFO = 3,
-  LOG_SEVERITY_WARNING = 4,
-  LOG_SEVERITY_ERROR = 5,
-};
-} // namespace perfetto_pbzero_enum_GpuLog
-using GpuLog_Severity = perfetto_pbzero_enum_GpuLog::Severity;
-
-
-constexpr GpuLog_Severity GpuLog_Severity_MIN = GpuLog_Severity::LOG_SEVERITY_UNSPECIFIED;
-constexpr GpuLog_Severity GpuLog_Severity_MAX = GpuLog_Severity::LOG_SEVERITY_ERROR;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* GpuLog_Severity_Name(::perfetto::protos::pbzero::GpuLog_Severity value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::GpuLog_Severity::LOG_SEVERITY_UNSPECIFIED:
-    return "LOG_SEVERITY_UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::GpuLog_Severity::LOG_SEVERITY_VERBOSE:
-    return "LOG_SEVERITY_VERBOSE";
-
-  case ::perfetto::protos::pbzero::GpuLog_Severity::LOG_SEVERITY_DEBUG:
-    return "LOG_SEVERITY_DEBUG";
-
-  case ::perfetto::protos::pbzero::GpuLog_Severity::LOG_SEVERITY_INFO:
-    return "LOG_SEVERITY_INFO";
-
-  case ::perfetto::protos::pbzero::GpuLog_Severity::LOG_SEVERITY_WARNING:
-    return "LOG_SEVERITY_WARNING";
-
-  case ::perfetto::protos::pbzero::GpuLog_Severity::LOG_SEVERITY_ERROR:
-    return "LOG_SEVERITY_ERROR";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-class GpuLog_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  GpuLog_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit GpuLog_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit GpuLog_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_severity() const { return at<1>().valid(); }
-  int32_t severity() const { return at<1>().as_int32(); }
-  bool has_tag() const { return at<2>().valid(); }
-  ::protozero::ConstChars tag() const { return at<2>().as_string(); }
-  bool has_log_message() const { return at<3>().valid(); }
-  ::protozero::ConstChars log_message() const { return at<3>().as_string(); }
-};
-
-class GpuLog : public ::protozero::Message {
- public:
-  using Decoder = GpuLog_Decoder;
-  enum : int32_t {
-    kSeverityFieldNumber = 1,
-    kTagFieldNumber = 2,
-    kLogMessageFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.GpuLog"; }
-
-
-  using Severity = ::perfetto::protos::pbzero::GpuLog_Severity;
-  static inline const char* Severity_Name(Severity value) {
-    return ::perfetto::protos::pbzero::GpuLog_Severity_Name(value);
-  }
-  static const Severity LOG_SEVERITY_UNSPECIFIED = Severity::LOG_SEVERITY_UNSPECIFIED;
-  static const Severity LOG_SEVERITY_VERBOSE = Severity::LOG_SEVERITY_VERBOSE;
-  static const Severity LOG_SEVERITY_DEBUG = Severity::LOG_SEVERITY_DEBUG;
-  static const Severity LOG_SEVERITY_INFO = Severity::LOG_SEVERITY_INFO;
-  static const Severity LOG_SEVERITY_WARNING = Severity::LOG_SEVERITY_WARNING;
-  static const Severity LOG_SEVERITY_ERROR = Severity::LOG_SEVERITY_ERROR;
 
-  using FieldMetadata_Severity =
+  using FieldMetadata_LutUsage =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::GpuLog_Severity,
-      GpuLog>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SdeSdePerfSetQosLutsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Severity kSeverity() { return {}; }
-  void set_severity(::perfetto::protos::pbzero::GpuLog_Severity value) {
-    static constexpr uint32_t field_id = FieldMetadata_Severity::kFieldId;
+  static constexpr FieldMetadata_LutUsage kLutUsage{};
+  void set_lut_usage(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LutUsage::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Tag =
+  using FieldMetadata_Pnum =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      GpuLog>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SdeSdePerfSetQosLutsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Tag kTag() { return {}; }
-  void set_tag(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Tag::kFieldId, data, size);
-  }
-  void set_tag(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Tag::kFieldId, chars.data, chars.size);
-  }
-  void set_tag(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Tag::kFieldId;
+  static constexpr FieldMetadata_Pnum kPnum{};
+  void set_pnum(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pnum::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_LogMessage =
+  using FieldMetadata_Rt =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      GpuLog>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SdeSdePerfSetQosLutsFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LogMessage kLogMessage() { return {}; }
-  void set_log_message(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_LogMessage::kFieldId, data, size);
-  }
-  void set_log_message(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_LogMessage::kFieldId, chars.data, chars.size);
-  }
-  void set_log_message(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_LogMessage::kFieldId;
+  static constexpr FieldMetadata_Rt kRt{};
+  void set_rt(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Rt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/gpu/gpu_render_stage_event.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GPU_GPU_RENDER_STAGE_EVENT_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GPU_GPU_RENDER_STAGE_EVENT_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-class GpuRenderStageEvent_ExtraData;
-class GpuRenderStageEvent_Specifications;
-class GpuRenderStageEvent_Specifications_ContextSpec;
-class GpuRenderStageEvent_Specifications_Description;
-namespace perfetto_pbzero_enum_InternedGpuRenderStageSpecification {
-enum RenderStageCategory : int32_t;
-}  // namespace perfetto_pbzero_enum_InternedGpuRenderStageSpecification
-using InternedGpuRenderStageSpecification_RenderStageCategory = perfetto_pbzero_enum_InternedGpuRenderStageSpecification::RenderStageCategory;
-namespace perfetto_pbzero_enum_InternedGraphicsContext {
-enum Api : int32_t;
-}  // namespace perfetto_pbzero_enum_InternedGraphicsContext
-using InternedGraphicsContext_Api = perfetto_pbzero_enum_InternedGraphicsContext::Api;
-
-namespace perfetto_pbzero_enum_InternedGpuRenderStageSpecification {
-enum RenderStageCategory : int32_t {
-  OTHER = 0,
-  GRAPHICS = 1,
-  COMPUTE = 2,
-};
-} // namespace perfetto_pbzero_enum_InternedGpuRenderStageSpecification
-using InternedGpuRenderStageSpecification_RenderStageCategory = perfetto_pbzero_enum_InternedGpuRenderStageSpecification::RenderStageCategory;
-
-
-constexpr InternedGpuRenderStageSpecification_RenderStageCategory InternedGpuRenderStageSpecification_RenderStageCategory_MIN = InternedGpuRenderStageSpecification_RenderStageCategory::OTHER;
-constexpr InternedGpuRenderStageSpecification_RenderStageCategory InternedGpuRenderStageSpecification_RenderStageCategory_MAX = InternedGpuRenderStageSpecification_RenderStageCategory::COMPUTE;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* InternedGpuRenderStageSpecification_RenderStageCategory_Name(::perfetto::protos::pbzero::InternedGpuRenderStageSpecification_RenderStageCategory value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::InternedGpuRenderStageSpecification_RenderStageCategory::OTHER:
-    return "OTHER";
-
-  case ::perfetto::protos::pbzero::InternedGpuRenderStageSpecification_RenderStageCategory::GRAPHICS:
-    return "GRAPHICS";
-
-  case ::perfetto::protos::pbzero::InternedGpuRenderStageSpecification_RenderStageCategory::COMPUTE:
-    return "COMPUTE";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-namespace perfetto_pbzero_enum_InternedGraphicsContext {
-enum Api : int32_t {
-  UNDEFINED = 0,
-  OPEN_GL = 1,
-  VULKAN = 2,
-  OPEN_CL = 3,
-};
-} // namespace perfetto_pbzero_enum_InternedGraphicsContext
-using InternedGraphicsContext_Api = perfetto_pbzero_enum_InternedGraphicsContext::Api;
-
-
-constexpr InternedGraphicsContext_Api InternedGraphicsContext_Api_MIN = InternedGraphicsContext_Api::UNDEFINED;
-constexpr InternedGraphicsContext_Api InternedGraphicsContext_Api_MAX = InternedGraphicsContext_Api::OPEN_CL;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* InternedGraphicsContext_Api_Name(::perfetto::protos::pbzero::InternedGraphicsContext_Api value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::InternedGraphicsContext_Api::UNDEFINED:
-    return "UNDEFINED";
-
-  case ::perfetto::protos::pbzero::InternedGraphicsContext_Api::OPEN_GL:
-    return "OPEN_GL";
-
-  case ::perfetto::protos::pbzero::InternedGraphicsContext_Api::VULKAN:
-    return "VULKAN";
-
-  case ::perfetto::protos::pbzero::InternedGraphicsContext_Api::OPEN_CL:
-    return "OPEN_CL";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-class InternedGpuRenderStageSpecification_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class SdeSdePerfCrtcUpdateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/12> {
  public:
-  InternedGpuRenderStageSpecification_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit InternedGpuRenderStageSpecification_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit InternedGpuRenderStageSpecification_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_iid() const { return at<1>().valid(); }
-  uint64_t iid() const { return at<1>().as_uint64(); }
-  bool has_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars name() const { return at<2>().as_string(); }
-  bool has_description() const { return at<3>().valid(); }
-  ::protozero::ConstChars description() const { return at<3>().as_string(); }
-  bool has_category() const { return at<4>().valid(); }
-  int32_t category() const { return at<4>().as_int32(); }
+  SdeSdePerfCrtcUpdateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SdeSdePerfCrtcUpdateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SdeSdePerfCrtcUpdateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_bw_ctl_ebi() const { return at<1>().valid(); }
+  uint64_t bw_ctl_ebi() const { return at<1>().as_uint64(); }
+  bool has_bw_ctl_llcc() const { return at<2>().valid(); }
+  uint64_t bw_ctl_llcc() const { return at<2>().as_uint64(); }
+  bool has_bw_ctl_mnoc() const { return at<3>().valid(); }
+  uint64_t bw_ctl_mnoc() const { return at<3>().as_uint64(); }
+  bool has_core_clk_rate() const { return at<4>().valid(); }
+  uint32_t core_clk_rate() const { return at<4>().as_uint32(); }
+  bool has_crtc() const { return at<5>().valid(); }
+  uint32_t crtc() const { return at<5>().as_uint32(); }
+  bool has_params() const { return at<6>().valid(); }
+  int32_t params() const { return at<6>().as_int32(); }
+  bool has_per_pipe_ib_ebi() const { return at<7>().valid(); }
+  uint64_t per_pipe_ib_ebi() const { return at<7>().as_uint64(); }
+  bool has_per_pipe_ib_llcc() const { return at<8>().valid(); }
+  uint64_t per_pipe_ib_llcc() const { return at<8>().as_uint64(); }
+  bool has_per_pipe_ib_mnoc() const { return at<9>().valid(); }
+  uint64_t per_pipe_ib_mnoc() const { return at<9>().as_uint64(); }
+  bool has_stop_req() const { return at<10>().valid(); }
+  uint32_t stop_req() const { return at<10>().as_uint32(); }
+  bool has_update_bus() const { return at<11>().valid(); }
+  uint32_t update_bus() const { return at<11>().as_uint32(); }
+  bool has_update_clk() const { return at<12>().valid(); }
+  uint32_t update_clk() const { return at<12>().as_uint32(); }
 };
 
-class InternedGpuRenderStageSpecification : public ::protozero::Message {
+class SdeSdePerfCrtcUpdateFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = InternedGpuRenderStageSpecification_Decoder;
+  using Decoder = SdeSdePerfCrtcUpdateFtraceEvent_Decoder;
   enum : int32_t {
-    kIidFieldNumber = 1,
-    kNameFieldNumber = 2,
-    kDescriptionFieldNumber = 3,
-    kCategoryFieldNumber = 4,
+    kBwCtlEbiFieldNumber = 1,
+    kBwCtlLlccFieldNumber = 2,
+    kBwCtlMnocFieldNumber = 3,
+    kCoreClkRateFieldNumber = 4,
+    kCrtcFieldNumber = 5,
+    kParamsFieldNumber = 6,
+    kPerPipeIbEbiFieldNumber = 7,
+    kPerPipeIbLlccFieldNumber = 8,
+    kPerPipeIbMnocFieldNumber = 9,
+    kStopReqFieldNumber = 10,
+    kUpdateBusFieldNumber = 11,
+    kUpdateClkFieldNumber = 12,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.InternedGpuRenderStageSpecification"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.SdeSdePerfCrtcUpdateFtraceEvent"; }
 
 
-  using RenderStageCategory = ::perfetto::protos::pbzero::InternedGpuRenderStageSpecification_RenderStageCategory;
-  static inline const char* RenderStageCategory_Name(RenderStageCategory value) {
-    return ::perfetto::protos::pbzero::InternedGpuRenderStageSpecification_RenderStageCategory_Name(value);
+  using FieldMetadata_BwCtlEbi =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SdeSdePerfCrtcUpdateFtraceEvent>;
+
+  static constexpr FieldMetadata_BwCtlEbi kBwCtlEbi{};
+  void set_bw_ctl_ebi(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BwCtlEbi::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
-  static const RenderStageCategory OTHER = RenderStageCategory::OTHER;
-  static const RenderStageCategory GRAPHICS = RenderStageCategory::GRAPHICS;
-  static const RenderStageCategory COMPUTE = RenderStageCategory::COMPUTE;
 
-  using FieldMetadata_Iid =
+  using FieldMetadata_BwCtlLlcc =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      InternedGpuRenderStageSpecification>;
+      SdeSdePerfCrtcUpdateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Iid kIid() { return {}; }
-  void set_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
+  static constexpr FieldMetadata_BwCtlLlcc kBwCtlLlcc{};
+  void set_bw_ctl_llcc(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BwCtlLlcc::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BwCtlMnoc =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SdeSdePerfCrtcUpdateFtraceEvent>;
+
+  static constexpr FieldMetadata_BwCtlMnoc kBwCtlMnoc{};
+  void set_bw_ctl_mnoc(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BwCtlMnoc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -132691,145 +157213,107 @@ class InternedGpuRenderStageSpecification : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Name =
+  using FieldMetadata_CoreClkRate =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      InternedGpuRenderStageSpecification>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SdeSdePerfCrtcUpdateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_CoreClkRate kCoreClkRate{};
+  void set_core_clk_rate(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CoreClkRate::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Description =
+  using FieldMetadata_Crtc =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      InternedGpuRenderStageSpecification>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SdeSdePerfCrtcUpdateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Description kDescription() { return {}; }
-  void set_description(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Description::kFieldId, data, size);
-  }
-  void set_description(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Description::kFieldId, chars.data, chars.size);
-  }
-  void set_description(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Description::kFieldId;
+  static constexpr FieldMetadata_Crtc kCrtc{};
+  void set_crtc(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Crtc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Category =
+  using FieldMetadata_Params =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::InternedGpuRenderStageSpecification_RenderStageCategory,
-      InternedGpuRenderStageSpecification>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SdeSdePerfCrtcUpdateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Category kCategory() { return {}; }
-  void set_category(::perfetto::protos::pbzero::InternedGpuRenderStageSpecification_RenderStageCategory value) {
-    static constexpr uint32_t field_id = FieldMetadata_Category::kFieldId;
+  static constexpr FieldMetadata_Params kParams{};
+  void set_params(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Params::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
 
-class InternedGraphicsContext_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  InternedGraphicsContext_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit InternedGraphicsContext_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit InternedGraphicsContext_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_iid() const { return at<1>().valid(); }
-  uint64_t iid() const { return at<1>().as_uint64(); }
-  bool has_pid() const { return at<2>().valid(); }
-  int32_t pid() const { return at<2>().as_int32(); }
-  bool has_api() const { return at<3>().valid(); }
-  int32_t api() const { return at<3>().as_int32(); }
-};
+  using FieldMetadata_PerPipeIbEbi =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SdeSdePerfCrtcUpdateFtraceEvent>;
 
-class InternedGraphicsContext : public ::protozero::Message {
- public:
-  using Decoder = InternedGraphicsContext_Decoder;
-  enum : int32_t {
-    kIidFieldNumber = 1,
-    kPidFieldNumber = 2,
-    kApiFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.InternedGraphicsContext"; }
+  static constexpr FieldMetadata_PerPipeIbEbi kPerPipeIbEbi{};
+  void set_per_pipe_ib_ebi(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PerPipeIbEbi::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
+  using FieldMetadata_PerPipeIbLlcc =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SdeSdePerfCrtcUpdateFtraceEvent>;
 
-  using Api = ::perfetto::protos::pbzero::InternedGraphicsContext_Api;
-  static inline const char* Api_Name(Api value) {
-    return ::perfetto::protos::pbzero::InternedGraphicsContext_Api_Name(value);
+  static constexpr FieldMetadata_PerPipeIbLlcc kPerPipeIbLlcc{};
+  void set_per_pipe_ib_llcc(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PerPipeIbLlcc::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
-  static const Api UNDEFINED = Api::UNDEFINED;
-  static const Api OPEN_GL = Api::OPEN_GL;
-  static const Api VULKAN = Api::VULKAN;
-  static const Api OPEN_CL = Api::OPEN_CL;
 
-  using FieldMetadata_Iid =
+  using FieldMetadata_PerPipeIbMnoc =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      InternedGraphicsContext>;
+      SdeSdePerfCrtcUpdateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Iid kIid() { return {}; }
-  void set_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
+  static constexpr FieldMetadata_PerPipeIbMnoc kPerPipeIbMnoc{};
+  void set_per_pipe_ib_mnoc(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PerPipeIbMnoc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -132837,137 +157321,111 @@ class InternedGraphicsContext : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_StopReq =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      InternedGraphicsContext>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SdeSdePerfCrtcUpdateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_StopReq kStopReq{};
+  void set_stop_req(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StopReq::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Api =
+  using FieldMetadata_UpdateBus =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::InternedGraphicsContext_Api,
-      InternedGraphicsContext>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SdeSdePerfCrtcUpdateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Api kApi() { return {}; }
-  void set_api(::perfetto::protos::pbzero::InternedGraphicsContext_Api value) {
-    static constexpr uint32_t field_id = FieldMetadata_Api::kFieldId;
+  static constexpr FieldMetadata_UpdateBus kUpdateBus{};
+  void set_update_bus(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_UpdateBus::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_UpdateClk =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SdeSdePerfCrtcUpdateFtraceEvent>;
+
+  static constexpr FieldMetadata_UpdateClk kUpdateClk{};
+  void set_update_clk(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_UpdateClk::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class GpuRenderStageEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/15, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class SdeSdePerfCalcCrtcFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
  public:
-  GpuRenderStageEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit GpuRenderStageEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit GpuRenderStageEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_event_id() const { return at<1>().valid(); }
-  uint64_t event_id() const { return at<1>().as_uint64(); }
-  bool has_duration() const { return at<2>().valid(); }
-  uint64_t duration() const { return at<2>().as_uint64(); }
-  bool has_hw_queue_iid() const { return at<13>().valid(); }
-  uint64_t hw_queue_iid() const { return at<13>().as_uint64(); }
-  bool has_stage_iid() const { return at<14>().valid(); }
-  uint64_t stage_iid() const { return at<14>().as_uint64(); }
-  bool has_gpu_id() const { return at<11>().valid(); }
-  int32_t gpu_id() const { return at<11>().as_int32(); }
-  bool has_context() const { return at<5>().valid(); }
-  uint64_t context() const { return at<5>().as_uint64(); }
-  bool has_render_target_handle() const { return at<8>().valid(); }
-  uint64_t render_target_handle() const { return at<8>().as_uint64(); }
-  bool has_submission_id() const { return at<10>().valid(); }
-  uint32_t submission_id() const { return at<10>().as_uint32(); }
-  bool has_extra_data() const { return at<6>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> extra_data() const { return GetRepeated<::protozero::ConstBytes>(6); }
-  bool has_render_pass_handle() const { return at<9>().valid(); }
-  uint64_t render_pass_handle() const { return at<9>().as_uint64(); }
-  bool has_render_subpass_index_mask() const { return at<15>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> render_subpass_index_mask() const { return GetRepeated<uint64_t>(15); }
-  bool has_command_buffer_handle() const { return at<12>().valid(); }
-  uint64_t command_buffer_handle() const { return at<12>().as_uint64(); }
-  bool has_specifications() const { return at<7>().valid(); }
-  ::protozero::ConstBytes specifications() const { return at<7>().as_bytes(); }
-  bool has_hw_queue_id() const { return at<3>().valid(); }
-  int32_t hw_queue_id() const { return at<3>().as_int32(); }
-  bool has_stage_id() const { return at<4>().valid(); }
-  int32_t stage_id() const { return at<4>().as_int32(); }
+  SdeSdePerfCalcCrtcFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SdeSdePerfCalcCrtcFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SdeSdePerfCalcCrtcFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_bw_ctl_ebi() const { return at<1>().valid(); }
+  uint64_t bw_ctl_ebi() const { return at<1>().as_uint64(); }
+  bool has_bw_ctl_llcc() const { return at<2>().valid(); }
+  uint64_t bw_ctl_llcc() const { return at<2>().as_uint64(); }
+  bool has_bw_ctl_mnoc() const { return at<3>().valid(); }
+  uint64_t bw_ctl_mnoc() const { return at<3>().as_uint64(); }
+  bool has_core_clk_rate() const { return at<4>().valid(); }
+  uint32_t core_clk_rate() const { return at<4>().as_uint32(); }
+  bool has_crtc() const { return at<5>().valid(); }
+  uint32_t crtc() const { return at<5>().as_uint32(); }
+  bool has_ib_ebi() const { return at<6>().valid(); }
+  uint64_t ib_ebi() const { return at<6>().as_uint64(); }
+  bool has_ib_llcc() const { return at<7>().valid(); }
+  uint64_t ib_llcc() const { return at<7>().as_uint64(); }
+  bool has_ib_mnoc() const { return at<8>().valid(); }
+  uint64_t ib_mnoc() const { return at<8>().as_uint64(); }
 };
 
-class GpuRenderStageEvent : public ::protozero::Message {
+class SdeSdePerfCalcCrtcFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = GpuRenderStageEvent_Decoder;
+  using Decoder = SdeSdePerfCalcCrtcFtraceEvent_Decoder;
   enum : int32_t {
-    kEventIdFieldNumber = 1,
-    kDurationFieldNumber = 2,
-    kHwQueueIidFieldNumber = 13,
-    kStageIidFieldNumber = 14,
-    kGpuIdFieldNumber = 11,
-    kContextFieldNumber = 5,
-    kRenderTargetHandleFieldNumber = 8,
-    kSubmissionIdFieldNumber = 10,
-    kExtraDataFieldNumber = 6,
-    kRenderPassHandleFieldNumber = 9,
-    kRenderSubpassIndexMaskFieldNumber = 15,
-    kCommandBufferHandleFieldNumber = 12,
-    kSpecificationsFieldNumber = 7,
-    kHwQueueIdFieldNumber = 3,
-    kStageIdFieldNumber = 4,
+    kBwCtlEbiFieldNumber = 1,
+    kBwCtlLlccFieldNumber = 2,
+    kBwCtlMnocFieldNumber = 3,
+    kCoreClkRateFieldNumber = 4,
+    kCrtcFieldNumber = 5,
+    kIbEbiFieldNumber = 6,
+    kIbLlccFieldNumber = 7,
+    kIbMnocFieldNumber = 8,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.GpuRenderStageEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.SdeSdePerfCalcCrtcFtraceEvent"; }
 
-  using ExtraData = ::perfetto::protos::pbzero::GpuRenderStageEvent_ExtraData;
-  using Specifications = ::perfetto::protos::pbzero::GpuRenderStageEvent_Specifications;
 
-  using FieldMetadata_EventId =
+  using FieldMetadata_BwCtlEbi =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      GpuRenderStageEvent>;
+      SdeSdePerfCalcCrtcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EventId kEventId() { return {}; }
-  void set_event_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EventId::kFieldId;
+  static constexpr FieldMetadata_BwCtlEbi kBwCtlEbi{};
+  void set_bw_ctl_ebi(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BwCtlEbi::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -132975,24 +157433,17 @@ class GpuRenderStageEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Duration =
+  using FieldMetadata_BwCtlLlcc =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      GpuRenderStageEvent>;
+      SdeSdePerfCalcCrtcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Duration kDuration() { return {}; }
-  void set_duration(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Duration::kFieldId;
+  static constexpr FieldMetadata_BwCtlLlcc kBwCtlLlcc{};
+  void set_bw_ctl_llcc(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BwCtlLlcc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -133000,24 +157451,17 @@ class GpuRenderStageEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_HwQueueIid =
+  using FieldMetadata_BwCtlMnoc =
     ::protozero::proto_utils::FieldMetadata<
-      13,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      GpuRenderStageEvent>;
+      SdeSdePerfCalcCrtcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HwQueueIid kHwQueueIid() { return {}; }
-  void set_hw_queue_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_HwQueueIid::kFieldId;
+  static constexpr FieldMetadata_BwCtlMnoc kBwCtlMnoc{};
+  void set_bw_ctl_mnoc(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BwCtlMnoc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -133025,74 +157469,53 @@ class GpuRenderStageEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_StageIid =
+  using FieldMetadata_CoreClkRate =
     ::protozero::proto_utils::FieldMetadata<
-      14,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      GpuRenderStageEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SdeSdePerfCalcCrtcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StageIid kStageIid() { return {}; }
-  void set_stage_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StageIid::kFieldId;
+  static constexpr FieldMetadata_CoreClkRate kCoreClkRate{};
+  void set_core_clk_rate(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CoreClkRate::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_GpuId =
+  using FieldMetadata_Crtc =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      GpuRenderStageEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SdeSdePerfCalcCrtcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GpuId kGpuId() { return {}; }
-  void set_gpu_id(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GpuId::kFieldId;
+  static constexpr FieldMetadata_Crtc kCrtc{};
+  void set_crtc(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Crtc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Context =
+  using FieldMetadata_IbEbi =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      GpuRenderStageEvent>;
+      SdeSdePerfCalcCrtcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Context kContext() { return {}; }
-  void set_context(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId;
+  static constexpr FieldMetadata_IbEbi kIbEbi{};
+  void set_ib_ebi(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IbEbi::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -133100,24 +157523,17 @@ class GpuRenderStageEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_RenderTargetHandle =
+  using FieldMetadata_IbLlcc =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      GpuRenderStageEvent>;
+      SdeSdePerfCalcCrtcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RenderTargetHandle kRenderTargetHandle() { return {}; }
-  void set_render_target_handle(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RenderTargetHandle::kFieldId;
+  static constexpr FieldMetadata_IbLlcc kIbLlcc{};
+  void set_ib_llcc(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IbLlcc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -133125,435 +157541,363 @@ class GpuRenderStageEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SubmissionId =
+  using FieldMetadata_IbMnoc =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      GpuRenderStageEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SdeSdePerfCalcCrtcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SubmissionId kSubmissionId() { return {}; }
-  void set_submission_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SubmissionId::kFieldId;
+  static constexpr FieldMetadata_IbMnoc kIbMnoc{};
+  void set_ib_mnoc(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IbMnoc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_ExtraData =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      GpuRenderStageEvent_ExtraData,
-      GpuRenderStageEvent>;
+class SdeSdeEvtlogFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  SdeSdeEvtlogFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SdeSdeEvtlogFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SdeSdeEvtlogFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_evtlog_tag() const { return at<1>().valid(); }
+  ::protozero::ConstChars evtlog_tag() const { return at<1>().as_string(); }
+  bool has_pid() const { return at<2>().valid(); }
+  int32_t pid() const { return at<2>().as_int32(); }
+  bool has_tag_id() const { return at<3>().valid(); }
+  uint32_t tag_id() const { return at<3>().as_uint32(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExtraData kExtraData() { return {}; }
-  template <typename T = GpuRenderStageEvent_ExtraData> T* add_extra_data() {
-    return BeginNestedMessage<T>(6);
-  }
+class SdeSdeEvtlogFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = SdeSdeEvtlogFtraceEvent_Decoder;
+  enum : int32_t {
+    kEvtlogTagFieldNumber = 1,
+    kPidFieldNumber = 2,
+    kTagIdFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SdeSdeEvtlogFtraceEvent"; }
 
 
-  using FieldMetadata_RenderPassHandle =
+  using FieldMetadata_EvtlogTag =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      GpuRenderStageEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SdeSdeEvtlogFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RenderPassHandle kRenderPassHandle() { return {}; }
-  void set_render_pass_handle(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RenderPassHandle::kFieldId;
+  static constexpr FieldMetadata_EvtlogTag kEvtlogTag{};
+  void set_evtlog_tag(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_EvtlogTag::kFieldId, data, size);
+  }
+  void set_evtlog_tag(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_EvtlogTag::kFieldId, chars.data, chars.size);
+  }
+  void set_evtlog_tag(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_EvtlogTag::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_RenderSubpassIndexMask =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
-      15,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      GpuRenderStageEvent>;
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SdeSdeEvtlogFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RenderSubpassIndexMask kRenderSubpassIndexMask() { return {}; }
-  void add_render_subpass_index_mask(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RenderSubpassIndexMask::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CommandBufferHandle =
+  using FieldMetadata_TagId =
     ::protozero::proto_utils::FieldMetadata<
-      12,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      GpuRenderStageEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SdeSdeEvtlogFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CommandBufferHandle kCommandBufferHandle() { return {}; }
-  void set_command_buffer_handle(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CommandBufferHandle::kFieldId;
+  static constexpr FieldMetadata_TagId kTagId{};
+  void set_tag_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TagId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Specifications =
+class SdeTracingMarkWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  SdeTracingMarkWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SdeTracingMarkWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SdeTracingMarkWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  int32_t pid() const { return at<1>().as_int32(); }
+  bool has_trace_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars trace_name() const { return at<2>().as_string(); }
+  bool has_trace_type() const { return at<3>().valid(); }
+  uint32_t trace_type() const { return at<3>().as_uint32(); }
+  bool has_value() const { return at<4>().valid(); }
+  int32_t value() const { return at<4>().as_int32(); }
+  bool has_trace_begin() const { return at<5>().valid(); }
+  uint32_t trace_begin() const { return at<5>().as_uint32(); }
+};
+
+class SdeTracingMarkWriteFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = SdeTracingMarkWriteFtraceEvent_Decoder;
+  enum : int32_t {
+    kPidFieldNumber = 1,
+    kTraceNameFieldNumber = 2,
+    kTraceTypeFieldNumber = 3,
+    kValueFieldNumber = 4,
+    kTraceBeginFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SdeTracingMarkWriteFtraceEvent"; }
+
+
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      GpuRenderStageEvent_Specifications,
-      GpuRenderStageEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SdeTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Specifications kSpecifications() { return {}; }
-  template <typename T = GpuRenderStageEvent_Specifications> T* set_specifications() {
-    return BeginNestedMessage<T>(7);
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
   }
 
+  using FieldMetadata_TraceName =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SdeTracingMarkWriteFtraceEvent>;
 
-  using FieldMetadata_HwQueueId =
+  static constexpr FieldMetadata_TraceName kTraceName{};
+  void set_trace_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_TraceName::kFieldId, data, size);
+  }
+  void set_trace_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_TraceName::kFieldId, chars.data, chars.size);
+  }
+  void set_trace_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_TraceName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_TraceType =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      GpuRenderStageEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SdeTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HwQueueId kHwQueueId() { return {}; }
-  void set_hw_queue_id(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_HwQueueId::kFieldId;
+  static constexpr FieldMetadata_TraceType kTraceType{};
+  void set_trace_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TraceType::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_StageId =
+  using FieldMetadata_Value =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      GpuRenderStageEvent>;
+      SdeTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StageId kStageId() { return {}; }
-  void set_stage_id(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StageId::kFieldId;
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-class GpuRenderStageEvent_Specifications_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  GpuRenderStageEvent_Specifications_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit GpuRenderStageEvent_Specifications_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit GpuRenderStageEvent_Specifications_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_context_spec() const { return at<1>().valid(); }
-  ::protozero::ConstBytes context_spec() const { return at<1>().as_bytes(); }
-  bool has_hw_queue() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> hw_queue() const { return GetRepeated<::protozero::ConstBytes>(2); }
-  bool has_stage() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> stage() const { return GetRepeated<::protozero::ConstBytes>(3); }
-};
-
-class GpuRenderStageEvent_Specifications : public ::protozero::Message {
- public:
-  using Decoder = GpuRenderStageEvent_Specifications_Decoder;
-  enum : int32_t {
-    kContextSpecFieldNumber = 1,
-    kHwQueueFieldNumber = 2,
-    kStageFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.GpuRenderStageEvent.Specifications"; }
 
-  using ContextSpec = ::perfetto::protos::pbzero::GpuRenderStageEvent_Specifications_ContextSpec;
-  using Description = ::perfetto::protos::pbzero::GpuRenderStageEvent_Specifications_Description;
-
-  using FieldMetadata_ContextSpec =
+  using FieldMetadata_TraceBegin =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      GpuRenderStageEvent_Specifications_ContextSpec,
-      GpuRenderStageEvent_Specifications>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SdeTracingMarkWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ContextSpec kContextSpec() { return {}; }
-  template <typename T = GpuRenderStageEvent_Specifications_ContextSpec> T* set_context_spec() {
-    return BeginNestedMessage<T>(1);
+  static constexpr FieldMetadata_TraceBegin kTraceBegin{};
+  void set_trace_begin(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TraceBegin::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
+};
 
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/signal.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  using FieldMetadata_HwQueue =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      GpuRenderStageEvent_Specifications_Description,
-      GpuRenderStageEvent_Specifications>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HwQueue kHwQueue() { return {}; }
-  template <typename T = GpuRenderStageEvent_Specifications_Description> T* add_hw_queue() {
-    return BeginNestedMessage<T>(2);
-  }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SIGNAL_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SIGNAL_PROTO_H_
 
+#include <stddef.h>
+#include <stdint.h>
 
-  using FieldMetadata_Stage =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      GpuRenderStageEvent_Specifications_Description,
-      GpuRenderStageEvent_Specifications>;
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Stage kStage() { return {}; }
-  template <typename T = GpuRenderStageEvent_Specifications_Description> T* add_stage() {
-    return BeginNestedMessage<T>(3);
-  }
 
-};
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-class GpuRenderStageEvent_Specifications_Description_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class SignalGenerateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  GpuRenderStageEvent_Specifications_Description_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit GpuRenderStageEvent_Specifications_Description_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit GpuRenderStageEvent_Specifications_Description_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_description() const { return at<2>().valid(); }
-  ::protozero::ConstChars description() const { return at<2>().as_string(); }
+  SignalGenerateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SignalGenerateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SignalGenerateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_code() const { return at<1>().valid(); }
+  int32_t code() const { return at<1>().as_int32(); }
+  bool has_comm() const { return at<2>().valid(); }
+  ::protozero::ConstChars comm() const { return at<2>().as_string(); }
+  bool has_group() const { return at<3>().valid(); }
+  int32_t group() const { return at<3>().as_int32(); }
+  bool has_pid() const { return at<4>().valid(); }
+  int32_t pid() const { return at<4>().as_int32(); }
+  bool has_result() const { return at<5>().valid(); }
+  int32_t result() const { return at<5>().as_int32(); }
+  bool has_sig() const { return at<6>().valid(); }
+  int32_t sig() const { return at<6>().as_int32(); }
 };
 
-class GpuRenderStageEvent_Specifications_Description : public ::protozero::Message {
+class SignalGenerateFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = GpuRenderStageEvent_Specifications_Description_Decoder;
+  using Decoder = SignalGenerateFtraceEvent_Decoder;
   enum : int32_t {
-    kNameFieldNumber = 1,
-    kDescriptionFieldNumber = 2,
+    kCodeFieldNumber = 1,
+    kCommFieldNumber = 2,
+    kGroupFieldNumber = 3,
+    kPidFieldNumber = 4,
+    kResultFieldNumber = 5,
+    kSigFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.GpuRenderStageEvent.Specifications.Description"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.SignalGenerateFtraceEvent"; }
 
 
-  using FieldMetadata_Name =
+  using FieldMetadata_Code =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      GpuRenderStageEvent_Specifications_Description>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SignalGenerateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_Code kCode{};
+  void set_code(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Code::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Description =
+  using FieldMetadata_Comm =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      GpuRenderStageEvent_Specifications_Description>;
+      SignalGenerateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Description kDescription() { return {}; }
-  void set_description(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Description::kFieldId, data, size);
+  static constexpr FieldMetadata_Comm kComm{};
+  void set_comm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
   }
-  void set_description(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Description::kFieldId, chars.data, chars.size);
+  void set_comm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
   }
-  void set_description(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Description::kFieldId;
+  void set_comm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
-};
-
-class GpuRenderStageEvent_Specifications_ContextSpec_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  GpuRenderStageEvent_Specifications_ContextSpec_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit GpuRenderStageEvent_Specifications_ContextSpec_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit GpuRenderStageEvent_Specifications_ContextSpec_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_context() const { return at<1>().valid(); }
-  uint64_t context() const { return at<1>().as_uint64(); }
-  bool has_pid() const { return at<2>().valid(); }
-  int32_t pid() const { return at<2>().as_int32(); }
-};
-
-class GpuRenderStageEvent_Specifications_ContextSpec : public ::protozero::Message {
- public:
-  using Decoder = GpuRenderStageEvent_Specifications_ContextSpec_Decoder;
-  enum : int32_t {
-    kContextFieldNumber = 1,
-    kPidFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.GpuRenderStageEvent.Specifications.ContextSpec"; }
-
 
-  using FieldMetadata_Context =
+  using FieldMetadata_Group =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      GpuRenderStageEvent_Specifications_ContextSpec>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SignalGenerateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Context kContext() { return {}; }
-  void set_context(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId;
+  static constexpr FieldMetadata_Group kGroup{};
+  void set_group(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Group::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
   using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      GpuRenderStageEvent_Specifications_ContextSpec>;
+      SignalGenerateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
+  static constexpr FieldMetadata_Pid kPid{};
   void set_pid(int32_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -133562,88 +157906,119 @@ class GpuRenderStageEvent_Specifications_ContextSpec : public ::protozero::Messa
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_Result =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SignalGenerateFtraceEvent>;
+
+  static constexpr FieldMetadata_Result kResult{};
+  void set_result(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Result::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Sig =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SignalGenerateFtraceEvent>;
+
+  static constexpr FieldMetadata_Sig kSig{};
+  void set_sig(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Sig::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class GpuRenderStageEvent_ExtraData_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class SignalDeliverFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  GpuRenderStageEvent_ExtraData_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit GpuRenderStageEvent_ExtraData_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit GpuRenderStageEvent_ExtraData_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_value() const { return at<2>().valid(); }
-  ::protozero::ConstChars value() const { return at<2>().as_string(); }
+  SignalDeliverFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SignalDeliverFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SignalDeliverFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_code() const { return at<1>().valid(); }
+  int32_t code() const { return at<1>().as_int32(); }
+  bool has_sa_flags() const { return at<2>().valid(); }
+  uint64_t sa_flags() const { return at<2>().as_uint64(); }
+  bool has_sig() const { return at<3>().valid(); }
+  int32_t sig() const { return at<3>().as_int32(); }
 };
 
-class GpuRenderStageEvent_ExtraData : public ::protozero::Message {
+class SignalDeliverFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = GpuRenderStageEvent_ExtraData_Decoder;
+  using Decoder = SignalDeliverFtraceEvent_Decoder;
   enum : int32_t {
-    kNameFieldNumber = 1,
-    kValueFieldNumber = 2,
+    kCodeFieldNumber = 1,
+    kSaFlagsFieldNumber = 2,
+    kSigFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.GpuRenderStageEvent.ExtraData"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.SignalDeliverFtraceEvent"; }
 
 
-  using FieldMetadata_Name =
+  using FieldMetadata_Code =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      GpuRenderStageEvent_ExtraData>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SignalDeliverFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_Code kCode{};
+  void set_code(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Code::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Value =
+  using FieldMetadata_SaFlags =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      GpuRenderStageEvent_ExtraData>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SignalDeliverFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
-  }
-  void set_value(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
+  static constexpr FieldMetadata_SaFlags kSaFlags{};
+  void set_sa_flags(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SaFlags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
-  void set_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+
+  using FieldMetadata_Sig =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SignalDeliverFtraceEvent>;
+
+  static constexpr FieldMetadata_Sig kSig{};
+  void set_sig(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Sig::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
@@ -133652,11 +158027,11 @@ class GpuRenderStageEvent_ExtraData : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/gpu/vulkan_api_event.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/skb.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GPU_VULKAN_API_EVENT_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GPU_VULKAN_API_EVENT_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SKB_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SKB_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -133667,155 +158042,185 @@ class GpuRenderStageEvent_ExtraData : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-class VulkanApiEvent_VkDebugUtilsObjectName;
-class VulkanApiEvent_VkQueueSubmit;
-
-class VulkanApiEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class KfreeSkbFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  VulkanApiEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit VulkanApiEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit VulkanApiEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_vk_debug_utils_object_name() const { return at<1>().valid(); }
-  ::protozero::ConstBytes vk_debug_utils_object_name() const { return at<1>().as_bytes(); }
-  bool has_vk_queue_submit() const { return at<2>().valid(); }
-  ::protozero::ConstBytes vk_queue_submit() const { return at<2>().as_bytes(); }
+  KfreeSkbFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KfreeSkbFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KfreeSkbFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_location() const { return at<1>().valid(); }
+  uint64_t location() const { return at<1>().as_uint64(); }
+  bool has_protocol() const { return at<2>().valid(); }
+  uint32_t protocol() const { return at<2>().as_uint32(); }
+  bool has_skbaddr() const { return at<3>().valid(); }
+  uint64_t skbaddr() const { return at<3>().as_uint64(); }
 };
 
-class VulkanApiEvent : public ::protozero::Message {
+class KfreeSkbFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = VulkanApiEvent_Decoder;
+  using Decoder = KfreeSkbFtraceEvent_Decoder;
   enum : int32_t {
-    kVkDebugUtilsObjectNameFieldNumber = 1,
-    kVkQueueSubmitFieldNumber = 2,
+    kLocationFieldNumber = 1,
+    kProtocolFieldNumber = 2,
+    kSkbaddrFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.VulkanApiEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.KfreeSkbFtraceEvent"; }
 
-  using VkDebugUtilsObjectName = ::perfetto::protos::pbzero::VulkanApiEvent_VkDebugUtilsObjectName;
-  using VkQueueSubmit = ::perfetto::protos::pbzero::VulkanApiEvent_VkQueueSubmit;
 
-  using FieldMetadata_VkDebugUtilsObjectName =
+  using FieldMetadata_Location =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      VulkanApiEvent_VkDebugUtilsObjectName,
-      VulkanApiEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KfreeSkbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VkDebugUtilsObjectName kVkDebugUtilsObjectName() { return {}; }
-  template <typename T = VulkanApiEvent_VkDebugUtilsObjectName> T* set_vk_debug_utils_object_name() {
-    return BeginNestedMessage<T>(1);
+  static constexpr FieldMetadata_Location kLocation{};
+  void set_location(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Location::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_VkQueueSubmit =
+  using FieldMetadata_Protocol =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      VulkanApiEvent_VkQueueSubmit,
-      VulkanApiEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KfreeSkbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VkQueueSubmit kVkQueueSubmit() { return {}; }
-  template <typename T = VulkanApiEvent_VkQueueSubmit> T* set_vk_queue_submit() {
-    return BeginNestedMessage<T>(2);
+  static constexpr FieldMetadata_Protocol kProtocol{};
+  void set_protocol(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Protocol::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
 
+  using FieldMetadata_Skbaddr =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KfreeSkbFtraceEvent>;
+
+  static constexpr FieldMetadata_Skbaddr kSkbaddr{};
+  void set_skbaddr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Skbaddr::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class VulkanApiEvent_VkQueueSubmit_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/sock.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SOCK_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SOCK_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class InetSockSetStateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9> {
  public:
-  VulkanApiEvent_VkQueueSubmit_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit VulkanApiEvent_VkQueueSubmit_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit VulkanApiEvent_VkQueueSubmit_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_duration_ns() const { return at<1>().valid(); }
-  uint64_t duration_ns() const { return at<1>().as_uint64(); }
-  bool has_pid() const { return at<2>().valid(); }
-  uint32_t pid() const { return at<2>().as_uint32(); }
-  bool has_tid() const { return at<3>().valid(); }
-  uint32_t tid() const { return at<3>().as_uint32(); }
-  bool has_vk_queue() const { return at<4>().valid(); }
-  uint64_t vk_queue() const { return at<4>().as_uint64(); }
-  bool has_vk_command_buffers() const { return at<5>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> vk_command_buffers() const { return GetRepeated<uint64_t>(5); }
-  bool has_submission_id() const { return at<6>().valid(); }
-  uint32_t submission_id() const { return at<6>().as_uint32(); }
+  InetSockSetStateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit InetSockSetStateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit InetSockSetStateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_daddr() const { return at<1>().valid(); }
+  uint32_t daddr() const { return at<1>().as_uint32(); }
+  bool has_dport() const { return at<2>().valid(); }
+  uint32_t dport() const { return at<2>().as_uint32(); }
+  bool has_family() const { return at<3>().valid(); }
+  uint32_t family() const { return at<3>().as_uint32(); }
+  bool has_newstate() const { return at<4>().valid(); }
+  int32_t newstate() const { return at<4>().as_int32(); }
+  bool has_oldstate() const { return at<5>().valid(); }
+  int32_t oldstate() const { return at<5>().as_int32(); }
+  bool has_protocol() const { return at<6>().valid(); }
+  uint32_t protocol() const { return at<6>().as_uint32(); }
+  bool has_saddr() const { return at<7>().valid(); }
+  uint32_t saddr() const { return at<7>().as_uint32(); }
+  bool has_skaddr() const { return at<8>().valid(); }
+  uint64_t skaddr() const { return at<8>().as_uint64(); }
+  bool has_sport() const { return at<9>().valid(); }
+  uint32_t sport() const { return at<9>().as_uint32(); }
 };
 
-class VulkanApiEvent_VkQueueSubmit : public ::protozero::Message {
+class InetSockSetStateFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = VulkanApiEvent_VkQueueSubmit_Decoder;
+  using Decoder = InetSockSetStateFtraceEvent_Decoder;
   enum : int32_t {
-    kDurationNsFieldNumber = 1,
-    kPidFieldNumber = 2,
-    kTidFieldNumber = 3,
-    kVkQueueFieldNumber = 4,
-    kVkCommandBuffersFieldNumber = 5,
-    kSubmissionIdFieldNumber = 6,
+    kDaddrFieldNumber = 1,
+    kDportFieldNumber = 2,
+    kFamilyFieldNumber = 3,
+    kNewstateFieldNumber = 4,
+    kOldstateFieldNumber = 5,
+    kProtocolFieldNumber = 6,
+    kSaddrFieldNumber = 7,
+    kSkaddrFieldNumber = 8,
+    kSportFieldNumber = 9,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.VulkanApiEvent.VkQueueSubmit"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.InetSockSetStateFtraceEvent"; }
 
 
-  using FieldMetadata_DurationNs =
+  using FieldMetadata_Daddr =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      VulkanApiEvent_VkQueueSubmit>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      InetSockSetStateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DurationNs kDurationNs() { return {}; }
-  void set_duration_ns(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DurationNs::kFieldId;
+  static constexpr FieldMetadata_Daddr kDaddr{};
+  void set_daddr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Daddr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_Dport =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      VulkanApiEvent_VkQueueSubmit>;
+      InetSockSetStateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_Dport kDport{};
+  void set_dport(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dport::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -133823,24 +158228,17 @@ class VulkanApiEvent_VkQueueSubmit : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Tid =
+  using FieldMetadata_Family =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      VulkanApiEvent_VkQueueSubmit>;
+      InetSockSetStateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Tid kTid() { return {}; }
-  void set_tid(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId;
+  static constexpr FieldMetadata_Family kFamily{};
+  void set_family(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Family::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -133848,130 +158246,71 @@ class VulkanApiEvent_VkQueueSubmit : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VkQueue =
+  using FieldMetadata_Newstate =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      VulkanApiEvent_VkQueueSubmit>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      InetSockSetStateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VkQueue kVkQueue() { return {}; }
-  void set_vk_queue(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VkQueue::kFieldId;
+  static constexpr FieldMetadata_Newstate kNewstate{};
+  void set_newstate(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Newstate::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VkCommandBuffers =
+  using FieldMetadata_Oldstate =
     ::protozero::proto_utils::FieldMetadata<
       5,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      VulkanApiEvent_VkQueueSubmit>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      InetSockSetStateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VkCommandBuffers kVkCommandBuffers() { return {}; }
-  void add_vk_command_buffers(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VkCommandBuffers::kFieldId;
+  static constexpr FieldMetadata_Oldstate kOldstate{};
+  void set_oldstate(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Oldstate::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SubmissionId =
+  using FieldMetadata_Protocol =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      VulkanApiEvent_VkQueueSubmit>;
+      InetSockSetStateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SubmissionId kSubmissionId() { return {}; }
-  void set_submission_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SubmissionId::kFieldId;
+  static constexpr FieldMetadata_Protocol kProtocol{};
+  void set_protocol(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Protocol::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class VulkanApiEvent_VkDebugUtilsObjectName_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  VulkanApiEvent_VkDebugUtilsObjectName_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit VulkanApiEvent_VkDebugUtilsObjectName_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit VulkanApiEvent_VkDebugUtilsObjectName_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pid() const { return at<1>().valid(); }
-  uint32_t pid() const { return at<1>().as_uint32(); }
-  bool has_vk_device() const { return at<2>().valid(); }
-  uint64_t vk_device() const { return at<2>().as_uint64(); }
-  bool has_object_type() const { return at<3>().valid(); }
-  int32_t object_type() const { return at<3>().as_int32(); }
-  bool has_object() const { return at<4>().valid(); }
-  uint64_t object() const { return at<4>().as_uint64(); }
-  bool has_object_name() const { return at<5>().valid(); }
-  ::protozero::ConstChars object_name() const { return at<5>().as_string(); }
-};
-
-class VulkanApiEvent_VkDebugUtilsObjectName : public ::protozero::Message {
- public:
-  using Decoder = VulkanApiEvent_VkDebugUtilsObjectName_Decoder;
-  enum : int32_t {
-    kPidFieldNumber = 1,
-    kVkDeviceFieldNumber = 2,
-    kObjectTypeFieldNumber = 3,
-    kObjectFieldNumber = 4,
-    kObjectNameFieldNumber = 5,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.VulkanApiEvent.VkDebugUtilsObjectName"; }
 
-
-  using FieldMetadata_Pid =
+  using FieldMetadata_Saddr =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      VulkanApiEvent_VkDebugUtilsObjectName>;
+      InetSockSetStateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_Saddr kSaddr{};
+  void set_saddr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Saddr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -133979,74 +158318,17 @@ class VulkanApiEvent_VkDebugUtilsObjectName : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VkDevice =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      VulkanApiEvent_VkDebugUtilsObjectName>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VkDevice kVkDevice() { return {}; }
-  void set_vk_device(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VkDevice::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ObjectType =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      VulkanApiEvent_VkDebugUtilsObjectName>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ObjectType kObjectType() { return {}; }
-  void set_object_type(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ObjectType::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Object =
+  using FieldMetadata_Skaddr =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      VulkanApiEvent_VkDebugUtilsObjectName>;
+      InetSockSetStateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Object kObject() { return {}; }
-  void set_object(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Object::kFieldId;
+  static constexpr FieldMetadata_Skaddr kSkaddr{};
+  void set_skaddr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Skaddr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -134054,34 +158336,21 @@ class VulkanApiEvent_VkDebugUtilsObjectName : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ObjectName =
+  using FieldMetadata_Sport =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      VulkanApiEvent_VkDebugUtilsObjectName>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      InetSockSetStateFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ObjectName kObjectName() { return {}; }
-  void set_object_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ObjectName::kFieldId, data, size);
-  }
-  void set_object_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ObjectName::kFieldId, chars.data, chars.size);
-  }
-  void set_object_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ObjectName::kFieldId;
+  static constexpr FieldMetadata_Sport kSport{};
+  void set_sport(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Sport::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
@@ -134090,11 +158359,11 @@ class VulkanApiEvent_VkDebugUtilsObjectName : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/gpu/vulkan_memory_event.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/sync.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GPU_VULKAN_MEMORY_EVENT_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GPU_VULKAN_MEMORY_EVENT_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SYNC_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SYNC_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -134105,551 +158374,371 @@ class VulkanApiEvent_VkDebugUtilsObjectName : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-class VulkanMemoryEventAnnotation;
-namespace perfetto_pbzero_enum_VulkanMemoryEvent {
-enum AllocationScope : int32_t;
-}  // namespace perfetto_pbzero_enum_VulkanMemoryEvent
-using VulkanMemoryEvent_AllocationScope = perfetto_pbzero_enum_VulkanMemoryEvent::AllocationScope;
-namespace perfetto_pbzero_enum_VulkanMemoryEvent {
-enum Operation : int32_t;
-}  // namespace perfetto_pbzero_enum_VulkanMemoryEvent
-using VulkanMemoryEvent_Operation = perfetto_pbzero_enum_VulkanMemoryEvent::Operation;
-namespace perfetto_pbzero_enum_VulkanMemoryEvent {
-enum Source : int32_t;
-}  // namespace perfetto_pbzero_enum_VulkanMemoryEvent
-using VulkanMemoryEvent_Source = perfetto_pbzero_enum_VulkanMemoryEvent::Source;
-
-namespace perfetto_pbzero_enum_VulkanMemoryEvent {
-enum Source : int32_t {
-  SOURCE_UNSPECIFIED = 0,
-  SOURCE_DRIVER = 1,
-  SOURCE_DEVICE = 2,
-  SOURCE_DEVICE_MEMORY = 3,
-  SOURCE_BUFFER = 4,
-  SOURCE_IMAGE = 5,
-};
-} // namespace perfetto_pbzero_enum_VulkanMemoryEvent
-using VulkanMemoryEvent_Source = perfetto_pbzero_enum_VulkanMemoryEvent::Source;
-
-
-constexpr VulkanMemoryEvent_Source VulkanMemoryEvent_Source_MIN = VulkanMemoryEvent_Source::SOURCE_UNSPECIFIED;
-constexpr VulkanMemoryEvent_Source VulkanMemoryEvent_Source_MAX = VulkanMemoryEvent_Source::SOURCE_IMAGE;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* VulkanMemoryEvent_Source_Name(::perfetto::protos::pbzero::VulkanMemoryEvent_Source value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Source::SOURCE_UNSPECIFIED:
-    return "SOURCE_UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Source::SOURCE_DRIVER:
-    return "SOURCE_DRIVER";
-
-  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Source::SOURCE_DEVICE:
-    return "SOURCE_DEVICE";
-
-  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Source::SOURCE_DEVICE_MEMORY:
-    return "SOURCE_DEVICE_MEMORY";
-
-  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Source::SOURCE_BUFFER:
-    return "SOURCE_BUFFER";
-
-  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Source::SOURCE_IMAGE:
-    return "SOURCE_IMAGE";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-namespace perfetto_pbzero_enum_VulkanMemoryEvent {
-enum Operation : int32_t {
-  OP_UNSPECIFIED = 0,
-  OP_CREATE = 1,
-  OP_DESTROY = 2,
-  OP_BIND = 3,
-  OP_DESTROY_BOUND = 4,
-  OP_ANNOTATIONS = 5,
-};
-} // namespace perfetto_pbzero_enum_VulkanMemoryEvent
-using VulkanMemoryEvent_Operation = perfetto_pbzero_enum_VulkanMemoryEvent::Operation;
-
-
-constexpr VulkanMemoryEvent_Operation VulkanMemoryEvent_Operation_MIN = VulkanMemoryEvent_Operation::OP_UNSPECIFIED;
-constexpr VulkanMemoryEvent_Operation VulkanMemoryEvent_Operation_MAX = VulkanMemoryEvent_Operation::OP_ANNOTATIONS;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* VulkanMemoryEvent_Operation_Name(::perfetto::protos::pbzero::VulkanMemoryEvent_Operation value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation::OP_UNSPECIFIED:
-    return "OP_UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation::OP_CREATE:
-    return "OP_CREATE";
-
-  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation::OP_DESTROY:
-    return "OP_DESTROY";
-
-  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation::OP_BIND:
-    return "OP_BIND";
-
-  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation::OP_DESTROY_BOUND:
-    return "OP_DESTROY_BOUND";
-
-  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation::OP_ANNOTATIONS:
-    return "OP_ANNOTATIONS";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-namespace perfetto_pbzero_enum_VulkanMemoryEvent {
-enum AllocationScope : int32_t {
-  SCOPE_UNSPECIFIED = 0,
-  SCOPE_COMMAND = 1,
-  SCOPE_OBJECT = 2,
-  SCOPE_CACHE = 3,
-  SCOPE_DEVICE = 4,
-  SCOPE_INSTANCE = 5,
-};
-} // namespace perfetto_pbzero_enum_VulkanMemoryEvent
-using VulkanMemoryEvent_AllocationScope = perfetto_pbzero_enum_VulkanMemoryEvent::AllocationScope;
-
-
-constexpr VulkanMemoryEvent_AllocationScope VulkanMemoryEvent_AllocationScope_MIN = VulkanMemoryEvent_AllocationScope::SCOPE_UNSPECIFIED;
-constexpr VulkanMemoryEvent_AllocationScope VulkanMemoryEvent_AllocationScope_MAX = VulkanMemoryEvent_AllocationScope::SCOPE_INSTANCE;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* VulkanMemoryEvent_AllocationScope_Name(::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope::SCOPE_UNSPECIFIED:
-    return "SCOPE_UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope::SCOPE_COMMAND:
-    return "SCOPE_COMMAND";
-
-  case ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope::SCOPE_OBJECT:
-    return "SCOPE_OBJECT";
-
-  case ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope::SCOPE_CACHE:
-    return "SCOPE_CACHE";
-
-  case ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope::SCOPE_DEVICE:
-    return "SCOPE_DEVICE";
-
-  case ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope::SCOPE_INSTANCE:
-    return "SCOPE_INSTANCE";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-class VulkanMemoryEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/20, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class SyncWaitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  VulkanMemoryEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit VulkanMemoryEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit VulkanMemoryEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_source() const { return at<1>().valid(); }
-  int32_t source() const { return at<1>().as_int32(); }
-  bool has_operation() const { return at<2>().valid(); }
-  int32_t operation() const { return at<2>().as_int32(); }
-  bool has_timestamp() const { return at<3>().valid(); }
-  int64_t timestamp() const { return at<3>().as_int64(); }
-  bool has_pid() const { return at<4>().valid(); }
-  uint32_t pid() const { return at<4>().as_uint32(); }
-  bool has_memory_address() const { return at<5>().valid(); }
-  uint64_t memory_address() const { return at<5>().as_uint64(); }
-  bool has_memory_size() const { return at<6>().valid(); }
-  uint64_t memory_size() const { return at<6>().as_uint64(); }
-  bool has_caller_iid() const { return at<7>().valid(); }
-  uint64_t caller_iid() const { return at<7>().as_uint64(); }
-  bool has_allocation_scope() const { return at<8>().valid(); }
-  int32_t allocation_scope() const { return at<8>().as_int32(); }
-  bool has_annotations() const { return at<9>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> annotations() const { return GetRepeated<::protozero::ConstBytes>(9); }
-  bool has_device() const { return at<16>().valid(); }
-  uint64_t device() const { return at<16>().as_uint64(); }
-  bool has_device_memory() const { return at<17>().valid(); }
-  uint64_t device_memory() const { return at<17>().as_uint64(); }
-  bool has_memory_type() const { return at<18>().valid(); }
-  uint32_t memory_type() const { return at<18>().as_uint32(); }
-  bool has_heap() const { return at<19>().valid(); }
-  uint32_t heap() const { return at<19>().as_uint32(); }
-  bool has_object_handle() const { return at<20>().valid(); }
-  uint64_t object_handle() const { return at<20>().as_uint64(); }
+  SyncWaitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SyncWaitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SyncWaitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_status() const { return at<2>().valid(); }
+  int32_t status() const { return at<2>().as_int32(); }
+  bool has_begin() const { return at<3>().valid(); }
+  uint32_t begin() const { return at<3>().as_uint32(); }
 };
 
-class VulkanMemoryEvent : public ::protozero::Message {
+class SyncWaitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = VulkanMemoryEvent_Decoder;
+  using Decoder = SyncWaitFtraceEvent_Decoder;
   enum : int32_t {
-    kSourceFieldNumber = 1,
-    kOperationFieldNumber = 2,
-    kTimestampFieldNumber = 3,
-    kPidFieldNumber = 4,
-    kMemoryAddressFieldNumber = 5,
-    kMemorySizeFieldNumber = 6,
-    kCallerIidFieldNumber = 7,
-    kAllocationScopeFieldNumber = 8,
-    kAnnotationsFieldNumber = 9,
-    kDeviceFieldNumber = 16,
-    kDeviceMemoryFieldNumber = 17,
-    kMemoryTypeFieldNumber = 18,
-    kHeapFieldNumber = 19,
-    kObjectHandleFieldNumber = 20,
+    kNameFieldNumber = 1,
+    kStatusFieldNumber = 2,
+    kBeginFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.VulkanMemoryEvent"; }
-
-
-  using Source = ::perfetto::protos::pbzero::VulkanMemoryEvent_Source;
-  static inline const char* Source_Name(Source value) {
-    return ::perfetto::protos::pbzero::VulkanMemoryEvent_Source_Name(value);
-  }
-
-  using Operation = ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation;
-  static inline const char* Operation_Name(Operation value) {
-    return ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation_Name(value);
-  }
+  static constexpr const char* GetName() { return ".perfetto.protos.SyncWaitFtraceEvent"; }
 
-  using AllocationScope = ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope;
-  static inline const char* AllocationScope_Name(AllocationScope value) {
-    return ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope_Name(value);
-  }
-  static const Source SOURCE_UNSPECIFIED = Source::SOURCE_UNSPECIFIED;
-  static const Source SOURCE_DRIVER = Source::SOURCE_DRIVER;
-  static const Source SOURCE_DEVICE = Source::SOURCE_DEVICE;
-  static const Source SOURCE_DEVICE_MEMORY = Source::SOURCE_DEVICE_MEMORY;
-  static const Source SOURCE_BUFFER = Source::SOURCE_BUFFER;
-  static const Source SOURCE_IMAGE = Source::SOURCE_IMAGE;
-  static const Operation OP_UNSPECIFIED = Operation::OP_UNSPECIFIED;
-  static const Operation OP_CREATE = Operation::OP_CREATE;
-  static const Operation OP_DESTROY = Operation::OP_DESTROY;
-  static const Operation OP_BIND = Operation::OP_BIND;
-  static const Operation OP_DESTROY_BOUND = Operation::OP_DESTROY_BOUND;
-  static const Operation OP_ANNOTATIONS = Operation::OP_ANNOTATIONS;
-  static const AllocationScope SCOPE_UNSPECIFIED = AllocationScope::SCOPE_UNSPECIFIED;
-  static const AllocationScope SCOPE_COMMAND = AllocationScope::SCOPE_COMMAND;
-  static const AllocationScope SCOPE_OBJECT = AllocationScope::SCOPE_OBJECT;
-  static const AllocationScope SCOPE_CACHE = AllocationScope::SCOPE_CACHE;
-  static const AllocationScope SCOPE_DEVICE = AllocationScope::SCOPE_DEVICE;
-  static const AllocationScope SCOPE_INSTANCE = AllocationScope::SCOPE_INSTANCE;
 
-  using FieldMetadata_Source =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::VulkanMemoryEvent_Source,
-      VulkanMemoryEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SyncWaitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Source kSource() { return {}; }
-  void set_source(::perfetto::protos::pbzero::VulkanMemoryEvent_Source value) {
-    static constexpr uint32_t field_id = FieldMetadata_Source::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Operation =
+  using FieldMetadata_Status =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation,
-      VulkanMemoryEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SyncWaitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Operation kOperation() { return {}; }
-  void set_operation(::perfetto::protos::pbzero::VulkanMemoryEvent_Operation value) {
-    static constexpr uint32_t field_id = FieldMetadata_Operation::kFieldId;
+  static constexpr FieldMetadata_Status kStatus{};
+  void set_status(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Timestamp =
+  using FieldMetadata_Begin =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      VulkanMemoryEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timestamp kTimestamp() { return {}; }
-  void set_timestamp(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Pid =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      VulkanMemoryEvent>;
+      SyncWaitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_Begin kBegin{};
+  void set_begin(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Begin::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_MemoryAddress =
+class SyncTimelineFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  SyncTimelineFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SyncTimelineFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SyncTimelineFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_value() const { return at<2>().valid(); }
+  ::protozero::ConstChars value() const { return at<2>().as_string(); }
+};
+
+class SyncTimelineFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = SyncTimelineFtraceEvent_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SyncTimelineFtraceEvent"; }
+
+
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
-      uint64_t,
-      VulkanMemoryEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SyncTimelineFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MemoryAddress kMemoryAddress() { return {}; }
-  void set_memory_address(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MemoryAddress::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MemorySize =
+  using FieldMetadata_Value =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      VulkanMemoryEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SyncTimelineFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MemorySize kMemorySize() { return {}; }
-  void set_memory_size(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MemorySize::kFieldId;
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
+  }
+  void set_value(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
+  }
+  void set_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_CallerIid =
+class SyncPtFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  SyncPtFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SyncPtFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SyncPtFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_timeline() const { return at<1>().valid(); }
+  ::protozero::ConstChars timeline() const { return at<1>().as_string(); }
+  bool has_value() const { return at<2>().valid(); }
+  ::protozero::ConstChars value() const { return at<2>().as_string(); }
+};
+
+class SyncPtFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = SyncPtFtraceEvent_Decoder;
+  enum : int32_t {
+    kTimelineFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SyncPtFtraceEvent"; }
+
+
+  using FieldMetadata_Timeline =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      VulkanMemoryEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SyncPtFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CallerIid kCallerIid() { return {}; }
-  void set_caller_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CallerIid::kFieldId;
+  static constexpr FieldMetadata_Timeline kTimeline{};
+  void set_timeline(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Timeline::kFieldId, data, size);
+  }
+  void set_timeline(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Timeline::kFieldId, chars.data, chars.size);
+  }
+  void set_timeline(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timeline::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_AllocationScope =
+  using FieldMetadata_Value =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope,
-      VulkanMemoryEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SyncPtFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AllocationScope kAllocationScope() { return {}; }
-  void set_allocation_scope(::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope value) {
-    static constexpr uint32_t field_id = FieldMetadata_AllocationScope::kFieldId;
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
+  }
+  void set_value(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
+  }
+  void set_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Annotations =
-    ::protozero::proto_utils::FieldMetadata<
-      9,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      VulkanMemoryEventAnnotation,
-      VulkanMemoryEvent>;
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/synthetic.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Annotations kAnnotations() { return {}; }
-  template <typename T = VulkanMemoryEventAnnotation> T* add_annotations() {
-    return BeginNestedMessage<T>(9);
-  }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SYNTHETIC_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SYNTHETIC_PROTO_H_
 
+#include <stddef.h>
+#include <stdint.h>
 
-  using FieldMetadata_Device =
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class SuspendResumeMinimalFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  SuspendResumeMinimalFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SuspendResumeMinimalFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SuspendResumeMinimalFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_start() const { return at<1>().valid(); }
+  uint32_t start() const { return at<1>().as_uint32(); }
+};
+
+class SuspendResumeMinimalFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = SuspendResumeMinimalFtraceEvent_Decoder;
+  enum : int32_t {
+    kStartFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SuspendResumeMinimalFtraceEvent"; }
+
+
+  using FieldMetadata_Start =
     ::protozero::proto_utils::FieldMetadata<
-      16,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
-      uint64_t,
-      VulkanMemoryEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SuspendResumeMinimalFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Device kDevice() { return {}; }
-  void set_device(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Device::kFieldId;
+  static constexpr FieldMetadata_Start kStart{};
+  void set_start(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_DeviceMemory =
+class RssStatThrottledFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  RssStatThrottledFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit RssStatThrottledFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit RssStatThrottledFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_curr() const { return at<1>().valid(); }
+  uint32_t curr() const { return at<1>().as_uint32(); }
+  bool has_member() const { return at<2>().valid(); }
+  int32_t member() const { return at<2>().as_int32(); }
+  bool has_mm_id() const { return at<3>().valid(); }
+  uint32_t mm_id() const { return at<3>().as_uint32(); }
+  bool has_size() const { return at<4>().valid(); }
+  int64_t size() const { return at<4>().as_int64(); }
+};
+
+class RssStatThrottledFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = RssStatThrottledFtraceEvent_Decoder;
+  enum : int32_t {
+    kCurrFieldNumber = 1,
+    kMemberFieldNumber = 2,
+    kMmIdFieldNumber = 3,
+    kSizeFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.RssStatThrottledFtraceEvent"; }
+
+
+  using FieldMetadata_Curr =
     ::protozero::proto_utils::FieldMetadata<
-      17,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
-      uint64_t,
-      VulkanMemoryEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      RssStatThrottledFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DeviceMemory kDeviceMemory() { return {}; }
-  void set_device_memory(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DeviceMemory::kFieldId;
+  static constexpr FieldMetadata_Curr kCurr{};
+  void set_curr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Curr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MemoryType =
+  using FieldMetadata_Member =
     ::protozero::proto_utils::FieldMetadata<
-      18,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      VulkanMemoryEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      RssStatThrottledFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MemoryType kMemoryType() { return {}; }
-  void set_memory_type(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MemoryType::kFieldId;
+  static constexpr FieldMetadata_Member kMember{};
+  void set_member(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Member::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Heap =
+  using FieldMetadata_MmId =
     ::protozero::proto_utils::FieldMetadata<
-      19,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      VulkanMemoryEvent>;
+      RssStatThrottledFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Heap kHeap() { return {}; }
-  void set_heap(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Heap::kFieldId;
+  static constexpr FieldMetadata_MmId kMmId{};
+  void set_mm_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MmId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -134657,156 +158746,151 @@ class VulkanMemoryEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ObjectHandle =
+  using FieldMetadata_Size =
     ::protozero::proto_utils::FieldMetadata<
-      20,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
-      uint64_t,
-      VulkanMemoryEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      RssStatThrottledFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ObjectHandle kObjectHandle() { return {}; }
-  void set_object_handle(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ObjectHandle::kFieldId;
+  static constexpr FieldMetadata_Size kSize{};
+  void set_size(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 };
 
-class VulkanMemoryEventAnnotation_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/systrace.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SYSTRACE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_SYSTRACE_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class ZeroFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  VulkanMemoryEventAnnotation_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit VulkanMemoryEventAnnotation_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit VulkanMemoryEventAnnotation_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_key_iid() const { return at<1>().valid(); }
-  uint64_t key_iid() const { return at<1>().as_uint64(); }
-  bool has_int_value() const { return at<2>().valid(); }
-  int64_t int_value() const { return at<2>().as_int64(); }
-  bool has_double_value() const { return at<3>().valid(); }
-  double double_value() const { return at<3>().as_double(); }
-  bool has_string_iid() const { return at<4>().valid(); }
-  uint64_t string_iid() const { return at<4>().as_uint64(); }
+  ZeroFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ZeroFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ZeroFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_flag() const { return at<1>().valid(); }
+  int32_t flag() const { return at<1>().as_int32(); }
+  bool has_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars name() const { return at<2>().as_string(); }
+  bool has_pid() const { return at<3>().valid(); }
+  int32_t pid() const { return at<3>().as_int32(); }
+  bool has_value() const { return at<4>().valid(); }
+  int64_t value() const { return at<4>().as_int64(); }
 };
 
-class VulkanMemoryEventAnnotation : public ::protozero::Message {
+class ZeroFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = VulkanMemoryEventAnnotation_Decoder;
+  using Decoder = ZeroFtraceEvent_Decoder;
   enum : int32_t {
-    kKeyIidFieldNumber = 1,
-    kIntValueFieldNumber = 2,
-    kDoubleValueFieldNumber = 3,
-    kStringIidFieldNumber = 4,
+    kFlagFieldNumber = 1,
+    kNameFieldNumber = 2,
+    kPidFieldNumber = 3,
+    kValueFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.VulkanMemoryEventAnnotation"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.ZeroFtraceEvent"; }
 
 
-  using FieldMetadata_KeyIid =
+  using FieldMetadata_Flag =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      VulkanMemoryEventAnnotation>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ZeroFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KeyIid kKeyIid() { return {}; }
-  void set_key_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_KeyIid::kFieldId;
+  static constexpr FieldMetadata_Flag kFlag{};
+  void set_flag(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flag::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IntValue =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      VulkanMemoryEventAnnotation>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ZeroFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IntValue kIntValue() { return {}; }
-  void set_int_value(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DoubleValue =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kDouble,
-      double,
-      VulkanMemoryEventAnnotation>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ZeroFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DoubleValue kDoubleValue() { return {}; }
-  void set_double_value(double value) {
-    static constexpr uint32_t field_id = FieldMetadata_DoubleValue::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_StringIid =
+  using FieldMetadata_Value =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      VulkanMemoryEventAnnotation>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ZeroFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StringIid kStringIid() { return {}; }
-  void set_string_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StringIid::kFieldId;
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 };
@@ -134815,11 +158899,11 @@ class VulkanMemoryEventAnnotation : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/profiling/deobfuscation.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/task.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_DEOBFUSCATION_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_DEOBFUSCATION_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_TASK_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_TASK_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -134830,166 +158914,73 @@ class VulkanMemoryEventAnnotation : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-class ObfuscatedClass;
-class ObfuscatedMember;
-
-class DeobfuscationMapping_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class TaskRenameFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  DeobfuscationMapping_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit DeobfuscationMapping_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit DeobfuscationMapping_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_package_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars package_name() const { return at<1>().as_string(); }
-  bool has_version_code() const { return at<2>().valid(); }
-  int64_t version_code() const { return at<2>().as_int64(); }
-  bool has_obfuscated_classes() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> obfuscated_classes() const { return GetRepeated<::protozero::ConstBytes>(3); }
+  TaskRenameFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TaskRenameFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TaskRenameFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  int32_t pid() const { return at<1>().as_int32(); }
+  bool has_oldcomm() const { return at<2>().valid(); }
+  ::protozero::ConstChars oldcomm() const { return at<2>().as_string(); }
+  bool has_newcomm() const { return at<3>().valid(); }
+  ::protozero::ConstChars newcomm() const { return at<3>().as_string(); }
+  bool has_oom_score_adj() const { return at<4>().valid(); }
+  int32_t oom_score_adj() const { return at<4>().as_int32(); }
 };
 
-class DeobfuscationMapping : public ::protozero::Message {
+class TaskRenameFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = DeobfuscationMapping_Decoder;
+  using Decoder = TaskRenameFtraceEvent_Decoder;
   enum : int32_t {
-    kPackageNameFieldNumber = 1,
-    kVersionCodeFieldNumber = 2,
-    kObfuscatedClassesFieldNumber = 3,
+    kPidFieldNumber = 1,
+    kOldcommFieldNumber = 2,
+    kNewcommFieldNumber = 3,
+    kOomScoreAdjFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.DeobfuscationMapping"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.TaskRenameFtraceEvent"; }
 
 
-  using FieldMetadata_PackageName =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      DeobfuscationMapping>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TaskRenameFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PackageName kPackageName() { return {}; }
-  void set_package_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_PackageName::kFieldId, data, size);
-  }
-  void set_package_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_PackageName::kFieldId, chars.data, chars.size);
-  }
-  void set_package_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_PackageName::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VersionCode =
+  using FieldMetadata_Oldcomm =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      DeobfuscationMapping>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VersionCode kVersionCode() { return {}; }
-  void set_version_code(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VersionCode::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ObfuscatedClasses =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ObfuscatedClass,
-      DeobfuscationMapping>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ObfuscatedClasses kObfuscatedClasses() { return {}; }
-  template <typename T = ObfuscatedClass> T* add_obfuscated_classes() {
-    return BeginNestedMessage<T>(3);
-  }
-
-};
-
-class ObfuscatedClass_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  ObfuscatedClass_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ObfuscatedClass_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ObfuscatedClass_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_obfuscated_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars obfuscated_name() const { return at<1>().as_string(); }
-  bool has_deobfuscated_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars deobfuscated_name() const { return at<2>().as_string(); }
-  bool has_obfuscated_members() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> obfuscated_members() const { return GetRepeated<::protozero::ConstBytes>(3); }
-  bool has_obfuscated_methods() const { return at<4>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> obfuscated_methods() const { return GetRepeated<::protozero::ConstBytes>(4); }
-};
-
-class ObfuscatedClass : public ::protozero::Message {
- public:
-  using Decoder = ObfuscatedClass_Decoder;
-  enum : int32_t {
-    kObfuscatedNameFieldNumber = 1,
-    kDeobfuscatedNameFieldNumber = 2,
-    kObfuscatedMembersFieldNumber = 3,
-    kObfuscatedMethodsFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ObfuscatedClass"; }
-
-
-  using FieldMetadata_ObfuscatedName =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      ObfuscatedClass>;
+      TaskRenameFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ObfuscatedName kObfuscatedName() { return {}; }
-  void set_obfuscated_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ObfuscatedName::kFieldId, data, size);
+  static constexpr FieldMetadata_Oldcomm kOldcomm{};
+  void set_oldcomm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Oldcomm::kFieldId, data, size);
   }
-  void set_obfuscated_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ObfuscatedName::kFieldId, chars.data, chars.size);
+  void set_oldcomm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Oldcomm::kFieldId, chars.data, chars.size);
   }
-  void set_obfuscated_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ObfuscatedName::kFieldId;
+  void set_oldcomm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Oldcomm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -134997,30 +158988,23 @@ class ObfuscatedClass : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DeobfuscatedName =
+  using FieldMetadata_Newcomm =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      ObfuscatedClass>;
+      TaskRenameFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DeobfuscatedName kDeobfuscatedName() { return {}; }
-  void set_deobfuscated_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_DeobfuscatedName::kFieldId, data, size);
+  static constexpr FieldMetadata_Newcomm kNewcomm{};
+  void set_newcomm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Newcomm::kFieldId, data, size);
   }
-  void set_deobfuscated_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_DeobfuscatedName::kFieldId, chars.data, chars.size);
+  void set_newcomm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Newcomm::kFieldId, chars.data, chars.size);
   }
-  void set_deobfuscated_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_DeobfuscatedName::kFieldId;
+  void set_newcomm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Newcomm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -135028,143 +159012,140 @@ class ObfuscatedClass : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ObfuscatedMembers =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ObfuscatedMember,
-      ObfuscatedClass>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ObfuscatedMembers kObfuscatedMembers() { return {}; }
-  template <typename T = ObfuscatedMember> T* add_obfuscated_members() {
-    return BeginNestedMessage<T>(3);
-  }
-
-
-  using FieldMetadata_ObfuscatedMethods =
+  using FieldMetadata_OomScoreAdj =
     ::protozero::proto_utils::FieldMetadata<
       4,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ObfuscatedMember,
-      ObfuscatedClass>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TaskRenameFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ObfuscatedMethods kObfuscatedMethods() { return {}; }
-  template <typename T = ObfuscatedMember> T* add_obfuscated_methods() {
-    return BeginNestedMessage<T>(4);
+  static constexpr FieldMetadata_OomScoreAdj kOomScoreAdj{};
+  void set_oom_score_adj(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OomScoreAdj::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
   }
-
 };
 
-class ObfuscatedMember_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class TaskNewtaskFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  ObfuscatedMember_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ObfuscatedMember_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ObfuscatedMember_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_obfuscated_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars obfuscated_name() const { return at<1>().as_string(); }
-  bool has_deobfuscated_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars deobfuscated_name() const { return at<2>().as_string(); }
+  TaskNewtaskFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TaskNewtaskFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TaskNewtaskFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  int32_t pid() const { return at<1>().as_int32(); }
+  bool has_comm() const { return at<2>().valid(); }
+  ::protozero::ConstChars comm() const { return at<2>().as_string(); }
+  bool has_clone_flags() const { return at<3>().valid(); }
+  uint64_t clone_flags() const { return at<3>().as_uint64(); }
+  bool has_oom_score_adj() const { return at<4>().valid(); }
+  int32_t oom_score_adj() const { return at<4>().as_int32(); }
 };
 
-class ObfuscatedMember : public ::protozero::Message {
+class TaskNewtaskFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = ObfuscatedMember_Decoder;
+  using Decoder = TaskNewtaskFtraceEvent_Decoder;
   enum : int32_t {
-    kObfuscatedNameFieldNumber = 1,
-    kDeobfuscatedNameFieldNumber = 2,
+    kPidFieldNumber = 1,
+    kCommFieldNumber = 2,
+    kCloneFlagsFieldNumber = 3,
+    kOomScoreAdjFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ObfuscatedMember"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.TaskNewtaskFtraceEvent"; }
 
 
-  using FieldMetadata_ObfuscatedName =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ObfuscatedMember>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TaskNewtaskFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ObfuscatedName kObfuscatedName() { return {}; }
-  void set_obfuscated_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ObfuscatedName::kFieldId, data, size);
-  }
-  void set_obfuscated_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ObfuscatedName::kFieldId, chars.data, chars.size);
-  }
-  void set_obfuscated_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ObfuscatedName::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DeobfuscatedName =
+  using FieldMetadata_Comm =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      ObfuscatedMember>;
+      TaskNewtaskFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DeobfuscatedName kDeobfuscatedName() { return {}; }
-  void set_deobfuscated_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_DeobfuscatedName::kFieldId, data, size);
+  static constexpr FieldMetadata_Comm kComm{};
+  void set_comm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
   }
-  void set_deobfuscated_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_DeobfuscatedName::kFieldId, chars.data, chars.size);
+  void set_comm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
   }
-  void set_deobfuscated_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_DeobfuscatedName::kFieldId;
+  void set_comm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_CloneFlags =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TaskNewtaskFtraceEvent>;
+
+  static constexpr FieldMetadata_CloneFlags kCloneFlags{};
+  void set_clone_flags(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CloneFlags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_OomScoreAdj =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TaskNewtaskFtraceEvent>;
+
+  static constexpr FieldMetadata_OomScoreAdj kOomScoreAdj{};
+  void set_oom_score_adj(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OomScoreAdj::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 };
 
 } // Namespace.
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/profiling/heap_graph.pbzero.h
-// gen_amalgamated begin header: gen/protos/perfetto/trace/profiling/deobfuscation.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/tcp.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_DEOBFUSCATION_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_DEOBFUSCATION_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_TCP_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_TCP_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -135175,327 +159156,170 @@ class ObfuscatedMember : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-class ObfuscatedClass;
-class ObfuscatedMember;
-
-class DeobfuscationMapping_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class TcpRetransmitSkbFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
-  DeobfuscationMapping_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit DeobfuscationMapping_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit DeobfuscationMapping_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_package_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars package_name() const { return at<1>().as_string(); }
-  bool has_version_code() const { return at<2>().valid(); }
-  int64_t version_code() const { return at<2>().as_int64(); }
-  bool has_obfuscated_classes() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> obfuscated_classes() const { return GetRepeated<::protozero::ConstBytes>(3); }
+  TcpRetransmitSkbFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TcpRetransmitSkbFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TcpRetransmitSkbFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_daddr() const { return at<1>().valid(); }
+  uint32_t daddr() const { return at<1>().as_uint32(); }
+  bool has_dport() const { return at<2>().valid(); }
+  uint32_t dport() const { return at<2>().as_uint32(); }
+  bool has_saddr() const { return at<3>().valid(); }
+  uint32_t saddr() const { return at<3>().as_uint32(); }
+  bool has_skaddr() const { return at<4>().valid(); }
+  uint64_t skaddr() const { return at<4>().as_uint64(); }
+  bool has_skbaddr() const { return at<5>().valid(); }
+  uint64_t skbaddr() const { return at<5>().as_uint64(); }
+  bool has_sport() const { return at<6>().valid(); }
+  uint32_t sport() const { return at<6>().as_uint32(); }
+  bool has_state() const { return at<7>().valid(); }
+  int32_t state() const { return at<7>().as_int32(); }
 };
 
-class DeobfuscationMapping : public ::protozero::Message {
+class TcpRetransmitSkbFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = DeobfuscationMapping_Decoder;
+  using Decoder = TcpRetransmitSkbFtraceEvent_Decoder;
   enum : int32_t {
-    kPackageNameFieldNumber = 1,
-    kVersionCodeFieldNumber = 2,
-    kObfuscatedClassesFieldNumber = 3,
+    kDaddrFieldNumber = 1,
+    kDportFieldNumber = 2,
+    kSaddrFieldNumber = 3,
+    kSkaddrFieldNumber = 4,
+    kSkbaddrFieldNumber = 5,
+    kSportFieldNumber = 6,
+    kStateFieldNumber = 7,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.DeobfuscationMapping"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.TcpRetransmitSkbFtraceEvent"; }
 
 
-  using FieldMetadata_PackageName =
+  using FieldMetadata_Daddr =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      DeobfuscationMapping>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TcpRetransmitSkbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PackageName kPackageName() { return {}; }
-  void set_package_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_PackageName::kFieldId, data, size);
-  }
-  void set_package_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_PackageName::kFieldId, chars.data, chars.size);
-  }
-  void set_package_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_PackageName::kFieldId;
+  static constexpr FieldMetadata_Daddr kDaddr{};
+  void set_daddr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Daddr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VersionCode =
+  using FieldMetadata_Dport =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      DeobfuscationMapping>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TcpRetransmitSkbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VersionCode kVersionCode() { return {}; }
-  void set_version_code(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VersionCode::kFieldId;
+  static constexpr FieldMetadata_Dport kDport{};
+  void set_dport(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dport::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ObfuscatedClasses =
+  using FieldMetadata_Saddr =
     ::protozero::proto_utils::FieldMetadata<
       3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ObfuscatedClass,
-      DeobfuscationMapping>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ObfuscatedClasses kObfuscatedClasses() { return {}; }
-  template <typename T = ObfuscatedClass> T* add_obfuscated_classes() {
-    return BeginNestedMessage<T>(3);
-  }
-
-};
-
-class ObfuscatedClass_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  ObfuscatedClass_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ObfuscatedClass_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ObfuscatedClass_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_obfuscated_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars obfuscated_name() const { return at<1>().as_string(); }
-  bool has_deobfuscated_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars deobfuscated_name() const { return at<2>().as_string(); }
-  bool has_obfuscated_members() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> obfuscated_members() const { return GetRepeated<::protozero::ConstBytes>(3); }
-  bool has_obfuscated_methods() const { return at<4>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> obfuscated_methods() const { return GetRepeated<::protozero::ConstBytes>(4); }
-};
-
-class ObfuscatedClass : public ::protozero::Message {
- public:
-  using Decoder = ObfuscatedClass_Decoder;
-  enum : int32_t {
-    kObfuscatedNameFieldNumber = 1,
-    kDeobfuscatedNameFieldNumber = 2,
-    kObfuscatedMembersFieldNumber = 3,
-    kObfuscatedMethodsFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ObfuscatedClass"; }
-
-
-  using FieldMetadata_ObfuscatedName =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ObfuscatedClass>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TcpRetransmitSkbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ObfuscatedName kObfuscatedName() { return {}; }
-  void set_obfuscated_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ObfuscatedName::kFieldId, data, size);
-  }
-  void set_obfuscated_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ObfuscatedName::kFieldId, chars.data, chars.size);
-  }
-  void set_obfuscated_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ObfuscatedName::kFieldId;
+  static constexpr FieldMetadata_Saddr kSaddr{};
+  void set_saddr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Saddr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DeobfuscatedName =
+  using FieldMetadata_Skaddr =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ObfuscatedClass>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TcpRetransmitSkbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DeobfuscatedName kDeobfuscatedName() { return {}; }
-  void set_deobfuscated_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_DeobfuscatedName::kFieldId, data, size);
-  }
-  void set_deobfuscated_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_DeobfuscatedName::kFieldId, chars.data, chars.size);
-  }
-  void set_deobfuscated_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_DeobfuscatedName::kFieldId;
+  static constexpr FieldMetadata_Skaddr kSkaddr{};
+  void set_skaddr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Skaddr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ObfuscatedMembers =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ObfuscatedMember,
-      ObfuscatedClass>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ObfuscatedMembers kObfuscatedMembers() { return {}; }
-  template <typename T = ObfuscatedMember> T* add_obfuscated_members() {
-    return BeginNestedMessage<T>(3);
-  }
-
-
-  using FieldMetadata_ObfuscatedMethods =
+  using FieldMetadata_Skbaddr =
     ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ObfuscatedMember,
-      ObfuscatedClass>;
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TcpRetransmitSkbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ObfuscatedMethods kObfuscatedMethods() { return {}; }
-  template <typename T = ObfuscatedMember> T* add_obfuscated_methods() {
-    return BeginNestedMessage<T>(4);
+  static constexpr FieldMetadata_Skbaddr kSkbaddr{};
+  void set_skbaddr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Skbaddr::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
 
-};
-
-class ObfuscatedMember_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  ObfuscatedMember_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ObfuscatedMember_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ObfuscatedMember_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_obfuscated_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars obfuscated_name() const { return at<1>().as_string(); }
-  bool has_deobfuscated_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars deobfuscated_name() const { return at<2>().as_string(); }
-};
-
-class ObfuscatedMember : public ::protozero::Message {
- public:
-  using Decoder = ObfuscatedMember_Decoder;
-  enum : int32_t {
-    kObfuscatedNameFieldNumber = 1,
-    kDeobfuscatedNameFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ObfuscatedMember"; }
-
-
-  using FieldMetadata_ObfuscatedName =
+  using FieldMetadata_Sport =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ObfuscatedMember>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TcpRetransmitSkbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ObfuscatedName kObfuscatedName() { return {}; }
-  void set_obfuscated_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ObfuscatedName::kFieldId, data, size);
-  }
-  void set_obfuscated_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ObfuscatedName::kFieldId, chars.data, chars.size);
-  }
-  void set_obfuscated_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ObfuscatedName::kFieldId;
+  static constexpr FieldMetadata_Sport kSport{};
+  void set_sport(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Sport::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DeobfuscatedName =
+  using FieldMetadata_State =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ObfuscatedMember>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TcpRetransmitSkbFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DeobfuscatedName kDeobfuscatedName() { return {}; }
-  void set_deobfuscated_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_DeobfuscatedName::kFieldId, data, size);
-  }
-  void set_deobfuscated_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_DeobfuscatedName::kFieldId, chars.data, chars.size);
-  }
-  void set_deobfuscated_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_DeobfuscatedName::kFieldId;
+  static constexpr FieldMetadata_State kState{};
+  void set_state(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
@@ -135504,10 +159328,11 @@ class ObfuscatedMember : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/thermal.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_HEAP_GRAPH_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_HEAP_GRAPH_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_THERMAL_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_THERMAL_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -135517,224 +159342,114 @@ class ObfuscatedMember : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/profiling/deobfuscation.pbzero.h"
+
 
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-class HeapGraphObject;
-class HeapGraphRoot;
-class HeapGraphType;
-class InternedString;
-namespace perfetto_pbzero_enum_HeapGraphRoot {
-enum Type : int32_t;
-}  // namespace perfetto_pbzero_enum_HeapGraphRoot
-using HeapGraphRoot_Type = perfetto_pbzero_enum_HeapGraphRoot::Type;
-namespace perfetto_pbzero_enum_HeapGraphType {
-enum Kind : int32_t;
-}  // namespace perfetto_pbzero_enum_HeapGraphType
-using HeapGraphType_Kind = perfetto_pbzero_enum_HeapGraphType::Kind;
-
-namespace perfetto_pbzero_enum_HeapGraphType {
-enum Kind : int32_t {
-  KIND_UNKNOWN = 0,
-  KIND_NORMAL = 1,
-  KIND_NOREFERENCES = 2,
-  KIND_STRING = 3,
-  KIND_ARRAY = 4,
-  KIND_CLASS = 5,
-  KIND_CLASSLOADER = 6,
-  KIND_DEXCACHE = 7,
-  KIND_SOFT_REFERENCE = 8,
-  KIND_WEAK_REFERENCE = 9,
-  KIND_FINALIZER_REFERENCE = 10,
-  KIND_PHANTOM_REFERENCE = 11,
+class CdevUpdateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  CdevUpdateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit CdevUpdateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit CdevUpdateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_target() const { return at<1>().valid(); }
+  uint64_t target() const { return at<1>().as_uint64(); }
+  bool has_type() const { return at<2>().valid(); }
+  ::protozero::ConstChars type() const { return at<2>().as_string(); }
 };
-} // namespace perfetto_pbzero_enum_HeapGraphType
-using HeapGraphType_Kind = perfetto_pbzero_enum_HeapGraphType::Kind;
-
-
-constexpr HeapGraphType_Kind HeapGraphType_Kind_MIN = HeapGraphType_Kind::KIND_UNKNOWN;
-constexpr HeapGraphType_Kind HeapGraphType_Kind_MAX = HeapGraphType_Kind::KIND_PHANTOM_REFERENCE;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* HeapGraphType_Kind_Name(::perfetto::protos::pbzero::HeapGraphType_Kind value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_UNKNOWN:
-    return "KIND_UNKNOWN";
-
-  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_NORMAL:
-    return "KIND_NORMAL";
-
-  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_NOREFERENCES:
-    return "KIND_NOREFERENCES";
-
-  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_STRING:
-    return "KIND_STRING";
-
-  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_ARRAY:
-    return "KIND_ARRAY";
-
-  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_CLASS:
-    return "KIND_CLASS";
 
-  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_CLASSLOADER:
-    return "KIND_CLASSLOADER";
-
-  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_DEXCACHE:
-    return "KIND_DEXCACHE";
-
-  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_SOFT_REFERENCE:
-    return "KIND_SOFT_REFERENCE";
+class CdevUpdateFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = CdevUpdateFtraceEvent_Decoder;
+  enum : int32_t {
+    kTargetFieldNumber = 1,
+    kTypeFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.CdevUpdateFtraceEvent"; }
 
-  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_WEAK_REFERENCE:
-    return "KIND_WEAK_REFERENCE";
 
-  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_FINALIZER_REFERENCE:
-    return "KIND_FINALIZER_REFERENCE";
+  using FieldMetadata_Target =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      CdevUpdateFtraceEvent>;
 
-  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_PHANTOM_REFERENCE:
-    return "KIND_PHANTOM_REFERENCE";
+  static constexpr FieldMetadata_Target kTarget{};
+  void set_target(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Target::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-namespace perfetto_pbzero_enum_HeapGraphRoot {
-enum Type : int32_t {
-  ROOT_UNKNOWN = 0,
-  ROOT_JNI_GLOBAL = 1,
-  ROOT_JNI_LOCAL = 2,
-  ROOT_JAVA_FRAME = 3,
-  ROOT_NATIVE_STACK = 4,
-  ROOT_STICKY_CLASS = 5,
-  ROOT_THREAD_BLOCK = 6,
-  ROOT_MONITOR_USED = 7,
-  ROOT_THREAD_OBJECT = 8,
-  ROOT_INTERNED_STRING = 9,
-  ROOT_FINALIZING = 10,
-  ROOT_DEBUGGER = 11,
-  ROOT_REFERENCE_CLEANUP = 12,
-  ROOT_VM_INTERNAL = 13,
-  ROOT_JNI_MONITOR = 14,
-};
-} // namespace perfetto_pbzero_enum_HeapGraphRoot
-using HeapGraphRoot_Type = perfetto_pbzero_enum_HeapGraphRoot::Type;
-
-
-constexpr HeapGraphRoot_Type HeapGraphRoot_Type_MIN = HeapGraphRoot_Type::ROOT_UNKNOWN;
-constexpr HeapGraphRoot_Type HeapGraphRoot_Type_MAX = HeapGraphRoot_Type::ROOT_JNI_MONITOR;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* HeapGraphRoot_Type_Name(::perfetto::protos::pbzero::HeapGraphRoot_Type value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_UNKNOWN:
-    return "ROOT_UNKNOWN";
-
-  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_JNI_GLOBAL:
-    return "ROOT_JNI_GLOBAL";
-
-  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_JNI_LOCAL:
-    return "ROOT_JNI_LOCAL";
-
-  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_JAVA_FRAME:
-    return "ROOT_JAVA_FRAME";
-
-  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_NATIVE_STACK:
-    return "ROOT_NATIVE_STACK";
-
-  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_STICKY_CLASS:
-    return "ROOT_STICKY_CLASS";
-
-  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_THREAD_BLOCK:
-    return "ROOT_THREAD_BLOCK";
-
-  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_MONITOR_USED:
-    return "ROOT_MONITOR_USED";
-
-  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_THREAD_OBJECT:
-    return "ROOT_THREAD_OBJECT";
-
-  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_INTERNED_STRING:
-    return "ROOT_INTERNED_STRING";
-
-  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_FINALIZING:
-    return "ROOT_FINALIZING";
-
-  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_DEBUGGER:
-    return "ROOT_DEBUGGER";
-
-  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_REFERENCE_CLEANUP:
-    return "ROOT_REFERENCE_CLEANUP";
 
-  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_VM_INTERNAL:
-    return "ROOT_VM_INTERNAL";
+  using FieldMetadata_Type =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      CdevUpdateFtraceEvent>;
 
-  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_JNI_MONITOR:
-    return "ROOT_JNI_MONITOR";
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Type::kFieldId, data, size);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+  void set_type(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Type::kFieldId, chars.data, chars.size);
+  }
+  void set_type(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
 
-class HeapGraph_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class ThermalTemperatureFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  HeapGraph_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit HeapGraph_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit HeapGraph_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pid() const { return at<1>().valid(); }
-  int32_t pid() const { return at<1>().as_int32(); }
-  bool has_objects() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> objects() const { return GetRepeated<::protozero::ConstBytes>(2); }
-  bool has_roots() const { return at<7>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> roots() const { return GetRepeated<::protozero::ConstBytes>(7); }
-  bool has_types() const { return at<9>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> types() const { return GetRepeated<::protozero::ConstBytes>(9); }
-  bool has_field_names() const { return at<4>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> field_names() const { return GetRepeated<::protozero::ConstBytes>(4); }
-  bool has_location_names() const { return at<8>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> location_names() const { return GetRepeated<::protozero::ConstBytes>(8); }
-  bool has_continued() const { return at<5>().valid(); }
-  bool continued() const { return at<5>().as_bool(); }
-  bool has_index() const { return at<6>().valid(); }
-  uint64_t index() const { return at<6>().as_uint64(); }
+  ThermalTemperatureFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ThermalTemperatureFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ThermalTemperatureFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  int32_t id() const { return at<1>().as_int32(); }
+  bool has_temp() const { return at<2>().valid(); }
+  int32_t temp() const { return at<2>().as_int32(); }
+  bool has_temp_prev() const { return at<3>().valid(); }
+  int32_t temp_prev() const { return at<3>().as_int32(); }
+  bool has_thermal_zone() const { return at<4>().valid(); }
+  ::protozero::ConstChars thermal_zone() const { return at<4>().as_string(); }
 };
 
-class HeapGraph : public ::protozero::Message {
+class ThermalTemperatureFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = HeapGraph_Decoder;
+  using Decoder = ThermalTemperatureFtraceEvent_Decoder;
   enum : int32_t {
-    kPidFieldNumber = 1,
-    kObjectsFieldNumber = 2,
-    kRootsFieldNumber = 7,
-    kTypesFieldNumber = 9,
-    kFieldNamesFieldNumber = 4,
-    kLocationNamesFieldNumber = 8,
-    kContinuedFieldNumber = 5,
-    kIndexFieldNumber = 6,
+    kIdFieldNumber = 1,
+    kTempFieldNumber = 2,
+    kTempPrevFieldNumber = 3,
+    kThermalZoneFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.HeapGraph"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.ThermalTemperatureFtraceEvent"; }
 
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      HeapGraph>;
+      ThermalTemperatureFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -135742,737 +159457,497 @@ class HeapGraph : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Objects =
+  using FieldMetadata_Temp =
     ::protozero::proto_utils::FieldMetadata<
       2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      HeapGraphObject,
-      HeapGraph>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Objects kObjects() { return {}; }
-  template <typename T = HeapGraphObject> T* add_objects() {
-    return BeginNestedMessage<T>(2);
-  }
-
-
-  using FieldMetadata_Roots =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      HeapGraphRoot,
-      HeapGraph>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Roots kRoots() { return {}; }
-  template <typename T = HeapGraphRoot> T* add_roots() {
-    return BeginNestedMessage<T>(7);
-  }
-
-
-  using FieldMetadata_Types =
-    ::protozero::proto_utils::FieldMetadata<
-      9,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      HeapGraphType,
-      HeapGraph>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Types kTypes() { return {}; }
-  template <typename T = HeapGraphType> T* add_types() {
-    return BeginNestedMessage<T>(9);
-  }
-
-
-  using FieldMetadata_FieldNames =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      InternedString,
-      HeapGraph>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FieldNames kFieldNames() { return {}; }
-  template <typename T = InternedString> T* add_field_names() {
-    return BeginNestedMessage<T>(4);
-  }
-
-
-  using FieldMetadata_LocationNames =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      InternedString,
-      HeapGraph>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ThermalTemperatureFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LocationNames kLocationNames() { return {}; }
-  template <typename T = InternedString> T* add_location_names() {
-    return BeginNestedMessage<T>(8);
+  static constexpr FieldMetadata_Temp kTemp{};
+  void set_temp(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Temp::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_Continued =
+  using FieldMetadata_TempPrev =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      HeapGraph>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ThermalTemperatureFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Continued kContinued() { return {}; }
-  void set_continued(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_Continued::kFieldId;
+  static constexpr FieldMetadata_TempPrev kTempPrev{};
+  void set_temp_prev(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TempPrev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Index =
+  using FieldMetadata_ThermalZone =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      HeapGraph>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ThermalTemperatureFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Index kIndex() { return {}; }
-  void set_index(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
+  static constexpr FieldMetadata_ThermalZone kThermalZone{};
+  void set_thermal_zone(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ThermalZone::kFieldId, data, size);
+  }
+  void set_thermal_zone(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ThermalZone::kFieldId, chars.data, chars.size);
+  }
+  void set_thermal_zone(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ThermalZone::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 };
 
-class HeapGraphObject_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/thermal_exynos.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_THERMAL_EXYNOS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_THERMAL_EXYNOS_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class ThermalExynosAcpmHighOverheadFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
-  HeapGraphObject_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit HeapGraphObject_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit HeapGraphObject_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_id() const { return at<1>().valid(); }
-  uint64_t id() const { return at<1>().as_uint64(); }
-  bool has_id_delta() const { return at<7>().valid(); }
-  uint64_t id_delta() const { return at<7>().as_uint64(); }
-  bool has_type_id() const { return at<2>().valid(); }
-  uint64_t type_id() const { return at<2>().as_uint64(); }
-  bool has_self_size() const { return at<3>().valid(); }
-  uint64_t self_size() const { return at<3>().as_uint64(); }
-  bool has_reference_field_id_base() const { return at<6>().valid(); }
-  uint64_t reference_field_id_base() const { return at<6>().as_uint64(); }
-  bool has_reference_field_id() const { return at<4>().valid(); }
-  ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> reference_field_id(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(4, parse_error_ptr); }
-  bool has_reference_object_id() const { return at<5>().valid(); }
-  ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> reference_object_id(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(5, parse_error_ptr); }
-  bool has_native_allocation_registry_size_field() const { return at<8>().valid(); }
-  int64_t native_allocation_registry_size_field() const { return at<8>().as_int64(); }
+  ThermalExynosAcpmHighOverheadFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ThermalExynosAcpmHighOverheadFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ThermalExynosAcpmHighOverheadFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_tz_id() const { return at<1>().valid(); }
+  int32_t tz_id() const { return at<1>().as_int32(); }
+  bool has_current_temp() const { return at<2>().valid(); }
+  uint32_t current_temp() const { return at<2>().as_uint32(); }
+  bool has_ctrl_temp() const { return at<3>().valid(); }
+  uint32_t ctrl_temp() const { return at<3>().as_uint32(); }
+  bool has_cdev_state() const { return at<4>().valid(); }
+  uint32_t cdev_state() const { return at<4>().as_uint32(); }
+  bool has_pid_et_p() const { return at<5>().valid(); }
+  int32_t pid_et_p() const { return at<5>().as_int32(); }
+  bool has_k_p() const { return at<6>().valid(); }
+  int32_t k_p() const { return at<6>().as_int32(); }
+  bool has_k_i() const { return at<7>().valid(); }
+  int32_t k_i() const { return at<7>().as_int32(); }
 };
 
-class HeapGraphObject : public ::protozero::Message {
+class ThermalExynosAcpmHighOverheadFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = HeapGraphObject_Decoder;
+  using Decoder = ThermalExynosAcpmHighOverheadFtraceEvent_Decoder;
   enum : int32_t {
-    kIdFieldNumber = 1,
-    kIdDeltaFieldNumber = 7,
-    kTypeIdFieldNumber = 2,
-    kSelfSizeFieldNumber = 3,
-    kReferenceFieldIdBaseFieldNumber = 6,
-    kReferenceFieldIdFieldNumber = 4,
-    kReferenceObjectIdFieldNumber = 5,
-    kNativeAllocationRegistrySizeFieldFieldNumber = 8,
+    kTzIdFieldNumber = 1,
+    kCurrentTempFieldNumber = 2,
+    kCtrlTempFieldNumber = 3,
+    kCdevStateFieldNumber = 4,
+    kPidEtPFieldNumber = 5,
+    kKPFieldNumber = 6,
+    kKIFieldNumber = 7,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.HeapGraphObject"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.ThermalExynosAcpmHighOverheadFtraceEvent"; }
 
 
-  using FieldMetadata_Id =
+  using FieldMetadata_TzId =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      HeapGraphObject>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ThermalExynosAcpmHighOverheadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
-  void set_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+  static constexpr FieldMetadata_TzId kTzId{};
+  void set_tz_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TzId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IdDelta =
+  using FieldMetadata_CurrentTemp =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      HeapGraphObject>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ThermalExynosAcpmHighOverheadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IdDelta kIdDelta() { return {}; }
-  void set_id_delta(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IdDelta::kFieldId;
+  static constexpr FieldMetadata_CurrentTemp kCurrentTemp{};
+  void set_current_temp(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CurrentTemp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TypeId =
+  using FieldMetadata_CtrlTemp =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      HeapGraphObject>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ThermalExynosAcpmHighOverheadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TypeId kTypeId() { return {}; }
-  void set_type_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TypeId::kFieldId;
+  static constexpr FieldMetadata_CtrlTemp kCtrlTemp{};
+  void set_ctrl_temp(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CtrlTemp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SelfSize =
+  using FieldMetadata_CdevState =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      HeapGraphObject>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ThermalExynosAcpmHighOverheadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SelfSize kSelfSize() { return {}; }
-  void set_self_size(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SelfSize::kFieldId;
+  static constexpr FieldMetadata_CdevState kCdevState{};
+  void set_cdev_state(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CdevState::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ReferenceFieldIdBase =
+  using FieldMetadata_PidEtP =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      HeapGraphObject>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ThermalExynosAcpmHighOverheadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReferenceFieldIdBase kReferenceFieldIdBase() { return {}; }
-  void set_reference_field_id_base(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReferenceFieldIdBase::kFieldId;
+  static constexpr FieldMetadata_PidEtP kPidEtP{};
+  void set_pid_et_p(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PidEtP::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ReferenceFieldId =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      HeapGraphObject>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReferenceFieldId kReferenceFieldId() { return {}; }
-  void set_reference_field_id(const ::protozero::PackedVarInt& packed_buffer) {
-    AppendBytes(FieldMetadata_ReferenceFieldId::kFieldId, packed_buffer.data(),
-                packed_buffer.size());
-  }
-
-  using FieldMetadata_ReferenceObjectId =
+  using FieldMetadata_KP =
     ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      HeapGraphObject>;
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ThermalExynosAcpmHighOverheadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReferenceObjectId kReferenceObjectId() { return {}; }
-  void set_reference_object_id(const ::protozero::PackedVarInt& packed_buffer) {
-    AppendBytes(FieldMetadata_ReferenceObjectId::kFieldId, packed_buffer.data(),
-                packed_buffer.size());
+  static constexpr FieldMetadata_KP kKP{};
+  void set_k_p(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KP::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NativeAllocationRegistrySizeField =
+  using FieldMetadata_KI =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      HeapGraphObject>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ThermalExynosAcpmHighOverheadFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NativeAllocationRegistrySizeField kNativeAllocationRegistrySizeField() { return {}; }
-  void set_native_allocation_registry_size_field(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NativeAllocationRegistrySizeField::kFieldId;
+  static constexpr FieldMetadata_KI kKI{};
+  void set_k_i(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KI::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class HeapGraphType_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class ThermalExynosAcpmBulkFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11> {
  public:
-  HeapGraphType_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit HeapGraphType_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit HeapGraphType_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_id() const { return at<1>().valid(); }
-  uint64_t id() const { return at<1>().as_uint64(); }
-  bool has_location_id() const { return at<2>().valid(); }
-  uint64_t location_id() const { return at<2>().as_uint64(); }
-  bool has_class_name() const { return at<3>().valid(); }
-  ::protozero::ConstChars class_name() const { return at<3>().as_string(); }
-  bool has_object_size() const { return at<4>().valid(); }
-  uint64_t object_size() const { return at<4>().as_uint64(); }
-  bool has_superclass_id() const { return at<5>().valid(); }
-  uint64_t superclass_id() const { return at<5>().as_uint64(); }
-  bool has_reference_field_id() const { return at<6>().valid(); }
-  ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> reference_field_id(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(6, parse_error_ptr); }
-  bool has_kind() const { return at<7>().valid(); }
-  int32_t kind() const { return at<7>().as_int32(); }
-  bool has_classloader_id() const { return at<8>().valid(); }
-  uint64_t classloader_id() const { return at<8>().as_uint64(); }
+  ThermalExynosAcpmBulkFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ThermalExynosAcpmBulkFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ThermalExynosAcpmBulkFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_tz_id() const { return at<1>().valid(); }
+  uint32_t tz_id() const { return at<1>().as_uint32(); }
+  bool has_current_temp() const { return at<2>().valid(); }
+  uint32_t current_temp() const { return at<2>().as_uint32(); }
+  bool has_ctrl_temp() const { return at<3>().valid(); }
+  uint32_t ctrl_temp() const { return at<3>().as_uint32(); }
+  bool has_cdev_state() const { return at<4>().valid(); }
+  uint32_t cdev_state() const { return at<4>().as_uint32(); }
+  bool has_pid_et_p() const { return at<5>().valid(); }
+  int32_t pid_et_p() const { return at<5>().as_int32(); }
+  bool has_pid_power_range() const { return at<6>().valid(); }
+  int32_t pid_power_range() const { return at<6>().as_int32(); }
+  bool has_pid_p() const { return at<7>().valid(); }
+  int32_t pid_p() const { return at<7>().as_int32(); }
+  bool has_pid_i() const { return at<8>().valid(); }
+  int32_t pid_i() const { return at<8>().as_int32(); }
+  bool has_k_p() const { return at<9>().valid(); }
+  int32_t k_p() const { return at<9>().as_int32(); }
+  bool has_k_i() const { return at<10>().valid(); }
+  int32_t k_i() const { return at<10>().as_int32(); }
+  bool has_timestamp() const { return at<11>().valid(); }
+  uint64_t timestamp() const { return at<11>().as_uint64(); }
 };
 
-class HeapGraphType : public ::protozero::Message {
+class ThermalExynosAcpmBulkFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = HeapGraphType_Decoder;
+  using Decoder = ThermalExynosAcpmBulkFtraceEvent_Decoder;
   enum : int32_t {
-    kIdFieldNumber = 1,
-    kLocationIdFieldNumber = 2,
-    kClassNameFieldNumber = 3,
-    kObjectSizeFieldNumber = 4,
-    kSuperclassIdFieldNumber = 5,
-    kReferenceFieldIdFieldNumber = 6,
-    kKindFieldNumber = 7,
-    kClassloaderIdFieldNumber = 8,
+    kTzIdFieldNumber = 1,
+    kCurrentTempFieldNumber = 2,
+    kCtrlTempFieldNumber = 3,
+    kCdevStateFieldNumber = 4,
+    kPidEtPFieldNumber = 5,
+    kPidPowerRangeFieldNumber = 6,
+    kPidPFieldNumber = 7,
+    kPidIFieldNumber = 8,
+    kKPFieldNumber = 9,
+    kKIFieldNumber = 10,
+    kTimestampFieldNumber = 11,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.HeapGraphType"; }
-
+  static constexpr const char* GetName() { return ".perfetto.protos.ThermalExynosAcpmBulkFtraceEvent"; }
 
-  using Kind = ::perfetto::protos::pbzero::HeapGraphType_Kind;
-  static inline const char* Kind_Name(Kind value) {
-    return ::perfetto::protos::pbzero::HeapGraphType_Kind_Name(value);
-  }
-  static const Kind KIND_UNKNOWN = Kind::KIND_UNKNOWN;
-  static const Kind KIND_NORMAL = Kind::KIND_NORMAL;
-  static const Kind KIND_NOREFERENCES = Kind::KIND_NOREFERENCES;
-  static const Kind KIND_STRING = Kind::KIND_STRING;
-  static const Kind KIND_ARRAY = Kind::KIND_ARRAY;
-  static const Kind KIND_CLASS = Kind::KIND_CLASS;
-  static const Kind KIND_CLASSLOADER = Kind::KIND_CLASSLOADER;
-  static const Kind KIND_DEXCACHE = Kind::KIND_DEXCACHE;
-  static const Kind KIND_SOFT_REFERENCE = Kind::KIND_SOFT_REFERENCE;
-  static const Kind KIND_WEAK_REFERENCE = Kind::KIND_WEAK_REFERENCE;
-  static const Kind KIND_FINALIZER_REFERENCE = Kind::KIND_FINALIZER_REFERENCE;
-  static const Kind KIND_PHANTOM_REFERENCE = Kind::KIND_PHANTOM_REFERENCE;
 
-  using FieldMetadata_Id =
+  using FieldMetadata_TzId =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      HeapGraphType>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ThermalExynosAcpmBulkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
-  void set_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+  static constexpr FieldMetadata_TzId kTzId{};
+  void set_tz_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TzId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_LocationId =
+  using FieldMetadata_CurrentTemp =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      HeapGraphType>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ThermalExynosAcpmBulkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LocationId kLocationId() { return {}; }
-  void set_location_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LocationId::kFieldId;
+  static constexpr FieldMetadata_CurrentTemp kCurrentTemp{};
+  void set_current_temp(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CurrentTemp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ClassName =
+  using FieldMetadata_CtrlTemp =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      HeapGraphType>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ThermalExynosAcpmBulkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClassName kClassName() { return {}; }
-  void set_class_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ClassName::kFieldId, data, size);
-  }
-  void set_class_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ClassName::kFieldId, chars.data, chars.size);
-  }
-  void set_class_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ClassName::kFieldId;
+  static constexpr FieldMetadata_CtrlTemp kCtrlTemp{};
+  void set_ctrl_temp(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CtrlTemp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ObjectSize =
+  using FieldMetadata_CdevState =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      HeapGraphType>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ThermalExynosAcpmBulkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ObjectSize kObjectSize() { return {}; }
-  void set_object_size(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ObjectSize::kFieldId;
+  static constexpr FieldMetadata_CdevState kCdevState{};
+  void set_cdev_state(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CdevState::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SuperclassId =
+  using FieldMetadata_PidEtP =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      HeapGraphType>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ThermalExynosAcpmBulkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SuperclassId kSuperclassId() { return {}; }
-  void set_superclass_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SuperclassId::kFieldId;
+  static constexpr FieldMetadata_PidEtP kPidEtP{};
+  void set_pid_et_p(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PidEtP::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ReferenceFieldId =
+  using FieldMetadata_PidPowerRange =
     ::protozero::proto_utils::FieldMetadata<
       6,
-      ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      HeapGraphType>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ThermalExynosAcpmBulkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReferenceFieldId kReferenceFieldId() { return {}; }
-  void set_reference_field_id(const ::protozero::PackedVarInt& packed_buffer) {
-    AppendBytes(FieldMetadata_ReferenceFieldId::kFieldId, packed_buffer.data(),
-                packed_buffer.size());
+  static constexpr FieldMetadata_PidPowerRange kPidPowerRange{};
+  void set_pid_power_range(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PidPowerRange::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Kind =
+  using FieldMetadata_PidP =
     ::protozero::proto_utils::FieldMetadata<
       7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::HeapGraphType_Kind,
-      HeapGraphType>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ThermalExynosAcpmBulkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Kind kKind() { return {}; }
-  void set_kind(::perfetto::protos::pbzero::HeapGraphType_Kind value) {
-    static constexpr uint32_t field_id = FieldMetadata_Kind::kFieldId;
+  static constexpr FieldMetadata_PidP kPidP{};
+  void set_pid_p(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PidP::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_PidI =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ThermalExynosAcpmBulkFtraceEvent>;
+
+  static constexpr FieldMetadata_PidI kPidI{};
+  void set_pid_i(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PidI::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_KP =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ThermalExynosAcpmBulkFtraceEvent>;
+
+  static constexpr FieldMetadata_KP kKP{};
+  void set_k_p(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KP::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ClassloaderId =
+  using FieldMetadata_KI =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      HeapGraphType>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ThermalExynosAcpmBulkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClassloaderId kClassloaderId() { return {}; }
-  void set_classloader_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ClassloaderId::kFieldId;
+  static constexpr FieldMetadata_KI kKI{};
+  void set_k_i(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KI::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-class HeapGraphRoot_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  HeapGraphRoot_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit HeapGraphRoot_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit HeapGraphRoot_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_object_ids() const { return at<1>().valid(); }
-  ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> object_ids(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(1, parse_error_ptr); }
-  bool has_root_type() const { return at<2>().valid(); }
-  int32_t root_type() const { return at<2>().as_int32(); }
-};
-
-class HeapGraphRoot : public ::protozero::Message {
- public:
-  using Decoder = HeapGraphRoot_Decoder;
-  enum : int32_t {
-    kObjectIdsFieldNumber = 1,
-    kRootTypeFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.HeapGraphRoot"; }
-
-
-  using Type = ::perfetto::protos::pbzero::HeapGraphRoot_Type;
-  static inline const char* Type_Name(Type value) {
-    return ::perfetto::protos::pbzero::HeapGraphRoot_Type_Name(value);
-  }
-  static const Type ROOT_UNKNOWN = Type::ROOT_UNKNOWN;
-  static const Type ROOT_JNI_GLOBAL = Type::ROOT_JNI_GLOBAL;
-  static const Type ROOT_JNI_LOCAL = Type::ROOT_JNI_LOCAL;
-  static const Type ROOT_JAVA_FRAME = Type::ROOT_JAVA_FRAME;
-  static const Type ROOT_NATIVE_STACK = Type::ROOT_NATIVE_STACK;
-  static const Type ROOT_STICKY_CLASS = Type::ROOT_STICKY_CLASS;
-  static const Type ROOT_THREAD_BLOCK = Type::ROOT_THREAD_BLOCK;
-  static const Type ROOT_MONITOR_USED = Type::ROOT_MONITOR_USED;
-  static const Type ROOT_THREAD_OBJECT = Type::ROOT_THREAD_OBJECT;
-  static const Type ROOT_INTERNED_STRING = Type::ROOT_INTERNED_STRING;
-  static const Type ROOT_FINALIZING = Type::ROOT_FINALIZING;
-  static const Type ROOT_DEBUGGER = Type::ROOT_DEBUGGER;
-  static const Type ROOT_REFERENCE_CLEANUP = Type::ROOT_REFERENCE_CLEANUP;
-  static const Type ROOT_VM_INTERNAL = Type::ROOT_VM_INTERNAL;
-  static const Type ROOT_JNI_MONITOR = Type::ROOT_JNI_MONITOR;
 
-  using FieldMetadata_ObjectIds =
+  using FieldMetadata_Timestamp =
     ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      HeapGraphRoot>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ObjectIds kObjectIds() { return {}; }
-  void set_object_ids(const ::protozero::PackedVarInt& packed_buffer) {
-    AppendBytes(FieldMetadata_ObjectIds::kFieldId, packed_buffer.data(),
-                packed_buffer.size());
-  }
-
-  using FieldMetadata_RootType =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::HeapGraphRoot_Type,
-      HeapGraphRoot>;
+      ThermalExynosAcpmBulkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RootType kRootType() { return {}; }
-  void set_root_type(::perfetto::protos::pbzero::HeapGraphRoot_Type value) {
-    static constexpr uint32_t field_id = FieldMetadata_RootType::kFieldId;
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
@@ -136481,11 +159956,11 @@ class HeapGraphRoot : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/profiling/profile_common.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/timer.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_PROFILE_COMMON_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_PROFILE_COMMON_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_TIMER_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_TIMER_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -136496,77 +159971,40 @@ class HeapGraphRoot : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-class AddressSymbols;
-class Line;
-
-class Callstack_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class TimerExpireExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  Callstack_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Callstack_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Callstack_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_iid() const { return at<1>().valid(); }
-  uint64_t iid() const { return at<1>().as_uint64(); }
-  bool has_frame_ids() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> frame_ids() const { return GetRepeated<uint64_t>(2); }
+  TimerExpireExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TimerExpireExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TimerExpireExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_timer() const { return at<1>().valid(); }
+  uint64_t timer() const { return at<1>().as_uint64(); }
 };
 
-class Callstack : public ::protozero::Message {
+class TimerExpireExitFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Callstack_Decoder;
+  using Decoder = TimerExpireExitFtraceEvent_Decoder;
   enum : int32_t {
-    kIidFieldNumber = 1,
-    kFrameIdsFieldNumber = 2,
+    kTimerFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Callstack"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.TimerExpireExitFtraceEvent"; }
 
 
-  using FieldMetadata_Iid =
+  using FieldMetadata_Timer =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Callstack>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Iid kIid() { return {}; }
-  void set_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_FrameIds =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Callstack>;
+      TimerExpireExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FrameIds kFrameIds() { return {}; }
-  void add_frame_ids(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FrameIds::kFieldId;
+  static constexpr FieldMetadata_Timer kTimer{};
+  void set_timer(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timer::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -136575,51 +160013,44 @@ class Callstack : public ::protozero::Message {
   }
 };
 
-class Frame_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class TimerExpireEntryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  Frame_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Frame_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Frame_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_iid() const { return at<1>().valid(); }
-  uint64_t iid() const { return at<1>().as_uint64(); }
-  bool has_function_name_id() const { return at<2>().valid(); }
-  uint64_t function_name_id() const { return at<2>().as_uint64(); }
-  bool has_mapping_id() const { return at<3>().valid(); }
-  uint64_t mapping_id() const { return at<3>().as_uint64(); }
-  bool has_rel_pc() const { return at<4>().valid(); }
-  uint64_t rel_pc() const { return at<4>().as_uint64(); }
+  TimerExpireEntryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TimerExpireEntryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TimerExpireEntryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_timer() const { return at<1>().valid(); }
+  uint64_t timer() const { return at<1>().as_uint64(); }
+  bool has_now() const { return at<2>().valid(); }
+  uint64_t now() const { return at<2>().as_uint64(); }
+  bool has_function() const { return at<3>().valid(); }
+  uint64_t function() const { return at<3>().as_uint64(); }
+  bool has_baseclk() const { return at<4>().valid(); }
+  uint64_t baseclk() const { return at<4>().as_uint64(); }
 };
 
-class Frame : public ::protozero::Message {
+class TimerExpireEntryFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Frame_Decoder;
+  using Decoder = TimerExpireEntryFtraceEvent_Decoder;
   enum : int32_t {
-    kIidFieldNumber = 1,
-    kFunctionNameIdFieldNumber = 2,
-    kMappingIdFieldNumber = 3,
-    kRelPcFieldNumber = 4,
+    kTimerFieldNumber = 1,
+    kNowFieldNumber = 2,
+    kFunctionFieldNumber = 3,
+    kBaseclkFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Frame"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.TimerExpireEntryFtraceEvent"; }
 
 
-  using FieldMetadata_Iid =
+  using FieldMetadata_Timer =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Frame>;
+      TimerExpireEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Iid kIid() { return {}; }
-  void set_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
+  static constexpr FieldMetadata_Timer kTimer{};
+  void set_timer(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timer::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -136627,24 +160058,17 @@ class Frame : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FunctionNameId =
+  using FieldMetadata_Now =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Frame>;
+      TimerExpireEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FunctionNameId kFunctionNameId() { return {}; }
-  void set_function_name_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FunctionNameId::kFieldId;
+  static constexpr FieldMetadata_Now kNow{};
+  void set_now(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Now::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -136652,24 +160076,17 @@ class Frame : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MappingId =
+  using FieldMetadata_Function =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Frame>;
+      TimerExpireEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MappingId kMappingId() { return {}; }
-  void set_mapping_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MappingId::kFieldId;
+  static constexpr FieldMetadata_Function kFunction{};
+  void set_function(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Function::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -136677,24 +160094,17 @@ class Frame : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_RelPc =
+  using FieldMetadata_Baseclk =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Frame>;
+      TimerExpireEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RelPc kRelPc() { return {}; }
-  void set_rel_pc(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RelPc::kFieldId;
+  static constexpr FieldMetadata_Baseclk kBaseclk{};
+  void set_baseclk(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Baseclk::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -136703,88 +160113,90 @@ class Frame : public ::protozero::Message {
   }
 };
 
-class Mapping_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class TimerCancelFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  Mapping_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Mapping_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Mapping_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_iid() const { return at<1>().valid(); }
-  uint64_t iid() const { return at<1>().as_uint64(); }
-  bool has_build_id() const { return at<2>().valid(); }
-  uint64_t build_id() const { return at<2>().as_uint64(); }
-  bool has_exact_offset() const { return at<8>().valid(); }
-  uint64_t exact_offset() const { return at<8>().as_uint64(); }
-  bool has_start_offset() const { return at<3>().valid(); }
-  uint64_t start_offset() const { return at<3>().as_uint64(); }
-  bool has_start() const { return at<4>().valid(); }
-  uint64_t start() const { return at<4>().as_uint64(); }
-  bool has_end() const { return at<5>().valid(); }
-  uint64_t end() const { return at<5>().as_uint64(); }
-  bool has_load_bias() const { return at<6>().valid(); }
-  uint64_t load_bias() const { return at<6>().as_uint64(); }
-  bool has_path_string_ids() const { return at<7>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> path_string_ids() const { return GetRepeated<uint64_t>(7); }
+  TimerCancelFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TimerCancelFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TimerCancelFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_timer() const { return at<1>().valid(); }
+  uint64_t timer() const { return at<1>().as_uint64(); }
 };
 
-class Mapping : public ::protozero::Message {
+class TimerCancelFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Mapping_Decoder;
+  using Decoder = TimerCancelFtraceEvent_Decoder;
   enum : int32_t {
-    kIidFieldNumber = 1,
-    kBuildIdFieldNumber = 2,
-    kExactOffsetFieldNumber = 8,
-    kStartOffsetFieldNumber = 3,
-    kStartFieldNumber = 4,
-    kEndFieldNumber = 5,
-    kLoadBiasFieldNumber = 6,
-    kPathStringIdsFieldNumber = 7,
+    kTimerFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Mapping"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.TimerCancelFtraceEvent"; }
 
 
-  using FieldMetadata_Iid =
+  using FieldMetadata_Timer =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Mapping>;
+      TimerCancelFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Iid kIid() { return {}; }
-  void set_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
+  static constexpr FieldMetadata_Timer kTimer{};
+  void set_timer(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timer::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_BuildId =
+class TimerStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
+ public:
+  TimerStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TimerStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TimerStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_timer() const { return at<1>().valid(); }
+  uint64_t timer() const { return at<1>().as_uint64(); }
+  bool has_function() const { return at<2>().valid(); }
+  uint64_t function() const { return at<2>().as_uint64(); }
+  bool has_expires() const { return at<3>().valid(); }
+  uint64_t expires() const { return at<3>().as_uint64(); }
+  bool has_now() const { return at<4>().valid(); }
+  uint64_t now() const { return at<4>().as_uint64(); }
+  bool has_deferrable() const { return at<5>().valid(); }
+  uint32_t deferrable() const { return at<5>().as_uint32(); }
+  bool has_flags() const { return at<6>().valid(); }
+  uint32_t flags() const { return at<6>().as_uint32(); }
+  bool has_bucket_expiry() const { return at<7>().valid(); }
+  uint64_t bucket_expiry() const { return at<7>().as_uint64(); }
+};
+
+class TimerStartFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = TimerStartFtraceEvent_Decoder;
+  enum : int32_t {
+    kTimerFieldNumber = 1,
+    kFunctionFieldNumber = 2,
+    kExpiresFieldNumber = 3,
+    kNowFieldNumber = 4,
+    kDeferrableFieldNumber = 5,
+    kFlagsFieldNumber = 6,
+    kBucketExpiryFieldNumber = 7,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TimerStartFtraceEvent"; }
+
+
+  using FieldMetadata_Timer =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Mapping>;
+      TimerStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BuildId kBuildId() { return {}; }
-  void set_build_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BuildId::kFieldId;
+  static constexpr FieldMetadata_Timer kTimer{};
+  void set_timer(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timer::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -136792,24 +160204,17 @@ class Mapping : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ExactOffset =
+  using FieldMetadata_Function =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Mapping>;
+      TimerStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExactOffset kExactOffset() { return {}; }
-  void set_exact_offset(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ExactOffset::kFieldId;
+  static constexpr FieldMetadata_Function kFunction{};
+  void set_function(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Function::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -136817,24 +160222,17 @@ class Mapping : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_StartOffset =
+  using FieldMetadata_Expires =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Mapping>;
+      TimerStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StartOffset kStartOffset() { return {}; }
-  void set_start_offset(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StartOffset::kFieldId;
+  static constexpr FieldMetadata_Expires kExpires{};
+  void set_expires(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Expires::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -136842,24 +160240,17 @@ class Mapping : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Start =
+  using FieldMetadata_Now =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Mapping>;
+      TimerStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Start kStart() { return {}; }
-  void set_start(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
+  static constexpr FieldMetadata_Now kNow{};
+  void set_now(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Now::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -136867,74 +160258,90 @@ class Mapping : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_End =
+  using FieldMetadata_Deferrable =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      Mapping>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TimerStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_End kEnd() { return {}; }
-  void set_end(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_End::kFieldId;
+  static constexpr FieldMetadata_Deferrable kDeferrable{};
+  void set_deferrable(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Deferrable::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_LoadBias =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TimerStartFtraceEvent>;
+
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_BucketExpiry =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Mapping>;
+      TimerStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LoadBias kLoadBias() { return {}; }
-  void set_load_bias(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LoadBias::kFieldId;
+  static constexpr FieldMetadata_BucketExpiry kBucketExpiry{};
+  void set_bucket_expiry(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BucketExpiry::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_PathStringIds =
+class HrtimerExpireExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  HrtimerExpireExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HrtimerExpireExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HrtimerExpireExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_hrtimer() const { return at<1>().valid(); }
+  uint64_t hrtimer() const { return at<1>().as_uint64(); }
+};
+
+class HrtimerExpireExitFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = HrtimerExpireExitFtraceEvent_Decoder;
+  enum : int32_t {
+    kHrtimerFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.HrtimerExpireExitFtraceEvent"; }
+
+
+  using FieldMetadata_Hrtimer =
     ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      Mapping>;
+      HrtimerExpireExitFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PathStringIds kPathStringIds() { return {}; }
-  void add_path_string_ids(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PathStringIds::kFieldId;
+  static constexpr FieldMetadata_Hrtimer kHrtimer{};
+  void set_hrtimer(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Hrtimer::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -136943,286 +160350,235 @@ class Mapping : public ::protozero::Message {
   }
 };
 
-class ModuleSymbols_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class HrtimerExpireEntryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  ModuleSymbols_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ModuleSymbols_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ModuleSymbols_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_path() const { return at<1>().valid(); }
-  ::protozero::ConstChars path() const { return at<1>().as_string(); }
-  bool has_build_id() const { return at<2>().valid(); }
-  ::protozero::ConstChars build_id() const { return at<2>().as_string(); }
-  bool has_address_symbols() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> address_symbols() const { return GetRepeated<::protozero::ConstBytes>(3); }
+  HrtimerExpireEntryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HrtimerExpireEntryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HrtimerExpireEntryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_hrtimer() const { return at<1>().valid(); }
+  uint64_t hrtimer() const { return at<1>().as_uint64(); }
+  bool has_now() const { return at<2>().valid(); }
+  int64_t now() const { return at<2>().as_int64(); }
+  bool has_function() const { return at<3>().valid(); }
+  uint64_t function() const { return at<3>().as_uint64(); }
 };
 
-class ModuleSymbols : public ::protozero::Message {
+class HrtimerExpireEntryFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = ModuleSymbols_Decoder;
+  using Decoder = HrtimerExpireEntryFtraceEvent_Decoder;
   enum : int32_t {
-    kPathFieldNumber = 1,
-    kBuildIdFieldNumber = 2,
-    kAddressSymbolsFieldNumber = 3,
+    kHrtimerFieldNumber = 1,
+    kNowFieldNumber = 2,
+    kFunctionFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ModuleSymbols"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.HrtimerExpireEntryFtraceEvent"; }
 
 
-  using FieldMetadata_Path =
+  using FieldMetadata_Hrtimer =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ModuleSymbols>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HrtimerExpireEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Path kPath() { return {}; }
-  void set_path(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Path::kFieldId, data, size);
-  }
-  void set_path(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Path::kFieldId, chars.data, chars.size);
-  }
-  void set_path(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Path::kFieldId;
+  static constexpr FieldMetadata_Hrtimer kHrtimer{};
+  void set_hrtimer(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Hrtimer::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BuildId =
+  using FieldMetadata_Now =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ModuleSymbols>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      HrtimerExpireEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BuildId kBuildId() { return {}; }
-  void set_build_id(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_BuildId::kFieldId, data, size);
-  }
-  void set_build_id(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_BuildId::kFieldId, chars.data, chars.size);
-  }
-  void set_build_id(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_BuildId::kFieldId;
+  static constexpr FieldMetadata_Now kNow{};
+  void set_now(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Now::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_AddressSymbols =
+  using FieldMetadata_Function =
     ::protozero::proto_utils::FieldMetadata<
       3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AddressSymbols,
-      ModuleSymbols>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HrtimerExpireEntryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AddressSymbols kAddressSymbols() { return {}; }
-  template <typename T = AddressSymbols> T* add_address_symbols() {
-    return BeginNestedMessage<T>(3);
+  static constexpr FieldMetadata_Function kFunction{};
+  void set_function(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Function::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
-
 };
 
-class AddressSymbols_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class HrtimerCancelFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  AddressSymbols_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AddressSymbols_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AddressSymbols_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_address() const { return at<1>().valid(); }
-  uint64_t address() const { return at<1>().as_uint64(); }
-  bool has_lines() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> lines() const { return GetRepeated<::protozero::ConstBytes>(2); }
+  HrtimerCancelFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HrtimerCancelFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HrtimerCancelFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_hrtimer() const { return at<1>().valid(); }
+  uint64_t hrtimer() const { return at<1>().as_uint64(); }
 };
 
-class AddressSymbols : public ::protozero::Message {
+class HrtimerCancelFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = AddressSymbols_Decoder;
+  using Decoder = HrtimerCancelFtraceEvent_Decoder;
   enum : int32_t {
-    kAddressFieldNumber = 1,
-    kLinesFieldNumber = 2,
+    kHrtimerFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.AddressSymbols"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.HrtimerCancelFtraceEvent"; }
 
 
-  using FieldMetadata_Address =
+  using FieldMetadata_Hrtimer =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      AddressSymbols>;
+      HrtimerCancelFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Address kAddress() { return {}; }
-  void set_address(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Address::kFieldId;
+  static constexpr FieldMetadata_Hrtimer kHrtimer{};
+  void set_hrtimer(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Hrtimer::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-
-  using FieldMetadata_Lines =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      Line,
-      AddressSymbols>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Lines kLines() { return {}; }
-  template <typename T = Line> T* add_lines() {
-    return BeginNestedMessage<T>(2);
-  }
-
 };
 
-class Line_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class HrtimerStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  Line_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Line_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Line_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_function_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars function_name() const { return at<1>().as_string(); }
-  bool has_source_file_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars source_file_name() const { return at<2>().as_string(); }
-  bool has_line_number() const { return at<3>().valid(); }
-  uint32_t line_number() const { return at<3>().as_uint32(); }
+  HrtimerStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HrtimerStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HrtimerStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_hrtimer() const { return at<1>().valid(); }
+  uint64_t hrtimer() const { return at<1>().as_uint64(); }
+  bool has_function() const { return at<2>().valid(); }
+  uint64_t function() const { return at<2>().as_uint64(); }
+  bool has_expires() const { return at<3>().valid(); }
+  int64_t expires() const { return at<3>().as_int64(); }
+  bool has_softexpires() const { return at<4>().valid(); }
+  int64_t softexpires() const { return at<4>().as_int64(); }
+  bool has_mode() const { return at<5>().valid(); }
+  uint32_t mode() const { return at<5>().as_uint32(); }
 };
 
-class Line : public ::protozero::Message {
+class HrtimerStartFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = Line_Decoder;
+  using Decoder = HrtimerStartFtraceEvent_Decoder;
   enum : int32_t {
-    kFunctionNameFieldNumber = 1,
-    kSourceFileNameFieldNumber = 2,
-    kLineNumberFieldNumber = 3,
+    kHrtimerFieldNumber = 1,
+    kFunctionFieldNumber = 2,
+    kExpiresFieldNumber = 3,
+    kSoftexpiresFieldNumber = 4,
+    kModeFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Line"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.HrtimerStartFtraceEvent"; }
 
 
-  using FieldMetadata_FunctionName =
+  using FieldMetadata_Hrtimer =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      Line>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HrtimerStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FunctionName kFunctionName() { return {}; }
-  void set_function_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_FunctionName::kFieldId, data, size);
-  }
-  void set_function_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_FunctionName::kFieldId, chars.data, chars.size);
-  }
-  void set_function_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_FunctionName::kFieldId;
+  static constexpr FieldMetadata_Hrtimer kHrtimer{};
+  void set_hrtimer(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Hrtimer::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SourceFileName =
+  using FieldMetadata_Function =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      Line>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HrtimerStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SourceFileName kSourceFileName() { return {}; }
-  void set_source_file_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_SourceFileName::kFieldId, data, size);
+  static constexpr FieldMetadata_Function kFunction{};
+  void set_function(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Function::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
-  void set_source_file_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_SourceFileName::kFieldId, chars.data, chars.size);
+
+  using FieldMetadata_Expires =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      HrtimerStartFtraceEvent>;
+
+  static constexpr FieldMetadata_Expires kExpires{};
+  void set_expires(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Expires::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
   }
-  void set_source_file_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_SourceFileName::kFieldId;
+
+  using FieldMetadata_Softexpires =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      HrtimerStartFtraceEvent>;
+
+  static constexpr FieldMetadata_Softexpires kSoftexpires{};
+  void set_softexpires(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Softexpires::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_LineNumber =
+  using FieldMetadata_Mode =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      Line>;
+      HrtimerStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LineNumber kLineNumber() { return {}; }
-  void set_line_number(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LineNumber::kFieldId;
+  static constexpr FieldMetadata_Mode kMode{};
+  void set_mode(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -137231,126 +160587,101 @@ class Line : public ::protozero::Message {
   }
 };
 
-class ProfiledFrameSymbols_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/trusty.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_TRUSTY_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_TRUSTY_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class TrustyEnqueueNopFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  ProfiledFrameSymbols_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ProfiledFrameSymbols_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ProfiledFrameSymbols_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_frame_iid() const { return at<1>().valid(); }
-  uint64_t frame_iid() const { return at<1>().as_uint64(); }
-  bool has_function_name_id() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> function_name_id() const { return GetRepeated<uint64_t>(2); }
-  bool has_file_name_id() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> file_name_id() const { return GetRepeated<uint64_t>(3); }
-  bool has_line_number() const { return at<4>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint32_t> line_number() const { return GetRepeated<uint32_t>(4); }
+  TrustyEnqueueNopFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TrustyEnqueueNopFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TrustyEnqueueNopFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_arg1() const { return at<1>().valid(); }
+  uint32_t arg1() const { return at<1>().as_uint32(); }
+  bool has_arg2() const { return at<2>().valid(); }
+  uint32_t arg2() const { return at<2>().as_uint32(); }
+  bool has_arg3() const { return at<3>().valid(); }
+  uint32_t arg3() const { return at<3>().as_uint32(); }
 };
 
-class ProfiledFrameSymbols : public ::protozero::Message {
+class TrustyEnqueueNopFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = ProfiledFrameSymbols_Decoder;
+  using Decoder = TrustyEnqueueNopFtraceEvent_Decoder;
   enum : int32_t {
-    kFrameIidFieldNumber = 1,
-    kFunctionNameIdFieldNumber = 2,
-    kFileNameIdFieldNumber = 3,
-    kLineNumberFieldNumber = 4,
+    kArg1FieldNumber = 1,
+    kArg2FieldNumber = 2,
+    kArg3FieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ProfiledFrameSymbols"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.TrustyEnqueueNopFtraceEvent"; }
 
 
-  using FieldMetadata_FrameIid =
+  using FieldMetadata_Arg1 =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProfiledFrameSymbols>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TrustyEnqueueNopFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FrameIid kFrameIid() { return {}; }
-  void set_frame_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FrameIid::kFieldId;
+  static constexpr FieldMetadata_Arg1 kArg1{};
+  void set_arg1(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Arg1::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FunctionNameId =
+  using FieldMetadata_Arg2 =
     ::protozero::proto_utils::FieldMetadata<
       2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProfiledFrameSymbols>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TrustyEnqueueNopFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FunctionNameId kFunctionNameId() { return {}; }
-  void add_function_name_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FunctionNameId::kFieldId;
+  static constexpr FieldMetadata_Arg2 kArg2{};
+  void set_arg2(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Arg2::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FileNameId =
+  using FieldMetadata_Arg3 =
     ::protozero::proto_utils::FieldMetadata<
       3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProfiledFrameSymbols>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FileNameId kFileNameId() { return {}; }
-  void add_file_name_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FileNameId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_LineNumber =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      ProfiledFrameSymbols>;
+      TrustyEnqueueNopFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LineNumber kLineNumber() { return {}; }
-  void add_line_number(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LineNumber::kFieldId;
+  static constexpr FieldMetadata_Arg3 kArg3{};
+  void set_arg3(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Arg3::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -137359,45 +160690,41 @@ class ProfiledFrameSymbols : public ::protozero::Message {
   }
 };
 
-class InternedString_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class TrustyIpcRxFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  InternedString_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit InternedString_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit InternedString_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_iid() const { return at<1>().valid(); }
-  uint64_t iid() const { return at<1>().as_uint64(); }
-  bool has_str() const { return at<2>().valid(); }
-  ::protozero::ConstBytes str() const { return at<2>().as_bytes(); }
+  TrustyIpcRxFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TrustyIpcRxFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TrustyIpcRxFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_buf_id() const { return at<1>().valid(); }
+  uint64_t buf_id() const { return at<1>().as_uint64(); }
+  bool has_chan() const { return at<2>().valid(); }
+  uint32_t chan() const { return at<2>().as_uint32(); }
+  bool has_srv_name() const { return at<3>().valid(); }
+  ::protozero::ConstChars srv_name() const { return at<3>().as_string(); }
 };
 
-class InternedString : public ::protozero::Message {
+class TrustyIpcRxFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = InternedString_Decoder;
+  using Decoder = TrustyIpcRxFtraceEvent_Decoder;
   enum : int32_t {
-    kIidFieldNumber = 1,
-    kStrFieldNumber = 2,
+    kBufIdFieldNumber = 1,
+    kChanFieldNumber = 2,
+    kSrvNameFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.InternedString"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcRxFtraceEvent"; }
 
 
-  using FieldMetadata_Iid =
+  using FieldMetadata_BufId =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      InternedString>;
+      TrustyIpcRxFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Iid kIid() { return {}; }
-  void set_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
+  static constexpr FieldMetadata_BufId kBufId{};
+  void set_buf_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BufId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -137405,365 +160732,293 @@ class InternedString : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Str =
+  using FieldMetadata_Chan =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TrustyIpcRxFtraceEvent>;
+
+  static constexpr FieldMetadata_Chan kChan{};
+  void set_chan(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SrvName =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      InternedString>;
+      TrustyIpcRxFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Str kStr() { return {}; }
-  void set_str(const uint8_t* data, size_t size) {
-    AppendBytes(FieldMetadata_Str::kFieldId, data, size);
+  static constexpr FieldMetadata_SrvName kSrvName{};
+  void set_srv_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_SrvName::kFieldId, data, size);
   }
-  void set_str(::protozero::ConstBytes bytes) {
-    AppendBytes(FieldMetadata_Str::kFieldId, bytes.data, bytes.size);
+  void set_srv_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_SrvName::kFieldId, chars.data, chars.size);
   }
-  void set_str(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Str::kFieldId;
+  void set_srv_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_SrvName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/profiling/profile_packet.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_PROFILE_PACKET_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_PROFILE_PACKET_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-class Callstack;
-class Frame;
-class InternedString;
-class Mapping;
-class PerfEvents_Timebase;
-class PerfSample_ProducerEvent;
-class ProfilePacket_HeapSample;
-class ProfilePacket_Histogram;
-class ProfilePacket_Histogram_Bucket;
-class ProfilePacket_ProcessHeapSamples;
-class ProfilePacket_ProcessStats;
-namespace perfetto_pbzero_enum_PerfSample_ProducerEvent {
-enum DataSourceStopReason : int32_t;
-}  // namespace perfetto_pbzero_enum_PerfSample_ProducerEvent
-using PerfSample_ProducerEvent_DataSourceStopReason = perfetto_pbzero_enum_PerfSample_ProducerEvent::DataSourceStopReason;
-namespace perfetto_pbzero_enum_PerfSample {
-enum SampleSkipReason : int32_t;
-}  // namespace perfetto_pbzero_enum_PerfSample
-using PerfSample_SampleSkipReason = perfetto_pbzero_enum_PerfSample::SampleSkipReason;
-namespace perfetto_pbzero_enum_ProfilePacket_ProcessHeapSamples {
-enum ClientError : int32_t;
-}  // namespace perfetto_pbzero_enum_ProfilePacket_ProcessHeapSamples
-using ProfilePacket_ProcessHeapSamples_ClientError = perfetto_pbzero_enum_ProfilePacket_ProcessHeapSamples::ClientError;
-namespace perfetto_pbzero_enum_Profiling {
-enum CpuMode : int32_t;
-}  // namespace perfetto_pbzero_enum_Profiling
-using Profiling_CpuMode = perfetto_pbzero_enum_Profiling::CpuMode;
-namespace perfetto_pbzero_enum_Profiling {
-enum StackUnwindError : int32_t;
-}  // namespace perfetto_pbzero_enum_Profiling
-using Profiling_StackUnwindError = perfetto_pbzero_enum_Profiling::StackUnwindError;
-
-namespace perfetto_pbzero_enum_PerfSample {
-enum SampleSkipReason : int32_t {
-  PROFILER_SKIP_UNKNOWN = 0,
-  PROFILER_SKIP_READ_STAGE = 1,
-  PROFILER_SKIP_UNWIND_STAGE = 2,
-  PROFILER_SKIP_UNWIND_ENQUEUE = 3,
+class TrustyIpcReadEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  TrustyIpcReadEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TrustyIpcReadEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TrustyIpcReadEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_buf_id() const { return at<1>().valid(); }
+  uint64_t buf_id() const { return at<1>().as_uint64(); }
+  bool has_chan() const { return at<2>().valid(); }
+  uint32_t chan() const { return at<2>().as_uint32(); }
+  bool has_len_or_err() const { return at<3>().valid(); }
+  int32_t len_or_err() const { return at<3>().as_int32(); }
+  bool has_shm_cnt() const { return at<4>().valid(); }
+  uint64_t shm_cnt() const { return at<4>().as_uint64(); }
+  bool has_srv_name() const { return at<5>().valid(); }
+  ::protozero::ConstChars srv_name() const { return at<5>().as_string(); }
 };
-} // namespace perfetto_pbzero_enum_PerfSample
-using PerfSample_SampleSkipReason = perfetto_pbzero_enum_PerfSample::SampleSkipReason;
-
-
-constexpr PerfSample_SampleSkipReason PerfSample_SampleSkipReason_MIN = PerfSample_SampleSkipReason::PROFILER_SKIP_UNKNOWN;
-constexpr PerfSample_SampleSkipReason PerfSample_SampleSkipReason_MAX = PerfSample_SampleSkipReason::PROFILER_SKIP_UNWIND_ENQUEUE;
 
+class TrustyIpcReadEndFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = TrustyIpcReadEndFtraceEvent_Decoder;
+  enum : int32_t {
+    kBufIdFieldNumber = 1,
+    kChanFieldNumber = 2,
+    kLenOrErrFieldNumber = 3,
+    kShmCntFieldNumber = 4,
+    kSrvNameFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcReadEndFtraceEvent"; }
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* PerfSample_SampleSkipReason_Name(::perfetto::protos::pbzero::PerfSample_SampleSkipReason value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::PerfSample_SampleSkipReason::PROFILER_SKIP_UNKNOWN:
-    return "PROFILER_SKIP_UNKNOWN";
-
-  case ::perfetto::protos::pbzero::PerfSample_SampleSkipReason::PROFILER_SKIP_READ_STAGE:
-    return "PROFILER_SKIP_READ_STAGE";
 
-  case ::perfetto::protos::pbzero::PerfSample_SampleSkipReason::PROFILER_SKIP_UNWIND_STAGE:
-    return "PROFILER_SKIP_UNWIND_STAGE";
+  using FieldMetadata_BufId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TrustyIpcReadEndFtraceEvent>;
 
-  case ::perfetto::protos::pbzero::PerfSample_SampleSkipReason::PROFILER_SKIP_UNWIND_ENQUEUE:
-    return "PROFILER_SKIP_UNWIND_ENQUEUE";
+  static constexpr FieldMetadata_BufId kBufId{};
+  void set_buf_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BufId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-namespace perfetto_pbzero_enum_PerfSample_ProducerEvent {
-enum DataSourceStopReason : int32_t {
-  PROFILER_STOP_UNKNOWN = 0,
-  PROFILER_STOP_GUARDRAIL = 1,
-};
-} // namespace perfetto_pbzero_enum_PerfSample_ProducerEvent
-using PerfSample_ProducerEvent_DataSourceStopReason = perfetto_pbzero_enum_PerfSample_ProducerEvent::DataSourceStopReason;
-
-
-constexpr PerfSample_ProducerEvent_DataSourceStopReason PerfSample_ProducerEvent_DataSourceStopReason_MIN = PerfSample_ProducerEvent_DataSourceStopReason::PROFILER_STOP_UNKNOWN;
-constexpr PerfSample_ProducerEvent_DataSourceStopReason PerfSample_ProducerEvent_DataSourceStopReason_MAX = PerfSample_ProducerEvent_DataSourceStopReason::PROFILER_STOP_GUARDRAIL;
-
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* PerfSample_ProducerEvent_DataSourceStopReason_Name(::perfetto::protos::pbzero::PerfSample_ProducerEvent_DataSourceStopReason value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::PerfSample_ProducerEvent_DataSourceStopReason::PROFILER_STOP_UNKNOWN:
-    return "PROFILER_STOP_UNKNOWN";
+  using FieldMetadata_Chan =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TrustyIpcReadEndFtraceEvent>;
 
-  case ::perfetto::protos::pbzero::PerfSample_ProducerEvent_DataSourceStopReason::PROFILER_STOP_GUARDRAIL:
-    return "PROFILER_STOP_GUARDRAIL";
+  static constexpr FieldMetadata_Chan kChan{};
+  void set_chan(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-namespace perfetto_pbzero_enum_Profiling {
-enum CpuMode : int32_t {
-  MODE_UNKNOWN = 0,
-  MODE_KERNEL = 1,
-  MODE_USER = 2,
-  MODE_HYPERVISOR = 3,
-  MODE_GUEST_KERNEL = 4,
-  MODE_GUEST_USER = 5,
-};
-} // namespace perfetto_pbzero_enum_Profiling
-using Profiling_CpuMode = perfetto_pbzero_enum_Profiling::CpuMode;
-
-
-constexpr Profiling_CpuMode Profiling_CpuMode_MIN = Profiling_CpuMode::MODE_UNKNOWN;
-constexpr Profiling_CpuMode Profiling_CpuMode_MAX = Profiling_CpuMode::MODE_GUEST_USER;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* Profiling_CpuMode_Name(::perfetto::protos::pbzero::Profiling_CpuMode value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::Profiling_CpuMode::MODE_UNKNOWN:
-    return "MODE_UNKNOWN";
-
-  case ::perfetto::protos::pbzero::Profiling_CpuMode::MODE_KERNEL:
-    return "MODE_KERNEL";
-
-  case ::perfetto::protos::pbzero::Profiling_CpuMode::MODE_USER:
-    return "MODE_USER";
 
-  case ::perfetto::protos::pbzero::Profiling_CpuMode::MODE_HYPERVISOR:
-    return "MODE_HYPERVISOR";
-
-  case ::perfetto::protos::pbzero::Profiling_CpuMode::MODE_GUEST_KERNEL:
-    return "MODE_GUEST_KERNEL";
+  using FieldMetadata_LenOrErr =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TrustyIpcReadEndFtraceEvent>;
 
-  case ::perfetto::protos::pbzero::Profiling_CpuMode::MODE_GUEST_USER:
-    return "MODE_GUEST_USER";
+  static constexpr FieldMetadata_LenOrErr kLenOrErr{};
+  void set_len_or_err(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LenOrErr::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-namespace perfetto_pbzero_enum_Profiling {
-enum StackUnwindError : int32_t {
-  UNWIND_ERROR_UNKNOWN = 0,
-  UNWIND_ERROR_NONE = 1,
-  UNWIND_ERROR_MEMORY_INVALID = 2,
-  UNWIND_ERROR_UNWIND_INFO = 3,
-  UNWIND_ERROR_UNSUPPORTED = 4,
-  UNWIND_ERROR_INVALID_MAP = 5,
-  UNWIND_ERROR_MAX_FRAMES_EXCEEDED = 6,
-  UNWIND_ERROR_REPEATED_FRAME = 7,
-  UNWIND_ERROR_INVALID_ELF = 8,
-  UNWIND_ERROR_SYSTEM_CALL = 9,
-  UNWIND_ERROR_THREAD_TIMEOUT = 10,
-  UNWIND_ERROR_THREAD_DOES_NOT_EXIST = 11,
-  UNWIND_ERROR_BAD_ARCH = 12,
-  UNWIND_ERROR_MAPS_PARSE = 13,
-  UNWIND_ERROR_INVALID_PARAMETER = 14,
-  UNWIND_ERROR_PTRACE_CALL = 15,
-};
-} // namespace perfetto_pbzero_enum_Profiling
-using Profiling_StackUnwindError = perfetto_pbzero_enum_Profiling::StackUnwindError;
-
-
-constexpr Profiling_StackUnwindError Profiling_StackUnwindError_MIN = Profiling_StackUnwindError::UNWIND_ERROR_UNKNOWN;
-constexpr Profiling_StackUnwindError Profiling_StackUnwindError_MAX = Profiling_StackUnwindError::UNWIND_ERROR_PTRACE_CALL;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* Profiling_StackUnwindError_Name(::perfetto::protos::pbzero::Profiling_StackUnwindError value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_UNKNOWN:
-    return "UNWIND_ERROR_UNKNOWN";
-
-  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_NONE:
-    return "UNWIND_ERROR_NONE";
-
-  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_MEMORY_INVALID:
-    return "UNWIND_ERROR_MEMORY_INVALID";
-
-  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_UNWIND_INFO:
-    return "UNWIND_ERROR_UNWIND_INFO";
-
-  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_UNSUPPORTED:
-    return "UNWIND_ERROR_UNSUPPORTED";
-
-  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_INVALID_MAP:
-    return "UNWIND_ERROR_INVALID_MAP";
-
-  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_MAX_FRAMES_EXCEEDED:
-    return "UNWIND_ERROR_MAX_FRAMES_EXCEEDED";
-
-  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_REPEATED_FRAME:
-    return "UNWIND_ERROR_REPEATED_FRAME";
-
-  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_INVALID_ELF:
-    return "UNWIND_ERROR_INVALID_ELF";
-
-  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_SYSTEM_CALL:
-    return "UNWIND_ERROR_SYSTEM_CALL";
-
-  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_THREAD_TIMEOUT:
-    return "UNWIND_ERROR_THREAD_TIMEOUT";
-
-  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_THREAD_DOES_NOT_EXIST:
-    return "UNWIND_ERROR_THREAD_DOES_NOT_EXIST";
 
-  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_BAD_ARCH:
-    return "UNWIND_ERROR_BAD_ARCH";
+  using FieldMetadata_ShmCnt =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TrustyIpcReadEndFtraceEvent>;
 
-  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_MAPS_PARSE:
-    return "UNWIND_ERROR_MAPS_PARSE";
+  static constexpr FieldMetadata_ShmCnt kShmCnt{};
+  void set_shm_cnt(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ShmCnt::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_INVALID_PARAMETER:
-    return "UNWIND_ERROR_INVALID_PARAMETER";
+  using FieldMetadata_SrvName =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TrustyIpcReadEndFtraceEvent>;
 
-  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_PTRACE_CALL:
-    return "UNWIND_ERROR_PTRACE_CALL";
+  static constexpr FieldMetadata_SrvName kSrvName{};
+  void set_srv_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_SrvName::kFieldId, data, size);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+  void set_srv_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_SrvName::kFieldId, chars.data, chars.size);
+  }
+  void set_srv_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_SrvName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
 
-namespace perfetto_pbzero_enum_ProfilePacket_ProcessHeapSamples {
-enum ClientError : int32_t {
-  CLIENT_ERROR_NONE = 0,
-  CLIENT_ERROR_HIT_TIMEOUT = 1,
-  CLIENT_ERROR_INVALID_STACK_BOUNDS = 2,
+class TrustyIpcReadFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  TrustyIpcReadFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TrustyIpcReadFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TrustyIpcReadFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_chan() const { return at<1>().valid(); }
+  uint32_t chan() const { return at<1>().as_uint32(); }
+  bool has_srv_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars srv_name() const { return at<2>().as_string(); }
 };
-} // namespace perfetto_pbzero_enum_ProfilePacket_ProcessHeapSamples
-using ProfilePacket_ProcessHeapSamples_ClientError = perfetto_pbzero_enum_ProfilePacket_ProcessHeapSamples::ClientError;
 
+class TrustyIpcReadFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = TrustyIpcReadFtraceEvent_Decoder;
+  enum : int32_t {
+    kChanFieldNumber = 1,
+    kSrvNameFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcReadFtraceEvent"; }
 
-constexpr ProfilePacket_ProcessHeapSamples_ClientError ProfilePacket_ProcessHeapSamples_ClientError_MIN = ProfilePacket_ProcessHeapSamples_ClientError::CLIENT_ERROR_NONE;
-constexpr ProfilePacket_ProcessHeapSamples_ClientError ProfilePacket_ProcessHeapSamples_ClientError_MAX = ProfilePacket_ProcessHeapSamples_ClientError::CLIENT_ERROR_INVALID_STACK_BOUNDS;
 
+  using FieldMetadata_Chan =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TrustyIpcReadFtraceEvent>;
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ProfilePacket_ProcessHeapSamples_ClientError_Name(::perfetto::protos::pbzero::ProfilePacket_ProcessHeapSamples_ClientError value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ProfilePacket_ProcessHeapSamples_ClientError::CLIENT_ERROR_NONE:
-    return "CLIENT_ERROR_NONE";
+  static constexpr FieldMetadata_Chan kChan{};
+  void set_chan(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  case ::perfetto::protos::pbzero::ProfilePacket_ProcessHeapSamples_ClientError::CLIENT_ERROR_HIT_TIMEOUT:
-    return "CLIENT_ERROR_HIT_TIMEOUT";
+  using FieldMetadata_SrvName =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TrustyIpcReadFtraceEvent>;
 
-  case ::perfetto::protos::pbzero::ProfilePacket_ProcessHeapSamples_ClientError::CLIENT_ERROR_INVALID_STACK_BOUNDS:
-    return "CLIENT_ERROR_INVALID_STACK_BOUNDS";
+  static constexpr FieldMetadata_SrvName kSrvName{};
+  void set_srv_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_SrvName::kFieldId, data, size);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+  void set_srv_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_SrvName::kFieldId, chars.data, chars.size);
+  }
+  void set_srv_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_SrvName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
 
-class PerfSampleDefaults_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class TrustyIpcPollFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  PerfSampleDefaults_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit PerfSampleDefaults_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit PerfSampleDefaults_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_timebase() const { return at<1>().valid(); }
-  ::protozero::ConstBytes timebase() const { return at<1>().as_bytes(); }
-  bool has_process_shard_count() const { return at<2>().valid(); }
-  uint32_t process_shard_count() const { return at<2>().as_uint32(); }
-  bool has_chosen_process_shard() const { return at<3>().valid(); }
-  uint32_t chosen_process_shard() const { return at<3>().as_uint32(); }
+  TrustyIpcPollFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TrustyIpcPollFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TrustyIpcPollFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_chan() const { return at<1>().valid(); }
+  uint32_t chan() const { return at<1>().as_uint32(); }
+  bool has_poll_mask() const { return at<2>().valid(); }
+  uint32_t poll_mask() const { return at<2>().as_uint32(); }
+  bool has_srv_name() const { return at<3>().valid(); }
+  ::protozero::ConstChars srv_name() const { return at<3>().as_string(); }
 };
 
-class PerfSampleDefaults : public ::protozero::Message {
+class TrustyIpcPollFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = PerfSampleDefaults_Decoder;
+  using Decoder = TrustyIpcPollFtraceEvent_Decoder;
   enum : int32_t {
-    kTimebaseFieldNumber = 1,
-    kProcessShardCountFieldNumber = 2,
-    kChosenProcessShardFieldNumber = 3,
+    kChanFieldNumber = 1,
+    kPollMaskFieldNumber = 2,
+    kSrvNameFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.PerfSampleDefaults"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcPollFtraceEvent"; }
 
 
-  using FieldMetadata_Timebase =
+  using FieldMetadata_Chan =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      PerfEvents_Timebase,
-      PerfSampleDefaults>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TrustyIpcPollFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timebase kTimebase() { return {}; }
-  template <typename T = PerfEvents_Timebase> T* set_timebase() {
-    return BeginNestedMessage<T>(1);
+  static constexpr FieldMetadata_Chan kChan{};
+  void set_chan(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_ProcessShardCount =
+  using FieldMetadata_PollMask =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      PerfSampleDefaults>;
+      TrustyIpcPollFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessShardCount kProcessShardCount() { return {}; }
-  void set_process_shard_count(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProcessShardCount::kFieldId;
+  static constexpr FieldMetadata_PollMask kPollMask{};
+  void set_poll_mask(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PollMask::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -137771,130 +161026,93 @@ class PerfSampleDefaults : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ChosenProcessShard =
+  using FieldMetadata_SrvName =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      PerfSampleDefaults>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TrustyIpcPollFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChosenProcessShard kChosenProcessShard() { return {}; }
-  void set_chosen_process_shard(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ChosenProcessShard::kFieldId;
+  static constexpr FieldMetadata_SrvName kSrvName{};
+  void set_srv_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_SrvName::kFieldId, data, size);
+  }
+  void set_srv_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_SrvName::kFieldId, chars.data, chars.size);
+  }
+  void set_srv_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_SrvName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 };
 
-class PerfSample_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/19, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class TrustyIpcWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  PerfSample_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit PerfSample_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit PerfSample_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_cpu() const { return at<1>().valid(); }
-  uint32_t cpu() const { return at<1>().as_uint32(); }
-  bool has_pid() const { return at<2>().valid(); }
-  uint32_t pid() const { return at<2>().as_uint32(); }
-  bool has_tid() const { return at<3>().valid(); }
-  uint32_t tid() const { return at<3>().as_uint32(); }
-  bool has_cpu_mode() const { return at<5>().valid(); }
-  int32_t cpu_mode() const { return at<5>().as_int32(); }
-  bool has_timebase_count() const { return at<6>().valid(); }
-  uint64_t timebase_count() const { return at<6>().as_uint64(); }
-  bool has_callstack_iid() const { return at<4>().valid(); }
-  uint64_t callstack_iid() const { return at<4>().as_uint64(); }
-  bool has_unwind_error() const { return at<16>().valid(); }
-  int32_t unwind_error() const { return at<16>().as_int32(); }
-  bool has_kernel_records_lost() const { return at<17>().valid(); }
-  uint64_t kernel_records_lost() const { return at<17>().as_uint64(); }
-  bool has_sample_skipped_reason() const { return at<18>().valid(); }
-  int32_t sample_skipped_reason() const { return at<18>().as_int32(); }
-  bool has_producer_event() const { return at<19>().valid(); }
-  ::protozero::ConstBytes producer_event() const { return at<19>().as_bytes(); }
+  TrustyIpcWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TrustyIpcWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TrustyIpcWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_buf_id() const { return at<1>().valid(); }
+  uint64_t buf_id() const { return at<1>().as_uint64(); }
+  bool has_chan() const { return at<2>().valid(); }
+  uint32_t chan() const { return at<2>().as_uint32(); }
+  bool has_kind_shm() const { return at<3>().valid(); }
+  int32_t kind_shm() const { return at<3>().as_int32(); }
+  bool has_len_or_err() const { return at<4>().valid(); }
+  int32_t len_or_err() const { return at<4>().as_int32(); }
+  bool has_shm_cnt() const { return at<5>().valid(); }
+  uint64_t shm_cnt() const { return at<5>().as_uint64(); }
+  bool has_srv_name() const { return at<6>().valid(); }
+  ::protozero::ConstChars srv_name() const { return at<6>().as_string(); }
 };
 
-class PerfSample : public ::protozero::Message {
+class TrustyIpcWriteFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = PerfSample_Decoder;
+  using Decoder = TrustyIpcWriteFtraceEvent_Decoder;
   enum : int32_t {
-    kCpuFieldNumber = 1,
-    kPidFieldNumber = 2,
-    kTidFieldNumber = 3,
-    kCpuModeFieldNumber = 5,
-    kTimebaseCountFieldNumber = 6,
-    kCallstackIidFieldNumber = 4,
-    kUnwindErrorFieldNumber = 16,
-    kKernelRecordsLostFieldNumber = 17,
-    kSampleSkippedReasonFieldNumber = 18,
-    kProducerEventFieldNumber = 19,
+    kBufIdFieldNumber = 1,
+    kChanFieldNumber = 2,
+    kKindShmFieldNumber = 3,
+    kLenOrErrFieldNumber = 4,
+    kShmCntFieldNumber = 5,
+    kSrvNameFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.PerfSample"; }
-
-  using ProducerEvent = ::perfetto::protos::pbzero::PerfSample_ProducerEvent;
+  static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcWriteFtraceEvent"; }
 
-  using SampleSkipReason = ::perfetto::protos::pbzero::PerfSample_SampleSkipReason;
-  static inline const char* SampleSkipReason_Name(SampleSkipReason value) {
-    return ::perfetto::protos::pbzero::PerfSample_SampleSkipReason_Name(value);
-  }
-  static const SampleSkipReason PROFILER_SKIP_UNKNOWN = SampleSkipReason::PROFILER_SKIP_UNKNOWN;
-  static const SampleSkipReason PROFILER_SKIP_READ_STAGE = SampleSkipReason::PROFILER_SKIP_READ_STAGE;
-  static const SampleSkipReason PROFILER_SKIP_UNWIND_STAGE = SampleSkipReason::PROFILER_SKIP_UNWIND_STAGE;
-  static const SampleSkipReason PROFILER_SKIP_UNWIND_ENQUEUE = SampleSkipReason::PROFILER_SKIP_UNWIND_ENQUEUE;
 
-  using FieldMetadata_Cpu =
+  using FieldMetadata_BufId =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      PerfSample>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TrustyIpcWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cpu kCpu() { return {}; }
-  void set_cpu(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId;
+  static constexpr FieldMetadata_BufId kBufId{};
+  void set_buf_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BufId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_Chan =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      PerfSample>;
+      TrustyIpcWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_Chan kChan{};
+  void set_chan(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -137902,74 +161120,53 @@ class PerfSample : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Tid =
+  using FieldMetadata_KindShm =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      PerfSample>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TrustyIpcWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Tid kTid() { return {}; }
-  void set_tid(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId;
+  static constexpr FieldMetadata_KindShm kKindShm{};
+  void set_kind_shm(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KindShm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CpuMode =
+  using FieldMetadata_LenOrErr =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::Profiling_CpuMode,
-      PerfSample>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TrustyIpcWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpuMode kCpuMode() { return {}; }
-  void set_cpu_mode(::perfetto::protos::pbzero::Profiling_CpuMode value) {
-    static constexpr uint32_t field_id = FieldMetadata_CpuMode::kFieldId;
+  static constexpr FieldMetadata_LenOrErr kLenOrErr{};
+  void set_len_or_err(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LenOrErr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimebaseCount =
+  using FieldMetadata_ShmCnt =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      PerfSample>;
+      TrustyIpcWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimebaseCount kTimebaseCount() { return {}; }
-  void set_timebase_count(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimebaseCount::kFieldId;
+  static constexpr FieldMetadata_ShmCnt kShmCnt{};
+  void set_shm_cnt(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ShmCnt::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -137977,317 +161174,309 @@ class PerfSample : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CallstackIid =
+  using FieldMetadata_SrvName =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      PerfSample>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TrustyIpcWriteFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CallstackIid kCallstackIid() { return {}; }
-  void set_callstack_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CallstackIid::kFieldId;
+  static constexpr FieldMetadata_SrvName kSrvName{};
+  void set_srv_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_SrvName::kFieldId, data, size);
+  }
+  void set_srv_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_SrvName::kFieldId, chars.data, chars.size);
+  }
+  void set_srv_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_SrvName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_UnwindError =
+class TrustyIpcConnectEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  TrustyIpcConnectEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TrustyIpcConnectEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TrustyIpcConnectEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_chan() const { return at<1>().valid(); }
+  uint32_t chan() const { return at<1>().as_uint32(); }
+  bool has_err() const { return at<2>().valid(); }
+  int32_t err() const { return at<2>().as_int32(); }
+  bool has_state() const { return at<3>().valid(); }
+  int32_t state() const { return at<3>().as_int32(); }
+};
+
+class TrustyIpcConnectEndFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = TrustyIpcConnectEndFtraceEvent_Decoder;
+  enum : int32_t {
+    kChanFieldNumber = 1,
+    kErrFieldNumber = 2,
+    kStateFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcConnectEndFtraceEvent"; }
+
+
+  using FieldMetadata_Chan =
     ::protozero::proto_utils::FieldMetadata<
-      16,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::Profiling_StackUnwindError,
-      PerfSample>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TrustyIpcConnectEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UnwindError kUnwindError() { return {}; }
-  void set_unwind_error(::perfetto::protos::pbzero::Profiling_StackUnwindError value) {
-    static constexpr uint32_t field_id = FieldMetadata_UnwindError::kFieldId;
+  static constexpr FieldMetadata_Chan kChan{};
+  void set_chan(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_KernelRecordsLost =
+  using FieldMetadata_Err =
     ::protozero::proto_utils::FieldMetadata<
-      17,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      PerfSample>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TrustyIpcConnectEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KernelRecordsLost kKernelRecordsLost() { return {}; }
-  void set_kernel_records_lost(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_KernelRecordsLost::kFieldId;
+  static constexpr FieldMetadata_Err kErr{};
+  void set_err(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Err::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SampleSkippedReason =
+  using FieldMetadata_State =
     ::protozero::proto_utils::FieldMetadata<
-      18,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::PerfSample_SampleSkipReason,
-      PerfSample>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TrustyIpcConnectEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SampleSkippedReason kSampleSkippedReason() { return {}; }
-  void set_sample_skipped_reason(::perfetto::protos::pbzero::PerfSample_SampleSkipReason value) {
-    static constexpr uint32_t field_id = FieldMetadata_SampleSkippedReason::kFieldId;
+  static constexpr FieldMetadata_State kState{};
+  void set_state(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-
-  using FieldMetadata_ProducerEvent =
-    ::protozero::proto_utils::FieldMetadata<
-      19,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      PerfSample_ProducerEvent,
-      PerfSample>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProducerEvent kProducerEvent() { return {}; }
-  template <typename T = PerfSample_ProducerEvent> T* set_producer_event() {
-    return BeginNestedMessage<T>(19);
-  }
-
 };
 
-class PerfSample_ProducerEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class TrustyIpcConnectFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  PerfSample_ProducerEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit PerfSample_ProducerEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit PerfSample_ProducerEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_source_stop_reason() const { return at<1>().valid(); }
-  int32_t source_stop_reason() const { return at<1>().as_int32(); }
+  TrustyIpcConnectFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TrustyIpcConnectFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TrustyIpcConnectFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_chan() const { return at<1>().valid(); }
+  uint32_t chan() const { return at<1>().as_uint32(); }
+  bool has_port() const { return at<2>().valid(); }
+  ::protozero::ConstChars port() const { return at<2>().as_string(); }
+  bool has_state() const { return at<3>().valid(); }
+  int32_t state() const { return at<3>().as_int32(); }
 };
 
-class PerfSample_ProducerEvent : public ::protozero::Message {
+class TrustyIpcConnectFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = PerfSample_ProducerEvent_Decoder;
+  using Decoder = TrustyIpcConnectFtraceEvent_Decoder;
   enum : int32_t {
-    kSourceStopReasonFieldNumber = 1,
+    kChanFieldNumber = 1,
+    kPortFieldNumber = 2,
+    kStateFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.PerfSample.ProducerEvent"; }
-
+  static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcConnectFtraceEvent"; }
 
-  using DataSourceStopReason = ::perfetto::protos::pbzero::PerfSample_ProducerEvent_DataSourceStopReason;
-  static inline const char* DataSourceStopReason_Name(DataSourceStopReason value) {
-    return ::perfetto::protos::pbzero::PerfSample_ProducerEvent_DataSourceStopReason_Name(value);
-  }
-  static const DataSourceStopReason PROFILER_STOP_UNKNOWN = DataSourceStopReason::PROFILER_STOP_UNKNOWN;
-  static const DataSourceStopReason PROFILER_STOP_GUARDRAIL = DataSourceStopReason::PROFILER_STOP_GUARDRAIL;
 
-  using FieldMetadata_SourceStopReason =
+  using FieldMetadata_Chan =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::PerfSample_ProducerEvent_DataSourceStopReason,
-      PerfSample_ProducerEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TrustyIpcConnectFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SourceStopReason kSourceStopReason() { return {}; }
-  void set_source_stop_reason(::perfetto::protos::pbzero::PerfSample_ProducerEvent_DataSourceStopReason value) {
-    static constexpr uint32_t field_id = FieldMetadata_SourceStopReason::kFieldId;
+  static constexpr FieldMetadata_Chan kChan{};
+  void set_chan(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
 
-class Profiling_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  Profiling_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Profiling_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Profiling_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-};
+  using FieldMetadata_Port =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TrustyIpcConnectFtraceEvent>;
 
-class Profiling : public ::protozero::Message {
- public:
-  using Decoder = Profiling_Decoder;
-  static constexpr const char* GetName() { return ".perfetto.protos.Profiling"; }
+  static constexpr FieldMetadata_Port kPort{};
+  void set_port(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Port::kFieldId, data, size);
+  }
+  void set_port(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Port::kFieldId, chars.data, chars.size);
+  }
+  void set_port(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Port::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
+  using FieldMetadata_State =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TrustyIpcConnectFtraceEvent>;
 
-  using CpuMode = ::perfetto::protos::pbzero::Profiling_CpuMode;
-  static inline const char* CpuMode_Name(CpuMode value) {
-    return ::perfetto::protos::pbzero::Profiling_CpuMode_Name(value);
+  static constexpr FieldMetadata_State kState{};
+  void set_state(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
   }
+};
 
-  using StackUnwindError = ::perfetto::protos::pbzero::Profiling_StackUnwindError;
-  static inline const char* StackUnwindError_Name(StackUnwindError value) {
-    return ::perfetto::protos::pbzero::Profiling_StackUnwindError_Name(value);
-  }
-  static const CpuMode MODE_UNKNOWN = CpuMode::MODE_UNKNOWN;
-  static const CpuMode MODE_KERNEL = CpuMode::MODE_KERNEL;
-  static const CpuMode MODE_USER = CpuMode::MODE_USER;
-  static const CpuMode MODE_HYPERVISOR = CpuMode::MODE_HYPERVISOR;
-  static const CpuMode MODE_GUEST_KERNEL = CpuMode::MODE_GUEST_KERNEL;
-  static const CpuMode MODE_GUEST_USER = CpuMode::MODE_GUEST_USER;
-  static const StackUnwindError UNWIND_ERROR_UNKNOWN = StackUnwindError::UNWIND_ERROR_UNKNOWN;
-  static const StackUnwindError UNWIND_ERROR_NONE = StackUnwindError::UNWIND_ERROR_NONE;
-  static const StackUnwindError UNWIND_ERROR_MEMORY_INVALID = StackUnwindError::UNWIND_ERROR_MEMORY_INVALID;
-  static const StackUnwindError UNWIND_ERROR_UNWIND_INFO = StackUnwindError::UNWIND_ERROR_UNWIND_INFO;
-  static const StackUnwindError UNWIND_ERROR_UNSUPPORTED = StackUnwindError::UNWIND_ERROR_UNSUPPORTED;
-  static const StackUnwindError UNWIND_ERROR_INVALID_MAP = StackUnwindError::UNWIND_ERROR_INVALID_MAP;
-  static const StackUnwindError UNWIND_ERROR_MAX_FRAMES_EXCEEDED = StackUnwindError::UNWIND_ERROR_MAX_FRAMES_EXCEEDED;
-  static const StackUnwindError UNWIND_ERROR_REPEATED_FRAME = StackUnwindError::UNWIND_ERROR_REPEATED_FRAME;
-  static const StackUnwindError UNWIND_ERROR_INVALID_ELF = StackUnwindError::UNWIND_ERROR_INVALID_ELF;
-  static const StackUnwindError UNWIND_ERROR_SYSTEM_CALL = StackUnwindError::UNWIND_ERROR_SYSTEM_CALL;
-  static const StackUnwindError UNWIND_ERROR_THREAD_TIMEOUT = StackUnwindError::UNWIND_ERROR_THREAD_TIMEOUT;
-  static const StackUnwindError UNWIND_ERROR_THREAD_DOES_NOT_EXIST = StackUnwindError::UNWIND_ERROR_THREAD_DOES_NOT_EXIST;
-  static const StackUnwindError UNWIND_ERROR_BAD_ARCH = StackUnwindError::UNWIND_ERROR_BAD_ARCH;
-  static const StackUnwindError UNWIND_ERROR_MAPS_PARSE = StackUnwindError::UNWIND_ERROR_MAPS_PARSE;
-  static const StackUnwindError UNWIND_ERROR_INVALID_PARAMETER = StackUnwindError::UNWIND_ERROR_INVALID_PARAMETER;
-  static const StackUnwindError UNWIND_ERROR_PTRACE_CALL = StackUnwindError::UNWIND_ERROR_PTRACE_CALL;
-};
-
-class StreamingProfilePacket_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class TrustyIpcHandleEventFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  StreamingProfilePacket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit StreamingProfilePacket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit StreamingProfilePacket_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_callstack_iid() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> callstack_iid() const { return GetRepeated<uint64_t>(1); }
-  bool has_timestamp_delta_us() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<int64_t> timestamp_delta_us() const { return GetRepeated<int64_t>(2); }
-  bool has_process_priority() const { return at<3>().valid(); }
-  int32_t process_priority() const { return at<3>().as_int32(); }
+  TrustyIpcHandleEventFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TrustyIpcHandleEventFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TrustyIpcHandleEventFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_chan() const { return at<1>().valid(); }
+  uint32_t chan() const { return at<1>().as_uint32(); }
+  bool has_event_id() const { return at<2>().valid(); }
+  uint32_t event_id() const { return at<2>().as_uint32(); }
+  bool has_srv_name() const { return at<3>().valid(); }
+  ::protozero::ConstChars srv_name() const { return at<3>().as_string(); }
 };
 
-class StreamingProfilePacket : public ::protozero::Message {
+class TrustyIpcHandleEventFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = StreamingProfilePacket_Decoder;
+  using Decoder = TrustyIpcHandleEventFtraceEvent_Decoder;
   enum : int32_t {
-    kCallstackIidFieldNumber = 1,
-    kTimestampDeltaUsFieldNumber = 2,
-    kProcessPriorityFieldNumber = 3,
+    kChanFieldNumber = 1,
+    kEventIdFieldNumber = 2,
+    kSrvNameFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.StreamingProfilePacket"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcHandleEventFtraceEvent"; }
 
 
-  using FieldMetadata_CallstackIid =
+  using FieldMetadata_Chan =
     ::protozero::proto_utils::FieldMetadata<
       1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      StreamingProfilePacket>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TrustyIpcHandleEventFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CallstackIid kCallstackIid() { return {}; }
-  void add_callstack_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CallstackIid::kFieldId;
+  static constexpr FieldMetadata_Chan kChan{};
+  void set_chan(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimestampDeltaUs =
+  using FieldMetadata_EventId =
     ::protozero::proto_utils::FieldMetadata<
       2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      StreamingProfilePacket>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TrustyIpcHandleEventFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimestampDeltaUs kTimestampDeltaUs() { return {}; }
-  void add_timestamp_delta_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimestampDeltaUs::kFieldId;
+  static constexpr FieldMetadata_EventId kEventId{};
+  void set_event_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EventId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ProcessPriority =
+  using FieldMetadata_SrvName =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TrustyIpcHandleEventFtraceEvent>;
+
+  static constexpr FieldMetadata_SrvName kSrvName{};
+  void set_srv_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_SrvName::kFieldId, data, size);
+  }
+  void set_srv_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_SrvName::kFieldId, chars.data, chars.size);
+  }
+  void set_srv_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_SrvName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class TrustyIrqFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  TrustyIrqFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TrustyIrqFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TrustyIrqFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_irq() const { return at<1>().valid(); }
+  int32_t irq() const { return at<1>().as_int32(); }
+};
+
+class TrustyIrqFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = TrustyIrqFtraceEvent_Decoder;
+  enum : int32_t {
+    kIrqFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TrustyIrqFtraceEvent"; }
+
+
+  using FieldMetadata_Irq =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      StreamingProfilePacket>;
+      TrustyIrqFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessPriority kProcessPriority() { return {}; }
-  void set_process_priority(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProcessPriority::kFieldId;
+  static constexpr FieldMetadata_Irq kIrq{};
+  void set_irq(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Irq::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -138296,48 +161485,38 @@ class StreamingProfilePacket : public ::protozero::Message {
   }
 };
 
-class StreamingFree_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class TrustyReclaimMemoryDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  StreamingFree_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit StreamingFree_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit StreamingFree_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_address() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> address() const { return GetRepeated<uint64_t>(1); }
-  bool has_heap_id() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint32_t> heap_id() const { return GetRepeated<uint32_t>(2); }
-  bool has_sequence_number() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> sequence_number() const { return GetRepeated<uint64_t>(3); }
+  TrustyReclaimMemoryDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TrustyReclaimMemoryDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TrustyReclaimMemoryDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  uint64_t id() const { return at<1>().as_uint64(); }
+  bool has_ret() const { return at<2>().valid(); }
+  int32_t ret() const { return at<2>().as_int32(); }
 };
 
-class StreamingFree : public ::protozero::Message {
+class TrustyReclaimMemoryDoneFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = StreamingFree_Decoder;
+  using Decoder = TrustyReclaimMemoryDoneFtraceEvent_Decoder;
   enum : int32_t {
-    kAddressFieldNumber = 1,
-    kHeapIdFieldNumber = 2,
-    kSequenceNumberFieldNumber = 3,
+    kIdFieldNumber = 1,
+    kRetFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.StreamingFree"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.TrustyReclaimMemoryDoneFtraceEvent"; }
 
 
-  using FieldMetadata_Address =
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
       1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      StreamingFree>;
+      TrustyReclaimMemoryDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Address kAddress() { return {}; }
-  void add_address(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Address::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -138345,49 +161524,54 @@ class StreamingFree : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_HeapId =
+  using FieldMetadata_Ret =
     ::protozero::proto_utils::FieldMetadata<
       2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      StreamingFree>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TrustyReclaimMemoryDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HeapId kHeapId() { return {}; }
-  void add_heap_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_HeapId::kFieldId;
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_SequenceNumber =
+class TrustyReclaimMemoryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  TrustyReclaimMemoryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TrustyReclaimMemoryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TrustyReclaimMemoryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  uint64_t id() const { return at<1>().as_uint64(); }
+};
+
+class TrustyReclaimMemoryFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = TrustyReclaimMemoryFtraceEvent_Decoder;
+  enum : int32_t {
+    kIdFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TrustyReclaimMemoryFtraceEvent"; }
+
+
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      StreamingFree>;
+      TrustyReclaimMemoryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SequenceNumber kSequenceNumber() { return {}; }
-  void add_sequence_number(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SequenceNumber::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -138396,57 +161580,47 @@ class StreamingFree : public ::protozero::Message {
   }
 };
 
-class StreamingAllocation_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class TrustyShareMemoryDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  StreamingAllocation_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit StreamingAllocation_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit StreamingAllocation_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_address() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> address() const { return GetRepeated<uint64_t>(1); }
-  bool has_size() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> size() const { return GetRepeated<uint64_t>(2); }
-  bool has_sample_size() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> sample_size() const { return GetRepeated<uint64_t>(3); }
-  bool has_clock_monotonic_coarse_timestamp() const { return at<4>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> clock_monotonic_coarse_timestamp() const { return GetRepeated<uint64_t>(4); }
-  bool has_heap_id() const { return at<5>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint32_t> heap_id() const { return GetRepeated<uint32_t>(5); }
-  bool has_sequence_number() const { return at<6>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> sequence_number() const { return GetRepeated<uint64_t>(6); }
+  TrustyShareMemoryDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TrustyShareMemoryDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TrustyShareMemoryDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_handle() const { return at<1>().valid(); }
+  uint64_t handle() const { return at<1>().as_uint64(); }
+  bool has_len() const { return at<2>().valid(); }
+  uint64_t len() const { return at<2>().as_uint64(); }
+  bool has_lend() const { return at<3>().valid(); }
+  uint32_t lend() const { return at<3>().as_uint32(); }
+  bool has_nents() const { return at<4>().valid(); }
+  uint32_t nents() const { return at<4>().as_uint32(); }
+  bool has_ret() const { return at<5>().valid(); }
+  int32_t ret() const { return at<5>().as_int32(); }
 };
 
-class StreamingAllocation : public ::protozero::Message {
+class TrustyShareMemoryDoneFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = StreamingAllocation_Decoder;
+  using Decoder = TrustyShareMemoryDoneFtraceEvent_Decoder;
   enum : int32_t {
-    kAddressFieldNumber = 1,
-    kSizeFieldNumber = 2,
-    kSampleSizeFieldNumber = 3,
-    kClockMonotonicCoarseTimestampFieldNumber = 4,
-    kHeapIdFieldNumber = 5,
-    kSequenceNumberFieldNumber = 6,
+    kHandleFieldNumber = 1,
+    kLenFieldNumber = 2,
+    kLendFieldNumber = 3,
+    kNentsFieldNumber = 4,
+    kRetFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.StreamingAllocation"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.TrustyShareMemoryDoneFtraceEvent"; }
 
 
-  using FieldMetadata_Address =
+  using FieldMetadata_Handle =
     ::protozero::proto_utils::FieldMetadata<
       1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      StreamingAllocation>;
+      TrustyShareMemoryDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Address kAddress() { return {}; }
-  void add_address(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Address::kFieldId;
+  static constexpr FieldMetadata_Handle kHandle{};
+  void set_handle(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Handle::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -138454,24 +161628,17 @@ class StreamingAllocation : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Size =
+  using FieldMetadata_Len =
     ::protozero::proto_utils::FieldMetadata<
       2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      StreamingAllocation>;
+      TrustyShareMemoryDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Size kSize() { return {}; }
-  void add_size(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -138479,49 +161646,96 @@ class StreamingAllocation : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SampleSize =
+  using FieldMetadata_Lend =
     ::protozero::proto_utils::FieldMetadata<
       3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      StreamingAllocation>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TrustyShareMemoryDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SampleSize kSampleSize() { return {}; }
-  void add_sample_size(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SampleSize::kFieldId;
+  static constexpr FieldMetadata_Lend kLend{};
+  void set_lend(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lend::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ClockMonotonicCoarseTimestamp =
+  using FieldMetadata_Nents =
     ::protozero::proto_utils::FieldMetadata<
       4,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TrustyShareMemoryDoneFtraceEvent>;
+
+  static constexpr FieldMetadata_Nents kNents{};
+  void set_nents(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Nents::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ret =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TrustyShareMemoryDoneFtraceEvent>;
+
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class TrustyShareMemoryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  TrustyShareMemoryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TrustyShareMemoryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TrustyShareMemoryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_len() const { return at<1>().valid(); }
+  uint64_t len() const { return at<1>().as_uint64(); }
+  bool has_lend() const { return at<2>().valid(); }
+  uint32_t lend() const { return at<2>().as_uint32(); }
+  bool has_nents() const { return at<3>().valid(); }
+  uint32_t nents() const { return at<3>().as_uint32(); }
+};
+
+class TrustyShareMemoryFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = TrustyShareMemoryFtraceEvent_Decoder;
+  enum : int32_t {
+    kLenFieldNumber = 1,
+    kLendFieldNumber = 2,
+    kNentsFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TrustyShareMemoryFtraceEvent"; }
+
+
+  using FieldMetadata_Len =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      StreamingAllocation>;
+      TrustyShareMemoryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClockMonotonicCoarseTimestamp kClockMonotonicCoarseTimestamp() { return {}; }
-  void add_clock_monotonic_coarse_timestamp(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ClockMonotonicCoarseTimestamp::kFieldId;
+  static constexpr FieldMetadata_Len kLen{};
+  void set_len(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -138529,24 +161743,17 @@ class StreamingAllocation : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_HeapId =
+  using FieldMetadata_Lend =
     ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      StreamingAllocation>;
+      TrustyShareMemoryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HeapId kHeapId() { return {}; }
-  void add_heap_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_HeapId::kFieldId;
+  static constexpr FieldMetadata_Lend kLend{};
+  void set_lend(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lend::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -138554,220 +161761,154 @@ class StreamingAllocation : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SequenceNumber =
+  using FieldMetadata_Nents =
     ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      StreamingAllocation>;
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TrustyShareMemoryFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SequenceNumber kSequenceNumber() { return {}; }
-  void add_sequence_number(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SequenceNumber::kFieldId;
+  static constexpr FieldMetadata_Nents kNents{};
+  void set_nents(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Nents::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class ProfilePacket_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class TrustyStdCall32DoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  ProfilePacket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ProfilePacket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ProfilePacket_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_strings() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> strings() const { return GetRepeated<::protozero::ConstBytes>(1); }
-  bool has_mappings() const { return at<4>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> mappings() const { return GetRepeated<::protozero::ConstBytes>(4); }
-  bool has_frames() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> frames() const { return GetRepeated<::protozero::ConstBytes>(2); }
-  bool has_callstacks() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> callstacks() const { return GetRepeated<::protozero::ConstBytes>(3); }
-  bool has_process_dumps() const { return at<5>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> process_dumps() const { return GetRepeated<::protozero::ConstBytes>(5); }
-  bool has_continued() const { return at<6>().valid(); }
-  bool continued() const { return at<6>().as_bool(); }
-  bool has_index() const { return at<7>().valid(); }
-  uint64_t index() const { return at<7>().as_uint64(); }
+  TrustyStdCall32DoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TrustyStdCall32DoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TrustyStdCall32DoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_ret() const { return at<1>().valid(); }
+  int64_t ret() const { return at<1>().as_int64(); }
 };
 
-class ProfilePacket : public ::protozero::Message {
+class TrustyStdCall32DoneFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = ProfilePacket_Decoder;
+  using Decoder = TrustyStdCall32DoneFtraceEvent_Decoder;
   enum : int32_t {
-    kStringsFieldNumber = 1,
-    kMappingsFieldNumber = 4,
-    kFramesFieldNumber = 2,
-    kCallstacksFieldNumber = 3,
-    kProcessDumpsFieldNumber = 5,
-    kContinuedFieldNumber = 6,
-    kIndexFieldNumber = 7,
+    kRetFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ProfilePacket"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.TrustyStdCall32DoneFtraceEvent"; }
 
-  using HeapSample = ::perfetto::protos::pbzero::ProfilePacket_HeapSample;
-  using Histogram = ::perfetto::protos::pbzero::ProfilePacket_Histogram;
-  using ProcessStats = ::perfetto::protos::pbzero::ProfilePacket_ProcessStats;
-  using ProcessHeapSamples = ::perfetto::protos::pbzero::ProfilePacket_ProcessHeapSamples;
 
-  using FieldMetadata_Strings =
+  using FieldMetadata_Ret =
     ::protozero::proto_utils::FieldMetadata<
       1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      InternedString,
-      ProfilePacket>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Strings kStrings() { return {}; }
-  template <typename T = InternedString> T* add_strings() {
-    return BeginNestedMessage<T>(1);
-  }
-
-
-  using FieldMetadata_Mappings =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      Mapping,
-      ProfilePacket>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      TrustyStdCall32DoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mappings kMappings() { return {}; }
-  template <typename T = Mapping> T* add_mappings() {
-    return BeginNestedMessage<T>(4);
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
   }
+};
 
+class TrustyStdCall32FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  TrustyStdCall32FtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TrustyStdCall32FtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TrustyStdCall32FtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_r0() const { return at<1>().valid(); }
+  uint64_t r0() const { return at<1>().as_uint64(); }
+  bool has_r1() const { return at<2>().valid(); }
+  uint64_t r1() const { return at<2>().as_uint64(); }
+  bool has_r2() const { return at<3>().valid(); }
+  uint64_t r2() const { return at<3>().as_uint64(); }
+  bool has_r3() const { return at<4>().valid(); }
+  uint64_t r3() const { return at<4>().as_uint64(); }
+};
 
-  using FieldMetadata_Frames =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      Frame,
-      ProfilePacket>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Frames kFrames() { return {}; }
-  template <typename T = Frame> T* add_frames() {
-    return BeginNestedMessage<T>(2);
-  }
+class TrustyStdCall32FtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = TrustyStdCall32FtraceEvent_Decoder;
+  enum : int32_t {
+    kR0FieldNumber = 1,
+    kR1FieldNumber = 2,
+    kR2FieldNumber = 3,
+    kR3FieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TrustyStdCall32FtraceEvent"; }
 
 
-  using FieldMetadata_Callstacks =
+  using FieldMetadata_R0 =
     ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      Callstack,
-      ProfilePacket>;
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TrustyStdCall32FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Callstacks kCallstacks() { return {}; }
-  template <typename T = Callstack> T* add_callstacks() {
-    return BeginNestedMessage<T>(3);
+  static constexpr FieldMetadata_R0 kR0{};
+  void set_r0(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_R0::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_ProcessDumps =
+  using FieldMetadata_R1 =
     ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ProfilePacket_ProcessHeapSamples,
-      ProfilePacket>;
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TrustyStdCall32FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessDumps kProcessDumps() { return {}; }
-  template <typename T = ProfilePacket_ProcessHeapSamples> T* add_process_dumps() {
-    return BeginNestedMessage<T>(5);
+  static constexpr FieldMetadata_R1 kR1{};
+  void set_r1(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_R1::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_Continued =
+  using FieldMetadata_R2 =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ProfilePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TrustyStdCall32FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Continued kContinued() { return {}; }
-  void set_continued(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_Continued::kFieldId;
+  static constexpr FieldMetadata_R2 kR2{};
+  void set_r2(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_R2::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Index =
+  using FieldMetadata_R3 =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      ProfilePacket>;
+      TrustyStdCall32FtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Index kIndex() { return {}; }
-  void set_index(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
+  static constexpr FieldMetadata_R3 kR3{};
+  void set_r3(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_R3::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -138776,295 +161917,293 @@ class ProfilePacket : public ::protozero::Message {
   }
 };
 
-class ProfilePacket_ProcessHeapSamples_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/14, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class TrustySmcDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  ProfilePacket_ProcessHeapSamples_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ProfilePacket_ProcessHeapSamples_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ProfilePacket_ProcessHeapSamples_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pid() const { return at<1>().valid(); }
-  uint64_t pid() const { return at<1>().as_uint64(); }
-  bool has_from_startup() const { return at<3>().valid(); }
-  bool from_startup() const { return at<3>().as_bool(); }
-  bool has_rejected_concurrent() const { return at<4>().valid(); }
-  bool rejected_concurrent() const { return at<4>().as_bool(); }
-  bool has_disconnected() const { return at<6>().valid(); }
-  bool disconnected() const { return at<6>().as_bool(); }
-  bool has_buffer_overran() const { return at<7>().valid(); }
-  bool buffer_overran() const { return at<7>().as_bool(); }
-  bool has_client_error() const { return at<14>().valid(); }
-  int32_t client_error() const { return at<14>().as_int32(); }
-  bool has_buffer_corrupted() const { return at<8>().valid(); }
-  bool buffer_corrupted() const { return at<8>().as_bool(); }
-  bool has_hit_guardrail() const { return at<10>().valid(); }
-  bool hit_guardrail() const { return at<10>().as_bool(); }
-  bool has_heap_name() const { return at<11>().valid(); }
-  ::protozero::ConstChars heap_name() const { return at<11>().as_string(); }
-  bool has_sampling_interval_bytes() const { return at<12>().valid(); }
-  uint64_t sampling_interval_bytes() const { return at<12>().as_uint64(); }
-  bool has_orig_sampling_interval_bytes() const { return at<13>().valid(); }
-  uint64_t orig_sampling_interval_bytes() const { return at<13>().as_uint64(); }
-  bool has_timestamp() const { return at<9>().valid(); }
-  uint64_t timestamp() const { return at<9>().as_uint64(); }
-  bool has_stats() const { return at<5>().valid(); }
-  ::protozero::ConstBytes stats() const { return at<5>().as_bytes(); }
-  bool has_samples() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> samples() const { return GetRepeated<::protozero::ConstBytes>(2); }
+  TrustySmcDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TrustySmcDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TrustySmcDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_ret() const { return at<1>().valid(); }
+  uint64_t ret() const { return at<1>().as_uint64(); }
 };
 
-class ProfilePacket_ProcessHeapSamples : public ::protozero::Message {
+class TrustySmcDoneFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = ProfilePacket_ProcessHeapSamples_Decoder;
+  using Decoder = TrustySmcDoneFtraceEvent_Decoder;
   enum : int32_t {
-    kPidFieldNumber = 1,
-    kFromStartupFieldNumber = 3,
-    kRejectedConcurrentFieldNumber = 4,
-    kDisconnectedFieldNumber = 6,
-    kBufferOverranFieldNumber = 7,
-    kClientErrorFieldNumber = 14,
-    kBufferCorruptedFieldNumber = 8,
-    kHitGuardrailFieldNumber = 10,
-    kHeapNameFieldNumber = 11,
-    kSamplingIntervalBytesFieldNumber = 12,
-    kOrigSamplingIntervalBytesFieldNumber = 13,
-    kTimestampFieldNumber = 9,
-    kStatsFieldNumber = 5,
-    kSamplesFieldNumber = 2,
+    kRetFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ProfilePacket.ProcessHeapSamples"; }
-
+  static constexpr const char* GetName() { return ".perfetto.protos.TrustySmcDoneFtraceEvent"; }
 
-  using ClientError = ::perfetto::protos::pbzero::ProfilePacket_ProcessHeapSamples_ClientError;
-  static inline const char* ClientError_Name(ClientError value) {
-    return ::perfetto::protos::pbzero::ProfilePacket_ProcessHeapSamples_ClientError_Name(value);
-  }
-  static const ClientError CLIENT_ERROR_NONE = ClientError::CLIENT_ERROR_NONE;
-  static const ClientError CLIENT_ERROR_HIT_TIMEOUT = ClientError::CLIENT_ERROR_HIT_TIMEOUT;
-  static const ClientError CLIENT_ERROR_INVALID_STACK_BOUNDS = ClientError::CLIENT_ERROR_INVALID_STACK_BOUNDS;
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_Ret =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      ProfilePacket_ProcessHeapSamples>;
+      TrustySmcDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_Ret kRet{};
+  void set_ret(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_FromStartup =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ProfilePacket_ProcessHeapSamples>;
+class TrustySmcFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  TrustySmcFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TrustySmcFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TrustySmcFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_r0() const { return at<1>().valid(); }
+  uint64_t r0() const { return at<1>().as_uint64(); }
+  bool has_r1() const { return at<2>().valid(); }
+  uint64_t r1() const { return at<2>().as_uint64(); }
+  bool has_r2() const { return at<3>().valid(); }
+  uint64_t r2() const { return at<3>().as_uint64(); }
+  bool has_r3() const { return at<4>().valid(); }
+  uint64_t r3() const { return at<4>().as_uint64(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FromStartup kFromStartup() { return {}; }
-  void set_from_startup(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_FromStartup::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+class TrustySmcFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = TrustySmcFtraceEvent_Decoder;
+  enum : int32_t {
+    kR0FieldNumber = 1,
+    kR1FieldNumber = 2,
+    kR2FieldNumber = 3,
+    kR3FieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TrustySmcFtraceEvent"; }
 
-  using FieldMetadata_RejectedConcurrent =
+
+  using FieldMetadata_R0 =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ProfilePacket_ProcessHeapSamples>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TrustySmcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RejectedConcurrent kRejectedConcurrent() { return {}; }
-  void set_rejected_concurrent(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_RejectedConcurrent::kFieldId;
+  static constexpr FieldMetadata_R0 kR0{};
+  void set_r0(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_R0::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Disconnected =
+  using FieldMetadata_R1 =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ProfilePacket_ProcessHeapSamples>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TrustySmcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Disconnected kDisconnected() { return {}; }
-  void set_disconnected(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_Disconnected::kFieldId;
+  static constexpr FieldMetadata_R1 kR1{};
+  void set_r1(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_R1::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BufferOverran =
+  using FieldMetadata_R2 =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ProfilePacket_ProcessHeapSamples>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TrustySmcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BufferOverran kBufferOverran() { return {}; }
-  void set_buffer_overran(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_BufferOverran::kFieldId;
+  static constexpr FieldMetadata_R2 kR2{};
+  void set_r2(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_R2::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ClientError =
+  using FieldMetadata_R3 =
     ::protozero::proto_utils::FieldMetadata<
-      14,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ProfilePacket_ProcessHeapSamples_ClientError,
-      ProfilePacket_ProcessHeapSamples>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TrustySmcFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClientError kClientError() { return {}; }
-  void set_client_error(::perfetto::protos::pbzero::ProfilePacket_ProcessHeapSamples_ClientError value) {
-    static constexpr uint32_t field_id = FieldMetadata_ClientError::kFieldId;
+  static constexpr FieldMetadata_R3 kR3{};
+  void set_r3(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_R3::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_BufferCorrupted =
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/ufs.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_UFS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_UFS_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class UfshcdClkGatingFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  UfshcdClkGatingFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit UfshcdClkGatingFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit UfshcdClkGatingFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars dev_name() const { return at<1>().as_string(); }
+  bool has_state() const { return at<2>().valid(); }
+  int32_t state() const { return at<2>().as_int32(); }
+};
+
+class UfshcdClkGatingFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = UfshcdClkGatingFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevNameFieldNumber = 1,
+    kStateFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.UfshcdClkGatingFtraceEvent"; }
+
+
+  using FieldMetadata_DevName =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ProfilePacket_ProcessHeapSamples>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      UfshcdClkGatingFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BufferCorrupted kBufferCorrupted() { return {}; }
-  void set_buffer_corrupted(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_BufferCorrupted::kFieldId;
+  static constexpr FieldMetadata_DevName kDevName{};
+  void set_dev_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_DevName::kFieldId, data, size);
+  }
+  void set_dev_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_DevName::kFieldId, chars.data, chars.size);
+  }
+  void set_dev_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_DevName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_HitGuardrail =
+  using FieldMetadata_State =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ProfilePacket_ProcessHeapSamples>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      UfshcdClkGatingFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HitGuardrail kHitGuardrail() { return {}; }
-  void set_hit_guardrail(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_HitGuardrail::kFieldId;
+  static constexpr FieldMetadata_State kState{};
+  void set_state(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_HeapName =
+class UfshcdCommandFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10> {
+ public:
+  UfshcdCommandFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit UfshcdCommandFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit UfshcdCommandFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dev_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars dev_name() const { return at<1>().as_string(); }
+  bool has_doorbell() const { return at<2>().valid(); }
+  uint32_t doorbell() const { return at<2>().as_uint32(); }
+  bool has_intr() const { return at<3>().valid(); }
+  uint32_t intr() const { return at<3>().as_uint32(); }
+  bool has_lba() const { return at<4>().valid(); }
+  uint64_t lba() const { return at<4>().as_uint64(); }
+  bool has_opcode() const { return at<5>().valid(); }
+  uint32_t opcode() const { return at<5>().as_uint32(); }
+  bool has_str() const { return at<6>().valid(); }
+  ::protozero::ConstChars str() const { return at<6>().as_string(); }
+  bool has_tag() const { return at<7>().valid(); }
+  uint32_t tag() const { return at<7>().as_uint32(); }
+  bool has_transfer_len() const { return at<8>().valid(); }
+  int32_t transfer_len() const { return at<8>().as_int32(); }
+  bool has_group_id() const { return at<9>().valid(); }
+  uint32_t group_id() const { return at<9>().as_uint32(); }
+  bool has_str_t() const { return at<10>().valid(); }
+  uint32_t str_t() const { return at<10>().as_uint32(); }
+};
+
+class UfshcdCommandFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = UfshcdCommandFtraceEvent_Decoder;
+  enum : int32_t {
+    kDevNameFieldNumber = 1,
+    kDoorbellFieldNumber = 2,
+    kIntrFieldNumber = 3,
+    kLbaFieldNumber = 4,
+    kOpcodeFieldNumber = 5,
+    kStrFieldNumber = 6,
+    kTagFieldNumber = 7,
+    kTransferLenFieldNumber = 8,
+    kGroupIdFieldNumber = 9,
+    kStrTFieldNumber = 10,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.UfshcdCommandFtraceEvent"; }
+
+
+  using FieldMetadata_DevName =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      ProfilePacket_ProcessHeapSamples>;
+      UfshcdCommandFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HeapName kHeapName() { return {}; }
-  void set_heap_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_HeapName::kFieldId, data, size);
+  static constexpr FieldMetadata_DevName kDevName{};
+  void set_dev_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_DevName::kFieldId, data, size);
   }
-  void set_heap_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size);
+  void set_dev_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_DevName::kFieldId, chars.data, chars.size);
   }
-  void set_heap_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId;
+  void set_dev_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_DevName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -139072,74 +162211,53 @@ class ProfilePacket_ProcessHeapSamples : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SamplingIntervalBytes =
+  using FieldMetadata_Doorbell =
     ::protozero::proto_utils::FieldMetadata<
-      12,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProfilePacket_ProcessHeapSamples>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      UfshcdCommandFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SamplingIntervalBytes kSamplingIntervalBytes() { return {}; }
-  void set_sampling_interval_bytes(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SamplingIntervalBytes::kFieldId;
+  static constexpr FieldMetadata_Doorbell kDoorbell{};
+  void set_doorbell(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Doorbell::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_OrigSamplingIntervalBytes =
+  using FieldMetadata_Intr =
     ::protozero::proto_utils::FieldMetadata<
-      13,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProfilePacket_ProcessHeapSamples>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      UfshcdCommandFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OrigSamplingIntervalBytes kOrigSamplingIntervalBytes() { return {}; }
-  void set_orig_sampling_interval_bytes(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OrigSamplingIntervalBytes::kFieldId;
+  static constexpr FieldMetadata_Intr kIntr{};
+  void set_intr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Intr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Timestamp =
+  using FieldMetadata_Lba =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      ProfilePacket_ProcessHeapSamples>;
+      UfshcdCommandFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timestamp kTimestamp() { return {}; }
-  void set_timestamp(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+  static constexpr FieldMetadata_Lba kLba{};
+  void set_lba(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Lba::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -139147,674 +162265,450 @@ class ProfilePacket_ProcessHeapSamples : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Stats =
+  using FieldMetadata_Opcode =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ProfilePacket_ProcessStats,
-      ProfilePacket_ProcessHeapSamples>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Stats kStats() { return {}; }
-  template <typename T = ProfilePacket_ProcessStats> T* set_stats() {
-    return BeginNestedMessage<T>(5);
-  }
-
-
-  using FieldMetadata_Samples =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ProfilePacket_HeapSample,
-      ProfilePacket_ProcessHeapSamples>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Samples kSamples() { return {}; }
-  template <typename T = ProfilePacket_HeapSample> T* add_samples() {
-    return BeginNestedMessage<T>(2);
-  }
-
-};
-
-class ProfilePacket_ProcessStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  ProfilePacket_ProcessStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ProfilePacket_ProcessStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ProfilePacket_ProcessStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_unwinding_errors() const { return at<1>().valid(); }
-  uint64_t unwinding_errors() const { return at<1>().as_uint64(); }
-  bool has_heap_samples() const { return at<2>().valid(); }
-  uint64_t heap_samples() const { return at<2>().as_uint64(); }
-  bool has_map_reparses() const { return at<3>().valid(); }
-  uint64_t map_reparses() const { return at<3>().as_uint64(); }
-  bool has_unwinding_time_us() const { return at<4>().valid(); }
-  ::protozero::ConstBytes unwinding_time_us() const { return at<4>().as_bytes(); }
-  bool has_total_unwinding_time_us() const { return at<5>().valid(); }
-  uint64_t total_unwinding_time_us() const { return at<5>().as_uint64(); }
-  bool has_client_spinlock_blocked_us() const { return at<6>().valid(); }
-  uint64_t client_spinlock_blocked_us() const { return at<6>().as_uint64(); }
-};
-
-class ProfilePacket_ProcessStats : public ::protozero::Message {
- public:
-  using Decoder = ProfilePacket_ProcessStats_Decoder;
-  enum : int32_t {
-    kUnwindingErrorsFieldNumber = 1,
-    kHeapSamplesFieldNumber = 2,
-    kMapReparsesFieldNumber = 3,
-    kUnwindingTimeUsFieldNumber = 4,
-    kTotalUnwindingTimeUsFieldNumber = 5,
-    kClientSpinlockBlockedUsFieldNumber = 6,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ProfilePacket.ProcessStats"; }
-
-
-  using FieldMetadata_UnwindingErrors =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProfilePacket_ProcessStats>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      UfshcdCommandFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UnwindingErrors kUnwindingErrors() { return {}; }
-  void set_unwinding_errors(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_UnwindingErrors::kFieldId;
+  static constexpr FieldMetadata_Opcode kOpcode{};
+  void set_opcode(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Opcode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_HeapSamples =
+  using FieldMetadata_Str =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProfilePacket_ProcessStats>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      UfshcdCommandFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HeapSamples kHeapSamples() { return {}; }
-  void set_heap_samples(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_HeapSamples::kFieldId;
+  static constexpr FieldMetadata_Str kStr{};
+  void set_str(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Str::kFieldId, data, size);
+  }
+  void set_str(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Str::kFieldId, chars.data, chars.size);
+  }
+  void set_str(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Str::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MapReparses =
+  using FieldMetadata_Tag =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProfilePacket_ProcessStats>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      UfshcdCommandFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MapReparses kMapReparses() { return {}; }
-  void set_map_reparses(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MapReparses::kFieldId;
+  static constexpr FieldMetadata_Tag kTag{};
+  void set_tag(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tag::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_UnwindingTimeUs =
+  using FieldMetadata_TransferLen =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ProfilePacket_Histogram,
-      ProfilePacket_ProcessStats>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      UfshcdCommandFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UnwindingTimeUs kUnwindingTimeUs() { return {}; }
-  template <typename T = ProfilePacket_Histogram> T* set_unwinding_time_us() {
-    return BeginNestedMessage<T>(4);
+  static constexpr FieldMetadata_TransferLen kTransferLen{};
+  void set_transfer_len(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TransferLen::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_TotalUnwindingTimeUs =
+  using FieldMetadata_GroupId =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProfilePacket_ProcessStats>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      UfshcdCommandFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TotalUnwindingTimeUs kTotalUnwindingTimeUs() { return {}; }
-  void set_total_unwinding_time_us(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TotalUnwindingTimeUs::kFieldId;
+  static constexpr FieldMetadata_GroupId kGroupId{};
+  void set_group_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GroupId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ClientSpinlockBlockedUs =
+  using FieldMetadata_StrT =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProfilePacket_ProcessStats>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      UfshcdCommandFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClientSpinlockBlockedUs kClientSpinlockBlockedUs() { return {}; }
-  void set_client_spinlock_blocked_us(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ClientSpinlockBlockedUs::kFieldId;
+  static constexpr FieldMetadata_StrT kStrT{};
+  void set_str_t(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StrT::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class ProfilePacket_Histogram_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  ProfilePacket_Histogram_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ProfilePacket_Histogram_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ProfilePacket_Histogram_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_buckets() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> buckets() const { return GetRepeated<::protozero::ConstBytes>(1); }
-};
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/v4l2.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-class ProfilePacket_Histogram : public ::protozero::Message {
- public:
-  using Decoder = ProfilePacket_Histogram_Decoder;
-  enum : int32_t {
-    kBucketsFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ProfilePacket.Histogram"; }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_V4L2_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_V4L2_PROTO_H_
 
-  using Bucket = ::perfetto::protos::pbzero::ProfilePacket_Histogram_Bucket;
+#include <stddef.h>
+#include <stdint.h>
 
-  using FieldMetadata_Buckets =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ProfilePacket_Histogram_Bucket,
-      ProfilePacket_Histogram>;
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Buckets kBuckets() { return {}; }
-  template <typename T = ProfilePacket_Histogram_Bucket> T* add_buckets() {
-    return BeginNestedMessage<T>(1);
-  }
 
-};
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-class ProfilePacket_Histogram_Bucket_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Vb2V4l2DqbufFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/15> {
  public:
-  ProfilePacket_Histogram_Bucket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ProfilePacket_Histogram_Bucket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ProfilePacket_Histogram_Bucket_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_upper_limit() const { return at<1>().valid(); }
-  uint64_t upper_limit() const { return at<1>().as_uint64(); }
-  bool has_max_bucket() const { return at<2>().valid(); }
-  bool max_bucket() const { return at<2>().as_bool(); }
-  bool has_count() const { return at<3>().valid(); }
-  uint64_t count() const { return at<3>().as_uint64(); }
+  Vb2V4l2DqbufFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Vb2V4l2DqbufFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Vb2V4l2DqbufFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_field() const { return at<1>().valid(); }
+  uint32_t field() const { return at<1>().as_uint32(); }
+  bool has_flags() const { return at<2>().valid(); }
+  uint32_t flags() const { return at<2>().as_uint32(); }
+  bool has_minor() const { return at<3>().valid(); }
+  int32_t minor() const { return at<3>().as_int32(); }
+  bool has_sequence() const { return at<4>().valid(); }
+  uint32_t sequence() const { return at<4>().as_uint32(); }
+  bool has_timecode_flags() const { return at<5>().valid(); }
+  uint32_t timecode_flags() const { return at<5>().as_uint32(); }
+  bool has_timecode_frames() const { return at<6>().valid(); }
+  uint32_t timecode_frames() const { return at<6>().as_uint32(); }
+  bool has_timecode_hours() const { return at<7>().valid(); }
+  uint32_t timecode_hours() const { return at<7>().as_uint32(); }
+  bool has_timecode_minutes() const { return at<8>().valid(); }
+  uint32_t timecode_minutes() const { return at<8>().as_uint32(); }
+  bool has_timecode_seconds() const { return at<9>().valid(); }
+  uint32_t timecode_seconds() const { return at<9>().as_uint32(); }
+  bool has_timecode_type() const { return at<10>().valid(); }
+  uint32_t timecode_type() const { return at<10>().as_uint32(); }
+  bool has_timecode_userbits0() const { return at<11>().valid(); }
+  uint32_t timecode_userbits0() const { return at<11>().as_uint32(); }
+  bool has_timecode_userbits1() const { return at<12>().valid(); }
+  uint32_t timecode_userbits1() const { return at<12>().as_uint32(); }
+  bool has_timecode_userbits2() const { return at<13>().valid(); }
+  uint32_t timecode_userbits2() const { return at<13>().as_uint32(); }
+  bool has_timecode_userbits3() const { return at<14>().valid(); }
+  uint32_t timecode_userbits3() const { return at<14>().as_uint32(); }
+  bool has_timestamp() const { return at<15>().valid(); }
+  int64_t timestamp() const { return at<15>().as_int64(); }
 };
 
-class ProfilePacket_Histogram_Bucket : public ::protozero::Message {
+class Vb2V4l2DqbufFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = ProfilePacket_Histogram_Bucket_Decoder;
+  using Decoder = Vb2V4l2DqbufFtraceEvent_Decoder;
   enum : int32_t {
-    kUpperLimitFieldNumber = 1,
-    kMaxBucketFieldNumber = 2,
-    kCountFieldNumber = 3,
+    kFieldFieldNumber = 1,
+    kFlagsFieldNumber = 2,
+    kMinorFieldNumber = 3,
+    kSequenceFieldNumber = 4,
+    kTimecodeFlagsFieldNumber = 5,
+    kTimecodeFramesFieldNumber = 6,
+    kTimecodeHoursFieldNumber = 7,
+    kTimecodeMinutesFieldNumber = 8,
+    kTimecodeSecondsFieldNumber = 9,
+    kTimecodeTypeFieldNumber = 10,
+    kTimecodeUserbits0FieldNumber = 11,
+    kTimecodeUserbits1FieldNumber = 12,
+    kTimecodeUserbits2FieldNumber = 13,
+    kTimecodeUserbits3FieldNumber = 14,
+    kTimestampFieldNumber = 15,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ProfilePacket.Histogram.Bucket"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Vb2V4l2DqbufFtraceEvent"; }
 
 
-  using FieldMetadata_UpperLimit =
+  using FieldMetadata_Field =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProfilePacket_Histogram_Bucket>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UpperLimit kUpperLimit() { return {}; }
-  void set_upper_limit(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_UpperLimit::kFieldId;
+  static constexpr FieldMetadata_Field kField{};
+  void set_field(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Field::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MaxBucket =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ProfilePacket_Histogram_Bucket>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MaxBucket kMaxBucket() { return {}; }
-  void set_max_bucket(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_MaxBucket::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Count =
+  using FieldMetadata_Minor =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProfilePacket_Histogram_Bucket>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Vb2V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Count kCount() { return {}; }
-  void set_count(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId;
+  static constexpr FieldMetadata_Minor kMinor{};
+  void set_minor(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Minor::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-class ProfilePacket_HeapSample_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  ProfilePacket_HeapSample_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ProfilePacket_HeapSample_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ProfilePacket_HeapSample_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_callstack_id() const { return at<1>().valid(); }
-  uint64_t callstack_id() const { return at<1>().as_uint64(); }
-  bool has_self_allocated() const { return at<2>().valid(); }
-  uint64_t self_allocated() const { return at<2>().as_uint64(); }
-  bool has_self_freed() const { return at<3>().valid(); }
-  uint64_t self_freed() const { return at<3>().as_uint64(); }
-  bool has_self_max() const { return at<8>().valid(); }
-  uint64_t self_max() const { return at<8>().as_uint64(); }
-  bool has_self_max_count() const { return at<9>().valid(); }
-  uint64_t self_max_count() const { return at<9>().as_uint64(); }
-  bool has_timestamp() const { return at<4>().valid(); }
-  uint64_t timestamp() const { return at<4>().as_uint64(); }
-  bool has_alloc_count() const { return at<5>().valid(); }
-  uint64_t alloc_count() const { return at<5>().as_uint64(); }
-  bool has_free_count() const { return at<6>().valid(); }
-  uint64_t free_count() const { return at<6>().as_uint64(); }
-};
 
-class ProfilePacket_HeapSample : public ::protozero::Message {
- public:
-  using Decoder = ProfilePacket_HeapSample_Decoder;
-  enum : int32_t {
-    kCallstackIdFieldNumber = 1,
-    kSelfAllocatedFieldNumber = 2,
-    kSelfFreedFieldNumber = 3,
-    kSelfMaxFieldNumber = 8,
-    kSelfMaxCountFieldNumber = 9,
-    kTimestampFieldNumber = 4,
-    kAllocCountFieldNumber = 5,
-    kFreeCountFieldNumber = 6,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ProfilePacket.HeapSample"; }
+  using FieldMetadata_Sequence =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2DqbufFtraceEvent>;
 
+  static constexpr FieldMetadata_Sequence kSequence{};
+  void set_sequence(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Sequence::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_CallstackId =
+  using FieldMetadata_TimecodeFlags =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProfilePacket_HeapSample>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CallstackId kCallstackId() { return {}; }
-  void set_callstack_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CallstackId::kFieldId;
+  static constexpr FieldMetadata_TimecodeFlags kTimecodeFlags{};
+  void set_timecode_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeFlags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SelfAllocated =
+  using FieldMetadata_TimecodeFrames =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProfilePacket_HeapSample>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SelfAllocated kSelfAllocated() { return {}; }
-  void set_self_allocated(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SelfAllocated::kFieldId;
+  static constexpr FieldMetadata_TimecodeFrames kTimecodeFrames{};
+  void set_timecode_frames(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeFrames::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SelfFreed =
+  using FieldMetadata_TimecodeHours =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProfilePacket_HeapSample>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SelfFreed kSelfFreed() { return {}; }
-  void set_self_freed(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SelfFreed::kFieldId;
+  static constexpr FieldMetadata_TimecodeHours kTimecodeHours{};
+  void set_timecode_hours(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeHours::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SelfMax =
+  using FieldMetadata_TimecodeMinutes =
     ::protozero::proto_utils::FieldMetadata<
       8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProfilePacket_HeapSample>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SelfMax kSelfMax() { return {}; }
-  void set_self_max(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SelfMax::kFieldId;
+  static constexpr FieldMetadata_TimecodeMinutes kTimecodeMinutes{};
+  void set_timecode_minutes(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeMinutes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SelfMaxCount =
+  using FieldMetadata_TimecodeSeconds =
     ::protozero::proto_utils::FieldMetadata<
       9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProfilePacket_HeapSample>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SelfMaxCount kSelfMaxCount() { return {}; }
-  void set_self_max_count(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SelfMaxCount::kFieldId;
+  static constexpr FieldMetadata_TimecodeSeconds kTimecodeSeconds{};
+  void set_timecode_seconds(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeSeconds::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Timestamp =
+  using FieldMetadata_TimecodeType =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProfilePacket_HeapSample>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timestamp kTimestamp() { return {}; }
-  void set_timestamp(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+  static constexpr FieldMetadata_TimecodeType kTimecodeType{};
+  void set_timecode_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeType::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_AllocCount =
+  using FieldMetadata_TimecodeUserbits0 =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProfilePacket_HeapSample>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AllocCount kAllocCount() { return {}; }
-  void set_alloc_count(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_AllocCount::kFieldId;
+  static constexpr FieldMetadata_TimecodeUserbits0 kTimecodeUserbits0{};
+  void set_timecode_userbits0(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits0::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FreeCount =
+  using FieldMetadata_TimecodeUserbits1 =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      12,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProfilePacket_HeapSample>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FreeCount kFreeCount() { return {}; }
-  void set_free_count(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FreeCount::kFieldId;
+  static constexpr FieldMetadata_TimecodeUserbits1 kTimecodeUserbits1{};
+  void set_timecode_userbits1(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits1::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/profiling/smaps.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_SMAPS_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_SMAPS_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-class SmapsEntry;
-
-class SmapsPacket_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  SmapsPacket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SmapsPacket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SmapsPacket_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pid() const { return at<1>().valid(); }
-  uint32_t pid() const { return at<1>().as_uint32(); }
-  bool has_entries() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> entries() const { return GetRepeated<::protozero::ConstBytes>(2); }
-};
 
-class SmapsPacket : public ::protozero::Message {
- public:
-  using Decoder = SmapsPacket_Decoder;
-  enum : int32_t {
-    kPidFieldNumber = 1,
-    kEntriesFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.SmapsPacket"; }
+  using FieldMetadata_TimecodeUserbits2 =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2DqbufFtraceEvent>;
 
+  static constexpr FieldMetadata_TimecodeUserbits2 kTimecodeUserbits2{};
+  void set_timecode_userbits2(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits2::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_TimecodeUserbits3 =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      14,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SmapsPacket>;
+      Vb2V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_TimecodeUserbits3 kTimecodeUserbits3{};
+  void set_timecode_userbits3(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits3::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -139822,355 +162716,258 @@ class SmapsPacket : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Entries =
+  using FieldMetadata_Timestamp =
     ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      SmapsEntry,
-      SmapsPacket>;
+      15,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Vb2V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Entries kEntries() { return {}; }
-  template <typename T = SmapsEntry> T* add_entries() {
-    return BeginNestedMessage<T>(2);
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
   }
-
 };
 
-class SmapsEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/15, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Vb2V4l2QbufFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/15> {
  public:
-  SmapsEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SmapsEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SmapsEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_path() const { return at<1>().valid(); }
-  ::protozero::ConstChars path() const { return at<1>().as_string(); }
-  bool has_size_kb() const { return at<2>().valid(); }
-  uint64_t size_kb() const { return at<2>().as_uint64(); }
-  bool has_private_dirty_kb() const { return at<3>().valid(); }
-  uint64_t private_dirty_kb() const { return at<3>().as_uint64(); }
-  bool has_swap_kb() const { return at<4>().valid(); }
-  uint64_t swap_kb() const { return at<4>().as_uint64(); }
-  bool has_file_name() const { return at<5>().valid(); }
-  ::protozero::ConstChars file_name() const { return at<5>().as_string(); }
-  bool has_start_address() const { return at<6>().valid(); }
-  uint64_t start_address() const { return at<6>().as_uint64(); }
-  bool has_module_timestamp() const { return at<7>().valid(); }
-  uint64_t module_timestamp() const { return at<7>().as_uint64(); }
-  bool has_module_debugid() const { return at<8>().valid(); }
-  ::protozero::ConstChars module_debugid() const { return at<8>().as_string(); }
-  bool has_module_debug_path() const { return at<9>().valid(); }
-  ::protozero::ConstChars module_debug_path() const { return at<9>().as_string(); }
-  bool has_protection_flags() const { return at<10>().valid(); }
-  uint32_t protection_flags() const { return at<10>().as_uint32(); }
-  bool has_private_clean_resident_kb() const { return at<11>().valid(); }
-  uint64_t private_clean_resident_kb() const { return at<11>().as_uint64(); }
-  bool has_shared_dirty_resident_kb() const { return at<12>().valid(); }
-  uint64_t shared_dirty_resident_kb() const { return at<12>().as_uint64(); }
-  bool has_shared_clean_resident_kb() const { return at<13>().valid(); }
-  uint64_t shared_clean_resident_kb() const { return at<13>().as_uint64(); }
-  bool has_locked_kb() const { return at<14>().valid(); }
-  uint64_t locked_kb() const { return at<14>().as_uint64(); }
-  bool has_proportional_resident_kb() const { return at<15>().valid(); }
-  uint64_t proportional_resident_kb() const { return at<15>().as_uint64(); }
+  Vb2V4l2QbufFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Vb2V4l2QbufFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Vb2V4l2QbufFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_field() const { return at<1>().valid(); }
+  uint32_t field() const { return at<1>().as_uint32(); }
+  bool has_flags() const { return at<2>().valid(); }
+  uint32_t flags() const { return at<2>().as_uint32(); }
+  bool has_minor() const { return at<3>().valid(); }
+  int32_t minor() const { return at<3>().as_int32(); }
+  bool has_sequence() const { return at<4>().valid(); }
+  uint32_t sequence() const { return at<4>().as_uint32(); }
+  bool has_timecode_flags() const { return at<5>().valid(); }
+  uint32_t timecode_flags() const { return at<5>().as_uint32(); }
+  bool has_timecode_frames() const { return at<6>().valid(); }
+  uint32_t timecode_frames() const { return at<6>().as_uint32(); }
+  bool has_timecode_hours() const { return at<7>().valid(); }
+  uint32_t timecode_hours() const { return at<7>().as_uint32(); }
+  bool has_timecode_minutes() const { return at<8>().valid(); }
+  uint32_t timecode_minutes() const { return at<8>().as_uint32(); }
+  bool has_timecode_seconds() const { return at<9>().valid(); }
+  uint32_t timecode_seconds() const { return at<9>().as_uint32(); }
+  bool has_timecode_type() const { return at<10>().valid(); }
+  uint32_t timecode_type() const { return at<10>().as_uint32(); }
+  bool has_timecode_userbits0() const { return at<11>().valid(); }
+  uint32_t timecode_userbits0() const { return at<11>().as_uint32(); }
+  bool has_timecode_userbits1() const { return at<12>().valid(); }
+  uint32_t timecode_userbits1() const { return at<12>().as_uint32(); }
+  bool has_timecode_userbits2() const { return at<13>().valid(); }
+  uint32_t timecode_userbits2() const { return at<13>().as_uint32(); }
+  bool has_timecode_userbits3() const { return at<14>().valid(); }
+  uint32_t timecode_userbits3() const { return at<14>().as_uint32(); }
+  bool has_timestamp() const { return at<15>().valid(); }
+  int64_t timestamp() const { return at<15>().as_int64(); }
 };
 
-class SmapsEntry : public ::protozero::Message {
+class Vb2V4l2QbufFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = SmapsEntry_Decoder;
+  using Decoder = Vb2V4l2QbufFtraceEvent_Decoder;
   enum : int32_t {
-    kPathFieldNumber = 1,
-    kSizeKbFieldNumber = 2,
-    kPrivateDirtyKbFieldNumber = 3,
-    kSwapKbFieldNumber = 4,
-    kFileNameFieldNumber = 5,
-    kStartAddressFieldNumber = 6,
-    kModuleTimestampFieldNumber = 7,
-    kModuleDebugidFieldNumber = 8,
-    kModuleDebugPathFieldNumber = 9,
-    kProtectionFlagsFieldNumber = 10,
-    kPrivateCleanResidentKbFieldNumber = 11,
-    kSharedDirtyResidentKbFieldNumber = 12,
-    kSharedCleanResidentKbFieldNumber = 13,
-    kLockedKbFieldNumber = 14,
-    kProportionalResidentKbFieldNumber = 15,
+    kFieldFieldNumber = 1,
+    kFlagsFieldNumber = 2,
+    kMinorFieldNumber = 3,
+    kSequenceFieldNumber = 4,
+    kTimecodeFlagsFieldNumber = 5,
+    kTimecodeFramesFieldNumber = 6,
+    kTimecodeHoursFieldNumber = 7,
+    kTimecodeMinutesFieldNumber = 8,
+    kTimecodeSecondsFieldNumber = 9,
+    kTimecodeTypeFieldNumber = 10,
+    kTimecodeUserbits0FieldNumber = 11,
+    kTimecodeUserbits1FieldNumber = 12,
+    kTimecodeUserbits2FieldNumber = 13,
+    kTimecodeUserbits3FieldNumber = 14,
+    kTimestampFieldNumber = 15,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SmapsEntry"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Vb2V4l2QbufFtraceEvent"; }
 
 
-  using FieldMetadata_Path =
+  using FieldMetadata_Field =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SmapsEntry>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Path kPath() { return {}; }
-  void set_path(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Path::kFieldId, data, size);
-  }
-  void set_path(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Path::kFieldId, chars.data, chars.size);
-  }
-  void set_path(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Path::kFieldId;
+  static constexpr FieldMetadata_Field kField{};
+  void set_field(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Field::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SizeKb =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SmapsEntry>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SizeKb kSizeKb() { return {}; }
-  void set_size_kb(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SizeKb::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PrivateDirtyKb =
+  using FieldMetadata_Minor =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SmapsEntry>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Vb2V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PrivateDirtyKb kPrivateDirtyKb() { return {}; }
-  void set_private_dirty_kb(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PrivateDirtyKb::kFieldId;
+  static constexpr FieldMetadata_Minor kMinor{};
+  void set_minor(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Minor::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SwapKb =
+  using FieldMetadata_Sequence =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SmapsEntry>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SwapKb kSwapKb() { return {}; }
-  void set_swap_kb(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SwapKb::kFieldId;
+  static constexpr FieldMetadata_Sequence kSequence{};
+  void set_sequence(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Sequence::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FileName =
+  using FieldMetadata_TimecodeFlags =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SmapsEntry>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FileName kFileName() { return {}; }
-  void set_file_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_FileName::kFieldId, data, size);
-  }
-  void set_file_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_FileName::kFieldId, chars.data, chars.size);
-  }
-  void set_file_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_FileName::kFieldId;
+  static constexpr FieldMetadata_TimecodeFlags kTimecodeFlags{};
+  void set_timecode_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeFlags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_StartAddress =
+  using FieldMetadata_TimecodeFrames =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SmapsEntry>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StartAddress kStartAddress() { return {}; }
-  void set_start_address(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StartAddress::kFieldId;
+  static constexpr FieldMetadata_TimecodeFrames kTimecodeFrames{};
+  void set_timecode_frames(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeFrames::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ModuleTimestamp =
+  using FieldMetadata_TimecodeHours =
     ::protozero::proto_utils::FieldMetadata<
       7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SmapsEntry>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ModuleTimestamp kModuleTimestamp() { return {}; }
-  void set_module_timestamp(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ModuleTimestamp::kFieldId;
+  static constexpr FieldMetadata_TimecodeHours kTimecodeHours{};
+  void set_timecode_hours(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeHours::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ModuleDebugid =
+  using FieldMetadata_TimecodeMinutes =
     ::protozero::proto_utils::FieldMetadata<
       8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SmapsEntry>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ModuleDebugid kModuleDebugid() { return {}; }
-  void set_module_debugid(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ModuleDebugid::kFieldId, data, size);
-  }
-  void set_module_debugid(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ModuleDebugid::kFieldId, chars.data, chars.size);
-  }
-  void set_module_debugid(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ModuleDebugid::kFieldId;
+  static constexpr FieldMetadata_TimecodeMinutes kTimecodeMinutes{};
+  void set_timecode_minutes(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeMinutes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ModuleDebugPath =
+  using FieldMetadata_TimecodeSeconds =
     ::protozero::proto_utils::FieldMetadata<
       9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SmapsEntry>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ModuleDebugPath kModuleDebugPath() { return {}; }
-  void set_module_debug_path(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ModuleDebugPath::kFieldId, data, size);
-  }
-  void set_module_debug_path(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ModuleDebugPath::kFieldId, chars.data, chars.size);
-  }
-  void set_module_debug_path(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ModuleDebugPath::kFieldId;
+  static constexpr FieldMetadata_TimecodeSeconds kTimecodeSeconds{};
+  void set_timecode_seconds(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeSeconds::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ProtectionFlags =
+  using FieldMetadata_TimecodeType =
     ::protozero::proto_utils::FieldMetadata<
       10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      SmapsEntry>;
+      Vb2V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProtectionFlags kProtectionFlags() { return {}; }
-  void set_protection_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProtectionFlags::kFieldId;
+  static constexpr FieldMetadata_TimecodeType kTimecodeType{};
+  void set_timecode_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeType::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -140178,1021 +162975,625 @@ class SmapsEntry : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PrivateCleanResidentKb =
+  using FieldMetadata_TimecodeUserbits0 =
     ::protozero::proto_utils::FieldMetadata<
       11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SmapsEntry>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PrivateCleanResidentKb kPrivateCleanResidentKb() { return {}; }
-  void set_private_clean_resident_kb(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PrivateCleanResidentKb::kFieldId;
+  static constexpr FieldMetadata_TimecodeUserbits0 kTimecodeUserbits0{};
+  void set_timecode_userbits0(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits0::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SharedDirtyResidentKb =
+  using FieldMetadata_TimecodeUserbits1 =
     ::protozero::proto_utils::FieldMetadata<
       12,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SmapsEntry>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SharedDirtyResidentKb kSharedDirtyResidentKb() { return {}; }
-  void set_shared_dirty_resident_kb(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SharedDirtyResidentKb::kFieldId;
+  static constexpr FieldMetadata_TimecodeUserbits1 kTimecodeUserbits1{};
+  void set_timecode_userbits1(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits1::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SharedCleanResidentKb =
+  using FieldMetadata_TimecodeUserbits2 =
     ::protozero::proto_utils::FieldMetadata<
       13,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SmapsEntry>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SharedCleanResidentKb kSharedCleanResidentKb() { return {}; }
-  void set_shared_clean_resident_kb(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SharedCleanResidentKb::kFieldId;
+  static constexpr FieldMetadata_TimecodeUserbits2 kTimecodeUserbits2{};
+  void set_timecode_userbits2(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits2::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_LockedKb =
+  using FieldMetadata_TimecodeUserbits3 =
     ::protozero::proto_utils::FieldMetadata<
       14,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SmapsEntry>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LockedKb kLockedKb() { return {}; }
-  void set_locked_kb(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LockedKb::kFieldId;
+  static constexpr FieldMetadata_TimecodeUserbits3 kTimecodeUserbits3{};
+  void set_timecode_userbits3(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits3::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ProportionalResidentKb =
+  using FieldMetadata_Timestamp =
     ::protozero::proto_utils::FieldMetadata<
       15,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SmapsEntry>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Vb2V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProportionalResidentKb kProportionalResidentKb() { return {}; }
-  void set_proportional_resident_kb(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProportionalResidentKb::kFieldId;
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_active_processes.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_ACTIVE_PROCESSES_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_ACTIVE_PROCESSES_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class ChromeActiveProcesses_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class Vb2V4l2BufDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/15> {
  public:
-  ChromeActiveProcesses_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeActiveProcesses_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeActiveProcesses_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pid() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<int32_t> pid() const { return GetRepeated<int32_t>(1); }
+  Vb2V4l2BufDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Vb2V4l2BufDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Vb2V4l2BufDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_field() const { return at<1>().valid(); }
+  uint32_t field() const { return at<1>().as_uint32(); }
+  bool has_flags() const { return at<2>().valid(); }
+  uint32_t flags() const { return at<2>().as_uint32(); }
+  bool has_minor() const { return at<3>().valid(); }
+  int32_t minor() const { return at<3>().as_int32(); }
+  bool has_sequence() const { return at<4>().valid(); }
+  uint32_t sequence() const { return at<4>().as_uint32(); }
+  bool has_timecode_flags() const { return at<5>().valid(); }
+  uint32_t timecode_flags() const { return at<5>().as_uint32(); }
+  bool has_timecode_frames() const { return at<6>().valid(); }
+  uint32_t timecode_frames() const { return at<6>().as_uint32(); }
+  bool has_timecode_hours() const { return at<7>().valid(); }
+  uint32_t timecode_hours() const { return at<7>().as_uint32(); }
+  bool has_timecode_minutes() const { return at<8>().valid(); }
+  uint32_t timecode_minutes() const { return at<8>().as_uint32(); }
+  bool has_timecode_seconds() const { return at<9>().valid(); }
+  uint32_t timecode_seconds() const { return at<9>().as_uint32(); }
+  bool has_timecode_type() const { return at<10>().valid(); }
+  uint32_t timecode_type() const { return at<10>().as_uint32(); }
+  bool has_timecode_userbits0() const { return at<11>().valid(); }
+  uint32_t timecode_userbits0() const { return at<11>().as_uint32(); }
+  bool has_timecode_userbits1() const { return at<12>().valid(); }
+  uint32_t timecode_userbits1() const { return at<12>().as_uint32(); }
+  bool has_timecode_userbits2() const { return at<13>().valid(); }
+  uint32_t timecode_userbits2() const { return at<13>().as_uint32(); }
+  bool has_timecode_userbits3() const { return at<14>().valid(); }
+  uint32_t timecode_userbits3() const { return at<14>().as_uint32(); }
+  bool has_timestamp() const { return at<15>().valid(); }
+  int64_t timestamp() const { return at<15>().as_int64(); }
 };
 
-class ChromeActiveProcesses : public ::protozero::Message {
+class Vb2V4l2BufDoneFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = ChromeActiveProcesses_Decoder;
+  using Decoder = Vb2V4l2BufDoneFtraceEvent_Decoder;
   enum : int32_t {
-    kPidFieldNumber = 1,
+    kFieldFieldNumber = 1,
+    kFlagsFieldNumber = 2,
+    kMinorFieldNumber = 3,
+    kSequenceFieldNumber = 4,
+    kTimecodeFlagsFieldNumber = 5,
+    kTimecodeFramesFieldNumber = 6,
+    kTimecodeHoursFieldNumber = 7,
+    kTimecodeMinutesFieldNumber = 8,
+    kTimecodeSecondsFieldNumber = 9,
+    kTimecodeTypeFieldNumber = 10,
+    kTimecodeUserbits0FieldNumber = 11,
+    kTimecodeUserbits1FieldNumber = 12,
+    kTimecodeUserbits2FieldNumber = 13,
+    kTimecodeUserbits3FieldNumber = 14,
+    kTimestampFieldNumber = 15,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeActiveProcesses"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Vb2V4l2BufDoneFtraceEvent"; }
 
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_Field =
     ::protozero::proto_utils::FieldMetadata<
       1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ChromeActiveProcesses>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void add_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_Field kField{};
+  void set_field(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Field::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_application_state_info.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_APPLICATION_STATE_INFO_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_APPLICATION_STATE_INFO_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-namespace perfetto_pbzero_enum_ChromeApplicationStateInfo {
-enum ChromeApplicationState : int32_t;
-}  // namespace perfetto_pbzero_enum_ChromeApplicationStateInfo
-using ChromeApplicationStateInfo_ChromeApplicationState = perfetto_pbzero_enum_ChromeApplicationStateInfo::ChromeApplicationState;
-
-namespace perfetto_pbzero_enum_ChromeApplicationStateInfo {
-enum ChromeApplicationState : int32_t {
-  APPLICATION_STATE_UNKNOWN = 0,
-  APPLICATION_STATE_HAS_RUNNING_ACTIVITIES = 1,
-  APPLICATION_STATE_HAS_PAUSED_ACTIVITIES = 2,
-  APPLICATION_STATE_HAS_STOPPED_ACTIVITIES = 3,
-  APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES = 4,
-};
-} // namespace perfetto_pbzero_enum_ChromeApplicationStateInfo
-using ChromeApplicationStateInfo_ChromeApplicationState = perfetto_pbzero_enum_ChromeApplicationStateInfo::ChromeApplicationState;
-
-
-constexpr ChromeApplicationStateInfo_ChromeApplicationState ChromeApplicationStateInfo_ChromeApplicationState_MIN = ChromeApplicationStateInfo_ChromeApplicationState::APPLICATION_STATE_UNKNOWN;
-constexpr ChromeApplicationStateInfo_ChromeApplicationState ChromeApplicationStateInfo_ChromeApplicationState_MAX = ChromeApplicationStateInfo_ChromeApplicationState::APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES;
 
+  using FieldMetadata_Flags =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufDoneFtraceEvent>;
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ChromeApplicationStateInfo_ChromeApplicationState_Name(::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState::APPLICATION_STATE_UNKNOWN:
-    return "APPLICATION_STATE_UNKNOWN";
-
-  case ::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES:
-    return "APPLICATION_STATE_HAS_RUNNING_ACTIVITIES";
-
-  case ::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState::APPLICATION_STATE_HAS_PAUSED_ACTIVITIES:
-    return "APPLICATION_STATE_HAS_PAUSED_ACTIVITIES";
-
-  case ::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState::APPLICATION_STATE_HAS_STOPPED_ACTIVITIES:
-    return "APPLICATION_STATE_HAS_STOPPED_ACTIVITIES";
-
-  case ::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState::APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES:
-    return "APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES";
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-class ChromeApplicationStateInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  ChromeApplicationStateInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeApplicationStateInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeApplicationStateInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_application_state() const { return at<1>().valid(); }
-  int32_t application_state() const { return at<1>().as_int32(); }
-};
-
-class ChromeApplicationStateInfo : public ::protozero::Message {
- public:
-  using Decoder = ChromeApplicationStateInfo_Decoder;
-  enum : int32_t {
-    kApplicationStateFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeApplicationStateInfo"; }
 
+  using FieldMetadata_Minor =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Vb2V4l2BufDoneFtraceEvent>;
 
-  using ChromeApplicationState = ::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState;
-  static inline const char* ChromeApplicationState_Name(ChromeApplicationState value) {
-    return ::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState_Name(value);
+  static constexpr FieldMetadata_Minor kMinor{};
+  void set_minor(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Minor::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
   }
-  static const ChromeApplicationState APPLICATION_STATE_UNKNOWN = ChromeApplicationState::APPLICATION_STATE_UNKNOWN;
-  static const ChromeApplicationState APPLICATION_STATE_HAS_RUNNING_ACTIVITIES = ChromeApplicationState::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES;
-  static const ChromeApplicationState APPLICATION_STATE_HAS_PAUSED_ACTIVITIES = ChromeApplicationState::APPLICATION_STATE_HAS_PAUSED_ACTIVITIES;
-  static const ChromeApplicationState APPLICATION_STATE_HAS_STOPPED_ACTIVITIES = ChromeApplicationState::APPLICATION_STATE_HAS_STOPPED_ACTIVITIES;
-  static const ChromeApplicationState APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES = ChromeApplicationState::APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES;
 
-  using FieldMetadata_ApplicationState =
+  using FieldMetadata_Sequence =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState,
-      ChromeApplicationStateInfo>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ApplicationState kApplicationState() { return {}; }
-  void set_application_state(::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState value) {
-    static constexpr uint32_t field_id = FieldMetadata_ApplicationState::kFieldId;
+  static constexpr FieldMetadata_Sequence kSequence{};
+  void set_sequence(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Sequence::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_compositor_scheduler_state.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_COMPOSITOR_SCHEDULER_STATE_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_COMPOSITOR_SCHEDULER_STATE_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-class BeginFrameArgs;
-class BeginFrameObserverState;
-class BeginFrameSourceState;
-class BeginImplFrameArgs;
-class BeginImplFrameArgs_TimestampsInUs;
-class ChromeCompositorStateMachine;
-class ChromeCompositorStateMachine_MajorState;
-class ChromeCompositorStateMachine_MinorState;
-class CompositorTimingHistory;
-class SourceLocation;
-namespace perfetto_pbzero_enum_BeginFrameArgs {
-enum BeginFrameArgsType : int32_t;
-}  // namespace perfetto_pbzero_enum_BeginFrameArgs
-using BeginFrameArgs_BeginFrameArgsType = perfetto_pbzero_enum_BeginFrameArgs::BeginFrameArgsType;
-namespace perfetto_pbzero_enum_BeginImplFrameArgs {
-enum State : int32_t;
-}  // namespace perfetto_pbzero_enum_BeginImplFrameArgs
-using BeginImplFrameArgs_State = perfetto_pbzero_enum_BeginImplFrameArgs::State;
-enum ChromeCompositorSchedulerAction : int32_t;
-namespace perfetto_pbzero_enum_ChromeCompositorSchedulerState {
-enum BeginImplFrameDeadlineMode : int32_t;
-}  // namespace perfetto_pbzero_enum_ChromeCompositorSchedulerState
-using ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode = perfetto_pbzero_enum_ChromeCompositorSchedulerState::BeginImplFrameDeadlineMode;
-namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState {
-enum BeginImplFrameState : int32_t;
-}  // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState
-using ChromeCompositorStateMachine_MajorState_BeginImplFrameState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::BeginImplFrameState;
-namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState {
-enum BeginMainFrameState : int32_t;
-}  // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState
-using ChromeCompositorStateMachine_MajorState_BeginMainFrameState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::BeginMainFrameState;
-namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState {
-enum ForcedRedrawOnTimeoutState : int32_t;
-}  // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState
-using ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::ForcedRedrawOnTimeoutState;
-namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState {
-enum LayerTreeFrameSinkState : int32_t;
-}  // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState
-using ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::LayerTreeFrameSinkState;
-namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState {
-enum ScrollHandlerState : int32_t;
-}  // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState
-using ChromeCompositorStateMachine_MinorState_ScrollHandlerState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState::ScrollHandlerState;
-namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState {
-enum TreePriority : int32_t;
-}  // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState
-using ChromeCompositorStateMachine_MinorState_TreePriority = perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState::TreePriority;
-
-enum ChromeCompositorSchedulerAction : int32_t {
-  CC_SCHEDULER_ACTION_UNSPECIFIED = 0,
-  CC_SCHEDULER_ACTION_NONE = 1,
-  CC_SCHEDULER_ACTION_SEND_BEGIN_MAIN_FRAME = 2,
-  CC_SCHEDULER_ACTION_COMMIT = 3,
-  CC_SCHEDULER_ACTION_ACTIVATE_SYNC_TREE = 4,
-  CC_SCHEDULER_ACTION_DRAW_IF_POSSIBLE = 5,
-  CC_SCHEDULER_ACTION_DRAW_FORCED = 6,
-  CC_SCHEDULER_ACTION_DRAW_ABORT = 7,
-  CC_SCHEDULER_ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION = 8,
-  CC_SCHEDULER_ACTION_PREPARE_TILES = 9,
-  CC_SCHEDULER_ACTION_INVALIDATE_LAYER_TREE_FRAME_SINK = 10,
-  CC_SCHEDULER_ACTION_PERFORM_IMPL_SIDE_INVALIDATION = 11,
-  CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_UNTIL = 12,
-  CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_SOON = 13,
-};
-
-constexpr ChromeCompositorSchedulerAction ChromeCompositorSchedulerAction_MIN = ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_UNSPECIFIED;
-constexpr ChromeCompositorSchedulerAction ChromeCompositorSchedulerAction_MAX = ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_SOON;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ChromeCompositorSchedulerAction_Name(::perfetto::protos::pbzero::ChromeCompositorSchedulerAction value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_UNSPECIFIED:
-    return "CC_SCHEDULER_ACTION_UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_NONE:
-    return "CC_SCHEDULER_ACTION_NONE";
-
-  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_SEND_BEGIN_MAIN_FRAME:
-    return "CC_SCHEDULER_ACTION_SEND_BEGIN_MAIN_FRAME";
-
-  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_COMMIT:
-    return "CC_SCHEDULER_ACTION_COMMIT";
-
-  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_ACTIVATE_SYNC_TREE:
-    return "CC_SCHEDULER_ACTION_ACTIVATE_SYNC_TREE";
-
-  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_DRAW_IF_POSSIBLE:
-    return "CC_SCHEDULER_ACTION_DRAW_IF_POSSIBLE";
-
-  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_DRAW_FORCED:
-    return "CC_SCHEDULER_ACTION_DRAW_FORCED";
-
-  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_DRAW_ABORT:
-    return "CC_SCHEDULER_ACTION_DRAW_ABORT";
-
-  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION:
-    return "CC_SCHEDULER_ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION";
-
-  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_PREPARE_TILES:
-    return "CC_SCHEDULER_ACTION_PREPARE_TILES";
-
-  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_INVALIDATE_LAYER_TREE_FRAME_SINK:
-    return "CC_SCHEDULER_ACTION_INVALIDATE_LAYER_TREE_FRAME_SINK";
-
-  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_PERFORM_IMPL_SIDE_INVALIDATION:
-    return "CC_SCHEDULER_ACTION_PERFORM_IMPL_SIDE_INVALIDATION";
 
-  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_UNTIL:
-    return "CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_UNTIL";
+  using FieldMetadata_TimecodeFlags =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufDoneFtraceEvent>;
 
-  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_SOON:
-    return "CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_SOON";
+  static constexpr FieldMetadata_TimecodeFlags kTimecodeFlags{};
+  void set_timecode_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeFlags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-namespace perfetto_pbzero_enum_BeginImplFrameArgs {
-enum State : int32_t {
-  BEGIN_FRAME_FINISHED = 0,
-  BEGIN_FRAME_USING = 1,
-};
-} // namespace perfetto_pbzero_enum_BeginImplFrameArgs
-using BeginImplFrameArgs_State = perfetto_pbzero_enum_BeginImplFrameArgs::State;
 
+  using FieldMetadata_TimecodeFrames =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufDoneFtraceEvent>;
 
-constexpr BeginImplFrameArgs_State BeginImplFrameArgs_State_MIN = BeginImplFrameArgs_State::BEGIN_FRAME_FINISHED;
-constexpr BeginImplFrameArgs_State BeginImplFrameArgs_State_MAX = BeginImplFrameArgs_State::BEGIN_FRAME_USING;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* BeginImplFrameArgs_State_Name(::perfetto::protos::pbzero::BeginImplFrameArgs_State value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::BeginImplFrameArgs_State::BEGIN_FRAME_FINISHED:
-    return "BEGIN_FRAME_FINISHED";
-
-  case ::perfetto::protos::pbzero::BeginImplFrameArgs_State::BEGIN_FRAME_USING:
-    return "BEGIN_FRAME_USING";
+  static constexpr FieldMetadata_TimecodeFrames kTimecodeFrames{};
+  void set_timecode_frames(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeFrames::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-namespace perfetto_pbzero_enum_BeginFrameArgs {
-enum BeginFrameArgsType : int32_t {
-  BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED = 0,
-  BEGIN_FRAME_ARGS_TYPE_INVALID = 1,
-  BEGIN_FRAME_ARGS_TYPE_NORMAL = 2,
-  BEGIN_FRAME_ARGS_TYPE_MISSED = 3,
-};
-} // namespace perfetto_pbzero_enum_BeginFrameArgs
-using BeginFrameArgs_BeginFrameArgsType = perfetto_pbzero_enum_BeginFrameArgs::BeginFrameArgsType;
-
-
-constexpr BeginFrameArgs_BeginFrameArgsType BeginFrameArgs_BeginFrameArgsType_MIN = BeginFrameArgs_BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED;
-constexpr BeginFrameArgs_BeginFrameArgsType BeginFrameArgs_BeginFrameArgsType_MAX = BeginFrameArgs_BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_MISSED;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* BeginFrameArgs_BeginFrameArgsType_Name(::perfetto::protos::pbzero::BeginFrameArgs_BeginFrameArgsType value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::BeginFrameArgs_BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED:
-    return "BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::BeginFrameArgs_BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_INVALID:
-    return "BEGIN_FRAME_ARGS_TYPE_INVALID";
 
-  case ::perfetto::protos::pbzero::BeginFrameArgs_BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_NORMAL:
-    return "BEGIN_FRAME_ARGS_TYPE_NORMAL";
+  using FieldMetadata_TimecodeHours =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufDoneFtraceEvent>;
 
-  case ::perfetto::protos::pbzero::BeginFrameArgs_BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_MISSED:
-    return "BEGIN_FRAME_ARGS_TYPE_MISSED";
+  static constexpr FieldMetadata_TimecodeHours kTimecodeHours{};
+  void set_timecode_hours(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeHours::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState {
-enum TreePriority : int32_t {
-  TREE_PRIORITY_UNSPECIFIED = 0,
-  TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES = 1,
-  TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY = 2,
-  TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY = 3,
-};
-} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState
-using ChromeCompositorStateMachine_MinorState_TreePriority = perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState::TreePriority;
-
-
-constexpr ChromeCompositorStateMachine_MinorState_TreePriority ChromeCompositorStateMachine_MinorState_TreePriority_MIN = ChromeCompositorStateMachine_MinorState_TreePriority::TREE_PRIORITY_UNSPECIFIED;
-constexpr ChromeCompositorStateMachine_MinorState_TreePriority ChromeCompositorStateMachine_MinorState_TreePriority_MAX = ChromeCompositorStateMachine_MinorState_TreePriority::TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ChromeCompositorStateMachine_MinorState_TreePriority_Name(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_TreePriority value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_TreePriority::TREE_PRIORITY_UNSPECIFIED:
-    return "TREE_PRIORITY_UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_TreePriority::TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES:
-    return "TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES";
 
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_TreePriority::TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY:
-    return "TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY";
+  using FieldMetadata_TimecodeMinutes =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufDoneFtraceEvent>;
 
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_TreePriority::TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY:
-    return "TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY";
+  static constexpr FieldMetadata_TimecodeMinutes kTimecodeMinutes{};
+  void set_timecode_minutes(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeMinutes::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState {
-enum ScrollHandlerState : int32_t {
-  SCROLL_HANDLER_UNSPECIFIED = 0,
-  SCROLL_AFFECTS_SCROLL_HANDLER = 1,
-  SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER = 2,
-};
-} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState
-using ChromeCompositorStateMachine_MinorState_ScrollHandlerState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState::ScrollHandlerState;
-
-
-constexpr ChromeCompositorStateMachine_MinorState_ScrollHandlerState ChromeCompositorStateMachine_MinorState_ScrollHandlerState_MIN = ChromeCompositorStateMachine_MinorState_ScrollHandlerState::SCROLL_HANDLER_UNSPECIFIED;
-constexpr ChromeCompositorStateMachine_MinorState_ScrollHandlerState ChromeCompositorStateMachine_MinorState_ScrollHandlerState_MAX = ChromeCompositorStateMachine_MinorState_ScrollHandlerState::SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ChromeCompositorStateMachine_MinorState_ScrollHandlerState_Name(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_ScrollHandlerState value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_ScrollHandlerState::SCROLL_HANDLER_UNSPECIFIED:
-    return "SCROLL_HANDLER_UNSPECIFIED";
 
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_ScrollHandlerState::SCROLL_AFFECTS_SCROLL_HANDLER:
-    return "SCROLL_AFFECTS_SCROLL_HANDLER";
+  using FieldMetadata_TimecodeSeconds =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufDoneFtraceEvent>;
 
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_ScrollHandlerState::SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER:
-    return "SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER";
+  static constexpr FieldMetadata_TimecodeSeconds kTimecodeSeconds{};
+  void set_timecode_seconds(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeSeconds::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState {
-enum BeginImplFrameState : int32_t {
-  BEGIN_IMPL_FRAME_UNSPECIFIED = 0,
-  BEGIN_IMPL_FRAME_IDLE = 1,
-  BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME = 2,
-  BEGIN_IMPL_FRAME_INSIDE_DEADLINE = 3,
-};
-} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState
-using ChromeCompositorStateMachine_MajorState_BeginImplFrameState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::BeginImplFrameState;
-
-
-constexpr ChromeCompositorStateMachine_MajorState_BeginImplFrameState ChromeCompositorStateMachine_MajorState_BeginImplFrameState_MIN = ChromeCompositorStateMachine_MajorState_BeginImplFrameState::BEGIN_IMPL_FRAME_UNSPECIFIED;
-constexpr ChromeCompositorStateMachine_MajorState_BeginImplFrameState ChromeCompositorStateMachine_MajorState_BeginImplFrameState_MAX = ChromeCompositorStateMachine_MajorState_BeginImplFrameState::BEGIN_IMPL_FRAME_INSIDE_DEADLINE;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ChromeCompositorStateMachine_MajorState_BeginImplFrameState_Name(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginImplFrameState value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginImplFrameState::BEGIN_IMPL_FRAME_UNSPECIFIED:
-    return "BEGIN_IMPL_FRAME_UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginImplFrameState::BEGIN_IMPL_FRAME_IDLE:
-    return "BEGIN_IMPL_FRAME_IDLE";
 
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginImplFrameState::BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME:
-    return "BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME";
+  using FieldMetadata_TimecodeType =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufDoneFtraceEvent>;
 
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginImplFrameState::BEGIN_IMPL_FRAME_INSIDE_DEADLINE:
-    return "BEGIN_IMPL_FRAME_INSIDE_DEADLINE";
+  static constexpr FieldMetadata_TimecodeType kTimecodeType{};
+  void set_timecode_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState {
-enum BeginMainFrameState : int32_t {
-  BEGIN_MAIN_FRAME_UNSPECIFIED = 0,
-  BEGIN_MAIN_FRAME_IDLE = 1,
-  BEGIN_MAIN_FRAME_SENT = 2,
-  BEGIN_MAIN_FRAME_READY_TO_COMMIT = 3,
-};
-} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState
-using ChromeCompositorStateMachine_MajorState_BeginMainFrameState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::BeginMainFrameState;
-
-
-constexpr ChromeCompositorStateMachine_MajorState_BeginMainFrameState ChromeCompositorStateMachine_MajorState_BeginMainFrameState_MIN = ChromeCompositorStateMachine_MajorState_BeginMainFrameState::BEGIN_MAIN_FRAME_UNSPECIFIED;
-constexpr ChromeCompositorStateMachine_MajorState_BeginMainFrameState ChromeCompositorStateMachine_MajorState_BeginMainFrameState_MAX = ChromeCompositorStateMachine_MajorState_BeginMainFrameState::BEGIN_MAIN_FRAME_READY_TO_COMMIT;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ChromeCompositorStateMachine_MajorState_BeginMainFrameState_Name(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginMainFrameState value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginMainFrameState::BEGIN_MAIN_FRAME_UNSPECIFIED:
-    return "BEGIN_MAIN_FRAME_UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginMainFrameState::BEGIN_MAIN_FRAME_IDLE:
-    return "BEGIN_MAIN_FRAME_IDLE";
 
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginMainFrameState::BEGIN_MAIN_FRAME_SENT:
-    return "BEGIN_MAIN_FRAME_SENT";
+  using FieldMetadata_TimecodeUserbits0 =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufDoneFtraceEvent>;
 
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginMainFrameState::BEGIN_MAIN_FRAME_READY_TO_COMMIT:
-    return "BEGIN_MAIN_FRAME_READY_TO_COMMIT";
+  static constexpr FieldMetadata_TimecodeUserbits0 kTimecodeUserbits0{};
+  void set_timecode_userbits0(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits0::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState {
-enum LayerTreeFrameSinkState : int32_t {
-  LAYER_TREE_FRAME_UNSPECIFIED = 0,
-  LAYER_TREE_FRAME_NONE = 1,
-  LAYER_TREE_FRAME_ACTIVE = 2,
-  LAYER_TREE_FRAME_CREATING = 3,
-  LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT = 4,
-  LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION = 5,
-};
-} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState
-using ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::LayerTreeFrameSinkState;
-
-
-constexpr ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_MIN = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_UNSPECIFIED;
-constexpr ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_MAX = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_Name(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_UNSPECIFIED:
-    return "LAYER_TREE_FRAME_UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_NONE:
-    return "LAYER_TREE_FRAME_NONE";
-
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_ACTIVE:
-    return "LAYER_TREE_FRAME_ACTIVE";
-
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_CREATING:
-    return "LAYER_TREE_FRAME_CREATING";
 
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT:
-    return "LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT";
+  using FieldMetadata_TimecodeUserbits1 =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufDoneFtraceEvent>;
 
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION:
-    return "LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION";
+  static constexpr FieldMetadata_TimecodeUserbits1 kTimecodeUserbits1{};
+  void set_timecode_userbits1(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits1::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState {
-enum ForcedRedrawOnTimeoutState : int32_t {
-  FORCED_REDRAW_UNSPECIFIED = 0,
-  FORCED_REDRAW_IDLE = 1,
-  FORCED_REDRAW_WAITING_FOR_COMMIT = 2,
-  FORCED_REDRAW_WAITING_FOR_ACTIVATION = 3,
-  FORCED_REDRAW_WAITING_FOR_DRAW = 4,
-};
-} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState
-using ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::ForcedRedrawOnTimeoutState;
-
-
-constexpr ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_MIN = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState::FORCED_REDRAW_UNSPECIFIED;
-constexpr ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_MAX = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState::FORCED_REDRAW_WAITING_FOR_DRAW;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_Name(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState::FORCED_REDRAW_UNSPECIFIED:
-    return "FORCED_REDRAW_UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState::FORCED_REDRAW_IDLE:
-    return "FORCED_REDRAW_IDLE";
-
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState::FORCED_REDRAW_WAITING_FOR_COMMIT:
-    return "FORCED_REDRAW_WAITING_FOR_COMMIT";
 
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState::FORCED_REDRAW_WAITING_FOR_ACTIVATION:
-    return "FORCED_REDRAW_WAITING_FOR_ACTIVATION";
+  using FieldMetadata_TimecodeUserbits2 =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufDoneFtraceEvent>;
 
-  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState::FORCED_REDRAW_WAITING_FOR_DRAW:
-    return "FORCED_REDRAW_WAITING_FOR_DRAW";
+  static constexpr FieldMetadata_TimecodeUserbits2 kTimecodeUserbits2{};
+  void set_timecode_userbits2(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits2::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-namespace perfetto_pbzero_enum_ChromeCompositorSchedulerState {
-enum BeginImplFrameDeadlineMode : int32_t {
-  DEADLINE_MODE_UNSPECIFIED = 0,
-  DEADLINE_MODE_NONE = 1,
-  DEADLINE_MODE_IMMEDIATE = 2,
-  DEADLINE_MODE_REGULAR = 3,
-  DEADLINE_MODE_LATE = 4,
-  DEADLINE_MODE_BLOCKED = 5,
-};
-} // namespace perfetto_pbzero_enum_ChromeCompositorSchedulerState
-using ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode = perfetto_pbzero_enum_ChromeCompositorSchedulerState::BeginImplFrameDeadlineMode;
-
-
-constexpr ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_MIN = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_UNSPECIFIED;
-constexpr ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_MAX = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_BLOCKED;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_Name(::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_UNSPECIFIED:
-    return "DEADLINE_MODE_UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_NONE:
-    return "DEADLINE_MODE_NONE";
 
-  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_IMMEDIATE:
-    return "DEADLINE_MODE_IMMEDIATE";
+  using FieldMetadata_TimecodeUserbits3 =
+    ::protozero::proto_utils::FieldMetadata<
+      14,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufDoneFtraceEvent>;
 
-  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_REGULAR:
-    return "DEADLINE_MODE_REGULAR";
+  static constexpr FieldMetadata_TimecodeUserbits3 kTimecodeUserbits3{};
+  void set_timecode_userbits3(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits3::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_LATE:
-    return "DEADLINE_MODE_LATE";
+  using FieldMetadata_Timestamp =
+    ::protozero::proto_utils::FieldMetadata<
+      15,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Vb2V4l2BufDoneFtraceEvent>;
 
-  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_BLOCKED:
-    return "DEADLINE_MODE_BLOCKED";
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+};
 
-class CompositorTimingHistory_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Vb2V4l2BufQueueFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/15> {
  public:
-  CompositorTimingHistory_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit CompositorTimingHistory_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit CompositorTimingHistory_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_begin_main_frame_queue_critical_estimate_delta_us() const { return at<1>().valid(); }
-  int64_t begin_main_frame_queue_critical_estimate_delta_us() const { return at<1>().as_int64(); }
-  bool has_begin_main_frame_queue_not_critical_estimate_delta_us() const { return at<2>().valid(); }
-  int64_t begin_main_frame_queue_not_critical_estimate_delta_us() const { return at<2>().as_int64(); }
-  bool has_begin_main_frame_start_to_ready_to_commit_estimate_delta_us() const { return at<3>().valid(); }
-  int64_t begin_main_frame_start_to_ready_to_commit_estimate_delta_us() const { return at<3>().as_int64(); }
-  bool has_commit_to_ready_to_activate_estimate_delta_us() const { return at<4>().valid(); }
-  int64_t commit_to_ready_to_activate_estimate_delta_us() const { return at<4>().as_int64(); }
-  bool has_prepare_tiles_estimate_delta_us() const { return at<5>().valid(); }
-  int64_t prepare_tiles_estimate_delta_us() const { return at<5>().as_int64(); }
-  bool has_activate_estimate_delta_us() const { return at<6>().valid(); }
-  int64_t activate_estimate_delta_us() const { return at<6>().as_int64(); }
-  bool has_draw_estimate_delta_us() const { return at<7>().valid(); }
-  int64_t draw_estimate_delta_us() const { return at<7>().as_int64(); }
+  Vb2V4l2BufQueueFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Vb2V4l2BufQueueFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Vb2V4l2BufQueueFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_field() const { return at<1>().valid(); }
+  uint32_t field() const { return at<1>().as_uint32(); }
+  bool has_flags() const { return at<2>().valid(); }
+  uint32_t flags() const { return at<2>().as_uint32(); }
+  bool has_minor() const { return at<3>().valid(); }
+  int32_t minor() const { return at<3>().as_int32(); }
+  bool has_sequence() const { return at<4>().valid(); }
+  uint32_t sequence() const { return at<4>().as_uint32(); }
+  bool has_timecode_flags() const { return at<5>().valid(); }
+  uint32_t timecode_flags() const { return at<5>().as_uint32(); }
+  bool has_timecode_frames() const { return at<6>().valid(); }
+  uint32_t timecode_frames() const { return at<6>().as_uint32(); }
+  bool has_timecode_hours() const { return at<7>().valid(); }
+  uint32_t timecode_hours() const { return at<7>().as_uint32(); }
+  bool has_timecode_minutes() const { return at<8>().valid(); }
+  uint32_t timecode_minutes() const { return at<8>().as_uint32(); }
+  bool has_timecode_seconds() const { return at<9>().valid(); }
+  uint32_t timecode_seconds() const { return at<9>().as_uint32(); }
+  bool has_timecode_type() const { return at<10>().valid(); }
+  uint32_t timecode_type() const { return at<10>().as_uint32(); }
+  bool has_timecode_userbits0() const { return at<11>().valid(); }
+  uint32_t timecode_userbits0() const { return at<11>().as_uint32(); }
+  bool has_timecode_userbits1() const { return at<12>().valid(); }
+  uint32_t timecode_userbits1() const { return at<12>().as_uint32(); }
+  bool has_timecode_userbits2() const { return at<13>().valid(); }
+  uint32_t timecode_userbits2() const { return at<13>().as_uint32(); }
+  bool has_timecode_userbits3() const { return at<14>().valid(); }
+  uint32_t timecode_userbits3() const { return at<14>().as_uint32(); }
+  bool has_timestamp() const { return at<15>().valid(); }
+  int64_t timestamp() const { return at<15>().as_int64(); }
 };
 
-class CompositorTimingHistory : public ::protozero::Message {
+class Vb2V4l2BufQueueFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = CompositorTimingHistory_Decoder;
+  using Decoder = Vb2V4l2BufQueueFtraceEvent_Decoder;
   enum : int32_t {
-    kBeginMainFrameQueueCriticalEstimateDeltaUsFieldNumber = 1,
-    kBeginMainFrameQueueNotCriticalEstimateDeltaUsFieldNumber = 2,
-    kBeginMainFrameStartToReadyToCommitEstimateDeltaUsFieldNumber = 3,
-    kCommitToReadyToActivateEstimateDeltaUsFieldNumber = 4,
-    kPrepareTilesEstimateDeltaUsFieldNumber = 5,
-    kActivateEstimateDeltaUsFieldNumber = 6,
-    kDrawEstimateDeltaUsFieldNumber = 7,
+    kFieldFieldNumber = 1,
+    kFlagsFieldNumber = 2,
+    kMinorFieldNumber = 3,
+    kSequenceFieldNumber = 4,
+    kTimecodeFlagsFieldNumber = 5,
+    kTimecodeFramesFieldNumber = 6,
+    kTimecodeHoursFieldNumber = 7,
+    kTimecodeMinutesFieldNumber = 8,
+    kTimecodeSecondsFieldNumber = 9,
+    kTimecodeTypeFieldNumber = 10,
+    kTimecodeUserbits0FieldNumber = 11,
+    kTimecodeUserbits1FieldNumber = 12,
+    kTimecodeUserbits2FieldNumber = 13,
+    kTimecodeUserbits3FieldNumber = 14,
+    kTimestampFieldNumber = 15,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.CompositorTimingHistory"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Vb2V4l2BufQueueFtraceEvent"; }
 
 
-  using FieldMetadata_BeginMainFrameQueueCriticalEstimateDeltaUs =
+  using FieldMetadata_Field =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      CompositorTimingHistory>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BeginMainFrameQueueCriticalEstimateDeltaUs kBeginMainFrameQueueCriticalEstimateDeltaUs() { return {}; }
-  void set_begin_main_frame_queue_critical_estimate_delta_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BeginMainFrameQueueCriticalEstimateDeltaUs::kFieldId;
+  static constexpr FieldMetadata_Field kField{};
+  void set_field(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Field::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BeginMainFrameQueueNotCriticalEstimateDeltaUs =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      CompositorTimingHistory>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BeginMainFrameQueueNotCriticalEstimateDeltaUs kBeginMainFrameQueueNotCriticalEstimateDeltaUs() { return {}; }
-  void set_begin_main_frame_queue_not_critical_estimate_delta_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BeginMainFrameQueueNotCriticalEstimateDeltaUs::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BeginMainFrameStartToReadyToCommitEstimateDeltaUs =
+  using FieldMetadata_Minor =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      CompositorTimingHistory>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      Vb2V4l2BufQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BeginMainFrameStartToReadyToCommitEstimateDeltaUs kBeginMainFrameStartToReadyToCommitEstimateDeltaUs() { return {}; }
-  void set_begin_main_frame_start_to_ready_to_commit_estimate_delta_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BeginMainFrameStartToReadyToCommitEstimateDeltaUs::kFieldId;
+  static constexpr FieldMetadata_Minor kMinor{};
+  void set_minor(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Minor::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CommitToReadyToActivateEstimateDeltaUs =
+  using FieldMetadata_Sequence =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      CompositorTimingHistory>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CommitToReadyToActivateEstimateDeltaUs kCommitToReadyToActivateEstimateDeltaUs() { return {}; }
-  void set_commit_to_ready_to_activate_estimate_delta_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CommitToReadyToActivateEstimateDeltaUs::kFieldId;
+  static constexpr FieldMetadata_Sequence kSequence{};
+  void set_sequence(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Sequence::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PrepareTilesEstimateDeltaUs =
+  using FieldMetadata_TimecodeFlags =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      CompositorTimingHistory>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PrepareTilesEstimateDeltaUs kPrepareTilesEstimateDeltaUs() { return {}; }
-  void set_prepare_tiles_estimate_delta_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PrepareTilesEstimateDeltaUs::kFieldId;
+  static constexpr FieldMetadata_TimecodeFlags kTimecodeFlags{};
+  void set_timecode_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeFlags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ActivateEstimateDeltaUs =
+  using FieldMetadata_TimecodeFrames =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      CompositorTimingHistory>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ActivateEstimateDeltaUs kActivateEstimateDeltaUs() { return {}; }
-  void set_activate_estimate_delta_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ActivateEstimateDeltaUs::kFieldId;
+  static constexpr FieldMetadata_TimecodeFrames kTimecodeFrames{};
+  void set_timecode_frames(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeFrames::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DrawEstimateDeltaUs =
+  using FieldMetadata_TimecodeHours =
     ::protozero::proto_utils::FieldMetadata<
       7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      CompositorTimingHistory>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DrawEstimateDeltaUs kDrawEstimateDeltaUs() { return {}; }
-  void set_draw_estimate_delta_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DrawEstimateDeltaUs::kFieldId;
+  static constexpr FieldMetadata_TimecodeHours kTimecodeHours{};
+  void set_timecode_hours(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeHours::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class BeginFrameSourceState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  BeginFrameSourceState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit BeginFrameSourceState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit BeginFrameSourceState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_source_id() const { return at<1>().valid(); }
-  uint32_t source_id() const { return at<1>().as_uint32(); }
-  bool has_paused() const { return at<2>().valid(); }
-  bool paused() const { return at<2>().as_bool(); }
-  bool has_num_observers() const { return at<3>().valid(); }
-  uint32_t num_observers() const { return at<3>().as_uint32(); }
-  bool has_last_begin_frame_args() const { return at<4>().valid(); }
-  ::protozero::ConstBytes last_begin_frame_args() const { return at<4>().as_bytes(); }
-};
-
-class BeginFrameSourceState : public ::protozero::Message {
- public:
-  using Decoder = BeginFrameSourceState_Decoder;
-  enum : int32_t {
-    kSourceIdFieldNumber = 1,
-    kPausedFieldNumber = 2,
-    kNumObserversFieldNumber = 3,
-    kLastBeginFrameArgsFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.BeginFrameSourceState"; }
 
-
-  using FieldMetadata_SourceId =
+  using FieldMetadata_TimecodeMinutes =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      BeginFrameSourceState>;
+      Vb2V4l2BufQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SourceId kSourceId() { return {}; }
-  void set_source_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SourceId::kFieldId;
+  static constexpr FieldMetadata_TimecodeMinutes kTimecodeMinutes{};
+  void set_timecode_minutes(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeMinutes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -141200,49 +163601,35 @@ class BeginFrameSourceState : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Paused =
+  using FieldMetadata_TimecodeSeconds =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      BeginFrameSourceState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Paused kPaused() { return {}; }
-  void set_paused(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_Paused::kFieldId;
+  static constexpr FieldMetadata_TimecodeSeconds kTimecodeSeconds{};
+  void set_timecode_seconds(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeSeconds::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NumObservers =
+  using FieldMetadata_TimecodeType =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      BeginFrameSourceState>;
+      Vb2V4l2BufQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NumObservers kNumObservers() { return {}; }
-  void set_num_observers(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NumObservers::kFieldId;
+  static constexpr FieldMetadata_TimecodeType kTimecodeType{};
+  void set_timecode_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeType::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -141250,1168 +163637,643 @@ class BeginFrameSourceState : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_LastBeginFrameArgs =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      BeginFrameArgs,
-      BeginFrameSourceState>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LastBeginFrameArgs kLastBeginFrameArgs() { return {}; }
-  template <typename T = BeginFrameArgs> T* set_last_begin_frame_args() {
-    return BeginNestedMessage<T>(4);
-  }
-
-};
-
-class BeginFrameObserverState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  BeginFrameObserverState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit BeginFrameObserverState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit BeginFrameObserverState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dropped_begin_frame_args() const { return at<1>().valid(); }
-  int64_t dropped_begin_frame_args() const { return at<1>().as_int64(); }
-  bool has_last_begin_frame_args() const { return at<2>().valid(); }
-  ::protozero::ConstBytes last_begin_frame_args() const { return at<2>().as_bytes(); }
-};
-
-class BeginFrameObserverState : public ::protozero::Message {
- public:
-  using Decoder = BeginFrameObserverState_Decoder;
-  enum : int32_t {
-    kDroppedBeginFrameArgsFieldNumber = 1,
-    kLastBeginFrameArgsFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.BeginFrameObserverState"; }
-
-
-  using FieldMetadata_DroppedBeginFrameArgs =
+  using FieldMetadata_TimecodeUserbits0 =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      BeginFrameObserverState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DroppedBeginFrameArgs kDroppedBeginFrameArgs() { return {}; }
-  void set_dropped_begin_frame_args(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DroppedBeginFrameArgs::kFieldId;
+  static constexpr FieldMetadata_TimecodeUserbits0 kTimecodeUserbits0{};
+  void set_timecode_userbits0(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits0::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_LastBeginFrameArgs =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      BeginFrameArgs,
-      BeginFrameObserverState>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LastBeginFrameArgs kLastBeginFrameArgs() { return {}; }
-  template <typename T = BeginFrameArgs> T* set_last_begin_frame_args() {
-    return BeginNestedMessage<T>(2);
-  }
-
-};
-
-class BeginImplFrameArgs_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  BeginImplFrameArgs_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit BeginImplFrameArgs_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit BeginImplFrameArgs_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_updated_at_us() const { return at<1>().valid(); }
-  int64_t updated_at_us() const { return at<1>().as_int64(); }
-  bool has_finished_at_us() const { return at<2>().valid(); }
-  int64_t finished_at_us() const { return at<2>().as_int64(); }
-  bool has_state() const { return at<3>().valid(); }
-  int32_t state() const { return at<3>().as_int32(); }
-  bool has_current_args() const { return at<4>().valid(); }
-  ::protozero::ConstBytes current_args() const { return at<4>().as_bytes(); }
-  bool has_last_args() const { return at<5>().valid(); }
-  ::protozero::ConstBytes last_args() const { return at<5>().as_bytes(); }
-  bool has_timestamps_in_us() const { return at<6>().valid(); }
-  ::protozero::ConstBytes timestamps_in_us() const { return at<6>().as_bytes(); }
-};
-
-class BeginImplFrameArgs : public ::protozero::Message {
- public:
-  using Decoder = BeginImplFrameArgs_Decoder;
-  enum : int32_t {
-    kUpdatedAtUsFieldNumber = 1,
-    kFinishedAtUsFieldNumber = 2,
-    kStateFieldNumber = 3,
-    kCurrentArgsFieldNumber = 4,
-    kLastArgsFieldNumber = 5,
-    kTimestampsInUsFieldNumber = 6,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.BeginImplFrameArgs"; }
-
-  using TimestampsInUs = ::perfetto::protos::pbzero::BeginImplFrameArgs_TimestampsInUs;
-
-  using State = ::perfetto::protos::pbzero::BeginImplFrameArgs_State;
-  static inline const char* State_Name(State value) {
-    return ::perfetto::protos::pbzero::BeginImplFrameArgs_State_Name(value);
-  }
-  static const State BEGIN_FRAME_FINISHED = State::BEGIN_FRAME_FINISHED;
-  static const State BEGIN_FRAME_USING = State::BEGIN_FRAME_USING;
-
-  using FieldMetadata_UpdatedAtUs =
+  using FieldMetadata_TimecodeUserbits1 =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      12,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      BeginImplFrameArgs>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UpdatedAtUs kUpdatedAtUs() { return {}; }
-  void set_updated_at_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_UpdatedAtUs::kFieldId;
+  static constexpr FieldMetadata_TimecodeUserbits1 kTimecodeUserbits1{};
+  void set_timecode_userbits1(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits1::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FinishedAtUs =
+  using FieldMetadata_TimecodeUserbits2 =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      13,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      BeginImplFrameArgs>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FinishedAtUs kFinishedAtUs() { return {}; }
-  void set_finished_at_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FinishedAtUs::kFieldId;
+  static constexpr FieldMetadata_TimecodeUserbits2 kTimecodeUserbits2{};
+  void set_timecode_userbits2(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits2::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_State =
+  using FieldMetadata_TimecodeUserbits3 =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      14,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::BeginImplFrameArgs_State,
-      BeginImplFrameArgs>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Vb2V4l2BufQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_State kState() { return {}; }
-  void set_state(::perfetto::protos::pbzero::BeginImplFrameArgs_State value) {
-    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
+  static constexpr FieldMetadata_TimecodeUserbits3 kTimecodeUserbits3{};
+  void set_timecode_userbits3(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits3::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CurrentArgs =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      BeginFrameArgs,
-      BeginImplFrameArgs>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CurrentArgs kCurrentArgs() { return {}; }
-  template <typename T = BeginFrameArgs> T* set_current_args() {
-    return BeginNestedMessage<T>(4);
-  }
-
-
-  using FieldMetadata_LastArgs =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      BeginFrameArgs,
-      BeginImplFrameArgs>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LastArgs kLastArgs() { return {}; }
-  template <typename T = BeginFrameArgs> T* set_last_args() {
-    return BeginNestedMessage<T>(5);
-  }
-
-
-  using FieldMetadata_TimestampsInUs =
+  using FieldMetadata_Timestamp =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      15,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      BeginImplFrameArgs_TimestampsInUs,
-      BeginImplFrameArgs>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      Vb2V4l2BufQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimestampsInUs kTimestampsInUs() { return {}; }
-  template <typename T = BeginImplFrameArgs_TimestampsInUs> T* set_timestamps_in_us() {
-    return BeginNestedMessage<T>(6);
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
   }
-
 };
 
-class BeginImplFrameArgs_TimestampsInUs_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class V4l2DqbufFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/18> {
  public:
-  BeginImplFrameArgs_TimestampsInUs_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit BeginImplFrameArgs_TimestampsInUs_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit BeginImplFrameArgs_TimestampsInUs_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_interval_delta() const { return at<1>().valid(); }
-  int64_t interval_delta() const { return at<1>().as_int64(); }
-  bool has_now_to_deadline_delta() const { return at<2>().valid(); }
-  int64_t now_to_deadline_delta() const { return at<2>().as_int64(); }
-  bool has_frame_time_to_now_delta() const { return at<3>().valid(); }
-  int64_t frame_time_to_now_delta() const { return at<3>().as_int64(); }
-  bool has_frame_time_to_deadline_delta() const { return at<4>().valid(); }
-  int64_t frame_time_to_deadline_delta() const { return at<4>().as_int64(); }
-  bool has_now() const { return at<5>().valid(); }
-  int64_t now() const { return at<5>().as_int64(); }
-  bool has_frame_time() const { return at<6>().valid(); }
-  int64_t frame_time() const { return at<6>().as_int64(); }
-  bool has_deadline() const { return at<7>().valid(); }
-  int64_t deadline() const { return at<7>().as_int64(); }
+  V4l2DqbufFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit V4l2DqbufFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit V4l2DqbufFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_bytesused() const { return at<1>().valid(); }
+  uint32_t bytesused() const { return at<1>().as_uint32(); }
+  bool has_field() const { return at<2>().valid(); }
+  uint32_t field() const { return at<2>().as_uint32(); }
+  bool has_flags() const { return at<3>().valid(); }
+  uint32_t flags() const { return at<3>().as_uint32(); }
+  bool has_index() const { return at<4>().valid(); }
+  uint32_t index() const { return at<4>().as_uint32(); }
+  bool has_minor() const { return at<5>().valid(); }
+  int32_t minor() const { return at<5>().as_int32(); }
+  bool has_sequence() const { return at<6>().valid(); }
+  uint32_t sequence() const { return at<6>().as_uint32(); }
+  bool has_timecode_flags() const { return at<7>().valid(); }
+  uint32_t timecode_flags() const { return at<7>().as_uint32(); }
+  bool has_timecode_frames() const { return at<8>().valid(); }
+  uint32_t timecode_frames() const { return at<8>().as_uint32(); }
+  bool has_timecode_hours() const { return at<9>().valid(); }
+  uint32_t timecode_hours() const { return at<9>().as_uint32(); }
+  bool has_timecode_minutes() const { return at<10>().valid(); }
+  uint32_t timecode_minutes() const { return at<10>().as_uint32(); }
+  bool has_timecode_seconds() const { return at<11>().valid(); }
+  uint32_t timecode_seconds() const { return at<11>().as_uint32(); }
+  bool has_timecode_type() const { return at<12>().valid(); }
+  uint32_t timecode_type() const { return at<12>().as_uint32(); }
+  bool has_timecode_userbits0() const { return at<13>().valid(); }
+  uint32_t timecode_userbits0() const { return at<13>().as_uint32(); }
+  bool has_timecode_userbits1() const { return at<14>().valid(); }
+  uint32_t timecode_userbits1() const { return at<14>().as_uint32(); }
+  bool has_timecode_userbits2() const { return at<15>().valid(); }
+  uint32_t timecode_userbits2() const { return at<15>().as_uint32(); }
+  bool has_timecode_userbits3() const { return at<16>().valid(); }
+  uint32_t timecode_userbits3() const { return at<16>().as_uint32(); }
+  bool has_timestamp() const { return at<17>().valid(); }
+  int64_t timestamp() const { return at<17>().as_int64(); }
+  bool has_type() const { return at<18>().valid(); }
+  uint32_t type() const { return at<18>().as_uint32(); }
 };
 
-class BeginImplFrameArgs_TimestampsInUs : public ::protozero::Message {
+class V4l2DqbufFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = BeginImplFrameArgs_TimestampsInUs_Decoder;
+  using Decoder = V4l2DqbufFtraceEvent_Decoder;
   enum : int32_t {
-    kIntervalDeltaFieldNumber = 1,
-    kNowToDeadlineDeltaFieldNumber = 2,
-    kFrameTimeToNowDeltaFieldNumber = 3,
-    kFrameTimeToDeadlineDeltaFieldNumber = 4,
-    kNowFieldNumber = 5,
-    kFrameTimeFieldNumber = 6,
-    kDeadlineFieldNumber = 7,
+    kBytesusedFieldNumber = 1,
+    kFieldFieldNumber = 2,
+    kFlagsFieldNumber = 3,
+    kIndexFieldNumber = 4,
+    kMinorFieldNumber = 5,
+    kSequenceFieldNumber = 6,
+    kTimecodeFlagsFieldNumber = 7,
+    kTimecodeFramesFieldNumber = 8,
+    kTimecodeHoursFieldNumber = 9,
+    kTimecodeMinutesFieldNumber = 10,
+    kTimecodeSecondsFieldNumber = 11,
+    kTimecodeTypeFieldNumber = 12,
+    kTimecodeUserbits0FieldNumber = 13,
+    kTimecodeUserbits1FieldNumber = 14,
+    kTimecodeUserbits2FieldNumber = 15,
+    kTimecodeUserbits3FieldNumber = 16,
+    kTimestampFieldNumber = 17,
+    kTypeFieldNumber = 18,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.BeginImplFrameArgs.TimestampsInUs"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.V4l2DqbufFtraceEvent"; }
 
 
-  using FieldMetadata_IntervalDelta =
+  using FieldMetadata_Bytesused =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      BeginImplFrameArgs_TimestampsInUs>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IntervalDelta kIntervalDelta() { return {}; }
-  void set_interval_delta(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IntervalDelta::kFieldId;
+  static constexpr FieldMetadata_Bytesused kBytesused{};
+  void set_bytesused(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Bytesused::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NowToDeadlineDelta =
+  using FieldMetadata_Field =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      BeginImplFrameArgs_TimestampsInUs>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NowToDeadlineDelta kNowToDeadlineDelta() { return {}; }
-  void set_now_to_deadline_delta(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NowToDeadlineDelta::kFieldId;
+  static constexpr FieldMetadata_Field kField{};
+  void set_field(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Field::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FrameTimeToNowDelta =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      BeginImplFrameArgs_TimestampsInUs>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FrameTimeToNowDelta kFrameTimeToNowDelta() { return {}; }
-  void set_frame_time_to_now_delta(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FrameTimeToNowDelta::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FrameTimeToDeadlineDelta =
+  using FieldMetadata_Index =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      BeginImplFrameArgs_TimestampsInUs>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FrameTimeToDeadlineDelta kFrameTimeToDeadlineDelta() { return {}; }
-  void set_frame_time_to_deadline_delta(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FrameTimeToDeadlineDelta::kFieldId;
+  static constexpr FieldMetadata_Index kIndex{};
+  void set_index(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Now =
+  using FieldMetadata_Minor =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      BeginImplFrameArgs_TimestampsInUs>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Now kNow() { return {}; }
-  void set_now(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Now::kFieldId;
+  static constexpr FieldMetadata_Minor kMinor{};
+  void set_minor(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Minor::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FrameTime =
+  using FieldMetadata_Sequence =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      BeginImplFrameArgs_TimestampsInUs>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FrameTime kFrameTime() { return {}; }
-  void set_frame_time(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FrameTime::kFieldId;
+  static constexpr FieldMetadata_Sequence kSequence{};
+  void set_sequence(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Sequence::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Deadline =
+  using FieldMetadata_TimecodeFlags =
     ::protozero::proto_utils::FieldMetadata<
       7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      BeginImplFrameArgs_TimestampsInUs>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Deadline kDeadline() { return {}; }
-  void set_deadline(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Deadline::kFieldId;
+  static constexpr FieldMetadata_TimecodeFlags kTimecodeFlags{};
+  void set_timecode_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeFlags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-class BeginFrameArgs_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/12, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  BeginFrameArgs_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit BeginFrameArgs_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit BeginFrameArgs_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_type() const { return at<1>().valid(); }
-  int32_t type() const { return at<1>().as_int32(); }
-  bool has_source_id() const { return at<2>().valid(); }
-  uint64_t source_id() const { return at<2>().as_uint64(); }
-  bool has_sequence_number() const { return at<3>().valid(); }
-  uint64_t sequence_number() const { return at<3>().as_uint64(); }
-  bool has_frame_time_us() const { return at<4>().valid(); }
-  int64_t frame_time_us() const { return at<4>().as_int64(); }
-  bool has_deadline_us() const { return at<5>().valid(); }
-  int64_t deadline_us() const { return at<5>().as_int64(); }
-  bool has_interval_delta_us() const { return at<6>().valid(); }
-  int64_t interval_delta_us() const { return at<6>().as_int64(); }
-  bool has_on_critical_path() const { return at<7>().valid(); }
-  bool on_critical_path() const { return at<7>().as_bool(); }
-  bool has_animate_only() const { return at<8>().valid(); }
-  bool animate_only() const { return at<8>().as_bool(); }
-  bool has_source_location_iid() const { return at<9>().valid(); }
-  uint64_t source_location_iid() const { return at<9>().as_uint64(); }
-  bool has_source_location() const { return at<10>().valid(); }
-  ::protozero::ConstBytes source_location() const { return at<10>().as_bytes(); }
-  bool has_frames_throttled_since_last() const { return at<12>().valid(); }
-  int64_t frames_throttled_since_last() const { return at<12>().as_int64(); }
-};
-
-class BeginFrameArgs : public ::protozero::Message {
- public:
-  using Decoder = BeginFrameArgs_Decoder;
-  enum : int32_t {
-    kTypeFieldNumber = 1,
-    kSourceIdFieldNumber = 2,
-    kSequenceNumberFieldNumber = 3,
-    kFrameTimeUsFieldNumber = 4,
-    kDeadlineUsFieldNumber = 5,
-    kIntervalDeltaUsFieldNumber = 6,
-    kOnCriticalPathFieldNumber = 7,
-    kAnimateOnlyFieldNumber = 8,
-    kSourceLocationIidFieldNumber = 9,
-    kSourceLocationFieldNumber = 10,
-    kFramesThrottledSinceLastFieldNumber = 12,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.BeginFrameArgs"; }
-
-
-  using BeginFrameArgsType = ::perfetto::protos::pbzero::BeginFrameArgs_BeginFrameArgsType;
-  static inline const char* BeginFrameArgsType_Name(BeginFrameArgsType value) {
-    return ::perfetto::protos::pbzero::BeginFrameArgs_BeginFrameArgsType_Name(value);
-  }
-  static const BeginFrameArgsType BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED = BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED;
-  static const BeginFrameArgsType BEGIN_FRAME_ARGS_TYPE_INVALID = BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_INVALID;
-  static const BeginFrameArgsType BEGIN_FRAME_ARGS_TYPE_NORMAL = BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_NORMAL;
-  static const BeginFrameArgsType BEGIN_FRAME_ARGS_TYPE_MISSED = BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_MISSED;
 
-  using FieldMetadata_Type =
+  using FieldMetadata_TimecodeFrames =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::BeginFrameArgs_BeginFrameArgsType,
-      BeginFrameArgs>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(::perfetto::protos::pbzero::BeginFrameArgs_BeginFrameArgsType value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+  static constexpr FieldMetadata_TimecodeFrames kTimecodeFrames{};
+  void set_timecode_frames(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeFrames::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SourceId =
+  using FieldMetadata_TimecodeHours =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      BeginFrameArgs>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SourceId kSourceId() { return {}; }
-  void set_source_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SourceId::kFieldId;
+  static constexpr FieldMetadata_TimecodeHours kTimecodeHours{};
+  void set_timecode_hours(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeHours::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SequenceNumber =
+  using FieldMetadata_TimecodeMinutes =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      BeginFrameArgs>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SequenceNumber kSequenceNumber() { return {}; }
-  void set_sequence_number(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SequenceNumber::kFieldId;
+  static constexpr FieldMetadata_TimecodeMinutes kTimecodeMinutes{};
+  void set_timecode_minutes(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeMinutes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FrameTimeUs =
+  using FieldMetadata_TimecodeSeconds =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      BeginFrameArgs>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FrameTimeUs kFrameTimeUs() { return {}; }
-  void set_frame_time_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FrameTimeUs::kFieldId;
+  static constexpr FieldMetadata_TimecodeSeconds kTimecodeSeconds{};
+  void set_timecode_seconds(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeSeconds::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DeadlineUs =
+  using FieldMetadata_TimecodeType =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      12,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      BeginFrameArgs>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DeadlineUs kDeadlineUs() { return {}; }
-  void set_deadline_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DeadlineUs::kFieldId;
+  static constexpr FieldMetadata_TimecodeType kTimecodeType{};
+  void set_timecode_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeType::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IntervalDeltaUs =
+  using FieldMetadata_TimecodeUserbits0 =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      13,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      BeginFrameArgs>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IntervalDeltaUs kIntervalDeltaUs() { return {}; }
-  void set_interval_delta_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IntervalDeltaUs::kFieldId;
+  static constexpr FieldMetadata_TimecodeUserbits0 kTimecodeUserbits0{};
+  void set_timecode_userbits0(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits0::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_OnCriticalPath =
+  using FieldMetadata_TimecodeUserbits1 =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      14,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      BeginFrameArgs>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OnCriticalPath kOnCriticalPath() { return {}; }
-  void set_on_critical_path(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_OnCriticalPath::kFieldId;
+  static constexpr FieldMetadata_TimecodeUserbits1 kTimecodeUserbits1{};
+  void set_timecode_userbits1(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits1::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_AnimateOnly =
+  using FieldMetadata_TimecodeUserbits2 =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      15,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      BeginFrameArgs>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AnimateOnly kAnimateOnly() { return {}; }
-  void set_animate_only(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_AnimateOnly::kFieldId;
+  static constexpr FieldMetadata_TimecodeUserbits2 kTimecodeUserbits2{};
+  void set_timecode_userbits2(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits2::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SourceLocationIid =
+  using FieldMetadata_TimecodeUserbits3 =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      16,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      BeginFrameArgs>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SourceLocationIid kSourceLocationIid() { return {}; }
-  void set_source_location_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SourceLocationIid::kFieldId;
+  static constexpr FieldMetadata_TimecodeUserbits3 kTimecodeUserbits3{};
+  void set_timecode_userbits3(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits3::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SourceLocation =
-    ::protozero::proto_utils::FieldMetadata<
-      10,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      SourceLocation,
-      BeginFrameArgs>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SourceLocation kSourceLocation() { return {}; }
-  template <typename T = SourceLocation> T* set_source_location() {
-    return BeginNestedMessage<T>(10);
-  }
-
-
-  using FieldMetadata_FramesThrottledSinceLast =
+  using FieldMetadata_Timestamp =
     ::protozero::proto_utils::FieldMetadata<
-      12,
+      17,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt64,
       int64_t,
-      BeginFrameArgs>;
+      V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FramesThrottledSinceLast kFramesThrottledSinceLast() { return {}; }
-  void set_frames_throttled_since_last(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FramesThrottledSinceLast::kFieldId;
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
-};
-
-class ChromeCompositorStateMachine_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  ChromeCompositorStateMachine_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeCompositorStateMachine_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeCompositorStateMachine_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_major_state() const { return at<1>().valid(); }
-  ::protozero::ConstBytes major_state() const { return at<1>().as_bytes(); }
-  bool has_minor_state() const { return at<2>().valid(); }
-  ::protozero::ConstBytes minor_state() const { return at<2>().as_bytes(); }
-};
-
-class ChromeCompositorStateMachine : public ::protozero::Message {
- public:
-  using Decoder = ChromeCompositorStateMachine_Decoder;
-  enum : int32_t {
-    kMajorStateFieldNumber = 1,
-    kMinorStateFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeCompositorStateMachine"; }
-
-  using MajorState = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState;
-  using MinorState = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState;
-
-  using FieldMetadata_MajorState =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeCompositorStateMachine_MajorState,
-      ChromeCompositorStateMachine>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MajorState kMajorState() { return {}; }
-  template <typename T = ChromeCompositorStateMachine_MajorState> T* set_major_state() {
-    return BeginNestedMessage<T>(1);
-  }
-
 
-  using FieldMetadata_MinorState =
+  using FieldMetadata_Type =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      18,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeCompositorStateMachine_MinorState,
-      ChromeCompositorStateMachine>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2DqbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MinorState kMinorState() { return {}; }
-  template <typename T = ChromeCompositorStateMachine_MinorState> T* set_minor_state() {
-    return BeginNestedMessage<T>(2);
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
-
 };
 
-class ChromeCompositorStateMachine_MinorState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/46, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class V4l2QbufFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/18> {
  public:
-  ChromeCompositorStateMachine_MinorState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeCompositorStateMachine_MinorState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeCompositorStateMachine_MinorState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_commit_count() const { return at<1>().valid(); }
-  int32_t commit_count() const { return at<1>().as_int32(); }
-  bool has_current_frame_number() const { return at<2>().valid(); }
-  int32_t current_frame_number() const { return at<2>().as_int32(); }
-  bool has_last_frame_number_submit_performed() const { return at<3>().valid(); }
-  int32_t last_frame_number_submit_performed() const { return at<3>().as_int32(); }
-  bool has_last_frame_number_draw_performed() const { return at<4>().valid(); }
-  int32_t last_frame_number_draw_performed() const { return at<4>().as_int32(); }
-  bool has_last_frame_number_begin_main_frame_sent() const { return at<5>().valid(); }
-  int32_t last_frame_number_begin_main_frame_sent() const { return at<5>().as_int32(); }
-  bool has_did_draw() const { return at<6>().valid(); }
-  bool did_draw() const { return at<6>().as_bool(); }
-  bool has_did_send_begin_main_frame_for_current_frame() const { return at<7>().valid(); }
-  bool did_send_begin_main_frame_for_current_frame() const { return at<7>().as_bool(); }
-  bool has_did_notify_begin_main_frame_not_expected_until() const { return at<8>().valid(); }
-  bool did_notify_begin_main_frame_not_expected_until() const { return at<8>().as_bool(); }
-  bool has_did_notify_begin_main_frame_not_expected_soon() const { return at<9>().valid(); }
-  bool did_notify_begin_main_frame_not_expected_soon() const { return at<9>().as_bool(); }
-  bool has_wants_begin_main_frame_not_expected() const { return at<10>().valid(); }
-  bool wants_begin_main_frame_not_expected() const { return at<10>().as_bool(); }
-  bool has_did_commit_during_frame() const { return at<11>().valid(); }
-  bool did_commit_during_frame() const { return at<11>().as_bool(); }
-  bool has_did_invalidate_layer_tree_frame_sink() const { return at<12>().valid(); }
-  bool did_invalidate_layer_tree_frame_sink() const { return at<12>().as_bool(); }
-  bool has_did_perform_impl_side_invalidaion() const { return at<13>().valid(); }
-  bool did_perform_impl_side_invalidaion() const { return at<13>().as_bool(); }
-  bool has_did_prepare_tiles() const { return at<14>().valid(); }
-  bool did_prepare_tiles() const { return at<14>().as_bool(); }
-  bool has_consecutive_checkerboard_animations() const { return at<15>().valid(); }
-  int32_t consecutive_checkerboard_animations() const { return at<15>().as_int32(); }
-  bool has_pending_submit_frames() const { return at<16>().valid(); }
-  int32_t pending_submit_frames() const { return at<16>().as_int32(); }
-  bool has_submit_frames_with_current_layer_tree_frame_sink() const { return at<17>().valid(); }
-  int32_t submit_frames_with_current_layer_tree_frame_sink() const { return at<17>().as_int32(); }
-  bool has_needs_redraw() const { return at<18>().valid(); }
-  bool needs_redraw() const { return at<18>().as_bool(); }
-  bool has_needs_prepare_tiles() const { return at<19>().valid(); }
-  bool needs_prepare_tiles() const { return at<19>().as_bool(); }
-  bool has_needs_begin_main_frame() const { return at<20>().valid(); }
-  bool needs_begin_main_frame() const { return at<20>().as_bool(); }
-  bool has_needs_one_begin_impl_frame() const { return at<21>().valid(); }
-  bool needs_one_begin_impl_frame() const { return at<21>().as_bool(); }
-  bool has_visible() const { return at<22>().valid(); }
-  bool visible() const { return at<22>().as_bool(); }
-  bool has_begin_frame_source_paused() const { return at<23>().valid(); }
-  bool begin_frame_source_paused() const { return at<23>().as_bool(); }
-  bool has_can_draw() const { return at<24>().valid(); }
-  bool can_draw() const { return at<24>().as_bool(); }
-  bool has_resourceless_draw() const { return at<25>().valid(); }
-  bool resourceless_draw() const { return at<25>().as_bool(); }
-  bool has_has_pending_tree() const { return at<26>().valid(); }
-  bool has_pending_tree() const { return at<26>().as_bool(); }
-  bool has_pending_tree_is_ready_for_activation() const { return at<27>().valid(); }
-  bool pending_tree_is_ready_for_activation() const { return at<27>().as_bool(); }
-  bool has_active_tree_needs_first_draw() const { return at<28>().valid(); }
-  bool active_tree_needs_first_draw() const { return at<28>().as_bool(); }
-  bool has_active_tree_is_ready_to_draw() const { return at<29>().valid(); }
-  bool active_tree_is_ready_to_draw() const { return at<29>().as_bool(); }
-  bool has_did_create_and_initialize_first_layer_tree_frame_sink() const { return at<30>().valid(); }
-  bool did_create_and_initialize_first_layer_tree_frame_sink() const { return at<30>().as_bool(); }
-  bool has_tree_priority() const { return at<31>().valid(); }
-  int32_t tree_priority() const { return at<31>().as_int32(); }
-  bool has_scroll_handler_state() const { return at<32>().valid(); }
-  int32_t scroll_handler_state() const { return at<32>().as_int32(); }
-  bool has_critical_begin_main_frame_to_activate_is_fast() const { return at<33>().valid(); }
-  bool critical_begin_main_frame_to_activate_is_fast() const { return at<33>().as_bool(); }
-  bool has_main_thread_missed_last_deadline() const { return at<34>().valid(); }
-  bool main_thread_missed_last_deadline() const { return at<34>().as_bool(); }
-  bool has_video_needs_begin_frames() const { return at<36>().valid(); }
-  bool video_needs_begin_frames() const { return at<36>().as_bool(); }
-  bool has_defer_begin_main_frame() const { return at<37>().valid(); }
-  bool defer_begin_main_frame() const { return at<37>().as_bool(); }
-  bool has_last_commit_had_no_updates() const { return at<38>().valid(); }
-  bool last_commit_had_no_updates() const { return at<38>().as_bool(); }
-  bool has_did_draw_in_last_frame() const { return at<39>().valid(); }
-  bool did_draw_in_last_frame() const { return at<39>().as_bool(); }
-  bool has_did_submit_in_last_frame() const { return at<40>().valid(); }
-  bool did_submit_in_last_frame() const { return at<40>().as_bool(); }
-  bool has_needs_impl_side_invalidation() const { return at<41>().valid(); }
-  bool needs_impl_side_invalidation() const { return at<41>().as_bool(); }
-  bool has_current_pending_tree_is_impl_side() const { return at<42>().valid(); }
-  bool current_pending_tree_is_impl_side() const { return at<42>().as_bool(); }
-  bool has_previous_pending_tree_was_impl_side() const { return at<43>().valid(); }
-  bool previous_pending_tree_was_impl_side() const { return at<43>().as_bool(); }
-  bool has_processing_animation_worklets_for_active_tree() const { return at<44>().valid(); }
-  bool processing_animation_worklets_for_active_tree() const { return at<44>().as_bool(); }
-  bool has_processing_animation_worklets_for_pending_tree() const { return at<45>().valid(); }
-  bool processing_animation_worklets_for_pending_tree() const { return at<45>().as_bool(); }
-  bool has_processing_paint_worklets_for_pending_tree() const { return at<46>().valid(); }
-  bool processing_paint_worklets_for_pending_tree() const { return at<46>().as_bool(); }
+  V4l2QbufFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit V4l2QbufFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit V4l2QbufFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_bytesused() const { return at<1>().valid(); }
+  uint32_t bytesused() const { return at<1>().as_uint32(); }
+  bool has_field() const { return at<2>().valid(); }
+  uint32_t field() const { return at<2>().as_uint32(); }
+  bool has_flags() const { return at<3>().valid(); }
+  uint32_t flags() const { return at<3>().as_uint32(); }
+  bool has_index() const { return at<4>().valid(); }
+  uint32_t index() const { return at<4>().as_uint32(); }
+  bool has_minor() const { return at<5>().valid(); }
+  int32_t minor() const { return at<5>().as_int32(); }
+  bool has_sequence() const { return at<6>().valid(); }
+  uint32_t sequence() const { return at<6>().as_uint32(); }
+  bool has_timecode_flags() const { return at<7>().valid(); }
+  uint32_t timecode_flags() const { return at<7>().as_uint32(); }
+  bool has_timecode_frames() const { return at<8>().valid(); }
+  uint32_t timecode_frames() const { return at<8>().as_uint32(); }
+  bool has_timecode_hours() const { return at<9>().valid(); }
+  uint32_t timecode_hours() const { return at<9>().as_uint32(); }
+  bool has_timecode_minutes() const { return at<10>().valid(); }
+  uint32_t timecode_minutes() const { return at<10>().as_uint32(); }
+  bool has_timecode_seconds() const { return at<11>().valid(); }
+  uint32_t timecode_seconds() const { return at<11>().as_uint32(); }
+  bool has_timecode_type() const { return at<12>().valid(); }
+  uint32_t timecode_type() const { return at<12>().as_uint32(); }
+  bool has_timecode_userbits0() const { return at<13>().valid(); }
+  uint32_t timecode_userbits0() const { return at<13>().as_uint32(); }
+  bool has_timecode_userbits1() const { return at<14>().valid(); }
+  uint32_t timecode_userbits1() const { return at<14>().as_uint32(); }
+  bool has_timecode_userbits2() const { return at<15>().valid(); }
+  uint32_t timecode_userbits2() const { return at<15>().as_uint32(); }
+  bool has_timecode_userbits3() const { return at<16>().valid(); }
+  uint32_t timecode_userbits3() const { return at<16>().as_uint32(); }
+  bool has_timestamp() const { return at<17>().valid(); }
+  int64_t timestamp() const { return at<17>().as_int64(); }
+  bool has_type() const { return at<18>().valid(); }
+  uint32_t type() const { return at<18>().as_uint32(); }
 };
 
-class ChromeCompositorStateMachine_MinorState : public ::protozero::Message {
+class V4l2QbufFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = ChromeCompositorStateMachine_MinorState_Decoder;
+  using Decoder = V4l2QbufFtraceEvent_Decoder;
   enum : int32_t {
-    kCommitCountFieldNumber = 1,
-    kCurrentFrameNumberFieldNumber = 2,
-    kLastFrameNumberSubmitPerformedFieldNumber = 3,
-    kLastFrameNumberDrawPerformedFieldNumber = 4,
-    kLastFrameNumberBeginMainFrameSentFieldNumber = 5,
-    kDidDrawFieldNumber = 6,
-    kDidSendBeginMainFrameForCurrentFrameFieldNumber = 7,
-    kDidNotifyBeginMainFrameNotExpectedUntilFieldNumber = 8,
-    kDidNotifyBeginMainFrameNotExpectedSoonFieldNumber = 9,
-    kWantsBeginMainFrameNotExpectedFieldNumber = 10,
-    kDidCommitDuringFrameFieldNumber = 11,
-    kDidInvalidateLayerTreeFrameSinkFieldNumber = 12,
-    kDidPerformImplSideInvalidaionFieldNumber = 13,
-    kDidPrepareTilesFieldNumber = 14,
-    kConsecutiveCheckerboardAnimationsFieldNumber = 15,
-    kPendingSubmitFramesFieldNumber = 16,
-    kSubmitFramesWithCurrentLayerTreeFrameSinkFieldNumber = 17,
-    kNeedsRedrawFieldNumber = 18,
-    kNeedsPrepareTilesFieldNumber = 19,
-    kNeedsBeginMainFrameFieldNumber = 20,
-    kNeedsOneBeginImplFrameFieldNumber = 21,
-    kVisibleFieldNumber = 22,
-    kBeginFrameSourcePausedFieldNumber = 23,
-    kCanDrawFieldNumber = 24,
-    kResourcelessDrawFieldNumber = 25,
-    kHasPendingTreeFieldNumber = 26,
-    kPendingTreeIsReadyForActivationFieldNumber = 27,
-    kActiveTreeNeedsFirstDrawFieldNumber = 28,
-    kActiveTreeIsReadyToDrawFieldNumber = 29,
-    kDidCreateAndInitializeFirstLayerTreeFrameSinkFieldNumber = 30,
-    kTreePriorityFieldNumber = 31,
-    kScrollHandlerStateFieldNumber = 32,
-    kCriticalBeginMainFrameToActivateIsFastFieldNumber = 33,
-    kMainThreadMissedLastDeadlineFieldNumber = 34,
-    kVideoNeedsBeginFramesFieldNumber = 36,
-    kDeferBeginMainFrameFieldNumber = 37,
-    kLastCommitHadNoUpdatesFieldNumber = 38,
-    kDidDrawInLastFrameFieldNumber = 39,
-    kDidSubmitInLastFrameFieldNumber = 40,
-    kNeedsImplSideInvalidationFieldNumber = 41,
-    kCurrentPendingTreeIsImplSideFieldNumber = 42,
-    kPreviousPendingTreeWasImplSideFieldNumber = 43,
-    kProcessingAnimationWorkletsForActiveTreeFieldNumber = 44,
-    kProcessingAnimationWorkletsForPendingTreeFieldNumber = 45,
-    kProcessingPaintWorkletsForPendingTreeFieldNumber = 46,
+    kBytesusedFieldNumber = 1,
+    kFieldFieldNumber = 2,
+    kFlagsFieldNumber = 3,
+    kIndexFieldNumber = 4,
+    kMinorFieldNumber = 5,
+    kSequenceFieldNumber = 6,
+    kTimecodeFlagsFieldNumber = 7,
+    kTimecodeFramesFieldNumber = 8,
+    kTimecodeHoursFieldNumber = 9,
+    kTimecodeMinutesFieldNumber = 10,
+    kTimecodeSecondsFieldNumber = 11,
+    kTimecodeTypeFieldNumber = 12,
+    kTimecodeUserbits0FieldNumber = 13,
+    kTimecodeUserbits1FieldNumber = 14,
+    kTimecodeUserbits2FieldNumber = 15,
+    kTimecodeUserbits3FieldNumber = 16,
+    kTimestampFieldNumber = 17,
+    kTypeFieldNumber = 18,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeCompositorStateMachine.MinorState"; }
-
-
-  using TreePriority = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_TreePriority;
-  static inline const char* TreePriority_Name(TreePriority value) {
-    return ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_TreePriority_Name(value);
-  }
+  static constexpr const char* GetName() { return ".perfetto.protos.V4l2QbufFtraceEvent"; }
 
-  using ScrollHandlerState = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_ScrollHandlerState;
-  static inline const char* ScrollHandlerState_Name(ScrollHandlerState value) {
-    return ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_ScrollHandlerState_Name(value);
-  }
-  static const TreePriority TREE_PRIORITY_UNSPECIFIED = TreePriority::TREE_PRIORITY_UNSPECIFIED;
-  static const TreePriority TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES = TreePriority::TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES;
-  static const TreePriority TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY = TreePriority::TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY;
-  static const TreePriority TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY = TreePriority::TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY;
-  static const ScrollHandlerState SCROLL_HANDLER_UNSPECIFIED = ScrollHandlerState::SCROLL_HANDLER_UNSPECIFIED;
-  static const ScrollHandlerState SCROLL_AFFECTS_SCROLL_HANDLER = ScrollHandlerState::SCROLL_AFFECTS_SCROLL_HANDLER;
-  static const ScrollHandlerState SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER = ScrollHandlerState::SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER;
 
-  using FieldMetadata_CommitCount =
+  using FieldMetadata_Bytesused =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CommitCount kCommitCount() { return {}; }
-  void set_commit_count(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CommitCount::kFieldId;
+  static constexpr FieldMetadata_Bytesused kBytesused{};
+  void set_bytesused(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Bytesused::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CurrentFrameNumber =
+  using FieldMetadata_Field =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CurrentFrameNumber kCurrentFrameNumber() { return {}; }
-  void set_current_frame_number(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CurrentFrameNumber::kFieldId;
+  static constexpr FieldMetadata_Field kField{};
+  void set_field(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Field::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_LastFrameNumberSubmitPerformed =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LastFrameNumberSubmitPerformed kLastFrameNumberSubmitPerformed() { return {}; }
-  void set_last_frame_number_submit_performed(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LastFrameNumberSubmitPerformed::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_LastFrameNumberDrawPerformed =
+  using FieldMetadata_Index =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LastFrameNumberDrawPerformed kLastFrameNumberDrawPerformed() { return {}; }
-  void set_last_frame_number_draw_performed(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LastFrameNumberDrawPerformed::kFieldId;
+  static constexpr FieldMetadata_Index kIndex{};
+  void set_index(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_LastFrameNumberBeginMainFrameSent =
+  using FieldMetadata_Minor =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      ChromeCompositorStateMachine_MinorState>;
+      V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LastFrameNumberBeginMainFrameSent kLastFrameNumberBeginMainFrameSent() { return {}; }
-  void set_last_frame_number_begin_main_frame_sent(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LastFrameNumberBeginMainFrameSent::kFieldId;
+  static constexpr FieldMetadata_Minor kMinor{};
+  void set_minor(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Minor::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -142419,299 +164281,336 @@ class ChromeCompositorStateMachine_MinorState : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DidDraw =
+  using FieldMetadata_Sequence =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DidDraw kDidDraw() { return {}; }
-  void set_did_draw(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DidDraw::kFieldId;
+  static constexpr FieldMetadata_Sequence kSequence{};
+  void set_sequence(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Sequence::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DidSendBeginMainFrameForCurrentFrame =
+  using FieldMetadata_TimecodeFlags =
     ::protozero::proto_utils::FieldMetadata<
       7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DidSendBeginMainFrameForCurrentFrame kDidSendBeginMainFrameForCurrentFrame() { return {}; }
-  void set_did_send_begin_main_frame_for_current_frame(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DidSendBeginMainFrameForCurrentFrame::kFieldId;
+  static constexpr FieldMetadata_TimecodeFlags kTimecodeFlags{};
+  void set_timecode_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeFlags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DidNotifyBeginMainFrameNotExpectedUntil =
+  using FieldMetadata_TimecodeFrames =
     ::protozero::proto_utils::FieldMetadata<
       8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DidNotifyBeginMainFrameNotExpectedUntil kDidNotifyBeginMainFrameNotExpectedUntil() { return {}; }
-  void set_did_notify_begin_main_frame_not_expected_until(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DidNotifyBeginMainFrameNotExpectedUntil::kFieldId;
+  static constexpr FieldMetadata_TimecodeFrames kTimecodeFrames{};
+  void set_timecode_frames(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeFrames::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DidNotifyBeginMainFrameNotExpectedSoon =
+  using FieldMetadata_TimecodeHours =
     ::protozero::proto_utils::FieldMetadata<
       9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DidNotifyBeginMainFrameNotExpectedSoon kDidNotifyBeginMainFrameNotExpectedSoon() { return {}; }
-  void set_did_notify_begin_main_frame_not_expected_soon(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DidNotifyBeginMainFrameNotExpectedSoon::kFieldId;
+  static constexpr FieldMetadata_TimecodeHours kTimecodeHours{};
+  void set_timecode_hours(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeHours::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_WantsBeginMainFrameNotExpected =
+  using FieldMetadata_TimecodeMinutes =
     ::protozero::proto_utils::FieldMetadata<
       10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WantsBeginMainFrameNotExpected kWantsBeginMainFrameNotExpected() { return {}; }
-  void set_wants_begin_main_frame_not_expected(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_WantsBeginMainFrameNotExpected::kFieldId;
+  static constexpr FieldMetadata_TimecodeMinutes kTimecodeMinutes{};
+  void set_timecode_minutes(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeMinutes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DidCommitDuringFrame =
+  using FieldMetadata_TimecodeSeconds =
     ::protozero::proto_utils::FieldMetadata<
       11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DidCommitDuringFrame kDidCommitDuringFrame() { return {}; }
-  void set_did_commit_during_frame(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DidCommitDuringFrame::kFieldId;
+  static constexpr FieldMetadata_TimecodeSeconds kTimecodeSeconds{};
+  void set_timecode_seconds(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeSeconds::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DidInvalidateLayerTreeFrameSink =
+  using FieldMetadata_TimecodeType =
     ::protozero::proto_utils::FieldMetadata<
       12,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DidInvalidateLayerTreeFrameSink kDidInvalidateLayerTreeFrameSink() { return {}; }
-  void set_did_invalidate_layer_tree_frame_sink(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DidInvalidateLayerTreeFrameSink::kFieldId;
+  static constexpr FieldMetadata_TimecodeType kTimecodeType{};
+  void set_timecode_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeType::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DidPerformImplSideInvalidaion =
+  using FieldMetadata_TimecodeUserbits0 =
     ::protozero::proto_utils::FieldMetadata<
       13,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DidPerformImplSideInvalidaion kDidPerformImplSideInvalidaion() { return {}; }
-  void set_did_perform_impl_side_invalidaion(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DidPerformImplSideInvalidaion::kFieldId;
+  static constexpr FieldMetadata_TimecodeUserbits0 kTimecodeUserbits0{};
+  void set_timecode_userbits0(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits0::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DidPrepareTiles =
+  using FieldMetadata_TimecodeUserbits1 =
     ::protozero::proto_utils::FieldMetadata<
       14,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DidPrepareTiles kDidPrepareTiles() { return {}; }
-  void set_did_prepare_tiles(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DidPrepareTiles::kFieldId;
+  static constexpr FieldMetadata_TimecodeUserbits1 kTimecodeUserbits1{};
+  void set_timecode_userbits1(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits1::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ConsecutiveCheckerboardAnimations =
+  using FieldMetadata_TimecodeUserbits2 =
     ::protozero::proto_utils::FieldMetadata<
       15,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ConsecutiveCheckerboardAnimations kConsecutiveCheckerboardAnimations() { return {}; }
-  void set_consecutive_checkerboard_animations(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ConsecutiveCheckerboardAnimations::kFieldId;
+  static constexpr FieldMetadata_TimecodeUserbits2 kTimecodeUserbits2{};
+  void set_timecode_userbits2(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits2::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PendingSubmitFrames =
+  using FieldMetadata_TimecodeUserbits3 =
     ::protozero::proto_utils::FieldMetadata<
       16,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2QbufFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PendingSubmitFrames kPendingSubmitFrames() { return {}; }
-  void set_pending_submit_frames(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PendingSubmitFrames::kFieldId;
+  static constexpr FieldMetadata_TimecodeUserbits3 kTimecodeUserbits3{};
+  void set_timecode_userbits3(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits3::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SubmitFramesWithCurrentLayerTreeFrameSink =
+  using FieldMetadata_Timestamp =
     ::protozero::proto_utils::FieldMetadata<
       17,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      V4l2QbufFtraceEvent>;
+
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Type =
+    ::protozero::proto_utils::FieldMetadata<
+      18,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      V4l2QbufFtraceEvent>;
+
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/virtio_gpu.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_VIRTIO_GPU_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_VIRTIO_GPU_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class VirtioGpuCmdResponseFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9> {
+ public:
+  VirtioGpuCmdResponseFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit VirtioGpuCmdResponseFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit VirtioGpuCmdResponseFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_ctx_id() const { return at<1>().valid(); }
+  uint32_t ctx_id() const { return at<1>().as_uint32(); }
+  bool has_dev() const { return at<2>().valid(); }
+  int32_t dev() const { return at<2>().as_int32(); }
+  bool has_fence_id() const { return at<3>().valid(); }
+  uint64_t fence_id() const { return at<3>().as_uint64(); }
+  bool has_flags() const { return at<4>().valid(); }
+  uint32_t flags() const { return at<4>().as_uint32(); }
+  bool has_name() const { return at<5>().valid(); }
+  ::protozero::ConstChars name() const { return at<5>().as_string(); }
+  bool has_num_free() const { return at<6>().valid(); }
+  uint32_t num_free() const { return at<6>().as_uint32(); }
+  bool has_seqno() const { return at<7>().valid(); }
+  uint32_t seqno() const { return at<7>().as_uint32(); }
+  bool has_type() const { return at<8>().valid(); }
+  uint32_t type() const { return at<8>().as_uint32(); }
+  bool has_vq() const { return at<9>().valid(); }
+  uint32_t vq() const { return at<9>().as_uint32(); }
+};
+
+class VirtioGpuCmdResponseFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = VirtioGpuCmdResponseFtraceEvent_Decoder;
+  enum : int32_t {
+    kCtxIdFieldNumber = 1,
+    kDevFieldNumber = 2,
+    kFenceIdFieldNumber = 3,
+    kFlagsFieldNumber = 4,
+    kNameFieldNumber = 5,
+    kNumFreeFieldNumber = 6,
+    kSeqnoFieldNumber = 7,
+    kTypeFieldNumber = 8,
+    kVqFieldNumber = 9,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.VirtioGpuCmdResponseFtraceEvent"; }
+
+
+  using FieldMetadata_CtxId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioGpuCmdResponseFtraceEvent>;
+
+  static constexpr FieldMetadata_CtxId kCtxId{};
+  void set_ctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CtxId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Dev =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      ChromeCompositorStateMachine_MinorState>;
+      VirtioGpuCmdResponseFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SubmitFramesWithCurrentLayerTreeFrameSink kSubmitFramesWithCurrentLayerTreeFrameSink() { return {}; }
-  void set_submit_frames_with_current_layer_tree_frame_sink(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SubmitFramesWithCurrentLayerTreeFrameSink::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -142719,1417 +164618,1516 @@ class ChromeCompositorStateMachine_MinorState : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NeedsRedraw =
+  using FieldMetadata_FenceId =
     ::protozero::proto_utils::FieldMetadata<
-      18,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      VirtioGpuCmdResponseFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NeedsRedraw kNeedsRedraw() { return {}; }
-  void set_needs_redraw(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_NeedsRedraw::kFieldId;
+  static constexpr FieldMetadata_FenceId kFenceId{};
+  void set_fence_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FenceId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NeedsPrepareTiles =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
-      19,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioGpuCmdResponseFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NeedsPrepareTiles kNeedsPrepareTiles() { return {}; }
-  void set_needs_prepare_tiles(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_NeedsPrepareTiles::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NeedsBeginMainFrame =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
-      20,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      VirtioGpuCmdResponseFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NeedsBeginMainFrame kNeedsBeginMainFrame() { return {}; }
-  void set_needs_begin_main_frame(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_NeedsBeginMainFrame::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NeedsOneBeginImplFrame =
+  using FieldMetadata_NumFree =
     ::protozero::proto_utils::FieldMetadata<
-      21,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioGpuCmdResponseFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NeedsOneBeginImplFrame kNeedsOneBeginImplFrame() { return {}; }
-  void set_needs_one_begin_impl_frame(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_NeedsOneBeginImplFrame::kFieldId;
+  static constexpr FieldMetadata_NumFree kNumFree{};
+  void set_num_free(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NumFree::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Visible =
+  using FieldMetadata_Seqno =
     ::protozero::proto_utils::FieldMetadata<
-      22,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioGpuCmdResponseFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Visible kVisible() { return {}; }
-  void set_visible(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_Visible::kFieldId;
+  static constexpr FieldMetadata_Seqno kSeqno{};
+  void set_seqno(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BeginFrameSourcePaused =
+  using FieldMetadata_Type =
     ::protozero::proto_utils::FieldMetadata<
-      23,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioGpuCmdResponseFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BeginFrameSourcePaused kBeginFrameSourcePaused() { return {}; }
-  void set_begin_frame_source_paused(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_BeginFrameSourcePaused::kFieldId;
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CanDraw =
+  using FieldMetadata_Vq =
     ::protozero::proto_utils::FieldMetadata<
-      24,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioGpuCmdResponseFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CanDraw kCanDraw() { return {}; }
-  void set_can_draw(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_CanDraw::kFieldId;
+  static constexpr FieldMetadata_Vq kVq{};
+  void set_vq(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Vq::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_ResourcelessDraw =
+class VirtioGpuCmdQueueFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9> {
+ public:
+  VirtioGpuCmdQueueFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit VirtioGpuCmdQueueFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit VirtioGpuCmdQueueFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_ctx_id() const { return at<1>().valid(); }
+  uint32_t ctx_id() const { return at<1>().as_uint32(); }
+  bool has_dev() const { return at<2>().valid(); }
+  int32_t dev() const { return at<2>().as_int32(); }
+  bool has_fence_id() const { return at<3>().valid(); }
+  uint64_t fence_id() const { return at<3>().as_uint64(); }
+  bool has_flags() const { return at<4>().valid(); }
+  uint32_t flags() const { return at<4>().as_uint32(); }
+  bool has_name() const { return at<5>().valid(); }
+  ::protozero::ConstChars name() const { return at<5>().as_string(); }
+  bool has_num_free() const { return at<6>().valid(); }
+  uint32_t num_free() const { return at<6>().as_uint32(); }
+  bool has_seqno() const { return at<7>().valid(); }
+  uint32_t seqno() const { return at<7>().as_uint32(); }
+  bool has_type() const { return at<8>().valid(); }
+  uint32_t type() const { return at<8>().as_uint32(); }
+  bool has_vq() const { return at<9>().valid(); }
+  uint32_t vq() const { return at<9>().as_uint32(); }
+};
+
+class VirtioGpuCmdQueueFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = VirtioGpuCmdQueueFtraceEvent_Decoder;
+  enum : int32_t {
+    kCtxIdFieldNumber = 1,
+    kDevFieldNumber = 2,
+    kFenceIdFieldNumber = 3,
+    kFlagsFieldNumber = 4,
+    kNameFieldNumber = 5,
+    kNumFreeFieldNumber = 6,
+    kSeqnoFieldNumber = 7,
+    kTypeFieldNumber = 8,
+    kVqFieldNumber = 9,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.VirtioGpuCmdQueueFtraceEvent"; }
+
+
+  using FieldMetadata_CtxId =
     ::protozero::proto_utils::FieldMetadata<
-      25,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioGpuCmdQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ResourcelessDraw kResourcelessDraw() { return {}; }
-  void set_resourceless_draw(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_ResourcelessDraw::kFieldId;
+  static constexpr FieldMetadata_CtxId kCtxId{};
+  void set_ctx_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CtxId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_HasPendingTree =
+  using FieldMetadata_Dev =
     ::protozero::proto_utils::FieldMetadata<
-      26,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      VirtioGpuCmdQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HasPendingTree kHasPendingTree() { return {}; }
-  void set_has_pending_tree(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_HasPendingTree::kFieldId;
+  static constexpr FieldMetadata_Dev kDev{};
+  void set_dev(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PendingTreeIsReadyForActivation =
+  using FieldMetadata_FenceId =
     ::protozero::proto_utils::FieldMetadata<
-      27,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      VirtioGpuCmdQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PendingTreeIsReadyForActivation kPendingTreeIsReadyForActivation() { return {}; }
-  void set_pending_tree_is_ready_for_activation(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_PendingTreeIsReadyForActivation::kFieldId;
+  static constexpr FieldMetadata_FenceId kFenceId{};
+  void set_fence_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FenceId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ActiveTreeNeedsFirstDraw =
+  using FieldMetadata_Flags =
     ::protozero::proto_utils::FieldMetadata<
-      28,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioGpuCmdQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ActiveTreeNeedsFirstDraw kActiveTreeNeedsFirstDraw() { return {}; }
-  void set_active_tree_needs_first_draw(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_ActiveTreeNeedsFirstDraw::kFieldId;
+  static constexpr FieldMetadata_Flags kFlags{};
+  void set_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ActiveTreeIsReadyToDraw =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
-      29,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      VirtioGpuCmdQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ActiveTreeIsReadyToDraw kActiveTreeIsReadyToDraw() { return {}; }
-  void set_active_tree_is_ready_to_draw(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_ActiveTreeIsReadyToDraw::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DidCreateAndInitializeFirstLayerTreeFrameSink =
+  using FieldMetadata_NumFree =
     ::protozero::proto_utils::FieldMetadata<
-      30,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioGpuCmdQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DidCreateAndInitializeFirstLayerTreeFrameSink kDidCreateAndInitializeFirstLayerTreeFrameSink() { return {}; }
-  void set_did_create_and_initialize_first_layer_tree_frame_sink(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DidCreateAndInitializeFirstLayerTreeFrameSink::kFieldId;
+  static constexpr FieldMetadata_NumFree kNumFree{};
+  void set_num_free(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NumFree::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TreePriority =
+  using FieldMetadata_Seqno =
     ::protozero::proto_utils::FieldMetadata<
-      31,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_TreePriority,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioGpuCmdQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TreePriority kTreePriority() { return {}; }
-  void set_tree_priority(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_TreePriority value) {
-    static constexpr uint32_t field_id = FieldMetadata_TreePriority::kFieldId;
+  static constexpr FieldMetadata_Seqno kSeqno{};
+  void set_seqno(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ScrollHandlerState =
+  using FieldMetadata_Type =
     ::protozero::proto_utils::FieldMetadata<
-      32,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_ScrollHandlerState,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioGpuCmdQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ScrollHandlerState kScrollHandlerState() { return {}; }
-  void set_scroll_handler_state(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_ScrollHandlerState value) {
-    static constexpr uint32_t field_id = FieldMetadata_ScrollHandlerState::kFieldId;
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CriticalBeginMainFrameToActivateIsFast =
+  using FieldMetadata_Vq =
     ::protozero::proto_utils::FieldMetadata<
-      33,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioGpuCmdQueueFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CriticalBeginMainFrameToActivateIsFast kCriticalBeginMainFrameToActivateIsFast() { return {}; }
-  void set_critical_begin_main_frame_to_activate_is_fast(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_CriticalBeginMainFrameToActivateIsFast::kFieldId;
+  static constexpr FieldMetadata_Vq kVq{};
+  void set_vq(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Vq::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_MainThreadMissedLastDeadline =
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/virtio_video.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_VIRTIO_VIDEO_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_VIRTIO_VIDEO_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class VirtioVideoResourceQueueDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
+ public:
+  VirtioVideoResourceQueueDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit VirtioVideoResourceQueueDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit VirtioVideoResourceQueueDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_data_size0() const { return at<1>().valid(); }
+  uint32_t data_size0() const { return at<1>().as_uint32(); }
+  bool has_data_size1() const { return at<2>().valid(); }
+  uint32_t data_size1() const { return at<2>().as_uint32(); }
+  bool has_data_size2() const { return at<3>().valid(); }
+  uint32_t data_size2() const { return at<3>().as_uint32(); }
+  bool has_data_size3() const { return at<4>().valid(); }
+  uint32_t data_size3() const { return at<4>().as_uint32(); }
+  bool has_queue_type() const { return at<5>().valid(); }
+  uint32_t queue_type() const { return at<5>().as_uint32(); }
+  bool has_resource_id() const { return at<6>().valid(); }
+  int32_t resource_id() const { return at<6>().as_int32(); }
+  bool has_stream_id() const { return at<7>().valid(); }
+  int32_t stream_id() const { return at<7>().as_int32(); }
+  bool has_timestamp() const { return at<8>().valid(); }
+  uint64_t timestamp() const { return at<8>().as_uint64(); }
+};
+
+class VirtioVideoResourceQueueDoneFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = VirtioVideoResourceQueueDoneFtraceEvent_Decoder;
+  enum : int32_t {
+    kDataSize0FieldNumber = 1,
+    kDataSize1FieldNumber = 2,
+    kDataSize2FieldNumber = 3,
+    kDataSize3FieldNumber = 4,
+    kQueueTypeFieldNumber = 5,
+    kResourceIdFieldNumber = 6,
+    kStreamIdFieldNumber = 7,
+    kTimestampFieldNumber = 8,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.VirtioVideoResourceQueueDoneFtraceEvent"; }
+
+
+  using FieldMetadata_DataSize0 =
     ::protozero::proto_utils::FieldMetadata<
-      34,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioVideoResourceQueueDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MainThreadMissedLastDeadline kMainThreadMissedLastDeadline() { return {}; }
-  void set_main_thread_missed_last_deadline(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_MainThreadMissedLastDeadline::kFieldId;
+  static constexpr FieldMetadata_DataSize0 kDataSize0{};
+  void set_data_size0(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DataSize0::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VideoNeedsBeginFrames =
+  using FieldMetadata_DataSize1 =
     ::protozero::proto_utils::FieldMetadata<
-      36,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioVideoResourceQueueDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VideoNeedsBeginFrames kVideoNeedsBeginFrames() { return {}; }
-  void set_video_needs_begin_frames(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_VideoNeedsBeginFrames::kFieldId;
+  static constexpr FieldMetadata_DataSize1 kDataSize1{};
+  void set_data_size1(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DataSize1::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DeferBeginMainFrame =
+  using FieldMetadata_DataSize2 =
     ::protozero::proto_utils::FieldMetadata<
-      37,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioVideoResourceQueueDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DeferBeginMainFrame kDeferBeginMainFrame() { return {}; }
-  void set_defer_begin_main_frame(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DeferBeginMainFrame::kFieldId;
+  static constexpr FieldMetadata_DataSize2 kDataSize2{};
+  void set_data_size2(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DataSize2::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_LastCommitHadNoUpdates =
+  using FieldMetadata_DataSize3 =
     ::protozero::proto_utils::FieldMetadata<
-      38,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioVideoResourceQueueDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LastCommitHadNoUpdates kLastCommitHadNoUpdates() { return {}; }
-  void set_last_commit_had_no_updates(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_LastCommitHadNoUpdates::kFieldId;
+  static constexpr FieldMetadata_DataSize3 kDataSize3{};
+  void set_data_size3(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DataSize3::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DidDrawInLastFrame =
+  using FieldMetadata_QueueType =
     ::protozero::proto_utils::FieldMetadata<
-      39,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioVideoResourceQueueDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DidDrawInLastFrame kDidDrawInLastFrame() { return {}; }
-  void set_did_draw_in_last_frame(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DidDrawInLastFrame::kFieldId;
+  static constexpr FieldMetadata_QueueType kQueueType{};
+  void set_queue_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_QueueType::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DidSubmitInLastFrame =
+  using FieldMetadata_ResourceId =
     ::protozero::proto_utils::FieldMetadata<
-      40,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      VirtioVideoResourceQueueDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DidSubmitInLastFrame kDidSubmitInLastFrame() { return {}; }
-  void set_did_submit_in_last_frame(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_DidSubmitInLastFrame::kFieldId;
+  static constexpr FieldMetadata_ResourceId kResourceId{};
+  void set_resource_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResourceId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NeedsImplSideInvalidation =
+  using FieldMetadata_StreamId =
     ::protozero::proto_utils::FieldMetadata<
-      41,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      VirtioVideoResourceQueueDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NeedsImplSideInvalidation kNeedsImplSideInvalidation() { return {}; }
-  void set_needs_impl_side_invalidation(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_NeedsImplSideInvalidation::kFieldId;
+  static constexpr FieldMetadata_StreamId kStreamId{};
+  void set_stream_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StreamId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CurrentPendingTreeIsImplSide =
+  using FieldMetadata_Timestamp =
     ::protozero::proto_utils::FieldMetadata<
-      42,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      VirtioVideoResourceQueueDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CurrentPendingTreeIsImplSide kCurrentPendingTreeIsImplSide() { return {}; }
-  void set_current_pending_tree_is_impl_side(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_CurrentPendingTreeIsImplSide::kFieldId;
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class VirtioVideoResourceQueueFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
+ public:
+  VirtioVideoResourceQueueFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit VirtioVideoResourceQueueFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit VirtioVideoResourceQueueFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_data_size0() const { return at<1>().valid(); }
+  uint32_t data_size0() const { return at<1>().as_uint32(); }
+  bool has_data_size1() const { return at<2>().valid(); }
+  uint32_t data_size1() const { return at<2>().as_uint32(); }
+  bool has_data_size2() const { return at<3>().valid(); }
+  uint32_t data_size2() const { return at<3>().as_uint32(); }
+  bool has_data_size3() const { return at<4>().valid(); }
+  uint32_t data_size3() const { return at<4>().as_uint32(); }
+  bool has_queue_type() const { return at<5>().valid(); }
+  uint32_t queue_type() const { return at<5>().as_uint32(); }
+  bool has_resource_id() const { return at<6>().valid(); }
+  int32_t resource_id() const { return at<6>().as_int32(); }
+  bool has_stream_id() const { return at<7>().valid(); }
+  int32_t stream_id() const { return at<7>().as_int32(); }
+  bool has_timestamp() const { return at<8>().valid(); }
+  uint64_t timestamp() const { return at<8>().as_uint64(); }
+};
+
+class VirtioVideoResourceQueueFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = VirtioVideoResourceQueueFtraceEvent_Decoder;
+  enum : int32_t {
+    kDataSize0FieldNumber = 1,
+    kDataSize1FieldNumber = 2,
+    kDataSize2FieldNumber = 3,
+    kDataSize3FieldNumber = 4,
+    kQueueTypeFieldNumber = 5,
+    kResourceIdFieldNumber = 6,
+    kStreamIdFieldNumber = 7,
+    kTimestampFieldNumber = 8,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.VirtioVideoResourceQueueFtraceEvent"; }
+
+
+  using FieldMetadata_DataSize0 =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioVideoResourceQueueFtraceEvent>;
+
+  static constexpr FieldMetadata_DataSize0 kDataSize0{};
+  void set_data_size0(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DataSize0::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DataSize1 =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioVideoResourceQueueFtraceEvent>;
+
+  static constexpr FieldMetadata_DataSize1 kDataSize1{};
+  void set_data_size1(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DataSize1::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DataSize2 =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioVideoResourceQueueFtraceEvent>;
+
+  static constexpr FieldMetadata_DataSize2 kDataSize2{};
+  void set_data_size2(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DataSize2::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DataSize3 =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioVideoResourceQueueFtraceEvent>;
+
+  static constexpr FieldMetadata_DataSize3 kDataSize3{};
+  void set_data_size3(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DataSize3::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_QueueType =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioVideoResourceQueueFtraceEvent>;
+
+  static constexpr FieldMetadata_QueueType kQueueType{};
+  void set_queue_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_QueueType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ResourceId =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      VirtioVideoResourceQueueFtraceEvent>;
+
+  static constexpr FieldMetadata_ResourceId kResourceId{};
+  void set_resource_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResourceId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_StreamId =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      VirtioVideoResourceQueueFtraceEvent>;
+
+  static constexpr FieldMetadata_StreamId kStreamId{};
+  void set_stream_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StreamId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Timestamp =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      VirtioVideoResourceQueueFtraceEvent>;
+
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
+
+class VirtioVideoCmdDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  VirtioVideoCmdDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit VirtioVideoCmdDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit VirtioVideoCmdDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_stream_id() const { return at<1>().valid(); }
+  uint32_t stream_id() const { return at<1>().as_uint32(); }
+  bool has_type() const { return at<2>().valid(); }
+  uint32_t type() const { return at<2>().as_uint32(); }
+};
+
+class VirtioVideoCmdDoneFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = VirtioVideoCmdDoneFtraceEvent_Decoder;
+  enum : int32_t {
+    kStreamIdFieldNumber = 1,
+    kTypeFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.VirtioVideoCmdDoneFtraceEvent"; }
 
-  using FieldMetadata_PreviousPendingTreeWasImplSide =
+
+  using FieldMetadata_StreamId =
     ::protozero::proto_utils::FieldMetadata<
-      43,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioVideoCmdDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PreviousPendingTreeWasImplSide kPreviousPendingTreeWasImplSide() { return {}; }
-  void set_previous_pending_tree_was_impl_side(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_PreviousPendingTreeWasImplSide::kFieldId;
+  static constexpr FieldMetadata_StreamId kStreamId{};
+  void set_stream_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StreamId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ProcessingAnimationWorkletsForActiveTree =
+  using FieldMetadata_Type =
     ::protozero::proto_utils::FieldMetadata<
-      44,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioVideoCmdDoneFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessingAnimationWorkletsForActiveTree kProcessingAnimationWorkletsForActiveTree() { return {}; }
-  void set_processing_animation_worklets_for_active_tree(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProcessingAnimationWorkletsForActiveTree::kFieldId;
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_ProcessingAnimationWorkletsForPendingTree =
+class VirtioVideoCmdFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  VirtioVideoCmdFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit VirtioVideoCmdFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit VirtioVideoCmdFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_stream_id() const { return at<1>().valid(); }
+  uint32_t stream_id() const { return at<1>().as_uint32(); }
+  bool has_type() const { return at<2>().valid(); }
+  uint32_t type() const { return at<2>().as_uint32(); }
+};
+
+class VirtioVideoCmdFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = VirtioVideoCmdFtraceEvent_Decoder;
+  enum : int32_t {
+    kStreamIdFieldNumber = 1,
+    kTypeFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.VirtioVideoCmdFtraceEvent"; }
+
+
+  using FieldMetadata_StreamId =
     ::protozero::proto_utils::FieldMetadata<
-      45,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioVideoCmdFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessingAnimationWorkletsForPendingTree kProcessingAnimationWorkletsForPendingTree() { return {}; }
-  void set_processing_animation_worklets_for_pending_tree(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProcessingAnimationWorkletsForPendingTree::kFieldId;
+  static constexpr FieldMetadata_StreamId kStreamId{};
+  void set_stream_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StreamId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ProcessingPaintWorkletsForPendingTree =
+  using FieldMetadata_Type =
     ::protozero::proto_utils::FieldMetadata<
-      46,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorStateMachine_MinorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VirtioVideoCmdFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessingPaintWorkletsForPendingTree kProcessingPaintWorkletsForPendingTree() { return {}; }
-  void set_processing_paint_worklets_for_pending_tree(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProcessingPaintWorkletsForPendingTree::kFieldId;
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class ChromeCompositorStateMachine_MajorState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/vmscan.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_VMSCAN_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_VMSCAN_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class MmShrinkSlabEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
-  ChromeCompositorStateMachine_MajorState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeCompositorStateMachine_MajorState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeCompositorStateMachine_MajorState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_next_action() const { return at<1>().valid(); }
-  int32_t next_action() const { return at<1>().as_int32(); }
-  bool has_begin_impl_frame_state() const { return at<2>().valid(); }
-  int32_t begin_impl_frame_state() const { return at<2>().as_int32(); }
-  bool has_begin_main_frame_state() const { return at<3>().valid(); }
-  int32_t begin_main_frame_state() const { return at<3>().as_int32(); }
-  bool has_layer_tree_frame_sink_state() const { return at<4>().valid(); }
-  int32_t layer_tree_frame_sink_state() const { return at<4>().as_int32(); }
-  bool has_forced_redraw_state() const { return at<5>().valid(); }
-  int32_t forced_redraw_state() const { return at<5>().as_int32(); }
+  MmShrinkSlabEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MmShrinkSlabEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MmShrinkSlabEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_new_scan() const { return at<1>().valid(); }
+  int64_t new_scan() const { return at<1>().as_int64(); }
+  bool has_retval() const { return at<2>().valid(); }
+  int32_t retval() const { return at<2>().as_int32(); }
+  bool has_shr() const { return at<3>().valid(); }
+  uint64_t shr() const { return at<3>().as_uint64(); }
+  bool has_shrink() const { return at<4>().valid(); }
+  uint64_t shrink() const { return at<4>().as_uint64(); }
+  bool has_total_scan() const { return at<5>().valid(); }
+  int64_t total_scan() const { return at<5>().as_int64(); }
+  bool has_unused_scan() const { return at<6>().valid(); }
+  int64_t unused_scan() const { return at<6>().as_int64(); }
+  bool has_nid() const { return at<7>().valid(); }
+  int32_t nid() const { return at<7>().as_int32(); }
 };
 
-class ChromeCompositorStateMachine_MajorState : public ::protozero::Message {
+class MmShrinkSlabEndFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = ChromeCompositorStateMachine_MajorState_Decoder;
+  using Decoder = MmShrinkSlabEndFtraceEvent_Decoder;
   enum : int32_t {
-    kNextActionFieldNumber = 1,
-    kBeginImplFrameStateFieldNumber = 2,
-    kBeginMainFrameStateFieldNumber = 3,
-    kLayerTreeFrameSinkStateFieldNumber = 4,
-    kForcedRedrawStateFieldNumber = 5,
+    kNewScanFieldNumber = 1,
+    kRetvalFieldNumber = 2,
+    kShrFieldNumber = 3,
+    kShrinkFieldNumber = 4,
+    kTotalScanFieldNumber = 5,
+    kUnusedScanFieldNumber = 6,
+    kNidFieldNumber = 7,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeCompositorStateMachine.MajorState"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MmShrinkSlabEndFtraceEvent"; }
 
 
-  using BeginImplFrameState = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginImplFrameState;
-  static inline const char* BeginImplFrameState_Name(BeginImplFrameState value) {
-    return ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginImplFrameState_Name(value);
-  }
+  using FieldMetadata_NewScan =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      MmShrinkSlabEndFtraceEvent>;
 
-  using BeginMainFrameState = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginMainFrameState;
-  static inline const char* BeginMainFrameState_Name(BeginMainFrameState value) {
-    return ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginMainFrameState_Name(value);
+  static constexpr FieldMetadata_NewScan kNewScan{};
+  void set_new_scan(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NewScan::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
   }
 
-  using LayerTreeFrameSinkState = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState;
-  static inline const char* LayerTreeFrameSinkState_Name(LayerTreeFrameSinkState value) {
-    return ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_Name(value);
-  }
+  using FieldMetadata_Retval =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MmShrinkSlabEndFtraceEvent>;
 
-  using ForcedRedrawOnTimeoutState = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState;
-  static inline const char* ForcedRedrawOnTimeoutState_Name(ForcedRedrawOnTimeoutState value) {
-    return ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_Name(value);
+  static constexpr FieldMetadata_Retval kRetval{};
+  void set_retval(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Retval::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
   }
-  static const BeginImplFrameState BEGIN_IMPL_FRAME_UNSPECIFIED = BeginImplFrameState::BEGIN_IMPL_FRAME_UNSPECIFIED;
-  static const BeginImplFrameState BEGIN_IMPL_FRAME_IDLE = BeginImplFrameState::BEGIN_IMPL_FRAME_IDLE;
-  static const BeginImplFrameState BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME = BeginImplFrameState::BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME;
-  static const BeginImplFrameState BEGIN_IMPL_FRAME_INSIDE_DEADLINE = BeginImplFrameState::BEGIN_IMPL_FRAME_INSIDE_DEADLINE;
-  static const BeginMainFrameState BEGIN_MAIN_FRAME_UNSPECIFIED = BeginMainFrameState::BEGIN_MAIN_FRAME_UNSPECIFIED;
-  static const BeginMainFrameState BEGIN_MAIN_FRAME_IDLE = BeginMainFrameState::BEGIN_MAIN_FRAME_IDLE;
-  static const BeginMainFrameState BEGIN_MAIN_FRAME_SENT = BeginMainFrameState::BEGIN_MAIN_FRAME_SENT;
-  static const BeginMainFrameState BEGIN_MAIN_FRAME_READY_TO_COMMIT = BeginMainFrameState::BEGIN_MAIN_FRAME_READY_TO_COMMIT;
-  static const LayerTreeFrameSinkState LAYER_TREE_FRAME_UNSPECIFIED = LayerTreeFrameSinkState::LAYER_TREE_FRAME_UNSPECIFIED;
-  static const LayerTreeFrameSinkState LAYER_TREE_FRAME_NONE = LayerTreeFrameSinkState::LAYER_TREE_FRAME_NONE;
-  static const LayerTreeFrameSinkState LAYER_TREE_FRAME_ACTIVE = LayerTreeFrameSinkState::LAYER_TREE_FRAME_ACTIVE;
-  static const LayerTreeFrameSinkState LAYER_TREE_FRAME_CREATING = LayerTreeFrameSinkState::LAYER_TREE_FRAME_CREATING;
-  static const LayerTreeFrameSinkState LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT = LayerTreeFrameSinkState::LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT;
-  static const LayerTreeFrameSinkState LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION = LayerTreeFrameSinkState::LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION;
-  static const ForcedRedrawOnTimeoutState FORCED_REDRAW_UNSPECIFIED = ForcedRedrawOnTimeoutState::FORCED_REDRAW_UNSPECIFIED;
-  static const ForcedRedrawOnTimeoutState FORCED_REDRAW_IDLE = ForcedRedrawOnTimeoutState::FORCED_REDRAW_IDLE;
-  static const ForcedRedrawOnTimeoutState FORCED_REDRAW_WAITING_FOR_COMMIT = ForcedRedrawOnTimeoutState::FORCED_REDRAW_WAITING_FOR_COMMIT;
-  static const ForcedRedrawOnTimeoutState FORCED_REDRAW_WAITING_FOR_ACTIVATION = ForcedRedrawOnTimeoutState::FORCED_REDRAW_WAITING_FOR_ACTIVATION;
-  static const ForcedRedrawOnTimeoutState FORCED_REDRAW_WAITING_FOR_DRAW = ForcedRedrawOnTimeoutState::FORCED_REDRAW_WAITING_FOR_DRAW;
 
-  using FieldMetadata_NextAction =
+  using FieldMetadata_Shr =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction,
-      ChromeCompositorStateMachine_MajorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmShrinkSlabEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NextAction kNextAction() { return {}; }
-  void set_next_action(::perfetto::protos::pbzero::ChromeCompositorSchedulerAction value) {
-    static constexpr uint32_t field_id = FieldMetadata_NextAction::kFieldId;
+  static constexpr FieldMetadata_Shr kShr{};
+  void set_shr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Shr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BeginImplFrameState =
+  using FieldMetadata_Shrink =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginImplFrameState,
-      ChromeCompositorStateMachine_MajorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmShrinkSlabEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BeginImplFrameState kBeginImplFrameState() { return {}; }
-  void set_begin_impl_frame_state(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginImplFrameState value) {
-    static constexpr uint32_t field_id = FieldMetadata_BeginImplFrameState::kFieldId;
+  static constexpr FieldMetadata_Shrink kShrink{};
+  void set_shrink(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Shrink::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BeginMainFrameState =
+  using FieldMetadata_TotalScan =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginMainFrameState,
-      ChromeCompositorStateMachine_MajorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      MmShrinkSlabEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BeginMainFrameState kBeginMainFrameState() { return {}; }
-  void set_begin_main_frame_state(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginMainFrameState value) {
-    static constexpr uint32_t field_id = FieldMetadata_BeginMainFrameState::kFieldId;
+  static constexpr FieldMetadata_TotalScan kTotalScan{};
+  void set_total_scan(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TotalScan::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_LayerTreeFrameSinkState =
+  using FieldMetadata_UnusedScan =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState,
-      ChromeCompositorStateMachine_MajorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      MmShrinkSlabEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LayerTreeFrameSinkState kLayerTreeFrameSinkState() { return {}; }
-  void set_layer_tree_frame_sink_state(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState value) {
-    static constexpr uint32_t field_id = FieldMetadata_LayerTreeFrameSinkState::kFieldId;
+  static constexpr FieldMetadata_UnusedScan kUnusedScan{};
+  void set_unused_scan(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_UnusedScan::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ForcedRedrawState =
+  using FieldMetadata_Nid =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState,
-      ChromeCompositorStateMachine_MajorState>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MmShrinkSlabEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ForcedRedrawState kForcedRedrawState() { return {}; }
-  void set_forced_redraw_state(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState value) {
-    static constexpr uint32_t field_id = FieldMetadata_ForcedRedrawState::kFieldId;
+  static constexpr FieldMetadata_Nid kNid{};
+  void set_nid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 };
 
-class ChromeCompositorSchedulerState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/17, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmShrinkSlabStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11> {
  public:
-  ChromeCompositorSchedulerState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeCompositorSchedulerState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeCompositorSchedulerState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_state_machine() const { return at<1>().valid(); }
-  ::protozero::ConstBytes state_machine() const { return at<1>().as_bytes(); }
-  bool has_observing_begin_frame_source() const { return at<2>().valid(); }
-  bool observing_begin_frame_source() const { return at<2>().as_bool(); }
-  bool has_begin_impl_frame_deadline_task() const { return at<3>().valid(); }
-  bool begin_impl_frame_deadline_task() const { return at<3>().as_bool(); }
-  bool has_pending_begin_frame_task() const { return at<4>().valid(); }
-  bool pending_begin_frame_task() const { return at<4>().as_bool(); }
-  bool has_skipped_last_frame_missed_exceeded_deadline() const { return at<5>().valid(); }
-  bool skipped_last_frame_missed_exceeded_deadline() const { return at<5>().as_bool(); }
-  bool has_inside_action() const { return at<7>().valid(); }
-  int32_t inside_action() const { return at<7>().as_int32(); }
-  bool has_deadline_mode() const { return at<8>().valid(); }
-  int32_t deadline_mode() const { return at<8>().as_int32(); }
-  bool has_deadline_us() const { return at<9>().valid(); }
-  int64_t deadline_us() const { return at<9>().as_int64(); }
-  bool has_deadline_scheduled_at_us() const { return at<10>().valid(); }
-  int64_t deadline_scheduled_at_us() const { return at<10>().as_int64(); }
-  bool has_now_us() const { return at<11>().valid(); }
-  int64_t now_us() const { return at<11>().as_int64(); }
-  bool has_now_to_deadline_delta_us() const { return at<12>().valid(); }
-  int64_t now_to_deadline_delta_us() const { return at<12>().as_int64(); }
-  bool has_now_to_deadline_scheduled_at_delta_us() const { return at<13>().valid(); }
-  int64_t now_to_deadline_scheduled_at_delta_us() const { return at<13>().as_int64(); }
-  bool has_begin_impl_frame_args() const { return at<14>().valid(); }
-  ::protozero::ConstBytes begin_impl_frame_args() const { return at<14>().as_bytes(); }
-  bool has_begin_frame_observer_state() const { return at<15>().valid(); }
-  ::protozero::ConstBytes begin_frame_observer_state() const { return at<15>().as_bytes(); }
-  bool has_begin_frame_source_state() const { return at<16>().valid(); }
-  ::protozero::ConstBytes begin_frame_source_state() const { return at<16>().as_bytes(); }
-  bool has_compositor_timing_history() const { return at<17>().valid(); }
-  ::protozero::ConstBytes compositor_timing_history() const { return at<17>().as_bytes(); }
+  MmShrinkSlabStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MmShrinkSlabStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MmShrinkSlabStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cache_items() const { return at<1>().valid(); }
+  uint64_t cache_items() const { return at<1>().as_uint64(); }
+  bool has_delta() const { return at<2>().valid(); }
+  uint64_t delta() const { return at<2>().as_uint64(); }
+  bool has_gfp_flags() const { return at<3>().valid(); }
+  uint32_t gfp_flags() const { return at<3>().as_uint32(); }
+  bool has_lru_pgs() const { return at<4>().valid(); }
+  uint64_t lru_pgs() const { return at<4>().as_uint64(); }
+  bool has_nr_objects_to_shrink() const { return at<5>().valid(); }
+  int64_t nr_objects_to_shrink() const { return at<5>().as_int64(); }
+  bool has_pgs_scanned() const { return at<6>().valid(); }
+  uint64_t pgs_scanned() const { return at<6>().as_uint64(); }
+  bool has_shr() const { return at<7>().valid(); }
+  uint64_t shr() const { return at<7>().as_uint64(); }
+  bool has_shrink() const { return at<8>().valid(); }
+  uint64_t shrink() const { return at<8>().as_uint64(); }
+  bool has_total_scan() const { return at<9>().valid(); }
+  uint64_t total_scan() const { return at<9>().as_uint64(); }
+  bool has_nid() const { return at<10>().valid(); }
+  int32_t nid() const { return at<10>().as_int32(); }
+  bool has_priority() const { return at<11>().valid(); }
+  int32_t priority() const { return at<11>().as_int32(); }
 };
 
-class ChromeCompositorSchedulerState : public ::protozero::Message {
+class MmShrinkSlabStartFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = ChromeCompositorSchedulerState_Decoder;
+  using Decoder = MmShrinkSlabStartFtraceEvent_Decoder;
   enum : int32_t {
-    kStateMachineFieldNumber = 1,
-    kObservingBeginFrameSourceFieldNumber = 2,
-    kBeginImplFrameDeadlineTaskFieldNumber = 3,
-    kPendingBeginFrameTaskFieldNumber = 4,
-    kSkippedLastFrameMissedExceededDeadlineFieldNumber = 5,
-    kInsideActionFieldNumber = 7,
-    kDeadlineModeFieldNumber = 8,
-    kDeadlineUsFieldNumber = 9,
-    kDeadlineScheduledAtUsFieldNumber = 10,
-    kNowUsFieldNumber = 11,
-    kNowToDeadlineDeltaUsFieldNumber = 12,
-    kNowToDeadlineScheduledAtDeltaUsFieldNumber = 13,
-    kBeginImplFrameArgsFieldNumber = 14,
-    kBeginFrameObserverStateFieldNumber = 15,
-    kBeginFrameSourceStateFieldNumber = 16,
-    kCompositorTimingHistoryFieldNumber = 17,
+    kCacheItemsFieldNumber = 1,
+    kDeltaFieldNumber = 2,
+    kGfpFlagsFieldNumber = 3,
+    kLruPgsFieldNumber = 4,
+    kNrObjectsToShrinkFieldNumber = 5,
+    kPgsScannedFieldNumber = 6,
+    kShrFieldNumber = 7,
+    kShrinkFieldNumber = 8,
+    kTotalScanFieldNumber = 9,
+    kNidFieldNumber = 10,
+    kPriorityFieldNumber = 11,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeCompositorSchedulerState"; }
-
+  static constexpr const char* GetName() { return ".perfetto.protos.MmShrinkSlabStartFtraceEvent"; }
 
-  using BeginImplFrameDeadlineMode = ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode;
-  static inline const char* BeginImplFrameDeadlineMode_Name(BeginImplFrameDeadlineMode value) {
-    return ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_Name(value);
-  }
-  static const BeginImplFrameDeadlineMode DEADLINE_MODE_UNSPECIFIED = BeginImplFrameDeadlineMode::DEADLINE_MODE_UNSPECIFIED;
-  static const BeginImplFrameDeadlineMode DEADLINE_MODE_NONE = BeginImplFrameDeadlineMode::DEADLINE_MODE_NONE;
-  static const BeginImplFrameDeadlineMode DEADLINE_MODE_IMMEDIATE = BeginImplFrameDeadlineMode::DEADLINE_MODE_IMMEDIATE;
-  static const BeginImplFrameDeadlineMode DEADLINE_MODE_REGULAR = BeginImplFrameDeadlineMode::DEADLINE_MODE_REGULAR;
-  static const BeginImplFrameDeadlineMode DEADLINE_MODE_LATE = BeginImplFrameDeadlineMode::DEADLINE_MODE_LATE;
-  static const BeginImplFrameDeadlineMode DEADLINE_MODE_BLOCKED = BeginImplFrameDeadlineMode::DEADLINE_MODE_BLOCKED;
 
-  using FieldMetadata_StateMachine =
+  using FieldMetadata_CacheItems =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeCompositorStateMachine,
-      ChromeCompositorSchedulerState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmShrinkSlabStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StateMachine kStateMachine() { return {}; }
-  template <typename T = ChromeCompositorStateMachine> T* set_state_machine() {
-    return BeginNestedMessage<T>(1);
+  static constexpr FieldMetadata_CacheItems kCacheItems{};
+  void set_cache_items(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CacheItems::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_ObservingBeginFrameSource =
+  using FieldMetadata_Delta =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorSchedulerState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmShrinkSlabStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ObservingBeginFrameSource kObservingBeginFrameSource() { return {}; }
-  void set_observing_begin_frame_source(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_ObservingBeginFrameSource::kFieldId;
+  static constexpr FieldMetadata_Delta kDelta{};
+  void set_delta(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Delta::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BeginImplFrameDeadlineTask =
+  using FieldMetadata_GfpFlags =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorSchedulerState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MmShrinkSlabStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BeginImplFrameDeadlineTask kBeginImplFrameDeadlineTask() { return {}; }
-  void set_begin_impl_frame_deadline_task(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_BeginImplFrameDeadlineTask::kFieldId;
+  static constexpr FieldMetadata_GfpFlags kGfpFlags{};
+  void set_gfp_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PendingBeginFrameTask =
+  using FieldMetadata_LruPgs =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorSchedulerState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmShrinkSlabStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PendingBeginFrameTask kPendingBeginFrameTask() { return {}; }
-  void set_pending_begin_frame_task(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_PendingBeginFrameTask::kFieldId;
+  static constexpr FieldMetadata_LruPgs kLruPgs{};
+  void set_lru_pgs(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LruPgs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SkippedLastFrameMissedExceededDeadline =
+  using FieldMetadata_NrObjectsToShrink =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeCompositorSchedulerState>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      MmShrinkSlabStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SkippedLastFrameMissedExceededDeadline kSkippedLastFrameMissedExceededDeadline() { return {}; }
-  void set_skipped_last_frame_missed_exceeded_deadline(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_SkippedLastFrameMissedExceededDeadline::kFieldId;
+  static constexpr FieldMetadata_NrObjectsToShrink kNrObjectsToShrink{};
+  void set_nr_objects_to_shrink(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NrObjectsToShrink::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_InsideAction =
+  using FieldMetadata_PgsScanned =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction,
-      ChromeCompositorSchedulerState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmShrinkSlabStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InsideAction kInsideAction() { return {}; }
-  void set_inside_action(::perfetto::protos::pbzero::ChromeCompositorSchedulerAction value) {
-    static constexpr uint32_t field_id = FieldMetadata_InsideAction::kFieldId;
+  static constexpr FieldMetadata_PgsScanned kPgsScanned{};
+  void set_pgs_scanned(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PgsScanned::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DeadlineMode =
+  using FieldMetadata_Shr =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode,
-      ChromeCompositorSchedulerState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmShrinkSlabStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DeadlineMode kDeadlineMode() { return {}; }
-  void set_deadline_mode(::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode value) {
-    static constexpr uint32_t field_id = FieldMetadata_DeadlineMode::kFieldId;
+  static constexpr FieldMetadata_Shr kShr{};
+  void set_shr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Shr::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DeadlineUs =
+  using FieldMetadata_Shrink =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ChromeCompositorSchedulerState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmShrinkSlabStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DeadlineUs kDeadlineUs() { return {}; }
-  void set_deadline_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DeadlineUs::kFieldId;
+  static constexpr FieldMetadata_Shrink kShrink{};
+  void set_shrink(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Shrink::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DeadlineScheduledAtUs =
+  using FieldMetadata_TotalScan =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ChromeCompositorSchedulerState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmShrinkSlabStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DeadlineScheduledAtUs kDeadlineScheduledAtUs() { return {}; }
-  void set_deadline_scheduled_at_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DeadlineScheduledAtUs::kFieldId;
+  static constexpr FieldMetadata_TotalScan kTotalScan{};
+  void set_total_scan(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TotalScan::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NowUs =
+  using FieldMetadata_Nid =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ChromeCompositorSchedulerState>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MmShrinkSlabStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NowUs kNowUs() { return {}; }
-  void set_now_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NowUs::kFieldId;
+  static constexpr FieldMetadata_Nid kNid{};
+  void set_nid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NowToDeadlineDeltaUs =
+  using FieldMetadata_Priority =
     ::protozero::proto_utils::FieldMetadata<
-      12,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ChromeCompositorSchedulerState>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MmShrinkSlabStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NowToDeadlineDeltaUs kNowToDeadlineDeltaUs() { return {}; }
-  void set_now_to_deadline_delta_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NowToDeadlineDeltaUs::kFieldId;
+  static constexpr FieldMetadata_Priority kPriority{};
+  void set_priority(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Priority::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_NowToDeadlineScheduledAtDeltaUs =
+class MmVmscanKswapdSleepFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  MmVmscanKswapdSleepFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MmVmscanKswapdSleepFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MmVmscanKswapdSleepFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_nid() const { return at<1>().valid(); }
+  int32_t nid() const { return at<1>().as_int32(); }
+};
+
+class MmVmscanKswapdSleepFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = MmVmscanKswapdSleepFtraceEvent_Decoder;
+  enum : int32_t {
+    kNidFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.MmVmscanKswapdSleepFtraceEvent"; }
+
+
+  using FieldMetadata_Nid =
     ::protozero::proto_utils::FieldMetadata<
-      13,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ChromeCompositorSchedulerState>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MmVmscanKswapdSleepFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NowToDeadlineScheduledAtDeltaUs kNowToDeadlineScheduledAtDeltaUs() { return {}; }
-  void set_now_to_deadline_scheduled_at_delta_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NowToDeadlineScheduledAtDeltaUs::kFieldId;
+  static constexpr FieldMetadata_Nid kNid{};
+  void set_nid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_BeginImplFrameArgs =
-    ::protozero::proto_utils::FieldMetadata<
-      14,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      BeginImplFrameArgs,
-      ChromeCompositorSchedulerState>;
+class MmVmscanKswapdWakeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  MmVmscanKswapdWakeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MmVmscanKswapdWakeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MmVmscanKswapdWakeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_nid() const { return at<1>().valid(); }
+  int32_t nid() const { return at<1>().as_int32(); }
+  bool has_order() const { return at<2>().valid(); }
+  int32_t order() const { return at<2>().as_int32(); }
+  bool has_zid() const { return at<3>().valid(); }
+  int32_t zid() const { return at<3>().as_int32(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BeginImplFrameArgs kBeginImplFrameArgs() { return {}; }
-  template <typename T = BeginImplFrameArgs> T* set_begin_impl_frame_args() {
-    return BeginNestedMessage<T>(14);
-  }
+class MmVmscanKswapdWakeFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = MmVmscanKswapdWakeFtraceEvent_Decoder;
+  enum : int32_t {
+    kNidFieldNumber = 1,
+    kOrderFieldNumber = 2,
+    kZidFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.MmVmscanKswapdWakeFtraceEvent"; }
 
 
-  using FieldMetadata_BeginFrameObserverState =
+  using FieldMetadata_Nid =
     ::protozero::proto_utils::FieldMetadata<
-      15,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      BeginFrameObserverState,
-      ChromeCompositorSchedulerState>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MmVmscanKswapdWakeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BeginFrameObserverState kBeginFrameObserverState() { return {}; }
-  template <typename T = BeginFrameObserverState> T* set_begin_frame_observer_state() {
-    return BeginNestedMessage<T>(15);
+  static constexpr FieldMetadata_Nid kNid{};
+  void set_nid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_BeginFrameSourceState =
+  using FieldMetadata_Order =
     ::protozero::proto_utils::FieldMetadata<
-      16,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      BeginFrameSourceState,
-      ChromeCompositorSchedulerState>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MmVmscanKswapdWakeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BeginFrameSourceState kBeginFrameSourceState() { return {}; }
-  template <typename T = BeginFrameSourceState> T* set_begin_frame_source_state() {
-    return BeginNestedMessage<T>(16);
+  static constexpr FieldMetadata_Order kOrder{};
+  void set_order(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_CompositorTimingHistory =
+  using FieldMetadata_Zid =
     ::protozero::proto_utils::FieldMetadata<
-      17,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      CompositorTimingHistory,
-      ChromeCompositorSchedulerState>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MmVmscanKswapdWakeFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CompositorTimingHistory kCompositorTimingHistory() { return {}; }
-  template <typename T = CompositorTimingHistory> T* set_compositor_timing_history() {
-    return BeginNestedMessage<T>(17);
+  static constexpr FieldMetadata_Zid kZid{};
+  void set_zid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Zid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
   }
-
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_content_settings_event_info.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_CONTENT_SETTINGS_EVENT_INFO_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_CONTENT_SETTINGS_EVENT_INFO_PROTO_H_
+class MmVmscanDirectReclaimEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  MmVmscanDirectReclaimEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MmVmscanDirectReclaimEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MmVmscanDirectReclaimEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_nr_reclaimed() const { return at<1>().valid(); }
+  uint64_t nr_reclaimed() const { return at<1>().as_uint64(); }
+};
 
-#include <stddef.h>
-#include <stdint.h>
+class MmVmscanDirectReclaimEndFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = MmVmscanDirectReclaimEndFtraceEvent_Decoder;
+  enum : int32_t {
+    kNrReclaimedFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.MmVmscanDirectReclaimEndFtraceEvent"; }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  using FieldMetadata_NrReclaimed =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MmVmscanDirectReclaimEndFtraceEvent>;
 
+  static constexpr FieldMetadata_NrReclaimed kNrReclaimed{};
+  void set_nr_reclaimed(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NrReclaimed::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
 
-class ChromeContentSettingsEventInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class MmVmscanDirectReclaimBeginFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  ChromeContentSettingsEventInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeContentSettingsEventInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeContentSettingsEventInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_number_of_exceptions() const { return at<1>().valid(); }
-  uint32_t number_of_exceptions() const { return at<1>().as_uint32(); }
+  MmVmscanDirectReclaimBeginFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MmVmscanDirectReclaimBeginFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MmVmscanDirectReclaimBeginFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_order() const { return at<1>().valid(); }
+  int32_t order() const { return at<1>().as_int32(); }
+  bool has_may_writepage() const { return at<2>().valid(); }
+  int32_t may_writepage() const { return at<2>().as_int32(); }
+  bool has_gfp_flags() const { return at<3>().valid(); }
+  uint32_t gfp_flags() const { return at<3>().as_uint32(); }
 };
 
-class ChromeContentSettingsEventInfo : public ::protozero::Message {
+class MmVmscanDirectReclaimBeginFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = ChromeContentSettingsEventInfo_Decoder;
+  using Decoder = MmVmscanDirectReclaimBeginFtraceEvent_Decoder;
   enum : int32_t {
-    kNumberOfExceptionsFieldNumber = 1,
+    kOrderFieldNumber = 1,
+    kMayWritepageFieldNumber = 2,
+    kGfpFlagsFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeContentSettingsEventInfo"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.MmVmscanDirectReclaimBeginFtraceEvent"; }
 
 
-  using FieldMetadata_NumberOfExceptions =
+  using FieldMetadata_Order =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MmVmscanDirectReclaimBeginFtraceEvent>;
+
+  static constexpr FieldMetadata_Order kOrder{};
+  void set_order(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MayWritepage =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MmVmscanDirectReclaimBeginFtraceEvent>;
+
+  static constexpr FieldMetadata_MayWritepage kMayWritepage{};
+  void set_may_writepage(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MayWritepage::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_GfpFlags =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      ChromeContentSettingsEventInfo>;
+      MmVmscanDirectReclaimBeginFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NumberOfExceptions kNumberOfExceptions() { return {}; }
-  void set_number_of_exceptions(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NumberOfExceptions::kFieldId;
+  static constexpr FieldMetadata_GfpFlags kGfpFlags{};
+  void set_gfp_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -144142,11 +166140,11 @@ class ChromeContentSettingsEventInfo : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_frame_reporter.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/workqueue.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_FRAME_REPORTER_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_FRAME_REPORTER_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_WORKQUEUE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_WORKQUEUE_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -144157,310 +166155,70 @@ class ChromeContentSettingsEventInfo : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-namespace perfetto_pbzero_enum_ChromeFrameReporter {
-enum FrameDropReason : int32_t;
-}  // namespace perfetto_pbzero_enum_ChromeFrameReporter
-using ChromeFrameReporter_FrameDropReason = perfetto_pbzero_enum_ChromeFrameReporter::FrameDropReason;
-namespace perfetto_pbzero_enum_ChromeFrameReporter {
-enum FrameType : int32_t;
-}  // namespace perfetto_pbzero_enum_ChromeFrameReporter
-using ChromeFrameReporter_FrameType = perfetto_pbzero_enum_ChromeFrameReporter::FrameType;
-namespace perfetto_pbzero_enum_ChromeFrameReporter {
-enum ScrollState : int32_t;
-}  // namespace perfetto_pbzero_enum_ChromeFrameReporter
-using ChromeFrameReporter_ScrollState = perfetto_pbzero_enum_ChromeFrameReporter::ScrollState;
-namespace perfetto_pbzero_enum_ChromeFrameReporter {
-enum State : int32_t;
-}  // namespace perfetto_pbzero_enum_ChromeFrameReporter
-using ChromeFrameReporter_State = perfetto_pbzero_enum_ChromeFrameReporter::State;
-
-namespace perfetto_pbzero_enum_ChromeFrameReporter {
-enum State : int32_t {
-  STATE_NO_UPDATE_DESIRED = 0,
-  STATE_PRESENTED_ALL = 1,
-  STATE_PRESENTED_PARTIAL = 2,
-  STATE_DROPPED = 3,
-};
-} // namespace perfetto_pbzero_enum_ChromeFrameReporter
-using ChromeFrameReporter_State = perfetto_pbzero_enum_ChromeFrameReporter::State;
-
-
-constexpr ChromeFrameReporter_State ChromeFrameReporter_State_MIN = ChromeFrameReporter_State::STATE_NO_UPDATE_DESIRED;
-constexpr ChromeFrameReporter_State ChromeFrameReporter_State_MAX = ChromeFrameReporter_State::STATE_DROPPED;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ChromeFrameReporter_State_Name(::perfetto::protos::pbzero::ChromeFrameReporter_State value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ChromeFrameReporter_State::STATE_NO_UPDATE_DESIRED:
-    return "STATE_NO_UPDATE_DESIRED";
-
-  case ::perfetto::protos::pbzero::ChromeFrameReporter_State::STATE_PRESENTED_ALL:
-    return "STATE_PRESENTED_ALL";
-
-  case ::perfetto::protos::pbzero::ChromeFrameReporter_State::STATE_PRESENTED_PARTIAL:
-    return "STATE_PRESENTED_PARTIAL";
-
-  case ::perfetto::protos::pbzero::ChromeFrameReporter_State::STATE_DROPPED:
-    return "STATE_DROPPED";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-namespace perfetto_pbzero_enum_ChromeFrameReporter {
-enum FrameDropReason : int32_t {
-  REASON_UNSPECIFIED = 0,
-  REASON_DISPLAY_COMPOSITOR = 1,
-  REASON_MAIN_THREAD = 2,
-  REASON_CLIENT_COMPOSITOR = 3,
-};
-} // namespace perfetto_pbzero_enum_ChromeFrameReporter
-using ChromeFrameReporter_FrameDropReason = perfetto_pbzero_enum_ChromeFrameReporter::FrameDropReason;
-
-
-constexpr ChromeFrameReporter_FrameDropReason ChromeFrameReporter_FrameDropReason_MIN = ChromeFrameReporter_FrameDropReason::REASON_UNSPECIFIED;
-constexpr ChromeFrameReporter_FrameDropReason ChromeFrameReporter_FrameDropReason_MAX = ChromeFrameReporter_FrameDropReason::REASON_CLIENT_COMPOSITOR;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ChromeFrameReporter_FrameDropReason_Name(::perfetto::protos::pbzero::ChromeFrameReporter_FrameDropReason value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ChromeFrameReporter_FrameDropReason::REASON_UNSPECIFIED:
-    return "REASON_UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::ChromeFrameReporter_FrameDropReason::REASON_DISPLAY_COMPOSITOR:
-    return "REASON_DISPLAY_COMPOSITOR";
-
-  case ::perfetto::protos::pbzero::ChromeFrameReporter_FrameDropReason::REASON_MAIN_THREAD:
-    return "REASON_MAIN_THREAD";
-
-  case ::perfetto::protos::pbzero::ChromeFrameReporter_FrameDropReason::REASON_CLIENT_COMPOSITOR:
-    return "REASON_CLIENT_COMPOSITOR";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-namespace perfetto_pbzero_enum_ChromeFrameReporter {
-enum ScrollState : int32_t {
-  SCROLL_NONE = 0,
-  SCROLL_MAIN_THREAD = 1,
-  SCROLL_COMPOSITOR_THREAD = 2,
-  SCROLL_UNKNOWN = 3,
-};
-} // namespace perfetto_pbzero_enum_ChromeFrameReporter
-using ChromeFrameReporter_ScrollState = perfetto_pbzero_enum_ChromeFrameReporter::ScrollState;
-
-
-constexpr ChromeFrameReporter_ScrollState ChromeFrameReporter_ScrollState_MIN = ChromeFrameReporter_ScrollState::SCROLL_NONE;
-constexpr ChromeFrameReporter_ScrollState ChromeFrameReporter_ScrollState_MAX = ChromeFrameReporter_ScrollState::SCROLL_UNKNOWN;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ChromeFrameReporter_ScrollState_Name(::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState::SCROLL_NONE:
-    return "SCROLL_NONE";
-
-  case ::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState::SCROLL_MAIN_THREAD:
-    return "SCROLL_MAIN_THREAD";
-
-  case ::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState::SCROLL_COMPOSITOR_THREAD:
-    return "SCROLL_COMPOSITOR_THREAD";
-
-  case ::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState::SCROLL_UNKNOWN:
-    return "SCROLL_UNKNOWN";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-namespace perfetto_pbzero_enum_ChromeFrameReporter {
-enum FrameType : int32_t {
-  FORKED = 0,
-  BACKFILL = 1,
-};
-} // namespace perfetto_pbzero_enum_ChromeFrameReporter
-using ChromeFrameReporter_FrameType = perfetto_pbzero_enum_ChromeFrameReporter::FrameType;
-
-
-constexpr ChromeFrameReporter_FrameType ChromeFrameReporter_FrameType_MIN = ChromeFrameReporter_FrameType::FORKED;
-constexpr ChromeFrameReporter_FrameType ChromeFrameReporter_FrameType_MAX = ChromeFrameReporter_FrameType::BACKFILL;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ChromeFrameReporter_FrameType_Name(::perfetto::protos::pbzero::ChromeFrameReporter_FrameType value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ChromeFrameReporter_FrameType::FORKED:
-    return "FORKED";
-
-  case ::perfetto::protos::pbzero::ChromeFrameReporter_FrameType::BACKFILL:
-    return "BACKFILL";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-class ChromeFrameReporter_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/14, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class WorkqueueQueueWorkFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  ChromeFrameReporter_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeFrameReporter_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeFrameReporter_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_state() const { return at<1>().valid(); }
-  int32_t state() const { return at<1>().as_int32(); }
-  bool has_reason() const { return at<2>().valid(); }
-  int32_t reason() const { return at<2>().as_int32(); }
-  bool has_frame_source() const { return at<3>().valid(); }
-  uint64_t frame_source() const { return at<3>().as_uint64(); }
-  bool has_frame_sequence() const { return at<4>().valid(); }
-  uint64_t frame_sequence() const { return at<4>().as_uint64(); }
-  bool has_affects_smoothness() const { return at<5>().valid(); }
-  bool affects_smoothness() const { return at<5>().as_bool(); }
-  bool has_scroll_state() const { return at<6>().valid(); }
-  int32_t scroll_state() const { return at<6>().as_int32(); }
-  bool has_has_main_animation() const { return at<7>().valid(); }
-  bool has_main_animation() const { return at<7>().as_bool(); }
-  bool has_has_compositor_animation() const { return at<8>().valid(); }
-  bool has_compositor_animation() const { return at<8>().as_bool(); }
-  bool has_has_smooth_input_main() const { return at<9>().valid(); }
-  bool has_smooth_input_main() const { return at<9>().as_bool(); }
-  bool has_has_missing_content() const { return at<10>().valid(); }
-  bool has_missing_content() const { return at<10>().as_bool(); }
-  bool has_layer_tree_host_id() const { return at<11>().valid(); }
-  uint64_t layer_tree_host_id() const { return at<11>().as_uint64(); }
-  bool has_has_high_latency() const { return at<12>().valid(); }
-  bool has_high_latency() const { return at<12>().as_bool(); }
-  bool has_frame_type() const { return at<13>().valid(); }
-  int32_t frame_type() const { return at<13>().as_int32(); }
-  bool has_high_latency_contribution_stage() const { return at<14>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> high_latency_contribution_stage() const { return GetRepeated<::protozero::ConstChars>(14); }
+  WorkqueueQueueWorkFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit WorkqueueQueueWorkFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit WorkqueueQueueWorkFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_work() const { return at<1>().valid(); }
+  uint64_t work() const { return at<1>().as_uint64(); }
+  bool has_function() const { return at<2>().valid(); }
+  uint64_t function() const { return at<2>().as_uint64(); }
+  bool has_req_cpu() const { return at<4>().valid(); }
+  int32_t req_cpu() const { return at<4>().as_int32(); }
+  bool has_cpu() const { return at<5>().valid(); }
+  int32_t cpu() const { return at<5>().as_int32(); }
+  bool has_workqueue() const { return at<6>().valid(); }
+  ::protozero::ConstChars workqueue() const { return at<6>().as_string(); }
 };
 
-class ChromeFrameReporter : public ::protozero::Message {
+class WorkqueueQueueWorkFtraceEvent : public ::protozero::Message {
  public:
-  using Decoder = ChromeFrameReporter_Decoder;
+  using Decoder = WorkqueueQueueWorkFtraceEvent_Decoder;
   enum : int32_t {
-    kStateFieldNumber = 1,
-    kReasonFieldNumber = 2,
-    kFrameSourceFieldNumber = 3,
-    kFrameSequenceFieldNumber = 4,
-    kAffectsSmoothnessFieldNumber = 5,
-    kScrollStateFieldNumber = 6,
-    kHasMainAnimationFieldNumber = 7,
-    kHasCompositorAnimationFieldNumber = 8,
-    kHasSmoothInputMainFieldNumber = 9,
-    kHasMissingContentFieldNumber = 10,
-    kLayerTreeHostIdFieldNumber = 11,
-    kHasHighLatencyFieldNumber = 12,
-    kFrameTypeFieldNumber = 13,
-    kHighLatencyContributionStageFieldNumber = 14,
+    kWorkFieldNumber = 1,
+    kFunctionFieldNumber = 2,
+    kReqCpuFieldNumber = 4,
+    kCpuFieldNumber = 5,
+    kWorkqueueFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeFrameReporter"; }
-
-
-  using State = ::perfetto::protos::pbzero::ChromeFrameReporter_State;
-  static inline const char* State_Name(State value) {
-    return ::perfetto::protos::pbzero::ChromeFrameReporter_State_Name(value);
-  }
-
-  using FrameDropReason = ::perfetto::protos::pbzero::ChromeFrameReporter_FrameDropReason;
-  static inline const char* FrameDropReason_Name(FrameDropReason value) {
-    return ::perfetto::protos::pbzero::ChromeFrameReporter_FrameDropReason_Name(value);
-  }
-
-  using ScrollState = ::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState;
-  static inline const char* ScrollState_Name(ScrollState value) {
-    return ::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState_Name(value);
-  }
-
-  using FrameType = ::perfetto::protos::pbzero::ChromeFrameReporter_FrameType;
-  static inline const char* FrameType_Name(FrameType value) {
-    return ::perfetto::protos::pbzero::ChromeFrameReporter_FrameType_Name(value);
-  }
-  static const State STATE_NO_UPDATE_DESIRED = State::STATE_NO_UPDATE_DESIRED;
-  static const State STATE_PRESENTED_ALL = State::STATE_PRESENTED_ALL;
-  static const State STATE_PRESENTED_PARTIAL = State::STATE_PRESENTED_PARTIAL;
-  static const State STATE_DROPPED = State::STATE_DROPPED;
-  static const FrameDropReason REASON_UNSPECIFIED = FrameDropReason::REASON_UNSPECIFIED;
-  static const FrameDropReason REASON_DISPLAY_COMPOSITOR = FrameDropReason::REASON_DISPLAY_COMPOSITOR;
-  static const FrameDropReason REASON_MAIN_THREAD = FrameDropReason::REASON_MAIN_THREAD;
-  static const FrameDropReason REASON_CLIENT_COMPOSITOR = FrameDropReason::REASON_CLIENT_COMPOSITOR;
-  static const ScrollState SCROLL_NONE = ScrollState::SCROLL_NONE;
-  static const ScrollState SCROLL_MAIN_THREAD = ScrollState::SCROLL_MAIN_THREAD;
-  static const ScrollState SCROLL_COMPOSITOR_THREAD = ScrollState::SCROLL_COMPOSITOR_THREAD;
-  static const ScrollState SCROLL_UNKNOWN = ScrollState::SCROLL_UNKNOWN;
-  static const FrameType FORKED = FrameType::FORKED;
-  static const FrameType BACKFILL = FrameType::BACKFILL;
-
-  using FieldMetadata_State =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ChromeFrameReporter_State,
-      ChromeFrameReporter>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_State kState() { return {}; }
-  void set_state(::perfetto::protos::pbzero::ChromeFrameReporter_State value) {
-    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
+  static constexpr const char* GetName() { return ".perfetto.protos.WorkqueueQueueWorkFtraceEvent"; }
 
-  using FieldMetadata_Reason =
+
+  using FieldMetadata_Work =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ChromeFrameReporter_FrameDropReason,
-      ChromeFrameReporter>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      WorkqueueQueueWorkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Reason kReason() { return {}; }
-  void set_reason(::perfetto::protos::pbzero::ChromeFrameReporter_FrameDropReason value) {
-    static constexpr uint32_t field_id = FieldMetadata_Reason::kFieldId;
+  static constexpr FieldMetadata_Work kWork{};
+  void set_work(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Work::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FrameSource =
+  using FieldMetadata_Function =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      ChromeFrameReporter>;
+      WorkqueueQueueWorkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FrameSource kFrameSource() { return {}; }
-  void set_frame_source(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FrameSource::kFieldId;
+  static constexpr FieldMetadata_Function kFunction{};
+  void set_function(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Function::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -144468,199 +166226,215 @@ class ChromeFrameReporter : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FrameSequence =
+  using FieldMetadata_ReqCpu =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ChromeFrameReporter>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      WorkqueueQueueWorkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FrameSequence kFrameSequence() { return {}; }
-  void set_frame_sequence(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FrameSequence::kFieldId;
+  static constexpr FieldMetadata_ReqCpu kReqCpu{};
+  void set_req_cpu(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReqCpu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_AffectsSmoothness =
+  using FieldMetadata_Cpu =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeFrameReporter>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      WorkqueueQueueWorkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AffectsSmoothness kAffectsSmoothness() { return {}; }
-  void set_affects_smoothness(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_AffectsSmoothness::kFieldId;
+  static constexpr FieldMetadata_Cpu kCpu{};
+  void set_cpu(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ScrollState =
+  using FieldMetadata_Workqueue =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState,
-      ChromeFrameReporter>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      WorkqueueQueueWorkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ScrollState kScrollState() { return {}; }
-  void set_scroll_state(::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState value) {
-    static constexpr uint32_t field_id = FieldMetadata_ScrollState::kFieldId;
+  static constexpr FieldMetadata_Workqueue kWorkqueue{};
+  void set_workqueue(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Workqueue::kFieldId, data, size);
+  }
+  void set_workqueue(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Workqueue::kFieldId, chars.data, chars.size);
+  }
+  void set_workqueue(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Workqueue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_HasMainAnimation =
+class WorkqueueExecuteStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  WorkqueueExecuteStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit WorkqueueExecuteStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit WorkqueueExecuteStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_work() const { return at<1>().valid(); }
+  uint64_t work() const { return at<1>().as_uint64(); }
+  bool has_function() const { return at<2>().valid(); }
+  uint64_t function() const { return at<2>().as_uint64(); }
+};
+
+class WorkqueueExecuteStartFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = WorkqueueExecuteStartFtraceEvent_Decoder;
+  enum : int32_t {
+    kWorkFieldNumber = 1,
+    kFunctionFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.WorkqueueExecuteStartFtraceEvent"; }
+
+
+  using FieldMetadata_Work =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeFrameReporter>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      WorkqueueExecuteStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HasMainAnimation kHasMainAnimation() { return {}; }
-  void set_has_main_animation(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_HasMainAnimation::kFieldId;
+  static constexpr FieldMetadata_Work kWork{};
+  void set_work(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Work::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_HasCompositorAnimation =
+  using FieldMetadata_Function =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeFrameReporter>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      WorkqueueExecuteStartFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HasCompositorAnimation kHasCompositorAnimation() { return {}; }
-  void set_has_compositor_animation(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_HasCompositorAnimation::kFieldId;
+  static constexpr FieldMetadata_Function kFunction{};
+  void set_function(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Function::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_HasSmoothInputMain =
+class WorkqueueExecuteEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  WorkqueueExecuteEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit WorkqueueExecuteEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit WorkqueueExecuteEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_work() const { return at<1>().valid(); }
+  uint64_t work() const { return at<1>().as_uint64(); }
+  bool has_function() const { return at<2>().valid(); }
+  uint64_t function() const { return at<2>().as_uint64(); }
+};
+
+class WorkqueueExecuteEndFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = WorkqueueExecuteEndFtraceEvent_Decoder;
+  enum : int32_t {
+    kWorkFieldNumber = 1,
+    kFunctionFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.WorkqueueExecuteEndFtraceEvent"; }
+
+
+  using FieldMetadata_Work =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeFrameReporter>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      WorkqueueExecuteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HasSmoothInputMain kHasSmoothInputMain() { return {}; }
-  void set_has_smooth_input_main(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_HasSmoothInputMain::kFieldId;
+  static constexpr FieldMetadata_Work kWork{};
+  void set_work(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Work::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_HasMissingContent =
+  using FieldMetadata_Function =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeFrameReporter>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      WorkqueueExecuteEndFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HasMissingContent kHasMissingContent() { return {}; }
-  void set_has_missing_content(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_HasMissingContent::kFieldId;
+  static constexpr FieldMetadata_Function kFunction{};
+  void set_function(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Function::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_LayerTreeHostId =
+class WorkqueueActivateWorkFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  WorkqueueActivateWorkFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit WorkqueueActivateWorkFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit WorkqueueActivateWorkFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_work() const { return at<1>().valid(); }
+  uint64_t work() const { return at<1>().as_uint64(); }
+  bool has_function() const { return at<2>().valid(); }
+  uint64_t function() const { return at<2>().as_uint64(); }
+};
+
+class WorkqueueActivateWorkFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = WorkqueueActivateWorkFtraceEvent_Decoder;
+  enum : int32_t {
+    kWorkFieldNumber = 1,
+    kFunctionFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.WorkqueueActivateWorkFtraceEvent"; }
+
+
+  using FieldMetadata_Work =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      ChromeFrameReporter>;
+      WorkqueueActivateWorkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LayerTreeHostId kLayerTreeHostId() { return {}; }
-  void set_layer_tree_host_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LayerTreeHostId::kFieldId;
+  static constexpr FieldMetadata_Work kWork{};
+  void set_work(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Work::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -144668,84 +166442,103 @@ class ChromeFrameReporter : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_HasHighLatency =
+  using FieldMetadata_Function =
     ::protozero::proto_utils::FieldMetadata<
-      12,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeFrameReporter>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      WorkqueueActivateWorkFtraceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HasHighLatency kHasHighLatency() { return {}; }
-  void set_has_high_latency(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_HasHighLatency::kFieldId;
+  static constexpr FieldMetadata_Function kFunction{};
+  void set_function(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Function::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_FrameType =
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/generic_kernel/generic_power.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GENERIC_KERNEL_GENERIC_POWER_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GENERIC_KERNEL_GENERIC_POWER_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class GenericKernelCpuFrequencyEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  GenericKernelCpuFrequencyEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GenericKernelCpuFrequencyEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GenericKernelCpuFrequencyEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cpu() const { return at<1>().valid(); }
+  int32_t cpu() const { return at<1>().as_int32(); }
+  bool has_freq_hz() const { return at<2>().valid(); }
+  int64_t freq_hz() const { return at<2>().as_int64(); }
+};
+
+class GenericKernelCpuFrequencyEvent : public ::protozero::Message {
+ public:
+  using Decoder = GenericKernelCpuFrequencyEvent_Decoder;
+  enum : int32_t {
+    kCpuFieldNumber = 1,
+    kFreqHzFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.GenericKernelCpuFrequencyEvent"; }
+
+
+  using FieldMetadata_Cpu =
     ::protozero::proto_utils::FieldMetadata<
-      13,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ChromeFrameReporter_FrameType,
-      ChromeFrameReporter>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      GenericKernelCpuFrequencyEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FrameType kFrameType() { return {}; }
-  void set_frame_type(::perfetto::protos::pbzero::ChromeFrameReporter_FrameType value) {
-    static constexpr uint32_t field_id = FieldMetadata_FrameType::kFieldId;
+  static constexpr FieldMetadata_Cpu kCpu{};
+  void set_cpu(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_HighLatencyContributionStage =
+  using FieldMetadata_FreqHz =
     ::protozero::proto_utils::FieldMetadata<
-      14,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeFrameReporter>;
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      GenericKernelCpuFrequencyEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HighLatencyContributionStage kHighLatencyContributionStage() { return {}; }
-  void add_high_latency_contribution_stage(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_HighLatencyContributionStage::kFieldId, data, size);
-  }
-  void add_high_latency_contribution_stage(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_HighLatencyContributionStage::kFieldId, chars.data, chars.size);
-  }
-  void add_high_latency_contribution_stage(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_HighLatencyContributionStage::kFieldId;
+  static constexpr FieldMetadata_FreqHz kFreqHz{};
+  void set_freq_hz(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FreqHz::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 };
@@ -144754,11 +166547,11 @@ class ChromeFrameReporter : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_histogram_sample.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/generic_kernel/generic_task.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_HISTOGRAM_SAMPLE_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_HISTOGRAM_SAMPLE_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GENERIC_KERNEL_GENERIC_TASK_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GENERIC_KERNEL_GENERIC_TASK_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -144772,109 +166565,251 @@ class ChromeFrameReporter : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
+class GenericKernelProcessTree_Process;
+class GenericKernelProcessTree_Thread;
+namespace perfetto_pbzero_enum_GenericKernelTaskStateEvent {
+enum TaskStateEnum : int32_t;
+}  // namespace perfetto_pbzero_enum_GenericKernelTaskStateEvent
+using GenericKernelTaskStateEvent_TaskStateEnum = perfetto_pbzero_enum_GenericKernelTaskStateEvent::TaskStateEnum;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_GenericKernelTaskStateEvent {
+enum TaskStateEnum : int32_t {
+  TASK_STATE_UNKNOWN = 0,
+  TASK_STATE_CREATED = 1,
+  TASK_STATE_RUNNABLE = 2,
+  TASK_STATE_RUNNING = 3,
+  TASK_STATE_INTERRUPTIBLE_SLEEP = 4,
+  TASK_STATE_UNINTERRUPTIBLE_SLEEP = 5,
+  TASK_STATE_STOPPED = 6,
+  TASK_STATE_DEAD = 7,
+  TASK_STATE_DESTROYED = 8,
+};
+} // namespace perfetto_pbzero_enum_GenericKernelTaskStateEvent
+using GenericKernelTaskStateEvent_TaskStateEnum = perfetto_pbzero_enum_GenericKernelTaskStateEvent::TaskStateEnum;
+
+
+constexpr GenericKernelTaskStateEvent_TaskStateEnum GenericKernelTaskStateEvent_TaskStateEnum_MIN = GenericKernelTaskStateEvent_TaskStateEnum::TASK_STATE_UNKNOWN;
+constexpr GenericKernelTaskStateEvent_TaskStateEnum GenericKernelTaskStateEvent_TaskStateEnum_MAX = GenericKernelTaskStateEvent_TaskStateEnum::TASK_STATE_DESTROYED;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* GenericKernelTaskStateEvent_TaskStateEnum_Name(::perfetto::protos::pbzero::GenericKernelTaskStateEvent_TaskStateEnum value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::GenericKernelTaskStateEvent_TaskStateEnum::TASK_STATE_UNKNOWN:
+    return "TASK_STATE_UNKNOWN";
+
+  case ::perfetto::protos::pbzero::GenericKernelTaskStateEvent_TaskStateEnum::TASK_STATE_CREATED:
+    return "TASK_STATE_CREATED";
+
+  case ::perfetto::protos::pbzero::GenericKernelTaskStateEvent_TaskStateEnum::TASK_STATE_RUNNABLE:
+    return "TASK_STATE_RUNNABLE";
+
+  case ::perfetto::protos::pbzero::GenericKernelTaskStateEvent_TaskStateEnum::TASK_STATE_RUNNING:
+    return "TASK_STATE_RUNNING";
+
+  case ::perfetto::protos::pbzero::GenericKernelTaskStateEvent_TaskStateEnum::TASK_STATE_INTERRUPTIBLE_SLEEP:
+    return "TASK_STATE_INTERRUPTIBLE_SLEEP";
+
+  case ::perfetto::protos::pbzero::GenericKernelTaskStateEvent_TaskStateEnum::TASK_STATE_UNINTERRUPTIBLE_SLEEP:
+    return "TASK_STATE_UNINTERRUPTIBLE_SLEEP";
+
+  case ::perfetto::protos::pbzero::GenericKernelTaskStateEvent_TaskStateEnum::TASK_STATE_STOPPED:
+    return "TASK_STATE_STOPPED";
+
+  case ::perfetto::protos::pbzero::GenericKernelTaskStateEvent_TaskStateEnum::TASK_STATE_DEAD:
+    return "TASK_STATE_DEAD";
 
+  case ::perfetto::protos::pbzero::GenericKernelTaskStateEvent_TaskStateEnum::TASK_STATE_DESTROYED:
+    return "TASK_STATE_DESTROYED";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
-class ChromeHistogramSample_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class GenericKernelProcessTree_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  ChromeHistogramSample_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeHistogramSample_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeHistogramSample_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name_hash() const { return at<1>().valid(); }
-  uint64_t name_hash() const { return at<1>().as_uint64(); }
-  bool has_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars name() const { return at<2>().as_string(); }
-  bool has_sample() const { return at<3>().valid(); }
-  int64_t sample() const { return at<3>().as_int64(); }
-  bool has_name_iid() const { return at<4>().valid(); }
-  uint64_t name_iid() const { return at<4>().as_uint64(); }
+  GenericKernelProcessTree_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GenericKernelProcessTree_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GenericKernelProcessTree_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_processes() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> processes() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  bool has_threads() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> threads() const { return GetRepeated<::protozero::ConstBytes>(2); }
 };
 
-class ChromeHistogramSample : public ::protozero::Message {
+class GenericKernelProcessTree : public ::protozero::Message {
  public:
-  using Decoder = ChromeHistogramSample_Decoder;
+  using Decoder = GenericKernelProcessTree_Decoder;
   enum : int32_t {
-    kNameHashFieldNumber = 1,
-    kNameFieldNumber = 2,
-    kSampleFieldNumber = 3,
-    kNameIidFieldNumber = 4,
+    kProcessesFieldNumber = 1,
+    kThreadsFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeHistogramSample"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.GenericKernelProcessTree"; }
 
+  using Thread = ::perfetto::protos::pbzero::GenericKernelProcessTree_Thread;
+  using Process = ::perfetto::protos::pbzero::GenericKernelProcessTree_Process;
 
-  using FieldMetadata_NameHash =
+  using FieldMetadata_Processes =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      GenericKernelProcessTree_Process,
+      GenericKernelProcessTree>;
+
+  static constexpr FieldMetadata_Processes kProcesses{};
+  template <typename T = GenericKernelProcessTree_Process> T* add_processes() {
+    return BeginNestedMessage<T>(1);
+  }
+
+
+  using FieldMetadata_Threads =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      GenericKernelProcessTree_Thread,
+      GenericKernelProcessTree>;
+
+  static constexpr FieldMetadata_Threads kThreads{};
+  template <typename T = GenericKernelProcessTree_Thread> T* add_threads() {
+    return BeginNestedMessage<T>(2);
+  }
+
+};
+
+class GenericKernelProcessTree_Process_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  GenericKernelProcessTree_Process_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GenericKernelProcessTree_Process_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GenericKernelProcessTree_Process_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  int64_t pid() const { return at<1>().as_int64(); }
+  bool has_ppid() const { return at<2>().valid(); }
+  int64_t ppid() const { return at<2>().as_int64(); }
+  bool has_cmdline() const { return at<3>().valid(); }
+  ::protozero::ConstChars cmdline() const { return at<3>().as_string(); }
+};
+
+class GenericKernelProcessTree_Process : public ::protozero::Message {
+ public:
+  using Decoder = GenericKernelProcessTree_Process_Decoder;
+  enum : int32_t {
+    kPidFieldNumber = 1,
+    kPpidFieldNumber = 2,
+    kCmdlineFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.GenericKernelProcessTree.Process"; }
+
+
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ChromeHistogramSample>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      GenericKernelProcessTree_Process>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NameHash kNameHash() { return {}; }
-  void set_name_hash(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NameHash::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Name =
+  using FieldMetadata_Ppid =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      GenericKernelProcessTree_Process>;
+
+  static constexpr FieldMetadata_Ppid kPpid{};
+  void set_ppid(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ppid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Cmdline =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      ChromeHistogramSample>;
+      GenericKernelProcessTree_Process>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  static constexpr FieldMetadata_Cmdline kCmdline{};
+  void set_cmdline(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Cmdline::kFieldId, data, size);
   }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  void set_cmdline(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Cmdline::kFieldId, chars.data, chars.size);
   }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  void set_cmdline(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cmdline::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Sample =
+class GenericKernelProcessTree_Thread_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  GenericKernelProcessTree_Thread_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GenericKernelProcessTree_Thread_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GenericKernelProcessTree_Thread_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_tid() const { return at<1>().valid(); }
+  int64_t tid() const { return at<1>().as_int64(); }
+  bool has_pid() const { return at<2>().valid(); }
+  int64_t pid() const { return at<2>().as_int64(); }
+  bool has_comm() const { return at<3>().valid(); }
+  ::protozero::ConstChars comm() const { return at<3>().as_string(); }
+  bool has_is_main_thread() const { return at<4>().valid(); }
+  bool is_main_thread() const { return at<4>().as_bool(); }
+  bool has_is_idle() const { return at<5>().valid(); }
+  bool is_idle() const { return at<5>().as_bool(); }
+};
+
+class GenericKernelProcessTree_Thread : public ::protozero::Message {
+ public:
+  using Decoder = GenericKernelProcessTree_Thread_Decoder;
+  enum : int32_t {
+    kTidFieldNumber = 1,
+    kPidFieldNumber = 2,
+    kCommFieldNumber = 3,
+    kIsMainThreadFieldNumber = 4,
+    kIsIdleFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.GenericKernelProcessTree.Thread"; }
+
+
+  using FieldMetadata_Tid =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt64,
       int64_t,
-      ChromeHistogramSample>;
+      GenericKernelProcessTree_Thread>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Sample kSample() { return {}; }
-  void set_sample(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Sample::kFieldId;
+  static constexpr FieldMetadata_Tid kTid{};
+  void set_tid(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -144882,102 +166817,141 @@ class ChromeHistogramSample : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NameIid =
+  using FieldMetadata_Pid =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      GenericKernelProcessTree_Thread>;
+
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Comm =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      GenericKernelProcessTree_Thread>;
+
+  static constexpr FieldMetadata_Comm kComm{};
+  void set_comm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
+  }
+  void set_comm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
+  }
+  void set_comm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IsMainThread =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ChromeHistogramSample>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      GenericKernelProcessTree_Thread>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NameIid kNameIid() { return {}; }
-  void set_name_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NameIid::kFieldId;
+  static constexpr FieldMetadata_IsMainThread kIsMainThread{};
+  void set_is_main_thread(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsMainThread::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IsIdle =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      GenericKernelProcessTree_Thread>;
+
+  static constexpr FieldMetadata_IsIdle kIsIdle{};
+  void set_is_idle(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsIdle::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 };
 
-class HistogramName_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class GenericKernelTaskRenameEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  HistogramName_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit HistogramName_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit HistogramName_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_iid() const { return at<1>().valid(); }
-  uint64_t iid() const { return at<1>().as_uint64(); }
-  bool has_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars name() const { return at<2>().as_string(); }
+  GenericKernelTaskRenameEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GenericKernelTaskRenameEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GenericKernelTaskRenameEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_tid() const { return at<1>().valid(); }
+  int64_t tid() const { return at<1>().as_int64(); }
+  bool has_comm() const { return at<2>().valid(); }
+  ::protozero::ConstChars comm() const { return at<2>().as_string(); }
 };
 
-class HistogramName : public ::protozero::Message {
+class GenericKernelTaskRenameEvent : public ::protozero::Message {
  public:
-  using Decoder = HistogramName_Decoder;
+  using Decoder = GenericKernelTaskRenameEvent_Decoder;
   enum : int32_t {
-    kIidFieldNumber = 1,
-    kNameFieldNumber = 2,
+    kTidFieldNumber = 1,
+    kCommFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.HistogramName"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.GenericKernelTaskRenameEvent"; }
 
 
-  using FieldMetadata_Iid =
+  using FieldMetadata_Tid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      HistogramName>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      GenericKernelTaskRenameEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Iid kIid() { return {}; }
-  void set_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
+  static constexpr FieldMetadata_Tid kTid{};
+  void set_tid(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Name =
+  using FieldMetadata_Comm =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      HistogramName>;
+      GenericKernelTaskRenameEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  static constexpr FieldMetadata_Comm kComm{};
+  void set_comm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
   }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  void set_comm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
   }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  void set_comm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -144986,89 +166960,156 @@ class HistogramName : public ::protozero::Message {
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_keyed_service.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_KEYED_SERVICE_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_KEYED_SERVICE_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class ChromeKeyedService_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class GenericKernelTaskStateEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  ChromeKeyedService_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeKeyedService_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeKeyedService_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  GenericKernelTaskStateEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GenericKernelTaskStateEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GenericKernelTaskStateEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cpu() const { return at<1>().valid(); }
+  int32_t cpu() const { return at<1>().as_int32(); }
+  bool has_comm() const { return at<2>().valid(); }
+  ::protozero::ConstChars comm() const { return at<2>().as_string(); }
+  bool has_tid() const { return at<3>().valid(); }
+  int64_t tid() const { return at<3>().as_int64(); }
+  bool has_state() const { return at<4>().valid(); }
+  int32_t state() const { return at<4>().as_int32(); }
+  bool has_prio() const { return at<5>().valid(); }
+  int32_t prio() const { return at<5>().as_int32(); }
 };
 
-class ChromeKeyedService : public ::protozero::Message {
+class GenericKernelTaskStateEvent : public ::protozero::Message {
  public:
-  using Decoder = ChromeKeyedService_Decoder;
+  using Decoder = GenericKernelTaskStateEvent_Decoder;
   enum : int32_t {
-    kNameFieldNumber = 1,
+    kCpuFieldNumber = 1,
+    kCommFieldNumber = 2,
+    kTidFieldNumber = 3,
+    kStateFieldNumber = 4,
+    kPrioFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeKeyedService"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.GenericKernelTaskStateEvent"; }
 
 
-  using FieldMetadata_Name =
+  using TaskStateEnum = ::perfetto::protos::pbzero::GenericKernelTaskStateEvent_TaskStateEnum;
+  static inline const char* TaskStateEnum_Name(TaskStateEnum value) {
+    return ::perfetto::protos::pbzero::GenericKernelTaskStateEvent_TaskStateEnum_Name(value);
+  }
+  static inline const TaskStateEnum TASK_STATE_UNKNOWN = TaskStateEnum::TASK_STATE_UNKNOWN;
+  static inline const TaskStateEnum TASK_STATE_CREATED = TaskStateEnum::TASK_STATE_CREATED;
+  static inline const TaskStateEnum TASK_STATE_RUNNABLE = TaskStateEnum::TASK_STATE_RUNNABLE;
+  static inline const TaskStateEnum TASK_STATE_RUNNING = TaskStateEnum::TASK_STATE_RUNNING;
+  static inline const TaskStateEnum TASK_STATE_INTERRUPTIBLE_SLEEP = TaskStateEnum::TASK_STATE_INTERRUPTIBLE_SLEEP;
+  static inline const TaskStateEnum TASK_STATE_UNINTERRUPTIBLE_SLEEP = TaskStateEnum::TASK_STATE_UNINTERRUPTIBLE_SLEEP;
+  static inline const TaskStateEnum TASK_STATE_STOPPED = TaskStateEnum::TASK_STATE_STOPPED;
+  static inline const TaskStateEnum TASK_STATE_DEAD = TaskStateEnum::TASK_STATE_DEAD;
+  static inline const TaskStateEnum TASK_STATE_DESTROYED = TaskStateEnum::TASK_STATE_DESTROYED;
+
+  using FieldMetadata_Cpu =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      GenericKernelTaskStateEvent>;
+
+  static constexpr FieldMetadata_Cpu kCpu{};
+  void set_cpu(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Comm =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      ChromeKeyedService>;
+      GenericKernelTaskStateEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  static constexpr FieldMetadata_Comm kComm{};
+  void set_comm(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, data, size);
   }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  void set_comm(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size);
   }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  void set_comm(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_Tid =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      GenericKernelTaskStateEvent>;
+
+  static constexpr FieldMetadata_Tid kTid{};
+  void set_tid(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_State =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      GenericKernelTaskStateEvent_TaskStateEnum,
+      GenericKernelTaskStateEvent>;
+
+  static constexpr FieldMetadata_State kState{};
+  void set_state(GenericKernelTaskStateEvent_TaskStateEnum value) {
+    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Prio =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      GenericKernelTaskStateEvent>;
+
+  static constexpr FieldMetadata_Prio kPrio{};
+  void set_prio(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 };
 
 } // Namespace.
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_latency_info.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/gpu/gpu_counter_event.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LATENCY_INFO_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LATENCY_INFO_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GPU_GPU_COUNTER_EVENT_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GPU_GPU_COUNTER_EVENT_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -145082,444 +167123,288 @@ class ChromeKeyedService : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
+class GpuCounterDescriptor;
+class GpuCounterEvent_GpuCounter;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-class ChromeLatencyInfo_ComponentInfo;
-namespace perfetto_pbzero_enum_ChromeLatencyInfo {
-enum LatencyComponentType : int32_t;
-}  // namespace perfetto_pbzero_enum_ChromeLatencyInfo
-using ChromeLatencyInfo_LatencyComponentType = perfetto_pbzero_enum_ChromeLatencyInfo::LatencyComponentType;
-namespace perfetto_pbzero_enum_ChromeLatencyInfo {
-enum Step : int32_t;
-}  // namespace perfetto_pbzero_enum_ChromeLatencyInfo
-using ChromeLatencyInfo_Step = perfetto_pbzero_enum_ChromeLatencyInfo::Step;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-namespace perfetto_pbzero_enum_ChromeLatencyInfo {
-enum Step : int32_t {
-  STEP_UNSPECIFIED = 0,
-  STEP_SEND_INPUT_EVENT_UI = 3,
-  STEP_HANDLE_INPUT_EVENT_IMPL = 5,
-  STEP_DID_HANDLE_INPUT_AND_OVERSCROLL = 8,
-  STEP_HANDLE_INPUT_EVENT_MAIN = 4,
-  STEP_MAIN_THREAD_SCROLL_UPDATE = 2,
-  STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT = 1,
-  STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL = 9,
-  STEP_HANDLED_INPUT_EVENT_IMPL = 10,
-  STEP_SWAP_BUFFERS = 6,
-  STEP_DRAW_AND_SWAP = 7,
-  STEP_FINISHED_SWAP_BUFFERS = 11,
+class GpuCounterEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  GpuCounterEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GpuCounterEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GpuCounterEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_counter_descriptor() const { return at<1>().valid(); }
+  ::protozero::ConstBytes counter_descriptor() const { return at<1>().as_bytes(); }
+  bool has_counters() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> counters() const { return GetRepeated<::protozero::ConstBytes>(2); }
+  bool has_gpu_id() const { return at<3>().valid(); }
+  int32_t gpu_id() const { return at<3>().as_int32(); }
 };
-} // namespace perfetto_pbzero_enum_ChromeLatencyInfo
-using ChromeLatencyInfo_Step = perfetto_pbzero_enum_ChromeLatencyInfo::Step;
-
-
-constexpr ChromeLatencyInfo_Step ChromeLatencyInfo_Step_MIN = ChromeLatencyInfo_Step::STEP_UNSPECIFIED;
-constexpr ChromeLatencyInfo_Step ChromeLatencyInfo_Step_MAX = ChromeLatencyInfo_Step::STEP_FINISHED_SWAP_BUFFERS;
-
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ChromeLatencyInfo_Step_Name(::perfetto::protos::pbzero::ChromeLatencyInfo_Step value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_UNSPECIFIED:
-    return "STEP_UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_SEND_INPUT_EVENT_UI:
-    return "STEP_SEND_INPUT_EVENT_UI";
-
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_HANDLE_INPUT_EVENT_IMPL:
-    return "STEP_HANDLE_INPUT_EVENT_IMPL";
-
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_DID_HANDLE_INPUT_AND_OVERSCROLL:
-    return "STEP_DID_HANDLE_INPUT_AND_OVERSCROLL";
-
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_HANDLE_INPUT_EVENT_MAIN:
-    return "STEP_HANDLE_INPUT_EVENT_MAIN";
-
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_MAIN_THREAD_SCROLL_UPDATE:
-    return "STEP_MAIN_THREAD_SCROLL_UPDATE";
-
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT:
-    return "STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT";
-
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL:
-    return "STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL";
-
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_HANDLED_INPUT_EVENT_IMPL:
-    return "STEP_HANDLED_INPUT_EVENT_IMPL";
+class GpuCounterEvent : public ::protozero::Message {
+ public:
+  using Decoder = GpuCounterEvent_Decoder;
+  enum : int32_t {
+    kCounterDescriptorFieldNumber = 1,
+    kCountersFieldNumber = 2,
+    kGpuIdFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.GpuCounterEvent"; }
 
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_SWAP_BUFFERS:
-    return "STEP_SWAP_BUFFERS";
+  using GpuCounter = ::perfetto::protos::pbzero::GpuCounterEvent_GpuCounter;
 
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_DRAW_AND_SWAP:
-    return "STEP_DRAW_AND_SWAP";
+  using FieldMetadata_CounterDescriptor =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      GpuCounterDescriptor,
+      GpuCounterEvent>;
 
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_FINISHED_SWAP_BUFFERS:
-    return "STEP_FINISHED_SWAP_BUFFERS";
+  static constexpr FieldMetadata_CounterDescriptor kCounterDescriptor{};
+  template <typename T = GpuCounterDescriptor> T* set_counter_descriptor() {
+    return BeginNestedMessage<T>(1);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-namespace perfetto_pbzero_enum_ChromeLatencyInfo {
-enum LatencyComponentType : int32_t {
-  COMPONENT_UNSPECIFIED = 0,
-  COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH = 1,
-  COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL = 2,
-  COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL = 3,
-  COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL = 4,
-  COMPONENT_INPUT_EVENT_LATENCY_UI = 5,
-  COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN = 6,
-  COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN = 7,
-  COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL = 8,
-  COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT = 9,
-  COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH = 10,
-  COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP = 11,
-  COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME = 12,
-  COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER = 13,
-  COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP = 14,
-};
-} // namespace perfetto_pbzero_enum_ChromeLatencyInfo
-using ChromeLatencyInfo_LatencyComponentType = perfetto_pbzero_enum_ChromeLatencyInfo::LatencyComponentType;
-
-
-constexpr ChromeLatencyInfo_LatencyComponentType ChromeLatencyInfo_LatencyComponentType_MIN = ChromeLatencyInfo_LatencyComponentType::COMPONENT_UNSPECIFIED;
-constexpr ChromeLatencyInfo_LatencyComponentType ChromeLatencyInfo_LatencyComponentType_MAX = ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ChromeLatencyInfo_LatencyComponentType_Name(::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_UNSPECIFIED:
-    return "COMPONENT_UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH:
-    return "COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH";
-
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL:
-    return "COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL";
-
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL:
-    return "COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL";
-
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL:
-    return "COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL";
-
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_UI:
-    return "COMPONENT_INPUT_EVENT_LATENCY_UI";
-
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN:
-    return "COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN";
-
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN:
-    return "COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN";
-
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL:
-    return "COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL";
 
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT:
-    return "COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT";
 
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH:
-    return "COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH";
+  using FieldMetadata_Counters =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      GpuCounterEvent_GpuCounter,
+      GpuCounterEvent>;
 
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP:
-    return "COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP";
+  static constexpr FieldMetadata_Counters kCounters{};
+  template <typename T = GpuCounterEvent_GpuCounter> T* add_counters() {
+    return BeginNestedMessage<T>(2);
+  }
 
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME:
-    return "COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME";
 
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER:
-    return "COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER";
+  using FieldMetadata_GpuId =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      GpuCounterEvent>;
 
-  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP:
-    return "COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP";
+  static constexpr FieldMetadata_GpuId kGpuId{};
+  void set_gpu_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GpuId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+};
 
-class ChromeLatencyInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class GpuCounterEvent_GpuCounter_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  ChromeLatencyInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeLatencyInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeLatencyInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_trace_id() const { return at<1>().valid(); }
-  int64_t trace_id() const { return at<1>().as_int64(); }
-  bool has_step() const { return at<2>().valid(); }
-  int32_t step() const { return at<2>().as_int32(); }
-  bool has_frame_tree_node_id() const { return at<3>().valid(); }
-  int32_t frame_tree_node_id() const { return at<3>().as_int32(); }
-  bool has_component_info() const { return at<4>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> component_info() const { return GetRepeated<::protozero::ConstBytes>(4); }
-  bool has_is_coalesced() const { return at<5>().valid(); }
-  bool is_coalesced() const { return at<5>().as_bool(); }
-  bool has_gesture_scroll_id() const { return at<6>().valid(); }
-  int64_t gesture_scroll_id() const { return at<6>().as_int64(); }
-  bool has_touch_id() const { return at<7>().valid(); }
-  int64_t touch_id() const { return at<7>().as_int64(); }
+  GpuCounterEvent_GpuCounter_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GpuCounterEvent_GpuCounter_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GpuCounterEvent_GpuCounter_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_counter_id() const { return at<1>().valid(); }
+  uint32_t counter_id() const { return at<1>().as_uint32(); }
+  bool has_int_value() const { return at<2>().valid(); }
+  int64_t int_value() const { return at<2>().as_int64(); }
+  bool has_double_value() const { return at<3>().valid(); }
+  double double_value() const { return at<3>().as_double(); }
 };
 
-class ChromeLatencyInfo : public ::protozero::Message {
+class GpuCounterEvent_GpuCounter : public ::protozero::Message {
  public:
-  using Decoder = ChromeLatencyInfo_Decoder;
+  using Decoder = GpuCounterEvent_GpuCounter_Decoder;
   enum : int32_t {
-    kTraceIdFieldNumber = 1,
-    kStepFieldNumber = 2,
-    kFrameTreeNodeIdFieldNumber = 3,
-    kComponentInfoFieldNumber = 4,
-    kIsCoalescedFieldNumber = 5,
-    kGestureScrollIdFieldNumber = 6,
-    kTouchIdFieldNumber = 7,
+    kCounterIdFieldNumber = 1,
+    kIntValueFieldNumber = 2,
+    kDoubleValueFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeLatencyInfo"; }
-
-  using ComponentInfo = ::perfetto::protos::pbzero::ChromeLatencyInfo_ComponentInfo;
-
-  using Step = ::perfetto::protos::pbzero::ChromeLatencyInfo_Step;
-  static inline const char* Step_Name(Step value) {
-    return ::perfetto::protos::pbzero::ChromeLatencyInfo_Step_Name(value);
-  }
+  static constexpr const char* GetName() { return ".perfetto.protos.GpuCounterEvent.GpuCounter"; }
 
-  using LatencyComponentType = ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType;
-  static inline const char* LatencyComponentType_Name(LatencyComponentType value) {
-    return ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType_Name(value);
-  }
-  static const Step STEP_UNSPECIFIED = Step::STEP_UNSPECIFIED;
-  static const Step STEP_SEND_INPUT_EVENT_UI = Step::STEP_SEND_INPUT_EVENT_UI;
-  static const Step STEP_HANDLE_INPUT_EVENT_IMPL = Step::STEP_HANDLE_INPUT_EVENT_IMPL;
-  static const Step STEP_DID_HANDLE_INPUT_AND_OVERSCROLL = Step::STEP_DID_HANDLE_INPUT_AND_OVERSCROLL;
-  static const Step STEP_HANDLE_INPUT_EVENT_MAIN = Step::STEP_HANDLE_INPUT_EVENT_MAIN;
-  static const Step STEP_MAIN_THREAD_SCROLL_UPDATE = Step::STEP_MAIN_THREAD_SCROLL_UPDATE;
-  static const Step STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT = Step::STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT;
-  static const Step STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL = Step::STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL;
-  static const Step STEP_HANDLED_INPUT_EVENT_IMPL = Step::STEP_HANDLED_INPUT_EVENT_IMPL;
-  static const Step STEP_SWAP_BUFFERS = Step::STEP_SWAP_BUFFERS;
-  static const Step STEP_DRAW_AND_SWAP = Step::STEP_DRAW_AND_SWAP;
-  static const Step STEP_FINISHED_SWAP_BUFFERS = Step::STEP_FINISHED_SWAP_BUFFERS;
-  static const LatencyComponentType COMPONENT_UNSPECIFIED = LatencyComponentType::COMPONENT_UNSPECIFIED;
-  static const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH;
-  static const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL;
-  static const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL;
-  static const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL;
-  static const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_UI = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_UI;
-  static const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN;
-  static const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN;
-  static const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL;
-  static const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT;
-  static const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH;
-  static const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP;
-  static const LatencyComponentType COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME = LatencyComponentType::COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME;
-  static const LatencyComponentType COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER = LatencyComponentType::COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER;
-  static const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP;
 
-  using FieldMetadata_TraceId =
+  using FieldMetadata_CounterId =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ChromeLatencyInfo>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      GpuCounterEvent_GpuCounter>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceId kTraceId() { return {}; }
-  void set_trace_id(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TraceId::kFieldId;
+  static constexpr FieldMetadata_CounterId kCounterId{};
+  void set_counter_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CounterId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Step =
+  using FieldMetadata_IntValue =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ChromeLatencyInfo_Step,
-      ChromeLatencyInfo>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      GpuCounterEvent_GpuCounter>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Step kStep() { return {}; }
-  void set_step(::perfetto::protos::pbzero::ChromeLatencyInfo_Step value) {
-    static constexpr uint32_t field_id = FieldMetadata_Step::kFieldId;
+  static constexpr FieldMetadata_IntValue kIntValue{};
+  void set_int_value(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FrameTreeNodeId =
+  using FieldMetadata_DoubleValue =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ChromeLatencyInfo>;
+      ::protozero::proto_utils::ProtoSchemaType::kDouble,
+      double,
+      GpuCounterEvent_GpuCounter>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FrameTreeNodeId kFrameTreeNodeId() { return {}; }
-  void set_frame_tree_node_id(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FrameTreeNodeId::kFieldId;
+  static constexpr FieldMetadata_DoubleValue kDoubleValue{};
+  void set_double_value(double value) {
+    static constexpr uint32_t field_id = FieldMetadata_DoubleValue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kDouble>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_ComponentInfo =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeLatencyInfo_ComponentInfo,
-      ChromeLatencyInfo>;
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/gpu/gpu_log.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ComponentInfo kComponentInfo() { return {}; }
-  template <typename T = ChromeLatencyInfo_ComponentInfo> T* add_component_info() {
-    return BeginNestedMessage<T>(4);
-  }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GPU_GPU_LOG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GPU_GPU_LOG_PROTO_H_
 
+#include <stddef.h>
+#include <stdint.h>
 
-  using FieldMetadata_IsCoalesced =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeLatencyInfo>;
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IsCoalesced kIsCoalesced() { return {}; }
-  void set_is_coalesced(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_IsCoalesced::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+namespace perfetto_pbzero_enum_GpuLog {
+enum Severity : int32_t;
+}  // namespace perfetto_pbzero_enum_GpuLog
+using GpuLog_Severity = perfetto_pbzero_enum_GpuLog::Severity;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_GpuLog {
+enum Severity : int32_t {
+  LOG_SEVERITY_UNSPECIFIED = 0,
+  LOG_SEVERITY_VERBOSE = 1,
+  LOG_SEVERITY_DEBUG = 2,
+  LOG_SEVERITY_INFO = 3,
+  LOG_SEVERITY_WARNING = 4,
+  LOG_SEVERITY_ERROR = 5,
+};
+} // namespace perfetto_pbzero_enum_GpuLog
+using GpuLog_Severity = perfetto_pbzero_enum_GpuLog::Severity;
+
+
+constexpr GpuLog_Severity GpuLog_Severity_MIN = GpuLog_Severity::LOG_SEVERITY_UNSPECIFIED;
+constexpr GpuLog_Severity GpuLog_Severity_MAX = GpuLog_Severity::LOG_SEVERITY_ERROR;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* GpuLog_Severity_Name(::perfetto::protos::pbzero::GpuLog_Severity value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::GpuLog_Severity::LOG_SEVERITY_UNSPECIFIED:
+    return "LOG_SEVERITY_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::GpuLog_Severity::LOG_SEVERITY_VERBOSE:
+    return "LOG_SEVERITY_VERBOSE";
 
-  using FieldMetadata_GestureScrollId =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ChromeLatencyInfo>;
+  case ::perfetto::protos::pbzero::GpuLog_Severity::LOG_SEVERITY_DEBUG:
+    return "LOG_SEVERITY_DEBUG";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GestureScrollId kGestureScrollId() { return {}; }
-  void set_gesture_scroll_id(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GestureScrollId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::GpuLog_Severity::LOG_SEVERITY_INFO:
+    return "LOG_SEVERITY_INFO";
 
-  using FieldMetadata_TouchId =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ChromeLatencyInfo>;
+  case ::perfetto::protos::pbzero::GpuLog_Severity::LOG_SEVERITY_WARNING:
+    return "LOG_SEVERITY_WARNING";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TouchId kTouchId() { return {}; }
-  void set_touch_id(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TouchId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
+  case ::perfetto::protos::pbzero::GpuLog_Severity::LOG_SEVERITY_ERROR:
+    return "LOG_SEVERITY_ERROR";
   }
-};
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
-class ChromeLatencyInfo_ComponentInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class GpuLog_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  ChromeLatencyInfo_ComponentInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeLatencyInfo_ComponentInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeLatencyInfo_ComponentInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_component_type() const { return at<1>().valid(); }
-  int32_t component_type() const { return at<1>().as_int32(); }
-  bool has_time_us() const { return at<2>().valid(); }
-  uint64_t time_us() const { return at<2>().as_uint64(); }
+  GpuLog_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GpuLog_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GpuLog_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_severity() const { return at<1>().valid(); }
+  int32_t severity() const { return at<1>().as_int32(); }
+  bool has_tag() const { return at<2>().valid(); }
+  ::protozero::ConstChars tag() const { return at<2>().as_string(); }
+  bool has_log_message() const { return at<3>().valid(); }
+  ::protozero::ConstChars log_message() const { return at<3>().as_string(); }
 };
 
-class ChromeLatencyInfo_ComponentInfo : public ::protozero::Message {
+class GpuLog : public ::protozero::Message {
  public:
-  using Decoder = ChromeLatencyInfo_ComponentInfo_Decoder;
+  using Decoder = GpuLog_Decoder;
   enum : int32_t {
-    kComponentTypeFieldNumber = 1,
-    kTimeUsFieldNumber = 2,
+    kSeverityFieldNumber = 1,
+    kTagFieldNumber = 2,
+    kLogMessageFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeLatencyInfo.ComponentInfo"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.GpuLog"; }
 
 
-  using FieldMetadata_ComponentType =
+  using Severity = ::perfetto::protos::pbzero::GpuLog_Severity;
+  static inline const char* Severity_Name(Severity value) {
+    return ::perfetto::protos::pbzero::GpuLog_Severity_Name(value);
+  }
+  static inline const Severity LOG_SEVERITY_UNSPECIFIED = Severity::LOG_SEVERITY_UNSPECIFIED;
+  static inline const Severity LOG_SEVERITY_VERBOSE = Severity::LOG_SEVERITY_VERBOSE;
+  static inline const Severity LOG_SEVERITY_DEBUG = Severity::LOG_SEVERITY_DEBUG;
+  static inline const Severity LOG_SEVERITY_INFO = Severity::LOG_SEVERITY_INFO;
+  static inline const Severity LOG_SEVERITY_WARNING = Severity::LOG_SEVERITY_WARNING;
+  static inline const Severity LOG_SEVERITY_ERROR = Severity::LOG_SEVERITY_ERROR;
+
+  using FieldMetadata_Severity =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType,
-      ChromeLatencyInfo_ComponentInfo>;
+      GpuLog_Severity,
+      GpuLog>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ComponentType kComponentType() { return {}; }
-  void set_component_type(::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType value) {
-    static constexpr uint32_t field_id = FieldMetadata_ComponentType::kFieldId;
+  static constexpr FieldMetadata_Severity kSeverity{};
+  void set_severity(GpuLog_Severity value) {
+    static constexpr uint32_t field_id = FieldMetadata_Severity::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -145527,28 +167412,51 @@ class ChromeLatencyInfo_ComponentInfo : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimeUs =
+  using FieldMetadata_Tag =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ChromeLatencyInfo_ComponentInfo>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      GpuLog>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimeUs kTimeUs() { return {}; }
-  void set_time_us(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimeUs::kFieldId;
+  static constexpr FieldMetadata_Tag kTag{};
+  void set_tag(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Tag::kFieldId, data, size);
+  }
+  void set_tag(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Tag::kFieldId, chars.data, chars.size);
+  }
+  void set_tag(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tag::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_LogMessage =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      GpuLog>;
+
+  static constexpr FieldMetadata_LogMessage kLogMessage{};
+  void set_log_message(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_LogMessage::kFieldId, data, size);
+  }
+  void set_log_message(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_LogMessage::kFieldId, chars.data, chars.size);
+  }
+  void set_log_message(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_LogMessage::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 };
@@ -145557,11 +167465,11 @@ class ChromeLatencyInfo_ComponentInfo : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_legacy_ipc.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/gpu/gpu_render_stage_event.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LEGACY_IPC_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LEGACY_IPC_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GPU_GPU_RENDER_STAGE_EVENT_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GPU_GPU_RENDER_STAGE_EVENT_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -145575,557 +167483,426 @@ class ChromeLatencyInfo_ComponentInfo : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
+class GpuRenderStageEvent_ExtraData;
+class GpuRenderStageEvent_Specifications;
+class GpuRenderStageEvent_Specifications_ContextSpec;
+class GpuRenderStageEvent_Specifications_Description;
+namespace perfetto_pbzero_enum_InternedGpuRenderStageSpecification {
+enum RenderStageCategory : int32_t;
+}  // namespace perfetto_pbzero_enum_InternedGpuRenderStageSpecification
+using InternedGpuRenderStageSpecification_RenderStageCategory = perfetto_pbzero_enum_InternedGpuRenderStageSpecification::RenderStageCategory;
+namespace perfetto_pbzero_enum_InternedGraphicsContext {
+enum Api : int32_t;
+}  // namespace perfetto_pbzero_enum_InternedGraphicsContext
+using InternedGraphicsContext_Api = perfetto_pbzero_enum_InternedGraphicsContext::Api;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-namespace perfetto_pbzero_enum_ChromeLegacyIpc {
-enum MessageClass : int32_t;
-}  // namespace perfetto_pbzero_enum_ChromeLegacyIpc
-using ChromeLegacyIpc_MessageClass = perfetto_pbzero_enum_ChromeLegacyIpc::MessageClass;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-namespace perfetto_pbzero_enum_ChromeLegacyIpc {
-enum MessageClass : int32_t {
-  CLASS_UNSPECIFIED = 0,
-  CLASS_AUTOMATION = 1,
-  CLASS_FRAME = 2,
-  CLASS_PAGE = 3,
-  CLASS_VIEW = 4,
-  CLASS_WIDGET = 5,
-  CLASS_INPUT = 6,
-  CLASS_TEST = 7,
-  CLASS_WORKER = 8,
-  CLASS_NACL = 9,
-  CLASS_GPU_CHANNEL = 10,
-  CLASS_MEDIA = 11,
-  CLASS_PPAPI = 12,
-  CLASS_CHROME = 13,
-  CLASS_DRAG = 14,
-  CLASS_PRINT = 15,
-  CLASS_EXTENSION = 16,
-  CLASS_TEXT_INPUT_CLIENT = 17,
-  CLASS_BLINK_TEST = 18,
-  CLASS_ACCESSIBILITY = 19,
-  CLASS_PRERENDER = 20,
-  CLASS_CHROMOTING = 21,
-  CLASS_BROWSER_PLUGIN = 22,
-  CLASS_ANDROID_WEB_VIEW = 23,
-  CLASS_NACL_HOST = 24,
-  CLASS_ENCRYPTED_MEDIA = 25,
-  CLASS_CAST = 26,
-  CLASS_GIN_JAVA_BRIDGE = 27,
-  CLASS_CHROME_UTILITY_PRINTING = 28,
-  CLASS_OZONE_GPU = 29,
-  CLASS_WEB_TEST = 30,
-  CLASS_NETWORK_HINTS = 31,
-  CLASS_EXTENSIONS_GUEST_VIEW = 32,
-  CLASS_GUEST_VIEW = 33,
-  CLASS_MEDIA_PLAYER_DELEGATE = 34,
-  CLASS_EXTENSION_WORKER = 35,
-  CLASS_SUBRESOURCE_FILTER = 36,
-  CLASS_UNFREEZABLE_FRAME = 37,
+namespace perfetto_pbzero_enum_InternedGpuRenderStageSpecification {
+enum RenderStageCategory : int32_t {
+  OTHER = 0,
+  GRAPHICS = 1,
+  COMPUTE = 2,
 };
-} // namespace perfetto_pbzero_enum_ChromeLegacyIpc
-using ChromeLegacyIpc_MessageClass = perfetto_pbzero_enum_ChromeLegacyIpc::MessageClass;
+} // namespace perfetto_pbzero_enum_InternedGpuRenderStageSpecification
+using InternedGpuRenderStageSpecification_RenderStageCategory = perfetto_pbzero_enum_InternedGpuRenderStageSpecification::RenderStageCategory;
 
 
-constexpr ChromeLegacyIpc_MessageClass ChromeLegacyIpc_MessageClass_MIN = ChromeLegacyIpc_MessageClass::CLASS_UNSPECIFIED;
-constexpr ChromeLegacyIpc_MessageClass ChromeLegacyIpc_MessageClass_MAX = ChromeLegacyIpc_MessageClass::CLASS_UNFREEZABLE_FRAME;
+constexpr InternedGpuRenderStageSpecification_RenderStageCategory InternedGpuRenderStageSpecification_RenderStageCategory_MIN = InternedGpuRenderStageSpecification_RenderStageCategory::OTHER;
+constexpr InternedGpuRenderStageSpecification_RenderStageCategory InternedGpuRenderStageSpecification_RenderStageCategory_MAX = InternedGpuRenderStageSpecification_RenderStageCategory::COMPUTE;
 
 
 PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ChromeLegacyIpc_MessageClass_Name(::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass value) {
+const char* InternedGpuRenderStageSpecification_RenderStageCategory_Name(::perfetto::protos::pbzero::InternedGpuRenderStageSpecification_RenderStageCategory value) {
   switch (value) {
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_UNSPECIFIED:
-    return "CLASS_UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_AUTOMATION:
-    return "CLASS_AUTOMATION";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_FRAME:
-    return "CLASS_FRAME";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_PAGE:
-    return "CLASS_PAGE";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_VIEW:
-    return "CLASS_VIEW";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_WIDGET:
-    return "CLASS_WIDGET";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_INPUT:
-    return "CLASS_INPUT";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_TEST:
-    return "CLASS_TEST";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_WORKER:
-    return "CLASS_WORKER";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_NACL:
-    return "CLASS_NACL";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_GPU_CHANNEL:
-    return "CLASS_GPU_CHANNEL";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_MEDIA:
-    return "CLASS_MEDIA";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_PPAPI:
-    return "CLASS_PPAPI";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_CHROME:
-    return "CLASS_CHROME";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_DRAG:
-    return "CLASS_DRAG";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_PRINT:
-    return "CLASS_PRINT";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_EXTENSION:
-    return "CLASS_EXTENSION";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_TEXT_INPUT_CLIENT:
-    return "CLASS_TEXT_INPUT_CLIENT";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_BLINK_TEST:
-    return "CLASS_BLINK_TEST";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_ACCESSIBILITY:
-    return "CLASS_ACCESSIBILITY";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_PRERENDER:
-    return "CLASS_PRERENDER";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_CHROMOTING:
-    return "CLASS_CHROMOTING";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_BROWSER_PLUGIN:
-    return "CLASS_BROWSER_PLUGIN";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_ANDROID_WEB_VIEW:
-    return "CLASS_ANDROID_WEB_VIEW";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_NACL_HOST:
-    return "CLASS_NACL_HOST";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_ENCRYPTED_MEDIA:
-    return "CLASS_ENCRYPTED_MEDIA";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_CAST:
-    return "CLASS_CAST";
-
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_GIN_JAVA_BRIDGE:
-    return "CLASS_GIN_JAVA_BRIDGE";
+  case ::perfetto::protos::pbzero::InternedGpuRenderStageSpecification_RenderStageCategory::OTHER:
+    return "OTHER";
 
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_CHROME_UTILITY_PRINTING:
-    return "CLASS_CHROME_UTILITY_PRINTING";
+  case ::perfetto::protos::pbzero::InternedGpuRenderStageSpecification_RenderStageCategory::GRAPHICS:
+    return "GRAPHICS";
 
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_OZONE_GPU:
-    return "CLASS_OZONE_GPU";
+  case ::perfetto::protos::pbzero::InternedGpuRenderStageSpecification_RenderStageCategory::COMPUTE:
+    return "COMPUTE";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_WEB_TEST:
-    return "CLASS_WEB_TEST";
+namespace perfetto_pbzero_enum_InternedGraphicsContext {
+enum Api : int32_t {
+  UNDEFINED = 0,
+  OPEN_GL = 1,
+  VULKAN = 2,
+  OPEN_CL = 3,
+};
+} // namespace perfetto_pbzero_enum_InternedGraphicsContext
+using InternedGraphicsContext_Api = perfetto_pbzero_enum_InternedGraphicsContext::Api;
 
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_NETWORK_HINTS:
-    return "CLASS_NETWORK_HINTS";
 
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_EXTENSIONS_GUEST_VIEW:
-    return "CLASS_EXTENSIONS_GUEST_VIEW";
+constexpr InternedGraphicsContext_Api InternedGraphicsContext_Api_MIN = InternedGraphicsContext_Api::UNDEFINED;
+constexpr InternedGraphicsContext_Api InternedGraphicsContext_Api_MAX = InternedGraphicsContext_Api::OPEN_CL;
 
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_GUEST_VIEW:
-    return "CLASS_GUEST_VIEW";
 
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_MEDIA_PLAYER_DELEGATE:
-    return "CLASS_MEDIA_PLAYER_DELEGATE";
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* InternedGraphicsContext_Api_Name(::perfetto::protos::pbzero::InternedGraphicsContext_Api value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::InternedGraphicsContext_Api::UNDEFINED:
+    return "UNDEFINED";
 
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_EXTENSION_WORKER:
-    return "CLASS_EXTENSION_WORKER";
+  case ::perfetto::protos::pbzero::InternedGraphicsContext_Api::OPEN_GL:
+    return "OPEN_GL";
 
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_SUBRESOURCE_FILTER:
-    return "CLASS_SUBRESOURCE_FILTER";
+  case ::perfetto::protos::pbzero::InternedGraphicsContext_Api::VULKAN:
+    return "VULKAN";
 
-  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_UNFREEZABLE_FRAME:
-    return "CLASS_UNFREEZABLE_FRAME";
+  case ::perfetto::protos::pbzero::InternedGraphicsContext_Api::OPEN_CL:
+    return "OPEN_CL";
   }
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-class ChromeLegacyIpc_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class InternedGpuRenderStageSpecification_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  ChromeLegacyIpc_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeLegacyIpc_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeLegacyIpc_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_message_class() const { return at<1>().valid(); }
-  int32_t message_class() const { return at<1>().as_int32(); }
-  bool has_message_line() const { return at<2>().valid(); }
-  uint32_t message_line() const { return at<2>().as_uint32(); }
+  InternedGpuRenderStageSpecification_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit InternedGpuRenderStageSpecification_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit InternedGpuRenderStageSpecification_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_iid() const { return at<1>().valid(); }
+  uint64_t iid() const { return at<1>().as_uint64(); }
+  bool has_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars name() const { return at<2>().as_string(); }
+  bool has_description() const { return at<3>().valid(); }
+  ::protozero::ConstChars description() const { return at<3>().as_string(); }
+  bool has_category() const { return at<4>().valid(); }
+  int32_t category() const { return at<4>().as_int32(); }
 };
 
-class ChromeLegacyIpc : public ::protozero::Message {
+class InternedGpuRenderStageSpecification : public ::protozero::Message {
  public:
-  using Decoder = ChromeLegacyIpc_Decoder;
+  using Decoder = InternedGpuRenderStageSpecification_Decoder;
   enum : int32_t {
-    kMessageClassFieldNumber = 1,
-    kMessageLineFieldNumber = 2,
+    kIidFieldNumber = 1,
+    kNameFieldNumber = 2,
+    kDescriptionFieldNumber = 3,
+    kCategoryFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeLegacyIpc"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.InternedGpuRenderStageSpecification"; }
 
 
-  using MessageClass = ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass;
-  static inline const char* MessageClass_Name(MessageClass value) {
-    return ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass_Name(value);
+  using RenderStageCategory = ::perfetto::protos::pbzero::InternedGpuRenderStageSpecification_RenderStageCategory;
+  static inline const char* RenderStageCategory_Name(RenderStageCategory value) {
+    return ::perfetto::protos::pbzero::InternedGpuRenderStageSpecification_RenderStageCategory_Name(value);
   }
-  static const MessageClass CLASS_UNSPECIFIED = MessageClass::CLASS_UNSPECIFIED;
-  static const MessageClass CLASS_AUTOMATION = MessageClass::CLASS_AUTOMATION;
-  static const MessageClass CLASS_FRAME = MessageClass::CLASS_FRAME;
-  static const MessageClass CLASS_PAGE = MessageClass::CLASS_PAGE;
-  static const MessageClass CLASS_VIEW = MessageClass::CLASS_VIEW;
-  static const MessageClass CLASS_WIDGET = MessageClass::CLASS_WIDGET;
-  static const MessageClass CLASS_INPUT = MessageClass::CLASS_INPUT;
-  static const MessageClass CLASS_TEST = MessageClass::CLASS_TEST;
-  static const MessageClass CLASS_WORKER = MessageClass::CLASS_WORKER;
-  static const MessageClass CLASS_NACL = MessageClass::CLASS_NACL;
-  static const MessageClass CLASS_GPU_CHANNEL = MessageClass::CLASS_GPU_CHANNEL;
-  static const MessageClass CLASS_MEDIA = MessageClass::CLASS_MEDIA;
-  static const MessageClass CLASS_PPAPI = MessageClass::CLASS_PPAPI;
-  static const MessageClass CLASS_CHROME = MessageClass::CLASS_CHROME;
-  static const MessageClass CLASS_DRAG = MessageClass::CLASS_DRAG;
-  static const MessageClass CLASS_PRINT = MessageClass::CLASS_PRINT;
-  static const MessageClass CLASS_EXTENSION = MessageClass::CLASS_EXTENSION;
-  static const MessageClass CLASS_TEXT_INPUT_CLIENT = MessageClass::CLASS_TEXT_INPUT_CLIENT;
-  static const MessageClass CLASS_BLINK_TEST = MessageClass::CLASS_BLINK_TEST;
-  static const MessageClass CLASS_ACCESSIBILITY = MessageClass::CLASS_ACCESSIBILITY;
-  static const MessageClass CLASS_PRERENDER = MessageClass::CLASS_PRERENDER;
-  static const MessageClass CLASS_CHROMOTING = MessageClass::CLASS_CHROMOTING;
-  static const MessageClass CLASS_BROWSER_PLUGIN = MessageClass::CLASS_BROWSER_PLUGIN;
-  static const MessageClass CLASS_ANDROID_WEB_VIEW = MessageClass::CLASS_ANDROID_WEB_VIEW;
-  static const MessageClass CLASS_NACL_HOST = MessageClass::CLASS_NACL_HOST;
-  static const MessageClass CLASS_ENCRYPTED_MEDIA = MessageClass::CLASS_ENCRYPTED_MEDIA;
-  static const MessageClass CLASS_CAST = MessageClass::CLASS_CAST;
-  static const MessageClass CLASS_GIN_JAVA_BRIDGE = MessageClass::CLASS_GIN_JAVA_BRIDGE;
-  static const MessageClass CLASS_CHROME_UTILITY_PRINTING = MessageClass::CLASS_CHROME_UTILITY_PRINTING;
-  static const MessageClass CLASS_OZONE_GPU = MessageClass::CLASS_OZONE_GPU;
-  static const MessageClass CLASS_WEB_TEST = MessageClass::CLASS_WEB_TEST;
-  static const MessageClass CLASS_NETWORK_HINTS = MessageClass::CLASS_NETWORK_HINTS;
-  static const MessageClass CLASS_EXTENSIONS_GUEST_VIEW = MessageClass::CLASS_EXTENSIONS_GUEST_VIEW;
-  static const MessageClass CLASS_GUEST_VIEW = MessageClass::CLASS_GUEST_VIEW;
-  static const MessageClass CLASS_MEDIA_PLAYER_DELEGATE = MessageClass::CLASS_MEDIA_PLAYER_DELEGATE;
-  static const MessageClass CLASS_EXTENSION_WORKER = MessageClass::CLASS_EXTENSION_WORKER;
-  static const MessageClass CLASS_SUBRESOURCE_FILTER = MessageClass::CLASS_SUBRESOURCE_FILTER;
-  static const MessageClass CLASS_UNFREEZABLE_FRAME = MessageClass::CLASS_UNFREEZABLE_FRAME;
+  static inline const RenderStageCategory OTHER = RenderStageCategory::OTHER;
+  static inline const RenderStageCategory GRAPHICS = RenderStageCategory::GRAPHICS;
+  static inline const RenderStageCategory COMPUTE = RenderStageCategory::COMPUTE;
 
-  using FieldMetadata_MessageClass =
+  using FieldMetadata_Iid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass,
-      ChromeLegacyIpc>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      InternedGpuRenderStageSpecification>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MessageClass kMessageClass() { return {}; }
-  void set_message_class(::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass value) {
-    static constexpr uint32_t field_id = FieldMetadata_MessageClass::kFieldId;
+  static constexpr FieldMetadata_Iid kIid{};
+  void set_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MessageLine =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      ChromeLegacyIpc>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      InternedGpuRenderStageSpecification>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MessageLine kMessageLine() { return {}; }
-  void set_message_line(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MessageLine::kFieldId;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_message_pump.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MESSAGE_PUMP_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MESSAGE_PUMP_PROTO_H_
 
-#include <stddef.h>
-#include <stdint.h>
+  using FieldMetadata_Description =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      InternedGpuRenderStageSpecification>;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  static constexpr FieldMetadata_Description kDescription{};
+  void set_description(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Description::kFieldId, data, size);
+  }
+  void set_description(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Description::kFieldId, chars.data, chars.size);
+  }
+  void set_description(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Description::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  using FieldMetadata_Category =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      InternedGpuRenderStageSpecification_RenderStageCategory,
+      InternedGpuRenderStageSpecification>;
 
+  static constexpr FieldMetadata_Category kCategory{};
+  void set_category(InternedGpuRenderStageSpecification_RenderStageCategory value) {
+    static constexpr uint32_t field_id = FieldMetadata_Category::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+};
 
-class ChromeMessagePump_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class InternedGraphicsContext_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  ChromeMessagePump_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeMessagePump_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeMessagePump_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_sent_messages_in_queue() const { return at<1>().valid(); }
-  bool sent_messages_in_queue() const { return at<1>().as_bool(); }
-  bool has_io_handler_location_iid() const { return at<2>().valid(); }
-  uint64_t io_handler_location_iid() const { return at<2>().as_uint64(); }
+  InternedGraphicsContext_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit InternedGraphicsContext_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit InternedGraphicsContext_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_iid() const { return at<1>().valid(); }
+  uint64_t iid() const { return at<1>().as_uint64(); }
+  bool has_pid() const { return at<2>().valid(); }
+  int32_t pid() const { return at<2>().as_int32(); }
+  bool has_api() const { return at<3>().valid(); }
+  int32_t api() const { return at<3>().as_int32(); }
 };
 
-class ChromeMessagePump : public ::protozero::Message {
+class InternedGraphicsContext : public ::protozero::Message {
  public:
-  using Decoder = ChromeMessagePump_Decoder;
+  using Decoder = InternedGraphicsContext_Decoder;
   enum : int32_t {
-    kSentMessagesInQueueFieldNumber = 1,
-    kIoHandlerLocationIidFieldNumber = 2,
+    kIidFieldNumber = 1,
+    kPidFieldNumber = 2,
+    kApiFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeMessagePump"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.InternedGraphicsContext"; }
 
 
-  using FieldMetadata_SentMessagesInQueue =
+  using Api = ::perfetto::protos::pbzero::InternedGraphicsContext_Api;
+  static inline const char* Api_Name(Api value) {
+    return ::perfetto::protos::pbzero::InternedGraphicsContext_Api_Name(value);
+  }
+  static inline const Api UNDEFINED = Api::UNDEFINED;
+  static inline const Api OPEN_GL = Api::OPEN_GL;
+  static inline const Api VULKAN = Api::VULKAN;
+  static inline const Api OPEN_CL = Api::OPEN_CL;
+
+  using FieldMetadata_Iid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeMessagePump>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      InternedGraphicsContext>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SentMessagesInQueue kSentMessagesInQueue() { return {}; }
-  void set_sent_messages_in_queue(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_SentMessagesInQueue::kFieldId;
+  static constexpr FieldMetadata_Iid kIid{};
+  void set_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IoHandlerLocationIid =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ChromeMessagePump>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      InternedGraphicsContext>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IoHandlerLocationIid kIoHandlerLocationIid() { return {}; }
-  void set_io_handler_location_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IoHandlerLocationIid::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_mojo_event_info.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MOJO_EVENT_INFO_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MOJO_EVENT_INFO_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  using FieldMetadata_Api =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      InternedGraphicsContext_Api,
+      InternedGraphicsContext>;
 
+  static constexpr FieldMetadata_Api kApi{};
+  void set_api(InternedGraphicsContext_Api value) {
+    static constexpr uint32_t field_id = FieldMetadata_Api::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+};
 
-class ChromeMojoEventInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class GpuRenderStageEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/100> {
  public:
-  ChromeMojoEventInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeMojoEventInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeMojoEventInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_watcher_notify_interface_tag() const { return at<1>().valid(); }
-  ::protozero::ConstChars watcher_notify_interface_tag() const { return at<1>().as_string(); }
-  bool has_ipc_hash() const { return at<2>().valid(); }
-  uint32_t ipc_hash() const { return at<2>().as_uint32(); }
-  bool has_mojo_interface_tag() const { return at<3>().valid(); }
-  ::protozero::ConstChars mojo_interface_tag() const { return at<3>().as_string(); }
-  bool has_mojo_interface_method_iid() const { return at<4>().valid(); }
-  uint64_t mojo_interface_method_iid() const { return at<4>().as_uint64(); }
-  bool has_is_reply() const { return at<5>().valid(); }
-  bool is_reply() const { return at<5>().as_bool(); }
-  bool has_payload_size() const { return at<6>().valid(); }
-  uint64_t payload_size() const { return at<6>().as_uint64(); }
-  bool has_data_num_bytes() const { return at<7>().valid(); }
-  uint64_t data_num_bytes() const { return at<7>().as_uint64(); }
+  GpuRenderStageEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GpuRenderStageEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GpuRenderStageEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_event_id() const { return at<1>().valid(); }
+  uint64_t event_id() const { return at<1>().as_uint64(); }
+  bool has_duration() const { return at<2>().valid(); }
+  uint64_t duration() const { return at<2>().as_uint64(); }
+  bool has_hw_queue_iid() const { return at<13>().valid(); }
+  uint64_t hw_queue_iid() const { return at<13>().as_uint64(); }
+  bool has_stage_iid() const { return at<14>().valid(); }
+  uint64_t stage_iid() const { return at<14>().as_uint64(); }
+  bool has_gpu_id() const { return at<11>().valid(); }
+  int32_t gpu_id() const { return at<11>().as_int32(); }
+  bool has_context() const { return at<5>().valid(); }
+  uint64_t context() const { return at<5>().as_uint64(); }
+  bool has_render_target_handle() const { return at<8>().valid(); }
+  uint64_t render_target_handle() const { return at<8>().as_uint64(); }
+  bool has_submission_id() const { return at<10>().valid(); }
+  uint32_t submission_id() const { return at<10>().as_uint32(); }
+  bool has_extra_data() const { return at<6>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> extra_data() const { return GetRepeated<::protozero::ConstBytes>(6); }
+  bool has_render_pass_handle() const { return at<9>().valid(); }
+  uint64_t render_pass_handle() const { return at<9>().as_uint64(); }
+  bool has_render_pass_instance_id() const { return at<16>().valid(); }
+  uint64_t render_pass_instance_id() const { return at<16>().as_uint64(); }
+  bool has_render_subpass_index_mask() const { return at<15>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint64_t> render_subpass_index_mask() const { return GetRepeated<uint64_t>(15); }
+  bool has_command_buffer_handle() const { return at<12>().valid(); }
+  uint64_t command_buffer_handle() const { return at<12>().as_uint64(); }
+  bool has_specifications() const { return at<7>().valid(); }
+  ::protozero::ConstBytes specifications() const { return at<7>().as_bytes(); }
+  bool has_hw_queue_id() const { return at<3>().valid(); }
+  int32_t hw_queue_id() const { return at<3>().as_int32(); }
+  bool has_stage_id() const { return at<4>().valid(); }
+  int32_t stage_id() const { return at<4>().as_int32(); }
 };
 
-class ChromeMojoEventInfo : public ::protozero::Message {
+class GpuRenderStageEvent : public ::protozero::Message {
  public:
-  using Decoder = ChromeMojoEventInfo_Decoder;
+  using Decoder = GpuRenderStageEvent_Decoder;
   enum : int32_t {
-    kWatcherNotifyInterfaceTagFieldNumber = 1,
-    kIpcHashFieldNumber = 2,
-    kMojoInterfaceTagFieldNumber = 3,
-    kMojoInterfaceMethodIidFieldNumber = 4,
-    kIsReplyFieldNumber = 5,
-    kPayloadSizeFieldNumber = 6,
-    kDataNumBytesFieldNumber = 7,
+    kEventIdFieldNumber = 1,
+    kDurationFieldNumber = 2,
+    kHwQueueIidFieldNumber = 13,
+    kStageIidFieldNumber = 14,
+    kGpuIdFieldNumber = 11,
+    kContextFieldNumber = 5,
+    kRenderTargetHandleFieldNumber = 8,
+    kSubmissionIdFieldNumber = 10,
+    kExtraDataFieldNumber = 6,
+    kRenderPassHandleFieldNumber = 9,
+    kRenderPassInstanceIdFieldNumber = 16,
+    kRenderSubpassIndexMaskFieldNumber = 15,
+    kCommandBufferHandleFieldNumber = 12,
+    kSpecificationsFieldNumber = 7,
+    kHwQueueIdFieldNumber = 3,
+    kStageIdFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeMojoEventInfo"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.GpuRenderStageEvent"; }
 
+  using ExtraData = ::perfetto::protos::pbzero::GpuRenderStageEvent_ExtraData;
+  using Specifications = ::perfetto::protos::pbzero::GpuRenderStageEvent_Specifications;
 
-  using FieldMetadata_WatcherNotifyInterfaceTag =
+  using FieldMetadata_EventId =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeMojoEventInfo>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      GpuRenderStageEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WatcherNotifyInterfaceTag kWatcherNotifyInterfaceTag() { return {}; }
-  void set_watcher_notify_interface_tag(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_WatcherNotifyInterfaceTag::kFieldId, data, size);
-  }
-  void set_watcher_notify_interface_tag(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_WatcherNotifyInterfaceTag::kFieldId, chars.data, chars.size);
-  }
-  void set_watcher_notify_interface_tag(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_WatcherNotifyInterfaceTag::kFieldId;
+  static constexpr FieldMetadata_EventId kEventId{};
+  void set_event_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EventId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IpcHash =
+  using FieldMetadata_Duration =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      ChromeMojoEventInfo>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      GpuRenderStageEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IpcHash kIpcHash() { return {}; }
-  void set_ipc_hash(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IpcHash::kFieldId;
+  static constexpr FieldMetadata_Duration kDuration{};
+  void set_duration(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Duration::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MojoInterfaceTag =
+  using FieldMetadata_HwQueueIid =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      13,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeMojoEventInfo>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      GpuRenderStageEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MojoInterfaceTag kMojoInterfaceTag() { return {}; }
-  void set_mojo_interface_tag(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_MojoInterfaceTag::kFieldId, data, size);
-  }
-  void set_mojo_interface_tag(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_MojoInterfaceTag::kFieldId, chars.data, chars.size);
-  }
-  void set_mojo_interface_tag(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_MojoInterfaceTag::kFieldId;
+  static constexpr FieldMetadata_HwQueueIid kHwQueueIid{};
+  void set_hw_queue_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_HwQueueIid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MojoInterfaceMethodIid =
+  using FieldMetadata_StageIid =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      14,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      ChromeMojoEventInfo>;
+      GpuRenderStageEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MojoInterfaceMethodIid kMojoInterfaceMethodIid() { return {}; }
-  void set_mojo_interface_method_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MojoInterfaceMethodIid::kFieldId;
+  static constexpr FieldMetadata_StageIid kStageIid{};
+  void set_stage_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StageIid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -146133,49 +167910,35 @@ class ChromeMojoEventInfo : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IsReply =
+  using FieldMetadata_GpuId =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeMojoEventInfo>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      GpuRenderStageEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IsReply kIsReply() { return {}; }
-  void set_is_reply(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_IsReply::kFieldId;
+  static constexpr FieldMetadata_GpuId kGpuId{};
+  void set_gpu_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GpuId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PayloadSize =
+  using FieldMetadata_Context =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      ChromeMojoEventInfo>;
+      GpuRenderStageEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PayloadSize kPayloadSize() { return {}; }
-  void set_payload_size(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PayloadSize::kFieldId;
+  static constexpr FieldMetadata_Context kContext{};
+  void set_context(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -146183,416 +167946,414 @@ class ChromeMojoEventInfo : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DataNumBytes =
+  using FieldMetadata_RenderTargetHandle =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      ChromeMojoEventInfo>;
+      GpuRenderStageEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DataNumBytes kDataNumBytes() { return {}; }
-  void set_data_num_bytes(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DataNumBytes::kFieldId;
+  static constexpr FieldMetadata_RenderTargetHandle kRenderTargetHandle{};
+  void set_render_target_handle(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RenderTargetHandle::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_process_descriptor.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_PROCESS_DESCRIPTOR_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_PROCESS_DESCRIPTOR_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-namespace perfetto_pbzero_enum_ChromeProcessDescriptor {
-enum ProcessType : int32_t;
-}  // namespace perfetto_pbzero_enum_ChromeProcessDescriptor
-using ChromeProcessDescriptor_ProcessType = perfetto_pbzero_enum_ChromeProcessDescriptor::ProcessType;
-
-namespace perfetto_pbzero_enum_ChromeProcessDescriptor {
-enum ProcessType : int32_t {
-  PROCESS_UNSPECIFIED = 0,
-  PROCESS_BROWSER = 1,
-  PROCESS_RENDERER = 2,
-  PROCESS_UTILITY = 3,
-  PROCESS_ZYGOTE = 4,
-  PROCESS_SANDBOX_HELPER = 5,
-  PROCESS_GPU = 6,
-  PROCESS_PPAPI_PLUGIN = 7,
-  PROCESS_PPAPI_BROKER = 8,
-  PROCESS_SERVICE_NETWORK = 9,
-  PROCESS_SERVICE_TRACING = 10,
-  PROCESS_SERVICE_STORAGE = 11,
-  PROCESS_SERVICE_AUDIO = 12,
-  PROCESS_SERVICE_DATA_DECODER = 13,
-  PROCESS_SERVICE_UTIL_WIN = 14,
-  PROCESS_SERVICE_PROXY_RESOLVER = 15,
-  PROCESS_SERVICE_CDM = 16,
-  PROCESS_SERVICE_VIDEO_CAPTURE = 17,
-  PROCESS_SERVICE_UNZIPPER = 18,
-  PROCESS_SERVICE_MIRRORING = 19,
-  PROCESS_SERVICE_FILEPATCHER = 20,
-  PROCESS_SERVICE_TTS = 21,
-  PROCESS_SERVICE_PRINTING = 22,
-  PROCESS_SERVICE_QUARANTINE = 23,
-  PROCESS_SERVICE_CROS_LOCALSEARCH = 24,
-  PROCESS_SERVICE_CROS_ASSISTANT_AUDIO_DECODER = 25,
-  PROCESS_SERVICE_FILEUTIL = 26,
-  PROCESS_SERVICE_PRINTCOMPOSITOR = 27,
-  PROCESS_SERVICE_PAINTPREVIEW = 28,
-  PROCESS_SERVICE_SPEECHRECOGNITION = 29,
-  PROCESS_SERVICE_XRDEVICE = 30,
-  PROCESS_SERVICE_READICON = 31,
-  PROCESS_SERVICE_LANGUAGEDETECTION = 32,
-  PROCESS_SERVICE_SHARING = 33,
-  PROCESS_SERVICE_MEDIAPARSER = 34,
-  PROCESS_SERVICE_QRCODEGENERATOR = 35,
-  PROCESS_SERVICE_PROFILEIMPORT = 36,
-  PROCESS_SERVICE_IME = 37,
-  PROCESS_SERVICE_RECORDING = 38,
-  PROCESS_SERVICE_SHAPEDETECTION = 39,
-  PROCESS_RENDERER_EXTENSION = 40,
-};
-} // namespace perfetto_pbzero_enum_ChromeProcessDescriptor
-using ChromeProcessDescriptor_ProcessType = perfetto_pbzero_enum_ChromeProcessDescriptor::ProcessType;
-
-
-constexpr ChromeProcessDescriptor_ProcessType ChromeProcessDescriptor_ProcessType_MIN = ChromeProcessDescriptor_ProcessType::PROCESS_UNSPECIFIED;
-constexpr ChromeProcessDescriptor_ProcessType ChromeProcessDescriptor_ProcessType_MAX = ChromeProcessDescriptor_ProcessType::PROCESS_RENDERER_EXTENSION;
-
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ChromeProcessDescriptor_ProcessType_Name(::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_UNSPECIFIED:
-    return "PROCESS_UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_BROWSER:
-    return "PROCESS_BROWSER";
-
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_RENDERER:
-    return "PROCESS_RENDERER";
+  using FieldMetadata_SubmissionId =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      GpuRenderStageEvent>;
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_UTILITY:
-    return "PROCESS_UTILITY";
+  static constexpr FieldMetadata_SubmissionId kSubmissionId{};
+  void set_submission_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SubmissionId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_ZYGOTE:
-    return "PROCESS_ZYGOTE";
+  using FieldMetadata_ExtraData =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      GpuRenderStageEvent_ExtraData,
+      GpuRenderStageEvent>;
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SANDBOX_HELPER:
-    return "PROCESS_SANDBOX_HELPER";
+  static constexpr FieldMetadata_ExtraData kExtraData{};
+  template <typename T = GpuRenderStageEvent_ExtraData> T* add_extra_data() {
+    return BeginNestedMessage<T>(6);
+  }
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_GPU:
-    return "PROCESS_GPU";
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_PPAPI_PLUGIN:
-    return "PROCESS_PPAPI_PLUGIN";
+  using FieldMetadata_RenderPassHandle =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      GpuRenderStageEvent>;
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_PPAPI_BROKER:
-    return "PROCESS_PPAPI_BROKER";
+  static constexpr FieldMetadata_RenderPassHandle kRenderPassHandle{};
+  void set_render_pass_handle(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RenderPassHandle::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_NETWORK:
-    return "PROCESS_SERVICE_NETWORK";
+  using FieldMetadata_RenderPassInstanceId =
+    ::protozero::proto_utils::FieldMetadata<
+      16,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      GpuRenderStageEvent>;
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_TRACING:
-    return "PROCESS_SERVICE_TRACING";
+  static constexpr FieldMetadata_RenderPassInstanceId kRenderPassInstanceId{};
+  void set_render_pass_instance_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RenderPassInstanceId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_STORAGE:
-    return "PROCESS_SERVICE_STORAGE";
+  using FieldMetadata_RenderSubpassIndexMask =
+    ::protozero::proto_utils::FieldMetadata<
+      15,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      GpuRenderStageEvent>;
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_AUDIO:
-    return "PROCESS_SERVICE_AUDIO";
+  static constexpr FieldMetadata_RenderSubpassIndexMask kRenderSubpassIndexMask{};
+  void add_render_subpass_index_mask(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RenderSubpassIndexMask::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_DATA_DECODER:
-    return "PROCESS_SERVICE_DATA_DECODER";
+  using FieldMetadata_CommandBufferHandle =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      GpuRenderStageEvent>;
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_UTIL_WIN:
-    return "PROCESS_SERVICE_UTIL_WIN";
+  static constexpr FieldMetadata_CommandBufferHandle kCommandBufferHandle{};
+  void set_command_buffer_handle(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CommandBufferHandle::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_PROXY_RESOLVER:
-    return "PROCESS_SERVICE_PROXY_RESOLVER";
+  using FieldMetadata_Specifications =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      GpuRenderStageEvent_Specifications,
+      GpuRenderStageEvent>;
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_CDM:
-    return "PROCESS_SERVICE_CDM";
+  static constexpr FieldMetadata_Specifications kSpecifications{};
+  template <typename T = GpuRenderStageEvent_Specifications> T* set_specifications() {
+    return BeginNestedMessage<T>(7);
+  }
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_VIDEO_CAPTURE:
-    return "PROCESS_SERVICE_VIDEO_CAPTURE";
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_UNZIPPER:
-    return "PROCESS_SERVICE_UNZIPPER";
+  using FieldMetadata_HwQueueId =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      GpuRenderStageEvent>;
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_MIRRORING:
-    return "PROCESS_SERVICE_MIRRORING";
+  static constexpr FieldMetadata_HwQueueId kHwQueueId{};
+  void set_hw_queue_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_HwQueueId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_FILEPATCHER:
-    return "PROCESS_SERVICE_FILEPATCHER";
+  using FieldMetadata_StageId =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      GpuRenderStageEvent>;
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_TTS:
-    return "PROCESS_SERVICE_TTS";
+  static constexpr FieldMetadata_StageId kStageId{};
+  void set_stage_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StageId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_PRINTING:
-    return "PROCESS_SERVICE_PRINTING";
+class GpuRenderStageEvent_Specifications_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  GpuRenderStageEvent_Specifications_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GpuRenderStageEvent_Specifications_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GpuRenderStageEvent_Specifications_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_context_spec() const { return at<1>().valid(); }
+  ::protozero::ConstBytes context_spec() const { return at<1>().as_bytes(); }
+  bool has_hw_queue() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> hw_queue() const { return GetRepeated<::protozero::ConstBytes>(2); }
+  bool has_stage() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> stage() const { return GetRepeated<::protozero::ConstBytes>(3); }
+};
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_QUARANTINE:
-    return "PROCESS_SERVICE_QUARANTINE";
+class GpuRenderStageEvent_Specifications : public ::protozero::Message {
+ public:
+  using Decoder = GpuRenderStageEvent_Specifications_Decoder;
+  enum : int32_t {
+    kContextSpecFieldNumber = 1,
+    kHwQueueFieldNumber = 2,
+    kStageFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.GpuRenderStageEvent.Specifications"; }
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_CROS_LOCALSEARCH:
-    return "PROCESS_SERVICE_CROS_LOCALSEARCH";
+  using ContextSpec = ::perfetto::protos::pbzero::GpuRenderStageEvent_Specifications_ContextSpec;
+  using Description = ::perfetto::protos::pbzero::GpuRenderStageEvent_Specifications_Description;
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_CROS_ASSISTANT_AUDIO_DECODER:
-    return "PROCESS_SERVICE_CROS_ASSISTANT_AUDIO_DECODER";
+  using FieldMetadata_ContextSpec =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      GpuRenderStageEvent_Specifications_ContextSpec,
+      GpuRenderStageEvent_Specifications>;
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_FILEUTIL:
-    return "PROCESS_SERVICE_FILEUTIL";
+  static constexpr FieldMetadata_ContextSpec kContextSpec{};
+  template <typename T = GpuRenderStageEvent_Specifications_ContextSpec> T* set_context_spec() {
+    return BeginNestedMessage<T>(1);
+  }
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_PRINTCOMPOSITOR:
-    return "PROCESS_SERVICE_PRINTCOMPOSITOR";
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_PAINTPREVIEW:
-    return "PROCESS_SERVICE_PAINTPREVIEW";
+  using FieldMetadata_HwQueue =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      GpuRenderStageEvent_Specifications_Description,
+      GpuRenderStageEvent_Specifications>;
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_SPEECHRECOGNITION:
-    return "PROCESS_SERVICE_SPEECHRECOGNITION";
+  static constexpr FieldMetadata_HwQueue kHwQueue{};
+  template <typename T = GpuRenderStageEvent_Specifications_Description> T* add_hw_queue() {
+    return BeginNestedMessage<T>(2);
+  }
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_XRDEVICE:
-    return "PROCESS_SERVICE_XRDEVICE";
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_READICON:
-    return "PROCESS_SERVICE_READICON";
+  using FieldMetadata_Stage =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      GpuRenderStageEvent_Specifications_Description,
+      GpuRenderStageEvent_Specifications>;
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_LANGUAGEDETECTION:
-    return "PROCESS_SERVICE_LANGUAGEDETECTION";
+  static constexpr FieldMetadata_Stage kStage{};
+  template <typename T = GpuRenderStageEvent_Specifications_Description> T* add_stage() {
+    return BeginNestedMessage<T>(3);
+  }
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_SHARING:
-    return "PROCESS_SERVICE_SHARING";
+};
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_MEDIAPARSER:
-    return "PROCESS_SERVICE_MEDIAPARSER";
+class GpuRenderStageEvent_Specifications_Description_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  GpuRenderStageEvent_Specifications_Description_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GpuRenderStageEvent_Specifications_Description_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GpuRenderStageEvent_Specifications_Description_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_description() const { return at<2>().valid(); }
+  ::protozero::ConstChars description() const { return at<2>().as_string(); }
+};
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_QRCODEGENERATOR:
-    return "PROCESS_SERVICE_QRCODEGENERATOR";
+class GpuRenderStageEvent_Specifications_Description : public ::protozero::Message {
+ public:
+  using Decoder = GpuRenderStageEvent_Specifications_Description_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kDescriptionFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.GpuRenderStageEvent.Specifications.Description"; }
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_PROFILEIMPORT:
-    return "PROCESS_SERVICE_PROFILEIMPORT";
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_IME:
-    return "PROCESS_SERVICE_IME";
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      GpuRenderStageEvent_Specifications_Description>;
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_RECORDING:
-    return "PROCESS_SERVICE_RECORDING";
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_SHAPEDETECTION:
-    return "PROCESS_SERVICE_SHAPEDETECTION";
+  using FieldMetadata_Description =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      GpuRenderStageEvent_Specifications_Description>;
 
-  case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_RENDERER_EXTENSION:
-    return "PROCESS_RENDERER_EXTENSION";
+  static constexpr FieldMetadata_Description kDescription{};
+  void set_description(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Description::kFieldId, data, size);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+  void set_description(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Description::kFieldId, chars.data, chars.size);
+  }
+  void set_description(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Description::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
 
-class ChromeProcessDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class GpuRenderStageEvent_Specifications_ContextSpec_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  ChromeProcessDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeProcessDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeProcessDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_process_type() const { return at<1>().valid(); }
-  int32_t process_type() const { return at<1>().as_int32(); }
-  bool has_process_priority() const { return at<2>().valid(); }
-  int32_t process_priority() const { return at<2>().as_int32(); }
-  bool has_legacy_sort_index() const { return at<3>().valid(); }
-  int32_t legacy_sort_index() const { return at<3>().as_int32(); }
-  bool has_host_app_package_name() const { return at<4>().valid(); }
-  ::protozero::ConstChars host_app_package_name() const { return at<4>().as_string(); }
-  bool has_crash_trace_id() const { return at<5>().valid(); }
-  uint64_t crash_trace_id() const { return at<5>().as_uint64(); }
+  GpuRenderStageEvent_Specifications_ContextSpec_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GpuRenderStageEvent_Specifications_ContextSpec_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GpuRenderStageEvent_Specifications_ContextSpec_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_context() const { return at<1>().valid(); }
+  uint64_t context() const { return at<1>().as_uint64(); }
+  bool has_pid() const { return at<2>().valid(); }
+  int32_t pid() const { return at<2>().as_int32(); }
 };
 
-class ChromeProcessDescriptor : public ::protozero::Message {
+class GpuRenderStageEvent_Specifications_ContextSpec : public ::protozero::Message {
  public:
-  using Decoder = ChromeProcessDescriptor_Decoder;
+  using Decoder = GpuRenderStageEvent_Specifications_ContextSpec_Decoder;
   enum : int32_t {
-    kProcessTypeFieldNumber = 1,
-    kProcessPriorityFieldNumber = 2,
-    kLegacySortIndexFieldNumber = 3,
-    kHostAppPackageNameFieldNumber = 4,
-    kCrashTraceIdFieldNumber = 5,
+    kContextFieldNumber = 1,
+    kPidFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeProcessDescriptor"; }
-
+  static constexpr const char* GetName() { return ".perfetto.protos.GpuRenderStageEvent.Specifications.ContextSpec"; }
 
-  using ProcessType = ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType;
-  static inline const char* ProcessType_Name(ProcessType value) {
-    return ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType_Name(value);
-  }
-  static const ProcessType PROCESS_UNSPECIFIED = ProcessType::PROCESS_UNSPECIFIED;
-  static const ProcessType PROCESS_BROWSER = ProcessType::PROCESS_BROWSER;
-  static const ProcessType PROCESS_RENDERER = ProcessType::PROCESS_RENDERER;
-  static const ProcessType PROCESS_UTILITY = ProcessType::PROCESS_UTILITY;
-  static const ProcessType PROCESS_ZYGOTE = ProcessType::PROCESS_ZYGOTE;
-  static const ProcessType PROCESS_SANDBOX_HELPER = ProcessType::PROCESS_SANDBOX_HELPER;
-  static const ProcessType PROCESS_GPU = ProcessType::PROCESS_GPU;
-  static const ProcessType PROCESS_PPAPI_PLUGIN = ProcessType::PROCESS_PPAPI_PLUGIN;
-  static const ProcessType PROCESS_PPAPI_BROKER = ProcessType::PROCESS_PPAPI_BROKER;
-  static const ProcessType PROCESS_SERVICE_NETWORK = ProcessType::PROCESS_SERVICE_NETWORK;
-  static const ProcessType PROCESS_SERVICE_TRACING = ProcessType::PROCESS_SERVICE_TRACING;
-  static const ProcessType PROCESS_SERVICE_STORAGE = ProcessType::PROCESS_SERVICE_STORAGE;
-  static const ProcessType PROCESS_SERVICE_AUDIO = ProcessType::PROCESS_SERVICE_AUDIO;
-  static const ProcessType PROCESS_SERVICE_DATA_DECODER = ProcessType::PROCESS_SERVICE_DATA_DECODER;
-  static const ProcessType PROCESS_SERVICE_UTIL_WIN = ProcessType::PROCESS_SERVICE_UTIL_WIN;
-  static const ProcessType PROCESS_SERVICE_PROXY_RESOLVER = ProcessType::PROCESS_SERVICE_PROXY_RESOLVER;
-  static const ProcessType PROCESS_SERVICE_CDM = ProcessType::PROCESS_SERVICE_CDM;
-  static const ProcessType PROCESS_SERVICE_VIDEO_CAPTURE = ProcessType::PROCESS_SERVICE_VIDEO_CAPTURE;
-  static const ProcessType PROCESS_SERVICE_UNZIPPER = ProcessType::PROCESS_SERVICE_UNZIPPER;
-  static const ProcessType PROCESS_SERVICE_MIRRORING = ProcessType::PROCESS_SERVICE_MIRRORING;
-  static const ProcessType PROCESS_SERVICE_FILEPATCHER = ProcessType::PROCESS_SERVICE_FILEPATCHER;
-  static const ProcessType PROCESS_SERVICE_TTS = ProcessType::PROCESS_SERVICE_TTS;
-  static const ProcessType PROCESS_SERVICE_PRINTING = ProcessType::PROCESS_SERVICE_PRINTING;
-  static const ProcessType PROCESS_SERVICE_QUARANTINE = ProcessType::PROCESS_SERVICE_QUARANTINE;
-  static const ProcessType PROCESS_SERVICE_CROS_LOCALSEARCH = ProcessType::PROCESS_SERVICE_CROS_LOCALSEARCH;
-  static const ProcessType PROCESS_SERVICE_CROS_ASSISTANT_AUDIO_DECODER = ProcessType::PROCESS_SERVICE_CROS_ASSISTANT_AUDIO_DECODER;
-  static const ProcessType PROCESS_SERVICE_FILEUTIL = ProcessType::PROCESS_SERVICE_FILEUTIL;
-  static const ProcessType PROCESS_SERVICE_PRINTCOMPOSITOR = ProcessType::PROCESS_SERVICE_PRINTCOMPOSITOR;
-  static const ProcessType PROCESS_SERVICE_PAINTPREVIEW = ProcessType::PROCESS_SERVICE_PAINTPREVIEW;
-  static const ProcessType PROCESS_SERVICE_SPEECHRECOGNITION = ProcessType::PROCESS_SERVICE_SPEECHRECOGNITION;
-  static const ProcessType PROCESS_SERVICE_XRDEVICE = ProcessType::PROCESS_SERVICE_XRDEVICE;
-  static const ProcessType PROCESS_SERVICE_READICON = ProcessType::PROCESS_SERVICE_READICON;
-  static const ProcessType PROCESS_SERVICE_LANGUAGEDETECTION = ProcessType::PROCESS_SERVICE_LANGUAGEDETECTION;
-  static const ProcessType PROCESS_SERVICE_SHARING = ProcessType::PROCESS_SERVICE_SHARING;
-  static const ProcessType PROCESS_SERVICE_MEDIAPARSER = ProcessType::PROCESS_SERVICE_MEDIAPARSER;
-  static const ProcessType PROCESS_SERVICE_QRCODEGENERATOR = ProcessType::PROCESS_SERVICE_QRCODEGENERATOR;
-  static const ProcessType PROCESS_SERVICE_PROFILEIMPORT = ProcessType::PROCESS_SERVICE_PROFILEIMPORT;
-  static const ProcessType PROCESS_SERVICE_IME = ProcessType::PROCESS_SERVICE_IME;
-  static const ProcessType PROCESS_SERVICE_RECORDING = ProcessType::PROCESS_SERVICE_RECORDING;
-  static const ProcessType PROCESS_SERVICE_SHAPEDETECTION = ProcessType::PROCESS_SERVICE_SHAPEDETECTION;
-  static const ProcessType PROCESS_RENDERER_EXTENSION = ProcessType::PROCESS_RENDERER_EXTENSION;
 
-  using FieldMetadata_ProcessType =
+  using FieldMetadata_Context =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType,
-      ChromeProcessDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      GpuRenderStageEvent_Specifications_ContextSpec>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessType kProcessType() { return {}; }
-  void set_process_type(::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProcessType::kFieldId;
+  static constexpr FieldMetadata_Context kContext{};
+  void set_context(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ProcessPriority =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      ChromeProcessDescriptor>;
+      GpuRenderStageEvent_Specifications_ContextSpec>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessPriority kProcessPriority() { return {}; }
-  void set_process_priority(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProcessPriority::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_LegacySortIndex =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ChromeProcessDescriptor>;
+class GpuRenderStageEvent_ExtraData_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  GpuRenderStageEvent_ExtraData_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit GpuRenderStageEvent_ExtraData_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit GpuRenderStageEvent_ExtraData_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_value() const { return at<2>().valid(); }
+  ::protozero::ConstChars value() const { return at<2>().as_string(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LegacySortIndex kLegacySortIndex() { return {}; }
-  void set_legacy_sort_index(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LegacySortIndex::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
+class GpuRenderStageEvent_ExtraData : public ::protozero::Message {
+ public:
+  using Decoder = GpuRenderStageEvent_ExtraData_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.GpuRenderStageEvent.ExtraData"; }
 
-  using FieldMetadata_HostAppPackageName =
+
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      ChromeProcessDescriptor>;
+      GpuRenderStageEvent_ExtraData>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HostAppPackageName kHostAppPackageName() { return {}; }
-  void set_host_app_package_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_HostAppPackageName::kFieldId, data, size);
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
-  void set_host_app_package_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_HostAppPackageName::kFieldId, chars.data, chars.size);
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
   }
-  void set_host_app_package_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_HostAppPackageName::kFieldId;
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -146600,28 +168361,27 @@ class ChromeProcessDescriptor : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CrashTraceId =
+  using FieldMetadata_Value =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ChromeProcessDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      GpuRenderStageEvent_ExtraData>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CrashTraceId kCrashTraceId() { return {}; }
-  void set_crash_trace_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CrashTraceId::kFieldId;
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
+  }
+  void set_value(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
+  }
+  void set_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 };
@@ -146630,11 +168390,11 @@ class ChromeProcessDescriptor : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_renderer_scheduler_state.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/gpu/vulkan_api_event.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_RENDERER_SCHEDULER_STATE_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_RENDERER_SCHEDULER_STATE_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GPU_VULKAN_API_EVENT_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GPU_VULKAN_API_EVENT_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -146648,706 +168408,333 @@ class ChromeProcessDescriptor : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
+class VulkanApiEvent_VkDebugUtilsObjectName;
+class VulkanApiEvent_VkQueueSubmit;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-enum ChromeRAILMode : int32_t;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-enum ChromeRAILMode : int32_t {
-  RAIL_MODE_NONE = 0,
-  RAIL_MODE_RESPONSE = 1,
-  RAIL_MODE_ANIMATION = 2,
-  RAIL_MODE_IDLE = 3,
-  RAIL_MODE_LOAD = 4,
+class VulkanApiEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  VulkanApiEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit VulkanApiEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit VulkanApiEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_vk_debug_utils_object_name() const { return at<1>().valid(); }
+  ::protozero::ConstBytes vk_debug_utils_object_name() const { return at<1>().as_bytes(); }
+  bool has_vk_queue_submit() const { return at<2>().valid(); }
+  ::protozero::ConstBytes vk_queue_submit() const { return at<2>().as_bytes(); }
 };
 
-constexpr ChromeRAILMode ChromeRAILMode_MIN = ChromeRAILMode::RAIL_MODE_NONE;
-constexpr ChromeRAILMode ChromeRAILMode_MAX = ChromeRAILMode::RAIL_MODE_LOAD;
+class VulkanApiEvent : public ::protozero::Message {
+ public:
+  using Decoder = VulkanApiEvent_Decoder;
+  enum : int32_t {
+    kVkDebugUtilsObjectNameFieldNumber = 1,
+    kVkQueueSubmitFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.VulkanApiEvent"; }
 
+  using VkDebugUtilsObjectName = ::perfetto::protos::pbzero::VulkanApiEvent_VkDebugUtilsObjectName;
+  using VkQueueSubmit = ::perfetto::protos::pbzero::VulkanApiEvent_VkQueueSubmit;
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ChromeRAILMode_Name(::perfetto::protos::pbzero::ChromeRAILMode value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ChromeRAILMode::RAIL_MODE_NONE:
-    return "RAIL_MODE_NONE";
+  using FieldMetadata_VkDebugUtilsObjectName =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      VulkanApiEvent_VkDebugUtilsObjectName,
+      VulkanApiEvent>;
 
-  case ::perfetto::protos::pbzero::ChromeRAILMode::RAIL_MODE_RESPONSE:
-    return "RAIL_MODE_RESPONSE";
+  static constexpr FieldMetadata_VkDebugUtilsObjectName kVkDebugUtilsObjectName{};
+  template <typename T = VulkanApiEvent_VkDebugUtilsObjectName> T* set_vk_debug_utils_object_name() {
+    return BeginNestedMessage<T>(1);
+  }
 
-  case ::perfetto::protos::pbzero::ChromeRAILMode::RAIL_MODE_ANIMATION:
-    return "RAIL_MODE_ANIMATION";
 
-  case ::perfetto::protos::pbzero::ChromeRAILMode::RAIL_MODE_IDLE:
-    return "RAIL_MODE_IDLE";
+  using FieldMetadata_VkQueueSubmit =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      VulkanApiEvent_VkQueueSubmit,
+      VulkanApiEvent>;
 
-  case ::perfetto::protos::pbzero::ChromeRAILMode::RAIL_MODE_LOAD:
-    return "RAIL_MODE_LOAD";
+  static constexpr FieldMetadata_VkQueueSubmit kVkQueueSubmit{};
+  template <typename T = VulkanApiEvent_VkQueueSubmit> T* set_vk_queue_submit() {
+    return BeginNestedMessage<T>(2);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
 
-class ChromeRendererSchedulerState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+};
+
+class VulkanApiEvent_VkQueueSubmit_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  ChromeRendererSchedulerState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeRendererSchedulerState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeRendererSchedulerState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_rail_mode() const { return at<1>().valid(); }
-  int32_t rail_mode() const { return at<1>().as_int32(); }
-  bool has_is_backgrounded() const { return at<2>().valid(); }
-  bool is_backgrounded() const { return at<2>().as_bool(); }
-  bool has_is_hidden() const { return at<3>().valid(); }
-  bool is_hidden() const { return at<3>().as_bool(); }
+  VulkanApiEvent_VkQueueSubmit_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit VulkanApiEvent_VkQueueSubmit_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit VulkanApiEvent_VkQueueSubmit_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_duration_ns() const { return at<1>().valid(); }
+  uint64_t duration_ns() const { return at<1>().as_uint64(); }
+  bool has_pid() const { return at<2>().valid(); }
+  uint32_t pid() const { return at<2>().as_uint32(); }
+  bool has_tid() const { return at<3>().valid(); }
+  uint32_t tid() const { return at<3>().as_uint32(); }
+  bool has_vk_queue() const { return at<4>().valid(); }
+  uint64_t vk_queue() const { return at<4>().as_uint64(); }
+  bool has_vk_command_buffers() const { return at<5>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint64_t> vk_command_buffers() const { return GetRepeated<uint64_t>(5); }
+  bool has_submission_id() const { return at<6>().valid(); }
+  uint32_t submission_id() const { return at<6>().as_uint32(); }
 };
 
-class ChromeRendererSchedulerState : public ::protozero::Message {
+class VulkanApiEvent_VkQueueSubmit : public ::protozero::Message {
  public:
-  using Decoder = ChromeRendererSchedulerState_Decoder;
+  using Decoder = VulkanApiEvent_VkQueueSubmit_Decoder;
   enum : int32_t {
-    kRailModeFieldNumber = 1,
-    kIsBackgroundedFieldNumber = 2,
-    kIsHiddenFieldNumber = 3,
+    kDurationNsFieldNumber = 1,
+    kPidFieldNumber = 2,
+    kTidFieldNumber = 3,
+    kVkQueueFieldNumber = 4,
+    kVkCommandBuffersFieldNumber = 5,
+    kSubmissionIdFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeRendererSchedulerState"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.VulkanApiEvent.VkQueueSubmit"; }
 
 
-  using FieldMetadata_RailMode =
+  using FieldMetadata_DurationNs =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ChromeRAILMode,
-      ChromeRendererSchedulerState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      VulkanApiEvent_VkQueueSubmit>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RailMode kRailMode() { return {}; }
-  void set_rail_mode(::perfetto::protos::pbzero::ChromeRAILMode value) {
-    static constexpr uint32_t field_id = FieldMetadata_RailMode::kFieldId;
+  static constexpr FieldMetadata_DurationNs kDurationNs{};
+  void set_duration_ns(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DurationNs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IsBackgrounded =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeRendererSchedulerState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VulkanApiEvent_VkQueueSubmit>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IsBackgrounded kIsBackgrounded() { return {}; }
-  void set_is_backgrounded(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_IsBackgrounded::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IsHidden =
+  using FieldMetadata_Tid =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      ChromeRendererSchedulerState>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VulkanApiEvent_VkQueueSubmit>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IsHidden kIsHidden() { return {}; }
-  void set_is_hidden(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_IsHidden::kFieldId;
+  static constexpr FieldMetadata_Tid kTid{};
+  void set_tid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_thread_descriptor.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_THREAD_DESCRIPTOR_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_THREAD_DESCRIPTOR_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-namespace perfetto_pbzero_enum_ChromeThreadDescriptor {
-enum ThreadType : int32_t;
-}  // namespace perfetto_pbzero_enum_ChromeThreadDescriptor
-using ChromeThreadDescriptor_ThreadType = perfetto_pbzero_enum_ChromeThreadDescriptor::ThreadType;
-
-namespace perfetto_pbzero_enum_ChromeThreadDescriptor {
-enum ThreadType : int32_t {
-  THREAD_UNSPECIFIED = 0,
-  THREAD_MAIN = 1,
-  THREAD_IO = 2,
-  THREAD_POOL_BG_WORKER = 3,
-  THREAD_POOL_FG_WORKER = 4,
-  THREAD_POOL_FG_BLOCKING = 5,
-  THREAD_POOL_BG_BLOCKING = 6,
-  THREAD_POOL_SERVICE = 7,
-  THREAD_COMPOSITOR = 8,
-  THREAD_VIZ_COMPOSITOR = 9,
-  THREAD_COMPOSITOR_WORKER = 10,
-  THREAD_SERVICE_WORKER = 11,
-  THREAD_NETWORK_SERVICE = 12,
-  THREAD_CHILD_IO = 13,
-  THREAD_BROWSER_IO = 14,
-  THREAD_BROWSER_MAIN = 15,
-  THREAD_RENDERER_MAIN = 16,
-  THREAD_UTILITY_MAIN = 17,
-  THREAD_GPU_MAIN = 18,
-  THREAD_CACHE_BLOCKFILE = 19,
-  THREAD_MEDIA = 20,
-  THREAD_AUDIO_OUTPUTDEVICE = 21,
-  THREAD_AUDIO_INPUTDEVICE = 22,
-  THREAD_GPU_MEMORY = 23,
-  THREAD_GPU_VSYNC = 24,
-  THREAD_DXA_VIDEODECODER = 25,
-  THREAD_BROWSER_WATCHDOG = 26,
-  THREAD_WEBRTC_NETWORK = 27,
-  THREAD_WINDOW_OWNER = 28,
-  THREAD_WEBRTC_SIGNALING = 29,
-  THREAD_WEBRTC_WORKER = 30,
-  THREAD_PPAPI_MAIN = 31,
-  THREAD_GPU_WATCHDOG = 32,
-  THREAD_SWAPPER = 33,
-  THREAD_GAMEPAD_POLLING = 34,
-  THREAD_WEBCRYPTO = 35,
-  THREAD_DATABASE = 36,
-  THREAD_PROXYRESOLVER = 37,
-  THREAD_DEVTOOLSADB = 38,
-  THREAD_NETWORKCONFIGWATCHER = 39,
-  THREAD_WASAPI_RENDER = 40,
-  THREAD_LOADER_LOCK_SAMPLER = 41,
-  THREAD_MEMORY_INFRA = 50,
-  THREAD_SAMPLING_PROFILER = 51,
-};
-} // namespace perfetto_pbzero_enum_ChromeThreadDescriptor
-using ChromeThreadDescriptor_ThreadType = perfetto_pbzero_enum_ChromeThreadDescriptor::ThreadType;
-
-
-constexpr ChromeThreadDescriptor_ThreadType ChromeThreadDescriptor_ThreadType_MIN = ChromeThreadDescriptor_ThreadType::THREAD_UNSPECIFIED;
-constexpr ChromeThreadDescriptor_ThreadType ChromeThreadDescriptor_ThreadType_MAX = ChromeThreadDescriptor_ThreadType::THREAD_SAMPLING_PROFILER;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ChromeThreadDescriptor_ThreadType_Name(::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_UNSPECIFIED:
-    return "THREAD_UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_MAIN:
-    return "THREAD_MAIN";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_IO:
-    return "THREAD_IO";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_POOL_BG_WORKER:
-    return "THREAD_POOL_BG_WORKER";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_POOL_FG_WORKER:
-    return "THREAD_POOL_FG_WORKER";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_POOL_FG_BLOCKING:
-    return "THREAD_POOL_FG_BLOCKING";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_POOL_BG_BLOCKING:
-    return "THREAD_POOL_BG_BLOCKING";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_POOL_SERVICE:
-    return "THREAD_POOL_SERVICE";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_COMPOSITOR:
-    return "THREAD_COMPOSITOR";
 
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_VIZ_COMPOSITOR:
-    return "THREAD_VIZ_COMPOSITOR";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_COMPOSITOR_WORKER:
-    return "THREAD_COMPOSITOR_WORKER";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_SERVICE_WORKER:
-    return "THREAD_SERVICE_WORKER";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_NETWORK_SERVICE:
-    return "THREAD_NETWORK_SERVICE";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_CHILD_IO:
-    return "THREAD_CHILD_IO";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_BROWSER_IO:
-    return "THREAD_BROWSER_IO";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_BROWSER_MAIN:
-    return "THREAD_BROWSER_MAIN";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_RENDERER_MAIN:
-    return "THREAD_RENDERER_MAIN";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_UTILITY_MAIN:
-    return "THREAD_UTILITY_MAIN";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_GPU_MAIN:
-    return "THREAD_GPU_MAIN";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_CACHE_BLOCKFILE:
-    return "THREAD_CACHE_BLOCKFILE";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_MEDIA:
-    return "THREAD_MEDIA";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_AUDIO_OUTPUTDEVICE:
-    return "THREAD_AUDIO_OUTPUTDEVICE";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_AUDIO_INPUTDEVICE:
-    return "THREAD_AUDIO_INPUTDEVICE";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_GPU_MEMORY:
-    return "THREAD_GPU_MEMORY";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_GPU_VSYNC:
-    return "THREAD_GPU_VSYNC";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_DXA_VIDEODECODER:
-    return "THREAD_DXA_VIDEODECODER";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_BROWSER_WATCHDOG:
-    return "THREAD_BROWSER_WATCHDOG";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_WEBRTC_NETWORK:
-    return "THREAD_WEBRTC_NETWORK";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_WINDOW_OWNER:
-    return "THREAD_WINDOW_OWNER";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_WEBRTC_SIGNALING:
-    return "THREAD_WEBRTC_SIGNALING";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_WEBRTC_WORKER:
-    return "THREAD_WEBRTC_WORKER";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_PPAPI_MAIN:
-    return "THREAD_PPAPI_MAIN";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_GPU_WATCHDOG:
-    return "THREAD_GPU_WATCHDOG";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_SWAPPER:
-    return "THREAD_SWAPPER";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_GAMEPAD_POLLING:
-    return "THREAD_GAMEPAD_POLLING";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_WEBCRYPTO:
-    return "THREAD_WEBCRYPTO";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_DATABASE:
-    return "THREAD_DATABASE";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_PROXYRESOLVER:
-    return "THREAD_PROXYRESOLVER";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_DEVTOOLSADB:
-    return "THREAD_DEVTOOLSADB";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_NETWORKCONFIGWATCHER:
-    return "THREAD_NETWORKCONFIGWATCHER";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_WASAPI_RENDER:
-    return "THREAD_WASAPI_RENDER";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_LOADER_LOCK_SAMPLER:
-    return "THREAD_LOADER_LOCK_SAMPLER";
-
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_MEMORY_INFRA:
-    return "THREAD_MEMORY_INFRA";
+  using FieldMetadata_VkQueue =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      VulkanApiEvent_VkQueueSubmit>;
 
-  case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_SAMPLING_PROFILER:
-    return "THREAD_SAMPLING_PROFILER";
+  static constexpr FieldMetadata_VkQueue kVkQueue{};
+  void set_vk_queue(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VkQueue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-class ChromeThreadDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  ChromeThreadDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeThreadDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeThreadDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_thread_type() const { return at<1>().valid(); }
-  int32_t thread_type() const { return at<1>().as_int32(); }
-  bool has_legacy_sort_index() const { return at<2>().valid(); }
-  int32_t legacy_sort_index() const { return at<2>().as_int32(); }
-};
-
-class ChromeThreadDescriptor : public ::protozero::Message {
- public:
-  using Decoder = ChromeThreadDescriptor_Decoder;
-  enum : int32_t {
-    kThreadTypeFieldNumber = 1,
-    kLegacySortIndexFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeThreadDescriptor"; }
 
-
-  using ThreadType = ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType;
-  static inline const char* ThreadType_Name(ThreadType value) {
-    return ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType_Name(value);
-  }
-  static const ThreadType THREAD_UNSPECIFIED = ThreadType::THREAD_UNSPECIFIED;
-  static const ThreadType THREAD_MAIN = ThreadType::THREAD_MAIN;
-  static const ThreadType THREAD_IO = ThreadType::THREAD_IO;
-  static const ThreadType THREAD_POOL_BG_WORKER = ThreadType::THREAD_POOL_BG_WORKER;
-  static const ThreadType THREAD_POOL_FG_WORKER = ThreadType::THREAD_POOL_FG_WORKER;
-  static const ThreadType THREAD_POOL_FG_BLOCKING = ThreadType::THREAD_POOL_FG_BLOCKING;
-  static const ThreadType THREAD_POOL_BG_BLOCKING = ThreadType::THREAD_POOL_BG_BLOCKING;
-  static const ThreadType THREAD_POOL_SERVICE = ThreadType::THREAD_POOL_SERVICE;
-  static const ThreadType THREAD_COMPOSITOR = ThreadType::THREAD_COMPOSITOR;
-  static const ThreadType THREAD_VIZ_COMPOSITOR = ThreadType::THREAD_VIZ_COMPOSITOR;
-  static const ThreadType THREAD_COMPOSITOR_WORKER = ThreadType::THREAD_COMPOSITOR_WORKER;
-  static const ThreadType THREAD_SERVICE_WORKER = ThreadType::THREAD_SERVICE_WORKER;
-  static const ThreadType THREAD_NETWORK_SERVICE = ThreadType::THREAD_NETWORK_SERVICE;
-  static const ThreadType THREAD_CHILD_IO = ThreadType::THREAD_CHILD_IO;
-  static const ThreadType THREAD_BROWSER_IO = ThreadType::THREAD_BROWSER_IO;
-  static const ThreadType THREAD_BROWSER_MAIN = ThreadType::THREAD_BROWSER_MAIN;
-  static const ThreadType THREAD_RENDERER_MAIN = ThreadType::THREAD_RENDERER_MAIN;
-  static const ThreadType THREAD_UTILITY_MAIN = ThreadType::THREAD_UTILITY_MAIN;
-  static const ThreadType THREAD_GPU_MAIN = ThreadType::THREAD_GPU_MAIN;
-  static const ThreadType THREAD_CACHE_BLOCKFILE = ThreadType::THREAD_CACHE_BLOCKFILE;
-  static const ThreadType THREAD_MEDIA = ThreadType::THREAD_MEDIA;
-  static const ThreadType THREAD_AUDIO_OUTPUTDEVICE = ThreadType::THREAD_AUDIO_OUTPUTDEVICE;
-  static const ThreadType THREAD_AUDIO_INPUTDEVICE = ThreadType::THREAD_AUDIO_INPUTDEVICE;
-  static const ThreadType THREAD_GPU_MEMORY = ThreadType::THREAD_GPU_MEMORY;
-  static const ThreadType THREAD_GPU_VSYNC = ThreadType::THREAD_GPU_VSYNC;
-  static const ThreadType THREAD_DXA_VIDEODECODER = ThreadType::THREAD_DXA_VIDEODECODER;
-  static const ThreadType THREAD_BROWSER_WATCHDOG = ThreadType::THREAD_BROWSER_WATCHDOG;
-  static const ThreadType THREAD_WEBRTC_NETWORK = ThreadType::THREAD_WEBRTC_NETWORK;
-  static const ThreadType THREAD_WINDOW_OWNER = ThreadType::THREAD_WINDOW_OWNER;
-  static const ThreadType THREAD_WEBRTC_SIGNALING = ThreadType::THREAD_WEBRTC_SIGNALING;
-  static const ThreadType THREAD_WEBRTC_WORKER = ThreadType::THREAD_WEBRTC_WORKER;
-  static const ThreadType THREAD_PPAPI_MAIN = ThreadType::THREAD_PPAPI_MAIN;
-  static const ThreadType THREAD_GPU_WATCHDOG = ThreadType::THREAD_GPU_WATCHDOG;
-  static const ThreadType THREAD_SWAPPER = ThreadType::THREAD_SWAPPER;
-  static const ThreadType THREAD_GAMEPAD_POLLING = ThreadType::THREAD_GAMEPAD_POLLING;
-  static const ThreadType THREAD_WEBCRYPTO = ThreadType::THREAD_WEBCRYPTO;
-  static const ThreadType THREAD_DATABASE = ThreadType::THREAD_DATABASE;
-  static const ThreadType THREAD_PROXYRESOLVER = ThreadType::THREAD_PROXYRESOLVER;
-  static const ThreadType THREAD_DEVTOOLSADB = ThreadType::THREAD_DEVTOOLSADB;
-  static const ThreadType THREAD_NETWORKCONFIGWATCHER = ThreadType::THREAD_NETWORKCONFIGWATCHER;
-  static const ThreadType THREAD_WASAPI_RENDER = ThreadType::THREAD_WASAPI_RENDER;
-  static const ThreadType THREAD_LOADER_LOCK_SAMPLER = ThreadType::THREAD_LOADER_LOCK_SAMPLER;
-  static const ThreadType THREAD_MEMORY_INFRA = ThreadType::THREAD_MEMORY_INFRA;
-  static const ThreadType THREAD_SAMPLING_PROFILER = ThreadType::THREAD_SAMPLING_PROFILER;
-
-  using FieldMetadata_ThreadType =
+  using FieldMetadata_VkCommandBuffers =
     ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType,
-      ChromeThreadDescriptor>;
+      5,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      VulkanApiEvent_VkQueueSubmit>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThreadType kThreadType() { return {}; }
-  void set_thread_type(::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType value) {
-    static constexpr uint32_t field_id = FieldMetadata_ThreadType::kFieldId;
+  static constexpr FieldMetadata_VkCommandBuffers kVkCommandBuffers{};
+  void add_vk_command_buffers(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VkCommandBuffers::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_LegacySortIndex =
+  using FieldMetadata_SubmissionId =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ChromeThreadDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VulkanApiEvent_VkQueueSubmit>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LegacySortIndex kLegacySortIndex() { return {}; }
-  void set_legacy_sort_index(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LegacySortIndex::kFieldId;
+  static constexpr FieldMetadata_SubmissionId kSubmissionId{};
+  void set_submission_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SubmissionId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_user_event.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_USER_EVENT_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_USER_EVENT_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class ChromeUserEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class VulkanApiEvent_VkDebugUtilsObjectName_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  ChromeUserEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeUserEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeUserEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_action() const { return at<1>().valid(); }
-  ::protozero::ConstChars action() const { return at<1>().as_string(); }
-  bool has_action_hash() const { return at<2>().valid(); }
-  uint64_t action_hash() const { return at<2>().as_uint64(); }
+  VulkanApiEvent_VkDebugUtilsObjectName_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit VulkanApiEvent_VkDebugUtilsObjectName_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit VulkanApiEvent_VkDebugUtilsObjectName_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  uint32_t pid() const { return at<1>().as_uint32(); }
+  bool has_vk_device() const { return at<2>().valid(); }
+  uint64_t vk_device() const { return at<2>().as_uint64(); }
+  bool has_object_type() const { return at<3>().valid(); }
+  int32_t object_type() const { return at<3>().as_int32(); }
+  bool has_object() const { return at<4>().valid(); }
+  uint64_t object() const { return at<4>().as_uint64(); }
+  bool has_object_name() const { return at<5>().valid(); }
+  ::protozero::ConstChars object_name() const { return at<5>().as_string(); }
 };
 
-class ChromeUserEvent : public ::protozero::Message {
+class VulkanApiEvent_VkDebugUtilsObjectName : public ::protozero::Message {
  public:
-  using Decoder = ChromeUserEvent_Decoder;
+  using Decoder = VulkanApiEvent_VkDebugUtilsObjectName_Decoder;
   enum : int32_t {
-    kActionFieldNumber = 1,
-    kActionHashFieldNumber = 2,
+    kPidFieldNumber = 1,
+    kVkDeviceFieldNumber = 2,
+    kObjectTypeFieldNumber = 3,
+    kObjectFieldNumber = 4,
+    kObjectNameFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeUserEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.VulkanApiEvent.VkDebugUtilsObjectName"; }
 
 
-  using FieldMetadata_Action =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeUserEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VulkanApiEvent_VkDebugUtilsObjectName>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Action kAction() { return {}; }
-  void set_action(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Action::kFieldId, data, size);
-  }
-  void set_action(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Action::kFieldId, chars.data, chars.size);
-  }
-  void set_action(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Action::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ActionHash =
+  using FieldMetadata_VkDevice =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      ChromeUserEvent>;
+      VulkanApiEvent_VkDebugUtilsObjectName>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ActionHash kActionHash() { return {}; }
-  void set_action_hash(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ActionHash::kFieldId;
+  static constexpr FieldMetadata_VkDevice kVkDevice{};
+  void set_vk_device(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VkDevice::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_window_handle_event_info.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_WINDOW_HANDLE_EVENT_INFO_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_WINDOW_HANDLE_EVENT_INFO_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class ChromeWindowHandleEventInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  ChromeWindowHandleEventInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeWindowHandleEventInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeWindowHandleEventInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_dpi() const { return at<1>().valid(); }
-  uint32_t dpi() const { return at<1>().as_uint32(); }
-  bool has_message_id() const { return at<2>().valid(); }
-  uint32_t message_id() const { return at<2>().as_uint32(); }
-  bool has_hwnd_ptr() const { return at<3>().valid(); }
-  uint64_t hwnd_ptr() const { return at<3>().as_uint64(); }
-};
 
-class ChromeWindowHandleEventInfo : public ::protozero::Message {
- public:
-  using Decoder = ChromeWindowHandleEventInfo_Decoder;
-  enum : int32_t {
-    kDpiFieldNumber = 1,
-    kMessageIdFieldNumber = 2,
-    kHwndPtrFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeWindowHandleEventInfo"; }
-
-
-  using FieldMetadata_Dpi =
+  using FieldMetadata_ObjectType =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      ChromeWindowHandleEventInfo>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      VulkanApiEvent_VkDebugUtilsObjectName>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Dpi kDpi() { return {}; }
-  void set_dpi(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Dpi::kFieldId;
+  static constexpr FieldMetadata_ObjectType kObjectType{};
+  void set_object_type(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ObjectType::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MessageId =
+  using FieldMetadata_Object =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      ChromeWindowHandleEventInfo>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      VulkanApiEvent_VkDebugUtilsObjectName>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MessageId kMessageId() { return {}; }
-  void set_message_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_MessageId::kFieldId;
+  static constexpr FieldMetadata_Object kObject{};
+  void set_object(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Object::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_HwndPtr =
+  using FieldMetadata_ObjectName =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
-      uint64_t,
-      ChromeWindowHandleEventInfo>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      VulkanApiEvent_VkDebugUtilsObjectName>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HwndPtr kHwndPtr() { return {}; }
-  void set_hwnd_ptr(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_HwndPtr::kFieldId;
+  static constexpr FieldMetadata_ObjectName kObjectName{};
+  void set_object_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ObjectName::kFieldId, data, size);
+  }
+  void set_object_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ObjectName::kFieldId, chars.data, chars.size);
+  }
+  void set_object_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ObjectName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 };
@@ -147356,11 +168743,11 @@ class ChromeWindowHandleEventInfo : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/counter_descriptor.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/gpu/vulkan_memory_event.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_COUNTER_DESCRIPTOR_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_COUNTER_DESCRIPTOR_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GPU_VULKAN_MEMORY_EVENT_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_GPU_VULKAN_MEMORY_EVENT_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -147374,146 +168761,251 @@ class ChromeWindowHandleEventInfo : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
+class VulkanMemoryEventAnnotation;
+namespace perfetto_pbzero_enum_VulkanMemoryEvent {
+enum AllocationScope : int32_t;
+}  // namespace perfetto_pbzero_enum_VulkanMemoryEvent
+using VulkanMemoryEvent_AllocationScope = perfetto_pbzero_enum_VulkanMemoryEvent::AllocationScope;
+namespace perfetto_pbzero_enum_VulkanMemoryEvent {
+enum Operation : int32_t;
+}  // namespace perfetto_pbzero_enum_VulkanMemoryEvent
+using VulkanMemoryEvent_Operation = perfetto_pbzero_enum_VulkanMemoryEvent::Operation;
+namespace perfetto_pbzero_enum_VulkanMemoryEvent {
+enum Source : int32_t;
+}  // namespace perfetto_pbzero_enum_VulkanMemoryEvent
+using VulkanMemoryEvent_Source = perfetto_pbzero_enum_VulkanMemoryEvent::Source;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-namespace perfetto_pbzero_enum_CounterDescriptor {
-enum BuiltinCounterType : int32_t;
-}  // namespace perfetto_pbzero_enum_CounterDescriptor
-using CounterDescriptor_BuiltinCounterType = perfetto_pbzero_enum_CounterDescriptor::BuiltinCounterType;
-namespace perfetto_pbzero_enum_CounterDescriptor {
-enum Unit : int32_t;
-}  // namespace perfetto_pbzero_enum_CounterDescriptor
-using CounterDescriptor_Unit = perfetto_pbzero_enum_CounterDescriptor::Unit;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-namespace perfetto_pbzero_enum_CounterDescriptor {
-enum BuiltinCounterType : int32_t {
-  COUNTER_UNSPECIFIED = 0,
-  COUNTER_THREAD_TIME_NS = 1,
-  COUNTER_THREAD_INSTRUCTION_COUNT = 2,
+namespace perfetto_pbzero_enum_VulkanMemoryEvent {
+enum Source : int32_t {
+  SOURCE_UNSPECIFIED = 0,
+  SOURCE_DRIVER = 1,
+  SOURCE_DEVICE = 2,
+  SOURCE_DEVICE_MEMORY = 3,
+  SOURCE_BUFFER = 4,
+  SOURCE_IMAGE = 5,
 };
-} // namespace perfetto_pbzero_enum_CounterDescriptor
-using CounterDescriptor_BuiltinCounterType = perfetto_pbzero_enum_CounterDescriptor::BuiltinCounterType;
+} // namespace perfetto_pbzero_enum_VulkanMemoryEvent
+using VulkanMemoryEvent_Source = perfetto_pbzero_enum_VulkanMemoryEvent::Source;
 
 
-constexpr CounterDescriptor_BuiltinCounterType CounterDescriptor_BuiltinCounterType_MIN = CounterDescriptor_BuiltinCounterType::COUNTER_UNSPECIFIED;
-constexpr CounterDescriptor_BuiltinCounterType CounterDescriptor_BuiltinCounterType_MAX = CounterDescriptor_BuiltinCounterType::COUNTER_THREAD_INSTRUCTION_COUNT;
+constexpr VulkanMemoryEvent_Source VulkanMemoryEvent_Source_MIN = VulkanMemoryEvent_Source::SOURCE_UNSPECIFIED;
+constexpr VulkanMemoryEvent_Source VulkanMemoryEvent_Source_MAX = VulkanMemoryEvent_Source::SOURCE_IMAGE;
 
 
 PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* CounterDescriptor_BuiltinCounterType_Name(::perfetto::protos::pbzero::CounterDescriptor_BuiltinCounterType value) {
+const char* VulkanMemoryEvent_Source_Name(::perfetto::protos::pbzero::VulkanMemoryEvent_Source value) {
   switch (value) {
-  case ::perfetto::protos::pbzero::CounterDescriptor_BuiltinCounterType::COUNTER_UNSPECIFIED:
-    return "COUNTER_UNSPECIFIED";
+  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Source::SOURCE_UNSPECIFIED:
+    return "SOURCE_UNSPECIFIED";
 
-  case ::perfetto::protos::pbzero::CounterDescriptor_BuiltinCounterType::COUNTER_THREAD_TIME_NS:
-    return "COUNTER_THREAD_TIME_NS";
+  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Source::SOURCE_DRIVER:
+    return "SOURCE_DRIVER";
 
-  case ::perfetto::protos::pbzero::CounterDescriptor_BuiltinCounterType::COUNTER_THREAD_INSTRUCTION_COUNT:
-    return "COUNTER_THREAD_INSTRUCTION_COUNT";
+  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Source::SOURCE_DEVICE:
+    return "SOURCE_DEVICE";
+
+  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Source::SOURCE_DEVICE_MEMORY:
+    return "SOURCE_DEVICE_MEMORY";
+
+  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Source::SOURCE_BUFFER:
+    return "SOURCE_BUFFER";
+
+  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Source::SOURCE_IMAGE:
+    return "SOURCE_IMAGE";
   }
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-namespace perfetto_pbzero_enum_CounterDescriptor {
-enum Unit : int32_t {
-  UNIT_UNSPECIFIED = 0,
-  UNIT_TIME_NS = 1,
-  UNIT_COUNT = 2,
-  UNIT_SIZE_BYTES = 3,
+namespace perfetto_pbzero_enum_VulkanMemoryEvent {
+enum Operation : int32_t {
+  OP_UNSPECIFIED = 0,
+  OP_CREATE = 1,
+  OP_DESTROY = 2,
+  OP_BIND = 3,
+  OP_DESTROY_BOUND = 4,
+  OP_ANNOTATIONS = 5,
 };
-} // namespace perfetto_pbzero_enum_CounterDescriptor
-using CounterDescriptor_Unit = perfetto_pbzero_enum_CounterDescriptor::Unit;
+} // namespace perfetto_pbzero_enum_VulkanMemoryEvent
+using VulkanMemoryEvent_Operation = perfetto_pbzero_enum_VulkanMemoryEvent::Operation;
 
 
-constexpr CounterDescriptor_Unit CounterDescriptor_Unit_MIN = CounterDescriptor_Unit::UNIT_UNSPECIFIED;
-constexpr CounterDescriptor_Unit CounterDescriptor_Unit_MAX = CounterDescriptor_Unit::UNIT_SIZE_BYTES;
+constexpr VulkanMemoryEvent_Operation VulkanMemoryEvent_Operation_MIN = VulkanMemoryEvent_Operation::OP_UNSPECIFIED;
+constexpr VulkanMemoryEvent_Operation VulkanMemoryEvent_Operation_MAX = VulkanMemoryEvent_Operation::OP_ANNOTATIONS;
 
 
 PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* CounterDescriptor_Unit_Name(::perfetto::protos::pbzero::CounterDescriptor_Unit value) {
+const char* VulkanMemoryEvent_Operation_Name(::perfetto::protos::pbzero::VulkanMemoryEvent_Operation value) {
   switch (value) {
-  case ::perfetto::protos::pbzero::CounterDescriptor_Unit::UNIT_UNSPECIFIED:
-    return "UNIT_UNSPECIFIED";
+  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation::OP_UNSPECIFIED:
+    return "OP_UNSPECIFIED";
 
-  case ::perfetto::protos::pbzero::CounterDescriptor_Unit::UNIT_TIME_NS:
-    return "UNIT_TIME_NS";
+  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation::OP_CREATE:
+    return "OP_CREATE";
 
-  case ::perfetto::protos::pbzero::CounterDescriptor_Unit::UNIT_COUNT:
-    return "UNIT_COUNT";
+  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation::OP_DESTROY:
+    return "OP_DESTROY";
 
-  case ::perfetto::protos::pbzero::CounterDescriptor_Unit::UNIT_SIZE_BYTES:
-    return "UNIT_SIZE_BYTES";
+  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation::OP_BIND:
+    return "OP_BIND";
+
+  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation::OP_DESTROY_BOUND:
+    return "OP_DESTROY_BOUND";
+
+  case ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation::OP_ANNOTATIONS:
+    return "OP_ANNOTATIONS";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_VulkanMemoryEvent {
+enum AllocationScope : int32_t {
+  SCOPE_UNSPECIFIED = 0,
+  SCOPE_COMMAND = 1,
+  SCOPE_OBJECT = 2,
+  SCOPE_CACHE = 3,
+  SCOPE_DEVICE = 4,
+  SCOPE_INSTANCE = 5,
+};
+} // namespace perfetto_pbzero_enum_VulkanMemoryEvent
+using VulkanMemoryEvent_AllocationScope = perfetto_pbzero_enum_VulkanMemoryEvent::AllocationScope;
+
+
+constexpr VulkanMemoryEvent_AllocationScope VulkanMemoryEvent_AllocationScope_MIN = VulkanMemoryEvent_AllocationScope::SCOPE_UNSPECIFIED;
+constexpr VulkanMemoryEvent_AllocationScope VulkanMemoryEvent_AllocationScope_MAX = VulkanMemoryEvent_AllocationScope::SCOPE_INSTANCE;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* VulkanMemoryEvent_AllocationScope_Name(::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope::SCOPE_UNSPECIFIED:
+    return "SCOPE_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope::SCOPE_COMMAND:
+    return "SCOPE_COMMAND";
+
+  case ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope::SCOPE_OBJECT:
+    return "SCOPE_OBJECT";
+
+  case ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope::SCOPE_CACHE:
+    return "SCOPE_CACHE";
+
+  case ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope::SCOPE_DEVICE:
+    return "SCOPE_DEVICE";
+
+  case ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope::SCOPE_INSTANCE:
+    return "SCOPE_INSTANCE";
   }
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-class CounterDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class VulkanMemoryEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/20> {
  public:
-  CounterDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit CounterDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit CounterDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_type() const { return at<1>().valid(); }
-  int32_t type() const { return at<1>().as_int32(); }
-  bool has_categories() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> categories() const { return GetRepeated<::protozero::ConstChars>(2); }
-  bool has_unit() const { return at<3>().valid(); }
-  int32_t unit() const { return at<3>().as_int32(); }
-  bool has_unit_name() const { return at<6>().valid(); }
-  ::protozero::ConstChars unit_name() const { return at<6>().as_string(); }
-  bool has_unit_multiplier() const { return at<4>().valid(); }
-  int64_t unit_multiplier() const { return at<4>().as_int64(); }
-  bool has_is_incremental() const { return at<5>().valid(); }
-  bool is_incremental() const { return at<5>().as_bool(); }
+  VulkanMemoryEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit VulkanMemoryEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit VulkanMemoryEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_source() const { return at<1>().valid(); }
+  int32_t source() const { return at<1>().as_int32(); }
+  bool has_operation() const { return at<2>().valid(); }
+  int32_t operation() const { return at<2>().as_int32(); }
+  bool has_timestamp() const { return at<3>().valid(); }
+  int64_t timestamp() const { return at<3>().as_int64(); }
+  bool has_pid() const { return at<4>().valid(); }
+  uint32_t pid() const { return at<4>().as_uint32(); }
+  bool has_memory_address() const { return at<5>().valid(); }
+  uint64_t memory_address() const { return at<5>().as_uint64(); }
+  bool has_memory_size() const { return at<6>().valid(); }
+  uint64_t memory_size() const { return at<6>().as_uint64(); }
+  bool has_caller_iid() const { return at<7>().valid(); }
+  uint64_t caller_iid() const { return at<7>().as_uint64(); }
+  bool has_allocation_scope() const { return at<8>().valid(); }
+  int32_t allocation_scope() const { return at<8>().as_int32(); }
+  bool has_annotations() const { return at<9>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> annotations() const { return GetRepeated<::protozero::ConstBytes>(9); }
+  bool has_device() const { return at<16>().valid(); }
+  uint64_t device() const { return at<16>().as_uint64(); }
+  bool has_device_memory() const { return at<17>().valid(); }
+  uint64_t device_memory() const { return at<17>().as_uint64(); }
+  bool has_memory_type() const { return at<18>().valid(); }
+  uint32_t memory_type() const { return at<18>().as_uint32(); }
+  bool has_heap() const { return at<19>().valid(); }
+  uint32_t heap() const { return at<19>().as_uint32(); }
+  bool has_object_handle() const { return at<20>().valid(); }
+  uint64_t object_handle() const { return at<20>().as_uint64(); }
 };
 
-class CounterDescriptor : public ::protozero::Message {
+class VulkanMemoryEvent : public ::protozero::Message {
  public:
-  using Decoder = CounterDescriptor_Decoder;
+  using Decoder = VulkanMemoryEvent_Decoder;
   enum : int32_t {
-    kTypeFieldNumber = 1,
-    kCategoriesFieldNumber = 2,
-    kUnitFieldNumber = 3,
-    kUnitNameFieldNumber = 6,
-    kUnitMultiplierFieldNumber = 4,
-    kIsIncrementalFieldNumber = 5,
+    kSourceFieldNumber = 1,
+    kOperationFieldNumber = 2,
+    kTimestampFieldNumber = 3,
+    kPidFieldNumber = 4,
+    kMemoryAddressFieldNumber = 5,
+    kMemorySizeFieldNumber = 6,
+    kCallerIidFieldNumber = 7,
+    kAllocationScopeFieldNumber = 8,
+    kAnnotationsFieldNumber = 9,
+    kDeviceFieldNumber = 16,
+    kDeviceMemoryFieldNumber = 17,
+    kMemoryTypeFieldNumber = 18,
+    kHeapFieldNumber = 19,
+    kObjectHandleFieldNumber = 20,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.CounterDescriptor"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.VulkanMemoryEvent"; }
 
 
-  using BuiltinCounterType = ::perfetto::protos::pbzero::CounterDescriptor_BuiltinCounterType;
-  static inline const char* BuiltinCounterType_Name(BuiltinCounterType value) {
-    return ::perfetto::protos::pbzero::CounterDescriptor_BuiltinCounterType_Name(value);
+  using Source = ::perfetto::protos::pbzero::VulkanMemoryEvent_Source;
+  static inline const char* Source_Name(Source value) {
+    return ::perfetto::protos::pbzero::VulkanMemoryEvent_Source_Name(value);
   }
 
-  using Unit = ::perfetto::protos::pbzero::CounterDescriptor_Unit;
-  static inline const char* Unit_Name(Unit value) {
-    return ::perfetto::protos::pbzero::CounterDescriptor_Unit_Name(value);
+  using Operation = ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation;
+  static inline const char* Operation_Name(Operation value) {
+    return ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation_Name(value);
   }
-  static const BuiltinCounterType COUNTER_UNSPECIFIED = BuiltinCounterType::COUNTER_UNSPECIFIED;
-  static const BuiltinCounterType COUNTER_THREAD_TIME_NS = BuiltinCounterType::COUNTER_THREAD_TIME_NS;
-  static const BuiltinCounterType COUNTER_THREAD_INSTRUCTION_COUNT = BuiltinCounterType::COUNTER_THREAD_INSTRUCTION_COUNT;
-  static const Unit UNIT_UNSPECIFIED = Unit::UNIT_UNSPECIFIED;
-  static const Unit UNIT_TIME_NS = Unit::UNIT_TIME_NS;
-  static const Unit UNIT_COUNT = Unit::UNIT_COUNT;
-  static const Unit UNIT_SIZE_BYTES = Unit::UNIT_SIZE_BYTES;
 
-  using FieldMetadata_Type =
+  using AllocationScope = ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope;
+  static inline const char* AllocationScope_Name(AllocationScope value) {
+    return ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope_Name(value);
+  }
+  static inline const Source SOURCE_UNSPECIFIED = Source::SOURCE_UNSPECIFIED;
+  static inline const Source SOURCE_DRIVER = Source::SOURCE_DRIVER;
+  static inline const Source SOURCE_DEVICE = Source::SOURCE_DEVICE;
+  static inline const Source SOURCE_DEVICE_MEMORY = Source::SOURCE_DEVICE_MEMORY;
+  static inline const Source SOURCE_BUFFER = Source::SOURCE_BUFFER;
+  static inline const Source SOURCE_IMAGE = Source::SOURCE_IMAGE;
+  static inline const Operation OP_UNSPECIFIED = Operation::OP_UNSPECIFIED;
+  static inline const Operation OP_CREATE = Operation::OP_CREATE;
+  static inline const Operation OP_DESTROY = Operation::OP_DESTROY;
+  static inline const Operation OP_BIND = Operation::OP_BIND;
+  static inline const Operation OP_DESTROY_BOUND = Operation::OP_DESTROY_BOUND;
+  static inline const Operation OP_ANNOTATIONS = Operation::OP_ANNOTATIONS;
+  static inline const AllocationScope SCOPE_UNSPECIFIED = AllocationScope::SCOPE_UNSPECIFIED;
+  static inline const AllocationScope SCOPE_COMMAND = AllocationScope::SCOPE_COMMAND;
+  static inline const AllocationScope SCOPE_OBJECT = AllocationScope::SCOPE_OBJECT;
+  static inline const AllocationScope SCOPE_CACHE = AllocationScope::SCOPE_CACHE;
+  static inline const AllocationScope SCOPE_DEVICE = AllocationScope::SCOPE_DEVICE;
+  static inline const AllocationScope SCOPE_INSTANCE = AllocationScope::SCOPE_INSTANCE;
+
+  using FieldMetadata_Source =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::CounterDescriptor_BuiltinCounterType,
-      CounterDescriptor>;
+      VulkanMemoryEvent_Source,
+      VulkanMemoryEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(::perfetto::protos::pbzero::CounterDescriptor_BuiltinCounterType value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+  static constexpr FieldMetadata_Source kSource{};
+  void set_source(VulkanMemoryEvent_Source value) {
+    static constexpr uint32_t field_id = FieldMetadata_Source::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -147521,55 +169013,17 @@ class CounterDescriptor : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Categories =
+  using FieldMetadata_Operation =
     ::protozero::proto_utils::FieldMetadata<
       2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      CounterDescriptor>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Categories kCategories() { return {}; }
-  void add_categories(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Categories::kFieldId, data, size);
-  }
-  void add_categories(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Categories::kFieldId, chars.data, chars.size);
-  }
-  void add_categories(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Categories::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Unit =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::CounterDescriptor_Unit,
-      CounterDescriptor>;
+      VulkanMemoryEvent_Operation,
+      VulkanMemoryEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Unit kUnit() { return {}; }
-  void set_unit(::perfetto::protos::pbzero::CounterDescriptor_Unit value) {
-    static constexpr uint32_t field_id = FieldMetadata_Unit::kFieldId;
+  static constexpr FieldMetadata_Operation kOperation{};
+  void set_operation(VulkanMemoryEvent_Operation value) {
+    static constexpr uint32_t field_id = FieldMetadata_Operation::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -147577,55 +169031,17 @@ class CounterDescriptor : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_UnitName =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      CounterDescriptor>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UnitName kUnitName() { return {}; }
-  void set_unit_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_UnitName::kFieldId, data, size);
-  }
-  void set_unit_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_UnitName::kFieldId, chars.data, chars.size);
-  }
-  void set_unit_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_UnitName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_UnitMultiplier =
+  using FieldMetadata_Timestamp =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt64,
       int64_t,
-      CounterDescriptor>;
+      VulkanMemoryEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UnitMultiplier kUnitMultiplier() { return {}; }
-  void set_unit_multiplier(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_UnitMultiplier::kFieldId;
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -147633,208 +169049,71 @@ class CounterDescriptor : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IsIncremental =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      CounterDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VulkanMemoryEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IsIncremental kIsIncremental() { return {}; }
-  void set_is_incremental(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_IsIncremental::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/debug_annotation.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_DEBUG_ANNOTATION_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_DEBUG_ANNOTATION_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-class DebugAnnotation;
-class DebugAnnotation_NestedValue;
-namespace perfetto_pbzero_enum_DebugAnnotation_NestedValue {
-enum NestedType : int32_t;
-}  // namespace perfetto_pbzero_enum_DebugAnnotation_NestedValue
-using DebugAnnotation_NestedValue_NestedType = perfetto_pbzero_enum_DebugAnnotation_NestedValue::NestedType;
-
-namespace perfetto_pbzero_enum_DebugAnnotation_NestedValue {
-enum NestedType : int32_t {
-  UNSPECIFIED = 0,
-  DICT = 1,
-  ARRAY = 2,
-};
-} // namespace perfetto_pbzero_enum_DebugAnnotation_NestedValue
-using DebugAnnotation_NestedValue_NestedType = perfetto_pbzero_enum_DebugAnnotation_NestedValue::NestedType;
-
-
-constexpr DebugAnnotation_NestedValue_NestedType DebugAnnotation_NestedValue_NestedType_MIN = DebugAnnotation_NestedValue_NestedType::UNSPECIFIED;
-constexpr DebugAnnotation_NestedValue_NestedType DebugAnnotation_NestedValue_NestedType_MAX = DebugAnnotation_NestedValue_NestedType::ARRAY;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* DebugAnnotation_NestedValue_NestedType_Name(::perfetto::protos::pbzero::DebugAnnotation_NestedValue_NestedType value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::DebugAnnotation_NestedValue_NestedType::UNSPECIFIED:
-    return "UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::DebugAnnotation_NestedValue_NestedType::DICT:
-    return "DICT";
-
-  case ::perfetto::protos::pbzero::DebugAnnotation_NestedValue_NestedType::ARRAY:
-    return "ARRAY";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-class DebugAnnotationValueTypeName_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  DebugAnnotationValueTypeName_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit DebugAnnotationValueTypeName_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit DebugAnnotationValueTypeName_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_iid() const { return at<1>().valid(); }
-  uint64_t iid() const { return at<1>().as_uint64(); }
-  bool has_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars name() const { return at<2>().as_string(); }
-};
-
-class DebugAnnotationValueTypeName : public ::protozero::Message {
- public:
-  using Decoder = DebugAnnotationValueTypeName_Decoder;
-  enum : int32_t {
-    kIidFieldNumber = 1,
-    kNameFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.DebugAnnotationValueTypeName"; }
-
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Iid =
+  using FieldMetadata_MemoryAddress =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
       uint64_t,
-      DebugAnnotationValueTypeName>;
+      VulkanMemoryEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Iid kIid() { return {}; }
-  void set_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
+  static constexpr FieldMetadata_MemoryAddress kMemoryAddress{};
+  void set_memory_address(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MemoryAddress::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Name =
+  using FieldMetadata_MemorySize =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      DebugAnnotationValueTypeName>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      VulkanMemoryEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_MemorySize kMemorySize{};
+  void set_memory_size(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MemorySize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class DebugAnnotationName_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  DebugAnnotationName_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit DebugAnnotationName_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit DebugAnnotationName_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_iid() const { return at<1>().valid(); }
-  uint64_t iid() const { return at<1>().as_uint64(); }
-  bool has_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars name() const { return at<2>().as_string(); }
-};
-
-class DebugAnnotationName : public ::protozero::Message {
- public:
-  using Decoder = DebugAnnotationName_Decoder;
-  enum : int32_t {
-    kIidFieldNumber = 1,
-    kNameFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.DebugAnnotationName"; }
-
 
-  using FieldMetadata_Iid =
+  using FieldMetadata_CallerIid =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      DebugAnnotationName>;
+      VulkanMemoryEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Iid kIid() { return {}; }
-  void set_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
+  static constexpr FieldMetadata_CallerIid kCallerIid{};
+  void set_caller_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CallerIid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -147842,201 +169121,167 @@ class DebugAnnotationName : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Name =
+  using FieldMetadata_AllocationScope =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      DebugAnnotationName>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      VulkanMemoryEvent_AllocationScope,
+      VulkanMemoryEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_AllocationScope kAllocationScope{};
+  void set_allocation_scope(VulkanMemoryEvent_AllocationScope value) {
+    static constexpr uint32_t field_id = FieldMetadata_AllocationScope::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
-};
 
-class DebugAnnotation_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/17, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  DebugAnnotation_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit DebugAnnotation_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit DebugAnnotation_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name_iid() const { return at<1>().valid(); }
-  uint64_t name_iid() const { return at<1>().as_uint64(); }
-  bool has_name() const { return at<10>().valid(); }
-  ::protozero::ConstChars name() const { return at<10>().as_string(); }
-  bool has_bool_value() const { return at<2>().valid(); }
-  bool bool_value() const { return at<2>().as_bool(); }
-  bool has_uint_value() const { return at<3>().valid(); }
-  uint64_t uint_value() const { return at<3>().as_uint64(); }
-  bool has_int_value() const { return at<4>().valid(); }
-  int64_t int_value() const { return at<4>().as_int64(); }
-  bool has_double_value() const { return at<5>().valid(); }
-  double double_value() const { return at<5>().as_double(); }
-  bool has_pointer_value() const { return at<7>().valid(); }
-  uint64_t pointer_value() const { return at<7>().as_uint64(); }
-  bool has_nested_value() const { return at<8>().valid(); }
-  ::protozero::ConstBytes nested_value() const { return at<8>().as_bytes(); }
-  bool has_legacy_json_value() const { return at<9>().valid(); }
-  ::protozero::ConstChars legacy_json_value() const { return at<9>().as_string(); }
-  bool has_string_value() const { return at<6>().valid(); }
-  ::protozero::ConstChars string_value() const { return at<6>().as_string(); }
-  bool has_string_value_iid() const { return at<17>().valid(); }
-  uint64_t string_value_iid() const { return at<17>().as_uint64(); }
-  bool has_proto_type_name() const { return at<16>().valid(); }
-  ::protozero::ConstChars proto_type_name() const { return at<16>().as_string(); }
-  bool has_proto_type_name_iid() const { return at<13>().valid(); }
-  uint64_t proto_type_name_iid() const { return at<13>().as_uint64(); }
-  bool has_proto_value() const { return at<14>().valid(); }
-  ::protozero::ConstBytes proto_value() const { return at<14>().as_bytes(); }
-  bool has_dict_entries() const { return at<11>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> dict_entries() const { return GetRepeated<::protozero::ConstBytes>(11); }
-  bool has_array_values() const { return at<12>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> array_values() const { return GetRepeated<::protozero::ConstBytes>(12); }
-};
+  using FieldMetadata_Annotations =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      VulkanMemoryEventAnnotation,
+      VulkanMemoryEvent>;
 
-class DebugAnnotation : public ::protozero::Message {
- public:
-  using Decoder = DebugAnnotation_Decoder;
-  enum : int32_t {
-    kNameIidFieldNumber = 1,
-    kNameFieldNumber = 10,
-    kBoolValueFieldNumber = 2,
-    kUintValueFieldNumber = 3,
-    kIntValueFieldNumber = 4,
-    kDoubleValueFieldNumber = 5,
-    kPointerValueFieldNumber = 7,
-    kNestedValueFieldNumber = 8,
-    kLegacyJsonValueFieldNumber = 9,
-    kStringValueFieldNumber = 6,
-    kStringValueIidFieldNumber = 17,
-    kProtoTypeNameFieldNumber = 16,
-    kProtoTypeNameIidFieldNumber = 13,
-    kProtoValueFieldNumber = 14,
-    kDictEntriesFieldNumber = 11,
-    kArrayValuesFieldNumber = 12,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.DebugAnnotation"; }
+  static constexpr FieldMetadata_Annotations kAnnotations{};
+  template <typename T = VulkanMemoryEventAnnotation> T* add_annotations() {
+    return BeginNestedMessage<T>(9);
+  }
 
-  using NestedValue = ::perfetto::protos::pbzero::DebugAnnotation_NestedValue;
 
-  using FieldMetadata_NameIid =
+  using FieldMetadata_Device =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      16,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
       uint64_t,
-      DebugAnnotation>;
+      VulkanMemoryEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NameIid kNameIid() { return {}; }
-  void set_name_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NameIid::kFieldId;
+  static constexpr FieldMetadata_Device kDevice{};
+  void set_device(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Device::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Name =
+  using FieldMetadata_DeviceMemory =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      17,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      DebugAnnotation>;
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
+      uint64_t,
+      VulkanMemoryEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  static constexpr FieldMetadata_DeviceMemory kDeviceMemory{};
+  void set_device_memory(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DeviceMemory::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
+        ::Append(*this, field_id, value);
   }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+
+  using FieldMetadata_MemoryType =
+    ::protozero::proto_utils::FieldMetadata<
+      18,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VulkanMemoryEvent>;
+
+  static constexpr FieldMetadata_MemoryType kMemoryType{};
+  void set_memory_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MemoryType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+
+  using FieldMetadata_Heap =
+    ::protozero::proto_utils::FieldMetadata<
+      19,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      VulkanMemoryEvent>;
+
+  static constexpr FieldMetadata_Heap kHeap{};
+  void set_heap(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Heap::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BoolValue =
+  using FieldMetadata_ObjectHandle =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      20,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      DebugAnnotation>;
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
+      uint64_t,
+      VulkanMemoryEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BoolValue kBoolValue() { return {}; }
-  void set_bool_value(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_BoolValue::kFieldId;
+  static constexpr FieldMetadata_ObjectHandle kObjectHandle{};
+  void set_object_handle(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ObjectHandle::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_UintValue =
+class VulkanMemoryEventAnnotation_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  VulkanMemoryEventAnnotation_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit VulkanMemoryEventAnnotation_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit VulkanMemoryEventAnnotation_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_key_iid() const { return at<1>().valid(); }
+  uint64_t key_iid() const { return at<1>().as_uint64(); }
+  bool has_int_value() const { return at<2>().valid(); }
+  int64_t int_value() const { return at<2>().as_int64(); }
+  bool has_double_value() const { return at<3>().valid(); }
+  double double_value() const { return at<3>().as_double(); }
+  bool has_string_iid() const { return at<4>().valid(); }
+  uint64_t string_iid() const { return at<4>().as_uint64(); }
+};
+
+class VulkanMemoryEventAnnotation : public ::protozero::Message {
+ public:
+  using Decoder = VulkanMemoryEventAnnotation_Decoder;
+  enum : int32_t {
+    kKeyIidFieldNumber = 1,
+    kIntValueFieldNumber = 2,
+    kDoubleValueFieldNumber = 3,
+    kStringIidFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.VulkanMemoryEventAnnotation"; }
+
+
+  using FieldMetadata_KeyIid =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      DebugAnnotation>;
+      VulkanMemoryEventAnnotation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UintValue kUintValue() { return {}; }
-  void set_uint_value(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_UintValue::kFieldId;
+  static constexpr FieldMetadata_KeyIid kKeyIid{};
+  void set_key_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KeyIid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -148046,20 +169291,13 @@ class DebugAnnotation : public ::protozero::Message {
 
   using FieldMetadata_IntValue =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt64,
       int64_t,
-      DebugAnnotation>;
+      VulkanMemoryEventAnnotation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IntValue kIntValue() { return {}; }
+  static constexpr FieldMetadata_IntValue kIntValue{};
   void set_int_value(int64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -148071,20 +169309,13 @@ class DebugAnnotation : public ::protozero::Message {
 
   using FieldMetadata_DoubleValue =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kDouble,
       double,
-      DebugAnnotation>;
+      VulkanMemoryEventAnnotation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DoubleValue kDoubleValue() { return {}; }
+  static constexpr FieldMetadata_DoubleValue kDoubleValue{};
   void set_double_value(double value) {
     static constexpr uint32_t field_id = FieldMetadata_DoubleValue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -148094,76 +169325,98 @@ class DebugAnnotation : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PointerValue =
+  using FieldMetadata_StringIid =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      DebugAnnotation>;
+      VulkanMemoryEventAnnotation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PointerValue kPointerValue() { return {}; }
-  void set_pointer_value(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PointerValue::kFieldId;
+  static constexpr FieldMetadata_StringIid kStringIid{};
+  void set_string_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StringIid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_NestedValue =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      DebugAnnotation_NestedValue,
-      DebugAnnotation>;
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/profiling/deobfuscation.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NestedValue kNestedValue() { return {}; }
-  template <typename T = DebugAnnotation_NestedValue> T* set_nested_value() {
-    return BeginNestedMessage<T>(8);
-  }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_DEOBFUSCATION_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_DEOBFUSCATION_PROTO_H_
 
+#include <stddef.h>
+#include <stdint.h>
 
-  using FieldMetadata_LegacyJsonValue =
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class ObfuscatedClass;
+class ObfuscatedMember;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class DeobfuscationMapping_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  DeobfuscationMapping_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit DeobfuscationMapping_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit DeobfuscationMapping_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_package_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars package_name() const { return at<1>().as_string(); }
+  bool has_version_code() const { return at<2>().valid(); }
+  int64_t version_code() const { return at<2>().as_int64(); }
+  bool has_obfuscated_classes() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> obfuscated_classes() const { return GetRepeated<::protozero::ConstBytes>(3); }
+};
+
+class DeobfuscationMapping : public ::protozero::Message {
+ public:
+  using Decoder = DeobfuscationMapping_Decoder;
+  enum : int32_t {
+    kPackageNameFieldNumber = 1,
+    kVersionCodeFieldNumber = 2,
+    kObfuscatedClassesFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.DeobfuscationMapping"; }
+
+
+  using FieldMetadata_PackageName =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      DebugAnnotation>;
+      DeobfuscationMapping>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LegacyJsonValue kLegacyJsonValue() { return {}; }
-  void set_legacy_json_value(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_LegacyJsonValue::kFieldId, data, size);
+  static constexpr FieldMetadata_PackageName kPackageName{};
+  void set_package_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_PackageName::kFieldId, data, size);
   }
-  void set_legacy_json_value(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_LegacyJsonValue::kFieldId, chars.data, chars.size);
+  void set_package_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_PackageName::kFieldId, chars.data, chars.size);
   }
-  void set_legacy_json_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_LegacyJsonValue::kFieldId;
+  void set_package_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_PackageName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -148171,86 +169424,83 @@ class DebugAnnotation : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_StringValue =
+  using FieldMetadata_VersionCode =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      DebugAnnotation>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      DeobfuscationMapping>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StringValue kStringValue() { return {}; }
-  void set_string_value(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_StringValue::kFieldId, data, size);
-  }
-  void set_string_value(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_StringValue::kFieldId, chars.data, chars.size);
-  }
-  void set_string_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_StringValue::kFieldId;
+  static constexpr FieldMetadata_VersionCode kVersionCode{};
+  void set_version_code(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VersionCode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_StringValueIid =
+  using FieldMetadata_ObfuscatedClasses =
     ::protozero::proto_utils::FieldMetadata<
-      17,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      DebugAnnotation>;
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ObfuscatedClass,
+      DeobfuscationMapping>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StringValueIid kStringValueIid() { return {}; }
-  void set_string_value_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StringValueIid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_ObfuscatedClasses kObfuscatedClasses{};
+  template <typename T = ObfuscatedClass> T* add_obfuscated_classes() {
+    return BeginNestedMessage<T>(3);
   }
 
-  using FieldMetadata_ProtoTypeName =
+};
+
+class ObfuscatedClass_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  ObfuscatedClass_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ObfuscatedClass_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ObfuscatedClass_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_obfuscated_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars obfuscated_name() const { return at<1>().as_string(); }
+  bool has_deobfuscated_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars deobfuscated_name() const { return at<2>().as_string(); }
+  bool has_obfuscated_members() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> obfuscated_members() const { return GetRepeated<::protozero::ConstBytes>(3); }
+  bool has_obfuscated_methods() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> obfuscated_methods() const { return GetRepeated<::protozero::ConstBytes>(4); }
+};
+
+class ObfuscatedClass : public ::protozero::Message {
+ public:
+  using Decoder = ObfuscatedClass_Decoder;
+  enum : int32_t {
+    kObfuscatedNameFieldNumber = 1,
+    kDeobfuscatedNameFieldNumber = 2,
+    kObfuscatedMembersFieldNumber = 3,
+    kObfuscatedMethodsFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ObfuscatedClass"; }
+
+
+  using FieldMetadata_ObfuscatedName =
     ::protozero::proto_utils::FieldMetadata<
-      16,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      DebugAnnotation>;
+      ObfuscatedClass>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProtoTypeName kProtoTypeName() { return {}; }
-  void set_proto_type_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ProtoTypeName::kFieldId, data, size);
+  static constexpr FieldMetadata_ObfuscatedName kObfuscatedName{};
+  void set_obfuscated_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ObfuscatedName::kFieldId, data, size);
   }
-  void set_proto_type_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ProtoTypeName::kFieldId, chars.data, chars.size);
+  void set_obfuscated_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ObfuscatedName::kFieldId, chars.data, chars.size);
   }
-  void set_proto_type_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProtoTypeName::kFieldId;
+  void set_obfuscated_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ObfuscatedName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -148258,201 +169508,133 @@ class DebugAnnotation : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ProtoTypeNameIid =
-    ::protozero::proto_utils::FieldMetadata<
-      13,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      DebugAnnotation>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProtoTypeNameIid kProtoTypeNameIid() { return {}; }
-  void set_proto_type_name_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProtoTypeNameIid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ProtoValue =
+  using FieldMetadata_DeobfuscatedName =
     ::protozero::proto_utils::FieldMetadata<
-      14,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      DebugAnnotation>;
+      ObfuscatedClass>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProtoValue kProtoValue() { return {}; }
-  void set_proto_value(const uint8_t* data, size_t size) {
-    AppendBytes(FieldMetadata_ProtoValue::kFieldId, data, size);
+  static constexpr FieldMetadata_DeobfuscatedName kDeobfuscatedName{};
+  void set_deobfuscated_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_DeobfuscatedName::kFieldId, data, size);
   }
-  void set_proto_value(::protozero::ConstBytes bytes) {
-    AppendBytes(FieldMetadata_ProtoValue::kFieldId, bytes.data, bytes.size);
+  void set_deobfuscated_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_DeobfuscatedName::kFieldId, chars.data, chars.size);
   }
-  void set_proto_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProtoValue::kFieldId;
+  void set_deobfuscated_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_DeobfuscatedName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DictEntries =
+  using FieldMetadata_ObfuscatedMembers =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      3,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      DebugAnnotation,
-      DebugAnnotation>;
+      ObfuscatedMember,
+      ObfuscatedClass>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DictEntries kDictEntries() { return {}; }
-  template <typename T = DebugAnnotation> T* add_dict_entries() {
-    return BeginNestedMessage<T>(11);
+  static constexpr FieldMetadata_ObfuscatedMembers kObfuscatedMembers{};
+  template <typename T = ObfuscatedMember> T* add_obfuscated_members() {
+    return BeginNestedMessage<T>(3);
   }
 
 
-  using FieldMetadata_ArrayValues =
+  using FieldMetadata_ObfuscatedMethods =
     ::protozero::proto_utils::FieldMetadata<
-      12,
+      4,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      DebugAnnotation,
-      DebugAnnotation>;
+      ObfuscatedMember,
+      ObfuscatedClass>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ArrayValues kArrayValues() { return {}; }
-  template <typename T = DebugAnnotation> T* add_array_values() {
-    return BeginNestedMessage<T>(12);
+  static constexpr FieldMetadata_ObfuscatedMethods kObfuscatedMethods{};
+  template <typename T = ObfuscatedMember> T* add_obfuscated_methods() {
+    return BeginNestedMessage<T>(4);
   }
 
 };
 
-class DebugAnnotation_NestedValue_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class ObfuscatedMember_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  DebugAnnotation_NestedValue_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit DebugAnnotation_NestedValue_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit DebugAnnotation_NestedValue_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_nested_type() const { return at<1>().valid(); }
-  int32_t nested_type() const { return at<1>().as_int32(); }
-  bool has_dict_keys() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> dict_keys() const { return GetRepeated<::protozero::ConstChars>(2); }
-  bool has_dict_values() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> dict_values() const { return GetRepeated<::protozero::ConstBytes>(3); }
-  bool has_array_values() const { return at<4>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> array_values() const { return GetRepeated<::protozero::ConstBytes>(4); }
-  bool has_int_value() const { return at<5>().valid(); }
-  int64_t int_value() const { return at<5>().as_int64(); }
-  bool has_double_value() const { return at<6>().valid(); }
-  double double_value() const { return at<6>().as_double(); }
-  bool has_bool_value() const { return at<7>().valid(); }
-  bool bool_value() const { return at<7>().as_bool(); }
-  bool has_string_value() const { return at<8>().valid(); }
-  ::protozero::ConstChars string_value() const { return at<8>().as_string(); }
+  ObfuscatedMember_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ObfuscatedMember_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ObfuscatedMember_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_obfuscated_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars obfuscated_name() const { return at<1>().as_string(); }
+  bool has_deobfuscated_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars deobfuscated_name() const { return at<2>().as_string(); }
+  bool has_obfuscated_line_start() const { return at<3>().valid(); }
+  uint32_t obfuscated_line_start() const { return at<3>().as_uint32(); }
+  bool has_obfuscated_line_end() const { return at<4>().valid(); }
+  uint32_t obfuscated_line_end() const { return at<4>().as_uint32(); }
+  bool has_source_line_start() const { return at<5>().valid(); }
+  uint32_t source_line_start() const { return at<5>().as_uint32(); }
+  bool has_source_line_end() const { return at<6>().valid(); }
+  uint32_t source_line_end() const { return at<6>().as_uint32(); }
 };
 
-class DebugAnnotation_NestedValue : public ::protozero::Message {
+class ObfuscatedMember : public ::protozero::Message {
  public:
-  using Decoder = DebugAnnotation_NestedValue_Decoder;
+  using Decoder = ObfuscatedMember_Decoder;
   enum : int32_t {
-    kNestedTypeFieldNumber = 1,
-    kDictKeysFieldNumber = 2,
-    kDictValuesFieldNumber = 3,
-    kArrayValuesFieldNumber = 4,
-    kIntValueFieldNumber = 5,
-    kDoubleValueFieldNumber = 6,
-    kBoolValueFieldNumber = 7,
-    kStringValueFieldNumber = 8,
+    kObfuscatedNameFieldNumber = 1,
+    kDeobfuscatedNameFieldNumber = 2,
+    kObfuscatedLineStartFieldNumber = 3,
+    kObfuscatedLineEndFieldNumber = 4,
+    kSourceLineStartFieldNumber = 5,
+    kSourceLineEndFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.DebugAnnotation.NestedValue"; }
-
+  static constexpr const char* GetName() { return ".perfetto.protos.ObfuscatedMember"; }
 
-  using NestedType = ::perfetto::protos::pbzero::DebugAnnotation_NestedValue_NestedType;
-  static inline const char* NestedType_Name(NestedType value) {
-    return ::perfetto::protos::pbzero::DebugAnnotation_NestedValue_NestedType_Name(value);
-  }
-  static const NestedType UNSPECIFIED = NestedType::UNSPECIFIED;
-  static const NestedType DICT = NestedType::DICT;
-  static const NestedType ARRAY = NestedType::ARRAY;
 
-  using FieldMetadata_NestedType =
+  using FieldMetadata_ObfuscatedName =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::DebugAnnotation_NestedValue_NestedType,
-      DebugAnnotation_NestedValue>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ObfuscatedMember>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NestedType kNestedType() { return {}; }
-  void set_nested_type(::perfetto::protos::pbzero::DebugAnnotation_NestedValue_NestedType value) {
-    static constexpr uint32_t field_id = FieldMetadata_NestedType::kFieldId;
+  static constexpr FieldMetadata_ObfuscatedName kObfuscatedName{};
+  void set_obfuscated_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ObfuscatedName::kFieldId, data, size);
+  }
+  void set_obfuscated_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ObfuscatedName::kFieldId, chars.data, chars.size);
+  }
+  void set_obfuscated_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ObfuscatedName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DictKeys =
+  using FieldMetadata_DeobfuscatedName =
     ::protozero::proto_utils::FieldMetadata<
       2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      DebugAnnotation_NestedValue>;
+      ObfuscatedMember>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DictKeys kDictKeys() { return {}; }
-  void add_dict_keys(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_DictKeys::kFieldId, data, size);
+  static constexpr FieldMetadata_DeobfuscatedName kDeobfuscatedName{};
+  void set_deobfuscated_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_DeobfuscatedName::kFieldId, data, size);
   }
-  void add_dict_keys(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_DictKeys::kFieldId, chars.data, chars.size);
+  void set_deobfuscated_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_DeobfuscatedName::kFieldId, chars.data, chars.size);
   }
-  void add_dict_keys(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_DictKeys::kFieldId;
+  void set_deobfuscated_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_DeobfuscatedName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -148460,151 +169642,75 @@ class DebugAnnotation_NestedValue : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DictValues =
+  using FieldMetadata_ObfuscatedLineStart =
     ::protozero::proto_utils::FieldMetadata<
       3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      DebugAnnotation_NestedValue,
-      DebugAnnotation_NestedValue>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DictValues kDictValues() { return {}; }
-  template <typename T = DebugAnnotation_NestedValue> T* add_dict_values() {
-    return BeginNestedMessage<T>(3);
-  }
-
-
-  using FieldMetadata_ArrayValues =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      DebugAnnotation_NestedValue,
-      DebugAnnotation_NestedValue>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ArrayValues kArrayValues() { return {}; }
-  template <typename T = DebugAnnotation_NestedValue> T* add_array_values() {
-    return BeginNestedMessage<T>(4);
-  }
-
-
-  using FieldMetadata_IntValue =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      DebugAnnotation_NestedValue>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ObfuscatedMember>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IntValue kIntValue() { return {}; }
-  void set_int_value(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId;
+  static constexpr FieldMetadata_ObfuscatedLineStart kObfuscatedLineStart{};
+  void set_obfuscated_line_start(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ObfuscatedLineStart::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DoubleValue =
+  using FieldMetadata_ObfuscatedLineEnd =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kDouble,
-      double,
-      DebugAnnotation_NestedValue>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ObfuscatedMember>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DoubleValue kDoubleValue() { return {}; }
-  void set_double_value(double value) {
-    static constexpr uint32_t field_id = FieldMetadata_DoubleValue::kFieldId;
+  static constexpr FieldMetadata_ObfuscatedLineEnd kObfuscatedLineEnd{};
+  void set_obfuscated_line_end(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ObfuscatedLineEnd::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BoolValue =
+  using FieldMetadata_SourceLineStart =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      DebugAnnotation_NestedValue>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ObfuscatedMember>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BoolValue kBoolValue() { return {}; }
-  void set_bool_value(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_BoolValue::kFieldId;
+  static constexpr FieldMetadata_SourceLineStart kSourceLineStart{};
+  void set_source_line_start(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SourceLineStart::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_StringValue =
+  using FieldMetadata_SourceLineEnd =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      DebugAnnotation_NestedValue>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ObfuscatedMember>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StringValue kStringValue() { return {}; }
-  void set_string_value(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_StringValue::kFieldId, data, size);
-  }
-  void set_string_value(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_StringValue::kFieldId, chars.data, chars.size);
-  }
-  void set_string_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_StringValue::kFieldId;
+  static constexpr FieldMetadata_SourceLineEnd kSourceLineEnd{};
+  void set_source_line_end(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SourceLineEnd::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
@@ -148613,11 +169719,11 @@ class DebugAnnotation_NestedValue : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/log_message.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/profiling/heap_graph.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_LOG_MESSAGE_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_LOG_MESSAGE_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_HEAP_GRAPH_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_HEAP_GRAPH_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -148627,51 +169733,439 @@ class DebugAnnotation_NestedValue : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/profiling/deobfuscation.pbzero.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class HeapGraphObject;
+class HeapGraphRoot;
+class HeapGraphType;
+class InternedString;
+namespace perfetto_pbzero_enum_HeapGraphObject {
+enum HeapType : int32_t;
+}  // namespace perfetto_pbzero_enum_HeapGraphObject
+using HeapGraphObject_HeapType = perfetto_pbzero_enum_HeapGraphObject::HeapType;
+namespace perfetto_pbzero_enum_HeapGraphRoot {
+enum Type : int32_t;
+}  // namespace perfetto_pbzero_enum_HeapGraphRoot
+using HeapGraphRoot_Type = perfetto_pbzero_enum_HeapGraphRoot::Type;
+namespace perfetto_pbzero_enum_HeapGraphType {
+enum Kind : int32_t;
+}  // namespace perfetto_pbzero_enum_HeapGraphType
+using HeapGraphType_Kind = perfetto_pbzero_enum_HeapGraphType::Kind;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
+namespace perfetto_pbzero_enum_HeapGraphObject {
+enum HeapType : int32_t {
+  HEAP_TYPE_UNKNOWN = 0,
+  HEAP_TYPE_APP = 1,
+  HEAP_TYPE_ZYGOTE = 2,
+  HEAP_TYPE_BOOT_IMAGE = 3,
+};
+} // namespace perfetto_pbzero_enum_HeapGraphObject
+using HeapGraphObject_HeapType = perfetto_pbzero_enum_HeapGraphObject::HeapType;
+
+
+constexpr HeapGraphObject_HeapType HeapGraphObject_HeapType_MIN = HeapGraphObject_HeapType::HEAP_TYPE_UNKNOWN;
+constexpr HeapGraphObject_HeapType HeapGraphObject_HeapType_MAX = HeapGraphObject_HeapType::HEAP_TYPE_BOOT_IMAGE;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* HeapGraphObject_HeapType_Name(::perfetto::protos::pbzero::HeapGraphObject_HeapType value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::HeapGraphObject_HeapType::HEAP_TYPE_UNKNOWN:
+    return "HEAP_TYPE_UNKNOWN";
+
+  case ::perfetto::protos::pbzero::HeapGraphObject_HeapType::HEAP_TYPE_APP:
+    return "HEAP_TYPE_APP";
+
+  case ::perfetto::protos::pbzero::HeapGraphObject_HeapType::HEAP_TYPE_ZYGOTE:
+    return "HEAP_TYPE_ZYGOTE";
+
+  case ::perfetto::protos::pbzero::HeapGraphObject_HeapType::HEAP_TYPE_BOOT_IMAGE:
+    return "HEAP_TYPE_BOOT_IMAGE";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_HeapGraphType {
+enum Kind : int32_t {
+  KIND_UNKNOWN = 0,
+  KIND_NORMAL = 1,
+  KIND_NOREFERENCES = 2,
+  KIND_STRING = 3,
+  KIND_ARRAY = 4,
+  KIND_CLASS = 5,
+  KIND_CLASSLOADER = 6,
+  KIND_DEXCACHE = 7,
+  KIND_SOFT_REFERENCE = 8,
+  KIND_WEAK_REFERENCE = 9,
+  KIND_FINALIZER_REFERENCE = 10,
+  KIND_PHANTOM_REFERENCE = 11,
+};
+} // namespace perfetto_pbzero_enum_HeapGraphType
+using HeapGraphType_Kind = perfetto_pbzero_enum_HeapGraphType::Kind;
+
+
+constexpr HeapGraphType_Kind HeapGraphType_Kind_MIN = HeapGraphType_Kind::KIND_UNKNOWN;
+constexpr HeapGraphType_Kind HeapGraphType_Kind_MAX = HeapGraphType_Kind::KIND_PHANTOM_REFERENCE;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* HeapGraphType_Kind_Name(::perfetto::protos::pbzero::HeapGraphType_Kind value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_UNKNOWN:
+    return "KIND_UNKNOWN";
+
+  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_NORMAL:
+    return "KIND_NORMAL";
+
+  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_NOREFERENCES:
+    return "KIND_NOREFERENCES";
+
+  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_STRING:
+    return "KIND_STRING";
+
+  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_ARRAY:
+    return "KIND_ARRAY";
+
+  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_CLASS:
+    return "KIND_CLASS";
+
+  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_CLASSLOADER:
+    return "KIND_CLASSLOADER";
+
+  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_DEXCACHE:
+    return "KIND_DEXCACHE";
+
+  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_SOFT_REFERENCE:
+    return "KIND_SOFT_REFERENCE";
+
+  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_WEAK_REFERENCE:
+    return "KIND_WEAK_REFERENCE";
+
+  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_FINALIZER_REFERENCE:
+    return "KIND_FINALIZER_REFERENCE";
+
+  case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_PHANTOM_REFERENCE:
+    return "KIND_PHANTOM_REFERENCE";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_HeapGraphRoot {
+enum Type : int32_t {
+  ROOT_UNKNOWN = 0,
+  ROOT_JNI_GLOBAL = 1,
+  ROOT_JNI_LOCAL = 2,
+  ROOT_JAVA_FRAME = 3,
+  ROOT_NATIVE_STACK = 4,
+  ROOT_STICKY_CLASS = 5,
+  ROOT_THREAD_BLOCK = 6,
+  ROOT_MONITOR_USED = 7,
+  ROOT_THREAD_OBJECT = 8,
+  ROOT_INTERNED_STRING = 9,
+  ROOT_FINALIZING = 10,
+  ROOT_DEBUGGER = 11,
+  ROOT_REFERENCE_CLEANUP = 12,
+  ROOT_VM_INTERNAL = 13,
+  ROOT_JNI_MONITOR = 14,
+};
+} // namespace perfetto_pbzero_enum_HeapGraphRoot
+using HeapGraphRoot_Type = perfetto_pbzero_enum_HeapGraphRoot::Type;
+
+
+constexpr HeapGraphRoot_Type HeapGraphRoot_Type_MIN = HeapGraphRoot_Type::ROOT_UNKNOWN;
+constexpr HeapGraphRoot_Type HeapGraphRoot_Type_MAX = HeapGraphRoot_Type::ROOT_JNI_MONITOR;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* HeapGraphRoot_Type_Name(::perfetto::protos::pbzero::HeapGraphRoot_Type value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_UNKNOWN:
+    return "ROOT_UNKNOWN";
+
+  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_JNI_GLOBAL:
+    return "ROOT_JNI_GLOBAL";
+
+  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_JNI_LOCAL:
+    return "ROOT_JNI_LOCAL";
+
+  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_JAVA_FRAME:
+    return "ROOT_JAVA_FRAME";
+
+  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_NATIVE_STACK:
+    return "ROOT_NATIVE_STACK";
+
+  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_STICKY_CLASS:
+    return "ROOT_STICKY_CLASS";
+
+  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_THREAD_BLOCK:
+    return "ROOT_THREAD_BLOCK";
+
+  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_MONITOR_USED:
+    return "ROOT_MONITOR_USED";
+
+  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_THREAD_OBJECT:
+    return "ROOT_THREAD_OBJECT";
+
+  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_INTERNED_STRING:
+    return "ROOT_INTERNED_STRING";
+
+  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_FINALIZING:
+    return "ROOT_FINALIZING";
+
+  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_DEBUGGER:
+    return "ROOT_DEBUGGER";
+
+  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_REFERENCE_CLEANUP:
+    return "ROOT_REFERENCE_CLEANUP";
+
+  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_VM_INTERNAL:
+    return "ROOT_VM_INTERNAL";
+
+  case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_JNI_MONITOR:
+    return "ROOT_JNI_MONITOR";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class HeapGraph_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9> {
+ public:
+  HeapGraph_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HeapGraph_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HeapGraph_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  int32_t pid() const { return at<1>().as_int32(); }
+  bool has_objects() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> objects() const { return GetRepeated<::protozero::ConstBytes>(2); }
+  bool has_roots() const { return at<7>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> roots() const { return GetRepeated<::protozero::ConstBytes>(7); }
+  bool has_types() const { return at<9>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> types() const { return GetRepeated<::protozero::ConstBytes>(9); }
+  bool has_field_names() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> field_names() const { return GetRepeated<::protozero::ConstBytes>(4); }
+  bool has_location_names() const { return at<8>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> location_names() const { return GetRepeated<::protozero::ConstBytes>(8); }
+  bool has_continued() const { return at<5>().valid(); }
+  bool continued() const { return at<5>().as_bool(); }
+  bool has_index() const { return at<6>().valid(); }
+  uint64_t index() const { return at<6>().as_uint64(); }
+};
+
+class HeapGraph : public ::protozero::Message {
+ public:
+  using Decoder = HeapGraph_Decoder;
+  enum : int32_t {
+    kPidFieldNumber = 1,
+    kObjectsFieldNumber = 2,
+    kRootsFieldNumber = 7,
+    kTypesFieldNumber = 9,
+    kFieldNamesFieldNumber = 4,
+    kLocationNamesFieldNumber = 8,
+    kContinuedFieldNumber = 5,
+    kIndexFieldNumber = 6,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.HeapGraph"; }
+
+
+  using FieldMetadata_Pid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      HeapGraph>;
+
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Objects =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HeapGraphObject,
+      HeapGraph>;
+
+  static constexpr FieldMetadata_Objects kObjects{};
+  template <typename T = HeapGraphObject> T* add_objects() {
+    return BeginNestedMessage<T>(2);
+  }
+
+
+  using FieldMetadata_Roots =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HeapGraphRoot,
+      HeapGraph>;
+
+  static constexpr FieldMetadata_Roots kRoots{};
+  template <typename T = HeapGraphRoot> T* add_roots() {
+    return BeginNestedMessage<T>(7);
+  }
+
+
+  using FieldMetadata_Types =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      HeapGraphType,
+      HeapGraph>;
+
+  static constexpr FieldMetadata_Types kTypes{};
+  template <typename T = HeapGraphType> T* add_types() {
+    return BeginNestedMessage<T>(9);
+  }
+
+
+  using FieldMetadata_FieldNames =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      InternedString,
+      HeapGraph>;
+
+  static constexpr FieldMetadata_FieldNames kFieldNames{};
+  template <typename T = InternedString> T* add_field_names() {
+    return BeginNestedMessage<T>(4);
+  }
+
+
+  using FieldMetadata_LocationNames =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      InternedString,
+      HeapGraph>;
+
+  static constexpr FieldMetadata_LocationNames kLocationNames{};
+  template <typename T = InternedString> T* add_location_names() {
+    return BeginNestedMessage<T>(8);
+  }
+
+
+  using FieldMetadata_Continued =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      HeapGraph>;
+
+  static constexpr FieldMetadata_Continued kContinued{};
+  void set_continued(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_Continued::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Index =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HeapGraph>;
+
+  static constexpr FieldMetadata_Index kIndex{};
+  void set_index(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
 
-class LogMessageBody_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class HeapGraphObject_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10> {
  public:
-  LogMessageBody_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit LogMessageBody_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit LogMessageBody_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_iid() const { return at<1>().valid(); }
-  uint64_t iid() const { return at<1>().as_uint64(); }
-  bool has_body() const { return at<2>().valid(); }
-  ::protozero::ConstChars body() const { return at<2>().as_string(); }
+  HeapGraphObject_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HeapGraphObject_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HeapGraphObject_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  uint64_t id() const { return at<1>().as_uint64(); }
+  bool has_id_delta() const { return at<7>().valid(); }
+  uint64_t id_delta() const { return at<7>().as_uint64(); }
+  bool has_type_id() const { return at<2>().valid(); }
+  uint64_t type_id() const { return at<2>().as_uint64(); }
+  bool has_self_size() const { return at<3>().valid(); }
+  uint64_t self_size() const { return at<3>().as_uint64(); }
+  bool has_reference_field_id_base() const { return at<6>().valid(); }
+  uint64_t reference_field_id_base() const { return at<6>().as_uint64(); }
+  bool has_reference_field_id() const { return at<4>().valid(); }
+  ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> reference_field_id(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(4, parse_error_ptr); }
+  bool has_reference_object_id() const { return at<5>().valid(); }
+  ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> reference_object_id(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(5, parse_error_ptr); }
+  bool has_native_allocation_registry_size_field() const { return at<8>().valid(); }
+  int64_t native_allocation_registry_size_field() const { return at<8>().as_int64(); }
+  bool has_heap_type_delta() const { return at<9>().valid(); }
+  int32_t heap_type_delta() const { return at<9>().as_int32(); }
+  bool has_runtime_internal_object_id() const { return at<10>().valid(); }
+  ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> runtime_internal_object_id(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(10, parse_error_ptr); }
 };
 
-class LogMessageBody : public ::protozero::Message {
+class HeapGraphObject : public ::protozero::Message {
  public:
-  using Decoder = LogMessageBody_Decoder;
+  using Decoder = HeapGraphObject_Decoder;
   enum : int32_t {
-    kIidFieldNumber = 1,
-    kBodyFieldNumber = 2,
+    kIdFieldNumber = 1,
+    kIdDeltaFieldNumber = 7,
+    kTypeIdFieldNumber = 2,
+    kSelfSizeFieldNumber = 3,
+    kReferenceFieldIdBaseFieldNumber = 6,
+    kReferenceFieldIdFieldNumber = 4,
+    kReferenceObjectIdFieldNumber = 5,
+    kNativeAllocationRegistrySizeFieldFieldNumber = 8,
+    kHeapTypeDeltaFieldNumber = 9,
+    kRuntimeInternalObjectIdFieldNumber = 10,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.LogMessageBody"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.HeapGraphObject"; }
 
 
-  using FieldMetadata_Iid =
+  using HeapType = ::perfetto::protos::pbzero::HeapGraphObject_HeapType;
+  static inline const char* HeapType_Name(HeapType value) {
+    return ::perfetto::protos::pbzero::HeapGraphObject_HeapType_Name(value);
+  }
+  static inline const HeapType HEAP_TYPE_UNKNOWN = HeapType::HEAP_TYPE_UNKNOWN;
+  static inline const HeapType HEAP_TYPE_APP = HeapType::HEAP_TYPE_APP;
+  static inline const HeapType HEAP_TYPE_ZYGOTE = HeapType::HEAP_TYPE_ZYGOTE;
+  static inline const HeapType HEAP_TYPE_BOOT_IMAGE = HeapType::HEAP_TYPE_BOOT_IMAGE;
+
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      LogMessageBody>;
+      HeapGraphObject>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Iid kIid() { return {}; }
-  void set_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -148679,77 +170173,35 @@ class LogMessageBody : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Body =
+  using FieldMetadata_IdDelta =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      LogMessageBody>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HeapGraphObject>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Body kBody() { return {}; }
-  void set_body(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Body::kFieldId, data, size);
-  }
-  void set_body(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Body::kFieldId, chars.data, chars.size);
-  }
-  void set_body(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Body::kFieldId;
+  static constexpr FieldMetadata_IdDelta kIdDelta{};
+  void set_id_delta(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IdDelta::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class LogMessage_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  LogMessage_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit LogMessage_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit LogMessage_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_source_location_iid() const { return at<1>().valid(); }
-  uint64_t source_location_iid() const { return at<1>().as_uint64(); }
-  bool has_body_iid() const { return at<2>().valid(); }
-  uint64_t body_iid() const { return at<2>().as_uint64(); }
-};
-
-class LogMessage : public ::protozero::Message {
- public:
-  using Decoder = LogMessage_Decoder;
-  enum : int32_t {
-    kSourceLocationIidFieldNumber = 1,
-    kBodyIidFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.LogMessage"; }
 
-
-  using FieldMetadata_SourceLocationIid =
+  using FieldMetadata_TypeId =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      LogMessage>;
+      HeapGraphObject>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SourceLocationIid kSourceLocationIid() { return {}; }
-  void set_source_location_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SourceLocationIid::kFieldId;
+  static constexpr FieldMetadata_TypeId kTypeId{};
+  void set_type_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TypeId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -148757,246 +170209,230 @@ class LogMessage : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BodyIid =
+  using FieldMetadata_SelfSize =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      LogMessage>;
+      HeapGraphObject>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BodyIid kBodyIid() { return {}; }
-  void set_body_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BodyIid::kFieldId;
+  static constexpr FieldMetadata_SelfSize kSelfSize{};
+  void set_self_size(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SelfSize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/process_descriptor.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_PROCESS_DESCRIPTOR_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_PROCESS_DESCRIPTOR_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-namespace perfetto_pbzero_enum_ProcessDescriptor {
-enum ChromeProcessType : int32_t;
-}  // namespace perfetto_pbzero_enum_ProcessDescriptor
-using ProcessDescriptor_ChromeProcessType = perfetto_pbzero_enum_ProcessDescriptor::ChromeProcessType;
-
-namespace perfetto_pbzero_enum_ProcessDescriptor {
-enum ChromeProcessType : int32_t {
-  PROCESS_UNSPECIFIED = 0,
-  PROCESS_BROWSER = 1,
-  PROCESS_RENDERER = 2,
-  PROCESS_UTILITY = 3,
-  PROCESS_ZYGOTE = 4,
-  PROCESS_SANDBOX_HELPER = 5,
-  PROCESS_GPU = 6,
-  PROCESS_PPAPI_PLUGIN = 7,
-  PROCESS_PPAPI_BROKER = 8,
-};
-} // namespace perfetto_pbzero_enum_ProcessDescriptor
-using ProcessDescriptor_ChromeProcessType = perfetto_pbzero_enum_ProcessDescriptor::ChromeProcessType;
 
+  using FieldMetadata_ReferenceFieldIdBase =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HeapGraphObject>;
 
-constexpr ProcessDescriptor_ChromeProcessType ProcessDescriptor_ChromeProcessType_MIN = ProcessDescriptor_ChromeProcessType::PROCESS_UNSPECIFIED;
-constexpr ProcessDescriptor_ChromeProcessType ProcessDescriptor_ChromeProcessType_MAX = ProcessDescriptor_ChromeProcessType::PROCESS_PPAPI_BROKER;
+  static constexpr FieldMetadata_ReferenceFieldIdBase kReferenceFieldIdBase{};
+  void set_reference_field_id_base(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReferenceFieldIdBase::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
+  using FieldMetadata_ReferenceFieldId =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HeapGraphObject>;
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ProcessDescriptor_ChromeProcessType_Name(::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_UNSPECIFIED:
-    return "PROCESS_UNSPECIFIED";
+  static constexpr FieldMetadata_ReferenceFieldId kReferenceFieldId{};
+  void set_reference_field_id(const ::protozero::PackedVarInt& packed_buffer) {
+    AppendBytes(FieldMetadata_ReferenceFieldId::kFieldId, packed_buffer.data(),
+                packed_buffer.size());
+  }
 
-  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_BROWSER:
-    return "PROCESS_BROWSER";
+  using FieldMetadata_ReferenceObjectId =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HeapGraphObject>;
 
-  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_RENDERER:
-    return "PROCESS_RENDERER";
+  static constexpr FieldMetadata_ReferenceObjectId kReferenceObjectId{};
+  void set_reference_object_id(const ::protozero::PackedVarInt& packed_buffer) {
+    AppendBytes(FieldMetadata_ReferenceObjectId::kFieldId, packed_buffer.data(),
+                packed_buffer.size());
+  }
 
-  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_UTILITY:
-    return "PROCESS_UTILITY";
+  using FieldMetadata_NativeAllocationRegistrySizeField =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      HeapGraphObject>;
 
-  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_ZYGOTE:
-    return "PROCESS_ZYGOTE";
+  static constexpr FieldMetadata_NativeAllocationRegistrySizeField kNativeAllocationRegistrySizeField{};
+  void set_native_allocation_registry_size_field(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NativeAllocationRegistrySizeField::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
 
-  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_SANDBOX_HELPER:
-    return "PROCESS_SANDBOX_HELPER";
+  using FieldMetadata_HeapTypeDelta =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      HeapGraphObject_HeapType,
+      HeapGraphObject>;
 
-  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_GPU:
-    return "PROCESS_GPU";
+  static constexpr FieldMetadata_HeapTypeDelta kHeapTypeDelta{};
+  void set_heap_type_delta(HeapGraphObject_HeapType value) {
+    static constexpr uint32_t field_id = FieldMetadata_HeapTypeDelta::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
 
-  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_PPAPI_PLUGIN:
-    return "PROCESS_PPAPI_PLUGIN";
+  using FieldMetadata_RuntimeInternalObjectId =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HeapGraphObject>;
 
-  case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_PPAPI_BROKER:
-    return "PROCESS_PPAPI_BROKER";
+  static constexpr FieldMetadata_RuntimeInternalObjectId kRuntimeInternalObjectId{};
+  void set_runtime_internal_object_id(const ::protozero::PackedVarInt& packed_buffer) {
+    AppendBytes(FieldMetadata_RuntimeInternalObjectId::kFieldId, packed_buffer.data(),
+                packed_buffer.size());
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
+};
 
-class ProcessDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class HeapGraphType_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
  public:
-  ProcessDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ProcessDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ProcessDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pid() const { return at<1>().valid(); }
-  int32_t pid() const { return at<1>().as_int32(); }
-  bool has_cmdline() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> cmdline() const { return GetRepeated<::protozero::ConstChars>(2); }
-  bool has_process_name() const { return at<6>().valid(); }
-  ::protozero::ConstChars process_name() const { return at<6>().as_string(); }
-  bool has_process_priority() const { return at<5>().valid(); }
-  int32_t process_priority() const { return at<5>().as_int32(); }
-  bool has_start_timestamp_ns() const { return at<7>().valid(); }
-  int64_t start_timestamp_ns() const { return at<7>().as_int64(); }
-  bool has_chrome_process_type() const { return at<4>().valid(); }
-  int32_t chrome_process_type() const { return at<4>().as_int32(); }
-  bool has_legacy_sort_index() const { return at<3>().valid(); }
-  int32_t legacy_sort_index() const { return at<3>().as_int32(); }
-  bool has_process_labels() const { return at<8>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> process_labels() const { return GetRepeated<::protozero::ConstChars>(8); }
+  HeapGraphType_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HeapGraphType_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HeapGraphType_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  uint64_t id() const { return at<1>().as_uint64(); }
+  bool has_location_id() const { return at<2>().valid(); }
+  uint64_t location_id() const { return at<2>().as_uint64(); }
+  bool has_class_name() const { return at<3>().valid(); }
+  ::protozero::ConstChars class_name() const { return at<3>().as_string(); }
+  bool has_object_size() const { return at<4>().valid(); }
+  uint64_t object_size() const { return at<4>().as_uint64(); }
+  bool has_superclass_id() const { return at<5>().valid(); }
+  uint64_t superclass_id() const { return at<5>().as_uint64(); }
+  bool has_reference_field_id() const { return at<6>().valid(); }
+  ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> reference_field_id(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(6, parse_error_ptr); }
+  bool has_kind() const { return at<7>().valid(); }
+  int32_t kind() const { return at<7>().as_int32(); }
+  bool has_classloader_id() const { return at<8>().valid(); }
+  uint64_t classloader_id() const { return at<8>().as_uint64(); }
 };
 
-class ProcessDescriptor : public ::protozero::Message {
+class HeapGraphType : public ::protozero::Message {
  public:
-  using Decoder = ProcessDescriptor_Decoder;
+  using Decoder = HeapGraphType_Decoder;
   enum : int32_t {
-    kPidFieldNumber = 1,
-    kCmdlineFieldNumber = 2,
-    kProcessNameFieldNumber = 6,
-    kProcessPriorityFieldNumber = 5,
-    kStartTimestampNsFieldNumber = 7,
-    kChromeProcessTypeFieldNumber = 4,
-    kLegacySortIndexFieldNumber = 3,
-    kProcessLabelsFieldNumber = 8,
+    kIdFieldNumber = 1,
+    kLocationIdFieldNumber = 2,
+    kClassNameFieldNumber = 3,
+    kObjectSizeFieldNumber = 4,
+    kSuperclassIdFieldNumber = 5,
+    kReferenceFieldIdFieldNumber = 6,
+    kKindFieldNumber = 7,
+    kClassloaderIdFieldNumber = 8,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ProcessDescriptor"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.HeapGraphType"; }
 
 
-  using ChromeProcessType = ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType;
-  static inline const char* ChromeProcessType_Name(ChromeProcessType value) {
-    return ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType_Name(value);
+  using Kind = ::perfetto::protos::pbzero::HeapGraphType_Kind;
+  static inline const char* Kind_Name(Kind value) {
+    return ::perfetto::protos::pbzero::HeapGraphType_Kind_Name(value);
   }
-  static const ChromeProcessType PROCESS_UNSPECIFIED = ChromeProcessType::PROCESS_UNSPECIFIED;
-  static const ChromeProcessType PROCESS_BROWSER = ChromeProcessType::PROCESS_BROWSER;
-  static const ChromeProcessType PROCESS_RENDERER = ChromeProcessType::PROCESS_RENDERER;
-  static const ChromeProcessType PROCESS_UTILITY = ChromeProcessType::PROCESS_UTILITY;
-  static const ChromeProcessType PROCESS_ZYGOTE = ChromeProcessType::PROCESS_ZYGOTE;
-  static const ChromeProcessType PROCESS_SANDBOX_HELPER = ChromeProcessType::PROCESS_SANDBOX_HELPER;
-  static const ChromeProcessType PROCESS_GPU = ChromeProcessType::PROCESS_GPU;
-  static const ChromeProcessType PROCESS_PPAPI_PLUGIN = ChromeProcessType::PROCESS_PPAPI_PLUGIN;
-  static const ChromeProcessType PROCESS_PPAPI_BROKER = ChromeProcessType::PROCESS_PPAPI_BROKER;
+  static inline const Kind KIND_UNKNOWN = Kind::KIND_UNKNOWN;
+  static inline const Kind KIND_NORMAL = Kind::KIND_NORMAL;
+  static inline const Kind KIND_NOREFERENCES = Kind::KIND_NOREFERENCES;
+  static inline const Kind KIND_STRING = Kind::KIND_STRING;
+  static inline const Kind KIND_ARRAY = Kind::KIND_ARRAY;
+  static inline const Kind KIND_CLASS = Kind::KIND_CLASS;
+  static inline const Kind KIND_CLASSLOADER = Kind::KIND_CLASSLOADER;
+  static inline const Kind KIND_DEXCACHE = Kind::KIND_DEXCACHE;
+  static inline const Kind KIND_SOFT_REFERENCE = Kind::KIND_SOFT_REFERENCE;
+  static inline const Kind KIND_WEAK_REFERENCE = Kind::KIND_WEAK_REFERENCE;
+  static inline const Kind KIND_FINALIZER_REFERENCE = Kind::KIND_FINALIZER_REFERENCE;
+  static inline const Kind KIND_PHANTOM_REFERENCE = Kind::KIND_PHANTOM_REFERENCE;
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ProcessDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HeapGraphType>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Cmdline =
+  using FieldMetadata_LocationId =
     ::protozero::proto_utils::FieldMetadata<
       2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ProcessDescriptor>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HeapGraphType>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cmdline kCmdline() { return {}; }
-  void add_cmdline(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Cmdline::kFieldId, data, size);
-  }
-  void add_cmdline(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Cmdline::kFieldId, chars.data, chars.size);
-  }
-  void add_cmdline(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Cmdline::kFieldId;
+  static constexpr FieldMetadata_LocationId kLocationId{};
+  void set_location_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LocationId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ProcessName =
+  using FieldMetadata_ClassName =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      ProcessDescriptor>;
+      HeapGraphType>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessName kProcessName() { return {}; }
-  void set_process_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ProcessName::kFieldId, data, size);
+  static constexpr FieldMetadata_ClassName kClassName{};
+  void set_class_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ClassName::kFieldId, data, size);
   }
-  void set_process_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ProcessName::kFieldId, chars.data, chars.size);
+  void set_class_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ClassName::kFieldId, chars.data, chars.size);
   }
-  void set_process_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProcessName::kFieldId;
+  void set_class_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ClassName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -149004,202 +170440,163 @@ class ProcessDescriptor : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ProcessPriority =
+  using FieldMetadata_ObjectSize =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ProcessDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HeapGraphType>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessPriority kProcessPriority() { return {}; }
-  void set_process_priority(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProcessPriority::kFieldId;
+  static constexpr FieldMetadata_ObjectSize kObjectSize{};
+  void set_object_size(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ObjectSize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_StartTimestampNs =
+  using FieldMetadata_SuperclassId =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ProcessDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HeapGraphType>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StartTimestampNs kStartTimestampNs() { return {}; }
-  void set_start_timestamp_ns(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StartTimestampNs::kFieldId;
+  static constexpr FieldMetadata_SuperclassId kSuperclassId{};
+  void set_superclass_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SuperclassId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ChromeProcessType =
+  using FieldMetadata_ReferenceFieldId =
     ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType,
-      ProcessDescriptor>;
+      6,
+      ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HeapGraphType>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeProcessType kChromeProcessType() { return {}; }
-  void set_chrome_process_type(::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType value) {
-    static constexpr uint32_t field_id = FieldMetadata_ChromeProcessType::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_ReferenceFieldId kReferenceFieldId{};
+  void set_reference_field_id(const ::protozero::PackedVarInt& packed_buffer) {
+    AppendBytes(FieldMetadata_ReferenceFieldId::kFieldId, packed_buffer.data(),
+                packed_buffer.size());
   }
 
-  using FieldMetadata_LegacySortIndex =
+  using FieldMetadata_Kind =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ProcessDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      HeapGraphType_Kind,
+      HeapGraphType>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LegacySortIndex kLegacySortIndex() { return {}; }
-  void set_legacy_sort_index(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LegacySortIndex::kFieldId;
+  static constexpr FieldMetadata_Kind kKind{};
+  void set_kind(HeapGraphType_Kind value) {
+    static constexpr uint32_t field_id = FieldMetadata_Kind::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ProcessLabels =
+  using FieldMetadata_ClassloaderId =
     ::protozero::proto_utils::FieldMetadata<
       8,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ProcessDescriptor>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HeapGraphType>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessLabels kProcessLabels() { return {}; }
-  void add_process_labels(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ProcessLabels::kFieldId, data, size);
-  }
-  void add_process_labels(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ProcessLabels::kFieldId, chars.data, chars.size);
-  }
-  void add_process_labels(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ProcessLabels::kFieldId;
+  static constexpr FieldMetadata_ClassloaderId kClassloaderId{};
+  void set_classloader_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ClassloaderId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/range_of_interest.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_RANGE_OF_INTEREST_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_RANGE_OF_INTEREST_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-
-class TrackEventRangeOfInterest_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class HeapGraphRoot_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  TrackEventRangeOfInterest_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrackEventRangeOfInterest_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrackEventRangeOfInterest_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_start_us() const { return at<1>().valid(); }
-  int64_t start_us() const { return at<1>().as_int64(); }
+  HeapGraphRoot_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HeapGraphRoot_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HeapGraphRoot_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_object_ids() const { return at<1>().valid(); }
+  ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> object_ids(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(1, parse_error_ptr); }
+  bool has_root_type() const { return at<2>().valid(); }
+  int32_t root_type() const { return at<2>().as_int32(); }
 };
 
-class TrackEventRangeOfInterest : public ::protozero::Message {
+class HeapGraphRoot : public ::protozero::Message {
  public:
-  using Decoder = TrackEventRangeOfInterest_Decoder;
+  using Decoder = HeapGraphRoot_Decoder;
   enum : int32_t {
-    kStartUsFieldNumber = 1,
+    kObjectIdsFieldNumber = 1,
+    kRootTypeFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrackEventRangeOfInterest"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.HeapGraphRoot"; }
 
 
-  using FieldMetadata_StartUs =
+  using Type = ::perfetto::protos::pbzero::HeapGraphRoot_Type;
+  static inline const char* Type_Name(Type value) {
+    return ::perfetto::protos::pbzero::HeapGraphRoot_Type_Name(value);
+  }
+  static inline const Type ROOT_UNKNOWN = Type::ROOT_UNKNOWN;
+  static inline const Type ROOT_JNI_GLOBAL = Type::ROOT_JNI_GLOBAL;
+  static inline const Type ROOT_JNI_LOCAL = Type::ROOT_JNI_LOCAL;
+  static inline const Type ROOT_JAVA_FRAME = Type::ROOT_JAVA_FRAME;
+  static inline const Type ROOT_NATIVE_STACK = Type::ROOT_NATIVE_STACK;
+  static inline const Type ROOT_STICKY_CLASS = Type::ROOT_STICKY_CLASS;
+  static inline const Type ROOT_THREAD_BLOCK = Type::ROOT_THREAD_BLOCK;
+  static inline const Type ROOT_MONITOR_USED = Type::ROOT_MONITOR_USED;
+  static inline const Type ROOT_THREAD_OBJECT = Type::ROOT_THREAD_OBJECT;
+  static inline const Type ROOT_INTERNED_STRING = Type::ROOT_INTERNED_STRING;
+  static inline const Type ROOT_FINALIZING = Type::ROOT_FINALIZING;
+  static inline const Type ROOT_DEBUGGER = Type::ROOT_DEBUGGER;
+  static inline const Type ROOT_REFERENCE_CLEANUP = Type::ROOT_REFERENCE_CLEANUP;
+  static inline const Type ROOT_VM_INTERNAL = Type::ROOT_VM_INTERNAL;
+  static inline const Type ROOT_JNI_MONITOR = Type::ROOT_JNI_MONITOR;
+
+  using FieldMetadata_ObjectIds =
     ::protozero::proto_utils::FieldMetadata<
       1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HeapGraphRoot>;
+
+  static constexpr FieldMetadata_ObjectIds kObjectIds{};
+  void set_object_ids(const ::protozero::PackedVarInt& packed_buffer) {
+    AppendBytes(FieldMetadata_ObjectIds::kFieldId, packed_buffer.data(),
+                packed_buffer.size());
+  }
+
+  using FieldMetadata_RootType =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TrackEventRangeOfInterest>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      HeapGraphRoot_Type,
+      HeapGraphRoot>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StartUs kStartUs() { return {}; }
-  void set_start_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StartUs::kFieldId;
+  static constexpr FieldMetadata_RootType kRootType{};
+  void set_root_type(HeapGraphRoot_Type value) {
+    static constexpr uint32_t field_id = FieldMetadata_RootType::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 };
@@ -149208,11 +170605,11 @@ class TrackEventRangeOfInterest : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/source_location.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/profiling/profile_common.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_SOURCE_LOCATION_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_SOURCE_LOCATION_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_PROFILE_COMMON_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_PROFILE_COMMON_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -149226,33 +170623,35 @@ class TrackEventRangeOfInterest : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
+class AddressSymbols;
+class Line;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-class SourceLocation_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Callstack_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  SourceLocation_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SourceLocation_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SourceLocation_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Callstack_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Callstack_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Callstack_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_iid() const { return at<1>().valid(); }
   uint64_t iid() const { return at<1>().as_uint64(); }
-  bool has_file_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars file_name() const { return at<2>().as_string(); }
-  bool has_function_name() const { return at<3>().valid(); }
-  ::protozero::ConstChars function_name() const { return at<3>().as_string(); }
-  bool has_line_number() const { return at<4>().valid(); }
-  uint32_t line_number() const { return at<4>().as_uint32(); }
+  bool has_frame_ids() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint64_t> frame_ids() const { return GetRepeated<uint64_t>(2); }
 };
 
-class SourceLocation : public ::protozero::Message {
+class Callstack : public ::protozero::Message {
  public:
-  using Decoder = SourceLocation_Decoder;
+  using Decoder = Callstack_Decoder;
   enum : int32_t {
     kIidFieldNumber = 1,
-    kFileNameFieldNumber = 2,
-    kFunctionNameFieldNumber = 3,
-    kLineNumberFieldNumber = 4,
+    kFrameIdsFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SourceLocation"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Callstack"; }
 
 
   using FieldMetadata_Iid =
@@ -149261,16 +170660,9 @@ class SourceLocation : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      SourceLocation>;
+      Callstack>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Iid kIid() { return {}; }
+  static constexpr FieldMetadata_Iid kIid{};
   void set_iid(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -149280,116 +170672,56 @@ class SourceLocation : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FileName =
+  using FieldMetadata_FrameIds =
     ::protozero::proto_utils::FieldMetadata<
       2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SourceLocation>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FileName kFileName() { return {}; }
-  void set_file_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_FileName::kFieldId, data, size);
-  }
-  void set_file_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_FileName::kFieldId, chars.data, chars.size);
-  }
-  void set_file_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_FileName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_FunctionName =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SourceLocation>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FunctionName kFunctionName() { return {}; }
-  void set_function_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_FunctionName::kFieldId, data, size);
-  }
-  void set_function_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_FunctionName::kFieldId, chars.data, chars.size);
-  }
-  void set_function_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_FunctionName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_LineNumber =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SourceLocation>;
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Callstack>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LineNumber kLineNumber() { return {}; }
-  void set_line_number(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LineNumber::kFieldId;
+  static constexpr FieldMetadata_FrameIds kFrameIds{};
+  void add_frame_ids(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FrameIds::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class UnsymbolizedSourceLocation_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Frame_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  UnsymbolizedSourceLocation_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit UnsymbolizedSourceLocation_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit UnsymbolizedSourceLocation_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  Frame_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Frame_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Frame_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
   bool has_iid() const { return at<1>().valid(); }
   uint64_t iid() const { return at<1>().as_uint64(); }
-  bool has_mapping_id() const { return at<2>().valid(); }
-  uint64_t mapping_id() const { return at<2>().as_uint64(); }
-  bool has_rel_pc() const { return at<3>().valid(); }
-  uint64_t rel_pc() const { return at<3>().as_uint64(); }
+  bool has_function_name_id() const { return at<2>().valid(); }
+  uint64_t function_name_id() const { return at<2>().as_uint64(); }
+  bool has_mapping_id() const { return at<3>().valid(); }
+  uint64_t mapping_id() const { return at<3>().as_uint64(); }
+  bool has_rel_pc() const { return at<4>().valid(); }
+  uint64_t rel_pc() const { return at<4>().as_uint64(); }
+  bool has_source_path_iid() const { return at<5>().valid(); }
+  uint64_t source_path_iid() const { return at<5>().as_uint64(); }
+  bool has_line_number() const { return at<6>().valid(); }
+  uint32_t line_number() const { return at<6>().as_uint32(); }
 };
 
-class UnsymbolizedSourceLocation : public ::protozero::Message {
+class Frame : public ::protozero::Message {
  public:
-  using Decoder = UnsymbolizedSourceLocation_Decoder;
+  using Decoder = Frame_Decoder;
   enum : int32_t {
     kIidFieldNumber = 1,
-    kMappingIdFieldNumber = 2,
-    kRelPcFieldNumber = 3,
+    kFunctionNameIdFieldNumber = 2,
+    kMappingIdFieldNumber = 3,
+    kRelPcFieldNumber = 4,
+    kSourcePathIidFieldNumber = 5,
+    kLineNumberFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.UnsymbolizedSourceLocation"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Frame"; }
 
 
   using FieldMetadata_Iid =
@@ -149398,16 +170730,9 @@ class UnsymbolizedSourceLocation : public ::protozero::Message {
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      UnsymbolizedSourceLocation>;
+      Frame>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Iid kIid() { return {}; }
+  static constexpr FieldMetadata_Iid kIid{};
   void set_iid(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -149417,22 +170742,33 @@ class UnsymbolizedSourceLocation : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_MappingId =
+  using FieldMetadata_FunctionNameId =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      UnsymbolizedSourceLocation>;
+      Frame>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MappingId kMappingId() { return {}; }
+  static constexpr FieldMetadata_FunctionNameId kFunctionNameId{};
+  void set_function_name_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FunctionNameId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_MappingId =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Frame>;
+
+  static constexpr FieldMetadata_MappingId kMappingId{};
   void set_mapping_id(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_MappingId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -149444,20 +170780,13 @@ class UnsymbolizedSourceLocation : public ::protozero::Message {
 
   using FieldMetadata_RelPc =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      UnsymbolizedSourceLocation>;
+      Frame>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RelPc kRelPc() { return {}; }
+  static constexpr FieldMetadata_RelPc kRelPc{};
   void set_rel_pc(uint64_t value) {
     static constexpr uint32_t field_id = FieldMetadata_RelPc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
@@ -149466,528 +170795,347 @@ class UnsymbolizedSourceLocation : public ::protozero::Message {
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/task_execution.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TASK_EXECUTION_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TASK_EXECUTION_PROTO_H_
 
-#include <stddef.h>
-#include <stdint.h>
+  using FieldMetadata_SourcePathIid =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Frame>;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  static constexpr FieldMetadata_SourcePathIid kSourcePathIid{};
+  void set_source_path_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SourcePathIid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  using FieldMetadata_LineNumber =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Frame>;
 
+  static constexpr FieldMetadata_LineNumber kLineNumber{};
+  void set_line_number(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LineNumber::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
 
-class TaskExecution_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class Mapping_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
  public:
-  TaskExecution_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TaskExecution_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TaskExecution_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_posted_from_iid() const { return at<1>().valid(); }
-  uint64_t posted_from_iid() const { return at<1>().as_uint64(); }
+  Mapping_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Mapping_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Mapping_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_iid() const { return at<1>().valid(); }
+  uint64_t iid() const { return at<1>().as_uint64(); }
+  bool has_build_id() const { return at<2>().valid(); }
+  uint64_t build_id() const { return at<2>().as_uint64(); }
+  bool has_exact_offset() const { return at<8>().valid(); }
+  uint64_t exact_offset() const { return at<8>().as_uint64(); }
+  bool has_start_offset() const { return at<3>().valid(); }
+  uint64_t start_offset() const { return at<3>().as_uint64(); }
+  bool has_start() const { return at<4>().valid(); }
+  uint64_t start() const { return at<4>().as_uint64(); }
+  bool has_end() const { return at<5>().valid(); }
+  uint64_t end() const { return at<5>().as_uint64(); }
+  bool has_load_bias() const { return at<6>().valid(); }
+  uint64_t load_bias() const { return at<6>().as_uint64(); }
+  bool has_path_string_ids() const { return at<7>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint64_t> path_string_ids() const { return GetRepeated<uint64_t>(7); }
 };
 
-class TaskExecution : public ::protozero::Message {
+class Mapping : public ::protozero::Message {
  public:
-  using Decoder = TaskExecution_Decoder;
+  using Decoder = Mapping_Decoder;
   enum : int32_t {
-    kPostedFromIidFieldNumber = 1,
+    kIidFieldNumber = 1,
+    kBuildIdFieldNumber = 2,
+    kExactOffsetFieldNumber = 8,
+    kStartOffsetFieldNumber = 3,
+    kStartFieldNumber = 4,
+    kEndFieldNumber = 5,
+    kLoadBiasFieldNumber = 6,
+    kPathStringIdsFieldNumber = 7,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TaskExecution"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.Mapping"; }
 
 
-  using FieldMetadata_PostedFromIid =
+  using FieldMetadata_Iid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TaskExecution>;
+      Mapping>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PostedFromIid kPostedFromIid() { return {}; }
-  void set_posted_from_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PostedFromIid::kFieldId;
+  static constexpr FieldMetadata_Iid kIid{};
+  void set_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/thread_descriptor.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_THREAD_DESCRIPTOR_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_THREAD_DESCRIPTOR_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-namespace perfetto_pbzero_enum_ThreadDescriptor {
-enum ChromeThreadType : int32_t;
-}  // namespace perfetto_pbzero_enum_ThreadDescriptor
-using ThreadDescriptor_ChromeThreadType = perfetto_pbzero_enum_ThreadDescriptor::ChromeThreadType;
-
-namespace perfetto_pbzero_enum_ThreadDescriptor {
-enum ChromeThreadType : int32_t {
-  CHROME_THREAD_UNSPECIFIED = 0,
-  CHROME_THREAD_MAIN = 1,
-  CHROME_THREAD_IO = 2,
-  CHROME_THREAD_POOL_BG_WORKER = 3,
-  CHROME_THREAD_POOL_FG_WORKER = 4,
-  CHROME_THREAD_POOL_FB_BLOCKING = 5,
-  CHROME_THREAD_POOL_BG_BLOCKING = 6,
-  CHROME_THREAD_POOL_SERVICE = 7,
-  CHROME_THREAD_COMPOSITOR = 8,
-  CHROME_THREAD_VIZ_COMPOSITOR = 9,
-  CHROME_THREAD_COMPOSITOR_WORKER = 10,
-  CHROME_THREAD_SERVICE_WORKER = 11,
-  CHROME_THREAD_MEMORY_INFRA = 50,
-  CHROME_THREAD_SAMPLING_PROFILER = 51,
-};
-} // namespace perfetto_pbzero_enum_ThreadDescriptor
-using ThreadDescriptor_ChromeThreadType = perfetto_pbzero_enum_ThreadDescriptor::ChromeThreadType;
-
-
-constexpr ThreadDescriptor_ChromeThreadType ThreadDescriptor_ChromeThreadType_MIN = ThreadDescriptor_ChromeThreadType::CHROME_THREAD_UNSPECIFIED;
-constexpr ThreadDescriptor_ChromeThreadType ThreadDescriptor_ChromeThreadType_MAX = ThreadDescriptor_ChromeThreadType::CHROME_THREAD_SAMPLING_PROFILER;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* ThreadDescriptor_ChromeThreadType_Name(::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_UNSPECIFIED:
-    return "CHROME_THREAD_UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_MAIN:
-    return "CHROME_THREAD_MAIN";
-
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_IO:
-    return "CHROME_THREAD_IO";
-
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_POOL_BG_WORKER:
-    return "CHROME_THREAD_POOL_BG_WORKER";
-
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_POOL_FG_WORKER:
-    return "CHROME_THREAD_POOL_FG_WORKER";
-
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_POOL_FB_BLOCKING:
-    return "CHROME_THREAD_POOL_FB_BLOCKING";
-
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_POOL_BG_BLOCKING:
-    return "CHROME_THREAD_POOL_BG_BLOCKING";
-
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_POOL_SERVICE:
-    return "CHROME_THREAD_POOL_SERVICE";
-
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_COMPOSITOR:
-    return "CHROME_THREAD_COMPOSITOR";
-
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_VIZ_COMPOSITOR:
-    return "CHROME_THREAD_VIZ_COMPOSITOR";
-
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_COMPOSITOR_WORKER:
-    return "CHROME_THREAD_COMPOSITOR_WORKER";
-
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_SERVICE_WORKER:
-    return "CHROME_THREAD_SERVICE_WORKER";
-
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_MEMORY_INFRA:
-    return "CHROME_THREAD_MEMORY_INFRA";
-
-  case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_SAMPLING_PROFILER:
-    return "CHROME_THREAD_SAMPLING_PROFILER";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-class ThreadDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  ThreadDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ThreadDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ThreadDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pid() const { return at<1>().valid(); }
-  int32_t pid() const { return at<1>().as_int32(); }
-  bool has_tid() const { return at<2>().valid(); }
-  int32_t tid() const { return at<2>().as_int32(); }
-  bool has_thread_name() const { return at<5>().valid(); }
-  ::protozero::ConstChars thread_name() const { return at<5>().as_string(); }
-  bool has_chrome_thread_type() const { return at<4>().valid(); }
-  int32_t chrome_thread_type() const { return at<4>().as_int32(); }
-  bool has_reference_timestamp_us() const { return at<6>().valid(); }
-  int64_t reference_timestamp_us() const { return at<6>().as_int64(); }
-  bool has_reference_thread_time_us() const { return at<7>().valid(); }
-  int64_t reference_thread_time_us() const { return at<7>().as_int64(); }
-  bool has_reference_thread_instruction_count() const { return at<8>().valid(); }
-  int64_t reference_thread_instruction_count() const { return at<8>().as_int64(); }
-  bool has_legacy_sort_index() const { return at<3>().valid(); }
-  int32_t legacy_sort_index() const { return at<3>().as_int32(); }
-};
-
-class ThreadDescriptor : public ::protozero::Message {
- public:
-  using Decoder = ThreadDescriptor_Decoder;
-  enum : int32_t {
-    kPidFieldNumber = 1,
-    kTidFieldNumber = 2,
-    kThreadNameFieldNumber = 5,
-    kChromeThreadTypeFieldNumber = 4,
-    kReferenceTimestampUsFieldNumber = 6,
-    kReferenceThreadTimeUsFieldNumber = 7,
-    kReferenceThreadInstructionCountFieldNumber = 8,
-    kLegacySortIndexFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ThreadDescriptor"; }
 
+  using FieldMetadata_BuildId =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Mapping>;
 
-  using ChromeThreadType = ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType;
-  static inline const char* ChromeThreadType_Name(ChromeThreadType value) {
-    return ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType_Name(value);
+  static constexpr FieldMetadata_BuildId kBuildId{};
+  void set_build_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BuildId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
-  static const ChromeThreadType CHROME_THREAD_UNSPECIFIED = ChromeThreadType::CHROME_THREAD_UNSPECIFIED;
-  static const ChromeThreadType CHROME_THREAD_MAIN = ChromeThreadType::CHROME_THREAD_MAIN;
-  static const ChromeThreadType CHROME_THREAD_IO = ChromeThreadType::CHROME_THREAD_IO;
-  static const ChromeThreadType CHROME_THREAD_POOL_BG_WORKER = ChromeThreadType::CHROME_THREAD_POOL_BG_WORKER;
-  static const ChromeThreadType CHROME_THREAD_POOL_FG_WORKER = ChromeThreadType::CHROME_THREAD_POOL_FG_WORKER;
-  static const ChromeThreadType CHROME_THREAD_POOL_FB_BLOCKING = ChromeThreadType::CHROME_THREAD_POOL_FB_BLOCKING;
-  static const ChromeThreadType CHROME_THREAD_POOL_BG_BLOCKING = ChromeThreadType::CHROME_THREAD_POOL_BG_BLOCKING;
-  static const ChromeThreadType CHROME_THREAD_POOL_SERVICE = ChromeThreadType::CHROME_THREAD_POOL_SERVICE;
-  static const ChromeThreadType CHROME_THREAD_COMPOSITOR = ChromeThreadType::CHROME_THREAD_COMPOSITOR;
-  static const ChromeThreadType CHROME_THREAD_VIZ_COMPOSITOR = ChromeThreadType::CHROME_THREAD_VIZ_COMPOSITOR;
-  static const ChromeThreadType CHROME_THREAD_COMPOSITOR_WORKER = ChromeThreadType::CHROME_THREAD_COMPOSITOR_WORKER;
-  static const ChromeThreadType CHROME_THREAD_SERVICE_WORKER = ChromeThreadType::CHROME_THREAD_SERVICE_WORKER;
-  static const ChromeThreadType CHROME_THREAD_MEMORY_INFRA = ChromeThreadType::CHROME_THREAD_MEMORY_INFRA;
-  static const ChromeThreadType CHROME_THREAD_SAMPLING_PROFILER = ChromeThreadType::CHROME_THREAD_SAMPLING_PROFILER;
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_ExactOffset =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ThreadDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Mapping>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_ExactOffset kExactOffset{};
+  void set_exact_offset(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ExactOffset::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Tid =
+  using FieldMetadata_StartOffset =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ThreadDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Mapping>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Tid kTid() { return {}; }
-  void set_tid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId;
+  static constexpr FieldMetadata_StartOffset kStartOffset{};
+  void set_start_offset(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StartOffset::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ThreadName =
+  using FieldMetadata_Start =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ThreadDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Mapping>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThreadName kThreadName() { return {}; }
-  void set_thread_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ThreadName::kFieldId, data, size);
-  }
-  void set_thread_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ThreadName::kFieldId, chars.data, chars.size);
-  }
-  void set_thread_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ThreadName::kFieldId;
+  static constexpr FieldMetadata_Start kStart{};
+  void set_start(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ChromeThreadType =
+  using FieldMetadata_End =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType,
-      ThreadDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Mapping>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeThreadType kChromeThreadType() { return {}; }
-  void set_chrome_thread_type(::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType value) {
-    static constexpr uint32_t field_id = FieldMetadata_ChromeThreadType::kFieldId;
+  static constexpr FieldMetadata_End kEnd{};
+  void set_end(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_End::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ReferenceTimestampUs =
+  using FieldMetadata_LoadBias =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ThreadDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Mapping>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReferenceTimestampUs kReferenceTimestampUs() { return {}; }
-  void set_reference_timestamp_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReferenceTimestampUs::kFieldId;
+  static constexpr FieldMetadata_LoadBias kLoadBias{};
+  void set_load_bias(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LoadBias::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ReferenceThreadTimeUs =
+  using FieldMetadata_PathStringIds =
     ::protozero::proto_utils::FieldMetadata<
       7,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ThreadDescriptor>;
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      Mapping>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReferenceThreadTimeUs kReferenceThreadTimeUs() { return {}; }
-  void set_reference_thread_time_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReferenceThreadTimeUs::kFieldId;
+  static constexpr FieldMetadata_PathStringIds kPathStringIds{};
+  void add_path_string_ids(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PathStringIds::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_ReferenceThreadInstructionCount =
+class ModuleSymbols_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  ModuleSymbols_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ModuleSymbols_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ModuleSymbols_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_path() const { return at<1>().valid(); }
+  ::protozero::ConstChars path() const { return at<1>().as_string(); }
+  bool has_build_id() const { return at<2>().valid(); }
+  ::protozero::ConstChars build_id() const { return at<2>().as_string(); }
+  bool has_address_symbols() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> address_symbols() const { return GetRepeated<::protozero::ConstBytes>(3); }
+};
+
+class ModuleSymbols : public ::protozero::Message {
+ public:
+  using Decoder = ModuleSymbols_Decoder;
+  enum : int32_t {
+    kPathFieldNumber = 1,
+    kBuildIdFieldNumber = 2,
+    kAddressSymbolsFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ModuleSymbols"; }
+
+
+  using FieldMetadata_Path =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ThreadDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ModuleSymbols>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReferenceThreadInstructionCount kReferenceThreadInstructionCount() { return {}; }
-  void set_reference_thread_instruction_count(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReferenceThreadInstructionCount::kFieldId;
+  static constexpr FieldMetadata_Path kPath{};
+  void set_path(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Path::kFieldId, data, size);
+  }
+  void set_path(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Path::kFieldId, chars.data, chars.size);
+  }
+  void set_path(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Path::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_LegacySortIndex =
+  using FieldMetadata_BuildId =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ThreadDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ModuleSymbols>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LegacySortIndex kLegacySortIndex() { return {}; }
-  void set_legacy_sort_index(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LegacySortIndex::kFieldId;
+  static constexpr FieldMetadata_BuildId kBuildId{};
+  void set_build_id(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_BuildId::kFieldId, data, size);
+  }
+  void set_build_id(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_BuildId::kFieldId, chars.data, chars.size);
+  }
+  void set_build_id(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_BuildId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/track_descriptor.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TRACK_DESCRIPTOR_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TRACK_DESCRIPTOR_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  using FieldMetadata_AddressSymbols =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AddressSymbols,
+      ModuleSymbols>;
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  static constexpr FieldMetadata_AddressSymbols kAddressSymbols{};
+  template <typename T = AddressSymbols> T* add_address_symbols() {
+    return BeginNestedMessage<T>(3);
+  }
 
-class ChromeProcessDescriptor;
-class ChromeThreadDescriptor;
-class CounterDescriptor;
-class ProcessDescriptor;
-class ThreadDescriptor;
+};
 
-class TrackDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class AddressSymbols_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  TrackDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrackDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrackDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_uuid() const { return at<1>().valid(); }
-  uint64_t uuid() const { return at<1>().as_uint64(); }
-  bool has_parent_uuid() const { return at<5>().valid(); }
-  uint64_t parent_uuid() const { return at<5>().as_uint64(); }
-  bool has_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars name() const { return at<2>().as_string(); }
-  bool has_process() const { return at<3>().valid(); }
-  ::protozero::ConstBytes process() const { return at<3>().as_bytes(); }
-  bool has_chrome_process() const { return at<6>().valid(); }
-  ::protozero::ConstBytes chrome_process() const { return at<6>().as_bytes(); }
-  bool has_thread() const { return at<4>().valid(); }
-  ::protozero::ConstBytes thread() const { return at<4>().as_bytes(); }
-  bool has_chrome_thread() const { return at<7>().valid(); }
-  ::protozero::ConstBytes chrome_thread() const { return at<7>().as_bytes(); }
-  bool has_counter() const { return at<8>().valid(); }
-  ::protozero::ConstBytes counter() const { return at<8>().as_bytes(); }
+  AddressSymbols_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AddressSymbols_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AddressSymbols_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_address() const { return at<1>().valid(); }
+  uint64_t address() const { return at<1>().as_uint64(); }
+  bool has_lines() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> lines() const { return GetRepeated<::protozero::ConstBytes>(2); }
 };
 
-class TrackDescriptor : public ::protozero::Message {
+class AddressSymbols : public ::protozero::Message {
  public:
-  using Decoder = TrackDescriptor_Decoder;
+  using Decoder = AddressSymbols_Decoder;
   enum : int32_t {
-    kUuidFieldNumber = 1,
-    kParentUuidFieldNumber = 5,
-    kNameFieldNumber = 2,
-    kProcessFieldNumber = 3,
-    kChromeProcessFieldNumber = 6,
-    kThreadFieldNumber = 4,
-    kChromeThreadFieldNumber = 7,
-    kCounterFieldNumber = 8,
+    kAddressFieldNumber = 1,
+    kLinesFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrackDescriptor"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.AddressSymbols"; }
 
 
-  using FieldMetadata_Uuid =
+  using FieldMetadata_Address =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TrackDescriptor>;
+      AddressSymbols>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Uuid kUuid() { return {}; }
-  void set_uuid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Uuid::kFieldId;
+  static constexpr FieldMetadata_Address kAddress{};
+  void set_address(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Address::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -149995,55 +171143,86 @@ class TrackDescriptor : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ParentUuid =
+  using FieldMetadata_Lines =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      Line,
+      AddressSymbols>;
+
+  static constexpr FieldMetadata_Lines kLines{};
+  template <typename T = Line> T* add_lines() {
+    return BeginNestedMessage<T>(2);
+  }
+
+};
+
+class Line_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  Line_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Line_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Line_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_function_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars function_name() const { return at<1>().as_string(); }
+  bool has_source_file_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars source_file_name() const { return at<2>().as_string(); }
+  bool has_line_number() const { return at<3>().valid(); }
+  uint32_t line_number() const { return at<3>().as_uint32(); }
+};
+
+class Line : public ::protozero::Message {
+ public:
+  using Decoder = Line_Decoder;
+  enum : int32_t {
+    kFunctionNameFieldNumber = 1,
+    kSourceFileNameFieldNumber = 2,
+    kLineNumberFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Line"; }
+
+
+  using FieldMetadata_FunctionName =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TrackDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      Line>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ParentUuid kParentUuid() { return {}; }
-  void set_parent_uuid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ParentUuid::kFieldId;
+  static constexpr FieldMetadata_FunctionName kFunctionName{};
+  void set_function_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_FunctionName::kFieldId, data, size);
+  }
+  void set_function_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_FunctionName::kFieldId, chars.data, chars.size);
+  }
+  void set_function_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_FunctionName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Name =
+  using FieldMetadata_SourceFileName =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      TrackDescriptor>;
+      Line>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  static constexpr FieldMetadata_SourceFileName kSourceFileName{};
+  void set_source_file_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_SourceFileName::kFieldId, data, size);
   }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  void set_source_file_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_SourceFileName::kFieldId, chars.data, chars.size);
   }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  void set_source_file_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_SourceFileName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -150051,121 +171230,98 @@ class TrackDescriptor : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Process =
+  using FieldMetadata_LineNumber =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ProcessDescriptor,
-      TrackDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      Line>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Process kProcess() { return {}; }
-  template <typename T = ProcessDescriptor> T* set_process() {
-    return BeginNestedMessage<T>(3);
+  static constexpr FieldMetadata_LineNumber kLineNumber{};
+  void set_line_number(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LineNumber::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
+};
 
+class InternedString_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  InternedString_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit InternedString_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit InternedString_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_iid() const { return at<1>().valid(); }
+  uint64_t iid() const { return at<1>().as_uint64(); }
+  bool has_str() const { return at<2>().valid(); }
+  ::protozero::ConstBytes str() const { return at<2>().as_bytes(); }
+};
 
-  using FieldMetadata_ChromeProcess =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeProcessDescriptor,
-      TrackDescriptor>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeProcess kChromeProcess() { return {}; }
-  template <typename T = ChromeProcessDescriptor> T* set_chrome_process() {
-    return BeginNestedMessage<T>(6);
-  }
+class InternedString : public ::protozero::Message {
+ public:
+  using Decoder = InternedString_Decoder;
+  enum : int32_t {
+    kIidFieldNumber = 1,
+    kStrFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.InternedString"; }
 
 
-  using FieldMetadata_Thread =
+  using FieldMetadata_Iid =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ThreadDescriptor,
-      TrackDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      InternedString>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Thread kThread() { return {}; }
-  template <typename T = ThreadDescriptor> T* set_thread() {
-    return BeginNestedMessage<T>(4);
+  static constexpr FieldMetadata_Iid kIid{};
+  void set_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_ChromeThread =
+  using FieldMetadata_Str =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeThreadDescriptor,
-      TrackDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      InternedString>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeThread kChromeThread() { return {}; }
-  template <typename T = ChromeThreadDescriptor> T* set_chrome_thread() {
-    return BeginNestedMessage<T>(7);
+  static constexpr FieldMetadata_Str kStr{};
+  void set_str(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_Str::kFieldId, data, size);
   }
-
-
-  using FieldMetadata_Counter =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      CounterDescriptor,
-      TrackDescriptor>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Counter kCounter() { return {}; }
-  template <typename T = CounterDescriptor> T* set_counter() {
-    return BeginNestedMessage<T>(8);
+  void set_str(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_Str::kFieldId, bytes.data, bytes.size);
+  }
+  void set_str(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Str::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
   }
-
 };
 
 } // Namespace.
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/track_event.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/profiling/profile_packet.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TRACK_EVENT_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TRACK_EVENT_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_PROFILE_PACKET_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_PROFILE_PACKET_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -150179,624 +171335,493 @@ class TrackDescriptor : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
+class Callstack;
+class FollowerEvent;
+class Frame;
+class InternedString;
+class Mapping;
+class PerfEvents_Timebase;
+class PerfSample_ProducerEvent;
+class ProfilePacket_HeapSample;
+class ProfilePacket_Histogram;
+class ProfilePacket_Histogram_Bucket;
+class ProfilePacket_ProcessHeapSamples;
+class ProfilePacket_ProcessStats;
+namespace perfetto_pbzero_enum_PerfSample_ProducerEvent {
+enum DataSourceStopReason : int32_t;
+}  // namespace perfetto_pbzero_enum_PerfSample_ProducerEvent
+using PerfSample_ProducerEvent_DataSourceStopReason = perfetto_pbzero_enum_PerfSample_ProducerEvent::DataSourceStopReason;
+namespace perfetto_pbzero_enum_PerfSample {
+enum SampleSkipReason : int32_t;
+}  // namespace perfetto_pbzero_enum_PerfSample
+using PerfSample_SampleSkipReason = perfetto_pbzero_enum_PerfSample::SampleSkipReason;
+namespace perfetto_pbzero_enum_ProfilePacket_ProcessHeapSamples {
+enum ClientError : int32_t;
+}  // namespace perfetto_pbzero_enum_ProfilePacket_ProcessHeapSamples
+using ProfilePacket_ProcessHeapSamples_ClientError = perfetto_pbzero_enum_ProfilePacket_ProcessHeapSamples::ClientError;
+namespace perfetto_pbzero_enum_Profiling {
+enum CpuMode : int32_t;
+}  // namespace perfetto_pbzero_enum_Profiling
+using Profiling_CpuMode = perfetto_pbzero_enum_Profiling::CpuMode;
+namespace perfetto_pbzero_enum_Profiling {
+enum StackUnwindError : int32_t;
+}  // namespace perfetto_pbzero_enum_Profiling
+using Profiling_StackUnwindError = perfetto_pbzero_enum_Profiling::StackUnwindError;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-class ChromeActiveProcesses;
-class ChromeApplicationStateInfo;
-class ChromeCompositorSchedulerState;
-class ChromeContentSettingsEventInfo;
-class ChromeFrameReporter;
-class ChromeHistogramSample;
-class ChromeKeyedService;
-class ChromeLatencyInfo;
-class ChromeLegacyIpc;
-class ChromeMessagePump;
-class ChromeMojoEventInfo;
-class ChromeRendererSchedulerState;
-class ChromeUserEvent;
-class ChromeWindowHandleEventInfo;
-class DebugAnnotation;
-class LogMessage;
-class SourceLocation;
-class TaskExecution;
-class TrackEvent_LegacyEvent;
-namespace perfetto_pbzero_enum_TrackEvent_LegacyEvent {
-enum FlowDirection : int32_t;
-}  // namespace perfetto_pbzero_enum_TrackEvent_LegacyEvent
-using TrackEvent_LegacyEvent_FlowDirection = perfetto_pbzero_enum_TrackEvent_LegacyEvent::FlowDirection;
-namespace perfetto_pbzero_enum_TrackEvent_LegacyEvent {
-enum InstantEventScope : int32_t;
-}  // namespace perfetto_pbzero_enum_TrackEvent_LegacyEvent
-using TrackEvent_LegacyEvent_InstantEventScope = perfetto_pbzero_enum_TrackEvent_LegacyEvent::InstantEventScope;
-namespace perfetto_pbzero_enum_TrackEvent {
-enum Type : int32_t;
-}  // namespace perfetto_pbzero_enum_TrackEvent
-using TrackEvent_Type = perfetto_pbzero_enum_TrackEvent::Type;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-namespace perfetto_pbzero_enum_TrackEvent {
-enum Type : int32_t {
-  TYPE_UNSPECIFIED = 0,
-  TYPE_SLICE_BEGIN = 1,
-  TYPE_SLICE_END = 2,
-  TYPE_INSTANT = 3,
-  TYPE_COUNTER = 4,
+namespace perfetto_pbzero_enum_PerfSample {
+enum SampleSkipReason : int32_t {
+  PROFILER_SKIP_UNKNOWN = 0,
+  PROFILER_SKIP_READ_STAGE = 1,
+  PROFILER_SKIP_UNWIND_STAGE = 2,
+  PROFILER_SKIP_UNWIND_ENQUEUE = 3,
+  PROFILER_SKIP_NOT_IN_SCOPE = 4,
 };
-} // namespace perfetto_pbzero_enum_TrackEvent
-using TrackEvent_Type = perfetto_pbzero_enum_TrackEvent::Type;
+} // namespace perfetto_pbzero_enum_PerfSample
+using PerfSample_SampleSkipReason = perfetto_pbzero_enum_PerfSample::SampleSkipReason;
 
 
-constexpr TrackEvent_Type TrackEvent_Type_MIN = TrackEvent_Type::TYPE_UNSPECIFIED;
-constexpr TrackEvent_Type TrackEvent_Type_MAX = TrackEvent_Type::TYPE_COUNTER;
+constexpr PerfSample_SampleSkipReason PerfSample_SampleSkipReason_MIN = PerfSample_SampleSkipReason::PROFILER_SKIP_UNKNOWN;
+constexpr PerfSample_SampleSkipReason PerfSample_SampleSkipReason_MAX = PerfSample_SampleSkipReason::PROFILER_SKIP_NOT_IN_SCOPE;
 
 
 PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* TrackEvent_Type_Name(::perfetto::protos::pbzero::TrackEvent_Type value) {
+const char* PerfSample_SampleSkipReason_Name(::perfetto::protos::pbzero::PerfSample_SampleSkipReason value) {
   switch (value) {
-  case ::perfetto::protos::pbzero::TrackEvent_Type::TYPE_UNSPECIFIED:
-    return "TYPE_UNSPECIFIED";
+  case ::perfetto::protos::pbzero::PerfSample_SampleSkipReason::PROFILER_SKIP_UNKNOWN:
+    return "PROFILER_SKIP_UNKNOWN";
 
-  case ::perfetto::protos::pbzero::TrackEvent_Type::TYPE_SLICE_BEGIN:
-    return "TYPE_SLICE_BEGIN";
+  case ::perfetto::protos::pbzero::PerfSample_SampleSkipReason::PROFILER_SKIP_READ_STAGE:
+    return "PROFILER_SKIP_READ_STAGE";
 
-  case ::perfetto::protos::pbzero::TrackEvent_Type::TYPE_SLICE_END:
-    return "TYPE_SLICE_END";
+  case ::perfetto::protos::pbzero::PerfSample_SampleSkipReason::PROFILER_SKIP_UNWIND_STAGE:
+    return "PROFILER_SKIP_UNWIND_STAGE";
 
-  case ::perfetto::protos::pbzero::TrackEvent_Type::TYPE_INSTANT:
-    return "TYPE_INSTANT";
+  case ::perfetto::protos::pbzero::PerfSample_SampleSkipReason::PROFILER_SKIP_UNWIND_ENQUEUE:
+    return "PROFILER_SKIP_UNWIND_ENQUEUE";
 
-  case ::perfetto::protos::pbzero::TrackEvent_Type::TYPE_COUNTER:
-    return "TYPE_COUNTER";
+  case ::perfetto::protos::pbzero::PerfSample_SampleSkipReason::PROFILER_SKIP_NOT_IN_SCOPE:
+    return "PROFILER_SKIP_NOT_IN_SCOPE";
   }
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-namespace perfetto_pbzero_enum_TrackEvent_LegacyEvent {
-enum FlowDirection : int32_t {
-  FLOW_UNSPECIFIED = 0,
-  FLOW_IN = 1,
-  FLOW_OUT = 2,
-  FLOW_INOUT = 3,
+namespace perfetto_pbzero_enum_PerfSample_ProducerEvent {
+enum DataSourceStopReason : int32_t {
+  PROFILER_STOP_UNKNOWN = 0,
+  PROFILER_STOP_GUARDRAIL = 1,
 };
-} // namespace perfetto_pbzero_enum_TrackEvent_LegacyEvent
-using TrackEvent_LegacyEvent_FlowDirection = perfetto_pbzero_enum_TrackEvent_LegacyEvent::FlowDirection;
+} // namespace perfetto_pbzero_enum_PerfSample_ProducerEvent
+using PerfSample_ProducerEvent_DataSourceStopReason = perfetto_pbzero_enum_PerfSample_ProducerEvent::DataSourceStopReason;
 
 
-constexpr TrackEvent_LegacyEvent_FlowDirection TrackEvent_LegacyEvent_FlowDirection_MIN = TrackEvent_LegacyEvent_FlowDirection::FLOW_UNSPECIFIED;
-constexpr TrackEvent_LegacyEvent_FlowDirection TrackEvent_LegacyEvent_FlowDirection_MAX = TrackEvent_LegacyEvent_FlowDirection::FLOW_INOUT;
+constexpr PerfSample_ProducerEvent_DataSourceStopReason PerfSample_ProducerEvent_DataSourceStopReason_MIN = PerfSample_ProducerEvent_DataSourceStopReason::PROFILER_STOP_UNKNOWN;
+constexpr PerfSample_ProducerEvent_DataSourceStopReason PerfSample_ProducerEvent_DataSourceStopReason_MAX = PerfSample_ProducerEvent_DataSourceStopReason::PROFILER_STOP_GUARDRAIL;
 
 
 PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* TrackEvent_LegacyEvent_FlowDirection_Name(::perfetto::protos::pbzero::TrackEvent_LegacyEvent_FlowDirection value) {
+const char* PerfSample_ProducerEvent_DataSourceStopReason_Name(::perfetto::protos::pbzero::PerfSample_ProducerEvent_DataSourceStopReason value) {
   switch (value) {
-  case ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_FlowDirection::FLOW_UNSPECIFIED:
-    return "FLOW_UNSPECIFIED";
+  case ::perfetto::protos::pbzero::PerfSample_ProducerEvent_DataSourceStopReason::PROFILER_STOP_UNKNOWN:
+    return "PROFILER_STOP_UNKNOWN";
 
-  case ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_FlowDirection::FLOW_IN:
-    return "FLOW_IN";
+  case ::perfetto::protos::pbzero::PerfSample_ProducerEvent_DataSourceStopReason::PROFILER_STOP_GUARDRAIL:
+    return "PROFILER_STOP_GUARDRAIL";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
-  case ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_FlowDirection::FLOW_OUT:
-    return "FLOW_OUT";
+namespace perfetto_pbzero_enum_Profiling {
+enum CpuMode : int32_t {
+  MODE_UNKNOWN = 0,
+  MODE_KERNEL = 1,
+  MODE_USER = 2,
+  MODE_HYPERVISOR = 3,
+  MODE_GUEST_KERNEL = 4,
+  MODE_GUEST_USER = 5,
+};
+} // namespace perfetto_pbzero_enum_Profiling
+using Profiling_CpuMode = perfetto_pbzero_enum_Profiling::CpuMode;
 
-  case ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_FlowDirection::FLOW_INOUT:
-    return "FLOW_INOUT";
+
+constexpr Profiling_CpuMode Profiling_CpuMode_MIN = Profiling_CpuMode::MODE_UNKNOWN;
+constexpr Profiling_CpuMode Profiling_CpuMode_MAX = Profiling_CpuMode::MODE_GUEST_USER;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* Profiling_CpuMode_Name(::perfetto::protos::pbzero::Profiling_CpuMode value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::Profiling_CpuMode::MODE_UNKNOWN:
+    return "MODE_UNKNOWN";
+
+  case ::perfetto::protos::pbzero::Profiling_CpuMode::MODE_KERNEL:
+    return "MODE_KERNEL";
+
+  case ::perfetto::protos::pbzero::Profiling_CpuMode::MODE_USER:
+    return "MODE_USER";
+
+  case ::perfetto::protos::pbzero::Profiling_CpuMode::MODE_HYPERVISOR:
+    return "MODE_HYPERVISOR";
+
+  case ::perfetto::protos::pbzero::Profiling_CpuMode::MODE_GUEST_KERNEL:
+    return "MODE_GUEST_KERNEL";
+
+  case ::perfetto::protos::pbzero::Profiling_CpuMode::MODE_GUEST_USER:
+    return "MODE_GUEST_USER";
   }
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-namespace perfetto_pbzero_enum_TrackEvent_LegacyEvent {
-enum InstantEventScope : int32_t {
-  SCOPE_UNSPECIFIED = 0,
-  SCOPE_GLOBAL = 1,
-  SCOPE_PROCESS = 2,
-  SCOPE_THREAD = 3,
+namespace perfetto_pbzero_enum_Profiling {
+enum StackUnwindError : int32_t {
+  UNWIND_ERROR_UNKNOWN = 0,
+  UNWIND_ERROR_NONE = 1,
+  UNWIND_ERROR_MEMORY_INVALID = 2,
+  UNWIND_ERROR_UNWIND_INFO = 3,
+  UNWIND_ERROR_UNSUPPORTED = 4,
+  UNWIND_ERROR_INVALID_MAP = 5,
+  UNWIND_ERROR_MAX_FRAMES_EXCEEDED = 6,
+  UNWIND_ERROR_REPEATED_FRAME = 7,
+  UNWIND_ERROR_INVALID_ELF = 8,
+  UNWIND_ERROR_SYSTEM_CALL = 9,
+  UNWIND_ERROR_THREAD_TIMEOUT = 10,
+  UNWIND_ERROR_THREAD_DOES_NOT_EXIST = 11,
+  UNWIND_ERROR_BAD_ARCH = 12,
+  UNWIND_ERROR_MAPS_PARSE = 13,
+  UNWIND_ERROR_INVALID_PARAMETER = 14,
+  UNWIND_ERROR_PTRACE_CALL = 15,
 };
-} // namespace perfetto_pbzero_enum_TrackEvent_LegacyEvent
-using TrackEvent_LegacyEvent_InstantEventScope = perfetto_pbzero_enum_TrackEvent_LegacyEvent::InstantEventScope;
+} // namespace perfetto_pbzero_enum_Profiling
+using Profiling_StackUnwindError = perfetto_pbzero_enum_Profiling::StackUnwindError;
 
 
-constexpr TrackEvent_LegacyEvent_InstantEventScope TrackEvent_LegacyEvent_InstantEventScope_MIN = TrackEvent_LegacyEvent_InstantEventScope::SCOPE_UNSPECIFIED;
-constexpr TrackEvent_LegacyEvent_InstantEventScope TrackEvent_LegacyEvent_InstantEventScope_MAX = TrackEvent_LegacyEvent_InstantEventScope::SCOPE_THREAD;
+constexpr Profiling_StackUnwindError Profiling_StackUnwindError_MIN = Profiling_StackUnwindError::UNWIND_ERROR_UNKNOWN;
+constexpr Profiling_StackUnwindError Profiling_StackUnwindError_MAX = Profiling_StackUnwindError::UNWIND_ERROR_PTRACE_CALL;
 
 
 PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* TrackEvent_LegacyEvent_InstantEventScope_Name(::perfetto::protos::pbzero::TrackEvent_LegacyEvent_InstantEventScope value) {
+const char* Profiling_StackUnwindError_Name(::perfetto::protos::pbzero::Profiling_StackUnwindError value) {
   switch (value) {
-  case ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_InstantEventScope::SCOPE_UNSPECIFIED:
-    return "SCOPE_UNSPECIFIED";
+  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_UNKNOWN:
+    return "UNWIND_ERROR_UNKNOWN";
 
-  case ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_InstantEventScope::SCOPE_GLOBAL:
-    return "SCOPE_GLOBAL";
+  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_NONE:
+    return "UNWIND_ERROR_NONE";
 
-  case ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_InstantEventScope::SCOPE_PROCESS:
-    return "SCOPE_PROCESS";
+  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_MEMORY_INVALID:
+    return "UNWIND_ERROR_MEMORY_INVALID";
 
-  case ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_InstantEventScope::SCOPE_THREAD:
-    return "SCOPE_THREAD";
+  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_UNWIND_INFO:
+    return "UNWIND_ERROR_UNWIND_INFO";
+
+  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_UNSUPPORTED:
+    return "UNWIND_ERROR_UNSUPPORTED";
+
+  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_INVALID_MAP:
+    return "UNWIND_ERROR_INVALID_MAP";
+
+  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_MAX_FRAMES_EXCEEDED:
+    return "UNWIND_ERROR_MAX_FRAMES_EXCEEDED";
+
+  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_REPEATED_FRAME:
+    return "UNWIND_ERROR_REPEATED_FRAME";
+
+  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_INVALID_ELF:
+    return "UNWIND_ERROR_INVALID_ELF";
+
+  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_SYSTEM_CALL:
+    return "UNWIND_ERROR_SYSTEM_CALL";
+
+  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_THREAD_TIMEOUT:
+    return "UNWIND_ERROR_THREAD_TIMEOUT";
+
+  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_THREAD_DOES_NOT_EXIST:
+    return "UNWIND_ERROR_THREAD_DOES_NOT_EXIST";
+
+  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_BAD_ARCH:
+    return "UNWIND_ERROR_BAD_ARCH";
+
+  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_MAPS_PARSE:
+    return "UNWIND_ERROR_MAPS_PARSE";
+
+  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_INVALID_PARAMETER:
+    return "UNWIND_ERROR_INVALID_PARAMETER";
+
+  case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_PTRACE_CALL:
+    return "UNWIND_ERROR_PTRACE_CALL";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_ProfilePacket_ProcessHeapSamples {
+enum ClientError : int32_t {
+  CLIENT_ERROR_NONE = 0,
+  CLIENT_ERROR_HIT_TIMEOUT = 1,
+  CLIENT_ERROR_INVALID_STACK_BOUNDS = 2,
+};
+} // namespace perfetto_pbzero_enum_ProfilePacket_ProcessHeapSamples
+using ProfilePacket_ProcessHeapSamples_ClientError = perfetto_pbzero_enum_ProfilePacket_ProcessHeapSamples::ClientError;
+
+
+constexpr ProfilePacket_ProcessHeapSamples_ClientError ProfilePacket_ProcessHeapSamples_ClientError_MIN = ProfilePacket_ProcessHeapSamples_ClientError::CLIENT_ERROR_NONE;
+constexpr ProfilePacket_ProcessHeapSamples_ClientError ProfilePacket_ProcessHeapSamples_ClientError_MAX = ProfilePacket_ProcessHeapSamples_ClientError::CLIENT_ERROR_INVALID_STACK_BOUNDS;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ProfilePacket_ProcessHeapSamples_ClientError_Name(::perfetto::protos::pbzero::ProfilePacket_ProcessHeapSamples_ClientError value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ProfilePacket_ProcessHeapSamples_ClientError::CLIENT_ERROR_NONE:
+    return "CLIENT_ERROR_NONE";
+
+  case ::perfetto::protos::pbzero::ProfilePacket_ProcessHeapSamples_ClientError::CLIENT_ERROR_HIT_TIMEOUT:
+    return "CLIENT_ERROR_HIT_TIMEOUT";
+
+  case ::perfetto::protos::pbzero::ProfilePacket_ProcessHeapSamples_ClientError::CLIENT_ERROR_INVALID_STACK_BOUNDS:
+    return "CLIENT_ERROR_INVALID_STACK_BOUNDS";
   }
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-class EventName_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class PerfSampleDefaults_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  EventName_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit EventName_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit EventName_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_iid() const { return at<1>().valid(); }
-  uint64_t iid() const { return at<1>().as_uint64(); }
-  bool has_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars name() const { return at<2>().as_string(); }
+  PerfSampleDefaults_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PerfSampleDefaults_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PerfSampleDefaults_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_timebase() const { return at<1>().valid(); }
+  ::protozero::ConstBytes timebase() const { return at<1>().as_bytes(); }
+  bool has_followers() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> followers() const { return GetRepeated<::protozero::ConstBytes>(4); }
+  bool has_process_shard_count() const { return at<2>().valid(); }
+  uint32_t process_shard_count() const { return at<2>().as_uint32(); }
+  bool has_chosen_process_shard() const { return at<3>().valid(); }
+  uint32_t chosen_process_shard() const { return at<3>().as_uint32(); }
 };
 
-class EventName : public ::protozero::Message {
+class PerfSampleDefaults : public ::protozero::Message {
  public:
-  using Decoder = EventName_Decoder;
+  using Decoder = PerfSampleDefaults_Decoder;
   enum : int32_t {
-    kIidFieldNumber = 1,
-    kNameFieldNumber = 2,
+    kTimebaseFieldNumber = 1,
+    kFollowersFieldNumber = 4,
+    kProcessShardCountFieldNumber = 2,
+    kChosenProcessShardFieldNumber = 3,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.EventName"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.PerfSampleDefaults"; }
 
 
-  using FieldMetadata_Iid =
+  using FieldMetadata_Timebase =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      EventName>;
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PerfEvents_Timebase,
+      PerfSampleDefaults>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Iid kIid() { return {}; }
-  void set_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_Timebase kTimebase{};
+  template <typename T = PerfEvents_Timebase> T* set_timebase() {
+    return BeginNestedMessage<T>(1);
   }
 
-  using FieldMetadata_Name =
+
+  using FieldMetadata_Followers =
     ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      EventName>;
+      4,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FollowerEvent,
+      PerfSampleDefaults>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_Followers kFollowers{};
+  template <typename T = FollowerEvent> T* add_followers() {
+    return BeginNestedMessage<T>(4);
   }
-};
-
-class EventCategory_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  EventCategory_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit EventCategory_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit EventCategory_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_iid() const { return at<1>().valid(); }
-  uint64_t iid() const { return at<1>().as_uint64(); }
-  bool has_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars name() const { return at<2>().as_string(); }
-};
-
-class EventCategory : public ::protozero::Message {
- public:
-  using Decoder = EventCategory_Decoder;
-  enum : int32_t {
-    kIidFieldNumber = 1,
-    kNameFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.EventCategory"; }
 
 
-  using FieldMetadata_Iid =
+  using FieldMetadata_ProcessShardCount =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      EventCategory>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      PerfSampleDefaults>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Iid kIid() { return {}; }
-  void set_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
+  static constexpr FieldMetadata_ProcessShardCount kProcessShardCount{};
+  void set_process_shard_count(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProcessShardCount::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Name =
+  using FieldMetadata_ChosenProcessShard =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      EventCategory>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      PerfSampleDefaults>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_ChosenProcessShard kChosenProcessShard{};
+  void set_chosen_process_shard(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ChosenProcessShard::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 };
 
-class TrackEventDefaults_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/45, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class PerfSample_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/19> {
  public:
-  TrackEventDefaults_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrackEventDefaults_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrackEventDefaults_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_track_uuid() const { return at<11>().valid(); }
-  uint64_t track_uuid() const { return at<11>().as_uint64(); }
-  bool has_extra_counter_track_uuids() const { return at<31>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> extra_counter_track_uuids() const { return GetRepeated<uint64_t>(31); }
-  bool has_extra_double_counter_track_uuids() const { return at<45>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> extra_double_counter_track_uuids() const { return GetRepeated<uint64_t>(45); }
+  PerfSample_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PerfSample_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PerfSample_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cpu() const { return at<1>().valid(); }
+  uint32_t cpu() const { return at<1>().as_uint32(); }
+  bool has_pid() const { return at<2>().valid(); }
+  uint32_t pid() const { return at<2>().as_uint32(); }
+  bool has_tid() const { return at<3>().valid(); }
+  uint32_t tid() const { return at<3>().as_uint32(); }
+  bool has_cpu_mode() const { return at<5>().valid(); }
+  int32_t cpu_mode() const { return at<5>().as_int32(); }
+  bool has_timebase_count() const { return at<6>().valid(); }
+  uint64_t timebase_count() const { return at<6>().as_uint64(); }
+  bool has_follower_counts() const { return at<7>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint64_t> follower_counts() const { return GetRepeated<uint64_t>(7); }
+  bool has_callstack_iid() const { return at<4>().valid(); }
+  uint64_t callstack_iid() const { return at<4>().as_uint64(); }
+  bool has_unwind_error() const { return at<16>().valid(); }
+  int32_t unwind_error() const { return at<16>().as_int32(); }
+  bool has_kernel_records_lost() const { return at<17>().valid(); }
+  uint64_t kernel_records_lost() const { return at<17>().as_uint64(); }
+  bool has_sample_skipped_reason() const { return at<18>().valid(); }
+  int32_t sample_skipped_reason() const { return at<18>().as_int32(); }
+  bool has_producer_event() const { return at<19>().valid(); }
+  ::protozero::ConstBytes producer_event() const { return at<19>().as_bytes(); }
 };
 
-class TrackEventDefaults : public ::protozero::Message {
+class PerfSample : public ::protozero::Message {
  public:
-  using Decoder = TrackEventDefaults_Decoder;
+  using Decoder = PerfSample_Decoder;
   enum : int32_t {
-    kTrackUuidFieldNumber = 11,
-    kExtraCounterTrackUuidsFieldNumber = 31,
-    kExtraDoubleCounterTrackUuidsFieldNumber = 45,
+    kCpuFieldNumber = 1,
+    kPidFieldNumber = 2,
+    kTidFieldNumber = 3,
+    kCpuModeFieldNumber = 5,
+    kTimebaseCountFieldNumber = 6,
+    kFollowerCountsFieldNumber = 7,
+    kCallstackIidFieldNumber = 4,
+    kUnwindErrorFieldNumber = 16,
+    kKernelRecordsLostFieldNumber = 17,
+    kSampleSkippedReasonFieldNumber = 18,
+    kProducerEventFieldNumber = 19,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrackEventDefaults"; }
-
+  static constexpr const char* GetName() { return ".perfetto.protos.PerfSample"; }
 
-  using FieldMetadata_TrackUuid =
-    ::protozero::proto_utils::FieldMetadata<
-      11,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TrackEventDefaults>;
+  using ProducerEvent = ::perfetto::protos::pbzero::PerfSample_ProducerEvent;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrackUuid kTrackUuid() { return {}; }
-  void set_track_uuid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TrackUuid::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
+  using SampleSkipReason = ::perfetto::protos::pbzero::PerfSample_SampleSkipReason;
+  static inline const char* SampleSkipReason_Name(SampleSkipReason value) {
+    return ::perfetto::protos::pbzero::PerfSample_SampleSkipReason_Name(value);
   }
+  static inline const SampleSkipReason PROFILER_SKIP_UNKNOWN = SampleSkipReason::PROFILER_SKIP_UNKNOWN;
+  static inline const SampleSkipReason PROFILER_SKIP_READ_STAGE = SampleSkipReason::PROFILER_SKIP_READ_STAGE;
+  static inline const SampleSkipReason PROFILER_SKIP_UNWIND_STAGE = SampleSkipReason::PROFILER_SKIP_UNWIND_STAGE;
+  static inline const SampleSkipReason PROFILER_SKIP_UNWIND_ENQUEUE = SampleSkipReason::PROFILER_SKIP_UNWIND_ENQUEUE;
+  static inline const SampleSkipReason PROFILER_SKIP_NOT_IN_SCOPE = SampleSkipReason::PROFILER_SKIP_NOT_IN_SCOPE;
 
-  using FieldMetadata_ExtraCounterTrackUuids =
+  using FieldMetadata_Cpu =
     ::protozero::proto_utils::FieldMetadata<
-      31,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TrackEventDefaults>;
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      PerfSample>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExtraCounterTrackUuids kExtraCounterTrackUuids() { return {}; }
-  void add_extra_counter_track_uuids(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ExtraCounterTrackUuids::kFieldId;
+  static constexpr FieldMetadata_Cpu kCpu{};
+  void set_cpu(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ExtraDoubleCounterTrackUuids =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
-      45,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TrackEventDefaults>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExtraDoubleCounterTrackUuids kExtraDoubleCounterTrackUuids() { return {}; }
-  void add_extra_double_counter_track_uuids(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ExtraDoubleCounterTrackUuids::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-};
-
-class TrackEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/49, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  TrackEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrackEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrackEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_category_iids() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> category_iids() const { return GetRepeated<uint64_t>(3); }
-  bool has_categories() const { return at<22>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> categories() const { return GetRepeated<::protozero::ConstChars>(22); }
-  bool has_name_iid() const { return at<10>().valid(); }
-  uint64_t name_iid() const { return at<10>().as_uint64(); }
-  bool has_name() const { return at<23>().valid(); }
-  ::protozero::ConstChars name() const { return at<23>().as_string(); }
-  bool has_type() const { return at<9>().valid(); }
-  int32_t type() const { return at<9>().as_int32(); }
-  bool has_track_uuid() const { return at<11>().valid(); }
-  uint64_t track_uuid() const { return at<11>().as_uint64(); }
-  bool has_counter_value() const { return at<30>().valid(); }
-  int64_t counter_value() const { return at<30>().as_int64(); }
-  bool has_double_counter_value() const { return at<44>().valid(); }
-  double double_counter_value() const { return at<44>().as_double(); }
-  bool has_extra_counter_track_uuids() const { return at<31>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> extra_counter_track_uuids() const { return GetRepeated<uint64_t>(31); }
-  bool has_extra_counter_values() const { return at<12>().valid(); }
-  ::protozero::RepeatedFieldIterator<int64_t> extra_counter_values() const { return GetRepeated<int64_t>(12); }
-  bool has_extra_double_counter_track_uuids() const { return at<45>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> extra_double_counter_track_uuids() const { return GetRepeated<uint64_t>(45); }
-  bool has_extra_double_counter_values() const { return at<46>().valid(); }
-  ::protozero::RepeatedFieldIterator<double> extra_double_counter_values() const { return GetRepeated<double>(46); }
-  bool has_flow_ids_old() const { return at<36>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> flow_ids_old() const { return GetRepeated<uint64_t>(36); }
-  bool has_flow_ids() const { return at<47>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> flow_ids() const { return GetRepeated<uint64_t>(47); }
-  bool has_terminating_flow_ids_old() const { return at<42>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> terminating_flow_ids_old() const { return GetRepeated<uint64_t>(42); }
-  bool has_terminating_flow_ids() const { return at<48>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint64_t> terminating_flow_ids() const { return GetRepeated<uint64_t>(48); }
-  bool has_debug_annotations() const { return at<4>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> debug_annotations() const { return GetRepeated<::protozero::ConstBytes>(4); }
-  bool has_task_execution() const { return at<5>().valid(); }
-  ::protozero::ConstBytes task_execution() const { return at<5>().as_bytes(); }
-  bool has_log_message() const { return at<21>().valid(); }
-  ::protozero::ConstBytes log_message() const { return at<21>().as_bytes(); }
-  bool has_cc_scheduler_state() const { return at<24>().valid(); }
-  ::protozero::ConstBytes cc_scheduler_state() const { return at<24>().as_bytes(); }
-  bool has_chrome_user_event() const { return at<25>().valid(); }
-  ::protozero::ConstBytes chrome_user_event() const { return at<25>().as_bytes(); }
-  bool has_chrome_keyed_service() const { return at<26>().valid(); }
-  ::protozero::ConstBytes chrome_keyed_service() const { return at<26>().as_bytes(); }
-  bool has_chrome_legacy_ipc() const { return at<27>().valid(); }
-  ::protozero::ConstBytes chrome_legacy_ipc() const { return at<27>().as_bytes(); }
-  bool has_chrome_histogram_sample() const { return at<28>().valid(); }
-  ::protozero::ConstBytes chrome_histogram_sample() const { return at<28>().as_bytes(); }
-  bool has_chrome_latency_info() const { return at<29>().valid(); }
-  ::protozero::ConstBytes chrome_latency_info() const { return at<29>().as_bytes(); }
-  bool has_chrome_frame_reporter() const { return at<32>().valid(); }
-  ::protozero::ConstBytes chrome_frame_reporter() const { return at<32>().as_bytes(); }
-  bool has_chrome_application_state_info() const { return at<39>().valid(); }
-  ::protozero::ConstBytes chrome_application_state_info() const { return at<39>().as_bytes(); }
-  bool has_chrome_renderer_scheduler_state() const { return at<40>().valid(); }
-  ::protozero::ConstBytes chrome_renderer_scheduler_state() const { return at<40>().as_bytes(); }
-  bool has_chrome_window_handle_event_info() const { return at<41>().valid(); }
-  ::protozero::ConstBytes chrome_window_handle_event_info() const { return at<41>().as_bytes(); }
-  bool has_chrome_content_settings_event_info() const { return at<43>().valid(); }
-  ::protozero::ConstBytes chrome_content_settings_event_info() const { return at<43>().as_bytes(); }
-  bool has_chrome_active_processes() const { return at<49>().valid(); }
-  ::protozero::ConstBytes chrome_active_processes() const { return at<49>().as_bytes(); }
-  bool has_source_location() const { return at<33>().valid(); }
-  ::protozero::ConstBytes source_location() const { return at<33>().as_bytes(); }
-  bool has_source_location_iid() const { return at<34>().valid(); }
-  uint64_t source_location_iid() const { return at<34>().as_uint64(); }
-  bool has_chrome_message_pump() const { return at<35>().valid(); }
-  ::protozero::ConstBytes chrome_message_pump() const { return at<35>().as_bytes(); }
-  bool has_chrome_mojo_event_info() const { return at<38>().valid(); }
-  ::protozero::ConstBytes chrome_mojo_event_info() const { return at<38>().as_bytes(); }
-  bool has_timestamp_delta_us() const { return at<1>().valid(); }
-  int64_t timestamp_delta_us() const { return at<1>().as_int64(); }
-  bool has_timestamp_absolute_us() const { return at<16>().valid(); }
-  int64_t timestamp_absolute_us() const { return at<16>().as_int64(); }
-  bool has_thread_time_delta_us() const { return at<2>().valid(); }
-  int64_t thread_time_delta_us() const { return at<2>().as_int64(); }
-  bool has_thread_time_absolute_us() const { return at<17>().valid(); }
-  int64_t thread_time_absolute_us() const { return at<17>().as_int64(); }
-  bool has_thread_instruction_count_delta() const { return at<8>().valid(); }
-  int64_t thread_instruction_count_delta() const { return at<8>().as_int64(); }
-  bool has_thread_instruction_count_absolute() const { return at<20>().valid(); }
-  int64_t thread_instruction_count_absolute() const { return at<20>().as_int64(); }
-  bool has_legacy_event() const { return at<6>().valid(); }
-  ::protozero::ConstBytes legacy_event() const { return at<6>().as_bytes(); }
-};
-
-class TrackEvent : public ::protozero::Message {
- public:
-  using Decoder = TrackEvent_Decoder;
-  enum : int32_t {
-    kCategoryIidsFieldNumber = 3,
-    kCategoriesFieldNumber = 22,
-    kNameIidFieldNumber = 10,
-    kNameFieldNumber = 23,
-    kTypeFieldNumber = 9,
-    kTrackUuidFieldNumber = 11,
-    kCounterValueFieldNumber = 30,
-    kDoubleCounterValueFieldNumber = 44,
-    kExtraCounterTrackUuidsFieldNumber = 31,
-    kExtraCounterValuesFieldNumber = 12,
-    kExtraDoubleCounterTrackUuidsFieldNumber = 45,
-    kExtraDoubleCounterValuesFieldNumber = 46,
-    kFlowIdsOldFieldNumber = 36,
-    kFlowIdsFieldNumber = 47,
-    kTerminatingFlowIdsOldFieldNumber = 42,
-    kTerminatingFlowIdsFieldNumber = 48,
-    kDebugAnnotationsFieldNumber = 4,
-    kTaskExecutionFieldNumber = 5,
-    kLogMessageFieldNumber = 21,
-    kCcSchedulerStateFieldNumber = 24,
-    kChromeUserEventFieldNumber = 25,
-    kChromeKeyedServiceFieldNumber = 26,
-    kChromeLegacyIpcFieldNumber = 27,
-    kChromeHistogramSampleFieldNumber = 28,
-    kChromeLatencyInfoFieldNumber = 29,
-    kChromeFrameReporterFieldNumber = 32,
-    kChromeApplicationStateInfoFieldNumber = 39,
-    kChromeRendererSchedulerStateFieldNumber = 40,
-    kChromeWindowHandleEventInfoFieldNumber = 41,
-    kChromeContentSettingsEventInfoFieldNumber = 43,
-    kChromeActiveProcessesFieldNumber = 49,
-    kSourceLocationFieldNumber = 33,
-    kSourceLocationIidFieldNumber = 34,
-    kChromeMessagePumpFieldNumber = 35,
-    kChromeMojoEventInfoFieldNumber = 38,
-    kTimestampDeltaUsFieldNumber = 1,
-    kTimestampAbsoluteUsFieldNumber = 16,
-    kThreadTimeDeltaUsFieldNumber = 2,
-    kThreadTimeAbsoluteUsFieldNumber = 17,
-    kThreadInstructionCountDeltaFieldNumber = 8,
-    kThreadInstructionCountAbsoluteFieldNumber = 20,
-    kLegacyEventFieldNumber = 6,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrackEvent"; }
-
-  using LegacyEvent = ::perfetto::protos::pbzero::TrackEvent_LegacyEvent;
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      PerfSample>;
 
-  using Type = ::perfetto::protos::pbzero::TrackEvent_Type;
-  static inline const char* Type_Name(Type value) {
-    return ::perfetto::protos::pbzero::TrackEvent_Type_Name(value);
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
-  static const Type TYPE_UNSPECIFIED = Type::TYPE_UNSPECIFIED;
-  static const Type TYPE_SLICE_BEGIN = Type::TYPE_SLICE_BEGIN;
-  static const Type TYPE_SLICE_END = Type::TYPE_SLICE_END;
-  static const Type TYPE_INSTANT = Type::TYPE_INSTANT;
-  static const Type TYPE_COUNTER = Type::TYPE_COUNTER;
 
-  using FieldMetadata_CategoryIids =
+  using FieldMetadata_Tid =
     ::protozero::proto_utils::FieldMetadata<
       3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TrackEvent>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      PerfSample>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CategoryIids kCategoryIids() { return {}; }
-  void add_category_iids(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CategoryIids::kFieldId;
+  static constexpr FieldMetadata_Tid kTid{};
+  void set_tid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Categories =
+  using FieldMetadata_CpuMode =
     ::protozero::proto_utils::FieldMetadata<
-      22,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TrackEvent>;
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      Profiling_CpuMode,
+      PerfSample>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Categories kCategories() { return {}; }
-  void add_categories(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Categories::kFieldId, data, size);
-  }
-  void add_categories(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Categories::kFieldId, chars.data, chars.size);
-  }
-  void add_categories(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Categories::kFieldId;
+  static constexpr FieldMetadata_CpuMode kCpuMode{};
+  void set_cpu_mode(Profiling_CpuMode value) {
+    static constexpr uint32_t field_id = FieldMetadata_CpuMode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NameIid =
+  using FieldMetadata_TimebaseCount =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TrackEvent>;
+      PerfSample>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NameIid kNameIid() { return {}; }
-  void set_name_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NameIid::kFieldId;
+  static constexpr FieldMetadata_TimebaseCount kTimebaseCount{};
+  void set_timebase_count(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimebaseCount::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -150804,55 +171829,53 @@ class TrackEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Name =
+  using FieldMetadata_FollowerCounts =
     ::protozero::proto_utils::FieldMetadata<
-      23,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TrackEvent>;
+      7,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      PerfSample>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  static constexpr FieldMetadata_FollowerCounts kFollowerCounts{};
+  void add_follower_counts(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FollowerCounts::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+
+  using FieldMetadata_CallstackIid =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      PerfSample>;
+
+  static constexpr FieldMetadata_CallstackIid kCallstackIid{};
+  void set_callstack_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CallstackIid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Type =
+  using FieldMetadata_UnwindError =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      16,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::TrackEvent_Type,
-      TrackEvent>;
+      Profiling_StackUnwindError,
+      PerfSample>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Type kType() { return {}; }
-  void set_type(::perfetto::protos::pbzero::TrackEvent_Type value) {
-    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+  static constexpr FieldMetadata_UnwindError kUnwindError{};
+  void set_unwind_error(Profiling_StackUnwindError value) {
+    static constexpr uint32_t field_id = FieldMetadata_UnwindError::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -150860,24 +171883,17 @@ class TrackEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TrackUuid =
+  using FieldMetadata_KernelRecordsLost =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      17,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TrackEvent>;
+      PerfSample>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrackUuid kTrackUuid() { return {}; }
-  void set_track_uuid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TrackUuid::kFieldId;
+  static constexpr FieldMetadata_KernelRecordsLost kKernelRecordsLost{};
+  void set_kernel_records_lost(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KernelRecordsLost::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -150885,74 +171901,164 @@ class TrackEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CounterValue =
+  using FieldMetadata_SampleSkippedReason =
     ::protozero::proto_utils::FieldMetadata<
-      30,
+      18,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TrackEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      PerfSample_SampleSkipReason,
+      PerfSample>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CounterValue kCounterValue() { return {}; }
-  void set_counter_value(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CounterValue::kFieldId;
+  static constexpr FieldMetadata_SampleSkippedReason kSampleSkippedReason{};
+  void set_sample_skipped_reason(PerfSample_SampleSkipReason value) {
+    static constexpr uint32_t field_id = FieldMetadata_SampleSkippedReason::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DoubleCounterValue =
+  using FieldMetadata_ProducerEvent =
     ::protozero::proto_utils::FieldMetadata<
-      44,
+      19,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kDouble,
-      double,
-      TrackEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PerfSample_ProducerEvent,
+      PerfSample>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DoubleCounterValue kDoubleCounterValue() { return {}; }
-  void set_double_counter_value(double value) {
-    static constexpr uint32_t field_id = FieldMetadata_DoubleCounterValue::kFieldId;
+  static constexpr FieldMetadata_ProducerEvent kProducerEvent{};
+  template <typename T = PerfSample_ProducerEvent> T* set_producer_event() {
+    return BeginNestedMessage<T>(19);
+  }
+
+};
+
+class PerfSample_ProducerEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  PerfSample_ProducerEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PerfSample_ProducerEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PerfSample_ProducerEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_source_stop_reason() const { return at<1>().valid(); }
+  int32_t source_stop_reason() const { return at<1>().as_int32(); }
+};
+
+class PerfSample_ProducerEvent : public ::protozero::Message {
+ public:
+  using Decoder = PerfSample_ProducerEvent_Decoder;
+  enum : int32_t {
+    kSourceStopReasonFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.PerfSample.ProducerEvent"; }
+
+
+  using DataSourceStopReason = ::perfetto::protos::pbzero::PerfSample_ProducerEvent_DataSourceStopReason;
+  static inline const char* DataSourceStopReason_Name(DataSourceStopReason value) {
+    return ::perfetto::protos::pbzero::PerfSample_ProducerEvent_DataSourceStopReason_Name(value);
+  }
+  static inline const DataSourceStopReason PROFILER_STOP_UNKNOWN = DataSourceStopReason::PROFILER_STOP_UNKNOWN;
+  static inline const DataSourceStopReason PROFILER_STOP_GUARDRAIL = DataSourceStopReason::PROFILER_STOP_GUARDRAIL;
+
+  using FieldMetadata_SourceStopReason =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      PerfSample_ProducerEvent_DataSourceStopReason,
+      PerfSample_ProducerEvent>;
+
+  static constexpr FieldMetadata_SourceStopReason kSourceStopReason{};
+  void set_source_stop_reason(PerfSample_ProducerEvent_DataSourceStopReason value) {
+    static constexpr uint32_t field_id = FieldMetadata_SourceStopReason::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_ExtraCounterTrackUuids =
+class Profiling_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0> {
+ public:
+  Profiling_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Profiling_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Profiling_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+};
+
+class Profiling : public ::protozero::Message {
+ public:
+  using Decoder = Profiling_Decoder;
+  static constexpr const char* GetName() { return ".perfetto.protos.Profiling"; }
+
+
+  using CpuMode = ::perfetto::protos::pbzero::Profiling_CpuMode;
+  static inline const char* CpuMode_Name(CpuMode value) {
+    return ::perfetto::protos::pbzero::Profiling_CpuMode_Name(value);
+  }
+
+  using StackUnwindError = ::perfetto::protos::pbzero::Profiling_StackUnwindError;
+  static inline const char* StackUnwindError_Name(StackUnwindError value) {
+    return ::perfetto::protos::pbzero::Profiling_StackUnwindError_Name(value);
+  }
+  static inline const CpuMode MODE_UNKNOWN = CpuMode::MODE_UNKNOWN;
+  static inline const CpuMode MODE_KERNEL = CpuMode::MODE_KERNEL;
+  static inline const CpuMode MODE_USER = CpuMode::MODE_USER;
+  static inline const CpuMode MODE_HYPERVISOR = CpuMode::MODE_HYPERVISOR;
+  static inline const CpuMode MODE_GUEST_KERNEL = CpuMode::MODE_GUEST_KERNEL;
+  static inline const CpuMode MODE_GUEST_USER = CpuMode::MODE_GUEST_USER;
+  static inline const StackUnwindError UNWIND_ERROR_UNKNOWN = StackUnwindError::UNWIND_ERROR_UNKNOWN;
+  static inline const StackUnwindError UNWIND_ERROR_NONE = StackUnwindError::UNWIND_ERROR_NONE;
+  static inline const StackUnwindError UNWIND_ERROR_MEMORY_INVALID = StackUnwindError::UNWIND_ERROR_MEMORY_INVALID;
+  static inline const StackUnwindError UNWIND_ERROR_UNWIND_INFO = StackUnwindError::UNWIND_ERROR_UNWIND_INFO;
+  static inline const StackUnwindError UNWIND_ERROR_UNSUPPORTED = StackUnwindError::UNWIND_ERROR_UNSUPPORTED;
+  static inline const StackUnwindError UNWIND_ERROR_INVALID_MAP = StackUnwindError::UNWIND_ERROR_INVALID_MAP;
+  static inline const StackUnwindError UNWIND_ERROR_MAX_FRAMES_EXCEEDED = StackUnwindError::UNWIND_ERROR_MAX_FRAMES_EXCEEDED;
+  static inline const StackUnwindError UNWIND_ERROR_REPEATED_FRAME = StackUnwindError::UNWIND_ERROR_REPEATED_FRAME;
+  static inline const StackUnwindError UNWIND_ERROR_INVALID_ELF = StackUnwindError::UNWIND_ERROR_INVALID_ELF;
+  static inline const StackUnwindError UNWIND_ERROR_SYSTEM_CALL = StackUnwindError::UNWIND_ERROR_SYSTEM_CALL;
+  static inline const StackUnwindError UNWIND_ERROR_THREAD_TIMEOUT = StackUnwindError::UNWIND_ERROR_THREAD_TIMEOUT;
+  static inline const StackUnwindError UNWIND_ERROR_THREAD_DOES_NOT_EXIST = StackUnwindError::UNWIND_ERROR_THREAD_DOES_NOT_EXIST;
+  static inline const StackUnwindError UNWIND_ERROR_BAD_ARCH = StackUnwindError::UNWIND_ERROR_BAD_ARCH;
+  static inline const StackUnwindError UNWIND_ERROR_MAPS_PARSE = StackUnwindError::UNWIND_ERROR_MAPS_PARSE;
+  static inline const StackUnwindError UNWIND_ERROR_INVALID_PARAMETER = StackUnwindError::UNWIND_ERROR_INVALID_PARAMETER;
+  static inline const StackUnwindError UNWIND_ERROR_PTRACE_CALL = StackUnwindError::UNWIND_ERROR_PTRACE_CALL;
+};
+
+class StreamingProfilePacket_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  StreamingProfilePacket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit StreamingProfilePacket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit StreamingProfilePacket_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_callstack_iid() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint64_t> callstack_iid() const { return GetRepeated<uint64_t>(1); }
+  bool has_timestamp_delta_us() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<int64_t> timestamp_delta_us() const { return GetRepeated<int64_t>(2); }
+  bool has_process_priority() const { return at<3>().valid(); }
+  int32_t process_priority() const { return at<3>().as_int32(); }
+};
+
+class StreamingProfilePacket : public ::protozero::Message {
+ public:
+  using Decoder = StreamingProfilePacket_Decoder;
+  enum : int32_t {
+    kCallstackIidFieldNumber = 1,
+    kTimestampDeltaUsFieldNumber = 2,
+    kProcessPriorityFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.StreamingProfilePacket"; }
+
+
+  using FieldMetadata_CallstackIid =
     ::protozero::proto_utils::FieldMetadata<
-      31,
+      1,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TrackEvent>;
+      StreamingProfilePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExtraCounterTrackUuids kExtraCounterTrackUuids() { return {}; }
-  void add_extra_counter_track_uuids(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ExtraCounterTrackUuids::kFieldId;
+  static constexpr FieldMetadata_CallstackIid kCallstackIid{};
+  void add_callstack_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CallstackIid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -150960,24 +172066,17 @@ class TrackEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ExtraCounterValues =
+  using FieldMetadata_TimestampDeltaUs =
     ::protozero::proto_utils::FieldMetadata<
-      12,
+      2,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kInt64,
       int64_t,
-      TrackEvent>;
+      StreamingProfilePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExtraCounterValues kExtraCounterValues() { return {}; }
-  void add_extra_counter_values(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ExtraCounterValues::kFieldId;
+  static constexpr FieldMetadata_TimestampDeltaUs kTimestampDeltaUs{};
+  void add_timestamp_delta_us(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimestampDeltaUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -150985,24 +172084,60 @@ class TrackEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ExtraDoubleCounterTrackUuids =
+  using FieldMetadata_ProcessPriority =
     ::protozero::proto_utils::FieldMetadata<
-      45,
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      StreamingProfilePacket>;
+
+  static constexpr FieldMetadata_ProcessPriority kProcessPriority{};
+  void set_process_priority(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProcessPriority::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class StreamingFree_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  StreamingFree_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit StreamingFree_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit StreamingFree_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_address() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint64_t> address() const { return GetRepeated<uint64_t>(1); }
+  bool has_heap_id() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint32_t> heap_id() const { return GetRepeated<uint32_t>(2); }
+  bool has_sequence_number() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint64_t> sequence_number() const { return GetRepeated<uint64_t>(3); }
+};
+
+class StreamingFree : public ::protozero::Message {
+ public:
+  using Decoder = StreamingFree_Decoder;
+  enum : int32_t {
+    kAddressFieldNumber = 1,
+    kHeapIdFieldNumber = 2,
+    kSequenceNumberFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.StreamingFree"; }
+
+
+  using FieldMetadata_Address =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TrackEvent>;
+      StreamingFree>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExtraDoubleCounterTrackUuids kExtraDoubleCounterTrackUuids() { return {}; }
-  void add_extra_double_counter_track_uuids(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ExtraDoubleCounterTrackUuids::kFieldId;
+  static constexpr FieldMetadata_Address kAddress{};
+  void add_address(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Address::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -151010,99 +172145,105 @@ class TrackEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ExtraDoubleCounterValues =
+  using FieldMetadata_HeapId =
     ::protozero::proto_utils::FieldMetadata<
-      46,
+      2,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kDouble,
-      double,
-      TrackEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      StreamingFree>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExtraDoubleCounterValues kExtraDoubleCounterValues() { return {}; }
-  void add_extra_double_counter_values(double value) {
-    static constexpr uint32_t field_id = FieldMetadata_ExtraDoubleCounterValues::kFieldId;
+  static constexpr FieldMetadata_HeapId kHeapId{};
+  void add_heap_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_HeapId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kDouble>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FlowIdsOld =
+  using FieldMetadata_SequenceNumber =
     ::protozero::proto_utils::FieldMetadata<
-      36,
+      3,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TrackEvent>;
+      StreamingFree>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FlowIdsOld kFlowIdsOld() { return {}; }
-  void add_flow_ids_old(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FlowIdsOld::kFieldId;
+  static constexpr FieldMetadata_SequenceNumber kSequenceNumber{};
+  void add_sequence_number(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SequenceNumber::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_FlowIds =
+class StreamingAllocation_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
+ public:
+  StreamingAllocation_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit StreamingAllocation_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit StreamingAllocation_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_address() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint64_t> address() const { return GetRepeated<uint64_t>(1); }
+  bool has_size() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint64_t> size() const { return GetRepeated<uint64_t>(2); }
+  bool has_sample_size() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint64_t> sample_size() const { return GetRepeated<uint64_t>(3); }
+  bool has_clock_monotonic_coarse_timestamp() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint64_t> clock_monotonic_coarse_timestamp() const { return GetRepeated<uint64_t>(4); }
+  bool has_heap_id() const { return at<5>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint32_t> heap_id() const { return GetRepeated<uint32_t>(5); }
+  bool has_sequence_number() const { return at<6>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint64_t> sequence_number() const { return GetRepeated<uint64_t>(6); }
+};
+
+class StreamingAllocation : public ::protozero::Message {
+ public:
+  using Decoder = StreamingAllocation_Decoder;
+  enum : int32_t {
+    kAddressFieldNumber = 1,
+    kSizeFieldNumber = 2,
+    kSampleSizeFieldNumber = 3,
+    kClockMonotonicCoarseTimestampFieldNumber = 4,
+    kHeapIdFieldNumber = 5,
+    kSequenceNumberFieldNumber = 6,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.StreamingAllocation"; }
+
+
+  using FieldMetadata_Address =
     ::protozero::proto_utils::FieldMetadata<
-      47,
+      1,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TrackEvent>;
+      StreamingAllocation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FlowIds kFlowIds() { return {}; }
-  void add_flow_ids(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FlowIds::kFieldId;
+  static constexpr FieldMetadata_Address kAddress{};
+  void add_address(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Address::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TerminatingFlowIdsOld =
+  using FieldMetadata_Size =
     ::protozero::proto_utils::FieldMetadata<
-      42,
+      2,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TrackEvent>;
+      StreamingAllocation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TerminatingFlowIdsOld kTerminatingFlowIdsOld() { return {}; }
-  void add_terminating_flow_ids_old(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TerminatingFlowIdsOld::kFieldId;
+  static constexpr FieldMetadata_Size kSize{};
+  void add_size(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -151110,705 +172251,586 @@ class TrackEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TerminatingFlowIds =
+  using FieldMetadata_SampleSize =
     ::protozero::proto_utils::FieldMetadata<
-      48,
+      3,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TrackEvent>;
+      StreamingAllocation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TerminatingFlowIds kTerminatingFlowIds() { return {}; }
-  void add_terminating_flow_ids(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TerminatingFlowIds::kFieldId;
+  static constexpr FieldMetadata_SampleSize kSampleSize{};
+  void add_sample_size(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SampleSize::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DebugAnnotations =
+  using FieldMetadata_ClockMonotonicCoarseTimestamp =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      DebugAnnotation,
-      TrackEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      StreamingAllocation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DebugAnnotations kDebugAnnotations() { return {}; }
-  template <typename T = DebugAnnotation> T* add_debug_annotations() {
-    return BeginNestedMessage<T>(4);
+  static constexpr FieldMetadata_ClockMonotonicCoarseTimestamp kClockMonotonicCoarseTimestamp{};
+  void add_clock_monotonic_coarse_timestamp(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ClockMonotonicCoarseTimestamp::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_TaskExecution =
+  using FieldMetadata_HeapId =
     ::protozero::proto_utils::FieldMetadata<
       5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TaskExecution,
-      TrackEvent>;
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      StreamingAllocation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TaskExecution kTaskExecution() { return {}; }
-  template <typename T = TaskExecution> T* set_task_execution() {
-    return BeginNestedMessage<T>(5);
+  static constexpr FieldMetadata_HeapId kHeapId{};
+  void add_heap_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_HeapId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_LogMessage =
+  using FieldMetadata_SequenceNumber =
     ::protozero::proto_utils::FieldMetadata<
-      21,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      LogMessage,
-      TrackEvent>;
+      6,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      StreamingAllocation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LogMessage kLogMessage() { return {}; }
-  template <typename T = LogMessage> T* set_log_message() {
-    return BeginNestedMessage<T>(21);
+  static constexpr FieldMetadata_SequenceNumber kSequenceNumber{};
+  void add_sequence_number(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SequenceNumber::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
+};
 
+class ProfilePacket_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
+ public:
+  ProfilePacket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProfilePacket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProfilePacket_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_strings() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> strings() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  bool has_mappings() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> mappings() const { return GetRepeated<::protozero::ConstBytes>(4); }
+  bool has_frames() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> frames() const { return GetRepeated<::protozero::ConstBytes>(2); }
+  bool has_callstacks() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> callstacks() const { return GetRepeated<::protozero::ConstBytes>(3); }
+  bool has_process_dumps() const { return at<5>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> process_dumps() const { return GetRepeated<::protozero::ConstBytes>(5); }
+  bool has_continued() const { return at<6>().valid(); }
+  bool continued() const { return at<6>().as_bool(); }
+  bool has_index() const { return at<7>().valid(); }
+  uint64_t index() const { return at<7>().as_uint64(); }
+};
 
-  using FieldMetadata_CcSchedulerState =
-    ::protozero::proto_utils::FieldMetadata<
-      24,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeCompositorSchedulerState,
-      TrackEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CcSchedulerState kCcSchedulerState() { return {}; }
-  template <typename T = ChromeCompositorSchedulerState> T* set_cc_scheduler_state() {
-    return BeginNestedMessage<T>(24);
-  }
+class ProfilePacket : public ::protozero::Message {
+ public:
+  using Decoder = ProfilePacket_Decoder;
+  enum : int32_t {
+    kStringsFieldNumber = 1,
+    kMappingsFieldNumber = 4,
+    kFramesFieldNumber = 2,
+    kCallstacksFieldNumber = 3,
+    kProcessDumpsFieldNumber = 5,
+    kContinuedFieldNumber = 6,
+    kIndexFieldNumber = 7,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ProfilePacket"; }
 
+  using HeapSample = ::perfetto::protos::pbzero::ProfilePacket_HeapSample;
+  using Histogram = ::perfetto::protos::pbzero::ProfilePacket_Histogram;
+  using ProcessStats = ::perfetto::protos::pbzero::ProfilePacket_ProcessStats;
+  using ProcessHeapSamples = ::perfetto::protos::pbzero::ProfilePacket_ProcessHeapSamples;
 
-  using FieldMetadata_ChromeUserEvent =
+  using FieldMetadata_Strings =
     ::protozero::proto_utils::FieldMetadata<
-      25,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeUserEvent,
-      TrackEvent>;
+      InternedString,
+      ProfilePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeUserEvent kChromeUserEvent() { return {}; }
-  template <typename T = ChromeUserEvent> T* set_chrome_user_event() {
-    return BeginNestedMessage<T>(25);
+  static constexpr FieldMetadata_Strings kStrings{};
+  template <typename T = InternedString> T* add_strings() {
+    return BeginNestedMessage<T>(1);
   }
 
 
-  using FieldMetadata_ChromeKeyedService =
+  using FieldMetadata_Mappings =
     ::protozero::proto_utils::FieldMetadata<
-      26,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      4,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeKeyedService,
-      TrackEvent>;
+      Mapping,
+      ProfilePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeKeyedService kChromeKeyedService() { return {}; }
-  template <typename T = ChromeKeyedService> T* set_chrome_keyed_service() {
-    return BeginNestedMessage<T>(26);
+  static constexpr FieldMetadata_Mappings kMappings{};
+  template <typename T = Mapping> T* add_mappings() {
+    return BeginNestedMessage<T>(4);
   }
 
 
-  using FieldMetadata_ChromeLegacyIpc =
+  using FieldMetadata_Frames =
     ::protozero::proto_utils::FieldMetadata<
-      27,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeLegacyIpc,
-      TrackEvent>;
+      Frame,
+      ProfilePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeLegacyIpc kChromeLegacyIpc() { return {}; }
-  template <typename T = ChromeLegacyIpc> T* set_chrome_legacy_ipc() {
-    return BeginNestedMessage<T>(27);
+  static constexpr FieldMetadata_Frames kFrames{};
+  template <typename T = Frame> T* add_frames() {
+    return BeginNestedMessage<T>(2);
   }
 
 
-  using FieldMetadata_ChromeHistogramSample =
+  using FieldMetadata_Callstacks =
     ::protozero::proto_utils::FieldMetadata<
-      28,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeHistogramSample,
-      TrackEvent>;
+      Callstack,
+      ProfilePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeHistogramSample kChromeHistogramSample() { return {}; }
-  template <typename T = ChromeHistogramSample> T* set_chrome_histogram_sample() {
-    return BeginNestedMessage<T>(28);
+  static constexpr FieldMetadata_Callstacks kCallstacks{};
+  template <typename T = Callstack> T* add_callstacks() {
+    return BeginNestedMessage<T>(3);
   }
 
 
-  using FieldMetadata_ChromeLatencyInfo =
+  using FieldMetadata_ProcessDumps =
     ::protozero::proto_utils::FieldMetadata<
-      29,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      5,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeLatencyInfo,
-      TrackEvent>;
+      ProfilePacket_ProcessHeapSamples,
+      ProfilePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeLatencyInfo kChromeLatencyInfo() { return {}; }
-  template <typename T = ChromeLatencyInfo> T* set_chrome_latency_info() {
-    return BeginNestedMessage<T>(29);
+  static constexpr FieldMetadata_ProcessDumps kProcessDumps{};
+  template <typename T = ProfilePacket_ProcessHeapSamples> T* add_process_dumps() {
+    return BeginNestedMessage<T>(5);
   }
 
 
-  using FieldMetadata_ChromeFrameReporter =
+  using FieldMetadata_Continued =
     ::protozero::proto_utils::FieldMetadata<
-      32,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeFrameReporter,
-      TrackEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ProfilePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeFrameReporter kChromeFrameReporter() { return {}; }
-  template <typename T = ChromeFrameReporter> T* set_chrome_frame_reporter() {
-    return BeginNestedMessage<T>(32);
+  static constexpr FieldMetadata_Continued kContinued{};
+  void set_continued(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_Continued::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_ChromeApplicationStateInfo =
+  using FieldMetadata_Index =
     ::protozero::proto_utils::FieldMetadata<
-      39,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeApplicationStateInfo,
-      TrackEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProfilePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeApplicationStateInfo kChromeApplicationStateInfo() { return {}; }
-  template <typename T = ChromeApplicationStateInfo> T* set_chrome_application_state_info() {
-    return BeginNestedMessage<T>(39);
+  static constexpr FieldMetadata_Index kIndex{};
+  void set_index(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
+};
 
+class ProfilePacket_ProcessHeapSamples_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/14> {
+ public:
+  ProfilePacket_ProcessHeapSamples_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProfilePacket_ProcessHeapSamples_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProfilePacket_ProcessHeapSamples_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  uint64_t pid() const { return at<1>().as_uint64(); }
+  bool has_from_startup() const { return at<3>().valid(); }
+  bool from_startup() const { return at<3>().as_bool(); }
+  bool has_rejected_concurrent() const { return at<4>().valid(); }
+  bool rejected_concurrent() const { return at<4>().as_bool(); }
+  bool has_disconnected() const { return at<6>().valid(); }
+  bool disconnected() const { return at<6>().as_bool(); }
+  bool has_buffer_overran() const { return at<7>().valid(); }
+  bool buffer_overran() const { return at<7>().as_bool(); }
+  bool has_client_error() const { return at<14>().valid(); }
+  int32_t client_error() const { return at<14>().as_int32(); }
+  bool has_buffer_corrupted() const { return at<8>().valid(); }
+  bool buffer_corrupted() const { return at<8>().as_bool(); }
+  bool has_hit_guardrail() const { return at<10>().valid(); }
+  bool hit_guardrail() const { return at<10>().as_bool(); }
+  bool has_heap_name() const { return at<11>().valid(); }
+  ::protozero::ConstChars heap_name() const { return at<11>().as_string(); }
+  bool has_sampling_interval_bytes() const { return at<12>().valid(); }
+  uint64_t sampling_interval_bytes() const { return at<12>().as_uint64(); }
+  bool has_orig_sampling_interval_bytes() const { return at<13>().valid(); }
+  uint64_t orig_sampling_interval_bytes() const { return at<13>().as_uint64(); }
+  bool has_timestamp() const { return at<9>().valid(); }
+  uint64_t timestamp() const { return at<9>().as_uint64(); }
+  bool has_stats() const { return at<5>().valid(); }
+  ::protozero::ConstBytes stats() const { return at<5>().as_bytes(); }
+  bool has_samples() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> samples() const { return GetRepeated<::protozero::ConstBytes>(2); }
+};
 
-  using FieldMetadata_ChromeRendererSchedulerState =
-    ::protozero::proto_utils::FieldMetadata<
-      40,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeRendererSchedulerState,
-      TrackEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeRendererSchedulerState kChromeRendererSchedulerState() { return {}; }
-  template <typename T = ChromeRendererSchedulerState> T* set_chrome_renderer_scheduler_state() {
-    return BeginNestedMessage<T>(40);
-  }
-
+class ProfilePacket_ProcessHeapSamples : public ::protozero::Message {
+ public:
+  using Decoder = ProfilePacket_ProcessHeapSamples_Decoder;
+  enum : int32_t {
+    kPidFieldNumber = 1,
+    kFromStartupFieldNumber = 3,
+    kRejectedConcurrentFieldNumber = 4,
+    kDisconnectedFieldNumber = 6,
+    kBufferOverranFieldNumber = 7,
+    kClientErrorFieldNumber = 14,
+    kBufferCorruptedFieldNumber = 8,
+    kHitGuardrailFieldNumber = 10,
+    kHeapNameFieldNumber = 11,
+    kSamplingIntervalBytesFieldNumber = 12,
+    kOrigSamplingIntervalBytesFieldNumber = 13,
+    kTimestampFieldNumber = 9,
+    kStatsFieldNumber = 5,
+    kSamplesFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ProfilePacket.ProcessHeapSamples"; }
 
-  using FieldMetadata_ChromeWindowHandleEventInfo =
-    ::protozero::proto_utils::FieldMetadata<
-      41,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeWindowHandleEventInfo,
-      TrackEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeWindowHandleEventInfo kChromeWindowHandleEventInfo() { return {}; }
-  template <typename T = ChromeWindowHandleEventInfo> T* set_chrome_window_handle_event_info() {
-    return BeginNestedMessage<T>(41);
+  using ClientError = ::perfetto::protos::pbzero::ProfilePacket_ProcessHeapSamples_ClientError;
+  static inline const char* ClientError_Name(ClientError value) {
+    return ::perfetto::protos::pbzero::ProfilePacket_ProcessHeapSamples_ClientError_Name(value);
   }
+  static inline const ClientError CLIENT_ERROR_NONE = ClientError::CLIENT_ERROR_NONE;
+  static inline const ClientError CLIENT_ERROR_HIT_TIMEOUT = ClientError::CLIENT_ERROR_HIT_TIMEOUT;
+  static inline const ClientError CLIENT_ERROR_INVALID_STACK_BOUNDS = ClientError::CLIENT_ERROR_INVALID_STACK_BOUNDS;
 
-
-  using FieldMetadata_ChromeContentSettingsEventInfo =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
-      43,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeContentSettingsEventInfo,
-      TrackEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProfilePacket_ProcessHeapSamples>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeContentSettingsEventInfo kChromeContentSettingsEventInfo() { return {}; }
-  template <typename T = ChromeContentSettingsEventInfo> T* set_chrome_content_settings_event_info() {
-    return BeginNestedMessage<T>(43);
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_ChromeActiveProcesses =
+  using FieldMetadata_FromStartup =
     ::protozero::proto_utils::FieldMetadata<
-      49,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeActiveProcesses,
-      TrackEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ProfilePacket_ProcessHeapSamples>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeActiveProcesses kChromeActiveProcesses() { return {}; }
-  template <typename T = ChromeActiveProcesses> T* set_chrome_active_processes() {
-    return BeginNestedMessage<T>(49);
+  static constexpr FieldMetadata_FromStartup kFromStartup{};
+  void set_from_startup(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_FromStartup::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_SourceLocation =
+  using FieldMetadata_RejectedConcurrent =
     ::protozero::proto_utils::FieldMetadata<
-      33,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      SourceLocation,
-      TrackEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ProfilePacket_ProcessHeapSamples>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SourceLocation kSourceLocation() { return {}; }
-  template <typename T = SourceLocation> T* set_source_location() {
-    return BeginNestedMessage<T>(33);
+  static constexpr FieldMetadata_RejectedConcurrent kRejectedConcurrent{};
+  void set_rejected_concurrent(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_RejectedConcurrent::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_SourceLocationIid =
+  using FieldMetadata_Disconnected =
     ::protozero::proto_utils::FieldMetadata<
-      34,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TrackEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ProfilePacket_ProcessHeapSamples>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SourceLocationIid kSourceLocationIid() { return {}; }
-  void set_source_location_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SourceLocationIid::kFieldId;
+  static constexpr FieldMetadata_Disconnected kDisconnected{};
+  void set_disconnected(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_Disconnected::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ChromeMessagePump =
+  using FieldMetadata_BufferOverran =
     ::protozero::proto_utils::FieldMetadata<
-      35,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeMessagePump,
-      TrackEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ProfilePacket_ProcessHeapSamples>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeMessagePump kChromeMessagePump() { return {}; }
-  template <typename T = ChromeMessagePump> T* set_chrome_message_pump() {
-    return BeginNestedMessage<T>(35);
+  static constexpr FieldMetadata_BufferOverran kBufferOverran{};
+  void set_buffer_overran(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_BufferOverran::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_ChromeMojoEventInfo =
+  using FieldMetadata_ClientError =
     ::protozero::proto_utils::FieldMetadata<
-      38,
+      14,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeMojoEventInfo,
-      TrackEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ProfilePacket_ProcessHeapSamples_ClientError,
+      ProfilePacket_ProcessHeapSamples>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeMojoEventInfo kChromeMojoEventInfo() { return {}; }
-  template <typename T = ChromeMojoEventInfo> T* set_chrome_mojo_event_info() {
-    return BeginNestedMessage<T>(38);
+  static constexpr FieldMetadata_ClientError kClientError{};
+  void set_client_error(ProfilePacket_ProcessHeapSamples_ClientError value) {
+    static constexpr uint32_t field_id = FieldMetadata_ClientError::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_TimestampDeltaUs =
+  using FieldMetadata_BufferCorrupted =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TrackEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ProfilePacket_ProcessHeapSamples>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimestampDeltaUs kTimestampDeltaUs() { return {}; }
-  void set_timestamp_delta_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimestampDeltaUs::kFieldId;
+  static constexpr FieldMetadata_BufferCorrupted kBufferCorrupted{};
+  void set_buffer_corrupted(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_BufferCorrupted::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimestampAbsoluteUs =
+  using FieldMetadata_HitGuardrail =
     ::protozero::proto_utils::FieldMetadata<
-      16,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TrackEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ProfilePacket_ProcessHeapSamples>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimestampAbsoluteUs kTimestampAbsoluteUs() { return {}; }
-  void set_timestamp_absolute_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimestampAbsoluteUs::kFieldId;
+  static constexpr FieldMetadata_HitGuardrail kHitGuardrail{};
+  void set_hit_guardrail(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_HitGuardrail::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ThreadTimeDeltaUs =
+  using FieldMetadata_HeapName =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TrackEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ProfilePacket_ProcessHeapSamples>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThreadTimeDeltaUs kThreadTimeDeltaUs() { return {}; }
-  void set_thread_time_delta_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ThreadTimeDeltaUs::kFieldId;
+  static constexpr FieldMetadata_HeapName kHeapName{};
+  void set_heap_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_HeapName::kFieldId, data, size);
+  }
+  void set_heap_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size);
+  }
+  void set_heap_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ThreadTimeAbsoluteUs =
+  using FieldMetadata_SamplingIntervalBytes =
     ::protozero::proto_utils::FieldMetadata<
-      17,
+      12,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TrackEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProfilePacket_ProcessHeapSamples>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThreadTimeAbsoluteUs kThreadTimeAbsoluteUs() { return {}; }
-  void set_thread_time_absolute_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ThreadTimeAbsoluteUs::kFieldId;
+  static constexpr FieldMetadata_SamplingIntervalBytes kSamplingIntervalBytes{};
+  void set_sampling_interval_bytes(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SamplingIntervalBytes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ThreadInstructionCountDelta =
+  using FieldMetadata_OrigSamplingIntervalBytes =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      13,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TrackEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProfilePacket_ProcessHeapSamples>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThreadInstructionCountDelta kThreadInstructionCountDelta() { return {}; }
-  void set_thread_instruction_count_delta(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ThreadInstructionCountDelta::kFieldId;
+  static constexpr FieldMetadata_OrigSamplingIntervalBytes kOrigSamplingIntervalBytes{};
+  void set_orig_sampling_interval_bytes(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OrigSamplingIntervalBytes::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ThreadInstructionCountAbsolute =
+  using FieldMetadata_Timestamp =
     ::protozero::proto_utils::FieldMetadata<
-      20,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TrackEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProfilePacket_ProcessHeapSamples>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThreadInstructionCountAbsolute kThreadInstructionCountAbsolute() { return {}; }
-  void set_thread_instruction_count_absolute(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ThreadInstructionCountAbsolute::kFieldId;
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_LegacyEvent =
+  using FieldMetadata_Stats =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TrackEvent_LegacyEvent,
-      TrackEvent>;
+      ProfilePacket_ProcessStats,
+      ProfilePacket_ProcessHeapSamples>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LegacyEvent kLegacyEvent() { return {}; }
-  template <typename T = TrackEvent_LegacyEvent> T* set_legacy_event() {
-    return BeginNestedMessage<T>(6);
+  static constexpr FieldMetadata_Stats kStats{};
+  template <typename T = ProfilePacket_ProcessStats> T* set_stats() {
+    return BeginNestedMessage<T>(5);
+  }
+
+
+  using FieldMetadata_Samples =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ProfilePacket_HeapSample,
+      ProfilePacket_ProcessHeapSamples>;
+
+  static constexpr FieldMetadata_Samples kSamples{};
+  template <typename T = ProfilePacket_HeapSample> T* add_samples() {
+    return BeginNestedMessage<T>(2);
   }
 
 };
 
-class TrackEvent_LegacyEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/19, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class ProfilePacket_ProcessStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  TrackEvent_LegacyEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TrackEvent_LegacyEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TrackEvent_LegacyEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name_iid() const { return at<1>().valid(); }
-  uint64_t name_iid() const { return at<1>().as_uint64(); }
-  bool has_phase() const { return at<2>().valid(); }
-  int32_t phase() const { return at<2>().as_int32(); }
-  bool has_duration_us() const { return at<3>().valid(); }
-  int64_t duration_us() const { return at<3>().as_int64(); }
-  bool has_thread_duration_us() const { return at<4>().valid(); }
-  int64_t thread_duration_us() const { return at<4>().as_int64(); }
-  bool has_thread_instruction_delta() const { return at<15>().valid(); }
-  int64_t thread_instruction_delta() const { return at<15>().as_int64(); }
-  bool has_unscoped_id() const { return at<6>().valid(); }
-  uint64_t unscoped_id() const { return at<6>().as_uint64(); }
-  bool has_local_id() const { return at<10>().valid(); }
-  uint64_t local_id() const { return at<10>().as_uint64(); }
-  bool has_global_id() const { return at<11>().valid(); }
-  uint64_t global_id() const { return at<11>().as_uint64(); }
-  bool has_id_scope() const { return at<7>().valid(); }
-  ::protozero::ConstChars id_scope() const { return at<7>().as_string(); }
-  bool has_use_async_tts() const { return at<9>().valid(); }
-  bool use_async_tts() const { return at<9>().as_bool(); }
-  bool has_bind_id() const { return at<8>().valid(); }
-  uint64_t bind_id() const { return at<8>().as_uint64(); }
-  bool has_bind_to_enclosing() const { return at<12>().valid(); }
-  bool bind_to_enclosing() const { return at<12>().as_bool(); }
-  bool has_flow_direction() const { return at<13>().valid(); }
-  int32_t flow_direction() const { return at<13>().as_int32(); }
-  bool has_instant_event_scope() const { return at<14>().valid(); }
-  int32_t instant_event_scope() const { return at<14>().as_int32(); }
-  bool has_pid_override() const { return at<18>().valid(); }
-  int32_t pid_override() const { return at<18>().as_int32(); }
-  bool has_tid_override() const { return at<19>().valid(); }
-  int32_t tid_override() const { return at<19>().as_int32(); }
+  ProfilePacket_ProcessStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProfilePacket_ProcessStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProfilePacket_ProcessStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_unwinding_errors() const { return at<1>().valid(); }
+  uint64_t unwinding_errors() const { return at<1>().as_uint64(); }
+  bool has_heap_samples() const { return at<2>().valid(); }
+  uint64_t heap_samples() const { return at<2>().as_uint64(); }
+  bool has_map_reparses() const { return at<3>().valid(); }
+  uint64_t map_reparses() const { return at<3>().as_uint64(); }
+  bool has_unwinding_time_us() const { return at<4>().valid(); }
+  ::protozero::ConstBytes unwinding_time_us() const { return at<4>().as_bytes(); }
+  bool has_total_unwinding_time_us() const { return at<5>().valid(); }
+  uint64_t total_unwinding_time_us() const { return at<5>().as_uint64(); }
+  bool has_client_spinlock_blocked_us() const { return at<6>().valid(); }
+  uint64_t client_spinlock_blocked_us() const { return at<6>().as_uint64(); }
 };
 
-class TrackEvent_LegacyEvent : public ::protozero::Message {
+class ProfilePacket_ProcessStats : public ::protozero::Message {
  public:
-  using Decoder = TrackEvent_LegacyEvent_Decoder;
+  using Decoder = ProfilePacket_ProcessStats_Decoder;
   enum : int32_t {
-    kNameIidFieldNumber = 1,
-    kPhaseFieldNumber = 2,
-    kDurationUsFieldNumber = 3,
-    kThreadDurationUsFieldNumber = 4,
-    kThreadInstructionDeltaFieldNumber = 15,
-    kUnscopedIdFieldNumber = 6,
-    kLocalIdFieldNumber = 10,
-    kGlobalIdFieldNumber = 11,
-    kIdScopeFieldNumber = 7,
-    kUseAsyncTtsFieldNumber = 9,
-    kBindIdFieldNumber = 8,
-    kBindToEnclosingFieldNumber = 12,
-    kFlowDirectionFieldNumber = 13,
-    kInstantEventScopeFieldNumber = 14,
-    kPidOverrideFieldNumber = 18,
-    kTidOverrideFieldNumber = 19,
+    kUnwindingErrorsFieldNumber = 1,
+    kHeapSamplesFieldNumber = 2,
+    kMapReparsesFieldNumber = 3,
+    kUnwindingTimeUsFieldNumber = 4,
+    kTotalUnwindingTimeUsFieldNumber = 5,
+    kClientSpinlockBlockedUsFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TrackEvent.LegacyEvent"; }
-
-
-  using FlowDirection = ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_FlowDirection;
-  static inline const char* FlowDirection_Name(FlowDirection value) {
-    return ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_FlowDirection_Name(value);
-  }
+  static constexpr const char* GetName() { return ".perfetto.protos.ProfilePacket.ProcessStats"; }
 
-  using InstantEventScope = ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_InstantEventScope;
-  static inline const char* InstantEventScope_Name(InstantEventScope value) {
-    return ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_InstantEventScope_Name(value);
-  }
-  static const FlowDirection FLOW_UNSPECIFIED = FlowDirection::FLOW_UNSPECIFIED;
-  static const FlowDirection FLOW_IN = FlowDirection::FLOW_IN;
-  static const FlowDirection FLOW_OUT = FlowDirection::FLOW_OUT;
-  static const FlowDirection FLOW_INOUT = FlowDirection::FLOW_INOUT;
-  static const InstantEventScope SCOPE_UNSPECIFIED = InstantEventScope::SCOPE_UNSPECIFIED;
-  static const InstantEventScope SCOPE_GLOBAL = InstantEventScope::SCOPE_GLOBAL;
-  static const InstantEventScope SCOPE_PROCESS = InstantEventScope::SCOPE_PROCESS;
-  static const InstantEventScope SCOPE_THREAD = InstantEventScope::SCOPE_THREAD;
 
-  using FieldMetadata_NameIid =
+  using FieldMetadata_UnwindingErrors =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TrackEvent_LegacyEvent>;
+      ProfilePacket_ProcessStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NameIid kNameIid() { return {}; }
-  void set_name_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NameIid::kFieldId;
+  static constexpr FieldMetadata_UnwindingErrors kUnwindingErrors{};
+  void set_unwinding_errors(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_UnwindingErrors::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -151816,149 +172838,162 @@ class TrackEvent_LegacyEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Phase =
+  using FieldMetadata_HeapSamples =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TrackEvent_LegacyEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProfilePacket_ProcessStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Phase kPhase() { return {}; }
-  void set_phase(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Phase::kFieldId;
+  static constexpr FieldMetadata_HeapSamples kHeapSamples{};
+  void set_heap_samples(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_HeapSamples::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DurationUs =
+  using FieldMetadata_MapReparses =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TrackEvent_LegacyEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProfilePacket_ProcessStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DurationUs kDurationUs() { return {}; }
-  void set_duration_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DurationUs::kFieldId;
+  static constexpr FieldMetadata_MapReparses kMapReparses{};
+  void set_map_reparses(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MapReparses::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ThreadDurationUs =
+  using FieldMetadata_UnwindingTimeUs =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TrackEvent_LegacyEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ProfilePacket_Histogram,
+      ProfilePacket_ProcessStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThreadDurationUs kThreadDurationUs() { return {}; }
-  void set_thread_duration_us(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ThreadDurationUs::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_UnwindingTimeUs kUnwindingTimeUs{};
+  template <typename T = ProfilePacket_Histogram> T* set_unwinding_time_us() {
+    return BeginNestedMessage<T>(4);
   }
 
-  using FieldMetadata_ThreadInstructionDelta =
+
+  using FieldMetadata_TotalUnwindingTimeUs =
     ::protozero::proto_utils::FieldMetadata<
-      15,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      TrackEvent_LegacyEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProfilePacket_ProcessStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThreadInstructionDelta kThreadInstructionDelta() { return {}; }
-  void set_thread_instruction_delta(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ThreadInstructionDelta::kFieldId;
+  static constexpr FieldMetadata_TotalUnwindingTimeUs kTotalUnwindingTimeUs{};
+  void set_total_unwinding_time_us(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TotalUnwindingTimeUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_UnscopedId =
+  using FieldMetadata_ClientSpinlockBlockedUs =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TrackEvent_LegacyEvent>;
+      ProfilePacket_ProcessStats>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UnscopedId kUnscopedId() { return {}; }
-  void set_unscoped_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_UnscopedId::kFieldId;
+  static constexpr FieldMetadata_ClientSpinlockBlockedUs kClientSpinlockBlockedUs{};
+  void set_client_spinlock_blocked_us(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ClientSpinlockBlockedUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_LocalId =
+class ProfilePacket_Histogram_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  ProfilePacket_Histogram_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProfilePacket_Histogram_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProfilePacket_Histogram_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_buckets() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> buckets() const { return GetRepeated<::protozero::ConstBytes>(1); }
+};
+
+class ProfilePacket_Histogram : public ::protozero::Message {
+ public:
+  using Decoder = ProfilePacket_Histogram_Decoder;
+  enum : int32_t {
+    kBucketsFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ProfilePacket.Histogram"; }
+
+  using Bucket = ::perfetto::protos::pbzero::ProfilePacket_Histogram_Bucket;
+
+  using FieldMetadata_Buckets =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ProfilePacket_Histogram_Bucket,
+      ProfilePacket_Histogram>;
+
+  static constexpr FieldMetadata_Buckets kBuckets{};
+  template <typename T = ProfilePacket_Histogram_Bucket> T* add_buckets() {
+    return BeginNestedMessage<T>(1);
+  }
+
+};
+
+class ProfilePacket_Histogram_Bucket_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  ProfilePacket_Histogram_Bucket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProfilePacket_Histogram_Bucket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProfilePacket_Histogram_Bucket_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_upper_limit() const { return at<1>().valid(); }
+  uint64_t upper_limit() const { return at<1>().as_uint64(); }
+  bool has_max_bucket() const { return at<2>().valid(); }
+  bool max_bucket() const { return at<2>().as_bool(); }
+  bool has_count() const { return at<3>().valid(); }
+  uint64_t count() const { return at<3>().as_uint64(); }
+};
+
+class ProfilePacket_Histogram_Bucket : public ::protozero::Message {
+ public:
+  using Decoder = ProfilePacket_Histogram_Bucket_Decoder;
+  enum : int32_t {
+    kUpperLimitFieldNumber = 1,
+    kMaxBucketFieldNumber = 2,
+    kCountFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ProfilePacket.Histogram.Bucket"; }
+
+
+  using FieldMetadata_UpperLimit =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TrackEvent_LegacyEvent>;
+      ProfilePacket_Histogram_Bucket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LocalId kLocalId() { return {}; }
-  void set_local_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LocalId::kFieldId;
+  static constexpr FieldMetadata_UpperLimit kUpperLimit{};
+  void set_upper_limit(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_UpperLimit::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -151966,105 +173001,129 @@ class TrackEvent_LegacyEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_GlobalId =
+  using FieldMetadata_MaxBucket =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ProfilePacket_Histogram_Bucket>;
+
+  static constexpr FieldMetadata_MaxBucket kMaxBucket{};
+  void set_max_bucket(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_MaxBucket::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Count =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TrackEvent_LegacyEvent>;
+      ProfilePacket_Histogram_Bucket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GlobalId kGlobalId() { return {}; }
-  void set_global_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GlobalId::kFieldId;
+  static constexpr FieldMetadata_Count kCount{};
+  void set_count(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_IdScope =
+class ProfilePacket_HeapSample_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9> {
+ public:
+  ProfilePacket_HeapSample_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProfilePacket_HeapSample_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProfilePacket_HeapSample_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_callstack_id() const { return at<1>().valid(); }
+  uint64_t callstack_id() const { return at<1>().as_uint64(); }
+  bool has_self_allocated() const { return at<2>().valid(); }
+  uint64_t self_allocated() const { return at<2>().as_uint64(); }
+  bool has_self_freed() const { return at<3>().valid(); }
+  uint64_t self_freed() const { return at<3>().as_uint64(); }
+  bool has_self_max() const { return at<8>().valid(); }
+  uint64_t self_max() const { return at<8>().as_uint64(); }
+  bool has_self_max_count() const { return at<9>().valid(); }
+  uint64_t self_max_count() const { return at<9>().as_uint64(); }
+  bool has_timestamp() const { return at<4>().valid(); }
+  uint64_t timestamp() const { return at<4>().as_uint64(); }
+  bool has_alloc_count() const { return at<5>().valid(); }
+  uint64_t alloc_count() const { return at<5>().as_uint64(); }
+  bool has_free_count() const { return at<6>().valid(); }
+  uint64_t free_count() const { return at<6>().as_uint64(); }
+};
+
+class ProfilePacket_HeapSample : public ::protozero::Message {
+ public:
+  using Decoder = ProfilePacket_HeapSample_Decoder;
+  enum : int32_t {
+    kCallstackIdFieldNumber = 1,
+    kSelfAllocatedFieldNumber = 2,
+    kSelfFreedFieldNumber = 3,
+    kSelfMaxFieldNumber = 8,
+    kSelfMaxCountFieldNumber = 9,
+    kTimestampFieldNumber = 4,
+    kAllocCountFieldNumber = 5,
+    kFreeCountFieldNumber = 6,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ProfilePacket.HeapSample"; }
+
+
+  using FieldMetadata_CallstackId =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TrackEvent_LegacyEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProfilePacket_HeapSample>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IdScope kIdScope() { return {}; }
-  void set_id_scope(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_IdScope::kFieldId, data, size);
-  }
-  void set_id_scope(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_IdScope::kFieldId, chars.data, chars.size);
-  }
-  void set_id_scope(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_IdScope::kFieldId;
+  static constexpr FieldMetadata_CallstackId kCallstackId{};
+  void set_callstack_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CallstackId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_UseAsyncTts =
+  using FieldMetadata_SelfAllocated =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TrackEvent_LegacyEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProfilePacket_HeapSample>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UseAsyncTts kUseAsyncTts() { return {}; }
-  void set_use_async_tts(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_UseAsyncTts::kFieldId;
+  static constexpr FieldMetadata_SelfAllocated kSelfAllocated{};
+  void set_self_allocated(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SelfAllocated::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BindId =
+  using FieldMetadata_SelfFreed =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      TrackEvent_LegacyEvent>;
+      ProfilePacket_HeapSample>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BindId kBindId() { return {}; }
-  void set_bind_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_BindId::kFieldId;
+  static constexpr FieldMetadata_SelfFreed kSelfFreed{};
+  void set_self_freed(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SelfFreed::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -152072,128 +173131,93 @@ class TrackEvent_LegacyEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_BindToEnclosing =
+  using FieldMetadata_SelfMax =
     ::protozero::proto_utils::FieldMetadata<
-      12,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TrackEvent_LegacyEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProfilePacket_HeapSample>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BindToEnclosing kBindToEnclosing() { return {}; }
-  void set_bind_to_enclosing(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_BindToEnclosing::kFieldId;
+  static constexpr FieldMetadata_SelfMax kSelfMax{};
+  void set_self_max(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SelfMax::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FlowDirection =
+  using FieldMetadata_SelfMaxCount =
     ::protozero::proto_utils::FieldMetadata<
-      13,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_FlowDirection,
-      TrackEvent_LegacyEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProfilePacket_HeapSample>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FlowDirection kFlowDirection() { return {}; }
-  void set_flow_direction(::perfetto::protos::pbzero::TrackEvent_LegacyEvent_FlowDirection value) {
-    static constexpr uint32_t field_id = FieldMetadata_FlowDirection::kFieldId;
+  static constexpr FieldMetadata_SelfMaxCount kSelfMaxCount{};
+  void set_self_max_count(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SelfMaxCount::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_InstantEventScope =
+  using FieldMetadata_Timestamp =
     ::protozero::proto_utils::FieldMetadata<
-      14,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_InstantEventScope,
-      TrackEvent_LegacyEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProfilePacket_HeapSample>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InstantEventScope kInstantEventScope() { return {}; }
-  void set_instant_event_scope(::perfetto::protos::pbzero::TrackEvent_LegacyEvent_InstantEventScope value) {
-    static constexpr uint32_t field_id = FieldMetadata_InstantEventScope::kFieldId;
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PidOverride =
+  using FieldMetadata_AllocCount =
     ::protozero::proto_utils::FieldMetadata<
-      18,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TrackEvent_LegacyEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProfilePacket_HeapSample>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PidOverride kPidOverride() { return {}; }
-  void set_pid_override(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_PidOverride::kFieldId;
+  static constexpr FieldMetadata_AllocCount kAllocCount{};
+  void set_alloc_count(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_AllocCount::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TidOverride =
+  using FieldMetadata_FreeCount =
     ::protozero::proto_utils::FieldMetadata<
-      19,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TrackEvent_LegacyEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProfilePacket_HeapSample>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TidOverride kTidOverride() { return {}; }
-  void set_tid_override(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TidOverride::kFieldId;
+  static constexpr FieldMetadata_FreeCount kFreeCount{};
+  void set_free_count(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FreeCount::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
@@ -152202,11 +173226,11 @@ class TrackEvent_LegacyEvent : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/interned_data/interned_data.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/profiling/smaps.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_INTERNED_DATA_INTERNED_DATA_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_INTERNED_DATA_INTERNED_DATA_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_SMAPS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_SMAPS_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -152220,718 +173244,200 @@ class TrackEvent_LegacyEvent : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
+class SmapsEntry;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-class Callstack;
-class DebugAnnotationName;
-class DebugAnnotationValueTypeName;
-class EventCategory;
-class EventName;
-class Frame;
-class HistogramName;
-class InternedGpuRenderStageSpecification;
-class InternedGraphicsContext;
-class InternedString;
-class LogMessageBody;
-class Mapping;
-class ProfiledFrameSymbols;
-class SourceLocation;
-class UnsymbolizedSourceLocation;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-class InternedData_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/29, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class SmapsPacket_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  InternedData_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit InternedData_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit InternedData_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_event_categories() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> event_categories() const { return GetRepeated<::protozero::ConstBytes>(1); }
-  bool has_event_names() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> event_names() const { return GetRepeated<::protozero::ConstBytes>(2); }
-  bool has_debug_annotation_names() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> debug_annotation_names() const { return GetRepeated<::protozero::ConstBytes>(3); }
-  bool has_debug_annotation_value_type_names() const { return at<27>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> debug_annotation_value_type_names() const { return GetRepeated<::protozero::ConstBytes>(27); }
-  bool has_source_locations() const { return at<4>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> source_locations() const { return GetRepeated<::protozero::ConstBytes>(4); }
-  bool has_unsymbolized_source_locations() const { return at<28>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> unsymbolized_source_locations() const { return GetRepeated<::protozero::ConstBytes>(28); }
-  bool has_log_message_body() const { return at<20>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> log_message_body() const { return GetRepeated<::protozero::ConstBytes>(20); }
-  bool has_histogram_names() const { return at<25>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> histogram_names() const { return GetRepeated<::protozero::ConstBytes>(25); }
-  bool has_build_ids() const { return at<16>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> build_ids() const { return GetRepeated<::protozero::ConstBytes>(16); }
-  bool has_mapping_paths() const { return at<17>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> mapping_paths() const { return GetRepeated<::protozero::ConstBytes>(17); }
-  bool has_source_paths() const { return at<18>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> source_paths() const { return GetRepeated<::protozero::ConstBytes>(18); }
-  bool has_function_names() const { return at<5>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> function_names() const { return GetRepeated<::protozero::ConstBytes>(5); }
-  bool has_profiled_frame_symbols() const { return at<21>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> profiled_frame_symbols() const { return GetRepeated<::protozero::ConstBytes>(21); }
-  bool has_mappings() const { return at<19>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> mappings() const { return GetRepeated<::protozero::ConstBytes>(19); }
-  bool has_frames() const { return at<6>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> frames() const { return GetRepeated<::protozero::ConstBytes>(6); }
-  bool has_callstacks() const { return at<7>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> callstacks() const { return GetRepeated<::protozero::ConstBytes>(7); }
-  bool has_vulkan_memory_keys() const { return at<22>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> vulkan_memory_keys() const { return GetRepeated<::protozero::ConstBytes>(22); }
-  bool has_graphics_contexts() const { return at<23>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> graphics_contexts() const { return GetRepeated<::protozero::ConstBytes>(23); }
-  bool has_gpu_specifications() const { return at<24>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> gpu_specifications() const { return GetRepeated<::protozero::ConstBytes>(24); }
-  bool has_kernel_symbols() const { return at<26>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> kernel_symbols() const { return GetRepeated<::protozero::ConstBytes>(26); }
-  bool has_debug_annotation_string_values() const { return at<29>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> debug_annotation_string_values() const { return GetRepeated<::protozero::ConstBytes>(29); }
+  SmapsPacket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SmapsPacket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SmapsPacket_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  uint32_t pid() const { return at<1>().as_uint32(); }
+  bool has_entries() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> entries() const { return GetRepeated<::protozero::ConstBytes>(2); }
 };
 
-class InternedData : public ::protozero::Message {
+class SmapsPacket : public ::protozero::Message {
  public:
-  using Decoder = InternedData_Decoder;
+  using Decoder = SmapsPacket_Decoder;
   enum : int32_t {
-    kEventCategoriesFieldNumber = 1,
-    kEventNamesFieldNumber = 2,
-    kDebugAnnotationNamesFieldNumber = 3,
-    kDebugAnnotationValueTypeNamesFieldNumber = 27,
-    kSourceLocationsFieldNumber = 4,
-    kUnsymbolizedSourceLocationsFieldNumber = 28,
-    kLogMessageBodyFieldNumber = 20,
-    kHistogramNamesFieldNumber = 25,
-    kBuildIdsFieldNumber = 16,
-    kMappingPathsFieldNumber = 17,
-    kSourcePathsFieldNumber = 18,
-    kFunctionNamesFieldNumber = 5,
-    kProfiledFrameSymbolsFieldNumber = 21,
-    kMappingsFieldNumber = 19,
-    kFramesFieldNumber = 6,
-    kCallstacksFieldNumber = 7,
-    kVulkanMemoryKeysFieldNumber = 22,
-    kGraphicsContextsFieldNumber = 23,
-    kGpuSpecificationsFieldNumber = 24,
-    kKernelSymbolsFieldNumber = 26,
-    kDebugAnnotationStringValuesFieldNumber = 29,
+    kPidFieldNumber = 1,
+    kEntriesFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.InternedData"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.SmapsPacket"; }
 
 
-  using FieldMetadata_EventCategories =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
       1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      EventCategory,
-      InternedData>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SmapsPacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EventCategories kEventCategories() { return {}; }
-  template <typename T = EventCategory> T* add_event_categories() {
-    return BeginNestedMessage<T>(1);
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_EventNames =
+  using FieldMetadata_Entries =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      EventName,
-      InternedData>;
+      SmapsEntry,
+      SmapsPacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EventNames kEventNames() { return {}; }
-  template <typename T = EventName> T* add_event_names() {
+  static constexpr FieldMetadata_Entries kEntries{};
+  template <typename T = SmapsEntry> T* add_entries() {
     return BeginNestedMessage<T>(2);
   }
 
-
-  using FieldMetadata_DebugAnnotationNames =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      DebugAnnotationName,
-      InternedData>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DebugAnnotationNames kDebugAnnotationNames() { return {}; }
-  template <typename T = DebugAnnotationName> T* add_debug_annotation_names() {
-    return BeginNestedMessage<T>(3);
-  }
-
-
-  using FieldMetadata_DebugAnnotationValueTypeNames =
-    ::protozero::proto_utils::FieldMetadata<
-      27,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      DebugAnnotationValueTypeName,
-      InternedData>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DebugAnnotationValueTypeNames kDebugAnnotationValueTypeNames() { return {}; }
-  template <typename T = DebugAnnotationValueTypeName> T* add_debug_annotation_value_type_names() {
-    return BeginNestedMessage<T>(27);
-  }
-
-
-  using FieldMetadata_SourceLocations =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      SourceLocation,
-      InternedData>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SourceLocations kSourceLocations() { return {}; }
-  template <typename T = SourceLocation> T* add_source_locations() {
-    return BeginNestedMessage<T>(4);
-  }
-
-
-  using FieldMetadata_UnsymbolizedSourceLocations =
-    ::protozero::proto_utils::FieldMetadata<
-      28,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      UnsymbolizedSourceLocation,
-      InternedData>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UnsymbolizedSourceLocations kUnsymbolizedSourceLocations() { return {}; }
-  template <typename T = UnsymbolizedSourceLocation> T* add_unsymbolized_source_locations() {
-    return BeginNestedMessage<T>(28);
-  }
-
-
-  using FieldMetadata_LogMessageBody =
-    ::protozero::proto_utils::FieldMetadata<
-      20,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      LogMessageBody,
-      InternedData>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LogMessageBody kLogMessageBody() { return {}; }
-  template <typename T = LogMessageBody> T* add_log_message_body() {
-    return BeginNestedMessage<T>(20);
-  }
-
-
-  using FieldMetadata_HistogramNames =
-    ::protozero::proto_utils::FieldMetadata<
-      25,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      HistogramName,
-      InternedData>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HistogramNames kHistogramNames() { return {}; }
-  template <typename T = HistogramName> T* add_histogram_names() {
-    return BeginNestedMessage<T>(25);
-  }
-
-
-  using FieldMetadata_BuildIds =
-    ::protozero::proto_utils::FieldMetadata<
-      16,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      InternedString,
-      InternedData>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BuildIds kBuildIds() { return {}; }
-  template <typename T = InternedString> T* add_build_ids() {
-    return BeginNestedMessage<T>(16);
-  }
-
-
-  using FieldMetadata_MappingPaths =
-    ::protozero::proto_utils::FieldMetadata<
-      17,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      InternedString,
-      InternedData>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MappingPaths kMappingPaths() { return {}; }
-  template <typename T = InternedString> T* add_mapping_paths() {
-    return BeginNestedMessage<T>(17);
-  }
-
-
-  using FieldMetadata_SourcePaths =
-    ::protozero::proto_utils::FieldMetadata<
-      18,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      InternedString,
-      InternedData>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SourcePaths kSourcePaths() { return {}; }
-  template <typename T = InternedString> T* add_source_paths() {
-    return BeginNestedMessage<T>(18);
-  }
-
-
-  using FieldMetadata_FunctionNames =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      InternedString,
-      InternedData>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FunctionNames kFunctionNames() { return {}; }
-  template <typename T = InternedString> T* add_function_names() {
-    return BeginNestedMessage<T>(5);
-  }
-
-
-  using FieldMetadata_ProfiledFrameSymbols =
-    ::protozero::proto_utils::FieldMetadata<
-      21,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ProfiledFrameSymbols,
-      InternedData>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProfiledFrameSymbols kProfiledFrameSymbols() { return {}; }
-  template <typename T = ProfiledFrameSymbols> T* add_profiled_frame_symbols() {
-    return BeginNestedMessage<T>(21);
-  }
-
-
-  using FieldMetadata_Mappings =
-    ::protozero::proto_utils::FieldMetadata<
-      19,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      Mapping,
-      InternedData>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Mappings kMappings() { return {}; }
-  template <typename T = Mapping> T* add_mappings() {
-    return BeginNestedMessage<T>(19);
-  }
-
-
-  using FieldMetadata_Frames =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      Frame,
-      InternedData>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Frames kFrames() { return {}; }
-  template <typename T = Frame> T* add_frames() {
-    return BeginNestedMessage<T>(6);
-  }
-
-
-  using FieldMetadata_Callstacks =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      Callstack,
-      InternedData>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Callstacks kCallstacks() { return {}; }
-  template <typename T = Callstack> T* add_callstacks() {
-    return BeginNestedMessage<T>(7);
-  }
-
-
-  using FieldMetadata_VulkanMemoryKeys =
-    ::protozero::proto_utils::FieldMetadata<
-      22,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      InternedString,
-      InternedData>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VulkanMemoryKeys kVulkanMemoryKeys() { return {}; }
-  template <typename T = InternedString> T* add_vulkan_memory_keys() {
-    return BeginNestedMessage<T>(22);
-  }
-
-
-  using FieldMetadata_GraphicsContexts =
-    ::protozero::proto_utils::FieldMetadata<
-      23,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      InternedGraphicsContext,
-      InternedData>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GraphicsContexts kGraphicsContexts() { return {}; }
-  template <typename T = InternedGraphicsContext> T* add_graphics_contexts() {
-    return BeginNestedMessage<T>(23);
-  }
-
-
-  using FieldMetadata_GpuSpecifications =
-    ::protozero::proto_utils::FieldMetadata<
-      24,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      InternedGpuRenderStageSpecification,
-      InternedData>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GpuSpecifications kGpuSpecifications() { return {}; }
-  template <typename T = InternedGpuRenderStageSpecification> T* add_gpu_specifications() {
-    return BeginNestedMessage<T>(24);
-  }
-
-
-  using FieldMetadata_KernelSymbols =
-    ::protozero::proto_utils::FieldMetadata<
-      26,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      InternedString,
-      InternedData>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KernelSymbols kKernelSymbols() { return {}; }
-  template <typename T = InternedString> T* add_kernel_symbols() {
-    return BeginNestedMessage<T>(26);
-  }
-
-
-  using FieldMetadata_DebugAnnotationStringValues =
-    ::protozero::proto_utils::FieldMetadata<
-      29,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      InternedString,
-      InternedData>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DebugAnnotationStringValues kDebugAnnotationStringValues() { return {}; }
-  template <typename T = InternedString> T* add_debug_annotation_string_values() {
-    return BeginNestedMessage<T>(29);
-  }
-
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/perfetto/perfetto_metatrace.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PERFETTO_PERFETTO_METATRACE_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PERFETTO_PERFETTO_METATRACE_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-class PerfettoMetatrace_Arg;
-class PerfettoMetatrace_InternedString;
-
-class PerfettoMetatrace_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class SmapsEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/15> {
  public:
-  PerfettoMetatrace_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit PerfettoMetatrace_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit PerfettoMetatrace_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_event_id() const { return at<1>().valid(); }
-  uint32_t event_id() const { return at<1>().as_uint32(); }
-  bool has_counter_id() const { return at<2>().valid(); }
-  uint32_t counter_id() const { return at<2>().as_uint32(); }
-  bool has_event_name() const { return at<8>().valid(); }
-  ::protozero::ConstChars event_name() const { return at<8>().as_string(); }
-  bool has_event_name_iid() const { return at<11>().valid(); }
-  uint64_t event_name_iid() const { return at<11>().as_uint64(); }
-  bool has_counter_name() const { return at<9>().valid(); }
-  ::protozero::ConstChars counter_name() const { return at<9>().as_string(); }
-  bool has_event_duration_ns() const { return at<3>().valid(); }
-  uint64_t event_duration_ns() const { return at<3>().as_uint64(); }
-  bool has_counter_value() const { return at<4>().valid(); }
-  int32_t counter_value() const { return at<4>().as_int32(); }
-  bool has_thread_id() const { return at<5>().valid(); }
-  uint32_t thread_id() const { return at<5>().as_uint32(); }
-  bool has_has_overruns() const { return at<6>().valid(); }
-  bool has_overruns() const { return at<6>().as_bool(); }
-  bool has_args() const { return at<7>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> args() const { return GetRepeated<::protozero::ConstBytes>(7); }
-  bool has_interned_strings() const { return at<10>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> interned_strings() const { return GetRepeated<::protozero::ConstBytes>(10); }
+  SmapsEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SmapsEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SmapsEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_path() const { return at<1>().valid(); }
+  ::protozero::ConstChars path() const { return at<1>().as_string(); }
+  bool has_size_kb() const { return at<2>().valid(); }
+  uint64_t size_kb() const { return at<2>().as_uint64(); }
+  bool has_private_dirty_kb() const { return at<3>().valid(); }
+  uint64_t private_dirty_kb() const { return at<3>().as_uint64(); }
+  bool has_swap_kb() const { return at<4>().valid(); }
+  uint64_t swap_kb() const { return at<4>().as_uint64(); }
+  bool has_file_name() const { return at<5>().valid(); }
+  ::protozero::ConstChars file_name() const { return at<5>().as_string(); }
+  bool has_start_address() const { return at<6>().valid(); }
+  uint64_t start_address() const { return at<6>().as_uint64(); }
+  bool has_module_timestamp() const { return at<7>().valid(); }
+  uint64_t module_timestamp() const { return at<7>().as_uint64(); }
+  bool has_module_debugid() const { return at<8>().valid(); }
+  ::protozero::ConstChars module_debugid() const { return at<8>().as_string(); }
+  bool has_module_debug_path() const { return at<9>().valid(); }
+  ::protozero::ConstChars module_debug_path() const { return at<9>().as_string(); }
+  bool has_protection_flags() const { return at<10>().valid(); }
+  uint32_t protection_flags() const { return at<10>().as_uint32(); }
+  bool has_private_clean_resident_kb() const { return at<11>().valid(); }
+  uint64_t private_clean_resident_kb() const { return at<11>().as_uint64(); }
+  bool has_shared_dirty_resident_kb() const { return at<12>().valid(); }
+  uint64_t shared_dirty_resident_kb() const { return at<12>().as_uint64(); }
+  bool has_shared_clean_resident_kb() const { return at<13>().valid(); }
+  uint64_t shared_clean_resident_kb() const { return at<13>().as_uint64(); }
+  bool has_locked_kb() const { return at<14>().valid(); }
+  uint64_t locked_kb() const { return at<14>().as_uint64(); }
+  bool has_proportional_resident_kb() const { return at<15>().valid(); }
+  uint64_t proportional_resident_kb() const { return at<15>().as_uint64(); }
 };
 
-class PerfettoMetatrace : public ::protozero::Message {
+class SmapsEntry : public ::protozero::Message {
  public:
-  using Decoder = PerfettoMetatrace_Decoder;
+  using Decoder = SmapsEntry_Decoder;
   enum : int32_t {
-    kEventIdFieldNumber = 1,
-    kCounterIdFieldNumber = 2,
-    kEventNameFieldNumber = 8,
-    kEventNameIidFieldNumber = 11,
-    kCounterNameFieldNumber = 9,
-    kEventDurationNsFieldNumber = 3,
-    kCounterValueFieldNumber = 4,
-    kThreadIdFieldNumber = 5,
-    kHasOverrunsFieldNumber = 6,
-    kArgsFieldNumber = 7,
-    kInternedStringsFieldNumber = 10,
+    kPathFieldNumber = 1,
+    kSizeKbFieldNumber = 2,
+    kPrivateDirtyKbFieldNumber = 3,
+    kSwapKbFieldNumber = 4,
+    kFileNameFieldNumber = 5,
+    kStartAddressFieldNumber = 6,
+    kModuleTimestampFieldNumber = 7,
+    kModuleDebugidFieldNumber = 8,
+    kModuleDebugPathFieldNumber = 9,
+    kProtectionFlagsFieldNumber = 10,
+    kPrivateCleanResidentKbFieldNumber = 11,
+    kSharedDirtyResidentKbFieldNumber = 12,
+    kSharedCleanResidentKbFieldNumber = 13,
+    kLockedKbFieldNumber = 14,
+    kProportionalResidentKbFieldNumber = 15,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.PerfettoMetatrace"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.SmapsEntry"; }
 
-  using Arg = ::perfetto::protos::pbzero::PerfettoMetatrace_Arg;
-  using InternedString = ::perfetto::protos::pbzero::PerfettoMetatrace_InternedString;
 
-  using FieldMetadata_EventId =
+  using FieldMetadata_Path =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      PerfettoMetatrace>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SmapsEntry>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EventId kEventId() { return {}; }
-  void set_event_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EventId::kFieldId;
+  static constexpr FieldMetadata_Path kPath{};
+  void set_path(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Path::kFieldId, data, size);
+  }
+  void set_path(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Path::kFieldId, chars.data, chars.size);
+  }
+  void set_path(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Path::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CounterId =
+  using FieldMetadata_SizeKb =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      PerfettoMetatrace>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SmapsEntry>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CounterId kCounterId() { return {}; }
-  void set_counter_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CounterId::kFieldId;
+  static constexpr FieldMetadata_SizeKb kSizeKb{};
+  void set_size_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SizeKb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_EventName =
+  using FieldMetadata_PrivateDirtyKb =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      PerfettoMetatrace>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SmapsEntry>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EventName kEventName() { return {}; }
-  void set_event_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_EventName::kFieldId, data, size);
-  }
-  void set_event_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_EventName::kFieldId, chars.data, chars.size);
-  }
-  void set_event_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_EventName::kFieldId;
+  static constexpr FieldMetadata_PrivateDirtyKb kPrivateDirtyKb{};
+  void set_private_dirty_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PrivateDirtyKb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_EventNameIid =
+  using FieldMetadata_SwapKb =
     ::protozero::proto_utils::FieldMetadata<
-      11,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      PerfettoMetatrace>;
+      SmapsEntry>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EventNameIid kEventNameIid() { return {}; }
-  void set_event_name_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EventNameIid::kFieldId;
+  static constexpr FieldMetadata_SwapKb kSwapKb{};
+  void set_swap_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SwapKb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -152939,30 +173445,23 @@ class PerfettoMetatrace : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CounterName =
+  using FieldMetadata_FileName =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      PerfettoMetatrace>;
+      SmapsEntry>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CounterName kCounterName() { return {}; }
-  void set_counter_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_CounterName::kFieldId, data, size);
+  static constexpr FieldMetadata_FileName kFileName{};
+  void set_file_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_FileName::kFieldId, data, size);
   }
-  void set_counter_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_CounterName::kFieldId, chars.data, chars.size);
+  void set_file_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_FileName::kFieldId, chars.data, chars.size);
   }
-  void set_counter_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_CounterName::kFieldId;
+  void set_file_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_FileName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -152970,24 +173469,17 @@ class PerfettoMetatrace : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_EventDurationNs =
+  using FieldMetadata_StartAddress =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      PerfettoMetatrace>;
+      SmapsEntry>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EventDurationNs kEventDurationNs() { return {}; }
-  void set_event_duration_ns(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EventDurationNs::kFieldId;
+  static constexpr FieldMetadata_StartAddress kStartAddress{};
+  void set_start_address(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StartAddress::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -152995,278 +173487,119 @@ class PerfettoMetatrace : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CounterValue =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      PerfettoMetatrace>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CounterValue kCounterValue() { return {}; }
-  void set_counter_value(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CounterValue::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ThreadId =
+  using FieldMetadata_ModuleTimestamp =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      PerfettoMetatrace>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SmapsEntry>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThreadId kThreadId() { return {}; }
-  void set_thread_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ThreadId::kFieldId;
+  static constexpr FieldMetadata_ModuleTimestamp kModuleTimestamp{};
+  void set_module_timestamp(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ModuleTimestamp::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_HasOverruns =
+  using FieldMetadata_ModuleDebugid =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      PerfettoMetatrace>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HasOverruns kHasOverruns() { return {}; }
-  void set_has_overruns(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_HasOverruns::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Args =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      PerfettoMetatrace_Arg,
-      PerfettoMetatrace>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Args kArgs() { return {}; }
-  template <typename T = PerfettoMetatrace_Arg> T* add_args() {
-    return BeginNestedMessage<T>(7);
-  }
-
-
-  using FieldMetadata_InternedStrings =
-    ::protozero::proto_utils::FieldMetadata<
-      10,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      PerfettoMetatrace_InternedString,
-      PerfettoMetatrace>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SmapsEntry>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InternedStrings kInternedStrings() { return {}; }
-  template <typename T = PerfettoMetatrace_InternedString> T* add_interned_strings() {
-    return BeginNestedMessage<T>(10);
+  static constexpr FieldMetadata_ModuleDebugid kModuleDebugid{};
+  void set_module_debugid(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ModuleDebugid::kFieldId, data, size);
   }
-
-};
-
-class PerfettoMetatrace_InternedString_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  PerfettoMetatrace_InternedString_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit PerfettoMetatrace_InternedString_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit PerfettoMetatrace_InternedString_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_iid() const { return at<1>().valid(); }
-  uint64_t iid() const { return at<1>().as_uint64(); }
-  bool has_value() const { return at<2>().valid(); }
-  ::protozero::ConstChars value() const { return at<2>().as_string(); }
-};
-
-class PerfettoMetatrace_InternedString : public ::protozero::Message {
- public:
-  using Decoder = PerfettoMetatrace_InternedString_Decoder;
-  enum : int32_t {
-    kIidFieldNumber = 1,
-    kValueFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.PerfettoMetatrace.InternedString"; }
-
-
-  using FieldMetadata_Iid =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      PerfettoMetatrace_InternedString>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Iid kIid() { return {}; }
-  void set_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
+  void set_module_debugid(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ModuleDebugid::kFieldId, chars.data, chars.size);
+  }
+  void set_module_debugid(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ModuleDebugid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Value =
+  using FieldMetadata_ModuleDebugPath =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      PerfettoMetatrace_InternedString>;
+      SmapsEntry>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
+  static constexpr FieldMetadata_ModuleDebugPath kModuleDebugPath{};
+  void set_module_debug_path(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ModuleDebugPath::kFieldId, data, size);
   }
-  void set_value(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
+  void set_module_debug_path(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ModuleDebugPath::kFieldId, chars.data, chars.size);
   }
-  void set_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+  void set_module_debug_path(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ModuleDebugPath::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
-};
-
-class PerfettoMetatrace_Arg_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  PerfettoMetatrace_Arg_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit PerfettoMetatrace_Arg_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit PerfettoMetatrace_Arg_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_key() const { return at<1>().valid(); }
-  ::protozero::ConstChars key() const { return at<1>().as_string(); }
-  bool has_key_iid() const { return at<3>().valid(); }
-  uint64_t key_iid() const { return at<3>().as_uint64(); }
-  bool has_value() const { return at<2>().valid(); }
-  ::protozero::ConstChars value() const { return at<2>().as_string(); }
-  bool has_value_iid() const { return at<4>().valid(); }
-  uint64_t value_iid() const { return at<4>().as_uint64(); }
-};
 
-class PerfettoMetatrace_Arg : public ::protozero::Message {
- public:
-  using Decoder = PerfettoMetatrace_Arg_Decoder;
-  enum : int32_t {
-    kKeyFieldNumber = 1,
-    kKeyIidFieldNumber = 3,
-    kValueFieldNumber = 2,
-    kValueIidFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.PerfettoMetatrace.Arg"; }
+  using FieldMetadata_ProtectionFlags =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SmapsEntry>;
 
+  static constexpr FieldMetadata_ProtectionFlags kProtectionFlags{};
+  void set_protection_flags(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProtectionFlags::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Key =
+  using FieldMetadata_PrivateCleanResidentKb =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      PerfettoMetatrace_Arg>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SmapsEntry>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Key kKey() { return {}; }
-  void set_key(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Key::kFieldId, data, size);
-  }
-  void set_key(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Key::kFieldId, chars.data, chars.size);
-  }
-  void set_key(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+  static constexpr FieldMetadata_PrivateCleanResidentKb kPrivateCleanResidentKb{};
+  void set_private_clean_resident_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PrivateCleanResidentKb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_KeyIid =
+  using FieldMetadata_SharedDirtyResidentKb =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      12,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      PerfettoMetatrace_Arg>;
+      SmapsEntry>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_KeyIid kKeyIid() { return {}; }
-  void set_key_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_KeyIid::kFieldId;
+  static constexpr FieldMetadata_SharedDirtyResidentKb kSharedDirtyResidentKb{};
+  void set_shared_dirty_resident_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SharedDirtyResidentKb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -153274,55 +173607,53 @@ class PerfettoMetatrace_Arg : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Value =
+  using FieldMetadata_SharedCleanResidentKb =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      13,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      PerfettoMetatrace_Arg>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SmapsEntry>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
-  }
-  void set_value(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
+  static constexpr FieldMetadata_SharedCleanResidentKb kSharedCleanResidentKb{};
+  void set_shared_clean_resident_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SharedCleanResidentKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
-  void set_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+
+  using FieldMetadata_LockedKb =
+    ::protozero::proto_utils::FieldMetadata<
+      14,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SmapsEntry>;
+
+  static constexpr FieldMetadata_LockedKb kLockedKb{};
+  void set_locked_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LockedKb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ValueIid =
+  using FieldMetadata_ProportionalResidentKb =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      15,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      PerfettoMetatrace_Arg>;
+      SmapsEntry>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ValueIid kValueIid() { return {}; }
-  void set_value_iid(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ValueIid::kFieldId;
+  static constexpr FieldMetadata_ProportionalResidentKb kProportionalResidentKb{};
+  void set_proportional_resident_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProportionalResidentKb::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -153335,11 +173666,11 @@ class PerfettoMetatrace_Arg : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/perfetto/tracing_service_event.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_active_processes.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PERFETTO_TRACING_SERVICE_EVENT_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PERFETTO_TRACING_SERVICE_EVENT_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_ACTIVE_PROCESSES_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_ACTIVE_PROCESSES_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -153350,191 +173681,162 @@ class PerfettoMetatrace_Arg : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-
-class TracingServiceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class ChromeActiveProcesses_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  TracingServiceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TracingServiceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TracingServiceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_tracing_started() const { return at<2>().valid(); }
-  bool tracing_started() const { return at<2>().as_bool(); }
-  bool has_all_data_sources_started() const { return at<1>().valid(); }
-  bool all_data_sources_started() const { return at<1>().as_bool(); }
-  bool has_all_data_sources_flushed() const { return at<3>().valid(); }
-  bool all_data_sources_flushed() const { return at<3>().as_bool(); }
-  bool has_read_tracing_buffers_completed() const { return at<4>().valid(); }
-  bool read_tracing_buffers_completed() const { return at<4>().as_bool(); }
-  bool has_tracing_disabled() const { return at<5>().valid(); }
-  bool tracing_disabled() const { return at<5>().as_bool(); }
-  bool has_seized_for_bugreport() const { return at<6>().valid(); }
-  bool seized_for_bugreport() const { return at<6>().as_bool(); }
+  ChromeActiveProcesses_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeActiveProcesses_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeActiveProcesses_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> pid() const { return GetRepeated<int32_t>(1); }
 };
 
-class TracingServiceEvent : public ::protozero::Message {
+class ChromeActiveProcesses : public ::protozero::Message {
  public:
-  using Decoder = TracingServiceEvent_Decoder;
+  using Decoder = ChromeActiveProcesses_Decoder;
   enum : int32_t {
-    kTracingStartedFieldNumber = 2,
-    kAllDataSourcesStartedFieldNumber = 1,
-    kAllDataSourcesFlushedFieldNumber = 3,
-    kReadTracingBuffersCompletedFieldNumber = 4,
-    kTracingDisabledFieldNumber = 5,
-    kSeizedForBugreportFieldNumber = 6,
+    kPidFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TracingServiceEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeActiveProcesses"; }
 
 
-  using FieldMetadata_TracingStarted =
+  using FieldMetadata_Pid =
     ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TracingServiceEvent>;
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ChromeActiveProcesses>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TracingStarted kTracingStarted() { return {}; }
-  void set_tracing_started(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_TracingStarted::kFieldId;
+  static constexpr FieldMetadata_Pid kPid{};
+  void add_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_AllDataSourcesStarted =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TracingServiceEvent>;
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_application_state_info.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AllDataSourcesStarted kAllDataSourcesStarted() { return {}; }
-  void set_all_data_sources_started(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_AllDataSourcesStarted::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_APPLICATION_STATE_INFO_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_APPLICATION_STATE_INFO_PROTO_H_
 
-  using FieldMetadata_AllDataSourcesFlushed =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TracingServiceEvent>;
+#include <stddef.h>
+#include <stdint.h>
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AllDataSourcesFlushed kAllDataSourcesFlushed() { return {}; }
-  void set_all_data_sources_flushed(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_AllDataSourcesFlushed::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
-  }
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  using FieldMetadata_ReadTracingBuffersCompleted =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TracingServiceEvent>;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+namespace perfetto_pbzero_enum_ChromeApplicationStateInfo {
+enum ChromeApplicationState : int32_t;
+}  // namespace perfetto_pbzero_enum_ChromeApplicationStateInfo
+using ChromeApplicationStateInfo_ChromeApplicationState = perfetto_pbzero_enum_ChromeApplicationStateInfo::ChromeApplicationState;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReadTracingBuffersCompleted kReadTracingBuffersCompleted() { return {}; }
-  void set_read_tracing_buffers_completed(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReadTracingBuffersCompleted::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_ChromeApplicationStateInfo {
+enum ChromeApplicationState : int32_t {
+  APPLICATION_STATE_UNKNOWN = 0,
+  APPLICATION_STATE_HAS_RUNNING_ACTIVITIES = 1,
+  APPLICATION_STATE_HAS_PAUSED_ACTIVITIES = 2,
+  APPLICATION_STATE_HAS_STOPPED_ACTIVITIES = 3,
+  APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES = 4,
+};
+} // namespace perfetto_pbzero_enum_ChromeApplicationStateInfo
+using ChromeApplicationStateInfo_ChromeApplicationState = perfetto_pbzero_enum_ChromeApplicationStateInfo::ChromeApplicationState;
+
+
+constexpr ChromeApplicationStateInfo_ChromeApplicationState ChromeApplicationStateInfo_ChromeApplicationState_MIN = ChromeApplicationStateInfo_ChromeApplicationState::APPLICATION_STATE_UNKNOWN;
+constexpr ChromeApplicationStateInfo_ChromeApplicationState ChromeApplicationStateInfo_ChromeApplicationState_MAX = ChromeApplicationStateInfo_ChromeApplicationState::APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ChromeApplicationStateInfo_ChromeApplicationState_Name(::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState::APPLICATION_STATE_UNKNOWN:
+    return "APPLICATION_STATE_UNKNOWN";
+
+  case ::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES:
+    return "APPLICATION_STATE_HAS_RUNNING_ACTIVITIES";
+
+  case ::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState::APPLICATION_STATE_HAS_PAUSED_ACTIVITIES:
+    return "APPLICATION_STATE_HAS_PAUSED_ACTIVITIES";
+
+  case ::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState::APPLICATION_STATE_HAS_STOPPED_ACTIVITIES:
+    return "APPLICATION_STATE_HAS_STOPPED_ACTIVITIES";
+
+  case ::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState::APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES:
+    return "APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES";
   }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
-  using FieldMetadata_TracingDisabled =
-    ::protozero::proto_utils::FieldMetadata<
-      5,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TracingServiceEvent>;
+class ChromeApplicationStateInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  ChromeApplicationStateInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeApplicationStateInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeApplicationStateInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_application_state() const { return at<1>().valid(); }
+  int32_t application_state() const { return at<1>().as_int32(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TracingDisabled kTracingDisabled() { return {}; }
-  void set_tracing_disabled(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_TracingDisabled::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
-        ::Append(*this, field_id, value);
+class ChromeApplicationStateInfo : public ::protozero::Message {
+ public:
+  using Decoder = ChromeApplicationStateInfo_Decoder;
+  enum : int32_t {
+    kApplicationStateFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeApplicationStateInfo"; }
+
+
+  using ChromeApplicationState = ::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState;
+  static inline const char* ChromeApplicationState_Name(ChromeApplicationState value) {
+    return ::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState_Name(value);
   }
+  static inline const ChromeApplicationState APPLICATION_STATE_UNKNOWN = ChromeApplicationState::APPLICATION_STATE_UNKNOWN;
+  static inline const ChromeApplicationState APPLICATION_STATE_HAS_RUNNING_ACTIVITIES = ChromeApplicationState::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES;
+  static inline const ChromeApplicationState APPLICATION_STATE_HAS_PAUSED_ACTIVITIES = ChromeApplicationState::APPLICATION_STATE_HAS_PAUSED_ACTIVITIES;
+  static inline const ChromeApplicationState APPLICATION_STATE_HAS_STOPPED_ACTIVITIES = ChromeApplicationState::APPLICATION_STATE_HAS_STOPPED_ACTIVITIES;
+  static inline const ChromeApplicationState APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES = ChromeApplicationState::APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES;
 
-  using FieldMetadata_SeizedForBugreport =
+  using FieldMetadata_ApplicationState =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TracingServiceEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ChromeApplicationStateInfo_ChromeApplicationState,
+      ChromeApplicationStateInfo>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SeizedForBugreport kSeizedForBugreport() { return {}; }
-  void set_seized_for_bugreport(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_SeizedForBugreport::kFieldId;
+  static constexpr FieldMetadata_ApplicationState kApplicationState{};
+  void set_application_state(ChromeApplicationStateInfo_ChromeApplicationState value) {
+    static constexpr uint32_t field_id = FieldMetadata_ApplicationState::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 };
@@ -153543,11 +173845,11 @@ class TracingServiceEvent : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/power/android_energy_estimation_breakdown.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_compositor_scheduler_state.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_POWER_ANDROID_ENERGY_ESTIMATION_BREAKDOWN_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_POWER_ANDROID_ENERGY_ESTIMATION_BREAKDOWN_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_COMPOSITOR_SCHEDULER_STATE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_COMPOSITOR_SCHEDULER_STATE_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -153558,105 +173860,521 @@ class TracingServiceEvent : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class BeginFrameArgs;
+class BeginFrameObserverState;
+class BeginFrameSourceState;
+class BeginImplFrameArgs;
+class BeginImplFrameArgs_TimestampsInUs;
+class ChromeCompositorStateMachine;
+class ChromeCompositorStateMachine_MajorState;
+class ChromeCompositorStateMachine_MinorState;
+class CompositorTimingHistory;
+class SourceLocation;
+namespace perfetto_pbzero_enum_BeginFrameArgs {
+enum BeginFrameArgsType : int32_t;
+}  // namespace perfetto_pbzero_enum_BeginFrameArgs
+using BeginFrameArgs_BeginFrameArgsType = perfetto_pbzero_enum_BeginFrameArgs::BeginFrameArgsType;
+namespace perfetto_pbzero_enum_BeginImplFrameArgs {
+enum State : int32_t;
+}  // namespace perfetto_pbzero_enum_BeginImplFrameArgs
+using BeginImplFrameArgs_State = perfetto_pbzero_enum_BeginImplFrameArgs::State;
+enum ChromeCompositorSchedulerAction : int32_t;
+namespace perfetto_pbzero_enum_ChromeCompositorSchedulerState {
+enum BeginImplFrameDeadlineMode : int32_t;
+}  // namespace perfetto_pbzero_enum_ChromeCompositorSchedulerState
+using ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode = perfetto_pbzero_enum_ChromeCompositorSchedulerState::BeginImplFrameDeadlineMode;
+namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState {
+enum BeginImplFrameState : int32_t;
+}  // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState
+using ChromeCompositorStateMachine_MajorState_BeginImplFrameState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::BeginImplFrameState;
+namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState {
+enum BeginMainFrameState : int32_t;
+}  // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState
+using ChromeCompositorStateMachine_MajorState_BeginMainFrameState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::BeginMainFrameState;
+namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState {
+enum ForcedRedrawOnTimeoutState : int32_t;
+}  // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState
+using ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::ForcedRedrawOnTimeoutState;
+namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState {
+enum LayerTreeFrameSinkState : int32_t;
+}  // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState
+using ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::LayerTreeFrameSinkState;
+namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState {
+enum ScrollHandlerState : int32_t;
+}  // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState
+using ChromeCompositorStateMachine_MinorState_ScrollHandlerState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState::ScrollHandlerState;
+namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState {
+enum TreePriority : int32_t;
+}  // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState
+using ChromeCompositorStateMachine_MinorState_TreePriority = perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState::TreePriority;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-class AndroidEnergyConsumerDescriptor;
-class AndroidEnergyEstimationBreakdown_EnergyUidBreakdown;
+enum ChromeCompositorSchedulerAction : int32_t {
+  CC_SCHEDULER_ACTION_UNSPECIFIED = 0,
+  CC_SCHEDULER_ACTION_NONE = 1,
+  CC_SCHEDULER_ACTION_SEND_BEGIN_MAIN_FRAME = 2,
+  CC_SCHEDULER_ACTION_COMMIT = 3,
+  CC_SCHEDULER_ACTION_ACTIVATE_SYNC_TREE = 4,
+  CC_SCHEDULER_ACTION_DRAW_IF_POSSIBLE = 5,
+  CC_SCHEDULER_ACTION_DRAW_FORCED = 6,
+  CC_SCHEDULER_ACTION_DRAW_ABORT = 7,
+  CC_SCHEDULER_ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION = 8,
+  CC_SCHEDULER_ACTION_PREPARE_TILES = 9,
+  CC_SCHEDULER_ACTION_INVALIDATE_LAYER_TREE_FRAME_SINK = 10,
+  CC_SCHEDULER_ACTION_PERFORM_IMPL_SIDE_INVALIDATION = 11,
+  CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_UNTIL = 12,
+  CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_SOON = 13,
+};
+
+constexpr ChromeCompositorSchedulerAction ChromeCompositorSchedulerAction_MIN = ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_UNSPECIFIED;
+constexpr ChromeCompositorSchedulerAction ChromeCompositorSchedulerAction_MAX = ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_SOON;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ChromeCompositorSchedulerAction_Name(::perfetto::protos::pbzero::ChromeCompositorSchedulerAction value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_UNSPECIFIED:
+    return "CC_SCHEDULER_ACTION_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_NONE:
+    return "CC_SCHEDULER_ACTION_NONE";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_SEND_BEGIN_MAIN_FRAME:
+    return "CC_SCHEDULER_ACTION_SEND_BEGIN_MAIN_FRAME";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_COMMIT:
+    return "CC_SCHEDULER_ACTION_COMMIT";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_ACTIVATE_SYNC_TREE:
+    return "CC_SCHEDULER_ACTION_ACTIVATE_SYNC_TREE";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_DRAW_IF_POSSIBLE:
+    return "CC_SCHEDULER_ACTION_DRAW_IF_POSSIBLE";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_DRAW_FORCED:
+    return "CC_SCHEDULER_ACTION_DRAW_FORCED";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_DRAW_ABORT:
+    return "CC_SCHEDULER_ACTION_DRAW_ABORT";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION:
+    return "CC_SCHEDULER_ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_PREPARE_TILES:
+    return "CC_SCHEDULER_ACTION_PREPARE_TILES";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_INVALIDATE_LAYER_TREE_FRAME_SINK:
+    return "CC_SCHEDULER_ACTION_INVALIDATE_LAYER_TREE_FRAME_SINK";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_PERFORM_IMPL_SIDE_INVALIDATION:
+    return "CC_SCHEDULER_ACTION_PERFORM_IMPL_SIDE_INVALIDATION";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_UNTIL:
+    return "CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_UNTIL";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_SOON:
+    return "CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_SOON";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_BeginImplFrameArgs {
+enum State : int32_t {
+  BEGIN_FRAME_FINISHED = 0,
+  BEGIN_FRAME_USING = 1,
+};
+} // namespace perfetto_pbzero_enum_BeginImplFrameArgs
+using BeginImplFrameArgs_State = perfetto_pbzero_enum_BeginImplFrameArgs::State;
+
+
+constexpr BeginImplFrameArgs_State BeginImplFrameArgs_State_MIN = BeginImplFrameArgs_State::BEGIN_FRAME_FINISHED;
+constexpr BeginImplFrameArgs_State BeginImplFrameArgs_State_MAX = BeginImplFrameArgs_State::BEGIN_FRAME_USING;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* BeginImplFrameArgs_State_Name(::perfetto::protos::pbzero::BeginImplFrameArgs_State value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::BeginImplFrameArgs_State::BEGIN_FRAME_FINISHED:
+    return "BEGIN_FRAME_FINISHED";
+
+  case ::perfetto::protos::pbzero::BeginImplFrameArgs_State::BEGIN_FRAME_USING:
+    return "BEGIN_FRAME_USING";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_BeginFrameArgs {
+enum BeginFrameArgsType : int32_t {
+  BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED = 0,
+  BEGIN_FRAME_ARGS_TYPE_INVALID = 1,
+  BEGIN_FRAME_ARGS_TYPE_NORMAL = 2,
+  BEGIN_FRAME_ARGS_TYPE_MISSED = 3,
+};
+} // namespace perfetto_pbzero_enum_BeginFrameArgs
+using BeginFrameArgs_BeginFrameArgsType = perfetto_pbzero_enum_BeginFrameArgs::BeginFrameArgsType;
+
+
+constexpr BeginFrameArgs_BeginFrameArgsType BeginFrameArgs_BeginFrameArgsType_MIN = BeginFrameArgs_BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED;
+constexpr BeginFrameArgs_BeginFrameArgsType BeginFrameArgs_BeginFrameArgsType_MAX = BeginFrameArgs_BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_MISSED;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* BeginFrameArgs_BeginFrameArgsType_Name(::perfetto::protos::pbzero::BeginFrameArgs_BeginFrameArgsType value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::BeginFrameArgs_BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED:
+    return "BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::BeginFrameArgs_BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_INVALID:
+    return "BEGIN_FRAME_ARGS_TYPE_INVALID";
+
+  case ::perfetto::protos::pbzero::BeginFrameArgs_BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_NORMAL:
+    return "BEGIN_FRAME_ARGS_TYPE_NORMAL";
+
+  case ::perfetto::protos::pbzero::BeginFrameArgs_BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_MISSED:
+    return "BEGIN_FRAME_ARGS_TYPE_MISSED";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState {
+enum TreePriority : int32_t {
+  TREE_PRIORITY_UNSPECIFIED = 0,
+  TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES = 1,
+  TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY = 2,
+  TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY = 3,
+};
+} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState
+using ChromeCompositorStateMachine_MinorState_TreePriority = perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState::TreePriority;
+
+
+constexpr ChromeCompositorStateMachine_MinorState_TreePriority ChromeCompositorStateMachine_MinorState_TreePriority_MIN = ChromeCompositorStateMachine_MinorState_TreePriority::TREE_PRIORITY_UNSPECIFIED;
+constexpr ChromeCompositorStateMachine_MinorState_TreePriority ChromeCompositorStateMachine_MinorState_TreePriority_MAX = ChromeCompositorStateMachine_MinorState_TreePriority::TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ChromeCompositorStateMachine_MinorState_TreePriority_Name(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_TreePriority value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_TreePriority::TREE_PRIORITY_UNSPECIFIED:
+    return "TREE_PRIORITY_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_TreePriority::TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES:
+    return "TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_TreePriority::TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY:
+    return "TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_TreePriority::TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY:
+    return "TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState {
+enum ScrollHandlerState : int32_t {
+  SCROLL_HANDLER_UNSPECIFIED = 0,
+  SCROLL_AFFECTS_SCROLL_HANDLER = 1,
+  SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER = 2,
+};
+} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState
+using ChromeCompositorStateMachine_MinorState_ScrollHandlerState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState::ScrollHandlerState;
+
+
+constexpr ChromeCompositorStateMachine_MinorState_ScrollHandlerState ChromeCompositorStateMachine_MinorState_ScrollHandlerState_MIN = ChromeCompositorStateMachine_MinorState_ScrollHandlerState::SCROLL_HANDLER_UNSPECIFIED;
+constexpr ChromeCompositorStateMachine_MinorState_ScrollHandlerState ChromeCompositorStateMachine_MinorState_ScrollHandlerState_MAX = ChromeCompositorStateMachine_MinorState_ScrollHandlerState::SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ChromeCompositorStateMachine_MinorState_ScrollHandlerState_Name(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_ScrollHandlerState value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_ScrollHandlerState::SCROLL_HANDLER_UNSPECIFIED:
+    return "SCROLL_HANDLER_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_ScrollHandlerState::SCROLL_AFFECTS_SCROLL_HANDLER:
+    return "SCROLL_AFFECTS_SCROLL_HANDLER";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_ScrollHandlerState::SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER:
+    return "SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState {
+enum BeginImplFrameState : int32_t {
+  BEGIN_IMPL_FRAME_UNSPECIFIED = 0,
+  BEGIN_IMPL_FRAME_IDLE = 1,
+  BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME = 2,
+  BEGIN_IMPL_FRAME_INSIDE_DEADLINE = 3,
+};
+} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState
+using ChromeCompositorStateMachine_MajorState_BeginImplFrameState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::BeginImplFrameState;
+
+
+constexpr ChromeCompositorStateMachine_MajorState_BeginImplFrameState ChromeCompositorStateMachine_MajorState_BeginImplFrameState_MIN = ChromeCompositorStateMachine_MajorState_BeginImplFrameState::BEGIN_IMPL_FRAME_UNSPECIFIED;
+constexpr ChromeCompositorStateMachine_MajorState_BeginImplFrameState ChromeCompositorStateMachine_MajorState_BeginImplFrameState_MAX = ChromeCompositorStateMachine_MajorState_BeginImplFrameState::BEGIN_IMPL_FRAME_INSIDE_DEADLINE;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ChromeCompositorStateMachine_MajorState_BeginImplFrameState_Name(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginImplFrameState value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginImplFrameState::BEGIN_IMPL_FRAME_UNSPECIFIED:
+    return "BEGIN_IMPL_FRAME_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginImplFrameState::BEGIN_IMPL_FRAME_IDLE:
+    return "BEGIN_IMPL_FRAME_IDLE";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginImplFrameState::BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME:
+    return "BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginImplFrameState::BEGIN_IMPL_FRAME_INSIDE_DEADLINE:
+    return "BEGIN_IMPL_FRAME_INSIDE_DEADLINE";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState {
+enum BeginMainFrameState : int32_t {
+  BEGIN_MAIN_FRAME_UNSPECIFIED = 0,
+  BEGIN_MAIN_FRAME_IDLE = 1,
+  BEGIN_MAIN_FRAME_SENT = 2,
+  BEGIN_MAIN_FRAME_READY_TO_COMMIT = 3,
+};
+} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState
+using ChromeCompositorStateMachine_MajorState_BeginMainFrameState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::BeginMainFrameState;
+
+
+constexpr ChromeCompositorStateMachine_MajorState_BeginMainFrameState ChromeCompositorStateMachine_MajorState_BeginMainFrameState_MIN = ChromeCompositorStateMachine_MajorState_BeginMainFrameState::BEGIN_MAIN_FRAME_UNSPECIFIED;
+constexpr ChromeCompositorStateMachine_MajorState_BeginMainFrameState ChromeCompositorStateMachine_MajorState_BeginMainFrameState_MAX = ChromeCompositorStateMachine_MajorState_BeginMainFrameState::BEGIN_MAIN_FRAME_READY_TO_COMMIT;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ChromeCompositorStateMachine_MajorState_BeginMainFrameState_Name(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginMainFrameState value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginMainFrameState::BEGIN_MAIN_FRAME_UNSPECIFIED:
+    return "BEGIN_MAIN_FRAME_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginMainFrameState::BEGIN_MAIN_FRAME_IDLE:
+    return "BEGIN_MAIN_FRAME_IDLE";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginMainFrameState::BEGIN_MAIN_FRAME_SENT:
+    return "BEGIN_MAIN_FRAME_SENT";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginMainFrameState::BEGIN_MAIN_FRAME_READY_TO_COMMIT:
+    return "BEGIN_MAIN_FRAME_READY_TO_COMMIT";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState {
+enum LayerTreeFrameSinkState : int32_t {
+  LAYER_TREE_FRAME_UNSPECIFIED = 0,
+  LAYER_TREE_FRAME_NONE = 1,
+  LAYER_TREE_FRAME_ACTIVE = 2,
+  LAYER_TREE_FRAME_CREATING = 3,
+  LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT = 4,
+  LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION = 5,
+};
+} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState
+using ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::LayerTreeFrameSinkState;
+
+
+constexpr ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_MIN = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_UNSPECIFIED;
+constexpr ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_MAX = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_Name(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_UNSPECIFIED:
+    return "LAYER_TREE_FRAME_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_NONE:
+    return "LAYER_TREE_FRAME_NONE";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_ACTIVE:
+    return "LAYER_TREE_FRAME_ACTIVE";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_CREATING:
+    return "LAYER_TREE_FRAME_CREATING";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT:
+    return "LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION:
+    return "LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState {
+enum ForcedRedrawOnTimeoutState : int32_t {
+  FORCED_REDRAW_UNSPECIFIED = 0,
+  FORCED_REDRAW_IDLE = 1,
+  FORCED_REDRAW_WAITING_FOR_COMMIT = 2,
+  FORCED_REDRAW_WAITING_FOR_ACTIVATION = 3,
+  FORCED_REDRAW_WAITING_FOR_DRAW = 4,
+};
+} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState
+using ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::ForcedRedrawOnTimeoutState;
+
+
+constexpr ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_MIN = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState::FORCED_REDRAW_UNSPECIFIED;
+constexpr ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_MAX = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState::FORCED_REDRAW_WAITING_FOR_DRAW;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_Name(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState::FORCED_REDRAW_UNSPECIFIED:
+    return "FORCED_REDRAW_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState::FORCED_REDRAW_IDLE:
+    return "FORCED_REDRAW_IDLE";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState::FORCED_REDRAW_WAITING_FOR_COMMIT:
+    return "FORCED_REDRAW_WAITING_FOR_COMMIT";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState::FORCED_REDRAW_WAITING_FOR_ACTIVATION:
+    return "FORCED_REDRAW_WAITING_FOR_ACTIVATION";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState::FORCED_REDRAW_WAITING_FOR_DRAW:
+    return "FORCED_REDRAW_WAITING_FOR_DRAW";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_ChromeCompositorSchedulerState {
+enum BeginImplFrameDeadlineMode : int32_t {
+  DEADLINE_MODE_UNSPECIFIED = 0,
+  DEADLINE_MODE_NONE = 1,
+  DEADLINE_MODE_IMMEDIATE = 2,
+  DEADLINE_MODE_REGULAR = 3,
+  DEADLINE_MODE_LATE = 4,
+  DEADLINE_MODE_BLOCKED = 5,
+};
+} // namespace perfetto_pbzero_enum_ChromeCompositorSchedulerState
+using ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode = perfetto_pbzero_enum_ChromeCompositorSchedulerState::BeginImplFrameDeadlineMode;
+
+
+constexpr ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_MIN = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_UNSPECIFIED;
+constexpr ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_MAX = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_BLOCKED;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_Name(::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_UNSPECIFIED:
+    return "DEADLINE_MODE_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_NONE:
+    return "DEADLINE_MODE_NONE";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_IMMEDIATE:
+    return "DEADLINE_MODE_IMMEDIATE";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_REGULAR:
+    return "DEADLINE_MODE_REGULAR";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_LATE:
+    return "DEADLINE_MODE_LATE";
+
+  case ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_BLOCKED:
+    return "DEADLINE_MODE_BLOCKED";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
-class AndroidEnergyEstimationBreakdown_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class CompositorTimingHistory_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
-  AndroidEnergyEstimationBreakdown_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AndroidEnergyEstimationBreakdown_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AndroidEnergyEstimationBreakdown_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_energy_consumer_descriptor() const { return at<1>().valid(); }
-  ::protozero::ConstBytes energy_consumer_descriptor() const { return at<1>().as_bytes(); }
-  bool has_energy_consumer_id() const { return at<2>().valid(); }
-  int32_t energy_consumer_id() const { return at<2>().as_int32(); }
-  bool has_energy_uws() const { return at<3>().valid(); }
-  int64_t energy_uws() const { return at<3>().as_int64(); }
-  bool has_per_uid_breakdown() const { return at<4>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> per_uid_breakdown() const { return GetRepeated<::protozero::ConstBytes>(4); }
+  CompositorTimingHistory_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit CompositorTimingHistory_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit CompositorTimingHistory_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_begin_main_frame_queue_critical_estimate_delta_us() const { return at<1>().valid(); }
+  int64_t begin_main_frame_queue_critical_estimate_delta_us() const { return at<1>().as_int64(); }
+  bool has_begin_main_frame_queue_not_critical_estimate_delta_us() const { return at<2>().valid(); }
+  int64_t begin_main_frame_queue_not_critical_estimate_delta_us() const { return at<2>().as_int64(); }
+  bool has_begin_main_frame_start_to_ready_to_commit_estimate_delta_us() const { return at<3>().valid(); }
+  int64_t begin_main_frame_start_to_ready_to_commit_estimate_delta_us() const { return at<3>().as_int64(); }
+  bool has_commit_to_ready_to_activate_estimate_delta_us() const { return at<4>().valid(); }
+  int64_t commit_to_ready_to_activate_estimate_delta_us() const { return at<4>().as_int64(); }
+  bool has_prepare_tiles_estimate_delta_us() const { return at<5>().valid(); }
+  int64_t prepare_tiles_estimate_delta_us() const { return at<5>().as_int64(); }
+  bool has_activate_estimate_delta_us() const { return at<6>().valid(); }
+  int64_t activate_estimate_delta_us() const { return at<6>().as_int64(); }
+  bool has_draw_estimate_delta_us() const { return at<7>().valid(); }
+  int64_t draw_estimate_delta_us() const { return at<7>().as_int64(); }
 };
 
-class AndroidEnergyEstimationBreakdown : public ::protozero::Message {
+class CompositorTimingHistory : public ::protozero::Message {
  public:
-  using Decoder = AndroidEnergyEstimationBreakdown_Decoder;
+  using Decoder = CompositorTimingHistory_Decoder;
   enum : int32_t {
-    kEnergyConsumerDescriptorFieldNumber = 1,
-    kEnergyConsumerIdFieldNumber = 2,
-    kEnergyUwsFieldNumber = 3,
-    kPerUidBreakdownFieldNumber = 4,
+    kBeginMainFrameQueueCriticalEstimateDeltaUsFieldNumber = 1,
+    kBeginMainFrameQueueNotCriticalEstimateDeltaUsFieldNumber = 2,
+    kBeginMainFrameStartToReadyToCommitEstimateDeltaUsFieldNumber = 3,
+    kCommitToReadyToActivateEstimateDeltaUsFieldNumber = 4,
+    kPrepareTilesEstimateDeltaUsFieldNumber = 5,
+    kActivateEstimateDeltaUsFieldNumber = 6,
+    kDrawEstimateDeltaUsFieldNumber = 7,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.AndroidEnergyEstimationBreakdown"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.CompositorTimingHistory"; }
 
-  using EnergyUidBreakdown = ::perfetto::protos::pbzero::AndroidEnergyEstimationBreakdown_EnergyUidBreakdown;
 
-  using FieldMetadata_EnergyConsumerDescriptor =
+  using FieldMetadata_BeginMainFrameQueueCriticalEstimateDeltaUs =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AndroidEnergyConsumerDescriptor,
-      AndroidEnergyEstimationBreakdown>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      CompositorTimingHistory>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EnergyConsumerDescriptor kEnergyConsumerDescriptor() { return {}; }
-  template <typename T = AndroidEnergyConsumerDescriptor> T* set_energy_consumer_descriptor() {
-    return BeginNestedMessage<T>(1);
+  static constexpr FieldMetadata_BeginMainFrameQueueCriticalEstimateDeltaUs kBeginMainFrameQueueCriticalEstimateDeltaUs{};
+  void set_begin_main_frame_queue_critical_estimate_delta_us(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BeginMainFrameQueueCriticalEstimateDeltaUs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_EnergyConsumerId =
+  using FieldMetadata_BeginMainFrameQueueNotCriticalEstimateDeltaUs =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      AndroidEnergyEstimationBreakdown>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      CompositorTimingHistory>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EnergyConsumerId kEnergyConsumerId() { return {}; }
-  void set_energy_consumer_id(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EnergyConsumerId::kFieldId;
+  static constexpr FieldMetadata_BeginMainFrameQueueNotCriticalEstimateDeltaUs kBeginMainFrameQueueNotCriticalEstimateDeltaUs{};
+  void set_begin_main_frame_queue_not_critical_estimate_delta_us(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BeginMainFrameQueueNotCriticalEstimateDeltaUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_EnergyUws =
+  using FieldMetadata_BeginMainFrameStartToReadyToCommitEstimateDeltaUs =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt64,
       int64_t,
-      AndroidEnergyEstimationBreakdown>;
+      CompositorTimingHistory>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EnergyUws kEnergyUws() { return {}; }
-  void set_energy_uws(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EnergyUws::kFieldId;
+  static constexpr FieldMetadata_BeginMainFrameStartToReadyToCommitEstimateDeltaUs kBeginMainFrameStartToReadyToCommitEstimateDeltaUs{};
+  void set_begin_main_frame_start_to_ready_to_commit_estimate_delta_us(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BeginMainFrameStartToReadyToCommitEstimateDeltaUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -153664,566 +174382,414 @@ class AndroidEnergyEstimationBreakdown : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_PerUidBreakdown =
+  using FieldMetadata_CommitToReadyToActivateEstimateDeltaUs =
     ::protozero::proto_utils::FieldMetadata<
       4,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AndroidEnergyEstimationBreakdown_EnergyUidBreakdown,
-      AndroidEnergyEstimationBreakdown>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PerUidBreakdown kPerUidBreakdown() { return {}; }
-  template <typename T = AndroidEnergyEstimationBreakdown_EnergyUidBreakdown> T* add_per_uid_breakdown() {
-    return BeginNestedMessage<T>(4);
-  }
-
-};
-
-class AndroidEnergyEstimationBreakdown_EnergyUidBreakdown_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  AndroidEnergyEstimationBreakdown_EnergyUidBreakdown_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit AndroidEnergyEstimationBreakdown_EnergyUidBreakdown_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit AndroidEnergyEstimationBreakdown_EnergyUidBreakdown_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_uid() const { return at<1>().valid(); }
-  int32_t uid() const { return at<1>().as_int32(); }
-  bool has_energy_uws() const { return at<2>().valid(); }
-  int64_t energy_uws() const { return at<2>().as_int64(); }
-};
-
-class AndroidEnergyEstimationBreakdown_EnergyUidBreakdown : public ::protozero::Message {
- public:
-  using Decoder = AndroidEnergyEstimationBreakdown_EnergyUidBreakdown_Decoder;
-  enum : int32_t {
-    kUidFieldNumber = 1,
-    kEnergyUwsFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.AndroidEnergyEstimationBreakdown.EnergyUidBreakdown"; }
-
-
-  using FieldMetadata_Uid =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      AndroidEnergyEstimationBreakdown_EnergyUidBreakdown>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      CompositorTimingHistory>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Uid kUid() { return {}; }
-  void set_uid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId;
+  static constexpr FieldMetadata_CommitToReadyToActivateEstimateDeltaUs kCommitToReadyToActivateEstimateDeltaUs{};
+  void set_commit_to_ready_to_activate_estimate_delta_us(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CommitToReadyToActivateEstimateDeltaUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_EnergyUws =
+  using FieldMetadata_PrepareTilesEstimateDeltaUs =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt64,
       int64_t,
-      AndroidEnergyEstimationBreakdown_EnergyUidBreakdown>;
+      CompositorTimingHistory>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EnergyUws kEnergyUws() { return {}; }
-  void set_energy_uws(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EnergyUws::kFieldId;
+  static constexpr FieldMetadata_PrepareTilesEstimateDeltaUs kPrepareTilesEstimateDeltaUs{};
+  void set_prepare_tiles_estimate_delta_us(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PrepareTilesEstimateDeltaUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/power/android_entity_state_residency.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_POWER_ANDROID_ENTITY_STATE_RESIDENCY_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_POWER_ANDROID_ENTITY_STATE_RESIDENCY_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-class EntityStateResidency_PowerEntityState;
-class EntityStateResidency_StateResidency;
-
-class EntityStateResidency_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  EntityStateResidency_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit EntityStateResidency_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit EntityStateResidency_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_power_entity_state() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> power_entity_state() const { return GetRepeated<::protozero::ConstBytes>(1); }
-  bool has_residency() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> residency() const { return GetRepeated<::protozero::ConstBytes>(2); }
-};
-
-class EntityStateResidency : public ::protozero::Message {
- public:
-  using Decoder = EntityStateResidency_Decoder;
-  enum : int32_t {
-    kPowerEntityStateFieldNumber = 1,
-    kResidencyFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.EntityStateResidency"; }
-
-  using PowerEntityState = ::perfetto::protos::pbzero::EntityStateResidency_PowerEntityState;
-  using StateResidency = ::perfetto::protos::pbzero::EntityStateResidency_StateResidency;
 
-  using FieldMetadata_PowerEntityState =
+  using FieldMetadata_ActivateEstimateDeltaUs =
     ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      EntityStateResidency_PowerEntityState,
-      EntityStateResidency>;
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      CompositorTimingHistory>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PowerEntityState kPowerEntityState() { return {}; }
-  template <typename T = EntityStateResidency_PowerEntityState> T* add_power_entity_state() {
-    return BeginNestedMessage<T>(1);
+  static constexpr FieldMetadata_ActivateEstimateDeltaUs kActivateEstimateDeltaUs{};
+  void set_activate_estimate_delta_us(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ActivateEstimateDeltaUs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_Residency =
+  using FieldMetadata_DrawEstimateDeltaUs =
     ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      EntityStateResidency_StateResidency,
-      EntityStateResidency>;
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      CompositorTimingHistory>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Residency kResidency() { return {}; }
-  template <typename T = EntityStateResidency_StateResidency> T* add_residency() {
-    return BeginNestedMessage<T>(2);
+  static constexpr FieldMetadata_DrawEstimateDeltaUs kDrawEstimateDeltaUs{};
+  void set_draw_estimate_delta_us(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DrawEstimateDeltaUs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
   }
-
 };
 
-class EntityStateResidency_StateResidency_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BeginFrameSourceState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  EntityStateResidency_StateResidency_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit EntityStateResidency_StateResidency_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit EntityStateResidency_StateResidency_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_entity_index() const { return at<1>().valid(); }
-  int32_t entity_index() const { return at<1>().as_int32(); }
-  bool has_state_index() const { return at<2>().valid(); }
-  int32_t state_index() const { return at<2>().as_int32(); }
-  bool has_total_time_in_state_ms() const { return at<3>().valid(); }
-  uint64_t total_time_in_state_ms() const { return at<3>().as_uint64(); }
-  bool has_total_state_entry_count() const { return at<4>().valid(); }
-  uint64_t total_state_entry_count() const { return at<4>().as_uint64(); }
-  bool has_last_entry_timestamp_ms() const { return at<5>().valid(); }
-  uint64_t last_entry_timestamp_ms() const { return at<5>().as_uint64(); }
+  BeginFrameSourceState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit BeginFrameSourceState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit BeginFrameSourceState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_source_id() const { return at<1>().valid(); }
+  uint32_t source_id() const { return at<1>().as_uint32(); }
+  bool has_paused() const { return at<2>().valid(); }
+  bool paused() const { return at<2>().as_bool(); }
+  bool has_num_observers() const { return at<3>().valid(); }
+  uint32_t num_observers() const { return at<3>().as_uint32(); }
+  bool has_last_begin_frame_args() const { return at<4>().valid(); }
+  ::protozero::ConstBytes last_begin_frame_args() const { return at<4>().as_bytes(); }
 };
 
-class EntityStateResidency_StateResidency : public ::protozero::Message {
+class BeginFrameSourceState : public ::protozero::Message {
  public:
-  using Decoder = EntityStateResidency_StateResidency_Decoder;
+  using Decoder = BeginFrameSourceState_Decoder;
   enum : int32_t {
-    kEntityIndexFieldNumber = 1,
-    kStateIndexFieldNumber = 2,
-    kTotalTimeInStateMsFieldNumber = 3,
-    kTotalStateEntryCountFieldNumber = 4,
-    kLastEntryTimestampMsFieldNumber = 5,
+    kSourceIdFieldNumber = 1,
+    kPausedFieldNumber = 2,
+    kNumObserversFieldNumber = 3,
+    kLastBeginFrameArgsFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.EntityStateResidency.StateResidency"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.BeginFrameSourceState"; }
 
 
-  using FieldMetadata_EntityIndex =
+  using FieldMetadata_SourceId =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      EntityStateResidency_StateResidency>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      BeginFrameSourceState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EntityIndex kEntityIndex() { return {}; }
-  void set_entity_index(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EntityIndex::kFieldId;
+  static constexpr FieldMetadata_SourceId kSourceId{};
+  void set_source_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SourceId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_StateIndex =
+  using FieldMetadata_Paused =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      EntityStateResidency_StateResidency>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      BeginFrameSourceState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StateIndex kStateIndex() { return {}; }
-  void set_state_index(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StateIndex::kFieldId;
+  static constexpr FieldMetadata_Paused kPaused{};
+  void set_paused(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_Paused::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TotalTimeInStateMs =
+  using FieldMetadata_NumObservers =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      EntityStateResidency_StateResidency>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      BeginFrameSourceState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TotalTimeInStateMs kTotalTimeInStateMs() { return {}; }
-  void set_total_time_in_state_ms(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TotalTimeInStateMs::kFieldId;
+  static constexpr FieldMetadata_NumObservers kNumObservers{};
+  void set_num_observers(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NumObservers::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TotalStateEntryCount =
+  using FieldMetadata_LastBeginFrameArgs =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      EntityStateResidency_StateResidency>;
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BeginFrameArgs,
+      BeginFrameSourceState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TotalStateEntryCount kTotalStateEntryCount() { return {}; }
-  void set_total_state_entry_count(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TotalStateEntryCount::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_LastBeginFrameArgs kLastBeginFrameArgs{};
+  template <typename T = BeginFrameArgs> T* set_last_begin_frame_args() {
+    return BeginNestedMessage<T>(4);
   }
 
-  using FieldMetadata_LastEntryTimestampMs =
+};
+
+class BeginFrameObserverState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  BeginFrameObserverState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit BeginFrameObserverState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit BeginFrameObserverState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dropped_begin_frame_args() const { return at<1>().valid(); }
+  int64_t dropped_begin_frame_args() const { return at<1>().as_int64(); }
+  bool has_last_begin_frame_args() const { return at<2>().valid(); }
+  ::protozero::ConstBytes last_begin_frame_args() const { return at<2>().as_bytes(); }
+};
+
+class BeginFrameObserverState : public ::protozero::Message {
+ public:
+  using Decoder = BeginFrameObserverState_Decoder;
+  enum : int32_t {
+    kDroppedBeginFrameArgsFieldNumber = 1,
+    kLastBeginFrameArgsFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.BeginFrameObserverState"; }
+
+
+  using FieldMetadata_DroppedBeginFrameArgs =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      EntityStateResidency_StateResidency>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      BeginFrameObserverState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LastEntryTimestampMs kLastEntryTimestampMs() { return {}; }
-  void set_last_entry_timestamp_ms(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_LastEntryTimestampMs::kFieldId;
+  static constexpr FieldMetadata_DroppedBeginFrameArgs kDroppedBeginFrameArgs{};
+  void set_dropped_begin_frame_args(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DroppedBeginFrameArgs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_LastBeginFrameArgs =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BeginFrameArgs,
+      BeginFrameObserverState>;
+
+  static constexpr FieldMetadata_LastBeginFrameArgs kLastBeginFrameArgs{};
+  template <typename T = BeginFrameArgs> T* set_last_begin_frame_args() {
+    return BeginNestedMessage<T>(2);
+  }
+
 };
 
-class EntityStateResidency_PowerEntityState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BeginImplFrameArgs_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
  public:
-  EntityStateResidency_PowerEntityState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit EntityStateResidency_PowerEntityState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit EntityStateResidency_PowerEntityState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_entity_index() const { return at<1>().valid(); }
-  int32_t entity_index() const { return at<1>().as_int32(); }
-  bool has_state_index() const { return at<2>().valid(); }
-  int32_t state_index() const { return at<2>().as_int32(); }
-  bool has_entity_name() const { return at<3>().valid(); }
-  ::protozero::ConstChars entity_name() const { return at<3>().as_string(); }
-  bool has_state_name() const { return at<4>().valid(); }
-  ::protozero::ConstChars state_name() const { return at<4>().as_string(); }
+  BeginImplFrameArgs_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit BeginImplFrameArgs_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit BeginImplFrameArgs_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_updated_at_us() const { return at<1>().valid(); }
+  int64_t updated_at_us() const { return at<1>().as_int64(); }
+  bool has_finished_at_us() const { return at<2>().valid(); }
+  int64_t finished_at_us() const { return at<2>().as_int64(); }
+  bool has_state() const { return at<3>().valid(); }
+  int32_t state() const { return at<3>().as_int32(); }
+  bool has_current_args() const { return at<4>().valid(); }
+  ::protozero::ConstBytes current_args() const { return at<4>().as_bytes(); }
+  bool has_last_args() const { return at<5>().valid(); }
+  ::protozero::ConstBytes last_args() const { return at<5>().as_bytes(); }
+  bool has_timestamps_in_us() const { return at<6>().valid(); }
+  ::protozero::ConstBytes timestamps_in_us() const { return at<6>().as_bytes(); }
 };
 
-class EntityStateResidency_PowerEntityState : public ::protozero::Message {
+class BeginImplFrameArgs : public ::protozero::Message {
  public:
-  using Decoder = EntityStateResidency_PowerEntityState_Decoder;
+  using Decoder = BeginImplFrameArgs_Decoder;
   enum : int32_t {
-    kEntityIndexFieldNumber = 1,
-    kStateIndexFieldNumber = 2,
-    kEntityNameFieldNumber = 3,
-    kStateNameFieldNumber = 4,
+    kUpdatedAtUsFieldNumber = 1,
+    kFinishedAtUsFieldNumber = 2,
+    kStateFieldNumber = 3,
+    kCurrentArgsFieldNumber = 4,
+    kLastArgsFieldNumber = 5,
+    kTimestampsInUsFieldNumber = 6,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.EntityStateResidency.PowerEntityState"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.BeginImplFrameArgs"; }
+
+  using TimestampsInUs = ::perfetto::protos::pbzero::BeginImplFrameArgs_TimestampsInUs;
 
+  using State = ::perfetto::protos::pbzero::BeginImplFrameArgs_State;
+  static inline const char* State_Name(State value) {
+    return ::perfetto::protos::pbzero::BeginImplFrameArgs_State_Name(value);
+  }
+  static inline const State BEGIN_FRAME_FINISHED = State::BEGIN_FRAME_FINISHED;
+  static inline const State BEGIN_FRAME_USING = State::BEGIN_FRAME_USING;
 
-  using FieldMetadata_EntityIndex =
+  using FieldMetadata_UpdatedAtUs =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      EntityStateResidency_PowerEntityState>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      BeginImplFrameArgs>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EntityIndex kEntityIndex() { return {}; }
-  void set_entity_index(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EntityIndex::kFieldId;
+  static constexpr FieldMetadata_UpdatedAtUs kUpdatedAtUs{};
+  void set_updated_at_us(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_UpdatedAtUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_StateIndex =
+  using FieldMetadata_FinishedAtUs =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      EntityStateResidency_PowerEntityState>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      BeginImplFrameArgs>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StateIndex kStateIndex() { return {}; }
-  void set_state_index(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_StateIndex::kFieldId;
+  static constexpr FieldMetadata_FinishedAtUs kFinishedAtUs{};
+  void set_finished_at_us(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FinishedAtUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_EntityName =
+  using FieldMetadata_State =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      EntityStateResidency_PowerEntityState>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      BeginImplFrameArgs_State,
+      BeginImplFrameArgs>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EntityName kEntityName() { return {}; }
-  void set_entity_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_EntityName::kFieldId, data, size);
-  }
-  void set_entity_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_EntityName::kFieldId, chars.data, chars.size);
-  }
-  void set_entity_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_EntityName::kFieldId;
+  static constexpr FieldMetadata_State kState{};
+  void set_state(BeginImplFrameArgs_State value) {
+    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_StateName =
+  using FieldMetadata_CurrentArgs =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      EntityStateResidency_PowerEntityState>;
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BeginFrameArgs,
+      BeginImplFrameArgs>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StateName kStateName() { return {}; }
-  void set_state_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_StateName::kFieldId, data, size);
-  }
-  void set_state_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_StateName::kFieldId, chars.data, chars.size);
-  }
-  void set_state_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_StateName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_CurrentArgs kCurrentArgs{};
+  template <typename T = BeginFrameArgs> T* set_current_args() {
+    return BeginNestedMessage<T>(4);
   }
-};
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/power/battery_counters.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_POWER_BATTERY_COUNTERS_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_POWER_BATTERY_COUNTERS_PROTO_H_
+  using FieldMetadata_LastArgs =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BeginFrameArgs,
+      BeginImplFrameArgs>;
 
-#include <stddef.h>
-#include <stdint.h>
+  static constexpr FieldMetadata_LastArgs kLastArgs{};
+  template <typename T = BeginFrameArgs> T* set_last_args() {
+    return BeginNestedMessage<T>(5);
+  }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  using FieldMetadata_TimestampsInUs =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BeginImplFrameArgs_TimestampsInUs,
+      BeginImplFrameArgs>;
+
+  static constexpr FieldMetadata_TimestampsInUs kTimestampsInUs{};
+  template <typename T = BeginImplFrameArgs_TimestampsInUs> T* set_timestamps_in_us() {
+    return BeginNestedMessage<T>(6);
+  }
 
+};
 
-class BatteryCounters_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class BeginImplFrameArgs_TimestampsInUs_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
-  BatteryCounters_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit BatteryCounters_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit BatteryCounters_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_charge_counter_uah() const { return at<1>().valid(); }
-  int64_t charge_counter_uah() const { return at<1>().as_int64(); }
-  bool has_capacity_percent() const { return at<2>().valid(); }
-  float capacity_percent() const { return at<2>().as_float(); }
-  bool has_current_ua() const { return at<3>().valid(); }
-  int64_t current_ua() const { return at<3>().as_int64(); }
-  bool has_current_avg_ua() const { return at<4>().valid(); }
-  int64_t current_avg_ua() const { return at<4>().as_int64(); }
-  bool has_name() const { return at<5>().valid(); }
-  ::protozero::ConstChars name() const { return at<5>().as_string(); }
-  bool has_energy_counter_uwh() const { return at<6>().valid(); }
-  int64_t energy_counter_uwh() const { return at<6>().as_int64(); }
-  bool has_voltage_uv() const { return at<7>().valid(); }
-  int64_t voltage_uv() const { return at<7>().as_int64(); }
+  BeginImplFrameArgs_TimestampsInUs_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit BeginImplFrameArgs_TimestampsInUs_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit BeginImplFrameArgs_TimestampsInUs_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_interval_delta() const { return at<1>().valid(); }
+  int64_t interval_delta() const { return at<1>().as_int64(); }
+  bool has_now_to_deadline_delta() const { return at<2>().valid(); }
+  int64_t now_to_deadline_delta() const { return at<2>().as_int64(); }
+  bool has_frame_time_to_now_delta() const { return at<3>().valid(); }
+  int64_t frame_time_to_now_delta() const { return at<3>().as_int64(); }
+  bool has_frame_time_to_deadline_delta() const { return at<4>().valid(); }
+  int64_t frame_time_to_deadline_delta() const { return at<4>().as_int64(); }
+  bool has_now() const { return at<5>().valid(); }
+  int64_t now() const { return at<5>().as_int64(); }
+  bool has_frame_time() const { return at<6>().valid(); }
+  int64_t frame_time() const { return at<6>().as_int64(); }
+  bool has_deadline() const { return at<7>().valid(); }
+  int64_t deadline() const { return at<7>().as_int64(); }
 };
 
-class BatteryCounters : public ::protozero::Message {
+class BeginImplFrameArgs_TimestampsInUs : public ::protozero::Message {
  public:
-  using Decoder = BatteryCounters_Decoder;
+  using Decoder = BeginImplFrameArgs_TimestampsInUs_Decoder;
   enum : int32_t {
-    kChargeCounterUahFieldNumber = 1,
-    kCapacityPercentFieldNumber = 2,
-    kCurrentUaFieldNumber = 3,
-    kCurrentAvgUaFieldNumber = 4,
-    kNameFieldNumber = 5,
-    kEnergyCounterUwhFieldNumber = 6,
-    kVoltageUvFieldNumber = 7,
+    kIntervalDeltaFieldNumber = 1,
+    kNowToDeadlineDeltaFieldNumber = 2,
+    kFrameTimeToNowDeltaFieldNumber = 3,
+    kFrameTimeToDeadlineDeltaFieldNumber = 4,
+    kNowFieldNumber = 5,
+    kFrameTimeFieldNumber = 6,
+    kDeadlineFieldNumber = 7,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.BatteryCounters"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.BeginImplFrameArgs.TimestampsInUs"; }
 
 
-  using FieldMetadata_ChargeCounterUah =
+  using FieldMetadata_IntervalDelta =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt64,
       int64_t,
-      BatteryCounters>;
+      BeginImplFrameArgs_TimestampsInUs>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChargeCounterUah kChargeCounterUah() { return {}; }
-  void set_charge_counter_uah(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ChargeCounterUah::kFieldId;
+  static constexpr FieldMetadata_IntervalDelta kIntervalDelta{};
+  void set_interval_delta(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IntervalDelta::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -154231,49 +174797,35 @@ class BatteryCounters : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CapacityPercent =
+  using FieldMetadata_NowToDeadlineDelta =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kFloat,
-      float,
-      BatteryCounters>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      BeginImplFrameArgs_TimestampsInUs>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CapacityPercent kCapacityPercent() { return {}; }
-  void set_capacity_percent(float value) {
-    static constexpr uint32_t field_id = FieldMetadata_CapacityPercent::kFieldId;
+  static constexpr FieldMetadata_NowToDeadlineDelta kNowToDeadlineDelta{};
+  void set_now_to_deadline_delta(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NowToDeadlineDelta::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CurrentUa =
+  using FieldMetadata_FrameTimeToNowDelta =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt64,
       int64_t,
-      BatteryCounters>;
+      BeginImplFrameArgs_TimestampsInUs>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CurrentUa kCurrentUa() { return {}; }
-  void set_current_ua(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CurrentUa::kFieldId;
+  static constexpr FieldMetadata_FrameTimeToNowDelta kFrameTimeToNowDelta{};
+  void set_frame_time_to_now_delta(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FrameTimeToNowDelta::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -154281,24 +174833,17 @@ class BatteryCounters : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_CurrentAvgUa =
+  using FieldMetadata_FrameTimeToDeadlineDelta =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt64,
       int64_t,
-      BatteryCounters>;
+      BeginImplFrameArgs_TimestampsInUs>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CurrentAvgUa kCurrentAvgUa() { return {}; }
-  void set_current_avg_ua(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CurrentAvgUa::kFieldId;
+  static constexpr FieldMetadata_FrameTimeToDeadlineDelta kFrameTimeToDeadlineDelta{};
+  void set_frame_time_to_deadline_delta(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FrameTimeToDeadlineDelta::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -154306,55 +174851,35 @@ class BatteryCounters : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Name =
+  using FieldMetadata_Now =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      BatteryCounters>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      BeginImplFrameArgs_TimestampsInUs>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_Now kNow{};
+  void set_now(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Now::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_EnergyCounterUwh =
+  using FieldMetadata_FrameTime =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt64,
       int64_t,
-      BatteryCounters>;
+      BeginImplFrameArgs_TimestampsInUs>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EnergyCounterUwh kEnergyCounterUwh() { return {}; }
-  void set_energy_counter_uwh(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_EnergyCounterUwh::kFieldId;
+  static constexpr FieldMetadata_FrameTime kFrameTime{};
+  void set_frame_time(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FrameTime::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -154362,24 +174887,17 @@ class BatteryCounters : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VoltageUv =
+  using FieldMetadata_Deadline =
     ::protozero::proto_utils::FieldMetadata<
       7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt64,
       int64_t,
-      BatteryCounters>;
+      BeginImplFrameArgs_TimestampsInUs>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VoltageUv kVoltageUv() { return {}; }
-  void set_voltage_uv(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VoltageUv::kFieldId;
+  static constexpr FieldMetadata_Deadline kDeadline{};
+  void set_deadline(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Deadline::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -154388,165 +174906,92 @@ class BatteryCounters : public ::protozero::Message {
   }
 };
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/power/power_rails.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_POWER_POWER_RAILS_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_POWER_POWER_RAILS_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-class PowerRails_EnergyData;
-class PowerRails_RailDescriptor;
-
-class PowerRails_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class BeginFrameArgs_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/12> {
  public:
-  PowerRails_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit PowerRails_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit PowerRails_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_rail_descriptor() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> rail_descriptor() const { return GetRepeated<::protozero::ConstBytes>(1); }
-  bool has_energy_data() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> energy_data() const { return GetRepeated<::protozero::ConstBytes>(2); }
+  BeginFrameArgs_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit BeginFrameArgs_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit BeginFrameArgs_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_type() const { return at<1>().valid(); }
+  int32_t type() const { return at<1>().as_int32(); }
+  bool has_source_id() const { return at<2>().valid(); }
+  uint64_t source_id() const { return at<2>().as_uint64(); }
+  bool has_sequence_number() const { return at<3>().valid(); }
+  uint64_t sequence_number() const { return at<3>().as_uint64(); }
+  bool has_frame_time_us() const { return at<4>().valid(); }
+  int64_t frame_time_us() const { return at<4>().as_int64(); }
+  bool has_deadline_us() const { return at<5>().valid(); }
+  int64_t deadline_us() const { return at<5>().as_int64(); }
+  bool has_interval_delta_us() const { return at<6>().valid(); }
+  int64_t interval_delta_us() const { return at<6>().as_int64(); }
+  bool has_on_critical_path() const { return at<7>().valid(); }
+  bool on_critical_path() const { return at<7>().as_bool(); }
+  bool has_animate_only() const { return at<8>().valid(); }
+  bool animate_only() const { return at<8>().as_bool(); }
+  bool has_source_location_iid() const { return at<9>().valid(); }
+  uint64_t source_location_iid() const { return at<9>().as_uint64(); }
+  bool has_source_location() const { return at<10>().valid(); }
+  ::protozero::ConstBytes source_location() const { return at<10>().as_bytes(); }
+  bool has_frames_throttled_since_last() const { return at<12>().valid(); }
+  int64_t frames_throttled_since_last() const { return at<12>().as_int64(); }
 };
 
-class PowerRails : public ::protozero::Message {
+class BeginFrameArgs : public ::protozero::Message {
  public:
-  using Decoder = PowerRails_Decoder;
+  using Decoder = BeginFrameArgs_Decoder;
   enum : int32_t {
-    kRailDescriptorFieldNumber = 1,
-    kEnergyDataFieldNumber = 2,
+    kTypeFieldNumber = 1,
+    kSourceIdFieldNumber = 2,
+    kSequenceNumberFieldNumber = 3,
+    kFrameTimeUsFieldNumber = 4,
+    kDeadlineUsFieldNumber = 5,
+    kIntervalDeltaUsFieldNumber = 6,
+    kOnCriticalPathFieldNumber = 7,
+    kAnimateOnlyFieldNumber = 8,
+    kSourceLocationIidFieldNumber = 9,
+    kSourceLocationFieldNumber = 10,
+    kFramesThrottledSinceLastFieldNumber = 12,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.PowerRails"; }
-
-  using RailDescriptor = ::perfetto::protos::pbzero::PowerRails_RailDescriptor;
-  using EnergyData = ::perfetto::protos::pbzero::PowerRails_EnergyData;
-
-  using FieldMetadata_RailDescriptor =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      PowerRails_RailDescriptor,
-      PowerRails>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RailDescriptor kRailDescriptor() { return {}; }
-  template <typename T = PowerRails_RailDescriptor> T* add_rail_descriptor() {
-    return BeginNestedMessage<T>(1);
-  }
-
+  static constexpr const char* GetName() { return ".perfetto.protos.BeginFrameArgs"; }
 
-  using FieldMetadata_EnergyData =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      PowerRails_EnergyData,
-      PowerRails>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EnergyData kEnergyData() { return {}; }
-  template <typename T = PowerRails_EnergyData> T* add_energy_data() {
-    return BeginNestedMessage<T>(2);
+  using BeginFrameArgsType = ::perfetto::protos::pbzero::BeginFrameArgs_BeginFrameArgsType;
+  static inline const char* BeginFrameArgsType_Name(BeginFrameArgsType value) {
+    return ::perfetto::protos::pbzero::BeginFrameArgs_BeginFrameArgsType_Name(value);
   }
+  static inline const BeginFrameArgsType BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED = BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED;
+  static inline const BeginFrameArgsType BEGIN_FRAME_ARGS_TYPE_INVALID = BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_INVALID;
+  static inline const BeginFrameArgsType BEGIN_FRAME_ARGS_TYPE_NORMAL = BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_NORMAL;
+  static inline const BeginFrameArgsType BEGIN_FRAME_ARGS_TYPE_MISSED = BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_MISSED;
 
-};
-
-class PowerRails_EnergyData_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  PowerRails_EnergyData_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit PowerRails_EnergyData_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit PowerRails_EnergyData_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_index() const { return at<1>().valid(); }
-  uint32_t index() const { return at<1>().as_uint32(); }
-  bool has_timestamp_ms() const { return at<2>().valid(); }
-  uint64_t timestamp_ms() const { return at<2>().as_uint64(); }
-  bool has_energy() const { return at<3>().valid(); }
-  uint64_t energy() const { return at<3>().as_uint64(); }
-};
-
-class PowerRails_EnergyData : public ::protozero::Message {
- public:
-  using Decoder = PowerRails_EnergyData_Decoder;
-  enum : int32_t {
-    kIndexFieldNumber = 1,
-    kTimestampMsFieldNumber = 2,
-    kEnergyFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.PowerRails.EnergyData"; }
-
-
-  using FieldMetadata_Index =
+  using FieldMetadata_Type =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      PowerRails_EnergyData>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      BeginFrameArgs_BeginFrameArgsType,
+      BeginFrameArgs>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Index kIndex() { return {}; }
-  void set_index(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(BeginFrameArgs_BeginFrameArgsType value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimestampMs =
+  using FieldMetadata_SourceId =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      PowerRails_EnergyData>;
+      BeginFrameArgs>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimestampMs kTimestampMs() { return {}; }
-  void set_timestamp_ms(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimestampMs::kFieldId;
+  static constexpr FieldMetadata_SourceId kSourceId{};
+  void set_source_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SourceId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -154554,348 +174999,395 @@ class PowerRails_EnergyData : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Energy =
+  using FieldMetadata_SequenceNumber =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      PowerRails_EnergyData>;
+      BeginFrameArgs>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Energy kEnergy() { return {}; }
-  void set_energy(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Energy::kFieldId;
+  static constexpr FieldMetadata_SequenceNumber kSequenceNumber{};
+  void set_sequence_number(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SequenceNumber::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class PowerRails_RailDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  PowerRails_RailDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit PowerRails_RailDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit PowerRails_RailDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_index() const { return at<1>().valid(); }
-  uint32_t index() const { return at<1>().as_uint32(); }
-  bool has_rail_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars rail_name() const { return at<2>().as_string(); }
-  bool has_subsys_name() const { return at<3>().valid(); }
-  ::protozero::ConstChars subsys_name() const { return at<3>().as_string(); }
-  bool has_sampling_rate() const { return at<4>().valid(); }
-  uint32_t sampling_rate() const { return at<4>().as_uint32(); }
-};
 
-class PowerRails_RailDescriptor : public ::protozero::Message {
- public:
-  using Decoder = PowerRails_RailDescriptor_Decoder;
-  enum : int32_t {
-    kIndexFieldNumber = 1,
-    kRailNameFieldNumber = 2,
-    kSubsysNameFieldNumber = 3,
-    kSamplingRateFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.PowerRails.RailDescriptor"; }
+  using FieldMetadata_FrameTimeUs =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      BeginFrameArgs>;
 
+  static constexpr FieldMetadata_FrameTimeUs kFrameTimeUs{};
+  void set_frame_time_us(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FrameTimeUs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Index =
+  using FieldMetadata_DeadlineUs =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      PowerRails_RailDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      BeginFrameArgs>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Index kIndex() { return {}; }
-  void set_index(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
+  static constexpr FieldMetadata_DeadlineUs kDeadlineUs{};
+  void set_deadline_us(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DeadlineUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_RailName =
+  using FieldMetadata_IntervalDeltaUs =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      PowerRails_RailDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      BeginFrameArgs>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RailName kRailName() { return {}; }
-  void set_rail_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_RailName::kFieldId, data, size);
-  }
-  void set_rail_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_RailName::kFieldId, chars.data, chars.size);
-  }
-  void set_rail_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_RailName::kFieldId;
+  static constexpr FieldMetadata_IntervalDeltaUs kIntervalDeltaUs{};
+  void set_interval_delta_us(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IntervalDeltaUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SubsysName =
+  using FieldMetadata_OnCriticalPath =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      PowerRails_RailDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      BeginFrameArgs>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SubsysName kSubsysName() { return {}; }
-  void set_subsys_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_SubsysName::kFieldId, data, size);
-  }
-  void set_subsys_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_SubsysName::kFieldId, chars.data, chars.size);
-  }
-  void set_subsys_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_SubsysName::kFieldId;
+  static constexpr FieldMetadata_OnCriticalPath kOnCriticalPath{};
+  void set_on_critical_path(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_OnCriticalPath::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SamplingRate =
+  using FieldMetadata_AnimateOnly =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      PowerRails_RailDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      BeginFrameArgs>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SamplingRate kSamplingRate() { return {}; }
-  void set_sampling_rate(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SamplingRate::kFieldId;
+  static constexpr FieldMetadata_AnimateOnly kAnimateOnly{};
+  void set_animate_only(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_AnimateOnly::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
-};
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ps/process_stats.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+  using FieldMetadata_SourceLocationIid =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      BeginFrameArgs>;
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PS_PROCESS_STATS_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PS_PROCESS_STATS_PROTO_H_
+  static constexpr FieldMetadata_SourceLocationIid kSourceLocationIid{};
+  void set_source_location_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SourceLocationIid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-#include <stddef.h>
-#include <stdint.h>
+  using FieldMetadata_SourceLocation =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SourceLocation,
+      BeginFrameArgs>;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  static constexpr FieldMetadata_SourceLocation kSourceLocation{};
+  template <typename T = SourceLocation> T* set_source_location() {
+    return BeginNestedMessage<T>(10);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
 
-class ProcessStats_FDInfo;
-class ProcessStats_Process;
-class ProcessStats_Thread;
+  using FieldMetadata_FramesThrottledSinceLast =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      BeginFrameArgs>;
+
+  static constexpr FieldMetadata_FramesThrottledSinceLast kFramesThrottledSinceLast{};
+  void set_frames_throttled_since_last(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FramesThrottledSinceLast::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+};
 
-class ProcessStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class ChromeCompositorStateMachine_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  ProcessStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ProcessStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ProcessStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_processes() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> processes() const { return GetRepeated<::protozero::ConstBytes>(1); }
-  bool has_collection_end_timestamp() const { return at<2>().valid(); }
-  uint64_t collection_end_timestamp() const { return at<2>().as_uint64(); }
+  ChromeCompositorStateMachine_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeCompositorStateMachine_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeCompositorStateMachine_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_major_state() const { return at<1>().valid(); }
+  ::protozero::ConstBytes major_state() const { return at<1>().as_bytes(); }
+  bool has_minor_state() const { return at<2>().valid(); }
+  ::protozero::ConstBytes minor_state() const { return at<2>().as_bytes(); }
 };
 
-class ProcessStats : public ::protozero::Message {
+class ChromeCompositorStateMachine : public ::protozero::Message {
  public:
-  using Decoder = ProcessStats_Decoder;
+  using Decoder = ChromeCompositorStateMachine_Decoder;
   enum : int32_t {
-    kProcessesFieldNumber = 1,
-    kCollectionEndTimestampFieldNumber = 2,
+    kMajorStateFieldNumber = 1,
+    kMinorStateFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ProcessStats"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeCompositorStateMachine"; }
 
-  using Thread = ::perfetto::protos::pbzero::ProcessStats_Thread;
-  using FDInfo = ::perfetto::protos::pbzero::ProcessStats_FDInfo;
-  using Process = ::perfetto::protos::pbzero::ProcessStats_Process;
+  using MajorState = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState;
+  using MinorState = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState;
 
-  using FieldMetadata_Processes =
+  using FieldMetadata_MajorState =
     ::protozero::proto_utils::FieldMetadata<
       1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ProcessStats_Process,
-      ProcessStats>;
+      ChromeCompositorStateMachine_MajorState,
+      ChromeCompositorStateMachine>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Processes kProcesses() { return {}; }
-  template <typename T = ProcessStats_Process> T* add_processes() {
+  static constexpr FieldMetadata_MajorState kMajorState{};
+  template <typename T = ChromeCompositorStateMachine_MajorState> T* set_major_state() {
     return BeginNestedMessage<T>(1);
   }
 
 
-  using FieldMetadata_CollectionEndTimestamp =
+  using FieldMetadata_MinorState =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProcessStats>;
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromeCompositorStateMachine_MinorState,
+      ChromeCompositorStateMachine>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CollectionEndTimestamp kCollectionEndTimestamp() { return {}; }
-  void set_collection_end_timestamp(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CollectionEndTimestamp::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_MinorState kMinorState{};
+  template <typename T = ChromeCompositorStateMachine_MinorState> T* set_minor_state() {
+    return BeginNestedMessage<T>(2);
   }
+
 };
 
-class ProcessStats_Process_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/15, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class ChromeCompositorStateMachine_MinorState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/46> {
  public:
-  ProcessStats_Process_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ProcessStats_Process_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ProcessStats_Process_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pid() const { return at<1>().valid(); }
-  int32_t pid() const { return at<1>().as_int32(); }
-  bool has_vm_size_kb() const { return at<2>().valid(); }
-  uint64_t vm_size_kb() const { return at<2>().as_uint64(); }
-  bool has_vm_rss_kb() const { return at<3>().valid(); }
-  uint64_t vm_rss_kb() const { return at<3>().as_uint64(); }
-  bool has_rss_anon_kb() const { return at<4>().valid(); }
-  uint64_t rss_anon_kb() const { return at<4>().as_uint64(); }
-  bool has_rss_file_kb() const { return at<5>().valid(); }
-  uint64_t rss_file_kb() const { return at<5>().as_uint64(); }
-  bool has_rss_shmem_kb() const { return at<6>().valid(); }
-  uint64_t rss_shmem_kb() const { return at<6>().as_uint64(); }
-  bool has_vm_swap_kb() const { return at<7>().valid(); }
-  uint64_t vm_swap_kb() const { return at<7>().as_uint64(); }
-  bool has_vm_locked_kb() const { return at<8>().valid(); }
-  uint64_t vm_locked_kb() const { return at<8>().as_uint64(); }
-  bool has_vm_hwm_kb() const { return at<9>().valid(); }
-  uint64_t vm_hwm_kb() const { return at<9>().as_uint64(); }
-  bool has_oom_score_adj() const { return at<10>().valid(); }
-  int64_t oom_score_adj() const { return at<10>().as_int64(); }
-  bool has_threads() const { return at<11>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> threads() const { return GetRepeated<::protozero::ConstBytes>(11); }
-  bool has_is_peak_rss_resettable() const { return at<12>().valid(); }
-  bool is_peak_rss_resettable() const { return at<12>().as_bool(); }
-  bool has_chrome_private_footprint_kb() const { return at<13>().valid(); }
-  uint32_t chrome_private_footprint_kb() const { return at<13>().as_uint32(); }
-  bool has_chrome_peak_resident_set_kb() const { return at<14>().valid(); }
-  uint32_t chrome_peak_resident_set_kb() const { return at<14>().as_uint32(); }
-  bool has_fds() const { return at<15>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> fds() const { return GetRepeated<::protozero::ConstBytes>(15); }
+  ChromeCompositorStateMachine_MinorState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeCompositorStateMachine_MinorState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeCompositorStateMachine_MinorState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_commit_count() const { return at<1>().valid(); }
+  int32_t commit_count() const { return at<1>().as_int32(); }
+  bool has_current_frame_number() const { return at<2>().valid(); }
+  int32_t current_frame_number() const { return at<2>().as_int32(); }
+  bool has_last_frame_number_submit_performed() const { return at<3>().valid(); }
+  int32_t last_frame_number_submit_performed() const { return at<3>().as_int32(); }
+  bool has_last_frame_number_draw_performed() const { return at<4>().valid(); }
+  int32_t last_frame_number_draw_performed() const { return at<4>().as_int32(); }
+  bool has_last_frame_number_begin_main_frame_sent() const { return at<5>().valid(); }
+  int32_t last_frame_number_begin_main_frame_sent() const { return at<5>().as_int32(); }
+  bool has_did_draw() const { return at<6>().valid(); }
+  bool did_draw() const { return at<6>().as_bool(); }
+  bool has_did_send_begin_main_frame_for_current_frame() const { return at<7>().valid(); }
+  bool did_send_begin_main_frame_for_current_frame() const { return at<7>().as_bool(); }
+  bool has_did_notify_begin_main_frame_not_expected_until() const { return at<8>().valid(); }
+  bool did_notify_begin_main_frame_not_expected_until() const { return at<8>().as_bool(); }
+  bool has_did_notify_begin_main_frame_not_expected_soon() const { return at<9>().valid(); }
+  bool did_notify_begin_main_frame_not_expected_soon() const { return at<9>().as_bool(); }
+  bool has_wants_begin_main_frame_not_expected() const { return at<10>().valid(); }
+  bool wants_begin_main_frame_not_expected() const { return at<10>().as_bool(); }
+  bool has_did_commit_during_frame() const { return at<11>().valid(); }
+  bool did_commit_during_frame() const { return at<11>().as_bool(); }
+  bool has_did_invalidate_layer_tree_frame_sink() const { return at<12>().valid(); }
+  bool did_invalidate_layer_tree_frame_sink() const { return at<12>().as_bool(); }
+  bool has_did_perform_impl_side_invalidaion() const { return at<13>().valid(); }
+  bool did_perform_impl_side_invalidaion() const { return at<13>().as_bool(); }
+  bool has_did_prepare_tiles() const { return at<14>().valid(); }
+  bool did_prepare_tiles() const { return at<14>().as_bool(); }
+  bool has_consecutive_checkerboard_animations() const { return at<15>().valid(); }
+  int32_t consecutive_checkerboard_animations() const { return at<15>().as_int32(); }
+  bool has_pending_submit_frames() const { return at<16>().valid(); }
+  int32_t pending_submit_frames() const { return at<16>().as_int32(); }
+  bool has_submit_frames_with_current_layer_tree_frame_sink() const { return at<17>().valid(); }
+  int32_t submit_frames_with_current_layer_tree_frame_sink() const { return at<17>().as_int32(); }
+  bool has_needs_redraw() const { return at<18>().valid(); }
+  bool needs_redraw() const { return at<18>().as_bool(); }
+  bool has_needs_prepare_tiles() const { return at<19>().valid(); }
+  bool needs_prepare_tiles() const { return at<19>().as_bool(); }
+  bool has_needs_begin_main_frame() const { return at<20>().valid(); }
+  bool needs_begin_main_frame() const { return at<20>().as_bool(); }
+  bool has_needs_one_begin_impl_frame() const { return at<21>().valid(); }
+  bool needs_one_begin_impl_frame() const { return at<21>().as_bool(); }
+  bool has_visible() const { return at<22>().valid(); }
+  bool visible() const { return at<22>().as_bool(); }
+  bool has_begin_frame_source_paused() const { return at<23>().valid(); }
+  bool begin_frame_source_paused() const { return at<23>().as_bool(); }
+  bool has_can_draw() const { return at<24>().valid(); }
+  bool can_draw() const { return at<24>().as_bool(); }
+  bool has_resourceless_draw() const { return at<25>().valid(); }
+  bool resourceless_draw() const { return at<25>().as_bool(); }
+  bool has_has_pending_tree() const { return at<26>().valid(); }
+  bool has_pending_tree() const { return at<26>().as_bool(); }
+  bool has_pending_tree_is_ready_for_activation() const { return at<27>().valid(); }
+  bool pending_tree_is_ready_for_activation() const { return at<27>().as_bool(); }
+  bool has_active_tree_needs_first_draw() const { return at<28>().valid(); }
+  bool active_tree_needs_first_draw() const { return at<28>().as_bool(); }
+  bool has_active_tree_is_ready_to_draw() const { return at<29>().valid(); }
+  bool active_tree_is_ready_to_draw() const { return at<29>().as_bool(); }
+  bool has_did_create_and_initialize_first_layer_tree_frame_sink() const { return at<30>().valid(); }
+  bool did_create_and_initialize_first_layer_tree_frame_sink() const { return at<30>().as_bool(); }
+  bool has_tree_priority() const { return at<31>().valid(); }
+  int32_t tree_priority() const { return at<31>().as_int32(); }
+  bool has_scroll_handler_state() const { return at<32>().valid(); }
+  int32_t scroll_handler_state() const { return at<32>().as_int32(); }
+  bool has_critical_begin_main_frame_to_activate_is_fast() const { return at<33>().valid(); }
+  bool critical_begin_main_frame_to_activate_is_fast() const { return at<33>().as_bool(); }
+  bool has_main_thread_missed_last_deadline() const { return at<34>().valid(); }
+  bool main_thread_missed_last_deadline() const { return at<34>().as_bool(); }
+  bool has_video_needs_begin_frames() const { return at<36>().valid(); }
+  bool video_needs_begin_frames() const { return at<36>().as_bool(); }
+  bool has_defer_begin_main_frame() const { return at<37>().valid(); }
+  bool defer_begin_main_frame() const { return at<37>().as_bool(); }
+  bool has_last_commit_had_no_updates() const { return at<38>().valid(); }
+  bool last_commit_had_no_updates() const { return at<38>().as_bool(); }
+  bool has_did_draw_in_last_frame() const { return at<39>().valid(); }
+  bool did_draw_in_last_frame() const { return at<39>().as_bool(); }
+  bool has_did_submit_in_last_frame() const { return at<40>().valid(); }
+  bool did_submit_in_last_frame() const { return at<40>().as_bool(); }
+  bool has_needs_impl_side_invalidation() const { return at<41>().valid(); }
+  bool needs_impl_side_invalidation() const { return at<41>().as_bool(); }
+  bool has_current_pending_tree_is_impl_side() const { return at<42>().valid(); }
+  bool current_pending_tree_is_impl_side() const { return at<42>().as_bool(); }
+  bool has_previous_pending_tree_was_impl_side() const { return at<43>().valid(); }
+  bool previous_pending_tree_was_impl_side() const { return at<43>().as_bool(); }
+  bool has_processing_animation_worklets_for_active_tree() const { return at<44>().valid(); }
+  bool processing_animation_worklets_for_active_tree() const { return at<44>().as_bool(); }
+  bool has_processing_animation_worklets_for_pending_tree() const { return at<45>().valid(); }
+  bool processing_animation_worklets_for_pending_tree() const { return at<45>().as_bool(); }
+  bool has_processing_paint_worklets_for_pending_tree() const { return at<46>().valid(); }
+  bool processing_paint_worklets_for_pending_tree() const { return at<46>().as_bool(); }
 };
 
-class ProcessStats_Process : public ::protozero::Message {
+class ChromeCompositorStateMachine_MinorState : public ::protozero::Message {
  public:
-  using Decoder = ProcessStats_Process_Decoder;
+  using Decoder = ChromeCompositorStateMachine_MinorState_Decoder;
   enum : int32_t {
-    kPidFieldNumber = 1,
-    kVmSizeKbFieldNumber = 2,
-    kVmRssKbFieldNumber = 3,
-    kRssAnonKbFieldNumber = 4,
-    kRssFileKbFieldNumber = 5,
-    kRssShmemKbFieldNumber = 6,
-    kVmSwapKbFieldNumber = 7,
-    kVmLockedKbFieldNumber = 8,
-    kVmHwmKbFieldNumber = 9,
-    kOomScoreAdjFieldNumber = 10,
-    kThreadsFieldNumber = 11,
-    kIsPeakRssResettableFieldNumber = 12,
-    kChromePrivateFootprintKbFieldNumber = 13,
-    kChromePeakResidentSetKbFieldNumber = 14,
-    kFdsFieldNumber = 15,
+    kCommitCountFieldNumber = 1,
+    kCurrentFrameNumberFieldNumber = 2,
+    kLastFrameNumberSubmitPerformedFieldNumber = 3,
+    kLastFrameNumberDrawPerformedFieldNumber = 4,
+    kLastFrameNumberBeginMainFrameSentFieldNumber = 5,
+    kDidDrawFieldNumber = 6,
+    kDidSendBeginMainFrameForCurrentFrameFieldNumber = 7,
+    kDidNotifyBeginMainFrameNotExpectedUntilFieldNumber = 8,
+    kDidNotifyBeginMainFrameNotExpectedSoonFieldNumber = 9,
+    kWantsBeginMainFrameNotExpectedFieldNumber = 10,
+    kDidCommitDuringFrameFieldNumber = 11,
+    kDidInvalidateLayerTreeFrameSinkFieldNumber = 12,
+    kDidPerformImplSideInvalidaionFieldNumber = 13,
+    kDidPrepareTilesFieldNumber = 14,
+    kConsecutiveCheckerboardAnimationsFieldNumber = 15,
+    kPendingSubmitFramesFieldNumber = 16,
+    kSubmitFramesWithCurrentLayerTreeFrameSinkFieldNumber = 17,
+    kNeedsRedrawFieldNumber = 18,
+    kNeedsPrepareTilesFieldNumber = 19,
+    kNeedsBeginMainFrameFieldNumber = 20,
+    kNeedsOneBeginImplFrameFieldNumber = 21,
+    kVisibleFieldNumber = 22,
+    kBeginFrameSourcePausedFieldNumber = 23,
+    kCanDrawFieldNumber = 24,
+    kResourcelessDrawFieldNumber = 25,
+    kHasPendingTreeFieldNumber = 26,
+    kPendingTreeIsReadyForActivationFieldNumber = 27,
+    kActiveTreeNeedsFirstDrawFieldNumber = 28,
+    kActiveTreeIsReadyToDrawFieldNumber = 29,
+    kDidCreateAndInitializeFirstLayerTreeFrameSinkFieldNumber = 30,
+    kTreePriorityFieldNumber = 31,
+    kScrollHandlerStateFieldNumber = 32,
+    kCriticalBeginMainFrameToActivateIsFastFieldNumber = 33,
+    kMainThreadMissedLastDeadlineFieldNumber = 34,
+    kVideoNeedsBeginFramesFieldNumber = 36,
+    kDeferBeginMainFrameFieldNumber = 37,
+    kLastCommitHadNoUpdatesFieldNumber = 38,
+    kDidDrawInLastFrameFieldNumber = 39,
+    kDidSubmitInLastFrameFieldNumber = 40,
+    kNeedsImplSideInvalidationFieldNumber = 41,
+    kCurrentPendingTreeIsImplSideFieldNumber = 42,
+    kPreviousPendingTreeWasImplSideFieldNumber = 43,
+    kProcessingAnimationWorkletsForActiveTreeFieldNumber = 44,
+    kProcessingAnimationWorkletsForPendingTreeFieldNumber = 45,
+    kProcessingPaintWorkletsForPendingTreeFieldNumber = 46,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ProcessStats.Process"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeCompositorStateMachine.MinorState"; }
+
+
+  using TreePriority = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_TreePriority;
+  static inline const char* TreePriority_Name(TreePriority value) {
+    return ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_TreePriority_Name(value);
+  }
 
+  using ScrollHandlerState = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_ScrollHandlerState;
+  static inline const char* ScrollHandlerState_Name(ScrollHandlerState value) {
+    return ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_ScrollHandlerState_Name(value);
+  }
+  static inline const TreePriority TREE_PRIORITY_UNSPECIFIED = TreePriority::TREE_PRIORITY_UNSPECIFIED;
+  static inline const TreePriority TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES = TreePriority::TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES;
+  static inline const TreePriority TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY = TreePriority::TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY;
+  static inline const TreePriority TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY = TreePriority::TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY;
+  static inline const ScrollHandlerState SCROLL_HANDLER_UNSPECIFIED = ScrollHandlerState::SCROLL_HANDLER_UNSPECIFIED;
+  static inline const ScrollHandlerState SCROLL_AFFECTS_SCROLL_HANDLER = ScrollHandlerState::SCROLL_AFFECTS_SCROLL_HANDLER;
+  static inline const ScrollHandlerState SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER = ScrollHandlerState::SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER;
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_CommitCount =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      ProcessStats_Process>;
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_CommitCount kCommitCount{};
+  void set_commit_count(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CommitCount::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -154903,270 +175395,197 @@ class ProcessStats_Process : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VmSizeKb =
+  using FieldMetadata_CurrentFrameNumber =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProcessStats_Process>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VmSizeKb kVmSizeKb() { return {}; }
-  void set_vm_size_kb(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VmSizeKb::kFieldId;
+  static constexpr FieldMetadata_CurrentFrameNumber kCurrentFrameNumber{};
+  void set_current_frame_number(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CurrentFrameNumber::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VmRssKb =
+  using FieldMetadata_LastFrameNumberSubmitPerformed =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProcessStats_Process>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VmRssKb kVmRssKb() { return {}; }
-  void set_vm_rss_kb(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VmRssKb::kFieldId;
+  static constexpr FieldMetadata_LastFrameNumberSubmitPerformed kLastFrameNumberSubmitPerformed{};
+  void set_last_frame_number_submit_performed(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LastFrameNumberSubmitPerformed::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_RssAnonKb =
+  using FieldMetadata_LastFrameNumberDrawPerformed =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProcessStats_Process>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RssAnonKb kRssAnonKb() { return {}; }
-  void set_rss_anon_kb(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RssAnonKb::kFieldId;
+  static constexpr FieldMetadata_LastFrameNumberDrawPerformed kLastFrameNumberDrawPerformed{};
+  void set_last_frame_number_draw_performed(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LastFrameNumberDrawPerformed::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_RssFileKb =
+  using FieldMetadata_LastFrameNumberBeginMainFrameSent =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProcessStats_Process>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RssFileKb kRssFileKb() { return {}; }
-  void set_rss_file_kb(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RssFileKb::kFieldId;
+  static constexpr FieldMetadata_LastFrameNumberBeginMainFrameSent kLastFrameNumberBeginMainFrameSent{};
+  void set_last_frame_number_begin_main_frame_sent(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LastFrameNumberBeginMainFrameSent::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_RssShmemKb =
+  using FieldMetadata_DidDraw =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProcessStats_Process>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RssShmemKb kRssShmemKb() { return {}; }
-  void set_rss_shmem_kb(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RssShmemKb::kFieldId;
+  static constexpr FieldMetadata_DidDraw kDidDraw{};
+  void set_did_draw(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DidDraw::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VmSwapKb =
+  using FieldMetadata_DidSendBeginMainFrameForCurrentFrame =
     ::protozero::proto_utils::FieldMetadata<
       7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProcessStats_Process>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VmSwapKb kVmSwapKb() { return {}; }
-  void set_vm_swap_kb(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VmSwapKb::kFieldId;
+  static constexpr FieldMetadata_DidSendBeginMainFrameForCurrentFrame kDidSendBeginMainFrameForCurrentFrame{};
+  void set_did_send_begin_main_frame_for_current_frame(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DidSendBeginMainFrameForCurrentFrame::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VmLockedKb =
+  using FieldMetadata_DidNotifyBeginMainFrameNotExpectedUntil =
     ::protozero::proto_utils::FieldMetadata<
       8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProcessStats_Process>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VmLockedKb kVmLockedKb() { return {}; }
-  void set_vm_locked_kb(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VmLockedKb::kFieldId;
+  static constexpr FieldMetadata_DidNotifyBeginMainFrameNotExpectedUntil kDidNotifyBeginMainFrameNotExpectedUntil{};
+  void set_did_notify_begin_main_frame_not_expected_until(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DidNotifyBeginMainFrameNotExpectedUntil::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_VmHwmKb =
+  using FieldMetadata_DidNotifyBeginMainFrameNotExpectedSoon =
     ::protozero::proto_utils::FieldMetadata<
       9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProcessStats_Process>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VmHwmKb kVmHwmKb() { return {}; }
-  void set_vm_hwm_kb(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_VmHwmKb::kFieldId;
+  static constexpr FieldMetadata_DidNotifyBeginMainFrameNotExpectedSoon kDidNotifyBeginMainFrameNotExpectedSoon{};
+  void set_did_notify_begin_main_frame_not_expected_soon(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DidNotifyBeginMainFrameNotExpectedSoon::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_OomScoreAdj =
+  using FieldMetadata_WantsBeginMainFrameNotExpected =
     ::protozero::proto_utils::FieldMetadata<
       10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      ProcessStats_Process>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OomScoreAdj kOomScoreAdj() { return {}; }
-  void set_oom_score_adj(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OomScoreAdj::kFieldId;
+  static constexpr FieldMetadata_WantsBeginMainFrameNotExpected kWantsBeginMainFrameNotExpected{};
+  void set_wants_begin_main_frame_not_expected(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_WantsBeginMainFrameNotExpected::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Threads =
+  using FieldMetadata_DidCommitDuringFrame =
     ::protozero::proto_utils::FieldMetadata<
       11,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ProcessStats_Thread,
-      ProcessStats_Process>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Threads kThreads() { return {}; }
-  template <typename T = ProcessStats_Thread> T* add_threads() {
-    return BeginNestedMessage<T>(11);
+  static constexpr FieldMetadata_DidCommitDuringFrame kDidCommitDuringFrame{};
+  void set_did_commit_during_frame(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DidCommitDuringFrame::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_IsPeakRssResettable =
+  using FieldMetadata_DidInvalidateLayerTreeFrameSink =
     ::protozero::proto_utils::FieldMetadata<
       12,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kBool,
       bool,
-      ProcessStats_Process>;
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IsPeakRssResettable kIsPeakRssResettable() { return {}; }
-  void set_is_peak_rss_resettable(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_IsPeakRssResettable::kFieldId;
+  static constexpr FieldMetadata_DidInvalidateLayerTreeFrameSink kDidInvalidateLayerTreeFrameSink{};
+  void set_did_invalidate_layer_tree_frame_sink(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DidInvalidateLayerTreeFrameSink::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -155174,1750 +175593,1490 @@ class ProcessStats_Process : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ChromePrivateFootprintKb =
+  using FieldMetadata_DidPerformImplSideInvalidaion =
     ::protozero::proto_utils::FieldMetadata<
       13,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      ProcessStats_Process>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromePrivateFootprintKb kChromePrivateFootprintKb() { return {}; }
-  void set_chrome_private_footprint_kb(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ChromePrivateFootprintKb::kFieldId;
+  static constexpr FieldMetadata_DidPerformImplSideInvalidaion kDidPerformImplSideInvalidaion{};
+  void set_did_perform_impl_side_invalidaion(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DidPerformImplSideInvalidaion::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ChromePeakResidentSetKb =
+  using FieldMetadata_DidPrepareTiles =
     ::protozero::proto_utils::FieldMetadata<
       14,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      ProcessStats_Process>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromePeakResidentSetKb kChromePeakResidentSetKb() { return {}; }
-  void set_chrome_peak_resident_set_kb(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ChromePeakResidentSetKb::kFieldId;
+  static constexpr FieldMetadata_DidPrepareTiles kDidPrepareTiles{};
+  void set_did_prepare_tiles(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DidPrepareTiles::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Fds =
+  using FieldMetadata_ConsecutiveCheckerboardAnimations =
     ::protozero::proto_utils::FieldMetadata<
       15,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ProcessStats_FDInfo,
-      ProcessStats_Process>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Fds kFds() { return {}; }
-  template <typename T = ProcessStats_FDInfo> T* add_fds() {
-    return BeginNestedMessage<T>(15);
-  }
-
-};
-
-class ProcessStats_FDInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  ProcessStats_FDInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ProcessStats_FDInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ProcessStats_FDInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_fd() const { return at<1>().valid(); }
-  uint64_t fd() const { return at<1>().as_uint64(); }
-  bool has_path() const { return at<2>().valid(); }
-  ::protozero::ConstChars path() const { return at<2>().as_string(); }
-};
-
-class ProcessStats_FDInfo : public ::protozero::Message {
- public:
-  using Decoder = ProcessStats_FDInfo_Decoder;
-  enum : int32_t {
-    kFdFieldNumber = 1,
-    kPathFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ProcessStats.FDInfo"; }
-
-
-  using FieldMetadata_Fd =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProcessStats_FDInfo>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Fd kFd() { return {}; }
-  void set_fd(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Fd::kFieldId;
+  static constexpr FieldMetadata_ConsecutiveCheckerboardAnimations kConsecutiveCheckerboardAnimations{};
+  void set_consecutive_checkerboard_animations(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ConsecutiveCheckerboardAnimations::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Path =
+  using FieldMetadata_PendingSubmitFrames =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      16,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ProcessStats_FDInfo>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Path kPath() { return {}; }
-  void set_path(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Path::kFieldId, data, size);
-  }
-  void set_path(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Path::kFieldId, chars.data, chars.size);
-  }
-  void set_path(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Path::kFieldId;
+  static constexpr FieldMetadata_PendingSubmitFrames kPendingSubmitFrames{};
+  void set_pending_submit_frames(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PendingSubmitFrames::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-class ProcessStats_Thread_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  ProcessStats_Thread_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ProcessStats_Thread_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ProcessStats_Thread_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_tid() const { return at<1>().valid(); }
-  int32_t tid() const { return at<1>().as_int32(); }
-};
-
-class ProcessStats_Thread : public ::protozero::Message {
- public:
-  using Decoder = ProcessStats_Thread_Decoder;
-  enum : int32_t {
-    kTidFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ProcessStats.Thread"; }
-
 
-  using FieldMetadata_Tid =
+  using FieldMetadata_SubmitFramesWithCurrentLayerTreeFrameSink =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      17,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt32,
       int32_t,
-      ProcessStats_Thread>;
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Tid kTid() { return {}; }
-  void set_tid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId;
+  static constexpr FieldMetadata_SubmitFramesWithCurrentLayerTreeFrameSink kSubmitFramesWithCurrentLayerTreeFrameSink{};
+  void set_submit_frames_with_current_layer_tree_frame_sink(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SubmitFramesWithCurrentLayerTreeFrameSink::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ps/process_tree.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PS_PROCESS_TREE_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PS_PROCESS_TREE_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  using FieldMetadata_NeedsRedraw =
+    ::protozero::proto_utils::FieldMetadata<
+      18,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  static constexpr FieldMetadata_NeedsRedraw kNeedsRedraw{};
+  void set_needs_redraw(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_NeedsRedraw::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-class ProcessTree_Process;
-class ProcessTree_Thread;
+  using FieldMetadata_NeedsPrepareTiles =
+    ::protozero::proto_utils::FieldMetadata<
+      19,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-class ProcessTree_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  ProcessTree_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ProcessTree_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ProcessTree_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_processes() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> processes() const { return GetRepeated<::protozero::ConstBytes>(1); }
-  bool has_threads() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> threads() const { return GetRepeated<::protozero::ConstBytes>(2); }
-  bool has_collection_end_timestamp() const { return at<3>().valid(); }
-  uint64_t collection_end_timestamp() const { return at<3>().as_uint64(); }
-};
+  static constexpr FieldMetadata_NeedsPrepareTiles kNeedsPrepareTiles{};
+  void set_needs_prepare_tiles(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_NeedsPrepareTiles::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-class ProcessTree : public ::protozero::Message {
- public:
-  using Decoder = ProcessTree_Decoder;
-  enum : int32_t {
-    kProcessesFieldNumber = 1,
-    kThreadsFieldNumber = 2,
-    kCollectionEndTimestampFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ProcessTree"; }
+  using FieldMetadata_NeedsBeginMainFrame =
+    ::protozero::proto_utils::FieldMetadata<
+      20,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-  using Thread = ::perfetto::protos::pbzero::ProcessTree_Thread;
-  using Process = ::perfetto::protos::pbzero::ProcessTree_Process;
+  static constexpr FieldMetadata_NeedsBeginMainFrame kNeedsBeginMainFrame{};
+  void set_needs_begin_main_frame(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_NeedsBeginMainFrame::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Processes =
+  using FieldMetadata_NeedsOneBeginImplFrame =
     ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ProcessTree_Process,
-      ProcessTree>;
+      21,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Processes kProcesses() { return {}; }
-  template <typename T = ProcessTree_Process> T* add_processes() {
-    return BeginNestedMessage<T>(1);
+  static constexpr FieldMetadata_NeedsOneBeginImplFrame kNeedsOneBeginImplFrame{};
+  void set_needs_one_begin_impl_frame(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_NeedsOneBeginImplFrame::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_Threads =
+  using FieldMetadata_Visible =
     ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ProcessTree_Thread,
-      ProcessTree>;
+      22,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Threads kThreads() { return {}; }
-  template <typename T = ProcessTree_Thread> T* add_threads() {
-    return BeginNestedMessage<T>(2);
+  static constexpr FieldMetadata_Visible kVisible{};
+  void set_visible(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_Visible::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_CollectionEndTimestamp =
+  using FieldMetadata_BeginFrameSourcePaused =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      23,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ProcessTree>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CollectionEndTimestamp kCollectionEndTimestamp() { return {}; }
-  void set_collection_end_timestamp(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CollectionEndTimestamp::kFieldId;
+  static constexpr FieldMetadata_BeginFrameSourcePaused kBeginFrameSourcePaused{};
+  void set_begin_frame_source_paused(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_BeginFrameSourcePaused::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
-};
 
-class ProcessTree_Process_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  ProcessTree_Process_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ProcessTree_Process_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ProcessTree_Process_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pid() const { return at<1>().valid(); }
-  int32_t pid() const { return at<1>().as_int32(); }
-  bool has_ppid() const { return at<2>().valid(); }
-  int32_t ppid() const { return at<2>().as_int32(); }
-  bool has_cmdline() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> cmdline() const { return GetRepeated<::protozero::ConstChars>(3); }
-  bool has_threads_deprecated() const { return at<4>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> threads_deprecated() const { return GetRepeated<::protozero::ConstBytes>(4); }
-  bool has_uid() const { return at<5>().valid(); }
-  int32_t uid() const { return at<5>().as_int32(); }
-  bool has_nspid() const { return at<6>().valid(); }
-  ::protozero::RepeatedFieldIterator<int32_t> nspid() const { return GetRepeated<int32_t>(6); }
-};
-
-class ProcessTree_Process : public ::protozero::Message {
- public:
-  using Decoder = ProcessTree_Process_Decoder;
-  enum : int32_t {
-    kPidFieldNumber = 1,
-    kPpidFieldNumber = 2,
-    kCmdlineFieldNumber = 3,
-    kThreadsDeprecatedFieldNumber = 4,
-    kUidFieldNumber = 5,
-    kNspidFieldNumber = 6,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ProcessTree.Process"; }
+  using FieldMetadata_CanDraw =
+    ::protozero::proto_utils::FieldMetadata<
+      24,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
+  static constexpr FieldMetadata_CanDraw kCanDraw{};
+  void set_can_draw(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_CanDraw::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_ResourcelessDraw =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      25,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ProcessTree_Process>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_ResourcelessDraw kResourcelessDraw{};
+  void set_resourceless_draw(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ResourcelessDraw::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Ppid =
+  using FieldMetadata_HasPendingTree =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      26,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ProcessTree_Process>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Ppid kPpid() { return {}; }
-  void set_ppid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Ppid::kFieldId;
+  static constexpr FieldMetadata_HasPendingTree kHasPendingTree{};
+  void set_has_pending_tree(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_HasPendingTree::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Cmdline =
+  using FieldMetadata_PendingTreeIsReadyForActivation =
     ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ProcessTree_Process>;
+      27,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cmdline kCmdline() { return {}; }
-  void add_cmdline(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Cmdline::kFieldId, data, size);
-  }
-  void add_cmdline(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Cmdline::kFieldId, chars.data, chars.size);
-  }
-  void add_cmdline(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Cmdline::kFieldId;
+  static constexpr FieldMetadata_PendingTreeIsReadyForActivation kPendingTreeIsReadyForActivation{};
+  void set_pending_tree_is_ready_for_activation(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_PendingTreeIsReadyForActivation::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ThreadsDeprecated =
+  using FieldMetadata_ActiveTreeNeedsFirstDraw =
     ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ProcessTree_Thread,
-      ProcessTree_Process>;
+      28,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThreadsDeprecated kThreadsDeprecated() { return {}; }
-  template <typename T = ProcessTree_Thread> T* add_threads_deprecated() {
-    return BeginNestedMessage<T>(4);
+  static constexpr FieldMetadata_ActiveTreeNeedsFirstDraw kActiveTreeNeedsFirstDraw{};
+  void set_active_tree_needs_first_draw(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ActiveTreeNeedsFirstDraw::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_Uid =
+  using FieldMetadata_ActiveTreeIsReadyToDraw =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      29,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ProcessTree_Process>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Uid kUid() { return {}; }
-  void set_uid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId;
+  static constexpr FieldMetadata_ActiveTreeIsReadyToDraw kActiveTreeIsReadyToDraw{};
+  void set_active_tree_is_ready_to_draw(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ActiveTreeIsReadyToDraw::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Nspid =
+  using FieldMetadata_DidCreateAndInitializeFirstLayerTreeFrameSink =
     ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ProcessTree_Process>;
+      30,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nspid kNspid() { return {}; }
-  void add_nspid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Nspid::kFieldId;
+  static constexpr FieldMetadata_DidCreateAndInitializeFirstLayerTreeFrameSink kDidCreateAndInitializeFirstLayerTreeFrameSink{};
+  void set_did_create_and_initialize_first_layer_tree_frame_sink(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DidCreateAndInitializeFirstLayerTreeFrameSink::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
-};
-
-class ProcessTree_Thread_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  ProcessTree_Thread_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ProcessTree_Thread_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ProcessTree_Thread_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_tid() const { return at<1>().valid(); }
-  int32_t tid() const { return at<1>().as_int32(); }
-  bool has_tgid() const { return at<3>().valid(); }
-  int32_t tgid() const { return at<3>().as_int32(); }
-  bool has_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars name() const { return at<2>().as_string(); }
-  bool has_nstid() const { return at<4>().valid(); }
-  ::protozero::RepeatedFieldIterator<int32_t> nstid() const { return GetRepeated<int32_t>(4); }
-};
 
-class ProcessTree_Thread : public ::protozero::Message {
- public:
-  using Decoder = ProcessTree_Thread_Decoder;
-  enum : int32_t {
-    kTidFieldNumber = 1,
-    kTgidFieldNumber = 3,
-    kNameFieldNumber = 2,
-    kNstidFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ProcessTree.Thread"; }
+  using FieldMetadata_TreePriority =
+    ::protozero::proto_utils::FieldMetadata<
+      31,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ChromeCompositorStateMachine_MinorState_TreePriority,
+      ChromeCompositorStateMachine_MinorState>;
 
+  static constexpr FieldMetadata_TreePriority kTreePriority{};
+  void set_tree_priority(ChromeCompositorStateMachine_MinorState_TreePriority value) {
+    static constexpr uint32_t field_id = FieldMetadata_TreePriority::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Tid =
+  using FieldMetadata_ScrollHandlerState =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      32,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ProcessTree_Thread>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ChromeCompositorStateMachine_MinorState_ScrollHandlerState,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Tid kTid() { return {}; }
-  void set_tid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId;
+  static constexpr FieldMetadata_ScrollHandlerState kScrollHandlerState{};
+  void set_scroll_handler_state(ChromeCompositorStateMachine_MinorState_ScrollHandlerState value) {
+    static constexpr uint32_t field_id = FieldMetadata_ScrollHandlerState::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Tgid =
+  using FieldMetadata_CriticalBeginMainFrameToActivateIsFast =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      33,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ProcessTree_Thread>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Tgid kTgid() { return {}; }
-  void set_tgid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Tgid::kFieldId;
+  static constexpr FieldMetadata_CriticalBeginMainFrameToActivateIsFast kCriticalBeginMainFrameToActivateIsFast{};
+  void set_critical_begin_main_frame_to_activate_is_fast(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_CriticalBeginMainFrameToActivateIsFast::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Name =
+  using FieldMetadata_MainThreadMissedLastDeadline =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      34,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ProcessTree_Thread>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
-  }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
-  }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  static constexpr FieldMetadata_MainThreadMissedLastDeadline kMainThreadMissedLastDeadline{};
+  void set_main_thread_missed_last_deadline(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_MainThreadMissedLastDeadline::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Nstid =
+  using FieldMetadata_VideoNeedsBeginFrames =
     ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      ProcessTree_Thread>;
+      36,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nstid kNstid() { return {}; }
-  void add_nstid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Nstid::kFieldId;
+  static constexpr FieldMetadata_VideoNeedsBeginFrames kVideoNeedsBeginFrames{};
+  void set_video_needs_begin_frames(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_VideoNeedsBeginFrames::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/statsd/statsd_atom.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_STATSD_STATSD_ATOM_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_STATSD_STATSD_ATOM_PROTO_H_
+  using FieldMetadata_DeferBeginMainFrame =
+    ::protozero::proto_utils::FieldMetadata<
+      37,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-#include <stddef.h>
-#include <stdint.h>
+  static constexpr FieldMetadata_DeferBeginMainFrame kDeferBeginMainFrame{};
+  void set_defer_begin_main_frame(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DeferBeginMainFrame::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  using FieldMetadata_LastCommitHadNoUpdates =
+    ::protozero::proto_utils::FieldMetadata<
+      38,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  static constexpr FieldMetadata_LastCommitHadNoUpdates kLastCommitHadNoUpdates{};
+  void set_last_commit_had_no_updates(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_LastCommitHadNoUpdates::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-class OpaqueAtom;
+  using FieldMetadata_DidDrawInLastFrame =
+    ::protozero::proto_utils::FieldMetadata<
+      39,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-class StatsdAtom_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  StatsdAtom_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit StatsdAtom_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit StatsdAtom_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_nested() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> nested() const { return GetRepeated<::protozero::ConstBytes>(1); }
-};
+  static constexpr FieldMetadata_DidDrawInLastFrame kDidDrawInLastFrame{};
+  void set_did_draw_in_last_frame(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DidDrawInLastFrame::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-class StatsdAtom : public ::protozero::Message {
- public:
-  using Decoder = StatsdAtom_Decoder;
-  enum : int32_t {
-    kNestedFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.StatsdAtom"; }
+  using FieldMetadata_DidSubmitInLastFrame =
+    ::protozero::proto_utils::FieldMetadata<
+      40,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
+  static constexpr FieldMetadata_DidSubmitInLastFrame kDidSubmitInLastFrame{};
+  void set_did_submit_in_last_frame(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_DidSubmitInLastFrame::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Nested =
+  using FieldMetadata_NeedsImplSideInvalidation =
     ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      OpaqueAtom,
-      StatsdAtom>;
+      41,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nested kNested() { return {}; }
-  template <typename T = OpaqueAtom> T* add_nested() {
-    return BeginNestedMessage<T>(1);
+  static constexpr FieldMetadata_NeedsImplSideInvalidation kNeedsImplSideInvalidation{};
+  void set_needs_impl_side_invalidation(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_NeedsImplSideInvalidation::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
   }
 
-};
+  using FieldMetadata_CurrentPendingTreeIsImplSide =
+    ::protozero::proto_utils::FieldMetadata<
+      42,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-class OpaqueAtom_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  OpaqueAtom_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit OpaqueAtom_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit OpaqueAtom_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-};
+  static constexpr FieldMetadata_CurrentPendingTreeIsImplSide kCurrentPendingTreeIsImplSide{};
+  void set_current_pending_tree_is_impl_side(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_CurrentPendingTreeIsImplSide::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-class OpaqueAtom : public ::protozero::Message {
- public:
-  using Decoder = OpaqueAtom_Decoder;
-  static constexpr const char* GetName() { return ".perfetto.protos.OpaqueAtom"; }
+  using FieldMetadata_PreviousPendingTreeWasImplSide =
+    ::protozero::proto_utils::FieldMetadata<
+      43,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-};
+  static constexpr FieldMetadata_PreviousPendingTreeWasImplSide kPreviousPendingTreeWasImplSide{};
+  void set_previous_pending_tree_was_impl_side(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_PreviousPendingTreeWasImplSide::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/sys_stats/sys_stats.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+  using FieldMetadata_ProcessingAnimationWorkletsForActiveTree =
+    ::protozero::proto_utils::FieldMetadata<
+      44,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_SYS_STATS_SYS_STATS_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_SYS_STATS_SYS_STATS_PROTO_H_
+  static constexpr FieldMetadata_ProcessingAnimationWorkletsForActiveTree kProcessingAnimationWorkletsForActiveTree{};
+  void set_processing_animation_worklets_for_active_tree(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProcessingAnimationWorkletsForActiveTree::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-#include <stddef.h>
-#include <stdint.h>
+  using FieldMetadata_ProcessingAnimationWorkletsForPendingTree =
+    ::protozero::proto_utils::FieldMetadata<
+      45,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  static constexpr FieldMetadata_ProcessingAnimationWorkletsForPendingTree kProcessingAnimationWorkletsForPendingTree{};
+  void set_processing_animation_worklets_for_pending_tree(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProcessingAnimationWorkletsForPendingTree::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  using FieldMetadata_ProcessingPaintWorkletsForPendingTree =
+    ::protozero::proto_utils::FieldMetadata<
+      46,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorStateMachine_MinorState>;
 
-class SysStats_BuddyInfo;
-class SysStats_CpuTimes;
-class SysStats_DevfreqValue;
-class SysStats_DiskStat;
-class SysStats_InterruptCount;
-class SysStats_MeminfoValue;
-class SysStats_VmstatValue;
-enum MeminfoCounters : int32_t;
-enum VmstatCounters : int32_t;
+  static constexpr FieldMetadata_ProcessingPaintWorkletsForPendingTree kProcessingPaintWorkletsForPendingTree{};
+  void set_processing_paint_worklets_for_pending_tree(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProcessingPaintWorkletsForPendingTree::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+};
 
-class SysStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/13, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class ChromeCompositorStateMachine_MajorState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  SysStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SysStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SysStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_meminfo() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> meminfo() const { return GetRepeated<::protozero::ConstBytes>(1); }
-  bool has_vmstat() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> vmstat() const { return GetRepeated<::protozero::ConstBytes>(2); }
-  bool has_cpu_stat() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> cpu_stat() const { return GetRepeated<::protozero::ConstBytes>(3); }
-  bool has_num_forks() const { return at<4>().valid(); }
-  uint64_t num_forks() const { return at<4>().as_uint64(); }
-  bool has_num_irq_total() const { return at<5>().valid(); }
-  uint64_t num_irq_total() const { return at<5>().as_uint64(); }
-  bool has_num_irq() const { return at<6>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> num_irq() const { return GetRepeated<::protozero::ConstBytes>(6); }
-  bool has_num_softirq_total() const { return at<7>().valid(); }
-  uint64_t num_softirq_total() const { return at<7>().as_uint64(); }
-  bool has_num_softirq() const { return at<8>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> num_softirq() const { return GetRepeated<::protozero::ConstBytes>(8); }
-  bool has_collection_end_timestamp() const { return at<9>().valid(); }
-  uint64_t collection_end_timestamp() const { return at<9>().as_uint64(); }
-  bool has_devfreq() const { return at<10>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> devfreq() const { return GetRepeated<::protozero::ConstBytes>(10); }
-  bool has_cpufreq_khz() const { return at<11>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint32_t> cpufreq_khz() const { return GetRepeated<uint32_t>(11); }
-  bool has_buddy_info() const { return at<12>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> buddy_info() const { return GetRepeated<::protozero::ConstBytes>(12); }
-  bool has_disk_stat() const { return at<13>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> disk_stat() const { return GetRepeated<::protozero::ConstBytes>(13); }
+  ChromeCompositorStateMachine_MajorState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeCompositorStateMachine_MajorState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeCompositorStateMachine_MajorState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_next_action() const { return at<1>().valid(); }
+  int32_t next_action() const { return at<1>().as_int32(); }
+  bool has_begin_impl_frame_state() const { return at<2>().valid(); }
+  int32_t begin_impl_frame_state() const { return at<2>().as_int32(); }
+  bool has_begin_main_frame_state() const { return at<3>().valid(); }
+  int32_t begin_main_frame_state() const { return at<3>().as_int32(); }
+  bool has_layer_tree_frame_sink_state() const { return at<4>().valid(); }
+  int32_t layer_tree_frame_sink_state() const { return at<4>().as_int32(); }
+  bool has_forced_redraw_state() const { return at<5>().valid(); }
+  int32_t forced_redraw_state() const { return at<5>().as_int32(); }
 };
 
-class SysStats : public ::protozero::Message {
+class ChromeCompositorStateMachine_MajorState : public ::protozero::Message {
  public:
-  using Decoder = SysStats_Decoder;
+  using Decoder = ChromeCompositorStateMachine_MajorState_Decoder;
   enum : int32_t {
-    kMeminfoFieldNumber = 1,
-    kVmstatFieldNumber = 2,
-    kCpuStatFieldNumber = 3,
-    kNumForksFieldNumber = 4,
-    kNumIrqTotalFieldNumber = 5,
-    kNumIrqFieldNumber = 6,
-    kNumSoftirqTotalFieldNumber = 7,
-    kNumSoftirqFieldNumber = 8,
-    kCollectionEndTimestampFieldNumber = 9,
-    kDevfreqFieldNumber = 10,
-    kCpufreqKhzFieldNumber = 11,
-    kBuddyInfoFieldNumber = 12,
-    kDiskStatFieldNumber = 13,
+    kNextActionFieldNumber = 1,
+    kBeginImplFrameStateFieldNumber = 2,
+    kBeginMainFrameStateFieldNumber = 3,
+    kLayerTreeFrameSinkStateFieldNumber = 4,
+    kForcedRedrawStateFieldNumber = 5,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SysStats"; }
-
-  using MeminfoValue = ::perfetto::protos::pbzero::SysStats_MeminfoValue;
-  using VmstatValue = ::perfetto::protos::pbzero::SysStats_VmstatValue;
-  using CpuTimes = ::perfetto::protos::pbzero::SysStats_CpuTimes;
-  using InterruptCount = ::perfetto::protos::pbzero::SysStats_InterruptCount;
-  using DevfreqValue = ::perfetto::protos::pbzero::SysStats_DevfreqValue;
-  using BuddyInfo = ::perfetto::protos::pbzero::SysStats_BuddyInfo;
-  using DiskStat = ::perfetto::protos::pbzero::SysStats_DiskStat;
-
-  using FieldMetadata_Meminfo =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      SysStats_MeminfoValue,
-      SysStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Meminfo kMeminfo() { return {}; }
-  template <typename T = SysStats_MeminfoValue> T* add_meminfo() {
-    return BeginNestedMessage<T>(1);
-  }
-
-
-  using FieldMetadata_Vmstat =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      SysStats_VmstatValue,
-      SysStats>;
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeCompositorStateMachine.MajorState"; }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Vmstat kVmstat() { return {}; }
-  template <typename T = SysStats_VmstatValue> T* add_vmstat() {
-    return BeginNestedMessage<T>(2);
-  }
 
+  using BeginImplFrameState = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginImplFrameState;
+  static inline const char* BeginImplFrameState_Name(BeginImplFrameState value) {
+    return ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginImplFrameState_Name(value);
+  }
 
-  using FieldMetadata_CpuStat =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      SysStats_CpuTimes,
-      SysStats>;
+  using BeginMainFrameState = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginMainFrameState;
+  static inline const char* BeginMainFrameState_Name(BeginMainFrameState value) {
+    return ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginMainFrameState_Name(value);
+  }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpuStat kCpuStat() { return {}; }
-  template <typename T = SysStats_CpuTimes> T* add_cpu_stat() {
-    return BeginNestedMessage<T>(3);
+  using LayerTreeFrameSinkState = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState;
+  static inline const char* LayerTreeFrameSinkState_Name(LayerTreeFrameSinkState value) {
+    return ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_Name(value);
   }
 
+  using ForcedRedrawOnTimeoutState = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState;
+  static inline const char* ForcedRedrawOnTimeoutState_Name(ForcedRedrawOnTimeoutState value) {
+    return ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_Name(value);
+  }
+  static inline const BeginImplFrameState BEGIN_IMPL_FRAME_UNSPECIFIED = BeginImplFrameState::BEGIN_IMPL_FRAME_UNSPECIFIED;
+  static inline const BeginImplFrameState BEGIN_IMPL_FRAME_IDLE = BeginImplFrameState::BEGIN_IMPL_FRAME_IDLE;
+  static inline const BeginImplFrameState BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME = BeginImplFrameState::BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME;
+  static inline const BeginImplFrameState BEGIN_IMPL_FRAME_INSIDE_DEADLINE = BeginImplFrameState::BEGIN_IMPL_FRAME_INSIDE_DEADLINE;
+  static inline const BeginMainFrameState BEGIN_MAIN_FRAME_UNSPECIFIED = BeginMainFrameState::BEGIN_MAIN_FRAME_UNSPECIFIED;
+  static inline const BeginMainFrameState BEGIN_MAIN_FRAME_IDLE = BeginMainFrameState::BEGIN_MAIN_FRAME_IDLE;
+  static inline const BeginMainFrameState BEGIN_MAIN_FRAME_SENT = BeginMainFrameState::BEGIN_MAIN_FRAME_SENT;
+  static inline const BeginMainFrameState BEGIN_MAIN_FRAME_READY_TO_COMMIT = BeginMainFrameState::BEGIN_MAIN_FRAME_READY_TO_COMMIT;
+  static inline const LayerTreeFrameSinkState LAYER_TREE_FRAME_UNSPECIFIED = LayerTreeFrameSinkState::LAYER_TREE_FRAME_UNSPECIFIED;
+  static inline const LayerTreeFrameSinkState LAYER_TREE_FRAME_NONE = LayerTreeFrameSinkState::LAYER_TREE_FRAME_NONE;
+  static inline const LayerTreeFrameSinkState LAYER_TREE_FRAME_ACTIVE = LayerTreeFrameSinkState::LAYER_TREE_FRAME_ACTIVE;
+  static inline const LayerTreeFrameSinkState LAYER_TREE_FRAME_CREATING = LayerTreeFrameSinkState::LAYER_TREE_FRAME_CREATING;
+  static inline const LayerTreeFrameSinkState LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT = LayerTreeFrameSinkState::LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT;
+  static inline const LayerTreeFrameSinkState LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION = LayerTreeFrameSinkState::LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION;
+  static inline const ForcedRedrawOnTimeoutState FORCED_REDRAW_UNSPECIFIED = ForcedRedrawOnTimeoutState::FORCED_REDRAW_UNSPECIFIED;
+  static inline const ForcedRedrawOnTimeoutState FORCED_REDRAW_IDLE = ForcedRedrawOnTimeoutState::FORCED_REDRAW_IDLE;
+  static inline const ForcedRedrawOnTimeoutState FORCED_REDRAW_WAITING_FOR_COMMIT = ForcedRedrawOnTimeoutState::FORCED_REDRAW_WAITING_FOR_COMMIT;
+  static inline const ForcedRedrawOnTimeoutState FORCED_REDRAW_WAITING_FOR_ACTIVATION = ForcedRedrawOnTimeoutState::FORCED_REDRAW_WAITING_FOR_ACTIVATION;
+  static inline const ForcedRedrawOnTimeoutState FORCED_REDRAW_WAITING_FOR_DRAW = ForcedRedrawOnTimeoutState::FORCED_REDRAW_WAITING_FOR_DRAW;
 
-  using FieldMetadata_NumForks =
+  using FieldMetadata_NextAction =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SysStats>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ChromeCompositorSchedulerAction,
+      ChromeCompositorStateMachine_MajorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NumForks kNumForks() { return {}; }
-  void set_num_forks(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NumForks::kFieldId;
+  static constexpr FieldMetadata_NextAction kNextAction{};
+  void set_next_action(ChromeCompositorSchedulerAction value) {
+    static constexpr uint32_t field_id = FieldMetadata_NextAction::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NumIrqTotal =
+  using FieldMetadata_BeginImplFrameState =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SysStats>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ChromeCompositorStateMachine_MajorState_BeginImplFrameState,
+      ChromeCompositorStateMachine_MajorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NumIrqTotal kNumIrqTotal() { return {}; }
-  void set_num_irq_total(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NumIrqTotal::kFieldId;
+  static constexpr FieldMetadata_BeginImplFrameState kBeginImplFrameState{};
+  void set_begin_impl_frame_state(ChromeCompositorStateMachine_MajorState_BeginImplFrameState value) {
+    static constexpr uint32_t field_id = FieldMetadata_BeginImplFrameState::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NumIrq =
-    ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      SysStats_InterruptCount,
-      SysStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NumIrq kNumIrq() { return {}; }
-  template <typename T = SysStats_InterruptCount> T* add_num_irq() {
-    return BeginNestedMessage<T>(6);
-  }
-
-
-  using FieldMetadata_NumSoftirqTotal =
+  using FieldMetadata_BeginMainFrameState =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SysStats>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ChromeCompositorStateMachine_MajorState_BeginMainFrameState,
+      ChromeCompositorStateMachine_MajorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NumSoftirqTotal kNumSoftirqTotal() { return {}; }
-  void set_num_softirq_total(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_NumSoftirqTotal::kFieldId;
+  static constexpr FieldMetadata_BeginMainFrameState kBeginMainFrameState{};
+  void set_begin_main_frame_state(ChromeCompositorStateMachine_MajorState_BeginMainFrameState value) {
+    static constexpr uint32_t field_id = FieldMetadata_BeginMainFrameState::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NumSoftirq =
-    ::protozero::proto_utils::FieldMetadata<
-      8,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      SysStats_InterruptCount,
-      SysStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NumSoftirq kNumSoftirq() { return {}; }
-  template <typename T = SysStats_InterruptCount> T* add_num_softirq() {
-    return BeginNestedMessage<T>(8);
-  }
-
-
-  using FieldMetadata_CollectionEndTimestamp =
+  using FieldMetadata_LayerTreeFrameSinkState =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SysStats>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState,
+      ChromeCompositorStateMachine_MajorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CollectionEndTimestamp kCollectionEndTimestamp() { return {}; }
-  void set_collection_end_timestamp(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CollectionEndTimestamp::kFieldId;
+  static constexpr FieldMetadata_LayerTreeFrameSinkState kLayerTreeFrameSinkState{};
+  void set_layer_tree_frame_sink_state(ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState value) {
+    static constexpr uint32_t field_id = FieldMetadata_LayerTreeFrameSinkState::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Devfreq =
-    ::protozero::proto_utils::FieldMetadata<
-      10,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      SysStats_DevfreqValue,
-      SysStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Devfreq kDevfreq() { return {}; }
-  template <typename T = SysStats_DevfreqValue> T* add_devfreq() {
-    return BeginNestedMessage<T>(10);
-  }
-
-
-  using FieldMetadata_CpufreqKhz =
+  using FieldMetadata_ForcedRedrawState =
     ::protozero::proto_utils::FieldMetadata<
-      11,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SysStats>;
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState,
+      ChromeCompositorStateMachine_MajorState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpufreqKhz kCpufreqKhz() { return {}; }
-  void add_cpufreq_khz(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CpufreqKhz::kFieldId;
+  static constexpr FieldMetadata_ForcedRedrawState kForcedRedrawState{};
+  void set_forced_redraw_state(ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState value) {
+    static constexpr uint32_t field_id = FieldMetadata_ForcedRedrawState::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
-
-  using FieldMetadata_BuddyInfo =
-    ::protozero::proto_utils::FieldMetadata<
-      12,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      SysStats_BuddyInfo,
-      SysStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_BuddyInfo kBuddyInfo() { return {}; }
-  template <typename T = SysStats_BuddyInfo> T* add_buddy_info() {
-    return BeginNestedMessage<T>(12);
-  }
-
-
-  using FieldMetadata_DiskStat =
-    ::protozero::proto_utils::FieldMetadata<
-      13,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      SysStats_DiskStat,
-      SysStats>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DiskStat kDiskStat() { return {}; }
-  template <typename T = SysStats_DiskStat> T* add_disk_stat() {
-    return BeginNestedMessage<T>(13);
-  }
-
 };
 
-class SysStats_DiskStat_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class ChromeCompositorSchedulerState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/17> {
  public:
-  SysStats_DiskStat_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SysStats_DiskStat_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SysStats_DiskStat_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_device_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars device_name() const { return at<1>().as_string(); }
-  bool has_read_sectors() const { return at<2>().valid(); }
-  uint64_t read_sectors() const { return at<2>().as_uint64(); }
-  bool has_read_time_ms() const { return at<3>().valid(); }
-  uint64_t read_time_ms() const { return at<3>().as_uint64(); }
-  bool has_write_sectors() const { return at<4>().valid(); }
-  uint64_t write_sectors() const { return at<4>().as_uint64(); }
-  bool has_write_time_ms() const { return at<5>().valid(); }
-  uint64_t write_time_ms() const { return at<5>().as_uint64(); }
-  bool has_discard_sectors() const { return at<6>().valid(); }
-  uint64_t discard_sectors() const { return at<6>().as_uint64(); }
-  bool has_discard_time_ms() const { return at<7>().valid(); }
-  uint64_t discard_time_ms() const { return at<7>().as_uint64(); }
-  bool has_flush_count() const { return at<8>().valid(); }
-  uint64_t flush_count() const { return at<8>().as_uint64(); }
-  bool has_flush_time_ms() const { return at<9>().valid(); }
-  uint64_t flush_time_ms() const { return at<9>().as_uint64(); }
+  ChromeCompositorSchedulerState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeCompositorSchedulerState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeCompositorSchedulerState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_state_machine() const { return at<1>().valid(); }
+  ::protozero::ConstBytes state_machine() const { return at<1>().as_bytes(); }
+  bool has_observing_begin_frame_source() const { return at<2>().valid(); }
+  bool observing_begin_frame_source() const { return at<2>().as_bool(); }
+  bool has_begin_impl_frame_deadline_task() const { return at<3>().valid(); }
+  bool begin_impl_frame_deadline_task() const { return at<3>().as_bool(); }
+  bool has_pending_begin_frame_task() const { return at<4>().valid(); }
+  bool pending_begin_frame_task() const { return at<4>().as_bool(); }
+  bool has_skipped_last_frame_missed_exceeded_deadline() const { return at<5>().valid(); }
+  bool skipped_last_frame_missed_exceeded_deadline() const { return at<5>().as_bool(); }
+  bool has_inside_action() const { return at<7>().valid(); }
+  int32_t inside_action() const { return at<7>().as_int32(); }
+  bool has_deadline_mode() const { return at<8>().valid(); }
+  int32_t deadline_mode() const { return at<8>().as_int32(); }
+  bool has_deadline_us() const { return at<9>().valid(); }
+  int64_t deadline_us() const { return at<9>().as_int64(); }
+  bool has_deadline_scheduled_at_us() const { return at<10>().valid(); }
+  int64_t deadline_scheduled_at_us() const { return at<10>().as_int64(); }
+  bool has_now_us() const { return at<11>().valid(); }
+  int64_t now_us() const { return at<11>().as_int64(); }
+  bool has_now_to_deadline_delta_us() const { return at<12>().valid(); }
+  int64_t now_to_deadline_delta_us() const { return at<12>().as_int64(); }
+  bool has_now_to_deadline_scheduled_at_delta_us() const { return at<13>().valid(); }
+  int64_t now_to_deadline_scheduled_at_delta_us() const { return at<13>().as_int64(); }
+  bool has_begin_impl_frame_args() const { return at<14>().valid(); }
+  ::protozero::ConstBytes begin_impl_frame_args() const { return at<14>().as_bytes(); }
+  bool has_begin_frame_observer_state() const { return at<15>().valid(); }
+  ::protozero::ConstBytes begin_frame_observer_state() const { return at<15>().as_bytes(); }
+  bool has_begin_frame_source_state() const { return at<16>().valid(); }
+  ::protozero::ConstBytes begin_frame_source_state() const { return at<16>().as_bytes(); }
+  bool has_compositor_timing_history() const { return at<17>().valid(); }
+  ::protozero::ConstBytes compositor_timing_history() const { return at<17>().as_bytes(); }
 };
 
-class SysStats_DiskStat : public ::protozero::Message {
+class ChromeCompositorSchedulerState : public ::protozero::Message {
  public:
-  using Decoder = SysStats_DiskStat_Decoder;
+  using Decoder = ChromeCompositorSchedulerState_Decoder;
   enum : int32_t {
-    kDeviceNameFieldNumber = 1,
-    kReadSectorsFieldNumber = 2,
-    kReadTimeMsFieldNumber = 3,
-    kWriteSectorsFieldNumber = 4,
-    kWriteTimeMsFieldNumber = 5,
-    kDiscardSectorsFieldNumber = 6,
-    kDiscardTimeMsFieldNumber = 7,
-    kFlushCountFieldNumber = 8,
-    kFlushTimeMsFieldNumber = 9,
+    kStateMachineFieldNumber = 1,
+    kObservingBeginFrameSourceFieldNumber = 2,
+    kBeginImplFrameDeadlineTaskFieldNumber = 3,
+    kPendingBeginFrameTaskFieldNumber = 4,
+    kSkippedLastFrameMissedExceededDeadlineFieldNumber = 5,
+    kInsideActionFieldNumber = 7,
+    kDeadlineModeFieldNumber = 8,
+    kDeadlineUsFieldNumber = 9,
+    kDeadlineScheduledAtUsFieldNumber = 10,
+    kNowUsFieldNumber = 11,
+    kNowToDeadlineDeltaUsFieldNumber = 12,
+    kNowToDeadlineScheduledAtDeltaUsFieldNumber = 13,
+    kBeginImplFrameArgsFieldNumber = 14,
+    kBeginFrameObserverStateFieldNumber = 15,
+    kBeginFrameSourceStateFieldNumber = 16,
+    kCompositorTimingHistoryFieldNumber = 17,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SysStats.DiskStat"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeCompositorSchedulerState"; }
 
 
-  using FieldMetadata_DeviceName =
+  using BeginImplFrameDeadlineMode = ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode;
+  static inline const char* BeginImplFrameDeadlineMode_Name(BeginImplFrameDeadlineMode value) {
+    return ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_Name(value);
+  }
+  static inline const BeginImplFrameDeadlineMode DEADLINE_MODE_UNSPECIFIED = BeginImplFrameDeadlineMode::DEADLINE_MODE_UNSPECIFIED;
+  static inline const BeginImplFrameDeadlineMode DEADLINE_MODE_NONE = BeginImplFrameDeadlineMode::DEADLINE_MODE_NONE;
+  static inline const BeginImplFrameDeadlineMode DEADLINE_MODE_IMMEDIATE = BeginImplFrameDeadlineMode::DEADLINE_MODE_IMMEDIATE;
+  static inline const BeginImplFrameDeadlineMode DEADLINE_MODE_REGULAR = BeginImplFrameDeadlineMode::DEADLINE_MODE_REGULAR;
+  static inline const BeginImplFrameDeadlineMode DEADLINE_MODE_LATE = BeginImplFrameDeadlineMode::DEADLINE_MODE_LATE;
+  static inline const BeginImplFrameDeadlineMode DEADLINE_MODE_BLOCKED = BeginImplFrameDeadlineMode::DEADLINE_MODE_BLOCKED;
+
+  using FieldMetadata_StateMachine =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SysStats_DiskStat>;
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromeCompositorStateMachine,
+      ChromeCompositorSchedulerState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DeviceName kDeviceName() { return {}; }
-  void set_device_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_DeviceName::kFieldId, data, size);
-  }
-  void set_device_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_DeviceName::kFieldId, chars.data, chars.size);
-  }
-  void set_device_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_DeviceName::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_StateMachine kStateMachine{};
+  template <typename T = ChromeCompositorStateMachine> T* set_state_machine() {
+    return BeginNestedMessage<T>(1);
   }
 
-  using FieldMetadata_ReadSectors =
+
+  using FieldMetadata_ObservingBeginFrameSource =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SysStats_DiskStat>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorSchedulerState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReadSectors kReadSectors() { return {}; }
-  void set_read_sectors(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReadSectors::kFieldId;
+  static constexpr FieldMetadata_ObservingBeginFrameSource kObservingBeginFrameSource{};
+  void set_observing_begin_frame_source(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ObservingBeginFrameSource::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ReadTimeMs =
+  using FieldMetadata_BeginImplFrameDeadlineTask =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SysStats_DiskStat>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorSchedulerState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ReadTimeMs kReadTimeMs() { return {}; }
-  void set_read_time_ms(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ReadTimeMs::kFieldId;
+  static constexpr FieldMetadata_BeginImplFrameDeadlineTask kBeginImplFrameDeadlineTask{};
+  void set_begin_impl_frame_deadline_task(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_BeginImplFrameDeadlineTask::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_WriteSectors =
+  using FieldMetadata_PendingBeginFrameTask =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SysStats_DiskStat>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorSchedulerState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WriteSectors kWriteSectors() { return {}; }
-  void set_write_sectors(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_WriteSectors::kFieldId;
+  static constexpr FieldMetadata_PendingBeginFrameTask kPendingBeginFrameTask{};
+  void set_pending_begin_frame_task(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_PendingBeginFrameTask::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_WriteTimeMs =
+  using FieldMetadata_SkippedLastFrameMissedExceededDeadline =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SysStats_DiskStat>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeCompositorSchedulerState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_WriteTimeMs kWriteTimeMs() { return {}; }
-  void set_write_time_ms(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_WriteTimeMs::kFieldId;
+  static constexpr FieldMetadata_SkippedLastFrameMissedExceededDeadline kSkippedLastFrameMissedExceededDeadline{};
+  void set_skipped_last_frame_missed_exceeded_deadline(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_SkippedLastFrameMissedExceededDeadline::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DiscardSectors =
+  using FieldMetadata_InsideAction =
     ::protozero::proto_utils::FieldMetadata<
-      6,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SysStats_DiskStat>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ChromeCompositorSchedulerAction,
+      ChromeCompositorSchedulerState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DiscardSectors kDiscardSectors() { return {}; }
-  void set_discard_sectors(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DiscardSectors::kFieldId;
+  static constexpr FieldMetadata_InsideAction kInsideAction{};
+  void set_inside_action(ChromeCompositorSchedulerAction value) {
+    static constexpr uint32_t field_id = FieldMetadata_InsideAction::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_DiscardTimeMs =
+  using FieldMetadata_DeadlineMode =
     ::protozero::proto_utils::FieldMetadata<
-      7,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SysStats_DiskStat>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode,
+      ChromeCompositorSchedulerState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DiscardTimeMs kDiscardTimeMs() { return {}; }
-  void set_discard_time_ms(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_DiscardTimeMs::kFieldId;
+  static constexpr FieldMetadata_DeadlineMode kDeadlineMode{};
+  void set_deadline_mode(ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode value) {
+    static constexpr uint32_t field_id = FieldMetadata_DeadlineMode::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FlushCount =
+  using FieldMetadata_DeadlineUs =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SysStats_DiskStat>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ChromeCompositorSchedulerState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FlushCount kFlushCount() { return {}; }
-  void set_flush_count(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FlushCount::kFieldId;
+  static constexpr FieldMetadata_DeadlineUs kDeadlineUs{};
+  void set_deadline_us(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DeadlineUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FlushTimeMs =
+  using FieldMetadata_DeadlineScheduledAtUs =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SysStats_DiskStat>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ChromeCompositorSchedulerState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FlushTimeMs kFlushTimeMs() { return {}; }
-  void set_flush_time_ms(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_FlushTimeMs::kFieldId;
+  static constexpr FieldMetadata_DeadlineScheduledAtUs kDeadlineScheduledAtUs{};
+  void set_deadline_scheduled_at_us(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DeadlineScheduledAtUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
-};
-
-class SysStats_BuddyInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  SysStats_BuddyInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SysStats_BuddyInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SysStats_BuddyInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_node() const { return at<1>().valid(); }
-  ::protozero::ConstChars node() const { return at<1>().as_string(); }
-  bool has_zone() const { return at<2>().valid(); }
-  ::protozero::ConstChars zone() const { return at<2>().as_string(); }
-  bool has_order_pages() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint32_t> order_pages() const { return GetRepeated<uint32_t>(3); }
-};
-
-class SysStats_BuddyInfo : public ::protozero::Message {
- public:
-  using Decoder = SysStats_BuddyInfo_Decoder;
-  enum : int32_t {
-    kNodeFieldNumber = 1,
-    kZoneFieldNumber = 2,
-    kOrderPagesFieldNumber = 3,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.SysStats.BuddyInfo"; }
 
-
-  using FieldMetadata_Node =
+  using FieldMetadata_NowUs =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SysStats_BuddyInfo>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ChromeCompositorSchedulerState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Node kNode() { return {}; }
-  void set_node(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Node::kFieldId, data, size);
-  }
-  void set_node(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Node::kFieldId, chars.data, chars.size);
-  }
-  void set_node(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Node::kFieldId;
+  static constexpr FieldMetadata_NowUs kNowUs{};
+  void set_now_us(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NowUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Zone =
+  using FieldMetadata_NowToDeadlineDeltaUs =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      12,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SysStats_BuddyInfo>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ChromeCompositorSchedulerState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Zone kZone() { return {}; }
-  void set_zone(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Zone::kFieldId, data, size);
-  }
-  void set_zone(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Zone::kFieldId, chars.data, chars.size);
-  }
-  void set_zone(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Zone::kFieldId;
+  static constexpr FieldMetadata_NowToDeadlineDeltaUs kNowToDeadlineDeltaUs{};
+  void set_now_to_deadline_delta_us(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NowToDeadlineDeltaUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_OrderPages =
+  using FieldMetadata_NowToDeadlineScheduledAtDeltaUs =
     ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SysStats_BuddyInfo>;
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ChromeCompositorSchedulerState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OrderPages kOrderPages() { return {}; }
-  void add_order_pages(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_OrderPages::kFieldId;
+  static constexpr FieldMetadata_NowToDeadlineScheduledAtDeltaUs kNowToDeadlineScheduledAtDeltaUs{};
+  void set_now_to_deadline_scheduled_at_delta_us(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NowToDeadlineScheduledAtDeltaUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
-};
 
-class SysStats_DevfreqValue_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  SysStats_DevfreqValue_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SysStats_DevfreqValue_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SysStats_DevfreqValue_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_key() const { return at<1>().valid(); }
-  ::protozero::ConstChars key() const { return at<1>().as_string(); }
-  bool has_value() const { return at<2>().valid(); }
-  uint64_t value() const { return at<2>().as_uint64(); }
-};
+  using FieldMetadata_BeginImplFrameArgs =
+    ::protozero::proto_utils::FieldMetadata<
+      14,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BeginImplFrameArgs,
+      ChromeCompositorSchedulerState>;
 
-class SysStats_DevfreqValue : public ::protozero::Message {
- public:
-  using Decoder = SysStats_DevfreqValue_Decoder;
-  enum : int32_t {
-    kKeyFieldNumber = 1,
-    kValueFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.SysStats.DevfreqValue"; }
+  static constexpr FieldMetadata_BeginImplFrameArgs kBeginImplFrameArgs{};
+  template <typename T = BeginImplFrameArgs> T* set_begin_impl_frame_args() {
+    return BeginNestedMessage<T>(14);
+  }
 
 
-  using FieldMetadata_Key =
+  using FieldMetadata_BeginFrameObserverState =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      15,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SysStats_DevfreqValue>;
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BeginFrameObserverState,
+      ChromeCompositorSchedulerState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Key kKey() { return {}; }
-  void set_key(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Key::kFieldId, data, size);
-  }
-  void set_key(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Key::kFieldId, chars.data, chars.size);
+  static constexpr FieldMetadata_BeginFrameObserverState kBeginFrameObserverState{};
+  template <typename T = BeginFrameObserverState> T* set_begin_frame_observer_state() {
+    return BeginNestedMessage<T>(15);
   }
-  void set_key(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
+
+
+  using FieldMetadata_BeginFrameSourceState =
+    ::protozero::proto_utils::FieldMetadata<
+      16,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BeginFrameSourceState,
+      ChromeCompositorSchedulerState>;
+
+  static constexpr FieldMetadata_BeginFrameSourceState kBeginFrameSourceState{};
+  template <typename T = BeginFrameSourceState> T* set_begin_frame_source_state() {
+    return BeginNestedMessage<T>(16);
   }
 
-  using FieldMetadata_Value =
+
+  using FieldMetadata_CompositorTimingHistory =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      17,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SysStats_DevfreqValue>;
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      CompositorTimingHistory,
+      ChromeCompositorSchedulerState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
+  static constexpr FieldMetadata_CompositorTimingHistory kCompositorTimingHistory{};
+  template <typename T = CompositorTimingHistory> T* set_compositor_timing_history() {
+    return BeginNestedMessage<T>(17);
   }
+
 };
 
-class SysStats_InterruptCount_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_content_settings_event_info.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_CONTENT_SETTINGS_EVENT_INFO_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_CONTENT_SETTINGS_EVENT_INFO_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class ChromeContentSettingsEventInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  SysStats_InterruptCount_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SysStats_InterruptCount_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SysStats_InterruptCount_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_irq() const { return at<1>().valid(); }
-  int32_t irq() const { return at<1>().as_int32(); }
-  bool has_count() const { return at<2>().valid(); }
-  uint64_t count() const { return at<2>().as_uint64(); }
+  ChromeContentSettingsEventInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeContentSettingsEventInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeContentSettingsEventInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_number_of_exceptions() const { return at<1>().valid(); }
+  uint32_t number_of_exceptions() const { return at<1>().as_uint32(); }
 };
 
-class SysStats_InterruptCount : public ::protozero::Message {
+class ChromeContentSettingsEventInfo : public ::protozero::Message {
  public:
-  using Decoder = SysStats_InterruptCount_Decoder;
+  using Decoder = ChromeContentSettingsEventInfo_Decoder;
   enum : int32_t {
-    kIrqFieldNumber = 1,
-    kCountFieldNumber = 2,
+    kNumberOfExceptionsFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SysStats.InterruptCount"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeContentSettingsEventInfo"; }
 
 
-  using FieldMetadata_Irq =
+  using FieldMetadata_NumberOfExceptions =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      SysStats_InterruptCount>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ChromeContentSettingsEventInfo>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Irq kIrq() { return {}; }
-  void set_irq(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Irq::kFieldId;
+  static constexpr FieldMetadata_NumberOfExceptions kNumberOfExceptions{};
+  void set_number_of_exceptions(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NumberOfExceptions::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Count =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SysStats_InterruptCount>;
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_frame_reporter.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Count kCount() { return {}; }
-  void set_count(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_FRAME_REPORTER_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_FRAME_REPORTER_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+namespace perfetto_pbzero_enum_ChromeFrameReporter {
+enum FrameDropReason : int32_t;
+}  // namespace perfetto_pbzero_enum_ChromeFrameReporter
+using ChromeFrameReporter_FrameDropReason = perfetto_pbzero_enum_ChromeFrameReporter::FrameDropReason;
+namespace perfetto_pbzero_enum_ChromeFrameReporter {
+enum FrameType : int32_t;
+}  // namespace perfetto_pbzero_enum_ChromeFrameReporter
+using ChromeFrameReporter_FrameType = perfetto_pbzero_enum_ChromeFrameReporter::FrameType;
+namespace perfetto_pbzero_enum_ChromeFrameReporter {
+enum ScrollState : int32_t;
+}  // namespace perfetto_pbzero_enum_ChromeFrameReporter
+using ChromeFrameReporter_ScrollState = perfetto_pbzero_enum_ChromeFrameReporter::ScrollState;
+namespace perfetto_pbzero_enum_ChromeFrameReporter {
+enum State : int32_t;
+}  // namespace perfetto_pbzero_enum_ChromeFrameReporter
+using ChromeFrameReporter_State = perfetto_pbzero_enum_ChromeFrameReporter::State;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_ChromeFrameReporter {
+enum State : int32_t {
+  STATE_NO_UPDATE_DESIRED = 0,
+  STATE_PRESENTED_ALL = 1,
+  STATE_PRESENTED_PARTIAL = 2,
+  STATE_DROPPED = 3,
+};
+} // namespace perfetto_pbzero_enum_ChromeFrameReporter
+using ChromeFrameReporter_State = perfetto_pbzero_enum_ChromeFrameReporter::State;
+
+
+constexpr ChromeFrameReporter_State ChromeFrameReporter_State_MIN = ChromeFrameReporter_State::STATE_NO_UPDATE_DESIRED;
+constexpr ChromeFrameReporter_State ChromeFrameReporter_State_MAX = ChromeFrameReporter_State::STATE_DROPPED;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ChromeFrameReporter_State_Name(::perfetto::protos::pbzero::ChromeFrameReporter_State value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ChromeFrameReporter_State::STATE_NO_UPDATE_DESIRED:
+    return "STATE_NO_UPDATE_DESIRED";
+
+  case ::perfetto::protos::pbzero::ChromeFrameReporter_State::STATE_PRESENTED_ALL:
+    return "STATE_PRESENTED_ALL";
+
+  case ::perfetto::protos::pbzero::ChromeFrameReporter_State::STATE_PRESENTED_PARTIAL:
+    return "STATE_PRESENTED_PARTIAL";
+
+  case ::perfetto::protos::pbzero::ChromeFrameReporter_State::STATE_DROPPED:
+    return "STATE_DROPPED";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_ChromeFrameReporter {
+enum FrameDropReason : int32_t {
+  REASON_UNSPECIFIED = 0,
+  REASON_DISPLAY_COMPOSITOR = 1,
+  REASON_MAIN_THREAD = 2,
+  REASON_CLIENT_COMPOSITOR = 3,
+};
+} // namespace perfetto_pbzero_enum_ChromeFrameReporter
+using ChromeFrameReporter_FrameDropReason = perfetto_pbzero_enum_ChromeFrameReporter::FrameDropReason;
+
+
+constexpr ChromeFrameReporter_FrameDropReason ChromeFrameReporter_FrameDropReason_MIN = ChromeFrameReporter_FrameDropReason::REASON_UNSPECIFIED;
+constexpr ChromeFrameReporter_FrameDropReason ChromeFrameReporter_FrameDropReason_MAX = ChromeFrameReporter_FrameDropReason::REASON_CLIENT_COMPOSITOR;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ChromeFrameReporter_FrameDropReason_Name(::perfetto::protos::pbzero::ChromeFrameReporter_FrameDropReason value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ChromeFrameReporter_FrameDropReason::REASON_UNSPECIFIED:
+    return "REASON_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::ChromeFrameReporter_FrameDropReason::REASON_DISPLAY_COMPOSITOR:
+    return "REASON_DISPLAY_COMPOSITOR";
+
+  case ::perfetto::protos::pbzero::ChromeFrameReporter_FrameDropReason::REASON_MAIN_THREAD:
+    return "REASON_MAIN_THREAD";
+
+  case ::perfetto::protos::pbzero::ChromeFrameReporter_FrameDropReason::REASON_CLIENT_COMPOSITOR:
+    return "REASON_CLIENT_COMPOSITOR";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_ChromeFrameReporter {
+enum ScrollState : int32_t {
+  SCROLL_NONE = 0,
+  SCROLL_MAIN_THREAD = 1,
+  SCROLL_COMPOSITOR_THREAD = 2,
+  SCROLL_RASTER = 3,
+  SCROLL_UNKNOWN = 4,
+};
+} // namespace perfetto_pbzero_enum_ChromeFrameReporter
+using ChromeFrameReporter_ScrollState = perfetto_pbzero_enum_ChromeFrameReporter::ScrollState;
+
+
+constexpr ChromeFrameReporter_ScrollState ChromeFrameReporter_ScrollState_MIN = ChromeFrameReporter_ScrollState::SCROLL_NONE;
+constexpr ChromeFrameReporter_ScrollState ChromeFrameReporter_ScrollState_MAX = ChromeFrameReporter_ScrollState::SCROLL_UNKNOWN;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ChromeFrameReporter_ScrollState_Name(::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState::SCROLL_NONE:
+    return "SCROLL_NONE";
+
+  case ::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState::SCROLL_MAIN_THREAD:
+    return "SCROLL_MAIN_THREAD";
+
+  case ::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState::SCROLL_COMPOSITOR_THREAD:
+    return "SCROLL_COMPOSITOR_THREAD";
+
+  case ::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState::SCROLL_RASTER:
+    return "SCROLL_RASTER";
+
+  case ::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState::SCROLL_UNKNOWN:
+    return "SCROLL_UNKNOWN";
   }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_ChromeFrameReporter {
+enum FrameType : int32_t {
+  FORKED = 0,
+  BACKFILL = 1,
 };
+} // namespace perfetto_pbzero_enum_ChromeFrameReporter
+using ChromeFrameReporter_FrameType = perfetto_pbzero_enum_ChromeFrameReporter::FrameType;
+
+
+constexpr ChromeFrameReporter_FrameType ChromeFrameReporter_FrameType_MIN = ChromeFrameReporter_FrameType::FORKED;
+constexpr ChromeFrameReporter_FrameType ChromeFrameReporter_FrameType_MAX = ChromeFrameReporter_FrameType::BACKFILL;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ChromeFrameReporter_FrameType_Name(::perfetto::protos::pbzero::ChromeFrameReporter_FrameType value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ChromeFrameReporter_FrameType::FORKED:
+    return "FORKED";
+
+  case ::perfetto::protos::pbzero::ChromeFrameReporter_FrameType::BACKFILL:
+    return "BACKFILL";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
-class SysStats_CpuTimes_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class ChromeFrameReporter_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/18> {
  public:
-  SysStats_CpuTimes_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SysStats_CpuTimes_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SysStats_CpuTimes_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_cpu_id() const { return at<1>().valid(); }
-  uint32_t cpu_id() const { return at<1>().as_uint32(); }
-  bool has_user_ns() const { return at<2>().valid(); }
-  uint64_t user_ns() const { return at<2>().as_uint64(); }
-  bool has_user_ice_ns() const { return at<3>().valid(); }
-  uint64_t user_ice_ns() const { return at<3>().as_uint64(); }
-  bool has_system_mode_ns() const { return at<4>().valid(); }
-  uint64_t system_mode_ns() const { return at<4>().as_uint64(); }
-  bool has_idle_ns() const { return at<5>().valid(); }
-  uint64_t idle_ns() const { return at<5>().as_uint64(); }
-  bool has_io_wait_ns() const { return at<6>().valid(); }
-  uint64_t io_wait_ns() const { return at<6>().as_uint64(); }
-  bool has_irq_ns() const { return at<7>().valid(); }
-  uint64_t irq_ns() const { return at<7>().as_uint64(); }
-  bool has_softirq_ns() const { return at<8>().valid(); }
-  uint64_t softirq_ns() const { return at<8>().as_uint64(); }
+  ChromeFrameReporter_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeFrameReporter_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeFrameReporter_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_state() const { return at<1>().valid(); }
+  int32_t state() const { return at<1>().as_int32(); }
+  bool has_reason() const { return at<2>().valid(); }
+  int32_t reason() const { return at<2>().as_int32(); }
+  bool has_frame_source() const { return at<3>().valid(); }
+  uint64_t frame_source() const { return at<3>().as_uint64(); }
+  bool has_frame_sequence() const { return at<4>().valid(); }
+  uint64_t frame_sequence() const { return at<4>().as_uint64(); }
+  bool has_affects_smoothness() const { return at<5>().valid(); }
+  bool affects_smoothness() const { return at<5>().as_bool(); }
+  bool has_scroll_state() const { return at<6>().valid(); }
+  int32_t scroll_state() const { return at<6>().as_int32(); }
+  bool has_has_main_animation() const { return at<7>().valid(); }
+  bool has_main_animation() const { return at<7>().as_bool(); }
+  bool has_has_compositor_animation() const { return at<8>().valid(); }
+  bool has_compositor_animation() const { return at<8>().as_bool(); }
+  bool has_has_smooth_input_main() const { return at<9>().valid(); }
+  bool has_smooth_input_main() const { return at<9>().as_bool(); }
+  bool has_has_missing_content() const { return at<10>().valid(); }
+  bool has_missing_content() const { return at<10>().as_bool(); }
+  bool has_layer_tree_host_id() const { return at<11>().valid(); }
+  uint64_t layer_tree_host_id() const { return at<11>().as_uint64(); }
+  bool has_has_high_latency() const { return at<12>().valid(); }
+  bool has_high_latency() const { return at<12>().as_bool(); }
+  bool has_frame_type() const { return at<13>().valid(); }
+  int32_t frame_type() const { return at<13>().as_int32(); }
+  bool has_high_latency_contribution_stage() const { return at<14>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> high_latency_contribution_stage() const { return GetRepeated<::protozero::ConstChars>(14); }
+  bool has_checkerboarded_needs_raster() const { return at<15>().valid(); }
+  bool checkerboarded_needs_raster() const { return at<15>().as_bool(); }
+  bool has_checkerboarded_needs_record() const { return at<16>().valid(); }
+  bool checkerboarded_needs_record() const { return at<16>().as_bool(); }
+  bool has_surface_frame_trace_id() const { return at<17>().valid(); }
+  int64_t surface_frame_trace_id() const { return at<17>().as_int64(); }
+  bool has_display_trace_id() const { return at<18>().valid(); }
+  int64_t display_trace_id() const { return at<18>().as_int64(); }
 };
 
-class SysStats_CpuTimes : public ::protozero::Message {
+class ChromeFrameReporter : public ::protozero::Message {
  public:
-  using Decoder = SysStats_CpuTimes_Decoder;
+  using Decoder = ChromeFrameReporter_Decoder;
   enum : int32_t {
-    kCpuIdFieldNumber = 1,
-    kUserNsFieldNumber = 2,
-    kUserIceNsFieldNumber = 3,
-    kSystemModeNsFieldNumber = 4,
-    kIdleNsFieldNumber = 5,
-    kIoWaitNsFieldNumber = 6,
-    kIrqNsFieldNumber = 7,
-    kSoftirqNsFieldNumber = 8,
+    kStateFieldNumber = 1,
+    kReasonFieldNumber = 2,
+    kFrameSourceFieldNumber = 3,
+    kFrameSequenceFieldNumber = 4,
+    kAffectsSmoothnessFieldNumber = 5,
+    kScrollStateFieldNumber = 6,
+    kHasMainAnimationFieldNumber = 7,
+    kHasCompositorAnimationFieldNumber = 8,
+    kHasSmoothInputMainFieldNumber = 9,
+    kHasMissingContentFieldNumber = 10,
+    kLayerTreeHostIdFieldNumber = 11,
+    kHasHighLatencyFieldNumber = 12,
+    kFrameTypeFieldNumber = 13,
+    kHighLatencyContributionStageFieldNumber = 14,
+    kCheckerboardedNeedsRasterFieldNumber = 15,
+    kCheckerboardedNeedsRecordFieldNumber = 16,
+    kSurfaceFrameTraceIdFieldNumber = 17,
+    kDisplayTraceIdFieldNumber = 18,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SysStats.CpuTimes"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeFrameReporter"; }
 
 
-  using FieldMetadata_CpuId =
+  using State = ::perfetto::protos::pbzero::ChromeFrameReporter_State;
+  static inline const char* State_Name(State value) {
+    return ::perfetto::protos::pbzero::ChromeFrameReporter_State_Name(value);
+  }
+
+  using FrameDropReason = ::perfetto::protos::pbzero::ChromeFrameReporter_FrameDropReason;
+  static inline const char* FrameDropReason_Name(FrameDropReason value) {
+    return ::perfetto::protos::pbzero::ChromeFrameReporter_FrameDropReason_Name(value);
+  }
+
+  using ScrollState = ::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState;
+  static inline const char* ScrollState_Name(ScrollState value) {
+    return ::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState_Name(value);
+  }
+
+  using FrameType = ::perfetto::protos::pbzero::ChromeFrameReporter_FrameType;
+  static inline const char* FrameType_Name(FrameType value) {
+    return ::perfetto::protos::pbzero::ChromeFrameReporter_FrameType_Name(value);
+  }
+  static inline const State STATE_NO_UPDATE_DESIRED = State::STATE_NO_UPDATE_DESIRED;
+  static inline const State STATE_PRESENTED_ALL = State::STATE_PRESENTED_ALL;
+  static inline const State STATE_PRESENTED_PARTIAL = State::STATE_PRESENTED_PARTIAL;
+  static inline const State STATE_DROPPED = State::STATE_DROPPED;
+  static inline const FrameDropReason REASON_UNSPECIFIED = FrameDropReason::REASON_UNSPECIFIED;
+  static inline const FrameDropReason REASON_DISPLAY_COMPOSITOR = FrameDropReason::REASON_DISPLAY_COMPOSITOR;
+  static inline const FrameDropReason REASON_MAIN_THREAD = FrameDropReason::REASON_MAIN_THREAD;
+  static inline const FrameDropReason REASON_CLIENT_COMPOSITOR = FrameDropReason::REASON_CLIENT_COMPOSITOR;
+  static inline const ScrollState SCROLL_NONE = ScrollState::SCROLL_NONE;
+  static inline const ScrollState SCROLL_MAIN_THREAD = ScrollState::SCROLL_MAIN_THREAD;
+  static inline const ScrollState SCROLL_COMPOSITOR_THREAD = ScrollState::SCROLL_COMPOSITOR_THREAD;
+  static inline const ScrollState SCROLL_RASTER = ScrollState::SCROLL_RASTER;
+  static inline const ScrollState SCROLL_UNKNOWN = ScrollState::SCROLL_UNKNOWN;
+  static inline const FrameType FORKED = FrameType::FORKED;
+  static inline const FrameType BACKFILL = FrameType::BACKFILL;
+
+  using FieldMetadata_State =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      SysStats_CpuTimes>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ChromeFrameReporter_State,
+      ChromeFrameReporter>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpuId kCpuId() { return {}; }
-  void set_cpu_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_CpuId::kFieldId;
+  static constexpr FieldMetadata_State kState{};
+  void set_state(ChromeFrameReporter_State value) {
+    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_UserNs =
+  using FieldMetadata_Reason =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SysStats_CpuTimes>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ChromeFrameReporter_FrameDropReason,
+      ChromeFrameReporter>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UserNs kUserNs() { return {}; }
-  void set_user_ns(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_UserNs::kFieldId;
+  static constexpr FieldMetadata_Reason kReason{};
+  void set_reason(ChromeFrameReporter_FrameDropReason value) {
+    static constexpr uint32_t field_id = FieldMetadata_Reason::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_UserIceNs =
+  using FieldMetadata_FrameSource =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      SysStats_CpuTimes>;
+      ChromeFrameReporter>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UserIceNs kUserIceNs() { return {}; }
-  void set_user_ice_ns(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_UserIceNs::kFieldId;
+  static constexpr FieldMetadata_FrameSource kFrameSource{};
+  void set_frame_source(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FrameSource::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -156925,24 +177084,17 @@ class SysStats_CpuTimes : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SystemModeNs =
+  using FieldMetadata_FrameSequence =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      SysStats_CpuTimes>;
+      ChromeFrameReporter>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SystemModeNs kSystemModeNs() { return {}; }
-  void set_system_mode_ns(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SystemModeNs::kFieldId;
+  static constexpr FieldMetadata_FrameSequence kFrameSequence{};
+  void set_frame_sequence(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FrameSequence::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -156950,391 +177102,261 @@ class SysStats_CpuTimes : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IdleNs =
+  using FieldMetadata_AffectsSmoothness =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SysStats_CpuTimes>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeFrameReporter>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IdleNs kIdleNs() { return {}; }
-  void set_idle_ns(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IdleNs::kFieldId;
+  static constexpr FieldMetadata_AffectsSmoothness kAffectsSmoothness{};
+  void set_affects_smoothness(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_AffectsSmoothness::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IoWaitNs =
+  using FieldMetadata_ScrollState =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SysStats_CpuTimes>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ChromeFrameReporter_ScrollState,
+      ChromeFrameReporter>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IoWaitNs kIoWaitNs() { return {}; }
-  void set_io_wait_ns(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IoWaitNs::kFieldId;
+  static constexpr FieldMetadata_ScrollState kScrollState{};
+  void set_scroll_state(ChromeFrameReporter_ScrollState value) {
+    static constexpr uint32_t field_id = FieldMetadata_ScrollState::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IrqNs =
+  using FieldMetadata_HasMainAnimation =
     ::protozero::proto_utils::FieldMetadata<
       7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SysStats_CpuTimes>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeFrameReporter>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IrqNs kIrqNs() { return {}; }
-  void set_irq_ns(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IrqNs::kFieldId;
+  static constexpr FieldMetadata_HasMainAnimation kHasMainAnimation{};
+  void set_has_main_animation(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_HasMainAnimation::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SoftirqNs =
+  using FieldMetadata_HasCompositorAnimation =
     ::protozero::proto_utils::FieldMetadata<
       8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SysStats_CpuTimes>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeFrameReporter>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SoftirqNs kSoftirqNs() { return {}; }
-  void set_softirq_ns(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SoftirqNs::kFieldId;
+  static constexpr FieldMetadata_HasCompositorAnimation kHasCompositorAnimation{};
+  void set_has_compositor_animation(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_HasCompositorAnimation::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
-};
-
-class SysStats_VmstatValue_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  SysStats_VmstatValue_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SysStats_VmstatValue_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SysStats_VmstatValue_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_key() const { return at<1>().valid(); }
-  int32_t key() const { return at<1>().as_int32(); }
-  bool has_value() const { return at<2>().valid(); }
-  uint64_t value() const { return at<2>().as_uint64(); }
-};
 
-class SysStats_VmstatValue : public ::protozero::Message {
- public:
-  using Decoder = SysStats_VmstatValue_Decoder;
-  enum : int32_t {
-    kKeyFieldNumber = 1,
-    kValueFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.SysStats.VmstatValue"; }
+  using FieldMetadata_HasSmoothInputMain =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeFrameReporter>;
 
+  static constexpr FieldMetadata_HasSmoothInputMain kHasSmoothInputMain{};
+  void set_has_smooth_input_main(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_HasSmoothInputMain::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Key =
+  using FieldMetadata_HasMissingContent =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::VmstatCounters,
-      SysStats_VmstatValue>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeFrameReporter>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Key kKey() { return {}; }
-  void set_key(::perfetto::protos::pbzero::VmstatCounters value) {
-    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+  static constexpr FieldMetadata_HasMissingContent kHasMissingContent{};
+  void set_has_missing_content(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_HasMissingContent::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Value =
+  using FieldMetadata_LayerTreeHostId =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      SysStats_VmstatValue>;
+      ChromeFrameReporter>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+  static constexpr FieldMetadata_LayerTreeHostId kLayerTreeHostId{};
+  void set_layer_tree_host_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LayerTreeHostId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-};
-
-class SysStats_MeminfoValue_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  SysStats_MeminfoValue_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SysStats_MeminfoValue_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SysStats_MeminfoValue_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_key() const { return at<1>().valid(); }
-  int32_t key() const { return at<1>().as_int32(); }
-  bool has_value() const { return at<2>().valid(); }
-  uint64_t value() const { return at<2>().as_uint64(); }
-};
 
-class SysStats_MeminfoValue : public ::protozero::Message {
- public:
-  using Decoder = SysStats_MeminfoValue_Decoder;
-  enum : int32_t {
-    kKeyFieldNumber = 1,
-    kValueFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.SysStats.MeminfoValue"; }
-
-
-  using FieldMetadata_Key =
+  using FieldMetadata_HasHighLatency =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      12,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::MeminfoCounters,
-      SysStats_MeminfoValue>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeFrameReporter>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Key kKey() { return {}; }
-  void set_key(::perfetto::protos::pbzero::MeminfoCounters value) {
-    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+  static constexpr FieldMetadata_HasHighLatency kHasHighLatency{};
+  void set_has_high_latency(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_HasHighLatency::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Value =
+  using FieldMetadata_FrameType =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      13,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      SysStats_MeminfoValue>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ChromeFrameReporter_FrameType,
+      ChromeFrameReporter>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+  static constexpr FieldMetadata_FrameType kFrameType{};
+  void set_frame_type(ChromeFrameReporter_FrameType value) {
+    static constexpr uint32_t field_id = FieldMetadata_FrameType::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/system_info/cpu_info.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
-
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_SYSTEM_INFO_CPU_INFO_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_SYSTEM_INFO_CPU_INFO_PROTO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-
-namespace perfetto {
-namespace protos {
-namespace pbzero {
-
-class CpuInfo_Cpu;
 
-class CpuInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  CpuInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit CpuInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit CpuInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_cpus() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> cpus() const { return GetRepeated<::protozero::ConstBytes>(1); }
-};
-
-class CpuInfo : public ::protozero::Message {
- public:
-  using Decoder = CpuInfo_Decoder;
-  enum : int32_t {
-    kCpusFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.CpuInfo"; }
-
-  using Cpu = ::perfetto::protos::pbzero::CpuInfo_Cpu;
-
-  using FieldMetadata_Cpus =
+  using FieldMetadata_HighLatencyContributionStage =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      14,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      CpuInfo_Cpu,
-      CpuInfo>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeFrameReporter>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cpus kCpus() { return {}; }
-  template <typename T = CpuInfo_Cpu> T* add_cpus() {
-    return BeginNestedMessage<T>(1);
+  static constexpr FieldMetadata_HighLatencyContributionStage kHighLatencyContributionStage{};
+  void add_high_latency_contribution_stage(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_HighLatencyContributionStage::kFieldId, data, size);
+  }
+  void add_high_latency_contribution_stage(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_HighLatencyContributionStage::kFieldId, chars.data, chars.size);
+  }
+  void add_high_latency_contribution_stage(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_HighLatencyContributionStage::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
   }
 
-};
+  using FieldMetadata_CheckerboardedNeedsRaster =
+    ::protozero::proto_utils::FieldMetadata<
+      15,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeFrameReporter>;
 
-class CpuInfo_Cpu_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  CpuInfo_Cpu_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit CpuInfo_Cpu_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit CpuInfo_Cpu_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_processor() const { return at<1>().valid(); }
-  ::protozero::ConstChars processor() const { return at<1>().as_string(); }
-  bool has_frequencies() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<uint32_t> frequencies() const { return GetRepeated<uint32_t>(2); }
-};
+  static constexpr FieldMetadata_CheckerboardedNeedsRaster kCheckerboardedNeedsRaster{};
+  void set_checkerboarded_needs_raster(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_CheckerboardedNeedsRaster::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-class CpuInfo_Cpu : public ::protozero::Message {
- public:
-  using Decoder = CpuInfo_Cpu_Decoder;
-  enum : int32_t {
-    kProcessorFieldNumber = 1,
-    kFrequenciesFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.CpuInfo.Cpu"; }
+  using FieldMetadata_CheckerboardedNeedsRecord =
+    ::protozero::proto_utils::FieldMetadata<
+      16,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeFrameReporter>;
 
+  static constexpr FieldMetadata_CheckerboardedNeedsRecord kCheckerboardedNeedsRecord{};
+  void set_checkerboarded_needs_record(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_CheckerboardedNeedsRecord::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-  using FieldMetadata_Processor =
+  using FieldMetadata_SurfaceFrameTraceId =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      17,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      CpuInfo_Cpu>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ChromeFrameReporter>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Processor kProcessor() { return {}; }
-  void set_processor(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Processor::kFieldId, data, size);
-  }
-  void set_processor(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Processor::kFieldId, chars.data, chars.size);
-  }
-  void set_processor(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Processor::kFieldId;
+  static constexpr FieldMetadata_SurfaceFrameTraceId kSurfaceFrameTraceId{};
+  void set_surface_frame_trace_id(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SurfaceFrameTraceId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Frequencies =
+  using FieldMetadata_DisplayTraceId =
     ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      CpuInfo_Cpu>;
+      18,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ChromeFrameReporter>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Frequencies kFrequencies() { return {}; }
-  void add_frequencies(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Frequencies::kFieldId;
+  static constexpr FieldMetadata_DisplayTraceId kDisplayTraceId{};
+  void set_display_trace_id(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DisplayTraceId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 };
@@ -157343,11 +177365,11 @@ class CpuInfo_Cpu : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/translation/translation_table.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_histogram_sample.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRANSLATION_TRANSLATION_TABLE_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRANSLATION_TRANSLATION_TABLE_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_HISTOGRAM_SAMPLE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_HISTOGRAM_SAMPLE_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -157358,359 +177380,173 @@ class CpuInfo_Cpu : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-class ChromeHistorgramTranslationTable;
-class ChromeHistorgramTranslationTable_HashToNameEntry;
-class ChromePerformanceMarkTranslationTable;
-class ChromePerformanceMarkTranslationTable_MarkHashToNameEntry;
-class ChromePerformanceMarkTranslationTable_SiteHashToNameEntry;
-class ChromeUserEventTranslationTable;
-class ChromeUserEventTranslationTable_ActionHashToNameEntry;
-class SliceNameTranslationTable;
-class SliceNameTranslationTable_RawToDeobfuscatedNameEntry;
-
-class SliceNameTranslationTable_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  SliceNameTranslationTable_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SliceNameTranslationTable_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SliceNameTranslationTable_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_raw_to_deobfuscated_name() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> raw_to_deobfuscated_name() const { return GetRepeated<::protozero::ConstBytes>(1); }
-};
-
-class SliceNameTranslationTable : public ::protozero::Message {
- public:
-  using Decoder = SliceNameTranslationTable_Decoder;
-  enum : int32_t {
-    kRawToDeobfuscatedNameFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.SliceNameTranslationTable"; }
-
-  using RawToDeobfuscatedNameEntry = ::perfetto::protos::pbzero::SliceNameTranslationTable_RawToDeobfuscatedNameEntry;
-
-  using FieldMetadata_RawToDeobfuscatedName =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      SliceNameTranslationTable_RawToDeobfuscatedNameEntry,
-      SliceNameTranslationTable>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RawToDeobfuscatedName kRawToDeobfuscatedName() { return {}; }
-  template <typename T = SliceNameTranslationTable_RawToDeobfuscatedNameEntry> T* add_raw_to_deobfuscated_name() {
-    return BeginNestedMessage<T>(1);
-  }
-
-};
-
-class SliceNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class ChromeHistogramSample_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  SliceNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit SliceNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit SliceNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_key() const { return at<1>().valid(); }
-  ::protozero::ConstChars key() const { return at<1>().as_string(); }
-  bool has_value() const { return at<2>().valid(); }
-  ::protozero::ConstChars value() const { return at<2>().as_string(); }
+  ChromeHistogramSample_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeHistogramSample_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeHistogramSample_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name_hash() const { return at<1>().valid(); }
+  uint64_t name_hash() const { return at<1>().as_uint64(); }
+  bool has_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars name() const { return at<2>().as_string(); }
+  bool has_sample() const { return at<3>().valid(); }
+  int64_t sample() const { return at<3>().as_int64(); }
+  bool has_name_iid() const { return at<4>().valid(); }
+  uint64_t name_iid() const { return at<4>().as_uint64(); }
 };
 
-class SliceNameTranslationTable_RawToDeobfuscatedNameEntry : public ::protozero::Message {
+class ChromeHistogramSample : public ::protozero::Message {
  public:
-  using Decoder = SliceNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder;
+  using Decoder = ChromeHistogramSample_Decoder;
   enum : int32_t {
-    kKeyFieldNumber = 1,
-    kValueFieldNumber = 2,
+    kNameHashFieldNumber = 1,
+    kNameFieldNumber = 2,
+    kSampleFieldNumber = 3,
+    kNameIidFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.SliceNameTranslationTable.RawToDeobfuscatedNameEntry"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeHistogramSample"; }
 
 
-  using FieldMetadata_Key =
+  using FieldMetadata_NameHash =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      SliceNameTranslationTable_RawToDeobfuscatedNameEntry>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ChromeHistogramSample>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Key kKey() { return {}; }
-  void set_key(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Key::kFieldId, data, size);
-  }
-  void set_key(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Key::kFieldId, chars.data, chars.size);
-  }
-  void set_key(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+  static constexpr FieldMetadata_NameHash kNameHash{};
+  void set_name_hash(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NameHash::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Value =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      SliceNameTranslationTable_RawToDeobfuscatedNameEntry>;
+      ChromeHistogramSample>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
-  void set_value(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
   }
-  void set_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
-};
-
-class ChromePerformanceMarkTranslationTable_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  ChromePerformanceMarkTranslationTable_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromePerformanceMarkTranslationTable_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromePerformanceMarkTranslationTable_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_site_hash_to_name() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> site_hash_to_name() const { return GetRepeated<::protozero::ConstBytes>(1); }
-  bool has_mark_hash_to_name() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> mark_hash_to_name() const { return GetRepeated<::protozero::ConstBytes>(2); }
-};
-
-class ChromePerformanceMarkTranslationTable : public ::protozero::Message {
- public:
-  using Decoder = ChromePerformanceMarkTranslationTable_Decoder;
-  enum : int32_t {
-    kSiteHashToNameFieldNumber = 1,
-    kMarkHashToNameFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromePerformanceMarkTranslationTable"; }
-
-  using SiteHashToNameEntry = ::perfetto::protos::pbzero::ChromePerformanceMarkTranslationTable_SiteHashToNameEntry;
-  using MarkHashToNameEntry = ::perfetto::protos::pbzero::ChromePerformanceMarkTranslationTable_MarkHashToNameEntry;
-
-  using FieldMetadata_SiteHashToName =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromePerformanceMarkTranslationTable_SiteHashToNameEntry,
-      ChromePerformanceMarkTranslationTable>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SiteHashToName kSiteHashToName() { return {}; }
-  template <typename T = ChromePerformanceMarkTranslationTable_SiteHashToNameEntry> T* add_site_hash_to_name() {
-    return BeginNestedMessage<T>(1);
-  }
-
-
-  using FieldMetadata_MarkHashToName =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromePerformanceMarkTranslationTable_MarkHashToNameEntry,
-      ChromePerformanceMarkTranslationTable>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MarkHashToName kMarkHashToName() { return {}; }
-  template <typename T = ChromePerformanceMarkTranslationTable_MarkHashToNameEntry> T* add_mark_hash_to_name() {
-    return BeginNestedMessage<T>(2);
-  }
-
-};
-
-class ChromePerformanceMarkTranslationTable_MarkHashToNameEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  ChromePerformanceMarkTranslationTable_MarkHashToNameEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromePerformanceMarkTranslationTable_MarkHashToNameEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromePerformanceMarkTranslationTable_MarkHashToNameEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_key() const { return at<1>().valid(); }
-  uint32_t key() const { return at<1>().as_uint32(); }
-  bool has_value() const { return at<2>().valid(); }
-  ::protozero::ConstChars value() const { return at<2>().as_string(); }
-};
-
-class ChromePerformanceMarkTranslationTable_MarkHashToNameEntry : public ::protozero::Message {
- public:
-  using Decoder = ChromePerformanceMarkTranslationTable_MarkHashToNameEntry_Decoder;
-  enum : int32_t {
-    kKeyFieldNumber = 1,
-    kValueFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromePerformanceMarkTranslationTable.MarkHashToNameEntry"; }
-
 
-  using FieldMetadata_Key =
+  using FieldMetadata_Sample =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      ChromePerformanceMarkTranslationTable_MarkHashToNameEntry>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ChromeHistogramSample>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Key kKey() { return {}; }
-  void set_key(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+  static constexpr FieldMetadata_Sample kSample{};
+  void set_sample(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Sample::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Value =
+  using FieldMetadata_NameIid =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromePerformanceMarkTranslationTable_MarkHashToNameEntry>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ChromeHistogramSample>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
-  }
-  void set_value(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
-  }
-  void set_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+  static constexpr FieldMetadata_NameIid kNameIid{};
+  void set_name_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NameIid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
 
-class ChromePerformanceMarkTranslationTable_SiteHashToNameEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class HistogramName_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  ChromePerformanceMarkTranslationTable_SiteHashToNameEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromePerformanceMarkTranslationTable_SiteHashToNameEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromePerformanceMarkTranslationTable_SiteHashToNameEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_key() const { return at<1>().valid(); }
-  uint32_t key() const { return at<1>().as_uint32(); }
-  bool has_value() const { return at<2>().valid(); }
-  ::protozero::ConstChars value() const { return at<2>().as_string(); }
+  HistogramName_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit HistogramName_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit HistogramName_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_iid() const { return at<1>().valid(); }
+  uint64_t iid() const { return at<1>().as_uint64(); }
+  bool has_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars name() const { return at<2>().as_string(); }
 };
 
-class ChromePerformanceMarkTranslationTable_SiteHashToNameEntry : public ::protozero::Message {
+class HistogramName : public ::protozero::Message {
  public:
-  using Decoder = ChromePerformanceMarkTranslationTable_SiteHashToNameEntry_Decoder;
+  using Decoder = HistogramName_Decoder;
   enum : int32_t {
-    kKeyFieldNumber = 1,
-    kValueFieldNumber = 2,
+    kIidFieldNumber = 1,
+    kNameFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromePerformanceMarkTranslationTable.SiteHashToNameEntry"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.HistogramName"; }
 
 
-  using FieldMetadata_Key =
+  using FieldMetadata_Iid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      ChromePerformanceMarkTranslationTable_SiteHashToNameEntry>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      HistogramName>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Key kKey() { return {}; }
-  void set_key(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+  static constexpr FieldMetadata_Iid kIid{};
+  void set_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Value =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      ChromePerformanceMarkTranslationTable_SiteHashToNameEntry>;
+      HistogramName>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
-  void set_value(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
   }
-  void set_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -157719,117 +177555,65 @@ class ChromePerformanceMarkTranslationTable_SiteHashToNameEntry : public ::proto
   }
 };
 
-class ChromeUserEventTranslationTable_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  ChromeUserEventTranslationTable_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeUserEventTranslationTable_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeUserEventTranslationTable_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_action_hash_to_name() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> action_hash_to_name() const { return GetRepeated<::protozero::ConstBytes>(1); }
-};
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_keyed_service.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-class ChromeUserEventTranslationTable : public ::protozero::Message {
- public:
-  using Decoder = ChromeUserEventTranslationTable_Decoder;
-  enum : int32_t {
-    kActionHashToNameFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeUserEventTranslationTable"; }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_KEYED_SERVICE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_KEYED_SERVICE_PROTO_H_
 
-  using ActionHashToNameEntry = ::perfetto::protos::pbzero::ChromeUserEventTranslationTable_ActionHashToNameEntry;
+#include <stddef.h>
+#include <stdint.h>
 
-  using FieldMetadata_ActionHashToName =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeUserEventTranslationTable_ActionHashToNameEntry,
-      ChromeUserEventTranslationTable>;
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ActionHashToName kActionHashToName() { return {}; }
-  template <typename T = ChromeUserEventTranslationTable_ActionHashToNameEntry> T* add_action_hash_to_name() {
-    return BeginNestedMessage<T>(1);
-  }
 
-};
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-class ChromeUserEventTranslationTable_ActionHashToNameEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class ChromeKeyedService_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  ChromeUserEventTranslationTable_ActionHashToNameEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeUserEventTranslationTable_ActionHashToNameEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeUserEventTranslationTable_ActionHashToNameEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_key() const { return at<1>().valid(); }
-  uint64_t key() const { return at<1>().as_uint64(); }
-  bool has_value() const { return at<2>().valid(); }
-  ::protozero::ConstChars value() const { return at<2>().as_string(); }
+  ChromeKeyedService_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeKeyedService_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeKeyedService_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
 };
 
-class ChromeUserEventTranslationTable_ActionHashToNameEntry : public ::protozero::Message {
+class ChromeKeyedService : public ::protozero::Message {
  public:
-  using Decoder = ChromeUserEventTranslationTable_ActionHashToNameEntry_Decoder;
+  using Decoder = ChromeKeyedService_Decoder;
   enum : int32_t {
-    kKeyFieldNumber = 1,
-    kValueFieldNumber = 2,
+    kNameFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeUserEventTranslationTable.ActionHashToNameEntry"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeKeyedService"; }
 
 
-  using FieldMetadata_Key =
+  using FieldMetadata_Name =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ChromeUserEventTranslationTable_ActionHashToNameEntry>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Key kKey() { return {}; }
-  void set_key(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_Value =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      ChromeUserEventTranslationTable_ActionHashToNameEntry>;
+      ChromeKeyedService>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
   }
-  void set_value(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
   }
-  void set_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -157838,511 +177622,404 @@ class ChromeUserEventTranslationTable_ActionHashToNameEntry : public ::protozero
   }
 };
 
-class ChromeHistorgramTranslationTable_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  ChromeHistorgramTranslationTable_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeHistorgramTranslationTable_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeHistorgramTranslationTable_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_hash_to_name() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> hash_to_name() const { return GetRepeated<::protozero::ConstBytes>(1); }
-};
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_latency_info.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-class ChromeHistorgramTranslationTable : public ::protozero::Message {
- public:
-  using Decoder = ChromeHistorgramTranslationTable_Decoder;
-  enum : int32_t {
-    kHashToNameFieldNumber = 1,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeHistorgramTranslationTable"; }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LATENCY_INFO_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LATENCY_INFO_PROTO_H_
 
-  using HashToNameEntry = ::perfetto::protos::pbzero::ChromeHistorgramTranslationTable_HashToNameEntry;
+#include <stddef.h>
+#include <stdint.h>
 
-  using FieldMetadata_HashToName =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeHistorgramTranslationTable_HashToNameEntry,
-      ChromeHistorgramTranslationTable>;
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HashToName kHashToName() { return {}; }
-  template <typename T = ChromeHistorgramTranslationTable_HashToNameEntry> T* add_hash_to_name() {
-    return BeginNestedMessage<T>(1);
-  }
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class ChromeLatencyInfo_ComponentInfo;
+namespace perfetto_pbzero_enum_ChromeLatencyInfo {
+enum InputType : int32_t;
+}  // namespace perfetto_pbzero_enum_ChromeLatencyInfo
+using ChromeLatencyInfo_InputType = perfetto_pbzero_enum_ChromeLatencyInfo::InputType;
+namespace perfetto_pbzero_enum_ChromeLatencyInfo {
+enum LatencyComponentType : int32_t;
+}  // namespace perfetto_pbzero_enum_ChromeLatencyInfo
+using ChromeLatencyInfo_LatencyComponentType = perfetto_pbzero_enum_ChromeLatencyInfo::LatencyComponentType;
+namespace perfetto_pbzero_enum_ChromeLatencyInfo {
+enum Step : int32_t;
+}  // namespace perfetto_pbzero_enum_ChromeLatencyInfo
+using ChromeLatencyInfo_Step = perfetto_pbzero_enum_ChromeLatencyInfo::Step;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-};
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-class ChromeHistorgramTranslationTable_HashToNameEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  ChromeHistorgramTranslationTable_HashToNameEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ChromeHistorgramTranslationTable_HashToNameEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ChromeHistorgramTranslationTable_HashToNameEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_key() const { return at<1>().valid(); }
-  uint64_t key() const { return at<1>().as_uint64(); }
-  bool has_value() const { return at<2>().valid(); }
-  ::protozero::ConstChars value() const { return at<2>().as_string(); }
+namespace perfetto_pbzero_enum_ChromeLatencyInfo {
+enum Step : int32_t {
+  STEP_UNSPECIFIED = 0,
+  STEP_SEND_INPUT_EVENT_UI = 3,
+  STEP_HANDLE_INPUT_EVENT_IMPL = 5,
+  STEP_DID_HANDLE_INPUT_AND_OVERSCROLL = 8,
+  STEP_HANDLE_INPUT_EVENT_MAIN = 4,
+  STEP_MAIN_THREAD_SCROLL_UPDATE = 2,
+  STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT = 1,
+  STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL = 9,
+  STEP_HANDLED_INPUT_EVENT_IMPL = 10,
+  STEP_SWAP_BUFFERS = 6,
+  STEP_DRAW_AND_SWAP = 7,
+  STEP_FINISHED_SWAP_BUFFERS = 11,
 };
+} // namespace perfetto_pbzero_enum_ChromeLatencyInfo
+using ChromeLatencyInfo_Step = perfetto_pbzero_enum_ChromeLatencyInfo::Step;
 
-class ChromeHistorgramTranslationTable_HashToNameEntry : public ::protozero::Message {
- public:
-  using Decoder = ChromeHistorgramTranslationTable_HashToNameEntry_Decoder;
-  enum : int32_t {
-    kKeyFieldNumber = 1,
-    kValueFieldNumber = 2,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.ChromeHistorgramTranslationTable.HashToNameEntry"; }
 
+constexpr ChromeLatencyInfo_Step ChromeLatencyInfo_Step_MIN = ChromeLatencyInfo_Step::STEP_UNSPECIFIED;
+constexpr ChromeLatencyInfo_Step ChromeLatencyInfo_Step_MAX = ChromeLatencyInfo_Step::STEP_FINISHED_SWAP_BUFFERS;
 
-  using FieldMetadata_Key =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      ChromeHistorgramTranslationTable_HashToNameEntry>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Key kKey() { return {}; }
-  void set_key(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ChromeLatencyInfo_Step_Name(::perfetto::protos::pbzero::ChromeLatencyInfo_Step value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_UNSPECIFIED:
+    return "STEP_UNSPECIFIED";
 
-  using FieldMetadata_Value =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      ChromeHistorgramTranslationTable_HashToNameEntry>;
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_SEND_INPUT_EVENT_UI:
+    return "STEP_SEND_INPUT_EVENT_UI";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Value kValue() { return {}; }
-  void set_value(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
-  }
-  void set_value(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
-  }
-  void set_value(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-};
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_HANDLE_INPUT_EVENT_IMPL:
+    return "STEP_HANDLE_INPUT_EVENT_IMPL";
 
-class TranslationTable_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TranslationTable_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TranslationTable_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TranslationTable_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_chrome_histogram() const { return at<1>().valid(); }
-  ::protozero::ConstBytes chrome_histogram() const { return at<1>().as_bytes(); }
-  bool has_chrome_user_event() const { return at<2>().valid(); }
-  ::protozero::ConstBytes chrome_user_event() const { return at<2>().as_bytes(); }
-  bool has_chrome_performance_mark() const { return at<3>().valid(); }
-  ::protozero::ConstBytes chrome_performance_mark() const { return at<3>().as_bytes(); }
-  bool has_slice_name() const { return at<4>().valid(); }
-  ::protozero::ConstBytes slice_name() const { return at<4>().as_bytes(); }
-};
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_DID_HANDLE_INPUT_AND_OVERSCROLL:
+    return "STEP_DID_HANDLE_INPUT_AND_OVERSCROLL";
 
-class TranslationTable : public ::protozero::Message {
- public:
-  using Decoder = TranslationTable_Decoder;
-  enum : int32_t {
-    kChromeHistogramFieldNumber = 1,
-    kChromeUserEventFieldNumber = 2,
-    kChromePerformanceMarkFieldNumber = 3,
-    kSliceNameFieldNumber = 4,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TranslationTable"; }
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_HANDLE_INPUT_EVENT_MAIN:
+    return "STEP_HANDLE_INPUT_EVENT_MAIN";
 
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_MAIN_THREAD_SCROLL_UPDATE:
+    return "STEP_MAIN_THREAD_SCROLL_UPDATE";
 
-  using FieldMetadata_ChromeHistogram =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeHistorgramTranslationTable,
-      TranslationTable>;
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT:
+    return "STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeHistogram kChromeHistogram() { return {}; }
-  template <typename T = ChromeHistorgramTranslationTable> T* set_chrome_histogram() {
-    return BeginNestedMessage<T>(1);
-  }
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL:
+    return "STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL";
 
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_HANDLED_INPUT_EVENT_IMPL:
+    return "STEP_HANDLED_INPUT_EVENT_IMPL";
 
-  using FieldMetadata_ChromeUserEvent =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeUserEventTranslationTable,
-      TranslationTable>;
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_SWAP_BUFFERS:
+    return "STEP_SWAP_BUFFERS";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeUserEvent kChromeUserEvent() { return {}; }
-  template <typename T = ChromeUserEventTranslationTable> T* set_chrome_user_event() {
-    return BeginNestedMessage<T>(2);
-  }
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_DRAW_AND_SWAP:
+    return "STEP_DRAW_AND_SWAP";
 
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_FINISHED_SWAP_BUFFERS:
+    return "STEP_FINISHED_SWAP_BUFFERS";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
-  using FieldMetadata_ChromePerformanceMark =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromePerformanceMarkTranslationTable,
-      TranslationTable>;
+namespace perfetto_pbzero_enum_ChromeLatencyInfo {
+enum LatencyComponentType : int32_t {
+  COMPONENT_UNSPECIFIED = 0,
+  COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH = 1,
+  COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL = 2,
+  COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL = 3,
+  COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL = 4,
+  COMPONENT_INPUT_EVENT_LATENCY_UI = 5,
+  COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN = 6,
+  COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN = 7,
+  COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL = 8,
+  COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT = 9,
+  COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH = 10,
+  COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP = 11,
+  COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME = 12,
+  COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER = 13,
+  COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP = 14,
+};
+} // namespace perfetto_pbzero_enum_ChromeLatencyInfo
+using ChromeLatencyInfo_LatencyComponentType = perfetto_pbzero_enum_ChromeLatencyInfo::LatencyComponentType;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromePerformanceMark kChromePerformanceMark() { return {}; }
-  template <typename T = ChromePerformanceMarkTranslationTable> T* set_chrome_performance_mark() {
-    return BeginNestedMessage<T>(3);
-  }
 
+constexpr ChromeLatencyInfo_LatencyComponentType ChromeLatencyInfo_LatencyComponentType_MIN = ChromeLatencyInfo_LatencyComponentType::COMPONENT_UNSPECIFIED;
+constexpr ChromeLatencyInfo_LatencyComponentType ChromeLatencyInfo_LatencyComponentType_MAX = ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP;
 
-  using FieldMetadata_SliceName =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      SliceNameTranslationTable,
-      TranslationTable>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SliceName kSliceName() { return {}; }
-  template <typename T = SliceNameTranslationTable> T* set_slice_name() {
-    return BeginNestedMessage<T>(4);
-  }
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ChromeLatencyInfo_LatencyComponentType_Name(::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_UNSPECIFIED:
+    return "COMPONENT_UNSPECIFIED";
 
-};
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH:
+    return "COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH";
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/trace_packet_defaults.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL:
+    return "COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL";
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACE_PACKET_DEFAULTS_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACE_PACKET_DEFAULTS_PROTO_H_
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL:
+    return "COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL";
 
-#include <stddef.h>
-#include <stdint.h>
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL:
+    return "COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL";
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_UI:
+    return "COMPONENT_INPUT_EVENT_LATENCY_UI";
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN:
+    return "COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN";
 
-class PerfSampleDefaults;
-class TrackEventDefaults;
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN:
+    return "COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN";
 
-class TracePacketDefaults_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/58, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
- public:
-  TracePacketDefaults_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TracePacketDefaults_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TracePacketDefaults_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_timestamp_clock_id() const { return at<58>().valid(); }
-  uint32_t timestamp_clock_id() const { return at<58>().as_uint32(); }
-  bool has_track_event_defaults() const { return at<11>().valid(); }
-  ::protozero::ConstBytes track_event_defaults() const { return at<11>().as_bytes(); }
-  bool has_perf_sample_defaults() const { return at<12>().valid(); }
-  ::protozero::ConstBytes perf_sample_defaults() const { return at<12>().as_bytes(); }
-};
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL:
+    return "COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL";
 
-class TracePacketDefaults : public ::protozero::Message {
- public:
-  using Decoder = TracePacketDefaults_Decoder;
-  enum : int32_t {
-    kTimestampClockIdFieldNumber = 58,
-    kTrackEventDefaultsFieldNumber = 11,
-    kPerfSampleDefaultsFieldNumber = 12,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TracePacketDefaults"; }
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT:
+    return "COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT";
 
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH:
+    return "COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH";
 
-  using FieldMetadata_TimestampClockId =
-    ::protozero::proto_utils::FieldMetadata<
-      58,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TracePacketDefaults>;
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP:
+    return "COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimestampClockId kTimestampClockId() { return {}; }
-  void set_timestamp_clock_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimestampClockId::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
-        ::Append(*this, field_id, value);
-  }
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME:
+    return "COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME";
 
-  using FieldMetadata_TrackEventDefaults =
-    ::protozero::proto_utils::FieldMetadata<
-      11,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TrackEventDefaults,
-      TracePacketDefaults>;
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER:
+    return "COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrackEventDefaults kTrackEventDefaults() { return {}; }
-  template <typename T = TrackEventDefaults> T* set_track_event_defaults() {
-    return BeginNestedMessage<T>(11);
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP:
+    return "COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP";
   }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
+namespace perfetto_pbzero_enum_ChromeLatencyInfo {
+enum InputType : int32_t {
+  UNSPECIFIED_OR_OTHER = 0,
+  TOUCH_MOVED = 1,
+  GESTURE_SCROLL_BEGIN = 2,
+  GESTURE_SCROLL_UPDATE = 3,
+  GESTURE_SCROLL_END = 4,
+  GESTURE_TAP = 5,
+  GESTURE_TAP_CANCEL = 6,
+};
+} // namespace perfetto_pbzero_enum_ChromeLatencyInfo
+using ChromeLatencyInfo_InputType = perfetto_pbzero_enum_ChromeLatencyInfo::InputType;
 
-  using FieldMetadata_PerfSampleDefaults =
-    ::protozero::proto_utils::FieldMetadata<
-      12,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      PerfSampleDefaults,
-      TracePacketDefaults>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PerfSampleDefaults kPerfSampleDefaults() { return {}; }
-  template <typename T = PerfSampleDefaults> T* set_perf_sample_defaults() {
-    return BeginNestedMessage<T>(12);
-  }
+constexpr ChromeLatencyInfo_InputType ChromeLatencyInfo_InputType_MIN = ChromeLatencyInfo_InputType::UNSPECIFIED_OR_OTHER;
+constexpr ChromeLatencyInfo_InputType ChromeLatencyInfo_InputType_MAX = ChromeLatencyInfo_InputType::GESTURE_TAP_CANCEL;
 
-};
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/test_event.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ChromeLatencyInfo_InputType_Name(::perfetto::protos::pbzero::ChromeLatencyInfo_InputType value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_InputType::UNSPECIFIED_OR_OTHER:
+    return "UNSPECIFIED_OR_OTHER";
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TEST_EVENT_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TEST_EVENT_PROTO_H_
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_InputType::TOUCH_MOVED:
+    return "TOUCH_MOVED";
 
-#include <stddef.h>
-#include <stdint.h>
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_InputType::GESTURE_SCROLL_BEGIN:
+    return "GESTURE_SCROLL_BEGIN";
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_InputType::GESTURE_SCROLL_UPDATE:
+    return "GESTURE_SCROLL_UPDATE";
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_InputType::GESTURE_SCROLL_END:
+    return "GESTURE_SCROLL_END";
 
-class DebugAnnotation;
-class TestEvent_TestPayload;
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_InputType::GESTURE_TAP:
+    return "GESTURE_TAP";
+
+  case ::perfetto::protos::pbzero::ChromeLatencyInfo_InputType::GESTURE_TAP_CANCEL:
+    return "GESTURE_TAP_CANCEL";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
-class TestEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class ChromeLatencyInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/8> {
  public:
-  TestEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TestEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TestEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_str() const { return at<1>().valid(); }
-  ::protozero::ConstChars str() const { return at<1>().as_string(); }
-  bool has_seq_value() const { return at<2>().valid(); }
-  uint32_t seq_value() const { return at<2>().as_uint32(); }
-  bool has_counter() const { return at<3>().valid(); }
-  uint64_t counter() const { return at<3>().as_uint64(); }
-  bool has_is_last() const { return at<4>().valid(); }
-  bool is_last() const { return at<4>().as_bool(); }
-  bool has_payload() const { return at<5>().valid(); }
-  ::protozero::ConstBytes payload() const { return at<5>().as_bytes(); }
+  ChromeLatencyInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeLatencyInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeLatencyInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_trace_id() const { return at<1>().valid(); }
+  int64_t trace_id() const { return at<1>().as_int64(); }
+  bool has_step() const { return at<2>().valid(); }
+  int32_t step() const { return at<2>().as_int32(); }
+  bool has_frame_tree_node_id() const { return at<3>().valid(); }
+  int32_t frame_tree_node_id() const { return at<3>().as_int32(); }
+  bool has_component_info() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> component_info() const { return GetRepeated<::protozero::ConstBytes>(4); }
+  bool has_is_coalesced() const { return at<5>().valid(); }
+  bool is_coalesced() const { return at<5>().as_bool(); }
+  bool has_gesture_scroll_id() const { return at<6>().valid(); }
+  int64_t gesture_scroll_id() const { return at<6>().as_int64(); }
+  bool has_touch_id() const { return at<7>().valid(); }
+  int64_t touch_id() const { return at<7>().as_int64(); }
+  bool has_input_type() const { return at<8>().valid(); }
+  int32_t input_type() const { return at<8>().as_int32(); }
 };
 
-class TestEvent : public ::protozero::Message {
+class ChromeLatencyInfo : public ::protozero::Message {
  public:
-  using Decoder = TestEvent_Decoder;
+  using Decoder = ChromeLatencyInfo_Decoder;
   enum : int32_t {
-    kStrFieldNumber = 1,
-    kSeqValueFieldNumber = 2,
-    kCounterFieldNumber = 3,
-    kIsLastFieldNumber = 4,
-    kPayloadFieldNumber = 5,
+    kTraceIdFieldNumber = 1,
+    kStepFieldNumber = 2,
+    kFrameTreeNodeIdFieldNumber = 3,
+    kComponentInfoFieldNumber = 4,
+    kIsCoalescedFieldNumber = 5,
+    kGestureScrollIdFieldNumber = 6,
+    kTouchIdFieldNumber = 7,
+    kInputTypeFieldNumber = 8,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TestEvent"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeLatencyInfo"; }
+
+  using ComponentInfo = ::perfetto::protos::pbzero::ChromeLatencyInfo_ComponentInfo;
 
-  using TestPayload = ::perfetto::protos::pbzero::TestEvent_TestPayload;
+  using Step = ::perfetto::protos::pbzero::ChromeLatencyInfo_Step;
+  static inline const char* Step_Name(Step value) {
+    return ::perfetto::protos::pbzero::ChromeLatencyInfo_Step_Name(value);
+  }
 
-  using FieldMetadata_Str =
+  using LatencyComponentType = ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType;
+  static inline const char* LatencyComponentType_Name(LatencyComponentType value) {
+    return ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType_Name(value);
+  }
+
+  using InputType = ::perfetto::protos::pbzero::ChromeLatencyInfo_InputType;
+  static inline const char* InputType_Name(InputType value) {
+    return ::perfetto::protos::pbzero::ChromeLatencyInfo_InputType_Name(value);
+  }
+  static inline const Step STEP_UNSPECIFIED = Step::STEP_UNSPECIFIED;
+  static inline const Step STEP_SEND_INPUT_EVENT_UI = Step::STEP_SEND_INPUT_EVENT_UI;
+  static inline const Step STEP_HANDLE_INPUT_EVENT_IMPL = Step::STEP_HANDLE_INPUT_EVENT_IMPL;
+  static inline const Step STEP_DID_HANDLE_INPUT_AND_OVERSCROLL = Step::STEP_DID_HANDLE_INPUT_AND_OVERSCROLL;
+  static inline const Step STEP_HANDLE_INPUT_EVENT_MAIN = Step::STEP_HANDLE_INPUT_EVENT_MAIN;
+  static inline const Step STEP_MAIN_THREAD_SCROLL_UPDATE = Step::STEP_MAIN_THREAD_SCROLL_UPDATE;
+  static inline const Step STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT = Step::STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT;
+  static inline const Step STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL = Step::STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL;
+  static inline const Step STEP_HANDLED_INPUT_EVENT_IMPL = Step::STEP_HANDLED_INPUT_EVENT_IMPL;
+  static inline const Step STEP_SWAP_BUFFERS = Step::STEP_SWAP_BUFFERS;
+  static inline const Step STEP_DRAW_AND_SWAP = Step::STEP_DRAW_AND_SWAP;
+  static inline const Step STEP_FINISHED_SWAP_BUFFERS = Step::STEP_FINISHED_SWAP_BUFFERS;
+  static inline const LatencyComponentType COMPONENT_UNSPECIFIED = LatencyComponentType::COMPONENT_UNSPECIFIED;
+  static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH;
+  static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL;
+  static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL;
+  static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL;
+  static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_UI = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_UI;
+  static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN;
+  static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN;
+  static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL;
+  static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT;
+  static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH;
+  static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP;
+  static inline const LatencyComponentType COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME = LatencyComponentType::COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME;
+  static inline const LatencyComponentType COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER = LatencyComponentType::COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER;
+  static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP;
+  static inline const InputType UNSPECIFIED_OR_OTHER = InputType::UNSPECIFIED_OR_OTHER;
+  static inline const InputType TOUCH_MOVED = InputType::TOUCH_MOVED;
+  static inline const InputType GESTURE_SCROLL_BEGIN = InputType::GESTURE_SCROLL_BEGIN;
+  static inline const InputType GESTURE_SCROLL_UPDATE = InputType::GESTURE_SCROLL_UPDATE;
+  static inline const InputType GESTURE_SCROLL_END = InputType::GESTURE_SCROLL_END;
+  static inline const InputType GESTURE_TAP = InputType::GESTURE_TAP;
+  static inline const InputType GESTURE_TAP_CANCEL = InputType::GESTURE_TAP_CANCEL;
+
+  using FieldMetadata_TraceId =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TestEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ChromeLatencyInfo>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Str kStr() { return {}; }
-  void set_str(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Str::kFieldId, data, size);
-  }
-  void set_str(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Str::kFieldId, chars.data, chars.size);
-  }
-  void set_str(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Str::kFieldId;
+  static constexpr FieldMetadata_TraceId kTraceId{};
+  void set_trace_id(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TraceId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SeqValue =
+  using FieldMetadata_Step =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TestEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ChromeLatencyInfo_Step,
+      ChromeLatencyInfo>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SeqValue kSeqValue() { return {}; }
-  void set_seq_value(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SeqValue::kFieldId;
+  static constexpr FieldMetadata_Step kStep{};
+  void set_step(ChromeLatencyInfo_Step value) {
+    static constexpr uint32_t field_id = FieldMetadata_Step::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Counter =
+  using FieldMetadata_FrameTreeNodeId =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TestEvent>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ChromeLatencyInfo>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Counter kCounter() { return {}; }
-  void set_counter(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Counter::kFieldId;
+  static constexpr FieldMetadata_FrameTreeNodeId kFrameTreeNodeId{};
+  void set_frame_tree_node_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FrameTreeNodeId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IsLast =
+  using FieldMetadata_ComponentInfo =
     ::protozero::proto_utils::FieldMetadata<
       4,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromeLatencyInfo_ComponentInfo,
+      ChromeLatencyInfo>;
+
+  static constexpr FieldMetadata_ComponentInfo kComponentInfo{};
+  template <typename T = ChromeLatencyInfo_ComponentInfo> T* add_component_info() {
+    return BeginNestedMessage<T>(4);
+  }
+
+
+  using FieldMetadata_IsCoalesced =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kBool,
       bool,
-      TestEvent>;
+      ChromeLatencyInfo>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IsLast kIsLast() { return {}; }
-  void set_is_last(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_IsLast::kFieldId;
+  static constexpr FieldMetadata_IsCoalesced kIsCoalesced{};
+  void set_is_coalesced(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsCoalesced::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -158350,253 +178027,128 @@ class TestEvent : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Payload =
+  using FieldMetadata_GestureScrollId =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TestEvent_TestPayload,
-      TestEvent>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Payload kPayload() { return {}; }
-  template <typename T = TestEvent_TestPayload> T* set_payload() {
-    return BeginNestedMessage<T>(5);
-  }
-
-};
-
-class TestEvent_TestPayload_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  TestEvent_TestPayload_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TestEvent_TestPayload_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TestEvent_TestPayload_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_str() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> str() const { return GetRepeated<::protozero::ConstChars>(1); }
-  bool has_nested() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> nested() const { return GetRepeated<::protozero::ConstBytes>(2); }
-  bool has_single_string() const { return at<4>().valid(); }
-  ::protozero::ConstChars single_string() const { return at<4>().as_string(); }
-  bool has_single_int() const { return at<5>().valid(); }
-  int32_t single_int() const { return at<5>().as_int32(); }
-  bool has_repeated_ints() const { return at<6>().valid(); }
-  ::protozero::RepeatedFieldIterator<int32_t> repeated_ints() const { return GetRepeated<int32_t>(6); }
-  bool has_remaining_nesting_depth() const { return at<3>().valid(); }
-  uint32_t remaining_nesting_depth() const { return at<3>().as_uint32(); }
-  bool has_debug_annotations() const { return at<7>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> debug_annotations() const { return GetRepeated<::protozero::ConstBytes>(7); }
-};
-
-class TestEvent_TestPayload : public ::protozero::Message {
- public:
-  using Decoder = TestEvent_TestPayload_Decoder;
-  enum : int32_t {
-    kStrFieldNumber = 1,
-    kNestedFieldNumber = 2,
-    kSingleStringFieldNumber = 4,
-    kSingleIntFieldNumber = 5,
-    kRepeatedIntsFieldNumber = 6,
-    kRemainingNestingDepthFieldNumber = 3,
-    kDebugAnnotationsFieldNumber = 7,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TestEvent.TestPayload"; }
-
-
-  using FieldMetadata_Str =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TestEvent_TestPayload>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ChromeLatencyInfo>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Str kStr() { return {}; }
-  void add_str(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Str::kFieldId, data, size);
-  }
-  void add_str(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Str::kFieldId, chars.data, chars.size);
-  }
-  void add_str(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Str::kFieldId;
+  static constexpr FieldMetadata_GestureScrollId kGestureScrollId{};
+  void set_gesture_scroll_id(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GestureScrollId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Nested =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TestEvent_TestPayload,
-      TestEvent_TestPayload>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Nested kNested() { return {}; }
-  template <typename T = TestEvent_TestPayload> T* add_nested() {
-    return BeginNestedMessage<T>(2);
-  }
-
-
-  using FieldMetadata_SingleString =
+  using FieldMetadata_TouchId =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TestEvent_TestPayload>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ChromeLatencyInfo>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SingleString kSingleString() { return {}; }
-  void set_single_string(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_SingleString::kFieldId, data, size);
-  }
-  void set_single_string(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_SingleString::kFieldId, chars.data, chars.size);
-  }
-  void set_single_string(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_SingleString::kFieldId;
+  static constexpr FieldMetadata_TouchId kTouchId{};
+  void set_touch_id(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TouchId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SingleInt =
+  using FieldMetadata_InputType =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      8,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TestEvent_TestPayload>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ChromeLatencyInfo_InputType,
+      ChromeLatencyInfo>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SingleInt kSingleInt() { return {}; }
-  void set_single_int(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SingleInt::kFieldId;
+  static constexpr FieldMetadata_InputType kInputType{};
+  void set_input_type(ChromeLatencyInfo_InputType value) {
+    static constexpr uint32_t field_id = FieldMetadata_InputType::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_RepeatedInts =
+class ChromeLatencyInfo_ComponentInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  ChromeLatencyInfo_ComponentInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeLatencyInfo_ComponentInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeLatencyInfo_ComponentInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_component_type() const { return at<1>().valid(); }
+  int32_t component_type() const { return at<1>().as_int32(); }
+  bool has_time_us() const { return at<2>().valid(); }
+  uint64_t time_us() const { return at<2>().as_uint64(); }
+};
+
+class ChromeLatencyInfo_ComponentInfo : public ::protozero::Message {
+ public:
+  using Decoder = ChromeLatencyInfo_ComponentInfo_Decoder;
+  enum : int32_t {
+    kComponentTypeFieldNumber = 1,
+    kTimeUsFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeLatencyInfo.ComponentInfo"; }
+
+
+  using FieldMetadata_ComponentType =
     ::protozero::proto_utils::FieldMetadata<
-      6,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TestEvent_TestPayload>;
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ChromeLatencyInfo_LatencyComponentType,
+      ChromeLatencyInfo_ComponentInfo>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RepeatedInts kRepeatedInts() { return {}; }
-  void add_repeated_ints(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RepeatedInts::kFieldId;
+  static constexpr FieldMetadata_ComponentType kComponentType{};
+  void set_component_type(ChromeLatencyInfo_LatencyComponentType value) {
+    static constexpr uint32_t field_id = FieldMetadata_ComponentType::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_RemainingNestingDepth =
+  using FieldMetadata_TimeUs =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TestEvent_TestPayload>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ChromeLatencyInfo_ComponentInfo>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_RemainingNestingDepth kRemainingNestingDepth() { return {}; }
-  void set_remaining_nesting_depth(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_RemainingNestingDepth::kFieldId;
+  static constexpr FieldMetadata_TimeUs kTimeUs{};
+  void set_time_us(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimeUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
-
-  using FieldMetadata_DebugAnnotations =
-    ::protozero::proto_utils::FieldMetadata<
-      7,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      DebugAnnotation,
-      TestEvent_TestPayload>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DebugAnnotations kDebugAnnotations() { return {}; }
-  template <typename T = DebugAnnotation> T* add_debug_annotations() {
-    return BeginNestedMessage<T>(7);
-  }
-
 };
 
 } // Namespace.
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/test_extensions.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_legacy_ipc.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TEST_EXTENSIONS_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TEST_EXTENSIONS_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LEGACY_IPC_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LEGACY_IPC_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -158606,208 +178158,383 @@ class TestEvent_TestPayload : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_event.pbzero.h"
 
 namespace perfetto {
 namespace protos {
 namespace pbzero {
+namespace perfetto_pbzero_enum_ChromeLegacyIpc {
+enum MessageClass : int32_t;
+}  // namespace perfetto_pbzero_enum_ChromeLegacyIpc
+using ChromeLegacyIpc_MessageClass = perfetto_pbzero_enum_ChromeLegacyIpc::MessageClass;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-class DebugAnnotation;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-class TestExtensionChild_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/99, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  TestExtensionChild_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TestExtensionChild_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TestExtensionChild_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_child_field_for_testing() const { return at<1>().valid(); }
-  ::protozero::ConstChars child_field_for_testing() const { return at<1>().as_string(); }
-  bool has_debug_annotations() const { return at<99>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> debug_annotations() const { return GetRepeated<::protozero::ConstBytes>(99); }
+namespace perfetto_pbzero_enum_ChromeLegacyIpc {
+enum MessageClass : int32_t {
+  CLASS_UNSPECIFIED = 0,
+  CLASS_AUTOMATION = 1,
+  CLASS_FRAME = 2,
+  CLASS_PAGE = 3,
+  CLASS_VIEW = 4,
+  CLASS_WIDGET = 5,
+  CLASS_INPUT = 6,
+  CLASS_TEST = 7,
+  CLASS_WORKER = 8,
+  CLASS_NACL = 9,
+  CLASS_GPU_CHANNEL = 10,
+  CLASS_MEDIA = 11,
+  CLASS_PPAPI = 12,
+  CLASS_CHROME = 13,
+  CLASS_DRAG = 14,
+  CLASS_PRINT = 15,
+  CLASS_EXTENSION = 16,
+  CLASS_TEXT_INPUT_CLIENT = 17,
+  CLASS_BLINK_TEST = 18,
+  CLASS_ACCESSIBILITY = 19,
+  CLASS_PRERENDER = 20,
+  CLASS_CHROMOTING = 21,
+  CLASS_BROWSER_PLUGIN = 22,
+  CLASS_ANDROID_WEB_VIEW = 23,
+  CLASS_NACL_HOST = 24,
+  CLASS_ENCRYPTED_MEDIA = 25,
+  CLASS_CAST = 26,
+  CLASS_GIN_JAVA_BRIDGE = 27,
+  CLASS_CHROME_UTILITY_PRINTING = 28,
+  CLASS_OZONE_GPU = 29,
+  CLASS_WEB_TEST = 30,
+  CLASS_NETWORK_HINTS = 31,
+  CLASS_EXTENSIONS_GUEST_VIEW = 32,
+  CLASS_GUEST_VIEW = 33,
+  CLASS_MEDIA_PLAYER_DELEGATE = 34,
+  CLASS_EXTENSION_WORKER = 35,
+  CLASS_SUBRESOURCE_FILTER = 36,
+  CLASS_UNFREEZABLE_FRAME = 37,
 };
+} // namespace perfetto_pbzero_enum_ChromeLegacyIpc
+using ChromeLegacyIpc_MessageClass = perfetto_pbzero_enum_ChromeLegacyIpc::MessageClass;
 
-class TestExtensionChild : public ::protozero::Message {
- public:
-  using Decoder = TestExtensionChild_Decoder;
-  enum : int32_t {
-    kChildFieldForTestingFieldNumber = 1,
-    kDebugAnnotationsFieldNumber = 99,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.TestExtensionChild"; }
 
+constexpr ChromeLegacyIpc_MessageClass ChromeLegacyIpc_MessageClass_MIN = ChromeLegacyIpc_MessageClass::CLASS_UNSPECIFIED;
+constexpr ChromeLegacyIpc_MessageClass ChromeLegacyIpc_MessageClass_MAX = ChromeLegacyIpc_MessageClass::CLASS_UNFREEZABLE_FRAME;
 
-  using FieldMetadata_ChildFieldForTesting =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TestExtensionChild>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChildFieldForTesting kChildFieldForTesting() { return {}; }
-  void set_child_field_for_testing(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ChildFieldForTesting::kFieldId, data, size);
-  }
-  void set_child_field_for_testing(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ChildFieldForTesting::kFieldId, chars.data, chars.size);
-  }
-  void set_child_field_for_testing(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ChildFieldForTesting::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ChromeLegacyIpc_MessageClass_Name(::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_UNSPECIFIED:
+    return "CLASS_UNSPECIFIED";
 
-  using FieldMetadata_DebugAnnotations =
-    ::protozero::proto_utils::FieldMetadata<
-      99,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      DebugAnnotation,
-      TestExtensionChild>;
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_AUTOMATION:
+    return "CLASS_AUTOMATION";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DebugAnnotations kDebugAnnotations() { return {}; }
-  template <typename T = DebugAnnotation> T* add_debug_annotations() {
-    return BeginNestedMessage<T>(99);
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_FRAME:
+    return "CLASS_FRAME";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_PAGE:
+    return "CLASS_PAGE";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_VIEW:
+    return "CLASS_VIEW";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_WIDGET:
+    return "CLASS_WIDGET";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_INPUT:
+    return "CLASS_INPUT";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_TEST:
+    return "CLASS_TEST";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_WORKER:
+    return "CLASS_WORKER";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_NACL:
+    return "CLASS_NACL";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_GPU_CHANNEL:
+    return "CLASS_GPU_CHANNEL";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_MEDIA:
+    return "CLASS_MEDIA";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_PPAPI:
+    return "CLASS_PPAPI";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_CHROME:
+    return "CLASS_CHROME";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_DRAG:
+    return "CLASS_DRAG";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_PRINT:
+    return "CLASS_PRINT";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_EXTENSION:
+    return "CLASS_EXTENSION";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_TEXT_INPUT_CLIENT:
+    return "CLASS_TEXT_INPUT_CLIENT";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_BLINK_TEST:
+    return "CLASS_BLINK_TEST";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_ACCESSIBILITY:
+    return "CLASS_ACCESSIBILITY";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_PRERENDER:
+    return "CLASS_PRERENDER";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_CHROMOTING:
+    return "CLASS_CHROMOTING";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_BROWSER_PLUGIN:
+    return "CLASS_BROWSER_PLUGIN";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_ANDROID_WEB_VIEW:
+    return "CLASS_ANDROID_WEB_VIEW";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_NACL_HOST:
+    return "CLASS_NACL_HOST";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_ENCRYPTED_MEDIA:
+    return "CLASS_ENCRYPTED_MEDIA";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_CAST:
+    return "CLASS_CAST";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_GIN_JAVA_BRIDGE:
+    return "CLASS_GIN_JAVA_BRIDGE";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_CHROME_UTILITY_PRINTING:
+    return "CLASS_CHROME_UTILITY_PRINTING";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_OZONE_GPU:
+    return "CLASS_OZONE_GPU";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_WEB_TEST:
+    return "CLASS_WEB_TEST";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_NETWORK_HINTS:
+    return "CLASS_NETWORK_HINTS";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_EXTENSIONS_GUEST_VIEW:
+    return "CLASS_EXTENSIONS_GUEST_VIEW";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_GUEST_VIEW:
+    return "CLASS_GUEST_VIEW";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_MEDIA_PLAYER_DELEGATE:
+    return "CLASS_MEDIA_PLAYER_DELEGATE";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_EXTENSION_WORKER:
+    return "CLASS_EXTENSION_WORKER";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_SUBRESOURCE_FILTER:
+    return "CLASS_SUBRESOURCE_FILTER";
+
+  case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_UNFREEZABLE_FRAME:
+    return "CLASS_UNFREEZABLE_FRAME";
   }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
+class ChromeLegacyIpc_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  ChromeLegacyIpc_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeLegacyIpc_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeLegacyIpc_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_message_class() const { return at<1>().valid(); }
+  int32_t message_class() const { return at<1>().as_int32(); }
+  bool has_message_line() const { return at<2>().valid(); }
+  uint32_t message_line() const { return at<2>().as_uint32(); }
 };
 
-class TestExtension : public ::perfetto::protos::pbzero::TrackEvent {
+class ChromeLegacyIpc : public ::protozero::Message {
  public:
+  using Decoder = ChromeLegacyIpc_Decoder;
+  enum : int32_t {
+    kMessageClassFieldNumber = 1,
+    kMessageLineFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeLegacyIpc"; }
 
-  using FieldMetadata_StringExtensionForTesting =
+
+  using MessageClass = ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass;
+  static inline const char* MessageClass_Name(MessageClass value) {
+    return ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass_Name(value);
+  }
+  static inline const MessageClass CLASS_UNSPECIFIED = MessageClass::CLASS_UNSPECIFIED;
+  static inline const MessageClass CLASS_AUTOMATION = MessageClass::CLASS_AUTOMATION;
+  static inline const MessageClass CLASS_FRAME = MessageClass::CLASS_FRAME;
+  static inline const MessageClass CLASS_PAGE = MessageClass::CLASS_PAGE;
+  static inline const MessageClass CLASS_VIEW = MessageClass::CLASS_VIEW;
+  static inline const MessageClass CLASS_WIDGET = MessageClass::CLASS_WIDGET;
+  static inline const MessageClass CLASS_INPUT = MessageClass::CLASS_INPUT;
+  static inline const MessageClass CLASS_TEST = MessageClass::CLASS_TEST;
+  static inline const MessageClass CLASS_WORKER = MessageClass::CLASS_WORKER;
+  static inline const MessageClass CLASS_NACL = MessageClass::CLASS_NACL;
+  static inline const MessageClass CLASS_GPU_CHANNEL = MessageClass::CLASS_GPU_CHANNEL;
+  static inline const MessageClass CLASS_MEDIA = MessageClass::CLASS_MEDIA;
+  static inline const MessageClass CLASS_PPAPI = MessageClass::CLASS_PPAPI;
+  static inline const MessageClass CLASS_CHROME = MessageClass::CLASS_CHROME;
+  static inline const MessageClass CLASS_DRAG = MessageClass::CLASS_DRAG;
+  static inline const MessageClass CLASS_PRINT = MessageClass::CLASS_PRINT;
+  static inline const MessageClass CLASS_EXTENSION = MessageClass::CLASS_EXTENSION;
+  static inline const MessageClass CLASS_TEXT_INPUT_CLIENT = MessageClass::CLASS_TEXT_INPUT_CLIENT;
+  static inline const MessageClass CLASS_BLINK_TEST = MessageClass::CLASS_BLINK_TEST;
+  static inline const MessageClass CLASS_ACCESSIBILITY = MessageClass::CLASS_ACCESSIBILITY;
+  static inline const MessageClass CLASS_PRERENDER = MessageClass::CLASS_PRERENDER;
+  static inline const MessageClass CLASS_CHROMOTING = MessageClass::CLASS_CHROMOTING;
+  static inline const MessageClass CLASS_BROWSER_PLUGIN = MessageClass::CLASS_BROWSER_PLUGIN;
+  static inline const MessageClass CLASS_ANDROID_WEB_VIEW = MessageClass::CLASS_ANDROID_WEB_VIEW;
+  static inline const MessageClass CLASS_NACL_HOST = MessageClass::CLASS_NACL_HOST;
+  static inline const MessageClass CLASS_ENCRYPTED_MEDIA = MessageClass::CLASS_ENCRYPTED_MEDIA;
+  static inline const MessageClass CLASS_CAST = MessageClass::CLASS_CAST;
+  static inline const MessageClass CLASS_GIN_JAVA_BRIDGE = MessageClass::CLASS_GIN_JAVA_BRIDGE;
+  static inline const MessageClass CLASS_CHROME_UTILITY_PRINTING = MessageClass::CLASS_CHROME_UTILITY_PRINTING;
+  static inline const MessageClass CLASS_OZONE_GPU = MessageClass::CLASS_OZONE_GPU;
+  static inline const MessageClass CLASS_WEB_TEST = MessageClass::CLASS_WEB_TEST;
+  static inline const MessageClass CLASS_NETWORK_HINTS = MessageClass::CLASS_NETWORK_HINTS;
+  static inline const MessageClass CLASS_EXTENSIONS_GUEST_VIEW = MessageClass::CLASS_EXTENSIONS_GUEST_VIEW;
+  static inline const MessageClass CLASS_GUEST_VIEW = MessageClass::CLASS_GUEST_VIEW;
+  static inline const MessageClass CLASS_MEDIA_PLAYER_DELEGATE = MessageClass::CLASS_MEDIA_PLAYER_DELEGATE;
+  static inline const MessageClass CLASS_EXTENSION_WORKER = MessageClass::CLASS_EXTENSION_WORKER;
+  static inline const MessageClass CLASS_SUBRESOURCE_FILTER = MessageClass::CLASS_SUBRESOURCE_FILTER;
+  static inline const MessageClass CLASS_UNFREEZABLE_FRAME = MessageClass::CLASS_UNFREEZABLE_FRAME;
+
+  using FieldMetadata_MessageClass =
     ::protozero::proto_utils::FieldMetadata<
-      9900,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TestExtension>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ChromeLegacyIpc_MessageClass,
+      ChromeLegacyIpc>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StringExtensionForTesting kStringExtensionForTesting() { return {}; }
-  void set_string_extension_for_testing(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_StringExtensionForTesting::kFieldId, data, size);
-  }
-  void set_string_extension_for_testing(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_StringExtensionForTesting::kFieldId, chars.data, chars.size);
-  }
-  void set_string_extension_for_testing(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_StringExtensionForTesting::kFieldId;
+  static constexpr FieldMetadata_MessageClass kMessageClass{};
+  void set_message_class(ChromeLegacyIpc_MessageClass value) {
+    static constexpr uint32_t field_id = FieldMetadata_MessageClass::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_IntExtensionForTesting =
+  using FieldMetadata_MessageLine =
     ::protozero::proto_utils::FieldMetadata<
-      9901,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TestExtension>;
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ChromeLegacyIpc>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IntExtensionForTesting kIntExtensionForTesting() { return {}; }
-  void add_int_extension_for_testing(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_IntExtensionForTesting::kFieldId;
+  static constexpr FieldMetadata_MessageLine kMessageLine{};
+  void set_message_line(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MessageLine::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_OmittedExtensionForTesting =
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_message_pump.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MESSAGE_PUMP_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MESSAGE_PUMP_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class ChromeMessagePump_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  ChromeMessagePump_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeMessagePump_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeMessagePump_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_sent_messages_in_queue() const { return at<1>().valid(); }
+  bool sent_messages_in_queue() const { return at<1>().as_bool(); }
+  bool has_io_handler_location_iid() const { return at<2>().valid(); }
+  uint64_t io_handler_location_iid() const { return at<2>().as_uint64(); }
+};
+
+class ChromeMessagePump : public ::protozero::Message {
+ public:
+  using Decoder = ChromeMessagePump_Decoder;
+  enum : int32_t {
+    kSentMessagesInQueueFieldNumber = 1,
+    kIoHandlerLocationIidFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeMessagePump"; }
+
+
+  using FieldMetadata_SentMessagesInQueue =
     ::protozero::proto_utils::FieldMetadata<
-      9902,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      TestExtension>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeMessagePump>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_OmittedExtensionForTesting kOmittedExtensionForTesting() { return {}; }
-  void set_omitted_extension_for_testing(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_OmittedExtensionForTesting::kFieldId, data, size);
-  }
-  void set_omitted_extension_for_testing(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_OmittedExtensionForTesting::kFieldId, chars.data, chars.size);
-  }
-  void set_omitted_extension_for_testing(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_OmittedExtensionForTesting::kFieldId;
+  static constexpr FieldMetadata_SentMessagesInQueue kSentMessagesInQueue{};
+  void set_sent_messages_in_queue(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_SentMessagesInQueue::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_NestedMessageExtensionForTesting =
+  using FieldMetadata_IoHandlerLocationIid =
     ::protozero::proto_utils::FieldMetadata<
-      9903,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TestExtensionChild,
-      TestExtension>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ChromeMessagePump>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NestedMessageExtensionForTesting kNestedMessageExtensionForTesting() { return {}; }
-  template <typename T = TestExtensionChild> T* set_nested_message_extension_for_testing() {
-    return BeginNestedMessage<T>(9903);
+  static constexpr FieldMetadata_IoHandlerLocationIid kIoHandlerLocationIid{};
+  void set_io_handler_location_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IoHandlerLocationIid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
-
 };
+
 } // Namespace.
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/trace_packet.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_mojo_event_info.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACE_PACKET_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACE_PACKET_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MOJO_EVENT_INFO_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MOJO_EVENT_INFO_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -158818,383 +178545,82 @@ class TestExtension : public ::perfetto::protos::pbzero::TrackEvent {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-class AndroidCameraFrameEvent;
-class AndroidCameraSessionStats;
-class AndroidEnergyEstimationBreakdown;
-class AndroidGameInterventionList;
-class AndroidLogPacket;
-class AndroidSystemProperty;
-class BatteryCounters;
-class ChromeBenchmarkMetadata;
-class ChromeEventBundle;
-class ChromeMetadataPacket;
-class ClockSnapshot;
-class CpuInfo;
-class DeobfuscationMapping;
-class EntityStateResidency;
-class ExtensionDescriptor;
-class FrameTimelineEvent;
-class FtraceEventBundle;
-class FtraceStats;
-class GpuCounterEvent;
-class GpuLog;
-class GpuMemTotalEvent;
-class GpuRenderStageEvent;
-class GraphicsFrameEvent;
-class HeapGraph;
-class InitialDisplayState;
-class InodeFileMap;
-class InternedData;
-class MemoryTrackerSnapshot;
-class ModuleSymbols;
-class NetworkPacketEvent;
-class PackagesList;
-class PerfSample;
-class PerfettoMetatrace;
-class PowerRails;
-class ProcessDescriptor;
-class ProcessStats;
-class ProcessTree;
-class ProfilePacket;
-class ProfiledFrameSymbols;
-class SmapsPacket;
-class StatsdAtom;
-class StreamingAllocation;
-class StreamingFree;
-class StreamingProfilePacket;
-class SysStats;
-class SystemInfo;
-class TestEvent;
-class ThreadDescriptor;
-class TraceConfig;
-class TracePacketDefaults;
-class TraceStats;
-class TraceUuid;
-class TracingServiceEvent;
-class TrackDescriptor;
-class TrackEvent;
-class TrackEventRangeOfInterest;
-class TranslationTable;
-class Trigger;
-class UiState;
-class VulkanApiEvent;
-class VulkanMemoryEvent;
-
-namespace perfetto_pbzero_enum_TracePacket {
-enum SequenceFlags : int32_t {
-  SEQ_UNSPECIFIED = 0,
-  SEQ_INCREMENTAL_STATE_CLEARED = 1,
-  SEQ_NEEDS_INCREMENTAL_STATE = 2,
-};
-} // namespace perfetto_pbzero_enum_TracePacket
-using TracePacket_SequenceFlags = perfetto_pbzero_enum_TracePacket::SequenceFlags;
-
-
-constexpr TracePacket_SequenceFlags TracePacket_SequenceFlags_MIN = TracePacket_SequenceFlags::SEQ_UNSPECIFIED;
-constexpr TracePacket_SequenceFlags TracePacket_SequenceFlags_MAX = TracePacket_SequenceFlags::SEQ_NEEDS_INCREMENTAL_STATE;
-
-
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* TracePacket_SequenceFlags_Name(::perfetto::protos::pbzero::TracePacket_SequenceFlags value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::TracePacket_SequenceFlags::SEQ_UNSPECIFIED:
-    return "SEQ_UNSPECIFIED";
-
-  case ::perfetto::protos::pbzero::TracePacket_SequenceFlags::SEQ_INCREMENTAL_STATE_CLEARED:
-    return "SEQ_INCREMENTAL_STATE_CLEARED";
-
-  case ::perfetto::protos::pbzero::TracePacket_SequenceFlags::SEQ_NEEDS_INCREMENTAL_STATE:
-    return "SEQ_NEEDS_INCREMENTAL_STATE";
-  }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
-
-class TracePacket_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/900, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class ChromeMojoEventInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
-  TracePacket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit TracePacket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit TracePacket_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_timestamp() const { return at<8>().valid(); }
-  uint64_t timestamp() const { return at<8>().as_uint64(); }
-  bool has_timestamp_clock_id() const { return at<58>().valid(); }
-  uint32_t timestamp_clock_id() const { return at<58>().as_uint32(); }
-  bool has_process_tree() const { return at<2>().valid(); }
-  ::protozero::ConstBytes process_tree() const { return at<2>().as_bytes(); }
-  bool has_process_stats() const { return at<9>().valid(); }
-  ::protozero::ConstBytes process_stats() const { return at<9>().as_bytes(); }
-  bool has_inode_file_map() const { return at<4>().valid(); }
-  ::protozero::ConstBytes inode_file_map() const { return at<4>().as_bytes(); }
-  bool has_chrome_events() const { return at<5>().valid(); }
-  ::protozero::ConstBytes chrome_events() const { return at<5>().as_bytes(); }
-  bool has_clock_snapshot() const { return at<6>().valid(); }
-  ::protozero::ConstBytes clock_snapshot() const { return at<6>().as_bytes(); }
-  bool has_sys_stats() const { return at<7>().valid(); }
-  ::protozero::ConstBytes sys_stats() const { return at<7>().as_bytes(); }
-  bool has_track_event() const { return at<11>().valid(); }
-  ::protozero::ConstBytes track_event() const { return at<11>().as_bytes(); }
-  bool has_trace_uuid() const { return at<89>().valid(); }
-  ::protozero::ConstBytes trace_uuid() const { return at<89>().as_bytes(); }
-  bool has_trace_config() const { return at<33>().valid(); }
-  ::protozero::ConstBytes trace_config() const { return at<33>().as_bytes(); }
-  bool has_ftrace_stats() const { return at<34>().valid(); }
-  ::protozero::ConstBytes ftrace_stats() const { return at<34>().as_bytes(); }
-  bool has_trace_stats() const { return at<35>().valid(); }
-  ::protozero::ConstBytes trace_stats() const { return at<35>().as_bytes(); }
-  bool has_profile_packet() const { return at<37>().valid(); }
-  ::protozero::ConstBytes profile_packet() const { return at<37>().as_bytes(); }
-  bool has_streaming_allocation() const { return at<74>().valid(); }
-  ::protozero::ConstBytes streaming_allocation() const { return at<74>().as_bytes(); }
-  bool has_streaming_free() const { return at<75>().valid(); }
-  ::protozero::ConstBytes streaming_free() const { return at<75>().as_bytes(); }
-  bool has_battery() const { return at<38>().valid(); }
-  ::protozero::ConstBytes battery() const { return at<38>().as_bytes(); }
-  bool has_power_rails() const { return at<40>().valid(); }
-  ::protozero::ConstBytes power_rails() const { return at<40>().as_bytes(); }
-  bool has_android_log() const { return at<39>().valid(); }
-  ::protozero::ConstBytes android_log() const { return at<39>().as_bytes(); }
-  bool has_system_info() const { return at<45>().valid(); }
-  ::protozero::ConstBytes system_info() const { return at<45>().as_bytes(); }
-  bool has_trigger() const { return at<46>().valid(); }
-  ::protozero::ConstBytes trigger() const { return at<46>().as_bytes(); }
-  bool has_packages_list() const { return at<47>().valid(); }
-  ::protozero::ConstBytes packages_list() const { return at<47>().as_bytes(); }
-  bool has_chrome_benchmark_metadata() const { return at<48>().valid(); }
-  ::protozero::ConstBytes chrome_benchmark_metadata() const { return at<48>().as_bytes(); }
-  bool has_perfetto_metatrace() const { return at<49>().valid(); }
-  ::protozero::ConstBytes perfetto_metatrace() const { return at<49>().as_bytes(); }
-  bool has_chrome_metadata() const { return at<51>().valid(); }
-  ::protozero::ConstBytes chrome_metadata() const { return at<51>().as_bytes(); }
-  bool has_gpu_counter_event() const { return at<52>().valid(); }
-  ::protozero::ConstBytes gpu_counter_event() const { return at<52>().as_bytes(); }
-  bool has_gpu_render_stage_event() const { return at<53>().valid(); }
-  ::protozero::ConstBytes gpu_render_stage_event() const { return at<53>().as_bytes(); }
-  bool has_streaming_profile_packet() const { return at<54>().valid(); }
-  ::protozero::ConstBytes streaming_profile_packet() const { return at<54>().as_bytes(); }
-  bool has_heap_graph() const { return at<56>().valid(); }
-  ::protozero::ConstBytes heap_graph() const { return at<56>().as_bytes(); }
-  bool has_graphics_frame_event() const { return at<57>().valid(); }
-  ::protozero::ConstBytes graphics_frame_event() const { return at<57>().as_bytes(); }
-  bool has_vulkan_memory_event() const { return at<62>().valid(); }
-  ::protozero::ConstBytes vulkan_memory_event() const { return at<62>().as_bytes(); }
-  bool has_gpu_log() const { return at<63>().valid(); }
-  ::protozero::ConstBytes gpu_log() const { return at<63>().as_bytes(); }
-  bool has_vulkan_api_event() const { return at<65>().valid(); }
-  ::protozero::ConstBytes vulkan_api_event() const { return at<65>().as_bytes(); }
-  bool has_perf_sample() const { return at<66>().valid(); }
-  ::protozero::ConstBytes perf_sample() const { return at<66>().as_bytes(); }
-  bool has_cpu_info() const { return at<67>().valid(); }
-  ::protozero::ConstBytes cpu_info() const { return at<67>().as_bytes(); }
-  bool has_smaps_packet() const { return at<68>().valid(); }
-  ::protozero::ConstBytes smaps_packet() const { return at<68>().as_bytes(); }
-  bool has_service_event() const { return at<69>().valid(); }
-  ::protozero::ConstBytes service_event() const { return at<69>().as_bytes(); }
-  bool has_initial_display_state() const { return at<70>().valid(); }
-  ::protozero::ConstBytes initial_display_state() const { return at<70>().as_bytes(); }
-  bool has_gpu_mem_total_event() const { return at<71>().valid(); }
-  ::protozero::ConstBytes gpu_mem_total_event() const { return at<71>().as_bytes(); }
-  bool has_memory_tracker_snapshot() const { return at<73>().valid(); }
-  ::protozero::ConstBytes memory_tracker_snapshot() const { return at<73>().as_bytes(); }
-  bool has_frame_timeline_event() const { return at<76>().valid(); }
-  ::protozero::ConstBytes frame_timeline_event() const { return at<76>().as_bytes(); }
-  bool has_android_energy_estimation_breakdown() const { return at<77>().valid(); }
-  ::protozero::ConstBytes android_energy_estimation_breakdown() const { return at<77>().as_bytes(); }
-  bool has_ui_state() const { return at<78>().valid(); }
-  ::protozero::ConstBytes ui_state() const { return at<78>().as_bytes(); }
-  bool has_android_camera_frame_event() const { return at<80>().valid(); }
-  ::protozero::ConstBytes android_camera_frame_event() const { return at<80>().as_bytes(); }
-  bool has_android_camera_session_stats() const { return at<81>().valid(); }
-  ::protozero::ConstBytes android_camera_session_stats() const { return at<81>().as_bytes(); }
-  bool has_translation_table() const { return at<82>().valid(); }
-  ::protozero::ConstBytes translation_table() const { return at<82>().as_bytes(); }
-  bool has_android_game_intervention_list() const { return at<83>().valid(); }
-  ::protozero::ConstBytes android_game_intervention_list() const { return at<83>().as_bytes(); }
-  bool has_statsd_atom() const { return at<84>().valid(); }
-  ::protozero::ConstBytes statsd_atom() const { return at<84>().as_bytes(); }
-  bool has_android_system_property() const { return at<86>().valid(); }
-  ::protozero::ConstBytes android_system_property() const { return at<86>().as_bytes(); }
-  bool has_entity_state_residency() const { return at<91>().valid(); }
-  ::protozero::ConstBytes entity_state_residency() const { return at<91>().as_bytes(); }
-  bool has_profiled_frame_symbols() const { return at<55>().valid(); }
-  ::protozero::ConstBytes profiled_frame_symbols() const { return at<55>().as_bytes(); }
-  bool has_module_symbols() const { return at<61>().valid(); }
-  ::protozero::ConstBytes module_symbols() const { return at<61>().as_bytes(); }
-  bool has_deobfuscation_mapping() const { return at<64>().valid(); }
-  ::protozero::ConstBytes deobfuscation_mapping() const { return at<64>().as_bytes(); }
-  bool has_track_descriptor() const { return at<60>().valid(); }
-  ::protozero::ConstBytes track_descriptor() const { return at<60>().as_bytes(); }
-  bool has_process_descriptor() const { return at<43>().valid(); }
-  ::protozero::ConstBytes process_descriptor() const { return at<43>().as_bytes(); }
-  bool has_thread_descriptor() const { return at<44>().valid(); }
-  ::protozero::ConstBytes thread_descriptor() const { return at<44>().as_bytes(); }
-  bool has_ftrace_events() const { return at<1>().valid(); }
-  ::protozero::ConstBytes ftrace_events() const { return at<1>().as_bytes(); }
-  bool has_synchronization_marker() const { return at<36>().valid(); }
-  ::protozero::ConstBytes synchronization_marker() const { return at<36>().as_bytes(); }
-  bool has_compressed_packets() const { return at<50>().valid(); }
-  ::protozero::ConstBytes compressed_packets() const { return at<50>().as_bytes(); }
-  bool has_extension_descriptor() const { return at<72>().valid(); }
-  ::protozero::ConstBytes extension_descriptor() const { return at<72>().as_bytes(); }
-  bool has_network_packet() const { return at<88>().valid(); }
-  ::protozero::ConstBytes network_packet() const { return at<88>().as_bytes(); }
-  bool has_track_event_range_of_interest() const { return at<90>().valid(); }
-  ::protozero::ConstBytes track_event_range_of_interest() const { return at<90>().as_bytes(); }
-  bool has_for_testing() const { return at<900>().valid(); }
-  ::protozero::ConstBytes for_testing() const { return at<900>().as_bytes(); }
-  bool has_trusted_uid() const { return at<3>().valid(); }
-  int32_t trusted_uid() const { return at<3>().as_int32(); }
-  bool has_trusted_packet_sequence_id() const { return at<10>().valid(); }
-  uint32_t trusted_packet_sequence_id() const { return at<10>().as_uint32(); }
-  bool has_trusted_pid() const { return at<79>().valid(); }
-  int32_t trusted_pid() const { return at<79>().as_int32(); }
-  bool has_interned_data() const { return at<12>().valid(); }
-  ::protozero::ConstBytes interned_data() const { return at<12>().as_bytes(); }
-  bool has_sequence_flags() const { return at<13>().valid(); }
-  uint32_t sequence_flags() const { return at<13>().as_uint32(); }
-  bool has_incremental_state_cleared() const { return at<41>().valid(); }
-  bool incremental_state_cleared() const { return at<41>().as_bool(); }
-  bool has_trace_packet_defaults() const { return at<59>().valid(); }
-  ::protozero::ConstBytes trace_packet_defaults() const { return at<59>().as_bytes(); }
-  bool has_previous_packet_dropped() const { return at<42>().valid(); }
-  bool previous_packet_dropped() const { return at<42>().as_bool(); }
-  bool has_first_packet_on_sequence() const { return at<87>().valid(); }
-  bool first_packet_on_sequence() const { return at<87>().as_bool(); }
+  ChromeMojoEventInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeMojoEventInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeMojoEventInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_watcher_notify_interface_tag() const { return at<1>().valid(); }
+  ::protozero::ConstChars watcher_notify_interface_tag() const { return at<1>().as_string(); }
+  bool has_ipc_hash() const { return at<2>().valid(); }
+  uint32_t ipc_hash() const { return at<2>().as_uint32(); }
+  bool has_mojo_interface_tag() const { return at<3>().valid(); }
+  ::protozero::ConstChars mojo_interface_tag() const { return at<3>().as_string(); }
+  bool has_mojo_interface_method_iid() const { return at<4>().valid(); }
+  uint64_t mojo_interface_method_iid() const { return at<4>().as_uint64(); }
+  bool has_is_reply() const { return at<5>().valid(); }
+  bool is_reply() const { return at<5>().as_bool(); }
+  bool has_payload_size() const { return at<6>().valid(); }
+  uint64_t payload_size() const { return at<6>().as_uint64(); }
+  bool has_data_num_bytes() const { return at<7>().valid(); }
+  uint64_t data_num_bytes() const { return at<7>().as_uint64(); }
 };
 
-class TracePacket : public ::protozero::Message {
+class ChromeMojoEventInfo : public ::protozero::Message {
  public:
-  using Decoder = TracePacket_Decoder;
+  using Decoder = ChromeMojoEventInfo_Decoder;
   enum : int32_t {
-    kTimestampFieldNumber = 8,
-    kTimestampClockIdFieldNumber = 58,
-    kProcessTreeFieldNumber = 2,
-    kProcessStatsFieldNumber = 9,
-    kInodeFileMapFieldNumber = 4,
-    kChromeEventsFieldNumber = 5,
-    kClockSnapshotFieldNumber = 6,
-    kSysStatsFieldNumber = 7,
-    kTrackEventFieldNumber = 11,
-    kTraceUuidFieldNumber = 89,
-    kTraceConfigFieldNumber = 33,
-    kFtraceStatsFieldNumber = 34,
-    kTraceStatsFieldNumber = 35,
-    kProfilePacketFieldNumber = 37,
-    kStreamingAllocationFieldNumber = 74,
-    kStreamingFreeFieldNumber = 75,
-    kBatteryFieldNumber = 38,
-    kPowerRailsFieldNumber = 40,
-    kAndroidLogFieldNumber = 39,
-    kSystemInfoFieldNumber = 45,
-    kTriggerFieldNumber = 46,
-    kPackagesListFieldNumber = 47,
-    kChromeBenchmarkMetadataFieldNumber = 48,
-    kPerfettoMetatraceFieldNumber = 49,
-    kChromeMetadataFieldNumber = 51,
-    kGpuCounterEventFieldNumber = 52,
-    kGpuRenderStageEventFieldNumber = 53,
-    kStreamingProfilePacketFieldNumber = 54,
-    kHeapGraphFieldNumber = 56,
-    kGraphicsFrameEventFieldNumber = 57,
-    kVulkanMemoryEventFieldNumber = 62,
-    kGpuLogFieldNumber = 63,
-    kVulkanApiEventFieldNumber = 65,
-    kPerfSampleFieldNumber = 66,
-    kCpuInfoFieldNumber = 67,
-    kSmapsPacketFieldNumber = 68,
-    kServiceEventFieldNumber = 69,
-    kInitialDisplayStateFieldNumber = 70,
-    kGpuMemTotalEventFieldNumber = 71,
-    kMemoryTrackerSnapshotFieldNumber = 73,
-    kFrameTimelineEventFieldNumber = 76,
-    kAndroidEnergyEstimationBreakdownFieldNumber = 77,
-    kUiStateFieldNumber = 78,
-    kAndroidCameraFrameEventFieldNumber = 80,
-    kAndroidCameraSessionStatsFieldNumber = 81,
-    kTranslationTableFieldNumber = 82,
-    kAndroidGameInterventionListFieldNumber = 83,
-    kStatsdAtomFieldNumber = 84,
-    kAndroidSystemPropertyFieldNumber = 86,
-    kEntityStateResidencyFieldNumber = 91,
-    kProfiledFrameSymbolsFieldNumber = 55,
-    kModuleSymbolsFieldNumber = 61,
-    kDeobfuscationMappingFieldNumber = 64,
-    kTrackDescriptorFieldNumber = 60,
-    kProcessDescriptorFieldNumber = 43,
-    kThreadDescriptorFieldNumber = 44,
-    kFtraceEventsFieldNumber = 1,
-    kSynchronizationMarkerFieldNumber = 36,
-    kCompressedPacketsFieldNumber = 50,
-    kExtensionDescriptorFieldNumber = 72,
-    kNetworkPacketFieldNumber = 88,
-    kTrackEventRangeOfInterestFieldNumber = 90,
-    kForTestingFieldNumber = 900,
-    kTrustedUidFieldNumber = 3,
-    kTrustedPacketSequenceIdFieldNumber = 10,
-    kTrustedPidFieldNumber = 79,
-    kInternedDataFieldNumber = 12,
-    kSequenceFlagsFieldNumber = 13,
-    kIncrementalStateClearedFieldNumber = 41,
-    kTracePacketDefaultsFieldNumber = 59,
-    kPreviousPacketDroppedFieldNumber = 42,
-    kFirstPacketOnSequenceFieldNumber = 87,
+    kWatcherNotifyInterfaceTagFieldNumber = 1,
+    kIpcHashFieldNumber = 2,
+    kMojoInterfaceTagFieldNumber = 3,
+    kMojoInterfaceMethodIidFieldNumber = 4,
+    kIsReplyFieldNumber = 5,
+    kPayloadSizeFieldNumber = 6,
+    kDataNumBytesFieldNumber = 7,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.TracePacket"; }
-
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeMojoEventInfo"; }
 
-  using SequenceFlags = ::perfetto::protos::pbzero::TracePacket_SequenceFlags;
-  static inline const char* SequenceFlags_Name(SequenceFlags value) {
-    return ::perfetto::protos::pbzero::TracePacket_SequenceFlags_Name(value);
-  }
-  static const SequenceFlags SEQ_UNSPECIFIED = SequenceFlags::SEQ_UNSPECIFIED;
-  static const SequenceFlags SEQ_INCREMENTAL_STATE_CLEARED = SequenceFlags::SEQ_INCREMENTAL_STATE_CLEARED;
-  static const SequenceFlags SEQ_NEEDS_INCREMENTAL_STATE = SequenceFlags::SEQ_NEEDS_INCREMENTAL_STATE;
 
-  using FieldMetadata_Timestamp =
+  using FieldMetadata_WatcherNotifyInterfaceTag =
     ::protozero::proto_utils::FieldMetadata<
-      8,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeMojoEventInfo>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Timestamp kTimestamp() { return {}; }
-  void set_timestamp(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId;
+  static constexpr FieldMetadata_WatcherNotifyInterfaceTag kWatcherNotifyInterfaceTag{};
+  void set_watcher_notify_interface_tag(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_WatcherNotifyInterfaceTag::kFieldId, data, size);
+  }
+  void set_watcher_notify_interface_tag(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_WatcherNotifyInterfaceTag::kFieldId, chars.data, chars.size);
+  }
+  void set_watcher_notify_interface_tag(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_WatcherNotifyInterfaceTag::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimestampClockId =
+  using FieldMetadata_IpcHash =
     ::protozero::proto_utils::FieldMetadata<
-      58,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      TracePacket>;
+      ChromeMojoEventInfo>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimestampClockId kTimestampClockId() { return {}; }
-  void set_timestamp_clock_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimestampClockId::kFieldId;
+  static constexpr FieldMetadata_IpcHash kIpcHash{};
+  void set_ipc_hash(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IpcHash::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -159202,1521 +178628,1269 @@ class TracePacket : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ProcessTree =
-    ::protozero::proto_utils::FieldMetadata<
-      2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ProcessTree,
-      TracePacket>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessTree kProcessTree() { return {}; }
-  template <typename T = ProcessTree> T* set_process_tree() {
-    return BeginNestedMessage<T>(2);
-  }
-
-
-  using FieldMetadata_ProcessStats =
+  using FieldMetadata_MojoInterfaceTag =
     ::protozero::proto_utils::FieldMetadata<
-      9,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ProcessStats,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeMojoEventInfo>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessStats kProcessStats() { return {}; }
-  template <typename T = ProcessStats> T* set_process_stats() {
-    return BeginNestedMessage<T>(9);
+  static constexpr FieldMetadata_MojoInterfaceTag kMojoInterfaceTag{};
+  void set_mojo_interface_tag(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_MojoInterfaceTag::kFieldId, data, size);
+  }
+  void set_mojo_interface_tag(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_MojoInterfaceTag::kFieldId, chars.data, chars.size);
+  }
+  void set_mojo_interface_tag(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_MojoInterfaceTag::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_InodeFileMap =
+  using FieldMetadata_MojoInterfaceMethodIid =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      InodeFileMap,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ChromeMojoEventInfo>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InodeFileMap kInodeFileMap() { return {}; }
-  template <typename T = InodeFileMap> T* set_inode_file_map() {
-    return BeginNestedMessage<T>(4);
+  static constexpr FieldMetadata_MojoInterfaceMethodIid kMojoInterfaceMethodIid{};
+  void set_mojo_interface_method_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MojoInterfaceMethodIid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_ChromeEvents =
+  using FieldMetadata_IsReply =
     ::protozero::proto_utils::FieldMetadata<
       5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeEventBundle,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeMojoEventInfo>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeEvents kChromeEvents() { return {}; }
-  template <typename T = ChromeEventBundle> T* set_chrome_events() {
-    return BeginNestedMessage<T>(5);
+  static constexpr FieldMetadata_IsReply kIsReply{};
+  void set_is_reply(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsReply::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_ClockSnapshot =
+  using FieldMetadata_PayloadSize =
     ::protozero::proto_utils::FieldMetadata<
       6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ClockSnapshot,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ChromeMojoEventInfo>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ClockSnapshot kClockSnapshot() { return {}; }
-  template <typename T = ClockSnapshot> T* set_clock_snapshot() {
-    return BeginNestedMessage<T>(6);
+  static constexpr FieldMetadata_PayloadSize kPayloadSize{};
+  void set_payload_size(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PayloadSize::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_SysStats =
+  using FieldMetadata_DataNumBytes =
     ::protozero::proto_utils::FieldMetadata<
       7,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      SysStats,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ChromeMojoEventInfo>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SysStats kSysStats() { return {}; }
-  template <typename T = SysStats> T* set_sys_stats() {
-    return BeginNestedMessage<T>(7);
+  static constexpr FieldMetadata_DataNumBytes kDataNumBytes{};
+  void set_data_num_bytes(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DataNumBytes::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
+};
 
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_process_descriptor.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  using FieldMetadata_TrackEvent =
-    ::protozero::proto_utils::FieldMetadata<
-      11,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TrackEvent,
-      TracePacket>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrackEvent kTrackEvent() { return {}; }
-  template <typename T = TrackEvent> T* set_track_event() {
-    return BeginNestedMessage<T>(11);
-  }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_PROCESS_DESCRIPTOR_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_PROCESS_DESCRIPTOR_PROTO_H_
 
+#include <stddef.h>
+#include <stdint.h>
 
-  using FieldMetadata_TraceUuid =
-    ::protozero::proto_utils::FieldMetadata<
-      89,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceUuid,
-      TracePacket>;
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceUuid kTraceUuid() { return {}; }
-  template <typename T = TraceUuid> T* set_trace_uuid() {
-    return BeginNestedMessage<T>(89);
-  }
 
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-  using FieldMetadata_TraceConfig =
-    ::protozero::proto_utils::FieldMetadata<
-      33,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceConfig,
-      TracePacket>;
+class ChromeProcessDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  ChromeProcessDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeProcessDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeProcessDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_process_type() const { return at<1>().valid(); }
+  int32_t process_type() const { return at<1>().as_int32(); }
+  bool has_process_priority() const { return at<2>().valid(); }
+  int32_t process_priority() const { return at<2>().as_int32(); }
+  bool has_legacy_sort_index() const { return at<3>().valid(); }
+  int32_t legacy_sort_index() const { return at<3>().as_int32(); }
+  bool has_host_app_package_name() const { return at<4>().valid(); }
+  ::protozero::ConstChars host_app_package_name() const { return at<4>().as_string(); }
+  bool has_crash_trace_id() const { return at<5>().valid(); }
+  uint64_t crash_trace_id() const { return at<5>().as_uint64(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceConfig kTraceConfig() { return {}; }
-  template <typename T = TraceConfig> T* set_trace_config() {
-    return BeginNestedMessage<T>(33);
-  }
+class ChromeProcessDescriptor : public ::protozero::Message {
+ public:
+  using Decoder = ChromeProcessDescriptor_Decoder;
+  enum : int32_t {
+    kProcessTypeFieldNumber = 1,
+    kProcessPriorityFieldNumber = 2,
+    kLegacySortIndexFieldNumber = 3,
+    kHostAppPackageNameFieldNumber = 4,
+    kCrashTraceIdFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeProcessDescriptor"; }
 
 
-  using FieldMetadata_FtraceStats =
+  using FieldMetadata_ProcessType =
     ::protozero::proto_utils::FieldMetadata<
-      34,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      FtraceStats,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ChromeProcessDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FtraceStats kFtraceStats() { return {}; }
-  template <typename T = FtraceStats> T* set_ftrace_stats() {
-    return BeginNestedMessage<T>(34);
+  static constexpr FieldMetadata_ProcessType kProcessType{};
+  void set_process_type(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProcessType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_TraceStats =
+  using FieldMetadata_ProcessPriority =
     ::protozero::proto_utils::FieldMetadata<
-      35,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TraceStats,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ChromeProcessDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TraceStats kTraceStats() { return {}; }
-  template <typename T = TraceStats> T* set_trace_stats() {
-    return BeginNestedMessage<T>(35);
+  static constexpr FieldMetadata_ProcessPriority kProcessPriority{};
+  void set_process_priority(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProcessPriority::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_ProfilePacket =
+  using FieldMetadata_LegacySortIndex =
     ::protozero::proto_utils::FieldMetadata<
-      37,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ProfilePacket,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ChromeProcessDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProfilePacket kProfilePacket() { return {}; }
-  template <typename T = ProfilePacket> T* set_profile_packet() {
-    return BeginNestedMessage<T>(37);
+  static constexpr FieldMetadata_LegacySortIndex kLegacySortIndex{};
+  void set_legacy_sort_index(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LegacySortIndex::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_StreamingAllocation =
+  using FieldMetadata_HostAppPackageName =
     ::protozero::proto_utils::FieldMetadata<
-      74,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      StreamingAllocation,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeProcessDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StreamingAllocation kStreamingAllocation() { return {}; }
-  template <typename T = StreamingAllocation> T* set_streaming_allocation() {
-    return BeginNestedMessage<T>(74);
+  static constexpr FieldMetadata_HostAppPackageName kHostAppPackageName{};
+  void set_host_app_package_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_HostAppPackageName::kFieldId, data, size);
+  }
+  void set_host_app_package_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_HostAppPackageName::kFieldId, chars.data, chars.size);
+  }
+  void set_host_app_package_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_HostAppPackageName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_StreamingFree =
+  using FieldMetadata_CrashTraceId =
     ::protozero::proto_utils::FieldMetadata<
-      75,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      StreamingFree,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ChromeProcessDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StreamingFree kStreamingFree() { return {}; }
-  template <typename T = StreamingFree> T* set_streaming_free() {
-    return BeginNestedMessage<T>(75);
+  static constexpr FieldMetadata_CrashTraceId kCrashTraceId{};
+  void set_crash_trace_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CrashTraceId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
+};
 
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_renderer_scheduler_state.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  using FieldMetadata_Battery =
-    ::protozero::proto_utils::FieldMetadata<
-      38,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      BatteryCounters,
-      TracePacket>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Battery kBattery() { return {}; }
-  template <typename T = BatteryCounters> T* set_battery() {
-    return BeginNestedMessage<T>(38);
-  }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_RENDERER_SCHEDULER_STATE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_RENDERER_SCHEDULER_STATE_PROTO_H_
 
+#include <stddef.h>
+#include <stdint.h>
 
-  using FieldMetadata_PowerRails =
-    ::protozero::proto_utils::FieldMetadata<
-      40,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      PowerRails,
-      TracePacket>;
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PowerRails kPowerRails() { return {}; }
-  template <typename T = PowerRails> T* set_power_rails() {
-    return BeginNestedMessage<T>(40);
-  }
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+enum ChromeRAILMode : int32_t;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-  using FieldMetadata_AndroidLog =
-    ::protozero::proto_utils::FieldMetadata<
-      39,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AndroidLogPacket,
-      TracePacket>;
+enum ChromeRAILMode : int32_t {
+  RAIL_MODE_NONE = 0,
+  RAIL_MODE_RESPONSE = 1,
+  RAIL_MODE_ANIMATION = 2,
+  RAIL_MODE_IDLE = 3,
+  RAIL_MODE_LOAD = 4,
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidLog kAndroidLog() { return {}; }
-  template <typename T = AndroidLogPacket> T* set_android_log() {
-    return BeginNestedMessage<T>(39);
-  }
+constexpr ChromeRAILMode ChromeRAILMode_MIN = ChromeRAILMode::RAIL_MODE_NONE;
+constexpr ChromeRAILMode ChromeRAILMode_MAX = ChromeRAILMode::RAIL_MODE_LOAD;
 
 
-  using FieldMetadata_SystemInfo =
-    ::protozero::proto_utils::FieldMetadata<
-      45,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      SystemInfo,
-      TracePacket>;
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* ChromeRAILMode_Name(::perfetto::protos::pbzero::ChromeRAILMode value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::ChromeRAILMode::RAIL_MODE_NONE:
+    return "RAIL_MODE_NONE";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SystemInfo kSystemInfo() { return {}; }
-  template <typename T = SystemInfo> T* set_system_info() {
-    return BeginNestedMessage<T>(45);
-  }
+  case ::perfetto::protos::pbzero::ChromeRAILMode::RAIL_MODE_RESPONSE:
+    return "RAIL_MODE_RESPONSE";
 
+  case ::perfetto::protos::pbzero::ChromeRAILMode::RAIL_MODE_ANIMATION:
+    return "RAIL_MODE_ANIMATION";
 
-  using FieldMetadata_Trigger =
-    ::protozero::proto_utils::FieldMetadata<
-      46,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      Trigger,
-      TracePacket>;
+  case ::perfetto::protos::pbzero::ChromeRAILMode::RAIL_MODE_IDLE:
+    return "RAIL_MODE_IDLE";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Trigger kTrigger() { return {}; }
-  template <typename T = Trigger> T* set_trigger() {
-    return BeginNestedMessage<T>(46);
+  case ::perfetto::protos::pbzero::ChromeRAILMode::RAIL_MODE_LOAD:
+    return "RAIL_MODE_LOAD";
   }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
+class ChromeRendererSchedulerState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  ChromeRendererSchedulerState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeRendererSchedulerState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeRendererSchedulerState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_rail_mode() const { return at<1>().valid(); }
+  int32_t rail_mode() const { return at<1>().as_int32(); }
+  bool has_is_backgrounded() const { return at<2>().valid(); }
+  bool is_backgrounded() const { return at<2>().as_bool(); }
+  bool has_is_hidden() const { return at<3>().valid(); }
+  bool is_hidden() const { return at<3>().as_bool(); }
+};
 
-  using FieldMetadata_PackagesList =
-    ::protozero::proto_utils::FieldMetadata<
-      47,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      PackagesList,
-      TracePacket>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PackagesList kPackagesList() { return {}; }
-  template <typename T = PackagesList> T* set_packages_list() {
-    return BeginNestedMessage<T>(47);
-  }
+class ChromeRendererSchedulerState : public ::protozero::Message {
+ public:
+  using Decoder = ChromeRendererSchedulerState_Decoder;
+  enum : int32_t {
+    kRailModeFieldNumber = 1,
+    kIsBackgroundedFieldNumber = 2,
+    kIsHiddenFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeRendererSchedulerState"; }
 
 
-  using FieldMetadata_ChromeBenchmarkMetadata =
+  using FieldMetadata_RailMode =
     ::protozero::proto_utils::FieldMetadata<
-      48,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeBenchmarkMetadata,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ChromeRAILMode,
+      ChromeRendererSchedulerState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeBenchmarkMetadata kChromeBenchmarkMetadata() { return {}; }
-  template <typename T = ChromeBenchmarkMetadata> T* set_chrome_benchmark_metadata() {
-    return BeginNestedMessage<T>(48);
+  static constexpr FieldMetadata_RailMode kRailMode{};
+  void set_rail_mode(ChromeRAILMode value) {
+    static constexpr uint32_t field_id = FieldMetadata_RailMode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_PerfettoMetatrace =
+  using FieldMetadata_IsBackgrounded =
     ::protozero::proto_utils::FieldMetadata<
-      49,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      PerfettoMetatrace,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeRendererSchedulerState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PerfettoMetatrace kPerfettoMetatrace() { return {}; }
-  template <typename T = PerfettoMetatrace> T* set_perfetto_metatrace() {
-    return BeginNestedMessage<T>(49);
+  static constexpr FieldMetadata_IsBackgrounded kIsBackgrounded{};
+  void set_is_backgrounded(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsBackgrounded::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_ChromeMetadata =
+  using FieldMetadata_IsHidden =
     ::protozero::proto_utils::FieldMetadata<
-      51,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ChromeMetadataPacket,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeRendererSchedulerState>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ChromeMetadata kChromeMetadata() { return {}; }
-  template <typename T = ChromeMetadataPacket> T* set_chrome_metadata() {
-    return BeginNestedMessage<T>(51);
+  static constexpr FieldMetadata_IsHidden kIsHidden{};
+  void set_is_hidden(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsHidden::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
   }
+};
 
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_thread_descriptor.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  using FieldMetadata_GpuCounterEvent =
-    ::protozero::proto_utils::FieldMetadata<
-      52,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      GpuCounterEvent,
-      TracePacket>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GpuCounterEvent kGpuCounterEvent() { return {}; }
-  template <typename T = GpuCounterEvent> T* set_gpu_counter_event() {
-    return BeginNestedMessage<T>(52);
-  }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_THREAD_DESCRIPTOR_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_THREAD_DESCRIPTOR_PROTO_H_
 
+#include <stddef.h>
+#include <stdint.h>
 
-  using FieldMetadata_GpuRenderStageEvent =
-    ::protozero::proto_utils::FieldMetadata<
-      53,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      GpuRenderStageEvent,
-      TracePacket>;
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GpuRenderStageEvent kGpuRenderStageEvent() { return {}; }
-  template <typename T = GpuRenderStageEvent> T* set_gpu_render_stage_event() {
-    return BeginNestedMessage<T>(53);
-  }
 
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-  using FieldMetadata_StreamingProfilePacket =
-    ::protozero::proto_utils::FieldMetadata<
-      54,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      StreamingProfilePacket,
-      TracePacket>;
+class ChromeThreadDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  ChromeThreadDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeThreadDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeThreadDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_thread_type() const { return at<1>().valid(); }
+  int32_t thread_type() const { return at<1>().as_int32(); }
+  bool has_legacy_sort_index() const { return at<2>().valid(); }
+  int32_t legacy_sort_index() const { return at<2>().as_int32(); }
+  bool has_is_sandboxed_tid() const { return at<3>().valid(); }
+  bool is_sandboxed_tid() const { return at<3>().as_bool(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StreamingProfilePacket kStreamingProfilePacket() { return {}; }
-  template <typename T = StreamingProfilePacket> T* set_streaming_profile_packet() {
-    return BeginNestedMessage<T>(54);
-  }
+class ChromeThreadDescriptor : public ::protozero::Message {
+ public:
+  using Decoder = ChromeThreadDescriptor_Decoder;
+  enum : int32_t {
+    kThreadTypeFieldNumber = 1,
+    kLegacySortIndexFieldNumber = 2,
+    kIsSandboxedTidFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeThreadDescriptor"; }
 
 
-  using FieldMetadata_HeapGraph =
+  using FieldMetadata_ThreadType =
     ::protozero::proto_utils::FieldMetadata<
-      56,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      HeapGraph,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ChromeThreadDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HeapGraph kHeapGraph() { return {}; }
-  template <typename T = HeapGraph> T* set_heap_graph() {
-    return BeginNestedMessage<T>(56);
+  static constexpr FieldMetadata_ThreadType kThreadType{};
+  void set_thread_type(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ThreadType::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_GraphicsFrameEvent =
+  using FieldMetadata_LegacySortIndex =
     ::protozero::proto_utils::FieldMetadata<
-      57,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      GraphicsFrameEvent,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ChromeThreadDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GraphicsFrameEvent kGraphicsFrameEvent() { return {}; }
-  template <typename T = GraphicsFrameEvent> T* set_graphics_frame_event() {
-    return BeginNestedMessage<T>(57);
+  static constexpr FieldMetadata_LegacySortIndex kLegacySortIndex{};
+  void set_legacy_sort_index(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LegacySortIndex::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_VulkanMemoryEvent =
+  using FieldMetadata_IsSandboxedTid =
     ::protozero::proto_utils::FieldMetadata<
-      62,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      VulkanMemoryEvent,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeThreadDescriptor>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VulkanMemoryEvent kVulkanMemoryEvent() { return {}; }
-  template <typename T = VulkanMemoryEvent> T* set_vulkan_memory_event() {
-    return BeginNestedMessage<T>(62);
+  static constexpr FieldMetadata_IsSandboxedTid kIsSandboxedTid{};
+  void set_is_sandboxed_tid(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsSandboxedTid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
   }
+};
 
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_user_event.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  using FieldMetadata_GpuLog =
-    ::protozero::proto_utils::FieldMetadata<
-      63,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      GpuLog,
-      TracePacket>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GpuLog kGpuLog() { return {}; }
-  template <typename T = GpuLog> T* set_gpu_log() {
-    return BeginNestedMessage<T>(63);
-  }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_USER_EVENT_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_USER_EVENT_PROTO_H_
 
+#include <stddef.h>
+#include <stdint.h>
 
-  using FieldMetadata_VulkanApiEvent =
-    ::protozero::proto_utils::FieldMetadata<
-      65,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      VulkanApiEvent,
-      TracePacket>;
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_VulkanApiEvent kVulkanApiEvent() { return {}; }
-  template <typename T = VulkanApiEvent> T* set_vulkan_api_event() {
-    return BeginNestedMessage<T>(65);
-  }
 
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-  using FieldMetadata_PerfSample =
-    ::protozero::proto_utils::FieldMetadata<
-      66,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      PerfSample,
-      TracePacket>;
+class ChromeUserEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  ChromeUserEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeUserEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeUserEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_action() const { return at<1>().valid(); }
+  ::protozero::ConstChars action() const { return at<1>().as_string(); }
+  bool has_action_hash() const { return at<2>().valid(); }
+  uint64_t action_hash() const { return at<2>().as_uint64(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PerfSample kPerfSample() { return {}; }
-  template <typename T = PerfSample> T* set_perf_sample() {
-    return BeginNestedMessage<T>(66);
-  }
+class ChromeUserEvent : public ::protozero::Message {
+ public:
+  using Decoder = ChromeUserEvent_Decoder;
+  enum : int32_t {
+    kActionFieldNumber = 1,
+    kActionHashFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeUserEvent"; }
 
 
-  using FieldMetadata_CpuInfo =
+  using FieldMetadata_Action =
     ::protozero::proto_utils::FieldMetadata<
-      67,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      CpuInfo,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeUserEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CpuInfo kCpuInfo() { return {}; }
-  template <typename T = CpuInfo> T* set_cpu_info() {
-    return BeginNestedMessage<T>(67);
+  static constexpr FieldMetadata_Action kAction{};
+  void set_action(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Action::kFieldId, data, size);
+  }
+  void set_action(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Action::kFieldId, chars.data, chars.size);
+  }
+  void set_action(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Action::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_SmapsPacket =
+  using FieldMetadata_ActionHash =
     ::protozero::proto_utils::FieldMetadata<
-      68,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      SmapsPacket,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ChromeUserEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SmapsPacket kSmapsPacket() { return {}; }
-  template <typename T = SmapsPacket> T* set_smaps_packet() {
-    return BeginNestedMessage<T>(68);
+  static constexpr FieldMetadata_ActionHash kActionHash{};
+  void set_action_hash(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ActionHash::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
+};
 
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_window_handle_event_info.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  using FieldMetadata_ServiceEvent =
-    ::protozero::proto_utils::FieldMetadata<
-      69,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TracingServiceEvent,
-      TracePacket>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ServiceEvent kServiceEvent() { return {}; }
-  template <typename T = TracingServiceEvent> T* set_service_event() {
-    return BeginNestedMessage<T>(69);
-  }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_WINDOW_HANDLE_EVENT_INFO_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_WINDOW_HANDLE_EVENT_INFO_PROTO_H_
 
+#include <stddef.h>
+#include <stdint.h>
 
-  using FieldMetadata_InitialDisplayState =
-    ::protozero::proto_utils::FieldMetadata<
-      70,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      InitialDisplayState,
-      TracePacket>;
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InitialDisplayState kInitialDisplayState() { return {}; }
-  template <typename T = InitialDisplayState> T* set_initial_display_state() {
-    return BeginNestedMessage<T>(70);
-  }
 
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-  using FieldMetadata_GpuMemTotalEvent =
-    ::protozero::proto_utils::FieldMetadata<
-      71,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      GpuMemTotalEvent,
-      TracePacket>;
+class ChromeWindowHandleEventInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  ChromeWindowHandleEventInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeWindowHandleEventInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeWindowHandleEventInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_dpi() const { return at<1>().valid(); }
+  uint32_t dpi() const { return at<1>().as_uint32(); }
+  bool has_message_id() const { return at<2>().valid(); }
+  uint32_t message_id() const { return at<2>().as_uint32(); }
+  bool has_hwnd_ptr() const { return at<3>().valid(); }
+  uint64_t hwnd_ptr() const { return at<3>().as_uint64(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GpuMemTotalEvent kGpuMemTotalEvent() { return {}; }
-  template <typename T = GpuMemTotalEvent> T* set_gpu_mem_total_event() {
-    return BeginNestedMessage<T>(71);
-  }
+class ChromeWindowHandleEventInfo : public ::protozero::Message {
+ public:
+  using Decoder = ChromeWindowHandleEventInfo_Decoder;
+  enum : int32_t {
+    kDpiFieldNumber = 1,
+    kMessageIdFieldNumber = 2,
+    kHwndPtrFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeWindowHandleEventInfo"; }
 
 
-  using FieldMetadata_MemoryTrackerSnapshot =
+  using FieldMetadata_Dpi =
     ::protozero::proto_utils::FieldMetadata<
-      73,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      MemoryTrackerSnapshot,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ChromeWindowHandleEventInfo>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MemoryTrackerSnapshot kMemoryTrackerSnapshot() { return {}; }
-  template <typename T = MemoryTrackerSnapshot> T* set_memory_tracker_snapshot() {
-    return BeginNestedMessage<T>(73);
+  static constexpr FieldMetadata_Dpi kDpi{};
+  void set_dpi(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Dpi::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_FrameTimelineEvent =
+  using FieldMetadata_MessageId =
     ::protozero::proto_utils::FieldMetadata<
-      76,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      FrameTimelineEvent,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ChromeWindowHandleEventInfo>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FrameTimelineEvent kFrameTimelineEvent() { return {}; }
-  template <typename T = FrameTimelineEvent> T* set_frame_timeline_event() {
-    return BeginNestedMessage<T>(76);
+  static constexpr FieldMetadata_MessageId kMessageId{};
+  void set_message_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MessageId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_AndroidEnergyEstimationBreakdown =
+  using FieldMetadata_HwndPtr =
     ::protozero::proto_utils::FieldMetadata<
-      77,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AndroidEnergyEstimationBreakdown,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64,
+      uint64_t,
+      ChromeWindowHandleEventInfo>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidEnergyEstimationBreakdown kAndroidEnergyEstimationBreakdown() { return {}; }
-  template <typename T = AndroidEnergyEstimationBreakdown> T* set_android_energy_estimation_breakdown() {
-    return BeginNestedMessage<T>(77);
+  static constexpr FieldMetadata_HwndPtr kHwndPtr{};
+  void set_hwnd_ptr(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_HwndPtr::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFixed64>
+        ::Append(*this, field_id, value);
   }
+};
 
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/log_message.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  using FieldMetadata_UiState =
-    ::protozero::proto_utils::FieldMetadata<
-      78,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      UiState,
-      TracePacket>;
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_LOG_MESSAGE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_LOG_MESSAGE_PROTO_H_
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_UiState kUiState() { return {}; }
-  template <typename T = UiState> T* set_ui_state() {
-    return BeginNestedMessage<T>(78);
-  }
+#include <stddef.h>
+#include <stdint.h>
 
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  using FieldMetadata_AndroidCameraFrameEvent =
-    ::protozero::proto_utils::FieldMetadata<
-      80,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AndroidCameraFrameEvent,
-      TracePacket>;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+namespace perfetto_pbzero_enum_LogMessage {
+enum Priority : int32_t;
+}  // namespace perfetto_pbzero_enum_LogMessage
+using LogMessage_Priority = perfetto_pbzero_enum_LogMessage::Priority;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidCameraFrameEvent kAndroidCameraFrameEvent() { return {}; }
-  template <typename T = AndroidCameraFrameEvent> T* set_android_camera_frame_event() {
-    return BeginNestedMessage<T>(80);
-  }
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
+namespace perfetto_pbzero_enum_LogMessage {
+enum Priority : int32_t {
+  PRIO_UNSPECIFIED = 0,
+  PRIO_UNUSED = 1,
+  PRIO_VERBOSE = 2,
+  PRIO_DEBUG = 3,
+  PRIO_INFO = 4,
+  PRIO_WARN = 5,
+  PRIO_ERROR = 6,
+  PRIO_FATAL = 7,
+};
+} // namespace perfetto_pbzero_enum_LogMessage
+using LogMessage_Priority = perfetto_pbzero_enum_LogMessage::Priority;
 
-  using FieldMetadata_AndroidCameraSessionStats =
-    ::protozero::proto_utils::FieldMetadata<
-      81,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AndroidCameraSessionStats,
-      TracePacket>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidCameraSessionStats kAndroidCameraSessionStats() { return {}; }
-  template <typename T = AndroidCameraSessionStats> T* set_android_camera_session_stats() {
-    return BeginNestedMessage<T>(81);
-  }
+constexpr LogMessage_Priority LogMessage_Priority_MIN = LogMessage_Priority::PRIO_UNSPECIFIED;
+constexpr LogMessage_Priority LogMessage_Priority_MAX = LogMessage_Priority::PRIO_FATAL;
 
 
-  using FieldMetadata_TranslationTable =
-    ::protozero::proto_utils::FieldMetadata<
-      82,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TranslationTable,
-      TracePacket>;
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* LogMessage_Priority_Name(::perfetto::protos::pbzero::LogMessage_Priority value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::LogMessage_Priority::PRIO_UNSPECIFIED:
+    return "PRIO_UNSPECIFIED";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TranslationTable kTranslationTable() { return {}; }
-  template <typename T = TranslationTable> T* set_translation_table() {
-    return BeginNestedMessage<T>(82);
-  }
+  case ::perfetto::protos::pbzero::LogMessage_Priority::PRIO_UNUSED:
+    return "PRIO_UNUSED";
 
+  case ::perfetto::protos::pbzero::LogMessage_Priority::PRIO_VERBOSE:
+    return "PRIO_VERBOSE";
 
-  using FieldMetadata_AndroidGameInterventionList =
-    ::protozero::proto_utils::FieldMetadata<
-      83,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AndroidGameInterventionList,
-      TracePacket>;
+  case ::perfetto::protos::pbzero::LogMessage_Priority::PRIO_DEBUG:
+    return "PRIO_DEBUG";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidGameInterventionList kAndroidGameInterventionList() { return {}; }
-  template <typename T = AndroidGameInterventionList> T* set_android_game_intervention_list() {
-    return BeginNestedMessage<T>(83);
-  }
+  case ::perfetto::protos::pbzero::LogMessage_Priority::PRIO_INFO:
+    return "PRIO_INFO";
 
+  case ::perfetto::protos::pbzero::LogMessage_Priority::PRIO_WARN:
+    return "PRIO_WARN";
 
-  using FieldMetadata_StatsdAtom =
-    ::protozero::proto_utils::FieldMetadata<
-      84,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      StatsdAtom,
-      TracePacket>;
+  case ::perfetto::protos::pbzero::LogMessage_Priority::PRIO_ERROR:
+    return "PRIO_ERROR";
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_StatsdAtom kStatsdAtom() { return {}; }
-  template <typename T = StatsdAtom> T* set_statsd_atom() {
-    return BeginNestedMessage<T>(84);
+  case ::perfetto::protos::pbzero::LogMessage_Priority::PRIO_FATAL:
+    return "PRIO_FATAL";
   }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
+class LogMessageBody_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  LogMessageBody_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit LogMessageBody_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit LogMessageBody_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_iid() const { return at<1>().valid(); }
+  uint64_t iid() const { return at<1>().as_uint64(); }
+  bool has_body() const { return at<2>().valid(); }
+  ::protozero::ConstChars body() const { return at<2>().as_string(); }
+};
 
-  using FieldMetadata_AndroidSystemProperty =
-    ::protozero::proto_utils::FieldMetadata<
-      86,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      AndroidSystemProperty,
-      TracePacket>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AndroidSystemProperty kAndroidSystemProperty() { return {}; }
-  template <typename T = AndroidSystemProperty> T* set_android_system_property() {
-    return BeginNestedMessage<T>(86);
-  }
+class LogMessageBody : public ::protozero::Message {
+ public:
+  using Decoder = LogMessageBody_Decoder;
+  enum : int32_t {
+    kIidFieldNumber = 1,
+    kBodyFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.LogMessageBody"; }
 
 
-  using FieldMetadata_EntityStateResidency =
+  using FieldMetadata_Iid =
     ::protozero::proto_utils::FieldMetadata<
-      91,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      EntityStateResidency,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      LogMessageBody>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_EntityStateResidency kEntityStateResidency() { return {}; }
-  template <typename T = EntityStateResidency> T* set_entity_state_residency() {
-    return BeginNestedMessage<T>(91);
+  static constexpr FieldMetadata_Iid kIid{};
+  void set_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_ProfiledFrameSymbols =
+  using FieldMetadata_Body =
     ::protozero::proto_utils::FieldMetadata<
-      55,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ProfiledFrameSymbols,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      LogMessageBody>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProfiledFrameSymbols kProfiledFrameSymbols() { return {}; }
-  template <typename T = ProfiledFrameSymbols> T* set_profiled_frame_symbols() {
-    return BeginNestedMessage<T>(55);
+  static constexpr FieldMetadata_Body kBody{};
+  void set_body(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Body::kFieldId, data, size);
+  }
+  void set_body(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Body::kFieldId, chars.data, chars.size);
+  }
+  void set_body(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Body::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
   }
+};
 
+class LogMessage_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  LogMessage_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit LogMessage_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit LogMessage_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_source_location_iid() const { return at<1>().valid(); }
+  uint64_t source_location_iid() const { return at<1>().as_uint64(); }
+  bool has_body_iid() const { return at<2>().valid(); }
+  uint64_t body_iid() const { return at<2>().as_uint64(); }
+  bool has_prio() const { return at<3>().valid(); }
+  int32_t prio() const { return at<3>().as_int32(); }
+};
 
-  using FieldMetadata_ModuleSymbols =
-    ::protozero::proto_utils::FieldMetadata<
-      61,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ModuleSymbols,
-      TracePacket>;
+class LogMessage : public ::protozero::Message {
+ public:
+  using Decoder = LogMessage_Decoder;
+  enum : int32_t {
+    kSourceLocationIidFieldNumber = 1,
+    kBodyIidFieldNumber = 2,
+    kPrioFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.LogMessage"; }
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ModuleSymbols kModuleSymbols() { return {}; }
-  template <typename T = ModuleSymbols> T* set_module_symbols() {
-    return BeginNestedMessage<T>(61);
-  }
 
+  using Priority = ::perfetto::protos::pbzero::LogMessage_Priority;
+  static inline const char* Priority_Name(Priority value) {
+    return ::perfetto::protos::pbzero::LogMessage_Priority_Name(value);
+  }
+  static inline const Priority PRIO_UNSPECIFIED = Priority::PRIO_UNSPECIFIED;
+  static inline const Priority PRIO_UNUSED = Priority::PRIO_UNUSED;
+  static inline const Priority PRIO_VERBOSE = Priority::PRIO_VERBOSE;
+  static inline const Priority PRIO_DEBUG = Priority::PRIO_DEBUG;
+  static inline const Priority PRIO_INFO = Priority::PRIO_INFO;
+  static inline const Priority PRIO_WARN = Priority::PRIO_WARN;
+  static inline const Priority PRIO_ERROR = Priority::PRIO_ERROR;
+  static inline const Priority PRIO_FATAL = Priority::PRIO_FATAL;
 
-  using FieldMetadata_DeobfuscationMapping =
+  using FieldMetadata_SourceLocationIid =
     ::protozero::proto_utils::FieldMetadata<
-      64,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      DeobfuscationMapping,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      LogMessage>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_DeobfuscationMapping kDeobfuscationMapping() { return {}; }
-  template <typename T = DeobfuscationMapping> T* set_deobfuscation_mapping() {
-    return BeginNestedMessage<T>(64);
+  static constexpr FieldMetadata_SourceLocationIid kSourceLocationIid{};
+  void set_source_location_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SourceLocationIid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_TrackDescriptor =
+  using FieldMetadata_BodyIid =
     ::protozero::proto_utils::FieldMetadata<
-      60,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TrackDescriptor,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      LogMessage>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrackDescriptor kTrackDescriptor() { return {}; }
-  template <typename T = TrackDescriptor> T* set_track_descriptor() {
-    return BeginNestedMessage<T>(60);
+  static constexpr FieldMetadata_BodyIid kBodyIid{};
+  void set_body_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BodyIid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
 
-
-  using FieldMetadata_ProcessDescriptor =
+  using FieldMetadata_Prio =
     ::protozero::proto_utils::FieldMetadata<
-      43,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ProcessDescriptor,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      LogMessage_Priority,
+      LogMessage>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessDescriptor kProcessDescriptor() { return {}; }
-  template <typename T = ProcessDescriptor> T* set_process_descriptor() {
-    return BeginNestedMessage<T>(43);
+  static constexpr FieldMetadata_Prio kPrio{};
+  void set_prio(LogMessage_Priority value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
   }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/range_of_interest.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_RANGE_OF_INTEREST_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_RANGE_OF_INTEREST_PROTO_H_
 
-  using FieldMetadata_ThreadDescriptor =
-    ::protozero::proto_utils::FieldMetadata<
-      44,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ThreadDescriptor,
-      TracePacket>;
+#include <stddef.h>
+#include <stdint.h>
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ThreadDescriptor kThreadDescriptor() { return {}; }
-  template <typename T = ThreadDescriptor> T* set_thread_descriptor() {
-    return BeginNestedMessage<T>(44);
-  }
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
 
-  using FieldMetadata_FtraceEvents =
-    ::protozero::proto_utils::FieldMetadata<
-      1,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      FtraceEventBundle,
-      TracePacket>;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FtraceEvents kFtraceEvents() { return {}; }
-  template <typename T = FtraceEventBundle> T* set_ftrace_events() {
-    return BeginNestedMessage<T>(1);
-  }
+class TrackEventRangeOfInterest_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  TrackEventRangeOfInterest_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TrackEventRangeOfInterest_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TrackEventRangeOfInterest_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_start_us() const { return at<1>().valid(); }
+  int64_t start_us() const { return at<1>().as_int64(); }
+};
+
+class TrackEventRangeOfInterest : public ::protozero::Message {
+ public:
+  using Decoder = TrackEventRangeOfInterest_Decoder;
+  enum : int32_t {
+    kStartUsFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TrackEventRangeOfInterest"; }
 
 
-  using FieldMetadata_SynchronizationMarker =
+  using FieldMetadata_StartUs =
     ::protozero::proto_utils::FieldMetadata<
-      36,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBytes,
-      std::string,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      TrackEventRangeOfInterest>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SynchronizationMarker kSynchronizationMarker() { return {}; }
-  void set_synchronization_marker(const uint8_t* data, size_t size) {
-    AppendBytes(FieldMetadata_SynchronizationMarker::kFieldId, data, size);
-  }
-  void set_synchronization_marker(::protozero::ConstBytes bytes) {
-    AppendBytes(FieldMetadata_SynchronizationMarker::kFieldId, bytes.data, bytes.size);
-  }
-  void set_synchronization_marker(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_SynchronizationMarker::kFieldId;
+  static constexpr FieldMetadata_StartUs kStartUs{};
+  void set_start_us(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StartUs::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_CompressedPackets =
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/screenshot.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_SCREENSHOT_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_SCREENSHOT_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class Screenshot_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  Screenshot_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Screenshot_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Screenshot_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_jpg_image() const { return at<1>().valid(); }
+  ::protozero::ConstBytes jpg_image() const { return at<1>().as_bytes(); }
+};
+
+class Screenshot : public ::protozero::Message {
+ public:
+  using Decoder = Screenshot_Decoder;
+  enum : int32_t {
+    kJpgImageFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Screenshot"; }
+
+
+  using FieldMetadata_JpgImage =
     ::protozero::proto_utils::FieldMetadata<
-      50,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kBytes,
       std::string,
-      TracePacket>;
+      Screenshot>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_CompressedPackets kCompressedPackets() { return {}; }
-  void set_compressed_packets(const uint8_t* data, size_t size) {
-    AppendBytes(FieldMetadata_CompressedPackets::kFieldId, data, size);
+  static constexpr FieldMetadata_JpgImage kJpgImage{};
+  void set_jpg_image(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_JpgImage::kFieldId, data, size);
   }
-  void set_compressed_packets(::protozero::ConstBytes bytes) {
-    AppendBytes(FieldMetadata_CompressedPackets::kFieldId, bytes.data, bytes.size);
+  void set_jpg_image(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_JpgImage::kFieldId, bytes.data, bytes.size);
   }
-  void set_compressed_packets(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_CompressedPackets::kFieldId;
+  void set_jpg_image(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_JpgImage::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kBytes>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_ExtensionDescriptor =
-    ::protozero::proto_utils::FieldMetadata<
-      72,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      ExtensionDescriptor,
-      TracePacket>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExtensionDescriptor kExtensionDescriptor() { return {}; }
-  template <typename T = ExtensionDescriptor> T* set_extension_descriptor() {
-    return BeginNestedMessage<T>(72);
-  }
-
-
-  using FieldMetadata_NetworkPacket =
-    ::protozero::proto_utils::FieldMetadata<
-      88,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      NetworkPacketEvent,
-      TracePacket>;
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/source_location.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_NetworkPacket kNetworkPacket() { return {}; }
-  template <typename T = NetworkPacketEvent> T* set_network_packet() {
-    return BeginNestedMessage<T>(88);
-  }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_SOURCE_LOCATION_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_SOURCE_LOCATION_PROTO_H_
 
+#include <stddef.h>
+#include <stdint.h>
 
-  using FieldMetadata_TrackEventRangeOfInterest =
-    ::protozero::proto_utils::FieldMetadata<
-      90,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TrackEventRangeOfInterest,
-      TracePacket>;
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrackEventRangeOfInterest kTrackEventRangeOfInterest() { return {}; }
-  template <typename T = TrackEventRangeOfInterest> T* set_track_event_range_of_interest() {
-    return BeginNestedMessage<T>(90);
-  }
 
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-  using FieldMetadata_ForTesting =
-    ::protozero::proto_utils::FieldMetadata<
-      900,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TestEvent,
-      TracePacket>;
+class SourceLocation_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  SourceLocation_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SourceLocation_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SourceLocation_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_iid() const { return at<1>().valid(); }
+  uint64_t iid() const { return at<1>().as_uint64(); }
+  bool has_file_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars file_name() const { return at<2>().as_string(); }
+  bool has_function_name() const { return at<3>().valid(); }
+  ::protozero::ConstChars function_name() const { return at<3>().as_string(); }
+  bool has_line_number() const { return at<4>().valid(); }
+  uint32_t line_number() const { return at<4>().as_uint32(); }
+};
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ForTesting kForTesting() { return {}; }
-  template <typename T = TestEvent> T* set_for_testing() {
-    return BeginNestedMessage<T>(900);
-  }
+class SourceLocation : public ::protozero::Message {
+ public:
+  using Decoder = SourceLocation_Decoder;
+  enum : int32_t {
+    kIidFieldNumber = 1,
+    kFileNameFieldNumber = 2,
+    kFunctionNameFieldNumber = 3,
+    kLineNumberFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SourceLocation"; }
 
 
-  using FieldMetadata_TrustedUid =
+  using FieldMetadata_Iid =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SourceLocation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustedUid kTrustedUid() { return {}; }
-  void set_trusted_uid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TrustedUid::kFieldId;
+  static constexpr FieldMetadata_Iid kIid{};
+  void set_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TrustedPacketSequenceId =
+  using FieldMetadata_FileName =
     ::protozero::proto_utils::FieldMetadata<
-      10,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SourceLocation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustedPacketSequenceId kTrustedPacketSequenceId() { return {}; }
-  void set_trusted_packet_sequence_id(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TrustedPacketSequenceId::kFieldId;
+  static constexpr FieldMetadata_FileName kFileName{};
+  void set_file_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_FileName::kFieldId, data, size);
+  }
+  void set_file_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_FileName::kFieldId, chars.data, chars.size);
+  }
+  void set_file_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_FileName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TrustedPid =
+  using FieldMetadata_FunctionName =
     ::protozero::proto_utils::FieldMetadata<
-      79,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SourceLocation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TrustedPid kTrustedPid() { return {}; }
-  void set_trusted_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TrustedPid::kFieldId;
+  static constexpr FieldMetadata_FunctionName kFunctionName{};
+  void set_function_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_FunctionName::kFieldId, data, size);
+  }
+  void set_function_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_FunctionName::kFieldId, chars.data, chars.size);
+  }
+  void set_function_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_FunctionName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_InternedData =
-    ::protozero::proto_utils::FieldMetadata<
-      12,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      InternedData,
-      TracePacket>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_InternedData kInternedData() { return {}; }
-  template <typename T = InternedData> T* set_interned_data() {
-    return BeginNestedMessage<T>(12);
-  }
-
-
-  using FieldMetadata_SequenceFlags =
+  using FieldMetadata_LineNumber =
     ::protozero::proto_utils::FieldMetadata<
-      13,
+      4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint32,
       uint32_t,
-      TracePacket>;
+      SourceLocation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SequenceFlags kSequenceFlags() { return {}; }
-  void set_sequence_flags(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SequenceFlags::kFieldId;
+  static constexpr FieldMetadata_LineNumber kLineNumber{};
+  void set_line_number(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LineNumber::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_IncrementalStateCleared =
+class UnsymbolizedSourceLocation_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  UnsymbolizedSourceLocation_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit UnsymbolizedSourceLocation_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit UnsymbolizedSourceLocation_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_iid() const { return at<1>().valid(); }
+  uint64_t iid() const { return at<1>().as_uint64(); }
+  bool has_mapping_id() const { return at<2>().valid(); }
+  uint64_t mapping_id() const { return at<2>().as_uint64(); }
+  bool has_rel_pc() const { return at<3>().valid(); }
+  uint64_t rel_pc() const { return at<3>().as_uint64(); }
+};
+
+class UnsymbolizedSourceLocation : public ::protozero::Message {
+ public:
+  using Decoder = UnsymbolizedSourceLocation_Decoder;
+  enum : int32_t {
+    kIidFieldNumber = 1,
+    kMappingIdFieldNumber = 2,
+    kRelPcFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.UnsymbolizedSourceLocation"; }
+
+
+  using FieldMetadata_Iid =
     ::protozero::proto_utils::FieldMetadata<
-      41,
+      1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      UnsymbolizedSourceLocation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_IncrementalStateCleared kIncrementalStateCleared() { return {}; }
-  void set_incremental_state_cleared(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_IncrementalStateCleared::kFieldId;
+  static constexpr FieldMetadata_Iid kIid{};
+  void set_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TracePacketDefaults =
-    ::protozero::proto_utils::FieldMetadata<
-      59,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TracePacketDefaults,
-      TracePacket>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TracePacketDefaults kTracePacketDefaults() { return {}; }
-  template <typename T = TracePacketDefaults> T* set_trace_packet_defaults() {
-    return BeginNestedMessage<T>(59);
-  }
-
-
-  using FieldMetadata_PreviousPacketDropped =
+  using FieldMetadata_MappingId =
     ::protozero::proto_utils::FieldMetadata<
-      42,
+      2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      UnsymbolizedSourceLocation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_PreviousPacketDropped kPreviousPacketDropped() { return {}; }
-  void set_previous_packet_dropped(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_PreviousPacketDropped::kFieldId;
+  static constexpr FieldMetadata_MappingId kMappingId{};
+  void set_mapping_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_MappingId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_FirstPacketOnSequence =
+  using FieldMetadata_RelPc =
     ::protozero::proto_utils::FieldMetadata<
-      87,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kBool,
-      bool,
-      TracePacket>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      UnsymbolizedSourceLocation>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_FirstPacketOnSequence kFirstPacketOnSequence() { return {}; }
-  void set_first_packet_on_sequence(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_FirstPacketOnSequence::kFieldId;
+  static constexpr FieldMetadata_RelPc kRelPc{};
+  void set_rel_pc(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RelPc::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kBool>
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
         ::Append(*this, field_id, value);
   }
 };
@@ -160725,11 +179899,11 @@ class TracePacket : public ::protozero::Message {
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/trace.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/task_execution.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACE_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACE_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TASK_EXECUTION_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TASK_EXECUTION_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -160740,61 +179914,57 @@ class TracePacket : public ::protozero::Message {
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
 // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
+
 namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-class TracePacket;
-
-class Trace_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class TaskExecution_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  Trace_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit Trace_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit Trace_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_packet() const { return at<1>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> packet() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  TaskExecution_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TaskExecution_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TaskExecution_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_posted_from_iid() const { return at<1>().valid(); }
+  uint64_t posted_from_iid() const { return at<1>().as_uint64(); }
 };
 
-class Trace : public ::protozero::Message {
+class TaskExecution : public ::protozero::Message {
  public:
-  using Decoder = Trace_Decoder;
+  using Decoder = TaskExecution_Decoder;
   enum : int32_t {
-    kPacketFieldNumber = 1,
+    kPostedFromIidFieldNumber = 1,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.Trace"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.TaskExecution"; }
 
 
-  using FieldMetadata_Packet =
+  using FieldMetadata_PostedFromIid =
     ::protozero::proto_utils::FieldMetadata<
       1,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      TracePacket,
-      Trace>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TaskExecution>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Packet kPacket() { return {}; }
-  template <typename T = TracePacket> T* add_packet() {
-    return BeginNestedMessage<T>(1);
+  static constexpr FieldMetadata_PostedFromIid kPostedFromIid{};
+  void set_posted_from_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_PostedFromIid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
-
 };
 
 } // Namespace.
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/extension_descriptor.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/perfetto/perfetto_metatrace.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_EXTENSION_DESCRIPTOR_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_EXTENSION_DESCRIPTOR_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PERFETTO_PERFETTO_METATRACE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PERFETTO_PERFETTO_METATRACE_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -160808,194 +179978,395 @@ class Trace : public ::protozero::Message {
 namespace perfetto {
 namespace protos {
 namespace pbzero {
+class PerfettoMetatrace_Arg;
+class PerfettoMetatrace_InternedString;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-class FileDescriptorSet;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-class ExtensionDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class PerfettoMetatrace_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11> {
  public:
-  ExtensionDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit ExtensionDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit ExtensionDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_extension_set() const { return at<1>().valid(); }
-  ::protozero::ConstBytes extension_set() const { return at<1>().as_bytes(); }
+  PerfettoMetatrace_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PerfettoMetatrace_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PerfettoMetatrace_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_event_id() const { return at<1>().valid(); }
+  uint32_t event_id() const { return at<1>().as_uint32(); }
+  bool has_counter_id() const { return at<2>().valid(); }
+  uint32_t counter_id() const { return at<2>().as_uint32(); }
+  bool has_event_name() const { return at<8>().valid(); }
+  ::protozero::ConstChars event_name() const { return at<8>().as_string(); }
+  bool has_event_name_iid() const { return at<11>().valid(); }
+  uint64_t event_name_iid() const { return at<11>().as_uint64(); }
+  bool has_counter_name() const { return at<9>().valid(); }
+  ::protozero::ConstChars counter_name() const { return at<9>().as_string(); }
+  bool has_event_duration_ns() const { return at<3>().valid(); }
+  uint64_t event_duration_ns() const { return at<3>().as_uint64(); }
+  bool has_counter_value() const { return at<4>().valid(); }
+  int32_t counter_value() const { return at<4>().as_int32(); }
+  bool has_thread_id() const { return at<5>().valid(); }
+  uint32_t thread_id() const { return at<5>().as_uint32(); }
+  bool has_has_overruns() const { return at<6>().valid(); }
+  bool has_overruns() const { return at<6>().as_bool(); }
+  bool has_args() const { return at<7>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> args() const { return GetRepeated<::protozero::ConstBytes>(7); }
+  bool has_interned_strings() const { return at<10>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> interned_strings() const { return GetRepeated<::protozero::ConstBytes>(10); }
 };
 
-class ExtensionDescriptor : public ::protozero::Message {
+class PerfettoMetatrace : public ::protozero::Message {
  public:
-  using Decoder = ExtensionDescriptor_Decoder;
+  using Decoder = PerfettoMetatrace_Decoder;
   enum : int32_t {
-    kExtensionSetFieldNumber = 1,
+    kEventIdFieldNumber = 1,
+    kCounterIdFieldNumber = 2,
+    kEventNameFieldNumber = 8,
+    kEventNameIidFieldNumber = 11,
+    kCounterNameFieldNumber = 9,
+    kEventDurationNsFieldNumber = 3,
+    kCounterValueFieldNumber = 4,
+    kThreadIdFieldNumber = 5,
+    kHasOverrunsFieldNumber = 6,
+    kArgsFieldNumber = 7,
+    kInternedStringsFieldNumber = 10,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.ExtensionDescriptor"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.PerfettoMetatrace"; }
 
+  using Arg = ::perfetto::protos::pbzero::PerfettoMetatrace_Arg;
+  using InternedString = ::perfetto::protos::pbzero::PerfettoMetatrace_InternedString;
 
-  using FieldMetadata_ExtensionSet =
+  using FieldMetadata_EventId =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      FileDescriptorSet,
-      ExtensionDescriptor>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      PerfettoMetatrace>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ExtensionSet kExtensionSet() { return {}; }
-  template <typename T = FileDescriptorSet> T* set_extension_set() {
-    return BeginNestedMessage<T>(1);
+  static constexpr FieldMetadata_EventId kEventId{};
+  void set_event_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EventId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
 
-};
+  using FieldMetadata_CounterId =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      PerfettoMetatrace>;
 
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/memory_graph.pbzero.h
-// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+  static constexpr FieldMetadata_CounterId kCounterId{};
+  void set_counter_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CounterId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_MEMORY_GRAPH_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_MEMORY_GRAPH_PROTO_H_
+  using FieldMetadata_EventName =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      PerfettoMetatrace>;
 
-#include <stddef.h>
-#include <stdint.h>
+  static constexpr FieldMetadata_EventName kEventName{};
+  void set_event_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_EventName::kFieldId, data, size);
+  }
+  void set_event_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_EventName::kFieldId, chars.data, chars.size);
+  }
+  void set_event_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_EventName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  using FieldMetadata_EventNameIid =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      PerfettoMetatrace>;
 
-namespace perfetto {
-namespace protos {
-namespace pbzero {
+  static constexpr FieldMetadata_EventNameIid kEventNameIid{};
+  void set_event_name_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EventNameIid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-class MemoryTrackerSnapshot_ProcessSnapshot;
-class MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge;
-class MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode;
-class MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry;
-namespace perfetto_pbzero_enum_MemoryTrackerSnapshot {
-enum LevelOfDetail : int32_t;
-}  // namespace perfetto_pbzero_enum_MemoryTrackerSnapshot
-using MemoryTrackerSnapshot_LevelOfDetail = perfetto_pbzero_enum_MemoryTrackerSnapshot::LevelOfDetail;
-namespace perfetto_pbzero_enum_MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry {
-enum Units : int32_t;
-}  // namespace perfetto_pbzero_enum_MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry
-using MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units = perfetto_pbzero_enum_MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry::Units;
+  using FieldMetadata_CounterName =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      PerfettoMetatrace>;
 
-namespace perfetto_pbzero_enum_MemoryTrackerSnapshot {
-enum LevelOfDetail : int32_t {
-  DETAIL_FULL = 0,
-  DETAIL_LIGHT = 1,
-  DETAIL_BACKGROUND = 2,
-};
-} // namespace perfetto_pbzero_enum_MemoryTrackerSnapshot
-using MemoryTrackerSnapshot_LevelOfDetail = perfetto_pbzero_enum_MemoryTrackerSnapshot::LevelOfDetail;
+  static constexpr FieldMetadata_CounterName kCounterName{};
+  void set_counter_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_CounterName::kFieldId, data, size);
+  }
+  void set_counter_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_CounterName::kFieldId, chars.data, chars.size);
+  }
+  void set_counter_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_CounterName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
+  using FieldMetadata_EventDurationNs =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      PerfettoMetatrace>;
 
-constexpr MemoryTrackerSnapshot_LevelOfDetail MemoryTrackerSnapshot_LevelOfDetail_MIN = MemoryTrackerSnapshot_LevelOfDetail::DETAIL_FULL;
-constexpr MemoryTrackerSnapshot_LevelOfDetail MemoryTrackerSnapshot_LevelOfDetail_MAX = MemoryTrackerSnapshot_LevelOfDetail::DETAIL_BACKGROUND;
+  static constexpr FieldMetadata_EventDurationNs kEventDurationNs{};
+  void set_event_duration_ns(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EventDurationNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
+  using FieldMetadata_CounterValue =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      PerfettoMetatrace>;
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* MemoryTrackerSnapshot_LevelOfDetail_Name(::perfetto::protos::pbzero::MemoryTrackerSnapshot_LevelOfDetail value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::MemoryTrackerSnapshot_LevelOfDetail::DETAIL_FULL:
-    return "DETAIL_FULL";
+  static constexpr FieldMetadata_CounterValue kCounterValue{};
+  void set_counter_value(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CounterValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-  case ::perfetto::protos::pbzero::MemoryTrackerSnapshot_LevelOfDetail::DETAIL_LIGHT:
-    return "DETAIL_LIGHT";
+  using FieldMetadata_ThreadId =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      PerfettoMetatrace>;
 
-  case ::perfetto::protos::pbzero::MemoryTrackerSnapshot_LevelOfDetail::DETAIL_BACKGROUND:
-    return "DETAIL_BACKGROUND";
+  static constexpr FieldMetadata_ThreadId kThreadId{};
+  void set_thread_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ThreadId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
 
-namespace perfetto_pbzero_enum_MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry {
-enum Units : int32_t {
-  UNSPECIFIED = 0,
-  BYTES = 1,
-  COUNT = 2,
-};
-} // namespace perfetto_pbzero_enum_MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry
-using MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units = perfetto_pbzero_enum_MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry::Units;
+  using FieldMetadata_HasOverruns =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      PerfettoMetatrace>;
 
+  static constexpr FieldMetadata_HasOverruns kHasOverruns{};
+  void set_has_overruns(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_HasOverruns::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-constexpr MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units_MIN = MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units::UNSPECIFIED;
-constexpr MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units_MAX = MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units::COUNT;
+  using FieldMetadata_Args =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PerfettoMetatrace_Arg,
+      PerfettoMetatrace>;
 
+  static constexpr FieldMetadata_Args kArgs{};
+  template <typename T = PerfettoMetatrace_Arg> T* add_args() {
+    return BeginNestedMessage<T>(7);
+  }
 
-PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
-const char* MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units_Name(::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units value) {
-  switch (value) {
-  case ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units::UNSPECIFIED:
-    return "UNSPECIFIED";
 
-  case ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units::BYTES:
-    return "BYTES";
+  using FieldMetadata_InternedStrings =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PerfettoMetatrace_InternedString,
+      PerfettoMetatrace>;
 
-  case ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units::COUNT:
-    return "COUNT";
+  static constexpr FieldMetadata_InternedStrings kInternedStrings{};
+  template <typename T = PerfettoMetatrace_InternedString> T* add_interned_strings() {
+    return BeginNestedMessage<T>(10);
   }
-  return "PBZERO_UNKNOWN_ENUM_VALUE";
-}
 
-class MemoryTrackerSnapshot_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+};
+
+class PerfettoMetatrace_InternedString_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  MemoryTrackerSnapshot_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MemoryTrackerSnapshot_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MemoryTrackerSnapshot_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_global_dump_id() const { return at<1>().valid(); }
-  uint64_t global_dump_id() const { return at<1>().as_uint64(); }
-  bool has_level_of_detail() const { return at<2>().valid(); }
-  int32_t level_of_detail() const { return at<2>().as_int32(); }
-  bool has_process_memory_dumps() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> process_memory_dumps() const { return GetRepeated<::protozero::ConstBytes>(3); }
+  PerfettoMetatrace_InternedString_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PerfettoMetatrace_InternedString_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PerfettoMetatrace_InternedString_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_iid() const { return at<1>().valid(); }
+  uint64_t iid() const { return at<1>().as_uint64(); }
+  bool has_value() const { return at<2>().valid(); }
+  ::protozero::ConstChars value() const { return at<2>().as_string(); }
 };
 
-class MemoryTrackerSnapshot : public ::protozero::Message {
+class PerfettoMetatrace_InternedString : public ::protozero::Message {
  public:
-  using Decoder = MemoryTrackerSnapshot_Decoder;
+  using Decoder = PerfettoMetatrace_InternedString_Decoder;
   enum : int32_t {
-    kGlobalDumpIdFieldNumber = 1,
-    kLevelOfDetailFieldNumber = 2,
-    kProcessMemoryDumpsFieldNumber = 3,
+    kIidFieldNumber = 1,
+    kValueFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MemoryTrackerSnapshot"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.PerfettoMetatrace.InternedString"; }
 
-  using ProcessSnapshot = ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot;
 
-  using LevelOfDetail = ::perfetto::protos::pbzero::MemoryTrackerSnapshot_LevelOfDetail;
-  static inline const char* LevelOfDetail_Name(LevelOfDetail value) {
-    return ::perfetto::protos::pbzero::MemoryTrackerSnapshot_LevelOfDetail_Name(value);
+  using FieldMetadata_Iid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      PerfettoMetatrace_InternedString>;
+
+  static constexpr FieldMetadata_Iid kIid{};
+  void set_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
   }
-  static const LevelOfDetail DETAIL_FULL = LevelOfDetail::DETAIL_FULL;
-  static const LevelOfDetail DETAIL_LIGHT = LevelOfDetail::DETAIL_LIGHT;
-  static const LevelOfDetail DETAIL_BACKGROUND = LevelOfDetail::DETAIL_BACKGROUND;
 
-  using FieldMetadata_GlobalDumpId =
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      PerfettoMetatrace_InternedString>;
+
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
+  }
+  void set_value(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
+  }
+  void set_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
+
+class PerfettoMetatrace_Arg_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  PerfettoMetatrace_Arg_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PerfettoMetatrace_Arg_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PerfettoMetatrace_Arg_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_key() const { return at<1>().valid(); }
+  ::protozero::ConstChars key() const { return at<1>().as_string(); }
+  bool has_key_iid() const { return at<3>().valid(); }
+  uint64_t key_iid() const { return at<3>().as_uint64(); }
+  bool has_value() const { return at<2>().valid(); }
+  ::protozero::ConstChars value() const { return at<2>().as_string(); }
+  bool has_value_iid() const { return at<4>().valid(); }
+  uint64_t value_iid() const { return at<4>().as_uint64(); }
+};
+
+class PerfettoMetatrace_Arg : public ::protozero::Message {
+ public:
+  using Decoder = PerfettoMetatrace_Arg_Decoder;
+  enum : int32_t {
+    kKeyFieldNumber = 1,
+    kKeyIidFieldNumber = 3,
+    kValueFieldNumber = 2,
+    kValueIidFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.PerfettoMetatrace.Arg"; }
+
+
+  using FieldMetadata_Key =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      PerfettoMetatrace_Arg>;
+
+  static constexpr FieldMetadata_Key kKey{};
+  void set_key(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Key::kFieldId, data, size);
+  }
+  void set_key(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Key::kFieldId, chars.data, chars.size);
+  }
+  void set_key(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_KeyIid =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kUint64,
       uint64_t,
-      MemoryTrackerSnapshot>;
+      PerfettoMetatrace_Arg>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_GlobalDumpId kGlobalDumpId() { return {}; }
-  void set_global_dump_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_GlobalDumpId::kFieldId;
+  static constexpr FieldMetadata_KeyIid kKeyIid{};
+  void set_key_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KeyIid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -161003,380 +180374,453 @@ class MemoryTrackerSnapshot : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_LevelOfDetail =
+  using FieldMetadata_Value =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::MemoryTrackerSnapshot_LevelOfDetail,
-      MemoryTrackerSnapshot>;
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      PerfettoMetatrace_Arg>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_LevelOfDetail kLevelOfDetail() { return {}; }
-  void set_level_of_detail(::perfetto::protos::pbzero::MemoryTrackerSnapshot_LevelOfDetail value) {
-    static constexpr uint32_t field_id = FieldMetadata_LevelOfDetail::kFieldId;
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
+  }
+  void set_value(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
+  }
+  void set_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+      ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_ProcessMemoryDumps =
+  using FieldMetadata_ValueIid =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      PerfettoMetatrace_Arg>;
+
+  static constexpr FieldMetadata_ValueIid kValueIid{};
+  void set_value_iid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ValueIid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/perfetto/trace_provenance.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PERFETTO_TRACE_PROVENANCE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PERFETTO_TRACE_PROVENANCE_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class TraceProvenance_Buffer;
+class TraceProvenance_Sequence;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class TraceProvenance_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  TraceProvenance_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceProvenance_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceProvenance_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_buffers() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> buffers() const { return GetRepeated<::protozero::ConstBytes>(2); }
+};
+
+class TraceProvenance : public ::protozero::Message {
+ public:
+  using Decoder = TraceProvenance_Decoder;
+  enum : int32_t {
+    kBuffersFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceProvenance"; }
+
+  using Sequence = ::perfetto::protos::pbzero::TraceProvenance_Sequence;
+  using Buffer = ::perfetto::protos::pbzero::TraceProvenance_Buffer;
+
+  using FieldMetadata_Buffers =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      MemoryTrackerSnapshot_ProcessSnapshot,
-      MemoryTrackerSnapshot>;
+      TraceProvenance_Buffer,
+      TraceProvenance>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ProcessMemoryDumps kProcessMemoryDumps() { return {}; }
-  template <typename T = MemoryTrackerSnapshot_ProcessSnapshot> T* add_process_memory_dumps() {
-    return BeginNestedMessage<T>(3);
+  static constexpr FieldMetadata_Buffers kBuffers{};
+  template <typename T = TraceProvenance_Buffer> T* add_buffers() {
+    return BeginNestedMessage<T>(2);
   }
 
 };
 
-class MemoryTrackerSnapshot_ProcessSnapshot_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class TraceProvenance_Buffer_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  MemoryTrackerSnapshot_ProcessSnapshot_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MemoryTrackerSnapshot_ProcessSnapshot_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MemoryTrackerSnapshot_ProcessSnapshot_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pid() const { return at<1>().valid(); }
-  int32_t pid() const { return at<1>().as_int32(); }
-  bool has_allocator_dumps() const { return at<2>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> allocator_dumps() const { return GetRepeated<::protozero::ConstBytes>(2); }
-  bool has_memory_edges() const { return at<3>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> memory_edges() const { return GetRepeated<::protozero::ConstBytes>(3); }
+  TraceProvenance_Buffer_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceProvenance_Buffer_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceProvenance_Buffer_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_sequences() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> sequences() const { return GetRepeated<::protozero::ConstBytes>(1); }
 };
 
-class MemoryTrackerSnapshot_ProcessSnapshot : public ::protozero::Message {
+class TraceProvenance_Buffer : public ::protozero::Message {
  public:
-  using Decoder = MemoryTrackerSnapshot_ProcessSnapshot_Decoder;
+  using Decoder = TraceProvenance_Buffer_Decoder;
   enum : int32_t {
-    kPidFieldNumber = 1,
-    kAllocatorDumpsFieldNumber = 2,
-    kMemoryEdgesFieldNumber = 3,
+    kSequencesFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceProvenance.Buffer"; }
+
+
+  using FieldMetadata_Sequences =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TraceProvenance_Sequence,
+      TraceProvenance_Buffer>;
+
+  static constexpr FieldMetadata_Sequences kSequences{};
+  template <typename T = TraceProvenance_Sequence> T* add_sequences() {
+    return BeginNestedMessage<T>(1);
+  }
+
+};
+
+class TraceProvenance_Sequence_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  TraceProvenance_Sequence_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TraceProvenance_Sequence_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TraceProvenance_Sequence_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  uint32_t id() const { return at<1>().as_uint32(); }
+  bool has_producer_id() const { return at<2>().valid(); }
+  int32_t producer_id() const { return at<2>().as_int32(); }
+};
+
+class TraceProvenance_Sequence : public ::protozero::Message {
+ public:
+  using Decoder = TraceProvenance_Sequence_Decoder;
+  enum : int32_t {
+    kIdFieldNumber = 1,
+    kProducerIdFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MemoryTrackerSnapshot.ProcessSnapshot"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.TraceProvenance.Sequence"; }
 
-  using MemoryNode = ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode;
-  using MemoryEdge = ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge;
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_Id =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt32,
-      int32_t,
-      MemoryTrackerSnapshot_ProcessSnapshot>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TraceProvenance_Sequence>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(int32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_AllocatorDumps =
+  using FieldMetadata_ProducerId =
     ::protozero::proto_utils::FieldMetadata<
       2,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode,
-      MemoryTrackerSnapshot_ProcessSnapshot>;
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TraceProvenance_Sequence>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AllocatorDumps kAllocatorDumps() { return {}; }
-  template <typename T = MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode> T* add_allocator_dumps() {
-    return BeginNestedMessage<T>(2);
+  static constexpr FieldMetadata_ProducerId kProducerId{};
+  void set_producer_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProducerId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
   }
+};
 
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/perfetto/tracing_service_event.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  using FieldMetadata_MemoryEdges =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
-      ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge,
-      MemoryTrackerSnapshot_ProcessSnapshot>;
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PERFETTO_TRACING_SERVICE_EVENT_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PERFETTO_TRACING_SERVICE_EVENT_PROTO_H_
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_MemoryEdges kMemoryEdges() { return {}; }
-  template <typename T = MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge> T* add_memory_edges() {
-    return BeginNestedMessage<T>(3);
-  }
+#include <stddef.h>
+#include <stdint.h>
 
-};
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class TracingServiceEvent_DataSources;
+class TracingServiceEvent_DataSources_DataSource;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-class MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class TracingServiceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11> {
  public:
-  MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_source_id() const { return at<1>().valid(); }
-  uint64_t source_id() const { return at<1>().as_uint64(); }
-  bool has_target_id() const { return at<2>().valid(); }
-  uint64_t target_id() const { return at<2>().as_uint64(); }
-  bool has_importance() const { return at<3>().valid(); }
-  uint32_t importance() const { return at<3>().as_uint32(); }
-  bool has_overridable() const { return at<4>().valid(); }
-  bool overridable() const { return at<4>().as_bool(); }
+  TracingServiceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TracingServiceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TracingServiceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_tracing_started() const { return at<2>().valid(); }
+  bool tracing_started() const { return at<2>().as_bool(); }
+  bool has_all_data_sources_started() const { return at<1>().valid(); }
+  bool all_data_sources_started() const { return at<1>().as_bool(); }
+  bool has_flush_started() const { return at<9>().valid(); }
+  bool flush_started() const { return at<9>().as_bool(); }
+  bool has_all_data_sources_flushed() const { return at<3>().valid(); }
+  bool all_data_sources_flushed() const { return at<3>().as_bool(); }
+  bool has_read_tracing_buffers_completed() const { return at<4>().valid(); }
+  bool read_tracing_buffers_completed() const { return at<4>().as_bool(); }
+  bool has_tracing_disabled() const { return at<5>().valid(); }
+  bool tracing_disabled() const { return at<5>().as_bool(); }
+  bool has_seized_for_bugreport() const { return at<6>().valid(); }
+  bool seized_for_bugreport() const { return at<6>().as_bool(); }
+  bool has_slow_starting_data_sources() const { return at<7>().valid(); }
+  ::protozero::ConstBytes slow_starting_data_sources() const { return at<7>().as_bytes(); }
+  bool has_last_flush_slow_data_sources() const { return at<8>().valid(); }
+  ::protozero::ConstBytes last_flush_slow_data_sources() const { return at<8>().as_bytes(); }
+  bool has_clone_started() const { return at<10>().valid(); }
+  bool clone_started() const { return at<10>().as_bool(); }
+  bool has_buffer_cloned() const { return at<11>().valid(); }
+  uint32_t buffer_cloned() const { return at<11>().as_uint32(); }
 };
 
-class MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge : public ::protozero::Message {
+class TracingServiceEvent : public ::protozero::Message {
  public:
-  using Decoder = MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge_Decoder;
+  using Decoder = TracingServiceEvent_Decoder;
   enum : int32_t {
-    kSourceIdFieldNumber = 1,
-    kTargetIdFieldNumber = 2,
-    kImportanceFieldNumber = 3,
-    kOverridableFieldNumber = 4,
+    kTracingStartedFieldNumber = 2,
+    kAllDataSourcesStartedFieldNumber = 1,
+    kFlushStartedFieldNumber = 9,
+    kAllDataSourcesFlushedFieldNumber = 3,
+    kReadTracingBuffersCompletedFieldNumber = 4,
+    kTracingDisabledFieldNumber = 5,
+    kSeizedForBugreportFieldNumber = 6,
+    kSlowStartingDataSourcesFieldNumber = 7,
+    kLastFlushSlowDataSourcesFieldNumber = 8,
+    kCloneStartedFieldNumber = 10,
+    kBufferClonedFieldNumber = 11,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MemoryTrackerSnapshot.ProcessSnapshot.MemoryEdge"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.TracingServiceEvent"; }
 
+  using DataSources = ::perfetto::protos::pbzero::TracingServiceEvent_DataSources;
 
-  using FieldMetadata_SourceId =
+  using FieldMetadata_TracingStarted =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TracingServiceEvent>;
+
+  static constexpr FieldMetadata_TracingStarted kTracingStarted{};
+  void set_tracing_started(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_TracingStarted::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_AllDataSourcesStarted =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TracingServiceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SourceId kSourceId() { return {}; }
-  void set_source_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SourceId::kFieldId;
+  static constexpr FieldMetadata_AllDataSourcesStarted kAllDataSourcesStarted{};
+  void set_all_data_sources_started(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_AllDataSourcesStarted::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TargetId =
+  using FieldMetadata_FlushStarted =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      9,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TracingServiceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TargetId kTargetId() { return {}; }
-  void set_target_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TargetId::kFieldId;
+  static constexpr FieldMetadata_FlushStarted kFlushStarted{};
+  void set_flush_started(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_FlushStarted::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Importance =
+  using FieldMetadata_AllDataSourcesFlushed =
     ::protozero::proto_utils::FieldMetadata<
       3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TracingServiceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Importance kImportance() { return {}; }
-  void set_importance(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Importance::kFieldId;
+  static constexpr FieldMetadata_AllDataSourcesFlushed kAllDataSourcesFlushed{};
+  void set_all_data_sources_flushed(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_AllDataSourcesFlushed::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Overridable =
+  using FieldMetadata_ReadTracingBuffersCompleted =
     ::protozero::proto_utils::FieldMetadata<
       4,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kBool,
       bool,
-      MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge>;
+      TracingServiceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Overridable kOverridable() { return {}; }
-  void set_overridable(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_Overridable::kFieldId;
+  static constexpr FieldMetadata_ReadTracingBuffersCompleted kReadTracingBuffersCompleted{};
+  void set_read_tracing_buffers_completed(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReadTracingBuffersCompleted::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
       ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
-};
-
-class MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
- public:
-  MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_id() const { return at<1>().valid(); }
-  uint64_t id() const { return at<1>().as_uint64(); }
-  bool has_absolute_name() const { return at<2>().valid(); }
-  ::protozero::ConstChars absolute_name() const { return at<2>().as_string(); }
-  bool has_weak() const { return at<3>().valid(); }
-  bool weak() const { return at<3>().as_bool(); }
-  bool has_size_bytes() const { return at<4>().valid(); }
-  uint64_t size_bytes() const { return at<4>().as_uint64(); }
-  bool has_entries() const { return at<5>().valid(); }
-  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> entries() const { return GetRepeated<::protozero::ConstBytes>(5); }
-};
-
-class MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode : public ::protozero::Message {
- public:
-  using Decoder = MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_Decoder;
-  enum : int32_t {
-    kIdFieldNumber = 1,
-    kAbsoluteNameFieldNumber = 2,
-    kWeakFieldNumber = 3,
-    kSizeBytesFieldNumber = 4,
-    kEntriesFieldNumber = 5,
-  };
-  static constexpr const char* GetName() { return ".perfetto.protos.MemoryTrackerSnapshot.ProcessSnapshot.MemoryNode"; }
-
-  using MemoryNodeEntry = ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry;
 
-  using FieldMetadata_Id =
+  using FieldMetadata_TracingDisabled =
     ::protozero::proto_utils::FieldMetadata<
-      1,
+      5,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TracingServiceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Id kId() { return {}; }
-  void set_id(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+  static constexpr FieldMetadata_TracingDisabled kTracingDisabled{};
+  void set_tracing_disabled(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_TracingDisabled::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_AbsoluteName =
+  using FieldMetadata_SeizedForBugreport =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      6,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode>;
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TracingServiceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_AbsoluteName kAbsoluteName() { return {}; }
-  void set_absolute_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_AbsoluteName::kFieldId, data, size);
-  }
-  void set_absolute_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_AbsoluteName::kFieldId, chars.data, chars.size);
-  }
-  void set_absolute_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_AbsoluteName::kFieldId;
+  static constexpr FieldMetadata_SeizedForBugreport kSeizedForBugreport{};
+  void set_seized_for_bugreport(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_SeizedForBugreport::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Weak =
+  using FieldMetadata_SlowStartingDataSources =
     ::protozero::proto_utils::FieldMetadata<
-      3,
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TracingServiceEvent_DataSources,
+      TracingServiceEvent>;
+
+  static constexpr FieldMetadata_SlowStartingDataSources kSlowStartingDataSources{};
+  template <typename T = TracingServiceEvent_DataSources> T* set_slow_starting_data_sources() {
+    return BeginNestedMessage<T>(7);
+  }
+
+
+  using FieldMetadata_LastFlushSlowDataSources =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TracingServiceEvent_DataSources,
+      TracingServiceEvent>;
+
+  static constexpr FieldMetadata_LastFlushSlowDataSources kLastFlushSlowDataSources{};
+  template <typename T = TracingServiceEvent_DataSources> T* set_last_flush_slow_data_sources() {
+    return BeginNestedMessage<T>(8);
+  }
+
+
+  using FieldMetadata_CloneStarted =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kBool,
       bool,
-      MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode>;
+      TracingServiceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Weak kWeak() { return {}; }
-  void set_weak(bool value) {
-    static constexpr uint32_t field_id = FieldMetadata_Weak::kFieldId;
+  static constexpr FieldMetadata_CloneStarted kCloneStarted{};
+  void set_clone_started(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_CloneStarted::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -161384,112 +180828,97 @@ class MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode : public ::protozero::Mes
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_SizeBytes =
+  using FieldMetadata_BufferCloned =
     ::protozero::proto_utils::FieldMetadata<
-      4,
+      11,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode>;
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TracingServiceEvent>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_SizeBytes kSizeBytes() { return {}; }
-  void set_size_bytes(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_SizeBytes::kFieldId;
+  static constexpr FieldMetadata_BufferCloned kBufferCloned{};
+  void set_buffer_cloned(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_BufferCloned::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+};
 
-  using FieldMetadata_Entries =
+class TracingServiceEvent_DataSources_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  TracingServiceEvent_DataSources_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TracingServiceEvent_DataSources_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TracingServiceEvent_DataSources_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_data_source() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> data_source() const { return GetRepeated<::protozero::ConstBytes>(1); }
+};
+
+class TracingServiceEvent_DataSources : public ::protozero::Message {
+ public:
+  using Decoder = TracingServiceEvent_DataSources_Decoder;
+  enum : int32_t {
+    kDataSourceFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TracingServiceEvent.DataSources"; }
+
+  using DataSource = ::perfetto::protos::pbzero::TracingServiceEvent_DataSources_DataSource;
+
+  using FieldMetadata_DataSource =
     ::protozero::proto_utils::FieldMetadata<
-      5,
+      1,
       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry,
-      MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode>;
+      TracingServiceEvent_DataSources_DataSource,
+      TracingServiceEvent_DataSources>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Entries kEntries() { return {}; }
-  template <typename T = MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry> T* add_entries() {
-    return BeginNestedMessage<T>(5);
+  static constexpr FieldMetadata_DataSource kDataSource{};
+  template <typename T = TracingServiceEvent_DataSources_DataSource> T* add_data_source() {
+    return BeginNestedMessage<T>(1);
   }
 
 };
 
-class MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class TracingServiceEvent_DataSources_DataSource_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_name() const { return at<1>().valid(); }
-  ::protozero::ConstChars name() const { return at<1>().as_string(); }
-  bool has_units() const { return at<2>().valid(); }
-  int32_t units() const { return at<2>().as_int32(); }
-  bool has_value_uint64() const { return at<3>().valid(); }
-  uint64_t value_uint64() const { return at<3>().as_uint64(); }
-  bool has_value_string() const { return at<4>().valid(); }
-  ::protozero::ConstChars value_string() const { return at<4>().as_string(); }
+  TracingServiceEvent_DataSources_DataSource_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TracingServiceEvent_DataSources_DataSource_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TracingServiceEvent_DataSources_DataSource_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_producer_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars producer_name() const { return at<1>().as_string(); }
+  bool has_data_source_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars data_source_name() const { return at<2>().as_string(); }
 };
 
-class MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry : public ::protozero::Message {
+class TracingServiceEvent_DataSources_DataSource : public ::protozero::Message {
  public:
-  using Decoder = MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Decoder;
+  using Decoder = TracingServiceEvent_DataSources_DataSource_Decoder;
   enum : int32_t {
-    kNameFieldNumber = 1,
-    kUnitsFieldNumber = 2,
-    kValueUint64FieldNumber = 3,
-    kValueStringFieldNumber = 4,
+    kProducerNameFieldNumber = 1,
+    kDataSourceNameFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.MemoryTrackerSnapshot.ProcessSnapshot.MemoryNode.MemoryNodeEntry"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.TracingServiceEvent.DataSources.DataSource"; }
 
 
-  using Units = ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units;
-  static inline const char* Units_Name(Units value) {
-    return ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units_Name(value);
-  }
-  static const Units UNSPECIFIED = Units::UNSPECIFIED;
-  static const Units BYTES = Units::BYTES;
-  static const Units COUNT = Units::COUNT;
-
-  using FieldMetadata_Name =
+  using FieldMetadata_ProducerName =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry>;
+      TracingServiceEvent_DataSources_DataSource>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Name kName() { return {}; }
-  void set_name(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  static constexpr FieldMetadata_ProducerName kProducerName{};
+  void set_producer_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ProducerName::kFieldId, data, size);
   }
-  void set_name(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  void set_producer_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ProducerName::kFieldId, chars.data, chars.size);
   }
-  void set_name(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+  void set_producer_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProducerName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -161497,80 +180926,23 @@ class MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry : public
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Units =
+  using FieldMetadata_DataSourceName =
     ::protozero::proto_utils::FieldMetadata<
       2,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kEnum,
-      ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units,
-      MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Units kUnits() { return {}; }
-  void set_units(::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units value) {
-    static constexpr uint32_t field_id = FieldMetadata_Units::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kEnum>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ValueUint64 =
-    ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint64,
-      uint64_t,
-      MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ValueUint64 kValueUint64() { return {}; }
-  void set_value_uint64(uint64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_ValueUint64::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint64>
-        ::Append(*this, field_id, value);
-  }
-
-  using FieldMetadata_ValueString =
-    ::protozero::proto_utils::FieldMetadata<
-      4,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kString,
       std::string,
-      MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry>;
+      TracingServiceEvent_DataSources_DataSource>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_ValueString kValueString() { return {}; }
-  void set_value_string(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_ValueString::kFieldId, data, size);
+  static constexpr FieldMetadata_DataSourceName kDataSourceName{};
+  void set_data_source_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_DataSourceName::kFieldId, data, size);
   }
-  void set_value_string(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_ValueString::kFieldId, chars.data, chars.size);
+  void set_data_source_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_DataSourceName::kFieldId, chars.data, chars.size);
   }
-  void set_value_string(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_ValueString::kFieldId;
+  void set_data_source_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_DataSourceName::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -161583,11 +180955,11 @@ class MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry : public
 } // Namespace.
 } // Namespace.
 #endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/ui_state.pbzero.h
+// gen_amalgamated begin header: gen/protos/perfetto/trace/power/android_energy_estimation_breakdown.pbzero.h
 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_UI_STATE_PROTO_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_UI_STATE_PROTO_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_POWER_ANDROID_ENERGY_ESTIMATION_BREAKDOWN_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_POWER_ANDROID_ENERGY_ESTIMATION_BREAKDOWN_PROTO_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -161601,77 +180973,87 @@ class MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry : public
 namespace perfetto {
 namespace protos {
 namespace pbzero {
+class AndroidEnergyConsumerDescriptor;
+class AndroidEnergyEstimationBreakdown_EnergyUidBreakdown;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-class UiState_HighlightProcess;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-class UiState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class AndroidEnergyEstimationBreakdown_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  UiState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit UiState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit UiState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_timeline_start_ts() const { return at<1>().valid(); }
-  int64_t timeline_start_ts() const { return at<1>().as_int64(); }
-  bool has_timeline_end_ts() const { return at<2>().valid(); }
-  int64_t timeline_end_ts() const { return at<2>().as_int64(); }
-  bool has_highlight_process() const { return at<3>().valid(); }
-  ::protozero::ConstBytes highlight_process() const { return at<3>().as_bytes(); }
+  AndroidEnergyEstimationBreakdown_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidEnergyEstimationBreakdown_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidEnergyEstimationBreakdown_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_energy_consumer_descriptor() const { return at<1>().valid(); }
+  ::protozero::ConstBytes energy_consumer_descriptor() const { return at<1>().as_bytes(); }
+  bool has_energy_consumer_id() const { return at<2>().valid(); }
+  int32_t energy_consumer_id() const { return at<2>().as_int32(); }
+  bool has_energy_uws() const { return at<3>().valid(); }
+  int64_t energy_uws() const { return at<3>().as_int64(); }
+  bool has_per_uid_breakdown() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> per_uid_breakdown() const { return GetRepeated<::protozero::ConstBytes>(4); }
 };
 
-class UiState : public ::protozero::Message {
+class AndroidEnergyEstimationBreakdown : public ::protozero::Message {
  public:
-  using Decoder = UiState_Decoder;
+  using Decoder = AndroidEnergyEstimationBreakdown_Decoder;
   enum : int32_t {
-    kTimelineStartTsFieldNumber = 1,
-    kTimelineEndTsFieldNumber = 2,
-    kHighlightProcessFieldNumber = 3,
+    kEnergyConsumerDescriptorFieldNumber = 1,
+    kEnergyConsumerIdFieldNumber = 2,
+    kEnergyUwsFieldNumber = 3,
+    kPerUidBreakdownFieldNumber = 4,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.UiState"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidEnergyEstimationBreakdown"; }
 
-  using HighlightProcess = ::perfetto::protos::pbzero::UiState_HighlightProcess;
+  using EnergyUidBreakdown = ::perfetto::protos::pbzero::AndroidEnergyEstimationBreakdown_EnergyUidBreakdown;
 
-  using FieldMetadata_TimelineStartTs =
+  using FieldMetadata_EnergyConsumerDescriptor =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kInt64,
-      int64_t,
-      UiState>;
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      AndroidEnergyConsumerDescriptor,
+      AndroidEnergyEstimationBreakdown>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimelineStartTs kTimelineStartTs() { return {}; }
-  void set_timeline_start_ts(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimelineStartTs::kFieldId;
+  static constexpr FieldMetadata_EnergyConsumerDescriptor kEnergyConsumerDescriptor{};
+  template <typename T = AndroidEnergyConsumerDescriptor> T* set_energy_consumer_descriptor() {
+    return BeginNestedMessage<T>(1);
+  }
+
+
+  using FieldMetadata_EnergyConsumerId =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      AndroidEnergyEstimationBreakdown>;
+
+  static constexpr FieldMetadata_EnergyConsumerId kEnergyConsumerId{};
+  void set_energy_consumer_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EnergyConsumerId::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_TimelineEndTs =
+  using FieldMetadata_EnergyUws =
     ::protozero::proto_utils::FieldMetadata<
-      2,
+      3,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
       ::protozero::proto_utils::ProtoSchemaType::kInt64,
       int64_t,
-      UiState>;
+      AndroidEnergyEstimationBreakdown>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_TimelineEndTs kTimelineEndTs() { return {}; }
-  void set_timeline_end_ts(int64_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_TimelineEndTs::kFieldId;
+  static constexpr FieldMetadata_EnergyUws kEnergyUws{};
+  void set_energy_uws(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EnergyUws::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
@@ -161679,6349 +181061,7811 @@ class UiState : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_HighlightProcess =
+  using FieldMetadata_PerUidBreakdown =
     ::protozero::proto_utils::FieldMetadata<
-      3,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      4,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
       ::protozero::proto_utils::ProtoSchemaType::kMessage,
-      UiState_HighlightProcess,
-      UiState>;
+      AndroidEnergyEstimationBreakdown_EnergyUidBreakdown,
+      AndroidEnergyEstimationBreakdown>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_HighlightProcess kHighlightProcess() { return {}; }
-  template <typename T = UiState_HighlightProcess> T* set_highlight_process() {
-    return BeginNestedMessage<T>(3);
+  static constexpr FieldMetadata_PerUidBreakdown kPerUidBreakdown{};
+  template <typename T = AndroidEnergyEstimationBreakdown_EnergyUidBreakdown> T* add_per_uid_breakdown() {
+    return BeginNestedMessage<T>(4);
   }
 
 };
 
-class UiState_HighlightProcess_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class AndroidEnergyEstimationBreakdown_EnergyUidBreakdown_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  UiState_HighlightProcess_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
-  explicit UiState_HighlightProcess_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
-  explicit UiState_HighlightProcess_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
-  bool has_pid() const { return at<1>().valid(); }
-  uint32_t pid() const { return at<1>().as_uint32(); }
-  bool has_cmdline() const { return at<2>().valid(); }
-  ::protozero::ConstChars cmdline() const { return at<2>().as_string(); }
+  AndroidEnergyEstimationBreakdown_EnergyUidBreakdown_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit AndroidEnergyEstimationBreakdown_EnergyUidBreakdown_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit AndroidEnergyEstimationBreakdown_EnergyUidBreakdown_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_uid() const { return at<1>().valid(); }
+  int32_t uid() const { return at<1>().as_int32(); }
+  bool has_energy_uws() const { return at<2>().valid(); }
+  int64_t energy_uws() const { return at<2>().as_int64(); }
 };
 
-class UiState_HighlightProcess : public ::protozero::Message {
+class AndroidEnergyEstimationBreakdown_EnergyUidBreakdown : public ::protozero::Message {
  public:
-  using Decoder = UiState_HighlightProcess_Decoder;
+  using Decoder = AndroidEnergyEstimationBreakdown_EnergyUidBreakdown_Decoder;
   enum : int32_t {
-    kPidFieldNumber = 1,
-    kCmdlineFieldNumber = 2,
+    kUidFieldNumber = 1,
+    kEnergyUwsFieldNumber = 2,
   };
-  static constexpr const char* GetName() { return ".perfetto.protos.UiState.HighlightProcess"; }
+  static constexpr const char* GetName() { return ".perfetto.protos.AndroidEnergyEstimationBreakdown.EnergyUidBreakdown"; }
 
 
-  using FieldMetadata_Pid =
+  using FieldMetadata_Uid =
     ::protozero::proto_utils::FieldMetadata<
       1,
       ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kUint32,
-      uint32_t,
-      UiState_HighlightProcess>;
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      AndroidEnergyEstimationBreakdown_EnergyUidBreakdown>;
 
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Pid kPid() { return {}; }
-  void set_pid(uint32_t value) {
-    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+  static constexpr FieldMetadata_Uid kUid{};
+  void set_uid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId;
     // Call the appropriate protozero::Message::Append(field_id, ...)
     // method based on the type of the field.
     ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
         ::Append(*this, field_id, value);
   }
 
-  using FieldMetadata_Cmdline =
+  using FieldMetadata_EnergyUws =
     ::protozero::proto_utils::FieldMetadata<
       2,
-      ::protozero::proto_utils::RepetitionType::kNotRepeated,
-      ::protozero::proto_utils::ProtoSchemaType::kString,
-      std::string,
-      UiState_HighlightProcess>;
-
-  // Ceci n'est pas une pipe.
-  // This is actually a variable of FieldMetadataHelper<FieldMetadata<...>>
-  // type (and users are expected to use it as such, hence kCamelCase name).
-  // It is declared as a function to keep protozero bindings header-only as
-  // inline constexpr variables are not available until C++17 (while inline
-  // functions are).
-  // TODO(altimin): Use inline variable instead after adopting C++17.
-  static constexpr FieldMetadata_Cmdline kCmdline() { return {}; }
-  void set_cmdline(const char* data, size_t size) {
-    AppendBytes(FieldMetadata_Cmdline::kFieldId, data, size);
-  }
-  void set_cmdline(::protozero::ConstChars chars) {
-    AppendBytes(FieldMetadata_Cmdline::kFieldId, chars.data, chars.size);
-  }
-  void set_cmdline(std::string value) {
-    static constexpr uint32_t field_id = FieldMetadata_Cmdline::kFieldId;
-    // Call the appropriate protozero::Message::Append(field_id, ...)
-    // method based on the type of the field.
-    ::protozero::internal::FieldWriter<
-      ::protozero::proto_utils::ProtoSchemaType::kString>
-        ::Append(*this, field_id, value);
-  }
-};
-
-} // Namespace.
-} // Namespace.
-} // Namespace.
-#endif  // Include guard.
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_active_processes.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_ACTIVE_PROCESSES_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_ACTIVE_PROCESSES_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeActiveProcesses;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT ChromeActiveProcesses : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kPidFieldNumber = 1,
-  };
-
-  ChromeActiveProcesses();
-  ~ChromeActiveProcesses() override;
-  ChromeActiveProcesses(ChromeActiveProcesses&&) noexcept;
-  ChromeActiveProcesses& operator=(ChromeActiveProcesses&&);
-  ChromeActiveProcesses(const ChromeActiveProcesses&);
-  ChromeActiveProcesses& operator=(const ChromeActiveProcesses&);
-  bool operator==(const ChromeActiveProcesses&) const;
-  bool operator!=(const ChromeActiveProcesses& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  const std::vector<int32_t>& pid() const { return pid_; }
-  std::vector<int32_t>* mutable_pid() { return &pid_; }
-  int pid_size() const { return static_cast<int>(pid_.size()); }
-  void clear_pid() { pid_.clear(); }
-  void add_pid(int32_t value) { pid_.emplace_back(value); }
-  int32_t* add_pid() { pid_.emplace_back(); return &pid_.back(); }
-
- private:
-  std::vector<int32_t> pid_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_ACTIVE_PROCESSES_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_application_state_info.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_APPLICATION_STATE_INFO_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_APPLICATION_STATE_INFO_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeApplicationStateInfo;
-enum ChromeApplicationStateInfo_ChromeApplicationState : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum ChromeApplicationStateInfo_ChromeApplicationState : int {
-  ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_UNKNOWN = 0,
-  ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_RUNNING_ACTIVITIES = 1,
-  ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_PAUSED_ACTIVITIES = 2,
-  ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_STOPPED_ACTIVITIES = 3,
-  ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES = 4,
-};
-
-class PERFETTO_EXPORT_COMPONENT ChromeApplicationStateInfo : public ::protozero::CppMessageObj {
- public:
-  using ChromeApplicationState = ChromeApplicationStateInfo_ChromeApplicationState;
-  static constexpr auto APPLICATION_STATE_UNKNOWN = ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_UNKNOWN;
-  static constexpr auto APPLICATION_STATE_HAS_RUNNING_ACTIVITIES = ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_RUNNING_ACTIVITIES;
-  static constexpr auto APPLICATION_STATE_HAS_PAUSED_ACTIVITIES = ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_PAUSED_ACTIVITIES;
-  static constexpr auto APPLICATION_STATE_HAS_STOPPED_ACTIVITIES = ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_STOPPED_ACTIVITIES;
-  static constexpr auto APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES = ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES;
-  static constexpr auto ChromeApplicationState_MIN = ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_UNKNOWN;
-  static constexpr auto ChromeApplicationState_MAX = ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES;
-  enum FieldNumbers {
-    kApplicationStateFieldNumber = 1,
-  };
-
-  ChromeApplicationStateInfo();
-  ~ChromeApplicationStateInfo() override;
-  ChromeApplicationStateInfo(ChromeApplicationStateInfo&&) noexcept;
-  ChromeApplicationStateInfo& operator=(ChromeApplicationStateInfo&&);
-  ChromeApplicationStateInfo(const ChromeApplicationStateInfo&);
-  ChromeApplicationStateInfo& operator=(const ChromeApplicationStateInfo&);
-  bool operator==(const ChromeApplicationStateInfo&) const;
-  bool operator!=(const ChromeApplicationStateInfo& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_application_state() const { return _has_field_[1]; }
-  ChromeApplicationStateInfo_ChromeApplicationState application_state() const { return application_state_; }
-  void set_application_state(ChromeApplicationStateInfo_ChromeApplicationState value) { application_state_ = value; _has_field_.set(1); }
-
- private:
-  ChromeApplicationStateInfo_ChromeApplicationState application_state_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_APPLICATION_STATE_INFO_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_compositor_scheduler_state.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_COMPOSITOR_SCHEDULER_STATE_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_COMPOSITOR_SCHEDULER_STATE_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class CompositorTimingHistory;
-class BeginFrameSourceState;
-class BeginFrameArgs;
-class SourceLocation;
-class BeginFrameObserverState;
-class BeginImplFrameArgs;
-class BeginImplFrameArgs_TimestampsInUs;
-class ChromeCompositorStateMachine;
-class ChromeCompositorStateMachine_MinorState;
-class ChromeCompositorStateMachine_MajorState;
-class ChromeCompositorSchedulerState;
-enum ChromeCompositorSchedulerAction : int;
-enum BeginFrameArgs_BeginFrameArgsType : int;
-enum BeginImplFrameArgs_State : int;
-enum ChromeCompositorStateMachine_MinorState_TreePriority : int;
-enum ChromeCompositorStateMachine_MinorState_ScrollHandlerState : int;
-enum ChromeCompositorStateMachine_MajorState_BeginImplFrameState : int;
-enum ChromeCompositorStateMachine_MajorState_BeginMainFrameState : int;
-enum ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState : int;
-enum ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState : int;
-enum ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum ChromeCompositorSchedulerAction : int {
-  CC_SCHEDULER_ACTION_UNSPECIFIED = 0,
-  CC_SCHEDULER_ACTION_NONE = 1,
-  CC_SCHEDULER_ACTION_SEND_BEGIN_MAIN_FRAME = 2,
-  CC_SCHEDULER_ACTION_COMMIT = 3,
-  CC_SCHEDULER_ACTION_ACTIVATE_SYNC_TREE = 4,
-  CC_SCHEDULER_ACTION_DRAW_IF_POSSIBLE = 5,
-  CC_SCHEDULER_ACTION_DRAW_FORCED = 6,
-  CC_SCHEDULER_ACTION_DRAW_ABORT = 7,
-  CC_SCHEDULER_ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION = 8,
-  CC_SCHEDULER_ACTION_PREPARE_TILES = 9,
-  CC_SCHEDULER_ACTION_INVALIDATE_LAYER_TREE_FRAME_SINK = 10,
-  CC_SCHEDULER_ACTION_PERFORM_IMPL_SIDE_INVALIDATION = 11,
-  CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_UNTIL = 12,
-  CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_SOON = 13,
-};
-enum BeginFrameArgs_BeginFrameArgsType : int {
-  BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED = 0,
-  BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_INVALID = 1,
-  BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_NORMAL = 2,
-  BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_MISSED = 3,
-};
-enum BeginImplFrameArgs_State : int {
-  BeginImplFrameArgs_State_BEGIN_FRAME_FINISHED = 0,
-  BeginImplFrameArgs_State_BEGIN_FRAME_USING = 1,
-};
-enum ChromeCompositorStateMachine_MinorState_TreePriority : int {
-  ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_UNSPECIFIED = 0,
-  ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES = 1,
-  ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY = 2,
-  ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY = 3,
-};
-enum ChromeCompositorStateMachine_MinorState_ScrollHandlerState : int {
-  ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_HANDLER_UNSPECIFIED = 0,
-  ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_AFFECTS_SCROLL_HANDLER = 1,
-  ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER = 2,
-};
-enum ChromeCompositorStateMachine_MajorState_BeginImplFrameState : int {
-  ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_UNSPECIFIED = 0,
-  ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_IDLE = 1,
-  ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME = 2,
-  ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_INSIDE_DEADLINE = 3,
-};
-enum ChromeCompositorStateMachine_MajorState_BeginMainFrameState : int {
-  ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_UNSPECIFIED = 0,
-  ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_IDLE = 1,
-  ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_SENT = 2,
-  ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_READY_TO_COMMIT = 3,
-};
-enum ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState : int {
-  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_UNSPECIFIED = 0,
-  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_NONE = 1,
-  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_ACTIVE = 2,
-  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_CREATING = 3,
-  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT = 4,
-  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION = 5,
-};
-enum ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState : int {
-  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_UNSPECIFIED = 0,
-  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_IDLE = 1,
-  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_COMMIT = 2,
-  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_ACTIVATION = 3,
-  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_DRAW = 4,
-};
-enum ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode : int {
-  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_UNSPECIFIED = 0,
-  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_NONE = 1,
-  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_IMMEDIATE = 2,
-  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_REGULAR = 3,
-  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_LATE = 4,
-  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_BLOCKED = 5,
-};
-
-class PERFETTO_EXPORT_COMPONENT CompositorTimingHistory : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kBeginMainFrameQueueCriticalEstimateDeltaUsFieldNumber = 1,
-    kBeginMainFrameQueueNotCriticalEstimateDeltaUsFieldNumber = 2,
-    kBeginMainFrameStartToReadyToCommitEstimateDeltaUsFieldNumber = 3,
-    kCommitToReadyToActivateEstimateDeltaUsFieldNumber = 4,
-    kPrepareTilesEstimateDeltaUsFieldNumber = 5,
-    kActivateEstimateDeltaUsFieldNumber = 6,
-    kDrawEstimateDeltaUsFieldNumber = 7,
-  };
-
-  CompositorTimingHistory();
-  ~CompositorTimingHistory() override;
-  CompositorTimingHistory(CompositorTimingHistory&&) noexcept;
-  CompositorTimingHistory& operator=(CompositorTimingHistory&&);
-  CompositorTimingHistory(const CompositorTimingHistory&);
-  CompositorTimingHistory& operator=(const CompositorTimingHistory&);
-  bool operator==(const CompositorTimingHistory&) const;
-  bool operator!=(const CompositorTimingHistory& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_begin_main_frame_queue_critical_estimate_delta_us() const { return _has_field_[1]; }
-  int64_t begin_main_frame_queue_critical_estimate_delta_us() const { return begin_main_frame_queue_critical_estimate_delta_us_; }
-  void set_begin_main_frame_queue_critical_estimate_delta_us(int64_t value) { begin_main_frame_queue_critical_estimate_delta_us_ = value; _has_field_.set(1); }
-
-  bool has_begin_main_frame_queue_not_critical_estimate_delta_us() const { return _has_field_[2]; }
-  int64_t begin_main_frame_queue_not_critical_estimate_delta_us() const { return begin_main_frame_queue_not_critical_estimate_delta_us_; }
-  void set_begin_main_frame_queue_not_critical_estimate_delta_us(int64_t value) { begin_main_frame_queue_not_critical_estimate_delta_us_ = value; _has_field_.set(2); }
-
-  bool has_begin_main_frame_start_to_ready_to_commit_estimate_delta_us() const { return _has_field_[3]; }
-  int64_t begin_main_frame_start_to_ready_to_commit_estimate_delta_us() const { return begin_main_frame_start_to_ready_to_commit_estimate_delta_us_; }
-  void set_begin_main_frame_start_to_ready_to_commit_estimate_delta_us(int64_t value) { begin_main_frame_start_to_ready_to_commit_estimate_delta_us_ = value; _has_field_.set(3); }
-
-  bool has_commit_to_ready_to_activate_estimate_delta_us() const { return _has_field_[4]; }
-  int64_t commit_to_ready_to_activate_estimate_delta_us() const { return commit_to_ready_to_activate_estimate_delta_us_; }
-  void set_commit_to_ready_to_activate_estimate_delta_us(int64_t value) { commit_to_ready_to_activate_estimate_delta_us_ = value; _has_field_.set(4); }
-
-  bool has_prepare_tiles_estimate_delta_us() const { return _has_field_[5]; }
-  int64_t prepare_tiles_estimate_delta_us() const { return prepare_tiles_estimate_delta_us_; }
-  void set_prepare_tiles_estimate_delta_us(int64_t value) { prepare_tiles_estimate_delta_us_ = value; _has_field_.set(5); }
-
-  bool has_activate_estimate_delta_us() const { return _has_field_[6]; }
-  int64_t activate_estimate_delta_us() const { return activate_estimate_delta_us_; }
-  void set_activate_estimate_delta_us(int64_t value) { activate_estimate_delta_us_ = value; _has_field_.set(6); }
-
-  bool has_draw_estimate_delta_us() const { return _has_field_[7]; }
-  int64_t draw_estimate_delta_us() const { return draw_estimate_delta_us_; }
-  void set_draw_estimate_delta_us(int64_t value) { draw_estimate_delta_us_ = value; _has_field_.set(7); }
-
- private:
-  int64_t begin_main_frame_queue_critical_estimate_delta_us_{};
-  int64_t begin_main_frame_queue_not_critical_estimate_delta_us_{};
-  int64_t begin_main_frame_start_to_ready_to_commit_estimate_delta_us_{};
-  int64_t commit_to_ready_to_activate_estimate_delta_us_{};
-  int64_t prepare_tiles_estimate_delta_us_{};
-  int64_t activate_estimate_delta_us_{};
-  int64_t draw_estimate_delta_us_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<8> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT BeginFrameSourceState : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kSourceIdFieldNumber = 1,
-    kPausedFieldNumber = 2,
-    kNumObserversFieldNumber = 3,
-    kLastBeginFrameArgsFieldNumber = 4,
-  };
-
-  BeginFrameSourceState();
-  ~BeginFrameSourceState() override;
-  BeginFrameSourceState(BeginFrameSourceState&&) noexcept;
-  BeginFrameSourceState& operator=(BeginFrameSourceState&&);
-  BeginFrameSourceState(const BeginFrameSourceState&);
-  BeginFrameSourceState& operator=(const BeginFrameSourceState&);
-  bool operator==(const BeginFrameSourceState&) const;
-  bool operator!=(const BeginFrameSourceState& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_source_id() const { return _has_field_[1]; }
-  uint32_t source_id() const { return source_id_; }
-  void set_source_id(uint32_t value) { source_id_ = value; _has_field_.set(1); }
-
-  bool has_paused() const { return _has_field_[2]; }
-  bool paused() const { return paused_; }
-  void set_paused(bool value) { paused_ = value; _has_field_.set(2); }
-
-  bool has_num_observers() const { return _has_field_[3]; }
-  uint32_t num_observers() const { return num_observers_; }
-  void set_num_observers(uint32_t value) { num_observers_ = value; _has_field_.set(3); }
-
-  bool has_last_begin_frame_args() const { return _has_field_[4]; }
-  const BeginFrameArgs& last_begin_frame_args() const { return *last_begin_frame_args_; }
-  BeginFrameArgs* mutable_last_begin_frame_args() { _has_field_.set(4); return last_begin_frame_args_.get(); }
-
- private:
-  uint32_t source_id_{};
-  bool paused_{};
-  uint32_t num_observers_{};
-  ::protozero::CopyablePtr<BeginFrameArgs> last_begin_frame_args_;
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<5> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT BeginFrameArgs : public ::protozero::CppMessageObj {
- public:
-  using BeginFrameArgsType = BeginFrameArgs_BeginFrameArgsType;
-  static constexpr auto BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED = BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED;
-  static constexpr auto BEGIN_FRAME_ARGS_TYPE_INVALID = BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_INVALID;
-  static constexpr auto BEGIN_FRAME_ARGS_TYPE_NORMAL = BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_NORMAL;
-  static constexpr auto BEGIN_FRAME_ARGS_TYPE_MISSED = BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_MISSED;
-  static constexpr auto BeginFrameArgsType_MIN = BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED;
-  static constexpr auto BeginFrameArgsType_MAX = BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_MISSED;
-  enum FieldNumbers {
-    kTypeFieldNumber = 1,
-    kSourceIdFieldNumber = 2,
-    kSequenceNumberFieldNumber = 3,
-    kFrameTimeUsFieldNumber = 4,
-    kDeadlineUsFieldNumber = 5,
-    kIntervalDeltaUsFieldNumber = 6,
-    kOnCriticalPathFieldNumber = 7,
-    kAnimateOnlyFieldNumber = 8,
-    kSourceLocationIidFieldNumber = 9,
-    kSourceLocationFieldNumber = 10,
-    kFramesThrottledSinceLastFieldNumber = 12,
-  };
-
-  BeginFrameArgs();
-  ~BeginFrameArgs() override;
-  BeginFrameArgs(BeginFrameArgs&&) noexcept;
-  BeginFrameArgs& operator=(BeginFrameArgs&&);
-  BeginFrameArgs(const BeginFrameArgs&);
-  BeginFrameArgs& operator=(const BeginFrameArgs&);
-  bool operator==(const BeginFrameArgs&) const;
-  bool operator!=(const BeginFrameArgs& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_type() const { return _has_field_[1]; }
-  BeginFrameArgs_BeginFrameArgsType type() const { return type_; }
-  void set_type(BeginFrameArgs_BeginFrameArgsType value) { type_ = value; _has_field_.set(1); }
-
-  bool has_source_id() const { return _has_field_[2]; }
-  uint64_t source_id() const { return source_id_; }
-  void set_source_id(uint64_t value) { source_id_ = value; _has_field_.set(2); }
-
-  bool has_sequence_number() const { return _has_field_[3]; }
-  uint64_t sequence_number() const { return sequence_number_; }
-  void set_sequence_number(uint64_t value) { sequence_number_ = value; _has_field_.set(3); }
-
-  bool has_frame_time_us() const { return _has_field_[4]; }
-  int64_t frame_time_us() const { return frame_time_us_; }
-  void set_frame_time_us(int64_t value) { frame_time_us_ = value; _has_field_.set(4); }
-
-  bool has_deadline_us() const { return _has_field_[5]; }
-  int64_t deadline_us() const { return deadline_us_; }
-  void set_deadline_us(int64_t value) { deadline_us_ = value; _has_field_.set(5); }
-
-  bool has_interval_delta_us() const { return _has_field_[6]; }
-  int64_t interval_delta_us() const { return interval_delta_us_; }
-  void set_interval_delta_us(int64_t value) { interval_delta_us_ = value; _has_field_.set(6); }
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      AndroidEnergyEstimationBreakdown_EnergyUidBreakdown>;
 
-  bool has_on_critical_path() const { return _has_field_[7]; }
-  bool on_critical_path() const { return on_critical_path_; }
-  void set_on_critical_path(bool value) { on_critical_path_ = value; _has_field_.set(7); }
+  static constexpr FieldMetadata_EnergyUws kEnergyUws{};
+  void set_energy_uws(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EnergyUws::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+};
 
-  bool has_animate_only() const { return _has_field_[8]; }
-  bool animate_only() const { return animate_only_; }
-  void set_animate_only(bool value) { animate_only_ = value; _has_field_.set(8); }
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/power/android_entity_state_residency.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  bool has_source_location_iid() const { return _has_field_[9]; }
-  uint64_t source_location_iid() const { return source_location_iid_; }
-  void set_source_location_iid(uint64_t value) { source_location_iid_ = value; _has_field_.set(9); }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_POWER_ANDROID_ENTITY_STATE_RESIDENCY_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_POWER_ANDROID_ENTITY_STATE_RESIDENCY_PROTO_H_
 
-  bool has_source_location() const { return _has_field_[10]; }
-  const SourceLocation& source_location() const { return *source_location_; }
-  SourceLocation* mutable_source_location() { _has_field_.set(10); return source_location_.get(); }
+#include <stddef.h>
+#include <stdint.h>
 
-  bool has_frames_throttled_since_last() const { return _has_field_[12]; }
-  int64_t frames_throttled_since_last() const { return frames_throttled_since_last_; }
-  void set_frames_throttled_since_last(int64_t value) { frames_throttled_since_last_ = value; _has_field_.set(12); }
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
- private:
-  BeginFrameArgs_BeginFrameArgsType type_{};
-  uint64_t source_id_{};
-  uint64_t sequence_number_{};
-  int64_t frame_time_us_{};
-  int64_t deadline_us_{};
-  int64_t interval_delta_us_{};
-  bool on_critical_path_{};
-  bool animate_only_{};
-  uint64_t source_location_iid_{};
-  ::protozero::CopyablePtr<SourceLocation> source_location_;
-  int64_t frames_throttled_since_last_{};
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class EntityStateResidency_PowerEntityState;
+class EntityStateResidency_StateResidency;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-  std::bitset<13> _has_field_{};
+class EntityStateResidency_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  EntityStateResidency_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit EntityStateResidency_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit EntityStateResidency_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_power_entity_state() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> power_entity_state() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  bool has_residency() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> residency() const { return GetRepeated<::protozero::ConstBytes>(2); }
 };
 
-
-class PERFETTO_EXPORT_COMPONENT BeginFrameObserverState : public ::protozero::CppMessageObj {
+class EntityStateResidency : public ::protozero::Message {
  public:
-  enum FieldNumbers {
-    kDroppedBeginFrameArgsFieldNumber = 1,
-    kLastBeginFrameArgsFieldNumber = 2,
+  using Decoder = EntityStateResidency_Decoder;
+  enum : int32_t {
+    kPowerEntityStateFieldNumber = 1,
+    kResidencyFieldNumber = 2,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.EntityStateResidency"; }
 
-  BeginFrameObserverState();
-  ~BeginFrameObserverState() override;
-  BeginFrameObserverState(BeginFrameObserverState&&) noexcept;
-  BeginFrameObserverState& operator=(BeginFrameObserverState&&);
-  BeginFrameObserverState(const BeginFrameObserverState&);
-  BeginFrameObserverState& operator=(const BeginFrameObserverState&);
-  bool operator==(const BeginFrameObserverState&) const;
-  bool operator!=(const BeginFrameObserverState& other) const { return !(*this == other); }
+  using PowerEntityState = ::perfetto::protos::pbzero::EntityStateResidency_PowerEntityState;
+  using StateResidency = ::perfetto::protos::pbzero::EntityStateResidency_StateResidency;
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_PowerEntityState =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      EntityStateResidency_PowerEntityState,
+      EntityStateResidency>;
 
-  bool has_dropped_begin_frame_args() const { return _has_field_[1]; }
-  int64_t dropped_begin_frame_args() const { return dropped_begin_frame_args_; }
-  void set_dropped_begin_frame_args(int64_t value) { dropped_begin_frame_args_ = value; _has_field_.set(1); }
+  static constexpr FieldMetadata_PowerEntityState kPowerEntityState{};
+  template <typename T = EntityStateResidency_PowerEntityState> T* add_power_entity_state() {
+    return BeginNestedMessage<T>(1);
+  }
 
-  bool has_last_begin_frame_args() const { return _has_field_[2]; }
-  const BeginFrameArgs& last_begin_frame_args() const { return *last_begin_frame_args_; }
-  BeginFrameArgs* mutable_last_begin_frame_args() { _has_field_.set(2); return last_begin_frame_args_.get(); }
 
- private:
-  int64_t dropped_begin_frame_args_{};
-  ::protozero::CopyablePtr<BeginFrameArgs> last_begin_frame_args_;
+  using FieldMetadata_Residency =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      EntityStateResidency_StateResidency,
+      EntityStateResidency>;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  static constexpr FieldMetadata_Residency kResidency{};
+  template <typename T = EntityStateResidency_StateResidency> T* add_residency() {
+    return BeginNestedMessage<T>(2);
+  }
 
-  std::bitset<3> _has_field_{};
 };
 
+class EntityStateResidency_StateResidency_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  EntityStateResidency_StateResidency_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit EntityStateResidency_StateResidency_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit EntityStateResidency_StateResidency_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_entity_index() const { return at<1>().valid(); }
+  int32_t entity_index() const { return at<1>().as_int32(); }
+  bool has_state_index() const { return at<2>().valid(); }
+  int32_t state_index() const { return at<2>().as_int32(); }
+  bool has_total_time_in_state_ms() const { return at<3>().valid(); }
+  uint64_t total_time_in_state_ms() const { return at<3>().as_uint64(); }
+  bool has_total_state_entry_count() const { return at<4>().valid(); }
+  uint64_t total_state_entry_count() const { return at<4>().as_uint64(); }
+  bool has_last_entry_timestamp_ms() const { return at<5>().valid(); }
+  uint64_t last_entry_timestamp_ms() const { return at<5>().as_uint64(); }
+};
 
-class PERFETTO_EXPORT_COMPONENT BeginImplFrameArgs : public ::protozero::CppMessageObj {
+class EntityStateResidency_StateResidency : public ::protozero::Message {
  public:
-  using TimestampsInUs = BeginImplFrameArgs_TimestampsInUs;
-  using State = BeginImplFrameArgs_State;
-  static constexpr auto BEGIN_FRAME_FINISHED = BeginImplFrameArgs_State_BEGIN_FRAME_FINISHED;
-  static constexpr auto BEGIN_FRAME_USING = BeginImplFrameArgs_State_BEGIN_FRAME_USING;
-  static constexpr auto State_MIN = BeginImplFrameArgs_State_BEGIN_FRAME_FINISHED;
-  static constexpr auto State_MAX = BeginImplFrameArgs_State_BEGIN_FRAME_USING;
-  enum FieldNumbers {
-    kUpdatedAtUsFieldNumber = 1,
-    kFinishedAtUsFieldNumber = 2,
-    kStateFieldNumber = 3,
-    kCurrentArgsFieldNumber = 4,
-    kLastArgsFieldNumber = 5,
-    kTimestampsInUsFieldNumber = 6,
+  using Decoder = EntityStateResidency_StateResidency_Decoder;
+  enum : int32_t {
+    kEntityIndexFieldNumber = 1,
+    kStateIndexFieldNumber = 2,
+    kTotalTimeInStateMsFieldNumber = 3,
+    kTotalStateEntryCountFieldNumber = 4,
+    kLastEntryTimestampMsFieldNumber = 5,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.EntityStateResidency.StateResidency"; }
 
-  BeginImplFrameArgs();
-  ~BeginImplFrameArgs() override;
-  BeginImplFrameArgs(BeginImplFrameArgs&&) noexcept;
-  BeginImplFrameArgs& operator=(BeginImplFrameArgs&&);
-  BeginImplFrameArgs(const BeginImplFrameArgs&);
-  BeginImplFrameArgs& operator=(const BeginImplFrameArgs&);
-  bool operator==(const BeginImplFrameArgs&) const;
-  bool operator!=(const BeginImplFrameArgs& other) const { return !(*this == other); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_EntityIndex =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      EntityStateResidency_StateResidency>;
 
-  bool has_updated_at_us() const { return _has_field_[1]; }
-  int64_t updated_at_us() const { return updated_at_us_; }
-  void set_updated_at_us(int64_t value) { updated_at_us_ = value; _has_field_.set(1); }
+  static constexpr FieldMetadata_EntityIndex kEntityIndex{};
+  void set_entity_index(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EntityIndex::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_finished_at_us() const { return _has_field_[2]; }
-  int64_t finished_at_us() const { return finished_at_us_; }
-  void set_finished_at_us(int64_t value) { finished_at_us_ = value; _has_field_.set(2); }
+  using FieldMetadata_StateIndex =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      EntityStateResidency_StateResidency>;
 
-  bool has_state() const { return _has_field_[3]; }
-  BeginImplFrameArgs_State state() const { return state_; }
-  void set_state(BeginImplFrameArgs_State value) { state_ = value; _has_field_.set(3); }
+  static constexpr FieldMetadata_StateIndex kStateIndex{};
+  void set_state_index(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StateIndex::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_current_args() const { return _has_field_[4]; }
-  const BeginFrameArgs& current_args() const { return *current_args_; }
-  BeginFrameArgs* mutable_current_args() { _has_field_.set(4); return current_args_.get(); }
+  using FieldMetadata_TotalTimeInStateMs =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      EntityStateResidency_StateResidency>;
 
-  bool has_last_args() const { return _has_field_[5]; }
-  const BeginFrameArgs& last_args() const { return *last_args_; }
-  BeginFrameArgs* mutable_last_args() { _has_field_.set(5); return last_args_.get(); }
+  static constexpr FieldMetadata_TotalTimeInStateMs kTotalTimeInStateMs{};
+  void set_total_time_in_state_ms(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TotalTimeInStateMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_timestamps_in_us() const { return _has_field_[6]; }
-  const BeginImplFrameArgs_TimestampsInUs& timestamps_in_us() const { return *timestamps_in_us_; }
-  BeginImplFrameArgs_TimestampsInUs* mutable_timestamps_in_us() { _has_field_.set(6); return timestamps_in_us_.get(); }
+  using FieldMetadata_TotalStateEntryCount =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      EntityStateResidency_StateResidency>;
 
- private:
-  int64_t updated_at_us_{};
-  int64_t finished_at_us_{};
-  BeginImplFrameArgs_State state_{};
-  ::protozero::CopyablePtr<BeginFrameArgs> current_args_;
-  ::protozero::CopyablePtr<BeginFrameArgs> last_args_;
-  ::protozero::CopyablePtr<BeginImplFrameArgs_TimestampsInUs> timestamps_in_us_;
+  static constexpr FieldMetadata_TotalStateEntryCount kTotalStateEntryCount{};
+  void set_total_state_entry_count(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TotalStateEntryCount::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_LastEntryTimestampMs =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      EntityStateResidency_StateResidency>;
 
-  std::bitset<7> _has_field_{};
+  static constexpr FieldMetadata_LastEntryTimestampMs kLastEntryTimestampMs{};
+  void set_last_entry_timestamp_ms(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_LastEntryTimestampMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 };
 
+class EntityStateResidency_PowerEntityState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  EntityStateResidency_PowerEntityState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit EntityStateResidency_PowerEntityState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit EntityStateResidency_PowerEntityState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_entity_index() const { return at<1>().valid(); }
+  int32_t entity_index() const { return at<1>().as_int32(); }
+  bool has_state_index() const { return at<2>().valid(); }
+  int32_t state_index() const { return at<2>().as_int32(); }
+  bool has_entity_name() const { return at<3>().valid(); }
+  ::protozero::ConstChars entity_name() const { return at<3>().as_string(); }
+  bool has_state_name() const { return at<4>().valid(); }
+  ::protozero::ConstChars state_name() const { return at<4>().as_string(); }
+};
 
-class PERFETTO_EXPORT_COMPONENT BeginImplFrameArgs_TimestampsInUs : public ::protozero::CppMessageObj {
+class EntityStateResidency_PowerEntityState : public ::protozero::Message {
  public:
-  enum FieldNumbers {
-    kIntervalDeltaFieldNumber = 1,
-    kNowToDeadlineDeltaFieldNumber = 2,
-    kFrameTimeToNowDeltaFieldNumber = 3,
-    kFrameTimeToDeadlineDeltaFieldNumber = 4,
-    kNowFieldNumber = 5,
-    kFrameTimeFieldNumber = 6,
-    kDeadlineFieldNumber = 7,
+  using Decoder = EntityStateResidency_PowerEntityState_Decoder;
+  enum : int32_t {
+    kEntityIndexFieldNumber = 1,
+    kStateIndexFieldNumber = 2,
+    kEntityNameFieldNumber = 3,
+    kStateNameFieldNumber = 4,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.EntityStateResidency.PowerEntityState"; }
 
-  BeginImplFrameArgs_TimestampsInUs();
-  ~BeginImplFrameArgs_TimestampsInUs() override;
-  BeginImplFrameArgs_TimestampsInUs(BeginImplFrameArgs_TimestampsInUs&&) noexcept;
-  BeginImplFrameArgs_TimestampsInUs& operator=(BeginImplFrameArgs_TimestampsInUs&&);
-  BeginImplFrameArgs_TimestampsInUs(const BeginImplFrameArgs_TimestampsInUs&);
-  BeginImplFrameArgs_TimestampsInUs& operator=(const BeginImplFrameArgs_TimestampsInUs&);
-  bool operator==(const BeginImplFrameArgs_TimestampsInUs&) const;
-  bool operator!=(const BeginImplFrameArgs_TimestampsInUs& other) const { return !(*this == other); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_EntityIndex =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      EntityStateResidency_PowerEntityState>;
 
-  bool has_interval_delta() const { return _has_field_[1]; }
-  int64_t interval_delta() const { return interval_delta_; }
-  void set_interval_delta(int64_t value) { interval_delta_ = value; _has_field_.set(1); }
+  static constexpr FieldMetadata_EntityIndex kEntityIndex{};
+  void set_entity_index(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EntityIndex::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_now_to_deadline_delta() const { return _has_field_[2]; }
-  int64_t now_to_deadline_delta() const { return now_to_deadline_delta_; }
-  void set_now_to_deadline_delta(int64_t value) { now_to_deadline_delta_ = value; _has_field_.set(2); }
+  using FieldMetadata_StateIndex =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      EntityStateResidency_PowerEntityState>;
 
-  bool has_frame_time_to_now_delta() const { return _has_field_[3]; }
-  int64_t frame_time_to_now_delta() const { return frame_time_to_now_delta_; }
-  void set_frame_time_to_now_delta(int64_t value) { frame_time_to_now_delta_ = value; _has_field_.set(3); }
+  static constexpr FieldMetadata_StateIndex kStateIndex{};
+  void set_state_index(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StateIndex::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_frame_time_to_deadline_delta() const { return _has_field_[4]; }
-  int64_t frame_time_to_deadline_delta() const { return frame_time_to_deadline_delta_; }
-  void set_frame_time_to_deadline_delta(int64_t value) { frame_time_to_deadline_delta_ = value; _has_field_.set(4); }
+  using FieldMetadata_EntityName =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      EntityStateResidency_PowerEntityState>;
 
-  bool has_now() const { return _has_field_[5]; }
-  int64_t now() const { return now_; }
-  void set_now(int64_t value) { now_ = value; _has_field_.set(5); }
+  static constexpr FieldMetadata_EntityName kEntityName{};
+  void set_entity_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_EntityName::kFieldId, data, size);
+  }
+  void set_entity_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_EntityName::kFieldId, chars.data, chars.size);
+  }
+  void set_entity_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_EntityName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_frame_time() const { return _has_field_[6]; }
-  int64_t frame_time() const { return frame_time_; }
-  void set_frame_time(int64_t value) { frame_time_ = value; _has_field_.set(6); }
+  using FieldMetadata_StateName =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      EntityStateResidency_PowerEntityState>;
 
-  bool has_deadline() const { return _has_field_[7]; }
-  int64_t deadline() const { return deadline_; }
-  void set_deadline(int64_t value) { deadline_ = value; _has_field_.set(7); }
+  static constexpr FieldMetadata_StateName kStateName{};
+  void set_state_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_StateName::kFieldId, data, size);
+  }
+  void set_state_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_StateName::kFieldId, chars.data, chars.size);
+  }
+  void set_state_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_StateName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
 
- private:
-  int64_t interval_delta_{};
-  int64_t now_to_deadline_delta_{};
-  int64_t frame_time_to_now_delta_{};
-  int64_t frame_time_to_deadline_delta_{};
-  int64_t now_{};
-  int64_t frame_time_{};
-  int64_t deadline_{};
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/power/battery_counters.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_POWER_BATTERY_COUNTERS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_POWER_BATTERY_COUNTERS_PROTO_H_
 
-  std::bitset<8> _has_field_{};
-};
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
 
-class PERFETTO_EXPORT_COMPONENT ChromeCompositorStateMachine : public ::protozero::CppMessageObj {
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class BatteryCounters_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
  public:
-  using MajorState = ChromeCompositorStateMachine_MajorState;
-  using MinorState = ChromeCompositorStateMachine_MinorState;
-  enum FieldNumbers {
-    kMajorStateFieldNumber = 1,
-    kMinorStateFieldNumber = 2,
+  BatteryCounters_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit BatteryCounters_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit BatteryCounters_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_charge_counter_uah() const { return at<1>().valid(); }
+  int64_t charge_counter_uah() const { return at<1>().as_int64(); }
+  bool has_capacity_percent() const { return at<2>().valid(); }
+  float capacity_percent() const { return at<2>().as_float(); }
+  bool has_current_ua() const { return at<3>().valid(); }
+  int64_t current_ua() const { return at<3>().as_int64(); }
+  bool has_current_avg_ua() const { return at<4>().valid(); }
+  int64_t current_avg_ua() const { return at<4>().as_int64(); }
+  bool has_name() const { return at<5>().valid(); }
+  ::protozero::ConstChars name() const { return at<5>().as_string(); }
+  bool has_energy_counter_uwh() const { return at<6>().valid(); }
+  int64_t energy_counter_uwh() const { return at<6>().as_int64(); }
+  bool has_voltage_uv() const { return at<7>().valid(); }
+  int64_t voltage_uv() const { return at<7>().as_int64(); }
+};
+
+class BatteryCounters : public ::protozero::Message {
+ public:
+  using Decoder = BatteryCounters_Decoder;
+  enum : int32_t {
+    kChargeCounterUahFieldNumber = 1,
+    kCapacityPercentFieldNumber = 2,
+    kCurrentUaFieldNumber = 3,
+    kCurrentAvgUaFieldNumber = 4,
+    kNameFieldNumber = 5,
+    kEnergyCounterUwhFieldNumber = 6,
+    kVoltageUvFieldNumber = 7,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.BatteryCounters"; }
 
-  ChromeCompositorStateMachine();
-  ~ChromeCompositorStateMachine() override;
-  ChromeCompositorStateMachine(ChromeCompositorStateMachine&&) noexcept;
-  ChromeCompositorStateMachine& operator=(ChromeCompositorStateMachine&&);
-  ChromeCompositorStateMachine(const ChromeCompositorStateMachine&);
-  ChromeCompositorStateMachine& operator=(const ChromeCompositorStateMachine&);
-  bool operator==(const ChromeCompositorStateMachine&) const;
-  bool operator!=(const ChromeCompositorStateMachine& other) const { return !(*this == other); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_ChargeCounterUah =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      BatteryCounters>;
 
-  bool has_major_state() const { return _has_field_[1]; }
-  const ChromeCompositorStateMachine_MajorState& major_state() const { return *major_state_; }
-  ChromeCompositorStateMachine_MajorState* mutable_major_state() { _has_field_.set(1); return major_state_.get(); }
+  static constexpr FieldMetadata_ChargeCounterUah kChargeCounterUah{};
+  void set_charge_counter_uah(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ChargeCounterUah::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_minor_state() const { return _has_field_[2]; }
-  const ChromeCompositorStateMachine_MinorState& minor_state() const { return *minor_state_; }
-  ChromeCompositorStateMachine_MinorState* mutable_minor_state() { _has_field_.set(2); return minor_state_.get(); }
+  using FieldMetadata_CapacityPercent =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kFloat,
+      float,
+      BatteryCounters>;
 
- private:
-  ::protozero::CopyablePtr<ChromeCompositorStateMachine_MajorState> major_state_;
-  ::protozero::CopyablePtr<ChromeCompositorStateMachine_MinorState> minor_state_;
+  static constexpr FieldMetadata_CapacityPercent kCapacityPercent{};
+  void set_capacity_percent(float value) {
+    static constexpr uint32_t field_id = FieldMetadata_CapacityPercent::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kFloat>
+        ::Append(*this, field_id, value);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_CurrentUa =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      BatteryCounters>;
 
-  std::bitset<3> _has_field_{};
-};
+  static constexpr FieldMetadata_CurrentUa kCurrentUa{};
+  void set_current_ua(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CurrentUa::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
 
+  using FieldMetadata_CurrentAvgUa =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      BatteryCounters>;
 
-class PERFETTO_EXPORT_COMPONENT ChromeCompositorStateMachine_MinorState : public ::protozero::CppMessageObj {
- public:
-  using TreePriority = ChromeCompositorStateMachine_MinorState_TreePriority;
-  static constexpr auto TREE_PRIORITY_UNSPECIFIED = ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_UNSPECIFIED;
-  static constexpr auto TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES = ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES;
-  static constexpr auto TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY = ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY;
-  static constexpr auto TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY = ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY;
-  static constexpr auto TreePriority_MIN = ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_UNSPECIFIED;
-  static constexpr auto TreePriority_MAX = ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY;
-  using ScrollHandlerState = ChromeCompositorStateMachine_MinorState_ScrollHandlerState;
-  static constexpr auto SCROLL_HANDLER_UNSPECIFIED = ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_HANDLER_UNSPECIFIED;
-  static constexpr auto SCROLL_AFFECTS_SCROLL_HANDLER = ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_AFFECTS_SCROLL_HANDLER;
-  static constexpr auto SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER = ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER;
-  static constexpr auto ScrollHandlerState_MIN = ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_HANDLER_UNSPECIFIED;
-  static constexpr auto ScrollHandlerState_MAX = ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER;
-  enum FieldNumbers {
-    kCommitCountFieldNumber = 1,
-    kCurrentFrameNumberFieldNumber = 2,
-    kLastFrameNumberSubmitPerformedFieldNumber = 3,
-    kLastFrameNumberDrawPerformedFieldNumber = 4,
-    kLastFrameNumberBeginMainFrameSentFieldNumber = 5,
-    kDidDrawFieldNumber = 6,
-    kDidSendBeginMainFrameForCurrentFrameFieldNumber = 7,
-    kDidNotifyBeginMainFrameNotExpectedUntilFieldNumber = 8,
-    kDidNotifyBeginMainFrameNotExpectedSoonFieldNumber = 9,
-    kWantsBeginMainFrameNotExpectedFieldNumber = 10,
-    kDidCommitDuringFrameFieldNumber = 11,
-    kDidInvalidateLayerTreeFrameSinkFieldNumber = 12,
-    kDidPerformImplSideInvalidaionFieldNumber = 13,
-    kDidPrepareTilesFieldNumber = 14,
-    kConsecutiveCheckerboardAnimationsFieldNumber = 15,
-    kPendingSubmitFramesFieldNumber = 16,
-    kSubmitFramesWithCurrentLayerTreeFrameSinkFieldNumber = 17,
-    kNeedsRedrawFieldNumber = 18,
-    kNeedsPrepareTilesFieldNumber = 19,
-    kNeedsBeginMainFrameFieldNumber = 20,
-    kNeedsOneBeginImplFrameFieldNumber = 21,
-    kVisibleFieldNumber = 22,
-    kBeginFrameSourcePausedFieldNumber = 23,
-    kCanDrawFieldNumber = 24,
-    kResourcelessDrawFieldNumber = 25,
-    kHasPendingTreeFieldNumber = 26,
-    kPendingTreeIsReadyForActivationFieldNumber = 27,
-    kActiveTreeNeedsFirstDrawFieldNumber = 28,
-    kActiveTreeIsReadyToDrawFieldNumber = 29,
-    kDidCreateAndInitializeFirstLayerTreeFrameSinkFieldNumber = 30,
-    kTreePriorityFieldNumber = 31,
-    kScrollHandlerStateFieldNumber = 32,
-    kCriticalBeginMainFrameToActivateIsFastFieldNumber = 33,
-    kMainThreadMissedLastDeadlineFieldNumber = 34,
-    kVideoNeedsBeginFramesFieldNumber = 36,
-    kDeferBeginMainFrameFieldNumber = 37,
-    kLastCommitHadNoUpdatesFieldNumber = 38,
-    kDidDrawInLastFrameFieldNumber = 39,
-    kDidSubmitInLastFrameFieldNumber = 40,
-    kNeedsImplSideInvalidationFieldNumber = 41,
-    kCurrentPendingTreeIsImplSideFieldNumber = 42,
-    kPreviousPendingTreeWasImplSideFieldNumber = 43,
-    kProcessingAnimationWorkletsForActiveTreeFieldNumber = 44,
-    kProcessingAnimationWorkletsForPendingTreeFieldNumber = 45,
-    kProcessingPaintWorkletsForPendingTreeFieldNumber = 46,
-  };
+  static constexpr FieldMetadata_CurrentAvgUa kCurrentAvgUa{};
+  void set_current_avg_ua(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CurrentAvgUa::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
 
-  ChromeCompositorStateMachine_MinorState();
-  ~ChromeCompositorStateMachine_MinorState() override;
-  ChromeCompositorStateMachine_MinorState(ChromeCompositorStateMachine_MinorState&&) noexcept;
-  ChromeCompositorStateMachine_MinorState& operator=(ChromeCompositorStateMachine_MinorState&&);
-  ChromeCompositorStateMachine_MinorState(const ChromeCompositorStateMachine_MinorState&);
-  ChromeCompositorStateMachine_MinorState& operator=(const ChromeCompositorStateMachine_MinorState&);
-  bool operator==(const ChromeCompositorStateMachine_MinorState&) const;
-  bool operator!=(const ChromeCompositorStateMachine_MinorState& other) const { return !(*this == other); }
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      BatteryCounters>;
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_commit_count() const { return _has_field_[1]; }
-  int32_t commit_count() const { return commit_count_; }
-  void set_commit_count(int32_t value) { commit_count_ = value; _has_field_.set(1); }
+  using FieldMetadata_EnergyCounterUwh =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      BatteryCounters>;
 
-  bool has_current_frame_number() const { return _has_field_[2]; }
-  int32_t current_frame_number() const { return current_frame_number_; }
-  void set_current_frame_number(int32_t value) { current_frame_number_ = value; _has_field_.set(2); }
+  static constexpr FieldMetadata_EnergyCounterUwh kEnergyCounterUwh{};
+  void set_energy_counter_uwh(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_EnergyCounterUwh::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_last_frame_number_submit_performed() const { return _has_field_[3]; }
-  int32_t last_frame_number_submit_performed() const { return last_frame_number_submit_performed_; }
-  void set_last_frame_number_submit_performed(int32_t value) { last_frame_number_submit_performed_ = value; _has_field_.set(3); }
+  using FieldMetadata_VoltageUv =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      BatteryCounters>;
 
-  bool has_last_frame_number_draw_performed() const { return _has_field_[4]; }
-  int32_t last_frame_number_draw_performed() const { return last_frame_number_draw_performed_; }
-  void set_last_frame_number_draw_performed(int32_t value) { last_frame_number_draw_performed_ = value; _has_field_.set(4); }
+  static constexpr FieldMetadata_VoltageUv kVoltageUv{};
+  void set_voltage_uv(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VoltageUv::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
+};
 
-  bool has_last_frame_number_begin_main_frame_sent() const { return _has_field_[5]; }
-  int32_t last_frame_number_begin_main_frame_sent() const { return last_frame_number_begin_main_frame_sent_; }
-  void set_last_frame_number_begin_main_frame_sent(int32_t value) { last_frame_number_begin_main_frame_sent_ = value; _has_field_.set(5); }
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/power/power_rails.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  bool has_did_draw() const { return _has_field_[6]; }
-  bool did_draw() const { return did_draw_; }
-  void set_did_draw(bool value) { did_draw_ = value; _has_field_.set(6); }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_POWER_POWER_RAILS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_POWER_POWER_RAILS_PROTO_H_
 
-  bool has_did_send_begin_main_frame_for_current_frame() const { return _has_field_[7]; }
-  bool did_send_begin_main_frame_for_current_frame() const { return did_send_begin_main_frame_for_current_frame_; }
-  void set_did_send_begin_main_frame_for_current_frame(bool value) { did_send_begin_main_frame_for_current_frame_ = value; _has_field_.set(7); }
+#include <stddef.h>
+#include <stdint.h>
 
-  bool has_did_notify_begin_main_frame_not_expected_until() const { return _has_field_[8]; }
-  bool did_notify_begin_main_frame_not_expected_until() const { return did_notify_begin_main_frame_not_expected_until_; }
-  void set_did_notify_begin_main_frame_not_expected_until(bool value) { did_notify_begin_main_frame_not_expected_until_ = value; _has_field_.set(8); }
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  bool has_did_notify_begin_main_frame_not_expected_soon() const { return _has_field_[9]; }
-  bool did_notify_begin_main_frame_not_expected_soon() const { return did_notify_begin_main_frame_not_expected_soon_; }
-  void set_did_notify_begin_main_frame_not_expected_soon(bool value) { did_notify_begin_main_frame_not_expected_soon_ = value; _has_field_.set(9); }
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class PowerRails_EnergyData;
+class PowerRails_RailDescriptor;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-  bool has_wants_begin_main_frame_not_expected() const { return _has_field_[10]; }
-  bool wants_begin_main_frame_not_expected() const { return wants_begin_main_frame_not_expected_; }
-  void set_wants_begin_main_frame_not_expected(bool value) { wants_begin_main_frame_not_expected_ = value; _has_field_.set(10); }
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-  bool has_did_commit_during_frame() const { return _has_field_[11]; }
-  bool did_commit_during_frame() const { return did_commit_during_frame_; }
-  void set_did_commit_during_frame(bool value) { did_commit_during_frame_ = value; _has_field_.set(11); }
+class PowerRails_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  PowerRails_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PowerRails_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PowerRails_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_rail_descriptor() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> rail_descriptor() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  bool has_energy_data() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> energy_data() const { return GetRepeated<::protozero::ConstBytes>(2); }
+  bool has_session_uuid() const { return at<3>().valid(); }
+  uint64_t session_uuid() const { return at<3>().as_uint64(); }
+};
 
-  bool has_did_invalidate_layer_tree_frame_sink() const { return _has_field_[12]; }
-  bool did_invalidate_layer_tree_frame_sink() const { return did_invalidate_layer_tree_frame_sink_; }
-  void set_did_invalidate_layer_tree_frame_sink(bool value) { did_invalidate_layer_tree_frame_sink_ = value; _has_field_.set(12); }
+class PowerRails : public ::protozero::Message {
+ public:
+  using Decoder = PowerRails_Decoder;
+  enum : int32_t {
+    kRailDescriptorFieldNumber = 1,
+    kEnergyDataFieldNumber = 2,
+    kSessionUuidFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.PowerRails"; }
 
-  bool has_did_perform_impl_side_invalidaion() const { return _has_field_[13]; }
-  bool did_perform_impl_side_invalidaion() const { return did_perform_impl_side_invalidaion_; }
-  void set_did_perform_impl_side_invalidaion(bool value) { did_perform_impl_side_invalidaion_ = value; _has_field_.set(13); }
+  using RailDescriptor = ::perfetto::protos::pbzero::PowerRails_RailDescriptor;
+  using EnergyData = ::perfetto::protos::pbzero::PowerRails_EnergyData;
 
-  bool has_did_prepare_tiles() const { return _has_field_[14]; }
-  bool did_prepare_tiles() const { return did_prepare_tiles_; }
-  void set_did_prepare_tiles(bool value) { did_prepare_tiles_ = value; _has_field_.set(14); }
+  using FieldMetadata_RailDescriptor =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PowerRails_RailDescriptor,
+      PowerRails>;
 
-  bool has_consecutive_checkerboard_animations() const { return _has_field_[15]; }
-  int32_t consecutive_checkerboard_animations() const { return consecutive_checkerboard_animations_; }
-  void set_consecutive_checkerboard_animations(int32_t value) { consecutive_checkerboard_animations_ = value; _has_field_.set(15); }
+  static constexpr FieldMetadata_RailDescriptor kRailDescriptor{};
+  template <typename T = PowerRails_RailDescriptor> T* add_rail_descriptor() {
+    return BeginNestedMessage<T>(1);
+  }
 
-  bool has_pending_submit_frames() const { return _has_field_[16]; }
-  int32_t pending_submit_frames() const { return pending_submit_frames_; }
-  void set_pending_submit_frames(int32_t value) { pending_submit_frames_ = value; _has_field_.set(16); }
 
-  bool has_submit_frames_with_current_layer_tree_frame_sink() const { return _has_field_[17]; }
-  int32_t submit_frames_with_current_layer_tree_frame_sink() const { return submit_frames_with_current_layer_tree_frame_sink_; }
-  void set_submit_frames_with_current_layer_tree_frame_sink(int32_t value) { submit_frames_with_current_layer_tree_frame_sink_ = value; _has_field_.set(17); }
+  using FieldMetadata_EnergyData =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PowerRails_EnergyData,
+      PowerRails>;
 
-  bool has_needs_redraw() const { return _has_field_[18]; }
-  bool needs_redraw() const { return needs_redraw_; }
-  void set_needs_redraw(bool value) { needs_redraw_ = value; _has_field_.set(18); }
+  static constexpr FieldMetadata_EnergyData kEnergyData{};
+  template <typename T = PowerRails_EnergyData> T* add_energy_data() {
+    return BeginNestedMessage<T>(2);
+  }
 
-  bool has_needs_prepare_tiles() const { return _has_field_[19]; }
-  bool needs_prepare_tiles() const { return needs_prepare_tiles_; }
-  void set_needs_prepare_tiles(bool value) { needs_prepare_tiles_ = value; _has_field_.set(19); }
 
-  bool has_needs_begin_main_frame() const { return _has_field_[20]; }
-  bool needs_begin_main_frame() const { return needs_begin_main_frame_; }
-  void set_needs_begin_main_frame(bool value) { needs_begin_main_frame_ = value; _has_field_.set(20); }
+  using FieldMetadata_SessionUuid =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      PowerRails>;
 
-  bool has_needs_one_begin_impl_frame() const { return _has_field_[21]; }
-  bool needs_one_begin_impl_frame() const { return needs_one_begin_impl_frame_; }
-  void set_needs_one_begin_impl_frame(bool value) { needs_one_begin_impl_frame_ = value; _has_field_.set(21); }
+  static constexpr FieldMetadata_SessionUuid kSessionUuid{};
+  void set_session_uuid(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SessionUuid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
 
-  bool has_visible() const { return _has_field_[22]; }
-  bool visible() const { return visible_; }
-  void set_visible(bool value) { visible_ = value; _has_field_.set(22); }
+class PowerRails_EnergyData_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  PowerRails_EnergyData_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PowerRails_EnergyData_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PowerRails_EnergyData_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_index() const { return at<1>().valid(); }
+  uint32_t index() const { return at<1>().as_uint32(); }
+  bool has_timestamp_ms() const { return at<2>().valid(); }
+  uint64_t timestamp_ms() const { return at<2>().as_uint64(); }
+  bool has_energy() const { return at<3>().valid(); }
+  uint64_t energy() const { return at<3>().as_uint64(); }
+};
 
-  bool has_begin_frame_source_paused() const { return _has_field_[23]; }
-  bool begin_frame_source_paused() const { return begin_frame_source_paused_; }
-  void set_begin_frame_source_paused(bool value) { begin_frame_source_paused_ = value; _has_field_.set(23); }
+class PowerRails_EnergyData : public ::protozero::Message {
+ public:
+  using Decoder = PowerRails_EnergyData_Decoder;
+  enum : int32_t {
+    kIndexFieldNumber = 1,
+    kTimestampMsFieldNumber = 2,
+    kEnergyFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.PowerRails.EnergyData"; }
 
-  bool has_can_draw() const { return _has_field_[24]; }
-  bool can_draw() const { return can_draw_; }
-  void set_can_draw(bool value) { can_draw_ = value; _has_field_.set(24); }
 
-  bool has_resourceless_draw() const { return _has_field_[25]; }
-  bool resourceless_draw() const { return resourceless_draw_; }
-  void set_resourceless_draw(bool value) { resourceless_draw_ = value; _has_field_.set(25); }
+  using FieldMetadata_Index =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      PowerRails_EnergyData>;
 
-  bool has_has_pending_tree() const { return _has_field_[26]; }
-  bool has_pending_tree() const { return has_pending_tree_; }
-  void set_has_pending_tree(bool value) { has_pending_tree_ = value; _has_field_.set(26); }
+  static constexpr FieldMetadata_Index kIndex{};
+  void set_index(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_pending_tree_is_ready_for_activation() const { return _has_field_[27]; }
-  bool pending_tree_is_ready_for_activation() const { return pending_tree_is_ready_for_activation_; }
-  void set_pending_tree_is_ready_for_activation(bool value) { pending_tree_is_ready_for_activation_ = value; _has_field_.set(27); }
+  using FieldMetadata_TimestampMs =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      PowerRails_EnergyData>;
 
-  bool has_active_tree_needs_first_draw() const { return _has_field_[28]; }
-  bool active_tree_needs_first_draw() const { return active_tree_needs_first_draw_; }
-  void set_active_tree_needs_first_draw(bool value) { active_tree_needs_first_draw_ = value; _has_field_.set(28); }
+  static constexpr FieldMetadata_TimestampMs kTimestampMs{};
+  void set_timestamp_ms(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimestampMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_active_tree_is_ready_to_draw() const { return _has_field_[29]; }
-  bool active_tree_is_ready_to_draw() const { return active_tree_is_ready_to_draw_; }
-  void set_active_tree_is_ready_to_draw(bool value) { active_tree_is_ready_to_draw_ = value; _has_field_.set(29); }
+  using FieldMetadata_Energy =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      PowerRails_EnergyData>;
 
-  bool has_did_create_and_initialize_first_layer_tree_frame_sink() const { return _has_field_[30]; }
-  bool did_create_and_initialize_first_layer_tree_frame_sink() const { return did_create_and_initialize_first_layer_tree_frame_sink_; }
-  void set_did_create_and_initialize_first_layer_tree_frame_sink(bool value) { did_create_and_initialize_first_layer_tree_frame_sink_ = value; _has_field_.set(30); }
+  static constexpr FieldMetadata_Energy kEnergy{};
+  void set_energy(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Energy::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
 
-  bool has_tree_priority() const { return _has_field_[31]; }
-  ChromeCompositorStateMachine_MinorState_TreePriority tree_priority() const { return tree_priority_; }
-  void set_tree_priority(ChromeCompositorStateMachine_MinorState_TreePriority value) { tree_priority_ = value; _has_field_.set(31); }
+class PowerRails_RailDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  PowerRails_RailDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit PowerRails_RailDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit PowerRails_RailDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_index() const { return at<1>().valid(); }
+  uint32_t index() const { return at<1>().as_uint32(); }
+  bool has_rail_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars rail_name() const { return at<2>().as_string(); }
+  bool has_subsys_name() const { return at<3>().valid(); }
+  ::protozero::ConstChars subsys_name() const { return at<3>().as_string(); }
+  bool has_sampling_rate() const { return at<4>().valid(); }
+  uint32_t sampling_rate() const { return at<4>().as_uint32(); }
+};
 
-  bool has_scroll_handler_state() const { return _has_field_[32]; }
-  ChromeCompositorStateMachine_MinorState_ScrollHandlerState scroll_handler_state() const { return scroll_handler_state_; }
-  void set_scroll_handler_state(ChromeCompositorStateMachine_MinorState_ScrollHandlerState value) { scroll_handler_state_ = value; _has_field_.set(32); }
+class PowerRails_RailDescriptor : public ::protozero::Message {
+ public:
+  using Decoder = PowerRails_RailDescriptor_Decoder;
+  enum : int32_t {
+    kIndexFieldNumber = 1,
+    kRailNameFieldNumber = 2,
+    kSubsysNameFieldNumber = 3,
+    kSamplingRateFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.PowerRails.RailDescriptor"; }
+
+
+  using FieldMetadata_Index =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      PowerRails_RailDescriptor>;
+
+  static constexpr FieldMetadata_Index kIndex{};
+  void set_index(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_RailName =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      PowerRails_RailDescriptor>;
+
+  static constexpr FieldMetadata_RailName kRailName{};
+  void set_rail_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_RailName::kFieldId, data, size);
+  }
+  void set_rail_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_RailName::kFieldId, chars.data, chars.size);
+  }
+  void set_rail_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_RailName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_SubsysName =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      PowerRails_RailDescriptor>;
+
+  static constexpr FieldMetadata_SubsysName kSubsysName{};
+  void set_subsys_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_SubsysName::kFieldId, data, size);
+  }
+  void set_subsys_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_SubsysName::kFieldId, chars.data, chars.size);
+  }
+  void set_subsys_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_SubsysName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_critical_begin_main_frame_to_activate_is_fast() const { return _has_field_[33]; }
-  bool critical_begin_main_frame_to_activate_is_fast() const { return critical_begin_main_frame_to_activate_is_fast_; }
-  void set_critical_begin_main_frame_to_activate_is_fast(bool value) { critical_begin_main_frame_to_activate_is_fast_ = value; _has_field_.set(33); }
+  using FieldMetadata_SamplingRate =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      PowerRails_RailDescriptor>;
 
-  bool has_main_thread_missed_last_deadline() const { return _has_field_[34]; }
-  bool main_thread_missed_last_deadline() const { return main_thread_missed_last_deadline_; }
-  void set_main_thread_missed_last_deadline(bool value) { main_thread_missed_last_deadline_ = value; _has_field_.set(34); }
+  static constexpr FieldMetadata_SamplingRate kSamplingRate{};
+  void set_sampling_rate(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SamplingRate::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
 
-  bool has_video_needs_begin_frames() const { return _has_field_[36]; }
-  bool video_needs_begin_frames() const { return video_needs_begin_frames_; }
-  void set_video_needs_begin_frames(bool value) { video_needs_begin_frames_ = value; _has_field_.set(36); }
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ps/process_stats.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  bool has_defer_begin_main_frame() const { return _has_field_[37]; }
-  bool defer_begin_main_frame() const { return defer_begin_main_frame_; }
-  void set_defer_begin_main_frame(bool value) { defer_begin_main_frame_ = value; _has_field_.set(37); }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PS_PROCESS_STATS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PS_PROCESS_STATS_PROTO_H_
 
-  bool has_last_commit_had_no_updates() const { return _has_field_[38]; }
-  bool last_commit_had_no_updates() const { return last_commit_had_no_updates_; }
-  void set_last_commit_had_no_updates(bool value) { last_commit_had_no_updates_ = value; _has_field_.set(38); }
+#include <stddef.h>
+#include <stdint.h>
 
-  bool has_did_draw_in_last_frame() const { return _has_field_[39]; }
-  bool did_draw_in_last_frame() const { return did_draw_in_last_frame_; }
-  void set_did_draw_in_last_frame(bool value) { did_draw_in_last_frame_ = value; _has_field_.set(39); }
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  bool has_did_submit_in_last_frame() const { return _has_field_[40]; }
-  bool did_submit_in_last_frame() const { return did_submit_in_last_frame_; }
-  void set_did_submit_in_last_frame(bool value) { did_submit_in_last_frame_ = value; _has_field_.set(40); }
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class ProcessStats_FDInfo;
+class ProcessStats_Process;
+class ProcessStats_Thread;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-  bool has_needs_impl_side_invalidation() const { return _has_field_[41]; }
-  bool needs_impl_side_invalidation() const { return needs_impl_side_invalidation_; }
-  void set_needs_impl_side_invalidation(bool value) { needs_impl_side_invalidation_ = value; _has_field_.set(41); }
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-  bool has_current_pending_tree_is_impl_side() const { return _has_field_[42]; }
-  bool current_pending_tree_is_impl_side() const { return current_pending_tree_is_impl_side_; }
-  void set_current_pending_tree_is_impl_side(bool value) { current_pending_tree_is_impl_side_ = value; _has_field_.set(42); }
+class ProcessStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  ProcessStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProcessStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProcessStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_processes() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> processes() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  bool has_collection_end_timestamp() const { return at<2>().valid(); }
+  uint64_t collection_end_timestamp() const { return at<2>().as_uint64(); }
+};
 
-  bool has_previous_pending_tree_was_impl_side() const { return _has_field_[43]; }
-  bool previous_pending_tree_was_impl_side() const { return previous_pending_tree_was_impl_side_; }
-  void set_previous_pending_tree_was_impl_side(bool value) { previous_pending_tree_was_impl_side_ = value; _has_field_.set(43); }
+class ProcessStats : public ::protozero::Message {
+ public:
+  using Decoder = ProcessStats_Decoder;
+  enum : int32_t {
+    kProcessesFieldNumber = 1,
+    kCollectionEndTimestampFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ProcessStats"; }
 
-  bool has_processing_animation_worklets_for_active_tree() const { return _has_field_[44]; }
-  bool processing_animation_worklets_for_active_tree() const { return processing_animation_worklets_for_active_tree_; }
-  void set_processing_animation_worklets_for_active_tree(bool value) { processing_animation_worklets_for_active_tree_ = value; _has_field_.set(44); }
+  using Thread = ::perfetto::protos::pbzero::ProcessStats_Thread;
+  using FDInfo = ::perfetto::protos::pbzero::ProcessStats_FDInfo;
+  using Process = ::perfetto::protos::pbzero::ProcessStats_Process;
 
-  bool has_processing_animation_worklets_for_pending_tree() const { return _has_field_[45]; }
-  bool processing_animation_worklets_for_pending_tree() const { return processing_animation_worklets_for_pending_tree_; }
-  void set_processing_animation_worklets_for_pending_tree(bool value) { processing_animation_worklets_for_pending_tree_ = value; _has_field_.set(45); }
+  using FieldMetadata_Processes =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ProcessStats_Process,
+      ProcessStats>;
 
-  bool has_processing_paint_worklets_for_pending_tree() const { return _has_field_[46]; }
-  bool processing_paint_worklets_for_pending_tree() const { return processing_paint_worklets_for_pending_tree_; }
-  void set_processing_paint_worklets_for_pending_tree(bool value) { processing_paint_worklets_for_pending_tree_ = value; _has_field_.set(46); }
+  static constexpr FieldMetadata_Processes kProcesses{};
+  template <typename T = ProcessStats_Process> T* add_processes() {
+    return BeginNestedMessage<T>(1);
+  }
 
- private:
-  int32_t commit_count_{};
-  int32_t current_frame_number_{};
-  int32_t last_frame_number_submit_performed_{};
-  int32_t last_frame_number_draw_performed_{};
-  int32_t last_frame_number_begin_main_frame_sent_{};
-  bool did_draw_{};
-  bool did_send_begin_main_frame_for_current_frame_{};
-  bool did_notify_begin_main_frame_not_expected_until_{};
-  bool did_notify_begin_main_frame_not_expected_soon_{};
-  bool wants_begin_main_frame_not_expected_{};
-  bool did_commit_during_frame_{};
-  bool did_invalidate_layer_tree_frame_sink_{};
-  bool did_perform_impl_side_invalidaion_{};
-  bool did_prepare_tiles_{};
-  int32_t consecutive_checkerboard_animations_{};
-  int32_t pending_submit_frames_{};
-  int32_t submit_frames_with_current_layer_tree_frame_sink_{};
-  bool needs_redraw_{};
-  bool needs_prepare_tiles_{};
-  bool needs_begin_main_frame_{};
-  bool needs_one_begin_impl_frame_{};
-  bool visible_{};
-  bool begin_frame_source_paused_{};
-  bool can_draw_{};
-  bool resourceless_draw_{};
-  bool has_pending_tree_{};
-  bool pending_tree_is_ready_for_activation_{};
-  bool active_tree_needs_first_draw_{};
-  bool active_tree_is_ready_to_draw_{};
-  bool did_create_and_initialize_first_layer_tree_frame_sink_{};
-  ChromeCompositorStateMachine_MinorState_TreePriority tree_priority_{};
-  ChromeCompositorStateMachine_MinorState_ScrollHandlerState scroll_handler_state_{};
-  bool critical_begin_main_frame_to_activate_is_fast_{};
-  bool main_thread_missed_last_deadline_{};
-  bool video_needs_begin_frames_{};
-  bool defer_begin_main_frame_{};
-  bool last_commit_had_no_updates_{};
-  bool did_draw_in_last_frame_{};
-  bool did_submit_in_last_frame_{};
-  bool needs_impl_side_invalidation_{};
-  bool current_pending_tree_is_impl_side_{};
-  bool previous_pending_tree_was_impl_side_{};
-  bool processing_animation_worklets_for_active_tree_{};
-  bool processing_animation_worklets_for_pending_tree_{};
-  bool processing_paint_worklets_for_pending_tree_{};
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_CollectionEndTimestamp =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProcessStats>;
 
-  std::bitset<47> _has_field_{};
+  static constexpr FieldMetadata_CollectionEndTimestamp kCollectionEndTimestamp{};
+  void set_collection_end_timestamp(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CollectionEndTimestamp::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 };
 
+class ProcessStats_Process_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/24> {
+ public:
+  ProcessStats_Process_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProcessStats_Process_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProcessStats_Process_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  int32_t pid() const { return at<1>().as_int32(); }
+  bool has_threads() const { return at<11>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> threads() const { return GetRepeated<::protozero::ConstBytes>(11); }
+  bool has_vm_size_kb() const { return at<2>().valid(); }
+  uint64_t vm_size_kb() const { return at<2>().as_uint64(); }
+  bool has_vm_rss_kb() const { return at<3>().valid(); }
+  uint64_t vm_rss_kb() const { return at<3>().as_uint64(); }
+  bool has_rss_anon_kb() const { return at<4>().valid(); }
+  uint64_t rss_anon_kb() const { return at<4>().as_uint64(); }
+  bool has_rss_file_kb() const { return at<5>().valid(); }
+  uint64_t rss_file_kb() const { return at<5>().as_uint64(); }
+  bool has_rss_shmem_kb() const { return at<6>().valid(); }
+  uint64_t rss_shmem_kb() const { return at<6>().as_uint64(); }
+  bool has_vm_swap_kb() const { return at<7>().valid(); }
+  uint64_t vm_swap_kb() const { return at<7>().as_uint64(); }
+  bool has_vm_locked_kb() const { return at<8>().valid(); }
+  uint64_t vm_locked_kb() const { return at<8>().as_uint64(); }
+  bool has_vm_hwm_kb() const { return at<9>().valid(); }
+  uint64_t vm_hwm_kb() const { return at<9>().as_uint64(); }
+  bool has_oom_score_adj() const { return at<10>().valid(); }
+  int64_t oom_score_adj() const { return at<10>().as_int64(); }
+  bool has_is_peak_rss_resettable() const { return at<12>().valid(); }
+  bool is_peak_rss_resettable() const { return at<12>().as_bool(); }
+  bool has_chrome_private_footprint_kb() const { return at<13>().valid(); }
+  uint32_t chrome_private_footprint_kb() const { return at<13>().as_uint32(); }
+  bool has_chrome_peak_resident_set_kb() const { return at<14>().valid(); }
+  uint32_t chrome_peak_resident_set_kb() const { return at<14>().as_uint32(); }
+  bool has_fds() const { return at<15>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> fds() const { return GetRepeated<::protozero::ConstBytes>(15); }
+  bool has_smr_rss_kb() const { return at<16>().valid(); }
+  uint64_t smr_rss_kb() const { return at<16>().as_uint64(); }
+  bool has_smr_pss_kb() const { return at<17>().valid(); }
+  uint64_t smr_pss_kb() const { return at<17>().as_uint64(); }
+  bool has_smr_pss_anon_kb() const { return at<18>().valid(); }
+  uint64_t smr_pss_anon_kb() const { return at<18>().as_uint64(); }
+  bool has_smr_pss_file_kb() const { return at<19>().valid(); }
+  uint64_t smr_pss_file_kb() const { return at<19>().as_uint64(); }
+  bool has_smr_pss_shmem_kb() const { return at<20>().valid(); }
+  uint64_t smr_pss_shmem_kb() const { return at<20>().as_uint64(); }
+  bool has_smr_swap_pss_kb() const { return at<23>().valid(); }
+  uint64_t smr_swap_pss_kb() const { return at<23>().as_uint64(); }
+  bool has_runtime_user_mode() const { return at<21>().valid(); }
+  uint64_t runtime_user_mode() const { return at<21>().as_uint64(); }
+  bool has_runtime_kernel_mode() const { return at<22>().valid(); }
+  uint64_t runtime_kernel_mode() const { return at<22>().as_uint64(); }
+  bool has_dmabuf_rss_kb() const { return at<24>().valid(); }
+  uint64_t dmabuf_rss_kb() const { return at<24>().as_uint64(); }
+};
 
-class PERFETTO_EXPORT_COMPONENT ChromeCompositorStateMachine_MajorState : public ::protozero::CppMessageObj {
+class ProcessStats_Process : public ::protozero::Message {
  public:
-  using BeginImplFrameState = ChromeCompositorStateMachine_MajorState_BeginImplFrameState;
-  static constexpr auto BEGIN_IMPL_FRAME_UNSPECIFIED = ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_UNSPECIFIED;
-  static constexpr auto BEGIN_IMPL_FRAME_IDLE = ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_IDLE;
-  static constexpr auto BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME = ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME;
-  static constexpr auto BEGIN_IMPL_FRAME_INSIDE_DEADLINE = ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_INSIDE_DEADLINE;
-  static constexpr auto BeginImplFrameState_MIN = ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_UNSPECIFIED;
-  static constexpr auto BeginImplFrameState_MAX = ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_INSIDE_DEADLINE;
-  using BeginMainFrameState = ChromeCompositorStateMachine_MajorState_BeginMainFrameState;
-  static constexpr auto BEGIN_MAIN_FRAME_UNSPECIFIED = ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_UNSPECIFIED;
-  static constexpr auto BEGIN_MAIN_FRAME_IDLE = ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_IDLE;
-  static constexpr auto BEGIN_MAIN_FRAME_SENT = ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_SENT;
-  static constexpr auto BEGIN_MAIN_FRAME_READY_TO_COMMIT = ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_READY_TO_COMMIT;
-  static constexpr auto BeginMainFrameState_MIN = ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_UNSPECIFIED;
-  static constexpr auto BeginMainFrameState_MAX = ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_READY_TO_COMMIT;
-  using LayerTreeFrameSinkState = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState;
-  static constexpr auto LAYER_TREE_FRAME_UNSPECIFIED = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_UNSPECIFIED;
-  static constexpr auto LAYER_TREE_FRAME_NONE = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_NONE;
-  static constexpr auto LAYER_TREE_FRAME_ACTIVE = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_ACTIVE;
-  static constexpr auto LAYER_TREE_FRAME_CREATING = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_CREATING;
-  static constexpr auto LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT;
-  static constexpr auto LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION;
-  static constexpr auto LayerTreeFrameSinkState_MIN = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_UNSPECIFIED;
-  static constexpr auto LayerTreeFrameSinkState_MAX = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION;
-  using ForcedRedrawOnTimeoutState = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState;
-  static constexpr auto FORCED_REDRAW_UNSPECIFIED = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_UNSPECIFIED;
-  static constexpr auto FORCED_REDRAW_IDLE = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_IDLE;
-  static constexpr auto FORCED_REDRAW_WAITING_FOR_COMMIT = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_COMMIT;
-  static constexpr auto FORCED_REDRAW_WAITING_FOR_ACTIVATION = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_ACTIVATION;
-  static constexpr auto FORCED_REDRAW_WAITING_FOR_DRAW = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_DRAW;
-  static constexpr auto ForcedRedrawOnTimeoutState_MIN = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_UNSPECIFIED;
-  static constexpr auto ForcedRedrawOnTimeoutState_MAX = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_DRAW;
-  enum FieldNumbers {
-    kNextActionFieldNumber = 1,
-    kBeginImplFrameStateFieldNumber = 2,
-    kBeginMainFrameStateFieldNumber = 3,
-    kLayerTreeFrameSinkStateFieldNumber = 4,
-    kForcedRedrawStateFieldNumber = 5,
+  using Decoder = ProcessStats_Process_Decoder;
+  enum : int32_t {
+    kPidFieldNumber = 1,
+    kThreadsFieldNumber = 11,
+    kVmSizeKbFieldNumber = 2,
+    kVmRssKbFieldNumber = 3,
+    kRssAnonKbFieldNumber = 4,
+    kRssFileKbFieldNumber = 5,
+    kRssShmemKbFieldNumber = 6,
+    kVmSwapKbFieldNumber = 7,
+    kVmLockedKbFieldNumber = 8,
+    kVmHwmKbFieldNumber = 9,
+    kOomScoreAdjFieldNumber = 10,
+    kIsPeakRssResettableFieldNumber = 12,
+    kChromePrivateFootprintKbFieldNumber = 13,
+    kChromePeakResidentSetKbFieldNumber = 14,
+    kFdsFieldNumber = 15,
+    kSmrRssKbFieldNumber = 16,
+    kSmrPssKbFieldNumber = 17,
+    kSmrPssAnonKbFieldNumber = 18,
+    kSmrPssFileKbFieldNumber = 19,
+    kSmrPssShmemKbFieldNumber = 20,
+    kSmrSwapPssKbFieldNumber = 23,
+    kRuntimeUserModeFieldNumber = 21,
+    kRuntimeKernelModeFieldNumber = 22,
+    kDmabufRssKbFieldNumber = 24,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.ProcessStats.Process"; }
 
-  ChromeCompositorStateMachine_MajorState();
-  ~ChromeCompositorStateMachine_MajorState() override;
-  ChromeCompositorStateMachine_MajorState(ChromeCompositorStateMachine_MajorState&&) noexcept;
-  ChromeCompositorStateMachine_MajorState& operator=(ChromeCompositorStateMachine_MajorState&&);
-  ChromeCompositorStateMachine_MajorState(const ChromeCompositorStateMachine_MajorState&);
-  ChromeCompositorStateMachine_MajorState& operator=(const ChromeCompositorStateMachine_MajorState&);
-  bool operator==(const ChromeCompositorStateMachine_MajorState&) const;
-  bool operator!=(const ChromeCompositorStateMachine_MajorState& other) const { return !(*this == other); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_Pid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ProcessStats_Process>;
 
-  bool has_next_action() const { return _has_field_[1]; }
-  ChromeCompositorSchedulerAction next_action() const { return next_action_; }
-  void set_next_action(ChromeCompositorSchedulerAction value) { next_action_ = value; _has_field_.set(1); }
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_begin_impl_frame_state() const { return _has_field_[2]; }
-  ChromeCompositorStateMachine_MajorState_BeginImplFrameState begin_impl_frame_state() const { return begin_impl_frame_state_; }
-  void set_begin_impl_frame_state(ChromeCompositorStateMachine_MajorState_BeginImplFrameState value) { begin_impl_frame_state_ = value; _has_field_.set(2); }
+  using FieldMetadata_Threads =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ProcessStats_Thread,
+      ProcessStats_Process>;
 
-  bool has_begin_main_frame_state() const { return _has_field_[3]; }
-  ChromeCompositorStateMachine_MajorState_BeginMainFrameState begin_main_frame_state() const { return begin_main_frame_state_; }
-  void set_begin_main_frame_state(ChromeCompositorStateMachine_MajorState_BeginMainFrameState value) { begin_main_frame_state_ = value; _has_field_.set(3); }
+  static constexpr FieldMetadata_Threads kThreads{};
+  template <typename T = ProcessStats_Thread> T* add_threads() {
+    return BeginNestedMessage<T>(11);
+  }
 
-  bool has_layer_tree_frame_sink_state() const { return _has_field_[4]; }
-  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState layer_tree_frame_sink_state() const { return layer_tree_frame_sink_state_; }
-  void set_layer_tree_frame_sink_state(ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState value) { layer_tree_frame_sink_state_ = value; _has_field_.set(4); }
 
-  bool has_forced_redraw_state() const { return _has_field_[5]; }
-  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState forced_redraw_state() const { return forced_redraw_state_; }
-  void set_forced_redraw_state(ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState value) { forced_redraw_state_ = value; _has_field_.set(5); }
+  using FieldMetadata_VmSizeKb =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProcessStats_Process>;
 
- private:
-  ChromeCompositorSchedulerAction next_action_{};
-  ChromeCompositorStateMachine_MajorState_BeginImplFrameState begin_impl_frame_state_{};
-  ChromeCompositorStateMachine_MajorState_BeginMainFrameState begin_main_frame_state_{};
-  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState layer_tree_frame_sink_state_{};
-  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState forced_redraw_state_{};
+  static constexpr FieldMetadata_VmSizeKb kVmSizeKb{};
+  void set_vm_size_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VmSizeKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_VmRssKb =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProcessStats_Process>;
 
-  std::bitset<6> _has_field_{};
-};
+  static constexpr FieldMetadata_VmRssKb kVmRssKb{};
+  void set_vm_rss_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VmRssKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
+  using FieldMetadata_RssAnonKb =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProcessStats_Process>;
 
-class PERFETTO_EXPORT_COMPONENT ChromeCompositorSchedulerState : public ::protozero::CppMessageObj {
- public:
-  using BeginImplFrameDeadlineMode = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode;
-  static constexpr auto DEADLINE_MODE_UNSPECIFIED = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_UNSPECIFIED;
-  static constexpr auto DEADLINE_MODE_NONE = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_NONE;
-  static constexpr auto DEADLINE_MODE_IMMEDIATE = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_IMMEDIATE;
-  static constexpr auto DEADLINE_MODE_REGULAR = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_REGULAR;
-  static constexpr auto DEADLINE_MODE_LATE = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_LATE;
-  static constexpr auto DEADLINE_MODE_BLOCKED = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_BLOCKED;
-  static constexpr auto BeginImplFrameDeadlineMode_MIN = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_UNSPECIFIED;
-  static constexpr auto BeginImplFrameDeadlineMode_MAX = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_BLOCKED;
-  enum FieldNumbers {
-    kStateMachineFieldNumber = 1,
-    kObservingBeginFrameSourceFieldNumber = 2,
-    kBeginImplFrameDeadlineTaskFieldNumber = 3,
-    kPendingBeginFrameTaskFieldNumber = 4,
-    kSkippedLastFrameMissedExceededDeadlineFieldNumber = 5,
-    kInsideActionFieldNumber = 7,
-    kDeadlineModeFieldNumber = 8,
-    kDeadlineUsFieldNumber = 9,
-    kDeadlineScheduledAtUsFieldNumber = 10,
-    kNowUsFieldNumber = 11,
-    kNowToDeadlineDeltaUsFieldNumber = 12,
-    kNowToDeadlineScheduledAtDeltaUsFieldNumber = 13,
-    kBeginImplFrameArgsFieldNumber = 14,
-    kBeginFrameObserverStateFieldNumber = 15,
-    kBeginFrameSourceStateFieldNumber = 16,
-    kCompositorTimingHistoryFieldNumber = 17,
-  };
+  static constexpr FieldMetadata_RssAnonKb kRssAnonKb{};
+  void set_rss_anon_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RssAnonKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  ChromeCompositorSchedulerState();
-  ~ChromeCompositorSchedulerState() override;
-  ChromeCompositorSchedulerState(ChromeCompositorSchedulerState&&) noexcept;
-  ChromeCompositorSchedulerState& operator=(ChromeCompositorSchedulerState&&);
-  ChromeCompositorSchedulerState(const ChromeCompositorSchedulerState&);
-  ChromeCompositorSchedulerState& operator=(const ChromeCompositorSchedulerState&);
-  bool operator==(const ChromeCompositorSchedulerState&) const;
-  bool operator!=(const ChromeCompositorSchedulerState& other) const { return !(*this == other); }
+  using FieldMetadata_RssFileKb =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProcessStats_Process>;
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  static constexpr FieldMetadata_RssFileKb kRssFileKb{};
+  void set_rss_file_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RssFileKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_state_machine() const { return _has_field_[1]; }
-  const ChromeCompositorStateMachine& state_machine() const { return *state_machine_; }
-  ChromeCompositorStateMachine* mutable_state_machine() { _has_field_.set(1); return state_machine_.get(); }
+  using FieldMetadata_RssShmemKb =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProcessStats_Process>;
 
-  bool has_observing_begin_frame_source() const { return _has_field_[2]; }
-  bool observing_begin_frame_source() const { return observing_begin_frame_source_; }
-  void set_observing_begin_frame_source(bool value) { observing_begin_frame_source_ = value; _has_field_.set(2); }
+  static constexpr FieldMetadata_RssShmemKb kRssShmemKb{};
+  void set_rss_shmem_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RssShmemKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_begin_impl_frame_deadline_task() const { return _has_field_[3]; }
-  bool begin_impl_frame_deadline_task() const { return begin_impl_frame_deadline_task_; }
-  void set_begin_impl_frame_deadline_task(bool value) { begin_impl_frame_deadline_task_ = value; _has_field_.set(3); }
+  using FieldMetadata_VmSwapKb =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProcessStats_Process>;
 
-  bool has_pending_begin_frame_task() const { return _has_field_[4]; }
-  bool pending_begin_frame_task() const { return pending_begin_frame_task_; }
-  void set_pending_begin_frame_task(bool value) { pending_begin_frame_task_ = value; _has_field_.set(4); }
+  static constexpr FieldMetadata_VmSwapKb kVmSwapKb{};
+  void set_vm_swap_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VmSwapKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_skipped_last_frame_missed_exceeded_deadline() const { return _has_field_[5]; }
-  bool skipped_last_frame_missed_exceeded_deadline() const { return skipped_last_frame_missed_exceeded_deadline_; }
-  void set_skipped_last_frame_missed_exceeded_deadline(bool value) { skipped_last_frame_missed_exceeded_deadline_ = value; _has_field_.set(5); }
+  using FieldMetadata_VmLockedKb =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProcessStats_Process>;
 
-  bool has_inside_action() const { return _has_field_[7]; }
-  ChromeCompositorSchedulerAction inside_action() const { return inside_action_; }
-  void set_inside_action(ChromeCompositorSchedulerAction value) { inside_action_ = value; _has_field_.set(7); }
+  static constexpr FieldMetadata_VmLockedKb kVmLockedKb{};
+  void set_vm_locked_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VmLockedKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_deadline_mode() const { return _has_field_[8]; }
-  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode deadline_mode() const { return deadline_mode_; }
-  void set_deadline_mode(ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode value) { deadline_mode_ = value; _has_field_.set(8); }
+  using FieldMetadata_VmHwmKb =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProcessStats_Process>;
 
-  bool has_deadline_us() const { return _has_field_[9]; }
-  int64_t deadline_us() const { return deadline_us_; }
-  void set_deadline_us(int64_t value) { deadline_us_ = value; _has_field_.set(9); }
+  static constexpr FieldMetadata_VmHwmKb kVmHwmKb{};
+  void set_vm_hwm_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_VmHwmKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_deadline_scheduled_at_us() const { return _has_field_[10]; }
-  int64_t deadline_scheduled_at_us() const { return deadline_scheduled_at_us_; }
-  void set_deadline_scheduled_at_us(int64_t value) { deadline_scheduled_at_us_ = value; _has_field_.set(10); }
+  using FieldMetadata_OomScoreAdj =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      ProcessStats_Process>;
 
-  bool has_now_us() const { return _has_field_[11]; }
-  int64_t now_us() const { return now_us_; }
-  void set_now_us(int64_t value) { now_us_ = value; _has_field_.set(11); }
+  static constexpr FieldMetadata_OomScoreAdj kOomScoreAdj{};
+  void set_oom_score_adj(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OomScoreAdj::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_now_to_deadline_delta_us() const { return _has_field_[12]; }
-  int64_t now_to_deadline_delta_us() const { return now_to_deadline_delta_us_; }
-  void set_now_to_deadline_delta_us(int64_t value) { now_to_deadline_delta_us_ = value; _has_field_.set(12); }
+  using FieldMetadata_IsPeakRssResettable =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ProcessStats_Process>;
 
-  bool has_now_to_deadline_scheduled_at_delta_us() const { return _has_field_[13]; }
-  int64_t now_to_deadline_scheduled_at_delta_us() const { return now_to_deadline_scheduled_at_delta_us_; }
-  void set_now_to_deadline_scheduled_at_delta_us(int64_t value) { now_to_deadline_scheduled_at_delta_us_ = value; _has_field_.set(13); }
+  static constexpr FieldMetadata_IsPeakRssResettable kIsPeakRssResettable{};
+  void set_is_peak_rss_resettable(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsPeakRssResettable::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_begin_impl_frame_args() const { return _has_field_[14]; }
-  const BeginImplFrameArgs& begin_impl_frame_args() const { return *begin_impl_frame_args_; }
-  BeginImplFrameArgs* mutable_begin_impl_frame_args() { _has_field_.set(14); return begin_impl_frame_args_.get(); }
+  using FieldMetadata_ChromePrivateFootprintKb =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ProcessStats_Process>;
 
-  bool has_begin_frame_observer_state() const { return _has_field_[15]; }
-  const BeginFrameObserverState& begin_frame_observer_state() const { return *begin_frame_observer_state_; }
-  BeginFrameObserverState* mutable_begin_frame_observer_state() { _has_field_.set(15); return begin_frame_observer_state_.get(); }
+  static constexpr FieldMetadata_ChromePrivateFootprintKb kChromePrivateFootprintKb{};
+  void set_chrome_private_footprint_kb(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ChromePrivateFootprintKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_begin_frame_source_state() const { return _has_field_[16]; }
-  const BeginFrameSourceState& begin_frame_source_state() const { return *begin_frame_source_state_; }
-  BeginFrameSourceState* mutable_begin_frame_source_state() { _has_field_.set(16); return begin_frame_source_state_.get(); }
+  using FieldMetadata_ChromePeakResidentSetKb =
+    ::protozero::proto_utils::FieldMetadata<
+      14,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ProcessStats_Process>;
 
-  bool has_compositor_timing_history() const { return _has_field_[17]; }
-  const CompositorTimingHistory& compositor_timing_history() const { return *compositor_timing_history_; }
-  CompositorTimingHistory* mutable_compositor_timing_history() { _has_field_.set(17); return compositor_timing_history_.get(); }
+  static constexpr FieldMetadata_ChromePeakResidentSetKb kChromePeakResidentSetKb{};
+  void set_chrome_peak_resident_set_kb(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ChromePeakResidentSetKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
- private:
-  ::protozero::CopyablePtr<ChromeCompositorStateMachine> state_machine_;
-  bool observing_begin_frame_source_{};
-  bool begin_impl_frame_deadline_task_{};
-  bool pending_begin_frame_task_{};
-  bool skipped_last_frame_missed_exceeded_deadline_{};
-  ChromeCompositorSchedulerAction inside_action_{};
-  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode deadline_mode_{};
-  int64_t deadline_us_{};
-  int64_t deadline_scheduled_at_us_{};
-  int64_t now_us_{};
-  int64_t now_to_deadline_delta_us_{};
-  int64_t now_to_deadline_scheduled_at_delta_us_{};
-  ::protozero::CopyablePtr<BeginImplFrameArgs> begin_impl_frame_args_;
-  ::protozero::CopyablePtr<BeginFrameObserverState> begin_frame_observer_state_;
-  ::protozero::CopyablePtr<BeginFrameSourceState> begin_frame_source_state_;
-  ::protozero::CopyablePtr<CompositorTimingHistory> compositor_timing_history_;
+  using FieldMetadata_Fds =
+    ::protozero::proto_utils::FieldMetadata<
+      15,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ProcessStats_FDInfo,
+      ProcessStats_Process>;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  static constexpr FieldMetadata_Fds kFds{};
+  template <typename T = ProcessStats_FDInfo> T* add_fds() {
+    return BeginNestedMessage<T>(15);
+  }
 
-  std::bitset<18> _has_field_{};
-};
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  using FieldMetadata_SmrRssKb =
+    ::protozero::proto_utils::FieldMetadata<
+      16,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProcessStats_Process>;
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_COMPOSITOR_SCHEDULER_STATE_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_content_settings_event_info.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_CONTENT_SETTINGS_EVENT_INFO_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_CONTENT_SETTINGS_EVENT_INFO_PROTO_CPP_H_
+  static constexpr FieldMetadata_SmrRssKb kSmrRssKb{};
+  void set_smr_rss_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SmrRssKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  using FieldMetadata_SmrPssKb =
+    ::protozero::proto_utils::FieldMetadata<
+      17,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProcessStats_Process>;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  static constexpr FieldMetadata_SmrPssKb kSmrPssKb{};
+  void set_smr_pss_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SmrPssKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeContentSettingsEventInfo;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  using FieldMetadata_SmrPssAnonKb =
+    ::protozero::proto_utils::FieldMetadata<
+      18,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProcessStats_Process>;
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  static constexpr FieldMetadata_SmrPssAnonKb kSmrPssAnonKb{};
+  void set_smr_pss_anon_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SmrPssAnonKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+  using FieldMetadata_SmrPssFileKb =
+    ::protozero::proto_utils::FieldMetadata<
+      19,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProcessStats_Process>;
 
-class PERFETTO_EXPORT_COMPONENT ChromeContentSettingsEventInfo : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kNumberOfExceptionsFieldNumber = 1,
-  };
+  static constexpr FieldMetadata_SmrPssFileKb kSmrPssFileKb{};
+  void set_smr_pss_file_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SmrPssFileKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  ChromeContentSettingsEventInfo();
-  ~ChromeContentSettingsEventInfo() override;
-  ChromeContentSettingsEventInfo(ChromeContentSettingsEventInfo&&) noexcept;
-  ChromeContentSettingsEventInfo& operator=(ChromeContentSettingsEventInfo&&);
-  ChromeContentSettingsEventInfo(const ChromeContentSettingsEventInfo&);
-  ChromeContentSettingsEventInfo& operator=(const ChromeContentSettingsEventInfo&);
-  bool operator==(const ChromeContentSettingsEventInfo&) const;
-  bool operator!=(const ChromeContentSettingsEventInfo& other) const { return !(*this == other); }
+  using FieldMetadata_SmrPssShmemKb =
+    ::protozero::proto_utils::FieldMetadata<
+      20,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProcessStats_Process>;
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  static constexpr FieldMetadata_SmrPssShmemKb kSmrPssShmemKb{};
+  void set_smr_pss_shmem_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SmrPssShmemKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_number_of_exceptions() const { return _has_field_[1]; }
-  uint32_t number_of_exceptions() const { return number_of_exceptions_; }
-  void set_number_of_exceptions(uint32_t value) { number_of_exceptions_ = value; _has_field_.set(1); }
+  using FieldMetadata_SmrSwapPssKb =
+    ::protozero::proto_utils::FieldMetadata<
+      23,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProcessStats_Process>;
 
- private:
-  uint32_t number_of_exceptions_{};
+  static constexpr FieldMetadata_SmrSwapPssKb kSmrSwapPssKb{};
+  void set_smr_swap_pss_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SmrSwapPssKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_RuntimeUserMode =
+    ::protozero::proto_utils::FieldMetadata<
+      21,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProcessStats_Process>;
 
-  std::bitset<2> _has_field_{};
+  static constexpr FieldMetadata_RuntimeUserMode kRuntimeUserMode{};
+  void set_runtime_user_mode(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RuntimeUserMode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_RuntimeKernelMode =
+    ::protozero::proto_utils::FieldMetadata<
+      22,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProcessStats_Process>;
+
+  static constexpr FieldMetadata_RuntimeKernelMode kRuntimeKernelMode{};
+  void set_runtime_kernel_mode(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RuntimeKernelMode::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DmabufRssKb =
+    ::protozero::proto_utils::FieldMetadata<
+      24,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProcessStats_Process>;
+
+  static constexpr FieldMetadata_DmabufRssKb kDmabufRssKb{};
+  void set_dmabuf_rss_kb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DmabufRssKb::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+class ProcessStats_FDInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  ProcessStats_FDInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProcessStats_FDInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProcessStats_FDInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_fd() const { return at<1>().valid(); }
+  uint64_t fd() const { return at<1>().as_uint64(); }
+  bool has_path() const { return at<2>().valid(); }
+  ::protozero::ConstChars path() const { return at<2>().as_string(); }
+};
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_CONTENT_SETTINGS_EVENT_INFO_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_frame_reporter.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_FRAME_REPORTER_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_FRAME_REPORTER_PROTO_CPP_H_
+class ProcessStats_FDInfo : public ::protozero::Message {
+ public:
+  using Decoder = ProcessStats_FDInfo_Decoder;
+  enum : int32_t {
+    kFdFieldNumber = 1,
+    kPathFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ProcessStats.FDInfo"; }
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  using FieldMetadata_Fd =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProcessStats_FDInfo>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeFrameReporter;
-enum ChromeFrameReporter_State : int;
-enum ChromeFrameReporter_FrameDropReason : int;
-enum ChromeFrameReporter_ScrollState : int;
-enum ChromeFrameReporter_FrameType : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  static constexpr FieldMetadata_Fd kFd{};
+  void set_fd(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Fd::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  using FieldMetadata_Path =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ProcessStats_FDInfo>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum ChromeFrameReporter_State : int {
-  ChromeFrameReporter_State_STATE_NO_UPDATE_DESIRED = 0,
-  ChromeFrameReporter_State_STATE_PRESENTED_ALL = 1,
-  ChromeFrameReporter_State_STATE_PRESENTED_PARTIAL = 2,
-  ChromeFrameReporter_State_STATE_DROPPED = 3,
-};
-enum ChromeFrameReporter_FrameDropReason : int {
-  ChromeFrameReporter_FrameDropReason_REASON_UNSPECIFIED = 0,
-  ChromeFrameReporter_FrameDropReason_REASON_DISPLAY_COMPOSITOR = 1,
-  ChromeFrameReporter_FrameDropReason_REASON_MAIN_THREAD = 2,
-  ChromeFrameReporter_FrameDropReason_REASON_CLIENT_COMPOSITOR = 3,
-};
-enum ChromeFrameReporter_ScrollState : int {
-  ChromeFrameReporter_ScrollState_SCROLL_NONE = 0,
-  ChromeFrameReporter_ScrollState_SCROLL_MAIN_THREAD = 1,
-  ChromeFrameReporter_ScrollState_SCROLL_COMPOSITOR_THREAD = 2,
-  ChromeFrameReporter_ScrollState_SCROLL_UNKNOWN = 3,
+  static constexpr FieldMetadata_Path kPath{};
+  void set_path(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Path::kFieldId, data, size);
+  }
+  void set_path(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Path::kFieldId, chars.data, chars.size);
+  }
+  void set_path(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Path::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 };
-enum ChromeFrameReporter_FrameType : int {
-  ChromeFrameReporter_FrameType_FORKED = 0,
-  ChromeFrameReporter_FrameType_BACKFILL = 1,
+
+class ProcessStats_Thread_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  ProcessStats_Thread_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProcessStats_Thread_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProcessStats_Thread_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_tid() const { return at<1>().valid(); }
+  int32_t tid() const { return at<1>().as_int32(); }
 };
 
-class PERFETTO_EXPORT_COMPONENT ChromeFrameReporter : public ::protozero::CppMessageObj {
+class ProcessStats_Thread : public ::protozero::Message {
  public:
-  using State = ChromeFrameReporter_State;
-  static constexpr auto STATE_NO_UPDATE_DESIRED = ChromeFrameReporter_State_STATE_NO_UPDATE_DESIRED;
-  static constexpr auto STATE_PRESENTED_ALL = ChromeFrameReporter_State_STATE_PRESENTED_ALL;
-  static constexpr auto STATE_PRESENTED_PARTIAL = ChromeFrameReporter_State_STATE_PRESENTED_PARTIAL;
-  static constexpr auto STATE_DROPPED = ChromeFrameReporter_State_STATE_DROPPED;
-  static constexpr auto State_MIN = ChromeFrameReporter_State_STATE_NO_UPDATE_DESIRED;
-  static constexpr auto State_MAX = ChromeFrameReporter_State_STATE_DROPPED;
-  using FrameDropReason = ChromeFrameReporter_FrameDropReason;
-  static constexpr auto REASON_UNSPECIFIED = ChromeFrameReporter_FrameDropReason_REASON_UNSPECIFIED;
-  static constexpr auto REASON_DISPLAY_COMPOSITOR = ChromeFrameReporter_FrameDropReason_REASON_DISPLAY_COMPOSITOR;
-  static constexpr auto REASON_MAIN_THREAD = ChromeFrameReporter_FrameDropReason_REASON_MAIN_THREAD;
-  static constexpr auto REASON_CLIENT_COMPOSITOR = ChromeFrameReporter_FrameDropReason_REASON_CLIENT_COMPOSITOR;
-  static constexpr auto FrameDropReason_MIN = ChromeFrameReporter_FrameDropReason_REASON_UNSPECIFIED;
-  static constexpr auto FrameDropReason_MAX = ChromeFrameReporter_FrameDropReason_REASON_CLIENT_COMPOSITOR;
-  using ScrollState = ChromeFrameReporter_ScrollState;
-  static constexpr auto SCROLL_NONE = ChromeFrameReporter_ScrollState_SCROLL_NONE;
-  static constexpr auto SCROLL_MAIN_THREAD = ChromeFrameReporter_ScrollState_SCROLL_MAIN_THREAD;
-  static constexpr auto SCROLL_COMPOSITOR_THREAD = ChromeFrameReporter_ScrollState_SCROLL_COMPOSITOR_THREAD;
-  static constexpr auto SCROLL_UNKNOWN = ChromeFrameReporter_ScrollState_SCROLL_UNKNOWN;
-  static constexpr auto ScrollState_MIN = ChromeFrameReporter_ScrollState_SCROLL_NONE;
-  static constexpr auto ScrollState_MAX = ChromeFrameReporter_ScrollState_SCROLL_UNKNOWN;
-  using FrameType = ChromeFrameReporter_FrameType;
-  static constexpr auto FORKED = ChromeFrameReporter_FrameType_FORKED;
-  static constexpr auto BACKFILL = ChromeFrameReporter_FrameType_BACKFILL;
-  static constexpr auto FrameType_MIN = ChromeFrameReporter_FrameType_FORKED;
-  static constexpr auto FrameType_MAX = ChromeFrameReporter_FrameType_BACKFILL;
-  enum FieldNumbers {
-    kStateFieldNumber = 1,
-    kReasonFieldNumber = 2,
-    kFrameSourceFieldNumber = 3,
-    kFrameSequenceFieldNumber = 4,
-    kAffectsSmoothnessFieldNumber = 5,
-    kScrollStateFieldNumber = 6,
-    kHasMainAnimationFieldNumber = 7,
-    kHasCompositorAnimationFieldNumber = 8,
-    kHasSmoothInputMainFieldNumber = 9,
-    kHasMissingContentFieldNumber = 10,
-    kLayerTreeHostIdFieldNumber = 11,
-    kHasHighLatencyFieldNumber = 12,
-    kFrameTypeFieldNumber = 13,
-    kHighLatencyContributionStageFieldNumber = 14,
+  using Decoder = ProcessStats_Thread_Decoder;
+  enum : int32_t {
+    kTidFieldNumber = 1,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.ProcessStats.Thread"; }
 
-  ChromeFrameReporter();
-  ~ChromeFrameReporter() override;
-  ChromeFrameReporter(ChromeFrameReporter&&) noexcept;
-  ChromeFrameReporter& operator=(ChromeFrameReporter&&);
-  ChromeFrameReporter(const ChromeFrameReporter&);
-  ChromeFrameReporter& operator=(const ChromeFrameReporter&);
-  bool operator==(const ChromeFrameReporter&) const;
-  bool operator!=(const ChromeFrameReporter& other) const { return !(*this == other); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_Tid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ProcessStats_Thread>;
 
-  bool has_state() const { return _has_field_[1]; }
-  ChromeFrameReporter_State state() const { return state_; }
-  void set_state(ChromeFrameReporter_State value) { state_ = value; _has_field_.set(1); }
+  static constexpr FieldMetadata_Tid kTid{};
+  void set_tid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
 
-  bool has_reason() const { return _has_field_[2]; }
-  ChromeFrameReporter_FrameDropReason reason() const { return reason_; }
-  void set_reason(ChromeFrameReporter_FrameDropReason value) { reason_ = value; _has_field_.set(2); }
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ps/process_tree.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  bool has_frame_source() const { return _has_field_[3]; }
-  uint64_t frame_source() const { return frame_source_; }
-  void set_frame_source(uint64_t value) { frame_source_ = value; _has_field_.set(3); }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PS_PROCESS_TREE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PS_PROCESS_TREE_PROTO_H_
 
-  bool has_frame_sequence() const { return _has_field_[4]; }
-  uint64_t frame_sequence() const { return frame_sequence_; }
-  void set_frame_sequence(uint64_t value) { frame_sequence_ = value; _has_field_.set(4); }
+#include <stddef.h>
+#include <stdint.h>
 
-  bool has_affects_smoothness() const { return _has_field_[5]; }
-  bool affects_smoothness() const { return affects_smoothness_; }
-  void set_affects_smoothness(bool value) { affects_smoothness_ = value; _has_field_.set(5); }
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class ProcessTree_Process;
+class ProcessTree_Thread;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-  bool has_scroll_state() const { return _has_field_[6]; }
-  ChromeFrameReporter_ScrollState scroll_state() const { return scroll_state_; }
-  void set_scroll_state(ChromeFrameReporter_ScrollState value) { scroll_state_ = value; _has_field_.set(6); }
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-  bool has_has_main_animation() const { return _has_field_[7]; }
-  bool has_main_animation() const { return has_main_animation_; }
-  void set_has_main_animation(bool value) { has_main_animation_ = value; _has_field_.set(7); }
+class ProcessTree_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  ProcessTree_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProcessTree_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProcessTree_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_processes() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> processes() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  bool has_threads() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> threads() const { return GetRepeated<::protozero::ConstBytes>(2); }
+  bool has_collection_end_timestamp() const { return at<3>().valid(); }
+  uint64_t collection_end_timestamp() const { return at<3>().as_uint64(); }
+};
 
-  bool has_has_compositor_animation() const { return _has_field_[8]; }
-  bool has_compositor_animation() const { return has_compositor_animation_; }
-  void set_has_compositor_animation(bool value) { has_compositor_animation_ = value; _has_field_.set(8); }
+class ProcessTree : public ::protozero::Message {
+ public:
+  using Decoder = ProcessTree_Decoder;
+  enum : int32_t {
+    kProcessesFieldNumber = 1,
+    kThreadsFieldNumber = 2,
+    kCollectionEndTimestampFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ProcessTree"; }
 
-  bool has_has_smooth_input_main() const { return _has_field_[9]; }
-  bool has_smooth_input_main() const { return has_smooth_input_main_; }
-  void set_has_smooth_input_main(bool value) { has_smooth_input_main_ = value; _has_field_.set(9); }
+  using Thread = ::perfetto::protos::pbzero::ProcessTree_Thread;
+  using Process = ::perfetto::protos::pbzero::ProcessTree_Process;
 
-  bool has_has_missing_content() const { return _has_field_[10]; }
-  bool has_missing_content() const { return has_missing_content_; }
-  void set_has_missing_content(bool value) { has_missing_content_ = value; _has_field_.set(10); }
+  using FieldMetadata_Processes =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ProcessTree_Process,
+      ProcessTree>;
 
-  bool has_layer_tree_host_id() const { return _has_field_[11]; }
-  uint64_t layer_tree_host_id() const { return layer_tree_host_id_; }
-  void set_layer_tree_host_id(uint64_t value) { layer_tree_host_id_ = value; _has_field_.set(11); }
+  static constexpr FieldMetadata_Processes kProcesses{};
+  template <typename T = ProcessTree_Process> T* add_processes() {
+    return BeginNestedMessage<T>(1);
+  }
 
-  bool has_has_high_latency() const { return _has_field_[12]; }
-  bool has_high_latency() const { return has_high_latency_; }
-  void set_has_high_latency(bool value) { has_high_latency_ = value; _has_field_.set(12); }
 
-  bool has_frame_type() const { return _has_field_[13]; }
-  ChromeFrameReporter_FrameType frame_type() const { return frame_type_; }
-  void set_frame_type(ChromeFrameReporter_FrameType value) { frame_type_ = value; _has_field_.set(13); }
+  using FieldMetadata_Threads =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ProcessTree_Thread,
+      ProcessTree>;
 
-  const std::vector<std::string>& high_latency_contribution_stage() const { return high_latency_contribution_stage_; }
-  std::vector<std::string>* mutable_high_latency_contribution_stage() { return &high_latency_contribution_stage_; }
-  int high_latency_contribution_stage_size() const { return static_cast<int>(high_latency_contribution_stage_.size()); }
-  void clear_high_latency_contribution_stage() { high_latency_contribution_stage_.clear(); }
-  void add_high_latency_contribution_stage(std::string value) { high_latency_contribution_stage_.emplace_back(value); }
-  std::string* add_high_latency_contribution_stage() { high_latency_contribution_stage_.emplace_back(); return &high_latency_contribution_stage_.back(); }
+  static constexpr FieldMetadata_Threads kThreads{};
+  template <typename T = ProcessTree_Thread> T* add_threads() {
+    return BeginNestedMessage<T>(2);
+  }
 
- private:
-  ChromeFrameReporter_State state_{};
-  ChromeFrameReporter_FrameDropReason reason_{};
-  uint64_t frame_source_{};
-  uint64_t frame_sequence_{};
-  bool affects_smoothness_{};
-  ChromeFrameReporter_ScrollState scroll_state_{};
-  bool has_main_animation_{};
-  bool has_compositor_animation_{};
-  bool has_smooth_input_main_{};
-  bool has_missing_content_{};
-  uint64_t layer_tree_host_id_{};
-  bool has_high_latency_{};
-  ChromeFrameReporter_FrameType frame_type_{};
-  std::vector<std::string> high_latency_contribution_stage_;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_CollectionEndTimestamp =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProcessTree>;
 
-  std::bitset<15> _has_field_{};
+  static constexpr FieldMetadata_CollectionEndTimestamp kCollectionEndTimestamp{};
+  void set_collection_end_timestamp(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CollectionEndTimestamp::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+class ProcessTree_Process_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9> {
+ public:
+  ProcessTree_Process_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProcessTree_Process_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProcessTree_Process_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  int32_t pid() const { return at<1>().as_int32(); }
+  bool has_ppid() const { return at<2>().valid(); }
+  int32_t ppid() const { return at<2>().as_int32(); }
+  bool has_cmdline() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> cmdline() const { return GetRepeated<::protozero::ConstChars>(3); }
+  bool has_cmdline_is_comm() const { return at<9>().valid(); }
+  bool cmdline_is_comm() const { return at<9>().as_bool(); }
+  bool has_uid() const { return at<5>().valid(); }
+  int32_t uid() const { return at<5>().as_int32(); }
+  bool has_nspid() const { return at<6>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> nspid() const { return GetRepeated<int32_t>(6); }
+  bool has_process_start_from_boot() const { return at<7>().valid(); }
+  uint64_t process_start_from_boot() const { return at<7>().as_uint64(); }
+  bool has_is_kthread() const { return at<8>().valid(); }
+  bool is_kthread() const { return at<8>().as_bool(); }
+};
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_FRAME_REPORTER_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_histogram_sample.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_HISTOGRAM_SAMPLE_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_HISTOGRAM_SAMPLE_PROTO_CPP_H_
+class ProcessTree_Process : public ::protozero::Message {
+ public:
+  using Decoder = ProcessTree_Process_Decoder;
+  enum : int32_t {
+    kPidFieldNumber = 1,
+    kPpidFieldNumber = 2,
+    kCmdlineFieldNumber = 3,
+    kCmdlineIsCommFieldNumber = 9,
+    kUidFieldNumber = 5,
+    kNspidFieldNumber = 6,
+    kProcessStartFromBootFieldNumber = 7,
+    kIsKthreadFieldNumber = 8,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ProcessTree.Process"; }
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  using FieldMetadata_Pid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ProcessTree_Process>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeHistogramSample;
-class HistogramName;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  using FieldMetadata_Ppid =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ProcessTree_Process>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+  static constexpr FieldMetadata_Ppid kPpid{};
+  void set_ppid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ppid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-class PERFETTO_EXPORT_COMPONENT ChromeHistogramSample : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kNameHashFieldNumber = 1,
-    kNameFieldNumber = 2,
-    kSampleFieldNumber = 3,
-    kNameIidFieldNumber = 4,
-  };
+  using FieldMetadata_Cmdline =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ProcessTree_Process>;
 
-  ChromeHistogramSample();
-  ~ChromeHistogramSample() override;
-  ChromeHistogramSample(ChromeHistogramSample&&) noexcept;
-  ChromeHistogramSample& operator=(ChromeHistogramSample&&);
-  ChromeHistogramSample(const ChromeHistogramSample&);
-  ChromeHistogramSample& operator=(const ChromeHistogramSample&);
-  bool operator==(const ChromeHistogramSample&) const;
-  bool operator!=(const ChromeHistogramSample& other) const { return !(*this == other); }
+  static constexpr FieldMetadata_Cmdline kCmdline{};
+  void add_cmdline(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Cmdline::kFieldId, data, size);
+  }
+  void add_cmdline(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Cmdline::kFieldId, chars.data, chars.size);
+  }
+  void add_cmdline(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cmdline::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_CmdlineIsComm =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ProcessTree_Process>;
 
-  bool has_name_hash() const { return _has_field_[1]; }
-  uint64_t name_hash() const { return name_hash_; }
-  void set_name_hash(uint64_t value) { name_hash_ = value; _has_field_.set(1); }
+  static constexpr FieldMetadata_CmdlineIsComm kCmdlineIsComm{};
+  void set_cmdline_is_comm(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_CmdlineIsComm::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_name() const { return _has_field_[2]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
+  using FieldMetadata_Uid =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ProcessTree_Process>;
 
-  bool has_sample() const { return _has_field_[3]; }
-  int64_t sample() const { return sample_; }
-  void set_sample(int64_t value) { sample_ = value; _has_field_.set(3); }
+  static constexpr FieldMetadata_Uid kUid{};
+  void set_uid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_name_iid() const { return _has_field_[4]; }
-  uint64_t name_iid() const { return name_iid_; }
-  void set_name_iid(uint64_t value) { name_iid_ = value; _has_field_.set(4); }
+  using FieldMetadata_Nspid =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ProcessTree_Process>;
 
- private:
-  uint64_t name_hash_{};
-  std::string name_{};
-  int64_t sample_{};
-  uint64_t name_iid_{};
+  static constexpr FieldMetadata_Nspid kNspid{};
+  void add_nspid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Nspid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_ProcessStartFromBoot =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ProcessTree_Process>;
 
-  std::bitset<5> _has_field_{};
+  static constexpr FieldMetadata_ProcessStartFromBoot kProcessStartFromBoot{};
+  void set_process_start_from_boot(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ProcessStartFromBoot::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IsKthread =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ProcessTree_Process>;
+
+  static constexpr FieldMetadata_IsKthread kIsKthread{};
+  void set_is_kthread(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsKthread::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 };
 
+class ProcessTree_Thread_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  ProcessTree_Thread_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProcessTree_Thread_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProcessTree_Thread_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_tid() const { return at<1>().valid(); }
+  int32_t tid() const { return at<1>().as_int32(); }
+  bool has_tgid() const { return at<3>().valid(); }
+  int32_t tgid() const { return at<3>().as_int32(); }
+  bool has_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars name() const { return at<2>().as_string(); }
+  bool has_nstid() const { return at<4>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> nstid() const { return GetRepeated<int32_t>(4); }
+};
 
-class PERFETTO_EXPORT_COMPONENT HistogramName : public ::protozero::CppMessageObj {
+class ProcessTree_Thread : public ::protozero::Message {
  public:
-  enum FieldNumbers {
-    kIidFieldNumber = 1,
+  using Decoder = ProcessTree_Thread_Decoder;
+  enum : int32_t {
+    kTidFieldNumber = 1,
+    kTgidFieldNumber = 3,
     kNameFieldNumber = 2,
+    kNstidFieldNumber = 4,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.ProcessTree.Thread"; }
 
-  HistogramName();
-  ~HistogramName() override;
-  HistogramName(HistogramName&&) noexcept;
-  HistogramName& operator=(HistogramName&&);
-  HistogramName(const HistogramName&);
-  HistogramName& operator=(const HistogramName&);
-  bool operator==(const HistogramName&) const;
-  bool operator!=(const HistogramName& other) const { return !(*this == other); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_Tid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ProcessTree_Thread>;
 
-  bool has_iid() const { return _has_field_[1]; }
-  uint64_t iid() const { return iid_; }
-  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
+  static constexpr FieldMetadata_Tid kTid{};
+  void set_tid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_name() const { return _has_field_[2]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
+  using FieldMetadata_Tgid =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ProcessTree_Thread>;
 
- private:
-  uint64_t iid_{};
-  std::string name_{};
+  static constexpr FieldMetadata_Tgid kTgid{};
+  void set_tgid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Tgid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ProcessTree_Thread>;
 
-  std::bitset<3> _has_field_{};
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Nstid =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      ProcessTree_Thread>;
+
+  static constexpr FieldMetadata_Nstid kNstid{};
+  void add_nstid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Nstid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/statsd/statsd_atom.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_HISTOGRAM_SAMPLE_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_keyed_service.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_KEYED_SERVICE_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_KEYED_SERVICE_PROTO_CPP_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_STATSD_STATSD_ATOM_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_STATSD_STATSD_ATOM_PROTO_H_
 
+#include <stddef.h>
 #include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
 namespace perfetto {
 namespace protos {
-namespace gen {
-class ChromeKeyedService;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
+namespace pbzero {
+class Atom;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
 namespace perfetto {
 namespace protos {
-namespace gen {
+namespace pbzero {
 
-class PERFETTO_EXPORT_COMPONENT ChromeKeyedService : public ::protozero::CppMessageObj {
+class StatsdAtom_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  enum FieldNumbers {
-    kNameFieldNumber = 1,
+  StatsdAtom_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit StatsdAtom_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit StatsdAtom_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_atom() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> atom() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  bool has_timestamp_nanos() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<int64_t> timestamp_nanos() const { return GetRepeated<int64_t>(2); }
+};
+
+class StatsdAtom : public ::protozero::Message {
+ public:
+  using Decoder = StatsdAtom_Decoder;
+  enum : int32_t {
+    kAtomFieldNumber = 1,
+    kTimestampNanosFieldNumber = 2,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.StatsdAtom"; }
 
-  ChromeKeyedService();
-  ~ChromeKeyedService() override;
-  ChromeKeyedService(ChromeKeyedService&&) noexcept;
-  ChromeKeyedService& operator=(ChromeKeyedService&&);
-  ChromeKeyedService(const ChromeKeyedService&);
-  ChromeKeyedService& operator=(const ChromeKeyedService&);
-  bool operator==(const ChromeKeyedService&) const;
-  bool operator!=(const ChromeKeyedService& other) const { return !(*this == other); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_Atom =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      Atom,
+      StatsdAtom>;
 
-  bool has_name() const { return _has_field_[1]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
+  static constexpr FieldMetadata_Atom kAtom{};
+  template <typename T = Atom> T* add_atom() {
+    return BeginNestedMessage<T>(1);
+  }
 
- private:
-  std::string name_{};
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_TimestampNanos =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      StatsdAtom>;
 
-  std::bitset<2> _has_field_{};
+  static constexpr FieldMetadata_TimestampNanos kTimestampNanos{};
+  void add_timestamp_nanos(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimestampNanos::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+class Atom_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0> {
+ public:
+  Atom_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Atom_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Atom_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+};
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_KEYED_SERVICE_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_latency_info.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LATENCY_INFO_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LATENCY_INFO_PROTO_CPP_H_
+class Atom : public ::protozero::Message {
+ public:
+  using Decoder = Atom_Decoder;
+  static constexpr const char* GetName() { return ".perfetto.protos.Atom"; }
+
+};
+
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/sys_stats/sys_stats.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_SYS_STATS_SYS_STATS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_SYS_STATS_SYS_STATS_PROTO_H_
+
+#include <stddef.h>
 #include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
 namespace perfetto {
 namespace protos {
-namespace gen {
-class ChromeLatencyInfo;
-class ChromeLatencyInfo_ComponentInfo;
-enum ChromeLatencyInfo_Step : int;
-enum ChromeLatencyInfo_LatencyComponentType : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
+namespace pbzero {
+class SysStats_BuddyInfo;
+class SysStats_CpuIdleState;
+class SysStats_CpuIdleStateEntry;
+class SysStats_CpuTimes;
+class SysStats_DevfreqValue;
+class SysStats_DiskStat;
+class SysStats_InterruptCount;
+class SysStats_MeminfoValue;
+class SysStats_PsiSample;
+class SysStats_ThermalZone;
+class SysStats_VmstatValue;
+enum MeminfoCounters : int32_t;
+namespace perfetto_pbzero_enum_SysStats_PsiSample {
+enum PsiResource : int32_t;
+}  // namespace perfetto_pbzero_enum_SysStats_PsiSample
+using SysStats_PsiSample_PsiResource = perfetto_pbzero_enum_SysStats_PsiSample::PsiResource;
+enum VmstatCounters : int32_t;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
 namespace perfetto {
 namespace protos {
-namespace gen {
-enum ChromeLatencyInfo_Step : int {
-  ChromeLatencyInfo_Step_STEP_UNSPECIFIED = 0,
-  ChromeLatencyInfo_Step_STEP_SEND_INPUT_EVENT_UI = 3,
-  ChromeLatencyInfo_Step_STEP_HANDLE_INPUT_EVENT_IMPL = 5,
-  ChromeLatencyInfo_Step_STEP_DID_HANDLE_INPUT_AND_OVERSCROLL = 8,
-  ChromeLatencyInfo_Step_STEP_HANDLE_INPUT_EVENT_MAIN = 4,
-  ChromeLatencyInfo_Step_STEP_MAIN_THREAD_SCROLL_UPDATE = 2,
-  ChromeLatencyInfo_Step_STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT = 1,
-  ChromeLatencyInfo_Step_STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL = 9,
-  ChromeLatencyInfo_Step_STEP_HANDLED_INPUT_EVENT_IMPL = 10,
-  ChromeLatencyInfo_Step_STEP_SWAP_BUFFERS = 6,
-  ChromeLatencyInfo_Step_STEP_DRAW_AND_SWAP = 7,
-  ChromeLatencyInfo_Step_STEP_FINISHED_SWAP_BUFFERS = 11,
-};
-enum ChromeLatencyInfo_LatencyComponentType : int {
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_UNSPECIFIED = 0,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH = 1,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL = 2,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL = 3,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL = 4,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_UI = 5,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN = 6,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN = 7,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL = 8,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT = 9,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH = 10,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP = 11,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME = 12,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER = 13,
-  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP = 14,
-};
-
-class PERFETTO_EXPORT_COMPONENT ChromeLatencyInfo : public ::protozero::CppMessageObj {
- public:
-  using ComponentInfo = ChromeLatencyInfo_ComponentInfo;
-  using Step = ChromeLatencyInfo_Step;
-  static constexpr auto STEP_UNSPECIFIED = ChromeLatencyInfo_Step_STEP_UNSPECIFIED;
-  static constexpr auto STEP_SEND_INPUT_EVENT_UI = ChromeLatencyInfo_Step_STEP_SEND_INPUT_EVENT_UI;
-  static constexpr auto STEP_HANDLE_INPUT_EVENT_IMPL = ChromeLatencyInfo_Step_STEP_HANDLE_INPUT_EVENT_IMPL;
-  static constexpr auto STEP_DID_HANDLE_INPUT_AND_OVERSCROLL = ChromeLatencyInfo_Step_STEP_DID_HANDLE_INPUT_AND_OVERSCROLL;
-  static constexpr auto STEP_HANDLE_INPUT_EVENT_MAIN = ChromeLatencyInfo_Step_STEP_HANDLE_INPUT_EVENT_MAIN;
-  static constexpr auto STEP_MAIN_THREAD_SCROLL_UPDATE = ChromeLatencyInfo_Step_STEP_MAIN_THREAD_SCROLL_UPDATE;
-  static constexpr auto STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT = ChromeLatencyInfo_Step_STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT;
-  static constexpr auto STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL = ChromeLatencyInfo_Step_STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL;
-  static constexpr auto STEP_HANDLED_INPUT_EVENT_IMPL = ChromeLatencyInfo_Step_STEP_HANDLED_INPUT_EVENT_IMPL;
-  static constexpr auto STEP_SWAP_BUFFERS = ChromeLatencyInfo_Step_STEP_SWAP_BUFFERS;
-  static constexpr auto STEP_DRAW_AND_SWAP = ChromeLatencyInfo_Step_STEP_DRAW_AND_SWAP;
-  static constexpr auto STEP_FINISHED_SWAP_BUFFERS = ChromeLatencyInfo_Step_STEP_FINISHED_SWAP_BUFFERS;
-  static constexpr auto Step_MIN = ChromeLatencyInfo_Step_STEP_UNSPECIFIED;
-  static constexpr auto Step_MAX = ChromeLatencyInfo_Step_STEP_FINISHED_SWAP_BUFFERS;
-  using LatencyComponentType = ChromeLatencyInfo_LatencyComponentType;
-  static constexpr auto COMPONENT_UNSPECIFIED = ChromeLatencyInfo_LatencyComponentType_COMPONENT_UNSPECIFIED;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_UI = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_UI;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP;
-  static constexpr auto COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME = ChromeLatencyInfo_LatencyComponentType_COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME;
-  static constexpr auto COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER;
-  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP;
-  static constexpr auto LatencyComponentType_MIN = ChromeLatencyInfo_LatencyComponentType_COMPONENT_UNSPECIFIED;
-  static constexpr auto LatencyComponentType_MAX = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP;
-  enum FieldNumbers {
-    kTraceIdFieldNumber = 1,
-    kStepFieldNumber = 2,
-    kFrameTreeNodeIdFieldNumber = 3,
-    kComponentInfoFieldNumber = 4,
-    kIsCoalescedFieldNumber = 5,
-    kGestureScrollIdFieldNumber = 6,
-    kTouchIdFieldNumber = 7,
-  };
+namespace pbzero {
 
-  ChromeLatencyInfo();
-  ~ChromeLatencyInfo() override;
-  ChromeLatencyInfo(ChromeLatencyInfo&&) noexcept;
-  ChromeLatencyInfo& operator=(ChromeLatencyInfo&&);
-  ChromeLatencyInfo(const ChromeLatencyInfo&);
-  ChromeLatencyInfo& operator=(const ChromeLatencyInfo&);
-  bool operator==(const ChromeLatencyInfo&) const;
-  bool operator!=(const ChromeLatencyInfo& other) const { return !(*this == other); }
+namespace perfetto_pbzero_enum_SysStats_PsiSample {
+enum PsiResource : int32_t {
+  PSI_RESOURCE_UNSPECIFIED = 0,
+  PSI_RESOURCE_CPU_SOME = 1,
+  PSI_RESOURCE_CPU_FULL = 2,
+  PSI_RESOURCE_IO_SOME = 3,
+  PSI_RESOURCE_IO_FULL = 4,
+  PSI_RESOURCE_MEMORY_SOME = 5,
+  PSI_RESOURCE_MEMORY_FULL = 6,
+};
+} // namespace perfetto_pbzero_enum_SysStats_PsiSample
+using SysStats_PsiSample_PsiResource = perfetto_pbzero_enum_SysStats_PsiSample::PsiResource;
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
 
-  bool has_trace_id() const { return _has_field_[1]; }
-  int64_t trace_id() const { return trace_id_; }
-  void set_trace_id(int64_t value) { trace_id_ = value; _has_field_.set(1); }
+constexpr SysStats_PsiSample_PsiResource SysStats_PsiSample_PsiResource_MIN = SysStats_PsiSample_PsiResource::PSI_RESOURCE_UNSPECIFIED;
+constexpr SysStats_PsiSample_PsiResource SysStats_PsiSample_PsiResource_MAX = SysStats_PsiSample_PsiResource::PSI_RESOURCE_MEMORY_FULL;
 
-  bool has_step() const { return _has_field_[2]; }
-  ChromeLatencyInfo_Step step() const { return step_; }
-  void set_step(ChromeLatencyInfo_Step value) { step_ = value; _has_field_.set(2); }
 
-  bool has_frame_tree_node_id() const { return _has_field_[3]; }
-  int32_t frame_tree_node_id() const { return frame_tree_node_id_; }
-  void set_frame_tree_node_id(int32_t value) { frame_tree_node_id_ = value; _has_field_.set(3); }
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* SysStats_PsiSample_PsiResource_Name(::perfetto::protos::pbzero::SysStats_PsiSample_PsiResource value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::SysStats_PsiSample_PsiResource::PSI_RESOURCE_UNSPECIFIED:
+    return "PSI_RESOURCE_UNSPECIFIED";
 
-  const std::vector<ChromeLatencyInfo_ComponentInfo>& component_info() const { return component_info_; }
-  std::vector<ChromeLatencyInfo_ComponentInfo>* mutable_component_info() { return &component_info_; }
-  int component_info_size() const;
-  void clear_component_info();
-  ChromeLatencyInfo_ComponentInfo* add_component_info();
+  case ::perfetto::protos::pbzero::SysStats_PsiSample_PsiResource::PSI_RESOURCE_CPU_SOME:
+    return "PSI_RESOURCE_CPU_SOME";
 
-  bool has_is_coalesced() const { return _has_field_[5]; }
-  bool is_coalesced() const { return is_coalesced_; }
-  void set_is_coalesced(bool value) { is_coalesced_ = value; _has_field_.set(5); }
+  case ::perfetto::protos::pbzero::SysStats_PsiSample_PsiResource::PSI_RESOURCE_CPU_FULL:
+    return "PSI_RESOURCE_CPU_FULL";
 
-  bool has_gesture_scroll_id() const { return _has_field_[6]; }
-  int64_t gesture_scroll_id() const { return gesture_scroll_id_; }
-  void set_gesture_scroll_id(int64_t value) { gesture_scroll_id_ = value; _has_field_.set(6); }
+  case ::perfetto::protos::pbzero::SysStats_PsiSample_PsiResource::PSI_RESOURCE_IO_SOME:
+    return "PSI_RESOURCE_IO_SOME";
 
-  bool has_touch_id() const { return _has_field_[7]; }
-  int64_t touch_id() const { return touch_id_; }
-  void set_touch_id(int64_t value) { touch_id_ = value; _has_field_.set(7); }
+  case ::perfetto::protos::pbzero::SysStats_PsiSample_PsiResource::PSI_RESOURCE_IO_FULL:
+    return "PSI_RESOURCE_IO_FULL";
 
- private:
-  int64_t trace_id_{};
-  ChromeLatencyInfo_Step step_{};
-  int32_t frame_tree_node_id_{};
-  std::vector<ChromeLatencyInfo_ComponentInfo> component_info_;
-  bool is_coalesced_{};
-  int64_t gesture_scroll_id_{};
-  int64_t touch_id_{};
+  case ::perfetto::protos::pbzero::SysStats_PsiSample_PsiResource::PSI_RESOURCE_MEMORY_SOME:
+    return "PSI_RESOURCE_MEMORY_SOME";
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  case ::perfetto::protos::pbzero::SysStats_PsiSample_PsiResource::PSI_RESOURCE_MEMORY_FULL:
+    return "PSI_RESOURCE_MEMORY_FULL";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
-  std::bitset<8> _has_field_{};
+class SysStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/17> {
+ public:
+  SysStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SysStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SysStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_meminfo() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> meminfo() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  bool has_vmstat() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> vmstat() const { return GetRepeated<::protozero::ConstBytes>(2); }
+  bool has_cpu_stat() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> cpu_stat() const { return GetRepeated<::protozero::ConstBytes>(3); }
+  bool has_num_forks() const { return at<4>().valid(); }
+  uint64_t num_forks() const { return at<4>().as_uint64(); }
+  bool has_num_irq_total() const { return at<5>().valid(); }
+  uint64_t num_irq_total() const { return at<5>().as_uint64(); }
+  bool has_num_irq() const { return at<6>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> num_irq() const { return GetRepeated<::protozero::ConstBytes>(6); }
+  bool has_num_softirq_total() const { return at<7>().valid(); }
+  uint64_t num_softirq_total() const { return at<7>().as_uint64(); }
+  bool has_num_softirq() const { return at<8>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> num_softirq() const { return GetRepeated<::protozero::ConstBytes>(8); }
+  bool has_collection_end_timestamp() const { return at<9>().valid(); }
+  uint64_t collection_end_timestamp() const { return at<9>().as_uint64(); }
+  bool has_devfreq() const { return at<10>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> devfreq() const { return GetRepeated<::protozero::ConstBytes>(10); }
+  bool has_cpufreq_khz() const { return at<11>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint32_t> cpufreq_khz() const { return GetRepeated<uint32_t>(11); }
+  bool has_buddy_info() const { return at<12>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> buddy_info() const { return GetRepeated<::protozero::ConstBytes>(12); }
+  bool has_disk_stat() const { return at<13>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> disk_stat() const { return GetRepeated<::protozero::ConstBytes>(13); }
+  bool has_psi() const { return at<14>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> psi() const { return GetRepeated<::protozero::ConstBytes>(14); }
+  bool has_thermal_zone() const { return at<15>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> thermal_zone() const { return GetRepeated<::protozero::ConstBytes>(15); }
+  bool has_cpuidle_state() const { return at<16>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> cpuidle_state() const { return GetRepeated<::protozero::ConstBytes>(16); }
+  bool has_gpufreq_mhz() const { return at<17>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint64_t> gpufreq_mhz() const { return GetRepeated<uint64_t>(17); }
 };
 
-
-class PERFETTO_EXPORT_COMPONENT ChromeLatencyInfo_ComponentInfo : public ::protozero::CppMessageObj {
+class SysStats : public ::protozero::Message {
  public:
-  enum FieldNumbers {
-    kComponentTypeFieldNumber = 1,
-    kTimeUsFieldNumber = 2,
+  using Decoder = SysStats_Decoder;
+  enum : int32_t {
+    kMeminfoFieldNumber = 1,
+    kVmstatFieldNumber = 2,
+    kCpuStatFieldNumber = 3,
+    kNumForksFieldNumber = 4,
+    kNumIrqTotalFieldNumber = 5,
+    kNumIrqFieldNumber = 6,
+    kNumSoftirqTotalFieldNumber = 7,
+    kNumSoftirqFieldNumber = 8,
+    kCollectionEndTimestampFieldNumber = 9,
+    kDevfreqFieldNumber = 10,
+    kCpufreqKhzFieldNumber = 11,
+    kBuddyInfoFieldNumber = 12,
+    kDiskStatFieldNumber = 13,
+    kPsiFieldNumber = 14,
+    kThermalZoneFieldNumber = 15,
+    kCpuidleStateFieldNumber = 16,
+    kGpufreqMhzFieldNumber = 17,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.SysStats"; }
 
-  ChromeLatencyInfo_ComponentInfo();
-  ~ChromeLatencyInfo_ComponentInfo() override;
-  ChromeLatencyInfo_ComponentInfo(ChromeLatencyInfo_ComponentInfo&&) noexcept;
-  ChromeLatencyInfo_ComponentInfo& operator=(ChromeLatencyInfo_ComponentInfo&&);
-  ChromeLatencyInfo_ComponentInfo(const ChromeLatencyInfo_ComponentInfo&);
-  ChromeLatencyInfo_ComponentInfo& operator=(const ChromeLatencyInfo_ComponentInfo&);
-  bool operator==(const ChromeLatencyInfo_ComponentInfo&) const;
-  bool operator!=(const ChromeLatencyInfo_ComponentInfo& other) const { return !(*this == other); }
+  using MeminfoValue = ::perfetto::protos::pbzero::SysStats_MeminfoValue;
+  using VmstatValue = ::perfetto::protos::pbzero::SysStats_VmstatValue;
+  using CpuTimes = ::perfetto::protos::pbzero::SysStats_CpuTimes;
+  using InterruptCount = ::perfetto::protos::pbzero::SysStats_InterruptCount;
+  using DevfreqValue = ::perfetto::protos::pbzero::SysStats_DevfreqValue;
+  using BuddyInfo = ::perfetto::protos::pbzero::SysStats_BuddyInfo;
+  using DiskStat = ::perfetto::protos::pbzero::SysStats_DiskStat;
+  using PsiSample = ::perfetto::protos::pbzero::SysStats_PsiSample;
+  using ThermalZone = ::perfetto::protos::pbzero::SysStats_ThermalZone;
+  using CpuIdleStateEntry = ::perfetto::protos::pbzero::SysStats_CpuIdleStateEntry;
+  using CpuIdleState = ::perfetto::protos::pbzero::SysStats_CpuIdleState;
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_Meminfo =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SysStats_MeminfoValue,
+      SysStats>;
 
-  bool has_component_type() const { return _has_field_[1]; }
-  ChromeLatencyInfo_LatencyComponentType component_type() const { return component_type_; }
-  void set_component_type(ChromeLatencyInfo_LatencyComponentType value) { component_type_ = value; _has_field_.set(1); }
+  static constexpr FieldMetadata_Meminfo kMeminfo{};
+  template <typename T = SysStats_MeminfoValue> T* add_meminfo() {
+    return BeginNestedMessage<T>(1);
+  }
 
-  bool has_time_us() const { return _has_field_[2]; }
-  uint64_t time_us() const { return time_us_; }
-  void set_time_us(uint64_t value) { time_us_ = value; _has_field_.set(2); }
 
- private:
-  ChromeLatencyInfo_LatencyComponentType component_type_{};
-  uint64_t time_us_{};
+  using FieldMetadata_Vmstat =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SysStats_VmstatValue,
+      SysStats>;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  static constexpr FieldMetadata_Vmstat kVmstat{};
+  template <typename T = SysStats_VmstatValue> T* add_vmstat() {
+    return BeginNestedMessage<T>(2);
+  }
 
-  std::bitset<3> _has_field_{};
-};
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  using FieldMetadata_CpuStat =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SysStats_CpuTimes,
+      SysStats>;
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LATENCY_INFO_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_legacy_ipc.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LEGACY_IPC_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LEGACY_IPC_PROTO_CPP_H_
+  static constexpr FieldMetadata_CpuStat kCpuStat{};
+  template <typename T = SysStats_CpuTimes> T* add_cpu_stat() {
+    return BeginNestedMessage<T>(3);
+  }
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  using FieldMetadata_NumForks =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeLegacyIpc;
-enum ChromeLegacyIpc_MessageClass : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  static constexpr FieldMetadata_NumForks kNumForks{};
+  void set_num_forks(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NumForks::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  using FieldMetadata_NumIrqTotal =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum ChromeLegacyIpc_MessageClass : int {
-  ChromeLegacyIpc_MessageClass_CLASS_UNSPECIFIED = 0,
-  ChromeLegacyIpc_MessageClass_CLASS_AUTOMATION = 1,
-  ChromeLegacyIpc_MessageClass_CLASS_FRAME = 2,
-  ChromeLegacyIpc_MessageClass_CLASS_PAGE = 3,
-  ChromeLegacyIpc_MessageClass_CLASS_VIEW = 4,
-  ChromeLegacyIpc_MessageClass_CLASS_WIDGET = 5,
-  ChromeLegacyIpc_MessageClass_CLASS_INPUT = 6,
-  ChromeLegacyIpc_MessageClass_CLASS_TEST = 7,
-  ChromeLegacyIpc_MessageClass_CLASS_WORKER = 8,
-  ChromeLegacyIpc_MessageClass_CLASS_NACL = 9,
-  ChromeLegacyIpc_MessageClass_CLASS_GPU_CHANNEL = 10,
-  ChromeLegacyIpc_MessageClass_CLASS_MEDIA = 11,
-  ChromeLegacyIpc_MessageClass_CLASS_PPAPI = 12,
-  ChromeLegacyIpc_MessageClass_CLASS_CHROME = 13,
-  ChromeLegacyIpc_MessageClass_CLASS_DRAG = 14,
-  ChromeLegacyIpc_MessageClass_CLASS_PRINT = 15,
-  ChromeLegacyIpc_MessageClass_CLASS_EXTENSION = 16,
-  ChromeLegacyIpc_MessageClass_CLASS_TEXT_INPUT_CLIENT = 17,
-  ChromeLegacyIpc_MessageClass_CLASS_BLINK_TEST = 18,
-  ChromeLegacyIpc_MessageClass_CLASS_ACCESSIBILITY = 19,
-  ChromeLegacyIpc_MessageClass_CLASS_PRERENDER = 20,
-  ChromeLegacyIpc_MessageClass_CLASS_CHROMOTING = 21,
-  ChromeLegacyIpc_MessageClass_CLASS_BROWSER_PLUGIN = 22,
-  ChromeLegacyIpc_MessageClass_CLASS_ANDROID_WEB_VIEW = 23,
-  ChromeLegacyIpc_MessageClass_CLASS_NACL_HOST = 24,
-  ChromeLegacyIpc_MessageClass_CLASS_ENCRYPTED_MEDIA = 25,
-  ChromeLegacyIpc_MessageClass_CLASS_CAST = 26,
-  ChromeLegacyIpc_MessageClass_CLASS_GIN_JAVA_BRIDGE = 27,
-  ChromeLegacyIpc_MessageClass_CLASS_CHROME_UTILITY_PRINTING = 28,
-  ChromeLegacyIpc_MessageClass_CLASS_OZONE_GPU = 29,
-  ChromeLegacyIpc_MessageClass_CLASS_WEB_TEST = 30,
-  ChromeLegacyIpc_MessageClass_CLASS_NETWORK_HINTS = 31,
-  ChromeLegacyIpc_MessageClass_CLASS_EXTENSIONS_GUEST_VIEW = 32,
-  ChromeLegacyIpc_MessageClass_CLASS_GUEST_VIEW = 33,
-  ChromeLegacyIpc_MessageClass_CLASS_MEDIA_PLAYER_DELEGATE = 34,
-  ChromeLegacyIpc_MessageClass_CLASS_EXTENSION_WORKER = 35,
-  ChromeLegacyIpc_MessageClass_CLASS_SUBRESOURCE_FILTER = 36,
-  ChromeLegacyIpc_MessageClass_CLASS_UNFREEZABLE_FRAME = 37,
-};
+  static constexpr FieldMetadata_NumIrqTotal kNumIrqTotal{};
+  void set_num_irq_total(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NumIrqTotal::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-class PERFETTO_EXPORT_COMPONENT ChromeLegacyIpc : public ::protozero::CppMessageObj {
- public:
-  using MessageClass = ChromeLegacyIpc_MessageClass;
-  static constexpr auto CLASS_UNSPECIFIED = ChromeLegacyIpc_MessageClass_CLASS_UNSPECIFIED;
-  static constexpr auto CLASS_AUTOMATION = ChromeLegacyIpc_MessageClass_CLASS_AUTOMATION;
-  static constexpr auto CLASS_FRAME = ChromeLegacyIpc_MessageClass_CLASS_FRAME;
-  static constexpr auto CLASS_PAGE = ChromeLegacyIpc_MessageClass_CLASS_PAGE;
-  static constexpr auto CLASS_VIEW = ChromeLegacyIpc_MessageClass_CLASS_VIEW;
-  static constexpr auto CLASS_WIDGET = ChromeLegacyIpc_MessageClass_CLASS_WIDGET;
-  static constexpr auto CLASS_INPUT = ChromeLegacyIpc_MessageClass_CLASS_INPUT;
-  static constexpr auto CLASS_TEST = ChromeLegacyIpc_MessageClass_CLASS_TEST;
-  static constexpr auto CLASS_WORKER = ChromeLegacyIpc_MessageClass_CLASS_WORKER;
-  static constexpr auto CLASS_NACL = ChromeLegacyIpc_MessageClass_CLASS_NACL;
-  static constexpr auto CLASS_GPU_CHANNEL = ChromeLegacyIpc_MessageClass_CLASS_GPU_CHANNEL;
-  static constexpr auto CLASS_MEDIA = ChromeLegacyIpc_MessageClass_CLASS_MEDIA;
-  static constexpr auto CLASS_PPAPI = ChromeLegacyIpc_MessageClass_CLASS_PPAPI;
-  static constexpr auto CLASS_CHROME = ChromeLegacyIpc_MessageClass_CLASS_CHROME;
-  static constexpr auto CLASS_DRAG = ChromeLegacyIpc_MessageClass_CLASS_DRAG;
-  static constexpr auto CLASS_PRINT = ChromeLegacyIpc_MessageClass_CLASS_PRINT;
-  static constexpr auto CLASS_EXTENSION = ChromeLegacyIpc_MessageClass_CLASS_EXTENSION;
-  static constexpr auto CLASS_TEXT_INPUT_CLIENT = ChromeLegacyIpc_MessageClass_CLASS_TEXT_INPUT_CLIENT;
-  static constexpr auto CLASS_BLINK_TEST = ChromeLegacyIpc_MessageClass_CLASS_BLINK_TEST;
-  static constexpr auto CLASS_ACCESSIBILITY = ChromeLegacyIpc_MessageClass_CLASS_ACCESSIBILITY;
-  static constexpr auto CLASS_PRERENDER = ChromeLegacyIpc_MessageClass_CLASS_PRERENDER;
-  static constexpr auto CLASS_CHROMOTING = ChromeLegacyIpc_MessageClass_CLASS_CHROMOTING;
-  static constexpr auto CLASS_BROWSER_PLUGIN = ChromeLegacyIpc_MessageClass_CLASS_BROWSER_PLUGIN;
-  static constexpr auto CLASS_ANDROID_WEB_VIEW = ChromeLegacyIpc_MessageClass_CLASS_ANDROID_WEB_VIEW;
-  static constexpr auto CLASS_NACL_HOST = ChromeLegacyIpc_MessageClass_CLASS_NACL_HOST;
-  static constexpr auto CLASS_ENCRYPTED_MEDIA = ChromeLegacyIpc_MessageClass_CLASS_ENCRYPTED_MEDIA;
-  static constexpr auto CLASS_CAST = ChromeLegacyIpc_MessageClass_CLASS_CAST;
-  static constexpr auto CLASS_GIN_JAVA_BRIDGE = ChromeLegacyIpc_MessageClass_CLASS_GIN_JAVA_BRIDGE;
-  static constexpr auto CLASS_CHROME_UTILITY_PRINTING = ChromeLegacyIpc_MessageClass_CLASS_CHROME_UTILITY_PRINTING;
-  static constexpr auto CLASS_OZONE_GPU = ChromeLegacyIpc_MessageClass_CLASS_OZONE_GPU;
-  static constexpr auto CLASS_WEB_TEST = ChromeLegacyIpc_MessageClass_CLASS_WEB_TEST;
-  static constexpr auto CLASS_NETWORK_HINTS = ChromeLegacyIpc_MessageClass_CLASS_NETWORK_HINTS;
-  static constexpr auto CLASS_EXTENSIONS_GUEST_VIEW = ChromeLegacyIpc_MessageClass_CLASS_EXTENSIONS_GUEST_VIEW;
-  static constexpr auto CLASS_GUEST_VIEW = ChromeLegacyIpc_MessageClass_CLASS_GUEST_VIEW;
-  static constexpr auto CLASS_MEDIA_PLAYER_DELEGATE = ChromeLegacyIpc_MessageClass_CLASS_MEDIA_PLAYER_DELEGATE;
-  static constexpr auto CLASS_EXTENSION_WORKER = ChromeLegacyIpc_MessageClass_CLASS_EXTENSION_WORKER;
-  static constexpr auto CLASS_SUBRESOURCE_FILTER = ChromeLegacyIpc_MessageClass_CLASS_SUBRESOURCE_FILTER;
-  static constexpr auto CLASS_UNFREEZABLE_FRAME = ChromeLegacyIpc_MessageClass_CLASS_UNFREEZABLE_FRAME;
-  static constexpr auto MessageClass_MIN = ChromeLegacyIpc_MessageClass_CLASS_UNSPECIFIED;
-  static constexpr auto MessageClass_MAX = ChromeLegacyIpc_MessageClass_CLASS_UNFREEZABLE_FRAME;
-  enum FieldNumbers {
-    kMessageClassFieldNumber = 1,
-    kMessageLineFieldNumber = 2,
-  };
+  using FieldMetadata_NumIrq =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SysStats_InterruptCount,
+      SysStats>;
 
-  ChromeLegacyIpc();
-  ~ChromeLegacyIpc() override;
-  ChromeLegacyIpc(ChromeLegacyIpc&&) noexcept;
-  ChromeLegacyIpc& operator=(ChromeLegacyIpc&&);
-  ChromeLegacyIpc(const ChromeLegacyIpc&);
-  ChromeLegacyIpc& operator=(const ChromeLegacyIpc&);
-  bool operator==(const ChromeLegacyIpc&) const;
-  bool operator!=(const ChromeLegacyIpc& other) const { return !(*this == other); }
+  static constexpr FieldMetadata_NumIrq kNumIrq{};
+  template <typename T = SysStats_InterruptCount> T* add_num_irq() {
+    return BeginNestedMessage<T>(6);
+  }
+
+
+  using FieldMetadata_NumSoftirqTotal =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats>;
+
+  static constexpr FieldMetadata_NumSoftirqTotal kNumSoftirqTotal{};
+  void set_num_softirq_total(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_NumSoftirqTotal::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_NumSoftirq =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SysStats_InterruptCount,
+      SysStats>;
 
-  bool has_message_class() const { return _has_field_[1]; }
-  ChromeLegacyIpc_MessageClass message_class() const { return message_class_; }
-  void set_message_class(ChromeLegacyIpc_MessageClass value) { message_class_ = value; _has_field_.set(1); }
+  static constexpr FieldMetadata_NumSoftirq kNumSoftirq{};
+  template <typename T = SysStats_InterruptCount> T* add_num_softirq() {
+    return BeginNestedMessage<T>(8);
+  }
 
-  bool has_message_line() const { return _has_field_[2]; }
-  uint32_t message_line() const { return message_line_; }
-  void set_message_line(uint32_t value) { message_line_ = value; _has_field_.set(2); }
 
- private:
-  ChromeLegacyIpc_MessageClass message_class_{};
-  uint32_t message_line_{};
+  using FieldMetadata_CollectionEndTimestamp =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats>;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  static constexpr FieldMetadata_CollectionEndTimestamp kCollectionEndTimestamp{};
+  void set_collection_end_timestamp(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CollectionEndTimestamp::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  std::bitset<3> _has_field_{};
-};
+  using FieldMetadata_Devfreq =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SysStats_DevfreqValue,
+      SysStats>;
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  static constexpr FieldMetadata_Devfreq kDevfreq{};
+  template <typename T = SysStats_DevfreqValue> T* add_devfreq() {
+    return BeginNestedMessage<T>(10);
+  }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LEGACY_IPC_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_message_pump.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MESSAGE_PUMP_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MESSAGE_PUMP_PROTO_CPP_H_
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  using FieldMetadata_CpufreqKhz =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SysStats>;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  static constexpr FieldMetadata_CpufreqKhz kCpufreqKhz{};
+  void add_cpufreq_khz(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CpufreqKhz::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeMessagePump;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  using FieldMetadata_BuddyInfo =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SysStats_BuddyInfo,
+      SysStats>;
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  static constexpr FieldMetadata_BuddyInfo kBuddyInfo{};
+  template <typename T = SysStats_BuddyInfo> T* add_buddy_info() {
+    return BeginNestedMessage<T>(12);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
 
-class PERFETTO_EXPORT_COMPONENT ChromeMessagePump : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kSentMessagesInQueueFieldNumber = 1,
-    kIoHandlerLocationIidFieldNumber = 2,
-  };
+  using FieldMetadata_DiskStat =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SysStats_DiskStat,
+      SysStats>;
 
-  ChromeMessagePump();
-  ~ChromeMessagePump() override;
-  ChromeMessagePump(ChromeMessagePump&&) noexcept;
-  ChromeMessagePump& operator=(ChromeMessagePump&&);
-  ChromeMessagePump(const ChromeMessagePump&);
-  ChromeMessagePump& operator=(const ChromeMessagePump&);
-  bool operator==(const ChromeMessagePump&) const;
-  bool operator!=(const ChromeMessagePump& other) const { return !(*this == other); }
+  static constexpr FieldMetadata_DiskStat kDiskStat{};
+  template <typename T = SysStats_DiskStat> T* add_disk_stat() {
+    return BeginNestedMessage<T>(13);
+  }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
 
-  bool has_sent_messages_in_queue() const { return _has_field_[1]; }
-  bool sent_messages_in_queue() const { return sent_messages_in_queue_; }
-  void set_sent_messages_in_queue(bool value) { sent_messages_in_queue_ = value; _has_field_.set(1); }
+  using FieldMetadata_Psi =
+    ::protozero::proto_utils::FieldMetadata<
+      14,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SysStats_PsiSample,
+      SysStats>;
 
-  bool has_io_handler_location_iid() const { return _has_field_[2]; }
-  uint64_t io_handler_location_iid() const { return io_handler_location_iid_; }
-  void set_io_handler_location_iid(uint64_t value) { io_handler_location_iid_ = value; _has_field_.set(2); }
+  static constexpr FieldMetadata_Psi kPsi{};
+  template <typename T = SysStats_PsiSample> T* add_psi() {
+    return BeginNestedMessage<T>(14);
+  }
 
- private:
-  bool sent_messages_in_queue_{};
-  uint64_t io_handler_location_iid_{};
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_ThermalZone =
+    ::protozero::proto_utils::FieldMetadata<
+      15,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SysStats_ThermalZone,
+      SysStats>;
 
-  std::bitset<3> _has_field_{};
-};
+  static constexpr FieldMetadata_ThermalZone kThermalZone{};
+  template <typename T = SysStats_ThermalZone> T* add_thermal_zone() {
+    return BeginNestedMessage<T>(15);
+  }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MESSAGE_PUMP_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_mojo_event_info.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MOJO_EVENT_INFO_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MOJO_EVENT_INFO_PROTO_CPP_H_
+  using FieldMetadata_CpuidleState =
+    ::protozero::proto_utils::FieldMetadata<
+      16,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SysStats_CpuIdleState,
+      SysStats>;
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  static constexpr FieldMetadata_CpuidleState kCpuidleState{};
+  template <typename T = SysStats_CpuIdleState> T* add_cpuidle_state() {
+    return BeginNestedMessage<T>(16);
+  }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeMojoEventInfo;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  using FieldMetadata_GpufreqMhz =
+    ::protozero::proto_utils::FieldMetadata<
+      17,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats>;
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  static constexpr FieldMetadata_GpufreqMhz kGpufreqMhz{};
+  void add_gpufreq_mhz(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GpufreqMhz::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+class SysStats_CpuIdleState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  SysStats_CpuIdleState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SysStats_CpuIdleState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SysStats_CpuIdleState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cpu_id() const { return at<1>().valid(); }
+  uint32_t cpu_id() const { return at<1>().as_uint32(); }
+  bool has_cpuidle_state_entry() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> cpuidle_state_entry() const { return GetRepeated<::protozero::ConstBytes>(2); }
+};
 
-class PERFETTO_EXPORT_COMPONENT ChromeMojoEventInfo : public ::protozero::CppMessageObj {
+class SysStats_CpuIdleState : public ::protozero::Message {
  public:
-  enum FieldNumbers {
-    kWatcherNotifyInterfaceTagFieldNumber = 1,
-    kIpcHashFieldNumber = 2,
-    kMojoInterfaceTagFieldNumber = 3,
-    kMojoInterfaceMethodIidFieldNumber = 4,
-    kIsReplyFieldNumber = 5,
-    kPayloadSizeFieldNumber = 6,
-    kDataNumBytesFieldNumber = 7,
+  using Decoder = SysStats_CpuIdleState_Decoder;
+  enum : int32_t {
+    kCpuIdFieldNumber = 1,
+    kCpuidleStateEntryFieldNumber = 2,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.SysStats.CpuIdleState"; }
 
-  ChromeMojoEventInfo();
-  ~ChromeMojoEventInfo() override;
-  ChromeMojoEventInfo(ChromeMojoEventInfo&&) noexcept;
-  ChromeMojoEventInfo& operator=(ChromeMojoEventInfo&&);
-  ChromeMojoEventInfo(const ChromeMojoEventInfo&);
-  ChromeMojoEventInfo& operator=(const ChromeMojoEventInfo&);
-  bool operator==(const ChromeMojoEventInfo&) const;
-  bool operator!=(const ChromeMojoEventInfo& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_watcher_notify_interface_tag() const { return _has_field_[1]; }
-  const std::string& watcher_notify_interface_tag() const { return watcher_notify_interface_tag_; }
-  void set_watcher_notify_interface_tag(const std::string& value) { watcher_notify_interface_tag_ = value; _has_field_.set(1); }
-
-  bool has_ipc_hash() const { return _has_field_[2]; }
-  uint32_t ipc_hash() const { return ipc_hash_; }
-  void set_ipc_hash(uint32_t value) { ipc_hash_ = value; _has_field_.set(2); }
-
-  bool has_mojo_interface_tag() const { return _has_field_[3]; }
-  const std::string& mojo_interface_tag() const { return mojo_interface_tag_; }
-  void set_mojo_interface_tag(const std::string& value) { mojo_interface_tag_ = value; _has_field_.set(3); }
-
-  bool has_mojo_interface_method_iid() const { return _has_field_[4]; }
-  uint64_t mojo_interface_method_iid() const { return mojo_interface_method_iid_; }
-  void set_mojo_interface_method_iid(uint64_t value) { mojo_interface_method_iid_ = value; _has_field_.set(4); }
 
-  bool has_is_reply() const { return _has_field_[5]; }
-  bool is_reply() const { return is_reply_; }
-  void set_is_reply(bool value) { is_reply_ = value; _has_field_.set(5); }
+  using FieldMetadata_CpuId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SysStats_CpuIdleState>;
 
-  bool has_payload_size() const { return _has_field_[6]; }
-  uint64_t payload_size() const { return payload_size_; }
-  void set_payload_size(uint64_t value) { payload_size_ = value; _has_field_.set(6); }
+  static constexpr FieldMetadata_CpuId kCpuId{};
+  void set_cpu_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CpuId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_data_num_bytes() const { return _has_field_[7]; }
-  uint64_t data_num_bytes() const { return data_num_bytes_; }
-  void set_data_num_bytes(uint64_t value) { data_num_bytes_ = value; _has_field_.set(7); }
+  using FieldMetadata_CpuidleStateEntry =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SysStats_CpuIdleStateEntry,
+      SysStats_CpuIdleState>;
 
- private:
-  std::string watcher_notify_interface_tag_{};
-  uint32_t ipc_hash_{};
-  std::string mojo_interface_tag_{};
-  uint64_t mojo_interface_method_iid_{};
-  bool is_reply_{};
-  uint64_t payload_size_{};
-  uint64_t data_num_bytes_{};
+  static constexpr FieldMetadata_CpuidleStateEntry kCpuidleStateEntry{};
+  template <typename T = SysStats_CpuIdleStateEntry> T* add_cpuidle_state_entry() {
+    return BeginNestedMessage<T>(2);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+};
 
-  std::bitset<8> _has_field_{};
+class SysStats_CpuIdleStateEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  SysStats_CpuIdleStateEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SysStats_CpuIdleStateEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SysStats_CpuIdleStateEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_state() const { return at<1>().valid(); }
+  ::protozero::ConstChars state() const { return at<1>().as_string(); }
+  bool has_duration_us() const { return at<2>().valid(); }
+  uint64_t duration_us() const { return at<2>().as_uint64(); }
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+class SysStats_CpuIdleStateEntry : public ::protozero::Message {
+ public:
+  using Decoder = SysStats_CpuIdleStateEntry_Decoder;
+  enum : int32_t {
+    kStateFieldNumber = 1,
+    kDurationUsFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SysStats.CpuIdleStateEntry"; }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MOJO_EVENT_INFO_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_process_descriptor.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_PROCESS_DESCRIPTOR_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_PROCESS_DESCRIPTOR_PROTO_CPP_H_
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  using FieldMetadata_State =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SysStats_CpuIdleStateEntry>;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  static constexpr FieldMetadata_State kState{};
+  void set_state(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_State::kFieldId, data, size);
+  }
+  void set_state(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_State::kFieldId, chars.data, chars.size);
+  }
+  void set_state(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_State::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeProcessDescriptor;
-enum ChromeProcessDescriptor_ProcessType : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  using FieldMetadata_DurationUs =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_CpuIdleStateEntry>;
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  static constexpr FieldMetadata_DurationUs kDurationUs{};
+  void set_duration_us(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DurationUs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum ChromeProcessDescriptor_ProcessType : int {
-  ChromeProcessDescriptor_ProcessType_PROCESS_UNSPECIFIED = 0,
-  ChromeProcessDescriptor_ProcessType_PROCESS_BROWSER = 1,
-  ChromeProcessDescriptor_ProcessType_PROCESS_RENDERER = 2,
-  ChromeProcessDescriptor_ProcessType_PROCESS_UTILITY = 3,
-  ChromeProcessDescriptor_ProcessType_PROCESS_ZYGOTE = 4,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SANDBOX_HELPER = 5,
-  ChromeProcessDescriptor_ProcessType_PROCESS_GPU = 6,
-  ChromeProcessDescriptor_ProcessType_PROCESS_PPAPI_PLUGIN = 7,
-  ChromeProcessDescriptor_ProcessType_PROCESS_PPAPI_BROKER = 8,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_NETWORK = 9,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_TRACING = 10,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_STORAGE = 11,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_AUDIO = 12,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_DATA_DECODER = 13,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_UTIL_WIN = 14,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_PROXY_RESOLVER = 15,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_CDM = 16,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_VIDEO_CAPTURE = 17,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_UNZIPPER = 18,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_MIRRORING = 19,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_FILEPATCHER = 20,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_TTS = 21,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_PRINTING = 22,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_QUARANTINE = 23,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_CROS_LOCALSEARCH = 24,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_CROS_ASSISTANT_AUDIO_DECODER = 25,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_FILEUTIL = 26,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_PRINTCOMPOSITOR = 27,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_PAINTPREVIEW = 28,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_SPEECHRECOGNITION = 29,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_XRDEVICE = 30,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_READICON = 31,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_LANGUAGEDETECTION = 32,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_SHARING = 33,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_MEDIAPARSER = 34,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_QRCODEGENERATOR = 35,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_PROFILEIMPORT = 36,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_IME = 37,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_RECORDING = 38,
-  ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_SHAPEDETECTION = 39,
-  ChromeProcessDescriptor_ProcessType_PROCESS_RENDERER_EXTENSION = 40,
+class SysStats_ThermalZone_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  SysStats_ThermalZone_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SysStats_ThermalZone_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SysStats_ThermalZone_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_temp() const { return at<2>().valid(); }
+  uint64_t temp() const { return at<2>().as_uint64(); }
+  bool has_type() const { return at<3>().valid(); }
+  ::protozero::ConstChars type() const { return at<3>().as_string(); }
 };
 
-class PERFETTO_EXPORT_COMPONENT ChromeProcessDescriptor : public ::protozero::CppMessageObj {
+class SysStats_ThermalZone : public ::protozero::Message {
  public:
-  using ProcessType = ChromeProcessDescriptor_ProcessType;
-  static constexpr auto PROCESS_UNSPECIFIED = ChromeProcessDescriptor_ProcessType_PROCESS_UNSPECIFIED;
-  static constexpr auto PROCESS_BROWSER = ChromeProcessDescriptor_ProcessType_PROCESS_BROWSER;
-  static constexpr auto PROCESS_RENDERER = ChromeProcessDescriptor_ProcessType_PROCESS_RENDERER;
-  static constexpr auto PROCESS_UTILITY = ChromeProcessDescriptor_ProcessType_PROCESS_UTILITY;
-  static constexpr auto PROCESS_ZYGOTE = ChromeProcessDescriptor_ProcessType_PROCESS_ZYGOTE;
-  static constexpr auto PROCESS_SANDBOX_HELPER = ChromeProcessDescriptor_ProcessType_PROCESS_SANDBOX_HELPER;
-  static constexpr auto PROCESS_GPU = ChromeProcessDescriptor_ProcessType_PROCESS_GPU;
-  static constexpr auto PROCESS_PPAPI_PLUGIN = ChromeProcessDescriptor_ProcessType_PROCESS_PPAPI_PLUGIN;
-  static constexpr auto PROCESS_PPAPI_BROKER = ChromeProcessDescriptor_ProcessType_PROCESS_PPAPI_BROKER;
-  static constexpr auto PROCESS_SERVICE_NETWORK = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_NETWORK;
-  static constexpr auto PROCESS_SERVICE_TRACING = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_TRACING;
-  static constexpr auto PROCESS_SERVICE_STORAGE = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_STORAGE;
-  static constexpr auto PROCESS_SERVICE_AUDIO = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_AUDIO;
-  static constexpr auto PROCESS_SERVICE_DATA_DECODER = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_DATA_DECODER;
-  static constexpr auto PROCESS_SERVICE_UTIL_WIN = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_UTIL_WIN;
-  static constexpr auto PROCESS_SERVICE_PROXY_RESOLVER = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_PROXY_RESOLVER;
-  static constexpr auto PROCESS_SERVICE_CDM = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_CDM;
-  static constexpr auto PROCESS_SERVICE_VIDEO_CAPTURE = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_VIDEO_CAPTURE;
-  static constexpr auto PROCESS_SERVICE_UNZIPPER = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_UNZIPPER;
-  static constexpr auto PROCESS_SERVICE_MIRRORING = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_MIRRORING;
-  static constexpr auto PROCESS_SERVICE_FILEPATCHER = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_FILEPATCHER;
-  static constexpr auto PROCESS_SERVICE_TTS = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_TTS;
-  static constexpr auto PROCESS_SERVICE_PRINTING = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_PRINTING;
-  static constexpr auto PROCESS_SERVICE_QUARANTINE = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_QUARANTINE;
-  static constexpr auto PROCESS_SERVICE_CROS_LOCALSEARCH = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_CROS_LOCALSEARCH;
-  static constexpr auto PROCESS_SERVICE_CROS_ASSISTANT_AUDIO_DECODER = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_CROS_ASSISTANT_AUDIO_DECODER;
-  static constexpr auto PROCESS_SERVICE_FILEUTIL = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_FILEUTIL;
-  static constexpr auto PROCESS_SERVICE_PRINTCOMPOSITOR = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_PRINTCOMPOSITOR;
-  static constexpr auto PROCESS_SERVICE_PAINTPREVIEW = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_PAINTPREVIEW;
-  static constexpr auto PROCESS_SERVICE_SPEECHRECOGNITION = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_SPEECHRECOGNITION;
-  static constexpr auto PROCESS_SERVICE_XRDEVICE = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_XRDEVICE;
-  static constexpr auto PROCESS_SERVICE_READICON = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_READICON;
-  static constexpr auto PROCESS_SERVICE_LANGUAGEDETECTION = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_LANGUAGEDETECTION;
-  static constexpr auto PROCESS_SERVICE_SHARING = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_SHARING;
-  static constexpr auto PROCESS_SERVICE_MEDIAPARSER = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_MEDIAPARSER;
-  static constexpr auto PROCESS_SERVICE_QRCODEGENERATOR = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_QRCODEGENERATOR;
-  static constexpr auto PROCESS_SERVICE_PROFILEIMPORT = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_PROFILEIMPORT;
-  static constexpr auto PROCESS_SERVICE_IME = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_IME;
-  static constexpr auto PROCESS_SERVICE_RECORDING = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_RECORDING;
-  static constexpr auto PROCESS_SERVICE_SHAPEDETECTION = ChromeProcessDescriptor_ProcessType_PROCESS_SERVICE_SHAPEDETECTION;
-  static constexpr auto PROCESS_RENDERER_EXTENSION = ChromeProcessDescriptor_ProcessType_PROCESS_RENDERER_EXTENSION;
-  static constexpr auto ProcessType_MIN = ChromeProcessDescriptor_ProcessType_PROCESS_UNSPECIFIED;
-  static constexpr auto ProcessType_MAX = ChromeProcessDescriptor_ProcessType_PROCESS_RENDERER_EXTENSION;
-  enum FieldNumbers {
-    kProcessTypeFieldNumber = 1,
-    kProcessPriorityFieldNumber = 2,
-    kLegacySortIndexFieldNumber = 3,
-    kHostAppPackageNameFieldNumber = 4,
-    kCrashTraceIdFieldNumber = 5,
+  using Decoder = SysStats_ThermalZone_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kTempFieldNumber = 2,
+    kTypeFieldNumber = 3,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.SysStats.ThermalZone"; }
 
-  ChromeProcessDescriptor();
-  ~ChromeProcessDescriptor() override;
-  ChromeProcessDescriptor(ChromeProcessDescriptor&&) noexcept;
-  ChromeProcessDescriptor& operator=(ChromeProcessDescriptor&&);
-  ChromeProcessDescriptor(const ChromeProcessDescriptor&);
-  ChromeProcessDescriptor& operator=(const ChromeProcessDescriptor&);
-  bool operator==(const ChromeProcessDescriptor&) const;
-  bool operator!=(const ChromeProcessDescriptor& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_process_type() const { return _has_field_[1]; }
-  ChromeProcessDescriptor_ProcessType process_type() const { return process_type_; }
-  void set_process_type(ChromeProcessDescriptor_ProcessType value) { process_type_ = value; _has_field_.set(1); }
 
-  bool has_process_priority() const { return _has_field_[2]; }
-  int32_t process_priority() const { return process_priority_; }
-  void set_process_priority(int32_t value) { process_priority_ = value; _has_field_.set(2); }
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SysStats_ThermalZone>;
 
-  bool has_legacy_sort_index() const { return _has_field_[3]; }
-  int32_t legacy_sort_index() const { return legacy_sort_index_; }
-  void set_legacy_sort_index(int32_t value) { legacy_sort_index_ = value; _has_field_.set(3); }
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_host_app_package_name() const { return _has_field_[4]; }
-  const std::string& host_app_package_name() const { return host_app_package_name_; }
-  void set_host_app_package_name(const std::string& value) { host_app_package_name_ = value; _has_field_.set(4); }
+  using FieldMetadata_Temp =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_ThermalZone>;
 
-  bool has_crash_trace_id() const { return _has_field_[5]; }
-  uint64_t crash_trace_id() const { return crash_trace_id_; }
-  void set_crash_trace_id(uint64_t value) { crash_trace_id_ = value; _has_field_.set(5); }
+  static constexpr FieldMetadata_Temp kTemp{};
+  void set_temp(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Temp::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
- private:
-  ChromeProcessDescriptor_ProcessType process_type_{};
-  int32_t process_priority_{};
-  int32_t legacy_sort_index_{};
-  std::string host_app_package_name_{};
-  uint64_t crash_trace_id_{};
+  using FieldMetadata_Type =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SysStats_ThermalZone>;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Type::kFieldId, data, size);
+  }
+  void set_type(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Type::kFieldId, chars.data, chars.size);
+  }
+  void set_type(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
 
-  std::bitset<6> _has_field_{};
+class SysStats_PsiSample_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  SysStats_PsiSample_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SysStats_PsiSample_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SysStats_PsiSample_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_resource() const { return at<1>().valid(); }
+  int32_t resource() const { return at<1>().as_int32(); }
+  bool has_total_ns() const { return at<2>().valid(); }
+  uint64_t total_ns() const { return at<2>().as_uint64(); }
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+class SysStats_PsiSample : public ::protozero::Message {
+ public:
+  using Decoder = SysStats_PsiSample_Decoder;
+  enum : int32_t {
+    kResourceFieldNumber = 1,
+    kTotalNsFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SysStats.PsiSample"; }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_PROCESS_DESCRIPTOR_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_renderer_scheduler_state.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_RENDERER_SCHEDULER_STATE_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_RENDERER_SCHEDULER_STATE_PROTO_CPP_H_
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  using PsiResource = ::perfetto::protos::pbzero::SysStats_PsiSample_PsiResource;
+  static inline const char* PsiResource_Name(PsiResource value) {
+    return ::perfetto::protos::pbzero::SysStats_PsiSample_PsiResource_Name(value);
+  }
+  static inline const PsiResource PSI_RESOURCE_UNSPECIFIED = PsiResource::PSI_RESOURCE_UNSPECIFIED;
+  static inline const PsiResource PSI_RESOURCE_CPU_SOME = PsiResource::PSI_RESOURCE_CPU_SOME;
+  static inline const PsiResource PSI_RESOURCE_CPU_FULL = PsiResource::PSI_RESOURCE_CPU_FULL;
+  static inline const PsiResource PSI_RESOURCE_IO_SOME = PsiResource::PSI_RESOURCE_IO_SOME;
+  static inline const PsiResource PSI_RESOURCE_IO_FULL = PsiResource::PSI_RESOURCE_IO_FULL;
+  static inline const PsiResource PSI_RESOURCE_MEMORY_SOME = PsiResource::PSI_RESOURCE_MEMORY_SOME;
+  static inline const PsiResource PSI_RESOURCE_MEMORY_FULL = PsiResource::PSI_RESOURCE_MEMORY_FULL;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  using FieldMetadata_Resource =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      SysStats_PsiSample_PsiResource,
+      SysStats_PsiSample>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeRendererSchedulerState;
-enum ChromeRAILMode : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  static constexpr FieldMetadata_Resource kResource{};
+  void set_resource(SysStats_PsiSample_PsiResource value) {
+    static constexpr uint32_t field_id = FieldMetadata_Resource::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  using FieldMetadata_TotalNs =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_PsiSample>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum ChromeRAILMode : int {
-  RAIL_MODE_NONE = 0,
-  RAIL_MODE_RESPONSE = 1,
-  RAIL_MODE_ANIMATION = 2,
-  RAIL_MODE_IDLE = 3,
-  RAIL_MODE_LOAD = 4,
+  static constexpr FieldMetadata_TotalNs kTotalNs{};
+  void set_total_ns(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TotalNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class PERFETTO_EXPORT_COMPONENT ChromeRendererSchedulerState : public ::protozero::CppMessageObj {
+class SysStats_DiskStat_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9> {
  public:
-  enum FieldNumbers {
-    kRailModeFieldNumber = 1,
-    kIsBackgroundedFieldNumber = 2,
-    kIsHiddenFieldNumber = 3,
+  SysStats_DiskStat_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SysStats_DiskStat_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SysStats_DiskStat_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_device_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars device_name() const { return at<1>().as_string(); }
+  bool has_read_sectors() const { return at<2>().valid(); }
+  uint64_t read_sectors() const { return at<2>().as_uint64(); }
+  bool has_read_time_ms() const { return at<3>().valid(); }
+  uint64_t read_time_ms() const { return at<3>().as_uint64(); }
+  bool has_write_sectors() const { return at<4>().valid(); }
+  uint64_t write_sectors() const { return at<4>().as_uint64(); }
+  bool has_write_time_ms() const { return at<5>().valid(); }
+  uint64_t write_time_ms() const { return at<5>().as_uint64(); }
+  bool has_discard_sectors() const { return at<6>().valid(); }
+  uint64_t discard_sectors() const { return at<6>().as_uint64(); }
+  bool has_discard_time_ms() const { return at<7>().valid(); }
+  uint64_t discard_time_ms() const { return at<7>().as_uint64(); }
+  bool has_flush_count() const { return at<8>().valid(); }
+  uint64_t flush_count() const { return at<8>().as_uint64(); }
+  bool has_flush_time_ms() const { return at<9>().valid(); }
+  uint64_t flush_time_ms() const { return at<9>().as_uint64(); }
+};
+
+class SysStats_DiskStat : public ::protozero::Message {
+ public:
+  using Decoder = SysStats_DiskStat_Decoder;
+  enum : int32_t {
+    kDeviceNameFieldNumber = 1,
+    kReadSectorsFieldNumber = 2,
+    kReadTimeMsFieldNumber = 3,
+    kWriteSectorsFieldNumber = 4,
+    kWriteTimeMsFieldNumber = 5,
+    kDiscardSectorsFieldNumber = 6,
+    kDiscardTimeMsFieldNumber = 7,
+    kFlushCountFieldNumber = 8,
+    kFlushTimeMsFieldNumber = 9,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.SysStats.DiskStat"; }
 
-  ChromeRendererSchedulerState();
-  ~ChromeRendererSchedulerState() override;
-  ChromeRendererSchedulerState(ChromeRendererSchedulerState&&) noexcept;
-  ChromeRendererSchedulerState& operator=(ChromeRendererSchedulerState&&);
-  ChromeRendererSchedulerState(const ChromeRendererSchedulerState&);
-  ChromeRendererSchedulerState& operator=(const ChromeRendererSchedulerState&);
-  bool operator==(const ChromeRendererSchedulerState&) const;
-  bool operator!=(const ChromeRendererSchedulerState& other) const { return !(*this == other); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_DeviceName =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SysStats_DiskStat>;
 
-  bool has_rail_mode() const { return _has_field_[1]; }
-  ChromeRAILMode rail_mode() const { return rail_mode_; }
-  void set_rail_mode(ChromeRAILMode value) { rail_mode_ = value; _has_field_.set(1); }
+  static constexpr FieldMetadata_DeviceName kDeviceName{};
+  void set_device_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_DeviceName::kFieldId, data, size);
+  }
+  void set_device_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_DeviceName::kFieldId, chars.data, chars.size);
+  }
+  void set_device_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_DeviceName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_is_backgrounded() const { return _has_field_[2]; }
-  bool is_backgrounded() const { return is_backgrounded_; }
-  void set_is_backgrounded(bool value) { is_backgrounded_ = value; _has_field_.set(2); }
+  using FieldMetadata_ReadSectors =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_DiskStat>;
 
-  bool has_is_hidden() const { return _has_field_[3]; }
-  bool is_hidden() const { return is_hidden_; }
-  void set_is_hidden(bool value) { is_hidden_ = value; _has_field_.set(3); }
+  static constexpr FieldMetadata_ReadSectors kReadSectors{};
+  void set_read_sectors(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReadSectors::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
- private:
-  ChromeRAILMode rail_mode_{};
-  bool is_backgrounded_{};
-  bool is_hidden_{};
+  using FieldMetadata_ReadTimeMs =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_DiskStat>;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  static constexpr FieldMetadata_ReadTimeMs kReadTimeMs{};
+  void set_read_time_ms(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ReadTimeMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  std::bitset<4> _has_field_{};
-};
+  using FieldMetadata_WriteSectors =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_DiskStat>;
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  static constexpr FieldMetadata_WriteSectors kWriteSectors{};
+  void set_write_sectors(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_WriteSectors::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_RENDERER_SCHEDULER_STATE_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_thread_descriptor.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_THREAD_DESCRIPTOR_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_THREAD_DESCRIPTOR_PROTO_CPP_H_
+  using FieldMetadata_WriteTimeMs =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_DiskStat>;
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  static constexpr FieldMetadata_WriteTimeMs kWriteTimeMs{};
+  void set_write_time_ms(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_WriteTimeMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  using FieldMetadata_DiscardSectors =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_DiskStat>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeThreadDescriptor;
-enum ChromeThreadDescriptor_ThreadType : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  static constexpr FieldMetadata_DiscardSectors kDiscardSectors{};
+  void set_discard_sectors(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DiscardSectors::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  using FieldMetadata_DiscardTimeMs =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_DiskStat>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum ChromeThreadDescriptor_ThreadType : int {
-  ChromeThreadDescriptor_ThreadType_THREAD_UNSPECIFIED = 0,
-  ChromeThreadDescriptor_ThreadType_THREAD_MAIN = 1,
-  ChromeThreadDescriptor_ThreadType_THREAD_IO = 2,
-  ChromeThreadDescriptor_ThreadType_THREAD_POOL_BG_WORKER = 3,
-  ChromeThreadDescriptor_ThreadType_THREAD_POOL_FG_WORKER = 4,
-  ChromeThreadDescriptor_ThreadType_THREAD_POOL_FG_BLOCKING = 5,
-  ChromeThreadDescriptor_ThreadType_THREAD_POOL_BG_BLOCKING = 6,
-  ChromeThreadDescriptor_ThreadType_THREAD_POOL_SERVICE = 7,
-  ChromeThreadDescriptor_ThreadType_THREAD_COMPOSITOR = 8,
-  ChromeThreadDescriptor_ThreadType_THREAD_VIZ_COMPOSITOR = 9,
-  ChromeThreadDescriptor_ThreadType_THREAD_COMPOSITOR_WORKER = 10,
-  ChromeThreadDescriptor_ThreadType_THREAD_SERVICE_WORKER = 11,
-  ChromeThreadDescriptor_ThreadType_THREAD_NETWORK_SERVICE = 12,
-  ChromeThreadDescriptor_ThreadType_THREAD_CHILD_IO = 13,
-  ChromeThreadDescriptor_ThreadType_THREAD_BROWSER_IO = 14,
-  ChromeThreadDescriptor_ThreadType_THREAD_BROWSER_MAIN = 15,
-  ChromeThreadDescriptor_ThreadType_THREAD_RENDERER_MAIN = 16,
-  ChromeThreadDescriptor_ThreadType_THREAD_UTILITY_MAIN = 17,
-  ChromeThreadDescriptor_ThreadType_THREAD_GPU_MAIN = 18,
-  ChromeThreadDescriptor_ThreadType_THREAD_CACHE_BLOCKFILE = 19,
-  ChromeThreadDescriptor_ThreadType_THREAD_MEDIA = 20,
-  ChromeThreadDescriptor_ThreadType_THREAD_AUDIO_OUTPUTDEVICE = 21,
-  ChromeThreadDescriptor_ThreadType_THREAD_AUDIO_INPUTDEVICE = 22,
-  ChromeThreadDescriptor_ThreadType_THREAD_GPU_MEMORY = 23,
-  ChromeThreadDescriptor_ThreadType_THREAD_GPU_VSYNC = 24,
-  ChromeThreadDescriptor_ThreadType_THREAD_DXA_VIDEODECODER = 25,
-  ChromeThreadDescriptor_ThreadType_THREAD_BROWSER_WATCHDOG = 26,
-  ChromeThreadDescriptor_ThreadType_THREAD_WEBRTC_NETWORK = 27,
-  ChromeThreadDescriptor_ThreadType_THREAD_WINDOW_OWNER = 28,
-  ChromeThreadDescriptor_ThreadType_THREAD_WEBRTC_SIGNALING = 29,
-  ChromeThreadDescriptor_ThreadType_THREAD_WEBRTC_WORKER = 30,
-  ChromeThreadDescriptor_ThreadType_THREAD_PPAPI_MAIN = 31,
-  ChromeThreadDescriptor_ThreadType_THREAD_GPU_WATCHDOG = 32,
-  ChromeThreadDescriptor_ThreadType_THREAD_SWAPPER = 33,
-  ChromeThreadDescriptor_ThreadType_THREAD_GAMEPAD_POLLING = 34,
-  ChromeThreadDescriptor_ThreadType_THREAD_WEBCRYPTO = 35,
-  ChromeThreadDescriptor_ThreadType_THREAD_DATABASE = 36,
-  ChromeThreadDescriptor_ThreadType_THREAD_PROXYRESOLVER = 37,
-  ChromeThreadDescriptor_ThreadType_THREAD_DEVTOOLSADB = 38,
-  ChromeThreadDescriptor_ThreadType_THREAD_NETWORKCONFIGWATCHER = 39,
-  ChromeThreadDescriptor_ThreadType_THREAD_WASAPI_RENDER = 40,
-  ChromeThreadDescriptor_ThreadType_THREAD_LOADER_LOCK_SAMPLER = 41,
-  ChromeThreadDescriptor_ThreadType_THREAD_MEMORY_INFRA = 50,
-  ChromeThreadDescriptor_ThreadType_THREAD_SAMPLING_PROFILER = 51,
+  static constexpr FieldMetadata_DiscardTimeMs kDiscardTimeMs{};
+  void set_discard_time_ms(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DiscardTimeMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FlushCount =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_DiskStat>;
+
+  static constexpr FieldMetadata_FlushCount kFlushCount{};
+  void set_flush_count(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FlushCount::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_FlushTimeMs =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_DiskStat>;
+
+  static constexpr FieldMetadata_FlushTimeMs kFlushTimeMs{};
+  void set_flush_time_ms(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FlushTimeMs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 };
 
-class PERFETTO_EXPORT_COMPONENT ChromeThreadDescriptor : public ::protozero::CppMessageObj {
+class SysStats_BuddyInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  using ThreadType = ChromeThreadDescriptor_ThreadType;
-  static constexpr auto THREAD_UNSPECIFIED = ChromeThreadDescriptor_ThreadType_THREAD_UNSPECIFIED;
-  static constexpr auto THREAD_MAIN = ChromeThreadDescriptor_ThreadType_THREAD_MAIN;
-  static constexpr auto THREAD_IO = ChromeThreadDescriptor_ThreadType_THREAD_IO;
-  static constexpr auto THREAD_POOL_BG_WORKER = ChromeThreadDescriptor_ThreadType_THREAD_POOL_BG_WORKER;
-  static constexpr auto THREAD_POOL_FG_WORKER = ChromeThreadDescriptor_ThreadType_THREAD_POOL_FG_WORKER;
-  static constexpr auto THREAD_POOL_FG_BLOCKING = ChromeThreadDescriptor_ThreadType_THREAD_POOL_FG_BLOCKING;
-  static constexpr auto THREAD_POOL_BG_BLOCKING = ChromeThreadDescriptor_ThreadType_THREAD_POOL_BG_BLOCKING;
-  static constexpr auto THREAD_POOL_SERVICE = ChromeThreadDescriptor_ThreadType_THREAD_POOL_SERVICE;
-  static constexpr auto THREAD_COMPOSITOR = ChromeThreadDescriptor_ThreadType_THREAD_COMPOSITOR;
-  static constexpr auto THREAD_VIZ_COMPOSITOR = ChromeThreadDescriptor_ThreadType_THREAD_VIZ_COMPOSITOR;
-  static constexpr auto THREAD_COMPOSITOR_WORKER = ChromeThreadDescriptor_ThreadType_THREAD_COMPOSITOR_WORKER;
-  static constexpr auto THREAD_SERVICE_WORKER = ChromeThreadDescriptor_ThreadType_THREAD_SERVICE_WORKER;
-  static constexpr auto THREAD_NETWORK_SERVICE = ChromeThreadDescriptor_ThreadType_THREAD_NETWORK_SERVICE;
-  static constexpr auto THREAD_CHILD_IO = ChromeThreadDescriptor_ThreadType_THREAD_CHILD_IO;
-  static constexpr auto THREAD_BROWSER_IO = ChromeThreadDescriptor_ThreadType_THREAD_BROWSER_IO;
-  static constexpr auto THREAD_BROWSER_MAIN = ChromeThreadDescriptor_ThreadType_THREAD_BROWSER_MAIN;
-  static constexpr auto THREAD_RENDERER_MAIN = ChromeThreadDescriptor_ThreadType_THREAD_RENDERER_MAIN;
-  static constexpr auto THREAD_UTILITY_MAIN = ChromeThreadDescriptor_ThreadType_THREAD_UTILITY_MAIN;
-  static constexpr auto THREAD_GPU_MAIN = ChromeThreadDescriptor_ThreadType_THREAD_GPU_MAIN;
-  static constexpr auto THREAD_CACHE_BLOCKFILE = ChromeThreadDescriptor_ThreadType_THREAD_CACHE_BLOCKFILE;
-  static constexpr auto THREAD_MEDIA = ChromeThreadDescriptor_ThreadType_THREAD_MEDIA;
-  static constexpr auto THREAD_AUDIO_OUTPUTDEVICE = ChromeThreadDescriptor_ThreadType_THREAD_AUDIO_OUTPUTDEVICE;
-  static constexpr auto THREAD_AUDIO_INPUTDEVICE = ChromeThreadDescriptor_ThreadType_THREAD_AUDIO_INPUTDEVICE;
-  static constexpr auto THREAD_GPU_MEMORY = ChromeThreadDescriptor_ThreadType_THREAD_GPU_MEMORY;
-  static constexpr auto THREAD_GPU_VSYNC = ChromeThreadDescriptor_ThreadType_THREAD_GPU_VSYNC;
-  static constexpr auto THREAD_DXA_VIDEODECODER = ChromeThreadDescriptor_ThreadType_THREAD_DXA_VIDEODECODER;
-  static constexpr auto THREAD_BROWSER_WATCHDOG = ChromeThreadDescriptor_ThreadType_THREAD_BROWSER_WATCHDOG;
-  static constexpr auto THREAD_WEBRTC_NETWORK = ChromeThreadDescriptor_ThreadType_THREAD_WEBRTC_NETWORK;
-  static constexpr auto THREAD_WINDOW_OWNER = ChromeThreadDescriptor_ThreadType_THREAD_WINDOW_OWNER;
-  static constexpr auto THREAD_WEBRTC_SIGNALING = ChromeThreadDescriptor_ThreadType_THREAD_WEBRTC_SIGNALING;
-  static constexpr auto THREAD_WEBRTC_WORKER = ChromeThreadDescriptor_ThreadType_THREAD_WEBRTC_WORKER;
-  static constexpr auto THREAD_PPAPI_MAIN = ChromeThreadDescriptor_ThreadType_THREAD_PPAPI_MAIN;
-  static constexpr auto THREAD_GPU_WATCHDOG = ChromeThreadDescriptor_ThreadType_THREAD_GPU_WATCHDOG;
-  static constexpr auto THREAD_SWAPPER = ChromeThreadDescriptor_ThreadType_THREAD_SWAPPER;
-  static constexpr auto THREAD_GAMEPAD_POLLING = ChromeThreadDescriptor_ThreadType_THREAD_GAMEPAD_POLLING;
-  static constexpr auto THREAD_WEBCRYPTO = ChromeThreadDescriptor_ThreadType_THREAD_WEBCRYPTO;
-  static constexpr auto THREAD_DATABASE = ChromeThreadDescriptor_ThreadType_THREAD_DATABASE;
-  static constexpr auto THREAD_PROXYRESOLVER = ChromeThreadDescriptor_ThreadType_THREAD_PROXYRESOLVER;
-  static constexpr auto THREAD_DEVTOOLSADB = ChromeThreadDescriptor_ThreadType_THREAD_DEVTOOLSADB;
-  static constexpr auto THREAD_NETWORKCONFIGWATCHER = ChromeThreadDescriptor_ThreadType_THREAD_NETWORKCONFIGWATCHER;
-  static constexpr auto THREAD_WASAPI_RENDER = ChromeThreadDescriptor_ThreadType_THREAD_WASAPI_RENDER;
-  static constexpr auto THREAD_LOADER_LOCK_SAMPLER = ChromeThreadDescriptor_ThreadType_THREAD_LOADER_LOCK_SAMPLER;
-  static constexpr auto THREAD_MEMORY_INFRA = ChromeThreadDescriptor_ThreadType_THREAD_MEMORY_INFRA;
-  static constexpr auto THREAD_SAMPLING_PROFILER = ChromeThreadDescriptor_ThreadType_THREAD_SAMPLING_PROFILER;
-  static constexpr auto ThreadType_MIN = ChromeThreadDescriptor_ThreadType_THREAD_UNSPECIFIED;
-  static constexpr auto ThreadType_MAX = ChromeThreadDescriptor_ThreadType_THREAD_SAMPLING_PROFILER;
-  enum FieldNumbers {
-    kThreadTypeFieldNumber = 1,
-    kLegacySortIndexFieldNumber = 2,
+  SysStats_BuddyInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SysStats_BuddyInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SysStats_BuddyInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_node() const { return at<1>().valid(); }
+  ::protozero::ConstChars node() const { return at<1>().as_string(); }
+  bool has_zone() const { return at<2>().valid(); }
+  ::protozero::ConstChars zone() const { return at<2>().as_string(); }
+  bool has_order_pages() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint32_t> order_pages() const { return GetRepeated<uint32_t>(3); }
+};
+
+class SysStats_BuddyInfo : public ::protozero::Message {
+ public:
+  using Decoder = SysStats_BuddyInfo_Decoder;
+  enum : int32_t {
+    kNodeFieldNumber = 1,
+    kZoneFieldNumber = 2,
+    kOrderPagesFieldNumber = 3,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.SysStats.BuddyInfo"; }
 
-  ChromeThreadDescriptor();
-  ~ChromeThreadDescriptor() override;
-  ChromeThreadDescriptor(ChromeThreadDescriptor&&) noexcept;
-  ChromeThreadDescriptor& operator=(ChromeThreadDescriptor&&);
-  ChromeThreadDescriptor(const ChromeThreadDescriptor&);
-  ChromeThreadDescriptor& operator=(const ChromeThreadDescriptor&);
-  bool operator==(const ChromeThreadDescriptor&) const;
-  bool operator!=(const ChromeThreadDescriptor& other) const { return !(*this == other); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_Node =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SysStats_BuddyInfo>;
 
-  bool has_thread_type() const { return _has_field_[1]; }
-  ChromeThreadDescriptor_ThreadType thread_type() const { return thread_type_; }
-  void set_thread_type(ChromeThreadDescriptor_ThreadType value) { thread_type_ = value; _has_field_.set(1); }
+  static constexpr FieldMetadata_Node kNode{};
+  void set_node(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Node::kFieldId, data, size);
+  }
+  void set_node(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Node::kFieldId, chars.data, chars.size);
+  }
+  void set_node(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Node::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_legacy_sort_index() const { return _has_field_[2]; }
-  int32_t legacy_sort_index() const { return legacy_sort_index_; }
-  void set_legacy_sort_index(int32_t value) { legacy_sort_index_ = value; _has_field_.set(2); }
+  using FieldMetadata_Zone =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SysStats_BuddyInfo>;
 
- private:
-  ChromeThreadDescriptor_ThreadType thread_type_{};
-  int32_t legacy_sort_index_{};
+  static constexpr FieldMetadata_Zone kZone{};
+  void set_zone(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Zone::kFieldId, data, size);
+  }
+  void set_zone(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Zone::kFieldId, chars.data, chars.size);
+  }
+  void set_zone(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Zone::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_OrderPages =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SysStats_BuddyInfo>;
 
-  std::bitset<3> _has_field_{};
+  static constexpr FieldMetadata_OrderPages kOrderPages{};
+  void add_order_pages(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_OrderPages::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+class SysStats_DevfreqValue_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  SysStats_DevfreqValue_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SysStats_DevfreqValue_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SysStats_DevfreqValue_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_key() const { return at<1>().valid(); }
+  ::protozero::ConstChars key() const { return at<1>().as_string(); }
+  bool has_value() const { return at<2>().valid(); }
+  uint64_t value() const { return at<2>().as_uint64(); }
+};
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_THREAD_DESCRIPTOR_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_user_event.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_USER_EVENT_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_USER_EVENT_PROTO_CPP_H_
+class SysStats_DevfreqValue : public ::protozero::Message {
+ public:
+  using Decoder = SysStats_DevfreqValue_Decoder;
+  enum : int32_t {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SysStats.DevfreqValue"; }
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  using FieldMetadata_Key =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SysStats_DevfreqValue>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeUserEvent;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  static constexpr FieldMetadata_Key kKey{};
+  void set_key(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Key::kFieldId, data, size);
+  }
+  void set_key(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Key::kFieldId, chars.data, chars.size);
+  }
+  void set_key(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_DevfreqValue>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
 
-class PERFETTO_EXPORT_COMPONENT ChromeUserEvent : public ::protozero::CppMessageObj {
+class SysStats_InterruptCount_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
  public:
-  enum FieldNumbers {
-    kActionFieldNumber = 1,
-    kActionHashFieldNumber = 2,
-  };
-
-  ChromeUserEvent();
-  ~ChromeUserEvent() override;
-  ChromeUserEvent(ChromeUserEvent&&) noexcept;
-  ChromeUserEvent& operator=(ChromeUserEvent&&);
-  ChromeUserEvent(const ChromeUserEvent&);
-  ChromeUserEvent& operator=(const ChromeUserEvent&);
-  bool operator==(const ChromeUserEvent&) const;
-  bool operator!=(const ChromeUserEvent& other) const { return !(*this == other); }
+  SysStats_InterruptCount_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SysStats_InterruptCount_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SysStats_InterruptCount_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_irq() const { return at<1>().valid(); }
+  int32_t irq() const { return at<1>().as_int32(); }
+  bool has_count() const { return at<2>().valid(); }
+  uint64_t count() const { return at<2>().as_uint64(); }
+};
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+class SysStats_InterruptCount : public ::protozero::Message {
+ public:
+  using Decoder = SysStats_InterruptCount_Decoder;
+  enum : int32_t {
+    kIrqFieldNumber = 1,
+    kCountFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SysStats.InterruptCount"; }
 
-  bool has_action() const { return _has_field_[1]; }
-  const std::string& action() const { return action_; }
-  void set_action(const std::string& value) { action_ = value; _has_field_.set(1); }
 
-  bool has_action_hash() const { return _has_field_[2]; }
-  uint64_t action_hash() const { return action_hash_; }
-  void set_action_hash(uint64_t value) { action_hash_ = value; _has_field_.set(2); }
+  using FieldMetadata_Irq =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      SysStats_InterruptCount>;
 
- private:
-  std::string action_{};
-  uint64_t action_hash_{};
+  static constexpr FieldMetadata_Irq kIrq{};
+  void set_irq(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Irq::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_Count =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_InterruptCount>;
 
-  std::bitset<3> _has_field_{};
+  static constexpr FieldMetadata_Count kCount{};
+  void set_count(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_USER_EVENT_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_window_handle_event_info.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_WINDOW_HANDLE_EVENT_INFO_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_WINDOW_HANDLE_EVENT_INFO_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+class SysStats_CpuTimes_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9> {
+ public:
+  SysStats_CpuTimes_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SysStats_CpuTimes_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SysStats_CpuTimes_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cpu_id() const { return at<1>().valid(); }
+  uint32_t cpu_id() const { return at<1>().as_uint32(); }
+  bool has_user_ns() const { return at<2>().valid(); }
+  uint64_t user_ns() const { return at<2>().as_uint64(); }
+  bool has_user_nice_ns() const { return at<3>().valid(); }
+  uint64_t user_nice_ns() const { return at<3>().as_uint64(); }
+  bool has_system_mode_ns() const { return at<4>().valid(); }
+  uint64_t system_mode_ns() const { return at<4>().as_uint64(); }
+  bool has_idle_ns() const { return at<5>().valid(); }
+  uint64_t idle_ns() const { return at<5>().as_uint64(); }
+  bool has_io_wait_ns() const { return at<6>().valid(); }
+  uint64_t io_wait_ns() const { return at<6>().as_uint64(); }
+  bool has_irq_ns() const { return at<7>().valid(); }
+  uint64_t irq_ns() const { return at<7>().as_uint64(); }
+  bool has_softirq_ns() const { return at<8>().valid(); }
+  uint64_t softirq_ns() const { return at<8>().as_uint64(); }
+  bool has_steal_ns() const { return at<9>().valid(); }
+  uint64_t steal_ns() const { return at<9>().as_uint64(); }
+};
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+class SysStats_CpuTimes : public ::protozero::Message {
+ public:
+  using Decoder = SysStats_CpuTimes_Decoder;
+  enum : int32_t {
+    kCpuIdFieldNumber = 1,
+    kUserNsFieldNumber = 2,
+    kUserNiceNsFieldNumber = 3,
+    kSystemModeNsFieldNumber = 4,
+    kIdleNsFieldNumber = 5,
+    kIoWaitNsFieldNumber = 6,
+    kIrqNsFieldNumber = 7,
+    kSoftirqNsFieldNumber = 8,
+    kStealNsFieldNumber = 9,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SysStats.CpuTimes"; }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeWindowHandleEventInfo;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  using FieldMetadata_CpuId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SysStats_CpuTimes>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+  static constexpr FieldMetadata_CpuId kCpuId{};
+  void set_cpu_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CpuId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-class PERFETTO_EXPORT_COMPONENT ChromeWindowHandleEventInfo : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kDpiFieldNumber = 1,
-    kMessageIdFieldNumber = 2,
-    kHwndPtrFieldNumber = 3,
-  };
+  using FieldMetadata_UserNs =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_CpuTimes>;
 
-  ChromeWindowHandleEventInfo();
-  ~ChromeWindowHandleEventInfo() override;
-  ChromeWindowHandleEventInfo(ChromeWindowHandleEventInfo&&) noexcept;
-  ChromeWindowHandleEventInfo& operator=(ChromeWindowHandleEventInfo&&);
-  ChromeWindowHandleEventInfo(const ChromeWindowHandleEventInfo&);
-  ChromeWindowHandleEventInfo& operator=(const ChromeWindowHandleEventInfo&);
-  bool operator==(const ChromeWindowHandleEventInfo&) const;
-  bool operator!=(const ChromeWindowHandleEventInfo& other) const { return !(*this == other); }
+  static constexpr FieldMetadata_UserNs kUserNs{};
+  void set_user_ns(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_UserNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_UserNiceNs =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_CpuTimes>;
 
-  bool has_dpi() const { return _has_field_[1]; }
-  uint32_t dpi() const { return dpi_; }
-  void set_dpi(uint32_t value) { dpi_ = value; _has_field_.set(1); }
+  static constexpr FieldMetadata_UserNiceNs kUserNiceNs{};
+  void set_user_nice_ns(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_UserNiceNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_message_id() const { return _has_field_[2]; }
-  uint32_t message_id() const { return message_id_; }
-  void set_message_id(uint32_t value) { message_id_ = value; _has_field_.set(2); }
+  using FieldMetadata_SystemModeNs =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_CpuTimes>;
 
-  bool has_hwnd_ptr() const { return _has_field_[3]; }
-  uint64_t hwnd_ptr() const { return hwnd_ptr_; }
-  void set_hwnd_ptr(uint64_t value) { hwnd_ptr_ = value; _has_field_.set(3); }
+  static constexpr FieldMetadata_SystemModeNs kSystemModeNs{};
+  void set_system_mode_ns(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SystemModeNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
- private:
-  uint32_t dpi_{};
-  uint32_t message_id_{};
-  uint64_t hwnd_ptr_{};
+  using FieldMetadata_IdleNs =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_CpuTimes>;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  static constexpr FieldMetadata_IdleNs kIdleNs{};
+  void set_idle_ns(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IdleNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  std::bitset<4> _has_field_{};
-};
+  using FieldMetadata_IoWaitNs =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_CpuTimes>;
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  static constexpr FieldMetadata_IoWaitNs kIoWaitNs{};
+  void set_io_wait_ns(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IoWaitNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_WINDOW_HANDLE_EVENT_INFO_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/counter_descriptor.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_COUNTER_DESCRIPTOR_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_COUNTER_DESCRIPTOR_PROTO_CPP_H_
+  using FieldMetadata_IrqNs =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_CpuTimes>;
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  static constexpr FieldMetadata_IrqNs kIrqNs{};
+  void set_irq_ns(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IrqNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  using FieldMetadata_SoftirqNs =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_CpuTimes>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class CounterDescriptor;
-enum CounterDescriptor_BuiltinCounterType : int;
-enum CounterDescriptor_Unit : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  static constexpr FieldMetadata_SoftirqNs kSoftirqNs{};
+  void set_softirq_ns(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SoftirqNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  using FieldMetadata_StealNs =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_CpuTimes>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum CounterDescriptor_BuiltinCounterType : int {
-  CounterDescriptor_BuiltinCounterType_COUNTER_UNSPECIFIED = 0,
-  CounterDescriptor_BuiltinCounterType_COUNTER_THREAD_TIME_NS = 1,
-  CounterDescriptor_BuiltinCounterType_COUNTER_THREAD_INSTRUCTION_COUNT = 2,
+  static constexpr FieldMetadata_StealNs kStealNs{};
+  void set_steal_ns(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_StealNs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 };
-enum CounterDescriptor_Unit : int {
-  CounterDescriptor_Unit_UNIT_UNSPECIFIED = 0,
-  CounterDescriptor_Unit_UNIT_TIME_NS = 1,
-  CounterDescriptor_Unit_UNIT_COUNT = 2,
-  CounterDescriptor_Unit_UNIT_SIZE_BYTES = 3,
+
+class SysStats_VmstatValue_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  SysStats_VmstatValue_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SysStats_VmstatValue_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SysStats_VmstatValue_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_key() const { return at<1>().valid(); }
+  int32_t key() const { return at<1>().as_int32(); }
+  bool has_value() const { return at<2>().valid(); }
+  uint64_t value() const { return at<2>().as_uint64(); }
 };
 
-class PERFETTO_EXPORT_COMPONENT CounterDescriptor : public ::protozero::CppMessageObj {
+class SysStats_VmstatValue : public ::protozero::Message {
  public:
-  using BuiltinCounterType = CounterDescriptor_BuiltinCounterType;
-  static constexpr auto COUNTER_UNSPECIFIED = CounterDescriptor_BuiltinCounterType_COUNTER_UNSPECIFIED;
-  static constexpr auto COUNTER_THREAD_TIME_NS = CounterDescriptor_BuiltinCounterType_COUNTER_THREAD_TIME_NS;
-  static constexpr auto COUNTER_THREAD_INSTRUCTION_COUNT = CounterDescriptor_BuiltinCounterType_COUNTER_THREAD_INSTRUCTION_COUNT;
-  static constexpr auto BuiltinCounterType_MIN = CounterDescriptor_BuiltinCounterType_COUNTER_UNSPECIFIED;
-  static constexpr auto BuiltinCounterType_MAX = CounterDescriptor_BuiltinCounterType_COUNTER_THREAD_INSTRUCTION_COUNT;
-  using Unit = CounterDescriptor_Unit;
-  static constexpr auto UNIT_UNSPECIFIED = CounterDescriptor_Unit_UNIT_UNSPECIFIED;
-  static constexpr auto UNIT_TIME_NS = CounterDescriptor_Unit_UNIT_TIME_NS;
-  static constexpr auto UNIT_COUNT = CounterDescriptor_Unit_UNIT_COUNT;
-  static constexpr auto UNIT_SIZE_BYTES = CounterDescriptor_Unit_UNIT_SIZE_BYTES;
-  static constexpr auto Unit_MIN = CounterDescriptor_Unit_UNIT_UNSPECIFIED;
-  static constexpr auto Unit_MAX = CounterDescriptor_Unit_UNIT_SIZE_BYTES;
-  enum FieldNumbers {
-    kTypeFieldNumber = 1,
-    kCategoriesFieldNumber = 2,
-    kUnitFieldNumber = 3,
-    kUnitNameFieldNumber = 6,
-    kUnitMultiplierFieldNumber = 4,
-    kIsIncrementalFieldNumber = 5,
+  using Decoder = SysStats_VmstatValue_Decoder;
+  enum : int32_t {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.SysStats.VmstatValue"; }
 
-  CounterDescriptor();
-  ~CounterDescriptor() override;
-  CounterDescriptor(CounterDescriptor&&) noexcept;
-  CounterDescriptor& operator=(CounterDescriptor&&);
-  CounterDescriptor(const CounterDescriptor&);
-  CounterDescriptor& operator=(const CounterDescriptor&);
-  bool operator==(const CounterDescriptor&) const;
-  bool operator!=(const CounterDescriptor& other) const { return !(*this == other); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_Key =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      VmstatCounters,
+      SysStats_VmstatValue>;
 
-  bool has_type() const { return _has_field_[1]; }
-  CounterDescriptor_BuiltinCounterType type() const { return type_; }
-  void set_type(CounterDescriptor_BuiltinCounterType value) { type_ = value; _has_field_.set(1); }
+  static constexpr FieldMetadata_Key kKey{};
+  void set_key(VmstatCounters value) {
+    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
 
-  const std::vector<std::string>& categories() const { return categories_; }
-  std::vector<std::string>* mutable_categories() { return &categories_; }
-  int categories_size() const { return static_cast<int>(categories_.size()); }
-  void clear_categories() { categories_.clear(); }
-  void add_categories(std::string value) { categories_.emplace_back(value); }
-  std::string* add_categories() { categories_.emplace_back(); return &categories_.back(); }
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_VmstatValue>;
 
-  bool has_unit() const { return _has_field_[3]; }
-  CounterDescriptor_Unit unit() const { return unit_; }
-  void set_unit(CounterDescriptor_Unit value) { unit_ = value; _has_field_.set(3); }
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
 
-  bool has_unit_name() const { return _has_field_[6]; }
-  const std::string& unit_name() const { return unit_name_; }
-  void set_unit_name(const std::string& value) { unit_name_ = value; _has_field_.set(6); }
+class SysStats_MeminfoValue_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  SysStats_MeminfoValue_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SysStats_MeminfoValue_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SysStats_MeminfoValue_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_key() const { return at<1>().valid(); }
+  int32_t key() const { return at<1>().as_int32(); }
+  bool has_value() const { return at<2>().valid(); }
+  uint64_t value() const { return at<2>().as_uint64(); }
+};
 
-  bool has_unit_multiplier() const { return _has_field_[4]; }
-  int64_t unit_multiplier() const { return unit_multiplier_; }
-  void set_unit_multiplier(int64_t value) { unit_multiplier_ = value; _has_field_.set(4); }
+class SysStats_MeminfoValue : public ::protozero::Message {
+ public:
+  using Decoder = SysStats_MeminfoValue_Decoder;
+  enum : int32_t {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SysStats.MeminfoValue"; }
 
-  bool has_is_incremental() const { return _has_field_[5]; }
-  bool is_incremental() const { return is_incremental_; }
-  void set_is_incremental(bool value) { is_incremental_ = value; _has_field_.set(5); }
 
- private:
-  CounterDescriptor_BuiltinCounterType type_{};
-  std::vector<std::string> categories_;
-  CounterDescriptor_Unit unit_{};
-  std::string unit_name_{};
-  int64_t unit_multiplier_{};
-  bool is_incremental_{};
+  using FieldMetadata_Key =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      MeminfoCounters,
+      SysStats_MeminfoValue>;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  static constexpr FieldMetadata_Key kKey{};
+  void set_key(MeminfoCounters value) {
+    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
 
-  std::bitset<7> _has_field_{};
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_MeminfoValue>;
+
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/system_info/cpu_info.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_COUNTER_DESCRIPTOR_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/debug_annotation.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_DEBUG_ANNOTATION_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_DEBUG_ANNOTATION_PROTO_CPP_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_SYSTEM_INFO_CPU_INFO_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_SYSTEM_INFO_CPU_INFO_PROTO_H_
 
+#include <stddef.h>
 #include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
 namespace perfetto {
 namespace protos {
-namespace gen {
-class DebugAnnotationValueTypeName;
-class DebugAnnotationName;
-class DebugAnnotation;
-class DebugAnnotation_NestedValue;
-enum DebugAnnotation_NestedValue_NestedType : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
+namespace pbzero {
+class CpuInfo_ArmCpuIdentifier;
+class CpuInfo_Cpu;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
 namespace perfetto {
 namespace protos {
-namespace gen {
-enum DebugAnnotation_NestedValue_NestedType : int {
-  DebugAnnotation_NestedValue_NestedType_UNSPECIFIED = 0,
-  DebugAnnotation_NestedValue_NestedType_DICT = 1,
-  DebugAnnotation_NestedValue_NestedType_ARRAY = 2,
+namespace pbzero {
+
+class CpuInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  CpuInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit CpuInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit CpuInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cpus() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> cpus() const { return GetRepeated<::protozero::ConstBytes>(1); }
 };
 
-class PERFETTO_EXPORT_COMPONENT DebugAnnotationValueTypeName : public ::protozero::CppMessageObj {
+class CpuInfo : public ::protozero::Message {
  public:
-  enum FieldNumbers {
-    kIidFieldNumber = 1,
-    kNameFieldNumber = 2,
+  using Decoder = CpuInfo_Decoder;
+  enum : int32_t {
+    kCpusFieldNumber = 1,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.CpuInfo"; }
 
-  DebugAnnotationValueTypeName();
-  ~DebugAnnotationValueTypeName() override;
-  DebugAnnotationValueTypeName(DebugAnnotationValueTypeName&&) noexcept;
-  DebugAnnotationValueTypeName& operator=(DebugAnnotationValueTypeName&&);
-  DebugAnnotationValueTypeName(const DebugAnnotationValueTypeName&);
-  DebugAnnotationValueTypeName& operator=(const DebugAnnotationValueTypeName&);
-  bool operator==(const DebugAnnotationValueTypeName&) const;
-  bool operator!=(const DebugAnnotationValueTypeName& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_iid() const { return _has_field_[1]; }
-  uint64_t iid() const { return iid_; }
-  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
-
-  bool has_name() const { return _has_field_[2]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
+  using ArmCpuIdentifier = ::perfetto::protos::pbzero::CpuInfo_ArmCpuIdentifier;
+  using Cpu = ::perfetto::protos::pbzero::CpuInfo_Cpu;
 
- private:
-  uint64_t iid_{};
-  std::string name_{};
+  using FieldMetadata_Cpus =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      CpuInfo_Cpu,
+      CpuInfo>;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  static constexpr FieldMetadata_Cpus kCpus{};
+  template <typename T = CpuInfo_Cpu> T* add_cpus() {
+    return BeginNestedMessage<T>(1);
+  }
 
-  std::bitset<3> _has_field_{};
 };
 
+class CpuInfo_Cpu_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  CpuInfo_Cpu_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit CpuInfo_Cpu_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit CpuInfo_Cpu_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_processor() const { return at<1>().valid(); }
+  ::protozero::ConstChars processor() const { return at<1>().as_string(); }
+  bool has_frequencies() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<uint32_t> frequencies() const { return GetRepeated<uint32_t>(2); }
+  bool has_capacity() const { return at<3>().valid(); }
+  uint32_t capacity() const { return at<3>().as_uint32(); }
+  bool has_arm_identifier() const { return at<4>().valid(); }
+  ::protozero::ConstBytes arm_identifier() const { return at<4>().as_bytes(); }
+  bool has_features() const { return at<5>().valid(); }
+  uint64_t features() const { return at<5>().as_uint64(); }
+};
 
-class PERFETTO_EXPORT_COMPONENT DebugAnnotationName : public ::protozero::CppMessageObj {
+class CpuInfo_Cpu : public ::protozero::Message {
  public:
-  enum FieldNumbers {
-    kIidFieldNumber = 1,
-    kNameFieldNumber = 2,
+  using Decoder = CpuInfo_Cpu_Decoder;
+  enum : int32_t {
+    kProcessorFieldNumber = 1,
+    kFrequenciesFieldNumber = 2,
+    kCapacityFieldNumber = 3,
+    kArmIdentifierFieldNumber = 4,
+    kFeaturesFieldNumber = 5,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.CpuInfo.Cpu"; }
 
-  DebugAnnotationName();
-  ~DebugAnnotationName() override;
-  DebugAnnotationName(DebugAnnotationName&&) noexcept;
-  DebugAnnotationName& operator=(DebugAnnotationName&&);
-  DebugAnnotationName(const DebugAnnotationName&);
-  DebugAnnotationName& operator=(const DebugAnnotationName&);
-  bool operator==(const DebugAnnotationName&) const;
-  bool operator!=(const DebugAnnotationName& other) const { return !(*this == other); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_Processor =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      CpuInfo_Cpu>;
 
-  bool has_iid() const { return _has_field_[1]; }
-  uint64_t iid() const { return iid_; }
-  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
+  static constexpr FieldMetadata_Processor kProcessor{};
+  void set_processor(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Processor::kFieldId, data, size);
+  }
+  void set_processor(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Processor::kFieldId, chars.data, chars.size);
+  }
+  void set_processor(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Processor::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_name() const { return _has_field_[2]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
+  using FieldMetadata_Frequencies =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      CpuInfo_Cpu>;
 
- private:
-  uint64_t iid_{};
-  std::string name_{};
+  static constexpr FieldMetadata_Frequencies kFrequencies{};
+  void add_frequencies(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Frequencies::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_Capacity =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      CpuInfo_Cpu>;
 
-  std::bitset<3> _has_field_{};
-};
+  static constexpr FieldMetadata_Capacity kCapacity{};
+  void set_capacity(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Capacity::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
+  using FieldMetadata_ArmIdentifier =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      CpuInfo_ArmCpuIdentifier,
+      CpuInfo_Cpu>;
 
-class PERFETTO_EXPORT_COMPONENT DebugAnnotation : public ::protozero::CppMessageObj {
- public:
-  using NestedValue = DebugAnnotation_NestedValue;
-  enum FieldNumbers {
-    kNameIidFieldNumber = 1,
-    kNameFieldNumber = 10,
-    kBoolValueFieldNumber = 2,
-    kUintValueFieldNumber = 3,
-    kIntValueFieldNumber = 4,
-    kDoubleValueFieldNumber = 5,
-    kPointerValueFieldNumber = 7,
-    kNestedValueFieldNumber = 8,
-    kLegacyJsonValueFieldNumber = 9,
-    kStringValueFieldNumber = 6,
-    kStringValueIidFieldNumber = 17,
-    kProtoTypeNameFieldNumber = 16,
-    kProtoTypeNameIidFieldNumber = 13,
-    kProtoValueFieldNumber = 14,
-    kDictEntriesFieldNumber = 11,
-    kArrayValuesFieldNumber = 12,
-  };
+  static constexpr FieldMetadata_ArmIdentifier kArmIdentifier{};
+  template <typename T = CpuInfo_ArmCpuIdentifier> T* set_arm_identifier() {
+    return BeginNestedMessage<T>(4);
+  }
 
-  DebugAnnotation();
-  ~DebugAnnotation() override;
-  DebugAnnotation(DebugAnnotation&&) noexcept;
-  DebugAnnotation& operator=(DebugAnnotation&&);
-  DebugAnnotation(const DebugAnnotation&);
-  DebugAnnotation& operator=(const DebugAnnotation&);
-  bool operator==(const DebugAnnotation&) const;
-  bool operator!=(const DebugAnnotation& other) const { return !(*this == other); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_Features =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      CpuInfo_Cpu>;
 
-  bool has_name_iid() const { return _has_field_[1]; }
-  uint64_t name_iid() const { return name_iid_; }
-  void set_name_iid(uint64_t value) { name_iid_ = value; _has_field_.set(1); }
+  static constexpr FieldMetadata_Features kFeatures{};
+  void set_features(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Features::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+};
 
-  bool has_name() const { return _has_field_[10]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(10); }
+class CpuInfo_ArmCpuIdentifier_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  CpuInfo_ArmCpuIdentifier_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit CpuInfo_ArmCpuIdentifier_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit CpuInfo_ArmCpuIdentifier_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_implementer() const { return at<1>().valid(); }
+  uint32_t implementer() const { return at<1>().as_uint32(); }
+  bool has_architecture() const { return at<2>().valid(); }
+  uint32_t architecture() const { return at<2>().as_uint32(); }
+  bool has_variant() const { return at<3>().valid(); }
+  uint32_t variant() const { return at<3>().as_uint32(); }
+  bool has_part() const { return at<4>().valid(); }
+  uint32_t part() const { return at<4>().as_uint32(); }
+  bool has_revision() const { return at<5>().valid(); }
+  uint32_t revision() const { return at<5>().as_uint32(); }
+};
 
-  bool has_bool_value() const { return _has_field_[2]; }
-  bool bool_value() const { return bool_value_; }
-  void set_bool_value(bool value) { bool_value_ = value; _has_field_.set(2); }
+class CpuInfo_ArmCpuIdentifier : public ::protozero::Message {
+ public:
+  using Decoder = CpuInfo_ArmCpuIdentifier_Decoder;
+  enum : int32_t {
+    kImplementerFieldNumber = 1,
+    kArchitectureFieldNumber = 2,
+    kVariantFieldNumber = 3,
+    kPartFieldNumber = 4,
+    kRevisionFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.CpuInfo.ArmCpuIdentifier"; }
 
-  bool has_uint_value() const { return _has_field_[3]; }
-  uint64_t uint_value() const { return uint_value_; }
-  void set_uint_value(uint64_t value) { uint_value_ = value; _has_field_.set(3); }
 
-  bool has_int_value() const { return _has_field_[4]; }
-  int64_t int_value() const { return int_value_; }
-  void set_int_value(int64_t value) { int_value_ = value; _has_field_.set(4); }
+  using FieldMetadata_Implementer =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      CpuInfo_ArmCpuIdentifier>;
 
-  bool has_double_value() const { return _has_field_[5]; }
-  double double_value() const { return double_value_; }
-  void set_double_value(double value) { double_value_ = value; _has_field_.set(5); }
+  static constexpr FieldMetadata_Implementer kImplementer{};
+  void set_implementer(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Implementer::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_pointer_value() const { return _has_field_[7]; }
-  uint64_t pointer_value() const { return pointer_value_; }
-  void set_pointer_value(uint64_t value) { pointer_value_ = value; _has_field_.set(7); }
+  using FieldMetadata_Architecture =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      CpuInfo_ArmCpuIdentifier>;
 
-  bool has_nested_value() const { return _has_field_[8]; }
-  const DebugAnnotation_NestedValue& nested_value() const { return *nested_value_; }
-  DebugAnnotation_NestedValue* mutable_nested_value() { _has_field_.set(8); return nested_value_.get(); }
+  static constexpr FieldMetadata_Architecture kArchitecture{};
+  void set_architecture(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Architecture::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_legacy_json_value() const { return _has_field_[9]; }
-  const std::string& legacy_json_value() const { return legacy_json_value_; }
-  void set_legacy_json_value(const std::string& value) { legacy_json_value_ = value; _has_field_.set(9); }
+  using FieldMetadata_Variant =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      CpuInfo_ArmCpuIdentifier>;
 
-  bool has_string_value() const { return _has_field_[6]; }
-  const std::string& string_value() const { return string_value_; }
-  void set_string_value(const std::string& value) { string_value_ = value; _has_field_.set(6); }
+  static constexpr FieldMetadata_Variant kVariant{};
+  void set_variant(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Variant::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_string_value_iid() const { return _has_field_[17]; }
-  uint64_t string_value_iid() const { return string_value_iid_; }
-  void set_string_value_iid(uint64_t value) { string_value_iid_ = value; _has_field_.set(17); }
+  using FieldMetadata_Part =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      CpuInfo_ArmCpuIdentifier>;
 
-  bool has_proto_type_name() const { return _has_field_[16]; }
-  const std::string& proto_type_name() const { return proto_type_name_; }
-  void set_proto_type_name(const std::string& value) { proto_type_name_ = value; _has_field_.set(16); }
+  static constexpr FieldMetadata_Part kPart{};
+  void set_part(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Part::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_proto_type_name_iid() const { return _has_field_[13]; }
-  uint64_t proto_type_name_iid() const { return proto_type_name_iid_; }
-  void set_proto_type_name_iid(uint64_t value) { proto_type_name_iid_ = value; _has_field_.set(13); }
+  using FieldMetadata_Revision =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      CpuInfo_ArmCpuIdentifier>;
 
-  bool has_proto_value() const { return _has_field_[14]; }
-  const std::string& proto_value() const { return proto_value_; }
-  void set_proto_value(const std::string& value) { proto_value_ = value; _has_field_.set(14); }
-  void set_proto_value(const void* p, size_t s) { proto_value_.assign(reinterpret_cast<const char*>(p), s); _has_field_.set(14); }
+  static constexpr FieldMetadata_Revision kRevision{};
+  void set_revision(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Revision::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+};
 
-  const std::vector<DebugAnnotation>& dict_entries() const { return dict_entries_; }
-  std::vector<DebugAnnotation>* mutable_dict_entries() { return &dict_entries_; }
-  int dict_entries_size() const;
-  void clear_dict_entries();
-  DebugAnnotation* add_dict_entries();
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/translation/translation_table.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  const std::vector<DebugAnnotation>& array_values() const { return array_values_; }
-  std::vector<DebugAnnotation>* mutable_array_values() { return &array_values_; }
-  int array_values_size() const;
-  void clear_array_values();
-  DebugAnnotation* add_array_values();
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRANSLATION_TRANSLATION_TABLE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRANSLATION_TRANSLATION_TABLE_PROTO_H_
 
- private:
-  uint64_t name_iid_{};
-  std::string name_{};
-  bool bool_value_{};
-  uint64_t uint_value_{};
-  int64_t int_value_{};
-  double double_value_{};
-  uint64_t pointer_value_{};
-  ::protozero::CopyablePtr<DebugAnnotation_NestedValue> nested_value_;
-  std::string legacy_json_value_{};
-  std::string string_value_{};
-  uint64_t string_value_iid_{};
-  std::string proto_type_name_{};
-  uint64_t proto_type_name_iid_{};
-  std::string proto_value_{};
-  std::vector<DebugAnnotation> dict_entries_;
-  std::vector<DebugAnnotation> array_values_;
+#include <stddef.h>
+#include <stdint.h>
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  std::bitset<18> _has_field_{};
-};
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class ChromeHistorgramTranslationTable;
+class ChromeHistorgramTranslationTable_HashToNameEntry;
+class ChromePerformanceMarkTranslationTable;
+class ChromePerformanceMarkTranslationTable_MarkHashToNameEntry;
+class ChromePerformanceMarkTranslationTable_SiteHashToNameEntry;
+class ChromeStudyTranslationTable;
+class ChromeStudyTranslationTable_HashToNameEntry;
+class ChromeUserEventTranslationTable;
+class ChromeUserEventTranslationTable_ActionHashToNameEntry;
+class ProcessTrackNameTranslationTable;
+class ProcessTrackNameTranslationTable_RawToDeobfuscatedNameEntry;
+class SliceNameTranslationTable;
+class SliceNameTranslationTable_RawToDeobfuscatedNameEntry;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-class PERFETTO_EXPORT_COMPONENT DebugAnnotation_NestedValue : public ::protozero::CppMessageObj {
+class ChromeStudyTranslationTable_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  using NestedType = DebugAnnotation_NestedValue_NestedType;
-  static constexpr auto UNSPECIFIED = DebugAnnotation_NestedValue_NestedType_UNSPECIFIED;
-  static constexpr auto DICT = DebugAnnotation_NestedValue_NestedType_DICT;
-  static constexpr auto ARRAY = DebugAnnotation_NestedValue_NestedType_ARRAY;
-  static constexpr auto NestedType_MIN = DebugAnnotation_NestedValue_NestedType_UNSPECIFIED;
-  static constexpr auto NestedType_MAX = DebugAnnotation_NestedValue_NestedType_ARRAY;
-  enum FieldNumbers {
-    kNestedTypeFieldNumber = 1,
-    kDictKeysFieldNumber = 2,
-    kDictValuesFieldNumber = 3,
-    kArrayValuesFieldNumber = 4,
-    kIntValueFieldNumber = 5,
-    kDoubleValueFieldNumber = 6,
-    kBoolValueFieldNumber = 7,
-    kStringValueFieldNumber = 8,
-  };
-
-  DebugAnnotation_NestedValue();
-  ~DebugAnnotation_NestedValue() override;
-  DebugAnnotation_NestedValue(DebugAnnotation_NestedValue&&) noexcept;
-  DebugAnnotation_NestedValue& operator=(DebugAnnotation_NestedValue&&);
-  DebugAnnotation_NestedValue(const DebugAnnotation_NestedValue&);
-  DebugAnnotation_NestedValue& operator=(const DebugAnnotation_NestedValue&);
-  bool operator==(const DebugAnnotation_NestedValue&) const;
-  bool operator!=(const DebugAnnotation_NestedValue& other) const { return !(*this == other); }
+  ChromeStudyTranslationTable_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeStudyTranslationTable_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeStudyTranslationTable_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_hash_to_name() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> hash_to_name() const { return GetRepeated<::protozero::ConstBytes>(1); }
+};
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+class ChromeStudyTranslationTable : public ::protozero::Message {
+ public:
+  using Decoder = ChromeStudyTranslationTable_Decoder;
+  enum : int32_t {
+    kHashToNameFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeStudyTranslationTable"; }
 
-  bool has_nested_type() const { return _has_field_[1]; }
-  DebugAnnotation_NestedValue_NestedType nested_type() const { return nested_type_; }
-  void set_nested_type(DebugAnnotation_NestedValue_NestedType value) { nested_type_ = value; _has_field_.set(1); }
+  using HashToNameEntry = ::perfetto::protos::pbzero::ChromeStudyTranslationTable_HashToNameEntry;
 
-  const std::vector<std::string>& dict_keys() const { return dict_keys_; }
-  std::vector<std::string>* mutable_dict_keys() { return &dict_keys_; }
-  int dict_keys_size() const { return static_cast<int>(dict_keys_.size()); }
-  void clear_dict_keys() { dict_keys_.clear(); }
-  void add_dict_keys(std::string value) { dict_keys_.emplace_back(value); }
-  std::string* add_dict_keys() { dict_keys_.emplace_back(); return &dict_keys_.back(); }
+  using FieldMetadata_HashToName =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromeStudyTranslationTable_HashToNameEntry,
+      ChromeStudyTranslationTable>;
 
-  const std::vector<DebugAnnotation_NestedValue>& dict_values() const { return dict_values_; }
-  std::vector<DebugAnnotation_NestedValue>* mutable_dict_values() { return &dict_values_; }
-  int dict_values_size() const;
-  void clear_dict_values();
-  DebugAnnotation_NestedValue* add_dict_values();
+  static constexpr FieldMetadata_HashToName kHashToName{};
+  template <typename T = ChromeStudyTranslationTable_HashToNameEntry> T* add_hash_to_name() {
+    return BeginNestedMessage<T>(1);
+  }
 
-  const std::vector<DebugAnnotation_NestedValue>& array_values() const { return array_values_; }
-  std::vector<DebugAnnotation_NestedValue>* mutable_array_values() { return &array_values_; }
-  int array_values_size() const;
-  void clear_array_values();
-  DebugAnnotation_NestedValue* add_array_values();
+};
 
-  bool has_int_value() const { return _has_field_[5]; }
-  int64_t int_value() const { return int_value_; }
-  void set_int_value(int64_t value) { int_value_ = value; _has_field_.set(5); }
+class ChromeStudyTranslationTable_HashToNameEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  ChromeStudyTranslationTable_HashToNameEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeStudyTranslationTable_HashToNameEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeStudyTranslationTable_HashToNameEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_key() const { return at<1>().valid(); }
+  uint64_t key() const { return at<1>().as_uint64(); }
+  bool has_value() const { return at<2>().valid(); }
+  ::protozero::ConstChars value() const { return at<2>().as_string(); }
+};
 
-  bool has_double_value() const { return _has_field_[6]; }
-  double double_value() const { return double_value_; }
-  void set_double_value(double value) { double_value_ = value; _has_field_.set(6); }
+class ChromeStudyTranslationTable_HashToNameEntry : public ::protozero::Message {
+ public:
+  using Decoder = ChromeStudyTranslationTable_HashToNameEntry_Decoder;
+  enum : int32_t {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeStudyTranslationTable.HashToNameEntry"; }
 
-  bool has_bool_value() const { return _has_field_[7]; }
-  bool bool_value() const { return bool_value_; }
-  void set_bool_value(bool value) { bool_value_ = value; _has_field_.set(7); }
 
-  bool has_string_value() const { return _has_field_[8]; }
-  const std::string& string_value() const { return string_value_; }
-  void set_string_value(const std::string& value) { string_value_ = value; _has_field_.set(8); }
+  using FieldMetadata_Key =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ChromeStudyTranslationTable_HashToNameEntry>;
 
- private:
-  DebugAnnotation_NestedValue_NestedType nested_type_{};
-  std::vector<std::string> dict_keys_;
-  std::vector<DebugAnnotation_NestedValue> dict_values_;
-  std::vector<DebugAnnotation_NestedValue> array_values_;
-  int64_t int_value_{};
-  double double_value_{};
-  bool bool_value_{};
-  std::string string_value_{};
+  static constexpr FieldMetadata_Key kKey{};
+  void set_key(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeStudyTranslationTable_HashToNameEntry>;
 
-  std::bitset<9> _has_field_{};
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
+  }
+  void set_value(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
+  }
+  void set_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+class ProcessTrackNameTranslationTable_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  ProcessTrackNameTranslationTable_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProcessTrackNameTranslationTable_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProcessTrackNameTranslationTable_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_raw_to_deobfuscated_name() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> raw_to_deobfuscated_name() const { return GetRepeated<::protozero::ConstBytes>(1); }
+};
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_DEBUG_ANNOTATION_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/log_message.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_LOG_MESSAGE_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_LOG_MESSAGE_PROTO_CPP_H_
+class ProcessTrackNameTranslationTable : public ::protozero::Message {
+ public:
+  using Decoder = ProcessTrackNameTranslationTable_Decoder;
+  enum : int32_t {
+    kRawToDeobfuscatedNameFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ProcessTrackNameTranslationTable"; }
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  using RawToDeobfuscatedNameEntry = ::perfetto::protos::pbzero::ProcessTrackNameTranslationTable_RawToDeobfuscatedNameEntry;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  using FieldMetadata_RawToDeobfuscatedName =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ProcessTrackNameTranslationTable_RawToDeobfuscatedNameEntry,
+      ProcessTrackNameTranslationTable>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class LogMessageBody;
-class LogMessage;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  static constexpr FieldMetadata_RawToDeobfuscatedName kRawToDeobfuscatedName{};
+  template <typename T = ProcessTrackNameTranslationTable_RawToDeobfuscatedNameEntry> T* add_raw_to_deobfuscated_name() {
+    return BeginNestedMessage<T>(1);
+  }
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+};
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+class ProcessTrackNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  ProcessTrackNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ProcessTrackNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ProcessTrackNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_key() const { return at<1>().valid(); }
+  ::protozero::ConstChars key() const { return at<1>().as_string(); }
+  bool has_value() const { return at<2>().valid(); }
+  ::protozero::ConstChars value() const { return at<2>().as_string(); }
+};
 
-class PERFETTO_EXPORT_COMPONENT LogMessageBody : public ::protozero::CppMessageObj {
+class ProcessTrackNameTranslationTable_RawToDeobfuscatedNameEntry : public ::protozero::Message {
  public:
-  enum FieldNumbers {
-    kIidFieldNumber = 1,
-    kBodyFieldNumber = 2,
+  using Decoder = ProcessTrackNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder;
+  enum : int32_t {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.ProcessTrackNameTranslationTable.RawToDeobfuscatedNameEntry"; }
 
-  LogMessageBody();
-  ~LogMessageBody() override;
-  LogMessageBody(LogMessageBody&&) noexcept;
-  LogMessageBody& operator=(LogMessageBody&&);
-  LogMessageBody(const LogMessageBody&);
-  LogMessageBody& operator=(const LogMessageBody&);
-  bool operator==(const LogMessageBody&) const;
-  bool operator!=(const LogMessageBody& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_iid() const { return _has_field_[1]; }
-  uint64_t iid() const { return iid_; }
-  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
 
-  bool has_body() const { return _has_field_[2]; }
-  const std::string& body() const { return body_; }
-  void set_body(const std::string& value) { body_ = value; _has_field_.set(2); }
+  using FieldMetadata_Key =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ProcessTrackNameTranslationTable_RawToDeobfuscatedNameEntry>;
 
- private:
-  uint64_t iid_{};
-  std::string body_{};
+  static constexpr FieldMetadata_Key kKey{};
+  void set_key(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Key::kFieldId, data, size);
+  }
+  void set_key(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Key::kFieldId, chars.data, chars.size);
+  }
+  void set_key(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ProcessTrackNameTranslationTable_RawToDeobfuscatedNameEntry>;
 
-  std::bitset<3> _has_field_{};
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
+  }
+  void set_value(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
+  }
+  void set_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 };
 
+class SliceNameTranslationTable_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  SliceNameTranslationTable_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SliceNameTranslationTable_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SliceNameTranslationTable_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_raw_to_deobfuscated_name() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> raw_to_deobfuscated_name() const { return GetRepeated<::protozero::ConstBytes>(1); }
+};
 
-class PERFETTO_EXPORT_COMPONENT LogMessage : public ::protozero::CppMessageObj {
+class SliceNameTranslationTable : public ::protozero::Message {
  public:
-  enum FieldNumbers {
-    kSourceLocationIidFieldNumber = 1,
-    kBodyIidFieldNumber = 2,
+  using Decoder = SliceNameTranslationTable_Decoder;
+  enum : int32_t {
+    kRawToDeobfuscatedNameFieldNumber = 1,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.SliceNameTranslationTable"; }
 
-  LogMessage();
-  ~LogMessage() override;
-  LogMessage(LogMessage&&) noexcept;
-  LogMessage& operator=(LogMessage&&);
-  LogMessage(const LogMessage&);
-  LogMessage& operator=(const LogMessage&);
-  bool operator==(const LogMessage&) const;
-  bool operator!=(const LogMessage& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_source_location_iid() const { return _has_field_[1]; }
-  uint64_t source_location_iid() const { return source_location_iid_; }
-  void set_source_location_iid(uint64_t value) { source_location_iid_ = value; _has_field_.set(1); }
+  using RawToDeobfuscatedNameEntry = ::perfetto::protos::pbzero::SliceNameTranslationTable_RawToDeobfuscatedNameEntry;
 
-  bool has_body_iid() const { return _has_field_[2]; }
-  uint64_t body_iid() const { return body_iid_; }
-  void set_body_iid(uint64_t value) { body_iid_ = value; _has_field_.set(2); }
+  using FieldMetadata_RawToDeobfuscatedName =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SliceNameTranslationTable_RawToDeobfuscatedNameEntry,
+      SliceNameTranslationTable>;
 
- private:
-  uint64_t source_location_iid_{};
-  uint64_t body_iid_{};
+  static constexpr FieldMetadata_RawToDeobfuscatedName kRawToDeobfuscatedName{};
+  template <typename T = SliceNameTranslationTable_RawToDeobfuscatedNameEntry> T* add_raw_to_deobfuscated_name() {
+    return BeginNestedMessage<T>(1);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+};
 
-  std::bitset<3> _has_field_{};
+class SliceNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  SliceNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SliceNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SliceNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_key() const { return at<1>().valid(); }
+  ::protozero::ConstChars key() const { return at<1>().as_string(); }
+  bool has_value() const { return at<2>().valid(); }
+  ::protozero::ConstChars value() const { return at<2>().as_string(); }
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+class SliceNameTranslationTable_RawToDeobfuscatedNameEntry : public ::protozero::Message {
+ public:
+  using Decoder = SliceNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder;
+  enum : int32_t {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SliceNameTranslationTable.RawToDeobfuscatedNameEntry"; }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_LOG_MESSAGE_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/process_descriptor.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_PROCESS_DESCRIPTOR_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_PROCESS_DESCRIPTOR_PROTO_CPP_H_
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  using FieldMetadata_Key =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SliceNameTranslationTable_RawToDeobfuscatedNameEntry>;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  static constexpr FieldMetadata_Key kKey{};
+  void set_key(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Key::kFieldId, data, size);
+  }
+  void set_key(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Key::kFieldId, chars.data, chars.size);
+  }
+  void set_key(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ProcessDescriptor;
-enum ProcessDescriptor_ChromeProcessType : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SliceNameTranslationTable_RawToDeobfuscatedNameEntry>;
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
+  }
+  void set_value(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
+  }
+  void set_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum ProcessDescriptor_ChromeProcessType : int {
-  ProcessDescriptor_ChromeProcessType_PROCESS_UNSPECIFIED = 0,
-  ProcessDescriptor_ChromeProcessType_PROCESS_BROWSER = 1,
-  ProcessDescriptor_ChromeProcessType_PROCESS_RENDERER = 2,
-  ProcessDescriptor_ChromeProcessType_PROCESS_UTILITY = 3,
-  ProcessDescriptor_ChromeProcessType_PROCESS_ZYGOTE = 4,
-  ProcessDescriptor_ChromeProcessType_PROCESS_SANDBOX_HELPER = 5,
-  ProcessDescriptor_ChromeProcessType_PROCESS_GPU = 6,
-  ProcessDescriptor_ChromeProcessType_PROCESS_PPAPI_PLUGIN = 7,
-  ProcessDescriptor_ChromeProcessType_PROCESS_PPAPI_BROKER = 8,
+class ChromePerformanceMarkTranslationTable_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  ChromePerformanceMarkTranslationTable_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromePerformanceMarkTranslationTable_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromePerformanceMarkTranslationTable_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_site_hash_to_name() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> site_hash_to_name() const { return GetRepeated<::protozero::ConstBytes>(1); }
+  bool has_mark_hash_to_name() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> mark_hash_to_name() const { return GetRepeated<::protozero::ConstBytes>(2); }
 };
 
-class PERFETTO_EXPORT_COMPONENT ProcessDescriptor : public ::protozero::CppMessageObj {
+class ChromePerformanceMarkTranslationTable : public ::protozero::Message {
  public:
-  using ChromeProcessType = ProcessDescriptor_ChromeProcessType;
-  static constexpr auto PROCESS_UNSPECIFIED = ProcessDescriptor_ChromeProcessType_PROCESS_UNSPECIFIED;
-  static constexpr auto PROCESS_BROWSER = ProcessDescriptor_ChromeProcessType_PROCESS_BROWSER;
-  static constexpr auto PROCESS_RENDERER = ProcessDescriptor_ChromeProcessType_PROCESS_RENDERER;
-  static constexpr auto PROCESS_UTILITY = ProcessDescriptor_ChromeProcessType_PROCESS_UTILITY;
-  static constexpr auto PROCESS_ZYGOTE = ProcessDescriptor_ChromeProcessType_PROCESS_ZYGOTE;
-  static constexpr auto PROCESS_SANDBOX_HELPER = ProcessDescriptor_ChromeProcessType_PROCESS_SANDBOX_HELPER;
-  static constexpr auto PROCESS_GPU = ProcessDescriptor_ChromeProcessType_PROCESS_GPU;
-  static constexpr auto PROCESS_PPAPI_PLUGIN = ProcessDescriptor_ChromeProcessType_PROCESS_PPAPI_PLUGIN;
-  static constexpr auto PROCESS_PPAPI_BROKER = ProcessDescriptor_ChromeProcessType_PROCESS_PPAPI_BROKER;
-  static constexpr auto ChromeProcessType_MIN = ProcessDescriptor_ChromeProcessType_PROCESS_UNSPECIFIED;
-  static constexpr auto ChromeProcessType_MAX = ProcessDescriptor_ChromeProcessType_PROCESS_PPAPI_BROKER;
-  enum FieldNumbers {
-    kPidFieldNumber = 1,
-    kCmdlineFieldNumber = 2,
-    kProcessNameFieldNumber = 6,
-    kProcessPriorityFieldNumber = 5,
-    kStartTimestampNsFieldNumber = 7,
-    kChromeProcessTypeFieldNumber = 4,
-    kLegacySortIndexFieldNumber = 3,
-    kProcessLabelsFieldNumber = 8,
+  using Decoder = ChromePerformanceMarkTranslationTable_Decoder;
+  enum : int32_t {
+    kSiteHashToNameFieldNumber = 1,
+    kMarkHashToNameFieldNumber = 2,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromePerformanceMarkTranslationTable"; }
 
-  ProcessDescriptor();
-  ~ProcessDescriptor() override;
-  ProcessDescriptor(ProcessDescriptor&&) noexcept;
-  ProcessDescriptor& operator=(ProcessDescriptor&&);
-  ProcessDescriptor(const ProcessDescriptor&);
-  ProcessDescriptor& operator=(const ProcessDescriptor&);
-  bool operator==(const ProcessDescriptor&) const;
-  bool operator!=(const ProcessDescriptor& other) const { return !(*this == other); }
+  using SiteHashToNameEntry = ::perfetto::protos::pbzero::ChromePerformanceMarkTranslationTable_SiteHashToNameEntry;
+  using MarkHashToNameEntry = ::perfetto::protos::pbzero::ChromePerformanceMarkTranslationTable_MarkHashToNameEntry;
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_SiteHashToName =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromePerformanceMarkTranslationTable_SiteHashToNameEntry,
+      ChromePerformanceMarkTranslationTable>;
 
-  bool has_pid() const { return _has_field_[1]; }
-  int32_t pid() const { return pid_; }
-  void set_pid(int32_t value) { pid_ = value; _has_field_.set(1); }
+  static constexpr FieldMetadata_SiteHashToName kSiteHashToName{};
+  template <typename T = ChromePerformanceMarkTranslationTable_SiteHashToNameEntry> T* add_site_hash_to_name() {
+    return BeginNestedMessage<T>(1);
+  }
 
-  const std::vector<std::string>& cmdline() const { return cmdline_; }
-  std::vector<std::string>* mutable_cmdline() { return &cmdline_; }
-  int cmdline_size() const { return static_cast<int>(cmdline_.size()); }
-  void clear_cmdline() { cmdline_.clear(); }
-  void add_cmdline(std::string value) { cmdline_.emplace_back(value); }
-  std::string* add_cmdline() { cmdline_.emplace_back(); return &cmdline_.back(); }
 
-  bool has_process_name() const { return _has_field_[6]; }
-  const std::string& process_name() const { return process_name_; }
-  void set_process_name(const std::string& value) { process_name_ = value; _has_field_.set(6); }
+  using FieldMetadata_MarkHashToName =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromePerformanceMarkTranslationTable_MarkHashToNameEntry,
+      ChromePerformanceMarkTranslationTable>;
 
-  bool has_process_priority() const { return _has_field_[5]; }
-  int32_t process_priority() const { return process_priority_; }
-  void set_process_priority(int32_t value) { process_priority_ = value; _has_field_.set(5); }
+  static constexpr FieldMetadata_MarkHashToName kMarkHashToName{};
+  template <typename T = ChromePerformanceMarkTranslationTable_MarkHashToNameEntry> T* add_mark_hash_to_name() {
+    return BeginNestedMessage<T>(2);
+  }
 
-  bool has_start_timestamp_ns() const { return _has_field_[7]; }
-  int64_t start_timestamp_ns() const { return start_timestamp_ns_; }
-  void set_start_timestamp_ns(int64_t value) { start_timestamp_ns_ = value; _has_field_.set(7); }
+};
 
-  bool has_chrome_process_type() const { return _has_field_[4]; }
-  ProcessDescriptor_ChromeProcessType chrome_process_type() const { return chrome_process_type_; }
-  void set_chrome_process_type(ProcessDescriptor_ChromeProcessType value) { chrome_process_type_ = value; _has_field_.set(4); }
+class ChromePerformanceMarkTranslationTable_MarkHashToNameEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  ChromePerformanceMarkTranslationTable_MarkHashToNameEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromePerformanceMarkTranslationTable_MarkHashToNameEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromePerformanceMarkTranslationTable_MarkHashToNameEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_key() const { return at<1>().valid(); }
+  uint32_t key() const { return at<1>().as_uint32(); }
+  bool has_value() const { return at<2>().valid(); }
+  ::protozero::ConstChars value() const { return at<2>().as_string(); }
+};
 
-  bool has_legacy_sort_index() const { return _has_field_[3]; }
-  int32_t legacy_sort_index() const { return legacy_sort_index_; }
-  void set_legacy_sort_index(int32_t value) { legacy_sort_index_ = value; _has_field_.set(3); }
+class ChromePerformanceMarkTranslationTable_MarkHashToNameEntry : public ::protozero::Message {
+ public:
+  using Decoder = ChromePerformanceMarkTranslationTable_MarkHashToNameEntry_Decoder;
+  enum : int32_t {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromePerformanceMarkTranslationTable.MarkHashToNameEntry"; }
 
-  const std::vector<std::string>& process_labels() const { return process_labels_; }
-  std::vector<std::string>* mutable_process_labels() { return &process_labels_; }
-  int process_labels_size() const { return static_cast<int>(process_labels_.size()); }
-  void clear_process_labels() { process_labels_.clear(); }
-  void add_process_labels(std::string value) { process_labels_.emplace_back(value); }
-  std::string* add_process_labels() { process_labels_.emplace_back(); return &process_labels_.back(); }
 
- private:
-  int32_t pid_{};
-  std::vector<std::string> cmdline_;
-  std::string process_name_{};
-  int32_t process_priority_{};
-  int64_t start_timestamp_ns_{};
-  ProcessDescriptor_ChromeProcessType chrome_process_type_{};
-  int32_t legacy_sort_index_{};
-  std::vector<std::string> process_labels_;
+  using FieldMetadata_Key =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ChromePerformanceMarkTranslationTable_MarkHashToNameEntry>;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  static constexpr FieldMetadata_Key kKey{};
+  void set_key(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  std::bitset<9> _has_field_{};
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromePerformanceMarkTranslationTable_MarkHashToNameEntry>;
+
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
+  }
+  void set_value(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
+  }
+  void set_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+class ChromePerformanceMarkTranslationTable_SiteHashToNameEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  ChromePerformanceMarkTranslationTable_SiteHashToNameEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromePerformanceMarkTranslationTable_SiteHashToNameEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromePerformanceMarkTranslationTable_SiteHashToNameEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_key() const { return at<1>().valid(); }
+  uint32_t key() const { return at<1>().as_uint32(); }
+  bool has_value() const { return at<2>().valid(); }
+  ::protozero::ConstChars value() const { return at<2>().as_string(); }
+};
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_PROCESS_DESCRIPTOR_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/range_of_interest.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_RANGE_OF_INTEREST_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_RANGE_OF_INTEREST_PROTO_CPP_H_
+class ChromePerformanceMarkTranslationTable_SiteHashToNameEntry : public ::protozero::Message {
+ public:
+  using Decoder = ChromePerformanceMarkTranslationTable_SiteHashToNameEntry_Decoder;
+  enum : int32_t {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromePerformanceMarkTranslationTable.SiteHashToNameEntry"; }
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  using FieldMetadata_Key =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      ChromePerformanceMarkTranslationTable_SiteHashToNameEntry>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class TrackEventRangeOfInterest;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  static constexpr FieldMetadata_Key kKey{};
+  void set_key(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromePerformanceMarkTranslationTable_SiteHashToNameEntry>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
+  }
+  void set_value(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
+  }
+  void set_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
 
-class PERFETTO_EXPORT_COMPONENT TrackEventRangeOfInterest : public ::protozero::CppMessageObj {
+class ChromeUserEventTranslationTable_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  enum FieldNumbers {
-    kStartUsFieldNumber = 1,
-  };
+  ChromeUserEventTranslationTable_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeUserEventTranslationTable_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeUserEventTranslationTable_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_action_hash_to_name() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> action_hash_to_name() const { return GetRepeated<::protozero::ConstBytes>(1); }
+};
 
-  TrackEventRangeOfInterest();
-  ~TrackEventRangeOfInterest() override;
-  TrackEventRangeOfInterest(TrackEventRangeOfInterest&&) noexcept;
-  TrackEventRangeOfInterest& operator=(TrackEventRangeOfInterest&&);
-  TrackEventRangeOfInterest(const TrackEventRangeOfInterest&);
-  TrackEventRangeOfInterest& operator=(const TrackEventRangeOfInterest&);
-  bool operator==(const TrackEventRangeOfInterest&) const;
-  bool operator!=(const TrackEventRangeOfInterest& other) const { return !(*this == other); }
+class ChromeUserEventTranslationTable : public ::protozero::Message {
+ public:
+  using Decoder = ChromeUserEventTranslationTable_Decoder;
+  enum : int32_t {
+    kActionHashToNameFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeUserEventTranslationTable"; }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using ActionHashToNameEntry = ::perfetto::protos::pbzero::ChromeUserEventTranslationTable_ActionHashToNameEntry;
 
-  bool has_start_us() const { return _has_field_[1]; }
-  int64_t start_us() const { return start_us_; }
-  void set_start_us(int64_t value) { start_us_ = value; _has_field_.set(1); }
+  using FieldMetadata_ActionHashToName =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromeUserEventTranslationTable_ActionHashToNameEntry,
+      ChromeUserEventTranslationTable>;
 
- private:
-  int64_t start_us_{};
+  static constexpr FieldMetadata_ActionHashToName kActionHashToName{};
+  template <typename T = ChromeUserEventTranslationTable_ActionHashToNameEntry> T* add_action_hash_to_name() {
+    return BeginNestedMessage<T>(1);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+};
 
-  std::bitset<2> _has_field_{};
+class ChromeUserEventTranslationTable_ActionHashToNameEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  ChromeUserEventTranslationTable_ActionHashToNameEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeUserEventTranslationTable_ActionHashToNameEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeUserEventTranslationTable_ActionHashToNameEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_key() const { return at<1>().valid(); }
+  uint64_t key() const { return at<1>().as_uint64(); }
+  bool has_value() const { return at<2>().valid(); }
+  ::protozero::ConstChars value() const { return at<2>().as_string(); }
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+class ChromeUserEventTranslationTable_ActionHashToNameEntry : public ::protozero::Message {
+ public:
+  using Decoder = ChromeUserEventTranslationTable_ActionHashToNameEntry_Decoder;
+  enum : int32_t {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeUserEventTranslationTable.ActionHashToNameEntry"; }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_RANGE_OF_INTEREST_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/source_location.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_SOURCE_LOCATION_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_SOURCE_LOCATION_PROTO_CPP_H_
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  using FieldMetadata_Key =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ChromeUserEventTranslationTable_ActionHashToNameEntry>;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  static constexpr FieldMetadata_Key kKey{};
+  void set_key(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class SourceLocation;
-class UnsymbolizedSourceLocation;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeUserEventTranslationTable_ActionHashToNameEntry>;
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
+  }
+  void set_value(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
+  }
+  void set_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+class ChromeHistorgramTranslationTable_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  ChromeHistorgramTranslationTable_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeHistorgramTranslationTable_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeHistorgramTranslationTable_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_hash_to_name() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> hash_to_name() const { return GetRepeated<::protozero::ConstBytes>(1); }
+};
 
-class PERFETTO_EXPORT_COMPONENT SourceLocation : public ::protozero::CppMessageObj {
+class ChromeHistorgramTranslationTable : public ::protozero::Message {
  public:
-  enum FieldNumbers {
-    kIidFieldNumber = 1,
-    kFileNameFieldNumber = 2,
-    kFunctionNameFieldNumber = 3,
-    kLineNumberFieldNumber = 4,
+  using Decoder = ChromeHistorgramTranslationTable_Decoder;
+  enum : int32_t {
+    kHashToNameFieldNumber = 1,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeHistorgramTranslationTable"; }
 
-  SourceLocation();
-  ~SourceLocation() override;
-  SourceLocation(SourceLocation&&) noexcept;
-  SourceLocation& operator=(SourceLocation&&);
-  SourceLocation(const SourceLocation&);
-  SourceLocation& operator=(const SourceLocation&);
-  bool operator==(const SourceLocation&) const;
-  bool operator!=(const SourceLocation& other) const { return !(*this == other); }
+  using HashToNameEntry = ::perfetto::protos::pbzero::ChromeHistorgramTranslationTable_HashToNameEntry;
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_HashToName =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromeHistorgramTranslationTable_HashToNameEntry,
+      ChromeHistorgramTranslationTable>;
 
-  bool has_iid() const { return _has_field_[1]; }
-  uint64_t iid() const { return iid_; }
-  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
+  static constexpr FieldMetadata_HashToName kHashToName{};
+  template <typename T = ChromeHistorgramTranslationTable_HashToNameEntry> T* add_hash_to_name() {
+    return BeginNestedMessage<T>(1);
+  }
 
-  bool has_file_name() const { return _has_field_[2]; }
-  const std::string& file_name() const { return file_name_; }
-  void set_file_name(const std::string& value) { file_name_ = value; _has_field_.set(2); }
+};
 
-  bool has_function_name() const { return _has_field_[3]; }
-  const std::string& function_name() const { return function_name_; }
-  void set_function_name(const std::string& value) { function_name_ = value; _has_field_.set(3); }
+class ChromeHistorgramTranslationTable_HashToNameEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  ChromeHistorgramTranslationTable_HashToNameEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ChromeHistorgramTranslationTable_HashToNameEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ChromeHistorgramTranslationTable_HashToNameEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_key() const { return at<1>().valid(); }
+  uint64_t key() const { return at<1>().as_uint64(); }
+  bool has_value() const { return at<2>().valid(); }
+  ::protozero::ConstChars value() const { return at<2>().as_string(); }
+};
 
-  bool has_line_number() const { return _has_field_[4]; }
-  uint32_t line_number() const { return line_number_; }
-  void set_line_number(uint32_t value) { line_number_ = value; _has_field_.set(4); }
+class ChromeHistorgramTranslationTable_HashToNameEntry : public ::protozero::Message {
+ public:
+  using Decoder = ChromeHistorgramTranslationTable_HashToNameEntry_Decoder;
+  enum : int32_t {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.ChromeHistorgramTranslationTable.HashToNameEntry"; }
 
- private:
-  uint64_t iid_{};
-  std::string file_name_{};
-  std::string function_name_{};
-  uint32_t line_number_{};
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_Key =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      ChromeHistorgramTranslationTable_HashToNameEntry>;
 
-  std::bitset<5> _has_field_{};
+  static constexpr FieldMetadata_Key kKey{};
+  void set_key(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ChromeHistorgramTranslationTable_HashToNameEntry>;
+
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
+  }
+  void set_value(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size);
+  }
+  void set_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 };
 
+class TranslationTable_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6> {
+ public:
+  TranslationTable_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TranslationTable_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TranslationTable_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_chrome_histogram() const { return at<1>().valid(); }
+  ::protozero::ConstBytes chrome_histogram() const { return at<1>().as_bytes(); }
+  bool has_chrome_user_event() const { return at<2>().valid(); }
+  ::protozero::ConstBytes chrome_user_event() const { return at<2>().as_bytes(); }
+  bool has_chrome_performance_mark() const { return at<3>().valid(); }
+  ::protozero::ConstBytes chrome_performance_mark() const { return at<3>().as_bytes(); }
+  bool has_slice_name() const { return at<4>().valid(); }
+  ::protozero::ConstBytes slice_name() const { return at<4>().as_bytes(); }
+  bool has_process_track_name() const { return at<5>().valid(); }
+  ::protozero::ConstBytes process_track_name() const { return at<5>().as_bytes(); }
+  bool has_chrome_study() const { return at<6>().valid(); }
+  ::protozero::ConstBytes chrome_study() const { return at<6>().as_bytes(); }
+};
 
-class PERFETTO_EXPORT_COMPONENT UnsymbolizedSourceLocation : public ::protozero::CppMessageObj {
+class TranslationTable : public ::protozero::Message {
  public:
-  enum FieldNumbers {
-    kIidFieldNumber = 1,
-    kMappingIdFieldNumber = 2,
-    kRelPcFieldNumber = 3,
+  using Decoder = TranslationTable_Decoder;
+  enum : int32_t {
+    kChromeHistogramFieldNumber = 1,
+    kChromeUserEventFieldNumber = 2,
+    kChromePerformanceMarkFieldNumber = 3,
+    kSliceNameFieldNumber = 4,
+    kProcessTrackNameFieldNumber = 5,
+    kChromeStudyFieldNumber = 6,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.TranslationTable"; }
 
-  UnsymbolizedSourceLocation();
-  ~UnsymbolizedSourceLocation() override;
-  UnsymbolizedSourceLocation(UnsymbolizedSourceLocation&&) noexcept;
-  UnsymbolizedSourceLocation& operator=(UnsymbolizedSourceLocation&&);
-  UnsymbolizedSourceLocation(const UnsymbolizedSourceLocation&);
-  UnsymbolizedSourceLocation& operator=(const UnsymbolizedSourceLocation&);
-  bool operator==(const UnsymbolizedSourceLocation&) const;
-  bool operator!=(const UnsymbolizedSourceLocation& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_iid() const { return _has_field_[1]; }
-  uint64_t iid() const { return iid_; }
-  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
-
-  bool has_mapping_id() const { return _has_field_[2]; }
-  uint64_t mapping_id() const { return mapping_id_; }
-  void set_mapping_id(uint64_t value) { mapping_id_ = value; _has_field_.set(2); }
 
-  bool has_rel_pc() const { return _has_field_[3]; }
-  uint64_t rel_pc() const { return rel_pc_; }
-  void set_rel_pc(uint64_t value) { rel_pc_ = value; _has_field_.set(3); }
+  using FieldMetadata_ChromeHistogram =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromeHistorgramTranslationTable,
+      TranslationTable>;
 
- private:
-  uint64_t iid_{};
-  uint64_t mapping_id_{};
-  uint64_t rel_pc_{};
+  static constexpr FieldMetadata_ChromeHistogram kChromeHistogram{};
+  template <typename T = ChromeHistorgramTranslationTable> T* set_chrome_histogram() {
+    return BeginNestedMessage<T>(1);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
 
-  std::bitset<4> _has_field_{};
-};
+  using FieldMetadata_ChromeUserEvent =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromeUserEventTranslationTable,
+      TranslationTable>;
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  static constexpr FieldMetadata_ChromeUserEvent kChromeUserEvent{};
+  template <typename T = ChromeUserEventTranslationTable> T* set_chrome_user_event() {
+    return BeginNestedMessage<T>(2);
+  }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_SOURCE_LOCATION_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/task_execution.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TASK_EXECUTION_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TASK_EXECUTION_PROTO_CPP_H_
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  using FieldMetadata_ChromePerformanceMark =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromePerformanceMarkTranslationTable,
+      TranslationTable>;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  static constexpr FieldMetadata_ChromePerformanceMark kChromePerformanceMark{};
+  template <typename T = ChromePerformanceMarkTranslationTable> T* set_chrome_performance_mark() {
+    return BeginNestedMessage<T>(3);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class TaskExecution;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  using FieldMetadata_SliceName =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SliceNameTranslationTable,
+      TranslationTable>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+  static constexpr FieldMetadata_SliceName kSliceName{};
+  template <typename T = SliceNameTranslationTable> T* set_slice_name() {
+    return BeginNestedMessage<T>(4);
+  }
 
-class PERFETTO_EXPORT_COMPONENT TaskExecution : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kPostedFromIidFieldNumber = 1,
-  };
 
-  TaskExecution();
-  ~TaskExecution() override;
-  TaskExecution(TaskExecution&&) noexcept;
-  TaskExecution& operator=(TaskExecution&&);
-  TaskExecution(const TaskExecution&);
-  TaskExecution& operator=(const TaskExecution&);
-  bool operator==(const TaskExecution&) const;
-  bool operator!=(const TaskExecution& other) const { return !(*this == other); }
+  using FieldMetadata_ProcessTrackName =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ProcessTrackNameTranslationTable,
+      TranslationTable>;
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  static constexpr FieldMetadata_ProcessTrackName kProcessTrackName{};
+  template <typename T = ProcessTrackNameTranslationTable> T* set_process_track_name() {
+    return BeginNestedMessage<T>(5);
+  }
 
-  bool has_posted_from_iid() const { return _has_field_[1]; }
-  uint64_t posted_from_iid() const { return posted_from_iid_; }
-  void set_posted_from_iid(uint64_t value) { posted_from_iid_ = value; _has_field_.set(1); }
 
- private:
-  uint64_t posted_from_iid_{};
+  using FieldMetadata_ChromeStudy =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ChromeStudyTranslationTable,
+      TranslationTable>;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  static constexpr FieldMetadata_ChromeStudy kChromeStudy{};
+  template <typename T = ChromeStudyTranslationTable> T* set_chrome_study() {
+    return BeginNestedMessage<T>(6);
+  }
 
-  std::bitset<2> _has_field_{};
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/remote_clock_sync.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TASK_EXECUTION_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/thread_descriptor.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_THREAD_DESCRIPTOR_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_THREAD_DESCRIPTOR_PROTO_CPP_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_REMOTE_CLOCK_SYNC_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_REMOTE_CLOCK_SYNC_PROTO_H_
 
+#include <stddef.h>
 #include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
 namespace perfetto {
 namespace protos {
-namespace gen {
-class ThreadDescriptor;
-enum ThreadDescriptor_ChromeThreadType : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
+namespace pbzero {
+class ClockSnapshot;
+class RemoteClockSync_SyncedClocks;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
 namespace perfetto {
 namespace protos {
-namespace gen {
-enum ThreadDescriptor_ChromeThreadType : int {
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_UNSPECIFIED = 0,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_MAIN = 1,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_IO = 2,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_BG_WORKER = 3,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_FG_WORKER = 4,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_FB_BLOCKING = 5,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_BG_BLOCKING = 6,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_SERVICE = 7,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_COMPOSITOR = 8,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_VIZ_COMPOSITOR = 9,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_COMPOSITOR_WORKER = 10,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_SERVICE_WORKER = 11,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_MEMORY_INFRA = 50,
-  ThreadDescriptor_ChromeThreadType_CHROME_THREAD_SAMPLING_PROFILER = 51,
-};
+namespace pbzero {
 
-class PERFETTO_EXPORT_COMPONENT ThreadDescriptor : public ::protozero::CppMessageObj {
+class RemoteClockSync_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  using ChromeThreadType = ThreadDescriptor_ChromeThreadType;
-  static constexpr auto CHROME_THREAD_UNSPECIFIED = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_UNSPECIFIED;
-  static constexpr auto CHROME_THREAD_MAIN = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_MAIN;
-  static constexpr auto CHROME_THREAD_IO = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_IO;
-  static constexpr auto CHROME_THREAD_POOL_BG_WORKER = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_BG_WORKER;
-  static constexpr auto CHROME_THREAD_POOL_FG_WORKER = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_FG_WORKER;
-  static constexpr auto CHROME_THREAD_POOL_FB_BLOCKING = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_FB_BLOCKING;
-  static constexpr auto CHROME_THREAD_POOL_BG_BLOCKING = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_BG_BLOCKING;
-  static constexpr auto CHROME_THREAD_POOL_SERVICE = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_POOL_SERVICE;
-  static constexpr auto CHROME_THREAD_COMPOSITOR = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_COMPOSITOR;
-  static constexpr auto CHROME_THREAD_VIZ_COMPOSITOR = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_VIZ_COMPOSITOR;
-  static constexpr auto CHROME_THREAD_COMPOSITOR_WORKER = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_COMPOSITOR_WORKER;
-  static constexpr auto CHROME_THREAD_SERVICE_WORKER = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_SERVICE_WORKER;
-  static constexpr auto CHROME_THREAD_MEMORY_INFRA = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_MEMORY_INFRA;
-  static constexpr auto CHROME_THREAD_SAMPLING_PROFILER = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_SAMPLING_PROFILER;
-  static constexpr auto ChromeThreadType_MIN = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_UNSPECIFIED;
-  static constexpr auto ChromeThreadType_MAX = ThreadDescriptor_ChromeThreadType_CHROME_THREAD_SAMPLING_PROFILER;
-  enum FieldNumbers {
-    kPidFieldNumber = 1,
-    kTidFieldNumber = 2,
-    kThreadNameFieldNumber = 5,
-    kChromeThreadTypeFieldNumber = 4,
-    kReferenceTimestampUsFieldNumber = 6,
-    kReferenceThreadTimeUsFieldNumber = 7,
-    kReferenceThreadInstructionCountFieldNumber = 8,
-    kLegacySortIndexFieldNumber = 3,
-  };
-
-  ThreadDescriptor();
-  ~ThreadDescriptor() override;
-  ThreadDescriptor(ThreadDescriptor&&) noexcept;
-  ThreadDescriptor& operator=(ThreadDescriptor&&);
-  ThreadDescriptor(const ThreadDescriptor&);
-  ThreadDescriptor& operator=(const ThreadDescriptor&);
-  bool operator==(const ThreadDescriptor&) const;
-  bool operator!=(const ThreadDescriptor& other) const { return !(*this == other); }
+  RemoteClockSync_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit RemoteClockSync_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit RemoteClockSync_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_synced_clocks() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> synced_clocks() const { return GetRepeated<::protozero::ConstBytes>(1); }
+};
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+class RemoteClockSync : public ::protozero::Message {
+ public:
+  using Decoder = RemoteClockSync_Decoder;
+  enum : int32_t {
+    kSyncedClocksFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.RemoteClockSync"; }
 
-  bool has_pid() const { return _has_field_[1]; }
-  int32_t pid() const { return pid_; }
-  void set_pid(int32_t value) { pid_ = value; _has_field_.set(1); }
+  using SyncedClocks = ::perfetto::protos::pbzero::RemoteClockSync_SyncedClocks;
 
-  bool has_tid() const { return _has_field_[2]; }
-  int32_t tid() const { return tid_; }
-  void set_tid(int32_t value) { tid_ = value; _has_field_.set(2); }
+  using FieldMetadata_SyncedClocks =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      RemoteClockSync_SyncedClocks,
+      RemoteClockSync>;
 
-  bool has_thread_name() const { return _has_field_[5]; }
-  const std::string& thread_name() const { return thread_name_; }
-  void set_thread_name(const std::string& value) { thread_name_ = value; _has_field_.set(5); }
+  static constexpr FieldMetadata_SyncedClocks kSyncedClocks{};
+  template <typename T = RemoteClockSync_SyncedClocks> T* add_synced_clocks() {
+    return BeginNestedMessage<T>(1);
+  }
 
-  bool has_chrome_thread_type() const { return _has_field_[4]; }
-  ThreadDescriptor_ChromeThreadType chrome_thread_type() const { return chrome_thread_type_; }
-  void set_chrome_thread_type(ThreadDescriptor_ChromeThreadType value) { chrome_thread_type_ = value; _has_field_.set(4); }
+};
 
-  bool has_reference_timestamp_us() const { return _has_field_[6]; }
-  int64_t reference_timestamp_us() const { return reference_timestamp_us_; }
-  void set_reference_timestamp_us(int64_t value) { reference_timestamp_us_ = value; _has_field_.set(6); }
+class RemoteClockSync_SyncedClocks_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  RemoteClockSync_SyncedClocks_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit RemoteClockSync_SyncedClocks_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit RemoteClockSync_SyncedClocks_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_client_clocks() const { return at<2>().valid(); }
+  ::protozero::ConstBytes client_clocks() const { return at<2>().as_bytes(); }
+  bool has_host_clocks() const { return at<3>().valid(); }
+  ::protozero::ConstBytes host_clocks() const { return at<3>().as_bytes(); }
+};
 
-  bool has_reference_thread_time_us() const { return _has_field_[7]; }
-  int64_t reference_thread_time_us() const { return reference_thread_time_us_; }
-  void set_reference_thread_time_us(int64_t value) { reference_thread_time_us_ = value; _has_field_.set(7); }
+class RemoteClockSync_SyncedClocks : public ::protozero::Message {
+ public:
+  using Decoder = RemoteClockSync_SyncedClocks_Decoder;
+  enum : int32_t {
+    kClientClocksFieldNumber = 2,
+    kHostClocksFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.RemoteClockSync.SyncedClocks"; }
 
-  bool has_reference_thread_instruction_count() const { return _has_field_[8]; }
-  int64_t reference_thread_instruction_count() const { return reference_thread_instruction_count_; }
-  void set_reference_thread_instruction_count(int64_t value) { reference_thread_instruction_count_ = value; _has_field_.set(8); }
 
-  bool has_legacy_sort_index() const { return _has_field_[3]; }
-  int32_t legacy_sort_index() const { return legacy_sort_index_; }
-  void set_legacy_sort_index(int32_t value) { legacy_sort_index_ = value; _has_field_.set(3); }
+  using FieldMetadata_ClientClocks =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ClockSnapshot,
+      RemoteClockSync_SyncedClocks>;
 
- private:
-  int32_t pid_{};
-  int32_t tid_{};
-  std::string thread_name_{};
-  ThreadDescriptor_ChromeThreadType chrome_thread_type_{};
-  int64_t reference_timestamp_us_{};
-  int64_t reference_thread_time_us_{};
-  int64_t reference_thread_instruction_count_{};
-  int32_t legacy_sort_index_{};
+  static constexpr FieldMetadata_ClientClocks kClientClocks{};
+  template <typename T = ClockSnapshot> T* set_client_clocks() {
+    return BeginNestedMessage<T>(2);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
 
-  std::bitset<9> _has_field_{};
+  using FieldMetadata_HostClocks =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      ClockSnapshot,
+      RemoteClockSync_SyncedClocks>;
+
+  static constexpr FieldMetadata_HostClocks kHostClocks{};
+  template <typename T = ClockSnapshot> T* set_host_clocks() {
+    return BeginNestedMessage<T>(3);
+  }
+
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/trace_packet_defaults.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_THREAD_DESCRIPTOR_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/track_descriptor.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TRACK_DESCRIPTOR_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TRACK_DESCRIPTOR_PROTO_CPP_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACE_PACKET_DEFAULTS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACE_PACKET_DEFAULTS_PROTO_H_
 
+#include <stddef.h>
 #include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
 namespace perfetto {
 namespace protos {
-namespace gen {
-class TrackDescriptor;
-class CounterDescriptor;
-class ChromeThreadDescriptor;
-class ThreadDescriptor;
-class ChromeProcessDescriptor;
-class ProcessDescriptor;
-enum CounterDescriptor_BuiltinCounterType : int;
-enum CounterDescriptor_Unit : int;
-enum ChromeThreadDescriptor_ThreadType : int;
-enum ThreadDescriptor_ChromeThreadType : int;
-enum ChromeProcessDescriptor_ProcessType : int;
-enum ProcessDescriptor_ChromeProcessType : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
+namespace pbzero {
+class PerfSampleDefaults;
+class TrackEventDefaults;
+class V8CodeDefaults;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
 namespace perfetto {
 namespace protos {
-namespace gen {
+namespace pbzero {
 
-class PERFETTO_EXPORT_COMPONENT TrackDescriptor : public ::protozero::CppMessageObj {
+class TracePacketDefaults_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/99> {
  public:
-  enum FieldNumbers {
-    kUuidFieldNumber = 1,
-    kParentUuidFieldNumber = 5,
-    kNameFieldNumber = 2,
-    kProcessFieldNumber = 3,
-    kChromeProcessFieldNumber = 6,
-    kThreadFieldNumber = 4,
-    kChromeThreadFieldNumber = 7,
-    kCounterFieldNumber = 8,
-  };
+  TracePacketDefaults_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TracePacketDefaults_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TracePacketDefaults_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_timestamp_clock_id() const { return at<58>().valid(); }
+  uint32_t timestamp_clock_id() const { return at<58>().as_uint32(); }
+  bool has_track_event_defaults() const { return at<11>().valid(); }
+  ::protozero::ConstBytes track_event_defaults() const { return at<11>().as_bytes(); }
+  bool has_perf_sample_defaults() const { return at<12>().valid(); }
+  ::protozero::ConstBytes perf_sample_defaults() const { return at<12>().as_bytes(); }
+  bool has_v8_code_defaults() const { return at<99>().valid(); }
+  ::protozero::ConstBytes v8_code_defaults() const { return at<99>().as_bytes(); }
+};
 
-  TrackDescriptor();
-  ~TrackDescriptor() override;
-  TrackDescriptor(TrackDescriptor&&) noexcept;
-  TrackDescriptor& operator=(TrackDescriptor&&);
-  TrackDescriptor(const TrackDescriptor&);
-  TrackDescriptor& operator=(const TrackDescriptor&);
-  bool operator==(const TrackDescriptor&) const;
-  bool operator!=(const TrackDescriptor& other) const { return !(*this == other); }
+class TracePacketDefaults : public ::protozero::Message {
+ public:
+  using Decoder = TracePacketDefaults_Decoder;
+  enum : int32_t {
+    kTimestampClockIdFieldNumber = 58,
+    kTrackEventDefaultsFieldNumber = 11,
+    kPerfSampleDefaultsFieldNumber = 12,
+    kV8CodeDefaultsFieldNumber = 99,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TracePacketDefaults"; }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
 
-  bool has_uuid() const { return _has_field_[1]; }
-  uint64_t uuid() const { return uuid_; }
-  void set_uuid(uint64_t value) { uuid_ = value; _has_field_.set(1); }
+  using FieldMetadata_TimestampClockId =
+    ::protozero::proto_utils::FieldMetadata<
+      58,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TracePacketDefaults>;
 
-  bool has_parent_uuid() const { return _has_field_[5]; }
-  uint64_t parent_uuid() const { return parent_uuid_; }
-  void set_parent_uuid(uint64_t value) { parent_uuid_ = value; _has_field_.set(5); }
+  static constexpr FieldMetadata_TimestampClockId kTimestampClockId{};
+  void set_timestamp_clock_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimestampClockId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_name() const { return _has_field_[2]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
+  using FieldMetadata_TrackEventDefaults =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TrackEventDefaults,
+      TracePacketDefaults>;
 
-  bool has_process() const { return _has_field_[3]; }
-  const ProcessDescriptor& process() const { return *process_; }
-  ProcessDescriptor* mutable_process() { _has_field_.set(3); return process_.get(); }
+  static constexpr FieldMetadata_TrackEventDefaults kTrackEventDefaults{};
+  template <typename T = TrackEventDefaults> T* set_track_event_defaults() {
+    return BeginNestedMessage<T>(11);
+  }
 
-  bool has_chrome_process() const { return _has_field_[6]; }
-  const ChromeProcessDescriptor& chrome_process() const { return *chrome_process_; }
-  ChromeProcessDescriptor* mutable_chrome_process() { _has_field_.set(6); return chrome_process_.get(); }
 
-  bool has_thread() const { return _has_field_[4]; }
-  const ThreadDescriptor& thread() const { return *thread_; }
-  ThreadDescriptor* mutable_thread() { _has_field_.set(4); return thread_.get(); }
+  using FieldMetadata_PerfSampleDefaults =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      PerfSampleDefaults,
+      TracePacketDefaults>;
 
-  bool has_chrome_thread() const { return _has_field_[7]; }
-  const ChromeThreadDescriptor& chrome_thread() const { return *chrome_thread_; }
-  ChromeThreadDescriptor* mutable_chrome_thread() { _has_field_.set(7); return chrome_thread_.get(); }
+  static constexpr FieldMetadata_PerfSampleDefaults kPerfSampleDefaults{};
+  template <typename T = PerfSampleDefaults> T* set_perf_sample_defaults() {
+    return BeginNestedMessage<T>(12);
+  }
 
-  bool has_counter() const { return _has_field_[8]; }
-  const CounterDescriptor& counter() const { return *counter_; }
-  CounterDescriptor* mutable_counter() { _has_field_.set(8); return counter_.get(); }
 
- private:
-  uint64_t uuid_{};
-  uint64_t parent_uuid_{};
-  std::string name_{};
-  ::protozero::CopyablePtr<ProcessDescriptor> process_;
-  ::protozero::CopyablePtr<ChromeProcessDescriptor> chrome_process_;
-  ::protozero::CopyablePtr<ThreadDescriptor> thread_;
-  ::protozero::CopyablePtr<ChromeThreadDescriptor> chrome_thread_;
-  ::protozero::CopyablePtr<CounterDescriptor> counter_;
+  using FieldMetadata_V8CodeDefaults =
+    ::protozero::proto_utils::FieldMetadata<
+      99,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      V8CodeDefaults,
+      TracePacketDefaults>;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  static constexpr FieldMetadata_V8CodeDefaults kV8CodeDefaults{};
+  template <typename T = V8CodeDefaults> T* set_v8_code_defaults() {
+    return BeginNestedMessage<T>(99);
+  }
 
-  std::bitset<9> _has_field_{};
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/test_event.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TRACK_DESCRIPTOR_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/track_event.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TRACK_EVENT_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TRACK_EVENT_PROTO_CPP_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TEST_EVENT_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TEST_EVENT_PROTO_H_
 
+#include <stddef.h>
 #include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
 namespace perfetto {
 namespace protos {
-namespace gen {
-class EventName;
-class EventCategory;
-class TrackEventDefaults;
-class TrackEvent;
-class TrackEvent_LegacyEvent;
-class ChromeMojoEventInfo;
-class ChromeMessagePump;
-class SourceLocation;
-class ChromeActiveProcesses;
-class ChromeContentSettingsEventInfo;
-class ChromeWindowHandleEventInfo;
-class ChromeRendererSchedulerState;
-class ChromeApplicationStateInfo;
-class ChromeFrameReporter;
-class ChromeLatencyInfo;
-class ChromeLatencyInfo_ComponentInfo;
-class ChromeHistogramSample;
-class ChromeLegacyIpc;
-class ChromeKeyedService;
-class ChromeUserEvent;
-class ChromeCompositorSchedulerState;
-class CompositorTimingHistory;
-class BeginFrameSourceState;
-class BeginFrameArgs;
-class BeginFrameObserverState;
-class BeginImplFrameArgs;
-class BeginImplFrameArgs_TimestampsInUs;
-class ChromeCompositorStateMachine;
-class ChromeCompositorStateMachine_MinorState;
-class ChromeCompositorStateMachine_MajorState;
-class LogMessage;
-class TaskExecution;
+namespace pbzero {
 class DebugAnnotation;
-class DebugAnnotation_NestedValue;
-enum TrackEvent_Type : int;
-enum TrackEvent_LegacyEvent_FlowDirection : int;
-enum TrackEvent_LegacyEvent_InstantEventScope : int;
-enum ChromeRAILMode : int;
-enum ChromeApplicationStateInfo_ChromeApplicationState : int;
-enum ChromeFrameReporter_State : int;
-enum ChromeFrameReporter_FrameDropReason : int;
-enum ChromeFrameReporter_ScrollState : int;
-enum ChromeFrameReporter_FrameType : int;
-enum ChromeLatencyInfo_Step : int;
-enum ChromeLatencyInfo_LatencyComponentType : int;
-enum ChromeLegacyIpc_MessageClass : int;
-enum ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode : int;
-enum ChromeCompositorSchedulerAction : int;
-enum BeginFrameArgs_BeginFrameArgsType : int;
-enum BeginImplFrameArgs_State : int;
-enum ChromeCompositorStateMachine_MinorState_TreePriority : int;
-enum ChromeCompositorStateMachine_MinorState_ScrollHandlerState : int;
-enum ChromeCompositorStateMachine_MajorState_BeginImplFrameState : int;
-enum ChromeCompositorStateMachine_MajorState_BeginMainFrameState : int;
-enum ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState : int;
-enum ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState : int;
-enum DebugAnnotation_NestedValue_NestedType : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
+class TestEvent_ProtoVmIncrementalState;
+class TestEvent_ProtoVmPatch;
+class TestEvent_TestPayload;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
 namespace perfetto {
 namespace protos {
-namespace gen {
-enum TrackEvent_Type : int {
-  TrackEvent_Type_TYPE_UNSPECIFIED = 0,
-  TrackEvent_Type_TYPE_SLICE_BEGIN = 1,
-  TrackEvent_Type_TYPE_SLICE_END = 2,
-  TrackEvent_Type_TYPE_INSTANT = 3,
-  TrackEvent_Type_TYPE_COUNTER = 4,
-};
-enum TrackEvent_LegacyEvent_FlowDirection : int {
-  TrackEvent_LegacyEvent_FlowDirection_FLOW_UNSPECIFIED = 0,
-  TrackEvent_LegacyEvent_FlowDirection_FLOW_IN = 1,
-  TrackEvent_LegacyEvent_FlowDirection_FLOW_OUT = 2,
-  TrackEvent_LegacyEvent_FlowDirection_FLOW_INOUT = 3,
-};
-enum TrackEvent_LegacyEvent_InstantEventScope : int {
-  TrackEvent_LegacyEvent_InstantEventScope_SCOPE_UNSPECIFIED = 0,
-  TrackEvent_LegacyEvent_InstantEventScope_SCOPE_GLOBAL = 1,
-  TrackEvent_LegacyEvent_InstantEventScope_SCOPE_PROCESS = 2,
-  TrackEvent_LegacyEvent_InstantEventScope_SCOPE_THREAD = 3,
+namespace pbzero {
+
+class TestEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
+ public:
+  TestEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TestEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TestEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_str() const { return at<1>().valid(); }
+  ::protozero::ConstChars str() const { return at<1>().as_string(); }
+  bool has_seq_value() const { return at<2>().valid(); }
+  uint32_t seq_value() const { return at<2>().as_uint32(); }
+  bool has_counter() const { return at<3>().valid(); }
+  uint64_t counter() const { return at<3>().as_uint64(); }
+  bool has_is_last() const { return at<4>().valid(); }
+  bool is_last() const { return at<4>().as_bool(); }
+  bool has_payload() const { return at<5>().valid(); }
+  ::protozero::ConstBytes payload() const { return at<5>().as_bytes(); }
+  bool has_protovm_patch() const { return at<6>().valid(); }
+  ::protozero::ConstBytes protovm_patch() const { return at<6>().as_bytes(); }
+  bool has_protovm_incremental_state() const { return at<7>().valid(); }
+  ::protozero::ConstBytes protovm_incremental_state() const { return at<7>().as_bytes(); }
 };
 
-class PERFETTO_EXPORT_COMPONENT EventName : public ::protozero::CppMessageObj {
+class TestEvent : public ::protozero::Message {
  public:
-  enum FieldNumbers {
-    kIidFieldNumber = 1,
-    kNameFieldNumber = 2,
+  using Decoder = TestEvent_Decoder;
+  enum : int32_t {
+    kStrFieldNumber = 1,
+    kSeqValueFieldNumber = 2,
+    kCounterFieldNumber = 3,
+    kIsLastFieldNumber = 4,
+    kPayloadFieldNumber = 5,
+    kProtovmPatchFieldNumber = 6,
+    kProtovmIncrementalStateFieldNumber = 7,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.TestEvent"; }
 
-  EventName();
-  ~EventName() override;
-  EventName(EventName&&) noexcept;
-  EventName& operator=(EventName&&);
-  EventName(const EventName&);
-  EventName& operator=(const EventName&);
-  bool operator==(const EventName&) const;
-  bool operator!=(const EventName& other) const { return !(*this == other); }
+  using TestPayload = ::perfetto::protos::pbzero::TestEvent_TestPayload;
+  using ProtoVmPatch = ::perfetto::protos::pbzero::TestEvent_ProtoVmPatch;
+  using ProtoVmIncrementalState = ::perfetto::protos::pbzero::TestEvent_ProtoVmIncrementalState;
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_Str =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TestEvent>;
 
-  bool has_iid() const { return _has_field_[1]; }
-  uint64_t iid() const { return iid_; }
-  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
+  static constexpr FieldMetadata_Str kStr{};
+  void set_str(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Str::kFieldId, data, size);
+  }
+  void set_str(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Str::kFieldId, chars.data, chars.size);
+  }
+  void set_str(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Str::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_name() const { return _has_field_[2]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
+  using FieldMetadata_SeqValue =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TestEvent>;
 
- private:
-  uint64_t iid_{};
-  std::string name_{};
+  static constexpr FieldMetadata_SeqValue kSeqValue{};
+  void set_seq_value(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SeqValue::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_Counter =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      TestEvent>;
 
-  std::bitset<3> _has_field_{};
-};
+  static constexpr FieldMetadata_Counter kCounter{};
+  void set_counter(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Counter::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
+  using FieldMetadata_IsLast =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      TestEvent>;
 
-class PERFETTO_EXPORT_COMPONENT EventCategory : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kIidFieldNumber = 1,
-    kNameFieldNumber = 2,
-  };
+  static constexpr FieldMetadata_IsLast kIsLast{};
+  void set_is_last(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_IsLast::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-  EventCategory();
-  ~EventCategory() override;
-  EventCategory(EventCategory&&) noexcept;
-  EventCategory& operator=(EventCategory&&);
-  EventCategory(const EventCategory&);
-  EventCategory& operator=(const EventCategory&);
-  bool operator==(const EventCategory&) const;
-  bool operator!=(const EventCategory& other) const { return !(*this == other); }
+  using FieldMetadata_Payload =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TestEvent_TestPayload,
+      TestEvent>;
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  static constexpr FieldMetadata_Payload kPayload{};
+  template <typename T = TestEvent_TestPayload> T* set_payload() {
+    return BeginNestedMessage<T>(5);
+  }
 
-  bool has_iid() const { return _has_field_[1]; }
-  uint64_t iid() const { return iid_; }
-  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
 
-  bool has_name() const { return _has_field_[2]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
+  using FieldMetadata_ProtovmPatch =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TestEvent_ProtoVmPatch,
+      TestEvent>;
 
- private:
-  uint64_t iid_{};
-  std::string name_{};
+  static constexpr FieldMetadata_ProtovmPatch kProtovmPatch{};
+  template <typename T = TestEvent_ProtoVmPatch> T* set_protovm_patch() {
+    return BeginNestedMessage<T>(6);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
 
-  std::bitset<3> _has_field_{};
+  using FieldMetadata_ProtovmIncrementalState =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TestEvent_ProtoVmIncrementalState,
+      TestEvent>;
+
+  static constexpr FieldMetadata_ProtovmIncrementalState kProtovmIncrementalState{};
+  template <typename T = TestEvent_ProtoVmIncrementalState> T* set_protovm_incremental_state() {
+    return BeginNestedMessage<T>(7);
+  }
+
 };
 
+class TestEvent_ProtoVmIncrementalState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  TestEvent_ProtoVmIncrementalState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TestEvent_ProtoVmIncrementalState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TestEvent_ProtoVmIncrementalState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_string_merged() const { return at<1>().valid(); }
+  ::protozero::ConstChars string_merged() const { return at<1>().as_string(); }
+  bool has_int_merged() const { return at<2>().valid(); }
+  int32_t int_merged() const { return at<2>().as_int32(); }
+};
 
-class PERFETTO_EXPORT_COMPONENT TrackEventDefaults : public ::protozero::CppMessageObj {
+class TestEvent_ProtoVmIncrementalState : public ::protozero::Message {
  public:
-  enum FieldNumbers {
-    kTrackUuidFieldNumber = 11,
-    kExtraCounterTrackUuidsFieldNumber = 31,
-    kExtraDoubleCounterTrackUuidsFieldNumber = 45,
+  using Decoder = TestEvent_ProtoVmIncrementalState_Decoder;
+  enum : int32_t {
+    kStringMergedFieldNumber = 1,
+    kIntMergedFieldNumber = 2,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.TestEvent.ProtoVmIncrementalState"; }
 
-  TrackEventDefaults();
-  ~TrackEventDefaults() override;
-  TrackEventDefaults(TrackEventDefaults&&) noexcept;
-  TrackEventDefaults& operator=(TrackEventDefaults&&);
-  TrackEventDefaults(const TrackEventDefaults&);
-  TrackEventDefaults& operator=(const TrackEventDefaults&);
-  bool operator==(const TrackEventDefaults&) const;
-  bool operator!=(const TrackEventDefaults& other) const { return !(*this == other); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_StringMerged =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TestEvent_ProtoVmIncrementalState>;
 
-  bool has_track_uuid() const { return _has_field_[11]; }
-  uint64_t track_uuid() const { return track_uuid_; }
-  void set_track_uuid(uint64_t value) { track_uuid_ = value; _has_field_.set(11); }
+  static constexpr FieldMetadata_StringMerged kStringMerged{};
+  void set_string_merged(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_StringMerged::kFieldId, data, size);
+  }
+  void set_string_merged(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_StringMerged::kFieldId, chars.data, chars.size);
+  }
+  void set_string_merged(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_StringMerged::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-  const std::vector<uint64_t>& extra_counter_track_uuids() const { return extra_counter_track_uuids_; }
-  std::vector<uint64_t>* mutable_extra_counter_track_uuids() { return &extra_counter_track_uuids_; }
-  int extra_counter_track_uuids_size() const { return static_cast<int>(extra_counter_track_uuids_.size()); }
-  void clear_extra_counter_track_uuids() { extra_counter_track_uuids_.clear(); }
-  void add_extra_counter_track_uuids(uint64_t value) { extra_counter_track_uuids_.emplace_back(value); }
-  uint64_t* add_extra_counter_track_uuids() { extra_counter_track_uuids_.emplace_back(); return &extra_counter_track_uuids_.back(); }
+  using FieldMetadata_IntMerged =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TestEvent_ProtoVmIncrementalState>;
 
-  const std::vector<uint64_t>& extra_double_counter_track_uuids() const { return extra_double_counter_track_uuids_; }
-  std::vector<uint64_t>* mutable_extra_double_counter_track_uuids() { return &extra_double_counter_track_uuids_; }
-  int extra_double_counter_track_uuids_size() const { return static_cast<int>(extra_double_counter_track_uuids_.size()); }
-  void clear_extra_double_counter_track_uuids() { extra_double_counter_track_uuids_.clear(); }
-  void add_extra_double_counter_track_uuids(uint64_t value) { extra_double_counter_track_uuids_.emplace_back(value); }
-  uint64_t* add_extra_double_counter_track_uuids() { extra_double_counter_track_uuids_.emplace_back(); return &extra_double_counter_track_uuids_.back(); }
+  static constexpr FieldMetadata_IntMerged kIntMerged{};
+  void set_int_merged(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IntMerged::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
+};
 
- private:
-  uint64_t track_uuid_{};
-  std::vector<uint64_t> extra_counter_track_uuids_;
-  std::vector<uint64_t> extra_double_counter_track_uuids_;
+class TestEvent_ProtoVmPatch_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  TestEvent_ProtoVmPatch_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TestEvent_ProtoVmPatch_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TestEvent_ProtoVmPatch_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_string_to_merge() const { return at<1>().valid(); }
+  ::protozero::ConstChars string_to_merge() const { return at<1>().as_string(); }
+  bool has_int_to_merge() const { return at<2>().valid(); }
+  int32_t int_to_merge() const { return at<2>().as_int32(); }
+};
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+class TestEvent_ProtoVmPatch : public ::protozero::Message {
+ public:
+  using Decoder = TestEvent_ProtoVmPatch_Decoder;
+  enum : int32_t {
+    kStringToMergeFieldNumber = 1,
+    kIntToMergeFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TestEvent.ProtoVmPatch"; }
 
-  std::bitset<46> _has_field_{};
+
+  using FieldMetadata_StringToMerge =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TestEvent_ProtoVmPatch>;
+
+  static constexpr FieldMetadata_StringToMerge kStringToMerge{};
+  void set_string_to_merge(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_StringToMerge::kFieldId, data, size);
+  }
+  void set_string_to_merge(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_StringToMerge::kFieldId, chars.data, chars.size);
+  }
+  void set_string_to_merge(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_StringToMerge::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_IntToMerge =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TestEvent_ProtoVmPatch>;
+
+  static constexpr FieldMetadata_IntToMerge kIntToMerge{};
+  void set_int_to_merge(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IntToMerge::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 };
 
+class TestEvent_TestPayload_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/7> {
+ public:
+  TestEvent_TestPayload_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TestEvent_TestPayload_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TestEvent_TestPayload_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_str() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> str() const { return GetRepeated<::protozero::ConstChars>(1); }
+  bool has_nested() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> nested() const { return GetRepeated<::protozero::ConstBytes>(2); }
+  bool has_single_string() const { return at<4>().valid(); }
+  ::protozero::ConstChars single_string() const { return at<4>().as_string(); }
+  bool has_single_int() const { return at<5>().valid(); }
+  int32_t single_int() const { return at<5>().as_int32(); }
+  bool has_repeated_ints() const { return at<6>().valid(); }
+  ::protozero::RepeatedFieldIterator<int32_t> repeated_ints() const { return GetRepeated<int32_t>(6); }
+  bool has_remaining_nesting_depth() const { return at<3>().valid(); }
+  uint32_t remaining_nesting_depth() const { return at<3>().as_uint32(); }
+  bool has_debug_annotations() const { return at<7>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> debug_annotations() const { return GetRepeated<::protozero::ConstBytes>(7); }
+};
 
-class PERFETTO_EXPORT_COMPONENT TrackEvent : public ::protozero::CppMessageObj {
+class TestEvent_TestPayload : public ::protozero::Message {
  public:
-  using LegacyEvent = TrackEvent_LegacyEvent;
-  using Type = TrackEvent_Type;
-  static constexpr auto TYPE_UNSPECIFIED = TrackEvent_Type_TYPE_UNSPECIFIED;
-  static constexpr auto TYPE_SLICE_BEGIN = TrackEvent_Type_TYPE_SLICE_BEGIN;
-  static constexpr auto TYPE_SLICE_END = TrackEvent_Type_TYPE_SLICE_END;
-  static constexpr auto TYPE_INSTANT = TrackEvent_Type_TYPE_INSTANT;
-  static constexpr auto TYPE_COUNTER = TrackEvent_Type_TYPE_COUNTER;
-  static constexpr auto Type_MIN = TrackEvent_Type_TYPE_UNSPECIFIED;
-  static constexpr auto Type_MAX = TrackEvent_Type_TYPE_COUNTER;
-  enum FieldNumbers {
-    kCategoryIidsFieldNumber = 3,
-    kCategoriesFieldNumber = 22,
-    kNameIidFieldNumber = 10,
-    kNameFieldNumber = 23,
-    kTypeFieldNumber = 9,
-    kTrackUuidFieldNumber = 11,
-    kCounterValueFieldNumber = 30,
-    kDoubleCounterValueFieldNumber = 44,
-    kExtraCounterTrackUuidsFieldNumber = 31,
-    kExtraCounterValuesFieldNumber = 12,
-    kExtraDoubleCounterTrackUuidsFieldNumber = 45,
-    kExtraDoubleCounterValuesFieldNumber = 46,
-    kFlowIdsOldFieldNumber = 36,
-    kFlowIdsFieldNumber = 47,
-    kTerminatingFlowIdsOldFieldNumber = 42,
-    kTerminatingFlowIdsFieldNumber = 48,
-    kDebugAnnotationsFieldNumber = 4,
-    kTaskExecutionFieldNumber = 5,
-    kLogMessageFieldNumber = 21,
-    kCcSchedulerStateFieldNumber = 24,
-    kChromeUserEventFieldNumber = 25,
-    kChromeKeyedServiceFieldNumber = 26,
-    kChromeLegacyIpcFieldNumber = 27,
-    kChromeHistogramSampleFieldNumber = 28,
-    kChromeLatencyInfoFieldNumber = 29,
-    kChromeFrameReporterFieldNumber = 32,
-    kChromeApplicationStateInfoFieldNumber = 39,
-    kChromeRendererSchedulerStateFieldNumber = 40,
-    kChromeWindowHandleEventInfoFieldNumber = 41,
-    kChromeContentSettingsEventInfoFieldNumber = 43,
-    kChromeActiveProcessesFieldNumber = 49,
-    kSourceLocationFieldNumber = 33,
-    kSourceLocationIidFieldNumber = 34,
-    kChromeMessagePumpFieldNumber = 35,
-    kChromeMojoEventInfoFieldNumber = 38,
-    kTimestampDeltaUsFieldNumber = 1,
-    kTimestampAbsoluteUsFieldNumber = 16,
-    kThreadTimeDeltaUsFieldNumber = 2,
-    kThreadTimeAbsoluteUsFieldNumber = 17,
-    kThreadInstructionCountDeltaFieldNumber = 8,
-    kThreadInstructionCountAbsoluteFieldNumber = 20,
-    kLegacyEventFieldNumber = 6,
+  using Decoder = TestEvent_TestPayload_Decoder;
+  enum : int32_t {
+    kStrFieldNumber = 1,
+    kNestedFieldNumber = 2,
+    kSingleStringFieldNumber = 4,
+    kSingleIntFieldNumber = 5,
+    kRepeatedIntsFieldNumber = 6,
+    kRemainingNestingDepthFieldNumber = 3,
+    kDebugAnnotationsFieldNumber = 7,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.TestEvent.TestPayload"; }
 
-  TrackEvent();
-  ~TrackEvent() override;
-  TrackEvent(TrackEvent&&) noexcept;
-  TrackEvent& operator=(TrackEvent&&);
-  TrackEvent(const TrackEvent&);
-  TrackEvent& operator=(const TrackEvent&);
-  bool operator==(const TrackEvent&) const;
-  bool operator!=(const TrackEvent& other) const { return !(*this == other); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_Str =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TestEvent_TestPayload>;
 
-  const std::vector<uint64_t>& category_iids() const { return category_iids_; }
-  std::vector<uint64_t>* mutable_category_iids() { return &category_iids_; }
-  int category_iids_size() const { return static_cast<int>(category_iids_.size()); }
-  void clear_category_iids() { category_iids_.clear(); }
-  void add_category_iids(uint64_t value) { category_iids_.emplace_back(value); }
-  uint64_t* add_category_iids() { category_iids_.emplace_back(); return &category_iids_.back(); }
+  static constexpr FieldMetadata_Str kStr{};
+  void add_str(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Str::kFieldId, data, size);
+  }
+  void add_str(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Str::kFieldId, chars.data, chars.size);
+  }
+  void add_str(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Str::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-  const std::vector<std::string>& categories() const { return categories_; }
-  std::vector<std::string>* mutable_categories() { return &categories_; }
-  int categories_size() const { return static_cast<int>(categories_.size()); }
-  void clear_categories() { categories_.clear(); }
-  void add_categories(std::string value) { categories_.emplace_back(value); }
-  std::string* add_categories() { categories_.emplace_back(); return &categories_.back(); }
+  using FieldMetadata_Nested =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TestEvent_TestPayload,
+      TestEvent_TestPayload>;
 
-  bool has_name_iid() const { return _has_field_[10]; }
-  uint64_t name_iid() const { return name_iid_; }
-  void set_name_iid(uint64_t value) { name_iid_ = value; _has_field_.set(10); }
+  static constexpr FieldMetadata_Nested kNested{};
+  template <typename T = TestEvent_TestPayload> T* add_nested() {
+    return BeginNestedMessage<T>(2);
+  }
 
-  bool has_name() const { return _has_field_[23]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(23); }
 
-  bool has_type() const { return _has_field_[9]; }
-  TrackEvent_Type type() const { return type_; }
-  void set_type(TrackEvent_Type value) { type_ = value; _has_field_.set(9); }
+  using FieldMetadata_SingleString =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TestEvent_TestPayload>;
 
-  bool has_track_uuid() const { return _has_field_[11]; }
-  uint64_t track_uuid() const { return track_uuid_; }
-  void set_track_uuid(uint64_t value) { track_uuid_ = value; _has_field_.set(11); }
+  static constexpr FieldMetadata_SingleString kSingleString{};
+  void set_single_string(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_SingleString::kFieldId, data, size);
+  }
+  void set_single_string(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_SingleString::kFieldId, chars.data, chars.size);
+  }
+  void set_single_string(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_SingleString::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_counter_value() const { return _has_field_[30]; }
-  int64_t counter_value() const { return counter_value_; }
-  void set_counter_value(int64_t value) { counter_value_ = value; _has_field_.set(30); }
+  using FieldMetadata_SingleInt =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TestEvent_TestPayload>;
 
-  bool has_double_counter_value() const { return _has_field_[44]; }
-  double double_counter_value() const { return double_counter_value_; }
-  void set_double_counter_value(double value) { double_counter_value_ = value; _has_field_.set(44); }
+  static constexpr FieldMetadata_SingleInt kSingleInt{};
+  void set_single_int(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SingleInt::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-  const std::vector<uint64_t>& extra_counter_track_uuids() const { return extra_counter_track_uuids_; }
-  std::vector<uint64_t>* mutable_extra_counter_track_uuids() { return &extra_counter_track_uuids_; }
-  int extra_counter_track_uuids_size() const { return static_cast<int>(extra_counter_track_uuids_.size()); }
-  void clear_extra_counter_track_uuids() { extra_counter_track_uuids_.clear(); }
-  void add_extra_counter_track_uuids(uint64_t value) { extra_counter_track_uuids_.emplace_back(value); }
-  uint64_t* add_extra_counter_track_uuids() { extra_counter_track_uuids_.emplace_back(); return &extra_counter_track_uuids_.back(); }
+  using FieldMetadata_RepeatedInts =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TestEvent_TestPayload>;
 
-  const std::vector<int64_t>& extra_counter_values() const { return extra_counter_values_; }
-  std::vector<int64_t>* mutable_extra_counter_values() { return &extra_counter_values_; }
-  int extra_counter_values_size() const { return static_cast<int>(extra_counter_values_.size()); }
-  void clear_extra_counter_values() { extra_counter_values_.clear(); }
-  void add_extra_counter_values(int64_t value) { extra_counter_values_.emplace_back(value); }
-  int64_t* add_extra_counter_values() { extra_counter_values_.emplace_back(); return &extra_counter_values_.back(); }
+  static constexpr FieldMetadata_RepeatedInts kRepeatedInts{};
+  void add_repeated_ints(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RepeatedInts::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-  const std::vector<uint64_t>& extra_double_counter_track_uuids() const { return extra_double_counter_track_uuids_; }
-  std::vector<uint64_t>* mutable_extra_double_counter_track_uuids() { return &extra_double_counter_track_uuids_; }
-  int extra_double_counter_track_uuids_size() const { return static_cast<int>(extra_double_counter_track_uuids_.size()); }
-  void clear_extra_double_counter_track_uuids() { extra_double_counter_track_uuids_.clear(); }
-  void add_extra_double_counter_track_uuids(uint64_t value) { extra_double_counter_track_uuids_.emplace_back(value); }
-  uint64_t* add_extra_double_counter_track_uuids() { extra_double_counter_track_uuids_.emplace_back(); return &extra_double_counter_track_uuids_.back(); }
+  using FieldMetadata_RemainingNestingDepth =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TestEvent_TestPayload>;
 
-  const std::vector<double>& extra_double_counter_values() const { return extra_double_counter_values_; }
-  std::vector<double>* mutable_extra_double_counter_values() { return &extra_double_counter_values_; }
-  int extra_double_counter_values_size() const { return static_cast<int>(extra_double_counter_values_.size()); }
-  void clear_extra_double_counter_values() { extra_double_counter_values_.clear(); }
-  void add_extra_double_counter_values(double value) { extra_double_counter_values_.emplace_back(value); }
-  double* add_extra_double_counter_values() { extra_double_counter_values_.emplace_back(); return &extra_double_counter_values_.back(); }
+  static constexpr FieldMetadata_RemainingNestingDepth kRemainingNestingDepth{};
+  void set_remaining_nesting_depth(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RemainingNestingDepth::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  const std::vector<uint64_t>& flow_ids_old() const { return flow_ids_old_; }
-  std::vector<uint64_t>* mutable_flow_ids_old() { return &flow_ids_old_; }
-  int flow_ids_old_size() const { return static_cast<int>(flow_ids_old_.size()); }
-  void clear_flow_ids_old() { flow_ids_old_.clear(); }
-  void add_flow_ids_old(uint64_t value) { flow_ids_old_.emplace_back(value); }
-  uint64_t* add_flow_ids_old() { flow_ids_old_.emplace_back(); return &flow_ids_old_.back(); }
+  using FieldMetadata_DebugAnnotations =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      DebugAnnotation,
+      TestEvent_TestPayload>;
 
-  const std::vector<uint64_t>& flow_ids() const { return flow_ids_; }
-  std::vector<uint64_t>* mutable_flow_ids() { return &flow_ids_; }
-  int flow_ids_size() const { return static_cast<int>(flow_ids_.size()); }
-  void clear_flow_ids() { flow_ids_.clear(); }
-  void add_flow_ids(uint64_t value) { flow_ids_.emplace_back(value); }
-  uint64_t* add_flow_ids() { flow_ids_.emplace_back(); return &flow_ids_.back(); }
+  static constexpr FieldMetadata_DebugAnnotations kDebugAnnotations{};
+  template <typename T = DebugAnnotation> T* add_debug_annotations() {
+    return BeginNestedMessage<T>(7);
+  }
 
-  const std::vector<uint64_t>& terminating_flow_ids_old() const { return terminating_flow_ids_old_; }
-  std::vector<uint64_t>* mutable_terminating_flow_ids_old() { return &terminating_flow_ids_old_; }
-  int terminating_flow_ids_old_size() const { return static_cast<int>(terminating_flow_ids_old_.size()); }
-  void clear_terminating_flow_ids_old() { terminating_flow_ids_old_.clear(); }
-  void add_terminating_flow_ids_old(uint64_t value) { terminating_flow_ids_old_.emplace_back(value); }
-  uint64_t* add_terminating_flow_ids_old() { terminating_flow_ids_old_.emplace_back(); return &terminating_flow_ids_old_.back(); }
+};
 
-  const std::vector<uint64_t>& terminating_flow_ids() const { return terminating_flow_ids_; }
-  std::vector<uint64_t>* mutable_terminating_flow_ids() { return &terminating_flow_ids_; }
-  int terminating_flow_ids_size() const { return static_cast<int>(terminating_flow_ids_.size()); }
-  void clear_terminating_flow_ids() { terminating_flow_ids_.clear(); }
-  void add_terminating_flow_ids(uint64_t value) { terminating_flow_ids_.emplace_back(value); }
-  uint64_t* add_terminating_flow_ids() { terminating_flow_ids_.emplace_back(); return &terminating_flow_ids_.back(); }
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/test_extensions.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TEST_EXTENSIONS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TEST_EXTENSIONS_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_event.pbzero.h"
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class DebugAnnotation;
+class TestExtensionChild;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+class TestExtensionChild_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/99> {
+ public:
+  TestExtensionChild_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit TestExtensionChild_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit TestExtensionChild_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_child_field_for_testing() const { return at<1>().valid(); }
+  ::protozero::ConstChars child_field_for_testing() const { return at<1>().as_string(); }
+  bool has_debug_annotations() const { return at<99>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> debug_annotations() const { return GetRepeated<::protozero::ConstBytes>(99); }
+};
+
+class TestExtensionChild : public ::protozero::Message {
+ public:
+  using Decoder = TestExtensionChild_Decoder;
+  enum : int32_t {
+    kChildFieldForTestingFieldNumber = 1,
+    kDebugAnnotationsFieldNumber = 99,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.TestExtensionChild"; }
+
+
+  using FieldMetadata_ChildFieldForTesting =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TestExtensionChild>;
+
+  static constexpr FieldMetadata_ChildFieldForTesting kChildFieldForTesting{};
+  void set_child_field_for_testing(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ChildFieldForTesting::kFieldId, data, size);
+  }
+  void set_child_field_for_testing(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ChildFieldForTesting::kFieldId, chars.data, chars.size);
+  }
+  void set_child_field_for_testing(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ChildFieldForTesting::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_DebugAnnotations =
+    ::protozero::proto_utils::FieldMetadata<
+      99,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      DebugAnnotation,
+      TestExtensionChild>;
+
+  static constexpr FieldMetadata_DebugAnnotations kDebugAnnotations{};
+  template <typename T = DebugAnnotation> T* add_debug_annotations() {
+    return BeginNestedMessage<T>(99);
+  }
+
+};
+
+class TestExtension : public ::perfetto::protos::pbzero::TrackEvent {
+ public:
+
+  using FieldMetadata_StringExtensionForTesting =
+    ::protozero::proto_utils::FieldMetadata<
+      9900,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TestExtension>;
+
+  static constexpr FieldMetadata_StringExtensionForTesting kStringExtensionForTesting{};
+  void set_string_extension_for_testing(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_StringExtensionForTesting::kFieldId, data, size);
+  }
+  void set_string_extension_for_testing(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_StringExtensionForTesting::kFieldId, chars.data, chars.size);
+  }
+  void set_string_extension_for_testing(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_StringExtensionForTesting::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-  const std::vector<DebugAnnotation>& debug_annotations() const { return debug_annotations_; }
-  std::vector<DebugAnnotation>* mutable_debug_annotations() { return &debug_annotations_; }
-  int debug_annotations_size() const;
-  void clear_debug_annotations();
-  DebugAnnotation* add_debug_annotations();
+  using FieldMetadata_StringExtensionForTesting2 =
+    ::protozero::proto_utils::FieldMetadata<
+      9905,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TestExtension>;
 
-  bool has_task_execution() const { return _has_field_[5]; }
-  const TaskExecution& task_execution() const { return *task_execution_; }
-  TaskExecution* mutable_task_execution() { _has_field_.set(5); return task_execution_.get(); }
+  static constexpr FieldMetadata_StringExtensionForTesting2 kStringExtensionForTesting2{};
+  void set_string_extension_for_testing2(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_StringExtensionForTesting2::kFieldId, data, size);
+  }
+  void set_string_extension_for_testing2(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_StringExtensionForTesting2::kFieldId, chars.data, chars.size);
+  }
+  void set_string_extension_for_testing2(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_StringExtensionForTesting2::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_log_message() const { return _has_field_[21]; }
-  const LogMessage& log_message() const { return *log_message_; }
-  LogMessage* mutable_log_message() { _has_field_.set(21); return log_message_.get(); }
+  using FieldMetadata_IntExtensionForTesting =
+    ::protozero::proto_utils::FieldMetadata<
+      9901,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      TestExtension>;
 
-  bool has_cc_scheduler_state() const { return _has_field_[24]; }
-  const ChromeCompositorSchedulerState& cc_scheduler_state() const { return *cc_scheduler_state_; }
-  ChromeCompositorSchedulerState* mutable_cc_scheduler_state() { _has_field_.set(24); return cc_scheduler_state_.get(); }
+  static constexpr FieldMetadata_IntExtensionForTesting kIntExtensionForTesting{};
+  void add_int_extension_for_testing(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_IntExtensionForTesting::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_chrome_user_event() const { return _has_field_[25]; }
-  const ChromeUserEvent& chrome_user_event() const { return *chrome_user_event_; }
-  ChromeUserEvent* mutable_chrome_user_event() { _has_field_.set(25); return chrome_user_event_.get(); }
+  using FieldMetadata_OmittedExtensionForTesting =
+    ::protozero::proto_utils::FieldMetadata<
+      9902,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      TestExtension>;
 
-  bool has_chrome_keyed_service() const { return _has_field_[26]; }
-  const ChromeKeyedService& chrome_keyed_service() const { return *chrome_keyed_service_; }
-  ChromeKeyedService* mutable_chrome_keyed_service() { _has_field_.set(26); return chrome_keyed_service_.get(); }
+  static constexpr FieldMetadata_OmittedExtensionForTesting kOmittedExtensionForTesting{};
+  void set_omitted_extension_for_testing(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_OmittedExtensionForTesting::kFieldId, data, size);
+  }
+  void set_omitted_extension_for_testing(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_OmittedExtensionForTesting::kFieldId, chars.data, chars.size);
+  }
+  void set_omitted_extension_for_testing(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_OmittedExtensionForTesting::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_chrome_legacy_ipc() const { return _has_field_[27]; }
-  const ChromeLegacyIpc& chrome_legacy_ipc() const { return *chrome_legacy_ipc_; }
-  ChromeLegacyIpc* mutable_chrome_legacy_ipc() { _has_field_.set(27); return chrome_legacy_ipc_.get(); }
+  using FieldMetadata_NestedMessageExtensionForTesting =
+    ::protozero::proto_utils::FieldMetadata<
+      9903,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TestExtensionChild,
+      TestExtension>;
 
-  bool has_chrome_histogram_sample() const { return _has_field_[28]; }
-  const ChromeHistogramSample& chrome_histogram_sample() const { return *chrome_histogram_sample_; }
-  ChromeHistogramSample* mutable_chrome_histogram_sample() { _has_field_.set(28); return chrome_histogram_sample_.get(); }
+  static constexpr FieldMetadata_NestedMessageExtensionForTesting kNestedMessageExtensionForTesting{};
+  template <typename T = TestExtensionChild> T* set_nested_message_extension_for_testing() {
+    return BeginNestedMessage<T>(9903);
+  }
 
-  bool has_chrome_latency_info() const { return _has_field_[29]; }
-  const ChromeLatencyInfo& chrome_latency_info() const { return *chrome_latency_info_; }
-  ChromeLatencyInfo* mutable_chrome_latency_info() { _has_field_.set(29); return chrome_latency_info_.get(); }
 
-  bool has_chrome_frame_reporter() const { return _has_field_[32]; }
-  const ChromeFrameReporter& chrome_frame_reporter() const { return *chrome_frame_reporter_; }
-  ChromeFrameReporter* mutable_chrome_frame_reporter() { _has_field_.set(32); return chrome_frame_reporter_.get(); }
+  using FieldMetadata_UintExtensionForTesting =
+    ::protozero::proto_utils::FieldMetadata<
+      9904,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      TestExtension>;
 
-  bool has_chrome_application_state_info() const { return _has_field_[39]; }
-  const ChromeApplicationStateInfo& chrome_application_state_info() const { return *chrome_application_state_info_; }
-  ChromeApplicationStateInfo* mutable_chrome_application_state_info() { _has_field_.set(39); return chrome_application_state_info_.get(); }
+  static constexpr FieldMetadata_UintExtensionForTesting kUintExtensionForTesting{};
+  void set_uint_extension_for_testing(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_UintExtensionForTesting::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+  enum : int32_t {
+    kStringExtensionForTestingFieldNumber = 9900,
+    kStringExtensionForTesting2FieldNumber = 9905,
+    kIntExtensionForTestingFieldNumber = 9901,
+    kOmittedExtensionForTestingFieldNumber = 9902,
+    kNestedMessageExtensionForTestingFieldNumber = 9903,
+    kUintExtensionForTestingFieldNumber = 9904,
+  };
+};
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/trace.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  bool has_chrome_renderer_scheduler_state() const { return _has_field_[40]; }
-  const ChromeRendererSchedulerState& chrome_renderer_scheduler_state() const { return *chrome_renderer_scheduler_state_; }
-  ChromeRendererSchedulerState* mutable_chrome_renderer_scheduler_state() { _has_field_.set(40); return chrome_renderer_scheduler_state_.get(); }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACE_PROTO_H_
 
-  bool has_chrome_window_handle_event_info() const { return _has_field_[41]; }
-  const ChromeWindowHandleEventInfo& chrome_window_handle_event_info() const { return *chrome_window_handle_event_info_; }
-  ChromeWindowHandleEventInfo* mutable_chrome_window_handle_event_info() { _has_field_.set(41); return chrome_window_handle_event_info_.get(); }
+#include <stddef.h>
+#include <stdint.h>
 
-  bool has_chrome_content_settings_event_info() const { return _has_field_[43]; }
-  const ChromeContentSettingsEventInfo& chrome_content_settings_event_info() const { return *chrome_content_settings_event_info_; }
-  ChromeContentSettingsEventInfo* mutable_chrome_content_settings_event_info() { _has_field_.set(43); return chrome_content_settings_event_info_.get(); }
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  bool has_chrome_active_processes() const { return _has_field_[49]; }
-  const ChromeActiveProcesses& chrome_active_processes() const { return *chrome_active_processes_; }
-  ChromeActiveProcesses* mutable_chrome_active_processes() { _has_field_.set(49); return chrome_active_processes_.get(); }
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class TracePacket;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-  bool has_source_location() const { return _has_field_[33]; }
-  const SourceLocation& source_location() const { return *source_location_; }
-  SourceLocation* mutable_source_location() { _has_field_.set(33); return source_location_.get(); }
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-  bool has_source_location_iid() const { return _has_field_[34]; }
-  uint64_t source_location_iid() const { return source_location_iid_; }
-  void set_source_location_iid(uint64_t value) { source_location_iid_ = value; _has_field_.set(34); }
+class Trace_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  Trace_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit Trace_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit Trace_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_packet() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> packet() const { return GetRepeated<::protozero::ConstBytes>(1); }
+};
 
-  bool has_chrome_message_pump() const { return _has_field_[35]; }
-  const ChromeMessagePump& chrome_message_pump() const { return *chrome_message_pump_; }
-  ChromeMessagePump* mutable_chrome_message_pump() { _has_field_.set(35); return chrome_message_pump_.get(); }
+class Trace : public ::protozero::Message {
+ public:
+  using Decoder = Trace_Decoder;
+  enum : int32_t {
+    kPacketFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.Trace"; }
 
-  bool has_chrome_mojo_event_info() const { return _has_field_[38]; }
-  const ChromeMojoEventInfo& chrome_mojo_event_info() const { return *chrome_mojo_event_info_; }
-  ChromeMojoEventInfo* mutable_chrome_mojo_event_info() { _has_field_.set(38); return chrome_mojo_event_info_.get(); }
 
-  bool has_timestamp_delta_us() const { return _has_field_[1]; }
-  int64_t timestamp_delta_us() const { return timestamp_delta_us_; }
-  void set_timestamp_delta_us(int64_t value) { timestamp_delta_us_ = value; _has_field_.set(1); }
+  using FieldMetadata_Packet =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      TracePacket,
+      Trace>;
 
-  bool has_timestamp_absolute_us() const { return _has_field_[16]; }
-  int64_t timestamp_absolute_us() const { return timestamp_absolute_us_; }
-  void set_timestamp_absolute_us(int64_t value) { timestamp_absolute_us_ = value; _has_field_.set(16); }
+  static constexpr FieldMetadata_Packet kPacket{};
+  template <typename T = TracePacket> T* add_packet() {
+    return BeginNestedMessage<T>(1);
+  }
 
-  bool has_thread_time_delta_us() const { return _has_field_[2]; }
-  int64_t thread_time_delta_us() const { return thread_time_delta_us_; }
-  void set_thread_time_delta_us(int64_t value) { thread_time_delta_us_ = value; _has_field_.set(2); }
+};
 
-  bool has_thread_time_absolute_us() const { return _has_field_[17]; }
-  int64_t thread_time_absolute_us() const { return thread_time_absolute_us_; }
-  void set_thread_time_absolute_us(int64_t value) { thread_time_absolute_us_ = value; _has_field_.set(17); }
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/extension_descriptor.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  bool has_thread_instruction_count_delta() const { return _has_field_[8]; }
-  int64_t thread_instruction_count_delta() const { return thread_instruction_count_delta_; }
-  void set_thread_instruction_count_delta(int64_t value) { thread_instruction_count_delta_ = value; _has_field_.set(8); }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_EXTENSION_DESCRIPTOR_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_EXTENSION_DESCRIPTOR_PROTO_H_
 
-  bool has_thread_instruction_count_absolute() const { return _has_field_[20]; }
-  int64_t thread_instruction_count_absolute() const { return thread_instruction_count_absolute_; }
-  void set_thread_instruction_count_absolute(int64_t value) { thread_instruction_count_absolute_ = value; _has_field_.set(20); }
+#include <stddef.h>
+#include <stdint.h>
 
-  bool has_legacy_event() const { return _has_field_[6]; }
-  const TrackEvent_LegacyEvent& legacy_event() const { return *legacy_event_; }
-  TrackEvent_LegacyEvent* mutable_legacy_event() { _has_field_.set(6); return legacy_event_.get(); }
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
- private:
-  std::vector<uint64_t> category_iids_;
-  std::vector<std::string> categories_;
-  uint64_t name_iid_{};
-  std::string name_{};
-  TrackEvent_Type type_{};
-  uint64_t track_uuid_{};
-  int64_t counter_value_{};
-  double double_counter_value_{};
-  std::vector<uint64_t> extra_counter_track_uuids_;
-  std::vector<int64_t> extra_counter_values_;
-  std::vector<uint64_t> extra_double_counter_track_uuids_;
-  std::vector<double> extra_double_counter_values_;
-  std::vector<uint64_t> flow_ids_old_;
-  std::vector<uint64_t> flow_ids_;
-  std::vector<uint64_t> terminating_flow_ids_old_;
-  std::vector<uint64_t> terminating_flow_ids_;
-  std::vector<DebugAnnotation> debug_annotations_;
-  ::protozero::CopyablePtr<TaskExecution> task_execution_;
-  ::protozero::CopyablePtr<LogMessage> log_message_;
-  ::protozero::CopyablePtr<ChromeCompositorSchedulerState> cc_scheduler_state_;
-  ::protozero::CopyablePtr<ChromeUserEvent> chrome_user_event_;
-  ::protozero::CopyablePtr<ChromeKeyedService> chrome_keyed_service_;
-  ::protozero::CopyablePtr<ChromeLegacyIpc> chrome_legacy_ipc_;
-  ::protozero::CopyablePtr<ChromeHistogramSample> chrome_histogram_sample_;
-  ::protozero::CopyablePtr<ChromeLatencyInfo> chrome_latency_info_;
-  ::protozero::CopyablePtr<ChromeFrameReporter> chrome_frame_reporter_;
-  ::protozero::CopyablePtr<ChromeApplicationStateInfo> chrome_application_state_info_;
-  ::protozero::CopyablePtr<ChromeRendererSchedulerState> chrome_renderer_scheduler_state_;
-  ::protozero::CopyablePtr<ChromeWindowHandleEventInfo> chrome_window_handle_event_info_;
-  ::protozero::CopyablePtr<ChromeContentSettingsEventInfo> chrome_content_settings_event_info_;
-  ::protozero::CopyablePtr<ChromeActiveProcesses> chrome_active_processes_;
-  ::protozero::CopyablePtr<SourceLocation> source_location_;
-  uint64_t source_location_iid_{};
-  ::protozero::CopyablePtr<ChromeMessagePump> chrome_message_pump_;
-  ::protozero::CopyablePtr<ChromeMojoEventInfo> chrome_mojo_event_info_;
-  int64_t timestamp_delta_us_{};
-  int64_t timestamp_absolute_us_{};
-  int64_t thread_time_delta_us_{};
-  int64_t thread_time_absolute_us_{};
-  int64_t thread_instruction_count_delta_{};
-  int64_t thread_instruction_count_absolute_{};
-  ::protozero::CopyablePtr<TrackEvent_LegacyEvent> legacy_event_;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class FileDescriptorSet;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-  std::bitset<50> _has_field_{};
+class ExtensionDescriptor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  ExtensionDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit ExtensionDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit ExtensionDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_extension_set() const { return at<1>().valid(); }
+  ::protozero::ConstBytes extension_set() const { return at<1>().as_bytes(); }
+  bool has_extension_set_gzip() const { return at<2>().valid(); }
+  ::protozero::ConstBytes extension_set_gzip() const { return at<2>().as_bytes(); }
+  bool has_file_name() const { return at<3>().valid(); }
+  ::protozero::ConstChars file_name() const { return at<3>().as_string(); }
 };
 
-
-class PERFETTO_EXPORT_COMPONENT TrackEvent_LegacyEvent : public ::protozero::CppMessageObj {
+class ExtensionDescriptor : public ::protozero::Message {
  public:
-  using FlowDirection = TrackEvent_LegacyEvent_FlowDirection;
-  static constexpr auto FLOW_UNSPECIFIED = TrackEvent_LegacyEvent_FlowDirection_FLOW_UNSPECIFIED;
-  static constexpr auto FLOW_IN = TrackEvent_LegacyEvent_FlowDirection_FLOW_IN;
-  static constexpr auto FLOW_OUT = TrackEvent_LegacyEvent_FlowDirection_FLOW_OUT;
-  static constexpr auto FLOW_INOUT = TrackEvent_LegacyEvent_FlowDirection_FLOW_INOUT;
-  static constexpr auto FlowDirection_MIN = TrackEvent_LegacyEvent_FlowDirection_FLOW_UNSPECIFIED;
-  static constexpr auto FlowDirection_MAX = TrackEvent_LegacyEvent_FlowDirection_FLOW_INOUT;
-  using InstantEventScope = TrackEvent_LegacyEvent_InstantEventScope;
-  static constexpr auto SCOPE_UNSPECIFIED = TrackEvent_LegacyEvent_InstantEventScope_SCOPE_UNSPECIFIED;
-  static constexpr auto SCOPE_GLOBAL = TrackEvent_LegacyEvent_InstantEventScope_SCOPE_GLOBAL;
-  static constexpr auto SCOPE_PROCESS = TrackEvent_LegacyEvent_InstantEventScope_SCOPE_PROCESS;
-  static constexpr auto SCOPE_THREAD = TrackEvent_LegacyEvent_InstantEventScope_SCOPE_THREAD;
-  static constexpr auto InstantEventScope_MIN = TrackEvent_LegacyEvent_InstantEventScope_SCOPE_UNSPECIFIED;
-  static constexpr auto InstantEventScope_MAX = TrackEvent_LegacyEvent_InstantEventScope_SCOPE_THREAD;
-  enum FieldNumbers {
-    kNameIidFieldNumber = 1,
-    kPhaseFieldNumber = 2,
-    kDurationUsFieldNumber = 3,
-    kThreadDurationUsFieldNumber = 4,
-    kThreadInstructionDeltaFieldNumber = 15,
-    kUnscopedIdFieldNumber = 6,
-    kLocalIdFieldNumber = 10,
-    kGlobalIdFieldNumber = 11,
-    kIdScopeFieldNumber = 7,
-    kUseAsyncTtsFieldNumber = 9,
-    kBindIdFieldNumber = 8,
-    kBindToEnclosingFieldNumber = 12,
-    kFlowDirectionFieldNumber = 13,
-    kInstantEventScopeFieldNumber = 14,
-    kPidOverrideFieldNumber = 18,
-    kTidOverrideFieldNumber = 19,
+  using Decoder = ExtensionDescriptor_Decoder;
+  enum : int32_t {
+    kExtensionSetFieldNumber = 1,
+    kExtensionSetGzipFieldNumber = 2,
+    kFileNameFieldNumber = 3,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.ExtensionDescriptor"; }
 
-  TrackEvent_LegacyEvent();
-  ~TrackEvent_LegacyEvent() override;
-  TrackEvent_LegacyEvent(TrackEvent_LegacyEvent&&) noexcept;
-  TrackEvent_LegacyEvent& operator=(TrackEvent_LegacyEvent&&);
-  TrackEvent_LegacyEvent(const TrackEvent_LegacyEvent&);
-  TrackEvent_LegacyEvent& operator=(const TrackEvent_LegacyEvent&);
-  bool operator==(const TrackEvent_LegacyEvent&) const;
-  bool operator!=(const TrackEvent_LegacyEvent& other) const { return !(*this == other); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_ExtensionSet =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      FileDescriptorSet,
+      ExtensionDescriptor>;
 
-  bool has_name_iid() const { return _has_field_[1]; }
-  uint64_t name_iid() const { return name_iid_; }
-  void set_name_iid(uint64_t value) { name_iid_ = value; _has_field_.set(1); }
+  static constexpr FieldMetadata_ExtensionSet kExtensionSet{};
+  template <typename T = FileDescriptorSet> T* set_extension_set() {
+    return BeginNestedMessage<T>(1);
+  }
 
-  bool has_phase() const { return _has_field_[2]; }
-  int32_t phase() const { return phase_; }
-  void set_phase(int32_t value) { phase_ = value; _has_field_.set(2); }
 
-  bool has_duration_us() const { return _has_field_[3]; }
-  int64_t duration_us() const { return duration_us_; }
-  void set_duration_us(int64_t value) { duration_us_ = value; _has_field_.set(3); }
+  using FieldMetadata_ExtensionSetGzip =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      ExtensionDescriptor>;
 
-  bool has_thread_duration_us() const { return _has_field_[4]; }
-  int64_t thread_duration_us() const { return thread_duration_us_; }
-  void set_thread_duration_us(int64_t value) { thread_duration_us_ = value; _has_field_.set(4); }
+  static constexpr FieldMetadata_ExtensionSetGzip kExtensionSetGzip{};
+  void set_extension_set_gzip(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_ExtensionSetGzip::kFieldId, data, size);
+  }
+  void set_extension_set_gzip(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_ExtensionSetGzip::kFieldId, bytes.data, bytes.size);
+  }
+  void set_extension_set_gzip(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ExtensionSetGzip::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_thread_instruction_delta() const { return _has_field_[15]; }
-  int64_t thread_instruction_delta() const { return thread_instruction_delta_; }
-  void set_thread_instruction_delta(int64_t value) { thread_instruction_delta_ = value; _has_field_.set(15); }
+  using FieldMetadata_FileName =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ExtensionDescriptor>;
 
-  bool has_unscoped_id() const { return _has_field_[6]; }
-  uint64_t unscoped_id() const { return unscoped_id_; }
-  void set_unscoped_id(uint64_t value) { unscoped_id_ = value; _has_field_.set(6); }
+  static constexpr FieldMetadata_FileName kFileName{};
+  void set_file_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_FileName::kFieldId, data, size);
+  }
+  void set_file_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_FileName::kFieldId, chars.data, chars.size);
+  }
+  void set_file_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_FileName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
+};
 
-  bool has_local_id() const { return _has_field_[10]; }
-  uint64_t local_id() const { return local_id_; }
-  void set_local_id(uint64_t value) { local_id_ = value; _has_field_.set(10); }
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/memory_graph.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-  bool has_global_id() const { return _has_field_[11]; }
-  uint64_t global_id() const { return global_id_; }
-  void set_global_id(uint64_t value) { global_id_ = value; _has_field_.set(11); }
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_MEMORY_GRAPH_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_MEMORY_GRAPH_PROTO_H_
 
-  bool has_id_scope() const { return _has_field_[7]; }
-  const std::string& id_scope() const { return id_scope_; }
-  void set_id_scope(const std::string& value) { id_scope_ = value; _has_field_.set(7); }
+#include <stddef.h>
+#include <stdint.h>
 
-  bool has_use_async_tts() const { return _has_field_[9]; }
-  bool use_async_tts() const { return use_async_tts_; }
-  void set_use_async_tts(bool value) { use_async_tts_ = value; _has_field_.set(9); }
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
-  bool has_bind_id() const { return _has_field_[8]; }
-  uint64_t bind_id() const { return bind_id_; }
-  void set_bind_id(uint64_t value) { bind_id_ = value; _has_field_.set(8); }
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class MemoryTrackerSnapshot_ProcessSnapshot;
+class MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge;
+class MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode;
+class MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry;
+namespace perfetto_pbzero_enum_MemoryTrackerSnapshot {
+enum LevelOfDetail : int32_t;
+}  // namespace perfetto_pbzero_enum_MemoryTrackerSnapshot
+using MemoryTrackerSnapshot_LevelOfDetail = perfetto_pbzero_enum_MemoryTrackerSnapshot::LevelOfDetail;
+namespace perfetto_pbzero_enum_MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry {
+enum Units : int32_t;
+}  // namespace perfetto_pbzero_enum_MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry
+using MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units = perfetto_pbzero_enum_MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry::Units;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
-  bool has_bind_to_enclosing() const { return _has_field_[12]; }
-  bool bind_to_enclosing() const { return bind_to_enclosing_; }
-  void set_bind_to_enclosing(bool value) { bind_to_enclosing_ = value; _has_field_.set(12); }
+namespace perfetto {
+namespace protos {
+namespace pbzero {
 
-  bool has_flow_direction() const { return _has_field_[13]; }
-  TrackEvent_LegacyEvent_FlowDirection flow_direction() const { return flow_direction_; }
-  void set_flow_direction(TrackEvent_LegacyEvent_FlowDirection value) { flow_direction_ = value; _has_field_.set(13); }
+namespace perfetto_pbzero_enum_MemoryTrackerSnapshot {
+enum LevelOfDetail : int32_t {
+  DETAIL_FULL = 0,
+  DETAIL_LIGHT = 1,
+  DETAIL_BACKGROUND = 2,
+};
+} // namespace perfetto_pbzero_enum_MemoryTrackerSnapshot
+using MemoryTrackerSnapshot_LevelOfDetail = perfetto_pbzero_enum_MemoryTrackerSnapshot::LevelOfDetail;
 
-  bool has_instant_event_scope() const { return _has_field_[14]; }
-  TrackEvent_LegacyEvent_InstantEventScope instant_event_scope() const { return instant_event_scope_; }
-  void set_instant_event_scope(TrackEvent_LegacyEvent_InstantEventScope value) { instant_event_scope_ = value; _has_field_.set(14); }
 
-  bool has_pid_override() const { return _has_field_[18]; }
-  int32_t pid_override() const { return pid_override_; }
-  void set_pid_override(int32_t value) { pid_override_ = value; _has_field_.set(18); }
+constexpr MemoryTrackerSnapshot_LevelOfDetail MemoryTrackerSnapshot_LevelOfDetail_MIN = MemoryTrackerSnapshot_LevelOfDetail::DETAIL_FULL;
+constexpr MemoryTrackerSnapshot_LevelOfDetail MemoryTrackerSnapshot_LevelOfDetail_MAX = MemoryTrackerSnapshot_LevelOfDetail::DETAIL_BACKGROUND;
 
-  bool has_tid_override() const { return _has_field_[19]; }
-  int32_t tid_override() const { return tid_override_; }
-  void set_tid_override(int32_t value) { tid_override_ = value; _has_field_.set(19); }
 
- private:
-  uint64_t name_iid_{};
-  int32_t phase_{};
-  int64_t duration_us_{};
-  int64_t thread_duration_us_{};
-  int64_t thread_instruction_delta_{};
-  uint64_t unscoped_id_{};
-  uint64_t local_id_{};
-  uint64_t global_id_{};
-  std::string id_scope_{};
-  bool use_async_tts_{};
-  uint64_t bind_id_{};
-  bool bind_to_enclosing_{};
-  TrackEvent_LegacyEvent_FlowDirection flow_direction_{};
-  TrackEvent_LegacyEvent_InstantEventScope instant_event_scope_{};
-  int32_t pid_override_{};
-  int32_t tid_override_{};
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* MemoryTrackerSnapshot_LevelOfDetail_Name(::perfetto::protos::pbzero::MemoryTrackerSnapshot_LevelOfDetail value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::MemoryTrackerSnapshot_LevelOfDetail::DETAIL_FULL:
+    return "DETAIL_FULL";
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  case ::perfetto::protos::pbzero::MemoryTrackerSnapshot_LevelOfDetail::DETAIL_LIGHT:
+    return "DETAIL_LIGHT";
 
-  std::bitset<20> _has_field_{};
+  case ::perfetto::protos::pbzero::MemoryTrackerSnapshot_LevelOfDetail::DETAIL_BACKGROUND:
+    return "DETAIL_BACKGROUND";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry {
+enum Units : int32_t {
+  UNSPECIFIED = 0,
+  BYTES = 1,
+  COUNT = 2,
 };
+} // namespace perfetto_pbzero_enum_MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry
+using MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units = perfetto_pbzero_enum_MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry::Units;
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TRACK_EVENT_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_game_intervention_list_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_GAME_INTERVENTION_LIST_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_GAME_INTERVENTION_LIST_CONFIG_PROTO_CPP_H_
+constexpr MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units_MIN = MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units::UNSPECIFIED;
+constexpr MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units_MAX = MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units::COUNT;
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units_Name(::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units::UNSPECIFIED:
+    return "UNSPECIFIED";
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class AndroidGameInterventionListConfig;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  case ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units::BYTES:
+    return "BYTES";
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  case ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units::COUNT:
+    return "COUNT";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+class MemoryTrackerSnapshot_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  MemoryTrackerSnapshot_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MemoryTrackerSnapshot_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MemoryTrackerSnapshot_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_global_dump_id() const { return at<1>().valid(); }
+  uint64_t global_dump_id() const { return at<1>().as_uint64(); }
+  bool has_level_of_detail() const { return at<2>().valid(); }
+  int32_t level_of_detail() const { return at<2>().as_int32(); }
+  bool has_process_memory_dumps() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> process_memory_dumps() const { return GetRepeated<::protozero::ConstBytes>(3); }
+};
 
-class PERFETTO_EXPORT_COMPONENT AndroidGameInterventionListConfig : public ::protozero::CppMessageObj {
+class MemoryTrackerSnapshot : public ::protozero::Message {
  public:
-  enum FieldNumbers {
-    kPackageNameFilterFieldNumber = 1,
+  using Decoder = MemoryTrackerSnapshot_Decoder;
+  enum : int32_t {
+    kGlobalDumpIdFieldNumber = 1,
+    kLevelOfDetailFieldNumber = 2,
+    kProcessMemoryDumpsFieldNumber = 3,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.MemoryTrackerSnapshot"; }
 
-  AndroidGameInterventionListConfig();
-  ~AndroidGameInterventionListConfig() override;
-  AndroidGameInterventionListConfig(AndroidGameInterventionListConfig&&) noexcept;
-  AndroidGameInterventionListConfig& operator=(AndroidGameInterventionListConfig&&);
-  AndroidGameInterventionListConfig(const AndroidGameInterventionListConfig&);
-  AndroidGameInterventionListConfig& operator=(const AndroidGameInterventionListConfig&);
-  bool operator==(const AndroidGameInterventionListConfig&) const;
-  bool operator!=(const AndroidGameInterventionListConfig& other) const { return !(*this == other); }
+  using ProcessSnapshot = ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot;
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using LevelOfDetail = ::perfetto::protos::pbzero::MemoryTrackerSnapshot_LevelOfDetail;
+  static inline const char* LevelOfDetail_Name(LevelOfDetail value) {
+    return ::perfetto::protos::pbzero::MemoryTrackerSnapshot_LevelOfDetail_Name(value);
+  }
+  static inline const LevelOfDetail DETAIL_FULL = LevelOfDetail::DETAIL_FULL;
+  static inline const LevelOfDetail DETAIL_LIGHT = LevelOfDetail::DETAIL_LIGHT;
+  static inline const LevelOfDetail DETAIL_BACKGROUND = LevelOfDetail::DETAIL_BACKGROUND;
 
-  const std::vector<std::string>& package_name_filter() const { return package_name_filter_; }
-  std::vector<std::string>* mutable_package_name_filter() { return &package_name_filter_; }
-  int package_name_filter_size() const { return static_cast<int>(package_name_filter_.size()); }
-  void clear_package_name_filter() { package_name_filter_.clear(); }
-  void add_package_name_filter(std::string value) { package_name_filter_.emplace_back(value); }
-  std::string* add_package_name_filter() { package_name_filter_.emplace_back(); return &package_name_filter_.back(); }
+  using FieldMetadata_GlobalDumpId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MemoryTrackerSnapshot>;
 
- private:
-  std::vector<std::string> package_name_filter_;
+  static constexpr FieldMetadata_GlobalDumpId kGlobalDumpId{};
+  void set_global_dump_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GlobalDumpId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_LevelOfDetail =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      MemoryTrackerSnapshot_LevelOfDetail,
+      MemoryTrackerSnapshot>;
+
+  static constexpr FieldMetadata_LevelOfDetail kLevelOfDetail{};
+  void set_level_of_detail(MemoryTrackerSnapshot_LevelOfDetail value) {
+    static constexpr uint32_t field_id = FieldMetadata_LevelOfDetail::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ProcessMemoryDumps =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MemoryTrackerSnapshot_ProcessSnapshot,
+      MemoryTrackerSnapshot>;
+
+  static constexpr FieldMetadata_ProcessMemoryDumps kProcessMemoryDumps{};
+  template <typename T = MemoryTrackerSnapshot_ProcessSnapshot> T* add_process_memory_dumps() {
+    return BeginNestedMessage<T>(3);
+  }
 
-  std::bitset<2> _has_field_{};
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+class MemoryTrackerSnapshot_ProcessSnapshot_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
+ public:
+  MemoryTrackerSnapshot_ProcessSnapshot_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MemoryTrackerSnapshot_ProcessSnapshot_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MemoryTrackerSnapshot_ProcessSnapshot_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  int32_t pid() const { return at<1>().as_int32(); }
+  bool has_allocator_dumps() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> allocator_dumps() const { return GetRepeated<::protozero::ConstBytes>(2); }
+  bool has_memory_edges() const { return at<3>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> memory_edges() const { return GetRepeated<::protozero::ConstBytes>(3); }
+};
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_GAME_INTERVENTION_LIST_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_log_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_LOG_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_LOG_CONFIG_PROTO_CPP_H_
+class MemoryTrackerSnapshot_ProcessSnapshot : public ::protozero::Message {
+ public:
+  using Decoder = MemoryTrackerSnapshot_ProcessSnapshot_Decoder;
+  enum : int32_t {
+    kPidFieldNumber = 1,
+    kAllocatorDumpsFieldNumber = 2,
+    kMemoryEdgesFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.MemoryTrackerSnapshot.ProcessSnapshot"; }
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  using MemoryNode = ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode;
+  using MemoryEdge = ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  using FieldMetadata_Pid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      MemoryTrackerSnapshot_ProcessSnapshot>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class AndroidLogConfig;
-enum AndroidLogId : int;
-enum AndroidLogPriority : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  using FieldMetadata_AllocatorDumps =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode,
+      MemoryTrackerSnapshot_ProcessSnapshot>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+  static constexpr FieldMetadata_AllocatorDumps kAllocatorDumps{};
+  template <typename T = MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode> T* add_allocator_dumps() {
+    return BeginNestedMessage<T>(2);
+  }
 
-class PERFETTO_EXPORT_COMPONENT AndroidLogConfig : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kLogIdsFieldNumber = 1,
-    kMinPrioFieldNumber = 3,
-    kFilterTagsFieldNumber = 4,
-  };
 
-  AndroidLogConfig();
-  ~AndroidLogConfig() override;
-  AndroidLogConfig(AndroidLogConfig&&) noexcept;
-  AndroidLogConfig& operator=(AndroidLogConfig&&);
-  AndroidLogConfig(const AndroidLogConfig&);
-  AndroidLogConfig& operator=(const AndroidLogConfig&);
-  bool operator==(const AndroidLogConfig&) const;
-  bool operator!=(const AndroidLogConfig& other) const { return !(*this == other); }
+  using FieldMetadata_MemoryEdges =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge,
+      MemoryTrackerSnapshot_ProcessSnapshot>;
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  static constexpr FieldMetadata_MemoryEdges kMemoryEdges{};
+  template <typename T = MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge> T* add_memory_edges() {
+    return BeginNestedMessage<T>(3);
+  }
 
-  const std::vector<AndroidLogId>& log_ids() const { return log_ids_; }
-  std::vector<AndroidLogId>* mutable_log_ids() { return &log_ids_; }
-  int log_ids_size() const { return static_cast<int>(log_ids_.size()); }
-  void clear_log_ids() { log_ids_.clear(); }
-  void add_log_ids(AndroidLogId value) { log_ids_.emplace_back(value); }
-  AndroidLogId* add_log_ids() { log_ids_.emplace_back(); return &log_ids_.back(); }
+};
 
-  bool has_min_prio() const { return _has_field_[3]; }
-  AndroidLogPriority min_prio() const { return min_prio_; }
-  void set_min_prio(AndroidLogPriority value) { min_prio_ = value; _has_field_.set(3); }
+class MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_source_id() const { return at<1>().valid(); }
+  uint64_t source_id() const { return at<1>().as_uint64(); }
+  bool has_target_id() const { return at<2>().valid(); }
+  uint64_t target_id() const { return at<2>().as_uint64(); }
+  bool has_importance() const { return at<3>().valid(); }
+  uint32_t importance() const { return at<3>().as_uint32(); }
+  bool has_overridable() const { return at<4>().valid(); }
+  bool overridable() const { return at<4>().as_bool(); }
+};
 
-  const std::vector<std::string>& filter_tags() const { return filter_tags_; }
-  std::vector<std::string>* mutable_filter_tags() { return &filter_tags_; }
-  int filter_tags_size() const { return static_cast<int>(filter_tags_.size()); }
-  void clear_filter_tags() { filter_tags_.clear(); }
-  void add_filter_tags(std::string value) { filter_tags_.emplace_back(value); }
-  std::string* add_filter_tags() { filter_tags_.emplace_back(); return &filter_tags_.back(); }
+class MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge : public ::protozero::Message {
+ public:
+  using Decoder = MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge_Decoder;
+  enum : int32_t {
+    kSourceIdFieldNumber = 1,
+    kTargetIdFieldNumber = 2,
+    kImportanceFieldNumber = 3,
+    kOverridableFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.MemoryTrackerSnapshot.ProcessSnapshot.MemoryEdge"; }
 
- private:
-  std::vector<AndroidLogId> log_ids_;
-  AndroidLogPriority min_prio_{};
-  std::vector<std::string> filter_tags_;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_SourceId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge>;
 
-  std::bitset<5> _has_field_{};
-};
+  static constexpr FieldMetadata_SourceId kSourceId{};
+  void set_source_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SourceId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  using FieldMetadata_TargetId =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge>;
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_LOG_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_polled_state_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_POLLED_STATE_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_POLLED_STATE_CONFIG_PROTO_CPP_H_
+  static constexpr FieldMetadata_TargetId kTargetId{};
+  void set_target_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TargetId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  using FieldMetadata_Importance =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge>;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  static constexpr FieldMetadata_Importance kImportance{};
+  void set_importance(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Importance::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class AndroidPolledStateConfig;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  using FieldMetadata_Overridable =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge>;
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  static constexpr FieldMetadata_Overridable kOverridable{};
+  void set_overridable(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_Overridable::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
+};
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+class MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
+ public:
+  MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_id() const { return at<1>().valid(); }
+  uint64_t id() const { return at<1>().as_uint64(); }
+  bool has_absolute_name() const { return at<2>().valid(); }
+  ::protozero::ConstChars absolute_name() const { return at<2>().as_string(); }
+  bool has_weak() const { return at<3>().valid(); }
+  bool weak() const { return at<3>().as_bool(); }
+  bool has_size_bytes() const { return at<4>().valid(); }
+  uint64_t size_bytes() const { return at<4>().as_uint64(); }
+  bool has_entries() const { return at<5>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> entries() const { return GetRepeated<::protozero::ConstBytes>(5); }
+};
 
-class PERFETTO_EXPORT_COMPONENT AndroidPolledStateConfig : public ::protozero::CppMessageObj {
+class MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode : public ::protozero::Message {
  public:
-  enum FieldNumbers {
-    kPollMsFieldNumber = 1,
+  using Decoder = MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_Decoder;
+  enum : int32_t {
+    kIdFieldNumber = 1,
+    kAbsoluteNameFieldNumber = 2,
+    kWeakFieldNumber = 3,
+    kSizeBytesFieldNumber = 4,
+    kEntriesFieldNumber = 5,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.MemoryTrackerSnapshot.ProcessSnapshot.MemoryNode"; }
 
-  AndroidPolledStateConfig();
-  ~AndroidPolledStateConfig() override;
-  AndroidPolledStateConfig(AndroidPolledStateConfig&&) noexcept;
-  AndroidPolledStateConfig& operator=(AndroidPolledStateConfig&&);
-  AndroidPolledStateConfig(const AndroidPolledStateConfig&);
-  AndroidPolledStateConfig& operator=(const AndroidPolledStateConfig&);
-  bool operator==(const AndroidPolledStateConfig&) const;
-  bool operator!=(const AndroidPolledStateConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using MemoryNodeEntry = ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry;
 
-  bool has_poll_ms() const { return _has_field_[1]; }
-  uint32_t poll_ms() const { return poll_ms_; }
-  void set_poll_ms(uint32_t value) { poll_ms_ = value; _has_field_.set(1); }
+  using FieldMetadata_Id =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode>;
 
- private:
-  uint32_t poll_ms_{};
+  static constexpr FieldMetadata_Id kId{};
+  void set_id(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_AbsoluteName =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode>;
 
-  std::bitset<2> _has_field_{};
-};
+  static constexpr FieldMetadata_AbsoluteName kAbsoluteName{};
+  void set_absolute_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_AbsoluteName::kFieldId, data, size);
+  }
+  void set_absolute_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_AbsoluteName::kFieldId, chars.data, chars.size);
+  }
+  void set_absolute_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_AbsoluteName::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  using FieldMetadata_Weak =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode>;
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_POLLED_STATE_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_system_property_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_SYSTEM_PROPERTY_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_SYSTEM_PROPERTY_CONFIG_PROTO_CPP_H_
+  static constexpr FieldMetadata_Weak kWeak{};
+  void set_weak(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_Weak::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBool>
+        ::Append(*this, field_id, value);
+  }
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  using FieldMetadata_SizeBytes =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode>;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  static constexpr FieldMetadata_SizeBytes kSizeBytes{};
+  void set_size_bytes(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SizeBytes::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class AndroidSystemPropertyConfig;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  using FieldMetadata_Entries =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry,
+      MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode>;
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  static constexpr FieldMetadata_Entries kEntries{};
+  template <typename T = MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry> T* add_entries() {
+    return BeginNestedMessage<T>(5);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+};
 
-class PERFETTO_EXPORT_COMPONENT AndroidSystemPropertyConfig : public ::protozero::CppMessageObj {
+class MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  enum FieldNumbers {
-    kPollMsFieldNumber = 1,
-    kPropertyNameFieldNumber = 2,
+  MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_name() const { return at<1>().valid(); }
+  ::protozero::ConstChars name() const { return at<1>().as_string(); }
+  bool has_units() const { return at<2>().valid(); }
+  int32_t units() const { return at<2>().as_int32(); }
+  bool has_value_uint64() const { return at<3>().valid(); }
+  uint64_t value_uint64() const { return at<3>().as_uint64(); }
+  bool has_value_string() const { return at<4>().valid(); }
+  ::protozero::ConstChars value_string() const { return at<4>().as_string(); }
+};
+
+class MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry : public ::protozero::Message {
+ public:
+  using Decoder = MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kUnitsFieldNumber = 2,
+    kValueUint64FieldNumber = 3,
+    kValueStringFieldNumber = 4,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.MemoryTrackerSnapshot.ProcessSnapshot.MemoryNode.MemoryNodeEntry"; }
 
-  AndroidSystemPropertyConfig();
-  ~AndroidSystemPropertyConfig() override;
-  AndroidSystemPropertyConfig(AndroidSystemPropertyConfig&&) noexcept;
-  AndroidSystemPropertyConfig& operator=(AndroidSystemPropertyConfig&&);
-  AndroidSystemPropertyConfig(const AndroidSystemPropertyConfig&);
-  AndroidSystemPropertyConfig& operator=(const AndroidSystemPropertyConfig&);
-  bool operator==(const AndroidSystemPropertyConfig&) const;
-  bool operator!=(const AndroidSystemPropertyConfig& other) const { return !(*this == other); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using Units = ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units;
+  static inline const char* Units_Name(Units value) {
+    return ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units_Name(value);
+  }
+  static inline const Units UNSPECIFIED = Units::UNSPECIFIED;
+  static inline const Units BYTES = Units::BYTES;
+  static inline const Units COUNT = Units::COUNT;
 
-  bool has_poll_ms() const { return _has_field_[1]; }
-  uint32_t poll_ms() const { return poll_ms_; }
-  void set_poll_ms(uint32_t value) { poll_ms_ = value; _has_field_.set(1); }
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry>;
 
-  const std::vector<std::string>& property_name() const { return property_name_; }
-  std::vector<std::string>* mutable_property_name() { return &property_name_; }
-  int property_name_size() const { return static_cast<int>(property_name_.size()); }
-  void clear_property_name() { property_name_.clear(); }
-  void add_property_name(std::string value) { property_name_.emplace_back(value); }
-  std::string* add_property_name() { property_name_.emplace_back(); return &property_name_.back(); }
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
- private:
-  uint32_t poll_ms_{};
-  std::vector<std::string> property_name_;
+  using FieldMetadata_Units =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units,
+      MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry>;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  static constexpr FieldMetadata_Units kUnits{};
+  void set_units(MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units value) {
+    static constexpr uint32_t field_id = FieldMetadata_Units::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kEnum>
+        ::Append(*this, field_id, value);
+  }
 
-  std::bitset<3> _has_field_{};
+  using FieldMetadata_ValueUint64 =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry>;
+
+  static constexpr FieldMetadata_ValueUint64 kValueUint64{};
+  void set_value_uint64(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ValueUint64::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_ValueString =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry>;
+
+  static constexpr FieldMetadata_ValueString kValueString{};
+  void set_value_string(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_ValueString::kFieldId, data, size);
+  }
+  void set_value_string(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_ValueString::kFieldId, chars.data, chars.size);
+  }
+  void set_value_string(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_ValueString::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ui_state.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_SYSTEM_PROPERTY_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/android/network_trace_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_NETWORK_TRACE_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_NETWORK_TRACE_CONFIG_PROTO_CPP_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_UI_STATE_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_UI_STATE_PROTO_H_
 
+#include <stddef.h>
 #include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
 namespace perfetto {
 namespace protos {
-namespace gen {
-class NetworkPacketTraceConfig;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
+namespace pbzero {
+class UiState_HighlightProcess;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
 namespace perfetto {
 namespace protos {
-namespace gen {
+namespace pbzero {
 
-class PERFETTO_EXPORT_COMPONENT NetworkPacketTraceConfig : public ::protozero::CppMessageObj {
+class UiState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3> {
  public:
-  enum FieldNumbers {
-    kPollMsFieldNumber = 1,
-  };
-
-  NetworkPacketTraceConfig();
-  ~NetworkPacketTraceConfig() override;
-  NetworkPacketTraceConfig(NetworkPacketTraceConfig&&) noexcept;
-  NetworkPacketTraceConfig& operator=(NetworkPacketTraceConfig&&);
-  NetworkPacketTraceConfig(const NetworkPacketTraceConfig&);
-  NetworkPacketTraceConfig& operator=(const NetworkPacketTraceConfig&);
-  bool operator==(const NetworkPacketTraceConfig&) const;
-  bool operator!=(const NetworkPacketTraceConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_poll_ms() const { return _has_field_[1]; }
-  uint32_t poll_ms() const { return poll_ms_; }
-  void set_poll_ms(uint32_t value) { poll_ms_ = value; _has_field_.set(1); }
+  UiState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit UiState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit UiState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_timeline_start_ts() const { return at<1>().valid(); }
+  int64_t timeline_start_ts() const { return at<1>().as_int64(); }
+  bool has_timeline_end_ts() const { return at<2>().valid(); }
+  int64_t timeline_end_ts() const { return at<2>().as_int64(); }
+  bool has_highlight_process() const { return at<3>().valid(); }
+  ::protozero::ConstBytes highlight_process() const { return at<3>().as_bytes(); }
+};
 
- private:
-  uint32_t poll_ms_{};
+class UiState : public ::protozero::Message {
+ public:
+  using Decoder = UiState_Decoder;
+  enum : int32_t {
+    kTimelineStartTsFieldNumber = 1,
+    kTimelineEndTsFieldNumber = 2,
+    kHighlightProcessFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.UiState"; }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using HighlightProcess = ::perfetto::protos::pbzero::UiState_HighlightProcess;
 
-  std::bitset<2> _has_field_{};
-};
+  using FieldMetadata_TimelineStartTs =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      UiState>;
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  static constexpr FieldMetadata_TimelineStartTs kTimelineStartTs{};
+  void set_timeline_start_ts(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimelineStartTs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_NETWORK_TRACE_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/android/packages_list_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PACKAGES_LIST_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PACKAGES_LIST_CONFIG_PROTO_CPP_H_
+  using FieldMetadata_TimelineEndTs =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      UiState>;
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  static constexpr FieldMetadata_TimelineEndTs kTimelineEndTs{};
+  void set_timeline_end_ts(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TimelineEndTs::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt64>
+        ::Append(*this, field_id, value);
+  }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  using FieldMetadata_HighlightProcess =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      UiState_HighlightProcess,
+      UiState>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class PackagesListConfig;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  static constexpr FieldMetadata_HighlightProcess kHighlightProcess{};
+  template <typename T = UiState_HighlightProcess> T* set_highlight_process() {
+    return BeginNestedMessage<T>(3);
+  }
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+};
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+class UiState_HighlightProcess_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  UiState_HighlightProcess_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit UiState_HighlightProcess_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit UiState_HighlightProcess_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_pid() const { return at<1>().valid(); }
+  uint32_t pid() const { return at<1>().as_uint32(); }
+  bool has_cmdline() const { return at<2>().valid(); }
+  ::protozero::ConstChars cmdline() const { return at<2>().as_string(); }
+};
 
-class PERFETTO_EXPORT_COMPONENT PackagesListConfig : public ::protozero::CppMessageObj {
+class UiState_HighlightProcess : public ::protozero::Message {
  public:
-  enum FieldNumbers {
-    kPackageNameFilterFieldNumber = 1,
+  using Decoder = UiState_HighlightProcess_Decoder;
+  enum : int32_t {
+    kPidFieldNumber = 1,
+    kCmdlineFieldNumber = 2,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.UiState.HighlightProcess"; }
 
-  PackagesListConfig();
-  ~PackagesListConfig() override;
-  PackagesListConfig(PackagesListConfig&&) noexcept;
-  PackagesListConfig& operator=(PackagesListConfig&&);
-  PackagesListConfig(const PackagesListConfig&);
-  PackagesListConfig& operator=(const PackagesListConfig&);
-  bool operator==(const PackagesListConfig&) const;
-  bool operator!=(const PackagesListConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
 
-  const std::vector<std::string>& package_name_filter() const { return package_name_filter_; }
-  std::vector<std::string>* mutable_package_name_filter() { return &package_name_filter_; }
-  int package_name_filter_size() const { return static_cast<int>(package_name_filter_.size()); }
-  void clear_package_name_filter() { package_name_filter_.clear(); }
-  void add_package_name_filter(std::string value) { package_name_filter_.emplace_back(value); }
-  std::string* add_package_name_filter() { package_name_filter_.emplace_back(); return &package_name_filter_.back(); }
+  using FieldMetadata_Pid =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      UiState_HighlightProcess>;
 
- private:
-  std::vector<std::string> package_name_filter_;
+  static constexpr FieldMetadata_Pid kPid{};
+  void set_pid(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_Cmdline =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      UiState_HighlightProcess>;
 
-  std::bitset<2> _has_field_{};
+  static constexpr FieldMetadata_Cmdline kCmdline{};
+  void set_cmdline(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Cmdline::kFieldId, data, size);
+  }
+  void set_cmdline(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Cmdline::kFieldId, chars.data, chars.size);
+  }
+  void set_cmdline(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cmdline::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/evdev.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PACKAGES_LIST_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/ftrace/ftrace_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_FTRACE_FTRACE_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_FTRACE_FTRACE_CONFIG_PROTO_CPP_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_EVDEV_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_EVDEV_PROTO_H_
 
+#include <stddef.h>
 #include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
 
 namespace perfetto {
 namespace protos {
-namespace gen {
-class FtraceConfig;
-class FtraceConfig_PrintFilter;
-class FtraceConfig_PrintFilter_Rule;
-class FtraceConfig_PrintFilter_Rule_AtraceMessage;
-class FtraceConfig_CompactSchedConfig;
-enum FtraceConfig_KsymsMemPolicy : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
+namespace pbzero {
+class EvdevDevice;
+class EvdevDevice_AbsInfo;
+class EvdevDevice_AbsMtStatesEntry;
+class EvdevDevice_AbsoluteAxisInfosEntry;
+class EvdevDevice_AxisMap;
+class EvdevDevice_AxisMap_AxisStatesEntry;
+class EvdevDevice_AxisStatesEntry;
+class EvdevDevice_EventTypeBitmasksEntry;
+class EvdevDevice_Identifier;
+class EvdevDevice_SlotValuesMap;
+class EvdevDevice_SlotValuesMap_SlotValuesEntry;
+class EvdevEvent_DeviceAddition;
+class EvdevEvent_DeviceRemoval;
+class EvdevEvent_InputEvent;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
 
 namespace perfetto {
 namespace protos {
-namespace gen {
-enum FtraceConfig_KsymsMemPolicy : int {
-  FtraceConfig_KsymsMemPolicy_KSYMS_UNSPECIFIED = 0,
-  FtraceConfig_KsymsMemPolicy_KSYMS_CLEANUP_ON_STOP = 1,
-  FtraceConfig_KsymsMemPolicy_KSYMS_RETAIN = 2,
-};
+namespace pbzero {
 
-class PERFETTO_EXPORT_COMPONENT FtraceConfig : public ::protozero::CppMessageObj {
+class EvdevDevice_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/12> {
  public:
-  using CompactSchedConfig = FtraceConfig_CompactSchedConfig;
-  using PrintFilter = FtraceConfig_PrintFilter;
-  using KsymsMemPolicy = FtraceConfig_KsymsMemPolicy;
-  static constexpr auto KSYMS_UNSPECIFIED = FtraceConfig_KsymsMemPolicy_KSYMS_UNSPECIFIED;
-  static constexpr auto KSYMS_CLEANUP_ON_STOP = FtraceConfig_KsymsMemPolicy_KSYMS_CLEANUP_ON_STOP;
-  static constexpr auto KSYMS_RETAIN = FtraceConfig_KsymsMemPolicy_KSYMS_RETAIN;
-  static constexpr auto KsymsMemPolicy_MIN = FtraceConfig_KsymsMemPolicy_KSYMS_UNSPECIFIED;
-  static constexpr auto KsymsMemPolicy_MAX = FtraceConfig_KsymsMemPolicy_KSYMS_RETAIN;
-  enum FieldNumbers {
-    kFtraceEventsFieldNumber = 1,
-    kAtraceCategoriesFieldNumber = 2,
-    kAtraceAppsFieldNumber = 3,
-    kBufferSizeKbFieldNumber = 10,
-    kDrainPeriodMsFieldNumber = 11,
-    kCompactSchedFieldNumber = 12,
-    kPrintFilterFieldNumber = 22,
-    kSymbolizeKsymsFieldNumber = 13,
-    kKsymsMemPolicyFieldNumber = 17,
-    kInitializeKsymsSynchronouslyForTestingFieldNumber = 14,
-    kThrottleRssStatFieldNumber = 15,
-    kDisableGenericEventsFieldNumber = 16,
-    kSyscallEventsFieldNumber = 18,
-    kEnableFunctionGraphFieldNumber = 19,
-    kFunctionFiltersFieldNumber = 20,
-    kFunctionGraphRootsFieldNumber = 21,
-    kPreserveFtraceBufferFieldNumber = 23,
-    kUseMonotonicRawClockFieldNumber = 24,
+  EvdevDevice_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit EvdevDevice_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit EvdevDevice_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_device_id() const { return at<1>().valid(); }
+  uint32_t device_id() const { return at<1>().as_uint32(); }
+  bool has_device_num() const { return at<2>().valid(); }
+  uint32_t device_num() const { return at<2>().as_uint32(); }
+  bool has_name() const { return at<3>().valid(); }
+  ::protozero::ConstChars name() const { return at<3>().as_string(); }
+  bool has_phys() const { return at<4>().valid(); }
+  ::protozero::ConstChars phys() const { return at<4>().as_string(); }
+  bool has_uniq() const { return at<5>().valid(); }
+  ::protozero::ConstChars uniq() const { return at<5>().as_string(); }
+  bool has_id() const { return at<6>().valid(); }
+  ::protozero::ConstBytes id() const { return at<6>().as_bytes(); }
+  bool has_absolute_axis_infos() const { return at<7>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> absolute_axis_infos() const { return GetRepeated<::protozero::ConstBytes>(7); }
+  bool has_ev_bitmask() const { return at<8>().valid(); }
+  ::protozero::ConstBytes ev_bitmask() const { return at<8>().as_bytes(); }
+  bool has_event_type_bitmasks() const { return at<9>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> event_type_bitmasks() const { return GetRepeated<::protozero::ConstBytes>(9); }
+  bool has_prop_bitmask() const { return at<10>().valid(); }
+  ::protozero::ConstBytes prop_bitmask() const { return at<10>().as_bytes(); }
+  bool has_axis_states() const { return at<11>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> axis_states() const { return GetRepeated<::protozero::ConstBytes>(11); }
+  bool has_abs_mt_states() const { return at<12>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> abs_mt_states() const { return GetRepeated<::protozero::ConstBytes>(12); }
+};
+
+class EvdevDevice : public ::protozero::Message {
+ public:
+  using Decoder = EvdevDevice_Decoder;
+  enum : int32_t {
+    kDeviceIdFieldNumber = 1,
+    kDeviceNumFieldNumber = 2,
+    kNameFieldNumber = 3,
+    kPhysFieldNumber = 4,
+    kUniqFieldNumber = 5,
+    kIdFieldNumber = 6,
+    kAbsoluteAxisInfosFieldNumber = 7,
+    kEvBitmaskFieldNumber = 8,
+    kEventTypeBitmasksFieldNumber = 9,
+    kPropBitmaskFieldNumber = 10,
+    kAxisStatesFieldNumber = 11,
+    kAbsMtStatesFieldNumber = 12,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.EvdevDevice"; }
 
-  FtraceConfig();
-  ~FtraceConfig() override;
-  FtraceConfig(FtraceConfig&&) noexcept;
-  FtraceConfig& operator=(FtraceConfig&&);
-  FtraceConfig(const FtraceConfig&);
-  FtraceConfig& operator=(const FtraceConfig&);
-  bool operator==(const FtraceConfig&) const;
-  bool operator!=(const FtraceConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using Identifier = ::perfetto::protos::pbzero::EvdevDevice_Identifier;
+  using AbsInfo = ::perfetto::protos::pbzero::EvdevDevice_AbsInfo;
+  using AbsoluteAxisInfosEntry = ::perfetto::protos::pbzero::EvdevDevice_AbsoluteAxisInfosEntry;
+  using EventTypeBitmasksEntry = ::perfetto::protos::pbzero::EvdevDevice_EventTypeBitmasksEntry;
+  using AxisMap = ::perfetto::protos::pbzero::EvdevDevice_AxisMap;
+  using AxisStatesEntry = ::perfetto::protos::pbzero::EvdevDevice_AxisStatesEntry;
+  using SlotValuesMap = ::perfetto::protos::pbzero::EvdevDevice_SlotValuesMap;
+  using AbsMtStatesEntry = ::perfetto::protos::pbzero::EvdevDevice_AbsMtStatesEntry;
 
-  const std::vector<std::string>& ftrace_events() const { return ftrace_events_; }
-  std::vector<std::string>* mutable_ftrace_events() { return &ftrace_events_; }
-  int ftrace_events_size() const { return static_cast<int>(ftrace_events_.size()); }
-  void clear_ftrace_events() { ftrace_events_.clear(); }
-  void add_ftrace_events(std::string value) { ftrace_events_.emplace_back(value); }
-  std::string* add_ftrace_events() { ftrace_events_.emplace_back(); return &ftrace_events_.back(); }
+  using FieldMetadata_DeviceId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      EvdevDevice>;
 
-  const std::vector<std::string>& atrace_categories() const { return atrace_categories_; }
-  std::vector<std::string>* mutable_atrace_categories() { return &atrace_categories_; }
-  int atrace_categories_size() const { return static_cast<int>(atrace_categories_.size()); }
-  void clear_atrace_categories() { atrace_categories_.clear(); }
-  void add_atrace_categories(std::string value) { atrace_categories_.emplace_back(value); }
-  std::string* add_atrace_categories() { atrace_categories_.emplace_back(); return &atrace_categories_.back(); }
+  static constexpr FieldMetadata_DeviceId kDeviceId{};
+  void set_device_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DeviceId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  const std::vector<std::string>& atrace_apps() const { return atrace_apps_; }
-  std::vector<std::string>* mutable_atrace_apps() { return &atrace_apps_; }
-  int atrace_apps_size() const { return static_cast<int>(atrace_apps_.size()); }
-  void clear_atrace_apps() { atrace_apps_.clear(); }
-  void add_atrace_apps(std::string value) { atrace_apps_.emplace_back(value); }
-  std::string* add_atrace_apps() { atrace_apps_.emplace_back(); return &atrace_apps_.back(); }
+  using FieldMetadata_DeviceNum =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      EvdevDevice>;
 
-  bool has_buffer_size_kb() const { return _has_field_[10]; }
-  uint32_t buffer_size_kb() const { return buffer_size_kb_; }
-  void set_buffer_size_kb(uint32_t value) { buffer_size_kb_ = value; _has_field_.set(10); }
+  static constexpr FieldMetadata_DeviceNum kDeviceNum{};
+  void set_device_num(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DeviceNum::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_drain_period_ms() const { return _has_field_[11]; }
-  uint32_t drain_period_ms() const { return drain_period_ms_; }
-  void set_drain_period_ms(uint32_t value) { drain_period_ms_ = value; _has_field_.set(11); }
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      EvdevDevice>;
 
-  bool has_compact_sched() const { return _has_field_[12]; }
-  const FtraceConfig_CompactSchedConfig& compact_sched() const { return *compact_sched_; }
-  FtraceConfig_CompactSchedConfig* mutable_compact_sched() { _has_field_.set(12); return compact_sched_.get(); }
+  static constexpr FieldMetadata_Name kName{};
+  void set_name(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Name::kFieldId, data, size);
+  }
+  void set_name(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
+  }
+  void set_name(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_print_filter() const { return _has_field_[22]; }
-  const FtraceConfig_PrintFilter& print_filter() const { return *print_filter_; }
-  FtraceConfig_PrintFilter* mutable_print_filter() { _has_field_.set(22); return print_filter_.get(); }
+  using FieldMetadata_Phys =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      EvdevDevice>;
 
-  bool has_symbolize_ksyms() const { return _has_field_[13]; }
-  bool symbolize_ksyms() const { return symbolize_ksyms_; }
-  void set_symbolize_ksyms(bool value) { symbolize_ksyms_ = value; _has_field_.set(13); }
+  static constexpr FieldMetadata_Phys kPhys{};
+  void set_phys(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Phys::kFieldId, data, size);
+  }
+  void set_phys(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Phys::kFieldId, chars.data, chars.size);
+  }
+  void set_phys(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Phys::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_ksyms_mem_policy() const { return _has_field_[17]; }
-  FtraceConfig_KsymsMemPolicy ksyms_mem_policy() const { return ksyms_mem_policy_; }
-  void set_ksyms_mem_policy(FtraceConfig_KsymsMemPolicy value) { ksyms_mem_policy_ = value; _has_field_.set(17); }
+  using FieldMetadata_Uniq =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      EvdevDevice>;
 
-  bool has_initialize_ksyms_synchronously_for_testing() const { return _has_field_[14]; }
-  bool initialize_ksyms_synchronously_for_testing() const { return initialize_ksyms_synchronously_for_testing_; }
-  void set_initialize_ksyms_synchronously_for_testing(bool value) { initialize_ksyms_synchronously_for_testing_ = value; _has_field_.set(14); }
+  static constexpr FieldMetadata_Uniq kUniq{};
+  void set_uniq(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Uniq::kFieldId, data, size);
+  }
+  void set_uniq(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Uniq::kFieldId, chars.data, chars.size);
+  }
+  void set_uniq(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Uniq::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kString>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_throttle_rss_stat() const { return _has_field_[15]; }
-  bool throttle_rss_stat() const { return throttle_rss_stat_; }
-  void set_throttle_rss_stat(bool value) { throttle_rss_stat_ = value; _has_field_.set(15); }
+  using FieldMetadata_Id =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      EvdevDevice_Identifier,
+      EvdevDevice>;
 
-  bool has_disable_generic_events() const { return _has_field_[16]; }
-  bool disable_generic_events() const { return disable_generic_events_; }
-  void set_disable_generic_events(bool value) { disable_generic_events_ = value; _has_field_.set(16); }
+  static constexpr FieldMetadata_Id kId{};
+  template <typename T = EvdevDevice_Identifier> T* set_id() {
+    return BeginNestedMessage<T>(6);
+  }
 
-  const std::vector<std::string>& syscall_events() const { return syscall_events_; }
-  std::vector<std::string>* mutable_syscall_events() { return &syscall_events_; }
-  int syscall_events_size() const { return static_cast<int>(syscall_events_.size()); }
-  void clear_syscall_events() { syscall_events_.clear(); }
-  void add_syscall_events(std::string value) { syscall_events_.emplace_back(value); }
-  std::string* add_syscall_events() { syscall_events_.emplace_back(); return &syscall_events_.back(); }
 
-  bool has_enable_function_graph() const { return _has_field_[19]; }
-  bool enable_function_graph() const { return enable_function_graph_; }
-  void set_enable_function_graph(bool value) { enable_function_graph_ = value; _has_field_.set(19); }
+  using FieldMetadata_AbsoluteAxisInfos =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      EvdevDevice_AbsoluteAxisInfosEntry,
+      EvdevDevice>;
 
-  const std::vector<std::string>& function_filters() const { return function_filters_; }
-  std::vector<std::string>* mutable_function_filters() { return &function_filters_; }
-  int function_filters_size() const { return static_cast<int>(function_filters_.size()); }
-  void clear_function_filters() { function_filters_.clear(); }
-  void add_function_filters(std::string value) { function_filters_.emplace_back(value); }
-  std::string* add_function_filters() { function_filters_.emplace_back(); return &function_filters_.back(); }
+  static constexpr FieldMetadata_AbsoluteAxisInfos kAbsoluteAxisInfos{};
+  template <typename T = EvdevDevice_AbsoluteAxisInfosEntry> T* add_absolute_axis_infos() {
+    return BeginNestedMessage<T>(7);
+  }
 
-  const std::vector<std::string>& function_graph_roots() const { return function_graph_roots_; }
-  std::vector<std::string>* mutable_function_graph_roots() { return &function_graph_roots_; }
-  int function_graph_roots_size() const { return static_cast<int>(function_graph_roots_.size()); }
-  void clear_function_graph_roots() { function_graph_roots_.clear(); }
-  void add_function_graph_roots(std::string value) { function_graph_roots_.emplace_back(value); }
-  std::string* add_function_graph_roots() { function_graph_roots_.emplace_back(); return &function_graph_roots_.back(); }
 
-  bool has_preserve_ftrace_buffer() const { return _has_field_[23]; }
-  bool preserve_ftrace_buffer() const { return preserve_ftrace_buffer_; }
-  void set_preserve_ftrace_buffer(bool value) { preserve_ftrace_buffer_ = value; _has_field_.set(23); }
+  using FieldMetadata_EvBitmask =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      EvdevDevice>;
 
-  bool has_use_monotonic_raw_clock() const { return _has_field_[24]; }
-  bool use_monotonic_raw_clock() const { return use_monotonic_raw_clock_; }
-  void set_use_monotonic_raw_clock(bool value) { use_monotonic_raw_clock_ = value; _has_field_.set(24); }
+  static constexpr FieldMetadata_EvBitmask kEvBitmask{};
+  void set_ev_bitmask(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_EvBitmask::kFieldId, data, size);
+  }
+  void set_ev_bitmask(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_EvBitmask::kFieldId, bytes.data, bytes.size);
+  }
+  void set_ev_bitmask(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_EvBitmask::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
 
- private:
-  std::vector<std::string> ftrace_events_;
-  std::vector<std::string> atrace_categories_;
-  std::vector<std::string> atrace_apps_;
-  uint32_t buffer_size_kb_{};
-  uint32_t drain_period_ms_{};
-  ::protozero::CopyablePtr<FtraceConfig_CompactSchedConfig> compact_sched_;
-  ::protozero::CopyablePtr<FtraceConfig_PrintFilter> print_filter_;
-  bool symbolize_ksyms_{};
-  FtraceConfig_KsymsMemPolicy ksyms_mem_policy_{};
-  bool initialize_ksyms_synchronously_for_testing_{};
-  bool throttle_rss_stat_{};
-  bool disable_generic_events_{};
-  std::vector<std::string> syscall_events_;
-  bool enable_function_graph_{};
-  std::vector<std::string> function_filters_;
-  std::vector<std::string> function_graph_roots_;
-  bool preserve_ftrace_buffer_{};
-  bool use_monotonic_raw_clock_{};
+  using FieldMetadata_EventTypeBitmasks =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      EvdevDevice_EventTypeBitmasksEntry,
+      EvdevDevice>;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  static constexpr FieldMetadata_EventTypeBitmasks kEventTypeBitmasks{};
+  template <typename T = EvdevDevice_EventTypeBitmasksEntry> T* add_event_type_bitmasks() {
+    return BeginNestedMessage<T>(9);
+  }
 
-  std::bitset<25> _has_field_{};
-};
 
+  using FieldMetadata_PropBitmask =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      EvdevDevice>;
 
-class PERFETTO_EXPORT_COMPONENT FtraceConfig_PrintFilter : public ::protozero::CppMessageObj {
- public:
-  using Rule = FtraceConfig_PrintFilter_Rule;
-  enum FieldNumbers {
-    kRulesFieldNumber = 1,
-  };
+  static constexpr FieldMetadata_PropBitmask kPropBitmask{};
+  void set_prop_bitmask(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_PropBitmask::kFieldId, data, size);
+  }
+  void set_prop_bitmask(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_PropBitmask::kFieldId, bytes.data, bytes.size);
+  }
+  void set_prop_bitmask(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_PropBitmask::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
 
-  FtraceConfig_PrintFilter();
-  ~FtraceConfig_PrintFilter() override;
-  FtraceConfig_PrintFilter(FtraceConfig_PrintFilter&&) noexcept;
-  FtraceConfig_PrintFilter& operator=(FtraceConfig_PrintFilter&&);
-  FtraceConfig_PrintFilter(const FtraceConfig_PrintFilter&);
-  FtraceConfig_PrintFilter& operator=(const FtraceConfig_PrintFilter&);
-  bool operator==(const FtraceConfig_PrintFilter&) const;
-  bool operator!=(const FtraceConfig_PrintFilter& other) const { return !(*this == other); }
+  using FieldMetadata_AxisStates =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      EvdevDevice_AxisStatesEntry,
+      EvdevDevice>;
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  static constexpr FieldMetadata_AxisStates kAxisStates{};
+  template <typename T = EvdevDevice_AxisStatesEntry> T* add_axis_states() {
+    return BeginNestedMessage<T>(11);
+  }
 
-  const std::vector<FtraceConfig_PrintFilter_Rule>& rules() const { return rules_; }
-  std::vector<FtraceConfig_PrintFilter_Rule>* mutable_rules() { return &rules_; }
-  int rules_size() const;
-  void clear_rules();
-  FtraceConfig_PrintFilter_Rule* add_rules();
 
- private:
-  std::vector<FtraceConfig_PrintFilter_Rule> rules_;
+  using FieldMetadata_AbsMtStates =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      EvdevDevice_AbsMtStatesEntry,
+      EvdevDevice>;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  static constexpr FieldMetadata_AbsMtStates kAbsMtStates{};
+  template <typename T = EvdevDevice_AbsMtStatesEntry> T* add_abs_mt_states() {
+    return BeginNestedMessage<T>(12);
+  }
 
-  std::bitset<2> _has_field_{};
 };
 
+class EvdevDevice_AbsMtStatesEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  EvdevDevice_AbsMtStatesEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit EvdevDevice_AbsMtStatesEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit EvdevDevice_AbsMtStatesEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_key() const { return at<1>().valid(); }
+  uint32_t key() const { return at<1>().as_uint32(); }
+  bool has_value() const { return at<2>().valid(); }
+  ::protozero::ConstBytes value() const { return at<2>().as_bytes(); }
+};
 
-class PERFETTO_EXPORT_COMPONENT FtraceConfig_PrintFilter_Rule : public ::protozero::CppMessageObj {
+class EvdevDevice_AbsMtStatesEntry : public ::protozero::Message {
  public:
-  using AtraceMessage = FtraceConfig_PrintFilter_Rule_AtraceMessage;
-  enum FieldNumbers {
-    kPrefixFieldNumber = 1,
-    kAtraceMsgFieldNumber = 3,
-    kAllowFieldNumber = 2,
+  using Decoder = EvdevDevice_AbsMtStatesEntry_Decoder;
+  enum : int32_t {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.EvdevDevice.AbsMtStatesEntry"; }
 
-  FtraceConfig_PrintFilter_Rule();
-  ~FtraceConfig_PrintFilter_Rule() override;
-  FtraceConfig_PrintFilter_Rule(FtraceConfig_PrintFilter_Rule&&) noexcept;
-  FtraceConfig_PrintFilter_Rule& operator=(FtraceConfig_PrintFilter_Rule&&);
-  FtraceConfig_PrintFilter_Rule(const FtraceConfig_PrintFilter_Rule&);
-  FtraceConfig_PrintFilter_Rule& operator=(const FtraceConfig_PrintFilter_Rule&);
-  bool operator==(const FtraceConfig_PrintFilter_Rule&) const;
-  bool operator!=(const FtraceConfig_PrintFilter_Rule& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_prefix() const { return _has_field_[1]; }
-  const std::string& prefix() const { return prefix_; }
-  void set_prefix(const std::string& value) { prefix_ = value; _has_field_.set(1); }
 
-  bool has_atrace_msg() const { return _has_field_[3]; }
-  const FtraceConfig_PrintFilter_Rule_AtraceMessage& atrace_msg() const { return *atrace_msg_; }
-  FtraceConfig_PrintFilter_Rule_AtraceMessage* mutable_atrace_msg() { _has_field_.set(3); return atrace_msg_.get(); }
+  using FieldMetadata_Key =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      EvdevDevice_AbsMtStatesEntry>;
 
-  bool has_allow() const { return _has_field_[2]; }
-  bool allow() const { return allow_; }
-  void set_allow(bool value) { allow_ = value; _has_field_.set(2); }
+  static constexpr FieldMetadata_Key kKey{};
+  void set_key(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
- private:
-  std::string prefix_{};
-  ::protozero::CopyablePtr<FtraceConfig_PrintFilter_Rule_AtraceMessage> atrace_msg_;
-  bool allow_{};
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      EvdevDevice_SlotValuesMap,
+      EvdevDevice_AbsMtStatesEntry>;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  static constexpr FieldMetadata_Value kValue{};
+  template <typename T = EvdevDevice_SlotValuesMap> T* set_value() {
+    return BeginNestedMessage<T>(2);
+  }
 
-  std::bitset<4> _has_field_{};
 };
 
+class EvdevDevice_SlotValuesMap_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  EvdevDevice_SlotValuesMap_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit EvdevDevice_SlotValuesMap_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit EvdevDevice_SlotValuesMap_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_slot_values() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> slot_values() const { return GetRepeated<::protozero::ConstBytes>(1); }
+};
 
-class PERFETTO_EXPORT_COMPONENT FtraceConfig_PrintFilter_Rule_AtraceMessage : public ::protozero::CppMessageObj {
+class EvdevDevice_SlotValuesMap : public ::protozero::Message {
  public:
-  enum FieldNumbers {
-    kTypeFieldNumber = 1,
-    kPrefixFieldNumber = 2,
+  using Decoder = EvdevDevice_SlotValuesMap_Decoder;
+  enum : int32_t {
+    kSlotValuesFieldNumber = 1,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.EvdevDevice.SlotValuesMap"; }
 
-  FtraceConfig_PrintFilter_Rule_AtraceMessage();
-  ~FtraceConfig_PrintFilter_Rule_AtraceMessage() override;
-  FtraceConfig_PrintFilter_Rule_AtraceMessage(FtraceConfig_PrintFilter_Rule_AtraceMessage&&) noexcept;
-  FtraceConfig_PrintFilter_Rule_AtraceMessage& operator=(FtraceConfig_PrintFilter_Rule_AtraceMessage&&);
-  FtraceConfig_PrintFilter_Rule_AtraceMessage(const FtraceConfig_PrintFilter_Rule_AtraceMessage&);
-  FtraceConfig_PrintFilter_Rule_AtraceMessage& operator=(const FtraceConfig_PrintFilter_Rule_AtraceMessage&);
-  bool operator==(const FtraceConfig_PrintFilter_Rule_AtraceMessage&) const;
-  bool operator!=(const FtraceConfig_PrintFilter_Rule_AtraceMessage& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_type() const { return _has_field_[1]; }
-  const std::string& type() const { return type_; }
-  void set_type(const std::string& value) { type_ = value; _has_field_.set(1); }
-
-  bool has_prefix() const { return _has_field_[2]; }
-  const std::string& prefix() const { return prefix_; }
-  void set_prefix(const std::string& value) { prefix_ = value; _has_field_.set(2); }
+  using SlotValuesEntry = ::perfetto::protos::pbzero::EvdevDevice_SlotValuesMap_SlotValuesEntry;
 
- private:
-  std::string type_{};
-  std::string prefix_{};
+  using FieldMetadata_SlotValues =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      EvdevDevice_SlotValuesMap_SlotValuesEntry,
+      EvdevDevice_SlotValuesMap>;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  static constexpr FieldMetadata_SlotValues kSlotValues{};
+  template <typename T = EvdevDevice_SlotValuesMap_SlotValuesEntry> T* add_slot_values() {
+    return BeginNestedMessage<T>(1);
+  }
 
-  std::bitset<3> _has_field_{};
 };
 
+class EvdevDevice_SlotValuesMap_SlotValuesEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  EvdevDevice_SlotValuesMap_SlotValuesEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit EvdevDevice_SlotValuesMap_SlotValuesEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit EvdevDevice_SlotValuesMap_SlotValuesEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_key() const { return at<1>().valid(); }
+  uint32_t key() const { return at<1>().as_uint32(); }
+  bool has_value() const { return at<2>().valid(); }
+  int32_t value() const { return at<2>().as_sint32(); }
+};
 
-class PERFETTO_EXPORT_COMPONENT FtraceConfig_CompactSchedConfig : public ::protozero::CppMessageObj {
+class EvdevDevice_SlotValuesMap_SlotValuesEntry : public ::protozero::Message {
  public:
-  enum FieldNumbers {
-    kEnabledFieldNumber = 1,
+  using Decoder = EvdevDevice_SlotValuesMap_SlotValuesEntry_Decoder;
+  enum : int32_t {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.EvdevDevice.SlotValuesMap.SlotValuesEntry"; }
 
-  FtraceConfig_CompactSchedConfig();
-  ~FtraceConfig_CompactSchedConfig() override;
-  FtraceConfig_CompactSchedConfig(FtraceConfig_CompactSchedConfig&&) noexcept;
-  FtraceConfig_CompactSchedConfig& operator=(FtraceConfig_CompactSchedConfig&&);
-  FtraceConfig_CompactSchedConfig(const FtraceConfig_CompactSchedConfig&);
-  FtraceConfig_CompactSchedConfig& operator=(const FtraceConfig_CompactSchedConfig&);
-  bool operator==(const FtraceConfig_CompactSchedConfig&) const;
-  bool operator!=(const FtraceConfig_CompactSchedConfig& other) const { return !(*this == other); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_Key =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      EvdevDevice_SlotValuesMap_SlotValuesEntry>;
 
-  bool has_enabled() const { return _has_field_[1]; }
-  bool enabled() const { return enabled_; }
-  void set_enabled(bool value) { enabled_ = value; _has_field_.set(1); }
+  static constexpr FieldMetadata_Key kKey{};
+  void set_key(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
- private:
-  bool enabled_{};
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kSint32,
+      int32_t,
+      EvdevDevice_SlotValuesMap_SlotValuesEntry>;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kSint32>
+        ::Append(*this, field_id, value);
+  }
+};
 
-  std::bitset<2> _has_field_{};
+class EvdevDevice_AxisStatesEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  EvdevDevice_AxisStatesEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit EvdevDevice_AxisStatesEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit EvdevDevice_AxisStatesEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_key() const { return at<1>().valid(); }
+  uint32_t key() const { return at<1>().as_uint32(); }
+  bool has_value() const { return at<2>().valid(); }
+  ::protozero::ConstBytes value() const { return at<2>().as_bytes(); }
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+class EvdevDevice_AxisStatesEntry : public ::protozero::Message {
+ public:
+  using Decoder = EvdevDevice_AxisStatesEntry_Decoder;
+  enum : int32_t {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.EvdevDevice.AxisStatesEntry"; }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_FTRACE_FTRACE_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/gpu/gpu_counter_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_GPU_COUNTER_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_GPU_COUNTER_CONFIG_PROTO_CPP_H_
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  using FieldMetadata_Key =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      EvdevDevice_AxisStatesEntry>;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  static constexpr FieldMetadata_Key kKey{};
+  void set_key(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class GpuCounterConfig;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      EvdevDevice_AxisMap,
+      EvdevDevice_AxisStatesEntry>;
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  static constexpr FieldMetadata_Value kValue{};
+  template <typename T = EvdevDevice_AxisMap> T* set_value() {
+    return BeginNestedMessage<T>(2);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+};
 
-class PERFETTO_EXPORT_COMPONENT GpuCounterConfig : public ::protozero::CppMessageObj {
+class EvdevDevice_AxisMap_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
  public:
-  enum FieldNumbers {
-    kCounterPeriodNsFieldNumber = 1,
-    kCounterIdsFieldNumber = 2,
-    kInstrumentedSamplingFieldNumber = 3,
-    kFixGpuClockFieldNumber = 4,
-  };
-
-  GpuCounterConfig();
-  ~GpuCounterConfig() override;
-  GpuCounterConfig(GpuCounterConfig&&) noexcept;
-  GpuCounterConfig& operator=(GpuCounterConfig&&);
-  GpuCounterConfig(const GpuCounterConfig&);
-  GpuCounterConfig& operator=(const GpuCounterConfig&);
-  bool operator==(const GpuCounterConfig&) const;
-  bool operator!=(const GpuCounterConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_counter_period_ns() const { return _has_field_[1]; }
-  uint64_t counter_period_ns() const { return counter_period_ns_; }
-  void set_counter_period_ns(uint64_t value) { counter_period_ns_ = value; _has_field_.set(1); }
+  EvdevDevice_AxisMap_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit EvdevDevice_AxisMap_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit EvdevDevice_AxisMap_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_axis_states() const { return at<1>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> axis_states() const { return GetRepeated<::protozero::ConstBytes>(1); }
+};
 
-  const std::vector<uint32_t>& counter_ids() const { return counter_ids_; }
-  std::vector<uint32_t>* mutable_counter_ids() { return &counter_ids_; }
-  int counter_ids_size() const { return static_cast<int>(counter_ids_.size()); }
-  void clear_counter_ids() { counter_ids_.clear(); }
-  void add_counter_ids(uint32_t value) { counter_ids_.emplace_back(value); }
-  uint32_t* add_counter_ids() { counter_ids_.emplace_back(); return &counter_ids_.back(); }
+class EvdevDevice_AxisMap : public ::protozero::Message {
+ public:
+  using Decoder = EvdevDevice_AxisMap_Decoder;
+  enum : int32_t {
+    kAxisStatesFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.EvdevDevice.AxisMap"; }
 
-  bool has_instrumented_sampling() const { return _has_field_[3]; }
-  bool instrumented_sampling() const { return instrumented_sampling_; }
-  void set_instrumented_sampling(bool value) { instrumented_sampling_ = value; _has_field_.set(3); }
+  using AxisStatesEntry = ::perfetto::protos::pbzero::EvdevDevice_AxisMap_AxisStatesEntry;
 
-  bool has_fix_gpu_clock() const { return _has_field_[4]; }
-  bool fix_gpu_clock() const { return fix_gpu_clock_; }
-  void set_fix_gpu_clock(bool value) { fix_gpu_clock_ = value; _has_field_.set(4); }
+  using FieldMetadata_AxisStates =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      EvdevDevice_AxisMap_AxisStatesEntry,
+      EvdevDevice_AxisMap>;
 
- private:
-  uint64_t counter_period_ns_{};
-  std::vector<uint32_t> counter_ids_;
-  bool instrumented_sampling_{};
-  bool fix_gpu_clock_{};
+  static constexpr FieldMetadata_AxisStates kAxisStates{};
+  template <typename T = EvdevDevice_AxisMap_AxisStatesEntry> T* add_axis_states() {
+    return BeginNestedMessage<T>(1);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+};
 
-  std::bitset<5> _has_field_{};
+class EvdevDevice_AxisMap_AxisStatesEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  EvdevDevice_AxisMap_AxisStatesEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit EvdevDevice_AxisMap_AxisStatesEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit EvdevDevice_AxisMap_AxisStatesEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_key() const { return at<1>().valid(); }
+  uint32_t key() const { return at<1>().as_uint32(); }
+  bool has_value() const { return at<2>().valid(); }
+  int32_t value() const { return at<2>().as_sint32(); }
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+class EvdevDevice_AxisMap_AxisStatesEntry : public ::protozero::Message {
+ public:
+  using Decoder = EvdevDevice_AxisMap_AxisStatesEntry_Decoder;
+  enum : int32_t {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.EvdevDevice.AxisMap.AxisStatesEntry"; }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_GPU_COUNTER_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/gpu/vulkan_memory_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_VULKAN_MEMORY_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_VULKAN_MEMORY_CONFIG_PROTO_CPP_H_
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  using FieldMetadata_Key =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      EvdevDevice_AxisMap_AxisStatesEntry>;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  static constexpr FieldMetadata_Key kKey{};
+  void set_key(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class VulkanMemoryConfig;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kSint32,
+      int32_t,
+      EvdevDevice_AxisMap_AxisStatesEntry>;
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kSint32>
+        ::Append(*this, field_id, value);
+  }
+};
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+class EvdevDevice_EventTypeBitmasksEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  EvdevDevice_EventTypeBitmasksEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit EvdevDevice_EventTypeBitmasksEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit EvdevDevice_EventTypeBitmasksEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_key() const { return at<1>().valid(); }
+  uint32_t key() const { return at<1>().as_uint32(); }
+  bool has_value() const { return at<2>().valid(); }
+  ::protozero::ConstBytes value() const { return at<2>().as_bytes(); }
+};
 
-class PERFETTO_EXPORT_COMPONENT VulkanMemoryConfig : public ::protozero::CppMessageObj {
+class EvdevDevice_EventTypeBitmasksEntry : public ::protozero::Message {
  public:
-  enum FieldNumbers {
-    kTrackDriverMemoryUsageFieldNumber = 1,
-    kTrackDeviceMemoryUsageFieldNumber = 2,
+  using Decoder = EvdevDevice_EventTypeBitmasksEntry_Decoder;
+  enum : int32_t {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.EvdevDevice.EventTypeBitmasksEntry"; }
 
-  VulkanMemoryConfig();
-  ~VulkanMemoryConfig() override;
-  VulkanMemoryConfig(VulkanMemoryConfig&&) noexcept;
-  VulkanMemoryConfig& operator=(VulkanMemoryConfig&&);
-  VulkanMemoryConfig(const VulkanMemoryConfig&);
-  VulkanMemoryConfig& operator=(const VulkanMemoryConfig&);
-  bool operator==(const VulkanMemoryConfig&) const;
-  bool operator!=(const VulkanMemoryConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
 
-  bool has_track_driver_memory_usage() const { return _has_field_[1]; }
-  bool track_driver_memory_usage() const { return track_driver_memory_usage_; }
-  void set_track_driver_memory_usage(bool value) { track_driver_memory_usage_ = value; _has_field_.set(1); }
+  using FieldMetadata_Key =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      EvdevDevice_EventTypeBitmasksEntry>;
 
-  bool has_track_device_memory_usage() const { return _has_field_[2]; }
-  bool track_device_memory_usage() const { return track_device_memory_usage_; }
-  void set_track_device_memory_usage(bool value) { track_device_memory_usage_ = value; _has_field_.set(2); }
+  static constexpr FieldMetadata_Key kKey{};
+  void set_key(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
- private:
-  bool track_driver_memory_usage_{};
-  bool track_device_memory_usage_{};
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBytes,
+      std::string,
+      EvdevDevice_EventTypeBitmasksEntry>;
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(const uint8_t* data, size_t size) {
+    AppendBytes(FieldMetadata_Value::kFieldId, data, size);
+  }
+  void set_value(::protozero::ConstBytes bytes) {
+    AppendBytes(FieldMetadata_Value::kFieldId, bytes.data, bytes.size);
+  }
+  void set_value(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kBytes>
+        ::Append(*this, field_id, value);
+  }
+};
 
-  std::bitset<3> _has_field_{};
+class EvdevDevice_AbsoluteAxisInfosEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2> {
+ public:
+  EvdevDevice_AbsoluteAxisInfosEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit EvdevDevice_AbsoluteAxisInfosEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit EvdevDevice_AbsoluteAxisInfosEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_key() const { return at<1>().valid(); }
+  uint32_t key() const { return at<1>().as_uint32(); }
+  bool has_value() const { return at<2>().valid(); }
+  ::protozero::ConstBytes value() const { return at<2>().as_bytes(); }
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+class EvdevDevice_AbsoluteAxisInfosEntry : public ::protozero::Message {
+ public:
+  using Decoder = EvdevDevice_AbsoluteAxisInfosEntry_Decoder;
+  enum : int32_t {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.EvdevDevice.AbsoluteAxisInfosEntry"; }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_GPU_VULKAN_MEMORY_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/inode_file/inode_file_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INODE_FILE_INODE_FILE_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INODE_FILE_INODE_FILE_CONFIG_PROTO_CPP_H_
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  using FieldMetadata_Key =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      EvdevDevice_AbsoluteAxisInfosEntry>;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  static constexpr FieldMetadata_Key kKey{};
+  void set_key(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class InodeFileConfig;
-class InodeFileConfig_MountPointMappingEntry;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      EvdevDevice_AbsInfo,
+      EvdevDevice_AbsoluteAxisInfosEntry>;
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  static constexpr FieldMetadata_Value kValue{};
+  template <typename T = EvdevDevice_AbsInfo> T* set_value() {
+    return BeginNestedMessage<T>(2);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+};
 
-class PERFETTO_EXPORT_COMPONENT InodeFileConfig : public ::protozero::CppMessageObj {
+class EvdevDevice_AbsInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5> {
  public:
-  using MountPointMappingEntry = InodeFileConfig_MountPointMappingEntry;
-  enum FieldNumbers {
-    kScanIntervalMsFieldNumber = 1,
-    kScanDelayMsFieldNumber = 2,
-    kScanBatchSizeFieldNumber = 3,
-    kDoNotScanFieldNumber = 4,
-    kScanMountPointsFieldNumber = 5,
-    kMountPointMappingFieldNumber = 6,
+  EvdevDevice_AbsInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit EvdevDevice_AbsInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit EvdevDevice_AbsInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_minimum() const { return at<1>().valid(); }
+  int32_t minimum() const { return at<1>().as_sint32(); }
+  bool has_maximum() const { return at<2>().valid(); }
+  int32_t maximum() const { return at<2>().as_sint32(); }
+  bool has_fuzz() const { return at<3>().valid(); }
+  int32_t fuzz() const { return at<3>().as_int32(); }
+  bool has_flat() const { return at<4>().valid(); }
+  int32_t flat() const { return at<4>().as_int32(); }
+  bool has_resolution() const { return at<5>().valid(); }
+  int32_t resolution() const { return at<5>().as_int32(); }
+};
+
+class EvdevDevice_AbsInfo : public ::protozero::Message {
+ public:
+  using Decoder = EvdevDevice_AbsInfo_Decoder;
+  enum : int32_t {
+    kMinimumFieldNumber = 1,
+    kMaximumFieldNumber = 2,
+    kFuzzFieldNumber = 3,
+    kFlatFieldNumber = 4,
+    kResolutionFieldNumber = 5,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.EvdevDevice.AbsInfo"; }
 
-  InodeFileConfig();
-  ~InodeFileConfig() override;
-  InodeFileConfig(InodeFileConfig&&) noexcept;
-  InodeFileConfig& operator=(InodeFileConfig&&);
-  InodeFileConfig(const InodeFileConfig&);
-  InodeFileConfig& operator=(const InodeFileConfig&);
-  bool operator==(const InodeFileConfig&) const;
-  bool operator!=(const InodeFileConfig& other) const { return !(*this == other); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_Minimum =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kSint32,
+      int32_t,
+      EvdevDevice_AbsInfo>;
 
-  bool has_scan_interval_ms() const { return _has_field_[1]; }
-  uint32_t scan_interval_ms() const { return scan_interval_ms_; }
-  void set_scan_interval_ms(uint32_t value) { scan_interval_ms_ = value; _has_field_.set(1); }
+  static constexpr FieldMetadata_Minimum kMinimum{};
+  void set_minimum(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Minimum::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kSint32>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_scan_delay_ms() const { return _has_field_[2]; }
-  uint32_t scan_delay_ms() const { return scan_delay_ms_; }
-  void set_scan_delay_ms(uint32_t value) { scan_delay_ms_ = value; _has_field_.set(2); }
+  using FieldMetadata_Maximum =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kSint32,
+      int32_t,
+      EvdevDevice_AbsInfo>;
 
-  bool has_scan_batch_size() const { return _has_field_[3]; }
-  uint32_t scan_batch_size() const { return scan_batch_size_; }
-  void set_scan_batch_size(uint32_t value) { scan_batch_size_ = value; _has_field_.set(3); }
+  static constexpr FieldMetadata_Maximum kMaximum{};
+  void set_maximum(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Maximum::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kSint32>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_do_not_scan() const { return _has_field_[4]; }
-  bool do_not_scan() const { return do_not_scan_; }
-  void set_do_not_scan(bool value) { do_not_scan_ = value; _has_field_.set(4); }
+  using FieldMetadata_Fuzz =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      EvdevDevice_AbsInfo>;
 
-  const std::vector<std::string>& scan_mount_points() const { return scan_mount_points_; }
-  std::vector<std::string>* mutable_scan_mount_points() { return &scan_mount_points_; }
-  int scan_mount_points_size() const { return static_cast<int>(scan_mount_points_.size()); }
-  void clear_scan_mount_points() { scan_mount_points_.clear(); }
-  void add_scan_mount_points(std::string value) { scan_mount_points_.emplace_back(value); }
-  std::string* add_scan_mount_points() { scan_mount_points_.emplace_back(); return &scan_mount_points_.back(); }
+  static constexpr FieldMetadata_Fuzz kFuzz{};
+  void set_fuzz(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Fuzz::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-  const std::vector<InodeFileConfig_MountPointMappingEntry>& mount_point_mapping() const { return mount_point_mapping_; }
-  std::vector<InodeFileConfig_MountPointMappingEntry>* mutable_mount_point_mapping() { return &mount_point_mapping_; }
-  int mount_point_mapping_size() const;
-  void clear_mount_point_mapping();
-  InodeFileConfig_MountPointMappingEntry* add_mount_point_mapping();
+  using FieldMetadata_Flat =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      EvdevDevice_AbsInfo>;
 
- private:
-  uint32_t scan_interval_ms_{};
-  uint32_t scan_delay_ms_{};
-  uint32_t scan_batch_size_{};
-  bool do_not_scan_{};
-  std::vector<std::string> scan_mount_points_;
-  std::vector<InodeFileConfig_MountPointMappingEntry> mount_point_mapping_;
+  static constexpr FieldMetadata_Flat kFlat{};
+  void set_flat(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Flat::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_Resolution =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      EvdevDevice_AbsInfo>;
 
-  std::bitset<7> _has_field_{};
+  static constexpr FieldMetadata_Resolution kResolution{};
+  void set_resolution(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Resolution::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kInt32>
+        ::Append(*this, field_id, value);
+  }
 };
 
+class EvdevDevice_Identifier_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  EvdevDevice_Identifier_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit EvdevDevice_Identifier_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit EvdevDevice_Identifier_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_bustype() const { return at<1>().valid(); }
+  uint32_t bustype() const { return at<1>().as_uint32(); }
+  bool has_vendor() const { return at<2>().valid(); }
+  uint32_t vendor() const { return at<2>().as_uint32(); }
+  bool has_product() const { return at<3>().valid(); }
+  uint32_t product() const { return at<3>().as_uint32(); }
+  bool has_version() const { return at<4>().valid(); }
+  uint32_t version() const { return at<4>().as_uint32(); }
+};
 
-class PERFETTO_EXPORT_COMPONENT InodeFileConfig_MountPointMappingEntry : public ::protozero::CppMessageObj {
+class EvdevDevice_Identifier : public ::protozero::Message {
  public:
-  enum FieldNumbers {
-    kMountpointFieldNumber = 1,
-    kScanRootsFieldNumber = 2,
+  using Decoder = EvdevDevice_Identifier_Decoder;
+  enum : int32_t {
+    kBustypeFieldNumber = 1,
+    kVendorFieldNumber = 2,
+    kProductFieldNumber = 3,
+    kVersionFieldNumber = 4,
   };
+  static constexpr const char* GetName() { return ".perfetto.protos.EvdevDevice.Identifier"; }
 
-  InodeFileConfig_MountPointMappingEntry();
-  ~InodeFileConfig_MountPointMappingEntry() override;
-  InodeFileConfig_MountPointMappingEntry(InodeFileConfig_MountPointMappingEntry&&) noexcept;
-  InodeFileConfig_MountPointMappingEntry& operator=(InodeFileConfig_MountPointMappingEntry&&);
-  InodeFileConfig_MountPointMappingEntry(const InodeFileConfig_MountPointMappingEntry&);
-  InodeFileConfig_MountPointMappingEntry& operator=(const InodeFileConfig_MountPointMappingEntry&);
-  bool operator==(const InodeFileConfig_MountPointMappingEntry&) const;
-  bool operator!=(const InodeFileConfig_MountPointMappingEntry& other) const { return !(*this == other); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  using FieldMetadata_Bustype =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      EvdevDevice_Identifier>;
 
-  bool has_mountpoint() const { return _has_field_[1]; }
-  const std::string& mountpoint() const { return mountpoint_; }
-  void set_mountpoint(const std::string& value) { mountpoint_ = value; _has_field_.set(1); }
+  static constexpr FieldMetadata_Bustype kBustype{};
+  void set_bustype(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Bustype::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  const std::vector<std::string>& scan_roots() const { return scan_roots_; }
-  std::vector<std::string>* mutable_scan_roots() { return &scan_roots_; }
-  int scan_roots_size() const { return static_cast<int>(scan_roots_.size()); }
-  void clear_scan_roots() { scan_roots_.clear(); }
-  void add_scan_roots(std::string value) { scan_roots_.emplace_back(value); }
-  std::string* add_scan_roots() { scan_roots_.emplace_back(); return &scan_roots_.back(); }
+  using FieldMetadata_Vendor =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      EvdevDevice_Identifier>;
 
- private:
-  std::string mountpoint_{};
-  std::vector<std::string> scan_roots_;
+  static constexpr FieldMetadata_Vendor kVendor{};
+  void set_vendor(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Vendor::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_Product =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      EvdevDevice_Identifier>;
 
-  std::bitset<3> _has_field_{};
+  static constexpr FieldMetadata_Product kProduct{};
+  void set_product(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Product::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Version =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      EvdevDevice_Identifier>;
+
+  static constexpr FieldMetadata_Version kVersion{};
+  void set_version(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Version::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+class EvdevEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
+ public:
+  EvdevEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit EvdevEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit EvdevEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_device_id() const { return at<1>().valid(); }
+  uint32_t device_id() const { return at<1>().as_uint32(); }
+  bool has_input_event() const { return at<2>().valid(); }
+  ::protozero::ConstBytes input_event() const { return at<2>().as_bytes(); }
+  bool has_add_event() const { return at<3>().valid(); }
+  ::protozero::ConstBytes add_event() const { return at<3>().as_bytes(); }
+  bool has_remove_event() const { return at<4>().valid(); }
+  ::protozero::ConstBytes remove_event() const { return at<4>().as_bytes(); }
+};
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INODE_FILE_INODE_FILE_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/interceptors/console_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTORS_CONSOLE_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTORS_CONSOLE_CONFIG_PROTO_CPP_H_
+class EvdevEvent : public ::protozero::Message {
+ public:
+  using Decoder = EvdevEvent_Decoder;
+  enum : int32_t {
+    kDeviceIdFieldNumber = 1,
+    kInputEventFieldNumber = 2,
+    kAddEventFieldNumber = 3,
+    kRemoveEventFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.EvdevEvent"; }
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  using InputEvent = ::perfetto::protos::pbzero::EvdevEvent_InputEvent;
+  using DeviceAddition = ::perfetto::protos::pbzero::EvdevEvent_DeviceAddition;
+  using DeviceRemoval = ::perfetto::protos::pbzero::EvdevEvent_DeviceRemoval;
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  using FieldMetadata_DeviceId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      EvdevEvent>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ConsoleConfig;
-enum ConsoleConfig_Output : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  static constexpr FieldMetadata_DeviceId kDeviceId{};
+  void set_device_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DeviceId::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  using FieldMetadata_InputEvent =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      EvdevEvent_InputEvent,
+      EvdevEvent>;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum ConsoleConfig_Output : int {
-  ConsoleConfig_Output_OUTPUT_UNSPECIFIED = 0,
-  ConsoleConfig_Output_OUTPUT_STDOUT = 1,
-  ConsoleConfig_Output_OUTPUT_STDERR = 2,
-};
+  static constexpr FieldMetadata_InputEvent kInputEvent{};
+  template <typename T = EvdevEvent_InputEvent> T* set_input_event() {
+    return BeginNestedMessage<T>(2);
+  }
 
-class PERFETTO_EXPORT_COMPONENT ConsoleConfig : public ::protozero::CppMessageObj {
- public:
-  using Output = ConsoleConfig_Output;
-  static constexpr auto OUTPUT_UNSPECIFIED = ConsoleConfig_Output_OUTPUT_UNSPECIFIED;
-  static constexpr auto OUTPUT_STDOUT = ConsoleConfig_Output_OUTPUT_STDOUT;
-  static constexpr auto OUTPUT_STDERR = ConsoleConfig_Output_OUTPUT_STDERR;
-  static constexpr auto Output_MIN = ConsoleConfig_Output_OUTPUT_UNSPECIFIED;
-  static constexpr auto Output_MAX = ConsoleConfig_Output_OUTPUT_STDERR;
-  enum FieldNumbers {
-    kOutputFieldNumber = 1,
-    kEnableColorsFieldNumber = 2,
-  };
 
-  ConsoleConfig();
-  ~ConsoleConfig() override;
-  ConsoleConfig(ConsoleConfig&&) noexcept;
-  ConsoleConfig& operator=(ConsoleConfig&&);
-  ConsoleConfig(const ConsoleConfig&);
-  ConsoleConfig& operator=(const ConsoleConfig&);
-  bool operator==(const ConsoleConfig&) const;
-  bool operator!=(const ConsoleConfig& other) const { return !(*this == other); }
+  using FieldMetadata_AddEvent =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      EvdevEvent_DeviceAddition,
+      EvdevEvent>;
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  static constexpr FieldMetadata_AddEvent kAddEvent{};
+  template <typename T = EvdevEvent_DeviceAddition> T* set_add_event() {
+    return BeginNestedMessage<T>(3);
+  }
 
-  bool has_output() const { return _has_field_[1]; }
-  ConsoleConfig_Output output() const { return output_; }
-  void set_output(ConsoleConfig_Output value) { output_ = value; _has_field_.set(1); }
 
-  bool has_enable_colors() const { return _has_field_[2]; }
-  bool enable_colors() const { return enable_colors_; }
-  void set_enable_colors(bool value) { enable_colors_ = value; _has_field_.set(2); }
+  using FieldMetadata_RemoveEvent =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      EvdevEvent_DeviceRemoval,
+      EvdevEvent>;
 
- private:
-  ConsoleConfig_Output output_{};
-  bool enable_colors_{};
+  static constexpr FieldMetadata_RemoveEvent kRemoveEvent{};
+  template <typename T = EvdevEvent_DeviceRemoval> T* set_remove_event() {
+    return BeginNestedMessage<T>(4);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+};
 
-  std::bitset<3> _has_field_{};
+class EvdevEvent_DeviceRemoval_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0> {
+ public:
+  EvdevEvent_DeviceRemoval_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit EvdevEvent_DeviceRemoval_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit EvdevEvent_DeviceRemoval_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+class EvdevEvent_DeviceRemoval : public ::protozero::Message {
+ public:
+  using Decoder = EvdevEvent_DeviceRemoval_Decoder;
+  static constexpr const char* GetName() { return ".perfetto.protos.EvdevEvent.DeviceRemoval"; }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTORS_CONSOLE_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/power/android_power_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_POWER_ANDROID_POWER_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_POWER_ANDROID_POWER_CONFIG_PROTO_CPP_H_
+};
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+class EvdevEvent_DeviceAddition_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1> {
+ public:
+  EvdevEvent_DeviceAddition_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit EvdevEvent_DeviceAddition_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit EvdevEvent_DeviceAddition_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_device() const { return at<1>().valid(); }
+  ::protozero::ConstBytes device() const { return at<1>().as_bytes(); }
+};
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+class EvdevEvent_DeviceAddition : public ::protozero::Message {
+ public:
+  using Decoder = EvdevEvent_DeviceAddition_Decoder;
+  enum : int32_t {
+    kDeviceFieldNumber = 1,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.EvdevEvent.DeviceAddition"; }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class AndroidPowerConfig;
-enum AndroidPowerConfig_BatteryCounters : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  using FieldMetadata_Device =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      EvdevDevice,
+      EvdevEvent_DeviceAddition>;
+
+  static constexpr FieldMetadata_Device kDevice{};
+  template <typename T = EvdevDevice> T* set_device() {
+    return BeginNestedMessage<T>(1);
+  }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum AndroidPowerConfig_BatteryCounters : int {
-  AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_UNSPECIFIED = 0,
-  AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CHARGE = 1,
-  AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CAPACITY_PERCENT = 2,
-  AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CURRENT = 3,
-  AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CURRENT_AVG = 4,
 };
 
-class PERFETTO_EXPORT_COMPONENT AndroidPowerConfig : public ::protozero::CppMessageObj {
+class EvdevEvent_InputEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4> {
  public:
-  using BatteryCounters = AndroidPowerConfig_BatteryCounters;
-  static constexpr auto BATTERY_COUNTER_UNSPECIFIED = AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_UNSPECIFIED;
-  static constexpr auto BATTERY_COUNTER_CHARGE = AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CHARGE;
-  static constexpr auto BATTERY_COUNTER_CAPACITY_PERCENT = AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CAPACITY_PERCENT;
-  static constexpr auto BATTERY_COUNTER_CURRENT = AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CURRENT;
-  static constexpr auto BATTERY_COUNTER_CURRENT_AVG = AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CURRENT_AVG;
-  static constexpr auto BatteryCounters_MIN = AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_UNSPECIFIED;
-  static constexpr auto BatteryCounters_MAX = AndroidPowerConfig_BatteryCounters_BATTERY_COUNTER_CURRENT_AVG;
-  enum FieldNumbers {
-    kBatteryPollMsFieldNumber = 1,
-    kBatteryCountersFieldNumber = 2,
-    kCollectPowerRailsFieldNumber = 3,
-    kCollectEnergyEstimationBreakdownFieldNumber = 4,
-    kCollectEntityStateResidencyFieldNumber = 5,
-  };
+  EvdevEvent_InputEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit EvdevEvent_InputEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit EvdevEvent_InputEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_kernel_timestamp() const { return at<1>().valid(); }
+  uint64_t kernel_timestamp() const { return at<1>().as_uint64(); }
+  bool has_type() const { return at<2>().valid(); }
+  uint32_t type() const { return at<2>().as_uint32(); }
+  bool has_code() const { return at<3>().valid(); }
+  uint32_t code() const { return at<3>().as_uint32(); }
+  bool has_value() const { return at<4>().valid(); }
+  int32_t value() const { return at<4>().as_sint32(); }
+};
 
-  AndroidPowerConfig();
-  ~AndroidPowerConfig() override;
-  AndroidPowerConfig(AndroidPowerConfig&&) noexcept;
-  AndroidPowerConfig& operator=(AndroidPowerConfig&&);
-  AndroidPowerConfig(const AndroidPowerConfig&);
-  AndroidPowerConfig& operator=(const AndroidPowerConfig&);
-  bool operator==(const AndroidPowerConfig&) const;
-  bool operator!=(const AndroidPowerConfig& other) const { return !(*this == other); }
+class EvdevEvent_InputEvent : public ::protozero::Message {
+ public:
+  using Decoder = EvdevEvent_InputEvent_Decoder;
+  enum : int32_t {
+    kKernelTimestampFieldNumber = 1,
+    kTypeFieldNumber = 2,
+    kCodeFieldNumber = 3,
+    kValueFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.EvdevEvent.InputEvent"; }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
 
-  bool has_battery_poll_ms() const { return _has_field_[1]; }
-  uint32_t battery_poll_ms() const { return battery_poll_ms_; }
-  void set_battery_poll_ms(uint32_t value) { battery_poll_ms_ = value; _has_field_.set(1); }
+  using FieldMetadata_KernelTimestamp =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      EvdevEvent_InputEvent>;
 
-  const std::vector<AndroidPowerConfig_BatteryCounters>& battery_counters() const { return battery_counters_; }
-  std::vector<AndroidPowerConfig_BatteryCounters>* mutable_battery_counters() { return &battery_counters_; }
-  int battery_counters_size() const { return static_cast<int>(battery_counters_.size()); }
-  void clear_battery_counters() { battery_counters_.clear(); }
-  void add_battery_counters(AndroidPowerConfig_BatteryCounters value) { battery_counters_.emplace_back(value); }
-  AndroidPowerConfig_BatteryCounters* add_battery_counters() { battery_counters_.emplace_back(); return &battery_counters_.back(); }
+  static constexpr FieldMetadata_KernelTimestamp kKernelTimestamp{};
+  void set_kernel_timestamp(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_KernelTimestamp::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint64>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_collect_power_rails() const { return _has_field_[3]; }
-  bool collect_power_rails() const { return collect_power_rails_; }
-  void set_collect_power_rails(bool value) { collect_power_rails_ = value; _has_field_.set(3); }
+  using FieldMetadata_Type =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      EvdevEvent_InputEvent>;
 
-  bool has_collect_energy_estimation_breakdown() const { return _has_field_[4]; }
-  bool collect_energy_estimation_breakdown() const { return collect_energy_estimation_breakdown_; }
-  void set_collect_energy_estimation_breakdown(bool value) { collect_energy_estimation_breakdown_ = value; _has_field_.set(4); }
+  static constexpr FieldMetadata_Type kType{};
+  void set_type(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  bool has_collect_entity_state_residency() const { return _has_field_[5]; }
-  bool collect_entity_state_residency() const { return collect_entity_state_residency_; }
-  void set_collect_entity_state_residency(bool value) { collect_entity_state_residency_ = value; _has_field_.set(5); }
+  using FieldMetadata_Code =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      EvdevEvent_InputEvent>;
 
- private:
-  uint32_t battery_poll_ms_{};
-  std::vector<AndroidPowerConfig_BatteryCounters> battery_counters_;
-  bool collect_power_rails_{};
-  bool collect_energy_estimation_breakdown_{};
-  bool collect_entity_state_residency_{};
+  static constexpr FieldMetadata_Code kCode{};
+  void set_code(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Code::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kUint32>
+        ::Append(*this, field_id, value);
+  }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  using FieldMetadata_Value =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kSint32,
+      int32_t,
+      EvdevEvent_InputEvent>;
 
-  std::bitset<6> _has_field_{};
+  static constexpr FieldMetadata_Value kValue{};
+  void set_value(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId;
+    // Call the appropriate protozero::Message::Append(field_id, ...)
+    // method based on the type of the field.
+    ::protozero::internal::FieldWriter<
+      ::protozero::proto_utils::ProtoSchemaType::kSint32>
+        ::Append(*this, field_id, value);
+  }
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_POWER_ANDROID_POWER_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/process_stats/process_stats_config.gen.h
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_active_processes.gen.h
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROCESS_STATS_PROCESS_STATS_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROCESS_STATS_PROCESS_STATS_CONFIG_PROTO_CPP_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_ACTIVE_PROCESSES_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_ACTIVE_PROCESSES_PROTO_CPP_H_
 
 #include <stdint.h>
 #include <bitset>
@@ -168036,8 +188880,7 @@ class PERFETTO_EXPORT_COMPONENT AndroidPowerConfig : public ::protozero::CppMess
 namespace perfetto {
 namespace protos {
 namespace gen {
-class ProcessStatsConfig;
-enum ProcessStatsConfig_Quirks : int;
+class ChromeActiveProcesses;
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
@@ -168049,94 +188892,53 @@ class Message;
 namespace perfetto {
 namespace protos {
 namespace gen {
-enum ProcessStatsConfig_Quirks : int {
-  ProcessStatsConfig_Quirks_QUIRKS_UNSPECIFIED = 0,
-  ProcessStatsConfig_Quirks_DISABLE_INITIAL_DUMP = 1,
-  ProcessStatsConfig_Quirks_DISABLE_ON_DEMAND = 2,
-};
 
-class PERFETTO_EXPORT_COMPONENT ProcessStatsConfig : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT ChromeActiveProcesses : public ::protozero::CppMessageObj {
  public:
-  using Quirks = ProcessStatsConfig_Quirks;
-  static constexpr auto QUIRKS_UNSPECIFIED = ProcessStatsConfig_Quirks_QUIRKS_UNSPECIFIED;
-  static constexpr auto DISABLE_INITIAL_DUMP = ProcessStatsConfig_Quirks_DISABLE_INITIAL_DUMP;
-  static constexpr auto DISABLE_ON_DEMAND = ProcessStatsConfig_Quirks_DISABLE_ON_DEMAND;
-  static constexpr auto Quirks_MIN = ProcessStatsConfig_Quirks_QUIRKS_UNSPECIFIED;
-  static constexpr auto Quirks_MAX = ProcessStatsConfig_Quirks_DISABLE_ON_DEMAND;
   enum FieldNumbers {
-    kQuirksFieldNumber = 1,
-    kScanAllProcessesOnStartFieldNumber = 2,
-    kRecordThreadNamesFieldNumber = 3,
-    kProcStatsPollMsFieldNumber = 4,
-    kProcStatsCacheTtlMsFieldNumber = 6,
-    kResolveProcessFdsFieldNumber = 9,
+    kPidFieldNumber = 1,
   };
 
-  ProcessStatsConfig();
-  ~ProcessStatsConfig() override;
-  ProcessStatsConfig(ProcessStatsConfig&&) noexcept;
-  ProcessStatsConfig& operator=(ProcessStatsConfig&&);
-  ProcessStatsConfig(const ProcessStatsConfig&);
-  ProcessStatsConfig& operator=(const ProcessStatsConfig&);
-  bool operator==(const ProcessStatsConfig&) const;
-  bool operator!=(const ProcessStatsConfig& other) const { return !(*this == other); }
+  ChromeActiveProcesses();
+  ~ChromeActiveProcesses() override;
+  ChromeActiveProcesses(ChromeActiveProcesses&&) noexcept;
+  ChromeActiveProcesses& operator=(ChromeActiveProcesses&&);
+  ChromeActiveProcesses(const ChromeActiveProcesses&);
+  ChromeActiveProcesses& operator=(const ChromeActiveProcesses&);
+  bool operator==(const ChromeActiveProcesses&) const;
+  bool operator!=(const ChromeActiveProcesses& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  const std::vector<ProcessStatsConfig_Quirks>& quirks() const { return quirks_; }
-  std::vector<ProcessStatsConfig_Quirks>* mutable_quirks() { return &quirks_; }
-  int quirks_size() const { return static_cast<int>(quirks_.size()); }
-  void clear_quirks() { quirks_.clear(); }
-  void add_quirks(ProcessStatsConfig_Quirks value) { quirks_.emplace_back(value); }
-  ProcessStatsConfig_Quirks* add_quirks() { quirks_.emplace_back(); return &quirks_.back(); }
-
-  bool has_scan_all_processes_on_start() const { return _has_field_[2]; }
-  bool scan_all_processes_on_start() const { return scan_all_processes_on_start_; }
-  void set_scan_all_processes_on_start(bool value) { scan_all_processes_on_start_ = value; _has_field_.set(2); }
-
-  bool has_record_thread_names() const { return _has_field_[3]; }
-  bool record_thread_names() const { return record_thread_names_; }
-  void set_record_thread_names(bool value) { record_thread_names_ = value; _has_field_.set(3); }
-
-  bool has_proc_stats_poll_ms() const { return _has_field_[4]; }
-  uint32_t proc_stats_poll_ms() const { return proc_stats_poll_ms_; }
-  void set_proc_stats_poll_ms(uint32_t value) { proc_stats_poll_ms_ = value; _has_field_.set(4); }
-
-  bool has_proc_stats_cache_ttl_ms() const { return _has_field_[6]; }
-  uint32_t proc_stats_cache_ttl_ms() const { return proc_stats_cache_ttl_ms_; }
-  void set_proc_stats_cache_ttl_ms(uint32_t value) { proc_stats_cache_ttl_ms_ = value; _has_field_.set(6); }
-
-  bool has_resolve_process_fds() const { return _has_field_[9]; }
-  bool resolve_process_fds() const { return resolve_process_fds_; }
-  void set_resolve_process_fds(bool value) { resolve_process_fds_ = value; _has_field_.set(9); }
+  const std::vector<int32_t>& pid() const { return pid_; }
+  std::vector<int32_t>* mutable_pid() { return &pid_; }
+  int pid_size() const { return static_cast<int>(pid_.size()); }
+  void clear_pid() { pid_.clear(); }
+  void add_pid(int32_t value) { pid_.emplace_back(value); }
+  int32_t* add_pid() { pid_.emplace_back(); return &pid_.back(); }
 
  private:
-  std::vector<ProcessStatsConfig_Quirks> quirks_;
-  bool scan_all_processes_on_start_{};
-  bool record_thread_names_{};
-  uint32_t proc_stats_poll_ms_{};
-  uint32_t proc_stats_cache_ttl_ms_{};
-  bool resolve_process_fds_{};
+  std::vector<int32_t> pid_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<10> _has_field_{};
+  std::bitset<2> _has_field_{};
 };
 
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROCESS_STATS_PROCESS_STATS_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/profiling/heapprofd_config.gen.h
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_ACTIVE_PROCESSES_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_application_state_info.gen.h
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_HEAPPROFD_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_HEAPPROFD_CONFIG_PROTO_CPP_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_APPLICATION_STATE_INFO_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_APPLICATION_STATE_INFO_PROTO_CPP_H_
 
 #include <stdint.h>
 #include <bitset>
@@ -168151,8 +188953,8 @@ class PERFETTO_EXPORT_COMPONENT ProcessStatsConfig : public ::protozero::CppMess
 namespace perfetto {
 namespace protos {
 namespace gen {
-class HeapprofdConfig;
-class HeapprofdConfig_ContinuousDumpConfig;
+class ChromeApplicationStateInfo;
+enum ChromeApplicationStateInfo_ChromeApplicationState : int;
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
@@ -168164,257 +188966,65 @@ class Message;
 namespace perfetto {
 namespace protos {
 namespace gen {
-
-class PERFETTO_EXPORT_COMPONENT HeapprofdConfig : public ::protozero::CppMessageObj {
- public:
-  using ContinuousDumpConfig = HeapprofdConfig_ContinuousDumpConfig;
-  enum FieldNumbers {
-    kSamplingIntervalBytesFieldNumber = 1,
-    kAdaptiveSamplingShmemThresholdFieldNumber = 24,
-    kAdaptiveSamplingMaxSamplingIntervalBytesFieldNumber = 25,
-    kProcessCmdlineFieldNumber = 2,
-    kPidFieldNumber = 4,
-    kTargetInstalledByFieldNumber = 26,
-    kHeapsFieldNumber = 20,
-    kExcludeHeapsFieldNumber = 27,
-    kStreamAllocationsFieldNumber = 23,
-    kHeapSamplingIntervalsFieldNumber = 22,
-    kAllHeapsFieldNumber = 21,
-    kAllFieldNumber = 5,
-    kMinAnonymousMemoryKbFieldNumber = 15,
-    kMaxHeapprofdMemoryKbFieldNumber = 16,
-    kMaxHeapprofdCpuSecsFieldNumber = 17,
-    kSkipSymbolPrefixFieldNumber = 7,
-    kContinuousDumpConfigFieldNumber = 6,
-    kShmemSizeBytesFieldNumber = 8,
-    kBlockClientFieldNumber = 9,
-    kBlockClientTimeoutUsFieldNumber = 14,
-    kNoStartupFieldNumber = 10,
-    kNoRunningFieldNumber = 11,
-    kDumpAtMaxFieldNumber = 13,
-    kDisableForkTeardownFieldNumber = 18,
-    kDisableVforkDetectionFieldNumber = 19,
-  };
-
-  HeapprofdConfig();
-  ~HeapprofdConfig() override;
-  HeapprofdConfig(HeapprofdConfig&&) noexcept;
-  HeapprofdConfig& operator=(HeapprofdConfig&&);
-  HeapprofdConfig(const HeapprofdConfig&);
-  HeapprofdConfig& operator=(const HeapprofdConfig&);
-  bool operator==(const HeapprofdConfig&) const;
-  bool operator!=(const HeapprofdConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_sampling_interval_bytes() const { return _has_field_[1]; }
-  uint64_t sampling_interval_bytes() const { return sampling_interval_bytes_; }
-  void set_sampling_interval_bytes(uint64_t value) { sampling_interval_bytes_ = value; _has_field_.set(1); }
-
-  bool has_adaptive_sampling_shmem_threshold() const { return _has_field_[24]; }
-  uint64_t adaptive_sampling_shmem_threshold() const { return adaptive_sampling_shmem_threshold_; }
-  void set_adaptive_sampling_shmem_threshold(uint64_t value) { adaptive_sampling_shmem_threshold_ = value; _has_field_.set(24); }
-
-  bool has_adaptive_sampling_max_sampling_interval_bytes() const { return _has_field_[25]; }
-  uint64_t adaptive_sampling_max_sampling_interval_bytes() const { return adaptive_sampling_max_sampling_interval_bytes_; }
-  void set_adaptive_sampling_max_sampling_interval_bytes(uint64_t value) { adaptive_sampling_max_sampling_interval_bytes_ = value; _has_field_.set(25); }
-
-  const std::vector<std::string>& process_cmdline() const { return process_cmdline_; }
-  std::vector<std::string>* mutable_process_cmdline() { return &process_cmdline_; }
-  int process_cmdline_size() const { return static_cast<int>(process_cmdline_.size()); }
-  void clear_process_cmdline() { process_cmdline_.clear(); }
-  void add_process_cmdline(std::string value) { process_cmdline_.emplace_back(value); }
-  std::string* add_process_cmdline() { process_cmdline_.emplace_back(); return &process_cmdline_.back(); }
-
-  const std::vector<uint64_t>& pid() const { return pid_; }
-  std::vector<uint64_t>* mutable_pid() { return &pid_; }
-  int pid_size() const { return static_cast<int>(pid_.size()); }
-  void clear_pid() { pid_.clear(); }
-  void add_pid(uint64_t value) { pid_.emplace_back(value); }
-  uint64_t* add_pid() { pid_.emplace_back(); return &pid_.back(); }
-
-  const std::vector<std::string>& target_installed_by() const { return target_installed_by_; }
-  std::vector<std::string>* mutable_target_installed_by() { return &target_installed_by_; }
-  int target_installed_by_size() const { return static_cast<int>(target_installed_by_.size()); }
-  void clear_target_installed_by() { target_installed_by_.clear(); }
-  void add_target_installed_by(std::string value) { target_installed_by_.emplace_back(value); }
-  std::string* add_target_installed_by() { target_installed_by_.emplace_back(); return &target_installed_by_.back(); }
-
-  const std::vector<std::string>& heaps() const { return heaps_; }
-  std::vector<std::string>* mutable_heaps() { return &heaps_; }
-  int heaps_size() const { return static_cast<int>(heaps_.size()); }
-  void clear_heaps() { heaps_.clear(); }
-  void add_heaps(std::string value) { heaps_.emplace_back(value); }
-  std::string* add_heaps() { heaps_.emplace_back(); return &heaps_.back(); }
-
-  const std::vector<std::string>& exclude_heaps() const { return exclude_heaps_; }
-  std::vector<std::string>* mutable_exclude_heaps() { return &exclude_heaps_; }
-  int exclude_heaps_size() const { return static_cast<int>(exclude_heaps_.size()); }
-  void clear_exclude_heaps() { exclude_heaps_.clear(); }
-  void add_exclude_heaps(std::string value) { exclude_heaps_.emplace_back(value); }
-  std::string* add_exclude_heaps() { exclude_heaps_.emplace_back(); return &exclude_heaps_.back(); }
-
-  bool has_stream_allocations() const { return _has_field_[23]; }
-  bool stream_allocations() const { return stream_allocations_; }
-  void set_stream_allocations(bool value) { stream_allocations_ = value; _has_field_.set(23); }
-
-  const std::vector<uint64_t>& heap_sampling_intervals() const { return heap_sampling_intervals_; }
-  std::vector<uint64_t>* mutable_heap_sampling_intervals() { return &heap_sampling_intervals_; }
-  int heap_sampling_intervals_size() const { return static_cast<int>(heap_sampling_intervals_.size()); }
-  void clear_heap_sampling_intervals() { heap_sampling_intervals_.clear(); }
-  void add_heap_sampling_intervals(uint64_t value) { heap_sampling_intervals_.emplace_back(value); }
-  uint64_t* add_heap_sampling_intervals() { heap_sampling_intervals_.emplace_back(); return &heap_sampling_intervals_.back(); }
-
-  bool has_all_heaps() const { return _has_field_[21]; }
-  bool all_heaps() const { return all_heaps_; }
-  void set_all_heaps(bool value) { all_heaps_ = value; _has_field_.set(21); }
-
-  bool has_all() const { return _has_field_[5]; }
-  bool all() const { return all_; }
-  void set_all(bool value) { all_ = value; _has_field_.set(5); }
-
-  bool has_min_anonymous_memory_kb() const { return _has_field_[15]; }
-  uint32_t min_anonymous_memory_kb() const { return min_anonymous_memory_kb_; }
-  void set_min_anonymous_memory_kb(uint32_t value) { min_anonymous_memory_kb_ = value; _has_field_.set(15); }
-
-  bool has_max_heapprofd_memory_kb() const { return _has_field_[16]; }
-  uint32_t max_heapprofd_memory_kb() const { return max_heapprofd_memory_kb_; }
-  void set_max_heapprofd_memory_kb(uint32_t value) { max_heapprofd_memory_kb_ = value; _has_field_.set(16); }
-
-  bool has_max_heapprofd_cpu_secs() const { return _has_field_[17]; }
-  uint64_t max_heapprofd_cpu_secs() const { return max_heapprofd_cpu_secs_; }
-  void set_max_heapprofd_cpu_secs(uint64_t value) { max_heapprofd_cpu_secs_ = value; _has_field_.set(17); }
-
-  const std::vector<std::string>& skip_symbol_prefix() const { return skip_symbol_prefix_; }
-  std::vector<std::string>* mutable_skip_symbol_prefix() { return &skip_symbol_prefix_; }
-  int skip_symbol_prefix_size() const { return static_cast<int>(skip_symbol_prefix_.size()); }
-  void clear_skip_symbol_prefix() { skip_symbol_prefix_.clear(); }
-  void add_skip_symbol_prefix(std::string value) { skip_symbol_prefix_.emplace_back(value); }
-  std::string* add_skip_symbol_prefix() { skip_symbol_prefix_.emplace_back(); return &skip_symbol_prefix_.back(); }
-
-  bool has_continuous_dump_config() const { return _has_field_[6]; }
-  const HeapprofdConfig_ContinuousDumpConfig& continuous_dump_config() const { return *continuous_dump_config_; }
-  HeapprofdConfig_ContinuousDumpConfig* mutable_continuous_dump_config() { _has_field_.set(6); return continuous_dump_config_.get(); }
-
-  bool has_shmem_size_bytes() const { return _has_field_[8]; }
-  uint64_t shmem_size_bytes() const { return shmem_size_bytes_; }
-  void set_shmem_size_bytes(uint64_t value) { shmem_size_bytes_ = value; _has_field_.set(8); }
-
-  bool has_block_client() const { return _has_field_[9]; }
-  bool block_client() const { return block_client_; }
-  void set_block_client(bool value) { block_client_ = value; _has_field_.set(9); }
-
-  bool has_block_client_timeout_us() const { return _has_field_[14]; }
-  uint32_t block_client_timeout_us() const { return block_client_timeout_us_; }
-  void set_block_client_timeout_us(uint32_t value) { block_client_timeout_us_ = value; _has_field_.set(14); }
-
-  bool has_no_startup() const { return _has_field_[10]; }
-  bool no_startup() const { return no_startup_; }
-  void set_no_startup(bool value) { no_startup_ = value; _has_field_.set(10); }
-
-  bool has_no_running() const { return _has_field_[11]; }
-  bool no_running() const { return no_running_; }
-  void set_no_running(bool value) { no_running_ = value; _has_field_.set(11); }
-
-  bool has_dump_at_max() const { return _has_field_[13]; }
-  bool dump_at_max() const { return dump_at_max_; }
-  void set_dump_at_max(bool value) { dump_at_max_ = value; _has_field_.set(13); }
-
-  bool has_disable_fork_teardown() const { return _has_field_[18]; }
-  bool disable_fork_teardown() const { return disable_fork_teardown_; }
-  void set_disable_fork_teardown(bool value) { disable_fork_teardown_ = value; _has_field_.set(18); }
-
-  bool has_disable_vfork_detection() const { return _has_field_[19]; }
-  bool disable_vfork_detection() const { return disable_vfork_detection_; }
-  void set_disable_vfork_detection(bool value) { disable_vfork_detection_ = value; _has_field_.set(19); }
-
- private:
-  uint64_t sampling_interval_bytes_{};
-  uint64_t adaptive_sampling_shmem_threshold_{};
-  uint64_t adaptive_sampling_max_sampling_interval_bytes_{};
-  std::vector<std::string> process_cmdline_;
-  std::vector<uint64_t> pid_;
-  std::vector<std::string> target_installed_by_;
-  std::vector<std::string> heaps_;
-  std::vector<std::string> exclude_heaps_;
-  bool stream_allocations_{};
-  std::vector<uint64_t> heap_sampling_intervals_;
-  bool all_heaps_{};
-  bool all_{};
-  uint32_t min_anonymous_memory_kb_{};
-  uint32_t max_heapprofd_memory_kb_{};
-  uint64_t max_heapprofd_cpu_secs_{};
-  std::vector<std::string> skip_symbol_prefix_;
-  ::protozero::CopyablePtr<HeapprofdConfig_ContinuousDumpConfig> continuous_dump_config_;
-  uint64_t shmem_size_bytes_{};
-  bool block_client_{};
-  uint32_t block_client_timeout_us_{};
-  bool no_startup_{};
-  bool no_running_{};
-  bool dump_at_max_{};
-  bool disable_fork_teardown_{};
-  bool disable_vfork_detection_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<28> _has_field_{};
+enum ChromeApplicationStateInfo_ChromeApplicationState : int {
+  ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_UNKNOWN = 0,
+  ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_RUNNING_ACTIVITIES = 1,
+  ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_PAUSED_ACTIVITIES = 2,
+  ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_STOPPED_ACTIVITIES = 3,
+  ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES = 4,
 };
 
-
-class PERFETTO_EXPORT_COMPONENT HeapprofdConfig_ContinuousDumpConfig : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT ChromeApplicationStateInfo : public ::protozero::CppMessageObj {
  public:
+  using ChromeApplicationState = ChromeApplicationStateInfo_ChromeApplicationState;
+  static constexpr auto APPLICATION_STATE_UNKNOWN = ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_UNKNOWN;
+  static constexpr auto APPLICATION_STATE_HAS_RUNNING_ACTIVITIES = ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_RUNNING_ACTIVITIES;
+  static constexpr auto APPLICATION_STATE_HAS_PAUSED_ACTIVITIES = ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_PAUSED_ACTIVITIES;
+  static constexpr auto APPLICATION_STATE_HAS_STOPPED_ACTIVITIES = ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_STOPPED_ACTIVITIES;
+  static constexpr auto APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES = ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES;
+  static constexpr auto ChromeApplicationState_MIN = ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_UNKNOWN;
+  static constexpr auto ChromeApplicationState_MAX = ChromeApplicationStateInfo_ChromeApplicationState_APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES;
   enum FieldNumbers {
-    kDumpPhaseMsFieldNumber = 5,
-    kDumpIntervalMsFieldNumber = 6,
+    kApplicationStateFieldNumber = 1,
   };
 
-  HeapprofdConfig_ContinuousDumpConfig();
-  ~HeapprofdConfig_ContinuousDumpConfig() override;
-  HeapprofdConfig_ContinuousDumpConfig(HeapprofdConfig_ContinuousDumpConfig&&) noexcept;
-  HeapprofdConfig_ContinuousDumpConfig& operator=(HeapprofdConfig_ContinuousDumpConfig&&);
-  HeapprofdConfig_ContinuousDumpConfig(const HeapprofdConfig_ContinuousDumpConfig&);
-  HeapprofdConfig_ContinuousDumpConfig& operator=(const HeapprofdConfig_ContinuousDumpConfig&);
-  bool operator==(const HeapprofdConfig_ContinuousDumpConfig&) const;
-  bool operator!=(const HeapprofdConfig_ContinuousDumpConfig& other) const { return !(*this == other); }
+  ChromeApplicationStateInfo();
+  ~ChromeApplicationStateInfo() override;
+  ChromeApplicationStateInfo(ChromeApplicationStateInfo&&) noexcept;
+  ChromeApplicationStateInfo& operator=(ChromeApplicationStateInfo&&);
+  ChromeApplicationStateInfo(const ChromeApplicationStateInfo&);
+  ChromeApplicationStateInfo& operator=(const ChromeApplicationStateInfo&);
+  bool operator==(const ChromeApplicationStateInfo&) const;
+  bool operator!=(const ChromeApplicationStateInfo& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_dump_phase_ms() const { return _has_field_[5]; }
-  uint32_t dump_phase_ms() const { return dump_phase_ms_; }
-  void set_dump_phase_ms(uint32_t value) { dump_phase_ms_ = value; _has_field_.set(5); }
-
-  bool has_dump_interval_ms() const { return _has_field_[6]; }
-  uint32_t dump_interval_ms() const { return dump_interval_ms_; }
-  void set_dump_interval_ms(uint32_t value) { dump_interval_ms_ = value; _has_field_.set(6); }
+  bool has_application_state() const { return _has_field_[1]; }
+  ChromeApplicationStateInfo_ChromeApplicationState application_state() const { return application_state_; }
+  void set_application_state(ChromeApplicationStateInfo_ChromeApplicationState value) { application_state_ = value; _has_field_.set(1); }
 
  private:
-  uint32_t dump_phase_ms_{};
-  uint32_t dump_interval_ms_{};
+  ChromeApplicationStateInfo_ChromeApplicationState application_state_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<7> _has_field_{};
+  std::bitset<2> _has_field_{};
 };
 
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_HEAPPROFD_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/profiling/java_hprof_config.gen.h
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_APPLICATION_STATE_INFO_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_compositor_scheduler_state.gen.h
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_JAVA_HPROF_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_JAVA_HPROF_CONFIG_PROTO_CPP_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_COMPOSITOR_SCHEDULER_STATE_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_COMPOSITOR_SCHEDULER_STATE_PROTO_CPP_H_
 
 #include <stdint.h>
 #include <bitset>
@@ -168429,8 +189039,27 @@ class PERFETTO_EXPORT_COMPONENT HeapprofdConfig_ContinuousDumpConfig : public ::
 namespace perfetto {
 namespace protos {
 namespace gen {
-class JavaHprofConfig;
-class JavaHprofConfig_ContinuousDumpConfig;
+class CompositorTimingHistory;
+class BeginFrameSourceState;
+class BeginFrameArgs;
+class SourceLocation;
+class BeginFrameObserverState;
+class BeginImplFrameArgs;
+class BeginImplFrameArgs_TimestampsInUs;
+class ChromeCompositorStateMachine;
+class ChromeCompositorStateMachine_MinorState;
+class ChromeCompositorStateMachine_MajorState;
+class ChromeCompositorSchedulerState;
+enum ChromeCompositorSchedulerAction : int;
+enum BeginFrameArgs_BeginFrameArgsType : int;
+enum BeginImplFrameArgs_State : int;
+enum ChromeCompositorStateMachine_MinorState_TreePriority : int;
+enum ChromeCompositorStateMachine_MinorState_ScrollHandlerState : int;
+enum ChromeCompositorStateMachine_MajorState_BeginImplFrameState : int;
+enum ChromeCompositorStateMachine_MajorState_BeginMainFrameState : int;
+enum ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState : int;
+enum ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState : int;
+enum ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode : int;
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
@@ -168442,82 +189071,141 @@ class Message;
 namespace perfetto {
 namespace protos {
 namespace gen {
+enum ChromeCompositorSchedulerAction : int {
+  CC_SCHEDULER_ACTION_UNSPECIFIED = 0,
+  CC_SCHEDULER_ACTION_NONE = 1,
+  CC_SCHEDULER_ACTION_SEND_BEGIN_MAIN_FRAME = 2,
+  CC_SCHEDULER_ACTION_COMMIT = 3,
+  CC_SCHEDULER_ACTION_ACTIVATE_SYNC_TREE = 4,
+  CC_SCHEDULER_ACTION_DRAW_IF_POSSIBLE = 5,
+  CC_SCHEDULER_ACTION_DRAW_FORCED = 6,
+  CC_SCHEDULER_ACTION_DRAW_ABORT = 7,
+  CC_SCHEDULER_ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION = 8,
+  CC_SCHEDULER_ACTION_PREPARE_TILES = 9,
+  CC_SCHEDULER_ACTION_INVALIDATE_LAYER_TREE_FRAME_SINK = 10,
+  CC_SCHEDULER_ACTION_PERFORM_IMPL_SIDE_INVALIDATION = 11,
+  CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_UNTIL = 12,
+  CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_SOON = 13,
+};
+enum BeginFrameArgs_BeginFrameArgsType : int {
+  BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED = 0,
+  BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_INVALID = 1,
+  BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_NORMAL = 2,
+  BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_MISSED = 3,
+};
+enum BeginImplFrameArgs_State : int {
+  BeginImplFrameArgs_State_BEGIN_FRAME_FINISHED = 0,
+  BeginImplFrameArgs_State_BEGIN_FRAME_USING = 1,
+};
+enum ChromeCompositorStateMachine_MinorState_TreePriority : int {
+  ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_UNSPECIFIED = 0,
+  ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES = 1,
+  ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY = 2,
+  ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY = 3,
+};
+enum ChromeCompositorStateMachine_MinorState_ScrollHandlerState : int {
+  ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_HANDLER_UNSPECIFIED = 0,
+  ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_AFFECTS_SCROLL_HANDLER = 1,
+  ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER = 2,
+};
+enum ChromeCompositorStateMachine_MajorState_BeginImplFrameState : int {
+  ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_UNSPECIFIED = 0,
+  ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_IDLE = 1,
+  ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME = 2,
+  ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_INSIDE_DEADLINE = 3,
+};
+enum ChromeCompositorStateMachine_MajorState_BeginMainFrameState : int {
+  ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_UNSPECIFIED = 0,
+  ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_IDLE = 1,
+  ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_SENT = 2,
+  ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_READY_TO_COMMIT = 3,
+};
+enum ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState : int {
+  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_UNSPECIFIED = 0,
+  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_NONE = 1,
+  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_ACTIVE = 2,
+  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_CREATING = 3,
+  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT = 4,
+  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION = 5,
+};
+enum ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState : int {
+  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_UNSPECIFIED = 0,
+  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_IDLE = 1,
+  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_COMMIT = 2,
+  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_ACTIVATION = 3,
+  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_DRAW = 4,
+};
+enum ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode : int {
+  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_UNSPECIFIED = 0,
+  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_NONE = 1,
+  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_IMMEDIATE = 2,
+  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_REGULAR = 3,
+  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_LATE = 4,
+  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_BLOCKED = 5,
+};
 
-class PERFETTO_EXPORT_COMPONENT JavaHprofConfig : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT CompositorTimingHistory : public ::protozero::CppMessageObj {
  public:
-  using ContinuousDumpConfig = JavaHprofConfig_ContinuousDumpConfig;
   enum FieldNumbers {
-    kProcessCmdlineFieldNumber = 1,
-    kPidFieldNumber = 2,
-    kTargetInstalledByFieldNumber = 7,
-    kContinuousDumpConfigFieldNumber = 3,
-    kMinAnonymousMemoryKbFieldNumber = 4,
-    kDumpSmapsFieldNumber = 5,
-    kIgnoredTypesFieldNumber = 6,
+    kBeginMainFrameQueueCriticalEstimateDeltaUsFieldNumber = 1,
+    kBeginMainFrameQueueNotCriticalEstimateDeltaUsFieldNumber = 2,
+    kBeginMainFrameStartToReadyToCommitEstimateDeltaUsFieldNumber = 3,
+    kCommitToReadyToActivateEstimateDeltaUsFieldNumber = 4,
+    kPrepareTilesEstimateDeltaUsFieldNumber = 5,
+    kActivateEstimateDeltaUsFieldNumber = 6,
+    kDrawEstimateDeltaUsFieldNumber = 7,
   };
 
-  JavaHprofConfig();
-  ~JavaHprofConfig() override;
-  JavaHprofConfig(JavaHprofConfig&&) noexcept;
-  JavaHprofConfig& operator=(JavaHprofConfig&&);
-  JavaHprofConfig(const JavaHprofConfig&);
-  JavaHprofConfig& operator=(const JavaHprofConfig&);
-  bool operator==(const JavaHprofConfig&) const;
-  bool operator!=(const JavaHprofConfig& other) const { return !(*this == other); }
+  CompositorTimingHistory();
+  ~CompositorTimingHistory() override;
+  CompositorTimingHistory(CompositorTimingHistory&&) noexcept;
+  CompositorTimingHistory& operator=(CompositorTimingHistory&&);
+  CompositorTimingHistory(const CompositorTimingHistory&);
+  CompositorTimingHistory& operator=(const CompositorTimingHistory&);
+  bool operator==(const CompositorTimingHistory&) const;
+  bool operator!=(const CompositorTimingHistory& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  const std::vector<std::string>& process_cmdline() const { return process_cmdline_; }
-  std::vector<std::string>* mutable_process_cmdline() { return &process_cmdline_; }
-  int process_cmdline_size() const { return static_cast<int>(process_cmdline_.size()); }
-  void clear_process_cmdline() { process_cmdline_.clear(); }
-  void add_process_cmdline(std::string value) { process_cmdline_.emplace_back(value); }
-  std::string* add_process_cmdline() { process_cmdline_.emplace_back(); return &process_cmdline_.back(); }
+  bool has_begin_main_frame_queue_critical_estimate_delta_us() const { return _has_field_[1]; }
+  int64_t begin_main_frame_queue_critical_estimate_delta_us() const { return begin_main_frame_queue_critical_estimate_delta_us_; }
+  void set_begin_main_frame_queue_critical_estimate_delta_us(int64_t value) { begin_main_frame_queue_critical_estimate_delta_us_ = value; _has_field_.set(1); }
 
-  const std::vector<uint64_t>& pid() const { return pid_; }
-  std::vector<uint64_t>* mutable_pid() { return &pid_; }
-  int pid_size() const { return static_cast<int>(pid_.size()); }
-  void clear_pid() { pid_.clear(); }
-  void add_pid(uint64_t value) { pid_.emplace_back(value); }
-  uint64_t* add_pid() { pid_.emplace_back(); return &pid_.back(); }
+  bool has_begin_main_frame_queue_not_critical_estimate_delta_us() const { return _has_field_[2]; }
+  int64_t begin_main_frame_queue_not_critical_estimate_delta_us() const { return begin_main_frame_queue_not_critical_estimate_delta_us_; }
+  void set_begin_main_frame_queue_not_critical_estimate_delta_us(int64_t value) { begin_main_frame_queue_not_critical_estimate_delta_us_ = value; _has_field_.set(2); }
 
-  const std::vector<std::string>& target_installed_by() const { return target_installed_by_; }
-  std::vector<std::string>* mutable_target_installed_by() { return &target_installed_by_; }
-  int target_installed_by_size() const { return static_cast<int>(target_installed_by_.size()); }
-  void clear_target_installed_by() { target_installed_by_.clear(); }
-  void add_target_installed_by(std::string value) { target_installed_by_.emplace_back(value); }
-  std::string* add_target_installed_by() { target_installed_by_.emplace_back(); return &target_installed_by_.back(); }
+  bool has_begin_main_frame_start_to_ready_to_commit_estimate_delta_us() const { return _has_field_[3]; }
+  int64_t begin_main_frame_start_to_ready_to_commit_estimate_delta_us() const { return begin_main_frame_start_to_ready_to_commit_estimate_delta_us_; }
+  void set_begin_main_frame_start_to_ready_to_commit_estimate_delta_us(int64_t value) { begin_main_frame_start_to_ready_to_commit_estimate_delta_us_ = value; _has_field_.set(3); }
 
-  bool has_continuous_dump_config() const { return _has_field_[3]; }
-  const JavaHprofConfig_ContinuousDumpConfig& continuous_dump_config() const { return *continuous_dump_config_; }
-  JavaHprofConfig_ContinuousDumpConfig* mutable_continuous_dump_config() { _has_field_.set(3); return continuous_dump_config_.get(); }
+  bool has_commit_to_ready_to_activate_estimate_delta_us() const { return _has_field_[4]; }
+  int64_t commit_to_ready_to_activate_estimate_delta_us() const { return commit_to_ready_to_activate_estimate_delta_us_; }
+  void set_commit_to_ready_to_activate_estimate_delta_us(int64_t value) { commit_to_ready_to_activate_estimate_delta_us_ = value; _has_field_.set(4); }
 
-  bool has_min_anonymous_memory_kb() const { return _has_field_[4]; }
-  uint32_t min_anonymous_memory_kb() const { return min_anonymous_memory_kb_; }
-  void set_min_anonymous_memory_kb(uint32_t value) { min_anonymous_memory_kb_ = value; _has_field_.set(4); }
+  bool has_prepare_tiles_estimate_delta_us() const { return _has_field_[5]; }
+  int64_t prepare_tiles_estimate_delta_us() const { return prepare_tiles_estimate_delta_us_; }
+  void set_prepare_tiles_estimate_delta_us(int64_t value) { prepare_tiles_estimate_delta_us_ = value; _has_field_.set(5); }
 
-  bool has_dump_smaps() const { return _has_field_[5]; }
-  bool dump_smaps() const { return dump_smaps_; }
-  void set_dump_smaps(bool value) { dump_smaps_ = value; _has_field_.set(5); }
+  bool has_activate_estimate_delta_us() const { return _has_field_[6]; }
+  int64_t activate_estimate_delta_us() const { return activate_estimate_delta_us_; }
+  void set_activate_estimate_delta_us(int64_t value) { activate_estimate_delta_us_ = value; _has_field_.set(6); }
 
-  const std::vector<std::string>& ignored_types() const { return ignored_types_; }
-  std::vector<std::string>* mutable_ignored_types() { return &ignored_types_; }
-  int ignored_types_size() const { return static_cast<int>(ignored_types_.size()); }
-  void clear_ignored_types() { ignored_types_.clear(); }
-  void add_ignored_types(std::string value) { ignored_types_.emplace_back(value); }
-  std::string* add_ignored_types() { ignored_types_.emplace_back(); return &ignored_types_.back(); }
+  bool has_draw_estimate_delta_us() const { return _has_field_[7]; }
+  int64_t draw_estimate_delta_us() const { return draw_estimate_delta_us_; }
+  void set_draw_estimate_delta_us(int64_t value) { draw_estimate_delta_us_ = value; _has_field_.set(7); }
 
  private:
-  std::vector<std::string> process_cmdline_;
-  std::vector<uint64_t> pid_;
-  std::vector<std::string> target_installed_by_;
-  ::protozero::CopyablePtr<JavaHprofConfig_ContinuousDumpConfig> continuous_dump_config_;
-  uint32_t min_anonymous_memory_kb_{};
-  bool dump_smaps_{};
-  std::vector<std::string> ignored_types_;
+  int64_t begin_main_frame_queue_critical_estimate_delta_us_{};
+  int64_t begin_main_frame_queue_not_critical_estimate_delta_us_{};
+  int64_t begin_main_frame_start_to_ready_to_commit_estimate_delta_us_{};
+  int64_t commit_to_ready_to_activate_estimate_delta_us_{};
+  int64_t prepare_tiles_estimate_delta_us_{};
+  int64_t activate_estimate_delta_us_{};
+  int64_t draw_estimate_delta_us_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
@@ -168527,370 +189215,264 @@ class PERFETTO_EXPORT_COMPONENT JavaHprofConfig : public ::protozero::CppMessage
 };
 
 
-class PERFETTO_EXPORT_COMPONENT JavaHprofConfig_ContinuousDumpConfig : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT BeginFrameSourceState : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kDumpPhaseMsFieldNumber = 1,
-    kDumpIntervalMsFieldNumber = 2,
-    kScanPidsOnlyOnStartFieldNumber = 3,
+    kSourceIdFieldNumber = 1,
+    kPausedFieldNumber = 2,
+    kNumObserversFieldNumber = 3,
+    kLastBeginFrameArgsFieldNumber = 4,
   };
 
-  JavaHprofConfig_ContinuousDumpConfig();
-  ~JavaHprofConfig_ContinuousDumpConfig() override;
-  JavaHprofConfig_ContinuousDumpConfig(JavaHprofConfig_ContinuousDumpConfig&&) noexcept;
-  JavaHprofConfig_ContinuousDumpConfig& operator=(JavaHprofConfig_ContinuousDumpConfig&&);
-  JavaHprofConfig_ContinuousDumpConfig(const JavaHprofConfig_ContinuousDumpConfig&);
-  JavaHprofConfig_ContinuousDumpConfig& operator=(const JavaHprofConfig_ContinuousDumpConfig&);
-  bool operator==(const JavaHprofConfig_ContinuousDumpConfig&) const;
-  bool operator!=(const JavaHprofConfig_ContinuousDumpConfig& other) const { return !(*this == other); }
+  BeginFrameSourceState();
+  ~BeginFrameSourceState() override;
+  BeginFrameSourceState(BeginFrameSourceState&&) noexcept;
+  BeginFrameSourceState& operator=(BeginFrameSourceState&&);
+  BeginFrameSourceState(const BeginFrameSourceState&);
+  BeginFrameSourceState& operator=(const BeginFrameSourceState&);
+  bool operator==(const BeginFrameSourceState&) const;
+  bool operator!=(const BeginFrameSourceState& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_dump_phase_ms() const { return _has_field_[1]; }
-  uint32_t dump_phase_ms() const { return dump_phase_ms_; }
-  void set_dump_phase_ms(uint32_t value) { dump_phase_ms_ = value; _has_field_.set(1); }
+  bool has_source_id() const { return _has_field_[1]; }
+  uint32_t source_id() const { return source_id_; }
+  void set_source_id(uint32_t value) { source_id_ = value; _has_field_.set(1); }
 
-  bool has_dump_interval_ms() const { return _has_field_[2]; }
-  uint32_t dump_interval_ms() const { return dump_interval_ms_; }
-  void set_dump_interval_ms(uint32_t value) { dump_interval_ms_ = value; _has_field_.set(2); }
+  bool has_paused() const { return _has_field_[2]; }
+  bool paused() const { return paused_; }
+  void set_paused(bool value) { paused_ = value; _has_field_.set(2); }
 
-  bool has_scan_pids_only_on_start() const { return _has_field_[3]; }
-  bool scan_pids_only_on_start() const { return scan_pids_only_on_start_; }
-  void set_scan_pids_only_on_start(bool value) { scan_pids_only_on_start_ = value; _has_field_.set(3); }
+  bool has_num_observers() const { return _has_field_[3]; }
+  uint32_t num_observers() const { return num_observers_; }
+  void set_num_observers(uint32_t value) { num_observers_ = value; _has_field_.set(3); }
+
+  bool has_last_begin_frame_args() const { return _has_field_[4]; }
+  const BeginFrameArgs& last_begin_frame_args() const { return *last_begin_frame_args_; }
+  BeginFrameArgs* mutable_last_begin_frame_args() { _has_field_.set(4); return last_begin_frame_args_.get(); }
 
  private:
-  uint32_t dump_phase_ms_{};
-  uint32_t dump_interval_ms_{};
-  bool scan_pids_only_on_start_{};
+  uint32_t source_id_{};
+  bool paused_{};
+  uint32_t num_observers_{};
+  ::protozero::CopyablePtr<BeginFrameArgs> last_begin_frame_args_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<4> _has_field_{};
+  std::bitset<5> _has_field_{};
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_JAVA_HPROF_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/profiling/perf_event_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_PERF_EVENT_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_PERF_EVENT_CONFIG_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class PerfEventConfig;
-class PerfEventConfig_CallstackSampling;
-class PerfEventConfig_Scope;
-class PerfEvents_Timebase;
-class PerfEvents_RawEvent;
-class PerfEvents_Tracepoint;
-enum PerfEventConfig_UnwindMode : int;
-enum PerfEvents_Counter : int;
-enum PerfEvents_PerfClock : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum PerfEventConfig_UnwindMode : int {
-  PerfEventConfig_UnwindMode_UNWIND_UNKNOWN = 0,
-  PerfEventConfig_UnwindMode_UNWIND_SKIP = 1,
-  PerfEventConfig_UnwindMode_UNWIND_DWARF = 2,
-};
 
-class PERFETTO_EXPORT_COMPONENT PerfEventConfig : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT BeginFrameArgs : public ::protozero::CppMessageObj {
  public:
-  using CallstackSampling = PerfEventConfig_CallstackSampling;
-  using Scope = PerfEventConfig_Scope;
-  using UnwindMode = PerfEventConfig_UnwindMode;
-  static constexpr auto UNWIND_UNKNOWN = PerfEventConfig_UnwindMode_UNWIND_UNKNOWN;
-  static constexpr auto UNWIND_SKIP = PerfEventConfig_UnwindMode_UNWIND_SKIP;
-  static constexpr auto UNWIND_DWARF = PerfEventConfig_UnwindMode_UNWIND_DWARF;
-  static constexpr auto UnwindMode_MIN = PerfEventConfig_UnwindMode_UNWIND_UNKNOWN;
-  static constexpr auto UnwindMode_MAX = PerfEventConfig_UnwindMode_UNWIND_DWARF;
+  using BeginFrameArgsType = BeginFrameArgs_BeginFrameArgsType;
+  static constexpr auto BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED = BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED;
+  static constexpr auto BEGIN_FRAME_ARGS_TYPE_INVALID = BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_INVALID;
+  static constexpr auto BEGIN_FRAME_ARGS_TYPE_NORMAL = BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_NORMAL;
+  static constexpr auto BEGIN_FRAME_ARGS_TYPE_MISSED = BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_MISSED;
+  static constexpr auto BeginFrameArgsType_MIN = BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED;
+  static constexpr auto BeginFrameArgsType_MAX = BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_MISSED;
   enum FieldNumbers {
-    kTimebaseFieldNumber = 15,
-    kCallstackSamplingFieldNumber = 16,
-    kRingBufferReadPeriodMsFieldNumber = 8,
-    kRingBufferPagesFieldNumber = 3,
-    kMaxEnqueuedFootprintKbFieldNumber = 17,
-    kMaxDaemonMemoryKbFieldNumber = 13,
-    kRemoteDescriptorTimeoutMsFieldNumber = 9,
-    kUnwindStateClearPeriodMsFieldNumber = 10,
-    kTargetInstalledByFieldNumber = 18,
-    kAllCpusFieldNumber = 1,
-    kSamplingFrequencyFieldNumber = 2,
-    kKernelFramesFieldNumber = 12,
-    kTargetPidFieldNumber = 4,
-    kTargetCmdlineFieldNumber = 5,
-    kExcludePidFieldNumber = 6,
-    kExcludeCmdlineFieldNumber = 7,
-    kAdditionalCmdlineCountFieldNumber = 11,
+    kTypeFieldNumber = 1,
+    kSourceIdFieldNumber = 2,
+    kSequenceNumberFieldNumber = 3,
+    kFrameTimeUsFieldNumber = 4,
+    kDeadlineUsFieldNumber = 5,
+    kIntervalDeltaUsFieldNumber = 6,
+    kOnCriticalPathFieldNumber = 7,
+    kAnimateOnlyFieldNumber = 8,
+    kSourceLocationIidFieldNumber = 9,
+    kSourceLocationFieldNumber = 10,
+    kFramesThrottledSinceLastFieldNumber = 12,
   };
 
-  PerfEventConfig();
-  ~PerfEventConfig() override;
-  PerfEventConfig(PerfEventConfig&&) noexcept;
-  PerfEventConfig& operator=(PerfEventConfig&&);
-  PerfEventConfig(const PerfEventConfig&);
-  PerfEventConfig& operator=(const PerfEventConfig&);
-  bool operator==(const PerfEventConfig&) const;
-  bool operator!=(const PerfEventConfig& other) const { return !(*this == other); }
+  BeginFrameArgs();
+  ~BeginFrameArgs() override;
+  BeginFrameArgs(BeginFrameArgs&&) noexcept;
+  BeginFrameArgs& operator=(BeginFrameArgs&&);
+  BeginFrameArgs(const BeginFrameArgs&);
+  BeginFrameArgs& operator=(const BeginFrameArgs&);
+  bool operator==(const BeginFrameArgs&) const;
+  bool operator!=(const BeginFrameArgs& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_timebase() const { return _has_field_[15]; }
-  const PerfEvents_Timebase& timebase() const { return *timebase_; }
-  PerfEvents_Timebase* mutable_timebase() { _has_field_.set(15); return timebase_.get(); }
-
-  bool has_callstack_sampling() const { return _has_field_[16]; }
-  const PerfEventConfig_CallstackSampling& callstack_sampling() const { return *callstack_sampling_; }
-  PerfEventConfig_CallstackSampling* mutable_callstack_sampling() { _has_field_.set(16); return callstack_sampling_.get(); }
-
-  bool has_ring_buffer_read_period_ms() const { return _has_field_[8]; }
-  uint32_t ring_buffer_read_period_ms() const { return ring_buffer_read_period_ms_; }
-  void set_ring_buffer_read_period_ms(uint32_t value) { ring_buffer_read_period_ms_ = value; _has_field_.set(8); }
-
-  bool has_ring_buffer_pages() const { return _has_field_[3]; }
-  uint32_t ring_buffer_pages() const { return ring_buffer_pages_; }
-  void set_ring_buffer_pages(uint32_t value) { ring_buffer_pages_ = value; _has_field_.set(3); }
-
-  bool has_max_enqueued_footprint_kb() const { return _has_field_[17]; }
-  uint64_t max_enqueued_footprint_kb() const { return max_enqueued_footprint_kb_; }
-  void set_max_enqueued_footprint_kb(uint64_t value) { max_enqueued_footprint_kb_ = value; _has_field_.set(17); }
-
-  bool has_max_daemon_memory_kb() const { return _has_field_[13]; }
-  uint32_t max_daemon_memory_kb() const { return max_daemon_memory_kb_; }
-  void set_max_daemon_memory_kb(uint32_t value) { max_daemon_memory_kb_ = value; _has_field_.set(13); }
-
-  bool has_remote_descriptor_timeout_ms() const { return _has_field_[9]; }
-  uint32_t remote_descriptor_timeout_ms() const { return remote_descriptor_timeout_ms_; }
-  void set_remote_descriptor_timeout_ms(uint32_t value) { remote_descriptor_timeout_ms_ = value; _has_field_.set(9); }
+  bool has_type() const { return _has_field_[1]; }
+  BeginFrameArgs_BeginFrameArgsType type() const { return type_; }
+  void set_type(BeginFrameArgs_BeginFrameArgsType value) { type_ = value; _has_field_.set(1); }
 
-  bool has_unwind_state_clear_period_ms() const { return _has_field_[10]; }
-  uint32_t unwind_state_clear_period_ms() const { return unwind_state_clear_period_ms_; }
-  void set_unwind_state_clear_period_ms(uint32_t value) { unwind_state_clear_period_ms_ = value; _has_field_.set(10); }
+  bool has_source_id() const { return _has_field_[2]; }
+  uint64_t source_id() const { return source_id_; }
+  void set_source_id(uint64_t value) { source_id_ = value; _has_field_.set(2); }
 
-  const std::vector<std::string>& target_installed_by() const { return target_installed_by_; }
-  std::vector<std::string>* mutable_target_installed_by() { return &target_installed_by_; }
-  int target_installed_by_size() const { return static_cast<int>(target_installed_by_.size()); }
-  void clear_target_installed_by() { target_installed_by_.clear(); }
-  void add_target_installed_by(std::string value) { target_installed_by_.emplace_back(value); }
-  std::string* add_target_installed_by() { target_installed_by_.emplace_back(); return &target_installed_by_.back(); }
+  bool has_sequence_number() const { return _has_field_[3]; }
+  uint64_t sequence_number() const { return sequence_number_; }
+  void set_sequence_number(uint64_t value) { sequence_number_ = value; _has_field_.set(3); }
 
-  bool has_all_cpus() const { return _has_field_[1]; }
-  bool all_cpus() const { return all_cpus_; }
-  void set_all_cpus(bool value) { all_cpus_ = value; _has_field_.set(1); }
+  bool has_frame_time_us() const { return _has_field_[4]; }
+  int64_t frame_time_us() const { return frame_time_us_; }
+  void set_frame_time_us(int64_t value) { frame_time_us_ = value; _has_field_.set(4); }
 
-  bool has_sampling_frequency() const { return _has_field_[2]; }
-  uint32_t sampling_frequency() const { return sampling_frequency_; }
-  void set_sampling_frequency(uint32_t value) { sampling_frequency_ = value; _has_field_.set(2); }
+  bool has_deadline_us() const { return _has_field_[5]; }
+  int64_t deadline_us() const { return deadline_us_; }
+  void set_deadline_us(int64_t value) { deadline_us_ = value; _has_field_.set(5); }
 
-  bool has_kernel_frames() const { return _has_field_[12]; }
-  bool kernel_frames() const { return kernel_frames_; }
-  void set_kernel_frames(bool value) { kernel_frames_ = value; _has_field_.set(12); }
+  bool has_interval_delta_us() const { return _has_field_[6]; }
+  int64_t interval_delta_us() const { return interval_delta_us_; }
+  void set_interval_delta_us(int64_t value) { interval_delta_us_ = value; _has_field_.set(6); }
 
-  const std::vector<int32_t>& target_pid() const { return target_pid_; }
-  std::vector<int32_t>* mutable_target_pid() { return &target_pid_; }
-  int target_pid_size() const { return static_cast<int>(target_pid_.size()); }
-  void clear_target_pid() { target_pid_.clear(); }
-  void add_target_pid(int32_t value) { target_pid_.emplace_back(value); }
-  int32_t* add_target_pid() { target_pid_.emplace_back(); return &target_pid_.back(); }
+  bool has_on_critical_path() const { return _has_field_[7]; }
+  bool on_critical_path() const { return on_critical_path_; }
+  void set_on_critical_path(bool value) { on_critical_path_ = value; _has_field_.set(7); }
 
-  const std::vector<std::string>& target_cmdline() const { return target_cmdline_; }
-  std::vector<std::string>* mutable_target_cmdline() { return &target_cmdline_; }
-  int target_cmdline_size() const { return static_cast<int>(target_cmdline_.size()); }
-  void clear_target_cmdline() { target_cmdline_.clear(); }
-  void add_target_cmdline(std::string value) { target_cmdline_.emplace_back(value); }
-  std::string* add_target_cmdline() { target_cmdline_.emplace_back(); return &target_cmdline_.back(); }
+  bool has_animate_only() const { return _has_field_[8]; }
+  bool animate_only() const { return animate_only_; }
+  void set_animate_only(bool value) { animate_only_ = value; _has_field_.set(8); }
 
-  const std::vector<int32_t>& exclude_pid() const { return exclude_pid_; }
-  std::vector<int32_t>* mutable_exclude_pid() { return &exclude_pid_; }
-  int exclude_pid_size() const { return static_cast<int>(exclude_pid_.size()); }
-  void clear_exclude_pid() { exclude_pid_.clear(); }
-  void add_exclude_pid(int32_t value) { exclude_pid_.emplace_back(value); }
-  int32_t* add_exclude_pid() { exclude_pid_.emplace_back(); return &exclude_pid_.back(); }
+  bool has_source_location_iid() const { return _has_field_[9]; }
+  uint64_t source_location_iid() const { return source_location_iid_; }
+  void set_source_location_iid(uint64_t value) { source_location_iid_ = value; _has_field_.set(9); }
 
-  const std::vector<std::string>& exclude_cmdline() const { return exclude_cmdline_; }
-  std::vector<std::string>* mutable_exclude_cmdline() { return &exclude_cmdline_; }
-  int exclude_cmdline_size() const { return static_cast<int>(exclude_cmdline_.size()); }
-  void clear_exclude_cmdline() { exclude_cmdline_.clear(); }
-  void add_exclude_cmdline(std::string value) { exclude_cmdline_.emplace_back(value); }
-  std::string* add_exclude_cmdline() { exclude_cmdline_.emplace_back(); return &exclude_cmdline_.back(); }
+  bool has_source_location() const { return _has_field_[10]; }
+  const SourceLocation& source_location() const { return *source_location_; }
+  SourceLocation* mutable_source_location() { _has_field_.set(10); return source_location_.get(); }
 
-  bool has_additional_cmdline_count() const { return _has_field_[11]; }
-  uint32_t additional_cmdline_count() const { return additional_cmdline_count_; }
-  void set_additional_cmdline_count(uint32_t value) { additional_cmdline_count_ = value; _has_field_.set(11); }
+  bool has_frames_throttled_since_last() const { return _has_field_[12]; }
+  int64_t frames_throttled_since_last() const { return frames_throttled_since_last_; }
+  void set_frames_throttled_since_last(int64_t value) { frames_throttled_since_last_ = value; _has_field_.set(12); }
 
  private:
-  ::protozero::CopyablePtr<PerfEvents_Timebase> timebase_;
-  ::protozero::CopyablePtr<PerfEventConfig_CallstackSampling> callstack_sampling_;
-  uint32_t ring_buffer_read_period_ms_{};
-  uint32_t ring_buffer_pages_{};
-  uint64_t max_enqueued_footprint_kb_{};
-  uint32_t max_daemon_memory_kb_{};
-  uint32_t remote_descriptor_timeout_ms_{};
-  uint32_t unwind_state_clear_period_ms_{};
-  std::vector<std::string> target_installed_by_;
-  bool all_cpus_{};
-  uint32_t sampling_frequency_{};
-  bool kernel_frames_{};
-  std::vector<int32_t> target_pid_;
-  std::vector<std::string> target_cmdline_;
-  std::vector<int32_t> exclude_pid_;
-  std::vector<std::string> exclude_cmdline_;
-  uint32_t additional_cmdline_count_{};
+  BeginFrameArgs_BeginFrameArgsType type_{};
+  uint64_t source_id_{};
+  uint64_t sequence_number_{};
+  int64_t frame_time_us_{};
+  int64_t deadline_us_{};
+  int64_t interval_delta_us_{};
+  bool on_critical_path_{};
+  bool animate_only_{};
+  uint64_t source_location_iid_{};
+  ::protozero::CopyablePtr<SourceLocation> source_location_;
+  int64_t frames_throttled_since_last_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<19> _has_field_{};
+  std::bitset<13> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT PerfEventConfig_CallstackSampling : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT BeginFrameObserverState : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kScopeFieldNumber = 1,
-    kKernelFramesFieldNumber = 2,
-    kUserFramesFieldNumber = 3,
+    kDroppedBeginFrameArgsFieldNumber = 1,
+    kLastBeginFrameArgsFieldNumber = 2,
   };
 
-  PerfEventConfig_CallstackSampling();
-  ~PerfEventConfig_CallstackSampling() override;
-  PerfEventConfig_CallstackSampling(PerfEventConfig_CallstackSampling&&) noexcept;
-  PerfEventConfig_CallstackSampling& operator=(PerfEventConfig_CallstackSampling&&);
-  PerfEventConfig_CallstackSampling(const PerfEventConfig_CallstackSampling&);
-  PerfEventConfig_CallstackSampling& operator=(const PerfEventConfig_CallstackSampling&);
-  bool operator==(const PerfEventConfig_CallstackSampling&) const;
-  bool operator!=(const PerfEventConfig_CallstackSampling& other) const { return !(*this == other); }
+  BeginFrameObserverState();
+  ~BeginFrameObserverState() override;
+  BeginFrameObserverState(BeginFrameObserverState&&) noexcept;
+  BeginFrameObserverState& operator=(BeginFrameObserverState&&);
+  BeginFrameObserverState(const BeginFrameObserverState&);
+  BeginFrameObserverState& operator=(const BeginFrameObserverState&);
+  bool operator==(const BeginFrameObserverState&) const;
+  bool operator!=(const BeginFrameObserverState& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_scope() const { return _has_field_[1]; }
-  const PerfEventConfig_Scope& scope() const { return *scope_; }
-  PerfEventConfig_Scope* mutable_scope() { _has_field_.set(1); return scope_.get(); }
-
-  bool has_kernel_frames() const { return _has_field_[2]; }
-  bool kernel_frames() const { return kernel_frames_; }
-  void set_kernel_frames(bool value) { kernel_frames_ = value; _has_field_.set(2); }
+  bool has_dropped_begin_frame_args() const { return _has_field_[1]; }
+  int64_t dropped_begin_frame_args() const { return dropped_begin_frame_args_; }
+  void set_dropped_begin_frame_args(int64_t value) { dropped_begin_frame_args_ = value; _has_field_.set(1); }
 
-  bool has_user_frames() const { return _has_field_[3]; }
-  PerfEventConfig_UnwindMode user_frames() const { return user_frames_; }
-  void set_user_frames(PerfEventConfig_UnwindMode value) { user_frames_ = value; _has_field_.set(3); }
+  bool has_last_begin_frame_args() const { return _has_field_[2]; }
+  const BeginFrameArgs& last_begin_frame_args() const { return *last_begin_frame_args_; }
+  BeginFrameArgs* mutable_last_begin_frame_args() { _has_field_.set(2); return last_begin_frame_args_.get(); }
 
  private:
-  ::protozero::CopyablePtr<PerfEventConfig_Scope> scope_;
-  bool kernel_frames_{};
-  PerfEventConfig_UnwindMode user_frames_{};
+  int64_t dropped_begin_frame_args_{};
+  ::protozero::CopyablePtr<BeginFrameArgs> last_begin_frame_args_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<4> _has_field_{};
+  std::bitset<3> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT PerfEventConfig_Scope : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT BeginImplFrameArgs : public ::protozero::CppMessageObj {
  public:
+  using TimestampsInUs = BeginImplFrameArgs_TimestampsInUs;
+  using State = BeginImplFrameArgs_State;
+  static constexpr auto BEGIN_FRAME_FINISHED = BeginImplFrameArgs_State_BEGIN_FRAME_FINISHED;
+  static constexpr auto BEGIN_FRAME_USING = BeginImplFrameArgs_State_BEGIN_FRAME_USING;
+  static constexpr auto State_MIN = BeginImplFrameArgs_State_BEGIN_FRAME_FINISHED;
+  static constexpr auto State_MAX = BeginImplFrameArgs_State_BEGIN_FRAME_USING;
   enum FieldNumbers {
-    kTargetPidFieldNumber = 1,
-    kTargetCmdlineFieldNumber = 2,
-    kExcludePidFieldNumber = 3,
-    kExcludeCmdlineFieldNumber = 4,
-    kAdditionalCmdlineCountFieldNumber = 5,
-    kProcessShardCountFieldNumber = 6,
+    kUpdatedAtUsFieldNumber = 1,
+    kFinishedAtUsFieldNumber = 2,
+    kStateFieldNumber = 3,
+    kCurrentArgsFieldNumber = 4,
+    kLastArgsFieldNumber = 5,
+    kTimestampsInUsFieldNumber = 6,
   };
 
-  PerfEventConfig_Scope();
-  ~PerfEventConfig_Scope() override;
-  PerfEventConfig_Scope(PerfEventConfig_Scope&&) noexcept;
-  PerfEventConfig_Scope& operator=(PerfEventConfig_Scope&&);
-  PerfEventConfig_Scope(const PerfEventConfig_Scope&);
-  PerfEventConfig_Scope& operator=(const PerfEventConfig_Scope&);
-  bool operator==(const PerfEventConfig_Scope&) const;
-  bool operator!=(const PerfEventConfig_Scope& other) const { return !(*this == other); }
+  BeginImplFrameArgs();
+  ~BeginImplFrameArgs() override;
+  BeginImplFrameArgs(BeginImplFrameArgs&&) noexcept;
+  BeginImplFrameArgs& operator=(BeginImplFrameArgs&&);
+  BeginImplFrameArgs(const BeginImplFrameArgs&);
+  BeginImplFrameArgs& operator=(const BeginImplFrameArgs&);
+  bool operator==(const BeginImplFrameArgs&) const;
+  bool operator!=(const BeginImplFrameArgs& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  const std::vector<int32_t>& target_pid() const { return target_pid_; }
-  std::vector<int32_t>* mutable_target_pid() { return &target_pid_; }
-  int target_pid_size() const { return static_cast<int>(target_pid_.size()); }
-  void clear_target_pid() { target_pid_.clear(); }
-  void add_target_pid(int32_t value) { target_pid_.emplace_back(value); }
-  int32_t* add_target_pid() { target_pid_.emplace_back(); return &target_pid_.back(); }
+  bool has_updated_at_us() const { return _has_field_[1]; }
+  int64_t updated_at_us() const { return updated_at_us_; }
+  void set_updated_at_us(int64_t value) { updated_at_us_ = value; _has_field_.set(1); }
 
-  const std::vector<std::string>& target_cmdline() const { return target_cmdline_; }
-  std::vector<std::string>* mutable_target_cmdline() { return &target_cmdline_; }
-  int target_cmdline_size() const { return static_cast<int>(target_cmdline_.size()); }
-  void clear_target_cmdline() { target_cmdline_.clear(); }
-  void add_target_cmdline(std::string value) { target_cmdline_.emplace_back(value); }
-  std::string* add_target_cmdline() { target_cmdline_.emplace_back(); return &target_cmdline_.back(); }
+  bool has_finished_at_us() const { return _has_field_[2]; }
+  int64_t finished_at_us() const { return finished_at_us_; }
+  void set_finished_at_us(int64_t value) { finished_at_us_ = value; _has_field_.set(2); }
 
-  const std::vector<int32_t>& exclude_pid() const { return exclude_pid_; }
-  std::vector<int32_t>* mutable_exclude_pid() { return &exclude_pid_; }
-  int exclude_pid_size() const { return static_cast<int>(exclude_pid_.size()); }
-  void clear_exclude_pid() { exclude_pid_.clear(); }
-  void add_exclude_pid(int32_t value) { exclude_pid_.emplace_back(value); }
-  int32_t* add_exclude_pid() { exclude_pid_.emplace_back(); return &exclude_pid_.back(); }
+  bool has_state() const { return _has_field_[3]; }
+  BeginImplFrameArgs_State state() const { return state_; }
+  void set_state(BeginImplFrameArgs_State value) { state_ = value; _has_field_.set(3); }
 
-  const std::vector<std::string>& exclude_cmdline() const { return exclude_cmdline_; }
-  std::vector<std::string>* mutable_exclude_cmdline() { return &exclude_cmdline_; }
-  int exclude_cmdline_size() const { return static_cast<int>(exclude_cmdline_.size()); }
-  void clear_exclude_cmdline() { exclude_cmdline_.clear(); }
-  void add_exclude_cmdline(std::string value) { exclude_cmdline_.emplace_back(value); }
-  std::string* add_exclude_cmdline() { exclude_cmdline_.emplace_back(); return &exclude_cmdline_.back(); }
+  bool has_current_args() const { return _has_field_[4]; }
+  const BeginFrameArgs& current_args() const { return *current_args_; }
+  BeginFrameArgs* mutable_current_args() { _has_field_.set(4); return current_args_.get(); }
 
-  bool has_additional_cmdline_count() const { return _has_field_[5]; }
-  uint32_t additional_cmdline_count() const { return additional_cmdline_count_; }
-  void set_additional_cmdline_count(uint32_t value) { additional_cmdline_count_ = value; _has_field_.set(5); }
+  bool has_last_args() const { return _has_field_[5]; }
+  const BeginFrameArgs& last_args() const { return *last_args_; }
+  BeginFrameArgs* mutable_last_args() { _has_field_.set(5); return last_args_.get(); }
 
-  bool has_process_shard_count() const { return _has_field_[6]; }
-  uint32_t process_shard_count() const { return process_shard_count_; }
-  void set_process_shard_count(uint32_t value) { process_shard_count_ = value; _has_field_.set(6); }
+  bool has_timestamps_in_us() const { return _has_field_[6]; }
+  const BeginImplFrameArgs_TimestampsInUs& timestamps_in_us() const { return *timestamps_in_us_; }
+  BeginImplFrameArgs_TimestampsInUs* mutable_timestamps_in_us() { _has_field_.set(6); return timestamps_in_us_.get(); }
 
  private:
-  std::vector<int32_t> target_pid_;
-  std::vector<std::string> target_cmdline_;
-  std::vector<int32_t> exclude_pid_;
-  std::vector<std::string> exclude_cmdline_;
-  uint32_t additional_cmdline_count_{};
-  uint32_t process_shard_count_{};
+  int64_t updated_at_us_{};
+  int64_t finished_at_us_{};
+  BeginImplFrameArgs_State state_{};
+  ::protozero::CopyablePtr<BeginFrameArgs> current_args_;
+  ::protozero::CopyablePtr<BeginFrameArgs> last_args_;
+  ::protozero::CopyablePtr<BeginImplFrameArgs_TimestampsInUs> timestamps_in_us_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
@@ -168899,1051 +189481,514 @@ class PERFETTO_EXPORT_COMPONENT PerfEventConfig_Scope : public ::protozero::CppM
   std::bitset<7> _has_field_{};
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_PROFILING_PERF_EVENT_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/statsd/atom_ids.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_ATOM_IDS_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_ATOM_IDS_PROTO_CPP_H_
+class PERFETTO_EXPORT_COMPONENT BeginImplFrameArgs_TimestampsInUs : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kIntervalDeltaFieldNumber = 1,
+    kNowToDeadlineDeltaFieldNumber = 2,
+    kFrameTimeToNowDeltaFieldNumber = 3,
+    kFrameTimeToDeadlineDeltaFieldNumber = 4,
+    kNowFieldNumber = 5,
+    kFrameTimeFieldNumber = 6,
+    kDeadlineFieldNumber = 7,
+  };
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  BeginImplFrameArgs_TimestampsInUs();
+  ~BeginImplFrameArgs_TimestampsInUs() override;
+  BeginImplFrameArgs_TimestampsInUs(BeginImplFrameArgs_TimestampsInUs&&) noexcept;
+  BeginImplFrameArgs_TimestampsInUs& operator=(BeginImplFrameArgs_TimestampsInUs&&);
+  BeginImplFrameArgs_TimestampsInUs(const BeginImplFrameArgs_TimestampsInUs&);
+  BeginImplFrameArgs_TimestampsInUs& operator=(const BeginImplFrameArgs_TimestampsInUs&);
+  bool operator==(const BeginImplFrameArgs_TimestampsInUs&) const;
+  bool operator!=(const BeginImplFrameArgs_TimestampsInUs& other) const { return !(*this == other); }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum AtomId : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  bool has_interval_delta() const { return _has_field_[1]; }
+  int64_t interval_delta() const { return interval_delta_; }
+  void set_interval_delta(int64_t value) { interval_delta_ = value; _has_field_.set(1); }
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  bool has_now_to_deadline_delta() const { return _has_field_[2]; }
+  int64_t now_to_deadline_delta() const { return now_to_deadline_delta_; }
+  void set_now_to_deadline_delta(int64_t value) { now_to_deadline_delta_ = value; _has_field_.set(2); }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum AtomId : int {
-  BLE_SCAN_STATE_CHANGED = 2,
-  PROCESS_STATE_CHANGED = 3,
-  BLE_SCAN_RESULT_RECEIVED = 4,
-  SENSOR_STATE_CHANGED = 5,
-  GPS_SCAN_STATE_CHANGED = 6,
-  SYNC_STATE_CHANGED = 7,
-  SCHEDULED_JOB_STATE_CHANGED = 8,
-  SCREEN_BRIGHTNESS_CHANGED = 9,
-  WAKELOCK_STATE_CHANGED = 10,
-  LONG_PARTIAL_WAKELOCK_STATE_CHANGED = 11,
-  MOBILE_RADIO_POWER_STATE_CHANGED = 12,
-  WIFI_RADIO_POWER_STATE_CHANGED = 13,
-  ACTIVITY_MANAGER_SLEEP_STATE_CHANGED = 14,
-  MEMORY_FACTOR_STATE_CHANGED = 15,
-  EXCESSIVE_CPU_USAGE_REPORTED = 16,
-  CACHED_KILL_REPORTED = 17,
-  PROCESS_MEMORY_STAT_REPORTED = 18,
-  LAUNCHER_EVENT = 19,
-  BATTERY_SAVER_MODE_STATE_CHANGED = 20,
-  DEVICE_IDLE_MODE_STATE_CHANGED = 21,
-  DEVICE_IDLING_MODE_STATE_CHANGED = 22,
-  AUDIO_STATE_CHANGED = 23,
-  MEDIA_CODEC_STATE_CHANGED = 24,
-  CAMERA_STATE_CHANGED = 25,
-  FLASHLIGHT_STATE_CHANGED = 26,
-  UID_PROCESS_STATE_CHANGED = 27,
-  PROCESS_LIFE_CYCLE_STATE_CHANGED = 28,
-  SCREEN_STATE_CHANGED = 29,
-  BATTERY_LEVEL_CHANGED = 30,
-  CHARGING_STATE_CHANGED = 31,
-  PLUGGED_STATE_CHANGED = 32,
-  INTERACTIVE_STATE_CHANGED = 33,
-  TOUCH_EVENT_REPORTED = 34,
-  WAKEUP_ALARM_OCCURRED = 35,
-  KERNEL_WAKEUP_REPORTED = 36,
-  WIFI_LOCK_STATE_CHANGED = 37,
-  WIFI_SIGNAL_STRENGTH_CHANGED = 38,
-  WIFI_SCAN_STATE_CHANGED = 39,
-  PHONE_SIGNAL_STRENGTH_CHANGED = 40,
-  SETTING_CHANGED = 41,
-  ACTIVITY_FOREGROUND_STATE_CHANGED = 42,
-  ISOLATED_UID_CHANGED = 43,
-  PACKET_WAKEUP_OCCURRED = 44,
-  WALL_CLOCK_TIME_SHIFTED = 45,
-  ANOMALY_DETECTED = 46,
-  APP_BREADCRUMB_REPORTED = 47,
-  APP_START_OCCURRED = 48,
-  APP_START_CANCELED = 49,
-  APP_START_FULLY_DRAWN = 50,
-  LMK_KILL_OCCURRED = 51,
-  PICTURE_IN_PICTURE_STATE_CHANGED = 52,
-  WIFI_MULTICAST_LOCK_STATE_CHANGED = 53,
-  LMK_STATE_CHANGED = 54,
-  APP_START_MEMORY_STATE_CAPTURED = 55,
-  SHUTDOWN_SEQUENCE_REPORTED = 56,
-  BOOT_SEQUENCE_REPORTED = 57,
-  DAVEY_OCCURRED = 58,
-  OVERLAY_STATE_CHANGED = 59,
-  FOREGROUND_SERVICE_STATE_CHANGED = 60,
-  CALL_STATE_CHANGED = 61,
-  KEYGUARD_STATE_CHANGED = 62,
-  KEYGUARD_BOUNCER_STATE_CHANGED = 63,
-  KEYGUARD_BOUNCER_PASSWORD_ENTERED = 64,
-  APP_DIED = 65,
-  RESOURCE_CONFIGURATION_CHANGED = 66,
-  BLUETOOTH_ENABLED_STATE_CHANGED = 67,
-  BLUETOOTH_CONNECTION_STATE_CHANGED = 68,
-  GPS_SIGNAL_QUALITY_CHANGED = 69,
-  USB_CONNECTOR_STATE_CHANGED = 70,
-  SPEAKER_IMPEDANCE_REPORTED = 71,
-  HARDWARE_FAILED = 72,
-  PHYSICAL_DROP_DETECTED = 73,
-  CHARGE_CYCLES_REPORTED = 74,
-  MOBILE_CONNECTION_STATE_CHANGED = 75,
-  MOBILE_RADIO_TECHNOLOGY_CHANGED = 76,
-  USB_DEVICE_ATTACHED = 77,
-  APP_CRASH_OCCURRED = 78,
-  ANR_OCCURRED = 79,
-  WTF_OCCURRED = 80,
-  LOW_MEM_REPORTED = 81,
-  GENERIC_ATOM = 82,
-  KEY_VALUE_PAIRS_ATOM = 83,
-  VIBRATOR_STATE_CHANGED = 84,
-  DEFERRED_JOB_STATS_REPORTED = 85,
-  THERMAL_THROTTLING = 86,
-  BIOMETRIC_ACQUIRED = 87,
-  BIOMETRIC_AUTHENTICATED = 88,
-  BIOMETRIC_ERROR_OCCURRED = 89,
-  UI_EVENT_REPORTED = 90,
-  BATTERY_HEALTH_SNAPSHOT = 91,
-  SLOW_IO = 92,
-  BATTERY_CAUSED_SHUTDOWN = 93,
-  PHONE_SERVICE_STATE_CHANGED = 94,
-  PHONE_STATE_CHANGED = 95,
-  USER_RESTRICTION_CHANGED = 96,
-  SETTINGS_UI_CHANGED = 97,
-  CONNECTIVITY_STATE_CHANGED = 98,
-  SERVICE_STATE_CHANGED = 99,
-  SERVICE_LAUNCH_REPORTED = 100,
-  FLAG_FLIP_UPDATE_OCCURRED = 101,
-  BINARY_PUSH_STATE_CHANGED = 102,
-  DEVICE_POLICY_EVENT = 103,
-  DOCS_UI_FILE_OP_CANCELED = 104,
-  DOCS_UI_FILE_OP_COPY_MOVE_MODE_REPORTED = 105,
-  DOCS_UI_FILE_OP_FAILURE = 106,
-  DOCS_UI_PROVIDER_FILE_OP = 107,
-  DOCS_UI_INVALID_SCOPED_ACCESS_REQUEST = 108,
-  DOCS_UI_LAUNCH_REPORTED = 109,
-  DOCS_UI_ROOT_VISITED = 110,
-  DOCS_UI_STARTUP_MS = 111,
-  DOCS_UI_USER_ACTION_REPORTED = 112,
-  WIFI_ENABLED_STATE_CHANGED = 113,
-  WIFI_RUNNING_STATE_CHANGED = 114,
-  APP_COMPACTED = 115,
-  NETWORK_DNS_EVENT_REPORTED = 116,
-  DOCS_UI_PICKER_LAUNCHED_FROM_REPORTED = 117,
-  DOCS_UI_PICK_RESULT_REPORTED = 118,
-  DOCS_UI_SEARCH_MODE_REPORTED = 119,
-  DOCS_UI_SEARCH_TYPE_REPORTED = 120,
-  DATA_STALL_EVENT = 121,
-  RESCUE_PARTY_RESET_REPORTED = 122,
-  SIGNED_CONFIG_REPORTED = 123,
-  GNSS_NI_EVENT_REPORTED = 124,
-  BLUETOOTH_LINK_LAYER_CONNECTION_EVENT = 125,
-  BLUETOOTH_ACL_CONNECTION_STATE_CHANGED = 126,
-  BLUETOOTH_SCO_CONNECTION_STATE_CHANGED = 127,
-  APP_DOWNGRADED = 128,
-  APP_OPTIMIZED_AFTER_DOWNGRADED = 129,
-  LOW_STORAGE_STATE_CHANGED = 130,
-  GNSS_NFW_NOTIFICATION_REPORTED = 131,
-  GNSS_CONFIGURATION_REPORTED = 132,
-  USB_PORT_OVERHEAT_EVENT_REPORTED = 133,
-  NFC_ERROR_OCCURRED = 134,
-  NFC_STATE_CHANGED = 135,
-  NFC_BEAM_OCCURRED = 136,
-  NFC_CARDEMULATION_OCCURRED = 137,
-  NFC_TAG_OCCURRED = 138,
-  NFC_HCE_TRANSACTION_OCCURRED = 139,
-  SE_STATE_CHANGED = 140,
-  SE_OMAPI_REPORTED = 141,
-  BROADCAST_DISPATCH_LATENCY_REPORTED = 142,
-  ATTENTION_MANAGER_SERVICE_RESULT_REPORTED = 143,
-  ADB_CONNECTION_CHANGED = 144,
-  SPEECH_DSP_STAT_REPORTED = 145,
-  USB_CONTAMINANT_REPORTED = 146,
-  WATCHDOG_ROLLBACK_OCCURRED = 147,
-  BIOMETRIC_SYSTEM_HEALTH_ISSUE_DETECTED = 148,
-  BUBBLE_UI_CHANGED = 149,
-  SCHEDULED_JOB_CONSTRAINT_CHANGED = 150,
-  BLUETOOTH_ACTIVE_DEVICE_CHANGED = 151,
-  BLUETOOTH_A2DP_PLAYBACK_STATE_CHANGED = 152,
-  BLUETOOTH_A2DP_CODEC_CONFIG_CHANGED = 153,
-  BLUETOOTH_A2DP_CODEC_CAPABILITY_CHANGED = 154,
-  BLUETOOTH_A2DP_AUDIO_UNDERRUN_REPORTED = 155,
-  BLUETOOTH_A2DP_AUDIO_OVERRUN_REPORTED = 156,
-  BLUETOOTH_DEVICE_RSSI_REPORTED = 157,
-  BLUETOOTH_DEVICE_FAILED_CONTACT_COUNTER_REPORTED = 158,
-  BLUETOOTH_DEVICE_TX_POWER_LEVEL_REPORTED = 159,
-  BLUETOOTH_HCI_TIMEOUT_REPORTED = 160,
-  BLUETOOTH_QUALITY_REPORT_REPORTED = 161,
-  BLUETOOTH_DEVICE_INFO_REPORTED = 162,
-  BLUETOOTH_REMOTE_VERSION_INFO_REPORTED = 163,
-  BLUETOOTH_SDP_ATTRIBUTE_REPORTED = 164,
-  BLUETOOTH_BOND_STATE_CHANGED = 165,
-  BLUETOOTH_CLASSIC_PAIRING_EVENT_REPORTED = 166,
-  BLUETOOTH_SMP_PAIRING_EVENT_REPORTED = 167,
-  SCREEN_TIMEOUT_EXTENSION_REPORTED = 168,
-  PROCESS_START_TIME = 169,
-  PERMISSION_GRANT_REQUEST_RESULT_REPORTED = 170,
-  BLUETOOTH_SOCKET_CONNECTION_STATE_CHANGED = 171,
-  DEVICE_IDENTIFIER_ACCESS_DENIED = 172,
-  BUBBLE_DEVELOPER_ERROR_REPORTED = 173,
-  ASSIST_GESTURE_STAGE_REPORTED = 174,
-  ASSIST_GESTURE_FEEDBACK_REPORTED = 175,
-  ASSIST_GESTURE_PROGRESS_REPORTED = 176,
-  TOUCH_GESTURE_CLASSIFIED = 177,
-  HIDDEN_API_USED = 178,
-  STYLE_UI_CHANGED = 179,
-  PRIVACY_INDICATORS_INTERACTED = 180,
-  APP_INSTALL_ON_EXTERNAL_STORAGE_REPORTED = 181,
-  NETWORK_STACK_REPORTED = 182,
-  APP_MOVED_STORAGE_REPORTED = 183,
-  BIOMETRIC_ENROLLED = 184,
-  SYSTEM_SERVER_WATCHDOG_OCCURRED = 185,
-  TOMB_STONE_OCCURRED = 186,
-  BLUETOOTH_CLASS_OF_DEVICE_REPORTED = 187,
-  INTELLIGENCE_EVENT_REPORTED = 188,
-  THERMAL_THROTTLING_SEVERITY_STATE_CHANGED = 189,
-  ROLE_REQUEST_RESULT_REPORTED = 190,
-  MEDIAMETRICS_AUDIOPOLICY_REPORTED = 191,
-  MEDIAMETRICS_AUDIORECORD_REPORTED = 192,
-  MEDIAMETRICS_AUDIOTHREAD_REPORTED = 193,
-  MEDIAMETRICS_AUDIOTRACK_REPORTED = 194,
-  MEDIAMETRICS_CODEC_REPORTED = 195,
-  MEDIAMETRICS_DRM_WIDEVINE_REPORTED = 196,
-  MEDIAMETRICS_EXTRACTOR_REPORTED = 197,
-  MEDIAMETRICS_MEDIADRM_REPORTED = 198,
-  MEDIAMETRICS_NUPLAYER_REPORTED = 199,
-  MEDIAMETRICS_RECORDER_REPORTED = 200,
-  MEDIAMETRICS_DRMMANAGER_REPORTED = 201,
-  CAR_POWER_STATE_CHANGED = 203,
-  GARAGE_MODE_INFO = 204,
-  TEST_ATOM_REPORTED = 205,
-  CONTENT_CAPTURE_CALLER_MISMATCH_REPORTED = 206,
-  CONTENT_CAPTURE_SERVICE_EVENTS = 207,
-  CONTENT_CAPTURE_SESSION_EVENTS = 208,
-  CONTENT_CAPTURE_FLUSHED = 209,
-  LOCATION_MANAGER_API_USAGE_REPORTED = 210,
-  REVIEW_PERMISSIONS_FRAGMENT_RESULT_REPORTED = 211,
-  RUNTIME_PERMISSIONS_UPGRADE_RESULT = 212,
-  GRANT_PERMISSIONS_ACTIVITY_BUTTON_ACTIONS = 213,
-  LOCATION_ACCESS_CHECK_NOTIFICATION_ACTION = 214,
-  APP_PERMISSION_FRAGMENT_ACTION_REPORTED = 215,
-  APP_PERMISSION_FRAGMENT_VIEWED = 216,
-  APP_PERMISSIONS_FRAGMENT_VIEWED = 217,
-  PERMISSION_APPS_FRAGMENT_VIEWED = 218,
-  TEXT_SELECTION_EVENT = 219,
-  TEXT_LINKIFY_EVENT = 220,
-  CONVERSATION_ACTIONS_EVENT = 221,
-  LANGUAGE_DETECTION_EVENT = 222,
-  EXCLUSION_RECT_STATE_CHANGED = 223,
-  BACK_GESTURE_REPORTED_REPORTED = 224,
-  UPDATE_ENGINE_UPDATE_ATTEMPT_REPORTED = 225,
-  UPDATE_ENGINE_SUCCESSFUL_UPDATE_REPORTED = 226,
-  CAMERA_ACTION_EVENT = 227,
-  APP_COMPATIBILITY_CHANGE_REPORTED = 228,
-  PERFETTO_UPLOADED = 229,
-  VMS_CLIENT_CONNECTION_STATE_CHANGED = 230,
-  MEDIA_PROVIDER_SCAN_OCCURRED = 233,
-  MEDIA_CONTENT_DELETED = 234,
-  MEDIA_PROVIDER_PERMISSION_REQUESTED = 235,
-  MEDIA_PROVIDER_SCHEMA_CHANGED = 236,
-  MEDIA_PROVIDER_IDLE_MAINTENANCE_FINISHED = 237,
-  REBOOT_ESCROW_RECOVERY_REPORTED = 238,
-  BOOT_TIME_EVENT_DURATION_REPORTED = 239,
-  BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED = 240,
-  BOOT_TIME_EVENT_UTC_TIME_REPORTED = 241,
-  BOOT_TIME_EVENT_ERROR_CODE_REPORTED = 242,
-  USERSPACE_REBOOT_REPORTED = 243,
-  NOTIFICATION_REPORTED = 244,
-  NOTIFICATION_PANEL_REPORTED = 245,
-  NOTIFICATION_CHANNEL_MODIFIED = 246,
-  INTEGRITY_CHECK_RESULT_REPORTED = 247,
-  INTEGRITY_RULES_PUSHED = 248,
-  CB_MESSAGE_REPORTED = 249,
-  CB_MESSAGE_ERROR = 250,
-  WIFI_HEALTH_STAT_REPORTED = 251,
-  WIFI_FAILURE_STAT_REPORTED = 252,
-  WIFI_CONNECTION_RESULT_REPORTED = 253,
-  APP_FREEZE_CHANGED = 254,
-  SNAPSHOT_MERGE_REPORTED = 255,
-  FOREGROUND_SERVICE_APP_OP_SESSION_ENDED = 256,
-  DISPLAY_JANK_REPORTED = 257,
-  APP_STANDBY_BUCKET_CHANGED = 258,
-  SHARESHEET_STARTED = 259,
-  RANKING_SELECTED = 260,
-  TVSETTINGS_UI_INTERACTED = 261,
-  LAUNCHER_SNAPSHOT = 262,
-  PACKAGE_INSTALLER_V2_REPORTED = 263,
-  USER_LIFECYCLE_JOURNEY_REPORTED = 264,
-  USER_LIFECYCLE_EVENT_OCCURRED = 265,
-  ACCESSIBILITY_SHORTCUT_REPORTED = 266,
-  ACCESSIBILITY_SERVICE_REPORTED = 267,
-  DOCS_UI_DRAG_AND_DROP_REPORTED = 268,
-  APP_USAGE_EVENT_OCCURRED = 269,
-  AUTO_REVOKE_NOTIFICATION_CLICKED = 270,
-  AUTO_REVOKE_FRAGMENT_APP_VIEWED = 271,
-  AUTO_REVOKED_APP_INTERACTION = 272,
-  APP_PERMISSION_GROUPS_FRAGMENT_AUTO_REVOKE_ACTION = 273,
-  EVS_USAGE_STATS_REPORTED = 274,
-  AUDIO_POWER_USAGE_DATA_REPORTED = 275,
-  TV_TUNER_STATE_CHANGED = 276,
-  MEDIAOUTPUT_OP_SWITCH_REPORTED = 277,
-  CB_MESSAGE_FILTERED = 278,
-  TV_TUNER_DVR_STATUS = 279,
-  TV_CAS_SESSION_OPEN_STATUS = 280,
-  ASSISTANT_INVOCATION_REPORTED = 281,
-  DISPLAY_WAKE_REPORTED = 282,
-  CAR_USER_HAL_MODIFY_USER_REQUEST_REPORTED = 283,
-  CAR_USER_HAL_MODIFY_USER_RESPONSE_REPORTED = 284,
-  CAR_USER_HAL_POST_SWITCH_RESPONSE_REPORTED = 285,
-  CAR_USER_HAL_INITIAL_USER_INFO_REQUEST_REPORTED = 286,
-  CAR_USER_HAL_INITIAL_USER_INFO_RESPONSE_REPORTED = 287,
-  CAR_USER_HAL_USER_ASSOCIATION_REQUEST_REPORTED = 288,
-  CAR_USER_HAL_SET_USER_ASSOCIATION_RESPONSE_REPORTED = 289,
-  NETWORK_IP_PROVISIONING_REPORTED = 290,
-  NETWORK_DHCP_RENEW_REPORTED = 291,
-  NETWORK_VALIDATION_REPORTED = 292,
-  NETWORK_STACK_QUIRK_REPORTED = 293,
-  MEDIAMETRICS_AUDIORECORDDEVICEUSAGE_REPORTED = 294,
-  MEDIAMETRICS_AUDIOTHREADDEVICEUSAGE_REPORTED = 295,
-  MEDIAMETRICS_AUDIOTRACKDEVICEUSAGE_REPORTED = 296,
-  MEDIAMETRICS_AUDIODEVICECONNECTION_REPORTED = 297,
-  BLOB_COMMITTED = 298,
-  BLOB_LEASED = 299,
-  BLOB_OPENED = 300,
-  CONTACTS_PROVIDER_STATUS_REPORTED = 301,
-  KEYSTORE_KEY_EVENT_REPORTED = 302,
-  NETWORK_TETHERING_REPORTED = 303,
-  IME_TOUCH_REPORTED = 304,
-  UI_INTERACTION_FRAME_INFO_REPORTED = 305,
-  UI_ACTION_LATENCY_REPORTED = 306,
-  WIFI_DISCONNECT_REPORTED = 307,
-  WIFI_CONNECTION_STATE_CHANGED = 308,
-  HDMI_CEC_ACTIVE_SOURCE_CHANGED = 309,
-  HDMI_CEC_MESSAGE_REPORTED = 310,
-  AIRPLANE_MODE = 311,
-  MODEM_RESTART = 312,
-  CARRIER_ID_MISMATCH_REPORTED = 313,
-  CARRIER_ID_TABLE_UPDATED = 314,
-  DATA_STALL_RECOVERY_REPORTED = 315,
-  MEDIAMETRICS_MEDIAPARSER_REPORTED = 316,
-  TLS_HANDSHAKE_REPORTED = 317,
-  TEXT_CLASSIFIER_API_USAGE_REPORTED = 318,
-  CAR_WATCHDOG_KILL_STATS_REPORTED = 319,
-  MEDIAMETRICS_PLAYBACK_REPORTED = 320,
-  MEDIA_NETWORK_INFO_CHANGED = 321,
-  MEDIA_PLAYBACK_STATE_CHANGED = 322,
-  MEDIA_PLAYBACK_ERROR_REPORTED = 323,
-  MEDIA_PLAYBACK_TRACK_CHANGED = 324,
-  WIFI_SCAN_REPORTED = 325,
-  WIFI_PNO_SCAN_REPORTED = 326,
-  TIF_TUNE_CHANGED = 327,
-  AUTO_ROTATE_REPORTED = 328,
-  PERFETTO_TRIGGER = 329,
-  TRANSCODING_DATA = 330,
-  IMS_SERVICE_ENTITLEMENT_UPDATED = 331,
-  ART_DATUM_REPORTED = 332,
-  DEVICE_ROTATED = 333,
-  SIM_SPECIFIC_SETTINGS_RESTORED = 334,
-  PIN_STORAGE_EVENT = 336,
-  FACE_DOWN_REPORTED = 337,
-  BLUETOOTH_HAL_CRASH_REASON_REPORTED = 338,
-  REBOOT_ESCROW_PREPARATION_REPORTED = 339,
-  REBOOT_ESCROW_LSKF_CAPTURE_REPORTED = 340,
-  REBOOT_ESCROW_REBOOT_REPORTED = 341,
-  BINDER_LATENCY_REPORTED = 342,
-  MEDIAMETRICS_AAUDIOSTREAM_REPORTED = 343,
-  MEDIA_TRANSCODING_SESSION_ENDED = 344,
-  MAGNIFICATION_USAGE_REPORTED = 345,
-  MAGNIFICATION_MODE_WITH_IME_ON_REPORTED = 346,
-  APP_SEARCH_CALL_STATS_REPORTED = 347,
-  APP_SEARCH_PUT_DOCUMENT_STATS_REPORTED = 348,
-  DEVICE_CONTROL_CHANGED = 349,
-  DEVICE_STATE_CHANGED = 350,
-  INPUTDEVICE_REGISTERED = 351,
-  SMARTSPACE_CARD_REPORTED = 352,
-  AUTH_PROMPT_AUTHENTICATE_INVOKED = 353,
-  AUTH_MANAGER_CAN_AUTHENTICATE_INVOKED = 354,
-  AUTH_ENROLL_ACTION_INVOKED = 355,
-  AUTH_DEPRECATED_API_USED = 356,
-  UNATTENDED_REBOOT_OCCURRED = 357,
-  LONG_REBOOT_BLOCKING_REPORTED = 358,
-  LOCATION_TIME_ZONE_PROVIDER_STATE_CHANGED = 359,
-  FDTRACK_EVENT_OCCURRED = 364,
-  TIMEOUT_AUTO_EXTENDED_REPORTED = 365,
-  ODREFRESH_REPORTED = 366,
-  ALARM_BATCH_DELIVERED = 367,
-  ALARM_SCHEDULED = 368,
-  CAR_WATCHDOG_IO_OVERUSE_STATS_REPORTED = 369,
-  USER_LEVEL_HIBERNATION_STATE_CHANGED = 370,
-  APP_SEARCH_INITIALIZE_STATS_REPORTED = 371,
-  APP_SEARCH_QUERY_STATS_REPORTED = 372,
-  APP_PROCESS_DIED = 373,
-  NETWORK_IP_REACHABILITY_MONITOR_REPORTED = 374,
-  SLOW_INPUT_EVENT_REPORTED = 375,
-  ANR_OCCURRED_PROCESSING_STARTED = 376,
-  APP_SEARCH_REMOVE_STATS_REPORTED = 377,
-  MEDIA_CODEC_REPORTED = 378,
-  PERMISSION_USAGE_FRAGMENT_INTERACTION = 379,
-  PERMISSION_DETAILS_INTERACTION = 380,
-  PRIVACY_SENSOR_TOGGLE_INTERACTION = 381,
-  PRIVACY_TOGGLE_DIALOG_INTERACTION = 382,
-  APP_SEARCH_OPTIMIZE_STATS_REPORTED = 383,
-  APP_COMPAT_STATE_CHANGED = 386,
-  SIZE_COMPAT_RESTART_BUTTON_EVENT_REPORTED = 387,
-  SPLITSCREEN_UI_CHANGED = 388,
-  BLUETOOTH_CODE_PATH_COUNTER = 390,
-  BLUETOOTH_LE_BATCH_SCAN_REPORT_DELAY = 392,
-  ACCESSIBILITY_FLOATING_MENU_UI_CHANGED = 393,
-  NEURALNETWORKS_COMPILATION_COMPLETED = 394,
-  NEURALNETWORKS_EXECUTION_COMPLETED = 395,
-  NEURALNETWORKS_COMPILATION_FAILED = 396,
-  NEURALNETWORKS_EXECUTION_FAILED = 397,
-  VM_CREATION_REQUESTED = 409,
-  CAMERA_COMPAT_CONTROL_EVENT_REPORTED = 411,
-  TRACING_SERVICE_REPORT_EVENT = 424,
-  EARLY_BOOT_COMP_OS_ARTIFACTS_CHECK_REPORTED = 419,
-  ISOLATED_COMPILATION_SCHEDULED = 457,
-  ISOLATED_COMPILATION_ENDED = 458,
-  TELEPHONY_ANOMALY_DETECTED = 461,
-  HOTWORD_DETECTOR_CREATE_REQUESTED = 430,
-  HOTWORD_DETECTION_SERVICE_INIT_RESULT_REPORTED = 431,
-  HOTWORD_DETECTION_SERVICE_RESTARTED = 432,
-  HOTWORD_DETECTOR_KEYPHRASE_TRIGGERED = 433,
-  HOTWORD_DETECTOR_EVENTS = 434,
-  REMOTE_KEY_PROVISIONING_ATTEMPT = 463,
-  REMOTE_KEY_PROVISIONING_NETWORK_INFO = 464,
-  REMOTE_KEY_PROVISIONING_TIMING = 465,
-  WIFI_BYTES_TRANSFER = 10000,
-  WIFI_BYTES_TRANSFER_BY_FG_BG = 10001,
-  MOBILE_BYTES_TRANSFER = 10002,
-  MOBILE_BYTES_TRANSFER_BY_FG_BG = 10003,
-  BLUETOOTH_BYTES_TRANSFER = 10006,
-  KERNEL_WAKELOCK = 10004,
-  SUBSYSTEM_SLEEP_STATE = 10005,
-  CPU_TIME_PER_UID = 10009,
-  CPU_TIME_PER_UID_FREQ = 10010,
-  WIFI_ACTIVITY_INFO = 10011,
-  MODEM_ACTIVITY_INFO = 10012,
-  BLUETOOTH_ACTIVITY_INFO = 10007,
-  PROCESS_MEMORY_STATE = 10013,
-  SYSTEM_ELAPSED_REALTIME = 10014,
-  SYSTEM_UPTIME = 10015,
-  CPU_ACTIVE_TIME = 10016,
-  CPU_CLUSTER_TIME = 10017,
-  DISK_SPACE = 10018,
-  REMAINING_BATTERY_CAPACITY = 10019,
-  FULL_BATTERY_CAPACITY = 10020,
-  TEMPERATURE = 10021,
-  BINDER_CALLS = 10022,
-  BINDER_CALLS_EXCEPTIONS = 10023,
-  LOOPER_STATS = 10024,
-  DISK_STATS = 10025,
-  DIRECTORY_USAGE = 10026,
-  APP_SIZE = 10027,
-  CATEGORY_SIZE = 10028,
-  PROC_STATS = 10029,
-  BATTERY_VOLTAGE = 10030,
-  NUM_FINGERPRINTS_ENROLLED = 10031,
-  DISK_IO = 10032,
-  POWER_PROFILE = 10033,
-  PROC_STATS_PKG_PROC = 10034,
-  PROCESS_CPU_TIME = 10035,
-  CPU_TIME_PER_THREAD_FREQ = 10037,
-  ON_DEVICE_POWER_MEASUREMENT = 10038,
-  DEVICE_CALCULATED_POWER_USE = 10039,
-  DEVICE_CALCULATED_POWER_BLAME_UID = 10040,
-  DEVICE_CALCULATED_POWER_BLAME_OTHER = 10041,
-  PROCESS_MEMORY_HIGH_WATER_MARK = 10042,
-  BATTERY_LEVEL = 10043,
-  BUILD_INFORMATION = 10044,
-  BATTERY_CYCLE_COUNT = 10045,
-  DEBUG_ELAPSED_CLOCK = 10046,
-  DEBUG_FAILING_ELAPSED_CLOCK = 10047,
-  NUM_FACES_ENROLLED = 10048,
-  ROLE_HOLDER = 10049,
-  DANGEROUS_PERMISSION_STATE = 10050,
-  TRAIN_INFO = 10051,
-  TIME_ZONE_DATA_INFO = 10052,
-  EXTERNAL_STORAGE_INFO = 10053,
-  GPU_STATS_GLOBAL_INFO = 10054,
-  GPU_STATS_APP_INFO = 10055,
-  SYSTEM_ION_HEAP_SIZE = 10056,
-  APPS_ON_EXTERNAL_STORAGE_INFO = 10057,
-  FACE_SETTINGS = 10058,
-  COOLING_DEVICE = 10059,
-  APP_OPS = 10060,
-  PROCESS_SYSTEM_ION_HEAP_SIZE = 10061,
-  SURFACEFLINGER_STATS_GLOBAL_INFO = 10062,
-  SURFACEFLINGER_STATS_LAYER_INFO = 10063,
-  PROCESS_MEMORY_SNAPSHOT = 10064,
-  VMS_CLIENT_STATS = 10065,
-  NOTIFICATION_REMOTE_VIEWS = 10066,
-  DANGEROUS_PERMISSION_STATE_SAMPLED = 10067,
-  GRAPHICS_STATS = 10068,
-  RUNTIME_APP_OP_ACCESS = 10069,
-  ION_HEAP_SIZE = 10070,
-  PACKAGE_NOTIFICATION_PREFERENCES = 10071,
-  PACKAGE_NOTIFICATION_CHANNEL_PREFERENCES = 10072,
-  PACKAGE_NOTIFICATION_CHANNEL_GROUP_PREFERENCES = 10073,
-  GNSS_STATS = 10074,
-  ATTRIBUTED_APP_OPS = 10075,
-  VOICE_CALL_SESSION = 10076,
-  VOICE_CALL_RAT_USAGE = 10077,
-  SIM_SLOT_STATE = 10078,
-  SUPPORTED_RADIO_ACCESS_FAMILY = 10079,
-  SETTING_SNAPSHOT = 10080,
-  BLOB_INFO = 10081,
-  DATA_USAGE_BYTES_TRANSFER = 10082,
-  BYTES_TRANSFER_BY_TAG_AND_METERED = 10083,
-  DND_MODE_RULE = 10084,
-  GENERAL_EXTERNAL_STORAGE_ACCESS_STATS = 10085,
-  INCOMING_SMS = 10086,
-  OUTGOING_SMS = 10087,
-  CARRIER_ID_TABLE_VERSION = 10088,
-  DATA_CALL_SESSION = 10089,
-  CELLULAR_SERVICE_STATE = 10090,
-  CELLULAR_DATA_SERVICE_SWITCH = 10091,
-  SYSTEM_MEMORY = 10092,
-  IMS_REGISTRATION_TERMINATION = 10093,
-  IMS_REGISTRATION_STATS = 10094,
-  CPU_TIME_PER_CLUSTER_FREQ = 10095,
-  CPU_CYCLES_PER_UID_CLUSTER = 10096,
-  DEVICE_ROTATED_DATA = 10097,
-  CPU_CYCLES_PER_THREAD_GROUP_CLUSTER = 10098,
-  MEDIA_DRM_ACTIVITY_INFO = 10099,
-  OEM_MANAGED_BYTES_TRANSFER = 10100,
-  GNSS_POWER_STATS = 10101,
-  TIME_ZONE_DETECTOR_STATE = 10102,
-  KEYSTORE2_STORAGE_STATS = 10103,
-  RKP_POOL_STATS = 10104,
-  PROCESS_DMABUF_MEMORY = 10105,
-  PENDING_ALARM_INFO = 10106,
-  USER_LEVEL_HIBERNATED_APPS = 10107,
-  LAUNCHER_LAYOUT_SNAPSHOT = 10108,
-  GLOBAL_HIBERNATED_APPS = 10109,
-  INPUT_EVENT_LATENCY_SKETCH = 10110,
-  BATTERY_USAGE_STATS_BEFORE_RESET = 10111,
-  BATTERY_USAGE_STATS_SINCE_RESET = 10112,
-  BATTERY_USAGE_STATS_SINCE_RESET_USING_POWER_PROFILE_MODEL = 10113,
-  INSTALLED_INCREMENTAL_PACKAGE = 10114,
-  TELEPHONY_NETWORK_REQUESTS = 10115,
-  APP_SEARCH_STORAGE_INFO = 10116,
-  VMSTAT = 10117,
-  KEYSTORE2_KEY_CREATION_WITH_GENERAL_INFO = 10118,
-  KEYSTORE2_KEY_CREATION_WITH_AUTH_INFO = 10119,
-  KEYSTORE2_KEY_CREATION_WITH_PURPOSE_AND_MODES_INFO = 10120,
-  KEYSTORE2_ATOM_WITH_OVERFLOW = 10121,
-  KEYSTORE2_KEY_OPERATION_WITH_PURPOSE_AND_MODES_INFO = 10122,
-  KEYSTORE2_KEY_OPERATION_WITH_GENERAL_INFO = 10123,
-  RKP_ERROR_STATS = 10124,
-  KEYSTORE2_CRASH_STATS = 10125,
-  ACCESSIBILITY_SHORTCUT_STATS = 10127,
-  ACCESSIBILITY_FLOATING_MENU_STATS = 10128,
-  CAR_WATCHDOG_SYSTEM_IO_USAGE_SUMMARY = 10131,
-  CAR_WATCHDOG_UID_IO_USAGE_SUMMARY = 10132,
-  IMS_REGISTRATION_FEATURE_TAG_STATS = 10133,
-  RCS_CLIENT_PROVISIONING_STATS = 10134,
-  RCS_ACS_PROVISIONING_STATS = 10135,
-  SIP_DELEGATE_STATS = 10136,
-  SIP_TRANSPORT_FEATURE_TAG_STATS = 10137,
-  SIP_MESSAGE_RESPONSE = 10138,
-  SIP_TRANSPORT_SESSION = 10139,
-  IMS_DEDICATED_BEARER_LISTENER_EVENT = 10140,
-  IMS_DEDICATED_BEARER_EVENT = 10141,
-  IMS_REGISTRATION_SERVICE_DESC_STATS = 10142,
-  UCE_EVENT_STATS = 10143,
-  PRESENCE_NOTIFY_EVENT = 10144,
-  GBA_EVENT = 10145,
-  REMOTE_KEY_PROVISIONING_ERROR_COUNTS = 10155,
-};
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  bool has_frame_time_to_now_delta() const { return _has_field_[3]; }
+  int64_t frame_time_to_now_delta() const { return frame_time_to_now_delta_; }
+  void set_frame_time_to_now_delta(int64_t value) { frame_time_to_now_delta_ = value; _has_field_.set(3); }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_ATOM_IDS_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/statsd/statsd_tracing_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_STATSD_TRACING_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_STATSD_TRACING_CONFIG_PROTO_CPP_H_
+  bool has_frame_time_to_deadline_delta() const { return _has_field_[4]; }
+  int64_t frame_time_to_deadline_delta() const { return frame_time_to_deadline_delta_; }
+  void set_frame_time_to_deadline_delta(int64_t value) { frame_time_to_deadline_delta_ = value; _has_field_.set(4); }
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  bool has_now() const { return _has_field_[5]; }
+  int64_t now() const { return now_; }
+  void set_now(int64_t value) { now_ = value; _has_field_.set(5); }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  bool has_frame_time() const { return _has_field_[6]; }
+  int64_t frame_time() const { return frame_time_; }
+  void set_frame_time(int64_t value) { frame_time_ = value; _has_field_.set(6); }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class StatsdPullAtomConfig;
-class StatsdTracingConfig;
-enum AtomId : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  bool has_deadline() const { return _has_field_[7]; }
+  int64_t deadline() const { return deadline_; }
+  void set_deadline(int64_t value) { deadline_ = value; _has_field_.set(7); }
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+ private:
+  int64_t interval_delta_{};
+  int64_t now_to_deadline_delta_{};
+  int64_t frame_time_to_now_delta_{};
+  int64_t frame_time_to_deadline_delta_{};
+  int64_t now_{};
+  int64_t frame_time_{};
+  int64_t deadline_{};
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-class PERFETTO_EXPORT_COMPONENT StatsdPullAtomConfig : public ::protozero::CppMessageObj {
+  std::bitset<8> _has_field_{};
+};
+
+
+class PERFETTO_EXPORT_COMPONENT ChromeCompositorStateMachine : public ::protozero::CppMessageObj {
  public:
+  using MajorState = ChromeCompositorStateMachine_MajorState;
+  using MinorState = ChromeCompositorStateMachine_MinorState;
   enum FieldNumbers {
-    kPullAtomIdFieldNumber = 1,
-    kRawPullAtomIdFieldNumber = 2,
-    kPullFrequencyMsFieldNumber = 3,
-    kPackagesFieldNumber = 4,
+    kMajorStateFieldNumber = 1,
+    kMinorStateFieldNumber = 2,
   };
 
-  StatsdPullAtomConfig();
-  ~StatsdPullAtomConfig() override;
-  StatsdPullAtomConfig(StatsdPullAtomConfig&&) noexcept;
-  StatsdPullAtomConfig& operator=(StatsdPullAtomConfig&&);
-  StatsdPullAtomConfig(const StatsdPullAtomConfig&);
-  StatsdPullAtomConfig& operator=(const StatsdPullAtomConfig&);
-  bool operator==(const StatsdPullAtomConfig&) const;
-  bool operator!=(const StatsdPullAtomConfig& other) const { return !(*this == other); }
+  ChromeCompositorStateMachine();
+  ~ChromeCompositorStateMachine() override;
+  ChromeCompositorStateMachine(ChromeCompositorStateMachine&&) noexcept;
+  ChromeCompositorStateMachine& operator=(ChromeCompositorStateMachine&&);
+  ChromeCompositorStateMachine(const ChromeCompositorStateMachine&);
+  ChromeCompositorStateMachine& operator=(const ChromeCompositorStateMachine&);
+  bool operator==(const ChromeCompositorStateMachine&) const;
+  bool operator!=(const ChromeCompositorStateMachine& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  const std::vector<AtomId>& pull_atom_id() const { return pull_atom_id_; }
-  std::vector<AtomId>* mutable_pull_atom_id() { return &pull_atom_id_; }
-  int pull_atom_id_size() const { return static_cast<int>(pull_atom_id_.size()); }
-  void clear_pull_atom_id() { pull_atom_id_.clear(); }
-  void add_pull_atom_id(AtomId value) { pull_atom_id_.emplace_back(value); }
-  AtomId* add_pull_atom_id() { pull_atom_id_.emplace_back(); return &pull_atom_id_.back(); }
-
-  const std::vector<int32_t>& raw_pull_atom_id() const { return raw_pull_atom_id_; }
-  std::vector<int32_t>* mutable_raw_pull_atom_id() { return &raw_pull_atom_id_; }
-  int raw_pull_atom_id_size() const { return static_cast<int>(raw_pull_atom_id_.size()); }
-  void clear_raw_pull_atom_id() { raw_pull_atom_id_.clear(); }
-  void add_raw_pull_atom_id(int32_t value) { raw_pull_atom_id_.emplace_back(value); }
-  int32_t* add_raw_pull_atom_id() { raw_pull_atom_id_.emplace_back(); return &raw_pull_atom_id_.back(); }
-
-  bool has_pull_frequency_ms() const { return _has_field_[3]; }
-  int32_t pull_frequency_ms() const { return pull_frequency_ms_; }
-  void set_pull_frequency_ms(int32_t value) { pull_frequency_ms_ = value; _has_field_.set(3); }
+  bool has_major_state() const { return _has_field_[1]; }
+  const ChromeCompositorStateMachine_MajorState& major_state() const { return *major_state_; }
+  ChromeCompositorStateMachine_MajorState* mutable_major_state() { _has_field_.set(1); return major_state_.get(); }
 
-  const std::vector<std::string>& packages() const { return packages_; }
-  std::vector<std::string>* mutable_packages() { return &packages_; }
-  int packages_size() const { return static_cast<int>(packages_.size()); }
-  void clear_packages() { packages_.clear(); }
-  void add_packages(std::string value) { packages_.emplace_back(value); }
-  std::string* add_packages() { packages_.emplace_back(); return &packages_.back(); }
+  bool has_minor_state() const { return _has_field_[2]; }
+  const ChromeCompositorStateMachine_MinorState& minor_state() const { return *minor_state_; }
+  ChromeCompositorStateMachine_MinorState* mutable_minor_state() { _has_field_.set(2); return minor_state_.get(); }
 
  private:
-  std::vector<AtomId> pull_atom_id_;
-  std::vector<int32_t> raw_pull_atom_id_;
-  int32_t pull_frequency_ms_{};
-  std::vector<std::string> packages_;
+  ::protozero::CopyablePtr<ChromeCompositorStateMachine_MajorState> major_state_;
+  ::protozero::CopyablePtr<ChromeCompositorStateMachine_MinorState> minor_state_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<5> _has_field_{};
+  std::bitset<3> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT StatsdTracingConfig : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT ChromeCompositorStateMachine_MinorState : public ::protozero::CppMessageObj {
  public:
+  using TreePriority = ChromeCompositorStateMachine_MinorState_TreePriority;
+  static constexpr auto TREE_PRIORITY_UNSPECIFIED = ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_UNSPECIFIED;
+  static constexpr auto TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES = ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES;
+  static constexpr auto TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY = ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY;
+  static constexpr auto TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY = ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY;
+  static constexpr auto TreePriority_MIN = ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_UNSPECIFIED;
+  static constexpr auto TreePriority_MAX = ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY;
+  using ScrollHandlerState = ChromeCompositorStateMachine_MinorState_ScrollHandlerState;
+  static constexpr auto SCROLL_HANDLER_UNSPECIFIED = ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_HANDLER_UNSPECIFIED;
+  static constexpr auto SCROLL_AFFECTS_SCROLL_HANDLER = ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_AFFECTS_SCROLL_HANDLER;
+  static constexpr auto SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER = ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER;
+  static constexpr auto ScrollHandlerState_MIN = ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_HANDLER_UNSPECIFIED;
+  static constexpr auto ScrollHandlerState_MAX = ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER;
   enum FieldNumbers {
-    kPushAtomIdFieldNumber = 1,
-    kRawPushAtomIdFieldNumber = 2,
-    kPullConfigFieldNumber = 3,
+    kCommitCountFieldNumber = 1,
+    kCurrentFrameNumberFieldNumber = 2,
+    kLastFrameNumberSubmitPerformedFieldNumber = 3,
+    kLastFrameNumberDrawPerformedFieldNumber = 4,
+    kLastFrameNumberBeginMainFrameSentFieldNumber = 5,
+    kDidDrawFieldNumber = 6,
+    kDidSendBeginMainFrameForCurrentFrameFieldNumber = 7,
+    kDidNotifyBeginMainFrameNotExpectedUntilFieldNumber = 8,
+    kDidNotifyBeginMainFrameNotExpectedSoonFieldNumber = 9,
+    kWantsBeginMainFrameNotExpectedFieldNumber = 10,
+    kDidCommitDuringFrameFieldNumber = 11,
+    kDidInvalidateLayerTreeFrameSinkFieldNumber = 12,
+    kDidPerformImplSideInvalidaionFieldNumber = 13,
+    kDidPrepareTilesFieldNumber = 14,
+    kConsecutiveCheckerboardAnimationsFieldNumber = 15,
+    kPendingSubmitFramesFieldNumber = 16,
+    kSubmitFramesWithCurrentLayerTreeFrameSinkFieldNumber = 17,
+    kNeedsRedrawFieldNumber = 18,
+    kNeedsPrepareTilesFieldNumber = 19,
+    kNeedsBeginMainFrameFieldNumber = 20,
+    kNeedsOneBeginImplFrameFieldNumber = 21,
+    kVisibleFieldNumber = 22,
+    kBeginFrameSourcePausedFieldNumber = 23,
+    kCanDrawFieldNumber = 24,
+    kResourcelessDrawFieldNumber = 25,
+    kHasPendingTreeFieldNumber = 26,
+    kPendingTreeIsReadyForActivationFieldNumber = 27,
+    kActiveTreeNeedsFirstDrawFieldNumber = 28,
+    kActiveTreeIsReadyToDrawFieldNumber = 29,
+    kDidCreateAndInitializeFirstLayerTreeFrameSinkFieldNumber = 30,
+    kTreePriorityFieldNumber = 31,
+    kScrollHandlerStateFieldNumber = 32,
+    kCriticalBeginMainFrameToActivateIsFastFieldNumber = 33,
+    kMainThreadMissedLastDeadlineFieldNumber = 34,
+    kVideoNeedsBeginFramesFieldNumber = 36,
+    kDeferBeginMainFrameFieldNumber = 37,
+    kLastCommitHadNoUpdatesFieldNumber = 38,
+    kDidDrawInLastFrameFieldNumber = 39,
+    kDidSubmitInLastFrameFieldNumber = 40,
+    kNeedsImplSideInvalidationFieldNumber = 41,
+    kCurrentPendingTreeIsImplSideFieldNumber = 42,
+    kPreviousPendingTreeWasImplSideFieldNumber = 43,
+    kProcessingAnimationWorkletsForActiveTreeFieldNumber = 44,
+    kProcessingAnimationWorkletsForPendingTreeFieldNumber = 45,
+    kProcessingPaintWorkletsForPendingTreeFieldNumber = 46,
   };
 
-  StatsdTracingConfig();
-  ~StatsdTracingConfig() override;
-  StatsdTracingConfig(StatsdTracingConfig&&) noexcept;
-  StatsdTracingConfig& operator=(StatsdTracingConfig&&);
-  StatsdTracingConfig(const StatsdTracingConfig&);
-  StatsdTracingConfig& operator=(const StatsdTracingConfig&);
-  bool operator==(const StatsdTracingConfig&) const;
-  bool operator!=(const StatsdTracingConfig& other) const { return !(*this == other); }
+  ChromeCompositorStateMachine_MinorState();
+  ~ChromeCompositorStateMachine_MinorState() override;
+  ChromeCompositorStateMachine_MinorState(ChromeCompositorStateMachine_MinorState&&) noexcept;
+  ChromeCompositorStateMachine_MinorState& operator=(ChromeCompositorStateMachine_MinorState&&);
+  ChromeCompositorStateMachine_MinorState(const ChromeCompositorStateMachine_MinorState&);
+  ChromeCompositorStateMachine_MinorState& operator=(const ChromeCompositorStateMachine_MinorState&);
+  bool operator==(const ChromeCompositorStateMachine_MinorState&) const;
+  bool operator!=(const ChromeCompositorStateMachine_MinorState& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  const std::vector<AtomId>& push_atom_id() const { return push_atom_id_; }
-  std::vector<AtomId>* mutable_push_atom_id() { return &push_atom_id_; }
-  int push_atom_id_size() const { return static_cast<int>(push_atom_id_.size()); }
-  void clear_push_atom_id() { push_atom_id_.clear(); }
-  void add_push_atom_id(AtomId value) { push_atom_id_.emplace_back(value); }
-  AtomId* add_push_atom_id() { push_atom_id_.emplace_back(); return &push_atom_id_.back(); }
-
-  const std::vector<int32_t>& raw_push_atom_id() const { return raw_push_atom_id_; }
-  std::vector<int32_t>* mutable_raw_push_atom_id() { return &raw_push_atom_id_; }
-  int raw_push_atom_id_size() const { return static_cast<int>(raw_push_atom_id_.size()); }
-  void clear_raw_push_atom_id() { raw_push_atom_id_.clear(); }
-  void add_raw_push_atom_id(int32_t value) { raw_push_atom_id_.emplace_back(value); }
-  int32_t* add_raw_push_atom_id() { raw_push_atom_id_.emplace_back(); return &raw_push_atom_id_.back(); }
+  bool has_commit_count() const { return _has_field_[1]; }
+  int32_t commit_count() const { return commit_count_; }
+  void set_commit_count(int32_t value) { commit_count_ = value; _has_field_.set(1); }
 
-  const std::vector<StatsdPullAtomConfig>& pull_config() const { return pull_config_; }
-  std::vector<StatsdPullAtomConfig>* mutable_pull_config() { return &pull_config_; }
-  int pull_config_size() const;
-  void clear_pull_config();
-  StatsdPullAtomConfig* add_pull_config();
+  bool has_current_frame_number() const { return _has_field_[2]; }
+  int32_t current_frame_number() const { return current_frame_number_; }
+  void set_current_frame_number(int32_t value) { current_frame_number_ = value; _has_field_.set(2); }
 
- private:
-  std::vector<AtomId> push_atom_id_;
-  std::vector<int32_t> raw_push_atom_id_;
-  std::vector<StatsdPullAtomConfig> pull_config_;
+  bool has_last_frame_number_submit_performed() const { return _has_field_[3]; }
+  int32_t last_frame_number_submit_performed() const { return last_frame_number_submit_performed_; }
+  void set_last_frame_number_submit_performed(int32_t value) { last_frame_number_submit_performed_ = value; _has_field_.set(3); }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  bool has_last_frame_number_draw_performed() const { return _has_field_[4]; }
+  int32_t last_frame_number_draw_performed() const { return last_frame_number_draw_performed_; }
+  void set_last_frame_number_draw_performed(int32_t value) { last_frame_number_draw_performed_ = value; _has_field_.set(4); }
 
-  std::bitset<4> _has_field_{};
-};
+  bool has_last_frame_number_begin_main_frame_sent() const { return _has_field_[5]; }
+  int32_t last_frame_number_begin_main_frame_sent() const { return last_frame_number_begin_main_frame_sent_; }
+  void set_last_frame_number_begin_main_frame_sent(int32_t value) { last_frame_number_begin_main_frame_sent_ = value; _has_field_.set(5); }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  bool has_did_draw() const { return _has_field_[6]; }
+  bool did_draw() const { return did_draw_; }
+  void set_did_draw(bool value) { did_draw_ = value; _has_field_.set(6); }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STATSD_STATSD_TRACING_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/sys_stats/sys_stats_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYS_STATS_SYS_STATS_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYS_STATS_SYS_STATS_CONFIG_PROTO_CPP_H_
+  bool has_did_send_begin_main_frame_for_current_frame() const { return _has_field_[7]; }
+  bool did_send_begin_main_frame_for_current_frame() const { return did_send_begin_main_frame_for_current_frame_; }
+  void set_did_send_begin_main_frame_for_current_frame(bool value) { did_send_begin_main_frame_for_current_frame_ = value; _has_field_.set(7); }
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  bool has_did_notify_begin_main_frame_not_expected_until() const { return _has_field_[8]; }
+  bool did_notify_begin_main_frame_not_expected_until() const { return did_notify_begin_main_frame_not_expected_until_; }
+  void set_did_notify_begin_main_frame_not_expected_until(bool value) { did_notify_begin_main_frame_not_expected_until_ = value; _has_field_.set(8); }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  bool has_did_notify_begin_main_frame_not_expected_soon() const { return _has_field_[9]; }
+  bool did_notify_begin_main_frame_not_expected_soon() const { return did_notify_begin_main_frame_not_expected_soon_; }
+  void set_did_notify_begin_main_frame_not_expected_soon(bool value) { did_notify_begin_main_frame_not_expected_soon_ = value; _has_field_.set(9); }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class SysStatsConfig;
-enum SysStatsConfig_StatCounters : int;
-enum MeminfoCounters : int;
-enum VmstatCounters : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  bool has_wants_begin_main_frame_not_expected() const { return _has_field_[10]; }
+  bool wants_begin_main_frame_not_expected() const { return wants_begin_main_frame_not_expected_; }
+  void set_wants_begin_main_frame_not_expected(bool value) { wants_begin_main_frame_not_expected_ = value; _has_field_.set(10); }
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  bool has_did_commit_during_frame() const { return _has_field_[11]; }
+  bool did_commit_during_frame() const { return did_commit_during_frame_; }
+  void set_did_commit_during_frame(bool value) { did_commit_during_frame_ = value; _has_field_.set(11); }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum SysStatsConfig_StatCounters : int {
-  SysStatsConfig_StatCounters_STAT_UNSPECIFIED = 0,
-  SysStatsConfig_StatCounters_STAT_CPU_TIMES = 1,
-  SysStatsConfig_StatCounters_STAT_IRQ_COUNTS = 2,
-  SysStatsConfig_StatCounters_STAT_SOFTIRQ_COUNTS = 3,
-  SysStatsConfig_StatCounters_STAT_FORK_COUNT = 4,
-};
+  bool has_did_invalidate_layer_tree_frame_sink() const { return _has_field_[12]; }
+  bool did_invalidate_layer_tree_frame_sink() const { return did_invalidate_layer_tree_frame_sink_; }
+  void set_did_invalidate_layer_tree_frame_sink(bool value) { did_invalidate_layer_tree_frame_sink_ = value; _has_field_.set(12); }
 
-class PERFETTO_EXPORT_COMPONENT SysStatsConfig : public ::protozero::CppMessageObj {
- public:
-  using StatCounters = SysStatsConfig_StatCounters;
-  static constexpr auto STAT_UNSPECIFIED = SysStatsConfig_StatCounters_STAT_UNSPECIFIED;
-  static constexpr auto STAT_CPU_TIMES = SysStatsConfig_StatCounters_STAT_CPU_TIMES;
-  static constexpr auto STAT_IRQ_COUNTS = SysStatsConfig_StatCounters_STAT_IRQ_COUNTS;
-  static constexpr auto STAT_SOFTIRQ_COUNTS = SysStatsConfig_StatCounters_STAT_SOFTIRQ_COUNTS;
-  static constexpr auto STAT_FORK_COUNT = SysStatsConfig_StatCounters_STAT_FORK_COUNT;
-  static constexpr auto StatCounters_MIN = SysStatsConfig_StatCounters_STAT_UNSPECIFIED;
-  static constexpr auto StatCounters_MAX = SysStatsConfig_StatCounters_STAT_FORK_COUNT;
-  enum FieldNumbers {
-    kMeminfoPeriodMsFieldNumber = 1,
-    kMeminfoCountersFieldNumber = 2,
-    kVmstatPeriodMsFieldNumber = 3,
-    kVmstatCountersFieldNumber = 4,
-    kStatPeriodMsFieldNumber = 5,
-    kStatCountersFieldNumber = 6,
-    kDevfreqPeriodMsFieldNumber = 7,
-    kCpufreqPeriodMsFieldNumber = 8,
-    kBuddyinfoPeriodMsFieldNumber = 9,
-    kDiskstatPeriodMsFieldNumber = 10,
-  };
+  bool has_did_perform_impl_side_invalidaion() const { return _has_field_[13]; }
+  bool did_perform_impl_side_invalidaion() const { return did_perform_impl_side_invalidaion_; }
+  void set_did_perform_impl_side_invalidaion(bool value) { did_perform_impl_side_invalidaion_ = value; _has_field_.set(13); }
 
-  SysStatsConfig();
-  ~SysStatsConfig() override;
-  SysStatsConfig(SysStatsConfig&&) noexcept;
-  SysStatsConfig& operator=(SysStatsConfig&&);
-  SysStatsConfig(const SysStatsConfig&);
-  SysStatsConfig& operator=(const SysStatsConfig&);
-  bool operator==(const SysStatsConfig&) const;
-  bool operator!=(const SysStatsConfig& other) const { return !(*this == other); }
+  bool has_did_prepare_tiles() const { return _has_field_[14]; }
+  bool did_prepare_tiles() const { return did_prepare_tiles_; }
+  void set_did_prepare_tiles(bool value) { did_prepare_tiles_ = value; _has_field_.set(14); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  bool has_consecutive_checkerboard_animations() const { return _has_field_[15]; }
+  int32_t consecutive_checkerboard_animations() const { return consecutive_checkerboard_animations_; }
+  void set_consecutive_checkerboard_animations(int32_t value) { consecutive_checkerboard_animations_ = value; _has_field_.set(15); }
 
-  bool has_meminfo_period_ms() const { return _has_field_[1]; }
-  uint32_t meminfo_period_ms() const { return meminfo_period_ms_; }
-  void set_meminfo_period_ms(uint32_t value) { meminfo_period_ms_ = value; _has_field_.set(1); }
+  bool has_pending_submit_frames() const { return _has_field_[16]; }
+  int32_t pending_submit_frames() const { return pending_submit_frames_; }
+  void set_pending_submit_frames(int32_t value) { pending_submit_frames_ = value; _has_field_.set(16); }
 
-  const std::vector<MeminfoCounters>& meminfo_counters() const { return meminfo_counters_; }
-  std::vector<MeminfoCounters>* mutable_meminfo_counters() { return &meminfo_counters_; }
-  int meminfo_counters_size() const { return static_cast<int>(meminfo_counters_.size()); }
-  void clear_meminfo_counters() { meminfo_counters_.clear(); }
-  void add_meminfo_counters(MeminfoCounters value) { meminfo_counters_.emplace_back(value); }
-  MeminfoCounters* add_meminfo_counters() { meminfo_counters_.emplace_back(); return &meminfo_counters_.back(); }
+  bool has_submit_frames_with_current_layer_tree_frame_sink() const { return _has_field_[17]; }
+  int32_t submit_frames_with_current_layer_tree_frame_sink() const { return submit_frames_with_current_layer_tree_frame_sink_; }
+  void set_submit_frames_with_current_layer_tree_frame_sink(int32_t value) { submit_frames_with_current_layer_tree_frame_sink_ = value; _has_field_.set(17); }
 
-  bool has_vmstat_period_ms() const { return _has_field_[3]; }
-  uint32_t vmstat_period_ms() const { return vmstat_period_ms_; }
-  void set_vmstat_period_ms(uint32_t value) { vmstat_period_ms_ = value; _has_field_.set(3); }
+  bool has_needs_redraw() const { return _has_field_[18]; }
+  bool needs_redraw() const { return needs_redraw_; }
+  void set_needs_redraw(bool value) { needs_redraw_ = value; _has_field_.set(18); }
 
-  const std::vector<VmstatCounters>& vmstat_counters() const { return vmstat_counters_; }
-  std::vector<VmstatCounters>* mutable_vmstat_counters() { return &vmstat_counters_; }
-  int vmstat_counters_size() const { return static_cast<int>(vmstat_counters_.size()); }
-  void clear_vmstat_counters() { vmstat_counters_.clear(); }
-  void add_vmstat_counters(VmstatCounters value) { vmstat_counters_.emplace_back(value); }
-  VmstatCounters* add_vmstat_counters() { vmstat_counters_.emplace_back(); return &vmstat_counters_.back(); }
+  bool has_needs_prepare_tiles() const { return _has_field_[19]; }
+  bool needs_prepare_tiles() const { return needs_prepare_tiles_; }
+  void set_needs_prepare_tiles(bool value) { needs_prepare_tiles_ = value; _has_field_.set(19); }
 
-  bool has_stat_period_ms() const { return _has_field_[5]; }
-  uint32_t stat_period_ms() const { return stat_period_ms_; }
-  void set_stat_period_ms(uint32_t value) { stat_period_ms_ = value; _has_field_.set(5); }
+  bool has_needs_begin_main_frame() const { return _has_field_[20]; }
+  bool needs_begin_main_frame() const { return needs_begin_main_frame_; }
+  void set_needs_begin_main_frame(bool value) { needs_begin_main_frame_ = value; _has_field_.set(20); }
 
-  const std::vector<SysStatsConfig_StatCounters>& stat_counters() const { return stat_counters_; }
-  std::vector<SysStatsConfig_StatCounters>* mutable_stat_counters() { return &stat_counters_; }
-  int stat_counters_size() const { return static_cast<int>(stat_counters_.size()); }
-  void clear_stat_counters() { stat_counters_.clear(); }
-  void add_stat_counters(SysStatsConfig_StatCounters value) { stat_counters_.emplace_back(value); }
-  SysStatsConfig_StatCounters* add_stat_counters() { stat_counters_.emplace_back(); return &stat_counters_.back(); }
+  bool has_needs_one_begin_impl_frame() const { return _has_field_[21]; }
+  bool needs_one_begin_impl_frame() const { return needs_one_begin_impl_frame_; }
+  void set_needs_one_begin_impl_frame(bool value) { needs_one_begin_impl_frame_ = value; _has_field_.set(21); }
 
-  bool has_devfreq_period_ms() const { return _has_field_[7]; }
-  uint32_t devfreq_period_ms() const { return devfreq_period_ms_; }
-  void set_devfreq_period_ms(uint32_t value) { devfreq_period_ms_ = value; _has_field_.set(7); }
+  bool has_visible() const { return _has_field_[22]; }
+  bool visible() const { return visible_; }
+  void set_visible(bool value) { visible_ = value; _has_field_.set(22); }
 
-  bool has_cpufreq_period_ms() const { return _has_field_[8]; }
-  uint32_t cpufreq_period_ms() const { return cpufreq_period_ms_; }
-  void set_cpufreq_period_ms(uint32_t value) { cpufreq_period_ms_ = value; _has_field_.set(8); }
+  bool has_begin_frame_source_paused() const { return _has_field_[23]; }
+  bool begin_frame_source_paused() const { return begin_frame_source_paused_; }
+  void set_begin_frame_source_paused(bool value) { begin_frame_source_paused_ = value; _has_field_.set(23); }
 
-  bool has_buddyinfo_period_ms() const { return _has_field_[9]; }
-  uint32_t buddyinfo_period_ms() const { return buddyinfo_period_ms_; }
-  void set_buddyinfo_period_ms(uint32_t value) { buddyinfo_period_ms_ = value; _has_field_.set(9); }
+  bool has_can_draw() const { return _has_field_[24]; }
+  bool can_draw() const { return can_draw_; }
+  void set_can_draw(bool value) { can_draw_ = value; _has_field_.set(24); }
 
-  bool has_diskstat_period_ms() const { return _has_field_[10]; }
-  uint32_t diskstat_period_ms() const { return diskstat_period_ms_; }
-  void set_diskstat_period_ms(uint32_t value) { diskstat_period_ms_ = value; _has_field_.set(10); }
+  bool has_resourceless_draw() const { return _has_field_[25]; }
+  bool resourceless_draw() const { return resourceless_draw_; }
+  void set_resourceless_draw(bool value) { resourceless_draw_ = value; _has_field_.set(25); }
 
- private:
-  uint32_t meminfo_period_ms_{};
-  std::vector<MeminfoCounters> meminfo_counters_;
-  uint32_t vmstat_period_ms_{};
-  std::vector<VmstatCounters> vmstat_counters_;
-  uint32_t stat_period_ms_{};
-  std::vector<SysStatsConfig_StatCounters> stat_counters_;
-  uint32_t devfreq_period_ms_{};
-  uint32_t cpufreq_period_ms_{};
-  uint32_t buddyinfo_period_ms_{};
-  uint32_t diskstat_period_ms_{};
+  bool has_has_pending_tree() const { return _has_field_[26]; }
+  bool has_pending_tree() const { return has_pending_tree_; }
+  void set_has_pending_tree(bool value) { has_pending_tree_ = value; _has_field_.set(26); }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  bool has_pending_tree_is_ready_for_activation() const { return _has_field_[27]; }
+  bool pending_tree_is_ready_for_activation() const { return pending_tree_is_ready_for_activation_; }
+  void set_pending_tree_is_ready_for_activation(bool value) { pending_tree_is_ready_for_activation_ = value; _has_field_.set(27); }
 
-  std::bitset<11> _has_field_{};
-};
+  bool has_active_tree_needs_first_draw() const { return _has_field_[28]; }
+  bool active_tree_needs_first_draw() const { return active_tree_needs_first_draw_; }
+  void set_active_tree_needs_first_draw(bool value) { active_tree_needs_first_draw_ = value; _has_field_.set(28); }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  bool has_active_tree_is_ready_to_draw() const { return _has_field_[29]; }
+  bool active_tree_is_ready_to_draw() const { return active_tree_is_ready_to_draw_; }
+  void set_active_tree_is_ready_to_draw(bool value) { active_tree_is_ready_to_draw_ = value; _has_field_.set(29); }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYS_STATS_SYS_STATS_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/system_info/system_info.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYSTEM_INFO_SYSTEM_INFO_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYSTEM_INFO_SYSTEM_INFO_PROTO_CPP_H_
+  bool has_did_create_and_initialize_first_layer_tree_frame_sink() const { return _has_field_[30]; }
+  bool did_create_and_initialize_first_layer_tree_frame_sink() const { return did_create_and_initialize_first_layer_tree_frame_sink_; }
+  void set_did_create_and_initialize_first_layer_tree_frame_sink(bool value) { did_create_and_initialize_first_layer_tree_frame_sink_ = value; _has_field_.set(30); }
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  bool has_tree_priority() const { return _has_field_[31]; }
+  ChromeCompositorStateMachine_MinorState_TreePriority tree_priority() const { return tree_priority_; }
+  void set_tree_priority(ChromeCompositorStateMachine_MinorState_TreePriority value) { tree_priority_ = value; _has_field_.set(31); }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  bool has_scroll_handler_state() const { return _has_field_[32]; }
+  ChromeCompositorStateMachine_MinorState_ScrollHandlerState scroll_handler_state() const { return scroll_handler_state_; }
+  void set_scroll_handler_state(ChromeCompositorStateMachine_MinorState_ScrollHandlerState value) { scroll_handler_state_ = value; _has_field_.set(32); }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class SystemInfoConfig;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  bool has_critical_begin_main_frame_to_activate_is_fast() const { return _has_field_[33]; }
+  bool critical_begin_main_frame_to_activate_is_fast() const { return critical_begin_main_frame_to_activate_is_fast_; }
+  void set_critical_begin_main_frame_to_activate_is_fast(bool value) { critical_begin_main_frame_to_activate_is_fast_ = value; _has_field_.set(33); }
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  bool has_main_thread_missed_last_deadline() const { return _has_field_[34]; }
+  bool main_thread_missed_last_deadline() const { return main_thread_missed_last_deadline_; }
+  void set_main_thread_missed_last_deadline(bool value) { main_thread_missed_last_deadline_ = value; _has_field_.set(34); }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
+  bool has_video_needs_begin_frames() const { return _has_field_[36]; }
+  bool video_needs_begin_frames() const { return video_needs_begin_frames_; }
+  void set_video_needs_begin_frames(bool value) { video_needs_begin_frames_ = value; _has_field_.set(36); }
 
-class PERFETTO_EXPORT_COMPONENT SystemInfoConfig : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
+  bool has_defer_begin_main_frame() const { return _has_field_[37]; }
+  bool defer_begin_main_frame() const { return defer_begin_main_frame_; }
+  void set_defer_begin_main_frame(bool value) { defer_begin_main_frame_ = value; _has_field_.set(37); }
 
-  SystemInfoConfig();
-  ~SystemInfoConfig() override;
-  SystemInfoConfig(SystemInfoConfig&&) noexcept;
-  SystemInfoConfig& operator=(SystemInfoConfig&&);
-  SystemInfoConfig(const SystemInfoConfig&);
-  SystemInfoConfig& operator=(const SystemInfoConfig&);
-  bool operator==(const SystemInfoConfig&) const;
-  bool operator!=(const SystemInfoConfig& other) const { return !(*this == other); }
+  bool has_last_commit_had_no_updates() const { return _has_field_[38]; }
+  bool last_commit_had_no_updates() const { return last_commit_had_no_updates_; }
+  void set_last_commit_had_no_updates(bool value) { last_commit_had_no_updates_ = value; _has_field_.set(38); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  bool has_did_draw_in_last_frame() const { return _has_field_[39]; }
+  bool did_draw_in_last_frame() const { return did_draw_in_last_frame_; }
+  void set_did_draw_in_last_frame(bool value) { did_draw_in_last_frame_ = value; _has_field_.set(39); }
 
- private:
+  bool has_did_submit_in_last_frame() const { return _has_field_[40]; }
+  bool did_submit_in_last_frame() const { return did_submit_in_last_frame_; }
+  void set_did_submit_in_last_frame(bool value) { did_submit_in_last_frame_ = value; _has_field_.set(40); }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  bool has_needs_impl_side_invalidation() const { return _has_field_[41]; }
+  bool needs_impl_side_invalidation() const { return needs_impl_side_invalidation_; }
+  void set_needs_impl_side_invalidation(bool value) { needs_impl_side_invalidation_ = value; _has_field_.set(41); }
 
-  std::bitset<2> _has_field_{};
-};
+  bool has_current_pending_tree_is_impl_side() const { return _has_field_[42]; }
+  bool current_pending_tree_is_impl_side() const { return current_pending_tree_is_impl_side_; }
+  void set_current_pending_tree_is_impl_side(bool value) { current_pending_tree_is_impl_side_ = value; _has_field_.set(42); }
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+  bool has_previous_pending_tree_was_impl_side() const { return _has_field_[43]; }
+  bool previous_pending_tree_was_impl_side() const { return previous_pending_tree_was_impl_side_; }
+  void set_previous_pending_tree_was_impl_side(bool value) { previous_pending_tree_was_impl_side_ = value; _has_field_.set(43); }
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_SYSTEM_INFO_SYSTEM_INFO_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/chrome/chrome_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_CHROME_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_CHROME_CONFIG_PROTO_CPP_H_
+  bool has_processing_animation_worklets_for_active_tree() const { return _has_field_[44]; }
+  bool processing_animation_worklets_for_active_tree() const { return processing_animation_worklets_for_active_tree_; }
+  void set_processing_animation_worklets_for_active_tree(bool value) { processing_animation_worklets_for_active_tree_ = value; _has_field_.set(44); }
 
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
+  bool has_processing_animation_worklets_for_pending_tree() const { return _has_field_[45]; }
+  bool processing_animation_worklets_for_pending_tree() const { return processing_animation_worklets_for_pending_tree_; }
+  void set_processing_animation_worklets_for_pending_tree(bool value) { processing_animation_worklets_for_pending_tree_ = value; _has_field_.set(45); }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
+  bool has_processing_paint_worklets_for_pending_tree() const { return _has_field_[46]; }
+  bool processing_paint_worklets_for_pending_tree() const { return processing_paint_worklets_for_pending_tree_; }
+  void set_processing_paint_worklets_for_pending_tree(bool value) { processing_paint_worklets_for_pending_tree_ = value; _has_field_.set(46); }
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-class ChromeConfig;
-enum ChromeConfig_ClientPriority : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
+ private:
+  int32_t commit_count_{};
+  int32_t current_frame_number_{};
+  int32_t last_frame_number_submit_performed_{};
+  int32_t last_frame_number_draw_performed_{};
+  int32_t last_frame_number_begin_main_frame_sent_{};
+  bool did_draw_{};
+  bool did_send_begin_main_frame_for_current_frame_{};
+  bool did_notify_begin_main_frame_not_expected_until_{};
+  bool did_notify_begin_main_frame_not_expected_soon_{};
+  bool wants_begin_main_frame_not_expected_{};
+  bool did_commit_during_frame_{};
+  bool did_invalidate_layer_tree_frame_sink_{};
+  bool did_perform_impl_side_invalidaion_{};
+  bool did_prepare_tiles_{};
+  int32_t consecutive_checkerboard_animations_{};
+  int32_t pending_submit_frames_{};
+  int32_t submit_frames_with_current_layer_tree_frame_sink_{};
+  bool needs_redraw_{};
+  bool needs_prepare_tiles_{};
+  bool needs_begin_main_frame_{};
+  bool needs_one_begin_impl_frame_{};
+  bool visible_{};
+  bool begin_frame_source_paused_{};
+  bool can_draw_{};
+  bool resourceless_draw_{};
+  bool has_pending_tree_{};
+  bool pending_tree_is_ready_for_activation_{};
+  bool active_tree_needs_first_draw_{};
+  bool active_tree_is_ready_to_draw_{};
+  bool did_create_and_initialize_first_layer_tree_frame_sink_{};
+  ChromeCompositorStateMachine_MinorState_TreePriority tree_priority_{};
+  ChromeCompositorStateMachine_MinorState_ScrollHandlerState scroll_handler_state_{};
+  bool critical_begin_main_frame_to_activate_is_fast_{};
+  bool main_thread_missed_last_deadline_{};
+  bool video_needs_begin_frames_{};
+  bool defer_begin_main_frame_{};
+  bool last_commit_had_no_updates_{};
+  bool did_draw_in_last_frame_{};
+  bool did_submit_in_last_frame_{};
+  bool needs_impl_side_invalidation_{};
+  bool current_pending_tree_is_impl_side_{};
+  bool previous_pending_tree_was_impl_side_{};
+  bool processing_animation_worklets_for_active_tree_{};
+  bool processing_animation_worklets_for_pending_tree_{};
+  bool processing_paint_worklets_for_pending_tree_{};
 
-namespace protozero {
-class Message;
-}  // namespace protozero
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum ChromeConfig_ClientPriority : int {
-  ChromeConfig_ClientPriority_UNKNOWN = 0,
-  ChromeConfig_ClientPriority_BACKGROUND = 1,
-  ChromeConfig_ClientPriority_USER_INITIATED = 2,
+  std::bitset<47> _has_field_{};
 };
 
-class PERFETTO_EXPORT_COMPONENT ChromeConfig : public ::protozero::CppMessageObj {
+
+class PERFETTO_EXPORT_COMPONENT ChromeCompositorStateMachine_MajorState : public ::protozero::CppMessageObj {
  public:
-  using ClientPriority = ChromeConfig_ClientPriority;
-  static constexpr auto UNKNOWN = ChromeConfig_ClientPriority_UNKNOWN;
-  static constexpr auto BACKGROUND = ChromeConfig_ClientPriority_BACKGROUND;
-  static constexpr auto USER_INITIATED = ChromeConfig_ClientPriority_USER_INITIATED;
-  static constexpr auto ClientPriority_MIN = ChromeConfig_ClientPriority_UNKNOWN;
-  static constexpr auto ClientPriority_MAX = ChromeConfig_ClientPriority_USER_INITIATED;
+  using BeginImplFrameState = ChromeCompositorStateMachine_MajorState_BeginImplFrameState;
+  static constexpr auto BEGIN_IMPL_FRAME_UNSPECIFIED = ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_UNSPECIFIED;
+  static constexpr auto BEGIN_IMPL_FRAME_IDLE = ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_IDLE;
+  static constexpr auto BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME = ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME;
+  static constexpr auto BEGIN_IMPL_FRAME_INSIDE_DEADLINE = ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_INSIDE_DEADLINE;
+  static constexpr auto BeginImplFrameState_MIN = ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_UNSPECIFIED;
+  static constexpr auto BeginImplFrameState_MAX = ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_INSIDE_DEADLINE;
+  using BeginMainFrameState = ChromeCompositorStateMachine_MajorState_BeginMainFrameState;
+  static constexpr auto BEGIN_MAIN_FRAME_UNSPECIFIED = ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_UNSPECIFIED;
+  static constexpr auto BEGIN_MAIN_FRAME_IDLE = ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_IDLE;
+  static constexpr auto BEGIN_MAIN_FRAME_SENT = ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_SENT;
+  static constexpr auto BEGIN_MAIN_FRAME_READY_TO_COMMIT = ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_READY_TO_COMMIT;
+  static constexpr auto BeginMainFrameState_MIN = ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_UNSPECIFIED;
+  static constexpr auto BeginMainFrameState_MAX = ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_READY_TO_COMMIT;
+  using LayerTreeFrameSinkState = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState;
+  static constexpr auto LAYER_TREE_FRAME_UNSPECIFIED = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_UNSPECIFIED;
+  static constexpr auto LAYER_TREE_FRAME_NONE = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_NONE;
+  static constexpr auto LAYER_TREE_FRAME_ACTIVE = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_ACTIVE;
+  static constexpr auto LAYER_TREE_FRAME_CREATING = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_CREATING;
+  static constexpr auto LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT;
+  static constexpr auto LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION;
+  static constexpr auto LayerTreeFrameSinkState_MIN = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_UNSPECIFIED;
+  static constexpr auto LayerTreeFrameSinkState_MAX = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION;
+  using ForcedRedrawOnTimeoutState = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState;
+  static constexpr auto FORCED_REDRAW_UNSPECIFIED = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_UNSPECIFIED;
+  static constexpr auto FORCED_REDRAW_IDLE = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_IDLE;
+  static constexpr auto FORCED_REDRAW_WAITING_FOR_COMMIT = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_COMMIT;
+  static constexpr auto FORCED_REDRAW_WAITING_FOR_ACTIVATION = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_ACTIVATION;
+  static constexpr auto FORCED_REDRAW_WAITING_FOR_DRAW = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_DRAW;
+  static constexpr auto ForcedRedrawOnTimeoutState_MIN = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_UNSPECIFIED;
+  static constexpr auto ForcedRedrawOnTimeoutState_MAX = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_DRAW;
   enum FieldNumbers {
-    kTraceConfigFieldNumber = 1,
-    kPrivacyFilteringEnabledFieldNumber = 2,
-    kConvertToLegacyJsonFieldNumber = 3,
-    kClientPriorityFieldNumber = 4,
-    kJsonAgentLabelFilterFieldNumber = 5,
+    kNextActionFieldNumber = 1,
+    kBeginImplFrameStateFieldNumber = 2,
+    kBeginMainFrameStateFieldNumber = 3,
+    kLayerTreeFrameSinkStateFieldNumber = 4,
+    kForcedRedrawStateFieldNumber = 5,
   };
 
-  ChromeConfig();
-  ~ChromeConfig() override;
-  ChromeConfig(ChromeConfig&&) noexcept;
-  ChromeConfig& operator=(ChromeConfig&&);
-  ChromeConfig(const ChromeConfig&);
-  ChromeConfig& operator=(const ChromeConfig&);
-  bool operator==(const ChromeConfig&) const;
-  bool operator!=(const ChromeConfig& other) const { return !(*this == other); }
+  ChromeCompositorStateMachine_MajorState();
+  ~ChromeCompositorStateMachine_MajorState() override;
+  ChromeCompositorStateMachine_MajorState(ChromeCompositorStateMachine_MajorState&&) noexcept;
+  ChromeCompositorStateMachine_MajorState& operator=(ChromeCompositorStateMachine_MajorState&&);
+  ChromeCompositorStateMachine_MajorState(const ChromeCompositorStateMachine_MajorState&);
+  ChromeCompositorStateMachine_MajorState& operator=(const ChromeCompositorStateMachine_MajorState&);
+  bool operator==(const ChromeCompositorStateMachine_MajorState&) const;
+  bool operator!=(const ChromeCompositorStateMachine_MajorState& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_trace_config() const { return _has_field_[1]; }
-  const std::string& trace_config() const { return trace_config_; }
-  void set_trace_config(const std::string& value) { trace_config_ = value; _has_field_.set(1); }
+  bool has_next_action() const { return _has_field_[1]; }
+  ChromeCompositorSchedulerAction next_action() const { return next_action_; }
+  void set_next_action(ChromeCompositorSchedulerAction value) { next_action_ = value; _has_field_.set(1); }
 
-  bool has_privacy_filtering_enabled() const { return _has_field_[2]; }
-  bool privacy_filtering_enabled() const { return privacy_filtering_enabled_; }
-  void set_privacy_filtering_enabled(bool value) { privacy_filtering_enabled_ = value; _has_field_.set(2); }
+  bool has_begin_impl_frame_state() const { return _has_field_[2]; }
+  ChromeCompositorStateMachine_MajorState_BeginImplFrameState begin_impl_frame_state() const { return begin_impl_frame_state_; }
+  void set_begin_impl_frame_state(ChromeCompositorStateMachine_MajorState_BeginImplFrameState value) { begin_impl_frame_state_ = value; _has_field_.set(2); }
 
-  bool has_convert_to_legacy_json() const { return _has_field_[3]; }
-  bool convert_to_legacy_json() const { return convert_to_legacy_json_; }
-  void set_convert_to_legacy_json(bool value) { convert_to_legacy_json_ = value; _has_field_.set(3); }
+  bool has_begin_main_frame_state() const { return _has_field_[3]; }
+  ChromeCompositorStateMachine_MajorState_BeginMainFrameState begin_main_frame_state() const { return begin_main_frame_state_; }
+  void set_begin_main_frame_state(ChromeCompositorStateMachine_MajorState_BeginMainFrameState value) { begin_main_frame_state_ = value; _has_field_.set(3); }
 
-  bool has_client_priority() const { return _has_field_[4]; }
-  ChromeConfig_ClientPriority client_priority() const { return client_priority_; }
-  void set_client_priority(ChromeConfig_ClientPriority value) { client_priority_ = value; _has_field_.set(4); }
+  bool has_layer_tree_frame_sink_state() const { return _has_field_[4]; }
+  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState layer_tree_frame_sink_state() const { return layer_tree_frame_sink_state_; }
+  void set_layer_tree_frame_sink_state(ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState value) { layer_tree_frame_sink_state_ = value; _has_field_.set(4); }
 
-  bool has_json_agent_label_filter() const { return _has_field_[5]; }
-  const std::string& json_agent_label_filter() const { return json_agent_label_filter_; }
-  void set_json_agent_label_filter(const std::string& value) { json_agent_label_filter_ = value; _has_field_.set(5); }
+  bool has_forced_redraw_state() const { return _has_field_[5]; }
+  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState forced_redraw_state() const { return forced_redraw_state_; }
+  void set_forced_redraw_state(ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState value) { forced_redraw_state_ = value; _has_field_.set(5); }
 
  private:
-  std::string trace_config_{};
-  bool privacy_filtering_enabled_{};
-  bool convert_to_legacy_json_{};
-  ChromeConfig_ClientPriority client_priority_{};
-  std::string json_agent_label_filter_{};
+  ChromeCompositorSchedulerAction next_action_{};
+  ChromeCompositorStateMachine_MajorState_BeginImplFrameState begin_impl_frame_state_{};
+  ChromeCompositorStateMachine_MajorState_BeginMainFrameState begin_main_frame_state_{};
+  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState layer_tree_frame_sink_state_{};
+  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState forced_redraw_state_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
@@ -169952,263 +189997,149 @@ class PERFETTO_EXPORT_COMPONENT ChromeConfig : public ::protozero::CppMessageObj
   std::bitset<6> _has_field_{};
 };
 
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_CHROME_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/data_source_config.gen.h
-// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_DATA_SOURCE_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_DATA_SOURCE_CONFIG_PROTO_CPP_H_
-
-#include <stdint.h>
-#include <bitset>
-#include <vector>
-#include <string>
-#include <type_traits>
-
-// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-class DataSourceConfig;
-class TestConfig;
-class TestConfig_DummyFields;
-class InterceptorConfig;
-class ChromeConfig;
-class SystemInfoConfig;
-enum DataSourceConfig_SessionInitiator : int;
-enum ChromeConfig_ClientPriority : int;
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-namespace protozero {
-class Message;
-}  // namespace protozero
-
-namespace perfetto {
-namespace protos {
-namespace gen {
-enum DataSourceConfig_SessionInitiator : int {
-  DataSourceConfig_SessionInitiator_SESSION_INITIATOR_UNSPECIFIED = 0,
-  DataSourceConfig_SessionInitiator_SESSION_INITIATOR_TRUSTED_SYSTEM = 1,
-};
 
-class PERFETTO_EXPORT_COMPONENT DataSourceConfig : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT ChromeCompositorSchedulerState : public ::protozero::CppMessageObj {
  public:
-  using SessionInitiator = DataSourceConfig_SessionInitiator;
-  static constexpr auto SESSION_INITIATOR_UNSPECIFIED = DataSourceConfig_SessionInitiator_SESSION_INITIATOR_UNSPECIFIED;
-  static constexpr auto SESSION_INITIATOR_TRUSTED_SYSTEM = DataSourceConfig_SessionInitiator_SESSION_INITIATOR_TRUSTED_SYSTEM;
-  static constexpr auto SessionInitiator_MIN = DataSourceConfig_SessionInitiator_SESSION_INITIATOR_UNSPECIFIED;
-  static constexpr auto SessionInitiator_MAX = DataSourceConfig_SessionInitiator_SESSION_INITIATOR_TRUSTED_SYSTEM;
+  using BeginImplFrameDeadlineMode = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode;
+  static constexpr auto DEADLINE_MODE_UNSPECIFIED = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_UNSPECIFIED;
+  static constexpr auto DEADLINE_MODE_NONE = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_NONE;
+  static constexpr auto DEADLINE_MODE_IMMEDIATE = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_IMMEDIATE;
+  static constexpr auto DEADLINE_MODE_REGULAR = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_REGULAR;
+  static constexpr auto DEADLINE_MODE_LATE = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_LATE;
+  static constexpr auto DEADLINE_MODE_BLOCKED = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_BLOCKED;
+  static constexpr auto BeginImplFrameDeadlineMode_MIN = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_UNSPECIFIED;
+  static constexpr auto BeginImplFrameDeadlineMode_MAX = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_BLOCKED;
   enum FieldNumbers {
-    kNameFieldNumber = 1,
-    kTargetBufferFieldNumber = 2,
-    kTraceDurationMsFieldNumber = 3,
-    kPreferSuspendClockForDurationFieldNumber = 122,
-    kStopTimeoutMsFieldNumber = 7,
-    kEnableExtraGuardrailsFieldNumber = 6,
-    kSessionInitiatorFieldNumber = 8,
-    kTracingSessionIdFieldNumber = 4,
-    kFtraceConfigFieldNumber = 100,
-    kInodeFileConfigFieldNumber = 102,
-    kProcessStatsConfigFieldNumber = 103,
-    kSysStatsConfigFieldNumber = 104,
-    kHeapprofdConfigFieldNumber = 105,
-    kJavaHprofConfigFieldNumber = 110,
-    kAndroidPowerConfigFieldNumber = 106,
-    kAndroidLogConfigFieldNumber = 107,
-    kGpuCounterConfigFieldNumber = 108,
-    kAndroidGameInterventionListConfigFieldNumber = 116,
-    kPackagesListConfigFieldNumber = 109,
-    kPerfEventConfigFieldNumber = 111,
-    kVulkanMemoryConfigFieldNumber = 112,
-    kTrackEventConfigFieldNumber = 113,
-    kAndroidPolledStateConfigFieldNumber = 114,
-    kAndroidSystemPropertyConfigFieldNumber = 118,
-    kStatsdTracingConfigFieldNumber = 117,
-    kSystemInfoConfigFieldNumber = 119,
-    kChromeConfigFieldNumber = 101,
-    kInterceptorConfigFieldNumber = 115,
-    kNetworkPacketTraceConfigFieldNumber = 120,
-    kLegacyConfigFieldNumber = 1000,
-    kForTestingFieldNumber = 1001,
+    kStateMachineFieldNumber = 1,
+    kObservingBeginFrameSourceFieldNumber = 2,
+    kBeginImplFrameDeadlineTaskFieldNumber = 3,
+    kPendingBeginFrameTaskFieldNumber = 4,
+    kSkippedLastFrameMissedExceededDeadlineFieldNumber = 5,
+    kInsideActionFieldNumber = 7,
+    kDeadlineModeFieldNumber = 8,
+    kDeadlineUsFieldNumber = 9,
+    kDeadlineScheduledAtUsFieldNumber = 10,
+    kNowUsFieldNumber = 11,
+    kNowToDeadlineDeltaUsFieldNumber = 12,
+    kNowToDeadlineScheduledAtDeltaUsFieldNumber = 13,
+    kBeginImplFrameArgsFieldNumber = 14,
+    kBeginFrameObserverStateFieldNumber = 15,
+    kBeginFrameSourceStateFieldNumber = 16,
+    kCompositorTimingHistoryFieldNumber = 17,
   };
 
-  DataSourceConfig();
-  ~DataSourceConfig() override;
-  DataSourceConfig(DataSourceConfig&&) noexcept;
-  DataSourceConfig& operator=(DataSourceConfig&&);
-  DataSourceConfig(const DataSourceConfig&);
-  DataSourceConfig& operator=(const DataSourceConfig&);
-  bool operator==(const DataSourceConfig&) const;
-  bool operator!=(const DataSourceConfig& other) const { return !(*this == other); }
+  ChromeCompositorSchedulerState();
+  ~ChromeCompositorSchedulerState() override;
+  ChromeCompositorSchedulerState(ChromeCompositorSchedulerState&&) noexcept;
+  ChromeCompositorSchedulerState& operator=(ChromeCompositorSchedulerState&&);
+  ChromeCompositorSchedulerState(const ChromeCompositorSchedulerState&);
+  ChromeCompositorSchedulerState& operator=(const ChromeCompositorSchedulerState&);
+  bool operator==(const ChromeCompositorSchedulerState&) const;
+  bool operator!=(const ChromeCompositorSchedulerState& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_name() const { return _has_field_[1]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
-
-  bool has_target_buffer() const { return _has_field_[2]; }
-  uint32_t target_buffer() const { return target_buffer_; }
-  void set_target_buffer(uint32_t value) { target_buffer_ = value; _has_field_.set(2); }
-
-  bool has_trace_duration_ms() const { return _has_field_[3]; }
-  uint32_t trace_duration_ms() const { return trace_duration_ms_; }
-  void set_trace_duration_ms(uint32_t value) { trace_duration_ms_ = value; _has_field_.set(3); }
-
-  bool has_prefer_suspend_clock_for_duration() const { return _has_field_[122]; }
-  bool prefer_suspend_clock_for_duration() const { return prefer_suspend_clock_for_duration_; }
-  void set_prefer_suspend_clock_for_duration(bool value) { prefer_suspend_clock_for_duration_ = value; _has_field_.set(122); }
-
-  bool has_stop_timeout_ms() const { return _has_field_[7]; }
-  uint32_t stop_timeout_ms() const { return stop_timeout_ms_; }
-  void set_stop_timeout_ms(uint32_t value) { stop_timeout_ms_ = value; _has_field_.set(7); }
-
-  bool has_enable_extra_guardrails() const { return _has_field_[6]; }
-  bool enable_extra_guardrails() const { return enable_extra_guardrails_; }
-  void set_enable_extra_guardrails(bool value) { enable_extra_guardrails_ = value; _has_field_.set(6); }
-
-  bool has_session_initiator() const { return _has_field_[8]; }
-  DataSourceConfig_SessionInitiator session_initiator() const { return session_initiator_; }
-  void set_session_initiator(DataSourceConfig_SessionInitiator value) { session_initiator_ = value; _has_field_.set(8); }
-
-  bool has_tracing_session_id() const { return _has_field_[4]; }
-  uint64_t tracing_session_id() const { return tracing_session_id_; }
-  void set_tracing_session_id(uint64_t value) { tracing_session_id_ = value; _has_field_.set(4); }
-
-  const std::string& ftrace_config_raw() const { return ftrace_config_; }
-  void set_ftrace_config_raw(const std::string& raw) { ftrace_config_ = raw; _has_field_.set(100); }
-
-  const std::string& inode_file_config_raw() const { return inode_file_config_; }
-  void set_inode_file_config_raw(const std::string& raw) { inode_file_config_ = raw; _has_field_.set(102); }
-
-  const std::string& process_stats_config_raw() const { return process_stats_config_; }
-  void set_process_stats_config_raw(const std::string& raw) { process_stats_config_ = raw; _has_field_.set(103); }
-
-  const std::string& sys_stats_config_raw() const { return sys_stats_config_; }
-  void set_sys_stats_config_raw(const std::string& raw) { sys_stats_config_ = raw; _has_field_.set(104); }
-
-  const std::string& heapprofd_config_raw() const { return heapprofd_config_; }
-  void set_heapprofd_config_raw(const std::string& raw) { heapprofd_config_ = raw; _has_field_.set(105); }
-
-  const std::string& java_hprof_config_raw() const { return java_hprof_config_; }
-  void set_java_hprof_config_raw(const std::string& raw) { java_hprof_config_ = raw; _has_field_.set(110); }
-
-  const std::string& android_power_config_raw() const { return android_power_config_; }
-  void set_android_power_config_raw(const std::string& raw) { android_power_config_ = raw; _has_field_.set(106); }
-
-  const std::string& android_log_config_raw() const { return android_log_config_; }
-  void set_android_log_config_raw(const std::string& raw) { android_log_config_ = raw; _has_field_.set(107); }
+  bool has_state_machine() const { return _has_field_[1]; }
+  const ChromeCompositorStateMachine& state_machine() const { return *state_machine_; }
+  ChromeCompositorStateMachine* mutable_state_machine() { _has_field_.set(1); return state_machine_.get(); }
 
-  const std::string& gpu_counter_config_raw() const { return gpu_counter_config_; }
-  void set_gpu_counter_config_raw(const std::string& raw) { gpu_counter_config_ = raw; _has_field_.set(108); }
+  bool has_observing_begin_frame_source() const { return _has_field_[2]; }
+  bool observing_begin_frame_source() const { return observing_begin_frame_source_; }
+  void set_observing_begin_frame_source(bool value) { observing_begin_frame_source_ = value; _has_field_.set(2); }
 
-  const std::string& android_game_intervention_list_config_raw() const { return android_game_intervention_list_config_; }
-  void set_android_game_intervention_list_config_raw(const std::string& raw) { android_game_intervention_list_config_ = raw; _has_field_.set(116); }
+  bool has_begin_impl_frame_deadline_task() const { return _has_field_[3]; }
+  bool begin_impl_frame_deadline_task() const { return begin_impl_frame_deadline_task_; }
+  void set_begin_impl_frame_deadline_task(bool value) { begin_impl_frame_deadline_task_ = value; _has_field_.set(3); }
 
-  const std::string& packages_list_config_raw() const { return packages_list_config_; }
-  void set_packages_list_config_raw(const std::string& raw) { packages_list_config_ = raw; _has_field_.set(109); }
+  bool has_pending_begin_frame_task() const { return _has_field_[4]; }
+  bool pending_begin_frame_task() const { return pending_begin_frame_task_; }
+  void set_pending_begin_frame_task(bool value) { pending_begin_frame_task_ = value; _has_field_.set(4); }
 
-  const std::string& perf_event_config_raw() const { return perf_event_config_; }
-  void set_perf_event_config_raw(const std::string& raw) { perf_event_config_ = raw; _has_field_.set(111); }
+  bool has_skipped_last_frame_missed_exceeded_deadline() const { return _has_field_[5]; }
+  bool skipped_last_frame_missed_exceeded_deadline() const { return skipped_last_frame_missed_exceeded_deadline_; }
+  void set_skipped_last_frame_missed_exceeded_deadline(bool value) { skipped_last_frame_missed_exceeded_deadline_ = value; _has_field_.set(5); }
 
-  const std::string& vulkan_memory_config_raw() const { return vulkan_memory_config_; }
-  void set_vulkan_memory_config_raw(const std::string& raw) { vulkan_memory_config_ = raw; _has_field_.set(112); }
+  bool has_inside_action() const { return _has_field_[7]; }
+  ChromeCompositorSchedulerAction inside_action() const { return inside_action_; }
+  void set_inside_action(ChromeCompositorSchedulerAction value) { inside_action_ = value; _has_field_.set(7); }
 
-  const std::string& track_event_config_raw() const { return track_event_config_; }
-  void set_track_event_config_raw(const std::string& raw) { track_event_config_ = raw; _has_field_.set(113); }
+  bool has_deadline_mode() const { return _has_field_[8]; }
+  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode deadline_mode() const { return deadline_mode_; }
+  void set_deadline_mode(ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode value) { deadline_mode_ = value; _has_field_.set(8); }
 
-  const std::string& android_polled_state_config_raw() const { return android_polled_state_config_; }
-  void set_android_polled_state_config_raw(const std::string& raw) { android_polled_state_config_ = raw; _has_field_.set(114); }
+  bool has_deadline_us() const { return _has_field_[9]; }
+  int64_t deadline_us() const { return deadline_us_; }
+  void set_deadline_us(int64_t value) { deadline_us_ = value; _has_field_.set(9); }
 
-  const std::string& android_system_property_config_raw() const { return android_system_property_config_; }
-  void set_android_system_property_config_raw(const std::string& raw) { android_system_property_config_ = raw; _has_field_.set(118); }
+  bool has_deadline_scheduled_at_us() const { return _has_field_[10]; }
+  int64_t deadline_scheduled_at_us() const { return deadline_scheduled_at_us_; }
+  void set_deadline_scheduled_at_us(int64_t value) { deadline_scheduled_at_us_ = value; _has_field_.set(10); }
 
-  const std::string& statsd_tracing_config_raw() const { return statsd_tracing_config_; }
-  void set_statsd_tracing_config_raw(const std::string& raw) { statsd_tracing_config_ = raw; _has_field_.set(117); }
+  bool has_now_us() const { return _has_field_[11]; }
+  int64_t now_us() const { return now_us_; }
+  void set_now_us(int64_t value) { now_us_ = value; _has_field_.set(11); }
 
-  bool has_system_info_config() const { return _has_field_[119]; }
-  const SystemInfoConfig& system_info_config() const { return *system_info_config_; }
-  SystemInfoConfig* mutable_system_info_config() { _has_field_.set(119); return system_info_config_.get(); }
+  bool has_now_to_deadline_delta_us() const { return _has_field_[12]; }
+  int64_t now_to_deadline_delta_us() const { return now_to_deadline_delta_us_; }
+  void set_now_to_deadline_delta_us(int64_t value) { now_to_deadline_delta_us_ = value; _has_field_.set(12); }
 
-  bool has_chrome_config() const { return _has_field_[101]; }
-  const ChromeConfig& chrome_config() const { return *chrome_config_; }
-  ChromeConfig* mutable_chrome_config() { _has_field_.set(101); return chrome_config_.get(); }
+  bool has_now_to_deadline_scheduled_at_delta_us() const { return _has_field_[13]; }
+  int64_t now_to_deadline_scheduled_at_delta_us() const { return now_to_deadline_scheduled_at_delta_us_; }
+  void set_now_to_deadline_scheduled_at_delta_us(int64_t value) { now_to_deadline_scheduled_at_delta_us_ = value; _has_field_.set(13); }
 
-  bool has_interceptor_config() const { return _has_field_[115]; }
-  const InterceptorConfig& interceptor_config() const { return *interceptor_config_; }
-  InterceptorConfig* mutable_interceptor_config() { _has_field_.set(115); return interceptor_config_.get(); }
+  bool has_begin_impl_frame_args() const { return _has_field_[14]; }
+  const BeginImplFrameArgs& begin_impl_frame_args() const { return *begin_impl_frame_args_; }
+  BeginImplFrameArgs* mutable_begin_impl_frame_args() { _has_field_.set(14); return begin_impl_frame_args_.get(); }
 
-  const std::string& network_packet_trace_config_raw() const { return network_packet_trace_config_; }
-  void set_network_packet_trace_config_raw(const std::string& raw) { network_packet_trace_config_ = raw; _has_field_.set(120); }
+  bool has_begin_frame_observer_state() const { return _has_field_[15]; }
+  const BeginFrameObserverState& begin_frame_observer_state() const { return *begin_frame_observer_state_; }
+  BeginFrameObserverState* mutable_begin_frame_observer_state() { _has_field_.set(15); return begin_frame_observer_state_.get(); }
 
-  bool has_legacy_config() const { return _has_field_[1000]; }
-  const std::string& legacy_config() const { return legacy_config_; }
-  void set_legacy_config(const std::string& value) { legacy_config_ = value; _has_field_.set(1000); }
+  bool has_begin_frame_source_state() const { return _has_field_[16]; }
+  const BeginFrameSourceState& begin_frame_source_state() const { return *begin_frame_source_state_; }
+  BeginFrameSourceState* mutable_begin_frame_source_state() { _has_field_.set(16); return begin_frame_source_state_.get(); }
 
-  bool has_for_testing() const { return _has_field_[1001]; }
-  const TestConfig& for_testing() const { return *for_testing_; }
-  TestConfig* mutable_for_testing() { _has_field_.set(1001); return for_testing_.get(); }
+  bool has_compositor_timing_history() const { return _has_field_[17]; }
+  const CompositorTimingHistory& compositor_timing_history() const { return *compositor_timing_history_; }
+  CompositorTimingHistory* mutable_compositor_timing_history() { _has_field_.set(17); return compositor_timing_history_.get(); }
 
  private:
-  std::string name_{};
-  uint32_t target_buffer_{};
-  uint32_t trace_duration_ms_{};
-  bool prefer_suspend_clock_for_duration_{};
-  uint32_t stop_timeout_ms_{};
-  bool enable_extra_guardrails_{};
-  DataSourceConfig_SessionInitiator session_initiator_{};
-  uint64_t tracing_session_id_{};
-  std::string ftrace_config_;  // [lazy=true]
-  std::string inode_file_config_;  // [lazy=true]
-  std::string process_stats_config_;  // [lazy=true]
-  std::string sys_stats_config_;  // [lazy=true]
-  std::string heapprofd_config_;  // [lazy=true]
-  std::string java_hprof_config_;  // [lazy=true]
-  std::string android_power_config_;  // [lazy=true]
-  std::string android_log_config_;  // [lazy=true]
-  std::string gpu_counter_config_;  // [lazy=true]
-  std::string android_game_intervention_list_config_;  // [lazy=true]
-  std::string packages_list_config_;  // [lazy=true]
-  std::string perf_event_config_;  // [lazy=true]
-  std::string vulkan_memory_config_;  // [lazy=true]
-  std::string track_event_config_;  // [lazy=true]
-  std::string android_polled_state_config_;  // [lazy=true]
-  std::string android_system_property_config_;  // [lazy=true]
-  std::string statsd_tracing_config_;  // [lazy=true]
-  ::protozero::CopyablePtr<SystemInfoConfig> system_info_config_;
-  ::protozero::CopyablePtr<ChromeConfig> chrome_config_;
-  ::protozero::CopyablePtr<InterceptorConfig> interceptor_config_;
-  std::string network_packet_trace_config_;  // [lazy=true]
-  std::string legacy_config_{};
-  ::protozero::CopyablePtr<TestConfig> for_testing_;
+  ::protozero::CopyablePtr<ChromeCompositorStateMachine> state_machine_;
+  bool observing_begin_frame_source_{};
+  bool begin_impl_frame_deadline_task_{};
+  bool pending_begin_frame_task_{};
+  bool skipped_last_frame_missed_exceeded_deadline_{};
+  ChromeCompositorSchedulerAction inside_action_{};
+  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode deadline_mode_{};
+  int64_t deadline_us_{};
+  int64_t deadline_scheduled_at_us_{};
+  int64_t now_us_{};
+  int64_t now_to_deadline_delta_us_{};
+  int64_t now_to_deadline_scheduled_at_delta_us_{};
+  ::protozero::CopyablePtr<BeginImplFrameArgs> begin_impl_frame_args_;
+  ::protozero::CopyablePtr<BeginFrameObserverState> begin_frame_observer_state_;
+  ::protozero::CopyablePtr<BeginFrameSourceState> begin_frame_source_state_;
+  ::protozero::CopyablePtr<CompositorTimingHistory> compositor_timing_history_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<1002> _has_field_{};
+  std::bitset<18> _has_field_{};
 };
 
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_DATA_SOURCE_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/interceptor_config.gen.h
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_COMPOSITOR_SCHEDULER_STATE_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_content_settings_event_info.gen.h
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTOR_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTOR_CONFIG_PROTO_CPP_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_CONTENT_SETTINGS_EVENT_INFO_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_CONTENT_SETTINGS_EVENT_INFO_PROTO_CPP_H_
 
 #include <stdint.h>
 #include <bitset>
@@ -170223,7 +190154,7 @@ class PERFETTO_EXPORT_COMPONENT DataSourceConfig : public ::protozero::CppMessag
 namespace perfetto {
 namespace protos {
 namespace gen {
-class InterceptorConfig;
+class ChromeContentSettingsEventInfo;
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
@@ -170236,54 +190167,49 @@ namespace perfetto {
 namespace protos {
 namespace gen {
 
-class PERFETTO_EXPORT_COMPONENT InterceptorConfig : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT ChromeContentSettingsEventInfo : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kNameFieldNumber = 1,
-    kConsoleConfigFieldNumber = 100,
+    kNumberOfExceptionsFieldNumber = 1,
   };
 
-  InterceptorConfig();
-  ~InterceptorConfig() override;
-  InterceptorConfig(InterceptorConfig&&) noexcept;
-  InterceptorConfig& operator=(InterceptorConfig&&);
-  InterceptorConfig(const InterceptorConfig&);
-  InterceptorConfig& operator=(const InterceptorConfig&);
-  bool operator==(const InterceptorConfig&) const;
-  bool operator!=(const InterceptorConfig& other) const { return !(*this == other); }
+  ChromeContentSettingsEventInfo();
+  ~ChromeContentSettingsEventInfo() override;
+  ChromeContentSettingsEventInfo(ChromeContentSettingsEventInfo&&) noexcept;
+  ChromeContentSettingsEventInfo& operator=(ChromeContentSettingsEventInfo&&);
+  ChromeContentSettingsEventInfo(const ChromeContentSettingsEventInfo&);
+  ChromeContentSettingsEventInfo& operator=(const ChromeContentSettingsEventInfo&);
+  bool operator==(const ChromeContentSettingsEventInfo&) const;
+  bool operator!=(const ChromeContentSettingsEventInfo& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_name() const { return _has_field_[1]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
-
-  const std::string& console_config_raw() const { return console_config_; }
-  void set_console_config_raw(const std::string& raw) { console_config_ = raw; _has_field_.set(100); }
+  bool has_number_of_exceptions() const { return _has_field_[1]; }
+  uint32_t number_of_exceptions() const { return number_of_exceptions_; }
+  void set_number_of_exceptions(uint32_t value) { number_of_exceptions_ = value; _has_field_.set(1); }
 
  private:
-  std::string name_{};
-  std::string console_config_;  // [lazy=true]
+  uint32_t number_of_exceptions_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<101> _has_field_{};
+  std::bitset<2> _has_field_{};
 };
 
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_INTERCEPTOR_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/stress_test_config.gen.h
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_CONTENT_SETTINGS_EVENT_INFO_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_frame_reporter.gen.h
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STRESS_TEST_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STRESS_TEST_CONFIG_PROTO_CPP_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_FRAME_REPORTER_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_FRAME_REPORTER_PROTO_CPP_H_
 
 #include <stdint.h>
 #include <bitset>
@@ -170298,36 +190224,11 @@ class PERFETTO_EXPORT_COMPONENT InterceptorConfig : public ::protozero::CppMessa
 namespace perfetto {
 namespace protos {
 namespace gen {
-class StressTestConfig;
-class StressTestConfig_WriterTiming;
-class TraceConfig;
-class TraceConfig_CmdTraceStartDelay;
-class TraceConfig_AndroidReportConfig;
-class TraceConfig_TraceFilter;
-class TraceConfig_IncidentReportConfig;
-class TraceConfig_IncrementalStateConfig;
-class TraceConfig_TriggerConfig;
-class TraceConfig_TriggerConfig_Trigger;
-class TraceConfig_GuardrailOverrides;
-class TraceConfig_StatsdMetadata;
-class TraceConfig_ProducerConfig;
-class TraceConfig_BuiltinDataSource;
-class TraceConfig_DataSource;
-class DataSourceConfig;
-class TestConfig;
-class TestConfig_DummyFields;
-class InterceptorConfig;
-class ChromeConfig;
-class SystemInfoConfig;
-class TraceConfig_BufferConfig;
-enum TraceConfig_LockdownModeOperation : int;
-enum TraceConfig_CompressionType : int;
-enum TraceConfig_StatsdLogging : int;
-enum TraceConfig_TriggerConfig_TriggerMode : int;
-enum BuiltinClock : int;
-enum DataSourceConfig_SessionInitiator : int;
-enum ChromeConfig_ClientPriority : int;
-enum TraceConfig_BufferConfig_FillPolicy : int;
+class ChromeFrameReporter;
+enum ChromeFrameReporter_State : int;
+enum ChromeFrameReporter_FrameDropReason : int;
+enum ChromeFrameReporter_ScrollState : int;
+enum ChromeFrameReporter_FrameType : int;
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
@@ -170339,170 +190240,205 @@ class Message;
 namespace perfetto {
 namespace protos {
 namespace gen {
+enum ChromeFrameReporter_State : int {
+  ChromeFrameReporter_State_STATE_NO_UPDATE_DESIRED = 0,
+  ChromeFrameReporter_State_STATE_PRESENTED_ALL = 1,
+  ChromeFrameReporter_State_STATE_PRESENTED_PARTIAL = 2,
+  ChromeFrameReporter_State_STATE_DROPPED = 3,
+};
+enum ChromeFrameReporter_FrameDropReason : int {
+  ChromeFrameReporter_FrameDropReason_REASON_UNSPECIFIED = 0,
+  ChromeFrameReporter_FrameDropReason_REASON_DISPLAY_COMPOSITOR = 1,
+  ChromeFrameReporter_FrameDropReason_REASON_MAIN_THREAD = 2,
+  ChromeFrameReporter_FrameDropReason_REASON_CLIENT_COMPOSITOR = 3,
+};
+enum ChromeFrameReporter_ScrollState : int {
+  ChromeFrameReporter_ScrollState_SCROLL_NONE = 0,
+  ChromeFrameReporter_ScrollState_SCROLL_MAIN_THREAD = 1,
+  ChromeFrameReporter_ScrollState_SCROLL_COMPOSITOR_THREAD = 2,
+  ChromeFrameReporter_ScrollState_SCROLL_RASTER = 3,
+  ChromeFrameReporter_ScrollState_SCROLL_UNKNOWN = 4,
+};
+enum ChromeFrameReporter_FrameType : int {
+  ChromeFrameReporter_FrameType_FORKED = 0,
+  ChromeFrameReporter_FrameType_BACKFILL = 1,
+};
 
-class PERFETTO_EXPORT_COMPONENT StressTestConfig : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT ChromeFrameReporter : public ::protozero::CppMessageObj {
  public:
-  using WriterTiming = StressTestConfig_WriterTiming;
+  using State = ChromeFrameReporter_State;
+  static constexpr auto STATE_NO_UPDATE_DESIRED = ChromeFrameReporter_State_STATE_NO_UPDATE_DESIRED;
+  static constexpr auto STATE_PRESENTED_ALL = ChromeFrameReporter_State_STATE_PRESENTED_ALL;
+  static constexpr auto STATE_PRESENTED_PARTIAL = ChromeFrameReporter_State_STATE_PRESENTED_PARTIAL;
+  static constexpr auto STATE_DROPPED = ChromeFrameReporter_State_STATE_DROPPED;
+  static constexpr auto State_MIN = ChromeFrameReporter_State_STATE_NO_UPDATE_DESIRED;
+  static constexpr auto State_MAX = ChromeFrameReporter_State_STATE_DROPPED;
+  using FrameDropReason = ChromeFrameReporter_FrameDropReason;
+  static constexpr auto REASON_UNSPECIFIED = ChromeFrameReporter_FrameDropReason_REASON_UNSPECIFIED;
+  static constexpr auto REASON_DISPLAY_COMPOSITOR = ChromeFrameReporter_FrameDropReason_REASON_DISPLAY_COMPOSITOR;
+  static constexpr auto REASON_MAIN_THREAD = ChromeFrameReporter_FrameDropReason_REASON_MAIN_THREAD;
+  static constexpr auto REASON_CLIENT_COMPOSITOR = ChromeFrameReporter_FrameDropReason_REASON_CLIENT_COMPOSITOR;
+  static constexpr auto FrameDropReason_MIN = ChromeFrameReporter_FrameDropReason_REASON_UNSPECIFIED;
+  static constexpr auto FrameDropReason_MAX = ChromeFrameReporter_FrameDropReason_REASON_CLIENT_COMPOSITOR;
+  using ScrollState = ChromeFrameReporter_ScrollState;
+  static constexpr auto SCROLL_NONE = ChromeFrameReporter_ScrollState_SCROLL_NONE;
+  static constexpr auto SCROLL_MAIN_THREAD = ChromeFrameReporter_ScrollState_SCROLL_MAIN_THREAD;
+  static constexpr auto SCROLL_COMPOSITOR_THREAD = ChromeFrameReporter_ScrollState_SCROLL_COMPOSITOR_THREAD;
+  static constexpr auto SCROLL_RASTER = ChromeFrameReporter_ScrollState_SCROLL_RASTER;
+  static constexpr auto SCROLL_UNKNOWN = ChromeFrameReporter_ScrollState_SCROLL_UNKNOWN;
+  static constexpr auto ScrollState_MIN = ChromeFrameReporter_ScrollState_SCROLL_NONE;
+  static constexpr auto ScrollState_MAX = ChromeFrameReporter_ScrollState_SCROLL_UNKNOWN;
+  using FrameType = ChromeFrameReporter_FrameType;
+  static constexpr auto FORKED = ChromeFrameReporter_FrameType_FORKED;
+  static constexpr auto BACKFILL = ChromeFrameReporter_FrameType_BACKFILL;
+  static constexpr auto FrameType_MIN = ChromeFrameReporter_FrameType_FORKED;
+  static constexpr auto FrameType_MAX = ChromeFrameReporter_FrameType_BACKFILL;
   enum FieldNumbers {
-    kTraceConfigFieldNumber = 1,
-    kShmemSizeKbFieldNumber = 2,
-    kShmemPageSizeKbFieldNumber = 3,
-    kNumProcessesFieldNumber = 4,
-    kNumThreadsFieldNumber = 5,
-    kMaxEventsFieldNumber = 6,
-    kNestingFieldNumber = 7,
-    kSteadyStateTimingsFieldNumber = 8,
-    kBurstPeriodMsFieldNumber = 9,
-    kBurstDurationMsFieldNumber = 10,
-    kBurstTimingsFieldNumber = 11,
+    kStateFieldNumber = 1,
+    kReasonFieldNumber = 2,
+    kFrameSourceFieldNumber = 3,
+    kFrameSequenceFieldNumber = 4,
+    kAffectsSmoothnessFieldNumber = 5,
+    kScrollStateFieldNumber = 6,
+    kHasMainAnimationFieldNumber = 7,
+    kHasCompositorAnimationFieldNumber = 8,
+    kHasSmoothInputMainFieldNumber = 9,
+    kHasMissingContentFieldNumber = 10,
+    kLayerTreeHostIdFieldNumber = 11,
+    kHasHighLatencyFieldNumber = 12,
+    kFrameTypeFieldNumber = 13,
+    kHighLatencyContributionStageFieldNumber = 14,
+    kCheckerboardedNeedsRasterFieldNumber = 15,
+    kCheckerboardedNeedsRecordFieldNumber = 16,
+    kSurfaceFrameTraceIdFieldNumber = 17,
+    kDisplayTraceIdFieldNumber = 18,
   };
 
-  StressTestConfig();
-  ~StressTestConfig() override;
-  StressTestConfig(StressTestConfig&&) noexcept;
-  StressTestConfig& operator=(StressTestConfig&&);
-  StressTestConfig(const StressTestConfig&);
-  StressTestConfig& operator=(const StressTestConfig&);
-  bool operator==(const StressTestConfig&) const;
-  bool operator!=(const StressTestConfig& other) const { return !(*this == other); }
+  ChromeFrameReporter();
+  ~ChromeFrameReporter() override;
+  ChromeFrameReporter(ChromeFrameReporter&&) noexcept;
+  ChromeFrameReporter& operator=(ChromeFrameReporter&&);
+  ChromeFrameReporter(const ChromeFrameReporter&);
+  ChromeFrameReporter& operator=(const ChromeFrameReporter&);
+  bool operator==(const ChromeFrameReporter&) const;
+  bool operator!=(const ChromeFrameReporter& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_trace_config() const { return _has_field_[1]; }
-  const TraceConfig& trace_config() const { return *trace_config_; }
-  TraceConfig* mutable_trace_config() { _has_field_.set(1); return trace_config_.get(); }
-
-  bool has_shmem_size_kb() const { return _has_field_[2]; }
-  uint32_t shmem_size_kb() const { return shmem_size_kb_; }
-  void set_shmem_size_kb(uint32_t value) { shmem_size_kb_ = value; _has_field_.set(2); }
-
-  bool has_shmem_page_size_kb() const { return _has_field_[3]; }
-  uint32_t shmem_page_size_kb() const { return shmem_page_size_kb_; }
-  void set_shmem_page_size_kb(uint32_t value) { shmem_page_size_kb_ = value; _has_field_.set(3); }
-
-  bool has_num_processes() const { return _has_field_[4]; }
-  uint32_t num_processes() const { return num_processes_; }
-  void set_num_processes(uint32_t value) { num_processes_ = value; _has_field_.set(4); }
-
-  bool has_num_threads() const { return _has_field_[5]; }
-  uint32_t num_threads() const { return num_threads_; }
-  void set_num_threads(uint32_t value) { num_threads_ = value; _has_field_.set(5); }
-
-  bool has_max_events() const { return _has_field_[6]; }
-  uint32_t max_events() const { return max_events_; }
-  void set_max_events(uint32_t value) { max_events_ = value; _has_field_.set(6); }
+  bool has_state() const { return _has_field_[1]; }
+  ChromeFrameReporter_State state() const { return state_; }
+  void set_state(ChromeFrameReporter_State value) { state_ = value; _has_field_.set(1); }
 
-  bool has_nesting() const { return _has_field_[7]; }
-  uint32_t nesting() const { return nesting_; }
-  void set_nesting(uint32_t value) { nesting_ = value; _has_field_.set(7); }
+  bool has_reason() const { return _has_field_[2]; }
+  ChromeFrameReporter_FrameDropReason reason() const { return reason_; }
+  void set_reason(ChromeFrameReporter_FrameDropReason value) { reason_ = value; _has_field_.set(2); }
 
-  bool has_steady_state_timings() const { return _has_field_[8]; }
-  const StressTestConfig_WriterTiming& steady_state_timings() const { return *steady_state_timings_; }
-  StressTestConfig_WriterTiming* mutable_steady_state_timings() { _has_field_.set(8); return steady_state_timings_.get(); }
+  bool has_frame_source() const { return _has_field_[3]; }
+  uint64_t frame_source() const { return frame_source_; }
+  void set_frame_source(uint64_t value) { frame_source_ = value; _has_field_.set(3); }
 
-  bool has_burst_period_ms() const { return _has_field_[9]; }
-  uint32_t burst_period_ms() const { return burst_period_ms_; }
-  void set_burst_period_ms(uint32_t value) { burst_period_ms_ = value; _has_field_.set(9); }
+  bool has_frame_sequence() const { return _has_field_[4]; }
+  uint64_t frame_sequence() const { return frame_sequence_; }
+  void set_frame_sequence(uint64_t value) { frame_sequence_ = value; _has_field_.set(4); }
 
-  bool has_burst_duration_ms() const { return _has_field_[10]; }
-  uint32_t burst_duration_ms() const { return burst_duration_ms_; }
-  void set_burst_duration_ms(uint32_t value) { burst_duration_ms_ = value; _has_field_.set(10); }
+  bool has_affects_smoothness() const { return _has_field_[5]; }
+  bool affects_smoothness() const { return affects_smoothness_; }
+  void set_affects_smoothness(bool value) { affects_smoothness_ = value; _has_field_.set(5); }
 
-  bool has_burst_timings() const { return _has_field_[11]; }
-  const StressTestConfig_WriterTiming& burst_timings() const { return *burst_timings_; }
-  StressTestConfig_WriterTiming* mutable_burst_timings() { _has_field_.set(11); return burst_timings_.get(); }
+  bool has_scroll_state() const { return _has_field_[6]; }
+  ChromeFrameReporter_ScrollState scroll_state() const { return scroll_state_; }
+  void set_scroll_state(ChromeFrameReporter_ScrollState value) { scroll_state_ = value; _has_field_.set(6); }
 
- private:
-  ::protozero::CopyablePtr<TraceConfig> trace_config_;
-  uint32_t shmem_size_kb_{};
-  uint32_t shmem_page_size_kb_{};
-  uint32_t num_processes_{};
-  uint32_t num_threads_{};
-  uint32_t max_events_{};
-  uint32_t nesting_{};
-  ::protozero::CopyablePtr<StressTestConfig_WriterTiming> steady_state_timings_;
-  uint32_t burst_period_ms_{};
-  uint32_t burst_duration_ms_{};
-  ::protozero::CopyablePtr<StressTestConfig_WriterTiming> burst_timings_;
+  bool has_has_main_animation() const { return _has_field_[7]; }
+  bool has_main_animation() const { return has_main_animation_; }
+  void set_has_main_animation(bool value) { has_main_animation_ = value; _has_field_.set(7); }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  bool has_has_compositor_animation() const { return _has_field_[8]; }
+  bool has_compositor_animation() const { return has_compositor_animation_; }
+  void set_has_compositor_animation(bool value) { has_compositor_animation_ = value; _has_field_.set(8); }
 
-  std::bitset<12> _has_field_{};
-};
+  bool has_has_smooth_input_main() const { return _has_field_[9]; }
+  bool has_smooth_input_main() const { return has_smooth_input_main_; }
+  void set_has_smooth_input_main(bool value) { has_smooth_input_main_ = value; _has_field_.set(9); }
 
+  bool has_has_missing_content() const { return _has_field_[10]; }
+  bool has_missing_content() const { return has_missing_content_; }
+  void set_has_missing_content(bool value) { has_missing_content_ = value; _has_field_.set(10); }
 
-class PERFETTO_EXPORT_COMPONENT StressTestConfig_WriterTiming : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kPayloadMeanFieldNumber = 1,
-    kPayloadStddevFieldNumber = 2,
-    kRateMeanFieldNumber = 3,
-    kRateStddevFieldNumber = 4,
-    kPayloadWriteTimeMsFieldNumber = 5,
-  };
+  bool has_layer_tree_host_id() const { return _has_field_[11]; }
+  uint64_t layer_tree_host_id() const { return layer_tree_host_id_; }
+  void set_layer_tree_host_id(uint64_t value) { layer_tree_host_id_ = value; _has_field_.set(11); }
 
-  StressTestConfig_WriterTiming();
-  ~StressTestConfig_WriterTiming() override;
-  StressTestConfig_WriterTiming(StressTestConfig_WriterTiming&&) noexcept;
-  StressTestConfig_WriterTiming& operator=(StressTestConfig_WriterTiming&&);
-  StressTestConfig_WriterTiming(const StressTestConfig_WriterTiming&);
-  StressTestConfig_WriterTiming& operator=(const StressTestConfig_WriterTiming&);
-  bool operator==(const StressTestConfig_WriterTiming&) const;
-  bool operator!=(const StressTestConfig_WriterTiming& other) const { return !(*this == other); }
+  bool has_has_high_latency() const { return _has_field_[12]; }
+  bool has_high_latency() const { return has_high_latency_; }
+  void set_has_high_latency(bool value) { has_high_latency_ = value; _has_field_.set(12); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  bool has_frame_type() const { return _has_field_[13]; }
+  ChromeFrameReporter_FrameType frame_type() const { return frame_type_; }
+  void set_frame_type(ChromeFrameReporter_FrameType value) { frame_type_ = value; _has_field_.set(13); }
 
-  bool has_payload_mean() const { return _has_field_[1]; }
-  double payload_mean() const { return payload_mean_; }
-  void set_payload_mean(double value) { payload_mean_ = value; _has_field_.set(1); }
+  const std::vector<std::string>& high_latency_contribution_stage() const { return high_latency_contribution_stage_; }
+  std::vector<std::string>* mutable_high_latency_contribution_stage() { return &high_latency_contribution_stage_; }
+  int high_latency_contribution_stage_size() const { return static_cast<int>(high_latency_contribution_stage_.size()); }
+  void clear_high_latency_contribution_stage() { high_latency_contribution_stage_.clear(); }
+  void add_high_latency_contribution_stage(std::string value) { high_latency_contribution_stage_.emplace_back(value); }
+  std::string* add_high_latency_contribution_stage() { high_latency_contribution_stage_.emplace_back(); return &high_latency_contribution_stage_.back(); }
 
-  bool has_payload_stddev() const { return _has_field_[2]; }
-  double payload_stddev() const { return payload_stddev_; }
-  void set_payload_stddev(double value) { payload_stddev_ = value; _has_field_.set(2); }
+  bool has_checkerboarded_needs_raster() const { return _has_field_[15]; }
+  bool checkerboarded_needs_raster() const { return checkerboarded_needs_raster_; }
+  void set_checkerboarded_needs_raster(bool value) { checkerboarded_needs_raster_ = value; _has_field_.set(15); }
 
-  bool has_rate_mean() const { return _has_field_[3]; }
-  double rate_mean() const { return rate_mean_; }
-  void set_rate_mean(double value) { rate_mean_ = value; _has_field_.set(3); }
+  bool has_checkerboarded_needs_record() const { return _has_field_[16]; }
+  bool checkerboarded_needs_record() const { return checkerboarded_needs_record_; }
+  void set_checkerboarded_needs_record(bool value) { checkerboarded_needs_record_ = value; _has_field_.set(16); }
 
-  bool has_rate_stddev() const { return _has_field_[4]; }
-  double rate_stddev() const { return rate_stddev_; }
-  void set_rate_stddev(double value) { rate_stddev_ = value; _has_field_.set(4); }
+  bool has_surface_frame_trace_id() const { return _has_field_[17]; }
+  int64_t surface_frame_trace_id() const { return surface_frame_trace_id_; }
+  void set_surface_frame_trace_id(int64_t value) { surface_frame_trace_id_ = value; _has_field_.set(17); }
 
-  bool has_payload_write_time_ms() const { return _has_field_[5]; }
-  uint32_t payload_write_time_ms() const { return payload_write_time_ms_; }
-  void set_payload_write_time_ms(uint32_t value) { payload_write_time_ms_ = value; _has_field_.set(5); }
+  bool has_display_trace_id() const { return _has_field_[18]; }
+  int64_t display_trace_id() const { return display_trace_id_; }
+  void set_display_trace_id(int64_t value) { display_trace_id_ = value; _has_field_.set(18); }
 
  private:
-  double payload_mean_{};
-  double payload_stddev_{};
-  double rate_mean_{};
-  double rate_stddev_{};
-  uint32_t payload_write_time_ms_{};
+  ChromeFrameReporter_State state_{};
+  ChromeFrameReporter_FrameDropReason reason_{};
+  uint64_t frame_source_{};
+  uint64_t frame_sequence_{};
+  bool affects_smoothness_{};
+  ChromeFrameReporter_ScrollState scroll_state_{};
+  bool has_main_animation_{};
+  bool has_compositor_animation_{};
+  bool has_smooth_input_main_{};
+  bool has_missing_content_{};
+  uint64_t layer_tree_host_id_{};
+  bool has_high_latency_{};
+  ChromeFrameReporter_FrameType frame_type_{};
+  std::vector<std::string> high_latency_contribution_stage_;
+  bool checkerboarded_needs_raster_{};
+  bool checkerboarded_needs_record_{};
+  int64_t surface_frame_trace_id_{};
+  int64_t display_trace_id_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<6> _has_field_{};
+  std::bitset<19> _has_field_{};
 };
 
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_STRESS_TEST_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/test_config.gen.h
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_FRAME_REPORTER_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_histogram_sample.gen.h
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TEST_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TEST_CONFIG_PROTO_CPP_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_HISTOGRAM_SAMPLE_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_HISTOGRAM_SAMPLE_PROTO_CPP_H_
 
 #include <stdint.h>
 #include <bitset>
@@ -170517,8 +190453,8 @@ class PERFETTO_EXPORT_COMPONENT StressTestConfig_WriterTiming : public ::protoze
 namespace perfetto {
 namespace protos {
 namespace gen {
-class TestConfig;
-class TestConfig_DummyFields;
+class ChromeHistogramSample;
+class HistogramName;
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
@@ -170531,194 +190467,108 @@ namespace perfetto {
 namespace protos {
 namespace gen {
 
-class PERFETTO_EXPORT_COMPONENT TestConfig : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT ChromeHistogramSample : public ::protozero::CppMessageObj {
  public:
-  using DummyFields = TestConfig_DummyFields;
   enum FieldNumbers {
-    kMessageCountFieldNumber = 1,
-    kMaxMessagesPerSecondFieldNumber = 2,
-    kSeedFieldNumber = 3,
-    kMessageSizeFieldNumber = 4,
-    kSendBatchOnRegisterFieldNumber = 5,
-    kDummyFieldsFieldNumber = 6,
+    kNameHashFieldNumber = 1,
+    kNameFieldNumber = 2,
+    kSampleFieldNumber = 3,
+    kNameIidFieldNumber = 4,
   };
 
-  TestConfig();
-  ~TestConfig() override;
-  TestConfig(TestConfig&&) noexcept;
-  TestConfig& operator=(TestConfig&&);
-  TestConfig(const TestConfig&);
-  TestConfig& operator=(const TestConfig&);
-  bool operator==(const TestConfig&) const;
-  bool operator!=(const TestConfig& other) const { return !(*this == other); }
+  ChromeHistogramSample();
+  ~ChromeHistogramSample() override;
+  ChromeHistogramSample(ChromeHistogramSample&&) noexcept;
+  ChromeHistogramSample& operator=(ChromeHistogramSample&&);
+  ChromeHistogramSample(const ChromeHistogramSample&);
+  ChromeHistogramSample& operator=(const ChromeHistogramSample&);
+  bool operator==(const ChromeHistogramSample&) const;
+  bool operator!=(const ChromeHistogramSample& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_message_count() const { return _has_field_[1]; }
-  uint32_t message_count() const { return message_count_; }
-  void set_message_count(uint32_t value) { message_count_ = value; _has_field_.set(1); }
-
-  bool has_max_messages_per_second() const { return _has_field_[2]; }
-  uint32_t max_messages_per_second() const { return max_messages_per_second_; }
-  void set_max_messages_per_second(uint32_t value) { max_messages_per_second_ = value; _has_field_.set(2); }
-
-  bool has_seed() const { return _has_field_[3]; }
-  uint32_t seed() const { return seed_; }
-  void set_seed(uint32_t value) { seed_ = value; _has_field_.set(3); }
+  bool has_name_hash() const { return _has_field_[1]; }
+  uint64_t name_hash() const { return name_hash_; }
+  void set_name_hash(uint64_t value) { name_hash_ = value; _has_field_.set(1); }
 
-  bool has_message_size() const { return _has_field_[4]; }
-  uint32_t message_size() const { return message_size_; }
-  void set_message_size(uint32_t value) { message_size_ = value; _has_field_.set(4); }
+  bool has_name() const { return _has_field_[2]; }
+  const std::string& name() const { return name_; }
+  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
 
-  bool has_send_batch_on_register() const { return _has_field_[5]; }
-  bool send_batch_on_register() const { return send_batch_on_register_; }
-  void set_send_batch_on_register(bool value) { send_batch_on_register_ = value; _has_field_.set(5); }
+  bool has_sample() const { return _has_field_[3]; }
+  int64_t sample() const { return sample_; }
+  void set_sample(int64_t value) { sample_ = value; _has_field_.set(3); }
 
-  bool has_dummy_fields() const { return _has_field_[6]; }
-  const TestConfig_DummyFields& dummy_fields() const { return *dummy_fields_; }
-  TestConfig_DummyFields* mutable_dummy_fields() { _has_field_.set(6); return dummy_fields_.get(); }
+  bool has_name_iid() const { return _has_field_[4]; }
+  uint64_t name_iid() const { return name_iid_; }
+  void set_name_iid(uint64_t value) { name_iid_ = value; _has_field_.set(4); }
 
  private:
-  uint32_t message_count_{};
-  uint32_t max_messages_per_second_{};
-  uint32_t seed_{};
-  uint32_t message_size_{};
-  bool send_batch_on_register_{};
-  ::protozero::CopyablePtr<TestConfig_DummyFields> dummy_fields_;
+  uint64_t name_hash_{};
+  std::string name_{};
+  int64_t sample_{};
+  uint64_t name_iid_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<7> _has_field_{};
+  std::bitset<5> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT TestConfig_DummyFields : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT HistogramName : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kFieldUint32FieldNumber = 1,
-    kFieldInt32FieldNumber = 2,
-    kFieldUint64FieldNumber = 3,
-    kFieldInt64FieldNumber = 4,
-    kFieldFixed64FieldNumber = 5,
-    kFieldSfixed64FieldNumber = 6,
-    kFieldFixed32FieldNumber = 7,
-    kFieldSfixed32FieldNumber = 8,
-    kFieldDoubleFieldNumber = 9,
-    kFieldFloatFieldNumber = 10,
-    kFieldSint64FieldNumber = 11,
-    kFieldSint32FieldNumber = 12,
-    kFieldStringFieldNumber = 13,
-    kFieldBytesFieldNumber = 14,
+    kIidFieldNumber = 1,
+    kNameFieldNumber = 2,
   };
 
-  TestConfig_DummyFields();
-  ~TestConfig_DummyFields() override;
-  TestConfig_DummyFields(TestConfig_DummyFields&&) noexcept;
-  TestConfig_DummyFields& operator=(TestConfig_DummyFields&&);
-  TestConfig_DummyFields(const TestConfig_DummyFields&);
-  TestConfig_DummyFields& operator=(const TestConfig_DummyFields&);
-  bool operator==(const TestConfig_DummyFields&) const;
-  bool operator!=(const TestConfig_DummyFields& other) const { return !(*this == other); }
+  HistogramName();
+  ~HistogramName() override;
+  HistogramName(HistogramName&&) noexcept;
+  HistogramName& operator=(HistogramName&&);
+  HistogramName(const HistogramName&);
+  HistogramName& operator=(const HistogramName&);
+  bool operator==(const HistogramName&) const;
+  bool operator!=(const HistogramName& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_field_uint32() const { return _has_field_[1]; }
-  uint32_t field_uint32() const { return field_uint32_; }
-  void set_field_uint32(uint32_t value) { field_uint32_ = value; _has_field_.set(1); }
-
-  bool has_field_int32() const { return _has_field_[2]; }
-  int32_t field_int32() const { return field_int32_; }
-  void set_field_int32(int32_t value) { field_int32_ = value; _has_field_.set(2); }
-
-  bool has_field_uint64() const { return _has_field_[3]; }
-  uint64_t field_uint64() const { return field_uint64_; }
-  void set_field_uint64(uint64_t value) { field_uint64_ = value; _has_field_.set(3); }
-
-  bool has_field_int64() const { return _has_field_[4]; }
-  int64_t field_int64() const { return field_int64_; }
-  void set_field_int64(int64_t value) { field_int64_ = value; _has_field_.set(4); }
-
-  bool has_field_fixed64() const { return _has_field_[5]; }
-  uint64_t field_fixed64() const { return field_fixed64_; }
-  void set_field_fixed64(uint64_t value) { field_fixed64_ = value; _has_field_.set(5); }
-
-  bool has_field_sfixed64() const { return _has_field_[6]; }
-  int64_t field_sfixed64() const { return field_sfixed64_; }
-  void set_field_sfixed64(int64_t value) { field_sfixed64_ = value; _has_field_.set(6); }
-
-  bool has_field_fixed32() const { return _has_field_[7]; }
-  uint32_t field_fixed32() const { return field_fixed32_; }
-  void set_field_fixed32(uint32_t value) { field_fixed32_ = value; _has_field_.set(7); }
-
-  bool has_field_sfixed32() const { return _has_field_[8]; }
-  int32_t field_sfixed32() const { return field_sfixed32_; }
-  void set_field_sfixed32(int32_t value) { field_sfixed32_ = value; _has_field_.set(8); }
-
-  bool has_field_double() const { return _has_field_[9]; }
-  double field_double() const { return field_double_; }
-  void set_field_double(double value) { field_double_ = value; _has_field_.set(9); }
-
-  bool has_field_float() const { return _has_field_[10]; }
-  float field_float() const { return field_float_; }
-  void set_field_float(float value) { field_float_ = value; _has_field_.set(10); }
-
-  bool has_field_sint64() const { return _has_field_[11]; }
-  int64_t field_sint64() const { return field_sint64_; }
-  void set_field_sint64(int64_t value) { field_sint64_ = value; _has_field_.set(11); }
-
-  bool has_field_sint32() const { return _has_field_[12]; }
-  int32_t field_sint32() const { return field_sint32_; }
-  void set_field_sint32(int32_t value) { field_sint32_ = value; _has_field_.set(12); }
-
-  bool has_field_string() const { return _has_field_[13]; }
-  const std::string& field_string() const { return field_string_; }
-  void set_field_string(const std::string& value) { field_string_ = value; _has_field_.set(13); }
+  bool has_iid() const { return _has_field_[1]; }
+  uint64_t iid() const { return iid_; }
+  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
 
-  bool has_field_bytes() const { return _has_field_[14]; }
-  const std::string& field_bytes() const { return field_bytes_; }
-  void set_field_bytes(const std::string& value) { field_bytes_ = value; _has_field_.set(14); }
-  void set_field_bytes(const void* p, size_t s) { field_bytes_.assign(reinterpret_cast<const char*>(p), s); _has_field_.set(14); }
+  bool has_name() const { return _has_field_[2]; }
+  const std::string& name() const { return name_; }
+  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
 
  private:
-  uint32_t field_uint32_{};
-  int32_t field_int32_{};
-  uint64_t field_uint64_{};
-  int64_t field_int64_{};
-  uint64_t field_fixed64_{};
-  int64_t field_sfixed64_{};
-  uint32_t field_fixed32_{};
-  int32_t field_sfixed32_{};
-  double field_double_{};
-  float field_float_{};
-  int64_t field_sint64_{};
-  int32_t field_sint32_{};
-  std::string field_string_{};
-  std::string field_bytes_{};
+  uint64_t iid_{};
+  std::string name_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<15> _has_field_{};
+  std::bitset<3> _has_field_{};
 };
 
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TEST_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/config/trace_config.gen.h
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_HISTOGRAM_SAMPLE_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_keyed_service.gen.h
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TRACE_CONFIG_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TRACE_CONFIG_PROTO_CPP_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_KEYED_SERVICE_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_KEYED_SERVICE_PROTO_CPP_H_
 
 #include <stdint.h>
 #include <bitset>
@@ -170733,34 +190583,7 @@ class PERFETTO_EXPORT_COMPONENT TestConfig_DummyFields : public ::protozero::Cpp
 namespace perfetto {
 namespace protos {
 namespace gen {
-class TraceConfig;
-class TraceConfig_CmdTraceStartDelay;
-class TraceConfig_AndroidReportConfig;
-class TraceConfig_TraceFilter;
-class TraceConfig_IncidentReportConfig;
-class TraceConfig_IncrementalStateConfig;
-class TraceConfig_TriggerConfig;
-class TraceConfig_TriggerConfig_Trigger;
-class TraceConfig_GuardrailOverrides;
-class TraceConfig_StatsdMetadata;
-class TraceConfig_ProducerConfig;
-class TraceConfig_BuiltinDataSource;
-class TraceConfig_DataSource;
-class DataSourceConfig;
-class TestConfig;
-class TestConfig_DummyFields;
-class InterceptorConfig;
-class ChromeConfig;
-class SystemInfoConfig;
-class TraceConfig_BufferConfig;
-enum TraceConfig_LockdownModeOperation : int;
-enum TraceConfig_CompressionType : int;
-enum TraceConfig_StatsdLogging : int;
-enum TraceConfig_TriggerConfig_TriggerMode : int;
-enum BuiltinClock : int;
-enum DataSourceConfig_SessionInitiator : int;
-enum ChromeConfig_ClientPriority : int;
-enum TraceConfig_BufferConfig_FillPolicy : int;
+class ChromeKeyedService;
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
@@ -170772,767 +190595,800 @@ class Message;
 namespace perfetto {
 namespace protos {
 namespace gen {
-enum TraceConfig_LockdownModeOperation : int {
-  TraceConfig_LockdownModeOperation_LOCKDOWN_UNCHANGED = 0,
-  TraceConfig_LockdownModeOperation_LOCKDOWN_CLEAR = 1,
-  TraceConfig_LockdownModeOperation_LOCKDOWN_SET = 2,
-};
-enum TraceConfig_CompressionType : int {
-  TraceConfig_CompressionType_COMPRESSION_TYPE_UNSPECIFIED = 0,
-  TraceConfig_CompressionType_COMPRESSION_TYPE_DEFLATE = 1,
-};
-enum TraceConfig_StatsdLogging : int {
-  TraceConfig_StatsdLogging_STATSD_LOGGING_UNSPECIFIED = 0,
-  TraceConfig_StatsdLogging_STATSD_LOGGING_ENABLED = 1,
-  TraceConfig_StatsdLogging_STATSD_LOGGING_DISABLED = 2,
-};
-enum TraceConfig_TriggerConfig_TriggerMode : int {
-  TraceConfig_TriggerConfig_TriggerMode_UNSPECIFIED = 0,
-  TraceConfig_TriggerConfig_TriggerMode_START_TRACING = 1,
-  TraceConfig_TriggerConfig_TriggerMode_STOP_TRACING = 2,
-};
-enum TraceConfig_BufferConfig_FillPolicy : int {
-  TraceConfig_BufferConfig_FillPolicy_UNSPECIFIED = 0,
-  TraceConfig_BufferConfig_FillPolicy_RING_BUFFER = 1,
-  TraceConfig_BufferConfig_FillPolicy_DISCARD = 2,
-};
 
-class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT ChromeKeyedService : public ::protozero::CppMessageObj {
  public:
-  using BufferConfig = TraceConfig_BufferConfig;
-  using DataSource = TraceConfig_DataSource;
-  using BuiltinDataSource = TraceConfig_BuiltinDataSource;
-  using ProducerConfig = TraceConfig_ProducerConfig;
-  using StatsdMetadata = TraceConfig_StatsdMetadata;
-  using GuardrailOverrides = TraceConfig_GuardrailOverrides;
-  using TriggerConfig = TraceConfig_TriggerConfig;
-  using IncrementalStateConfig = TraceConfig_IncrementalStateConfig;
-  using IncidentReportConfig = TraceConfig_IncidentReportConfig;
-  using TraceFilter = TraceConfig_TraceFilter;
-  using AndroidReportConfig = TraceConfig_AndroidReportConfig;
-  using CmdTraceStartDelay = TraceConfig_CmdTraceStartDelay;
-  using LockdownModeOperation = TraceConfig_LockdownModeOperation;
-  static constexpr auto LOCKDOWN_UNCHANGED = TraceConfig_LockdownModeOperation_LOCKDOWN_UNCHANGED;
-  static constexpr auto LOCKDOWN_CLEAR = TraceConfig_LockdownModeOperation_LOCKDOWN_CLEAR;
-  static constexpr auto LOCKDOWN_SET = TraceConfig_LockdownModeOperation_LOCKDOWN_SET;
-  static constexpr auto LockdownModeOperation_MIN = TraceConfig_LockdownModeOperation_LOCKDOWN_UNCHANGED;
-  static constexpr auto LockdownModeOperation_MAX = TraceConfig_LockdownModeOperation_LOCKDOWN_SET;
-  using CompressionType = TraceConfig_CompressionType;
-  static constexpr auto COMPRESSION_TYPE_UNSPECIFIED = TraceConfig_CompressionType_COMPRESSION_TYPE_UNSPECIFIED;
-  static constexpr auto COMPRESSION_TYPE_DEFLATE = TraceConfig_CompressionType_COMPRESSION_TYPE_DEFLATE;
-  static constexpr auto CompressionType_MIN = TraceConfig_CompressionType_COMPRESSION_TYPE_UNSPECIFIED;
-  static constexpr auto CompressionType_MAX = TraceConfig_CompressionType_COMPRESSION_TYPE_DEFLATE;
-  using StatsdLogging = TraceConfig_StatsdLogging;
-  static constexpr auto STATSD_LOGGING_UNSPECIFIED = TraceConfig_StatsdLogging_STATSD_LOGGING_UNSPECIFIED;
-  static constexpr auto STATSD_LOGGING_ENABLED = TraceConfig_StatsdLogging_STATSD_LOGGING_ENABLED;
-  static constexpr auto STATSD_LOGGING_DISABLED = TraceConfig_StatsdLogging_STATSD_LOGGING_DISABLED;
-  static constexpr auto StatsdLogging_MIN = TraceConfig_StatsdLogging_STATSD_LOGGING_UNSPECIFIED;
-  static constexpr auto StatsdLogging_MAX = TraceConfig_StatsdLogging_STATSD_LOGGING_DISABLED;
   enum FieldNumbers {
-    kBuffersFieldNumber = 1,
-    kDataSourcesFieldNumber = 2,
-    kBuiltinDataSourcesFieldNumber = 20,
-    kDurationMsFieldNumber = 3,
-    kPreferSuspendClockForDurationFieldNumber = 36,
-    kEnableExtraGuardrailsFieldNumber = 4,
-    kLockdownModeFieldNumber = 5,
-    kProducersFieldNumber = 6,
-    kStatsdMetadataFieldNumber = 7,
-    kWriteIntoFileFieldNumber = 8,
-    kOutputPathFieldNumber = 29,
-    kFileWritePeriodMsFieldNumber = 9,
-    kMaxFileSizeBytesFieldNumber = 10,
-    kGuardrailOverridesFieldNumber = 11,
-    kDeferredStartFieldNumber = 12,
-    kFlushPeriodMsFieldNumber = 13,
-    kFlushTimeoutMsFieldNumber = 14,
-    kDataSourceStopTimeoutMsFieldNumber = 23,
-    kNotifyTraceurFieldNumber = 16,
-    kBugreportScoreFieldNumber = 30,
-    kTriggerConfigFieldNumber = 17,
-    kActivateTriggersFieldNumber = 18,
-    kIncrementalStateConfigFieldNumber = 21,
-    kAllowUserBuildTracingFieldNumber = 19,
-    kUniqueSessionNameFieldNumber = 22,
-    kCompressionTypeFieldNumber = 24,
-    kIncidentReportConfigFieldNumber = 25,
-    kStatsdLoggingFieldNumber = 31,
-    kTraceUuidMsbFieldNumber = 27,
-    kTraceUuidLsbFieldNumber = 28,
-    kTraceFilterFieldNumber = 33,
-    kAndroidReportConfigFieldNumber = 34,
-    kCmdTraceStartDelayFieldNumber = 35,
+    kNameFieldNumber = 1,
   };
 
-  TraceConfig();
-  ~TraceConfig() override;
-  TraceConfig(TraceConfig&&) noexcept;
-  TraceConfig& operator=(TraceConfig&&);
-  TraceConfig(const TraceConfig&);
-  TraceConfig& operator=(const TraceConfig&);
-  bool operator==(const TraceConfig&) const;
-  bool operator!=(const TraceConfig& other) const { return !(*this == other); }
+  ChromeKeyedService();
+  ~ChromeKeyedService() override;
+  ChromeKeyedService(ChromeKeyedService&&) noexcept;
+  ChromeKeyedService& operator=(ChromeKeyedService&&);
+  ChromeKeyedService(const ChromeKeyedService&);
+  ChromeKeyedService& operator=(const ChromeKeyedService&);
+  bool operator==(const ChromeKeyedService&) const;
+  bool operator!=(const ChromeKeyedService& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  const std::vector<TraceConfig_BufferConfig>& buffers() const { return buffers_; }
-  std::vector<TraceConfig_BufferConfig>* mutable_buffers() { return &buffers_; }
-  int buffers_size() const;
-  void clear_buffers();
-  TraceConfig_BufferConfig* add_buffers();
-
-  const std::vector<TraceConfig_DataSource>& data_sources() const { return data_sources_; }
-  std::vector<TraceConfig_DataSource>* mutable_data_sources() { return &data_sources_; }
-  int data_sources_size() const;
-  void clear_data_sources();
-  TraceConfig_DataSource* add_data_sources();
-
-  bool has_builtin_data_sources() const { return _has_field_[20]; }
-  const TraceConfig_BuiltinDataSource& builtin_data_sources() const { return *builtin_data_sources_; }
-  TraceConfig_BuiltinDataSource* mutable_builtin_data_sources() { _has_field_.set(20); return builtin_data_sources_.get(); }
-
-  bool has_duration_ms() const { return _has_field_[3]; }
-  uint32_t duration_ms() const { return duration_ms_; }
-  void set_duration_ms(uint32_t value) { duration_ms_ = value; _has_field_.set(3); }
-
-  bool has_prefer_suspend_clock_for_duration() const { return _has_field_[36]; }
-  bool prefer_suspend_clock_for_duration() const { return prefer_suspend_clock_for_duration_; }
-  void set_prefer_suspend_clock_for_duration(bool value) { prefer_suspend_clock_for_duration_ = value; _has_field_.set(36); }
-
-  bool has_enable_extra_guardrails() const { return _has_field_[4]; }
-  bool enable_extra_guardrails() const { return enable_extra_guardrails_; }
-  void set_enable_extra_guardrails(bool value) { enable_extra_guardrails_ = value; _has_field_.set(4); }
-
-  bool has_lockdown_mode() const { return _has_field_[5]; }
-  TraceConfig_LockdownModeOperation lockdown_mode() const { return lockdown_mode_; }
-  void set_lockdown_mode(TraceConfig_LockdownModeOperation value) { lockdown_mode_ = value; _has_field_.set(5); }
-
-  const std::vector<TraceConfig_ProducerConfig>& producers() const { return producers_; }
-  std::vector<TraceConfig_ProducerConfig>* mutable_producers() { return &producers_; }
-  int producers_size() const;
-  void clear_producers();
-  TraceConfig_ProducerConfig* add_producers();
-
-  bool has_statsd_metadata() const { return _has_field_[7]; }
-  const TraceConfig_StatsdMetadata& statsd_metadata() const { return *statsd_metadata_; }
-  TraceConfig_StatsdMetadata* mutable_statsd_metadata() { _has_field_.set(7); return statsd_metadata_.get(); }
-
-  bool has_write_into_file() const { return _has_field_[8]; }
-  bool write_into_file() const { return write_into_file_; }
-  void set_write_into_file(bool value) { write_into_file_ = value; _has_field_.set(8); }
-
-  bool has_output_path() const { return _has_field_[29]; }
-  const std::string& output_path() const { return output_path_; }
-  void set_output_path(const std::string& value) { output_path_ = value; _has_field_.set(29); }
-
-  bool has_file_write_period_ms() const { return _has_field_[9]; }
-  uint32_t file_write_period_ms() const { return file_write_period_ms_; }
-  void set_file_write_period_ms(uint32_t value) { file_write_period_ms_ = value; _has_field_.set(9); }
-
-  bool has_max_file_size_bytes() const { return _has_field_[10]; }
-  uint64_t max_file_size_bytes() const { return max_file_size_bytes_; }
-  void set_max_file_size_bytes(uint64_t value) { max_file_size_bytes_ = value; _has_field_.set(10); }
-
-  bool has_guardrail_overrides() const { return _has_field_[11]; }
-  const TraceConfig_GuardrailOverrides& guardrail_overrides() const { return *guardrail_overrides_; }
-  TraceConfig_GuardrailOverrides* mutable_guardrail_overrides() { _has_field_.set(11); return guardrail_overrides_.get(); }
-
-  bool has_deferred_start() const { return _has_field_[12]; }
-  bool deferred_start() const { return deferred_start_; }
-  void set_deferred_start(bool value) { deferred_start_ = value; _has_field_.set(12); }
-
-  bool has_flush_period_ms() const { return _has_field_[13]; }
-  uint32_t flush_period_ms() const { return flush_period_ms_; }
-  void set_flush_period_ms(uint32_t value) { flush_period_ms_ = value; _has_field_.set(13); }
-
-  bool has_flush_timeout_ms() const { return _has_field_[14]; }
-  uint32_t flush_timeout_ms() const { return flush_timeout_ms_; }
-  void set_flush_timeout_ms(uint32_t value) { flush_timeout_ms_ = value; _has_field_.set(14); }
-
-  bool has_data_source_stop_timeout_ms() const { return _has_field_[23]; }
-  uint32_t data_source_stop_timeout_ms() const { return data_source_stop_timeout_ms_; }
-  void set_data_source_stop_timeout_ms(uint32_t value) { data_source_stop_timeout_ms_ = value; _has_field_.set(23); }
-
-  bool has_notify_traceur() const { return _has_field_[16]; }
-  bool notify_traceur() const { return notify_traceur_; }
-  void set_notify_traceur(bool value) { notify_traceur_ = value; _has_field_.set(16); }
-
-  bool has_bugreport_score() const { return _has_field_[30]; }
-  int32_t bugreport_score() const { return bugreport_score_; }
-  void set_bugreport_score(int32_t value) { bugreport_score_ = value; _has_field_.set(30); }
-
-  bool has_trigger_config() const { return _has_field_[17]; }
-  const TraceConfig_TriggerConfig& trigger_config() const { return *trigger_config_; }
-  TraceConfig_TriggerConfig* mutable_trigger_config() { _has_field_.set(17); return trigger_config_.get(); }
-
-  const std::vector<std::string>& activate_triggers() const { return activate_triggers_; }
-  std::vector<std::string>* mutable_activate_triggers() { return &activate_triggers_; }
-  int activate_triggers_size() const { return static_cast<int>(activate_triggers_.size()); }
-  void clear_activate_triggers() { activate_triggers_.clear(); }
-  void add_activate_triggers(std::string value) { activate_triggers_.emplace_back(value); }
-  std::string* add_activate_triggers() { activate_triggers_.emplace_back(); return &activate_triggers_.back(); }
-
-  bool has_incremental_state_config() const { return _has_field_[21]; }
-  const TraceConfig_IncrementalStateConfig& incremental_state_config() const { return *incremental_state_config_; }
-  TraceConfig_IncrementalStateConfig* mutable_incremental_state_config() { _has_field_.set(21); return incremental_state_config_.get(); }
-
-  bool has_allow_user_build_tracing() const { return _has_field_[19]; }
-  bool allow_user_build_tracing() const { return allow_user_build_tracing_; }
-  void set_allow_user_build_tracing(bool value) { allow_user_build_tracing_ = value; _has_field_.set(19); }
-
-  bool has_unique_session_name() const { return _has_field_[22]; }
-  const std::string& unique_session_name() const { return unique_session_name_; }
-  void set_unique_session_name(const std::string& value) { unique_session_name_ = value; _has_field_.set(22); }
-
-  bool has_compression_type() const { return _has_field_[24]; }
-  TraceConfig_CompressionType compression_type() const { return compression_type_; }
-  void set_compression_type(TraceConfig_CompressionType value) { compression_type_ = value; _has_field_.set(24); }
+  bool has_name() const { return _has_field_[1]; }
+  const std::string& name() const { return name_; }
+  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
 
-  bool has_incident_report_config() const { return _has_field_[25]; }
-  const TraceConfig_IncidentReportConfig& incident_report_config() const { return *incident_report_config_; }
-  TraceConfig_IncidentReportConfig* mutable_incident_report_config() { _has_field_.set(25); return incident_report_config_.get(); }
+ private:
+  std::string name_{};
 
-  bool has_statsd_logging() const { return _has_field_[31]; }
-  TraceConfig_StatsdLogging statsd_logging() const { return statsd_logging_; }
-  void set_statsd_logging(TraceConfig_StatsdLogging value) { statsd_logging_ = value; _has_field_.set(31); }
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  bool has_trace_uuid_msb() const { return _has_field_[27]; }
-  int64_t trace_uuid_msb() const { return trace_uuid_msb_; }
-  void set_trace_uuid_msb(int64_t value) { trace_uuid_msb_ = value; _has_field_.set(27); }
+  std::bitset<2> _has_field_{};
+};
 
-  bool has_trace_uuid_lsb() const { return _has_field_[28]; }
-  int64_t trace_uuid_lsb() const { return trace_uuid_lsb_; }
-  void set_trace_uuid_lsb(int64_t value) { trace_uuid_lsb_ = value; _has_field_.set(28); }
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  bool has_trace_filter() const { return _has_field_[33]; }
-  const TraceConfig_TraceFilter& trace_filter() const { return *trace_filter_; }
-  TraceConfig_TraceFilter* mutable_trace_filter() { _has_field_.set(33); return trace_filter_.get(); }
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_KEYED_SERVICE_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_latency_info.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LATENCY_INFO_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LATENCY_INFO_PROTO_CPP_H_
 
-  bool has_android_report_config() const { return _has_field_[34]; }
-  const TraceConfig_AndroidReportConfig& android_report_config() const { return *android_report_config_; }
-  TraceConfig_AndroidReportConfig* mutable_android_report_config() { _has_field_.set(34); return android_report_config_.get(); }
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  bool has_cmd_trace_start_delay() const { return _has_field_[35]; }
-  const TraceConfig_CmdTraceStartDelay& cmd_trace_start_delay() const { return *cmd_trace_start_delay_; }
-  TraceConfig_CmdTraceStartDelay* mutable_cmd_trace_start_delay() { _has_field_.set(35); return cmd_trace_start_delay_.get(); }
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
- private:
-  std::vector<TraceConfig_BufferConfig> buffers_;
-  std::vector<TraceConfig_DataSource> data_sources_;
-  ::protozero::CopyablePtr<TraceConfig_BuiltinDataSource> builtin_data_sources_;
-  uint32_t duration_ms_{};
-  bool prefer_suspend_clock_for_duration_{};
-  bool enable_extra_guardrails_{};
-  TraceConfig_LockdownModeOperation lockdown_mode_{};
-  std::vector<TraceConfig_ProducerConfig> producers_;
-  ::protozero::CopyablePtr<TraceConfig_StatsdMetadata> statsd_metadata_;
-  bool write_into_file_{};
-  std::string output_path_{};
-  uint32_t file_write_period_ms_{};
-  uint64_t max_file_size_bytes_{};
-  ::protozero::CopyablePtr<TraceConfig_GuardrailOverrides> guardrail_overrides_;
-  bool deferred_start_{};
-  uint32_t flush_period_ms_{};
-  uint32_t flush_timeout_ms_{};
-  uint32_t data_source_stop_timeout_ms_{};
-  bool notify_traceur_{};
-  int32_t bugreport_score_{};
-  ::protozero::CopyablePtr<TraceConfig_TriggerConfig> trigger_config_;
-  std::vector<std::string> activate_triggers_;
-  ::protozero::CopyablePtr<TraceConfig_IncrementalStateConfig> incremental_state_config_;
-  bool allow_user_build_tracing_{};
-  std::string unique_session_name_{};
-  TraceConfig_CompressionType compression_type_{};
-  ::protozero::CopyablePtr<TraceConfig_IncidentReportConfig> incident_report_config_;
-  TraceConfig_StatsdLogging statsd_logging_{};
-  int64_t trace_uuid_msb_{};
-  int64_t trace_uuid_lsb_{};
-  ::protozero::CopyablePtr<TraceConfig_TraceFilter> trace_filter_;
-  ::protozero::CopyablePtr<TraceConfig_AndroidReportConfig> android_report_config_;
-  ::protozero::CopyablePtr<TraceConfig_CmdTraceStartDelay> cmd_trace_start_delay_;
+namespace perfetto {
+namespace protos {
+namespace gen {
+class ChromeLatencyInfo;
+class ChromeLatencyInfo_ComponentInfo;
+enum ChromeLatencyInfo_Step : int;
+enum ChromeLatencyInfo_LatencyComponentType : int;
+enum ChromeLatencyInfo_InputType : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  std::bitset<37> _has_field_{};
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum ChromeLatencyInfo_Step : int {
+  ChromeLatencyInfo_Step_STEP_UNSPECIFIED = 0,
+  ChromeLatencyInfo_Step_STEP_SEND_INPUT_EVENT_UI = 3,
+  ChromeLatencyInfo_Step_STEP_HANDLE_INPUT_EVENT_IMPL = 5,
+  ChromeLatencyInfo_Step_STEP_DID_HANDLE_INPUT_AND_OVERSCROLL = 8,
+  ChromeLatencyInfo_Step_STEP_HANDLE_INPUT_EVENT_MAIN = 4,
+  ChromeLatencyInfo_Step_STEP_MAIN_THREAD_SCROLL_UPDATE = 2,
+  ChromeLatencyInfo_Step_STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT = 1,
+  ChromeLatencyInfo_Step_STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL = 9,
+  ChromeLatencyInfo_Step_STEP_HANDLED_INPUT_EVENT_IMPL = 10,
+  ChromeLatencyInfo_Step_STEP_SWAP_BUFFERS = 6,
+  ChromeLatencyInfo_Step_STEP_DRAW_AND_SWAP = 7,
+  ChromeLatencyInfo_Step_STEP_FINISHED_SWAP_BUFFERS = 11,
+};
+enum ChromeLatencyInfo_LatencyComponentType : int {
+  ChromeLatencyInfo_LatencyComponentType_COMPONENT_UNSPECIFIED = 0,
+  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH = 1,
+  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL = 2,
+  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL = 3,
+  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL = 4,
+  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_UI = 5,
+  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN = 6,
+  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN = 7,
+  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL = 8,
+  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT = 9,
+  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH = 10,
+  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP = 11,
+  ChromeLatencyInfo_LatencyComponentType_COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME = 12,
+  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER = 13,
+  ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP = 14,
+};
+enum ChromeLatencyInfo_InputType : int {
+  ChromeLatencyInfo_InputType_UNSPECIFIED_OR_OTHER = 0,
+  ChromeLatencyInfo_InputType_TOUCH_MOVED = 1,
+  ChromeLatencyInfo_InputType_GESTURE_SCROLL_BEGIN = 2,
+  ChromeLatencyInfo_InputType_GESTURE_SCROLL_UPDATE = 3,
+  ChromeLatencyInfo_InputType_GESTURE_SCROLL_END = 4,
+  ChromeLatencyInfo_InputType_GESTURE_TAP = 5,
+  ChromeLatencyInfo_InputType_GESTURE_TAP_CANCEL = 6,
 };
 
-
-class PERFETTO_EXPORT_COMPONENT TraceConfig_CmdTraceStartDelay : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT ChromeLatencyInfo : public ::protozero::CppMessageObj {
  public:
+  using ComponentInfo = ChromeLatencyInfo_ComponentInfo;
+  using Step = ChromeLatencyInfo_Step;
+  static constexpr auto STEP_UNSPECIFIED = ChromeLatencyInfo_Step_STEP_UNSPECIFIED;
+  static constexpr auto STEP_SEND_INPUT_EVENT_UI = ChromeLatencyInfo_Step_STEP_SEND_INPUT_EVENT_UI;
+  static constexpr auto STEP_HANDLE_INPUT_EVENT_IMPL = ChromeLatencyInfo_Step_STEP_HANDLE_INPUT_EVENT_IMPL;
+  static constexpr auto STEP_DID_HANDLE_INPUT_AND_OVERSCROLL = ChromeLatencyInfo_Step_STEP_DID_HANDLE_INPUT_AND_OVERSCROLL;
+  static constexpr auto STEP_HANDLE_INPUT_EVENT_MAIN = ChromeLatencyInfo_Step_STEP_HANDLE_INPUT_EVENT_MAIN;
+  static constexpr auto STEP_MAIN_THREAD_SCROLL_UPDATE = ChromeLatencyInfo_Step_STEP_MAIN_THREAD_SCROLL_UPDATE;
+  static constexpr auto STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT = ChromeLatencyInfo_Step_STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT;
+  static constexpr auto STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL = ChromeLatencyInfo_Step_STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL;
+  static constexpr auto STEP_HANDLED_INPUT_EVENT_IMPL = ChromeLatencyInfo_Step_STEP_HANDLED_INPUT_EVENT_IMPL;
+  static constexpr auto STEP_SWAP_BUFFERS = ChromeLatencyInfo_Step_STEP_SWAP_BUFFERS;
+  static constexpr auto STEP_DRAW_AND_SWAP = ChromeLatencyInfo_Step_STEP_DRAW_AND_SWAP;
+  static constexpr auto STEP_FINISHED_SWAP_BUFFERS = ChromeLatencyInfo_Step_STEP_FINISHED_SWAP_BUFFERS;
+  static constexpr auto Step_MIN = ChromeLatencyInfo_Step_STEP_UNSPECIFIED;
+  static constexpr auto Step_MAX = ChromeLatencyInfo_Step_STEP_FINISHED_SWAP_BUFFERS;
+  using LatencyComponentType = ChromeLatencyInfo_LatencyComponentType;
+  static constexpr auto COMPONENT_UNSPECIFIED = ChromeLatencyInfo_LatencyComponentType_COMPONENT_UNSPECIFIED;
+  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH;
+  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL;
+  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL;
+  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL;
+  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_UI = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_UI;
+  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN;
+  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN;
+  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL;
+  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT;
+  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH;
+  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP;
+  static constexpr auto COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME = ChromeLatencyInfo_LatencyComponentType_COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME;
+  static constexpr auto COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER;
+  static constexpr auto COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP;
+  static constexpr auto LatencyComponentType_MIN = ChromeLatencyInfo_LatencyComponentType_COMPONENT_UNSPECIFIED;
+  static constexpr auto LatencyComponentType_MAX = ChromeLatencyInfo_LatencyComponentType_COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP;
+  using InputType = ChromeLatencyInfo_InputType;
+  static constexpr auto UNSPECIFIED_OR_OTHER = ChromeLatencyInfo_InputType_UNSPECIFIED_OR_OTHER;
+  static constexpr auto TOUCH_MOVED = ChromeLatencyInfo_InputType_TOUCH_MOVED;
+  static constexpr auto GESTURE_SCROLL_BEGIN = ChromeLatencyInfo_InputType_GESTURE_SCROLL_BEGIN;
+  static constexpr auto GESTURE_SCROLL_UPDATE = ChromeLatencyInfo_InputType_GESTURE_SCROLL_UPDATE;
+  static constexpr auto GESTURE_SCROLL_END = ChromeLatencyInfo_InputType_GESTURE_SCROLL_END;
+  static constexpr auto GESTURE_TAP = ChromeLatencyInfo_InputType_GESTURE_TAP;
+  static constexpr auto GESTURE_TAP_CANCEL = ChromeLatencyInfo_InputType_GESTURE_TAP_CANCEL;
+  static constexpr auto InputType_MIN = ChromeLatencyInfo_InputType_UNSPECIFIED_OR_OTHER;
+  static constexpr auto InputType_MAX = ChromeLatencyInfo_InputType_GESTURE_TAP_CANCEL;
   enum FieldNumbers {
-    kMinDelayMsFieldNumber = 1,
-    kMaxDelayMsFieldNumber = 2,
+    kTraceIdFieldNumber = 1,
+    kStepFieldNumber = 2,
+    kFrameTreeNodeIdFieldNumber = 3,
+    kComponentInfoFieldNumber = 4,
+    kIsCoalescedFieldNumber = 5,
+    kGestureScrollIdFieldNumber = 6,
+    kTouchIdFieldNumber = 7,
+    kInputTypeFieldNumber = 8,
   };
 
-  TraceConfig_CmdTraceStartDelay();
-  ~TraceConfig_CmdTraceStartDelay() override;
-  TraceConfig_CmdTraceStartDelay(TraceConfig_CmdTraceStartDelay&&) noexcept;
-  TraceConfig_CmdTraceStartDelay& operator=(TraceConfig_CmdTraceStartDelay&&);
-  TraceConfig_CmdTraceStartDelay(const TraceConfig_CmdTraceStartDelay&);
-  TraceConfig_CmdTraceStartDelay& operator=(const TraceConfig_CmdTraceStartDelay&);
-  bool operator==(const TraceConfig_CmdTraceStartDelay&) const;
-  bool operator!=(const TraceConfig_CmdTraceStartDelay& other) const { return !(*this == other); }
+  ChromeLatencyInfo();
+  ~ChromeLatencyInfo() override;
+  ChromeLatencyInfo(ChromeLatencyInfo&&) noexcept;
+  ChromeLatencyInfo& operator=(ChromeLatencyInfo&&);
+  ChromeLatencyInfo(const ChromeLatencyInfo&);
+  ChromeLatencyInfo& operator=(const ChromeLatencyInfo&);
+  bool operator==(const ChromeLatencyInfo&) const;
+  bool operator!=(const ChromeLatencyInfo& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_min_delay_ms() const { return _has_field_[1]; }
-  uint32_t min_delay_ms() const { return min_delay_ms_; }
-  void set_min_delay_ms(uint32_t value) { min_delay_ms_ = value; _has_field_.set(1); }
+  bool has_trace_id() const { return _has_field_[1]; }
+  int64_t trace_id() const { return trace_id_; }
+  void set_trace_id(int64_t value) { trace_id_ = value; _has_field_.set(1); }
 
-  bool has_max_delay_ms() const { return _has_field_[2]; }
-  uint32_t max_delay_ms() const { return max_delay_ms_; }
-  void set_max_delay_ms(uint32_t value) { max_delay_ms_ = value; _has_field_.set(2); }
+  bool has_step() const { return _has_field_[2]; }
+  ChromeLatencyInfo_Step step() const { return step_; }
+  void set_step(ChromeLatencyInfo_Step value) { step_ = value; _has_field_.set(2); }
+
+  bool has_frame_tree_node_id() const { return _has_field_[3]; }
+  int32_t frame_tree_node_id() const { return frame_tree_node_id_; }
+  void set_frame_tree_node_id(int32_t value) { frame_tree_node_id_ = value; _has_field_.set(3); }
+
+  const std::vector<ChromeLatencyInfo_ComponentInfo>& component_info() const { return component_info_; }
+  std::vector<ChromeLatencyInfo_ComponentInfo>* mutable_component_info() { return &component_info_; }
+  int component_info_size() const;
+  void clear_component_info();
+  ChromeLatencyInfo_ComponentInfo* add_component_info();
+
+  bool has_is_coalesced() const { return _has_field_[5]; }
+  bool is_coalesced() const { return is_coalesced_; }
+  void set_is_coalesced(bool value) { is_coalesced_ = value; _has_field_.set(5); }
+
+  bool has_gesture_scroll_id() const { return _has_field_[6]; }
+  int64_t gesture_scroll_id() const { return gesture_scroll_id_; }
+  void set_gesture_scroll_id(int64_t value) { gesture_scroll_id_ = value; _has_field_.set(6); }
+
+  bool has_touch_id() const { return _has_field_[7]; }
+  int64_t touch_id() const { return touch_id_; }
+  void set_touch_id(int64_t value) { touch_id_ = value; _has_field_.set(7); }
+
+  bool has_input_type() const { return _has_field_[8]; }
+  ChromeLatencyInfo_InputType input_type() const { return input_type_; }
+  void set_input_type(ChromeLatencyInfo_InputType value) { input_type_ = value; _has_field_.set(8); }
 
  private:
-  uint32_t min_delay_ms_{};
-  uint32_t max_delay_ms_{};
+  int64_t trace_id_{};
+  ChromeLatencyInfo_Step step_{};
+  int32_t frame_tree_node_id_{};
+  std::vector<ChromeLatencyInfo_ComponentInfo> component_info_;
+  bool is_coalesced_{};
+  int64_t gesture_scroll_id_{};
+  int64_t touch_id_{};
+  ChromeLatencyInfo_InputType input_type_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<3> _has_field_{};
+  std::bitset<9> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT TraceConfig_AndroidReportConfig : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT ChromeLatencyInfo_ComponentInfo : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kReporterServicePackageFieldNumber = 1,
-    kReporterServiceClassFieldNumber = 2,
-    kSkipReportFieldNumber = 3,
-    kUsePipeInFrameworkForTestingFieldNumber = 4,
+    kComponentTypeFieldNumber = 1,
+    kTimeUsFieldNumber = 2,
   };
 
-  TraceConfig_AndroidReportConfig();
-  ~TraceConfig_AndroidReportConfig() override;
-  TraceConfig_AndroidReportConfig(TraceConfig_AndroidReportConfig&&) noexcept;
-  TraceConfig_AndroidReportConfig& operator=(TraceConfig_AndroidReportConfig&&);
-  TraceConfig_AndroidReportConfig(const TraceConfig_AndroidReportConfig&);
-  TraceConfig_AndroidReportConfig& operator=(const TraceConfig_AndroidReportConfig&);
-  bool operator==(const TraceConfig_AndroidReportConfig&) const;
-  bool operator!=(const TraceConfig_AndroidReportConfig& other) const { return !(*this == other); }
+  ChromeLatencyInfo_ComponentInfo();
+  ~ChromeLatencyInfo_ComponentInfo() override;
+  ChromeLatencyInfo_ComponentInfo(ChromeLatencyInfo_ComponentInfo&&) noexcept;
+  ChromeLatencyInfo_ComponentInfo& operator=(ChromeLatencyInfo_ComponentInfo&&);
+  ChromeLatencyInfo_ComponentInfo(const ChromeLatencyInfo_ComponentInfo&);
+  ChromeLatencyInfo_ComponentInfo& operator=(const ChromeLatencyInfo_ComponentInfo&);
+  bool operator==(const ChromeLatencyInfo_ComponentInfo&) const;
+  bool operator!=(const ChromeLatencyInfo_ComponentInfo& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_reporter_service_package() const { return _has_field_[1]; }
-  const std::string& reporter_service_package() const { return reporter_service_package_; }
-  void set_reporter_service_package(const std::string& value) { reporter_service_package_ = value; _has_field_.set(1); }
-
-  bool has_reporter_service_class() const { return _has_field_[2]; }
-  const std::string& reporter_service_class() const { return reporter_service_class_; }
-  void set_reporter_service_class(const std::string& value) { reporter_service_class_ = value; _has_field_.set(2); }
-
-  bool has_skip_report() const { return _has_field_[3]; }
-  bool skip_report() const { return skip_report_; }
-  void set_skip_report(bool value) { skip_report_ = value; _has_field_.set(3); }
+  bool has_component_type() const { return _has_field_[1]; }
+  ChromeLatencyInfo_LatencyComponentType component_type() const { return component_type_; }
+  void set_component_type(ChromeLatencyInfo_LatencyComponentType value) { component_type_ = value; _has_field_.set(1); }
 
-  bool has_use_pipe_in_framework_for_testing() const { return _has_field_[4]; }
-  bool use_pipe_in_framework_for_testing() const { return use_pipe_in_framework_for_testing_; }
-  void set_use_pipe_in_framework_for_testing(bool value) { use_pipe_in_framework_for_testing_ = value; _has_field_.set(4); }
+  bool has_time_us() const { return _has_field_[2]; }
+  uint64_t time_us() const { return time_us_; }
+  void set_time_us(uint64_t value) { time_us_ = value; _has_field_.set(2); }
 
  private:
-  std::string reporter_service_package_{};
-  std::string reporter_service_class_{};
-  bool skip_report_{};
-  bool use_pipe_in_framework_for_testing_{};
+  ChromeLatencyInfo_LatencyComponentType component_type_{};
+  uint64_t time_us_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<5> _has_field_{};
+  std::bitset<3> _has_field_{};
 };
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-class PERFETTO_EXPORT_COMPONENT TraceConfig_TraceFilter : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kBytecodeFieldNumber = 1,
-  };
-
-  TraceConfig_TraceFilter();
-  ~TraceConfig_TraceFilter() override;
-  TraceConfig_TraceFilter(TraceConfig_TraceFilter&&) noexcept;
-  TraceConfig_TraceFilter& operator=(TraceConfig_TraceFilter&&);
-  TraceConfig_TraceFilter(const TraceConfig_TraceFilter&);
-  TraceConfig_TraceFilter& operator=(const TraceConfig_TraceFilter&);
-  bool operator==(const TraceConfig_TraceFilter&) const;
-  bool operator!=(const TraceConfig_TraceFilter& other) const { return !(*this == other); }
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LATENCY_INFO_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_legacy_ipc.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LEGACY_IPC_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LEGACY_IPC_PROTO_CPP_H_
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  bool has_bytecode() const { return _has_field_[1]; }
-  const std::string& bytecode() const { return bytecode_; }
-  void set_bytecode(const std::string& value) { bytecode_ = value; _has_field_.set(1); }
-  void set_bytecode(const void* p, size_t s) { bytecode_.assign(reinterpret_cast<const char*>(p), s); _has_field_.set(1); }
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
- private:
-  std::string bytecode_{};
+namespace perfetto {
+namespace protos {
+namespace gen {
+class ChromeLegacyIpc;
+enum ChromeLegacyIpc_MessageClass : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  std::bitset<2> _has_field_{};
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum ChromeLegacyIpc_MessageClass : int {
+  ChromeLegacyIpc_MessageClass_CLASS_UNSPECIFIED = 0,
+  ChromeLegacyIpc_MessageClass_CLASS_AUTOMATION = 1,
+  ChromeLegacyIpc_MessageClass_CLASS_FRAME = 2,
+  ChromeLegacyIpc_MessageClass_CLASS_PAGE = 3,
+  ChromeLegacyIpc_MessageClass_CLASS_VIEW = 4,
+  ChromeLegacyIpc_MessageClass_CLASS_WIDGET = 5,
+  ChromeLegacyIpc_MessageClass_CLASS_INPUT = 6,
+  ChromeLegacyIpc_MessageClass_CLASS_TEST = 7,
+  ChromeLegacyIpc_MessageClass_CLASS_WORKER = 8,
+  ChromeLegacyIpc_MessageClass_CLASS_NACL = 9,
+  ChromeLegacyIpc_MessageClass_CLASS_GPU_CHANNEL = 10,
+  ChromeLegacyIpc_MessageClass_CLASS_MEDIA = 11,
+  ChromeLegacyIpc_MessageClass_CLASS_PPAPI = 12,
+  ChromeLegacyIpc_MessageClass_CLASS_CHROME = 13,
+  ChromeLegacyIpc_MessageClass_CLASS_DRAG = 14,
+  ChromeLegacyIpc_MessageClass_CLASS_PRINT = 15,
+  ChromeLegacyIpc_MessageClass_CLASS_EXTENSION = 16,
+  ChromeLegacyIpc_MessageClass_CLASS_TEXT_INPUT_CLIENT = 17,
+  ChromeLegacyIpc_MessageClass_CLASS_BLINK_TEST = 18,
+  ChromeLegacyIpc_MessageClass_CLASS_ACCESSIBILITY = 19,
+  ChromeLegacyIpc_MessageClass_CLASS_PRERENDER = 20,
+  ChromeLegacyIpc_MessageClass_CLASS_CHROMOTING = 21,
+  ChromeLegacyIpc_MessageClass_CLASS_BROWSER_PLUGIN = 22,
+  ChromeLegacyIpc_MessageClass_CLASS_ANDROID_WEB_VIEW = 23,
+  ChromeLegacyIpc_MessageClass_CLASS_NACL_HOST = 24,
+  ChromeLegacyIpc_MessageClass_CLASS_ENCRYPTED_MEDIA = 25,
+  ChromeLegacyIpc_MessageClass_CLASS_CAST = 26,
+  ChromeLegacyIpc_MessageClass_CLASS_GIN_JAVA_BRIDGE = 27,
+  ChromeLegacyIpc_MessageClass_CLASS_CHROME_UTILITY_PRINTING = 28,
+  ChromeLegacyIpc_MessageClass_CLASS_OZONE_GPU = 29,
+  ChromeLegacyIpc_MessageClass_CLASS_WEB_TEST = 30,
+  ChromeLegacyIpc_MessageClass_CLASS_NETWORK_HINTS = 31,
+  ChromeLegacyIpc_MessageClass_CLASS_EXTENSIONS_GUEST_VIEW = 32,
+  ChromeLegacyIpc_MessageClass_CLASS_GUEST_VIEW = 33,
+  ChromeLegacyIpc_MessageClass_CLASS_MEDIA_PLAYER_DELEGATE = 34,
+  ChromeLegacyIpc_MessageClass_CLASS_EXTENSION_WORKER = 35,
+  ChromeLegacyIpc_MessageClass_CLASS_SUBRESOURCE_FILTER = 36,
+  ChromeLegacyIpc_MessageClass_CLASS_UNFREEZABLE_FRAME = 37,
 };
 
-
-class PERFETTO_EXPORT_COMPONENT TraceConfig_IncidentReportConfig : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT ChromeLegacyIpc : public ::protozero::CppMessageObj {
  public:
+  using MessageClass = ChromeLegacyIpc_MessageClass;
+  static constexpr auto CLASS_UNSPECIFIED = ChromeLegacyIpc_MessageClass_CLASS_UNSPECIFIED;
+  static constexpr auto CLASS_AUTOMATION = ChromeLegacyIpc_MessageClass_CLASS_AUTOMATION;
+  static constexpr auto CLASS_FRAME = ChromeLegacyIpc_MessageClass_CLASS_FRAME;
+  static constexpr auto CLASS_PAGE = ChromeLegacyIpc_MessageClass_CLASS_PAGE;
+  static constexpr auto CLASS_VIEW = ChromeLegacyIpc_MessageClass_CLASS_VIEW;
+  static constexpr auto CLASS_WIDGET = ChromeLegacyIpc_MessageClass_CLASS_WIDGET;
+  static constexpr auto CLASS_INPUT = ChromeLegacyIpc_MessageClass_CLASS_INPUT;
+  static constexpr auto CLASS_TEST = ChromeLegacyIpc_MessageClass_CLASS_TEST;
+  static constexpr auto CLASS_WORKER = ChromeLegacyIpc_MessageClass_CLASS_WORKER;
+  static constexpr auto CLASS_NACL = ChromeLegacyIpc_MessageClass_CLASS_NACL;
+  static constexpr auto CLASS_GPU_CHANNEL = ChromeLegacyIpc_MessageClass_CLASS_GPU_CHANNEL;
+  static constexpr auto CLASS_MEDIA = ChromeLegacyIpc_MessageClass_CLASS_MEDIA;
+  static constexpr auto CLASS_PPAPI = ChromeLegacyIpc_MessageClass_CLASS_PPAPI;
+  static constexpr auto CLASS_CHROME = ChromeLegacyIpc_MessageClass_CLASS_CHROME;
+  static constexpr auto CLASS_DRAG = ChromeLegacyIpc_MessageClass_CLASS_DRAG;
+  static constexpr auto CLASS_PRINT = ChromeLegacyIpc_MessageClass_CLASS_PRINT;
+  static constexpr auto CLASS_EXTENSION = ChromeLegacyIpc_MessageClass_CLASS_EXTENSION;
+  static constexpr auto CLASS_TEXT_INPUT_CLIENT = ChromeLegacyIpc_MessageClass_CLASS_TEXT_INPUT_CLIENT;
+  static constexpr auto CLASS_BLINK_TEST = ChromeLegacyIpc_MessageClass_CLASS_BLINK_TEST;
+  static constexpr auto CLASS_ACCESSIBILITY = ChromeLegacyIpc_MessageClass_CLASS_ACCESSIBILITY;
+  static constexpr auto CLASS_PRERENDER = ChromeLegacyIpc_MessageClass_CLASS_PRERENDER;
+  static constexpr auto CLASS_CHROMOTING = ChromeLegacyIpc_MessageClass_CLASS_CHROMOTING;
+  static constexpr auto CLASS_BROWSER_PLUGIN = ChromeLegacyIpc_MessageClass_CLASS_BROWSER_PLUGIN;
+  static constexpr auto CLASS_ANDROID_WEB_VIEW = ChromeLegacyIpc_MessageClass_CLASS_ANDROID_WEB_VIEW;
+  static constexpr auto CLASS_NACL_HOST = ChromeLegacyIpc_MessageClass_CLASS_NACL_HOST;
+  static constexpr auto CLASS_ENCRYPTED_MEDIA = ChromeLegacyIpc_MessageClass_CLASS_ENCRYPTED_MEDIA;
+  static constexpr auto CLASS_CAST = ChromeLegacyIpc_MessageClass_CLASS_CAST;
+  static constexpr auto CLASS_GIN_JAVA_BRIDGE = ChromeLegacyIpc_MessageClass_CLASS_GIN_JAVA_BRIDGE;
+  static constexpr auto CLASS_CHROME_UTILITY_PRINTING = ChromeLegacyIpc_MessageClass_CLASS_CHROME_UTILITY_PRINTING;
+  static constexpr auto CLASS_OZONE_GPU = ChromeLegacyIpc_MessageClass_CLASS_OZONE_GPU;
+  static constexpr auto CLASS_WEB_TEST = ChromeLegacyIpc_MessageClass_CLASS_WEB_TEST;
+  static constexpr auto CLASS_NETWORK_HINTS = ChromeLegacyIpc_MessageClass_CLASS_NETWORK_HINTS;
+  static constexpr auto CLASS_EXTENSIONS_GUEST_VIEW = ChromeLegacyIpc_MessageClass_CLASS_EXTENSIONS_GUEST_VIEW;
+  static constexpr auto CLASS_GUEST_VIEW = ChromeLegacyIpc_MessageClass_CLASS_GUEST_VIEW;
+  static constexpr auto CLASS_MEDIA_PLAYER_DELEGATE = ChromeLegacyIpc_MessageClass_CLASS_MEDIA_PLAYER_DELEGATE;
+  static constexpr auto CLASS_EXTENSION_WORKER = ChromeLegacyIpc_MessageClass_CLASS_EXTENSION_WORKER;
+  static constexpr auto CLASS_SUBRESOURCE_FILTER = ChromeLegacyIpc_MessageClass_CLASS_SUBRESOURCE_FILTER;
+  static constexpr auto CLASS_UNFREEZABLE_FRAME = ChromeLegacyIpc_MessageClass_CLASS_UNFREEZABLE_FRAME;
+  static constexpr auto MessageClass_MIN = ChromeLegacyIpc_MessageClass_CLASS_UNSPECIFIED;
+  static constexpr auto MessageClass_MAX = ChromeLegacyIpc_MessageClass_CLASS_UNFREEZABLE_FRAME;
   enum FieldNumbers {
-    kDestinationPackageFieldNumber = 1,
-    kDestinationClassFieldNumber = 2,
-    kPrivacyLevelFieldNumber = 3,
-    kSkipIncidentdFieldNumber = 5,
-    kSkipDropboxFieldNumber = 4,
+    kMessageClassFieldNumber = 1,
+    kMessageLineFieldNumber = 2,
   };
 
-  TraceConfig_IncidentReportConfig();
-  ~TraceConfig_IncidentReportConfig() override;
-  TraceConfig_IncidentReportConfig(TraceConfig_IncidentReportConfig&&) noexcept;
-  TraceConfig_IncidentReportConfig& operator=(TraceConfig_IncidentReportConfig&&);
-  TraceConfig_IncidentReportConfig(const TraceConfig_IncidentReportConfig&);
-  TraceConfig_IncidentReportConfig& operator=(const TraceConfig_IncidentReportConfig&);
-  bool operator==(const TraceConfig_IncidentReportConfig&) const;
-  bool operator!=(const TraceConfig_IncidentReportConfig& other) const { return !(*this == other); }
+  ChromeLegacyIpc();
+  ~ChromeLegacyIpc() override;
+  ChromeLegacyIpc(ChromeLegacyIpc&&) noexcept;
+  ChromeLegacyIpc& operator=(ChromeLegacyIpc&&);
+  ChromeLegacyIpc(const ChromeLegacyIpc&);
+  ChromeLegacyIpc& operator=(const ChromeLegacyIpc&);
+  bool operator==(const ChromeLegacyIpc&) const;
+  bool operator!=(const ChromeLegacyIpc& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_destination_package() const { return _has_field_[1]; }
-  const std::string& destination_package() const { return destination_package_; }
-  void set_destination_package(const std::string& value) { destination_package_ = value; _has_field_.set(1); }
-
-  bool has_destination_class() const { return _has_field_[2]; }
-  const std::string& destination_class() const { return destination_class_; }
-  void set_destination_class(const std::string& value) { destination_class_ = value; _has_field_.set(2); }
-
-  bool has_privacy_level() const { return _has_field_[3]; }
-  int32_t privacy_level() const { return privacy_level_; }
-  void set_privacy_level(int32_t value) { privacy_level_ = value; _has_field_.set(3); }
-
-  bool has_skip_incidentd() const { return _has_field_[5]; }
-  bool skip_incidentd() const { return skip_incidentd_; }
-  void set_skip_incidentd(bool value) { skip_incidentd_ = value; _has_field_.set(5); }
+  bool has_message_class() const { return _has_field_[1]; }
+  ChromeLegacyIpc_MessageClass message_class() const { return message_class_; }
+  void set_message_class(ChromeLegacyIpc_MessageClass value) { message_class_ = value; _has_field_.set(1); }
 
-  bool has_skip_dropbox() const { return _has_field_[4]; }
-  bool skip_dropbox() const { return skip_dropbox_; }
-  void set_skip_dropbox(bool value) { skip_dropbox_ = value; _has_field_.set(4); }
+  bool has_message_line() const { return _has_field_[2]; }
+  uint32_t message_line() const { return message_line_; }
+  void set_message_line(uint32_t value) { message_line_ = value; _has_field_.set(2); }
 
  private:
-  std::string destination_package_{};
-  std::string destination_class_{};
-  int32_t privacy_level_{};
-  bool skip_incidentd_{};
-  bool skip_dropbox_{};
+  ChromeLegacyIpc_MessageClass message_class_{};
+  uint32_t message_line_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<6> _has_field_{};
+  std::bitset<3> _has_field_{};
 };
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-class PERFETTO_EXPORT_COMPONENT TraceConfig_IncrementalStateConfig : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kClearPeriodMsFieldNumber = 1,
-  };
-
-  TraceConfig_IncrementalStateConfig();
-  ~TraceConfig_IncrementalStateConfig() override;
-  TraceConfig_IncrementalStateConfig(TraceConfig_IncrementalStateConfig&&) noexcept;
-  TraceConfig_IncrementalStateConfig& operator=(TraceConfig_IncrementalStateConfig&&);
-  TraceConfig_IncrementalStateConfig(const TraceConfig_IncrementalStateConfig&);
-  TraceConfig_IncrementalStateConfig& operator=(const TraceConfig_IncrementalStateConfig&);
-  bool operator==(const TraceConfig_IncrementalStateConfig&) const;
-  bool operator!=(const TraceConfig_IncrementalStateConfig& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_LEGACY_IPC_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_message_pump.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MESSAGE_PUMP_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MESSAGE_PUMP_PROTO_CPP_H_
 
-  bool has_clear_period_ms() const { return _has_field_[1]; }
-  uint32_t clear_period_ms() const { return clear_period_ms_; }
-  void set_clear_period_ms(uint32_t value) { clear_period_ms_ = value; _has_field_.set(1); }
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
- private:
-  uint32_t clear_period_ms_{};
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+namespace perfetto {
+namespace protos {
+namespace gen {
+class ChromeMessagePump;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  std::bitset<2> _has_field_{};
-};
+namespace protozero {
+class Message;
+}  // namespace protozero
 
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-class PERFETTO_EXPORT_COMPONENT TraceConfig_TriggerConfig : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT ChromeMessagePump : public ::protozero::CppMessageObj {
  public:
-  using Trigger = TraceConfig_TriggerConfig_Trigger;
-  using TriggerMode = TraceConfig_TriggerConfig_TriggerMode;
-  static constexpr auto UNSPECIFIED = TraceConfig_TriggerConfig_TriggerMode_UNSPECIFIED;
-  static constexpr auto START_TRACING = TraceConfig_TriggerConfig_TriggerMode_START_TRACING;
-  static constexpr auto STOP_TRACING = TraceConfig_TriggerConfig_TriggerMode_STOP_TRACING;
-  static constexpr auto TriggerMode_MIN = TraceConfig_TriggerConfig_TriggerMode_UNSPECIFIED;
-  static constexpr auto TriggerMode_MAX = TraceConfig_TriggerConfig_TriggerMode_STOP_TRACING;
   enum FieldNumbers {
-    kTriggerModeFieldNumber = 1,
-    kTriggersFieldNumber = 2,
-    kTriggerTimeoutMsFieldNumber = 3,
+    kSentMessagesInQueueFieldNumber = 1,
+    kIoHandlerLocationIidFieldNumber = 2,
   };
 
-  TraceConfig_TriggerConfig();
-  ~TraceConfig_TriggerConfig() override;
-  TraceConfig_TriggerConfig(TraceConfig_TriggerConfig&&) noexcept;
-  TraceConfig_TriggerConfig& operator=(TraceConfig_TriggerConfig&&);
-  TraceConfig_TriggerConfig(const TraceConfig_TriggerConfig&);
-  TraceConfig_TriggerConfig& operator=(const TraceConfig_TriggerConfig&);
-  bool operator==(const TraceConfig_TriggerConfig&) const;
-  bool operator!=(const TraceConfig_TriggerConfig& other) const { return !(*this == other); }
+  ChromeMessagePump();
+  ~ChromeMessagePump() override;
+  ChromeMessagePump(ChromeMessagePump&&) noexcept;
+  ChromeMessagePump& operator=(ChromeMessagePump&&);
+  ChromeMessagePump(const ChromeMessagePump&);
+  ChromeMessagePump& operator=(const ChromeMessagePump&);
+  bool operator==(const ChromeMessagePump&) const;
+  bool operator!=(const ChromeMessagePump& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_trigger_mode() const { return _has_field_[1]; }
-  TraceConfig_TriggerConfig_TriggerMode trigger_mode() const { return trigger_mode_; }
-  void set_trigger_mode(TraceConfig_TriggerConfig_TriggerMode value) { trigger_mode_ = value; _has_field_.set(1); }
-
-  const std::vector<TraceConfig_TriggerConfig_Trigger>& triggers() const { return triggers_; }
-  std::vector<TraceConfig_TriggerConfig_Trigger>* mutable_triggers() { return &triggers_; }
-  int triggers_size() const;
-  void clear_triggers();
-  TraceConfig_TriggerConfig_Trigger* add_triggers();
+  bool has_sent_messages_in_queue() const { return _has_field_[1]; }
+  bool sent_messages_in_queue() const { return sent_messages_in_queue_; }
+  void set_sent_messages_in_queue(bool value) { sent_messages_in_queue_ = value; _has_field_.set(1); }
 
-  bool has_trigger_timeout_ms() const { return _has_field_[3]; }
-  uint32_t trigger_timeout_ms() const { return trigger_timeout_ms_; }
-  void set_trigger_timeout_ms(uint32_t value) { trigger_timeout_ms_ = value; _has_field_.set(3); }
+  bool has_io_handler_location_iid() const { return _has_field_[2]; }
+  uint64_t io_handler_location_iid() const { return io_handler_location_iid_; }
+  void set_io_handler_location_iid(uint64_t value) { io_handler_location_iid_ = value; _has_field_.set(2); }
 
  private:
-  TraceConfig_TriggerConfig_TriggerMode trigger_mode_{};
-  std::vector<TraceConfig_TriggerConfig_Trigger> triggers_;
-  uint32_t trigger_timeout_ms_{};
+  bool sent_messages_in_queue_{};
+  uint64_t io_handler_location_iid_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<4> _has_field_{};
+  std::bitset<3> _has_field_{};
 };
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-class PERFETTO_EXPORT_COMPONENT TraceConfig_TriggerConfig_Trigger : public ::protozero::CppMessageObj {
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MESSAGE_PUMP_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_mojo_event_info.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MOJO_EVENT_INFO_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MOJO_EVENT_INFO_PROTO_CPP_H_
+
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+class ChromeMojoEventInfo;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+namespace protozero {
+class Message;
+}  // namespace protozero
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+
+class PERFETTO_EXPORT_COMPONENT ChromeMojoEventInfo : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kNameFieldNumber = 1,
-    kProducerNameRegexFieldNumber = 2,
-    kStopDelayMsFieldNumber = 3,
-    kMaxPer24HFieldNumber = 4,
-    kSkipProbabilityFieldNumber = 5,
+    kWatcherNotifyInterfaceTagFieldNumber = 1,
+    kIpcHashFieldNumber = 2,
+    kMojoInterfaceTagFieldNumber = 3,
+    kMojoInterfaceMethodIidFieldNumber = 4,
+    kIsReplyFieldNumber = 5,
+    kPayloadSizeFieldNumber = 6,
+    kDataNumBytesFieldNumber = 7,
   };
 
-  TraceConfig_TriggerConfig_Trigger();
-  ~TraceConfig_TriggerConfig_Trigger() override;
-  TraceConfig_TriggerConfig_Trigger(TraceConfig_TriggerConfig_Trigger&&) noexcept;
-  TraceConfig_TriggerConfig_Trigger& operator=(TraceConfig_TriggerConfig_Trigger&&);
-  TraceConfig_TriggerConfig_Trigger(const TraceConfig_TriggerConfig_Trigger&);
-  TraceConfig_TriggerConfig_Trigger& operator=(const TraceConfig_TriggerConfig_Trigger&);
-  bool operator==(const TraceConfig_TriggerConfig_Trigger&) const;
-  bool operator!=(const TraceConfig_TriggerConfig_Trigger& other) const { return !(*this == other); }
+  ChromeMojoEventInfo();
+  ~ChromeMojoEventInfo() override;
+  ChromeMojoEventInfo(ChromeMojoEventInfo&&) noexcept;
+  ChromeMojoEventInfo& operator=(ChromeMojoEventInfo&&);
+  ChromeMojoEventInfo(const ChromeMojoEventInfo&);
+  ChromeMojoEventInfo& operator=(const ChromeMojoEventInfo&);
+  bool operator==(const ChromeMojoEventInfo&) const;
+  bool operator!=(const ChromeMojoEventInfo& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_name() const { return _has_field_[1]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(1); }
+  bool has_watcher_notify_interface_tag() const { return _has_field_[1]; }
+  const std::string& watcher_notify_interface_tag() const { return watcher_notify_interface_tag_; }
+  void set_watcher_notify_interface_tag(const std::string& value) { watcher_notify_interface_tag_ = value; _has_field_.set(1); }
 
-  bool has_producer_name_regex() const { return _has_field_[2]; }
-  const std::string& producer_name_regex() const { return producer_name_regex_; }
-  void set_producer_name_regex(const std::string& value) { producer_name_regex_ = value; _has_field_.set(2); }
+  bool has_ipc_hash() const { return _has_field_[2]; }
+  uint32_t ipc_hash() const { return ipc_hash_; }
+  void set_ipc_hash(uint32_t value) { ipc_hash_ = value; _has_field_.set(2); }
 
-  bool has_stop_delay_ms() const { return _has_field_[3]; }
-  uint32_t stop_delay_ms() const { return stop_delay_ms_; }
-  void set_stop_delay_ms(uint32_t value) { stop_delay_ms_ = value; _has_field_.set(3); }
+  bool has_mojo_interface_tag() const { return _has_field_[3]; }
+  const std::string& mojo_interface_tag() const { return mojo_interface_tag_; }
+  void set_mojo_interface_tag(const std::string& value) { mojo_interface_tag_ = value; _has_field_.set(3); }
 
-  bool has_max_per_24_h() const { return _has_field_[4]; }
-  uint32_t max_per_24_h() const { return max_per_24_h_; }
-  void set_max_per_24_h(uint32_t value) { max_per_24_h_ = value; _has_field_.set(4); }
+  bool has_mojo_interface_method_iid() const { return _has_field_[4]; }
+  uint64_t mojo_interface_method_iid() const { return mojo_interface_method_iid_; }
+  void set_mojo_interface_method_iid(uint64_t value) { mojo_interface_method_iid_ = value; _has_field_.set(4); }
 
-  bool has_skip_probability() const { return _has_field_[5]; }
-  double skip_probability() const { return skip_probability_; }
-  void set_skip_probability(double value) { skip_probability_ = value; _has_field_.set(5); }
+  bool has_is_reply() const { return _has_field_[5]; }
+  bool is_reply() const { return is_reply_; }
+  void set_is_reply(bool value) { is_reply_ = value; _has_field_.set(5); }
+
+  bool has_payload_size() const { return _has_field_[6]; }
+  uint64_t payload_size() const { return payload_size_; }
+  void set_payload_size(uint64_t value) { payload_size_ = value; _has_field_.set(6); }
+
+  bool has_data_num_bytes() const { return _has_field_[7]; }
+  uint64_t data_num_bytes() const { return data_num_bytes_; }
+  void set_data_num_bytes(uint64_t value) { data_num_bytes_ = value; _has_field_.set(7); }
 
  private:
-  std::string name_{};
-  std::string producer_name_regex_{};
-  uint32_t stop_delay_ms_{};
-  uint32_t max_per_24_h_{};
-  double skip_probability_{};
+  std::string watcher_notify_interface_tag_{};
+  uint32_t ipc_hash_{};
+  std::string mojo_interface_tag_{};
+  uint64_t mojo_interface_method_iid_{};
+  bool is_reply_{};
+  uint64_t payload_size_{};
+  uint64_t data_num_bytes_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<6> _has_field_{};
+  std::bitset<8> _has_field_{};
 };
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-class PERFETTO_EXPORT_COMPONENT TraceConfig_GuardrailOverrides : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kMaxUploadPerDayBytesFieldNumber = 1,
-    kMaxTracingBufferSizeKbFieldNumber = 2,
-  };
-
-  TraceConfig_GuardrailOverrides();
-  ~TraceConfig_GuardrailOverrides() override;
-  TraceConfig_GuardrailOverrides(TraceConfig_GuardrailOverrides&&) noexcept;
-  TraceConfig_GuardrailOverrides& operator=(TraceConfig_GuardrailOverrides&&);
-  TraceConfig_GuardrailOverrides(const TraceConfig_GuardrailOverrides&);
-  TraceConfig_GuardrailOverrides& operator=(const TraceConfig_GuardrailOverrides&);
-  bool operator==(const TraceConfig_GuardrailOverrides&) const;
-  bool operator!=(const TraceConfig_GuardrailOverrides& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_max_upload_per_day_bytes() const { return _has_field_[1]; }
-  uint64_t max_upload_per_day_bytes() const { return max_upload_per_day_bytes_; }
-  void set_max_upload_per_day_bytes(uint64_t value) { max_upload_per_day_bytes_ = value; _has_field_.set(1); }
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_MOJO_EVENT_INFO_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_process_descriptor.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_PROCESS_DESCRIPTOR_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_PROCESS_DESCRIPTOR_PROTO_CPP_H_
 
-  bool has_max_tracing_buffer_size_kb() const { return _has_field_[2]; }
-  uint32_t max_tracing_buffer_size_kb() const { return max_tracing_buffer_size_kb_; }
-  void set_max_tracing_buffer_size_kb(uint32_t value) { max_tracing_buffer_size_kb_ = value; _has_field_.set(2); }
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
- private:
-  uint64_t max_upload_per_day_bytes_{};
-  uint32_t max_tracing_buffer_size_kb_{};
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+namespace perfetto {
+namespace protos {
+namespace gen {
+class ChromeProcessDescriptor;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  std::bitset<3> _has_field_{};
-};
+namespace protozero {
+class Message;
+}  // namespace protozero
 
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-class PERFETTO_EXPORT_COMPONENT TraceConfig_StatsdMetadata : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT ChromeProcessDescriptor : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kTriggeringAlertIdFieldNumber = 1,
-    kTriggeringConfigUidFieldNumber = 2,
-    kTriggeringConfigIdFieldNumber = 3,
-    kTriggeringSubscriptionIdFieldNumber = 4,
+    kProcessTypeFieldNumber = 1,
+    kProcessPriorityFieldNumber = 2,
+    kLegacySortIndexFieldNumber = 3,
+    kHostAppPackageNameFieldNumber = 4,
+    kCrashTraceIdFieldNumber = 5,
   };
 
-  TraceConfig_StatsdMetadata();
-  ~TraceConfig_StatsdMetadata() override;
-  TraceConfig_StatsdMetadata(TraceConfig_StatsdMetadata&&) noexcept;
-  TraceConfig_StatsdMetadata& operator=(TraceConfig_StatsdMetadata&&);
-  TraceConfig_StatsdMetadata(const TraceConfig_StatsdMetadata&);
-  TraceConfig_StatsdMetadata& operator=(const TraceConfig_StatsdMetadata&);
-  bool operator==(const TraceConfig_StatsdMetadata&) const;
-  bool operator!=(const TraceConfig_StatsdMetadata& other) const { return !(*this == other); }
+  ChromeProcessDescriptor();
+  ~ChromeProcessDescriptor() override;
+  ChromeProcessDescriptor(ChromeProcessDescriptor&&) noexcept;
+  ChromeProcessDescriptor& operator=(ChromeProcessDescriptor&&);
+  ChromeProcessDescriptor(const ChromeProcessDescriptor&);
+  ChromeProcessDescriptor& operator=(const ChromeProcessDescriptor&);
+  bool operator==(const ChromeProcessDescriptor&) const;
+  bool operator!=(const ChromeProcessDescriptor& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_triggering_alert_id() const { return _has_field_[1]; }
-  int64_t triggering_alert_id() const { return triggering_alert_id_; }
-  void set_triggering_alert_id(int64_t value) { triggering_alert_id_ = value; _has_field_.set(1); }
+  bool has_process_type() const { return _has_field_[1]; }
+  int32_t process_type() const { return process_type_; }
+  void set_process_type(int32_t value) { process_type_ = value; _has_field_.set(1); }
 
-  bool has_triggering_config_uid() const { return _has_field_[2]; }
-  int32_t triggering_config_uid() const { return triggering_config_uid_; }
-  void set_triggering_config_uid(int32_t value) { triggering_config_uid_ = value; _has_field_.set(2); }
+  bool has_process_priority() const { return _has_field_[2]; }
+  int32_t process_priority() const { return process_priority_; }
+  void set_process_priority(int32_t value) { process_priority_ = value; _has_field_.set(2); }
 
-  bool has_triggering_config_id() const { return _has_field_[3]; }
-  int64_t triggering_config_id() const { return triggering_config_id_; }
-  void set_triggering_config_id(int64_t value) { triggering_config_id_ = value; _has_field_.set(3); }
+  bool has_legacy_sort_index() const { return _has_field_[3]; }
+  int32_t legacy_sort_index() const { return legacy_sort_index_; }
+  void set_legacy_sort_index(int32_t value) { legacy_sort_index_ = value; _has_field_.set(3); }
 
-  bool has_triggering_subscription_id() const { return _has_field_[4]; }
-  int64_t triggering_subscription_id() const { return triggering_subscription_id_; }
-  void set_triggering_subscription_id(int64_t value) { triggering_subscription_id_ = value; _has_field_.set(4); }
+  bool has_host_app_package_name() const { return _has_field_[4]; }
+  const std::string& host_app_package_name() const { return host_app_package_name_; }
+  void set_host_app_package_name(const std::string& value) { host_app_package_name_ = value; _has_field_.set(4); }
+
+  bool has_crash_trace_id() const { return _has_field_[5]; }
+  uint64_t crash_trace_id() const { return crash_trace_id_; }
+  void set_crash_trace_id(uint64_t value) { crash_trace_id_ = value; _has_field_.set(5); }
 
  private:
-  int64_t triggering_alert_id_{};
-  int32_t triggering_config_uid_{};
-  int64_t triggering_config_id_{};
-  int64_t triggering_subscription_id_{};
+  int32_t process_type_{};
+  int32_t process_priority_{};
+  int32_t legacy_sort_index_{};
+  std::string host_app_package_name_{};
+  uint64_t crash_trace_id_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<5> _has_field_{};
+  std::bitset<6> _has_field_{};
 };
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-class PERFETTO_EXPORT_COMPONENT TraceConfig_ProducerConfig : public ::protozero::CppMessageObj {
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_PROCESS_DESCRIPTOR_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_renderer_scheduler_state.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_RENDERER_SCHEDULER_STATE_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_RENDERER_SCHEDULER_STATE_PROTO_CPP_H_
+
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+class ChromeRendererSchedulerState;
+enum ChromeRAILMode : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+namespace protozero {
+class Message;
+}  // namespace protozero
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum ChromeRAILMode : int {
+  RAIL_MODE_NONE = 0,
+  RAIL_MODE_RESPONSE = 1,
+  RAIL_MODE_ANIMATION = 2,
+  RAIL_MODE_IDLE = 3,
+  RAIL_MODE_LOAD = 4,
+};
+
+class PERFETTO_EXPORT_COMPONENT ChromeRendererSchedulerState : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kProducerNameFieldNumber = 1,
-    kShmSizeKbFieldNumber = 2,
-    kPageSizeKbFieldNumber = 3,
+    kRailModeFieldNumber = 1,
+    kIsBackgroundedFieldNumber = 2,
+    kIsHiddenFieldNumber = 3,
   };
 
-  TraceConfig_ProducerConfig();
-  ~TraceConfig_ProducerConfig() override;
-  TraceConfig_ProducerConfig(TraceConfig_ProducerConfig&&) noexcept;
-  TraceConfig_ProducerConfig& operator=(TraceConfig_ProducerConfig&&);
-  TraceConfig_ProducerConfig(const TraceConfig_ProducerConfig&);
-  TraceConfig_ProducerConfig& operator=(const TraceConfig_ProducerConfig&);
-  bool operator==(const TraceConfig_ProducerConfig&) const;
-  bool operator!=(const TraceConfig_ProducerConfig& other) const { return !(*this == other); }
+  ChromeRendererSchedulerState();
+  ~ChromeRendererSchedulerState() override;
+  ChromeRendererSchedulerState(ChromeRendererSchedulerState&&) noexcept;
+  ChromeRendererSchedulerState& operator=(ChromeRendererSchedulerState&&);
+  ChromeRendererSchedulerState(const ChromeRendererSchedulerState&);
+  ChromeRendererSchedulerState& operator=(const ChromeRendererSchedulerState&);
+  bool operator==(const ChromeRendererSchedulerState&) const;
+  bool operator!=(const ChromeRendererSchedulerState& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_producer_name() const { return _has_field_[1]; }
-  const std::string& producer_name() const { return producer_name_; }
-  void set_producer_name(const std::string& value) { producer_name_ = value; _has_field_.set(1); }
+  bool has_rail_mode() const { return _has_field_[1]; }
+  ChromeRAILMode rail_mode() const { return rail_mode_; }
+  void set_rail_mode(ChromeRAILMode value) { rail_mode_ = value; _has_field_.set(1); }
 
-  bool has_shm_size_kb() const { return _has_field_[2]; }
-  uint32_t shm_size_kb() const { return shm_size_kb_; }
-  void set_shm_size_kb(uint32_t value) { shm_size_kb_ = value; _has_field_.set(2); }
+  bool has_is_backgrounded() const { return _has_field_[2]; }
+  bool is_backgrounded() const { return is_backgrounded_; }
+  void set_is_backgrounded(bool value) { is_backgrounded_ = value; _has_field_.set(2); }
 
-  bool has_page_size_kb() const { return _has_field_[3]; }
-  uint32_t page_size_kb() const { return page_size_kb_; }
-  void set_page_size_kb(uint32_t value) { page_size_kb_ = value; _has_field_.set(3); }
+  bool has_is_hidden() const { return _has_field_[3]; }
+  bool is_hidden() const { return is_hidden_; }
+  void set_is_hidden(bool value) { is_hidden_ = value; _has_field_.set(3); }
 
  private:
-  std::string producer_name_{};
-  uint32_t shm_size_kb_{};
-  uint32_t page_size_kb_{};
+  ChromeRAILMode rail_mode_{};
+  bool is_backgrounded_{};
+  bool is_hidden_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
@@ -171541,186 +191397,255 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig_ProducerConfig : public ::protozero:
   std::bitset<4> _has_field_{};
 };
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-class PERFETTO_EXPORT_COMPONENT TraceConfig_BuiltinDataSource : public ::protozero::CppMessageObj {
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_RENDERER_SCHEDULER_STATE_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_thread_descriptor.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_THREAD_DESCRIPTOR_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_THREAD_DESCRIPTOR_PROTO_CPP_H_
+
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+class ChromeThreadDescriptor;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+namespace protozero {
+class Message;
+}  // namespace protozero
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+
+class PERFETTO_EXPORT_COMPONENT ChromeThreadDescriptor : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kDisableClockSnapshottingFieldNumber = 1,
-    kDisableTraceConfigFieldNumber = 2,
-    kDisableSystemInfoFieldNumber = 3,
-    kDisableServiceEventsFieldNumber = 4,
-    kPrimaryTraceClockFieldNumber = 5,
-    kSnapshotIntervalMsFieldNumber = 6,
-    kPreferSuspendClockForSnapshotFieldNumber = 7,
+    kThreadTypeFieldNumber = 1,
+    kLegacySortIndexFieldNumber = 2,
+    kIsSandboxedTidFieldNumber = 3,
   };
 
-  TraceConfig_BuiltinDataSource();
-  ~TraceConfig_BuiltinDataSource() override;
-  TraceConfig_BuiltinDataSource(TraceConfig_BuiltinDataSource&&) noexcept;
-  TraceConfig_BuiltinDataSource& operator=(TraceConfig_BuiltinDataSource&&);
-  TraceConfig_BuiltinDataSource(const TraceConfig_BuiltinDataSource&);
-  TraceConfig_BuiltinDataSource& operator=(const TraceConfig_BuiltinDataSource&);
-  bool operator==(const TraceConfig_BuiltinDataSource&) const;
-  bool operator!=(const TraceConfig_BuiltinDataSource& other) const { return !(*this == other); }
+  ChromeThreadDescriptor();
+  ~ChromeThreadDescriptor() override;
+  ChromeThreadDescriptor(ChromeThreadDescriptor&&) noexcept;
+  ChromeThreadDescriptor& operator=(ChromeThreadDescriptor&&);
+  ChromeThreadDescriptor(const ChromeThreadDescriptor&);
+  ChromeThreadDescriptor& operator=(const ChromeThreadDescriptor&);
+  bool operator==(const ChromeThreadDescriptor&) const;
+  bool operator!=(const ChromeThreadDescriptor& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_disable_clock_snapshotting() const { return _has_field_[1]; }
-  bool disable_clock_snapshotting() const { return disable_clock_snapshotting_; }
-  void set_disable_clock_snapshotting(bool value) { disable_clock_snapshotting_ = value; _has_field_.set(1); }
-
-  bool has_disable_trace_config() const { return _has_field_[2]; }
-  bool disable_trace_config() const { return disable_trace_config_; }
-  void set_disable_trace_config(bool value) { disable_trace_config_ = value; _has_field_.set(2); }
-
-  bool has_disable_system_info() const { return _has_field_[3]; }
-  bool disable_system_info() const { return disable_system_info_; }
-  void set_disable_system_info(bool value) { disable_system_info_ = value; _has_field_.set(3); }
-
-  bool has_disable_service_events() const { return _has_field_[4]; }
-  bool disable_service_events() const { return disable_service_events_; }
-  void set_disable_service_events(bool value) { disable_service_events_ = value; _has_field_.set(4); }
-
-  bool has_primary_trace_clock() const { return _has_field_[5]; }
-  BuiltinClock primary_trace_clock() const { return primary_trace_clock_; }
-  void set_primary_trace_clock(BuiltinClock value) { primary_trace_clock_ = value; _has_field_.set(5); }
+  bool has_thread_type() const { return _has_field_[1]; }
+  int32_t thread_type() const { return thread_type_; }
+  void set_thread_type(int32_t value) { thread_type_ = value; _has_field_.set(1); }
 
-  bool has_snapshot_interval_ms() const { return _has_field_[6]; }
-  uint32_t snapshot_interval_ms() const { return snapshot_interval_ms_; }
-  void set_snapshot_interval_ms(uint32_t value) { snapshot_interval_ms_ = value; _has_field_.set(6); }
+  bool has_legacy_sort_index() const { return _has_field_[2]; }
+  int32_t legacy_sort_index() const { return legacy_sort_index_; }
+  void set_legacy_sort_index(int32_t value) { legacy_sort_index_ = value; _has_field_.set(2); }
 
-  bool has_prefer_suspend_clock_for_snapshot() const { return _has_field_[7]; }
-  bool prefer_suspend_clock_for_snapshot() const { return prefer_suspend_clock_for_snapshot_; }
-  void set_prefer_suspend_clock_for_snapshot(bool value) { prefer_suspend_clock_for_snapshot_ = value; _has_field_.set(7); }
+  bool has_is_sandboxed_tid() const { return _has_field_[3]; }
+  bool is_sandboxed_tid() const { return is_sandboxed_tid_; }
+  void set_is_sandboxed_tid(bool value) { is_sandboxed_tid_ = value; _has_field_.set(3); }
 
  private:
-  bool disable_clock_snapshotting_{};
-  bool disable_trace_config_{};
-  bool disable_system_info_{};
-  bool disable_service_events_{};
-  BuiltinClock primary_trace_clock_{};
-  uint32_t snapshot_interval_ms_{};
-  bool prefer_suspend_clock_for_snapshot_{};
+  int32_t thread_type_{};
+  int32_t legacy_sort_index_{};
+  bool is_sandboxed_tid_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<8> _has_field_{};
+  std::bitset<4> _has_field_{};
 };
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-class PERFETTO_EXPORT_COMPONENT TraceConfig_DataSource : public ::protozero::CppMessageObj {
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_THREAD_DESCRIPTOR_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_user_event.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_USER_EVENT_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_USER_EVENT_PROTO_CPP_H_
+
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
+
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+class ChromeUserEvent;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+namespace protozero {
+class Message;
+}  // namespace protozero
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+
+class PERFETTO_EXPORT_COMPONENT ChromeUserEvent : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kConfigFieldNumber = 1,
-    kProducerNameFilterFieldNumber = 2,
-    kProducerNameRegexFilterFieldNumber = 3,
+    kActionFieldNumber = 1,
+    kActionHashFieldNumber = 2,
   };
 
-  TraceConfig_DataSource();
-  ~TraceConfig_DataSource() override;
-  TraceConfig_DataSource(TraceConfig_DataSource&&) noexcept;
-  TraceConfig_DataSource& operator=(TraceConfig_DataSource&&);
-  TraceConfig_DataSource(const TraceConfig_DataSource&);
-  TraceConfig_DataSource& operator=(const TraceConfig_DataSource&);
-  bool operator==(const TraceConfig_DataSource&) const;
-  bool operator!=(const TraceConfig_DataSource& other) const { return !(*this == other); }
+  ChromeUserEvent();
+  ~ChromeUserEvent() override;
+  ChromeUserEvent(ChromeUserEvent&&) noexcept;
+  ChromeUserEvent& operator=(ChromeUserEvent&&);
+  ChromeUserEvent(const ChromeUserEvent&);
+  ChromeUserEvent& operator=(const ChromeUserEvent&);
+  bool operator==(const ChromeUserEvent&) const;
+  bool operator!=(const ChromeUserEvent& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_config() const { return _has_field_[1]; }
-  const DataSourceConfig& config() const { return *config_; }
-  DataSourceConfig* mutable_config() { _has_field_.set(1); return config_.get(); }
-
-  const std::vector<std::string>& producer_name_filter() const { return producer_name_filter_; }
-  std::vector<std::string>* mutable_producer_name_filter() { return &producer_name_filter_; }
-  int producer_name_filter_size() const { return static_cast<int>(producer_name_filter_.size()); }
-  void clear_producer_name_filter() { producer_name_filter_.clear(); }
-  void add_producer_name_filter(std::string value) { producer_name_filter_.emplace_back(value); }
-  std::string* add_producer_name_filter() { producer_name_filter_.emplace_back(); return &producer_name_filter_.back(); }
+  bool has_action() const { return _has_field_[1]; }
+  const std::string& action() const { return action_; }
+  void set_action(const std::string& value) { action_ = value; _has_field_.set(1); }
 
-  const std::vector<std::string>& producer_name_regex_filter() const { return producer_name_regex_filter_; }
-  std::vector<std::string>* mutable_producer_name_regex_filter() { return &producer_name_regex_filter_; }
-  int producer_name_regex_filter_size() const { return static_cast<int>(producer_name_regex_filter_.size()); }
-  void clear_producer_name_regex_filter() { producer_name_regex_filter_.clear(); }
-  void add_producer_name_regex_filter(std::string value) { producer_name_regex_filter_.emplace_back(value); }
-  std::string* add_producer_name_regex_filter() { producer_name_regex_filter_.emplace_back(); return &producer_name_regex_filter_.back(); }
+  bool has_action_hash() const { return _has_field_[2]; }
+  uint64_t action_hash() const { return action_hash_; }
+  void set_action_hash(uint64_t value) { action_hash_ = value; _has_field_.set(2); }
 
  private:
-  ::protozero::CopyablePtr<DataSourceConfig> config_;
-  std::vector<std::string> producer_name_filter_;
-  std::vector<std::string> producer_name_regex_filter_;
+  std::string action_{};
+  uint64_t action_hash_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<4> _has_field_{};
+  std::bitset<3> _has_field_{};
 };
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_USER_EVENT_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/chrome_window_handle_event_info.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_WINDOW_HANDLE_EVENT_INFO_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_WINDOW_HANDLE_EVENT_INFO_PROTO_CPP_H_
+
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-class PERFETTO_EXPORT_COMPONENT TraceConfig_BufferConfig : public ::protozero::CppMessageObj {
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+class ChromeWindowHandleEventInfo;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+namespace protozero {
+class Message;
+}  // namespace protozero
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+
+class PERFETTO_EXPORT_COMPONENT ChromeWindowHandleEventInfo : public ::protozero::CppMessageObj {
  public:
-  using FillPolicy = TraceConfig_BufferConfig_FillPolicy;
-  static constexpr auto UNSPECIFIED = TraceConfig_BufferConfig_FillPolicy_UNSPECIFIED;
-  static constexpr auto RING_BUFFER = TraceConfig_BufferConfig_FillPolicy_RING_BUFFER;
-  static constexpr auto DISCARD = TraceConfig_BufferConfig_FillPolicy_DISCARD;
-  static constexpr auto FillPolicy_MIN = TraceConfig_BufferConfig_FillPolicy_UNSPECIFIED;
-  static constexpr auto FillPolicy_MAX = TraceConfig_BufferConfig_FillPolicy_DISCARD;
   enum FieldNumbers {
-    kSizeKbFieldNumber = 1,
-    kFillPolicyFieldNumber = 4,
+    kDpiFieldNumber = 1,
+    kMessageIdFieldNumber = 2,
+    kHwndPtrFieldNumber = 3,
   };
 
-  TraceConfig_BufferConfig();
-  ~TraceConfig_BufferConfig() override;
-  TraceConfig_BufferConfig(TraceConfig_BufferConfig&&) noexcept;
-  TraceConfig_BufferConfig& operator=(TraceConfig_BufferConfig&&);
-  TraceConfig_BufferConfig(const TraceConfig_BufferConfig&);
-  TraceConfig_BufferConfig& operator=(const TraceConfig_BufferConfig&);
-  bool operator==(const TraceConfig_BufferConfig&) const;
-  bool operator!=(const TraceConfig_BufferConfig& other) const { return !(*this == other); }
+  ChromeWindowHandleEventInfo();
+  ~ChromeWindowHandleEventInfo() override;
+  ChromeWindowHandleEventInfo(ChromeWindowHandleEventInfo&&) noexcept;
+  ChromeWindowHandleEventInfo& operator=(ChromeWindowHandleEventInfo&&);
+  ChromeWindowHandleEventInfo(const ChromeWindowHandleEventInfo&);
+  ChromeWindowHandleEventInfo& operator=(const ChromeWindowHandleEventInfo&);
+  bool operator==(const ChromeWindowHandleEventInfo&) const;
+  bool operator!=(const ChromeWindowHandleEventInfo& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_size_kb() const { return _has_field_[1]; }
-  uint32_t size_kb() const { return size_kb_; }
-  void set_size_kb(uint32_t value) { size_kb_ = value; _has_field_.set(1); }
+  bool has_dpi() const { return _has_field_[1]; }
+  uint32_t dpi() const { return dpi_; }
+  void set_dpi(uint32_t value) { dpi_ = value; _has_field_.set(1); }
 
-  bool has_fill_policy() const { return _has_field_[4]; }
-  TraceConfig_BufferConfig_FillPolicy fill_policy() const { return fill_policy_; }
-  void set_fill_policy(TraceConfig_BufferConfig_FillPolicy value) { fill_policy_ = value; _has_field_.set(4); }
+  bool has_message_id() const { return _has_field_[2]; }
+  uint32_t message_id() const { return message_id_; }
+  void set_message_id(uint32_t value) { message_id_ = value; _has_field_.set(2); }
+
+  bool has_hwnd_ptr() const { return _has_field_[3]; }
+  uint64_t hwnd_ptr() const { return hwnd_ptr_; }
+  void set_hwnd_ptr(uint64_t value) { hwnd_ptr_ = value; _has_field_.set(3); }
 
  private:
-  uint32_t size_kb_{};
-  TraceConfig_BufferConfig_FillPolicy fill_policy_{};
+  uint32_t dpi_{};
+  uint32_t message_id_{};
+  uint64_t hwnd_ptr_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<5> _has_field_{};
+  std::bitset<4> _has_field_{};
 };
 
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_TRACE_CONFIG_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/ipc/consumer_port.gen.h
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_CHROME_WINDOW_HANDLE_EVENT_INFO_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/debug_annotation.gen.h
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_CONSUMER_PORT_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_CONSUMER_PORT_PROTO_CPP_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_DEBUG_ANNOTATION_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_DEBUG_ANNOTATION_PROTO_CPP_H_
 
 #include <stdint.h>
 #include <bitset>
@@ -171735,79 +191660,11 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig_BufferConfig : public ::protozero::C
 namespace perfetto {
 namespace protos {
 namespace gen {
-class CloneSessionResponse;
-class CloneSessionRequest;
-class SaveTraceForBugreportResponse;
-class SaveTraceForBugreportRequest;
-class QueryCapabilitiesResponse;
-class TracingServiceCapabilities;
-class QueryCapabilitiesRequest;
-class QueryServiceStateResponse;
-class TracingServiceState;
-class TracingServiceState_TracingSession;
-class TracingServiceState_DataSource;
-class DataSourceDescriptor;
-class TracingServiceState_Producer;
-class QueryServiceStateRequest;
-class ObserveEventsResponse;
-class ObservableEvents;
-class ObservableEvents_DataSourceInstanceStateChange;
-class ObserveEventsRequest;
-class GetTraceStatsResponse;
-class TraceStats;
-class TraceStats_FilterStats;
-class TraceStats_BufferStats;
-class GetTraceStatsRequest;
-class AttachResponse;
-class TraceConfig;
-class TraceConfig_CmdTraceStartDelay;
-class TraceConfig_AndroidReportConfig;
-class TraceConfig_TraceFilter;
-class TraceConfig_IncidentReportConfig;
-class TraceConfig_IncrementalStateConfig;
-class TraceConfig_TriggerConfig;
-class TraceConfig_TriggerConfig_Trigger;
-class TraceConfig_GuardrailOverrides;
-class TraceConfig_StatsdMetadata;
-class TraceConfig_ProducerConfig;
-class TraceConfig_BuiltinDataSource;
-class TraceConfig_DataSource;
-class DataSourceConfig;
-class TestConfig;
-class TestConfig_DummyFields;
-class InterceptorConfig;
-class ChromeConfig;
-class SystemInfoConfig;
-class TraceConfig_BufferConfig;
-class AttachRequest;
-class DetachResponse;
-class DetachRequest;
-class FlushResponse;
-class FlushRequest;
-class FreeBuffersResponse;
-class FreeBuffersRequest;
-class ReadBuffersResponse;
-class ReadBuffersResponse_Slice;
-class ReadBuffersRequest;
-class DisableTracingResponse;
-class DisableTracingRequest;
-class ChangeTraceConfigResponse;
-class ChangeTraceConfigRequest;
-class StartTracingResponse;
-class StartTracingRequest;
-class EnableTracingResponse;
-class EnableTracingRequest;
-enum ObservableEvents_Type : int;
-enum ObservableEvents_DataSourceInstanceState : int;
-enum TraceStats_FinalFlushOutcome : int;
-enum TraceConfig_LockdownModeOperation : int;
-enum TraceConfig_CompressionType : int;
-enum TraceConfig_StatsdLogging : int;
-enum TraceConfig_TriggerConfig_TriggerMode : int;
-enum BuiltinClock : int;
-enum DataSourceConfig_SessionInitiator : int;
-enum ChromeConfig_ClientPriority : int;
-enum TraceConfig_BufferConfig_FillPolicy : int;
+class DebugAnnotationValueTypeName;
+class DebugAnnotationName;
+class DebugAnnotation;
+class DebugAnnotation_NestedValue;
+enum DebugAnnotation_NestedValue_NestedType : int;
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
@@ -171819,39 +191676,44 @@ class Message;
 namespace perfetto {
 namespace protos {
 namespace gen {
+enum DebugAnnotation_NestedValue_NestedType : int {
+  DebugAnnotation_NestedValue_NestedType_UNSPECIFIED = 0,
+  DebugAnnotation_NestedValue_NestedType_DICT = 1,
+  DebugAnnotation_NestedValue_NestedType_ARRAY = 2,
+};
 
-class PERFETTO_EXPORT_COMPONENT CloneSessionResponse : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT DebugAnnotationValueTypeName : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kSuccessFieldNumber = 1,
-    kErrorFieldNumber = 2,
+    kIidFieldNumber = 1,
+    kNameFieldNumber = 2,
   };
 
-  CloneSessionResponse();
-  ~CloneSessionResponse() override;
-  CloneSessionResponse(CloneSessionResponse&&) noexcept;
-  CloneSessionResponse& operator=(CloneSessionResponse&&);
-  CloneSessionResponse(const CloneSessionResponse&);
-  CloneSessionResponse& operator=(const CloneSessionResponse&);
-  bool operator==(const CloneSessionResponse&) const;
-  bool operator!=(const CloneSessionResponse& other) const { return !(*this == other); }
+  DebugAnnotationValueTypeName();
+  ~DebugAnnotationValueTypeName() override;
+  DebugAnnotationValueTypeName(DebugAnnotationValueTypeName&&) noexcept;
+  DebugAnnotationValueTypeName& operator=(DebugAnnotationValueTypeName&&);
+  DebugAnnotationValueTypeName(const DebugAnnotationValueTypeName&);
+  DebugAnnotationValueTypeName& operator=(const DebugAnnotationValueTypeName&);
+  bool operator==(const DebugAnnotationValueTypeName&) const;
+  bool operator!=(const DebugAnnotationValueTypeName& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_success() const { return _has_field_[1]; }
-  bool success() const { return success_; }
-  void set_success(bool value) { success_ = value; _has_field_.set(1); }
+  bool has_iid() const { return _has_field_[1]; }
+  uint64_t iid() const { return iid_; }
+  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
 
-  bool has_error() const { return _has_field_[2]; }
-  const std::string& error() const { return error_; }
-  void set_error(const std::string& value) { error_ = value; _has_field_.set(2); }
+  bool has_name() const { return _has_field_[2]; }
+  const std::string& name() const { return name_; }
+  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
 
  private:
-  bool success_{};
-  std::string error_{};
+  uint64_t iid_{};
+  std::string name_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
@@ -171861,265 +191723,475 @@ class PERFETTO_EXPORT_COMPONENT CloneSessionResponse : public ::protozero::CppMe
 };
 
 
-class PERFETTO_EXPORT_COMPONENT CloneSessionRequest : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT DebugAnnotationName : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kSessionIdFieldNumber = 1,
+    kIidFieldNumber = 1,
+    kNameFieldNumber = 2,
   };
 
-  CloneSessionRequest();
-  ~CloneSessionRequest() override;
-  CloneSessionRequest(CloneSessionRequest&&) noexcept;
-  CloneSessionRequest& operator=(CloneSessionRequest&&);
-  CloneSessionRequest(const CloneSessionRequest&);
-  CloneSessionRequest& operator=(const CloneSessionRequest&);
-  bool operator==(const CloneSessionRequest&) const;
-  bool operator!=(const CloneSessionRequest& other) const { return !(*this == other); }
+  DebugAnnotationName();
+  ~DebugAnnotationName() override;
+  DebugAnnotationName(DebugAnnotationName&&) noexcept;
+  DebugAnnotationName& operator=(DebugAnnotationName&&);
+  DebugAnnotationName(const DebugAnnotationName&);
+  DebugAnnotationName& operator=(const DebugAnnotationName&);
+  bool operator==(const DebugAnnotationName&) const;
+  bool operator!=(const DebugAnnotationName& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_session_id() const { return _has_field_[1]; }
-  uint64_t session_id() const { return session_id_; }
-  void set_session_id(uint64_t value) { session_id_ = value; _has_field_.set(1); }
+  bool has_iid() const { return _has_field_[1]; }
+  uint64_t iid() const { return iid_; }
+  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
+
+  bool has_name() const { return _has_field_[2]; }
+  const std::string& name() const { return name_; }
+  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
 
  private:
-  uint64_t session_id_{};
+  uint64_t iid_{};
+  std::string name_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<2> _has_field_{};
+  std::bitset<3> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT SaveTraceForBugreportResponse : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT DebugAnnotation : public ::protozero::CppMessageObj {
  public:
+  using NestedValue = DebugAnnotation_NestedValue;
   enum FieldNumbers {
-    kSuccessFieldNumber = 1,
-    kMsgFieldNumber = 2,
+    kNameIidFieldNumber = 1,
+    kNameFieldNumber = 10,
+    kBoolValueFieldNumber = 2,
+    kUintValueFieldNumber = 3,
+    kIntValueFieldNumber = 4,
+    kDoubleValueFieldNumber = 5,
+    kPointerValueFieldNumber = 7,
+    kNestedValueFieldNumber = 8,
+    kLegacyJsonValueFieldNumber = 9,
+    kStringValueFieldNumber = 6,
+    kStringValueIidFieldNumber = 17,
+    kProtoTypeNameFieldNumber = 16,
+    kProtoTypeNameIidFieldNumber = 13,
+    kProtoValueFieldNumber = 14,
+    kDictEntriesFieldNumber = 11,
+    kArrayValuesFieldNumber = 12,
   };
 
-  SaveTraceForBugreportResponse();
-  ~SaveTraceForBugreportResponse() override;
-  SaveTraceForBugreportResponse(SaveTraceForBugreportResponse&&) noexcept;
-  SaveTraceForBugreportResponse& operator=(SaveTraceForBugreportResponse&&);
-  SaveTraceForBugreportResponse(const SaveTraceForBugreportResponse&);
-  SaveTraceForBugreportResponse& operator=(const SaveTraceForBugreportResponse&);
-  bool operator==(const SaveTraceForBugreportResponse&) const;
-  bool operator!=(const SaveTraceForBugreportResponse& other) const { return !(*this == other); }
+  DebugAnnotation();
+  ~DebugAnnotation() override;
+  DebugAnnotation(DebugAnnotation&&) noexcept;
+  DebugAnnotation& operator=(DebugAnnotation&&);
+  DebugAnnotation(const DebugAnnotation&);
+  DebugAnnotation& operator=(const DebugAnnotation&);
+  bool operator==(const DebugAnnotation&) const;
+  bool operator!=(const DebugAnnotation& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_success() const { return _has_field_[1]; }
-  bool success() const { return success_; }
-  void set_success(bool value) { success_ = value; _has_field_.set(1); }
+  bool has_name_iid() const { return _has_field_[1]; }
+  uint64_t name_iid() const { return name_iid_; }
+  void set_name_iid(uint64_t value) { name_iid_ = value; _has_field_.set(1); }
 
-  bool has_msg() const { return _has_field_[2]; }
-  const std::string& msg() const { return msg_; }
-  void set_msg(const std::string& value) { msg_ = value; _has_field_.set(2); }
+  bool has_name() const { return _has_field_[10]; }
+  const std::string& name() const { return name_; }
+  void set_name(const std::string& value) { name_ = value; _has_field_.set(10); }
+
+  bool has_bool_value() const { return _has_field_[2]; }
+  bool bool_value() const { return bool_value_; }
+  void set_bool_value(bool value) { bool_value_ = value; _has_field_.set(2); }
+
+  bool has_uint_value() const { return _has_field_[3]; }
+  uint64_t uint_value() const { return uint_value_; }
+  void set_uint_value(uint64_t value) { uint_value_ = value; _has_field_.set(3); }
+
+  bool has_int_value() const { return _has_field_[4]; }
+  int64_t int_value() const { return int_value_; }
+  void set_int_value(int64_t value) { int_value_ = value; _has_field_.set(4); }
+
+  bool has_double_value() const { return _has_field_[5]; }
+  double double_value() const { return double_value_; }
+  void set_double_value(double value) { double_value_ = value; _has_field_.set(5); }
+
+  bool has_pointer_value() const { return _has_field_[7]; }
+  uint64_t pointer_value() const { return pointer_value_; }
+  void set_pointer_value(uint64_t value) { pointer_value_ = value; _has_field_.set(7); }
+
+  bool has_nested_value() const { return _has_field_[8]; }
+  const DebugAnnotation_NestedValue& nested_value() const { return *nested_value_; }
+  DebugAnnotation_NestedValue* mutable_nested_value() { _has_field_.set(8); return nested_value_.get(); }
+
+  bool has_legacy_json_value() const { return _has_field_[9]; }
+  const std::string& legacy_json_value() const { return legacy_json_value_; }
+  void set_legacy_json_value(const std::string& value) { legacy_json_value_ = value; _has_field_.set(9); }
+
+  bool has_string_value() const { return _has_field_[6]; }
+  const std::string& string_value() const { return string_value_; }
+  void set_string_value(const std::string& value) { string_value_ = value; _has_field_.set(6); }
+
+  bool has_string_value_iid() const { return _has_field_[17]; }
+  uint64_t string_value_iid() const { return string_value_iid_; }
+  void set_string_value_iid(uint64_t value) { string_value_iid_ = value; _has_field_.set(17); }
+
+  bool has_proto_type_name() const { return _has_field_[16]; }
+  const std::string& proto_type_name() const { return proto_type_name_; }
+  void set_proto_type_name(const std::string& value) { proto_type_name_ = value; _has_field_.set(16); }
+
+  bool has_proto_type_name_iid() const { return _has_field_[13]; }
+  uint64_t proto_type_name_iid() const { return proto_type_name_iid_; }
+  void set_proto_type_name_iid(uint64_t value) { proto_type_name_iid_ = value; _has_field_.set(13); }
+
+  bool has_proto_value() const { return _has_field_[14]; }
+  const std::string& proto_value() const { return proto_value_; }
+  void set_proto_value(const std::string& value) { proto_value_ = value; _has_field_.set(14); }
+  void set_proto_value(const void* p, size_t s) { proto_value_.assign(reinterpret_cast<const char*>(p), s); _has_field_.set(14); }
+
+  const std::vector<DebugAnnotation>& dict_entries() const { return dict_entries_; }
+  std::vector<DebugAnnotation>* mutable_dict_entries() { return &dict_entries_; }
+  int dict_entries_size() const;
+  void clear_dict_entries();
+  DebugAnnotation* add_dict_entries();
+
+  const std::vector<DebugAnnotation>& array_values() const { return array_values_; }
+  std::vector<DebugAnnotation>* mutable_array_values() { return &array_values_; }
+  int array_values_size() const;
+  void clear_array_values();
+  DebugAnnotation* add_array_values();
 
  private:
-  bool success_{};
-  std::string msg_{};
+  uint64_t name_iid_{};
+  std::string name_{};
+  bool bool_value_{};
+  uint64_t uint_value_{};
+  int64_t int_value_{};
+  double double_value_{};
+  uint64_t pointer_value_{};
+  ::protozero::CopyablePtr<DebugAnnotation_NestedValue> nested_value_;
+  std::string legacy_json_value_{};
+  std::string string_value_{};
+  uint64_t string_value_iid_{};
+  std::string proto_type_name_{};
+  uint64_t proto_type_name_iid_{};
+  std::string proto_value_{};
+  std::vector<DebugAnnotation> dict_entries_;
+  std::vector<DebugAnnotation> array_values_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<3> _has_field_{};
+  std::bitset<18> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT SaveTraceForBugreportRequest : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT DebugAnnotation_NestedValue : public ::protozero::CppMessageObj {
  public:
+  using NestedType = DebugAnnotation_NestedValue_NestedType;
+  static constexpr auto UNSPECIFIED = DebugAnnotation_NestedValue_NestedType_UNSPECIFIED;
+  static constexpr auto DICT = DebugAnnotation_NestedValue_NestedType_DICT;
+  static constexpr auto ARRAY = DebugAnnotation_NestedValue_NestedType_ARRAY;
+  static constexpr auto NestedType_MIN = DebugAnnotation_NestedValue_NestedType_UNSPECIFIED;
+  static constexpr auto NestedType_MAX = DebugAnnotation_NestedValue_NestedType_ARRAY;
   enum FieldNumbers {
+    kNestedTypeFieldNumber = 1,
+    kDictKeysFieldNumber = 2,
+    kDictValuesFieldNumber = 3,
+    kArrayValuesFieldNumber = 4,
+    kIntValueFieldNumber = 5,
+    kDoubleValueFieldNumber = 6,
+    kBoolValueFieldNumber = 7,
+    kStringValueFieldNumber = 8,
   };
 
-  SaveTraceForBugreportRequest();
-  ~SaveTraceForBugreportRequest() override;
-  SaveTraceForBugreportRequest(SaveTraceForBugreportRequest&&) noexcept;
-  SaveTraceForBugreportRequest& operator=(SaveTraceForBugreportRequest&&);
-  SaveTraceForBugreportRequest(const SaveTraceForBugreportRequest&);
-  SaveTraceForBugreportRequest& operator=(const SaveTraceForBugreportRequest&);
-  bool operator==(const SaveTraceForBugreportRequest&) const;
-  bool operator!=(const SaveTraceForBugreportRequest& other) const { return !(*this == other); }
+  DebugAnnotation_NestedValue();
+  ~DebugAnnotation_NestedValue() override;
+  DebugAnnotation_NestedValue(DebugAnnotation_NestedValue&&) noexcept;
+  DebugAnnotation_NestedValue& operator=(DebugAnnotation_NestedValue&&);
+  DebugAnnotation_NestedValue(const DebugAnnotation_NestedValue&);
+  DebugAnnotation_NestedValue& operator=(const DebugAnnotation_NestedValue&);
+  bool operator==(const DebugAnnotation_NestedValue&) const;
+  bool operator!=(const DebugAnnotation_NestedValue& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_nested_type() const { return _has_field_[1]; }
+  DebugAnnotation_NestedValue_NestedType nested_type() const { return nested_type_; }
+  void set_nested_type(DebugAnnotation_NestedValue_NestedType value) { nested_type_ = value; _has_field_.set(1); }
+
+  const std::vector<std::string>& dict_keys() const { return dict_keys_; }
+  std::vector<std::string>* mutable_dict_keys() { return &dict_keys_; }
+  int dict_keys_size() const { return static_cast<int>(dict_keys_.size()); }
+  void clear_dict_keys() { dict_keys_.clear(); }
+  void add_dict_keys(std::string value) { dict_keys_.emplace_back(value); }
+  std::string* add_dict_keys() { dict_keys_.emplace_back(); return &dict_keys_.back(); }
+
+  const std::vector<DebugAnnotation_NestedValue>& dict_values() const { return dict_values_; }
+  std::vector<DebugAnnotation_NestedValue>* mutable_dict_values() { return &dict_values_; }
+  int dict_values_size() const;
+  void clear_dict_values();
+  DebugAnnotation_NestedValue* add_dict_values();
+
+  const std::vector<DebugAnnotation_NestedValue>& array_values() const { return array_values_; }
+  std::vector<DebugAnnotation_NestedValue>* mutable_array_values() { return &array_values_; }
+  int array_values_size() const;
+  void clear_array_values();
+  DebugAnnotation_NestedValue* add_array_values();
+
+  bool has_int_value() const { return _has_field_[5]; }
+  int64_t int_value() const { return int_value_; }
+  void set_int_value(int64_t value) { int_value_ = value; _has_field_.set(5); }
+
+  bool has_double_value() const { return _has_field_[6]; }
+  double double_value() const { return double_value_; }
+  void set_double_value(double value) { double_value_ = value; _has_field_.set(6); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  bool has_bool_value() const { return _has_field_[7]; }
+  bool bool_value() const { return bool_value_; }
+  void set_bool_value(bool value) { bool_value_ = value; _has_field_.set(7); }
+
+  bool has_string_value() const { return _has_field_[8]; }
+  const std::string& string_value() const { return string_value_; }
+  void set_string_value(const std::string& value) { string_value_ = value; _has_field_.set(8); }
 
  private:
+  DebugAnnotation_NestedValue_NestedType nested_type_{};
+  std::vector<std::string> dict_keys_;
+  std::vector<DebugAnnotation_NestedValue> dict_values_;
+  std::vector<DebugAnnotation_NestedValue> array_values_;
+  int64_t int_value_{};
+  double double_value_{};
+  bool bool_value_{};
+  std::string string_value_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<2> _has_field_{};
+  std::bitset<9> _has_field_{};
 };
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-class PERFETTO_EXPORT_COMPONENT QueryCapabilitiesResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kCapabilitiesFieldNumber = 1,
-  };
-
-  QueryCapabilitiesResponse();
-  ~QueryCapabilitiesResponse() override;
-  QueryCapabilitiesResponse(QueryCapabilitiesResponse&&) noexcept;
-  QueryCapabilitiesResponse& operator=(QueryCapabilitiesResponse&&);
-  QueryCapabilitiesResponse(const QueryCapabilitiesResponse&);
-  QueryCapabilitiesResponse& operator=(const QueryCapabilitiesResponse&);
-  bool operator==(const QueryCapabilitiesResponse&) const;
-  bool operator!=(const QueryCapabilitiesResponse& other) const { return !(*this == other); }
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_DEBUG_ANNOTATION_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/log_message.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_LOG_MESSAGE_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_LOG_MESSAGE_PROTO_CPP_H_
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  bool has_capabilities() const { return _has_field_[1]; }
-  const TracingServiceCapabilities& capabilities() const { return *capabilities_; }
-  TracingServiceCapabilities* mutable_capabilities() { _has_field_.set(1); return capabilities_.get(); }
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
- private:
-  ::protozero::CopyablePtr<TracingServiceCapabilities> capabilities_;
+namespace perfetto {
+namespace protos {
+namespace gen {
+class LogMessageBody;
+class LogMessage;
+enum LogMessage_Priority : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  std::bitset<2> _has_field_{};
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum LogMessage_Priority : int {
+  LogMessage_Priority_PRIO_UNSPECIFIED = 0,
+  LogMessage_Priority_PRIO_UNUSED = 1,
+  LogMessage_Priority_PRIO_VERBOSE = 2,
+  LogMessage_Priority_PRIO_DEBUG = 3,
+  LogMessage_Priority_PRIO_INFO = 4,
+  LogMessage_Priority_PRIO_WARN = 5,
+  LogMessage_Priority_PRIO_ERROR = 6,
+  LogMessage_Priority_PRIO_FATAL = 7,
 };
 
-
-class PERFETTO_EXPORT_COMPONENT QueryCapabilitiesRequest : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT LogMessageBody : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
+    kIidFieldNumber = 1,
+    kBodyFieldNumber = 2,
   };
 
-  QueryCapabilitiesRequest();
-  ~QueryCapabilitiesRequest() override;
-  QueryCapabilitiesRequest(QueryCapabilitiesRequest&&) noexcept;
-  QueryCapabilitiesRequest& operator=(QueryCapabilitiesRequest&&);
-  QueryCapabilitiesRequest(const QueryCapabilitiesRequest&);
-  QueryCapabilitiesRequest& operator=(const QueryCapabilitiesRequest&);
-  bool operator==(const QueryCapabilitiesRequest&) const;
-  bool operator!=(const QueryCapabilitiesRequest& other) const { return !(*this == other); }
+  LogMessageBody();
+  ~LogMessageBody() override;
+  LogMessageBody(LogMessageBody&&) noexcept;
+  LogMessageBody& operator=(LogMessageBody&&);
+  LogMessageBody(const LogMessageBody&);
+  LogMessageBody& operator=(const LogMessageBody&);
+  bool operator==(const LogMessageBody&) const;
+  bool operator!=(const LogMessageBody& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
+  bool has_iid() const { return _has_field_[1]; }
+  uint64_t iid() const { return iid_; }
+  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
+
+  bool has_body() const { return _has_field_[2]; }
+  const std::string& body() const { return body_; }
+  void set_body(const std::string& value) { body_ = value; _has_field_.set(2); }
+
  private:
+  uint64_t iid_{};
+  std::string body_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<2> _has_field_{};
+  std::bitset<3> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT QueryServiceStateResponse : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT LogMessage : public ::protozero::CppMessageObj {
  public:
+  using Priority = LogMessage_Priority;
+  static constexpr auto PRIO_UNSPECIFIED = LogMessage_Priority_PRIO_UNSPECIFIED;
+  static constexpr auto PRIO_UNUSED = LogMessage_Priority_PRIO_UNUSED;
+  static constexpr auto PRIO_VERBOSE = LogMessage_Priority_PRIO_VERBOSE;
+  static constexpr auto PRIO_DEBUG = LogMessage_Priority_PRIO_DEBUG;
+  static constexpr auto PRIO_INFO = LogMessage_Priority_PRIO_INFO;
+  static constexpr auto PRIO_WARN = LogMessage_Priority_PRIO_WARN;
+  static constexpr auto PRIO_ERROR = LogMessage_Priority_PRIO_ERROR;
+  static constexpr auto PRIO_FATAL = LogMessage_Priority_PRIO_FATAL;
+  static constexpr auto Priority_MIN = LogMessage_Priority_PRIO_UNSPECIFIED;
+  static constexpr auto Priority_MAX = LogMessage_Priority_PRIO_FATAL;
   enum FieldNumbers {
-    kServiceStateFieldNumber = 1,
+    kSourceLocationIidFieldNumber = 1,
+    kBodyIidFieldNumber = 2,
+    kPrioFieldNumber = 3,
   };
 
-  QueryServiceStateResponse();
-  ~QueryServiceStateResponse() override;
-  QueryServiceStateResponse(QueryServiceStateResponse&&) noexcept;
-  QueryServiceStateResponse& operator=(QueryServiceStateResponse&&);
-  QueryServiceStateResponse(const QueryServiceStateResponse&);
-  QueryServiceStateResponse& operator=(const QueryServiceStateResponse&);
-  bool operator==(const QueryServiceStateResponse&) const;
-  bool operator!=(const QueryServiceStateResponse& other) const { return !(*this == other); }
+  LogMessage();
+  ~LogMessage() override;
+  LogMessage(LogMessage&&) noexcept;
+  LogMessage& operator=(LogMessage&&);
+  LogMessage(const LogMessage&);
+  LogMessage& operator=(const LogMessage&);
+  bool operator==(const LogMessage&) const;
+  bool operator!=(const LogMessage& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_service_state() const { return _has_field_[1]; }
-  const TracingServiceState& service_state() const { return *service_state_; }
-  TracingServiceState* mutable_service_state() { _has_field_.set(1); return service_state_.get(); }
+  bool has_source_location_iid() const { return _has_field_[1]; }
+  uint64_t source_location_iid() const { return source_location_iid_; }
+  void set_source_location_iid(uint64_t value) { source_location_iid_ = value; _has_field_.set(1); }
+
+  bool has_body_iid() const { return _has_field_[2]; }
+  uint64_t body_iid() const { return body_iid_; }
+  void set_body_iid(uint64_t value) { body_iid_ = value; _has_field_.set(2); }
+
+  bool has_prio() const { return _has_field_[3]; }
+  LogMessage_Priority prio() const { return prio_; }
+  void set_prio(LogMessage_Priority value) { prio_ = value; _has_field_.set(3); }
 
  private:
-  ::protozero::CopyablePtr<TracingServiceState> service_state_;
+  uint64_t source_location_iid_{};
+  uint64_t body_iid_{};
+  LogMessage_Priority prio_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<2> _has_field_{};
+  std::bitset<4> _has_field_{};
 };
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-class PERFETTO_EXPORT_COMPONENT QueryServiceStateRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  QueryServiceStateRequest();
-  ~QueryServiceStateRequest() override;
-  QueryServiceStateRequest(QueryServiceStateRequest&&) noexcept;
-  QueryServiceStateRequest& operator=(QueryServiceStateRequest&&);
-  QueryServiceStateRequest(const QueryServiceStateRequest&);
-  QueryServiceStateRequest& operator=(const QueryServiceStateRequest&);
-  bool operator==(const QueryServiceStateRequest&) const;
-  bool operator!=(const QueryServiceStateRequest& other) const { return !(*this == other); }
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_LOG_MESSAGE_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/range_of_interest.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_RANGE_OF_INTEREST_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_RANGE_OF_INTEREST_PROTO_CPP_H_
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
- private:
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+namespace perfetto {
+namespace protos {
+namespace gen {
+class TrackEventRangeOfInterest;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  std::bitset<2> _has_field_{};
-};
+namespace protozero {
+class Message;
+}  // namespace protozero
 
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-class PERFETTO_EXPORT_COMPONENT ObserveEventsResponse : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT TrackEventRangeOfInterest : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kEventsFieldNumber = 1,
+    kStartUsFieldNumber = 1,
   };
 
-  ObserveEventsResponse();
-  ~ObserveEventsResponse() override;
-  ObserveEventsResponse(ObserveEventsResponse&&) noexcept;
-  ObserveEventsResponse& operator=(ObserveEventsResponse&&);
-  ObserveEventsResponse(const ObserveEventsResponse&);
-  ObserveEventsResponse& operator=(const ObserveEventsResponse&);
-  bool operator==(const ObserveEventsResponse&) const;
-  bool operator!=(const ObserveEventsResponse& other) const { return !(*this == other); }
+  TrackEventRangeOfInterest();
+  ~TrackEventRangeOfInterest() override;
+  TrackEventRangeOfInterest(TrackEventRangeOfInterest&&) noexcept;
+  TrackEventRangeOfInterest& operator=(TrackEventRangeOfInterest&&);
+  TrackEventRangeOfInterest(const TrackEventRangeOfInterest&);
+  TrackEventRangeOfInterest& operator=(const TrackEventRangeOfInterest&);
+  bool operator==(const TrackEventRangeOfInterest&) const;
+  bool operator!=(const TrackEventRangeOfInterest& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_events() const { return _has_field_[1]; }
-  const ObservableEvents& events() const { return *events_; }
-  ObservableEvents* mutable_events() { _has_field_.set(1); return events_.get(); }
+  bool has_start_us() const { return _has_field_[1]; }
+  int64_t start_us() const { return start_us_; }
+  void set_start_us(int64_t value) { start_us_ = value; _has_field_.set(1); }
 
  private:
-  ::protozero::CopyablePtr<ObservableEvents> events_;
+  int64_t start_us_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
@@ -172128,71 +192200,69 @@ class PERFETTO_EXPORT_COMPONENT ObserveEventsResponse : public ::protozero::CppM
   std::bitset<2> _has_field_{};
 };
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-class PERFETTO_EXPORT_COMPONENT ObserveEventsRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kEventsToObserveFieldNumber = 1,
-  };
-
-  ObserveEventsRequest();
-  ~ObserveEventsRequest() override;
-  ObserveEventsRequest(ObserveEventsRequest&&) noexcept;
-  ObserveEventsRequest& operator=(ObserveEventsRequest&&);
-  ObserveEventsRequest(const ObserveEventsRequest&);
-  ObserveEventsRequest& operator=(const ObserveEventsRequest&);
-  bool operator==(const ObserveEventsRequest&) const;
-  bool operator!=(const ObserveEventsRequest& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_RANGE_OF_INTEREST_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/screenshot.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_SCREENSHOT_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_SCREENSHOT_PROTO_CPP_H_
 
-  const std::vector<ObservableEvents_Type>& events_to_observe() const { return events_to_observe_; }
-  std::vector<ObservableEvents_Type>* mutable_events_to_observe() { return &events_to_observe_; }
-  int events_to_observe_size() const { return static_cast<int>(events_to_observe_.size()); }
-  void clear_events_to_observe() { events_to_observe_.clear(); }
-  void add_events_to_observe(ObservableEvents_Type value) { events_to_observe_.emplace_back(value); }
-  ObservableEvents_Type* add_events_to_observe() { events_to_observe_.emplace_back(); return &events_to_observe_.back(); }
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
- private:
-  std::vector<ObservableEvents_Type> events_to_observe_;
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+namespace perfetto {
+namespace protos {
+namespace gen {
+class Screenshot;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  std::bitset<2> _has_field_{};
-};
+namespace protozero {
+class Message;
+}  // namespace protozero
 
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-class PERFETTO_EXPORT_COMPONENT GetTraceStatsResponse : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT Screenshot : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kTraceStatsFieldNumber = 1,
+    kJpgImageFieldNumber = 1,
   };
 
-  GetTraceStatsResponse();
-  ~GetTraceStatsResponse() override;
-  GetTraceStatsResponse(GetTraceStatsResponse&&) noexcept;
-  GetTraceStatsResponse& operator=(GetTraceStatsResponse&&);
-  GetTraceStatsResponse(const GetTraceStatsResponse&);
-  GetTraceStatsResponse& operator=(const GetTraceStatsResponse&);
-  bool operator==(const GetTraceStatsResponse&) const;
-  bool operator!=(const GetTraceStatsResponse& other) const { return !(*this == other); }
+  Screenshot();
+  ~Screenshot() override;
+  Screenshot(Screenshot&&) noexcept;
+  Screenshot& operator=(Screenshot&&);
+  Screenshot(const Screenshot&);
+  Screenshot& operator=(const Screenshot&);
+  bool operator==(const Screenshot&) const;
+  bool operator!=(const Screenshot& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_trace_stats() const { return _has_field_[1]; }
-  const TraceStats& trace_stats() const { return *trace_stats_; }
-  TraceStats* mutable_trace_stats() { _has_field_.set(1); return trace_stats_.get(); }
+  bool has_jpg_image() const { return _has_field_[1]; }
+  const std::string& jpg_image() const { return jpg_image_; }
+  void set_jpg_image(const std::string& value) { jpg_image_ = value; _has_field_.set(1); }
+  void set_jpg_image(const void* p, size_t s) { jpg_image_.assign(reinterpret_cast<const char*>(p), s); _has_field_.set(1); }
 
  private:
-  ::protozero::CopyablePtr<TraceStats> trace_stats_;
+  std::string jpg_image_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
@@ -172201,161 +192271,204 @@ class PERFETTO_EXPORT_COMPONENT GetTraceStatsResponse : public ::protozero::CppM
   std::bitset<2> _has_field_{};
 };
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-class PERFETTO_EXPORT_COMPONENT GetTraceStatsRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  GetTraceStatsRequest();
-  ~GetTraceStatsRequest() override;
-  GetTraceStatsRequest(GetTraceStatsRequest&&) noexcept;
-  GetTraceStatsRequest& operator=(GetTraceStatsRequest&&);
-  GetTraceStatsRequest(const GetTraceStatsRequest&);
-  GetTraceStatsRequest& operator=(const GetTraceStatsRequest&);
-  bool operator==(const GetTraceStatsRequest&) const;
-  bool operator!=(const GetTraceStatsRequest& other) const { return !(*this == other); }
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_SCREENSHOT_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/source_location.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_SOURCE_LOCATION_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_SOURCE_LOCATION_PROTO_CPP_H_
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
- private:
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+namespace perfetto {
+namespace protos {
+namespace gen {
+class SourceLocation;
+class UnsymbolizedSourceLocation;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  std::bitset<2> _has_field_{};
-};
+namespace protozero {
+class Message;
+}  // namespace protozero
 
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-class PERFETTO_EXPORT_COMPONENT AttachResponse : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT SourceLocation : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kTraceConfigFieldNumber = 1,
+    kIidFieldNumber = 1,
+    kFileNameFieldNumber = 2,
+    kFunctionNameFieldNumber = 3,
+    kLineNumberFieldNumber = 4,
   };
 
-  AttachResponse();
-  ~AttachResponse() override;
-  AttachResponse(AttachResponse&&) noexcept;
-  AttachResponse& operator=(AttachResponse&&);
-  AttachResponse(const AttachResponse&);
-  AttachResponse& operator=(const AttachResponse&);
-  bool operator==(const AttachResponse&) const;
-  bool operator!=(const AttachResponse& other) const { return !(*this == other); }
+  SourceLocation();
+  ~SourceLocation() override;
+  SourceLocation(SourceLocation&&) noexcept;
+  SourceLocation& operator=(SourceLocation&&);
+  SourceLocation(const SourceLocation&);
+  SourceLocation& operator=(const SourceLocation&);
+  bool operator==(const SourceLocation&) const;
+  bool operator!=(const SourceLocation& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_trace_config() const { return _has_field_[1]; }
-  const TraceConfig& trace_config() const { return *trace_config_; }
-  TraceConfig* mutable_trace_config() { _has_field_.set(1); return trace_config_.get(); }
+  bool has_iid() const { return _has_field_[1]; }
+  uint64_t iid() const { return iid_; }
+  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
+
+  bool has_file_name() const { return _has_field_[2]; }
+  const std::string& file_name() const { return file_name_; }
+  void set_file_name(const std::string& value) { file_name_ = value; _has_field_.set(2); }
+
+  bool has_function_name() const { return _has_field_[3]; }
+  const std::string& function_name() const { return function_name_; }
+  void set_function_name(const std::string& value) { function_name_ = value; _has_field_.set(3); }
+
+  bool has_line_number() const { return _has_field_[4]; }
+  uint32_t line_number() const { return line_number_; }
+  void set_line_number(uint32_t value) { line_number_ = value; _has_field_.set(4); }
 
  private:
-  ::protozero::CopyablePtr<TraceConfig> trace_config_;
+  uint64_t iid_{};
+  std::string file_name_{};
+  std::string function_name_{};
+  uint32_t line_number_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<2> _has_field_{};
+  std::bitset<5> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT AttachRequest : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT UnsymbolizedSourceLocation : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kKeyFieldNumber = 1,
+    kIidFieldNumber = 1,
+    kMappingIdFieldNumber = 2,
+    kRelPcFieldNumber = 3,
   };
 
-  AttachRequest();
-  ~AttachRequest() override;
-  AttachRequest(AttachRequest&&) noexcept;
-  AttachRequest& operator=(AttachRequest&&);
-  AttachRequest(const AttachRequest&);
-  AttachRequest& operator=(const AttachRequest&);
-  bool operator==(const AttachRequest&) const;
-  bool operator!=(const AttachRequest& other) const { return !(*this == other); }
+  UnsymbolizedSourceLocation();
+  ~UnsymbolizedSourceLocation() override;
+  UnsymbolizedSourceLocation(UnsymbolizedSourceLocation&&) noexcept;
+  UnsymbolizedSourceLocation& operator=(UnsymbolizedSourceLocation&&);
+  UnsymbolizedSourceLocation(const UnsymbolizedSourceLocation&);
+  UnsymbolizedSourceLocation& operator=(const UnsymbolizedSourceLocation&);
+  bool operator==(const UnsymbolizedSourceLocation&) const;
+  bool operator!=(const UnsymbolizedSourceLocation& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_key() const { return _has_field_[1]; }
-  const std::string& key() const { return key_; }
-  void set_key(const std::string& value) { key_ = value; _has_field_.set(1); }
+  bool has_iid() const { return _has_field_[1]; }
+  uint64_t iid() const { return iid_; }
+  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
+
+  bool has_mapping_id() const { return _has_field_[2]; }
+  uint64_t mapping_id() const { return mapping_id_; }
+  void set_mapping_id(uint64_t value) { mapping_id_ = value; _has_field_.set(2); }
+
+  bool has_rel_pc() const { return _has_field_[3]; }
+  uint64_t rel_pc() const { return rel_pc_; }
+  void set_rel_pc(uint64_t value) { rel_pc_ = value; _has_field_.set(3); }
 
  private:
-  std::string key_{};
+  uint64_t iid_{};
+  uint64_t mapping_id_{};
+  uint64_t rel_pc_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<2> _has_field_{};
+  std::bitset<4> _has_field_{};
 };
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-class PERFETTO_EXPORT_COMPONENT DetachResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
-
-  DetachResponse();
-  ~DetachResponse() override;
-  DetachResponse(DetachResponse&&) noexcept;
-  DetachResponse& operator=(DetachResponse&&);
-  DetachResponse(const DetachResponse&);
-  DetachResponse& operator=(const DetachResponse&);
-  bool operator==(const DetachResponse&) const;
-  bool operator!=(const DetachResponse& other) const { return !(*this == other); }
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_SOURCE_LOCATION_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/task_execution.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TASK_EXECUTION_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TASK_EXECUTION_PROTO_CPP_H_
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
- private:
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+namespace perfetto {
+namespace protos {
+namespace gen {
+class TaskExecution;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  std::bitset<2> _has_field_{};
-};
+namespace protozero {
+class Message;
+}  // namespace protozero
 
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-class PERFETTO_EXPORT_COMPONENT DetachRequest : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT TaskExecution : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kKeyFieldNumber = 1,
+    kPostedFromIidFieldNumber = 1,
   };
 
-  DetachRequest();
-  ~DetachRequest() override;
-  DetachRequest(DetachRequest&&) noexcept;
-  DetachRequest& operator=(DetachRequest&&);
-  DetachRequest(const DetachRequest&);
-  DetachRequest& operator=(const DetachRequest&);
-  bool operator==(const DetachRequest&) const;
-  bool operator!=(const DetachRequest& other) const { return !(*this == other); }
+  TaskExecution();
+  ~TaskExecution() override;
+  TaskExecution(TaskExecution&&) noexcept;
+  TaskExecution& operator=(TaskExecution&&);
+  TaskExecution(const TaskExecution&);
+  TaskExecution& operator=(const TaskExecution&);
+  bool operator==(const TaskExecution&) const;
+  bool operator!=(const TaskExecution& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_key() const { return _has_field_[1]; }
-  const std::string& key() const { return key_; }
-  void set_key(const std::string& value) { key_ = value; _has_field_.set(1); }
+  bool has_posted_from_iid() const { return _has_field_[1]; }
+  uint64_t posted_from_iid() const { return posted_from_iid_; }
+  void set_posted_from_iid(uint64_t value) { posted_from_iid_ = value; _has_field_.set(1); }
 
  private:
-  std::string key_{};
+  uint64_t posted_from_iid_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
@@ -172364,517 +192477,848 @@ class PERFETTO_EXPORT_COMPONENT DetachRequest : public ::protozero::CppMessageOb
   std::bitset<2> _has_field_{};
 };
 
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-class PERFETTO_EXPORT_COMPONENT FlushResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TASK_EXECUTION_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/trace/track_event/track_event.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TRACK_EVENT_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TRACK_EVENT_PROTO_CPP_H_
 
-  FlushResponse();
-  ~FlushResponse() override;
-  FlushResponse(FlushResponse&&) noexcept;
-  FlushResponse& operator=(FlushResponse&&);
-  FlushResponse(const FlushResponse&);
-  FlushResponse& operator=(const FlushResponse&);
-  bool operator==(const FlushResponse&) const;
-  bool operator!=(const FlushResponse& other) const { return !(*this == other); }
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
- private:
+namespace perfetto {
+namespace protos {
+namespace gen {
+class EventName;
+class EventCategory;
+class TrackEventDefaults;
+class TrackEvent;
+class TrackEvent_LegacyEvent;
+class ChromeMojoEventInfo;
+class ChromeMessagePump;
+class SourceLocation;
+class Screenshot;
+class ChromeActiveProcesses;
+class ChromeContentSettingsEventInfo;
+class ChromeWindowHandleEventInfo;
+class ChromeRendererSchedulerState;
+class ChromeApplicationStateInfo;
+class ChromeFrameReporter;
+class ChromeLatencyInfo;
+class ChromeLatencyInfo_ComponentInfo;
+class ChromeHistogramSample;
+class ChromeLegacyIpc;
+class ChromeKeyedService;
+class ChromeUserEvent;
+class ChromeCompositorSchedulerState;
+class CompositorTimingHistory;
+class BeginFrameSourceState;
+class BeginFrameArgs;
+class BeginFrameObserverState;
+class BeginImplFrameArgs;
+class BeginImplFrameArgs_TimestampsInUs;
+class ChromeCompositorStateMachine;
+class ChromeCompositorStateMachine_MinorState;
+class ChromeCompositorStateMachine_MajorState;
+class LogMessage;
+class TaskExecution;
+class DebugAnnotation;
+class DebugAnnotation_NestedValue;
+class TrackEvent_Callstack;
+class TrackEvent_Callstack_Frame;
+enum TrackEvent_Type : int;
+enum TrackEvent_LegacyEvent_FlowDirection : int;
+enum TrackEvent_LegacyEvent_InstantEventScope : int;
+enum ChromeRAILMode : int;
+enum ChromeApplicationStateInfo_ChromeApplicationState : int;
+enum ChromeFrameReporter_State : int;
+enum ChromeFrameReporter_FrameDropReason : int;
+enum ChromeFrameReporter_ScrollState : int;
+enum ChromeFrameReporter_FrameType : int;
+enum ChromeLatencyInfo_Step : int;
+enum ChromeLatencyInfo_LatencyComponentType : int;
+enum ChromeLatencyInfo_InputType : int;
+enum ChromeLegacyIpc_MessageClass : int;
+enum ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode : int;
+enum ChromeCompositorSchedulerAction : int;
+enum BeginFrameArgs_BeginFrameArgsType : int;
+enum BeginImplFrameArgs_State : int;
+enum ChromeCompositorStateMachine_MinorState_TreePriority : int;
+enum ChromeCompositorStateMachine_MinorState_ScrollHandlerState : int;
+enum ChromeCompositorStateMachine_MajorState_BeginImplFrameState : int;
+enum ChromeCompositorStateMachine_MajorState_BeginMainFrameState : int;
+enum ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState : int;
+enum ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState : int;
+enum LogMessage_Priority : int;
+enum DebugAnnotation_NestedValue_NestedType : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-  std::bitset<2> _has_field_{};
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum TrackEvent_Type : int {
+  TrackEvent_Type_TYPE_UNSPECIFIED = 0,
+  TrackEvent_Type_TYPE_SLICE_BEGIN = 1,
+  TrackEvent_Type_TYPE_SLICE_END = 2,
+  TrackEvent_Type_TYPE_INSTANT = 3,
+  TrackEvent_Type_TYPE_COUNTER = 4,
+};
+enum TrackEvent_LegacyEvent_FlowDirection : int {
+  TrackEvent_LegacyEvent_FlowDirection_FLOW_UNSPECIFIED = 0,
+  TrackEvent_LegacyEvent_FlowDirection_FLOW_IN = 1,
+  TrackEvent_LegacyEvent_FlowDirection_FLOW_OUT = 2,
+  TrackEvent_LegacyEvent_FlowDirection_FLOW_INOUT = 3,
+};
+enum TrackEvent_LegacyEvent_InstantEventScope : int {
+  TrackEvent_LegacyEvent_InstantEventScope_SCOPE_UNSPECIFIED = 0,
+  TrackEvent_LegacyEvent_InstantEventScope_SCOPE_GLOBAL = 1,
+  TrackEvent_LegacyEvent_InstantEventScope_SCOPE_PROCESS = 2,
+  TrackEvent_LegacyEvent_InstantEventScope_SCOPE_THREAD = 3,
 };
 
-
-class PERFETTO_EXPORT_COMPONENT FlushRequest : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT EventName : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kTimeoutMsFieldNumber = 1,
+    kIidFieldNumber = 1,
+    kNameFieldNumber = 2,
   };
 
-  FlushRequest();
-  ~FlushRequest() override;
-  FlushRequest(FlushRequest&&) noexcept;
-  FlushRequest& operator=(FlushRequest&&);
-  FlushRequest(const FlushRequest&);
-  FlushRequest& operator=(const FlushRequest&);
-  bool operator==(const FlushRequest&) const;
-  bool operator!=(const FlushRequest& other) const { return !(*this == other); }
+  EventName();
+  ~EventName() override;
+  EventName(EventName&&) noexcept;
+  EventName& operator=(EventName&&);
+  EventName(const EventName&);
+  EventName& operator=(const EventName&);
+  bool operator==(const EventName&) const;
+  bool operator!=(const EventName& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_timeout_ms() const { return _has_field_[1]; }
-  uint32_t timeout_ms() const { return timeout_ms_; }
-  void set_timeout_ms(uint32_t value) { timeout_ms_ = value; _has_field_.set(1); }
+  bool has_iid() const { return _has_field_[1]; }
+  uint64_t iid() const { return iid_; }
+  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
+
+  bool has_name() const { return _has_field_[2]; }
+  const std::string& name() const { return name_; }
+  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
 
  private:
-  uint32_t timeout_ms_{};
+  uint64_t iid_{};
+  std::string name_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<2> _has_field_{};
+  std::bitset<3> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT FreeBuffersResponse : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT EventCategory : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
+    kIidFieldNumber = 1,
+    kNameFieldNumber = 2,
   };
 
-  FreeBuffersResponse();
-  ~FreeBuffersResponse() override;
-  FreeBuffersResponse(FreeBuffersResponse&&) noexcept;
-  FreeBuffersResponse& operator=(FreeBuffersResponse&&);
-  FreeBuffersResponse(const FreeBuffersResponse&);
-  FreeBuffersResponse& operator=(const FreeBuffersResponse&);
-  bool operator==(const FreeBuffersResponse&) const;
-  bool operator!=(const FreeBuffersResponse& other) const { return !(*this == other); }
+  EventCategory();
+  ~EventCategory() override;
+  EventCategory(EventCategory&&) noexcept;
+  EventCategory& operator=(EventCategory&&);
+  EventCategory(const EventCategory&);
+  EventCategory& operator=(const EventCategory&);
+  bool operator==(const EventCategory&) const;
+  bool operator!=(const EventCategory& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
+  bool has_iid() const { return _has_field_[1]; }
+  uint64_t iid() const { return iid_; }
+  void set_iid(uint64_t value) { iid_ = value; _has_field_.set(1); }
+
+  bool has_name() const { return _has_field_[2]; }
+  const std::string& name() const { return name_; }
+  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
+
  private:
+  uint64_t iid_{};
+  std::string name_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<2> _has_field_{};
+  std::bitset<3> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT FreeBuffersRequest : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT TrackEventDefaults : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kBufferIdsFieldNumber = 1,
+    kTrackUuidFieldNumber = 11,
+    kExtraCounterTrackUuidsFieldNumber = 31,
+    kExtraDoubleCounterTrackUuidsFieldNumber = 45,
   };
 
-  FreeBuffersRequest();
-  ~FreeBuffersRequest() override;
-  FreeBuffersRequest(FreeBuffersRequest&&) noexcept;
-  FreeBuffersRequest& operator=(FreeBuffersRequest&&);
-  FreeBuffersRequest(const FreeBuffersRequest&);
-  FreeBuffersRequest& operator=(const FreeBuffersRequest&);
-  bool operator==(const FreeBuffersRequest&) const;
-  bool operator!=(const FreeBuffersRequest& other) const { return !(*this == other); }
+  TrackEventDefaults();
+  ~TrackEventDefaults() override;
+  TrackEventDefaults(TrackEventDefaults&&) noexcept;
+  TrackEventDefaults& operator=(TrackEventDefaults&&);
+  TrackEventDefaults(const TrackEventDefaults&);
+  TrackEventDefaults& operator=(const TrackEventDefaults&);
+  bool operator==(const TrackEventDefaults&) const;
+  bool operator!=(const TrackEventDefaults& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  const std::vector<uint32_t>& buffer_ids() const { return buffer_ids_; }
-  std::vector<uint32_t>* mutable_buffer_ids() { return &buffer_ids_; }
-  int buffer_ids_size() const { return static_cast<int>(buffer_ids_.size()); }
-  void clear_buffer_ids() { buffer_ids_.clear(); }
-  void add_buffer_ids(uint32_t value) { buffer_ids_.emplace_back(value); }
-  uint32_t* add_buffer_ids() { buffer_ids_.emplace_back(); return &buffer_ids_.back(); }
+  bool has_track_uuid() const { return _has_field_[11]; }
+  uint64_t track_uuid() const { return track_uuid_; }
+  void set_track_uuid(uint64_t value) { track_uuid_ = value; _has_field_.set(11); }
+
+  const std::vector<uint64_t>& extra_counter_track_uuids() const { return extra_counter_track_uuids_; }
+  std::vector<uint64_t>* mutable_extra_counter_track_uuids() { return &extra_counter_track_uuids_; }
+  int extra_counter_track_uuids_size() const { return static_cast<int>(extra_counter_track_uuids_.size()); }
+  void clear_extra_counter_track_uuids() { extra_counter_track_uuids_.clear(); }
+  void add_extra_counter_track_uuids(uint64_t value) { extra_counter_track_uuids_.emplace_back(value); }
+  uint64_t* add_extra_counter_track_uuids() { extra_counter_track_uuids_.emplace_back(); return &extra_counter_track_uuids_.back(); }
+
+  const std::vector<uint64_t>& extra_double_counter_track_uuids() const { return extra_double_counter_track_uuids_; }
+  std::vector<uint64_t>* mutable_extra_double_counter_track_uuids() { return &extra_double_counter_track_uuids_; }
+  int extra_double_counter_track_uuids_size() const { return static_cast<int>(extra_double_counter_track_uuids_.size()); }
+  void clear_extra_double_counter_track_uuids() { extra_double_counter_track_uuids_.clear(); }
+  void add_extra_double_counter_track_uuids(uint64_t value) { extra_double_counter_track_uuids_.emplace_back(value); }
+  uint64_t* add_extra_double_counter_track_uuids() { extra_double_counter_track_uuids_.emplace_back(); return &extra_double_counter_track_uuids_.back(); }
 
  private:
-  std::vector<uint32_t> buffer_ids_;
+  uint64_t track_uuid_{};
+  std::vector<uint64_t> extra_counter_track_uuids_;
+  std::vector<uint64_t> extra_double_counter_track_uuids_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<2> _has_field_{};
+  std::bitset<46> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT ReadBuffersResponse : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT TrackEvent : public ::protozero::CppMessageObj {
  public:
-  using Slice = ReadBuffersResponse_Slice;
+  using Callstack = TrackEvent_Callstack;
+  using LegacyEvent = TrackEvent_LegacyEvent;
+  using Type = TrackEvent_Type;
+  static constexpr auto TYPE_UNSPECIFIED = TrackEvent_Type_TYPE_UNSPECIFIED;
+  static constexpr auto TYPE_SLICE_BEGIN = TrackEvent_Type_TYPE_SLICE_BEGIN;
+  static constexpr auto TYPE_SLICE_END = TrackEvent_Type_TYPE_SLICE_END;
+  static constexpr auto TYPE_INSTANT = TrackEvent_Type_TYPE_INSTANT;
+  static constexpr auto TYPE_COUNTER = TrackEvent_Type_TYPE_COUNTER;
+  static constexpr auto Type_MIN = TrackEvent_Type_TYPE_UNSPECIFIED;
+  static constexpr auto Type_MAX = TrackEvent_Type_TYPE_COUNTER;
   enum FieldNumbers {
-    kSlicesFieldNumber = 2,
+    kCategoryIidsFieldNumber = 3,
+    kCategoriesFieldNumber = 22,
+    kNameIidFieldNumber = 10,
+    kNameFieldNumber = 23,
+    kTypeFieldNumber = 9,
+    kTrackUuidFieldNumber = 11,
+    kCounterValueFieldNumber = 30,
+    kDoubleCounterValueFieldNumber = 44,
+    kExtraCounterTrackUuidsFieldNumber = 31,
+    kExtraCounterValuesFieldNumber = 12,
+    kExtraDoubleCounterTrackUuidsFieldNumber = 45,
+    kExtraDoubleCounterValuesFieldNumber = 46,
+    kFlowIdsOldFieldNumber = 36,
+    kFlowIdsFieldNumber = 47,
+    kTerminatingFlowIdsOldFieldNumber = 42,
+    kTerminatingFlowIdsFieldNumber = 48,
+    kCorrelationIdFieldNumber = 52,
+    kCorrelationIdStrFieldNumber = 53,
+    kCorrelationIdStrIidFieldNumber = 54,
+    kCallstackFieldNumber = 55,
+    kCallstackIidFieldNumber = 56,
+    kDebugAnnotationsFieldNumber = 4,
+    kTaskExecutionFieldNumber = 5,
+    kLogMessageFieldNumber = 21,
+    kCcSchedulerStateFieldNumber = 24,
+    kChromeUserEventFieldNumber = 25,
+    kChromeKeyedServiceFieldNumber = 26,
+    kChromeLegacyIpcFieldNumber = 27,
+    kChromeHistogramSampleFieldNumber = 28,
+    kChromeLatencyInfoFieldNumber = 29,
+    kChromeFrameReporterFieldNumber = 32,
+    kChromeApplicationStateInfoFieldNumber = 39,
+    kChromeRendererSchedulerStateFieldNumber = 40,
+    kChromeWindowHandleEventInfoFieldNumber = 41,
+    kChromeContentSettingsEventInfoFieldNumber = 43,
+    kChromeActiveProcessesFieldNumber = 49,
+    kScreenshotFieldNumber = 50,
+    kSourceLocationFieldNumber = 33,
+    kSourceLocationIidFieldNumber = 34,
+    kChromeMessagePumpFieldNumber = 35,
+    kChromeMojoEventInfoFieldNumber = 38,
+    kTimestampDeltaUsFieldNumber = 1,
+    kTimestampAbsoluteUsFieldNumber = 16,
+    kThreadTimeDeltaUsFieldNumber = 2,
+    kThreadTimeAbsoluteUsFieldNumber = 17,
+    kThreadInstructionCountDeltaFieldNumber = 8,
+    kThreadInstructionCountAbsoluteFieldNumber = 20,
+    kLegacyEventFieldNumber = 6,
   };
 
-  ReadBuffersResponse();
-  ~ReadBuffersResponse() override;
-  ReadBuffersResponse(ReadBuffersResponse&&) noexcept;
-  ReadBuffersResponse& operator=(ReadBuffersResponse&&);
-  ReadBuffersResponse(const ReadBuffersResponse&);
-  ReadBuffersResponse& operator=(const ReadBuffersResponse&);
-  bool operator==(const ReadBuffersResponse&) const;
-  bool operator!=(const ReadBuffersResponse& other) const { return !(*this == other); }
+  TrackEvent();
+  ~TrackEvent() override;
+  TrackEvent(TrackEvent&&) noexcept;
+  TrackEvent& operator=(TrackEvent&&);
+  TrackEvent(const TrackEvent&);
+  TrackEvent& operator=(const TrackEvent&);
+  bool operator==(const TrackEvent&) const;
+  bool operator!=(const TrackEvent& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  const std::vector<ReadBuffersResponse_Slice>& slices() const { return slices_; }
-  std::vector<ReadBuffersResponse_Slice>* mutable_slices() { return &slices_; }
-  int slices_size() const;
-  void clear_slices();
-  ReadBuffersResponse_Slice* add_slices();
+  const std::vector<uint64_t>& category_iids() const { return category_iids_; }
+  std::vector<uint64_t>* mutable_category_iids() { return &category_iids_; }
+  int category_iids_size() const { return static_cast<int>(category_iids_.size()); }
+  void clear_category_iids() { category_iids_.clear(); }
+  void add_category_iids(uint64_t value) { category_iids_.emplace_back(value); }
+  uint64_t* add_category_iids() { category_iids_.emplace_back(); return &category_iids_.back(); }
 
- private:
-  std::vector<ReadBuffersResponse_Slice> slices_;
+  const std::vector<std::string>& categories() const { return categories_; }
+  std::vector<std::string>* mutable_categories() { return &categories_; }
+  int categories_size() const { return static_cast<int>(categories_.size()); }
+  void clear_categories() { categories_.clear(); }
+  void add_categories(std::string value) { categories_.emplace_back(value); }
+  std::string* add_categories() { categories_.emplace_back(); return &categories_.back(); }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  bool has_name_iid() const { return _has_field_[10]; }
+  uint64_t name_iid() const { return name_iid_; }
+  void set_name_iid(uint64_t value) { name_iid_ = value; _has_field_.set(10); }
 
-  std::bitset<3> _has_field_{};
-};
+  bool has_name() const { return _has_field_[23]; }
+  const std::string& name() const { return name_; }
+  void set_name(const std::string& value) { name_ = value; _has_field_.set(23); }
 
+  bool has_type() const { return _has_field_[9]; }
+  TrackEvent_Type type() const { return type_; }
+  void set_type(TrackEvent_Type value) { type_ = value; _has_field_.set(9); }
 
-class PERFETTO_EXPORT_COMPONENT ReadBuffersResponse_Slice : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kDataFieldNumber = 1,
-    kLastSliceForPacketFieldNumber = 2,
-  };
+  bool has_track_uuid() const { return _has_field_[11]; }
+  uint64_t track_uuid() const { return track_uuid_; }
+  void set_track_uuid(uint64_t value) { track_uuid_ = value; _has_field_.set(11); }
 
-  ReadBuffersResponse_Slice();
-  ~ReadBuffersResponse_Slice() override;
-  ReadBuffersResponse_Slice(ReadBuffersResponse_Slice&&) noexcept;
-  ReadBuffersResponse_Slice& operator=(ReadBuffersResponse_Slice&&);
-  ReadBuffersResponse_Slice(const ReadBuffersResponse_Slice&);
-  ReadBuffersResponse_Slice& operator=(const ReadBuffersResponse_Slice&);
-  bool operator==(const ReadBuffersResponse_Slice&) const;
-  bool operator!=(const ReadBuffersResponse_Slice& other) const { return !(*this == other); }
+  bool has_counter_value() const { return _has_field_[30]; }
+  int64_t counter_value() const { return counter_value_; }
+  void set_counter_value(int64_t value) { counter_value_ = value; _has_field_.set(30); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  bool has_double_counter_value() const { return _has_field_[44]; }
+  double double_counter_value() const { return double_counter_value_; }
+  void set_double_counter_value(double value) { double_counter_value_ = value; _has_field_.set(44); }
 
-  bool has_data() const { return _has_field_[1]; }
-  const std::string& data() const { return data_; }
-  void set_data(const std::string& value) { data_ = value; _has_field_.set(1); }
-  void set_data(const void* p, size_t s) { data_.assign(reinterpret_cast<const char*>(p), s); _has_field_.set(1); }
+  const std::vector<uint64_t>& extra_counter_track_uuids() const { return extra_counter_track_uuids_; }
+  std::vector<uint64_t>* mutable_extra_counter_track_uuids() { return &extra_counter_track_uuids_; }
+  int extra_counter_track_uuids_size() const { return static_cast<int>(extra_counter_track_uuids_.size()); }
+  void clear_extra_counter_track_uuids() { extra_counter_track_uuids_.clear(); }
+  void add_extra_counter_track_uuids(uint64_t value) { extra_counter_track_uuids_.emplace_back(value); }
+  uint64_t* add_extra_counter_track_uuids() { extra_counter_track_uuids_.emplace_back(); return &extra_counter_track_uuids_.back(); }
 
-  bool has_last_slice_for_packet() const { return _has_field_[2]; }
-  bool last_slice_for_packet() const { return last_slice_for_packet_; }
-  void set_last_slice_for_packet(bool value) { last_slice_for_packet_ = value; _has_field_.set(2); }
+  const std::vector<int64_t>& extra_counter_values() const { return extra_counter_values_; }
+  std::vector<int64_t>* mutable_extra_counter_values() { return &extra_counter_values_; }
+  int extra_counter_values_size() const { return static_cast<int>(extra_counter_values_.size()); }
+  void clear_extra_counter_values() { extra_counter_values_.clear(); }
+  void add_extra_counter_values(int64_t value) { extra_counter_values_.emplace_back(value); }
+  int64_t* add_extra_counter_values() { extra_counter_values_.emplace_back(); return &extra_counter_values_.back(); }
 
- private:
-  std::string data_{};
-  bool last_slice_for_packet_{};
+  const std::vector<uint64_t>& extra_double_counter_track_uuids() const { return extra_double_counter_track_uuids_; }
+  std::vector<uint64_t>* mutable_extra_double_counter_track_uuids() { return &extra_double_counter_track_uuids_; }
+  int extra_double_counter_track_uuids_size() const { return static_cast<int>(extra_double_counter_track_uuids_.size()); }
+  void clear_extra_double_counter_track_uuids() { extra_double_counter_track_uuids_.clear(); }
+  void add_extra_double_counter_track_uuids(uint64_t value) { extra_double_counter_track_uuids_.emplace_back(value); }
+  uint64_t* add_extra_double_counter_track_uuids() { extra_double_counter_track_uuids_.emplace_back(); return &extra_double_counter_track_uuids_.back(); }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  const std::vector<double>& extra_double_counter_values() const { return extra_double_counter_values_; }
+  std::vector<double>* mutable_extra_double_counter_values() { return &extra_double_counter_values_; }
+  int extra_double_counter_values_size() const { return static_cast<int>(extra_double_counter_values_.size()); }
+  void clear_extra_double_counter_values() { extra_double_counter_values_.clear(); }
+  void add_extra_double_counter_values(double value) { extra_double_counter_values_.emplace_back(value); }
+  double* add_extra_double_counter_values() { extra_double_counter_values_.emplace_back(); return &extra_double_counter_values_.back(); }
 
-  std::bitset<3> _has_field_{};
-};
+  const std::vector<uint64_t>& flow_ids_old() const { return flow_ids_old_; }
+  std::vector<uint64_t>* mutable_flow_ids_old() { return &flow_ids_old_; }
+  int flow_ids_old_size() const { return static_cast<int>(flow_ids_old_.size()); }
+  void clear_flow_ids_old() { flow_ids_old_.clear(); }
+  void add_flow_ids_old(uint64_t value) { flow_ids_old_.emplace_back(value); }
+  uint64_t* add_flow_ids_old() { flow_ids_old_.emplace_back(); return &flow_ids_old_.back(); }
 
+  const std::vector<uint64_t>& flow_ids() const { return flow_ids_; }
+  std::vector<uint64_t>* mutable_flow_ids() { return &flow_ids_; }
+  int flow_ids_size() const { return static_cast<int>(flow_ids_.size()); }
+  void clear_flow_ids() { flow_ids_.clear(); }
+  void add_flow_ids(uint64_t value) { flow_ids_.emplace_back(value); }
+  uint64_t* add_flow_ids() { flow_ids_.emplace_back(); return &flow_ids_.back(); }
 
-class PERFETTO_EXPORT_COMPONENT ReadBuffersRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
+  const std::vector<uint64_t>& terminating_flow_ids_old() const { return terminating_flow_ids_old_; }
+  std::vector<uint64_t>* mutable_terminating_flow_ids_old() { return &terminating_flow_ids_old_; }
+  int terminating_flow_ids_old_size() const { return static_cast<int>(terminating_flow_ids_old_.size()); }
+  void clear_terminating_flow_ids_old() { terminating_flow_ids_old_.clear(); }
+  void add_terminating_flow_ids_old(uint64_t value) { terminating_flow_ids_old_.emplace_back(value); }
+  uint64_t* add_terminating_flow_ids_old() { terminating_flow_ids_old_.emplace_back(); return &terminating_flow_ids_old_.back(); }
 
-  ReadBuffersRequest();
-  ~ReadBuffersRequest() override;
-  ReadBuffersRequest(ReadBuffersRequest&&) noexcept;
-  ReadBuffersRequest& operator=(ReadBuffersRequest&&);
-  ReadBuffersRequest(const ReadBuffersRequest&);
-  ReadBuffersRequest& operator=(const ReadBuffersRequest&);
-  bool operator==(const ReadBuffersRequest&) const;
-  bool operator!=(const ReadBuffersRequest& other) const { return !(*this == other); }
+  const std::vector<uint64_t>& terminating_flow_ids() const { return terminating_flow_ids_; }
+  std::vector<uint64_t>* mutable_terminating_flow_ids() { return &terminating_flow_ids_; }
+  int terminating_flow_ids_size() const { return static_cast<int>(terminating_flow_ids_.size()); }
+  void clear_terminating_flow_ids() { terminating_flow_ids_.clear(); }
+  void add_terminating_flow_ids(uint64_t value) { terminating_flow_ids_.emplace_back(value); }
+  uint64_t* add_terminating_flow_ids() { terminating_flow_ids_.emplace_back(); return &terminating_flow_ids_.back(); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  bool has_correlation_id() const { return _has_field_[52]; }
+  uint64_t correlation_id() const { return correlation_id_; }
+  void set_correlation_id(uint64_t value) { correlation_id_ = value; _has_field_.set(52); }
 
- private:
+  bool has_correlation_id_str() const { return _has_field_[53]; }
+  const std::string& correlation_id_str() const { return correlation_id_str_; }
+  void set_correlation_id_str(const std::string& value) { correlation_id_str_ = value; _has_field_.set(53); }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  bool has_correlation_id_str_iid() const { return _has_field_[54]; }
+  uint64_t correlation_id_str_iid() const { return correlation_id_str_iid_; }
+  void set_correlation_id_str_iid(uint64_t value) { correlation_id_str_iid_ = value; _has_field_.set(54); }
 
-  std::bitset<2> _has_field_{};
-};
+  bool has_callstack() const { return _has_field_[55]; }
+  const TrackEvent_Callstack& callstack() const { return *callstack_; }
+  TrackEvent_Callstack* mutable_callstack() { _has_field_.set(55); return callstack_.get(); }
+
+  bool has_callstack_iid() const { return _has_field_[56]; }
+  uint64_t callstack_iid() const { return callstack_iid_; }
+  void set_callstack_iid(uint64_t value) { callstack_iid_ = value; _has_field_.set(56); }
+
+  const std::vector<DebugAnnotation>& debug_annotations() const { return debug_annotations_; }
+  std::vector<DebugAnnotation>* mutable_debug_annotations() { return &debug_annotations_; }
+  int debug_annotations_size() const;
+  void clear_debug_annotations();
+  DebugAnnotation* add_debug_annotations();
+
+  bool has_task_execution() const { return _has_field_[5]; }
+  const TaskExecution& task_execution() const { return *task_execution_; }
+  TaskExecution* mutable_task_execution() { _has_field_.set(5); return task_execution_.get(); }
+
+  bool has_log_message() const { return _has_field_[21]; }
+  const LogMessage& log_message() const { return *log_message_; }
+  LogMessage* mutable_log_message() { _has_field_.set(21); return log_message_.get(); }
+
+  bool has_cc_scheduler_state() const { return _has_field_[24]; }
+  const ChromeCompositorSchedulerState& cc_scheduler_state() const { return *cc_scheduler_state_; }
+  ChromeCompositorSchedulerState* mutable_cc_scheduler_state() { _has_field_.set(24); return cc_scheduler_state_.get(); }
+
+  bool has_chrome_user_event() const { return _has_field_[25]; }
+  const ChromeUserEvent& chrome_user_event() const { return *chrome_user_event_; }
+  ChromeUserEvent* mutable_chrome_user_event() { _has_field_.set(25); return chrome_user_event_.get(); }
+
+  bool has_chrome_keyed_service() const { return _has_field_[26]; }
+  const ChromeKeyedService& chrome_keyed_service() const { return *chrome_keyed_service_; }
+  ChromeKeyedService* mutable_chrome_keyed_service() { _has_field_.set(26); return chrome_keyed_service_.get(); }
+
+  bool has_chrome_legacy_ipc() const { return _has_field_[27]; }
+  const ChromeLegacyIpc& chrome_legacy_ipc() const { return *chrome_legacy_ipc_; }
+  ChromeLegacyIpc* mutable_chrome_legacy_ipc() { _has_field_.set(27); return chrome_legacy_ipc_.get(); }
+
+  bool has_chrome_histogram_sample() const { return _has_field_[28]; }
+  const ChromeHistogramSample& chrome_histogram_sample() const { return *chrome_histogram_sample_; }
+  ChromeHistogramSample* mutable_chrome_histogram_sample() { _has_field_.set(28); return chrome_histogram_sample_.get(); }
+
+  bool has_chrome_latency_info() const { return _has_field_[29]; }
+  const ChromeLatencyInfo& chrome_latency_info() const { return *chrome_latency_info_; }
+  ChromeLatencyInfo* mutable_chrome_latency_info() { _has_field_.set(29); return chrome_latency_info_.get(); }
 
+  bool has_chrome_frame_reporter() const { return _has_field_[32]; }
+  const ChromeFrameReporter& chrome_frame_reporter() const { return *chrome_frame_reporter_; }
+  ChromeFrameReporter* mutable_chrome_frame_reporter() { _has_field_.set(32); return chrome_frame_reporter_.get(); }
 
-class PERFETTO_EXPORT_COMPONENT DisableTracingResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
+  bool has_chrome_application_state_info() const { return _has_field_[39]; }
+  const ChromeApplicationStateInfo& chrome_application_state_info() const { return *chrome_application_state_info_; }
+  ChromeApplicationStateInfo* mutable_chrome_application_state_info() { _has_field_.set(39); return chrome_application_state_info_.get(); }
 
-  DisableTracingResponse();
-  ~DisableTracingResponse() override;
-  DisableTracingResponse(DisableTracingResponse&&) noexcept;
-  DisableTracingResponse& operator=(DisableTracingResponse&&);
-  DisableTracingResponse(const DisableTracingResponse&);
-  DisableTracingResponse& operator=(const DisableTracingResponse&);
-  bool operator==(const DisableTracingResponse&) const;
-  bool operator!=(const DisableTracingResponse& other) const { return !(*this == other); }
+  bool has_chrome_renderer_scheduler_state() const { return _has_field_[40]; }
+  const ChromeRendererSchedulerState& chrome_renderer_scheduler_state() const { return *chrome_renderer_scheduler_state_; }
+  ChromeRendererSchedulerState* mutable_chrome_renderer_scheduler_state() { _has_field_.set(40); return chrome_renderer_scheduler_state_.get(); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  bool has_chrome_window_handle_event_info() const { return _has_field_[41]; }
+  const ChromeWindowHandleEventInfo& chrome_window_handle_event_info() const { return *chrome_window_handle_event_info_; }
+  ChromeWindowHandleEventInfo* mutable_chrome_window_handle_event_info() { _has_field_.set(41); return chrome_window_handle_event_info_.get(); }
 
- private:
+  bool has_chrome_content_settings_event_info() const { return _has_field_[43]; }
+  const ChromeContentSettingsEventInfo& chrome_content_settings_event_info() const { return *chrome_content_settings_event_info_; }
+  ChromeContentSettingsEventInfo* mutable_chrome_content_settings_event_info() { _has_field_.set(43); return chrome_content_settings_event_info_.get(); }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  bool has_chrome_active_processes() const { return _has_field_[49]; }
+  const ChromeActiveProcesses& chrome_active_processes() const { return *chrome_active_processes_; }
+  ChromeActiveProcesses* mutable_chrome_active_processes() { _has_field_.set(49); return chrome_active_processes_.get(); }
 
-  std::bitset<2> _has_field_{};
-};
+  bool has_screenshot() const { return _has_field_[50]; }
+  const Screenshot& screenshot() const { return *screenshot_; }
+  Screenshot* mutable_screenshot() { _has_field_.set(50); return screenshot_.get(); }
 
+  bool has_source_location() const { return _has_field_[33]; }
+  const SourceLocation& source_location() const { return *source_location_; }
+  SourceLocation* mutable_source_location() { _has_field_.set(33); return source_location_.get(); }
 
-class PERFETTO_EXPORT_COMPONENT DisableTracingRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
+  bool has_source_location_iid() const { return _has_field_[34]; }
+  uint64_t source_location_iid() const { return source_location_iid_; }
+  void set_source_location_iid(uint64_t value) { source_location_iid_ = value; _has_field_.set(34); }
 
-  DisableTracingRequest();
-  ~DisableTracingRequest() override;
-  DisableTracingRequest(DisableTracingRequest&&) noexcept;
-  DisableTracingRequest& operator=(DisableTracingRequest&&);
-  DisableTracingRequest(const DisableTracingRequest&);
-  DisableTracingRequest& operator=(const DisableTracingRequest&);
-  bool operator==(const DisableTracingRequest&) const;
-  bool operator!=(const DisableTracingRequest& other) const { return !(*this == other); }
+  bool has_chrome_message_pump() const { return _has_field_[35]; }
+  const ChromeMessagePump& chrome_message_pump() const { return *chrome_message_pump_; }
+  ChromeMessagePump* mutable_chrome_message_pump() { _has_field_.set(35); return chrome_message_pump_.get(); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  bool has_chrome_mojo_event_info() const { return _has_field_[38]; }
+  const ChromeMojoEventInfo& chrome_mojo_event_info() const { return *chrome_mojo_event_info_; }
+  ChromeMojoEventInfo* mutable_chrome_mojo_event_info() { _has_field_.set(38); return chrome_mojo_event_info_.get(); }
 
- private:
+  bool has_timestamp_delta_us() const { return _has_field_[1]; }
+  int64_t timestamp_delta_us() const { return timestamp_delta_us_; }
+  void set_timestamp_delta_us(int64_t value) { timestamp_delta_us_ = value; _has_field_.set(1); }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  bool has_timestamp_absolute_us() const { return _has_field_[16]; }
+  int64_t timestamp_absolute_us() const { return timestamp_absolute_us_; }
+  void set_timestamp_absolute_us(int64_t value) { timestamp_absolute_us_ = value; _has_field_.set(16); }
 
-  std::bitset<2> _has_field_{};
-};
+  bool has_thread_time_delta_us() const { return _has_field_[2]; }
+  int64_t thread_time_delta_us() const { return thread_time_delta_us_; }
+  void set_thread_time_delta_us(int64_t value) { thread_time_delta_us_ = value; _has_field_.set(2); }
 
+  bool has_thread_time_absolute_us() const { return _has_field_[17]; }
+  int64_t thread_time_absolute_us() const { return thread_time_absolute_us_; }
+  void set_thread_time_absolute_us(int64_t value) { thread_time_absolute_us_ = value; _has_field_.set(17); }
 
-class PERFETTO_EXPORT_COMPONENT ChangeTraceConfigResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
+  bool has_thread_instruction_count_delta() const { return _has_field_[8]; }
+  int64_t thread_instruction_count_delta() const { return thread_instruction_count_delta_; }
+  void set_thread_instruction_count_delta(int64_t value) { thread_instruction_count_delta_ = value; _has_field_.set(8); }
 
-  ChangeTraceConfigResponse();
-  ~ChangeTraceConfigResponse() override;
-  ChangeTraceConfigResponse(ChangeTraceConfigResponse&&) noexcept;
-  ChangeTraceConfigResponse& operator=(ChangeTraceConfigResponse&&);
-  ChangeTraceConfigResponse(const ChangeTraceConfigResponse&);
-  ChangeTraceConfigResponse& operator=(const ChangeTraceConfigResponse&);
-  bool operator==(const ChangeTraceConfigResponse&) const;
-  bool operator!=(const ChangeTraceConfigResponse& other) const { return !(*this == other); }
+  bool has_thread_instruction_count_absolute() const { return _has_field_[20]; }
+  int64_t thread_instruction_count_absolute() const { return thread_instruction_count_absolute_; }
+  void set_thread_instruction_count_absolute(int64_t value) { thread_instruction_count_absolute_ = value; _has_field_.set(20); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  bool has_legacy_event() const { return _has_field_[6]; }
+  const TrackEvent_LegacyEvent& legacy_event() const { return *legacy_event_; }
+  TrackEvent_LegacyEvent* mutable_legacy_event() { _has_field_.set(6); return legacy_event_.get(); }
 
  private:
+  std::vector<uint64_t> category_iids_;
+  std::vector<std::string> categories_;
+  uint64_t name_iid_{};
+  std::string name_{};
+  TrackEvent_Type type_{};
+  uint64_t track_uuid_{};
+  int64_t counter_value_{};
+  double double_counter_value_{};
+  std::vector<uint64_t> extra_counter_track_uuids_;
+  std::vector<int64_t> extra_counter_values_;
+  std::vector<uint64_t> extra_double_counter_track_uuids_;
+  std::vector<double> extra_double_counter_values_;
+  std::vector<uint64_t> flow_ids_old_;
+  std::vector<uint64_t> flow_ids_;
+  std::vector<uint64_t> terminating_flow_ids_old_;
+  std::vector<uint64_t> terminating_flow_ids_;
+  uint64_t correlation_id_{};
+  std::string correlation_id_str_{};
+  uint64_t correlation_id_str_iid_{};
+  ::protozero::CopyablePtr<TrackEvent_Callstack> callstack_;
+  uint64_t callstack_iid_{};
+  std::vector<DebugAnnotation> debug_annotations_;
+  ::protozero::CopyablePtr<TaskExecution> task_execution_;
+  ::protozero::CopyablePtr<LogMessage> log_message_;
+  ::protozero::CopyablePtr<ChromeCompositorSchedulerState> cc_scheduler_state_;
+  ::protozero::CopyablePtr<ChromeUserEvent> chrome_user_event_;
+  ::protozero::CopyablePtr<ChromeKeyedService> chrome_keyed_service_;
+  ::protozero::CopyablePtr<ChromeLegacyIpc> chrome_legacy_ipc_;
+  ::protozero::CopyablePtr<ChromeHistogramSample> chrome_histogram_sample_;
+  ::protozero::CopyablePtr<ChromeLatencyInfo> chrome_latency_info_;
+  ::protozero::CopyablePtr<ChromeFrameReporter> chrome_frame_reporter_;
+  ::protozero::CopyablePtr<ChromeApplicationStateInfo> chrome_application_state_info_;
+  ::protozero::CopyablePtr<ChromeRendererSchedulerState> chrome_renderer_scheduler_state_;
+  ::protozero::CopyablePtr<ChromeWindowHandleEventInfo> chrome_window_handle_event_info_;
+  ::protozero::CopyablePtr<ChromeContentSettingsEventInfo> chrome_content_settings_event_info_;
+  ::protozero::CopyablePtr<ChromeActiveProcesses> chrome_active_processes_;
+  ::protozero::CopyablePtr<Screenshot> screenshot_;
+  ::protozero::CopyablePtr<SourceLocation> source_location_;
+  uint64_t source_location_iid_{};
+  ::protozero::CopyablePtr<ChromeMessagePump> chrome_message_pump_;
+  ::protozero::CopyablePtr<ChromeMojoEventInfo> chrome_mojo_event_info_;
+  int64_t timestamp_delta_us_{};
+  int64_t timestamp_absolute_us_{};
+  int64_t thread_time_delta_us_{};
+  int64_t thread_time_absolute_us_{};
+  int64_t thread_instruction_count_delta_{};
+  int64_t thread_instruction_count_absolute_{};
+  ::protozero::CopyablePtr<TrackEvent_LegacyEvent> legacy_event_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<2> _has_field_{};
+  std::bitset<57> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT ChangeTraceConfigRequest : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT TrackEvent_LegacyEvent : public ::protozero::CppMessageObj {
  public:
+  using FlowDirection = TrackEvent_LegacyEvent_FlowDirection;
+  static constexpr auto FLOW_UNSPECIFIED = TrackEvent_LegacyEvent_FlowDirection_FLOW_UNSPECIFIED;
+  static constexpr auto FLOW_IN = TrackEvent_LegacyEvent_FlowDirection_FLOW_IN;
+  static constexpr auto FLOW_OUT = TrackEvent_LegacyEvent_FlowDirection_FLOW_OUT;
+  static constexpr auto FLOW_INOUT = TrackEvent_LegacyEvent_FlowDirection_FLOW_INOUT;
+  static constexpr auto FlowDirection_MIN = TrackEvent_LegacyEvent_FlowDirection_FLOW_UNSPECIFIED;
+  static constexpr auto FlowDirection_MAX = TrackEvent_LegacyEvent_FlowDirection_FLOW_INOUT;
+  using InstantEventScope = TrackEvent_LegacyEvent_InstantEventScope;
+  static constexpr auto SCOPE_UNSPECIFIED = TrackEvent_LegacyEvent_InstantEventScope_SCOPE_UNSPECIFIED;
+  static constexpr auto SCOPE_GLOBAL = TrackEvent_LegacyEvent_InstantEventScope_SCOPE_GLOBAL;
+  static constexpr auto SCOPE_PROCESS = TrackEvent_LegacyEvent_InstantEventScope_SCOPE_PROCESS;
+  static constexpr auto SCOPE_THREAD = TrackEvent_LegacyEvent_InstantEventScope_SCOPE_THREAD;
+  static constexpr auto InstantEventScope_MIN = TrackEvent_LegacyEvent_InstantEventScope_SCOPE_UNSPECIFIED;
+  static constexpr auto InstantEventScope_MAX = TrackEvent_LegacyEvent_InstantEventScope_SCOPE_THREAD;
   enum FieldNumbers {
-    kTraceConfigFieldNumber = 1,
+    kNameIidFieldNumber = 1,
+    kPhaseFieldNumber = 2,
+    kDurationUsFieldNumber = 3,
+    kThreadDurationUsFieldNumber = 4,
+    kThreadInstructionDeltaFieldNumber = 15,
+    kUnscopedIdFieldNumber = 6,
+    kLocalIdFieldNumber = 10,
+    kGlobalIdFieldNumber = 11,
+    kIdScopeFieldNumber = 7,
+    kUseAsyncTtsFieldNumber = 9,
+    kBindIdFieldNumber = 8,
+    kBindToEnclosingFieldNumber = 12,
+    kFlowDirectionFieldNumber = 13,
+    kInstantEventScopeFieldNumber = 14,
+    kPidOverrideFieldNumber = 18,
+    kTidOverrideFieldNumber = 19,
   };
 
-  ChangeTraceConfigRequest();
-  ~ChangeTraceConfigRequest() override;
-  ChangeTraceConfigRequest(ChangeTraceConfigRequest&&) noexcept;
-  ChangeTraceConfigRequest& operator=(ChangeTraceConfigRequest&&);
-  ChangeTraceConfigRequest(const ChangeTraceConfigRequest&);
-  ChangeTraceConfigRequest& operator=(const ChangeTraceConfigRequest&);
-  bool operator==(const ChangeTraceConfigRequest&) const;
-  bool operator!=(const ChangeTraceConfigRequest& other) const { return !(*this == other); }
+  TrackEvent_LegacyEvent();
+  ~TrackEvent_LegacyEvent() override;
+  TrackEvent_LegacyEvent(TrackEvent_LegacyEvent&&) noexcept;
+  TrackEvent_LegacyEvent& operator=(TrackEvent_LegacyEvent&&);
+  TrackEvent_LegacyEvent(const TrackEvent_LegacyEvent&);
+  TrackEvent_LegacyEvent& operator=(const TrackEvent_LegacyEvent&);
+  bool operator==(const TrackEvent_LegacyEvent&) const;
+  bool operator!=(const TrackEvent_LegacyEvent& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_trace_config() const { return _has_field_[1]; }
-  const TraceConfig& trace_config() const { return *trace_config_; }
-  TraceConfig* mutable_trace_config() { _has_field_.set(1); return trace_config_.get(); }
+  bool has_name_iid() const { return _has_field_[1]; }
+  uint64_t name_iid() const { return name_iid_; }
+  void set_name_iid(uint64_t value) { name_iid_ = value; _has_field_.set(1); }
 
- private:
-  ::protozero::CopyablePtr<TraceConfig> trace_config_;
+  bool has_phase() const { return _has_field_[2]; }
+  int32_t phase() const { return phase_; }
+  void set_phase(int32_t value) { phase_ = value; _has_field_.set(2); }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  bool has_duration_us() const { return _has_field_[3]; }
+  int64_t duration_us() const { return duration_us_; }
+  void set_duration_us(int64_t value) { duration_us_ = value; _has_field_.set(3); }
 
-  std::bitset<2> _has_field_{};
-};
+  bool has_thread_duration_us() const { return _has_field_[4]; }
+  int64_t thread_duration_us() const { return thread_duration_us_; }
+  void set_thread_duration_us(int64_t value) { thread_duration_us_ = value; _has_field_.set(4); }
 
+  bool has_thread_instruction_delta() const { return _has_field_[15]; }
+  int64_t thread_instruction_delta() const { return thread_instruction_delta_; }
+  void set_thread_instruction_delta(int64_t value) { thread_instruction_delta_ = value; _has_field_.set(15); }
 
-class PERFETTO_EXPORT_COMPONENT StartTracingResponse : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
+  bool has_unscoped_id() const { return _has_field_[6]; }
+  uint64_t unscoped_id() const { return unscoped_id_; }
+  void set_unscoped_id(uint64_t value) { unscoped_id_ = value; _has_field_.set(6); }
 
-  StartTracingResponse();
-  ~StartTracingResponse() override;
-  StartTracingResponse(StartTracingResponse&&) noexcept;
-  StartTracingResponse& operator=(StartTracingResponse&&);
-  StartTracingResponse(const StartTracingResponse&);
-  StartTracingResponse& operator=(const StartTracingResponse&);
-  bool operator==(const StartTracingResponse&) const;
-  bool operator!=(const StartTracingResponse& other) const { return !(*this == other); }
+  bool has_local_id() const { return _has_field_[10]; }
+  uint64_t local_id() const { return local_id_; }
+  void set_local_id(uint64_t value) { local_id_ = value; _has_field_.set(10); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  bool has_global_id() const { return _has_field_[11]; }
+  uint64_t global_id() const { return global_id_; }
+  void set_global_id(uint64_t value) { global_id_ = value; _has_field_.set(11); }
 
- private:
+  bool has_id_scope() const { return _has_field_[7]; }
+  const std::string& id_scope() const { return id_scope_; }
+  void set_id_scope(const std::string& value) { id_scope_ = value; _has_field_.set(7); }
 
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
+  bool has_use_async_tts() const { return _has_field_[9]; }
+  bool use_async_tts() const { return use_async_tts_; }
+  void set_use_async_tts(bool value) { use_async_tts_ = value; _has_field_.set(9); }
 
-  std::bitset<2> _has_field_{};
-};
+  bool has_bind_id() const { return _has_field_[8]; }
+  uint64_t bind_id() const { return bind_id_; }
+  void set_bind_id(uint64_t value) { bind_id_ = value; _has_field_.set(8); }
 
+  bool has_bind_to_enclosing() const { return _has_field_[12]; }
+  bool bind_to_enclosing() const { return bind_to_enclosing_; }
+  void set_bind_to_enclosing(bool value) { bind_to_enclosing_ = value; _has_field_.set(12); }
 
-class PERFETTO_EXPORT_COMPONENT StartTracingRequest : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-  };
+  bool has_flow_direction() const { return _has_field_[13]; }
+  TrackEvent_LegacyEvent_FlowDirection flow_direction() const { return flow_direction_; }
+  void set_flow_direction(TrackEvent_LegacyEvent_FlowDirection value) { flow_direction_ = value; _has_field_.set(13); }
 
-  StartTracingRequest();
-  ~StartTracingRequest() override;
-  StartTracingRequest(StartTracingRequest&&) noexcept;
-  StartTracingRequest& operator=(StartTracingRequest&&);
-  StartTracingRequest(const StartTracingRequest&);
-  StartTracingRequest& operator=(const StartTracingRequest&);
-  bool operator==(const StartTracingRequest&) const;
-  bool operator!=(const StartTracingRequest& other) const { return !(*this == other); }
+  bool has_instant_event_scope() const { return _has_field_[14]; }
+  TrackEvent_LegacyEvent_InstantEventScope instant_event_scope() const { return instant_event_scope_; }
+  void set_instant_event_scope(TrackEvent_LegacyEvent_InstantEventScope value) { instant_event_scope_ = value; _has_field_.set(14); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  bool has_pid_override() const { return _has_field_[18]; }
+  int32_t pid_override() const { return pid_override_; }
+  void set_pid_override(int32_t value) { pid_override_ = value; _has_field_.set(18); }
+
+  bool has_tid_override() const { return _has_field_[19]; }
+  int32_t tid_override() const { return tid_override_; }
+  void set_tid_override(int32_t value) { tid_override_ = value; _has_field_.set(19); }
 
  private:
+  uint64_t name_iid_{};
+  int32_t phase_{};
+  int64_t duration_us_{};
+  int64_t thread_duration_us_{};
+  int64_t thread_instruction_delta_{};
+  uint64_t unscoped_id_{};
+  uint64_t local_id_{};
+  uint64_t global_id_{};
+  std::string id_scope_{};
+  bool use_async_tts_{};
+  uint64_t bind_id_{};
+  bool bind_to_enclosing_{};
+  TrackEvent_LegacyEvent_FlowDirection flow_direction_{};
+  TrackEvent_LegacyEvent_InstantEventScope instant_event_scope_{};
+  int32_t pid_override_{};
+  int32_t tid_override_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<2> _has_field_{};
+  std::bitset<20> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT EnableTracingResponse : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT TrackEvent_Callstack : public ::protozero::CppMessageObj {
  public:
+  using Frame = TrackEvent_Callstack_Frame;
   enum FieldNumbers {
-    kDisabledFieldNumber = 1,
-    kErrorFieldNumber = 3,
+    kFramesFieldNumber = 1,
   };
 
-  EnableTracingResponse();
-  ~EnableTracingResponse() override;
-  EnableTracingResponse(EnableTracingResponse&&) noexcept;
-  EnableTracingResponse& operator=(EnableTracingResponse&&);
-  EnableTracingResponse(const EnableTracingResponse&);
-  EnableTracingResponse& operator=(const EnableTracingResponse&);
-  bool operator==(const EnableTracingResponse&) const;
-  bool operator!=(const EnableTracingResponse& other) const { return !(*this == other); }
+  TrackEvent_Callstack();
+  ~TrackEvent_Callstack() override;
+  TrackEvent_Callstack(TrackEvent_Callstack&&) noexcept;
+  TrackEvent_Callstack& operator=(TrackEvent_Callstack&&);
+  TrackEvent_Callstack(const TrackEvent_Callstack&);
+  TrackEvent_Callstack& operator=(const TrackEvent_Callstack&);
+  bool operator==(const TrackEvent_Callstack&) const;
+  bool operator!=(const TrackEvent_Callstack& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_disabled() const { return _has_field_[1]; }
-  bool disabled() const { return disabled_; }
-  void set_disabled(bool value) { disabled_ = value; _has_field_.set(1); }
-
-  bool has_error() const { return _has_field_[3]; }
-  const std::string& error() const { return error_; }
-  void set_error(const std::string& value) { error_ = value; _has_field_.set(3); }
+  const std::vector<TrackEvent_Callstack_Frame>& frames() const { return frames_; }
+  std::vector<TrackEvent_Callstack_Frame>* mutable_frames() { return &frames_; }
+  int frames_size() const;
+  void clear_frames();
+  TrackEvent_Callstack_Frame* add_frames();
 
  private:
-  bool disabled_{};
-  std::string error_{};
+  std::vector<TrackEvent_Callstack_Frame> frames_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<4> _has_field_{};
+  std::bitset<2> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT EnableTracingRequest : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT TrackEvent_Callstack_Frame : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kTraceConfigFieldNumber = 1,
-    kAttachNotificationOnlyFieldNumber = 2,
+    kFunctionNameFieldNumber = 1,
+    kSourceFileFieldNumber = 2,
+    kLineNumberFieldNumber = 3,
   };
 
-  EnableTracingRequest();
-  ~EnableTracingRequest() override;
-  EnableTracingRequest(EnableTracingRequest&&) noexcept;
-  EnableTracingRequest& operator=(EnableTracingRequest&&);
-  EnableTracingRequest(const EnableTracingRequest&);
-  EnableTracingRequest& operator=(const EnableTracingRequest&);
-  bool operator==(const EnableTracingRequest&) const;
-  bool operator!=(const EnableTracingRequest& other) const { return !(*this == other); }
+  TrackEvent_Callstack_Frame();
+  ~TrackEvent_Callstack_Frame() override;
+  TrackEvent_Callstack_Frame(TrackEvent_Callstack_Frame&&) noexcept;
+  TrackEvent_Callstack_Frame& operator=(TrackEvent_Callstack_Frame&&);
+  TrackEvent_Callstack_Frame(const TrackEvent_Callstack_Frame&);
+  TrackEvent_Callstack_Frame& operator=(const TrackEvent_Callstack_Frame&);
+  bool operator==(const TrackEvent_Callstack_Frame&) const;
+  bool operator!=(const TrackEvent_Callstack_Frame& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_trace_config() const { return _has_field_[1]; }
-  const TraceConfig& trace_config() const { return *trace_config_; }
-  TraceConfig* mutable_trace_config() { _has_field_.set(1); return trace_config_.get(); }
+  bool has_function_name() const { return _has_field_[1]; }
+  const std::string& function_name() const { return function_name_; }
+  void set_function_name(const std::string& value) { function_name_ = value; _has_field_.set(1); }
 
-  bool has_attach_notification_only() const { return _has_field_[2]; }
-  bool attach_notification_only() const { return attach_notification_only_; }
-  void set_attach_notification_only(bool value) { attach_notification_only_ = value; _has_field_.set(2); }
+  bool has_source_file() const { return _has_field_[2]; }
+  const std::string& source_file() const { return source_file_; }
+  void set_source_file(const std::string& value) { source_file_ = value; _has_field_.set(2); }
+
+  bool has_line_number() const { return _has_field_[3]; }
+  uint32_t line_number() const { return line_number_; }
+  void set_line_number(uint32_t value) { line_number_ = value; _has_field_.set(3); }
 
  private:
-  ::protozero::CopyablePtr<TraceConfig> trace_config_;
-  bool attach_notification_only_{};
+  std::string function_name_{};
+  std::string source_file_{};
+  uint32_t line_number_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<3> _has_field_{};
+  std::bitset<4> _has_field_{};
 };
 
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_CONSUMER_PORT_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/ipc/producer_port.gen.h
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACK_EVENT_TRACK_EVENT_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/ipc/consumer_port.gen.h
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_PRODUCER_PORT_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_PRODUCER_PORT_PROTO_CPP_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_CONSUMER_PORT_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_CONSUMER_PORT_PROTO_CPP_H_
 
 #include <stdint.h>
 #include <bitset>
@@ -172889,45 +193333,107 @@ class PERFETTO_EXPORT_COMPONENT EnableTracingRequest : public ::protozero::CppMe
 namespace perfetto {
 namespace protos {
 namespace gen {
-class SyncResponse;
-class SyncRequest;
-class GetAsyncCommandResponse;
-class GetAsyncCommandResponse_ClearIncrementalState;
-class GetAsyncCommandResponse_Flush;
-class GetAsyncCommandResponse_StopDataSource;
-class GetAsyncCommandResponse_StartDataSource;
+class CloneSessionResponse;
+class CloneSessionRequest;
+class SaveTraceForBugreportResponse;
+class SaveTraceForBugreportRequest;
+class QueryCapabilitiesResponse;
+class TracingServiceCapabilities;
+class QueryCapabilitiesRequest;
+class QueryServiceStateResponse;
+class TracingServiceState;
+class TracingServiceState_TracingSession;
+class TracingServiceState_DataSource;
+class DataSourceDescriptor;
+class VmProgram;
+class VmInstruction;
+class VmOpDel;
+class VmOpSet;
+class VmOpMerge;
+class VmOpRegLoad;
+class VmOpSelect;
+class VmOpSelect_PathComponent;
+class TracingServiceState_Producer;
+class QueryServiceStateRequest;
+class ObserveEventsResponse;
+class ObservableEvents;
+class ObservableEvents_CloneTriggerHit;
+class ObservableEvents_DataSourceInstanceStateChange;
+class ObserveEventsRequest;
+class GetTraceStatsResponse;
+class TraceStats;
+class TraceStats_FilterStats;
+class TraceStats_WriterStats;
+class TraceStats_BufferStats;
+class TraceStats_BufferStats_ShadowBufferStats;
+class GetTraceStatsRequest;
+class AttachResponse;
+class TraceConfig;
+class TraceConfig_Note;
+class PriorityBoostConfig;
+class TraceConfig_SessionSemaphore;
+class TraceConfig_CmdTraceStartDelay;
+class TraceConfig_AndroidReportConfig;
+class TraceConfig_TraceFilter;
+class TraceConfig_TraceFilter_StringFilterChain;
+class TraceConfig_TraceFilter_StringFilterRule;
+class TraceConfig_IncidentReportConfig;
+class TraceConfig_IncrementalStateConfig;
+class TraceConfig_TriggerConfig;
+class TraceConfig_TriggerConfig_Trigger;
+class TraceConfig_GuardrailOverrides;
+class TraceConfig_StatsdMetadata;
+class TraceConfig_ProducerConfig;
+class TraceConfig_BuiltinDataSource;
+class TraceConfig_DataSource;
 class DataSourceConfig;
 class TestConfig;
 class TestConfig_DummyFields;
 class InterceptorConfig;
+class ConsoleConfig;
 class ChromeConfig;
 class SystemInfoConfig;
-class GetAsyncCommandResponse_SetupDataSource;
-class GetAsyncCommandResponse_SetupTracing;
-class GetAsyncCommandRequest;
-class ActivateTriggersResponse;
-class ActivateTriggersRequest;
-class NotifyDataSourceStoppedResponse;
-class NotifyDataSourceStoppedRequest;
-class NotifyDataSourceStartedResponse;
-class NotifyDataSourceStartedRequest;
-class CommitDataResponse;
-class UnregisterTraceWriterResponse;
-class UnregisterTraceWriterRequest;
-class RegisterTraceWriterResponse;
-class RegisterTraceWriterRequest;
-class UnregisterDataSourceResponse;
-class UnregisterDataSourceRequest;
-class UpdateDataSourceResponse;
-class UpdateDataSourceRequest;
-class DataSourceDescriptor;
-class RegisterDataSourceResponse;
-class RegisterDataSourceRequest;
-class InitializeConnectionResponse;
-class InitializeConnectionRequest;
+class ProtoVmConfig;
+class TraceConfig_BufferConfig;
+class AttachRequest;
+class DetachResponse;
+class DetachRequest;
+class FlushResponse;
+class FlushRequest;
+class FreeBuffersResponse;
+class FreeBuffersRequest;
+class ReadBuffersResponse;
+class ReadBuffersResponse_Slice;
+class ReadBuffersRequest;
+class DisableTracingResponse;
+class DisableTracingRequest;
+class ChangeTraceConfigResponse;
+class ChangeTraceConfigRequest;
+class StartTracingResponse;
+class StartTracingRequest;
+class EnableTracingResponse;
+class EnableTracingRequest;
+enum ObservableEvents_Type : int;
+enum VmInstruction_AbortLevel : int;
+enum VmCursorEnum : int;
+enum ObservableEvents_DataSourceInstanceState : int;
+enum TraceStats_FinalFlushOutcome : int;
+enum TraceConfig_LockdownModeOperation : int;
+enum TraceConfig_CompressionType : int;
+enum TraceConfig_StatsdLogging : int;
+enum TraceConfig_WriteFlushMode : int;
+enum TraceConfig_FFlushMode : int;
+enum PriorityBoostConfig_BoostPolicy : int;
+enum TraceConfig_TraceFilter_StringFilterPolicy : int;
+enum SemanticType : int;
+enum TraceConfig_TriggerConfig_TriggerMode : int;
+enum BuiltinClock : int;
 enum DataSourceConfig_SessionInitiator : int;
+enum DataSourceConfig_BufferExhaustedPolicy : int;
+enum ConsoleConfig_Output : int;
 enum ChromeConfig_ClientPriority : int;
-enum InitializeConnectionRequest_ProducerSMBScrapingMode : int;
+enum TraceConfig_BufferConfig_FillPolicy : int;
+enum TraceConfig_BufferConfig_ExperimentalMode : int;
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
@@ -172939,170 +193445,245 @@ class Message;
 namespace perfetto {
 namespace protos {
 namespace gen {
-enum InitializeConnectionRequest_ProducerSMBScrapingMode : int {
-  InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_UNSPECIFIED = 0,
-  InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_ENABLED = 1,
-  InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_DISABLED = 2,
-};
 
-class PERFETTO_EXPORT_COMPONENT SyncResponse : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT CloneSessionResponse : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
+    kSuccessFieldNumber = 1,
+    kErrorFieldNumber = 2,
+    kUuidMsbFieldNumber = 3,
+    kUuidLsbFieldNumber = 4,
+    kWasWriteIntoFileFieldNumber = 5,
   };
 
-  SyncResponse();
-  ~SyncResponse() override;
-  SyncResponse(SyncResponse&&) noexcept;
-  SyncResponse& operator=(SyncResponse&&);
-  SyncResponse(const SyncResponse&);
-  SyncResponse& operator=(const SyncResponse&);
-  bool operator==(const SyncResponse&) const;
-  bool operator!=(const SyncResponse& other) const { return !(*this == other); }
+  CloneSessionResponse();
+  ~CloneSessionResponse() override;
+  CloneSessionResponse(CloneSessionResponse&&) noexcept;
+  CloneSessionResponse& operator=(CloneSessionResponse&&);
+  CloneSessionResponse(const CloneSessionResponse&);
+  CloneSessionResponse& operator=(const CloneSessionResponse&);
+  bool operator==(const CloneSessionResponse&) const;
+  bool operator!=(const CloneSessionResponse& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
+  bool has_success() const { return _has_field_[1]; }
+  bool success() const { return success_; }
+  void set_success(bool value) { success_ = value; _has_field_.set(1); }
+
+  bool has_error() const { return _has_field_[2]; }
+  const std::string& error() const { return error_; }
+  void set_error(const std::string& value) { error_ = value; _has_field_.set(2); }
+
+  bool has_uuid_msb() const { return _has_field_[3]; }
+  int64_t uuid_msb() const { return uuid_msb_; }
+  void set_uuid_msb(int64_t value) { uuid_msb_ = value; _has_field_.set(3); }
+
+  bool has_uuid_lsb() const { return _has_field_[4]; }
+  int64_t uuid_lsb() const { return uuid_lsb_; }
+  void set_uuid_lsb(int64_t value) { uuid_lsb_ = value; _has_field_.set(4); }
+
+  bool has_was_write_into_file() const { return _has_field_[5]; }
+  bool was_write_into_file() const { return was_write_into_file_; }
+  void set_was_write_into_file(bool value) { was_write_into_file_ = value; _has_field_.set(5); }
+
  private:
+  bool success_{};
+  std::string error_{};
+  int64_t uuid_msb_{};
+  int64_t uuid_lsb_{};
+  bool was_write_into_file_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<2> _has_field_{};
+  std::bitset<6> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT SyncRequest : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT CloneSessionRequest : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
+    kSessionIdFieldNumber = 1,
+    kUniqueSessionNameFieldNumber = 4,
+    kSkipTraceFilterFieldNumber = 2,
+    kForBugreportFieldNumber = 3,
+    kCloneTriggerNameFieldNumber = 5,
+    kCloneTriggerProducerNameFieldNumber = 6,
+    kCloneTriggerTrustedProducerUidFieldNumber = 7,
+    kCloneTriggerBootTimeNsFieldNumber = 8,
+    kCloneTriggerDelayMsFieldNumber = 9,
   };
 
-  SyncRequest();
-  ~SyncRequest() override;
-  SyncRequest(SyncRequest&&) noexcept;
-  SyncRequest& operator=(SyncRequest&&);
-  SyncRequest(const SyncRequest&);
-  SyncRequest& operator=(const SyncRequest&);
-  bool operator==(const SyncRequest&) const;
-  bool operator!=(const SyncRequest& other) const { return !(*this == other); }
+  CloneSessionRequest();
+  ~CloneSessionRequest() override;
+  CloneSessionRequest(CloneSessionRequest&&) noexcept;
+  CloneSessionRequest& operator=(CloneSessionRequest&&);
+  CloneSessionRequest(const CloneSessionRequest&);
+  CloneSessionRequest& operator=(const CloneSessionRequest&);
+  bool operator==(const CloneSessionRequest&) const;
+  bool operator!=(const CloneSessionRequest& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
+  bool has_session_id() const { return _has_field_[1]; }
+  uint64_t session_id() const { return session_id_; }
+  void set_session_id(uint64_t value) { session_id_ = value; _has_field_.set(1); }
+
+  bool has_unique_session_name() const { return _has_field_[4]; }
+  const std::string& unique_session_name() const { return unique_session_name_; }
+  void set_unique_session_name(const std::string& value) { unique_session_name_ = value; _has_field_.set(4); }
+
+  bool has_skip_trace_filter() const { return _has_field_[2]; }
+  bool skip_trace_filter() const { return skip_trace_filter_; }
+  void set_skip_trace_filter(bool value) { skip_trace_filter_ = value; _has_field_.set(2); }
+
+  bool has_for_bugreport() const { return _has_field_[3]; }
+  bool for_bugreport() const { return for_bugreport_; }
+  void set_for_bugreport(bool value) { for_bugreport_ = value; _has_field_.set(3); }
+
+  bool has_clone_trigger_name() const { return _has_field_[5]; }
+  const std::string& clone_trigger_name() const { return clone_trigger_name_; }
+  void set_clone_trigger_name(const std::string& value) { clone_trigger_name_ = value; _has_field_.set(5); }
+
+  bool has_clone_trigger_producer_name() const { return _has_field_[6]; }
+  const std::string& clone_trigger_producer_name() const { return clone_trigger_producer_name_; }
+  void set_clone_trigger_producer_name(const std::string& value) { clone_trigger_producer_name_ = value; _has_field_.set(6); }
+
+  bool has_clone_trigger_trusted_producer_uid() const { return _has_field_[7]; }
+  int32_t clone_trigger_trusted_producer_uid() const { return clone_trigger_trusted_producer_uid_; }
+  void set_clone_trigger_trusted_producer_uid(int32_t value) { clone_trigger_trusted_producer_uid_ = value; _has_field_.set(7); }
+
+  bool has_clone_trigger_boot_time_ns() const { return _has_field_[8]; }
+  uint64_t clone_trigger_boot_time_ns() const { return clone_trigger_boot_time_ns_; }
+  void set_clone_trigger_boot_time_ns(uint64_t value) { clone_trigger_boot_time_ns_ = value; _has_field_.set(8); }
+
+  bool has_clone_trigger_delay_ms() const { return _has_field_[9]; }
+  uint64_t clone_trigger_delay_ms() const { return clone_trigger_delay_ms_; }
+  void set_clone_trigger_delay_ms(uint64_t value) { clone_trigger_delay_ms_ = value; _has_field_.set(9); }
+
  private:
+  uint64_t session_id_{};
+  std::string unique_session_name_{};
+  bool skip_trace_filter_{};
+  bool for_bugreport_{};
+  std::string clone_trigger_name_{};
+  std::string clone_trigger_producer_name_{};
+  int32_t clone_trigger_trusted_producer_uid_{};
+  uint64_t clone_trigger_boot_time_ns_{};
+  uint64_t clone_trigger_delay_ms_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<2> _has_field_{};
+  std::bitset<10> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT GetAsyncCommandResponse : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT SaveTraceForBugreportResponse : public ::protozero::CppMessageObj {
  public:
-  using SetupDataSource = GetAsyncCommandResponse_SetupDataSource;
-  using StartDataSource = GetAsyncCommandResponse_StartDataSource;
-  using StopDataSource = GetAsyncCommandResponse_StopDataSource;
-  using SetupTracing = GetAsyncCommandResponse_SetupTracing;
-  using Flush = GetAsyncCommandResponse_Flush;
-  using ClearIncrementalState = GetAsyncCommandResponse_ClearIncrementalState;
   enum FieldNumbers {
-    kSetupTracingFieldNumber = 3,
-    kSetupDataSourceFieldNumber = 6,
-    kStartDataSourceFieldNumber = 1,
-    kStopDataSourceFieldNumber = 2,
-    kFlushFieldNumber = 5,
-    kClearIncrementalStateFieldNumber = 7,
+    kSuccessFieldNumber = 1,
+    kMsgFieldNumber = 2,
   };
 
-  GetAsyncCommandResponse();
-  ~GetAsyncCommandResponse() override;
-  GetAsyncCommandResponse(GetAsyncCommandResponse&&) noexcept;
-  GetAsyncCommandResponse& operator=(GetAsyncCommandResponse&&);
-  GetAsyncCommandResponse(const GetAsyncCommandResponse&);
-  GetAsyncCommandResponse& operator=(const GetAsyncCommandResponse&);
-  bool operator==(const GetAsyncCommandResponse&) const;
-  bool operator!=(const GetAsyncCommandResponse& other) const { return !(*this == other); }
+  SaveTraceForBugreportResponse();
+  ~SaveTraceForBugreportResponse() override;
+  SaveTraceForBugreportResponse(SaveTraceForBugreportResponse&&) noexcept;
+  SaveTraceForBugreportResponse& operator=(SaveTraceForBugreportResponse&&);
+  SaveTraceForBugreportResponse(const SaveTraceForBugreportResponse&);
+  SaveTraceForBugreportResponse& operator=(const SaveTraceForBugreportResponse&);
+  bool operator==(const SaveTraceForBugreportResponse&) const;
+  bool operator!=(const SaveTraceForBugreportResponse& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_setup_tracing() const { return _has_field_[3]; }
-  const GetAsyncCommandResponse_SetupTracing& setup_tracing() const { return *setup_tracing_; }
-  GetAsyncCommandResponse_SetupTracing* mutable_setup_tracing() { _has_field_.set(3); return setup_tracing_.get(); }
+  bool has_success() const { return _has_field_[1]; }
+  bool success() const { return success_; }
+  void set_success(bool value) { success_ = value; _has_field_.set(1); }
 
-  bool has_setup_data_source() const { return _has_field_[6]; }
-  const GetAsyncCommandResponse_SetupDataSource& setup_data_source() const { return *setup_data_source_; }
-  GetAsyncCommandResponse_SetupDataSource* mutable_setup_data_source() { _has_field_.set(6); return setup_data_source_.get(); }
+  bool has_msg() const { return _has_field_[2]; }
+  const std::string& msg() const { return msg_; }
+  void set_msg(const std::string& value) { msg_ = value; _has_field_.set(2); }
 
-  bool has_start_data_source() const { return _has_field_[1]; }
-  const GetAsyncCommandResponse_StartDataSource& start_data_source() const { return *start_data_source_; }
-  GetAsyncCommandResponse_StartDataSource* mutable_start_data_source() { _has_field_.set(1); return start_data_source_.get(); }
+ private:
+  bool success_{};
+  std::string msg_{};
 
-  bool has_stop_data_source() const { return _has_field_[2]; }
-  const GetAsyncCommandResponse_StopDataSource& stop_data_source() const { return *stop_data_source_; }
-  GetAsyncCommandResponse_StopDataSource* mutable_stop_data_source() { _has_field_.set(2); return stop_data_source_.get(); }
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  bool has_flush() const { return _has_field_[5]; }
-  const GetAsyncCommandResponse_Flush& flush() const { return *flush_; }
-  GetAsyncCommandResponse_Flush* mutable_flush() { _has_field_.set(5); return flush_.get(); }
+  std::bitset<3> _has_field_{};
+};
 
-  bool has_clear_incremental_state() const { return _has_field_[7]; }
-  const GetAsyncCommandResponse_ClearIncrementalState& clear_incremental_state() const { return *clear_incremental_state_; }
-  GetAsyncCommandResponse_ClearIncrementalState* mutable_clear_incremental_state() { _has_field_.set(7); return clear_incremental_state_.get(); }
+
+class PERFETTO_EXPORT_COMPONENT SaveTraceForBugreportRequest : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+  };
+
+  SaveTraceForBugreportRequest();
+  ~SaveTraceForBugreportRequest() override;
+  SaveTraceForBugreportRequest(SaveTraceForBugreportRequest&&) noexcept;
+  SaveTraceForBugreportRequest& operator=(SaveTraceForBugreportRequest&&);
+  SaveTraceForBugreportRequest(const SaveTraceForBugreportRequest&);
+  SaveTraceForBugreportRequest& operator=(const SaveTraceForBugreportRequest&);
+  bool operator==(const SaveTraceForBugreportRequest&) const;
+  bool operator!=(const SaveTraceForBugreportRequest& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
  private:
-  ::protozero::CopyablePtr<GetAsyncCommandResponse_SetupTracing> setup_tracing_;
-  ::protozero::CopyablePtr<GetAsyncCommandResponse_SetupDataSource> setup_data_source_;
-  ::protozero::CopyablePtr<GetAsyncCommandResponse_StartDataSource> start_data_source_;
-  ::protozero::CopyablePtr<GetAsyncCommandResponse_StopDataSource> stop_data_source_;
-  ::protozero::CopyablePtr<GetAsyncCommandResponse_Flush> flush_;
-  ::protozero::CopyablePtr<GetAsyncCommandResponse_ClearIncrementalState> clear_incremental_state_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<8> _has_field_{};
+  std::bitset<2> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT GetAsyncCommandResponse_ClearIncrementalState : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT QueryCapabilitiesResponse : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kDataSourceIdsFieldNumber = 1,
+    kCapabilitiesFieldNumber = 1,
   };
 
-  GetAsyncCommandResponse_ClearIncrementalState();
-  ~GetAsyncCommandResponse_ClearIncrementalState() override;
-  GetAsyncCommandResponse_ClearIncrementalState(GetAsyncCommandResponse_ClearIncrementalState&&) noexcept;
-  GetAsyncCommandResponse_ClearIncrementalState& operator=(GetAsyncCommandResponse_ClearIncrementalState&&);
-  GetAsyncCommandResponse_ClearIncrementalState(const GetAsyncCommandResponse_ClearIncrementalState&);
-  GetAsyncCommandResponse_ClearIncrementalState& operator=(const GetAsyncCommandResponse_ClearIncrementalState&);
-  bool operator==(const GetAsyncCommandResponse_ClearIncrementalState&) const;
-  bool operator!=(const GetAsyncCommandResponse_ClearIncrementalState& other) const { return !(*this == other); }
+  QueryCapabilitiesResponse();
+  ~QueryCapabilitiesResponse() override;
+  QueryCapabilitiesResponse(QueryCapabilitiesResponse&&) noexcept;
+  QueryCapabilitiesResponse& operator=(QueryCapabilitiesResponse&&);
+  QueryCapabilitiesResponse(const QueryCapabilitiesResponse&);
+  QueryCapabilitiesResponse& operator=(const QueryCapabilitiesResponse&);
+  bool operator==(const QueryCapabilitiesResponse&) const;
+  bool operator!=(const QueryCapabilitiesResponse& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  const std::vector<uint64_t>& data_source_ids() const { return data_source_ids_; }
-  std::vector<uint64_t>* mutable_data_source_ids() { return &data_source_ids_; }
-  int data_source_ids_size() const { return static_cast<int>(data_source_ids_.size()); }
-  void clear_data_source_ids() { data_source_ids_.clear(); }
-  void add_data_source_ids(uint64_t value) { data_source_ids_.emplace_back(value); }
-  uint64_t* add_data_source_ids() { data_source_ids_.emplace_back(); return &data_source_ids_.back(); }
+  bool has_capabilities() const { return _has_field_[1]; }
+  const TracingServiceCapabilities& capabilities() const { return *capabilities_; }
+  TracingServiceCapabilities* mutable_capabilities() { _has_field_.set(1); return capabilities_.get(); }
 
  private:
-  std::vector<uint64_t> data_source_ids_;
+  ::protozero::CopyablePtr<TracingServiceCapabilities> capabilities_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
@@ -173112,76 +193693,96 @@ class PERFETTO_EXPORT_COMPONENT GetAsyncCommandResponse_ClearIncrementalState :
 };
 
 
-class PERFETTO_EXPORT_COMPONENT GetAsyncCommandResponse_Flush : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT QueryCapabilitiesRequest : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kDataSourceIdsFieldNumber = 1,
-    kRequestIdFieldNumber = 2,
   };
 
-  GetAsyncCommandResponse_Flush();
-  ~GetAsyncCommandResponse_Flush() override;
-  GetAsyncCommandResponse_Flush(GetAsyncCommandResponse_Flush&&) noexcept;
-  GetAsyncCommandResponse_Flush& operator=(GetAsyncCommandResponse_Flush&&);
-  GetAsyncCommandResponse_Flush(const GetAsyncCommandResponse_Flush&);
-  GetAsyncCommandResponse_Flush& operator=(const GetAsyncCommandResponse_Flush&);
-  bool operator==(const GetAsyncCommandResponse_Flush&) const;
-  bool operator!=(const GetAsyncCommandResponse_Flush& other) const { return !(*this == other); }
+  QueryCapabilitiesRequest();
+  ~QueryCapabilitiesRequest() override;
+  QueryCapabilitiesRequest(QueryCapabilitiesRequest&&) noexcept;
+  QueryCapabilitiesRequest& operator=(QueryCapabilitiesRequest&&);
+  QueryCapabilitiesRequest(const QueryCapabilitiesRequest&);
+  QueryCapabilitiesRequest& operator=(const QueryCapabilitiesRequest&);
+  bool operator==(const QueryCapabilitiesRequest&) const;
+  bool operator!=(const QueryCapabilitiesRequest& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  const std::vector<uint64_t>& data_source_ids() const { return data_source_ids_; }
-  std::vector<uint64_t>* mutable_data_source_ids() { return &data_source_ids_; }
-  int data_source_ids_size() const { return static_cast<int>(data_source_ids_.size()); }
-  void clear_data_source_ids() { data_source_ids_.clear(); }
-  void add_data_source_ids(uint64_t value) { data_source_ids_.emplace_back(value); }
-  uint64_t* add_data_source_ids() { data_source_ids_.emplace_back(); return &data_source_ids_.back(); }
+ private:
 
-  bool has_request_id() const { return _has_field_[2]; }
-  uint64_t request_id() const { return request_id_; }
-  void set_request_id(uint64_t value) { request_id_ = value; _has_field_.set(2); }
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<2> _has_field_{};
+};
+
+
+class PERFETTO_EXPORT_COMPONENT QueryServiceStateResponse : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kServiceStateFieldNumber = 1,
+  };
+
+  QueryServiceStateResponse();
+  ~QueryServiceStateResponse() override;
+  QueryServiceStateResponse(QueryServiceStateResponse&&) noexcept;
+  QueryServiceStateResponse& operator=(QueryServiceStateResponse&&);
+  QueryServiceStateResponse(const QueryServiceStateResponse&);
+  QueryServiceStateResponse& operator=(const QueryServiceStateResponse&);
+  bool operator==(const QueryServiceStateResponse&) const;
+  bool operator!=(const QueryServiceStateResponse& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_service_state() const { return _has_field_[1]; }
+  const TracingServiceState& service_state() const { return *service_state_; }
+  TracingServiceState* mutable_service_state() { _has_field_.set(1); return service_state_.get(); }
 
  private:
-  std::vector<uint64_t> data_source_ids_;
-  uint64_t request_id_{};
+  ::protozero::CopyablePtr<TracingServiceState> service_state_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<3> _has_field_{};
+  std::bitset<2> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT GetAsyncCommandResponse_StopDataSource : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT QueryServiceStateRequest : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kInstanceIdFieldNumber = 1,
+    kSessionsOnlyFieldNumber = 1,
   };
 
-  GetAsyncCommandResponse_StopDataSource();
-  ~GetAsyncCommandResponse_StopDataSource() override;
-  GetAsyncCommandResponse_StopDataSource(GetAsyncCommandResponse_StopDataSource&&) noexcept;
-  GetAsyncCommandResponse_StopDataSource& operator=(GetAsyncCommandResponse_StopDataSource&&);
-  GetAsyncCommandResponse_StopDataSource(const GetAsyncCommandResponse_StopDataSource&);
-  GetAsyncCommandResponse_StopDataSource& operator=(const GetAsyncCommandResponse_StopDataSource&);
-  bool operator==(const GetAsyncCommandResponse_StopDataSource&) const;
-  bool operator!=(const GetAsyncCommandResponse_StopDataSource& other) const { return !(*this == other); }
+  QueryServiceStateRequest();
+  ~QueryServiceStateRequest() override;
+  QueryServiceStateRequest(QueryServiceStateRequest&&) noexcept;
+  QueryServiceStateRequest& operator=(QueryServiceStateRequest&&);
+  QueryServiceStateRequest(const QueryServiceStateRequest&);
+  QueryServiceStateRequest& operator=(const QueryServiceStateRequest&);
+  bool operator==(const QueryServiceStateRequest&) const;
+  bool operator!=(const QueryServiceStateRequest& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_instance_id() const { return _has_field_[1]; }
-  uint64_t instance_id() const { return instance_id_; }
-  void set_instance_id(uint64_t value) { instance_id_ = value; _has_field_.set(1); }
+  bool has_sessions_only() const { return _has_field_[1]; }
+  bool sessions_only() const { return sessions_only_; }
+  void set_sessions_only(bool value) { sessions_only_ = value; _has_field_.set(1); }
 
  private:
-  uint64_t instance_id_{};
+  bool sessions_only_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
@@ -173191,142 +193792,127 @@ class PERFETTO_EXPORT_COMPONENT GetAsyncCommandResponse_StopDataSource : public
 };
 
 
-class PERFETTO_EXPORT_COMPONENT GetAsyncCommandResponse_StartDataSource : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT ObserveEventsResponse : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kNewInstanceIdFieldNumber = 1,
-    kConfigFieldNumber = 2,
+    kEventsFieldNumber = 1,
   };
 
-  GetAsyncCommandResponse_StartDataSource();
-  ~GetAsyncCommandResponse_StartDataSource() override;
-  GetAsyncCommandResponse_StartDataSource(GetAsyncCommandResponse_StartDataSource&&) noexcept;
-  GetAsyncCommandResponse_StartDataSource& operator=(GetAsyncCommandResponse_StartDataSource&&);
-  GetAsyncCommandResponse_StartDataSource(const GetAsyncCommandResponse_StartDataSource&);
-  GetAsyncCommandResponse_StartDataSource& operator=(const GetAsyncCommandResponse_StartDataSource&);
-  bool operator==(const GetAsyncCommandResponse_StartDataSource&) const;
-  bool operator!=(const GetAsyncCommandResponse_StartDataSource& other) const { return !(*this == other); }
+  ObserveEventsResponse();
+  ~ObserveEventsResponse() override;
+  ObserveEventsResponse(ObserveEventsResponse&&) noexcept;
+  ObserveEventsResponse& operator=(ObserveEventsResponse&&);
+  ObserveEventsResponse(const ObserveEventsResponse&);
+  ObserveEventsResponse& operator=(const ObserveEventsResponse&);
+  bool operator==(const ObserveEventsResponse&) const;
+  bool operator!=(const ObserveEventsResponse& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_new_instance_id() const { return _has_field_[1]; }
-  uint64_t new_instance_id() const { return new_instance_id_; }
-  void set_new_instance_id(uint64_t value) { new_instance_id_ = value; _has_field_.set(1); }
-
-  bool has_config() const { return _has_field_[2]; }
-  const DataSourceConfig& config() const { return *config_; }
-  DataSourceConfig* mutable_config() { _has_field_.set(2); return config_.get(); }
+  bool has_events() const { return _has_field_[1]; }
+  const ObservableEvents& events() const { return *events_; }
+  ObservableEvents* mutable_events() { _has_field_.set(1); return events_.get(); }
 
  private:
-  uint64_t new_instance_id_{};
-  ::protozero::CopyablePtr<DataSourceConfig> config_;
+  ::protozero::CopyablePtr<ObservableEvents> events_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<3> _has_field_{};
+  std::bitset<2> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT GetAsyncCommandResponse_SetupDataSource : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT ObserveEventsRequest : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kNewInstanceIdFieldNumber = 1,
-    kConfigFieldNumber = 2,
+    kEventsToObserveFieldNumber = 1,
   };
 
-  GetAsyncCommandResponse_SetupDataSource();
-  ~GetAsyncCommandResponse_SetupDataSource() override;
-  GetAsyncCommandResponse_SetupDataSource(GetAsyncCommandResponse_SetupDataSource&&) noexcept;
-  GetAsyncCommandResponse_SetupDataSource& operator=(GetAsyncCommandResponse_SetupDataSource&&);
-  GetAsyncCommandResponse_SetupDataSource(const GetAsyncCommandResponse_SetupDataSource&);
-  GetAsyncCommandResponse_SetupDataSource& operator=(const GetAsyncCommandResponse_SetupDataSource&);
-  bool operator==(const GetAsyncCommandResponse_SetupDataSource&) const;
-  bool operator!=(const GetAsyncCommandResponse_SetupDataSource& other) const { return !(*this == other); }
+  ObserveEventsRequest();
+  ~ObserveEventsRequest() override;
+  ObserveEventsRequest(ObserveEventsRequest&&) noexcept;
+  ObserveEventsRequest& operator=(ObserveEventsRequest&&);
+  ObserveEventsRequest(const ObserveEventsRequest&);
+  ObserveEventsRequest& operator=(const ObserveEventsRequest&);
+  bool operator==(const ObserveEventsRequest&) const;
+  bool operator!=(const ObserveEventsRequest& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_new_instance_id() const { return _has_field_[1]; }
-  uint64_t new_instance_id() const { return new_instance_id_; }
-  void set_new_instance_id(uint64_t value) { new_instance_id_ = value; _has_field_.set(1); }
-
-  bool has_config() const { return _has_field_[2]; }
-  const DataSourceConfig& config() const { return *config_; }
-  DataSourceConfig* mutable_config() { _has_field_.set(2); return config_.get(); }
+  const std::vector<ObservableEvents_Type>& events_to_observe() const { return events_to_observe_; }
+  std::vector<ObservableEvents_Type>* mutable_events_to_observe() { return &events_to_observe_; }
+  int events_to_observe_size() const { return static_cast<int>(events_to_observe_.size()); }
+  void clear_events_to_observe() { events_to_observe_.clear(); }
+  void add_events_to_observe(ObservableEvents_Type value) { events_to_observe_.emplace_back(value); }
+  ObservableEvents_Type* add_events_to_observe() { events_to_observe_.emplace_back(); return &events_to_observe_.back(); }
 
  private:
-  uint64_t new_instance_id_{};
-  ::protozero::CopyablePtr<DataSourceConfig> config_;
+  std::vector<ObservableEvents_Type> events_to_observe_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<3> _has_field_{};
+  std::bitset<2> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT GetAsyncCommandResponse_SetupTracing : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT GetTraceStatsResponse : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kSharedBufferPageSizeKbFieldNumber = 1,
-    kShmKeyWindowsFieldNumber = 2,
+    kTraceStatsFieldNumber = 1,
   };
 
-  GetAsyncCommandResponse_SetupTracing();
-  ~GetAsyncCommandResponse_SetupTracing() override;
-  GetAsyncCommandResponse_SetupTracing(GetAsyncCommandResponse_SetupTracing&&) noexcept;
-  GetAsyncCommandResponse_SetupTracing& operator=(GetAsyncCommandResponse_SetupTracing&&);
-  GetAsyncCommandResponse_SetupTracing(const GetAsyncCommandResponse_SetupTracing&);
-  GetAsyncCommandResponse_SetupTracing& operator=(const GetAsyncCommandResponse_SetupTracing&);
-  bool operator==(const GetAsyncCommandResponse_SetupTracing&) const;
-  bool operator!=(const GetAsyncCommandResponse_SetupTracing& other) const { return !(*this == other); }
+  GetTraceStatsResponse();
+  ~GetTraceStatsResponse() override;
+  GetTraceStatsResponse(GetTraceStatsResponse&&) noexcept;
+  GetTraceStatsResponse& operator=(GetTraceStatsResponse&&);
+  GetTraceStatsResponse(const GetTraceStatsResponse&);
+  GetTraceStatsResponse& operator=(const GetTraceStatsResponse&);
+  bool operator==(const GetTraceStatsResponse&) const;
+  bool operator!=(const GetTraceStatsResponse& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_shared_buffer_page_size_kb() const { return _has_field_[1]; }
-  uint32_t shared_buffer_page_size_kb() const { return shared_buffer_page_size_kb_; }
-  void set_shared_buffer_page_size_kb(uint32_t value) { shared_buffer_page_size_kb_ = value; _has_field_.set(1); }
-
-  bool has_shm_key_windows() const { return _has_field_[2]; }
-  const std::string& shm_key_windows() const { return shm_key_windows_; }
-  void set_shm_key_windows(const std::string& value) { shm_key_windows_ = value; _has_field_.set(2); }
+  bool has_trace_stats() const { return _has_field_[1]; }
+  const TraceStats& trace_stats() const { return *trace_stats_; }
+  TraceStats* mutable_trace_stats() { _has_field_.set(1); return trace_stats_.get(); }
 
  private:
-  uint32_t shared_buffer_page_size_kb_{};
-  std::string shm_key_windows_{};
+  ::protozero::CopyablePtr<TraceStats> trace_stats_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<3> _has_field_{};
+  std::bitset<2> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT GetAsyncCommandRequest : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT GetTraceStatsRequest : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
   };
 
-  GetAsyncCommandRequest();
-  ~GetAsyncCommandRequest() override;
-  GetAsyncCommandRequest(GetAsyncCommandRequest&&) noexcept;
-  GetAsyncCommandRequest& operator=(GetAsyncCommandRequest&&);
-  GetAsyncCommandRequest(const GetAsyncCommandRequest&);
-  GetAsyncCommandRequest& operator=(const GetAsyncCommandRequest&);
-  bool operator==(const GetAsyncCommandRequest&) const;
-  bool operator!=(const GetAsyncCommandRequest& other) const { return !(*this == other); }
+  GetTraceStatsRequest();
+  ~GetTraceStatsRequest() override;
+  GetTraceStatsRequest(GetTraceStatsRequest&&) noexcept;
+  GetTraceStatsRequest& operator=(GetTraceStatsRequest&&);
+  GetTraceStatsRequest(const GetTraceStatsRequest&);
+  GetTraceStatsRequest& operator=(const GetTraceStatsRequest&);
+  bool operator==(const GetTraceStatsRequest&) const;
+  bool operator!=(const GetTraceStatsRequest& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
@@ -173343,26 +193929,32 @@ class PERFETTO_EXPORT_COMPONENT GetAsyncCommandRequest : public ::protozero::Cpp
 };
 
 
-class PERFETTO_EXPORT_COMPONENT ActivateTriggersResponse : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT AttachResponse : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
+    kTraceConfigFieldNumber = 1,
   };
 
-  ActivateTriggersResponse();
-  ~ActivateTriggersResponse() override;
-  ActivateTriggersResponse(ActivateTriggersResponse&&) noexcept;
-  ActivateTriggersResponse& operator=(ActivateTriggersResponse&&);
-  ActivateTriggersResponse(const ActivateTriggersResponse&);
-  ActivateTriggersResponse& operator=(const ActivateTriggersResponse&);
-  bool operator==(const ActivateTriggersResponse&) const;
-  bool operator!=(const ActivateTriggersResponse& other) const { return !(*this == other); }
+  AttachResponse();
+  ~AttachResponse() override;
+  AttachResponse(AttachResponse&&) noexcept;
+  AttachResponse& operator=(AttachResponse&&);
+  AttachResponse(const AttachResponse&);
+  AttachResponse& operator=(const AttachResponse&);
+  bool operator==(const AttachResponse&) const;
+  bool operator!=(const AttachResponse& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
+  bool has_trace_config() const { return _has_field_[1]; }
+  const TraceConfig& trace_config() const { return *trace_config_; }
+  TraceConfig* mutable_trace_config() { _has_field_.set(1); return trace_config_.get(); }
+
  private:
+  ::protozero::CopyablePtr<TraceConfig> trace_config_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
@@ -173372,35 +193964,32 @@ class PERFETTO_EXPORT_COMPONENT ActivateTriggersResponse : public ::protozero::C
 };
 
 
-class PERFETTO_EXPORT_COMPONENT ActivateTriggersRequest : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT AttachRequest : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kTriggerNamesFieldNumber = 1,
+    kKeyFieldNumber = 1,
   };
 
-  ActivateTriggersRequest();
-  ~ActivateTriggersRequest() override;
-  ActivateTriggersRequest(ActivateTriggersRequest&&) noexcept;
-  ActivateTriggersRequest& operator=(ActivateTriggersRequest&&);
-  ActivateTriggersRequest(const ActivateTriggersRequest&);
-  ActivateTriggersRequest& operator=(const ActivateTriggersRequest&);
-  bool operator==(const ActivateTriggersRequest&) const;
-  bool operator!=(const ActivateTriggersRequest& other) const { return !(*this == other); }
+  AttachRequest();
+  ~AttachRequest() override;
+  AttachRequest(AttachRequest&&) noexcept;
+  AttachRequest& operator=(AttachRequest&&);
+  AttachRequest(const AttachRequest&);
+  AttachRequest& operator=(const AttachRequest&);
+  bool operator==(const AttachRequest&) const;
+  bool operator!=(const AttachRequest& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  const std::vector<std::string>& trigger_names() const { return trigger_names_; }
-  std::vector<std::string>* mutable_trigger_names() { return &trigger_names_; }
-  int trigger_names_size() const { return static_cast<int>(trigger_names_.size()); }
-  void clear_trigger_names() { trigger_names_.clear(); }
-  void add_trigger_names(std::string value) { trigger_names_.emplace_back(value); }
-  std::string* add_trigger_names() { trigger_names_.emplace_back(); return &trigger_names_.back(); }
+  bool has_key() const { return _has_field_[1]; }
+  const std::string& key() const { return key_; }
+  void set_key(const std::string& value) { key_ = value; _has_field_.set(1); }
 
  private:
-  std::vector<std::string> trigger_names_;
+  std::string key_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
@@ -173410,19 +193999,19 @@ class PERFETTO_EXPORT_COMPONENT ActivateTriggersRequest : public ::protozero::Cp
 };
 
 
-class PERFETTO_EXPORT_COMPONENT NotifyDataSourceStoppedResponse : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT DetachResponse : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
   };
 
-  NotifyDataSourceStoppedResponse();
-  ~NotifyDataSourceStoppedResponse() override;
-  NotifyDataSourceStoppedResponse(NotifyDataSourceStoppedResponse&&) noexcept;
-  NotifyDataSourceStoppedResponse& operator=(NotifyDataSourceStoppedResponse&&);
-  NotifyDataSourceStoppedResponse(const NotifyDataSourceStoppedResponse&);
-  NotifyDataSourceStoppedResponse& operator=(const NotifyDataSourceStoppedResponse&);
-  bool operator==(const NotifyDataSourceStoppedResponse&) const;
-  bool operator!=(const NotifyDataSourceStoppedResponse& other) const { return !(*this == other); }
+  DetachResponse();
+  ~DetachResponse() override;
+  DetachResponse(DetachResponse&&) noexcept;
+  DetachResponse& operator=(DetachResponse&&);
+  DetachResponse(const DetachResponse&);
+  DetachResponse& operator=(const DetachResponse&);
+  bool operator==(const DetachResponse&) const;
+  bool operator!=(const DetachResponse& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
@@ -173439,32 +194028,32 @@ class PERFETTO_EXPORT_COMPONENT NotifyDataSourceStoppedResponse : public ::proto
 };
 
 
-class PERFETTO_EXPORT_COMPONENT NotifyDataSourceStoppedRequest : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT DetachRequest : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kDataSourceIdFieldNumber = 1,
+    kKeyFieldNumber = 1,
   };
 
-  NotifyDataSourceStoppedRequest();
-  ~NotifyDataSourceStoppedRequest() override;
-  NotifyDataSourceStoppedRequest(NotifyDataSourceStoppedRequest&&) noexcept;
-  NotifyDataSourceStoppedRequest& operator=(NotifyDataSourceStoppedRequest&&);
-  NotifyDataSourceStoppedRequest(const NotifyDataSourceStoppedRequest&);
-  NotifyDataSourceStoppedRequest& operator=(const NotifyDataSourceStoppedRequest&);
-  bool operator==(const NotifyDataSourceStoppedRequest&) const;
-  bool operator!=(const NotifyDataSourceStoppedRequest& other) const { return !(*this == other); }
+  DetachRequest();
+  ~DetachRequest() override;
+  DetachRequest(DetachRequest&&) noexcept;
+  DetachRequest& operator=(DetachRequest&&);
+  DetachRequest(const DetachRequest&);
+  DetachRequest& operator=(const DetachRequest&);
+  bool operator==(const DetachRequest&) const;
+  bool operator!=(const DetachRequest& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_data_source_id() const { return _has_field_[1]; }
-  uint64_t data_source_id() const { return data_source_id_; }
-  void set_data_source_id(uint64_t value) { data_source_id_ = value; _has_field_.set(1); }
+  bool has_key() const { return _has_field_[1]; }
+  const std::string& key() const { return key_; }
+  void set_key(const std::string& value) { key_ = value; _has_field_.set(1); }
 
  private:
-  uint64_t data_source_id_{};
+  std::string key_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
@@ -173474,19 +194063,19 @@ class PERFETTO_EXPORT_COMPONENT NotifyDataSourceStoppedRequest : public ::protoz
 };
 
 
-class PERFETTO_EXPORT_COMPONENT NotifyDataSourceStartedResponse : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT FlushResponse : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
   };
 
-  NotifyDataSourceStartedResponse();
-  ~NotifyDataSourceStartedResponse() override;
-  NotifyDataSourceStartedResponse(NotifyDataSourceStartedResponse&&) noexcept;
-  NotifyDataSourceStartedResponse& operator=(NotifyDataSourceStartedResponse&&);
-  NotifyDataSourceStartedResponse(const NotifyDataSourceStartedResponse&);
-  NotifyDataSourceStartedResponse& operator=(const NotifyDataSourceStartedResponse&);
-  bool operator==(const NotifyDataSourceStartedResponse&) const;
-  bool operator!=(const NotifyDataSourceStartedResponse& other) const { return !(*this == other); }
+  FlushResponse();
+  ~FlushResponse() override;
+  FlushResponse(FlushResponse&&) noexcept;
+  FlushResponse& operator=(FlushResponse&&);
+  FlushResponse(const FlushResponse&);
+  FlushResponse& operator=(const FlushResponse&);
+  bool operator==(const FlushResponse&) const;
+  bool operator!=(const FlushResponse& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
@@ -173503,54 +194092,60 @@ class PERFETTO_EXPORT_COMPONENT NotifyDataSourceStartedResponse : public ::proto
 };
 
 
-class PERFETTO_EXPORT_COMPONENT NotifyDataSourceStartedRequest : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT FlushRequest : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kDataSourceIdFieldNumber = 1,
+    kTimeoutMsFieldNumber = 1,
+    kFlagsFieldNumber = 2,
   };
 
-  NotifyDataSourceStartedRequest();
-  ~NotifyDataSourceStartedRequest() override;
-  NotifyDataSourceStartedRequest(NotifyDataSourceStartedRequest&&) noexcept;
-  NotifyDataSourceStartedRequest& operator=(NotifyDataSourceStartedRequest&&);
-  NotifyDataSourceStartedRequest(const NotifyDataSourceStartedRequest&);
-  NotifyDataSourceStartedRequest& operator=(const NotifyDataSourceStartedRequest&);
-  bool operator==(const NotifyDataSourceStartedRequest&) const;
-  bool operator!=(const NotifyDataSourceStartedRequest& other) const { return !(*this == other); }
-
+  FlushRequest();
+  ~FlushRequest() override;
+  FlushRequest(FlushRequest&&) noexcept;
+  FlushRequest& operator=(FlushRequest&&);
+  FlushRequest(const FlushRequest&);
+  FlushRequest& operator=(const FlushRequest&);
+  bool operator==(const FlushRequest&) const;
+  bool operator!=(const FlushRequest& other) const { return !(*this == other); }
+
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_data_source_id() const { return _has_field_[1]; }
-  uint64_t data_source_id() const { return data_source_id_; }
-  void set_data_source_id(uint64_t value) { data_source_id_ = value; _has_field_.set(1); }
+  bool has_timeout_ms() const { return _has_field_[1]; }
+  uint32_t timeout_ms() const { return timeout_ms_; }
+  void set_timeout_ms(uint32_t value) { timeout_ms_ = value; _has_field_.set(1); }
+
+  bool has_flags() const { return _has_field_[2]; }
+  uint64_t flags() const { return flags_; }
+  void set_flags(uint64_t value) { flags_ = value; _has_field_.set(2); }
 
  private:
-  uint64_t data_source_id_{};
+  uint32_t timeout_ms_{};
+  uint64_t flags_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<2> _has_field_{};
+  std::bitset<3> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT CommitDataResponse : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT FreeBuffersResponse : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
   };
 
-  CommitDataResponse();
-  ~CommitDataResponse() override;
-  CommitDataResponse(CommitDataResponse&&) noexcept;
-  CommitDataResponse& operator=(CommitDataResponse&&);
-  CommitDataResponse(const CommitDataResponse&);
-  CommitDataResponse& operator=(const CommitDataResponse&);
-  bool operator==(const CommitDataResponse&) const;
-  bool operator!=(const CommitDataResponse& other) const { return !(*this == other); }
+  FreeBuffersResponse();
+  ~FreeBuffersResponse() override;
+  FreeBuffersResponse(FreeBuffersResponse&&) noexcept;
+  FreeBuffersResponse& operator=(FreeBuffersResponse&&);
+  FreeBuffersResponse(const FreeBuffersResponse&);
+  FreeBuffersResponse& operator=(const FreeBuffersResponse&);
+  bool operator==(const FreeBuffersResponse&) const;
+  bool operator!=(const FreeBuffersResponse& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
@@ -173567,26 +194162,35 @@ class PERFETTO_EXPORT_COMPONENT CommitDataResponse : public ::protozero::CppMess
 };
 
 
-class PERFETTO_EXPORT_COMPONENT UnregisterTraceWriterResponse : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT FreeBuffersRequest : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
+    kBufferIdsFieldNumber = 1,
   };
 
-  UnregisterTraceWriterResponse();
-  ~UnregisterTraceWriterResponse() override;
-  UnregisterTraceWriterResponse(UnregisterTraceWriterResponse&&) noexcept;
-  UnregisterTraceWriterResponse& operator=(UnregisterTraceWriterResponse&&);
-  UnregisterTraceWriterResponse(const UnregisterTraceWriterResponse&);
-  UnregisterTraceWriterResponse& operator=(const UnregisterTraceWriterResponse&);
-  bool operator==(const UnregisterTraceWriterResponse&) const;
-  bool operator!=(const UnregisterTraceWriterResponse& other) const { return !(*this == other); }
+  FreeBuffersRequest();
+  ~FreeBuffersRequest() override;
+  FreeBuffersRequest(FreeBuffersRequest&&) noexcept;
+  FreeBuffersRequest& operator=(FreeBuffersRequest&&);
+  FreeBuffersRequest(const FreeBuffersRequest&);
+  FreeBuffersRequest& operator=(const FreeBuffersRequest&);
+  bool operator==(const FreeBuffersRequest&) const;
+  bool operator!=(const FreeBuffersRequest& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
+  const std::vector<uint32_t>& buffer_ids() const { return buffer_ids_; }
+  std::vector<uint32_t>* mutable_buffer_ids() { return &buffer_ids_; }
+  int buffer_ids_size() const { return static_cast<int>(buffer_ids_.size()); }
+  void clear_buffer_ids() { buffer_ids_.clear(); }
+  void add_buffer_ids(uint32_t value) { buffer_ids_.emplace_back(value); }
+  uint32_t* add_buffer_ids() { buffer_ids_.emplace_back(); return &buffer_ids_.back(); }
+
  private:
+  std::vector<uint32_t> buffer_ids_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
@@ -173596,124 +194200,128 @@ class PERFETTO_EXPORT_COMPONENT UnregisterTraceWriterResponse : public ::protoze
 };
 
 
-class PERFETTO_EXPORT_COMPONENT UnregisterTraceWriterRequest : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT ReadBuffersResponse : public ::protozero::CppMessageObj {
  public:
+  using Slice = ReadBuffersResponse_Slice;
   enum FieldNumbers {
-    kTraceWriterIdFieldNumber = 1,
+    kSlicesFieldNumber = 2,
   };
 
-  UnregisterTraceWriterRequest();
-  ~UnregisterTraceWriterRequest() override;
-  UnregisterTraceWriterRequest(UnregisterTraceWriterRequest&&) noexcept;
-  UnregisterTraceWriterRequest& operator=(UnregisterTraceWriterRequest&&);
-  UnregisterTraceWriterRequest(const UnregisterTraceWriterRequest&);
-  UnregisterTraceWriterRequest& operator=(const UnregisterTraceWriterRequest&);
-  bool operator==(const UnregisterTraceWriterRequest&) const;
-  bool operator!=(const UnregisterTraceWriterRequest& other) const { return !(*this == other); }
+  ReadBuffersResponse();
+  ~ReadBuffersResponse() override;
+  ReadBuffersResponse(ReadBuffersResponse&&) noexcept;
+  ReadBuffersResponse& operator=(ReadBuffersResponse&&);
+  ReadBuffersResponse(const ReadBuffersResponse&);
+  ReadBuffersResponse& operator=(const ReadBuffersResponse&);
+  bool operator==(const ReadBuffersResponse&) const;
+  bool operator!=(const ReadBuffersResponse& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_trace_writer_id() const { return _has_field_[1]; }
-  uint32_t trace_writer_id() const { return trace_writer_id_; }
-  void set_trace_writer_id(uint32_t value) { trace_writer_id_ = value; _has_field_.set(1); }
+  const std::vector<ReadBuffersResponse_Slice>& slices() const { return slices_; }
+  std::vector<ReadBuffersResponse_Slice>* mutable_slices() { return &slices_; }
+  int slices_size() const;
+  void clear_slices();
+  ReadBuffersResponse_Slice* add_slices();
 
  private:
-  uint32_t trace_writer_id_{};
+  std::vector<ReadBuffersResponse_Slice> slices_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<2> _has_field_{};
+  std::bitset<3> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT RegisterTraceWriterResponse : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT ReadBuffersResponse_Slice : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
+    kDataFieldNumber = 1,
+    kLastSliceForPacketFieldNumber = 2,
   };
 
-  RegisterTraceWriterResponse();
-  ~RegisterTraceWriterResponse() override;
-  RegisterTraceWriterResponse(RegisterTraceWriterResponse&&) noexcept;
-  RegisterTraceWriterResponse& operator=(RegisterTraceWriterResponse&&);
-  RegisterTraceWriterResponse(const RegisterTraceWriterResponse&);
-  RegisterTraceWriterResponse& operator=(const RegisterTraceWriterResponse&);
-  bool operator==(const RegisterTraceWriterResponse&) const;
-  bool operator!=(const RegisterTraceWriterResponse& other) const { return !(*this == other); }
+  ReadBuffersResponse_Slice();
+  ~ReadBuffersResponse_Slice() override;
+  ReadBuffersResponse_Slice(ReadBuffersResponse_Slice&&) noexcept;
+  ReadBuffersResponse_Slice& operator=(ReadBuffersResponse_Slice&&);
+  ReadBuffersResponse_Slice(const ReadBuffersResponse_Slice&);
+  ReadBuffersResponse_Slice& operator=(const ReadBuffersResponse_Slice&);
+  bool operator==(const ReadBuffersResponse_Slice&) const;
+  bool operator!=(const ReadBuffersResponse_Slice& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
+  bool has_data() const { return _has_field_[1]; }
+  const std::string& data() const { return data_; }
+  void set_data(const std::string& value) { data_ = value; _has_field_.set(1); }
+  void set_data(const void* p, size_t s) { data_.assign(reinterpret_cast<const char*>(p), s); _has_field_.set(1); }
+
+  bool has_last_slice_for_packet() const { return _has_field_[2]; }
+  bool last_slice_for_packet() const { return last_slice_for_packet_; }
+  void set_last_slice_for_packet(bool value) { last_slice_for_packet_ = value; _has_field_.set(2); }
+
  private:
+  std::string data_{};
+  bool last_slice_for_packet_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<2> _has_field_{};
+  std::bitset<3> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT RegisterTraceWriterRequest : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT ReadBuffersRequest : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kTraceWriterIdFieldNumber = 1,
-    kTargetBufferFieldNumber = 2,
   };
 
-  RegisterTraceWriterRequest();
-  ~RegisterTraceWriterRequest() override;
-  RegisterTraceWriterRequest(RegisterTraceWriterRequest&&) noexcept;
-  RegisterTraceWriterRequest& operator=(RegisterTraceWriterRequest&&);
-  RegisterTraceWriterRequest(const RegisterTraceWriterRequest&);
-  RegisterTraceWriterRequest& operator=(const RegisterTraceWriterRequest&);
-  bool operator==(const RegisterTraceWriterRequest&) const;
-  bool operator!=(const RegisterTraceWriterRequest& other) const { return !(*this == other); }
+  ReadBuffersRequest();
+  ~ReadBuffersRequest() override;
+  ReadBuffersRequest(ReadBuffersRequest&&) noexcept;
+  ReadBuffersRequest& operator=(ReadBuffersRequest&&);
+  ReadBuffersRequest(const ReadBuffersRequest&);
+  ReadBuffersRequest& operator=(const ReadBuffersRequest&);
+  bool operator==(const ReadBuffersRequest&) const;
+  bool operator!=(const ReadBuffersRequest& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_trace_writer_id() const { return _has_field_[1]; }
-  uint32_t trace_writer_id() const { return trace_writer_id_; }
-  void set_trace_writer_id(uint32_t value) { trace_writer_id_ = value; _has_field_.set(1); }
-
-  bool has_target_buffer() const { return _has_field_[2]; }
-  uint32_t target_buffer() const { return target_buffer_; }
-  void set_target_buffer(uint32_t value) { target_buffer_ = value; _has_field_.set(2); }
-
  private:
-  uint32_t trace_writer_id_{};
-  uint32_t target_buffer_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<3> _has_field_{};
+  std::bitset<2> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT UnregisterDataSourceResponse : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT DisableTracingResponse : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
   };
 
-  UnregisterDataSourceResponse();
-  ~UnregisterDataSourceResponse() override;
-  UnregisterDataSourceResponse(UnregisterDataSourceResponse&&) noexcept;
-  UnregisterDataSourceResponse& operator=(UnregisterDataSourceResponse&&);
-  UnregisterDataSourceResponse(const UnregisterDataSourceResponse&);
-  UnregisterDataSourceResponse& operator=(const UnregisterDataSourceResponse&);
-  bool operator==(const UnregisterDataSourceResponse&) const;
-  bool operator!=(const UnregisterDataSourceResponse& other) const { return !(*this == other); }
+  DisableTracingResponse();
+  ~DisableTracingResponse() override;
+  DisableTracingResponse(DisableTracingResponse&&) noexcept;
+  DisableTracingResponse& operator=(DisableTracingResponse&&);
+  DisableTracingResponse(const DisableTracingResponse&);
+  DisableTracingResponse& operator=(const DisableTracingResponse&);
+  bool operator==(const DisableTracingResponse&) const;
+  bool operator!=(const DisableTracingResponse& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
@@ -173730,32 +194338,26 @@ class PERFETTO_EXPORT_COMPONENT UnregisterDataSourceResponse : public ::protozer
 };
 
 
-class PERFETTO_EXPORT_COMPONENT UnregisterDataSourceRequest : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT DisableTracingRequest : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kDataSourceNameFieldNumber = 1,
   };
 
-  UnregisterDataSourceRequest();
-  ~UnregisterDataSourceRequest() override;
-  UnregisterDataSourceRequest(UnregisterDataSourceRequest&&) noexcept;
-  UnregisterDataSourceRequest& operator=(UnregisterDataSourceRequest&&);
-  UnregisterDataSourceRequest(const UnregisterDataSourceRequest&);
-  UnregisterDataSourceRequest& operator=(const UnregisterDataSourceRequest&);
-  bool operator==(const UnregisterDataSourceRequest&) const;
-  bool operator!=(const UnregisterDataSourceRequest& other) const { return !(*this == other); }
+  DisableTracingRequest();
+  ~DisableTracingRequest() override;
+  DisableTracingRequest(DisableTracingRequest&&) noexcept;
+  DisableTracingRequest& operator=(DisableTracingRequest&&);
+  DisableTracingRequest(const DisableTracingRequest&);
+  DisableTracingRequest& operator=(const DisableTracingRequest&);
+  bool operator==(const DisableTracingRequest&) const;
+  bool operator!=(const DisableTracingRequest& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_data_source_name() const { return _has_field_[1]; }
-  const std::string& data_source_name() const { return data_source_name_; }
-  void set_data_source_name(const std::string& value) { data_source_name_ = value; _has_field_.set(1); }
-
  private:
-  std::string data_source_name_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
@@ -173765,19 +194367,19 @@ class PERFETTO_EXPORT_COMPONENT UnregisterDataSourceRequest : public ::protozero
 };
 
 
-class PERFETTO_EXPORT_COMPONENT UpdateDataSourceResponse : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT ChangeTraceConfigResponse : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
   };
 
-  UpdateDataSourceResponse();
-  ~UpdateDataSourceResponse() override;
-  UpdateDataSourceResponse(UpdateDataSourceResponse&&) noexcept;
-  UpdateDataSourceResponse& operator=(UpdateDataSourceResponse&&);
-  UpdateDataSourceResponse(const UpdateDataSourceResponse&);
-  UpdateDataSourceResponse& operator=(const UpdateDataSourceResponse&);
-  bool operator==(const UpdateDataSourceResponse&) const;
-  bool operator!=(const UpdateDataSourceResponse& other) const { return !(*this == other); }
+  ChangeTraceConfigResponse();
+  ~ChangeTraceConfigResponse() override;
+  ChangeTraceConfigResponse(ChangeTraceConfigResponse&&) noexcept;
+  ChangeTraceConfigResponse& operator=(ChangeTraceConfigResponse&&);
+  ChangeTraceConfigResponse(const ChangeTraceConfigResponse&);
+  ChangeTraceConfigResponse& operator=(const ChangeTraceConfigResponse&);
+  bool operator==(const ChangeTraceConfigResponse&) const;
+  bool operator!=(const ChangeTraceConfigResponse& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
@@ -173794,32 +194396,32 @@ class PERFETTO_EXPORT_COMPONENT UpdateDataSourceResponse : public ::protozero::C
 };
 
 
-class PERFETTO_EXPORT_COMPONENT UpdateDataSourceRequest : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT ChangeTraceConfigRequest : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kDataSourceDescriptorFieldNumber = 1,
+    kTraceConfigFieldNumber = 1,
   };
 
-  UpdateDataSourceRequest();
-  ~UpdateDataSourceRequest() override;
-  UpdateDataSourceRequest(UpdateDataSourceRequest&&) noexcept;
-  UpdateDataSourceRequest& operator=(UpdateDataSourceRequest&&);
-  UpdateDataSourceRequest(const UpdateDataSourceRequest&);
-  UpdateDataSourceRequest& operator=(const UpdateDataSourceRequest&);
-  bool operator==(const UpdateDataSourceRequest&) const;
-  bool operator!=(const UpdateDataSourceRequest& other) const { return !(*this == other); }
+  ChangeTraceConfigRequest();
+  ~ChangeTraceConfigRequest() override;
+  ChangeTraceConfigRequest(ChangeTraceConfigRequest&&) noexcept;
+  ChangeTraceConfigRequest& operator=(ChangeTraceConfigRequest&&);
+  ChangeTraceConfigRequest(const ChangeTraceConfigRequest&);
+  ChangeTraceConfigRequest& operator=(const ChangeTraceConfigRequest&);
+  bool operator==(const ChangeTraceConfigRequest&) const;
+  bool operator!=(const ChangeTraceConfigRequest& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_data_source_descriptor() const { return _has_field_[1]; }
-  const DataSourceDescriptor& data_source_descriptor() const { return *data_source_descriptor_; }
-  DataSourceDescriptor* mutable_data_source_descriptor() { _has_field_.set(1); return data_source_descriptor_.get(); }
+  bool has_trace_config() const { return _has_field_[1]; }
+  const TraceConfig& trace_config() const { return *trace_config_; }
+  TraceConfig* mutable_trace_config() { _has_field_.set(1); return trace_config_.get(); }
 
  private:
-  ::protozero::CopyablePtr<DataSourceDescriptor> data_source_descriptor_;
+  ::protozero::CopyablePtr<TraceConfig> trace_config_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
@@ -173829,32 +194431,26 @@ class PERFETTO_EXPORT_COMPONENT UpdateDataSourceRequest : public ::protozero::Cp
 };
 
 
-class PERFETTO_EXPORT_COMPONENT RegisterDataSourceResponse : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT StartTracingResponse : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kErrorFieldNumber = 1,
   };
 
-  RegisterDataSourceResponse();
-  ~RegisterDataSourceResponse() override;
-  RegisterDataSourceResponse(RegisterDataSourceResponse&&) noexcept;
-  RegisterDataSourceResponse& operator=(RegisterDataSourceResponse&&);
-  RegisterDataSourceResponse(const RegisterDataSourceResponse&);
-  RegisterDataSourceResponse& operator=(const RegisterDataSourceResponse&);
-  bool operator==(const RegisterDataSourceResponse&) const;
-  bool operator!=(const RegisterDataSourceResponse& other) const { return !(*this == other); }
+  StartTracingResponse();
+  ~StartTracingResponse() override;
+  StartTracingResponse(StartTracingResponse&&) noexcept;
+  StartTracingResponse& operator=(StartTracingResponse&&);
+  StartTracingResponse(const StartTracingResponse&);
+  StartTracingResponse& operator=(const StartTracingResponse&);
+  bool operator==(const StartTracingResponse&) const;
+  bool operator!=(const StartTracingResponse& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_error() const { return _has_field_[1]; }
-  const std::string& error() const { return error_; }
-  void set_error(const std::string& value) { error_ = value; _has_field_.set(1); }
-
  private:
-  std::string error_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
@@ -173864,32 +194460,26 @@ class PERFETTO_EXPORT_COMPONENT RegisterDataSourceResponse : public ::protozero:
 };
 
 
-class PERFETTO_EXPORT_COMPONENT RegisterDataSourceRequest : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT StartTracingRequest : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kDataSourceDescriptorFieldNumber = 1,
   };
 
-  RegisterDataSourceRequest();
-  ~RegisterDataSourceRequest() override;
-  RegisterDataSourceRequest(RegisterDataSourceRequest&&) noexcept;
-  RegisterDataSourceRequest& operator=(RegisterDataSourceRequest&&);
-  RegisterDataSourceRequest(const RegisterDataSourceRequest&);
-  RegisterDataSourceRequest& operator=(const RegisterDataSourceRequest&);
-  bool operator==(const RegisterDataSourceRequest&) const;
-  bool operator!=(const RegisterDataSourceRequest& other) const { return !(*this == other); }
+  StartTracingRequest();
+  ~StartTracingRequest() override;
+  StartTracingRequest(StartTracingRequest&&) noexcept;
+  StartTracingRequest& operator=(StartTracingRequest&&);
+  StartTracingRequest(const StartTracingRequest&);
+  StartTracingRequest& operator=(const StartTracingRequest&);
+  bool operator==(const StartTracingRequest&) const;
+  bool operator!=(const StartTracingRequest& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_data_source_descriptor() const { return _has_field_[1]; }
-  const DataSourceDescriptor& data_source_descriptor() const { return *data_source_descriptor_; }
-  DataSourceDescriptor* mutable_data_source_descriptor() { _has_field_.set(1); return data_source_descriptor_.get(); }
-
  private:
-  ::protozero::CopyablePtr<DataSourceDescriptor> data_source_descriptor_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
@@ -173899,132 +194489,96 @@ class PERFETTO_EXPORT_COMPONENT RegisterDataSourceRequest : public ::protozero::
 };
 
 
-class PERFETTO_EXPORT_COMPONENT InitializeConnectionResponse : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT EnableTracingResponse : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kUsingShmemProvidedByProducerFieldNumber = 1,
-    kDirectSmbPatchingSupportedFieldNumber = 2,
+    kDisabledFieldNumber = 1,
+    kErrorFieldNumber = 3,
   };
 
-  InitializeConnectionResponse();
-  ~InitializeConnectionResponse() override;
-  InitializeConnectionResponse(InitializeConnectionResponse&&) noexcept;
-  InitializeConnectionResponse& operator=(InitializeConnectionResponse&&);
-  InitializeConnectionResponse(const InitializeConnectionResponse&);
-  InitializeConnectionResponse& operator=(const InitializeConnectionResponse&);
-  bool operator==(const InitializeConnectionResponse&) const;
-  bool operator!=(const InitializeConnectionResponse& other) const { return !(*this == other); }
+  EnableTracingResponse();
+  ~EnableTracingResponse() override;
+  EnableTracingResponse(EnableTracingResponse&&) noexcept;
+  EnableTracingResponse& operator=(EnableTracingResponse&&);
+  EnableTracingResponse(const EnableTracingResponse&);
+  EnableTracingResponse& operator=(const EnableTracingResponse&);
+  bool operator==(const EnableTracingResponse&) const;
+  bool operator!=(const EnableTracingResponse& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_using_shmem_provided_by_producer() const { return _has_field_[1]; }
-  bool using_shmem_provided_by_producer() const { return using_shmem_provided_by_producer_; }
-  void set_using_shmem_provided_by_producer(bool value) { using_shmem_provided_by_producer_ = value; _has_field_.set(1); }
+  bool has_disabled() const { return _has_field_[1]; }
+  bool disabled() const { return disabled_; }
+  void set_disabled(bool value) { disabled_ = value; _has_field_.set(1); }
 
-  bool has_direct_smb_patching_supported() const { return _has_field_[2]; }
-  bool direct_smb_patching_supported() const { return direct_smb_patching_supported_; }
-  void set_direct_smb_patching_supported(bool value) { direct_smb_patching_supported_ = value; _has_field_.set(2); }
+  bool has_error() const { return _has_field_[3]; }
+  const std::string& error() const { return error_; }
+  void set_error(const std::string& value) { error_ = value; _has_field_.set(3); }
 
  private:
-  bool using_shmem_provided_by_producer_{};
-  bool direct_smb_patching_supported_{};
+  bool disabled_{};
+  std::string error_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<3> _has_field_{};
+  std::bitset<4> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT InitializeConnectionRequest : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT EnableTracingRequest : public ::protozero::CppMessageObj {
  public:
-  using ProducerSMBScrapingMode = InitializeConnectionRequest_ProducerSMBScrapingMode;
-  static constexpr auto SMB_SCRAPING_UNSPECIFIED = InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_UNSPECIFIED;
-  static constexpr auto SMB_SCRAPING_ENABLED = InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_ENABLED;
-  static constexpr auto SMB_SCRAPING_DISABLED = InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_DISABLED;
-  static constexpr auto ProducerSMBScrapingMode_MIN = InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_UNSPECIFIED;
-  static constexpr auto ProducerSMBScrapingMode_MAX = InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_DISABLED;
   enum FieldNumbers {
-    kSharedMemoryPageSizeHintBytesFieldNumber = 1,
-    kSharedMemorySizeHintBytesFieldNumber = 2,
-    kProducerNameFieldNumber = 3,
-    kSmbScrapingModeFieldNumber = 4,
-    kProducerProvidedShmemFieldNumber = 6,
-    kSdkVersionFieldNumber = 8,
-    kShmKeyWindowsFieldNumber = 7,
+    kTraceConfigFieldNumber = 1,
+    kAttachNotificationOnlyFieldNumber = 2,
   };
 
-  InitializeConnectionRequest();
-  ~InitializeConnectionRequest() override;
-  InitializeConnectionRequest(InitializeConnectionRequest&&) noexcept;
-  InitializeConnectionRequest& operator=(InitializeConnectionRequest&&);
-  InitializeConnectionRequest(const InitializeConnectionRequest&);
-  InitializeConnectionRequest& operator=(const InitializeConnectionRequest&);
-  bool operator==(const InitializeConnectionRequest&) const;
-  bool operator!=(const InitializeConnectionRequest& other) const { return !(*this == other); }
+  EnableTracingRequest();
+  ~EnableTracingRequest() override;
+  EnableTracingRequest(EnableTracingRequest&&) noexcept;
+  EnableTracingRequest& operator=(EnableTracingRequest&&);
+  EnableTracingRequest(const EnableTracingRequest&);
+  EnableTracingRequest& operator=(const EnableTracingRequest&);
+  bool operator==(const EnableTracingRequest&) const;
+  bool operator!=(const EnableTracingRequest& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_shared_memory_page_size_hint_bytes() const { return _has_field_[1]; }
-  uint32_t shared_memory_page_size_hint_bytes() const { return shared_memory_page_size_hint_bytes_; }
-  void set_shared_memory_page_size_hint_bytes(uint32_t value) { shared_memory_page_size_hint_bytes_ = value; _has_field_.set(1); }
-
-  bool has_shared_memory_size_hint_bytes() const { return _has_field_[2]; }
-  uint32_t shared_memory_size_hint_bytes() const { return shared_memory_size_hint_bytes_; }
-  void set_shared_memory_size_hint_bytes(uint32_t value) { shared_memory_size_hint_bytes_ = value; _has_field_.set(2); }
-
-  bool has_producer_name() const { return _has_field_[3]; }
-  const std::string& producer_name() const { return producer_name_; }
-  void set_producer_name(const std::string& value) { producer_name_ = value; _has_field_.set(3); }
-
-  bool has_smb_scraping_mode() const { return _has_field_[4]; }
-  InitializeConnectionRequest_ProducerSMBScrapingMode smb_scraping_mode() const { return smb_scraping_mode_; }
-  void set_smb_scraping_mode(InitializeConnectionRequest_ProducerSMBScrapingMode value) { smb_scraping_mode_ = value; _has_field_.set(4); }
-
-  bool has_producer_provided_shmem() const { return _has_field_[6]; }
-  bool producer_provided_shmem() const { return producer_provided_shmem_; }
-  void set_producer_provided_shmem(bool value) { producer_provided_shmem_ = value; _has_field_.set(6); }
-
-  bool has_sdk_version() const { return _has_field_[8]; }
-  const std::string& sdk_version() const { return sdk_version_; }
-  void set_sdk_version(const std::string& value) { sdk_version_ = value; _has_field_.set(8); }
+  bool has_trace_config() const { return _has_field_[1]; }
+  const TraceConfig& trace_config() const { return *trace_config_; }
+  TraceConfig* mutable_trace_config() { _has_field_.set(1); return trace_config_.get(); }
 
-  bool has_shm_key_windows() const { return _has_field_[7]; }
-  const std::string& shm_key_windows() const { return shm_key_windows_; }
-  void set_shm_key_windows(const std::string& value) { shm_key_windows_ = value; _has_field_.set(7); }
+  bool has_attach_notification_only() const { return _has_field_[2]; }
+  bool attach_notification_only() const { return attach_notification_only_; }
+  void set_attach_notification_only(bool value) { attach_notification_only_ = value; _has_field_.set(2); }
 
  private:
-  uint32_t shared_memory_page_size_hint_bytes_{};
-  uint32_t shared_memory_size_hint_bytes_{};
-  std::string producer_name_{};
-  InitializeConnectionRequest_ProducerSMBScrapingMode smb_scraping_mode_{};
-  bool producer_provided_shmem_{};
-  std::string sdk_version_{};
-  std::string shm_key_windows_{};
+  ::protozero::CopyablePtr<TraceConfig> trace_config_;
+  bool attach_notification_only_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<9> _has_field_{};
+  std::bitset<3> _has_field_{};
 };
 
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
 
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_PRODUCER_PORT_PROTO_CPP_H_
-// gen_amalgamated begin header: gen/protos/perfetto/ipc/wire_protocol.gen.h
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_CONSUMER_PORT_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/ipc/producer_port.gen.h
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
-#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_WIRE_PROTOCOL_PROTO_CPP_H_
-#define PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_WIRE_PROTOCOL_PROTO_CPP_H_
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_PRODUCER_PORT_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_PRODUCER_PORT_PROTO_CPP_H_
 
 #include <stdint.h>
 #include <bitset>
@@ -174039,13 +194593,61 @@ class PERFETTO_EXPORT_COMPONENT InitializeConnectionRequest : public ::protozero
 namespace perfetto {
 namespace protos {
 namespace gen {
-class IPCFrame;
-class IPCFrame_RequestError;
-class IPCFrame_InvokeMethodReply;
-class IPCFrame_InvokeMethod;
-class IPCFrame_BindServiceReply;
-class IPCFrame_BindServiceReply_MethodInfo;
-class IPCFrame_BindService;
+class SyncResponse;
+class SyncRequest;
+class GetAsyncCommandResponse;
+class GetAsyncCommandResponse_ClearIncrementalState;
+class GetAsyncCommandResponse_Flush;
+class GetAsyncCommandResponse_StopDataSource;
+class GetAsyncCommandResponse_StartDataSource;
+class DataSourceConfig;
+class TestConfig;
+class TestConfig_DummyFields;
+class InterceptorConfig;
+class ConsoleConfig;
+class ChromeConfig;
+class SystemInfoConfig;
+class ProtoVmConfig;
+class PriorityBoostConfig;
+class GetAsyncCommandResponse_SetupDataSource;
+class GetAsyncCommandResponse_SetupTracing;
+class GetAsyncCommandRequest;
+class ActivateTriggersResponse;
+class ActivateTriggersRequest;
+class NotifyDataSourceStoppedResponse;
+class NotifyDataSourceStoppedRequest;
+class NotifyDataSourceStartedResponse;
+class NotifyDataSourceStartedRequest;
+class CommitDataResponse;
+class UnregisterTraceWriterResponse;
+class UnregisterTraceWriterRequest;
+class RegisterTraceWriterResponse;
+class RegisterTraceWriterRequest;
+class UnregisterDataSourceResponse;
+class UnregisterDataSourceRequest;
+class UpdateDataSourceResponse;
+class UpdateDataSourceRequest;
+class DataSourceDescriptor;
+class VmProgram;
+class VmInstruction;
+class VmOpDel;
+class VmOpSet;
+class VmOpMerge;
+class VmOpRegLoad;
+class VmOpSelect;
+class VmOpSelect_PathComponent;
+class RegisterDataSourceResponse;
+class RegisterDataSourceRequest;
+class InitializeConnectionResponse;
+class InitializeConnectionRequest;
+enum DataSourceConfig_SessionInitiator : int;
+enum DataSourceConfig_BufferExhaustedPolicy : int;
+enum ConsoleConfig_Output : int;
+enum ChromeConfig_ClientPriority : int;
+enum PriorityBoostConfig_BoostPolicy : int;
+enum VmInstruction_AbortLevel : int;
+enum VmCursorEnum : int;
+enum InitializeConnectionRequest_ProducerSMBScrapingMode : int;
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
@@ -174057,112 +194659,61 @@ class Message;
 namespace perfetto {
 namespace protos {
 namespace gen {
+enum InitializeConnectionRequest_ProducerSMBScrapingMode : int {
+  InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_UNSPECIFIED = 0,
+  InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_ENABLED = 1,
+  InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_DISABLED = 2,
+};
 
-class PERFETTO_EXPORT_COMPONENT IPCFrame : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT SyncResponse : public ::protozero::CppMessageObj {
  public:
-  using BindService = IPCFrame_BindService;
-  using BindServiceReply = IPCFrame_BindServiceReply;
-  using InvokeMethod = IPCFrame_InvokeMethod;
-  using InvokeMethodReply = IPCFrame_InvokeMethodReply;
-  using RequestError = IPCFrame_RequestError;
   enum FieldNumbers {
-    kRequestIdFieldNumber = 2,
-    kMsgBindServiceFieldNumber = 3,
-    kMsgBindServiceReplyFieldNumber = 4,
-    kMsgInvokeMethodFieldNumber = 5,
-    kMsgInvokeMethodReplyFieldNumber = 6,
-    kMsgRequestErrorFieldNumber = 7,
-    kDataForTestingFieldNumber = 1,
   };
 
-  IPCFrame();
-  ~IPCFrame() override;
-  IPCFrame(IPCFrame&&) noexcept;
-  IPCFrame& operator=(IPCFrame&&);
-  IPCFrame(const IPCFrame&);
-  IPCFrame& operator=(const IPCFrame&);
-  bool operator==(const IPCFrame&) const;
-  bool operator!=(const IPCFrame& other) const { return !(*this == other); }
+  SyncResponse();
+  ~SyncResponse() override;
+  SyncResponse(SyncResponse&&) noexcept;
+  SyncResponse& operator=(SyncResponse&&);
+  SyncResponse(const SyncResponse&);
+  SyncResponse& operator=(const SyncResponse&);
+  bool operator==(const SyncResponse&) const;
+  bool operator!=(const SyncResponse& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_request_id() const { return _has_field_[2]; }
-  uint64_t request_id() const { return request_id_; }
-  void set_request_id(uint64_t value) { request_id_ = value; _has_field_.set(2); }
-
-  bool has_msg_bind_service() const { return _has_field_[3]; }
-  const IPCFrame_BindService& msg_bind_service() const { return *msg_bind_service_; }
-  IPCFrame_BindService* mutable_msg_bind_service() { _has_field_.set(3); return msg_bind_service_.get(); }
-
-  bool has_msg_bind_service_reply() const { return _has_field_[4]; }
-  const IPCFrame_BindServiceReply& msg_bind_service_reply() const { return *msg_bind_service_reply_; }
-  IPCFrame_BindServiceReply* mutable_msg_bind_service_reply() { _has_field_.set(4); return msg_bind_service_reply_.get(); }
-
-  bool has_msg_invoke_method() const { return _has_field_[5]; }
-  const IPCFrame_InvokeMethod& msg_invoke_method() const { return *msg_invoke_method_; }
-  IPCFrame_InvokeMethod* mutable_msg_invoke_method() { _has_field_.set(5); return msg_invoke_method_.get(); }
-
-  bool has_msg_invoke_method_reply() const { return _has_field_[6]; }
-  const IPCFrame_InvokeMethodReply& msg_invoke_method_reply() const { return *msg_invoke_method_reply_; }
-  IPCFrame_InvokeMethodReply* mutable_msg_invoke_method_reply() { _has_field_.set(6); return msg_invoke_method_reply_.get(); }
-
-  bool has_msg_request_error() const { return _has_field_[7]; }
-  const IPCFrame_RequestError& msg_request_error() const { return *msg_request_error_; }
-  IPCFrame_RequestError* mutable_msg_request_error() { _has_field_.set(7); return msg_request_error_.get(); }
-
-  const std::vector<std::string>& data_for_testing() const { return data_for_testing_; }
-  std::vector<std::string>* mutable_data_for_testing() { return &data_for_testing_; }
-  int data_for_testing_size() const { return static_cast<int>(data_for_testing_.size()); }
-  void clear_data_for_testing() { data_for_testing_.clear(); }
-  void add_data_for_testing(std::string value) { data_for_testing_.emplace_back(value); }
-  std::string* add_data_for_testing() { data_for_testing_.emplace_back(); return &data_for_testing_.back(); }
-
  private:
-  uint64_t request_id_{};
-  ::protozero::CopyablePtr<IPCFrame_BindService> msg_bind_service_;
-  ::protozero::CopyablePtr<IPCFrame_BindServiceReply> msg_bind_service_reply_;
-  ::protozero::CopyablePtr<IPCFrame_InvokeMethod> msg_invoke_method_;
-  ::protozero::CopyablePtr<IPCFrame_InvokeMethodReply> msg_invoke_method_reply_;
-  ::protozero::CopyablePtr<IPCFrame_RequestError> msg_request_error_;
-  std::vector<std::string> data_for_testing_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<8> _has_field_{};
+  std::bitset<2> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT IPCFrame_RequestError : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT SyncRequest : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kErrorFieldNumber = 1,
   };
 
-  IPCFrame_RequestError();
-  ~IPCFrame_RequestError() override;
-  IPCFrame_RequestError(IPCFrame_RequestError&&) noexcept;
-  IPCFrame_RequestError& operator=(IPCFrame_RequestError&&);
-  IPCFrame_RequestError(const IPCFrame_RequestError&);
-  IPCFrame_RequestError& operator=(const IPCFrame_RequestError&);
-  bool operator==(const IPCFrame_RequestError&) const;
-  bool operator!=(const IPCFrame_RequestError& other) const { return !(*this == other); }
+  SyncRequest();
+  ~SyncRequest() override;
+  SyncRequest(SyncRequest&&) noexcept;
+  SyncRequest& operator=(SyncRequest&&);
+  SyncRequest(const SyncRequest&);
+  SyncRequest& operator=(const SyncRequest&);
+  bool operator==(const SyncRequest&) const;
+  bool operator!=(const SyncRequest& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_error() const { return _has_field_[1]; }
-  const std::string& error() const { return error_; }
-  void set_error(const std::string& value) { error_ = value; _has_field_.set(1); }
-
  private:
-  std::string error_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
@@ -174172,2403 +194723,1712 @@ class PERFETTO_EXPORT_COMPONENT IPCFrame_RequestError : public ::protozero::CppM
 };
 
 
-class PERFETTO_EXPORT_COMPONENT IPCFrame_InvokeMethodReply : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT GetAsyncCommandResponse : public ::protozero::CppMessageObj {
  public:
+  using SetupDataSource = GetAsyncCommandResponse_SetupDataSource;
+  using StartDataSource = GetAsyncCommandResponse_StartDataSource;
+  using StopDataSource = GetAsyncCommandResponse_StopDataSource;
+  using SetupTracing = GetAsyncCommandResponse_SetupTracing;
+  using Flush = GetAsyncCommandResponse_Flush;
+  using ClearIncrementalState = GetAsyncCommandResponse_ClearIncrementalState;
   enum FieldNumbers {
-    kSuccessFieldNumber = 1,
-    kHasMoreFieldNumber = 2,
-    kReplyProtoFieldNumber = 3,
+    kSetupTracingFieldNumber = 3,
+    kSetupDataSourceFieldNumber = 6,
+    kStartDataSourceFieldNumber = 1,
+    kStopDataSourceFieldNumber = 2,
+    kFlushFieldNumber = 5,
+    kClearIncrementalStateFieldNumber = 7,
   };
 
-  IPCFrame_InvokeMethodReply();
-  ~IPCFrame_InvokeMethodReply() override;
-  IPCFrame_InvokeMethodReply(IPCFrame_InvokeMethodReply&&) noexcept;
-  IPCFrame_InvokeMethodReply& operator=(IPCFrame_InvokeMethodReply&&);
-  IPCFrame_InvokeMethodReply(const IPCFrame_InvokeMethodReply&);
-  IPCFrame_InvokeMethodReply& operator=(const IPCFrame_InvokeMethodReply&);
-  bool operator==(const IPCFrame_InvokeMethodReply&) const;
-  bool operator!=(const IPCFrame_InvokeMethodReply& other) const { return !(*this == other); }
+  GetAsyncCommandResponse();
+  ~GetAsyncCommandResponse() override;
+  GetAsyncCommandResponse(GetAsyncCommandResponse&&) noexcept;
+  GetAsyncCommandResponse& operator=(GetAsyncCommandResponse&&);
+  GetAsyncCommandResponse(const GetAsyncCommandResponse&);
+  GetAsyncCommandResponse& operator=(const GetAsyncCommandResponse&);
+  bool operator==(const GetAsyncCommandResponse&) const;
+  bool operator!=(const GetAsyncCommandResponse& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_success() const { return _has_field_[1]; }
-  bool success() const { return success_; }
-  void set_success(bool value) { success_ = value; _has_field_.set(1); }
-
-  bool has_has_more() const { return _has_field_[2]; }
-  bool has_more() const { return has_more_; }
-  void set_has_more(bool value) { has_more_ = value; _has_field_.set(2); }
-
-  bool has_reply_proto() const { return _has_field_[3]; }
-  const std::string& reply_proto() const { return reply_proto_; }
-  void set_reply_proto(const std::string& value) { reply_proto_ = value; _has_field_.set(3); }
-  void set_reply_proto(const void* p, size_t s) { reply_proto_.assign(reinterpret_cast<const char*>(p), s); _has_field_.set(3); }
-
- private:
-  bool success_{};
-  bool has_more_{};
-  std::string reply_proto_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<4> _has_field_{};
-};
-
-
-class PERFETTO_EXPORT_COMPONENT IPCFrame_InvokeMethod : public ::protozero::CppMessageObj {
- public:
-  enum FieldNumbers {
-    kServiceIdFieldNumber = 1,
-    kMethodIdFieldNumber = 2,
-    kArgsProtoFieldNumber = 3,
-    kDropReplyFieldNumber = 4,
-  };
-
-  IPCFrame_InvokeMethod();
-  ~IPCFrame_InvokeMethod() override;
-  IPCFrame_InvokeMethod(IPCFrame_InvokeMethod&&) noexcept;
-  IPCFrame_InvokeMethod& operator=(IPCFrame_InvokeMethod&&);
-  IPCFrame_InvokeMethod(const IPCFrame_InvokeMethod&);
-  IPCFrame_InvokeMethod& operator=(const IPCFrame_InvokeMethod&);
-  bool operator==(const IPCFrame_InvokeMethod&) const;
-  bool operator!=(const IPCFrame_InvokeMethod& other) const { return !(*this == other); }
+  bool has_setup_tracing() const { return _has_field_[3]; }
+  const GetAsyncCommandResponse_SetupTracing& setup_tracing() const { return *setup_tracing_; }
+  GetAsyncCommandResponse_SetupTracing* mutable_setup_tracing() { _has_field_.set(3); return setup_tracing_.get(); }
 
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
+  bool has_setup_data_source() const { return _has_field_[6]; }
+  const GetAsyncCommandResponse_SetupDataSource& setup_data_source() const { return *setup_data_source_; }
+  GetAsyncCommandResponse_SetupDataSource* mutable_setup_data_source() { _has_field_.set(6); return setup_data_source_.get(); }
 
-  bool has_service_id() const { return _has_field_[1]; }
-  uint32_t service_id() const { return service_id_; }
-  void set_service_id(uint32_t value) { service_id_ = value; _has_field_.set(1); }
+  bool has_start_data_source() const { return _has_field_[1]; }
+  const GetAsyncCommandResponse_StartDataSource& start_data_source() const { return *start_data_source_; }
+  GetAsyncCommandResponse_StartDataSource* mutable_start_data_source() { _has_field_.set(1); return start_data_source_.get(); }
 
-  bool has_method_id() const { return _has_field_[2]; }
-  uint32_t method_id() const { return method_id_; }
-  void set_method_id(uint32_t value) { method_id_ = value; _has_field_.set(2); }
+  bool has_stop_data_source() const { return _has_field_[2]; }
+  const GetAsyncCommandResponse_StopDataSource& stop_data_source() const { return *stop_data_source_; }
+  GetAsyncCommandResponse_StopDataSource* mutable_stop_data_source() { _has_field_.set(2); return stop_data_source_.get(); }
 
-  bool has_args_proto() const { return _has_field_[3]; }
-  const std::string& args_proto() const { return args_proto_; }
-  void set_args_proto(const std::string& value) { args_proto_ = value; _has_field_.set(3); }
-  void set_args_proto(const void* p, size_t s) { args_proto_.assign(reinterpret_cast<const char*>(p), s); _has_field_.set(3); }
+  bool has_flush() const { return _has_field_[5]; }
+  const GetAsyncCommandResponse_Flush& flush() const { return *flush_; }
+  GetAsyncCommandResponse_Flush* mutable_flush() { _has_field_.set(5); return flush_.get(); }
 
-  bool has_drop_reply() const { return _has_field_[4]; }
-  bool drop_reply() const { return drop_reply_; }
-  void set_drop_reply(bool value) { drop_reply_ = value; _has_field_.set(4); }
+  bool has_clear_incremental_state() const { return _has_field_[7]; }
+  const GetAsyncCommandResponse_ClearIncrementalState& clear_incremental_state() const { return *clear_incremental_state_; }
+  GetAsyncCommandResponse_ClearIncrementalState* mutable_clear_incremental_state() { _has_field_.set(7); return clear_incremental_state_.get(); }
 
  private:
-  uint32_t service_id_{};
-  uint32_t method_id_{};
-  std::string args_proto_{};
-  bool drop_reply_{};
+  ::protozero::CopyablePtr<GetAsyncCommandResponse_SetupTracing> setup_tracing_;
+  ::protozero::CopyablePtr<GetAsyncCommandResponse_SetupDataSource> setup_data_source_;
+  ::protozero::CopyablePtr<GetAsyncCommandResponse_StartDataSource> start_data_source_;
+  ::protozero::CopyablePtr<GetAsyncCommandResponse_StopDataSource> stop_data_source_;
+  ::protozero::CopyablePtr<GetAsyncCommandResponse_Flush> flush_;
+  ::protozero::CopyablePtr<GetAsyncCommandResponse_ClearIncrementalState> clear_incremental_state_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<5> _has_field_{};
+  std::bitset<8> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT IPCFrame_BindServiceReply : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT GetAsyncCommandResponse_ClearIncrementalState : public ::protozero::CppMessageObj {
  public:
-  using MethodInfo = IPCFrame_BindServiceReply_MethodInfo;
   enum FieldNumbers {
-    kSuccessFieldNumber = 1,
-    kServiceIdFieldNumber = 2,
-    kMethodsFieldNumber = 3,
+    kDataSourceIdsFieldNumber = 1,
   };
 
-  IPCFrame_BindServiceReply();
-  ~IPCFrame_BindServiceReply() override;
-  IPCFrame_BindServiceReply(IPCFrame_BindServiceReply&&) noexcept;
-  IPCFrame_BindServiceReply& operator=(IPCFrame_BindServiceReply&&);
-  IPCFrame_BindServiceReply(const IPCFrame_BindServiceReply&);
-  IPCFrame_BindServiceReply& operator=(const IPCFrame_BindServiceReply&);
-  bool operator==(const IPCFrame_BindServiceReply&) const;
-  bool operator!=(const IPCFrame_BindServiceReply& other) const { return !(*this == other); }
+  GetAsyncCommandResponse_ClearIncrementalState();
+  ~GetAsyncCommandResponse_ClearIncrementalState() override;
+  GetAsyncCommandResponse_ClearIncrementalState(GetAsyncCommandResponse_ClearIncrementalState&&) noexcept;
+  GetAsyncCommandResponse_ClearIncrementalState& operator=(GetAsyncCommandResponse_ClearIncrementalState&&);
+  GetAsyncCommandResponse_ClearIncrementalState(const GetAsyncCommandResponse_ClearIncrementalState&);
+  GetAsyncCommandResponse_ClearIncrementalState& operator=(const GetAsyncCommandResponse_ClearIncrementalState&);
+  bool operator==(const GetAsyncCommandResponse_ClearIncrementalState&) const;
+  bool operator!=(const GetAsyncCommandResponse_ClearIncrementalState& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_success() const { return _has_field_[1]; }
-  bool success() const { return success_; }
-  void set_success(bool value) { success_ = value; _has_field_.set(1); }
-
-  bool has_service_id() const { return _has_field_[2]; }
-  uint32_t service_id() const { return service_id_; }
-  void set_service_id(uint32_t value) { service_id_ = value; _has_field_.set(2); }
-
-  const std::vector<IPCFrame_BindServiceReply_MethodInfo>& methods() const { return methods_; }
-  std::vector<IPCFrame_BindServiceReply_MethodInfo>* mutable_methods() { return &methods_; }
-  int methods_size() const;
-  void clear_methods();
-  IPCFrame_BindServiceReply_MethodInfo* add_methods();
+  const std::vector<uint64_t>& data_source_ids() const { return data_source_ids_; }
+  std::vector<uint64_t>* mutable_data_source_ids() { return &data_source_ids_; }
+  int data_source_ids_size() const { return static_cast<int>(data_source_ids_.size()); }
+  void clear_data_source_ids() { data_source_ids_.clear(); }
+  void add_data_source_ids(uint64_t value) { data_source_ids_.emplace_back(value); }
+  uint64_t* add_data_source_ids() { data_source_ids_.emplace_back(); return &data_source_ids_.back(); }
 
  private:
-  bool success_{};
-  uint32_t service_id_{};
-  std::vector<IPCFrame_BindServiceReply_MethodInfo> methods_;
+  std::vector<uint64_t> data_source_ids_;
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<4> _has_field_{};
+  std::bitset<2> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT IPCFrame_BindServiceReply_MethodInfo : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT GetAsyncCommandResponse_Flush : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kIdFieldNumber = 1,
-    kNameFieldNumber = 2,
+    kDataSourceIdsFieldNumber = 1,
+    kRequestIdFieldNumber = 2,
+    kFlagsFieldNumber = 3,
   };
 
-  IPCFrame_BindServiceReply_MethodInfo();
-  ~IPCFrame_BindServiceReply_MethodInfo() override;
-  IPCFrame_BindServiceReply_MethodInfo(IPCFrame_BindServiceReply_MethodInfo&&) noexcept;
-  IPCFrame_BindServiceReply_MethodInfo& operator=(IPCFrame_BindServiceReply_MethodInfo&&);
-  IPCFrame_BindServiceReply_MethodInfo(const IPCFrame_BindServiceReply_MethodInfo&);
-  IPCFrame_BindServiceReply_MethodInfo& operator=(const IPCFrame_BindServiceReply_MethodInfo&);
-  bool operator==(const IPCFrame_BindServiceReply_MethodInfo&) const;
-  bool operator!=(const IPCFrame_BindServiceReply_MethodInfo& other) const { return !(*this == other); }
+  GetAsyncCommandResponse_Flush();
+  ~GetAsyncCommandResponse_Flush() override;
+  GetAsyncCommandResponse_Flush(GetAsyncCommandResponse_Flush&&) noexcept;
+  GetAsyncCommandResponse_Flush& operator=(GetAsyncCommandResponse_Flush&&);
+  GetAsyncCommandResponse_Flush(const GetAsyncCommandResponse_Flush&);
+  GetAsyncCommandResponse_Flush& operator=(const GetAsyncCommandResponse_Flush&);
+  bool operator==(const GetAsyncCommandResponse_Flush&) const;
+  bool operator!=(const GetAsyncCommandResponse_Flush& other) const { return !(*this == other); }
 
   bool ParseFromArray(const void*, size_t) override;
   std::string SerializeAsString() const override;
   std::vector<uint8_t> SerializeAsArray() const override;
   void Serialize(::protozero::Message*) const;
 
-  bool has_id() const { return _has_field_[1]; }
-  uint32_t id() const { return id_; }
-  void set_id(uint32_t value) { id_ = value; _has_field_.set(1); }
+  const std::vector<uint64_t>& data_source_ids() const { return data_source_ids_; }
+  std::vector<uint64_t>* mutable_data_source_ids() { return &data_source_ids_; }
+  int data_source_ids_size() const { return static_cast<int>(data_source_ids_.size()); }
+  void clear_data_source_ids() { data_source_ids_.clear(); }
+  void add_data_source_ids(uint64_t value) { data_source_ids_.emplace_back(value); }
+  uint64_t* add_data_source_ids() { data_source_ids_.emplace_back(); return &data_source_ids_.back(); }
 
-  bool has_name() const { return _has_field_[2]; }
-  const std::string& name() const { return name_; }
-  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
+  bool has_request_id() const { return _has_field_[2]; }
+  uint64_t request_id() const { return request_id_; }
+  void set_request_id(uint64_t value) { request_id_ = value; _has_field_.set(2); }
+
+  bool has_flags() const { return _has_field_[3]; }
+  uint64_t flags() const { return flags_; }
+  void set_flags(uint64_t value) { flags_ = value; _has_field_.set(3); }
 
  private:
-  uint32_t id_{};
-  std::string name_{};
+  std::vector<uint64_t> data_source_ids_;
+  uint64_t request_id_{};
+  uint64_t flags_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<3> _has_field_{};
+  std::bitset<4> _has_field_{};
 };
 
 
-class PERFETTO_EXPORT_COMPONENT IPCFrame_BindService : public ::protozero::CppMessageObj {
+class PERFETTO_EXPORT_COMPONENT GetAsyncCommandResponse_StopDataSource : public ::protozero::CppMessageObj {
  public:
   enum FieldNumbers {
-    kServiceNameFieldNumber = 1,
+    kInstanceIdFieldNumber = 1,
   };
 
-  IPCFrame_BindService();
-  ~IPCFrame_BindService() override;
-  IPCFrame_BindService(IPCFrame_BindService&&) noexcept;
-  IPCFrame_BindService& operator=(IPCFrame_BindService&&);
-  IPCFrame_BindService(const IPCFrame_BindService&);
-  IPCFrame_BindService& operator=(const IPCFrame_BindService&);
-  bool operator==(const IPCFrame_BindService&) const;
-  bool operator!=(const IPCFrame_BindService& other) const { return !(*this == other); }
-
-  bool ParseFromArray(const void*, size_t) override;
-  std::string SerializeAsString() const override;
-  std::vector<uint8_t> SerializeAsArray() const override;
-  void Serialize(::protozero::Message*) const;
-
-  bool has_service_name() const { return _has_field_[1]; }
-  const std::string& service_name() const { return service_name_; }
-  void set_service_name(const std::string& value) { service_name_ = value; _has_field_.set(1); }
-
- private:
-  std::string service_name_{};
-
-  // Allows to preserve unknown protobuf fields for compatibility
-  // with future versions of .proto files.
-  std::string unknown_fields_;
-
-  std::bitset<2> _has_field_{};
-};
-
-}  // namespace perfetto
-}  // namespace protos
-}  // namespace gen
-
-#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_WIRE_PROTOCOL_PROTO_CPP_H_
-// gen_amalgamated begin header: include/perfetto/protozero/contiguous_memory_range.h
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef INCLUDE_PERFETTO_PROTOZERO_CONTIGUOUS_MEMORY_RANGE_H_
-#define INCLUDE_PERFETTO_PROTOZERO_CONTIGUOUS_MEMORY_RANGE_H_
-
-#include <assert.h>
-#include <stddef.h>
-#include <stdint.h>
-
-namespace protozero {
-
-// Keep this struct trivially constructible (no ctors, no default initializers).
-struct ContiguousMemoryRange {
-  uint8_t* begin;
-  uint8_t* end;  // STL style: one byte past the end of the buffer.
-
-  inline bool is_valid() const { return begin != nullptr; }
-  inline void reset() { begin = nullptr; }
-  inline size_t size() const { return static_cast<size_t>(end - begin); }
-};
-
-}  // namespace protozero
-
-#endif  // INCLUDE_PERFETTO_PROTOZERO_CONTIGUOUS_MEMORY_RANGE_H_
-// gen_amalgamated begin header: include/perfetto/protozero/copyable_ptr.h
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef INCLUDE_PERFETTO_PROTOZERO_COPYABLE_PTR_H_
-#define INCLUDE_PERFETTO_PROTOZERO_COPYABLE_PTR_H_
-
-#include <memory>
-
-namespace protozero {
-
-// This class is essentially a std::vector<T> of fixed size = 1.
-// It's a pointer wrapper with deep copying and deep equality comparison.
-// At all effects this wrapper behaves like the underlying T, with the exception
-// of the heap indirection.
-// Conversely to a std::unique_ptr, the pointer will be always valid, never
-// null. The problem it solves is the following: when generating C++ classes
-// from proto files, we want to keep each header hermetic (i.e. not #include
-// headers of dependent types). As such we can't directly instantiate T
-// field members but we can instead rely on pointers, so only the .cc file needs
-// to see the actual definition of T. If the generated classes were move-only we
-// could just use a unique_ptr there. But they aren't, hence this wrapper.
-// Converesely to unique_ptr, this wrapper:
-// - Default constructs the T instance in its constructor.
-// - Implements deep comparison in operator== instead of pointer comparison.
-template <typename T>
-class CopyablePtr {
- public:
-  CopyablePtr() : ptr_(new T()) {}
-  ~CopyablePtr() = default;
-
-  // Copy operators.
-  CopyablePtr(const CopyablePtr& other) : ptr_(new T(*other.ptr_)) {}
-  CopyablePtr& operator=(const CopyablePtr& other) {
-    *ptr_ = *other.ptr_;
-    return *this;
-  }
-
-  // Move operators.
-  CopyablePtr(CopyablePtr&& other) noexcept : ptr_(std::move(other.ptr_)) {
-    other.ptr_.reset(new T());
-  }
-
-  CopyablePtr& operator=(CopyablePtr&& other) {
-    ptr_ = std::move(other.ptr_);
-    other.ptr_.reset(new T());
-    return *this;
-  }
-
-  T* get() { return ptr_.get(); }
-  const T* get() const { return ptr_.get(); }
-
-  T* operator->() { return ptr_.get(); }
-  const T* operator->() const { return ptr_.get(); }
-
-  T& operator*() { return *ptr_; }
-  const T& operator*() const { return *ptr_; }
-
-  friend bool operator==(const CopyablePtr& lhs, const CopyablePtr& rhs) {
-    return *lhs == *rhs;
-  }
-
-  friend bool operator!=(const CopyablePtr& lhs, const CopyablePtr& rhs) {
-    // In theory the underlying type might have a special operator!=
-    // implementation which is not just !(x == y). Respect that.
-    return *lhs != *rhs;
-  }
-
- private:
-  std::unique_ptr<T> ptr_;
-};
-
-}  // namespace protozero
-
-#endif  // INCLUDE_PERFETTO_PROTOZERO_COPYABLE_PTR_H_
-// gen_amalgamated begin header: include/perfetto/protozero/cpp_message_obj.h
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef INCLUDE_PERFETTO_PROTOZERO_CPP_MESSAGE_OBJ_H_
-#define INCLUDE_PERFETTO_PROTOZERO_CPP_MESSAGE_OBJ_H_
-
-#include <stdint.h>
-
-#include <string>
-#include <vector>
-
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-
-namespace protozero {
-
-// Base class for generated .gen.h classes, which are full C++ objects that
-// support both ser and deserialization (but are not zero-copy).
-// This is only used by the "cpp" targets not the "pbzero" ones.
-class PERFETTO_EXPORT_COMPONENT CppMessageObj {
- public:
-  virtual ~CppMessageObj();
-  virtual std::string SerializeAsString() const = 0;
-  virtual std::vector<uint8_t> SerializeAsArray() const = 0;
-  virtual bool ParseFromArray(const void*, size_t) = 0;
-
-  bool ParseFromString(const std::string& str) {
-    return ParseFromArray(str.data(), str.size());
-  }
-};
-
-}  // namespace protozero
-
-#endif  // INCLUDE_PERFETTO_PROTOZERO_CPP_MESSAGE_OBJ_H_
-// gen_amalgamated begin header: include/perfetto/protozero/field.h
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef INCLUDE_PERFETTO_PROTOZERO_FIELD_H_
-#define INCLUDE_PERFETTO_PROTOZERO_FIELD_H_
-
-#include <stdint.h>
+  GetAsyncCommandResponse_StopDataSource();
+  ~GetAsyncCommandResponse_StopDataSource() override;
+  GetAsyncCommandResponse_StopDataSource(GetAsyncCommandResponse_StopDataSource&&) noexcept;
+  GetAsyncCommandResponse_StopDataSource& operator=(GetAsyncCommandResponse_StopDataSource&&);
+  GetAsyncCommandResponse_StopDataSource(const GetAsyncCommandResponse_StopDataSource&);
+  GetAsyncCommandResponse_StopDataSource& operator=(const GetAsyncCommandResponse_StopDataSource&);
+  bool operator==(const GetAsyncCommandResponse_StopDataSource&) const;
+  bool operator!=(const GetAsyncCommandResponse_StopDataSource& other) const { return !(*this == other); }
 
-#include <string>
-#include <vector>
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/contiguous_memory_range.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  bool has_instance_id() const { return _has_field_[1]; }
+  uint64_t instance_id() const { return instance_id_; }
+  void set_instance_id(uint64_t value) { instance_id_ = value; _has_field_.set(1); }
 
-namespace protozero {
+ private:
+  uint64_t instance_id_{};
 
-struct ConstBytes {
-  std::string ToStdString() const {
-    return std::string(reinterpret_cast<const char*>(data), size);
-  }
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  const uint8_t* data;
-  size_t size;
+  std::bitset<2> _has_field_{};
 };
 
-struct ConstChars {
-  // Allow implicit conversion to perfetto's base::StringView without depending
-  // on perfetto/base or viceversa.
-  static constexpr bool kConvertibleToStringView = true;
-  std::string ToStdString() const { return std::string(data, size); }
-
-  const char* data;
-  size_t size;
-};
 
-// A protobuf field decoded by the protozero proto decoders. It exposes
-// convenience accessors with minimal debug checks.
-// This class is used both by the iterator-based ProtoDecoder and by the
-// one-shot TypedProtoDecoder.
-// If the field is not valid the accessors consistently return zero-integers or
-// null strings.
-class Field {
+class PERFETTO_EXPORT_COMPONENT GetAsyncCommandResponse_StartDataSource : public ::protozero::CppMessageObj {
  public:
-  bool valid() const { return id_ != 0; }
-  uint16_t id() const { return id_; }
-  explicit operator bool() const { return valid(); }
+  enum FieldNumbers {
+    kNewInstanceIdFieldNumber = 1,
+    kConfigFieldNumber = 2,
+  };
 
-  proto_utils::ProtoWireType type() const {
-    auto res = static_cast<proto_utils::ProtoWireType>(type_);
-    PERFETTO_DCHECK(res == proto_utils::ProtoWireType::kVarInt ||
-                    res == proto_utils::ProtoWireType::kLengthDelimited ||
-                    res == proto_utils::ProtoWireType::kFixed32 ||
-                    res == proto_utils::ProtoWireType::kFixed64);
-    return res;
-  }
+  GetAsyncCommandResponse_StartDataSource();
+  ~GetAsyncCommandResponse_StartDataSource() override;
+  GetAsyncCommandResponse_StartDataSource(GetAsyncCommandResponse_StartDataSource&&) noexcept;
+  GetAsyncCommandResponse_StartDataSource& operator=(GetAsyncCommandResponse_StartDataSource&&);
+  GetAsyncCommandResponse_StartDataSource(const GetAsyncCommandResponse_StartDataSource&);
+  GetAsyncCommandResponse_StartDataSource& operator=(const GetAsyncCommandResponse_StartDataSource&);
+  bool operator==(const GetAsyncCommandResponse_StartDataSource&) const;
+  bool operator!=(const GetAsyncCommandResponse_StartDataSource& other) const { return !(*this == other); }
 
-  bool as_bool() const {
-    PERFETTO_DCHECK(!valid() || type() == proto_utils::ProtoWireType::kVarInt);
-    return static_cast<bool>(int_value_);
-  }
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  uint32_t as_uint32() const {
-    PERFETTO_DCHECK(!valid() || type() == proto_utils::ProtoWireType::kVarInt ||
-                    type() == proto_utils::ProtoWireType::kFixed32);
-    return static_cast<uint32_t>(int_value_);
-  }
+  bool has_new_instance_id() const { return _has_field_[1]; }
+  uint64_t new_instance_id() const { return new_instance_id_; }
+  void set_new_instance_id(uint64_t value) { new_instance_id_ = value; _has_field_.set(1); }
 
-  int32_t as_int32() const {
-    PERFETTO_DCHECK(!valid() || type() == proto_utils::ProtoWireType::kVarInt ||
-                    type() == proto_utils::ProtoWireType::kFixed32);
-    return static_cast<int32_t>(int_value_);
-  }
+  bool has_config() const { return _has_field_[2]; }
+  const DataSourceConfig& config() const { return *config_; }
+  DataSourceConfig* mutable_config() { _has_field_.set(2); return config_.get(); }
 
-  int32_t as_sint32() const {
-    PERFETTO_DCHECK(!valid() || type() == proto_utils::ProtoWireType::kVarInt);
-    return proto_utils::ZigZagDecode(static_cast<uint32_t>(int_value_));
-  }
+ private:
+  uint64_t new_instance_id_{};
+  ::protozero::CopyablePtr<DataSourceConfig> config_;
 
-  uint64_t as_uint64() const {
-    PERFETTO_DCHECK(!valid() || type() == proto_utils::ProtoWireType::kVarInt ||
-                    type() == proto_utils::ProtoWireType::kFixed32 ||
-                    type() == proto_utils::ProtoWireType::kFixed64);
-    return int_value_;
-  }
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  int64_t as_int64() const {
-    PERFETTO_DCHECK(!valid() || type() == proto_utils::ProtoWireType::kVarInt ||
-                    type() == proto_utils::ProtoWireType::kFixed32 ||
-                    type() == proto_utils::ProtoWireType::kFixed64);
-    return static_cast<int64_t>(int_value_);
-  }
+  std::bitset<3> _has_field_{};
+};
 
-  int64_t as_sint64() const {
-    PERFETTO_DCHECK(!valid() || type() == proto_utils::ProtoWireType::kVarInt);
-    return proto_utils::ZigZagDecode(static_cast<uint64_t>(int_value_));
-  }
 
-  float as_float() const {
-    PERFETTO_DCHECK(!valid() || type() == proto_utils::ProtoWireType::kFixed32);
-    float res;
-    uint32_t value32 = static_cast<uint32_t>(int_value_);
-    memcpy(&res, &value32, sizeof(res));
-    return res;
-  }
+class PERFETTO_EXPORT_COMPONENT GetAsyncCommandResponse_SetupDataSource : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kNewInstanceIdFieldNumber = 1,
+    kConfigFieldNumber = 2,
+  };
 
-  double as_double() const {
-    PERFETTO_DCHECK(!valid() || type() == proto_utils::ProtoWireType::kFixed64);
-    double res;
-    memcpy(&res, &int_value_, sizeof(res));
-    return res;
-  }
+  GetAsyncCommandResponse_SetupDataSource();
+  ~GetAsyncCommandResponse_SetupDataSource() override;
+  GetAsyncCommandResponse_SetupDataSource(GetAsyncCommandResponse_SetupDataSource&&) noexcept;
+  GetAsyncCommandResponse_SetupDataSource& operator=(GetAsyncCommandResponse_SetupDataSource&&);
+  GetAsyncCommandResponse_SetupDataSource(const GetAsyncCommandResponse_SetupDataSource&);
+  GetAsyncCommandResponse_SetupDataSource& operator=(const GetAsyncCommandResponse_SetupDataSource&);
+  bool operator==(const GetAsyncCommandResponse_SetupDataSource&) const;
+  bool operator!=(const GetAsyncCommandResponse_SetupDataSource& other) const { return !(*this == other); }
 
-  ConstChars as_string() const {
-    PERFETTO_DCHECK(!valid() ||
-                    type() == proto_utils::ProtoWireType::kLengthDelimited);
-    return ConstChars{reinterpret_cast<const char*>(data()), size_};
-  }
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  std::string as_std_string() const { return as_string().ToStdString(); }
+  bool has_new_instance_id() const { return _has_field_[1]; }
+  uint64_t new_instance_id() const { return new_instance_id_; }
+  void set_new_instance_id(uint64_t value) { new_instance_id_ = value; _has_field_.set(1); }
 
-  ConstBytes as_bytes() const {
-    PERFETTO_DCHECK(!valid() ||
-                    type() == proto_utils::ProtoWireType::kLengthDelimited);
-    return ConstBytes{data(), size_};
-  }
+  bool has_config() const { return _has_field_[2]; }
+  const DataSourceConfig& config() const { return *config_; }
+  DataSourceConfig* mutable_config() { _has_field_.set(2); return config_.get(); }
 
-  const uint8_t* data() const {
-    PERFETTO_DCHECK(!valid() ||
-                    type() == proto_utils::ProtoWireType::kLengthDelimited);
-    return reinterpret_cast<const uint8_t*>(int_value_);
-  }
+ private:
+  uint64_t new_instance_id_{};
+  ::protozero::CopyablePtr<DataSourceConfig> config_;
 
-  size_t size() const {
-    PERFETTO_DCHECK(!valid() ||
-                    type() == proto_utils::ProtoWireType::kLengthDelimited);
-    return size_;
-  }
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  uint64_t raw_int_value() const { return int_value_; }
+  std::bitset<3> _has_field_{};
+};
 
-  void initialize(uint16_t id,
-                  uint8_t type,
-                  uint64_t int_value,
-                  uint32_t size) {
-    id_ = id;
-    type_ = type;
-    int_value_ = int_value;
-    size_ = size;
-  }
 
-  // For use with templates. This is used by RepeatedFieldIterator::operator*().
-  void get(bool* val) const { *val = as_bool(); }
-  void get(uint32_t* val) const { *val = as_uint32(); }
-  void get(int32_t* val) const { *val = as_int32(); }
-  void get(uint64_t* val) const { *val = as_uint64(); }
-  void get(int64_t* val) const { *val = as_int64(); }
-  void get(float* val) const { *val = as_float(); }
-  void get(double* val) const { *val = as_double(); }
-  void get(std::string* val) const { *val = as_std_string(); }
-  void get(ConstChars* val) const { *val = as_string(); }
-  void get(ConstBytes* val) const { *val = as_bytes(); }
-  void get_signed(int32_t* val) const { *val = as_sint32(); }
-  void get_signed(int64_t* val) const { *val = as_sint64(); }
+class PERFETTO_EXPORT_COMPONENT GetAsyncCommandResponse_SetupTracing : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kSharedBufferPageSizeKbFieldNumber = 1,
+    kShmKeyWindowsFieldNumber = 2,
+  };
 
-  // For enum types.
-  template <typename T,
-            typename = typename std::enable_if<std::is_enum<T>::value, T>::type>
-  void get(T* val) const {
-    *val = static_cast<T>(as_int32());
-  }
+  GetAsyncCommandResponse_SetupTracing();
+  ~GetAsyncCommandResponse_SetupTracing() override;
+  GetAsyncCommandResponse_SetupTracing(GetAsyncCommandResponse_SetupTracing&&) noexcept;
+  GetAsyncCommandResponse_SetupTracing& operator=(GetAsyncCommandResponse_SetupTracing&&);
+  GetAsyncCommandResponse_SetupTracing(const GetAsyncCommandResponse_SetupTracing&);
+  GetAsyncCommandResponse_SetupTracing& operator=(const GetAsyncCommandResponse_SetupTracing&);
+  bool operator==(const GetAsyncCommandResponse_SetupTracing&) const;
+  bool operator!=(const GetAsyncCommandResponse_SetupTracing& other) const { return !(*this == other); }
 
-  // Serializes the field back into a proto-encoded byte stream and appends it
-  // to |dst|. |dst| is resized accordingly.
-  void SerializeAndAppendTo(std::string* dst) const;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Serializes the field back into a proto-encoded byte stream and appends it
-  // to |dst|. |dst| is resized accordingly.
-  void SerializeAndAppendTo(std::vector<uint8_t>* dst) const;
+  bool has_shared_buffer_page_size_kb() const { return _has_field_[1]; }
+  uint32_t shared_buffer_page_size_kb() const { return shared_buffer_page_size_kb_; }
+  void set_shared_buffer_page_size_kb(uint32_t value) { shared_buffer_page_size_kb_ = value; _has_field_.set(1); }
+
+  bool has_shm_key_windows() const { return _has_field_[2]; }
+  const std::string& shm_key_windows() const { return shm_key_windows_; }
+  void set_shm_key_windows(const std::string& value) { shm_key_windows_ = value; _has_field_.set(2); }
 
  private:
-  template <typename Container>
-  void SerializeAndAppendToInternal(Container* dst) const;
+  uint32_t shared_buffer_page_size_kb_{};
+  std::string shm_key_windows_{};
 
-  // Fields are deliberately not initialized to keep the class trivially
-  // constructible. It makes a large perf difference for ProtoDecoder.
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  uint64_t int_value_;  // In kLengthDelimited this contains the data() addr.
-  uint32_t size_;       // Only valid when when type == kLengthDelimited.
-  uint16_t id_;         // Proto field ordinal.
-  uint8_t type_;        // proto_utils::ProtoWireType.
+  std::bitset<3> _has_field_{};
 };
 
-// The Field struct is used in a lot of perf-sensitive contexts.
-static_assert(sizeof(Field) == 16, "Field struct too big");
 
-}  // namespace protozero
+class PERFETTO_EXPORT_COMPONENT GetAsyncCommandRequest : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+  };
 
-#endif  // INCLUDE_PERFETTO_PROTOZERO_FIELD_H_
-// gen_amalgamated begin header: include/perfetto/protozero/field_writer.h
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+  GetAsyncCommandRequest();
+  ~GetAsyncCommandRequest() override;
+  GetAsyncCommandRequest(GetAsyncCommandRequest&&) noexcept;
+  GetAsyncCommandRequest& operator=(GetAsyncCommandRequest&&);
+  GetAsyncCommandRequest(const GetAsyncCommandRequest&);
+  GetAsyncCommandRequest& operator=(const GetAsyncCommandRequest&);
+  bool operator==(const GetAsyncCommandRequest&) const;
+  bool operator!=(const GetAsyncCommandRequest& other) const { return !(*this == other); }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-#ifndef INCLUDE_PERFETTO_PROTOZERO_FIELD_WRITER_H_
-#define INCLUDE_PERFETTO_PROTOZERO_FIELD_WRITER_H_
+ private:
 
-namespace protozero {
-namespace internal {
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-template <proto_utils::ProtoSchemaType proto_schema_type>
-struct FieldWriter {
-  static_assert(proto_schema_type != proto_utils::ProtoSchemaType::kMessage,
-                "FieldWriter can't be used with nested messages");
+  std::bitset<2> _has_field_{};
 };
 
-template <>
-struct FieldWriter<proto_utils::ProtoSchemaType::kDouble> {
-  inline static void Append(Message& message, uint32_t field_id, double value) {
-    message.AppendFixed(field_id, value);
-  }
-};
 
-template <>
-struct FieldWriter<proto_utils::ProtoSchemaType::kFloat> {
-  inline static void Append(Message& message, uint32_t field_id, float value) {
-    message.AppendFixed(field_id, value);
-  }
-};
+class PERFETTO_EXPORT_COMPONENT ActivateTriggersResponse : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+  };
 
-template <>
-struct FieldWriter<proto_utils::ProtoSchemaType::kBool> {
-  inline static void Append(Message& message, uint32_t field_id, bool value) {
-    message.AppendTinyVarInt(field_id, value);
-  }
-};
+  ActivateTriggersResponse();
+  ~ActivateTriggersResponse() override;
+  ActivateTriggersResponse(ActivateTriggersResponse&&) noexcept;
+  ActivateTriggersResponse& operator=(ActivateTriggersResponse&&);
+  ActivateTriggersResponse(const ActivateTriggersResponse&);
+  ActivateTriggersResponse& operator=(const ActivateTriggersResponse&);
+  bool operator==(const ActivateTriggersResponse&) const;
+  bool operator!=(const ActivateTriggersResponse& other) const { return !(*this == other); }
 
-template <>
-struct FieldWriter<proto_utils::ProtoSchemaType::kInt32> {
-  inline static void Append(Message& message,
-                            uint32_t field_id,
-                            int32_t value) {
-    message.AppendVarInt(field_id, value);
-  }
-};
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-template <>
-struct FieldWriter<proto_utils::ProtoSchemaType::kInt64> {
-  inline static void Append(Message& message,
-                            uint32_t field_id,
-                            int64_t value) {
-    message.AppendVarInt(field_id, value);
-  }
-};
+ private:
 
-template <>
-struct FieldWriter<proto_utils::ProtoSchemaType::kUint32> {
-  inline static void Append(Message& message,
-                            uint32_t field_id,
-                            uint32_t value) {
-    message.AppendVarInt(field_id, value);
-  }
-};
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-template <>
-struct FieldWriter<proto_utils::ProtoSchemaType::kUint64> {
-  inline static void Append(Message& message,
-                            uint32_t field_id,
-                            uint64_t value) {
-    message.AppendVarInt(field_id, value);
-  }
+  std::bitset<2> _has_field_{};
 };
 
-template <>
-struct FieldWriter<proto_utils::ProtoSchemaType::kSint32> {
-  inline static void Append(Message& message,
-                            uint32_t field_id,
-                            int32_t value) {
-    message.AppendSignedVarInt(field_id, value);
-  }
-};
 
-template <>
-struct FieldWriter<proto_utils::ProtoSchemaType::kSint64> {
-  inline static void Append(Message& message,
-                            uint32_t field_id,
-                            int64_t value) {
-    message.AppendSignedVarInt(field_id, value);
-  }
-};
+class PERFETTO_EXPORT_COMPONENT ActivateTriggersRequest : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kTriggerNamesFieldNumber = 1,
+  };
 
-template <>
-struct FieldWriter<proto_utils::ProtoSchemaType::kFixed32> {
-  inline static void Append(Message& message,
-                            uint32_t field_id,
-                            uint32_t value) {
-    message.AppendFixed(field_id, value);
-  }
-};
+  ActivateTriggersRequest();
+  ~ActivateTriggersRequest() override;
+  ActivateTriggersRequest(ActivateTriggersRequest&&) noexcept;
+  ActivateTriggersRequest& operator=(ActivateTriggersRequest&&);
+  ActivateTriggersRequest(const ActivateTriggersRequest&);
+  ActivateTriggersRequest& operator=(const ActivateTriggersRequest&);
+  bool operator==(const ActivateTriggersRequest&) const;
+  bool operator!=(const ActivateTriggersRequest& other) const { return !(*this == other); }
 
-template <>
-struct FieldWriter<proto_utils::ProtoSchemaType::kFixed64> {
-  inline static void Append(Message& message,
-                            uint32_t field_id,
-                            uint64_t value) {
-    message.AppendFixed(field_id, value);
-  }
-};
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-template <>
-struct FieldWriter<proto_utils::ProtoSchemaType::kSfixed32> {
-  inline static void Append(Message& message,
-                            uint32_t field_id,
-                            int32_t value) {
-    message.AppendFixed(field_id, value);
-  }
-};
+  const std::vector<std::string>& trigger_names() const { return trigger_names_; }
+  std::vector<std::string>* mutable_trigger_names() { return &trigger_names_; }
+  int trigger_names_size() const { return static_cast<int>(trigger_names_.size()); }
+  void clear_trigger_names() { trigger_names_.clear(); }
+  void add_trigger_names(std::string value) { trigger_names_.emplace_back(value); }
+  std::string* add_trigger_names() { trigger_names_.emplace_back(); return &trigger_names_.back(); }
 
-template <>
-struct FieldWriter<proto_utils::ProtoSchemaType::kSfixed64> {
-  inline static void Append(Message& message,
-                            uint32_t field_id,
-                            int64_t value) {
-    message.AppendFixed(field_id, value);
-  }
-};
+ private:
+  std::vector<std::string> trigger_names_;
 
-template <>
-struct FieldWriter<proto_utils::ProtoSchemaType::kEnum> {
-  template <typename EnumType>
-  inline static void Append(Message& message,
-                            uint32_t field_id,
-                            EnumType value) {
-    message.AppendVarInt(field_id, value);
-  }
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<2> _has_field_{};
 };
 
-template <>
-struct FieldWriter<proto_utils::ProtoSchemaType::kString> {
-  inline static void Append(Message& message,
-                            uint32_t field_id,
-                            const char* data,
-                            size_t size) {
-    message.AppendBytes(field_id, data, size);
-  }
 
-  inline static void Append(Message& message,
-                            uint32_t field_id,
-                            const std::string& value) {
-    message.AppendBytes(field_id, value.data(), value.size());
-  }
-};
+class PERFETTO_EXPORT_COMPONENT NotifyDataSourceStoppedResponse : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+  };
 
-template <>
-struct FieldWriter<proto_utils::ProtoSchemaType::kBytes> {
-  inline static void Append(Message& message,
-                            uint32_t field_id,
-                            const uint8_t* data,
-                            size_t size) {
-    message.AppendBytes(field_id, data, size);
-  }
+  NotifyDataSourceStoppedResponse();
+  ~NotifyDataSourceStoppedResponse() override;
+  NotifyDataSourceStoppedResponse(NotifyDataSourceStoppedResponse&&) noexcept;
+  NotifyDataSourceStoppedResponse& operator=(NotifyDataSourceStoppedResponse&&);
+  NotifyDataSourceStoppedResponse(const NotifyDataSourceStoppedResponse&);
+  NotifyDataSourceStoppedResponse& operator=(const NotifyDataSourceStoppedResponse&);
+  bool operator==(const NotifyDataSourceStoppedResponse&) const;
+  bool operator!=(const NotifyDataSourceStoppedResponse& other) const { return !(*this == other); }
 
-  inline static void Append(Message& message,
-                            uint32_t field_id,
-                            const std::string& value) {
-    message.AppendBytes(field_id, value.data(), value.size());
-  }
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+ private:
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<2> _has_field_{};
 };
 
-}  // namespace internal
-}  // namespace protozero
 
-#endif  // INCLUDE_PERFETTO_PROTOZERO_FIELD_WRITER_H_
-// gen_amalgamated begin header: include/perfetto/protozero/gen_field_helpers.h
-/*
- * Copyright (C) 2023 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+class PERFETTO_EXPORT_COMPONENT NotifyDataSourceStoppedRequest : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kDataSourceIdFieldNumber = 1,
+  };
 
-#ifndef INCLUDE_PERFETTO_PROTOZERO_GEN_FIELD_HELPERS_H_
-#define INCLUDE_PERFETTO_PROTOZERO_GEN_FIELD_HELPERS_H_
+  NotifyDataSourceStoppedRequest();
+  ~NotifyDataSourceStoppedRequest() override;
+  NotifyDataSourceStoppedRequest(NotifyDataSourceStoppedRequest&&) noexcept;
+  NotifyDataSourceStoppedRequest& operator=(NotifyDataSourceStoppedRequest&&);
+  NotifyDataSourceStoppedRequest(const NotifyDataSourceStoppedRequest&);
+  NotifyDataSourceStoppedRequest& operator=(const NotifyDataSourceStoppedRequest&);
+  bool operator==(const NotifyDataSourceStoppedRequest&) const;
+  bool operator!=(const NotifyDataSourceStoppedRequest& other) const { return !(*this == other); }
 
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-namespace protozero {
-namespace internal {
-namespace gen_helpers {
+  bool has_data_source_id() const { return _has_field_[1]; }
+  uint64_t data_source_id() const { return data_source_id_; }
+  void set_data_source_id(uint64_t value) { data_source_id_ = value; _has_field_.set(1); }
 
-// This file implements some helpers used by the protobuf generated code in the
-// .gen.cc files.
-//
-// The .gen.cc generated protobuf implementation (as opposed to the .pbzero.h
-// implementation) is not zero-copy and is not supposed to be used in fast
-// paths, so most of these helpers are designed to reduce binary size.
+ private:
+  uint64_t data_source_id_{};
 
-void DeserializeString(const protozero::Field& field, std::string* dst);
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-// Read packed repeated elements (serialized as `wire_type`) from `field` into
-// the `*dst` vector. Returns false if some bytes of `field` could not be
-// interpreted correctly as `wire_type`.
-template <proto_utils::ProtoWireType wire_type, typename CppType>
-bool DeserializePackedRepeated(const protozero::Field& field,
-                               std::vector<CppType>* dst) {
-  bool parse_error = false;
-  for (::protozero::PackedRepeatedFieldIterator<wire_type, CppType> rep(
-           field.data(), field.size(), &parse_error);
-       rep; ++rep) {
-    dst->emplace_back(*rep);
-  }
-  return !parse_error;
-}
+  std::bitset<2> _has_field_{};
+};
 
-extern template bool
-DeserializePackedRepeated<proto_utils::ProtoWireType::kVarInt, uint64_t>(
-    const protozero::Field& field,
-    std::vector<uint64_t>* dst);
 
-extern template bool
-DeserializePackedRepeated<proto_utils::ProtoWireType::kVarInt, int64_t>(
-    const protozero::Field& field,
-    std::vector<int64_t>* dst);
+class PERFETTO_EXPORT_COMPONENT NotifyDataSourceStartedResponse : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+  };
 
-extern template bool
-DeserializePackedRepeated<proto_utils::ProtoWireType::kVarInt, uint32_t>(
-    const protozero::Field& field,
-    std::vector<uint32_t>* dst);
+  NotifyDataSourceStartedResponse();
+  ~NotifyDataSourceStartedResponse() override;
+  NotifyDataSourceStartedResponse(NotifyDataSourceStartedResponse&&) noexcept;
+  NotifyDataSourceStartedResponse& operator=(NotifyDataSourceStartedResponse&&);
+  NotifyDataSourceStartedResponse(const NotifyDataSourceStartedResponse&);
+  NotifyDataSourceStartedResponse& operator=(const NotifyDataSourceStartedResponse&);
+  bool operator==(const NotifyDataSourceStartedResponse&) const;
+  bool operator!=(const NotifyDataSourceStartedResponse& other) const { return !(*this == other); }
 
-extern template bool
-DeserializePackedRepeated<proto_utils::ProtoWireType::kVarInt, int32_t>(
-    const protozero::Field& field,
-    std::vector<int32_t>* dst);
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-// Serializers for different type of fields
+ private:
 
-void SerializeTinyVarInt(uint32_t field_id, bool value, Message* msg);
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-template <typename T>
-void SerializeExtendedVarInt(uint32_t field_id, T value, Message* msg) {
-  msg->AppendVarInt(field_id, value);
-}
+  std::bitset<2> _has_field_{};
+};
 
-extern template void SerializeExtendedVarInt<uint64_t>(uint32_t field_id,
-                                                       uint64_t value,
-                                                       Message* msg);
 
-extern template void SerializeExtendedVarInt<uint32_t>(uint32_t field_id,
-                                                       uint32_t value,
-                                                       Message* msg);
+class PERFETTO_EXPORT_COMPONENT NotifyDataSourceStartedRequest : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kDataSourceIdFieldNumber = 1,
+  };
 
-template <typename T>
-void SerializeVarInt(uint32_t field_id, T value, Message* msg) {
-  SerializeExtendedVarInt(
-      field_id, proto_utils::ExtendValueForVarIntSerialization(value), msg);
-}
+  NotifyDataSourceStartedRequest();
+  ~NotifyDataSourceStartedRequest() override;
+  NotifyDataSourceStartedRequest(NotifyDataSourceStartedRequest&&) noexcept;
+  NotifyDataSourceStartedRequest& operator=(NotifyDataSourceStartedRequest&&);
+  NotifyDataSourceStartedRequest(const NotifyDataSourceStartedRequest&);
+  NotifyDataSourceStartedRequest& operator=(const NotifyDataSourceStartedRequest&);
+  bool operator==(const NotifyDataSourceStartedRequest&) const;
+  bool operator!=(const NotifyDataSourceStartedRequest& other) const { return !(*this == other); }
 
-template <typename T>
-void SerializeSignedVarInt(uint32_t field_id, T value, Message* msg) {
-  SerializeVarInt(field_id, proto_utils::ZigZagEncode(value), msg);
-}
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-template <typename T>
-void SerializeFixed(uint32_t field_id, T value, Message* msg) {
-  msg->AppendFixed(field_id, value);
-}
+  bool has_data_source_id() const { return _has_field_[1]; }
+  uint64_t data_source_id() const { return data_source_id_; }
+  void set_data_source_id(uint64_t value) { data_source_id_ = value; _has_field_.set(1); }
 
-extern template void SerializeFixed<double>(uint32_t field_id,
-                                            double value,
-                                            Message* msg);
+ private:
+  uint64_t data_source_id_{};
 
-extern template void SerializeFixed<float>(uint32_t field_id,
-                                           float value,
-                                           Message* msg);
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-extern template void SerializeFixed<uint64_t>(uint32_t field_id,
-                                              uint64_t value,
-                                              Message* msg);
+  std::bitset<2> _has_field_{};
+};
 
-extern template void SerializeFixed<int64_t>(uint32_t field_id,
-                                             int64_t value,
-                                             Message* msg);
 
-extern template void SerializeFixed<uint32_t>(uint32_t field_id,
-                                              uint32_t value,
-                                              Message* msg);
+class PERFETTO_EXPORT_COMPONENT CommitDataResponse : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+  };
 
-extern template void SerializeFixed<int32_t>(uint32_t field_id,
-                                             int32_t value,
-                                             Message* msg);
+  CommitDataResponse();
+  ~CommitDataResponse() override;
+  CommitDataResponse(CommitDataResponse&&) noexcept;
+  CommitDataResponse& operator=(CommitDataResponse&&);
+  CommitDataResponse(const CommitDataResponse&);
+  CommitDataResponse& operator=(const CommitDataResponse&);
+  bool operator==(const CommitDataResponse&) const;
+  bool operator!=(const CommitDataResponse& other) const { return !(*this == other); }
 
-void SerializeString(uint32_t field_id, const std::string& value, Message* msg);
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-void SerializeUnknownFields(const std::string& unknown_fields, Message* msg);
+ private:
 
-// Wrapper around HeapBuffered that avoids inlining.
-class MessageSerializer {
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<2> _has_field_{};
+};
+
+
+class PERFETTO_EXPORT_COMPONENT UnregisterTraceWriterResponse : public ::protozero::CppMessageObj {
  public:
-  MessageSerializer();
-  ~MessageSerializer();
+  enum FieldNumbers {
+  };
 
-  Message* get() { return msg_.get(); }
-  std::vector<uint8_t> SerializeAsArray();
-  std::string SerializeAsString();
+  UnregisterTraceWriterResponse();
+  ~UnregisterTraceWriterResponse() override;
+  UnregisterTraceWriterResponse(UnregisterTraceWriterResponse&&) noexcept;
+  UnregisterTraceWriterResponse& operator=(UnregisterTraceWriterResponse&&);
+  UnregisterTraceWriterResponse(const UnregisterTraceWriterResponse&);
+  UnregisterTraceWriterResponse& operator=(const UnregisterTraceWriterResponse&);
+  bool operator==(const UnregisterTraceWriterResponse&) const;
+  bool operator!=(const UnregisterTraceWriterResponse& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
  private:
-  HeapBuffered<Message> msg_;
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<2> _has_field_{};
 };
 
-}  // namespace gen_helpers
-}  // namespace internal
-}  // namespace protozero
 
-#endif  // INCLUDE_PERFETTO_PROTOZERO_GEN_FIELD_HELPERS_H_
-// gen_amalgamated begin header: include/perfetto/protozero/message.h
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+class PERFETTO_EXPORT_COMPONENT UnregisterTraceWriterRequest : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kTraceWriterIdFieldNumber = 1,
+  };
 
-#ifndef INCLUDE_PERFETTO_PROTOZERO_MESSAGE_H_
-#define INCLUDE_PERFETTO_PROTOZERO_MESSAGE_H_
+  UnregisterTraceWriterRequest();
+  ~UnregisterTraceWriterRequest() override;
+  UnregisterTraceWriterRequest(UnregisterTraceWriterRequest&&) noexcept;
+  UnregisterTraceWriterRequest& operator=(UnregisterTraceWriterRequest&&);
+  UnregisterTraceWriterRequest(const UnregisterTraceWriterRequest&);
+  UnregisterTraceWriterRequest& operator=(const UnregisterTraceWriterRequest&);
+  bool operator==(const UnregisterTraceWriterRequest&) const;
+  bool operator!=(const UnregisterTraceWriterRequest& other) const { return !(*this == other); }
 
-#include <assert.h>
-#include <stdint.h>
-#include <string.h>
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-#include <string>
-#include <type_traits>
+  bool has_trace_writer_id() const { return _has_field_[1]; }
+  uint32_t trace_writer_id() const { return trace_writer_id_; }
+  void set_trace_writer_id(uint32_t value) { trace_writer_id_ = value; _has_field_.set(1); }
 
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/contiguous_memory_range.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_stream_writer.h"
+ private:
+  uint32_t trace_writer_id_{};
 
-namespace perfetto {
-namespace shm_fuzz {
-class FakeProducer;
-}  // namespace shm_fuzz
-}  // namespace perfetto
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-namespace protozero {
+  std::bitset<2> _has_field_{};
+};
 
-class MessageArena;
-class MessageHandleBase;
 
-// Base class extended by the proto C++ stubs generated by the ProtoZero
-// compiler. This class provides the minimal runtime required to support
-// append-only operations and is designed for performance. None of the methods
-// require any dynamic memory allocation, unless more than 16 nested messages
-// are created via BeginNestedMessage() calls.
-class PERFETTO_EXPORT_COMPONENT Message {
+class PERFETTO_EXPORT_COMPONENT RegisterTraceWriterResponse : public ::protozero::CppMessageObj {
  public:
-  friend class MessageHandleBase;
+  enum FieldNumbers {
+  };
 
-  // The ctor is deliberately a no-op to avoid forwarding args from all
-  // subclasses. The real initialization is performed by Reset().
-  // Nested messages are allocated via placement new by MessageArena and
-  // implictly destroyed when the RootMessage's arena goes away. This is
-  // fine as long as all the fields are PODs, which is checked by the
-  // static_assert()s in the Reset() method.
-  Message() = default;
+  RegisterTraceWriterResponse();
+  ~RegisterTraceWriterResponse() override;
+  RegisterTraceWriterResponse(RegisterTraceWriterResponse&&) noexcept;
+  RegisterTraceWriterResponse& operator=(RegisterTraceWriterResponse&&);
+  RegisterTraceWriterResponse(const RegisterTraceWriterResponse&);
+  RegisterTraceWriterResponse& operator=(const RegisterTraceWriterResponse&);
+  bool operator==(const RegisterTraceWriterResponse&) const;
+  bool operator!=(const RegisterTraceWriterResponse& other) const { return !(*this == other); }
 
-  // Clears up the state, allowing the message to be reused as a fresh one.
-  void Reset(ScatteredStreamWriter*, MessageArena*);
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Commits all the changes to the buffer (backfills the size field of this and
-  // all nested messages) and seals the message. Returns the size of the message
-  // (and all nested sub-messages), without taking into account any chunking.
-  // Finalize is idempotent and can be called several times w/o side effects.
-  uint32_t Finalize();
+ private:
 
-  // Optional. If is_valid() == true, the corresponding memory region (its
-  // length == proto_utils::kMessageLengthFieldSize) is backfilled with the size
-  // of this message (minus |size_already_written| below). This is the mechanism
-  // used by messages to backfill their corresponding size field in the parent
-  // message.
-  uint8_t* size_field() const { return size_field_; }
-  void set_size_field(uint8_t* size_field) { size_field_ = size_field; }
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  // This is to deal with case of backfilling the size of a root (non-nested)
-  // message which is split into multiple chunks. Upon finalization only the
-  // partial size that lies in the last chunk has to be backfilled.
-  void inc_size_already_written(uint32_t sz) { size_already_written_ += sz; }
+  std::bitset<2> _has_field_{};
+};
 
-  Message* nested_message() { return nested_message_; }
 
-  bool is_finalized() const { return finalized_; }
+class PERFETTO_EXPORT_COMPONENT RegisterTraceWriterRequest : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kTraceWriterIdFieldNumber = 1,
+    kTargetBufferFieldNumber = 2,
+  };
 
-#if PERFETTO_DCHECK_IS_ON()
-  void set_handle(MessageHandleBase* handle) { handle_ = handle; }
-#endif
+  RegisterTraceWriterRequest();
+  ~RegisterTraceWriterRequest() override;
+  RegisterTraceWriterRequest(RegisterTraceWriterRequest&&) noexcept;
+  RegisterTraceWriterRequest& operator=(RegisterTraceWriterRequest&&);
+  RegisterTraceWriterRequest(const RegisterTraceWriterRequest&);
+  RegisterTraceWriterRequest& operator=(const RegisterTraceWriterRequest&);
+  bool operator==(const RegisterTraceWriterRequest&) const;
+  bool operator!=(const RegisterTraceWriterRequest& other) const { return !(*this == other); }
 
-  // Proto types: uint64, uint32, int64, int32, bool, enum.
-  template <typename T>
-  void AppendVarInt(uint32_t field_id, T value) {
-    if (nested_message_)
-      EndNestedMessage();
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-    uint8_t buffer[proto_utils::kMaxSimpleFieldEncodedSize];
-    uint8_t* pos = buffer;
+  bool has_trace_writer_id() const { return _has_field_[1]; }
+  uint32_t trace_writer_id() const { return trace_writer_id_; }
+  void set_trace_writer_id(uint32_t value) { trace_writer_id_ = value; _has_field_.set(1); }
 
-    pos = proto_utils::WriteVarInt(proto_utils::MakeTagVarInt(field_id), pos);
-    // WriteVarInt encodes signed values in two's complement form.
-    pos = proto_utils::WriteVarInt(value, pos);
-    WriteToStream(buffer, pos);
-  }
+  bool has_target_buffer() const { return _has_field_[2]; }
+  uint32_t target_buffer() const { return target_buffer_; }
+  void set_target_buffer(uint32_t value) { target_buffer_ = value; _has_field_.set(2); }
 
-  // Proto types: sint64, sint32.
-  template <typename T>
-  void AppendSignedVarInt(uint32_t field_id, T value) {
-    AppendVarInt(field_id, proto_utils::ZigZagEncode(value));
-  }
+ private:
+  uint32_t trace_writer_id_{};
+  uint32_t target_buffer_{};
 
-  // Proto types: bool, enum (small).
-  // Faster version of AppendVarInt for tiny numbers.
-  void AppendTinyVarInt(uint32_t field_id, int32_t value) {
-    PERFETTO_DCHECK(0 <= value && value < 0x80);
-    if (nested_message_)
-      EndNestedMessage();
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-    uint8_t buffer[proto_utils::kMaxSimpleFieldEncodedSize];
-    uint8_t* pos = buffer;
-    // MakeTagVarInt gets super optimized here for constexpr.
-    pos = proto_utils::WriteVarInt(proto_utils::MakeTagVarInt(field_id), pos);
-    *pos++ = static_cast<uint8_t>(value);
-    WriteToStream(buffer, pos);
-  }
+  std::bitset<3> _has_field_{};
+};
 
-  // Proto types: fixed64, sfixed64, fixed32, sfixed32, double, float.
-  template <typename T>
-  void AppendFixed(uint32_t field_id, T value) {
-    if (nested_message_)
-      EndNestedMessage();
 
-    uint8_t buffer[proto_utils::kMaxSimpleFieldEncodedSize];
-    uint8_t* pos = buffer;
+class PERFETTO_EXPORT_COMPONENT UnregisterDataSourceResponse : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+  };
 
-    pos = proto_utils::WriteVarInt(proto_utils::MakeTagFixed<T>(field_id), pos);
-    memcpy(pos, &value, sizeof(T));
-    pos += sizeof(T);
-    // TODO: Optimize memcpy performance, see http://crbug.com/624311 .
-    WriteToStream(buffer, pos);
-  }
+  UnregisterDataSourceResponse();
+  ~UnregisterDataSourceResponse() override;
+  UnregisterDataSourceResponse(UnregisterDataSourceResponse&&) noexcept;
+  UnregisterDataSourceResponse& operator=(UnregisterDataSourceResponse&&);
+  UnregisterDataSourceResponse(const UnregisterDataSourceResponse&);
+  UnregisterDataSourceResponse& operator=(const UnregisterDataSourceResponse&);
+  bool operator==(const UnregisterDataSourceResponse&) const;
+  bool operator!=(const UnregisterDataSourceResponse& other) const { return !(*this == other); }
 
-  void AppendString(uint32_t field_id, const char* str);
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  void AppendString(uint32_t field_id, const std::string& str) {
-    AppendBytes(field_id, str.data(), str.size());
-  }
+ private:
 
-  void AppendBytes(uint32_t field_id, const void* value, size_t size);
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  // Append raw bytes for a field, using the supplied |ranges| to
-  // copy from |num_ranges| individual buffers.
-  size_t AppendScatteredBytes(uint32_t field_id,
-                              ContiguousMemoryRange* ranges,
-                              size_t num_ranges);
+  std::bitset<2> _has_field_{};
+};
 
-  // Begins a nested message. The returned object is owned by the MessageArena
-  // of the root message. The nested message ends either when Finalize() is
-  // called or when any other Append* method is called in the parent class.
-  // The template argument T is supposed to be a stub class auto generated from
-  // a .proto, hence a subclass of Message.
-  template <class T>
-  T* BeginNestedMessage(uint32_t field_id) {
-    // This is to prevent subclasses (which should be autogenerated, though), to
-    // introduce extra state fields (which wouldn't be initialized by Reset()).
-    static_assert(std::is_base_of<Message, T>::value,
-                  "T must be a subclass of Message");
-    static_assert(sizeof(T) == sizeof(Message),
-                  "Message subclasses cannot introduce extra state.");
-    return static_cast<T*>(BeginNestedMessageInternal(field_id));
-  }
 
-  // Gives read-only access to the underlying stream_writer. This is used only
-  // by few internals to query the state of the underlying buffer. It is almost
-  // always a bad idea to poke at the stream_writer() internals.
-  const ScatteredStreamWriter* stream_writer() const { return stream_writer_; }
+class PERFETTO_EXPORT_COMPONENT UnregisterDataSourceRequest : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kDataSourceNameFieldNumber = 1,
+  };
 
-  // Appends some raw bytes to the message. The use-case for this is preserving
-  // unknown fields in the decode -> re-encode path of xxx.gen.cc classes
-  // generated by the cppgen_plugin.cc.
-  // The caller needs to guarantee that the appended data is properly
-  // proto-encoded and each field has a proto preamble.
-  void AppendRawProtoBytes(const void* data, size_t size) {
-    const uint8_t* src = reinterpret_cast<const uint8_t*>(data);
-    WriteToStream(src, src + size);
-  }
+  UnregisterDataSourceRequest();
+  ~UnregisterDataSourceRequest() override;
+  UnregisterDataSourceRequest(UnregisterDataSourceRequest&&) noexcept;
+  UnregisterDataSourceRequest& operator=(UnregisterDataSourceRequest&&);
+  UnregisterDataSourceRequest(const UnregisterDataSourceRequest&);
+  UnregisterDataSourceRequest& operator=(const UnregisterDataSourceRequest&);
+  bool operator==(const UnregisterDataSourceRequest&) const;
+  bool operator!=(const UnregisterDataSourceRequest& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_data_source_name() const { return _has_field_[1]; }
+  const std::string& data_source_name() const { return data_source_name_; }
+  void set_data_source_name(const std::string& value) { data_source_name_ = value; _has_field_.set(1); }
 
  private:
-  Message(const Message&) = delete;
-  Message& operator=(const Message&) = delete;
+  std::string data_source_name_{};
 
-  Message* BeginNestedMessageInternal(uint32_t field_id);
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  // Called by Finalize and Append* methods.
-  void EndNestedMessage();
+  std::bitset<2> _has_field_{};
+};
 
-  void WriteToStream(const uint8_t* src_begin, const uint8_t* src_end) {
-    PERFETTO_DCHECK(!finalized_);
-    PERFETTO_DCHECK(src_begin <= src_end);
-    const uint32_t size = static_cast<uint32_t>(src_end - src_begin);
-    stream_writer_->WriteBytes(src_begin, size);
-    size_ += size;
-  }
 
-  // Only POD fields are allowed. This class's dtor is never called.
-  // See the comment on the static_assert in the corresponding .cc file.
+class PERFETTO_EXPORT_COMPONENT UpdateDataSourceResponse : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+  };
 
-  // The stream writer interface used for the serialization.
-  ScatteredStreamWriter* stream_writer_;
+  UpdateDataSourceResponse();
+  ~UpdateDataSourceResponse() override;
+  UpdateDataSourceResponse(UpdateDataSourceResponse&&) noexcept;
+  UpdateDataSourceResponse& operator=(UpdateDataSourceResponse&&);
+  UpdateDataSourceResponse(const UpdateDataSourceResponse&);
+  UpdateDataSourceResponse& operator=(const UpdateDataSourceResponse&);
+  bool operator==(const UpdateDataSourceResponse&) const;
+  bool operator!=(const UpdateDataSourceResponse& other) const { return !(*this == other); }
 
-  // The storage used to allocate nested Message objects.
-  // This is owned by RootMessage<T>.
-  MessageArena* arena_;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Pointer to the last child message created through BeginNestedMessage(), if
-  // any, nullptr otherwise. There is no need to keep track of more than one
-  // message per nesting level as the proto-zero API contract mandates that
-  // nested fields can be filled only in a stacked fashion. In other words,
-  // nested messages are finalized and sealed when any other field is set in the
-  // parent message (or the parent message itself is finalized) and cannot be
-  // accessed anymore afterwards.
-  Message* nested_message_;
+ private:
 
-  // [optional] Pointer to a non-aligned pre-reserved var-int slot of
-  // kMessageLengthFieldSize bytes. When set, the Finalize() method will write
-  // the size of proto-encoded message in the pointed memory region.
-  uint8_t* size_field_;
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  // Keeps track of the size of the current message.
-  uint32_t size_;
+  std::bitset<2> _has_field_{};
+};
+
+
+class PERFETTO_EXPORT_COMPONENT UpdateDataSourceRequest : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kDataSourceDescriptorFieldNumber = 1,
+  };
+
+  UpdateDataSourceRequest();
+  ~UpdateDataSourceRequest() override;
+  UpdateDataSourceRequest(UpdateDataSourceRequest&&) noexcept;
+  UpdateDataSourceRequest& operator=(UpdateDataSourceRequest&&);
+  UpdateDataSourceRequest(const UpdateDataSourceRequest&);
+  UpdateDataSourceRequest& operator=(const UpdateDataSourceRequest&);
+  bool operator==(const UpdateDataSourceRequest&) const;
+  bool operator!=(const UpdateDataSourceRequest& other) const { return !(*this == other); }
 
-  // See comment for inc_size_already_written().
-  uint32_t size_already_written_;
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // When true, no more changes to the message are allowed. This is to DCHECK
-  // attempts of writing to a message which has been Finalize()-d.
-  bool finalized_;
+  bool has_data_source_descriptor() const { return _has_field_[1]; }
+  const DataSourceDescriptor& data_source_descriptor() const { return *data_source_descriptor_; }
+  DataSourceDescriptor* mutable_data_source_descriptor() { _has_field_.set(1); return data_source_descriptor_.get(); }
 
-#if PERFETTO_DCHECK_IS_ON()
-  // Current generation of message. Incremented on Reset.
-  // Used to detect stale handles.
-  uint32_t generation_;
+ private:
+  ::protozero::CopyablePtr<DataSourceDescriptor> data_source_descriptor_;
 
-  MessageHandleBase* handle_;
-#endif
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<2> _has_field_{};
 };
 
-}  // namespace protozero
 
-#endif  // INCLUDE_PERFETTO_PROTOZERO_MESSAGE_H_
-// gen_amalgamated begin header: include/perfetto/protozero/message_arena.h
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+class PERFETTO_EXPORT_COMPONENT RegisterDataSourceResponse : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kErrorFieldNumber = 1,
+  };
 
-#ifndef INCLUDE_PERFETTO_PROTOZERO_MESSAGE_ARENA_H_
-#define INCLUDE_PERFETTO_PROTOZERO_MESSAGE_ARENA_H_
+  RegisterDataSourceResponse();
+  ~RegisterDataSourceResponse() override;
+  RegisterDataSourceResponse(RegisterDataSourceResponse&&) noexcept;
+  RegisterDataSourceResponse& operator=(RegisterDataSourceResponse&&);
+  RegisterDataSourceResponse(const RegisterDataSourceResponse&);
+  RegisterDataSourceResponse& operator=(const RegisterDataSourceResponse&);
+  bool operator==(const RegisterDataSourceResponse&) const;
+  bool operator!=(const RegisterDataSourceResponse& other) const { return !(*this == other); }
 
-#include <stdint.h>
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-#include <forward_list>
-#include <type_traits>
+  bool has_error() const { return _has_field_[1]; }
+  const std::string& error() const { return error_; }
+  void set_error(const std::string& value) { error_ = value; _has_field_.set(1); }
 
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+ private:
+  std::string error_{};
 
-namespace protozero {
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-class Message;
+  std::bitset<2> _has_field_{};
+};
 
-// Object allocator for fixed-sized protozero::Message objects.
-// It's a simple bump-pointer allocator which leverages the stack-alike
-// usage pattern of protozero nested messages. It avoids hitting the system
-// allocator in most cases, by reusing the same block, and falls back on
-// allocating new blocks only when using deeply nested messages (which are
-// extremely rare).
-// This is used by RootMessage<T> to handle the storage for root-level messages.
-class PERFETTO_EXPORT_COMPONENT MessageArena {
- public:
-  MessageArena();
-  ~MessageArena();
 
-  // Strictly no copies or moves as this is used to hand out pointers.
-  MessageArena(const MessageArena&) = delete;
-  MessageArena& operator=(const MessageArena&) = delete;
-  MessageArena(MessageArena&&) = delete;
-  MessageArena& operator=(MessageArena&&) = delete;
+class PERFETTO_EXPORT_COMPONENT RegisterDataSourceRequest : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kDataSourceDescriptorFieldNumber = 1,
+  };
 
-  // Allocates a new Message object.
-  Message* NewMessage();
+  RegisterDataSourceRequest();
+  ~RegisterDataSourceRequest() override;
+  RegisterDataSourceRequest(RegisterDataSourceRequest&&) noexcept;
+  RegisterDataSourceRequest& operator=(RegisterDataSourceRequest&&);
+  RegisterDataSourceRequest(const RegisterDataSourceRequest&);
+  RegisterDataSourceRequest& operator=(const RegisterDataSourceRequest&);
+  bool operator==(const RegisterDataSourceRequest&) const;
+  bool operator!=(const RegisterDataSourceRequest& other) const { return !(*this == other); }
 
-  // Deletes the last message allocated. The |msg| argument is used only for
-  // DCHECKs, it MUST be the pointer obtained by the last NewMessage() call.
-  void DeleteLastMessage(Message* msg) {
-    PERFETTO_DCHECK(!blocks_.empty() && blocks_.front().entries > 0);
-    PERFETTO_DCHECK(&blocks_.front().storage[blocks_.front().entries - 1] ==
-                    static_cast<void*>(msg));
-    DeleteLastMessageInternal();
-  }
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Resets the state of the arena, clearing up all but one block. This is used
-  // to avoid leaking outstanding unfinished sub-messages while recycling the
-  // RootMessage object (this is extremely rare due to the RAII scoped handles
-  // but could happen if some client does some overly clever std::move() trick).
-  void Reset() {
-    PERFETTO_DCHECK(!blocks_.empty());
-    blocks_.resize(1);
-    auto& block = blocks_.front();
-    block.entries = 0;
-    PERFETTO_ASAN_POISON(block.storage, sizeof(block.storage));
-  }
+  bool has_data_source_descriptor() const { return _has_field_[1]; }
+  const DataSourceDescriptor& data_source_descriptor() const { return *data_source_descriptor_; }
+  DataSourceDescriptor* mutable_data_source_descriptor() { _has_field_.set(1); return data_source_descriptor_.get(); }
 
  private:
-  void DeleteLastMessageInternal();
+  ::protozero::CopyablePtr<DataSourceDescriptor> data_source_descriptor_;
 
-  struct Block {
-    static constexpr size_t kCapacity = 16;
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-    Block() { PERFETTO_ASAN_POISON(storage, sizeof(storage)); }
+  std::bitset<2> _has_field_{};
+};
 
-    std::aligned_storage<sizeof(Message), alignof(Message)>::type
-        storage[kCapacity];
-    uint32_t entries = 0;  // # Message entries used (<= kCapacity).
+
+class PERFETTO_EXPORT_COMPONENT InitializeConnectionResponse : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kUsingShmemProvidedByProducerFieldNumber = 1,
+    kDirectSmbPatchingSupportedFieldNumber = 2,
+    kUseShmemEmulationFieldNumber = 3,
   };
 
-  // blocks are used to hand out pointers and must not be moved. Hence why
-  // std::list rather than std::vector.
-  std::forward_list<Block> blocks_;
-};
+  InitializeConnectionResponse();
+  ~InitializeConnectionResponse() override;
+  InitializeConnectionResponse(InitializeConnectionResponse&&) noexcept;
+  InitializeConnectionResponse& operator=(InitializeConnectionResponse&&);
+  InitializeConnectionResponse(const InitializeConnectionResponse&);
+  InitializeConnectionResponse& operator=(const InitializeConnectionResponse&);
+  bool operator==(const InitializeConnectionResponse&) const;
+  bool operator!=(const InitializeConnectionResponse& other) const { return !(*this == other); }
 
-}  // namespace protozero
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-#endif  // INCLUDE_PERFETTO_PROTOZERO_MESSAGE_ARENA_H_
-// gen_amalgamated begin header: include/perfetto/protozero/message_handle.h
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+  bool has_using_shmem_provided_by_producer() const { return _has_field_[1]; }
+  bool using_shmem_provided_by_producer() const { return using_shmem_provided_by_producer_; }
+  void set_using_shmem_provided_by_producer(bool value) { using_shmem_provided_by_producer_ = value; _has_field_.set(1); }
 
-#ifndef INCLUDE_PERFETTO_PROTOZERO_MESSAGE_HANDLE_H_
-#define INCLUDE_PERFETTO_PROTOZERO_MESSAGE_HANDLE_H_
+  bool has_direct_smb_patching_supported() const { return _has_field_[2]; }
+  bool direct_smb_patching_supported() const { return direct_smb_patching_supported_; }
+  void set_direct_smb_patching_supported(bool value) { direct_smb_patching_supported_ = value; _has_field_.set(2); }
 
-#include <functional>
+  bool has_use_shmem_emulation() const { return _has_field_[3]; }
+  bool use_shmem_emulation() const { return use_shmem_emulation_; }
+  void set_use_shmem_emulation(bool value) { use_shmem_emulation_ = value; _has_field_.set(3); }
 
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_stream_writer.h"
+ private:
+  bool using_shmem_provided_by_producer_{};
+  bool direct_smb_patching_supported_{};
+  bool use_shmem_emulation_{};
 
-namespace protozero {
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-class Message;
+  std::bitset<4> _has_field_{};
+};
 
-// MessageHandle allows to decouple the lifetime of a proto message
-// from the underlying storage. It gives the following guarantees:
-// - The underlying message is finalized (if still alive) if the handle goes
-//   out of scope.
-// - In Debug / DCHECK_ALWAYS_ON builds, the handle becomes null once the
-//   message is finalized. This is to enforce the append-only API. For instance
-//   when adding two repeated messages, the addition of the 2nd one forces
-//   the finalization of the first.
-// Think about this as a WeakPtr<Message> which calls
-// Message::Finalize() when going out of scope.
 
-class PERFETTO_EXPORT_COMPONENT MessageHandleBase {
+class PERFETTO_EXPORT_COMPONENT InitializeConnectionRequest : public ::protozero::CppMessageObj {
  public:
-  ~MessageHandleBase();
-
-  // Move-only type.
-  MessageHandleBase(MessageHandleBase&&) noexcept;
-  MessageHandleBase& operator=(MessageHandleBase&&);
-  explicit operator bool() const {
-#if PERFETTO_DCHECK_IS_ON()
-    PERFETTO_DCHECK(!message_ || generation_ == message_->generation_);
-#endif
-    return !!message_;
-  }
+  using ProducerSMBScrapingMode = InitializeConnectionRequest_ProducerSMBScrapingMode;
+  static constexpr auto SMB_SCRAPING_UNSPECIFIED = InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_UNSPECIFIED;
+  static constexpr auto SMB_SCRAPING_ENABLED = InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_ENABLED;
+  static constexpr auto SMB_SCRAPING_DISABLED = InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_DISABLED;
+  static constexpr auto ProducerSMBScrapingMode_MIN = InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_UNSPECIFIED;
+  static constexpr auto ProducerSMBScrapingMode_MAX = InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_DISABLED;
+  enum FieldNumbers {
+    kSharedMemoryPageSizeHintBytesFieldNumber = 1,
+    kSharedMemorySizeHintBytesFieldNumber = 2,
+    kProducerNameFieldNumber = 3,
+    kSmbScrapingModeFieldNumber = 4,
+    kProducerProvidedShmemFieldNumber = 6,
+    kSdkVersionFieldNumber = 8,
+    kShmKeyWindowsFieldNumber = 7,
+  };
 
-  // Returns a (non-owned, it should not be deleted) pointer to the
-  // ScatteredStreamWriter used to write the message data. The Message becomes
-  // unusable after this point.
-  //
-  // The caller can now write directly, without using protozero::Message.
-  ScatteredStreamWriter* TakeStreamWriter() {
-    ScatteredStreamWriter* stream_writer = message_->stream_writer_;
-#if PERFETTO_DCHECK_IS_ON()
-    message_->set_handle(nullptr);
-#endif
-    message_ = nullptr;
-    return stream_writer;
-  }
+  InitializeConnectionRequest();
+  ~InitializeConnectionRequest() override;
+  InitializeConnectionRequest(InitializeConnectionRequest&&) noexcept;
+  InitializeConnectionRequest& operator=(InitializeConnectionRequest&&);
+  InitializeConnectionRequest(const InitializeConnectionRequest&);
+  InitializeConnectionRequest& operator=(const InitializeConnectionRequest&);
+  bool operator==(const InitializeConnectionRequest&) const;
+  bool operator!=(const InitializeConnectionRequest& other) const { return !(*this == other); }
 
- protected:
-  explicit MessageHandleBase(Message* = nullptr);
-  Message* operator->() const {
-#if PERFETTO_DCHECK_IS_ON()
-    PERFETTO_DCHECK(!message_ || generation_ == message_->generation_);
-#endif
-    return message_;
-  }
-  Message& operator*() const { return *(operator->()); }
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
- private:
-  friend class Message;
-  MessageHandleBase(const MessageHandleBase&) = delete;
-  MessageHandleBase& operator=(const MessageHandleBase&) = delete;
+  bool has_shared_memory_page_size_hint_bytes() const { return _has_field_[1]; }
+  uint32_t shared_memory_page_size_hint_bytes() const { return shared_memory_page_size_hint_bytes_; }
+  void set_shared_memory_page_size_hint_bytes(uint32_t value) { shared_memory_page_size_hint_bytes_ = value; _has_field_.set(1); }
 
-  void reset_message() {
-    // This is called by Message::Finalize().
-    PERFETTO_DCHECK(message_->is_finalized());
-    message_ = nullptr;
-  }
+  bool has_shared_memory_size_hint_bytes() const { return _has_field_[2]; }
+  uint32_t shared_memory_size_hint_bytes() const { return shared_memory_size_hint_bytes_; }
+  void set_shared_memory_size_hint_bytes(uint32_t value) { shared_memory_size_hint_bytes_ = value; _has_field_.set(2); }
 
-  void Move(MessageHandleBase&&);
+  bool has_producer_name() const { return _has_field_[3]; }
+  const std::string& producer_name() const { return producer_name_; }
+  void set_producer_name(const std::string& value) { producer_name_ = value; _has_field_.set(3); }
 
-  void FinalizeMessage() { message_->Finalize(); }
+  bool has_smb_scraping_mode() const { return _has_field_[4]; }
+  InitializeConnectionRequest_ProducerSMBScrapingMode smb_scraping_mode() const { return smb_scraping_mode_; }
+  void set_smb_scraping_mode(InitializeConnectionRequest_ProducerSMBScrapingMode value) { smb_scraping_mode_ = value; _has_field_.set(4); }
 
-  Message* message_;
-#if PERFETTO_DCHECK_IS_ON()
-  uint32_t generation_;
-#endif
-};
+  bool has_producer_provided_shmem() const { return _has_field_[6]; }
+  bool producer_provided_shmem() const { return producer_provided_shmem_; }
+  void set_producer_provided_shmem(bool value) { producer_provided_shmem_ = value; _has_field_.set(6); }
 
-template <typename T>
-class MessageHandle : public MessageHandleBase {
- public:
-  MessageHandle() : MessageHandle(nullptr) {}
-  explicit MessageHandle(T* message) : MessageHandleBase(message) {}
+  bool has_sdk_version() const { return _has_field_[8]; }
+  const std::string& sdk_version() const { return sdk_version_; }
+  void set_sdk_version(const std::string& value) { sdk_version_ = value; _has_field_.set(8); }
 
-  explicit operator bool() const { return MessageHandleBase::operator bool(); }
+  bool has_shm_key_windows() const { return _has_field_[7]; }
+  const std::string& shm_key_windows() const { return shm_key_windows_; }
+  void set_shm_key_windows(const std::string& value) { shm_key_windows_ = value; _has_field_.set(7); }
 
-  T& operator*() const {
-    return static_cast<T&>(MessageHandleBase::operator*());
-  }
+ private:
+  uint32_t shared_memory_page_size_hint_bytes_{};
+  uint32_t shared_memory_size_hint_bytes_{};
+  std::string producer_name_{};
+  InitializeConnectionRequest_ProducerSMBScrapingMode smb_scraping_mode_{};
+  bool producer_provided_shmem_{};
+  std::string sdk_version_{};
+  std::string shm_key_windows_{};
 
-  T* operator->() const {
-    return static_cast<T*>(MessageHandleBase::operator->());
-  }
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  T* get() const { return static_cast<T*>(MessageHandleBase::operator->()); }
+  std::bitset<9> _has_field_{};
 };
 
-}  // namespace protozero
-
-#endif  // INCLUDE_PERFETTO_PROTOZERO_MESSAGE_HANDLE_H_
-// gen_amalgamated begin header: include/perfetto/protozero/packed_repeated_fields.h
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-#ifndef INCLUDE_PERFETTO_PROTOZERO_PACKED_REPEATED_FIELDS_H_
-#define INCLUDE_PERFETTO_PROTOZERO_PACKED_REPEATED_FIELDS_H_
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_PRODUCER_PORT_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/ipc/relay_port.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_RELAY_PORT_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_RELAY_PORT_PROTO_CPP_H_
 
 #include <stdint.h>
-
-#include <array>
-#include <memory>
+#include <bitset>
+#include <vector>
+#include <string>
 #include <type_traits>
 
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+class SyncClockResponse;
+class SyncClockRequest;
+class SyncClockRequest_Clock;
+class InitRelayResponse;
+class InitRelayRequest;
+class SystemInfo;
+class Utsname;
+enum SyncClockRequest_Phase : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
 namespace protozero {
+class Message;
+}  // namespace protozero
 
-// This file contains classes used when encoding packed repeated fields.
-// To encode such a field, the caller is first expected to accumulate all of the
-// values in one of the following types (depending on the wire type of the
-// individual elements), defined below:
-// * protozero::PackedVarInt
-// * protozero::PackedFixedSizeInt</*element_type=*/ uint32_t>
-// Then that buffer is passed to the protozero-generated setters as an argument.
-// After calling the setter, the buffer can be destroyed.
-//
-// An example of encoding a packed field:
-//   protozero::HeapBuffered<protozero::Message> msg;
-//   protozero::PackedVarInt buf;
-//   buf.Append(42);
-//   buf.Append(-1);
-//   msg->set_fieldname(buf);
-//   msg.SerializeAsString();
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum SyncClockRequest_Phase : int {
+  SyncClockRequest_Phase_PING = 1,
+  SyncClockRequest_Phase_UPDATE = 2,
+};
 
-class PackedBufferBase {
+class PERFETTO_EXPORT_COMPONENT SyncClockResponse : public ::protozero::CppMessageObj {
  public:
-  PackedBufferBase() { Reset(); }
+  enum FieldNumbers {
+  };
 
-  // Copy or move is disabled due to pointers to stack addresses.
-  PackedBufferBase(const PackedBufferBase&) = delete;
-  PackedBufferBase(PackedBufferBase&&) = delete;
-  PackedBufferBase& operator=(const PackedBufferBase&) = delete;
-  PackedBufferBase& operator=(PackedBufferBase&&) = delete;
+  SyncClockResponse();
+  ~SyncClockResponse() override;
+  SyncClockResponse(SyncClockResponse&&) noexcept;
+  SyncClockResponse& operator=(SyncClockResponse&&);
+  SyncClockResponse(const SyncClockResponse&);
+  SyncClockResponse& operator=(const SyncClockResponse&);
+  bool operator==(const SyncClockResponse&) const;
+  bool operator!=(const SyncClockResponse& other) const { return !(*this == other); }
 
-  void Reset();
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  const uint8_t* data() const { return storage_begin_; }
+ private:
 
-  size_t size() const {
-    return static_cast<size_t>(write_ptr_ - storage_begin_);
-  }
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
- protected:
-  void GrowIfNeeded() {
-    PERFETTO_DCHECK(write_ptr_ >= storage_begin_ && write_ptr_ <= storage_end_);
-    if (PERFETTO_UNLIKELY(write_ptr_ + kMaxElementSize > storage_end_)) {
-      GrowSlowpath();
-    }
-  }
+  std::bitset<2> _has_field_{};
+};
 
-  void GrowSlowpath();
 
-  // max(uint64_t varint encoding, biggest fixed type (uint64)).
-  static constexpr size_t kMaxElementSize = 10;
+class PERFETTO_EXPORT_COMPONENT SyncClockRequest : public ::protozero::CppMessageObj {
+ public:
+  using Clock = SyncClockRequest_Clock;
+  using Phase = SyncClockRequest_Phase;
+  static constexpr auto PING = SyncClockRequest_Phase_PING;
+  static constexpr auto UPDATE = SyncClockRequest_Phase_UPDATE;
+  static constexpr auto Phase_MIN = SyncClockRequest_Phase_PING;
+  static constexpr auto Phase_MAX = SyncClockRequest_Phase_UPDATE;
+  enum FieldNumbers {
+    kPhaseFieldNumber = 1,
+    kClocksFieldNumber = 2,
+  };
 
-  // So sizeof(this) == 8k.
-  static constexpr size_t kOnStackStorageSize = 8192 - 32;
+  SyncClockRequest();
+  ~SyncClockRequest() override;
+  SyncClockRequest(SyncClockRequest&&) noexcept;
+  SyncClockRequest& operator=(SyncClockRequest&&);
+  SyncClockRequest(const SyncClockRequest&);
+  SyncClockRequest& operator=(const SyncClockRequest&);
+  bool operator==(const SyncClockRequest&) const;
+  bool operator!=(const SyncClockRequest& other) const { return !(*this == other); }
 
-  uint8_t* storage_begin_;
-  uint8_t* storage_end_;
-  uint8_t* write_ptr_;
-  std::unique_ptr<uint8_t[]> heap_buf_;
-  alignas(uint64_t) uint8_t stack_buf_[kOnStackStorageSize];
-};
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-class PackedVarInt : public PackedBufferBase {
- public:
-  template <typename T>
-  void Append(T value) {
-    GrowIfNeeded();
-    write_ptr_ = proto_utils::WriteVarInt(value, write_ptr_);
-  }
-};
+  bool has_phase() const { return _has_field_[1]; }
+  SyncClockRequest_Phase phase() const { return phase_; }
+  void set_phase(SyncClockRequest_Phase value) { phase_ = value; _has_field_.set(1); }
 
-template <typename T /* e.g. uint32_t for Fixed32 */>
-class PackedFixedSizeInt : public PackedBufferBase {
- public:
-  void Append(T value) {
-    static_assert(sizeof(T) == 4 || sizeof(T) == 8,
-                  "PackedFixedSizeInt should be used only with 32/64-bit ints");
-    static_assert(sizeof(T) <= kMaxElementSize,
-                  "kMaxElementSize needs to be updated");
-    GrowIfNeeded();
-    PERFETTO_DCHECK(reinterpret_cast<size_t>(write_ptr_) % alignof(T) == 0);
-    memcpy(reinterpret_cast<T*>(write_ptr_), &value, sizeof(T));
-    write_ptr_ += sizeof(T);
-  }
+  const std::vector<SyncClockRequest_Clock>& clocks() const { return clocks_; }
+  std::vector<SyncClockRequest_Clock>* mutable_clocks() { return &clocks_; }
+  int clocks_size() const;
+  void clear_clocks();
+  SyncClockRequest_Clock* add_clocks();
+
+ private:
+  SyncClockRequest_Phase phase_{};
+  std::vector<SyncClockRequest_Clock> clocks_;
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<3> _has_field_{};
 };
 
-}  // namespace protozero
 
-#endif  // INCLUDE_PERFETTO_PROTOZERO_PACKED_REPEATED_FIELDS_H_
-// gen_amalgamated begin header: include/perfetto/protozero/proto_decoder.h
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+class PERFETTO_EXPORT_COMPONENT SyncClockRequest_Clock : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kClockIdFieldNumber = 1,
+    kTimestampFieldNumber = 2,
+  };
 
-#ifndef INCLUDE_PERFETTO_PROTOZERO_PROTO_DECODER_H_
-#define INCLUDE_PERFETTO_PROTOZERO_PROTO_DECODER_H_
+  SyncClockRequest_Clock();
+  ~SyncClockRequest_Clock() override;
+  SyncClockRequest_Clock(SyncClockRequest_Clock&&) noexcept;
+  SyncClockRequest_Clock& operator=(SyncClockRequest_Clock&&);
+  SyncClockRequest_Clock(const SyncClockRequest_Clock&);
+  SyncClockRequest_Clock& operator=(const SyncClockRequest_Clock&);
+  bool operator==(const SyncClockRequest_Clock&) const;
+  bool operator!=(const SyncClockRequest_Clock& other) const { return !(*this == other); }
 
-#include <stdint.h>
-#include <array>
-#include <memory>
-#include <vector>
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/field.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+  bool has_clock_id() const { return _has_field_[1]; }
+  uint32_t clock_id() const { return clock_id_; }
+  void set_clock_id(uint32_t value) { clock_id_ = value; _has_field_.set(1); }
 
-namespace protozero {
+  bool has_timestamp() const { return _has_field_[2]; }
+  uint64_t timestamp() const { return timestamp_; }
+  void set_timestamp(uint64_t value) { timestamp_ = value; _has_field_.set(2); }
 
-// A generic protobuf decoder. Doesn't require any knowledge about the proto
-// schema. It tokenizes fields, retrieves their ID and type and exposes
-// accessors to retrieve its values.
-// It does NOT recurse in nested submessages, instead it just computes their
-// boundaries, recursion is left to the caller.
-// This class is designed to be used in perf-sensitive contexts. It does not
-// allocate and does not perform any proto semantic checks (e.g. repeated /
-// required / optional). It's supposedly safe wrt out-of-bounds memory accesses
-// (see proto_decoder_fuzzer.cc).
-// This class serves also as a building block for TypedProtoDecoder, used when
-// the schema is known at compile time.
-class PERFETTO_EXPORT_COMPONENT ProtoDecoder {
- public:
-  // Creates a ProtoDecoder using the given |buffer| with size |length| bytes.
-  ProtoDecoder(const void* buffer, size_t length)
-      : begin_(reinterpret_cast<const uint8_t*>(buffer)),
-        end_(begin_ + length),
-        read_ptr_(begin_) {}
-  ProtoDecoder(const std::string& str) : ProtoDecoder(str.data(), str.size()) {}
-  ProtoDecoder(const ConstBytes& cb) : ProtoDecoder(cb.data, cb.size) {}
+ private:
+  uint32_t clock_id_{};
+  uint64_t timestamp_{};
 
-  // Reads the next field from the buffer and advances the read cursor. If a
-  // full field cannot be read, the returned Field will be invalid (i.e.
-  // field.valid() == false).
-  Field ReadField();
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  // Finds the first field with the given id. Doesn't affect the read cursor.
-  Field FindField(uint32_t field_id);
+  std::bitset<3> _has_field_{};
+};
 
-  // Resets the read cursor to the start of the buffer.
-  void Reset() { read_ptr_ = begin_; }
 
-  // Resets the read cursor to the given position (must be within the buffer).
-  void Reset(const uint8_t* pos) {
-    PERFETTO_DCHECK(pos >= begin_ && pos < end_);
-    read_ptr_ = pos;
-  }
+class PERFETTO_EXPORT_COMPONENT InitRelayResponse : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+  };
 
-  // Returns the position of read cursor, relative to the start of the buffer.
-  size_t read_offset() const { return static_cast<size_t>(read_ptr_ - begin_); }
+  InitRelayResponse();
+  ~InitRelayResponse() override;
+  InitRelayResponse(InitRelayResponse&&) noexcept;
+  InitRelayResponse& operator=(InitRelayResponse&&);
+  InitRelayResponse(const InitRelayResponse&);
+  InitRelayResponse& operator=(const InitRelayResponse&);
+  bool operator==(const InitRelayResponse&) const;
+  bool operator!=(const InitRelayResponse& other) const { return !(*this == other); }
 
-  size_t bytes_left() const {
-    PERFETTO_DCHECK(read_ptr_ <= end_);
-    return static_cast<size_t>(end_ - read_ptr_);
-  }
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  const uint8_t* begin() const { return begin_; }
-  const uint8_t* end() const { return end_; }
+ private:
 
- protected:
-  const uint8_t* const begin_;
-  const uint8_t* const end_;
-  const uint8_t* read_ptr_ = nullptr;
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<2> _has_field_{};
 };
 
-// An iterator-like class used to iterate through repeated fields. Used by
-// TypedProtoDecoder. The iteration sequence is a bit counter-intuitive due to
-// the fact that fields_[field_id] holds the *last* value of the field, not the
-// first, but the remaining storage holds repeated fields in FIFO order.
-// Assume that we push the 10,11,12 into a repeated field with ID=1.
-//
-// Decoder memory layout:  [  fields storage  ] [ repeated fields storage ]
-// 1st iteration:           10
-// 2nd iteration:           11                   10
-// 3rd iteration:           12                   10 11
-//
-// We start the iteration @ fields_[num_fields], which is the start of the
-// repeated fields storage, proceed until the end and lastly jump @ fields_[id].
-template <typename T>
-class RepeatedFieldIterator {
+
+class PERFETTO_EXPORT_COMPONENT InitRelayRequest : public ::protozero::CppMessageObj {
  public:
-  RepeatedFieldIterator(uint32_t field_id,
-                        const Field* begin,
-                        const Field* end,
-                        const Field* last)
-      : field_id_(field_id), iter_(begin), end_(end), last_(last) {
-    FindNextMatchingId();
-  }
+  enum FieldNumbers {
+    kSystemInfoFieldNumber = 1,
+  };
 
-  // Constructs an invalid iterator.
-  RepeatedFieldIterator()
-      : field_id_(0u), iter_(nullptr), end_(nullptr), last_(nullptr) {}
+  InitRelayRequest();
+  ~InitRelayRequest() override;
+  InitRelayRequest(InitRelayRequest&&) noexcept;
+  InitRelayRequest& operator=(InitRelayRequest&&);
+  InitRelayRequest(const InitRelayRequest&);
+  InitRelayRequest& operator=(const InitRelayRequest&);
+  bool operator==(const InitRelayRequest&) const;
+  bool operator!=(const InitRelayRequest& other) const { return !(*this == other); }
 
-  explicit operator bool() const { return iter_ != end_; }
-  const Field& field() const { return *iter_; }
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  T operator*() const {
-    T val{};
-    iter_->get(&val);
-    return val;
-  }
-  const Field* operator->() const { return iter_; }
+  bool has_system_info() const { return _has_field_[1]; }
+  const SystemInfo& system_info() const { return *system_info_; }
+  SystemInfo* mutable_system_info() { _has_field_.set(1); return system_info_.get(); }
 
-  RepeatedFieldIterator& operator++() {
-    PERFETTO_DCHECK(iter_ != end_);
-    if (iter_ == last_) {
-      iter_ = end_;
-      return *this;
-    }
-    ++iter_;
-    FindNextMatchingId();
-    return *this;
-  }
+ private:
+  ::protozero::CopyablePtr<SystemInfo> system_info_;
 
-  RepeatedFieldIterator operator++(int) {
-    PERFETTO_DCHECK(iter_ != end_);
-    RepeatedFieldIterator it(*this);
-    ++(*this);
-    return it;
-  }
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
- private:
-  void FindNextMatchingId() {
-    PERFETTO_DCHECK(iter_ != last_);
-    for (; iter_ != end_; ++iter_) {
-      if (iter_->id() == field_id_)
-        return;
-    }
-    iter_ = last_->valid() ? last_ : end_;
-  }
+  std::bitset<2> _has_field_{};
+};
 
-  uint32_t field_id_;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-  // Initially points to the beginning of the repeated field storage, then is
-  // incremented as we call operator++().
-  const Field* iter_;
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_RELAY_PORT_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/ipc/wire_protocol.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_WIRE_PROTOCOL_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_WIRE_PROTOCOL_PROTO_CPP_H_
 
-  // Always points to fields_[size_], i.e. past the end of the storage.
-  const Field* end_;
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
 
-  // Always points to fields_[field_id].
-  const Field* last_;
-};
+// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h"
+// gen_amalgamated expanded: #include "perfetto/base/export.h"
 
-// As RepeatedFieldIterator, but allows iterating over a packed repeated field
-// (which will be initially stored as a single length-delimited field).
-// See |GetPackedRepeatedField| for details.
-//
-// Assumes little endianness, and that the input buffers are well formed -
-// containing an exact multiple of encoded elements.
-template <proto_utils::ProtoWireType wire_type, typename CppType>
-class PackedRepeatedFieldIterator {
- public:
-  PackedRepeatedFieldIterator(const uint8_t* data_begin,
-                              size_t size,
-                              bool* parse_error_ptr)
-      : data_end_(data_begin ? data_begin + size : nullptr),
-        read_ptr_(data_begin),
-        parse_error_(parse_error_ptr) {
-    using proto_utils::ProtoWireType;
-    static_assert(wire_type == ProtoWireType::kVarInt ||
-                      wire_type == ProtoWireType::kFixed32 ||
-                      wire_type == ProtoWireType::kFixed64,
-                  "invalid type");
+namespace perfetto {
+namespace protos {
+namespace gen {
+class IPCFrame;
+class IPCFrame_SetPeerIdentity;
+class IPCFrame_RequestError;
+class IPCFrame_InvokeMethodReply;
+class IPCFrame_InvokeMethod;
+class IPCFrame_BindServiceReply;
+class IPCFrame_BindServiceReply_MethodInfo;
+class IPCFrame_BindService;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-    PERFETTO_DCHECK(parse_error_ptr);
+namespace protozero {
+class Message;
+}  // namespace protozero
 
-    // Either the field is unset (and there are no data pointer), or the field
-    // is set with a zero length payload. Mark the iterator as invalid in both
-    // cases.
-    if (size == 0) {
-      curr_value_valid_ = false;
-      return;
-    }
+namespace perfetto {
+namespace protos {
+namespace gen {
 
-    if ((wire_type == ProtoWireType::kFixed32 && (size % 4) != 0) ||
-        (wire_type == ProtoWireType::kFixed64 && (size % 8) != 0)) {
-      *parse_error_ = true;
-      curr_value_valid_ = false;
-      return;
-    }
+class PERFETTO_EXPORT_COMPONENT IPCFrame : public ::protozero::CppMessageObj {
+ public:
+  using BindService = IPCFrame_BindService;
+  using BindServiceReply = IPCFrame_BindServiceReply;
+  using InvokeMethod = IPCFrame_InvokeMethod;
+  using InvokeMethodReply = IPCFrame_InvokeMethodReply;
+  using RequestError = IPCFrame_RequestError;
+  using SetPeerIdentity = IPCFrame_SetPeerIdentity;
+  enum FieldNumbers {
+    kRequestIdFieldNumber = 2,
+    kMsgBindServiceFieldNumber = 3,
+    kMsgBindServiceReplyFieldNumber = 4,
+    kMsgInvokeMethodFieldNumber = 5,
+    kMsgInvokeMethodReplyFieldNumber = 6,
+    kMsgRequestErrorFieldNumber = 7,
+    kSetPeerIdentityFieldNumber = 8,
+    kDataForTestingFieldNumber = 1,
+  };
 
-    ++(*this);
-  }
+  IPCFrame();
+  ~IPCFrame() override;
+  IPCFrame(IPCFrame&&) noexcept;
+  IPCFrame& operator=(IPCFrame&&);
+  IPCFrame(const IPCFrame&);
+  IPCFrame& operator=(const IPCFrame&);
+  bool operator==(const IPCFrame&) const;
+  bool operator!=(const IPCFrame& other) const { return !(*this == other); }
 
-  const CppType operator*() const { return curr_value_; }
-  explicit operator bool() const { return curr_value_valid_; }
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  PackedRepeatedFieldIterator& operator++() {
-    using proto_utils::ProtoWireType;
+  bool has_request_id() const { return _has_field_[2]; }
+  uint64_t request_id() const { return request_id_; }
+  void set_request_id(uint64_t value) { request_id_ = value; _has_field_.set(2); }
 
-    if (PERFETTO_UNLIKELY(!curr_value_valid_))
-      return *this;
+  bool has_msg_bind_service() const { return _has_field_[3]; }
+  const IPCFrame_BindService& msg_bind_service() const { return *msg_bind_service_; }
+  IPCFrame_BindService* mutable_msg_bind_service() { _has_field_.set(3); return msg_bind_service_.get(); }
 
-    if (PERFETTO_UNLIKELY(read_ptr_ == data_end_)) {
-      curr_value_valid_ = false;
-      return *this;
-    }
+  bool has_msg_bind_service_reply() const { return _has_field_[4]; }
+  const IPCFrame_BindServiceReply& msg_bind_service_reply() const { return *msg_bind_service_reply_; }
+  IPCFrame_BindServiceReply* mutable_msg_bind_service_reply() { _has_field_.set(4); return msg_bind_service_reply_.get(); }
 
-    if (wire_type == ProtoWireType::kVarInt) {
-      uint64_t new_value = 0;
-      const uint8_t* new_pos =
-          proto_utils::ParseVarInt(read_ptr_, data_end_, &new_value);
+  bool has_msg_invoke_method() const { return _has_field_[5]; }
+  const IPCFrame_InvokeMethod& msg_invoke_method() const { return *msg_invoke_method_; }
+  IPCFrame_InvokeMethod* mutable_msg_invoke_method() { _has_field_.set(5); return msg_invoke_method_.get(); }
 
-      if (PERFETTO_UNLIKELY(new_pos == read_ptr_)) {
-        // Failed to decode the varint (probably incomplete buffer).
-        *parse_error_ = true;
-        curr_value_valid_ = false;
-      } else {
-        read_ptr_ = new_pos;
-        curr_value_ = static_cast<CppType>(new_value);
-      }
-    } else {  // kFixed32 or kFixed64
-      constexpr size_t kStep = wire_type == ProtoWireType::kFixed32 ? 4 : 8;
+  bool has_msg_invoke_method_reply() const { return _has_field_[6]; }
+  const IPCFrame_InvokeMethodReply& msg_invoke_method_reply() const { return *msg_invoke_method_reply_; }
+  IPCFrame_InvokeMethodReply* mutable_msg_invoke_method_reply() { _has_field_.set(6); return msg_invoke_method_reply_.get(); }
 
-      // NB: the raw buffer is not guaranteed to be aligned, so neither are
-      // these copies.
-      memcpy(&curr_value_, read_ptr_, sizeof(CppType));
-      read_ptr_ += kStep;
-    }
+  bool has_msg_request_error() const { return _has_field_[7]; }
+  const IPCFrame_RequestError& msg_request_error() const { return *msg_request_error_; }
+  IPCFrame_RequestError* mutable_msg_request_error() { _has_field_.set(7); return msg_request_error_.get(); }
 
-    return *this;
-  }
+  bool has_set_peer_identity() const { return _has_field_[8]; }
+  const IPCFrame_SetPeerIdentity& set_peer_identity() const { return *set_peer_identity_; }
+  IPCFrame_SetPeerIdentity* mutable_set_peer_identity() { _has_field_.set(8); return set_peer_identity_.get(); }
 
-  PackedRepeatedFieldIterator operator++(int) {
-    PackedRepeatedFieldIterator it(*this);
-    ++(*this);
-    return it;
-  }
+  const std::vector<std::string>& data_for_testing() const { return data_for_testing_; }
+  std::vector<std::string>* mutable_data_for_testing() { return &data_for_testing_; }
+  int data_for_testing_size() const { return static_cast<int>(data_for_testing_.size()); }
+  void clear_data_for_testing() { data_for_testing_.clear(); }
+  void add_data_for_testing(std::string value) { data_for_testing_.emplace_back(value); }
+  std::string* add_data_for_testing() { data_for_testing_.emplace_back(); return &data_for_testing_.back(); }
 
  private:
-  // Might be null if the backing proto field isn't set.
-  const uint8_t* const data_end_;
-
-  // The iterator looks ahead by an element, so |curr_value| holds the value
-  // to be returned when the caller dereferences the iterator, and |read_ptr_|
-  // points at the start of the next element to be decoded.
-  // |read_ptr_| might be null if the backing proto field isn't set.
-  const uint8_t* read_ptr_;
-  CppType curr_value_ = {};
+  uint64_t request_id_{};
+  ::protozero::CopyablePtr<IPCFrame_BindService> msg_bind_service_;
+  ::protozero::CopyablePtr<IPCFrame_BindServiceReply> msg_bind_service_reply_;
+  ::protozero::CopyablePtr<IPCFrame_InvokeMethod> msg_invoke_method_;
+  ::protozero::CopyablePtr<IPCFrame_InvokeMethodReply> msg_invoke_method_reply_;
+  ::protozero::CopyablePtr<IPCFrame_RequestError> msg_request_error_;
+  ::protozero::CopyablePtr<IPCFrame_SetPeerIdentity> set_peer_identity_;
+  std::vector<std::string> data_for_testing_;
 
-  // Set to false once we've exhausted the iterator, or encountered an error.
-  bool curr_value_valid_ = true;
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-  // Where to set parsing errors, supplied by the caller.
-  bool* const parse_error_;
+  std::bitset<9> _has_field_{};
 };
 
-// This decoder loads all fields upfront, without recursing in nested messages.
-// It is used as a base class for typed decoders generated by the pbzero plugin.
-// The split between TypedProtoDecoderBase and TypedProtoDecoder<> is to have
-// unique definition of functions like ParseAllFields() and ExpandHeapStorage().
-// The storage (either on-stack or on-heap) for this class is organized as
-// follows:
-// |-------------------------- fields_ ----------------------|
-// [ field 0 (invalid) ] [ fields 1 .. N ] [ repeated fields ]
-//                                        ^                  ^
-//                                        num_fields_        size_
-// Note that if a message has high field numbers, upon creation |size_| can be
-// < |num_fields_| (until a heap expansion is hit while inserting).
-class PERFETTO_EXPORT_COMPONENT TypedProtoDecoderBase : public ProtoDecoder {
- public:
-  // If the field |id| is known at compile time, prefer the templated
-  // specialization at<kFieldNumber>().
-  const Field& Get(uint32_t id) const {
-    if (PERFETTO_LIKELY(id < num_fields_ && id < size_))
-      return fields_[id];
-    // If id >= num_fields_, the field id is invalid (was not known in the
-    // .proto) and we return the 0th field, which is always !valid().
-    // If id >= size_ and <= num_fields, the id is valid but the field has not
-    // been seen while decoding (hence the stack storage has not been expanded)
-    // so we return the 0th invalid field.
-    return fields_[0];
-  }
-
-  // Returns an object that allows to iterate over all instances of a repeated
-  // field given its id. Example usage:
-  //   for (auto it = decoder.GetRepeated<int32_t>(N); it; ++it) { ... }
-  template <typename T>
-  RepeatedFieldIterator<T> GetRepeated(uint32_t field_id) const {
-    const Field* repeated_begin;
-    // The storage for repeated fields starts after the slot for the highest
-    // field id (refer to the diagram in the class-level comment). However, if
-    // a message has more than INITIAL_STACK_CAPACITY field there will be no
-    // slots available for the repeated fields (if ExpandHeapStorage() was not
-    // called). Imagine a message that has highest field id = 102 and that is
-    // still using the stack:
-    // [ F0 ] [ F1 ] ... [ F100 ] [ F101 ] [ F1012] [ repeated fields ]
-    //                                            ^ num_fields_
-    //                          ^ size (== capacity)
-    if (PERFETTO_LIKELY(num_fields_ < size_)) {
-      repeated_begin = &fields_[num_fields_];
-    } else {
-      // This is the case of not having any storage space for repeated fields.
-      // This makes it so begin == end, so the iterator will just skip @ last.
-      repeated_begin = &fields_[size_];
-    }
-    const Field* repeated_end = &fields_[size_];
-    const Field* last = &Get(field_id);
-    return RepeatedFieldIterator<T>(field_id, repeated_begin, repeated_end,
-                                    last);
-  }
-
-  // Returns an objects that allows to iterate over all entries of a packed
-  // repeated field given its id and type. The |wire_type| is necessary for
-  // decoding the packed field, the |cpp_type| is for convenience & stronger
-  // typing.
-  //
-  // The caller must also supply a pointer to a bool that is set to true if the
-  // packed buffer is found to be malformed while iterating (so you need to
-  // exhaust the iterator if you want to check the full extent of the buffer).
-  //
-  // Note that unlike standard protobuf parsers, protozero does not allow
-  // treating of packed repeated fields as non-packed and vice-versa (therefore
-  // not making the packed option forwards and backwards compatible). So
-  // the caller needs to use the right accessor for correct results.
-  template <proto_utils::ProtoWireType wire_type, typename cpp_type>
-  PackedRepeatedFieldIterator<wire_type, cpp_type> GetPackedRepeated(
-      uint32_t field_id,
-      bool* parse_error_location) const {
-    const Field& field = Get(field_id);
-    if (field.valid()) {
-      return PackedRepeatedFieldIterator<wire_type, cpp_type>(
-          field.data(), field.size(), parse_error_location);
-    }
-    return PackedRepeatedFieldIterator<wire_type, cpp_type>(
-        nullptr, 0, parse_error_location);
-  }
 
- protected:
-  TypedProtoDecoderBase(Field* storage,
-                        uint32_t num_fields,
-                        uint32_t capacity,
-                        const uint8_t* buffer,
-                        size_t length)
-      : ProtoDecoder(buffer, length),
-        fields_(storage),
-        num_fields_(num_fields),
-        // The reason for "capacity -1" is to avoid hitting the expansion path
-        // in TypedProtoDecoderBase::ParseAllFields() when we are just setting
-        // fields < INITIAL_STACK_CAPACITY (which is the most common case).
-        size_(std::min(num_fields, capacity - 1)),
-        capacity_(capacity) {
-    // The reason why Field needs to be trivially de/constructible is to avoid
-    // implicit initializers on all the ~1000 entries. We need it to initialize
-    // only on the first |max_field_id| fields, the remaining capacity doesn't
-    // require initialization.
-    static_assert(std::is_trivially_constructible<Field>::value &&
-                      std::is_trivially_destructible<Field>::value &&
-                      std::is_trivial<Field>::value,
-                  "Field must be a trivial aggregate type");
-    memset(fields_, 0, sizeof(Field) * capacity_);
-    PERFETTO_DCHECK(capacity > 0);
-  }
+class PERFETTO_EXPORT_COMPONENT IPCFrame_SetPeerIdentity : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kPidFieldNumber = 1,
+    kUidFieldNumber = 2,
+    kMachineIdHintFieldNumber = 3,
+    kMachineNameFieldNumber = 4,
+  };
 
-  void ParseAllFields();
+  IPCFrame_SetPeerIdentity();
+  ~IPCFrame_SetPeerIdentity() override;
+  IPCFrame_SetPeerIdentity(IPCFrame_SetPeerIdentity&&) noexcept;
+  IPCFrame_SetPeerIdentity& operator=(IPCFrame_SetPeerIdentity&&);
+  IPCFrame_SetPeerIdentity(const IPCFrame_SetPeerIdentity&);
+  IPCFrame_SetPeerIdentity& operator=(const IPCFrame_SetPeerIdentity&);
+  bool operator==(const IPCFrame_SetPeerIdentity&) const;
+  bool operator!=(const IPCFrame_SetPeerIdentity& other) const { return !(*this == other); }
 
-  // Called when the default on-stack storage is exhausted and new repeated
-  // fields need to be pushed.
-  void ExpandHeapStorage();
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-  // Used only in presence of a large number of repeated fields, when the
-  // default on-stack storage is exhausted.
-  std::unique_ptr<Field[]> heap_storage_;
+  bool has_pid() const { return _has_field_[1]; }
+  int32_t pid() const { return pid_; }
+  void set_pid(int32_t value) { pid_ = value; _has_field_.set(1); }
 
-  // Points to the storage, either on-stack (default, provided by the template
-  // specialization) or |heap_storage_| after ExpandHeapStorage() is called, in
-  // case of a large number of repeated fields.
-  Field* fields_;
+  bool has_uid() const { return _has_field_[2]; }
+  int32_t uid() const { return uid_; }
+  void set_uid(int32_t value) { uid_ = value; _has_field_.set(2); }
 
-  // Number of known fields, without accounting repeated storage. This is equal
-  // to MAX_FIELD_ID + 1 (to account for the invalid 0th field). It never
-  // changes after construction.
-  // This is unrelated with |size_| and |capacity_|. If the highest field id of
-  // a proto message is 131, |num_fields_| will be = 132 but, on initialization,
-  // |size_| = |capacity_| = 100 (INITIAL_STACK_CAPACITY).
-  // One cannot generally assume that |fields_| has enough storage to
-  // dereference every field. That is only true:
-  // - For field ids < INITIAL_STACK_CAPACITY.
-  // - After the first call to ExpandHeapStorage().
-  uint32_t num_fields_;
+  bool has_machine_id_hint() const { return _has_field_[3]; }
+  const std::string& machine_id_hint() const { return machine_id_hint_; }
+  void set_machine_id_hint(const std::string& value) { machine_id_hint_ = value; _has_field_.set(3); }
 
-  // Number of active |fields_| entries. This is initially equal to
-  // min(num_fields_, INITIAL_STACK_CAPACITY - 1) and after ExpandHeapStorage()
-  // becomes == |num_fields_|. If the message has non-packed repeated fields, it
-  // can grow further, up to |capacity_|.
-  // |size_| is always <= |capacity_|. But |num_fields_| can be > |size_|.
-  uint32_t size_;
+  bool has_machine_name() const { return _has_field_[4]; }
+  const std::string& machine_name() const { return machine_name_; }
+  void set_machine_name(const std::string& value) { machine_name_ = value; _has_field_.set(4); }
 
-  // Initially equal to kFieldsCapacity of the TypedProtoDecoder
-  // specialization. Can grow when falling back on heap-based storage, in which
-  // case it represents the size (#fields with each entry of a repeated field
-  // counted individually) of the |heap_storage_| array.
-  uint32_t capacity_;
+ private:
+  int32_t pid_{};
+  int32_t uid_{};
+  std::string machine_id_hint_{};
+  std::string machine_name_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<5> _has_field_{};
 };
 
-// This constant is a tradeoff between having a larger stack frame and being
-// able to decode field IDs up to N (or N - num_fields repeated fields) without
-// falling back on the heap.
-#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100
 
-// Template class instantiated by the auto-generated decoder classes declared in
-// xxx.pbzero.h files.
-template <int MAX_FIELD_ID, bool HAS_NONPACKED_REPEATED_FIELDS>
-class TypedProtoDecoder : public TypedProtoDecoderBase {
+class PERFETTO_EXPORT_COMPONENT IPCFrame_RequestError : public ::protozero::CppMessageObj {
  public:
-  TypedProtoDecoder(const uint8_t* buffer, size_t length)
-      : TypedProtoDecoderBase(on_stack_storage_,
-                              /*num_fields=*/MAX_FIELD_ID + 1,
-                              PROTOZERO_DECODER_INITIAL_STACK_CAPACITY,
-                              buffer,
-                              length) {
-    TypedProtoDecoderBase::ParseAllFields();
-  }
+  enum FieldNumbers {
+    kErrorFieldNumber = 1,
+  };
 
-  template <uint32_t FIELD_ID>
-  const Field& at() const {
-    static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID");
-    // If the field id is < the on-stack capacity, it's safe to always
-    // dereference |fields_|, whether it's still using the stack or it fell
-    // back on the heap. Because both terms of the if () are known at compile
-    // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY.
-    if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) {
-      return fields_[FIELD_ID];
-    } else {
-      // Otherwise use the slowpath Get() which will do a runtime check.
-      return Get(FIELD_ID);
-    }
-  }
+  IPCFrame_RequestError();
+  ~IPCFrame_RequestError() override;
+  IPCFrame_RequestError(IPCFrame_RequestError&&) noexcept;
+  IPCFrame_RequestError& operator=(IPCFrame_RequestError&&);
+  IPCFrame_RequestError(const IPCFrame_RequestError&);
+  IPCFrame_RequestError& operator=(const IPCFrame_RequestError&);
+  bool operator==(const IPCFrame_RequestError&) const;
+  bool operator!=(const IPCFrame_RequestError& other) const { return !(*this == other); }
 
-  TypedProtoDecoder(TypedProtoDecoder&& other) noexcept
-      : TypedProtoDecoderBase(std::move(other)) {
-    // If the moved-from decoder was using on-stack storage, we need to update
-    // our pointer to point to this decoder's on-stack storage.
-    if (fields_ == other.on_stack_storage_) {
-      fields_ = on_stack_storage_;
-      memcpy(on_stack_storage_, other.on_stack_storage_,
-             sizeof(on_stack_storage_));
-    }
-  }
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_error() const { return _has_field_[1]; }
+  const std::string& error() const { return error_; }
+  void set_error(const std::string& value) { error_ = value; _has_field_.set(1); }
 
  private:
-  Field on_stack_storage_[PROTOZERO_DECODER_INITIAL_STACK_CAPACITY];
+  std::string error_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<2> _has_field_{};
 };
 
-}  // namespace protozero
 
-#endif  // INCLUDE_PERFETTO_PROTOZERO_PROTO_DECODER_H_
-// gen_amalgamated begin header: include/perfetto/protozero/proto_utils.h
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+class PERFETTO_EXPORT_COMPONENT IPCFrame_InvokeMethodReply : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kSuccessFieldNumber = 1,
+    kHasMoreFieldNumber = 2,
+    kReplyProtoFieldNumber = 3,
+  };
 
-#ifndef INCLUDE_PERFETTO_PROTOZERO_PROTO_UTILS_H_
-#define INCLUDE_PERFETTO_PROTOZERO_PROTO_UTILS_H_
+  IPCFrame_InvokeMethodReply();
+  ~IPCFrame_InvokeMethodReply() override;
+  IPCFrame_InvokeMethodReply(IPCFrame_InvokeMethodReply&&) noexcept;
+  IPCFrame_InvokeMethodReply& operator=(IPCFrame_InvokeMethodReply&&);
+  IPCFrame_InvokeMethodReply(const IPCFrame_InvokeMethodReply&);
+  IPCFrame_InvokeMethodReply& operator=(const IPCFrame_InvokeMethodReply&);
+  bool operator==(const IPCFrame_InvokeMethodReply&) const;
+  bool operator!=(const IPCFrame_InvokeMethodReply& other) const { return !(*this == other); }
 
-#include <stddef.h>
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-#include <cinttypes>
-#include <type_traits>
+  bool has_success() const { return _has_field_[1]; }
+  bool success() const { return success_; }
+  void set_success(bool value) { success_ = value; _has_field_.set(1); }
 
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
+  bool has_has_more() const { return _has_field_[2]; }
+  bool has_more() const { return has_more_; }
+  void set_has_more(bool value) { has_more_ = value; _has_field_.set(2); }
 
-// Helper macro for the constexpr functions containing
-// the switch statement: if C++14 is supported, this macro
-// resolves to `constexpr` and just `inline` otherwise.
-#if __cpp_constexpr >= 201304
-#define PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE constexpr
-#else
-#define PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE inline
-#endif
+  bool has_reply_proto() const { return _has_field_[3]; }
+  const std::string& reply_proto() const { return reply_proto_; }
+  void set_reply_proto(const std::string& value) { reply_proto_ = value; _has_field_.set(3); }
+  void set_reply_proto(const void* p, size_t s) { reply_proto_.assign(reinterpret_cast<const char*>(p), s); _has_field_.set(3); }
 
-namespace protozero {
-namespace proto_utils {
+ private:
+  bool success_{};
+  bool has_more_{};
+  std::string reply_proto_{};
 
-// See https://developers.google.com/protocol-buffers/docs/encoding wire types.
-// This is a type encoded into the proto that provides just enough info to
-// find the length of the following value.
-enum class ProtoWireType : uint32_t {
-  kVarInt = 0,
-  kFixed64 = 1,
-  kLengthDelimited = 2,
-  kFixed32 = 5,
-};
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-// This is the type defined in the proto for each field. This information
-// is used to decide the translation strategy when writing the trace.
-enum class ProtoSchemaType {
-  kUnknown = 0,
-  kDouble,
-  kFloat,
-  kInt64,
-  kUint64,
-  kInt32,
-  kFixed64,
-  kFixed32,
-  kBool,
-  kString,
-  kGroup,  // Deprecated (proto2 only)
-  kMessage,
-  kBytes,
-  kUint32,
-  kEnum,
-  kSfixed32,
-  kSfixed64,
-  kSint32,
-  kSint64,
+  std::bitset<4> _has_field_{};
 };
 
-inline const char* ProtoSchemaToString(ProtoSchemaType v) {
-  switch (v) {
-    case ProtoSchemaType::kUnknown:
-      return "unknown";
-    case ProtoSchemaType::kDouble:
-      return "double";
-    case ProtoSchemaType::kFloat:
-      return "float";
-    case ProtoSchemaType::kInt64:
-      return "int64";
-    case ProtoSchemaType::kUint64:
-      return "uint64";
-    case ProtoSchemaType::kInt32:
-      return "int32";
-    case ProtoSchemaType::kFixed64:
-      return "fixed64";
-    case ProtoSchemaType::kFixed32:
-      return "fixed32";
-    case ProtoSchemaType::kBool:
-      return "bool";
-    case ProtoSchemaType::kString:
-      return "string";
-    case ProtoSchemaType::kGroup:
-      return "group";
-    case ProtoSchemaType::kMessage:
-      return "message";
-    case ProtoSchemaType::kBytes:
-      return "bytes";
-    case ProtoSchemaType::kUint32:
-      return "uint32";
-    case ProtoSchemaType::kEnum:
-      return "enum";
-    case ProtoSchemaType::kSfixed32:
-      return "sfixed32";
-    case ProtoSchemaType::kSfixed64:
-      return "sfixed64";
-    case ProtoSchemaType::kSint32:
-      return "sint32";
-    case ProtoSchemaType::kSint64:
-      return "sint64";
-  }
-  // For gcc:
-  PERFETTO_DCHECK(false);
-  return "";
-}
 
-// Maximum message size supported: 256 MiB (4 x 7-bit due to varint encoding).
-constexpr size_t kMessageLengthFieldSize = 4;
-constexpr size_t kMaxMessageLength = (1u << (kMessageLengthFieldSize * 7)) - 1;
+class PERFETTO_EXPORT_COMPONENT IPCFrame_InvokeMethod : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kServiceIdFieldNumber = 1,
+    kMethodIdFieldNumber = 2,
+    kArgsProtoFieldNumber = 3,
+    kDropReplyFieldNumber = 4,
+  };
 
-// Field tag is encoded as 32-bit varint (5 bytes at most).
-// Largest value of simple (not length-delimited) field is 64-bit varint
-// (10 bytes at most). 15 bytes buffer is enough to store a simple field.
-constexpr size_t kMaxTagEncodedSize = 5;
-constexpr size_t kMaxSimpleFieldEncodedSize = kMaxTagEncodedSize + 10;
+  IPCFrame_InvokeMethod();
+  ~IPCFrame_InvokeMethod() override;
+  IPCFrame_InvokeMethod(IPCFrame_InvokeMethod&&) noexcept;
+  IPCFrame_InvokeMethod& operator=(IPCFrame_InvokeMethod&&);
+  IPCFrame_InvokeMethod(const IPCFrame_InvokeMethod&);
+  IPCFrame_InvokeMethod& operator=(const IPCFrame_InvokeMethod&);
+  bool operator==(const IPCFrame_InvokeMethod&) const;
+  bool operator!=(const IPCFrame_InvokeMethod& other) const { return !(*this == other); }
 
-// Proto types: (int|uint|sint)(32|64), bool, enum.
-constexpr uint32_t MakeTagVarInt(uint32_t field_id) {
-  return (field_id << 3) | static_cast<uint32_t>(ProtoWireType::kVarInt);
-}
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-// Proto types: fixed64, sfixed64, fixed32, sfixed32, double, float.
-template <typename T>
-constexpr uint32_t MakeTagFixed(uint32_t field_id) {
-  static_assert(sizeof(T) == 8 || sizeof(T) == 4, "Value must be 4 or 8 bytes");
-  return (field_id << 3) |
-         static_cast<uint32_t>((sizeof(T) == 8 ? ProtoWireType::kFixed64
-                                               : ProtoWireType::kFixed32));
-}
+  bool has_service_id() const { return _has_field_[1]; }
+  uint32_t service_id() const { return service_id_; }
+  void set_service_id(uint32_t value) { service_id_ = value; _has_field_.set(1); }
 
-// Proto types: string, bytes, embedded messages.
-constexpr uint32_t MakeTagLengthDelimited(uint32_t field_id) {
-  return (field_id << 3) |
-         static_cast<uint32_t>(ProtoWireType::kLengthDelimited);
-}
+  bool has_method_id() const { return _has_field_[2]; }
+  uint32_t method_id() const { return method_id_; }
+  void set_method_id(uint32_t value) { method_id_ = value; _has_field_.set(2); }
 
-// Proto types: sint64, sint32.
-template <typename T>
-inline typename std::make_unsigned<T>::type ZigZagEncode(T value) {
-  using UnsignedType = typename std::make_unsigned<T>::type;
+  bool has_args_proto() const { return _has_field_[3]; }
+  const std::string& args_proto() const { return args_proto_; }
+  void set_args_proto(const std::string& value) { args_proto_ = value; _has_field_.set(3); }
+  void set_args_proto(const void* p, size_t s) { args_proto_.assign(reinterpret_cast<const char*>(p), s); _has_field_.set(3); }
 
-  // Right-shift of negative values is implementation specific.
-  // Assert the implementation does what we expect, which is that shifting any
-  // positive value by sizeof(T) * 8 - 1 gives an all 0 bitmap, and a negative
-  // value gives and all 1 bitmap.
-  constexpr uint64_t kUnsignedZero = 0u;
-  constexpr int64_t kNegativeOne = -1;
-  constexpr int64_t kPositiveOne = 1;
-  static_assert(static_cast<uint64_t>(kNegativeOne >> 63) == ~kUnsignedZero,
-                "implementation does not support assumed rightshift");
-  static_assert(static_cast<uint64_t>(kPositiveOne >> 63) == kUnsignedZero,
-                "implementation does not support assumed rightshift");
+  bool has_drop_reply() const { return _has_field_[4]; }
+  bool drop_reply() const { return drop_reply_; }
+  void set_drop_reply(bool value) { drop_reply_ = value; _has_field_.set(4); }
 
-  return (static_cast<UnsignedType>(value) << 1) ^
-         static_cast<UnsignedType>(value >> (sizeof(T) * 8 - 1));
-}
+ private:
+  uint32_t service_id_{};
+  uint32_t method_id_{};
+  std::string args_proto_{};
+  bool drop_reply_{};
 
-// Proto types: sint64, sint32.
-template <typename T>
-inline typename std::make_signed<T>::type ZigZagDecode(T value) {
-  using UnsignedType = typename std::make_unsigned<T>::type;
-  using SignedType = typename std::make_signed<T>::type;
-  auto u_value = static_cast<UnsignedType>(value);
-  auto mask = static_cast<UnsignedType>(-static_cast<SignedType>(u_value & 1));
-  return static_cast<SignedType>((u_value >> 1) ^ mask);
-}
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-template <typename T>
-auto ExtendValueForVarIntSerialization(T value) -> typename std::make_unsigned<
-    typename std::conditional<std::is_unsigned<T>::value, T, int64_t>::type>::
-    type {
-  // If value is <= 0 we must first sign extend to int64_t (see [1]).
-  // Finally we always cast to an unsigned value to to avoid arithmetic
-  // (sign expanding) shifts in the while loop.
-  // [1]: "If you use int32 or int64 as the type for a negative number, the
-  // resulting varint is always ten bytes long".
-  // - developers.google.com/protocol-buffers/docs/encoding
-  // So for each input type we do the following casts:
-  // uintX_t -> uintX_t -> uintX_t
-  // int8_t  -> int64_t -> uint64_t
-  // int16_t -> int64_t -> uint64_t
-  // int32_t -> int64_t -> uint64_t
-  // int64_t -> int64_t -> uint64_t
-  using MaybeExtendedType =
-      typename std::conditional<std::is_unsigned<T>::value, T, int64_t>::type;
-  using UnsignedType = typename std::make_unsigned<MaybeExtendedType>::type;
+  std::bitset<5> _has_field_{};
+};
 
-  MaybeExtendedType extended_value = static_cast<MaybeExtendedType>(value);
-  UnsignedType unsigned_value = static_cast<UnsignedType>(extended_value);
 
-  return unsigned_value;
-}
+class PERFETTO_EXPORT_COMPONENT IPCFrame_BindServiceReply : public ::protozero::CppMessageObj {
+ public:
+  using MethodInfo = IPCFrame_BindServiceReply_MethodInfo;
+  enum FieldNumbers {
+    kSuccessFieldNumber = 1,
+    kServiceIdFieldNumber = 2,
+    kMethodsFieldNumber = 3,
+  };
 
-template <typename T>
-inline uint8_t* WriteVarInt(T value, uint8_t* target) {
-  auto unsigned_value = ExtendValueForVarIntSerialization(value);
+  IPCFrame_BindServiceReply();
+  ~IPCFrame_BindServiceReply() override;
+  IPCFrame_BindServiceReply(IPCFrame_BindServiceReply&&) noexcept;
+  IPCFrame_BindServiceReply& operator=(IPCFrame_BindServiceReply&&);
+  IPCFrame_BindServiceReply(const IPCFrame_BindServiceReply&);
+  IPCFrame_BindServiceReply& operator=(const IPCFrame_BindServiceReply&);
+  bool operator==(const IPCFrame_BindServiceReply&) const;
+  bool operator!=(const IPCFrame_BindServiceReply& other) const { return !(*this == other); }
 
-  while (unsigned_value >= 0x80) {
-    *target++ = static_cast<uint8_t>(unsigned_value) | 0x80;
-    unsigned_value >>= 7;
-  }
-  *target = static_cast<uint8_t>(unsigned_value);
-  return target + 1;
-}
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-// Writes a fixed-size redundant encoding of the given |value|. This is
-// used to backfill fixed-size reservations for the length field using a
-// non-canonical varint encoding (e.g. \x81\x80\x80\x00 instead of \x01).
-// See https://github.com/google/protobuf/issues/1530.
-// This is used mainly in two cases:
-// 1) At trace writing time, when starting a nested messages. The size of a
-//    nested message is not known until all its field have been written.
-//    |kMessageLengthFieldSize| bytes are reserved to encode the size field and
-//    backfilled at the end.
-// 2) When rewriting a message at trace filtering time, in protozero/filtering.
-//    At that point we know only the upper bound of the length (a filtered
-//    message is <= the original one) and we backfill after the message has been
-//    filtered.
-inline void WriteRedundantVarInt(uint32_t value,
-                                 uint8_t* buf,
-                                 size_t size = kMessageLengthFieldSize) {
-  for (size_t i = 0; i < size; ++i) {
-    const uint8_t msb = (i < size - 1) ? 0x80 : 0;
-    buf[i] = static_cast<uint8_t>(value) | msb;
-    value >>= 7;
-  }
-}
+  bool has_success() const { return _has_field_[1]; }
+  bool success() const { return success_; }
+  void set_success(bool value) { success_ = value; _has_field_.set(1); }
 
-template <uint32_t field_id>
-void StaticAssertSingleBytePreamble() {
-  static_assert(field_id < 16,
-                "Proto field id too big to fit in a single byte preamble");
-}
+  bool has_service_id() const { return _has_field_[2]; }
+  uint32_t service_id() const { return service_id_; }
+  void set_service_id(uint32_t value) { service_id_ = value; _has_field_.set(2); }
 
-// Parses a VarInt from the encoded buffer [start, end). |end| is STL-style and
-// points one byte past the end of buffer.
-// The parsed int value is stored in the output arg |value|. Returns a pointer
-// to the next unconsumed byte (so start < retval <= end) or |start| if the
-// VarInt could not be fully parsed because there was not enough space in the
-// buffer.
-inline const uint8_t* ParseVarInt(const uint8_t* start,
-                                  const uint8_t* end,
-                                  uint64_t* out_value) {
-  const uint8_t* pos = start;
-  uint64_t value = 0;
-  for (uint32_t shift = 0; pos < end && shift < 64u; shift += 7) {
-    // Cache *pos into |cur_byte| to prevent that the compiler dereferences the
-    // pointer twice (here and in the if() below) due to char* aliasing rules.
-    uint8_t cur_byte = *pos++;
-    value |= static_cast<uint64_t>(cur_byte & 0x7f) << shift;
-    if ((cur_byte & 0x80) == 0) {
-      // In valid cases we get here.
-      *out_value = value;
-      return pos;
-    }
-  }
-  *out_value = 0;
-  return start;
-}
+  const std::vector<IPCFrame_BindServiceReply_MethodInfo>& methods() const { return methods_; }
+  std::vector<IPCFrame_BindServiceReply_MethodInfo>* mutable_methods() { return &methods_; }
+  int methods_size() const;
+  void clear_methods();
+  IPCFrame_BindServiceReply_MethodInfo* add_methods();
 
-enum class RepetitionType {
-  kNotRepeated,
-  kRepeatedPacked,
-  kRepeatedNotPacked,
-};
+ private:
+  bool success_{};
+  uint32_t service_id_{};
+  std::vector<IPCFrame_BindServiceReply_MethodInfo> methods_;
 
-// Provide a common base struct for all templated FieldMetadata types to allow
-// simple checks if a given type is a FieldMetadata or not.
-struct FieldMetadataBase {
-  constexpr FieldMetadataBase() = default;
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<4> _has_field_{};
 };
 
-template <uint32_t field_id,
-          RepetitionType repetition_type,
-          ProtoSchemaType proto_schema_type,
-          typename CppFieldType,
-          typename MessageType>
-struct FieldMetadata : public FieldMetadataBase {
-  constexpr FieldMetadata() = default;
 
-  static constexpr int kFieldId = field_id;
-  // Whether this field is repeated, packed (repeated [packed-true]) or not
-  // (optional).
-  static constexpr RepetitionType kRepetitionType = repetition_type;
-  // Proto type of this field (e.g. int64, fixed32 or nested message).
-  static constexpr ProtoSchemaType kProtoFieldType = proto_schema_type;
-  // C++ type of this field (for nested messages - C++ protozero class).
-  using cpp_field_type = CppFieldType;
-  // Protozero message which this field belongs to.
-  using message_type = MessageType;
-};
+class PERFETTO_EXPORT_COMPONENT IPCFrame_BindServiceReply_MethodInfo : public ::protozero::CppMessageObj {
+ public:
+  enum FieldNumbers {
+    kIdFieldNumber = 1,
+    kNameFieldNumber = 2,
+  };
 
-namespace internal {
+  IPCFrame_BindServiceReply_MethodInfo();
+  ~IPCFrame_BindServiceReply_MethodInfo() override;
+  IPCFrame_BindServiceReply_MethodInfo(IPCFrame_BindServiceReply_MethodInfo&&) noexcept;
+  IPCFrame_BindServiceReply_MethodInfo& operator=(IPCFrame_BindServiceReply_MethodInfo&&);
+  IPCFrame_BindServiceReply_MethodInfo(const IPCFrame_BindServiceReply_MethodInfo&);
+  IPCFrame_BindServiceReply_MethodInfo& operator=(const IPCFrame_BindServiceReply_MethodInfo&);
+  bool operator==(const IPCFrame_BindServiceReply_MethodInfo&) const;
+  bool operator!=(const IPCFrame_BindServiceReply_MethodInfo& other) const { return !(*this == other); }
 
-// Ideally we would create variables of FieldMetadata<...> type directly,
-// but before C++17's support for constexpr inline variables arrive, we have to
-// actually use pointers to inline functions instead to avoid having to define
-// symbols in *.pbzero.cc files.
-//
-// Note: protozero bindings will generate Message::kFieldName variable and which
-// can then be passed to TRACE_EVENT macro for inline writing of typed messages.
-// The fact that the former can be passed to the latter is a part of the stable
-// API, while the particular type is not and users should not rely on it.
-template <typename T>
-using FieldMetadataHelper = T (*)(void);
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
 
-}  // namespace internal
-}  // namespace proto_utils
-}  // namespace protozero
+  bool has_id() const { return _has_field_[1]; }
+  uint32_t id() const { return id_; }
+  void set_id(uint32_t value) { id_ = value; _has_field_.set(1); }
 
-#endif  // INCLUDE_PERFETTO_PROTOZERO_PROTO_UTILS_H_
-// gen_amalgamated begin header: include/perfetto/protozero/root_message.h
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+  bool has_name() const { return _has_field_[2]; }
+  const std::string& name() const { return name_; }
+  void set_name(const std::string& value) { name_ = value; _has_field_.set(2); }
 
-#ifndef INCLUDE_PERFETTO_PROTOZERO_ROOT_MESSAGE_H_
-#define INCLUDE_PERFETTO_PROTOZERO_ROOT_MESSAGE_H_
+ private:
+  uint32_t id_{};
+  std::string name_{};
 
-// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/message_arena.h"
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
 
-namespace protozero {
+  std::bitset<3> _has_field_{};
+};
 
-// Helper class to hand out messages using the default MessageArena.
-// Usage:
-// RootMessage<perfetto::protos::zero::MyMessage> msg;
-// msg.Reset(stream_writer);
-// msg.set_foo(...);
-// auto* nested = msg.set_nested();
-template <typename T = Message>
-class RootMessage : public T {
+
+class PERFETTO_EXPORT_COMPONENT IPCFrame_BindService : public ::protozero::CppMessageObj {
  public:
-  RootMessage() { T::Reset(nullptr, &root_arena_); }
+  enum FieldNumbers {
+    kServiceNameFieldNumber = 1,
+  };
 
-  // Disallow copy and move.
-  RootMessage(const RootMessage&) = delete;
-  RootMessage& operator=(const RootMessage&) = delete;
-  RootMessage(RootMessage&&) = delete;
-  RootMessage& operator=(RootMessage&&) = delete;
+  IPCFrame_BindService();
+  ~IPCFrame_BindService() override;
+  IPCFrame_BindService(IPCFrame_BindService&&) noexcept;
+  IPCFrame_BindService& operator=(IPCFrame_BindService&&);
+  IPCFrame_BindService(const IPCFrame_BindService&);
+  IPCFrame_BindService& operator=(const IPCFrame_BindService&);
+  bool operator==(const IPCFrame_BindService&) const;
+  bool operator!=(const IPCFrame_BindService& other) const { return !(*this == other); }
 
-  void Reset(ScatteredStreamWriter* writer) {
-    root_arena_.Reset();
-    Message::Reset(writer, &root_arena_);
-  }
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_service_name() const { return _has_field_[1]; }
+  const std::string& service_name() const { return service_name_; }
+  void set_service_name(const std::string& value) { service_name_ = value; _has_field_.set(1); }
 
  private:
-  MessageArena root_arena_;
+  std::string service_name_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<2> _has_field_{};
 };
 
-}  // namespace protozero
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
 
-#endif  // INCLUDE_PERFETTO_PROTOZERO_ROOT_MESSAGE_H_
-// gen_amalgamated begin header: include/perfetto/protozero/scattered_heap_buffer.h
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_WIRE_PROTOCOL_PROTO_CPP_H_
+// gen_amalgamated begin header: include/perfetto/protozero/gen_field_helpers.h
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2023 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -176583,175 +196443,153 @@ class RootMessage : public T {
  * limitations under the License.
  */
 
-#ifndef INCLUDE_PERFETTO_PROTOZERO_SCATTERED_HEAP_BUFFER_H_
-#define INCLUDE_PERFETTO_PROTOZERO_SCATTERED_HEAP_BUFFER_H_
-
-#include <memory>
-#include <string>
-#include <vector>
+#ifndef INCLUDE_PERFETTO_PROTOZERO_GEN_FIELD_HELPERS_H_
+#define INCLUDE_PERFETTO_PROTOZERO_GEN_FIELD_HELPERS_H_
 
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-// gen_amalgamated expanded: #include "perfetto/base/logging.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/root_message.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/scattered_stream_writer.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/message.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h"
+// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h"
 
 namespace protozero {
+namespace internal {
+namespace gen_helpers {
 
-class Message;
-
-class PERFETTO_EXPORT_COMPONENT ScatteredHeapBuffer
-    : public protozero::ScatteredStreamWriter::Delegate {
- public:
-  class PERFETTO_EXPORT_COMPONENT Slice {
-   public:
-    Slice();
-    explicit Slice(size_t size);
-    Slice(Slice&& slice) noexcept;
-    ~Slice();
-    Slice& operator=(Slice&&);
-
-    inline protozero::ContiguousMemoryRange GetTotalRange() const {
-      return {buffer_.get(), buffer_.get() + size_};
-    }
-
-    inline protozero::ContiguousMemoryRange GetUsedRange() const {
-      return {buffer_.get(), buffer_.get() + size_ - unused_bytes_};
-    }
+// This file implements some helpers used by the protobuf generated code in the
+// .gen.cc files.
+//
+// The .gen.cc generated protobuf implementation (as opposed to the .pbzero.h
+// implementation) is not zero-copy and is not supposed to be used in fast
+// paths, so most of these helpers are designed to reduce binary size.
 
-    uint8_t* start() const { return buffer_.get(); }
-    size_t size() const { return size_; }
-    size_t unused_bytes() const { return unused_bytes_; }
-    void set_unused_bytes(size_t unused_bytes) {
-      PERFETTO_DCHECK(unused_bytes_ <= size_);
-      unused_bytes_ = unused_bytes;
-    }
+void DeserializeString(const protozero::Field& field, std::string* dst);
 
-    void Clear();
+// Read packed repeated elements (serialized as `wire_type`) from `field` into
+// the `*dst` vector. Returns false if some bytes of `field` could not be
+// interpreted correctly as `wire_type`.
+template <proto_utils::ProtoWireType wire_type, typename CppType>
+bool DeserializePackedRepeated(const protozero::Field& field,
+                               std::vector<CppType>* dst) {
+  bool parse_error = false;
+  for (::protozero::PackedRepeatedFieldIterator<wire_type, CppType> rep(
+           field.data(), field.size(), &parse_error);
+       rep; ++rep) {
+    dst->emplace_back(*rep);
+  }
+  return !parse_error;
+}
 
-   private:
-    std::unique_ptr<uint8_t[]> buffer_;
-    size_t size_;
-    size_t unused_bytes_;
-  };
+extern template bool
+DeserializePackedRepeated<proto_utils::ProtoWireType::kVarInt, uint64_t>(
+    const protozero::Field& field,
+    std::vector<uint64_t>* dst);
 
-  ScatteredHeapBuffer(size_t initial_slice_size_bytes = 128,
-                      size_t maximum_slice_size_bytes = 128 * 1024);
-  ~ScatteredHeapBuffer() override;
+extern template bool
+DeserializePackedRepeated<proto_utils::ProtoWireType::kVarInt, int64_t>(
+    const protozero::Field& field,
+    std::vector<int64_t>* dst);
 
-  // protozero::ScatteredStreamWriter::Delegate implementation.
-  protozero::ContiguousMemoryRange GetNewBuffer() override;
+extern template bool
+DeserializePackedRepeated<proto_utils::ProtoWireType::kVarInt, uint32_t>(
+    const protozero::Field& field,
+    std::vector<uint32_t>* dst);
 
-  // Return the slices backing this buffer, adjusted for the number of bytes the
-  // writer has written.
-  const std::vector<Slice>& GetSlices();
+extern template bool
+DeserializePackedRepeated<proto_utils::ProtoWireType::kVarInt, int32_t>(
+    const protozero::Field& field,
+    std::vector<int32_t>* dst);
 
-  // Stitch all the slices into a single contiguous buffer.
-  std::vector<uint8_t> StitchSlices();
+// Serializers for different type of fields
 
-  // Note that the returned ranges point back to this buffer and thus cannot
-  // outlive it.
-  std::vector<protozero::ContiguousMemoryRange> GetRanges();
+void SerializeTinyVarInt(uint32_t field_id, bool value, Message* msg);
 
-  // Note that size of the last slice isn't updated to reflect the number of
-  // bytes written by the trace writer.
-  const std::vector<Slice>& slices() const { return slices_; }
+template <typename T>
+void SerializeExtendedVarInt(uint32_t field_id, T value, Message* msg) {
+  msg->AppendVarInt(field_id, value);
+}
 
-  void set_writer(protozero::ScatteredStreamWriter* writer) {
-    writer_ = writer;
-  }
+extern template void SerializeExtendedVarInt<uint64_t>(uint32_t field_id,
+                                                       uint64_t value,
+                                                       Message* msg);
 
-  // Update unused_bytes() of the current |Slice| based on the writer's state.
-  void AdjustUsedSizeOfCurrentSlice();
+extern template void SerializeExtendedVarInt<uint32_t>(uint32_t field_id,
+                                                       uint32_t value,
+                                                       Message* msg);
 
-  // Returns the total size the slices occupy in heap memory (including unused).
-  size_t GetTotalSize();
+template <typename T>
+void SerializeVarInt(uint32_t field_id, T value, Message* msg) {
+  SerializeExtendedVarInt(
+      field_id, proto_utils::ExtendValueForVarIntSerialization(value), msg);
+}
 
-  // Reset the contents of this buffer but retain one slice allocation (if it
-  // exists) to be reused for future writes.
-  void Reset();
+template <typename T>
+void SerializeSignedVarInt(uint32_t field_id, T value, Message* msg) {
+  SerializeVarInt(field_id, proto_utils::ZigZagEncode(value), msg);
+}
 
- private:
-  size_t next_slice_size_;
-  const size_t maximum_slice_size_;
-  protozero::ScatteredStreamWriter* writer_ = nullptr;
-  std::vector<Slice> slices_;
+template <typename T>
+void SerializeFixed(uint32_t field_id, T value, Message* msg) {
+  msg->AppendFixed(field_id, value);
+}
 
-  // Used to keep an allocated slice around after this buffer is reset.
-  Slice cached_slice_;
-};
+extern template void SerializeFixed<double>(uint32_t field_id,
+                                            double value,
+                                            Message* msg);
 
-// Helper function to create heap-based protozero messages in one line.
-// Useful when manually serializing a protozero message (primarily in
-// tests/utilities). So instead of the following:
-//   protozero::MyMessage msg;
-//   protozero::ScatteredHeapBuffer shb;
-//   protozero::ScatteredStreamWriter writer(&shb);
-//   shb.set_writer(&writer);
-//   msg.Reset(&writer);
-//   ...
-// You can write:
-//   protozero::HeapBuffered<protozero::MyMessage> msg;
-//   msg->set_stuff(...);
-//   msg.SerializeAsString();
-template <typename T = ::protozero::Message>
-class HeapBuffered {
- public:
-  HeapBuffered() : HeapBuffered(4096, 4096) {}
-  HeapBuffered(size_t initial_slice_size_bytes, size_t maximum_slice_size_bytes)
-      : shb_(initial_slice_size_bytes, maximum_slice_size_bytes),
-        writer_(&shb_) {
-    shb_.set_writer(&writer_);
-    msg_.Reset(&writer_);
-  }
+extern template void SerializeFixed<float>(uint32_t field_id,
+                                           float value,
+                                           Message* msg);
 
-  // This can't be neither copied nor moved because Message hands out pointers
-  // to itself when creating submessages.
-  HeapBuffered(const HeapBuffered&) = delete;
-  HeapBuffered& operator=(const HeapBuffered&) = delete;
-  HeapBuffered(HeapBuffered&&) = delete;
-  HeapBuffered& operator=(HeapBuffered&&) = delete;
+extern template void SerializeFixed<uint64_t>(uint32_t field_id,
+                                              uint64_t value,
+                                              Message* msg);
 
-  T* get() { return &msg_; }
-  T* operator->() { return &msg_; }
+extern template void SerializeFixed<int64_t>(uint32_t field_id,
+                                             int64_t value,
+                                             Message* msg);
 
-  bool empty() const { return shb_.slices().empty(); }
+extern template void SerializeFixed<uint32_t>(uint32_t field_id,
+                                              uint32_t value,
+                                              Message* msg);
 
-  std::vector<uint8_t> SerializeAsArray() {
-    msg_.Finalize();
-    return shb_.StitchSlices();
-  }
+extern template void SerializeFixed<int32_t>(uint32_t field_id,
+                                             int32_t value,
+                                             Message* msg);
 
-  std::string SerializeAsString() {
-    auto vec = SerializeAsArray();
-    return std::string(reinterpret_cast<const char*>(vec.data()), vec.size());
-  }
+void SerializeString(uint32_t field_id, const std::string& value, Message* msg);
 
-  std::vector<protozero::ContiguousMemoryRange> GetRanges() {
-    msg_.Finalize();
-    return shb_.GetRanges();
-  }
+void SerializeUnknownFields(const std::string& unknown_fields, Message* msg);
 
-  const std::vector<ScatteredHeapBuffer::Slice>& GetSlices() {
-    msg_.Finalize();
-    return shb_.GetSlices();
-  }
+// Wrapper around HeapBuffered that avoids inlining.
+class MessageSerializer {
+ public:
+  MessageSerializer();
+  ~MessageSerializer();
 
-  void Reset() {
-    shb_.Reset();
-    writer_.Reset(protozero::ContiguousMemoryRange{});
-    msg_.Reset(&writer_);
-    PERFETTO_DCHECK(empty());
-  }
+  Message* get() { return msg_.get(); }
+  std::vector<uint8_t> SerializeAsArray();
+  std::string SerializeAsString();
 
  private:
-  ScatteredHeapBuffer shb_;
-  ScatteredStreamWriter writer_;
-  RootMessage<T> msg_;
+  HeapBuffered<Message> msg_;
 };
 
+// Wrapper about operator==() which reduces the binary size of generated protos.
+// This is needed because std::string's operator== is inlined aggressively (even
+// when optimizing for size). Having this layer of indirection with removes the
+// overhead.
+template <typename T>
+bool EqualsField(const T& a, const T& b) {
+  return a == b;
+}
+extern template bool EqualsField<std::string>(const std::string&,
+                                              const std::string&);
+
+}  // namespace gen_helpers
+}  // namespace internal
 }  // namespace protozero
 
-#endif  // INCLUDE_PERFETTO_PROTOZERO_SCATTERED_HEAP_BUFFER_H_
+#endif  // INCLUDE_PERFETTO_PROTOZERO_GEN_FIELD_HELPERS_H_
 // gen_amalgamated begin header: include/perfetto/protozero/scattered_stream_null_delegate.h
 /*
  * Copyright (C) 2018 The Android Open Source Project
@@ -176799,164 +196637,6 @@ class PERFETTO_EXPORT_COMPONENT ScatteredStreamWriterNullDelegate
 }  // namespace protozero
 
 #endif  // INCLUDE_PERFETTO_PROTOZERO_SCATTERED_STREAM_NULL_DELEGATE_H_
-// gen_amalgamated begin header: include/perfetto/protozero/scattered_stream_writer.h
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef INCLUDE_PERFETTO_PROTOZERO_SCATTERED_STREAM_WRITER_H_
-#define INCLUDE_PERFETTO_PROTOZERO_SCATTERED_STREAM_WRITER_H_
-
-#include <assert.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
-
-// gen_amalgamated expanded: #include "perfetto/base/compiler.h"
-// gen_amalgamated expanded: #include "perfetto/base/export.h"
-// gen_amalgamated expanded: #include "perfetto/protozero/contiguous_memory_range.h"
-
-namespace protozero {
-
-// This class deals with the following problem: append-only proto messages want
-// to write a stream of bytes, without caring about the implementation of the
-// underlying buffer (which concretely will be either the trace ring buffer
-// or a heap-allocated buffer). The main deal is: proto messages don't know in
-// advance what their size will be.
-// Due to the tracing buffer being split into fixed-size chunks, on some
-// occasions, these writes need to be spread over two (or more) non-contiguous
-// chunks of memory. Similarly, when the buffer is backed by the heap, we want
-// to avoid realloc() calls, as they might cause a full copy of the contents
-// of the buffer.
-// The purpose of this class is to abstract away the non-contiguous write logic.
-// This class knows how to deal with writes as long as they fall in the same
-// ContiguousMemoryRange and defers the chunk-chaining logic to the Delegate.
-class PERFETTO_EXPORT_COMPONENT ScatteredStreamWriter {
- public:
-  class PERFETTO_EXPORT_COMPONENT Delegate {
-   public:
-    static constexpr size_t kPatchSize = 4;
-    virtual ~Delegate();
-
-    // Returns a new chunk for writing.
-    virtual ContiguousMemoryRange GetNewBuffer() = 0;
-
-    // Signals the delegate that the location pointed by `to_patch` (which must
-    // be in the last chunk returned by GetNewBuffer()), kPatchSize long, needs
-    // to be updated later (after potentially multiple GetNewBuffer calls).
-    //
-    // The caller must write to the returned location later. If the returned
-    // pointer is nullptr, the caller should not write anything.
-    //
-    // The implementation considers the patch ready to apply when the caller
-    // writes the the first byte a value that's different than 0 (the
-    // implementation periodically checks for this).
-    virtual uint8_t* AnnotatePatch(uint8_t* patch_addr);
-  };
-
-  explicit ScatteredStreamWriter(Delegate* delegate);
-  ~ScatteredStreamWriter();
-
-  inline void WriteByte(uint8_t value) {
-    if (write_ptr_ >= cur_range_.end)
-      Extend();
-    *write_ptr_++ = value;
-  }
-
-  // Assumes that the caller checked that there is enough headroom.
-  // TODO(primiano): perf optimization, this is a tracing hot path. The
-  // compiler can make strong optimization on memcpy if the size arg is a
-  // constexpr. Make a templated variant of this for fixed-size writes.
-  // TODO(primiano): restrict / noalias might also help.
-  inline void WriteBytesUnsafe(const uint8_t* src, size_t size) {
-    uint8_t* const end = write_ptr_ + size;
-    assert(end <= cur_range_.end);
-    memcpy(write_ptr_, src, size);
-    write_ptr_ = end;
-  }
-
-  inline void WriteBytes(const uint8_t* src, size_t size) {
-    uint8_t* const end = write_ptr_ + size;
-    if (PERFETTO_LIKELY(end <= cur_range_.end))
-      return WriteBytesUnsafe(src, size);
-    WriteBytesSlowPath(src, size);
-  }
-
-  void WriteBytesSlowPath(const uint8_t* src, size_t size);
-
-  // Reserves a fixed amount of bytes to be backfilled later. The reserved range
-  // is guaranteed to be contiguous and not span across chunks. |size| has to be
-  // <= than the size of a new buffer returned by the Delegate::GetNewBuffer().
-  uint8_t* ReserveBytes(size_t size);
-
-  // Fast (but unsafe) version of the above. The caller must have previously
-  // checked that there are at least |size| contiguous bytes available.
-  // Returns only the start pointer of the reservation.
-  uint8_t* ReserveBytesUnsafe(size_t size) {
-    uint8_t* begin = write_ptr_;
-    write_ptr_ += size;
-    assert(write_ptr_ <= cur_range_.end);
-    return begin;
-  }
-
-  // Resets the buffer boundaries and the write pointer to the given |range|.
-  // Subsequent WriteByte(s) will write into |range|.
-  void Reset(ContiguousMemoryRange range);
-
-  // Commits the current chunk and gets a new chunk from the delegate.
-  void Extend();
-
-  // Number of contiguous free bytes in |cur_range_| that can be written without
-  // requesting a new buffer.
-  size_t bytes_available() const {
-    return static_cast<size_t>(cur_range_.end - write_ptr_);
-  }
-
-  ContiguousMemoryRange cur_range() const { return cur_range_; }
-
-  uint8_t* write_ptr() const { return write_ptr_; }
-
-  void set_write_ptr(uint8_t* write_ptr) {
-    assert(cur_range_.begin <= write_ptr && write_ptr <= cur_range_.end);
-    write_ptr_ = write_ptr;
-  }
-
-  uint64_t written() const {
-    return written_previously_ +
-           static_cast<uint64_t>(write_ptr_ - cur_range_.begin);
-  }
-
-  uint64_t written_previously() const { return written_previously_; }
-
-  uint8_t* AnnotatePatch(uint8_t* patch_addr) {
-    return delegate_->AnnotatePatch(patch_addr);
-  }
-
- private:
-  ScatteredStreamWriter(const ScatteredStreamWriter&) = delete;
-  ScatteredStreamWriter& operator=(const ScatteredStreamWriter&) = delete;
-
-  Delegate* const delegate_;
-  ContiguousMemoryRange cur_range_;
-  uint8_t* write_ptr_;
-  uint64_t written_previously_ = 0;
-};
-
-}  // namespace protozero
-
-#endif  // INCLUDE_PERFETTO_PROTOZERO_SCATTERED_STREAM_WRITER_H_
 // gen_amalgamated begin header: include/perfetto/protozero/static_buffer.h
 /*
  * Copyright (C) 2019 The Android Open Source Project
diff --git a/velox/external/tzdb/patches/0004-support-tzdir-pr-15871.patch b/velox/external/tzdb/patches/0004-support-tzdir-pr-15871.patch
new file mode 100644
index 00000000000..9d455c52f18
--- /dev/null
+++ b/velox/external/tzdb/patches/0004-support-tzdir-pr-15871.patch
@@ -0,0 +1,18 @@
+diff --git a/velox/external/tzdb/tzdb.cpp b/velox/external/tzdb/tzdb.cpp
+index c4e16b139..63a6d3458 100644
+--- a/velox/external/tzdb/tzdb.cpp
++++ b/velox/external/tzdb/tzdb.cpp
+@@ -57,6 +57,13 @@ using namespace std::chrono_literals;
+ std::string __libcpp_tzdb_directory() {
+   struct stat sb;
+   using namespace std;
++  // First, check for the TZDIR environment variable.
++  // If set, it takes precedence over standard system paths.
++  if (auto tzdir = getenv("TZDIR")) {
++    if (stat(tzdir, &sb) == 0 && S_ISDIR(sb.st_mode)) {
++        return tzdir;
++    }
++  }
+ #if !defined(__APPLE__)
+   CONSTDATA auto tz_dir_default = "/usr/share/zoneinfo";
+   CONSTDATA auto tz_dir_buildroot = "/usr/share/zoneinfo/uclibc";
diff --git a/velox/external/tzdb/tzdb.cpp b/velox/external/tzdb/tzdb.cpp
index c4e16b139b9..63a6d34583c 100644
--- a/velox/external/tzdb/tzdb.cpp
+++ b/velox/external/tzdb/tzdb.cpp
@@ -57,6 +57,13 @@ using namespace std::chrono_literals;
 std::string __libcpp_tzdb_directory() {
   struct stat sb;
   using namespace std;
+  // First, check for the TZDIR environment variable.
+  // If set, it takes precedence over standard system paths.
+  if (auto tzdir = getenv("TZDIR")) {
+    if (stat(tzdir, &sb) == 0 && S_ISDIR(sb.st_mode)) {
+        return tzdir;
+    }
+  }
 #if !defined(__APPLE__)
   CONSTDATA auto tz_dir_default = "/usr/share/zoneinfo";
   CONSTDATA auto tz_dir_buildroot = "/usr/share/zoneinfo/uclibc";
diff --git a/velox/external/tzdb/tzdb_list_private.h b/velox/external/tzdb/tzdb_list_private.h
index 9fa8dbab56b..e60888d1baa 100644
--- a/velox/external/tzdb/tzdb_list_private.h
+++ b/velox/external/tzdb/tzdb_list_private.h
@@ -43,7 +43,7 @@ class tzdb_list::__impl {
 
   [[nodiscard]] const tzdb& __load() {
 #if _LIBCPP_HAS_THREADS
-    unique_lock __lock{__mutex_};
+    std::unique_lock __lock{__mutex_};
 #endif
     __load_no_lock();
     return __tzdb_.front();
@@ -53,14 +53,14 @@ class tzdb_list::__impl {
 
   const tzdb& __front() const noexcept {
 #if _LIBCPP_HAS_THREADS
-    unique_lock __lock{__mutex_};
+    std::unique_lock __lock{__mutex_};
 #endif
     return __tzdb_.front();
   }
 
   const_iterator __erase_after(const_iterator __p) {
 #if _LIBCPP_HAS_THREADS
-    unique_lock __lock{__mutex_};
+    std::unique_lock __lock{__mutex_};
 #endif
 
     __rules_.erase_after(
@@ -70,7 +70,7 @@ class tzdb_list::__impl {
 
   const_iterator __begin() const noexcept {
 #if _LIBCPP_HAS_THREADS
-    unique_lock __lock{__mutex_};
+    std::unique_lock __lock{__mutex_};
 #endif
     return __tzdb_.begin();
   }
@@ -88,7 +88,7 @@ class tzdb_list::__impl {
   }
 
 #if _LIBCPP_HAS_THREADS
-  mutable mutex __mutex_;
+  mutable std::mutex __mutex_;
 #endif
   std::forward_list<tzdb> __tzdb_;
 
diff --git a/velox/flag_definitions/flags.cpp b/velox/flag_definitions/flags.cpp
index 1c12d365159..8648e80a68e 100644
--- a/velox/flag_definitions/flags.cpp
+++ b/velox/flag_definitions/flags.cpp
@@ -100,11 +100,6 @@ DEFINE_bool(
     false,
     "If true, check fails on any memory leaks in memory pool and memory manager");
 
-DEFINE_bool(
-    velox_memory_pool_debug_enabled,
-    false,
-    "If true, 'MemoryPool' will be running in debug mode to track the allocation and free call sites to detect the source of memory leak for testing purpose");
-
 // TODO: deprecate this after solves all the use cases that can cause
 // significant performance regression by memory usage tracking.
 DEFINE_bool(
diff --git a/velox/functions/CMakeLists.txt b/velox/functions/CMakeLists.txt
index 3401db234e0..2050876be1f 100644
--- a/velox/functions/CMakeLists.txt
+++ b/velox/functions/CMakeLists.txt
@@ -11,8 +11,8 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-velox_add_library(velox_function_registry FunctionRegistry.cpp)
-velox_add_library(velox_coverage_util CoverageUtil.cpp)
+velox_add_library(velox_function_registry FunctionRegistry.cpp HEADERS FunctionRegistry.h)
+velox_add_library(velox_coverage_util CoverageUtil.cpp HEADERS CoverageUtil.h)
 
 velox_link_libraries(velox_function_registry velox_expression velox_type velox_core velox_exception)
 velox_link_libraries(velox_coverage_util velox_function_registry)
@@ -36,3 +36,9 @@ endif()
 if(${VELOX_ENABLE_ICEBERG_FUNCTIONS})
   add_subdirectory(iceberg)
 endif()
+
+velox_add_library(velox_udf_output_string INTERFACE HEADERS UDFOutputString.h)
+
+velox_add_library(velox_functions_macros INTERFACE HEADERS Macros.h)
+
+velox_add_library(velox_functions INTERFACE HEADERS Registerer.h Udf.h)
diff --git a/velox/functions/CoverageUtil.cpp b/velox/functions/CoverageUtil.cpp
index a767ce3938b..25b842e0d10 100644
--- a/velox/functions/CoverageUtil.cpp
+++ b/velox/functions/CoverageUtil.cpp
@@ -21,6 +21,7 @@
 #include <iostream>
 #include "velox/exec/Aggregate.h"
 #include "velox/exec/WindowFunction.h"
+#include "velox/expression/ExprConstants.h"
 #include "velox/functions/FunctionRegistry.h"
 
 namespace facebook::velox::functions {
@@ -297,7 +298,9 @@ bool isCompanionFunctionName(
 /// excluding companion functions.
 std::vector<std::string> getSortedScalarNames() {
   // Do not print "internal" functions.
-  static const std::unordered_set<std::string> kBlockList = {"row_constructor"};
+  static const folly::F14FastSet<std::string_view> kBlockList{
+      expression::kRowConstructor,
+  };
 
   auto functions = getFunctionSignatures();
 
diff --git a/velox/functions/FunctionRegistry.cpp b/velox/functions/FunctionRegistry.cpp
index af10c292531..4e636bf4c8c 100644
--- a/velox/functions/FunctionRegistry.cpp
+++ b/velox/functions/FunctionRegistry.cpp
@@ -109,6 +109,25 @@ std::optional<bool> isDeterministic(const std::string& functionName) {
   return true;
 }
 
+std::optional<bool> isDefaultNullBehavior(const std::string& functionName) {
+  const auto simpleFunctions =
+      exec::simpleFunctions().getFunctionSignaturesAndMetadata(functionName);
+  const auto metadata = exec::getVectorFunctionMetadata(functionName);
+  if (simpleFunctions.empty() && !metadata.has_value()) {
+    return std::nullopt;
+  }
+
+  for (const auto& [funcMetadata, _] : simpleFunctions) {
+    if (!funcMetadata.defaultNullBehavior) {
+      return false;
+    }
+  }
+  if (metadata.has_value() && !metadata.value().defaultNullBehavior) {
+    return false;
+  }
+  return true;
+}
+
 TypePtr resolveFunction(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes) {
@@ -121,20 +140,42 @@ TypePtr resolveFunction(
   return resolveVectorFunction(functionName, argTypes);
 }
 
+namespace {
+bool hasCoercions(const std::vector<TypePtr>& coercions) {
+  return std::any_of(
+      coercions.cbegin(), coercions.cend(), [](const auto& coercion) {
+        return coercion != nullptr;
+      });
+}
+} // namespace
+
 TypePtr resolveFunctionWithCoercions(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes,
-    std::vector<TypePtr>& coercions) {
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer) {
   // Check if this is a simple function.
   if (auto resolvedFunction =
           exec::simpleFunctions().resolveFunctionWithCoercions(
-              functionName, argTypes, coercions)) {
+              functionName, argTypes, coercions, coercer)) {
+    if (hasCoercions(coercions)) {
+      // Check if there is a vector function that can be invoked without
+      // coercions.
+      std::vector<TypePtr> alternativeCoersions;
+      auto otherType = exec::resolveVectorFunctionWithCoercions(
+          functionName, argTypes, alternativeCoersions, coercer);
+      if (otherType != nullptr && !hasCoercions(alternativeCoersions)) {
+        coercions.clear();
+        return otherType;
+      }
+    }
+
     return resolvedFunction->type();
   }
 
   // Check if VectorFunctions has this function name + signature.
   return exec::resolveVectorFunctionWithCoercions(
-      functionName, argTypes, coercions);
+      functionName, argTypes, coercions, coercer);
 }
 
 std::optional<std::pair<TypePtr, exec::VectorFunctionMetadata>>
@@ -160,12 +201,35 @@ TypePtr resolveFunctionOrCallableSpecialForm(
   return resolveFunction(functionName, argTypes);
 }
 
+TypePtr resolveFunctionOrCallableSpecialFormWithCoercions(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer) {
+  if (auto returnType = resolveCallableSpecialFormWithCoercions(
+          functionName, argTypes, coercions, coercer)) {
+    return returnType;
+  }
+
+  return resolveFunctionWithCoercions(
+      functionName, argTypes, coercions, coercer);
+}
+
 TypePtr resolveCallableSpecialForm(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes) {
   return exec::resolveTypeForSpecialForm(functionName, argTypes);
 }
 
+TypePtr resolveCallableSpecialFormWithCoercions(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer) {
+  return exec::resolveTypeForSpecialFormWithCoercions(
+      functionName, argTypes, coercions, coercer);
+}
+
 TypePtr resolveSimpleFunction(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes) {
@@ -190,6 +254,16 @@ resolveVectorFunctionWithMetadata(
   return exec::resolveVectorFunctionWithMetadata(functionName, argTypes);
 }
 
+std::optional<std::pair<TypePtr, exec::VectorFunctionMetadata>>
+resolveVectorFunctionWithMetadataWithCoercions(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer) {
+  return exec::resolveVectorFunctionWithMetadataWithCoercions(
+      functionName, argTypes, coercions, coercer);
+}
+
 void removeFunction(const std::string& functionName) {
   exec::mutableSimpleFunctions().removeFunction(functionName);
   exec::vectorFunctionFactories().withWLock(
diff --git a/velox/functions/FunctionRegistry.h b/velox/functions/FunctionRegistry.h
index df7a1d55c44..cf49971dd50 100644
--- a/velox/functions/FunctionRegistry.h
+++ b/velox/functions/FunctionRegistry.h
@@ -21,6 +21,7 @@
 #include "velox/expression/FunctionMetadata.h"
 #include "velox/expression/FunctionSignature.h"
 #include "velox/type/Type.h"
+#include "velox/type/TypeCoercer.h"
 
 namespace facebook::velox {
 
@@ -46,6 +47,13 @@ FunctionSignatureMap getVectorFunctionSignatures();
 /// the entries are not deterministic.
 std::optional<bool> isDeterministic(const std::string& functionName);
 
+/// Returns if a function has default null behavior (null in any input produces
+/// null output) by fetching all registry entries for the given function name
+/// and checking if all of them have default null behavior.
+/// Returns std::nullopt if the function is not found. Returns false if any of
+/// the entries do not have default null behavior.
+std::optional<bool> isDefaultNullBehavior(const std::string& functionName);
+
 /// Given a function name and argument types, returns
 /// the return type if function exists otherwise returns nullptr
 TypePtr resolveFunction(
@@ -70,7 +78,8 @@ TypePtr resolveFunction(
 TypePtr resolveFunctionWithCoercions(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes,
-    std::vector<TypePtr>& coercions);
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer);
 
 /// Given a function name and argument types, returns a pair of return
 /// type and metadata if function exists. Otherwise, returns std::nullopt.
@@ -86,6 +95,20 @@ TypePtr resolveFunctionOrCallableSpecialForm(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes);
 
+/// Like 'resolveFunctionOrCallableSpecialForm', but with support for applying
+/// type conversions if a function or a special form signature doesn't match
+/// 'argTypes' exactly.
+///
+/// @param coercions A list of optional type coercions that were applied to
+/// resolve a function or a special form successfully. Contains one entry per
+/// argument. The entry is null if no coercion is required for that argument.
+/// The entry is not null if coercion is necessary.
+TypePtr resolveFunctionOrCallableSpecialFormWithCoercions(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer);
+
 /// Given the name of a special form and argument types, returns
 /// the return type if the special form exists and is supported, otherwise
 /// returns nullptr.
@@ -98,6 +121,20 @@ TypePtr resolveCallableSpecialForm(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes);
 
+/// Like 'resolveCallableSpecialForm', but with support for applying
+/// type conversions if a special form signature doesn't match 'argTypes'
+/// exactly.
+///
+/// @param coercions A list of optional type coercions that were applied to
+/// resolve a special form successfully. Contains one entry per argument. The
+/// entry is null if no coercion is required for that argument. The entry is not
+/// null if coercion is necessary.
+TypePtr resolveCallableSpecialFormWithCoercions(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer);
+
 /// Given name of simple function and argument types, returns
 /// the return type if function exists otherwise returns nullptr
 TypePtr resolveSimpleFunction(
@@ -117,6 +154,20 @@ resolveVectorFunctionWithMetadata(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes);
 
+/// Like 'resolveVectorFunctionWithMetadata', but with support for applying type
+/// coercions if no signature matches 'argTypes' exactly.
+///
+/// @param coercions A list of optional type coercions that were applied to
+/// resolve the function successfully. Contains one entry per argument. The
+/// entry is null if no coercion is required for that argument. The entry is not
+/// null if coercion is necessary.
+std::optional<std::pair<TypePtr, exec::VectorFunctionMetadata>>
+resolveVectorFunctionWithMetadataWithCoercions(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions,
+    const TypeCoercer& coercer);
+
 /// Given name of a function, removes it from both the simple and vector
 /// function registries (including all signatures).
 void removeFunction(const std::string& functionName);
diff --git a/velox/functions/UDFOutputString.h b/velox/functions/UDFOutputString.h
index 6271a6b5d19..c14340f3d8a 100644
--- a/velox/functions/UDFOutputString.h
+++ b/velox/functions/UDFOutputString.h
@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include <algorithm>
 #include <cstring>
 #include <string_view>
 
diff --git a/velox/functions/iceberg/CMakeLists.txt b/velox/functions/iceberg/CMakeLists.txt
index 6dac7e5bdab..c680cde06ee 100644
--- a/velox/functions/iceberg/CMakeLists.txt
+++ b/velox/functions/iceberg/CMakeLists.txt
@@ -12,11 +12,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_functions_iceberg_hash Murmur3Hash32.cpp)
+velox_add_library(velox_functions_iceberg_hash Murmur3Hash32.cpp HEADERS Murmur3Hash32.h)
 
 velox_link_libraries(velox_functions_iceberg_hash velox_common_base velox_functions_util)
 
-velox_add_library(velox_functions_iceberg BucketFunction.cpp Register.cpp)
+velox_add_library(
+  velox_functions_iceberg
+  BucketFunction.cpp
+  DateTimeFunctions.cpp
+  Register.cpp
+  Truncate.cpp
+  HEADERS
+  BucketFunction.h
+  DateTimeFunctions.h
+  DateTimeUtil.h
+  Register.h
+  Truncate.h
+)
 
 velox_link_libraries(
   velox_functions_iceberg
diff --git a/velox/functions/iceberg/DateTimeFunctions.cpp b/velox/functions/iceberg/DateTimeFunctions.cpp
new file mode 100644
index 00000000000..4e0f6e480f1
--- /dev/null
+++ b/velox/functions/iceberg/DateTimeFunctions.cpp
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/iceberg/DateTimeFunctions.h"
+#include "velox/functions/Macros.h"
+#include "velox/functions/Registerer.h"
+#include "velox/functions/iceberg/DateTimeUtil.h"
+
+namespace facebook::velox::functions::iceberg {
+
+// years(input) -> years from 1970
+// Input is date or timestamp.
+template <typename TExec>
+struct YearsFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      int32_t& result,
+      const arg_type<Timestamp>& timestamp) {
+    result = epochYear(timestamp);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(int32_t& result, const arg_type<Date>& date) {
+    result = epochYear(date);
+  }
+};
+
+// months(input) -> months from 1970-01-01
+// Input is date or timestamp.
+template <typename TExec>
+struct MonthsFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      int32_t& result,
+      const arg_type<Timestamp>& timestamp) {
+    result = epochMonth(timestamp);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(int32_t& result, const arg_type<Date>& date) {
+    result = epochMonth(date);
+  }
+};
+
+// days(input) -> days from 1970-01-01
+// Input is date or timestamp.
+template <typename TExec>
+struct DaysFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Date>& result,
+      const arg_type<Timestamp>& timestamp) {
+    result = epochDay(timestamp);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Date>& result,
+      const arg_type<Date>& date) {
+    result = date;
+  }
+};
+
+// hours(input) -> hours from 1970-01-01 00:00:00
+// Input is timestamp.
+template <typename TExec>
+struct HoursFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      int32_t& result,
+      const arg_type<Timestamp>& timestamp) {
+    result = epochHour(timestamp);
+  }
+};
+
+void registerDateTimeFunctions(const std::string& prefix) {
+  registerFunction<YearsFunction, int32_t, Timestamp>({prefix + "years"});
+  registerFunction<YearsFunction, int32_t, Date>({prefix + "years"});
+  registerFunction<MonthsFunction, int32_t, Timestamp>({prefix + "months"});
+  registerFunction<MonthsFunction, int32_t, Date>({prefix + "months"});
+  registerFunction<DaysFunction, Date, Timestamp>({prefix + "days"});
+  registerFunction<DaysFunction, Date, Date>({prefix + "days"});
+  registerFunction<HoursFunction, int32_t, Timestamp>({prefix + "hours"});
+}
+
+} // namespace facebook::velox::functions::iceberg
diff --git a/velox/functions/iceberg/DateTimeFunctions.h b/velox/functions/iceberg/DateTimeFunctions.h
new file mode 100644
index 00000000000..496aae48bb8
--- /dev/null
+++ b/velox/functions/iceberg/DateTimeFunctions.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace facebook::velox::functions::iceberg {
+
+void registerDateTimeFunctions(const std::string& prefix);
+
+} // namespace facebook::velox::functions::iceberg
diff --git a/velox/functions/iceberg/DateTimeUtil.h b/velox/functions/iceberg/DateTimeUtil.h
new file mode 100644
index 00000000000..37515988916
--- /dev/null
+++ b/velox/functions/iceberg/DateTimeUtil.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/functions/lib/TimeUtils.h"
+
+namespace facebook::velox::functions::iceberg {
+
+/// Extract a date year, as years from 1970.
+FOLLY_ALWAYS_INLINE int32_t epochYear(int32_t daysSinceEpoch) {
+  return functions::getYear(functions::getDateTime(daysSinceEpoch)) - 1970;
+}
+
+/// Extract a timestamp year, as years from 1970.
+FOLLY_ALWAYS_INLINE int32_t epochYear(Timestamp ts) {
+  return functions::getYear(functions::getDateTime(ts, nullptr)) - 1970;
+}
+
+/// Extract a date month, as months from 1970-01-01.
+FOLLY_ALWAYS_INLINE int32_t epochMonth(int32_t daysSinceEpoch) {
+  const std::tm tm = functions::getDateTime(daysSinceEpoch);
+  return (functions::getYear(tm) - 1970) * 12 + tm.tm_mon;
+}
+
+/// Extract a timestamp month, as months from 1970-01-01.
+FOLLY_ALWAYS_INLINE int32_t epochMonth(Timestamp ts) {
+  const std::tm tm = functions::getDateTime(ts, nullptr);
+  return (functions::getYear(tm) - 1970) * 12 + tm.tm_mon;
+}
+
+/// Extract a timestamp day, as days from 1970-01-01.
+FOLLY_ALWAYS_INLINE int32_t epochDay(Timestamp ts) {
+  const auto seconds = ts.getSeconds();
+  return (seconds >= 0) ? seconds / Timestamp::kSecondsInDay
+                        : ((seconds + 1) / Timestamp::kSecondsInDay) - 1;
+}
+
+/// Extract a timestamp hour, as hours from 1970-01-01 00:00:00.
+FOLLY_ALWAYS_INLINE int32_t epochHour(Timestamp ts) {
+  const auto seconds = ts.getSeconds();
+  return (seconds >= 0) ? seconds / 3'600 : ((seconds + 1) / 3'600) - 1;
+}
+
+} // namespace facebook::velox::functions::iceberg
diff --git a/velox/functions/iceberg/Register.cpp b/velox/functions/iceberg/Register.cpp
index 026389ea5cb..ab8afc4ed7b 100644
--- a/velox/functions/iceberg/Register.cpp
+++ b/velox/functions/iceberg/Register.cpp
@@ -16,11 +16,15 @@
 
 #include "velox/functions/iceberg/Register.h"
 #include "velox/functions/iceberg/BucketFunction.h"
+#include "velox/functions/iceberg/DateTimeFunctions.h"
+#include "velox/functions/iceberg/Truncate.h"
 
 namespace facebook::velox::functions::iceberg {
 
 void registerFunctions(const std::string& prefix) {
   registerBucketFunctions(prefix);
+  registerTruncateFunctions(prefix);
+  registerDateTimeFunctions(prefix);
 }
 
 } // namespace facebook::velox::functions::iceberg
diff --git a/velox/functions/iceberg/Truncate.cpp b/velox/functions/iceberg/Truncate.cpp
new file mode 100644
index 00000000000..82e166d1b9b
--- /dev/null
+++ b/velox/functions/iceberg/Truncate.cpp
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/iceberg/Truncate.h"
+#include "velox/functions/Macros.h"
+#include "velox/functions/Registerer.h"
+#include "velox/functions/lib/string/StringImpl.h"
+
+namespace facebook::velox::functions::iceberg {
+namespace {
+// truncate(width, input) -> truncatedValue
+// For numeric values, truncate to the nearest lower multiple of width works
+// consistently for both positive and negative values of input, even in
+// languages where the % operator can return a negative remainder. The width is
+// used to truncate decimal values is applied using unscaled value to avoid
+// additional (and potentially conflicting) parameters. For string values, it
+// truncates a valid UTF-8 string with no more than width code points. In
+// contrast to strings, binary values do not have an assumed encoding and are
+// truncated to width bytes.
+template <typename TExec>
+struct TruncateFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  // ASCII input always produces ASCII result.
+  static constexpr bool is_default_ascii_behavior = true;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      const int32_t* /*width*/,
+      const arg_type<Varchar>* /*input*/) {
+    inputIsVarbinary_ = inputTypes[1]->isVarbinary();
+  }
+
+  template <typename T>
+  FOLLY_ALWAYS_INLINE Status call(T& out, int32_t width, T input) {
+    VELOX_USER_RETURN_LE(width, 0, "Invalid truncate width");
+    // Truncate to the nearest lower multiple of width.
+    out = input - ((input % width) + width) % width;
+    return Status::OK();
+  }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<Varchar>& result,
+      int32_t width,
+      const arg_type<Varchar>& input) {
+    VELOX_USER_RETURN_LE(width, 0, "Invalid truncate width");
+    const auto truncatedwidth = inputIsVarbinary_
+        ? stringImpl::cappedByteLength<true>(input, width)
+        : stringImpl::cappedByteLength<false>(input, width);
+    result = StringView(input.data(), truncatedwidth);
+    return Status::OK();
+  }
+
+  FOLLY_ALWAYS_INLINE Status callAscii(
+      out_type<Varchar>& result,
+      int32_t width,
+      const arg_type<Varchar>& input) {
+    VELOX_USER_RETURN_LE(width, 0, "Invalid truncate width");
+    auto truncatedwidth = stringImpl::cappedLength<true>(input, width);
+    result = StringView(input.data(), truncatedwidth);
+    return Status::OK();
+  }
+
+ private:
+  bool inputIsVarbinary_ = false;
+};
+} // namespace
+
+void registerTruncateFunctions(const std::string& prefix) {
+  registerFunction<TruncateFunction, int8_t, int32_t, int8_t>(
+      {prefix + "truncate"});
+  registerFunction<TruncateFunction, int16_t, int32_t, int16_t>(
+      {prefix + "truncate"});
+  registerFunction<TruncateFunction, int32_t, int32_t, int32_t>(
+      {prefix + "truncate"});
+  registerFunction<TruncateFunction, int64_t, int32_t, int64_t>(
+      {prefix + "truncate"});
+  registerFunction<TruncateFunction, Varchar, int32_t, Varchar>(
+      {prefix + "truncate"});
+  registerFunction<TruncateFunction, Varbinary, int32_t, Varbinary>(
+      {prefix + "truncate"});
+  registerFunction<
+      TruncateFunction,
+      LongDecimal<P1, S1>,
+      int32_t,
+      LongDecimal<P1, S1>>({prefix + "truncate"});
+
+  registerFunction<
+      TruncateFunction,
+      ShortDecimal<P1, S1>,
+      int32_t,
+      ShortDecimal<P1, S1>>({prefix + "truncate"});
+}
+
+} // namespace facebook::velox::functions::iceberg
diff --git a/velox/functions/iceberg/Truncate.h b/velox/functions/iceberg/Truncate.h
new file mode 100644
index 00000000000..e31376d4362
--- /dev/null
+++ b/velox/functions/iceberg/Truncate.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace facebook::velox::functions::iceberg {
+
+void registerTruncateFunctions(const std::string& prefix);
+
+} // namespace facebook::velox::functions::iceberg
diff --git a/velox/functions/iceberg/tests/BucketFunctionTest.cpp b/velox/functions/iceberg/tests/BucketFunctionTest.cpp
index 3de2f66be34..f12242d17db 100644
--- a/velox/functions/iceberg/tests/BucketFunctionTest.cpp
+++ b/velox/functions/iceberg/tests/BucketFunctionTest.cpp
@@ -27,11 +27,6 @@ namespace {
 
 class BucketFunctionTest
     : public functions::iceberg::test::IcebergFunctionBaseTest {
- public:
-  BucketFunctionTest() {
-    options_.parseDecimalAsDouble = false;
-  }
-
  protected:
   template <typename T>
   std::optional<int32_t> bucket(
diff --git a/velox/functions/iceberg/tests/CMakeLists.txt b/velox/functions/iceberg/tests/CMakeLists.txt
index 133f7398400..a437afde8e8 100644
--- a/velox/functions/iceberg/tests/CMakeLists.txt
+++ b/velox/functions/iceberg/tests/CMakeLists.txt
@@ -11,7 +11,14 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-add_executable(velox_functions_iceberg_test BucketFunctionTest.cpp Murmur3Hash32Test.cpp)
+add_executable(
+  velox_functions_iceberg_test
+  BucketFunctionTest.cpp
+  DateTimeFunctionsTest.cpp
+  Murmur3Hash32Test.cpp
+  TruncateTest.cpp
+)
+velox_add_test_headers(velox_functions_iceberg_test IcebergFunctionBaseTest.h)
 
 add_test(
   NAME velox_functions_iceberg_test
diff --git a/velox/functions/iceberg/tests/DateTimeFunctionsTest.cpp b/velox/functions/iceberg/tests/DateTimeFunctionsTest.cpp
new file mode 100644
index 00000000000..ba4b10cffee
--- /dev/null
+++ b/velox/functions/iceberg/tests/DateTimeFunctionsTest.cpp
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/iceberg/tests/IcebergFunctionBaseTest.h"
+
+namespace facebook::velox::functions::iceberg {
+namespace {
+
+class DateTimeFunctionsTest
+    : public functions::iceberg::test::IcebergFunctionBaseTest {};
+
+TEST_F(DateTimeFunctionsTest, years) {
+  const auto years = [&](const std::string& ts) {
+    return evaluateOnce<int32_t>(
+        "years(c0)", std::make_optional<Timestamp>(parseTimestamp(ts)));
+  };
+  EXPECT_EQ(47, years("2017-12-01 10:12:55.038194"));
+  EXPECT_EQ(0, years("1970-01-01 00:00:01.000001"));
+  EXPECT_EQ(-1, years("1969-12-31 23:59:58.999999"));
+
+  const auto yearsDate = [&](const std::string& date) {
+    return evaluateOnce<int32_t>(
+        "years(c0)", DATE(), std::make_optional<int32_t>(parseDate(date)));
+  };
+  EXPECT_EQ(47, yearsDate("2017-12-01"));
+  EXPECT_EQ(0, yearsDate("1970-01-01"));
+  EXPECT_EQ(-1, yearsDate("1969-12-31"));
+}
+
+TEST_F(DateTimeFunctionsTest, months) {
+  const auto months = [&](const std::string& ts) {
+    return evaluateOnce<int32_t>(
+        "months(c0)", std::make_optional<Timestamp>(parseTimestamp(ts)));
+  };
+  EXPECT_EQ(575, months("2017-12-01 10:12:55.038194"));
+  EXPECT_EQ(0, months("1970-01-01 00:00:01.000001"));
+  EXPECT_EQ(-1, months("1969-12-31 23:59:58.999999"));
+
+  const auto monthsDate = [&](const std::string& date) {
+    return evaluateOnce<int32_t>(
+        "months(c0)", DATE(), std::make_optional<int32_t>(parseDate(date)));
+  };
+  EXPECT_EQ(575, monthsDate("2017-12-01"));
+  EXPECT_EQ(0, monthsDate("1970-01-01"));
+  EXPECT_EQ(-1, monthsDate("1969-12-31"));
+}
+
+TEST_F(DateTimeFunctionsTest, days) {
+  const auto days = [&](const std::string& ts) {
+    return evaluateOnce<int32_t>(
+        "days(c0)", std::make_optional<Timestamp>(parseTimestamp(ts)));
+  };
+
+  const auto daysDate = [&](const std::string& date) {
+    return evaluateOnce<int32_t>(
+        "days(c0)", DATE(), std::make_optional<int32_t>(parseDate(date)));
+  };
+  EXPECT_EQ(days("2017-12-01 10:12:55.038194"), daysDate("2017-12-01"));
+  EXPECT_EQ(days("1970-01-01 00:00:01.000001"), daysDate("1970-01-01"));
+  EXPECT_EQ(days("1969-12-31 23:59:58.999999"), daysDate("1969-12-31"));
+}
+
+TEST_F(DateTimeFunctionsTest, hours) {
+  const auto hours = [&](const std::string& ts) {
+    return evaluateOnce<int32_t>(
+        "hours(c0)", std::make_optional<Timestamp>(parseTimestamp(ts)));
+  };
+  EXPECT_EQ(420034, hours("2017-12-01 10:12:55.038194"));
+  EXPECT_EQ(0, hours("1970-01-01 00:00:01.000001"));
+  EXPECT_EQ(-1, hours("1969-12-31 23:59:58.999999"));
+}
+
+} // namespace
+} // namespace facebook::velox::functions::iceberg
diff --git a/velox/functions/iceberg/tests/IcebergFunctionBaseTest.h b/velox/functions/iceberg/tests/IcebergFunctionBaseTest.h
index 1a152b15359..4c68155c987 100644
--- a/velox/functions/iceberg/tests/IcebergFunctionBaseTest.h
+++ b/velox/functions/iceberg/tests/IcebergFunctionBaseTest.h
@@ -28,6 +28,10 @@ class IcebergFunctionBaseTest
     FunctionBaseTest::SetUpTestCase();
     registerFunctions("");
   }
+
+  void SetUp() override {
+    options_.parseDecimalAsDouble = false;
+  }
 };
 
 } // namespace facebook::velox::functions::iceberg::test
diff --git a/velox/functions/iceberg/tests/TruncateTest.cpp b/velox/functions/iceberg/tests/TruncateTest.cpp
new file mode 100644
index 00000000000..ff4a5051002
--- /dev/null
+++ b/velox/functions/iceberg/tests/TruncateTest.cpp
@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/iceberg/Truncate.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/core/Expressions.h"
+#include "velox/functions/iceberg/tests/IcebergFunctionBaseTest.h"
+
+namespace facebook::velox::functions::iceberg {
+namespace {
+class TruncateTest : public facebook::velox::functions::iceberg::test::
+                         IcebergFunctionBaseTest {
+ protected:
+  template <typename T>
+  std::optional<T> truncate(
+      std::optional<int32_t> width,
+      std::optional<T> value) {
+    return evaluateOnce<T>("truncate(c0, c1)", width, value);
+  }
+
+  template <typename T>
+  std::optional<T> truncate(
+      const TypePtr& type,
+      std::optional<int32_t> width,
+      std::optional<T> value) {
+    return evaluateOnce<T>("truncate(c0, c1)", {INTEGER(), type}, width, value);
+  }
+};
+
+TEST_F(TruncateTest, tinyInt) {
+  EXPECT_EQ(truncate<int8_t>(10, 0), 0);
+  EXPECT_EQ(truncate<int8_t>(10, 1), 0);
+  EXPECT_EQ(truncate<int8_t>(10, 5), 0);
+  EXPECT_EQ(truncate<int8_t>(10, 9), 0);
+  EXPECT_EQ(truncate<int8_t>(10, 10), 10);
+  EXPECT_EQ(truncate<int8_t>(10, 11), 10);
+  EXPECT_EQ(truncate<int8_t>(10, -1), -10);
+  EXPECT_EQ(truncate<int8_t>(10, -5), -10);
+  EXPECT_EQ(truncate<int8_t>(10, -10), -10);
+  EXPECT_EQ(truncate<int8_t>(10, -11), -20);
+
+  // Different widths.
+  EXPECT_EQ(truncate<int8_t>(2, -1), -2);
+
+  // Null handling.
+  EXPECT_EQ(truncate<int8_t>(10, std::nullopt), std::nullopt);
+}
+
+TEST_F(TruncateTest, smallInt) {
+  EXPECT_EQ(truncate<int16_t>(10, 0), 0);
+  EXPECT_EQ(truncate<int16_t>(10, 1), 0);
+  EXPECT_EQ(truncate<int16_t>(10, 5), 0);
+  EXPECT_EQ(truncate<int16_t>(10, 9), 0);
+  EXPECT_EQ(truncate<int16_t>(10, 10), 10);
+  EXPECT_EQ(truncate<int16_t>(10, 11), 10);
+  EXPECT_EQ(truncate<int16_t>(10, -1), -10);
+  EXPECT_EQ(truncate<int16_t>(10, -5), -10);
+  EXPECT_EQ(truncate<int16_t>(10, -10), -10);
+  EXPECT_EQ(truncate<int16_t>(10, -11), -20);
+  EXPECT_EQ(truncate<int16_t>(7, 22), 21);
+  EXPECT_EQ(truncate<int16_t>(2, -1), -2);
+  EXPECT_EQ(truncate<int16_t>(10, std::nullopt), std::nullopt);
+}
+
+TEST_F(TruncateTest, integer) {
+  EXPECT_EQ(truncate<int32_t>(10, 0), 0);
+  EXPECT_EQ(truncate<int32_t>(10, 1), 0);
+  EXPECT_EQ(truncate<int32_t>(10, 5), 0);
+  EXPECT_EQ(truncate<int32_t>(10, 9), 0);
+  EXPECT_EQ(truncate<int32_t>(10, 10), 10);
+  EXPECT_EQ(truncate<int32_t>(10, 11), 10);
+  EXPECT_EQ(truncate<int32_t>(10, -1), -10);
+  EXPECT_EQ(truncate<int32_t>(10, -5), -10);
+  EXPECT_EQ(truncate<int32_t>(10, -10), -10);
+  EXPECT_EQ(truncate<int32_t>(10, -11), -20);
+
+  // Different widths.
+  EXPECT_EQ(truncate<int32_t>(2, -1), -2);
+  EXPECT_EQ(truncate<int32_t>(300, 1), 0);
+
+  EXPECT_EQ(truncate<int32_t>(10, std::nullopt), std::nullopt);
+}
+
+TEST_F(TruncateTest, bigint) {
+  EXPECT_EQ(truncate<int64_t>(10, 0), 0);
+  EXPECT_EQ(truncate<int64_t>(10, 1), 0);
+  EXPECT_EQ(truncate<int64_t>(10, 5), 0);
+  EXPECT_EQ(truncate<int64_t>(10, 9), 0);
+  EXPECT_EQ(truncate<int64_t>(10, 10), 10);
+  EXPECT_EQ(truncate<int64_t>(10, 11), 10);
+  EXPECT_EQ(truncate<int64_t>(10, -1), -10);
+  EXPECT_EQ(truncate<int64_t>(10, -5), -10);
+  EXPECT_EQ(truncate<int64_t>(10, -10), -10);
+  EXPECT_EQ(truncate<int64_t>(10, -11), -20);
+
+  EXPECT_EQ(truncate<int64_t>(2, -1), -2);
+  EXPECT_EQ(truncate<int64_t>(10, std::nullopt), std::nullopt);
+  VELOX_ASSERT_THROW(
+      truncate<int64_t>(0, 34),
+      "Reason: (0 vs. 0) Invalid truncate width\nExpression: width <= 0");
+  VELOX_ASSERT_THROW(
+      truncate<int64_t>(-3, 34),
+      "Reason: (-3 vs. 0) Invalid truncate width\nExpression: width <= 0");
+}
+
+TEST_F(TruncateTest, string) {
+  // Basic truncation cases.
+  EXPECT_EQ(truncate<std::string>(5, "abcdefg"), "abcde");
+  EXPECT_EQ(truncate<std::string>(5, "abc"), "abc");
+  EXPECT_EQ(truncate<std::string>(5, "abcde"), "abcde");
+
+  // Empty string handling.
+  EXPECT_EQ(truncate<std::string>(10, ""), "");
+
+  // Unicode handling (4-byte characters).
+  std::string twoFourByteChars = "\U00010000\U00010000"; // Two 𐀀 characters
+  EXPECT_EQ(truncate<std::string>(1, twoFourByteChars), "\U00010000");
+
+  // Mixed character sizes.
+  EXPECT_EQ(truncate<std::string>(4, "测试raul试测"), "测试ra");
+
+  // Explicit varchar/char types (treated same as string).
+  EXPECT_EQ(truncate<std::string>(4, "测试raul试测"), "测试ra");
+
+  VELOX_ASSERT_THROW(
+      truncate<std::string>(0, "abc"),
+      "Reason: (0 vs. 0) Invalid truncate width\nExpression: width <= 0");
+  VELOX_ASSERT_THROW(
+      truncate<std::string>(-3, "abc"),
+      "Reason: (-3 vs. 0) Invalid truncate width\nExpression: width <= 0");
+  VELOX_ASSERT_THROW(
+      truncate<std::string>(0, "测试"),
+      "Reason: (0 vs. 0) Invalid truncate width\nExpression: width <= 0");
+  VELOX_ASSERT_THROW(
+      truncate<std::string>(-3, "测试"),
+      "Reason: (-3 vs. 0) Invalid truncate width\nExpression: width <= 0");
+}
+
+TEST_F(TruncateTest, unicodeBoundaries) {
+  // Japanese characters (3-byte UTF-8).
+  std::string japanese = "イロハニホヘト";
+  EXPECT_EQ(truncate<std::string>(2, japanese), "イロ");
+  EXPECT_EQ(truncate<std::string>(3, japanese), "イロハ");
+  EXPECT_EQ(truncate<std::string>(7, japanese), japanese);
+
+  // Chinese characters (3-byte UTF-8).
+  EXPECT_EQ(truncate<std::string>(1, "测试"), "测");
+}
+
+TEST_F(TruncateTest, binary) {
+  EXPECT_EQ(truncate<std::string>(VARBINARY(), 10, "abc\0\0"), "abc\0\0");
+  EXPECT_EQ(truncate<std::string>(VARBINARY(), 3, "abcdefg"), "abc");
+  EXPECT_EQ(truncate<std::string>(VARBINARY(), 3, "abc"), "abc");
+  EXPECT_EQ(truncate<std::string>(VARBINARY(), 6, "测试"), "测试");
+}
+
+TEST_F(TruncateTest, decimal) {
+  EXPECT_EQ(truncate<int64_t>(DECIMAL(9, 2), 10, 1234), 1230);
+  EXPECT_EQ(truncate<int64_t>(DECIMAL(9, 2), 10, 1239), 1230);
+  EXPECT_EQ(truncate<int64_t>(DECIMAL(9, 2), 10, 5), 0);
+  EXPECT_EQ(truncate<int64_t>(DECIMAL(9, 2), 10, -5), -10);
+  EXPECT_EQ(truncate<int64_t>(DECIMAL(9, 3), 10, 12299), 12290);
+  EXPECT_EQ(truncate<int64_t>(DECIMAL(9, 3), 1, 1), 1);
+  EXPECT_EQ(truncate<int64_t>(DECIMAL(5, 2), 3, 5), 3);
+  EXPECT_EQ(truncate<int64_t>(DECIMAL(10, 4), 10, 123453482), 123453480);
+  EXPECT_EQ(truncate<int64_t>(DECIMAL(6, 4), 10, -500), -500);
+  EXPECT_EQ(truncate<int128_t>(DECIMAL(38, 2), 10, 5), 0);
+  EXPECT_EQ(truncate<int128_t>(DECIMAL(38, 2), 10, -5), -10);
+}
+} // namespace
+} // namespace facebook::velox::functions::iceberg
diff --git a/velox/functions/lib/ApproxMostFrequentStreamSummary.h b/velox/functions/lib/ApproxMostFrequentStreamSummary.h
index b34197c15c3..24de5e59d63 100644
--- a/velox/functions/lib/ApproxMostFrequentStreamSummary.h
+++ b/velox/functions/lib/ApproxMostFrequentStreamSummary.h
@@ -44,8 +44,9 @@ struct ApproxMostFrequentStreamSummary {
 
   void setCapacity(int);
 
-  /// Add one or multiple new values to the summary.
-  void insert(T value, int64_t count = 1);
+  /// Add a value with the given count to the summary.
+  /// Returns the evicted value if at capacity, std::nullopt otherwise.
+  std::optional<T> insert(T value, int64_t count = 1);
 
   /// Get the top `k` frequent elements with their estimated counts, sorted from
   /// most hits to least hits.
@@ -131,17 +132,25 @@ int ApproxMostFrequentStreamSummary<T, A>::capacity() const {
 }
 
 template <typename T, typename A>
-void ApproxMostFrequentStreamSummary<T, A>::insert(T value, int64_t count) {
+std::optional<T> ApproxMostFrequentStreamSummary<T, A>::insert(
+    T value,
+    int64_t count) {
   auto index = queue_.getValueIndex(value);
   if (index.has_value()) {
-    auto oldCount = queue_.priorities()[*index];
+    const auto oldCount = queue_.priorities()[*index];
     queue_.updatePriority(*index, oldCount + count);
-  } else if (size() < capacity_) {
+    return std::nullopt;
+  }
+  if (size() < capacity_) {
     queue_.addNewValue(value, count);
-  } else {
-    auto oldCount = queue_.topPriority();
-    queue_.replaceTop(value, oldCount + count);
+    return std::nullopt;
   }
+
+  // At capacity - need to evict the minimum entry.
+  std::optional<T> evictedValue{queue_.top()};
+  auto evictedCount = queue_.topPriority();
+  queue_.replaceTop(value, evictedCount + count);
+  return evictedValue;
 }
 
 template <typename T, typename A>
@@ -149,7 +158,7 @@ void ApproxMostFrequentStreamSummary<T, A>::topK(
     int k,
     T* values,
     int64_t* counts) const {
-  VELOX_CHECK(k >= 0);
+  VELOX_CHECK_GE(k, 0);
   k = std::min(k, size());
   if (k == 0) {
     return;
@@ -180,7 +189,7 @@ void ApproxMostFrequentStreamSummary<T, A>::topK(
 template <typename T, typename A>
 std::vector<std::pair<T, int64_t>> ApproxMostFrequentStreamSummary<T, A>::topK(
     int k) const {
-  VELOX_CHECK(k >= 0);
+  VELOX_CHECK_GE(k, 0);
   k = std::min(k, size());
   std::vector<T> values(k);
   std::vector<int64_t> counts(k);
diff --git a/velox/functions/lib/ArraySort.cpp b/velox/functions/lib/ArraySort.cpp
new file mode 100644
index 00000000000..c16bae99840
--- /dev/null
+++ b/velox/functions/lib/ArraySort.cpp
@@ -0,0 +1,571 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/container/F14Set.h>
+
+#include "velox/expression/EvalCtx.h"
+#include "velox/expression/Expr.h"
+#include "velox/functions/lib/ArraySort.h"
+#include "velox/functions/lib/LambdaFunctionUtil.h"
+#include "velox/type/FloatingPointUtil.h"
+
+namespace facebook::velox::functions {
+namespace {
+
+BufferPtr sortElements(
+    const SelectivityVector& rows,
+    const ArrayVector& inputArray,
+    const BaseVector& inputElements,
+    bool ascending,
+    bool nullsFirst,
+    exec::EvalCtx& context,
+    bool throwOnNestedNull) {
+  const SelectivityVector inputElementRows =
+      toElementRows(inputElements.size(), rows, &inputArray);
+  exec::LocalDecodedVector decodedElements(
+      context, inputElements, inputElementRows);
+  const auto* baseElementsVector = decodedElements->base();
+
+  // Allocate new vectors for indices.
+  BufferPtr indices = allocateIndices(inputElements.size(), context.pool());
+  vector_size_t* rawIndices = indices->asMutable<vector_size_t>();
+
+  CompareFlags flags{.nullsFirst = nullsFirst, .ascending = ascending};
+  if (throwOnNestedNull) {
+    flags.nullHandlingMode =
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate;
+  }
+
+  auto decodedIndices = decodedElements->indices();
+  context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
+    const auto size = inputArray.sizeAt(row);
+    const auto offset = inputArray.offsetAt(row);
+
+    for (auto i = offset; i < offset + size; ++i) {
+      rawIndices[i] = i;
+    }
+
+    std::sort(
+        rawIndices + offset,
+        rawIndices + offset + size,
+        [&](vector_size_t& a, vector_size_t& b) {
+          if (a == b) {
+            return false;
+          }
+          bool aNull = decodedElements->isNullAt(a);
+          bool bNull = decodedElements->isNullAt(b);
+
+          if (aNull && bNull) {
+            return false;
+          }
+          if (aNull) {
+            return nullsFirst;
+          }
+          if (bNull) {
+            return !nullsFirst;
+          }
+
+          std::optional<int32_t> result = baseElementsVector->compare(
+              baseElementsVector, decodedIndices[a], decodedIndices[b], flags);
+
+          if (!result.has_value()) {
+            VELOX_USER_FAIL("Ordering nulls is not supported");
+          }
+
+          return result.value() < 0;
+        });
+  });
+
+  return indices;
+}
+
+void applyComplexType(
+    const SelectivityVector& rows,
+    ArrayVector* inputArray,
+    bool ascending,
+    bool nullsFirst,
+    exec::EvalCtx& context,
+    VectorPtr& resultElements,
+    bool throwOnNestedNull) {
+  auto inputElements = inputArray->elements();
+  auto indices = sortElements(
+      rows,
+      *inputArray,
+      *inputElements,
+      ascending,
+      nullsFirst,
+      context,
+      throwOnNestedNull);
+  resultElements = BaseVector::transpose(indices, std::move(inputElements));
+}
+
+template <typename T>
+inline void swapWithNull(
+    FlatVector<T>* vector,
+    vector_size_t index,
+    vector_size_t nullIndex) {
+  // Values are already present in vector stringBuffers. Don't create additional
+  // copy.
+  if constexpr (std::is_same_v<T, StringView>) {
+    vector->setNoCopy(nullIndex, vector->valueAt(index));
+  } else {
+    vector->set(nullIndex, vector->valueAt(index));
+  }
+  vector->setNull(index, true);
+}
+
+template <TypeKind kind>
+void applyScalarType(
+    const SelectivityVector& rows,
+    const ArrayVector* inputArray,
+    bool ascending,
+    bool nullsFirst,
+    exec::EvalCtx& context,
+    VectorPtr& resultElements) {
+  using T = typename TypeTraits<kind>::NativeType;
+
+  // Copy array elements to new vector.
+  const VectorPtr& inputElements = inputArray->elements();
+  VELOX_DCHECK(kind == inputElements->typeKind());
+  const SelectivityVector inputElementRows =
+      toElementRows(inputElements->size(), rows, inputArray);
+  const vector_size_t elementsCount = inputElementRows.size();
+
+  // TODO: consider to use dictionary wrapping to avoid the direct sorting on
+  // the scalar values as we do for complex data type if this runs slow in
+  // practice.
+  resultElements =
+      BaseVector::create(inputElements->type(), elementsCount, context.pool());
+  resultElements->copy(
+      inputElements.get(), inputElementRows, /*toSourceRow=*/nullptr);
+
+  auto flatResults = resultElements->asFlatVector<T>();
+
+  auto processRow = [&](vector_size_t row) {
+    const auto size = inputArray->sizeAt(row);
+    const auto offset = inputArray->offsetAt(row);
+    if (size == 0) {
+      return;
+    }
+    vector_size_t numNulls = 0;
+    if (nullsFirst) {
+      // Move nulls to beginning of array.
+      for (vector_size_t i = 0; i < size; ++i) {
+        if (flatResults->isNullAt(offset + i)) {
+          swapWithNull<T>(flatResults, offset + numNulls, offset + i);
+          ++numNulls;
+        }
+      }
+    } else {
+      // Move nulls to end of array.
+      for (vector_size_t i = size - 1; i >= 0; --i) {
+        if (flatResults->isNullAt(offset + i)) {
+          swapWithNull<T>(
+              flatResults, offset + size - numNulls - 1, offset + i);
+          ++numNulls;
+        }
+      }
+    }
+    // Exclude null values while sorting.
+    const auto startRow = offset + (nullsFirst ? numNulls : 0);
+    const auto endRow = startRow + size - numNulls;
+
+    if constexpr (kind == TypeKind::BOOLEAN) {
+      uint64_t* rawBits = flatResults->template mutableRawValues<uint64_t>();
+      const auto numOneBits = bits::countBits(rawBits, startRow, endRow);
+
+      if (ascending) {
+        const auto endZeroRow = endRow - numOneBits;
+        bits::fillBits(rawBits, startRow, endZeroRow, false);
+        bits::fillBits(rawBits, endZeroRow, endRow, true);
+      } else {
+        bits::fillBits(rawBits, startRow, startRow + numOneBits, true);
+        bits::fillBits(rawBits, startRow + numOneBits, endRow, false);
+      }
+    } else if constexpr (kind == TypeKind::REAL || kind == TypeKind::DOUBLE) {
+      T* resultRawValues = flatResults->mutableRawValues();
+      if (ascending) {
+        std::sort(
+            resultRawValues + startRow,
+            resultRawValues + endRow,
+            util::floating_point::NaNAwareLessThan<T>());
+      } else {
+        std::sort(
+            resultRawValues + startRow,
+            resultRawValues + endRow,
+            util::floating_point::NaNAwareGreaterThan<T>());
+      }
+    } else {
+      T* resultRawValues = flatResults->mutableRawValues();
+      if (ascending) {
+        std::sort(resultRawValues + startRow, resultRawValues + endRow);
+      } else {
+        std::sort(
+            resultRawValues + startRow,
+            resultRawValues + endRow,
+            std::greater<T>());
+      }
+    }
+  };
+  rows.applyToSelected(processRow);
+}
+
+// See documentation at https://prestodb.io/docs/current/functions/array.html
+template <TypeKind Kind>
+class ArraySortFunction : public exec::VectorFunction {
+ public:
+  /// This class implements the array_sort query function. Takes an array as
+  /// input and sorts it in ascending order and null elements will be placed at
+  /// the end of the returned array.
+  ///
+  /// Along with the set, we maintain a `hasNull` flag that indicates whether
+  /// null is present in the array.
+  ///
+  /// Zero element copy for complex data type:
+  ///
+  /// In order to prevent copies of array elements with complex data type, the
+  /// function reuses the internal elements() vector from the original
+  /// ArrayVector. A new vector is created containing the indices of the sorted
+  /// elements in the output, and wrapped into a DictionaryVector. The 'lengths'
+  /// and 'offsets' vectors that control where output arrays start and end
+  /// remain the same in the output ArrayVector.
+
+  explicit ArraySortFunction(
+      bool ascending,
+      bool nullsFirst,
+      bool throwOnNestedNull)
+      : ascending_{ascending},
+        nullsFirst_{nullsFirst},
+        throwOnNestedNull_{throwOnNestedNull} {}
+
+  // Execute function.
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& /*outputType*/,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    auto& arg = args[0];
+
+    VectorPtr localResult;
+
+    // Input can be constant or flat.
+    if constexpr (Kind == TypeKind::UNKNOWN) {
+      // All elements are NULL. Hence, sorting doesn't change anything.
+      localResult = arg;
+    } else if (arg->isConstantEncoding()) {
+      auto* constantArray = arg->as<ConstantVector<ComplexType>>();
+      const auto& flatArray = constantArray->valueVector();
+      const auto flatIndex = constantArray->index();
+
+      exec::LocalSingleRow singleRow(context, flatIndex);
+      localResult = applyFlat(*singleRow, flatArray, context);
+      localResult =
+          BaseVector::wrapInConstant(rows.end(), flatIndex, localResult);
+    } else {
+      localResult = applyFlat(rows, arg, context);
+    }
+
+    context.moveOrCopyResult(localResult, rows, result);
+  }
+
+ private:
+  VectorPtr applyFlat(
+      const SelectivityVector& rows,
+      const VectorPtr& arg,
+      exec::EvalCtx& context) const {
+    // Acquire the array elements vector.
+    auto inputArray = arg->as<ArrayVector>();
+    VectorPtr resultElements;
+
+    if constexpr (velox::TypeTraits<Kind>::isPrimitiveType) {
+      VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+          applyScalarType,
+          Kind,
+          rows,
+          inputArray,
+          ascending_,
+          nullsFirst_,
+          context,
+          resultElements);
+
+    } else {
+      applyComplexType(
+          rows,
+          inputArray,
+          ascending_,
+          nullsFirst_,
+          context,
+          resultElements,
+          throwOnNestedNull_);
+    }
+
+    return std::make_shared<ArrayVector>(
+        context.pool(),
+        inputArray->type(),
+        inputArray->nulls(),
+        rows.end(),
+        inputArray->offsets(),
+        inputArray->sizes(),
+        resultElements,
+        inputArray->getNullCount());
+  }
+
+  const bool ascending_;
+  const bool nullsFirst_;
+  const bool throwOnNestedNull_;
+};
+
+class ArraySortLambdaFunction : public exec::VectorFunction {
+ public:
+  explicit ArraySortLambdaFunction(bool ascending, bool throwOnNestedNull)
+      : ascending_{ascending}, throwOnNestedNull_(throwOnNestedNull) {}
+
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& /*outputType*/,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    // Flatten input array.
+    exec::LocalDecodedVector arrayDecoder(context, *args[0], rows);
+    auto& decodedArray = *arrayDecoder.get();
+
+    auto flatArray = flattenArray(rows, args[0], decodedArray);
+
+    auto numElements = flatArray->elements()->size();
+    const std::vector<VectorPtr> lambdaArgs = {flatArray->elements()};
+    SelectivityVector validRowsInReusedResult =
+        toElementRows<ArrayVector>(numElements, rows, flatArray.get());
+
+    VectorPtr newElements;
+    // Compute sorting keys.
+    applyLambdaToElements<ArrayVector>(
+        args[1],
+        rows,
+        numElements,
+        flatArray,
+        lambdaArgs,
+        validRowsInReusedResult,
+        context,
+        newElements);
+
+    // Sort 'newElements'.
+    auto indices = sortElements(
+        rows,
+        *flatArray,
+        *newElements,
+        ascending_,
+        false /*nullsFirst*/,
+        context,
+        throwOnNestedNull_);
+    auto sortedElements = BaseVector::wrapInDictionary(
+        nullptr,
+        indices,
+        indices->size() / sizeof(vector_size_t),
+        flatArray->elements());
+
+    // Set nulls for rows not present in 'rows'.
+    BufferPtr newNulls = addNullsForUnselectedRows(flatArray, rows);
+
+    VectorPtr localResult = std::make_shared<ArrayVector>(
+        flatArray->pool(),
+        flatArray->type(),
+        std::move(newNulls),
+        rows.end(),
+        flatArray->offsets(),
+        flatArray->sizes(),
+        sortedElements);
+    context.moveOrCopyResult(localResult, rows, result);
+  }
+
+ private:
+  const bool ascending_;
+  const bool throwOnNestedNull_;
+};
+
+// Create function template based on type.
+template <TypeKind kind>
+std::shared_ptr<exec::VectorFunction> createTyped(
+    const std::vector<exec::VectorFunctionArg>& /*inputArgs*/,
+    bool ascending,
+    bool nullsFirst,
+    bool throwOnNestedNull = true) {
+  return std::make_shared<ArraySortFunction<kind>>(
+      ascending, nullsFirst, throwOnNestedNull);
+}
+
+// Define function signature.
+std::vector<std::shared_ptr<exec::FunctionSignature>> signatures(
+    bool withComparator) {
+  std::vector<std::shared_ptr<exec::FunctionSignature>> signatures = {
+      // array(T) -> array(T)
+      exec::FunctionSignatureBuilder()
+          .orderableTypeVariable("T")
+          .returnType("array(T)")
+          .argumentType("array(T)")
+          .build(),
+      // array(T), function(T,U), boolean -> array(T)
+      exec::FunctionSignatureBuilder()
+          .typeVariable("T")
+          .orderableTypeVariable("U")
+          .returnType("array(T)")
+          .argumentType("array(T)")
+          .constantArgumentType("function(T,U)")
+          .build(),
+  };
+
+  if (withComparator) {
+    signatures.push_back(
+        // array(T), function(T,T,integer) -> array(T)
+        exec::FunctionSignatureBuilder()
+            .typeVariable("T")
+            .returnType("array(T)")
+            .argumentType("array(T)")
+            .constantArgumentType("function(T,T,integer)")
+            .build());
+  }
+  return signatures;
+}
+
+std::vector<std::shared_ptr<exec::FunctionSignature>>
+internalCanonicalizeSignatures() {
+  std::vector<std::shared_ptr<exec::FunctionSignature>> signatures = {
+      // array(T) -> array(T)
+      exec::FunctionSignatureBuilder()
+          .typeVariable("T")
+          .returnType("array(T)")
+          .argumentType("array(T)")
+          .build()};
+  return signatures;
+}
+
+std::shared_ptr<exec::VectorFunction> makeArraySortAscNoThrowOnNestedNull(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config) {
+  return makeArraySort(
+      name,
+      inputArgs,
+      config,
+      true,
+      false /*nullsFirst=*/,
+      false /*throwOnNestedNull=*/);
+}
+
+core::CallTypedExprPtr asArraySortCall(
+    const std::string& prefix,
+    const core::TypedExprPtr& expr) {
+  if (auto call = std::dynamic_pointer_cast<const core::CallTypedExpr>(expr)) {
+    if (call->name() == prefix + "array_sort") {
+      return call;
+    }
+  }
+  return nullptr;
+}
+
+} // namespace
+
+std::shared_ptr<exec::VectorFunction> makeArraySortLambdaFunction(
+    const std::string& /*name*/,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& /*config*/,
+    bool ascending,
+    bool throwOnNestedNull) {
+  VELOX_CHECK_EQ(inputArgs.size(), 2);
+  return std::make_shared<ArraySortLambdaFunction>(
+      ascending, throwOnNestedNull);
+}
+
+std::shared_ptr<exec::VectorFunction> makeArraySort(
+    const std::string& /*name*/,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& /*config*/,
+    bool ascending,
+    bool nullsFirst,
+    bool throwOnNestedNull) {
+  const auto elementType = inputArgs.front().type->childAt(0);
+  if (elementType->isUnknown()) {
+    return createTyped<TypeKind::UNKNOWN>(
+        inputArgs, ascending, nullsFirst, throwOnNestedNull);
+  }
+
+  return VELOX_DYNAMIC_TYPE_DISPATCH(
+      createTyped,
+      elementType->kind(),
+      inputArgs,
+      ascending,
+      nullsFirst,
+      throwOnNestedNull);
+}
+
+std::vector<std::shared_ptr<exec::FunctionSignature>> arraySortSignatures(
+    bool withComparator) {
+  return signatures(withComparator);
+}
+
+core::TypedExprPtr rewriteArraySortCall(
+    const std::string& prefix,
+    const core::TypedExprPtr& expr,
+    const std::shared_ptr<SimpleComparisonChecker> checker) {
+  auto call = asArraySortCall(prefix, expr);
+  if (call == nullptr || call->inputs().size() != 2) {
+    return nullptr;
+  }
+  auto lambda =
+      dynamic_cast<const core::LambdaTypedExpr*>(call->inputs()[1].get());
+  VELOX_CHECK_NOT_NULL(lambda);
+  // Extract 'transform' from the comparison lambda:
+  //  (x, y) -> if(func(x) < func(y),...) ===> x -> func(x).
+  if (lambda->signature()->size() != 2) {
+    return nullptr;
+  }
+  static constexpr const char* kNotSupported =
+      "array_sort with comparator lambda that cannot be rewritten "
+      "into a transform is not supported: {}";
+
+  if (auto comparison = checker->isSimpleComparison(prefix, *lambda)) {
+    std::string name = comparison->isLessThen ? prefix + "array_sort"
+                                              : prefix + "array_sort_desc";
+
+    if (!comparison->expr->type()->isOrderable()) {
+      VELOX_USER_FAIL(kNotSupported, lambda->toString());
+    }
+
+    auto rewritten = std::make_shared<core::CallTypedExpr>(
+        call->type(),
+        name,
+        call->inputs()[0],
+        std::make_shared<core::LambdaTypedExpr>(
+            ROW({lambda->signature()->nameOf(0)},
+                {lambda->signature()->childAt(0)}),
+            comparison->expr));
+
+    return rewritten;
+  }
+
+  VELOX_USER_FAIL(kNotSupported, lambda->toString());
+}
+
+// An internal function to canonicalize an array to allow for comparisons. Used
+// in AggregationFuzzerTest. Details in
+// https://github.com/facebookincubator/velox/issues/6999.
+VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
+    udf_$internal$canonicalize,
+    internalCanonicalizeSignatures(),
+    makeArraySortAscNoThrowOnNestedNull);
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/ArraySort.h b/velox/functions/lib/ArraySort.h
new file mode 100644
index 00000000000..915c2f738bd
--- /dev/null
+++ b/velox/functions/lib/ArraySort.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/VectorFunction.h"
+#include "velox/functions/lib/SimpleComparisonMatcher.h"
+
+namespace facebook::velox::functions {
+
+/// Creates array_sort function.
+///
+/// @param ascending If true, sort in ascending order; otherwise, sort in
+/// descending order.
+/// @param nullsFirst If true, nulls are placed first; otherwise, nulls are
+/// placed last.
+/// @param throwOnNestedNull If true, throw an exception if a nested null is
+/// encountered.
+std::shared_ptr<exec::VectorFunction> makeArraySort(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config,
+    bool ascending,
+    bool nullsFirst,
+    bool throwOnNestedNull);
+
+/// Creates array_sort with a lambda function.
+///
+/// @param ascending If true, sort in ascending order; otherwise, sort in
+/// descending order.
+/// @param throwOnNestedNull If true, throw an exception if a nested null is
+/// encountered.
+std::shared_ptr<exec::VectorFunction> makeArraySortLambdaFunction(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config,
+    bool ascending,
+    bool throwOnNestedNull);
+
+/// Returns signatures for array_sort function.
+///
+/// @param withComparator If true, includes a signature for sorting with a
+/// comparator function.
+std::vector<std::shared_ptr<exec::FunctionSignature>> arraySortSignatures(
+    bool withComparator);
+
+/// Analyzes array_sort(array, lambda) call to determine whether it can be
+/// re-written into a simpler call that specifies sort-by expression.
+///
+/// For example, rewrites
+///     array_sort(a, (x, y) -> if(length(x) < length(y), -1, if(length(x) >
+///     length(y), 1, 0))
+/// into
+///     array_sort(a, x -> length(x))
+///
+/// Returns the rewritten expression. If rewrite is not possible, throw a user
+/// error.
+core::TypedExprPtr rewriteArraySortCall(
+    const std::string& prefix,
+    const core::TypedExprPtr& expr,
+    const std::shared_ptr<SimpleComparisonChecker> checker);
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/CMakeLists.txt b/velox/functions/lib/CMakeLists.txt
index 31c7e82f81a..ac91448c37d 100644
--- a/velox/functions/lib/CMakeLists.txt
+++ b/velox/functions/lib/CMakeLists.txt
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_is_null_functions IsNull.cpp)
+velox_add_library(velox_is_null_functions IsNull.cpp HEADERS IsNull.h)
 
 velox_link_libraries(velox_is_null_functions velox_expression)
 
@@ -21,6 +21,11 @@ velox_add_library(
   Murmur3Hash32Base.cpp
   LambdaFunctionUtil.cpp
   RowsTranslationUtil.cpp
+  HEADERS
+  LambdaFunctionUtil.h
+  Murmur3Hash32Base.h
+  RowsTranslationUtil.h
+  XORShiftRandom.h
 )
 
 velox_link_libraries(velox_functions_util velox_vector velox_common_base)
@@ -29,6 +34,9 @@ velox_add_library(
   velox_functions_lib_date_time_formatter
   DateTimeFormatter.cpp
   DateTimeFormatterBuilder.cpp
+  HEADERS
+  DateTimeFormatter.h
+  DateTimeFormatterBuilder.h
 )
 
 velox_link_libraries(velox_functions_lib_date_time_formatter velox_type_tz)
@@ -36,17 +44,52 @@ velox_link_libraries(velox_functions_lib_date_time_formatter velox_type_tz)
 velox_add_library(
   velox_functions_lib
   ArrayShuffle.cpp
+  ArraySort.cpp
   CheckDuplicateKeys.cpp
   CheckNestedNulls.cpp
   KllSketch.cpp
   MapConcat.cpp
+  MapFromEntries.cpp
   Re2Functions.cpp
   Repeat.cpp
+  Sequence.cpp
   Slice.cpp
+  SimpleComparisonMatcher.cpp
   StringEncodingUtils.cpp
   SubscriptUtil.cpp
   TimeUtils.cpp
   Utf8Utils.cpp
+  HEADERS
+  ApproxMostFrequentStreamSummary.h
+  ArrayRemoveNullFunction.h
+  ArrayShuffle.h
+  ArraySort.h
+  CheckDuplicateKeys.h
+  CheckNestedNulls.h
+  CheckedArithmetic.h
+  CheckedArithmeticImpl.h
+  ComparatorUtil.h
+  FilterFunctionBase.h
+  JsonUtil.h
+  KllSketch-inl.h
+  KllSketch.h
+  MakeRowFromMap.h
+  MapConcat.h
+  MapFromEntries.h
+  Re2Functions.h
+  RegistrationHelpers.h
+  Repeat.h
+  SIMDComparisonUtil.h
+  Sequence.h
+  SimpleComparisonMatcher.h
+  Slice.h
+  StringEncodingUtils.h
+  SubscriptUtil.h
+  TimeUtils.h
+  ToHex.h
+  UpperLower.h
+  Utf8Utils.h
+  ZetaDistribution.h
 )
 
 velox_link_libraries(
@@ -55,6 +98,7 @@ velox_link_libraries(
   velox_functions_util
   velox_vector
   velox_type_tz
+  velox_common_hyperloglog
   re2::re2
   Folly::folly
 )
@@ -70,3 +114,22 @@ endif()
 if(${VELOX_ENABLE_BENCHMARKS})
   add_subdirectory(benchmarks)
 endif()
+
+velox_add_library(velox_transform_function_base INTERFACE HEADERS TransformFunctionBase.h)
+
+velox_add_library(velox_date_time_util INTERFACE HEADERS DateTimeUtil.h)
+
+velox_add_library(
+  velox_hll_accumulator
+  INTERFACE
+  HEADERS
+  HllAccumulator.h
+  KHyperLogLog.h
+  KHyperLogLogImpl.h
+)
+
+velox_add_library(velox_tdigest INTERFACE HEADERS TDigest.h)
+
+velox_add_library(velox_quantile_digest INTERFACE HEADERS QuantileDigest.h)
+
+velox_add_library(velox_setdigest INTERFACE HEADERS SetDigest.h SetDigestImpl.h)
diff --git a/velox/functions/lib/CheckDuplicateKeys.cpp b/velox/functions/lib/CheckDuplicateKeys.cpp
index 346fcc11d59..a12491cd16d 100644
--- a/velox/functions/lib/CheckDuplicateKeys.cpp
+++ b/velox/functions/lib/CheckDuplicateKeys.cpp
@@ -24,7 +24,8 @@ void checkDuplicateKeys(
   if (rows.end() == 0) {
     return;
   }
-  static const char* kDuplicateKey = "Duplicate map keys ({}) are not allowed";
+  static constexpr const char* kDuplicateKey =
+      "Duplicate map keys ({}) are not allowed";
 
   MapVector::canonicalize(mapVector);
 
diff --git a/velox/functions/lib/CheckNestedNulls.cpp b/velox/functions/lib/CheckNestedNulls.cpp
index 348535c9ce6..6e0d0b27bb2 100644
--- a/velox/functions/lib/CheckNestedNulls.cpp
+++ b/velox/functions/lib/CheckNestedNulls.cpp
@@ -18,13 +18,10 @@
 
 namespace facebook::velox::functions {
 
-/// Checks nested nulls in a complex type vector. Returns true if value at
-/// specified index is null. Throws an exception if the base vector contains
-/// nulls if 'throwOnNestedNulls' is true.
 bool checkNestedNulls(
     const DecodedVector& decoded,
-    const vector_size_t* indices,
     vector_size_t index,
+    vector_size_t baseIndex,
     bool throwOnNestedNulls) {
   if (decoded.isNullAt(index)) {
     return true;
@@ -32,11 +29,12 @@ bool checkNestedNulls(
 
   if (throwOnNestedNulls) {
     VELOX_USER_CHECK(
-        !decoded.base()->containsNullAt(indices[index]),
+        !decoded.base()->containsNullAt(baseIndex),
         "{} comparison not supported for values that contain nulls",
-        mapTypeKindToName(decoded.base()->typeKind()));
+        TypeKindName::toName(decoded.base()->typeKind()));
   }
 
   return false;
 }
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/lib/CheckNestedNulls.h b/velox/functions/lib/CheckNestedNulls.h
index eafbbe95c73..01d6d1e5cbd 100644
--- a/velox/functions/lib/CheckNestedNulls.h
+++ b/velox/functions/lib/CheckNestedNulls.h
@@ -20,12 +20,17 @@
 
 namespace facebook::velox::functions {
 
-/// Checks nested nulls in a complex type vector. Returns true if value at
-/// specified index is null. Throws an exception if the base vector contains
-/// nulls if 'throwOnNestedNulls' is true.
+/// Checks nested nulls in a complex type vector.
+///
+/// @param decoded The decoded vector to check
+/// @param index The index in the decoded vector to check
+/// @param baseIndex The index in the base vector to check for nested nulls
+/// @param throwOnNestedNulls If true, throws exception when base vector
+/// contains nulls
+/// @return true if the value at specified index is null, false otherwise
 bool checkNestedNulls(
     const DecodedVector& decoded,
-    const vector_size_t* indices,
     vector_size_t index,
+    vector_size_t baseIndex,
     bool throwOnNestedNulls = false);
 } // namespace facebook::velox::functions
diff --git a/velox/functions/lib/DateTimeFormatter.cpp b/velox/functions/lib/DateTimeFormatter.cpp
index 4d5d70c0197..7551a31eb50 100644
--- a/velox/functions/lib/DateTimeFormatter.cpp
+++ b/velox/functions/lib/DateTimeFormatter.cpp
@@ -310,10 +310,11 @@ parseFail(const std::string_view& input, const char* cur, const char* end) {
   if (threadSkipErrorDetails()) {
     return folly::makeUnexpected(Status::UserError());
   }
-  return folly::makeUnexpected(Status::UserError(
-      "Invalid date format: '{}' is malformed at '{}'",
-      input,
-      std::string_view(cur, end - cur)));
+  return folly::makeUnexpected(
+      Status::UserError(
+          "Invalid date format: '{}' is malformed at '{}'",
+          input,
+          std::string_view(cur, end - cur)));
 }
 
 // Joda only supports parsing a few three-letter prefixes. The list is available
@@ -1221,10 +1222,10 @@ uint32_t DateTimeFormatter::maxResultSize(const tz::TimeZone* timezone) const {
         break;
       case DateTimeFormatSpecifier::TIMEZONE:
         if (token.pattern.minRepresentDigits <= 3) {
-          // The longest timezone abbreviation is 6 in the case of negative or
-          // explicitly positive numeric representations (e.g., +01:00, -08:00)
-          // https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
-          size += 6;
+          // The longest timezone abbreviation is 9 in the case of timezones
+          // that do not have an abbreviation and use GMT offset (e.g.,
+          // GMT+01:00, GMT-08:00)
+          size += 9;
         } else {
           // The longest time zone long name is 40, Australian Central Western
           // Standard Time.
@@ -1618,13 +1619,14 @@ Expected<DateTimeResult> DateTimeFormatter::parse(
       if (threadSkipErrorDetails()) {
         return folly::makeUnexpected(Status::UserError());
       }
-      return folly::makeUnexpected(Status::UserError(
-          "Value {} for dayOfMonth must be in the range [1,{}] "
-          "for year {} and month {}.",
-          date.dayOfMonthValues[i],
-          util::getMaxDayOfMonth(date.year, date.month),
-          date.year,
-          date.month));
+      return folly::makeUnexpected(
+          Status::UserError(
+              "Value {} for dayOfMonth must be in the range [1,{}] "
+              "for year {} and month {}.",
+              date.dayOfMonthValues[i],
+              util::getMaxDayOfMonth(date.year, date.month),
+              date.year,
+              date.month));
     }
   }
 
@@ -1634,13 +1636,14 @@ Expected<DateTimeResult> DateTimeFormatter::parse(
       if (threadSkipErrorDetails()) {
         return folly::makeUnexpected(Status::UserError());
       }
-      return folly::makeUnexpected(Status::UserError(
-          "Value {} for dayOfMonth must be in the range [1,{}] "
-          "for year {} and month {}.",
-          date.dayOfYearValues[i],
-          util::isLeapYear(date.year) ? 366 : 365,
-          date.year,
-          date.month));
+      return folly::makeUnexpected(
+          Status::UserError(
+              "Value {} for dayOfMonth must be in the range [1,{}] "
+              "for year {} and month {}.",
+              date.dayOfYearValues[i],
+              util::isLeapYear(date.year) ? 366 : 365,
+              date.year,
+              date.month));
     }
   }
 
@@ -1797,8 +1800,9 @@ Expected<std::shared_ptr<DateTimeFormatter>> buildMysqlDateTimeFormatter(
           if (threadSkipErrorDetails()) {
             return folly::makeUnexpected(Status::UserError());
           }
-          return folly::makeUnexpected(Status::UserError(
-              "Date format specifier is not supported: %{}", *tokenEnd));
+          return folly::makeUnexpected(
+              Status::UserError(
+                  "Date format specifier is not supported: %{}", *tokenEnd));
         default:
           builder.appendLiteral(tokenEnd, 1);
           break;
@@ -1936,8 +1940,9 @@ Expected<std::shared_ptr<DateTimeFormatter>> buildJodaDateTimeFormatter(
             if (threadSkipErrorDetails()) {
               return folly::makeUnexpected(Status::UserError());
             }
-            return folly::makeUnexpected(Status::UserError(
-                "Specifier {} is not supported.", *startTokenPtr));
+            return folly::makeUnexpected(
+                Status::UserError(
+                    "Specifier {} is not supported.", *startTokenPtr));
           } else {
             builder.appendLiteral(startTokenPtr, cur - startTokenPtr);
           }
@@ -2015,9 +2020,6 @@ Expected<std::shared_ptr<DateTimeFormatter>> buildSimpleDateTimeFormatter(
         case 'D':
           builder.appendDayOfYear(count);
           break;
-        case 'e':
-          builder.appendDayOfWeek1Based(count);
-          break;
         case 'E':
           builder.appendDayOfWeekText(count);
           break;
@@ -2052,6 +2054,9 @@ Expected<std::shared_ptr<DateTimeFormatter>> buildSimpleDateTimeFormatter(
         case 'S':
           builder.appendFractionOfSecond(count);
           break;
+        case 'u':
+          builder.appendDayOfWeek1Based(count);
+          break;
         case 'w':
           builder.appendWeekOfWeekYear(count);
           break;
@@ -2078,8 +2083,9 @@ Expected<std::shared_ptr<DateTimeFormatter>> buildSimpleDateTimeFormatter(
             if (threadSkipErrorDetails()) {
               return folly::makeUnexpected(Status::UserError());
             }
-            return folly::makeUnexpected(Status::UserError(
-                "Specifier {} is not supported.", *startTokenPtr));
+            return folly::makeUnexpected(
+                Status::UserError(
+                    "Specifier {} is not supported.", *startTokenPtr));
           } else {
             builder.appendLiteral(startTokenPtr, cur - startTokenPtr);
           }
diff --git a/velox/functions/lib/DateTimeFormatterBuilder.cpp b/velox/functions/lib/DateTimeFormatterBuilder.cpp
index aa80058ac8f..afa808fd398 100644
--- a/velox/functions/lib/DateTimeFormatterBuilder.cpp
+++ b/velox/functions/lib/DateTimeFormatterBuilder.cpp
@@ -204,8 +204,9 @@ DateTimeFormatterBuilder& DateTimeFormatterBuilder::appendLiteral(
     tokens_.back().literal =
         std::string_view(prev.data(), prev.size() + literalSize);
   } else {
-    tokens_.emplace_back(std::string_view(
-        literalBuf_.get() + bufEnd_ - literalSize, literalSize));
+    tokens_.emplace_back(
+        std::string_view(
+            literalBuf_.get() + bufEnd_ - literalSize, literalSize));
   }
   return *this;
 }
diff --git a/velox/functions/lib/DateTimeUtil.h b/velox/functions/lib/DateTimeUtil.h
index e0064cd4a2e..46057f02b4d 100644
--- a/velox/functions/lib/DateTimeUtil.h
+++ b/velox/functions/lib/DateTimeUtil.h
@@ -18,6 +18,8 @@
 #include "velox/external/date/date.h"
 #include "velox/functions/lib/DateTimeFormatter.h"
 #include "velox/type/Timestamp.h"
+#include "velox/type/TimestampConversion.h"
+#include "velox/type/Type.h"
 #include "velox/type/tz/TimeZoneMap.h"
 
 namespace facebook::velox::functions {
@@ -45,8 +47,9 @@ FOLLY_ALWAYS_INLINE int64_t diffTimestamp(
   // converting all timestamps to microseconds for each unit.
   if (unit == DateTimeUnit::kMicrosecond) {
     const std::chrono::time_point<std::chrono::system_clock>
-        fromMicrosecondpoint(std::chrono::microseconds(
-            std::min(fromTimestamp, toTimestamp).toMicros()));
+        fromMicrosecondpoint(
+            std::chrono::microseconds(
+                std::min(fromTimestamp, toTimestamp).toMicros()));
     const std::chrono::time_point<std::chrono::system_clock> toMicrosecondpoint(
         std::chrono::microseconds(
             std::max(fromTimestamp, toTimestamp).toMicros()));
@@ -59,12 +62,14 @@ FOLLY_ALWAYS_INLINE int64_t diffTimestamp(
   // fromTimepoint is less than or equal to toTimepoint.
   const std::chrono::
       time_point<std::chrono::system_clock, std::chrono::milliseconds>
-          fromTimepoint(std::chrono::milliseconds(
-              std::min(fromTimestamp, toTimestamp).toMillis()));
+          fromTimepoint(
+              std::chrono::milliseconds(
+                  std::min(fromTimestamp, toTimestamp).toMillis()));
   const std::chrono::
       time_point<std::chrono::system_clock, std::chrono::milliseconds>
-          toTimepoint(std::chrono::milliseconds(
-              std::max(fromTimestamp, toTimestamp).toMillis()));
+          toTimepoint(
+              std::chrono::milliseconds(
+                  std::max(fromTimestamp, toTimestamp).toMillis()));
 
   // Millisecond, second, minute, hour and day have fixed conversion ratio.
   switch (unit) {
@@ -205,6 +210,21 @@ FOLLY_ALWAYS_INLINE int64_t diffTimestamp(
   return diffTimestamp(unit, fromTimestamp, toTimestamp, respectLastDay);
 }
 
+/// Returns toDate - fromDate expressed in terms of unit.
+FOLLY_ALWAYS_INLINE
+int64_t diffDate(
+    const DateTimeUnit unit,
+    const int32_t fromDate,
+    const int32_t toDate) {
+  if (fromDate == toDate) {
+    return 0;
+  }
+  return diffTimestamp(
+      unit,
+      Timestamp((int64_t)fromDate * util::kSecsPerDay, 0),
+      Timestamp((int64_t)toDate * util::kSecsPerDay, 0));
+}
+
 /// Year, quarter or month are not uniformly incremented. Months have different
 /// total days, and leap years have more days than the rest. If the new year,
 /// quarter or month has less total days than the given one, it will be coerced
@@ -288,11 +308,12 @@ addToTimestamp(const Timestamp& timestamp, DateTimeUnit unit, int32_t value) {
       outTimestamp;
 
   switch (unit) {
-    // Year, quarter or month are not uniformly incremented in terms of number
-    // of days. So we treat them differently.
+    // Year, quarter, month or week are not uniformly incremented in terms of
+    // number of days. So we treat them differently.
     case DateTimeUnit::kYear:
     case DateTimeUnit::kQuarter:
     case DateTimeUnit::kMonth:
+    case DateTimeUnit::kWeek:
     case DateTimeUnit::kDay: {
       const int32_t inDate =
           std::chrono::duration_cast<date::days>(inTimestamp.time_since_epoch())
@@ -318,15 +339,6 @@ addToTimestamp(const Timestamp& timestamp, DateTimeUnit unit, int32_t value) {
       outTimestamp = inTimestamp + std::chrono::milliseconds(value);
       break;
     }
-    case DateTimeUnit::kWeek: {
-      const int32_t inDate =
-          std::chrono::duration_cast<date::days>(inTimestamp.time_since_epoch())
-              .count();
-      const int32_t outDate = addToDate(inDate, DateTimeUnit::kDay, 7 * value);
-
-      outTimestamp = inTimestamp + date::days(outDate - inDate);
-      break;
-    }
     default:
       VELOX_UNREACHABLE("Unsupported datetime unit");
   }
@@ -373,4 +385,74 @@ FOLLY_ALWAYS_INLINE Timestamp addToTimestamp(
   return result;
 }
 
+/// Adds the specified unit and value to a TIME value, handling 24-hour
+/// wraparound. TIME represents milliseconds since midnight (0 to 86399999ms).
+/// For units < DAY, the time of day changes.
+/// For units >= DAY, the time of day doesn't change.
+FOLLY_ALWAYS_INLINE int64_t addToTime(int64_t time, int64_t valueInMillis) {
+  VELOX_USER_CHECK(
+      time >= 0 && time < kMillisInDay,
+      "TIME value {} is out of range [0, 86400000)",
+      time);
+
+  if (FOLLY_UNLIKELY(valueInMillis == 0)) {
+    return time;
+  }
+
+  // Use std::chrono for safe duration arithmetic with overflow protection
+  const auto timeDuration = std::chrono::milliseconds(time);
+  const auto valueDuration = std::chrono::milliseconds(valueInMillis);
+  const auto resultDuration = timeDuration + valueDuration;
+
+  // Handle 24-hour wraparound using modulo
+  const auto dayDuration = std::chrono::milliseconds(kMillisInDay);
+  auto newTime = resultDuration % dayDuration;
+
+  // Ensure result is positive (C++ modulo can return negative values)
+  if (FOLLY_UNLIKELY(newTime.count() < 0)) {
+    newTime += dayDuration;
+  }
+
+  return newTime.count();
+}
+
+/// Truncates a TIME value to the specified unit. TIME represents milliseconds
+/// since midnight (0 to 86399999ms). Only time-related units (millisecond,
+/// second, minute, hour) are supported.
+FOLLY_ALWAYS_INLINE int64_t truncateTime(int64_t time, DateTimeUnit unit) {
+  VELOX_USER_CHECK(
+      time >= 0 && time < kMillisInDay,
+      "TIME value {} is out of range [0, 86400000)",
+      time);
+
+  // Validate that the unit is appropriate for TIME type
+  VELOX_USER_CHECK(isTimeUnit(unit), "Unsupported time unit for TIME type");
+
+  const auto duration = std::chrono::milliseconds(time);
+
+  switch (unit) {
+    case DateTimeUnit::kMillisecond:
+      return time;
+    case DateTimeUnit::kSecond: {
+      const auto seconds =
+          std::chrono::duration_cast<std::chrono::seconds>(duration);
+      return std::chrono::duration_cast<std::chrono::milliseconds>(seconds)
+          .count();
+    }
+    case DateTimeUnit::kMinute: {
+      const auto minutes =
+          std::chrono::duration_cast<std::chrono::minutes>(duration);
+      return std::chrono::duration_cast<std::chrono::milliseconds>(minutes)
+          .count();
+    }
+    case DateTimeUnit::kHour: {
+      const auto hours =
+          std::chrono::duration_cast<std::chrono::hours>(duration);
+      return std::chrono::duration_cast<std::chrono::milliseconds>(hours)
+          .count();
+    }
+    default:
+      VELOX_UNREACHABLE();
+  }
+}
 } // namespace facebook::velox::functions
diff --git a/velox/functions/lib/FilterFunctionBase.h b/velox/functions/lib/FilterFunctionBase.h
new file mode 100644
index 00000000000..f71a099457a
--- /dev/null
+++ b/velox/functions/lib/FilterFunctionBase.h
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/Expr.h"
+#include "velox/expression/VectorFunction.h"
+#include "velox/functions/lib/LambdaFunctionUtil.h"
+#include "velox/functions/lib/RowsTranslationUtil.h"
+#include "velox/vector/FunctionVector.h"
+
+namespace facebook::velox::functions {
+
+/// Base class for filter functions (both array and map).
+/// Provides a shared doApply() template for evaluating lambda predicates
+/// and collecting indices of matching elements.
+class FilterFunctionBase : public exec::VectorFunction {
+ protected:
+  // Applies filter functions to elements of maps or arrays and returns the
+  // number of elements that passed the filters. Stores the number of elements
+  // in each array or map that passed the filter in resultSizes. Stores the
+  // indices of passing elements in selectedIndices. resultOffsets is populated
+  // assuming sequential layout of the passing elements.
+  template <typename T>
+  static vector_size_t doApply(
+      const SelectivityVector& rows,
+      const std::shared_ptr<T>& input,
+      const VectorPtr& lambda,
+      const std::vector<VectorPtr>& lambdaArgs,
+      exec::EvalCtx& context,
+      BufferPtr& resultOffsets,
+      BufferPtr& resultSizes,
+      BufferPtr& selectedIndices) {
+    const auto* inputOffsets = input->rawOffsets();
+    const auto* inputSizes = input->rawSizes();
+
+    auto* pool = context.pool();
+    resultSizes = allocateSizes(rows.end(), pool);
+    resultOffsets = allocateOffsets(rows.end(), pool);
+    auto* rawResultSizes = resultSizes->asMutable<vector_size_t>();
+    auto* rawResultOffsets = resultOffsets->asMutable<vector_size_t>();
+
+    const auto numElements = lambdaArgs[0]->size();
+
+    selectedIndices = allocateIndices(numElements, pool);
+    auto* rawSelectedIndices = selectedIndices->asMutable<vector_size_t>();
+
+    vector_size_t numSelected = 0;
+
+    auto elementToTopLevelRows =
+        getElementToTopLevelRows(numElements, rows, input.get(), pool);
+
+    exec::LocalDecodedVector bitsDecoder(context);
+    auto iter = lambda->asUnchecked<FunctionVector>()->iterator(&rows);
+    while (auto entry = iter.next()) {
+      auto elementRows =
+          toElementRows<T>(numElements, *entry.rows, input.get());
+      auto wrapCapture =
+          toWrapCapture<T>(numElements, entry.callable, *entry.rows, input);
+
+      VectorPtr bits;
+      entry.callable->apply(
+          elementRows,
+          nullptr,
+          wrapCapture,
+          &context,
+          lambdaArgs,
+          elementToTopLevelRows,
+          &bits);
+      bitsDecoder.get()->decode(*bits, elementRows);
+      entry.rows->applyToSelected([&](vector_size_t row) {
+        if (input->isNullAt(row)) {
+          return;
+        }
+        auto size = inputSizes[row];
+        auto offset = inputOffsets[row];
+        rawResultOffsets[row] = numSelected;
+        for (auto i = 0; i < size; ++i) {
+          if (!bitsDecoder.get()->isNullAt(offset + i) &&
+              bitsDecoder.get()->valueAt<bool>(offset + i)) {
+            ++rawResultSizes[row];
+            rawSelectedIndices[numSelected] = offset + i;
+            ++numSelected;
+          }
+        }
+      });
+    }
+
+    selectedIndices->setSize(numSelected * sizeof(vector_size_t));
+
+    return numSelected;
+  }
+};
+
+/// Array filter function base class.
+/// Subclasses can override addIndexVector() to provide additional lambda
+/// arguments (e.g., element index for Spark's filter function).
+class ArrayFilterFunctionBase : public FilterFunctionBase {
+ public:
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& /* outputType */,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    VELOX_CHECK_EQ(args.size(), 2);
+    exec::LocalDecodedVector arrayDecoder(context, *args[0], rows);
+    auto& decodedArray = *arrayDecoder.get();
+
+    auto flatArray = flattenArray(rows, args[0], decodedArray);
+
+    VectorPtr elements = flatArray->elements();
+    std::vector<VectorPtr> lambdaArgs = {elements};
+
+    // Allow subclasses to add additional lambda arguments (e.g., index vector).
+    addIndexVector(args, flatArray, elements->size(), context, lambdaArgs);
+
+    BufferPtr resultSizes;
+    BufferPtr resultOffsets;
+    BufferPtr selectedIndices;
+    auto numSelected = doApply(
+        rows,
+        flatArray,
+        args[1],
+        lambdaArgs,
+        context,
+        resultOffsets,
+        resultSizes,
+        selectedIndices);
+
+    // Filter can pass along very large elements vectors that can hold onto
+    // memory and copy operations on them can further put memory pressure. We
+    // try to flatten them if the dictionary layer is much smaller than the
+    // elements vector.
+    auto wrappedElements = numSelected ? BaseVector::wrapInDictionary(
+                                             BufferPtr(nullptr),
+                                             std::move(selectedIndices),
+                                             numSelected,
+                                             std::move(elements),
+                                             true /*flattenIfRedundant*/)
+                                       : nullptr;
+    // Set nulls for rows not present in 'rows'.
+    BufferPtr newNulls = addNullsForUnselectedRows(flatArray, rows);
+    auto localResult = std::make_shared<ArrayVector>(
+        flatArray->pool(),
+        flatArray->type(),
+        std::move(newNulls),
+        rows.end(),
+        std::move(resultOffsets),
+        std::move(resultSizes),
+        wrappedElements);
+    context.moveOrCopyResult(localResult, rows, result);
+  }
+
+  /// Returns the base signature: array(T), function(T, boolean) -> array(T).
+  /// Subclasses can call this and add additional signatures.
+  static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
+    return {exec::FunctionSignatureBuilder()
+                .typeVariable("T")
+                .returnType("array(T)")
+                .argumentType("array(T)")
+                .argumentType("function(T,boolean)")
+                .build()};
+  }
+
+ protected:
+  /// Override this method to add additional arguments to the lambda.
+  /// Default implementation does nothing (element-only filter).
+  virtual void addIndexVector(
+      const std::vector<VectorPtr>& /*args*/,
+      const ArrayVectorPtr& /*flatArray*/,
+      vector_size_t /*numElements*/,
+      exec::EvalCtx& /*context*/,
+      std::vector<VectorPtr>& /*lambdaArgs*/) const {}
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/HllAccumulator.h b/velox/functions/lib/HllAccumulator.h
new file mode 100644
index 00000000000..1b2cba7c5c9
--- /dev/null
+++ b/velox/functions/lib/HllAccumulator.h
@@ -0,0 +1,246 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cmath>
+#include "velox/common/base/XxHashInline.h"
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/hyperloglog/DenseHll.h"
+#include "velox/common/hyperloglog/Murmur3Hash128.h"
+#include "velox/common/hyperloglog/SparseHll.h"
+#include "velox/common/memory/HashStringAllocator.h"
+
+namespace facebook::velox::common::hll {
+
+namespace detail {
+template <typename T, bool HllAsFinalResult>
+inline uint64_t hashOne(const T& value) {
+  if constexpr (std::is_same_v<T, Timestamp>) {
+    return hashOne<int64_t, HllAsFinalResult>(value.toMillis());
+  }
+  if constexpr (HllAsFinalResult) {
+    if constexpr (std::is_same_v<T, int64_t>) {
+      return common::hll::Murmur3Hash128::hash64ForLong(value, 0);
+    } else if constexpr (std::is_same_v<T, double>) {
+      return common::hll::Murmur3Hash128::hash64ForLong(
+          *reinterpret_cast<const int64_t*>(&value), 0);
+    }
+    return common::hll::Murmur3Hash128::hash64(&value, sizeof(T), 0);
+  } else {
+    return XXH64(&value, sizeof(T), 0);
+  }
+}
+
+template <>
+inline uint64_t hashOne<StringView, false>(const StringView& value) {
+  return XXH64(value.data(), value.size(), 0);
+}
+
+template <>
+inline uint64_t hashOne<StringView, true>(const StringView& value) {
+  return common::hll::Murmur3Hash128::hash64(value.data(), value.size(), 0);
+}
+
+} // namespace detail
+
+template <
+    typename T,
+    bool HllAsFinalResult,
+    typename TAllocator = HashStringAllocator>
+struct HllAccumulator {
+  explicit HllAccumulator(TAllocator* allocator)
+      : sparseHll_{allocator}, denseHll_{allocator} {}
+
+  explicit HllAccumulator(int8_t indexBitLength, TAllocator* allocator)
+      : isSparse_(true),
+        indexBitLength_(indexBitLength),
+        sparseHll_(allocator),
+        denseHll_(allocator) {
+    // Set soft memory limit for sparse HLL to convert to dense when exceeded.
+    sparseHll_.setSoftMemoryLimit(
+        DenseHlls::estimateInMemorySize(indexBitLength_));
+  }
+
+  void setIndexBitLength(int8_t indexBitLength) {
+    indexBitLength_ = indexBitLength;
+    sparseHll_.setSoftMemoryLimit(
+        DenseHlls::estimateInMemorySize(indexBitLength_));
+  }
+
+  /// Creates an HllAccumulator instance from serialized data.
+  static std::unique_ptr<HllAccumulator> deserialize(
+      const char* data,
+      TAllocator* allocator) {
+    if (SparseHlls::canDeserialize(data)) {
+      int8_t indexBitLength = SparseHlls::deserializeIndexBitLength(data);
+      auto wrapper =
+          std::make_unique<HllAccumulator>(indexBitLength, allocator);
+      wrapper->sparseHll_ = SparseHll<TAllocator>(data, allocator);
+      wrapper->sparseHll_.setSoftMemoryLimit(
+          DenseHlls::estimateInMemorySize(indexBitLength));
+      return wrapper;
+    } else if (DenseHlls::canDeserialize(data)) {
+      int8_t indexBitLength = DenseHlls::deserializeIndexBitLength(data);
+      auto wrapper =
+          std::make_unique<HllAccumulator>(indexBitLength, allocator);
+      wrapper->denseHll_ = DenseHll<TAllocator>(data, allocator);
+      wrapper->isSparse_ = false;
+      return wrapper;
+    } else {
+      VELOX_FAIL("Cannot deserialize HyperLogLog");
+    }
+  }
+
+  void append(T value) {
+    const auto hash = detail::hashOne<T, HllAsFinalResult>(value);
+    insertHash(hash);
+  }
+
+  void insertHash(uint64_t hash) {
+    if (isSparse_) {
+      // insertHash returns true if soft memory limit exceeded
+      if (sparseHll_.insertHash(hash)) {
+        toDense();
+      }
+    } else {
+      denseHll_.insertHash(hash);
+    }
+  }
+
+  int64_t cardinality() const {
+    return isSparse_ ? sparseHll_.cardinality() : denseHll_.cardinality();
+  }
+
+  void mergeWith(StringView serialized, TAllocator* allocator) {
+    auto input = serialized.data();
+    if (indexBitLength_ < 0) {
+      // deserializeIndexBitLength is the same between Dense and Sparse HLL
+      setIndexBitLength(DenseHlls::deserializeIndexBitLength(input));
+    }
+
+    if (SparseHlls::canDeserialize(input)) {
+      SparseHll<TAllocator> other{input, allocator};
+      mergeWithSparse(other);
+    } else if (DenseHlls::canDeserialize(input)) {
+      DenseHll<TAllocator> other{input, allocator};
+      mergeWithDense(other);
+    } else {
+      VELOX_USER_FAIL("Unexpected type of HLL");
+    }
+  }
+
+  void mergeWith(const HllAccumulator& other) {
+    if (indexBitLength_ < 0) {
+      setIndexBitLength(other.indexBitLength_);
+    }
+    if (other.isSparse_) {
+      mergeWithSparse(other.sparseHll_);
+    } else {
+      mergeWithDense(other.denseHll_);
+    }
+  }
+
+  int32_t serializedSize() {
+    return isSparse_ ? sparseHll_.serializedSize() : denseHll_.serializedSize();
+  }
+
+  void serialize(char* outputBuffer) {
+    return isSparse_ ? sparseHll_.serialize(indexBitLength_, outputBuffer)
+                     : denseHll_.serialize(outputBuffer);
+  }
+
+  bool isSparse() const {
+    return isSparse_;
+  }
+
+ private:
+  void toDense() {
+    isSparse_ = false;
+    denseHll_.initialize(indexBitLength_);
+    sparseHll_.toDense(denseHll_);
+    sparseHll_.reset();
+  }
+
+  void mergeWithSparse(const SparseHll<TAllocator>& other) {
+    if (isSparse_) {
+      sparseHll_.mergeWith(other);
+      if (sparseHll_.overLimit()) {
+        toDense();
+      }
+    } else {
+      other.toDense(denseHll_);
+    }
+  }
+
+  void mergeWithDense(const DenseHll<TAllocator>& other) {
+    if (isSparse_) {
+      toDense();
+    }
+    VELOX_USER_CHECK_EQ(
+        indexBitLength_,
+        other.indexBitLength(),
+        "Cannot merge HLLs with different number of buckets");
+    denseHll_.mergeWith(other);
+  }
+
+  bool isSparse_{true};
+  int8_t indexBitLength_{-1};
+  SparseHll<TAllocator> sparseHll_;
+  DenseHll<TAllocator> denseHll_;
+};
+
+template <>
+struct HllAccumulator<bool, false> {
+  explicit HllAccumulator(HashStringAllocator* /*allocator*/) {}
+
+  void append(bool value) {
+    approxDistinctState_ |= (1 << value);
+  }
+
+  int64_t cardinality() const {
+    return (approxDistinctState_ & 1) + ((approxDistinctState_ & 2) >> 1);
+  }
+
+  void mergeWith(
+      StringView /*serialized*/,
+      HashStringAllocator* /*allocator*/) {
+    VELOX_UNREACHABLE(
+        "APPROX_DISTINCT<BOOLEAN> unsupported mergeWith(StringView, HashStringAllocator*)");
+  }
+
+  void mergeWith(int8_t data) {
+    approxDistinctState_ |= data;
+  }
+
+  int32_t serializedSize() const {
+    return sizeof(int8_t);
+  }
+
+  void serialize(char* /*outputBuffer*/) {
+    VELOX_UNREACHABLE("APPROX_DISTINCT<BOOLEAN> unsupported serialize(char*)");
+  }
+
+  void setIndexBitLength(int8_t /*indexBitLength*/) {}
+
+  int8_t getState() const {
+    return approxDistinctState_;
+  }
+
+ private:
+  int8_t approxDistinctState_{0};
+};
+} // namespace facebook::velox::common::hll
diff --git a/velox/functions/lib/KHyperLogLog.h b/velox/functions/lib/KHyperLogLog.h
new file mode 100644
index 00000000000..564f9e5babe
--- /dev/null
+++ b/velox/functions/lib/KHyperLogLog.h
@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <map>
+#include <memory>
+
+#include <folly/container/F14Map.h>
+#include "velox/common/base/Status.h"
+#include "velox/functions/lib/HllAccumulator.h"
+
+namespace facebook::velox::common::hll {
+
+/// See "KHyperLogLog: EstimatingReidentifiability and Joinability of Large Data
+/// at Scale" by Chia et al., 2019.
+/// https://research.google/pubs/khyperloglog-estimating-reidentifiability-and-joinability-of-large-data-at-scale/
+template <typename TUii, typename TAllocator>
+class KHyperLogLog {
+ public:
+  template <typename U>
+  using TStlAllocator = typename TAllocator::template TStlAllocator<U>;
+
+  static constexpr int32_t kDefaultHllBuckets = 256;
+  static constexpr int32_t kDefaultMaxSize = 4096;
+
+  explicit KHyperLogLog(TAllocator* allocator)
+      : KHyperLogLog(kDefaultMaxSize, kDefaultHllBuckets, allocator) {}
+
+  KHyperLogLog(int maxSize, int hllBuckets, TAllocator* allocator)
+      : maxSize_(maxSize),
+        hllBuckets_(hllBuckets),
+        allocator_(allocator),
+        minhash_(
+            TStlAllocator<std::pair<
+                const int64_t,
+                HllAccumulator<TUii, true, TAllocator>>>(allocator)) {
+    VELOX_CHECK(
+        hllBuckets > 0 && (hllBuckets & (hllBuckets - 1)) == 0,
+        "hllBuckets must be a power of 2");
+    // numBuckets = 2^bits
+    indexBitLength_ = static_cast<int8_t>(std::log2(hllBuckets));
+  }
+
+  /// Creates a KHyperLogLog instance from serialized data.
+  /// Returns an error status if the data is invalid.
+  static Expected<std::unique_ptr<KHyperLogLog<TUii, TAllocator>>>
+  deserialize(const char* data, size_t size, TAllocator* allocator);
+
+  /// Serializes the KHyperLogLog state to a varbinary.
+  /// The caller must ensure there is enough space at the buffer location, using
+  /// estimatedSerializedSize(). Note: Not const because DenseHll::serialize()
+  /// may reorder internal overflow arrays for deterministic serialization.
+  void serialize(char* outputBuffer);
+
+  /// Returns an estimate of the size in bytes of the serialized
+  /// representation.
+  size_t estimatedSerializedSize() const;
+
+  /// Convert JoinKey to int64_t, hash, then add with its associated User
+  /// Identifying Information (UII) to the existing KHLL.
+  template <typename TJoinKey>
+  void add(TJoinKey joinKey, TUii uii);
+
+  /// Returns the estimated cardinality (number of distinct join keys).
+  /// When isExact() is true, returns exact count. Otherwise, uses min-hash
+  /// density estimation to extrapolate to the full hash space.
+  int64_t cardinality() const;
+
+  /// Returns whether the KHyperLogLog is in exact mode.
+  /// Exact mode means the number of distinct values is less than maxSize,
+  /// so all values are being tracked exactly without approximation.
+  bool isExact() const;
+
+  size_t minhashSize() const;
+
+  /// Counts the exact number of common join keys between two KHyperLogLogs.
+  /// Both instances must be in exact mode (isExact() == true), otherwise
+  /// throws.
+  static int64_t exactIntersectionCardinality(
+      const KHyperLogLog<TUii, TAllocator>& left,
+      const KHyperLogLog<TUii, TAllocator>& right);
+
+  /// Computes the Jaccard index (similarity coefficient) between two
+  /// KHyperLogLogs. Uses the min-hash approach: looks at the first
+  /// min(|left.minhash|, |right.minhash|) entries in the sorted union of keys
+  /// and calculates the proportion that appear in both sets.
+  static double jaccardIndex(
+      const KHyperLogLog<TUii, TAllocator>& left,
+      const KHyperLogLog<TUii, TAllocator>& right);
+
+  /// Merges two KHyperLogLog instances into a new instance.
+  /// Uses the one with the smaller maxSize as the base to avoid losing
+  /// resolution. Takes ownership of the input unique_ptrs and returns one
+  /// of them to avoid copying.
+  static std::unique_ptr<KHyperLogLog<TUii, TAllocator>> merge(
+      std::unique_ptr<KHyperLogLog<TUii, TAllocator>> left,
+      std::unique_ptr<KHyperLogLog<TUii, TAllocator>> right);
+
+  /// Calculates the reidentification potential, which is the proportion of
+  /// values with cardinality (number of distinct UIIs) at or below the given
+  /// threshold. A higher value indicates more values are highly unique and
+  /// could potentially be used to reidentify individuals.
+  double reidentificationPotential(int64_t threshold) const;
+
+  /// Returns a histogram of the uniqueness distribution with specified number
+  /// of buckets. For each value, determines its cardinality (number of distinct
+  /// UIIs) and increments the corresponding bucket. For hash values larger than
+  /// the histogram size, the cardinality will be added to the last bucket at
+  /// histogramSize.
+  folly::F14FastMap<int64_t, double> uniquenessDistribution(
+      int64_t histogramSize) const;
+
+  /// Merges another KHyperLogLog instance into this one (modifies this
+  /// instance).
+  void mergeWith(const KHyperLogLog<TUii, TAllocator>& other);
+
+  /// Merges another serialized KHyperLogLog into this one.
+  /// The serialized data is assumed to be valid.
+  void mergeWith(StringView serialized, TAllocator* allocator) {
+    auto other = common::hll::KHyperLogLog<TUii, TAllocator>::deserialize(
+        serialized.data(), serialized.size(), allocator);
+    VELOX_CHECK(other.hasValue(), "Failed to deserialize KHyperLogLog");
+    mergeWith(*other.value());
+  }
+
+ private:
+  void update(int64_t hash, TUii uii);
+
+  void removeOverflowEntries();
+
+  void increaseTotalHllSize(HllAccumulator<TUii, true, TAllocator>& hll);
+
+  void decreaseTotalHllSize(HllAccumulator<TUii, true, TAllocator>& hll);
+
+  int64_t maxKey() const {
+    if (minhash_.empty()) {
+      return INT64_MIN;
+    }
+    return minhash_.rbegin()->first;
+  }
+
+  int32_t maxSize_;
+  int32_t hllBuckets_;
+  int8_t indexBitLength_;
+  TAllocator* allocator_;
+
+  std::map<
+      int64_t,
+      HllAccumulator<TUii, true, TAllocator>,
+      std::less<int64_t>,
+      TStlAllocator<
+          std::pair<const int64_t, HllAccumulator<TUii, true, TAllocator>>>>
+      minhash_;
+
+  size_t hllsTotalEstimatedSerializedSize_{0};
+};
+
+} // namespace facebook::velox::common::hll
+
+#include "velox/functions/lib/KHyperLogLogImpl.h"
diff --git a/velox/functions/lib/KHyperLogLogImpl.h b/velox/functions/lib/KHyperLogLogImpl.h
new file mode 100644
index 00000000000..757ed4fcf29
--- /dev/null
+++ b/velox/functions/lib/KHyperLogLogImpl.h
@@ -0,0 +1,438 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/base/IOUtils.h"
+#include "velox/common/hyperloglog/Murmur3Hash128.h"
+#include "velox/type/HugeInt.h"
+
+namespace facebook::velox::common::hll {
+
+namespace detail {
+constexpr uint8_t kVersionByte = 1;
+constexpr int64_t kHashOutputHalfRange = INT64_MAX;
+constexpr size_t kHeaderSize = sizeof(uint8_t) // version
+    + 4 * sizeof(int32_t); // maxSize, hllBuckets, minhashSize, hllsTotalSize;
+
+template <typename TJoinKey>
+static int64_t hashKey(TJoinKey joinKey) {
+  int64_t result;
+  if constexpr (std::is_same_v<TJoinKey, Timestamp>) {
+    result = joinKey.toMillis();
+  } else if constexpr (
+      std::is_same_v<TJoinKey, int128_t> ||
+      std::is_same_v<TJoinKey, uint128_t>) {
+    return Murmur3Hash128::hash64(&joinKey, sizeof(joinKey), 0);
+  } else if constexpr (std::is_integral_v<TJoinKey>) {
+    result = static_cast<int64_t>(joinKey);
+  } else if constexpr (std::is_same_v<TJoinKey, float>) {
+    // Cast to double first, then extract bits, based on implicit coercion
+    double dbl = static_cast<double>(joinKey);
+    std::memcpy(&result, &dbl, sizeof(result));
+  } else if constexpr (std::is_same_v<TJoinKey, double>) {
+    std::memcpy(&result, &joinKey, sizeof(result));
+  } else if constexpr (std::is_same_v<TJoinKey, StringView>) {
+    result =
+        common::hll::Murmur3Hash128::hash64(joinKey.data(), joinKey.size(), 0);
+  } else {
+    VELOX_UNREACHABLE("Unsupported input type: {}", typeid(TJoinKey).name());
+  }
+
+  return Murmur3Hash128::hash64(&result, sizeof(result), 0);
+}
+} // namespace detail
+
+template <typename TUii, typename TAllocator>
+Expected<std::unique_ptr<KHyperLogLog<TUii, TAllocator>>>
+KHyperLogLog<TUii, TAllocator>::deserialize(
+    const char* data,
+    size_t size,
+    TAllocator* allocator) {
+  VELOX_RETURN_UNEXPECTED_IF(
+      size < sizeof(uint8_t),
+      Status::UserError("Invalid KHyperLogLog data: too small"));
+
+  InputByteStream stream(data);
+
+  uint8_t version = stream.read<uint8_t>();
+  VELOX_RETURN_UNEXPECTED_IF(
+      version != detail::kVersionByte,
+      Status::UserError("Unsupported KHyperLogLog version"));
+
+  VELOX_RETURN_UNEXPECTED_IF(
+      size < detail::kHeaderSize,
+      Status::UserError("Invalid KHyperLogLog data: insufficient header size"));
+
+  // Header values
+  int32_t maxSize = stream.read<int32_t>();
+  int32_t hllBuckets = stream.read<int32_t>();
+  int32_t minhashSize = stream.read<int32_t>();
+  int32_t totalHllSize = stream.read<int32_t>();
+
+  if (minhashSize == 0) {
+    VELOX_RETURN_UNEXPECTED_IF(
+        totalHllSize != 0,
+        Status::UserError(
+            "Invalid KHyperLogLog data: minhashSize is 0 but totalHllSize is not 0"));
+    size_t remainingSize = size - stream.offset();
+    VELOX_RETURN_UNEXPECTED_IF(
+        remainingSize != 0,
+        Status::UserError(
+            "Invalid KHyperLogLog data: minhashSize is 0 but extra data remains"));
+    return std::make_unique<KHyperLogLog<TUii, TAllocator>>(
+        maxSize, hllBuckets, allocator);
+  }
+
+  // Validate remaining size.
+  size_t expectedRemainingSize =
+      minhashSize * (sizeof(int32_t) + sizeof(int64_t)) + totalHllSize;
+  size_t remainingSize = size - stream.offset();
+  VELOX_RETURN_UNEXPECTED_IF(
+      remainingSize < expectedRemainingSize,
+      Status::UserError(
+          "Invalid KHyperLogLog data: insufficient data for minhash and HLLs"));
+
+  // Read HLL sizes.
+  std::vector<int32_t> hllSizes(minhashSize);
+  stream.copyTo(hllSizes.data(), minhashSize);
+
+  // Read keys.
+  std::vector<int64_t> keys(minhashSize);
+  stream.copyTo(keys.data(), minhashSize);
+
+  // Create KHyperLogLog instance.
+  auto result = std::make_unique<KHyperLogLog<TUii, TAllocator>>(
+      maxSize, hllBuckets, allocator);
+
+  // Deserialize HLLs.
+  const char* hllData = data + stream.offset();
+  remainingSize = size - stream.offset();
+
+  size_t sumOfHllSizes = 0;
+  for (int32_t hllSize : hllSizes) {
+    sumOfHllSizes += hllSize;
+  }
+
+  VELOX_RETURN_UNEXPECTED_IF(
+      remainingSize < sumOfHllSizes,
+      Status::UserError(
+          "Invalid KHyperLogLog data: insufficient data for HLLs"));
+
+  for (int32_t i = 0; i < minhashSize; ++i) {
+    int32_t hllSize = hllSizes[i];
+    int64_t key = keys[i];
+
+    auto hll =
+        HllAccumulator<TUii, true, TAllocator>::deserialize(hllData, allocator);
+    result->increaseTotalHllSize(*hll);
+    result->minhash_.emplace(key, std::move(*hll));
+
+    hllData += hllSize;
+    remainingSize -= hllSize;
+  }
+
+  return result;
+}
+
+template <typename TUii, typename TAllocator>
+void KHyperLogLog<TUii, TAllocator>::serialize(char* outputBuffer) {
+  OutputByteStream stream(outputBuffer);
+
+  // Write version.
+  stream.appendOne<uint8_t>(detail::kVersionByte);
+
+  // Write header.
+  stream.appendOne<int32_t>(maxSize_);
+  stream.appendOne<int32_t>(hllBuckets_);
+  stream.appendOne<int32_t>(static_cast<int32_t>(minhash_.size()));
+
+  // Write the sum of all HLL sizes.
+  int32_t totalHllSize = 0;
+  for (auto& [key, hll] : minhash_) {
+    totalHllSize += hll.serializedSize();
+  }
+  stream.appendOne<int32_t>(totalHllSize);
+
+  // Write HLL sizes in sorted key order. minHash_ is a sorted map, so no
+  // additional sorting is necessary for deterministic serialization.
+  int32_t maxSerializedSize = 0;
+  for (auto& [key, hll] : minhash_) {
+    int32_t hllSerializedSize = hll.serializedSize();
+    stream.appendOne<int32_t>(hllSerializedSize);
+    maxSerializedSize = std::max(maxSerializedSize, hllSerializedSize);
+  }
+
+  // Write keys in sorted order.
+  for (const auto& [key, hll] : minhash_) {
+    stream.appendOne<int64_t>(key);
+  }
+
+  // Write serialized HLLs in sorted key order.
+  std::string hllBuffer(maxSerializedSize, '\0');
+  for (auto& [key, hll] : minhash_) {
+    const_cast<HllAccumulator<TUii, true, TAllocator>&>(hll).serialize(
+        hllBuffer.data());
+    stream.append(hllBuffer.data(), hll.serializedSize());
+  }
+}
+
+template <typename TUii, typename TAllocator>
+size_t KHyperLogLog<TUii, TAllocator>::estimatedSerializedSize() const {
+  return detail::kHeaderSize + // header: version, maxSize, hllBuckets,
+                               // minhashSize, totalHllSize
+      minhash_.size() * sizeof(int32_t) + // individual HLL sizes +
+      minhash_.size() * sizeof(int64_t) + // minhash keys +
+      hllsTotalEstimatedSerializedSize_; // sum of all HLL serialized sizes
+}
+
+template <typename TUii, typename TAllocator>
+template <typename TJoinKey>
+void KHyperLogLog<TUii, TAllocator>::add(TJoinKey joinKey, TUii uii) {
+  update(detail::hashKey(joinKey), uii);
+}
+
+template <typename TUii, typename TAllocator>
+void KHyperLogLog<TUii, TAllocator>::update(int64_t hash, TUii uii) {
+  auto it = minhash_.end();
+  if (!(isExact() || (minhash_.size() > 0 && hash < maxKey()) ||
+        ((it = minhash_.find(hash)) != minhash_.end()))) {
+    return;
+  }
+
+  // Get or create HLL for this hash.
+  HllAccumulator<TUii, true, TAllocator>* hll;
+  if (it == minhash_.end()) {
+    auto [iterator, inserted] = minhash_.emplace(
+        hash,
+        HllAccumulator<TUii, true, TAllocator>(indexBitLength_, allocator_));
+    hll = &iterator->second;
+  } else {
+    hll = &it->second;
+    decreaseTotalHllSize(*hll);
+  }
+
+  hll->append(uii);
+
+  increaseTotalHllSize(*hll);
+  removeOverflowEntries();
+}
+
+template <typename TUii, typename TAllocator>
+int64_t KHyperLogLog<TUii, TAllocator>::cardinality() const {
+  if (isExact()) {
+    return static_cast<int64_t>(minhash_.size());
+  }
+
+  // Estimate cardinality by calculating the average spacing (density) between
+  // stored hash values, then extrapolating to the full hash space.
+  // The hash range is the full 64-bit hash range (2^64) which does not fit in a
+  // double, so both the hash range and the density are halved to keep
+  // proportions mathematically correct. The "-1" is a statistical bias
+  // correction from "On Synopses for Distinct-Value Estimation Under Multiset
+  // Operations" by Beyer et. al.
+  // Use unsigned arithmetic to avoid overflow for large maxKey values.
+  uint64_t hashesRange =
+      static_cast<uint64_t>(maxKey()) - static_cast<uint64_t>(INT64_MIN);
+  double halfDensity =
+      static_cast<double>(hashesRange) / (minhash_.size() - 1) / 2.0;
+  return static_cast<int64_t>(
+      static_cast<double>(detail::kHashOutputHalfRange) / halfDensity);
+}
+
+template <typename TUii, typename TAllocator>
+bool KHyperLogLog<TUii, TAllocator>::isExact() const {
+  return static_cast<int32_t>(minhash_.size()) < maxSize_;
+}
+
+template <typename TUii, typename TAllocator>
+size_t KHyperLogLog<TUii, TAllocator>::minhashSize() const {
+  return minhash_.size();
+}
+
+template <typename TUii, typename TAllocator>
+int64_t KHyperLogLog<TUii, TAllocator>::exactIntersectionCardinality(
+    const KHyperLogLog<TUii, TAllocator>& left,
+    const KHyperLogLog<TUii, TAllocator>& right) {
+  VELOX_CHECK(
+      left.isExact(),
+      "exactIntersectionCardinality cannot operate on approximate sets");
+  VELOX_CHECK(
+      right.isExact(),
+      "exactIntersectionCardinality cannot operate on approximate sets");
+
+  // Optimize by iterating through the smaller map and checking the larger one.
+  const auto& smaller = left.minhash_.size() <= right.minhash_.size()
+      ? left.minhash_
+      : right.minhash_;
+  const auto& larger = left.minhash_.size() <= right.minhash_.size()
+      ? right.minhash_
+      : left.minhash_;
+
+  // Count intersection of keys.
+  int64_t intersectionCnt = 0;
+  for (const auto& [key, hll] : smaller) {
+    if (larger.contains(key)) {
+      intersectionCnt++;
+    }
+  }
+
+  return intersectionCnt;
+}
+
+template <typename TUii, typename TAllocator>
+double KHyperLogLog<TUii, TAllocator>::jaccardIndex(
+    const KHyperLogLog<TUii, TAllocator>& left,
+    const KHyperLogLog<TUii, TAllocator>& right) {
+  if (left.minhash_.empty() && right.minhash_.empty()) {
+    return 1.0;
+  }
+  auto smallerSize = std::min(left.minhash_.size(), right.minhash_.size());
+
+  if (smallerSize == 0) {
+    return 0.0;
+  }
+
+  auto itA = left.minhash_.begin();
+  auto itB = right.minhash_.begin();
+
+  auto intersectionCnt = 0;
+  auto unionCnt = 0;
+
+  // Merge the two sorted sequences, counting intersection along the way.
+  while (itA != left.minhash_.end() && itB != right.minhash_.end() &&
+         unionCnt < smallerSize) {
+    if (itA->first < itB->first) {
+      ++itA;
+    } else if (itB->first < itA->first) {
+      ++itB;
+    } else {
+      intersectionCnt++;
+      ++itA;
+      ++itB;
+    }
+    unionCnt++;
+  }
+
+  return static_cast<double>(intersectionCnt) / smallerSize;
+}
+
+template <typename TUii, typename TAllocator>
+std::unique_ptr<KHyperLogLog<TUii, TAllocator>>
+KHyperLogLog<TUii, TAllocator>::merge(
+    std::unique_ptr<KHyperLogLog<TUii, TAllocator>> left,
+    std::unique_ptr<KHyperLogLog<TUii, TAllocator>> right) {
+  // The KHLL with the smaller K will be used as base. This is because if a KHLL
+  // with a smaller K is merged into a KHLL with a larger K, the smaller KHLL's
+  // minhash will not cover all of the larger minhash's range. Instead, we want
+  // to keep only the smallest K number of HLLs in the new KHLL.
+  if (left->maxSize_ <= right->maxSize_) {
+    left->mergeWith(*right);
+    return std::move(left);
+  } else {
+    right->mergeWith(*left);
+    return std::move(right);
+  }
+}
+
+template <typename TUii, typename TAllocator>
+void KHyperLogLog<TUii, TAllocator>::mergeWith(
+    const KHyperLogLog<TUii, TAllocator>& other) {
+  for (const auto& [key, otherHll] : other.minhash_) {
+    auto it = minhash_.find(key);
+    if (it != minhash_.end()) {
+      decreaseTotalHllSize(it->second);
+      it->second.mergeWith(otherHll);
+      increaseTotalHllSize(it->second);
+    } else {
+      HllAccumulator<TUii, true, TAllocator> newHll(
+          indexBitLength_, allocator_);
+      newHll.mergeWith(otherHll);
+      increaseTotalHllSize(newHll);
+      minhash_.emplace(key, std::move(newHll));
+    }
+  }
+
+  removeOverflowEntries();
+}
+
+template <typename TUii, typename TAllocator>
+double KHyperLogLog<TUii, TAllocator>::reidentificationPotential(
+    int64_t threshold) const {
+  if (minhash_.empty()) {
+    return 0.0;
+  }
+  int64_t highlyUniqueValues = 0;
+
+  for (const auto& [key, hll] : minhash_) {
+    if (hll.cardinality() <= threshold) {
+      highlyUniqueValues++;
+    }
+  }
+
+  return static_cast<double>(highlyUniqueValues) / minhash_.size();
+}
+
+template <typename TUii, typename TAllocator>
+folly::F14FastMap<int64_t, double>
+KHyperLogLog<TUii, TAllocator>::uniquenessDistribution(
+    int64_t histogramSize) const {
+  folly::F14FastMap<int64_t, double> out;
+
+  for (int64_t i = 1; i <= histogramSize; ++i) {
+    out[i] = 0.0;
+  }
+
+  int64_t size = minhash_.size();
+  if (size == 0) {
+    return out;
+  }
+
+  double bucketScale = 1.0 / static_cast<double>(size);
+  for (const auto& [key, hll] : minhash_) {
+    int64_t cardinality = hll.cardinality();
+    int64_t bucket = std::min(cardinality, histogramSize);
+    out[bucket] += bucketScale;
+  }
+
+  return out;
+}
+
+template <typename TUii, typename TAllocator>
+void KHyperLogLog<TUii, TAllocator>::removeOverflowEntries() {
+  while (static_cast<int32_t>(minhash_.size()) > maxSize_) {
+    auto maxIt = std::prev(minhash_.end());
+    if (maxIt != minhash_.end()) {
+      decreaseTotalHllSize(maxIt->second);
+      minhash_.erase(maxIt);
+    }
+  }
+}
+
+template <typename TUii, typename TAllocator>
+void KHyperLogLog<TUii, TAllocator>::increaseTotalHllSize(
+    HllAccumulator<TUii, true, TAllocator>& hll) {
+  hllsTotalEstimatedSerializedSize_ += hll.serializedSize();
+}
+
+template <typename TUii, typename TAllocator>
+void KHyperLogLog<TUii, TAllocator>::decreaseTotalHllSize(
+    HllAccumulator<TUii, true, TAllocator>& hll) {
+  hllsTotalEstimatedSerializedSize_ -= hll.serializedSize();
+}
+
+} // namespace facebook::velox::common::hll
diff --git a/velox/functions/lib/LambdaFunctionUtil.h b/velox/functions/lib/LambdaFunctionUtil.h
index dd1d3227aa0..f355decb897 100644
--- a/velox/functions/lib/LambdaFunctionUtil.h
+++ b/velox/functions/lib/LambdaFunctionUtil.h
@@ -13,6 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#pragma once
+
+#include "velox/expression/EvalCtx.h"
+#include "velox/functions/lib/RowsTranslationUtil.h"
 #include "velox/vector/ComplexVector.h"
 #include "velox/vector/DecodedVector.h"
 #include "velox/vector/FunctionVector.h"
@@ -98,4 +102,51 @@ MapVectorPtr flattenMap(
 BufferPtr addNullsForUnselectedRows(
     const VectorPtr& vector,
     const SelectivityVector& rows);
+
+/// Applies a lambda function to all elements of an array or map container.
+/// This is a common pattern used by transform, filter, and similar functions.
+///
+/// @tparam ContainerType Either ArrayVector or MapVector.
+///
+/// @param functionArg The VectorPtr containing the lambda function.
+/// @param rows The top-level rows to process.
+/// @param numElements The total number of elements across all containers.
+/// @param flatContainer The flattened container vector.
+/// @param lambdaArgs The arguments to pass to the lambda function.
+/// @param validRowsInReusedResult SelectivityVector indicating which element
+///        rows are valid in the reused result.
+/// @param context The evaluation context.
+/// @param outputElements Output parameter for the transformed elements.
+template <typename ContainerType>
+void applyLambdaToElements(
+    const VectorPtr& functionArg,
+    const SelectivityVector& rows,
+    vector_size_t numElements,
+    const std::shared_ptr<ContainerType>& flatContainer,
+    const std::vector<VectorPtr>& lambdaArgs,
+    SelectivityVector& validRowsInReusedResult,
+    exec::EvalCtx& context,
+    VectorPtr& outputElements) {
+  auto elementToTopLevelRows = getElementToTopLevelRows(
+      numElements, rows, flatContainer.get(), context.pool());
+
+  // Loop over lambda functions and apply these to elements of the container.
+  auto it = functionArg->asUnchecked<FunctionVector>()->iterator(&rows);
+  while (auto entry = it.next()) {
+    auto elementRows = toElementRows<ContainerType>(
+        numElements, *entry.rows, flatContainer.get());
+    auto wrapCapture = toWrapCapture<ContainerType>(
+        numElements, entry.callable, *entry.rows, flatContainer);
+
+    entry.callable->apply(
+        elementRows,
+        &validRowsInReusedResult,
+        wrapCapture,
+        &context,
+        lambdaArgs,
+        elementToTopLevelRows,
+        &outputElements);
+  }
+}
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/lib/MakeRowFromMap.h b/velox/functions/lib/MakeRowFromMap.h
new file mode 100644
index 00000000000..8b90aa2a25e
--- /dev/null
+++ b/velox/functions/lib/MakeRowFromMap.h
@@ -0,0 +1,314 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/expression/EvalCtx.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/DecodedVector.h"
+#include "velox/vector/SimpleVector.h"
+
+namespace facebook::velox::functions {
+
+// Used to create a vector of a given type with default values. For primitive
+// types, it will be set to the c++ default, like 0 for INTEGER and empty string
+// for VARCHAR. For Array/Map they will be set to an empty array or map. Not
+// supported for ROW or UNKNOWN types.
+class MakeRowFromMapDefaults {
+ public:
+  // Returns a vector with flat encoding of the given type and size with default
+  // values. Optionally accepts a vector pool to enable recycling of vectors.
+  static VectorPtr createFlat(
+      const TypePtr& type,
+      const vector_size_t size,
+      memory::MemoryPool& pool,
+      VectorPool* vectorPool) {
+    VectorPtr result = vectorPool ? vectorPool->get(type, size)
+                                  : BaseVector::create(type, size, &pool);
+    VELOX_DYNAMIC_TYPE_DISPATCH_ALL(fillWithDefaultValue, type->kind(), result);
+    return result;
+  }
+
+  // Returns a vector with constant encoding of the given type and size with
+  // default values.
+  static VectorPtr createConstant(
+      const TypePtr& type,
+      const vector_size_t size,
+      memory::MemoryPool& pool) {
+    VectorPtr result = velox::BaseVector::create(type, 1, &pool);
+    VELOX_DYNAMIC_TYPE_DISPATCH_ALL(fillWithDefaultValue, type->kind(), result);
+    result = velox::BaseVector::wrapInConstant(size, 0, result);
+    return result;
+  }
+
+ private:
+  template <TypeKind ValueKind>
+  static void fillWithDefaultValue(VectorPtr& vector) {
+    VELOX_CHECK_NOT_NULL(vector);
+    if constexpr (
+        (TypeTraits<ValueKind>::isPrimitiveType ||
+         ValueKind == TypeKind::OPAQUE) &&
+        ValueKind != TypeKind::UNKNOWN) {
+      using T = typename TypeTraits<ValueKind>::NativeType;
+      VELOX_CHECK(vector->isFlatEncoding());
+      auto* rawValues = vector->asFlatVector<T>()->mutableRawValues();
+      std::fill(rawValues, rawValues + vector->size(), T());
+    } else if constexpr (
+        ValueKind == TypeKind::ARRAY || ValueKind == TypeKind::MAP) {
+      auto vectorSize = vector->size();
+      auto arrayBaseVector = vector->asChecked<ArrayVectorBase>();
+      VELOX_CHECK_NOT_NULL(arrayBaseVector);
+      auto* rawOffsets = arrayBaseVector->mutableOffsets(vectorSize)
+                             ->asMutable<vector_size_t>();
+      auto* rawSizes =
+          arrayBaseVector->mutableSizes(vectorSize)->asMutable<vector_size_t>();
+      std::fill(rawOffsets, rawOffsets + vectorSize, 0);
+      std::fill(rawSizes, rawSizes + vectorSize, 0);
+    } else {
+      VELOX_USER_FAIL(
+          "Unsupported type for replacing nulls: {}",
+          vector->type()->toString());
+    }
+  }
+};
+
+struct MakeRowFromMapOptions {
+  /// The list of keys to extract from each map. The type should be the same
+  /// as the key type in the map and the typeKind template specified when
+  /// creating MakeRowFromMap object. Should be the same size as
+  /// 'outputFieldNames'. Cannot be empty or null.
+  VectorPtr keysToProject;
+
+  /// The names to assign to the corresponding fields in the output RowVector.
+  ///  The i-th key in 'keysToProject' will be mapped to the i-th field name and
+  ///  therefore it should be the same size as 'keysToProject'. Cannot contain
+  ///  empty or duplicate entries.
+  std::vector<std::string> outputFieldNames;
+
+  /// When set to false, if the map is null, a key is missing, or the
+  /// value is null, the output field will also be null.
+  /// If set to true, replaces null output values with type-specific defaults
+  /// like for primitive types, they will be set to the c++ default
+  /// initialized value, like 0 for INTEGER and empty string for VARCHAR. For
+  /// Array/Map they will be set to an empty array or map. Not supported for
+  /// ROW or UNKNOWN types.
+  bool replaceNulls{false};
+
+  /// Only valid if replaceNulls is false. If set to true, a null map will
+  /// result in a null row in the output. Otherwise, the top level row will
+  /// not be null but every field in the output row will be null.
+  bool allowTopLevelNulls{false};
+
+  /// If true, duplicate keys are allowed and the last value is used.
+  bool throwOnDuplicateKeys{true};
+};
+
+///  A utility class for projecting specific keys from a vector of MAP type
+///  (which may be encoded) into a RowVector with named fields corresponding to
+///  each projected key. For each active row, it extracts the values
+///  corresponding to the specified keys and assigns them to their respective
+///  fields in an output RowVector. The output RowVector contains one field for
+///  each specified key, and its size will be equal to the last active row in
+///  the selectivity vector. It optionally accepts an exec::EvalCtx object
+///  pointer for use within Vector Functions. This allows it to leverage the
+///  vector and decodedVector pool within that context and apply per-row error
+///  handling as required by expression evaluation.
+///
+///  Note:
+/// - Only keys of types SMALLINT, INTEGER, and BIGINT are currently
+/// supported. TODO: Support other key types
+/// (https://github.com/facebookincubator/velox/issues/14790)
+/// - Rows marked as inactive in the 'rows' selectivity vector will result in
+/// valid rows in the output; however, no guarantees are made regarding their
+/// assigned values.
+template <TypeKind KeyKind>
+class MakeRowFromMap {
+  using KeyType = typename TypeTraits<KeyKind>::NativeType;
+
+ public:
+  MakeRowFromMap(const MakeRowFromMapOptions& options)
+      : replaceNulls_(options.replaceNulls),
+        allowTopLevelNulls_(options.allowTopLevelNulls),
+        throwOnDuplicateKeys_(options.throwOnDuplicateKeys),
+        outputFieldNames_(options.outputFieldNames),
+        inputKeyType_(options.keysToProject->type()) {
+    VELOX_USER_CHECK_NOT_NULL(options.keysToProject);
+    VELOX_USER_CHECK_GT(
+        options.keysToProject->size(), 0, "Keys to project cannot be empty");
+    VELOX_USER_CHECK_EQ(
+        options.keysToProject->size(),
+        options.outputFieldNames.size(),
+        "Number of keys to project and output field names must be the same");
+    ensureValidFieldNames(options.outputFieldNames);
+
+    VELOX_USER_CHECK_EQ(
+        KeyKind, inputKeyType_->kind(), "Unexptected key TypeKind");
+    if (inputKeyType_ != SMALLINT() && inputKeyType_ != INTEGER() &&
+        inputKeyType_ != BIGINT()) {
+      VELOX_NYI(
+          "Only SMALLINT, INTEGER, BIGINT keys are currently supported, instead got {}",
+          inputKeyType_->toString());
+    }
+    createKeyToFieldIndexMap(options.keysToProject);
+  }
+
+  VectorPtr apply(
+      const BaseVector& map,
+      const SelectivityVector& rows,
+      exec::EvalCtx* evalCtx) {
+    VELOX_USER_CHECK_EQ(
+        map.type()->kind(), TypeKind::MAP, "Input must be of MAP typeKind");
+
+    // Ensure that the key type from the map and type of keysToProject is the
+    // same.
+    const auto& keyType = map.type()->asMap().keyType();
+    VELOX_USER_CHECK_EQ(
+        keyType,
+        inputKeyType_,
+        "Map key type and the type of keys to project are not the same");
+
+    return toRowVectorImpl(map, rows, evalCtx);
+  }
+
+ private:
+  void createKeyToFieldIndexMap(const VectorPtr& keysToProject) {
+    keyToIndex_.reserve(keysToProject->size());
+    auto keysToProjectVec = keysToProject->template as<SimpleVector<KeyType>>();
+    for (size_t i = 0; i < keysToProjectVec->size(); ++i) {
+      VELOX_USER_CHECK(
+          !keysToProjectVec->isNullAt(i),
+          "Keys to project cannot contain null");
+      auto key = keysToProjectVec->valueAt(i);
+      bool ok = keyToIndex_.insert({key, i}).second;
+      // Key must be unique.
+      VELOX_USER_CHECK(ok, "Duplicate keys cannot be projected: {}", key);
+    }
+  }
+
+  VectorPtr toRowVectorImpl(
+      const BaseVector& vector,
+      const SelectivityVector& rows,
+      exec::EvalCtx* evalCtx) {
+    exec::LocalDecodedVector decodedMap(evalCtx);
+    decodedMap.get()->decode(vector, rows);
+    auto mapBase = decodedMap->base()->asUnchecked<MapVector>();
+    exec::LocalDecodedVector decodedKeys(evalCtx);
+    decodedKeys.get()->decode(*mapBase->mapKeys());
+    exec::LocalDecodedVector decodedValues(evalCtx);
+    decodedValues.get()->decode(*mapBase->mapValues());
+    auto valueType = mapBase->mapValues()->type();
+    auto* offsets = mapBase->rawOffsets();
+    auto* sizes = mapBase->rawSizes();
+    auto outputSize = rows.end();
+
+    std::vector<VectorPtr> children;
+    children.reserve(keyToIndex_.size());
+    auto vectorPool = evalCtx ? evalCtx->vectorPool() : nullptr;
+    for (size_t i = 0; i < keyToIndex_.size(); ++i) {
+      if (replaceNulls_) {
+        children.push_back(
+            MakeRowFromMapDefaults::createFlat(
+                valueType, outputSize, *mapBase->pool(), vectorPool));
+      } else {
+        children.push_back(
+            vectorPool
+                ? vectorPool->get(valueType, outputSize)
+                : BaseVector::create(valueType, outputSize, mapBase->pool()));
+        auto rawNulls = children.back()->mutableRawNulls();
+        bits::fillBits(rawNulls, 0, outputSize, bits::kNull);
+      }
+    }
+    auto outputNulls =
+        (!replaceNulls_ && allowTopLevelNulls_ && decodedMap->mayHaveNulls())
+        ? allocateNulls(outputSize, mapBase->pool(), bits::kNotNull)
+        : nullptr;
+    auto* rawNulls =
+        outputNulls ? outputNulls->template asMutable<uint64_t>() : nullptr;
+    std::vector<bool> visited(keyToIndex_.size());
+    std::vector<std::vector<BaseVector::CopyRange>> copyRangesFromBase(
+        keyToIndex_.size());
+    rows.applyToSelected([&](vector_size_t row) INLINE_LAMBDA {
+      std::fill(visited.begin(), visited.end(), false);
+      if (!decodedMap->isNullAt(row)) {
+        auto decodedIndex = decodedMap->index(row);
+        auto offset = offsets[decodedIndex];
+        auto size = sizes[decodedIndex];
+        for (auto i = offset; i < offset + size; ++i) {
+          if (decodedKeys->isNullAt(i) || decodedValues->isNullAt(i)) {
+            continue;
+          }
+          auto key = decodedKeys->valueAt<KeyType>(i);
+          auto it = keyToIndex_.find(key);
+          if (it == keyToIndex_.end()) {
+            continue;
+          }
+          auto index = it->second;
+          if (visited[index]) {
+            if (throwOnDuplicateKeys_) {
+              if (evalCtx) {
+                evalCtx->setStatus(
+                    row,
+                    Status::UserError(
+                        fmt::format("Duplicate keys not allowed: {}", key)));
+              } else {
+                VELOX_USER_FAIL("Duplicate keys not allowed: {}", key);
+              }
+              return;
+            }
+            VELOX_CHECK(!copyRangesFromBase[index].empty());
+            VELOX_CHECK_EQ(copyRangesFromBase[index].back().targetIndex, row);
+            copyRangesFromBase[index].back().sourceIndex =
+                decodedValues->index(i);
+          } else {
+            visited[index] = true;
+            copyRangesFromBase[index].push_back(
+                {decodedValues->index(i), row, 1});
+          }
+        }
+      } else if (rawNulls) {
+        bits::setNull(rawNulls, row, true);
+      }
+    });
+    for (size_t i = 0; i < children.size(); ++i) {
+      children[i]->copyRanges(decodedValues->base(), copyRangesFromBase[i]);
+    }
+
+    return std::make_shared<RowVector>(
+        vector.pool(),
+        ROW(outputFieldNames_, valueType),
+        std::move(outputNulls),
+        outputSize,
+        std::move(children));
+  }
+
+  void ensureValidFieldNames(const std::vector<std::string>& fieldNames) {
+    std::unordered_set<std::string> fieldNamesSet;
+    for (const auto& fieldName : fieldNames) {
+      VELOX_USER_CHECK(!fieldName.empty(), "Field name cannot be empty");
+      auto ok = fieldNamesSet.insert(fieldName).second;
+      VELOX_USER_CHECK(
+          ok, "Duplicate field names are not allowed: {}", fieldName);
+    }
+  }
+
+  const bool replaceNulls_{false};
+  const bool allowTopLevelNulls_{false};
+  const bool throwOnDuplicateKeys_{true};
+  const std::vector<std::string> outputFieldNames_;
+  const TypePtr inputKeyType_;
+  folly::F14FastMap<KeyType, size_t> keyToIndex_;
+};
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/MapConcat.cpp b/velox/functions/lib/MapConcat.cpp
index 25450df92b7..a096d759d50 100644
--- a/velox/functions/lib/MapConcat.cpp
+++ b/velox/functions/lib/MapConcat.cpp
@@ -16,15 +16,17 @@
 #include "velox/functions/lib/MapConcat.h"
 #include "velox/expression/DecodedArgs.h"
 #include "velox/expression/VectorFunction.h"
-#include "velox/vector/TypeAliases.h"
+#include "velox/vector/MapConcat.h"
 
 namespace facebook::velox::functions {
 namespace {
 
 // See documentation at https://prestodb.io/docs/current/functions/map.html
-template <bool EmptyForNull, bool AllowSingleArg>
 class MapConcatFunction : public exec::VectorFunction {
  public:
+  MapConcatFunction(bool emptyForNull, bool allowSingleArg)
+      : emptyForNull_(emptyForNull), allowSingleArg_(allowSingleArg) {}
+
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -39,135 +41,55 @@ class MapConcatFunction : public exec::VectorFunction {
     }
     VELOX_CHECK(mapType->kindEquals(outputType));
 
-    const size_t numArgs = args.size();
-    if constexpr (!AllowSingleArg) {
+    const auto numArgs = static_cast<int>(args.size());
+    if (!allowSingleArg_) {
       VELOX_CHECK_GE(numArgs, 2);
     }
 
     exec::DecodedArgs decodedArgs(rows, args, context);
-    vector_size_t maxSize = 0;
-    for (int i = 0; i < numArgs; i++) {
-      const DecodedVector* decodedArg = decodedArgs.at(i);
-      const MapVector* inputMap = decodedArg->base()->as<MapVector>();
-      const vector_size_t* rawSizes = inputMap->rawSizes();
-      rows.applyToSelected([&](vector_size_t row) {
-        if (EmptyForNull && decodedArg->isNullAt(row)) {
-          return;
-        }
-        maxSize += rawSizes[decodedArg->index(row)];
-      });
-    }
-
-    const TypePtr& keyType = outputType->asMap().keyType();
-    const TypePtr& valueType = outputType->asMap().valueType();
-
-    memory::MemoryPool* pool = context.pool();
-    auto combinedKeys = BaseVector::create(keyType, maxSize, pool);
-    auto combinedValues = BaseVector::create(valueType, maxSize, pool);
-
-    // Initialize offsets and sizes to 0 so that canonicalize() will
-    // work also for sparse 'rows'.
-    BufferPtr offsets = allocateOffsets(rows.end(), pool);
-    int* rawOffsets = offsets->asMutable<vector_size_t>();
-
-    BufferPtr sizes = allocateSizes(rows.end(), pool);
-    int* rawSizes = sizes->asMutable<vector_size_t>();
 
-    vector_size_t offset = 0;
-    rows.applyToSelected([&](vector_size_t row) {
-      rawOffsets[row] = offset;
-      // Reuse the last offset and size if null key must create empty map
-      for (int i = 0; i < numArgs; i++) {
-        const DecodedVector* decodedArg = decodedArgs.at(i);
-        if (EmptyForNull && decodedArg->isNullAt(row)) {
-          continue; // Treat NULL maps as empty.
-        }
-        const MapVector* inputMap = decodedArg->base()->as<MapVector>();
-        const vector_size_t index = decodedArg->index(row);
-        const vector_size_t inputOffset = inputMap->offsetAt(index);
-        const vector_size_t inputSize = inputMap->sizeAt(index);
-        combinedKeys->copy(
-            inputMap->mapKeys().get(), offset, inputOffset, inputSize);
-        combinedValues->copy(
-            inputMap->mapValues().get(), offset, inputOffset, inputSize);
-        offset += inputSize;
+    // UNKNOWN key type means all maps must be empty.
+    if (outputType->asMap().keyType()->kind() == TypeKind::UNKNOWN) {
+      for (auto i = 0; i < numArgs; ++i) {
+        auto* decoded = decodedArgs.at(i);
+        auto* map = decoded->base()->as<MapVector>();
+        rows.applyToSelected([&](vector_size_t row) {
+          VELOX_CHECK_EQ(
+              map->sizeAt(decoded->index(row)),
+              0,
+              "Map with UNKNOWN key type must be empty");
+        });
       }
-      rawSizes[row] = offset - rawOffsets[row];
-    });
-
-    auto combinedMap = std::make_shared<MapVector>(
-        pool,
-        outputType,
-        BufferPtr(nullptr),
-        rows.end(),
-        offsets,
-        sizes,
-        combinedKeys,
-        combinedValues);
-
-    MapVector::canonicalize(combinedMap, true);
+      auto emptyMap = std::make_shared<MapVector>(
+          context.pool(),
+          outputType,
+          BufferPtr(nullptr),
+          1,
+          allocateOffsets(1, context.pool()),
+          allocateSizes(1, context.pool()),
+          BaseVector::create(outputType->asMap().keyType(), 0, context.pool()),
+          BaseVector::create(
+              outputType->asMap().valueType(), 0, context.pool()));
+      auto constant = BaseVector::wrapInConstant(rows.end(), 0, emptyMap);
+      context.moveOrCopyResult(constant, rows, result);
+      return;
+    }
 
-    combinedKeys = combinedMap->mapKeys();
-    combinedValues = combinedMap->mapValues();
+    std::vector<DecodedVector*> inputs;
+    inputs.reserve(numArgs);
+    for (auto i = 0; i < numArgs; ++i) {
+      inputs.push_back(decodedArgs.at(i));
+    }
 
-    // Check for duplicate keys
-    SelectivityVector uniqueKeys(offset);
-    vector_size_t duplicateCnt = 0;
-    bool throwExceptionOnDuplicateMapKeys = false;
+    MapConcatConfig config;
+    config.emptyForNull = emptyForNull_;
     if (auto* ctx = context.execCtx()->queryCtx()) {
-      throwExceptionOnDuplicateMapKeys =
+      config.throwOnDuplicateKeys =
           ctx->queryConfig().throwExceptionOnDuplicateMapKeys();
     }
-    rows.applyToSelected([&](vector_size_t row) {
-      const int mapOffset = rawOffsets[row];
-      const int mapSize = rawSizes[row];
-      if (duplicateCnt) {
-        rawOffsets[row] -= duplicateCnt;
-      }
-      for (vector_size_t i = 1; i < mapSize; i++) {
-        if (combinedKeys->equalValueAt(
-                combinedKeys.get(), mapOffset + i, mapOffset + i - 1)) {
-          if (throwExceptionOnDuplicateMapKeys) {
-            const auto duplicateKey = combinedKeys->wrappedVector()->toString(
-                combinedKeys->wrappedIndex(mapOffset + i));
-            VELOX_USER_FAIL("Duplicate map key {} was found.", duplicateKey);
-          }
-          duplicateCnt++;
-          // "remove" duplicate entry
-          uniqueKeys.setValid(mapOffset + i - 1, false);
-          rawSizes[row]--;
-        }
-      }
-    });
-
-    if (duplicateCnt) {
-      uniqueKeys.updateBounds();
-      const vector_size_t uniqueCount = uniqueKeys.countSelected();
 
-      BufferPtr uniqueIndices = allocateIndices(uniqueCount, pool);
-      vector_size_t* rawUniqueIndices =
-          uniqueIndices->asMutable<vector_size_t>();
-      vector_size_t index = 0;
-      uniqueKeys.applyToSelected(
-          [&](vector_size_t row) { rawUniqueIndices[index++] = row; });
-
-      VectorPtr keys =
-          BaseVector::transpose(uniqueIndices, std::move(combinedKeys));
-      VectorPtr values =
-          BaseVector::transpose(uniqueIndices, std::move(combinedValues));
-
-      combinedMap = std::make_shared<MapVector>(
-          pool,
-          outputType,
-          BufferPtr(nullptr),
-          rows.end(),
-          offsets,
-          sizes,
-          std::move(keys),
-          std::move(values));
-    }
-
-    context.moveOrCopyResult(combinedMap, rows, result);
+    auto merged = mapConcat(context.pool(), outputType, inputs, rows, config);
+    context.moveOrCopyResult(merged, rows, result);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
@@ -180,37 +102,39 @@ class MapConcatFunction : public exec::VectorFunction {
                 .variableArity("map(K,V)")
                 .build()};
   }
+
+ private:
+  // When true, treat null map inputs as empty maps rather than propagating
+  // null.
+  const bool emptyForNull_;
+
+  // When true, allow a single map argument (Spark semantics).
+  const bool allowSingleArg_;
 };
 } // namespace
 
 void registerMapConcatFunction(const std::string& name) {
   exec::registerVectorFunction(
       name,
-      MapConcatFunction</*EmptyForNull=*/false, /*AllowSingleArg=*/false>::
-          signatures(),
-      std::make_unique<MapConcatFunction<
-          /*EmptyForNull=*/false,
-          /*AllowSingleArg=*/false>>());
+      MapConcatFunction::signatures(),
+      std::make_unique<MapConcatFunction>(
+          /*emptyForNull=*/false, /*allowSingleArg=*/false));
 }
 
 void registerMapConcatAllowSingleArg(const std::string& name) {
   exec::registerVectorFunction(
       name,
-      MapConcatFunction</*EmptyForNull=*/false, /*AllowSingleArg=*/true>::
-          signatures(),
-      std::make_unique<MapConcatFunction<
-          /*EmptyForNull=*/false,
-          /*AllowSingleArg=*/true>>());
+      MapConcatFunction::signatures(),
+      std::make_unique<MapConcatFunction>(
+          /*emptyForNull=*/false, /*allowSingleArg=*/true));
 }
 
 void registerMapConcatEmptyNullsFunction(const std::string& name) {
   exec::registerVectorFunction(
       name,
-      MapConcatFunction</*EmptyForNull=*/true, /*AllowSingleArg=*/false>::
-          signatures(),
-      std::make_unique<MapConcatFunction<
-          /*EmptyForNull=*/true,
-          /*AllowSingleArg=*/false>>(),
+      MapConcatFunction::signatures(),
+      std::make_unique<MapConcatFunction>(
+          /*emptyForNull=*/true, /*allowSingleArg=*/false),
       exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build());
 }
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapFromEntries.cpp b/velox/functions/lib/MapFromEntries.cpp
similarity index 67%
rename from velox/functions/prestosql/MapFromEntries.cpp
rename to velox/functions/lib/MapFromEntries.cpp
index 91e4c260ea3..0b6aef54390 100644
--- a/velox/functions/prestosql/MapFromEntries.cpp
+++ b/velox/functions/lib/MapFromEntries.cpp
@@ -28,9 +28,10 @@ namespace {
 static const char* kNullKeyErrorMessage = "map key cannot be null";
 static const char* kErrorMessageEntryNotNull = "map entry cannot be null";
 
-// See documentation at https://prestodb.io/docs/current/functions/map.html
 class MapFromEntriesFunction : public exec::VectorFunction {
  public:
+  explicit MapFromEntriesFunction(bool throwOnNull)
+      : throwOnNull_(throwOnNull) {}
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -64,23 +65,24 @@ class MapFromEntriesFunction : public exec::VectorFunction {
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
-    return {// unknown -> map(unknown, unknown)
-            exec::FunctionSignatureBuilder()
-                .returnType("map(unknown, unknown)")
-                .argumentType("unknown")
-                .build(),
-            // array(unknown) -> map(unknown, unknown)
-            exec::FunctionSignatureBuilder()
-                .returnType("map(unknown, unknown)")
-                .argumentType("array(unknown)")
-                .build(),
-            // array(row(K,V)) -> map(K,V)
-            exec::FunctionSignatureBuilder()
-                .typeVariable("K")
-                .typeVariable("V")
-                .returnType("map(K,V)")
-                .argumentType("array(row(K,V))")
-                .build()};
+    return {
+        // unknown -> map(unknown, unknown)
+        exec::FunctionSignatureBuilder()
+            .returnType("map(unknown, unknown)")
+            .argumentType("unknown")
+            .build(),
+        // array(unknown) -> map(unknown, unknown)
+        exec::FunctionSignatureBuilder()
+            .returnType("map(unknown, unknown)")
+            .argumentType("array(unknown)")
+            .build(),
+        // array(row(K,V)) -> map(K,V)
+        exec::FunctionSignatureBuilder()
+            .typeVariable("K")
+            .typeVariable("V")
+            .returnType("map(K,V)")
+            .argumentType("array(row(K,V))")
+            .build()};
   }
 
  private:
@@ -92,12 +94,21 @@ class MapFromEntriesFunction : public exec::VectorFunction {
     auto& inputValueVector = inputArray->elements();
     exec::LocalDecodedVector decodedRowVector(context);
     decodedRowVector.get()->decode(*inputValueVector);
-    // If the input array(unknown) then all rows should have errors.
     if (inputValueVector->typeKind() == TypeKind::UNKNOWN) {
-      try {
-        VELOX_USER_FAIL(kErrorMessageEntryNotNull);
-      } catch (...) {
-        context.setErrors(rows, std::current_exception());
+      // For Presto, if the input is array(unknown), rows with non-empty
+      // arrays should have errors since all entries would be null. Empty
+      // arrays produce empty maps without error.
+      if (throwOnNull_) {
+        try {
+          VELOX_USER_FAIL(kErrorMessageEntryNotNull);
+        } catch (...) {
+          auto exceptionPtr = std::current_exception();
+          rows.applyToSelected([&](vector_size_t row) {
+            if (inputArray->sizeAt(row) > 0) {
+              context.setError(row, exceptionPtr);
+            }
+          });
+        }
       }
 
       auto sizes = allocateSizes(rows.end(), context.pool());
@@ -116,7 +127,7 @@ class MapFromEntriesFunction : public exec::VectorFunction {
           BaseVector::create(UNKNOWN(), 0, context.pool()));
     }
 
-    exec::LocalSelectivityVector remianingRows(context, rows);
+    exec::LocalSelectivityVector remainingRows(context, rows);
     auto rowVector = decodedRowVector->base()->as<RowVector>();
     auto keyVector = rowVector->childAt(0);
 
@@ -127,8 +138,9 @@ class MapFromEntriesFunction : public exec::VectorFunction {
     });
 
     auto resetSize = [&](vector_size_t row) { mutableSizes[row] = 0; };
+    auto nulls = allocateNulls(rows.end(), context.pool());
+    auto* mutableNulls = nulls->asMutable<uint64_t>();
 
-    // Validate all map entries and map keys are not null.
     if (decodedRowVector->mayHaveNulls() || keyVector->mayHaveNulls() ||
         keyVector->mayHaveNullsRecursive()) {
       context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
@@ -139,12 +151,16 @@ class MapFromEntriesFunction : public exec::VectorFunction {
           // Check nulls in the top level row vector.
           const bool isMapEntryNull = decodedRowVector->isNullAt(offset + i);
           if (isMapEntryNull) {
-            // Set the sizes to 0 so that the final map vector generated is
-            // valid in case we are inside a try. The map vector needs to be
-            // valid because its consumed by checkDuplicateKeys before try
-            // sets invalid rows to null.
-            resetSize(row);
-            VELOX_USER_FAIL(kErrorMessageEntryNotNull);
+            if (throwOnNull_) {
+              // Set the sizes to 0 so that the final map vector generated is
+              // valid in case we are inside a try. The map vector needs to be
+              // valid because its consumed by checkDuplicateKeys before try
+              // sets invalid rows to null.
+              resetSize(row);
+              VELOX_USER_FAIL(kErrorMessageEntryNotNull);
+            }
+            bits::setNull(mutableNulls, row);
+            break;
           }
 
           // Check null keys.
@@ -157,7 +173,7 @@ class MapFromEntriesFunction : public exec::VectorFunction {
       });
     }
 
-    context.deselectErrors(*remianingRows.get());
+    context.deselectErrors(*remainingRows.get());
 
     VectorPtr wrappedKeys;
     VectorPtr wrappedValues;
@@ -189,8 +205,9 @@ class MapFromEntriesFunction : public exec::VectorFunction {
     } else {
       // Dictionary.
       auto indices = allocateIndices(decodedRowVector->size(), context.pool());
-      auto nulls = allocateNulls(decodedRowVector->size(), context.pool());
-      auto* mutableNulls = nulls->asMutable<uint64_t>();
+      auto rowVectorNulls =
+          allocateNulls(decodedRowVector->size(), context.pool());
+      auto* rowVectorMutableNulls = rowVectorNulls->asMutable<uint64_t>();
       memcpy(
           indices->asMutable<vector_size_t>(),
           decodedRowVector->indices(),
@@ -199,35 +216,51 @@ class MapFromEntriesFunction : public exec::VectorFunction {
       // not guranteed to be addressable at X or Y.
       for (auto i = 0; i < decodedRowVector->size(); i++) {
         if (decodedRowVector->isNullAt(i)) {
-          bits::setNull(mutableNulls, i);
+          bits::setNull(rowVectorMutableNulls, i);
         }
       }
       wrappedKeys = BaseVector::wrapInDictionary(
-          nulls, indices, decodedRowVector->size(), rowVector->childAt(0));
+          rowVectorNulls,
+          indices,
+          decodedRowVector->size(),
+          rowVector->childAt(0));
       wrappedValues = BaseVector::wrapInDictionary(
-          nulls, indices, decodedRowVector->size(), rowVector->childAt(1));
+          rowVectorNulls,
+          indices,
+          decodedRowVector->size(),
+          rowVector->childAt(1));
     }
 
-    // To avoid creating new buffers, we try to reuse the input's buffers
-    // as many as possible.
+    // For Presto, need construct map vector based on input nulls for possible
+    // outer expression like try(). For Spark, use the updated nulls unless it's
+    // empty.
+    if (throwOnNull_ || decodedRowVector->size() == 0) {
+      nulls = inputArray->nulls();
+    }
     auto mapVector = std::make_shared<MapVector>(
         context.pool(),
         outputType,
-        inputArray->nulls(),
+        nulls,
         rows.end(),
         inputArray->offsets(),
         sizes,
         wrappedKeys,
         wrappedValues);
 
-    checkDuplicateKeys(mapVector, *remianingRows, context);
+    checkDuplicateKeys(mapVector, *remainingRows, context);
     return mapVector;
   }
+
+  // If true, throws exception when input is NULL or contains NULL entry
+  // (Presto's behavior). Otherwise, returns NULL (Spark's behavior).
+  const bool throwOnNull_;
 };
 } // namespace
 
-VELOX_DECLARE_VECTOR_FUNCTION(
-    udf_map_from_entries,
-    MapFromEntriesFunction::signatures(),
-    std::make_unique<MapFromEntriesFunction>());
+void registerMapFromEntriesFunction(const std::string& name, bool throwOnNull) {
+  exec::registerVectorFunction(
+      name,
+      MapFromEntriesFunction::signatures(),
+      std::make_unique<MapFromEntriesFunction>(throwOnNull));
+}
 } // namespace facebook::velox::functions
diff --git a/velox/functions/lib/MapFromEntries.h b/velox/functions/lib/MapFromEntries.h
new file mode 100644
index 00000000000..98d8aa5f925
--- /dev/null
+++ b/velox/functions/lib/MapFromEntries.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace facebook::velox::functions {
+
+/// @param throwOnNull If true, throws exception when input array is null or
+/// contains null entry. Otherwise, returns null.
+void registerMapFromEntriesFunction(const std::string& name, bool throwForNull);
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/QuantileDigest.h b/velox/functions/lib/QuantileDigest.h
index 2b117346cf7..cb1a2fe6c00 100644
--- a/velox/functions/lib/QuantileDigest.h
+++ b/velox/functions/lib/QuantileDigest.h
@@ -299,7 +299,7 @@ T read(const char*& input) {
 
 template <typename T>
 void write(T value, char*& out) {
-  folly::storeUnaligned(out, value);
+  folly::storeUnaligned<T>(out, value);
   out += sizeof(T);
 }
 } // namespace detail
@@ -776,8 +776,8 @@ bool QuantileDigest<T, Allocator>::validateDigest() const {
     free.insert(iterator);
     iterator = lefts_[iterator];
   }
-  std::vector<bool, RebindAlloc<unsigned long>> visited(
-      lefts_.size(), false, RebindAlloc<unsigned long>(lefts_.get_allocator()));
+  std::vector<bool, RebindAlloc<bool>> visited(
+      lefts_.size(), false, RebindAlloc<bool>(lefts_.get_allocator()));
 
   // Check that visited nodes are not in the free list and are visited only
   // once.
@@ -1348,10 +1348,6 @@ QuantileDigest<T, Allocator>::getDistributionFunction(T rangeStart, T rangeEnd)
   std::vector<CdfEntry, RebindAlloc<CdfEntry>> cdf(
       RebindAlloc<CdfEntry>(counts_.get_allocator()));
 
-  if (weightedCount_ == 0 || root_ == -1) {
-    return cdf;
-  }
-
   VELOX_USER_CHECK_LE(
       rangeStart,
       rangeEnd,
diff --git a/velox/functions/lib/Re2Functions.cpp b/velox/functions/lib/Re2Functions.cpp
index 0ef97cf3f25..9c896afe20c 100644
--- a/velox/functions/lib/Re2Functions.cpp
+++ b/velox/functions/lib/Re2Functions.cpp
@@ -36,7 +36,7 @@ re2::StringPiece toStringPiece(const T& s) {
 namespace detail {
 
 Expected<RE2*> ReCache::tryFindOrCompile(const StringView& pattern) {
-  const std::string key = pattern;
+  const auto key = std::string(pattern);
 
   auto reIt = cache_.find(key);
   if (reIt != cache_.end()) {
@@ -870,8 +870,9 @@ class LikeWithRe2 final : public exec::VectorFunction {
     VELOX_CHECK(args.size() == 2 || args.size() == 3);
 
     if (!validPattern_) {
-      auto error = std::make_exception_ptr(std::invalid_argument(
-          "Escape character must be followed by '%', '_' or the escape character itself"));
+      auto error = std::make_exception_ptr(
+          std::invalid_argument(
+              "Escape character must be followed by '%', '_' or the escape character itself"));
       context.setErrors(rows, error);
       return;
     }
@@ -942,8 +943,12 @@ class LikeGeneric final : public exec::VectorFunction {
     auto applyRow = [&](const StringView& input,
                         const StringView& pattern,
                         const std::optional<char>& escapeChar) -> bool {
+      // Copy the pattern to a local string to protect against potential
+      // use-after-free if the underlying string buffer is reclaimed by memory
+      // arbitration under memory pressure.
+      std::string patternCopy(pattern.data(), pattern.size());
       PatternMetadata patternMetadata =
-          determinePatternKind(std::string_view(pattern), escapeChar);
+          determinePatternKind(patternCopy, escapeChar);
 
       if (isAscii) {
         switch (patternMetadata.patternKind()) {
@@ -1728,7 +1733,7 @@ std::shared_ptr<exec::VectorFunction> makeRe2Extract(
             groupIdTypeKind == TypeKind::BIGINT,
         "{} requires third argument of type INTEGER or BIGINT, but got {}",
         name,
-        mapTypeKindToName(groupIdTypeKind));
+        TypeKindName::toName(groupIdTypeKind));
   }
 
   BaseVector* constantPattern = inputArgs[1].constantValue.get();
@@ -2160,16 +2165,18 @@ PatternMetadata determinePatternKind(
           return PatternMetadata::prefix(
               std::string(unescapedPattern, 0, firstSubPatternLength));
         } else if (lastSubPatternKind == SubPatternKind::kLiteralString) {
-          return PatternMetadata::suffix(std::string(
-              unescapedPattern, lastSubPatternStart, lastSubPatternLength));
+          return PatternMetadata::suffix(
+              std::string(
+                  unescapedPattern, lastSubPatternStart, lastSubPatternLength));
         } else if (
             numSubPatterns == 3 &&
             firstSubPatternKind == SubPatternKind::kAnyCharsWildcard &&
             lastSubPatternKind == SubPatternKind::kAnyCharsWildcard) {
-          return PatternMetadata::substring(std::string(
-              unescapedPattern,
-              subPatternRanges[1].first,
-              subPatternRanges[1].second));
+          return PatternMetadata::substring(
+              std::string(
+                  unescapedPattern,
+                  subPatternRanges[1].first,
+                  subPatternRanges[1].second));
         }
       }
 
@@ -2379,7 +2386,7 @@ std::shared_ptr<exec::VectorFunction> makeRe2ExtractAll(
             groupIdTypeKind == TypeKind::BIGINT,
         "{} requires third argument of type INTEGER or BIGINT, but got {}",
         name,
-        mapTypeKindToName(groupIdTypeKind));
+        TypeKindName::toName(groupIdTypeKind));
   }
 
   BaseVector* constantPattern = inputArgs[1].constantValue.get();
diff --git a/velox/functions/lib/RegistrationHelpers.h b/velox/functions/lib/RegistrationHelpers.h
index 7b9bc495c5a..fb783e4de10 100644
--- a/velox/functions/lib/RegistrationHelpers.h
+++ b/velox/functions/lib/RegistrationHelpers.h
@@ -28,6 +28,15 @@ void registerBinaryIntegral(const std::vector<std::string>& aliases) {
   registerFunction<T, int64_t, int64_t, int64_t>(aliases);
 }
 
+template <template <class> class T, typename TReturn>
+void registerBinaryIntegralWithTReturn(
+    const std::vector<std::string>& aliases) {
+  registerFunction<T, TReturn, int8_t, int8_t>(aliases);
+  registerFunction<T, TReturn, int16_t, int16_t>(aliases);
+  registerFunction<T, TReturn, int32_t, int32_t>(aliases);
+  registerFunction<T, TReturn, int64_t, int64_t>(aliases);
+}
+
 template <template <class> typename T>
 void registerBinaryFloatingPoint(const std::vector<std::string>& aliases) {
   registerFunction<T, double, double, double>(aliases);
@@ -42,10 +51,7 @@ void registerBinaryNumeric(const std::vector<std::string>& aliases) {
 
 template <template <class> class T, typename TReturn>
 void registerBinaryScalar(const std::vector<std::string>& aliases) {
-  registerFunction<T, TReturn, int8_t, int8_t>(aliases);
-  registerFunction<T, TReturn, int16_t, int16_t>(aliases);
-  registerFunction<T, TReturn, int32_t, int32_t>(aliases);
-  registerFunction<T, TReturn, int64_t, int64_t>(aliases);
+  registerBinaryIntegralWithTReturn<T, TReturn>(aliases);
   registerFunction<T, TReturn, double, double>(aliases);
   registerFunction<T, TReturn, float, float>(aliases);
   registerFunction<T, TReturn, Varchar, Varchar>(aliases);
diff --git a/velox/functions/lib/Repeat.cpp b/velox/functions/lib/Repeat.cpp
index 1ea51b64f94..e1e6cc35172 100644
--- a/velox/functions/lib/Repeat.cpp
+++ b/velox/functions/lib/Repeat.cpp
@@ -66,6 +66,18 @@ class RepeatFunction : public exec::VectorFunction {
     return count;
   }
 
+  static void checkTotalCount(size_t totalCount) {
+    // We could overflow int32 if total count is too large, potentially
+    // causing a small buffer allocation followed by a large write, resulting
+    // in SIGSEGV.
+    VELOX_USER_CHECK_LE(
+        totalCount,
+        std::numeric_limits<vector_size_t>::max(),
+        "REPEAT result too large: {} elements exceeds maximum {}",
+        totalCount,
+        std::numeric_limits<vector_size_t>::max());
+  }
+
   VectorPtr applyConstantCount(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -81,13 +93,15 @@ class RepeatFunction : public exec::VectorFunction {
     }
 
     auto count = constantCount->valueAt(0);
+    size_t totalCount{0};
     try {
       count = checkCount(count, allowNegativeCount_);
+      totalCount = size_t(count) * numRows;
+      checkTotalCount(totalCount);
     } catch (const VeloxUserError&) {
       context.setErrors(rows, std::current_exception());
       return nullptr;
     }
-    const auto totalCount = count * numRows;
 
     // Allocate new vectors for indices, lengths and offsets.
     BufferPtr indices = allocateIndices(totalCount, pool);
@@ -122,7 +136,7 @@ class RepeatFunction : public exec::VectorFunction {
       exec::EvalCtx& context) const {
     exec::DecodedArgs decodedArgs(rows, args, context);
     auto countDecoded = decodedArgs.at(1);
-    int32_t totalCount = 0;
+    size_t totalCount = 0;
 
     context.applyToSelectedNoThrow(rows, [&](auto row) {
       auto count =
@@ -132,6 +146,13 @@ class RepeatFunction : public exec::VectorFunction {
       totalCount += count;
     });
 
+    try {
+      checkTotalCount(totalCount);
+    } catch (const VeloxUserError&) {
+      context.setErrors(rows, std::current_exception());
+      return nullptr;
+    }
+
     const auto numRows = rows.end();
     auto pool = context.pool();
 
diff --git a/velox/functions/lib/SIMDComparisonUtil.h b/velox/functions/lib/SIMDComparisonUtil.h
index bbb325325a9..c205fb1a6ad 100644
--- a/velox/functions/lib/SIMDComparisonUtil.h
+++ b/velox/functions/lib/SIMDComparisonUtil.h
@@ -39,31 +39,38 @@ inline uint64_t to64Bits(const int8_t* resultData) {
       "Unsupported number of scalar elements");
   uint64_t res = 0UL;
   if constexpr (numScalarElements == 64) {
-    res = simd::toBitMask(xsimd::batch_bool<int8_t>(
-        simd::reinterpretBatch<uint8_t>(d_type::load_unaligned(resultData)) !=
-        0));
+    res = simd::toBitMask(
+        xsimd::batch_bool<int8_t>(
+            simd::reinterpretBatch<uint8_t>(
+                d_type::load_unaligned(resultData)) != 0));
   } else if constexpr (numScalarElements == 32) {
     auto* addr = reinterpret_cast<uint32_t*>(&res);
-    *(addr) = simd::toBitMask(xsimd::batch_bool<int8_t>(
-        simd::reinterpretBatch<uint8_t>(d_type::load_unaligned(resultData)) !=
-        0));
-    *(addr + 1) = simd::toBitMask(xsimd::batch_bool<int8_t>(
-        simd::reinterpretBatch<uint8_t>(
-            d_type::load_unaligned(resultData + 32)) != 0));
+    *(addr) = simd::toBitMask(
+        xsimd::batch_bool<int8_t>(
+            simd::reinterpretBatch<uint8_t>(
+                d_type::load_unaligned(resultData)) != 0));
+    *(addr + 1) = simd::toBitMask(
+        xsimd::batch_bool<int8_t>(
+            simd::reinterpretBatch<uint8_t>(
+                d_type::load_unaligned(resultData + 32)) != 0));
   } else if constexpr (numScalarElements == 16) {
     auto* addr = reinterpret_cast<uint16_t*>(&res);
-    *(addr) = simd::toBitMask(xsimd::batch_bool<int8_t>(
-        simd::reinterpretBatch<uint8_t>(d_type::load_unaligned(resultData)) !=
-        0));
-    *(addr + 1) = simd::toBitMask(xsimd::batch_bool<int8_t>(
-        simd::reinterpretBatch<uint8_t>(
-            d_type::load_unaligned(resultData + 16)) != 0));
-    *(addr + 2) = simd::toBitMask(xsimd::batch_bool<int8_t>(
-        simd::reinterpretBatch<uint8_t>(
-            d_type::load_unaligned(resultData + 32)) != 0));
-    *(addr + 3) = simd::toBitMask(xsimd::batch_bool<int8_t>(
-        simd::reinterpretBatch<uint8_t>(
-            d_type::load_unaligned(resultData + 48)) != 0));
+    *(addr) = simd::toBitMask(
+        xsimd::batch_bool<int8_t>(
+            simd::reinterpretBatch<uint8_t>(
+                d_type::load_unaligned(resultData)) != 0));
+    *(addr + 1) = simd::toBitMask(
+        xsimd::batch_bool<int8_t>(
+            simd::reinterpretBatch<uint8_t>(
+                d_type::load_unaligned(resultData + 16)) != 0));
+    *(addr + 2) = simd::toBitMask(
+        xsimd::batch_bool<int8_t>(
+            simd::reinterpretBatch<uint8_t>(
+                d_type::load_unaligned(resultData + 32)) != 0));
+    *(addr + 3) = simd::toBitMask(
+        xsimd::batch_bool<int8_t>(
+            simd::reinterpretBatch<uint8_t>(
+                d_type::load_unaligned(resultData + 48)) != 0));
   }
   return res;
 }
diff --git a/velox/functions/lib/Sequence.cpp b/velox/functions/lib/Sequence.cpp
new file mode 100644
index 00000000000..270ea2c423a
--- /dev/null
+++ b/velox/functions/lib/Sequence.cpp
@@ -0,0 +1,297 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/lib/Sequence.h"
+#include "velox/expression/DecodedArgs.h"
+#include "velox/functions/lib/DateTimeUtil.h"
+
+namespace facebook::velox::functions {
+namespace {
+
+template <typename T>
+int64_t toInt64(T value);
+
+template <>
+int64_t toInt64(int8_t value) {
+  return value;
+}
+
+template <>
+int64_t toInt64(int16_t value) {
+  return value;
+}
+
+template <>
+int64_t toInt64(int32_t value) {
+  return value;
+}
+
+template <>
+int64_t toInt64(int64_t value) {
+  return value;
+}
+
+template <>
+int64_t toInt64(Timestamp value) {
+  return value.toMillis();
+}
+
+using Days = int64_t;
+using Months = int32_t;
+template <typename T, typename K>
+T add(T value, K step, int32_t sequence);
+
+template <>
+int8_t add(int8_t value, int8_t step, int32_t sequence) {
+  const auto delta =
+      static_cast<int128_t>(step) * static_cast<int128_t>(sequence);
+  return value + delta;
+}
+
+template <>
+int16_t add(int16_t value, int16_t step, int32_t sequence) {
+  const auto delta =
+      static_cast<int128_t>(step) * static_cast<int128_t>(sequence);
+  return value + delta;
+}
+
+template <>
+int64_t add(int64_t value, int64_t step, int32_t sequence) {
+  const auto delta =
+      static_cast<int128_t>(step) * static_cast<int128_t>(sequence);
+  // Since step is calculated from start and stop,
+  // the sum of 'value' and 'add' is within int64_t.
+  return value + delta;
+}
+
+template <>
+int32_t add(int32_t value, int64_t step, int32_t sequence) {
+  const auto delta =
+      static_cast<int128_t>(step) * static_cast<int128_t>(sequence);
+  return value + delta;
+}
+
+template <>
+Timestamp add(Timestamp value, int64_t step, int32_t sequence) {
+  const auto delta =
+      static_cast<int128_t>(step) * static_cast<int128_t>(sequence);
+  return Timestamp::fromMillis(value.toMillis() + delta);
+}
+
+template <>
+int32_t add(int32_t value, Months step, int32_t sequence) {
+  return addToDate(value, DateTimeUnit::kMonth, step * sequence);
+}
+
+template <>
+Timestamp add(Timestamp value, Months step, int32_t sequence) {
+  return addToTimestamp(value, DateTimeUnit::kMonth, step * sequence);
+}
+
+template <typename T>
+int128_t getStepCount(T start, T end, int32_t step) {
+  VELOX_FAIL("Unexpected start/end type for argument INTERVAL_YEAR_MONTH");
+}
+
+template <>
+int128_t getStepCount(int32_t start, int32_t end, int32_t step) {
+  return diffDate(DateTimeUnit::kMonth, start, end) / step + 1;
+}
+
+template <>
+int128_t getStepCount(Timestamp start, Timestamp end, int32_t step) {
+  return diffTimestamp(DateTimeUnit::kMonth, start, end) / step + 1;
+}
+
+} // namespace
+
+template <typename T, typename K>
+void SequenceFunction<T, K>::apply(
+    const SelectivityVector& rows,
+    std::vector<VectorPtr>& args,
+    const TypePtr& outputType,
+    exec::EvalCtx& context,
+    VectorPtr& result) const {
+  exec::DecodedArgs decodedArgs(rows, args, context);
+  auto startVector = decodedArgs.at(0);
+  auto stopVector = decodedArgs.at(1);
+  DecodedVector* stepVector = nullptr;
+  bool isIntervalYearMonth = false;
+  if (args.size() == 3) {
+    stepVector = decodedArgs.at(2);
+    isIntervalYearMonth = args[2]->type()->isIntervalYearMonth();
+  }
+
+  const auto numRows = rows.end();
+  auto pool = context.pool();
+  size_t numElements = 0;
+
+  BufferPtr sizes = allocateSizes(numRows, pool);
+  BufferPtr offsets = allocateOffsets(numRows, pool);
+  auto rawSizes = sizes->asMutable<vector_size_t>();
+  auto rawOffsets = offsets->asMutable<vector_size_t>();
+
+  const bool isDate = args[0]->type()->isDate();
+  context.applyToSelectedNoThrow(rows, [&](auto row) {
+    rawSizes[row] = checkArguments(
+        startVector,
+        stopVector,
+        stepVector,
+        row,
+        isDate,
+        isIntervalYearMonth,
+        context.execCtx()
+            ->queryCtx()
+            ->queryConfig()
+            .maxElementsSizeInRepeatAndSequence());
+    numElements += rawSizes[row];
+  });
+
+  // We could overflow int32 if total number of elements is too large,
+  // potentially causing a small buffer allocation followed by a large write,
+  // resulting in SIGSEGV.
+  VELOX_USER_CHECK_LE(
+      numElements,
+      std::numeric_limits<vector_size_t>::max(),
+      "SEQUENCE result too large: {} elements exceeds maximum {}",
+      numElements,
+      std::numeric_limits<vector_size_t>::max());
+
+  VectorPtr elements =
+      BaseVector::create(outputType->childAt(0), numElements, pool);
+  auto rawElements = elements->asFlatVector<T>()->mutableRawValues();
+
+  vector_size_t elementsOffset = 0;
+  context.applyToSelectedNoThrow(rows, [&](auto row) {
+    const auto sequenceCount = rawSizes[row];
+    if (sequenceCount) {
+      rawOffsets[row] = elementsOffset;
+      writeToElements(
+          rawElements + elementsOffset,
+          isDate,
+          isIntervalYearMonth,
+          sequenceCount,
+          startVector,
+          stopVector,
+          stepVector,
+          row);
+      elementsOffset += rawSizes[row];
+    }
+  });
+  context.moveOrCopyResult(
+      std::make_shared<ArrayVector>(
+          pool, outputType, nullptr, numRows, offsets, sizes, elements),
+      rows,
+      result);
+}
+
+template <typename T, typename K>
+vector_size_t SequenceFunction<T, K>::checkArguments(
+    DecodedVector* startVector,
+    DecodedVector* stopVector,
+    DecodedVector* stepVector,
+    vector_size_t row,
+    bool isDate,
+    bool isYearMonth,
+    int32_t maxElementsSize) {
+  T start = startVector->valueAt<T>(row);
+  T stop = stopVector->valueAt<T>(row);
+  auto step = getStep(
+      toInt64(start), toInt64(stop), stepVector, row, isDate, isYearMonth);
+  VELOX_USER_CHECK_NE(step, 0, "step must not be zero");
+  VELOX_USER_CHECK(
+      step > 0 ? stop >= start : stop <= start,
+      "sequence stop value should be greater than or equal to start value if "
+      "step is greater than zero otherwise stop should be less than or equal to start");
+  int128_t sequenceCount;
+  if (isYearMonth) {
+    sequenceCount = getStepCount(start, stop, step);
+  } else {
+    sequenceCount = (static_cast<int128_t>(toInt64(stop)) -
+                     static_cast<int128_t>(toInt64(start))) /
+            step +
+        1; // prevent overflow
+  }
+
+  VELOX_USER_CHECK_LE(
+      sequenceCount,
+      maxElementsSize,
+      "result of sequence function must not have more than {} entries",
+      maxElementsSize);
+  return sequenceCount;
+}
+
+template <typename T, typename K>
+void SequenceFunction<T, K>::writeToElements(
+    T* elements,
+    bool isDate,
+    bool isYearMonth,
+    vector_size_t sequenceCount,
+    DecodedVector* startVector,
+    DecodedVector* stopVector,
+    DecodedVector* stepVector,
+    vector_size_t row) {
+  auto start = startVector->valueAt<T>(row);
+  auto stop = stopVector->valueAt<T>(row);
+  auto step = getStep(
+      toInt64(start), toInt64(stop), stepVector, row, isDate, isYearMonth);
+  for (auto sequence = 0; sequence < sequenceCount; ++sequence) {
+    elements[sequence] = add(start, step, sequence);
+  }
+}
+
+template <typename T, typename K>
+K SequenceFunction<T, K>::getStep(
+    int64_t start,
+    int64_t stop,
+    DecodedVector* stepVector,
+    vector_size_t row,
+    bool isDate,
+    bool isYearMonth) {
+  if (!stepVector) {
+    return (stop >= start ? 1 : -1);
+  }
+  // When element type T differs from step type K (e.g., integer sequence
+  // using T=int32_t, K=int64_t to avoid conflicting with date
+  // specializations), read step as T and cast to K.
+  if constexpr (std::is_integral_v<T> && !std::is_same_v<T, K>) {
+    if (!isDate) {
+      return static_cast<K>(stepVector->valueAt<T>(row));
+    }
+  }
+  auto step = stepVector->valueAt<K>(row);
+  if (!isDate || isYearMonth) {
+    return step;
+  }
+  // Handle Date
+  VELOX_USER_CHECK(
+      step % kMillisInDay == 0,
+      "sequence step must be a day interval if start and end values are dates");
+  return step / kMillisInDay;
+}
+
+// Explicit instantiations for all supported types.
+// Presto types:
+template class SequenceFunction<int64_t, int64_t>;
+template class SequenceFunction<int32_t, int64_t>;
+template class SequenceFunction<int32_t, int32_t>;
+template class SequenceFunction<Timestamp, int64_t>;
+template class SequenceFunction<Timestamp, int32_t>;
+// Spark-specific types:
+template class SequenceFunction<int8_t, int8_t>;
+template class SequenceFunction<int16_t, int16_t>;
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/Sequence.h b/velox/functions/lib/Sequence.h
new file mode 100644
index 00000000000..a2af9a65c86
--- /dev/null
+++ b/velox/functions/lib/Sequence.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/VectorFunction.h"
+
+namespace facebook::velox::functions {
+
+/// Sequence function that generates an array of values from start to stop
+/// (inclusive) with an optional step. Supports integer types (tinyint,
+/// smallint, integer, bigint), date, and timestamp.
+template <typename T, typename K>
+class SequenceFunction : public exec::VectorFunction {
+ public:
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& outputType,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override;
+
+ private:
+  static vector_size_t checkArguments(
+      DecodedVector* startVector,
+      DecodedVector* stopVector,
+      DecodedVector* stepVector,
+      vector_size_t row,
+      bool isDate,
+      bool isYearMonth,
+      int32_t maxElementsSize);
+
+  static void writeToElements(
+      T* elements,
+      bool isDate,
+      bool isYearMonth,
+      vector_size_t sequenceCount,
+      DecodedVector* startVector,
+      DecodedVector* stopVector,
+      DecodedVector* stepVector,
+      vector_size_t row);
+
+  static K getStep(
+      int64_t start,
+      int64_t stop,
+      DecodedVector* stepVector,
+      vector_size_t row,
+      bool isDate,
+      bool isYearMonth);
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/SetDigest.h b/velox/functions/lib/SetDigest.h
new file mode 100644
index 00000000000..86ea16470ac
--- /dev/null
+++ b/velox/functions/lib/SetDigest.h
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/base/Status.h"
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/functions/lib/HllAccumulator.h"
+#include "velox/type/StringView.h"
+
+#include <cstdint>
+#include <map>
+#include <type_traits>
+
+namespace facebook::velox::functions {
+
+/// SetDigest is a probabilistic data structure for estimating set cardinality
+/// and performing set operations. It combines HyperLogLog for cardinality
+/// estimation with MinHash for exact counting and intersection operations.
+///
+/// Template parameters:
+/// - T: The element type, which must be either int64_t or StringView.
+template <typename T>
+class SetDigest {
+  static_assert(
+      std::is_same_v<T, int64_t> || std::is_same_v<T, StringView>,
+      "SetDigest only supports int64_t or StringView");
+
+ public:
+  template <typename U>
+  using TStlAllocator = HashStringAllocator::TStlAllocator<U>;
+
+  static constexpr int32_t kDefaultMaxHashes = 8192;
+  static constexpr int32_t kNumberOfBuckets = 2048;
+  static constexpr int8_t kDefaultIndexBitLength = 11;
+
+  /// Construct a SetDigest with specified parameters.
+  /// @param allocator Memory allocator for internal data structures.
+  /// @param indexBitLength Number of bits for HLL indexing (default 11 = 2048
+  /// buckets). Must be in range (0, 16].
+  /// @param maxHashes Maximum number of hashes to store in MinHash (default
+  /// 8192). When exceeded, digest becomes approximate.
+  explicit SetDigest(
+      HashStringAllocator* allocator,
+      int8_t indexBitLength = kDefaultIndexBitLength,
+      int32_t maxHashes = kDefaultMaxHashes);
+
+  /// Add a new value to the digest.
+  /// @param value The value to add.
+  void add(T value);
+
+  /// Merge this digest with another digest.
+  /// @param other The other digest to merge into this one.
+  void mergeWith(const SetDigest& other);
+
+  /// Returns true if the digest is exact (cardinality < maxHashes).
+  /// When exact, cardinality() returns the exact count.
+  /// Used in exactIntersectionCardinality().
+  bool isExact() const;
+
+  /// Returns the estimated cardinality of the set.
+  /// If isExact() is true, returns the exact count.
+  /// Otherwise, returns HyperLogLog estimate.
+  int64_t cardinality() const;
+
+  /// Calculate the exact intersection cardinality between two digests.
+  /// Both digests must be exact (isExact() == true).
+  /// @param left First digest (must be exact).
+  /// @param right Second digest (must be exact).
+  /// @return The exact number of elements in the intersection.
+  static int64_t exactIntersectionCardinality(
+      const SetDigest& left,
+      const SetDigest& right);
+
+  /// Compute the Jaccard index (similarity coefficient) between two digests.
+  /// Uses MinHash estimation. Returns a value in [0, 1] where 1 means
+  /// identical sets and 0 means disjoint sets.
+  /// @param left First digest.
+  /// @param right Second digest.
+  /// @return Estimated Jaccard index.
+  static double jaccardIndex(const SetDigest& left, const SetDigest& right);
+
+  /// Calculate the size needed for serialization.
+  /// @return The number of bytes needed to serialize this digest.
+  int32_t estimatedSerializedSize() const;
+
+  /// Serialize the digest into bytes. The serialization is versioned and
+  /// compatible with Presto Java.
+  /// @param out Pre-allocated memory at least estimatedSerializedSize() in
+  /// size.
+  void serialize(char* out) const;
+
+  /// Deserialize a SetDigest from serialized input.
+  /// Serialization produced by Presto Java can be used as input.
+  /// @param data The input serialization.
+  /// @param size The size of the serialization in bytes.
+  /// @return Status::OK() on success, or an error Status on failure.
+  Status deserialize(const char* data, int32_t size);
+
+  /// Get a copy of the MinHash hash counts.
+  /// Returns a map from hash value to count.
+  /// @return A map of hash values to their counts.
+  std::map<int64_t, int16_t> getHashCounts() const;
+
+ private:
+  void addHash(uint64_t hash);
+
+  void increaseTotalHllSize();
+  void decreaseTotalHllSize();
+
+  using MinHashAllocator = TStlAllocator<std::pair<const int64_t, int16_t>>;
+  std::map<int64_t, int16_t, std::less<int64_t>, MinHashAllocator> minhash_;
+
+  common::hll::HllAccumulator<int64_t, true, HashStringAllocator>
+      hllAccumulator_;
+  int32_t maxHashes_{kDefaultMaxHashes};
+  HashStringAllocator* allocator_;
+
+  /// Tracks the HLL serialized size, updated when HLL changes.
+  int32_t hllTotalEstimatedSerializedSize_{0};
+};
+
+} // namespace facebook::velox::functions
+
+#include "velox/functions/lib/SetDigestImpl.h"
diff --git a/velox/functions/lib/SetDigestImpl.h b/velox/functions/lib/SetDigestImpl.h
new file mode 100644
index 00000000000..82c4e07e354
--- /dev/null
+++ b/velox/functions/lib/SetDigestImpl.h
@@ -0,0 +1,333 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/base/IOUtils.h"
+#include "velox/common/hyperloglog/Murmur3Hash128.h"
+
+#include <limits>
+#include <vector>
+
+namespace facebook::velox::functions {
+
+namespace detail {
+constexpr int8_t kUncompressedFormat = 1;
+
+inline uint64_t computeHash(int64_t value) {
+  return common::hll::Murmur3Hash128::hash64ForLong(value, 0);
+}
+
+inline uint64_t computeHash(StringView value) {
+  return common::hll::Murmur3Hash128::hash64(value.data(), value.size(), 0);
+}
+} // namespace detail
+
+template <typename T>
+SetDigest<T>::SetDigest(
+    HashStringAllocator* allocator,
+    int8_t indexBitLength,
+    int32_t maxHashes)
+    : minhash_{MinHashAllocator(allocator)},
+      hllAccumulator_{indexBitLength, allocator},
+      maxHashes_{maxHashes},
+      allocator_{allocator},
+      hllTotalEstimatedSerializedSize_{0} {
+  // Validate indexBitLength matches Java validation
+  VELOX_CHECK_GT(indexBitLength, 0, "indexBitLength must be > 0");
+  VELOX_CHECK_LE(indexBitLength, 16, "indexBitLength must be <= 16");
+
+  // Validate maxHashes
+  VELOX_CHECK_GT(maxHashes, 0, "maxHashes must be > 0");
+
+  // Verify default indexBitLength matches kNumberOfBuckets
+  static_assert(
+      (1 << SetDigest<T>::kDefaultIndexBitLength) ==
+          SetDigest<T>::kNumberOfBuckets,
+      "Default index bit length must match NUMBER_OF_BUCKETS");
+
+  // Initialize HLL size after HLL is constructed
+  increaseTotalHllSize();
+}
+
+template <typename T>
+bool SetDigest<T>::isExact() const {
+  return static_cast<int32_t>(minhash_.size()) < maxHashes_;
+}
+
+template <typename T>
+void SetDigest<T>::add(T value) {
+  uint64_t hash = detail::computeHash(value);
+  addHash(hash);
+  decreaseTotalHllSize();
+  hllAccumulator_.insertHash(hash);
+  increaseTotalHllSize();
+}
+
+template <typename T>
+void SetDigest<T>::addHash(uint64_t hash) {
+  int64_t signedHash = static_cast<int64_t>(hash);
+  auto it = minhash_.find(signedHash);
+  int16_t currentCount = (it != minhash_.end()) ? it->second : 0;
+
+  if (currentCount < std::numeric_limits<int16_t>::max()) {
+    minhash_[signedHash] = static_cast<int16_t>(currentCount + 1);
+  }
+
+  while (static_cast<int32_t>(minhash_.size()) > maxHashes_) {
+    minhash_.erase(std::prev(minhash_.end()));
+  }
+}
+
+template <typename T>
+inline void SetDigest<T>::increaseTotalHllSize() {
+  hllTotalEstimatedSerializedSize_ += hllAccumulator_.serializedSize();
+}
+
+template <typename T>
+inline void SetDigest<T>::decreaseTotalHllSize() {
+  hllTotalEstimatedSerializedSize_ -= hllAccumulator_.serializedSize();
+}
+
+template <typename T>
+int32_t SetDigest<T>::estimatedSerializedSize() const {
+  return static_cast<int32_t>(
+      sizeof(int8_t) + // format byte
+      sizeof(int32_t) + // HLL length
+      hllTotalEstimatedSerializedSize_ + // HLL data
+      sizeof(int32_t) + // maxHashes
+      sizeof(int32_t) + // minhash size
+      minhash_.size() * (sizeof(int64_t) + sizeof(int16_t))); // keys + values
+}
+
+template <typename T>
+void SetDigest<T>::serialize(char* out) const {
+  common::OutputByteStream stream(out);
+
+  stream.appendOne(detail::kUncompressedFormat);
+  stream.appendOne(hllTotalEstimatedSerializedSize_);
+
+  // Use const_cast because HllAccumulator::serialize() is not const,
+  // but serialization does not logically modify the object.
+  const_cast<common::hll::HllAccumulator<int64_t, true, HashStringAllocator>&>(
+      hllAccumulator_)
+      .serialize(out + stream.offset());
+  stream = common::OutputByteStream(
+      out, stream.offset() + hllTotalEstimatedSerializedSize_);
+
+  stream.appendOne(maxHashes_);
+  stream.appendOne(static_cast<int32_t>(minhash_.size()));
+
+  for (const auto& entry : minhash_) {
+    stream.appendOne(entry.first);
+  }
+
+  for (const auto& entry : minhash_) {
+    stream.appendOne(entry.second);
+  }
+
+  VELOX_CHECK_EQ(stream.offset(), estimatedSerializedSize());
+}
+
+template <typename T>
+Status SetDigest<T>::deserialize(const char* data, int32_t size) {
+  if (size < static_cast<int32_t>(sizeof(int8_t) + sizeof(int32_t))) {
+    return Status::UserError("Input too small to be a valid SetDigest");
+  }
+
+  common::InputByteStream stream(data);
+
+  int8_t format = stream.read<int8_t>();
+  if (format != detail::kUncompressedFormat) {
+    return Status::UserError(
+        "Unexpected SetDigest format: expected {}, got {}",
+        detail::kUncompressedFormat,
+        format);
+  }
+
+  // Read HLL length
+  int32_t hllLength = stream.read<int32_t>();
+  if (hllLength < 0) {
+    return Status::UserError("Invalid HLL length in SetDigest serialization");
+  }
+  if (hllLength >
+      size - static_cast<int32_t>(sizeof(int8_t) + sizeof(int32_t))) {
+    return Status::UserError("HLL length exceeds input size");
+  }
+
+  // Deserialize HLL using HllAccumulator
+  auto deserializedHll =
+      common::hll::HllAccumulator<int64_t, true, HashStringAllocator>::
+          deserialize(data + stream.offset(), allocator_);
+  decreaseTotalHllSize();
+  hllAccumulator_ = std::move(*deserializedHll);
+  increaseTotalHllSize();
+
+  stream = common::InputByteStream(data + stream.offset() + hllLength);
+
+  // Calculate remaining bytes after HLL data
+  int32_t bytesConsumed = sizeof(int8_t) + sizeof(int32_t) + hllLength;
+  int32_t remainingBytes = size - bytesConsumed;
+
+  if (remainingBytes < static_cast<int32_t>(2 * sizeof(int32_t))) {
+    return Status::UserError(
+        "Input too small to contain maxHashes and minhash size");
+  }
+
+  maxHashes_ = stream.read<int32_t>();
+  if (maxHashes_ <= 0) {
+    return Status::UserError("maxHashes must be > 0");
+  }
+
+  int32_t minhashSize = stream.read<int32_t>();
+  if (minhashSize < 0) {
+    return Status::UserError("minhash size cannot be negative");
+  }
+
+  // Validate that there's enough data for the minhash entries
+  int32_t expectedMinhashBytes =
+      minhashSize * (sizeof(int64_t) + sizeof(int16_t));
+  if (remainingBytes - 2 * static_cast<int32_t>(sizeof(int32_t)) <
+      expectedMinhashBytes) {
+    return Status::UserError("Input too small to contain minhash entries");
+  }
+
+  std::vector<int64_t> keys;
+  keys.reserve(minhashSize);
+  for (int32_t i = 0; i < minhashSize; i++) {
+    keys.push_back(stream.read<int64_t>());
+  }
+
+  for (int32_t i = 0; i < minhashSize; i++) {
+    int16_t count = stream.read<int16_t>();
+    minhash_[keys[i]] = count;
+  }
+
+  return Status::OK();
+}
+
+template <typename T>
+void SetDigest<T>::mergeWith(const SetDigest& other) {
+  // Merge HyperLogLog using HllAccumulator
+  decreaseTotalHllSize();
+  hllAccumulator_.mergeWith(other.hllAccumulator_);
+  increaseTotalHllSize();
+
+  // Merge minhash maps
+  for (const auto& entry : other.minhash_) {
+    int64_t key = entry.first;
+    int16_t otherCount = entry.second;
+
+    auto it = minhash_.find(key);
+    int16_t currentCount = (it != minhash_.end()) ? it->second : 0;
+
+    // Add counts, saturating at int16_t max
+    int32_t newCount =
+        static_cast<int32_t>(currentCount) + static_cast<int32_t>(otherCount);
+    if (newCount > std::numeric_limits<int16_t>::max()) {
+      minhash_[key] = std::numeric_limits<int16_t>::max();
+    } else {
+      minhash_[key] = static_cast<int16_t>(newCount);
+    }
+  }
+
+  // Remove largest hash values when we exceed maxHashes
+  while (static_cast<int32_t>(minhash_.size()) > maxHashes_) {
+    minhash_.erase(std::prev(minhash_.end()));
+  }
+}
+
+template <typename T>
+int64_t SetDigest<T>::cardinality() const {
+  if (isExact()) {
+    return static_cast<int64_t>(minhash_.size());
+  }
+  return hllAccumulator_.cardinality();
+}
+
+template <typename T>
+int64_t SetDigest<T>::exactIntersectionCardinality(
+    const SetDigest& left,
+    const SetDigest& right) {
+  VELOX_USER_CHECK(
+      left.isExact(), "exact intersection cannot operate on approximate sets");
+  VELOX_USER_CHECK(
+      right.isExact(), "exact intersection cannot operate on approximate sets");
+
+  const auto& [smaller, larger] = left.minhash_.size() <= right.minhash_.size()
+      ? std::tie(left, right)
+      : std::tie(right, left);
+
+  int64_t count = 0;
+  for (const auto& entry : smaller.minhash_) {
+    if (larger.minhash_.count(entry.first)) {
+      count++;
+    }
+  }
+  return count;
+}
+
+template <typename T>
+double SetDigest<T>::jaccardIndex(
+    const SetDigest& left,
+    const SetDigest& right) {
+  if (left.minhash_.empty() && right.minhash_.empty()) {
+    return 1.0;
+  }
+
+  int32_t sizeOfSmallerSet = std::min(
+      static_cast<int32_t>(left.minhash_.size()),
+      static_cast<int32_t>(right.minhash_.size()));
+
+  if (sizeOfSmallerSet == 0) {
+    return 0.0;
+  }
+
+  auto itLeft = left.minhash_.begin();
+  auto itRight = right.minhash_.begin();
+
+  int32_t intersectionCnt = 0;
+  int32_t unionCnt = 0;
+
+  while (itLeft != left.minhash_.end() && itRight != right.minhash_.end() &&
+         unionCnt < sizeOfSmallerSet) {
+    if (itLeft->first < itRight->first) {
+      ++itLeft;
+    } else if (itRight->first < itLeft->first) {
+      ++itRight;
+    } else {
+      intersectionCnt++;
+      ++itLeft;
+      ++itRight;
+    }
+    unionCnt++;
+  }
+
+  return static_cast<double>(intersectionCnt) /
+      static_cast<double>(sizeOfSmallerSet);
+}
+
+template <typename T>
+std::map<int64_t, int16_t> SetDigest<T>::getHashCounts() const {
+  std::map<int64_t, int16_t> result;
+  for (const auto& entry : minhash_) {
+    result[entry.first] = entry.second;
+  }
+  return result;
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/SimpleComparisonMatcher.cpp b/velox/functions/lib/SimpleComparisonMatcher.cpp
new file mode 100644
index 00000000000..218f7e93ffb
--- /dev/null
+++ b/velox/functions/lib/SimpleComparisonMatcher.cpp
@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/lib/SimpleComparisonMatcher.h"
+#include "velox/expression/ExprConstants.h"
+
+namespace facebook::velox::functions {
+
+bool Matcher::allMatch(
+    const std::vector<core::TypedExprPtr>& exprs,
+    std::vector<std::shared_ptr<Matcher>>& matchers) {
+  for (auto i = 0; i < exprs.size(); ++i) {
+    if (!matchers[i]->match(exprs[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool IfMatcher::match(const core::TypedExprPtr& expr) {
+  if (auto call = dynamic_cast<const core::CallTypedExpr*>(expr.get())) {
+    if (call->name() == expression::kIf &&
+        allMatch(call->inputs(), inputMatchers_)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool ComparisonMatcher::match(const core::TypedExprPtr& expr) {
+  if (auto call = dynamic_cast<const core::CallTypedExpr*>(expr.get())) {
+    const auto& name = call->name();
+    if (exprNameMatch(name)) {
+      if (allMatch(call->inputs(), inputMatchers_)) {
+        *op_ = name;
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+bool AnySingleInputMatcher::match(const core::TypedExprPtr& expr) {
+  // Check if 'expr' depends on a single column.
+  std::unordered_set<core::FieldAccessTypedExprPtr> inputs;
+  collectInputs(expr, inputs);
+
+  if (inputs.size() == 1) {
+    *expr_ = expr;
+    *input_ = *inputs.begin();
+    return true;
+  }
+
+  return false;
+}
+
+void AnySingleInputMatcher::collectInputs(
+    const core::TypedExprPtr& expr,
+    std::unordered_set<core::FieldAccessTypedExprPtr>& inputs) {
+  if (auto field =
+          std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(expr)) {
+    if (field->isInputColumn()) {
+      inputs.insert(field);
+      return;
+    }
+  }
+
+  for (const auto& input : expr->inputs()) {
+    collectInputs(input, inputs);
+  }
+}
+
+bool ComparisonConstantMatcher::match(const core::TypedExprPtr& expr) {
+  if (auto constant = asConstant(expr.get())) {
+    auto v = constant.value();
+    if (v == 0 || v == 1 || v == -1) {
+      *value_ = v;
+      return true;
+    }
+  }
+  return false;
+}
+
+std::optional<int64_t> ComparisonConstantMatcher::asConstant(
+    const core::ITypedExpr* expr) {
+  if (auto constant = dynamic_cast<const core::ConstantTypedExpr*>(expr)) {
+    if (!constant->isNull()) {
+      if (constant->hasValueVector()) {
+        const auto& vector = constant->valueVector();
+        if (constant->type()->isBigint()) {
+          return vector->as<SimpleVector<int64_t>>()->valueAt(0);
+        } else if (constant->type()->isInteger()) {
+          return vector->as<SimpleVector<int32_t>>()->valueAt(0);
+        }
+      } else {
+        if (constant->value().kind() == TypeKind::BIGINT) {
+          return constant->value().value<int64_t>();
+        }
+
+        if (constant->value().kind() == TypeKind::INTEGER) {
+          return constant->value().value<int32_t>();
+        }
+      }
+    }
+  }
+
+  return std::nullopt;
+}
+
+bool SimpleComparisonChecker::isLessThen(
+    const std::string& prefix,
+    const std::string& operation,
+    const core::FieldAccessTypedExprPtr& left,
+    int64_t result,
+    const std::string& inputLeft) {
+  std::string op =
+      (left->name() == inputLeft) ? operation : invert(prefix, operation);
+
+  if (op == ltName(prefix)) {
+    return result < 0;
+  }
+
+  return result > 0;
+}
+
+std::optional<SimpleComparison> SimpleComparisonChecker::isSimpleComparison(
+    const std::string& prefix,
+    const core::LambdaTypedExpr& expr) {
+  // First, check the shape of the expression.
+  // if (x(a) < y(b), c1, if (u(c) > v(d), c2, c3))
+  core::FieldAccessTypedExprPtr a, b, c, d;
+  core::TypedExprPtr x, y, u, v;
+  std::string op1, op2;
+  int64_t c1, c2, c3;
+
+  auto matcher = ifelse(
+      comparison(prefix, anySingleInput(&x, &a), anySingleInput(&y, &b), &op1),
+      comparisonConstant(&c1),
+      ifelse(
+          comparison(
+              prefix, anySingleInput(&u, &c), anySingleInput(&v, &d), &op2),
+          comparisonConstant(&c2),
+          comparisonConstant(&c3)));
+
+  if (!matcher->match(expr.body())) {
+    return std::nullopt;
+  }
+
+  // Verify that a != b, c != d.
+  if (a == b || c == d) {
+    return std::nullopt;
+  }
+
+  // Verify that x, y, u, v are the same (except for input column).
+  std::unordered_map<std::string, core::TypedExprPtr> inputMapping;
+  inputMapping.emplace(
+      a->name(),
+      std::make_shared<core::FieldAccessTypedExpr>(a->type(), b->name()));
+  const auto xRewritten = x->rewriteInputNames(inputMapping);
+  if (!(*xRewritten == *y->rewriteInputNames(inputMapping) &&
+        *xRewritten == *u->rewriteInputNames(inputMapping) &&
+        *xRewritten == *v->rewriteInputNames(inputMapping))) {
+    return std::nullopt;
+  }
+
+  // Verify all constants are different.
+  if (c1 == c2 || c2 == c3 || c1 == c3) {
+    return std::nullopt;
+  }
+
+  const auto eq = eqName(prefix);
+
+  // Verify that equality comparisons return zero.
+  // if (x(a) = y(a), 0,..) is good. if (x(a) = y(a), 1,..) is not good.
+  // Also, verify that non-equality comparisons return non-zero.
+  // if (x(a) < y(a), 1,..) is good. if (x(a) < y(a), 0,..) is not good.
+  if ((op1 == eq && c1 != 0) || (op1 != eq && c1 == 0)) {
+    return std::nullopt;
+  }
+
+  if ((op2 == eq && c2 != 0) || (op2 != eq && c2 == 0)) {
+    return std::nullopt;
+  }
+
+  const auto left = expr.signature()->nameOf(0);
+
+  const auto transform = a->name() == left ? x : y;
+
+  if (op1 == eq) {
+    // if (x(a) = y(b), 0,...)
+    return {{transform, isLessThen(prefix, op2, c, c2, left)}};
+  }
+
+  if (op2 == eq) {
+    return {{transform, isLessThen(prefix, op1, a, c1, left)}};
+  }
+
+  // Make sure op1 and op2 are aligned.
+  auto b1 = isLessThen(prefix, op1, a, c1, left);
+  auto b2 = isLessThen(prefix, op2, c, c2, left);
+  if (b1 != b2) {
+    return std::nullopt;
+  }
+
+  return {{transform, b1}};
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/SimpleComparisonMatcher.h b/velox/functions/lib/SimpleComparisonMatcher.h
new file mode 100644
index 00000000000..5113d1542b2
--- /dev/null
+++ b/velox/functions/lib/SimpleComparisonMatcher.h
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/core/Expressions.h"
+#include "velox/vector/ConstantVector.h"
+
+namespace facebook::velox::functions {
+
+struct SimpleComparison {
+  core::TypedExprPtr expr;
+  bool isLessThen;
+};
+
+class Matcher {
+ public:
+  virtual bool match(const core::TypedExprPtr& expr) = 0;
+
+  virtual ~Matcher() = default;
+
+  // Checks if all expressions match the corresponding matchers.
+  static bool allMatch(
+      const std::vector<core::TypedExprPtr>& exprs,
+      std::vector<std::shared_ptr<Matcher>>& matchers);
+};
+
+// Matches the if expression that children match the given matchers.
+class IfMatcher : public Matcher {
+ public:
+  explicit IfMatcher(std::vector<std::shared_ptr<Matcher>> inputMatchers)
+      : inputMatchers_{std::move(inputMatchers)} {
+    VELOX_CHECK_EQ(3, inputMatchers_.size());
+  }
+
+  bool match(const core::TypedExprPtr& expr) override;
+
+ private:
+  std::vector<std::shared_ptr<Matcher>> inputMatchers_;
+};
+
+// Matches comparison expression that represents `eq`, `lt`, or `gt`.
+class ComparisonMatcher : public Matcher {
+ public:
+  ComparisonMatcher(
+      const std::string& prefix,
+      const std::vector<std::shared_ptr<Matcher>>& inputMatchers,
+      std::string* op)
+      : prefix_{prefix}, inputMatchers_{inputMatchers}, op_{op} {
+    VELOX_CHECK_EQ(2, inputMatchers_.size());
+  }
+
+  /// Checks if the given name specifies a comparison expression. Can be
+  /// overriden to use different function names for Spark.
+  virtual bool exprNameMatch(const std::string& name) {
+    return name == prefix_ + "eq" || name == prefix_ + "lt" ||
+        name == prefix_ + "gt";
+  }
+
+  bool match(const core::TypedExprPtr& expr) override;
+
+ protected:
+  const std::string prefix_;
+
+ private:
+  std::vector<std::shared_ptr<Matcher>> inputMatchers_;
+  std::string* op_;
+};
+
+class AnySingleInputMatcher : public Matcher {
+ public:
+  AnySingleInputMatcher(
+      core::TypedExprPtr* expr,
+      core::FieldAccessTypedExprPtr* input)
+      : expr_{expr}, input_{input} {}
+
+  bool match(const core::TypedExprPtr& expr) override;
+
+ private:
+  static void collectInputs(
+      const core::TypedExprPtr& expr,
+      std::unordered_set<core::FieldAccessTypedExprPtr>& inputs);
+
+  core::TypedExprPtr* const expr_;
+  core::FieldAccessTypedExprPtr* const input_;
+};
+
+/// Matches constant expression that represents values 1, 0, or -1 of type
+/// BIGINT.
+class ComparisonConstantMatcher : public Matcher {
+ public:
+  explicit ComparisonConstantMatcher(int64_t* value) : value_{value} {}
+
+  bool match(const core::TypedExprPtr& expr) override;
+
+ private:
+  static std::optional<int64_t> asConstant(const core::ITypedExpr* expr);
+
+  int64_t* const value_;
+};
+
+class SimpleComparisonChecker {
+ protected:
+  std::shared_ptr<Matcher> ifelse(
+      const std::shared_ptr<Matcher>& condition,
+      const std::shared_ptr<Matcher>& thenClause,
+      const std::shared_ptr<Matcher>& elseClause) {
+    return std::make_shared<IfMatcher>(std::vector<std::shared_ptr<Matcher>>{
+        condition, thenClause, elseClause});
+  }
+
+  std::shared_ptr<Matcher> anySingleInput(
+      core::TypedExprPtr* expr,
+      core::FieldAccessTypedExprPtr* input) {
+    return std::make_shared<AnySingleInputMatcher>(expr, input);
+  }
+
+  std::shared_ptr<Matcher> comparisonConstant(int64_t* value) {
+    return std::make_shared<ComparisonConstantMatcher>(value);
+  }
+
+  std::string invert(const std::string& prefix, const std::string& op) {
+    return op == ltName(prefix) ? gtName(prefix) : ltName(prefix);
+  }
+
+  // Returns true for a < b -> -1.
+  bool isLessThen(
+      const std::string& prefix,
+      const std::string& operation,
+      const core::FieldAccessTypedExprPtr& left,
+      int64_t result,
+      const std::string& inputLeft);
+
+  virtual std::shared_ptr<Matcher> comparison(
+      const std::string& prefix,
+      const std::shared_ptr<Matcher>& left,
+      const std::shared_ptr<Matcher>& right,
+      std::string* op) {
+    return std::make_shared<ComparisonMatcher>(
+        prefix, std::vector<std::shared_ptr<Matcher>>{left, right}, op);
+  }
+
+  virtual std::string eqName(const std::string& prefix) {
+    return prefix + "eq";
+  }
+
+  virtual std::string ltName(const std::string& prefix) {
+    return prefix + "lt";
+  }
+
+  virtual std::string gtName(const std::string& prefix) {
+    return prefix + "gt";
+  }
+
+ public:
+  virtual ~SimpleComparisonChecker() = default;
+
+  /// Given a lambda expression, checks it if represents a simple comparator and
+  /// returns the summary of the same.
+  ///
+  /// For example, identifies
+  ///     (x, y) -> if(length(x) < length(y), -1, if(length(x) > length(y), 1,
+  ///     0))
+  /// expression as a "less than" comparison over length(x).
+  ///
+  /// Recognizes different variations of this expression, e.g.
+  ///
+  ///     (x, y) -> if(expr(x) = expr(y), 0, if(expr(x) < expr(y), -1, 1))
+  ///     (x, y) -> if(expr(x) = expr(y), 0, if(expr(y) > expr(x), -1, 1))
+  ///
+  /// Returns std::nullopt if expression is not recognized as a simple
+  /// comparator.
+  ///
+  /// Can be used to re-write generic lambda expressions passed to array_sort
+  /// into simpler ones that can be evaluated more efficiently.
+  std::optional<SimpleComparison> isSimpleComparison(
+      const std::string& prefix,
+      const core::LambdaTypedExpr& expr);
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/Slice.cpp b/velox/functions/lib/Slice.cpp
index ed7830eb782..52a66ca6794 100644
--- a/velox/functions/lib/Slice.cpp
+++ b/velox/functions/lib/Slice.cpp
@@ -54,7 +54,7 @@ class SliceFunction : public exec::VectorFunction {
     VELOX_CHECK(
         kind == TypeKind::BIGINT || kind == TypeKind::INTEGER,
         "Unsupported parameter type {} to register slice function",
-        mapTypeKindToName(kind));
+        TypeKindName::toName(kind));
   }
 
   void apply(
@@ -71,7 +71,7 @@ class SliceFunction : public exec::VectorFunction {
         args[1]->typeKind(),
         kind_,
         "Function slice() requires second argument of type {}",
-        mapTypeKindToName(kind_));
+        TypeKindName::toName(kind_));
     VELOX_USER_CHECK_EQ(
         args[1]->typeKind(),
         args[2]->typeKind(),
@@ -213,7 +213,7 @@ class SliceFunction : public exec::VectorFunction {
 
 // @param kind The type kind of start and length.
 void registerSliceFunction(const std::string& prefix, TypeKind kind) {
-  auto kindName = exec::sanitizeName(mapTypeKindToName(kind));
+  auto kindName = exec::sanitizeName(std::string(TypeKindName::toName(kind)));
 
   std::vector<std::shared_ptr<exec::FunctionSignature>> signatures = {
       exec::FunctionSignatureBuilder()
diff --git a/velox/functions/lib/SubscriptUtil.cpp b/velox/functions/lib/SubscriptUtil.cpp
index dca16ce46f9..7a345e52076 100644
--- a/velox/functions/lib/SubscriptUtil.cpp
+++ b/velox/functions/lib/SubscriptUtil.cpp
@@ -22,6 +22,7 @@
 #include "velox/common/memory/MemoryPool.h"
 #include "velox/functions/lib/SubscriptUtil.h"
 #include "velox/type/Type.h"
+#include "velox/vector/FlatMapVector.h"
 #include "velox/vector/TypeAliases.h"
 
 namespace facebook::velox::functions {
@@ -60,7 +61,7 @@ VectorPtr applyMapTyped(
     bool triggerCaching,
     std::shared_ptr<detail::LookupTableBase>& cachedLookupTablePtr,
     const SelectivityVector& rows,
-    const VectorPtr& mapArg,
+    const DecodedVector& decodedMap,
     const VectorPtr& indexArg,
     exec::EvalCtx& context) {
   static constexpr vector_size_t kMinCachedMapSize = 100;
@@ -85,10 +86,8 @@ VectorPtr applyMapTyped(
 
   // Get base MapVector.
   // TODO: Optimize the case when indices are identity.
-  exec::LocalDecodedVector mapHolder(context, *mapArg, rows);
-  auto decodedMap = mapHolder.get();
-  auto baseMap = decodedMap->base()->as<MapVector>();
-  auto mapIndices = decodedMap->indices();
+  auto baseMap = decodedMap.base()->as<MapVector>();
+  auto mapIndices = decodedMap.indices();
 
   // Get map keys.
   auto mapKeys = baseMap->mapKeys();
@@ -186,9 +185,73 @@ VectorPtr applyMapTyped(
       true /*flattenIfRedundant*/);
 }
 
+/// Applies logic to vectors of FlatMapVector encoding. The implementation is
+/// far simpler than the regular map encoding because FlatMapVector already
+/// supports feature projection. This implementation will serve as a fast-path
+/// execution for now-wrapped vectors.
+VectorPtr applyFlatMap(
+    const SelectivityVector& rows,
+    const DecodedVector& decodedMap,
+    const VectorPtr& elementAt,
+    exec::EvalCtx& context) {
+  // Decode input flat map vector.
+  auto flatMap = decodedMap.base()->as<FlatMapVector>();
+
+  // Optimal use case: unwrapped vector and constant key. We can simply project
+  // the feature using the first value in the arg vector.
+  if (decodedMap.isIdentityMapping() && elementAt->isConstantEncoding()) {
+    if (auto projection = flatMap->projectKey(elementAt, 0)) {
+      return projection;
+    }
+  }
+
+  // Next base case: wrapped vector and constant key. In this scenario we just
+  // need to decode and simply project onto the first index again.
+  else if (elementAt->isConstantEncoding()) {
+    // Define nulls and indices buffers.
+    BufferPtr indices =
+        AlignedBuffer::allocate<vector_size_t>(rows.size(), flatMap->pool());
+    BufferPtr nulls = allocateNulls(rows.size(), flatMap->pool());
+    auto mutableIndices = indices->asMutable<vector_size_t>();
+    auto rawNulls = nulls->asMutable<uint64_t>();
+    for (int i = 0; i < decodedMap.size(); i++) {
+      mutableIndices[i] = decodedMap.indices()[i];
+      if (decodedMap.isNullAt(i)) {
+        bits::setNull(rawNulls, i, true);
+      }
+    }
+
+    if (auto projection = flatMap->projectKey(elementAt, 0)) {
+      // Wrap underlying projected feature stream. This will also help with
+      // memory pressure for large feature element vectors.
+      return BaseVector::wrapInDictionary(
+          std::move(nulls), indices, rows.end(), projection);
+    }
+  }
+
+  // In the case that elementAt is not constant, we will need to stitch together
+  // projected values from across our mapValues list.
+  else {
+    auto result =
+        BaseVector::create(flatMap->valueType(), rows.size(), context.pool());
+    rows.applyToSelected([&](vector_size_t row) {
+      if (auto projection = flatMap->projectKey(elementAt, row)) {
+        result->copy(projection.get(), row, decodedMap.indices()[row], 1);
+      } else {
+        result->setNull(row, true);
+      }
+    });
+    return result;
+  }
+
+  // Key doesn't exist, return null constant vector.
+  return BaseVector::createNullConstant(
+      flatMap->valueType(), rows.end(), context.pool());
+}
+
 VectorPtr applyMapComplexType(
     const SelectivityVector& rows,
-    const VectorPtr& mapArg,
+    const DecodedVector& decodedMap,
     const VectorPtr& indexArg,
     exec::EvalCtx& context,
     bool triggerCaching,
@@ -202,11 +265,9 @@ VectorPtr applyMapComplexType(
   // Create nulls for lazy initialization.
   NullsBuilder nullsBuilder(rows.end(), pool);
 
-  // Get base MapVector.
-  exec::LocalDecodedVector mapHolder(context, *mapArg, rows);
-  auto decodedMap = mapHolder.get();
-  auto baseMap = decodedMap->base()->as<MapVector>();
-  auto mapIndices = decodedMap->indices();
+  // Get base MapVector
+  auto baseMap = decodedMap.base()->as<MapVector>();
+  auto mapIndices = decodedMap.indices();
 
   // Get map keys.
   auto mapKeys = baseMap->mapKeys();
@@ -330,6 +391,16 @@ VectorPtr MapSubscript::applyMap(
   // Ensure map key type and second argument are the same.
   VELOX_CHECK(mapArg->type()->childAt(0)->equivalent(*indexArg->type()));
 
+  // Short-circuit for FlatMapVector encoding. FlatMapVector doesn't need to
+  // distinguish between primitive and complex types (where the former requires
+  // a type dispatch).
+  exec::LocalDecodedVector mapDecoder(context, *mapArg, rows);
+  auto decodedMap = mapDecoder.get();
+  if (decodedMap->base()->encoding() == VectorEncoding::Simple::FLAT_MAP) {
+    return applyFlatMap(rows, *decodedMap, indexArg, context);
+  }
+
+  // Regular map encoding with two paths for complex and primitive types.
   bool triggerCaching = shouldTriggerCaching(mapArg);
   if (indexArg->type()->isPrimitiveType() &&
       !indexArg->type()->providesCustomComparison()) {
@@ -339,7 +410,7 @@ VectorPtr MapSubscript::applyMap(
         triggerCaching,
         lookupTable_,
         rows,
-        mapArg,
+        *decodedMap,
         indexArg,
         context);
   } else {
@@ -349,50 +420,9 @@ VectorPtr MapSubscript::applyMap(
     // Vector's equalValueAt method, which calls the Types custom comparison
     // operator internally.
     return applyMapComplexType(
-        rows, mapArg, indexArg, context, triggerCaching, lookupTable_);
-  }
-}
-
-namespace {
-std::exception_ptr makeZeroSubscriptError() {
-  try {
-    VELOX_USER_FAIL("SQL array indices start at 1");
-  } catch (const std::exception&) {
-    return std::current_exception();
-  }
-}
-
-std::exception_ptr makeBadSubscriptError() {
-  try {
-    VELOX_USER_FAIL("Array subscript out of bounds.");
-  } catch (const std::exception&) {
-    return std::current_exception();
+        rows, *decodedMap, indexArg, context, triggerCaching, lookupTable_);
   }
 }
-
-std::exception_ptr makeNegativeSubscriptError() {
-  try {
-    VELOX_USER_FAIL("Array subscript is negative.");
-  } catch (const std::exception&) {
-    return std::current_exception();
-  }
-}
-} // namespace
-
-const std::exception_ptr& zeroSubscriptError() {
-  static std::exception_ptr error = makeZeroSubscriptError();
-  return error;
-}
-
-const std::exception_ptr& badSubscriptError() {
-  static std::exception_ptr error = makeBadSubscriptError();
-  return error;
-}
-
-const std::exception_ptr& negativeSubscriptError() {
-  static std::exception_ptr error = makeNegativeSubscriptError();
-  return error;
-}
 } // namespace detail
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/lib/SubscriptUtil.h b/velox/functions/lib/SubscriptUtil.h
index adb526d22cd..93de96b5659 100644
--- a/velox/functions/lib/SubscriptUtil.h
+++ b/velox/functions/lib/SubscriptUtil.h
@@ -31,10 +31,8 @@
 namespace facebook::velox::functions {
 
 namespace detail {
-// Below functions return a stock instance of each of the possible errors in
-// SubscriptImpl
-const std::exception_ptr& zeroSubscriptError();
-const std::exception_ptr& badSubscriptError();
+constexpr static inline std::string_view kZeroSubscriptErrorMsg =
+    "SQL array indices start at 1. Got 0.";
 const std::exception_ptr& negativeSubscriptError();
 
 // A flat vector of map keys, an index into that vector and an index into
@@ -277,7 +275,7 @@ class SubscriptImpl : public exec::Subscript {
       default:
         VELOX_UNSUPPORTED(
             "Unsupported type for element_at index {}",
-            mapTypeKindToName(indexArg->typeKind()));
+            TypeKindName::toName(indexArg->typeKind()));
     }
   }
 
@@ -286,22 +284,24 @@ class SubscriptImpl : public exec::Subscript {
 
     // array(T), integer|bigint -> T
     for (const auto& indexType : {"integer", "bigint"}) {
-      signatures.push_back(exec::FunctionSignatureBuilder()
-                               .typeVariable("T")
-                               .returnType("T")
-                               .argumentType("array(T)")
-                               .argumentType(indexType)
-                               .build());
+      signatures.push_back(
+          exec::FunctionSignatureBuilder()
+              .typeVariable("T")
+              .returnType("T")
+              .argumentType("array(T)")
+              .argumentType(indexType)
+              .build());
     }
 
     // map(K,V), K -> V
-    signatures.push_back(exec::FunctionSignatureBuilder()
-                             .typeVariable("K")
-                             .typeVariable("V")
-                             .returnType("V")
-                             .argumentType("map(K,V)")
-                             .argumentType("K")
-                             .build());
+    signatures.push_back(
+        exec::FunctionSignatureBuilder()
+            .typeVariable("K")
+            .typeVariable("V")
+            .returnType("V")
+            .argumentType("map(K,V)")
+            .argumentType("K")
+            .build());
 
     return signatures;
   }
@@ -336,17 +336,25 @@ class SubscriptImpl : public exec::Subscript {
       bool allFailed = false;
       // If index is invalid, capture the error and mark all rows as failed.
       bool isZeroSubscriptError = false;
+      const I originalIndex = decodedIndices->valueAt<I>(0);
       const auto adjustedIndex =
-          adjustIndex(decodedIndices->valueAt<I>(0), isZeroSubscriptError);
+          adjustIndex(originalIndex, isZeroSubscriptError);
       if (isZeroSubscriptError) {
-        context.setErrors(rows, detail::zeroSubscriptError());
+        context.setStatuses(
+            rows, Status::UserError(detail::kZeroSubscriptErrorMsg));
         allFailed = true;
       }
 
       if (!allFailed) {
         rows.applyToSelected([&](auto row) {
           const auto elementIndex = getIndex(
-              adjustedIndex, row, rawSizes, rawOffsets, arrayIndices, context);
+              originalIndex,
+              adjustedIndex,
+              row,
+              rawSizes,
+              rawOffsets,
+              arrayIndices,
+              context);
           rawIndices[row] = elementIndex;
           if (elementIndex == -1) {
             nullsBuilder.setNull(row);
@@ -355,16 +363,23 @@ class SubscriptImpl : public exec::Subscript {
       }
     } else {
       rows.applyToSelected([&](auto row) {
-        const auto originalIndex = decodedIndices->valueAt<I>(row);
+        const I originalIndex = decodedIndices->valueAt<I>(row);
         bool isZeroSubscriptError = false;
         const auto adjustedIndex =
             adjustIndex(originalIndex, isZeroSubscriptError);
         if (isZeroSubscriptError) {
-          context.setVeloxExceptionError(row, detail::zeroSubscriptError());
+          context.setStatus(
+              row, Status::UserError(detail::kZeroSubscriptErrorMsg));
           return;
         }
         const auto elementIndex = getIndex(
-            adjustedIndex, row, rawSizes, rawOffsets, arrayIndices, context);
+            originalIndex,
+            adjustedIndex,
+            row,
+            rawSizes,
+            rawOffsets,
+            arrayIndices,
+            context);
         rawIndices[row] = elementIndex;
         if (elementIndex == -1) {
           nullsBuilder.setNull(row);
@@ -416,7 +431,8 @@ class SubscriptImpl : public exec::Subscript {
   // above).
   template <typename I>
   vector_size_t getIndex(
-      I index,
+      I originalIndex,
+      vector_size_t index,
       vector_size_t row,
       const vector_size_t* rawSizes,
       const vector_size_t* rawOffsets,
@@ -433,7 +449,11 @@ class SubscriptImpl : public exec::Subscript {
           index += arraySize;
         }
       } else {
-        context.setVeloxExceptionError(row, detail::negativeSubscriptError());
+        context.setStatus(
+            row,
+            Status::UserError(
+                "Array subscript index cannot be negative, Index: {}",
+                originalIndex));
         return -1;
       }
     }
@@ -444,7 +464,12 @@ class SubscriptImpl : public exec::Subscript {
       if constexpr (allowOutOfBound) {
         return -1;
       } else {
-        context.setVeloxExceptionError(row, detail::badSubscriptError());
+        context.setStatus(
+            row,
+            Status::UserError(
+                "Array subscript index out of bounds, Index: {} Array size: {}",
+                originalIndex,
+                arraySize));
         return -1;
       }
     }
diff --git a/velox/functions/lib/TDigest.h b/velox/functions/lib/TDigest.h
index 08fddeaace9..aee558a8035 100644
--- a/velox/functions/lib/TDigest.h
+++ b/velox/functions/lib/TDigest.h
@@ -127,6 +127,17 @@ class TDigest {
   double trimmedMean(double lowerQuantileBound, double upperQuantileBound)
       const;
 
+  /// Calculate the Winsorized mean of the digest.
+  /// Values below the lower quantile are replaced with the lower boundary
+  /// value. Values above the upper quantile are replaced with the upper
+  /// boundary value. The mean is then computed on all N values:
+  ///   winsorizedMean = (trimmedSum + countLow * qLow + countHigh * qHigh) / N
+  /// @param lowerQuantileBound Lower quantile bound in [0, 1].
+  /// @param upperQuantileBound Upper quantile bound in [0, 1].
+  /// @return The Winsorized mean of the digest.
+  double winsorizedMean(double lowerQuantileBound, double upperQuantileBound)
+      const;
+
   /// Returns the compression parameter.
   double compression() const {
     return compression_;
@@ -168,6 +179,13 @@ class TDigest {
   static constexpr double kRelativeErrorEpsilon = 1e-4;
 
  private:
+  // Compute the weighted sum and weight of centroids overlapping the index
+  // range [lowerIndex, upperIndex]. Used by both trimmedMean and
+  // winsorizedMean.
+  std::pair<double, double> computeWeightedSumInBounds(
+      double lowerIndex,
+      double upperIndex) const;
+
   void mergeNewValues(std::vector<int16_t>& positions, double compression);
   void merge(
       double compression,
@@ -381,8 +399,15 @@ double TDigest<A>::estimateQuantile(double quantile) const {
   // If the right-most centroid has more than one sample, we still know that one
   // sample occurred at max so we can do some interpolation.
   if (weights_.back() > 1 && totalWeightVal - index <= weights_.back() / 2) {
+    auto halfWeight = weights_.back() / 2;
+    if (halfWeight <= 1) {
+      // When the last centroid has weight <= 2, the interpolation denominator
+      // (halfWeight - 1) is zero or negative. Return max_ since we are at or
+      // past the boundary between the last centroid and max_.
+      return max_;
+    }
     return max_ -
-        (totalWeightVal - index - 1) / (weights_.back() / 2 - 1) *
+        (totalWeightVal - index - 1) / (halfWeight - 1) *
         (max_ - means_.back());
   }
   // In between extremes we interpolate between centroids.
@@ -568,7 +593,7 @@ static_assert(folly::kIsLittleEndian);
 
 template <typename T>
 void write(T value, char*& out) {
-  folly::storeUnaligned(out, value);
+  folly::storeUnaligned<T>(out, value);
   out += sizeof(T);
 }
 
@@ -700,6 +725,36 @@ double TDigest<A>::sum() const {
   return result;
 }
 
+template <typename A>
+std::pair<double, double> TDigest<A>::computeWeightedSumInBounds(
+    double lowerIndex,
+    double upperIndex) const {
+  double weightSoFar{0};
+  double sumInBounds{0};
+  double weightInBounds{0};
+
+  for (size_t i = 0; i < weights_.size(); i++) {
+    double centroidStart{weightSoFar};
+    if (centroidStart >= upperIndex) {
+      break;
+    }
+    double centroidEnd{weightSoFar + weights_[i]};
+
+    double overlapStart{std::max(centroidStart, lowerIndex)};
+    double overlapEnd{std::min(centroidEnd, upperIndex)};
+
+    if (overlapStart < overlapEnd) {
+      double overlap{overlapEnd - overlapStart};
+      sumInBounds += means_[i] * overlap;
+      weightInBounds += overlap;
+    }
+
+    weightSoFar = centroidEnd;
+  }
+
+  return {sumInBounds, weightInBounds};
+}
+
 template <typename A>
 double TDigest<A>::trimmedMean(
     double lowerQuantileBound,
@@ -718,53 +773,74 @@ double TDigest<A>::trimmedMean(
     return std::numeric_limits<double>::quiet_NaN();
   }
 
-  // Special case for full range
   if (lowerQuantileBound == 0 && upperQuantileBound == 1) {
     return sum() / totalWeight();
   }
 
-  // Calculate the trimmed mean
-  double totalWeightVal = totalWeight();
-  double lowerIndex = lowerQuantileBound * totalWeightVal;
-  double upperIndex = upperQuantileBound * totalWeightVal;
+  double totalWeightVal{totalWeight()};
+  double lowerIndex{lowerQuantileBound * totalWeightVal};
+  double upperIndex{upperQuantileBound * totalWeightVal};
 
-  double weightSoFar = 0;
-  double sumInBounds = 0;
-  double weightInBounds = 0;
+  auto [sumInBounds, weightInBounds] =
+      computeWeightedSumInBounds(lowerIndex, upperIndex);
 
-  for (size_t i = 0; i < weights_.size(); i++) {
-    // Check if lower and upper bounds are in the same weight interval
-    if (weightSoFar < lowerIndex && (lowerIndex - weightSoFar) <= weights_[i] &&
-        (upperIndex - weightSoFar) <= weights_[i]) {
-      return means_[i];
-    }
-    // Check if the lower bound is between our current point and the next point
-    else if (
-        weightSoFar < lowerIndex && (lowerIndex - weightSoFar) <= weights_[i]) {
-      double addedWeight = weightSoFar + weights_[i] - lowerIndex;
-      sumInBounds += means_[i] * addedWeight;
-      weightInBounds += addedWeight;
-    }
-    // Check if the upper bound is between our current point and the next point
-    else if (
-        upperIndex > weightSoFar && upperIndex - weightSoFar <= weights_[i]) {
-      double addedWeight = upperIndex - weightSoFar;
-      sumInBounds += means_[i] * addedWeight;
-      weightInBounds += addedWeight;
-      return sumInBounds / weightInBounds;
-    }
-    // Check if we are somewhere in between the lower and upper bounds
-    else if (lowerIndex <= weightSoFar && weightSoFar <= upperIndex) {
-      sumInBounds += means_[i] * weights_[i];
-      weightInBounds += weights_[i];
-    }
-    weightSoFar += weights_[i];
-  }
   if (weightInBounds > 0) {
     return sumInBounds / weightInBounds;
   }
-
   return std::numeric_limits<double>::quiet_NaN();
 }
 
+template <typename A>
+double TDigest<A>::winsorizedMean(
+    double lowerQuantileBound,
+    double upperQuantileBound) const {
+  VELOX_CHECK_GE(lowerQuantileBound, 0.0, "Lower quantile bound must be >= 0");
+  VELOX_CHECK_LE(lowerQuantileBound, 1.0, "Lower quantile bound must be <= 1");
+  VELOX_CHECK_GE(upperQuantileBound, 0.0, "Upper quantile bound must be >= 0");
+  VELOX_CHECK_LE(upperQuantileBound, 1.0, "Upper quantile bound must be <= 1");
+  VELOX_CHECK_LE(
+      lowerQuantileBound,
+      upperQuantileBound,
+      "Lower quantile bound must be less than or equal to upper quantile bound");
+
+  if (weights_.size() == 0) {
+    return std::numeric_limits<double>::quiet_NaN();
+  }
+
+  if (lowerQuantileBound == 0 && upperQuantileBound == 1) {
+    return sum() / totalWeight();
+  }
+
+  double totalWeightVal{totalWeight()};
+  double lowerIndex{lowerQuantileBound * totalWeightVal};
+  double upperIndex{upperQuantileBound * totalWeightVal};
+
+  // Note: estimateQuantile() uses half-weight interpolation within each
+  // centroid, while the centroid walk below uses raw weight boundaries.
+  // This is a known approximation inherent to the TDigest sketch — the
+  // boundary values and weight partitioning operate under subtly different
+  // geometric assumptions, but the error is bounded by the centroid size
+  // at the tails, which is small by design.
+
+  auto [sumInBounds, weightInBounds] =
+      computeWeightedSumInBounds(lowerIndex, upperIndex);
+
+  // Replace tails with boundary values instead of discarding them.
+  double lowerTailWeight{lowerIndex};
+  double upperTailWeight{totalWeightVal - upperIndex};
+
+  // Guard: skip estimateQuantile when tail weight is zero to avoid
+  // 0 * NaN/Inf = NaN from floating-point edge cases.
+  double lowerContrib{
+      lowerTailWeight > 0
+          ? lowerTailWeight * estimateQuantile(lowerQuantileBound)
+          : 0.0};
+  double upperContrib{
+      upperTailWeight > 0
+          ? upperTailWeight * estimateQuantile(upperQuantileBound)
+          : 0.0};
+
+  return (sumInBounds + lowerContrib + upperContrib) / totalWeightVal;
+}
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/lib/TimeUtils.h b/velox/functions/lib/TimeUtils.h
index 424a4ba3d3a..4e1c1908d26 100644
--- a/velox/functions/lib/TimeUtils.h
+++ b/velox/functions/lib/TimeUtils.h
@@ -27,6 +27,9 @@
 
 namespace facebook::velox::functions {
 
+inline constexpr int64_t kSecondsInMinute = 60;
+inline constexpr int64_t kMinutesInHour = 60;
+inline constexpr int64_t kSecondsInHour = kSecondsInMinute * kMinutesInHour;
 inline constexpr int64_t kSecondsInDay = 86'400;
 inline constexpr int64_t kDaysInWeek = 7;
 extern const folly::F14FastMap<std::string, int8_t> kDayOfWeekNames;
diff --git a/velox/functions/lib/TransformFunctionBase.h b/velox/functions/lib/TransformFunctionBase.h
new file mode 100644
index 00000000000..6f5764d0773
--- /dev/null
+++ b/velox/functions/lib/TransformFunctionBase.h
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/Expr.h"
+#include "velox/expression/VectorFunction.h"
+#include "velox/functions/lib/LambdaFunctionUtil.h"
+
+namespace facebook::velox::functions {
+
+/// Base class for array transform functions.
+/// Subclasses can override addIndexVector() to provide additional lambda
+/// arguments (e.g., element index for Spark's transform function).
+class TransformFunctionBase : public exec::VectorFunction {
+ public:
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& outputType,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    VELOX_CHECK_EQ(args.size(), 2);
+
+    // Flatten input array.
+    exec::LocalDecodedVector arrayDecoder(context, *args[0], rows);
+    auto& decodedArray = *arrayDecoder.get();
+
+    auto flatArray = flattenArray(rows, args[0], decodedArray);
+
+    auto numElements = flatArray->elements()->size();
+    std::vector<VectorPtr> lambdaArgs = {flatArray->elements()};
+
+    // Allow subclasses to add additional lambda arguments (e.g., index vector).
+    addIndexVector(args, flatArray, numElements, context, lambdaArgs);
+
+    SelectivityVector validRowsInReusedResult =
+        toElementRows<ArrayVector>(numElements, rows, flatArray.get());
+
+    // Transformed elements.
+    VectorPtr newElements;
+
+    // Apply lambda to elements.
+    applyLambdaToElements<ArrayVector>(
+        args[1],
+        rows,
+        numElements,
+        flatArray,
+        lambdaArgs,
+        validRowsInReusedResult,
+        context,
+        newElements);
+
+    // Set nulls for rows not present in 'rows'.
+    BufferPtr newNulls = addNullsForUnselectedRows(flatArray, rows);
+
+    VectorPtr localResult = std::make_shared<ArrayVector>(
+        flatArray->pool(),
+        outputType,
+        std::move(newNulls),
+        rows.end(),
+        flatArray->offsets(),
+        flatArray->sizes(),
+        newElements);
+    context.moveOrCopyResult(localResult, rows, result);
+  }
+
+  /// Returns the base signature: array(T), function(T, U) -> array(U).
+  /// Subclasses can call this and add additional signatures.
+  static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
+    return {exec::FunctionSignatureBuilder()
+                .typeVariable("T")
+                .typeVariable("U")
+                .returnType("array(U)")
+                .argumentType("array(T)")
+                .argumentType("function(T, U)")
+                .build()};
+  }
+
+ protected:
+  /// Override this method to add additional arguments to the lambda.
+  /// Default implementation does nothing (element-only transform).
+  /// @param args The original function arguments.
+  /// @param flatArray The flattened input array.
+  /// @param numElements Total number of elements across all arrays.
+  /// @param context The evaluation context.
+  /// @param lambdaArgs Output vector to append additional arguments to.
+  virtual void addIndexVector(
+      const std::vector<VectorPtr>& /*args*/,
+      const ArrayVectorPtr& /*flatArray*/,
+      vector_size_t /*numElements*/,
+      exec::EvalCtx& /*context*/,
+      std::vector<VectorPtr>& /*lambdaArgs*/) const {}
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/XORShiftRandom.h b/velox/functions/lib/XORShiftRandom.h
new file mode 100644
index 00000000000..a6105ff0d1b
--- /dev/null
+++ b/velox/functions/lib/XORShiftRandom.h
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cstdint>
+
+namespace facebook::velox::functions {
+
+/// XORShift random number generator matching Spark's XORShiftRandom.
+/// Based on Marsaglia, G. (2003). Xorshift RNGs. Journal of Statistical
+/// Software, Vol. 8, Issue 14.
+///
+/// Spark hashes the seed with MurmurHash3 before use. This implementation
+/// matches that behavior for reproducibility.
+class XORShiftRandom {
+ public:
+  XORShiftRandom() = default;
+
+  void setSeed(int64_t seed) {
+    seed_ = hashSeed(seed);
+  }
+
+  /// Returns a random 32-bit integer (like Java's nextInt() with no argument).
+  int32_t nextInt() {
+    return next(32);
+  }
+
+  /// Returns a random integer in [0, bound) using Java's algorithm.
+  int32_t nextInt(int32_t bound) {
+    return static_cast<int32_t>(
+        (static_cast<uint32_t>(next(31)) * static_cast<uint64_t>(bound)) >> 31);
+  }
+
+  /// Returns a random double in [0.0, 1.0) matching Java's Random.nextDouble().
+  /// Uses 53 bits of randomness (26 + 27) to fill the mantissa of a double.
+  /// @see
+  /// https://github.com/openjdk/jdk/blob/master/src/java.base/share/classes/java/util/Random.java
+  double nextDouble() {
+    int64_t bits =
+        (static_cast<int64_t>(next(26)) << 27) + static_cast<int64_t>(next(27));
+    return static_cast<double>(bits) / static_cast<double>(1LL << 53);
+  }
+
+ private:
+  /// Generates the next random bits.
+  int32_t next(int32_t bits) {
+    int64_t nextSeed = seed_ ^ (seed_ << 21);
+    nextSeed ^= (static_cast<uint64_t>(nextSeed) >> 35);
+    nextSeed ^= (nextSeed << 4);
+    seed_ = nextSeed;
+    return static_cast<int32_t>(nextSeed & ((1LL << bits) - 1));
+  }
+
+  /// Hashes the seed using MurmurHash3 to distribute bits, matching Spark's
+  /// XORShiftRandom.hashSeed().
+  static int64_t hashSeed(int64_t seed) {
+    // Convert seed to bytes in big-endian order (Java's ByteBuffer default).
+    uint8_t bytes[8];
+    for (int i = 0; i < 8; ++i) {
+      bytes[i] = static_cast<uint8_t>((seed >> (56 - i * 8)) & 0xFF);
+    }
+    // Spark uses MurmurHash3.arraySeed (0x3c074a61) as initial seed.
+    int32_t lowBits = murmurHash3(bytes, 8, 0x3c074a61);
+    int32_t highBits = murmurHash3(bytes, 8, lowBits);
+    return (static_cast<int64_t>(highBits) << 32) |
+        (static_cast<int64_t>(lowBits) & 0xFFFFFFFFL);
+  }
+
+  /// MurmurHash3 32-bit implementation matching Scala's MurmurHash3.bytesHash.
+  static int32_t murmurHash3(const uint8_t* data, int32_t len, int32_t seed) {
+    constexpr uint32_t c1 = 0xcc9e2d51;
+    constexpr uint32_t c2 = 0x1b873593;
+
+    uint32_t h1 = seed;
+    int32_t i = 0;
+
+    // Body: process 4-byte chunks.
+    while (i + 4 <= len) {
+      uint32_t k1 = static_cast<uint32_t>(data[i]) |
+          (static_cast<uint32_t>(data[i + 1]) << 8) |
+          (static_cast<uint32_t>(data[i + 2]) << 16) |
+          (static_cast<uint32_t>(data[i + 3]) << 24);
+      k1 *= c1;
+      k1 = rotl32(k1, 15);
+      k1 *= c2;
+      h1 ^= k1;
+      h1 = rotl32(h1, 13);
+      h1 = h1 * 5 + 0xe6546b64;
+      i += 4;
+    }
+
+    // Tail: process remaining bytes.
+    uint32_t k1 = 0;
+    switch (len - i) {
+      case 3:
+        k1 ^= static_cast<uint32_t>(data[i + 2]) << 16;
+        [[fallthrough]];
+      case 2:
+        k1 ^= static_cast<uint32_t>(data[i + 1]) << 8;
+        [[fallthrough]];
+      case 1:
+        k1 ^= static_cast<uint32_t>(data[i]);
+        k1 *= c1;
+        k1 = rotl32(k1, 15);
+        k1 *= c2;
+        h1 ^= k1;
+        break;
+      default:
+        break;
+    }
+
+    // Finalization.
+    h1 ^= len;
+    h1 = fmix32(h1);
+    return static_cast<int32_t>(h1);
+  }
+
+  static uint32_t rotl32(uint32_t x, int r) {
+    return (x << r) | (x >> (32 - r));
+  }
+
+  static uint32_t fmix32(uint32_t h) {
+    h ^= h >> 16;
+    h *= 0x85ebca6b;
+    h ^= h >> 13;
+    h *= 0xc2b2ae35;
+    h ^= h >> 16;
+    return h;
+  }
+
+  int64_t seed_{0};
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/aggregates/ApproxPercentileAggregateBase.h b/velox/functions/lib/aggregates/ApproxPercentileAggregateBase.h
new file mode 100644
index 00000000000..e4189171a20
--- /dev/null
+++ b/velox/functions/lib/aggregates/ApproxPercentileAggregateBase.h
@@ -0,0 +1,910 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/base/RandomUtil.h"
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/exec/Aggregate.h"
+#include "velox/functions/lib/KllSketch.h"
+#include "velox/vector/ConstantVector.h"
+#include "velox/vector/DecodedVector.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::functions::aggregate {
+
+namespace detail {
+
+/// Type traits: selects NaN-aware comparator for floating-point types,
+/// and std::less for other types.
+template <typename T, typename Allocator>
+struct KllSketchTypeTraits {
+  using KllSketchType = functions::kll::KllSketch<T, Allocator, std::less<T>>;
+};
+
+template <>
+struct KllSketchTypeTraits<float, StlAllocator<float>> {
+  using KllSketchType = functions::kll::KllSketch<
+      float,
+      StlAllocator<float>,
+      util::floating_point::NaNAwareLessThan<float>>;
+};
+
+template <>
+struct KllSketchTypeTraits<double, StlAllocator<double>> {
+  using KllSketchType = functions::kll::KllSketch<
+      double,
+      StlAllocator<double>,
+      util::floating_point::NaNAwareLessThan<double>>;
+};
+
+template <>
+struct KllSketchTypeTraits<float, std::allocator<float>> {
+  using KllSketchType = functions::kll::KllSketch<
+      float,
+      std::allocator<float>,
+      util::floating_point::NaNAwareLessThan<float>>;
+};
+
+template <>
+struct KllSketchTypeTraits<double, std::allocator<double>> {
+  using KllSketchType = functions::kll::KllSketch<
+      double,
+      std::allocator<double>,
+      util::floating_point::NaNAwareLessThan<double>>;
+};
+
+template <typename T, typename Allocator = StlAllocator<T>>
+using KllSketch = typename KllSketchTypeTraits<T, Allocator>::KllSketchType;
+
+template <typename T>
+using KllView = functions::kll::detail::View<T>;
+
+inline unsigned getRandomSeed(std::optional<uint32_t> fixedRandomSeed) {
+  return fixedRandomSeed.has_value() ? *fixedRandomSeed : random::getSeed();
+}
+
+/// Aggregate accumulator for KllSketch, supporting weighted insertions
+/// with optimization for large weight values.
+template <typename T>
+struct KllSketchAccumulator {
+  explicit KllSketchAccumulator(
+      HashStringAllocator* allocator,
+      std::optional<uint32_t> fixedRandomSeed)
+      : sketch_(
+            functions::kll::kDefaultK,
+            StlAllocator<T>(allocator),
+            getRandomSeed(fixedRandomSeed)),
+        largeCountValues_(StlAllocator<std::pair<T, int64_t>>(allocator)) {}
+
+  /// Sets the accuracy of the sketch using the given epsilon value.
+  /// The epsilon value is a double in (0, 1] representing the error bound.
+  void setAccuracy(double epsilon) {
+    sketch_.setK(functions::kll::kFromEpsilon(epsilon));
+  }
+
+  void append(T value) {
+    sketch_.insert(value);
+  }
+
+  void append(
+      T value,
+      int64_t count,
+      HashStringAllocator* allocator,
+      std::optional<uint32_t> fixedRandomSeed) {
+    constexpr size_t kMaxBufferSize = 4096;
+    constexpr int64_t kMinCountToBuffer = 512;
+    if (count < kMinCountToBuffer) {
+      for (int i = 0; i < count; ++i) {
+        sketch_.insert(value);
+      }
+    } else {
+      largeCountValues_.emplace_back(value, count);
+      if (largeCountValues_.size() >= kMaxBufferSize) {
+        flush(allocator, fixedRandomSeed);
+      }
+    }
+  }
+
+  void append(const KllView<T>& view) {
+    sketch_.mergeViews(folly::Range(&view, 1));
+  }
+
+  void append(const std::vector<KllView<T>>& views) {
+    sketch_.mergeViews(views);
+  }
+
+  // Creates a copy of the KllSketch, merges the largeCountValues_ into it,
+  // compacts it, and returns it.
+  // Makes a copy so that uses std::allocator so that this is safe to call
+  // during spilling which may run in parallel.  HashStringAllocator is not
+  // thread safe, so merging into/compacting the original KllSketch which
+  // depends on it can lead to concurrency bugs.
+  KllSketch<T, std::allocator<T>> compact(
+      std::optional<uint32_t> fixedRandomSeed) const {
+    KllSketch<T, std::allocator<T>> newSketch =
+        KllSketch<T, std::allocator<T>>::fromView(
+            sketch_.toView(),
+            std::allocator<T>(),
+            getRandomSeed(fixedRandomSeed));
+
+    mergeLargeCountValuesIntoSketch(
+        std::allocator<T>(), newSketch, fixedRandomSeed);
+
+    newSketch.compact();
+
+    return newSketch;
+  }
+
+  const KllSketch<T>& getSketch() const {
+    return sketch_;
+  }
+
+  // This must be called before the KllSketch can be used for estimateQuantile()
+  // or estimateQuantiles().
+  void flush(
+      HashStringAllocator* allocator,
+      std::optional<uint32_t> fixedRandomSeed) {
+    mergeLargeCountValuesIntoSketch(
+        StlAllocator<T>(allocator), sketch_, fixedRandomSeed);
+    largeCountValues_.clear();
+
+    sketch_.finish();
+  }
+
+ private:
+  template <typename Allocator, typename Compare>
+  void mergeLargeCountValuesIntoSketch(
+      const Allocator& allocator,
+      functions::kll::KllSketch<T, Allocator, Compare>& sketch,
+      std::optional<uint32_t> fixedRandomSeed) const {
+    if (!largeCountValues_.empty()) {
+      std::vector<functions::kll::KllSketch<T, Allocator, Compare>> sketches;
+      sketches.reserve(largeCountValues_.size());
+      for (auto [x, n] : largeCountValues_) {
+        sketches.push_back(
+            functions::kll::KllSketch<T, Allocator, Compare>::fromRepeatedValue(
+                x, n, sketch_.k(), allocator, getRandomSeed(fixedRandomSeed)));
+      }
+      sketch.merge(folly::Range(sketches.begin(), sketches.end()));
+    }
+  }
+
+  KllSketch<T> sketch_;
+  std::vector<std::pair<T, int64_t>, StlAllocator<std::pair<T, int64_t>>>
+      largeCountValues_;
+};
+
+} // namespace detail
+
+enum class ApproxPercentileIntermediateTypeChildIndex {
+  kPercentiles = 0,
+  kPercentilesIsArray = 1,
+  kAccuracy = 2,
+  kK = 3,
+  kN = 4,
+  kMinValue = 5,
+  kMaxValue = 6,
+  kItems = 7,
+  kLevels = 8,
+};
+
+template <
+    typename T,
+    bool kHasWeight,
+    typename AccuracyPolicy,
+    typename AccuracyIntermediateType = double>
+class ApproxPercentileAggregateBase : public exec::Aggregate {
+ public:
+  ApproxPercentileAggregateBase(
+      bool hasWeight,
+      bool hasAccuracy,
+      const TypePtr& resultType,
+      std::optional<uint32_t> fixedRandomSeed)
+      : exec::Aggregate(resultType),
+        hasWeight_(hasWeight),
+        hasAccuracy_(hasAccuracy),
+        fixedRandomSeed_(fixedRandomSeed) {}
+
+  struct Percentiles {
+    std::vector<double> values;
+    bool isArray;
+  };
+
+  int32_t accumulatorFixedWidthSize() const override {
+    return sizeof(detail::KllSketchAccumulator<T>);
+  }
+
+  bool isFixedSize() const override {
+    return false;
+  }
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodeArguments(rows, args);
+
+    if (kHasWeight && hasWeight_) {
+      rows.applyToSelected([&](auto row) {
+        if (decodedValue_.isNullAt(row) || decodedWeight_.isNullAt(row)) {
+          return;
+        }
+
+        auto tracker = trackRowSize(groups[row]);
+        auto accumulator = initRawAccumulator(groups[row]);
+        auto value = decodedValue_.valueAt<T>(row);
+        auto weight = decodedWeight_.valueAt<int64_t>(row);
+        checkWeight(weight);
+        accumulator->append(value, weight, allocator_, fixedRandomSeed_);
+      });
+    } else {
+      if (decodedValue_.mayHaveNulls()) {
+        rows.applyToSelected([&](auto row) {
+          if (decodedValue_.isNullAt(row)) {
+            return;
+          }
+
+          auto accumulator = initRawAccumulator(groups[row]);
+          accumulator->append(decodedValue_.valueAt<T>(row));
+        });
+      } else {
+        rows.applyToSelected([&](auto row) {
+          auto accumulator = initRawAccumulator(groups[row]);
+          accumulator->append(decodedValue_.valueAt<T>(row));
+        });
+      }
+    }
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    addIntermediate<false>(groups, rows, args);
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodeArguments(rows, args);
+
+    auto tracker = trackRowSize(group);
+    auto accumulator = initRawAccumulator(group);
+
+    if (kHasWeight && hasWeight_) {
+      rows.applyToSelected([&](auto row) {
+        if (decodedValue_.isNullAt(row) || decodedWeight_.isNullAt(row)) {
+          return;
+        }
+
+        auto value = decodedValue_.valueAt<T>(row);
+        auto weight = decodedWeight_.valueAt<int64_t>(row);
+        checkWeight(weight);
+        accumulator->append(value, weight, allocator_, fixedRandomSeed_);
+      });
+    } else {
+      if (decodedValue_.mayHaveNulls()) {
+        rows.applyToSelected([&](auto row) {
+          if (decodedValue_.isNullAt(row)) {
+            return;
+          }
+
+          accumulator->append(decodedValue_.valueAt<T>(row));
+        });
+      } else {
+        rows.applyToSelected([&](auto row) {
+          accumulator->append(decodedValue_.valueAt<T>(row));
+        });
+      }
+    }
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    addIntermediate<true>(group, rows, args);
+  }
+
+  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    for (auto i = 0; i < numGroups; ++i) {
+      value<detail::KllSketchAccumulator<T>>(groups[i])->flush(
+          allocator_, fixedRandomSeed_);
+    }
+
+    VELOX_CHECK(result);
+    // When all inputs are nulls or masked out, percentiles_ can be
+    // uninitialized. The result should be nulls in this case.
+    if (!percentiles_.has_value()) {
+      *result = BaseVector::createNullConstant(
+          (*result)->type(), numGroups, (*result)->pool());
+      return;
+    }
+
+    if (percentiles_ && percentiles_->isArray) {
+      folly::Range percentiles(
+          percentiles_->values.begin(), percentiles_->values.end());
+      auto arrayResult = (*result)->asUnchecked<ArrayVector>();
+      vector_size_t elementsCount = 0;
+      for (auto i = 0; i < numGroups; ++i) {
+        char* group = groups[i];
+        auto accumulator = value<detail::KllSketchAccumulator<T>>(group);
+        if (accumulator->getSketch().totalCount() > 0) {
+          elementsCount += percentiles.size();
+        }
+      }
+      arrayResult->elements()->resize(elementsCount);
+      elementsCount = 0;
+      auto rawValues =
+          arrayResult->elements()->asFlatVector<T>()->mutableRawValues();
+      extractHelper(
+          groups,
+          numGroups,
+          arrayResult,
+          [&](const detail::KllSketch<T>& digest,
+              ArrayVector* result,
+              vector_size_t index) {
+            digest.estimateQuantiles(percentiles, rawValues + elementsCount);
+            result->setOffsetAndSize(index, elementsCount, percentiles.size());
+            result->setNull(index, false);
+            elementsCount += percentiles.size();
+          });
+    } else {
+      extractHelper(
+          groups,
+          numGroups,
+          (*result)->asFlatVector<T>(),
+          [&](const detail::KllSketch<T>& digest,
+              FlatVector<T>* result,
+              vector_size_t index) {
+            VELOX_DCHECK_EQ(percentiles_->values.size(), 1);
+            result->set(
+                index, digest.estimateQuantile(percentiles_->values.back()));
+          });
+    }
+  }
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    std::vector<detail::KllSketch<T, std::allocator<T>>> sketches;
+    sketches.reserve(numGroups);
+    for (auto i = 0; i < numGroups; ++i) {
+      sketches.push_back(
+          value<detail::KllSketchAccumulator<T>>(groups[i])->compact(
+              fixedRandomSeed_));
+    }
+
+    VELOX_CHECK(result);
+    auto rowResult = (*result)->as<RowVector>();
+    VELOX_CHECK(rowResult);
+    auto pool = rowResult->pool();
+
+    // percentiles_ can be uninitialized during an intermediate aggregation step
+    // when all input intermediate states are nulls. Result should be nulls in
+    // this case.
+    using Idx = ApproxPercentileIntermediateTypeChildIndex;
+    if (!percentiles_) {
+      rowResult->ensureWritable(SelectivityVector{numGroups});
+      // rowResult->childAt(i) for i = kPercentiles, kPercentilesIsArray, and
+      // kAccuracy are expected to be constant in addIntermediateResults.
+      rowResult->childAt(static_cast<int>(Idx::kPercentiles)) =
+          BaseVector::createNullConstant(ARRAY(DOUBLE()), numGroups, pool);
+      rowResult->childAt(static_cast<int>(Idx::kPercentilesIsArray)) =
+          BaseVector::createNullConstant(BOOLEAN(), numGroups, pool);
+      rowResult->childAt(static_cast<int>(Idx::kAccuracy)) =
+          BaseVector::createNullConstant(
+              CppToType<AccuracyIntermediateType>::create(), numGroups, pool);
+
+      // Set nulls for all rows.
+      auto rawNulls = rowResult->mutableRawNulls();
+      bits::fillBits(rawNulls, 0, rowResult->size(), bits::kNull);
+      return;
+    }
+    auto& values = percentiles_->values;
+    auto size = values.size();
+    auto elements =
+        BaseVector::create<FlatVector<double>>(DOUBLE(), size, pool);
+    std::copy(values.begin(), values.end(), elements->mutableRawValues());
+    auto array = std::make_shared<ArrayVector>(
+        pool,
+        ARRAY(DOUBLE()),
+        nullptr,
+        1,
+        AlignedBuffer::allocate<vector_size_t>(1, pool, 0),
+        AlignedBuffer::allocate<vector_size_t>(1, pool, size),
+        std::move(elements));
+    rowResult->childAt(static_cast<int>(Idx::kPercentiles)) =
+        BaseVector::wrapInConstant(numGroups, 0, std::move(array));
+    rowResult->childAt(static_cast<int>(Idx::kPercentilesIsArray)) =
+        std::make_shared<ConstantVector<bool>>(
+            pool,
+            numGroups,
+            false,
+            BOOLEAN(),
+            static_cast<bool&&>(percentiles_->isArray));
+
+    bool isDefaultAccuracy = AccuracyPolicy::isDefaultAccuracy(accuracy_);
+    auto accuracyIntermediateValue = accuracy_;
+    rowResult->childAt(static_cast<int>(Idx::kAccuracy)) =
+        std::make_shared<ConstantVector<AccuracyIntermediateType>>(
+            pool,
+            numGroups,
+            isDefaultAccuracy,
+            CppToType<AccuracyIntermediateType>::create(),
+            std::move(accuracyIntermediateValue));
+    auto k =
+        rowResult->childAt(static_cast<int>(Idx::kK))->asFlatVector<int32_t>();
+    auto n =
+        rowResult->childAt(static_cast<int>(Idx::kN))->asFlatVector<int64_t>();
+    auto minValue =
+        rowResult->childAt(static_cast<int>(Idx::kMinValue))->asFlatVector<T>();
+    auto maxValue =
+        rowResult->childAt(static_cast<int>(Idx::kMaxValue))->asFlatVector<T>();
+    auto items =
+        rowResult->childAt(static_cast<int>(Idx::kItems))->as<ArrayVector>();
+    auto levels =
+        rowResult->childAt(static_cast<int>(Idx::kLevels))->as<ArrayVector>();
+
+    rowResult->resize(numGroups);
+    k->resize(numGroups);
+    n->resize(numGroups);
+    minValue->resize(numGroups);
+    maxValue->resize(numGroups);
+    items->resize(numGroups);
+    levels->resize(numGroups);
+
+    auto itemsElements = items->elements()->asFlatVector<T>();
+    auto levelsElements = levels->elements()->asFlatVector<int32_t>();
+    size_t itemsCount = 0;
+    vector_size_t levelsCount = 0;
+    for (auto& sketch : sketches) {
+      auto v = sketch.toView();
+      itemsCount += v.items.size();
+      levelsCount += v.levels.size();
+    }
+    VELOX_CHECK_LE(itemsCount, std::numeric_limits<vector_size_t>::max());
+    itemsElements->resetNulls();
+    itemsElements->resize(itemsCount);
+    levelsElements->resetNulls();
+    levelsElements->resize(levelsCount);
+
+    auto rawItems = itemsElements->mutableRawValues();
+    auto rawLevels = levelsElements->mutableRawValues();
+    itemsCount = 0;
+    levelsCount = 0;
+    for (int i = 0; i < sketches.size(); ++i) {
+      auto v = sketches[i].toView();
+      if (v.n == 0) {
+        rowResult->setNull(i, true);
+      } else {
+        rowResult->setNull(i, false);
+        k->set(i, v.k);
+        n->set(i, v.n);
+        minValue->set(i, v.minValue);
+        maxValue->set(i, v.maxValue);
+        std::copy(v.items.begin(), v.items.end(), rawItems + itemsCount);
+        items->setOffsetAndSize(i, itemsCount, v.items.size());
+        itemsCount += v.items.size();
+        std::copy(v.levels.begin(), v.levels.end(), rawLevels + levelsCount);
+        levels->setOffsetAndSize(i, levelsCount, v.levels.size());
+        levelsCount += v.levels.size();
+      }
+    }
+  }
+
+ protected:
+  const bool hasWeight_;
+  const bool hasAccuracy_;
+  const std::optional<uint32_t> fixedRandomSeed_;
+
+  AccuracyIntermediateType accuracy_{AccuracyPolicy::kDefaultAccuracy};
+
+  std::optional<Percentiles> percentiles_;
+  DecodedVector decodedValue_;
+  DecodedVector decodedWeight_;
+  DecodedVector decodedAccuracy_;
+
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    exec::Aggregate::setAllNulls(groups, indices);
+    for (auto i : indices) {
+      auto group = groups[i];
+      new (group + offset_)
+          detail::KllSketchAccumulator<T>(allocator_, fixedRandomSeed_);
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
+    using Accumulator = detail::KllSketchAccumulator<T>;
+    for (auto group : groups) {
+      if (isInitialized(group)) {
+        value<Accumulator>(group)->~Accumulator();
+      }
+    }
+  }
+
+  detail::KllSketchAccumulator<T>* initRawAccumulator(char* group) {
+    auto accumulator = value<detail::KllSketchAccumulator<T>>(group);
+    AccuracyPolicy::setOnAccumulator(accumulator, accuracy_);
+    return accumulator;
+  }
+
+  void decodeArguments(
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args) {
+    size_t argIndex = 0;
+    decodedValue_.decode(*args[argIndex++], rows, true);
+    if (kHasWeight && hasWeight_) {
+      decodedWeight_.decode(*args[argIndex++], rows, true);
+    }
+    checkSetPercentile(rows, *args[argIndex++]);
+    if (hasAccuracy_) {
+      decodedAccuracy_.decode(*args[argIndex++], rows, true);
+      checkSetAccuracy(rows);
+    }
+    VELOX_CHECK_EQ(argIndex, args.size());
+  }
+
+  void checkSetPercentile(
+      const SelectivityVector& rows,
+      const BaseVector& vec) {
+    DecodedVector decoded(vec, rows);
+
+    auto* base = decoded.base();
+    auto baseFirstRow = decoded.index(rows.begin());
+    if (!decoded.isConstantMapping()) {
+      rows.applyToSelected([&](vector_size_t row) {
+        VELOX_USER_CHECK(!decoded.isNullAt(row), "Percentile cannot be null");
+        auto baseRow = decoded.index(row);
+        VELOX_USER_CHECK(
+            base->equalValueAt(base, baseRow, baseFirstRow),
+            "Percentile argument must be constant for all input rows: {} vs. {}",
+            base->toString(baseRow),
+            base->toString(baseFirstRow));
+      });
+    }
+
+    bool isArray;
+    vector_size_t offset;
+    vector_size_t len;
+    if (base->typeKind() == TypeKind::DOUBLE) {
+      isArray = false;
+      if constexpr (kHasWeight) {
+        offset = rows.begin();
+      } else {
+        offset = baseFirstRow;
+      }
+      len = 1;
+    } else if (base->typeKind() == TypeKind::ARRAY) {
+      isArray = true;
+      auto arrays = base->asUnchecked<ArrayVector>();
+      if constexpr (!kHasWeight) {
+        auto actualNullCount = arrays->nulls()
+            ? BaseVector::countNulls(arrays->nulls(), arrays->size())
+            : 0;
+        VELOX_USER_CHECK_EQ(
+            actualNullCount, 0, "Percentile array cannot contain nulls");
+      }
+      decoded.decode(*arrays->elements());
+      offset = arrays->offsetAt(baseFirstRow);
+      len = arrays->sizeAt(baseFirstRow);
+    } else {
+      VELOX_USER_FAIL(
+          "Incorrect type for percentile: {}", base->type()->toString());
+    }
+    checkSetPercentileValues(isArray, decoded, offset, len);
+  }
+
+  void checkSetPercentileValues(
+      bool isArray,
+      const DecodedVector& percentiles,
+      vector_size_t offset,
+      vector_size_t len) {
+    if (!percentiles_) {
+      VELOX_USER_CHECK_GT(len, 0, "Percentile cannot be empty");
+      percentiles_ = {
+          .values = std::vector<double>(len),
+          .isArray = isArray,
+      };
+      for (vector_size_t i = 0; i < len; ++i) {
+        VELOX_USER_CHECK(!percentiles.isNullAt(i), "Percentile cannot be null");
+        auto value = percentiles.valueAt<double>(offset + i);
+        VELOX_USER_CHECK_GE(value, 0, "Percentile must be between 0 and 1");
+        VELOX_USER_CHECK_LE(value, 1, "Percentile must be between 0 and 1");
+        percentiles_->values[i] = value;
+      }
+    } else {
+      VELOX_USER_CHECK_EQ(
+          isArray,
+          percentiles_->isArray,
+          "Percentile argument must be constant for all input rows");
+      VELOX_USER_CHECK_EQ(
+          len,
+          percentiles_->values.size(),
+          "Percentile argument must be constant for all input rows");
+      for (vector_size_t i = 0; i < len; ++i) {
+        VELOX_USER_CHECK_EQ(
+            percentiles.valueAt<double>(offset + i),
+            percentiles_->values[i],
+            "Percentile argument must be constant for all input rows");
+      }
+    }
+  }
+
+  void checkSetPercentileValuesFromVector(
+      bool isArray,
+      const std::vector<double>& percentiles) {
+    vector_size_t len = static_cast<vector_size_t>(percentiles.size());
+    if (!percentiles_) {
+      VELOX_USER_CHECK_GT(len, 0, "Percentile cannot be empty");
+      percentiles_ = {.values = percentiles, .isArray = isArray};
+      for (const auto& val : percentiles) {
+        VELOX_USER_CHECK_GE(val, 0.0, "Percentile must be between 0 and 1");
+        VELOX_USER_CHECK_LE(val, 1.0, "Percentile must be between 0 and 1");
+      }
+    } else {
+      VELOX_USER_CHECK_EQ(
+          isArray, percentiles_->isArray, "Percentile type must be constant");
+      VELOX_USER_CHECK_EQ(
+          len,
+          static_cast<vector_size_t>(percentiles_->values.size()),
+          "Percentile size must be constant");
+      for (vector_size_t i = 0; i < len; ++i) {
+        VELOX_USER_CHECK_EQ(
+            percentiles[i],
+            percentiles_->values[i],
+            "Percentile values must be constant");
+      }
+    }
+  }
+
+  void checkSetAccuracy(const SelectivityVector& rows) {
+    if (!hasAccuracy_) {
+      return;
+    }
+    AccuracyPolicy::checkSetAccuracy(decodedAccuracy_, rows, accuracy_);
+  }
+
+  static void checkWeight(int64_t weight) {
+    constexpr int64_t kMaxWeight = (1ll << 60) - 1;
+    VELOX_USER_CHECK(
+        1 <= weight && weight <= kMaxWeight,
+        "approx_percentile: weight must be in range [1, {}], got {}",
+        kMaxWeight,
+        weight);
+  }
+
+  template <typename VectorType, typename ExtractFunc>
+  void extractHelper(
+      char** groups,
+      int32_t numGroups,
+      VectorType* result,
+      ExtractFunc extractFunction) {
+    VELOX_CHECK(result);
+    result->resize(numGroups);
+
+    uint64_t* rawNulls = nullptr;
+    if (result->mayHaveNulls()) {
+      BufferPtr& nulls = result->mutableNulls(result->size());
+      rawNulls = nulls->asMutable<uint64_t>();
+    }
+
+    for (auto i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      auto accumulator = value<detail::KllSketchAccumulator<T>>(group);
+      if (accumulator->getSketch().totalCount() == 0) {
+        result->setNull(i, true);
+      } else {
+        if (rawNulls) {
+          bits::clearBit(rawNulls, i);
+        }
+        extractFunction(accumulator->getSketch(), result, i);
+      }
+    }
+  }
+
+ private:
+  template <bool kSingleGroup>
+  void addIntermediate(
+      std::conditional_t<kSingleGroup, char*, char**> group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args) {
+    if (validateIntermediateInputs_) {
+      addIntermediateImpl<kSingleGroup, true>(group, rows, args);
+    } else {
+      addIntermediateImpl<kSingleGroup, false>(group, rows, args);
+    }
+  }
+
+  template <bool kSingleGroup, bool checkIntermediateInputs>
+  void addIntermediateImpl(
+      std::conditional_t<kSingleGroup, char*, char**> group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args) {
+    using Idx = ApproxPercentileIntermediateTypeChildIndex;
+    VELOX_CHECK_EQ(args.size(), 1);
+    DecodedVector decoded(*args[0], rows);
+    auto rowVec = decoded.base()->as<RowVector>();
+    if constexpr (checkIntermediateInputs) {
+      VELOX_USER_CHECK(rowVec);
+      if constexpr (kHasWeight) {
+        for (int i = static_cast<int>(Idx::kPercentiles);
+             i <= static_cast<int>(Idx::kAccuracy);
+             ++i) {
+          VELOX_USER_CHECK(rowVec->childAt(i)->isConstantEncoding());
+        }
+      }
+      for (int i = static_cast<int>(Idx::kK);
+           i <= static_cast<int>(Idx::kMaxValue);
+           ++i) {
+        VELOX_USER_CHECK(rowVec->childAt(i)->isFlatEncoding());
+      }
+      for (int i = static_cast<int>(Idx::kItems);
+           i <= static_cast<int>(Idx::kLevels);
+           ++i) {
+        VELOX_USER_CHECK(
+            rowVec->childAt(i)->encoding() == VectorEncoding::Simple::ARRAY);
+      }
+    } else {
+      VELOX_CHECK(rowVec);
+    }
+
+    const SelectivityVector* baseRows = &rows;
+    SelectivityVector innerRows{rowVec->size(), false};
+    if (!decoded.isIdentityMapping()) {
+      if (decoded.isConstantMapping()) {
+        innerRows.setValid(decoded.index(0), true);
+        innerRows.updateBounds();
+      } else {
+        velox::translateToInnerRows(
+            rows, decoded.indices(), decoded.nulls(&rows), innerRows);
+      }
+      baseRows = &innerRows;
+    }
+
+    DecodedVector percentiles(
+        *rowVec->childAt(static_cast<int>(Idx::kPercentiles)), *baseRows);
+    auto percentileIsArray =
+        rowVec->childAt(static_cast<int>(Idx::kPercentilesIsArray))
+            ->asUnchecked<SimpleVector<bool>>();
+    auto accuracy = rowVec->childAt(static_cast<int>(Idx::kAccuracy))
+                        ->asUnchecked<SimpleVector<AccuracyIntermediateType>>();
+    auto k = rowVec->childAt(static_cast<int>(Idx::kK))
+                 ->asUnchecked<SimpleVector<int32_t>>();
+    auto n = rowVec->childAt(static_cast<int>(Idx::kN))
+                 ->asUnchecked<SimpleVector<int64_t>>();
+    auto minValue = rowVec->childAt(static_cast<int>(Idx::kMinValue))
+                        ->asUnchecked<SimpleVector<T>>();
+    auto maxValue = rowVec->childAt(static_cast<int>(Idx::kMaxValue))
+                        ->asUnchecked<SimpleVector<T>>();
+    auto items = rowVec->childAt(static_cast<int>(Idx::kItems))
+                     ->asUnchecked<ArrayVector>();
+    auto levels = rowVec->childAt(static_cast<int>(Idx::kLevels))
+                      ->asUnchecked<ArrayVector>();
+
+    auto itemsElements = items->elements()->asFlatVector<T>();
+    auto levelElements = levels->elements()->asFlatVector<int32_t>();
+    if constexpr (checkIntermediateInputs) {
+      VELOX_USER_CHECK(itemsElements);
+      VELOX_USER_CHECK(levelElements);
+    } else {
+      VELOX_CHECK(itemsElements);
+      VELOX_CHECK(levelElements);
+    }
+    auto rawItems = itemsElements->rawValues();
+    auto rawLevels = levelElements->rawValues<uint32_t>();
+
+    detail::KllSketchAccumulator<T>* accumulator = nullptr;
+    std::vector<detail::KllView<T>> views;
+    if constexpr (kSingleGroup) {
+      views.reserve(rows.end());
+    }
+    rows.applyToSelected([&](auto row) {
+      if (decoded.isNullAt(row)) {
+        return;
+      }
+      int i = decoded.index(row);
+      if (percentileIsArray->isNullAt(i)) {
+        return;
+      }
+      if (!accumulator) {
+        if constexpr (kHasWeight) {
+          int indexInBaseVector = percentiles.index(i);
+          auto percentilesBase = percentiles.base()->asUnchecked<ArrayVector>();
+          auto percentileBaseElements =
+              percentilesBase->elements()->asFlatVector<double>();
+          if constexpr (checkIntermediateInputs) {
+            VELOX_USER_CHECK(percentileBaseElements);
+            VELOX_USER_CHECK(!percentilesBase->isNullAt(indexInBaseVector));
+          }
+
+          bool isArray = percentileIsArray->valueAt(i);
+          DecodedVector decodedElements(*percentilesBase->elements());
+          checkSetPercentileValues(
+              isArray,
+              decodedElements,
+              percentilesBase->offsetAt(indexInBaseVector),
+              percentilesBase->sizeAt(indexInBaseVector));
+        } else {
+          auto pctArrayVec = percentiles.base()->asUnchecked<ArrayVector>();
+          auto pctElementsVec =
+              pctArrayVec->elements()->asUnchecked<FlatVector<double>>();
+          int32_t pctOffset = pctArrayVec->offsetAt(percentiles.index(i));
+          int32_t pctSize = pctArrayVec->sizeAt(percentiles.index(i));
+          std::vector<double> pctVals(pctSize);
+          for (int32_t j = 0; j < pctSize; ++j) {
+            pctVals[j] = pctElementsVec->valueAt(pctOffset + j);
+          }
+          checkSetPercentileValuesFromVector(
+              percentileIsArray->valueAt(i), pctVals);
+        }
+
+        if (!accuracy->isNullAt(i)) {
+          AccuracyPolicy::checkAndSetFromIntermediate(
+              accuracy_, accuracy->valueAt(i));
+        }
+      }
+      if constexpr (kSingleGroup) {
+        if (!accumulator) {
+          accumulator = initRawAccumulator(group);
+        }
+      } else {
+        accumulator = initRawAccumulator(group[row]);
+      }
+
+      if constexpr (checkIntermediateInputs) {
+        VELOX_USER_CHECK(
+            !(k->isNullAt(i) || n->isNullAt(i) || minValue->isNullAt(i) ||
+              maxValue->isNullAt(i) || items->isNullAt(i) ||
+              levels->isNullAt(i)));
+      }
+      detail::KllView<T> v{
+          .k = static_cast<uint32_t>(k->valueAt(i)),
+          .n = static_cast<size_t>(n->valueAt(i)),
+          .minValue = minValue->valueAt(i),
+          .maxValue = maxValue->valueAt(i),
+          .items =
+              {rawItems + items->offsetAt(i),
+               static_cast<size_t>(items->sizeAt(i))},
+          .levels =
+              {rawLevels + levels->offsetAt(i),
+               static_cast<size_t>(levels->sizeAt(i))},
+      };
+      if constexpr (kSingleGroup) {
+        views.push_back(v);
+      } else {
+        auto tracker = trackRowSize(group[row]);
+        accumulator->append(v);
+      }
+    });
+    if constexpr (kSingleGroup) {
+      if (!views.empty()) {
+        auto tracker = trackRowSize(group);
+        accumulator->append(views);
+      }
+    }
+  }
+};
+
+} // namespace facebook::velox::functions::aggregate
diff --git a/velox/functions/lib/aggregates/BitwiseAggregateBase.h b/velox/functions/lib/aggregates/BitwiseAggregateBase.h
index 972ae40c0ad..224231ef571 100644
--- a/velox/functions/lib/aggregates/BitwiseAggregateBase.h
+++ b/velox/functions/lib/aggregates/BitwiseAggregateBase.h
@@ -70,8 +70,9 @@ class BitwiseAggregateBase : public SimpleNumericAggregate<T, T, T> {
 };
 
 template <template <typename U> class T>
-exec::AggregateRegistrationResult registerBitwise(
-    const std::string& name,
+std::vector<exec::AggregateRegistrationResult> registerBitwise(
+    const std::vector<std::string>& names,
+    bool ignoreDuplicates,
     bool withCompanionFunctions,
     bool onlyPrestoSignatures,
     bool overwrite) {
@@ -81,21 +82,23 @@ exec::AggregateRegistrationResult registerBitwise(
     typeList = {"bigint"};
   }
   for (const auto& inputType : typeList) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType(inputType)
-                             .intermediateType(inputType)
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType(inputType)
+            .intermediateType(inputType)
+            .argumentType(inputType)
+            .build());
   }
 
   return exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
+      [names](
           core::AggregationNode::Step /*step*/,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
           const core::QueryConfig& config) -> std::unique_ptr<exec::Aggregate> {
+        const std::string& name = names.front();
         VELOX_CHECK_LE(argTypes.size(), 1, "{} takes only one argument", name);
         auto inputType = argTypes[0];
         switch (inputType->kind()) {
@@ -114,7 +117,7 @@ exec::AggregateRegistrationResult registerBitwise(
                 inputType->kindName());
         }
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.ignoreDuplicates = ignoreDuplicates, .orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/lib/aggregates/CMakeLists.txt b/velox/functions/lib/aggregates/CMakeLists.txt
index fcd4662063b..75e89dd8d66 100644
--- a/velox/functions/lib/aggregates/CMakeLists.txt
+++ b/velox/functions/lib/aggregates/CMakeLists.txt
@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+add_subdirectory(noisy_aggregation)
+
 velox_add_library(
   velox_functions_aggregates
   AverageAggregateBase.cpp
@@ -23,6 +25,24 @@ velox_add_library(
   ValueList.cpp
   ValueSet.cpp
   VarianceAggregatesBase.cpp
+  HEADERS
+  ApproxPercentileAggregateBase.h
+  AverageAggregateBase.h
+  BitwiseAggregateBase.h
+  CentralMomentsAggregatesBase.h
+  Compare.h
+  CovarianceAggregatesBase.h
+  DecimalAggregate.h
+  MinMaxAggregateBase.h
+  MinMaxByAggregatesBase.h
+  SetBaseAggregate.h
+  SimpleNumericAggregate.h
+  SingleValueAccumulator.h
+  SumAggregateBase.h
+  ValueList.h
+  ValueSet.h
+  VarianceAggregatesBase.h
+  noisy_aggregation/NoisyCountSumAvgAccumulator.h
 )
 
 velox_link_libraries(velox_functions_aggregates velox_exec velox_presto_serializer Folly::folly)
diff --git a/velox/functions/lib/aggregates/CentralMomentsAggregatesBase.h b/velox/functions/lib/aggregates/CentralMomentsAggregatesBase.h
index e44d0077e41..237b9389cef 100644
--- a/velox/functions/lib/aggregates/CentralMomentsAggregatesBase.h
+++ b/velox/functions/lib/aggregates/CentralMomentsAggregatesBase.h
@@ -384,9 +384,6 @@ class CentralMomentsAggregatesBase : public exec::Aggregate {
       override {
     auto rowVector = (*result)->as<RowVector>();
     rowVector->resize(numGroups);
-    for (auto& child : rowVector->children()) {
-      child->resize(numGroups);
-    }
 
     uint64_t* rawNulls = getRawNulls(rowVector);
 
diff --git a/velox/functions/lib/aggregates/Compare.cpp b/velox/functions/lib/aggregates/Compare.cpp
index 469a9cd347b..774cecdef4b 100644
--- a/velox/functions/lib/aggregates/Compare.cpp
+++ b/velox/functions/lib/aggregates/Compare.cpp
@@ -28,7 +28,7 @@ int32_t compare(
       result.has_value(),
       fmt::format(
           "{} comparison not supported for values that contain nulls",
-          mapTypeKindToName(decoded.base()->typeKind())));
+          TypeKindName::toName(decoded.base()->typeKind())));
   return result.value();
 }
 } // namespace facebook::velox::functions::aggregate
diff --git a/velox/functions/lib/aggregates/CovarianceAggregatesBase.h b/velox/functions/lib/aggregates/CovarianceAggregatesBase.h
index 64a9b1b8b6a..55adb218ac6 100644
--- a/velox/functions/lib/aggregates/CovarianceAggregatesBase.h
+++ b/velox/functions/lib/aggregates/CovarianceAggregatesBase.h
@@ -350,9 +350,6 @@ class CovarianceAggregate : public exec::Aggregate {
       override {
     auto rowVector = (*result)->as<RowVector>();
     rowVector->resize(numGroups);
-    for (auto& child : rowVector->children()) {
-      child->resize(numGroups);
-    }
 
     uint64_t* rawNulls = getRawNulls(rowVector);
 
diff --git a/velox/functions/lib/aggregates/DecimalAggregate.h b/velox/functions/lib/aggregates/DecimalAggregate.h
index 8e78a545d70..aa3f63bac62 100644
--- a/velox/functions/lib/aggregates/DecimalAggregate.h
+++ b/velox/functions/lib/aggregates/DecimalAggregate.h
@@ -59,7 +59,7 @@ struct LongDecimalWithOverflowState {
    * Total size = sizeOf(count) + sizeOf(overflow) + sizeOf(sum)
    *            = 8 + 8 + 16 = 32.
    */
-  inline static size_t serializedSize() {
+  static constexpr size_t serializedSize() {
     return sizeof(int64_t) * 4;
   }
 
diff --git a/velox/functions/lib/aggregates/MinMaxAggregateBase.cpp b/velox/functions/lib/aggregates/MinMaxAggregateBase.cpp
index f3ff997b1bc..9e62083d2cb 100644
--- a/velox/functions/lib/aggregates/MinMaxAggregateBase.cpp
+++ b/velox/functions/lib/aggregates/MinMaxAggregateBase.cpp
@@ -17,12 +17,12 @@
 #include "velox/functions/lib/aggregates/MinMaxAggregateBase.h"
 
 #include <limits>
-#include "velox/exec/AggregationHook.h"
 #include "velox/functions/lib/CheckNestedNulls.h"
 #include "velox/functions/lib/aggregates/Compare.h"
 #include "velox/functions/lib/aggregates/SimpleNumericAggregate.h"
 #include "velox/functions/lib/aggregates/SingleValueAccumulator.h"
 #include "velox/type/FloatingPointUtil.h"
+#include "velox/vector/AggregationHook.h"
 
 namespace facebook::velox::functions::aggregate {
 
@@ -327,7 +327,7 @@ class MinMaxAggregateBase : public exec::Aggregate {
       auto indices = decoded.indices();
       rows.applyToSelected([&](vector_size_t i) {
         velox::functions::checkNestedNulls(
-            decoded, indices, i, throwOnNestedNulls_);
+            decoded, i, indices[i], throwOnNestedNulls_);
       });
     }
 
@@ -406,7 +406,7 @@ class MinMaxAggregateBase : public exec::Aggregate {
 
     rows.applyToSelected([&](vector_size_t i) {
       if (velox::functions::checkNestedNulls(
-              decoded, indices, i, throwOnNestedNulls_)) {
+              decoded, i, indices[i], throwOnNestedNulls_)) {
         return;
       }
 
@@ -427,7 +427,6 @@ class MinMaxAggregateBase : public exec::Aggregate {
       const VectorPtr& arg,
       TCompareTest compareTest) {
     DecodedVector decoded(*arg, rows, true);
-    auto indices = decoded.indices();
     auto baseVector = decoded.base();
     const CompareFlags compareFlags{
         true, // nullsFirst
@@ -436,23 +435,39 @@ class MinMaxAggregateBase : public exec::Aggregate {
         nullHandlingMode};
 
     if (decoded.isConstantMapping()) {
+      vector_size_t baseIndex = decoded.index(0);
       if (velox::functions::checkNestedNulls(
-              decoded, indices, 0, throwOnNestedNulls_)) {
+              decoded, 0, baseIndex, throwOnNestedNulls_)) {
         return;
       }
 
       auto accumulator = value<SingleValueAccumulator>(group);
       if (!accumulator->hasValue() ||
           compareTest(compare(accumulator, decoded, 0, compareFlags))) {
-        accumulator->write(baseVector, indices[0], allocator_);
+        accumulator->write(baseVector, baseIndex, allocator_);
       }
       return;
     }
 
     auto accumulator = value<SingleValueAccumulator>(group);
+    if (decoded.isIdentityMapping()) {
+      rows.applyToSelected([&](vector_size_t i) {
+        if (velox::functions::checkNestedNulls(
+                decoded, i, i, throwOnNestedNulls_)) {
+          return;
+        }
+        if (!accumulator->hasValue() ||
+            compareTest(compare(accumulator, decoded, i, compareFlags))) {
+          accumulator->write(baseVector, i, allocator_);
+        }
+      });
+      return;
+    }
+
+    auto indices = decoded.indices();
     rows.applyToSelected([&](vector_size_t i) {
       if (velox::functions::checkNestedNulls(
-              decoded, indices, i, throwOnNestedNulls_)) {
+              decoded, i, indices[i], throwOnNestedNulls_)) {
         return;
       }
       if (!accumulator->hasValue() ||
@@ -574,10 +589,9 @@ class MinAggregate : public MinMaxAggregateBase {
 };
 
 template <
-    template <typename T>
-    class TSimpleNumericAggregate,
-    template <CompareFlags::NullHandlingMode nullHandlingMode>
-    typename TAggregate>
+    template <typename T> class TSimpleNumericAggregate,
+    template <
+        CompareFlags::NullHandlingMode nullHandlingMode> typename TAggregate>
 exec::AggregateFunctionFactory getMinMaxFunctionFactoryInternal(
     const std::string& name,
     CompareFlags::NullHandlingMode nullHandlingMode,
diff --git a/velox/functions/lib/aggregates/MinMaxByAggregatesBase.h b/velox/functions/lib/aggregates/MinMaxByAggregatesBase.h
index db29a96923d..d269eff5b37 100644
--- a/velox/functions/lib/aggregates/MinMaxByAggregatesBase.h
+++ b/velox/functions/lib/aggregates/MinMaxByAggregatesBase.h
@@ -310,7 +310,7 @@ class MinMaxByAggregateBase : public exec::Aggregate {
     if (decodedValue_.mayHaveNulls() || decodedComparison_.mayHaveNulls()) {
       rows.applyToSelected([&](vector_size_t i) {
         if (checkNestedNulls(
-                decodedComparison_, indices, i, throwOnNestedNulls_)) {
+                decodedComparison_, i, indices[i], throwOnNestedNulls_)) {
           return;
         }
         updateValues(
@@ -324,7 +324,8 @@ class MinMaxByAggregateBase : public exec::Aggregate {
     } else {
       rows.applyToSelected([&](vector_size_t i) {
         if (throwOnNestedNulls_) {
-          checkNestedNulls(decodedComparison_, indices, i, throwOnNestedNulls_);
+          checkNestedNulls(
+              decodedComparison_, i, indices[i], throwOnNestedNulls_);
         }
         updateValues(
             groups[i], decodedValue_, decodedComparison_, i, false, mayUpdate);
@@ -388,12 +389,14 @@ class MinMaxByAggregateBase : public exec::Aggregate {
     // the maximum.
     decodedValue_.decode(*args[0], rows);
     decodedComparison_.decode(*args[1], rows);
-    const auto* indices = decodedComparison_.indices();
 
     if (decodedValue_.isConstantMapping() &&
         decodedComparison_.isConstantMapping()) {
       if (checkNestedNulls(
-              decodedComparison_, indices, 0, throwOnNestedNulls_)) {
+              decodedComparison_,
+              0,
+              decodedComparison_.index(0),
+              throwOnNestedNulls_)) {
         return;
       }
       updateValues(
@@ -403,11 +406,14 @@ class MinMaxByAggregateBase : public exec::Aggregate {
           0,
           decodedValue_.isNullAt(0),
           mayUpdate);
-    } else if (
-        decodedValue_.mayHaveNulls() || decodedComparison_.mayHaveNulls()) {
+      return;
+    }
+
+    const auto* indices = decodedComparison_.indices();
+    if (decodedValue_.mayHaveNulls() || decodedComparison_.mayHaveNulls()) {
       rows.applyToSelected([&](vector_size_t i) {
         if (checkNestedNulls(
-                decodedComparison_, indices, i, throwOnNestedNulls_)) {
+                decodedComparison_, i, indices[i], throwOnNestedNulls_)) {
           return;
         }
         updateValues(
@@ -421,7 +427,8 @@ class MinMaxByAggregateBase : public exec::Aggregate {
     } else {
       rows.applyToSelected([&](vector_size_t i) {
         if (throwOnNestedNulls_) {
-          checkNestedNulls(decodedComparison_, indices, i, throwOnNestedNulls_);
+          checkNestedNulls(
+              decodedComparison_, i, indices[i], throwOnNestedNulls_);
         }
         updateValues(
             group, decodedValue_, decodedComparison_, i, false, mayUpdate);
@@ -573,8 +580,12 @@ class MinMaxByAggregateBase : public exec::Aggregate {
 };
 
 template <
-    template <typename U, typename V, bool B1, class C, bool B2>
-    class Aggregate,
+    template <
+        typename U,
+        typename V,
+        bool B1,
+        class C,
+        bool B2> class Aggregate,
     bool isMaxFunc,
     class Comparator,
     bool compareTypeUsesCustomComparison,
@@ -682,8 +693,12 @@ std::unique_ptr<exec::Aggregate> create(
 }
 
 template <
-    template <typename U, typename V, bool B1, class C, bool B2>
-    class Aggregate,
+    template <
+        typename U,
+        typename V,
+        bool B1,
+        class C,
+        bool B2> class Aggregate,
     class Comparator,
     bool isMaxFunc,
     bool compareTypeUsesCustomComparison = false>
diff --git a/velox/functions/lib/aggregates/SimpleNumericAggregate.h b/velox/functions/lib/aggregates/SimpleNumericAggregate.h
index 2f94fc9a544..a5327ea3c19 100644
--- a/velox/functions/lib/aggregates/SimpleNumericAggregate.h
+++ b/velox/functions/lib/aggregates/SimpleNumericAggregate.h
@@ -16,7 +16,7 @@
 #pragma once
 
 #include "velox/exec/Aggregate.h"
-#include "velox/exec/AggregationHook.h"
+#include "velox/vector/AggregationHook.h"
 #include "velox/vector/DecodedVector.h"
 #include "velox/vector/FlatVector.h"
 #include "velox/vector/LazyVector.h"
diff --git a/velox/functions/lib/aggregates/ValueList.cpp b/velox/functions/lib/aggregates/ValueList.cpp
index 2d602db44c7..8844c698593 100644
--- a/velox/functions/lib/aggregates/ValueList.cpp
+++ b/velox/functions/lib/aggregates/ValueList.cpp
@@ -65,8 +65,9 @@ void ValueList::appendNonNull(
   allocator->extendWrite(dataCurrent_, stream);
   // The stream may have a tail of a previous write.
   const auto initialSize = stream.size();
-  static const exec::ContainerRowSerdeOptions options{};
-  exec::ContainerRowSerde::serialize(values, index, stream, options);
+  // Set isKey to false to avoid unnecessary sorting.
+  static const exec::ContainerRowSerdeOptions kOptions{/*isKey=*/false};
+  exec::ContainerRowSerde::serialize(values, index, stream, kOptions);
   ++size_;
   bytes_ += stream.size() - initialSize;
 
diff --git a/velox/functions/lib/aggregates/ValueSet.cpp b/velox/functions/lib/aggregates/ValueSet.cpp
index ff06f0da35d..cff7b1b9c69 100644
--- a/velox/functions/lib/aggregates/ValueSet.cpp
+++ b/velox/functions/lib/aggregates/ValueSet.cpp
@@ -29,8 +29,9 @@ void ValueSet::write(
     allocator_->extendWrite(position, stream);
   }
 
-  static const exec::ContainerRowSerdeOptions options{};
-  exec::ContainerRowSerde::serialize(vector, index, stream, options);
+  // Set isKey to false to avoid unnecessary sorting.
+  static const exec::ContainerRowSerdeOptions kOptions{/*isKey=*/false};
+  exec::ContainerRowSerde::serialize(vector, index, stream, kOptions);
   allocator_->finishWrite(stream, 0);
 }
 
diff --git a/velox/functions/lib/aggregates/VarianceAggregatesBase.h b/velox/functions/lib/aggregates/VarianceAggregatesBase.h
index 654fa4df695..96424e7321a 100644
--- a/velox/functions/lib/aggregates/VarianceAggregatesBase.h
+++ b/velox/functions/lib/aggregates/VarianceAggregatesBase.h
@@ -87,9 +87,6 @@ class VarianceAggregate : public exec::Aggregate {
     auto m2Vector = rowVector->childAt(kM2Idx)->asFlatVector<double>();
 
     rowVector->resize(numGroups);
-    for (auto& child : rowVector->children()) {
-      child->resize(numGroups);
-    }
     uint64_t* rawNulls = getRawNulls(rowVector);
 
     int64_t* rawCounts = countVector->mutableRawValues();
diff --git a/velox/functions/lib/aggregates/noisy_aggregation/CMakeLists.txt b/velox/functions/lib/aggregates/noisy_aggregation/CMakeLists.txt
new file mode 100644
index 00000000000..a598690b32e
--- /dev/null
+++ b/velox/functions/lib/aggregates/noisy_aggregation/CMakeLists.txt
@@ -0,0 +1,14 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+velox_install_library_headers()
diff --git a/velox/functions/lib/aggregates/noisy_aggregation/NoisyCountSumAvgAccumulator.h b/velox/functions/lib/aggregates/noisy_aggregation/NoisyCountSumAvgAccumulator.h
index 09168f2d21f..d8c2cec0b2b 100644
--- a/velox/functions/lib/aggregates/noisy_aggregation/NoisyCountSumAvgAccumulator.h
+++ b/velox/functions/lib/aggregates/noisy_aggregation/NoisyCountSumAvgAccumulator.h
@@ -107,7 +107,7 @@ class NoisyCountSumAvgAccumulator {
   // sizeof(double) for lowerBound_ value
   // sizeof(double) for upperBound_ value
   // sizeof(bool) for randomSeed_ has_value flag
-  // sizeof(int32_t) for randomSeed_ value
+  // sizeof(int64_t) for randomSeed_ value
   static size_t serializedSize() {
     return sizeof(double) + sizeof(uint64_t) + sizeof(double) + sizeof(bool) +
         sizeof(double) + sizeof(double) + sizeof(bool) + sizeof(int64_t);
@@ -137,7 +137,7 @@ class NoisyCountSumAvgAccumulator {
     std::optional<double> lowerBound = stream.read<double>();
     std::optional<double> upperBound = stream.read<double>();
     bool hasRandomSeed = stream.read<bool>();
-    std::optional<int32_t> randomSeed = stream.read<int64_t>();
+    std::optional<int64_t> randomSeed = stream.read<int64_t>();
     return NoisyCountSumAvgAccumulator(
         sum,
         count,
diff --git a/velox/functions/lib/aggregates/tests/CMakeLists.txt b/velox/functions/lib/aggregates/tests/CMakeLists.txt
index 88e4765bb36..b6beffe0f76 100644
--- a/velox/functions/lib/aggregates/tests/CMakeLists.txt
+++ b/velox/functions/lib/aggregates/tests/CMakeLists.txt
@@ -27,3 +27,5 @@ target_link_libraries(
   GTest::gtest_main
   glog::glog
 )
+
+velox_add_library(velox_lib INTERFACE HEADERS SumTestBase.h)
diff --git a/velox/functions/lib/aggregates/tests/SumTestBase.h b/velox/functions/lib/aggregates/tests/SumTestBase.h
index 4ddf57515f8..29584cb73d0 100644
--- a/velox/functions/lib/aggregates/tests/SumTestBase.h
+++ b/velox/functions/lib/aggregates/tests/SumTestBase.h
@@ -17,10 +17,10 @@
 #include "folly/CPortability.h"
 
 #include "velox/common/base/tests/GTestUtils.h"
-#include "velox/exec/AggregationHook.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+#include "velox/vector/AggregationHook.h"
 
 namespace facebook::velox::functions::aggregate::test {
 
diff --git a/velox/functions/lib/aggregates/tests/utils/AggregationTestBase.cpp b/velox/functions/lib/aggregates/tests/utils/AggregationTestBase.cpp
index 9674cf2ed75..ee430e2fab8 100644
--- a/velox/functions/lib/aggregates/tests/utils/AggregationTestBase.cpp
+++ b/velox/functions/lib/aggregates/tests/utils/AggregationTestBase.cpp
@@ -18,6 +18,9 @@
 #include "velox/common/base/tests/GTestUtils.h"
 
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
+#include "velox/common/testutil/TempFilePath.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
@@ -27,11 +30,10 @@
 #include "velox/exec/AggregateFunctionRegistry.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/Spill.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
-#include "velox/exec/tests/utils/TempFilePath.h"
 #include "velox/expression/Expr.h"
 #include "velox/expression/SignatureBinder.h"
 
+using namespace facebook::velox::common::testutil;
 using facebook::velox::exec::CursorParameters;
 using facebook::velox::exec::test::AssertQueryBuilder;
 using facebook::velox::exec::test::PlanBuilder;
@@ -50,6 +52,14 @@ void enableAbandonPartialAggregation(AssertQueryBuilder& queryBuilder) {
       .maxDrivers(1);
 }
 
+// Companion function names for an aggregate function.
+struct CompanionFunctions {
+  std::string partialFunction;
+  std::string mergeFunction;
+  std::string mergeExtractFunction;
+  std::string extractFunction;
+};
+
 } // namespace
 
 std::vector<RowVectorPtr> AggregationTestBase::makeVectors(
@@ -73,13 +83,14 @@ void AggregationTestBase::SetUp() {
       kHiveConnectorId,
       std::make_shared<config::ConfigBase>(
           std::unordered_map<std::string, std::string>()));
-  connector::registerConnector(hiveConnector);
+  connector::ConnectorRegistry::global().insert(
+      hiveConnector->connectorId(), hiveConnector);
   dwrf::registerDwrfReaderFactory();
 }
 
 void AggregationTestBase::TearDown() {
   dwrf::unregisterDwrfReaderFactory();
-  connector::unregisterConnector(kHiveConnectorId);
+  connector::ConnectorRegistry::global().erase(kHiveConnectorId);
   OperatorTestBase::TearDown();
 }
 
@@ -199,6 +210,29 @@ std::vector<RowVectorPtr> addExtraGroupingKey(
   return newData;
 }
 
+// Given the name of the original aggregate function and the argument types,
+// return the name of the merge_extract companion function with a suffix of the
+// result type. Merge_extract function names with suffixes should only be used
+// when the original aggregate function has multiple signatures with the same
+// intermediate type.
+std::string getMergeExtractFunctionNameWithSuffix(
+    const std::string& name,
+    const std::vector<TypePtr>& argTypes) {
+  auto signatures = exec::getAggregateFunctionSignatures(name);
+  VELOX_CHECK(signatures.has_value());
+
+  for (const auto& signature : signatures.value()) {
+    exec::SignatureBinder binder{*signature, argTypes, TypeCoercer::defaults()};
+    if (binder.tryBind()) {
+      if (auto resolvedType = binder.tryResolveReturnType()) {
+        return exec::CompanionSignatures::mergeExtractFunctionNameWithSuffix(
+            name, signature->returnType());
+      }
+    }
+  }
+  VELOX_UNREACHABLE("Could not find a function bound to argTypes.");
+}
+
 // Given the name of the original aggregation function and the argument types,
 // return the name of the extract companion function with a suffix of the result
 // type. Extract function names with suffixes should only be used when the
@@ -211,7 +245,7 @@ std::string getExtractFunctionNameWithSuffix(
   VELOX_CHECK(signatures.has_value());
 
   for (const auto& signature : signatures.value()) {
-    exec::SignatureBinder binder{*signature, argTypes};
+    exec::SignatureBinder binder{*signature, argTypes, TypeCoercer::defaults()};
     if (binder.tryBind()) {
       if (auto resultType = binder.tryResolveReturnType()) {
         return exec::CompanionSignatures::extractFunctionNameWithSuffix(
@@ -222,12 +256,13 @@ std::string getExtractFunctionNameWithSuffix(
   VELOX_UNREACHABLE("Could not find a function bound to argTypes.");
 }
 
-// Given the `index`-th aggregation expression, e.g., "avg(c0)", return three
-// strings of its partial companion aggregation expression, merge companion
-// aggregation expression, and extract companion expression, e.g.,
-// {"avg_partial(c0)", "avg_merge(a0)", "avg_extract_double(a0)"} when `index`
-// is 0.
-std::tuple<std::string, std::string, std::string> getCompanionAggregates(
+// Given the `index`-th aggregation expression, e.g., "avg(c0)", return the
+// names of its partial companion aggregation expression, merge companion
+// aggregation expression, merge_extract companion expression and extract
+// companion expression, e.g., CompanionFunctions{"avg_partial(c0)",
+// "avg_merge(a0)", "avg_merge_extract_double(a0)", "avg_extract_double(a0)"}
+// when `index` is 0.
+CompanionFunctions getCompanionAggregates(
     column_index_t index,
     const exec::CompanionFunctionSignatureMap& companionFunctions,
     const std::string& functionName,
@@ -241,9 +276,24 @@ std::tuple<std::string, std::string, std::string> getCompanionAggregates(
   auto mergeAggregate = fmt::format(
       "{}(a{})", companionFunctions.merge.front().functionName, index);
 
-  // Construct the extract expression. Rename the result of the extract
-  // expression to be the same as the original aggregation result, so that
-  // post-aggregation projections, if exist, can apply with no change.
+  // Construct the merge_extract expression. Rename the result of the expression
+  // to be the same as the original aggregation result, so that post-aggregation
+  // projections, if exist, can apply with no change.
+  std::string mergeExtractExpression;
+  if (companionFunctions.mergeExtract.size() == 1) {
+    mergeExtractExpression = fmt::format(
+        "{0}(a{1}) as a{1}",
+        companionFunctions.mergeExtract.front().functionName,
+        index);
+  } else {
+    VELOX_CHECK_GT(companionFunctions.mergeExtract.size(), 1);
+    auto mergeExtractFunctionName =
+        getMergeExtractFunctionNameWithSuffix(functionName, argTypes);
+    mergeExtractExpression =
+        fmt::format("{0}(a{1}) as a{1}", mergeExtractFunctionName, index);
+  }
+
+  // Construct the extract expression.
   std::string extractExpression;
   if (companionFunctions.extract.size() == 1) {
     extractExpression = fmt::format(
@@ -257,7 +307,11 @@ std::tuple<std::string, std::string, std::string> getCompanionAggregates(
     extractExpression =
         fmt::format("{0}(a{1}) as a{1}", extractFunctionName, index);
   }
-  return std::make_tuple(partialAggregate, mergeAggregate, extractExpression);
+  return CompanionFunctions{
+      partialAggregate,
+      mergeAggregate,
+      mergeExtractExpression,
+      extractExpression};
 }
 
 // Given a list of aggregation expressions, e.g., {"avg(c0)"}, return a list of
@@ -383,6 +437,7 @@ void AggregationTestBase::testAggregationsWithCompanion(
 
   std::vector<std::string> partialAggregates;
   std::vector<std::string> mergeAggregates;
+  std::vector<std::string> mergeExtractAggregates;
   std::vector<std::string> extractExpressions;
   extractExpressions.insert(
       extractExpressions.end(), groupingKeys.begin(), groupingKeys.end());
@@ -393,16 +448,16 @@ void AggregationTestBase::testAggregationsWithCompanion(
         exec::getCompanionFunctionSignatures(functionNames[i]);
     VELOX_CHECK(companionSignatures.has_value());
 
-    const auto& [partialAggregate, mergeAggregate, extractAggregate] =
-        getCompanionAggregates(
-            i,
-            *companionSignatures,
-            functionNames[i],
-            aggregateArgs[i],
-            aggregatesArgTypes[i]);
-    partialAggregates.push_back(partialAggregate);
-    mergeAggregates.push_back(mergeAggregate);
-    extractExpressions.push_back(extractAggregate);
+    const auto& companionFunctions = getCompanionAggregates(
+        i,
+        *companionSignatures,
+        functionNames[i],
+        aggregateArgs[i],
+        aggregatesArgTypes[i]);
+    partialAggregates.push_back(companionFunctions.partialFunction);
+    mergeAggregates.push_back(companionFunctions.mergeFunction);
+    mergeExtractAggregates.push_back(companionFunctions.mergeExtractFunction);
+    extractExpressions.push_back(companionFunctions.extractFunction);
   }
 
   {
@@ -451,7 +506,7 @@ void AggregationTestBase::testAggregationsWithCompanion(
       builder.project(postAggregationProjections);
     }
 
-    auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto spillDirectory = TempDirectoryPath::create();
 
     AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
     queryBuilder.configs(config)
@@ -527,6 +582,28 @@ void AggregationTestBase::testAggregationsWithCompanion(
     assertResults(queryBuilder);
   }
 
+  {
+    SCOPED_TRACE("Run partial + intermediate + final merge extract");
+    PlanBuilder builder(pool());
+    builder.values(dataWithExtraGroupingKey);
+    preAggregationProcessing(builder);
+
+    builder.partialAggregation(groupingKeysWithPartialKey, partialAggregates)
+        .intermediateAggregation()
+        .finalAggregation()
+        .partialAggregation(groupingKeys, mergeExtractAggregates)
+        .intermediateAggregation()
+        .finalAggregation();
+
+    if (!postAggregationProjections.empty()) {
+      builder.project(postAggregationProjections);
+    }
+
+    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
+    queryBuilder.configs(config);
+    assertResults(queryBuilder);
+  }
+
   if (!groupingKeys.empty()) {
     SCOPED_TRACE("Run partial + local exchange + final");
     PlanBuilder builder(pool());
@@ -679,7 +756,7 @@ void AggregationTestBase::testReadFromFiles(
     return;
   }
 
-  std::vector<std::shared_ptr<exec::test::TempFilePath>> files;
+  std::vector<std::shared_ptr<TempFilePath>> files;
   std::vector<exec::Split> splits;
   std::vector<VectorPtr> inputs;
   auto writerPool = rootPool_->addAggregateChild("AggregationTestBase.writer");
@@ -699,11 +776,12 @@ void AggregationTestBase::testReadFromFiles(
   }
 
   for (auto& vector : inputs) {
-    auto file = exec::test::TempFilePath::create();
+    auto file = TempFilePath::create();
     writeToFile(file->getPath(), vector, writerPool.get());
     files.push_back(file);
-    splits.emplace_back(std::make_shared<connector::hive::HiveConnectorSplit>(
-        kHiveConnectorId, file->getPath(), dwio::common::FileFormat::DWRF));
+    splits.emplace_back(
+        std::make_shared<connector::hive::HiveConnectorSplit>(
+            kHiveConnectorId, file->getPath(), dwio::common::FileFormat::DWRF));
   }
   // No need to test streaming as the streaming test generates its own inputs,
   // so it would be the same as the original test.
@@ -888,7 +966,7 @@ void AggregationTestBase::testAggregationsImpl(
       builder.project(postAggregationProjections);
     }
 
-    auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto spillDirectory = TempDirectoryPath::create();
 
     ASSERT_EQ(memory::spillMemoryPool()->stats().usedBytes, 0);
     const auto peakSpillMemoryUsage =
@@ -961,8 +1039,8 @@ void AggregationTestBase::testAggregationsImpl(
     auto partialStats = taskStats.at(partialNodeId).customStats;
     auto intermediateStats = taskStats.at(intermediateNodeId).customStats;
     if (inputVectors > 1) {
-      EXPECT_LT(0, partialStats.at("abandonedPartialAggregation").count);
-      EXPECT_LT(0, intermediateStats.at("abandonedPartialAggregation").count);
+      EXPECT_LT(0, partialStats.at("abandonedPartialAggregationRows").sum);
+      EXPECT_LT(0, intermediateStats.at("abandonedPartialAggregationRows").sum);
     }
   }
 
@@ -992,7 +1070,7 @@ void AggregationTestBase::testAggregationsImpl(
       builder.project(postAggregationProjections);
     }
 
-    auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto spillDirectory = TempDirectoryPath::create();
 
     AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
     queryBuilder.configs(config)
@@ -1222,9 +1300,11 @@ std::unique_ptr<exec::Aggregate> createAggregateFunction(
     const std::string& functionName,
     const std::vector<TypePtr>& inputTypes,
     HashStringAllocator& allocator,
-    const std::unordered_map<std::string, std::string>& config) {
-  auto [finalType, intermediateType] =
-      exec::resolveAggregateFunction(functionName, inputTypes);
+    const std::unordered_map<std::string, std::string>& config,
+    const std::vector<VectorPtr>& rawInputs = {}) {
+  auto finalType = exec::resolveResultType(functionName, inputTypes);
+  auto intermediateType =
+      exec::resolveIntermediateType(functionName, inputTypes);
   core::QueryConfig queryConfig({config});
   auto func = exec::Aggregate::create(
       functionName,
@@ -1232,6 +1312,17 @@ std::unique_ptr<exec::Aggregate> createAggregateFunction(
       inputTypes,
       finalType,
       queryConfig);
+  // Pass constant inputs so aggregates can read constant arguments at
+  // initialization time (e.g., ignoreNulls flag for collect_set).
+  if (!rawInputs.empty()) {
+    std::vector<VectorPtr> constantInputs(rawInputs.size());
+    for (size_t i = 0; i < rawInputs.size(); ++i) {
+      if (rawInputs[i] && rawInputs[i]->isConstantEncoding()) {
+        constantInputs[i] = rawInputs[i];
+      }
+    }
+    func->setConstantInputs(constantInputs);
+  }
   func->setAllocator(&allocator);
   func->setOffsets(kOffset, 0, 1, 0, 2, kRowSizeOffset);
 
@@ -1290,8 +1381,10 @@ void AggregationTestBase::testIncrementalAggregation(
     func->addSingleGroupRawInput(
         group.data(), SelectivityVector(inputSize), input, false);
 
-    auto [finalType, intermediateType] =
-        exec::resolveAggregateFunction(functionName, aggregate.rawInputTypes);
+    auto finalType =
+        exec::resolveResultType(functionName, aggregate.rawInputTypes);
+    auto intermediateType =
+        exec::resolveIntermediateType(functionName, aggregate.rawInputTypes);
 
     // Extract intermediate result from the same accumulator twice and expect
     // results to be the same.
@@ -1333,8 +1426,8 @@ VectorPtr AggregationTestBase::testStreaming(
       [](const VectorPtr& vec) { return vec->type(); });
 
   HashStringAllocator allocator(pool());
-  auto func =
-      createAggregateFunction(functionName, rawInputTypes, allocator, config);
+  auto func = createAggregateFunction(
+      functionName, rawInputTypes, allocator, config, rawInput1);
   int maxRowCount = std::max(rawInput1Size, rawInput2Size);
   std::vector<char> group(kOffset + func->accumulatorFixedWidthSize());
   std::vector<char*> groups(maxRowCount, group.data());
@@ -1348,8 +1441,9 @@ VectorPtr AggregationTestBase::testStreaming(
         groups.data(), SelectivityVector(rawInput1Size), rawInput1, false);
   }
 
-  auto [finalType, intermediateType] =
-      exec::resolveAggregateFunction(functionName, rawInputTypes);
+  auto finalType = exec::resolveResultType(functionName, rawInputTypes);
+  auto intermediateType =
+      exec::resolveIntermediateType(functionName, rawInputTypes);
 
   auto intermediate = BaseVector::create(intermediateType, 1, pool());
   func->extractAccumulators(groups.data(), 1, &intermediate);
@@ -1359,8 +1453,8 @@ VectorPtr AggregationTestBase::testStreaming(
   }
 
   // Create a new function picking up the intermediate result.
-  auto func2 =
-      createAggregateFunction(functionName, rawInputTypes, allocator, config);
+  auto func2 = createAggregateFunction(
+      functionName, rawInputTypes, allocator, config, rawInput1);
   func2->initializeNewGroups(groups.data(), indices);
   if (testGlobal) {
     func2->addSingleGroupIntermediateResults(
diff --git a/velox/functions/lib/aggregates/tests/utils/CMakeLists.txt b/velox/functions/lib/aggregates/tests/utils/CMakeLists.txt
index bdb9ebe1ef8..5c66d0d5ed2 100644
--- a/velox/functions/lib/aggregates/tests/utils/CMakeLists.txt
+++ b/velox/functions/lib/aggregates/tests/utils/CMakeLists.txt
@@ -13,5 +13,6 @@
 # limitations under the License.
 
 add_library(velox_functions_aggregates_test_lib AggregationTestBase.cpp)
+velox_add_test_headers(velox_functions_aggregates_test_lib AggregationTestBase.h)
 
 target_link_libraries(velox_functions_aggregates_test_lib velox_exec_test_lib velox_vector_test_lib)
diff --git a/velox/functions/lib/benchmarks/CMakeLists.txt b/velox/functions/lib/benchmarks/CMakeLists.txt
index 86f62a40ccc..221df2fc32f 100644
--- a/velox/functions/lib/benchmarks/CMakeLists.txt
+++ b/velox/functions/lib/benchmarks/CMakeLists.txt
@@ -23,3 +23,5 @@ target_link_libraries(
   Folly::folly
   Folly::follybenchmark
 )
+
+velox_add_library(velox_functions_benchmark_util INTERFACE HEADERS FunctionBenchmarkBase.h)
diff --git a/velox/functions/lib/benchmarks/FunctionBenchmarkBase.h b/velox/functions/lib/benchmarks/FunctionBenchmarkBase.h
index f9f20ab98d7..42a25a5dc85 100644
--- a/velox/functions/lib/benchmarks/FunctionBenchmarkBase.h
+++ b/velox/functions/lib/benchmarks/FunctionBenchmarkBase.h
@@ -17,7 +17,6 @@
 
 #include "velox/expression/Expr.h"
 #include "velox/expression/RegisterSpecialForm.h"
-#include "velox/parse/Expressions.h"
 #include "velox/parse/ExpressionsParser.h"
 #include "velox/parse/TypeResolver.h"
 #include "velox/vector/tests/utils/VectorMaker.h"
@@ -42,13 +41,23 @@ class FunctionBenchmarkBase {
         {{core::QueryConfig::kAdjustTimestampToTimezone, value}});
   }
 
+  exec::ExprSet compileExpressions(
+      const std::vector<std::string>& texts,
+      const TypePtr& rowType) {
+    std::vector<core::TypedExprPtr> typedExprs;
+    for (const auto& text : texts) {
+      auto untyped = parse::DuckSqlExpressionsParser(options_).parseExpr(text);
+      auto typed =
+          core::Expressions::inferTypes(untyped, rowType, execCtx_.pool());
+      typedExprs.push_back(typed);
+    }
+    return exec::ExprSet(typedExprs, &execCtx_);
+  }
+
   exec::ExprSet compileExpression(
       const std::string& text,
       const TypePtr& rowType) {
-    auto untyped = parse::parseExpr(text, options_);
-    auto typed =
-        core::Expressions::inferTypes(untyped, rowType, execCtx_.pool());
-    return exec::ExprSet({typed}, &execCtx_);
+    return compileExpressions({text}, rowType);
   }
 
   void evaluate(
diff --git a/velox/functions/lib/sfm/CMakeLists.txt b/velox/functions/lib/sfm/CMakeLists.txt
index fa8fe516985..d25f5d82e8f 100644
--- a/velox/functions/lib/sfm/CMakeLists.txt
+++ b/velox/functions/lib/sfm/CMakeLists.txt
@@ -12,10 +12,33 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_functions_sfm SfmSketch.cpp SfmSketchAccumulator.cpp)
+velox_add_library(
+  velox_functions_sfm
+  SfmSketch.cpp
+  SfmSketchAccumulator.cpp
+  HEADERS
+  SfmSketch.h
+  SfmSketchAccumulator.h
+)
 
 velox_link_libraries(velox_functions_sfm velox_common_base velox_memory Folly::folly)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
 endif()
+
+velox_add_library(velox_randomization_strategy INTERFACE HEADERS RandomizationStrategy.h)
+
+velox_add_library(
+  velox_secure_randomization_strategy
+  INTERFACE
+  HEADERS
+  SecureRandomizationStrategy.h
+)
+
+velox_add_library(
+  velox_MT_randomization_strategy
+  INTERFACE
+  HEADERS
+  MersenneTwisterRandomizationStrategy.h
+)
diff --git a/velox/functions/lib/sfm/SfmSketch.h b/velox/functions/lib/sfm/SfmSketch.h
index 9e529a280a3..92bd5e8ff90 100644
--- a/velox/functions/lib/sfm/SfmSketch.h
+++ b/velox/functions/lib/sfm/SfmSketch.h
@@ -16,8 +16,7 @@
 
 #pragma once
 
-#define XXH_INLINE_ALL
-#include <xxhash.h> // @manual=third-party//xxHash:xxhash
+#include "velox/common/base/XxHashInline.h"
 
 #include <folly/Range.h>
 #include <cstdint>
diff --git a/velox/functions/lib/string/CMakeLists.txt b/velox/functions/lib/string/CMakeLists.txt
index 4f9f69f9093..4ed776d0296 100644
--- a/velox/functions/lib/string/CMakeLists.txt
+++ b/velox/functions/lib/string/CMakeLists.txt
@@ -11,7 +11,14 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-velox_add_library(velox_functions_string INTERFACE)
+velox_add_library(
+  velox_functions_string
+  INTERFACE
+  HEADERS
+  GreekFinalSigma.h
+  StringCore.h
+  StringImpl.h
+)
 
 velox_link_libraries(velox_functions_string INTERFACE velox_common_base Folly::folly)
 
diff --git a/velox/functions/lib/string/GreekFinalSigma.h b/velox/functions/lib/string/GreekFinalSigma.h
new file mode 100644
index 00000000000..c7a95058ab3
--- /dev/null
+++ b/velox/functions/lib/string/GreekFinalSigma.h
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "folly/CPortability.h"
+#include "velox/external/utf8proc/utf8procImpl.h"
+
+namespace facebook::velox::functions {
+
+/// Helper function to check if a character is cased. Compatible with the
+/// 'isCased' implementation in 'ConditionalSpecialCasting.java' of JDK, which
+/// is used by 'toLowerCase' function in Spark SQL.
+FOLLY_ALWAYS_INLINE bool isCased(utf8proc_int32_t ch) {
+  auto type = utf8proc_category(ch);
+  // Lowercase letter, uppercase letter or titlecase letter.
+  if (type == UTF8PROC_CATEGORY_LL || type == UTF8PROC_CATEGORY_LU ||
+      type == UTF8PROC_CATEGORY_LT) {
+    return true;
+  }
+  // Modifier letters and special cases.
+  if ((ch >= 0x02B0 && ch <= 0x02B8) || (ch >= 0x02C0 && ch <= 0x02C1) ||
+      (ch >= 0x02E0 && ch <= 0x02E4) || ch == 0x0345 || ch == 0x037A ||
+      (ch >= 0x1D2C && ch <= 0x1D61) || (ch >= 0x2160 && ch <= 0x217F) ||
+      (ch >= 0x24B6 && ch <= 0x24E9)) {
+    return true;
+  }
+  return false;
+}
+
+/// Helper function to check if a character is case-ignorable.
+/// Case-ignorable characters can be skipped when checking for cased characters
+/// before or after Σ.
+FOLLY_ALWAYS_INLINE bool isCaseIgnorable(utf8proc_int32_t ch) {
+  auto cat = utf8proc_category(ch);
+  // General_Category: Mn (Nonspacing Mark), Me (Enclosing Mark),
+  // Cf (Format), Lm (Modifier Letter), Sk (Modifier Symbol).
+  if (cat == UTF8PROC_CATEGORY_MN || cat == UTF8PROC_CATEGORY_ME ||
+      cat == UTF8PROC_CATEGORY_CF || cat == UTF8PROC_CATEGORY_LM ||
+      cat == UTF8PROC_CATEGORY_SK) {
+    return true;
+  }
+  // Word_Break property: MidLetter, MidNumLet, Single_Quote.
+  switch (ch) {
+    case 0x00B7: // · MIDDLE DOT
+    case 0x0387: // · GREEK ANO TELEIA
+    case 0x05F4: // ״ HEBREW PUNCTUATION GERSHAYIM
+    case 0x2027: // ‧ HYPHENATION POINT
+    case 0xFE13: // ︓ PRESENTATION FORM FOR VERTICAL COLON
+    case 0xFE55: // ﹕ SMALL COLON
+    case 0xFF1A: // ： FULLWIDTH COLON
+    case 0x002E: // . FULL STOP
+    case 0x2018: // ' LEFT SINGLE QUOTATION MARK
+    case 0x2019: // ' RIGHT SINGLE QUOTATION MARK
+    case 0x2024: // ․ ONE DOT LEADER
+    case 0xFE52: // ﹒ SMALL FULL STOP
+    case 0xFF07: // ＇ FULLWIDTH APOSTROPHE
+    case 0xFF0E: // ． FULLWIDTH FULL STOP
+    case 0x0027: // ' APOSTROPHE
+      return true;
+    default:
+      return false;
+  }
+}
+
+/// Scan backward to check if there is a cased character before the position.
+/// Skips case-ignorable characters during the scan.
+FOLLY_ALWAYS_INLINE bool hasCasedBefore(
+    const char* input,
+    size_t sigmaStartPos) {
+  if (sigmaStartPos == 0) {
+    return false;
+  }
+
+  size_t pos = sigmaStartPos;
+  while (pos > 0) {
+    // Move backward to the start of the previous UTF-8 character.
+    size_t prevPos = pos - 1;
+    while (prevPos > 0 &&
+           (static_cast<unsigned char>(input[prevPos]) & 0xC0) == 0x80) {
+      --prevPos;
+    }
+
+    int size;
+    utf8proc_int32_t cp =
+        utf8proc_codepoint(&input[prevPos], &input[pos], size);
+
+    if (cp == -1) {
+      return false;
+    }
+    if (isCased(cp)) {
+      return true;
+    }
+    if (!isCaseIgnorable(cp)) {
+      return false;
+    }
+    pos = prevPos;
+  }
+  return false;
+}
+
+/// Scan forward to check if there is a cased character after the position.
+/// Skips case-ignorable characters during the scan.
+FOLLY_ALWAYS_INLINE bool
+hasCasedAfter(const char* input, size_t inputLength, size_t afterSigmaPos) {
+  size_t pos = afterSigmaPos;
+  while (pos < inputLength) {
+    int size;
+    utf8proc_int32_t cp =
+        utf8proc_codepoint(&input[pos], input + inputLength, size);
+
+    if (cp == -1) {
+      return false;
+    }
+    if (isCased(cp)) {
+      return true;
+    }
+    if (!isCaseIgnorable(cp)) {
+      return false;
+    }
+    pos += size;
+  }
+  return false;
+}
+
+/// Check if the Greek capital letter Σ (U+03A3) at the given position should
+/// be converted to final sigma (ς) or regular sigma (σ).
+///
+/// According to the Final_Sigma rule in Unicode Standard Section 3.13:
+/// https://www.unicode.org/versions/Unicode15.0.0/ch03.pdf
+///
+/// A capital sigma maps to final sigma (ς) if and only if:
+/// 1. There is a cased character before Σ (possibly separated by
+///    case-ignorable characters)
+/// 2. There is no cased character after Σ (possibly separated by
+///    case-ignorable characters)
+///
+/// @param input The input string.
+/// @param inputLength The length of the input string in bytes.
+/// @param sigmaStartPos The byte position where Σ starts.
+/// @param afterSigmaPos The byte position immediately after Σ.
+/// @return true if Σ should be converted to final sigma (ς), false for regular
+/// sigma (σ).
+FOLLY_ALWAYS_INLINE bool isFinalSigma(
+    const char* input,
+    size_t inputLength,
+    size_t sigmaStartPos,
+    size_t afterSigmaPos) {
+  return hasCasedBefore(input, sigmaStartPos) &&
+      !hasCasedAfter(input, inputLength, afterSigmaPos);
+}
+
+/// Write the lowercase form of Greek capital letter Σ (U+03A3) to output.
+/// Writes ς (U+03C2) if isFinal is true, otherwise writes σ (U+03C3).
+///
+/// @param output The output buffer to write to.
+/// @param isFinal If true, write final sigma (ς); otherwise write regular
+/// sigma (σ).
+/// @return The number of bytes written (always 2 for these characters).
+FOLLY_ALWAYS_INLINE int writeLowerSigma(char* output, bool isFinal) {
+  // ς (U+03C2) = 0xCF 0x82, σ (U+03C3) = 0xCF 0x83
+  constexpr utf8proc_int32_t kFinalSigma = 0x03C2;
+  constexpr utf8proc_int32_t kRegularSigma = 0x03C3;
+  utf8proc_int32_t lowerSigma = isFinal ? kFinalSigma : kRegularSigma;
+  return utf8proc_encode_char(
+      lowerSigma, reinterpret_cast<unsigned char*>(output));
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/string/StringCore.h b/velox/functions/lib/string/StringCore.h
index 745e1ae985d..84b124aae04 100644
--- a/velox/functions/lib/string/StringCore.h
+++ b/velox/functions/lib/string/StringCore.h
@@ -22,6 +22,7 @@
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/SimdUtil.h"
 #include "velox/external/utf8proc/utf8procImpl.h"
+#include "velox/functions/lib/string/GreekFinalSigma.h"
 
 #if (ENABLE_VECTORIZATION > 0) && !defined(_DEBUG) && !defined(DEBUG)
 #if defined(__clang__) && (__clang_major__ > 7)
@@ -43,30 +44,6 @@
 #endif
 
 namespace facebook::velox::functions {
-namespace detail {
-
-// Helper function to check if a character is cased. Compatible with the
-// 'isCased' implementation in 'ConditionalSpecialCasting.java' of JDK, which is
-// used by 'toLowerCase' function in Spark SQL.
-FOLLY_ALWAYS_INLINE bool isCased(utf8proc_int32_t ch) {
-  auto type = utf8proc_category(ch);
-  // Lowercase letter, uppercase letter or titlecase letter.
-  if (type == UTF8PROC_CATEGORY_LL || type == UTF8PROC_CATEGORY_LU ||
-      type == UTF8PROC_CATEGORY_LT) {
-    return true;
-  }
-  // Modifier letters and special cases.
-  if ((ch >= 0x02B0 && ch <= 0x02B8) || (ch >= 0x02C0 && ch <= 0x02C1) ||
-      (ch >= 0x02E0 && ch <= 0x02E4) || ch == 0x0345 || ch == 0x037A ||
-      (ch >= 0x1D2C && ch <= 0x1D61) || (ch >= 0x2160 && ch <= 0x217F) ||
-      (ch >= 0x24B6 && ch <= 0x24E9)) {
-    return true;
-  }
-  return false;
-}
-
-} // namespace detail
-
 namespace stringCore {
 
 /// Check if a given string is ascii
@@ -239,23 +216,12 @@ FOLLY_ALWAYS_INLINE size_t lowerUnicode(
 
     if constexpr (greekFinalSigma) {
       // Handle Greek final sigma for Σ (U+03A3).
+      // See isFinalSigma() for the Final_Sigma rule reference.
       if (nextCodePoint == 0x03A3) {
-        // Look ahead to see if this is the end of a word.
-        bool isFinal = true;
-        if (inputIdx < inputLength) {
-          int lookaheadSize;
-          utf8proc_int32_t lookaheadCodePoint = utf8proc_codepoint(
-              &input[inputIdx], input + inputLength, lookaheadSize);
-          if (lookaheadCodePoint != -1 && detail::isCased(lookaheadCodePoint)) {
-            // If the next code point is cased, not the final.
-            isFinal = false;
-          }
-        }
-        // Convert to ς or σ.
-        utf8proc_int32_t lowerSigma = isFinal ? 0x03C2 : 0x03C3;
-        auto newSize = utf8proc_encode_char(
-            lowerSigma, reinterpret_cast<unsigned char*>(&output[outputIdx]));
-        outputIdx += newSize;
+        size_t sigmaStartPos = inputIdx - size;
+        bool isFinal =
+            isFinalSigma(input, inputLength, sigmaStartPos, inputIdx);
+        outputIdx += writeLowerSigma(&output[outputIdx], isFinal);
         continue;
       }
     }
@@ -316,8 +282,118 @@ lengthUnicode(const char* inputBuffer, size_t bufferLength) {
   return size;
 }
 
+namespace detail {
+
+// Returns the byte length of a UTF-8 character based on its first byte.
+// This is an optimistic check that only looks at the first byte.
+// We have this helper instead of using utf8proc_char_length because:
+// 1. It is FOLLY_ALWAYS_INLINE, making it faster in tight loops.
+// 2. It avoids the explicit 'c <= 127' check by treating all non-multi-byte
+//    start bytes (including ASCII and invalid bytes) as 1 byte.
+// 3. It ensures we always progress by at least 1 byte even on invalid data.
+FOLLY_ALWAYS_INLINE int32_t getUtf8CharLength(uint8_t c) {
+  auto n = std::countl_zero((~static_cast<uint32_t>(c) << 24) | 1);
+  return (n == 0 || n > 4) ? 1 : n;
+}
+
+// Helper function to unify cappedLengthUnicode and cappedByteLengthUnicode.
+// If kReturnBytes is true, it returns the byte offset of the maxChars-th char.
+// If kReturnBytes is false, it returns the number of characters capped at
+// maxChars.
+template <bool kReturnBytes>
+FOLLY_ALWAYS_INLINE int64_t
+cappedUnicodeImpl(const char* input, size_t size, int64_t maxChars) {
+  size_t position = 0;
+  int64_t numChars = 0;
+  constexpr size_t kBatchSize = xsimd::batch<uint8_t>::size;
+
+  if (size >= kBatchSize) {
+    // Use SIMD to process the string in blocks of the native register width.
+    const auto highBitMask = xsimd::broadcast<uint8_t>(0x80);
+    const auto continuationMask = xsimd::broadcast<uint8_t>(0xc0);
+
+    while (position + kBatchSize <= size && numChars < maxChars) {
+      auto batch = xsimd::batch<uint8_t>::load_unaligned(
+          reinterpret_cast<const uint8_t*>(input + position));
+
+      // Fast path for pure ASCII blocks.
+      if (LIKELY(!xsimd::any(batch >= highBitMask))) {
+        const int64_t jump =
+            std::min(static_cast<int64_t>(kBatchSize), maxChars - numChars);
+        position += jump;
+        numChars += jump;
+        continue;
+      }
+
+      // Mixed UTF-8: Count character starts (bytes where (byte & 0xc0) != 0x80)
+      const auto isCharStart = (batch & continuationMask) != highBitMask;
+      uint32_t mask = static_cast<uint32_t>(simd::toBitMask(isCharStart));
+      int32_t countInBlock = __builtin_popcount(mask);
+
+      if (numChars + countInBlock < maxChars) {
+        numChars += countInBlock;
+        position += kBatchSize;
+      } else {
+        // We hit maxChars within this block.
+        if constexpr (kReturnBytes) {
+          int32_t needed = maxChars - numChars;
+          while (mask) {
+            if (--needed == 0) {
+              const int32_t bit = __builtin_ctz(mask);
+              uint8_t startByte = static_cast<uint8_t>(input[position + bit]);
+              return position + bit + getUtf8CharLength(startByte);
+            }
+            mask &= (mask - 1);
+          }
+          VELOX_UNREACHABLE();
+        } else {
+          return maxChars;
+        }
+      }
+    }
+  }
+
+  // Standard UTF-8 path for the remainder or strings shorter than a block.
+  // Skip continuation bytes (0x80..0xBF) without counting — they belong to
+  // a character whose leading byte was already counted by the SIMD loop.
+  // We explicitly keep two separate loops.
+  // The branchless implementation (used in the `if` block below) performs fewer
+  // branches but executes more ALU instructions per byte.
+  // The branching implementation (used in the `else` block) uses an explicit
+  // `if (c < 0x80)` check, this is cheaper than executing the additional ALU
+  // instructions required by the branchless approach.
+  if (position < size &&
+      UNLIKELY(static_cast<uint8_t>(input[position]) & 0x80)) {
+    // Non-ASCII remainder: avoid ASCII fast-path branch mispredicts.
+    while (position < size && numChars < maxChars) {
+      const uint8_t c = static_cast<uint8_t>(input[position]);
+      position += getUtf8CharLength(c);
+      numChars += ((c & 0xC0) != 0x80);
+    }
+  } else {
+    while (position < size && numChars < maxChars) {
+      const uint8_t c = static_cast<uint8_t>(input[position]);
+      if (c < 0x80) {
+        position++;
+        numChars++;
+      } else {
+        position += getUtf8CharLength(c);
+        numChars += ((c & 0xC0) != 0x80);
+      }
+    }
+  }
+
+  if constexpr (kReturnBytes) {
+    return position;
+  } else {
+    return numChars;
+  }
+}
+
+} // namespace detail
+
 /**
- * Return an capped length(controlled by maxChars) of a unicode string. The
+ * Return a capped length(controlled by maxChars) of a unicode string. The
  * returned length is not greater than maxChars.
  *
  * This method is used to tell whether a string is longer or the same length of
@@ -325,56 +401,35 @@ lengthUnicode(const char* inputBuffer, size_t bufferLength) {
  * providing maxChars we can get better performance by avoid calculating whole
  * length of a string which might be very long.
  *
- * @param input input buffer that hold the string
- * @param size size of input buffer
- * @param maxChars stop counting characters if the string is longer
- * than this value
- * @return the number of characters represented by the input utf8 string
+ * @param input Input buffer that hold the string.
+ * @param size Size of input buffer.
+ * @param maxChars Stop counting characters if the string is longer
+ * than this value.
+ * @return The number of characters represented by the input utf8 string.
  */
 FOLLY_ALWAYS_INLINE int64_t
 cappedLengthUnicode(const char* input, size_t size, int64_t maxChars) {
-  // First address after the last byte in the input
-  auto end = input + size;
-  auto currentChar = input;
-  int64_t numChars = 0;
-
-  // Use maxChars to early stop to avoid calculating the whole
-  // length of long string.
-  while (currentChar < end && numChars < maxChars) {
-    auto charSize = utf8proc_char_length(currentChar);
-    // Skip bad byte if we get utf length < 0.
-    currentChar += UNLIKELY(charSize < 0) ? 1 : charSize;
-    numChars++;
-  }
-
-  return numChars;
+  return detail::cappedUnicodeImpl<false>(input, size, maxChars);
 }
 
 ///
-/// Return an capped length in bytes(controlled by maxChars) of a unicode
-/// string. The returned length may be greater than maxCharacters if there are
+/// Returns a capped length in bytes (controlled by maxChars) of a Unicode
+/// string. The returned length may be greater than maxChars if there are
 /// multi-byte characters present in the input string.
 ///
-/// This method is used to help with indexing unicode strings by byte position.
+/// This method is used to help with indexing Unicode strings by byte position.
 /// It is used to find the byte position of the Nth character in a string.
 ///
-/// @param input input buffer that hold the string
-/// @param size size of input buffer
-/// @param maxChars stop counting characters if the string is longer
-/// than this value
-/// @return the number of bytes represented by the input utf8 string up to
-/// maxChars
+/// @param input Input buffer that holds the string.
+/// @param size Size of the input buffer.
+/// @param maxChars Stop counting characters if the string is longer than this
+/// value.
+/// @return The number of bytes represented by the input UTF-8 string up to
+/// maxChars.
 ///
 FOLLY_ALWAYS_INLINE int64_t
 cappedByteLengthUnicode(const char* input, int64_t size, int64_t maxChars) {
-  int64_t utf8Position = 0;
-  int64_t numCharacters = 0;
-  while (utf8Position < size && numCharacters < maxChars) {
-    auto charSize = utf8proc_char_length(input + utf8Position);
-    utf8Position += UNLIKELY(charSize < 0) ? 1 : charSize;
-    numCharacters++;
-  }
-  return utf8Position;
+  return detail::cappedUnicodeImpl<true>(input, size, maxChars);
 }
 
 /// Returns the start byte index of the Nth instance of subString in
diff --git a/velox/functions/lib/string/StringImpl.h b/velox/functions/lib/string/StringImpl.h
index ea4786b52b0..3322ac36991 100644
--- a/velox/functions/lib/string/StringImpl.h
+++ b/velox/functions/lib/string/StringImpl.h
@@ -137,23 +137,21 @@ cappedByteLength(const TString& input, size_t maxCharacters) {
   }
 }
 
-/// Write the Unicode codePoint as string to the output string. The function
+/// Write the Unicode codePoint as string to an output StringView. The function
 /// behavior is undefined when code point it invalid. Implements the logic of
 /// presto chr function.
-template <typename TOutString>
-FOLLY_ALWAYS_INLINE void codePointToString(
-    TOutString& output,
-    const int64_t codePoint) {
+///
+/// Returns an StringView with an inlined buffer (since the maximum string size
+/// is only 4 bytes).
+FOLLY_ALWAYS_INLINE StringView codePointToString(const int64_t codePoint) {
   auto validCodePoint =
       codePoint <= INT32_MAX && utf8proc_codepoint_valid(codePoint);
   VELOX_USER_CHECK(
       validCodePoint, "Not a valid Unicode code point: {}", codePoint);
 
-  output.reserve(4);
-  auto size = utf8proc_encode_char(
-      codePoint, reinterpret_cast<unsigned char*>(output.data()));
-
-  output.resize(size);
+  unsigned char output[4];
+  auto size = utf8proc_encode_char(codePoint, output);
+  return StringView((const char*)output, size);
 }
 
 /// Returns the Unicode code point of the first char in a single char input
diff --git a/velox/functions/lib/string/tests/CMakeLists.txt b/velox/functions/lib/string/tests/CMakeLists.txt
index baf38f88322..819227aa438 100644
--- a/velox/functions/lib/string/tests/CMakeLists.txt
+++ b/velox/functions/lib/string/tests/CMakeLists.txt
@@ -24,3 +24,16 @@ target_link_libraries(
   gflags::gflags
   glog::glog
 )
+
+if(VELOX_ENABLE_BENCHMARKS)
+  add_executable(velox_string_core_benchmark StringCoreBenchmark.cpp)
+
+  target_link_libraries(
+    velox_string_core_benchmark
+    velox_functions_string
+    Folly::folly
+    Folly::follybenchmark
+    gflags::gflags
+    glog::glog
+  )
+endif()
diff --git a/velox/functions/lib/string/tests/StringCoreBenchmark.cpp b/velox/functions/lib/string/tests/StringCoreBenchmark.cpp
new file mode 100644
index 00000000000..4c1b8730f22
--- /dev/null
+++ b/velox/functions/lib/string/tests/StringCoreBenchmark.cpp
@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+#include <gflags/gflags.h>
+
+#include <functional>
+#include <random>
+#include <string>
+#include <vector>
+
+#include "velox/functions/lib/string/StringCore.h"
+
+using namespace facebook::velox::functions;
+
+DEFINE_int32(num_strings, 10000, "Number of strings to process");
+DEFINE_int32(max_chars, 128, "maxChars argument to cappedByteLengthUnicode");
+
+namespace facebook::velox::functions {
+
+class StringCoreBenchmark {
+ public:
+  static void init(int32_t length, int32_t ratio) {
+    strings_.clear();
+    strings_.reserve(FLAGS_num_strings);
+    std::mt19937 rng(42);
+    for (int32_t i = 0; i < FLAGS_num_strings; ++i) {
+      strings_.push_back(generateString(length, ratio, rng));
+    }
+  }
+
+  static const std::vector<std::string>& strings() {
+    return strings_;
+  }
+
+ private:
+  static std::string
+  generateString(int32_t length, int32_t ratio, std::mt19937& rng) {
+    if (ratio == 100) {
+      return generateAscii(length, rng);
+    }
+    if (ratio == 0) {
+      return generateUnicode(length, rng);
+    }
+    return generateMixed(length, ratio, rng);
+  }
+
+  static std::string generateAscii(int32_t length, std::mt19937& rng) {
+    std::string s(length, '\0');
+    std::uniform_int_distribution<int32_t> dist(0x20, 0x7E);
+    for (int32_t i = 0; i < length; ++i) {
+      s[i] = static_cast<char>(dist(rng));
+    }
+    return s;
+  }
+
+  static std::string
+  generateMixed(int32_t length, int32_t ratio, std::mt19937& rng) {
+    std::string s;
+    s.reserve(length);
+    std::uniform_int_distribution<int32_t> asciiDist(0x20, 0x7E);
+    std::uniform_int_distribution<int32_t> unicodeDist(0x4E00, 0x9FFF);
+    std::uniform_int_distribution<int32_t> chance(1, 100);
+
+    while (static_cast<int32_t>(s.size()) < length) {
+      if (chance(rng) > ratio && static_cast<int32_t>(s.size()) + 3 <= length) {
+        int32_t cp = unicodeDist(rng);
+        s.push_back(static_cast<char>(0xE0 | (cp >> 12)));
+        s.push_back(static_cast<char>(0x80 | ((cp >> 6) & 0x3F)));
+        s.push_back(static_cast<char>(0x80 | (cp & 0x3F)));
+      } else {
+        s.push_back(static_cast<char>(asciiDist(rng)));
+      }
+    }
+    return s;
+  }
+
+  static std::string generateUnicode(int32_t length, std::mt19937& rng) {
+    std::string s;
+    s.reserve(length);
+    std::uniform_int_distribution<int32_t> dist(0x4E00, 0x9FFF);
+
+    while (static_cast<int32_t>(s.size()) + 3 <= length) {
+      int32_t cp = dist(rng);
+      s.push_back(static_cast<char>(0xE0 | (cp >> 12)));
+      s.push_back(static_cast<char>(0x80 | ((cp >> 6) & 0x3F)));
+      s.push_back(static_cast<char>(0x80 | (cp & 0x3F)));
+    }
+    return s;
+  }
+
+  static std::vector<std::string> strings_;
+};
+
+} // namespace facebook::velox::functions
+
+std::vector<std::string> StringCoreBenchmark::strings_;
+
+void runCappedByteLengthUnicode(uint32_t iters, int32_t length, int32_t ratio) {
+  folly::BenchmarkSuspender suspender;
+  StringCoreBenchmark::init(length, ratio);
+  suspender.dismiss();
+
+  int64_t total = 0;
+  const int32_t maxChars = std::min(FLAGS_max_chars, length);
+  for (unsigned i = 0; i < iters; ++i) {
+    for (const auto& s : StringCoreBenchmark::strings()) {
+      total +=
+          stringCore::cappedByteLengthUnicode(s.data(), s.size(), maxChars);
+    }
+  }
+  folly::doNotOptimizeAway(total);
+}
+
+void runCappedLengthUnicode(uint32_t iters, int32_t length, int32_t ratio) {
+  folly::BenchmarkSuspender suspender;
+  StringCoreBenchmark::init(length, ratio);
+  suspender.dismiss();
+
+  int64_t total = 0;
+  const int32_t maxChars = std::min(FLAGS_max_chars, length);
+  for (unsigned i = 0; i < iters; ++i) {
+    for (const auto& s : StringCoreBenchmark::strings()) {
+      total += stringCore::cappedLengthUnicode(s.data(), s.size(), maxChars);
+    }
+  }
+  folly::doNotOptimizeAway(total);
+}
+
+int32_t main(int32_t argc, char** argv) {
+  folly::Init init{&argc, &argv};
+
+  std::vector<int32_t> ratios = {0, 1, 25, 50, 75, 99, 100};
+  std::vector<int32_t> lengths = {4, 16, 64, 256, 1024};
+
+  for (auto length : lengths) {
+    for (auto ratio : ratios) {
+      std::string suffix =
+          std::to_string(length) + "_" + std::to_string(ratio) + "%";
+      folly::addBenchmark(
+          __FILE__,
+          "cappedByteLengthUnicode_" + suffix,
+          [length, ratio](unsigned iters) {
+            runCappedByteLengthUnicode(iters, length, ratio);
+            return iters;
+          });
+    }
+  }
+
+  folly::addBenchmark(__FILE__, "-", []() { return 0; });
+
+  for (auto length : lengths) {
+    for (auto ratio : ratios) {
+      std::string suffix =
+          std::to_string(length) + "_" + std::to_string(ratio) + "%";
+      folly::addBenchmark(
+          __FILE__,
+          "cappedLengthUnicode_" + suffix,
+          [length, ratio](unsigned iters) {
+            runCappedLengthUnicode(iters, length, ratio);
+            return iters;
+          });
+    }
+  }
+
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/functions/lib/string/tests/StringImplTest.cpp b/velox/functions/lib/string/tests/StringImplTest.cpp
index 7c50de51d4d..c9a0a671c95 100644
--- a/velox/functions/lib/string/tests/StringImplTest.cpp
+++ b/velox/functions/lib/string/tests/StringImplTest.cpp
@@ -17,6 +17,7 @@
 #include "velox/functions/lib/string/StringImpl.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/core/CoreTypeSystem.h"
+#include "velox/functions/lib/string/StringCore.h"
 #include "velox/type/StringView.h"
 
 #include <gtest/gtest.h>
@@ -349,6 +350,157 @@ TEST_F(StringImplTest, cappedLength) {
   ASSERT_EQ(cappedLength</*isAscii*/ false>(input, 7), 5);
 }
 
+TEST_F(StringImplTest, cappedLengthUnicode) {
+  constexpr int32_t batchSize = xsimd::batch<uint8_t>::size;
+
+  // Empty string.
+  EXPECT_EQ(cappedLengthUnicode("", 0, 10), 0);
+
+  // Short ASCII string (smaller than one SIMD batch, scalar tail only).
+  {
+    std::string s = "hello";
+    EXPECT_EQ(cappedLengthUnicode(s.data(), s.size(), 100), 5);
+    EXPECT_EQ(cappedLengthUnicode(s.data(), s.size(), 3), 3);
+    EXPECT_EQ(cappedLengthUnicode(s.data(), s.size(), 5), 5);
+  }
+
+  // Long ASCII string (SIMD ASCII fast-path).
+  {
+    std::string s(batchSize * 3, 'a');
+    EXPECT_EQ(
+        cappedLengthUnicode(s.data(), s.size(), batchSize * 3 + 100),
+        batchSize * 3);
+  }
+
+  // ASCII string with maxChars limiting within the SIMD fast-path.
+  // maxChars < batchSize forces the jump to be capped.
+  {
+    std::string s(batchSize * 2, 'x');
+    EXPECT_EQ(cappedLengthUnicode(s.data(), s.size(), 5), 5);
+    EXPECT_EQ(
+        cappedLengthUnicode(s.data(), s.size(), batchSize + 1), batchSize + 1);
+  }
+
+  // Mixed string that fits entirely within maxChars.
+  // 3-byte Unicode characters mixed with ASCII.
+  // "你好abc世界" = 3 + 3 + 1 + 1 + 1 + 3 + 3 = 15 bytes, 7 characters.
+  {
+    std::string s = "你好abc世界";
+    EXPECT_EQ(cappedLengthUnicode(s.data(), s.size(), 100), 7);
+    EXPECT_EQ(cappedLengthUnicode(s.data(), s.size(), 7), 7);
+    EXPECT_EQ(cappedLengthUnicode(s.data(), s.size(), 3), 3);
+    EXPECT_EQ(cappedLengthUnicode(s.data(), s.size(), 4), 4);
+    EXPECT_EQ(cappedLengthUnicode(s.data(), s.size(), 1), 1);
+  }
+
+  // maxChars hit within a SIMD block (return maxChars branch).
+  // Build a string longer than batchSize with enough Unicode chars to
+  // trigger the character-start counting path, then set maxChars so
+  // that numChars + countInBlock >= maxChars.
+  {
+    // Build: (batchSize / 3) 3-byte chars, then fill rest with ASCII.
+    // This ensures the first SIMD block has mixed content.
+    std::string s;
+    auto numUnicodeChars = batchSize / 3;
+    for (auto i = 0; i < numUnicodeChars; ++i) {
+      s += "你"; // 3-byte character
+    }
+    // Pad with ASCII to exceed batchSize.
+    while (static_cast<int32_t>(s.size()) < batchSize * 2) {
+      s += 'a';
+    }
+    int64_t totalChars = numUnicodeChars + (s.size() - numUnicodeChars * 3);
+
+    EXPECT_EQ(
+        cappedLengthUnicode(s.data(), s.size(), totalChars + 10), totalChars);
+
+    // Cap within the first (mixed) SIMD block. The SIMD block contains
+    // numUnicodeChars character starts from multi-byte chars.
+    // Setting maxChars to numUnicodeChars - 1 should return maxChars.
+    if (numUnicodeChars > 2) {
+      EXPECT_EQ(
+          cappedLengthUnicode(s.data(), s.size(), numUnicodeChars - 1),
+          numUnicodeChars - 1);
+    }
+  }
+
+  // Pure Unicode string (all 3-byte chars).
+  {
+    std::string s;
+    int32_t numChars = batchSize;
+    for (int32_t i = 0; i < numChars; ++i) {
+      s += "世";
+    }
+    EXPECT_EQ(cappedLengthUnicode(s.data(), s.size(), numChars + 10), numChars);
+    EXPECT_EQ(cappedLengthUnicode(s.data(), s.size(), 5), 5);
+  }
+
+  // 4-byte UTF-8 characters (emoji).
+  {
+    std::string s = "😊😊😊😊😊";
+    EXPECT_EQ(cappedLengthUnicode(s.data(), s.size(), 10), 5);
+    EXPECT_EQ(cappedLengthUnicode(s.data(), s.size(), 3), 3);
+  }
+
+  // 2-byte UTF-8 characters.
+  {
+    std::string s = "ñéüôà";
+    EXPECT_EQ(cappedLengthUnicode(s.data(), s.size(), 10), 5);
+    EXPECT_EQ(cappedLengthUnicode(s.data(), s.size(), 2), 2);
+  }
+
+  // Scalar tail processing multi-byte characters that straddle the
+  // SIMD block boundary.
+  {
+    // batchSize - 1 ASCII bytes + one 3-byte Unicode char + 1 ASCII.
+    // The 3-byte char starts at the last byte of the first SIMD block
+    // and spills into the scalar tail.
+    std::string s(batchSize - 1, 'a');
+    s += "你"; // 3 bytes.
+    s += "b";
+    // Total characters: (batchSize - 1) + 1 + 1 = batchSize + 1.
+    EXPECT_EQ(
+        cappedLengthUnicode(s.data(), s.size(), batchSize + 10), batchSize + 1);
+  }
+
+  // String exactly one SIMD batch long (pure ASCII).
+  {
+    std::string s(batchSize, 'z');
+    EXPECT_EQ(cappedLengthUnicode(s.data(), s.size(), batchSize), batchSize);
+    EXPECT_EQ(
+        cappedLengthUnicode(s.data(), s.size(), batchSize - 1), batchSize - 1);
+    EXPECT_EQ(
+        cappedLengthUnicode(s.data(), s.size(), batchSize + 1), batchSize);
+  }
+
+  // maxChars = 0 should return 0.
+  {
+    std::string s = "hello";
+    EXPECT_EQ(cappedLengthUnicode(s.data(), s.size(), 0), 0);
+  }
+
+  // Large mixed string: multiple SIMD blocks with alternating
+  // ASCII and Unicode content.
+  {
+    std::string s;
+    int64_t expectedChars = 0;
+    for (int32_t i = 0; i < batchSize * 2; ++i) {
+      if (i % 5 == 0) {
+        s += "你"; // 3-byte.
+      } else {
+        s += 'a';
+      }
+      expectedChars++;
+    }
+    EXPECT_EQ(
+        cappedLengthUnicode(s.data(), s.size(), expectedChars + 100),
+        expectedChars);
+    EXPECT_EQ(
+        cappedLengthUnicode(s.data(), s.size(), expectedChars / 2),
+        expectedChars / 2);
+  }
+}
+
 TEST_F(StringImplTest, cappedUnicodeBytes) {
   // Test functions use case for indexing
   // UTF strings.
@@ -368,6 +520,19 @@ TEST_F(StringImplTest, cappedUnicodeBytes) {
   ASSERT_EQ("♫¡Singing is fun!", stringInput.substr(0, exPos));
   ASSERT_EQ("Singing is fun!", stringInput.substr(sPos, exPos - sPos));
 
+  // Ensure the remainder loop handles a continuation byte at the block
+  // boundary. Place a UTF-8 lead byte (0xC2) as the last byte of a SIMD block
+  // and its continuation byte (0xA2) in the remainder. The string layout is:
+  // (batchSize - 1) ASCII 'a' bytes, then a 2-byte UTF-8 character, then 'b'.
+  // With maxChars set to include the trailing 'b', the expected byte length
+  // must account for both bytes of the UTF-8 character.
+  constexpr int32_t batchSize = xsimd::batch<uint8_t>::size;
+  stringInput = std::string(batchSize - 1, 'a');
+  stringInput.push_back(static_cast<char>(0xC2));
+  stringInput.push_back(static_cast<char>(0xA2));
+  stringInput.push_back('b');
+  ASSERT_EQ(cappedByteLength<false>(stringInput, batchSize + 1), batchSize + 2);
+
   stringInput = std::string("abcd");
   auto stringViewInput = std::string_view(stringInput);
   ASSERT_EQ(cappedByteLength<true>(stringInput, 1), 1);
@@ -443,6 +608,159 @@ TEST_F(StringImplTest, cappedUnicodeBytes) {
   ASSERT_EQ(cappedByteLength<false>(stringViewInput, 3), 4);
 }
 
+TEST_F(StringImplTest, cappedByteLengthUnicode) {
+  constexpr int32_t batchSize = xsimd::batch<uint8_t>::size;
+
+  // Empty string.
+  EXPECT_EQ(cappedByteLengthUnicode("", 0, 10), 0);
+
+  // maxChars = 0 should return 0.
+  {
+    std::string s = "hello";
+    EXPECT_EQ(cappedByteLengthUnicode(s.data(), s.size(), 0), 0);
+  }
+
+  // Short ASCII string (scalar tail only).
+  {
+    std::string s = "hello";
+    EXPECT_EQ(cappedByteLengthUnicode(s.data(), s.size(), 100), 5);
+    EXPECT_EQ(cappedByteLengthUnicode(s.data(), s.size(), 3), 3);
+    EXPECT_EQ(cappedByteLengthUnicode(s.data(), s.size(), 5), 5);
+  }
+
+  // Long ASCII string (SIMD ASCII fast-path).
+  {
+    std::string s(batchSize * 3, 'a');
+    EXPECT_EQ(
+        cappedByteLengthUnicode(s.data(), s.size(), batchSize * 3 + 100),
+        batchSize * 3);
+  }
+
+  // ASCII string with maxChars limiting within the SIMD fast-path.
+  {
+    std::string s(batchSize * 2, 'x');
+    EXPECT_EQ(cappedByteLengthUnicode(s.data(), s.size(), 5), 5);
+    EXPECT_EQ(
+        cappedByteLengthUnicode(s.data(), s.size(), batchSize + 1),
+        batchSize + 1);
+  }
+
+  // Mixed string: return byte position, not character count.
+  // "你好abc世界" = 3+3+1+1+1+3+3 = 15 bytes, 7 characters.
+  {
+    std::string s = "你好abc世界";
+    EXPECT_EQ(cappedByteLengthUnicode(s.data(), s.size(), 100), 15);
+    EXPECT_EQ(cappedByteLengthUnicode(s.data(), s.size(), 1), 3);
+    EXPECT_EQ(cappedByteLengthUnicode(s.data(), s.size(), 2), 6);
+    EXPECT_EQ(cappedByteLengthUnicode(s.data(), s.size(), 3), 7);
+    EXPECT_EQ(cappedByteLengthUnicode(s.data(), s.size(), 4), 8);
+    EXPECT_EQ(cappedByteLengthUnicode(s.data(), s.size(), 5), 9);
+  }
+
+  // maxChars hit within a SIMD block (bit-scanning branch).
+  // Build: (batchSize / 3) 3-byte chars, then fill rest with ASCII.
+  {
+    std::string s;
+    int32_t numUnicodeChars = batchSize / 3;
+    for (int32_t i = 0; i < numUnicodeChars; ++i) {
+      s += "你"; // 3-byte.
+    }
+    while (static_cast<int32_t>(s.size()) < batchSize * 2) {
+      s += 'a';
+    }
+
+    // Cap at 2 characters — should return byte position after 2nd char.
+    // First 2 chars are 3-byte each, so expected = 6.
+    EXPECT_EQ(cappedByteLengthUnicode(s.data(), s.size(), 2), 6);
+
+    // Cap at 1 character — first char is 3 bytes.
+    EXPECT_EQ(cappedByteLengthUnicode(s.data(), s.size(), 1), 3);
+  }
+
+  // Pure Unicode string (all 3-byte chars).
+  {
+    std::string s;
+    int32_t numChars = batchSize;
+    for (int32_t i = 0; i < numChars; ++i) {
+      s += "世";
+    }
+    EXPECT_EQ(
+        cappedByteLengthUnicode(s.data(), s.size(), numChars + 10),
+        numChars * 3);
+    EXPECT_EQ(cappedByteLengthUnicode(s.data(), s.size(), 5), 15);
+  }
+
+  // 4-byte UTF-8 characters (emoji).
+  {
+    std::string s = "😊😊😊😊😊";
+    EXPECT_EQ(cappedByteLengthUnicode(s.data(), s.size(), 10), 20);
+    EXPECT_EQ(cappedByteLengthUnicode(s.data(), s.size(), 3), 12);
+  }
+
+  // 2-byte UTF-8 characters.
+  {
+    std::string s = "ñéüôà";
+    EXPECT_EQ(cappedByteLengthUnicode(s.data(), s.size(), 10), 10);
+    EXPECT_EQ(cappedByteLengthUnicode(s.data(), s.size(), 2), 4);
+  }
+
+  // Scalar tail with multi-byte char span the SIMD block boundary.
+  {
+    // batchSize - 1 ASCII + one 2-byte char (0xC2, 0xA2) + 'b'.
+    // The leading byte 0xC2 is in the SIMD block, continuation 0xA2 is in
+    // the scalar tail. The SIMD block counts 0xC2 as a char start.
+    // Scalar tail sees 0xA2 (continuation, skip) then 'b'.
+    std::string s(batchSize - 1, 'a');
+    s.push_back(static_cast<char>(0xC2));
+    s.push_back(static_cast<char>(0xA2));
+    s.push_back('b');
+    // maxChars = batchSize + 1 means batchSize chars counted.
+    // The SIMD block has batchSize char starts (batchSize-1 'a's + 0xC2).
+    // After SIMD: remainingChars = 1. Scalar tail: skip 0xA2, then 'b'
+    // counts as the last char. Byte position = batchSize + 2 + 1 = batchSize+3.
+    // Wait: let me recalculate. batchSize-1 'a's + 0xC2 = batchSize bytes.
+    // In SIMD: batchSize char starts found. maxChars = batchSize + 1.
+    // countInBlock (batchSize) < remainingChars (batchSize+1) → consume block.
+    // remainingChars = 1, utf8Position = batchSize.
+    // Scalar tail at byte batchSize: 0xA2 → continuation, skip, pos++.
+    // byte batchSize+1: 'b' → char start, advance by 1, remainingChars = 0.
+    // Return batchSize + 2.
+    EXPECT_EQ(
+        cappedByteLengthUnicode(s.data(), s.size(), batchSize + 1),
+        batchSize + 2);
+  }
+
+  // String exactly one SIMD batch long (pure ASCII).
+  {
+    std::string s(batchSize, 'z');
+    EXPECT_EQ(
+        cappedByteLengthUnicode(s.data(), s.size(), batchSize), batchSize);
+    EXPECT_EQ(
+        cappedByteLengthUnicode(s.data(), s.size(), batchSize - 1),
+        batchSize - 1);
+    EXPECT_EQ(
+        cappedByteLengthUnicode(s.data(), s.size(), batchSize + 1), batchSize);
+  }
+
+  // Large mixed string: multiple SIMD blocks.
+  {
+    std::string s;
+    int64_t expectedChars = 0;
+    for (int32_t i = 0; i < batchSize * 2; ++i) {
+      if (i % 5 == 0) {
+        s += "你"; // 3-byte.
+      } else {
+        s += 'a';
+      }
+      expectedChars++;
+    }
+    // Full count should return total byte length.
+    EXPECT_EQ(
+        cappedByteLengthUnicode(s.data(), s.size(), expectedChars + 100),
+        static_cast<int64_t>(s.size()));
+  }
+}
+
 TEST_F(StringImplTest, badUnicodeLength) {
   ASSERT_EQ(0, length</*isAscii*/ false>(std::string("")));
   ASSERT_EQ(2, length</*isAscii*/ false>(std::string("ab")));
@@ -466,15 +784,11 @@ TEST_F(StringImplTest, badUnicodeLength) {
 TEST_F(StringImplTest, codePointToString) {
   auto testValidInput = [](const int64_t codePoint,
                            const std::string& expectedString) {
-    core::StringWriter output;
-    codePointToString(output, codePoint);
-    ASSERT_EQ(
-        StringView(expectedString), StringView(output.data(), output.size()));
+    ASSERT_EQ(StringView(expectedString), codePointToString(codePoint));
   };
 
   auto testInvalidCodePoint = [](const int64_t codePoint) {
-    core::StringWriter output;
-    EXPECT_THROW(codePointToString(output, codePoint), VeloxUserError)
+    EXPECT_THROW(codePointToString(codePoint), VeloxUserError)
         << "codePoint " << codePoint;
   };
 
@@ -494,9 +808,8 @@ TEST_F(StringImplTest, charToCodePoint) {
   };
 
   auto testValidInputRoundTrip = [](const int64_t codePoint) {
-    core::StringWriter string;
-    codePointToString(string, codePoint);
-    ASSERT_EQ(charToCodePoint(string), codePoint) << "codePoint " << codePoint;
+    ASSERT_EQ(charToCodePoint(codePointToString(codePoint)), codePoint)
+        << "codePoint " << codePoint;
   };
 
   auto testExpectDeath = [](const std::string& charString) {
diff --git a/velox/functions/lib/tests/CMakeLists.txt b/velox/functions/lib/tests/CMakeLists.txt
index ff2e5152a6c..632c3107f16 100644
--- a/velox/functions/lib/tests/CMakeLists.txt
+++ b/velox/functions/lib/tests/CMakeLists.txt
@@ -17,19 +17,24 @@ add_executable(
   ArrayRemoveNullsTest.cpp
   CheckNestedNullsTest.cpp
   DateTimeFormatterTest.cpp
+  HllAccumulatorTest.cpp
   IsNullTest.cpp
   IsNotNullTest.cpp
+  KHyperLogLogTest.cpp
   KllSketchTest.cpp
   LambdaFunctionUtilTest.cpp
+  MakeRowFromMapTest.cpp
   MapConcatTest.cpp
   QuantileDigestTest.cpp
   Re2FunctionsTest.cpp
   RepeatTest.cpp
+  SetDigestTest.cpp
   TDigestTest.cpp
   TimeUtilsTest.cpp
   Utf8Test.cpp
   ZetaDistributionTest.cpp
 )
+velox_add_test_headers(velox_functions_lib_test QuantileDigestTestBase.h)
 
 add_test(
   NAME velox_functions_lib_test
@@ -50,3 +55,5 @@ target_link_libraries(
   GTest::gtest_main
   GTest::gmock
 )
+
+velox_add_library(velox_functions_lib_slice_test_base INTERFACE HEADERS SliceTestBase.h)
diff --git a/velox/functions/lib/tests/CheckNestedNullsTest.cpp b/velox/functions/lib/tests/CheckNestedNullsTest.cpp
index 3b033644383..df716b16453 100644
--- a/velox/functions/lib/tests/CheckNestedNullsTest.cpp
+++ b/velox/functions/lib/tests/CheckNestedNullsTest.cpp
@@ -40,15 +40,15 @@ TEST_F(CheckNestedNullsTest, array) {
 
   for (bool throwOnNestedNulls : {true, false}) {
     ASSERT_TRUE(
-        checkNestedNulls(decodedVector, indices, 0, throwOnNestedNulls));
+        checkNestedNulls(decodedVector, 0, indices[0], throwOnNestedNulls));
     ASSERT_FALSE(
-        checkNestedNulls(decodedVector, indices, 1, throwOnNestedNulls));
+        checkNestedNulls(decodedVector, 1, indices[1], throwOnNestedNulls));
   }
 
   VELOX_ASSERT_THROW(
-      checkNestedNulls(decodedVector, indices, 2, true),
+      checkNestedNulls(decodedVector, 2, indices[2], true),
       "ARRAY comparison not supported for values that contain nulls");
-  ASSERT_FALSE(checkNestedNulls(decodedVector, indices, 2, false));
+  ASSERT_FALSE(checkNestedNulls(decodedVector, 2, indices[2], false));
 }
 
 TEST_F(CheckNestedNullsTest, map) {
@@ -62,15 +62,15 @@ TEST_F(CheckNestedNullsTest, map) {
 
   for (bool throwOnNestedNulls : {true, false}) {
     ASSERT_TRUE(
-        checkNestedNulls(decodedVector, indices, 0, throwOnNestedNulls));
+        checkNestedNulls(decodedVector, 0, indices[0], throwOnNestedNulls));
     ASSERT_FALSE(
-        checkNestedNulls(decodedVector, indices, 1, throwOnNestedNulls));
+        checkNestedNulls(decodedVector, 1, indices[1], throwOnNestedNulls));
   }
 
   VELOX_ASSERT_THROW(
-      checkNestedNulls(decodedVector, indices, 2, true),
+      checkNestedNulls(decodedVector, 2, indices[2], true),
       "MAP comparison not supported for values that contain nulls");
-  ASSERT_FALSE(checkNestedNulls(decodedVector, indices, 2, false));
+  ASSERT_FALSE(checkNestedNulls(decodedVector, 2, indices[2], false));
 }
 
 TEST_F(CheckNestedNullsTest, row) {
@@ -93,14 +93,14 @@ TEST_F(CheckNestedNullsTest, row) {
 
   for (bool throwOnNestedNulls : {true, false}) {
     ASSERT_TRUE(
-        checkNestedNulls(decodedVector, indices, 0, throwOnNestedNulls));
+        checkNestedNulls(decodedVector, 0, indices[0], throwOnNestedNulls));
     ASSERT_FALSE(
-        checkNestedNulls(decodedVector, indices, 1, throwOnNestedNulls));
+        checkNestedNulls(decodedVector, 1, indices[1], throwOnNestedNulls));
   }
 
   VELOX_ASSERT_THROW(
-      checkNestedNulls(decodedVector, indices, 2, true),
+      checkNestedNulls(decodedVector, 2, indices[2], true),
       "ROW comparison not supported for values that contain nulls");
-  ASSERT_FALSE(checkNestedNulls(decodedVector, indices, 2, false));
+  ASSERT_FALSE(checkNestedNulls(decodedVector, 2, indices[2], false));
 }
 } // namespace facebook::velox::functions::test
diff --git a/velox/functions/lib/tests/DateTimeFormatterTest.cpp b/velox/functions/lib/tests/DateTimeFormatterTest.cpp
index 218bd4a5097..724c8ff4b08 100644
--- a/velox/functions/lib/tests/DateTimeFormatterTest.cpp
+++ b/velox/functions/lib/tests/DateTimeFormatterTest.cpp
@@ -1347,7 +1347,7 @@ TEST_F(JodaDateTimeFormatterTest, formatResultSize) {
   EXPECT_EQ(getJodaDateTimeFormatter("CCCCCCCCC")->maxResultSize(timezone), 9);
 
   EXPECT_EQ(
-      getJodaDateTimeFormatter("yyyy-MM-dd z")->maxResultSize(timezone), 23);
+      getJodaDateTimeFormatter("yyyy-MM-dd z")->maxResultSize(timezone), 26);
   EXPECT_EQ(
       getJodaDateTimeFormatter("yyyy-MM-dd Z")->maxResultSize(timezone), 25);
   EXPECT_EQ(
@@ -2368,16 +2368,16 @@ TEST_F(SimpleDateTimeFormatterTest, parseSimpleWeekOfMonth) {
     // Format contains year, month, weekOfMonth and dayOfWeek.
     EXPECT_EQ(
         fromTimestampString("2024-08-02"),
-        parseSimple("2024 08 01 5", "yyyy MM WW e", lenient).timestamp);
+        parseSimple("2024 08 01 5", "yyyy MM WW u", lenient).timestamp);
     EXPECT_EQ(
         fromTimestampString("2024-08-03"),
-        parseSimple("2024 08 01 6", "yyyy MM WW e", lenient).timestamp);
+        parseSimple("2024 08 01 6", "yyyy MM WW u", lenient).timestamp);
     EXPECT_EQ(
         fromTimestampString("2024-08-09"),
-        parseSimple("2024 08 02 5", "yyyy MM WW e", lenient).timestamp);
+        parseSimple("2024 08 02 5", "yyyy MM WW u", lenient).timestamp);
     EXPECT_EQ(
         fromTimestampString("2024-08-12"),
-        parseSimple("2024 08 03 1", "yyyy MM WW e", lenient).timestamp);
+        parseSimple("2024 08 03 1", "yyyy MM WW u", lenient).timestamp);
 
     // Format contains year, month and weekOfMonth.
     EXPECT_EQ(
@@ -2398,25 +2398,25 @@ TEST_F(SimpleDateTimeFormatterTest, parseSimpleWeekOfMonth) {
   // Field out of range for lenient mode.
   EXPECT_EQ(
       fromTimestampString("2024-09-30"),
-      parseSimple("2024 08 10 1", "yyyy MM WW e", true).timestamp);
+      parseSimple("2024 08 10 1", "yyyy MM WW u", true).timestamp);
   EXPECT_EQ(
       fromTimestampString("2024-07-28"),
       parseSimple("2024 08 01", "yyyy MM WW", true).timestamp);
   EXPECT_EQ(
       fromTimestampString("2025-02-24"),
-      parseSimple("2024 15 01 1", "yyyy MM WW e", true).timestamp);
+      parseSimple("2024 15 01 1", "yyyy MM WW u", true).timestamp);
   EXPECT_EQ(
       fromTimestampString("2024-07-29"),
-      parseSimple("2024 08 01 9", "yyyy MM WW e", true).timestamp);
+      parseSimple("2024 08 01 9", "yyyy MM WW u", true).timestamp);
 
   // Field out of range for strict mode.
   EXPECT_THROW(
-      parseSimple("2024 08 10 1", "yyyy MM WW e", false), VeloxUserError);
+      parseSimple("2024 08 10 1", "yyyy MM WW u", false), VeloxUserError);
   EXPECT_THROW(parseSimple("2024 08 10", "yyyy MM WW", false), VeloxUserError);
   EXPECT_THROW(
-      parseSimple("2024 15 01 1", "yyyy MM WW e", false), VeloxUserError);
+      parseSimple("2024 15 01 1", "yyyy MM WW u", false), VeloxUserError);
   EXPECT_THROW(
-      parseSimple("2024 08 01 9", "yyyy MM WW e", false), VeloxUserError);
+      parseSimple("2024 08 01 9", "yyyy MM WW u", false), VeloxUserError);
 }
 
 TEST_F(SimpleDateTimeFormatterTest, formatResultSize) {
diff --git a/velox/functions/lib/tests/HllAccumulatorTest.cpp b/velox/functions/lib/tests/HllAccumulatorTest.cpp
new file mode 100644
index 00000000000..5a80754dd57
--- /dev/null
+++ b/velox/functions/lib/tests/HllAccumulatorTest.cpp
@@ -0,0 +1,331 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/lib/HllAccumulator.h"
+
+#include "velox/common/base/XxHashInline.h"
+
+#include <gtest/gtest-typed-test.h>
+#include <gtest/gtest.h>
+
+using namespace facebook::velox;
+using namespace facebook::velox::common::hll;
+
+namespace {
+const int8_t kDefaultIndexBitLength = 11;
+const double kDefaultStandardError =
+    1.04 / std::sqrt(1 << kDefaultIndexBitLength);
+} // namespace
+
+template <typename TAllocator>
+class HllAccumulatorTest : public ::testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    if constexpr (std::is_same_v<TAllocator, HashStringAllocator>) {
+      allocator_ = &hsa_;
+    } else {
+      allocator_ = pool_.get();
+    }
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
+  HashStringAllocator hsa_{pool_.get()};
+  TAllocator* allocator_{};
+};
+
+using AllocatorTypes =
+    ::testing::Types<HashStringAllocator, memory::MemoryPool>;
+
+class NameGenerator {
+ public:
+  template <typename TAllocator>
+  static std::string GetName(int) {
+    if constexpr (std::is_same_v<TAllocator, HashStringAllocator>) {
+      return "hsa";
+    } else if constexpr (std::is_same_v<TAllocator, memory::MemoryPool>) {
+      return "pool";
+    } else {
+      VELOX_UNREACHABLE(
+          "Only HashStringAllocator and MemoryPool are supported allocator types.");
+    }
+  }
+};
+
+TYPED_TEST_SUITE(HllAccumulatorTest, AllocatorTypes, NameGenerator);
+
+TYPED_TEST(HllAccumulatorTest, basicInt64) {
+  // Test SparseHLL.
+  HllAccumulator<int64_t, false, TypeParam> accumulator(
+      kDefaultIndexBitLength, this->allocator_);
+
+  constexpr int64_t numValues = 100;
+  for (int64_t i = 0; i < numValues; i++) {
+    accumulator.append(i);
+  }
+
+  // Sparse HLL should be exact.
+  EXPECT_EQ(accumulator.cardinality(), numValues);
+
+  // Test DenseHLL.
+  constexpr int64_t numValuesDense = 10000;
+  for (int64_t i = 0; i < numValuesDense; i++) {
+    accumulator.append(i);
+  }
+  EXPECT_NEAR(
+      accumulator.cardinality(),
+      numValuesDense,
+      numValuesDense * kDefaultStandardError);
+}
+
+TYPED_TEST(HllAccumulatorTest, basicDouble) {
+  // Test SparseHLL.
+  HllAccumulator<double, true, TypeParam> accumulator(
+      kDefaultIndexBitLength, this->allocator_);
+
+  constexpr int numValues = 150;
+  for (int i = 0; i < numValues; i++) {
+    accumulator.append(static_cast<double>(i) * 1.5);
+  }
+  EXPECT_EQ(accumulator.cardinality(), numValues);
+
+  // Test DenseHLL.
+  constexpr int numValuesDense = 15000;
+  for (int i = numValues; i < numValuesDense; i++) {
+    accumulator.append(static_cast<double>(i) * 1.5);
+  }
+  EXPECT_NEAR(
+      accumulator.cardinality(),
+      numValuesDense,
+      numValuesDense * kDefaultStandardError);
+}
+
+TYPED_TEST(HllAccumulatorTest, basicStringView) {
+  // Test SparseHLL.
+  HllAccumulator<StringView, true, TypeParam> accumulator(
+      kDefaultIndexBitLength, this->allocator_);
+
+  constexpr int numValues = 100;
+  std::vector<std::string> strings;
+  strings.reserve(numValues);
+  for (int i = 0; i < numValues; i++) {
+    strings.push_back("value_" + std::to_string(i));
+  }
+  for (const auto& str : strings) {
+    accumulator.append(StringView(str));
+  }
+  EXPECT_EQ(accumulator.cardinality(), numValues);
+
+  // Test DenseHLL.
+  constexpr int numValuesDense = 10000;
+  for (int i = numValues; i < numValuesDense; i++) {
+    strings.push_back("value_" + std::to_string(i));
+  }
+  for (int i = numValues; i < numValuesDense; i++) {
+    accumulator.append(StringView(strings[i]));
+  }
+  EXPECT_NEAR(
+      accumulator.cardinality(),
+      numValuesDense,
+      numValuesDense * kDefaultStandardError);
+}
+
+TYPED_TEST(HllAccumulatorTest, serde) {
+  HllAccumulator<int64_t, false, TypeParam> accumulator(
+      kDefaultIndexBitLength, this->allocator_);
+
+  constexpr int64_t numValues = 200;
+  for (int64_t i = 0; i < numValues; i++) {
+    accumulator.append(i);
+  }
+
+  auto size = accumulator.serializedSize();
+  std::string serialized(size, '\0');
+  accumulator.serialize(serialized.data());
+
+  auto deserialized = HllAccumulator<int64_t, false, TypeParam>::deserialize(
+      serialized.data(), this->allocator_);
+
+  EXPECT_EQ(deserialized->cardinality(), numValues);
+
+  // Test round trip
+  std::string reserialized(deserialized->serializedSize(), '\0');
+  deserialized->serialize(reserialized.data());
+  EXPECT_EQ(reserialized, serialized);
+}
+
+TYPED_TEST(HllAccumulatorTest, mergeWithBothSparse) {
+  HllAccumulator<int64_t, false, TypeParam> accumulator1(
+      kDefaultIndexBitLength, this->allocator_);
+  HllAccumulator<int64_t, false, TypeParam> accumulator2(
+      kDefaultIndexBitLength, this->allocator_);
+
+  // Add non-overlapping values that keep both sparse.
+  for (int64_t i = 0; i < 100; i++) {
+    accumulator1.append(i);
+  }
+  for (int64_t i = 100; i < 200; i++) {
+    accumulator2.append(i);
+  }
+
+  accumulator1.mergeWith(accumulator2);
+
+  // Resulting accumulator should be sparse and exact.
+  EXPECT_TRUE(accumulator1.isSparse());
+  EXPECT_EQ(accumulator1.cardinality(), 200);
+}
+
+TYPED_TEST(HllAccumulatorTest, mergeWithBothDense) {
+  HllAccumulator<int64_t, false, TypeParam> accumulator1(
+      kDefaultIndexBitLength, this->allocator_);
+  HllAccumulator<int64_t, false, TypeParam> accumulator2(
+      kDefaultIndexBitLength, this->allocator_);
+
+  // Add non-overlapping values that trigger dense mode.
+  constexpr int64_t numValues = 10000;
+  for (int64_t i = 0; i < 5000; i++) {
+    accumulator1.append(i);
+  }
+  for (int64_t i = 5000; i < numValues; i++) {
+    accumulator2.append(i);
+  }
+
+  accumulator1.mergeWith(accumulator2);
+  EXPECT_FALSE(accumulator1.isSparse());
+
+  EXPECT_NEAR(
+      accumulator1.cardinality(), numValues, numValues * kDefaultStandardError);
+}
+
+TYPED_TEST(HllAccumulatorTest, mergeSparseWithDense) {
+  HllAccumulator<int64_t, false, TypeParam> sparseAccumulator(
+      kDefaultIndexBitLength, this->allocator_);
+  HllAccumulator<int64_t, false, TypeParam> denseAccumulator(
+      kDefaultIndexBitLength, this->allocator_);
+
+  for (int64_t i = 0; i < 100; i++) {
+    sparseAccumulator.append(i);
+  }
+
+  constexpr int64_t numValuesDense = 5000;
+  for (int64_t i = 100; i < numValuesDense; i++) {
+    denseAccumulator.append(i);
+  }
+
+  sparseAccumulator.mergeWith(denseAccumulator);
+
+  // mergeWith should convert any sparse accumulator to dense if either is
+  // dense. Result should be dense and approximate.
+
+  EXPECT_FALSE(sparseAccumulator.isSparse());
+  EXPECT_NEAR(
+      sparseAccumulator.cardinality(),
+      numValuesDense,
+      numValuesDense * kDefaultStandardError);
+}
+
+TYPED_TEST(HllAccumulatorTest, mergeDenseWithSparse) {
+  HllAccumulator<int64_t, false, TypeParam> sparseAccumulator(
+      kDefaultIndexBitLength, this->allocator_);
+  HllAccumulator<int64_t, false, TypeParam> denseAccumulator(
+      kDefaultIndexBitLength, this->allocator_);
+
+  for (int64_t i = 0; i < 100; i++) {
+    sparseAccumulator.append(i);
+  }
+
+  constexpr int64_t numValuesDense = 5000;
+  for (int64_t i = 100; i < numValuesDense; i++) {
+    denseAccumulator.append(i);
+  }
+
+  denseAccumulator.mergeWith(sparseAccumulator);
+
+  // Result should be dense and approximate.
+  EXPECT_FALSE(denseAccumulator.isSparse());
+  EXPECT_NEAR(
+      denseAccumulator.cardinality(),
+      numValuesDense,
+      numValuesDense * kDefaultStandardError);
+}
+
+TYPED_TEST(HllAccumulatorTest, mergeWithSerializedDataSparse) {
+  HllAccumulator<int64_t, false, TypeParam> accumulator1(
+      kDefaultIndexBitLength, this->allocator_);
+  HllAccumulator<int64_t, false, TypeParam> accumulator2(
+      kDefaultIndexBitLength, this->allocator_);
+
+  for (int64_t i = 0; i < 100; i++) {
+    accumulator1.append(i);
+  }
+  for (int64_t i = 100; i < 200; i++) {
+    accumulator2.append(i);
+  }
+
+  auto size = accumulator2.serializedSize();
+  std::string buffer(size, '\0');
+  accumulator2.serialize(buffer.data());
+
+  // Merge with serialized data (should remain sparse).
+  accumulator1.mergeWith(StringView(buffer), this->allocator_);
+
+  // Should be sparse and exact.
+  EXPECT_TRUE(accumulator1.isSparse());
+  EXPECT_EQ(accumulator1.cardinality(), 200);
+}
+
+TYPED_TEST(HllAccumulatorTest, mergeWithOverlappingDataSparse) {
+  HllAccumulator<int64_t, false, TypeParam> accumulator1(
+      kDefaultIndexBitLength, this->allocator_);
+  HllAccumulator<int64_t, false, TypeParam> accumulator2(
+      kDefaultIndexBitLength, this->allocator_);
+
+  for (int64_t i = 0; i < 100; i++) {
+    accumulator1.append(i);
+  }
+  for (int64_t i = 50; i < 150; i++) {
+    accumulator2.append(i);
+  }
+
+  accumulator1.mergeWith(accumulator2);
+
+  // Sparse HLL should be sparse and exact: union of [0, 100) and [50, 150) =
+  // [0, 150)
+  EXPECT_TRUE(accumulator1.isSparse());
+  EXPECT_EQ(accumulator1.cardinality(), 150);
+}
+
+TYPED_TEST(HllAccumulatorTest, mergeUninitializedAccumulator) {
+  HllAccumulator<int64_t, false, TypeParam> accumulator(this->allocator_);
+  HllAccumulator<int64_t, false, TypeParam> initialized(
+      kDefaultIndexBitLength, this->allocator_);
+
+  constexpr int64_t numValues = 100;
+  for (int64_t i = 0; i < numValues; i++) {
+    initialized.append(i);
+  }
+
+  auto size = initialized.serializedSize();
+  std::string buffer(size, '\0');
+  initialized.serialize(buffer.data());
+
+  accumulator.mergeWith(StringView(buffer), this->allocator_);
+
+  EXPECT_EQ(accumulator.cardinality(), numValues);
+}
diff --git a/velox/functions/lib/tests/KHyperLogLogTest.cpp b/velox/functions/lib/tests/KHyperLogLogTest.cpp
new file mode 100644
index 00000000000..239ef9c261c
--- /dev/null
+++ b/velox/functions/lib/tests/KHyperLogLogTest.cpp
@@ -0,0 +1,710 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/lib/KHyperLogLog.h"
+#include "velox/common/memory/Memory.h"
+
+#include <folly/Random.h>
+#include <gtest/gtest.h>
+#include <set>
+#include <unordered_set>
+#include "velox/type/Timestamp.h"
+
+using namespace facebook::velox::common::hll;
+using namespace facebook::velox::memory;
+using namespace facebook::velox;
+
+namespace {
+const int32_t kDefaultNumBuckets = 256;
+// Theoretical relative standard error formula from the HyperLogLog paper
+// (Flajolet et al.): 1.04 / sqrt(num buckets)
+const double kDefaultStandardError = 1.04 / std::sqrt(kDefaultNumBuckets);
+} // namespace
+
+class KHyperLogLogTest : public ::testing::Test {
+ public:
+  static void SetUpTestSuite() {
+    facebook::velox::memory::MemoryManager::testingSetInstance({});
+  }
+
+  void SetUp() override {
+    pool_ = facebook::velox::memory::memoryManager()->addLeafPool();
+    hsa_ = std::make_unique<HashStringAllocator>(pool_.get());
+    allocator_ = hsa_.get();
+  }
+
+  void TearDown() override {
+    // Clean up allocator before pool.
+    hsa_.reset();
+    pool_.reset();
+  }
+
+ protected:
+  std::shared_ptr<MemoryPool> pool_;
+  std::unique_ptr<HashStringAllocator> hsa_;
+  HashStringAllocator* allocator_{};
+
+  // Helper function to generate random values with quadratic distribution.
+  // Squaring a uniform random [0.0, 1.0] heavily skews results toward zero
+  // (e.g., ~70% of values fall in the lower half). This simulates realistic
+  // data where most values have low cardinality and few have high cardinality,
+  // which is critical for testing KHLL's privacy features under conditions
+  // where re-identification risk is highest.
+  int64_t randomLong(int64_t range) {
+    double random = folly::Random::randDouble01();
+    return static_cast<int64_t>(std::pow(random, 2.0) * range);
+  }
+
+  // Creates a KHyperLogLog with specific values for testing.
+  std::unique_ptr<KHyperLogLog<int64_t, HashStringAllocator>> createKHLL(
+      const std::vector<int64_t>& values,
+      const std::vector<int64_t>& uiis) {
+    EXPECT_EQ(values.size(), uiis.size());
+    auto khll = std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(
+        allocator_);
+
+    for (size_t i = 0; i < values.size(); ++i) {
+      khll->add(values[i], uiis[i]);
+    }
+
+    return khll;
+  }
+};
+
+TEST_F(KHyperLogLogTest, basicCardinality) {
+  auto khll =
+      std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(allocator_);
+
+  // Empty KHLL should have cardinality 0.
+  EXPECT_EQ(0, khll->cardinality());
+  EXPECT_TRUE(khll->isExact());
+
+  // Add some values.
+  for (int64_t i = 0; i < 100; ++i) {
+    khll->add(i, randomLong(100));
+  }
+
+  // Should be exact since it is under the default max size.
+  EXPECT_TRUE(khll->isExact());
+  EXPECT_EQ(100, khll->cardinality());
+}
+
+TEST_F(KHyperLogLogTest, cardinalityAccuracy) {
+  // Test representative precision levels (low and high) to ensure
+  // accuracy across different bucket configurations: 4 (16 buckets) and
+  // 12 (4096 buckets).
+  const int trials = 30;
+
+  for (int indexBits : {4, 12}) {
+    const int numberOfBuckets = 1 << indexBits;
+    const int maxCardinality = numberOfBuckets * 2;
+
+    std::vector<double> errors;
+
+    for (int trial = 0; trial < trials; ++trial) {
+      auto khll = std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(
+          KHyperLogLog<int64_t, HashStringAllocator>::kDefaultMaxSize,
+          numberOfBuckets,
+          allocator_);
+
+      for (int cardinality = 1; cardinality <= maxCardinality; cardinality++) {
+        khll->add(folly::Random::rand64(), 0L);
+
+        // Sample every 20% of bucket count (vs Java's 10%) to reduce test
+        // time
+        if (cardinality % (numberOfBuckets / 5) == 0) {
+          double error =
+              (static_cast<double>(khll->cardinality()) - cardinality) /
+              cardinality;
+          errors.push_back(std::abs(error));
+        }
+      }
+    }
+
+    // Calculate standard deviation
+    double mean = 0.0;
+    for (double error : errors) {
+      mean += error;
+    }
+    mean /= errors.size();
+
+    double variance = 0.0;
+    for (double error : errors) {
+      variance += (error - mean) * (error - mean);
+    }
+    variance /= errors.size();
+    double stdDev = std::sqrt(variance);
+
+    EXPECT_LE(stdDev, kDefaultStandardError)
+        << "Cardinality mismatch at indexBits " << indexBits << ", bucket "
+        << numberOfBuckets;
+  }
+}
+
+TEST_F(KHyperLogLogTest, mergeWith) {
+  auto khll1 = createKHLL(
+      std::vector<int64_t>{0, 1, 2, 3, 4, 5},
+      std::vector<int64_t>{10, 11, 12, 13, 14, 15});
+
+  auto khll2 = createKHLL(
+      std::vector<int64_t>{3, 4, 5, 6, 7, 8},
+      std::vector<int64_t>{13, 14, 15, 16, 17, 18});
+
+  auto expected = createKHLL(
+      std::vector<int64_t>{0, 1, 2, 3, 4, 5, 6, 7, 8},
+      std::vector<int64_t>{10, 11, 12, 13, 14, 15, 16, 17, 18});
+
+  khll1->mergeWith(*khll2);
+
+  EXPECT_EQ(expected->cardinality(), khll1->cardinality());
+  EXPECT_EQ(
+      expected->reidentificationPotential(10),
+      khll1->reidentificationPotential(10));
+}
+
+TEST_F(KHyperLogLogTest, merge) {
+  // Helpers to create a KHLL with given maxSize and data
+  auto createSmaller = [&]() {
+    const auto smallerSize = 5;
+    auto khll = std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(
+        smallerSize, kDefaultNumBuckets, allocator_);
+    for (size_t i = 0; i < smallerSize; ++i) {
+      khll->add(i, i);
+    }
+    return khll;
+  };
+
+  auto createLarger = [&]() {
+    const auto largerSize = 10;
+    auto khll = std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(
+        largerSize, kDefaultNumBuckets, allocator_);
+    for (size_t i = 0; i < largerSize; ++i) {
+      khll->add(i, i);
+    }
+    return khll;
+  };
+
+  // Test merge(left, right)
+  auto smallerFirst = KHyperLogLog<int64_t, HashStringAllocator>::merge(
+      createSmaller(), createLarger());
+
+  // Test merge(right, left) - should produce same result
+  auto largerFist = KHyperLogLog<int64_t, HashStringAllocator>::merge(
+      createLarger(), createSmaller());
+
+  EXPECT_EQ(smallerFirst->cardinality(), largerFist->cardinality());
+
+  // Explicitly merging smaller into larger should produce different results.
+  auto larger = createLarger();
+  larger->mergeWith(*createSmaller());
+  EXPECT_NE(larger->cardinality(), largerFist->cardinality());
+}
+
+TEST_F(KHyperLogLogTest, serde) {
+  // Test small serialization
+  std::vector<int64_t> values;
+  std::vector<int64_t> uiis;
+
+  for (int64_t i = 0; i < 1000; ++i) {
+    values.push_back(i);
+    uiis.push_back(randomLong(100));
+  }
+
+  auto khll = createKHLL(values, uiis);
+
+  size_t totalSize = khll->estimatedSerializedSize();
+  std::string outputBuffer(totalSize, '\0');
+  khll->serialize(outputBuffer.data());
+  auto deserializedResult =
+      KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+          outputBuffer.data(), outputBuffer.size(), allocator_);
+  ASSERT_TRUE(deserializedResult.hasValue());
+  auto& deserialized = deserializedResult.value();
+
+  EXPECT_EQ(khll->cardinality(), deserialized->cardinality());
+  EXPECT_EQ(
+      khll->reidentificationPotential(10),
+      deserialized->reidentificationPotential(10));
+
+  // Test round-trip
+  std::string reserializeBuffer(totalSize, '\0');
+  deserialized->serialize(reserializeBuffer.data());
+  EXPECT_EQ(outputBuffer, reserializeBuffer);
+
+  // Test empty KHLL round-trip
+  auto emptyKhll = createKHLL({}, {});
+  size_t emptySize = emptyKhll->estimatedSerializedSize();
+  std::string emptyOutputBuffer(emptySize, '\0');
+  emptyKhll->serialize(emptyOutputBuffer.data());
+  auto deserializedEmptyResult =
+      KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+          emptyOutputBuffer.data(), emptyOutputBuffer.size(), allocator_);
+  ASSERT_TRUE(deserializedEmptyResult.hasValue());
+  auto& deserializedEmpty = deserializedEmptyResult.value();
+  EXPECT_EQ(deserializedEmpty->cardinality(), 0);
+  std::string reserializedEmptyOutputBuffer(emptySize, '\0');
+  deserializedEmpty->serialize(reserializedEmptyOutputBuffer.data());
+  EXPECT_EQ(emptyOutputBuffer, reserializedEmptyOutputBuffer);
+}
+
+TEST_F(KHyperLogLogTest, uniquenessDistribution) {
+  const int histogramSize = 256;
+  const int count = 1000;
+
+  auto khll =
+      std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(allocator_);
+  std::map<int64_t, std::set<int64_t>> valueToUiis;
+
+  for (int i = 0; i < count; ++i) {
+    int64_t uii = randomLong(histogramSize);
+    int64_t value = randomLong(count);
+    khll->add(value, uii);
+    valueToUiis[value].insert(uii);
+  }
+  auto khllHistogram = khll->uniquenessDistribution(histogramSize);
+
+  // Build the actual histogram
+  std::map<int64_t, double> actualHistogram;
+  int size = valueToUiis.size();
+
+  for (const auto& [value, uiiSet] : valueToUiis) {
+    int64_t bucket = std::min(
+        static_cast<int64_t>(uiiSet.size()),
+        static_cast<int64_t>(histogramSize));
+    actualHistogram[bucket] += 1.0 / size;
+  }
+
+  // Verify histogram accuracy (with some tolerance for approximation)
+  for (int64_t i = 1; i < histogramSize; ++i) {
+    double expected = actualHistogram.count(i) ? actualHistogram[i] : 0.0;
+    double khllEstimated = khllHistogram.count(i) ? khllHistogram[i] : 0.0;
+
+    // Use 10% tolerance since the values of uniqueness distribution are a sum
+    // of 1 / size of minHash, and not the cardinality estimates.
+    // Allow larger tolerance for buckets with very few values.
+    double tolerance = std::max(2.0 / size, 0.1 * expected);
+    EXPECT_NEAR(khllEstimated, expected, tolerance)
+        << "Histogram mismatch at bucket " << i;
+  }
+}
+
+TEST_F(KHyperLogLogTest, reidentificationPotential) {
+  auto khll =
+      std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(allocator_);
+  std::map<int64_t, std::set<int64_t>> valueToUiis;
+
+  const int count = 1000;
+  for (int i = 0; i < count; ++i) {
+    int64_t uii = randomLong(100);
+    int64_t value = randomLong(count);
+    khll->add(value, uii);
+    valueToUiis[value].insert(uii);
+  }
+
+  // Test different thresholds
+  for (int threshold = 1; threshold < 10; ++threshold) {
+    double khllEstimated = khll->reidentificationPotential(threshold);
+
+    // Calculate the actual reidentification potential
+    int highlyUniqueCount = 0;
+    for (const auto& [value, uiiSet] : valueToUiis) {
+      if (static_cast<int>(uiiSet.size()) <= threshold) {
+        highlyUniqueCount++;
+      }
+    }
+
+    double expected =
+        static_cast<double>(highlyUniqueCount) / valueToUiis.size();
+
+    if (expected > 0) {
+      EXPECT_NEAR(khllEstimated, expected, expected * kDefaultStandardError)
+          << "Reidentification potential mismatch for threshold " << threshold;
+    }
+  }
+}
+
+TEST_F(KHyperLogLogTest, exactIntersectionCardinality) {
+  auto khll1 = createKHLL(
+      std::vector<int64_t>{1, 2, 3, 4, 5},
+      std::vector<int64_t>{10, 20, 30, 40, 50});
+
+  auto khll2 = createKHLL(
+      std::vector<int64_t>{3, 4, 5, 6, 7},
+      std::vector<int64_t>{30, 40, 50, 60, 70});
+
+  EXPECT_TRUE(khll1->isExact());
+  EXPECT_TRUE(khll2->isExact());
+
+  int64_t intersection =
+      KHyperLogLog<int64_t, HashStringAllocator>::exactIntersectionCardinality(
+          *khll1, *khll2);
+  // Values 3, 4, 5 are in both
+  EXPECT_EQ(3, intersection);
+}
+
+TEST_F(KHyperLogLogTest, jaccardIndex) {
+  // Test with larger datasets.
+  // Create two KHLLs where one is a subset of the other
+  const int64_t set1Size = 100000;
+  const int64_t set2Size = 150000;
+
+  auto khll1 =
+      std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(allocator_);
+  auto khll2 =
+      std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(allocator_);
+
+  // Add values 0 to 99,999 to khll1
+  for (int64_t i = 0; i < set1Size; ++i) {
+    khll1->add(i, randomLong(100));
+  }
+
+  // Add values 0 to 149,999 to khll2 (includes all of khll1)
+  for (int64_t i = 0; i < set2Size; ++i) {
+    khll2->add(i, randomLong(100));
+  }
+
+  double jaccard =
+      KHyperLogLog<int64_t, HashStringAllocator>::jaccardIndex(*khll1, *khll2);
+
+  // Expected Jaccard = |intersection| / |union|
+  // Intersection: 100,000 (all of set1)
+  // Union: 150,000 (all of set2)
+  // Jaccard = 100,000 / 150,000 = 2/3 ≈ 0.6667
+  double expectedJaccard = static_cast<double>(set1Size) / set2Size;
+
+  EXPECT_NEAR(
+      jaccard, expectedJaccard, expectedJaccard * kDefaultStandardError);
+}
+
+TEST_F(KHyperLogLogTest, largeDataset) {
+  auto khll =
+      std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(allocator_);
+
+  const int count = 200000;
+  std::unordered_set<int64_t> uniqueValues;
+
+  for (int i = 0; i < count; ++i) {
+    int64_t value = folly::Random::rand64();
+    int64_t uii = randomLong(100);
+    khll->add(value, uii);
+    uniqueValues.insert(value);
+  }
+
+  EXPECT_FALSE(khll->isExact());
+
+  int64_t expected = static_cast<int64_t>(uniqueValues.size());
+  int64_t khllEstimated = khll->cardinality();
+
+  EXPECT_NEAR(expected, khllEstimated, khllEstimated * kDefaultStandardError);
+}
+
+TEST_F(KHyperLogLogTest, minhashSize) {
+  auto khll =
+      std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(allocator_);
+
+  EXPECT_EQ(0, khll->minhashSize());
+
+  khll->add(1, 10);
+  khll->add(2, 20);
+  khll->add(3, 30);
+
+  EXPECT_EQ(3, khll->minhashSize());
+}
+
+TEST_F(KHyperLogLogTest, estimatedSizes) {
+  auto khll =
+      std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(allocator_);
+
+  size_t initialEstimatedSerSize = khll->estimatedSerializedSize();
+
+  for (int64_t i = 0; i < 100; ++i) {
+    khll->add(i, randomLong(100));
+  }
+
+  size_t finalEstimatedSerSize = khll->estimatedSerializedSize();
+
+  // Sizes should increase after adding data.
+  EXPECT_GT(finalEstimatedSerSize, initialEstimatedSerSize);
+
+  // Verify the estimated size is accurate.
+  std::string serializedBuffer(finalEstimatedSerSize, '\0');
+  khll->serialize(serializedBuffer.data());
+  size_t actualSerSize = serializedBuffer.size();
+
+  EXPECT_LE(actualSerSize, finalEstimatedSerSize)
+      << "Actual serialized size exceeds estimate - potential buffer overflow";
+
+  EXPECT_NEAR(
+      actualSerSize,
+      finalEstimatedSerSize,
+      finalEstimatedSerSize * kDefaultStandardError);
+}
+
+TEST_F(KHyperLogLogTest, differentJoinKeyUIITypes) {
+  // Test different TJoinKey, TUii combinations:
+  // int32_t TJoinKey, int32_t TUii
+  {
+    auto khll = std::make_unique<KHyperLogLog<int32_t, HashStringAllocator>>(
+        allocator_);
+    for (int32_t i = 0; i < 100; ++i) {
+      khll->add(i, i);
+    }
+    EXPECT_TRUE(khll->isExact());
+    EXPECT_EQ(100, khll->cardinality());
+
+    // Test round trip
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    auto deserializedResult =
+        KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+            outputBuffer.data(), outputBuffer.size(), allocator_);
+    ASSERT_TRUE(deserializedResult.hasValue());
+    auto& deserialized = deserializedResult.value();
+    std::string reserializeBuffer(totalSize, '\0');
+    deserialized->serialize(reserializeBuffer.data());
+    EXPECT_EQ(outputBuffer, reserializeBuffer);
+  }
+
+  // uint32_t TJoinKey, uint32_t TUii
+  {
+    auto khll = std::make_unique<KHyperLogLog<uint32_t, HashStringAllocator>>(
+        allocator_);
+    for (uint32_t i = 0; i < 100; ++i) {
+      khll->add(i % 10, i);
+    }
+    EXPECT_TRUE(khll->isExact());
+    EXPECT_EQ(10, khll->cardinality());
+
+    // Test round trip
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    auto deserializedResult =
+        KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+            outputBuffer.data(), outputBuffer.size(), allocator_);
+    ASSERT_TRUE(deserializedResult.hasValue());
+    auto& deserialized = deserializedResult.value();
+    std::string reserializeBuffer(totalSize, '\0');
+    deserialized->serialize(reserializeBuffer.data());
+    EXPECT_EQ(outputBuffer, reserializeBuffer);
+  }
+
+  // int16_t TJoinKey, int16_t TUii
+  {
+    auto khll = std::make_unique<KHyperLogLog<int16_t, HashStringAllocator>>(
+        allocator_);
+    for (int16_t i = 0; i < 10000; ++i) {
+      khll->add(i % 100, i);
+    }
+    EXPECT_TRUE(khll->isExact());
+    EXPECT_EQ(100, khll->cardinality());
+
+    // Test round trip
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    auto deserialized = KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+        outputBuffer.data(), outputBuffer.size(), allocator_);
+    ASSERT_TRUE(deserialized.hasValue());
+    std::string reserializeBuffer(totalSize, '\0');
+    deserialized.value()->serialize(reserializeBuffer.data());
+    EXPECT_EQ(outputBuffer, reserializeBuffer);
+  }
+
+  // uint16_t TJoinKey, uint16_t TUii
+  {
+    auto khll = std::make_unique<KHyperLogLog<uint16_t, HashStringAllocator>>(
+        allocator_);
+    for (uint16_t i = 0; i < 100; ++i) {
+      khll->add(i, i);
+    }
+    EXPECT_TRUE(khll->isExact());
+    EXPECT_EQ(100, khll->cardinality());
+
+    // Test round trip
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    auto deserialized = KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+        outputBuffer.data(), outputBuffer.size(), allocator_);
+    ASSERT_TRUE(deserialized.hasValue());
+    std::string reserializeBuffer(totalSize, '\0');
+    deserialized.value()->serialize(reserializeBuffer.data());
+    EXPECT_EQ(outputBuffer, reserializeBuffer);
+  }
+
+  // int8_t TJoinKey, int8_t TUii
+  {
+    auto khll =
+        std::make_unique<KHyperLogLog<int8_t, HashStringAllocator>>(allocator_);
+    for (int8_t i = -100; i < 100; ++i) {
+      khll->add(i, i);
+    }
+    EXPECT_TRUE(khll->isExact());
+    EXPECT_EQ(200, khll->cardinality());
+
+    // Test round trip
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    auto deserialized = KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+        outputBuffer.data(), outputBuffer.size(), allocator_);
+    ASSERT_TRUE(deserialized.hasValue());
+    std::string reserializeBuffer(totalSize, '\0');
+    deserialized.value()->serialize(reserializeBuffer.data());
+    EXPECT_EQ(outputBuffer, reserializeBuffer);
+  }
+
+  // uint8_t TJoinKey, uint8_t TUii
+  {
+    auto khll = std::make_unique<KHyperLogLog<uint8_t, HashStringAllocator>>(
+        allocator_);
+    for (uint8_t i = 0; i < 100; ++i) {
+      khll->add(i, i);
+    }
+    EXPECT_TRUE(khll->isExact());
+    EXPECT_EQ(100, khll->cardinality());
+
+    // Test round trip
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    auto deserialized = KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+        outputBuffer.data(), outputBuffer.size(), allocator_);
+    ASSERT_TRUE(deserialized.hasValue());
+    std::string reserializeBuffer(totalSize, '\0');
+    deserialized.value()->serialize(reserializeBuffer.data());
+    EXPECT_EQ(outputBuffer, reserializeBuffer);
+  }
+
+  // float TJoinKey, float TUii
+  {
+    auto khll =
+        std::make_unique<KHyperLogLog<float, HashStringAllocator>>(allocator_);
+    for (int i = 0; i < 10; ++i) {
+      khll->add(static_cast<float>(i), static_cast<float>(i));
+    }
+    EXPECT_TRUE(khll->isExact());
+    EXPECT_EQ(10, khll->cardinality());
+
+    // Test round trip
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    auto deserialized = KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+        outputBuffer.data(), outputBuffer.size(), allocator_);
+    ASSERT_TRUE(deserialized.hasValue());
+    std::string reserializeBuffer(totalSize, '\0');
+    deserialized.value()->serialize(reserializeBuffer.data());
+    EXPECT_EQ(outputBuffer, reserializeBuffer);
+  }
+
+  // double TJoinKey, double TUii
+  {
+    auto khll =
+        std::make_unique<KHyperLogLog<double, HashStringAllocator>>(allocator_);
+    for (int i = 0; i < 100; ++i) {
+      khll->add(static_cast<double>(i), static_cast<double>(i));
+    }
+    EXPECT_TRUE(khll->isExact());
+    EXPECT_EQ(100, khll->cardinality());
+
+    // Test round trip
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    auto deserialized = KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+        outputBuffer.data(), outputBuffer.size(), allocator_);
+    ASSERT_TRUE(deserialized.hasValue());
+    std::string reserializeBuffer(totalSize, '\0');
+    deserialized.value()->serialize(reserializeBuffer.data());
+    EXPECT_EQ(outputBuffer, reserializeBuffer);
+  }
+
+  // StringView TJoinKey, StringView TUii
+  {
+    auto khll = std::make_unique<KHyperLogLog<StringView, HashStringAllocator>>(
+        allocator_);
+    std::vector<std::string> strings;
+    strings.reserve(100);
+    for (int i = 0; i < 100; ++i) {
+      strings.push_back("key_" + std::to_string(i));
+    }
+    for (int i = 0; i < 100; ++i) {
+      khll->add(StringView(strings[i]), StringView(strings[i]));
+    }
+    EXPECT_TRUE(khll->isExact());
+    EXPECT_EQ(100, khll->cardinality());
+
+    // Test round trip
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    auto deserialized = KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+        outputBuffer.data(), outputBuffer.size(), allocator_);
+    ASSERT_TRUE(deserialized.hasValue());
+    std::string reserializeBuffer(totalSize, '\0');
+    deserialized.value()->serialize(reserializeBuffer.data());
+    EXPECT_EQ(outputBuffer, reserializeBuffer);
+  }
+
+  // Timestamp TJoinKey, Timestamp TUii
+  {
+    auto khll = std::make_unique<KHyperLogLog<Timestamp, HashStringAllocator>>(
+        allocator_);
+    for (int i = 0; i < 100; ++i) {
+      Timestamp ts(i * 1000, 0);
+      khll->add(ts, ts);
+    }
+    EXPECT_TRUE(khll->isExact());
+    EXPECT_EQ(100, khll->cardinality());
+
+    // Test round trip
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    auto deserialized = KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+        outputBuffer.data(), outputBuffer.size(), allocator_);
+    ASSERT_TRUE(deserialized.hasValue());
+    std::string reserializeBuffer(totalSize, '\0');
+    deserialized.value()->serialize(reserializeBuffer.data());
+    EXPECT_EQ(outputBuffer, reserializeBuffer);
+  }
+
+  // int128_t TJoinKey, int128_t TUii
+  {
+    auto khll = std::make_unique<KHyperLogLog<int128_t, HashStringAllocator>>(
+        allocator_);
+    for (int i = 0; i < 100; ++i) {
+      // Create 128-bit values with different upper and lower 64 bits
+      int128_t value = (static_cast<int128_t>(i) << 64) | (i + 1000);
+      khll->add(value, value);
+    }
+    EXPECT_TRUE(khll->isExact());
+    EXPECT_EQ(100, khll->cardinality());
+
+    // Test round trip
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    auto deserialized = KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+        outputBuffer.data(), outputBuffer.size(), allocator_);
+    ASSERT_TRUE(deserialized.hasValue());
+    std::string reserializeBuffer(totalSize, '\0');
+    deserialized.value()->serialize(reserializeBuffer.data());
+    EXPECT_EQ(outputBuffer, reserializeBuffer);
+  }
+}
diff --git a/velox/functions/lib/tests/MakeRowFromMapTest.cpp b/velox/functions/lib/tests/MakeRowFromMapTest.cpp
new file mode 100644
index 00000000000..60a9e583fcf
--- /dev/null
+++ b/velox/functions/lib/tests/MakeRowFromMapTest.cpp
@@ -0,0 +1,710 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <glog/logging.h>
+#include <gtest/gtest.h>
+#include <cstdint>
+#include <optional>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/core/Expressions.h"
+#include "velox/core/QueryCtx.h"
+#include "velox/expression/Expr.h"
+#include "velox/functions/lib/MakeRowFromMap.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/parse/ExpressionsParser.h"
+#include "velox/parse/TypeResolver.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/DecodedVector.h"
+#include "velox/vector/SelectivityVector.h"
+#include "velox/vector/SimpleVector.h"
+#include "velox/vector/TypeAliases.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+namespace facebook::velox::functions {
+namespace {
+
+// For testing Opaque types.
+struct NonPOD {
+  static int alive;
+
+  int x;
+  NonPOD(int x = 123) : x(x) {
+    ++alive;
+  }
+  ~NonPOD() {
+    --alive;
+  }
+  bool operator==(const NonPOD& other) const {
+    return x == other.x;
+  }
+};
+
+int NonPOD::alive = 0;
+
+class MakeRowFroMapTest : public testing::Test, public test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    functions::prestosql::registerAllScalarFunctions();
+    parse::registerTypeResolver();
+  }
+
+  template <TypeKind Kind>
+  VectorPtr toRowVector(
+      const BaseVector& map,
+      const MakeRowFromMapOptions& options,
+      const SelectivityVector& rows,
+      exec::EvalCtx* evalCtx = nullptr) {
+    return MakeRowFromMap<Kind>(options).apply(map, rows, evalCtx);
+  }
+
+  // Generates a set of test cases for toRowVector. Each test case
+  // is a MapVector with the same keys but different value types.
+  std::vector<MapVectorPtr> makeTestCases() {
+    std::vector<MapVectorPtr> testCases;
+    auto map = makeMapVectorFromJson<int64_t, int64_t>(
+        {"{1:1, 2:2, 3:3}", // All valid values
+         "{2:20, 4:40, 7:3}", // Only one projected key
+         "{1:100, 2:null, 6:600}", // Null Value
+         "{4:4000, 6:6000}", // No projected keys
+         "{1:10000}", // single element, projected key
+         "{}", // empty map
+         "null"}); // null map
+    auto keyType = map->type()->asMap().keyType();
+    auto intValues = map->mapValues();
+    VELOX_CHECK_EQ(intValues->size(), 12);
+    testCases.push_back(map);
+
+    auto makeCopyWithValues = [&](VectorPtr& values) {
+      return std::make_shared<MapVector>(
+          pool(),
+          MAP(keyType, values->type()),
+          map->nulls(),
+          map->size(),
+          map->offsets(),
+          map->sizes(),
+          map->mapKeys(),
+          values);
+    };
+
+    // With String Values.
+    VectorFuzzer::Options opts{.nullRatio = 0};
+    VectorFuzzer fuzzer(opts, pool());
+    auto stringValues = fuzzer.fuzzFlat(VARCHAR(), intValues->size());
+    stringValues->setNulls(intValues->nulls());
+    testCases.push_back(makeCopyWithValues(stringValues));
+
+    // With Array Values.
+    auto arrayValues = fuzzer.fuzzFlat(ARRAY(BIGINT()), intValues->size());
+    arrayValues->setNulls(intValues->nulls());
+    testCases.push_back(makeCopyWithValues(arrayValues));
+
+    // With Row Values.
+    auto rowValues = fuzzer.fuzzFlat(ROW({BIGINT()}), intValues->size());
+    rowValues->setNulls(intValues->nulls());
+    testCases.push_back(makeCopyWithValues(rowValues));
+
+    // With Map Values.
+    auto mapValues =
+        fuzzer.fuzzFlat(MAP(BIGINT(), BIGINT()), intValues->size());
+    mapValues->setNulls(intValues->nulls());
+    testCases.push_back(makeCopyWithValues(mapValues));
+
+    auto opaqueValues =
+        BaseVector::create(OPAQUE<int>(), intValues->size(), pool());
+    auto flat = opaqueValues->asFlatVector<std::shared_ptr<void>>();
+    for (int i = 0; i < intValues->size(); i++) {
+      flat->set(i, std::make_shared<NonPOD>(i));
+    }
+    testCases.push_back(makeCopyWithValues(opaqueValues));
+
+    return testCases;
+  }
+
+  template <TypeKind ValueKind>
+  void verifyDefaultValue(VectorPtr& vector, vector_size_t row) {
+    if constexpr (
+        (TypeTraits<ValueKind>::isPrimitiveType ||
+         ValueKind == TypeKind::OPAQUE) &&
+        ValueKind != TypeKind::UNKNOWN) {
+      using NativeType = typename TypeTraits<ValueKind>::NativeType;
+      static NativeType defaultValue;
+      ASSERT_EQ(vector->asFlatVector<NativeType>()->valueAt(row), defaultValue);
+    } else if constexpr (
+        ValueKind == TypeKind::ARRAY || ValueKind == TypeKind::MAP) {
+      auto arrayBaseVector = vector->asChecked<ArrayVectorBase>();
+      ASSERT_NE(arrayBaseVector, nullptr);
+      ASSERT_EQ(arrayBaseVector->offsetAt(row), 0);
+      ASSERT_EQ(arrayBaseVector->sizeAt(row), 0);
+    } else {
+      VELOX_USER_FAIL(
+          "Unsupported type for replacing nulls: {}",
+          TypeTraits<ValueKind>::TypeTraits::name);
+    }
+  }
+
+  // For the case where 'replaceNulls' and 'allowTopLevelNulls' is false, we
+  // use this helper function to verify the result by evaluating an expression
+  // that mimics the map to row projection.
+  void verifyResultUsingExprEval(
+      const VectorPtr& result,
+      const VectorPtr& input,
+      SelectivityVector& rows) {
+    auto inputRow = makeRowVector({input});
+    // Evaluate an expression the mimics the map to row projection.
+    // eg: cast(row_constructor(c0[1], c0[2]) as row(key1 bigint, key2 bigint))
+    // Extract keys and wrap it in a struct
+    auto typedExpr = core::Expressions::inferTypes(
+        parse::DuckSqlExpressionsParser().parseExpr(
+            "row_constructor(c0[1], c0[2])"),
+        inputRow->type(),
+        execCtx_->pool());
+    // Wrap the struct in a cast to get the correct field names
+    typedExpr =
+        std::make_shared<core::CastTypedExpr>(result->type(), typedExpr, false);
+    exec::ExprSet exprSet({typedExpr}, execCtx_.get());
+    std::vector<VectorPtr> output;
+    exec::EvalCtx context(execCtx_.get(), &exprSet, inputRow.get());
+    exprSet.eval(rows, context, output);
+    test::assertEqualVectors(result, output[0], rows);
+  }
+
+  // Helper function that verifies the output of toRowVector. For
+  // each row in the result, it retrieves the corresponding value from the
+  // original MapVector by looking up the key for that row, if present. If the
+  // key is not found, it checks that the value is set to null or to the default
+  // value, depending on whether replaceNulls is enabled. As a sanity check, for
+  // cases that can be represented as valid expressions, the verification is
+  // also performed using expression evaluation to ensure the logic is correct.
+  void verifyResult(
+      const VectorPtr& result,
+      const VectorPtr& input,
+      SelectivityVector& rows,
+      MakeRowFromMapOptions& options) {
+    ASSERT_TRUE(result != nullptr);
+    // Assert expected types and field names
+    ASSERT_EQ(result->type()->asRow().children().size(), 2);
+    ASSERT_EQ(result->type()->asRow().nameOf(0), "key1");
+    ASSERT_EQ(result->type()->asRow().nameOf(1), "key2");
+    ASSERT_EQ(
+        result->type()->asRow().childAt(0), input->type()->asMap().valueType());
+    ASSERT_EQ(
+        result->type()->asRow().childAt(1), input->type()->asMap().valueType());
+
+    // Assert expected number of rows
+    ASSERT_EQ(result->size(), rows.end());
+
+    if (!options.replaceNulls && !options.allowTopLevelNulls) {
+      verifyResultUsingExprEval(result, input, rows);
+    }
+
+    DecodedVector decodedInput(*input);
+    auto map = decodedInput.base()->as<MapVector>();
+    auto mapKeys = map->mapKeys()->as<SimpleVector<int64_t>>();
+    auto mapValues = map->mapValues();
+    auto rawOffsets = map->rawOffsets();
+    auto rawSizes = map->rawSizes();
+
+    auto findValueIdx = [&](vector_size_t row,
+                            int64_t key) -> std::optional<vector_size_t> {
+      if (decodedInput.isNullAt(row)) {
+        return std::nullopt;
+      }
+      auto offset = rawOffsets[decodedInput.index(row)];
+      auto size = rawSizes[decodedInput.index(row)];
+      for (auto i = offset; i < offset + size; ++i) {
+        if (mapKeys->valueAt(i) == key) {
+          return i;
+        }
+      }
+      return std::nullopt;
+    };
+    // Verify expected values
+    rows.applyToSelected([&](auto row) {
+      // Check for top-level nulls if allowed
+      if (options.allowTopLevelNulls && !options.replaceNulls &&
+          decodedInput.isNullAt(row)) {
+        ASSERT_TRUE(result->isNullAt(row)) << " row idx: " << row;
+        return;
+      }
+      // For every projected key, find the corresponding value in the original
+      // map and verify its correctly set in the result.
+      for (int64_t key : {1, 2}) {
+        auto valueIdx = findValueIdx(row, key);
+        auto child = result->as<RowVector>()->childAt(key - 1);
+        if (valueIdx.has_value() && !mapValues->isNullAt(valueIdx.value())) {
+          ASSERT_TRUE(!child->isNullAt(row));
+          if (child->type()->kind() == TypeKind::OPAQUE) {
+            auto opaqueValue =
+                child->asFlatVector<std::shared_ptr<void>>()->valueAt(row);
+            auto expectedOpaqueValue =
+                mapValues->as<SimpleVector<std::shared_ptr<void>>>()->valueAt(
+                    valueIdx.value());
+            EXPECT_EQ(
+                *std::static_pointer_cast<NonPOD>(opaqueValue),
+                *std::static_pointer_cast<NonPOD>(expectedOpaqueValue));
+          } else {
+            child->compare(mapValues.get(), row, valueIdx.value());
+          }
+        } else if (options.replaceNulls) {
+          VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
+              verifyDefaultValue, child->type()->kind(), child, row);
+        } else {
+          ASSERT_TRUE(child->isNullAt(row));
+        }
+      }
+    });
+  }
+
+  // Helper to create SelectivityVector for different selected patterns
+  SelectivityVector createSelectivityVector(
+      vector_size_t size,
+      const std::string& pattern) {
+    SelectivityVector rows(size);
+    if (pattern == "all") {
+      // All rows selected (default)
+    } else if (pattern == "start") {
+      // First half selected
+      rows.setValidRange(size / 2, size, false);
+    } else if (pattern == "end") {
+      // Second half selected
+      rows.setValidRange(0, size / 2, false);
+    } else if (pattern == "mid") {
+      // Middle quarter selected
+      auto start = size / 4;
+      auto end = 3 * size / 4;
+      rows.setValidRange(0, start, false);
+      rows.setValidRange(end, size, false);
+    } else if (pattern == "scattered") {
+      // Every 3rd row selected
+      rows.clearAll();
+      for (auto i = 0; i < size; i += 3) {
+        rows.setValid(i, true);
+      }
+    }
+    rows.updateBounds();
+    return rows;
+  }
+
+  // Helper functions to execute a single test case with different parameters
+  // like selected rows and replaceNulls verify the result.
+  void executeTestCase(MapVectorPtr& testCase) {
+    auto keysToProject = makeFlatVector<int64_t>({1, 2});
+    auto outputFieldNames = std::vector<std::string>{"key1", "key2"};
+    MakeRowFromMapOptions options{
+        .keysToProject = keysToProject,
+        .outputFieldNames = outputFieldNames,
+        .replaceNulls = false,
+        .allowTopLevelNulls = false,
+        .throwOnDuplicateKeys = false};
+    for (bool replaceNulls : {false, true}) {
+      for (bool allowTopLevelNulls : {false, true}) {
+        for (bool useEvalCtx : {false, true}) {
+          for (std::string selectedRowsStr :
+               {"all", "start", "end", "mid", "scattered"}) {
+            if (replaceNulls &&
+                testCase->type()->asMap().valueType()->kind() ==
+                    TypeKind::ROW) {
+              continue;
+            }
+            SCOPED_TRACE(
+                "Selected Rows: " + selectedRowsStr +
+                " replaceNulls: " + std::to_string(replaceNulls) +
+                " allowTopLevelNulls: " + std::to_string(allowTopLevelNulls) +
+                " useEvalCtx: " + std::to_string(useEvalCtx) +
+                " MapType: " + testCase->type()->toString());
+            auto rows =
+                createSelectivityVector(testCase->size(), selectedRowsStr);
+            options.replaceNulls = replaceNulls;
+            options.allowTopLevelNulls = allowTopLevelNulls;
+            std::optional<exec::EvalCtx> evalCtx;
+            if (useEvalCtx) {
+              exec::EvalCtx evalCtx(
+                  execCtx_.get(), &dummyExprSet, dummyRowVector.get());
+              auto result = toRowVector<TypeKind::BIGINT>(
+                  *testCase, options, rows, &evalCtx);
+              verifyResult(result, testCase, rows, options);
+            } else {
+              auto result =
+                  toRowVector<TypeKind::BIGINT>(*testCase, options, rows);
+              verifyResult(result, testCase, rows, options);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  std::shared_ptr<core::QueryCtx> queryCtx_{velox::core::QueryCtx::create()};
+  std::unique_ptr<core::ExecCtx> execCtx_{
+      std::make_unique<core::ExecCtx>(pool_.get(), queryCtx_.get())};
+  // Dummy EvalCtx and related objects to pass to MakeRowFroMap when
+  // testing the code path that uses EvalCtx.
+  exec::ExprSet dummyExprSet{{}, execCtx_.get()};
+  RowVectorPtr dummyRowVector = makeRowVector({});
+};
+
+TEST_F(MakeRowFroMapTest, basic) {
+  EXPECT_EQ(NonPOD::alive, 0);
+  auto testCases = makeTestCases();
+  for (auto& testCase : testCases) {
+    executeTestCase(testCase);
+    break;
+  }
+  testCases.clear();
+  EXPECT_EQ(NonPOD::alive, 0);
+}
+
+TEST_F(MakeRowFroMapTest, unknownTypeValues) {
+  auto testCase = makeMapVectorFromJson<int64_t, int64_t>(
+      {"{1:1, 2:2, 3:3}", // All valid values
+       "{2:20, 4:40, 7:3}", // Only one projected key
+       "{1:100, 2:null, 6:600}", // Null Value
+       "{4:4000, 6:6000}", // No projected keys
+       "{1:10000}", // single element, projected key
+       "{}", // empty map
+       "null"}); // null map
+  auto unknownTypeValues =
+      BaseVector::create(UNKNOWN(), testCase->mapValues()->size(), pool());
+
+  testCase = std::make_shared<MapVector>(
+      pool(),
+      MAP(BIGINT(), UNKNOWN()),
+      testCase->nulls(),
+      testCase->size(),
+      testCase->offsets(),
+      testCase->sizes(),
+      testCase->mapKeys(),
+      unknownTypeValues);
+
+  SelectivityVector rows(testCase->size());
+  auto keysToProject = makeFlatVector<int64_t>({1, 2});
+  auto outputFieldNames = std::vector<std::string>{"key1", "key2"};
+  MakeRowFromMapOptions options{
+      .keysToProject = keysToProject,
+      .outputFieldNames = outputFieldNames,
+      .replaceNulls = false,
+      .allowTopLevelNulls = false,
+      .throwOnDuplicateKeys = false};
+  auto result = toRowVector<TypeKind::BIGINT>(*testCase, options, rows);
+
+  auto expectedType = ROW(outputFieldNames, {UNKNOWN(), UNKNOWN()});
+  ASSERT_EQ(*result->type(), *expectedType);
+  ASSERT_EQ(result->size(), testCase->size());
+
+  options.replaceNulls = true;
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*testCase, options, rows),
+      "Unsupported type for replacing nulls: UNKNOWN");
+}
+
+TEST_F(MakeRowFroMapTest, encoded) {
+  EXPECT_EQ(NonPOD::alive, 0);
+  auto testCases = makeTestCases();
+  auto reverseIndices = makeIndicesInReverse(testCases[0]->size());
+  auto reverseElementIndices =
+      makeIndicesInReverse(testCases[0]->mapKeys()->size());
+
+  // Wrap the top level map with a dictionary and a constant encoding.
+  for (auto& testCase : testCases) {
+    auto dictOnMap = BaseVector::wrapInDictionary(
+        nullptr, reverseIndices, testCase->size(), testCase);
+    executeTestCase(testCase);
+
+    auto constOnMap =
+        BaseVector::wrapInConstant(testCase->size(), 0, dictOnMap);
+    executeTestCase(testCase);
+  }
+
+  // Wrap the keys and values with a dictionary encoding.
+  for (auto& testCase : testCases) {
+    auto elementsSizes = testCase->mapValues()->size();
+    auto dictKeys = BaseVector::wrapInDictionary(
+        nullptr, reverseElementIndices, elementsSizes, testCase->mapKeys());
+    auto dictValues = BaseVector::wrapInDictionary(
+        nullptr, reverseElementIndices, elementsSizes, testCase->mapValues());
+    testCase->setKeysAndValues(dictKeys, dictValues);
+    executeTestCase(testCase);
+  }
+  testCases.clear();
+  EXPECT_EQ(NonPOD::alive, 0);
+}
+
+TEST_F(MakeRowFroMapTest, errorCases) {
+  SelectivityVector rows(1);
+  auto validMap = makeMapVectorFromJson<int64_t, int64_t>({"{1:1, 2:2, 3:3}"});
+
+  // Input of typeKind other than Map used
+  MakeRowFromMapOptions options{
+      .keysToProject = makeFlatVector<int64_t>({1, 2}),
+      .outputFieldNames = {"1", "2"},
+      .replaceNulls = false,
+      .allowTopLevelNulls = false,
+      .throwOnDuplicateKeys = false};
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*(validMap->mapKeys()), options, rows),
+      "Input must be of MAP typeKind");
+
+  // Mismatched Type between keysToProject and map keys
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(
+          *makeMapVectorFromJson<int32_t, int64_t>({"{1:1}"}), options, rows),
+      "(INTEGER vs. BIGINT) Map key type and the type of keys to project are not the same");
+
+  // Mismatched Type between keysToProject and template type of toRowVector
+  options.keysToProject = makeFlatVector<int32_t>({1, 2});
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*validMap, options, rows),
+      "Unexptected key TypeKind");
+
+  // Invalid key type
+  options.keysToProject = makeFlatVector<int32_t>({1, 2});
+  options.keysToProject->setType(DATE());
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::INTEGER>(*validMap, options, rows),
+      "Only SMALLINT, INTEGER, BIGINT keys are currently supported, instead got DATE");
+
+  // Keys to project are not empty
+  options.keysToProject->resize(0);
+  options.outputFieldNames = {"key1", "key2"};
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*validMap, options, rows),
+      "Keys to project cannot be empty");
+
+  // Mismatched size between keysToProject and outputFieldNames
+  options.keysToProject = makeFlatVector<int64_t>({1, 2});
+  options.outputFieldNames = {"key1"};
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*validMap, options, rows),
+      "Number of keys to project and output field names must be the same");
+
+  // One of the outputFieldNames is empty.
+  options.keysToProject = makeFlatVector<int64_t>({1, 2});
+  options.outputFieldNames = {"", "key2"};
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*validMap, options, rows),
+      "Field name cannot be empty");
+
+  // One of the outputFieldNames is duplicate.
+  options.keysToProject = makeFlatVector<int64_t>({1, 2});
+  options.outputFieldNames = {"key1", "key1"};
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*validMap, options, rows),
+      "Duplicate field names are not allowed: key1");
+
+  // Keys to project cannot contain null
+  options.keysToProject = makeNullableFlatVector<int64_t>({1, std::nullopt});
+  options.outputFieldNames = {"key1", "key2"};
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*validMap, options, rows),
+      "Keys to project cannot contain null");
+
+  // Duplicate keys not allowed
+  options.keysToProject = makeFlatVector<int64_t>({1, 1});
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*validMap, options, rows),
+      "Duplicate keys cannot be projected");
+
+  // Replace nulls is true, but map values are of ROW type
+  auto rowValues = makeRowVector({makeFlatVector<int64_t>({1, 2, 3})});
+  options.keysToProject = makeFlatVector<int64_t>({1, 2});
+  options.replaceNulls = true;
+  auto mapWithRowValues = std::make_shared<MapVector>(
+      pool(),
+      MAP(validMap->mapKeys()->type(), rowValues->type()),
+      validMap->nulls(),
+      validMap->size(),
+      validMap->offsets(),
+      validMap->sizes(),
+      validMap->mapKeys(),
+      rowValues);
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*mapWithRowValues, options, rows),
+      "Unsupported type for replacing nulls: ROW");
+}
+
+TEST_F(MakeRowFroMapTest, duplicateKey) {
+  auto testCase = makeMapVector<int64_t, int64_t>({
+      {{1, 1}, {2, 2}, {2, 3}},
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  MakeRowFromMapOptions options{
+      .keysToProject = makeFlatVector<int64_t>({1, 2}),
+      .outputFieldNames = std::vector<std::string>{"key1", "key2"},
+      .replaceNulls = false,
+      .allowTopLevelNulls = false,
+      .throwOnDuplicateKeys = true};
+  SelectivityVector rows(testCase->size());
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*testCase, options, rows),
+      "Duplicate keys not allowed");
+  exec::EvalCtx evalCtx(execCtx_.get(), &dummyExprSet, dummyRowVector.get());
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*testCase, options, rows, &evalCtx),
+      "Duplicate keys not allowed");
+
+  // Verify that the error is thrown only for the first duplicate key and the
+  // rest of the rows are evaluated.
+  exec::EvalCtx contextNoThrow(
+      execCtx_.get(), &dummyExprSet, dummyRowVector.get());
+  *contextNoThrow.mutableThrowOnError() = false;
+  auto result =
+      toRowVector<TypeKind::BIGINT>(*testCase, options, rows, &contextNoThrow);
+  auto expected = makeRowVector(
+      options.outputFieldNames,
+      {makeNullableFlatVector<int64_t>({std::nullopt, 10}),
+       makeNullableFlatVector<int64_t>({std::nullopt, 20})});
+  ASSERT_TRUE(contextNoThrow.errors()->hasErrorAt(0));
+  SelectivityVector expectedRows(result->size());
+  contextNoThrow.deselectErrors(expectedRows);
+  test::assertEqualVectors(expected, result, expectedRows);
+
+  // Verify that the value from the last encountered duplicate key is used when
+  // duplicate keys are allowed.
+  options.throwOnDuplicateKeys = false;
+  result = toRowVector<TypeKind::BIGINT>(*testCase, options, rows);
+  expected = makeRowVector(
+      options.outputFieldNames,
+      {makeFlatVector<int64_t>({1, 10}), makeFlatVector<int64_t>({3, 20})});
+  test::assertEqualVectors(expected, result);
+
+  // Ensure no error is thrown if the row with the duplicate key is not
+  // selected and duplicate keys are not allowed.
+  rows.setValid(0, false);
+  rows.updateBounds();
+  options.throwOnDuplicateKeys = true;
+  result = toRowVector<TypeKind::BIGINT>(*testCase, options, rows);
+  test::assertEqualVectors(expected, result, rows);
+}
+
+class MakeRowFromMapDefaultsTest : public testing::Test,
+                                   public test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  template <typename T>
+  void verifyPrimitiveDefaults(const VectorPtr& vector, T expectedDefault) {
+    ASSERT_TRUE(vector->isFlatEncoding());
+    auto flatVector = vector->asFlatVector<T>();
+    for (auto i = 0; i < vector->size(); ++i) {
+      ASSERT_EQ(flatVector->valueAt(i), expectedDefault) << " at row " << i;
+    }
+  }
+
+  void verifyArrayVectorBaseDefaults(const VectorPtr& vector) {
+    ASSERT_TRUE(
+        vector->encoding() == VectorEncoding::Simple::ARRAY ||
+        vector->encoding() == VectorEncoding::Simple::MAP);
+    auto arrayVectorBase = vector->asUnchecked<ArrayVectorBase>();
+    for (auto i = 0; i < vector->size(); ++i) {
+      ASSERT_EQ(arrayVectorBase->sizeAt(i), 0) << " at row " << i;
+      ASSERT_EQ(arrayVectorBase->offsetAt(i), 0) << " at row " << i;
+    }
+  }
+};
+
+TEST_F(MakeRowFromMapDefaultsTest, createFlatPrimitiveTypes) {
+  vector_size_t size = 5;
+  // Test INTEGER
+  auto integerVector =
+      MakeRowFromMapDefaults::createFlat(INTEGER(), size, *pool(), nullptr);
+  verifyPrimitiveDefaults<int32_t>(integerVector, 0);
+
+  // Test VARCHAR
+  auto varcharVector =
+      MakeRowFromMapDefaults::createFlat(VARCHAR(), size, *pool(), nullptr);
+  verifyPrimitiveDefaults<StringView>(varcharVector, StringView());
+
+  // Test TIMESTAMP
+  auto timestampVector =
+      MakeRowFromMapDefaults::createFlat(TIMESTAMP(), size, *pool(), nullptr);
+  verifyPrimitiveDefaults<Timestamp>(timestampVector, Timestamp());
+}
+
+TEST_F(MakeRowFromMapDefaultsTest, createFlatComplexTypes) {
+  vector_size_t size = 5;
+
+  // Test ARRAY
+  auto arrayVector = MakeRowFromMapDefaults::createFlat(
+      ARRAY(INTEGER()), size, *pool(), nullptr);
+  verifyArrayVectorBaseDefaults(arrayVector);
+
+  // Test MAP
+  auto mapVector = MakeRowFromMapDefaults::createFlat(
+      MAP(INTEGER(), VARCHAR()), size, *pool(), nullptr);
+  verifyArrayVectorBaseDefaults(mapVector);
+}
+
+TEST_F(MakeRowFromMapDefaultsTest, createConstantPrimitiveTypes) {
+  vector_size_t size = 5;
+
+  // Test BIGINT constant
+  auto bigintConstant =
+      MakeRowFromMapDefaults::createConstant(BIGINT(), size, *pool());
+  ASSERT_TRUE(bigintConstant->isConstantEncoding());
+  ASSERT_EQ(bigintConstant->size(), size);
+  ASSERT_EQ(
+      bigintConstant->asUnchecked<ConstantVector<int64_t>>()->valueAt(0), 0);
+
+  // Test VARCHAR constant
+  auto varcharConstant =
+      MakeRowFromMapDefaults::createConstant(VARCHAR(), size, *pool());
+  ASSERT_TRUE(varcharConstant->isConstantEncoding());
+  ASSERT_EQ(varcharConstant->size(), size);
+  ASSERT_EQ(
+      varcharConstant->asUnchecked<ConstantVector<StringView>>()->valueAt(0),
+      StringView());
+}
+
+TEST_F(MakeRowFromMapDefaultsTest, createConstantComplexTypes) {
+  vector_size_t size = 5;
+
+  // Test ARRAY constant
+  auto arrayConstant =
+      MakeRowFromMapDefaults::createConstant(ARRAY(INTEGER()), size, *pool());
+  ASSERT_TRUE(arrayConstant->isConstantEncoding());
+  ASSERT_EQ(arrayConstant->size(), size);
+  verifyArrayVectorBaseDefaults(arrayConstant->valueVector());
+
+  // Test MAP constant
+  auto mapConstant = MakeRowFromMapDefaults::createConstant(
+      MAP(BIGINT(), VARCHAR()), size, *pool());
+  ASSERT_TRUE(mapConstant->isConstantEncoding());
+  ASSERT_EQ(mapConstant->size(), size);
+  verifyArrayVectorBaseDefaults(mapConstant->valueVector());
+}
+
+TEST_F(MakeRowFromMapDefaultsTest, unsupportedTypes) {
+  vector_size_t size = 5;
+
+  VELOX_ASSERT_THROW(
+      MakeRowFromMapDefaults::createConstant(ROW({BIGINT()}), size, *pool()),
+      "Unsupported type for replacing nulls: ROW<\"\":BIGINT>");
+
+  VELOX_ASSERT_THROW(
+      MakeRowFromMapDefaults::createConstant(UNKNOWN(), size, *pool()),
+      "Unsupported type for replacing nulls: UNKNOWN");
+}
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/tests/QuantileDigestTest.cpp b/velox/functions/lib/tests/QuantileDigestTest.cpp
index 59b62e7b86c..58b20ddfb12 100644
--- a/velox/functions/lib/tests/QuantileDigestTest.cpp
+++ b/velox/functions/lib/tests/QuantileDigestTest.cpp
@@ -990,6 +990,31 @@ TEST_F(QuantileDigestTest, getDistributionFunction) {
   testGetDistributionFunction<float>();
 }
 
+template <typename T>
+void testEmptyDistributionFunction() {
+  std::allocator<T> allocator;
+  // Create empty QuantileDigest and get CDF
+  QuantileDigest<T, std::allocator<T>> digest(allocator, 0.01);
+  auto cdf = digest.getDistributionFunction(0, 100);
+  ASSERT_EQ(cdf.size(), 2);
+
+  // By convention, the CDF should always start at (rangeStart, 0) and end at
+  // (rangeEnd, 1) Since the digest is empty, these will be the only points
+  std::vector<T> expectedCdfUpperBound = {0, 100};
+  std::vector<double> expectedCdfCumulativeProbability = {0, 1};
+  for (auto i = 0; i < cdf.size(); i++) {
+    ASSERT_EQ(
+        cdf[i].cumulativeProbability, expectedCdfCumulativeProbability[i]);
+    ASSERT_EQ(cdf[i].upperBound, expectedCdfUpperBound[i]);
+  }
+}
+
+TEST_F(QuantileDigestTest, emptyDistributionFunction) {
+  testEmptyDistributionFunction<int64_t>();
+  testEmptyDistributionFunction<double>();
+  testEmptyDistributionFunction<float>();
+}
+
 TEST_F(QuantileDigestTest, getValuesInQuantileRangeBigInt) {
   QuantileDigest<int64_t> digest{StlAllocator<int64_t>(allocator()), 0.01};
 
diff --git a/velox/functions/lib/tests/Re2FunctionsTest.cpp b/velox/functions/lib/tests/Re2FunctionsTest.cpp
index 90fcf01d5d2..c3026c251ea 100644
--- a/velox/functions/lib/tests/Re2FunctionsTest.cpp
+++ b/velox/functions/lib/tests/Re2FunctionsTest.cpp
@@ -17,6 +17,7 @@
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
+#include <sys/mman.h>
 #include <velox/type/Type.h>
 #include <functional>
 #include <optional>
@@ -33,6 +34,27 @@
 #include "velox/vector/ComplexVector.h"
 #include "velox/vector/FlatVector.h"
 
+// Detect sanitizer builds for guarding death tests.
+#ifdef __has_feature
+#define RE2_BUILDING_WITH_ASAN() __has_feature(address_sanitizer)
+#define RE2_BUILDING_WITH_TSAN() __has_feature(thread_sanitizer)
+#else
+#if defined(__SANITIZE_ADDRESS__) && __SANITIZE_ADDRESS__
+#define RE2_BUILDING_WITH_ASAN() 1
+#else
+#define RE2_BUILDING_WITH_ASAN() 0
+#endif
+#if defined(__SANITIZE_THREAD__) && __SANITIZE_THREAD__
+#define RE2_BUILDING_WITH_TSAN() 1
+#else
+#define RE2_BUILDING_WITH_TSAN() 0
+#endif
+#endif
+
+#if RE2_BUILDING_WITH_TSAN() || RE2_BUILDING_WITH_ASAN()
+#define RE2_BUILDING_WITH_SAN
+#endif
+
 namespace facebook::velox::functions {
 
 using namespace facebook::velox::test;
@@ -522,17 +544,93 @@ TEST_F(Re2FunctionsTest, likePattern) {
   testLike("aaccddeeff", "%aa%bb%", false);
 }
 
+// Test LikeGeneric with non-constant patterns longer than 12 bytes (non-inline
+// StringView) to exercise the code path where pattern data is stored as a
+// pointer to the vector's string buffer rather than inline in the StringView.
+TEST_F(Re2FunctionsTest, likeGenericWithLongPatterns) {
+  // Patterns >12 bytes to ensure StringView stores a pointer (non-inline).
+  // Fixed pattern.
+  testLike("longfixedpatternvalue", "longfixedpatternvalue", true);
+  testLike("longfixedpatternvalue", "longfixedpatternother", false);
+  // Prefix pattern.
+  testLike("longprefixpatternvalue", "longprefixpattern%", true);
+  testLike("shortvalue", "longprefixpattern%", false);
+  // Suffix pattern.
+  testLike("valuelongsuffixpattern", "%longsuffixpattern", true);
+  testLike("shortvalue", "%longsuffixpattern", false);
+  // Substring pattern.
+  testLike("prefixlongsubstringpatternsuffix", "%longsubstringpattern%", true);
+  testLike("nothinghere", "%longsubstringpattern%", false);
+  // Generic pattern.
+  testLike("a_long_generic_pattern_value", "%long_generic_pattern%", true);
+  testLike("a_short_value", "%long_generic_pattern%", false);
+}
+
+// Verify that copying a pattern string before calling determinePatternKind
+// protects against use-after-free when the underlying StringView buffer is
+// reclaimed. Uses mmap/munmap to simulate the production crash scenario where
+// memory-mapped pages backing pattern data are unmapped under memory pressure,
+// producing a SIGSEGV at a page-aligned address (as seen in T260427308).
+TEST_F(Re2FunctionsTest, likePatternCopyProtectsAgainstDanglingPointer) {
+  // Use a pattern with only literal chars + trailing '%' to get kPrefix kind.
+  // Avoid '_' which is a LIKE single-char wildcard.
+  const std::string pattern = "averylongpatternthatexceedsinlinestorage%";
+  ASSERT_GT(pattern.size(), 12);
+
+  // Allocate a page of memory via mmap (simulates memory-mapped file pages
+  // that back string data in production scans).
+  void* page = mmap(
+      nullptr,
+      4096,
+      PROT_READ | PROT_WRITE,
+      MAP_PRIVATE | MAP_ANONYMOUS,
+      -1,
+      0);
+  ASSERT_NE(page, MAP_FAILED);
+  memcpy(page, pattern.data(), pattern.size());
+
+  // Create a StringView pointing into the mmap'd page (simulates how
+  // FlatVector<StringView> stores pointers to string buffers).
+  StringView patternView(static_cast<const char*>(page), pattern.size());
+
+  // The fix: copy to a local string while the page is still mapped.
+  std::string patternCopy(patternView.data(), patternView.size());
+
+  // Unmap the page (simulates buffer reclamation under memory pressure).
+  // After this, any access to 'page' causes SIGSEGV, exactly matching the
+  // production crash at page-aligned address 0x7fa369c00000.
+  munmap(page, 4096);
+
+  // With the fix (using the copy): works correctly.
+  auto metadata = determinePatternKind(patternCopy, std::nullopt);
+  EXPECT_EQ(metadata.patternKind(), PatternKind::kPrefix);
+  EXPECT_EQ(
+      metadata.fixedPattern(), "averylongpatternthatexceedsinlinestorage");
+
+  // Without the fix (using the unmapped page): SIGSEGV.
+  // Under sanitizers, ASSERT_DEATH may not work reliably (sanitizers
+  // intercept signals and fork() has known issues with ASAN shadow memory).
+#ifndef RE2_BUILDING_WITH_SAN
+  ASSERT_DEATH(
+      determinePatternKind(
+          std::string_view(static_cast<const char*>(page), pattern.size()),
+          std::nullopt),
+      "");
+#endif
+}
+
 TEST_F(Re2FunctionsTest, likeDeterminePatternKind) {
   auto testPattern =
       [&](std::string_view pattern, PatternKind patternKind, size_t length) {
         PatternMetadata patternMetadata =
             determinePatternKind(pattern, std::nullopt);
 
-        SCOPED_TRACE(fmt::format(
-            "pattern: '{}', length: {}, actualLength: {}",
-            pattern,
-            length,
-            patternMetadata.length()));
+        SCOPED_TRACE(
+            fmt::format(
+                "pattern: '{}', length: {}, actualLength: {}",
+                pattern,
+                length,
+                patternMetadata.length()));
         EXPECT_EQ(patternMetadata.patternKind(), patternKind);
         EXPECT_EQ(patternMetadata.length(), length);
       };
@@ -540,8 +638,9 @@ TEST_F(Re2FunctionsTest, likeDeterminePatternKind) {
   auto testPatternString = [&](std::string_view pattern,
                                PatternKind patternKind,
                                std::string_view fixedPattern) {
-    SCOPED_TRACE(fmt::format(
-        "pattern: '{}', fixedPattern: '{}'", pattern, fixedPattern));
+    SCOPED_TRACE(
+        fmt::format(
+            "pattern: '{}', fixedPattern: '{}'", pattern, fixedPattern));
 
     PatternMetadata patternMetadata =
         determinePatternKind(pattern, std::nullopt);
diff --git a/velox/functions/lib/tests/RepeatTest.cpp b/velox/functions/lib/tests/RepeatTest.cpp
index e4c92a834eb..1296532be2f 100644
--- a/velox/functions/lib/tests/RepeatTest.cpp
+++ b/velox/functions/lib/tests/RepeatTest.cpp
@@ -213,5 +213,66 @@ TEST_F(RepeatTest, repeatAllowNegativeCount) {
       {elementVector, countVector},
       expected);
 }
+
+// Test that repeat() properly detects integer overflow when totalCount
+// exceeds INT32_MAX. Without the fix, count * numRows would overflow
+// causing a small buffer allocation followed by a large write, resulting
+// in SIGSEGV.
+TEST_F(RepeatTest, repeatTotalCountOverflow) {
+  // Set a high max elements limit to allow large per-row counts.
+  // We want to test the total count overflow, not the per-row limit.
+  execCtx_.queryCtx()->testingOverrideConfigUnsafe({
+      {core::QueryConfig::kMaxElementsSizeInRepeatAndSequence, "1000000000"},
+  });
+
+  // Test constant count path: count * numRows > INT32_MAX
+  // With count=10000 and numRows=300000, totalCount = 3,000,000,000
+  // which exceeds INT32_MAX (2,147,483,647).
+  {
+    const int32_t count = 10'000;
+    const int32_t numElements = 300'000;
+    const auto elementVector =
+        makeFlatVector<int32_t>(numElements, [](auto row) { return row; });
+
+    // Using constant count path.
+    VELOX_ASSERT_THROW(
+        evaluate(
+            fmt::format("repeat(C0, '{}'::INTEGER)", count),
+            makeRowVector({elementVector})),
+        "REPEAT result too large");
+  }
+
+  // Test non-constant count path: sum of counts > INT32_MAX
+  // With count in {10000, 10001, 10002} for each of 300000 rows,
+  // totalCount > 3,000,000,000.
+  {
+    const int32_t count = 10'000;
+    const int32_t numElements = 300'000;
+    const auto elementVector =
+        makeFlatVector<int32_t>(numElements, [](auto row) { return row; });
+    const auto countVector = makeFlatVector<int32_t>(
+        numElements, [count](auto row) { return count + row % 3; });
+
+    VELOX_ASSERT_THROW(
+        evaluate("repeat(C0, C1)", makeRowVector({elementVector, countVector})),
+        "REPEAT result too large");
+  }
+
+  // Test with try() - should return null rows instead of throwing.
+  {
+    const int32_t count = 10'000;
+    const int32_t numElements = 300'000;
+    const auto elementVector =
+        makeFlatVector<int32_t>(numElements, [](auto row) { return row; });
+
+    auto result = evaluate(
+        fmt::format("try(repeat(C0, '{}'::INTEGER))", count),
+        makeRowVector({elementVector}));
+    // All rows should be null.
+    for (auto i = 0; i < numElements; ++i) {
+      ASSERT_TRUE(result->isNullAt(i)) << "Row " << i << " should be null";
+    }
+  }
+}
 } // namespace
 } // namespace facebook::velox::functions
diff --git a/velox/functions/lib/tests/SetDigestTest.cpp b/velox/functions/lib/tests/SetDigestTest.cpp
new file mode 100644
index 00000000000..974af80391f
--- /dev/null
+++ b/velox/functions/lib/tests/SetDigestTest.cpp
@@ -0,0 +1,717 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/lib/SetDigest.h"
+#include "velox/common/memory/Memory.h"
+#include "velox/type/StringView.h"
+
+#include <folly/base64.h>
+#include <gtest/gtest.h>
+#include <cmath>
+#include <random>
+
+using namespace facebook::velox::functions;
+using facebook::velox::HashStringAllocator;
+using facebook::velox::StringView;
+
+namespace {
+// SetDigest uses HllAccumulator with 2048 buckets.
+// The theoretical relative standard error formula from the HyperLogLog paper
+// (Flajolet et al.) is: 1.04 / sqrt(num_buckets)
+const double kStandardError =
+    1.04 / std::sqrt(SetDigest<int64_t>::kNumberOfBuckets);
+} // namespace
+
+class SetDigestTest : public ::testing::Test {
+ protected:
+  static void SetUpTestSuite() {
+    facebook::velox::memory::MemoryManager::testingSetInstance({});
+  }
+
+  void SetUp() override {
+    pool_ = facebook::velox::memory::memoryManager()->addLeafPool();
+    allocator_ =
+        std::make_unique<facebook::velox::HashStringAllocator>(pool_.get());
+  }
+
+  // Helper for Java-equivalent intersection cardinality tests
+  void testIntersectionCardinalityHelper(
+      int32_t maxHashes1,
+      int32_t numBuckets1,
+      int32_t maxHashes2,
+      int32_t numBuckets2);
+
+  std::string decodeBase64(const std::string& encoded) {
+    return folly::base64Decode(encoded);
+  }
+
+  std::shared_ptr<facebook::velox::memory::MemoryPool> pool_;
+  std::unique_ptr<facebook::velox::HashStringAllocator> allocator_;
+};
+
+TEST_F(SetDigestTest, roundTripSerialization) {
+  SetDigest<int64_t> digest1(allocator_.get());
+  digest1.add(1L);
+  digest1.add(1L);
+  digest1.add(1L);
+  digest1.add(2L);
+  digest1.add(2L);
+
+  int32_t size1 = digest1.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest1.serialize(buffer1.data());
+
+  SetDigest<int64_t> digest2(allocator_.get());
+  ASSERT_TRUE(digest2.deserialize(buffer1.data(), size1).ok());
+
+  int32_t size2 = digest2.estimatedSerializedSize();
+  EXPECT_EQ(size1, size2);
+
+  std::vector<char> buffer2(size2);
+  digest2.serialize(buffer2.data());
+
+  EXPECT_EQ(
+      std::string(buffer1.begin(), buffer1.end()),
+      std::string(buffer2.begin(), buffer2.end()));
+
+  EXPECT_EQ(digest1.isExact(), digest2.isExact());
+  EXPECT_EQ(digest1.cardinality(), digest2.cardinality());
+}
+
+TEST_F(SetDigestTest, roundTripWithStrings) {
+  SetDigest<StringView> digest1(allocator_.get());
+
+  digest1.add(facebook::velox::StringView("apple"));
+  digest1.add(facebook::velox::StringView("banana"));
+  digest1.add(facebook::velox::StringView("apple"));
+
+  int32_t size1 = digest1.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest1.serialize(buffer1.data());
+
+  SetDigest<StringView> digest2(allocator_.get());
+  ASSERT_TRUE(digest2.deserialize(buffer1.data(), size1).ok());
+
+  int32_t size2 = digest2.estimatedSerializedSize();
+  EXPECT_EQ(size1, size2);
+
+  std::vector<char> buffer2(size2);
+  digest2.serialize(buffer2.data());
+
+  EXPECT_EQ(
+      std::string(buffer1.begin(), buffer1.end()),
+      std::string(buffer2.begin(), buffer2.end()));
+}
+
+TEST_F(SetDigestTest, mergeWithRoundTrip) {
+  SetDigest<int64_t> digest1(allocator_.get());
+  digest1.add(1L);
+  digest1.add(2L);
+  digest1.add(3L);
+
+  SetDigest<int64_t> digest2(allocator_.get());
+  digest2.add(3L);
+  digest2.add(4L);
+  digest2.add(5L);
+
+  digest1.mergeWith(digest2);
+
+  int32_t size1 = digest1.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest1.serialize(buffer1.data());
+
+  SetDigest<int64_t> digest3(allocator_.get());
+  ASSERT_TRUE(digest3.deserialize(buffer1.data(), size1).ok());
+
+  int32_t size2 = digest3.estimatedSerializedSize();
+  EXPECT_EQ(size1, size2);
+
+  std::vector<char> buffer2(size2);
+  digest3.serialize(buffer2.data());
+
+  EXPECT_EQ(
+      std::string(buffer1.begin(), buffer1.end()),
+      std::string(buffer2.begin(), buffer2.end()));
+
+  EXPECT_TRUE(digest1.isExact());
+  EXPECT_EQ(digest1.cardinality(), 5);
+  EXPECT_EQ(digest3.cardinality(), 5);
+}
+
+TEST_F(SetDigestTest, mergeWithDuplicates) {
+  SetDigest<int64_t> digest1(allocator_.get());
+  digest1.add(1L);
+  digest1.add(1L);
+  digest1.add(1L);
+
+  SetDigest<int64_t> digest2(allocator_.get());
+  digest2.add(1L);
+  digest2.add(2L);
+
+  digest1.mergeWith(digest2);
+
+  EXPECT_TRUE(digest1.isExact());
+  EXPECT_EQ(digest1.cardinality(), 2);
+
+  int32_t size1 = digest1.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest1.serialize(buffer1.data());
+
+  SetDigest<int64_t> digest3(allocator_.get());
+  ASSERT_TRUE(digest3.deserialize(buffer1.data(), size1).ok());
+
+  int32_t size2 = digest3.estimatedSerializedSize();
+  std::vector<char> buffer2(size2);
+  digest3.serialize(buffer2.data());
+
+  EXPECT_EQ(
+      std::string(buffer1.begin(), buffer1.end()),
+      std::string(buffer2.begin(), buffer2.end()));
+}
+
+TEST_F(SetDigestTest, javaCompatibility) {
+  // Query used: SELECT to_base64(cast(make_set_digest(value) as varbinary))
+  // FROM (VALUES 1, 1, 1, 2, 2) T(value);
+  SetDigest<int64_t> digest(allocator_.get());
+
+  digest.add(1L);
+  digest.add(1L);
+  digest.add(1L);
+  digest.add(2L);
+  digest.add(2L);
+
+  int32_t size = digest.estimatedSerializedSize();
+  std::vector<char> buffer(size);
+  digest.serialize(buffer.data());
+
+  std::string base64Output =
+      folly::base64Encode(folly::StringPiece(buffer.data(), size));
+
+  EXPECT_TRUE(digest.isExact());
+  EXPECT_EQ(digest.cardinality(), 2);
+  EXPECT_GT(size, 0);
+}
+
+TEST_F(SetDigestTest, javaCompatibilityEmptyDigest) {
+  // Query: SELECT to_base64(cast(make_set_digest(value) as varbinary))
+  // FROM (SELECT NULL as value WHERE 1=0) T(value);
+  SetDigest<int64_t> digest(allocator_.get());
+
+  int32_t size = digest.estimatedSerializedSize();
+  std::vector<char> buffer(size);
+  digest.serialize(buffer.data());
+
+  std::string base64Output =
+      folly::base64Encode(folly::StringPiece(buffer.data(), size));
+
+  EXPECT_TRUE(digest.isExact());
+  EXPECT_EQ(digest.cardinality(), 0);
+}
+
+TEST_F(SetDigestTest, cardinality) {
+  SetDigest<int64_t> digest(allocator_.get());
+
+  EXPECT_EQ(digest.cardinality(), 0);
+
+  digest.add(1L);
+  EXPECT_EQ(digest.cardinality(), 1);
+
+  digest.add(1L);
+  EXPECT_EQ(digest.cardinality(), 1);
+
+  digest.add(2L);
+  EXPECT_EQ(digest.cardinality(), 2);
+}
+
+TEST_F(SetDigestTest, exactIntersectionCardinality) {
+  SetDigest<int64_t> digest1(allocator_.get());
+  digest1.add(1L);
+  digest1.add(2L);
+  digest1.add(3L);
+
+  SetDigest<int64_t> digest2(allocator_.get());
+  digest2.add(2L);
+  digest2.add(3L);
+  digest2.add(4L);
+
+  int64_t intersection =
+      SetDigest<int64_t>::exactIntersectionCardinality(digest1, digest2);
+  EXPECT_EQ(intersection, 2);
+
+  SetDigest<int64_t> digest3(allocator_.get());
+  digest3.add(5L);
+  digest3.add(6L);
+
+  intersection =
+      SetDigest<int64_t>::exactIntersectionCardinality(digest1, digest3);
+  EXPECT_EQ(intersection, 0);
+}
+
+TEST_F(SetDigestTest, jaccardIndex) {
+  SetDigest<int64_t> digest1(allocator_.get());
+  digest1.add(1L);
+  digest1.add(2L);
+  digest1.add(3L);
+
+  SetDigest<int64_t> digest2(allocator_.get());
+  digest2.add(2L);
+  digest2.add(3L);
+  digest2.add(4L);
+
+  double jaccard = SetDigest<int64_t>::jaccardIndex(digest1, digest2);
+  EXPECT_GE(jaccard, 0.0);
+  EXPECT_LE(jaccard, 1.0);
+
+  // Test identical sets - should always be 1.0
+  SetDigest<int64_t> digest3(allocator_.get());
+  digest3.add(1L);
+  digest3.add(2L);
+  digest3.add(3L);
+
+  jaccard = SetDigest<int64_t>::jaccardIndex(digest1, digest3);
+  EXPECT_NEAR(jaccard, 1.0, 0.001);
+
+  // Test disjoint sets - should be 0.0
+  SetDigest<int64_t> digest4(allocator_.get());
+  digest4.add(10L);
+  digest4.add(20L);
+  digest4.add(30L);
+
+  jaccard = SetDigest<int64_t>::jaccardIndex(digest1, digest4);
+  EXPECT_NEAR(jaccard, 0.0, 0.001);
+}
+
+TEST_F(SetDigestTest, getHashCounts) {
+  SetDigest<int64_t> digest(allocator_.get());
+
+  digest.add(1L);
+  digest.add(1L);
+  digest.add(1L);
+  digest.add(2L);
+  digest.add(2L);
+
+  auto hashCounts = digest.getHashCounts();
+  EXPECT_EQ(hashCounts.size(), 2);
+  int totalCount = 0;
+  for (const auto& entry : hashCounts) {
+    totalCount += entry.second;
+  }
+  EXPECT_EQ(totalCount, 5);
+}
+
+TEST_F(SetDigestTest, hashCountsJavaCompatibility) {
+  // This test matches the Java TestSetDigest.testHashCounts() test
+  SetDigest<int64_t> digest1(allocator_.get());
+  digest1.add(0L);
+  digest1.add(0L);
+  digest1.add(1L);
+
+  auto hashCounts1 = digest1.getHashCounts();
+  EXPECT_EQ(hashCounts1.size(), 2);
+
+  std::set<int16_t> counts1;
+  for (const auto& entry : hashCounts1) {
+    counts1.insert(entry.second);
+  }
+  std::set<int16_t> expected1 = {1, 2};
+  EXPECT_EQ(counts1, expected1);
+
+  SetDigest<int64_t> digest2(allocator_.get());
+  digest2.add(0L);
+  digest2.add(0L);
+  digest2.add(2L);
+  digest2.add(2L);
+
+  auto hashCounts2 = digest2.getHashCounts();
+  EXPECT_EQ(hashCounts2.size(), 2);
+
+  std::set<int16_t> counts2;
+  for (const auto& entry : hashCounts2) {
+    counts2.insert(entry.second);
+  }
+  std::set<int16_t> expected2 = {2, 2};
+  EXPECT_EQ(counts2, expected2);
+
+  // Merge digest2 into digest1
+  digest1.mergeWith(digest2);
+
+  auto hashCountsMerged = digest1.getHashCounts();
+  EXPECT_EQ(hashCountsMerged.size(), 3);
+
+  std::set<int16_t> countsMerged;
+  for (const auto& entry : hashCountsMerged) {
+    countsMerged.insert(entry.second);
+  }
+  std::set<int16_t> expectedMerged = {1, 2, 4};
+  // hash(0): 2 + 2 = 4
+  // hash(1): 1 + 0 = 1
+  // hash(2): 0 + 2 = 2
+  EXPECT_EQ(countsMerged, expectedMerged);
+}
+
+TEST_F(SetDigestTest, javaSerializationCompatibilityIntegerValues) {
+  SCOPED_TRACE(
+      "SELECT to_base64(cast(make_set_digest(col) as varbinary)) "
+      "FROM (VALUES (1), (2), (3), (4), (5), (6), (7), (8), (9), (10)) AS t(col)");
+
+  // Base64 encoded SetDigest generated by Java Presto for values 1-10
+  auto data = decodeBase64(
+      "ASwAAAACCwoAgANEAEDsyQbAxdQPADQvEoYdNBuBKeEwgtKHOQBYPVsB0hm0gCAI3gAgAAAKAAAAwbZqSBDSGbSowHZsoCAI3krEBfu3A0QAUyYs1XjsyQYbd2yb9sXUD3IeYiw5NC8S5tfq34AdNBuyj38lkynhMHnf8AaM0oc5DItIsjlYPVsBAAEAAQABAAEAAQABAAEAAQABAA==");
+
+  SetDigest<int64_t> digest(allocator_.get());
+  ASSERT_TRUE(digest.deserialize(data.data(), data.size()).ok());
+
+  EXPECT_TRUE(digest.isExact());
+  EXPECT_EQ(digest.cardinality(), 10);
+
+  SetDigest<int64_t> expectedDigest(allocator_.get());
+  for (int64_t i = 1; i <= 10; i++) {
+    expectedDigest.add(i);
+  }
+  EXPECT_EQ(expectedDigest.cardinality(), 10);
+  EXPECT_TRUE(expectedDigest.isExact());
+
+  int64_t intersection =
+      SetDigest<int64_t>::exactIntersectionCardinality(digest, expectedDigest);
+  EXPECT_EQ(intersection, 10);
+
+  auto hashCounts = digest.getHashCounts();
+  auto expectedHashCounts = expectedDigest.getHashCounts();
+  EXPECT_EQ(hashCounts.size(), expectedHashCounts.size());
+
+  for (const auto& entry : hashCounts) {
+    EXPECT_EQ(entry.second, 1);
+  }
+
+  int32_t size = digest.estimatedSerializedSize();
+  std::vector<char> buffer(size);
+  digest.serialize(buffer.data());
+
+  EXPECT_EQ(size, data.size());
+  EXPECT_EQ(std::string(buffer.begin(), buffer.end()), data);
+
+  SetDigest<int64_t> digest2(allocator_.get());
+  ASSERT_TRUE(digest2.deserialize(buffer.data(), size).ok());
+  EXPECT_EQ(digest2.cardinality(), 10);
+  EXPECT_TRUE(digest2.isExact());
+
+  int64_t intersection2 =
+      SetDigest<int64_t>::exactIntersectionCardinality(digest2, expectedDigest);
+  EXPECT_EQ(intersection2, 10);
+
+  int32_t size2 = digest2.estimatedSerializedSize();
+  std::vector<char> buffer2(size2);
+  digest2.serialize(buffer2.data());
+
+  EXPECT_EQ(std::string(buffer2.begin(), buffer2.end()), data);
+}
+
+TEST_F(SetDigestTest, javaSerializationCompatibilityStringValues) {
+  SCOPED_TRACE(
+      "SELECT to_base64(cast(make_set_digest(col) as varbinary)) "
+      "FROM (VALUES ('apple'), ('banana'), ('cherry')) AS t(col)");
+
+  SetDigest<StringView> digest1(allocator_.get());
+  digest1.add(StringView("apple"));
+  digest1.add(StringView("banana"));
+  digest1.add(StringView("cherry"));
+
+  int32_t size1 = digest1.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest1.serialize(buffer1.data());
+
+  SetDigest<StringView> digest2(allocator_.get());
+  ASSERT_TRUE(digest2.deserialize(buffer1.data(), size1).ok());
+
+  EXPECT_TRUE(digest2.isExact());
+  EXPECT_EQ(digest2.cardinality(), 3);
+
+  int32_t size2 = digest2.estimatedSerializedSize();
+  std::vector<char> buffer2(size2);
+  digest2.serialize(buffer2.data());
+
+  EXPECT_EQ(size1, size2);
+  EXPECT_EQ(
+      std::string(buffer1.begin(), buffer1.end()),
+      std::string(buffer2.begin(), buffer2.end()));
+
+  SetDigest<StringView> digest3(allocator_.get());
+  ASSERT_TRUE(digest3.deserialize(buffer2.data(), size2).ok());
+  int32_t size3 = digest3.estimatedSerializedSize();
+  std::vector<char> buffer3(size3);
+  digest3.serialize(buffer3.data());
+
+  EXPECT_EQ(
+      std::string(buffer3.begin(), buffer3.end()),
+      std::string(buffer1.begin(), buffer1.end()));
+}
+
+TEST_F(SetDigestTest, sparseHllToDenseConversion) {
+  SetDigest<int64_t> digest(allocator_.get());
+
+  // digest is still exact (5000 < 8192 maxHashes)
+  constexpr int32_t kNumValues = 5000;
+  for (int32_t i = 0; i < kNumValues; i++) {
+    digest.add(static_cast<int64_t>(i));
+  }
+
+  EXPECT_TRUE(digest.isExact());
+  EXPECT_EQ(digest.cardinality(), kNumValues);
+
+  int32_t size1 = digest.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest.serialize(buffer1.data());
+
+  SetDigest<int64_t> digest2(allocator_.get());
+  ASSERT_TRUE(digest2.deserialize(buffer1.data(), size1).ok());
+
+  EXPECT_TRUE(digest2.isExact());
+  EXPECT_EQ(digest2.cardinality(), kNumValues);
+
+  int32_t size2 = digest2.estimatedSerializedSize();
+  std::vector<char> buffer2(size2);
+  digest2.serialize(buffer2.data());
+
+  EXPECT_EQ(size1, size2);
+  EXPECT_EQ(
+      std::string(buffer1.begin(), buffer1.end()),
+      std::string(buffer2.begin(), buffer2.end()));
+
+  digest2.add(static_cast<int64_t>(kNumValues));
+  EXPECT_EQ(digest2.cardinality(), kNumValues + 1);
+
+  // add enough values to exceed maxHashes (8192) and become approximate
+  constexpr int32_t kNumAdditionalValues = 5000;
+  for (int32_t i = kNumValues; i < kNumValues + kNumAdditionalValues; i++) {
+    digest.add(static_cast<int64_t>(i));
+  }
+
+  EXPECT_FALSE(digest.isExact());
+
+  int64_t actualCardinality = kNumValues + kNumAdditionalValues;
+  int64_t estimatedCardinality = digest.cardinality();
+
+  // The error bound relates to HyperLogLog cardinality estimation.
+  // Theoretical standard error: 1.04 / sqrt(2048 buckets) ≈ 2.3%
+  // Use 3x standard error for 99.7% confidence (3-sigma rule).
+  EXPECT_NEAR(
+      estimatedCardinality,
+      actualCardinality,
+      actualCardinality * 3 * kStandardError);
+
+  int32_t size3 = digest.estimatedSerializedSize();
+  std::vector<char> buffer3(size3);
+  digest.serialize(buffer3.data());
+
+  SetDigest<int64_t> digest3(allocator_.get());
+  ASSERT_TRUE(digest3.deserialize(buffer3.data(), size3).ok());
+
+  EXPECT_FALSE(digest3.isExact());
+  EXPECT_EQ(digest3.cardinality(), digest.cardinality());
+
+  int32_t size4 = digest3.estimatedSerializedSize();
+  std::vector<char> buffer4(size4);
+  digest3.serialize(buffer4.data());
+
+  EXPECT_EQ(size3, size4);
+  EXPECT_EQ(
+      std::string(buffer3.begin(), buffer3.end()),
+      std::string(buffer4.begin(), buffer4.end()));
+}
+
+// Java-equivalent tests matching TestSetDigest.java
+
+TEST_F(SetDigestTest, testIntersectionCardinality) {
+  // Equivalent to Java's testIntersectionCardinality() with default parameters
+  testIntersectionCardinalityHelper(
+      SetDigest<int64_t>::kDefaultMaxHashes,
+      SetDigest<int64_t>::kNumberOfBuckets,
+      SetDigest<int64_t>::kDefaultMaxHashes,
+      SetDigest<int64_t>::kNumberOfBuckets);
+}
+
+TEST_F(SetDigestTest, testUnevenIntersectionCardinality) {
+  // Equivalent to Java's testUnevenIntersectionCardinality()
+  testIntersectionCardinalityHelper(
+      SetDigest<int64_t>::kDefaultMaxHashes / 4,
+      SetDigest<int64_t>::kNumberOfBuckets,
+      SetDigest<int64_t>::kDefaultMaxHashes,
+      SetDigest<int64_t>::kNumberOfBuckets);
+}
+
+void SetDigestTest::testIntersectionCardinalityHelper(
+    int32_t maxHashes1,
+    int32_t numBuckets1,
+    int32_t maxHashes2,
+    int32_t numBuckets2) {
+  std::vector<int32_t> sizes;
+
+  std::mt19937 rand(0); // Same seed as Java for reproducibility
+  // Generate random size from each power of ten in [10, 100,000,000]
+  for (int32_t i = 10; i < 100000000; i *= 10) {
+    std::uniform_int_distribution<int32_t> dist(10, i + 9);
+    sizes.push_back(dist(rand));
+  }
+
+  for (int32_t size : sizes) {
+    int32_t expectedCardinality = 0;
+    SetDigest<int64_t> digest1(
+        allocator_.get(),
+        static_cast<int8_t>(std::log2(numBuckets1)),
+        maxHashes1);
+    SetDigest<int64_t> digest2(
+        allocator_.get(),
+        static_cast<int8_t>(std::log2(numBuckets2)),
+        maxHashes2);
+
+    std::uniform_int_distribution<int64_t> valueDist;
+    std::uniform_real_distribution<double> probDist(0.0, 1.0);
+
+    for (int32_t j = 0; j < size; j++) {
+      int32_t added = 0;
+      int64_t value = valueDist(rand);
+
+      if (probDist(rand) < 0.5) {
+        digest1.add(value);
+        added++;
+      }
+      if (probDist(rand) < 0.5) {
+        digest2.add(value);
+        added++;
+      }
+      if (added == 2) {
+        expectedCardinality++;
+      }
+    }
+
+    // Skip test if expectedCardinality is too small
+    if (expectedCardinality < 10) {
+      continue;
+    }
+
+    // Calculate intersection using C++ implementation
+    int64_t estimatedCardinality;
+    if (digest1.isExact() && digest2.isExact()) {
+      estimatedCardinality =
+          SetDigest<int64_t>::exactIntersectionCardinality(digest1, digest2);
+    } else {
+      // Use Jaccard index for approximate intersection
+      int64_t cardinality1 = digest1.cardinality();
+      int64_t cardinality2 = digest2.cardinality();
+      double jaccard = SetDigest<int64_t>::jaccardIndex(digest1, digest2);
+
+      // Merge to get union cardinality
+      SetDigest<int64_t> tempDigest(
+          allocator_.get(),
+          static_cast<int8_t>(std::log2(numBuckets1)),
+          maxHashes1);
+      tempDigest.mergeWith(digest1);
+      tempDigest.mergeWith(digest2);
+      int64_t unionCardinality = tempDigest.cardinality();
+
+      estimatedCardinality =
+          static_cast<int64_t>(std::round(jaccard * unionCardinality));
+      estimatedCardinality =
+          std::min(estimatedCardinality, std::min(cardinality1, cardinality2));
+    }
+
+    double errorRate = std::abs(expectedCardinality - estimatedCardinality) /
+        static_cast<double>(expectedCardinality);
+    EXPECT_LT(errorRate, 0.10);
+  }
+}
+
+TEST_F(SetDigestTest, testSmallLargeIntersections) {
+  // Equivalent to Java's testSmallLargeIntersections()
+  std::vector<int32_t> sizes;
+
+  std::mt19937 rand(0); // Same seed as Java
+  for (int32_t i = 1000; i < 1000000; i *= 10) {
+    std::uniform_int_distribution<int32_t> dist(10, i + 9);
+    sizes.push_back(dist(rand));
+  }
+
+  for (size_t size1_idx = 0; size1_idx < sizes.size(); ++size1_idx) {
+    int32_t size1 = sizes[size1_idx];
+    SetDigest<int64_t> digest1(allocator_.get());
+    std::vector<std::pair<std::unique_ptr<SetDigest<int64_t>>, int32_t>>
+        smallerSets;
+
+    std::uniform_int_distribution<int64_t> valueDist;
+    std::uniform_real_distribution<double> probDist(0.0, 1.0);
+
+    for (size_t size2_idx = 0; size2_idx < size1_idx; ++size2_idx) {
+      int32_t size2 = sizes[size2_idx];
+
+      for (int32_t overlap = 2; overlap <= 10; overlap += 2) {
+        int32_t expectedCardinality = 0;
+        auto digest2 = std::make_unique<SetDigest<int64_t>>(allocator_.get());
+
+        // Reset rand for this iteration to generate same values for digest1
+        std::mt19937 innerRand(rand());
+
+        for (int32_t j = 0; j < size1; j++) {
+          int64_t value = valueDist(innerRand);
+          digest1.add(value);
+
+          if (probDist(innerRand) < size2 / static_cast<double>(size1)) {
+            if (probDist(innerRand) * 10 < overlap) {
+              digest2->add(value);
+              expectedCardinality++;
+            } else {
+              digest2->add(valueDist(innerRand));
+            }
+          }
+        }
+
+        smallerSets.emplace_back(std::move(digest2), expectedCardinality);
+      }
+    }
+
+    for (const auto& [digest2Ptr, expectedCardinality] : smallerSets) {
+      const SetDigest<int64_t>& digest2 = *digest2Ptr;
+
+      // Calculate estimated intersection
+      int64_t estIntersectionCardinality;
+      if (digest1.isExact() && digest2.isExact()) {
+        estIntersectionCardinality =
+            SetDigest<int64_t>::exactIntersectionCardinality(digest1, digest2);
+      } else {
+        int64_t cardinality1 = digest1.cardinality();
+        int64_t cardinality2 = digest2.cardinality();
+        double jaccard = SetDigest<int64_t>::jaccardIndex(digest1, digest2);
+
+        SetDigest<int64_t> tempDigest(allocator_.get());
+        tempDigest.mergeWith(digest1);
+        tempDigest.mergeWith(digest2);
+        int64_t unionCardinality = tempDigest.cardinality();
+
+        estIntersectionCardinality =
+            static_cast<int64_t>(std::round(jaccard * unionCardinality));
+        estIntersectionCardinality = std::min(
+            estIntersectionCardinality, std::min(cardinality1, cardinality2));
+      }
+
+      int64_t size2 = digest2.cardinality();
+      EXPECT_LE(estIntersectionCardinality, size2);
+
+      double errorRate =
+          std::abs(expectedCardinality - estIntersectionCardinality) /
+          static_cast<double>(size1);
+      EXPECT_LT(errorRate, 0.05);
+    }
+  }
+}
diff --git a/velox/functions/lib/tests/TDigestTest.cpp b/velox/functions/lib/tests/TDigestTest.cpp
index f26bb09890b..2bd69345709 100644
--- a/velox/functions/lib/tests/TDigestTest.cpp
+++ b/velox/functions/lib/tests/TDigestTest.cpp
@@ -346,12 +346,13 @@ TEST_F(TDigestTest, merge) {
   std::vector<double> values;
   std::string buf;
   auto test = [&](int numDigests, int size, double mean, double stddev) {
-    SCOPED_TRACE(fmt::format(
-        "numDigests={} size={} mean={} stddev={}",
-        numDigests,
-        size,
-        mean,
-        stddev));
+    SCOPED_TRACE(
+        fmt::format(
+            "numDigests={} size={} mean={} stddev={}",
+            numDigests,
+            size,
+            mean,
+            stddev));
     values.clear();
     values.reserve(numDigests * size);
     std::normal_distribution<> dist(mean, stddev);
@@ -574,5 +575,189 @@ TEST_F(TDigestTest, largeWeightFloatingPointPrecision) {
   ASSERT_FALSE(std::isnan(digest.estimateQuantile(0.5)));
 }
 
+TEST_F(TDigestTest, winsorizedMeanFullRange) {
+  // winsorizedMean(0, 1) should equal sum() / totalWeight() (regular mean).
+  constexpr int N = 1e5;
+  TDigest digest;
+  std::vector<int16_t> positions;
+  for (int i = 0; i < N; ++i) {
+    digest.add(positions, i);
+  }
+  digest.compress(positions);
+  ASSERT_NEAR(
+      digest.winsorizedMean(0, 1),
+      digest.sum() / digest.totalWeight(),
+      kSumError);
+}
+
+TEST_F(TDigestTest, winsorizedMeanUniform) {
+  // Uniform distribution: winsorization has minimal effect on mean.
+  constexpr int N = 1e6;
+  TDigest digest;
+  std::vector<int16_t> positions;
+  for (int i = 0; i < N; ++i) {
+    digest.add(positions, i);
+  }
+  digest.compress(positions);
+  double exactMean = (N - 1) / 2.0;
+  ASSERT_NEAR(digest.winsorizedMean(0.01, 0.99), exactMean, exactMean * 0.01);
+}
+
+TEST_F(TDigestTest, winsorizedMeanVsTrimmedMean) {
+  // winsorizedMean(p, 1-p) should be between trimmedMean(p, 1-p) and mean().
+  constexpr int N = 1e5;
+  TDigest digest;
+  std::vector<int16_t> positions;
+  std::default_random_engine gen(common::testutil::getRandomSeed(42));
+  std::exponential_distribution<> dist(1.0);
+  for (int i = 0; i < N; ++i) {
+    digest.add(positions, dist(gen));
+  }
+  digest.compress(positions);
+  double mean = digest.sum() / digest.totalWeight();
+  double trimmed = digest.trimmedMean(0.05, 0.95);
+  double winsorized = digest.winsorizedMean(0.05, 0.95);
+  ASSERT_GE(winsorized, std::min(trimmed, mean) - kSumError);
+  ASSERT_LE(winsorized, std::max(trimmed, mean) + kSumError);
+}
+
+TEST_F(TDigestTest, winsorizedMeanOneSided) {
+  // One-sided upper winsorization should reduce the mean.
+  constexpr int N = 1e5;
+  TDigest digest;
+  std::vector<int16_t> positions;
+  for (int i = 0; i < N; ++i) {
+    digest.add(positions, i);
+  }
+  digest.compress(positions);
+  double result = digest.winsorizedMean(0, 0.99);
+  double regularMean = digest.sum() / digest.totalWeight();
+  ASSERT_LE(result, regularMean + kSumError);
+}
+
+TEST_F(TDigestTest, winsorizedMeanEmpty) {
+  TDigest digest;
+  ASSERT_TRUE(std::isnan(digest.winsorizedMean(0.01, 0.99)));
+}
+
+TEST_F(TDigestTest, winsorizedMeanSingleElement) {
+  TDigest digest;
+  std::vector<int16_t> positions;
+  digest.add(positions, 42.0);
+  digest.compress(positions);
+  ASSERT_EQ(digest.winsorizedMean(0.01, 0.99), 42.0);
+}
+
+TEST_F(TDigestTest, winsorizedMeanAllSame) {
+  TDigest digest;
+  std::vector<int16_t> positions;
+  for (int i = 0; i < 1000; ++i) {
+    digest.add(positions, 7.0);
+  }
+  digest.compress(positions);
+  ASSERT_NEAR(digest.winsorizedMean(0.1, 0.9), 7.0, kSumError);
+}
+
+TEST_F(TDigestTest, winsorizedMeanEqualBounds) {
+  // winsorizedMean(0.5, 0.5) should equal estimateQuantile(0.5).
+  // Both tails cover the full weight and sumInBounds == 0.
+  constexpr int N{10'000};
+  TDigest digest;
+  std::vector<int16_t> positions;
+  for (int i = 0; i < N; ++i) {
+    digest.add(positions, i);
+  }
+  digest.compress(positions);
+  ASSERT_NEAR(
+      digest.winsorizedMean(0.5, 0.5), digest.estimateQuantile(0.5), kSumError);
+}
+
+TEST_F(TDigestTest, trimmedMeanNarrowRangeSmallDigest) {
+  // Both bounds within a single centroid — old trimmedMean had a special early
+  // return for this case. Verify the shared helper produces the same result.
+  TDigest digest;
+  std::vector<int16_t> positions;
+  digest.add(positions, 10.0);
+  digest.add(positions, 20.0);
+  digest.add(positions, 30.0);
+  digest.compress(positions);
+  // Narrow range around the median.
+  double trimmed{digest.trimmedMean(0.4, 0.6)};
+  ASSERT_FALSE(std::isnan(trimmed));
+  // The result should be close to the median value (20).
+  ASSERT_NEAR(trimmed, 20.0, 10.0);
+}
+
+TEST_F(TDigestTest, trimmedMeanSingleElement) {
+  // Single-element digest — trimmedMean should return that element for any
+  // valid range.
+  TDigest digest;
+  std::vector<int16_t> positions;
+  digest.add(positions, 42.0);
+  digest.compress(positions);
+  ASSERT_EQ(digest.trimmedMean(0.1, 0.9), 42.0);
+  ASSERT_EQ(digest.trimmedMean(0.0, 1.0), 42.0);
+  ASSERT_EQ(digest.trimmedMean(0.0, 0.5), 42.0);
+}
+
+TEST_F(TDigestTest, trimmedMeanVsWinsorizedMeanConsistency) {
+  // For uniform data, trimmedMean and winsorizedMean should be close since
+  // tails are symmetric. Verify both use the shared helper correctly.
+  constexpr int N{10'000};
+  TDigest digest;
+  std::vector<int16_t> positions;
+  for (int i = 0; i < N; ++i) {
+    digest.add(positions, i);
+  }
+  digest.compress(positions);
+  double trimmed{digest.trimmedMean(0.1, 0.9)};
+  double winsorized{digest.winsorizedMean(0.1, 0.9)};
+  // Both should be close to the true mean (4999.5) for uniform data.
+  double trueMean{(N - 1) / 2.0};
+  ASSERT_NEAR(trimmed, trueMean, trueMean * 0.02);
+  ASSERT_NEAR(winsorized, trueMean, trueMean * 0.02);
+}
+
+TEST_F(TDigestTest, winsorizedMeanInvalid) {
+  TDigest digest;
+  std::vector<int16_t> positions;
+  digest.add(positions, 1.0);
+  digest.compress(positions);
+  ASSERT_THROW(digest.winsorizedMean(-0.1, 0.5), VeloxRuntimeError);
+  ASSERT_THROW(digest.winsorizedMean(0.5, 1.1), VeloxRuntimeError);
+  ASSERT_THROW(digest.winsorizedMean(0.9, 0.1), VeloxRuntimeError);
+}
+
+TEST_F(TDigestTest, winsorizedMeanAccuracy) {
+  // Compare against exact winsorized mean on raw data.
+  constexpr int N = 1e5;
+  std::vector<double> values(N);
+  TDigest digest;
+  std::vector<int16_t> positions;
+  std::default_random_engine gen(common::testutil::getRandomSeed(42));
+  std::lognormal_distribution<> dist(0, 1.0);
+  for (int i = 0; i < N; ++i) {
+    values[i] = dist(gen);
+    digest.add(positions, values[i]);
+  }
+  digest.compress(positions);
+  std::sort(values.begin(), values.end());
+
+  // Compute exact winsorized mean at (0.01, 0.99).
+  int lowerK = static_cast<int>(0.01 * N);
+  int upperK = static_cast<int>(0.99 * N);
+  double qLow = values[lowerK];
+  double qHigh = values[upperK];
+  double exactSum = 0;
+  for (int i = 0; i < N; ++i) {
+    exactSum += std::max(qLow, std::min(qHigh, values[i]));
+  }
+  double exactWinsorizedMean = exactSum / N;
+
+  double approx = digest.winsorizedMean(0.01, 0.99);
+  ASSERT_NEAR(
+      approx, exactWinsorizedMean, std::abs(exactWinsorizedMean) * 0.02);
+}
+
 } // namespace
 } // namespace facebook::velox::functions
diff --git a/velox/functions/lib/window/CMakeLists.txt b/velox/functions/lib/window/CMakeLists.txt
index 43994bfb98e..9c3dd07cdfb 100644
--- a/velox/functions/lib/window/CMakeLists.txt
+++ b/velox/functions/lib/window/CMakeLists.txt
@@ -12,7 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_functions_window NthValue.cpp Ntile.cpp Rank.cpp RowNumber.cpp)
+velox_add_library(
+  velox_functions_window
+  NthValue.cpp
+  Ntile.cpp
+  Rank.cpp
+  RowNumber.cpp
+  HEADERS
+  RegistrationFunctions.h
+)
 
 velox_link_libraries(velox_functions_window velox_buffer velox_exec Folly::folly)
 
diff --git a/velox/functions/lib/window/NthValue.cpp b/velox/functions/lib/window/NthValue.cpp
index 5ef33fc303c..97b32fb6584 100644
--- a/velox/functions/lib/window/NthValue.cpp
+++ b/velox/functions/lib/window/NthValue.cpp
@@ -31,13 +31,16 @@ class NthValueFunction : public exec::WindowFunction {
       velox::memory::MemoryPool* pool)
       : WindowFunction(resultType, pool, nullptr), ignoreNulls_(ignoreNulls) {
     VELOX_CHECK_EQ(args.size(), 2);
-    VELOX_CHECK_NULL(args[0].constantValue);
     auto offsetType = args[1].type;
     VELOX_USER_CHECK(
         (offsetType->isInteger() || offsetType->isBigint()),
         "Invalid offset type: {}",
         offsetType->toString());
-    valueIndex_ = args[0].index.value();
+    if (args[0].constantValue) {
+      constantValue_ = args[0].constantValue;
+    } else {
+      valueIndex_ = args[0].index.value();
+    }
     if (args[1].constantValue) {
       if (args[1].constantValue->isNullAt(0)) {
         isConstantOffsetNull_ = true;
@@ -82,6 +85,17 @@ class NthValueFunction : public exec::WindowFunction {
       int32_t resultOffset,
       const VectorPtr& result) override {
     auto numRows = frameStarts->size() / sizeof(vector_size_t);
+
+    // When value is a constant null and IGNORE NULLS is set, the result is
+    // always null.
+    if (constantValue_ && ignoreNulls_ && constantValue_->isNullAt(0)) {
+      for (auto i = 0; i < numRows; ++i) {
+        result->setNull(resultOffset + i, true);
+      }
+      partitionOffset_ += numRows;
+      return;
+    }
+
     rowNumbers_.resize(numRows);
 
     if (isConstantOffsetNull_) {
@@ -94,9 +108,13 @@ class NthValueFunction : public exec::WindowFunction {
 
     setRowNumbersForEmptyFrames(validRows);
 
-    auto rowNumbersRange = folly::Range(rowNumbers_.data(), numRows);
-    partition_->extractColumn(
-        valueIndex_, rowNumbersRange, resultOffset, result);
+    if (constantValue_) {
+      setConstantResult(numRows, resultOffset, result);
+    } else {
+      auto rowNumbersRange = folly::Range(rowNumbers_.data(), numRows);
+      partition_->extractColumn(
+          valueIndex_, rowNumbersRange, resultOffset, result);
+    }
 
     partitionOffset_ += numRows;
   }
@@ -116,7 +134,9 @@ class NthValueFunction : public exec::WindowFunction {
     auto rawFrameEnds = frameEnds->as<vector_size_t>();
     bool ignoreNullsForBlock = false;
     vector_size_t leastFrame = 0;
-    if (ignoreNulls_) {
+    // When the value is a constant (non-null, since null+ignoreNulls is
+    // handled earlier), there are no nulls to ignore.
+    if (ignoreNulls_ && !constantValue_) {
       auto extractNullsResult = partition_->extractNulls(
           valueIndex_, validRows, frameStarts, frameEnds, &nulls_);
       // Perform ignoreNulls processing only if there are null values in the
@@ -223,6 +243,21 @@ class NthValueFunction : public exec::WindowFunction {
     }
   }
 
+  // Write the constant value for rows with valid rowNumbers and null
+  // otherwise.
+  void setConstantResult(
+      vector_size_t numRows,
+      int32_t resultOffset,
+      const VectorPtr& result) {
+    for (auto i = 0; i < numRows; ++i) {
+      if (rowNumbers_[i] == kNullRow) {
+        result->setNull(resultOffset + i, true);
+      } else {
+        result->copy(constantValue_.get(), resultOffset + i, 0, 1);
+      }
+    }
+  }
+
   void setRowNumbersForEmptyFrames(const SelectivityVector& validRows) {
     if (validRows.isAllSelected()) {
       return;
@@ -271,6 +306,9 @@ class NthValueFunction : public exec::WindowFunction {
 
   const bool ignoreNulls_;
 
+  // Non-null when the value argument is a constant expression.
+  VectorPtr constantValue_;
+
   // These are the argument indices of the nth_value value and offset columns
   // in the input row vector. These are needed to retrieve column values
   // from the partition data.
@@ -312,7 +350,7 @@ void registerNthValue(const std::string& name, TypeKind offsetTypeKind) {
           .typeVariable("T")
           .returnType("T")
           .argumentType("T")
-          .argumentType(mapTypeKindToName(offsetTypeKind))
+          .argumentType(std::string(TypeKindName::toName(offsetTypeKind)))
           .build(),
   };
 
diff --git a/velox/functions/lib/window/RowNumber.cpp b/velox/functions/lib/window/RowNumber.cpp
index 81fc7e5e0c6..67d34933061 100644
--- a/velox/functions/lib/window/RowNumber.cpp
+++ b/velox/functions/lib/window/RowNumber.cpp
@@ -68,7 +68,7 @@ class RowNumberFunction : public exec::WindowFunction {
 void registerRowNumber(const std::string& name, TypeKind resultTypeKind) {
   std::vector<exec::FunctionSignaturePtr> signatures{
       exec::FunctionSignatureBuilder()
-          .returnType(mapTypeKindToName(resultTypeKind))
+          .returnType(std::string(TypeKindName::toName(resultTypeKind)))
           .build(),
   };
 
diff --git a/velox/functions/lib/window/tests/CMakeLists.txt b/velox/functions/lib/window/tests/CMakeLists.txt
index 0320b47d22a..5233fe21e9b 100644
--- a/velox/functions/lib/window/tests/CMakeLists.txt
+++ b/velox/functions/lib/window/tests/CMakeLists.txt
@@ -13,6 +13,7 @@
 # limitations under the License.
 
 add_library(velox_functions_window_test_lib WindowTestBase.cpp)
+velox_add_test_headers(velox_functions_window_test_lib WindowTestBase.h)
 
 target_link_libraries(
   velox_functions_window_test_lib
diff --git a/velox/functions/lib/window/tests/WindowTestBase.cpp b/velox/functions/lib/window/tests/WindowTestBase.cpp
index 07a255974ca..8dd66364bf5 100644
--- a/velox/functions/lib/window/tests/WindowTestBase.cpp
+++ b/velox/functions/lib/window/tests/WindowTestBase.cpp
@@ -59,13 +59,18 @@ WindowTestBase::QueryInfo WindowTestBase::buildStreamingWindowQuery(
   auto windowExpr = duckdb::parseWindowExpr(functionSql, {});
 
   // Extract the partition by keys.
-  for (const auto& partition : windowExpr.partitionBy) {
+  for (const auto& partition : windowExpr->partitionKeys()) {
     orderByClauses.push_back(partition->toString() + " NULLS FIRST");
   }
 
   // Extract the order by keys.
-  for (const auto& clause : windowExpr.orderBy) {
-    orderByClauses.push_back(clause.toString());
+  for (const auto& sortKey : windowExpr->orderByKeys()) {
+    orderByClauses.push_back(
+        fmt::format(
+            "{} {} NULLS {}",
+            sortKey.expr->toString(),
+            (sortKey.ascending ? "ASC" : "DESC"),
+            (sortKey.nullsFirst ? "FIRST" : "LAST")));
   }
 
   // Sort the input data before streaming window.
diff --git a/velox/functions/prestosql/Arithmetic.h b/velox/functions/prestosql/Arithmetic.h
index 836e073befc..9e3835981cd 100644
--- a/velox/functions/prestosql/Arithmetic.h
+++ b/velox/functions/prestosql/Arithmetic.h
@@ -191,6 +191,45 @@ struct ModulusFunction {
   }
 };
 
+// Positive modulo for integral types. Returns NULL for division by zero.
+template <typename T>
+struct PModIntFunction {
+  template <typename TInput>
+  FOLLY_ALWAYS_INLINE bool call(TInput& result, const TInput a, const TInput n)
+#if defined(__has_feature)
+#if __has_feature(__address_sanitizer__)
+      __attribute__((__no_sanitize__("signed-integer-overflow")))
+#endif
+#endif
+  {
+    if (UNLIKELY(n == 0)) {
+      return false;
+    }
+    if (UNLIKELY(n == 1 || n == -1)) {
+      result = 0;
+      return true;
+    }
+    TInput r = a % n;
+    result = (r > 0) ? r : (r + n) % n;
+    return true;
+  }
+};
+
+// Positive modulo for floating-point types. Returns NULL for division by zero.
+template <typename T>
+struct PModFloatFunction {
+  template <typename TInput>
+  FOLLY_ALWAYS_INLINE bool
+  call(TInput& result, const TInput a, const TInput n) {
+    if (UNLIKELY(n == static_cast<TInput>(0))) {
+      return false;
+    }
+    TInput r = std::fmod(a, n);
+    result = (r > 0) ? r : std::fmod(r + n, n);
+    return true;
+  }
+};
+
 template <typename T>
 struct CeilFunction {
   template <typename TOutput, typename TInput = TOutput>
diff --git a/velox/functions/prestosql/ArithmeticImpl.h b/velox/functions/prestosql/ArithmeticImpl.h
index a7b85dd78db..cb12ac645cb 100644
--- a/velox/functions/prestosql/ArithmeticImpl.h
+++ b/velox/functions/prestosql/ArithmeticImpl.h
@@ -76,7 +76,7 @@ round(const TNum& number, const TDecimals& decimals = 0) {
   // The threshold is a somewhat arbitrary/empirical number taking up 44 bits in
   // the integer form.
   if constexpr (!std::is_integral_v<TNum>) {
-    if (fabs(number) < 17592186044415) {
+    if (fabs(number) < 17592186044415.F) {
       return std::round(number * factor) / factor;
     }
   }
diff --git a/velox/functions/prestosql/ArrayAndMapMatch.cpp b/velox/functions/prestosql/ArrayAndMapMatch.cpp
index 9907db732f7..56233297b0a 100644
--- a/velox/functions/prestosql/ArrayAndMapMatch.cpp
+++ b/velox/functions/prestosql/ArrayAndMapMatch.cpp
@@ -267,6 +267,7 @@ class MapValuesMatchFunction
   }
 };
 
+class AllValuesMatchFunction : public MapValuesMatchFunction<true, false> {};
 class AnyValuesMatchFunction : public MapValuesMatchFunction<false, true> {};
 class NoValuesMatchFunction : public MapValuesMatchFunction<true, true> {};
 
@@ -359,4 +360,22 @@ VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<NoValuesMatchFunction>());
 
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
+    udf_map_values_all_match,
+    valuesSignatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
+    std::make_unique<AllValuesMatchFunction>());
+
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
+    udf_map_values_any_match,
+    valuesSignatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
+    std::make_unique<AnyValuesMatchFunction>());
+
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
+    udf_map_values_none_match,
+    valuesSignatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
+    std::make_unique<NoValuesMatchFunction>());
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/ArrayDistinct.cpp b/velox/functions/prestosql/ArrayDistinct.cpp
index 45d9809ffad..2833defc2ec 100644
--- a/velox/functions/prestosql/ArrayDistinct.cpp
+++ b/velox/functions/prestosql/ArrayDistinct.cpp
@@ -291,7 +291,7 @@ std::shared_ptr<exec::VectorFunction> create(
     const core::QueryConfig& /*config*/) {
   validateType(inputArgs);
   auto elementType = inputArgs.front().type->childAt(0);
-  if (elementType->isUnKnown()) {
+  if (elementType->isUnknown()) {
     return std::make_shared<ArrayDistinctFunction<UnknownType>>();
   }
 
diff --git a/velox/functions/prestosql/ArrayFlatten.cpp b/velox/functions/prestosql/ArrayFlatten.cpp
index f245524b9f7..4201b71d688 100644
--- a/velox/functions/prestosql/ArrayFlatten.cpp
+++ b/velox/functions/prestosql/ArrayFlatten.cpp
@@ -106,6 +106,8 @@ class ArrayFlattenFunction : public exec::VectorFunction {
       state.arraySizes = arrayVector->rawSizes();
 
       const auto innerArrayVector = arrayVector->elements();
+      state.flattenElementsConsecutive =
+          innerArrayVector->encoding() == VectorEncoding::Simple::ARRAY;
       state.innerArrayRowSelector =
           std::make_unique<exec::LocalSelectivityVector>(
               context, innerArrayVector->size());
diff --git a/velox/functions/prestosql/ArrayFunctions.h b/velox/functions/prestosql/ArrayFunctions.h
index 8c66fefb01e..cca5e012e00 100644
--- a/velox/functions/prestosql/ArrayFunctions.h
+++ b/velox/functions/prestosql/ArrayFunctions.h
@@ -686,24 +686,22 @@ template <typename TExec, typename T>
 struct ArrayConcatFunction {
   VELOX_DEFINE_FUNCTION_TYPES(TExec)
 
-  static constexpr int32_t kMinArity = 2;
-  static constexpr int32_t kMaxArity = 254;
+  static constexpr int32_t kMaxArity = 252;
 
   void call(
       out_type<Array<T>>& out,
+      const arg_type<Array<T>>& array1,
+      const arg_type<Array<T>>& array2,
       const arg_type<Variadic<Array<T>>>& arrays) {
-    VELOX_USER_CHECK_GE(
-        arrays.size(),
-        kMinArity,
-        "There must be {} or more arguments to concat",
-        kMinArity);
     VELOX_USER_CHECK_LE(
         arrays.size(), kMaxArity, "Too many arguments for concat function");
-    int64_t elementCount = 0;
+    int64_t elementCount = array1.size() + array2.size();
     for (const auto& array : arrays) {
       elementCount += array.value().size();
     }
     out.reserve(elementCount);
+    out.add_items(array1);
+    out.add_items(array2);
     for (const auto& array : arrays) {
       out.add_items(array.value());
     }
@@ -1030,6 +1028,46 @@ struct ArrayNGramsFunctionString {
   }
 };
 
+/// Splits the input array into chunks of the given size. If the array is not
+/// evenly divisible, the last chunk contains the remaining elements.
+///
+/// array_split_into_chunks(array(T), sz) -> array(array(T))
+template <typename TExecParams, typename T>
+struct ArraySplitIntoChunksFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExecParams);
+
+  static constexpr int32_t kMaxNumChunks = 10'000;
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<velox::Array<velox::Array<T>>>& out,
+      const arg_type<velox::Array<T>>& input,
+      const int32_t& sz) {
+    VELOX_USER_CHECK_GT(
+        sz, 0, "Invalid slice size: {}. Size must be greater than zero.", sz);
+
+    const auto inputSize = input.size();
+    VELOX_USER_CHECK_GT(inputSize, 0, "Cannot split an empty array.");
+
+    VELOX_USER_CHECK_LE(
+        inputSize / sz,
+        kMaxNumChunks,
+        "Cannot split array of size: {} into more than 10000 parts.",
+        inputSize);
+
+    for (auto i = 0; i < inputSize; i += sz) {
+      auto& chunk = out.add_item();
+      const auto end = std::min<int64_t>(i + sz, inputSize);
+      for (auto j = i; j < end; ++j) {
+        if (!input[j].has_value()) {
+          chunk.add_null();
+        } else {
+          chunk.push_back(input[j].value());
+        }
+      }
+    }
+  }
+};
+
 /// This class implements the array union function.
 ///
 /// DEFINITION:
diff --git a/velox/functions/prestosql/ArrayIntersectExcept.cpp b/velox/functions/prestosql/ArrayIntersectExcept.cpp
index 076d3114f1f..2b21e3ccab4 100644
--- a/velox/functions/prestosql/ArrayIntersectExcept.cpp
+++ b/velox/functions/prestosql/ArrayIntersectExcept.cpp
@@ -32,6 +32,10 @@ struct SetWithNull {
     return set.insert(decodedElements->valueAt<T>(offset)).second;
   }
 
+  void reserve(vector_size_t size) {
+    set.reserve(size);
+  }
+
   size_t count(const DecodedVector* decodedElements, vector_size_t offset)
       const {
     return set.count(decodedElements->valueAt<T>(offset));
@@ -95,6 +99,10 @@ struct SetWithNull<WrappedVectorEntry> {
     return set.insert(WrappedVectorEntry{hash, vector, index}).second;
   }
 
+  void reserve(vector_size_t size) {
+    set.reserve(size);
+  }
+
   size_t count(const DecodedVector* decodedElements, vector_size_t offset)
       const {
     const auto vector = decodedElements->base();
@@ -125,6 +133,7 @@ void generateSet(
   auto size = arrayVector->sizeAt(idx);
   auto offset = arrayVector->offsetAt(idx);
   rightSet.reset();
+  rightSet.reserve(size);
 
   for (vector_size_t i = offset; i < (offset + size); ++i) {
     if (arrayElements->isNullAt(i)) {
@@ -236,6 +245,7 @@ class ArraysIntersectSingleParam : public exec::VectorFunction {
         auto innerIdx = decodedInnerArray->index(i);
         auto innerOffset = innerArray->offsetAt(innerIdx);
         auto innerSize = innerArray->sizeAt(innerIdx);
+        intermediateSet.reserve(innerSize);
 
         // 3. Regular array
         for (auto j = innerOffset; j < (innerOffset + innerSize); ++j) {
@@ -369,6 +379,7 @@ class ArrayIntersectExceptFunction : public exec::VectorFunction {
       auto offset = baseLeftArray->offsetAt(idx);
 
       outputSet.reset();
+      outputSet.reserve(size);
       rawNewOffsets[row] = indicesCursor;
       // Scans the array elements on the left-hand side.
       for (vector_size_t i = offset; i < (offset + size); ++i) {
diff --git a/velox/functions/prestosql/ArrayMinMaxBy.cpp b/velox/functions/prestosql/ArrayMinMaxBy.cpp
index 0d524adf596..2473b1649b2 100644
--- a/velox/functions/prestosql/ArrayMinMaxBy.cpp
+++ b/velox/functions/prestosql/ArrayMinMaxBy.cpp
@@ -21,7 +21,6 @@
 #include "velox/expression/Expr.h"
 #include "velox/expression/VectorFunction.h"
 #include "velox/functions/lib/LambdaFunctionUtil.h"
-#include "velox/functions/lib/RowsTranslationUtil.h"
 
 namespace facebook::velox::functions {
 namespace {
@@ -52,34 +51,22 @@ class ArrayMinMaxByFunction : public exec::VectorFunction {
       return;
     }
 
-    std::vector<VectorPtr> lambdaArgs = {flatArray->elements()};
-    auto newNumElements = flatArray->elements()->size();
-
+    auto numElements = flatArray->elements()->size();
+    const std::vector<VectorPtr> lambdaArgs = {flatArray->elements()};
     SelectivityVector validRowsInReusedResult =
-        toElementRows<ArrayVector>(newNumElements, rows, flatArray.get());
+        toElementRows<ArrayVector>(numElements, rows, flatArray.get());
 
     VectorPtr newElements;
-    auto elementToTopLevelRows = getElementToTopLevelRows(
-        newNumElements, rows, flatArray.get(), context.pool());
-
-    // Loop over lambda functions and apply these to elements of the base array.
-    // In most cases there will be only one function and the loop will run once.
-    auto it = args[1]->asUnchecked<FunctionVector>()->iterator(&rows);
-    while (auto entry = it.next()) {
-      auto elementRows = toElementRows<ArrayVector>(
-          newNumElements, *entry.rows, flatArray.get());
-      auto wrapCapture = toWrapCapture<ArrayVector>(
-          newNumElements, entry.callable, *entry.rows, flatArray);
-
-      entry.callable->apply(
-          elementRows,
-          &validRowsInReusedResult,
-          wrapCapture,
-          &context,
-          lambdaArgs,
-          elementToTopLevelRows,
-          &newElements);
-    }
+    // Apply lambda to array elements.
+    applyLambdaToElements<ArrayVector>(
+        args[1],
+        rows,
+        numElements,
+        flatArray,
+        lambdaArgs,
+        validRowsInReusedResult,
+        context,
+        newElements);
 
     // New elements after the lambda function is applied
     exec::LocalDecodedVector decodedElements(
diff --git a/velox/functions/prestosql/ArrayPosition.cpp b/velox/functions/prestosql/ArrayPosition.cpp
index 631bd4738bc..4935ba6b84b 100644
--- a/velox/functions/prestosql/ArrayPosition.cpp
+++ b/velox/functions/prestosql/ArrayPosition.cpp
@@ -437,22 +437,23 @@ class ArrayPositionFunction : public exec::VectorFunction {
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
-    return {// array(T), T -> int64_t
-            exec::FunctionSignatureBuilder()
-                .typeVariable("T")
-                .returnType("bigint")
-                .argumentType("array(T)")
-                .argumentType("T")
-                .build(),
-
-            // array(T), T, int64_t -> int64_t
-            exec::FunctionSignatureBuilder()
-                .typeVariable("T")
-                .returnType("bigint")
-                .argumentType("array(T)")
-                .argumentType("T")
-                .argumentType("bigint")
-                .build()};
+    return {
+        // array(T), T -> int64_t
+        exec::FunctionSignatureBuilder()
+            .typeVariable("T")
+            .returnType("bigint")
+            .argumentType("array(T)")
+            .argumentType("T")
+            .build(),
+
+        // array(T), T, int64_t -> int64_t
+        exec::FunctionSignatureBuilder()
+            .typeVariable("T")
+            .returnType("bigint")
+            .argumentType("array(T)")
+            .argumentType("T")
+            .argumentType("bigint")
+            .build()};
   }
 };
 
diff --git a/velox/functions/prestosql/ArraySort.cpp b/velox/functions/prestosql/ArraySort.cpp
index d04e07e24a4..c417fd96f6c 100644
--- a/velox/functions/prestosql/ArraySort.cpp
+++ b/velox/functions/prestosql/ArraySort.cpp
@@ -14,550 +14,32 @@
  * limitations under the License.
  */
 
-#include <folly/container/F14Set.h>
-
-#include "velox/expression/EvalCtx.h"
-#include "velox/expression/Expr.h"
-#include "velox/expression/VectorFunction.h"
-#include "velox/functions/lib/LambdaFunctionUtil.h"
-#include "velox/functions/lib/RowsTranslationUtil.h"
-#include "velox/functions/prestosql/SimpleComparisonMatcher.h"
-#include "velox/type/FloatingPointUtil.h"
+#include "velox/functions/prestosql/ArraySort.h"
 
 namespace facebook::velox::functions {
-namespace {
-
-BufferPtr sortElements(
-    const SelectivityVector& rows,
-    const ArrayVector& inputArray,
-    const BaseVector& inputElements,
-    bool ascending,
-    exec::EvalCtx& context,
-    bool throwOnNestedNull) {
-  const SelectivityVector inputElementRows =
-      toElementRows(inputElements.size(), rows, &inputArray);
-  exec::LocalDecodedVector decodedElements(
-      context, inputElements, inputElementRows);
-  const auto* baseElementsVector = decodedElements->base();
-
-  // Allocate new vectors for indices.
-  BufferPtr indices = allocateIndices(inputElements.size(), context.pool());
-  vector_size_t* rawIndices = indices->asMutable<vector_size_t>();
-
-  CompareFlags flags{.nullsFirst = false, .ascending = ascending};
-  if (throwOnNestedNull) {
-    flags.nullHandlingMode =
-        CompareFlags::NullHandlingMode::kNullAsIndeterminate;
-  }
-
-  auto decodedIndices = decodedElements->indices();
-  context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
-    const auto size = inputArray.sizeAt(row);
-    const auto offset = inputArray.offsetAt(row);
-
-    for (auto i = offset; i < offset + size; ++i) {
-      rawIndices[i] = i;
-    }
-
-    std::sort(
-        rawIndices + offset,
-        rawIndices + offset + size,
-        [&](vector_size_t& a, vector_size_t& b) {
-          if (a == b) {
-            return false;
-          }
-          bool aNull = decodedElements->isNullAt(a);
-          bool bNull = decodedElements->isNullAt(b);
-          if (aNull) {
-            return false;
-          }
-          if (bNull) {
-            return true;
-          }
-
-          std::optional<int32_t> result = baseElementsVector->compare(
-              baseElementsVector, decodedIndices[a], decodedIndices[b], flags);
-
-          if (!result.has_value()) {
-            VELOX_USER_FAIL("Ordering nulls is not supported");
-          }
-
-          return result.value() < 0;
-        });
-  });
-
-  return indices;
-}
-
-void applyComplexType(
-    const SelectivityVector& rows,
-    ArrayVector* inputArray,
-    bool ascending,
-    exec::EvalCtx& context,
-    VectorPtr& resultElements,
-    bool throwOnNestedNull) {
-  auto inputElements = inputArray->elements();
-  auto indices = sortElements(
-      rows, *inputArray, *inputElements, ascending, context, throwOnNestedNull);
-  resultElements = BaseVector::transpose(indices, std::move(inputElements));
-}
-
-template <typename T>
-inline void swapWithNull(
-    FlatVector<T>* vector,
-    vector_size_t index,
-    vector_size_t nullIndex) {
-  // Values are already present in vector stringBuffers. Don't create additional
-  // copy.
-  if constexpr (std::is_same_v<T, StringView>) {
-    vector->setNoCopy(nullIndex, vector->valueAt(index));
-  } else {
-    vector->set(nullIndex, vector->valueAt(index));
-  }
-  vector->setNull(index, true);
-}
-
-template <TypeKind kind>
-void applyScalarType(
-    const SelectivityVector& rows,
-    const ArrayVector* inputArray,
-    bool ascending,
-    exec::EvalCtx& context,
-    VectorPtr& resultElements) {
-  using T = typename TypeTraits<kind>::NativeType;
-
-  // Copy array elements to new vector.
-  const VectorPtr& inputElements = inputArray->elements();
-  VELOX_DCHECK(kind == inputElements->typeKind());
-  const SelectivityVector inputElementRows =
-      toElementRows(inputElements->size(), rows, inputArray);
-  const vector_size_t elementsCount = inputElementRows.size();
-
-  // TODO: consider to use dictionary wrapping to avoid the direct sorting on
-  // the scalar values as we do for complex data type if this runs slow in
-  // practice.
-  resultElements =
-      BaseVector::create(inputElements->type(), elementsCount, context.pool());
-  resultElements->copy(
-      inputElements.get(), inputElementRows, /*toSourceRow=*/nullptr);
-
-  auto flatResults = resultElements->asFlatVector<T>();
-
-  auto processRow = [&](vector_size_t row) {
-    const auto size = inputArray->sizeAt(row);
-    const auto offset = inputArray->offsetAt(row);
-    if (size == 0) {
-      return;
-    }
-    vector_size_t numNulls = 0;
-    // Move nulls to end of array.
-    for (vector_size_t i = size - 1; i >= 0; --i) {
-      if (flatResults->isNullAt(offset + i)) {
-        swapWithNull<T>(flatResults, offset + size - numNulls - 1, offset + i);
-        ++numNulls;
-      }
-    }
-    // Exclude null values while sorting.
-    const auto startRow = offset;
-    const auto endRow = startRow + size - numNulls;
-
-    if constexpr (kind == TypeKind::BOOLEAN) {
-      uint64_t* rawBits = flatResults->template mutableRawValues<uint64_t>();
-      const auto numOneBits = bits::countBits(rawBits, startRow, endRow);
-      const auto endZeroRow = endRow - numOneBits;
-
-      if (ascending) {
-        bits::fillBits(rawBits, startRow, endZeroRow, false);
-        bits::fillBits(rawBits, endZeroRow, endRow, true);
-      } else {
-        bits::fillBits(rawBits, startRow, startRow + numOneBits, true);
-        bits::fillBits(rawBits, startRow + numOneBits, endRow, false);
-      }
-    } else if constexpr (kind == TypeKind::REAL || kind == TypeKind::DOUBLE) {
-      T* resultRawValues = flatResults->mutableRawValues();
-      if (ascending) {
-        std::sort(
-            resultRawValues + startRow,
-            resultRawValues + endRow,
-            util::floating_point::NaNAwareLessThan<T>());
-      } else {
-        std::sort(
-            resultRawValues + startRow,
-            resultRawValues + endRow,
-            util::floating_point::NaNAwareGreaterThan<T>());
-      }
-    } else {
-      T* resultRawValues = flatResults->mutableRawValues();
-      if (ascending) {
-        std::sort(resultRawValues + startRow, resultRawValues + endRow);
-      } else {
-        std::sort(
-            resultRawValues + startRow,
-            resultRawValues + endRow,
-            std::greater<T>());
-      }
-    }
-  };
-  rows.applyToSelected(processRow);
-}
-
-// See documentation at https://prestodb.io/docs/current/functions/array.html
-template <TypeKind Kind>
-class ArraySortFunction : public exec::VectorFunction {
- public:
-  /// This class implements the array_sort query function. Takes an array as
-  /// input and sorts it in ascending order and null elements will be placed at
-  /// the end of the returned array.
-  ///
-  /// Along with the set, we maintain a `hasNull` flag that indicates whether
-  /// null is present in the array.
-  ///
-  /// Zero element copy for complex data type:
-  ///
-  /// In order to prevent copies of array elements with complex data type, the
-  /// function reuses the internal elements() vector from the original
-  /// ArrayVector. A new vector is created containing the indices of the sorted
-  /// elements in the output, and wrapped into a DictionaryVector. The 'lengths'
-  /// and 'offsets' vectors that control where output arrays start and end
-  /// remain the same in the output ArrayVector.
-
-  explicit ArraySortFunction(bool ascending, bool throwOnNestedNull)
-      : ascending_{ascending}, throwOnNestedNull_(throwOnNestedNull) {}
-
-  // Execute function.
-  void apply(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& /*outputType*/,
-      exec::EvalCtx& context,
-      VectorPtr& result) const override {
-    VELOX_CHECK_EQ(args.size(), 1);
-    auto& arg = args[0];
-
-    VectorPtr localResult;
-
-    // Input can be constant or flat.
-    if constexpr (Kind == TypeKind::UNKNOWN) {
-      // All elements are NULL. Hence, sorting doesn't change anything.
-      localResult = arg;
-    } else if (arg->isConstantEncoding()) {
-      auto* constantArray = arg->as<ConstantVector<ComplexType>>();
-      const auto& flatArray = constantArray->valueVector();
-      const auto flatIndex = constantArray->index();
-
-      exec::LocalSingleRow singleRow(context, flatIndex);
-      localResult = applyFlat(*singleRow, flatArray, context);
-      localResult =
-          BaseVector::wrapInConstant(rows.end(), flatIndex, localResult);
-    } else {
-      localResult = applyFlat(rows, arg, context);
-    }
-
-    context.moveOrCopyResult(localResult, rows, result);
-  }
-
- private:
-  VectorPtr applyFlat(
-      const SelectivityVector& rows,
-      const VectorPtr& arg,
-      exec::EvalCtx& context) const {
-    // Acquire the array elements vector.
-    auto inputArray = arg->as<ArrayVector>();
-    VectorPtr resultElements;
-
-    if constexpr (velox::TypeTraits<Kind>::isPrimitiveType) {
-      VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
-          applyScalarType,
-          Kind,
-          rows,
-          inputArray,
-          ascending_,
-          context,
-          resultElements);
-
-    } else {
-      applyComplexType(
-          rows,
-          inputArray,
-          ascending_,
-          context,
-          resultElements,
-          throwOnNestedNull_);
-    }
-
-    return std::make_shared<ArrayVector>(
-        context.pool(),
-        inputArray->type(),
-        inputArray->nulls(),
-        rows.end(),
-        inputArray->offsets(),
-        inputArray->sizes(),
-        resultElements,
-        inputArray->getNullCount());
-  }
-
-  const bool ascending_;
-  const bool throwOnNestedNull_;
-};
-
-class ArraySortLambdaFunction : public exec::VectorFunction {
- public:
-  explicit ArraySortLambdaFunction(bool ascending, bool throwOnNestedNull)
-      : ascending_{ascending}, throwOnNestedNull_(throwOnNestedNull) {}
-
-  void apply(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& /*outputType*/,
-      exec::EvalCtx& context,
-      VectorPtr& result) const override {
-    // Flatten input array.
-    exec::LocalDecodedVector arrayDecoder(context, *args[0], rows);
-    auto& decodedArray = *arrayDecoder.get();
-
-    auto flatArray = flattenArray(rows, args[0], decodedArray);
-
-    std::vector<VectorPtr> lambdaArgs = {flatArray->elements()};
-    auto newNumElements = flatArray->elements()->size();
-
-    SelectivityVector validRowsInReusedResult =
-        toElementRows<ArrayVector>(newNumElements, rows, flatArray.get());
-
-    // Compute sorting keys.
-    VectorPtr newElements;
-
-    auto elementToTopLevelRows = getElementToTopLevelRows(
-        newNumElements, rows, flatArray.get(), context.pool());
 
-    // Loop over lambda functions and apply these to elements of the base array.
-    // In most cases there will be only one function and the loop will run once.
-    auto it = args[1]->asUnchecked<FunctionVector>()->iterator(&rows);
-    while (auto entry = it.next()) {
-      auto elementRows = toElementRows<ArrayVector>(
-          newNumElements, *entry.rows, flatArray.get());
-      auto wrapCapture = toWrapCapture<ArrayVector>(
-          newNumElements, entry.callable, *entry.rows, flatArray);
-
-      entry.callable->apply(
-          elementRows,
-          &validRowsInReusedResult,
-          wrapCapture,
-          &context,
-          lambdaArgs,
-          elementToTopLevelRows,
-          &newElements);
-    }
-
-    // Sort 'newElements'.
-    auto indices = sortElements(
-        rows,
-        *flatArray,
-        *newElements,
-        ascending_,
-        context,
-        throwOnNestedNull_);
-    auto sortedElements = BaseVector::wrapInDictionary(
-        nullptr,
-        indices,
-        indices->size() / sizeof(vector_size_t),
-        flatArray->elements());
-
-    // Set nulls for rows not present in 'rows'.
-    BufferPtr newNulls = addNullsForUnselectedRows(flatArray, rows);
-
-    VectorPtr localResult = std::make_shared<ArrayVector>(
-        flatArray->pool(),
-        flatArray->type(),
-        std::move(newNulls),
-        rows.end(),
-        flatArray->offsets(),
-        flatArray->sizes(),
-        sortedElements);
-    context.moveOrCopyResult(localResult, rows, result);
-  }
-
- private:
-  const bool ascending_;
-  const bool throwOnNestedNull_;
-};
-
-// Create function template based on type.
-template <TypeKind kind>
-std::shared_ptr<exec::VectorFunction> createTyped(
-    const std::vector<exec::VectorFunctionArg>& inputArgs,
-    bool ascending,
-    bool throwOnNestedNull = true) {
-  VELOX_CHECK_EQ(inputArgs.size(), 1);
-  return std::make_shared<ArraySortFunction<kind>>(
-      ascending, throwOnNestedNull);
-}
-
-// Create function.
-std::shared_ptr<exec::VectorFunction> create(
+std::shared_ptr<exec::VectorFunction> makeArraySortAsc(
+    const std::string& name,
     const std::vector<exec::VectorFunctionArg>& inputArgs,
-    bool ascending,
-    bool throwOnNestedNull = true) {
+    const core::QueryConfig& config) {
   if (inputArgs.size() == 2) {
-    return std::make_shared<ArraySortLambdaFunction>(
-        ascending, throwOnNestedNull);
-  }
-
-  const auto elementType = inputArgs.front().type->childAt(0);
-  if (elementType->isUnKnown()) {
-    return createTyped<TypeKind::UNKNOWN>(
-        inputArgs, ascending, throwOnNestedNull);
-  }
-
-  return VELOX_DYNAMIC_TYPE_DISPATCH(
-      createTyped,
-      elementType->kind(),
-      inputArgs,
-      ascending,
-      throwOnNestedNull);
-}
-
-std::shared_ptr<exec::VectorFunction> createAsc(
-    const std::string& /* name */,
-    const std::vector<exec::VectorFunctionArg>& inputArgs,
-    const core::QueryConfig& /*config*/) {
-  return create(inputArgs, true, true);
-}
-
-std::shared_ptr<exec::VectorFunction> createDesc(
-    const std::string& /* name */,
-    const std::vector<exec::VectorFunctionArg>& inputArgs,
-    const core::QueryConfig& /*config*/) {
-  return create(inputArgs, false, true);
-}
-
-// Define function signature.
-std::vector<std::shared_ptr<exec::FunctionSignature>> signatures(
-    bool withComparator) {
-  std::vector<std::shared_ptr<exec::FunctionSignature>> signatures = {
-      // array(T) -> array(T)
-      exec::FunctionSignatureBuilder()
-          .orderableTypeVariable("T")
-          .returnType("array(T)")
-          .argumentType("array(T)")
-          .build(),
-      // array(T), function(T,U), boolean -> array(T)
-      exec::FunctionSignatureBuilder()
-          .typeVariable("T")
-          .orderableTypeVariable("U")
-          .returnType("array(T)")
-          .argumentType("array(T)")
-          .constantArgumentType("function(T,U)")
-          .build(),
-  };
-
-  if (withComparator) {
-    signatures.push_back(
-        // array(T), function(T,T,bigint) -> array(T)
-        exec::FunctionSignatureBuilder()
-            .typeVariable("T")
-            .returnType("array(T)")
-            .argumentType("array(T)")
-            .constantArgumentType("function(T,T,bigint)")
-            .build());
+    return makeArraySortLambdaFunction(name, inputArgs, config, true, true);
   }
-  return signatures;
-}
 
-std::vector<std::shared_ptr<exec::FunctionSignature>>
-internalCanonicalizeSignatures() {
-  std::vector<std::shared_ptr<exec::FunctionSignature>> signatures = {
-      // array(T) -> array(T)
-      exec::FunctionSignatureBuilder()
-          .typeVariable("T")
-          .returnType("array(T)")
-          .argumentType("array(T)")
-          .build()};
-  return signatures;
+  VELOX_CHECK_EQ(inputArgs.size(), 1);
+  return makeArraySort(name, inputArgs, config, true, false, true);
 }
 
-std::shared_ptr<exec::VectorFunction> createAscNoThrowOnNestedNull(
-    const std::string& /* name */,
+std::shared_ptr<exec::VectorFunction> makeArraySortDesc(
+    const std::string& name,
     const std::vector<exec::VectorFunctionArg>& inputArgs,
-    const core::QueryConfig& /*config*/) {
-  return create(inputArgs, true, false);
-}
-
-core::CallTypedExprPtr asArraySortCall(
-    const std::string& prefix,
-    const core::TypedExprPtr& expr) {
-  if (auto call = std::dynamic_pointer_cast<const core::CallTypedExpr>(expr)) {
-    if (call->name() == prefix + "array_sort") {
-      return call;
-    }
-  }
-  return nullptr;
-}
-
-} // namespace
-
-core::TypedExprPtr rewriteArraySortCall(
-    const std::string& prefix,
-    const core::TypedExprPtr& expr) {
-  auto call = asArraySortCall(prefix, expr);
-  if (call == nullptr || call->inputs().size() != 2) {
-    return nullptr;
-  }
-
-  auto lambda =
-      dynamic_cast<const core::LambdaTypedExpr*>(call->inputs()[1].get());
-  VELOX_CHECK_NOT_NULL(lambda);
-
-  // Extract 'transform' from the comparison lambda:
-  //  (x, y) -> if(func(x) < func(y),...) ===> x -> func(x).
-  if (lambda->signature()->size() != 2) {
-    return nullptr;
-  }
-
-  static const std::string kNotSupported =
-      "array_sort with comparator lambda that cannot be rewritten "
-      "into a transform is not supported: {}";
-
-  if (auto comparison =
-          functions::prestosql::isSimpleComparison(prefix, *lambda)) {
-    std::string name = comparison->isLessThen ? prefix + "array_sort"
-                                              : prefix + "array_sort_desc";
-
-    if (!comparison->expr->type()->isOrderable()) {
-      VELOX_USER_FAIL(kNotSupported, lambda->toString());
-    }
-
-    auto rewritten = std::make_shared<core::CallTypedExpr>(
-        call->type(),
-        name,
-        call->inputs()[0],
-        std::make_shared<core::LambdaTypedExpr>(
-            ROW({lambda->signature()->nameOf(0)},
-                {lambda->signature()->childAt(0)}),
-            comparison->expr));
-
-    return rewritten;
+    const core::QueryConfig& config) {
+  if (inputArgs.size() == 2) {
+    return makeArraySortLambdaFunction(name, inputArgs, config, false, true);
   }
 
-  VELOX_USER_FAIL(kNotSupported, lambda->toString());
+  VELOX_CHECK_EQ(inputArgs.size(), 1);
+  return makeArraySort(name, inputArgs, config, false, false, true);
 }
 
-// Register function.
-VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
-    udf_array_sort,
-    signatures(true),
-    createAsc);
-
-VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
-    udf_array_sort_desc,
-    signatures(false),
-    createDesc);
-
-// An internal function to canonicalize an array to allow for comparisons. Used
-// in AggregationFuzzerTest. Details in
-// https://github.com/facebookincubator/velox/issues/6999.
-VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
-    udf_$internal$canonicalize,
-    internalCanonicalizeSignatures(),
-    createAscNoThrowOnNestedNull);
-
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/ArraySort.h b/velox/functions/prestosql/ArraySort.h
index ffe5414ef2d..e26a812dc15 100644
--- a/velox/functions/prestosql/ArraySort.h
+++ b/velox/functions/prestosql/ArraySort.h
@@ -16,21 +16,18 @@
 #pragma once
 
 #include "velox/core/Expressions.h"
+#include "velox/functions/lib/ArraySort.h"
 
 namespace facebook::velox::functions {
 
-/// Analyzes array_sort(array, lambda) call to determine whether it can be
-/// re-written into a simpler call that specifies sort-by expression.
-///
-/// For example, rewrites
-///     array_sort(a, (x, y) -> if(length(x) < length(y), -1, if(length(x) >
-///     length(y), 1, 0))
-/// into
-///     array_sort(a, x -> length(x))
-///
-/// Returns new expression or nullptr if rewrite is not possible.
-core::TypedExprPtr rewriteArraySortCall(
-    const std::string& prefix,
-    const core::TypedExprPtr& expr);
+std::shared_ptr<exec::VectorFunction> makeArraySortAsc(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config);
+
+std::shared_ptr<exec::VectorFunction> makeArraySortDesc(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config);
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/ArraySubset.h b/velox/functions/prestosql/ArraySubset.h
new file mode 100644
index 00000000000..5a5af0c85cf
--- /dev/null
+++ b/velox/functions/prestosql/ArraySubset.h
@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/ComplexViewTypes.h"
+#include "velox/functions/Udf.h"
+
+namespace facebook::velox::functions {
+
+/// Fast path for constant indices: array_subset(arr, array[1, 2, 3]).
+template <typename TExec, typename T>
+struct ArraySubsetFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      out_type<Array<T>>& out,
+      const arg_type<Array<T>>& inputArray,
+      const arg_type<Array<int32_t>>& indices) {
+    // If indices is empty, return empty array
+    if (indices.empty()) {
+      return;
+    }
+
+    // Collect valid indices with explicit bounds checking
+    folly::F14FastSet<int32_t> validIndices;
+
+    for (const auto& index : indices.skipNulls()) {
+      // Only store positive indices (1-based) and check bounds
+      if (index > 0 && index <= inputArray.size()) {
+        validIndices.emplace(index);
+      }
+    }
+
+    // If no valid indices, return empty array
+    if (validIndices.empty()) {
+      return;
+    }
+
+    // Sort indices to maintain order in output
+    std::vector<int32_t> sortedIndices(
+        validIndices.begin(), validIndices.end());
+    std::sort(sortedIndices.begin(), sortedIndices.end());
+
+    for (int32_t index : sortedIndices) {
+      // Convert 1-based to 0-based index
+      int32_t zeroBasedIndex = index - 1;
+
+      // Check bounds - only add elements that exist in the input array
+      if (zeroBasedIndex >= 0 && zeroBasedIndex < inputArray.size()) {
+        if (inputArray[zeroBasedIndex].has_value()) {
+          if constexpr (std::is_same_v<T, Varchar>) {
+            out.add_item().setNoCopy(inputArray[zeroBasedIndex].value());
+          } else {
+            out.push_back(inputArray[zeroBasedIndex].value());
+          }
+        } else {
+          // Include null elements in output
+          out.add_null();
+        }
+      }
+      // Note: Out-of-bounds indices are silently ignored (no element added)
+    }
+  }
+};
+
+/// String version that avoids copy of strings.
+template <typename TExec>
+struct ArraySubsetVarcharFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  static constexpr int32_t reuse_strings_from_arg = 0;
+
+  void call(
+      out_type<Array<Varchar>>& out,
+      const arg_type<Array<Varchar>>& inputArray,
+      const arg_type<Array<int32_t>>& indices) {
+    // If indices is empty, return empty array
+    if (indices.empty()) {
+      return;
+    }
+
+    // Collect valid indices with explicit bounds checking
+    folly::F14FastSet<int32_t> validIndices;
+
+    for (const auto& index : indices.skipNulls()) {
+      // Only store positive indices (1-based) and check bounds
+      if (index > 0 && index <= inputArray.size()) {
+        validIndices.emplace(index);
+      }
+    }
+
+    // If no valid indices, return empty array
+    if (validIndices.empty()) {
+      return;
+    }
+
+    // Sort indices to maintain order in output
+    std::vector<int32_t> sortedIndices(
+        validIndices.begin(), validIndices.end());
+    std::sort(sortedIndices.begin(), sortedIndices.end());
+
+    for (int32_t index : sortedIndices) {
+      // Convert 1-based to 0-based index
+      int32_t zeroBasedIndex = index - 1;
+
+      // Check bounds - only add elements that exist in the input array
+      if (zeroBasedIndex >= 0 && zeroBasedIndex < inputArray.size()) {
+        if (inputArray[zeroBasedIndex].has_value()) {
+          out.add_item().setNoCopy(inputArray[zeroBasedIndex].value());
+        } else {
+          // Include null elements in output
+          out.add_null();
+        }
+      }
+      // Note: Out-of-bounds indices are silently ignored (no element added)
+    }
+  }
+};
+
+/// Generic implementation for complex types.
+template <typename TExec>
+struct ArraySubsetGenericFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      out_type<Array<Generic<T1>>>& out,
+      const arg_type<Array<Generic<T1>>>& inputArray,
+      const arg_type<Array<int32_t>>& indices) {
+    // If indices is empty, return empty array
+    if (indices.empty()) {
+      return;
+    }
+
+    const auto arraySize = inputArray.size();
+
+    // Early return for large arrays to prevent overflow
+    if (arraySize == 0) {
+      return;
+    }
+
+    // Collect valid 1-based indices and convert to 0-based
+    std::vector<vector_size_t> validZeroBasedIndices;
+
+    for (const auto& index : indices.skipNulls()) {
+      // Only store positive indices (1-based) and check bounds
+      if (index > 0 && static_cast<vector_size_t>(index) <= arraySize) {
+        validZeroBasedIndices.push_back(static_cast<vector_size_t>(index - 1));
+      }
+    }
+
+    // If no valid indices, return empty array
+    if (validZeroBasedIndices.empty()) {
+      return;
+    }
+
+    // Sort indices to maintain order in output
+    std::sort(validZeroBasedIndices.begin(), validZeroBasedIndices.end());
+
+    // Remove duplicates
+    validZeroBasedIndices.erase(
+        std::unique(validZeroBasedIndices.begin(), validZeroBasedIndices.end()),
+        validZeroBasedIndices.end());
+
+    // Use safe iteration approach
+    vector_size_t currentPos = 0;
+    auto it = inputArray.begin();
+
+    for (vector_size_t targetIndex : validZeroBasedIndices) {
+      // Advance iterator to target position
+      while (currentPos < targetIndex && it != inputArray.end()) {
+        ++it;
+        ++currentPos;
+      }
+
+      if (it != inputArray.end() && currentPos == targetIndex) {
+        if (it->has_value()) {
+          out.push_back(it->value());
+        } else {
+          out.add_null();
+        }
+      }
+    }
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/ArraySum.cpp b/velox/functions/prestosql/ArraySum.cpp
index 1021137323f..729534eeabe 100644
--- a/velox/functions/prestosql/ArraySum.cpp
+++ b/velox/functions/prestosql/ArraySum.cpp
@@ -285,21 +285,24 @@ std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
   std::vector<std::shared_ptr<exec::FunctionSignature>> signatures;
   signatures.reserve(typePairs.size());
   for (const auto& [argType, returnType] : typePairs) {
-    signatures.emplace_back(exec::FunctionSignatureBuilder()
-                                .returnType(returnType)
-                                .argumentType(fmt::format("array({})", argType))
-                                .build());
+    signatures.emplace_back(
+        exec::FunctionSignatureBuilder()
+            .returnType(returnType)
+            .argumentType(fmt::format("array({})", argType))
+            .build());
   }
   return signatures;
 }
 } // namespace
 
 // Register function.
-void registerVectorFunction_udf_array_sum(const std::string& name) {
+void registerVectorFunction_udf_array_sum(std::string_view name) {
   facebook::velox::exec::registerStatefulVectorFunction(
       name, signatures(), create<false>);
   facebook::velox::exec::registerStatefulVectorFunction(
-      name + "_propagate_element_null", signatures(), create<true>);
+      std::string(name) + "_propagate_element_null",
+      signatures(),
+      create<true>);
 }
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/BinaryFunctions.h b/velox/functions/prestosql/BinaryFunctions.h
index 7b2ce9ff6ae..8b5a987998d 100644
--- a/velox/functions/prestosql/BinaryFunctions.h
+++ b/velox/functions/prestosql/BinaryFunctions.h
@@ -16,11 +16,11 @@
 #pragma once
 
 #include <folly/hash/Checksum.h>
-#define XXH_INLINE_ALL
-#include <xxhash.h>
+#include "velox/common/base/XxHashInline.h"
 
 #include "folly/ssl/OpenSSLHash.h"
 #include "velox/common/base/BitUtil.h"
+#include "velox/common/encode/Base32.h"
 #include "velox/common/encode/Base64.h"
 #include "velox/common/hyperloglog/Murmur3Hash128.h"
 #include "velox/external/md5/md5.h"
@@ -88,9 +88,11 @@ struct Sha1Function {
   FOLLY_ALWAYS_INLINE
   void call(out_type<Varbinary>& result, const arg_type<Varbinary>& input) {
     result.resize(20);
+    VELOX_SUPPRESS_DEPRECATED_WARNING
     folly::ssl::OpenSSLHash::sha1(
         folly::MutableByteRange((uint8_t*)result.data(), result.size()),
         folly::ByteRange((const uint8_t*)input.data(), input.size()));
+    VELOX_UNSUPPRESS_DEPRECATED_WARNING
   }
 };
 
@@ -166,10 +168,12 @@ struct HmacSha1Function {
   call(TOutput& result, const TInput& data, const TInput& key) {
     VELOX_USER_CHECK_GT(key.size(), 0, "Empty key is not allowed");
     result.resize(20);
+    VELOX_SUPPRESS_DEPRECATED_WARNING
     folly::ssl::OpenSSLHash::hmac_sha1(
         folly::MutableByteRange((uint8_t*)result.data(), result.size()),
         folly::ByteRange((const uint8_t*)key.data(), key.size()),
         folly::ByteRange((const uint8_t*)data.data(), data.size()));
+    VELOX_UNSUPPRESS_DEPRECATED_WARNING
   }
 };
 
@@ -257,9 +261,10 @@ template <typename T>
 struct FromHexFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
+  template <typename TInput>
   FOLLY_ALWAYS_INLINE void call(
       out_type<Varchar>& result,
-      const arg_type<Varbinary>& input) {
+      const TInput& input) {
     VELOX_USER_CHECK_EQ(
         input.size() % 2,
         0,
@@ -311,11 +316,33 @@ struct FromBase64Function {
   }
 };
 
+template <typename TExec>
+struct FromBase32Function {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  // T can be either arg_type<Varchar> or arg_type<Varbinary>. These are the
+  // same, but hard-coding one of them might be confusing.
+  template <typename T>
+  FOLLY_ALWAYS_INLINE Status call(out_type<Varbinary>& result, const T& input) {
+    auto inputSize = input.size();
+    auto decodedSize =
+        encoding::Base32::calculateDecodedSize(input.data(), inputSize);
+    if (decodedSize.hasError()) {
+      return decodedSize.error();
+    }
+    result.resize(decodedSize.value());
+    return encoding::Base32::decode(
+        input.data(), inputSize, result.data(), result.size());
+  }
+};
+
 template <typename T>
 struct FromBase64UrlFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  template <typename TInput>
   FOLLY_ALWAYS_INLINE Status
-  call(out_type<Varbinary>& result, const arg_type<Varchar>& input) {
+  call(out_type<Varbinary>& result, const TInput& input) {
     auto inputSize = input.size();
     auto decodedSize =
         encoding::Base64::calculateDecodedSize(input.data(), inputSize);
@@ -500,4 +527,81 @@ struct Murmur3X64_128Function {
   }
 };
 
+/// Computes FNV hash for the given data.
+/// FNV-1 multiplies then XORs, FNV-1a XORs then multiplies.
+template <typename HashType, bool XORFirst>
+FOLLY_ALWAYS_INLINE HashType computeFnvHash(
+    const unsigned char* data,
+    size_t size,
+    HashType offsetBasis,
+    HashType prime) {
+  HashType hash = offsetBasis;
+  for (auto i = 0; i < size; ++i) {
+    if constexpr (XORFirst) {
+      hash ^= data[i];
+      hash *= prime;
+    } else {
+      hash *= prime;
+      hash ^= data[i];
+    }
+  }
+  return hash;
+}
+
+template <typename T>
+struct Fnv1_32Function {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE
+  void call(out_type<int32_t>& result, const arg_type<Varbinary>& input) {
+    static constexpr uint32_t kOffsetBasis = 0x811c9dc5;
+    static constexpr uint32_t kPrime = 0x01000193;
+    const auto* data = reinterpret_cast<const unsigned char*>(input.data());
+    result = computeFnvHash<uint32_t, false>(
+        data, input.size(), kOffsetBasis, kPrime);
+  }
+};
+
+template <typename T>
+struct Fnv1_64Function {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE
+  void call(out_type<int64_t>& result, const arg_type<Varbinary>& input) {
+    static constexpr uint64_t kOffsetBasis = 0xcbf29ce484222325L;
+    static constexpr uint64_t kPrime = 0x100000001b3L;
+    const auto* data = reinterpret_cast<const unsigned char*>(input.data());
+    result = computeFnvHash<uint64_t, false>(
+        data, input.size(), kOffsetBasis, kPrime);
+  }
+};
+
+template <typename T>
+struct Fnv1a_32Function {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE
+  void call(out_type<int32_t>& result, const arg_type<Varbinary>& input) {
+    static constexpr uint32_t kOffsetBasis = 0x811c9dc5;
+    static constexpr uint32_t kPrime = 0x01000193;
+    const auto* data = reinterpret_cast<const unsigned char*>(input.data());
+    result = computeFnvHash<uint32_t, true>(
+        data, input.size(), kOffsetBasis, kPrime);
+  }
+};
+
+template <typename T>
+struct Fnv1a_64Function {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE
+  void call(out_type<int64_t>& result, const arg_type<Varbinary>& input) {
+    static constexpr uint64_t kOffsetBasis = 0xcbf29ce484222325L;
+    static constexpr uint64_t kPrime = 0x100000001b3L;
+    const auto* data = reinterpret_cast<const unsigned char*>(input.data());
+    result = computeFnvHash<uint64_t, true>(
+        data, input.size(), kOffsetBasis, kPrime);
+  }
+};
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/BingTileFunctions.h b/velox/functions/prestosql/BingTileFunctions.h
index 46930a687cc..3277ef3ac00 100644
--- a/velox/functions/prestosql/BingTileFunctions.h
+++ b/velox/functions/prestosql/BingTileFunctions.h
@@ -28,10 +28,11 @@ FOLLY_ALWAYS_INLINE Status checkBingTileZoom(int32_t zoom) {
         fmt::format("Bing tile zoom {} cannot be negative", zoom));
   }
   if (FOLLY_UNLIKELY(zoom > BingTileType::kBingTileMaxZoomLevel)) {
-    return Status::UserError(fmt::format(
-        "Bing tile zoom {} cannot be greater than max zoom {}",
-        zoom,
-        BingTileType::kBingTileMaxZoomLevel));
+    return Status::UserError(
+        fmt::format(
+            "Bing tile zoom {} cannot be greater than max zoom {}",
+            zoom,
+            BingTileType::kBingTileMaxZoomLevel));
   }
   return Status::OK();
 }
@@ -69,11 +70,12 @@ struct BingTileFunction {
       if (reason.has_value()) {
         return Status::UserError(reason.value());
       } else {
-        return Status::UnknownError(fmt::format(
-            "Velox Error constructing BingTile from x {} y {} zoom {}; please report this.",
-            x,
-            y,
-            zoom));
+        return Status::UnknownError(
+            fmt::format(
+                "Velox Error constructing BingTile from x {} y {} zoom {}; please report this.",
+                x,
+                y,
+                zoom));
       }
     }
     result = tile;
@@ -165,10 +167,11 @@ struct BingTileParentFunction {
       const arg_type<BingTile>& tile,
       const arg_type<int32_t>& parentZoom) {
     if (FOLLY_UNLIKELY(parentZoom > BingTileType::kBingTileMaxZoomLevel)) {
-      return Status::UserError(fmt::format(
-          "newZoom {} is greater than max zoom {}",
-          parentZoom,
-          BingTileType::kBingTileMaxZoomLevel));
+      return Status::UserError(
+          fmt::format(
+              "newZoom {} is greater than max zoom {}",
+              parentZoom,
+              BingTileType::kBingTileMaxZoomLevel));
     }
     return call(result, tile, static_cast<int8_t>(parentZoom));
   }
diff --git a/velox/functions/prestosql/CMakeLists.txt b/velox/functions/prestosql/CMakeLists.txt
index 7a238964a7b..244b228663d 100644
--- a/velox/functions/prestosql/CMakeLists.txt
+++ b/velox/functions/prestosql/CMakeLists.txt
@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+add_subdirectory(coercion)
 add_subdirectory(json)
 add_subdirectory(types)
 add_subdirectory(window)
@@ -38,8 +39,8 @@ velox_add_library(
   JsonFunctions.cpp
   Map.cpp
   MapEntries.cpp
-  MapFromEntries.cpp
   MapKeysAndValues.cpp
+  MapSubset.cpp
   MapZipWith.cpp
   Not.cpp
   Reduce.cpp
@@ -47,23 +48,90 @@ velox_add_library(
   RowFunction.cpp
   Sequence.cpp
   SfmSketchFunctions.cpp
-  SimpleComparisonMatcher.cpp
   Split.cpp
   SplitToMap.cpp
   StringFunctions.cpp
   Subscript.cpp
   ToUtf8.cpp
   Transform.cpp
+  TransformWithIndex.cpp
   TransformKeys.cpp
   TransformValues.cpp
   TypeOf.cpp
   UpperLower.cpp
   URIParser.cpp
-  URLFunctions.cpp
   VectorArithmetic.cpp
   WidthBucketArray.cpp
   Zip.cpp
   ZipWith.cpp
+  HEADERS
+  Arithmetic.h
+  ArithmeticImpl.h
+  ArrayConstructor.h
+  ArrayFunctions.h
+  ArraySort.h
+  ArraySubset.h
+  BinaryFunctions.h
+  BingTileFunctions.h
+  Bitwise.h
+  Cardinality.h
+  Comparisons.h
+  DataSizeFunctions.h
+  DateTimeFunctions.h
+  DateTimeImpl.h
+  DecimalFunctions.h
+  DistanceFunctions.h
+  DotProduct.h
+  EnumFunctions.h
+  Fail.h
+  FloatingPointFunctions.h
+  GeometryFunctions.h
+  GreatestLeast.h
+  HyperLogLogFunctions.h
+  IPAddressFunctions.h
+  InPredicate.h
+  IntegerFunctions.h
+  JsonFunctions.h
+  KHyperLogLogFunctions.h
+  L2Norm.h
+  Map.h
+  MapAppend.h
+  MapExcept.h
+  MapFunctions.h
+  MapIntersect.h
+  MapKeysByTopNValues.h
+  MapKeysOverlap.h
+  MapNormalize.h
+  MapSubset.h
+  MapSubsetKeyInRange.h
+  MapTopN.h
+  MapTopNImpl.h
+  MapTopNKeys.h
+  MapTopNValues.h
+  MapTrimValues.h
+  MapUpdate.h
+  MapValuesInRange.h
+  MultimapFromEntries.h
+  Probability.h
+  QDigestFunctions.h
+  Rand.h
+  Reduce.h
+  RegexpReplace.h
+  RegexpSplit.h
+  RemapKeys.h
+  S2Functions.h
+  SetDigestFunctions.h
+  SfmSketchFunctions.h
+  SplitPart.h
+  SplitToMap.h
+  SplitToMultiMap.h
+  StringFunctions.h
+  TDigestFunctions.h
+  URIParser.h
+  URLFunctions.h
+  UuidFunctions.h
+  WidthBucketArray.h
+  WordStem.h
 )
 
 velox_link_libraries(
@@ -77,6 +145,7 @@ velox_link_libraries(
   velox_presto_types
   velox_functions_util
   Folly::folly
+  FastFloat::fast_float
   stemmer::stemmer
 )
 
@@ -87,7 +156,14 @@ endif()
 
 if(VELOX_ENABLE_GEO)
   add_subdirectory(geospatial)
-  velox_link_libraries(velox_functions_prestosql_impl velox_functions_geo)
+
+  # S2 cell operations are isolated in a separate library to prevent a
+  # nallocx symbol conflict between s2geometry's malloc_extension.h and
+  # folly's MallocImpl.h.
+  velox_add_library(velox_s2_cell_operations S2CellOperations.cpp HEADERS S2CellOperations.h)
+  velox_link_libraries(velox_s2_cell_operations s2::s2 GEOS::geos)
+
+  velox_link_libraries(velox_functions_prestosql_impl velox_functions_geo velox_s2_cell_operations)
 endif()
 
 if(NOT VELOX_MONO_LIBRARY)
diff --git a/velox/functions/prestosql/Cardinality.h b/velox/functions/prestosql/Cardinality.h
index 28fde43cae5..a1a29282377 100644
--- a/velox/functions/prestosql/Cardinality.h
+++ b/velox/functions/prestosql/Cardinality.h
@@ -19,16 +19,19 @@
 
 namespace facebook::velox::functions {
 
+/// Returns the number of elements in an array or map.
 template <typename T>
 struct CardinalityFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
-  void call(int64_t& out, const arg_type<Array<Generic<T1>>>& input) {
+  template <typename TReturn>
+  void call(TReturn& out, const arg_type<Array<Generic<T1>>>& input) {
     out = input.size();
   }
 
+  template <typename TReturn>
   void call(
-      int64_t& out,
+      TReturn& out,
       const arg_type<Map<Generic<T1>, Generic<T2>>>& input) {
     out = input.size();
   }
diff --git a/velox/functions/prestosql/Comparisons.cpp b/velox/functions/prestosql/Comparisons.cpp
index 89015f9f7f2..d89237b11ee 100644
--- a/velox/functions/prestosql/Comparisons.cpp
+++ b/velox/functions/prestosql/Comparisons.cpp
@@ -190,19 +190,21 @@ class ComparisonSimdFunction : public exec::VectorFunction {
              "interval day to second",
              "interval year to month",
          }) {
-      signatures.push_back(exec::FunctionSignatureBuilder()
-                               .returnType("boolean")
-                               .argumentType(inputType)
-                               .argumentType(inputType)
-                               .build());
+      signatures.push_back(
+          exec::FunctionSignatureBuilder()
+              .returnType("boolean")
+              .argumentType(inputType)
+              .argumentType(inputType)
+              .build());
     }
-    signatures.push_back(exec::FunctionSignatureBuilder()
-                             .integerVariable("a_precision")
-                             .integerVariable("a_scale")
-                             .returnType("boolean")
-                             .argumentType("DECIMAL(a_precision, a_scale)")
-                             .argumentType("DECIMAL(a_precision, a_scale)")
-                             .build());
+    signatures.push_back(
+        exec::FunctionSignatureBuilder()
+            .integerVariable("a_precision")
+            .integerVariable("a_scale")
+            .returnType("boolean")
+            .argumentType("DECIMAL(a_precision, a_scale)")
+            .argumentType("DECIMAL(a_precision, a_scale)")
+            .build());
     return signatures;
   }
 
diff --git a/velox/functions/prestosql/DataSizeFunctions.h b/velox/functions/prestosql/DataSizeFunctions.h
index 85c7bc9f1c2..881bb61bd18 100644
--- a/velox/functions/prestosql/DataSizeFunctions.h
+++ b/velox/functions/prestosql/DataSizeFunctions.h
@@ -35,8 +35,8 @@ enum class Unit : int128_t {
   YOTTABYTE = int128_t(1) << 80
 };
 
-inline Unit parseUnit(const std::string& dataSize, const size_t& valueLength) {
-  static const std::map<std::string, Unit> unitMap = {
+inline Unit parseUnit(std::string_view dataSize, size_t valueLength) {
+  static const std::map<std::string_view, Unit> unitMap = {
       {"B", Unit::BYTE},
       {"kB", Unit::KILOBYTE},
       {"MB", Unit::MEGABYTE},
@@ -45,9 +45,10 @@ inline Unit parseUnit(const std::string& dataSize, const size_t& valueLength) {
       {"PB", Unit::PETABYTE},
       {"EB", Unit::EXABYTE},
       {"ZB", Unit::ZETTABYTE},
-      {"YB", Unit::YOTTABYTE}};
+      {"YB", Unit::YOTTABYTE},
+  };
   try {
-    std::string unitString = dataSize.substr(valueLength);
+    std::string_view unitString = dataSize.substr(valueLength);
     auto it = unitMap.find(unitString);
     VELOX_USER_CHECK(it != unitMap.end(), "Invalid data size: '{}'", dataSize);
     return it->second;
@@ -55,18 +56,16 @@ inline Unit parseUnit(const std::string& dataSize, const size_t& valueLength) {
     VELOX_USER_FAIL("Invalid data size: '{}'", dataSize);
   }
 }
-inline double parseValue(
-    const std::string& dataSize,
-    const size_t& valueLength) {
+inline double parseValue(std::string_view dataSize, size_t valueLength) {
   try {
-    std::string value = dataSize.substr(0, valueLength);
-    return std::stod(value);
+    std::string_view value = dataSize.substr(0, valueLength);
+    return folly::to<double>(value);
   } catch (const std::exception&) {
     VELOX_USER_FAIL("Invalid data size: '{}'", dataSize);
   }
 }
 
-inline int128_t getDecimal(const std::string& dataSize) {
+inline int128_t getDecimal(std::string_view dataSize) {
   size_t valueLength = 0;
   while (valueLength < dataSize.length() &&
          (isdigit(dataSize[valueLength]) || dataSize[valueLength] == '.')) {
@@ -98,14 +97,16 @@ struct ParsePrestoDataSizeFunction {
   FOLLY_ALWAYS_INLINE void callAscii(
       out_type<LongDecimal<P1, S1>>& result,
       const arg_type<Varchar>& input) {
-    result = getDecimal(input);
+    // TODO: Remove explicit std::string_view cast.
+    result = getDecimal(std::string_view(input));
   }
   FOLLY_ALWAYS_INLINE void call(
       out_type<LongDecimal<P1, S1>>& result,
       const arg_type<Varchar>& input) {
     // If ASCII input process else fail.
     if (stringCore::isAscii(input.data(), input.size())) {
-      result = getDecimal(input);
+      // TODO: Remove explicit std::string_view cast.
+      result = getDecimal(std::string_view(input));
     } else {
       VELOX_USER_FAIL("Invalid data size: '{}'", input);
     }
diff --git a/velox/functions/prestosql/DateTimeFunctions.h b/velox/functions/prestosql/DateTimeFunctions.h
index 26d50a2c1ec..888585e5acd 100644
--- a/velox/functions/prestosql/DateTimeFunctions.h
+++ b/velox/functions/prestosql/DateTimeFunctions.h
@@ -15,17 +15,23 @@
  */
 #pragma once
 
-#define XXH_INLINE_ALL
-#include <boost/regex.hpp>
-#include <xxhash.h>
+#include <fast_float/fast_float.h>
+#include <re2/re2.h>
 #include <string_view>
+#include "velox/common/base/XxHashInline.h"
+#include "velox/expression/VectorFunction.h"
 #include "velox/functions/lib/DateTimeFormatter.h"
 #include "velox/functions/lib/TimeUtils.h"
 #include "velox/functions/prestosql/DateTimeImpl.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/type/Time.h"
 #include "velox/type/TimestampConversion.h"
 #include "velox/type/Type.h"
 #include "velox/type/tz/TimeZoneMap.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/ConstantVector.h"
+#include "velox/vector/FlatVector.h"
 
 namespace facebook::velox::functions {
 
@@ -96,8 +102,9 @@ struct FromUnixtimeFunction {
       const arg_type<double>& unixtime,
       const arg_type<int64_t>& hours,
       const arg_type<int64_t>& minutes) {
-    int16_t timezoneId = tzID_.value_or(tz::getTimeZoneID(
-        checkedPlus(checkedMultiply<int64_t>(hours, 60), minutes)));
+    int16_t timezoneId = tzID_.value_or(
+        tz::getTimeZoneID(
+            checkedPlus(checkedMultiply<int64_t>(hours, 60), minutes)));
     result = pack(fromUnixtime(unixtime).toMillis(), timezoneId);
   }
 
@@ -533,6 +540,137 @@ struct TimestampPlusInterval {
   const tz::TimeZone* sessionTimeZone_ = nullptr;
 };
 
+template <typename T>
+struct TimePlusInterval {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Time>& result,
+      const arg_type<Time>& time,
+      const arg_type<IntervalDayTime>& interval) {
+    result = addToTime(time, interval);
+  }
+};
+
+template <typename T>
+struct TimeMinusInterval {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Time>& result,
+      const arg_type<Time>& time,
+      const arg_type<IntervalDayTime>& interval) {
+    result = addToTime(time, -interval);
+  }
+};
+
+template <typename T>
+struct TimeMinusFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<IntervalDayTime>& result,
+      const arg_type<Time>& a,
+      const arg_type<Time>& b) {
+    // Validate inputs are in valid TIME range [0, 86400000)
+    VELOX_USER_CHECK(
+        a >= 0 && a < kMillisInDay,
+        "TIME value {} is out of range [0, 86400000)",
+        a);
+    VELOX_USER_CHECK(
+        b >= 0 && b < kMillisInDay,
+        "TIME value {} is out of range [0, 86400000)",
+        b);
+
+    // Simple subtraction returns interval in milliseconds
+    result = a - b;
+  }
+};
+
+// Optimized vector function for Time +/- IntervalYearMonth
+// This case is special because result = time (identity function), allowing
+// for significant optimizations.
+// For plus: supports both (time, interval) and (interval, time)
+// For minus: only supports (time, interval) - not (interval, time)
+class TimeIntervalYearMonthVectorFunction : public exec::VectorFunction {
+ public:
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& outputType,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    VectorPtr& timeVector = args[0]->type()->isTime() ? args[0] : args[1];
+    VELOX_DCHECK(timeVector->type()->equivalent(*TIME()));
+
+    // Constant vector case
+    // If time input is constant, create constant result - no iteration!
+    if (timeVector->isConstantEncoding()) {
+      auto constantTime = timeVector->as<ConstantVector<int64_t>>();
+      if (constantTime->isNullAt(0)) {
+        result = BaseVector::createNullConstant(
+            outputType, rows.size(), context.pool());
+      } else {
+        auto value = constantTime->valueAt(0);
+        result = BaseVector::createConstant(
+            outputType, value, rows.size(), context.pool());
+      }
+      return;
+    }
+
+    // Single reference case
+    // If input vector is singly referenced, reuse it directly - zero copy!
+    if (!result && BaseVector::isVectorWritable(timeVector)) {
+      result = std::move(timeVector); // Move input to result - zero copy!
+      return;
+    }
+
+    // FALLBACK: Standard processing for other cases
+    context.ensureWritable(rows, outputType, result);
+    auto* flatResult = result->asFlatVector<int64_t>();
+    // Fast path for flat vectors - use FlatVector::copy for efficient copying
+    flatResult->copy(timeVector.get(), rows, nullptr);
+  }
+
+  static std::vector<std::shared_ptr<exec::FunctionSignature>>
+  signaturesPlus() {
+    return {
+        // Signature 1: (time, interval year to month) -> time
+        exec::FunctionSignatureBuilder()
+            .returnType("time")
+            .argumentType("time")
+            .argumentType("interval year to month")
+            .build(),
+        // Signature 2: (interval year to month, time) -> time
+        exec::FunctionSignatureBuilder()
+            .returnType("time")
+            .argumentType("interval year to month")
+            .argumentType("time")
+            .build()};
+  }
+
+  static std::vector<std::shared_ptr<exec::FunctionSignature>>
+  signaturesMinus() {
+    return {// Only support: (time, interval year to month) -> time
+            exec::FunctionSignatureBuilder()
+                .returnType("time")
+                .argumentType("time")
+                .argumentType("interval year to month")
+                .build()};
+  }
+};
+
+template <typename T>
+struct IntervalPlusTime {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Time>& result,
+      const arg_type<IntervalDayTime>& interval,
+      const arg_type<Time>& time) {
+    result = addToTime(time, interval);
+  }
+};
+
 template <typename T>
 struct IntervalPlusTimestamp {
   VELOX_DEFINE_FUNCTION_TYPES(T);
@@ -764,6 +902,16 @@ struct HourFunction : public InitSessionTimezone<T>,
     auto timestamp = this->toTimestamp(timestampWithTimezone);
     result = getDateTime(timestamp, nullptr).tm_hour;
   }
+
+  FOLLY_ALWAYS_INLINE void call(int64_t& result, const arg_type<Time>& time) {
+    VELOX_USER_CHECK(
+        time >= 0 && time < kMillisInDay,
+        "TIME value {} is out of range [0, 86400000)",
+        time);
+    result = std::chrono::duration_cast<std::chrono::hours>(
+                 std::chrono::milliseconds(time))
+                 .count();
+  }
 };
 
 template <typename T>
@@ -798,6 +946,16 @@ struct MinuteFunction : public InitSessionTimezone<T>,
     auto timestamp = this->toTimestamp(timestampWithTimezone);
     result = getDateTime(timestamp, nullptr).tm_min;
   }
+
+  FOLLY_ALWAYS_INLINE void call(int64_t& result, const arg_type<Time>& time) {
+    VELOX_USER_CHECK(
+        time >= 0 && time < kMillisInDay,
+        "TIME value {} is out of valid range [0, 86399999]",
+        time);
+    auto duration = std::chrono::milliseconds(time);
+    auto minutes = std::chrono::duration_cast<std::chrono::minutes>(duration);
+    result = minutes.count() % kMinutesInHour;
+  }
 };
 
 template <typename T>
@@ -831,6 +989,16 @@ struct SecondFunction : public TimestampWithTimezoneSupport<T> {
     auto timestamp = this->toTimestamp(timestampWithTimezone);
     result = getDateTime(timestamp, nullptr).tm_sec;
   }
+
+  FOLLY_ALWAYS_INLINE void call(int64_t& result, const arg_type<Time>& time) {
+    VELOX_USER_CHECK(
+        time >= 0 && time < kMillisInDay,
+        "TIME value {} is out of range [0, 86400000)",
+        time);
+    auto duration = std::chrono::milliseconds(time);
+    auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration);
+    result = seconds.count() % kSecondsInMinute;
+  }
 };
 
 template <typename T>
@@ -867,6 +1035,15 @@ struct MillisecondFunction : public TimestampWithTimezoneSupport<T> {
     auto timestamp = this->toTimestamp(timestampWithTimezone);
     result = timestamp.getNanos() / Timestamp::kNanosecondsInMillisecond;
   }
+
+  FOLLY_ALWAYS_INLINE void call(int64_t& result, const arg_type<Time>& time) {
+    VELOX_USER_CHECK(
+        time >= 0 && time < kMillisInDay,
+        "TIME value {} is out of range [0, 86400000)",
+        time);
+    auto time_duration = std::chrono::milliseconds(time);
+    result = (time_duration % std::chrono::seconds(1)).count();
+  }
 };
 
 template <typename T>
@@ -913,6 +1090,35 @@ inline std::optional<DateTimeUnit> getTimestampUnit(
   return unit;
 }
 
+inline std::optional<DateTimeUnit> getTimeUnit(
+    const StringView& unitString,
+    bool throwIfInvalid = true) {
+  std::optional<DateTimeUnit> unit =
+      fromDateTimeUnitString(unitString, /*throwIfInvalid=*/false);
+
+  // Presto does not support microseconds for TIME type operations.
+  // Only millisecond, second, minute, and hour are valid TIME fields.
+  // See: presto-main-base/.../DateTimeFunctions.java:getTimeField()
+  if (unit.has_value() && isTimeUnit(unit.value()) &&
+      unit.value() != DateTimeUnit::kMicrosecond) {
+    return unit;
+  }
+
+  if (throwIfInvalid) {
+    VELOX_USER_FAIL("{} is not a valid TIME field", unitString);
+  }
+  return std::nullopt;
+}
+
+inline void checkValueInInt32Range(int64_t value) {
+  if (value != static_cast<int32_t>(value)) {
+    VELOX_UNSUPPORTED(
+        "Value should be in range [{}, {}]",
+        std::numeric_limits<int32_t>::min(),
+        std::numeric_limits<int32_t>::max());
+  }
+}
+
 } // namespace
 
 template <typename T>
@@ -954,6 +1160,16 @@ struct DateTruncFunction : public TimestampWithTimezoneSupport<T> {
     }
   }
 
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      const arg_type<Varchar>* unitString,
+      const arg_type<Time>* /*time*/) {
+    if (unitString != nullptr) {
+      unit_ = getTimeUnit(*unitString);
+    }
+  }
+
   FOLLY_ALWAYS_INLINE void call(
       out_type<Timestamp>& result,
       const arg_type<Varchar>& unitString,
@@ -1035,6 +1251,19 @@ struct DateTruncFunction : public TimestampWithTimezoneSupport<T> {
 
     result = pack(resultMillis, unpackZoneKeyId(*timestampWithTimezone));
   }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Time>& result,
+      const arg_type<Varchar>& unitString,
+      const arg_type<Time>& time) {
+    DateTimeUnit unit;
+    if (unit_.has_value()) {
+      unit = unit_.value();
+    } else {
+      unit = getTimeUnit(unitString).value();
+    }
+    result = truncateTime(time, unit);
+  }
 };
 
 template <typename T>
@@ -1052,7 +1281,7 @@ struct DateAddFunction : public TimestampWithTimezoneSupport<T> {
       const arg_type<Timestamp>* /*timestamp*/) {
     sessionTimeZone_ = getTimeZoneFromConfig(config);
     if (unitString != nullptr) {
-      unit_ = fromDateTimeUnitString(*unitString, /*throwIfInvalid=*/false);
+      unit_ = fromDateTimeUnitString(*unitString, /*throwIfInvalid=*/true);
     }
   }
 
@@ -1067,6 +1296,17 @@ struct DateAddFunction : public TimestampWithTimezoneSupport<T> {
     }
   }
 
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      const arg_type<Varchar>* unitString,
+      const int64_t* /*value*/,
+      const arg_type<Time>* /*time*/) {
+    if (unitString != nullptr) {
+      unit_ = getTimeUnit(*unitString, /*throwIfInvalid=*/true);
+    }
+  }
+
   FOLLY_ALWAYS_INLINE void call(
       out_type<Timestamp>& result,
       const arg_type<Varchar>& unitString,
@@ -1076,10 +1316,9 @@ struct DateAddFunction : public TimestampWithTimezoneSupport<T> {
         ? unit_.value()
         : fromDateTimeUnitString(unitString, /*throwIfInvalid=*/true).value();
 
-    if (value != (int32_t)value) {
-      VELOX_UNSUPPORTED("integer overflow");
-    }
-    result = addToTimestamp(unit, (int32_t)value, timestamp, sessionTimeZone_);
+    checkValueInInt32Range(value);
+    result = addToTimestamp(
+        unit, static_cast<int32_t>(value), timestamp, sessionTimeZone_);
   }
 
   FOLLY_ALWAYS_INLINE void call(
@@ -1090,12 +1329,10 @@ struct DateAddFunction : public TimestampWithTimezoneSupport<T> {
     const auto unit = unit_.value_or(
         fromDateTimeUnitString(unitString, /*throwIfInvalid=*/true).value());
 
-    if (value != (int32_t)value) {
-      VELOX_UNSUPPORTED("integer overflow");
-    }
+    checkValueInInt32Range(value);
 
     result = addToTimestampWithTimezone(
-        *timestampWithTimezone, unit, (int32_t)value);
+        *timestampWithTimezone, unit, static_cast<int32_t>(value));
   }
 
   FOLLY_ALWAYS_INLINE void call(
@@ -1107,11 +1344,26 @@ struct DateAddFunction : public TimestampWithTimezoneSupport<T> {
         ? unit_.value()
         : getDateUnit(unitString, true).value();
 
-    if (value != (int32_t)value) {
-      VELOX_UNSUPPORTED("integer overflow");
+    checkValueInInt32Range(value);
+
+    result = addToDate(date, unit, static_cast<int32_t>(value));
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Time>& result,
+      const arg_type<Varchar>& unitString,
+      const int64_t value,
+      const arg_type<Time>& time) {
+    DateTimeUnit unit;
+    if (unit_.has_value()) {
+      unit = unit_.value();
+    } else {
+      unit = getTimeUnit(unitString, /*throwIfInvalid=*/true).value();
     }
 
-    result = addToDate(date, unit, (int32_t)value);
+    checkValueInInt32Range(value);
+
+    result = addToTime(unit, static_cast<int32_t>(value), time);
   }
 };
 
@@ -1129,7 +1381,7 @@ struct DateDiffFunction : public TimestampWithTimezoneSupport<T> {
       const arg_type<Timestamp>* /*timestamp1*/,
       const arg_type<Timestamp>* /*timestamp2*/) {
     if (unitString != nullptr) {
-      unit_ = fromDateTimeUnitString(*unitString, /*throwIfInvalid=*/false);
+      unit_ = fromDateTimeUnitString(*unitString, /*throwIfInvalid=*/true);
     }
 
     sessionTimeZone_ = getTimeZoneFromConfig(config);
@@ -1153,7 +1405,18 @@ struct DateDiffFunction : public TimestampWithTimezoneSupport<T> {
       const arg_type<TimestampWithTimezone>* /*timestampWithTimezone1*/,
       const arg_type<TimestampWithTimezone>* /*timestampWithTimezone2*/) {
     if (unitString != nullptr) {
-      unit_ = fromDateTimeUnitString(*unitString, /*throwIfInvalid=*/false);
+      unit_ = fromDateTimeUnitString(*unitString, /*throwIfInvalid=*/true);
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      const arg_type<Varchar>* unitString,
+      const arg_type<Time>* /*time1*/,
+      const arg_type<Time>* /*time2*/) {
+    if (unitString != nullptr) {
+      unit_ = getTimeUnit(*unitString, /*throwIfInvalid=*/true);
     }
   }
 
@@ -1197,6 +1460,21 @@ struct DateDiffFunction : public TimestampWithTimezoneSupport<T> {
         *timestampWithTz1,
         pack(unpackMillisUtc(*timestampWithTz2), timeZoneId));
   }
+
+  FOLLY_ALWAYS_INLINE void call(
+      int64_t& result,
+      const arg_type<Varchar>& unitString,
+      const arg_type<Time>& time1,
+      const arg_type<Time>& time2) {
+    DateTimeUnit unit;
+    if (unit_.has_value()) {
+      unit = unit_.value();
+    } else {
+      unit = getTimeUnit(unitString, /*throwIfInvalid=*/true).value();
+    }
+
+    result = diffTime(unit, time1, time2);
+  }
 };
 
 template <typename T>
@@ -1528,6 +1806,44 @@ struct CurrentDateFunction {
   }
 };
 
+template <typename T>
+struct CurrentTimezoneFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+  std::string tzName_;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>&,
+      const core::QueryConfig& config) {
+    tzName_ = config.sessionTimezone();
+  }
+  FOLLY_ALWAYS_INLINE void call(out_type<Varchar>& result) {
+    result = std::string_view(tzName_);
+  }
+};
+
+template <typename T>
+struct CurrentTimestampFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  int64_t result_{0};
+  const tz::TimeZone* timeZone_ = nullptr;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /* type */,
+      const core::QueryConfig& config) {
+    Timestamp ts = Timestamp::fromMillis(config.sessionStartTimeMs());
+    timeZone_ = getTimeZoneFromConfig(config);
+    if (timeZone_ == nullptr) {
+      VELOX_USER_FAIL("Timezone cannot be null");
+    }
+    result_ = pack(ts, timeZone_->id());
+  }
+
+  FOLLY_ALWAYS_INLINE void call(out_type<TimestampWithTimezone>& result) {
+    result = result_;
+  }
+};
+
 template <typename T>
 struct TimeZoneHourFunction : public TimestampWithTimezoneSupport<T> {
   VELOX_DEFINE_FUNCTION_TYPES(T);
@@ -1649,6 +1965,40 @@ struct AtTimezoneFunction : public TimestampWithTimezoneSupport<T> {
   }
 };
 
+template <typename T>
+struct AtTimezoneTimeWithTimezoneFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<TimeWithTimezone>& result,
+      const arg_type<TimeWithTimezone>& timeWithTz,
+      const arg_type<Varchar>& targetTimezone) {
+    // Extract milliseconds UTC from the input
+    auto millisUtc = util::unpackMillisUtc(*timeWithTz);
+
+    // Parse the target timezone offset from the VARCHAR string
+    auto offsetResult = util::parseTimezoneOffset(
+        targetTimezone.data(),
+        targetTimezone.size(),
+        /*allowCompactFormat*/ false);
+    if (offsetResult.hasError()) {
+      if (offsetResult.error().isUserError()) {
+        VELOX_USER_FAIL(offsetResult.error().message());
+      } else {
+        VELOX_FAIL(offsetResult.error().message());
+      }
+    }
+
+    auto targetOffsetMinutes = offsetResult.value();
+
+    // Encode the timezone offset using bias encoding
+    auto encodedOffset = util::biasEncode(targetOffsetMinutes);
+
+    // Pack and return the result with the same UTC time but new timezone
+    result = util::pack(millisUtc, encodedOffset);
+  }
+};
+
 template <typename TExec>
 struct ToMillisecondFunction {
   VELOX_DEFINE_FUNCTION_TYPES(TExec);
@@ -1688,48 +2038,132 @@ struct XxHash64TimestampFunction {
   }
 };
 
+/// xxhash64(Time) → bigint
+/// Return a xxhash64 of input Time
 template <typename T>
-struct ParseDurationFunction {
+struct XxHash64TimeFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
-  std::unique_ptr<boost::regex> durationRegex_;
-
-  FOLLY_ALWAYS_INLINE void initialize(
-      const std::vector<TypePtr>& /*inputTypes*/,
-      const core::QueryConfig& /*config*/,
-      const arg_type<Varchar>* /*amountUnit*/) {
-    durationRegex_ = std::make_unique<boost::regex>(
-        "^\\s*(\\d+(?:\\.\\d+)?)\\s*([a-zA-Z]+)\\s*$");
+  FOLLY_ALWAYS_INLINE
+  void call(out_type<int64_t>& result, const arg_type<Time>& input) {
+    // TIME is represented as milliseconds since midnight
+    // Convert to big-endian to match Presto's xxhash64 behavior
+    auto bigEndianValue = folly::Endian::big(input);
+    result = XXH64(&bigEndianValue, sizeof(bigEndianValue), 0);
   }
+};
+
+template <typename T>
+struct ParseDurationFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
 
   FOLLY_ALWAYS_INLINE void call(
       out_type<IntervalDayTime>& result,
       const arg_type<Varchar>& amountUnit) {
-    std::string strAmountUnit = (std::string)amountUnit;
-    boost::smatch match;
-    bool isMatch = boost::regex_search(strAmountUnit, match, *durationRegex_);
-    if (!isMatch) {
+    static const LazyRE2 kDurationRegex{
+        .pattern_ = R"(^\s*(\d+(?:\.\d+)?)\s*([a-zA-Z]+)\s*$)",
+        .options_ = {},
+    };
+    // TODO: Remove re2::StringPiece != std::string_view hacks.
+    // It's needed because for some systems in CI,
+    // re2 and abseil libraries are old.
+    re2::StringPiece valueStr;
+    re2::StringPiece unitStr;
+    re2::StringPiece amountUnitStr{amountUnit.data(), amountUnit.size()};
+    if (!RE2::FullMatch(amountUnitStr, *kDurationRegex, &valueStr, &unitStr)) {
       VELOX_USER_FAIL(
-          "Input duration is not a valid data duration string: {}", amountUnit);
+          "Input duration is not a valid data duration string: {}",
+          std::string_view(amountUnitStr.data(), amountUnitStr.size()));
     }
-    VELOX_USER_CHECK_EQ(
-        match.size(),
-        3,
-        "Input duration does not have value and unit components only: {}",
-        amountUnit);
-    try {
-      double value = std::stod(match[1].str());
-      std::string unit = match[2].str();
-      result = valueOfTimeUnitToMillis(value, unit);
-    } catch (std::out_of_range&) {
+
+    double value{};
+    auto [_, error] = fast_float::from_chars(
+        valueStr.data(), valueStr.data() + valueStr.size(), value);
+    if (error == std::errc::result_out_of_range) {
       VELOX_USER_FAIL(
           "Input duration value is out of range for double: {}",
-          match[1].str());
-    } catch (std::invalid_argument&) {
+          std::string_view(valueStr.data(), valueStr.size()));
+    } else if (error != std::errc{}) {
       VELOX_USER_FAIL(
-          "Input duration value is not a valid number: {}", match[1].str());
+          "Input duration value is not a valid number: {}",
+          std::string_view(valueStr.data(), valueStr.size()));
     }
+
+    result = valueOfTimeUnitToMillis(value, {unitStr.data(), unitStr.size()});
+  }
+};
+
+template <typename T>
+struct LocalTimeFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config) {
+    auto sessionStartTimeMs = config.sessionStartTimeMs();
+    localTimeSinceMidnight_ = sessionStartTimeMs % kMillisInDay;
+  }
+
+  // LocalTime just returns the time from midnight in UTC.
+  FOLLY_ALWAYS_INLINE void call(out_type<Time>& result) {
+    result = localTimeSinceMidnight_;
+  }
+
+ private:
+  int64_t localTimeSinceMidnight_;
+};
+
+template <typename T>
+struct LocalTimestampFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config) {
+    ts_ = Timestamp::fromMillis(config.sessionStartTimeMs());
   }
+
+  FOLLY_ALWAYS_INLINE void call(out_type<Timestamp>& result) {
+    result = ts_;
+  }
+
+ private:
+  Timestamp ts_;
+};
+
+template <typename T>
+struct CurrentTimeFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /* type */,
+      const core::QueryConfig& config) {
+    const tz::TimeZone* timeZone = getTimeZoneFromConfig(config);
+    // Java/Presto session always provides a timezone (TimeZoneKey is required).
+    VELOX_CHECK_NOT_NULL(timeZone);
+
+    auto sessionStartTimeMs = config.sessionStartTimeMs();
+
+    auto localMillis =
+        timeZone->to_local(std::chrono::milliseconds{sessionStartTimeMs});
+    auto localMillisSinceMidnight =
+        localMillis - std::chrono::floor<std::chrono::days>(localMillis);
+
+    auto currentOffset = localMillis.count() - sessionStartTimeMs;
+    // Safe since timezone offsets are bounded [-840, 840] minutes
+    auto currentOffsetMinutes =
+        static_cast<int16_t>(currentOffset / (60 * 1000));
+
+    auto encodedOffset = util::biasEncode(currentOffsetMinutes);
+    currentTime_ = util::pack(localMillisSinceMidnight.count(), encodedOffset);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(out_type<TimeWithTimezone>& result) {
+    result = currentTime_;
+  }
+
+ private:
+  int64_t currentTime_{0};
 };
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/DateTimeImpl.h b/velox/functions/prestosql/DateTimeImpl.h
index 76798bfe30f..ce4aa53a008 100644
--- a/velox/functions/prestosql/DateTimeImpl.h
+++ b/velox/functions/prestosql/DateTimeImpl.h
@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include "velox/common/base/CheckedArithmetic.h"
 #include "velox/common/base/Doubles.h"
 #include "velox/functions/lib/DateTimeFormatter.h"
 #include "velox/functions/lib/DateTimeUtil.h"
@@ -61,9 +62,7 @@ FOLLY_ALWAYS_INLINE Timestamp fromUnixtime(double unixtime) {
       seconds, milliseconds * Timestamp::kNanosecondsInMillisecond);
 }
 
-FOLLY_ALWAYS_INLINE boost::int64_t fromUnixtime(
-    double unixtime,
-    int16_t timeZoneId) {
+FOLLY_ALWAYS_INLINE int64_t fromUnixtime(double unixtime, int16_t timeZoneId) {
   if (FOLLY_UNLIKELY(std::isnan(unixtime))) {
     return pack(0, timeZoneId);
   }
@@ -123,11 +122,12 @@ FOLLY_ALWAYS_INLINE int64_t addToTimestampWithTimezone(
       // results if we use local time.
       const tz::TimeZone* timeZone =
           tz::locateZone(unpackZoneKeyId(timestampWithTimezone));
-      auto originalTimestamp =
-          Timestamp::fromMillis(timeZone
-                                    ->to_local(std::chrono::milliseconds(
-                                        unpackMillisUtc(timestampWithTimezone)))
-                                    .count());
+      auto originalTimestamp = Timestamp::fromMillis(
+          timeZone
+              ->to_local(
+                  std::chrono::milliseconds(
+                      unpackMillisUtc(timestampWithTimezone)))
+              .count());
       auto updatedTimeStamp =
           addToTimestamp(originalTimestamp, unit, (int32_t)value);
       updatedTimeStamp = Timestamp(
@@ -172,34 +172,88 @@ FOLLY_ALWAYS_INLINE int64_t diffTimestampWithTimeZone(
     // doesn't affect time units less than a day, and will produce incorrect
     // results if we use local time.
     const tz::TimeZone* timeZone = tz::locateZone(fromTimeZoneId);
-    fromTimestamp = Timestamp::fromMillis(
-        timeZone
-            ->to_local(std::chrono::milliseconds(
-                unpackMillisUtc(fromTimestampWithTimeZone)))
-            .count());
+    fromTimestamp =
+        Timestamp::fromMillis(timeZone
+                                  ->to_local(
+                                      std::chrono::milliseconds(unpackMillisUtc(
+                                          fromTimestampWithTimeZone)))
+                                  .count());
     toTimestamp =
         Timestamp::fromMillis(timeZone
-                                  ->to_local(std::chrono::milliseconds(
-                                      unpackMillisUtc(toTimestampWithTimeZone)))
+                                  ->to_local(
+                                      std::chrono::milliseconds(unpackMillisUtc(
+                                          toTimestampWithTimeZone)))
                                   .count());
   }
 
   return diffTimestamp(unit, fromTimestamp, toTimestamp);
 }
 
+// diffDate is defined in velox/functions/lib/DateTimeUtil.h
+
 FOLLY_ALWAYS_INLINE
-int64_t diffDate(
+int64_t diffTime(
     const DateTimeUnit unit,
-    const int32_t fromDate,
-    const int32_t toDate) {
-  if (fromDate == toDate) {
+    const int64_t fromTime,
+    const int64_t toTime) {
+  // Validate time inputs are in valid range [0, 86400000)
+  VELOX_USER_CHECK(
+      fromTime >= 0 && fromTime < kMillisInDay,
+      "from TIME value {} is out of range [0, 86400000)",
+      fromTime);
+  VELOX_USER_CHECK(
+      toTime >= 0 && toTime < kMillisInDay,
+      "to TIME value {} is out of range [0, 86400000)",
+      toTime);
+
+  if (fromTime == toTime) {
     return 0;
   }
-  return diffTimestamp(
-      unit,
-      // prevent overflow
-      Timestamp((int64_t)fromDate * util::kSecsPerDay, 0),
-      Timestamp((int64_t)toDate * util::kSecsPerDay, 0));
+
+  // Use std::chrono for safe duration arithmetic
+  const auto fromDuration = std::chrono::milliseconds(fromTime);
+  const auto toDuration = std::chrono::milliseconds(toTime);
+  const auto diff = toDuration - fromDuration;
+
+  switch (unit) {
+    case DateTimeUnit::kMillisecond:
+      return diff.count();
+    case DateTimeUnit::kSecond:
+      return std::chrono::duration_cast<std::chrono::seconds>(diff).count();
+    case DateTimeUnit::kMinute:
+      return std::chrono::duration_cast<std::chrono::minutes>(diff).count();
+    case DateTimeUnit::kHour:
+      return std::chrono::duration_cast<std::chrono::hours>(diff).count();
+    default:
+      VELOX_USER_FAIL("Unsupported time unit for TIME type");
+  }
+}
+
+FOLLY_ALWAYS_INLINE int64_t
+addToTime(const DateTimeUnit unit, const int32_t value, const int64_t time) {
+  if (value == 0) {
+    return time;
+  }
+
+  int64_t valueInMillis;
+  switch (unit) {
+    case DateTimeUnit::kMillisecond:
+      valueInMillis = value;
+      break;
+    case DateTimeUnit::kSecond:
+      valueInMillis = checkedMultiply<int64_t>(value, kMillisInSecond);
+      break;
+    case DateTimeUnit::kMinute:
+      valueInMillis = checkedMultiply<int64_t>(value, kMillisInMinute);
+      break;
+    case DateTimeUnit::kHour:
+      valueInMillis = checkedMultiply<int64_t>(value, kMillisInHour);
+      break;
+    default:
+      VELOX_USER_FAIL("Unsupported time unit for TIME type");
+  }
+
+  return addToTime(time, valueInMillis);
 }
 
 FOLLY_ALWAYS_INLINE int64_t
diff --git a/velox/functions/prestosql/DecimalFunctions.cpp b/velox/functions/prestosql/DecimalFunctions.cpp
index 283d5e7ad9f..4c4400707fd 100644
--- a/velox/functions/prestosql/DecimalFunctions.cpp
+++ b/velox/functions/prestosql/DecimalFunctions.cpp
@@ -278,8 +278,7 @@ struct DecimalFloorFunction {
   template <typename R, typename A>
   void call(R& out, const A& a) {
     const auto rescaleFactor = DecimalUtil::kPowersOfTen[scale_];
-    // Function interpretation is the same as ceil for negative numbers, and as
-    // floor for positive numbers.
+    // Round rowards -INF.
     const auto increment = (a % rescaleFactor) < 0 ? -1 : 0;
     out = a / rescaleFactor + increment;
   }
@@ -288,6 +287,30 @@ struct DecimalFloorFunction {
   uint8_t scale_;
 };
 
+template <typename TExec>
+struct DecimalCeilFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename A>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      A* /*a*/) {
+    scale_ = getDecimalPrecisionScale(*inputTypes[0]).second;
+  }
+
+  template <typename R, typename A>
+  void call(R& out, const A& a) {
+    const auto rescaleFactor = DecimalUtil::kPowersOfTen[scale_];
+    // Round towards +INF.
+    const auto increment = (a % rescaleFactor) > 0 ? 1 : 0;
+    out = a / rescaleFactor + increment;
+  }
+
+ private:
+  uint8_t scale_;
+};
+
 template <typename TExec>
 struct DecimalTruncateFunction {
   VELOX_DEFINE_FUNCTION_TYPES(TExec);
@@ -532,7 +555,10 @@ void registerDecimalModulus(const std::string& prefix) {
       LongDecimal<P2, S2>>({prefix + "mod"}, constraints);
 }
 
-void registerDecimalFloor(const std::string& prefix) {
+template <template <class> typename TFunc>
+void registerDecimalFloorOrCeil(
+    const std::string& prefix,
+    const std::string& functionName) {
   std::vector<exec::SignatureVariable> constraints = {
       exec::SignatureVariable(
           P2::name(),
@@ -545,20 +571,22 @@ void registerDecimalFloor(const std::string& prefix) {
           S2::name(), "0", exec::ParameterType::kIntegerParameter),
   };
 
-  registerFunction<
-      DecimalFloorFunction,
-      LongDecimal<P2, S2>,
-      LongDecimal<P1, S1>>({prefix + "floor"}, constraints);
+  registerFunction<TFunc, LongDecimal<P2, S2>, LongDecimal<P1, S1>>(
+      {prefix + functionName}, constraints);
 
-  registerFunction<
-      DecimalFloorFunction,
-      ShortDecimal<P2, S2>,
-      LongDecimal<P1, S1>>({prefix + "floor"}, constraints);
+  registerFunction<TFunc, ShortDecimal<P2, S2>, LongDecimal<P1, S1>>(
+      {prefix + functionName}, constraints);
 
-  registerFunction<
-      DecimalFloorFunction,
-      ShortDecimal<P2, S2>,
-      ShortDecimal<P1, S1>>({prefix + "floor"}, constraints);
+  registerFunction<TFunc, ShortDecimal<P2, S2>, ShortDecimal<P1, S1>>(
+      {prefix + functionName}, constraints);
+}
+
+void registerDecimalFloor(const std::string& prefix) {
+  registerDecimalFloorOrCeil<DecimalFloorFunction>(prefix, "floor");
+}
+
+void registerDecimalCeil(const std::string& prefix) {
+  registerDecimalFloorOrCeil<DecimalCeilFunction>(prefix, "ceil");
 }
 
 void registerDecimalRound(const std::string& prefix) {
diff --git a/velox/functions/prestosql/DecimalFunctions.h b/velox/functions/prestosql/DecimalFunctions.h
index 651a0cd6b56..f590852c93f 100644
--- a/velox/functions/prestosql/DecimalFunctions.h
+++ b/velox/functions/prestosql/DecimalFunctions.h
@@ -31,6 +31,8 @@ void registerDecimalModulus(const std::string& prefix);
 
 void registerDecimalFloor(const std::string& prefix);
 
+void registerDecimalCeil(const std::string& prefix);
+
 void registerDecimalRound(const std::string& prefix);
 
 void registerDecimalTruncate(const std::string& prefix);
diff --git a/velox/functions/prestosql/DistanceFunctions.h b/velox/functions/prestosql/DistanceFunctions.h
index 00f1c15acd7..db6a5141444 100644
--- a/velox/functions/prestosql/DistanceFunctions.h
+++ b/velox/functions/prestosql/DistanceFunctions.h
@@ -17,6 +17,8 @@
 
 #include <limits>
 #include <vector>
+#include "velox/functions/Macros.h"
+#include "velox/functions/Registerer.h"
 
 #ifdef VELOX_ENABLE_FAISS
 #include "faiss/utils/distances.h"
diff --git a/velox/functions/prestosql/DotProduct.h b/velox/functions/prestosql/DotProduct.h
new file mode 100644
index 00000000000..57c4258faf2
--- /dev/null
+++ b/velox/functions/prestosql/DotProduct.h
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cstdint>
+
+#include <folly/CPortability.h>
+#include <folly/container/F14Map.h>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/functions/Macros.h"
+#include "velox/functions/lib/CheckedArithmetic.h"
+#include "velox/type/SimpleFunctionApi.h"
+
+namespace facebook::velox::functions {
+
+/// Computes the dot product of two arrays.
+/// The dot product is the sum of element-wise products of corresponding
+/// elements. Both arrays must have the same length. If either array is null,
+/// returns null. If arrays have different lengths, throws an error.
+/// Null elements in arrays are treated as zero.
+/// NaN values propagate through the computation (IEEE 754 behavior).
+template <typename TExec, typename T>
+struct DotProductFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename TOutput>
+  FOLLY_ALWAYS_INLINE void call(
+      TOutput& out,
+      const arg_type<Array<T>>& array1,
+      const arg_type<Array<T>>& array2) {
+    const auto size1 = array1.size();
+    const auto size2 = array2.size();
+
+    VELOX_USER_CHECK_EQ(
+        size1,
+        size2,
+        "dot_product requires arrays of equal length, but got {} and {}",
+        size1,
+        size2);
+
+    TOutput sum = 0;
+    for (vector_size_t i = 0; i < size1; ++i) {
+      const auto& val1 = array1[i];
+      const auto& val2 = array2[i];
+
+      if (val1.has_value() && val2.has_value()) {
+        if constexpr (std::is_same_v<TOutput, int64_t>) {
+          auto product = checkedMultiply<TOutput>(
+              static_cast<TOutput>(val1.value()),
+              static_cast<TOutput>(val2.value()));
+          sum = checkedPlus<TOutput>(sum, product);
+        } else {
+          sum += static_cast<TOutput>(val1.value()) *
+              static_cast<TOutput>(val2.value());
+        }
+      }
+    }
+    out = sum;
+  }
+};
+
+/// Computes the dot product of two maps.
+/// For maps, the dot product is computed by multiplying values with matching
+/// keys and summing the results. Keys present in only one map contribute zero
+/// to the result. If either map is null, returns null.
+/// Null values in maps are treated as zero.
+template <typename TExec, typename K, typename V>
+struct MapDotProductFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename TOutput>
+  FOLLY_ALWAYS_INLINE void call(
+      TOutput& out,
+      const arg_type<Map<K, V>>& map1,
+      const arg_type<Map<K, V>>& map2) {
+    TOutput sum = 0;
+
+    // Build a lookup map from the smaller map for O(1) key lookup.
+    // This reduces complexity from O(n*m) to O(n+m).
+    const auto& smallMap = map1.size() <= map2.size() ? map1 : map2;
+    const auto& largeMap = map1.size() <= map2.size() ? map2 : map1;
+
+    folly::F14FastMap<arg_type<K>, arg_type<V>> lookup;
+    lookup.reserve(smallMap.size());
+    for (const auto& [key, val] : smallMap) {
+      if (val.has_value()) {
+        lookup.emplace(key, val.value());
+      }
+    }
+
+    // Iterate through the larger map and look up matching keys.
+    for (const auto& [key, val] : largeMap) {
+      if (!val.has_value()) {
+        continue;
+      }
+
+      auto it = lookup.find(key);
+      if (it != lookup.end()) {
+        if constexpr (std::is_same_v<TOutput, int64_t>) {
+          auto product = checkedMultiply<TOutput>(
+              static_cast<TOutput>(val.value()),
+              static_cast<TOutput>(it->second));
+          sum = checkedPlus<TOutput>(sum, product);
+        } else {
+          sum += static_cast<TOutput>(val.value()) *
+              static_cast<TOutput>(it->second);
+        }
+      }
+    }
+
+    out = sum;
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/EnumFunctions.h b/velox/functions/prestosql/EnumFunctions.h
index a7eb0d6c22f..326d3f61087 100644
--- a/velox/functions/prestosql/EnumFunctions.h
+++ b/velox/functions/prestosql/EnumFunctions.h
@@ -61,8 +61,8 @@ struct EnumKeyFunction {
     return Status::OK();
   }
 
-  Status call(out_type<Varchar>& result, const std::string& input) {
-    auto keyAt = enumPtr_->keyAt(input);
+  Status call(out_type<Varchar>& result, const arg_type<Varchar>& input) {
+    auto keyAt = enumPtr_->keyAt(std::string(input));
     if (!keyAt.has_value()) {
       return Status::UserError(
           "Value '{}' not in VarcharEnum: {}", input, enumPtr_->toString());
diff --git a/velox/functions/prestosql/FilterFunctions.cpp b/velox/functions/prestosql/FilterFunctions.cpp
index 7c972d2b470..f224689b2c2 100644
--- a/velox/functions/prestosql/FilterFunctions.cpp
+++ b/velox/functions/prestosql/FilterFunctions.cpp
@@ -13,162 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "velox/expression/Expr.h"
 #include "velox/expression/LambdaExpr.h"
-#include "velox/expression/VectorFunction.h"
-#include "velox/functions/lib/LambdaFunctionUtil.h"
-#include "velox/functions/lib/RowsTranslationUtil.h"
+#include "velox/functions/lib/FilterFunctionBase.h"
 #include "velox/vector/FlatMapVector.h"
-#include "velox/vector/FunctionVector.h"
 
 namespace facebook::velox::functions {
 namespace {
 
-class FilterFunctionBase : public exec::VectorFunction {
- protected:
-  // Applies filter functions to elements of maps or arrays and returns the
-  // number of elements that passed the filters. Stores the number of elements
-  // in each array or map that passed the filter in resultSizes. Stores the
-  // indices of passing elements in selectedIndices. resultOffsets is populated
-  // assuming sequential layout of the passing elements.
-  template <typename T>
-  static vector_size_t doApply(
-      const SelectivityVector& rows,
-      const std::shared_ptr<T>& input,
-      const VectorPtr& lambda,
-      const std::vector<VectorPtr>& lambdaArgs,
-      exec::EvalCtx& context,
-      BufferPtr& resultOffsets,
-      BufferPtr& resultSizes,
-      BufferPtr& selectedIndices) {
-    const auto* inputOffsets = input->rawOffsets();
-    const auto* inputSizes = input->rawSizes();
-
-    auto* pool = context.pool();
-    resultSizes = allocateSizes(rows.end(), pool);
-    resultOffsets = allocateOffsets(rows.end(), pool);
-    auto* rawResultSizes = resultSizes->asMutable<vector_size_t>();
-    auto* rawResultOffsets = resultOffsets->asMutable<vector_size_t>();
-
-    const auto numElements = lambdaArgs[0]->size();
-
-    selectedIndices = allocateIndices(numElements, pool);
-    auto* rawSelectedIndices = selectedIndices->asMutable<vector_size_t>();
-
-    vector_size_t numSelected = 0;
-
-    auto elementToTopLevelRows =
-        getElementToTopLevelRows(numElements, rows, input.get(), pool);
-
-    exec::LocalDecodedVector bitsDecoder(context);
-    auto iter = lambda->asUnchecked<FunctionVector>()->iterator(&rows);
-    while (auto entry = iter.next()) {
-      auto elementRows =
-          toElementRows<T>(numElements, *entry.rows, input.get());
-      auto wrapCapture =
-          toWrapCapture<T>(numElements, entry.callable, *entry.rows, input);
-
-      VectorPtr bits;
-      entry.callable->apply(
-          elementRows,
-          nullptr,
-          wrapCapture,
-          &context,
-          lambdaArgs,
-          elementToTopLevelRows,
-          &bits);
-      bitsDecoder.get()->decode(*bits, elementRows);
-      entry.rows->applyToSelected([&](vector_size_t row) {
-        if (input->isNullAt(row)) {
-          return;
-        }
-        auto size = inputSizes[row];
-        auto offset = inputOffsets[row];
-        rawResultOffsets[row] = numSelected;
-        for (auto i = 0; i < size; ++i) {
-          if (!bitsDecoder.get()->isNullAt(offset + i) &&
-              bitsDecoder.get()->valueAt<bool>(offset + i)) {
-            ++rawResultSizes[row];
-            rawSelectedIndices[numSelected] = offset + i;
-            ++numSelected;
-          }
-        }
-      });
-    }
-
-    selectedIndices->setSize(numSelected * sizeof(vector_size_t));
-
-    return numSelected;
-  }
-};
-
-// See documentation at
-//    - https://prestodb.io/docs/current/functions/array.html
-//    - https://prestodb.io/docs/current/functions/lambda.html
-//    - https://prestodb.io/blog/2020/03/02/presto-lambda
-class ArrayFilterFunction : public FilterFunctionBase {
- public:
-  void apply(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& /* outputType */,
-      exec::EvalCtx& context,
-      VectorPtr& result) const override {
-    VELOX_CHECK_EQ(args.size(), 2);
-    exec::LocalDecodedVector arrayDecoder(context, *args[0], rows);
-    auto& decodedArray = *arrayDecoder.get();
-
-    auto flatArray = flattenArray(rows, args[0], decodedArray);
-
-    VectorPtr elements = flatArray->elements();
-    BufferPtr resultSizes;
-    BufferPtr resultOffsets;
-    BufferPtr selectedIndices;
-    auto numSelected = doApply(
-        rows,
-        flatArray,
-        args[1],
-        {elements},
-        context,
-        resultOffsets,
-        resultSizes,
-        selectedIndices);
-
-    // Filter can pass along very large elements vectors that can hold onto
-    // memory and copy operations on them can further put memory pressure. We
-    // try to flatten them if the dictionary layer is much smaller than the
-    // elements vector.
-    auto wrappedElements = numSelected ? BaseVector::wrapInDictionary(
-                                             BufferPtr(nullptr),
-                                             std::move(selectedIndices),
-                                             numSelected,
-                                             std::move(elements),
-                                             true /*flattenIfRedundant*/)
-                                       : nullptr;
-    // Set nulls for rows not present in 'rows'.
-    BufferPtr newNulls = addNullsForUnselectedRows(flatArray, rows);
-    auto localResult = std::make_shared<ArrayVector>(
-        flatArray->pool(),
-        flatArray->type(),
-        std::move(newNulls),
-        rows.end(),
-        std::move(resultOffsets),
-        std::move(resultSizes),
-        wrappedElements);
-    context.moveOrCopyResult(localResult, rows, result);
-  }
-
-  static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
-    // array(T), function(T, boolean) -> array(T)
-    return {exec::FunctionSignatureBuilder()
-                .typeVariable("T")
-                .returnType("array(T)")
-                .argumentType("array(T)")
-                .argumentType("function(T,boolean)")
-                .build()};
-  }
-};
-
 // See documentation at
 //    - https://prestodb.io/docs/current/functions/map.html
 //    - https://prestodb.io/docs/current/functions/lambda.html
@@ -183,18 +34,17 @@ class MapFilterFunction : public FilterFunctionBase {
   void buildInMapSelectivityVector(
       SelectivityVector& rowsToFilterOn,
       BufferPtr flattenedInMap,
-      BufferPtr inMap,
+      const uint64_t* inMapBits,
       vector_size_t inMapSize,
       const SelectivityVector& rows,
       const vector_size_t* decodedIndices) const {
     // Flatten inMap buffer.
     auto* mutableFlattedInMap = flattenedInMap->asMutable<uint64_t>();
     bits::fillBits(mutableFlattedInMap, 0, inMapSize, false);
-    auto* mutableInMap = inMap ? inMap->asMutable<uint64_t>() : nullptr;
     rows.applyToSelected([&](vector_size_t row) {
       // If inMap is null, short circuit and set bit because key is present in
       // all rows.
-      if (!inMap || bits::isBitSet(mutableInMap, decodedIndices[row])) {
+      if (!inMapBits || bits::isBitSet(inMapBits, decodedIndices[row])) {
         bits::setBit(mutableFlattedInMap, decodedIndices[row]);
       }
     });
@@ -206,8 +56,50 @@ class MapFilterFunction : public FilterFunctionBase {
     rowsToFilterOn.updateBounds();
   }
 
+  enum class UniformResult { kAllTrue, kAllFalse, kMixed };
+
+  // Adds a fast path for detecting uniform lambda results (all-true or
+  // all-false) across in-map rows using O(N/64) word-level bitmap comparison,
+  // avoiding per-row decoding when the result is uniform.
+  UniformResult detectUniformResult(
+      const VectorPtr& lambdaResultBits,
+      const SelectivityVector& rowsToFilterOn) const {
+    if (lambdaResultBits->isConstantEncoding()) {
+      bool passAll = !lambdaResultBits->isNullAt(0) &&
+          lambdaResultBits->asUnchecked<ConstantVector<bool>>()->valueAt(0);
+      return passAll ? UniformResult::kAllTrue : UniformResult::kAllFalse;
+    }
+
+    if (lambdaResultBits->isFlatEncoding() &&
+        !lambdaResultBits->mayHaveNulls()) {
+      auto* resultBits = lambdaResultBits->asUnchecked<FlatVector<bool>>()
+                             ->template rawValues<uint64_t>();
+      auto* inMapBits = rowsToFilterOn.asRange().bits();
+      bool allTrue = true;
+      bool anyTrue = false;
+      bits::forEachWord(
+          0, rowsToFilterOn.end(), [&](int32_t idx, uint64_t mask) {
+            auto masked = resultBits[idx] & inMapBits[idx] & mask;
+            if (masked) {
+              anyTrue = true;
+            }
+            if (masked != (inMapBits[idx] & mask)) {
+              allTrue = false;
+            }
+          });
+      if (!anyTrue) {
+        return UniformResult::kAllFalse;
+      }
+      if (allTrue) {
+        return UniformResult::kAllTrue;
+      }
+    }
+
+    return UniformResult::kMixed;
+  }
+
   // Apply filter function to vector of encoding FlatMapVector. Because the
-  // entirety of the map values are stored in in a list of vectors (one vector
+  // entirety of the map values are stored in a list of vectors (one vector
   // per key), we will need to apply the filter function on each vector and
   // associated inMap buffer. Additionally, we will have to reduce the number of
   // distinct keys stored in the FlatMapVector if they key list changes.
@@ -264,11 +156,15 @@ class MapFilterFunction : public FilterFunctionBase {
         buildInMapSelectivityVector(
             rowsToFilterOn,
             flattenedInMap,
-            flatMap.inMaps()[channel],
+            flatMap.rawInMapsAt(channel),
             flatMap.size(),
             *entry.rows,
             decodedMap.indices());
 
+        if (!rowsToFilterOn.hasSelections()) {
+          continue;
+        }
+
         // Call lambda function and decode its output bit vector. We will
         // use it to determine what will persist to the final result vector.
         VectorPtr lambdaResultBits;
@@ -284,8 +180,25 @@ class MapFilterFunction : public FilterFunctionBase {
             },
             decodedIndices,
             &lambdaResultBits);
-        bitsDecoder.get()->decode(*lambdaResultBits);
 
+        auto uniform = detectUniformResult(lambdaResultBits, rowsToFilterOn);
+        if (uniform == UniformResult::kAllFalse) {
+          continue;
+        }
+        if (uniform == UniformResult::kAllTrue) {
+          rawIndices[numDistinct++] = channel;
+          filteredMapValues.push_back(mapValues[channel]);
+          auto newInMap =
+              AlignedBuffer::allocate<bool>(numRows, context.pool(), 0);
+          memcpy(
+              newInMap->asMutable<void>(),
+              flattenedInMap->as<void>(),
+              bits::nbytes(numRows));
+          filteredInMaps.push_back(std::move(newInMap));
+          continue;
+        }
+
+        bitsDecoder.get()->decode(*lambdaResultBits, rowsToFilterOn);
         bool isFilteredIn = false;
         entry.rows->applyToSelected([&](vector_size_t row) {
           row = decodedMap.indices()[row];
@@ -296,8 +209,7 @@ class MapFilterFunction : public FilterFunctionBase {
             // vector and define a new filtered inMap buffer. Let's also note
             // the index of this key for key filtering.
             if (!isFilteredIn) {
-              filteredMapValues.push_back(
-                  BaseVector::copy(*mapValues[channel]));
+              filteredMapValues.push_back(mapValues[channel]);
               filteredInMaps.push_back(
                   AlignedBuffer::allocate<bool>(numRows, context.pool(), 0));
               filteredInMap = filteredInMaps.back()->asMutable<uint64_t>();
@@ -440,9 +352,9 @@ class MapFilterFunction : public FilterFunctionBase {
 
 VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_array_filter,
-    ArrayFilterFunction::signatures(),
+    ArrayFilterFunctionBase::signatures(),
     exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
-    std::make_unique<ArrayFilterFunction>());
+    std::make_unique<ArrayFilterFunctionBase>());
 
 VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_map_filter,
diff --git a/velox/functions/prestosql/FloatingPointFunctions.h b/velox/functions/prestosql/FloatingPointFunctions.h
index f78c0d13dc0..7220de67c8f 100644
--- a/velox/functions/prestosql/FloatingPointFunctions.h
+++ b/velox/functions/prestosql/FloatingPointFunctions.h
@@ -15,8 +15,7 @@
  */
 #pragma once
 
-#define XXH_INLINE_ALL
-#include <xxhash.h>
+#include "velox/common/base/XxHashInline.h"
 
 #include "velox/functions/Udf.h"
 #include "velox/type/Type.h"
diff --git a/velox/functions/prestosql/FromUtf8.cpp b/velox/functions/prestosql/FromUtf8.cpp
index 70d09643bfa..8736d39e552 100644
--- a/velox/functions/prestosql/FromUtf8.cpp
+++ b/velox/functions/prestosql/FromUtf8.cpp
@@ -43,7 +43,7 @@ class FromUtf8Function : public exec::VectorFunction {
     // Read the constant replacement if it exisits and verify that it is valid.
     bool constantReplacement =
         args.size() == 1 || decodedArgs.at(1)->isConstantMapping();
-    std::string constantReplacementValue = kReplacementChar;
+    StringView constantReplacementValue = kReplacementChar;
 
     if (constantReplacement) {
       if (args.size() > 1) {
@@ -146,24 +146,17 @@ class FromUtf8Function : public exec::VectorFunction {
   }
 
  private:
-  static const std::string kReplacementChar;
+  static const StringView kReplacementChar;
 
-  static std::string codePointToString(int64_t codePoint) {
-    std::string result;
-    result.resize(4);
-    stringImpl::codePointToString(result, codePoint);
-    return result;
-  }
-
-  std::string getReplacementCharacter(
+  StringView getReplacementCharacter(
       const TypePtr& type,
       DecodedVector& decoded,
       vector_size_t row) const {
     if (type->isBigint()) {
-      return codePointToString(decoded.valueAt<int64_t>(row));
+      return stringImpl::codePointToString(decoded.valueAt<int64_t>(row));
     }
 
-    auto replacement = decoded.valueAt<StringView>(row);
+    StringView replacement = decoded.valueAt<StringView>(row);
     if (!replacement.empty()) {
       int32_t codePoint;
       auto charLength = tryGetUtf8CharLength(
@@ -260,7 +253,7 @@ class FromUtf8Function : public exec::VectorFunction {
 
   void fixInvalidUtf8(
       StringView input,
-      const std::string& replacement,
+      const StringView& replacement,
       exec::StringWriter& fixedWriter) const {
     if (input.empty()) {
       fixedWriter.setEmpty();
@@ -290,8 +283,9 @@ class FromUtf8Function : public exec::VectorFunction {
 };
 
 // static
-const std::string FromUtf8Function::kReplacementChar =
-    codePointToString(0xFFFD);
+const StringView FromUtf8Function::kReplacementChar =
+    stringImpl::codePointToString(0xFFFD);
+
 } // namespace
 
 VELOX_DECLARE_VECTOR_FUNCTION(
diff --git a/velox/functions/prestosql/GeometryFunctions.h b/velox/functions/prestosql/GeometryFunctions.h
index 6b5e12bd91e..b4b5905541c 100644
--- a/velox/functions/prestosql/GeometryFunctions.h
+++ b/velox/functions/prestosql/GeometryFunctions.h
@@ -17,6 +17,8 @@
 #pragma once
 
 #include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateArraySequence.h>
+#include <geos/geom/CoordinateSequenceFactory.h>
 #include <geos/geom/Envelope.h>
 #include <geos/io/GeoJSON.h>
 #include <geos/io/GeoJSONReader.h>
@@ -33,11 +35,12 @@
 #include <cmath>
 
 #include <velox/type/StringView.h>
+#include "velox/common/geospatial/GeometrySerde.h"
 #include "velox/functions/Macros.h"
-#include "velox/functions/prestosql/geospatial/GeometrySerde.h"
 #include "velox/functions/prestosql/geospatial/GeometryUtils.h"
 #include "velox/functions/prestosql/types/BingTileType.h"
 #include "velox/functions/prestosql/types/GeometryType.h"
+#include "velox/functions/prestosql/types/SphericalGeographyType.h"
 #include "velox/type/Variant.h"
 
 namespace facebook::velox::functions {
@@ -52,10 +55,10 @@ struct StGeometryFromTextFunction {
     GEOS_TRY(
         {
           geos::io::WKTReader reader;
-          geosGeometry = reader.read(wkt);
+          geosGeometry = reader.read(std::string(wkt));
         },
         "Failed to parse WKT");
-    geospatial::GeometrySerializer::serialize(*geosGeometry, result);
+    common::geospatial::GeometrySerializer::serialize(*geosGeometry, result);
     return Status::OK();
   }
 };
@@ -75,7 +78,7 @@ struct StGeomFromBinaryFunction {
               reinterpret_cast<const uint8_t*>(wkb.data()), wkb.size());
         },
         "Failed to parse WKB");
-    geospatial::GeometrySerializer::serialize(*geosGeometry, result);
+    common::geospatial::GeometrySerializer::serialize(*geosGeometry, result);
     return Status::OK();
   }
 };
@@ -87,7 +90,28 @@ struct StAsTextFunction {
   FOLLY_ALWAYS_INLINE Status
   call(out_type<Varchar>& result, const arg_type<Geometry>& geometry) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
+
+    GEOS_TRY(
+        {
+          geos::io::WKTWriter writer;
+          writer.setTrim(true);
+          result = writer.write(geosGeometry.get());
+        },
+        "Failed to write WKT");
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct SphericalAsTextFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<Varchar>& result,
+      const arg_type<SphericalGeography>& geography) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(geography);
 
     GEOS_TRY(
         {
@@ -107,7 +131,7 @@ struct StAsBinaryFunction {
   FOLLY_ALWAYS_INLINE Status
   call(out_type<Varbinary>& result, const arg_type<Geometry>& geometry) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
     GEOS_TRY(
         {
           geos::io::WKBWriter writer;
@@ -133,14 +157,15 @@ struct StPointFunction {
       const arg_type<double>& x,
       const arg_type<double>& y) {
     if (!std::isfinite(x) || !std::isfinite(y)) {
-      return Status::UserError(fmt::format(
-          "ST_Point requires finite coordinates, got x={} y={}", x, y));
+      return Status::UserError(
+          fmt::format(
+              "ST_Point requires finite coordinates, got x={} y={}", x, y));
     }
     GEOS_TRY(
         {
           auto point = std::unique_ptr<geos::geom::Point>(
               factory_->createPoint(geos::geom::Coordinate(x, y)));
-          geospatial::GeometrySerializer::serialize(*point, result);
+          common::geospatial::GeometrySerializer::serialize(*point, result);
         },
         "Failed to create point geometry");
     return Status::OK();
@@ -160,7 +185,7 @@ struct StPolygonFunction {
     GEOS_TRY(
         {
           geos::io::WKTReader reader;
-          geosGeometry = reader.read(wkt);
+          geosGeometry = reader.read(std::string(wkt));
         },
         "Failed to parse WKT");
     auto validate = geospatial::validateType(
@@ -168,7 +193,7 @@ struct StPolygonFunction {
         {geos::geom::GeometryTypeId::GEOS_POLYGON},
         "ST_Polygon");
 
-    geospatial::GeometrySerializer::serialize(*geosGeometry, result);
+    common::geospatial::GeometrySerializer::serialize(*geosGeometry, result);
 
     return validate;
   }
@@ -186,11 +211,13 @@ struct StRelateFunction {
       const arg_type<Geometry>& rightGeometry,
       const arg_type<Varchar>& relation) {
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(rightGeometry);
-    GEOS_TRY(result = leftGeosGeometry->relate(*rightGeosGeometry, relation);
-             , "Failed to check geometry relation");
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
+    GEOS_TRY(
+        result =
+            leftGeosGeometry->relate(*rightGeosGeometry, std::string(relation));
+        , "Failed to check geometry relation");
 
     return Status::OK();
   }
@@ -204,13 +231,21 @@ struct StContainsFunction {
       out_type<bool>& result,
       const arg_type<Geometry>& leftGeometry,
       const arg_type<Geometry>& rightGeometry) {
-    // TODO: When #12771 is merged, check envelopes and short-circuit
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(rightGeometry);
-    GEOS_TRY(result = leftGeosGeometry->contains(&*rightGeosGeometry);
-             , "Failed to check geometry contains");
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
+    if (!geospatial::hasGeometryCollection(
+            *leftGeosGeometry, *rightGeosGeometry) &&
+        !leftGeosGeometry->getEnvelopeInternal()->contains(
+            rightGeosGeometry->getEnvelopeInternal())) {
+      result = false;
+      return Status::OK();
+    }
+
+    GEOS_TRY(
+        result = leftGeosGeometry->contains(&*rightGeosGeometry);
+        , "Failed to check geometry contains");
 
     return Status::OK();
   }
@@ -224,13 +259,21 @@ struct StCrossesFunction {
       out_type<bool>& result,
       const arg_type<Geometry>& leftGeometry,
       const arg_type<Geometry>& rightGeometry) {
-    // TODO: When #12771 is merged, check envelopes and short-circuit
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(rightGeometry);
-    GEOS_TRY(result = leftGeosGeometry->crosses(&*rightGeosGeometry);
-             , "Failed to check geometry crosses");
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
+    if (!geospatial::hasGeometryCollection(
+            *leftGeosGeometry, *rightGeosGeometry) &&
+        !leftGeosGeometry->getEnvelopeInternal()->intersects(
+            rightGeosGeometry->getEnvelopeInternal())) {
+      result = false;
+      return Status::OK();
+    }
+
+    GEOS_TRY(
+        result = leftGeosGeometry->crosses(&*rightGeosGeometry);
+        , "Failed to check geometry crosses");
 
     return Status::OK();
   }
@@ -244,13 +287,21 @@ struct StDisjointFunction {
       out_type<bool>& result,
       const arg_type<Geometry>& leftGeometry,
       const arg_type<Geometry>& rightGeometry) {
-    // TODO: When #12771 is merged, check envelopes and short-circuit
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(rightGeometry);
-    GEOS_TRY(result = leftGeosGeometry->disjoint(&*rightGeosGeometry);
-             , "Failed to check geometry disjoint");
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
+    if (!geospatial::hasGeometryCollection(
+            *leftGeosGeometry, *rightGeosGeometry) &&
+        !leftGeosGeometry->getEnvelopeInternal()->intersects(
+            rightGeosGeometry->getEnvelopeInternal())) {
+      result = true;
+      return Status::OK();
+    }
+
+    GEOS_TRY(
+        result = leftGeosGeometry->disjoint(&*rightGeosGeometry);
+        , "Failed to check geometry disjoint");
 
     return Status::OK();
   }
@@ -264,13 +315,25 @@ struct StEqualsFunction {
       out_type<bool>& result,
       const arg_type<Geometry>& leftGeometry,
       const arg_type<Geometry>& rightGeometry) {
-    // TODO: When #12771 is merged, check envelopes and short-circuit
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(rightGeometry);
-    GEOS_TRY(result = leftGeosGeometry->equals(&*rightGeosGeometry);
-             , "Failed to check geometry equals");
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
+    if (!geospatial::hasGeometryCollection(
+            *leftGeosGeometry, *rightGeosGeometry) &&
+        // Technically two empty geometries are not equal, but GEOS treats them
+        // as equal, so we default to GEOS in that case.
+        !(leftGeosGeometry->getEnvelopeInternal()->isNull() &&
+          rightGeosGeometry->getEnvelopeInternal()->isNull()) &&
+        !leftGeosGeometry->getEnvelopeInternal()->intersects(
+            rightGeosGeometry->getEnvelopeInternal())) {
+      result = false;
+      return Status::OK();
+    }
+
+    GEOS_TRY(
+        result = leftGeosGeometry->equals(&*rightGeosGeometry);
+        , "Failed to check geometry equals");
 
     return Status::OK();
   }
@@ -284,13 +347,21 @@ struct StIntersectsFunction {
       out_type<bool>& result,
       const arg_type<Geometry>& leftGeometry,
       const arg_type<Geometry>& rightGeometry) {
-    // TODO: When #12771 is merged, check envelopes and short-circuit
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(rightGeometry);
-    GEOS_TRY(result = leftGeosGeometry->intersects(&*rightGeosGeometry);
-             , "Failed to check geometry intersects");
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
+    if (!geospatial::hasGeometryCollection(
+            *leftGeosGeometry, *rightGeosGeometry) &&
+        !leftGeosGeometry->getEnvelopeInternal()->intersects(
+            rightGeosGeometry->getEnvelopeInternal())) {
+      result = false;
+      return Status::OK();
+    }
+
+    GEOS_TRY(
+        result = leftGeosGeometry->intersects(&*rightGeosGeometry);
+        , "Failed to check geometry intersects");
 
     return Status::OK();
   }
@@ -304,13 +375,21 @@ struct StOverlapsFunction {
       out_type<bool>& result,
       const arg_type<Geometry>& leftGeometry,
       const arg_type<Geometry>& rightGeometry) {
-    // TODO: When #12771 is merged, check envelopes and short-circuit
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(rightGeometry);
-    GEOS_TRY(result = leftGeosGeometry->overlaps(&*rightGeosGeometry);
-             , "Failed to check geometry overlaps");
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
+    if (!geospatial::hasGeometryCollection(
+            *leftGeosGeometry, *rightGeosGeometry) &&
+        !leftGeosGeometry->getEnvelopeInternal()->intersects(
+            rightGeosGeometry->getEnvelopeInternal())) {
+      result = false;
+      return Status::OK();
+    }
+
+    GEOS_TRY(
+        result = leftGeosGeometry->overlaps(&*rightGeosGeometry);
+        , "Failed to check geometry overlaps");
 
     return Status::OK();
   }
@@ -324,13 +403,21 @@ struct StTouchesFunction {
       out_type<bool>& result,
       const arg_type<Geometry>& leftGeometry,
       const arg_type<Geometry>& rightGeometry) {
-    // TODO: When #12771 is merged, check envelopes and short-circuit
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(rightGeometry);
-    GEOS_TRY(result = leftGeosGeometry->touches(&*rightGeosGeometry);
-             , "Failed to check geometry touches");
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
+    if (!geospatial::hasGeometryCollection(
+            *leftGeosGeometry, *rightGeosGeometry) &&
+        !leftGeosGeometry->getEnvelopeInternal()->intersects(
+            rightGeosGeometry->getEnvelopeInternal())) {
+      result = false;
+      return Status::OK();
+    }
+
+    GEOS_TRY(
+        result = leftGeosGeometry->touches(&*rightGeosGeometry);
+        , "Failed to check geometry touches");
 
     return Status::OK();
   }
@@ -344,13 +431,21 @@ struct StWithinFunction {
       out_type<bool>& result,
       const arg_type<Geometry>& leftGeometry,
       const arg_type<Geometry>& rightGeometry) {
-    // TODO: When #12771 is merged, check envelopes and short-circuit
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(rightGeometry);
-    GEOS_TRY(result = leftGeosGeometry->within(&*rightGeosGeometry);
-             , "Failed to check geometry within");
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
+    if (!geospatial::hasGeometryCollection(
+            *leftGeosGeometry, *rightGeosGeometry) &&
+        !rightGeosGeometry->getEnvelopeInternal()->contains(
+            leftGeosGeometry->getEnvelopeInternal())) {
+      result = false;
+      return Status::OK();
+    }
+
+    GEOS_TRY(
+        result = leftGeosGeometry->within(&*rightGeosGeometry);
+        , "Failed to check geometry within");
 
     return Status::OK();
   }
@@ -366,18 +461,24 @@ struct StDifferenceFunction {
       out_type<Geometry>& result,
       const arg_type<Geometry>& leftGeometry,
       const arg_type<Geometry>& rightGeometry) {
-    // TODO: When #12771 is merged, check envelopes and short-circuit
-    // if envelopes are disjoint
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(rightGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
+    if (!geospatial::hasGeometryCollection(
+            *leftGeosGeometry, *rightGeosGeometry) &&
+        !leftGeosGeometry->getEnvelopeInternal()->intersects(
+            rightGeosGeometry->getEnvelopeInternal())) {
+      result = leftGeometry;
+      return Status::OK();
+    }
 
     std::unique_ptr<geos::geom::Geometry> outputGeometry;
-    GEOS_TRY(outputGeometry = leftGeosGeometry->difference(&*rightGeosGeometry);
-             , "Failed to compute geometry difference");
+    GEOS_TRY(
+        outputGeometry = leftGeosGeometry->difference(&*rightGeosGeometry);
+        , "Failed to compute geometry difference");
 
-    geospatial::GeometrySerializer::serialize(*outputGeometry, result);
+    common::geospatial::GeometrySerializer::serialize(*outputGeometry, result);
     return Status::OK();
   }
 };
@@ -389,13 +490,14 @@ struct StBoundaryFunction {
   FOLLY_ALWAYS_INLINE Status
   call(out_type<Geometry>& result, const arg_type<Geometry>& input) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(input);
+        common::geospatial::GeometryDeserializer::deserialize(input);
 
     std::unique_ptr<geos::geom::Geometry> outputGeometry;
 
-    GEOS_TRY(geospatial::GeometrySerializer::serialize(
-                 *geosGeometry->getBoundary(), result);
-             , "Failed to compute geometry boundary");
+    GEOS_TRY(
+        common::geospatial::GeometrySerializer::serialize(
+            *geosGeometry->getBoundary(), result);
+        , "Failed to compute geometry boundary");
 
     return Status::OK();
   }
@@ -403,27 +505,40 @@ struct StBoundaryFunction {
 
 template <typename T>
 struct StIntersectionFunction {
+  StIntersectionFunction() {
+    factory_ = geos::geom::GeometryFactory::create();
+  }
+
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
   FOLLY_ALWAYS_INLINE Status call(
       out_type<Geometry>& result,
       const arg_type<Geometry>& leftGeometry,
       const arg_type<Geometry>& rightGeometry) {
-    // TODO: When #12771 is merged, check envelopes and short-circuit
-    // if envelopes are disjoint
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(rightGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
+    if (!geospatial::hasGeometryCollection(
+            *leftGeosGeometry, *rightGeosGeometry) &&
+        !leftGeosGeometry->getEnvelopeInternal()->intersects(
+            rightGeosGeometry->getEnvelopeInternal())) {
+      auto emptyGeometry = factory_->createEmptyGeometry();
+      common::geospatial::GeometrySerializer::serialize(*emptyGeometry, result);
+      return Status::OK();
+    }
 
     std::unique_ptr<geos::geom::Geometry> outputGeometry;
     GEOS_TRY(
         outputGeometry = leftGeosGeometry->intersection(&*rightGeosGeometry);
         , "Failed to compute geometry intersection");
 
-    geospatial::GeometrySerializer::serialize(*outputGeometry, result);
+    common::geospatial::GeometrySerializer::serialize(*outputGeometry, result);
     return Status::OK();
   }
+
+ private:
+  geos::geom::GeometryFactory::Ptr factory_;
 };
 
 template <typename T>
@@ -434,19 +549,17 @@ struct StSymDifferenceFunction {
       out_type<Geometry>& result,
       const arg_type<Geometry>& leftGeometry,
       const arg_type<Geometry>& rightGeometry) {
-    // TODO: When #12771 is merged, check envelopes and short-circuit
-    // if envelopes are disjoint
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(rightGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
 
     std::unique_ptr<geos::geom::Geometry> outputGeometry;
     GEOS_TRY(
         outputGeometry = leftGeosGeometry->symDifference(&*rightGeosGeometry);
         , "Failed to compute geometry symdifference");
 
-    geospatial::GeometrySerializer::serialize(*outputGeometry, result);
+    common::geospatial::GeometrySerializer::serialize(*outputGeometry, result);
     return Status::OK();
   }
 };
@@ -459,18 +572,17 @@ struct StUnionFunction {
       out_type<Geometry>& result,
       const arg_type<Geometry>& leftGeometry,
       const arg_type<Geometry>& rightGeometry) {
-    // TODO: When #12771 is merged, check envelopes and short-circuit if
-    // one/both are empty
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::GeometryDeserializer::deserialize(rightGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
 
     std::unique_ptr<geos::geom::Geometry> outputGeometry;
-    GEOS_TRY(outputGeometry = leftGeosGeometry->Union(&*rightGeosGeometry);
-             , "Failed to compute geometry union");
+    GEOS_TRY(
+        outputGeometry = leftGeosGeometry->Union(&*rightGeosGeometry);
+        , "Failed to compute geometry union");
 
-    geospatial::GeometrySerializer::serialize(*outputGeometry, result);
+    common::geospatial::GeometrySerializer::serialize(*outputGeometry, result);
     return Status::OK();
   }
 };
@@ -484,10 +596,10 @@ struct StIsValidFunction {
   FOLLY_ALWAYS_INLINE Status
   call(out_type<bool>& result, const arg_type<Geometry>& input) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(input);
+        common::geospatial::GeometryDeserializer::deserialize(input);
 
-    GEOS_TRY(result = geosGeometry->isValid();
-             , "Failed to check geometry isValid");
+    GEOS_TRY(
+        result = geosGeometry->isValid();, "Failed to check geometry isValid");
 
     return Status::OK();
   }
@@ -500,10 +612,11 @@ struct StIsSimpleFunction {
   FOLLY_ALWAYS_INLINE Status
   call(out_type<bool>& result, const arg_type<Geometry>& input) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(input);
+        common::geospatial::GeometryDeserializer::deserialize(input);
 
-    GEOS_TRY(result = geosGeometry->isSimple();
-             , "Failed to check geometry isSimple");
+    GEOS_TRY(
+        result = geosGeometry->isSimple();
+        , "Failed to check geometry isSimple");
 
     return Status::OK();
   }
@@ -517,7 +630,7 @@ struct GeometryInvalidReasonFunction {
       out_type<Varchar>& result,
       const arg_type<Geometry>& input) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(input);
+        common::geospatial::GeometryDeserializer::deserialize(input);
 
     std::optional<std::string> messageOpt =
         geospatial::geometryInvalidReason(geosGeometry.get());
@@ -536,12 +649,12 @@ struct StAreaFunction {
   FOLLY_ALWAYS_INLINE Status
   call(out_type<double>& result, const arg_type<Geometry>& input) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(input);
+        common::geospatial::GeometryDeserializer::deserialize(input);
 
     std::unique_ptr<geos::geom::Geometry> outputGeometry;
 
-    GEOS_TRY(result = geosGeometry->getArea();
-             , "Failed to compute geometry area");
+    GEOS_TRY(
+        result = geosGeometry->getArea();, "Failed to compute geometry area");
 
     return Status::OK();
   }
@@ -551,10 +664,15 @@ template <typename T>
 struct StCentroidFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
-  FOLLY_ALWAYS_INLINE Status
-  call(out_type<Geometry>& result, const arg_type<Geometry>& input) {
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Geometry>& result,
+      const arg_type<Geometry>& input) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(input);
+        common::geospatial::GeometryDeserializer::deserialize(input);
+
+    if (geosGeometry->isEmpty()) {
+      return false;
+    }
 
     auto validate = facebook::velox::functions::geospatial::validateType(
         *geosGeometry,
@@ -565,33 +683,30 @@ struct StCentroidFunction {
          geos::geom::GeometryTypeId::GEOS_POLYGON,
          geos::geom::GeometryTypeId::GEOS_MULTIPOLYGON},
         "ST_Centroid");
-
-    if (!validate.ok()) {
-      return validate;
-    }
+    VELOX_USER_CHECK(validate.ok(), validate.message());
 
     geos::geom::GeometryTypeId type = geosGeometry->getGeometryTypeId();
     if (type == geos::geom::GeometryTypeId::GEOS_POINT) {
       result = input;
-      return Status::OK();
+      return true;
     }
 
     if (geosGeometry->getNumPoints() == 0) {
-      GEOS_TRY(
+      GEOS_RETHROW(
           {
             geos::geom::GeometryFactory::Ptr factory =
                 geos::geom::GeometryFactory::create();
             std::unique_ptr<geos::geom::Point> point = factory->createPoint();
-            geospatial::GeometrySerializer::serialize(*point, result);
+            common::geospatial::GeometrySerializer::serialize(*point, result);
             factory->destroyGeometry(point.release());
           },
           "Failed to create point geometry");
-      return Status::OK();
+      return true;
     }
 
-    geospatial::GeometrySerializer::serialize(
+    common::geospatial::GeometrySerializer::serialize(
         *(geosGeometry->getCentroid()), result);
-    return Status::OK();
+    return true;
   }
 };
 
@@ -603,12 +718,13 @@ struct StXFunction {
       out_type<double>& result,
       const arg_type<Geometry>& geometry) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
     if (geosGeometry->getGeometryTypeId() !=
         geos::geom::GeometryTypeId::GEOS_POINT) {
-      VELOX_USER_FAIL(fmt::format(
-          "ST_X requires a Point geometry, found {}",
-          geosGeometry->getGeometryType()));
+      VELOX_USER_FAIL(
+          fmt::format(
+              "ST_X requires a Point geometry, found {}",
+              geosGeometry->getGeometryType()));
     }
     if (geosGeometry->isEmpty()) {
       return false;
@@ -627,12 +743,13 @@ struct StYFunction {
       out_type<double>& result,
       const arg_type<Geometry>& geometry) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
     if (geosGeometry->getGeometryTypeId() !=
         geos::geom::GeometryTypeId::GEOS_POINT) {
-      VELOX_USER_FAIL(fmt::format(
-          "ST_Y requires a Point geometry, found {}",
-          geosGeometry->getGeometryType()));
+      VELOX_USER_FAIL(
+          fmt::format(
+              "ST_Y requires a Point geometry, found {}",
+              geosGeometry->getGeometryType()));
     }
     if (geosGeometry->isEmpty()) {
       return false;
@@ -649,7 +766,7 @@ struct StXMinFunction {
 
   bool call(out_type<double>& result, const arg_type<Geometry>& geometry) {
     const std::unique_ptr<geos::geom::Envelope> env =
-        geospatial::GeometryDeserializer::deserializeEnvelope(geometry);
+        common::geospatial::GeometryDeserializer::deserializeEnvelope(geometry);
     if (env->isNull()) {
       return false;
     }
@@ -664,7 +781,7 @@ struct StYMinFunction {
 
   bool call(out_type<double>& result, const arg_type<Geometry>& geometry) {
     const std::unique_ptr<geos::geom::Envelope> env =
-        geospatial::GeometryDeserializer::deserializeEnvelope(geometry);
+        common::geospatial::GeometryDeserializer::deserializeEnvelope(geometry);
     if (env->isNull()) {
       return false;
     }
@@ -679,7 +796,7 @@ struct StXMaxFunction {
 
   bool call(out_type<double>& result, const arg_type<Geometry>& geometry) {
     const std::unique_ptr<geos::geom::Envelope> env =
-        geospatial::GeometryDeserializer::deserializeEnvelope(geometry);
+        common::geospatial::GeometryDeserializer::deserializeEnvelope(geometry);
     if (env->isNull()) {
       return false;
     }
@@ -694,7 +811,7 @@ struct StYMaxFunction {
 
   bool call(out_type<double>& result, const arg_type<Geometry>& geometry) {
     const std::unique_ptr<geos::geom::Envelope> env =
-        geospatial::GeometryDeserializer::deserializeEnvelope(geometry);
+        common::geospatial::GeometryDeserializer::deserializeEnvelope(geometry);
     if (env->isNull()) {
       return false;
     }
@@ -721,7 +838,7 @@ struct SimplifyGeometryFunction {
     }
 
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
 
     if (geosGeometry->isEmpty()) {
       result = geometry;
@@ -737,7 +854,7 @@ struct SimplifyGeometryFunction {
         },
         "Failed to compute simplified geometry");
 
-    geospatial::GeometrySerializer::serialize(*outputGeometry, result);
+    common::geospatial::GeometrySerializer::serialize(*outputGeometry, result);
     return Status::OK();
   }
 };
@@ -749,7 +866,7 @@ struct StGeometryTypeFunction {
   FOLLY_ALWAYS_INLINE Status
   call(out_type<Varchar>& result, const arg_type<Geometry>& input) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(input);
+        common::geospatial::GeometryDeserializer::deserialize(input);
 
     if (geosGeometry->getGeometryTypeId() ==
         geos::geom::GeometryTypeId::GEOS_GEOMETRYCOLLECTION) {
@@ -771,23 +888,25 @@ struct StDistanceFunction {
       const arg_type<Geometry>& geometry1,
       const arg_type<Geometry>& geometry2) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry1 =
-        geospatial::GeometryDeserializer::deserialize(geometry1);
+        common::geospatial::GeometryDeserializer::deserialize(geometry1);
     std::unique_ptr<geos::geom::Geometry> geosGeometry2 =
-        geospatial::GeometryDeserializer::deserialize(geometry2);
+        common::geospatial::GeometryDeserializer::deserialize(geometry2);
 
     if (geosGeometry1->getSRID() != geosGeometry2->getSRID()) {
-      VELOX_USER_FAIL(fmt::format(
-          "Input geometries must have the same spatial reference, found {} and {}",
-          geosGeometry1->getSRID(),
-          geosGeometry2->getSRID()));
+      VELOX_USER_FAIL(
+          fmt::format(
+              "Input geometries must have the same spatial reference, found {} and {}",
+              geosGeometry1->getSRID(),
+              geosGeometry2->getSRID()));
     }
 
     if (geosGeometry1->isEmpty() || geosGeometry2->isEmpty()) {
       return false;
     }
 
-    GEOS_RETHROW(result = geosGeometry1->distance(geosGeometry2.get());
-                 , "Failed to calculate geometry distance");
+    GEOS_RETHROW(
+        result = geosGeometry1->distance(geosGeometry2.get());
+        , "Failed to calculate geometry distance");
 
     return true;
   }
@@ -800,7 +919,7 @@ struct StIsClosedFunction {
   FOLLY_ALWAYS_INLINE Status
   call(out_type<bool>& result, const arg_type<Geometry>& geometry) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
 
     auto validate = geospatial::validateType(
         *geosGeometry,
@@ -837,7 +956,8 @@ struct StIsEmptyFunction {
     GEOS_TRY(
         {
           const std::unique_ptr<geos::geom::Envelope> env =
-              geospatial::GeometryDeserializer::deserializeEnvelope(geometry);
+              common::geospatial::GeometryDeserializer::deserializeEnvelope(
+                  geometry);
           result = env->isNull();
         },
         "Failed to get envelope from geometry");
@@ -852,7 +972,7 @@ struct StIsRingFunction {
   FOLLY_ALWAYS_INLINE Status
   call(out_type<bool>& result, const arg_type<Geometry>& geometry) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
 
     auto validate = geospatial::validateType(
         *geosGeometry,
@@ -880,7 +1000,7 @@ struct StLengthFunction {
   FOLLY_ALWAYS_INLINE Status
   call(out_type<double>& result, const arg_type<Geometry>& geometry) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
 
     auto validate = geospatial::validateType(
         *geosGeometry,
@@ -917,7 +1037,7 @@ struct StPointNFunction {
       const arg_type<Geometry>& geometry,
       const arg_type<int32_t>& index) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
 
     auto validate = geospatial::validateType(
         *geosGeometry,
@@ -933,7 +1053,7 @@ struct StPointNFunction {
       if (index < 1 || index > lineString->getNumPoints()) {
         return false;
       }
-      geospatial::GeometrySerializer::serialize(
+      common::geospatial::GeometrySerializer::serialize(
           *lineString->getPointN(index - 1), result);
       return true;
     }
@@ -951,7 +1071,7 @@ struct StStartPointFunction {
       out_type<Geometry>& result,
       const arg_type<Geometry>& geometry) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
 
     auto validate = geospatial::validateType(
         *geosGeometry,
@@ -966,7 +1086,7 @@ struct StStartPointFunction {
     }
     geos::geom::LineString* lineString =
         static_cast<geos::geom::LineString*>(geosGeometry.get());
-    geospatial::GeometrySerializer::serialize(
+    common::geospatial::GeometrySerializer::serialize(
         *(lineString->getStartPoint()), result);
 
     return true;
@@ -981,7 +1101,7 @@ struct StEndPointFunction {
       out_type<Geometry>& result,
       const arg_type<Geometry>& geometry) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
 
     auto validate = geospatial::validateType(
         *geosGeometry,
@@ -996,7 +1116,7 @@ struct StEndPointFunction {
     }
     geos::geom::LineString* lineString =
         static_cast<geos::geom::LineString*>(geosGeometry.get());
-    geospatial::GeometrySerializer::serialize(
+    common::geospatial::GeometrySerializer::serialize(
         *lineString->getEndPoint(), result);
 
     return true;
@@ -1012,7 +1132,7 @@ struct StGeometryNFunction {
       const arg_type<Geometry>& geometry,
       const arg_type<int32_t>& index) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
 
     if (geosGeometry->isEmpty()) {
       return false;
@@ -1020,7 +1140,8 @@ struct StGeometryNFunction {
 
     if (!geospatial::isMultiType(*geosGeometry)) {
       if (index == 1) {
-        geospatial::GeometrySerializer::serialize(*geosGeometry, result);
+        common::geospatial::GeometrySerializer::serialize(
+            *geosGeometry, result);
         return true;
       }
       return false;
@@ -1031,7 +1152,7 @@ struct StGeometryNFunction {
       if (index < 1 || index > geomCollection->getNumGeometries()) {
         return false;
       }
-      geospatial::GeometrySerializer::serialize(
+      common::geospatial::GeometrySerializer::serialize(
           *(geosGeometry->getGeometryN(index - 1)), result);
       return true;
     }
@@ -1049,7 +1170,7 @@ struct StInteriorRingNFunction {
       const arg_type<Geometry>& geometry,
       const arg_type<int32_t>& index) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
 
     auto validate = geospatial::validateType(
         *geosGeometry,
@@ -1065,7 +1186,7 @@ struct StInteriorRingNFunction {
     if (index < 1 || index > polygon->getNumInteriorRing()) {
       return false;
     }
-    geospatial::GeometrySerializer::serialize(
+    common::geospatial::GeometrySerializer::serialize(
         *(polygon->getInteriorRingN(index - 1)), result);
     return true;
   }
@@ -1078,7 +1199,7 @@ struct StNumGeometriesFunction {
   FOLLY_ALWAYS_INLINE Status
   call(out_type<int32_t>& result, const arg_type<Geometry>& geometry) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
 
     if (geosGeometry->isEmpty()) {
       result = 0;
@@ -1099,10 +1220,10 @@ struct StNumInteriorRingFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
   FOLLY_ALWAYS_INLINE bool call(
-      out_type<int32_t>& result,
+      out_type<int64_t>& result,
       const arg_type<Geometry>& geometry) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
 
     auto validate = geospatial::validateType(
         *geosGeometry,
@@ -1124,31 +1245,64 @@ struct StNumInteriorRingFunction {
       VELOX_USER_FAIL(
           "Number of interior rings exceeds the maximum value of int32");
     }
-    result = static_cast<int32_t>(numInteriorRings);
+    result = static_cast<int64_t>(numInteriorRings);
     return true;
   }
 };
 
 template <typename T>
 struct StConvexHullFunction {
+  StConvexHullFunction() {
+    factory_ = geos::geom::GeometryFactory::create();
+  }
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
   FOLLY_ALWAYS_INLINE Status
   call(out_type<Geometry>& result, const arg_type<Geometry>& geometry) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
+
+    if (!(geosGeometry->getEnvelopeInternal()->isNull() ||
+          geospatial::isGeometryCollection(*geosGeometry))) {
+      auto* env = geosGeometry->getEnvelopeInternal();
+      auto minX = env->getMinX();
+      auto minY = env->getMinY();
+      auto maxX = env->getMaxX();
+      auto maxY = env->getMaxY();
+
+      if ((minX == maxX) && (minY == maxY)) {
+        // Envelope is a point, so that's the minimum convex hull
+        auto res = std::unique_ptr<geos::geom::Point>(
+            factory_->createPoint(geos::geom::Coordinate(minX, minY)));
+        common::geospatial::GeometrySerializer::serialize(*res, result);
+      }
+
+      if ((minX == maxX) || (minY == maxY)) {
+        // Envelope is a line, so that's the minimum convex hull
+        auto coords = factory_->getCoordinateSequenceFactory()->create(
+            {geos::geom::Coordinate(minX, minY),
+             geos::geom::Coordinate(maxX, maxY)});
+
+        common::geospatial::GeometrySerializer::serialize(
+            *(factory_->createLineString(std::move(coords))), result);
+      }
+    }
 
     if (geosGeometry->isEmpty() ||
         geosGeometry->getGeometryTypeId() ==
             geos::geom::GeometryTypeId::GEOS_POINT) {
       result = geometry;
     } else {
-      geospatial::GeometrySerializer::serialize(
+      common::geospatial::GeometrySerializer::serialize(
           *(geosGeometry->convexHull()), result);
     }
     return Status::OK();
   }
+
+ private:
+  geos::geom::GeometryFactory::Ptr factory_;
 };
+
 class StCoordDimFunction : public facebook::velox::exec::VectorFunction {
  public:
   void apply(
@@ -1160,12 +1314,12 @@ class StCoordDimFunction : public facebook::velox::exec::VectorFunction {
     // Create a constant vector of value 2, with size equal to the number of
     // rows
     result = facebook::velox::BaseVector::createConstant(
-        outputType, 2, rows.size(), context.pool());
+        outputType, static_cast<int8_t>(2), rows.size(), context.pool());
   }
   static std::vector<std::shared_ptr<facebook::velox::exec::FunctionSignature>>
   signatures() {
     return {facebook::velox::exec::FunctionSignatureBuilder()
-                .returnType("integer")
+                .returnType("tinyint")
                 .argumentType("geometry")
                 .build()};
   }
@@ -1177,8 +1331,8 @@ struct StDimensionFunction {
 
   FOLLY_ALWAYS_INLINE Status
   call(out_type<int8_t>& result, const arg_type<Geometry>& geometry) {
-    result =
-        geospatial::GeometryDeserializer::deserialize(geometry)->getDimension();
+    result = common::geospatial::GeometryDeserializer::deserialize(geometry)
+                 ->getDimension();
 
     return Status::OK();
   }
@@ -1192,7 +1346,7 @@ struct StExteriorRingFunction {
       out_type<Geometry>& result,
       const arg_type<Geometry>& geometry) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
 
     auto validate = geospatial::validateType(
         *geosGeometry,
@@ -1213,7 +1367,7 @@ struct StExteriorRingFunction {
     VELOX_CHECK_NOT_NULL(
         polygon, "Validation passed but type not recognized as Polygon");
 
-    geospatial::GeometrySerializer::serialize(
+    common::geospatial::GeometrySerializer::serialize(
         *(polygon->getExteriorRing()), result);
 
     return true;
@@ -1230,22 +1384,10 @@ struct StEnvelopeFunction {
 
   FOLLY_ALWAYS_INLINE Status
   call(out_type<Geometry>& result, const arg_type<Geometry>& geometry) {
-    std::unique_ptr<const geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+    std::unique_ptr<geos::geom::Envelope> env =
+        common::geospatial::GeometryDeserializer::deserializeEnvelope(geometry);
 
-    auto env = geosGeometry->getEnvelope();
-
-    if (env->isEmpty()) {
-      GEOS_TRY(
-          {
-            auto polygon =
-                std::unique_ptr<geos::geom::Polygon>(factory_->createPolygon());
-            geospatial::GeometrySerializer::serialize(*polygon, result);
-          },
-          "Failed to create empty polygon in ST_Envelope");
-    }
-
-    geospatial::GeometrySerializer::serialize(*env, result);
+    common::geospatial::GeometrySerializer::serializeEnvelope(*env, result);
 
     return Status::OK();
   }
@@ -1263,9 +1405,10 @@ struct StBufferFunction {
       const arg_type<Geometry>& geometry,
       const arg_type<double>& distance) {
     if (distance < 0) {
-      VELOX_USER_FAIL(fmt::format(
-          "Provided distance must not be negative. Provided distance: {}",
-          distance));
+      VELOX_USER_FAIL(
+          fmt::format(
+              "Provided distance must not be negative. Provided distance: {}",
+              distance));
     }
     if (distance == 0) {
       result = geometry;
@@ -1273,11 +1416,11 @@ struct StBufferFunction {
     }
 
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
     if (geosGeometry->isEmpty()) {
       return false;
     }
-    geospatial::GeometrySerializer::serialize(
+    common::geospatial::GeometrySerializer::serialize(
         *(geosGeometry->buffer(distance)), result);
     return true;
   }
@@ -1291,7 +1434,7 @@ struct StPointsFunction {
       out_type<Array<Geometry>>& result,
       const arg_type<Geometry>& geometry) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
 
     if (geosGeometry->isEmpty()) {
       return false;
@@ -1311,7 +1454,7 @@ struct StPointsFunction {
     auto geometryType = geosGeometry->getGeometryTypeId();
 
     if (geometryType == geos::geom::GeometryTypeId::GEOS_POINT) {
-      geospatial::GeometrySerializer::serialize(
+      common::geospatial::GeometrySerializer::serialize(
           *geosGeometry, result.add_item());
     } else if (
         geometryType == geos::geom::GeometryTypeId::GEOS_GEOMETRYCOLLECTION) {
@@ -1329,7 +1472,8 @@ struct StPointsFunction {
         const geos::geom::Coordinate& coordinate = vertices->getAt(i);
         auto point = std::unique_ptr<geos::geom::Point>(
             geometryFactory->createPoint(coordinate));
-        geospatial::GeometrySerializer::serialize(*point, result.add_item());
+        common::geospatial::GeometrySerializer::serialize(
+            *point, result.add_item());
       }
     }
   }
@@ -1347,7 +1491,7 @@ struct StEnvelopeAsPtsFunction {
       out_type<Array<Geometry>>& result,
       const arg_type<Geometry>& geometry) {
     auto envelope =
-        geospatial::GeometryDeserializer::deserializeEnvelope(geometry);
+        common::geospatial::GeometryDeserializer::deserializeEnvelope(geometry);
 
     if (envelope->isNull()) {
       return false;
@@ -1359,8 +1503,10 @@ struct StEnvelopeAsPtsFunction {
     auto upperRight = std::unique_ptr<geos::geom::Point>(factory_->createPoint(
         geos::geom::Coordinate(envelope->getMaxX(), envelope->getMaxY())));
 
-    geospatial::GeometrySerializer::serialize(*lowerLeft, result.add_item());
-    geospatial::GeometrySerializer::serialize(*upperRight, result.add_item());
+    common::geospatial::GeometrySerializer::serialize(
+        *lowerLeft, result.add_item());
+    common::geospatial::GeometrySerializer::serialize(
+        *upperRight, result.add_item());
 
     return true;
   }
@@ -1374,9 +1520,10 @@ struct StNumPointsFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
   FOLLY_ALWAYS_INLINE void call(
-      out_type<int32_t>& result,
+      out_type<int64_t>& result,
       const arg_type<Geometry>& geometry) {
-    auto geosGeometry = geospatial::GeometryDeserializer::deserialize(geometry);
+    auto geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
 
     result = pointCount(*geosGeometry);
   }
@@ -1415,9 +1562,10 @@ struct StNumPointsFunction {
       }
       return static_cast<int32_t>(polygonPointCount);
     }
-    VELOX_FAIL(fmt::format(
-        "Unexpected failure in ST_NumPoints: geometry type {}",
-        geometry.getGeometryType()));
+    VELOX_FAIL(
+        fmt::format(
+            "Unexpected failure in ST_NumPoints: geometry type {}",
+            geometry.getGeometryType()));
   }
 };
 
@@ -1433,8 +1581,10 @@ struct GeometryNearestPointsFunction {
       out_type<Array<Geometry>>& result,
       const arg_type<Geometry>& leftGeometry,
       const arg_type<Geometry>& rightGeometry) {
-    auto left = geospatial::GeometryDeserializer::deserialize(leftGeometry);
-    auto right = geospatial::GeometryDeserializer::deserialize(rightGeometry);
+    auto left =
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
+    auto right =
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
 
     if (left->isEmpty() || right->isEmpty()) {
       return false;
@@ -1454,8 +1604,10 @@ struct GeometryNearestPointsFunction {
                   geos::geom::Coordinate(nearestCoordinates->getAt(1))));
 
           result.reserve(2);
-          geospatial::GeometrySerializer::serialize(*pointA, result.add_item());
-          geospatial::GeometrySerializer::serialize(*pointB, result.add_item());
+          common::geospatial::GeometrySerializer::serialize(
+              *pointA, result.add_item());
+          common::geospatial::GeometrySerializer::serialize(
+              *pointB, result.add_item());
         },
         "Failed to compute nearest points between geometries");
 
@@ -1474,8 +1626,10 @@ struct LineLocatePointFunction {
       out_type<double>& result,
       const arg_type<Geometry>& inputLine,
       const arg_type<Geometry>& inputPoint) {
-    auto line = geospatial::GeometryDeserializer::deserialize(inputLine);
-    auto point = geospatial::GeometryDeserializer::deserialize(inputPoint);
+    auto line =
+        common::geospatial::GeometryDeserializer::deserialize(inputLine);
+    auto point =
+        common::geospatial::GeometryDeserializer::deserialize(inputPoint);
 
     if (line->isEmpty() || point->isEmpty()) {
       return false;
@@ -1484,16 +1638,18 @@ struct LineLocatePointFunction {
     auto lineType = line->getGeometryTypeId();
     if (lineType != geos::geom::GeometryTypeId::GEOS_LINESTRING &&
         lineType != geos::geom::GeometryTypeId::GEOS_MULTILINESTRING) {
-      VELOX_USER_FAIL(fmt::format(
-          "First argument to line_locate_point must be a LineString or a MultiLineString. Got: {}",
-          line->getGeometryType()));
+      VELOX_USER_FAIL(
+          fmt::format(
+              "First argument to line_locate_point must be a LineString or a MultiLineString. Got: {}",
+              line->getGeometryType()));
     }
 
     auto pointType = point->getGeometryTypeId();
     if (pointType != geos::geom::GeometryTypeId::GEOS_POINT) {
-      VELOX_USER_FAIL(fmt::format(
-          "Second argument to line_locate_point must be a Point. Got: {}",
-          point->getGeometryType()));
+      VELOX_USER_FAIL(
+          fmt::format(
+              "Second argument to line_locate_point must be a Point. Got: {}",
+              point->getGeometryType()));
     }
 
     result = geos::linearref::LengthIndexedLine(line.get())
@@ -1516,11 +1672,13 @@ struct LineInterpolatePointFunction {
       const arg_type<Geometry>& inputLine,
       const arg_type<double>& fraction) {
     if (!(0.0 <= fraction && fraction <= 1.0)) {
-      return Status::UserError(fmt::format(
-          "line_interpolate_point: Fraction must be between 0 and 1, but is {}",
-          fraction));
+      return Status::UserError(
+          fmt::format(
+              "line_interpolate_point: Fraction must be between 0 and 1, but is {}",
+              fraction));
     }
-    auto line = geospatial::GeometryDeserializer::deserialize(inputLine);
+    auto line =
+        common::geospatial::GeometryDeserializer::deserialize(inputLine);
     Status validate = Status::OK();
     validate = geospatial::validateType(
         *line,
@@ -1532,7 +1690,7 @@ struct LineInterpolatePointFunction {
     }
 
     if (line->isEmpty()) {
-      geospatial::GeometrySerializer::serialize(
+      common::geospatial::GeometrySerializer::serialize(
           *(factory_->createPoint()), result);
     }
 
@@ -1542,7 +1700,7 @@ struct LineInterpolatePointFunction {
 
     auto resultPoint =
         std::unique_ptr<geos::geom::Point>(factory_->createPoint(coordinate));
-    geospatial::GeometrySerializer::serialize(*resultPoint, result);
+    common::geospatial::GeometrySerializer::serialize(*resultPoint, result);
 
     return validate;
   }
@@ -1559,7 +1717,7 @@ struct StInteriorRingsFunction {
       out_type<Array<Geometry>>& result,
       const arg_type<Geometry>& geometry) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
 
     auto validate = geospatial::validateType(
         *geosGeometry,
@@ -1582,7 +1740,7 @@ struct StInteriorRingsFunction {
     result.reserve(static_cast<int32_t>(numInteriorRings));
 
     for (int i = 0; i < numInteriorRings; i++) {
-      geospatial::GeometrySerializer::serialize(
+      common::geospatial::GeometrySerializer::serialize(
           *(polygon->getInteriorRingN(i)), result.add_item());
     }
 
@@ -1598,7 +1756,7 @@ struct StGeometriesFunction {
       out_type<Array<Geometry>>& result,
       const arg_type<Geometry>& geometry) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
 
     if (geosGeometry->isEmpty()) {
       return false;
@@ -1606,7 +1764,7 @@ struct StGeometriesFunction {
 
     if (!geospatial::isMultiType(*geosGeometry)) {
       result.reserve(1);
-      geospatial::GeometrySerializer::serialize(
+      common::geospatial::GeometrySerializer::serialize(
           *(geosGeometry), result.add_item());
       return true;
     }
@@ -1623,7 +1781,7 @@ struct StGeometriesFunction {
     result.reserve(numGeometries);
 
     for (int i = 0; i < numGeometries; i++) {
-      geospatial::GeometrySerializer::serialize(
+      common::geospatial::GeometrySerializer::serialize(
           *(geomCollection->getGeometryN(i)), result.add_item());
     }
 
@@ -1638,11 +1796,11 @@ struct FlattenGeometryCollectionsFunction {
   FOLLY_ALWAYS_INLINE Status
   call(out_type<Array<Geometry>>& result, const arg_type<Geometry>& geometry) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
 
     geospatial::GeometryCollectionIterator it(geosGeometry.get());
     while (it.hasNext()) {
-      geospatial::GeometrySerializer::serialize(
+      common::geospatial::GeometrySerializer::serialize(
           *(it.next()), result.add_item());
     }
 
@@ -1669,20 +1827,22 @@ struct ExpandEnvelopeFunction {
       return Status::UserError("Distance must be a non-negative number");
     }
     if (distance == std::numeric_limits<double>::infinity()) {
-      geospatial::GeometrySerializer::serialize(
+      common::geospatial::GeometrySerializer::serialize(
           *factory_->createPolygon(), result);
       return Status::OK();
     }
 
     const std::unique_ptr<geos::geom::Envelope> envelope =
-        geospatial::GeometryDeserializer::deserializeEnvelope(geometry);
+        common::geospatial::GeometryDeserializer::deserializeEnvelope(geometry);
     if (envelope->isNull()) {
-      geospatial::GeometrySerializer::serializeEnvelope(*envelope, result);
+      common::geospatial::GeometrySerializer::serializeEnvelope(
+          *envelope, result);
       return Status::OK();
     }
 
     envelope->expandBy(distance);
-    geospatial::GeometrySerializer::serializeEnvelope(*envelope, result);
+    common::geospatial::GeometrySerializer::serializeEnvelope(
+        *envelope, result);
 
     return Status::OK();
   }
@@ -1707,7 +1867,7 @@ struct BingTilePolygonFunction {
     double minY = BingTileType::tileYToLatitude(y, zoom);
     double maxY = BingTileType::tileYToLatitude(y + 1, zoom);
 
-    geospatial::GeometrySerializer::serializeEnvelope(
+    common::geospatial::GeometrySerializer::serializeEnvelope(
         minX, minY, maxX, maxY, result);
   }
 };
@@ -1720,7 +1880,7 @@ struct GeometryAsGeoJsonFunction {
       out_type<Varchar>& result,
       const arg_type<Geometry>& geometry) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::GeometryDeserializer::deserialize(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
     if (geospatial::isAtomicType(*geosGeometry) && geosGeometry->isEmpty()) {
       return false;
     }
@@ -1739,8 +1899,8 @@ struct GeometryFromGeoJsonFunction {
       out_type<Geometry>& result,
       const arg_type<Varchar>& geometry) {
     auto reader = geos::io::GeoJSONReader();
-    auto geosGeometry = reader.read(geometry);
-    geospatial::GeometrySerializer::serialize(*geosGeometry, result);
+    auto geosGeometry = reader.read(std::string(geometry));
+    common::geospatial::GeometrySerializer::serialize(*geosGeometry, result);
   }
 };
 
@@ -1791,14 +1951,14 @@ struct GeometryToBingTilesFunction {
     if (zoom < 0 || zoom > 23) {
       return Status::UserError("Zoom level must be between 0 and 23");
     }
-    auto envelope =
-        geospatial::GeometryDeserializer::deserializeEnvelope(geometry);
-    if (envelope->isNull()) {
+    auto geom =
+        common::geospatial::GeometryDeserializer::deserializeNonEmpty(geometry);
+    if (!geom) {
       return Status::OK();
     }
 
     std::vector<int64_t> covering;
-    auto geom = geospatial::GeometryDeserializer::deserialize(geometry);
+    const auto* envelope = geom->getEnvelopeInternal();
 
     if (geom->getGeometryTypeId() == geos::geom::GeometryTypeId::GEOS_POINT) {
       covering = geospatial::getMinimalTilesCoveringGeometry(*envelope, zoom);
@@ -1816,4 +1976,405 @@ struct GeometryToBingTilesFunction {
   }
 };
 
+template <typename T>
+struct GeometryToDissolvedBingTilesFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<Array<BingTile>>& result,
+      const arg_type<Geometry>& geometry,
+      const arg_type<int32_t>& zoom) {
+    if (zoom < 0 || zoom > 23) {
+      return Status::UserError("Zoom level must be between 0 and 23");
+    }
+    auto geom = common::geospatial::GeometryDeserializer::deserialize(geometry);
+    if (geom->isEmpty()) {
+      return Status::OK();
+    }
+
+    std::vector<int64_t> covering =
+        geospatial::getDissolvedTilesCoveringGeometry(*geom, zoom);
+
+    result.add_items(covering);
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct GeometryUnionFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+  GeometryUnionFunction() {
+    factory_ = geos::geom::GeometryFactory::create();
+  }
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Geometry>& result,
+      const arg_type<Array<Geometry>>& geometries) {
+    std::vector<std::unique_ptr<geos::geom::Geometry>> geometryVector;
+    if (geometries.size() == 0) {
+      return false;
+    }
+    // There seems to be a bug in the current version of geos where union with
+    // all empty geometries is returning incorrect results or even crashing.
+    // The isCompletelyEmpty check is a hack to avoid this case.
+    bool isCompletelyEmpty = true;
+
+    for (int i = 0; i < geometries.size(); i++) {
+      // Ignore null inputs
+      if (!geometries[i].has_value()) {
+        continue;
+      }
+      std::unique_ptr<geos::geom::Geometry> geosGeometry =
+          common::geospatial::GeometryDeserializer::deserialize(*geometries[i]);
+      if (!geosGeometry->isEmpty()) {
+        isCompletelyEmpty = false;
+      }
+      geometryVector.push_back(std::move(geosGeometry));
+    }
+
+    if (FOLLY_UNLIKELY(isCompletelyEmpty)) {
+      auto emptyCollection = factory_->createPolygon();
+      common::geospatial::GeometrySerializer::serialize(
+          *emptyCollection, result);
+      return true;
+    }
+
+    std::unique_ptr<geos::geom::Geometry> collection(
+        factory_->createGeometryCollection(std::move(geometryVector)));
+
+    // If geometry is not completely empty, we can proceed with union.
+    std::unique_ptr<geos::geom::Geometry> geomUnion = collection->Union();
+    common::geospatial::GeometrySerializer::serialize(*geomUnion, result);
+    return true;
+  }
+
+ private:
+  geos::geom::GeometryFactory::Ptr factory_;
+};
+
+template <typename T>
+struct StLineFromTextFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<Geometry>& result, const arg_type<Varchar>& wkt) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry;
+    GEOS_TRY(
+        {
+          geos::io::WKTReader reader;
+          geosGeometry = reader.read(std::string(wkt));
+        },
+        "Failed to parse WKT");
+    auto validate = geospatial::validateType(
+        *geosGeometry,
+        {geos::geom::GeometryTypeId::GEOS_LINESTRING},
+        "ST_LineFromText");
+
+    if (validate.ok()) {
+      common::geospatial::GeometrySerializer::serialize(*geosGeometry, result);
+    }
+
+    return validate;
+  }
+};
+
+template <typename T>
+struct StLineStringFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+  StLineStringFunction() {
+    factory_ = geos::geom::GeometryFactory::create();
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Geometry>& result,
+      const arg_type<Array<Geometry>>& input) {
+    std::unique_ptr<geos::geom::CoordinateArraySequence> coords =
+        common::geospatial::GeometryDeserializer::deserializePointsToCoordinate<
+            Geometry>(input, "ST_LineString", true);
+
+    std::unique_ptr<geos::geom::LineString> lineString;
+    if (input.size() < 2) {
+      lineString = factory_->createLineString();
+    } else {
+      lineString = factory_->createLineString(std::move(coords));
+    }
+    common::geospatial::GeometrySerializer::serialize(*lineString, result);
+  }
+
+ private:
+  geos::geom::GeometryFactory::Ptr factory_;
+};
+
+template <typename T>
+struct StMultiPointFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+  StMultiPointFunction() {
+    factory_ = geos::geom::GeometryFactory::create();
+  }
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Geometry>& result,
+      const arg_type<Array<Geometry>>& input) {
+    std::unique_ptr<geos::geom::CoordinateArraySequence> coords =
+        common::geospatial::GeometryDeserializer::deserializePointsToCoordinate<
+            Geometry>(input, "ST_MultiPoint", false);
+
+    if (coords->size() == 0) {
+      return false;
+    }
+
+    auto multiPoint = std::unique_ptr<geos::geom::MultiPoint>(
+        factory_->createMultiPoint(*coords));
+    common::geospatial::GeometrySerializer::serialize(*multiPoint, result);
+    return true;
+  }
+
+ private:
+  geos::geom::GeometryFactory::Ptr factory_;
+};
+
+template <typename T>
+struct ToGeometryFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Geometry>& result,
+      const arg_type<SphericalGeography>& input) {
+    // Every SphericalGeography object is a valid geometry object
+    result = input;
+  }
+};
+
+template <typename T>
+struct ToSphericalGeographyFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<SphericalGeography>& result, const arg_type<Geometry>& input) {
+    std::unique_ptr<geos::geom::Envelope> env =
+        common::geospatial::GeometryDeserializer::deserializeEnvelope(input);
+    Status status = Status::OK();
+    if (!env->isNull()) {
+      status =
+          geospatial::validateLatitudeLongitude(env->getMinY(), env->getMinX());
+      if (FOLLY_UNLIKELY(!status.ok())) {
+        return status;
+      }
+      status =
+          geospatial::validateLatitudeLongitude(env->getMaxY(), env->getMaxX());
+      if (FOLLY_UNLIKELY(!status.ok())) {
+        return status;
+      }
+    }
+
+    result = input;
+    return status;
+  }
+};
+
+template <typename T>
+struct StSphericalCentroidFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  StSphericalCentroidFunction() {
+    factory_ = geos::geom::GeometryFactory::create();
+  }
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<SphericalGeography>& result,
+      const arg_type<SphericalGeography>& input) {
+    std::unique_ptr<geos::geom::Geometry> geometry =
+        common::geospatial::GeometryDeserializer::deserialize(input);
+
+    if (geometry->isEmpty()) {
+      return false;
+    }
+
+    // Validate type is POINT or MULTI_POINT
+    auto validate = geospatial::validateType(
+        *geometry,
+        {geos::geom::GeometryTypeId::GEOS_POINT,
+         geos::geom::GeometryTypeId::GEOS_MULTIPOINT},
+        "ST_Centroid[SphericalGeography]");
+
+    if (!validate.ok()) {
+      VELOX_USER_FAIL(validate.message());
+    }
+
+    auto geometryType = geometry->getGeometryTypeId();
+    // Handle single point case
+    if (geometryType == geos::geom::GeometryTypeId::GEOS_POINT) {
+      common::geospatial::GeometrySerializer::serialize(*geometry, result);
+      return true;
+    }
+
+    const geos::geom::MultiPoint& multiPoint =
+        static_cast<const geos::geom::MultiPoint&>(*geometry);
+
+    // Compute the spherical centroid
+    auto centroidCoords = geospatial::computeSphericalCentroid(multiPoint);
+
+    // Create a Point geometry from the spherical coordinates
+    auto centroidPoint =
+        std::unique_ptr<geos::geom::Point>(factory_->createPoint(
+            geos::geom::Coordinate(
+                centroidCoords.first, centroidCoords.second)));
+
+    common::geospatial::GeometrySerializer::serialize(*centroidPoint, result);
+    return true;
+  }
+
+ private:
+  geos::geom::GeometryFactory::Ptr factory_;
+};
+
+template <typename T>
+struct StSphericalDistanceFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<double>& result,
+      const arg_type<SphericalGeography>& left,
+      const arg_type<SphericalGeography>& right) {
+    std::unique_ptr<geos::geom::Geometry> leftGeom =
+        common::geospatial::GeometryDeserializer::deserialize(left);
+    std::unique_ptr<geos::geom::Geometry> rightGeom =
+        common::geospatial::GeometryDeserializer::deserialize(right);
+
+    auto validateLeft = geospatial::validateType(
+        *leftGeom,
+        {geos::geom::GeometryTypeId::GEOS_POINT},
+        "ST_Distance[SphericalGeography]");
+    if (!validateLeft.ok()) {
+      VELOX_USER_FAIL(validateLeft.message());
+    };
+
+    auto validateRight = geospatial::validateType(
+        *rightGeom,
+        {geos::geom::GeometryTypeId::GEOS_POINT},
+        "ST_Distance[SphericalGeography]");
+    if (!validateRight.ok()) {
+      VELOX_USER_FAIL(validateRight.message());
+    }
+
+    if (leftGeom->isEmpty() || rightGeom->isEmpty()) {
+      return false;
+    }
+
+    geos::geom::Point* leftPoint =
+        static_cast<geos::geom::Point*>(leftGeom.get());
+    geos::geom::Point* rightPoint =
+        static_cast<geos::geom::Point*>(rightGeom.get());
+
+    result = BingTileType::greatCircleDistance(
+                 leftPoint->getY(),
+                 leftPoint->getX(),
+                 rightPoint->getY(),
+                 rightPoint->getX()) *
+        1000;
+
+    return true;
+  }
+};
+
+template <typename T>
+struct StSphericalLengthFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<double>& result,
+      const arg_type<SphericalGeography>& input) {
+    std::unique_ptr<geos::geom::Geometry> geom =
+        common::geospatial::GeometryDeserializer::deserialize(input);
+    if (geom->isEmpty()) {
+      return false;
+    }
+
+    auto validate = geospatial::validateType(
+        *geom,
+        {geos::geom::GeometryTypeId::GEOS_LINESTRING,
+         geos::geom::GeometryTypeId::GEOS_MULTILINESTRING},
+        "ST_Length[SphericalGeography]");
+
+    if (!validate.ok()) {
+      VELOX_USER_FAIL(validate.message());
+    }
+
+    double sum = 0.0;
+    if (geom->getGeometryTypeId() ==
+        geos::geom::GeometryTypeId::GEOS_LINESTRING) {
+      const geos::geom::LineString* lineString =
+          static_cast<const geos::geom::LineString*>(geom.get());
+      sum += geospatial::getSphericalLength(*lineString);
+
+    } else { // Multipoint
+      geos::geom::MultiLineString* multiLineString =
+          static_cast<geos::geom::MultiLineString*>(geom.get());
+      auto numLineStrings = multiLineString->getNumGeometries();
+      for (int i = 0; i < numLineStrings; i++) {
+        const geos::geom::LineString* lineString =
+            multiLineString->getGeometryN(i);
+        sum += geospatial::getSphericalLength(*lineString);
+      }
+    }
+
+    result = sum * 1000;
+    return true;
+  }
+};
+
+template <typename T>
+struct StSphericalAreaFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<double>& result,
+      const arg_type<SphericalGeography>& input) {
+    std::unique_ptr<geos::geom::Geometry> geom =
+        common::geospatial::GeometryDeserializer::deserialize(input);
+    if (geom->isEmpty()) {
+      return false;
+    }
+
+    auto validate = geospatial::validateType(
+        *geom,
+        {geos::geom::GeometryTypeId::GEOS_POLYGON,
+         geos::geom::GeometryTypeId::GEOS_MULTIPOLYGON},
+        "ST_Area[SphericalGeography]");
+    if (!validate.ok()) {
+      VELOX_USER_FAIL(validate.message());
+    }
+
+    double sphericalExcess = 0.0;
+    if (geom->getGeometryTypeId() == geos::geom::GEOS_POLYGON) {
+      geos::geom::Polygon* polygon =
+          static_cast<geos::geom::Polygon*>(geom.get());
+      // Single polygon: calculate excess for that polygon only
+      sphericalExcess = geospatial::computeSphericalExcess(*polygon);
+    } else if (geom->getGeometryTypeId() == geos::geom::GEOS_MULTIPOLYGON) {
+      geos::geom::MultiPolygon* multiPolygon =
+          static_cast<geos::geom::MultiPolygon*>(geom.get());
+      // MultiPolygon: calculate sum excess of all Polygons
+      auto polygonCount = multiPolygon->getNumGeometries();
+      for (int i = 0; i < polygonCount; i++) {
+        sphericalExcess +=
+            geospatial::computeSphericalExcess(*multiPolygon->getGeometryN(i));
+      }
+    } else {
+      VELOX_FAIL(
+          fmt::format(
+              "Unexpected failure in ST_Area initial type validation. Type: {}",
+              geom->getGeometryType()));
+    }
+
+    // abs is required here because for Polygons with a 2D area of 0
+    // isExteriorRing returns false for the exterior ring
+    result = std::abs(
+        (sphericalExcess * (BingTileType::kEarthRadiusKm * 1000.0) *
+         (BingTileType::kEarthRadiusKm * 1000.0)));
+
+    return true;
+  }
+};
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/GreatestLeast.h b/velox/functions/prestosql/GreatestLeast.h
index c4b04e95d54..5c9aa77d916 100644
--- a/velox/functions/prestosql/GreatestLeast.h
+++ b/velox/functions/prestosql/GreatestLeast.h
@@ -16,6 +16,7 @@
 #pragma once
 
 #include <cmath>
+#include <optional>
 #include "velox/expression/ComplexViewTypes.h"
 #include "velox/functions/Macros.h"
 
@@ -41,23 +42,32 @@ struct ExtremeValueFunction {
       out_type<T>& result,
       const arg_type<T>& firstElement,
       const arg_type<Variadic<T>>& remainingElement) {
-    auto currentValue = extractValue(firstElement);
+    // Track the winner: nullopt means firstElement, a value means index in
+    // remainingElement
+    std::optional<vector_size_t> winnerIdx;
 
-    for (auto element : remainingElement) {
-      auto candidateValue = extractValue(element.value());
+    for (size_t i = 0; i < remainingElement.size(); ++i) {
+      const auto& cur = remainingElement[i].value();
+      const auto& best = winnerIdx.has_value()
+          ? remainingElement[*winnerIdx].value()
+          : firstElement;
 
       if constexpr (isLeast) {
-        if (smallerThan(candidateValue, currentValue)) {
-          currentValue = candidateValue;
+        if (smallerThan(cur, best)) {
+          winnerIdx = i;
         }
       } else {
-        if (greaterThan(candidateValue, currentValue)) {
-          currentValue = candidateValue;
+        if (greaterThan(cur, best)) {
+          winnerIdx = i;
         }
       }
     }
 
-    result = currentValue;
+    if (!winnerIdx.has_value()) {
+      result = extractValue(firstElement);
+    } else {
+      result = extractValue(remainingElement[*winnerIdx].value());
+    }
   }
 
  private:
diff --git a/velox/functions/prestosql/HyperLogLogFunctions.h b/velox/functions/prestosql/HyperLogLogFunctions.h
index 8dc85d1ef58..93004a69c1b 100644
--- a/velox/functions/prestosql/HyperLogLogFunctions.h
+++ b/velox/functions/prestosql/HyperLogLogFunctions.h
@@ -18,6 +18,7 @@
 #include "velox/common/hyperloglog/DenseHll.h"
 #include "velox/common/hyperloglog/HllUtils.h"
 #include "velox/common/hyperloglog/SparseHll.h"
+#include "velox/common/memory/HashStringAllocator.h"
 #include "velox/functions/Macros.h"
 #include "velox/functions/prestosql/types/HyperLogLogType.h"
 
@@ -30,13 +31,10 @@ struct CardinalityFunction {
   FOLLY_ALWAYS_INLINE bool call(
       int64_t& result,
       const arg_type<HyperLogLog>& hll) {
-    using common::hll::DenseHll;
-    using common::hll::SparseHll;
-
-    if (SparseHll::canDeserialize(hll.data())) {
-      result = SparseHll::cardinality(hll.data());
+    if (common::hll::SparseHlls::canDeserialize(hll.data())) {
+      result = common::hll::SparseHlls::cardinality(hll.data());
     } else {
-      result = DenseHll::cardinality(hll.data());
+      result = common::hll::DenseHlls::cardinality(hll.data());
     }
     return true;
   }
@@ -48,7 +46,7 @@ struct EmptyApproxSetFunction {
 
   FOLLY_ALWAYS_INLINE bool call(out_type<HyperLogLog>& result) {
     static const std::string kEmpty =
-        common::hll::SparseHll::serializeEmpty(12);
+        common::hll::SparseHlls::serializeEmpty(12);
 
     result.resize(kEmpty.size());
     memcpy(result.data(), kEmpty.data(), kEmpty.size());
@@ -69,7 +67,7 @@ struct EmptyApproxSetWithMaxErrorFunction {
         maxStandardError,
         "empty_approx_set function requires constant value for maxStandardError argument");
     common::hll::checkMaxStandardError(*maxStandardError);
-    serialized_ = common::hll::SparseHll::serializeEmpty(
+    serialized_ = common::hll::SparseHlls::serializeEmpty(
         common::hll::toIndexBitLength(*maxStandardError));
   }
 
@@ -81,4 +79,118 @@ struct EmptyApproxSetWithMaxErrorFunction {
     return true;
   }
 };
+
+template <typename T>
+struct MergeHllFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<Array<HyperLogLog>>* /*constantArg*/) {
+    VELOX_USER_CHECK_NOT_NULL(
+        pool, "merge_hll requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<HyperLogLog>& result,
+      const arg_type<Array<HyperLogLog>>& hllArray) {
+    using SparseHll = common::hll::SparseHll<HashStringAllocator>;
+    using DenseHll = common::hll::DenseHll<HashStringAllocator>;
+
+    std::optional<int8_t> indexBitLength;
+    std::optional<SparseHll> sparseHll;
+    std::optional<DenseHll> denseHll;
+
+    for (const auto& hllData : hllArray) {
+      // Skip null elements
+      if (!hllData.has_value()) {
+        continue;
+      }
+
+      // Skip empty HLL data
+      const auto& hllValue = hllData.value();
+      if (hllValue.empty()) {
+        continue;
+      }
+
+      const bool isSparseHllData =
+          common::hll::SparseHlls::canDeserialize(hllValue.data());
+      const bool isDenseHllData = !isSparseHllData &&
+          common::hll::DenseHlls::canDeserialize(hllValue.data());
+
+      VELOX_USER_CHECK(
+          isSparseHllData || isDenseHllData, "Invalid HLL data format");
+
+      const auto hllIndexBitLength = isSparseHllData
+          ? common::hll::SparseHlls::deserializeIndexBitLength(hllValue.data())
+          : common::hll::DenseHlls::deserializeIndexBitLength(hllValue.data());
+
+      if (indexBitLength.has_value()) {
+        VELOX_USER_CHECK_EQ(
+            indexBitLength.value(),
+            hllIndexBitLength,
+            "Cannot merge HLLs with different indexBitLength");
+      } else {
+        indexBitLength = hllIndexBitLength;
+      }
+
+      if (isSparseHllData) {
+        if (denseHll.has_value()) {
+          SparseHll temp{hllValue.data(), allocator_.get()};
+          temp.toDense(*denseHll);
+        } else {
+          if (!sparseHll.has_value()) {
+            sparseHll.emplace(allocator_.get());
+            sparseHll->setSoftMemoryLimit(
+                common::hll::DenseHlls::estimateInMemorySize(
+                    indexBitLength.value()));
+          }
+
+          sparseHll->mergeWith(hllValue.data());
+          if (sparseHll->overLimit()) {
+            denseHll.emplace(allocator_.get());
+            denseHll->initialize(indexBitLength.value());
+            sparseHll->toDense(*denseHll);
+            sparseHll.reset();
+          }
+        }
+      } else {
+        if (sparseHll.has_value()) {
+          denseHll.emplace(allocator_.get());
+          denseHll->initialize(indexBitLength.value());
+          sparseHll->toDense(*denseHll);
+          sparseHll.reset();
+        } else if (!denseHll.has_value()) {
+          denseHll.emplace(allocator_.get());
+          denseHll->initialize(indexBitLength.value());
+        }
+        denseHll->mergeWith(hllValue.data());
+      }
+    }
+
+    // Return null if no valid HLLs were merged
+    if (!sparseHll.has_value() && !denseHll.has_value()) {
+      return false;
+    }
+
+    // Serialize the result
+    if (sparseHll.has_value()) {
+      auto size = sparseHll->serializedSize();
+      result.resize(size);
+      sparseHll->serialize(indexBitLength.value(), result.data());
+    } else {
+      auto size = denseHll->serializedSize();
+      result.resize(size);
+      denseHll->serialize(result.data());
+    }
+
+    return true;
+  }
+};
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/IPAddressFunctions.h b/velox/functions/prestosql/IPAddressFunctions.h
index 6339fdfbcb8..d12cf1a4404 100644
--- a/velox/functions/prestosql/IPAddressFunctions.h
+++ b/velox/functions/prestosql/IPAddressFunctions.h
@@ -69,7 +69,8 @@ struct IPPrefixFunction {
       out_type<IPPrefix>& result,
       const arg_type<Varchar>& ipString,
       const arg_type<int64_t>& prefixBits) {
-    auto tryIp = folly::IPAddress::tryFromString(ipString);
+    // TODO: Remove explicit std::string_view cast.
+    auto tryIp = folly::IPAddress::tryFromString(std::string_view(ipString));
     if (tryIp.hasError()) {
       VELOX_USER_FAIL("Cannot cast value to IPADDRESS: {}", ipString);
     }
@@ -195,8 +196,9 @@ struct IPPrefixCollapseFunction {
 
     for (const auto& ipPrefix : ipPrefixes) {
       if (ipPrefix.has_value()) {
-        prefixes.push_back(std::make_tuple(
-            *ipPrefix->template at<0>(), *ipPrefix->template at<1>()));
+        prefixes.push_back(
+            std::make_tuple(
+                *ipPrefix->template at<0>(), *ipPrefix->template at<1>()));
       } else {
         // ip_prefix_collapse does not support null elements. Thus we throw here
         // with the same error message as Presto java.
@@ -423,10 +425,11 @@ struct IPPrefixSubnetsFunction {
 
     if (newPrefixLength < 0 || (inputIsIpV4 && newPrefixLength > 32) ||
         (!inputIsIpV4 && newPrefixLength > 128)) {
-      VELOX_USER_FAIL(fmt::format(
-          "Invalid prefix length for IPv{}: {}",
-          inputIsIpV4 ? 4 : 6,
-          newPrefixLength));
+      VELOX_USER_FAIL(
+          fmt::format(
+              "Invalid prefix length for IPv{}: {}",
+              inputIsIpV4 ? 4 : 6,
+              newPrefixLength));
     }
 
     int8_t inputPrefixLength = *prefix.template at<1>();
@@ -599,6 +602,40 @@ struct IsPrivateIPFunction {
   }
 };
 
+template <typename T>
+struct IPVersionFromIPAddressFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<int64_t>& result,
+      const arg_type<IPAddress>& ip) {
+    result = isIPv4(*ip) ? 4 : 6;
+  }
+};
+
+template <typename T>
+struct IPVersionFromIPPrefixFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<int64_t>& result,
+      const arg_type<IPPrefix>& ipPrefix) {
+    result = isIPv4(*ipPrefix.template at<0>()) ? 4 : 6;
+  }
+};
+
+template <typename T>
+struct IPPrefixMaskLenFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<int64_t>& result,
+      const arg_type<IPPrefix>& ipPrefix) {
+    result =
+        static_cast<int64_t>(static_cast<uint8_t>(*ipPrefix.template at<1>()));
+  }
+};
+
 void registerIPAddressFunctions(const std::string& prefix) {
   registerIPAddressType();
   registerIPPrefixType();
@@ -622,6 +659,12 @@ void registerIPAddressFunctions(const std::string& prefix) {
       {prefix + "ip_prefix_subnets"});
   registerFunction<IsPrivateIPFunction, bool, IPAddress>(
       {prefix + "is_private_ip"});
+  registerFunction<IPVersionFromIPAddressFunction, int64_t, IPAddress>(
+      {prefix + "ip_version"});
+  registerFunction<IPVersionFromIPPrefixFunction, int64_t, IPPrefix>(
+      {prefix + "ip_version"});
+  registerFunction<IPPrefixMaskLenFunction, int64_t, IPPrefix>(
+      {prefix + "ip_prefix_masklen"});
 }
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/IntegerFunctions.h b/velox/functions/prestosql/IntegerFunctions.h
index 3608c09af3b..de99e5c0e7f 100644
--- a/velox/functions/prestosql/IntegerFunctions.h
+++ b/velox/functions/prestosql/IntegerFunctions.h
@@ -15,8 +15,7 @@
  */
 #pragma once
 
-#define XXH_INLINE_ALL
-#include <xxhash.h>
+#include "velox/common/base/XxHashInline.h"
 
 #include "velox/functions/Udf.h"
 #include "velox/type/Type.h"
diff --git a/velox/functions/prestosql/JsonFunctions.cpp b/velox/functions/prestosql/JsonFunctions.cpp
index bf7774cda86..2c9141bf12b 100644
--- a/velox/functions/prestosql/JsonFunctions.cpp
+++ b/velox/functions/prestosql/JsonFunctions.cpp
@@ -33,6 +33,12 @@ template <typename T>
 static simdjson::error_code validate(T value) {
   SIMDJSON_ASSIGN_OR_RAISE(auto type, value.type());
   switch (type) {
+    case simdjson::ondemand::json_type::unknown: {
+      // In simdjson 4.0.7+, unknown type is returned for invalid JSON values
+      // like NaN, Infinity, etc. Return INCORRECT_TYPE to indicate invalid
+      // JSON.
+      return simdjson::INCORRECT_TYPE;
+    }
     case simdjson::ondemand::json_type::array: {
       SIMDJSON_ASSIGN_OR_RAISE(auto array, value.get_array());
       for (auto elementOrError : array) {
@@ -389,6 +395,12 @@ class JsonParseImpl {
   simdjson::error_code generateViews(T value) const {
     SIMDJSON_ASSIGN_OR_RAISE(auto type, value.type());
     switch (type) {
+      case simdjson::ondemand::json_type::unknown: {
+        // In simdjson 4.0.7+, unknown type is returned for invalid JSON values
+        // like NaN, Infinity, etc. Return INCORRECT_TYPE to indicate invalid
+        // JSON.
+        return simdjson::INCORRECT_TYPE;
+      }
       case simdjson::ondemand::json_type::array: {
         SIMDJSON_ASSIGN_OR_RAISE(auto array, value.get_array());
         return generateViewsFromArray<kNeedNormalize>(array);
@@ -761,6 +773,12 @@ struct JsonExtractImpl {
       // contents directly) and we might miss invalid JSON.
       SIMDJSON_ASSIGN_OR_RAISE(auto vtype, v.type());
       switch (vtype) {
+        case simdjson::ondemand::json_type::unknown: {
+          // In simdjson 4.0.7+, unknown type is returned for invalid JSON
+          // values like NaN, Infinity, etc. Return INCORRECT_TYPE to indicate
+          // invalid JSON.
+          return simdjson::INCORRECT_TYPE;
+        }
         case simdjson::ondemand::json_type::object: {
           SIMDJSON_ASSIGN_OR_RAISE(
               auto jsonStr, simdjson::to_json_string(v.get_object()));
@@ -787,7 +805,9 @@ struct JsonExtractImpl {
       return simdjson::SUCCESS;
     };
 
-    auto& extractor = SIMDJsonExtractor::getInstance(jsonPath);
+    // TODO: Remove explicit std::string_view cast.
+    auto& extractor =
+        SIMDJsonExtractor::getInstance(std::string_view(jsonPath));
     bool isDefinitePath = true;
     simdjson::padded_string paddedJson(json.data(), json.size());
 
diff --git a/velox/functions/prestosql/JsonFunctions.h b/velox/functions/prestosql/JsonFunctions.h
index 4c8a1491a62..608eb2cd48c 100644
--- a/velox/functions/prestosql/JsonFunctions.h
+++ b/velox/functions/prestosql/JsonFunctions.h
@@ -241,7 +241,9 @@ struct JsonExtractScalarFunction {
       return simdjson::SUCCESS;
     };
 
-    auto& extractor = SIMDJsonExtractor::getInstance(jsonPath);
+    // TODO: Remove explicit std::string_view cast.
+    auto& extractor =
+        SIMDJsonExtractor::getInstance(std::string_view(jsonPath));
 
     // Check for valid json
     simdjson::padded_string paddedJson(json.data(), json.size());
@@ -303,12 +305,17 @@ struct JsonSizeFunction {
           case simdjson::ondemand::json_type::null:
             singleResultSize = 0;
             break;
+          case simdjson::ondemand::json_type::unknown: {
+            return simdjson::INCORRECT_TYPE;
+          }
         }
       }
       return simdjson::SUCCESS;
     };
 
-    auto& extractor = SIMDJsonExtractor::getInstance(jsonPath);
+    // TODO: Remove explicit std::string_view cast.
+    auto& extractor =
+        SIMDJsonExtractor::getInstance(std::string_view(jsonPath));
     bool isDefinitePath = true;
     simdjson::padded_string paddedJson(json.data(), json.size());
     SIMDJSON_TRY(extractor.extract(paddedJson, consumer, isDefinitePath));
diff --git a/velox/functions/prestosql/KHyperLogLogFunctions.h b/velox/functions/prestosql/KHyperLogLogFunctions.h
new file mode 100644
index 00000000000..32ddf9ce7da
--- /dev/null
+++ b/velox/functions/prestosql/KHyperLogLogFunctions.h
@@ -0,0 +1,351 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/common/base/Status.h"
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/core/QueryConfig.h"
+#include "velox/functions/Macros.h"
+#include "velox/functions/lib/KHyperLogLog.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+
+namespace facebook::velox::functions {
+
+template <typename T>
+struct KHyperLogLogCardinalityFunction {
+  using KHyperLogLogUtils =
+      common::hll::KHyperLogLog<int64_t, HashStringAllocator>;
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<KHyperLogLog>* /*constantArg*/) {
+    VELOX_CHECK_NOT_NULL(
+        pool,
+        "KHyperLogLog cardinality requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE Status
+  call(int64_t& result, const arg_type<KHyperLogLog>& khllData) {
+    auto khllInstance = KHyperLogLogUtils::deserialize(
+        khllData.data(), khllData.size(), allocator_.get());
+    if (khllInstance.hasError()) {
+      return khllInstance.error();
+    }
+    result = khllInstance.value()->cardinality();
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct KHyperLogLogIntersectionCardinalityFunction {
+  using KHyperLogLogUtils =
+      common::hll::KHyperLogLog<int64_t, HashStringAllocator>;
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<KHyperLogLog>* /*constantArg1*/,
+      const arg_type<KHyperLogLog>* /*constantArg2*/) {
+    VELOX_CHECK_NOT_NULL(
+        pool,
+        "KHyperLogLog intersection_cardinality requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      int64_t& result,
+      const arg_type<KHyperLogLog>& khll1Data,
+      const arg_type<KHyperLogLog>& khll2Data) {
+    auto khll1Instance = KHyperLogLogUtils::deserialize(
+        khll1Data.data(), khll1Data.size(), allocator_.get());
+    if (khll1Instance.hasError()) {
+      return khll1Instance.error();
+    }
+    auto khll1 = std::move(khll1Instance.value());
+    auto khll2Instance = KHyperLogLogUtils::deserialize(
+        khll2Data.data(), khll2Data.size(), allocator_.get());
+    if (khll2Instance.hasError()) {
+      return khll2Instance.error();
+    }
+    auto khll2 = std::move(khll2Instance.value());
+
+    // If both khlls are exact, return the exact intersection cardinality.
+    if (khll1->isExact() && khll2->isExact()) {
+      result = KHyperLogLogUtils::exactIntersectionCardinality(*khll1, *khll2);
+      return Status::OK();
+    }
+
+    // If either of the khlls are not exact, return an approximation of the
+    // intersection cardinality using the Jaccard Index like a similarity
+    // index between the 2 key sets.
+    int64_t lowestCardinality =
+        std::min(khll1->cardinality(), khll2->cardinality());
+    double jaccard = KHyperLogLogUtils::jaccardIndex(*khll1, *khll2);
+    auto setUnion =
+        KHyperLogLogUtils::merge(std::move(khll1), std::move(khll2));
+    int64_t computedResult =
+        static_cast<int64_t>(std::round(jaccard * setUnion->cardinality()));
+
+    // In a special case where one set is much smaller and almost a true
+    // subset of the other, return the size of the smaller set. For example:
+    // Set1 = {1,2,3,4,5,6}
+    // Set2 = {1,2}
+    // Jaccard Index = 1
+    // Approximated intersection cardinality = 6
+    // This result does not make sense as Set2 does not even have 6
+    // elements. Thus return 2 instead.
+    result = std::min(computedResult, lowestCardinality);
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct KHyperLogLogJaccardIndexFunction {
+  using KHyperLogLogUtils =
+      common::hll::KHyperLogLog<int64_t, HashStringAllocator>;
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<KHyperLogLog>* /*constantArg1*/,
+      const arg_type<KHyperLogLog>* /*constantArg2*/) {
+    VELOX_CHECK_NOT_NULL(
+        pool,
+        "KHyperLogLog jaccard_index requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      double& result,
+      const arg_type<KHyperLogLog>& khll1Data,
+      const arg_type<KHyperLogLog>& khll2Data) {
+    auto khll1Instance = KHyperLogLogUtils::deserialize(
+        khll1Data.data(), khll1Data.size(), allocator_.get());
+    if (khll1Instance.hasError()) {
+      return khll1Instance.error();
+    }
+    auto khll2Instance = KHyperLogLogUtils::deserialize(
+        khll2Data.data(), khll2Data.size(), allocator_.get());
+    if (khll2Instance.hasError()) {
+      return khll2Instance.error();
+    }
+
+    result = KHyperLogLogUtils::jaccardIndex(
+        *khll1Instance.value(), *khll2Instance.value());
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct KHyperLogLogReidentificationPotentialFunction {
+  using KHyperLogLogUtils =
+      common::hll::KHyperLogLog<int64_t, HashStringAllocator>;
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<KHyperLogLog>* /*constantArg1*/,
+      const int64_t* /*constantArg2*/) {
+    VELOX_CHECK_NOT_NULL(
+        pool,
+        "KHyperLogLog reidentification_potential requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      double& result,
+      const arg_type<KHyperLogLog>& khllData,
+      int64_t threshold) {
+    auto khllInstance = KHyperLogLogUtils::deserialize(
+        khllData.data(), khllData.size(), allocator_.get());
+    if (khllInstance.hasError()) {
+      return khllInstance.error();
+    }
+    result = khllInstance.value()->reidentificationPotential(threshold);
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct KHyperLogLogUniquenessDistributionFunction {
+  using KHyperLogLogUtils =
+      common::hll::KHyperLogLog<int64_t, HashStringAllocator>;
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<KHyperLogLog>* /*constantArg*/) {
+    VELOX_CHECK_NOT_NULL(
+        pool,
+        "KHyperLogLog uniqueness_distribution requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<KHyperLogLog>* /*constantArg1*/,
+      const int64_t* /*constantArg2*/) {
+    VELOX_CHECK_NOT_NULL(
+        pool,
+        "KHyperLogLog uniqueness_distribution requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<Map<int64_t, double>>& result,
+      const arg_type<KHyperLogLog>& khllData) {
+    // When histogramSize is not provided, use the minhash size of the KHLL
+    // instance as the default.
+    auto khllInstance = KHyperLogLogUtils::deserialize(
+        khllData.data(), khllData.size(), allocator_.get());
+    if (khllInstance.hasError()) {
+      return khllInstance.error();
+    }
+    int64_t histogramSize =
+        static_cast<int64_t>(khllInstance.value()->minhashSize());
+    return uniquenessDistribution(result, *khllInstance.value(), histogramSize);
+  }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<Map<int64_t, double>>& result,
+      const arg_type<KHyperLogLog>& khllData,
+      int64_t histogramSize) {
+    auto khllInstance = KHyperLogLogUtils::deserialize(
+        khllData.data(), khllData.size(), allocator_.get());
+    if (khllInstance.hasError()) {
+      return khllInstance.error();
+    }
+    return uniquenessDistribution(result, *khllInstance.value(), histogramSize);
+  }
+
+ private:
+  FOLLY_ALWAYS_INLINE Status uniquenessDistribution(
+      out_type<Map<int64_t, double>>& result,
+      KHyperLogLogUtils& khll,
+      int64_t histogramSize) {
+    auto distribution = khll.uniquenessDistribution(histogramSize);
+
+    // Sort the distribution by key to ensure sorted output
+    std::vector<std::pair<int64_t, double>> sortedDistribution(
+        distribution.begin(), distribution.end());
+    std::sort(
+        sortedDistribution.begin(),
+        sortedDistribution.end(),
+        [](const auto& a, const auto& b) { return a.first < b.first; });
+
+    // Populate the result map
+    for (const auto& [key, value] : sortedDistribution) {
+      result.add_item() = std::make_tuple(key, value);
+    }
+
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct MergeKHyperLogLogFunction {
+  using KHyperLogLogUtils =
+      common::hll::KHyperLogLog<int64_t, HashStringAllocator>;
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<Array<KHyperLogLog>>* /*constantArg*/) {
+    VELOX_CHECK_NOT_NULL(
+        pool,
+        "KHyperLogLog merge_khll requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<KHyperLogLog>& result,
+      const arg_type<Array<KHyperLogLog>>& hllArray) {
+    std::unique_ptr<KHyperLogLogUtils> merged = nullptr;
+
+    for (const auto& khllData : hllArray) {
+      // Skip null elements
+      if (!khllData.has_value()) {
+        continue;
+      }
+
+      // Skip empty HLL data
+      const auto& khllValue = khllData.value();
+      if (khllValue.empty()) {
+        continue;
+      }
+
+      if (!merged) {
+        // Initialize with first non-null element.
+        auto deserializeResult = KHyperLogLogUtils::deserialize(
+            khllValue.data(), khllValue.size(), allocator_.get());
+        VELOX_CHECK(
+            deserializeResult.hasValue(),
+            "Failed to deserialize KHyperLogLog: {}",
+            deserializeResult.error().message());
+        merged = std::move(deserializeResult.value());
+      } else {
+        auto currentKhll = KHyperLogLogUtils::deserialize(
+            khllValue.data(), khllValue.size(), allocator_.get());
+        VELOX_CHECK(
+            currentKhll.hasValue(),
+            "Failed to deserialize KHyperLogLog: {}",
+            currentKhll.error().message());
+        merged->mergeWith(*currentKhll.value());
+      }
+    }
+
+    // Return null if all elements were null.
+    if (!merged) {
+      return false;
+    }
+
+    size_t serializedSize = merged->estimatedSerializedSize();
+    result.resize(serializedSize);
+    merged->serialize(result.data());
+
+    return true;
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/L2Norm.h b/velox/functions/prestosql/L2Norm.h
new file mode 100644
index 00000000000..31c1cfd7a25
--- /dev/null
+++ b/velox/functions/prestosql/L2Norm.h
@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cmath>
+
+#include <folly/CPortability.h>
+#include "velox/functions/Macros.h"
+#include "velox/type/SimpleFunctionApi.h"
+
+namespace facebook::velox::functions {
+
+/// L2_NORM function for arrays.
+/// Calculates the Euclidean norm (L2 norm) of an array: sqrt(sum(x^2))
+/// Returns the L2 norm as a double.
+///
+/// Function Signature:
+///   L2_NORM(ARRAY<T>) -> DOUBLE where T is numeric
+///
+/// Behavior:
+///   - Returns 0.0 for empty arrays
+///   - Returns null if the input array is null
+///   - Null elements in the array are skipped (not included in calculation)
+///   - Supports all numeric types (int, float, double)
+template <typename TExec>
+struct ArrayL2NormFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename TInput>
+  FOLLY_ALWAYS_INLINE bool call(double& out, const TInput& inputArray) {
+    if (inputArray.size() == 0) {
+      out = 0.0;
+      return true;
+    }
+
+    double maxAbs = 0.0;
+    for (const auto& item : inputArray) {
+      if (item.has_value()) {
+        maxAbs = std::max(maxAbs, std::abs(static_cast<double>(item.value())));
+      }
+    }
+
+    if (maxAbs == 0.0) {
+      out = 0.0;
+      return true;
+    }
+
+    double sumOfSquares = 0.0;
+    for (const auto& item : inputArray) {
+      if (item.has_value()) {
+        auto scaled = static_cast<double>(item.value()) / maxAbs;
+        sumOfSquares += scaled * scaled;
+      }
+    }
+
+    out = maxAbs * std::sqrt(sumOfSquares);
+    return true;
+  }
+
+  template <typename TInput>
+  FOLLY_ALWAYS_INLINE bool callNullFree(double& out, const TInput& inputArray) {
+    if (inputArray.size() == 0) {
+      out = 0.0;
+      return true;
+    }
+
+    double maxAbs = 0.0;
+    for (const auto& item : inputArray) {
+      maxAbs = std::max(maxAbs, std::abs(static_cast<double>(item)));
+    }
+
+    if (maxAbs == 0.0) {
+      out = 0.0;
+      return true;
+    }
+
+    double sumOfSquares = 0.0;
+    for (const auto& item : inputArray) {
+      auto scaled = static_cast<double>(item) / maxAbs;
+      sumOfSquares += scaled * scaled;
+    }
+
+    out = maxAbs * std::sqrt(sumOfSquares);
+    return true;
+  }
+};
+
+/// L2_NORM function for maps.
+/// Calculates the Euclidean norm (L2 norm) of map values: sqrt(sum(v^2))
+/// Returns the L2 norm as a double.
+///
+/// Function Signature:
+///   L2_NORM(MAP<K, V>) -> DOUBLE where V is numeric
+///
+/// Behavior:
+///   - Returns 0.0 for empty maps
+///   - Returns null if the input map is null
+///   - Null values in the map are skipped (not included in calculation)
+///   - Keys are ignored, only values are used
+template <typename TExec, typename K, typename V>
+struct MapL2NormFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      double& out,
+      const arg_type<Map<K, V>>& inputMap) {
+    if (inputMap.size() == 0) {
+      out = 0.0;
+      return true;
+    }
+
+    double maxAbs = 0.0;
+    for (const auto& entry : inputMap) {
+      if (entry.second.has_value()) {
+        maxAbs = std::max(
+            maxAbs, std::abs(static_cast<double>(entry.second.value())));
+      }
+    }
+
+    if (maxAbs == 0.0) {
+      out = 0.0;
+      return true;
+    }
+
+    double sumOfSquares = 0.0;
+    for (const auto& entry : inputMap) {
+      if (entry.second.has_value()) {
+        auto scaled = static_cast<double>(entry.second.value()) / maxAbs;
+        sumOfSquares += scaled * scaled;
+      }
+    }
+
+    out = maxAbs * std::sqrt(sumOfSquares);
+    return true;
+  }
+
+  FOLLY_ALWAYS_INLINE bool callNullFree(
+      double& out,
+      const null_free_arg_type<Map<K, V>>& inputMap) {
+    if (inputMap.size() == 0) {
+      out = 0.0;
+      return true;
+    }
+
+    double maxAbs = 0.0;
+    for (const auto& entry : inputMap) {
+      maxAbs = std::max(maxAbs, std::abs(static_cast<double>(entry.second)));
+    }
+
+    if (maxAbs == 0.0) {
+      out = 0.0;
+      return true;
+    }
+
+    double sumOfSquares = 0.0;
+    for (const auto& entry : inputMap) {
+      auto scaled = static_cast<double>(entry.second) / maxAbs;
+      sumOfSquares += scaled * scaled;
+    }
+
+    out = maxAbs * std::sqrt(sumOfSquares);
+    return true;
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/Map.cpp b/velox/functions/prestosql/Map.cpp
index e24fadd467b..e9e28068c33 100644
--- a/velox/functions/prestosql/Map.cpp
+++ b/velox/functions/prestosql/Map.cpp
@@ -359,7 +359,7 @@ class MapFunction : public exec::VectorFunction {
   void checkDuplicateConstantKeys(
       const std::vector<vector_size_t>& sortedIndices,
       const VectorPtr& keysElements) const {
-    static const char* kDuplicateKey =
+    static constexpr const char* kDuplicateKey =
         "Duplicate map keys ({}) are not allowed";
 
     if (auto duplicateIndex = findDuplicateKeys(sortedIndices, keysElements)) {
diff --git a/velox/functions/prestosql/MapAppend.h b/velox/functions/prestosql/MapAppend.h
new file mode 100644
index 00000000000..501c3eca444
--- /dev/null
+++ b/velox/functions/prestosql/MapAppend.h
@@ -0,0 +1,271 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/ComplexViewTypes.h"
+#include "velox/functions/Macros.h"
+#include "velox/type/FloatingPointUtil.h"
+
+namespace facebook::velox::functions {
+
+/// Fast path for primitive type keys: map_append(m, array[1, 2], array[10,
+/// 20]).
+template <typename TExec, typename Key>
+struct MapAppendPrimitiveFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      out_type<Map<Key, Generic<T1>>>& out,
+      const arg_type<Map<Key, Generic<T1>>>& inputMap,
+      const arg_type<Array<Key>>& keys,
+      const arg_type<Array<Generic<T1>>>& values) {
+    // Check that keys and values arrays have the same size
+    VELOX_USER_CHECK_EQ(
+        keys.size(),
+        values.size(),
+        "Keys and values arrays must have the same length");
+
+    // Build a set of existing keys for fast lookup
+    util::floating_point::HashSetNaNAware<arg_type<Key>> existingKeys;
+    for (const auto& entry : inputMap) {
+      existingKeys.emplace(entry.first);
+    }
+
+    // Build a set of new keys to check for duplicates and verify they don't
+    // exist
+    util::floating_point::HashSetNaNAware<arg_type<Key>> newKeys;
+
+    auto keysIt = keys.begin();
+    auto valuesIt = values.begin();
+
+    for (; keysIt != keys.end(); ++keysIt, ++valuesIt) {
+      if (keysIt->has_value()) {
+        const auto& key = keysIt->value();
+
+        // Check if key already exists in the input map
+        VELOX_USER_CHECK(
+            !existingKeys.contains(key), "Key already exists in the map");
+
+        // Check for duplicate keys in the new keys array
+        VELOX_USER_CHECK(
+            newKeys.emplace(key).second, "Duplicate key in keys array");
+      }
+    }
+
+    // First, copy all existing entries from the input map
+    for (const auto& entry : inputMap) {
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        keyWriter = entry.first;
+      } else {
+        auto [keyWriter, valueWriter] = out.add_item();
+        keyWriter = entry.first;
+        valueWriter.copy_from(entry.second.value());
+      }
+    }
+
+    // Then, add new entries from keys and values arrays
+    keysIt = keys.begin();
+    valuesIt = values.begin();
+
+    for (; keysIt != keys.end(); ++keysIt, ++valuesIt) {
+      if (keysIt->has_value()) {
+        if (!valuesIt->has_value()) {
+          auto& keyWriter = out.add_null();
+          keyWriter = keysIt->value();
+        } else {
+          auto [keyWriter, valueWriter] = out.add_item();
+          keyWriter = keysIt->value();
+          valueWriter.copy_from(valuesIt->value());
+        }
+      }
+    }
+  }
+};
+
+/// String version for varchar keys.
+template <typename TExec>
+struct MapAppendVarcharFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      out_type<Map<Varchar, Generic<T1>>>& out,
+      const arg_type<Map<Varchar, Generic<T1>>>& inputMap,
+      const arg_type<Array<Varchar>>& keys,
+      const arg_type<Array<Generic<T1>>>& values) {
+    // Check that keys and values arrays have the same size
+    VELOX_USER_CHECK_EQ(
+        keys.size(),
+        values.size(),
+        "Keys and values arrays must have the same length");
+
+    // Build a set of existing keys for fast lookup
+    folly::F14FastSet<StringView> existingKeys;
+    for (const auto& entry : inputMap) {
+      existingKeys.emplace(entry.first);
+    }
+
+    // Build a set of new keys to check for duplicates and verify they don't
+    // exist
+    folly::F14FastSet<StringView> newKeys;
+
+    auto keysIt = keys.begin();
+    auto valuesIt = values.begin();
+
+    for (; keysIt != keys.end(); ++keysIt, ++valuesIt) {
+      if (keysIt->has_value()) {
+        const auto& key = keysIt->value();
+
+        // Check if key already exists in the input map
+        VELOX_USER_CHECK(
+            !existingKeys.contains(key), "Key already exists in the map");
+
+        // Check for duplicate keys in the new keys array
+        VELOX_USER_CHECK(
+            newKeys.emplace(key).second, "Duplicate key in keys array");
+      }
+    }
+
+    // First, copy all existing entries from the input map
+    for (const auto& entry : inputMap) {
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        keyWriter.copy_from(entry.first);
+      } else {
+        auto [keyWriter, valueWriter] = out.add_item();
+        keyWriter.copy_from(entry.first);
+        valueWriter.copy_from(entry.second.value());
+      }
+    }
+
+    // Then, add new entries from keys and values arrays
+    keysIt = keys.begin();
+    valuesIt = values.begin();
+
+    for (; keysIt != keys.end(); ++keysIt, ++valuesIt) {
+      if (keysIt->has_value()) {
+        if (!valuesIt->has_value()) {
+          auto& keyWriter = out.add_null();
+          keyWriter.copy_from(keysIt->value());
+        } else {
+          auto [keyWriter, valueWriter] = out.add_item();
+          keyWriter.copy_from(keysIt->value());
+          valueWriter.copy_from(valuesIt->value());
+        }
+      }
+    }
+  }
+};
+
+struct MapAppendFunctionEqualComparator {
+  bool operator()(const exec::GenericView& lhs, const exec::GenericView& rhs)
+      const {
+    static constexpr auto kEqualValueAtFlags = CompareFlags::equality(
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+
+    auto result = lhs.compare(rhs, kEqualValueAtFlags);
+
+    VELOX_USER_CHECK(
+        result.has_value(), "Comparison on null elements is not supported");
+
+    return result.value() == 0;
+  }
+};
+
+/// Generic implementation for complex types.
+template <typename TExec>
+struct MapAppendFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      out_type<Map<Generic<T1>, Generic<T2>>>& out,
+      const arg_type<Map<Generic<T1>, Generic<T2>>>& inputMap,
+      const arg_type<Array<Generic<T1>>>& keys,
+      const arg_type<Array<Generic<T2>>>& values) {
+    // Check that keys and values arrays have the same size
+    VELOX_USER_CHECK_EQ(
+        keys.size(),
+        values.size(),
+        "Keys and values arrays must have the same length");
+
+    // Build a set of existing keys for fast lookup
+    folly::F14FastSet<
+        exec::GenericView,
+        std::hash<exec::GenericView>,
+        MapAppendFunctionEqualComparator>
+        existingKeys;
+
+    for (const auto& entry : inputMap) {
+      existingKeys.emplace(entry.first);
+    }
+
+    // Build a set of new keys to check for duplicates and verify they don't
+    // exist
+    folly::F14FastSet<
+        exec::GenericView,
+        std::hash<exec::GenericView>,
+        MapAppendFunctionEqualComparator>
+        newKeys;
+
+    auto keysIt = keys.begin();
+    auto valuesIt = values.begin();
+
+    for (; keysIt != keys.end(); ++keysIt, ++valuesIt) {
+      if (keysIt->has_value()) {
+        const auto& key = keysIt->value();
+
+        // Check if key already exists in the input map
+        VELOX_USER_CHECK(
+            !existingKeys.contains(key), "Key already exists in the map");
+
+        // Check for duplicate keys in the new keys array
+        VELOX_USER_CHECK(
+            newKeys.emplace(key).second, "Duplicate key in keys array");
+      }
+    }
+
+    // First, copy all existing entries from the input map
+    for (const auto& entry : inputMap) {
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        keyWriter.copy_from(entry.first);
+      } else {
+        auto [keyWriter, valueWriter] = out.add_item();
+        keyWriter.copy_from(entry.first);
+        valueWriter.copy_from(entry.second.value());
+      }
+    }
+
+    // Then, add new entries from keys and values arrays
+    keysIt = keys.begin();
+    valuesIt = values.begin();
+
+    for (; keysIt != keys.end(); ++keysIt, ++valuesIt) {
+      if (keysIt->has_value()) {
+        if (!valuesIt->has_value()) {
+          auto& keyWriter = out.add_null();
+          keyWriter.copy_from(keysIt->value());
+        } else {
+          auto [keyWriter, valueWriter] = out.add_item();
+          keyWriter.copy_from(keysIt->value());
+          valueWriter.copy_from(valuesIt->value());
+        }
+      }
+    }
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapExcept.h b/velox/functions/prestosql/MapExcept.h
new file mode 100644
index 00000000000..51ec8760787
--- /dev/null
+++ b/velox/functions/prestosql/MapExcept.h
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/functions/Udf.h"
+#include "velox/type/FloatingPointUtil.h"
+
+namespace facebook::velox::functions {
+
+/// Fast path for constant primitive type keys: map_except(m, array[1, 2, 3]).
+template <typename TExec, typename Key>
+struct MapExceptPrimitiveFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      const arg_type<Map<Key, Generic<T1>>>* /*inputMap*/,
+      const arg_type<Array<Key>>* keys) {
+    if (keys != nullptr) {
+      constantSearchKeys_ = true;
+      searchKeys_.clear();
+      initializeSearchKeys(*keys);
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Map<Key, Generic<T1>>>& out,
+      const arg_type<Map<Key, Generic<T1>>>& inputMap,
+      const arg_type<Array<Key>>& keys) {
+    if (!constantSearchKeys_) {
+      searchKeys_.clear();
+      if (!keys.empty() && !inputMap.empty()) {
+        initializeSearchKeys(keys);
+      }
+    }
+
+    auto toExclude = searchKeys_.size();
+    out.reserve(inputMap.size());
+
+    for (const auto& entry : inputMap) {
+      if (toExclude > 0 && searchKeys_.contains(entry.first)) {
+        --toExclude;
+        continue;
+      }
+
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        keyWriter = entry.first;
+      } else {
+        auto [keyWriter, valueWriter] = out.add_item();
+        keyWriter = entry.first;
+        valueWriter.copy_from(entry.second.value());
+      }
+    }
+  }
+
+ private:
+  void initializeSearchKeys(const arg_type<Array<Key>>& keys) {
+    searchKeys_.reserve(keys.size());
+    for (const auto& key : keys.skipNulls()) {
+      searchKeys_.emplace(key);
+    }
+  }
+
+  bool constantSearchKeys_{false};
+  util::floating_point::HashSetNaNAware<arg_type<Key>> searchKeys_;
+};
+
+/// Fast path for constant string keys: map_except(m, array['a', 'b', 'c']).
+template <typename TExec>
+struct MapExceptVarcharFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      const arg_type<Map<Varchar, Generic<T1>>>* /*inputMap*/,
+      const arg_type<Array<Varchar>>* keys) {
+    if (keys != nullptr) {
+      constantSearchKeys_ = true;
+      searchKeys_.clear();
+      searchKeyStrings_.clear();
+
+      searchKeys_.reserve(keys->size());
+      searchKeyStrings_.reserve(keys->size());
+      for (const auto& key : keys->skipNulls()) {
+        if (key.isInline()) {
+          searchKeys_.emplace(key);
+        } else if (!searchKeys_.contains(key)) {
+          searchKeyStrings_.push_back(key.str());
+          searchKeys_.emplace(StringView(searchKeyStrings_.back()));
+        }
+      }
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Map<Varchar, Generic<T1>>>& out,
+      const arg_type<Map<Varchar, Generic<T1>>>& inputMap,
+      const arg_type<Array<Varchar>>& keys) {
+    if (!constantSearchKeys_) {
+      searchKeys_.clear();
+      if (!keys.empty() && !inputMap.empty()) {
+        searchKeys_.reserve(keys.size());
+        for (const auto& key : keys.skipNulls()) {
+          searchKeys_.emplace(key);
+        }
+      }
+    }
+
+    auto toExclude = searchKeys_.size();
+    out.reserve(inputMap.size());
+
+    for (const auto& entry : inputMap) {
+      if (toExclude > 0 && searchKeys_.contains(entry.first)) {
+        --toExclude;
+        continue;
+      }
+
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        keyWriter.copy_from(entry.first);
+      } else {
+        auto [keyWriter, valueWriter] = out.add_item();
+        keyWriter.copy_from(entry.first);
+        valueWriter.copy_from(entry.second.value());
+      }
+    }
+  }
+
+ private:
+  bool constantSearchKeys_{false};
+  folly::F14FastSet<StringView> searchKeys_;
+  std::vector<std::string> searchKeyStrings_;
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapIntersect.h b/velox/functions/prestosql/MapIntersect.h
new file mode 100644
index 00000000000..33e016f5a4c
--- /dev/null
+++ b/velox/functions/prestosql/MapIntersect.h
@@ -0,0 +1,254 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <algorithm>
+
+#include <folly/Likely.h>
+#include "velox/expression/ComplexViewTypes.h"
+#include "velox/functions/Udf.h"
+#include "velox/type/FloatingPointUtil.h"
+
+namespace facebook::velox::functions {
+
+/// Fast path for constant primitive type keys: map_intersect(m, array[1, 2,
+/// 3]).
+template <typename TExec, typename Key>
+struct MapIntersectPrimitiveFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      const arg_type<Map<Key, Generic<T1>>>* /*inputMap*/,
+      const arg_type<Array<Key>>* keys) {
+    if (keys != nullptr) {
+      constantSearchKeys_ = true;
+      searchKeys_.reserve(keys->size());
+      for (const auto& key : keys->skipNulls()) {
+        searchKeys_.emplace(key);
+      }
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Map<Key, Generic<T1>>>& out,
+      const arg_type<Map<Key, Generic<T1>>>& inputMap,
+      const arg_type<Array<Key>>& keys) {
+    if (FOLLY_UNLIKELY(keys.empty() || inputMap.empty())) {
+      return;
+    }
+
+    if (!constantSearchKeys_) {
+      searchKeys_.clear();
+      searchKeys_.reserve(keys.size());
+      for (const auto& key : keys.skipNulls()) {
+        searchKeys_.emplace(key);
+      }
+    }
+
+    if (FOLLY_UNLIKELY(searchKeys_.empty())) {
+      return;
+    }
+
+    out.reserve(
+        static_cast<vector_size_t>(
+            std::min<size_t>(inputMap.size(), searchKeys_.size())));
+
+    auto toFind = searchKeys_.size();
+
+    for (const auto& entry : inputMap) {
+      if (!searchKeys_.contains(entry.first)) {
+        continue;
+      }
+
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        keyWriter = entry.first;
+      } else {
+        auto [keyWriter, valueWriter] = out.add_item();
+        keyWriter = entry.first;
+        valueWriter.copy_from(entry.second.value());
+      }
+
+      --toFind;
+      if (toFind == 0) {
+        break;
+      }
+    }
+  }
+
+ private:
+  bool constantSearchKeys_{false};
+  util::floating_point::HashSetNaNAware<arg_type<Key>> searchKeys_;
+};
+
+/// Fast path for constant string keys: map_intersect(m, array['a', 'b', 'c']).
+template <typename TExec>
+struct MapIntersectVarcharFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      const arg_type<Map<Varchar, Generic<T1>>>* /*inputMap*/,
+      const arg_type<Array<Varchar>>* keys) {
+    if (keys != nullptr) {
+      constantSearchKeys_ = true;
+
+      searchKeys_.reserve(keys->size());
+      searchKeyStrings_.reserve(keys->size());
+      for (const auto& key : keys->skipNulls()) {
+        if (key.isInline()) {
+          searchKeys_.emplace(key);
+        } else if (!searchKeys_.contains(key)) {
+          searchKeyStrings_.push_back(key.str());
+          searchKeys_.emplace(StringView(searchKeyStrings_.back()));
+        }
+      }
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Map<Varchar, Generic<T1>>>& out,
+      const arg_type<Map<Varchar, Generic<T1>>>& inputMap,
+      const arg_type<Array<Varchar>>& keys) {
+    if (FOLLY_UNLIKELY(keys.empty() || inputMap.empty())) {
+      return;
+    }
+
+    if (!constantSearchKeys_) {
+      searchKeys_.clear();
+      searchKeys_.reserve(keys.size());
+      for (const auto& key : keys.skipNulls()) {
+        searchKeys_.emplace(key);
+      }
+    }
+
+    if (FOLLY_UNLIKELY(searchKeys_.empty())) {
+      return;
+    }
+
+    out.reserve(
+        static_cast<vector_size_t>(
+            std::min<size_t>(inputMap.size(), searchKeys_.size())));
+
+    auto toFind = searchKeys_.size();
+
+    for (const auto& entry : inputMap) {
+      if (!searchKeys_.contains(entry.first)) {
+        continue;
+      }
+
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        keyWriter.copy_from(entry.first);
+      } else {
+        auto [keyWriter, valueWriter] = out.add_item();
+        keyWriter.copy_from(entry.first);
+        valueWriter.copy_from(entry.second.value());
+      }
+
+      --toFind;
+      if (toFind == 0) {
+        break;
+      }
+    }
+  }
+
+ private:
+  bool constantSearchKeys_{false};
+  folly::F14FastSet<StringView> searchKeys_;
+  std::vector<std::string> searchKeyStrings_;
+};
+
+struct MapIntersectFunctionEqualComparator {
+  bool operator()(const exec::GenericView& lhs, const exec::GenericView& rhs)
+      const {
+    static constexpr auto kEqualValueAtFlags = CompareFlags::equality(
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+
+    auto result = lhs.compare(rhs, kEqualValueAtFlags);
+
+    // If comparison returns indeterminate (null), treat as not equal.
+    if (!result.has_value()) {
+      return false;
+    }
+
+    return result.value() == 0;
+  }
+};
+
+/// Generic implementation. Doesn't provide an optimization for constant search
+/// keys.
+template <typename TExec>
+struct MapIntersectFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Map<Generic<T1>, Generic<T2>>>& out,
+      const arg_type<Map<Generic<T1>, Generic<T2>>>& inputMap,
+      const arg_type<Array<Generic<T1>>>& keys) {
+    if (FOLLY_UNLIKELY(keys.empty() || inputMap.empty())) {
+      return;
+    }
+
+    searchKeys_.clear();
+    searchKeys_.reserve(keys.size());
+    for (const auto& key : keys.skipNulls()) {
+      searchKeys_.emplace(key);
+    }
+
+    if (FOLLY_UNLIKELY(searchKeys_.empty())) {
+      return;
+    }
+
+    out.reserve(
+        static_cast<vector_size_t>(
+            std::min<size_t>(inputMap.size(), searchKeys_.size())));
+
+    auto toFind = searchKeys_.size();
+
+    for (const auto& entry : inputMap) {
+      if (!searchKeys_.contains(entry.first)) {
+        continue;
+      }
+
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        keyWriter.copy_from(entry.first);
+      } else {
+        auto [keyWriter, valueWriter] = out.add_item();
+        keyWriter.copy_from(entry.first);
+        valueWriter.copy_from(entry.second.value());
+      }
+
+      --toFind;
+      if (toFind == 0) {
+        break;
+      }
+    }
+  }
+
+ private:
+  folly::F14FastSet<
+      exec::GenericView,
+      std::hash<exec::GenericView>,
+      MapIntersectFunctionEqualComparator>
+      searchKeys_;
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapKeysAndValues.cpp b/velox/functions/prestosql/MapKeysAndValues.cpp
index 50a03310dae..5d9c98f70cc 100644
--- a/velox/functions/prestosql/MapKeysAndValues.cpp
+++ b/velox/functions/prestosql/MapKeysAndValues.cpp
@@ -71,7 +71,7 @@ class MapKeysFunction : public MapKeyValueFunction {
     VELOX_CHECK(
         arg->typeKind() == TypeKind::MAP,
         "Unsupported type for map_keys function {}",
-        mapTypeKindToName(arg->typeKind()));
+        TypeKindName::toName(arg->typeKind()));
 
     auto mapVector = arg->as<MapVector>();
     auto mapKeys = mapVector->mapKeys();
@@ -108,7 +108,7 @@ class MapValuesFunction : public MapKeyValueFunction {
     VELOX_CHECK(
         arg->typeKind() == TypeKind::MAP,
         "Unsupported type for map_values function {}",
-        mapTypeKindToName(arg->typeKind()));
+        TypeKindName::toName(arg->typeKind()));
 
     auto mapVector = arg->as<MapVector>();
     auto mapValues = mapVector->mapValues();
diff --git a/velox/functions/prestosql/MapKeysOverlap.h b/velox/functions/prestosql/MapKeysOverlap.h
new file mode 100644
index 00000000000..a18e3a766e1
--- /dev/null
+++ b/velox/functions/prestosql/MapKeysOverlap.h
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/ComplexViewTypes.h"
+#include "velox/functions/Udf.h"
+
+namespace facebook::velox::functions {
+
+template <typename TExec, typename Key>
+struct MapKeysOverlapPrimitiveFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<bool>& out,
+      const arg_type<Map<Key, Generic<T1>>>& inputMap,
+      const arg_type<Array<Key>>& keys) {
+    if (inputMap.empty() || keys.empty()) {
+      out = false;
+      return;
+    }
+
+    folly::F14FastSet<arg_type<Key>> keySet;
+
+    for (const auto& key : keys) {
+      if (key.has_value()) {
+        keySet.insert(key.value());
+      }
+    }
+
+    for (const auto& entry : inputMap) {
+      if (keySet.find(entry.first) != keySet.end()) {
+        out = true;
+        return;
+      }
+    }
+
+    out = false;
+  }
+};
+
+template <typename TExec>
+struct MapKeysOverlapVarcharFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<bool>& out,
+      const arg_type<Map<Varchar, Generic<T1>>>& inputMap,
+      const arg_type<Array<Varchar>>& keys) {
+    if (inputMap.empty() || keys.empty()) {
+      out = false;
+      return;
+    }
+
+    folly::F14FastSet<StringView> keySet;
+
+    for (const auto& key : keys) {
+      if (key.has_value()) {
+        keySet.insert(key.value());
+      }
+    }
+
+    for (const auto& entry : inputMap) {
+      if (keySet.find(entry.first) != keySet.end()) {
+        out = true;
+        return;
+      }
+    }
+
+    out = false;
+  }
+};
+
+struct MapKeysOverlapFunctionEqualComparator {
+  bool operator()(const exec::GenericView& lhs, const exec::GenericView& rhs)
+      const {
+    static constexpr auto kEqualValueAtFlags = CompareFlags::equality(
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+
+    auto result = lhs.compare(rhs, kEqualValueAtFlags);
+
+    // If comparison returns indeterminate (null), treat as not equal
+    if (!result.has_value()) {
+      return false;
+    }
+
+    return result.value() == 0;
+  }
+};
+
+template <typename TExec>
+struct MapKeysOverlapFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<bool>& out,
+      const arg_type<Map<Generic<T1>, Generic<T2>>>& inputMap,
+      const arg_type<Array<Generic<T1>>>& keys) {
+    if (inputMap.empty() || keys.empty()) {
+      out = false;
+      return;
+    }
+
+    searchKeys_.clear();
+    for (const auto& key : keys) {
+      if (key.has_value()) {
+        searchKeys_.emplace(key.value());
+      }
+    }
+
+    if (searchKeys_.empty()) {
+      out = false;
+      return;
+    }
+
+    for (const auto& entry : inputMap) {
+      if (searchKeys_.contains(entry.first)) {
+        out = true;
+        return;
+      }
+    }
+
+    out = false;
+  }
+
+ private:
+  folly::F14FastSet<
+      exec::GenericView,
+      std::hash<exec::GenericView>,
+      MapKeysOverlapFunctionEqualComparator>
+      searchKeys_;
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapSubset.cpp b/velox/functions/prestosql/MapSubset.cpp
new file mode 100644
index 00000000000..d446f535634
--- /dev/null
+++ b/velox/functions/prestosql/MapSubset.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/MapSubset.h"
+#include "velox/functions/Registerer.h"
+
+namespace facebook::velox::functions {
+template <typename T>
+void registerMapSubsetPrimitive(const std::string& name) {
+  registerFunction<
+      ParameterBinder<MapSubsetPrimitiveFunction, T>,
+      Map<T, Generic<T1>>,
+      Map<T, Generic<T1>>,
+      Array<T>>({name});
+}
+
+void registerMapSubset(const std::string& name) {
+  registerMapSubsetPrimitive<bool>(name);
+  registerMapSubsetPrimitive<int8_t>(name);
+  registerMapSubsetPrimitive<int16_t>(name);
+  registerMapSubsetPrimitive<int32_t>(name);
+  registerMapSubsetPrimitive<int64_t>(name);
+  registerMapSubsetPrimitive<float>(name);
+  registerMapSubsetPrimitive<double>(name);
+  registerMapSubsetPrimitive<Timestamp>(name);
+  registerMapSubsetPrimitive<Date>(name);
+
+  registerFunction<
+      MapSubsetVarcharFunction,
+      Map<Varchar, Generic<T1>>,
+      Map<Varchar, Generic<T1>>,
+      Array<Varchar>>({name});
+
+  registerFunction<
+      MapSubsetFunction,
+      Map<Generic<T1>, Generic<T2>>,
+      Map<Generic<T1>, Generic<T2>>,
+      Array<Generic<T1>>>({name});
+}
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapSubset.h b/velox/functions/prestosql/MapSubset.h
index 007cd59c889..4c39f60bd51 100644
--- a/velox/functions/prestosql/MapSubset.h
+++ b/velox/functions/prestosql/MapSubset.h
@@ -15,8 +15,9 @@
  */
 #pragma once
 
+#include "velox/core/QueryConfig.h"
 #include "velox/expression/ComplexViewTypes.h"
-#include "velox/functions/Udf.h"
+#include "velox/functions/Macros.h"
 #include "velox/type/FloatingPointUtil.h"
 
 namespace facebook::velox::functions {
@@ -234,4 +235,6 @@ struct MapSubsetFunction {
       searchKeys_;
 };
 
+void registerMapSubset(const std::string& name);
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapSubsetKeyInRange.h b/velox/functions/prestosql/MapSubsetKeyInRange.h
new file mode 100644
index 00000000000..f0a3fe32403
--- /dev/null
+++ b/velox/functions/prestosql/MapSubsetKeyInRange.h
@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <type_traits>
+
+#include "velox/expression/ComplexViewTypes.h"
+#include "velox/functions/Macros.h"
+#include "velox/type/FloatingPointUtil.h"
+
+namespace facebook::velox::functions {
+
+namespace detail {
+
+// Returns true if 'lhs' is strictly less than 'rhs'. For floating-point
+// types this uses the NaN-aware ordering used elsewhere in Velox/Presto:
+// NaN compares greater than all non-NaN values, NaN == NaN.
+template <typename T>
+FOLLY_ALWAYS_INLINE bool nanAwareLess(const T& lhs, const T& rhs) {
+  if constexpr (std::is_floating_point_v<T>) {
+    return util::floating_point::NaNAwareLessThan<T>{}(lhs, rhs);
+  } else {
+    return lhs < rhs;
+  }
+}
+
+// Returns true if 'lhs' is strictly greater than 'rhs', using NaN-aware
+// ordering for floating-point types.
+template <typename T>
+FOLLY_ALWAYS_INLINE bool nanAwareGreater(const T& lhs, const T& rhs) {
+  if constexpr (std::is_floating_point_v<T>) {
+    return util::floating_point::NaNAwareGreaterThan<T>{}(lhs, rhs);
+  } else {
+    return lhs > rhs;
+  }
+}
+
+} // namespace detail
+
+/// map_subset_key_in_range(map(K, V), low_key, high_key) -> map(K, V)
+///
+/// Returns a sub-map containing only the entries from the input map whose
+/// keys fall within the inclusive range [low_key, high_key]. Both bounds
+/// are inclusive. If low_key > high_key, returns an empty map. Entries with
+/// null values are preserved (Velox map keys cannot be null).
+///
+/// Null-input semantics: the function uses Velox's default null behavior
+/// (`void call`, not `callNullable`), so if the input map, low_key, or
+/// high_key is null, the result is null.
+///
+/// Floating-point keys use NaN-aware comparison: NaN is treated as greater
+/// than all non-NaN values, and equal to itself.
+///
+/// Fast path for primitive key types.
+template <typename TExec, typename K>
+struct MapSubsetKeyInRangeFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      out_type<Map<K, Generic<T1>>>& out,
+      const arg_type<Map<K, Generic<T1>>>& inputMap,
+      const arg_type<K>& lowKey,
+      const arg_type<K>& highKey) {
+    if (detail::nanAwareGreater(lowKey, highKey)) {
+      return;
+    }
+
+    for (const auto& entry : inputMap) {
+      if (detail::nanAwareLess(entry.first, lowKey) ||
+          detail::nanAwareGreater(entry.first, highKey)) {
+        continue;
+      }
+
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        keyWriter = entry.first;
+      } else {
+        auto [keyWriter, valueWriter] = out.add_item();
+        keyWriter = entry.first;
+        valueWriter.copy_from(entry.second.value());
+      }
+    }
+  }
+};
+
+/// Varchar key version with zero-copy semantics for keys.
+template <typename TExec>
+struct MapSubsetKeyInRangeVarcharFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  // NOLINT: Framework-required variable name for zero-copy string semantics.
+  static constexpr int32_t reuse_strings_from_arg = 0;
+
+  void call(
+      out_type<Map<Varchar, Generic<T1>>>& out,
+      const arg_type<Map<Varchar, Generic<T1>>>& inputMap,
+      const arg_type<Varchar>& lowKey,
+      const arg_type<Varchar>& highKey) {
+    if (lowKey > highKey) {
+      return;
+    }
+
+    for (const auto& entry : inputMap) {
+      if (entry.first < lowKey || entry.first > highKey) {
+        continue;
+      }
+
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        keyWriter.copy_from(entry.first);
+      } else {
+        auto [keyWriter, valueWriter] = out.add_item();
+        keyWriter.copy_from(entry.first);
+        valueWriter.copy_from(entry.second.value());
+      }
+    }
+  }
+};
+
+/// Generic implementation for orderable key types not covered by the
+/// primitive or varchar fast paths. Uses GenericView::compare with
+/// kNullAsIndeterminate, which delegates to the type-aware comparator and
+/// therefore already handles NaN according to Velox/Presto semantics for
+/// any floating-point components nested inside the key.
+template <typename TExec>
+struct MapSubsetKeyInRangeGenericFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      out_type<Map<Orderable<T1>, Generic<T2>>>& out,
+      const arg_type<Map<Orderable<T1>, Generic<T2>>>& inputMap,
+      const arg_type<Orderable<T1>>& lowKey,
+      const arg_type<Orderable<T1>>& highKey) {
+    static constexpr CompareFlags kFlags{
+        false /*nullsFirst*/,
+        true /*ascending*/,
+        false /*equalsOnly*/,
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate};
+
+    auto lowVsHigh = lowKey.compare(highKey, kFlags);
+    VELOX_USER_CHECK(
+        lowVsHigh.has_value(), "Comparison on null elements is not supported");
+    if (lowVsHigh.value() > 0) {
+      return;
+    }
+
+    for (const auto& entry : inputMap) {
+      auto lowCmp = entry.first.compare(lowKey, kFlags);
+      VELOX_USER_CHECK(
+          lowCmp.has_value(), "Comparison on null elements is not supported");
+      if (lowCmp.value() < 0) {
+        continue;
+      }
+
+      auto highCmp = entry.first.compare(highKey, kFlags);
+      VELOX_USER_CHECK(
+          highCmp.has_value(), "Comparison on null elements is not supported");
+      if (highCmp.value() > 0) {
+        continue;
+      }
+
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        keyWriter.copy_from(entry.first);
+      } else {
+        auto [keyWriter, valueWriter] = out.add_item();
+        keyWriter.copy_from(entry.first);
+        valueWriter.copy_from(entry.second.value());
+      }
+    }
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapTrimValues.h b/velox/functions/prestosql/MapTrimValues.h
new file mode 100644
index 00000000000..7c0366b6919
--- /dev/null
+++ b/velox/functions/prestosql/MapTrimValues.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+
+#include "velox/expression/ComplexViewTypes.h"
+#include "velox/functions/Macros.h"
+
+namespace facebook::velox::functions {
+
+/// map_trim_values(map(K, array(V)), n) -> map(K, array(V))
+///
+/// Trims the value arrays in a map to a specified maximum size.
+/// This function is useful for optimizing memory usage and performance
+/// for large feature maps where the value arrays may grow unbounded.
+///
+/// Returns a map where each value array is trimmed to at most n elements.
+/// If n is negative, returns the original map unchanged.
+/// If n is 0, returns a map where all values are empty arrays.
+/// If a value array has fewer than n elements, it is left unchanged.
+/// Null map values are preserved in the output.
+/// Null elements within arrays are also preserved.
+template <typename TExec>
+struct MapTrimValuesFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      out_type<Map<Generic<T1>, Array<Generic<T2>>>>& out,
+      const arg_type<Map<Generic<T1>, Array<Generic<T2>>>>& inputMap,
+      int64_t n) {
+    // If n is negative, preserve the original map as-is
+    if (n < 0) {
+      out.copy_from(inputMap);
+      return;
+    }
+
+    for (const auto& entry : inputMap) {
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        keyWriter.copy_from(entry.first);
+      } else {
+        auto [keyWriter, valueWriter] = out.add_item();
+        keyWriter.copy_from(entry.first);
+
+        const auto& valueArray = entry.second.value();
+        const auto arraySize = static_cast<size_t>(valueArray.size());
+        const auto trimSize = std::min(static_cast<size_t>(n), arraySize);
+
+        size_t count = 0;
+        for (const auto& element : valueArray) {
+          if (count >= trimSize) {
+            break;
+          }
+          if (element.has_value()) {
+            auto& elementWriter = valueWriter.add_item();
+            elementWriter.copy_from(element.value());
+          } else {
+            valueWriter.add_null();
+          }
+          ++count;
+        }
+      }
+    }
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapUpdate.h b/velox/functions/prestosql/MapUpdate.h
new file mode 100644
index 00000000000..9ea8015fcf0
--- /dev/null
+++ b/velox/functions/prestosql/MapUpdate.h
@@ -0,0 +1,275 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/ComplexViewTypes.h"
+#include "velox/functions/Macros.h"
+#include "velox/type/FloatingPointUtil.h"
+
+namespace facebook::velox::functions {
+
+/// Fast path for primitive type keys: map_update(m, array[1, 2], array[10,
+/// 20]).
+/// Updates values in a map for specified keys. If a key exists, its value is
+/// updated in place (preserving order). If a key doesn't exist, it is added
+/// to the end of the map.
+template <typename TExec, typename Key>
+struct MapUpdatePrimitiveFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      out_type<Map<Key, Generic<T1>>>& out,
+      const arg_type<Map<Key, Generic<T1>>>& inputMap,
+      const arg_type<Array<Key>>& keys,
+      const arg_type<Array<Generic<T1>>>& values) {
+    VELOX_USER_CHECK_EQ(
+        keys.size(),
+        values.size(),
+        "Keys and values arrays must have the same length");
+
+    // Build map from key -> index in the update arrays.
+    typename util::floating_point::
+        HashMapNaNAwareTypeTraits<arg_type<Key>, size_t>::Type updateKeyIndex;
+    for (size_t i = 0; i < keys.size(); ++i) {
+      if (keys[i].has_value()) {
+        VELOX_USER_CHECK(
+            updateKeyIndex.emplace(keys[i].value(), i).second,
+            "Duplicate key in keys array");
+      }
+    }
+
+    // Track which update keys have been used (for keys already in inputMap).
+    util::floating_point::HashSetNaNAware<arg_type<Key>> usedUpdateKeys;
+
+    // Process entries from input map, updating values where needed.
+    for (const auto& entry : inputMap) {
+      auto it = updateKeyIndex.find(entry.first);
+      if (it != updateKeyIndex.end()) {
+        // Key is being updated - use new value.
+        usedUpdateKeys.insert(entry.first);
+        size_t idx = it->second;
+        if (!values[idx].has_value()) {
+          auto& keyWriter = out.add_null();
+          keyWriter = entry.first;
+        } else {
+          auto [keyWriter, valueWriter] = out.add_item();
+          keyWriter = entry.first;
+          valueWriter.copy_from(values[idx].value());
+        }
+      } else {
+        // Key is not being updated - keep original value.
+        if (!entry.second.has_value()) {
+          auto& keyWriter = out.add_null();
+          keyWriter = entry.first;
+        } else {
+          auto [keyWriter, valueWriter] = out.add_item();
+          keyWriter = entry.first;
+          valueWriter.copy_from(entry.second.value());
+        }
+      }
+    }
+
+    // Add new keys from update arrays (keys not in original map).
+    auto keysIt = keys.begin();
+    auto valuesIt = values.begin();
+    for (; keysIt != keys.end(); ++keysIt, ++valuesIt) {
+      if (keysIt->has_value() && !usedUpdateKeys.contains(keysIt->value())) {
+        if (!valuesIt->has_value()) {
+          auto& keyWriter = out.add_null();
+          keyWriter = keysIt->value();
+        } else {
+          auto [keyWriter, valueWriter] = out.add_item();
+          keyWriter = keysIt->value();
+          valueWriter.copy_from(valuesIt->value());
+        }
+      }
+    }
+  }
+};
+
+/// String version for varchar keys.
+template <typename TExec>
+struct MapUpdateVarcharFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      out_type<Map<Varchar, Generic<T1>>>& out,
+      const arg_type<Map<Varchar, Generic<T1>>>& inputMap,
+      const arg_type<Array<Varchar>>& keys,
+      const arg_type<Array<Generic<T1>>>& values) {
+    VELOX_USER_CHECK_EQ(
+        keys.size(),
+        values.size(),
+        "Keys and values arrays must have the same length");
+
+    // Build map from key -> index in the update arrays.
+    folly::F14FastMap<StringView, size_t> updateKeyIndex;
+    for (size_t i = 0; i < keys.size(); ++i) {
+      if (keys[i].has_value()) {
+        VELOX_USER_CHECK(
+            updateKeyIndex.emplace(keys[i].value(), i).second,
+            "Duplicate key in keys array");
+      }
+    }
+
+    // Track which update keys have been used (for keys already in inputMap).
+    folly::F14FastSet<StringView> usedUpdateKeys;
+
+    // Process entries from input map, updating values where needed.
+    for (const auto& entry : inputMap) {
+      auto it = updateKeyIndex.find(entry.first);
+      if (it != updateKeyIndex.end()) {
+        // Key is being updated - use new value.
+        usedUpdateKeys.insert(entry.first);
+        size_t idx = it->second;
+        if (!values[idx].has_value()) {
+          auto& keyWriter = out.add_null();
+          keyWriter.copy_from(entry.first);
+        } else {
+          auto [keyWriter, valueWriter] = out.add_item();
+          keyWriter.copy_from(entry.first);
+          valueWriter.copy_from(values[idx].value());
+        }
+      } else {
+        // Key is not being updated - keep original value.
+        if (!entry.second.has_value()) {
+          auto& keyWriter = out.add_null();
+          keyWriter.copy_from(entry.first);
+        } else {
+          auto [keyWriter, valueWriter] = out.add_item();
+          keyWriter.copy_from(entry.first);
+          valueWriter.copy_from(entry.second.value());
+        }
+      }
+    }
+
+    // Add new keys from update arrays (keys not in original map).
+    auto keysIt = keys.begin();
+    auto valuesIt = values.begin();
+    for (; keysIt != keys.end(); ++keysIt, ++valuesIt) {
+      if (keysIt->has_value() && !usedUpdateKeys.contains(keysIt->value())) {
+        if (!valuesIt->has_value()) {
+          auto& keyWriter = out.add_null();
+          keyWriter.copy_from(keysIt->value());
+        } else {
+          auto [keyWriter, valueWriter] = out.add_item();
+          keyWriter.copy_from(keysIt->value());
+          valueWriter.copy_from(valuesIt->value());
+        }
+      }
+    }
+  }
+};
+
+struct MapUpdateFunctionEqualComparator {
+  bool operator()(const exec::GenericView& lhs, const exec::GenericView& rhs)
+      const {
+    static constexpr auto kEqualValueAtFlags = CompareFlags::equality(
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+
+    auto result = lhs.compare(rhs, kEqualValueAtFlags);
+
+    VELOX_USER_CHECK(
+        result.has_value(), "Comparison on null elements is not supported");
+
+    return result.value() == 0;
+  }
+};
+
+/// Generic implementation for complex types.
+template <typename TExec>
+struct MapUpdateFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      out_type<Map<Generic<T1>, Generic<T2>>>& out,
+      const arg_type<Map<Generic<T1>, Generic<T2>>>& inputMap,
+      const arg_type<Array<Generic<T1>>>& keys,
+      const arg_type<Array<Generic<T2>>>& values) {
+    VELOX_USER_CHECK_EQ(
+        keys.size(),
+        values.size(),
+        "Keys and values arrays must have the same length");
+
+    // Build map from key -> index in the update arrays.
+    folly::F14FastMap<
+        exec::GenericView,
+        size_t,
+        std::hash<exec::GenericView>,
+        MapUpdateFunctionEqualComparator>
+        updateKeyIndex;
+    for (size_t i = 0; i < keys.size(); ++i) {
+      if (keys[i].has_value()) {
+        VELOX_USER_CHECK(
+            updateKeyIndex.emplace(keys[i].value(), i).second,
+            "Duplicate key in keys array");
+      }
+    }
+
+    // Track which update keys have been used (for keys already in inputMap).
+    folly::F14FastSet<
+        exec::GenericView,
+        std::hash<exec::GenericView>,
+        MapUpdateFunctionEqualComparator>
+        usedUpdateKeys;
+
+    // Process entries from input map, updating values where needed.
+    for (const auto& entry : inputMap) {
+      auto it = updateKeyIndex.find(entry.first);
+      if (it != updateKeyIndex.end()) {
+        // Key is being updated - use new value.
+        usedUpdateKeys.insert(entry.first);
+        size_t idx = it->second;
+        if (!values[idx].has_value()) {
+          auto& keyWriter = out.add_null();
+          keyWriter.copy_from(entry.first);
+        } else {
+          auto [keyWriter, valueWriter] = out.add_item();
+          keyWriter.copy_from(entry.first);
+          valueWriter.copy_from(values[idx].value());
+        }
+      } else {
+        // Key is not being updated - keep original value.
+        if (!entry.second.has_value()) {
+          auto& keyWriter = out.add_null();
+          keyWriter.copy_from(entry.first);
+        } else {
+          auto [keyWriter, valueWriter] = out.add_item();
+          keyWriter.copy_from(entry.first);
+          valueWriter.copy_from(entry.second.value());
+        }
+      }
+    }
+
+    // Add new keys from update arrays (keys not in original map).
+    auto keysIt = keys.begin();
+    auto valuesIt = values.begin();
+    for (; keysIt != keys.end(); ++keysIt, ++valuesIt) {
+      if (keysIt->has_value() && !usedUpdateKeys.contains(keysIt->value())) {
+        if (!valuesIt->has_value()) {
+          auto& keyWriter = out.add_null();
+          keyWriter.copy_from(keysIt->value());
+        } else {
+          auto [keyWriter, valueWriter] = out.add_item();
+          keyWriter.copy_from(keysIt->value());
+          valueWriter.copy_from(valuesIt->value());
+        }
+      }
+    }
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapValuesInRange.h b/velox/functions/prestosql/MapValuesInRange.h
new file mode 100644
index 00000000000..bfcbc9c0559
--- /dev/null
+++ b/velox/functions/prestosql/MapValuesInRange.h
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/functions/Macros.h"
+
+namespace facebook::velox::functions {
+
+/// map_values_in_range(map(K, V), lower_bound, upper_bound) -> map(K, V)
+///
+/// Returns a map containing only the entries from the input map whose values
+/// fall within the specified range [lower_bound, upper_bound] (inclusive).
+/// Entries with values less than lower_bound or greater than upper_bound are
+/// removed. Entries with null values are preserved in the output.
+/// If lower_bound or upper_bound is null, that bound is not applied.
+template <typename TExec, typename K, typename V>
+struct MapValuesInRangeFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      out_type<Map<K, V>>& out,
+      const arg_type<Map<K, V>>& inputMap,
+      const arg_type<V>& lowerBound,
+      const arg_type<V>& upperBound) {
+    for (const auto& entry : inputMap) {
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        if constexpr (std::is_same_v<K, Varchar>) {
+          keyWriter.copy_from(entry.first);
+        } else {
+          keyWriter = entry.first;
+        }
+        continue;
+      }
+
+      const auto& value = entry.second.value();
+
+      if (value >= lowerBound && value <= upperBound) {
+        auto [keyWriter, valueWriter] = out.add_item();
+        if constexpr (std::is_same_v<K, Varchar>) {
+          keyWriter.copy_from(entry.first);
+        } else {
+          keyWriter = entry.first;
+        }
+        if constexpr (std::is_same_v<V, Varchar>) {
+          valueWriter.copy_from(value);
+        } else {
+          valueWriter = value;
+        }
+      }
+    }
+  }
+};
+
+/// Varchar key version for zero-copy semantics.
+template <typename TExec, typename V>
+struct MapValuesInRangeVarcharKeyFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  // NOLINT: Framework-required variable name for zero-copy string semantics.
+  static constexpr int32_t reuse_strings_from_arg = 0;
+
+  void call(
+      out_type<Map<Varchar, V>>& out,
+      const arg_type<Map<Varchar, V>>& inputMap,
+      const arg_type<V>& lowerBound,
+      const arg_type<V>& upperBound) {
+    for (const auto& entry : inputMap) {
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        keyWriter.copy_from(entry.first);
+        continue;
+      }
+
+      const auto& value = entry.second.value();
+
+      if (value >= lowerBound && value <= upperBound) {
+        auto [keyWriter, valueWriter] = out.add_item();
+        keyWriter.copy_from(entry.first);
+        if constexpr (std::is_same_v<V, Varchar>) {
+          valueWriter.copy_from(value);
+        } else {
+          valueWriter = value;
+        }
+      }
+    }
+  }
+};
+
+/// Generic implementation for complex types.
+template <typename TExec>
+struct MapValuesInRangeGenericFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      out_type<Map<Generic<T1>, double>>& out,
+      const arg_type<Map<Generic<T1>, double>>& inputMap,
+      const double& lowerBound,
+      const double& upperBound) {
+    for (const auto& entry : inputMap) {
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        keyWriter.copy_from(entry.first);
+        continue;
+      }
+
+      const auto& value = entry.second.value();
+
+      if (value >= lowerBound && value <= upperBound) {
+        auto [keyWriter, valueWriter] = out.add_item();
+        keyWriter.copy_from(entry.first);
+        valueWriter = value;
+      }
+    }
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapZipWith.cpp b/velox/functions/prestosql/MapZipWith.cpp
index 5bcc72a142d..2cdd951d8a8 100644
--- a/velox/functions/prestosql/MapZipWith.cpp
+++ b/velox/functions/prestosql/MapZipWith.cpp
@@ -207,7 +207,7 @@ class MapZipWithFunction : public exec::VectorFunction {
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
     // map(K, V1), map(K, V2), function(K, V1, V2, V3) -> map(K, V3)
     return {exec::FunctionSignatureBuilder()
-                .knownTypeVariable("K")
+                .typeVariable("K")
                 .typeVariable("V1")
                 .typeVariable("V2")
                 .typeVariable("V3")
diff --git a/velox/functions/prestosql/MultimapFromEntries.h b/velox/functions/prestosql/MultimapFromEntries.h
index a9d448c51c1..acc43f99f95 100644
--- a/velox/functions/prestosql/MultimapFromEntries.h
+++ b/velox/functions/prestosql/MultimapFromEntries.h
@@ -31,6 +31,7 @@ struct MultimapFromEntriesFunction {
     // Reuse map and vector between rows to avoid re-allocating memory. The
     // benchmark shows 20-30% performance improvement.
     keyValuesMap_.clear();
+    keyValuesMap_.reserve(inputArray.size());
 
     uniqueKeys_.clear();
     uniqueKeys_.reserve(inputArray.size());
diff --git a/velox/functions/prestosql/Probability.h b/velox/functions/prestosql/Probability.h
index db42a8da3e6..8e9c0957f3e 100644
--- a/velox/functions/prestosql/Probability.h
+++ b/velox/functions/prestosql/Probability.h
@@ -18,6 +18,7 @@
 #include <boost/math/distributions.hpp>
 #include <boost/math/distributions/cauchy.hpp>
 #include <boost/math/distributions/laplace.hpp>
+#include <boost/math/distributions/students_t.hpp>
 #include <boost/math/distributions/weibull.hpp>
 #include "boost/math/distributions/beta.hpp"
 #include "boost/math/distributions/binomial.hpp"
@@ -468,5 +469,40 @@ struct InverseChiSquaredCdf {
   }
 };
 
+template <typename T>
+struct TCDFFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(double& result, double df, double value) {
+    VELOX_USER_CHECK_GT(df, 0, "df must be greater than 0");
+
+    boost::math::students_t_distribution<> dist(df);
+    result = boost::math::cdf(dist, value);
+  }
+};
+
+template <typename T>
+struct InverseTCDFFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(double& result, double df, double p) {
+    static constexpr double kInf = std::numeric_limits<double>::infinity();
+
+    VELOX_USER_CHECK_GT(df, 0, "df must be greater than 0");
+    VELOX_USER_CHECK(
+        p >= 0 && p <= 1 && p != kInf, "p must be in the interval [0, 1]");
+
+    if (p == 0.0) {
+      result = -std::numeric_limits<double>::infinity();
+      return;
+    } else if (p == 1.0) {
+      result = std::numeric_limits<double>::infinity();
+      return;
+    }
+    boost::math::students_t_distribution<> dist(df);
+    result = boost::math::quantile(dist, p);
+  }
+};
+
 } // namespace
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/Reduce.cpp b/velox/functions/prestosql/Reduce.cpp
index 38225da79f2..f73e2d85be8 100644
--- a/velox/functions/prestosql/Reduce.cpp
+++ b/velox/functions/prestosql/Reduce.cpp
@@ -15,6 +15,8 @@
  */
 #include "velox/common/base/RuntimeMetrics.h"
 #include "velox/core/Expressions.h"
+#include "velox/expression/ExprConstants.h"
+#include "velox/expression/ExprRewriteRegistry.h"
 #include "velox/expression/VectorFunction.h"
 #include "velox/functions/lib/LambdaFunctionUtil.h"
 
@@ -389,7 +391,8 @@ core::TypedExprPtr rewriteReduce(
     auto minus = std::make_shared<core::CallTypedExpr>(
         fx->type(), prefix + "minus", fx, inputBody->inputs()[1]);
     return toArraySum(prefix, *reduce, inputArgs, minus);
-  } else if (inputBody->name() == "if" && inputBody->inputs().size() == 3) {
+  } else if (
+      inputBody->name() == expression::kIf && inputBody->inputs().size() == 3) {
     // if(h(x), s + f(x), s + g(x)) =>
     // array_sum(transform(array, x -> if(h(x), f(x), g(x))))
     auto fx = extractFromAddition(prefix, inputBody->inputs()[1], s);
@@ -401,7 +404,7 @@ core::TypedExprPtr rewriteReduce(
       return nullptr;
     }
     auto ifExpr = std::make_shared<core::CallTypedExpr>(
-        fx->type(), "if", inputBody->inputs()[0], fx, gx);
+        fx->type(), expression::kIf, inputBody->inputs()[0], fx, gx);
     return toArraySum(prefix, *reduce, inputArgs, ifExpr);
   }
   return nullptr;
@@ -421,7 +424,7 @@ VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     std::make_unique<ReduceFunction>());
 
 void registerReduceRewrites(const std::string& prefix) {
-  exec::registerExpressionRewrite(
+  expression::ExprRewriteRegistry::instance().registerRewrite(
       [prefix](const auto& expr) { return rewriteReduce(prefix, expr); });
 }
 
diff --git a/velox/functions/prestosql/RemapKeys.h b/velox/functions/prestosql/RemapKeys.h
new file mode 100644
index 00000000000..1bb6c5c30d9
--- /dev/null
+++ b/velox/functions/prestosql/RemapKeys.h
@@ -0,0 +1,227 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/ComplexViewTypes.h"
+#include "velox/functions/Udf.h"
+#include "velox/type/FloatingPointUtil.h"
+
+namespace facebook::velox::functions {
+
+/// Fast path for constant primitive type keys.
+template <typename TExec, typename Key>
+struct RemapKeysPrimitiveFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      out_type<Map<Key, Generic<T1>>>& out,
+      const arg_type<Map<Key, Generic<T1>>>& inputMap,
+      const arg_type<Array<Key>>& oldKeys,
+      const arg_type<Array<Key>>& newKeys) {
+    if (inputMap.empty()) {
+      return;
+    }
+
+    // Build mapping from old keys to new keys
+    folly::F14FastMap<arg_type<Key>, arg_type<Key>> keyMapping;
+
+    // The old and new key arrays don't need to be the same size.
+    // If they differ, we only process up to the shorter array's length.
+    auto oldKeysSize = oldKeys.size();
+    auto newKeysSize = newKeys.size();
+    auto minSize = std::min(oldKeysSize, newKeysSize);
+
+    auto oldIt = oldKeys.begin();
+    auto newIt = newKeys.begin();
+
+    for (size_t i = 0; i < minSize; ++i, ++oldIt, ++newIt) {
+      if (oldIt->has_value() && newIt->has_value()) {
+        keyMapping[oldIt->value()] = newIt->value();
+      }
+    }
+
+    // Iterate through input map and remap keys
+    for (const auto& entry : inputMap) {
+      auto it = keyMapping.find(entry.first);
+
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        if (it != keyMapping.end()) {
+          keyWriter = it->second;
+        } else {
+          keyWriter = entry.first;
+        }
+      } else {
+        auto [keyWriter, valueWriter] = out.add_item();
+        if (it != keyMapping.end()) {
+          keyWriter = it->second;
+        } else {
+          keyWriter = entry.first;
+        }
+        valueWriter.copy_from(entry.second.value());
+      }
+    }
+  }
+};
+
+/// String version that avoids copy of strings.
+template <typename TExec>
+struct RemapKeysVarcharFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  static constexpr int32_t reuse_strings_from_arg = 0;
+
+  void call(
+      out_type<Map<Varchar, Generic<T1>>>& out,
+      const arg_type<Map<Varchar, Generic<T1>>>& inputMap,
+      const arg_type<Array<Varchar>>& oldKeys,
+      const arg_type<Array<Varchar>>& newKeys) {
+    if (inputMap.empty()) {
+      return;
+    }
+
+    // Build mapping from old keys to new keys
+    folly::F14FastMap<StringView, StringView> keyMapping;
+
+    auto oldKeysSize = oldKeys.size();
+    auto newKeysSize = newKeys.size();
+    auto minSize = std::min(oldKeysSize, newKeysSize);
+
+    auto oldIt = oldKeys.begin();
+    auto newIt = newKeys.begin();
+
+    for (size_t i = 0; i < minSize; ++i, ++oldIt, ++newIt) {
+      if (oldIt->has_value() && newIt->has_value()) {
+        keyMapping[oldIt->value()] = newIt->value();
+      }
+    }
+
+    // Iterate through input map and remap keys
+    for (const auto& entry : inputMap) {
+      auto it = keyMapping.find(entry.first);
+
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        if (it != keyMapping.end()) {
+          // Key is remapped - must copy from newKeys array
+          keyWriter.copy_from(it->second);
+        } else {
+          // Key is not remapped - can reuse from inputMap
+          keyWriter.setNoCopy(entry.first);
+        }
+      } else {
+        auto [keyWriter, valueWriter] = out.add_item();
+        if (it != keyMapping.end()) {
+          // Key is remapped - must copy from newKeys array
+          keyWriter.copy_from(it->second);
+        } else {
+          // Key is not remapped - can reuse from inputMap
+          keyWriter.setNoCopy(entry.first);
+        }
+        valueWriter.copy_from(entry.second.value());
+      }
+    }
+  }
+};
+
+struct RemapKeysFunctionEqualComparator {
+  bool operator()(const exec::GenericView& lhs, const exec::GenericView& rhs)
+      const {
+    static constexpr auto kEqualValueAtFlags = CompareFlags::equality(
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+
+    auto result = lhs.compare(rhs, kEqualValueAtFlags);
+
+    VELOX_USER_CHECK(
+        result.has_value(), "Comparison on null elements is not supported");
+
+    return result.value() == 0;
+  }
+};
+
+struct RemapKeysFunctionHasher {
+  size_t operator()(const exec::GenericView& value) const {
+    return value.hash();
+  }
+};
+
+/// Generic implementation for complex types.
+template <typename TExec>
+struct RemapKeysFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      out_type<Map<Generic<T1>, Generic<T2>>>& out,
+      const arg_type<Map<Generic<T1>, Generic<T2>>>& inputMap,
+      const arg_type<Array<Generic<T1>>>& oldKeys,
+      const arg_type<Array<Generic<T1>>>& newKeys) {
+    if (inputMap.empty()) {
+      return;
+    }
+
+    auto oldKeysSize = oldKeys.size();
+    auto newKeysSize = newKeys.size();
+    auto minSize = std::min(oldKeysSize, newKeysSize);
+
+    // Iterate through input map and remap keys
+    for (const auto& entry : inputMap) {
+      std::optional<size_t> matchIndex;
+
+      // Search for matching old key
+      auto oldIt = oldKeys.begin();
+      for (size_t i = 0; i < minSize; ++i, ++oldIt) {
+        if (oldIt->has_value()) {
+          RemapKeysFunctionEqualComparator comparator;
+          if (comparator(entry.first, oldIt->value())) {
+            matchIndex = i;
+            break;
+          }
+        }
+      }
+
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        if (matchIndex.has_value()) {
+          auto newIt = newKeys.begin();
+          std::advance(newIt, matchIndex.value());
+          if (newIt->has_value()) {
+            keyWriter.copy_from(newIt->value());
+          } else {
+            keyWriter.copy_from(entry.first);
+          }
+        } else {
+          keyWriter.copy_from(entry.first);
+        }
+      } else {
+        auto [keyWriter, valueWriter] = out.add_item();
+        if (matchIndex.has_value()) {
+          auto newIt = newKeys.begin();
+          std::advance(newIt, matchIndex.value());
+          if (newIt->has_value()) {
+            keyWriter.copy_from(newIt->value());
+          } else {
+            keyWriter.copy_from(entry.first);
+          }
+        } else {
+          keyWriter.copy_from(entry.first);
+        }
+        valueWriter.copy_from(entry.second.value());
+      }
+    }
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/S2CellOperations.cpp b/velox/functions/prestosql/S2CellOperations.cpp
new file mode 100644
index 00000000000..e13d9be565a
--- /dev/null
+++ b/velox/functions/prestosql/S2CellOperations.cpp
@@ -0,0 +1,230 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/S2CellOperations.h"
+
+#include <memory>
+
+#include <vector>
+
+#include <geos/geom/Geometry.h>
+#include <geos/geom/LineString.h>
+#include <geos/geom/LinearRing.h>
+#include <geos/geom/Polygon.h>
+#include <s2/s2cell.h>
+#include <s2/s2cell_id.h>
+#include <s2/s2earth.h>
+#include <s2/s2latlng.h>
+#include <s2/s2loop.h>
+#include <s2/s2point.h>
+#include <s2/s2polygon.h>
+#include <s2/s2polyline.h>
+#include <s2/s2region_coverer.h>
+
+namespace facebook::velox::functions {
+
+namespace {
+
+// Maps a GEOS coordinate (x=longitude, y=latitude) to a point on the
+// unit sphere.
+S2Point toS2Point(const geos::geom::Coordinate& coord) {
+  return S2LatLng::FromDegrees(coord.y, coord.x).ToPoint();
+}
+
+// Converts a GEOS linear ring to an S2Loop. Skips the closing vertex
+// (GEOS rings repeat the first vertex; S2 loops are implicitly closed).
+// Normalizes the loop so it encloses the smaller of the two spherical
+// regions it defines.
+std::unique_ptr<S2Loop> toS2Loop(const geos::geom::LinearRing& ring) {
+  auto coords = ring.getCoordinates();
+  auto numVertices = coords->getSize() - 1;
+  std::vector<S2Point> points;
+  points.reserve(numVertices);
+  for (size_t i = 0; i < numVertices; ++i) {
+    points.push_back(toS2Point(coords->getAt(i)));
+  }
+  auto loop = std::make_unique<S2Loop>(points);
+  loop->Normalize();
+  return loop;
+}
+
+// Converts a GEOS geometry to S2 objects and appends the cell covering.
+// A polygon valid in GEOS can be invalid on the sphere (e.g.,
+// self-intersecting edges after geodesic projection), which is why we
+// check S2Polygon::IsValid().
+std::string appendCovering(
+    const geos::geom::Geometry& geom,
+    int32_t level,
+    S2RegionCoverer& coverer,
+    std::vector<uint64_t>& result) {
+  if (geom.isEmpty()) {
+    return {};
+  }
+
+  auto typeId = geom.getGeometryTypeId();
+
+  if (typeId == geos::geom::GeometryTypeId::GEOS_POINT) {
+    result.push_back(
+        S2CellId(toS2Point(*geom.getCoordinate())).parent(level).id());
+
+  } else if (typeId == geos::geom::GeometryTypeId::GEOS_LINESTRING) {
+    auto coords = geom.getCoordinates();
+    if (coords->getSize() < 2) {
+      return "LineString must have at least 2 points";
+    }
+    std::vector<S2Point> points;
+    points.reserve(coords->getSize());
+    for (size_t i = 0; i < coords->getSize(); ++i) {
+      points.push_back(toS2Point(coords->getAt(i)));
+    }
+    S2Polyline polyline(points);
+    std::vector<S2CellId> covering;
+    coverer.GetCovering(polyline, &covering);
+    for (const auto& cellId : covering) {
+      result.push_back(cellId.id());
+    }
+
+  } else if (typeId == geos::geom::GeometryTypeId::GEOS_POLYGON) {
+    const auto& polygon = static_cast<const geos::geom::Polygon&>(geom);
+
+    auto* exteriorRing = polygon.getExteriorRing();
+    if (exteriorRing->getNumPoints() < 4) {
+      return "Polygon ring must have at least 4 points";
+    }
+
+    // Build S2Polygon from exterior ring and holes. The S2Polygon
+    // constructor determines hole nesting automatically.
+    std::vector<std::unique_ptr<S2Loop>> loops;
+    loops.reserve(1 + polygon.getNumInteriorRing());
+    loops.push_back(toS2Loop(*exteriorRing));
+    for (size_t i = 0; i < polygon.getNumInteriorRing(); ++i) {
+      loops.push_back(toS2Loop(*polygon.getInteriorRingN(i)));
+    }
+
+    S2Polygon s2polygon(std::move(loops));
+    if (!s2polygon.IsValid()) {
+      return "Polygon is not valid on the sphere";
+    }
+    std::vector<S2CellId> covering;
+    coverer.GetCovering(s2polygon, &covering);
+    for (const auto& cellId : covering) {
+      result.push_back(cellId.id());
+    }
+
+  } else {
+    for (size_t i = 0; i < geom.getNumGeometries(); ++i) {
+      auto error =
+          appendCovering(*geom.getGeometryN(i), level, coverer, result);
+      if (!error.empty()) {
+        return error;
+      }
+    }
+  }
+
+  return {};
+}
+
+} // namespace
+
+namespace {
+
+S2CellId s2CellId(int64_t cellId) {
+  return S2CellId(static_cast<uint64_t>(cellId));
+}
+
+int64_t fromS2CellId(S2CellId cellId) {
+  return static_cast<int64_t>(cellId.id());
+}
+
+} // namespace
+
+bool S2CellOp::isValid(int64_t cellId) {
+  return s2CellId(cellId).is_valid();
+}
+
+double S2CellOp::areaSqKm(int64_t cellId) {
+  return S2Earth::SteradiansToSquareKm(::S2Cell{s2CellId(cellId)}.ExactArea());
+}
+
+int S2CellOp::level(int64_t cellId) {
+  return s2CellId(cellId).level();
+}
+
+int64_t S2CellOp::parent(int64_t cellId, int level) {
+  return fromS2CellId(s2CellId(cellId).parent(level));
+}
+
+bool S2CellOp::contains(int64_t parent, int64_t child) {
+  return s2CellId(parent).contains(s2CellId(child));
+}
+
+int64_t S2CellOp::fromToken(std::string_view token) {
+  return fromS2CellId(S2CellId::FromToken(token));
+}
+
+std::string S2CellOp::toToken(int64_t cellId) {
+  return s2CellId(cellId).ToToken();
+}
+
+int64_t
+S2CellOp::cellIdFromFacePositionLevel(int face, uint64_t position, int level) {
+  // Start with a valid face cell and descend to the target level by picking
+  // a child (0-3) at each step, determined by successive 2-bit groups of
+  // 'position'.
+  auto cellId = S2CellId::FromFace(face);
+  for (int i = 0; i < level; ++i) {
+    cellId = cellId.child(static_cast<int>(position & 3));
+    position >>= 2;
+  }
+  return fromS2CellId(cellId);
+}
+
+S2Covering S2CellOp::tryCovering(
+    const geos::geom::Geometry& geom,
+    int32_t level) {
+  S2RegionCoverer::Options options;
+  options.set_min_level(level);
+  options.set_max_level(level);
+  S2RegionCoverer coverer(options);
+
+  std::vector<uint64_t> cellIds;
+  auto error = appendCovering(geom, level, coverer, cellIds);
+  if (!error.empty()) {
+    return {{}, std::move(error)};
+  }
+  return {std::vector<int64_t>(cellIds.begin(), cellIds.end()), {}};
+}
+
+S2Covering S2CellOp::tryDissolvedCovering(
+    const geos::geom::Geometry& geom,
+    int32_t minLevel,
+    int32_t maxLevel,
+    int32_t maxCells) {
+  S2RegionCoverer::Options options;
+  options.set_min_level(minLevel);
+  options.set_max_level(maxLevel);
+  options.set_max_cells(maxCells);
+  S2RegionCoverer coverer(options);
+
+  std::vector<uint64_t> cellIds;
+  auto error = appendCovering(geom, maxLevel, coverer, cellIds);
+  if (!error.empty()) {
+    return {{}, std::move(error)};
+  }
+  return {std::vector<int64_t>(cellIds.begin(), cellIds.end()), {}};
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/S2CellOperations.h b/velox/functions/prestosql/S2CellOperations.h
new file mode 100644
index 00000000000..a04300ad4e9
--- /dev/null
+++ b/velox/functions/prestosql/S2CellOperations.h
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Build isolation layer for s2geometry. s2geometry's malloc_extension.h
+// and folly's MallocImpl.h both define `nallocx` with incompatible types
+// (function declaration vs function pointer). This header exposes S2
+// operations through primitive types so that no translation unit needs
+// to include both s2geometry and folly headers.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace geos::geom {
+class Geometry;
+} // namespace geos::geom
+
+namespace facebook::velox::functions {
+
+/// Result of an S2 covering operation. Empty 'error' indicates success.
+struct S2Covering {
+  std::vector<int64_t> cellIds;
+  std::string error;
+};
+
+/// Wraps s2geometry operations, isolated from folly headers.
+/// All methods are static — no instance state. Cell IDs are int64_t
+/// (reinterpreted from unsigned S2 cell IDs) to match the SQL BIGINT type.
+///
+/// Unless otherwise noted, methods that accept a cell ID require it to be
+/// valid (as determined by isValid()). Passing an invalid cell ID results
+/// in undefined behavior. Callers should validate via isValid() first.
+struct S2CellOp {
+  /// Returns true if 'cellId' is a valid S2 cell identifier.
+  /// Safe to call with any int64_t value.
+  static bool isValid(int64_t cellId);
+
+  /// Returns the area of the cell in square kilometers.
+  static double areaSqKm(int64_t cellId);
+
+  /// Returns the level (0–30) of the cell.
+  static int level(int64_t cellId);
+
+  /// Returns the ancestor cell at the given level.
+  static int64_t parent(int64_t cellId, int level);
+
+  /// Returns true if 'parent' contains 'child'.
+  static bool contains(int64_t parent, int64_t child);
+
+  /// Converts a hex token string to a cell identifier. The returned cell ID
+  /// may be invalid if the token is malformed; callers should check with
+  /// isValid().
+  static int64_t fromToken(std::string_view token);
+
+  /// Converts a cell identifier to a hex token string.
+  static std::string toToken(int64_t cellId);
+
+  /// Constructs a valid cell ID by starting from a face cell (0–5) and
+  /// descending to the given level (0–30). At each level, the next child
+  /// (0–3) is selected from successive 2-bit groups of 'position'
+  /// (bits [1:0] for level 1, bits [3:2] for level 2, etc.). Any uint64_t
+  /// value is safe — extra bits beyond 2*level are ignored.
+  static int64_t
+  cellIdFromFacePositionLevel(int face, uint64_t position, int level);
+
+  /// Converts a GEOS geometry to S2 objects and returns the cell covering.
+  /// GEOS uses planar (straight-line) edges; S2 uses geodesic (great-circle)
+  /// edges. For small geometries the difference is negligible; for large ones
+  /// (country-sized) the S2 covering follows Earth's curvature.
+  static S2Covering tryCovering(
+      const geos::geom::Geometry& geom,
+      int32_t level);
+
+  /// Returns a compact mixed-level covering, similar to
+  /// geometry_to_dissolved_bing_tiles. Uses large cells for interiors and
+  /// small cells for boundaries.
+  static S2Covering tryDissolvedCovering(
+      const geos::geom::Geometry& geom,
+      int32_t minLevel,
+      int32_t maxLevel,
+      int32_t maxCells);
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/S2Functions.h b/velox/functions/prestosql/S2Functions.h
new file mode 100644
index 00000000000..878168a6d8f
--- /dev/null
+++ b/velox/functions/prestosql/S2Functions.h
@@ -0,0 +1,222 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string_view>
+
+#include <folly/CPortability.h>
+#include "velox/common/base/Status.h"
+#include "velox/common/geospatial/GeometrySerde.h"
+#include "velox/functions/Macros.h"
+#include "velox/functions/prestosql/S2CellOperations.h"
+#include "velox/functions/prestosql/types/GeometryType.h"
+
+namespace facebook::velox::functions {
+
+namespace detail {
+
+template <typename... Args>
+Status userError(std::string_view format, Args&&... args) {
+  if (threadSkipErrorDetails()) {
+    return Status::UserError();
+  }
+  return Status::UserError(format, std::forward<Args>(args)...);
+}
+
+inline Status validateCellId(int64_t cellId, std::string_view functionName) {
+  if (!S2CellOp::isValid(cellId)) {
+    return userError("{}: Invalid cell ID: {}", functionName, cellId);
+  }
+  return Status::OK();
+}
+
+inline Status validateLevel(int32_t level, std::string_view functionName) {
+  if (level < 0 || level > 30) {
+    return userError(
+        "{}: Level must be in [0, 30] range, got {}", functionName, level);
+  }
+  return Status::OK();
+}
+
+} // namespace detail
+
+/// Implements the s2_cell_area_sq_km SQL function.
+template <typename TExec>
+struct S2CellAreaSqKmFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(double& result, const arg_type<int64_t>& cellId) {
+    VELOX_RETURN_NOT_OK(detail::validateCellId(cellId, "s2_cell_area_sq_km"));
+    result = S2CellOp::areaSqKm(cellId);
+    return Status::OK();
+  }
+};
+
+/// Implements the s2_cell_contains SQL function.
+template <typename TExec>
+struct S2CellContainsFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE Status call(
+      bool& result,
+      const arg_type<int64_t>& parent,
+      const arg_type<int64_t>& child) {
+    VELOX_RETURN_NOT_OK(detail::validateCellId(parent, "s2_cell_contains"));
+    VELOX_RETURN_NOT_OK(detail::validateCellId(child, "s2_cell_contains"));
+    result = S2CellOp::contains(parent, child);
+    return Status::OK();
+  }
+};
+
+/// Implements the s2_cell_from_token SQL function.
+template <typename TExec>
+struct S2CellFromTokenFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(int64_t& result, const arg_type<Varchar>& token) {
+    if (token.empty()) {
+      return detail::userError("s2_cell_from_token: Empty cell token");
+    }
+    result = S2CellOp::fromToken({token.data(), token.size()});
+    if (!S2CellOp::isValid(result)) {
+      return detail::userError(
+          "s2_cell_from_token: Invalid cell token: {}",
+          std::string_view(token.data(), token.size()));
+    }
+    return Status::OK();
+  }
+};
+
+/// Implements the s2_cell_level SQL function.
+template <typename TExec>
+struct S2CellLevelFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(int32_t& result, const arg_type<int64_t>& cellId) {
+    VELOX_RETURN_NOT_OK(detail::validateCellId(cellId, "s2_cell_level"));
+    result = S2CellOp::level(cellId);
+    return Status::OK();
+  }
+};
+
+/// Implements the s2_cell_parent SQL function.
+template <typename TExec>
+struct S2CellParentFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE Status call(
+      int64_t& result,
+      const arg_type<int64_t>& cellId,
+      const arg_type<int32_t>& level) {
+    VELOX_RETURN_NOT_OK(detail::validateLevel(level, "s2_cell_parent"));
+    VELOX_RETURN_NOT_OK(detail::validateCellId(cellId, "s2_cell_parent"));
+
+    if (S2CellOp::level(cellId) <= level) {
+      result = cellId;
+      return Status::OK();
+    }
+    result = S2CellOp::parent(cellId, level);
+    return Status::OK();
+  }
+};
+
+/// Implements the s2_cell_to_token SQL function.
+template <typename TExec>
+struct S2CellToTokenFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<Varchar>& result, const arg_type<int64_t>& cellId) {
+    VELOX_RETURN_NOT_OK(detail::validateCellId(cellId, "s2_cell_to_token"));
+    result = S2CellOp::toToken(cellId);
+    return Status::OK();
+  }
+};
+
+/// Implements the fixed-level s2_cells(geometry, level) SQL function.
+template <typename TExec>
+struct S2CellsFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<Array<int64_t>>& result,
+      const arg_type<Geometry>& geometry,
+      const arg_type<int32_t>& level) {
+    VELOX_RETURN_NOT_OK(detail::validateLevel(level, "s2_cells"));
+
+    auto geom =
+        common::geospatial::GeometryDeserializer::deserializeNonEmpty(geometry);
+    if (!geom) {
+      return Status::OK();
+    }
+    auto covering = S2CellOp::tryCovering(*geom, level);
+    if (!covering.error.empty()) {
+      return detail::userError("s2_cells: {}", covering.error);
+    }
+    for (auto cellId : covering.cellIds) {
+      result.add_item() = cellId;
+    }
+    return Status::OK();
+  }
+};
+
+/// Implements the dissolved s2_cells(geometry, minLevel, maxLevel, maxCells)
+/// SQL function.
+template <typename TExec>
+struct S2CellsDissolvedFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<Array<int64_t>>& result,
+      const arg_type<Geometry>& geometry,
+      const arg_type<int32_t>& minLevel,
+      const arg_type<int32_t>& maxLevel,
+      const arg_type<int32_t>& maxCells) {
+    VELOX_RETURN_NOT_OK(detail::validateLevel(minLevel, "s2_cells"));
+    VELOX_RETURN_NOT_OK(detail::validateLevel(maxLevel, "s2_cells"));
+    if (minLevel > maxLevel) {
+      return detail::userError(
+          "s2_cells: min_level ({}) must be <= max_level ({})",
+          minLevel,
+          maxLevel);
+    }
+    if (maxCells < 1) {
+      return detail::userError(
+          "s2_cells: max_cells must be >= 1, got {}", maxCells);
+    }
+
+    auto geom =
+        common::geospatial::GeometryDeserializer::deserializeNonEmpty(geometry);
+    if (!geom) {
+      return Status::OK();
+    }
+    auto covering =
+        S2CellOp::tryDissolvedCovering(*geom, minLevel, maxLevel, maxCells);
+    if (!covering.error.empty()) {
+      return detail::userError("s2_cells: {}", covering.error);
+    }
+    for (auto cellId : covering.cellIds) {
+      result.add_item() = cellId;
+    }
+    return Status::OK();
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/Sequence.cpp b/velox/functions/prestosql/Sequence.cpp
index 20d11e57827..0733f9aab29 100644
--- a/velox/functions/prestosql/Sequence.cpp
+++ b/velox/functions/prestosql/Sequence.cpp
@@ -14,232 +14,11 @@
  * limitations under the License.
  */
 
-#include <iostream>
-#include "velox/expression/DecodedArgs.h"
-#include "velox/expression/VectorFunction.h"
-#include "velox/functions/prestosql/DateTimeImpl.h"
-#include "velox/vector/ConstantVector.h"
+#include "velox/functions/lib/Sequence.h"
 
 namespace facebook::velox::functions {
-namespace {
-
-template <typename T>
-int64_t toInt64(T value);
-
-template <>
-int64_t toInt64(int64_t value) {
-  return value;
-}
-
-template <>
-int64_t toInt64(int32_t value) {
-  return value;
-}
-
-template <>
-int64_t toInt64(Timestamp value) {
-  return value.toMillis();
-}
-
-using Days = int64_t;
-using Months = int32_t;
-template <typename T, typename K>
-T add(T value, K step, int32_t sequence);
-
-template <>
-int64_t add(int64_t value, int64_t step, int32_t sequence) {
-  const auto delta =
-      static_cast<int128_t>(step) * static_cast<int128_t>(sequence);
-  // Since step is calcuated from start and stop,
-  // the sum of 'value' and 'add' is within int64_t.
-  return value + delta;
-}
-
-template <>
-int32_t add(int32_t value, int64_t step, int32_t sequence) {
-  const auto delta =
-      static_cast<int128_t>(step) * static_cast<int128_t>(sequence);
-  return value + delta;
-}
-
-template <>
-Timestamp add(Timestamp value, int64_t step, int32_t sequence) {
-  const auto delta =
-      static_cast<int128_t>(step) * static_cast<int128_t>(sequence);
-  return Timestamp::fromMillis(value.toMillis() + delta);
-}
-
-template <>
-int32_t add(int32_t value, Months step, int32_t sequence) {
-  return addToDate(value, DateTimeUnit::kMonth, step * sequence);
-}
-
-template <>
-Timestamp add(Timestamp value, Months step, int32_t sequence) {
-  return addToTimestamp(value, DateTimeUnit::kMonth, step * sequence);
-}
-
-template <typename T>
-int128_t getStepCount(T start, T end, int32_t step) {
-  VELOX_FAIL("Unexpected start/end type for argument INTERVAL_YEAR_MONTH");
-}
-
-int128_t getStepCount(int32_t start, int32_t end, int32_t step) {
-  return diffDate(DateTimeUnit::kMonth, start, end) / step + 1;
-}
 
-int128_t getStepCount(Timestamp start, Timestamp end, int32_t step) {
-  return diffTimestamp(DateTimeUnit::kMonth, start, end) / step + 1;
-}
-
-// See documentation at https://prestodb.io/docs/current/functions/array.html
-template <typename T, typename K>
-class SequenceFunction : public exec::VectorFunction {
- public:
-  void apply(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& outputType,
-      exec::EvalCtx& context,
-      VectorPtr& result) const override {
-    exec::DecodedArgs decodedArgs(rows, args, context);
-    auto startVector = decodedArgs.at(0);
-    auto stopVector = decodedArgs.at(1);
-    DecodedVector* stepVector = nullptr;
-    bool isIntervalYearMonth = false;
-    if (args.size() == 3) {
-      stepVector = decodedArgs.at(2);
-      isIntervalYearMonth = args[2]->type()->isIntervalYearMonth();
-    }
-
-    const auto numRows = rows.end();
-    auto pool = context.pool();
-    vector_size_t numElements = 0;
-
-    BufferPtr sizes = allocateSizes(numRows, pool);
-    BufferPtr offsets = allocateOffsets(numRows, pool);
-    auto rawSizes = sizes->asMutable<vector_size_t>();
-    auto rawOffsets = offsets->asMutable<vector_size_t>();
-
-    const bool isDate = args[0]->type()->isDate();
-    context.applyToSelectedNoThrow(rows, [&](auto row) {
-      rawSizes[row] = checkArguments(
-          startVector,
-          stopVector,
-          stepVector,
-          row,
-          isDate,
-          isIntervalYearMonth,
-          context.execCtx()
-              ->queryCtx()
-              ->queryConfig()
-              .maxElementsSizeInRepeatAndSequence());
-      numElements += rawSizes[row];
-    });
-
-    VectorPtr elements =
-        BaseVector::create(outputType->childAt(0), numElements, pool);
-    auto rawElements = elements->asFlatVector<T>()->mutableRawValues();
-
-    vector_size_t elementsOffset = 0;
-    context.applyToSelectedNoThrow(rows, [&](auto row) {
-      const auto sequenceCount = rawSizes[row];
-      if (sequenceCount) {
-        rawOffsets[row] = elementsOffset;
-        writeToElements(
-            rawElements + elementsOffset,
-            isDate,
-            isIntervalYearMonth,
-            sequenceCount,
-            startVector,
-            stopVector,
-            stepVector,
-            row);
-        elementsOffset += rawSizes[row];
-      }
-    });
-    context.moveOrCopyResult(
-        std::make_shared<ArrayVector>(
-            pool, outputType, nullptr, numRows, offsets, sizes, elements),
-        rows,
-        result);
-  }
-
- private:
-  static vector_size_t checkArguments(
-      DecodedVector* startVector,
-      DecodedVector* stopVector,
-      DecodedVector* stepVector,
-      vector_size_t row,
-      bool isDate,
-      bool isYearMonth,
-      int32_t maxElementsSize) {
-    T start = startVector->valueAt<T>(row);
-    T stop = stopVector->valueAt<T>(row);
-    auto step = getStep(
-        toInt64(start), toInt64(stop), stepVector, row, isDate, isYearMonth);
-    VELOX_USER_CHECK_NE(step, 0, "step must not be zero");
-    VELOX_USER_CHECK(
-        step > 0 ? stop >= start : stop <= start,
-        "sequence stop value should be greater than or equal to start value if "
-        "step is greater than zero otherwise stop should be less than or equal to start");
-    int128_t sequenceCount;
-    if (isYearMonth) {
-      sequenceCount = getStepCount(start, stop, step);
-    } else {
-      sequenceCount = (static_cast<int128_t>(toInt64(stop)) -
-                       static_cast<int128_t>(toInt64(start))) /
-              step +
-          1; // prevent overflow
-    }
-
-    VELOX_USER_CHECK_LE(
-        sequenceCount,
-        maxElementsSize,
-        "result of sequence function must not have more than {} entries",
-        maxElementsSize);
-    return sequenceCount;
-  }
-
-  static void writeToElements(
-      T* elements,
-      bool isDate,
-      bool isYearMonth,
-      vector_size_t sequenceCount,
-      DecodedVector* startVector,
-      DecodedVector* stopVector,
-      DecodedVector* stepVector,
-      vector_size_t row) {
-    auto start = startVector->valueAt<T>(row);
-    auto stop = stopVector->valueAt<T>(row);
-    auto step = getStep(
-        toInt64(start), toInt64(stop), stepVector, row, isDate, isYearMonth);
-    for (auto sequence = 0; sequence < sequenceCount; ++sequence) {
-      elements[sequence] = add(start, step, sequence);
-    }
-  }
-
-  static K getStep(
-      int64_t start,
-      int64_t stop,
-      DecodedVector* stepVector,
-      vector_size_t row,
-      bool isDate,
-      bool isYearMonth) {
-    if (!stepVector) {
-      return (stop >= start ? 1 : -1);
-    }
-    auto step = stepVector->valueAt<K>(row);
-    if (!isDate || isYearMonth) {
-      return step;
-    }
-    // Handle Date
-    VELOX_USER_CHECK(
-        step % kMillisInDay == 0,
-        "sequence step must be a day interval if start and end values are dates");
-    return step / kMillisInDay;
-  }
-};
+namespace {
 
 std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
   std::vector<std::shared_ptr<exec::FunctionSignature>> signatures;
diff --git a/velox/functions/prestosql/SetDigestFunctions.h b/velox/functions/prestosql/SetDigestFunctions.h
new file mode 100644
index 00000000000..1e981e7abdd
--- /dev/null
+++ b/velox/functions/prestosql/SetDigestFunctions.h
@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/core/QueryConfig.h"
+#include "velox/functions/Macros.h"
+#include "velox/functions/lib/SetDigest.h"
+
+namespace facebook::velox::functions {
+
+/// Scalar function: cardinality(setdigest) -> bigint
+/// Returns the estimated cardinality of the set digest.
+template <typename T>
+struct CardinalitySetDigestFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<Varbinary>* /*input*/) {
+    VELOX_CHECK_NOT_NULL(
+        pool, "cardinality requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<int64_t>& result, const arg_type<Varbinary>& input) {
+    SetDigest<int64_t> digest(allocator_.get());
+    VELOX_RETURN_NOT_OK(digest.deserialize(input.data(), input.size()));
+    result = digest.cardinality();
+    return Status::OK();
+  }
+};
+
+/// Scalar function: intersection_cardinality(setdigest, setdigest) -> bigint
+/// Returns the intersection cardinality between two set digests.
+/// - If both digests are exact: returns exact intersection count
+/// - If either digest is approximate: returns estimated intersection using
+/// Jaccard index
+template <typename T>
+struct IntersectionCardinalityFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<Varbinary>* /*input1*/,
+      const arg_type<Varbinary>* /*input2*/) {
+    VELOX_CHECK_NOT_NULL(
+        pool,
+        "intersection_cardinality requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<int64_t>& result,
+      const arg_type<Varbinary>& input1,
+      const arg_type<Varbinary>& input2) {
+    using SetDigestType = SetDigest<int64_t>;
+
+    SetDigestType digest1(allocator_.get());
+    VELOX_RETURN_NOT_OK(digest1.deserialize(input1.data(), input1.size()));
+
+    SetDigestType digest2(allocator_.get());
+    VELOX_RETURN_NOT_OK(digest2.deserialize(input2.data(), input2.size()));
+
+    // If both are exact, use exact intersection
+    if (digest1.isExact() && digest2.isExact()) {
+      result = SetDigestType::exactIntersectionCardinality(digest1, digest2);
+      return Status::OK();
+    }
+
+    // Otherwise, estimate using Jaccard index (matching Java behavior)
+    int64_t cardinality1 = digest1.cardinality();
+    int64_t cardinality2 = digest2.cardinality();
+    double jaccard = SetDigestType::jaccardIndex(digest1, digest2);
+    digest1.mergeWith(digest2);
+    int64_t estimatedIntersection =
+        std::llround(jaccard * digest1.cardinality());
+
+    // When one set is much smaller and approaches being a subset of the other,
+    // the computed cardinality may exceed the smaller set's cardinality.
+    // In this case, the smaller cardinality is a better estimate.
+    result =
+        std::min(estimatedIntersection, std::min(cardinality1, cardinality2));
+    return Status::OK();
+  }
+};
+
+/// Scalar function: jaccard_index(setdigest, setdigest) -> double
+/// Returns the Jaccard index (similarity coefficient) between two set digests.
+/// The Jaccard index is a value in [0, 1] where:
+/// - 1.0 means the sets are identical
+/// - 0.0 means the sets are disjoint (no overlap)
+/// Uses MinHash estimation for efficient computation.
+template <typename T>
+struct JaccardIndexFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<Varbinary>* /*input1*/,
+      const arg_type<Varbinary>* /*input2*/) {
+    VELOX_CHECK_NOT_NULL(
+        pool, "jaccard_index requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<double>& result,
+      const arg_type<Varbinary>& input1,
+      const arg_type<Varbinary>& input2) {
+    using SetDigestType = SetDigest<int64_t>;
+
+    SetDigestType digest1(allocator_.get());
+    VELOX_RETURN_NOT_OK(digest1.deserialize(input1.data(), input1.size()));
+
+    SetDigestType digest2(allocator_.get());
+    VELOX_RETURN_NOT_OK(digest2.deserialize(input2.data(), input2.size()));
+
+    result = SetDigestType::jaccardIndex(digest1, digest2);
+    return Status::OK();
+  }
+};
+
+/// Scalar function: hash_counts(setdigest) -> map(bigint, smallint)
+/// Returns a map of hash values to their occurrence counts.
+/// This exposes the MinHash component of the SetDigest, showing which
+/// hash values were tracked and how many times each value was added.
+/// Only available when the digest is exact (cardinality < maxHashes).
+template <typename T>
+struct HashCountsFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<Varbinary>* /*input*/) {
+    VELOX_CHECK_NOT_NULL(
+        pool, "hash_counts requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<Map<int64_t, int16_t>>& result,
+      const arg_type<Varbinary>& input) {
+    SetDigest<int64_t> digest(allocator_.get());
+    VELOX_RETURN_NOT_OK(digest.deserialize(input.data(), input.size()));
+
+    auto hashCounts = digest.getHashCounts();
+    result.reserve(hashCounts.size());
+
+    for (const auto& [key, value] : hashCounts) {
+      auto item = result.add_item();
+      std::get<0>(item) = key;
+      std::get<1>(item) = value;
+    }
+
+    return Status::OK();
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/SfmSketchFunctions.h b/velox/functions/prestosql/SfmSketchFunctions.h
index 79f23079020..7f117c4c3d6 100644
--- a/velox/functions/prestosql/SfmSketchFunctions.h
+++ b/velox/functions/prestosql/SfmSketchFunctions.h
@@ -34,12 +34,17 @@ template <typename T>
 struct SfmSketchCardinality {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
+  std::unique_ptr<HashStringAllocator> allocator_;
+
   FOLLY_ALWAYS_INLINE void initialize(
       const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
       const arg_type<SfmSketch>* /*input*/) {
-    pool_ = memory::memoryManager()->addLeafPool();
-    allocator_ = std::make_unique<HashStringAllocator>(pool_.get());
+    VELOX_USER_CHECK_NOT_NULL(
+        pool,
+        "sfm_sketch_cardinality requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
   }
 
   FOLLY_ALWAYS_INLINE void call(
@@ -50,24 +55,25 @@ struct SfmSketchCardinality {
                  reinterpret_cast<const char*>(input.data()), allocator_.get())
                  .cardinality();
   }
-
- private:
-  std::shared_ptr<memory::MemoryPool> pool_;
-  std::unique_ptr<HashStringAllocator> allocator_;
 };
 
 template <typename T>
 struct NoisyEmptyApproxSetSfm {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
+  std::unique_ptr<HashStringAllocator> allocator_;
+
   FOLLY_ALWAYS_INLINE void initialize(
       const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
       const double* /*epsilon*/,
       const int64_t* /*buckets*/ = nullptr,
       const int64_t* /*precision*/ = nullptr) {
-    pool_ = memory::memoryManager()->addLeafPool();
-    allocator_ = std::make_unique<HashStringAllocator>(pool_.get());
+    VELOX_USER_CHECK_NOT_NULL(
+        pool,
+        "noisy_empty_approx_set_sfm requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
   }
 
   FOLLY_ALWAYS_INLINE void call(
@@ -98,22 +104,22 @@ struct NoisyEmptyApproxSetSfm {
     result.resize(serialized.size());
     memcpy(result.data(), serialized.data(), serialized.size());
   }
-
- private:
-  std::shared_ptr<memory::MemoryPool> pool_;
-  std::unique_ptr<HashStringAllocator> allocator_;
 };
 
 template <typename T>
 struct mergeSfmSketchArray {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
+  std::unique_ptr<HashStringAllocator> allocator_;
+
   FOLLY_ALWAYS_INLINE void initialize(
       const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
       const arg_type<Array<SfmSketch>>* /*input*/) {
-    pool_ = memory::memoryManager()->addLeafPool();
-    allocator_ = std::make_unique<HashStringAllocator>(pool_.get());
+    VELOX_USER_CHECK_NOT_NULL(
+        pool, "merge_sfm requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
   }
 
   FOLLY_ALWAYS_INLINE bool call(
@@ -153,10 +159,6 @@ struct mergeSfmSketchArray {
 
     return true;
   }
-
- private:
-  std::shared_ptr<memory::MemoryPool> pool_;
-  std::unique_ptr<HashStringAllocator> allocator_;
 };
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/SimpleComparisonMatcher.cpp b/velox/functions/prestosql/SimpleComparisonMatcher.cpp
deleted file mode 100644
index db194840b08..00000000000
--- a/velox/functions/prestosql/SimpleComparisonMatcher.cpp
+++ /dev/null
@@ -1,319 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/functions/prestosql/SimpleComparisonMatcher.h"
-#include "velox/vector/ConstantVector.h"
-
-namespace facebook::velox::functions::prestosql {
-
-namespace {
-
-class Matcher {
- public:
-  virtual bool match(const core::TypedExprPtr& expr) = 0;
-
-  virtual ~Matcher() = default;
-
-  static bool allMatch(
-      const std::vector<core::TypedExprPtr>& exprs,
-      std::vector<std::shared_ptr<Matcher>>& matchers) {
-    for (auto i = 0; i < exprs.size(); ++i) {
-      if (!matchers[i]->match(exprs[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-};
-
-using MatcherPtr = std::shared_ptr<Matcher>;
-
-class IfMatcher : public Matcher {
- public:
-  explicit IfMatcher(std::vector<MatcherPtr> inputMatchers)
-      : inputMatchers_{std::move(inputMatchers)} {
-    VELOX_CHECK_EQ(3, inputMatchers_.size());
-  }
-
-  bool match(const core::TypedExprPtr& expr) override {
-    if (auto call = dynamic_cast<const core::CallTypedExpr*>(expr.get())) {
-      if (call->name() == "if" && allMatch(call->inputs(), inputMatchers_)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
- private:
-  std::vector<MatcherPtr> inputMatchers_;
-};
-
-using IfMatcherPtr = std::shared_ptr<IfMatcher>;
-
-class ComparisonMatcher : public Matcher {
- public:
-  ComparisonMatcher(
-      const std::string& prefix,
-      std::vector<MatcherPtr> inputMatchers,
-      std::string* op)
-      : prefix_{prefix}, inputMatchers_{std::move(inputMatchers)}, op_{op} {
-    VELOX_CHECK_EQ(2, inputMatchers_.size());
-  }
-
-  bool match(const core::TypedExprPtr& expr) override {
-    if (auto call = dynamic_cast<const core::CallTypedExpr*>(expr.get())) {
-      const auto& name = call->name();
-      if (name == prefix_ + "eq" || name == prefix_ + "lt" ||
-          name == prefix_ + "gt") {
-        if (allMatch(call->inputs(), inputMatchers_)) {
-          *op_ = name;
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-
- private:
-  const std::string prefix_;
-  std::vector<MatcherPtr> inputMatchers_;
-  std::string* op_;
-};
-
-using ComparisonMatcherPtr = std::shared_ptr<ComparisonMatcher>;
-
-class AnySingleInputMatcher : public Matcher {
- public:
-  AnySingleInputMatcher(
-      core::TypedExprPtr* expr,
-      core::FieldAccessTypedExprPtr* input)
-      : expr_{expr}, input_{input} {}
-
-  bool match(const core::TypedExprPtr& expr) override {
-    // Check if 'expr' depends on a single column.
-    std::unordered_set<core::FieldAccessTypedExprPtr> inputs;
-    collectInputs(expr, inputs);
-
-    if (inputs.size() == 1) {
-      *expr_ = expr;
-      *input_ = *inputs.begin();
-      return true;
-    }
-
-    return false;
-  }
-
- private:
-  static void collectInputs(
-      const core::TypedExprPtr& expr,
-      std::unordered_set<core::FieldAccessTypedExprPtr>& inputs) {
-    if (auto field =
-            std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(expr)) {
-      if (field->isInputColumn()) {
-        inputs.insert(field);
-        return;
-      }
-    }
-
-    for (const auto& input : expr->inputs()) {
-      collectInputs(input, inputs);
-    }
-  }
-
-  core::TypedExprPtr* const expr_;
-  core::FieldAccessTypedExprPtr* const input_;
-};
-
-/// Matches constant expression that represents values 1, 0, or -1 of type
-/// BIGINT.
-class ComparisonConstantMatcher : public Matcher {
- public:
-  explicit ComparisonConstantMatcher(int64_t* value) : value_{value} {}
-
-  bool match(const core::TypedExprPtr& expr) override {
-    if (auto constant = asConstant(expr.get())) {
-      auto v = constant.value();
-      if (v == 0 || v == 1 || v == -1) {
-        *value_ = v;
-        return true;
-      }
-    }
-    return false;
-  }
-
- private:
-  static std::optional<int64_t> asConstant(const core::ITypedExpr* expr) {
-    if (auto constant = dynamic_cast<const core::ConstantTypedExpr*>(expr)) {
-      if (constant->hasValueVector()) {
-        auto constantVector =
-            constant->valueVector()->as<SimpleVector<int64_t>>();
-        if (!constantVector->isNullAt(0)) {
-          return constantVector->valueAt(0);
-        }
-      } else {
-        if (!constant->value().isNull()) {
-          if (constant->value().kind() == TypeKind::BIGINT) {
-            return constant->value().value<int64_t>();
-          }
-
-          if (constant->value().kind() == TypeKind::INTEGER) {
-            return constant->value().value<int32_t>();
-          }
-        }
-      }
-    }
-
-    return std::nullopt;
-  }
-
-  int64_t* const value_;
-};
-
-using ComparisonConstantMatcherPtr = std::shared_ptr<ComparisonConstantMatcher>;
-
-MatcherPtr ifelse(
-    const MatcherPtr& condition,
-    const MatcherPtr& thenClause,
-    const MatcherPtr& elseClause) {
-  return std::make_shared<IfMatcher>(
-      std::vector<MatcherPtr>{condition, thenClause, elseClause});
-}
-
-MatcherPtr comparison(
-    const std::string& prefix,
-    const MatcherPtr& left,
-    const MatcherPtr& right,
-    std::string* op) {
-  return std::make_shared<ComparisonMatcher>(
-      prefix, std::vector<MatcherPtr>{left, right}, op);
-}
-
-MatcherPtr anySingleInput(
-    core::TypedExprPtr* expr,
-    core::FieldAccessTypedExprPtr* input) {
-  return std::make_shared<AnySingleInputMatcher>(expr, input);
-}
-
-MatcherPtr comparisonConstant(int64_t* value) {
-  return std::make_shared<ComparisonConstantMatcher>(value);
-}
-
-std::string invert(const std::string& prefix, const std::string& op) {
-  return op == prefix + "lt" ? prefix + "gt" : prefix + "lt";
-}
-
-/// Returns true for a < b -> -1.
-bool isLessThen(
-    const std::string& prefix,
-    const std::string& operation,
-    const core::FieldAccessTypedExprPtr& left,
-    int64_t result,
-    const std::string& inputLeft) {
-  std::string op =
-      (left->name() == inputLeft) ? operation : invert(prefix, operation);
-
-  if (op == prefix + "lt") {
-    return result < 0;
-  }
-
-  return result > 0;
-}
-
-} // namespace
-
-std::optional<SimpleComparison> isSimpleComparison(
-    const std::string& prefix,
-    const core::LambdaTypedExpr& expr) {
-  // First, check the shape of the expression.
-  // if (x(a) < y(b), c1, if (u(c) > v(d), c2, c3))
-  core::FieldAccessTypedExprPtr a, b, c, d;
-  core::TypedExprPtr x, y, u, v;
-  std::string op1, op2;
-  int64_t c1, c2, c3;
-
-  auto matcher = ifelse(
-      comparison(prefix, anySingleInput(&x, &a), anySingleInput(&y, &b), &op1),
-      comparisonConstant(&c1),
-      ifelse(
-          comparison(
-              prefix, anySingleInput(&u, &c), anySingleInput(&v, &d), &op2),
-          comparisonConstant(&c2),
-          comparisonConstant(&c3)));
-
-  if (!matcher->match(expr.body())) {
-    return std::nullopt;
-  }
-
-  // Verify that a != b, c != d.
-  if (a == b || c == d) {
-    return std::nullopt;
-  }
-
-  // Verify that x, y, u, v are the same (except for input column).
-  std::unordered_map<std::string, core::TypedExprPtr> inputMapping;
-  inputMapping.emplace(
-      a->name(),
-      std::make_shared<core::FieldAccessTypedExpr>(a->type(), b->name()));
-  const auto xRewritten = x->rewriteInputNames(inputMapping);
-  if (!(*xRewritten == *y->rewriteInputNames(inputMapping) &&
-        *xRewritten == *u->rewriteInputNames(inputMapping) &&
-        *xRewritten == *v->rewriteInputNames(inputMapping))) {
-    return std::nullopt;
-  }
-
-  // Verify all constants are different.
-  if (c1 == c2 || c2 == c3 || c1 == c3) {
-    return std::nullopt;
-  }
-
-  const auto eq = prefix + "eq";
-
-  // Verify that equality comparisons return zero.
-  // if (x(a) = y(a), 0,..) is good. if (x(a) = y(a), 1,..) is not good.
-  // Also, verify that non-equality comparisons return non-zerp.
-  // if (x(a) < y(a), 1,..) is good. if (x(a) < y(a), 0,..) is not good.
-  if ((op1 == eq && c1 != 0) || (op1 != eq && c1 == 0)) {
-    return std::nullopt;
-  }
-
-  if ((op2 == eq && c2 != 0) || (op2 != eq && c2 == 0)) {
-    return std::nullopt;
-  }
-
-  const auto left = expr.signature()->nameOf(0);
-
-  const auto transform = a->name() == left ? x : y;
-
-  if (op1 == eq) {
-    // if (x(a) = y(b), 0,...)
-    return {{transform, isLessThen(prefix, op2, c, c2, left)}};
-  }
-
-  if (op2 == eq) {
-    return {{transform, isLessThen(prefix, op1, a, c1, left)}};
-  }
-
-  // Make sure op1 and op2 are aligned.
-  auto b1 = isLessThen(prefix, op1, a, c1, left);
-  auto b2 = isLessThen(prefix, op2, c, c2, left);
-  if (b1 != b2) {
-    return std::nullopt;
-  }
-
-  return {{transform, b1}};
-}
-
-} // namespace facebook::velox::functions::prestosql
diff --git a/velox/functions/prestosql/SimpleComparisonMatcher.h b/velox/functions/prestosql/SimpleComparisonMatcher.h
deleted file mode 100644
index 05f89134521..00000000000
--- a/velox/functions/prestosql/SimpleComparisonMatcher.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include "velox/core/Expressions.h"
-
-namespace facebook::velox::functions::prestosql {
-
-struct SimpleComparison {
-  core::TypedExprPtr expr;
-  bool isLessThen;
-};
-
-/// Given a lambda expression, checks it if represents a simple comparator and
-/// returns the summary of the same.
-///
-/// For example, identifies
-///     (x, y) -> if(length(x) < length(y), -1, if(length(x) > length(y), 1, 0))
-/// expression as a "less than" comparison over length(x).
-///
-/// Recognizes different variations of this expression, e.g.
-///
-///     (x, y) -> if(expr(x) = expr(y), 0, if(expr(x) < expr(y), -1, 1))
-///     (x, y) -> if(expr(x) = expr(y), 0, if(expr(y) > expr(x), -1, 1))
-///
-/// Returns std::nullopt if expression is not recognized as a simple comparator.
-///
-/// Can be used to re-write generic lambda expressions passed to array_sort into
-/// simpler ones that can be evaluated more efficiently.
-std::optional<SimpleComparison> isSimpleComparison(
-    const std::string& prefix,
-    const core::LambdaTypedExpr& expr);
-
-} // namespace facebook::velox::functions::prestosql
diff --git a/velox/functions/prestosql/Split.cpp b/velox/functions/prestosql/Split.cpp
index 55397bdf271..116ff66aedb 100644
--- a/velox/functions/prestosql/Split.cpp
+++ b/velox/functions/prestosql/Split.cpp
@@ -42,20 +42,22 @@ class SplitFunction : public exec::VectorFunction {
     std::vector<std::shared_ptr<exec::FunctionSignature>> signatures;
 
     // varchar, varchar -> array(varchar)
-    signatures.emplace_back(exec::FunctionSignatureBuilder()
-                                .returnType("array(varchar)")
-                                .argumentType("varchar")
-                                .argumentType("varchar")
-                                .build());
+    signatures.emplace_back(
+        exec::FunctionSignatureBuilder()
+            .returnType("array(varchar)")
+            .argumentType("varchar")
+            .argumentType("varchar")
+            .build());
 
     // varchar, varchar, integer|bigint -> array(varchar)
     for (const auto& limitType : {"integer", "bigint"}) {
-      signatures.emplace_back(exec::FunctionSignatureBuilder()
-                                  .returnType("array(varchar)")
-                                  .argumentType("varchar")
-                                  .argumentType("varchar")
-                                  .argumentType(limitType)
-                                  .build());
+      signatures.emplace_back(
+          exec::FunctionSignatureBuilder()
+              .returnType("array(varchar)")
+              .argumentType("varchar")
+              .argumentType("varchar")
+              .argumentType(limitType)
+              .build());
     }
     return signatures;
   }
@@ -85,7 +87,7 @@ class SplitFunction : public exec::VectorFunction {
       default:
         VELOX_FAIL(
             "Unsupported type for 'limit' argument of 'split' function: {}",
-            mapTypeKindToName(limitType));
+            TypeKindName::toName(limitType));
     }
   }
 
diff --git a/velox/functions/prestosql/SplitToMap.cpp b/velox/functions/prestosql/SplitToMap.cpp
index 16e7d13a3f3..ae4fba2fbaf 100644
--- a/velox/functions/prestosql/SplitToMap.cpp
+++ b/velox/functions/prestosql/SplitToMap.cpp
@@ -63,7 +63,7 @@ core::TypedExprPtr rewriteSplitToMapCall(
   }
 
   if (!keepFirst.has_value()) {
-    static const std::string kNotSupported =
+    static constexpr const char* kNotSupported =
         "split_to_map with arbitrary lambda is not supported: {}";
     VELOX_USER_FAIL(kNotSupported, lambda->toString());
   }
diff --git a/velox/functions/prestosql/StringFunctions.h b/velox/functions/prestosql/StringFunctions.h
index b076b9a7d17..246de3cc325 100644
--- a/velox/functions/prestosql/StringFunctions.h
+++ b/velox/functions/prestosql/StringFunctions.h
@@ -15,8 +15,7 @@
  */
 #pragma once
 
-#define XXH_INLINE_ALL
-#include <xxhash.h>
+#include "velox/common/base/XxHashInline.h"
 
 #include "velox/functions/Udf.h"
 #include "velox/functions/lib/string/StringCore.h"
@@ -33,7 +32,7 @@ struct ChrFunction {
   FOLLY_ALWAYS_INLINE void call(
       out_type<Varchar>& result,
       const int64_t& codePoint) {
-    stringImpl::codePointToString(result, codePoint);
+    result = stringImpl::codePointToString(codePoint);
   }
 };
 
@@ -602,13 +601,14 @@ template <typename T>
 struct NormalizeFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
-  // Map for holding normalization form options
-  const static inline std::unordered_map<std::string, utf8proc_int16_t>
+  // Map for holding normalization form options.
+  const static inline std::unordered_map<std::string_view, utf8proc_int16_t>
       normalizationOptions{
           {"NFC", (UTF8PROC_STABLE | UTF8PROC_COMPOSE)},
           {"NFD", (UTF8PROC_STABLE | UTF8PROC_DECOMPOSE)},
           {"NFKC", (UTF8PROC_STABLE | UTF8PROC_COMPOSE | UTF8PROC_COMPAT)},
-          {"NFKD", (UTF8PROC_STABLE | UTF8PROC_DECOMPOSE | UTF8PROC_COMPAT)}};
+          {"NFKD", (UTF8PROC_STABLE | UTF8PROC_DECOMPOSE | UTF8PROC_COMPAT)},
+      };
 
   FOLLY_ALWAYS_INLINE void initialize(
       const std::vector<TypePtr>& /*inputTypes*/,
@@ -616,8 +616,10 @@ struct NormalizeFunction {
       const arg_type<Varchar>* /*string*/,
       const arg_type<Varchar>* form) {
     VELOX_USER_CHECK_NOT_NULL(form);
+
+    // TODO: Remove explicit std::string_view cast.
     VELOX_USER_CHECK_NE(
-        normalizationOptions.count(*form),
+        normalizationOptions.count(std::string_view(*form)),
         0,
         "Normalization form must be one of [NFD, NFC, NFKD, NFKC]");
   }
@@ -646,7 +648,8 @@ struct NormalizeFunction {
         (utf8proc_uint8_t*)string.data(),
         string.size(),
         &output,
-        normalizationOptions.at(form));
+        // TODO: Remove explicit std::string_view cast.
+        normalizationOptions.at(std::string_view(form)));
     if (outputLength < 0) {
       result = string;
     } else {
@@ -660,6 +663,19 @@ struct NormalizeFunction {
   }
 };
 
+/// bit_length(string) → bigint
+/// Returns the length in bits of the input string.
+template <typename T>
+struct BitLengthFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      int64_t& result,
+      const arg_type<Varchar>& input) {
+    result = static_cast<int64_t>(input.size()) * 8;
+  }
+};
+
 /// xxhash64(varchar) → bigint
 /// Return a hash64 of input (Varchar such as string)
 template <typename T>
@@ -672,4 +688,258 @@ struct XxHash64StringFunction {
   }
 };
 
+/// longest_common_prefix(string1, string2) → varchar
+/// Returns the longest common prefix between two strings.
+template <typename T>
+struct LongestCommonPrefixFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  // Results refer to strings in the first argument.
+  static constexpr int32_t reuse_strings_from_arg = 0;
+
+  // ASCII input always produces ASCII result.
+  static constexpr bool is_default_ascii_behavior = true;
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& left,
+      const arg_type<Varchar>& right) {
+    doCall<false>(result, left, right);
+  }
+
+  FOLLY_ALWAYS_INLINE void callAscii(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& left,
+      const arg_type<Varchar>& right) {
+    doCall<true>(result, left, right);
+  }
+
+ private:
+  template <bool isAscii>
+  FOLLY_ALWAYS_INLINE void doCall(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& left,
+      const arg_type<Varchar>& right) {
+    // Validate both strings are valid UTF-8.
+    stringImpl::stringToCodePoints(left);
+    stringImpl::stringToCodePoints(right);
+
+    if constexpr (isAscii) {
+      // Fast path for ASCII: simple byte comparison.
+      const char* leftData = left.data();
+      const char* rightData = right.data();
+      const size_t minLength = std::min(left.size(), right.size());
+
+      size_t commonLength = 0;
+      while (commonLength < minLength &&
+             leftData[commonLength] == rightData[commonLength]) {
+        commonLength++;
+      }
+
+      if (commonLength == 0) {
+        result.setEmpty();
+      } else {
+        result.setNoCopy(StringView(leftData, commonLength));
+      }
+    } else {
+      // Unicode path: lazy codepoint iteration.
+      const char* leftData = left.data();
+      const char* rightData = right.data();
+      const size_t leftLength = left.size();
+      const size_t rightLength = right.size();
+      size_t leftPos = 0;
+      size_t rightPos = 0;
+
+      while (leftPos < leftLength && rightPos < rightLength) {
+        int leftSize = 0;
+        int rightSize = 0;
+        auto codePointLeft = utf8proc_codepoint(
+            leftData + leftPos, leftData + leftLength, leftSize);
+        auto codePointRight = utf8proc_codepoint(
+            rightData + rightPos, rightData + rightLength, rightSize);
+
+        if (codePointLeft != codePointRight) {
+          break;
+        }
+
+        leftPos += leftSize;
+        rightPos += rightSize;
+      }
+
+      if (leftPos == 0) {
+        result.setEmpty();
+      } else {
+        result.setNoCopy(StringView(leftData, leftPos));
+      }
+    }
+  }
+};
+
+/// jarowinkler_similarity(string1, string2) → double
+/// Computes the Jaro-Winkler similarity between two strings.
+template <typename T>
+struct JaroWinklerSimilarityFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+  void call(
+      out_type<double>& result,
+      const arg_type<Varchar>& left,
+      const arg_type<Varchar>& right) {
+    auto leftCodePoints = stringImpl::stringToCodePoints(left);
+    auto rightCodePoints = stringImpl::stringToCodePoints(right);
+
+    // Validate size before checking equality to ensure we throw for
+    // oversized inputs even when they're identical.
+    static const int64_t kMaxCombinedInputSize = 1'000'000;
+    auto combinedInputSize = static_cast<int64_t>(leftCodePoints.size()) *
+        (static_cast<int64_t>(rightCodePoints.size()) - 1);
+    VELOX_USER_CHECK_LE(
+        combinedInputSize,
+        kMaxCombinedInputSize,
+        "The combined inputs for Jaro-Winkler similarity are too large");
+
+    // If the strings are identical (same content), return 1.0.
+    // This is deterministic and handles all cases including empty strings.
+    if (left == right) {
+      result = 1.0;
+      return;
+    }
+
+    doCall<int32_t>(
+        result,
+        leftCodePoints.data(),
+        rightCodePoints.data(),
+        leftCodePoints.size(),
+        rightCodePoints.size());
+  }
+  void callAscii(
+      out_type<double>& result,
+      const arg_type<Varchar>& left,
+      const arg_type<Varchar>& right) {
+    // Validate size before checking equality to ensure we throw for
+    // oversized inputs even when they're identical.
+    static const int64_t kMaxCombinedInputSize = 1'000'000;
+    auto combinedInputSize = static_cast<int64_t>(left.size()) *
+        (static_cast<int64_t>(right.size()) - 1);
+    VELOX_USER_CHECK_LE(
+        combinedInputSize,
+        kMaxCombinedInputSize,
+        "The combined inputs for Jaro-Winkler similarity are too large");
+
+    // If the strings are identical (same content), return 1.0.
+    // This is deterministic and handles all cases including empty strings.
+    if (left == right) {
+      result = 1.0;
+      return;
+    }
+
+    auto leftCodePoints = reinterpret_cast<const uint8_t*>(left.data());
+    auto rightCodePoints = reinterpret_cast<const uint8_t*>(right.data());
+    doCall<uint8_t>(
+        result, leftCodePoints, rightCodePoints, left.size(), right.size());
+  }
+
+  template <typename TCodePoint>
+  void doCall(
+      out_type<double>& result,
+      const TCodePoint* leftCodePoints,
+      const TCodePoint* rightCodePoints,
+      size_t leftLength,
+      size_t rightLength) {
+    static const int64_t kMaxCombinedInputSize = 1'000'000;
+    // Cast to int64_t to avoid unsigned underflow
+    auto combinedInputSize = static_cast<int64_t>(leftLength) *
+        (static_cast<int64_t>(rightLength) - 1);
+    VELOX_USER_CHECK_LE(
+        combinedInputSize,
+        kMaxCombinedInputSize,
+        "The combined inputs for Jaro-Winkler similarity are too large");
+
+    int maxDist = std::max(leftLength, rightLength) / 2 - 1;
+    if (maxDist < 0) {
+      maxDist = 0;
+    }
+
+    int match = 0;
+    std::vector<int> leftHash(leftLength, 0);
+    std::vector<int> rightHash(rightLength, 0);
+
+    for (int i = 0; i < leftLength; i++) {
+      for (int j = std::max(0, i - maxDist);
+           j < std::min(static_cast<int>(rightLength), i + maxDist + 1);
+           j++) {
+        if (leftCodePoints[i] == rightCodePoints[j] && rightHash[j] == 0) {
+          leftHash[i] = 1;
+          rightHash[j] = 1;
+          match++;
+          break;
+        }
+      }
+    }
+
+    if (match == 0) {
+      result = 0.0;
+      return;
+    }
+
+    double t = 0;
+    int point = 0;
+
+    for (int i = 0; i < leftLength; i++) {
+      if (leftHash[i] == 1) {
+        while (rightHash[point] == 0) {
+          point++;
+        }
+
+        if (leftCodePoints[i] != rightCodePoints[point++]) {
+          t++;
+        }
+      }
+    }
+
+    t /= 2;
+
+    double jaroDist = ((static_cast<double>(match) / leftLength) +
+                       (static_cast<double>(match) / rightLength) +
+                       (static_cast<double>(match) - t) / match) /
+        3.0;
+
+    if (jaroDist > 0.7) {
+      int prefix = 0;
+
+      for (int i = 0; i < std::min(leftLength, rightLength); i++) {
+        if (leftCodePoints[i] == rightCodePoints[i]) {
+          prefix++;
+        } else {
+          break;
+        }
+      }
+
+      prefix = std::min(4, prefix);
+
+      jaroDist += 0.1 * prefix * (1 - jaroDist);
+    }
+
+    result = std::round(jaroDist * 100.0) / 100.0;
+  }
+};
+
+/// key_sampling_percent(varchar) -> double
+/// Returns a value between 0.0 and 1.0 using the hash of the given input
+/// string.
+template <typename T>
+struct KeySamplingPercentFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<double>& result,
+      const arg_type<Varchar>& string) {
+    static constexpr auto kTypeLength = sizeof(int64_t);
+    int64_t hash = XXH64(string.data(), string.size(), 0);
+    // Bitwise reinterpretation to match Java's
+    // Double.longBitsToDouble(xxhash64(...)) semantics.
+    // This may produce NaN, which is expected and allowed.
+    memcpy(&result, &hash, kTypeLength);
+    result = fmod(fabs(result), 100) / 100;
+  }
+};
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/TDigestFunctions.h b/velox/functions/prestosql/TDigestFunctions.h
index 5cce5ab5024..22908806901 100644
--- a/velox/functions/prestosql/TDigestFunctions.h
+++ b/velox/functions/prestosql/TDigestFunctions.h
@@ -206,14 +206,15 @@ struct DestructureTDigestFunction {
       count += tDigestWeights[i];
     }
     // Create the result row
-    result.copy_from(std::make_tuple(
-        std::move(means),
-        std::move(weights),
-        compression,
-        min,
-        max,
-        sum,
-        count));
+    result.copy_from(
+        std::make_tuple(
+            std::move(means),
+            std::move(weights),
+            compression,
+            min,
+            max,
+            sum,
+            count));
 
     return true;
   }
@@ -233,8 +234,9 @@ struct TrimmedMeanFunction {
     VELOX_USER_CHECK(
         0 <= upperQuantileBound && upperQuantileBound <= 1,
         "Upper quantile bound must be between 0 and 1");
-    VELOX_USER_CHECK(
-        lowerQuantileBound <= upperQuantileBound,
+    VELOX_USER_CHECK_LE(
+        lowerQuantileBound,
+        upperQuantileBound,
         "Lower quantile bound must be less than or equal to upper quantile bound");
     // Deserialize the TDigest
     auto digest = TDigest<>::fromSerialized(input.data());
@@ -248,4 +250,38 @@ struct TrimmedMeanFunction {
     return true;
   }
 };
+/// Computes the Winsorized mean from a serialized TDigest. Values below the
+/// lower quantile are replaced with the boundary value at that quantile, and
+/// values above the upper quantile are replaced with the boundary value at
+/// that quantile. The mean is then computed on all values including the
+/// replaced tails.
+template <typename T>
+struct WinsorizedMeanFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<double>& result,
+      const arg_type<SimpleTDigest<double>>& input,
+      const arg_type<double>& lowerQuantileBound,
+      const arg_type<double>& upperQuantileBound) {
+    VELOX_USER_CHECK(
+        0 <= lowerQuantileBound && lowerQuantileBound <= 1,
+        "Lower quantile bound must be between 0 and 1");
+    VELOX_USER_CHECK(
+        0 <= upperQuantileBound && upperQuantileBound <= 1,
+        "Upper quantile bound must be between 0 and 1");
+    VELOX_USER_CHECK_LE(
+        lowerQuantileBound,
+        upperQuantileBound,
+        "Lower quantile bound must be less than or equal to upper quantile bound");
+    auto digest = TDigest<>::fromSerialized(input.data());
+    if (digest.size() == 0) {
+      return false;
+    }
+    result = digest.winsorizedMean(lowerQuantileBound, upperQuantileBound);
+    if (std::isnan(result)) {
+      return false;
+    }
+    return true;
+  }
+};
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/Transform.cpp b/velox/functions/prestosql/Transform.cpp
index 3028a2c256d..cfa93674915 100644
--- a/velox/functions/prestosql/Transform.cpp
+++ b/velox/functions/prestosql/Transform.cpp
@@ -13,99 +13,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "velox/expression/Expr.h"
-#include "velox/expression/VectorFunction.h"
-#include "velox/functions/lib/LambdaFunctionUtil.h"
-#include "velox/functions/lib/RowsTranslationUtil.h"
-#include "velox/vector/FunctionVector.h"
+#include "velox/functions/lib/TransformFunctionBase.h"
 
 namespace facebook::velox::functions {
-namespace {
-
-// See documentation at https://prestodb.io/docs/current/functions/array.html
-class TransformFunction : public exec::VectorFunction {
- public:
-  void apply(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& outputType,
-      exec::EvalCtx& context,
-      VectorPtr& result) const override {
-    VELOX_CHECK_EQ(args.size(), 2);
-
-    // Flatten input array.
-    exec::LocalDecodedVector arrayDecoder(context, *args[0], rows);
-    auto& decodedArray = *arrayDecoder.get();
-
-    auto flatArray = flattenArray(rows, args[0], decodedArray);
-
-    std::vector<VectorPtr> lambdaArgs = {flatArray->elements()};
-    auto newNumElements = flatArray->elements()->size();
-
-    SelectivityVector validRowsInReusedResult =
-        toElementRows<ArrayVector>(newNumElements, rows, flatArray.get());
-
-    // transformed elements
-    VectorPtr newElements;
-
-    auto elementToTopLevelRows = getElementToTopLevelRows(
-        newNumElements, rows, flatArray.get(), context.pool());
-
-    // loop over lambda functions and apply these to elements of the base array;
-    // in most cases there will be only one function and the loop will run once
-    auto it = args[1]->asUnchecked<FunctionVector>()->iterator(&rows);
-    while (auto entry = it.next()) {
-      auto elementRows = toElementRows<ArrayVector>(
-          newNumElements, *entry.rows, flatArray.get());
-      auto wrapCapture = toWrapCapture<ArrayVector>(
-          newNumElements, entry.callable, *entry.rows, flatArray);
-
-      entry.callable->apply(
-          elementRows,
-          &validRowsInReusedResult,
-          wrapCapture,
-          &context,
-          lambdaArgs,
-          elementToTopLevelRows,
-          &newElements);
-    }
-
-    // Set nulls for rows not present in 'rows'.
-    BufferPtr newNulls = addNullsForUnselectedRows(flatArray, rows);
-
-    VectorPtr localResult = std::make_shared<ArrayVector>(
-        flatArray->pool(),
-        outputType,
-        std::move(newNulls),
-        rows.end(),
-        flatArray->offsets(),
-        flatArray->sizes(),
-        newElements);
-    context.moveOrCopyResult(localResult, rows, result);
-  }
-
-  static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
-    // array(T), function(T, U) -> array(U)
-    return {exec::FunctionSignatureBuilder()
-                .typeVariable("T")
-                .typeVariable("U")
-                .returnType("array(U)")
-                .argumentType("array(T)")
-                .argumentType("function(T, U)")
-                .build()};
-  }
-};
-} // namespace
 
 /// transform is null preserving for the array. But since an
 /// expr tree with a lambda depends on all named fields, including
 /// captures, a null in a capture does not automatically make a
 /// null result.
 
+// See documentation at https://prestodb.io/docs/current/functions/array.html
 VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_transform,
-    TransformFunction::signatures(),
+    TransformFunctionBase::signatures(),
     exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
-    std::make_unique<TransformFunction>());
+    std::make_unique<TransformFunctionBase>());
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/TransformValues.cpp b/velox/functions/prestosql/TransformValues.cpp
index d46e48c0018..44f36534c1d 100644
--- a/velox/functions/prestosql/TransformValues.cpp
+++ b/velox/functions/prestosql/TransformValues.cpp
@@ -16,8 +16,6 @@
 #include "velox/expression/Expr.h"
 #include "velox/expression/VectorFunction.h"
 #include "velox/functions/lib/LambdaFunctionUtil.h"
-#include "velox/functions/lib/RowsTranslationUtil.h"
-#include "velox/vector/FunctionVector.h"
 
 namespace facebook::velox::functions {
 namespace {
@@ -39,36 +37,23 @@ class TransformValuesFunction : public exec::VectorFunction {
 
     auto flatMap = flattenMap(rows, args[0], decodedMap);
 
-    std::vector<VectorPtr> lambdaArgs = {
+    auto numElements = flatMap->mapKeys()->size();
+    const std::vector<VectorPtr> lambdaArgs = {
         flatMap->mapKeys(), flatMap->mapValues()};
-    auto numValues = flatMap->mapValues()->size();
-
     SelectivityVector validRowsInReusedResult =
-        toElementRows<MapVector>(numValues, rows, flatMap.get());
+        toElementRows<MapVector>(numElements, rows, flatMap.get());
 
     VectorPtr transformedValues;
-
-    auto elementToTopLevelRows = getElementToTopLevelRows(
-        numValues, rows, flatMap.get(), context.pool());
-
-    // Loop over lambda functions and apply these to values of the map.
-    // In most cases there will be only one function and the loop will run once.
-    auto it = args[1]->asUnchecked<FunctionVector>()->iterator(&rows);
-    while (auto entry = it.next()) {
-      auto valueRows =
-          toElementRows<MapVector>(numValues, *entry.rows, flatMap.get());
-      auto wrapCapture = toWrapCapture<MapVector>(
-          numValues, entry.callable, *entry.rows, flatMap);
-
-      entry.callable->apply(
-          valueRows,
-          &validRowsInReusedResult,
-          wrapCapture,
-          &context,
-          lambdaArgs,
-          elementToTopLevelRows,
-          &transformedValues);
-    }
+    // Apply lambda to map values.
+    applyLambdaToElements<MapVector>(
+        args[1],
+        rows,
+        numElements,
+        flatMap,
+        lambdaArgs,
+        validRowsInReusedResult,
+        context,
+        transformedValues);
 
     // Set nulls for rows not present in 'rows'.
     BufferPtr newNulls = addNullsForUnselectedRows(flatMap, rows);
diff --git a/velox/functions/prestosql/TransformWithIndex.cpp b/velox/functions/prestosql/TransformWithIndex.cpp
new file mode 100644
index 00000000000..a2a3a62bf42
--- /dev/null
+++ b/velox/functions/prestosql/TransformWithIndex.cpp
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/expression/Expr.h"
+#include "velox/expression/VectorFunction.h"
+#include "velox/functions/lib/LambdaFunctionUtil.h"
+#include "velox/functions/lib/RowsTranslationUtil.h"
+#include "velox/vector/FunctionVector.h"
+
+namespace facebook::velox::functions {
+namespace {
+
+// transform_with_index(array(T), function(T, bigint, U)) -> array(U)
+//
+// Transforms each element of an array using the provided function.
+// The lambda function receives both the element and its 1-based index.
+class TransformWithIndexFunction : public exec::VectorFunction {
+ public:
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& outputType,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    VELOX_CHECK_EQ(args.size(), 2);
+
+    // Flatten input array.
+    exec::LocalDecodedVector arrayDecoder(context, *args[0], rows);
+    auto& decodedArray = *arrayDecoder.get();
+
+    auto flatArray = flattenArray(rows, args[0], decodedArray);
+
+    auto newNumElements = flatArray->elements()->size();
+
+    // Create indices vector (1-based indexing for Presto compatibility)
+    auto indices = createIndicesVector(flatArray, rows, context.pool());
+
+    std::vector<VectorPtr> lambdaArgs = {flatArray->elements(), indices};
+
+    SelectivityVector validRowsInReusedResult =
+        toElementRows<ArrayVector>(newNumElements, rows, flatArray.get());
+
+    VectorPtr newElements;
+
+    auto elementToTopLevelRows = getElementToTopLevelRows(
+        newNumElements, rows, flatArray.get(), context.pool());
+
+    // Loop over lambda functions and apply these to elements of the base array;
+    // in most cases there will be only one function and the loop will run once
+    auto it = args[1]->asUnchecked<FunctionVector>()->iterator(&rows);
+    while (auto entry = it.next()) {
+      auto elementRows = toElementRows<ArrayVector>(
+          newNumElements, *entry.rows, flatArray.get());
+      auto wrapCapture = toWrapCapture<ArrayVector>(
+          newNumElements, entry.callable, *entry.rows, flatArray);
+
+      entry.callable->apply(
+          elementRows,
+          &validRowsInReusedResult,
+          wrapCapture,
+          &context,
+          lambdaArgs,
+          elementToTopLevelRows,
+          &newElements);
+    }
+
+    // Set nulls for rows not present in 'rows'.
+    BufferPtr newNulls = addNullsForUnselectedRows(flatArray, rows);
+
+    VectorPtr localResult = std::make_shared<ArrayVector>(
+        flatArray->pool(),
+        outputType,
+        std::move(newNulls),
+        rows.end(),
+        flatArray->offsets(),
+        flatArray->sizes(),
+        newElements);
+    context.moveOrCopyResult(localResult, rows, result);
+  }
+
+  static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
+    // array(T), function(T, bigint, U) -> array(U)
+    return {exec::FunctionSignatureBuilder()
+                .typeVariable("T")
+                .typeVariable("U")
+                .returnType("array(U)")
+                .argumentType("array(T)")
+                .argumentType("function(T, bigint, U)")
+                .build()};
+  }
+
+ private:
+  // Creates a vector of 1-based indices for each element in the flattened
+  // array. For example, if we have arrays [[a, b, c], [d, e]], the indices
+  // will be [1, 2, 3, 1, 2] (1-based for each array).
+  static VectorPtr createIndicesVector(
+      const std::shared_ptr<ArrayVector>& flatArray,
+      const SelectivityVector& rows,
+      memory::MemoryPool* pool) {
+    const auto numElements = flatArray->elements()->size();
+    auto indicesVector =
+        BaseVector::create<FlatVector<int64_t>>(BIGINT(), numElements, pool);
+    auto* rawIndices = indicesVector->mutableRawValues();
+
+    const auto* rawOffsets = flatArray->rawOffsets();
+    const auto* rawSizes = flatArray->rawSizes();
+    const auto* rawNulls = flatArray->rawNulls();
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (rawNulls && bits::isBitNull(rawNulls, row)) {
+        return;
+      }
+      const auto offset = rawOffsets[row];
+      const auto size = rawSizes[row];
+      for (vector_size_t i = 0; i < size; ++i) {
+        // Use 1-based indexing for Presto compatibility
+        rawIndices[offset + i] = i + 1;
+      }
+    });
+
+    return indicesVector;
+  }
+};
+} // namespace
+
+/// transform_with_index is null preserving for the array. But since an
+/// expr tree with a lambda depends on all named fields, including
+/// captures, a null in a capture does not automatically make a
+/// null result.
+
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
+    udf_transform_with_index,
+    TransformWithIndexFunction::signatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
+    std::make_unique<TransformWithIndexFunction>());
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/TypeOf.cpp b/velox/functions/prestosql/TypeOf.cpp
index 13d875b12a2..16d68a49c16 100644
--- a/velox/functions/prestosql/TypeOf.cpp
+++ b/velox/functions/prestosql/TypeOf.cpp
@@ -15,140 +15,113 @@
  */
 #include "velox/expression/VectorFunction.h"
 #include "velox/functions/prestosql/types/BigintEnumType.h"
-#include "velox/functions/prestosql/types/BingTileType.h"
-#include "velox/functions/prestosql/types/GeometryType.h"
 #include "velox/functions/prestosql/types/HyperLogLogType.h"
-#include "velox/functions/prestosql/types/IPAddressType.h"
 #include "velox/functions/prestosql/types/IPPrefixType.h"
-#include "velox/functions/prestosql/types/JsonType.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
 #include "velox/functions/prestosql/types/P4HyperLogLogType.h"
 #include "velox/functions/prestosql/types/QDigestType.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
 #include "velox/functions/prestosql/types/TDigestType.h"
-#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
-#include "velox/functions/prestosql/types/UuidType.h"
 #include "velox/functions/prestosql/types/VarcharEnumType.h"
 
 namespace facebook::velox::functions {
 namespace {
 
+// Converts a TypePtr to its string representation. Handles most types by
+// default, but provides special handling for types with mixed casing, custom
+// names, or complex formatting.
 std::string typeName(const TypePtr& type) {
-  switch (type->kind()) {
-    case TypeKind::BOOLEAN:
-      return "boolean";
-    case TypeKind::TINYINT:
-      return "tinyint";
-    case TypeKind::SMALLINT:
-      return "smallint";
-    case TypeKind::INTEGER:
-      if (type->isDate()) {
-        return "date";
-      }
-      if (type->isIntervalYearMonth()) {
-        return "interval year to month";
-      }
-      return "integer";
-    case TypeKind::BIGINT:
-      if (isTimestampWithTimeZoneType(type)) {
-        return "timestamp with time zone";
-      }
-      if (type->isIntervalDayTime()) {
-        return "interval day to second";
-      }
-      if (type->isDecimal()) {
-        const auto& shortDecimal = type->asShortDecimal();
-        return fmt::format(
-            "decimal({},{})", shortDecimal.precision(), shortDecimal.scale());
-      }
-      if (isBingTileType(type)) {
-        return "bingtile";
-      }
-      if (isBigintEnumType(*type)) {
-        return asBigintEnum(type)->enumName();
-      }
-      return "bigint";
+  // Handle decimal types with precision and scale
+  if (type->isDecimal()) {
+    auto precision = type->isShortDecimal() ? type->asShortDecimal().precision()
+                                            : type->asLongDecimal().precision();
+    auto scale = type->isShortDecimal() ? type->asShortDecimal().scale()
+                                        : type->asLongDecimal().scale();
+    return fmt::format("decimal({},{})", precision, scale);
+  }
 
-    case TypeKind::HUGEINT: {
-      if (isUuidType(type)) {
-        return "uuid";
-      } else if (isIPAddressType(type)) {
-        return "ipaddress";
-      }
-      VELOX_USER_CHECK(
-          type->isDecimal(),
-          "Expected decimal type. Got: {}",
-          type->toString());
-      const auto& longDecimal = type->asLongDecimal();
-      return fmt::format(
-          "decimal({},{})", longDecimal.precision(), longDecimal.scale());
+  // Handle complex types with recursive formatting
+  if (type->kind() == TypeKind::ARRAY) {
+    return fmt::format("array({})", typeName(type->childAt(0)));
+  }
+
+  if (type->kind() == TypeKind::MAP) {
+    return fmt::format(
+        "map({}, {})", typeName(type->childAt(0)), typeName(type->childAt(1)));
+  }
+
+  if (type->kind() == TypeKind::ROW) {
+    if (isIPPrefixType(type)) {
+      return "ipprefix";
     }
-    case TypeKind::REAL:
-      return "real";
-    case TypeKind::DOUBLE:
-      return "double";
-    case TypeKind::VARCHAR:
-      if (isJsonType(type)) {
-        return "json";
-      }
-      if (isVarcharEnumType(*type)) {
-        return asVarcharEnum(type)->enumName();
-      }
-      return "varchar";
-    case TypeKind::VARBINARY:
-      if (isHyperLogLogType(type)) {
-        return "HyperLogLog";
-      }
-      if (isP4HyperLogLogType(type)) {
-        return "P4HyperLogLog";
-      }
-      if (isGeometryType(type)) {
-        return "geometry";
-      }
-      if (*type == *TDIGEST(DOUBLE())) {
-        return "tdigest(double)";
-      }
-      if (*type == *QDIGEST(BIGINT())) {
-        return "qdigest(bigint)";
-      }
-      if (*type == *QDIGEST(REAL())) {
-        return "qdigest(real)";
-      }
-      if (*type == *QDIGEST(DOUBLE())) {
-        return "qdigest(double)";
+    const auto& rowType = type->asRow();
+    std::ostringstream out;
+    out << "row(";
+    for (auto i = 0; i < type->size(); ++i) {
+      if (i > 0) {
+        out << ", ";
       }
-      return "varbinary";
-    case TypeKind::TIMESTAMP:
-      return "timestamp";
-    case TypeKind::ARRAY:
-      return fmt::format("array({})", typeName(type->childAt(0)));
-    case TypeKind::MAP:
-      return fmt::format(
-          "map({}, {})",
-          typeName(type->childAt(0)),
-          typeName(type->childAt(1)));
-    case TypeKind::ROW: {
-      if (isIPPrefixType(type)) {
-        return "ipprefix";
+      if (!rowType.nameOf(i).empty()) {
+        out << "\"" << rowType.nameOf(i) << "\" ";
       }
-      const auto& rowType = type->asRow();
-      std::ostringstream out;
-      out << "row(";
-      for (auto i = 0; i < type->size(); ++i) {
-        if (i > 0) {
-          out << ", ";
-        }
-        if (!rowType.nameOf(i).empty()) {
-          out << "\"" << rowType.nameOf(i) << "\" ";
-        }
-        out << typeName(type->childAt(i));
-      }
-      out << ")";
-      return out.str();
+      out << typeName(type->childAt(i));
     }
-    case TypeKind::UNKNOWN:
-      return "unknown";
-    default:
-      VELOX_UNSUPPORTED("Unsupported type: {}", type->toString());
+    out << ")";
+    return out.str();
+  }
+
+  // Handle enum types that have custom names
+  if (isBigintEnumType(*type)) {
+    return asBigintEnum(type)->enumName();
+  }
+  if (isVarcharEnumType(*type)) {
+    return asVarcharEnum(type)->enumName();
+  }
+
+  // Handle HyperLogLog types that use mixed case
+  if (isHyperLogLogType(type)) {
+    return "HyperLogLog";
+  }
+  if (isP4HyperLogLogType(type)) {
+    return "P4HyperLogLog";
+  }
+  if (isKHyperLogLogType(type)) {
+    return "KHyperLogLog";
+  }
+
+  // Handle SetDigest types
+  if (isSetDigestType(type)) {
+    return "SetDigest";
   }
+
+  // Handle special digest types that need parameter formatting
+  if (*type == *TDIGEST(DOUBLE())) {
+    return "tdigest(double)";
+  }
+  if (*type == *QDIGEST(BIGINT())) {
+    return "qdigest(bigint)";
+  }
+  if (*type == *QDIGEST(REAL())) {
+    return "qdigest(real)";
+  }
+  if (*type == *QDIGEST(DOUBLE())) {
+    return "qdigest(double)";
+  }
+
+  if (type->kind() == TypeKind::UNKNOWN) {
+    return "unknown";
+  }
+
+  // Handle unsupported types
+  if (type->kind() == TypeKind::OPAQUE || type->kind() == TypeKind::FUNCTION ||
+      type->kind() == TypeKind::INVALID) {
+    VELOX_UNSUPPORTED("Unsupported type: {}", type->toString());
+  }
+
+  // Default: use type->name() and lowercase it
+  std::string name = type->name();
+  folly::toLowerAscii(name);
+  return name;
 }
 
 class TypeOfFunction : public exec::VectorFunction {
diff --git a/velox/functions/prestosql/URIParser.h b/velox/functions/prestosql/URIParser.h
index 5b3a0724e8c..8e5b9f75ed9 100644
--- a/velox/functions/prestosql/URIParser.h
+++ b/velox/functions/prestosql/URIParser.h
@@ -15,16 +15,11 @@
  */
 #pragma once
 
-#include <boost/regex.hpp>
+#include <re2/re2.h>
+#include <optional>
 #include "velox/type/StringView.h"
 
 namespace facebook::velox::functions {
-namespace detail {
-FOLLY_ALWAYS_INLINE StringView submatch(const boost::cmatch& match, int idx) {
-  const auto& sub = match[idx];
-  return StringView(sub.first, sub.length());
-}
-} // namespace detail
 /// A struct containing the parts of the URI that were extracted during parsing.
 /// If the field was not found, it is empty.
 ///
@@ -51,35 +46,46 @@ bool parseUri(const StringView& uriStr, URI& uri);
 /// false and pos is unchanged.
 bool tryConsumeIPV6Address(const char* str, const size_t len, int32_t& pos);
 
-/// Find an extract the value for the parameter with key `param` from the query
+/// Find and extract the value for the parameter with key `param` from the query
 /// portion of a URI `query`. `query` should already be decoded if necessary.
 template <typename TString>
 std::optional<StringView> extractParameter(
     const StringView& query,
     const TString& param) {
   if (!query.empty()) {
-    // Parse query string.
-    static const boost::regex kQueryParamRegex(
+    // Parse query string using RE2.
+    static const RE2 kQueryParamRegex(
         "(^|&)" // start of query or start of parameter "&"
         "([^=&]*)=?" // parameter name and "=" if value is expected
         "([^&]*)" // parameter value (allows "=" to appear)
-        "(?=(&|$))" // forward reference, next should be end of query or
-                    // start of next parameter
     );
 
-    const boost::cregex_iterator begin(
-        query.data(), query.data() + query.size(), kQueryParamRegex);
-    boost::cregex_iterator end;
+    re2::StringPiece input(query.data(), query.size());
+    re2::StringPiece matches[4]; // Group 0 (full match) + 3 capturing groups
+    size_t pos = 0;
 
-    for (auto it = begin; it != end; ++it) {
-      if (it->length(2) != 0 && (*it)[2].matched) { // key shouldnt be empty.
-        auto key = detail::submatch((*it), 2);
+    while (pos < input.size() &&
+           kQueryParamRegex.Match(
+               input, pos, input.size(), RE2::UNANCHORED, matches, 4)) {
+      // Check if key (group 2) is not empty and matched
+      if (matches[2].size() > 0) {
+        StringView key(matches[2].data(), matches[2].size());
         if (param.compare(key) == 0) {
-          return detail::submatch((*it), 3);
+          // Return the value (group 3)
+          return std::optional<StringView>(
+              StringView(matches[3].data(), matches[3].size()));
         }
       }
+
+      // Move past this match to continue searching
+      pos = matches[0].end() - input.data();
+      if (pos == matches[0].data() - input.data()) {
+        // Avoid infinite loop on zero-width matches
+        ++pos;
+      }
     }
   }
   return std::nullopt;
 }
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/URLFunctions.cpp b/velox/functions/prestosql/URLFunctions.cpp
deleted file mode 100644
index b91e5b904a8..00000000000
--- a/velox/functions/prestosql/URLFunctions.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "URLFunctions.h"
-#include <optional>
-
-namespace facebook::velox::functions::detail {
-
-std::optional<StringView> matchAuthorityAndPath(
-    StringView authorityAndPath,
-    boost::cmatch& authorityMatch,
-    int subGroup) {
-  boost::cmatch authAndPathMatch;
-  static const boost::regex kAuthorityAndPathRegex("//([^/]*)(/.*)?");
-  if (!boost::regex_match(
-          authorityAndPath.begin(),
-          authorityAndPath.end(),
-          authAndPathMatch,
-          kAuthorityAndPathRegex)) {
-    // Does not start with //, doesn't have authority.
-    return std::nullopt;
-  }
-
-  static const boost::regex kAuthorityRegex(
-      "(?:([^@:]*)(?::([^@]*))?@)?" // username, password.
-      "(\\[[^\\]]*\\]|[^\\[:]*)" // host (IP-literal (e.g. '['+IPv6+']',
-      // dotted-IPv4, or named host).
-      "(?::(\\d*))?"); // port.
-
-  const auto authority = authAndPathMatch[1];
-  if (!boost::regex_match(
-          authority.first, authority.second, authorityMatch, kAuthorityRegex)) {
-    return std::nullopt; // Invalid URI Authority.
-  }
-
-  if (authorityMatch[subGroup].matched) {
-    return detail::submatch(authorityMatch, subGroup);
-  }
-
-  return std::nullopt;
-}
-
-} // namespace facebook::velox::functions::detail
diff --git a/velox/functions/prestosql/URLFunctions.h b/velox/functions/prestosql/URLFunctions.h
index e96be9223ec..6d3c01d196b 100644
--- a/velox/functions/prestosql/URLFunctions.h
+++ b/velox/functions/prestosql/URLFunctions.h
@@ -232,6 +232,7 @@ FOLLY_ALWAYS_INLINE void urlUnescape(
   }
   output.resize(outputBuffer - output.data());
 }
+
 } // namespace detail
 
 template <typename T>
diff --git a/velox/functions/prestosql/VectorArithmetic.cpp b/velox/functions/prestosql/VectorArithmetic.cpp
index 16704fb694c..6e508476436 100644
--- a/velox/functions/prestosql/VectorArithmetic.cpp
+++ b/velox/functions/prestosql/VectorArithmetic.cpp
@@ -361,11 +361,12 @@ class ArithmeticRegistration {
         "tinyint", "smallint", "integer", "bigint", "real", "double"};
     std::vector<std::shared_ptr<exec::FunctionSignature>> signatures;
     for (const auto& type : types) {
-      signatures.emplace_back(exec::FunctionSignatureBuilder()
-                                  .returnType(type)
-                                  .argumentType(type)
-                                  .argumentType(type)
-                                  .build());
+      signatures.emplace_back(
+          exec::FunctionSignatureBuilder()
+              .returnType(type)
+              .argumentType(type)
+              .argumentType(type)
+              .build());
     }
 
     registerVectorFunction(
diff --git a/velox/functions/prestosql/WordStem.h b/velox/functions/prestosql/WordStem.h
index 41b01bb9aa3..616f9dbc0cc 100644
--- a/velox/functions/prestosql/WordStem.h
+++ b/velox/functions/prestosql/WordStem.h
@@ -97,8 +97,8 @@ struct WordStemFunction {
   FOLLY_ALWAYS_INLINE void doCall(
       out_type<Varchar>& result,
       const arg_type<Varchar>& input,
-      const std::string& lang = "en") {
-    auto* stemmer = getStemmer(lang);
+      const arg_type<Varchar>& lang = "en") {
+    auto* stemmer = getStemmer(std::string(lang));
     VELOX_USER_CHECK_NOT_NULL(
         stemmer, "Unsupported stemmer language: {}", lang);
 
diff --git a/velox/functions/prestosql/aggregates/AggregateNames.h b/velox/functions/prestosql/aggregates/AggregateNames.h
index 76fe825cc0a..31f1cca57f6 100644
--- a/velox/functions/prestosql/aggregates/AggregateNames.h
+++ b/velox/functions/prestosql/aggregates/AggregateNames.h
@@ -22,6 +22,7 @@ const char* const kApproxDistinct = "approx_distinct";
 const char* const kApproxMostFrequent = "approx_most_frequent";
 const char* const kApproxPercentile = "approx_percentile";
 const char* const kApproxSet = "approx_set";
+const char* const kApproxWinsorizedMean = "approx_winsorized_mean";
 const char* const kQDigestAgg = "qdigest_agg";
 const char* const kArbitrary = "arbitrary";
 const char* const kAnyValue = "any_value";
@@ -38,6 +39,7 @@ const char* const kClassificationPrecision = "classification_precision";
 const char* const kClassificationRecall = "classification_recall";
 const char* const kClassificationMissRate = "classification_miss_rate";
 const char* const kClassificationThreshold = "classification_thresholds";
+const char* const kConvexHull = "convex_hull_agg";
 const char* const kCorr = "corr";
 const char* const kCount = "count";
 const char* const kCountIf = "count_if";
@@ -46,11 +48,14 @@ const char* const kCovarSamp = "covar_samp";
 const char* const kEntropy = "entropy";
 const char* const kEvery = "every";
 const char* const kGeometricMean = "geometric_mean";
+const char* const kGeometryUnion = "geometry_union_agg";
 const char* const kHistogram = "histogram";
 const char* const kKurtosis = "kurtosis";
 const char* const kMapAgg = "map_agg";
 const char* const kMapUnion = "map_union";
 const char* const kMapUnionSum = "map_union_sum";
+const char* const kMakeSetDigest = "make_set_digest";
+const char* const kMergeSetDigest = "merge_set_digest";
 const char* const kMax = "max";
 const char* const kMaxBy = "max_by";
 const char* const kMerge = "merge";
@@ -72,6 +77,7 @@ const char* const kRegrSxy = "regr_sxy";
 const char* const kRegrSxx = "regr_sxx";
 const char* const kRegrSyy = "regr_syy";
 const char* const kRegrR2 = "regr_r2";
+const char* const kReservoirSample = "reservoir_sample";
 const char* const kSetAgg = "set_agg";
 const char* const kSetUnion = "set_union";
 const char* const kSkewness = "skewness";
@@ -83,10 +89,12 @@ const char* const kTDigestAgg = "tdigest_agg";
 const char* const kVariance = "variance"; // Alias for var_samp.
 const char* const kVarPop = "var_pop";
 const char* const kVarSamp = "var_samp";
+const char* const kVectorSum = "vector_sum";
 const char* const kMaxSizeForStats = "max_data_size_for_stats";
 const char* const kSumDataSizeForStats = "sum_data_size_for_stats";
 const char* const kNoisyApproxSetSfm = "noisy_approx_set_sfm";
 const char* const kNoisyApproxDistinctSfm = "noisy_approx_distinct_sfm";
 const char* const kNoisyApproxSetSfmFromIndexAndZeros =
     "noisy_approx_set_sfm_from_index_and_zeros";
+const char* const kKHyperLogLogAgg = "khyperloglog_agg";
 } // namespace facebook::velox::aggregate
diff --git a/velox/functions/prestosql/aggregates/ApproxDistinctAggregate.cpp b/velox/functions/prestosql/aggregates/ApproxDistinctAggregate.cpp
index fcd7c808d90..95d41f5f86b 100644
--- a/velox/functions/prestosql/aggregates/ApproxDistinctAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/ApproxDistinctAggregate.cpp
@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 #include "velox/expression/FunctionSignature.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/functions/prestosql/aggregates/ApproxDistinctAggregates.h"
 #include "velox/functions/prestosql/aggregates/HyperLogLogAggregate.h"
 #include "velox/functions/prestosql/types/HyperLogLogRegistration.h"
@@ -23,8 +22,8 @@ namespace facebook::velox::aggregate::prestosql {
 
 namespace {
 
-exec::AggregateRegistrationResult registerApproxDistinct(
-    const std::string& name,
+std::vector<exec::AggregateRegistrationResult> registerApproxDistinct(
+    const std::vector<std::string>& names,
     bool hllAsFinalResult,
     bool withCompanionFunctions,
     bool overwrite,
@@ -49,52 +48,57 @@ exec::AggregateRegistrationResult registerApproxDistinct(
             "date",
             "unknown"};
   for (const auto& inputType : inputTypes) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType(returnType)
-                             .intermediateType("varbinary")
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType(returnType)
+            .intermediateType("varbinary")
+            .argumentType(inputType)
+            .build());
 
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType(returnType)
-                             .intermediateType("varbinary")
-                             .argumentType(inputType)
-                             .argumentType("double")
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType(returnType)
+            .intermediateType("varbinary")
+            .argumentType(inputType)
+            .argumentType("double")
+            .build());
   }
   if (!hllAsFinalResult) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType("bigint")
-                             .intermediateType("tinyint")
-                             .argumentType("boolean")
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType("bigint")
+            .intermediateType("tinyint")
+            .argumentType("boolean")
+            .build());
   }
 
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .integerVariable("a_precision")
-                           .integerVariable("a_scale")
-                           .returnType(returnType)
-                           .intermediateType("varbinary")
-                           .argumentType("DECIMAL(a_precision, a_scale)")
-                           .build());
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .integerVariable("a_precision")
-                           .integerVariable("a_scale")
-                           .returnType(returnType)
-                           .intermediateType("varbinary")
-                           .argumentType("DECIMAL(a_precision, a_scale)")
-                           .argumentType("double")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .integerVariable("a_precision")
+          .integerVariable("a_scale")
+          .returnType(returnType)
+          .intermediateType("varbinary")
+          .argumentType("DECIMAL(a_precision, a_scale)")
+          .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .integerVariable("a_precision")
+          .integerVariable("a_scale")
+          .returnType(returnType)
+          .intermediateType("varbinary")
+          .argumentType("DECIMAL(a_precision, a_scale)")
+          .argumentType("double")
+          .build());
   return exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name, hllAsFinalResult, hllAsRawInput, defaultError](
+      [hllAsFinalResult, hllAsRawInput, defaultError](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
-        if (argTypes[0]->isUnKnown()) {
+        if (argTypes[0]->isUnknown()) {
           if (hllAsFinalResult) {
             return std::make_unique<HyperLogLogAggregate<UnknownValue, true>>(
                 resultType, hllAsRawInput, defaultError);
@@ -123,12 +127,13 @@ exec::AggregateRegistrationResult registerApproxDistinct(
 } // namespace
 
 void registerApproxDistinctAggregates(
-    const std::string& prefix,
+    const std::vector<std::string>& approxDistinctNames,
+    const std::vector<std::string>& approxSetNames,
     bool withCompanionFunctions,
     bool overwrite) {
   registerHyperLogLogType();
   registerApproxDistinct(
-      prefix + kApproxDistinct,
+      approxDistinctNames,
       false,
       withCompanionFunctions,
       overwrite,
@@ -136,7 +141,7 @@ void registerApproxDistinctAggregates(
   // approx_set is companion function for approx_distinct. Don't register
   // companion functions for it.
   registerApproxDistinct(
-      prefix + kApproxSet,
+      approxSetNames,
       true,
       false,
       overwrite,
diff --git a/velox/functions/prestosql/aggregates/ApproxDistinctAggregates.h b/velox/functions/prestosql/aggregates/ApproxDistinctAggregates.h
index 0369ddbf458..6f2e31040fc 100644
--- a/velox/functions/prestosql/aggregates/ApproxDistinctAggregates.h
+++ b/velox/functions/prestosql/aggregates/ApproxDistinctAggregates.h
@@ -17,11 +17,13 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerApproxDistinctAggregates(
-    const std::string& prefix,
+    const std::vector<std::string>& approxDistinctNames,
+    const std::vector<std::string>& approxSetNames,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/ApproxMostFrequentAggregate.cpp b/velox/functions/prestosql/aggregates/ApproxMostFrequentAggregate.cpp
index d32f6ebcb50..4e49f1b361a 100644
--- a/velox/functions/prestosql/aggregates/ApproxMostFrequentAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/ApproxMostFrequentAggregate.cpp
@@ -15,65 +15,136 @@
  */
 
 #include "velox/functions/prestosql/aggregates/ApproxMostFrequentAggregate.h"
+#include "velox/core/QueryConfig.h"
 #include "velox/exec/Aggregate.h"
 #include "velox/exec/SimpleAggregateAdapter.h"
 #include "velox/exec/Strings.h"
 #include "velox/expression/FunctionSignature.h"
 #include "velox/functions/lib/ApproxMostFrequentStreamSummary.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/vector/FlatVector.h"
 
 namespace facebook::velox::aggregate::prestosql {
 
 namespace {
 
+template <typename T, typename A = AlignedStlAllocator<T, 16>>
+using Summary = functions::ApproxMostFrequentStreamSummary<T, A>;
+
 template <typename T>
 struct Accumulator {
-  functions::ApproxMostFrequentStreamSummary<T, AlignedStlAllocator<T, 16>>
-      summary;
+  Summary<T> summary;
 
   explicit Accumulator(HashStringAllocator* allocator)
       : summary(AlignedStlAllocator<T, 16>(allocator)) {}
 
-  void insert(T value, int64_t count = 1) {
+  void insert(T value, int64_t count) {
     summary.insert(value, count);
   }
 };
 
 template <>
 struct Accumulator<StringView> {
-  functions::ApproxMostFrequentStreamSummary<
-      StringView,
-      AlignedStlAllocator<StringView, 16>>
-      summary;
+  Summary<StringView> summary;
   HashStringAllocator* allocator;
   Strings strings;
+  size_t activeBytes_{0};
+  size_t evictedBytes_{0};
 
-  explicit Accumulator(HashStringAllocator* allocator)
-      : summary(AlignedStlAllocator<StringView, 16>(allocator)),
-        allocator(allocator) {}
+  explicit Accumulator(HashStringAllocator* _allocator)
+      : summary(AlignedStlAllocator<StringView, 16>(_allocator)),
+        allocator(_allocator) {}
 
   ~Accumulator() {
     strings.free(*allocator);
   }
 
-  void insert(StringView value, int64_t count = 1) {
+  void insert(
+      StringView value,
+      int64_t count,
+      uint64_t compactionBytesThreshold = 0,
+      double compactionUnusedMemoryRatio = 0) {
     if (!value.isInline() && !summary.contains(value)) {
+      activeBytes_ += value.size();
       value = strings.append(value, *allocator);
     }
-    summary.insert(value, count);
+
+    auto evicted = summary.insert(value, count);
+    if (evicted.has_value() && !evicted->isInline()) {
+      const auto evictedSize = evicted->size();
+      evictedBytes_ += evictedSize;
+      VELOX_CHECK_GE(activeBytes_, evictedSize);
+      activeBytes_ -= evictedSize;
+
+      // Trigger compaction to reclaim memory from evicted strings.
+      // Compact only when:
+      // 1. Total string storage exceeds compactionBytesThreshold, AND
+      // 2. Evicted bytes exceed compactionUnusedMemoryRatio of the threshold.
+      if (compactionBytesThreshold > 0) {
+        if (FOLLY_UNLIKELY(
+                (evictedBytes_ + activeBytes_ > compactionBytesThreshold) &&
+                (evictedBytes_ >
+                 compactionBytesThreshold * compactionUnusedMemoryRatio))) {
+          compact();
+        }
+      }
+    }
+  }
+
+  uint64_t compact() {
+    if (summary.size() == 0 || evictedBytes_ == 0) {
+      return 0;
+    }
+
+    const auto bytesFreed = evictedBytes_;
+    const auto capacity = summary.capacity();
+    const auto currentSize = summary.size();
+
+    Strings compactedStrings;
+    Summary<StringView> compactedSummary{
+        AlignedStlAllocator<StringView, 16>{allocator}};
+    compactedSummary.setCapacity(capacity);
+
+    uint64_t compactedActiveBytes = 0;
+    for (auto i = 0; i < currentSize; ++i) {
+      StringView v = summary.values()[i];
+      int64_t cnt = summary.counts()[i];
+      if (!v.isInline()) {
+        compactedActiveBytes += v.size();
+        v = compactedStrings.append(v, *allocator);
+      }
+      compactedSummary.insert(v, cnt);
+    }
+
+    VELOX_CHECK_EQ(compactedActiveBytes, activeBytes_);
+
+    // Free old storage.
+    strings.free(*allocator);
+
+    strings = std::move(compactedStrings);
+    summary = std::move(compactedSummary);
+    evictedBytes_ = 0;
+    return bytesFreed;
   }
 };
 
 template <typename T>
 struct ApproxMostFrequentAggregate : exec::Aggregate {
-  explicit ApproxMostFrequentAggregate(const TypePtr& resultType)
-      : Aggregate(resultType) {}
+  explicit ApproxMostFrequentAggregate(
+      const TypePtr& resultType,
+      uint64_t compactionBytesThreshold,
+      double compactionUnusedMemoryRatio)
+      : Aggregate(resultType),
+        compactionBytesThreshold_(compactionBytesThreshold),
+        compactionUnusedMemoryRatio_(compactionUnusedMemoryRatio) {}
 
   int32_t accumulatorFixedWidthSize() const override {
     return sizeof(Accumulator<T>);
   }
 
+  bool isFixedSize() const override {
+    return false;
+  }
+
   void addRawInput(
       char** groups,
       const SelectivityVector& rows,
@@ -83,7 +154,8 @@ struct ApproxMostFrequentAggregate : exec::Aggregate {
     rows.applyToSelected([&](auto row) {
       if (!decodedValues_.isNullAt(row)) {
         auto* accumulator = initAccumulator(groups[row]);
-        accumulator->insert(decodedValues_.valueAt<T>(row));
+        auto tracker = trackRowSize(groups[row]);
+        accumulator->insert(decodedValues_.valueAt<T>(row), 1);
       }
     });
   }
@@ -103,9 +175,18 @@ struct ApproxMostFrequentAggregate : exec::Aggregate {
       bool) override {
     decodeArguments(rows, args);
     auto* accumulator = initAccumulator(group);
+    auto tracker = trackRowSize(group);
     rows.applyToSelected([&](auto row) {
       if (!decodedValues_.isNullAt(row)) {
-        accumulator->insert(decodedValues_.valueAt<T>(row));
+        if constexpr (std::is_same_v<T, StringView>) {
+          accumulator->insert(
+              decodedValues_.valueAt<T>(row),
+              1,
+              compactionBytesThreshold_,
+              compactionUnusedMemoryRatio_);
+        } else {
+          accumulator->insert(decodedValues_.valueAt<T>(row), 1);
+        }
       }
     });
   }
@@ -135,7 +216,7 @@ struct ApproxMostFrequentAggregate : exec::Aggregate {
     vector_size_t entryCount = 0;
     for (int i = 0; i < numGroups; ++i) {
       auto* summary = &value<Accumulator<T>>(groups[i])->summary;
-      int size = std::min<int>(buckets_, summary->size());
+      const int size = std::min<int>(buckets_, summary->size());
       if (size == 0) {
         mapVector->setNull(i, true);
       } else {
@@ -157,8 +238,8 @@ struct ApproxMostFrequentAggregate : exec::Aggregate {
 
   void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
       override {
-    auto rowVec = (*result)->as<RowVector>();
-    VELOX_CHECK(rowVec);
+    auto* rowVec = (*result)->as<RowVector>();
+    VELOX_CHECK_NOT_NULL(rowVec);
     rowVec->childAt(0) = std::make_shared<ConstantVector<int64_t>>(
         rowVec->pool(),
         numGroups,
@@ -171,14 +252,14 @@ struct ApproxMostFrequentAggregate : exec::Aggregate {
         false,
         BIGINT(),
         static_cast<int64_t&&>(capacity_));
-    auto values = rowVec->childAt(2)->as<ArrayVector>();
-    auto counts = rowVec->childAt(3)->as<ArrayVector>();
+    auto* values = rowVec->childAt(2)->as<ArrayVector>();
+    auto* counts = rowVec->childAt(3)->as<ArrayVector>();
     rowVec->resize(numGroups);
     values->resize(numGroups);
     counts->resize(numGroups);
 
-    auto v = values->elements()->template asFlatVector<T>();
-    auto c = counts->elements()->template asFlatVector<int64_t>();
+    auto* v = values->elements()->template asFlatVector<T>();
+    auto* c = counts->elements()->template asFlatVector<int64_t>();
     vector_size_t entryCount = 0;
     for (int i = 0; i < numGroups; ++i) {
       auto* accumulator = value<const Accumulator<T>>(groups[i]);
@@ -229,6 +310,24 @@ struct ApproxMostFrequentAggregate : exec::Aggregate {
     destroyAccumulators<Accumulator<T>>(groups);
   }
 
+  bool supportsCompact() const override {
+    return std::is_same_v<T, StringView>;
+  }
+
+  uint64_t compact(folly::Range<char**> groups) override {
+    if constexpr (!std::is_same_v<T, StringView>) {
+      return 0;
+    } else {
+      uint64_t freedBytes = 0;
+      for (auto* group : groups) {
+        if (isInitialized(group)) {
+          freedBytes += value<Accumulator<T>>(group)->compact();
+        }
+      }
+      return freedBytes;
+    }
+  }
+
  private:
   void decodeArguments(
       const SelectivityVector& rows,
@@ -278,52 +377,71 @@ struct ApproxMostFrequentAggregate : exec::Aggregate {
     VELOX_CHECK_EQ(args.size(), 1);
     DecodedVector decoded(*args[0], rows);
     auto rowVec = static_cast<const RowVector*>(decoded.base());
-    auto buckets = rowVec->childAt(0)->as<SimpleVector<int64_t>>();
-    auto capacity = rowVec->childAt(1)->as<SimpleVector<int64_t>>();
-    auto values = rowVec->childAt(2)->as<ArrayVector>();
-    auto counts = rowVec->childAt(3)->as<ArrayVector>();
-    VELOX_CHECK(buckets);
-    VELOX_CHECK(capacity);
-    VELOX_CHECK(values);
-    VELOX_CHECK(counts);
-
-    auto v = values->elements()->template asFlatVector<T>();
-    auto c = counts->elements()->template asFlatVector<int64_t>();
-    VELOX_CHECK(v);
-    VELOX_CHECK(c);
-
-    Accumulator<T>* accumulator = nullptr;
+    auto* buckets = rowVec->childAt(0)->as<SimpleVector<int64_t>>();
+    VELOX_CHECK_NOT_NULL(buckets);
+    auto* capacity = rowVec->childAt(1)->as<SimpleVector<int64_t>>();
+    VELOX_CHECK_NOT_NULL(capacity);
+    auto* values = rowVec->childAt(2)->as<ArrayVector>();
+    VELOX_CHECK_NOT_NULL(values);
+    auto* counts = rowVec->childAt(3)->as<ArrayVector>();
+    VELOX_CHECK_NOT_NULL(counts);
+
+    auto* v = values->elements()->template asFlatVector<T>();
+    VELOX_CHECK_NOT_NULL(v);
+    auto* c = counts->elements()->template asFlatVector<int64_t>();
+    VELOX_CHECK_NOT_NULL(c);
+
+    Accumulator<T>* accumulator{nullptr};
     rows.applyToSelected([&](auto row) {
       if (decoded.isNullAt(row)) {
         return;
       }
-      int i = decoded.index(row);
+      const int i = decoded.index(row);
       setConstantArgument("Buckets", buckets_, buckets->valueAt(i));
       setConstantArgument("Capacity", capacity_, capacity->valueAt(i));
       if constexpr (kSingleGroup) {
-        if (!accumulator) {
+        if (accumulator == nullptr) {
           accumulator = initAccumulator(group);
         }
+        auto tracker = trackRowSize(group);
+        const auto size = values->sizeAt(i);
+        VELOX_DCHECK_EQ(counts->sizeAt(i), size);
+        const auto vo = values->offsetAt(i);
+        const auto co = counts->offsetAt(i);
+        if constexpr (std::is_same_v<T, StringView>) {
+          for (int j = 0; j < size; ++j) {
+            accumulator->insert(
+                v->valueAt(vo + j),
+                c->valueAt(co + j),
+                compactionBytesThreshold_,
+                compactionUnusedMemoryRatio_);
+          }
+        } else {
+          for (int j = 0; j < size; ++j) {
+            accumulator->insert(v->valueAt(vo + j), c->valueAt(co + j));
+          }
+        }
       } else {
         accumulator = initAccumulator(group[row]);
-      }
-      auto size = values->sizeAt(i);
-      VELOX_DCHECK_EQ(counts->sizeAt(i), size);
-      auto vo = values->offsetAt(i);
-      auto co = counts->offsetAt(i);
-      for (int j = 0; j < size; ++j) {
-        accumulator->insert(v->valueAt(vo + j), c->valueAt(co + j));
+        auto tracker = trackRowSize(group[row]);
+        const auto size = values->sizeAt(i);
+        VELOX_DCHECK_EQ(counts->sizeAt(i), size);
+        const auto vo = values->offsetAt(i);
+        const auto co = counts->offsetAt(i);
+        for (int j = 0; j < size; ++j) {
+          accumulator->insert(v->valueAt(vo + j), c->valueAt(co + j));
+        }
       }
     });
   }
 
   std::pair<FlatVector<T>*, FlatVector<int64_t>*>
   prepareFinalResult(char** groups, int32_t numGroups, MapVector* result) {
-    VELOX_CHECK(result);
-    auto keys = result->mapKeys()->asUnchecked<FlatVector<T>>();
-    auto values = result->mapValues()->asUnchecked<FlatVector<int64_t>>();
-    VELOX_CHECK(keys);
-    VELOX_CHECK(values);
+    VELOX_CHECK_NOT_NULL(result);
+    auto* keys = result->mapKeys()->asUnchecked<FlatVector<T>>();
+    VELOX_CHECK_NOT_NULL(keys);
+    auto* values = result->mapValues()->asUnchecked<FlatVector<int64_t>>();
+    VELOX_CHECK_NOT_NULL(values);
     vector_size_t entryCount = 0;
     for (int i = 0; i < numGroups; ++i) {
       auto* summary = &value<const Accumulator<T>>(groups[i])->summary;
@@ -334,10 +452,16 @@ struct ApproxMostFrequentAggregate : exec::Aggregate {
     return std::make_pair(keys, values);
   }
 
-  static constexpr int64_t kMissingArgument = -1;
+  static constexpr int64_t kMissingArgument{-1};
+
+  // NOTE: compaction is currently only applied for global aggregation
+  // addSingleGroupRawInput with StringView type
+  const uint64_t compactionBytesThreshold_;
+  const double compactionUnusedMemoryRatio_;
+
   DecodedVector decodedValues_;
-  int64_t buckets_ = kMissingArgument;
-  int64_t capacity_ = kMissingArgument;
+  int64_t buckets_{kMissingArgument};
+  int64_t capacity_{kMissingArgument};
 };
 
 class ApproxMostFrequentBooleanAggregate {
@@ -345,11 +469,10 @@ class ApproxMostFrequentBooleanAggregate {
   using InputType =
       Row</*buckets*/ int64_t, /*value*/ bool, /*capacity*/ int64_t>;
 
-  using IntermediateType =
-      Row</*buckets*/ int64_t,
-          /*capacity*/ int64_t,
-          /*values*/ Array<bool>,
-          /*counts*/ Array<int64_t>>;
+  using IntermediateType = Row</*buckets*/ int64_t,
+                               /*capacity*/ int64_t,
+                               /*values*/ Array<bool>,
+                               /*counts*/ Array<int64_t>>;
 
   using OutputType = Map<bool, int64_t>;
 
@@ -452,14 +575,16 @@ std::unique_ptr<exec::Aggregate> makeApproxMostFrequentAggregate(
     core::AggregationNode::Step step,
     const std::vector<TypePtr>& argTypes,
     const TypePtr& resultType,
-    const TypePtr& valueType) {
+    const TypePtr& valueType,
+    uint64_t compactionBytesThreshold,
+    double compactionUnusedMemoryRatio) {
   if constexpr (
       kKind == TypeKind::TINYINT || kKind == TypeKind::SMALLINT ||
       kKind == TypeKind::INTEGER || kKind == TypeKind::BIGINT ||
       kKind == TypeKind::VARCHAR) {
     return std::make_unique<
         ApproxMostFrequentAggregate<typename TypeTraits<kKind>::NativeType>>(
-        resultType);
+        resultType, compactionBytesThreshold, compactionUnusedMemoryRatio);
   }
 
   if (kKind == TypeKind::BOOLEAN) {
@@ -477,7 +602,7 @@ std::unique_ptr<exec::Aggregate> makeApproxMostFrequentAggregate(
 } // namespace
 
 void registerApproxMostFrequentAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
@@ -492,34 +617,35 @@ void registerApproxMostFrequentAggregate(
     signatures.push_back(
         exec::AggregateFunctionSignatureBuilder()
             .returnType(fmt::format("map({},bigint)", valueType))
-            .intermediateType(fmt::format(
-                "row(bigint, bigint, array({}), array(bigint))", valueType))
+            .intermediateType(
+                fmt::format(
+                    "row(bigint, bigint, array({}), array(bigint))", valueType))
             .argumentType("bigint")
             .argumentType(valueType)
             .argumentType("bigint")
             .build());
   }
-  auto name = prefix + kApproxMostFrequent;
   exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
+      [names](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
-          const core::QueryConfig& /*config*/)
-          -> std::unique_ptr<exec::Aggregate> {
+          const core::QueryConfig& config) -> std::unique_ptr<exec::Aggregate> {
         auto& valueType = exec::isPartialOutput(step)
             ? resultType->childAt(2)->childAt(0)
             : resultType->childAt(0);
         return VELOX_DYNAMIC_TYPE_DISPATCH(
             makeApproxMostFrequentAggregate,
             valueType->kind(),
-            name,
+            names.front(),
             step,
             argTypes,
             resultType,
-            valueType);
+            valueType,
+            config.aggregationCompactionBytesThreshold(),
+            config.aggregationCompactionUnusedMemoryRatio());
       },
       withCompanionFunctions,
       overwrite);
diff --git a/velox/functions/prestosql/aggregates/ApproxMostFrequentAggregate.h b/velox/functions/prestosql/aggregates/ApproxMostFrequentAggregate.h
index c3170a84458..f633d691d59 100644
--- a/velox/functions/prestosql/aggregates/ApproxMostFrequentAggregate.h
+++ b/velox/functions/prestosql/aggregates/ApproxMostFrequentAggregate.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerApproxMostFrequentAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/ApproxPercentileAggregate.cpp b/velox/functions/prestosql/aggregates/ApproxPercentileAggregate.cpp
index ea092bc691f..de3153e8a10 100644
--- a/velox/functions/prestosql/aggregates/ApproxPercentileAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/ApproxPercentileAggregate.cpp
@@ -14,828 +14,86 @@
  * limitations under the License.
  */
 #include "velox/functions/prestosql/aggregates/ApproxPercentileAggregate.h"
-#include "velox/common/base/IOUtils.h"
-#include "velox/common/base/Macros.h"
-#include "velox/common/base/RandomUtil.h"
-#include "velox/common/memory/HashStringAllocator.h"
-#include "velox/exec/Aggregate.h"
 #include "velox/expression/FunctionSignature.h"
-#include "velox/functions/lib/KllSketch.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
-#include "velox/vector/DecodedVector.h"
-#include "velox/vector/FlatVector.h"
+#include "velox/functions/lib/aggregates/ApproxPercentileAggregateBase.h"
 
 namespace facebook::velox::aggregate::prestosql {
 
-namespace {
-
-template <typename T, typename Allocator>
-struct KllSketchTypeTraits {
-  using KllSketchType = functions::kll::KllSketch<T, Allocator, std::less<T>>;
-};
-
-template <>
-struct KllSketchTypeTraits<float, StlAllocator<float>> {
-  using KllSketchType = functions::kll::KllSketch<
-      float,
-      StlAllocator<float>,
-      util::floating_point::NaNAwareLessThan<float>>;
-};
-
-template <>
-struct KllSketchTypeTraits<double, StlAllocator<double>> {
-  using KllSketchType = functions::kll::KllSketch<
-      double,
-      StlAllocator<double>,
-      util::floating_point::NaNAwareLessThan<double>>;
-};
-
-template <>
-struct KllSketchTypeTraits<float, std::allocator<float>> {
-  using KllSketchType = functions::kll::KllSketch<
-      float,
-      std::allocator<float>,
-      util::floating_point::NaNAwareLessThan<float>>;
-};
-
-template <>
-struct KllSketchTypeTraits<double, std::allocator<double>> {
-  using KllSketchType = functions::kll::KllSketch<
-      double,
-      std::allocator<double>,
-      util::floating_point::NaNAwareLessThan<double>>;
-};
-
-template <typename T, typename Allocator = StlAllocator<T>>
-using KllSketch = typename KllSketchTypeTraits<T, Allocator>::KllSketchType;
-template <typename T>
-using KllView = functions::kll::detail::View<T>;
-
-unsigned getRandomSeed(std::optional<uint32_t> fixedRandomSeed) {
-  return fixedRandomSeed.has_value() ? *fixedRandomSeed : random::getSeed();
-}
-
-// Accumulator to buffer large count values in addition to the KLL
-// sketch itself.
-template <typename T>
-struct KllSketchAccumulator {
-  explicit KllSketchAccumulator(
-      HashStringAllocator* allocator,
-      std::optional<uint32_t> fixedRandomSeed)
-      : sketch_(
-            functions::kll::kDefaultK,
-            StlAllocator<T>(allocator),
-            getRandomSeed(fixedRandomSeed)),
-        largeCountValues_(StlAllocator<std::pair<T, int64_t>>(allocator)) {}
-
-  void setAccuracy(double value) {
-    sketch_.setK(functions::kll::kFromEpsilon(value));
-  }
-
-  void append(T value) {
-    sketch_.insert(value);
-  }
-
-  void append(
-      T value,
-      int64_t count,
-      HashStringAllocator* allocator,
-      std::optional<uint32_t> fixedRandomSeed) {
-    constexpr size_t kMaxBufferSize = 4096;
-    constexpr int64_t kMinCountToBuffer = 512;
-    if (count < kMinCountToBuffer) {
-      for (int i = 0; i < count; ++i) {
-        sketch_.insert(value);
-      }
-    } else {
-      largeCountValues_.emplace_back(value, count);
-      if (largeCountValues_.size() >= kMaxBufferSize) {
-        flush(allocator, fixedRandomSeed);
-      }
-    }
-  }
-
-  void append(const KllView<T>& view) {
-    sketch_.mergeViews(folly::Range(&view, 1));
-  }
-
-  void append(const std::vector<KllView<T>>& views) {
-    sketch_.mergeViews(views);
-  }
-
-  // Creates a copy of the KllSketch, merges the largeCountValues_ into it,
-  // compacts it, and returns it.
-  // Makes a copy so that uses std::allocator so that this is safe to call
-  // during spilling which may run in parallel.  HashStringAllocator is not
-  // thread safe, so merging into/compacting the original KllSketch which
-  // depends on it can lead to concurrency bugs.
-  KllSketch<T, std::allocator<T>> compact(
-      std::optional<uint32_t> fixedRandomSeed) const {
-    KllSketch<T, std::allocator<T>> newSketch =
-        KllSketch<T, std::allocator<T>>::fromView(
-            sketch_.toView(),
-            std::allocator<T>(),
-            getRandomSeed(fixedRandomSeed));
-
-    mergeLargeCountValuesIntoSketch(
-        std::allocator<T>(), newSketch, fixedRandomSeed);
-
-    newSketch.compact();
-
-    return newSketch;
-  }
-
-  const KllSketch<T>& getSketch() const {
-    return sketch_;
-  }
-
-  // This must be called before the KllSketch can be used for estimateQuantile()
-  // or estimateQuantiles().
-  void flush(
-      HashStringAllocator* allocator,
-      std::optional<uint32_t> fixedRandomSeed) {
-    mergeLargeCountValuesIntoSketch(
-        StlAllocator<T>(allocator), sketch_, fixedRandomSeed);
-    largeCountValues_.clear();
-
-    sketch_.finish();
-  }
-
- private:
-  template <typename Allocator, typename Compare>
-  void mergeLargeCountValuesIntoSketch(
-      const Allocator& allocator,
-      functions::kll::KllSketch<T, Allocator, Compare>& sketch,
-      std::optional<uint32_t> fixedRandomSeed) const {
-    if (!largeCountValues_.empty()) {
-      std::vector<functions::kll::KllSketch<T, Allocator, Compare>> sketches;
-      sketches.reserve(largeCountValues_.size());
-      for (auto [x, n] : largeCountValues_) {
-        sketches.push_back(
-            functions::kll::KllSketch<T, Allocator, Compare>::fromRepeatedValue(
-                x, n, sketch_.k(), allocator, getRandomSeed(fixedRandomSeed)));
-      }
-      sketch.merge(folly::Range(sketches.begin(), sketches.end()));
-    }
-  }
-
-  KllSketch<T> sketch_;
-  std::vector<std::pair<T, int64_t>, StlAllocator<std::pair<T, int64_t>>>
-      largeCountValues_;
-};
+using functions::aggregate::ApproxPercentileAggregateBase;
+using Idx = functions::aggregate::ApproxPercentileIntermediateTypeChildIndex;
 
-void checkWeight(int64_t weight) {
-  constexpr int64_t kMaxWeight = (1ll << 60) - 1;
-  VELOX_USER_CHECK(
-      1 <= weight && weight <= kMaxWeight,
-      "{}: weight must be in range [1, {}], got {}",
-      kApproxPercentile,
-      kMaxWeight,
-      weight);
-}
-
-template <typename T>
-class ApproxPercentileAggregate : public exec::Aggregate {
- public:
-  ApproxPercentileAggregate(
-      bool hasWeight,
-      bool hasAccuracy,
-      const TypePtr& resultType,
-      std::optional<uint32_t> fixedRandomSeed)
-      : exec::Aggregate(resultType),
-        hasWeight_{hasWeight},
-        hasAccuracy_(hasAccuracy),
-        fixedRandomSeed_(fixedRandomSeed) {}
-
-  int32_t accumulatorFixedWidthSize() const override {
-    return sizeof(KllSketchAccumulator<T>);
-  }
-
-  bool isFixedSize() const override {
-    return false;
-  }
-
-  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
-      override {
-    for (auto i = 0; i < numGroups; ++i) {
-      value<KllSketchAccumulator<T>>(groups[i])->flush(
-          allocator_, fixedRandomSeed_);
-    }
-
-    VELOX_CHECK(result);
-    // When all inputs are nulls or masked out, percentiles_ can be
-    // uninitialized. The result should be nulls in this case.
-    if (!percentiles_.has_value()) {
-      *result = BaseVector::createNullConstant(
-          (*result)->type(), numGroups, (*result)->pool());
-      return;
-    }
-
-    if (percentiles_ && percentiles_->isArray) {
-      folly::Range percentiles(
-          percentiles_->values.begin(), percentiles_->values.end());
-      auto arrayResult = (*result)->asUnchecked<ArrayVector>();
-      vector_size_t elementsCount = 0;
-      for (auto i = 0; i < numGroups; ++i) {
-        char* group = groups[i];
-        auto accumulator = value<KllSketchAccumulator<T>>(group);
-        if (accumulator->getSketch().totalCount() > 0) {
-          elementsCount += percentiles.size();
-        }
-      }
-      arrayResult->elements()->resize(elementsCount);
-      elementsCount = 0;
-      auto rawValues =
-          arrayResult->elements()->asFlatVector<T>()->mutableRawValues();
-      extract(
-          groups,
-          numGroups,
-          arrayResult,
-          [&](const KllSketch<T>& digest,
-              ArrayVector* result,
-              vector_size_t index) {
-            digest.estimateQuantiles(percentiles, rawValues + elementsCount);
-            result->setOffsetAndSize(index, elementsCount, percentiles.size());
-            result->setNull(index, false);
-            elementsCount += percentiles.size();
-          });
-    } else {
-      extract(
-          groups,
-          numGroups,
-          (*result)->asFlatVector<T>(),
-          [&](const KllSketch<T>& digest,
-              FlatVector<T>* result,
-              vector_size_t index) {
-            VELOX_DCHECK_EQ(percentiles_->values.size(), 1);
-            result->set(
-                index, digest.estimateQuantile(percentiles_->values.back()));
-          });
-    }
-  }
-
-  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
-      override {
-    std::vector<KllSketch<T, std::allocator<T>>> sketches;
-    sketches.reserve(numGroups);
-    for (auto i = 0; i < numGroups; ++i) {
-      sketches.push_back(
-          value<KllSketchAccumulator<T>>(groups[i])->compact(fixedRandomSeed_));
-    }
-
-    VELOX_CHECK(result);
-    auto rowResult = (*result)->as<RowVector>();
-    VELOX_CHECK(rowResult);
-    auto pool = rowResult->pool();
-
-    // percentiles_ can be uninitialized during an intermediate aggregation step
-    // when all input intermediate states are nulls. Result should be nulls in
-    // this case.
-    if (!percentiles_) {
-      rowResult->ensureWritable(SelectivityVector{numGroups});
-      // rowResult->childAt(i) for i = kPercentiles, kPercentilesIsArray, and
-      // kAccuracy are expected to be constant in addIntermediateResults.
-      rowResult->childAt(kPercentiles) =
-          BaseVector::createNullConstant(ARRAY(DOUBLE()), numGroups, pool);
-      rowResult->childAt(kPercentilesIsArray) =
-          BaseVector::createNullConstant(BOOLEAN(), numGroups, pool);
-      rowResult->childAt(kAccuracy) =
-          BaseVector::createNullConstant(DOUBLE(), numGroups, pool);
-
-      // Set nulls for all rows.
-      auto rawNulls = rowResult->mutableRawNulls();
-      bits::fillBits(rawNulls, 0, rowResult->size(), bits::kNull);
-      return;
-    }
-    auto& values = percentiles_->values;
-    auto size = values.size();
-    auto elements =
-        BaseVector::create<FlatVector<double>>(DOUBLE(), size, pool);
-    std::copy(values.begin(), values.end(), elements->mutableRawValues());
-    auto array = std::make_shared<ArrayVector>(
-        pool,
-        ARRAY(DOUBLE()),
-        nullptr,
-        1,
-        AlignedBuffer::allocate<vector_size_t>(1, pool, 0),
-        AlignedBuffer::allocate<vector_size_t>(1, pool, size),
-        std::move(elements));
-    rowResult->childAt(kPercentiles) =
-        BaseVector::wrapInConstant(numGroups, 0, std::move(array));
-    rowResult->childAt(kPercentilesIsArray) =
-        std::make_shared<ConstantVector<bool>>(
-            pool,
-            numGroups,
-            false,
-            BOOLEAN(),
-            static_cast<bool&&>(percentiles_->isArray));
-    rowResult->childAt(kAccuracy) = std::make_shared<ConstantVector<double>>(
-        pool,
-        numGroups,
-        accuracy_ == kMissingNormalizedValue,
-        DOUBLE(),
-        static_cast<double&&>(accuracy_));
-    auto k = rowResult->childAt(kK)->asFlatVector<int32_t>();
-    auto n = rowResult->childAt(kN)->asFlatVector<int64_t>();
-    auto minValue = rowResult->childAt(kMinValue)->asFlatVector<T>();
-    auto maxValue = rowResult->childAt(kMaxValue)->asFlatVector<T>();
-    auto items = rowResult->childAt(kItems)->as<ArrayVector>();
-    auto levels = rowResult->childAt(kLevels)->as<ArrayVector>();
-
-    rowResult->resize(numGroups);
-    k->resize(numGroups);
-    n->resize(numGroups);
-    minValue->resize(numGroups);
-    maxValue->resize(numGroups);
-    items->resize(numGroups);
-    levels->resize(numGroups);
-
-    auto itemsElements = items->elements()->asFlatVector<T>();
-    auto levelsElements = levels->elements()->asFlatVector<int32_t>();
-    size_t itemsCount = 0;
-    vector_size_t levelsCount = 0;
-    for (auto& sketch : sketches) {
-      auto v = sketch.toView();
-      itemsCount += v.items.size();
-      levelsCount += v.levels.size();
-    }
-    VELOX_CHECK_LE(itemsCount, std::numeric_limits<vector_size_t>::max());
-    itemsElements->resetNulls();
-    itemsElements->resize(itemsCount);
-    levelsElements->resetNulls();
-    levelsElements->resize(levelsCount);
-
-    auto rawItems = itemsElements->mutableRawValues();
-    auto rawLevels = levelsElements->mutableRawValues();
-    itemsCount = 0;
-    levelsCount = 0;
-    for (int i = 0; i < sketches.size(); ++i) {
-      auto v = sketches[i].toView();
-      if (v.n == 0) {
-        rowResult->setNull(i, true);
-      } else {
-        rowResult->setNull(i, false);
-        k->set(i, v.k);
-        n->set(i, v.n);
-        minValue->set(i, v.minValue);
-        maxValue->set(i, v.maxValue);
-        std::copy(v.items.begin(), v.items.end(), rawItems + itemsCount);
-        items->setOffsetAndSize(i, itemsCount, v.items.size());
-        itemsCount += v.items.size();
-        std::copy(v.levels.begin(), v.levels.end(), rawLevels + levelsCount);
-        levels->setOffsetAndSize(i, levelsCount, v.levels.size());
-        levelsCount += v.levels.size();
-      }
-    }
-  }
-
-  void addRawInput(
-      char** groups,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool /*mayPushdown*/) override {
-    decodeArguments(rows, args);
-
-    if (hasWeight_) {
-      rows.applyToSelected([&](auto row) {
-        if (decodedValue_.isNullAt(row) || decodedWeight_.isNullAt(row)) {
-          return;
-        }
-
-        auto tracker = trackRowSize(groups[row]);
-        auto accumulator = initRawAccumulator(groups[row]);
-        auto value = decodedValue_.valueAt<T>(row);
-        auto weight = decodedWeight_.valueAt<int64_t>(row);
-        checkWeight(weight);
-        accumulator->append(value, weight, allocator_, fixedRandomSeed_);
-      });
-    } else {
-      if (decodedValue_.mayHaveNulls()) {
-        rows.applyToSelected([&](auto row) {
-          if (decodedValue_.isNullAt(row)) {
-            return;
-          }
-
-          auto accumulator = initRawAccumulator(groups[row]);
-          accumulator->append(decodedValue_.valueAt<T>(row));
-        });
-      } else {
-        rows.applyToSelected([&](auto row) {
-          auto accumulator = initRawAccumulator(groups[row]);
-          accumulator->append(decodedValue_.valueAt<T>(row));
-        });
-      }
-    }
-  }
-
-  void addIntermediateResults(
-      char** groups,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool /*mayPushdown*/) override {
-    addIntermediate<false>(groups, rows, args);
-  }
-
-  void addSingleGroupRawInput(
-      char* group,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool /*mayPushdown*/) override {
-    decodeArguments(rows, args);
-
-    auto tracker = trackRowSize(group);
-    auto accumulator = initRawAccumulator(group);
-
-    if (hasWeight_) {
-      rows.applyToSelected([&](auto row) {
-        if (decodedValue_.isNullAt(row) || decodedWeight_.isNullAt(row)) {
-          return;
-        }
-
-        auto value = decodedValue_.valueAt<T>(row);
-        auto weight = decodedWeight_.valueAt<int64_t>(row);
-        checkWeight(weight);
-        accumulator->append(value, weight, allocator_, fixedRandomSeed_);
-      });
-    } else {
-      if (decodedValue_.mayHaveNulls()) {
-        rows.applyToSelected([&](auto row) {
-          if (decodedValue_.isNullAt(row)) {
-            return;
-          }
-
-          accumulator->append(decodedValue_.valueAt<T>(row));
-        });
-      } else {
-        rows.applyToSelected([&](auto row) {
-          accumulator->append(decodedValue_.valueAt<T>(row));
-        });
-      }
-    }
-  }
-
-  void addSingleGroupIntermediateResults(
-      char* group,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool /*mayPushdown*/) override {
-    addIntermediate<true>(group, rows, args);
-  }
-
- protected:
-  void initializeNewGroupsInternal(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    exec::Aggregate::setAllNulls(groups, indices);
-    for (auto i : indices) {
-      auto group = groups[i];
-      new (group + offset_)
-          KllSketchAccumulator<T>(allocator_, fixedRandomSeed_);
-    }
-  }
-
-  void destroyInternal(folly::Range<char**> groups) override {
-    for (auto group : groups) {
-      if (isInitialized(group)) {
-        value<KllSketchAccumulator<T>>(group)->~KllSketchAccumulator<T>();
-      }
-    }
-  }
-
- private:
-  template <typename VectorType, typename ExtractFunc>
-  void extract(
-      char** groups,
-      int32_t numGroups,
-      VectorType* result,
-      ExtractFunc extractFunction) {
-    VELOX_CHECK(result);
-    result->resize(numGroups);
+namespace {
 
-    uint64_t* rawNulls = nullptr;
-    if (result->mayHaveNulls()) {
-      BufferPtr& nulls = result->mutableNulls(result->size());
-      rawNulls = nulls->asMutable<uint64_t>();
-    }
+/// Presto accuracy policy: accuracy is a double in (0, 1] representing
+/// the error bound for the approximation.
+struct PrestoAccuracyPolicy {
+  static constexpr double kMissingNormalizedValue = -1;
+  static constexpr double kDefaultAccuracy = kMissingNormalizedValue;
 
-    for (auto i = 0; i < numGroups; ++i) {
-      char* group = groups[i];
-      auto accumulator = value<KllSketchAccumulator<T>>(group);
-      if (accumulator->getSketch().totalCount() == 0) {
-        result->setNull(i, true);
-      } else {
-        if (rawNulls) {
-          bits::clearBit(rawNulls, i);
-        }
-        extractFunction(accumulator->getSketch(), result, i);
-      }
-    }
+  static bool isDefaultAccuracy(double accuracy) {
+    return accuracy == kMissingNormalizedValue;
   }
 
-  void decodeArguments(
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args) {
-    size_t argIndex = 0;
-    decodedValue_.decode(*args[argIndex++], rows, true);
-    if (hasWeight_) {
-      decodedWeight_.decode(*args[argIndex++], rows, true);
-    }
-    checkSetPercentile(rows, *args[argIndex++]);
-    if (hasAccuracy_) {
-      decodedAccuracy_.decode(*args[argIndex++], rows, true);
-      checkSetAccuracy(rows);
+  template <typename T>
+  static void setOnAccumulator(
+      functions::aggregate::detail::KllSketchAccumulator<T>* accumulator,
+      double accuracy) {
+    if (accuracy != kMissingNormalizedValue) {
+      accumulator->setAccuracy(accuracy);
     }
-    VELOX_CHECK_EQ(argIndex, args.size());
   }
 
-  void checkSetPercentile(
+  static void checkSetAccuracy(
+      DecodedVector& decodedAccuracy,
       const SelectivityVector& rows,
-      const BaseVector& vec) {
-    DecodedVector decoded(vec, rows);
-
-    auto* base = decoded.base();
-    auto baseFirstRow = decoded.index(rows.begin());
-    if (!decoded.isConstantMapping()) {
-      rows.applyToSelected([&](vector_size_t row) {
-        VELOX_USER_CHECK(!decoded.isNullAt(row), "Percentile cannot be null");
-        auto baseRow = decoded.index(row);
-        VELOX_USER_CHECK(
-            base->equalValueAt(base, baseRow, baseFirstRow),
-            "Percentile argument must be constant for all input rows: {} vs. {}",
-            base->toString(baseRow),
-            base->toString(baseFirstRow));
-      });
-    }
-
-    bool isArray;
-    vector_size_t offset;
-    vector_size_t len;
-    if (base->typeKind() == TypeKind::DOUBLE) {
-      isArray = false;
-      offset = rows.begin();
-      len = 1;
-    } else if (base->typeKind() == TypeKind::ARRAY) {
-      isArray = true;
-      auto arrays = base->asUnchecked<ArrayVector>();
-      decoded.decode(*arrays->elements());
-      offset = arrays->offsetAt(baseFirstRow);
-      len = arrays->sizeAt(baseFirstRow);
-    } else {
-      VELOX_USER_FAIL(
-          "Incorrect type for percentile: {}", base->type()->toString());
-    }
-    checkSetPercentile(isArray, decoded, offset, len);
-  }
-
-  void checkSetPercentile(
-      bool isArray,
-      const DecodedVector& percentiles,
-      vector_size_t offset,
-      vector_size_t len) {
-    if (!percentiles_) {
-      VELOX_USER_CHECK_GT(len, 0, "Percentile cannot be empty");
-      percentiles_ = {
-          .values = std::vector<double>(len),
-          .isArray = isArray,
-      };
-      for (vector_size_t i = 0; i < len; ++i) {
-        VELOX_USER_CHECK(!percentiles.isNullAt(i), "Percentile cannot be null");
-        auto value = percentiles.valueAt<double>(offset + i);
-        VELOX_USER_CHECK_GE(value, 0, "Percentile must be between 0 and 1");
-        VELOX_USER_CHECK_LE(value, 1, "Percentile must be between 0 and 1");
-        percentiles_->values[i] = value;
-      }
-    } else {
-      VELOX_USER_CHECK_EQ(
-          isArray,
-          percentiles_->isArray,
-          "Percentile argument must be constant for all input rows");
-      VELOX_USER_CHECK_EQ(
-          len,
-          percentiles_->values.size(),
-          "Percentile argument must be constant for all input rows");
-      for (vector_size_t i = 0; i < len; ++i) {
-        VELOX_USER_CHECK_EQ(
-            percentiles.valueAt<double>(offset + i),
-            percentiles_->values[i],
-            "Percentile argument must be constant for all input rows");
-      }
-    }
-  }
-
-  void checkSetAccuracy(const SelectivityVector& rows) {
-    if (!hasAccuracy_) {
-      return;
-    }
-
-    if (decodedAccuracy_.isConstantMapping()) {
-      VELOX_USER_CHECK(
-          !decodedAccuracy_.isNullAt(0), "Accuracy cannot be null");
-      checkSetAccuracy(decodedAccuracy_.valueAt<double>(0));
+      double& accuracy) {
+    if (decodedAccuracy.isConstantMapping()) {
+      VELOX_USER_CHECK(!decodedAccuracy.isNullAt(0), "Accuracy cannot be null");
+      checkSetPrestoAccuracy(accuracy, decodedAccuracy.valueAt<double>(0));
     } else {
       rows.applyToSelected([&](auto row) {
         VELOX_USER_CHECK(
-            !decodedAccuracy_.isNullAt(row), "Accuracy cannot be null");
-        const auto accuracy = decodedAccuracy_.valueAt<double>(row);
-        if (accuracy_ == kMissingNormalizedValue) {
-          checkSetAccuracy(accuracy);
+            !decodedAccuracy.isNullAt(row), "Accuracy cannot be null");
+        const auto value = decodedAccuracy.valueAt<double>(row);
+        if (accuracy == kMissingNormalizedValue) {
+          checkSetPrestoAccuracy(accuracy, value);
         }
         VELOX_USER_CHECK_EQ(
+            value,
             accuracy,
-            accuracy_,
             "Accuracy argument must be constant for all input rows");
       });
     }
   }
 
-  void checkSetAccuracy(double accuracy) {
+  static void checkAndSetFromIntermediate(
+      double& accuracy,
+      double inputAccuracy) {
+    checkSetPrestoAccuracy(accuracy, inputAccuracy);
+  }
+
+ private:
+  static void checkSetPrestoAccuracy(double& accuracy, double inputAccuracy) {
     VELOX_USER_CHECK(
-        0 < accuracy && accuracy <= 1, "Accuracy must be between 0 and 1");
-    if (accuracy_ == kMissingNormalizedValue) {
-      accuracy_ = accuracy;
+        0 < inputAccuracy && inputAccuracy <= 1,
+        "Accuracy must be between 0 and 1");
+    if (accuracy == kMissingNormalizedValue) {
+      accuracy = inputAccuracy;
     } else {
       VELOX_USER_CHECK_EQ(
+          inputAccuracy,
           accuracy,
-          accuracy_,
           "Accuracy argument must be constant for all input rows");
     }
   }
-
-  KllSketchAccumulator<T>* initRawAccumulator(char* group) {
-    auto accumulator = value<KllSketchAccumulator<T>>(group);
-    if (accuracy_ != kMissingNormalizedValue) {
-      accumulator->setAccuracy(accuracy_);
-    }
-    return accumulator;
-  }
-
-  template <bool kSingleGroup>
-  void addIntermediate(
-      std::conditional_t<kSingleGroup, char*, char**> group,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args) {
-    if (validateIntermediateInputs_) {
-      addIntermediateImpl<kSingleGroup, true>(group, rows, args);
-    } else {
-      addIntermediateImpl<kSingleGroup, false>(group, rows, args);
-    }
-  }
-
-  struct Percentiles {
-    std::vector<double> values;
-    bool isArray;
-  };
-
-  static constexpr double kMissingNormalizedValue = -1;
-  const bool hasWeight_;
-  const bool hasAccuracy_;
-  const std::optional<uint32_t> fixedRandomSeed_;
-  std::optional<Percentiles> percentiles_;
-  double accuracy_{kMissingNormalizedValue};
-  DecodedVector decodedValue_;
-  DecodedVector decodedWeight_;
-  DecodedVector decodedAccuracy_;
-  DecodedVector decodedDigest_;
-
- private:
-  template <bool kSingleGroup, bool checkIntermediateInputs>
-  void addIntermediateImpl(
-      std::conditional_t<kSingleGroup, char*, char**> group,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args) {
-    VELOX_CHECK_EQ(args.size(), 1);
-    DecodedVector decoded(*args[0], rows);
-    auto rowVec = decoded.base()->as<RowVector>();
-    if constexpr (checkIntermediateInputs) {
-      VELOX_USER_CHECK(rowVec);
-      for (int i = kPercentiles; i <= kAccuracy; ++i) {
-        VELOX_USER_CHECK(rowVec->childAt(i)->isConstantEncoding());
-      }
-      for (int i = kK; i <= kMaxValue; ++i) {
-        VELOX_USER_CHECK(rowVec->childAt(i)->isFlatEncoding());
-      }
-      for (int i = kItems; i <= kLevels; ++i) {
-        VELOX_USER_CHECK(
-            rowVec->childAt(i)->encoding() == VectorEncoding::Simple::ARRAY);
-      }
-    } else {
-      VELOX_CHECK(rowVec);
-    }
-
-    const SelectivityVector* baseRows = &rows;
-    SelectivityVector innerRows{rowVec->size(), false};
-    if (!decoded.isIdentityMapping()) {
-      if (decoded.isConstantMapping()) {
-        innerRows.setValid(decoded.index(0), true);
-        innerRows.updateBounds();
-      } else {
-        velox::translateToInnerRows(
-            rows, decoded.indices(), decoded.nulls(&rows), innerRows);
-      }
-      baseRows = &innerRows;
-    }
-
-    DecodedVector percentiles(*rowVec->childAt(kPercentiles), *baseRows);
-    auto percentileIsArray =
-        rowVec->childAt(kPercentilesIsArray)->asUnchecked<SimpleVector<bool>>();
-    auto accuracy =
-        rowVec->childAt(kAccuracy)->asUnchecked<SimpleVector<double>>();
-    auto k = rowVec->childAt(kK)->asUnchecked<SimpleVector<int32_t>>();
-    auto n = rowVec->childAt(kN)->asUnchecked<SimpleVector<int64_t>>();
-    auto minValue = rowVec->childAt(kMinValue)->asUnchecked<SimpleVector<T>>();
-    auto maxValue = rowVec->childAt(kMaxValue)->asUnchecked<SimpleVector<T>>();
-    auto items = rowVec->childAt(kItems)->asUnchecked<ArrayVector>();
-    auto levels = rowVec->childAt(kLevels)->asUnchecked<ArrayVector>();
-
-    auto itemsElements = items->elements()->asFlatVector<T>();
-    auto levelElements = levels->elements()->asFlatVector<int32_t>();
-    if constexpr (checkIntermediateInputs) {
-      VELOX_USER_CHECK(itemsElements);
-      VELOX_USER_CHECK(levelElements);
-    } else {
-      VELOX_CHECK(itemsElements);
-      VELOX_CHECK(levelElements);
-    }
-    auto rawItems = itemsElements->rawValues();
-    auto rawLevels = levelElements->rawValues<uint32_t>();
-
-    KllSketchAccumulator<T>* accumulator = nullptr;
-    std::vector<KllView<T>> views;
-    if constexpr (kSingleGroup) {
-      views.reserve(rows.end());
-    }
-    rows.applyToSelected([&](auto row) {
-      if (decoded.isNullAt(row)) {
-        return;
-      }
-      int i = decoded.index(row);
-      if (percentileIsArray->isNullAt(i)) {
-        return;
-      }
-      if (!accumulator) {
-        int indexInBaseVector = percentiles.index(i);
-        auto percentilesBase = percentiles.base()->asUnchecked<ArrayVector>();
-        auto percentileBaseElements =
-            percentilesBase->elements()->asFlatVector<double>();
-        if constexpr (checkIntermediateInputs) {
-          VELOX_USER_CHECK(percentileBaseElements);
-          VELOX_USER_CHECK(!percentilesBase->isNullAt(indexInBaseVector));
-        }
-
-        bool isArray = percentileIsArray->valueAt(i);
-        DecodedVector decodedElements(*percentilesBase->elements());
-        checkSetPercentile(
-            isArray,
-            decodedElements,
-            percentilesBase->offsetAt(indexInBaseVector),
-            percentilesBase->sizeAt(indexInBaseVector));
-
-        if (!accuracy->isNullAt(i)) {
-          checkSetAccuracy(accuracy->valueAt(i));
-        }
-      }
-      if constexpr (kSingleGroup) {
-        if (!accumulator) {
-          accumulator = initRawAccumulator(group);
-        }
-      } else {
-        accumulator = initRawAccumulator(group[row]);
-      }
-
-      if constexpr (checkIntermediateInputs) {
-        VELOX_USER_CHECK(
-            !(k->isNullAt(i) || n->isNullAt(i) || minValue->isNullAt(i) ||
-              maxValue->isNullAt(i) || items->isNullAt(i) ||
-              levels->isNullAt(i)));
-      }
-      KllView<T> v{
-          .k = static_cast<uint32_t>(k->valueAt(i)),
-          .n = static_cast<size_t>(n->valueAt(i)),
-          .minValue = minValue->valueAt(i),
-          .maxValue = maxValue->valueAt(i),
-          .items =
-              {rawItems + items->offsetAt(i),
-               static_cast<size_t>(items->sizeAt(i))},
-          .levels =
-              {rawLevels + levels->offsetAt(i),
-               static_cast<size_t>(levels->sizeAt(i))},
-      };
-      if constexpr (kSingleGroup) {
-        views.push_back(v);
-      } else {
-        auto tracker = trackRowSize(group[row]);
-        accumulator->append(v);
-      }
-    });
-    if constexpr (kSingleGroup) {
-      if (!views.empty()) {
-        auto tracker = trackRowSize(group);
-        accumulator->append(views);
-      }
-    }
-  }
 };
 
+template <typename T>
+using ApproxPercentileAggregate = ApproxPercentileAggregateBase<
+    T,
+    /*kHasWeight=*/true,
+    PrestoAccuracyPolicy>;
+
 bool validPercentileType(const Type& type) {
   if (type.kind() == TypeKind::DOUBLE) {
     return true;
@@ -855,40 +113,48 @@ void addSignatures(
   auto intermediateType = fmt::format(
       "row(array(double), boolean, double, integer, bigint, {0}, {0}, array({0}), array(integer))",
       inputType);
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .returnType(returnType)
-                           .intermediateType(intermediateType)
-                           .argumentType(inputType)
-                           .argumentType(percentileType)
-                           .build());
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .returnType(returnType)
-                           .intermediateType(intermediateType)
-                           .argumentType(inputType)
-                           .argumentType("bigint")
-                           .argumentType(percentileType)
-                           .build());
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .returnType(returnType)
-                           .intermediateType(intermediateType)
-                           .argumentType(inputType)
-                           .argumentType(percentileType)
-                           .argumentType("double")
-                           .build());
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .returnType(returnType)
-                           .intermediateType(intermediateType)
-                           .argumentType(inputType)
-                           .argumentType("bigint")
-                           .argumentType(percentileType)
-                           .argumentType("double")
-                           .build());
+  // (value, percentile)
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType(returnType)
+          .intermediateType(intermediateType)
+          .argumentType(inputType)
+          .argumentType(percentileType)
+          .build());
+  // (value, weight, percentile)
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType(returnType)
+          .intermediateType(intermediateType)
+          .argumentType(inputType)
+          .argumentType("bigint")
+          .argumentType(percentileType)
+          .build());
+  // (value, percentile, accuracy)
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType(returnType)
+          .intermediateType(intermediateType)
+          .argumentType(inputType)
+          .argumentType(percentileType)
+          .argumentType("double")
+          .build());
+  // (value, weight, percentile, accuracy)
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType(returnType)
+          .intermediateType(intermediateType)
+          .argumentType(inputType)
+          .argumentType("bigint")
+          .argumentType(percentileType)
+          .argumentType("double")
+          .build());
 }
 
 } // namespace
 
 void registerApproxPercentileAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
@@ -901,20 +167,20 @@ void registerApproxPercentileAggregate(
         fmt::format("array({})", inputType),
         signatures);
   }
-  auto name = prefix + kApproxPercentile;
   exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
+      [names](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
           const core::QueryConfig& config) -> std::unique_ptr<exec::Aggregate> {
-        auto isRawInput = exec::isRawInput(step);
-        auto hasWeight =
+        const std::string& name = names.front();
+        const auto isRawInput = exec::isRawInput(step);
+        const auto hasWeight =
             argTypes.size() >= 2 && argTypes[1]->kind() == TypeKind::BIGINT;
-        bool hasAccuracy = argTypes.size() == (hasWeight ? 4 : 3);
-        auto fixedRandomSeed =
+        const bool hasAccuracy = argTypes.size() == (hasWeight ? 4 : 3);
+        const auto fixedRandomSeed =
             config.debugAggregationApproxPercentileFixedRandomSeed();
 
         if (isRawInput) {
@@ -956,7 +222,7 @@ void registerApproxPercentileAggregate(
 
         TypePtr type;
         if (!isRawInput && exec::isPartialOutput(step)) {
-          type = argTypes[0]->asRow().childAt(kMinValue);
+          type = argTypes[0]->asRow().childAt(static_cast<int>(Idx::kMinValue));
         } else if (isRawInput) {
           type = argTypes[0];
         } else if (resultType->isArray()) {
diff --git a/velox/functions/prestosql/aggregates/ApproxPercentileAggregate.h b/velox/functions/prestosql/aggregates/ApproxPercentileAggregate.h
index cae808d1d95..c0538d646c6 100644
--- a/velox/functions/prestosql/aggregates/ApproxPercentileAggregate.h
+++ b/velox/functions/prestosql/aggregates/ApproxPercentileAggregate.h
@@ -17,23 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
-enum ApproxPercentileIntermediateTypeChildIndex {
-  kPercentiles = 0,
-  kPercentilesIsArray = 1,
-  kAccuracy = 2,
-  kK = 3,
-  kN = 4,
-  kMinValue = 5,
-  kMaxValue = 6,
-  kItems = 7,
-  kLevels = 8,
-};
-
 void registerApproxPercentileAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 
diff --git a/velox/functions/prestosql/aggregates/ApproxWinsorizedMeanAggregate.cpp b/velox/functions/prestosql/aggregates/ApproxWinsorizedMeanAggregate.cpp
new file mode 100644
index 00000000000..bc776f0cae5
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/ApproxWinsorizedMeanAggregate.cpp
@@ -0,0 +1,385 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <cstring>
+
+#include "velox/exec/Aggregate.h"
+#include "velox/functions/prestosql/aggregates/TDigestAccumulator.h"
+#include "velox/vector/FlatVector.h"
+
+using namespace facebook::velox::exec;
+
+namespace facebook::velox::aggregate::prestosql {
+
+namespace {
+
+constexpr double kMinCompression{10.0};
+constexpr double kMaxCompression{1'000.0};
+
+// The intermediate type is varbinary containing:
+//   [8 bytes: lowerQuantile double][8 bytes: upperQuantile double][TDigest
+//   bytes]
+// This ensures quantile bounds survive partial-to-final distributed
+// aggregation.
+constexpr size_t kQuantileBoundsHeaderSize{2 * sizeof(double)};
+
+// Velox aggregate function implementing approx_winsorized_mean using
+// TDigest-based quantile estimation. Builds a TDigest in a single pass,
+// then computes the Winsorized mean at extractValues time.
+//
+// The intermediate type is varbinary with a 16-byte header containing
+// the lower and upper quantile bounds, followed by the serialized TDigest.
+// This ensures quantile bounds survive partial-to-final distributed
+// aggregation.
+class ApproxWinsorizedMeanAggregate : public exec::Aggregate {
+ private:
+  // Whether the optional compression parameter was provided.
+  bool hasCompression_{false};
+  // Validated compression factor, shared across all rows. Zero means unset.
+  double compression_{0.0};
+  // Lower quantile bound for winsorization [0.0, 1.0].
+  double lowerQuantile_{0.0};
+  // Upper quantile bound for winsorization [0.0, 1.0].
+  double upperQuantile_{1.0};
+  // True once quantile bounds have been set from the first non-null row.
+  bool quantileBoundsSet_{false};
+  // Decoded input columns for raw input processing.
+  DecodedVector decodedValue_;
+  DecodedVector decodedLower_;
+  DecodedVector decodedUpper_;
+  DecodedVector decodedCompression_;
+  // Decoded intermediate input for partial-to-final aggregation.
+  DecodedVector decodedIntermediate_;
+
+ public:
+  ApproxWinsorizedMeanAggregate(const TypePtr& resultType, bool hasCompression)
+      : exec::Aggregate(resultType), hasCompression_{hasCompression} {}
+
+  int32_t accumulatorFixedWidthSize() const override {
+    return sizeof(TDigestAccumulator);
+  }
+
+  int32_t accumulatorAlignmentSize() const override {
+    return alignof(TDigestAccumulator);
+  }
+
+  bool isFixedSize() const override {
+    return false;
+  }
+
+  TDigestAccumulator* getAccumulator(char* group) {
+    return value<TDigestAccumulator>(group);
+  }
+
+  // Decodes raw input columns: args[0]=value, args[1]=lower, args[2]=upper,
+  // and optionally args[3]=compression.
+  void decodeArguments(
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args) {
+    decodedValue_.decode(*args[0], rows, true);
+    decodedLower_.decode(*args[1], rows, true);
+    decodedUpper_.decode(*args[2], rows, true);
+    if (hasCompression_) {
+      decodedCompression_.decode(*args[3], rows, true);
+    }
+  }
+
+  // Validates that quantile bounds are in [0,1] with lower <= upper, and
+  // ensures all rows use the same bounds. Throws on inconsistency.
+  void checkAndSetQuantileBounds(vector_size_t row) {
+    double lower = decodedLower_.valueAt<double>(row);
+    double upper = decodedUpper_.valueAt<double>(row);
+    VELOX_USER_CHECK(
+        !std::isnan(lower) && !std::isnan(upper),
+        "Quantile bounds must not be NaN.");
+    VELOX_USER_CHECK_GE(lower, 0.0, "Lower quantile bound must be >= 0");
+    VELOX_USER_CHECK_LE(lower, 1.0, "Lower quantile bound must be <= 1");
+    VELOX_USER_CHECK_GE(upper, 0.0, "Upper quantile bound must be >= 0");
+    VELOX_USER_CHECK_LE(upper, 1.0, "Upper quantile bound must be <= 1");
+    VELOX_USER_CHECK_LE(
+        lower,
+        upper,
+        "Lower quantile bound must be less than or equal to upper quantile bound");
+    if (!quantileBoundsSet_) {
+      lowerQuantile_ = lower;
+      upperQuantile_ = upper;
+      quantileBoundsSet_ = true;
+    } else if (lowerQuantile_ != lower || upperQuantile_ != upper) {
+      VELOX_USER_FAIL("Quantile bounds must be the same for all rows");
+    }
+  }
+
+  // Validates compression is positive, at most kMaxCompression, and consistent
+  // across rows. Clamps to kMinCompression and applies to the accumulator.
+  void checkAndSetCompression(
+      TDigestAccumulator* accumulator,
+      vector_size_t row) {
+    double compressionValue = decodedCompression_.valueAt<double>(row);
+    VELOX_USER_CHECK(
+        !std::isnan(compressionValue), "Compression factor must not be NaN.");
+    VELOX_USER_CHECK_GT(
+        compressionValue, 0, "Compression factor must be positive.");
+    VELOX_USER_CHECK_LE(
+        compressionValue,
+        kMaxCompression,
+        "Compression must be at most {}",
+        kMaxCompression);
+    compressionValue = std::max(compressionValue, kMinCompression);
+    if (compression_ == 0.0) {
+      compression_ = compressionValue;
+    } else if (compression_ != compressionValue) {
+      VELOX_USER_FAIL("Compression factor must be the same for all rows");
+    }
+    if (accumulator->compression == 0.0) {
+      accumulator->compression = compression_;
+    }
+    if (accumulator->digest.compression() != compression_) {
+      accumulator->digest.setCompression(compression_);
+    }
+  }
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodeArguments(rows, args);
+    std::vector<int16_t> positions;
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedValue_.isNullAt(row)) {
+        return;
+      }
+      double inputValue = decodedValue_.valueAt<double>(row);
+      if (std::isnan(inputValue)) {
+        VELOX_USER_FAIL("Cannot add NaN to approx_winsorized_mean");
+      }
+      checkAndSetQuantileBounds(row);
+      auto* accumulator = getAccumulator(groups[row]);
+      if (hasCompression_) {
+        checkAndSetCompression(accumulator, row);
+      }
+      accumulator->digest.add(positions, inputValue);
+    });
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodeArguments(rows, args);
+    auto* accumulator = getAccumulator(group);
+    std::vector<int16_t> positions;
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedValue_.isNullAt(row)) {
+        return;
+      }
+      double inputValue = decodedValue_.valueAt<double>(row);
+      if (std::isnan(inputValue)) {
+        VELOX_USER_FAIL("Cannot add NaN to approx_winsorized_mean");
+      }
+      checkAndSetQuantileBounds(row);
+      if (hasCompression_) {
+        checkAndSetCompression(accumulator, row);
+      }
+      accumulator->digest.add(positions, inputValue);
+    });
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    addIntermediate<false>(groups, rows, args);
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    addIntermediate<true>(group, rows, args);
+  }
+
+  template <bool kSingleGroup>
+  void addIntermediate(
+      std::conditional_t<kSingleGroup, char*, char**> group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args) {
+    decodedIntermediate_.decode(*args[0], rows);
+    std::vector<int16_t> positions;
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedIntermediate_.isNullAt(row)) {
+        return;
+      }
+
+      TDigestAccumulator* accumulator;
+      if constexpr (kSingleGroup) {
+        accumulator = getAccumulator(group);
+      } else {
+        accumulator = getAccumulator(group[row]);
+      }
+
+      auto serialized = decodedIntermediate_.valueAt<StringView>(row);
+      VELOX_CHECK_GE(
+          serialized.size(),
+          kQuantileBoundsHeaderSize,
+          "Intermediate data too small to contain quantile bounds header");
+      auto* data = serialized.data();
+
+      // Restore quantile bounds from the varbinary header.
+      if (!quantileBoundsSet_) {
+        memcpy(&lowerQuantile_, data, sizeof(double));
+        memcpy(&upperQuantile_, data + sizeof(double), sizeof(double));
+        quantileBoundsSet_ = true;
+      }
+
+      // Merge the TDigest bytes after the header.
+      accumulator->digest.mergeDeserialized(
+          positions, data + kQuantileBoundsHeaderSize);
+    });
+  }
+
+  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    if (numGroups == 0) {
+      (*result)->resize(0);
+      return;
+    }
+    auto flatResult = (*result)->asFlatVector<double>();
+    flatResult->resize(numGroups);
+    std::vector<int16_t> positions;
+    for (int32_t i = 0; i < numGroups; ++i) {
+      auto group = groups[i];
+      if (!group) {
+        flatResult->setNull(i, true);
+        continue;
+      }
+      auto* accumulator = getAccumulator(group);
+      if (!isInitialized(group) || accumulator->digest.size() == 0) {
+        flatResult->setNull(i, true);
+        continue;
+      }
+      accumulator->digest.compress(positions);
+      double winsorizedMeanValue =
+          accumulator->digest.winsorizedMean(lowerQuantile_, upperQuantile_);
+      if (std::isnan(winsorizedMeanValue)) {
+        flatResult->setNull(i, true);
+      } else {
+        flatResult->set(i, winsorizedMeanValue);
+      }
+    }
+  }
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    // Serialize as varbinary: [lowerQuantile][upperQuantile][TDigest bytes]
+    if (numGroups == 0) {
+      (*result)->resize(0);
+      return;
+    }
+    auto flatResult = (*result)->asFlatVector<StringView>();
+    flatResult->resize(numGroups);
+    std::vector<int16_t> positions;
+    for (int32_t i = 0; i < numGroups; ++i) {
+      auto group = groups[i];
+      if (!group) {
+        flatResult->setNull(i, true);
+        continue;
+      }
+      auto* accumulator = getAccumulator(group);
+      if (!isInitialized(group) || accumulator->digest.size() == 0) {
+        flatResult->setNull(i, true);
+        continue;
+      }
+
+      accumulator->digest.compress(positions);
+      auto digestSize = accumulator->digest.serializedByteSize();
+      int32_t totalSize =
+          static_cast<int32_t>(kQuantileBoundsHeaderSize + digestSize);
+
+      char* rawBuffer = flatResult->getRawStringBufferWithSpace(totalSize);
+      // Write quantile bounds header.
+      memcpy(rawBuffer, &lowerQuantile_, sizeof(double));
+      memcpy(rawBuffer + sizeof(double), &upperQuantile_, sizeof(double));
+      // Write TDigest after header.
+      accumulator->digest.serialize(rawBuffer + kQuantileBoundsHeaderSize);
+
+      flatResult->setNoCopy(i, StringView(rawBuffer, totalSize));
+    }
+  }
+
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    exec::Aggregate::setAllNulls(groups, indices);
+    for (auto i : indices) {
+      auto group = groups[i];
+      new (group + offset_) TDigestAccumulator(allocator_);
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
+    for (auto group : groups) {
+      if (isInitialized(group)) {
+        value<TDigestAccumulator>(group)->~TDigestAccumulator();
+      }
+    }
+  }
+};
+} // namespace
+
+void registerApproxWinsorizedMeanAggregate(
+    const std::vector<std::string>& names,
+    bool overwrite) {
+  std::vector<std::shared_ptr<AggregateFunctionSignature>> signatures;
+  // (value DOUBLE, lower DOUBLE, upper DOUBLE) -> DOUBLE
+  signatures.push_back(
+      AggregateFunctionSignatureBuilder()
+          .returnType("double")
+          .intermediateType("varbinary")
+          .argumentType("double")
+          .argumentType("double")
+          .argumentType("double")
+          .build());
+  // (value DOUBLE, lower DOUBLE, upper DOUBLE, compression DOUBLE) -> DOUBLE
+  signatures.push_back(
+      AggregateFunctionSignatureBuilder()
+          .returnType("double")
+          .intermediateType("varbinary")
+          .argumentType("double")
+          .argumentType("double")
+          .argumentType("double")
+          .argumentType("double")
+          .build());
+  exec::registerAggregateFunction(
+      names,
+      signatures,
+      [](core::AggregationNode::Step /*step*/,
+         const std::vector<TypePtr>& argTypes,
+         const TypePtr& resultType,
+         const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        bool hasCompression = argTypes.size() == 4;
+        return std::make_unique<ApproxWinsorizedMeanAggregate>(
+            resultType, hasCompression);
+      },
+      {},
+      false /*registerCompanionFunctions*/,
+      overwrite);
+}
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/ArbitraryAggregate.cpp b/velox/functions/prestosql/aggregates/ArbitraryAggregate.cpp
index fffee4f253c..bc748ba3eee 100644
--- a/velox/functions/prestosql/aggregates/ArbitraryAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/ArbitraryAggregate.cpp
@@ -19,7 +19,7 @@
 #include "velox/expression/FunctionSignature.h"
 #include "velox/functions/lib/aggregates/SimpleNumericAggregate.h"
 #include "velox/functions/lib/aggregates/SingleValueAccumulator.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
+#include "velox/functions/prestosql/types/IPAddressType.h"
 
 using namespace facebook::velox::functions::aggregate;
 
@@ -207,8 +207,13 @@ class NonNumericArbitrary : public exec::Aggregate {
           result->get()->copyRanges(currentSource->get(), copyRanges_);
         } else {
           if (copyRanges_.size() == 1 && copyRanges_[0].count == numGroups) {
-            *result = currentSource->get()->slice(
-                copyRanges_[0].sourceIndex, copyRanges_[0].count);
+            if (copyRanges_[0].sourceIndex == 0 &&
+                currentSource->get()->size() == numGroups) {
+              *result = *currentSource;
+            } else {
+              *result = currentSource->get()->slice(
+                  copyRanges_[0].sourceIndex, copyRanges_[0].count);
+            }
           } else {
             prepareGroupIndices(numGroups, result->get()->pool());
             applyToEachRange(
@@ -291,7 +296,9 @@ class NonNumericArbitrary : public exec::Aggregate {
       const std::vector<VectorPtr>& args,
       const folly::Range<const vector_size_t*>& groupBoundaries) override {
     VELOX_CHECK(clusteredInput_);
-    decoded_.decode(*args[0]);
+    // Since we're going through the process of decoding anyway, store the base
+    // so that downstream operators don't need to.
+    const auto base = decoded_.decodeAndGetBase(args[0]);
     vector_size_t groupStart = 0;
     auto forEachEmptyAccumulator = [&](auto func) {
       for (auto groupEnd : groupBoundaries) {
@@ -307,15 +314,15 @@ class NonNumericArbitrary : public exec::Aggregate {
     };
     if (rows.isAllSelected() && !decoded_.mayHaveNulls()) {
       forEachEmptyAccumulator([&](auto /*groupEnd*/, auto* accumulator) {
-        accumulator->vector = args[0];
-        accumulator->index = groupStart;
+        accumulator->vector = base;
+        accumulator->index = decoded_.index(groupStart);
       });
     } else {
       forEachEmptyAccumulator([&](auto groupEnd, auto* accumulator) {
         for (auto i = groupStart; i < groupEnd; ++i) {
           if (rows.isValid(i) && !decoded_.isNullAt(i)) {
-            accumulator->vector = args[0];
-            accumulator->index = i;
+            accumulator->vector = base;
+            accumulator->index = decoded_.index(i);
             break;
           }
         }
@@ -412,7 +419,7 @@ class NonNumericArbitrary : public exec::Aggregate {
 } // namespace
 
 void registerArbitraryAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
@@ -423,16 +430,16 @@ void registerArbitraryAggregate(
           .argumentType("T")
           .build()};
 
-  std::vector<std::string> names = {prefix + kArbitrary, prefix + kAnyValue};
   exec::registerAggregateFunction(
       names,
       std::move(signatures),
-      [name = names.front()](
+      [names](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& /*resultType*/,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
+        const std::string& name = names.front();
         VELOX_CHECK_LE(argTypes.size(), 1, "{} takes only one argument", name);
         auto inputType = argTypes[0];
         switch (inputType->kind()) {
@@ -447,7 +454,7 @@ void registerArbitraryAggregate(
           case TypeKind::BIGINT:
             return std::make_unique<ArbitraryAggregate<int64_t>>(inputType);
           case TypeKind::HUGEINT:
-            if (inputType->isLongDecimal()) {
+            if (inputType->isLongDecimal() || isIPAddressType(inputType)) {
               return std::make_unique<ArbitraryAggregate<int128_t>>(inputType);
             }
             VELOX_NYI();
diff --git a/velox/functions/prestosql/aggregates/ArbitraryAggregate.h b/velox/functions/prestosql/aggregates/ArbitraryAggregate.h
index a793a80db99..da31bee514e 100644
--- a/velox/functions/prestosql/aggregates/ArbitraryAggregate.h
+++ b/velox/functions/prestosql/aggregates/ArbitraryAggregate.h
@@ -17,17 +17,18 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 /// Register arbitrary aggregate function.
-/// @param prefix Prefix for the aggregate functions.
+/// @param names Names to use for the aggregate function.
 /// @param withCompanionFunctions Also register companion functions, defaults
 /// to true.
 /// @param overwrite Whether to overwrite existing entry in the function
 /// registry, defaults to true.
 void registerArbitraryAggregate(
-    const std::string& prefix = "",
+    const std::vector<std::string>& names,
     bool withCompanionFunctions = true,
     bool overwrite = true);
 
diff --git a/velox/functions/prestosql/aggregates/ArrayAggAggregate.cpp b/velox/functions/prestosql/aggregates/ArrayAggAggregate.cpp
index 97fa88a2563..cb35ed05c95 100644
--- a/velox/functions/prestosql/aggregates/ArrayAggAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/ArrayAggAggregate.cpp
@@ -18,7 +18,6 @@
 #include "velox/exec/ContainerRowSerde.h"
 #include "velox/expression/FunctionSignature.h"
 #include "velox/functions/lib/aggregates/ValueList.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 
 namespace facebook::velox::aggregate::prestosql {
 namespace {
@@ -128,49 +127,103 @@ class ArrayAggAggregate : public exec::Aggregate {
     if (clusteredInput_) {
       bool singleSource{true};
       VectorPtr* currentSource{nullptr};
-      std::vector<BaseVector::CopyRange> ranges;
+      bool contiguousElementsPerGroup = true;
+      // check if we can get a contiguous range for each group
+      std::vector<BaseVector::CopyRange> rangeMap;
+      rangeMap.resize(numGroups, {0, 0, 0});
       for (int32_t i = 0; i < numGroups; ++i) {
         auto* accumulator = value<ClusteredAccumulator>(groups[i]);
-        resultOffsets[i] = arrayOffset;
-        vector_size_t arraySize = 0;
+        if (accumulator->sources.empty()) {
+          continue;
+        }
         for (auto& source : accumulator->sources) {
-          if (currentSource && currentSource->get() != source.vector.get()) {
-            elements->copyRanges(currentSource->get(), ranges);
-            ranges.clear();
-          }
-          if (!currentSource || currentSource->get() != source.vector.get()) {
-            singleSource = currentSource == nullptr;
+          if (!currentSource) {
             currentSource = &source.vector;
-            ranges.push_back({source.offset, arrayOffset, source.size});
-          } else if (
-              ranges.back().sourceIndex + ranges.back().count ==
-              source.offset) {
-            ranges.back().count += source.size;
           } else {
-            VELOX_DCHECK_LT(
-                ranges.back().sourceIndex + ranges.back().count, source.offset);
-            ranges.push_back({source.offset, arrayOffset, source.size});
+            singleSource =
+                singleSource && (currentSource->get() == source.vector.get());
           }
-          arrayOffset += source.size;
-          arraySize += source.size;
         }
-        resultSizes[i] = arraySize;
-        if (arraySize == 0) {
-          vector->setNull(i, true);
+        if (singleSource) {
+          vector_size_t offset = accumulator->sources[0].offset;
+          vector_size_t size = accumulator->sources[0].size;
+          for (auto j = 1; j < accumulator->sources.size(); ++j) {
+            if (accumulator->sources[j].offset !=
+                accumulator->sources[j - 1].offset +
+                    accumulator->sources[j - 1].size) {
+              contiguousElementsPerGroup = false;
+              break;
+            } else {
+              size += accumulator->sources[j].size;
+            }
+          }
+          if (contiguousElementsPerGroup) {
+            rangeMap[i] = {offset, 0, size};
+          }
         } else {
-          clearNull(rawNulls, i);
+          contiguousElementsPerGroup = false;
+          break;
+        }
+      }
+      // fallback to copy if we can't get a contiguous range for each group
+      std::vector<BaseVector::CopyRange> ranges;
+      if (currentSource != nullptr && !contiguousElementsPerGroup) {
+        currentSource = nullptr;
+        for (int32_t i = 0; i < numGroups; ++i) {
+          auto* accumulator = value<ClusteredAccumulator>(groups[i]);
+          resultOffsets[i] = arrayOffset;
+          vector_size_t arraySize = 0;
+          for (auto& source : accumulator->sources) {
+            if (currentSource && currentSource->get() != source.vector.get()) {
+              elements->copyRanges(currentSource->get(), ranges);
+              ranges.clear();
+            }
+            if (!currentSource || currentSource->get() != source.vector.get()) {
+              currentSource = &source.vector;
+              ranges.push_back({source.offset, arrayOffset, source.size});
+            } else if (
+                ranges.back().sourceIndex + ranges.back().count ==
+                source.offset) {
+              ranges.back().count += source.size;
+            } else {
+              VELOX_DCHECK_LT(
+                  ranges.back().sourceIndex + ranges.back().count,
+                  source.offset);
+              ranges.push_back({source.offset, arrayOffset, source.size});
+            }
+            arrayOffset += source.size;
+            arraySize += source.size;
+          }
+          resultSizes[i] = arraySize;
+          if (arraySize == 0) {
+            vector->setNull(i, true);
+          } else {
+            clearNull(rawNulls, i);
+          }
         }
       }
       if (currentSource != nullptr) {
-        VELOX_DCHECK(!ranges.empty());
-        if (singleSource && ranges.size() == 1) {
-          VELOX_CHECK_GE(currentSource->get()->size(), numElements);
-          VELOX_CHECK_EQ(ranges[0].count, numElements);
-          elements = currentSource->get()->slice(
-              ranges[0].sourceIndex, ranges[0].count);
+        VELOX_DCHECK(contiguousElementsPerGroup || !ranges.empty());
+        if (singleSource && contiguousElementsPerGroup) {
+          elements = BaseVector::loadedVectorShared(*currentSource);
+          for (int32_t i = 0; i < numGroups; ++i) {
+            if (rangeMap[i].count > 0) {
+              resultOffsets[i] = rangeMap[i].sourceIndex;
+              resultSizes[i] = rangeMap[i].count;
+              clearNull(rawNulls, i);
+            } else {
+              vector->setNull(i, true);
+            }
+          }
         } else {
           elements->copyRanges(currentSource->get(), ranges);
         }
+      } else {
+        // Nothing to aggregate, mandatory behavior is to return nulls instead
+        // of empty array
+        for (int32_t i = 0; i < numGroups; ++i) {
+          vector->setNull(i, true);
+        }
       }
     } else {
       for (int32_t i = 0; i < numGroups; ++i) {
@@ -380,7 +433,7 @@ class ArrayAggAggregate : public exec::Aggregate {
 } // namespace
 
 void registerArrayAggAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
@@ -391,17 +444,16 @@ void registerArrayAggAggregate(
           .argumentType("E")
           .build()};
 
-  auto name = prefix + kArrayAgg;
   exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
+      [names](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
           const core::QueryConfig& config) -> std::unique_ptr<exec::Aggregate> {
         VELOX_CHECK_EQ(
-            argTypes.size(), 1, "{} takes at most one argument", name);
+            argTypes.size(), 1, "{} takes at most one argument", names.front());
         return std::make_unique<ArrayAggAggregate>(
             resultType, config.prestoArrayAggIgnoreNulls());
       },
@@ -410,7 +462,7 @@ void registerArrayAggAggregate(
 }
 
 void registerInternalArrayAggAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
@@ -421,18 +473,17 @@ void registerInternalArrayAggAggregate(
           .argumentType("E")
           .build()};
 
-  auto name = prefix + "$internal$array_agg";
   exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
+      [names](
           core::AggregationNode::Step /*step*/,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
         VELOX_CHECK_EQ(
-            argTypes.size(), 1, "{} takes at most one argument", name);
+            argTypes.size(), 1, "{} takes at most one argument", names.front());
         return std::make_unique<ArrayAggAggregate>(
             resultType, /*ignoreNulls*/ false);
       },
diff --git a/velox/functions/prestosql/aggregates/ArrayAggAggregate.h b/velox/functions/prestosql/aggregates/ArrayAggAggregate.h
index 1106021ff07..919b4f08079 100644
--- a/velox/functions/prestosql/aggregates/ArrayAggAggregate.h
+++ b/velox/functions/prestosql/aggregates/ArrayAggAggregate.h
@@ -17,22 +17,23 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 /// Register array_agg aggregate function.
-/// @param prefix Prefix for the aggregate function.
+/// @param names Names to use for the aggregate function.
 /// @param withCompanionFunctions Also register companion functions, defaults
 /// to true.
 /// @param overwrite Whether to overwrite existing entry in the function
 /// registry, defaults to true.
 void registerArrayAggAggregate(
-    const std::string& prefix = "",
+    const std::vector<std::string>& names,
     bool withCompanionFunctions = true,
     bool overwrite = true);
 
 void registerInternalArrayAggAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 
diff --git a/velox/functions/prestosql/aggregates/AverageAggregate.cpp b/velox/functions/prestosql/aggregates/AverageAggregate.cpp
index a18bab0784f..7825a21e5eb 100644
--- a/velox/functions/prestosql/aggregates/AverageAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/AverageAggregate.cpp
@@ -16,7 +16,6 @@
 
 #include "velox/functions/prestosql/aggregates/AverageAggregate.h"
 #include "velox/functions/lib/aggregates/AverageAggregateBase.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 
 using namespace facebook::velox::functions::aggregate;
 
@@ -31,52 +30,56 @@ namespace facebook::velox::aggregate::prestosql {
 ///     ALL INTs        |     DOUBLE          |    DOUBLE
 ///     DECIMAL         |     DECIMAL         |    DECIMAL
 void registerAverageAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
 
   for (const auto& inputType : {"smallint", "integer", "bigint", "double"}) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType("double")
-                             .intermediateType("row(double,bigint)")
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType("double")
+            .intermediateType("row(double,bigint)")
+            .argumentType(inputType)
+            .build());
   }
 
   // Interval input type in Presto has special case and returns INTERVAL, not
   // DOUBLE.
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .returnType("interval day to second")
-                           .intermediateType("row(double,bigint)")
-                           .argumentType("interval day to second")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType("interval day to second")
+          .intermediateType("row(double,bigint)")
+          .argumentType("interval day to second")
+          .build());
 
   // Real input type in Presto has special case and returns REAL, not DOUBLE.
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .returnType("real")
-                           .intermediateType("row(double,bigint)")
-                           .argumentType("real")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType("real")
+          .intermediateType("row(double,bigint)")
+          .argumentType("real")
+          .build());
 
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .integerVariable("a_precision")
-                           .integerVariable("a_scale")
-                           .argumentType("DECIMAL(a_precision, a_scale)")
-                           .intermediateType("varbinary")
-                           .returnType("DECIMAL(a_precision, a_scale)")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .integerVariable("a_precision")
+          .integerVariable("a_scale")
+          .argumentType("DECIMAL(a_precision, a_scale)")
+          .intermediateType("varbinary")
+          .returnType("DECIMAL(a_precision, a_scale)")
+          .build());
 
-  auto name = prefix + kAvg;
   exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
+      [names](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
+        const std::string& name = names.front();
         VELOX_CHECK_LE(
             argTypes.size(), 1, "{} takes at most one argument", name);
         auto inputType = argTypes[0];
@@ -156,7 +159,7 @@ void registerAverageAggregate(
           }
         }
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/AverageAggregate.h b/velox/functions/prestosql/aggregates/AverageAggregate.h
index ada6f347f45..a14408496c4 100644
--- a/velox/functions/prestosql/aggregates/AverageAggregate.h
+++ b/velox/functions/prestosql/aggregates/AverageAggregate.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerAverageAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/BitwiseAggregates.cpp b/velox/functions/prestosql/aggregates/BitwiseAggregates.cpp
index 1039ae39787..ded56070899 100644
--- a/velox/functions/prestosql/aggregates/BitwiseAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/BitwiseAggregates.cpp
@@ -16,7 +16,6 @@
 
 #include "velox/functions/prestosql/aggregates/BitwiseAggregates.h"
 #include "velox/functions/lib/aggregates/BitwiseAggregateBase.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 
 using namespace facebook::velox::functions::aggregate;
 
@@ -102,21 +101,22 @@ class BitwiseAndAggregate : public BitwiseAggregateBase<T> {
 
 } // namespace
 
-void registerBitwiseAggregates(
-    const std::string& prefix,
+void registerBitwiseAndAggregate(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool onlyPrestoSignatures,
     bool overwrite) {
-  registerBitwise<BitwiseOrAggregate>(
-      prefix + kBitwiseOr,
-      withCompanionFunctions,
-      onlyPrestoSignatures,
-      overwrite);
   registerBitwise<BitwiseAndAggregate>(
-      prefix + kBitwiseAnd,
-      withCompanionFunctions,
-      onlyPrestoSignatures,
-      overwrite);
+      names, true, withCompanionFunctions, onlyPrestoSignatures, overwrite);
+}
+
+void registerBitwiseOrAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool onlyPrestoSignatures,
+    bool overwrite) {
+  registerBitwise<BitwiseOrAggregate>(
+      names, true, withCompanionFunctions, onlyPrestoSignatures, overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/BitwiseAggregates.h b/velox/functions/prestosql/aggregates/BitwiseAggregates.h
index 00d1de989df..4e29890f231 100644
--- a/velox/functions/prestosql/aggregates/BitwiseAggregates.h
+++ b/velox/functions/prestosql/aggregates/BitwiseAggregates.h
@@ -17,11 +17,18 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
-void registerBitwiseAggregates(
-    const std::string& prefix,
+void registerBitwiseAndAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool onlyPrestoSignatures,
+    bool overwrite);
+
+void registerBitwiseOrAggregate(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool onlyPrestoSignatures,
     bool overwrite);
diff --git a/velox/functions/prestosql/aggregates/BitwiseXorAggregate.cpp b/velox/functions/prestosql/aggregates/BitwiseXorAggregate.cpp
index 120d92cb49f..e2117664cdf 100644
--- a/velox/functions/prestosql/aggregates/BitwiseXorAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/BitwiseXorAggregate.cpp
@@ -16,7 +16,6 @@
 
 #include "velox/functions/prestosql/aggregates/BitwiseXorAggregate.h"
 #include "velox/exec/SimpleAggregateAdapter.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 
 using namespace facebook::velox::exec;
 
@@ -70,34 +69,34 @@ class BitwiseXorAggregate {
 } // namespace
 
 void registerBitwiseXorAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool onlyPrestoSignatures,
     bool overwrite) {
-  const std::string name = prefix + kBitwiseXor;
-
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
   std::vector<std::string> typeList{"tinyint", "smallint", "integer", "bigint"};
   if (onlyPrestoSignatures) {
     typeList = {"bigint"};
   }
   for (const auto& inputType : typeList) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType(inputType)
-                             .intermediateType(inputType)
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType(inputType)
+            .intermediateType(inputType)
+            .argumentType(inputType)
+            .build());
   }
 
   exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
+      [names](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
+        const std::string& name = names.front();
         VELOX_USER_CHECK_EQ(argTypes.size(), 1, "{} takes one argument", name);
         auto inputType = argTypes[0];
         switch (inputType->kind()) {
diff --git a/velox/functions/prestosql/aggregates/BitwiseXorAggregate.h b/velox/functions/prestosql/aggregates/BitwiseXorAggregate.h
index d9a1b3fe82f..07d35b10c61 100644
--- a/velox/functions/prestosql/aggregates/BitwiseXorAggregate.h
+++ b/velox/functions/prestosql/aggregates/BitwiseXorAggregate.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerBitwiseXorAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool onlyPrestoSignatures,
     bool overwrite);
diff --git a/velox/functions/prestosql/aggregates/BoolAggregates.cpp b/velox/functions/prestosql/aggregates/BoolAggregates.cpp
index c9d690b7eb5..43b932ca16d 100644
--- a/velox/functions/prestosql/aggregates/BoolAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/BoolAggregates.cpp
@@ -18,7 +18,6 @@
 #include "velox/exec/Aggregate.h"
 #include "velox/expression/FunctionSignature.h"
 #include "velox/functions/lib/aggregates/SimpleNumericAggregate.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 
 using namespace facebook::velox::functions::aggregate;
 
@@ -179,8 +178,8 @@ class BoolOrAggregate final : public BoolAndOrAggregate {
 };
 
 template <class T>
-exec::AggregateRegistrationResult registerBool(
-    const std::string& name,
+std::vector<exec::AggregateRegistrationResult> registerBool(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   // TODO Fix signature to match Presto.
@@ -192,14 +191,15 @@ exec::AggregateRegistrationResult registerBool(
           .build()};
 
   return exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
+      [names](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& /*resultType*/,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
+        const std::string& name = names.front();
         VELOX_CHECK_EQ(argTypes.size(), 1, "{} takes only one argument", name);
         auto inputType = argTypes[0];
         VELOX_CHECK_EQ(
@@ -210,23 +210,25 @@ exec::AggregateRegistrationResult registerBool(
             inputType->kindName());
         return std::make_unique<T>();
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.ignoreDuplicates = true, .orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
 
 } // namespace
 
-void registerBoolAggregates(
-    const std::string& prefix,
+void registerBoolAndAggregate(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
-  registerBool<BoolAndAggregate>(
-      prefix + kBoolAnd, withCompanionFunctions, overwrite);
-  registerBool<BoolAndAggregate>(
-      prefix + kEvery, withCompanionFunctions, overwrite);
-  registerBool<BoolOrAggregate>(
-      prefix + kBoolOr, withCompanionFunctions, overwrite);
+  registerBool<BoolAndAggregate>(names, withCompanionFunctions, overwrite);
+}
+
+void registerBoolOrAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  registerBool<BoolOrAggregate>(names, withCompanionFunctions, overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/BoolAggregates.h b/velox/functions/prestosql/aggregates/BoolAggregates.h
index 0e19939aa8f..5fbe1a407be 100644
--- a/velox/functions/prestosql/aggregates/BoolAggregates.h
+++ b/velox/functions/prestosql/aggregates/BoolAggregates.h
@@ -17,11 +17,17 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
-void registerBoolAggregates(
-    const std::string& prefix,
+void registerBoolAndAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+void registerBoolOrAggregate(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/CMakeLists.txt b/velox/functions/prestosql/aggregates/CMakeLists.txt
index 5df97ab9ab2..951666b3276 100644
--- a/velox/functions/prestosql/aggregates/CMakeLists.txt
+++ b/velox/functions/prestosql/aggregates/CMakeLists.txt
@@ -17,6 +17,7 @@ velox_add_library(
   ApproxDistinctAggregate.cpp
   ApproxMostFrequentAggregate.cpp
   ApproxPercentileAggregate.cpp
+  ApproxWinsorizedMeanAggregate.cpp
   ArbitraryAggregate.cpp
   ArrayAggAggregate.cpp
   AverageAggregate.cpp
@@ -32,6 +33,7 @@ velox_add_library(
   EntropyAggregates.cpp
   GeometricMeanAggregate.cpp
   HistogramAggregate.cpp
+  KHyperLogLogAggregate.cpp
   MapAggAggregate.cpp
   MapUnionAggregate.cpp
   MapUnionSumAggregate.cpp
@@ -45,6 +47,7 @@ velox_add_library(
   PrestoHasher.cpp
   QDigestAggAggregate.cpp
   ReduceAgg.cpp
+  ReservoirSampleAggregate.cpp
   RegisterAggregateFunctions.cpp
   NoisyAvgGaussianAggregate.cpp
   NoisyCountIfGaussianAggregate.cpp
@@ -53,10 +56,67 @@ velox_add_library(
   NoisySumGaussianAggregate.cpp
   NoisyApproxSfmAggregate.cpp
   SetAggregates.cpp
+  SetDigestAggregate.cpp
   SumAggregate.cpp
   SumDataSizeForStatsAggregate.cpp
   TDigestAggregate.cpp
   VarianceAggregates.cpp
+  VectorSumAggregate.cpp
+  HEADERS
+  ApproxDistinctAggregates.h
+  ApproxMostFrequentAggregate.h
+  ApproxPercentileAggregate.h
+  ArbitraryAggregate.h
+  ArrayAggAggregate.h
+  AverageAggregate.h
+  BitwiseAggregates.h
+  BitwiseXorAggregate.h
+  BoolAggregates.h
+  CentralMomentsAggregates.h
+  ChecksumAggregate.h
+  ClassificationAggregation.h
+  CountAggregate.h
+  CountIfAggregate.h
+  CovarianceAggregates.h
+  EntropyAggregates.h
+  GeometricMeanAggregate.h
+  GeometryAggregate.h
+  HistogramAggregate.h
+  KHyperLogLogAggregate.h
+  MapAccumulator.h
+  MapAggAggregate.h
+  MapAggregateBase.h
+  MapUnionAggregate.h
+  MapUnionSumAggregate.h
+  MaxByAggregate.h
+  MaxSizeForStatsAggregate.h
+  MergeAggregate.h
+  MergeKHyperLogLogAggregate.h
+  MergeQDigestAggregate.h
+  MergeTDigestAggregate.h
+  MinByAggregate.h
+  MinMaxAggregates.h
+  MinMaxByAggregateBase.h
+  MultiMapAggAggregate.h
+  NoisyApproxSfmAggregate.h
+  NoisyAvgGaussianAggregate.h
+  NoisyCountGaussianAggregate.h
+  NoisyCountIfGaussianAggregate.h
+  NoisyHelperFunctionFactory.h
+  NoisySumGaussianAggregate.h
+  NumericHistogramAggregate.h
+  PrestoHasher.h
+  QDigestAggAggregate.h
+  ReduceAgg.h
+  RegisterAggregateFunctions.h
+  ReservoirSampleAggregate.h
+  SetAggregates.h
+  SetDigestAggregate.h
+  SumAggregate.h
+  SumDataSizeForStatsAggregate.h
+  TDigestAccumulator.h
+  VarianceAggregates.h
+  VectorSumAggregate.h
 )
 
 velox_link_libraries(
@@ -74,6 +134,12 @@ velox_link_libraries(
   Folly::folly
 )
 
+if(VELOX_ENABLE_GEO)
+  velox_sources(velox_aggregates PRIVATE GeometryAggregate.cpp)
+  velox_link_libraries(velox_aggregates velox_functions_geo)
+  velox_compile_definitions(velox_aggregates PRIVATE VELOX_ENABLE_GEO)
+endif()
+
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
 endif()
@@ -81,3 +147,9 @@ endif()
 if(${VELOX_ENABLE_BENCHMARKS})
   add_subdirectory(benchmarks)
 endif()
+
+velox_add_library(velox_aggregate_names INTERFACE HEADERS AggregateNames.h)
+
+velox_add_library(velox_hyperloglog_aggregate INTERFACE HEADERS HyperLogLogAggregate.h)
+
+velox_add_library(velox_sfm_sketch_aggregate INTERFACE HEADERS SfmSketchAggregate.h)
diff --git a/velox/functions/prestosql/aggregates/CentralMomentsAggregates.cpp b/velox/functions/prestosql/aggregates/CentralMomentsAggregates.cpp
index 530462335c0..75774949cb1 100644
--- a/velox/functions/prestosql/aggregates/CentralMomentsAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/CentralMomentsAggregates.cpp
@@ -17,7 +17,6 @@
 #include "velox/functions/prestosql/aggregates/CentralMomentsAggregates.h"
 #include "velox/exec/Aggregate.h"
 #include "velox/functions/lib/aggregates/CentralMomentsAggregatesBase.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 
 using namespace facebook::velox::functions::aggregate;
 
@@ -50,8 +49,8 @@ struct KurtosisResultAccessor {
 };
 
 template <typename TResultAccessor>
-exec::AggregateRegistrationResult registerCentralMoments(
-    const std::string& name,
+std::vector<exec::AggregateRegistrationResult> registerCentralMoments(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
@@ -67,14 +66,15 @@ exec::AggregateRegistrationResult registerCentralMoments(
   }
 
   return exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
+      [names](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
+        const std::string& name = names.front();
         VELOX_CHECK_LE(
             argTypes.size(), 1, "{} takes at most one argument", name);
         const auto& inputType = argTypes[0];
@@ -120,14 +120,20 @@ exec::AggregateRegistrationResult registerCentralMoments(
       overwrite);
 }
 
-void registerCentralMomentsAggregates(
-    const std::string& prefix,
+void registerKurtosisAggregate(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   registerCentralMoments<KurtosisResultAccessor>(
-      prefix + kKurtosis, withCompanionFunctions, overwrite);
+      names, withCompanionFunctions, overwrite);
+}
+
+void registerSkewnessAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
   registerCentralMoments<SkewnessResultAccessor>(
-      prefix + kSkewness, withCompanionFunctions, overwrite);
+      names, withCompanionFunctions, overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/CentralMomentsAggregates.h b/velox/functions/prestosql/aggregates/CentralMomentsAggregates.h
index f58f8af1b8f..72dbdbfd8a9 100644
--- a/velox/functions/prestosql/aggregates/CentralMomentsAggregates.h
+++ b/velox/functions/prestosql/aggregates/CentralMomentsAggregates.h
@@ -17,11 +17,17 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
-void registerCentralMomentsAggregates(
-    const std::string& prefix,
+void registerKurtosisAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+void registerSkewnessAggregate(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/ChecksumAggregate.cpp b/velox/functions/prestosql/aggregates/ChecksumAggregate.cpp
index 110e5f7a9a4..7a93a95c4d0 100644
--- a/velox/functions/prestosql/aggregates/ChecksumAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/ChecksumAggregate.cpp
@@ -14,12 +14,10 @@
  * limitations under the License.
  */
 
-#define XXH_INLINE_ALL
-#include <xxhash.h> // @manual=third-party//xxHash:xxhash
+#include "velox/common/base/XxHashInline.h"
 
 #include "velox/exec/Aggregate.h"
 #include "velox/expression/FunctionSignature.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/functions/prestosql/aggregates/ChecksumAggregate.h"
 #include "velox/functions/prestosql/aggregates/PrestoHasher.h"
 #include "velox/vector/FlatVector.h"
@@ -78,12 +76,12 @@ class ChecksumAggregate : public exec::Aggregate {
   }
 
   bool isNullOrNullArray(const TypePtr& type) {
-    if (type->isUnKnown()) {
+    if (type->isUnknown()) {
       return true;
     }
     // Only supports null array type for now.
     if (type->kind() == TypeKind::ARRAY) {
-      return type->asArray().elementType()->isUnKnown();
+      return type->asArray().elementType()->isUnknown();
     }
     return false;
   }
@@ -255,7 +253,7 @@ class ChecksumAggregate : public exec::Aggregate {
 } // namespace
 
 void registerChecksumAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
@@ -267,16 +265,16 @@ void registerChecksumAggregate(
           .build(),
   };
 
-  auto name = prefix + kChecksum;
   exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [&name](
+      [names](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& /*resultType*/,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
+        const std::string& name = names.front();
         VELOX_CHECK_EQ(argTypes.size(), 1, "{} takes one argument", name);
 
         if (exec::isPartialOutput(step)) {
@@ -285,7 +283,7 @@ void registerChecksumAggregate(
 
         return std::make_unique<ChecksumAggregate>(VARBINARY());
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/ChecksumAggregate.h b/velox/functions/prestosql/aggregates/ChecksumAggregate.h
index c1ef4936402..04e7df4ca30 100644
--- a/velox/functions/prestosql/aggregates/ChecksumAggregate.h
+++ b/velox/functions/prestosql/aggregates/ChecksumAggregate.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerChecksumAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/ClassificationAggregation.cpp b/velox/functions/prestosql/aggregates/ClassificationAggregation.cpp
index e6bd84710d2..31d5db3fc0f 100644
--- a/velox/functions/prestosql/aggregates/ClassificationAggregation.cpp
+++ b/velox/functions/prestosql/aggregates/ClassificationAggregation.cpp
@@ -17,11 +17,27 @@
 #include "velox/functions/prestosql/aggregates/ClassificationAggregation.h"
 #include "velox/common/base/IOUtils.h"
 #include "velox/exec/Aggregate.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/vector/FlatVector.h"
 
 namespace facebook::velox::aggregate::prestosql {
 namespace {
+const auto kSignatures =
+    std::vector<std::shared_ptr<exec::AggregateFunctionSignature>>{
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType("array(double)")
+            .intermediateType("varbinary")
+            .argumentType("bigint")
+            .argumentType("boolean")
+            .argumentType("double")
+            .build(),
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType("array(double)")
+            .intermediateType("varbinary")
+            .argumentType("bigint")
+            .argumentType("boolean")
+            .argumentType("double")
+            .argumentType("double")
+            .build()};
 
 enum class ClassificationType {
   kFallout = 0,
@@ -612,13 +628,13 @@ class ClassificationAggregation : public exec::Aggregate {
 
 template <ClassificationType T>
 void registerAggregateFunctionImpl(
-    const std::string& name,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite,
     const std::vector<std::shared_ptr<exec::AggregateFunctionSignature>>&
         signatures) {
   exec::registerAggregateFunction(
-      name,
+      names,
       signatures,
       [](core::AggregationNode::Step,
          const std::vector<TypePtr>& args,
@@ -637,52 +653,44 @@ void registerAggregateFunctionImpl(
 }
 } // namespace
 
-void registerClassificationFunctions(
-    const std::string& prefix,
+void registerFalloutAggregation(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
-  const auto signatures =
-      std::vector<std::shared_ptr<exec::AggregateFunctionSignature>>{
-          exec::AggregateFunctionSignatureBuilder()
-              .returnType("array(double)")
-              .intermediateType("varbinary")
-              .argumentType("bigint")
-              .argumentType("boolean")
-              .argumentType("double")
-              .build(),
-          exec::AggregateFunctionSignatureBuilder()
-              .returnType("array(double)")
-              .intermediateType("varbinary")
-              .argumentType("bigint")
-              .argumentType("boolean")
-              .argumentType("double")
-              .argumentType("double")
-              .build()};
   registerAggregateFunctionImpl<ClassificationType::kFallout>(
-      prefix + kClassificationFallout,
-      withCompanionFunctions,
-      overwrite,
-      signatures);
+      names, withCompanionFunctions, overwrite, kSignatures);
+}
+
+void registerPrecisionAggregation(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
   registerAggregateFunctionImpl<ClassificationType::kPrecision>(
-      prefix + kClassificationPrecision,
-      withCompanionFunctions,
-      overwrite,
-      signatures);
+      names, withCompanionFunctions, overwrite, kSignatures);
+}
+
+void registerRecallAggregation(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
   registerAggregateFunctionImpl<ClassificationType::kRecall>(
-      prefix + kClassificationRecall,
-      withCompanionFunctions,
-      overwrite,
-      signatures);
+      names, withCompanionFunctions, overwrite, kSignatures);
+}
+
+void registerMissRateAggregation(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
   registerAggregateFunctionImpl<ClassificationType::kMissRate>(
-      prefix + kClassificationMissRate,
-      withCompanionFunctions,
-      overwrite,
-      signatures);
+      names, withCompanionFunctions, overwrite, kSignatures);
+}
+
+void registerThresholdAggregation(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
   registerAggregateFunctionImpl<ClassificationType::kThresholds>(
-      prefix + kClassificationThreshold,
-      withCompanionFunctions,
-      overwrite,
-      signatures);
+      names, withCompanionFunctions, overwrite, kSignatures);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/ClassificationAggregation.h b/velox/functions/prestosql/aggregates/ClassificationAggregation.h
index 3e6f3f5295d..765edbc56e7 100644
--- a/velox/functions/prestosql/aggregates/ClassificationAggregation.h
+++ b/velox/functions/prestosql/aggregates/ClassificationAggregation.h
@@ -17,11 +17,32 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
-void registerClassificationFunctions(
-    const std::string& prefix,
+void registerFalloutAggregation(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+void registerPrecisionAggregation(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+void registerRecallAggregation(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+void registerMissRateAggregation(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+void registerThresholdAggregation(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/CountAggregate.cpp b/velox/functions/prestosql/aggregates/CountAggregate.cpp
index a92d6cfcf26..93d9a250b27 100644
--- a/velox/functions/prestosql/aggregates/CountAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/CountAggregate.cpp
@@ -17,7 +17,6 @@
 #include "velox/common/base/Exceptions.h"
 #include "velox/expression/FunctionSignature.h"
 #include "velox/functions/lib/aggregates/SumAggregateBase.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 
 using namespace facebook::velox::functions::aggregate;
 
@@ -153,7 +152,7 @@ class CountAggregate : public SimpleNumericAggregate<bool, int64_t, int64_t> {
 } // namespace
 
 void registerCountAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
@@ -169,21 +168,20 @@ void registerCountAggregate(
           .build(),
   };
 
-  auto name = prefix + kCount;
   exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
+      [names](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& /*resultType*/,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
         VELOX_CHECK_LE(
-            argTypes.size(), 1, "{} takes at most one argument", name);
+            argTypes.size(), 1, "{} takes at most one argument", names.front());
         return std::make_unique<CountAggregate>();
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/CountAggregate.h b/velox/functions/prestosql/aggregates/CountAggregate.h
index 5c5a9a85dd2..1a59cdae546 100644
--- a/velox/functions/prestosql/aggregates/CountAggregate.h
+++ b/velox/functions/prestosql/aggregates/CountAggregate.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerCountAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/CountIfAggregate.cpp b/velox/functions/prestosql/aggregates/CountIfAggregate.cpp
index 1b1fc394451..eaec59b3946 100644
--- a/velox/functions/prestosql/aggregates/CountIfAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/CountIfAggregate.cpp
@@ -17,7 +17,6 @@
 #include "velox/functions/prestosql/aggregates/CountIfAggregate.h"
 #include "velox/exec/Aggregate.h"
 #include "velox/expression/FunctionSignature.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/vector/DecodedVector.h"
 #include "velox/vector/FlatVector.h"
 #include "velox/vector/SimpleVector.h"
@@ -173,7 +172,7 @@ class CountIfAggregate : public exec::Aggregate {
 } // namespace
 
 void registerCountIfAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
@@ -184,16 +183,16 @@ void registerCountIfAggregate(
           .build(),
   };
 
-  auto name = prefix + kCountIf;
   exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
+      [names](
           core::AggregationNode::Step step,
           std::vector<TypePtr> argTypes,
           const TypePtr& /*resultType*/,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
+        const std::string& name = names.front();
         VELOX_CHECK_EQ(argTypes.size(), 1, "{} takes one argument", name);
 
         auto isPartial = exec::isRawInput(step);
@@ -207,7 +206,7 @@ void registerCountIfAggregate(
 
         return std::make_unique<CountIfAggregate>();
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/CountIfAggregate.h b/velox/functions/prestosql/aggregates/CountIfAggregate.h
index 04412bc1edb..bb20b81d57e 100644
--- a/velox/functions/prestosql/aggregates/CountIfAggregate.h
+++ b/velox/functions/prestosql/aggregates/CountIfAggregate.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerCountIfAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/CovarianceAggregates.cpp b/velox/functions/prestosql/aggregates/CovarianceAggregates.cpp
index c40a30e439f..e4921bca0ed 100644
--- a/velox/functions/prestosql/aggregates/CovarianceAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/CovarianceAggregates.cpp
@@ -17,7 +17,6 @@
 #include "velox/exec/Aggregate.h"
 #include "velox/expression/FunctionSignature.h"
 #include "velox/functions/lib/aggregates/CovarianceAggregatesBase.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/vector/DecodedVector.h"
 #include "velox/vector/FlatVector.h"
 
@@ -243,8 +242,8 @@ template <
     typename TIntermediateInput,
     typename TIntermediateResult,
     typename TResultAccessor>
-exec::AggregateRegistrationResult registerCovariance(
-    const std::string& name,
+std::vector<exec::AggregateRegistrationResult> registerCovariance(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures = {
@@ -265,7 +264,7 @@ exec::AggregateRegistrationResult registerCovariance(
   };
 
   return exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
       [](core::AggregationNode::Step step,
          const std::vector<TypePtr>& argTypes,
@@ -302,81 +301,136 @@ exec::AggregateRegistrationResult registerCovariance(
 
 } // namespace
 
-void registerCovarianceAggregates(
-    const std::string& prefix,
+void registerCovarPopAggregate(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   registerCovariance<
       CovarAccumulator,
       CovarIntermediateInput,
       CovarIntermediateResult,
-      CovarPopResultAccessor>(
-      prefix + kCovarPop, withCompanionFunctions, overwrite);
+      CovarPopResultAccessor>(names, withCompanionFunctions, overwrite);
+}
+
+void registerCovarSampAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
   registerCovariance<
       CovarAccumulator,
       CovarIntermediateInput,
       CovarIntermediateResult,
-      CovarSampResultAccessor>(
-      prefix + kCovarSamp, withCompanionFunctions, overwrite);
+      CovarSampResultAccessor>(names, withCompanionFunctions, overwrite);
+}
+
+void registerCorrAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
   registerCovariance<
       CorrAccumulator,
       CorrIntermediateInput,
       CorrIntermediateResult,
-      CorrResultAccessor>(prefix + kCorr, withCompanionFunctions, overwrite);
+      CorrResultAccessor>(names, withCompanionFunctions, overwrite);
+}
+
+void registerRegrInterceptAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
   registerCovariance<
       RegrAccumulator,
       RegrIntermediateInput,
       RegrIntermediateResult,
-      RegrInterceptResultAccessor>(
-      prefix + kRegrIntercept, withCompanionFunctions, overwrite);
+      RegrInterceptResultAccessor>(names, withCompanionFunctions, overwrite);
+}
+
+void registerRegrSlopeAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
   registerCovariance<
       RegrAccumulator,
       RegrIntermediateInput,
       RegrIntermediateResult,
-      RegrSlopeResultAccessor>(
-      prefix + kRegrSlop, withCompanionFunctions, overwrite);
+      RegrSlopeResultAccessor>(names, withCompanionFunctions, overwrite);
+}
+
+void registerRegrCountAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
   registerCovariance<
       ExtendedRegrAccumulator,
       ExtendedRegrIntermediateInput,
       ExtendedRegrIntermediateResult,
-      RegrCountResultAccessor>(
-      prefix + kRegrCount, withCompanionFunctions, overwrite);
+      RegrCountResultAccessor>(names, withCompanionFunctions, overwrite);
+}
+
+void registerRegrAvgyAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
   registerCovariance<
       ExtendedRegrAccumulator,
       ExtendedRegrIntermediateInput,
       ExtendedRegrIntermediateResult,
-      RegrAvgyResultAccessor>(
-      prefix + kRegrAvgy, withCompanionFunctions, overwrite);
+      RegrAvgyResultAccessor>(names, withCompanionFunctions, overwrite);
+}
+
+void registerRegrAvgxAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
   registerCovariance<
       ExtendedRegrAccumulator,
       ExtendedRegrIntermediateInput,
       ExtendedRegrIntermediateResult,
-      RegrAvgxResultAccessor>(
-      prefix + kRegrAvgx, withCompanionFunctions, overwrite);
+      RegrAvgxResultAccessor>(names, withCompanionFunctions, overwrite);
+}
+
+void registerRegrSxyAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
   registerCovariance<
       ExtendedRegrAccumulator,
       ExtendedRegrIntermediateInput,
       ExtendedRegrIntermediateResult,
-      RegrSxyResultAccessor>(
-      prefix + kRegrSxy, withCompanionFunctions, overwrite);
+      RegrSxyResultAccessor>(names, withCompanionFunctions, overwrite);
+}
+
+void registerRegrSxxAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
   registerCovariance<
       ExtendedRegrAccumulator,
       ExtendedRegrIntermediateInput,
       ExtendedRegrIntermediateResult,
-      RegrSxxResultAccessor>(
-      prefix + kRegrSxx, withCompanionFunctions, overwrite);
+      RegrSxxResultAccessor>(names, withCompanionFunctions, overwrite);
+}
+
+void registerRegrSyyAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
   registerCovariance<
       ExtendedRegrAccumulator,
       ExtendedRegrIntermediateInput,
       ExtendedRegrIntermediateResult,
-      RegrSyyResultAccessor>(
-      prefix + kRegrSyy, withCompanionFunctions, overwrite);
+      RegrSyyResultAccessor>(names, withCompanionFunctions, overwrite);
+}
+
+void registerRegrR2Aggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
   registerCovariance<
       ExtendedRegrAccumulator,
       ExtendedRegrIntermediateInput,
       ExtendedRegrIntermediateResult,
-      RegrR2ResultAccessor>(
-      prefix + kRegrR2, withCompanionFunctions, overwrite);
+      RegrR2ResultAccessor>(names, withCompanionFunctions, overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/CovarianceAggregates.h b/velox/functions/prestosql/aggregates/CovarianceAggregates.h
index dbecb679600..56c7db620a4 100644
--- a/velox/functions/prestosql/aggregates/CovarianceAggregates.h
+++ b/velox/functions/prestosql/aggregates/CovarianceAggregates.h
@@ -17,11 +17,67 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
-void registerCovarianceAggregates(
-    const std::string& prefix,
+void registerCovarPopAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+void registerCovarSampAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+void registerCorrAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+void registerRegrInterceptAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+void registerRegrSlopeAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+void registerRegrCountAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+void registerRegrAvgyAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+void registerRegrAvgxAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+void registerRegrSxyAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+void registerRegrSxxAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+void registerRegrSyyAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+void registerRegrR2Aggregate(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/EntropyAggregates.cpp b/velox/functions/prestosql/aggregates/EntropyAggregates.cpp
index 3c1c5b877a1..e700cfe911d 100644
--- a/velox/functions/prestosql/aggregates/EntropyAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/EntropyAggregates.cpp
@@ -16,7 +16,6 @@
 #include "velox/functions/prestosql/aggregates/EntropyAggregates.h"
 #include "velox/exec/Aggregate.h"
 #include "velox/expression/FunctionSignature.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/vector/ComplexVector.h"
 #include "velox/vector/DecodedVector.h"
 #include "velox/vector/FlatVector.h"
@@ -342,29 +341,30 @@ void checkRowType(const TypePtr& type, const std::string& errorMessage) {
 } // namespace
 
 void registerEntropyAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
   std::vector<std::string> inputTypes = {"smallint", "integer", "bigint"};
   for (const auto& inputType : inputTypes) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType("double")
-                             .intermediateType("row(double,double)")
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType("double")
+            .intermediateType("row(double,double)")
+            .argumentType(inputType)
+            .build());
   }
 
-  auto name = prefix + kEntropy;
   exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
+      [names](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
+        const std::string& name = names.front();
         VELOX_CHECK_LE(
             argTypes.size(), 1, "{} takes at most one argument", name);
         const auto& inputType = argTypes[0];
diff --git a/velox/functions/prestosql/aggregates/EntropyAggregates.h b/velox/functions/prestosql/aggregates/EntropyAggregates.h
index 9496adfd631..4cbfa644909 100644
--- a/velox/functions/prestosql/aggregates/EntropyAggregates.h
+++ b/velox/functions/prestosql/aggregates/EntropyAggregates.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerEntropyAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/GeometricMeanAggregate.cpp b/velox/functions/prestosql/aggregates/GeometricMeanAggregate.cpp
index 05a1f75db97..322691d4510 100644
--- a/velox/functions/prestosql/aggregates/GeometricMeanAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/GeometricMeanAggregate.cpp
@@ -17,7 +17,6 @@
 #include "velox/functions/prestosql/aggregates/GeometricMeanAggregate.h"
 #include <cmath>
 #include "velox/exec/SimpleAggregateAdapter.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 
 using namespace facebook::velox::exec;
 
@@ -30,9 +29,8 @@ class GeometricMeanAggregate {
  public:
   using InputType = Row<TInput>;
 
-  using IntermediateType =
-      Row</*logSum*/ double,
-          /*count*/ int64_t>;
+  using IntermediateType = Row</*logSum*/ double,
+                               /*count*/ int64_t>;
 
   using OutputType = TResult;
 
@@ -86,37 +84,38 @@ class GeometricMeanAggregate {
 } // namespace
 
 void registerGeometricMeanAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
-  const std::string name = prefix + kGeometricMean;
-
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
 
   for (const auto& inputType : {"bigint", "double"}) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType("double")
-                             .intermediateType("row(double,bigint)")
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType("double")
+            .intermediateType("row(double,bigint)")
+            .argumentType(inputType)
+            .build());
   }
 
   // Register for real input type.
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .returnType("real")
-                           .intermediateType("row(double,bigint)")
-                           .argumentType("real")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType("real")
+          .intermediateType("row(double,bigint)")
+          .argumentType("real")
+          .build());
 
   exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
+      [names](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
+        const std::string& name = names.front();
         VELOX_USER_CHECK_EQ(argTypes.size(), 1, "{} takes one argument", name);
         auto inputType = argTypes[0];
 
@@ -140,7 +139,7 @@ void registerGeometricMeanAggregate(
                 inputType->toString());
         }
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/GeometricMeanAggregate.h b/velox/functions/prestosql/aggregates/GeometricMeanAggregate.h
index 09eb664d366..2f4866e4d36 100644
--- a/velox/functions/prestosql/aggregates/GeometricMeanAggregate.h
+++ b/velox/functions/prestosql/aggregates/GeometricMeanAggregate.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerGeometricMeanAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/GeometryAggregate.cpp b/velox/functions/prestosql/aggregates/GeometryAggregate.cpp
new file mode 100644
index 00000000000..11b442507d4
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/GeometryAggregate.cpp
@@ -0,0 +1,350 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/aggregates/GeometryAggregate.h"
+
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/geom/Geometry.h>
+
+#include "velox/common/geospatial/GeometrySerde.h"
+#include "velox/exec/Aggregate.h"
+#include "velox/exec/SimpleAggregateAdapter.h"
+#include "velox/exec/Strings.h"
+#include "velox/expression/FunctionSignature.h"
+#include "velox/functions/prestosql/types/GeometryRegistration.h"
+#include "velox/functions/prestosql/types/GeometryType.h"
+
+using namespace facebook::velox::exec;
+using facebook::velox::common::geospatial::GeometryDeserializer;
+
+namespace facebook::velox::aggregate::prestosql {
+
+namespace {
+
+// Take the convex hull of all the geometries.
+// This is more efficient than taking the pairwise convex hull.
+template <typename T>
+class ConvexHullAggregate {
+ public:
+  using InputType = Row<Geometry>;
+  using IntermediateType = Geometry;
+  using OutputType = Geometry;
+
+  struct AccumulatorType {
+    static constexpr bool use_external_memory_ = true;
+    static constexpr bool is_fixed_size_ = false;
+    static constexpr bool is_aligned_ = true;
+
+    ConvexHullAggregate* fn_;
+    std::vector<StringView> geometryData_{};
+    Strings strings_;
+
+    AccumulatorType() = delete;
+
+    explicit AccumulatorType(
+        HashStringAllocator* /*allocator*/,
+        ConvexHullAggregate* /*fn*/) {}
+
+    void destroy(HashStringAllocator* allocator) {
+      geometryData_.clear();
+      geometryData_.shrink_to_fit();
+      strings_.free(*allocator);
+    }
+
+    void addInput(
+        HashStringAllocator* allocator,
+        exec::arg_type<Geometry> value) {
+      addGeometry(allocator, value);
+    }
+
+    void combine(
+        HashStringAllocator* allocator,
+        arg_type<IntermediateType> other) {
+      addGeometry(allocator, other);
+    }
+
+    // If there are geometries, write to `out` and return true.
+    // Otherwise, return false.
+    bool writeGeometry(exec::out_type<OutputType>& out) {
+      std::unique_ptr<geos::geom::Geometry> hull = makeHull();
+      if (hull != nullptr) {
+        common::geospatial::GeometrySerializer::serialize(*hull, out);
+      }
+      return hull != nullptr;
+    }
+
+    bool writeFinalResult(exec::out_type<OutputType>& out) {
+      return writeGeometry(out);
+    }
+
+    bool writeIntermediateResult(out_type<IntermediateType>& out) {
+      return writeGeometry(out);
+    }
+
+   private:
+    void addGeometry(
+        HashStringAllocator* allocator,
+        exec::arg_type<Geometry> value) {
+      // Must add empty geometries here, because geometryData_.empty() will
+      // tell us if there has been at least one input (and thus will have
+      // non-null output).
+      if (!value.isInline()) {
+        value = strings_.append(value, *allocator);
+      }
+      geometryData_.push_back(value);
+    }
+
+    // Create a convex hull from all the stored coordinates.
+    // Returns a nullptr if there are no geometries to make a hull from.
+    std::unique_ptr<geos::geom::Geometry> makeHull() {
+      // No geometryData_ means no inputs, so return NULL
+      if (geometryData_.empty()) {
+        return nullptr;
+      }
+
+      std::vector<std::unique_ptr<geos::geom::Geometry>> geometries;
+      geometries.reserve(geometryData_.size());
+      for (const auto& data : geometryData_) {
+        auto geom = common::geospatial::GeometryDeserializer::deserialize(data);
+        VELOX_DCHECK_NOT_NULL(geom);
+        if (!geom->isEmpty()) {
+          geometries.push_back(std::move(geom));
+        }
+      }
+      if (geometries.empty()) {
+        return GeometryDeserializer::getGeometryFactory()
+            ->createEmptyGeometry();
+      }
+
+      // Calculate total number of points for efficient memory allocation
+      size_t totalPoints = 0;
+      for (const auto& geom : geometries) {
+        totalPoints += geom->getNumPoints();
+      }
+
+      // Create a single CoordinateSequence from all coordinates
+      auto coords =
+          std::make_unique<geos::geom::CoordinateArraySequence>(totalPoints, 2);
+      size_t index = 0;
+
+      // Add all coordinates from coordinate sequences
+      for (const auto& geom : geometries) {
+        auto coordSeq = geom->getCoordinates();
+        for (size_t i = 0; i < coordSeq->size(); ++i) {
+          VELOX_DCHECK_GT(coords->size(), index);
+          coords->setAt(coordSeq->getAt(i), index++);
+        }
+      }
+
+      auto points = std::unique_ptr<geos::geom::MultiPoint>(
+          GeometryDeserializer::getGeometryFactory()->createMultiPoint(
+              *coords));
+      return points->convexHull();
+    }
+  };
+};
+
+void registerConvexHullAggregate(
+    const std::vector<std::string>& names,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
+
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType("geometry")
+          .intermediateType("geometry")
+          .argumentType("geometry")
+          .build());
+
+  exec::registerAggregateFunction(
+      names,
+      signatures,
+      [names](
+          core::AggregationNode::Step step,
+          const std::vector<TypePtr>& argTypes,
+          const TypePtr& resultType,
+          const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        const std::string& name = names.front();
+        VELOX_CHECK_LE(
+            argTypes.size(), 1, "{} takes at most one argument", name);
+        const auto& inputType = argTypes[0];
+        if (!isGeometryType(inputType)) {
+          VELOX_FAIL(
+              "Unexpected input type for {} aggregation {}",
+              name,
+              inputType->kindName());
+        }
+        return std::make_unique<
+            exec::SimpleAggregateAdapter<ConvexHullAggregate<Geometry>>>(
+            step, argTypes, resultType);
+      },
+      true /*registerCompanionFunctions*/,
+      overwrite);
+}
+
+template <typename T>
+class GeometryUnionAggregate {
+ public:
+  using InputType = Row<Geometry>;
+  using IntermediateType = Geometry;
+  using OutputType = Geometry;
+
+  struct AccumulatorType {
+    static constexpr bool use_external_memory_ = true;
+    static constexpr bool is_fixed_size_ = false;
+    static constexpr bool is_aligned_ = true;
+
+    GeometryUnionAggregate* fn_;
+    std::vector<StringView> geometryData_{};
+    Strings strings_;
+
+    AccumulatorType() = delete;
+
+    explicit AccumulatorType(
+        HashStringAllocator* /*allocator*/,
+        GeometryUnionAggregate* /*fn*/) {}
+
+    void destroy(HashStringAllocator* allocator) {
+      geometryData_.clear();
+      geometryData_.shrink_to_fit();
+      strings_.free(*allocator);
+    }
+
+    void addInput(
+        HashStringAllocator* allocator,
+        exec::arg_type<Geometry> value) {
+      addGeometry(allocator, value);
+    }
+
+    void combine(
+        HashStringAllocator* allocator,
+        arg_type<IntermediateType> other) {
+      addGeometry(allocator, other);
+    }
+
+    // If there are geometries, write to `out` and return true.
+    // Otherwise, return false.
+    bool writeGeometry(exec::out_type<OutputType>& out) {
+      std::unique_ptr<geos::geom::Geometry> geomUnion = makeUnion();
+      if (geomUnion != nullptr) {
+        common::geospatial::GeometrySerializer::serialize(*geomUnion, out);
+      }
+      return geomUnion != nullptr;
+    }
+
+    bool writeFinalResult(exec::out_type<OutputType>& out) {
+      return writeGeometry(out);
+    }
+
+    bool writeIntermediateResult(out_type<IntermediateType>& out) {
+      return writeGeometry(out);
+    }
+
+   private:
+    void addGeometry(
+        HashStringAllocator* allocator,
+        exec::arg_type<Geometry> value) {
+      // Must add empty geometries here, because geometryData_.empty() will
+      // tell us if there has been at least one input (and thus will have
+      // non-null output).
+      if (!value.isInline()) {
+        value = strings_.append(value, *allocator);
+      }
+      geometryData_.push_back(value);
+    }
+
+    // Create the geometries union from all the stored coordinates.
+    // Returns a nullptr if there has been no input.
+    std::unique_ptr<geos::geom::Geometry> makeUnion() {
+      // No geometryData_ means no inputs, so return NULL
+      if (geometryData_.empty()) {
+        return nullptr;
+      }
+
+      std::vector<std::unique_ptr<geos::geom::Geometry>> geometries;
+      geometries.reserve(geometryData_.size());
+      for (const auto& data : geometryData_) {
+        auto geom = common::geospatial::GeometryDeserializer::deserialize(data);
+        VELOX_DCHECK_NOT_NULL(geom);
+        if (!geom->isEmpty()) {
+          geometries.push_back(std::move(geom));
+        }
+      }
+      if (geometries.empty()) {
+        return GeometryDeserializer::getGeometryFactory()
+            ->createEmptyGeometry();
+      }
+
+      auto collection =
+          GeometryDeserializer::getGeometryFactory()->createGeometryCollection(
+              std::move(geometries));
+      return collection->Union();
+    }
+  };
+};
+
+void registerGeometryUnionAggregate(
+    const std::vector<std::string>& names,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
+
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType("geometry")
+          .intermediateType("geometry")
+          .argumentType("geometry")
+          .build());
+
+  exec::registerAggregateFunction(
+      names,
+      signatures,
+      [names](
+          core::AggregationNode::Step step,
+          const std::vector<TypePtr>& argTypes,
+          const TypePtr& resultType,
+          const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        const std::string& name = names.front();
+        VELOX_CHECK_LE(
+            argTypes.size(), 1, "{} takes at most one argument", name);
+        const auto& inputType = argTypes[0];
+        if (!isGeometryType(inputType)) {
+          VELOX_FAIL(
+              "Unexpected input type for {} aggregation {}",
+              name,
+              inputType->kindName());
+        }
+        return std::make_unique<
+            exec::SimpleAggregateAdapter<GeometryUnionAggregate<Geometry>>>(
+            step, argTypes, resultType);
+      },
+      true /*registerCompanionFunctions*/,
+      overwrite);
+}
+
+} // namespace
+
+void registerGeometryAggregate(
+    const std::vector<std::string>& convexHullNames,
+    const std::vector<std::string>& geometryUnionNames,
+    bool overwrite) {
+  registerGeometryType();
+  registerConvexHullAggregate(convexHullNames, overwrite);
+  registerGeometryUnionAggregate(geometryUnionNames, overwrite);
+}
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/GeometryAggregate.h b/velox/functions/prestosql/aggregates/GeometryAggregate.h
new file mode 100644
index 00000000000..5f15f4e7102
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/GeometryAggregate.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace facebook::velox::aggregate::prestosql {
+
+void registerGeometryAggregate(
+    const std::vector<std::string>& convexHullNames,
+    const std::vector<std::string>& geometryUnionNames,
+    bool overwrite);
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/HistogramAggregate.cpp b/velox/functions/prestosql/aggregates/HistogramAggregate.cpp
index e73acd9b257..18d514b4c70 100644
--- a/velox/functions/prestosql/aggregates/HistogramAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/HistogramAggregate.cpp
@@ -20,7 +20,6 @@
 #include "velox/exec/AddressableNonNullValueList.h"
 #include "velox/exec/Aggregate.h"
 #include "velox/exec/Strings.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/functions/prestosql/aggregates/HistogramAggregate.h"
 #include "velox/vector/FlatVector.h"
 
@@ -564,7 +563,7 @@ std::unique_ptr<exec::Aggregate> createHistogramAggregateWithCustomCompare(
 } // namespace
 
 void registerHistogramAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures = {
@@ -576,16 +575,16 @@ void registerHistogramAggregate(
           .build(),
   };
 
-  auto name = prefix + kHistogram;
   exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
+      [names](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
+        const std::string& name = names.front();
         VELOX_CHECK_EQ(
             argTypes.size(), 1, "{}: unexpected number of arguments", name);
 
@@ -638,7 +637,7 @@ void registerHistogramAggregate(
                 inputType->toString());
         }
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/HistogramAggregate.h b/velox/functions/prestosql/aggregates/HistogramAggregate.h
index 4532e04da56..a1115120e03 100644
--- a/velox/functions/prestosql/aggregates/HistogramAggregate.h
+++ b/velox/functions/prestosql/aggregates/HistogramAggregate.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerHistogramAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/HyperLogLogAggregate.h b/velox/functions/prestosql/aggregates/HyperLogLogAggregate.h
index e3a697620b4..e4678667b57 100644
--- a/velox/functions/prestosql/aggregates/HyperLogLogAggregate.h
+++ b/velox/functions/prestosql/aggregates/HyperLogLogAggregate.h
@@ -15,178 +15,19 @@
  */
 #pragma once
 
-#define XXH_INLINE_ALL
-#include <xxhash.h> // @manual=third-party//xxHash:xxhash
+#include "velox/common/base/XxHashInline.h"
 
-#include "velox/common/hyperloglog/DenseHll.h"
 #include "velox/common/hyperloglog/HllUtils.h"
-#include "velox/common/hyperloglog/Murmur3Hash128.h"
 #include "velox/common/hyperloglog/SparseHll.h"
-#include "velox/common/memory/HashStringAllocator.h"
 #include "velox/exec/Aggregate.h"
+#include "velox/functions/lib/HllAccumulator.h"
 #include "velox/vector/DecodedVector.h"
 #include "velox/vector/FlatVector.h"
 
-using facebook::velox::common::hll::DenseHll;
 using facebook::velox::common::hll::SparseHll;
 
 namespace facebook::velox::aggregate::prestosql {
 
-template <typename T, bool HllAsFinalResult>
-inline uint64_t hashOne(T value) {
-  if constexpr (HllAsFinalResult) {
-    if constexpr (std::is_same_v<T, int64_t>) {
-      return common::hll::Murmur3Hash128::hash64ForLong(value, 0);
-    } else if constexpr (std::is_same_v<T, double>) {
-      return common::hll::Murmur3Hash128::hash64ForLong(
-          *reinterpret_cast<int64_t*>(&value), 0);
-    }
-    return common::hll::Murmur3Hash128::hash64(&value, sizeof(T), 0);
-  } else {
-    return XXH64(&value, sizeof(T), 0);
-  }
-}
-
-// Use timestamp.toMillis() to compute hash value.
-template <>
-inline uint64_t hashOne<Timestamp, false>(Timestamp value) {
-  return hashOne<int64_t, false>(value.toMillis());
-}
-
-template <>
-inline uint64_t hashOne<Timestamp, true>(Timestamp /*value*/) {
-  VELOX_UNREACHABLE("approx_set(timestamp) is not supported.");
-}
-
-template <>
-inline uint64_t hashOne<StringView, false>(StringView value) {
-  return XXH64(value.data(), value.size(), 0);
-}
-
-template <>
-inline uint64_t hashOne<StringView, true>(StringView value) {
-  return common::hll::Murmur3Hash128::hash64(value.data(), value.size(), 0);
-}
-
-template <typename T, bool HllAsFinalResult>
-struct HllAccumulator {
-  explicit HllAccumulator(HashStringAllocator* allocator)
-      : sparseHll_{allocator}, denseHll_{allocator} {}
-
-  void setIndexBitLength(int8_t indexBitLength) {
-    indexBitLength_ = indexBitLength;
-    sparseHll_.setSoftMemoryLimit(
-        DenseHll::estimateInMemorySize(indexBitLength_));
-  }
-
-  void append(T value) {
-    const auto hash = hashOne<T, HllAsFinalResult>(value);
-
-    if (isSparse_) {
-      if (sparseHll_.insertHash(hash)) {
-        toDense();
-      }
-    } else {
-      denseHll_.insertHash(hash);
-    }
-  }
-
-  int64_t cardinality() const {
-    return isSparse_ ? sparseHll_.cardinality() : denseHll_.cardinality();
-  }
-
-  void mergeWith(StringView serialized, HashStringAllocator* allocator) {
-    auto input = serialized.data();
-    if (SparseHll::canDeserialize(input)) {
-      if (isSparse_) {
-        sparseHll_.mergeWith(input);
-        if (indexBitLength_ < 0) {
-          setIndexBitLength(DenseHll::deserializeIndexBitLength(input));
-        }
-        if (sparseHll_.overLimit()) {
-          toDense();
-        }
-      } else {
-        SparseHll other{input, allocator};
-        other.toDense(denseHll_);
-      }
-    } else if (DenseHll::canDeserialize(input)) {
-      if (isSparse_) {
-        if (indexBitLength_ < 0) {
-          setIndexBitLength(DenseHll::deserializeIndexBitLength(input));
-        }
-        toDense();
-      }
-      denseHll_.mergeWith(input);
-    } else {
-      VELOX_USER_FAIL("Unexpected type of HLL");
-    }
-  }
-
-  int32_t serializedSize() {
-    return isSparse_ ? sparseHll_.serializedSize() : denseHll_.serializedSize();
-  }
-
-  void serialize(char* outputBuffer) {
-    return isSparse_ ? sparseHll_.serialize(indexBitLength_, outputBuffer)
-                     : denseHll_.serialize(outputBuffer);
-  }
-
- private:
-  void toDense() {
-    isSparse_ = false;
-    denseHll_.initialize(indexBitLength_);
-    sparseHll_.toDense(denseHll_);
-    sparseHll_.reset();
-  }
-
-  bool isSparse_{true};
-  int8_t indexBitLength_{-1};
-  SparseHll sparseHll_;
-  DenseHll denseHll_;
-};
-
-template <>
-struct HllAccumulator<bool, false> {
-  explicit HllAccumulator(HashStringAllocator* /*allocator*/) {}
-
-  void append(bool value) {
-    approxDistinctState_ |= (1 << value);
-  }
-
-  int64_t cardinality() const {
-    return (approxDistinctState_ & 1) + ((approxDistinctState_ & 2) >> 1);
-  }
-
-  void mergeWith(
-      StringView /*serialized*/,
-      HashStringAllocator* /*allocator*/) {
-    VELOX_UNREACHABLE(
-        "APPROX_DISTINCT<BOOLEAN> unsupported mergeWith(StringView, HashStringAllocator*)");
-  }
-
-  void mergeWith(int8_t data) {
-    approxDistinctState_ |= data;
-  }
-
-  int32_t serializedSize() const {
-    return sizeof(int8_t);
-  }
-
-  void serialize(char* /*outputBuffer*/) {
-    VELOX_UNREACHABLE("APPROX_DISTINCT<BOOLEAN> unsupported serialize(char*)");
-  }
-
-  void setIndexBitLength(int8_t /*indexBitLength*/) {}
-
-  int8_t getState() const {
-    return approxDistinctState_;
-  }
-
- private:
-  int8_t approxDistinctState_{0};
-};
-
 template <typename T, bool HllAsFinalResult>
 class HyperLogLogAggregate : public exec::Aggregate {
  public:
@@ -200,11 +41,11 @@ class HyperLogLogAggregate : public exec::Aggregate {
         indexBitLength_{common::hll::toIndexBitLength(defaultError)} {}
 
   int32_t accumulatorFixedWidthSize() const override {
-    return sizeof(HllAccumulator<T, HllAsFinalResult>);
+    return sizeof(velox::common::hll::HllAccumulator<T, HllAsFinalResult>);
   }
 
   int32_t accumulatorAlignmentSize() const override {
-    return alignof(HllAccumulator<T, HllAsFinalResult>);
+    return alignof(velox::common::hll::HllAccumulator<T, HllAsFinalResult>);
   }
 
   bool isFixedSize() const override {
@@ -234,7 +75,8 @@ class HyperLogLogAggregate : public exec::Aggregate {
           groups,
           numGroups,
           flatResult,
-          [](HllAccumulator<T, HllAsFinalResult>* accumulator,
+          [](velox::common::hll::HllAccumulator<T, HllAsFinalResult>*
+                 accumulator,
              FlatVector<int64_t>* result,
              vector_size_t index) {
             result->set(index, accumulator->cardinality());
@@ -251,7 +93,8 @@ class HyperLogLogAggregate : public exec::Aggregate {
 
       for (auto i = 0; i < numGroups; ++i) {
         char* group = groups[i];
-        auto* accumulator = value<HllAccumulator<bool, false>>(group);
+        auto* accumulator =
+            value<velox::common::hll::HllAccumulator<bool, false>>(group);
         flatResult->set(i, accumulator->getState());
       }
 
@@ -262,7 +105,8 @@ class HyperLogLogAggregate : public exec::Aggregate {
           groups,
           numGroups,
           flatResult,
-          [&](HllAccumulator<T, HllAsFinalResult>* accumulator,
+          [&](velox::common::hll::HllAccumulator<T, HllAsFinalResult>*
+                  accumulator,
               FlatVector<StringView>* result,
               vector_size_t index) {
             auto size = accumulator->serializedSize();
@@ -298,7 +142,9 @@ class HyperLogLogAggregate : public exec::Aggregate {
 
         auto group = groups[row];
         auto tracker = trackRowSize(group);
-        auto accumulator = value<HllAccumulator<T, HllAsFinalResult>>(group);
+        auto accumulator =
+            value<velox::common::hll::HllAccumulator<T, HllAsFinalResult>>(
+                group);
         clearNull(group);
         accumulator->setIndexBitLength(indexBitLength_);
         accumulator->append(decodedValue_.valueAt<T>(row));
@@ -342,7 +188,9 @@ class HyperLogLogAggregate : public exec::Aggregate {
           return;
         }
 
-        auto accumulator = value<HllAccumulator<T, HllAsFinalResult>>(group);
+        auto accumulator =
+            value<velox::common::hll::HllAccumulator<T, HllAsFinalResult>>(
+                group);
         clearNull(group);
         accumulator->setIndexBitLength(indexBitLength_);
 
@@ -376,24 +224,26 @@ class HyperLogLogAggregate : public exec::Aggregate {
     setAllNulls(groups, indices);
     for (auto i : indices) {
       auto group = groups[i];
-      new (group + offset_) HllAccumulator<T, HllAsFinalResult>(allocator_);
+      new (group + offset_)
+          velox::common::hll::HllAccumulator<T, HllAsFinalResult>(allocator_);
     }
   }
 
   void destroyInternal(folly::Range<char**> groups) override {
-    destroyAccumulators<HllAccumulator<T, HllAsFinalResult>>(groups);
+    destroyAccumulators<
+        velox::common::hll::HllAccumulator<T, HllAsFinalResult>>(groups);
   }
 
  private:
   void mergeToAccumulator(char* group, const vector_size_t row) {
     if constexpr (std::is_same_v<T, bool>) {
       static_assert(!HllAsFinalResult);
-      value<HllAccumulator<bool, false>>(group)->mergeWith(
+      value<velox::common::hll::HllAccumulator<bool, false>>(group)->mergeWith(
           decodedHll_.valueAt<int8_t>(row));
     } else {
       auto serialized = decodedHll_.valueAt<StringView>(row);
-      HllAccumulator<T, HllAsFinalResult>* accumulator =
-          value<HllAccumulator<T, HllAsFinalResult>>(group);
+      velox::common::hll::HllAccumulator<T, HllAsFinalResult>* accumulator =
+          value<velox::common::hll::HllAccumulator<T, HllAsFinalResult>>(group);
       accumulator->mergeWith(serialized, allocator_);
     }
   }
@@ -432,7 +282,9 @@ class HyperLogLogAggregate : public exec::Aggregate {
           bits::clearBit(rawNulls, i);
         }
 
-        auto accumulator = value<HllAccumulator<T, HllAsFinalResult>>(group);
+        auto accumulator =
+            value<velox::common::hll::HllAccumulator<T, HllAsFinalResult>>(
+                group);
         extractFunction(accumulator, result, i);
       }
     }
diff --git a/velox/functions/prestosql/aggregates/KHyperLogLogAggregate.cpp b/velox/functions/prestosql/aggregates/KHyperLogLogAggregate.cpp
new file mode 100644
index 00000000000..1a29016e2f9
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/KHyperLogLogAggregate.cpp
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/aggregates/KHyperLogLogAggregate.h"
+#include "velox/exec/Aggregate.h"
+
+using namespace facebook::velox::aggregate;
+
+namespace facebook::velox::aggregate::prestosql {
+namespace {
+
+template <TypeKind TValueKind, TypeKind TUiiKind>
+std::unique_ptr<exec::Aggregate> createKHyperLogLogAggregate(
+    const TypePtr& resultType) {
+  using TValue = typename TypeTraits<TValueKind>::NativeType;
+  using TUii = typename TypeTraits<TUiiKind>::NativeType;
+  return std::make_unique<KHyperLogLogAggregate<TValue, TUii>>(resultType);
+}
+
+template <TypeKind TJoinKeyKind>
+std::unique_ptr<exec::Aggregate> dispatchOnUiiType(
+    TypeKind uiiKind,
+    const TypePtr& resultType) {
+  return VELOX_DYNAMIC_SCALAR_TEMPLATE_TYPE_DISPATCH(
+      createKHyperLogLogAggregate, TJoinKeyKind, uiiKind, resultType);
+}
+
+/// Registration for khyperloglog_agg aggregate function.
+std::vector<exec::AggregateRegistrationResult> registerKHyperLogLogAgg(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
+
+  // Register all physical types for both JoinKey and UII.
+  std::vector<std::string> inputTypes = {
+      "boolean",
+      "tinyint",
+      "smallint",
+      "integer",
+      "bigint",
+      "real",
+      "double",
+      "varchar",
+      "varbinary",
+      "timestamp",
+      "date"};
+
+  // Generate all combinations of (joinKeyType, uiiType)
+  for (const auto& valueType : inputTypes) {
+    for (const auto& uiiType : inputTypes) {
+      signatures.push_back(
+          exec::AggregateFunctionSignatureBuilder()
+              .returnType("khyperloglog")
+              .intermediateType("khyperloglog")
+              .argumentType(valueType)
+              .argumentType(uiiType)
+              .build());
+    }
+  }
+
+  return exec::registerAggregateFunction(
+      names,
+      signatures,
+      [names](
+          core::AggregationNode::Step /*step*/,
+          const std::vector<TypePtr>& argTypes,
+          const TypePtr& resultType,
+          const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        VELOX_CHECK_EQ(
+            argTypes.size(),
+            2,
+            "{}: unexpected number of arguments",
+            names.front());
+
+        auto joinKeyKind = argTypes[0]->kind();
+        auto uiiKind = argTypes[1]->kind();
+
+        // First dispatch on JoinKey type, then on UII type.
+        return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+            dispatchOnUiiType, joinKeyKind, uiiKind, resultType);
+      },
+      withCompanionFunctions,
+      overwrite);
+}
+} // namespace
+
+void registerKHyperLogLogAggregates(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  registerKHyperLogLogAgg(names, withCompanionFunctions, overwrite);
+}
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/KHyperLogLogAggregate.h b/velox/functions/prestosql/aggregates/KHyperLogLogAggregate.h
new file mode 100644
index 00000000000..19428148734
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/KHyperLogLogAggregate.h
@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/exec/Aggregate.h"
+#include "velox/functions/lib/KHyperLogLog.h"
+#include "velox/vector/DecodedVector.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::aggregate::prestosql {
+
+template <typename TValue, typename TUii>
+class KHyperLogLogAggregate : public exec::Aggregate {
+  using KHllAccumulator = common::hll::KHyperLogLog<TUii, HashStringAllocator>;
+
+ public:
+  explicit KHyperLogLogAggregate(const TypePtr& resultType)
+      : exec::Aggregate(resultType) {}
+
+  int32_t accumulatorFixedWidthSize() const override {
+    return sizeof(KHllAccumulator);
+  }
+
+  int32_t accumulatorAlignmentSize() const override {
+    return alignof(KHllAccumulator);
+  }
+
+  bool isFixedSize() const override {
+    return false;
+  }
+
+  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    extractAccumulators(groups, numGroups, result);
+  }
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    VELOX_CHECK(result);
+    auto* flatResult = (*result)->asFlatVector<StringView>();
+    flatResult->resize(numGroups);
+
+    BufferPtr& nulls = flatResult->mutableNulls(flatResult->size());
+    uint64_t* rawNulls = nulls->asMutable<uint64_t>();
+
+    // Calculate total size needed for non-inline strings.
+    int64_t totalSize = 0;
+    for (auto i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      if (!isNull(group)) {
+        auto* accumulator = value<KHllAccumulator>(group);
+        auto size = accumulator->estimatedSerializedSize();
+        if (!StringView::isInline(size)) {
+          totalSize += size;
+        }
+      }
+    }
+
+    // Allocate all required space at once.
+    char* rawBuffer = flatResult->getRawStringBufferWithSpace(totalSize);
+
+    // Serialize accumulators.
+    for (auto i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      if (isNull(group)) {
+        flatResult->setNull(i, true);
+      } else {
+        bits::clearBit(rawNulls, i);
+
+        auto* accumulator = value<KHllAccumulator>(group);
+        size_t size = accumulator->estimatedSerializedSize();
+
+        StringView serialized;
+        if (StringView::isInline(size)) {
+          std::string buffer(size, '\0');
+          accumulator->serialize(buffer.data());
+          serialized = StringView::makeInline(buffer);
+        } else {
+          accumulator->serialize(rawBuffer);
+          serialized = StringView(rawBuffer, size);
+          rawBuffer += size;
+        }
+        flatResult->setNoCopy(i, serialized);
+      }
+    }
+  }
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedValue_.decode(*args[0], rows, true);
+    decodedUii_.decode(*args[1], rows, true);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedValue_.isNullAt(row) || decodedUii_.isNullAt(row)) {
+        return;
+      }
+
+      auto group = groups[row];
+      auto tracker = trackRowSize(group);
+      auto* accumulator = value<KHllAccumulator>(group);
+      clearNull(group);
+
+      auto val = decodedValue_.valueAt<TValue>(row);
+      auto uii = decodedUii_.valueAt<TUii>(row);
+      accumulator->add(val, uii);
+    });
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedIntermediate_.decode(*args[0], rows, true);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedIntermediate_.isNullAt(row)) {
+        return;
+      }
+
+      auto group = groups[row];
+      auto tracker = trackRowSize(group);
+      clearNull(group);
+
+      auto serialized = decodedIntermediate_.valueAt<StringView>(row);
+      auto* accumulator = value<KHllAccumulator>(group);
+      accumulator->mergeWith(serialized, allocator_);
+    });
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    auto tracker = trackRowSize(group);
+
+    decodedValue_.decode(*args[0], rows, true);
+    decodedUii_.decode(*args[1], rows, true);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedValue_.isNullAt(row) || decodedUii_.isNullAt(row)) {
+        return;
+      }
+
+      auto* accumulator = value<KHllAccumulator>(group);
+      clearNull(group);
+
+      auto val = decodedValue_.valueAt<TValue>(row);
+      auto uii = decodedUii_.valueAt<TUii>(row);
+      accumulator->add(val, uii);
+    });
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedIntermediate_.decode(*args[0], rows, true);
+
+    auto tracker = trackRowSize(group);
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedIntermediate_.isNullAt(row)) {
+        return;
+      }
+
+      clearNull(group);
+
+      auto serialized = decodedIntermediate_.valueAt<StringView>(row);
+      auto* accumulator = value<KHllAccumulator>(group);
+      accumulator->mergeWith(serialized, allocator_);
+    });
+  }
+
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    setAllNulls(groups, indices);
+    for (auto i : indices) {
+      auto group = groups[i];
+      new (group + offset_) KHllAccumulator(allocator_);
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
+    destroyAccumulators<KHllAccumulator>(groups);
+  }
+
+ private:
+  DecodedVector decodedValue_;
+  DecodedVector decodedUii_;
+  DecodedVector decodedIntermediate_;
+};
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/MapAggAggregate.cpp b/velox/functions/prestosql/aggregates/MapAggAggregate.cpp
index 66986c8eb8e..4e6b199da60 100644
--- a/velox/functions/prestosql/aggregates/MapAggAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/MapAggAggregate.cpp
@@ -48,7 +48,7 @@ class MapAggAggregate : public MapAggregateBase<K, AccumulatorType> {
       const auto* indices = decodedKeys.indices();
       rows.applyToSelected([&](vector_size_t i) {
         velox::functions::checkNestedNulls(
-            decodedKeys, indices, i, throwOnNestedNulls_);
+            decodedKeys, i, indices[i], throwOnNestedNulls_);
       });
     }
 
@@ -105,7 +105,7 @@ class MapAggAggregate : public MapAggregateBase<K, AccumulatorType> {
 
     rows.applyToSelected([&](vector_size_t row) {
       if (velox::functions::checkNestedNulls(
-              Base::decodedKeys_, indices, row, throwOnNestedNulls_)) {
+              Base::decodedKeys_, row, indices[row], throwOnNestedNulls_)) {
         return;
       }
 
@@ -131,7 +131,7 @@ class MapAggAggregate : public MapAggregateBase<K, AccumulatorType> {
     auto tracker = Base::trackRowSize(group);
     rows.applyToSelected([&](vector_size_t row) {
       if (velox::functions::checkNestedNulls(
-              Base::decodedKeys_, indices, row, throwOnNestedNulls_)) {
+              Base::decodedKeys_, row, indices[row], throwOnNestedNulls_)) {
         return;
       }
 
@@ -156,7 +156,7 @@ std::unique_ptr<exec::Aggregate> createMapAggAggregateWithCustomCompare(
 } // namespace
 
 void registerMapAggAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
@@ -169,16 +169,16 @@ void registerMapAggAggregate(
           .argumentType("V")
           .build()};
 
-  auto name = prefix + kMapAgg;
   exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
+      [names](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
+        const std::string& name = names.front();
         auto rawInput = exec::isRawInput(step);
         VELOX_CHECK_EQ(
             argTypes.size(),
@@ -225,7 +225,7 @@ void registerMapAggAggregate(
             return std::make_unique<MapAggAggregate<int32_t>>(resultType);
           default:
             VELOX_UNREACHABLE(
-                "Unexpected type {}", mapTypeKindToName(typeKind));
+                "Unexpected type {}", TypeKindName::toName(typeKind));
         }
       },
       withCompanionFunctions,
diff --git a/velox/functions/prestosql/aggregates/MapAggAggregate.h b/velox/functions/prestosql/aggregates/MapAggAggregate.h
index db9adc31904..43675df072c 100644
--- a/velox/functions/prestosql/aggregates/MapAggAggregate.h
+++ b/velox/functions/prestosql/aggregates/MapAggAggregate.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerMapAggAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/MapAggregateBase.h b/velox/functions/prestosql/aggregates/MapAggregateBase.h
index b49284b4ca4..e4df357d533 100644
--- a/velox/functions/prestosql/aggregates/MapAggregateBase.h
+++ b/velox/functions/prestosql/aggregates/MapAggregateBase.h
@@ -200,8 +200,9 @@ class MapAggregateBase : public exec::Aggregate {
   DecodedVector decodedMaps_;
 };
 
-template <template <typename K, typename Accumulator = MapAccumulator<K>>
-          class TAggregate>
+template <template <
+    typename K,
+    typename Accumulator = MapAccumulator<K>> class TAggregate>
 std::unique_ptr<exec::Aggregate> createMapAggregate(const TypePtr& resultType) {
   auto typeKind = resultType->childAt(0)->kind();
   switch (typeKind) {
@@ -232,7 +233,7 @@ std::unique_ptr<exec::Aggregate> createMapAggregate(const TypePtr& resultType) {
     case TypeKind::UNKNOWN:
       return std::make_unique<TAggregate<int32_t>>(resultType);
     default:
-      VELOX_UNREACHABLE("Unexpected type {}", mapTypeKindToName(typeKind));
+      VELOX_UNREACHABLE("Unexpected type {}", TypeKindName::toName(typeKind));
   }
 }
 
diff --git a/velox/functions/prestosql/aggregates/MapUnionAggregate.cpp b/velox/functions/prestosql/aggregates/MapUnionAggregate.cpp
index 05cb69a4559..92f8bc45a57 100644
--- a/velox/functions/prestosql/aggregates/MapUnionAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/MapUnionAggregate.cpp
@@ -85,7 +85,7 @@ std::unique_ptr<exec::Aggregate> createMapUnionAggregateWithCustomCompare(
 } // namespace
 
 void registerMapUnionAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
@@ -97,16 +97,16 @@ void registerMapUnionAggregate(
           .argumentType("map(K,V)")
           .build()};
 
-  auto name = prefix + kMapUnion;
   exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
+      [names](
           core::AggregationNode::Step /*step*/,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
+        const std::string& name = names.front();
         VELOX_CHECK_EQ(
             argTypes.size(), 1, "{}: unexpected number of arguments", name);
 
diff --git a/velox/functions/prestosql/aggregates/MapUnionAggregate.h b/velox/functions/prestosql/aggregates/MapUnionAggregate.h
index 30d8d175047..76e0f19672c 100644
--- a/velox/functions/prestosql/aggregates/MapUnionAggregate.h
+++ b/velox/functions/prestosql/aggregates/MapUnionAggregate.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerMapUnionAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/MapUnionSumAggregate.cpp b/velox/functions/prestosql/aggregates/MapUnionSumAggregate.cpp
index 449072bff8e..82b2a507003 100644
--- a/velox/functions/prestosql/aggregates/MapUnionSumAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/MapUnionSumAggregate.cpp
@@ -18,7 +18,6 @@
 #include "velox/exec/Aggregate.h"
 #include "velox/exec/Strings.h"
 #include "velox/expression/FunctionSignature.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/vector/FlatVector.h"
 
 namespace facebook::velox::aggregate::prestosql {
@@ -81,12 +80,12 @@ struct Accumulator {
 
           if (errorValue < 0) {
             VELOX_ARITHMETIC_ERROR(
-                "Value {} is less than {}",
+                "Arithmetic overflow in MAP_UNION_SUM: Value {} is less than {}",
                 errorValue,
                 std::numeric_limits<S>::min());
           } else {
             VELOX_ARITHMETIC_ERROR(
-                "Value {} exceeds {}",
+                "Arithmetic overflow in MAP_UNION_SUM: Value {} exceeds {}",
                 errorValue,
                 std::numeric_limits<S>::max());
           }
@@ -230,12 +229,12 @@ struct ComplexTypeAccumulator {
 
               if (errorValue < 0) {
                 VELOX_ARITHMETIC_ERROR(
-                    "Value {} is less than {}",
+                    "Arithmetic overflow in MAP_UNION_SUM: Value {} is less than {}",
                     errorValue,
                     std::numeric_limits<V>::min());
               } else {
                 VELOX_ARITHMETIC_ERROR(
-                    "Value {} exceeds {}",
+                    "Arithmetic overflow in MAP_UNION_SUM: Value {} exceeds {}",
                     errorValue,
                     std::numeric_limits<V>::max());
               }
@@ -481,14 +480,14 @@ std::unique_ptr<exec::Aggregate> createMapUnionSumAggregate(
       return std::make_unique<MapUnionSumAggregate<K, double>>(resultType);
     default:
       VELOX_UNREACHABLE(
-          "Unexpected value type {}", mapTypeKindToName(valueKind));
+          "Unexpected value type {}", TypeKindName::toName(valueKind));
   }
 }
 
 } // namespace
 
 void registerMapUnionSumAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   const std::vector<std::string> valueTypes = {
@@ -506,15 +505,13 @@ void registerMapUnionSumAggregate(
             .build());
   }
 
-  auto name = prefix + kMapUnionSum;
   exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
-          core::AggregationNode::Step /*step*/,
-          const std::vector<TypePtr>& argTypes,
-          const TypePtr& resultType,
-          const core::QueryConfig& /*config*/)
+      [](core::AggregationNode::Step /*step*/,
+         const std::vector<TypePtr>& argTypes,
+         const TypePtr& resultType,
+         const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
         VELOX_CHECK_EQ(argTypes.size(), 1);
         VELOX_CHECK(argTypes[0]->isMap());
@@ -537,6 +534,9 @@ void registerMapUnionSumAggregate(
           case TypeKind::BIGINT:
             return createMapUnionSumAggregate<int64_t>(
                 valueTypeKind, resultType);
+          case TypeKind::HUGEINT:
+            return createMapUnionSumAggregate<int128_t>(
+                valueTypeKind, resultType);
           case TypeKind::REAL:
             return createMapUnionSumAggregate<float>(valueTypeKind, resultType);
           case TypeKind::DOUBLE:
@@ -563,7 +563,7 @@ void registerMapUnionSumAggregate(
                   valueTypeKind, resultType);
             }
             VELOX_UNREACHABLE(
-                "Unexpected key type {}", mapTypeKindToName(keyTypeKind));
+                "Unexpected key type {}", TypeKindName::toName(keyTypeKind));
         }
       },
       withCompanionFunctions,
diff --git a/velox/functions/prestosql/aggregates/MapUnionSumAggregate.h b/velox/functions/prestosql/aggregates/MapUnionSumAggregate.h
index ce7622c9752..57e1eb177d6 100644
--- a/velox/functions/prestosql/aggregates/MapUnionSumAggregate.h
+++ b/velox/functions/prestosql/aggregates/MapUnionSumAggregate.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerMapUnionSumAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/MaxByAggregate.cpp b/velox/functions/prestosql/aggregates/MaxByAggregate.cpp
index 037deb4afa2..01e2b1c6590 100644
--- a/velox/functions/prestosql/aggregates/MaxByAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/MaxByAggregate.cpp
@@ -15,7 +15,6 @@
  */
 
 #include "velox/functions/prestosql/aggregates/MaxByAggregate.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/functions/prestosql/aggregates/MinMaxByAggregateBase.h"
 
 namespace facebook::velox::aggregate::prestosql {
@@ -42,13 +41,13 @@ class MaxByNAggregate<ComplexType, C>
 };
 
 void registerMaxByAggregates(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   registerMinMaxBy<
       functions::aggregate::MinMaxByAggregateBase,
       true,
-      MaxByNAggregate>(prefix + kMaxBy, withCompanionFunctions, overwrite);
+      MaxByNAggregate>(names, withCompanionFunctions, overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/MaxByAggregate.h b/velox/functions/prestosql/aggregates/MaxByAggregate.h
index 3e2ffaadefc..e091725969f 100644
--- a/velox/functions/prestosql/aggregates/MaxByAggregate.h
+++ b/velox/functions/prestosql/aggregates/MaxByAggregate.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerMaxByAggregates(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/MaxSizeForStatsAggregate.cpp b/velox/functions/prestosql/aggregates/MaxSizeForStatsAggregate.cpp
index 936236a00c2..843a9f89876 100644
--- a/velox/functions/prestosql/aggregates/MaxSizeForStatsAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/MaxSizeForStatsAggregate.cpp
@@ -18,7 +18,6 @@
 #include "velox/exec/Aggregate.h"
 #include "velox/expression/FunctionSignature.h"
 #include "velox/functions/lib/aggregates/SimpleNumericAggregate.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/serializers/PrestoSerializer.h"
 
 using namespace facebook::velox::functions::aggregate;
@@ -206,33 +205,35 @@ class MaxSizeForStatsAggregate
 } // namespace
 
 void registerMaxDataSizeForStatsAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
 
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .typeVariable("T")
-                           .returnType("bigint")
-                           .intermediateType("bigint")
-                           .argumentType("T")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .typeVariable("T")
+          .returnType("bigint")
+          .intermediateType("bigint")
+          .argumentType("T")
+          .build());
 
-  auto name = prefix + kMaxSizeForStats;
   exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
+      [names](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
-        VELOX_CHECK_EQ(argTypes.size(), 1, "{} takes only one argument", name);
+        VELOX_CHECK_EQ(
+            argTypes.size(), 1, "{} takes only one argument", names.front());
         auto inputType = argTypes[0];
 
         return std::make_unique<MaxSizeForStatsAggregate>(resultType);
       },
+      {.ignoreDuplicates = true, .orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/MaxSizeForStatsAggregate.h b/velox/functions/prestosql/aggregates/MaxSizeForStatsAggregate.h
index aafecfa5451..aceac349046 100644
--- a/velox/functions/prestosql/aggregates/MaxSizeForStatsAggregate.h
+++ b/velox/functions/prestosql/aggregates/MaxSizeForStatsAggregate.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerMaxDataSizeForStatsAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/MergeAggregate.cpp b/velox/functions/prestosql/aggregates/MergeAggregate.cpp
index b8a59eab40d..b373acce56b 100644
--- a/velox/functions/prestosql/aggregates/MergeAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/MergeAggregate.cpp
@@ -15,12 +15,14 @@
  */
 #include "velox/functions/prestosql/aggregates/MergeAggregate.h"
 #include "velox/expression/FunctionSignature.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/functions/prestosql/aggregates/HyperLogLogAggregate.h"
+#include "velox/functions/prestosql/aggregates/MergeKHyperLogLogAggregate.h"
 #include "velox/functions/prestosql/aggregates/MergeQDigestAggregate.h"
 #include "velox/functions/prestosql/aggregates/MergeTDigestAggregate.h"
 #include "velox/functions/prestosql/aggregates/SfmSketchAggregate.h"
 #include "velox/functions/prestosql/types/HyperLogLogRegistration.h"
+#include "velox/functions/prestosql/types/KHyperLogLogRegistration.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
 #include "velox/functions/prestosql/types/QDigestRegistration.h"
 #include "velox/functions/prestosql/types/SfmSketchRegistration.h"
 #include "velox/functions/prestosql/types/SfmSketchType.h"
@@ -31,14 +33,15 @@ namespace facebook::velox::aggregate::prestosql {
 
 namespace {
 
-exec::AggregateRegistrationResult registerMerge(
-    const std::string& name,
+std::vector<exec::AggregateRegistrationResult> registerMerge(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite,
     double defaultError) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
   auto inputTypes = std::vector<std::string>{
       "hyperloglog",
+      "khyperloglog",
       "sfmsketch",
       "tdigest(double)",
       "qdigest(bigint)",
@@ -46,18 +49,19 @@ exec::AggregateRegistrationResult registerMerge(
       "qdigest(double)"};
   signatures.reserve(inputTypes.size());
   for (const auto& inputType : inputTypes) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType(inputType)
-                             .intermediateType("varbinary")
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType(inputType)
+            .intermediateType("varbinary")
+            .argumentType(inputType)
+            .build());
   }
   bool hllAsRawInput = true;
   bool hllAsFinalResult = true;
   return exec::registerAggregateFunction(
-      name,
+      names,
       signatures,
-      [name, hllAsFinalResult, hllAsRawInput, defaultError](
+      [hllAsFinalResult, hllAsRawInput, defaultError](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
@@ -79,7 +83,10 @@ exec::AggregateRegistrationResult registerMerge(
           return std::make_unique<SfmSketchAggregate<true, false, true>>(
               resultType);
         }
-        if (argTypes[0]->isUnKnown()) {
+        if (argTypes[0] == KHYPERLOGLOG()) {
+          return std::make_unique<MergeKHyperLogLogAggregate>(resultType);
+        }
+        if (argTypes[0]->isUnknown()) {
           return std::make_unique<HyperLogLogAggregate<UnknownValue, true>>(
               resultType, hllAsRawInput, defaultError);
         }
@@ -103,20 +110,18 @@ exec::AggregateRegistrationResult registerMerge(
 } // namespace
 
 void registerMergeAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool /* withCompanionFunctions */,
     bool overwrite) {
   registerSfmSketchType();
   registerHyperLogLogType();
+  registerKHyperLogLogType();
   registerTDigestType();
   registerQDigestType();
   // merge is companion function for approx_distinct. Don't register companion
   // functions for it.
   registerMerge(
-      prefix + kMerge,
-      false,
-      overwrite,
-      common::hll::kDefaultApproxSetStandardError);
+      names, false, overwrite, common::hll::kDefaultApproxSetStandardError);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/MergeAggregate.h b/velox/functions/prestosql/aggregates/MergeAggregate.h
index 4b2916d2870..c402343bba1 100644
--- a/velox/functions/prestosql/aggregates/MergeAggregate.h
+++ b/velox/functions/prestosql/aggregates/MergeAggregate.h
@@ -16,11 +16,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerMergeAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 
diff --git a/velox/functions/prestosql/aggregates/MergeKHyperLogLogAggregate.h b/velox/functions/prestosql/aggregates/MergeKHyperLogLogAggregate.h
new file mode 100644
index 00000000000..5362123c58e
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/MergeKHyperLogLogAggregate.h
@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/exec/Aggregate.h"
+#include "velox/functions/lib/KHyperLogLog.h"
+#include "velox/vector/DecodedVector.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::aggregate::prestosql {
+
+class MergeKHyperLogLogAggregate : public exec::Aggregate {
+  using MergeKHllAccumulator =
+      common::hll::KHyperLogLog<int64_t, HashStringAllocator>;
+
+ public:
+  explicit MergeKHyperLogLogAggregate(const TypePtr& resultType)
+      : exec::Aggregate(resultType) {}
+
+  int32_t accumulatorFixedWidthSize() const override {
+    return sizeof(MergeKHllAccumulator);
+  }
+
+  int32_t accumulatorAlignmentSize() const override {
+    return alignof(MergeKHllAccumulator);
+  }
+
+  bool accumulatorUsesExternalMemory() const override {
+    return true;
+  }
+
+  bool isFixedSize() const override {
+    return false;
+  }
+
+  void toIntermediate(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      VectorPtr& result) const final {
+    singleInputAsIntermediate(rows, args, result);
+  }
+
+  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    extractAccumulators(groups, numGroups, result);
+  }
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    VELOX_CHECK(result);
+    auto* flatResult = (*result)->asFlatVector<StringView>();
+    flatResult->resize(numGroups);
+
+    uint64_t* rawNulls = nullptr;
+    if (flatResult->mayHaveNulls()) {
+      BufferPtr& nulls = flatResult->mutableNulls(flatResult->size());
+      rawNulls = nulls->asMutable<uint64_t>();
+    }
+
+    // Calculate total size needed for non-inline strings.
+    int64_t totalSize = 0;
+    for (auto i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      if (!isNull(group)) {
+        auto* accumulator = value<MergeKHllAccumulator>(group);
+        auto size = accumulator->estimatedSerializedSize();
+        if (!StringView::isInline(size)) {
+          totalSize += size;
+        }
+      }
+    }
+
+    // Allocate all required space at once.
+    char* rawBuffer = flatResult->getRawStringBufferWithSpace(totalSize);
+
+    // Serialize accumulators.
+    for (auto i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      if (isNull(group)) {
+        flatResult->setNull(i, true);
+      } else {
+        if (rawNulls) {
+          bits::clearBit(rawNulls, i);
+        }
+
+        auto* accumulator = value<MergeKHllAccumulator>(group);
+        auto size = accumulator->estimatedSerializedSize();
+
+        StringView serialized;
+        if (StringView::isInline(size)) {
+          std::string buffer(size, '\0');
+          accumulator->serialize(buffer.data());
+          serialized = StringView::makeInline(buffer);
+        } else {
+          accumulator->serialize(rawBuffer);
+          serialized = StringView(rawBuffer, size);
+          rawBuffer += size;
+        }
+        flatResult->setNoCopy(i, serialized);
+      }
+    }
+  }
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    addIntermediateResults(groups, rows, args, false);
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedKHll_.decode(*args[0], rows, true);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedKHll_.isNullAt(row)) {
+        return;
+      }
+
+      auto group = groups[row];
+      auto tracker = trackRowSize(group);
+      clearNull(group);
+
+      auto serialized = decodedKHll_.valueAt<StringView>(row);
+      auto* accumulator = value<MergeKHllAccumulator>(group);
+      accumulator->mergeWith(serialized, allocator_);
+    });
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    addSingleGroupIntermediateResults(group, rows, args, false);
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedKHll_.decode(*args[0], rows, true);
+
+    auto tracker = trackRowSize(group);
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedKHll_.isNullAt(row)) {
+        return;
+      }
+
+      clearNull(group);
+
+      auto serialized = decodedKHll_.valueAt<StringView>(row);
+      auto* accumulator = value<MergeKHllAccumulator>(group);
+      accumulator->mergeWith(serialized, allocator_);
+    });
+  }
+
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    setAllNulls(groups, indices);
+    for (auto i : indices) {
+      auto group = groups[i];
+      new (group + offset_) MergeKHllAccumulator(allocator_);
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
+    destroyAccumulators<MergeKHllAccumulator>(groups);
+  }
+
+ private:
+  DecodedVector decodedKHll_;
+};
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/MergeTDigestAggregate.h b/velox/functions/prestosql/aggregates/MergeTDigestAggregate.h
index 26fbde19b6c..b57fb6c9d6b 100644
--- a/velox/functions/prestosql/aggregates/MergeTDigestAggregate.h
+++ b/velox/functions/prestosql/aggregates/MergeTDigestAggregate.h
@@ -17,40 +17,12 @@
 #pragma once
 
 #include "velox/exec/Aggregate.h"
-#include "velox/functions/lib/TDigest.h"
+#include "velox/functions/prestosql/aggregates/TDigestAccumulator.h"
 #include "velox/vector/DecodedVector.h"
 #include "velox/vector/FlatVector.h"
 
 namespace facebook::velox::aggregate::prestosql {
 
-// TDigest accumulator for merge operations
-struct TDigestAccumulator {
-  explicit TDigestAccumulator(HashStringAllocator* allocator)
-      : digest_(StlAllocator<double>(allocator)) {}
-
-  void mergeWith(
-      StringView serialized,
-      HashStringAllocator* /*allocator*/,
-      std::vector<int16_t>& positions) {
-    if (serialized.empty()) {
-      return;
-    }
-    digest_.mergeDeserialized(positions, serialized.data());
-  }
-
-  int64_t serializedSize(std::vector<int16_t>& positions) {
-    digest_.compress(positions);
-    return digest_.serializedByteSize();
-  }
-
-  void serialize(char* outputBuffer) {
-    digest_.serialize(outputBuffer);
-  }
-
- private:
-  facebook::velox::functions::TDigest<StlAllocator<double>> digest_;
-};
-
 class MergeTDigestAggregate : public exec::Aggregate {
  public:
   explicit MergeTDigestAggregate(const TypePtr& resultType)
@@ -98,15 +70,16 @@ class MergeTDigestAggregate : public exec::Aggregate {
         [&](TDigestAccumulator* accumulator,
             FlatVector<StringView>* result,
             vector_size_t index) {
-          auto size = accumulator->serializedSize(positions);
+          accumulator->digest.compress(positions);
+          auto size = accumulator->digest.serializedByteSize();
           StringView serialized;
           if (StringView::isInline(size)) {
             std::string buffer(size, '\0');
-            accumulator->serialize(buffer.data());
+            accumulator->digest.serialize(buffer.data());
             serialized = StringView::makeInline(buffer);
           } else {
             char* rawBuffer = flatResult->getRawStringBufferWithSpace(size);
-            accumulator->serialize(rawBuffer);
+            accumulator->digest.serialize(rawBuffer);
             serialized = StringView(rawBuffer, size);
           }
           result->setNoCopy(index, serialized);
@@ -191,8 +164,11 @@ class MergeTDigestAggregate : public exec::Aggregate {
       const vector_size_t row,
       std::vector<int16_t>& positions) {
     auto serialized = decodedTDigest_.valueAt<StringView>(row);
-    TDigestAccumulator* accumulator = value<TDigestAccumulator>(group);
-    accumulator->mergeWith(serialized, allocator_, positions);
+    if (serialized.empty()) {
+      return;
+    }
+    auto* accumulator = value<TDigestAccumulator>(group);
+    accumulator->digest.mergeDeserialized(positions, serialized.data());
   }
 
   template <typename ExtractResult, typename ExtractFunc>
diff --git a/velox/functions/prestosql/aggregates/MinByAggregate.cpp b/velox/functions/prestosql/aggregates/MinByAggregate.cpp
index 7e01a7db6be..968ad454839 100644
--- a/velox/functions/prestosql/aggregates/MinByAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/MinByAggregate.cpp
@@ -15,7 +15,6 @@
  */
 
 #include "velox/functions/prestosql/aggregates/MinByAggregate.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/functions/prestosql/aggregates/MinMaxByAggregateBase.h"
 
 namespace facebook::velox::aggregate::prestosql {
@@ -42,13 +41,13 @@ class MinByNAggregate<ComplexType, C>
 };
 
 void registerMinByAggregates(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   registerMinMaxBy<
       functions::aggregate::MinMaxByAggregateBase,
       false,
-      MinByNAggregate>(prefix + kMinBy, withCompanionFunctions, overwrite);
+      MinByNAggregate>(names, withCompanionFunctions, overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/MinByAggregate.h b/velox/functions/prestosql/aggregates/MinByAggregate.h
index fa1831cf8dc..8f1deaa27c3 100644
--- a/velox/functions/prestosql/aggregates/MinByAggregate.h
+++ b/velox/functions/prestosql/aggregates/MinByAggregate.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerMinByAggregates(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/MinMaxAggregates.cpp b/velox/functions/prestosql/aggregates/MinMaxAggregates.cpp
index 3acd58788b4..95d07d634b3 100644
--- a/velox/functions/prestosql/aggregates/MinMaxAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/MinMaxAggregates.cpp
@@ -17,12 +17,11 @@
 #include "velox/functions/prestosql/aggregates/MinMaxAggregates.h"
 #include <limits>
 #include "velox/exec/Aggregate.h"
-#include "velox/exec/AggregationHook.h"
 #include "velox/functions/lib/aggregates/MinMaxAggregateBase.h"
 #include "velox/functions/lib/aggregates/SimpleNumericAggregate.h"
 #include "velox/functions/lib/aggregates/ValueSet.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/type/FloatingPointUtil.h"
+#include "velox/vector/AggregationHook.h"
 
 using namespace facebook::velox::functions::aggregate;
 
@@ -491,18 +490,19 @@ class MaxNAggregate : public MinMaxNAggregateBase<T, GreaterThanComparator<T>> {
 };
 
 template <template <typename T> typename AggregateN>
-exec::AggregateRegistrationResult registerMinMax(
-    const std::string& name,
+std::vector<exec::AggregateRegistrationResult> registerMinMax(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite,
     bool registerMin) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .orderableTypeVariable("T")
-                           .returnType("T")
-                           .intermediateType("T")
-                           .argumentType("T")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .orderableTypeVariable("T")
+          .returnType("T")
+          .intermediateType("T")
+          .argumentType("T")
+          .build());
   for (const auto& type :
        {"tinyint",
         "integer",
@@ -534,13 +534,14 @@ exec::AggregateRegistrationResult registerMinMax(
           .build());
 
   return exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name, registerMin](
+      [names, registerMin](
           core::AggregationNode::Step step,
           std::vector<TypePtr> argTypes,
           const TypePtr& resultType,
           const core::QueryConfig& config) -> std::unique_ptr<exec::Aggregate> {
+        const std::string& name = names.front();
         const bool nAgg = !resultType->equivalent(*argTypes[0]);
         if (nAgg) {
           // We have either 2 arguments: T, bigint (partial aggregation)
@@ -594,21 +595,26 @@ exec::AggregateRegistrationResult registerMinMax(
           }
         }
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
 
 } // namespace
 
-void registerMinMaxAggregates(
-    const std::string& prefix,
+void registerMinAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  registerMinMax<MinNAggregate>(names, withCompanionFunctions, overwrite, true);
+}
+
+void registerMaxAggregate(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
-  registerMinMax<MinNAggregate>(
-      prefix + kMin, withCompanionFunctions, overwrite, true);
   registerMinMax<MaxNAggregate>(
-      prefix + kMax, withCompanionFunctions, overwrite, false);
+      names, withCompanionFunctions, overwrite, false);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/MinMaxAggregates.h b/velox/functions/prestosql/aggregates/MinMaxAggregates.h
index 4679fcce618..d90532a55d8 100644
--- a/velox/functions/prestosql/aggregates/MinMaxAggregates.h
+++ b/velox/functions/prestosql/aggregates/MinMaxAggregates.h
@@ -17,11 +17,17 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
-void registerMinMaxAggregates(
-    const std::string& prefix,
+void registerMinAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+void registerMaxAggregate(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/MinMaxByAggregateBase.h b/velox/functions/prestosql/aggregates/MinMaxByAggregateBase.h
index 5329df3ca5c..f3852332d87 100644
--- a/velox/functions/prestosql/aggregates/MinMaxByAggregateBase.h
+++ b/velox/functions/prestosql/aggregates/MinMaxByAggregateBase.h
@@ -1127,25 +1127,24 @@ template <
         typename V,
         bool B1,
         class C,
-        bool compareTypeUsesCustomComparison>
-    class Aggregate,
+        bool compareTypeUsesCustomComparison> class Aggregate,
     bool isMaxFunc,
-    template <typename U, typename V>
-    class NAggregate>
-exec::AggregateRegistrationResult registerMinMaxBy(
-    const std::string& name,
+    template <typename U, typename V> class NAggregate>
+std::vector<exec::AggregateRegistrationResult> registerMinMaxBy(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
   // V, C -> row(V, C) -> V.
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .typeVariable("V")
-                           .orderableTypeVariable("C")
-                           .returnType("V")
-                           .intermediateType("row(V,C)")
-                           .argumentType("V")
-                           .argumentType("C")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .typeVariable("V")
+          .orderableTypeVariable("C")
+          .returnType("V")
+          .intermediateType("row(V,C)")
+          .argumentType("V")
+          .argumentType("C")
+          .build());
   // Add signatures for 3-arg version of min_by/max_by.
   const std::vector<std::string> supportedCompareTypes = {
       "boolean",
@@ -1163,15 +1162,16 @@ exec::AggregateRegistrationResult registerMinMaxBy(
   // Add support for all value types to 3-arg version of the aggregate.
   for (const auto& compareType : supportedCompareTypes) {
     // V, C, bigint -> row(bigint, array(C), array(V)) -> array(V).
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .typeVariable("V")
-                             .returnType("array(V)")
-                             .intermediateType(fmt::format(
-                                 "row(bigint,array({}),array(V))", compareType))
-                             .argumentType("V")
-                             .argumentType(compareType)
-                             .argumentType("bigint")
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .typeVariable("V")
+            .returnType("array(V)")
+            .intermediateType(
+                fmt::format("row(bigint,array({}),array(V))", compareType))
+            .argumentType("V")
+            .argumentType(compareType)
+            .argumentType("bigint")
+            .build());
   }
   signatures.push_back(
       exec::AggregateFunctionSignatureBuilder()
@@ -1186,9 +1186,9 @@ exec::AggregateRegistrationResult registerMinMaxBy(
           .argumentType("bigint")
           .build());
   return exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
+      [names](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
@@ -1196,7 +1196,7 @@ exec::AggregateRegistrationResult registerMinMaxBy(
           -> std::unique_ptr<exec::Aggregate> {
         const std::string errorMessage = fmt::format(
             "Unknown input types for {} ({}) aggregation: {}",
-            name,
+            names.front(),
             mapAggregationStepToName(step),
             toString(argTypes));
 
diff --git a/velox/functions/prestosql/aggregates/MultiMapAggAggregate.cpp b/velox/functions/prestosql/aggregates/MultiMapAggAggregate.cpp
index 91723058951..648f2cbb877 100644
--- a/velox/functions/prestosql/aggregates/MultiMapAggAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/MultiMapAggAggregate.cpp
@@ -18,7 +18,6 @@
 #include "velox/exec/Aggregate.h"
 #include "velox/exec/Strings.h"
 #include "velox/functions/lib/aggregates/ValueList.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/type/FloatingPointUtil.h"
 #include "velox/vector/FlatVector.h"
 
@@ -599,7 +598,7 @@ std::unique_ptr<exec::Aggregate> createMultiMapAggAggregateWithCustomCompare(
 } // namespace
 
 void registerMultiMapAggAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
@@ -612,15 +611,13 @@ void registerMultiMapAggAggregate(
           .argumentType("V")
           .build()};
 
-  auto name = prefix + kMultiMapAgg;
   exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
-          core::AggregationNode::Step step,
-          const std::vector<TypePtr>& argTypes,
-          const TypePtr& resultType,
-          const core::QueryConfig& /*config*/)
+      [](core::AggregationNode::Step step,
+         const std::vector<TypePtr>& argTypes,
+         const TypePtr& resultType,
+         const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
         const auto keyType = resultType->childAt(0);
         const auto typeKind = keyType->kind();
@@ -666,7 +663,7 @@ void registerMultiMapAggAggregate(
             return std::make_unique<MultiMapAggAggregate<int32_t>>(resultType);
           default:
             VELOX_UNREACHABLE(
-                "Unexpected type {}", mapTypeKindToName(typeKind));
+                "Unexpected type {}", TypeKindName::toName(typeKind));
         }
       },
       withCompanionFunctions,
diff --git a/velox/functions/prestosql/aggregates/MultiMapAggAggregate.h b/velox/functions/prestosql/aggregates/MultiMapAggAggregate.h
index fee2be57bb6..5d4173af71e 100644
--- a/velox/functions/prestosql/aggregates/MultiMapAggAggregate.h
+++ b/velox/functions/prestosql/aggregates/MultiMapAggAggregate.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerMultiMapAggAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/NoisyApproxSfmAggregate.cpp b/velox/functions/prestosql/aggregates/NoisyApproxSfmAggregate.cpp
index 8ea944a4da6..65aea0a9048 100644
--- a/velox/functions/prestosql/aggregates/NoisyApproxSfmAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/NoisyApproxSfmAggregate.cpp
@@ -16,14 +16,15 @@
 
 #include "velox/exec/Aggregate.h"
 #include "velox/expression/FunctionSignature.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/functions/prestosql/aggregates/SfmSketchAggregate.h"
 #include "velox/functions/prestosql/types/SfmSketchRegistration.h"
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerNoisyApproxSfmAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& noisyApproxSetSfmNames,
+    const std::vector<std::string>& noisyApproxDistinctSfmNames,
+    const std::vector<std::string>& noisyApproxSetSfmFromIndexAndZerosNames,
     bool withCompanionFunctions,
     bool overwrite) {
   // Register the SfmSketch type.
@@ -47,36 +48,42 @@ void registerNoisyApproxSfmAggregate(
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>>
       countSignatures;
   for (const auto& inputType : supportedInputTypes) {
-    setSignatures.push_back(setBuilder()
-                                .argumentType(inputType)
-                                .constantArgumentType("double")
-                                .build());
-    setSignatures.push_back(setBuilder()
-                                .argumentType(inputType)
-                                .constantArgumentType("double")
-                                .constantArgumentType("bigint")
-                                .build());
-    setSignatures.push_back(setBuilder()
-                                .argumentType(inputType)
-                                .constantArgumentType("double")
-                                .constantArgumentType("bigint")
-                                .constantArgumentType("bigint")
-                                .build());
-    countSignatures.push_back(countBuilder()
-                                  .argumentType(inputType)
-                                  .constantArgumentType("double")
-                                  .build());
-    countSignatures.push_back(countBuilder()
-                                  .argumentType(inputType)
-                                  .constantArgumentType("double")
-                                  .constantArgumentType("bigint")
-                                  .build());
-    countSignatures.push_back(countBuilder()
-                                  .argumentType(inputType)
-                                  .constantArgumentType("double")
-                                  .constantArgumentType("bigint")
-                                  .constantArgumentType("bigint")
-                                  .build());
+    setSignatures.push_back(
+        setBuilder()
+            .argumentType(inputType)
+            .constantArgumentType("double")
+            .build());
+    setSignatures.push_back(
+        setBuilder()
+            .argumentType(inputType)
+            .constantArgumentType("double")
+            .constantArgumentType("bigint")
+            .build());
+    setSignatures.push_back(
+        setBuilder()
+            .argumentType(inputType)
+            .constantArgumentType("double")
+            .constantArgumentType("bigint")
+            .constantArgumentType("bigint")
+            .build());
+    countSignatures.push_back(
+        countBuilder()
+            .argumentType(inputType)
+            .constantArgumentType("double")
+            .build());
+    countSignatures.push_back(
+        countBuilder()
+            .argumentType(inputType)
+            .constantArgumentType("double")
+            .constantArgumentType("bigint")
+            .build());
+    countSignatures.push_back(
+        countBuilder()
+            .argumentType(inputType)
+            .constantArgumentType("double")
+            .constantArgumentType("bigint")
+            .constantArgumentType("bigint")
+            .build());
   }
 
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>>
@@ -99,13 +106,12 @@ void registerNoisyApproxSfmAggregate(
           .build());
 
   exec::registerAggregateFunction(
-      prefix + kNoisyApproxSetSfm,
+      noisyApproxSetSfmNames,
       setSignatures,
-      [prefix](
-          core::AggregationNode::Step step,
-          const std::vector<TypePtr>& /*argTypes*/,
-          const TypePtr& resultType,
-          const core::QueryConfig& /*config*/)
+      [](core::AggregationNode::Step step,
+         const std::vector<TypePtr>& /*argTypes*/,
+         const TypePtr& resultType,
+         const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
         if (exec::isPartialOutput(step)) {
           return std::make_unique<SfmSketchAggregate<true, false, false>>(
@@ -118,13 +124,12 @@ void registerNoisyApproxSfmAggregate(
       overwrite);
 
   exec::registerAggregateFunction(
-      prefix + kNoisyApproxDistinctSfm,
+      noisyApproxDistinctSfmNames,
       countSignatures,
-      [prefix](
-          core::AggregationNode::Step step,
-          const std::vector<TypePtr>& /*argTypes*/,
-          const TypePtr& resultType,
-          const core::QueryConfig& /*config*/)
+      [](core::AggregationNode::Step step,
+         const std::vector<TypePtr>& /*argTypes*/,
+         const TypePtr& resultType,
+         const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
         if (exec::isPartialOutput(step)) {
           return std::make_unique<SfmSketchAggregate<false, false, false>>(
@@ -137,13 +142,12 @@ void registerNoisyApproxSfmAggregate(
       overwrite);
 
   exec::registerAggregateFunction(
-      prefix + kNoisyApproxSetSfmFromIndexAndZeros,
+      noisyApproxSetSfmFromIndexAndZerosNames,
       setFromIndexAndZerosSignatures,
-      [prefix](
-          core::AggregationNode::Step step,
-          const std::vector<TypePtr>& /*argTypes*/,
-          const TypePtr& resultType,
-          const core::QueryConfig& /*config*/)
+      [](core::AggregationNode::Step step,
+         const std::vector<TypePtr>& /*argTypes*/,
+         const TypePtr& resultType,
+         const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
         if (exec::isPartialOutput(step)) {
           return std::make_unique<SfmSketchAggregate<true, true, false>>(
diff --git a/velox/functions/prestosql/aggregates/NoisyApproxSfmAggregate.h b/velox/functions/prestosql/aggregates/NoisyApproxSfmAggregate.h
index 7eb6937dff9..62090b5a7ce 100644
--- a/velox/functions/prestosql/aggregates/NoisyApproxSfmAggregate.h
+++ b/velox/functions/prestosql/aggregates/NoisyApproxSfmAggregate.h
@@ -17,11 +17,14 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerNoisyApproxSfmAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& noisyApproxSetSfmNames,
+    const std::vector<std::string>& noisyApproxDistinctSfmNames,
+    const std::vector<std::string>& noisyApproxSetSfmFromIndexAndZerosNames,
     bool withCompanionFunctions,
     bool overwrite);
 
diff --git a/velox/functions/prestosql/aggregates/NoisyAvgGaussianAggregate.cpp b/velox/functions/prestosql/aggregates/NoisyAvgGaussianAggregate.cpp
index 23f37b7e427..0263ad85cef 100644
--- a/velox/functions/prestosql/aggregates/NoisyAvgGaussianAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/NoisyAvgGaussianAggregate.cpp
@@ -18,7 +18,6 @@
 #include "velox/exec/Aggregate.h"
 #include "velox/expression/FunctionSignature.h"
 #include "velox/functions/lib/aggregates/noisy_aggregation/NoisyCountSumAvgAccumulator.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/functions/prestosql/aggregates/NoisyHelperFunctionFactory.h"
 #include "velox/vector/FlatVector.h"
 
@@ -220,7 +219,7 @@ class NoisyAvgGaussianAggregate : public exec::Aggregate {
 } // namespace
 
 void registerNoisyAvgGaussianAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   // Helper function to create a signature builder with return and
@@ -245,101 +244,108 @@ void registerNoisyAvgGaussianAggregate(
     // Handle simple types.
     for (const auto& dataType : simpleDataTypes) {
       // Signature 1: (col, noise_scale)
-      signatures.push_back(createBuilder()
-                               .argumentType(dataType)
-                               .argumentType(noiseScaleType)
-                               .build());
+      signatures.push_back(
+          createBuilder()
+              .argumentType(dataType)
+              .argumentType(noiseScaleType)
+              .build());
       // Signature 2: (col, noise_scale, random_seed)
-      signatures.push_back(createBuilder()
-                               .argumentType(dataType)
-                               .argumentType(noiseScaleType)
-                               .argumentType(randomSeedType)
-                               .build());
+      signatures.push_back(
+          createBuilder()
+              .argumentType(dataType)
+              .argumentType(noiseScaleType)
+              .argumentType(randomSeedType)
+              .build());
 
       for (const auto& lowerBoundType : boundTypes) {
         for (const auto& upperBoundType : boundTypes) {
           // Signature 3: (col, noise_scale, lower_bound, upper_bound)
-          signatures.push_back(createBuilder()
-                                   .argumentType(dataType)
-                                   .argumentType(noiseScaleType)
-                                   .argumentType(lowerBoundType)
-                                   .argumentType(upperBoundType)
-                                   .build());
+          signatures.push_back(
+              createBuilder()
+                  .argumentType(dataType)
+                  .argumentType(noiseScaleType)
+                  .argumentType(lowerBoundType)
+                  .argumentType(upperBoundType)
+                  .build());
           // Signature 4: (col, noise_scale, lower_bound, upper_bound,
           // random_seed)
-          signatures.push_back(createBuilder()
-                                   .argumentType(dataType)
-                                   .argumentType(noiseScaleType)
-                                   .argumentType(lowerBoundType)
-                                   .argumentType(upperBoundType)
-                                   .argumentType(randomSeedType)
-                                   .build());
+          signatures.push_back(
+              createBuilder()
+                  .argumentType(dataType)
+                  .argumentType(noiseScaleType)
+                  .argumentType(lowerBoundType)
+                  .argumentType(upperBoundType)
+                  .argumentType(randomSeedType)
+                  .build());
         }
       }
     }
     // Handle decimal types separately.
     // Signature 1: (col, noise_scale)
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .integerVariable("a_precision")
-                             .integerVariable("a_scale")
-                             .returnType("double")
-                             .intermediateType("varbinary")
-                             .argumentType("DECIMAL(a_precision, a_scale)")
-                             .argumentType(noiseScaleType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .integerVariable("a_precision")
+            .integerVariable("a_scale")
+            .returnType("double")
+            .intermediateType("varbinary")
+            .argumentType("DECIMAL(a_precision, a_scale)")
+            .argumentType(noiseScaleType)
+            .build());
     // Signature 2: (col, noise_scale, random_seed)
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .integerVariable("a_precision")
-                             .integerVariable("a_scale")
-                             .returnType("double")
-                             .intermediateType("varbinary")
-                             .argumentType("DECIMAL(a_precision, a_scale)")
-                             .argumentType(noiseScaleType)
-                             .argumentType(randomSeedType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .integerVariable("a_precision")
+            .integerVariable("a_scale")
+            .returnType("double")
+            .intermediateType("varbinary")
+            .argumentType("DECIMAL(a_precision, a_scale)")
+            .argumentType(noiseScaleType)
+            .argumentType(randomSeedType)
+            .build());
 
     for (const auto& lowerBoundType : boundTypes) {
       for (const auto& upperBoundType : boundTypes) {
         // Signature 3: (col, noise_scale, lower_bound, upper_bound)
-        signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                                 .integerVariable("a_precision")
-                                 .integerVariable("a_scale")
-                                 .returnType("double")
-                                 .intermediateType("varbinary")
-                                 .argumentType("DECIMAL(a_precision, a_scale)")
-                                 .argumentType(noiseScaleType)
-                                 .argumentType(lowerBoundType)
-                                 .argumentType(upperBoundType)
-                                 .build());
+        signatures.push_back(
+            exec::AggregateFunctionSignatureBuilder()
+                .integerVariable("a_precision")
+                .integerVariable("a_scale")
+                .returnType("double")
+                .intermediateType("varbinary")
+                .argumentType("DECIMAL(a_precision, a_scale)")
+                .argumentType(noiseScaleType)
+                .argumentType(lowerBoundType)
+                .argumentType(upperBoundType)
+                .build());
         // Signature 4: (col, noise_scale, lower_bound, upper_bound,
         // random_seed)
-        signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                                 .integerVariable("a_precision")
-                                 .integerVariable("a_scale")
-                                 .returnType("double")
-                                 .intermediateType("varbinary")
-                                 .argumentType("DECIMAL(a_precision, a_scale)")
-                                 .argumentType(noiseScaleType)
-                                 .argumentType(lowerBoundType)
-                                 .argumentType(upperBoundType)
-                                 .argumentType(randomSeedType)
-                                 .build());
+        signatures.push_back(
+            exec::AggregateFunctionSignatureBuilder()
+                .integerVariable("a_precision")
+                .integerVariable("a_scale")
+                .returnType("double")
+                .intermediateType("varbinary")
+                .argumentType("DECIMAL(a_precision, a_scale)")
+                .argumentType(noiseScaleType)
+                .argumentType(lowerBoundType)
+                .argumentType(upperBoundType)
+                .argumentType(randomSeedType)
+                .build());
       }
     }
   }
 
-  auto name = prefix + kNoisyAvgGaussian;
   exec::registerAggregateFunction(
-      name,
+      names,
       signatures,
-      [name](
+      [names](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& /*resultType*/,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
         VELOX_CHECK_GE(
-            argTypes.size(), 2, "{} takes at least 2 arguments", name);
+            argTypes.size(), 2, "{} takes at least 2 arguments", names.front());
 
         if (exec::isPartialOutput(step)) {
           return std::make_unique<NoisyAvgGaussianAggregate>(VARBINARY());
diff --git a/velox/functions/prestosql/aggregates/NoisyAvgGaussianAggregate.h b/velox/functions/prestosql/aggregates/NoisyAvgGaussianAggregate.h
index 6aae61c2571..28927c655f3 100644
--- a/velox/functions/prestosql/aggregates/NoisyAvgGaussianAggregate.h
+++ b/velox/functions/prestosql/aggregates/NoisyAvgGaussianAggregate.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerNoisyAvgGaussianAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 
diff --git a/velox/functions/prestosql/aggregates/NoisyCountGaussianAggregate.cpp b/velox/functions/prestosql/aggregates/NoisyCountGaussianAggregate.cpp
index f6f5fa4c41b..751a1d3346c 100644
--- a/velox/functions/prestosql/aggregates/NoisyCountGaussianAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/NoisyCountGaussianAggregate.cpp
@@ -19,7 +19,6 @@
 #include "velox/exec/Aggregate.h"
 #include "velox/expression/FunctionSignature.h"
 #include "velox/functions/lib/aggregates/noisy_aggregation/NoisyCountSumAvgAccumulator.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/functions/prestosql/aggregates/NoisyHelperFunctionFactory.h"
 #include "velox/vector/FlatVector.h"
 
@@ -215,7 +214,7 @@ class NoisyCountGaussianAggregate : public exec::Aggregate {
 } // namespace
 
 void registerNoisyCountGaussianAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
@@ -251,17 +250,16 @@ void registerNoisyCountGaussianAggregate(
           .build(),
   };
 
-  auto name = prefix + kNoisyCountGaussian;
-
   exec::registerAggregateFunction(
-      name,
+      names,
       signatures,
-      [name](
+      [names](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           [[maybe_unused]] const TypePtr& resultType,
           [[maybe_unused]] const core::QueryConfig& config)
           -> std::unique_ptr<exec::Aggregate> {
+        const std::string& name = names.front();
         VELOX_CHECK_LE(
             argTypes.size(), 3, "{} takes at most 3 arguments", name);
         VELOX_CHECK_GE(
@@ -273,7 +271,7 @@ void registerNoisyCountGaussianAggregate(
 
         return std::make_unique<NoisyCountGaussianAggregate>(BIGINT());
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/NoisyCountGaussianAggregate.h b/velox/functions/prestosql/aggregates/NoisyCountGaussianAggregate.h
index 9bfda08708d..c46fc001851 100644
--- a/velox/functions/prestosql/aggregates/NoisyCountGaussianAggregate.h
+++ b/velox/functions/prestosql/aggregates/NoisyCountGaussianAggregate.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerNoisyCountGaussianAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 
diff --git a/velox/functions/prestosql/aggregates/NoisyCountIfGaussianAggregate.cpp b/velox/functions/prestosql/aggregates/NoisyCountIfGaussianAggregate.cpp
index cbdafe19822..abf90934859 100644
--- a/velox/functions/prestosql/aggregates/NoisyCountIfGaussianAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/NoisyCountIfGaussianAggregate.cpp
@@ -19,7 +19,6 @@
 #include "velox/exec/Aggregate.h"
 #include "velox/expression/FunctionSignature.h"
 #include "velox/functions/lib/aggregates/noisy_aggregation/NoisyCountSumAvgAccumulator.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/functions/prestosql/aggregates/NoisyHelperFunctionFactory.h"
 #include "velox/vector/FlatVector.h"
 
@@ -225,7 +224,7 @@ class NoisyCountIfGaussianAggregate : public exec::Aggregate {
 } // namespace
 
 void registerNoisyCountIfGaussianAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
@@ -257,16 +256,16 @@ void registerNoisyCountIfGaussianAggregate(
           .build(),
   };
 
-  auto name = prefix + kNoisyCountIfGaussian;
   exec::registerAggregateFunction(
-      name,
+      names,
       signatures,
-      [name](
+      [names](
           core::AggregationNode::Step step,
           std::vector<TypePtr> argTypes,
           const TypePtr& /*resultType*/,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
+        const std::string& name = names.front();
         VELOX_CHECK_LE(argTypes.size(), 3, "{} takes 2 or 3 arguments", name);
         VELOX_CHECK_GE(argTypes.size(), 2, "{} takes 2 or 3 arguments", name);
 
@@ -285,7 +284,7 @@ void registerNoisyCountIfGaussianAggregate(
 
         return std::make_unique<NoisyCountIfGaussianAggregate>(BIGINT());
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/NoisyCountIfGaussianAggregate.h b/velox/functions/prestosql/aggregates/NoisyCountIfGaussianAggregate.h
index 85dd889b638..a832f2951bc 100644
--- a/velox/functions/prestosql/aggregates/NoisyCountIfGaussianAggregate.h
+++ b/velox/functions/prestosql/aggregates/NoisyCountIfGaussianAggregate.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerNoisyCountIfGaussianAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/NoisySumGaussianAggregate.cpp b/velox/functions/prestosql/aggregates/NoisySumGaussianAggregate.cpp
index 2fccbce62a7..eeeb69cc480 100644
--- a/velox/functions/prestosql/aggregates/NoisySumGaussianAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/NoisySumGaussianAggregate.cpp
@@ -17,7 +17,6 @@
 #include "velox/exec/Aggregate.h"
 #include "velox/expression/FunctionSignature.h"
 #include "velox/functions/lib/aggregates/noisy_aggregation/NoisyCountSumAvgAccumulator.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/functions/prestosql/aggregates/NoisyHelperFunctionFactory.h"
 #include "velox/vector/FlatVector.h"
 
@@ -211,7 +210,7 @@ class NoisySumGaussianAggregate : public exec::Aggregate {
 } // namespace
 
 void registerNoisySumGaussianAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   // Helper function to create a signature builder with return and
@@ -236,99 +235,107 @@ void registerNoisySumGaussianAggregate(
     // Handle simple types.
     for (const auto& dataType : simpleDataTypes) {
       // Signature 1: (col, noise_scale)
-      signatures.push_back(createBuilder()
-                               .argumentType(dataType)
-                               .argumentType(noiseScaleType)
-                               .build());
+      signatures.push_back(
+          createBuilder()
+              .argumentType(dataType)
+              .argumentType(noiseScaleType)
+              .build());
       // Signature 2: (col, noise_scale, random_seed)
-      signatures.push_back(createBuilder()
-                               .argumentType(dataType)
-                               .argumentType(noiseScaleType)
-                               .argumentType(randomSeedType)
-                               .build());
+      signatures.push_back(
+          createBuilder()
+              .argumentType(dataType)
+              .argumentType(noiseScaleType)
+              .argumentType(randomSeedType)
+              .build());
 
       for (const auto& lowerBoundType : boundTypes) {
         for (const auto& upperBoundType : boundTypes) {
           // Signature 3: (col, noise_scale, lower_bound, upper_bound)
-          signatures.push_back(createBuilder()
-                                   .argumentType(dataType)
-                                   .argumentType(noiseScaleType)
-                                   .argumentType(lowerBoundType)
-                                   .argumentType(upperBoundType)
-                                   .build());
+          signatures.push_back(
+              createBuilder()
+                  .argumentType(dataType)
+                  .argumentType(noiseScaleType)
+                  .argumentType(lowerBoundType)
+                  .argumentType(upperBoundType)
+                  .build());
           // Signature 4: (col, noise_scale, lower_bound, upper_bound,
           // random_seed)
-          signatures.push_back(createBuilder()
-                                   .argumentType(dataType)
-                                   .argumentType(noiseScaleType)
-                                   .argumentType(lowerBoundType)
-                                   .argumentType(upperBoundType)
-                                   .argumentType(randomSeedType)
-                                   .build());
+          signatures.push_back(
+              createBuilder()
+                  .argumentType(dataType)
+                  .argumentType(noiseScaleType)
+                  .argumentType(lowerBoundType)
+                  .argumentType(upperBoundType)
+                  .argumentType(randomSeedType)
+                  .build());
         }
       }
     }
     // Handle decimal types separately.
     // Signature 1: (col, noise_scale)
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .integerVariable("a_precision")
-                             .integerVariable("a_scale")
-                             .returnType("double")
-                             .intermediateType("varbinary")
-                             .argumentType("DECIMAL(a_precision, a_scale)")
-                             .argumentType(noiseScaleType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .integerVariable("a_precision")
+            .integerVariable("a_scale")
+            .returnType("double")
+            .intermediateType("varbinary")
+            .argumentType("DECIMAL(a_precision, a_scale)")
+            .argumentType(noiseScaleType)
+            .build());
     // Signature 2: (col, noise_scale, random_seed)
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .integerVariable("a_precision")
-                             .integerVariable("a_scale")
-                             .returnType("double")
-                             .intermediateType("varbinary")
-                             .argumentType("DECIMAL(a_precision, a_scale)")
-                             .argumentType(noiseScaleType)
-                             .argumentType(randomSeedType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .integerVariable("a_precision")
+            .integerVariable("a_scale")
+            .returnType("double")
+            .intermediateType("varbinary")
+            .argumentType("DECIMAL(a_precision, a_scale)")
+            .argumentType(noiseScaleType)
+            .argumentType(randomSeedType)
+            .build());
 
     for (const auto& lowerBoundType : boundTypes) {
       for (const auto& upperBoundType : boundTypes) {
         // Signature 3: (col, noise_scale, lower_bound, upper_bound)
-        signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                                 .integerVariable("a_precision")
-                                 .integerVariable("a_scale")
-                                 .returnType("double")
-                                 .intermediateType("varbinary")
-                                 .argumentType("DECIMAL(a_precision, a_scale)")
-                                 .argumentType(noiseScaleType)
-                                 .argumentType(lowerBoundType)
-                                 .argumentType(upperBoundType)
-                                 .build());
+        signatures.push_back(
+            exec::AggregateFunctionSignatureBuilder()
+                .integerVariable("a_precision")
+                .integerVariable("a_scale")
+                .returnType("double")
+                .intermediateType("varbinary")
+                .argumentType("DECIMAL(a_precision, a_scale)")
+                .argumentType(noiseScaleType)
+                .argumentType(lowerBoundType)
+                .argumentType(upperBoundType)
+                .build());
         // Signature 4: (col, noise_scale, lower_bound, upper_bound,
         // random_seed)
-        signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                                 .integerVariable("a_precision")
-                                 .integerVariable("a_scale")
-                                 .returnType("double")
-                                 .intermediateType("varbinary")
-                                 .argumentType("DECIMAL(a_precision, a_scale)")
-                                 .argumentType(noiseScaleType)
-                                 .argumentType(lowerBoundType)
-                                 .argumentType(upperBoundType)
-                                 .argumentType(randomSeedType)
-                                 .build());
+        signatures.push_back(
+            exec::AggregateFunctionSignatureBuilder()
+                .integerVariable("a_precision")
+                .integerVariable("a_scale")
+                .returnType("double")
+                .intermediateType("varbinary")
+                .argumentType("DECIMAL(a_precision, a_scale)")
+                .argumentType(noiseScaleType)
+                .argumentType(lowerBoundType)
+                .argumentType(upperBoundType)
+                .argumentType(randomSeedType)
+                .build());
       }
     }
   }
 
-  auto name = prefix + kNoisySumGaussian;
   exec::registerAggregateFunction(
-      name,
+      names,
       signatures,
-      [name](
+      [names](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           [[maybe_unused]] const TypePtr& resultType,
           [[maybe_unused]] const core::QueryConfig&)
           -> std::unique_ptr<exec::Aggregate> {
+        const std::string& name = names.front();
         VELOX_CHECK_GE(
             argTypes.size(), 2, "{} takes at least 2 arguments", name);
         VELOX_CHECK_LE(
@@ -339,7 +346,7 @@ void registerNoisySumGaussianAggregate(
         }
         return std::make_unique<NoisySumGaussianAggregate>(DOUBLE());
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/NoisySumGaussianAggregate.h b/velox/functions/prestosql/aggregates/NoisySumGaussianAggregate.h
index c078beba66b..29258e80237 100644
--- a/velox/functions/prestosql/aggregates/NoisySumGaussianAggregate.h
+++ b/velox/functions/prestosql/aggregates/NoisySumGaussianAggregate.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerNoisySumGaussianAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 
diff --git a/velox/functions/prestosql/aggregates/NumericHistogramAggregate.cpp b/velox/functions/prestosql/aggregates/NumericHistogramAggregate.cpp
index 2cee906b8e8..6f8f0ef83b4 100644
--- a/velox/functions/prestosql/aggregates/NumericHistogramAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/NumericHistogramAggregate.cpp
@@ -16,10 +16,10 @@
 #include "velox/common/base/IOUtils.h"
 #include "velox/exec/Aggregate.h"
 #include "velox/expression/FunctionSignature.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 
 #include <algorithm>
 #include <limits>
+#include <memory>
 #include <queue>
 
 #include <vector>
@@ -188,20 +188,23 @@ class NumericHistogram {
 
   // Initialize a priority queue with Entries for each value and weight
   std::priority_queue<Entry*, std::vector<Entry*>, Entry::Compare> initQueue(
-      std::vector<Entry*>& allocatedEntries) {
+      std::vector<std::unique_ptr<Entry>>& allocatedEntries) {
     VELOX_CHECK_GE(values_.size(), nextIndex_);
     VELOX_CHECK_GE(weights_.size(), nextIndex_);
 
     std::priority_queue<Entry*, std::vector<Entry*>, Entry::Compare> queue;
-    Entry* right = new Entry(
+    auto right = std::make_unique<Entry>(
         nextIndex_ - 1, values_[nextIndex_ - 1], weights_[nextIndex_ - 1]);
-    allocatedEntries.push_back(right);
-    queue.push(right);
+    auto* rightPtr = right.get();
+    queue.push(rightPtr);
+    allocatedEntries.push_back(std::move(right));
     for (int i = nextIndex_ - 2; i >= 0; i--) {
-      Entry* current = new Entry(i, values_[i], weights_[i], right);
-      queue.push(current);
-      allocatedEntries.push_back(current);
-      right = current;
+      auto current =
+          std::make_unique<Entry>(i, values_[i], weights_[i], rightPtr);
+      auto* currentPtr = current.get();
+      queue.push(currentPtr);
+      allocatedEntries.push_back(std::move(current));
+      rightPtr = currentPtr;
     }
 
     return queue;
@@ -213,7 +216,7 @@ class NumericHistogram {
       return;
     }
 
-    std::vector<Entry*> allocatedEntries;
+    std::vector<std::unique_ptr<Entry>> allocatedEntries;
     auto queue = initQueue(allocatedEntries);
 
     // Merge and reduce entries in queue until the count is equal to targetCount
@@ -244,11 +247,11 @@ class NumericHistogram {
                          right->value_ * right->weight_) /
           newWeight;
 
-      Entry* merged =
-          new Entry(current->id_, newValue, newWeight, right->right_);
-
-      allocatedEntries.push_back(merged);
-      queue.push(merged);
+      auto merged = std::make_unique<Entry>(
+          current->id_, newValue, newWeight, right->right_);
+      auto* mergedPtr = merged.get();
+      queue.push(mergedPtr);
+      allocatedEntries.push_back(std::move(merged));
 
       // Update left's penalty
       Entry* left = current->left_;
@@ -256,10 +259,10 @@ class NumericHistogram {
         VELOX_CHECK(left->valid_, "Left entry is not valid");
 
         left->invalidate();
-        Entry* newLeft = new Entry(
-            left->id_, left->value_, left->weight_, merged, left->left_);
-        allocatedEntries.push_back(newLeft);
-        queue.push(newLeft);
+        auto newLeft = std::make_unique<Entry>(
+            left->id_, left->value_, left->weight_, mergedPtr, left->left_);
+        queue.push(newLeft.get());
+        allocatedEntries.push_back(std::move(newLeft));
       }
     }
     // Re populate values_ and weights_ with the reduced queue
@@ -275,9 +278,6 @@ class NumericHistogram {
     }
 
     sortValuesAndWeights();
-    for (Entry* entry : allocatedEntries) {
-      delete entry;
-    }
   }
   // Following Java Standard:
   // https://docs.oracle.com/javase/7/docs/api/java/lang/Double.html#compare(double,%20double)
@@ -303,6 +303,9 @@ class NumericHistogram {
 
   // Merge same buckets in place and update nextIndex_
   void mergeSameBuckets() {
+    if (nextIndex_ <= 1) {
+      return;
+    }
     sortValuesAndWeights();
     VELOX_CHECK_GE(values_.size(), nextIndex_);
     VELOX_CHECK_GE(weights_.size(), nextIndex_);
@@ -475,7 +478,7 @@ class NumericHistogramAggregate<TValue, TWeight, 3> {
 } // namespace
 
 void registerNumericHistogramAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
@@ -485,47 +488,49 @@ void registerNumericHistogramAggregate(
   const auto weightTypes = {"real", "double"};
   for (const auto& valueType : valueTypes) {
     const auto returnType = fmt::format("map({}, {})", valueType, valueType);
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType(returnType)
-                             .intermediateType("varbinary")
-                             .argumentType("bigint")
-                             .argumentType(valueType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType(returnType)
+            .intermediateType("varbinary")
+            .argumentType("bigint")
+            .argumentType(valueType)
+            .build());
     for (const auto& weightType : weightTypes) {
-      signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                               .returnType(returnType)
-                               .intermediateType("varbinary")
-                               .argumentType("bigint")
-                               .argumentType(valueType)
-                               .argumentType(weightType)
-                               .build());
+      signatures.push_back(
+          exec::AggregateFunctionSignatureBuilder()
+              .returnType(returnType)
+              .intermediateType("varbinary")
+              .argumentType("bigint")
+              .argumentType(valueType)
+              .argumentType(weightType)
+              .build());
     }
   }
-  auto name = prefix + kNumericHistogram;
 
   exec::registerAggregateFunction(
-      name,
-      signatures,
-      [name](
+      names,
+      std::move(signatures),
+      [names](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
+        const std::string& name = names.front();
         VELOX_USER_CHECK_GE(
             argTypes.size(), 2, "{} takes at least two arguments", name);
         VELOX_USER_CHECK_LE(
             argTypes.size(), 3, "{} takes at most three arguments", name);
         if (argTypes[0]->kind() != TypeKind::BIGINT) {
           VELOX_USER_FAIL(
-              "Aggregation {}: Buckets must be bigint {}, but is {}",
+              "Aggregation {}: Buckets must be bigint, but is {}",
               name,
               argTypes[0]->kindName());
         }
         if (argTypes[1]->kind() != TypeKind::REAL &&
             argTypes[1]->kind() != TypeKind::DOUBLE) {
           VELOX_USER_FAIL(
-              "Aggregation {}: Value must be REAL or DOUBLE {}, but is {}",
+              "Aggregation {}: Value must be REAL or DOUBLE, but is {}",
               name,
               argTypes[1]->kindName());
         }
@@ -541,16 +546,16 @@ void registerNumericHistogramAggregate(
                   step, argTypes, resultType);
 
             default:
-              VELOX_USER_FAIL("Unknown input type for {} aggregation {}", name);
+              VELOX_USER_FAIL("Unknown input type for aggregation {}", name);
           }
         } else {
           // argTypes.size() == 3
           if (argTypes[2]->kind() != TypeKind::REAL &&
               argTypes[2]->kind() != TypeKind::DOUBLE) {
             VELOX_USER_FAIL(
-                "Aggregation {}: Weight must be REAL or DOUBLE {}, but is {}",
+                "Aggregation {}: Weight must be REAL or DOUBLE, but is {}",
                 name,
-                argTypes[1]->kindName());
+                argTypes[2]->kindName());
           }
           switch (argTypes[1]->kind()) {
             case TypeKind::REAL:
@@ -582,7 +587,7 @@ void registerNumericHistogramAggregate(
                       "Unknown weight type for aggregation {}", name);
               }
             default:
-              VELOX_USER_FAIL("Unknown input type for {} aggregation {}", name);
+              VELOX_USER_FAIL("Unknown input type for aggregation {}", name);
           }
         }
       },
diff --git a/velox/functions/prestosql/aggregates/NumericHistogramAggregate.h b/velox/functions/prestosql/aggregates/NumericHistogramAggregate.h
index fea9d905e8e..6dd6fd8356d 100644
--- a/velox/functions/prestosql/aggregates/NumericHistogramAggregate.h
+++ b/velox/functions/prestosql/aggregates/NumericHistogramAggregate.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerNumericHistogramAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/PrestoHasher.cpp b/velox/functions/prestosql/aggregates/PrestoHasher.cpp
index b6fff3a2e61..c3ae6d07b93 100644
--- a/velox/functions/prestosql/aggregates/PrestoHasher.cpp
+++ b/velox/functions/prestosql/aggregates/PrestoHasher.cpp
@@ -17,8 +17,7 @@
 
 #include <type_traits>
 
-#define XXH_INLINE_ALL
-#include <xxhash.h> // @manual=third-party//xxHash:xxhash
+#include "velox/common/base/XxHashInline.h"
 
 #include "velox/functions/lib/RowsTranslationUtil.h"
 #include "velox/functions/prestosql/types/IPAddressType.h"
@@ -104,8 +103,7 @@ FOLLY_ALWAYS_INLINE void hashFloating(
 #if defined(__clang__)
 __attribute__((no_sanitize("integer")))
 #endif
-FOLLY_ALWAYS_INLINE int64_t
-safeHash(const int64_t& a, const int64_t& b) {
+FOLLY_ALWAYS_INLINE int64_t safeHash(const int64_t& a, const int64_t& b) {
   return a * 31 + b;
 }
 
diff --git a/velox/functions/prestosql/aggregates/QDigestAggAggregate.cpp b/velox/functions/prestosql/aggregates/QDigestAggAggregate.cpp
index feb86e9ba73..651532ac23b 100644
--- a/velox/functions/prestosql/aggregates/QDigestAggAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/QDigestAggAggregate.cpp
@@ -20,7 +20,6 @@
 #include "velox/exec/SimpleAggregateAdapter.h"
 #include "velox/expression/FunctionSignature.h"
 #include "velox/functions/lib/QuantileDigest.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/functions/prestosql/types/QDigestRegistration.h"
 
 using namespace facebook::velox::exec;
@@ -84,15 +83,13 @@ struct QDigestAccumulator {
   void checkSetAccuracy(double accuracy) {
     VELOX_USER_CHECK(
         accuracy > 0.0 && accuracy < 1.0,
-        "{}: accuracy must be in range (0.0, 1.0), got {}",
-        kQDigestAgg,
+        "accuracy must be in range (0.0, 1.0), got {}",
         accuracy);
     if (digest.getMaxError() == kUninitializedMaxError) {
       digest.setMaxError(accuracy);
     } else if (digest.getMaxError() != accuracy) {
       VELOX_USER_FAIL(
-          "{}: accuracy must be the same for all rows in the group, got {} and {}",
-          kQDigestAgg,
+          "accuracy must be the same for all rows in the group, got {} and {}",
           digest.getMaxError(),
           accuracy);
     }
@@ -174,41 +171,44 @@ std::unique_ptr<exec::Aggregate> createQDigestAggAggregate(
 
 } // namespace
 
-void registerQDigestAggAggregate(const std::string& prefix, bool overwrite) {
+void registerQDigestAggAggregate(
+    const std::vector<std::string>& names,
+    bool overwrite) {
   registerQDigestType();
 
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
   for (const auto& type : {"bigint", "real", "double"}) {
     const auto digestType = fmt::format("qdigest({})", type);
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType(digestType)
-                             .intermediateType(digestType)
-                             .argumentType(type)
-                             .build());
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType(digestType)
-                             .intermediateType(digestType)
-                             .argumentType(type)
-                             .argumentType("bigint")
-                             .build());
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType(digestType)
-                             .intermediateType(digestType)
-                             .argumentType(type)
-                             .argumentType("bigint")
-                             .argumentType("double")
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType(digestType)
+            .intermediateType("varbinary")
+            .argumentType(type)
+            .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType(digestType)
+            .intermediateType("varbinary")
+            .argumentType(type)
+            .argumentType("bigint")
+            .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType(digestType)
+            .intermediateType("varbinary")
+            .argumentType(type)
+            .argumentType("bigint")
+            .argumentType("double")
+            .build());
   }
 
-  auto name = prefix + kQDigestAgg;
   exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
-          core::AggregationNode::Step step,
-          const std::vector<TypePtr>& argTypes,
-          const TypePtr& resultType,
-          const core::QueryConfig& /*config*/)
+      [](core::AggregationNode::Step step,
+         const std::vector<TypePtr>& argTypes,
+         const TypePtr& resultType,
+         const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
         if (argTypes.size() == 1) {
           return createQDigestAggAggregate<1>(step, argTypes, resultType);
diff --git a/velox/functions/prestosql/aggregates/QDigestAggAggregate.h b/velox/functions/prestosql/aggregates/QDigestAggAggregate.h
index 2e6c5ddb30e..7cc898bb7b5 100644
--- a/velox/functions/prestosql/aggregates/QDigestAggAggregate.h
+++ b/velox/functions/prestosql/aggregates/QDigestAggAggregate.h
@@ -17,9 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
-void registerQDigestAggAggregate(const std::string& prefix, bool overwrite);
+void registerQDigestAggAggregate(
+    const std::vector<std::string>& names,
+    bool overwrite);
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/ReduceAgg.cpp b/velox/functions/prestosql/aggregates/ReduceAgg.cpp
index a651da01f92..20de3c4866e 100644
--- a/velox/functions/prestosql/aggregates/ReduceAgg.cpp
+++ b/velox/functions/prestosql/aggregates/ReduceAgg.cpp
@@ -19,7 +19,6 @@
 #include "velox/expression/Expr.h"
 #include "velox/expression/FunctionSignature.h"
 #include "velox/functions/lib/aggregates/SingleValueAccumulator.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 
 namespace facebook::velox::aggregate::prestosql {
 namespace {
@@ -571,6 +570,12 @@ class ReduceAgg : public exec::Aggregate {
       }
     });
 
+    if (rawInput && numNotNull > 0) {
+      // Validate the initial value on the original input rows before group-by
+      // aggregation reorders values for lambda evaluation.
+      verifyInitialValueArg(args[1], rows);
+    }
+
     const auto numGroups = uniqueGroups.size();
 
     std::vector<vector_size_t> groupCounts(numGroups, 0);
@@ -791,7 +796,7 @@ class ReduceAgg : public exec::Aggregate {
 } // namespace
 
 void registerReduceAgg(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
@@ -806,19 +811,16 @@ void registerReduceAgg(
           .argumentType("function(S,S,S)")
           .build()};
 
-  const std::string name = prefix + kReduceAgg;
-
   exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
-          core::AggregationNode::Step step,
-          const std::vector<TypePtr>& argTypes,
-          const TypePtr& resultType,
-          const core::QueryConfig& config) -> std::unique_ptr<exec::Aggregate> {
+      [](core::AggregationNode::Step step,
+         const std::vector<TypePtr>& argTypes,
+         const TypePtr& resultType,
+         const core::QueryConfig& config) -> std::unique_ptr<exec::Aggregate> {
         return std::make_unique<ReduceAgg>(resultType);
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/ReduceAgg.h b/velox/functions/prestosql/aggregates/ReduceAgg.h
index e136f779432..074f78c664a 100644
--- a/velox/functions/prestosql/aggregates/ReduceAgg.h
+++ b/velox/functions/prestosql/aggregates/ReduceAgg.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerReduceAgg(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/RegisterAggregateFunctions.cpp b/velox/functions/prestosql/aggregates/RegisterAggregateFunctions.cpp
index 18126b789b1..da6abc5d550 100644
--- a/velox/functions/prestosql/aggregates/RegisterAggregateFunctions.cpp
+++ b/velox/functions/prestosql/aggregates/RegisterAggregateFunctions.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 #include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
+#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/functions/prestosql/aggregates/ApproxDistinctAggregates.h"
 #include "velox/functions/prestosql/aggregates/ApproxMostFrequentAggregate.h"
 #include "velox/functions/prestosql/aggregates/ApproxPercentileAggregate.h"
@@ -32,6 +33,7 @@
 #include "velox/functions/prestosql/aggregates/EntropyAggregates.h"
 #include "velox/functions/prestosql/aggregates/GeometricMeanAggregate.h"
 #include "velox/functions/prestosql/aggregates/HistogramAggregate.h"
+#include "velox/functions/prestosql/aggregates/KHyperLogLogAggregate.h"
 #include "velox/functions/prestosql/aggregates/MapAggAggregate.h"
 #include "velox/functions/prestosql/aggregates/MapUnionAggregate.h"
 #include "velox/functions/prestosql/aggregates/MapUnionSumAggregate.h"
@@ -49,150 +51,271 @@
 #include "velox/functions/prestosql/aggregates/NumericHistogramAggregate.h"
 #include "velox/functions/prestosql/aggregates/QDigestAggAggregate.h"
 #include "velox/functions/prestosql/aggregates/ReduceAgg.h"
+#include "velox/functions/prestosql/aggregates/ReservoirSampleAggregate.h"
 #include "velox/functions/prestosql/aggregates/SetAggregates.h"
+#include "velox/functions/prestosql/aggregates/SetDigestAggregate.h"
 #include "velox/functions/prestosql/aggregates/SumAggregate.h"
 #include "velox/functions/prestosql/aggregates/SumDataSizeForStatsAggregate.h"
 #include "velox/functions/prestosql/aggregates/VarianceAggregates.h"
+#include "velox/functions/prestosql/aggregates/VectorSumAggregate.h"
 #include "velox/functions/prestosql/types/JsonRegistration.h"
+#include "velox/functions/prestosql/types/KHyperLogLogRegistration.h"
+#include "velox/functions/prestosql/types/SetDigestRegistration.h"
 #include "velox/functions/prestosql/types/TDigestRegistration.h"
+#ifdef VELOX_ENABLE_GEO
+#include "velox/functions/prestosql/aggregates/GeometryAggregate.h"
+#endif
 
 namespace facebook::velox::aggregate::prestosql {
 
 extern void registerApproxMostFrequentAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 extern void registerApproxPercentileAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 extern void registerArbitraryAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 extern void registerArrayAggAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 extern void registerAverageAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 extern void registerBitwiseXorAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool onlyPrestoSignatures,
     bool overwrite);
 extern void registerChecksumAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
-extern void registerClassificationFunctions(
-    const std::string& prefix,
+extern void registerFalloutAggregation(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerPrecisionAggregation(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerRecallAggregation(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerMissRateAggregation(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerThresholdAggregation(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 extern void registerCountAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 extern void registerCountIfAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 extern void registerEntropyAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 extern void registerGeometricMeanAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
+#ifdef VELOX_ENABLE_GEO
+extern void registerGeometryAggregate(
+    const std::vector<std::string>& convexHullNames,
+    const std::vector<std::string>& geometryUnionNames,
+    bool overwrite);
+#endif
 extern void registerHistogramAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 extern void registerMapAggAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 extern void registerMapUnionAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 extern void registerMapUnionSumAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerMakeSetDigestAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerMergeSetDigestAggregate(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 extern void registerMaxDataSizeForStatsAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 extern void registerMultiMapAggAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 extern void registerSumDataSizeForStatsAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 extern void registerReduceAgg(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 extern void registerSetAggAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 extern void registerSetUnionAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 
 extern void registerApproxDistinctAggregates(
-    const std::string& prefix,
+    const std::vector<std::string>& approxDistinctNames,
+    const std::vector<std::string>& approxSetNames,
     bool withCompanionFunctions,
     bool overwrite);
-extern void registerBitwiseAggregates(
-    const std::string& prefix,
+extern void registerBitwiseAndAggregate(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool onlyPrestoSignatures,
     bool overwrite);
-extern void registerBoolAggregates(
-    const std::string& prefix,
+extern void registerBitwiseOrAggregate(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
+    bool onlyPrestoSignatures,
     bool overwrite);
-extern void registerCentralMomentsAggregates(
-    const std::string& prefix,
+extern void registerBoolAndAggregate(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
-extern void registerCovarianceAggregates(
-    const std::string& prefix,
+extern void registerBoolOrAggregate(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
-extern void registerMinMaxAggregates(
-    const std::string& prefix,
+extern void registerKurtosisAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerSkewnessAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerCovarPopAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerCovarSampAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerCorrAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerRegrInterceptAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerRegrSlopeAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerRegrCountAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerRegrAvgyAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerRegrAvgxAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerRegrSxyAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerRegrSxxAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerRegrSyyAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerRegrR2Aggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerMinAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerMaxAggregate(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 extern void registerMaxByAggregates(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 extern void registerMinByAggregates(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 extern void registerSumAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
-extern void registerVarianceAggregates(
-    const std::string& prefix,
+extern void registerStdDevSampAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerStdDevPopAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerVarSampAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerVarPopAggregate(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 extern void registerTDigestAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
+    bool overwrite);
+extern void registerApproxWinsorizedMeanAggregate(
+    const std::vector<std::string>& names,
+    bool overwrite);
+extern void registerKHyperLogLogAggregates(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
+extern void registerQDigestAggAggregate(
+    const std::vector<std::string>& names,
+    bool overwrite);
 
 void registerAllAggregateFunctions(
     const std::string& prefix,
@@ -200,62 +323,170 @@ void registerAllAggregateFunctions(
     bool onlyPrestoSignatures,
     bool overwrite) {
   registerJsonType();
+  registerSetDigestType();
   registerTDigestType();
-  registerApproxDistinctAggregates(prefix, withCompanionFunctions, overwrite);
+  registerKHyperLogLogType();
+  registerApproxDistinctAggregates(
+      {prefix + kApproxDistinct},
+      {prefix + kApproxSet},
+      withCompanionFunctions,
+      overwrite);
   registerApproxMostFrequentAggregate(
-      prefix, withCompanionFunctions, overwrite);
-  registerApproxPercentileAggregate(prefix, withCompanionFunctions, overwrite);
-  registerQDigestAggAggregate(prefix, overwrite);
-  registerArbitraryAggregate(prefix, withCompanionFunctions, overwrite);
-  registerArrayAggAggregate(prefix, withCompanionFunctions, overwrite);
-  registerAverageAggregate(prefix, withCompanionFunctions, overwrite);
-  registerBitwiseAggregates(
-      prefix, withCompanionFunctions, onlyPrestoSignatures, overwrite);
+      {prefix + kApproxMostFrequent}, withCompanionFunctions, overwrite);
+  registerApproxPercentileAggregate(
+      {prefix + kApproxPercentile}, withCompanionFunctions, overwrite);
+  registerQDigestAggAggregate({prefix + kQDigestAgg}, overwrite);
+  registerArbitraryAggregate(
+      {prefix + kArbitrary, prefix + kAnyValue},
+      withCompanionFunctions,
+      overwrite);
+  registerArrayAggAggregate(
+      {prefix + kArrayAgg}, withCompanionFunctions, overwrite);
+  registerVectorSumAggregate(
+      {prefix + kVectorSum}, withCompanionFunctions, overwrite);
+  registerAverageAggregate({prefix + kAvg}, withCompanionFunctions, overwrite);
+  registerBitwiseAndAggregate(
+      {prefix + kBitwiseAnd},
+      withCompanionFunctions,
+      onlyPrestoSignatures,
+      overwrite);
+  registerBitwiseOrAggregate(
+      {prefix + kBitwiseOr},
+      withCompanionFunctions,
+      onlyPrestoSignatures,
+      overwrite);
   registerBitwiseXorAggregate(
-      prefix, withCompanionFunctions, onlyPrestoSignatures, overwrite);
-  registerBoolAggregates(prefix, withCompanionFunctions, overwrite);
-  registerCentralMomentsAggregates(prefix, withCompanionFunctions, overwrite);
-  registerChecksumAggregate(prefix, withCompanionFunctions, overwrite);
-  registerClassificationFunctions(prefix, withCompanionFunctions, overwrite);
-  registerCountAggregate(prefix, withCompanionFunctions, overwrite);
-  registerCountIfAggregate(prefix, withCompanionFunctions, overwrite);
-  registerCovarianceAggregates(prefix, withCompanionFunctions, overwrite);
-  registerEntropyAggregate(prefix, withCompanionFunctions, overwrite);
-  registerGeometricMeanAggregate(prefix, withCompanionFunctions, overwrite);
-  registerHistogramAggregate(prefix, withCompanionFunctions, overwrite);
-  registerMapAggAggregate(prefix, withCompanionFunctions, overwrite);
-  registerMapUnionAggregate(prefix, withCompanionFunctions, overwrite);
-  registerMapUnionSumAggregate(prefix, withCompanionFunctions, overwrite);
+      {prefix + kBitwiseXor},
+      withCompanionFunctions,
+      onlyPrestoSignatures,
+      overwrite);
+  registerBoolAndAggregate(
+      {prefix + kEvery, prefix + kBoolAnd}, withCompanionFunctions, overwrite);
+  registerBoolOrAggregate(
+      {prefix + kBoolOr}, withCompanionFunctions, overwrite);
+  registerKurtosisAggregate(
+      {prefix + kKurtosis}, withCompanionFunctions, overwrite);
+  registerSkewnessAggregate(
+      {prefix + kSkewness}, withCompanionFunctions, overwrite);
+  registerChecksumAggregate(
+      {prefix + kChecksum}, withCompanionFunctions, overwrite);
+  registerFalloutAggregation(
+      {prefix + kClassificationFallout}, withCompanionFunctions, overwrite);
+  registerPrecisionAggregation(
+      {prefix + kClassificationPrecision}, withCompanionFunctions, overwrite);
+  registerRecallAggregation(
+      {prefix + kClassificationRecall}, withCompanionFunctions, overwrite);
+  registerMissRateAggregation(
+      {prefix + kClassificationMissRate}, withCompanionFunctions, overwrite);
+  registerThresholdAggregation(
+      {prefix + kClassificationThreshold}, withCompanionFunctions, overwrite);
+  registerCountAggregate({prefix + kCount}, withCompanionFunctions, overwrite);
+  registerCountIfAggregate(
+      {prefix + kCountIf}, withCompanionFunctions, overwrite);
+  registerCovarPopAggregate(
+      {prefix + kCovarPop}, withCompanionFunctions, overwrite);
+  registerCovarSampAggregate(
+      {prefix + kCovarSamp}, withCompanionFunctions, overwrite);
+  registerCorrAggregate({prefix + kCorr}, withCompanionFunctions, overwrite);
+  registerRegrInterceptAggregate(
+      {prefix + kRegrIntercept}, withCompanionFunctions, overwrite);
+  registerRegrSlopeAggregate(
+      {prefix + kRegrSlop}, withCompanionFunctions, overwrite);
+  registerRegrCountAggregate(
+      {prefix + kRegrCount}, withCompanionFunctions, overwrite);
+  registerRegrAvgyAggregate(
+      {prefix + kRegrAvgy}, withCompanionFunctions, overwrite);
+  registerRegrAvgxAggregate(
+      {prefix + kRegrAvgx}, withCompanionFunctions, overwrite);
+  registerRegrSxyAggregate(
+      {prefix + kRegrSxy}, withCompanionFunctions, overwrite);
+  registerRegrSxxAggregate(
+      {prefix + kRegrSxx}, withCompanionFunctions, overwrite);
+  registerRegrSyyAggregate(
+      {prefix + kRegrSyy}, withCompanionFunctions, overwrite);
+  registerRegrR2Aggregate(
+      {prefix + kRegrR2}, withCompanionFunctions, overwrite);
+  registerEntropyAggregate(
+      {prefix + kEntropy}, withCompanionFunctions, overwrite);
+  registerGeometricMeanAggregate(
+      {prefix + kGeometricMean}, withCompanionFunctions, overwrite);
+#ifdef VELOX_ENABLE_GEO
+  registerGeometryAggregate(
+      {prefix + kConvexHull}, {prefix + kGeometryUnion}, overwrite);
+#endif
+  registerHistogramAggregate(
+      {prefix + kHistogram}, withCompanionFunctions, overwrite);
+  registerMapAggAggregate(
+      {prefix + kMapAgg}, withCompanionFunctions, overwrite);
+  registerMapUnionAggregate(
+      {prefix + kMapUnion}, withCompanionFunctions, overwrite);
+  registerMapUnionSumAggregate(
+      {prefix + kMapUnionSum}, withCompanionFunctions, overwrite);
+  registerMakeSetDigestAggregate(
+      {prefix + kMakeSetDigest}, withCompanionFunctions, overwrite);
+  registerMergeSetDigestAggregate(
+      {prefix + kMergeSetDigest}, withCompanionFunctions, overwrite);
   registerMaxDataSizeForStatsAggregate(
-      prefix, withCompanionFunctions, overwrite);
-  registerMultiMapAggAggregate(prefix, withCompanionFunctions, overwrite);
+      {prefix + kMaxSizeForStats}, withCompanionFunctions, overwrite);
+  registerMultiMapAggAggregate(
+      {prefix + kMultiMapAgg}, withCompanionFunctions, overwrite);
   registerSumDataSizeForStatsAggregate(
-      prefix, withCompanionFunctions, overwrite);
-  registerMergeAggregate(prefix, withCompanionFunctions, overwrite);
-  registerMinMaxAggregates(prefix, withCompanionFunctions, overwrite);
-  registerMaxByAggregates(prefix, withCompanionFunctions, overwrite);
-  registerMinByAggregates(prefix, withCompanionFunctions, overwrite);
-  registerNoisyAvgGaussianAggregate(prefix, withCompanionFunctions, overwrite);
+      {prefix + kSumDataSizeForStats}, withCompanionFunctions, overwrite);
+  registerMergeAggregate({prefix + kMerge}, withCompanionFunctions, overwrite);
+  registerMinAggregate({prefix + kMin}, withCompanionFunctions, overwrite);
+  registerMaxAggregate({prefix + kMax}, withCompanionFunctions, overwrite);
+  registerMaxByAggregates({prefix + kMaxBy}, withCompanionFunctions, overwrite);
+  registerMinByAggregates({prefix + kMinBy}, withCompanionFunctions, overwrite);
+  registerNoisyAvgGaussianAggregate(
+      {prefix + kNoisyAvgGaussian}, withCompanionFunctions, overwrite);
   registerNoisyCountIfGaussianAggregate(
-      prefix, withCompanionFunctions, overwrite);
+      {prefix + kNoisyCountIfGaussian}, withCompanionFunctions, overwrite);
   registerNoisyCountGaussianAggregate(
-      prefix, withCompanionFunctions, overwrite);
-  registerNoisySumGaussianAggregate(prefix, withCompanionFunctions, overwrite);
-  registerReduceAgg(prefix, withCompanionFunctions, overwrite);
-  registerSetAggAggregate(prefix, withCompanionFunctions, overwrite);
-  registerSetUnionAggregate(prefix, withCompanionFunctions, overwrite);
-  registerSumAggregate(prefix, withCompanionFunctions, overwrite);
-  registerVarianceAggregates(prefix, withCompanionFunctions, overwrite);
-  registerTDigestAggregate(prefix, withCompanionFunctions, overwrite);
-  registerNoisyApproxSfmAggregate(prefix, withCompanionFunctions, overwrite);
-  registerNumericHistogramAggregate(prefix, withCompanionFunctions, overwrite);
+      {prefix + kNoisyCountGaussian}, withCompanionFunctions, overwrite);
+  registerNoisySumGaussianAggregate(
+      {prefix + kNoisySumGaussian}, withCompanionFunctions, overwrite);
+  registerReduceAgg({prefix + kReduceAgg}, withCompanionFunctions, overwrite);
+  registerReservoirSampleAggregate(
+      {prefix + kReservoirSample}, withCompanionFunctions, overwrite);
+  registerSetAggAggregate(
+      {prefix + kSetAgg}, withCompanionFunctions, overwrite);
+  registerSetUnionAggregate(
+      {prefix + kSetUnion}, withCompanionFunctions, overwrite);
+  registerSumAggregate({prefix + kSum}, withCompanionFunctions, overwrite);
+  registerStdDevSampAggregate(
+      {prefix + kStdDevSamp, prefix + kStdDev},
+      withCompanionFunctions,
+      overwrite);
+  registerStdDevPopAggregate(
+      {prefix + kStdDevPop}, withCompanionFunctions, overwrite);
+  registerVarSampAggregate(
+      {prefix + kVarSamp, prefix + kVariance},
+      withCompanionFunctions,
+      overwrite);
+  registerVarPopAggregate(
+      {prefix + kVarPop}, withCompanionFunctions, overwrite);
+  registerTDigestAggregate({prefix + kTDigestAgg}, overwrite);
+  registerApproxWinsorizedMeanAggregate(
+      {prefix + kApproxWinsorizedMean}, overwrite);
+  registerNoisyApproxSfmAggregate(
+      {prefix + kNoisyApproxSetSfm},
+      {prefix + kNoisyApproxDistinctSfm},
+      {prefix + kNoisyApproxSetSfmFromIndexAndZeros},
+      withCompanionFunctions,
+      overwrite);
+  registerNumericHistogramAggregate(
+      {prefix + kNumericHistogram}, withCompanionFunctions, overwrite);
+  registerKHyperLogLogAggregates(
+      {prefix + kKHyperLogLogAgg}, withCompanionFunctions, overwrite);
 }
 
 void registerInternalAggregateFunctions(const std::string& prefix) {
   bool withCompanionFunctions = false;
   bool overwrite = false;
-  registerCountDistinctAggregate(prefix, withCompanionFunctions, overwrite);
-  registerInternalArrayAggAggregate(prefix, withCompanionFunctions, overwrite);
+  registerCountDistinctAggregate(
+      {prefix + "$internal$count_distinct"}, withCompanionFunctions, overwrite);
+  registerInternalArrayAggAggregate(
+      {prefix + "$internal$array_agg"}, withCompanionFunctions, overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/ReservoirSampleAggregate.cpp b/velox/functions/prestosql/aggregates/ReservoirSampleAggregate.cpp
new file mode 100644
index 00000000000..23719655ec0
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/ReservoirSampleAggregate.cpp
@@ -0,0 +1,890 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/aggregates/ReservoirSampleAggregate.h"
+
+#include <folly/Random.h>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/exec/Aggregate.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/DecodedVector.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::aggregate::prestosql {
+
+namespace {
+
+struct ReservoirSampleAccumulator {
+  VectorPtr samples = nullptr;
+  std::optional<int32_t> maxSampleSize = std::nullopt;
+  std::optional<int64_t> processedCount = std::nullopt;
+  VectorPtr initialSamples = nullptr;
+  // -1 indicates no initialSamples. Use -1 for simplicity for writing and
+  // reading intermediate results. Allowed values of initialSeenCount are -1, 0,
+  // and positive integers.
+  int64_t initialSeenCount = -1;
+
+  void initialize(
+      int32_t desiredSampleSize,
+      const TypePtr& elementType,
+      memory::MemoryPool* pool);
+
+  bool isInitialized() const {
+    if (samples == nullptr) {
+      return false;
+    }
+    VELOX_DCHECK(maxSampleSize.has_value());
+    VELOX_DCHECK(processedCount.has_value());
+    return true;
+  }
+
+  vector_size_t initialSampleCount() const {
+    return initialSamples ? initialSamples->size() : 0;
+  }
+
+  vector_size_t sampleCount() const {
+    return std::min<vector_size_t>(
+        processedCount.value_or(0), maxSampleSize.value_or(0));
+  }
+
+  /// Adds a single value to the reservoir sample using reservoir sampling
+  /// algorithm.
+  /// @param vector The vector containing the value to add.
+  /// @param row The row within the vector to add.
+  /// @param isNull Whether the value at the given row is null.
+  void addValueToReservoir(
+      const BaseVector* vector,
+      vector_size_t row,
+      bool isNull = false);
+
+  /// Adds multiple values from a vector to the reservoir sample using
+  /// reservoir sampling algorithm.
+  /// @param vector The vector containing the values to add.
+  /// @param offset Starting offset within the vector.
+  /// @param size Number of values to add from the vector.
+  void addValuesToReservoir(
+      const BaseVector* vector,
+      vector_size_t offset,
+      vector_size_t size);
+
+  /// Merges reservoir samples from an ArrayVector row into this accumulator.
+  /// @param otherSampleArrayVector ArrayVector containing the samples to merge.
+  /// @param otherRow Row within otherSampleArrayVector containing the samples
+  /// to merge.
+  /// @param otherProcessedCount Total number of processed input elements.
+  /// @param otherMaxSampleSize: Max sample size to maintain in the reservoir.
+  void mergeSamples(
+      const ArrayVector& otherSampleArrayVector,
+      vector_size_t otherRow,
+      int64_t otherProcessedCount,
+      int32_t otherMaxSampleSize,
+      memory::MemoryPool* pool);
+
+  /// Merges reservoir samples from another vector into this accumulator.
+  /// @param otherSampleVector Vector containing the samples to merge.
+  /// @param otherOffset Starting offset within otherSampleVector.
+  /// @param otherSize Number of samples to merge from otherSampleVector.
+  /// @param otherProcessedCount Total number of processed input elements.
+  /// @param otherMaxSampleSize: Max sample size to maintain in the reservoir.
+  void mergeSamples(
+      const VectorPtr& otherSampleVector,
+      vector_size_t otherOffset,
+      vector_size_t otherSize,
+      int64_t otherProcessedCount,
+      int32_t otherMaxSampleSize,
+      memory::MemoryPool* pool);
+
+  /// Sets the samples for this accumulator from a source vector.
+  /// @param sampleVector Source vector containing the samples to copy.
+  /// @param offset Starting offset within sampleVector to copy from.
+  /// @param size Number of samples to copy from sampleVector.
+  /// @param seenCount Total number of elements that have been processed.
+  /// @param desiredSampleSize Max sample size to maintain in the reservoir.
+  void setSamples(
+      const VectorPtr& sampleVector,
+      vector_size_t offset,
+      vector_size_t size,
+      int64_t seenCount,
+      int32_t desiredSampleSize,
+      memory::MemoryPool* pool);
+
+  /// Sets the initial samples for this accumulator from a source vector.
+  /// This is used to initialize the reservoir with a pre-existing sample set
+  /// and its associated processed count from a previous sampling operation.
+  /// @param initialSampleVector Source vector containing the initial samples to
+  /// copy.
+  /// @param offset Starting offset within initialSampleVector to copy from.
+  /// @param size Number of initial samples to copy from initialSampleVector.
+  /// @param initialProcessedCount Total number of elements that were processed
+  ///        to generate the initial samples.
+  void setInitialSamples(
+      const VectorPtr initialSampleVector,
+      vector_size_t offset,
+      vector_size_t size,
+      int64_t initialProcessedCount,
+      memory::MemoryPool* pool);
+};
+
+void ReservoirSampleAccumulator::initialize(
+    int32_t desiredSampleSize,
+    const TypePtr& elementType,
+    memory::MemoryPool* pool) {
+  VELOX_USER_CHECK_GT(desiredSampleSize, 0, "sample size must be positive");
+  maxSampleSize = desiredSampleSize;
+  samples = BaseVector::create(elementType, desiredSampleSize, pool);
+  VELOX_DCHECK(samples->isFlatEncoding());
+  processedCount = 0;
+
+  initialSamples = nullptr;
+  initialSeenCount = -1;
+}
+
+void ReservoirSampleAccumulator::setSamples(
+    const VectorPtr& sampleVector,
+    vector_size_t offset,
+    vector_size_t size,
+    int64_t seenCount,
+    int32_t desiredSampleSize,
+    memory::MemoryPool* pool) {
+  VELOX_DCHECK_NOT_NULL(sampleVector);
+  VELOX_DCHECK_GE(seenCount, 0);
+  VELOX_DCHECK(size == seenCount || size == desiredSampleSize);
+
+  if (samples == nullptr) {
+    samples = BaseVector::create(sampleVector->type(), desiredSampleSize, pool);
+  }
+  samples->copy(sampleVector.get(), 0, offset, size);
+  processedCount = seenCount;
+  maxSampleSize = desiredSampleSize;
+}
+
+void ReservoirSampleAccumulator::setInitialSamples(
+    const VectorPtr initialSampleVector,
+    vector_size_t offset,
+    vector_size_t size,
+    int64_t initialProcessedCount,
+    memory::MemoryPool* pool) {
+  if (initialProcessedCount <= 0) {
+    VELOX_USER_CHECK(
+        initialSampleVector == nullptr || size == 0,
+        "Initial state array must be null or empty "
+        "when initial processed count is <= 0.");
+  }
+
+  if (initialSeenCount >= 0) {
+    return;
+  }
+
+  if (initialSampleVector && size > 0) {
+    VELOX_USER_CHECK_GE(
+        initialProcessedCount,
+        size,
+        "InitialProcessedCount must be greater than or equal to the number "
+        "of positions in the initial sample.");
+  }
+
+  // When initialSamples == nullptr, initialSeenCount can be any of
+  // -1, 0, or positive.
+  initialSeenCount = initialProcessedCount;
+
+  if (initialProcessedCount <= 0 || initialSampleVector == nullptr) {
+    initialSamples = nullptr;
+    return;
+  }
+  initialSamples = BaseVector::create(initialSampleVector->type(), size, pool);
+  initialSamples->copy(initialSampleVector.get(), 0, offset, size);
+}
+
+void ReservoirSampleAccumulator::addValueToReservoir(
+    const BaseVector* vector,
+    vector_size_t row,
+    bool isNull) {
+  VELOX_CHECK(isInitialized());
+
+  processedCount = processedCount.value_or(0) + 1;
+
+  vector_size_t targetIndex = -1;
+  if (processedCount.value() <= maxSampleSize) {
+    targetIndex = processedCount.value() - 1;
+  } else {
+    const uint64_t random = folly::Random::rand64(processedCount.value());
+    if (random < samples->size()) {
+      targetIndex = random;
+    }
+  }
+
+  if (targetIndex >= 0) {
+    if (isNull) {
+      samples->setNull(targetIndex, true);
+    } else {
+      samples->copy(vector, targetIndex, row, 1);
+    }
+  }
+}
+
+void ReservoirSampleAccumulator::addValuesToReservoir(
+    const BaseVector* vector,
+    vector_size_t offset,
+    vector_size_t size) {
+  VELOX_CHECK(isInitialized());
+
+  SelectivityVector rows(maxSampleSize.value(), false);
+  std::vector<vector_size_t> toSource(maxSampleSize.value());
+
+  for (vector_size_t i = 0; i < size; i++) {
+    if (processedCount.value() < maxSampleSize) {
+      toSource[processedCount.value()] = offset + i;
+      rows.setValid(processedCount.value(), true);
+
+      processedCount = processedCount.value_or(0) + 1;
+    } else {
+      processedCount = processedCount.value_or(0) + 1;
+
+      const uint64_t random = folly::Random::rand64(processedCount.value());
+      if (random < samples->size()) {
+        toSource[random] = offset + i;
+        rows.setValid(random, true);
+      }
+    }
+  }
+  rows.updateBounds();
+
+  samples->copy(vector, rows, toSource.data());
+}
+
+void ReservoirSampleAccumulator::mergeSamples(
+    const ArrayVector& otherSampleArrayVector,
+    vector_size_t otherRow,
+    int64_t otherProcessedCount,
+    int32_t otherMaxSampleSize,
+    memory::MemoryPool* pool) {
+  if (otherSampleArrayVector.isNullAt(otherRow)) {
+    return;
+  }
+  mergeSamples(
+      otherSampleArrayVector.elements(),
+      otherSampleArrayVector.offsetAt(otherRow),
+      otherSampleArrayVector.sizeAt(otherRow),
+      otherProcessedCount,
+      otherMaxSampleSize,
+      pool);
+}
+
+BufferPtr makeShuffledIndex(
+    vector_size_t size,
+    vector_size_t offset,
+    folly::ThreadLocalPRNG& randGen,
+    memory::MemoryPool* pool) {
+  BufferPtr index = allocateIndices(size, pool);
+  vector_size_t* rawIndex = index->asMutable<vector_size_t>();
+  std::iota(rawIndex, rawIndex + size, offset);
+  std::shuffle(rawIndex, rawIndex + size, randGen);
+  return index;
+}
+
+void ReservoirSampleAccumulator::mergeSamples(
+    const VectorPtr& otherSampleVector,
+    vector_size_t otherOffset,
+    vector_size_t otherSize,
+    int64_t otherProcessedCount,
+    int32_t otherMaxSampleSize,
+    memory::MemoryPool* pool) {
+  VELOX_DCHECK_GE(otherProcessedCount, 0);
+  VELOX_DCHECK_GT(otherMaxSampleSize, 0);
+  VELOX_CHECK_NOT_NULL(otherSampleVector);
+
+  const TypePtr& elementType = otherSampleVector->type();
+
+  if (!isInitialized()) {
+    initialize(otherMaxSampleSize, elementType, pool);
+  }
+
+  VELOX_DCHECK(
+      samples->type()->equivalent(*elementType),
+      "Samples to be merged are of different types.");
+  VELOX_USER_CHECK_EQ(
+      maxSampleSize.value(),
+      otherMaxSampleSize,
+      "maximum number of samples {} must be equal to that of other {}",
+      maxSampleSize.value(),
+      otherMaxSampleSize);
+
+  if (otherProcessedCount < maxSampleSize.value()) {
+    addValuesToReservoir(otherSampleVector.get(), otherOffset, otherSize);
+    return;
+  }
+
+  if (processedCount.value() < maxSampleSize.value()) {
+    const VectorPtr tempSamples = std::move(samples);
+    samples = nullptr;
+    const int64_t tempProcessedCount = processedCount.value();
+
+    setSamples(
+        otherSampleVector,
+        otherOffset,
+        otherSize,
+        otherProcessedCount,
+        otherMaxSampleSize,
+        pool);
+
+    addValuesToReservoir(tempSamples.get(), 0, tempProcessedCount);
+    return;
+  }
+
+  VectorPtr mergedSamples =
+      BaseVector::create(elementType, maxSampleSize.value(), pool);
+  vector_size_t oneSelected = 0;
+  for (vector_size_t i = 0; i < maxSampleSize.value(); ++i) {
+    if (folly::Random::rand64(processedCount.value() + otherProcessedCount) <
+        processedCount.value()) {
+      oneSelected++;
+    }
+  }
+
+  SelectivityVector rows(maxSampleSize.value(), false);
+  folly::ThreadLocalPRNG rng;
+  if (oneSelected > 0) {
+    rows.setValidRange(0, oneSelected, true);
+    rows.updateBounds();
+
+    const BufferPtr oneIndex = makeShuffledIndex(sampleCount(), 0, rng, pool);
+    mergedSamples->copy(samples.get(), rows, oneIndex->as<vector_size_t>());
+  }
+
+  vector_size_t otherSelected = maxSampleSize.value() - oneSelected;
+  if (otherSelected > 0) {
+    rows.clearAll();
+    rows.setValidRange(oneSelected, maxSampleSize.value(), true);
+    rows.updateBounds();
+
+    BufferPtr otherIndex = makeShuffledIndex(otherSize, otherOffset, rng, pool);
+    // Shift the source indices of the mapping forward by oneSelected.
+    auto* otherRawIndex = otherIndex->asMutable<vector_size_t>();
+    for (vector_size_t i = 0; i < otherSelected; ++i) {
+      otherRawIndex[maxSampleSize.value() - 1 - i] =
+          otherRawIndex[maxSampleSize.value() - 1 - i - oneSelected];
+    }
+
+    mergedSamples->copy(
+        otherSampleVector.get(), rows, otherIndex->as<vector_size_t>());
+  }
+
+  samples = std::move(mergedSamples);
+  processedCount = processedCount.value() + otherProcessedCount;
+}
+
+class ReservoirSampleAggregate : public exec::Aggregate {
+ public:
+  explicit ReservoirSampleAggregate(TypePtr resultType);
+
+  int32_t accumulatorFixedWidthSize() const override;
+
+  bool accumulatorUsesExternalMemory() const override;
+
+  bool isFixedSize() const override;
+
+  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
+      override;
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override;
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool mayPushdown) override;
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool mayPushdown) override;
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool mayPushdown) override;
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool mayPushdown) override;
+
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override;
+
+  void destroyInternal(folly::Range<char**> groups) override;
+
+ private:
+  template <bool kSingleGroup>
+  void addRaw(
+      std::conditional_t<kSingleGroup, char*, char**> group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args);
+
+  template <bool kSingleGroup>
+  void addIntermediate(
+      std::conditional_t<kSingleGroup, char*, char**> group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args);
+
+  static void validateArguments(const std::vector<VectorPtr>& args);
+
+  std::tuple<vector_size_t, vector_size_t, vector_size_t> computeTotalSamples(
+      char** groups,
+      int32_t numGroups) const;
+};
+
+ReservoirSampleAggregate::ReservoirSampleAggregate(TypePtr resultType)
+    : exec::Aggregate(std::move(resultType)) {}
+
+int32_t ReservoirSampleAggregate::accumulatorFixedWidthSize() const {
+  return sizeof(ReservoirSampleAccumulator);
+}
+
+bool ReservoirSampleAggregate::accumulatorUsesExternalMemory() const {
+  return true;
+}
+
+bool ReservoirSampleAggregate::isFixedSize() const {
+  return false;
+}
+
+void ReservoirSampleAggregate::extractValues(
+    char** groups,
+    int32_t numGroups,
+    VectorPtr* result) {
+  auto* rowVector = (*result)->asChecked<RowVector>();
+  rowVector->resetNulls();
+  rowVector->resize(numGroups);
+
+  auto* processedCountVector =
+      rowVector->childAt(0)->asChecked<FlatVector<int64_t>>();
+  processedCountVector->resetNulls();
+
+  auto* sampleArrayVector = rowVector->childAt(1)->asChecked<ArrayVector>();
+  sampleArrayVector->resetNulls();
+  const auto [_, __, totalMergedSamples] =
+      computeTotalSamples(groups, numGroups);
+  const VectorPtr& sampleElementsVector = sampleArrayVector->elements();
+  sampleElementsVector->resize(totalMergedSamples);
+
+  vector_size_t offset = 0;
+  for (int32_t i = 0; i < numGroups; i++) {
+    const auto* accumulator = value<ReservoirSampleAccumulator>(groups[i]);
+
+    if (!accumulator->isInitialized()) {
+      sampleArrayVector->setNull(i, true);
+      processedCountVector->setNull(i, true);
+      continue;
+    }
+
+    // Merge the initial sample at last in the final aggregation before
+    // extracting output.
+    VELOX_USER_CHECK(
+        accumulator->initialSeenCount <= 0 ||
+            (accumulator->initialSeenCount ==
+                 accumulator->initialSampleCount() &&
+             accumulator->initialSampleCount() <=
+                 accumulator->maxSampleSize.value()) ||
+            accumulator->maxSampleSize.value() ==
+                accumulator->initialSampleCount(),
+        "When a positive initial_processed_count is provided, "
+        "the size of the initial sample must be equal to desired_sample_size parameter.");
+
+    ReservoirSampleAccumulator finalAccumulator;
+    const VectorPtr nonNullInitialSample = BaseVector::getOrCreateEmpty(
+        accumulator->initialSamples,
+        accumulator->samples->type(),
+        allocator_->pool());
+    finalAccumulator.setSamples(
+        nonNullInitialSample,
+        0,
+        accumulator->initialSampleCount(),
+        std::max<int64_t>(accumulator->initialSeenCount, 0),
+        accumulator->maxSampleSize.value(),
+        allocator_->pool());
+    finalAccumulator.mergeSamples(
+        accumulator->samples,
+        0,
+        accumulator->sampleCount(),
+        accumulator->processedCount.value(),
+        accumulator->maxSampleSize.value(),
+        allocator_->pool());
+
+    sampleArrayVector->setNull(i, false);
+    const vector_size_t sampleSize = finalAccumulator.sampleCount();
+    sampleElementsVector->copy(
+        finalAccumulator.samples.get(), offset, 0, sampleSize);
+    sampleArrayVector->setOffsetAndSize(i, offset, sampleSize);
+    offset += sampleSize;
+
+    processedCountVector->set(i, finalAccumulator.processedCount.value());
+  }
+}
+
+void ReservoirSampleAggregate::extractAccumulators(
+    char** groups,
+    int32_t numGroups,
+    VectorPtr* result) {
+  // Order of RowVector children is determined by protocol.
+  auto* rowVector = (*result)->asChecked<RowVector>();
+  rowVector->resetNulls();
+  rowVector->resize(numGroups);
+
+  const auto [totalSamples, totalInitialSamples, _] =
+      computeTotalSamples(groups, numGroups);
+
+  auto* initialSampleVector = rowVector->childAt(0)->asChecked<ArrayVector>();
+  initialSampleVector->resetNulls();
+  const VectorPtr& initialSampleElementsVector =
+      initialSampleVector->elements();
+  initialSampleElementsVector->resize(totalInitialSamples);
+
+  auto* initialSeenCountVector =
+      rowVector->childAt(1)->asChecked<FlatVector<int64_t>>();
+  initialSeenCountVector->resetNulls();
+
+  auto* seenCountVector =
+      rowVector->childAt(2)->asChecked<FlatVector<int64_t>>();
+  seenCountVector->resetNulls();
+
+  auto* maxSampleSizeVector =
+      rowVector->childAt(3)->asChecked<FlatVector<int32_t>>();
+  maxSampleSizeVector->resetNulls();
+
+  auto* sampleVector = rowVector->childAt(4)->asChecked<ArrayVector>();
+  sampleVector->resetNulls();
+  const VectorPtr& sampleElementsVector = sampleVector->elements();
+  sampleElementsVector->resize(totalSamples);
+
+  vector_size_t offset = 0;
+  vector_size_t initialSampleOffset = 0;
+
+  for (int32_t i = 0; i < numGroups; i++) {
+    const auto* accumulator = value<ReservoirSampleAccumulator>(groups[i]);
+
+    if (!accumulator->isInitialized()) {
+      rowVector->setNull(i, true);
+      sampleVector->setNull(i, true);
+      maxSampleSizeVector->setNull(i, true);
+      seenCountVector->setNull(i, true);
+      initialSampleVector->setNull(i, true);
+      initialSeenCountVector->setNull(i, true);
+      continue;
+    }
+
+    rowVector->setNull(i, false);
+    sampleVector->setNull(i, false);
+    const vector_size_t sampleSize = accumulator->sampleCount();
+    sampleElementsVector->copy(
+        accumulator->samples.get(), offset, 0, sampleSize);
+    sampleVector->setOffsetAndSize(i, offset, sampleSize);
+    offset += sampleSize;
+
+    maxSampleSizeVector->set(i, accumulator->maxSampleSize.value());
+    seenCountVector->set(i, accumulator->processedCount.value());
+
+    if (accumulator->initialSamples == nullptr) {
+      initialSampleVector->setNull(i, true);
+    } else {
+      initialSampleVector->setNull(i, false);
+      const vector_size_t initialSampleSize = accumulator->initialSampleCount();
+      initialSampleElementsVector->copy(
+          accumulator->initialSamples.get(),
+          initialSampleOffset,
+          0,
+          initialSampleSize);
+      initialSampleVector->setOffsetAndSize(
+          i, initialSampleOffset, initialSampleSize);
+      initialSampleOffset += initialSampleSize;
+    }
+
+    initialSeenCountVector->set(i, accumulator->initialSeenCount);
+  }
+}
+
+template <bool kSingleGroup>
+void ReservoirSampleAggregate::addRaw(
+    std::conditional_t<kSingleGroup, char*, char**> group,
+    const SelectivityVector& rows,
+    const std::vector<VectorPtr>& args) {
+  validateArguments(args);
+
+  const DecodedVector initialSampleDecoded(*args[0], rows);
+  const DecodedVector initialProcessedCountDecoded(*args[1], rows);
+  const DecodedVector valuesToSampleDecoded(*args[2], rows);
+  const DecodedVector desiredSampleSizeDecoded(*args[3], rows);
+
+  rows.applyToSelected([&](vector_size_t row) {
+    if (desiredSampleSizeDecoded.isNullAt(row) ||
+        initialProcessedCountDecoded.isNullAt(row)) {
+      return;
+    }
+
+    ReservoirSampleAccumulator* accumulator;
+    if constexpr (kSingleGroup) {
+      accumulator = value<ReservoirSampleAccumulator>(group);
+    } else {
+      accumulator = value<ReservoirSampleAccumulator>(group[row]);
+    }
+
+    if (!accumulator->isInitialized()) {
+      accumulator->initialize(
+          desiredSampleSizeDecoded.valueAt<int32_t>(row),
+          valuesToSampleDecoded.base()->type(),
+          allocator_->pool());
+    }
+
+    const auto* initialSampleBase =
+        initialSampleDecoded.base()->asChecked<ArrayVector>();
+    accumulator->setInitialSamples(
+        initialSampleDecoded.isNullAt(row) ? nullptr
+                                           : initialSampleBase->elements(),
+        initialSampleBase->offsetAt(initialSampleDecoded.index(row)),
+        initialSampleBase->sizeAt(initialSampleDecoded.index(row)),
+        initialProcessedCountDecoded.valueAt<int64_t>(row),
+        allocator_->pool());
+
+    accumulator->addValueToReservoir(
+        valuesToSampleDecoded.base(),
+        valuesToSampleDecoded.index(row),
+        valuesToSampleDecoded.isNullAt(row));
+  });
+}
+
+template <bool kSingleGroup>
+void ReservoirSampleAggregate::addIntermediate(
+    std::conditional_t<kSingleGroup, char*, char**> group,
+    const SelectivityVector& rows,
+    const std::vector<VectorPtr>& args) {
+  VELOX_CHECK_EQ(args.size(), 1, "Intermediate results requires 1 argument");
+
+  const DecodedVector decodedIntermediate(*args[0], rows);
+  const auto* rowVector = decodedIntermediate.base()->asChecked<RowVector>();
+  VELOX_CHECK_EQ(rowVector->childrenSize(), 5);
+  const auto* initialSampleArrayVector =
+      rowVector->childAt(0)->asChecked<ArrayVector>();
+  const auto* initialSeenCountVector =
+      rowVector->childAt(1)->asChecked<FlatVector<int64_t>>();
+  const auto* seenCountVector =
+      rowVector->childAt(2)->asChecked<FlatVector<int64_t>>();
+  const auto* maxSampleSizeVector =
+      rowVector->childAt(3)->asChecked<FlatVector<int32_t>>();
+  const auto* sampleArrayVector =
+      rowVector->childAt(4)->asChecked<ArrayVector>();
+
+  const auto& elementType = sampleArrayVector->elements()->type();
+
+  rows.applyToSelected([&](vector_size_t row) {
+    if (decodedIntermediate.isNullAt(row)) {
+      return;
+    }
+
+    const auto decodedRow = decodedIntermediate.index(row);
+
+    if (sampleArrayVector->isNullAt(decodedRow)) {
+      return;
+    }
+    VELOX_DCHECK(!maxSampleSizeVector->isNullAt(decodedRow));
+    VELOX_DCHECK(!seenCountVector->isNullAt(decodedRow));
+    VELOX_DCHECK(!initialSeenCountVector->isNullAt(decodedRow));
+
+    ReservoirSampleAccumulator* accumulator;
+    if constexpr (kSingleGroup) {
+      accumulator = value<ReservoirSampleAccumulator>(group);
+    } else {
+      accumulator = value<ReservoirSampleAccumulator>(group[row]);
+    }
+
+    if (!accumulator->isInitialized()) {
+      accumulator->initialize(
+          maxSampleSizeVector->valueAt(decodedRow),
+          elementType,
+          allocator_->pool());
+    }
+
+    accumulator->mergeSamples(
+        *sampleArrayVector,
+        decodedRow,
+        seenCountVector->valueAt(decodedRow),
+        maxSampleSizeVector->valueAt(decodedRow),
+        allocator_->pool());
+    accumulator->setInitialSamples(
+        initialSampleArrayVector->isNullAt(decodedRow)
+            ? nullptr
+            : initialSampleArrayVector->elements(),
+        initialSampleArrayVector->offsetAt(decodedRow),
+        initialSampleArrayVector->sizeAt(decodedRow),
+        initialSeenCountVector->valueAt(decodedRow),
+        allocator_->pool());
+  });
+}
+
+void ReservoirSampleAggregate::addRawInput(
+    char** groups,
+    const SelectivityVector& rows,
+    const std::vector<VectorPtr>& args,
+    bool /* mayPushdown */) {
+  addRaw<false>(groups, rows, args);
+}
+
+void ReservoirSampleAggregate::addIntermediateResults(
+    char** groups,
+    const SelectivityVector& rows,
+    const std::vector<VectorPtr>& args,
+    bool /* mayPushdown */) {
+  addIntermediate<false>(groups, rows, args);
+}
+
+void ReservoirSampleAggregate::addSingleGroupRawInput(
+    char* group,
+    const SelectivityVector& rows,
+    const std::vector<VectorPtr>& args,
+    bool /* mayPushdown */) {
+  addRaw<true>(group, rows, args);
+}
+
+void ReservoirSampleAggregate::addSingleGroupIntermediateResults(
+    char* group,
+    const SelectivityVector& rows,
+    const std::vector<VectorPtr>& args,
+    bool /* mayPushdown */) {
+  addIntermediate<true>(group, rows, args);
+}
+
+void ReservoirSampleAggregate::initializeNewGroupsInternal(
+    char** groups,
+    folly::Range<const vector_size_t*> indices) {
+  for (auto index : indices) {
+    new (groups[index] + offset_) ReservoirSampleAccumulator();
+  }
+}
+
+void ReservoirSampleAggregate::destroyInternal(folly::Range<char**> groups) {
+  for (auto group : groups) {
+    if (isInitialized(group)) {
+      auto* accumulator = value<ReservoirSampleAccumulator>(group);
+      std::destroy_at(accumulator);
+    }
+  }
+}
+
+// static
+void ReservoirSampleAggregate::validateArguments(
+    const std::vector<VectorPtr>& args) {
+  static constexpr size_t kInitialSampleIndex = 0;
+  static constexpr size_t kInitialProcessedCountIndex = 1;
+  static constexpr size_t kSampleIndex = 2;
+  static constexpr size_t kMaxSampleSizeIndex = 3;
+
+  VELOX_USER_CHECK_EQ(args.size(), 4, "reservoir_sample requires 4 arguments");
+  VELOX_USER_CHECK(args[kInitialProcessedCountIndex]->type()->isBigint());
+  VELOX_USER_CHECK(args[kMaxSampleSizeIndex]->type()->isInteger());
+
+  auto elementType = args[kSampleIndex]->type();
+  // TODO: extend to ComplexType
+  VELOX_USER_CHECK(elementType->isPrimitiveType());
+  auto initialSampleType = args[kInitialSampleIndex]->type();
+  VELOX_USER_CHECK(initialSampleType->isArray());
+  VELOX_USER_CHECK(
+      initialSampleType->asArray().elementType()->equivalent(*elementType),
+      "Initial samples and values to sample must have the same type.");
+}
+
+std::tuple<vector_size_t, vector_size_t, vector_size_t>
+ReservoirSampleAggregate::computeTotalSamples(char** groups, int32_t numGroups)
+    const {
+  vector_size_t totalSamples = 0;
+  vector_size_t totalInitialSamples = 0;
+  vector_size_t totalMergedSamples = 0;
+
+  for (int32_t i = 0; i < numGroups; i++) {
+    const auto* accumulator = value<ReservoirSampleAccumulator>(groups[i]);
+    totalSamples += accumulator->sampleCount();
+    totalInitialSamples += accumulator->initialSampleCount();
+    totalMergedSamples += std::min<vector_size_t>(
+        accumulator->sampleCount() + accumulator->initialSampleCount(),
+        accumulator->maxSampleSize.value_or(0));
+  }
+
+  return std::make_tuple(totalSamples, totalInitialSamples, totalMergedSamples);
+}
+
+} // namespace
+
+void registerReservoirSampleAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
+
+  for (const auto& inputType : {
+           "tinyint",
+           "smallint",
+           "integer",
+           "bigint",
+           "real",
+           "double",
+           "varchar",
+           "boolean",
+           "timestamp",
+       }) {
+    // argumentType, intermediateType and returnType and their field order need
+    // to be consistent with those defined in protocol.
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType(
+                fmt::format(
+                    "row(processed_count bigint, sample array({}))", inputType))
+            .intermediateType(
+                fmt::format(
+                    "row(initialSample array({}), initialSeenCount bigint, "
+                    "seenCount bigint, maxSampleSize integer, sample array({}))",
+                    inputType,
+                    inputType))
+            .argumentType(fmt::format("array({})", inputType))
+            .argumentType("bigint")
+            .argumentType(inputType)
+            .argumentType("integer")
+            .build());
+  }
+
+  exec::registerAggregateFunction(
+      names,
+      std::move(signatures),
+      [names](
+          core::AggregationNode::Step /* step */,
+          const std::vector<TypePtr>& argTypes,
+          const TypePtr& resultType,
+          const core::QueryConfig& /* config */)
+          -> std::unique_ptr<exec::Aggregate> {
+        VELOX_CHECK_EQ(
+            argTypes.size(), 4, "{} requires 4 arguments", names.front());
+
+        return std::make_unique<ReservoirSampleAggregate>(resultType);
+      },
+      withCompanionFunctions,
+      overwrite);
+}
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/ReservoirSampleAggregate.h b/velox/functions/prestosql/aggregates/ReservoirSampleAggregate.h
new file mode 100644
index 00000000000..eae464f3424
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/ReservoirSampleAggregate.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace facebook::velox::aggregate::prestosql {
+
+void registerReservoirSampleAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+}
diff --git a/velox/functions/prestosql/aggregates/SetAggregates.cpp b/velox/functions/prestosql/aggregates/SetAggregates.cpp
index 6b7cee1edd8..6367def1c29 100644
--- a/velox/functions/prestosql/aggregates/SetAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/SetAggregates.cpp
@@ -15,7 +15,6 @@
  */
 #include "velox/functions/prestosql/aggregates/SetAggregates.h"
 #include "velox/functions/lib/aggregates/SetBaseAggregate.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 
 using namespace facebook::velox::functions::aggregate;
 
@@ -158,8 +157,7 @@ class CountDistinctAggregate
 };
 
 template <
-    template <typename T, typename AccumulatorType>
-    class Aggregate,
+    template <typename T, typename AccumulatorType> class Aggregate,
     TypeKind Kind>
 std::unique_ptr<exec::Aggregate> create(const TypePtr& resultType) {
   return std::make_unique<Aggregate<
@@ -167,8 +165,9 @@ std::unique_ptr<exec::Aggregate> create(const TypePtr& resultType) {
       aggregate::prestosql::CustomComparisonSetAccumulator<Kind>>>(resultType);
 }
 
-template <template <typename T, typename AcumulatorType = SetAccumulator<T>>
-          class Aggregate>
+template <template <
+    typename T,
+    typename AcumulatorType = SetAccumulator<T>> class Aggregate>
 std::unique_ptr<exec::Aggregate> create(
     const TypePtr& inputType,
     const TypePtr& resultType) {
@@ -213,7 +212,7 @@ std::unique_ptr<exec::Aggregate> create(
       return std::make_unique<Aggregate<UnknownValue>>(resultType);
     default:
       VELOX_UNREACHABLE(
-          "Unexpected type {}", mapTypeKindToName(inputType->kind()));
+          "Unexpected type {}", TypeKindName::toName(inputType->kind()));
   }
 }
 
@@ -240,7 +239,7 @@ std::unique_ptr<exec::Aggregate> createCountDistinctAggregate(
 } // namespace
 
 void registerSetAggAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures = {
@@ -251,15 +250,13 @@ void registerSetAggAggregate(
           .argumentType("T")
           .build()};
 
-  auto name = prefix + kSetAgg;
   exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
-          core::AggregationNode::Step step,
-          const std::vector<TypePtr>& argTypes,
-          const TypePtr& resultType,
-          const core::QueryConfig& /*config*/)
+      [](core::AggregationNode::Step step,
+         const std::vector<TypePtr>& argTypes,
+         const TypePtr& resultType,
+         const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
         VELOX_CHECK_EQ(argTypes.size(), 1);
 
@@ -309,15 +306,16 @@ void registerSetAggAggregate(
             return std::make_unique<SetAggAggregate<UnknownValue>>(resultType);
           default:
             VELOX_UNREACHABLE(
-                "Unexpected type {}", mapTypeKindToName(typeKind));
+                "Unexpected type {}", TypeKindName::toName(typeKind));
         }
       },
+      {.ignoreDuplicates = true},
       withCompanionFunctions,
       overwrite);
 }
 
 void registerSetUnionAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures = {
@@ -328,26 +326,25 @@ void registerSetUnionAggregate(
           .argumentType("array(T)")
           .build()};
 
-  auto name = prefix + kSetUnion;
   exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
-          core::AggregationNode::Step /*step*/,
-          const std::vector<TypePtr>& argTypes,
-          const TypePtr& resultType,
-          const core::QueryConfig& /*config*/)
+      [](core::AggregationNode::Step /*step*/,
+         const std::vector<TypePtr>& argTypes,
+         const TypePtr& resultType,
+         const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
         VELOX_CHECK_EQ(argTypes.size(), 1);
 
         return create<SetUnionAggregate>(argTypes[0]->childAt(0), resultType);
       },
+      {.ignoreDuplicates = true},
       withCompanionFunctions,
       overwrite);
 }
 
 void registerCountDistinctAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures = {
@@ -358,9 +355,8 @@ void registerCountDistinctAggregate(
           .argumentType("T")
           .build()};
 
-  auto name = prefix + "$internal$count_distinct";
   exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
       [](core::AggregationNode::Step step,
          const std::vector<TypePtr>& argTypes,
@@ -427,7 +423,7 @@ void registerCountDistinctAggregate(
                 resultType, argTypes[0]);
           default:
             VELOX_UNREACHABLE(
-                "Unexpected type {}", mapTypeKindToName(typeKind));
+                "Unexpected type {}", TypeKindName::toName(typeKind));
         }
       },
       withCompanionFunctions,
diff --git a/velox/functions/prestosql/aggregates/SetAggregates.h b/velox/functions/prestosql/aggregates/SetAggregates.h
index c8a6d866389..43105948d8d 100644
--- a/velox/functions/prestosql/aggregates/SetAggregates.h
+++ b/velox/functions/prestosql/aggregates/SetAggregates.h
@@ -17,21 +17,22 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerSetAggAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 
 void registerSetUnionAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 
 void registerCountDistinctAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/SetDigestAggregate.cpp b/velox/functions/prestosql/aggregates/SetDigestAggregate.cpp
new file mode 100644
index 00000000000..d4139655ae5
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/SetDigestAggregate.cpp
@@ -0,0 +1,591 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/Aggregate.h"
+#include "velox/expression/FunctionSignature.h"
+#include "velox/functions/lib/SetDigest.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::aggregate::prestosql {
+
+// SetDigest only supports int64_t and StringView as element types.
+// Template specializations ensure compile-time errors for unsupported types.
+template <typename T>
+struct SetDigestElementType;
+
+template <>
+struct SetDigestElementType<bool> {
+  using type = int64_t;
+};
+
+template <>
+struct SetDigestElementType<int8_t> {
+  using type = int64_t;
+};
+
+template <>
+struct SetDigestElementType<int16_t> {
+  using type = int64_t;
+};
+
+template <>
+struct SetDigestElementType<int32_t> {
+  using type = int64_t;
+};
+
+template <>
+struct SetDigestElementType<int64_t> {
+  using type = int64_t;
+};
+
+template <>
+struct SetDigestElementType<float> {
+  using type = int64_t;
+};
+
+template <>
+struct SetDigestElementType<double> {
+  using type = int64_t;
+};
+
+template <>
+struct SetDigestElementType<StringView> {
+  using type = StringView;
+};
+
+template <typename T>
+class SetDigestAggregate : public exec::Aggregate {
+ private:
+  using SetDigestAccumulator =
+      functions::SetDigest<typename SetDigestElementType<T>::type>;
+
+ public:
+  explicit SetDigestAggregate(const TypePtr& resultType)
+      : Aggregate(resultType) {}
+
+  int32_t accumulatorFixedWidthSize() const override {
+    return sizeof(SetDigestAccumulator);
+  }
+
+  bool isFixedSize() const override {
+    return false;
+  }
+
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    setAllNulls(groups, indices);
+    for (auto i : indices) {
+      new (groups[i] + offset_) SetDigestAccumulator(allocator_);
+    }
+  }
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedValue_.decode(*args[0], rows);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedValue_.isNullAt(row)) {
+        return;
+      }
+
+      auto* accumulator = value<SetDigestAccumulator>(groups[row]);
+      clearNull(groups[row]);
+
+      auto tracker = trackRowSize(groups[row]);
+      addValueToAccumulator(accumulator, row);
+    });
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedValue_.decode(*args[0], rows);
+
+    auto* accumulator = value<SetDigestAccumulator>(group);
+    auto tracker = trackRowSize(group);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedValue_.isNullAt(row)) {
+        return;
+      }
+
+      clearNull(group);
+      addValueToAccumulator(accumulator, row);
+    });
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedIntermediate_.decode(*args[0], rows);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedIntermediate_.isNullAt(row)) {
+        return;
+      }
+
+      auto* accumulator = value<SetDigestAccumulator>(groups[row]);
+      clearNull(groups[row]);
+
+      auto tracker = trackRowSize(groups[row]);
+      auto serialized = decodedIntermediate_.valueAt<StringView>(row);
+
+      SetDigestAccumulator other(allocator_);
+      auto status = other.deserialize(serialized.data(), serialized.size());
+      VELOX_CHECK(
+          status.ok(), "Failed to deserialize SetDigest: {}", status.message());
+      accumulator->mergeWith(other);
+    });
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedIntermediate_.decode(*args[0], rows);
+
+    auto* accumulator = value<SetDigestAccumulator>(group);
+    auto tracker = trackRowSize(group);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedIntermediate_.isNullAt(row)) {
+        return;
+      }
+
+      clearNull(group);
+
+      auto serialized = decodedIntermediate_.valueAt<StringView>(row);
+
+      SetDigestAccumulator other(allocator_);
+      auto status = other.deserialize(serialized.data(), serialized.size());
+      VELOX_CHECK(
+          status.ok(), "Failed to deserialize SetDigest: {}", status.message());
+      accumulator->mergeWith(other);
+    });
+  }
+
+  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    auto* flatResult = (*result)->as<FlatVector<StringView>>();
+    flatResult->resize(numGroups);
+
+    // Calculate total buffer size needed for all non-inline
+    // strings.
+    int64_t totalBufferSize = 0;
+    std::vector<int32_t> sizes(numGroups);
+    for (vector_size_t i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      if (!isNull(group)) {
+        auto* accumulator = value<SetDigestAccumulator>(group);
+        auto size = accumulator->estimatedSerializedSize();
+        sizes[i] = size;
+        if (!StringView::isInline(size)) {
+          totalBufferSize += size;
+        }
+      }
+    }
+
+    // Allocate buffer once for all non-inline strings.
+    char* rawBuffer = nullptr;
+    if (totalBufferSize > 0) {
+      rawBuffer = flatResult->getRawStringBufferWithSpace(totalBufferSize);
+    }
+
+    // Serialize into pre-allocated buffer.
+    for (vector_size_t i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      if (isNull(group)) {
+        flatResult->setNull(i, true);
+      } else {
+        auto* accumulator = value<SetDigestAccumulator>(group);
+        auto size = sizes[i];
+
+        StringView serialized;
+        if (StringView::isInline(size)) {
+          // For small serialized data (<= 12 bytes), use inline StringView
+          // storage to avoid heap allocation overhead.
+          std::string buffer(size, '\0');
+          accumulator->serialize(buffer.data());
+          serialized = StringView::makeInline(buffer);
+        } else {
+          accumulator->serialize(rawBuffer);
+          serialized = StringView(rawBuffer, size);
+          rawBuffer += size;
+        }
+        flatResult->setNoCopy(i, serialized);
+      }
+    }
+  }
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    extractValues(groups, numGroups, result);
+  }
+
+ protected:
+  void destroyInternal(folly::Range<char**> groups) override {
+    destroyAccumulators<SetDigestAccumulator>(groups);
+  }
+
+ private:
+  void addValueToAccumulator(
+      SetDigestAccumulator* accumulator,
+      vector_size_t row) {
+    if constexpr (std::is_same_v<T, StringView>) {
+      accumulator->add(decodedValue_.valueAt<StringView>(row));
+    } else if constexpr (std::is_same_v<T, float>) {
+      float val = decodedValue_.valueAt<float>(row);
+      int32_t bits;
+      std::memcpy(&bits, &val, sizeof(float));
+      accumulator->add(static_cast<int64_t>(bits));
+    } else if constexpr (std::is_same_v<T, double>) {
+      double val = decodedValue_.valueAt<double>(row);
+      int64_t bits;
+      std::memcpy(&bits, &val, sizeof(double));
+      accumulator->add(bits);
+    } else {
+      accumulator->add(static_cast<int64_t>(decodedValue_.valueAt<T>(row)));
+    }
+  }
+
+  DecodedVector decodedValue_;
+  DecodedVector decodedIntermediate_;
+};
+
+template <typename T>
+std::unique_ptr<exec::Aggregate> createSetDigestAggregate(
+    const TypePtr& resultType) {
+  return std::make_unique<SetDigestAggregate<T>>(resultType);
+}
+
+std::vector<exec::AggregateRegistrationResult> registerMakeSetDigest(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
+
+  // Support all common input types
+  std::vector<std::string> inputTypes = {
+      "boolean",
+      "tinyint",
+      "smallint",
+      "integer",
+      "bigint",
+      "real", // float (32-bit)
+      "double", // double (64-bit)
+      "date", // int32 days since epoch (handled by INTEGER case)
+      "varchar",
+      "varbinary",
+  };
+
+  signatures.reserve(inputTypes.size());
+  for (const auto& inputType : inputTypes) {
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType("SetDigest")
+            .intermediateType("varbinary")
+            .argumentType(inputType)
+            .build());
+  }
+
+  return exec::registerAggregateFunction(
+      names,
+      signatures,
+      [](core::AggregationNode::Step /*step*/,
+         const std::vector<TypePtr>& argTypes,
+         const TypePtr& resultType,
+         const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        const auto& inputType = argTypes[0];
+
+        switch (inputType->kind()) {
+          case TypeKind::BOOLEAN:
+            return createSetDigestAggregate<bool>(resultType);
+          case TypeKind::TINYINT:
+            return createSetDigestAggregate<int8_t>(resultType);
+          case TypeKind::SMALLINT:
+            return createSetDigestAggregate<int16_t>(resultType);
+          case TypeKind::INTEGER:
+            return createSetDigestAggregate<int32_t>(resultType);
+          case TypeKind::BIGINT:
+            return createSetDigestAggregate<int64_t>(resultType);
+          case TypeKind::REAL:
+            return createSetDigestAggregate<float>(resultType);
+          case TypeKind::DOUBLE:
+            return createSetDigestAggregate<double>(resultType);
+          case TypeKind::VARCHAR:
+          case TypeKind::VARBINARY:
+            return createSetDigestAggregate<StringView>(resultType);
+          default:
+            VELOX_UNREACHABLE(
+                "Unsupported input type for make_set_digest: {}",
+                inputType->toString());
+        }
+      },
+      withCompanionFunctions,
+      overwrite);
+}
+
+void registerMakeSetDigestAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  registerMakeSetDigest(names, withCompanionFunctions, overwrite);
+}
+
+class MergeSetDigestAggregate : public exec::Aggregate {
+ private:
+  using SetDigestAccumulator = functions::SetDigest<int64_t>;
+
+ public:
+  explicit MergeSetDigestAggregate(const TypePtr& resultType)
+      : Aggregate(resultType) {}
+
+  int32_t accumulatorFixedWidthSize() const override {
+    return sizeof(SetDigestAccumulator);
+  }
+
+  bool isFixedSize() const override {
+    return false;
+  }
+
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    setAllNulls(groups, indices);
+    for (auto i : indices) {
+      new (groups[i] + offset_) SetDigestAccumulator(allocator_);
+    }
+  }
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedValue_.decode(*args[0], rows);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedValue_.isNullAt(row)) {
+        return;
+      }
+
+      auto* accumulator = value<SetDigestAccumulator>(groups[row]);
+      clearNull(groups[row]);
+
+      auto tracker = trackRowSize(groups[row]);
+      auto serialized = decodedValue_.valueAt<StringView>(row);
+
+      SetDigestAccumulator other(allocator_);
+      auto status = other.deserialize(serialized.data(), serialized.size());
+      VELOX_CHECK(
+          status.ok(), "Failed to deserialize SetDigest: {}", status.message());
+      accumulator->mergeWith(other);
+    });
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedValue_.decode(*args[0], rows);
+
+    auto* accumulator = value<SetDigestAccumulator>(group);
+    auto tracker = trackRowSize(group);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedValue_.isNullAt(row)) {
+        return;
+      }
+
+      clearNull(group);
+
+      auto serialized = decodedValue_.valueAt<StringView>(row);
+
+      SetDigestAccumulator other(allocator_);
+      auto status = other.deserialize(serialized.data(), serialized.size());
+      VELOX_CHECK(
+          status.ok(), "Failed to deserialize SetDigest: {}", status.message());
+      accumulator->mergeWith(other);
+    });
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedIntermediate_.decode(*args[0], rows);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedIntermediate_.isNullAt(row)) {
+        return;
+      }
+
+      auto* accumulator = value<SetDigestAccumulator>(groups[row]);
+      clearNull(groups[row]);
+
+      auto tracker = trackRowSize(groups[row]);
+      auto serialized = decodedIntermediate_.valueAt<StringView>(row);
+
+      SetDigestAccumulator other(allocator_);
+      auto status = other.deserialize(serialized.data(), serialized.size());
+      VELOX_CHECK(
+          status.ok(), "Failed to deserialize SetDigest: {}", status.message());
+      accumulator->mergeWith(other);
+    });
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedIntermediate_.decode(*args[0], rows);
+
+    auto* accumulator = value<SetDigestAccumulator>(group);
+    auto tracker = trackRowSize(group);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedIntermediate_.isNullAt(row)) {
+        return;
+      }
+
+      clearNull(group);
+
+      auto serialized = decodedIntermediate_.valueAt<StringView>(row);
+
+      SetDigestAccumulator other(allocator_);
+      auto status = other.deserialize(serialized.data(), serialized.size());
+      VELOX_CHECK(
+          status.ok(), "Failed to deserialize SetDigest: {}", status.message());
+      accumulator->mergeWith(other);
+    });
+  }
+
+  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    auto* flatResult = (*result)->as<FlatVector<StringView>>();
+    flatResult->resize(numGroups);
+
+    // Calculate total buffer size needed for all non-inline
+    // strings.
+    int64_t totalBufferSize = 0;
+    std::vector<int32_t> sizes(numGroups);
+    for (vector_size_t i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      if (!isNull(group)) {
+        auto* accumulator = value<SetDigestAccumulator>(group);
+        auto size = accumulator->estimatedSerializedSize();
+        sizes[i] = size;
+        if (!StringView::isInline(size)) {
+          totalBufferSize += size;
+        }
+      }
+    }
+
+    // Allocate buffer once for all non-inline strings.
+    char* rawBuffer = nullptr;
+    if (totalBufferSize > 0) {
+      rawBuffer = flatResult->getRawStringBufferWithSpace(totalBufferSize);
+    }
+
+    // Serialize into pre-allocated buffer.
+    for (vector_size_t i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      if (isNull(group)) {
+        flatResult->setNull(i, true);
+      } else {
+        auto* accumulator = value<SetDigestAccumulator>(group);
+        auto size = sizes[i];
+
+        StringView serialized;
+        if (StringView::isInline(size)) {
+          // For small serialized data (<= 12 bytes), use inline StringView
+          // storage to avoid heap allocation overhead.
+          std::string buffer(size, '\0');
+          accumulator->serialize(buffer.data());
+          serialized = StringView::makeInline(buffer);
+        } else {
+          accumulator->serialize(rawBuffer);
+          serialized = StringView(rawBuffer, size);
+          rawBuffer += size;
+        }
+        flatResult->setNoCopy(i, serialized);
+      }
+    }
+  }
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    extractValues(groups, numGroups, result);
+  }
+
+ protected:
+  void destroyInternal(folly::Range<char**> groups) override {
+    destroyAccumulators<SetDigestAccumulator>(groups);
+  }
+
+ private:
+  DecodedVector decodedValue_;
+  DecodedVector decodedIntermediate_;
+};
+
+std::vector<exec::AggregateRegistrationResult> registerMergeSetDigest(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
+
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType("setdigest")
+          .intermediateType("varbinary")
+          .argumentType("setdigest")
+          .build());
+
+  return exec::registerAggregateFunction(
+      names,
+      signatures,
+      [](core::AggregationNode::Step /*step*/,
+         const std::vector<TypePtr>& /*argTypes*/,
+         const TypePtr& resultType,
+         const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        return std::make_unique<MergeSetDigestAggregate>(resultType);
+      },
+      withCompanionFunctions,
+      overwrite);
+}
+
+void registerMergeSetDigestAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  registerMergeSetDigest(names, withCompanionFunctions, overwrite);
+}
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/SetDigestAggregate.h b/velox/functions/prestosql/aggregates/SetDigestAggregate.h
new file mode 100644
index 00000000000..fd4bc3af775
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/SetDigestAggregate.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace facebook::velox::aggregate::prestosql {
+
+void registerMakeSetDigestAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions = true,
+    bool overwrite = true);
+
+void registerMergeSetDigestAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions = true,
+    bool overwrite = true);
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/SumAggregate.cpp b/velox/functions/prestosql/aggregates/SumAggregate.cpp
index 009d1861733..753528293d0 100644
--- a/velox/functions/prestosql/aggregates/SumAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/SumAggregate.cpp
@@ -15,7 +15,6 @@
  */
 #include "velox/functions/prestosql/aggregates/SumAggregate.h"
 #include "velox/functions/lib/aggregates/SumAggregateBase.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 
 using namespace facebook::velox::functions::aggregate;
 
@@ -25,8 +24,8 @@ template <typename TInput, typename TAccumulator, typename ResultType>
 using SumAggregate = SumAggregateBase<TInput, TAccumulator, ResultType, false>;
 
 template <template <typename U, typename V, typename W> class T>
-exec::AggregateRegistrationResult registerSum(
-    const std::string& name,
+std::vector<exec::AggregateRegistrationResult> registerSum(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
@@ -55,22 +54,24 @@ exec::AggregateRegistrationResult registerSum(
         "integer",
         "bigint",
         INTERVAL_DAY_TIME()->name()}) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType("bigint")
-                             .intermediateType("bigint")
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType("bigint")
+            .intermediateType("bigint")
+            .argumentType(inputType)
+            .build());
   }
 
   return exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
+      [names](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
+        const std::string& name = names.front();
         VELOX_CHECK_EQ(argTypes.size(), 1, "{} takes only one argument", name);
         auto inputType = argTypes[0];
         switch (inputType->kind()) {
@@ -115,17 +116,17 @@ exec::AggregateRegistrationResult registerSum(
                 inputType->kindName());
         }
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
 } // namespace
 
 void registerSumAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
-  registerSum<SumAggregate>(prefix + kSum, withCompanionFunctions, overwrite);
+  registerSum<SumAggregate>(names, withCompanionFunctions, overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/SumAggregate.h b/velox/functions/prestosql/aggregates/SumAggregate.h
index 2cdd1878840..16ac9487269 100644
--- a/velox/functions/prestosql/aggregates/SumAggregate.h
+++ b/velox/functions/prestosql/aggregates/SumAggregate.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerSumAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/SumDataSizeForStatsAggregate.cpp b/velox/functions/prestosql/aggregates/SumDataSizeForStatsAggregate.cpp
index 196261e3c9f..5124a33ac88 100644
--- a/velox/functions/prestosql/aggregates/SumDataSizeForStatsAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/SumDataSizeForStatsAggregate.cpp
@@ -18,7 +18,6 @@
 #include "velox/exec/Aggregate.h"
 #include "velox/expression/FunctionSignature.h"
 #include "velox/functions/lib/aggregates/SimpleNumericAggregate.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/serializers/PrestoSerializer.h"
 
 using namespace facebook::velox::functions::aggregate;
@@ -186,33 +185,35 @@ class SumDataSizeForStatsAggregate
 } // namespace
 
 void registerSumDataSizeForStatsAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
 
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .typeVariable("T")
-                           .returnType("bigint")
-                           .intermediateType("bigint")
-                           .argumentType("T")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .typeVariable("T")
+          .returnType("bigint")
+          .intermediateType("bigint")
+          .argumentType("T")
+          .build());
 
-  auto name = prefix + kSumDataSizeForStats;
   exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
+      [names](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
-        VELOX_CHECK_EQ(argTypes.size(), 1, "{} takes only one argument", name);
+        VELOX_CHECK_EQ(
+            argTypes.size(), 1, "{} takes only one argument", names.front());
         auto inputType = argTypes[0];
 
         return std::make_unique<SumDataSizeForStatsAggregate>(resultType);
       },
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/SumDataSizeForStatsAggregate.h b/velox/functions/prestosql/aggregates/SumDataSizeForStatsAggregate.h
index 3c9393ba695..07bb0a71a27 100644
--- a/velox/functions/prestosql/aggregates/SumDataSizeForStatsAggregate.h
+++ b/velox/functions/prestosql/aggregates/SumDataSizeForStatsAggregate.h
@@ -17,11 +17,12 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
 void registerSumDataSizeForStatsAggregate(
-    const std::string& prefix,
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/TDigestAccumulator.h b/velox/functions/prestosql/aggregates/TDigestAccumulator.h
new file mode 100644
index 00000000000..9ef5de6d027
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/TDigestAccumulator.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/functions/lib/TDigest.h"
+
+namespace facebook::velox::aggregate::prestosql {
+
+/// Accumulator holding a TDigest sketch and an optional compression parameter.
+/// Shared by TDigestAggregate and ApproxWinsorizedMeanAggregate.
+struct TDigestAccumulator {
+  explicit TDigestAccumulator(HashStringAllocator* allocator)
+      : digest(StlAllocator<double>(allocator)) {}
+
+  /// Compression factor controlling TDigest accuracy vs memory trade-off.
+  double compression{0.0};
+  /// TDigest sketch accumulating input values for quantile estimation.
+  facebook::velox::functions::TDigest<StlAllocator<double>> digest;
+};
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/TDigestAggregate.cpp b/velox/functions/prestosql/aggregates/TDigestAggregate.cpp
index 96cfabecd60..10158011abc 100644
--- a/velox/functions/prestosql/aggregates/TDigestAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/TDigestAggregate.cpp
@@ -14,10 +14,8 @@
  * limitations under the License.
  */
 // #include <functional>
-#include "velox/common/memory/HashStringAllocator.h"
 #include "velox/exec/Aggregate.h"
-#include "velox/functions/lib/TDigest.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
+#include "velox/functions/prestosql/aggregates/TDigestAccumulator.h"
 #include "velox/vector/FlatVector.h"
 
 using namespace facebook::velox::exec;
@@ -26,14 +24,6 @@ namespace facebook::velox::aggregate::prestosql {
 
 namespace {
 
-struct TDigestAccumulator {
-  explicit TDigestAccumulator(HashStringAllocator* allocator)
-      : digest(StlAllocator<double>(allocator)) {}
-
-  double compression = 0.0;
-  facebook::velox::functions::TDigest<StlAllocator<double>> digest;
-};
-
 template <typename T>
 class TDigestAggregate : public exec::Aggregate {
  private:
@@ -290,8 +280,7 @@ class TDigestAggregate : public exec::Aggregate {
 } // namespace
 
 void registerTDigestAggregate(
-    const std::string& prefix,
-    bool withCompanionFunctions,
+    const std::vector<std::string>& names,
     bool overwrite) {
   std::vector<std::shared_ptr<AggregateFunctionSignature>> signatures;
   for (const auto& signature :
@@ -315,16 +304,16 @@ void registerTDigestAggregate(
             .build()}) {
     signatures.push_back(signature);
   }
-  auto name = prefix + kTDigestAgg;
   exec::registerAggregateFunction(
-      name,
+      names,
       signatures,
-      [name](
+      [names](
           core::AggregationNode::Step /*step*/,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultTypes,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
+        const std::string& name = names.front();
         if (argTypes.empty() || argTypes[0]->kind() != TypeKind::DOUBLE) {
           VELOX_USER_FAIL(
               "The first argument of {} must be of type DOUBLE", name);
@@ -355,8 +344,8 @@ void registerTDigestAggregate(
         return std::make_unique<TDigestAggregate<double>>(
             hasWeight, hasCompression, resultTypes);
       },
-      {true /*orderSensitive*/, false /*companionFunction*/},
-      false /*companionFunction*/,
+      {},
+      false /*registerCompanionFunctions*/,
       overwrite);
 }
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/VarianceAggregates.cpp b/velox/functions/prestosql/aggregates/VarianceAggregates.cpp
index 86d58216727..24ff5ce26c8 100644
--- a/velox/functions/prestosql/aggregates/VarianceAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/VarianceAggregates.cpp
@@ -16,7 +16,6 @@
 #include "velox/functions/prestosql/aggregates/VarianceAggregates.h"
 #include "velox/exec/Aggregate.h"
 #include "velox/functions/lib/aggregates/VarianceAggregatesBase.h"
-#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 
 using namespace facebook::velox::functions::aggregate;
 
@@ -107,30 +106,32 @@ class VarSampAggregate : public VarianceAggregate<T, VarSampResultAccessor> {
 };
 
 template <template <typename TInput> class TClass>
-exec::AggregateRegistrationResult registerVariance(
-    const std::string& name,
+std::vector<exec::AggregateRegistrationResult> registerVariance(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
   std::vector<std::string> inputTypes = {
       "smallint", "integer", "bigint", "real", "double"};
   for (const auto& inputType : inputTypes) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType("double")
-                             .intermediateType("row(bigint,double,double)")
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType("double")
+            .intermediateType("row(bigint,double,double)")
+            .argumentType(inputType)
+            .build());
   }
 
   return exec::registerAggregateFunction(
-      name,
+      names,
       std::move(signatures),
-      [name](
+      [names](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
+        const std::string& name = names.front();
         VELOX_CHECK_LE(
             argTypes.size(), 1, "{} takes at most one argument", name);
         auto inputType = argTypes[0];
@@ -166,22 +167,34 @@ exec::AggregateRegistrationResult registerVariance(
 
 } // namespace
 
-void registerVarianceAggregates(
-    const std::string& prefix,
+void registerStdDevSampAggregate(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite) {
   registerVariance<StdDevSampAggregate>(
-      prefix + kStdDev, withCompanionFunctions, overwrite);
+      names, withCompanionFunctions, overwrite);
+}
+
+void registerStdDevPopAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
   registerVariance<StdDevPopAggregate>(
-      prefix + kStdDevPop, withCompanionFunctions, overwrite);
-  registerVariance<StdDevSampAggregate>(
-      prefix + kStdDevSamp, withCompanionFunctions, overwrite);
-  registerVariance<VarSampAggregate>(
-      prefix + kVariance, withCompanionFunctions, overwrite);
-  registerVariance<VarPopAggregate>(
-      prefix + kVarPop, withCompanionFunctions, overwrite);
-  registerVariance<VarSampAggregate>(
-      prefix + kVarSamp, withCompanionFunctions, overwrite);
+      names, withCompanionFunctions, overwrite);
+}
+
+void registerVarSampAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  registerVariance<VarSampAggregate>(names, withCompanionFunctions, overwrite);
+}
+
+void registerVarPopAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  registerVariance<VarPopAggregate>(names, withCompanionFunctions, overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/VarianceAggregates.h b/velox/functions/prestosql/aggregates/VarianceAggregates.h
index 0984ac54326..df201829ff7 100644
--- a/velox/functions/prestosql/aggregates/VarianceAggregates.h
+++ b/velox/functions/prestosql/aggregates/VarianceAggregates.h
@@ -17,11 +17,27 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace facebook::velox::aggregate::prestosql {
 
-void registerVarianceAggregates(
-    const std::string& prefix,
+void registerStdDevSampAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+void registerStdDevPopAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+void registerVarSampAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+void registerVarPopAggregate(
+    const std::vector<std::string>& names,
     bool withCompanionFunctions,
     bool overwrite);
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/VectorSumAggregate.cpp b/velox/functions/prestosql/aggregates/VectorSumAggregate.cpp
new file mode 100644
index 00000000000..edf215b2136
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/VectorSumAggregate.cpp
@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/prestosql/aggregates/VectorSumAggregate.h"
+#include "velox/exec/Aggregate.h"
+#include "velox/exec/SimpleAggregateAdapter.h"
+#include "velox/expression/FunctionSignature.h"
+
+namespace facebook::velox::aggregate::prestosql {
+
+namespace {
+
+template <typename T>
+inline void addToSum(T& sum, T value) {
+  if constexpr (std::is_floating_point_v<T>) {
+    sum += value;
+  } else {
+    T checkedSum;
+    auto overflow = __builtin_add_overflow(sum, value, &checkedSum);
+
+    if (UNLIKELY(overflow)) {
+      VELOX_ARITHMETIC_ERROR(
+          "integer overflow: {} + {}", (int64_t)sum, (int64_t)value);
+    }
+    sum = checkedSum;
+  }
+}
+
+/// Simple aggregate implementation for vector_sum(array(T)) -> array(T).
+/// Computes element-wise sums of arrays across rows. All input arrays must
+/// have the same length. Null elements follow standard sum aggregate semantics:
+/// they are skipped, and positions where all inputs are null produce null in
+/// the output.
+template <typename T>
+class SimpleVectorSumAggregate {
+ public:
+  using InputType = Row<Array<T>>;
+
+  using IntermediateType = Array<T>;
+
+  using OutputType = Array<T>;
+
+  struct AccumulatorType {
+    using SumsVector = std::vector<T, AlignedStlAllocator<T, 16>>;
+    SumsVector sums_;
+    /// Tracks whether each position has received at least one non-null value.
+    /// Positions where all inputs are null produce null in the output,
+    /// consistent with standard sum aggregate semantics.
+    std::vector<bool, StlAllocator<bool>> hasValue_;
+    bool initialized_{false};
+
+    AccumulatorType() = delete;
+
+    explicit AccumulatorType(
+        HashStringAllocator* allocator,
+        SimpleVectorSumAggregate* /*fn*/)
+        : sums_{AlignedStlAllocator<T, 16>(allocator)},
+          hasValue_{StlAllocator<bool>(allocator)} {}
+
+    static constexpr bool is_fixed_size_ = false;
+    static constexpr bool use_external_memory_ = true;
+
+    void addInput(
+        HashStringAllocator* /*allocator*/,
+        exec::arg_type<Array<T>> arrayInput) {
+      mergeArray(arrayInput);
+    }
+
+    void combine(
+        HashStringAllocator* /*allocator*/,
+        exec::arg_type<Array<T>> other) {
+      mergeArray(other);
+    }
+
+    bool writeFinalResult(exec::out_type<Array<T>>& out) {
+      return writeResult(out);
+    }
+
+    bool writeIntermediateResult(exec::out_type<Array<T>>& out) {
+      return writeResult(out);
+    }
+
+   private:
+    void mergeArray(exec::arg_type<Array<T>> input) {
+      if (!initialized_) {
+        sums_.resize(input.size(), T{0});
+        hasValue_.resize(input.size(), false);
+        size_t idx = 0;
+        for (const auto& element : input) {
+          if (element.has_value()) {
+            sums_[idx] = element.value();
+            hasValue_[idx] = true;
+          }
+          ++idx;
+        }
+        initialized_ = true;
+        return;
+      }
+
+      VELOX_USER_CHECK_EQ(
+          input.size(), sums_.size(), "All arrays must have the same length.");
+
+      size_t idx = 0;
+      for (const auto& element : input) {
+        if (element.has_value()) {
+          hasValue_[idx] = true;
+          auto value = element.value();
+          if (value != T{0}) {
+            addToSum(sums_[idx], value);
+          }
+        }
+        ++idx;
+      }
+    }
+
+    bool writeResult(exec::out_type<Array<T>>& out) {
+      VELOX_DCHECK_EQ(sums_.size(), hasValue_.size());
+      if (!initialized_) {
+        return false;
+      }
+      for (size_t i = 0; i < sums_.size(); ++i) {
+        if (hasValue_[i]) {
+          out.add_item() = sums_[i];
+        } else {
+          out.add_null();
+        }
+      }
+      return true;
+    }
+  };
+};
+
+template <typename T>
+std::unique_ptr<exec::Aggregate> createSimpleVectorSumAggregate(
+    core::AggregationNode::Step step,
+    const std::vector<TypePtr>& argTypes,
+    const TypePtr& resultType) {
+  return std::make_unique<
+      exec::SimpleAggregateAdapter<SimpleVectorSumAggregate<T>>>(
+      step, argTypes, resultType);
+}
+
+} // namespace
+
+void registerVectorSumAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  const std::vector<std::string> elementTypes = {
+      "tinyint", "smallint", "integer", "bigint", "double", "real"};
+
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
+  signatures.reserve(elementTypes.size());
+  for (const auto& elementType : elementTypes) {
+    // array(T) -> array(T) signature.
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType(fmt::format("array({})", elementType))
+            .intermediateType(fmt::format("array({})", elementType))
+            .argumentType(fmt::format("array({})", elementType))
+            .build());
+  }
+
+  exec::registerAggregateFunction(
+      names,
+      signatures,
+      [](core::AggregationNode::Step step,
+         const std::vector<TypePtr>& argTypes,
+         const TypePtr& resultType,
+         const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        VELOX_CHECK_EQ(argTypes.size(), 1);
+        VELOX_CHECK(argTypes[0]->isArray());
+
+        auto& arrayType = argTypes[0]->asArray();
+        auto elementTypeKind = arrayType.elementType()->kind();
+        switch (elementTypeKind) { // NOLINT(clang-diagnostic-switch-enum)
+          case TypeKind::TINYINT:
+            return createSimpleVectorSumAggregate<int8_t>(
+                step, argTypes, resultType);
+          case TypeKind::SMALLINT:
+            return createSimpleVectorSumAggregate<int16_t>(
+                step, argTypes, resultType);
+          case TypeKind::INTEGER:
+            return createSimpleVectorSumAggregate<int32_t>(
+                step, argTypes, resultType);
+          case TypeKind::BIGINT:
+            return createSimpleVectorSumAggregate<int64_t>(
+                step, argTypes, resultType);
+          case TypeKind::REAL:
+            return createSimpleVectorSumAggregate<float>(
+                step, argTypes, resultType);
+          case TypeKind::DOUBLE:
+            return createSimpleVectorSumAggregate<double>(
+                step, argTypes, resultType);
+          default:
+            VELOX_UNREACHABLE(
+                "Unexpected element type: {}",
+                TypeKindName::toName(elementTypeKind));
+        }
+      },
+      withCompanionFunctions,
+      overwrite);
+}
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/VectorSumAggregate.h b/velox/functions/prestosql/aggregates/VectorSumAggregate.h
new file mode 100644
index 00000000000..c4a2bd4e558
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/VectorSumAggregate.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace facebook::velox::aggregate::prestosql {
+
+/// Registers the vector_sum aggregate function.
+/// vector_sum(array(T)) -> array(T)
+/// Computes element-wise sums of all input arrays. Null elements are skipped,
+/// consistent with standard sum aggregate semantics.
+void registerVectorSumAggregate(
+    const std::vector<std::string>& names,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/benchmarks/ReduceAgg.cpp b/velox/functions/prestosql/aggregates/benchmarks/ReduceAgg.cpp
index 2397d0f84a1..06d79b3dd22 100644
--- a/velox/functions/prestosql/aggregates/benchmarks/ReduceAgg.cpp
+++ b/velox/functions/prestosql/aggregates/benchmarks/ReduceAgg.cpp
@@ -32,6 +32,7 @@ static constexpr int32_t kNumVectors = 10;
 static constexpr int32_t kRowsPerVector = 10'000;
 
 namespace {
+using namespace facebook::velox::common::testutil;
 
 // Compare performance of sum(x) with equivalent reduce_agg(x,..).
 class ReduceAggBenchmark : public HiveConnectorTestBase {
@@ -190,7 +191,8 @@ class ReduceAggBenchmark : public HiveConnectorTestBase {
         std::move(plan),
         0,
         core::QueryCtx::create(executor_.get()),
-        exec::Task::ExecutionMode::kSerial);
+        exec::Task::ExecutionMode::kSerial,
+        exec::Consumer{});
 
     task->addSplit(
         "0", exec::Split(makeHiveConnectorSplit(filePath_->getPath())));
diff --git a/velox/functions/prestosql/aggregates/benchmarks/SimpleAggregates.cpp b/velox/functions/prestosql/aggregates/benchmarks/SimpleAggregates.cpp
index 474051c8646..cee2e2e4892 100644
--- a/velox/functions/prestosql/aggregates/benchmarks/SimpleAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/benchmarks/SimpleAggregates.cpp
@@ -33,6 +33,7 @@ static constexpr int32_t kNumVectors = 1'000;
 static constexpr int32_t kRowsPerVector = 10'000;
 
 namespace {
+using namespace facebook::velox::common::testutil;
 
 class SimpleAggregatesBenchmark : public HiveConnectorTestBase {
  public:
@@ -64,8 +65,9 @@ class SimpleAggregatesBenchmark : public HiveConnectorTestBase {
 
       // Generate key with a small number of unique values from a small range
       // (0-16).
-      children.emplace_back(makeFlatVector<int32_t>(
-          kRowsPerVector, [](auto row) { return row % 17; }));
+      children.emplace_back(
+          makeFlatVector<int32_t>(
+              kRowsPerVector, [](auto row) { return row % 17; }));
 
       // Generate key with a small number of unique values from a large range
       // (300 total values).
@@ -165,7 +167,8 @@ class SimpleAggregatesBenchmark : public HiveConnectorTestBase {
         std::move(plan),
         0,
         core::QueryCtx::create(executor_.get()),
-        exec::Task::ExecutionMode::kSerial);
+        exec::Task::ExecutionMode::kSerial,
+        exec::Consumer{});
   }
 
  private:
diff --git a/velox/functions/prestosql/aggregates/benchmarks/TwoStringKeys.cpp b/velox/functions/prestosql/aggregates/benchmarks/TwoStringKeys.cpp
index 30e51c2f347..3fe6f8a7ce7 100644
--- a/velox/functions/prestosql/aggregates/benchmarks/TwoStringKeys.cpp
+++ b/velox/functions/prestosql/aggregates/benchmarks/TwoStringKeys.cpp
@@ -28,6 +28,7 @@ DEFINE_int64(fuzzer_seed, 99887766, "Seed for random input dataset generator");
 using namespace facebook::velox;
 using namespace facebook::velox::connector::hive;
 using namespace facebook::velox::exec::test;
+using namespace facebook::velox::common::testutil;
 
 static constexpr int32_t kNumVectors = 7'000;
 static constexpr int32_t kRowsPerVector = 4'000;
@@ -113,7 +114,8 @@ class TwoStringKeysBenchmark : public HiveConnectorTestBase {
         std::move(plan),
         0,
         core::QueryCtx::create(executor_.get()),
-        exec::Task::ExecutionMode::kSerial);
+        exec::Task::ExecutionMode::kSerial,
+        exec::Consumer{});
 
     task->addSplit(
         "0", exec::Split(makeHiveConnectorSplit((filePath_->getPath()))));
diff --git a/velox/functions/prestosql/aggregates/tests/ApproxDistinctTest.cpp b/velox/functions/prestosql/aggregates/tests/ApproxDistinctTest.cpp
index d18d81b5544..695d2a85848 100644
--- a/velox/functions/prestosql/aggregates/tests/ApproxDistinctTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/ApproxDistinctTest.cpp
@@ -668,5 +668,40 @@ TEST_F(ApproxDistinctTest, mergeMatchJava) {
       "AwwAMkEgAAABEAMAAQEAAAABESABAUEAAAMBABAQIgAQAQEAAAATABMAAAAAACAAAFAGAQAUcREQEEABAAIHAAAgACABAAMUAXAhQGADQQIQAzASBDACITAAAAAAMBIEAQEAARBhIjAAIABDAAAQMAADYAMSAGEwACIAAAAAAEEAAhABMQEhAAIQAAABEREAAAAAAYAAABEDYQIABAAUIBEAAAAAAgICQBAAMAAAEAAQADMAAAAAA0AgAAAAAAACBBUBEAEFAQAAEwEAEAAAIFEWIAAAAAMgADAABCIBAAEQASEAQCAAAAECAjBAEEAAIDABAgABEyFFAABFAwArAABTAgACIAAgAADQExMAAAICABACAxAAEAERABAAAQADAhEAAAAREAAQAgIQIRMAEQIQAgARAQAQAABEAEACAgAAAAASAAMAIDABAAASIBBAEAIAMBEyAQEAQAAwKSIxAgIAUAACIQUCEAAAAAAAABEBYCABAAEgASMAAAAhABEQEAAhAAEACBEAAEAgAGMAEAUQEQEBAAAAACICIQAAAHMAICIlASAQAAAAEyAAAhEQAAABEhMCERAAEiFAADAgADEAIhAAIAAhEiAiEgAQECAiAgIBAAEAAAQBBCAwAQAREAAAABYCIABgAgAAAwADEAAAQAEAAwBAABEEABAQAgECAAAAEBEAACEQAAAgJAAAAAAAAQASARIAEAIAADByEAMkAAACIhQDECAEEBAQAZAwIgAEMCAAADMREEAAAjAQABAiIBICBAAAAhIAQCIARQAQMEEwABAQAAAWMAAAIQEAMQAABAAAAAQAABAAAAAQIRFAAAAAADADEAAgAhAAAAEQAAAQIAEAUiARQAAAAAAAIwMBAAIEEQMQAQAAAAIDAgEAQAIAAAABAAIQEAAQAAAAEAEABQBQIEQAIEMAAAOxAQAABBAQAAAAEAABAQAzIBICEAFDAAAAMAAAERABACICAAkAAAAQAgAAAjABAQEAZxAAAgAAAAAAAAMBAhATABEAAyEAEgMQMgIgAQFAMAECAAECEGEhNQAAAAACAAAhABIAACAAQAADAFQBACEAAQAQBwAAQAAEIBIAASITAwAAEAAAACIhIhAiACAFIBESAABQMgMwERAAAwAgBgAQAAABMQAAIAEAAAEkAQYDEQABACEBIAAwEQIBAQAAVQAgAAAVARAgMAAEADUAEAMgIAAAADEQNUIAAAAAECAQAAARERMSAAEAEQABAQIRBUAQAAAxIQBAATAAAAAhAAABAQACAAASABJAABAAACABEBBgMAABFiAFYAAAADARAgADAAASEAEAEgECIAAAEgAAACAgABMQMAAAECACASAQEAACUQAAARUAEQAAIDAgAiAAAAMRAQIAYAEBAQIwUAEQAAAQMBABAAAAADACAAUBABAgAAEAEAAABAABABMABQEAAAAAQQAQAQAAIAECBAIAAAADERABEAAAAAKQIQAAQAEAAVEgBwACEgQgAwAAEAARAAACEAMgEAABEAEBACAAACEgIEIQAAIAIAAAAAAAAwAAESEAACADAjMCAAEgEAAAABAAEBIAAANgAxAAEQIAABNAARAAAiIAEyEwAxACExEQAAACIDAUAAACAjAAABAhAwEAAAIEABEAABYAARAwEgAQICEBEBMAAAAAUAAQAQACAQAEAQMAEBAAAAEAQwIABQBgAwAWAQAQIAAQAAAAAAAgAQMAYAIBEQEQICADAQACAkAgIAUSAAAABjAHMCAIAQAwQAABAgABFyAgADARAEMgAAAAECIAAAAQAQAQIBEAAAQAAAEQEBAQEAAFAAEQEAATUAEDADAgACABAAEAYSECAAESACQGAAAAAAYiAAAwEAAREAAAABAAIQATAABQIBAAAAAAIDAyAAAAAAAAEQEAAQAAAhAgAABBASAwADAAAiAAIAABFCByAAEABgEAAgAiAAMAA0UAAQABAEAAAQAAEQAAMAAAAAAQIBAAAAAQYAEAAQACAAEBQRIAATIEACAGABAAABIQAwIBAAAAAAMhAQAhAAAhACEwACEDAQEAAAAxEgMAAAIQIDBAAREAAQEAAiMAMAIQQAEQAQAQEABCABIEADAAAAMAAxAFcgQBEQAAEgBBARAAAAEAADIAFAAAAAIAAAABEAABAQAAAAAAETAABAABAAAAAwAAEQAABAACAQAwMQAAACABIAAAAiAAAAECJRAAAhBTBAAQEgAAAgIAEBEAAAAhAAADEBAAUAADIQAwABQAEHABAFABABMhAgAAAwAABCEDQAIwABAQASEBBQAiIDAAEAAAAABRMAAVAAJyEyIEBwAQACEAECEAEAAAIBAAACEAAEJQFAAQEBABIAAQAQAAASAAICACABEAAAAwABADEQBDAAAAEBACUDAAAiAgAAAAAwAAAhAiBgEQIgAQAAAiA1IAAAAAARBAABMAAAAAAxERAQMBQCIBEAJAARAQAAEQUQAQAgAAABABAAAQBQEAIwEgIgAhEQFABQAQAEYBAwAAIAAQICIRIAIAMAJBAAEQABIgBBEAAwACEAIAIQIBAQIAABAAAAAAEBEBAREEAAUhAQMwABABADAzAgIQAAEhFAABIFATEAAAZIAhAiEAEBAAAAJAEgEQEAABABEQABAAAQAAMkAAABABAjAABwRgQgEAABBSEiAAAAEEEAICERAhIAExAAIAYAAAIAEDMAAAABEAEAAAAA==");
 }
 
+// Corrupt DenseHll with negative overflow count crashes the process via
+// std::length_error instead of producing a task error.  Meta internally marks
+// std::vector::_M_check_len as noexcept so the exception is not catchable.
+TEST_F(ApproxDistinctTest, corruptHllCrashesProcess) {
+  // Craft a corrupt DenseHll serialization:
+  //   int8_t  version = 3 (kPrestoDenseV2)
+  //   int8_t  indexBitLength = 4
+  //   int8_t  baseline = 0
+  //   8 bytes of deltas (numBuckets/2 = 16/2 = 8)
+  //   int16_t overflows = -1 (0xFFFF)
+  constexpr int8_t kIndexBitLength = 4;
+  constexpr int32_t kNumBuckets = 1 << kIndexBitLength;
+  constexpr int32_t kDeltaBytes = kNumBuckets / 2;
+  std::string corruptHll(3 + kDeltaBytes + 2, '\0');
+  corruptHll[0] = 3; // version
+  corruptHll[1] = kIndexBitLength;
+  corruptHll[2] = 0; // baseline
+  // Deltas are all zero.
+  // Write overflows = -1 as little-endian int16_t.
+  auto overflowOffset = 3 + kDeltaBytes;
+  corruptHll[overflowOffset] = static_cast<char>(0xFF);
+  corruptHll[overflowOffset + 1] = static_cast<char>(0xFF);
+
+  auto corruptHllBase64 = folly::base64Encode(corruptHll);
+  auto hllVector = makeFlatVector<std::string>({corruptHllBase64});
+
+  auto op = PlanBuilder()
+                .values({makeRowVector({hllVector})})
+                .project({"cast(from_base64(c0) as hyperloglog) as c0"})
+                .singleAggregation({}, {"merge(c0)"})
+                .planNode();
+
+  EXPECT_THROW(AssertQueryBuilder(op).copyResults(pool()), VeloxRuntimeError);
+}
+
 } // namespace
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/ApproxMostFrequentTest.cpp b/velox/functions/prestosql/aggregates/tests/ApproxMostFrequentTest.cpp
index bf9932d4292..339952a995e 100644
--- a/velox/functions/prestosql/aggregates/tests/ApproxMostFrequentTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/ApproxMostFrequentTest.cpp
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/core/QueryConfig.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 
@@ -181,6 +183,121 @@ TEST_F(ApproxMostFrequentTestStringView, stringLifeCycle) {
       {rows, rows}, {}, {"approx_most_frequent(3, c0, 31)"}, {expected});
 }
 
+TEST_F(ApproxMostFrequentTestStringView, globalAggregationWithCompaction) {
+  // Test setup: 1024 unique strings of 1MB each = 1GB total input.
+  // With capacity=100, only 100 strings are kept at any time, so without
+  // compaction, ~924 dead strings accumulate in memory.
+  constexpr int kNumStrings = 1024;
+  constexpr int kCapacity = 100;
+  constexpr size_t kStringLen = 1 << 20; // 1MB
+  constexpr size_t kTotalInputBytes = kNumStrings * kStringLen; // 1GB
+  constexpr size_t kActiveBytes = kCapacity * kStringLen; // 100MB
+
+  // Use a smaller compaction threshold for testing.
+  constexpr uint64_t kCompactionBytes = 256UL << 20; // 256MB
+  constexpr uint64_t kMemoryLimit = 512UL << 20; // 512MB
+
+  std::vector<std::string> strings;
+  strings.reserve(kNumStrings);
+  for (int i = 0; i < kNumStrings; ++i) {
+    auto& s = strings.emplace_back(kStringLen, 'a' + (i % 26));
+    auto indexStr = folly::to<std::string>(i);
+    s.replace(kStringLen - indexStr.size(), indexStr.size(), indexStr);
+  }
+
+  auto values = makeFlatVector<StringView>(
+      kNumStrings, [&](auto row) { return StringView(strings[row]); });
+  auto rows = makeRowVector({values});
+
+  auto plan =
+      exec::test::PlanBuilder()
+          .values({rows})
+          .partialAggregation(
+              {}, {fmt::format("approx_most_frequent(10, c0, {})", kCapacity)})
+          .planNode();
+
+  struct TestSettings {
+    std::string name;
+    std::string compactionBytesConfig;
+    uint64_t memoryLimit;
+    bool expectOOM;
+    std::function<void(uint64_t)> validatePeakMemory;
+
+    std::string debugString() const {
+      return fmt::format(
+          "name: {}, compactionBytesConfig: {}, memoryLimit: {}, expectOOM: {}",
+          name,
+          compactionBytesConfig,
+          memoryLimit,
+          expectOOM);
+    }
+  };
+
+  std::vector<TestSettings> testSettings = {
+      {
+          "compaction-enabled",
+          folly::to<std::string>(kCompactionBytes),
+          kMemoryLimit,
+          false,
+          [=](uint64_t peakMemory) {
+            ASSERT_LT(peakMemory, kCompactionBytes + 2 * kActiveBytes)
+                << "With compaction enabled, peak memory should be bounded near "
+                   "compaction threshold plus active bytes";
+          },
+      },
+      {
+          "oom-without-compaction",
+          "0",
+          kMemoryLimit,
+          true,
+          nullptr,
+      },
+      {
+          "compaction-disabled-large-memory",
+          "0",
+          2UL << 30,
+          false,
+          [=](uint64_t peakMemory) {
+            // Without compaction, peak memory should exceed total input size.
+            ASSERT_GT(peakMemory, kTotalInputBytes)
+                << "Without compaction, peak memory should exceed total input "
+                   "size due to dead string accumulation";
+          },
+      },
+  };
+
+  for (const auto& testSetting : testSettings) {
+    SCOPED_TRACE(testSetting.debugString());
+
+    auto queryPool = memory::memoryManager()->addRootPool(
+        testSetting.name,
+        testSetting.memoryLimit,
+        exec::MemoryReclaimer::create());
+    auto queryCtx = core::QueryCtx::create(
+        executor_.get(), core::QueryConfig{{}}, {}, {}, std::move(queryPool));
+
+    exec::test::AssertQueryBuilder queryBuilder(plan);
+    queryBuilder.queryCtx(queryCtx);
+    if (!testSetting.compactionBytesConfig.empty()) {
+      queryBuilder.config(
+          core::QueryConfig::kAggregationCompactionBytesThreshold,
+          testSetting.compactionBytesConfig);
+    }
+
+    if (testSetting.expectOOM) {
+      VELOX_ASSERT_THROW(
+          queryBuilder.copyResults(pool()), "Exceeded memory pool capacity");
+    } else {
+      auto result = queryBuilder.copyResults(pool());
+      ASSERT_EQ(result->size(), 1);
+      ASSERT_FALSE(result->isNullAt(0));
+
+      auto peakMemory = queryCtx->pool()->peakBytes();
+      testSetting.validatePeakMemory(peakMemory);
+    }
+  }
+}
+
 class ApproxMostFrequentTestBoolean : public AggregationTestBase {
  protected:
   void SetUp() override {
diff --git a/velox/functions/prestosql/aggregates/tests/ApproxPercentileTest.cpp b/velox/functions/prestosql/aggregates/tests/ApproxPercentileTest.cpp
index a5cb8d8adab..b08e62e830b 100644
--- a/velox/functions/prestosql/aggregates/tests/ApproxPercentileTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/ApproxPercentileTest.cpp
@@ -102,11 +102,12 @@ class ApproxPercentileTest : public AggregationTestBase {
       double percentile,
       double accuracy,
       std::optional<T> expectedResult) {
-    SCOPED_TRACE(fmt::format(
-        "weighted={} percentile={} accuracy={}",
-        weights != nullptr,
-        percentile,
-        accuracy));
+    SCOPED_TRACE(
+        fmt::format(
+            "weighted={} percentile={} accuracy={}",
+            weights != nullptr,
+            percentile,
+            accuracy));
     auto rows =
         weights ? makeRowVector({values, weights}) : makeRowVector({values});
 
diff --git a/velox/functions/prestosql/aggregates/tests/ApproxWinsorizedMeanAggregateTest.cpp b/velox/functions/prestosql/aggregates/tests/ApproxWinsorizedMeanAggregateTest.cpp
new file mode 100644
index 00000000000..92f0d347bb3
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/tests/ApproxWinsorizedMeanAggregateTest.cpp
@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <random>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+
+using namespace facebook::velox::functions::aggregate::test;
+using facebook::velox::exec::test::AssertQueryBuilder;
+using facebook::velox::exec::test::PlanBuilder;
+
+namespace facebook::velox::aggregate::test {
+
+class ApproxWinsorizedMeanAggregateTest : public AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+  }
+};
+
+TEST_F(ApproxWinsorizedMeanAggregateTest, globalFullRange) {
+  auto vectors = makeRowVector(
+      {makeFlatVector<double>({1.0, 2.0, 3.0, 4.0, 5.0}),
+       makeConstant<double>(0.0, 5),
+       makeConstant<double>(1.0, 5)});
+  auto expected = makeRowVector({makeFlatVector<double>({3.0})});
+  testAggregations(
+      {vectors}, {}, {"approx_winsorized_mean(c0, c1, c2)"}, {expected});
+}
+
+TEST_F(ApproxWinsorizedMeanAggregateTest, groupBy) {
+  auto vectors = makeRowVector(
+      {makeFlatVector<int32_t>({1, 1, 1, 1, 1, 2, 2, 2, 2, 2}),
+       makeFlatVector<double>(
+           {1.0, 2.0, 3.0, 4.0, 100.0, 10.0, 20.0, 30.0, 40.0, 50.0}),
+       makeConstant<double>(0.0, 10),
+       makeConstant<double>(1.0, 10)});
+
+  auto expected = makeRowVector(
+      {makeFlatVector<int32_t>({1, 2}), makeFlatVector<double>({22.0, 30.0})});
+  testAggregations(
+      {vectors}, {"c0"}, {"approx_winsorized_mean(c1, c2, c3)"}, {expected});
+}
+
+TEST_F(ApproxWinsorizedMeanAggregateTest, nullHandling) {
+  auto vectors = makeRowVector(
+      {makeNullableFlatVector<double>(
+           {1.0, std::nullopt, 3.0, std::nullopt, 5.0}),
+       makeConstant<double>(0.0, 5),
+       makeConstant<double>(1.0, 5)});
+  auto expected = makeRowVector({makeFlatVector<double>({3.0})});
+  testAggregations(
+      {vectors}, {}, {"approx_winsorized_mean(c0, c1, c2)"}, {expected});
+}
+
+TEST_F(ApproxWinsorizedMeanAggregateTest, allNulls) {
+  auto vectors = makeRowVector(
+      {makeNullableFlatVector<double>({std::nullopt, std::nullopt}),
+       makeConstant<double>(0.0, 2),
+       makeConstant<double>(1.0, 2)});
+  auto expected =
+      makeRowVector({makeNullableFlatVector<double>({std::nullopt})});
+  testAggregations(
+      {vectors}, {}, {"approx_winsorized_mean(c0, c1, c2)"}, {expected});
+}
+
+TEST_F(ApproxWinsorizedMeanAggregateTest, invalidBounds) {
+  auto vectors = makeRowVector(
+      {makeFlatVector<double>({1.0, 2.0, 3.0}),
+       makeConstant<double>(-0.1, 3),
+       makeConstant<double>(0.5, 3)});
+  VELOX_ASSERT_THROW(
+      testAggregations(
+          {vectors}, {}, {"approx_winsorized_mean(c0, c1, c2)"}, {""}),
+      ">= 0");
+}
+
+TEST_F(ApproxWinsorizedMeanAggregateTest, boundsReversed) {
+  auto vectors = makeRowVector(
+      {makeFlatVector<double>({1.0, 2.0, 3.0}),
+       makeConstant<double>(0.9, 3),
+       makeConstant<double>(0.1, 3)});
+  VELOX_ASSERT_THROW(
+      testAggregations(
+          {vectors}, {}, {"approx_winsorized_mean(c0, c1, c2)"}, {""}),
+      "less than or equal");
+}
+
+TEST_F(ApproxWinsorizedMeanAggregateTest, nanInput) {
+  auto vectors = makeRowVector(
+      {makeFlatVector<double>({1.0, std::numeric_limits<double>::quiet_NaN()}),
+       makeConstant<double>(0.0, 2),
+       makeConstant<double>(1.0, 2)});
+  VELOX_ASSERT_THROW(
+      testAggregations(
+          {vectors}, {}, {"approx_winsorized_mean(c0, c1, c2)"}, {""}),
+      "Cannot add NaN");
+}
+
+TEST_F(ApproxWinsorizedMeanAggregateTest, withCompression) {
+  std::vector<double> values(1'000);
+  for (int i = 0; i < 1'000; ++i) {
+    values[i] = i;
+  }
+  auto vectors = makeRowVector(
+      {makeFlatVector<double>(values),
+       makeConstant<double>(0.0, 1'000),
+       makeConstant<double>(1.0, 1'000),
+       makeConstant<double>(200.0, 1'000)});
+  auto expected = makeRowVector({makeFlatVector<double>({499.5})});
+  testAggregations(
+      {vectors}, {}, {"approx_winsorized_mean(c0, c1, c2, c3)"}, {expected});
+}
+
+TEST_F(ApproxWinsorizedMeanAggregateTest, nonDefaultBoundsDistributed) {
+  // Exercises non-default quantile bounds (0.01, 0.99) through an explicit
+  // partial→final plan to verify that quantile bounds survive the
+  // intermediate varbinary serialization.
+  constexpr int N{1'000};
+  std::vector<double> values(N);
+  for (int i = 0; i < N; ++i) {
+    values[i] = i;
+  }
+  auto vectors = makeRowVector(
+      {makeFlatVector<double>(values),
+       makeConstant<double>(0.01, N),
+       makeConstant<double>(0.99, N)});
+
+  // Build partial→final plan to test distributed aggregation path.
+  auto plan =
+      PlanBuilder()
+          .values({vectors})
+          .partialAggregation({}, {"approx_winsorized_mean(c0, c1, c2)"})
+          .finalAggregation()
+          .planNode();
+  auto resultVector = AssertQueryBuilder(plan).copyResults(pool());
+  auto result = resultVector->childAt(0)->asFlatVector<double>()->valueAt(0);
+  // Uniform distribution winsorized at 1%/99% — mean should be close to
+  // regular mean (499.5) since uniform is symmetric.
+  ASSERT_NEAR(result, 499.5, 499.5 * 0.02);
+}
+
+TEST_F(ApproxWinsorizedMeanAggregateTest, accuracy) {
+  constexpr int N{100'000};
+  std::vector<double> values(N);
+  std::default_random_engine generator(42);
+  std::lognormal_distribution<> distribution(0, 1.0);
+  for (int i = 0; i < N; ++i) {
+    values[i] = distribution(generator);
+  }
+
+  auto vectors = makeRowVector(
+      {makeFlatVector<double>(values),
+       makeConstant<double>(0.01, N),
+       makeConstant<double>(0.99, N)});
+
+  std::sort(values.begin(), values.end());
+  int lowerIndex{static_cast<int>(N * 0.01)};
+  int upperIndex{static_cast<int>(N * 0.99)};
+  double lowBound{values[lowerIndex]};
+  double highBound{values[upperIndex]};
+  double exactSum{0};
+  for (auto value : values) {
+    exactSum += std::max(lowBound, std::min(highBound, value));
+  }
+  double exactMean{exactSum / N};
+
+  auto plan = PlanBuilder()
+                  .values({vectors})
+                  .singleAggregation({}, {"approx_winsorized_mean(c0, c1, c2)"})
+                  .planNode();
+  auto resultVector = AssertQueryBuilder(plan).copyResults(pool());
+  auto result = resultVector->childAt(0)->asFlatVector<double>()->valueAt(0);
+  ASSERT_NEAR(result, exactMean, std::abs(exactMean) * 0.05);
+}
+
+} // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/ArbitraryTest.cpp b/velox/functions/prestosql/aggregates/tests/ArbitraryTest.cpp
index c250870ec03..d79fbc213ad 100644
--- a/velox/functions/prestosql/aggregates/tests/ArbitraryTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/ArbitraryTest.cpp
@@ -14,12 +14,14 @@
  * limitations under the License.
  */
 
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/exec/Spill.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 #include "velox/functions/lib/window/tests/WindowTestBase.h"
+#include "velox/functions/prestosql/types/IPAddressType.h"
 
+using namespace facebook::velox::common::testutil;
 using namespace facebook::velox::exec::test;
 using namespace facebook::velox::functions::aggregate::test;
 using namespace facebook::velox::window::test;
@@ -28,7 +30,59 @@ namespace facebook::velox::aggregate::test {
 
 namespace {
 
-class ArbitraryTest : public AggregationTestBase {};
+class ArbitraryTest : public AggregationTestBase {
+ protected:
+  // Runs the clustered-input streaming-aggregation test loop.
+  // 'makeBatch' is called for each batch and must return a pair of RowVectors:
+  //   first  = flat reference data (loaded into DuckDB),
+  //   second = (possibly encoded) data fed to Velox.
+  // When both are the same vector the caller can return {v, v}.
+  void testClusteredInput(
+      std::function<std::pair<RowVectorPtr, RowVectorPtr>(int batchSize, int i)>
+          makeBatch) {
+    constexpr int kSize = 1000;
+    for (int batchRows : {kSize, 13}) {
+      std::vector<RowVectorPtr> flatData;
+      std::vector<RowVectorPtr> encodedData;
+      for (int i = 0; i < kSize; i += batchRows) {
+        auto batchSize = std::min(batchRows, kSize - i);
+        auto [flat, encoded] = makeBatch(batchSize, i);
+        flatData.push_back(flat);
+        encodedData.push_back(encoded);
+      }
+      createDuckDbTable(flatData);
+      for (bool mask : {false, true}) {
+        auto builder = PlanBuilder().values(encodedData);
+        std::string expected;
+        if (mask) {
+          builder.partialStreamingAggregation(
+              {"c0"}, {"arbitrary(c1)"}, {"c2"});
+          expected =
+              "select c0, first(c1) filter (where c2 and c1 is not null) from tmp group by 1";
+        } else {
+          builder.partialStreamingAggregation({"c0"}, {"arbitrary(c1)"});
+          expected =
+              "select c0, first(c1) filter (where c1 is not null) from tmp group by 1";
+        }
+        auto plan = builder.finalAggregation().planNode();
+        for (int32_t flushRows : {0, 1}) {
+          SCOPED_TRACE(
+              fmt::format(
+                  "mask={} batchRows={} flushRows={}",
+                  mask,
+                  batchRows,
+                  flushRows));
+          AssertQueryBuilder(plan, duckDbQueryRunner_)
+              .config(core::QueryConfig::kPreferredOutputBatchRows, batchRows)
+              .config(
+                  core::QueryConfig::kStreamingAggregationMinOutputBatchRows,
+                  flushRows)
+              .assertResults(expected);
+        }
+      }
+    }
+  }
+};
 
 TEST_F(ArbitraryTest, noNulls) {
   // Create vectors without nulls because DuckDB's "first" aggregate does not
@@ -352,18 +406,19 @@ TEST_F(ArbitraryTest, interval) {
 }
 
 TEST_F(ArbitraryTest, longDecimal) {
-  auto data = makeRowVector({// Grouping key.
-                             makeFlatVector<int64_t>({1, 1, 2, 2, 3, 3, 4, 4}),
-                             makeNullableFlatVector<int128_t>(
-                                 {HugeInt::build(10, 100),
-                                  HugeInt::build(10, 100),
-                                  HugeInt::build(10, 200),
-                                  HugeInt::build(10, 200),
-                                  std::nullopt,
-                                  std::nullopt,
-                                  std::nullopt,
-                                  HugeInt::build(10, 400)},
-                                 DECIMAL(38, 8))});
+  auto data = makeRowVector(
+      {// Grouping key.
+       makeFlatVector<int64_t>({1, 1, 2, 2, 3, 3, 4, 4}),
+       makeNullableFlatVector<int128_t>(
+           {HugeInt::build(10, 100),
+            HugeInt::build(10, 100),
+            HugeInt::build(10, 200),
+            HugeInt::build(10, 200),
+            std::nullopt,
+            std::nullopt,
+            std::nullopt,
+            HugeInt::build(10, 400)},
+           DECIMAL(38, 8))});
 
   auto expectedResult = makeRowVector({
       makeFlatVector<int64_t>({1, 2, 3, 4}),
@@ -379,18 +434,19 @@ TEST_F(ArbitraryTest, longDecimal) {
 }
 
 TEST_F(ArbitraryTest, shortDecimal) {
-  auto data = makeRowVector({// Grouping key.
-                             makeFlatVector<int64_t>({1, 1, 2, 2, 3, 3, 4, 4}),
-                             makeNullableFlatVector<int64_t>(
-                                 {10000000000000000,
-                                  10000000000000000,
-                                  20000000000000000,
-                                  20000000000000000,
-                                  std::nullopt,
-                                  std::nullopt,
-                                  std::nullopt,
-                                  40000000000000000},
-                                 DECIMAL(15, 2))});
+  auto data = makeRowVector(
+      {// Grouping key.
+       makeFlatVector<int64_t>({1, 1, 2, 2, 3, 3, 4, 4}),
+       makeNullableFlatVector<int64_t>(
+           {10000000000000000,
+            10000000000000000,
+            20000000000000000,
+            20000000000000000,
+            std::nullopt,
+            std::nullopt,
+            std::nullopt,
+            40000000000000000},
+           DECIMAL(15, 2))});
 
   auto expectedResult = makeRowVector({
       makeFlatVector<int64_t>({1, 2, 3, 4}),
@@ -405,6 +461,34 @@ TEST_F(ArbitraryTest, shortDecimal) {
   testAggregations({data}, {"c0"}, {"arbitrary(c1)"}, {expectedResult});
 }
 
+TEST_F(ArbitraryTest, ipAddress) {
+  auto data = makeRowVector(
+      {// Grouping key.
+       makeFlatVector<int64_t>({1, 1, 2, 2, 3, 3, 4, 4}),
+       // IPADDRESS values
+       makeNullableFlatVector<int128_t>(
+           {ipaddress::tryGetIPv6asInt128FromString("192.168.1.1").value(),
+            ipaddress::tryGetIPv6asInt128FromString("192.168.1.1").value(),
+            ipaddress::tryGetIPv6asInt128FromString("10.0.0.1").value(),
+            ipaddress::tryGetIPv6asInt128FromString("10.0.0.1").value(),
+            std::nullopt,
+            std::nullopt,
+            std::nullopt,
+            ipaddress::tryGetIPv6asInt128FromString("172.16.0.1").value()},
+           IPADDRESS())});
+
+  auto expectedResult = makeRowVector(
+      {makeFlatVector<int64_t>({1, 2, 3, 4}),
+       makeNullableFlatVector<int128_t>(
+           {ipaddress::tryGetIPv6asInt128FromString("192.168.1.1").value(),
+            ipaddress::tryGetIPv6asInt128FromString("10.0.0.1").value(),
+            std::nullopt,
+            ipaddress::tryGetIPv6asInt128FromString("172.16.0.1").value()},
+           IPADDRESS())});
+
+  testAggregations({data}, {"c0"}, {"arbitrary(c1)"}, {expectedResult});
+}
+
 class ArbitraryWindowTest : public WindowTestBase {};
 
 TEST_F(ArbitraryWindowTest, basic) {
@@ -455,7 +539,7 @@ TEST_F(ArbitraryTest, spilling) {
   AssertQueryBuilder builder(plan);
 
   exec::TestScopedSpillInjection scopedSpillInjection(100);
-  spillDirectory = exec::test::TempDirectoryPath::create();
+  spillDirectory = TempDirectoryPath::create();
   builder.spillDirectory(spillDirectory->getPath())
       .config(core::QueryConfig::kSpillEnabled, "true")
       .config(core::QueryConfig::kAggregationSpillEnabled, "true")
@@ -466,42 +550,155 @@ TEST_F(ArbitraryTest, spilling) {
 }
 
 TEST_F(ArbitraryTest, clusteredInput) {
-  constexpr int kSize = 1000;
-  for (int batchRows : {kSize, 13}) {
-    std::vector<RowVectorPtr> data;
-    for (int i = 0; i < kSize; i += batchRows) {
-      auto size = std::min(batchRows, kSize - i);
-      data.push_back(makeRowVector({
-          makeFlatVector<int64_t>(size, [&](auto j) { return (i + j) / 17; }),
-          makeFlatVector<std::string>(
-              size, [&](auto j) { return std::to_string(i + j); }),
-          makeFlatVector<bool>(size, [&](auto j) { return (i + j) % 11 == 0; }),
-      }));
-    }
-    createDuckDbTable(data);
-    for (bool mask : {false, true}) {
-      auto builder = PlanBuilder().values(data);
-      std::string expected;
-      if (mask) {
-        builder.partialStreamingAggregation({"c0"}, {"arbitrary(c1)"}, {"c2"});
-        expected = "select c0, first(c1) filter (where c2) from tmp group by 1";
-      } else {
-        builder.partialStreamingAggregation({"c0"}, {"arbitrary(c1)"});
-        expected = "select c0, first(c1) from tmp group by 1";
-      }
-      auto plan = builder.finalAggregation().planNode();
-      for (int32_t flushRows : {0, 1}) {
-        SCOPED_TRACE(fmt::format(
-            "mask={} batchRows={} flushRows={}", mask, batchRows, flushRows));
-        AssertQueryBuilder(plan, duckDbQueryRunner_)
-            .config(core::QueryConfig::kPreferredOutputBatchRows, batchRows)
-            .config(
-                core::QueryConfig::kStreamingAggregationMinOutputBatchRows,
-                flushRows)
-            .assertResults(expected);
-      }
-    }
-  }
+  testClusteredInput([&](int batchSize, int i) {
+    auto row = makeRowVector({
+        makeFlatVector<int64_t>(
+            batchSize, [&](auto j) { return (i + j) / 17; }),
+        makeFlatVector<std::string>(
+            batchSize, [&](auto j) { return std::to_string(i + j); }),
+        makeFlatVector<bool>(
+            batchSize, [&](auto j) { return (i + j) % 11 == 0; }),
+    });
+    return std::make_pair(row, row);
+  });
+}
+
+// Tests that addRawClusteredInput correctly decodes dictionary-encoded inputs
+// and stores the base vector in the accumulator. Uses a non-identity dictionary
+// mapping (reversed) so that storing the wrong vector/index pair would produce
+// incorrect results.
+TEST_F(ArbitraryTest, clusteredInputDictionaryEncoded) {
+  testClusteredInput([&](int batchSize, int i) {
+    auto keys = makeFlatVector<int64_t>(
+        batchSize, [&](auto j) { return (i + j) / 17; });
+    auto values = makeFlatVector<std::string>(
+        batchSize, [&](auto j) { return std::to_string(i + j); });
+    auto mask = makeFlatVector<bool>(
+        batchSize, [&](auto j) { return (i + j) % 11 == 0; });
+
+    auto reversedBase = makeFlatVector<std::string>(batchSize, [&](auto j) {
+      return std::to_string(i + (batchSize - 1 - j));
+    });
+    auto indices =
+        makeIndices(batchSize, [&](auto idx) { return batchSize - 1 - idx; });
+    auto dictValues =
+        BaseVector::wrapInDictionary(nullptr, indices, batchSize, reversedBase);
+
+    return std::make_pair(
+        makeRowVector({keys, values, mask}),
+        makeRowVector({keys, dictValues, mask}));
+  });
+}
+
+// Tests that addRawClusteredInput correctly decodes constant-encoded inputs.
+// When input is a ConstantVector, decodeAndGetBase returns the underlying flat
+// vector and the decoded index, both of which must be stored consistently in
+// the accumulator.
+TEST_F(ArbitraryTest, clusteredInputConstantEncoded) {
+  testClusteredInput([&](int batchSize, int i) {
+    auto keys = makeFlatVector<int64_t>(
+        batchSize, [&](auto j) { return (i + j) / 17; });
+    auto constantValue = fmt::format("batch_{}", i);
+    auto values = makeFlatVector<std::string>(
+        batchSize, [&](auto /*j*/) { return constantValue; });
+    auto mask = makeFlatVector<bool>(
+        batchSize, [&](auto j) { return (i + j) % 11 == 0; });
+
+    auto singleValue =
+        makeFlatVector<std::string>(1, [&](auto) { return constantValue; });
+    auto constValues = BaseVector::wrapInConstant(batchSize, 0, singleValue);
+
+    return std::make_pair(
+        makeRowVector({keys, values, mask}),
+        makeRowVector({keys, constValues, mask}));
+  });
+}
+
+// Tests dictionary-encoded inputs with nulls injected via the dictionary's null
+// bitmap. This exercises the null-skipping branch in addRawClusteredInput with
+// encoded vectors where the accumulator must correctly store the base vector
+// and decoded index for the first non-null row.
+TEST_F(ArbitraryTest, clusteredInputDictionaryEncodedWithNulls) {
+  testClusteredInput([&](int batchSize, int i) {
+    auto keys = makeFlatVector<int64_t>(
+        batchSize, [&](auto j) { return (i + j) / 17; });
+    auto values = makeFlatVector<std::string>(
+        batchSize,
+        [&](auto j) { return std::to_string(i + j); },
+        [&](auto j) { return (i + j) % 3 == 0; });
+    auto mask = makeFlatVector<bool>(
+        batchSize, [&](auto j) { return (i + j) % 11 == 0; });
+
+    auto reversedBase = makeFlatVector<std::string>(batchSize, [&](auto j) {
+      return std::to_string(i + (batchSize - 1 - j));
+    });
+    auto indices =
+        makeIndices(batchSize, [&](auto idx) { return batchSize - 1 - idx; });
+    auto nulls = makeNulls(batchSize, [&](auto j) { return (i + j) % 3 == 0; });
+    auto dictValues =
+        BaseVector::wrapInDictionary(nulls, indices, batchSize, reversedBase);
+
+    return std::make_pair(
+        makeRowVector({keys, values, mask}),
+        makeRowVector({keys, dictValues, mask}));
+  });
+}
+
+// Tests the optimization in NonNumericArbitrary::extractValues where when the
+// source vector size equals numGroups for a single contiguous range, we assign
+// the source vector directly instead of slicing.
+TEST_F(ArbitraryTest, clusteredInputDirectVectorAssign) {
+  // Each batch has exactly one row per distinct group so that when
+  // extractValues runs, the source vector size matches numGroups, triggering
+  // the direct assignment path (no slice).
+  constexpr int kNumGroups = 100;
+  std::vector<RowVectorPtr> data;
+  data.push_back(makeRowVector({
+      makeFlatVector<int64_t>(kNumGroups, [](auto j) { return j; }),
+      makeFlatVector<std::string>(
+          kNumGroups, [](auto j) { return std::to_string(j * 10); }),
+  }));
+
+  createDuckDbTable(data);
+
+  auto plan = PlanBuilder()
+                  .values(data)
+                  .partialStreamingAggregation({"c0"}, {"arbitrary(c1)"})
+                  .finalAggregation()
+                  .planNode();
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .config(core::QueryConfig::kPreferredOutputBatchRows, kNumGroups)
+      .config(core::QueryConfig::kStreamingAggregationMinOutputBatchRows, 0)
+      .assertResults("select c0, first(c1) from tmp group by 1");
+}
+
+// Also verify the direct vector assign path with multiple batches where the
+// source vector size may differ from numGroups (exercises the slice fallback).
+TEST_F(ArbitraryTest, clusteredInputSliceFallback) {
+  // Use a larger batch size than the number of groups so that the source
+  // vector size exceeds numGroups, exercising the existing slice path.
+  constexpr int kSize = 200;
+  constexpr int kGroupDivisor = 5;
+  std::vector<RowVectorPtr> data;
+  data.push_back(makeRowVector({
+      makeFlatVector<int64_t>(kSize, [](auto j) { return j / kGroupDivisor; }),
+      makeFlatVector<std::string>(
+          kSize, [](auto j) { return std::to_string(j); }),
+  }));
+
+  createDuckDbTable(data);
+
+  auto plan = PlanBuilder()
+                  .values(data)
+                  .partialStreamingAggregation({"c0"}, {"arbitrary(c1)"})
+                  .finalAggregation()
+                  .planNode();
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .config(core::QueryConfig::kPreferredOutputBatchRows, kSize)
+      .config(core::QueryConfig::kStreamingAggregationMinOutputBatchRows, 0)
+      .assertResults("select c0, first(c1) from tmp group by 1");
 }
 
 } // namespace
diff --git a/velox/functions/prestosql/aggregates/tests/ArrayAggTest.cpp b/velox/functions/prestosql/aggregates/tests/ArrayAggTest.cpp
index 76c672f7438..3088873a52f 100644
--- a/velox/functions/prestosql/aggregates/tests/ArrayAggTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/ArrayAggTest.cpp
@@ -586,8 +586,12 @@ TEST_F(ArrayAggTest, clusteredInput) {
       }
       auto plan = builder.finalAggregation().planNode();
       for (int32_t flushRows : {0, 1}) {
-        SCOPED_TRACE(fmt::format(
-            "mask={} batchRows={} flushRows={}", mask, batchRows, flushRows));
+        SCOPED_TRACE(
+            fmt::format(
+                "mask={} batchRows={} flushRows={}",
+                mask,
+                batchRows,
+                flushRows));
         AssertQueryBuilder(plan, duckDbQueryRunner_)
             .config(core::QueryConfig::kPreferredOutputBatchRows, batchRows)
             .config(
@@ -599,5 +603,33 @@ TEST_F(ArrayAggTest, clusteredInput) {
   }
 }
 
+TEST_F(ArrayAggTest, maskedRows) {
+  std::vector<int> numRows{1, 5};
+  std::vector<RowVectorPtr> data;
+  data.reserve(numRows.size());
+  for (auto numRow : numRows) {
+    data.emplace_back(makeRowVector({
+        makeFlatVector<int64_t>(numRow, [](auto row) { return row; }),
+        makeFlatVector<int64_t>(
+            numRow,
+            [](auto row) { return row; },
+            [](auto row) { return true; }),
+        makeFlatVector<bool>(numRow, [](auto row) { return false; }),
+    }));
+  }
+  createDuckDbTable({data});
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .streamingAggregation(
+                      {"c0"},
+                      {"array_agg(c1)"},
+                      {"c2"},
+                      core::AggregationNode::Step::kSingle,
+                      /*ignoreNullKeys=*/false,
+                      /*noGroupsSpanBatches=*/true)
+                  .planNode();
+  auto task = AssertQueryBuilder(plan, duckDbQueryRunner_)
+                  .assertResults("SELECT c0, null FROM tmp");
+}
 } // namespace
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/CMakeLists.txt b/velox/functions/prestosql/aggregates/tests/CMakeLists.txt
index cc583e32d56..b410dade7ea 100644
--- a/velox/functions/prestosql/aggregates/tests/CMakeLists.txt
+++ b/velox/functions/prestosql/aggregates/tests/CMakeLists.txt
@@ -12,14 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(
-  velox_aggregates_test
+# Split velox_aggregates_test into individual test binaries for parallel execution.
+set(
+  VELOX_AGGREGATES_TEST_SOURCES
   AggregationFunctionRegTest.cpp
   ApproxDistinctTest.cpp
   ApproxMostFrequentTest.cpp
   ApproxPercentileTest.cpp
+  ApproxWinsorizedMeanAggregateTest.cpp
   ArbitraryTest.cpp
   ArrayAggTest.cpp
+  VectorSumTest.cpp
   AverageAggregationTest.cpp
   BitwiseAggregationTest.cpp
   BoolAndOrTest.cpp
@@ -33,7 +36,7 @@ add_executable(
   EntropyAggregationTest.cpp
   GeometricMeanTest.cpp
   HistogramTest.cpp
-  Main.cpp
+  KHyperLogLogAggregateTest.cpp
   MapAccumulatorTest.cpp
   MapAggTest.cpp
   MapUnionAggregationTest.cpp
@@ -50,17 +53,17 @@ add_executable(
   PrestoHasherTest.cpp
   QDigestAggTest.cpp
   ReduceAggTest.cpp
+  ReservoirSampleTest.cpp
   SetAggTest.cpp
+  SetDigestAggregateTest.cpp
   SetUnionTest.cpp
   SumDataSizeForStatsTest.cpp
   SumTest.cpp
   VarianceAggregationTest.cpp
 )
 
-add_test(NAME velox_aggregates_test COMMAND velox_aggregates_test WORKING_DIRECTORY .)
-
-target_link_libraries(
-  velox_aggregates_test
+set(
+  VELOX_AGGREGATES_TEST_DEPS
   velox_aggregates
   velox_core
   velox_dwio_common_test_utils
@@ -77,8 +80,30 @@ target_link_libraries(
   velox_simple_aggregate
   velox_type
   velox_vector_fuzzer
-  velox_temp_path
+  velox_test_util
   gflags::gflags
   GTest::gtest
   GTest::gtest_main
 )
+
+velox_add_grouped_tests(
+  PREFIX velox_aggregates_test
+  SOURCES ${VELOX_AGGREGATES_TEST_SOURCES}
+  DEPS ${VELOX_AGGREGATES_TEST_DEPS}
+  EXTRA_SOURCES Main.cpp
+  WORKING_DIRECTORY .
+)
+
+if(${VELOX_ENABLE_GEO})
+  add_executable(velox_aggregates_GeometryAggregateTest GeometryAggregateTest.cpp Main.cpp)
+  add_test(
+    NAME velox_aggregates_GeometryAggregateTest
+    COMMAND velox_aggregates_GeometryAggregateTest
+    WORKING_DIRECTORY .
+  )
+  target_link_libraries(
+    velox_aggregates_GeometryAggregateTest
+    ${VELOX_AGGREGATES_TEST_DEPS}
+    velox_functions_geo
+  )
+endif()
diff --git a/velox/functions/prestosql/aggregates/tests/CountAggregationTest.cpp b/velox/functions/prestosql/aggregates/tests/CountAggregationTest.cpp
index 1b4ca57329c..69191818c84 100644
--- a/velox/functions/prestosql/aggregates/tests/CountAggregationTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/CountAggregationTest.cpp
@@ -150,7 +150,7 @@ TEST_F(CountAggregationTest, mask) {
               "SELECT k, count(c) FILTER (where m) FROM tmp GROUP BY k");
   auto taskStats = toPlanStats(task->taskStats());
   auto partialStats = taskStats.at(partialNodeId).customStats;
-  EXPECT_LT(0, partialStats.at("abandonedPartialAggregation").count);
+  EXPECT_LT(0, partialStats.at("abandonedPartialAggregationRows").sum);
 }
 
 TEST_F(CountAggregationTest, distinct) {
@@ -213,8 +213,9 @@ TEST_F(CountAggregationTest, distinct) {
                         {"c0"}, {fmt::format("count(distinct {})", input)})
                     .planNode();
     AssertQueryBuilder(plan, duckDbQueryRunner_)
-        .assertResults(fmt::format(
-            "SELECT c0, count(distinct {}) FROM tmp GROUP BY 1", input));
+        .assertResults(
+            fmt::format(
+                "SELECT c0, count(distinct {}) FROM tmp GROUP BY 1", input));
   };
 
   testGroupBy("c1");
diff --git a/velox/functions/prestosql/aggregates/tests/GeometricMeanTest.cpp b/velox/functions/prestosql/aggregates/tests/GeometricMeanTest.cpp
index 9a6a46dcd11..b9c8e1077b4 100644
--- a/velox/functions/prestosql/aggregates/tests/GeometricMeanTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/GeometricMeanTest.cpp
@@ -79,9 +79,10 @@ TEST_F(GeometricMeanTest, globalIntegers) {
   });
 
   auto expected = makeRowVector({
-      makeFlatVector(std::vector<double>{
-          geometricMean<double>(1, 100, 1, [](int32_t i) { return i / 7; }),
-      }),
+      makeFlatVector(
+          std::vector<double>{
+              geometricMean<double>(1, 100, 1, [](int32_t i) { return i / 7; }),
+          }),
   });
 
   testAggregations({data}, {}, {"geometric_mean(c0)"}, {expected});
@@ -143,8 +144,9 @@ TEST_F(GeometricMeanTest, globalDoubles) {
   });
 
   auto expected = makeRowVector({
-      makeFlatVector(std::vector<double>{geometricMean<double>(
-          0, 100, 1, [&](int32_t i) { return i * 0.1 / 7; })}),
+      makeFlatVector(
+          std::vector<double>{geometricMean<double>(
+              0, 100, 1, [&](int32_t i) { return i * 0.1 / 7; })}),
   });
 
   testAggregations({data}, {}, {"geometric_mean(c0)"}, {expected});
@@ -175,8 +177,9 @@ TEST_F(GeometricMeanTest, globalReals) {
   });
 
   auto expected = makeRowVector({
-      makeFlatVector(std::vector<float>{geometricMean<float>(
-          0, 100, 1, [&](int32_t i) { return i * 0.1 / 7; })}),
+      makeFlatVector(
+          std::vector<float>{geometricMean<float>(
+              0, 100, 1, [&](int32_t i) { return i * 0.1 / 7; })}),
   });
 
   testAggregations({data}, {}, {"geometric_mean(c0)"}, {expected});
diff --git a/velox/functions/prestosql/aggregates/tests/GeometryAggregateTest.cpp b/velox/functions/prestosql/aggregates/tests/GeometryAggregateTest.cpp
new file mode 100644
index 00000000000..2fb29206b09
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/tests/GeometryAggregateTest.cpp
@@ -0,0 +1,442 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+
+using namespace facebook::velox::exec;
+using namespace facebook::velox::functions::aggregate::test;
+
+namespace facebook::velox::aggregate::test {
+
+namespace {
+
+class GeometryAggregateTest : public AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+  }
+
+  void testGeometryAggregate(
+      const std::vector<std::string>& inputWkts,
+      std::string_view aggregation,
+      std::optional<std::string> outputWkt) {
+    auto data = makeRowVector({
+        makeFlatVector(inputWkts),
+    });
+
+    std::string outputSql;
+    if (outputWkt.has_value()) {
+      outputSql = fmt::format("SELECT '{}'", outputWkt.value());
+    } else {
+      outputSql = "SELECT NULL";
+    }
+
+    testAggregations(
+        [&](exec::test::PlanBuilder& builder) {
+          builder.values({data}).project({"st_geometryfromtext(c0) AS geom"});
+        },
+        {},
+        {fmt::format("{}(geom) as agg", aggregation)},
+        {"st_astext(agg)"},
+        [&](auto& builder) { return builder.assertResults(outputSql); });
+  }
+};
+
+TEST_F(GeometryAggregateTest, convexHullNoRows) {
+  testGeometryAggregate({}, "convex_hull_agg", std::nullopt);
+}
+
+TEST_F(GeometryAggregateTest, convexHullSingleEmpty) {
+  testGeometryAggregate(
+      {"POINT EMPTY"}, "convex_hull_agg", "GEOMETRYCOLLECTION EMPTY");
+}
+
+TEST_F(GeometryAggregateTest, convexHullSinglePoint) {
+  testGeometryAggregate({"POINT (1 2)"}, "convex_hull_agg", "POINT (1 2)");
+}
+
+TEST_F(GeometryAggregateTest, convexHullMultiplePoints) {
+  testGeometryAggregate(
+      {"POINT (0 0)", "POINT (1 1)", "POINT (1 0)"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 1 1, 1 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullMultipleLinearPoints) {
+  testGeometryAggregate(
+      {"POINT (1 2)", "POINT (3 4)", "POINT (4 5)"},
+      "convex_hull_agg",
+      "LINESTRING (1 2, 4 5)");
+}
+
+TEST_F(GeometryAggregateTest, convexHullSinglePolygon) {
+  testGeometryAggregate(
+      {"POLYGON ((0 0, 1 1, 1 0, 0 0), (0.5 0.5, 0.6 0.6, 0.6 0.5, 0.5 0.5))"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 1 1, 1 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullLineString) {
+  testGeometryAggregate(
+      {"LINESTRING (0 0, 1 1, 2 0)"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 1 1, 2 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullMultipleLineStrings) {
+  testGeometryAggregate(
+      {"LINESTRING (0 0, 1 1)", "LINESTRING (1 0, 2 1)"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 1 1, 2 1, 1 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullMultiPoint) {
+  testGeometryAggregate(
+      {"MULTIPOINT (0 0, 1 1, 2 0)"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 1 1, 2 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullMultiLineString) {
+  testGeometryAggregate(
+      {"MULTILINESTRING ((0 0, 1 1), (1 0, 2 1))"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 1 1, 2 1, 1 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullMultiPolygon) {
+  testGeometryAggregate(
+      {"MULTIPOLYGON (((0 0, 1 0, 1 1, 0 1, 0 0)), ((2 2, 3 2, 3 3, 2 3, 2 2)))"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 0 1, 2 3, 3 3, 3 2, 1 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullGeometryCollection) {
+  testGeometryAggregate(
+      {"GEOMETRYCOLLECTION (POINT (0 0), LINESTRING (1 1, 2 1), POLYGON ((3 0, 4 0, 4 1, 3 1, 3 0)))"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 1 1, 4 1, 4 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullMixedGeometryTypes) {
+  testGeometryAggregate(
+      {"POINT (0 0)",
+       "LINESTRING (1 1, 2 1)",
+       "POLYGON ((3 0, 4 0, 4 1, 3 1, 3 0))"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 1 1, 4 1, 4 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullOverlappingPoints) {
+  testGeometryAggregate(
+      {"POINT (0 0)", "POINT (0 0)", "POINT (1 1)", "POINT (1 0)"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 1 1, 1 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullOverlappingPolygons) {
+  testGeometryAggregate(
+      {"POLYGON ((0 0, 2 0, 2 2, 0 2, 0 0))",
+       "POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1))"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 0 2, 1 3, 3 3, 3 1, 2 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullNonOverlappingPolygons) {
+  testGeometryAggregate(
+      {"POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))",
+       "POLYGON ((3 3, 4 3, 4 4, 3 4, 3 3))"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 0 1, 3 4, 4 4, 4 3, 1 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullDuplicateCoordinatesAcrossGeometries) {
+  testGeometryAggregate(
+      {"POINT (0 0)",
+       "LINESTRING (0 0, 1 1)",
+       "POLYGON ((0 0, 2 0, 1 1, 0 0))"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 1 1, 2 0, 0 0))");
+}
+
+TEST_F(
+    GeometryAggregateTest,
+    convexHullDuplicateCoordinatesMultipleGeometries) {
+  testGeometryAggregate(
+      {"POINT (1 1)",
+       "POINT (1 1)",
+       "LINESTRING (1 1, 2 2)",
+       "POLYGON ((1 1, 3 1, 2 2, 1 1))"},
+      "convex_hull_agg",
+      "POLYGON ((1 1, 2 2, 3 1, 1 1))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullMixedWithEmpty) {
+  testGeometryAggregate(
+      {"POINT EMPTY", "POINT (1 1)", "POINT (2 2)", "POINT (1 2)"},
+      "convex_hull_agg",
+      "POLYGON ((1 1, 1 2, 2 2, 1 1))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullMultipleEmpty) {
+  testGeometryAggregate(
+      {"POINT EMPTY", "LINESTRING EMPTY", "POLYGON EMPTY"},
+      "convex_hull_agg",
+      "GEOMETRYCOLLECTION EMPTY");
+}
+
+TEST_F(GeometryAggregateTest, convexHullComplexGeometryCollection) {
+  testGeometryAggregate(
+      {"GEOMETRYCOLLECTION (POINT (0 0), MULTIPOINT (1 1, 2 2))",
+       "GEOMETRYCOLLECTION (LINESTRING (3 3, 4 4), POLYGON ((5 5, 6 5, 6 6, 5 6, 5 5)))"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 5 6, 6 6, 6 5, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullOverlappingLineStrings) {
+  testGeometryAggregate(
+      {"LINESTRING (0 0, 2 2)",
+       "LINESTRING (1 1, 3 3)",
+       "LINESTRING (0 2, 2 0)"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 0 2, 3 3, 2 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullNonOverlappingLineStrings) {
+  testGeometryAggregate(
+      {"LINESTRING (0 0, 1 0)", "LINESTRING (5 5, 6 5)"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 5 5, 6 5, 1 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullAllSamePoint) {
+  testGeometryAggregate(
+      {"POINT (5 5)", "POINT (5 5)", "POINT (5 5)"},
+      "convex_hull_agg",
+      "POINT (5 5)");
+}
+
+TEST_F(GeometryAggregateTest, convexHullCollinearPoints) {
+  testGeometryAggregate(
+      {"POINT (0 0)", "POINT (1 1)", "POINT (2 2)", "POINT (3 3)"},
+      "convex_hull_agg",
+      "LINESTRING (0 0, 3 3)");
+}
+
+TEST_F(GeometryAggregateTest, convexHullMixedDimensionalGeometries) {
+  testGeometryAggregate(
+      {"POINT (0 0)",
+       "LINESTRING (1 0, 2 0)",
+       "POLYGON ((0 1, 1 2, 2 1, 0 1))"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 0 1, 1 2, 2 1, 2 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullNestedGeometryCollections) {
+  testGeometryAggregate(
+      {"GEOMETRYCOLLECTION (GEOMETRYCOLLECTION (POINT (0 0), POINT (1 1)), POINT (2 2))",
+       "POINT (0 2)"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 0 2, 2 2, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullLargeCoordinates) {
+  testGeometryAggregate(
+      {"POINT (1000000 2000000)",
+       "POINT (3000000 4000000)",
+       "POINT (1000000 4000000)"},
+      "convex_hull_agg",
+      "POLYGON ((1000000 2000000, 1000000 4000000, 3000000 4000000, 1000000 2000000))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullNegativeCoordinates) {
+  testGeometryAggregate(
+      {"POINT (-1 -1)", "POINT (1 1)", "POINT (-1 1)", "POINT (1 -1)"},
+      "convex_hull_agg",
+      "POLYGON ((-1 -1, -1 1, 1 1, 1 -1, -1 -1))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullDecimalCoordinates) {
+  testGeometryAggregate(
+      {"POINT (0.5 0.5)",
+       "POINT (1.5 1.5)",
+       "POINT (0.5 1.5)",
+       "POINT (1.5 0.5)"},
+      "convex_hull_agg",
+      "POLYGON ((0.5 0.5, 0.5 1.5, 1.5 1.5, 1.5 0.5, 0.5 0.5))");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionNoRows) {
+  testGeometryAggregate({}, "geometry_union_agg", std::nullopt);
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionSingleEmpty) {
+  testGeometryAggregate(
+      {"POINT EMPTY"}, "geometry_union_agg", "GEOMETRYCOLLECTION EMPTY");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionMultipleEmpty) {
+  testGeometryAggregate(
+      {"POINT EMPTY", "LINESTRING EMPTY", "POLYGON EMPTY"},
+      "geometry_union_agg",
+      "GEOMETRYCOLLECTION EMPTY");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionSinglePoint) {
+  testGeometryAggregate({"POINT (1 2)"}, "geometry_union_agg", "POINT (1 2)");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionRepeatedPoints) {
+  testGeometryAggregate(
+      {"POINT (1 2)", "POINT (1 2)", "POINT (1 2)"},
+      "geometry_union_agg",
+      "POINT (1 2)");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionMultiplePoints) {
+  testGeometryAggregate(
+      {"POINT (0 0)", "POINT (1 1)", "POINT (2 0)"},
+      "geometry_union_agg",
+      "MULTIPOINT (0 0, 1 1, 2 0)");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionRepeatedGeometries) {
+  testGeometryAggregate(
+      {"POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))",
+       "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0)))"},
+      "geometry_union_agg",
+      "POLYGON ((0 1, 1 1, 1 0, 0 0, 0 1))");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionOverlappingPolygons) {
+  testGeometryAggregate(
+      {"POLYGON ((0 0, 0 2, 2 2, 2 0, 0 0))",
+       "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))"},
+      "geometry_union_agg",
+      "POLYGON ((0 2, 1 2, 1 3, 3 3, 3 1, 2 1, 2 0, 0 0, 0 2))"
+
+  );
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionMixedDimensionsPointLine) {
+  testGeometryAggregate(
+      {"POINT (0 0)", "LINESTRING (1 1, 2 2)"},
+      "geometry_union_agg",
+      "GEOMETRYCOLLECTION (POINT (0 0), LINESTRING (1 1, 2 2))");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionMixedDimensionsPointPolygon) {
+  testGeometryAggregate(
+      {"POINT (0 0)", "POLYGON ((1 1, 2 1, 2 2, 1 2, 1 1))"},
+      "geometry_union_agg",
+      "GEOMETRYCOLLECTION (POINT (0 0), POLYGON ((1 1, 1 2, 2 2, 2 1, 1 1)))");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionMixedDimensionsLinePolygon) {
+  testGeometryAggregate(
+      {"LINESTRING (0 0, 1 1)", "POLYGON ((2 2, 3 2, 3 3, 2 3, 2 2))"},
+      "geometry_union_agg",
+      "GEOMETRYCOLLECTION (LINESTRING (0 0, 1 1), POLYGON ((2 2, 2 3, 3 3, 3 2, 2 2)))");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionMixedDimensionsAll) {
+  testGeometryAggregate(
+      {"POINT (0 0)",
+       "LINESTRING (1 1, 2 2)",
+       "POLYGON ((3 3, 4 3, 4 4, 3 4, 3 3))"},
+      "geometry_union_agg",
+      "GEOMETRYCOLLECTION (POINT (0 0), LINESTRING (1 1, 2 2), POLYGON ((3 3, 3 4, 4 4, 4 3, 3 3)))");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionMixedWithEmpty) {
+  testGeometryAggregate(
+      {"POINT EMPTY", "POINT (1 1)", "POINT (2 2)"},
+      "geometry_union_agg",
+      "MULTIPOINT (1 1, 2 2)");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionLineStrings) {
+  testGeometryAggregate(
+      {"LINESTRING (0 0, 1 1)", "LINESTRING (1 1, 2 2)"},
+      "geometry_union_agg",
+      "MULTILINESTRING ((0 0, 1 1), (1 1, 2 2))");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionAdjacentPolygons) {
+  testGeometryAggregate(
+      {"POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))",
+       "POLYGON ((1 0, 2 0, 2 1, 1 1, 1 0))"},
+      "geometry_union_agg",
+      "POLYGON ((0 1, 1 1, 2 1, 2 0, 1 0, 0 0, 0 1))"
+
+  );
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionMultiPoint) {
+  testGeometryAggregate(
+      {"MULTIPOINT (0 0, 1 1)", "POINT (2 2)"},
+      "geometry_union_agg",
+      "MULTIPOINT (0 0, 1 1, 2 2)");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionMultiLineString) {
+  testGeometryAggregate(
+      {"MULTILINESTRING ((0 0, 1 1), (2 2, 3 3))", "LINESTRING (4 4, 5 5)"},
+      "geometry_union_agg",
+      "MULTILINESTRING ((0 0, 1 1), (2 2, 3 3), (4 4, 5 5))");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionGeometryCollection) {
+  testGeometryAggregate(
+      {"GEOMETRYCOLLECTION (POINT (0 0), LINESTRING (1 1, 2 2))"},
+      "geometry_union_agg",
+      "GEOMETRYCOLLECTION (POINT (0 0), LINESTRING (1 1, 2 2))");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionPointInsidePolygon) {
+  testGeometryAggregate(
+      {"POINT (0.5 0.5)", "POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))"},
+      "geometry_union_agg",
+      "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionLineInsidePolygon) {
+  testGeometryAggregate(
+      {"LINESTRING (0.2 0.5, 0.8 0.5)", "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))"},
+      "geometry_union_agg",
+      "POLYGON ((0 1, 1 1, 1 0, 0 0, 0 1))"
+
+  );
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionNegativeCoordinates) {
+  testGeometryAggregate(
+      {"POINT (-1 -1)", "POINT (1 1)"},
+      "geometry_union_agg",
+      "MULTIPOINT (-1 -1, 1 1)");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionDecimalCoordinates) {
+  testGeometryAggregate(
+      {"POINT (0.5 0.5)", "POINT (1.5 1.5)"},
+      "geometry_union_agg",
+      "MULTIPOINT (0.5 0.5, 1.5 1.5)");
+}
+
+} // namespace
+} // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/KHyperLogLogAggregateTest.cpp b/velox/functions/prestosql/aggregates/tests/KHyperLogLogAggregateTest.cpp
new file mode 100644
index 00000000000..8dacacc59eb
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/tests/KHyperLogLogAggregateTest.cpp
@@ -0,0 +1,345 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <map>
+
+#include "velox/functions/lib/KHyperLogLog.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+#include "velox/functions/prestosql/types/KHyperLogLogRegistration.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::functions::aggregate::test;
+using namespace facebook::velox::memory;
+
+namespace facebook::velox::aggregate::test {
+namespace {
+class KHyperLogLogAggregateTest : public AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+    registerKHyperLogLogType();
+    // Disable tests which do raw binary comparison.
+    disableTestStreaming();
+    disableTestIncremental();
+    pool_ = facebook::velox::memory::memoryManager()->addLeafPool();
+    hsa_ = std::make_unique<HashStringAllocator>(pool_.get());
+    allocator_ = hsa_.get();
+  }
+  void TearDown() override {
+    // Clean up allocator before pool.
+    hsa_.reset();
+    pool_.reset();
+    AggregationTestBase::TearDown();
+  }
+
+  // Helper to create KHLL with test data
+  std::string createKHLL(
+      const std::vector<int64_t>& values,
+      const std::vector<int64_t>& uiis) {
+    EXPECT_EQ(values.size(), uiis.size());
+    auto khll = std::make_unique<
+        common::hll::KHyperLogLog<int64_t, HashStringAllocator>>(allocator_);
+
+    for (size_t i = 0; i < values.size(); ++i) {
+      khll->add(values[i], uiis[i]);
+    }
+
+    std::string serialized(khll->estimatedSerializedSize(), '\0');
+    khll->serialize(serialized.data());
+    return serialized;
+  }
+
+  // Extract cardinality from KHLL varbinary.
+  int64_t getCardinality(const StringView& khllData) {
+    auto khll = common::hll::KHyperLogLog<int32_t, MemoryPool>::deserialize(
+        khllData.data(), khllData.size(), pool_.get());
+    VELOX_CHECK(!khll.hasError());
+    return khll.value()->cardinality();
+  }
+
+  // Helper to verify aggregation results have expected cardinalities.
+  // Uses testAggregations with a custom assert function to test all
+  // aggregation plan paths.
+  void testAggregationWithCardinality(
+      const std::vector<RowVectorPtr>& data,
+      const std::vector<std::string>& groupingKeys,
+      const std::vector<std::string>& aggregates,
+      const std::map<int32_t, int64_t>& keysToExpectedCardinalities) {
+    testAggregations(
+        [&](PlanBuilder& builder) { builder.values(data); },
+        groupingKeys,
+        aggregates,
+        {},
+        [&](AssertQueryBuilder& builder) {
+          std::shared_ptr<exec::Task> task;
+          auto result = builder.copyResults(pool_.get(), task);
+          EXPECT_EQ(result->size(), keysToExpectedCardinalities.size());
+
+          if (groupingKeys.empty()) {
+            // Global aggregation - single row result
+            EXPECT_EQ(keysToExpectedCardinalities.size(), 1);
+            auto expectedCardinality =
+                keysToExpectedCardinalities.begin()->second;
+
+            auto khllVector = result->childAt(0)->as<FlatVector<StringView>>();
+            EXPECT_EQ(
+                getCardinality(khllVector->valueAt(0)), expectedCardinality);
+          } else {
+            // Group-by aggregation - map keys to cardinalities
+            auto khllVector = result->childAt(groupingKeys.size())
+                                  ->as<FlatVector<StringView>>();
+            auto keyVector = result->childAt(0)->as<FlatVector<int32_t>>();
+
+            // Build map of key -> actual cardinality
+            std::map<int32_t, int64_t> actualCardinalities;
+            for (size_t i = 0; i < result->size(); ++i) {
+              int32_t key = keyVector->valueAt(i);
+              if (!khllVector->isNullAt(i)) {
+                actualCardinalities[key] =
+                    getCardinality(khllVector->valueAt(i));
+              }
+            }
+
+            // Verify each key has expected cardinality
+            for (const auto& [key, expectedCardinality] :
+                 keysToExpectedCardinalities) {
+              auto it = actualCardinalities.find(key);
+              EXPECT_TRUE(it != actualCardinalities.end())
+                  << "Missing result for key " << key;
+              EXPECT_EQ(it->second, expectedCardinality)
+                  << "Cardinality mismatch for key " << key;
+            }
+          }
+          return task;
+        });
+  }
+
+ protected:
+  std::shared_ptr<MemoryPool> pool_;
+  std::unique_ptr<HashStringAllocator> hsa_;
+  HashStringAllocator* allocator_{};
+};
+
+TEST_F(KHyperLogLogAggregateTest, globalAggIntegers) {
+  vector_size_t size = 1'000;
+  auto values =
+      makeFlatVector<int64_t>(size, [](auto row) { return row % 17; });
+  auto uii = makeFlatVector<int64_t>(size, [](auto /*row*/) { return 1; });
+
+  testAggregationWithCardinality(
+      {makeRowVector({values, uii})},
+      {},
+      {"khyperloglog_agg(c0, c1)"},
+      {{0, 17}});
+
+  // Test high cardinality
+  values = makeFlatVector<int64_t>(size, [](auto row) { return row; });
+  uii = makeFlatVector<int64_t>(size, [](auto /*row*/) { return 1; });
+
+  testAggregationWithCardinality(
+      {makeRowVector({values, uii})},
+      {},
+      {"khyperloglog_agg(c0, c1)"},
+      {{0, 1000}});
+}
+
+TEST_F(KHyperLogLogAggregateTest, globalAggIntegersWithNulls) {
+  testAggregationWithCardinality(
+      {makeRowVector({
+          makeNullableFlatVector<int64_t>({1, 2, std::nullopt, 4, 5}),
+          makeNullableFlatVector<int64_t>({10, 10, 20, std::nullopt, 30}),
+      })},
+      {},
+      {"khyperloglog_agg(c0, c1)"},
+      {{0, 3}});
+
+  // All nulls
+  auto expected = makeRowVector({makeNullConstant(TypeKind::VARBINARY, 1)});
+  testAggregations(
+      {makeRowVector({
+          makeNullableFlatVector<int64_t>(
+              {std::nullopt, std::nullopt, std::nullopt}),
+          makeNullableFlatVector<int64_t>(
+              {std::nullopt, std::nullopt, std::nullopt}),
+      })},
+      {},
+      {"khyperloglog_agg(c0, c1)"},
+      {expected});
+}
+
+TEST_F(KHyperLogLogAggregateTest, globalAggStrings) {
+  vector_size_t size = 1'000;
+  static const std::vector<std::string> kFruits = {
+      "apple",
+      "banana",
+      "cherry",
+      "unknown fruit with a long name",
+      "watermelon"};
+
+  auto values = makeFlatVector<StringView>(size, [&](auto row) {
+    return StringView(kFruits[row % kFruits.size()]);
+  });
+  auto uii = makeFlatVector<int64_t>(size, [](auto /*row*/) { return 1; });
+
+  testAggregationWithCardinality(
+      {makeRowVector({values, uii})},
+      {},
+      {"khyperloglog_agg(c0, c1)"},
+      {{0, static_cast<int64_t>(kFruits.size())}});
+}
+
+TEST_F(KHyperLogLogAggregateTest, globalAggVarbinary) {
+  vector_size_t size = 1'000;
+  static const std::vector<std::string> kFruits = {
+      "apple", "banana", "unknown fruit with a long name", "watermelon"};
+
+  auto values = makeFlatVector<std::string>(
+      size,
+      [&](auto row) { return kFruits[row % kFruits.size()]; },
+      nullptr,
+      VARBINARY());
+  auto uii = makeFlatVector<int64_t>(size, [](auto /*row*/) { return 1; });
+
+  testAggregationWithCardinality(
+      {makeRowVector({values, uii})},
+      {},
+      {"khyperloglog_agg(c0, c1)"},
+      {{0, static_cast<int64_t>(kFruits.size())}});
+}
+
+TEST_F(KHyperLogLogAggregateTest, globalAggTimeStamp) {
+  auto data = makeFlatVector<Timestamp>(
+      1'000, [](auto row) { return Timestamp::fromMillis(row); });
+  auto uii = makeFlatVector<int64_t>(1'000, [](auto /*row*/) { return 1; });
+
+  testAggregationWithCardinality(
+      {makeRowVector({data, uii})},
+      {},
+      {"khyperloglog_agg(c0, c1)"},
+      {{0, 1000}});
+}
+
+TEST_F(KHyperLogLogAggregateTest, globalAggBoolean) {
+  vector_size_t size = 2'000;
+  auto uii = makeFlatVector<int64_t>(size, [](auto /*row*/) { return 1; });
+
+  auto values =
+      makeFlatVector<bool>(size, [](auto row) { return row % 2 == 0; });
+  testAggregationWithCardinality(
+      {makeRowVector({values, uii})},
+      {},
+      {"khyperloglog_agg(c0, c1)"},
+      {{0, 2}});
+}
+
+TEST_F(KHyperLogLogAggregateTest, groupByIntegers) {
+  vector_size_t size = 1'000;
+  auto keys = makeFlatVector<int32_t>(size, [](auto row) { return row % 2; });
+  auto values = makeFlatVector<int64_t>(
+      size, [](auto row) { return row % 2 == 0 ? row % 17 : row % 23; });
+  auto uii = makeFlatVector<int64_t>(size, [](auto /*row*/) { return 1; });
+
+  testAggregationWithCardinality(
+      {makeRowVector({keys, values, uii})},
+      {"c0"},
+      {"khyperloglog_agg(c1, c2)"},
+      {{0, 17}, {1, 23}});
+}
+
+TEST_F(KHyperLogLogAggregateTest, groupByHighCardinalityIntegers) {
+  vector_size_t size = 1'000;
+  auto keys = makeFlatVector<int32_t>(size, [](auto row) { return row % 2; });
+  auto values = makeFlatVector<int64_t>(size, [](auto row) { return row; });
+  auto uii = makeFlatVector<int64_t>(size, [](auto /*row*/) { return 1; });
+
+  testAggregationWithCardinality(
+      {makeRowVector({keys, values, uii})},
+      {"c0"},
+      {"khyperloglog_agg(c1, c2)"},
+      {{0, 500}, {1, 500}});
+}
+
+TEST_F(KHyperLogLogAggregateTest, groupByAllNulls) {
+  vector_size_t size = 1'000;
+  auto keys = makeFlatVector<int32_t>(size, [](auto row) { return row % 2; });
+  auto values = makeFlatVector<int32_t>(
+      size, [](auto row) { return row % 2 == 0 ? 27 : row % 3; }, nullEvery(2));
+  auto uii = makeFlatVector<int64_t>(size, [](auto /*row*/) { return 1; });
+
+  auto vectors = makeRowVector({keys, values, uii});
+
+  // When a group has all nulls, khyperloglog_agg returns NULL, not KHLL with
+  // cardinality 0
+  auto result = AssertQueryBuilder(
+                    PlanBuilder()
+                        .values({vectors})
+                        .singleAggregation({"c0"}, {"khyperloglog_agg(c1, c2)"})
+                        .planNode())
+                    .copyResults(pool_.get());
+
+  ASSERT_EQ(result->size(), 2);
+  auto khllVector = result->childAt(1)->as<FlatVector<StringView>>();
+
+  // At group 0, all values are null, so result is NULL.
+  ASSERT_TRUE(khllVector->isNullAt(0));
+
+  // Group 1 should have (0, 1, 2)
+  ASSERT_FALSE(khllVector->isNullAt(1));
+  EXPECT_EQ(getCardinality(khllVector->valueAt(1)), 3);
+}
+
+TEST_F(KHyperLogLogAggregateTest, mergeKHyperLogLog) {
+  // Create two separate KHLL sketches
+  auto khll1 = createKHLL({1, 2, 3, 4, 5}, {1, 1, 1, 1, 1});
+  auto khll2 = createKHLL({6, 7, 8, 9, 10}, {1, 1, 1, 1, 1});
+
+  auto khllData = makeFlatVector<StringView>(
+      {StringView(khll1), StringView(khll2)}, KHYPERLOGLOG());
+
+  // Merge the two sketches - should have cardinality 10
+  testAggregationWithCardinality(
+      {makeRowVector({khllData})}, {}, {"merge(c0)"}, {{0, 10}});
+}
+
+TEST_F(KHyperLogLogAggregateTest, mergeToIntermediate) {
+  constexpr int kSize = 1000;
+  auto input = makeRowVector({
+      makeFlatVector<int32_t>(kSize, folly::identity),
+      makeFlatVector<int64_t>(kSize, [](auto /*row*/) { return 1; }),
+      makeFlatVector<int64_t>(kSize, [](auto /*row*/) { return 1; }),
+  });
+
+  // Create KHLL sketches per group
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .singleAggregation({"c0"}, {"khyperloglog_agg(c1, c2)"})
+                  .planNode();
+
+  auto digests = split(AssertQueryBuilder(plan).copyResults(pool()), 2);
+
+  // Merge the split digests - each group should still have cardinality 1
+  std::map<int32_t, int64_t> expectedCardinalities;
+  for (int32_t i = 0; i < kSize; ++i) {
+    expectedCardinalities[i] = 1;
+  }
+  testAggregationWithCardinality(
+      digests, {"c0"}, {"merge(a0)"}, expectedCardinalities);
+}
+
+} // namespace
+} // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/MapUnionSumTest.cpp b/velox/functions/prestosql/aggregates/tests/MapUnionSumTest.cpp
index 0f90e9ac696..ddeb2e6f8a2 100644
--- a/velox/functions/prestosql/aggregates/tests/MapUnionSumTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/MapUnionSumTest.cpp
@@ -17,6 +17,7 @@
 #include "velox/common/testutil/OptionalEmpty.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+#include "velox/functions/prestosql/types/IPAddressType.h"
 
 using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
@@ -145,7 +146,8 @@ TEST_F(MapUnionSumTest, tinyintOverflow) {
                   .planNode();
 
   VELOX_ASSERT_THROW(
-      AssertQueryBuilder(plan).copyResults(pool()), "Value 140 exceeds 127");
+      AssertQueryBuilder(plan).copyResults(pool()),
+      "Arithmetic overflow in MAP_UNION_SUM: Value 140 exceeds 127");
 
   data = makeRowVector({
       makeNullableMapVector<int64_t, int8_t>({
@@ -162,7 +164,7 @@ TEST_F(MapUnionSumTest, tinyintOverflow) {
 
   VELOX_ASSERT_THROW(
       AssertQueryBuilder(plan).copyResults(pool()),
-      "Value -140 is less than -128");
+      "Arithmetic overflow in MAP_UNION_SUM: Value -140 is less than -128");
 }
 
 TEST_F(MapUnionSumTest, smallintOverflow) {
@@ -183,7 +185,7 @@ TEST_F(MapUnionSumTest, smallintOverflow) {
 
   VELOX_ASSERT_THROW(
       AssertQueryBuilder(plan).copyResults(pool()),
-      "Value 32787 exceeds 32767");
+      "Arithmetic overflow in MAP_UNION_SUM: Value 32787 exceeds 32767");
 
   data = makeRowVector({
       makeNullableMapVector<int64_t, int16_t>({
@@ -200,7 +202,7 @@ TEST_F(MapUnionSumTest, smallintOverflow) {
 
   VELOX_ASSERT_THROW(
       AssertQueryBuilder(plan).copyResults(pool()),
-      "Value -32788 is less than -32768");
+      "Arithmetic overflow in MAP_UNION_SUM: Value -32788 is less than -32768");
 }
 
 TEST_F(MapUnionSumTest, integerOverflow) {
@@ -221,7 +223,7 @@ TEST_F(MapUnionSumTest, integerOverflow) {
 
   VELOX_ASSERT_THROW(
       AssertQueryBuilder(plan).copyResults(pool()),
-      "Value 2147483667 exceeds 2147483647");
+      "Arithmetic overflow in MAP_UNION_SUM: Value 2147483667 exceeds 2147483647");
 
   data = makeRowVector({
       makeNullableMapVector<int64_t, int32_t>({
@@ -238,7 +240,7 @@ TEST_F(MapUnionSumTest, integerOverflow) {
 
   VELOX_ASSERT_THROW(
       AssertQueryBuilder(plan).copyResults(pool()),
-      "Value -2147483668 is less than -2147483648");
+      "Arithmetic overflow in MAP_UNION_SUM: Value -2147483668 is less than -2147483648");
 }
 
 TEST_F(MapUnionSumTest, bigintOverflow) {
@@ -259,7 +261,7 @@ TEST_F(MapUnionSumTest, bigintOverflow) {
 
   VELOX_ASSERT_THROW(
       AssertQueryBuilder(plan).copyResults(pool()),
-      "Value 9223372036854775827 exceeds 9223372036854775807");
+      "Arithmetic overflow in MAP_UNION_SUM: Value 9223372036854775827 exceeds 9223372036854775807");
 
   data = makeRowVector({
       makeNullableMapVector<int64_t, int64_t>({
@@ -276,7 +278,7 @@ TEST_F(MapUnionSumTest, bigintOverflow) {
 
   VELOX_ASSERT_THROW(
       AssertQueryBuilder(plan).copyResults(pool()),
-      "Value -9223372036854775828 is less than -9223372036854775808");
+      "Arithmetic overflow in MAP_UNION_SUM: Value -9223372036854775828 is less than -9223372036854775808");
 }
 
 TEST_F(MapUnionSumTest, floatNan) {
@@ -571,5 +573,51 @@ TEST_F(MapUnionSumTest, decimalKey) {
       {makeRowVector({data})}, {}, {"map_union_sum(c0)"}, {expected});
 }
 
+TEST_F(MapUnionSumTest, ipAddressKey) {
+  // Helper to convert IP string to int128_t.
+  auto ipToInt128 = [](std::string_view ipAddr) -> int128_t {
+    return ipaddress::tryGetIPv6asInt128FromString(ipAddr).value();
+  };
+
+  // Test on nulls.
+  auto nullData =
+      makeRowVector({makeAllNullMapVector(3, IPADDRESS(), BIGINT())});
+  testAggregations({nullData}, {}, {"map_union_sum(c0)"}, {"VALUES (NULL)"});
+
+  auto ip1 = ipToInt128("192.168.1.1");
+  auto ip2 = ipToInt128("10.0.0.1");
+  auto ip3 = ipToInt128("172.16.0.1");
+
+  // Test global aggregation with IPADDRESS keys.
+  auto data = makeMapVector<int128_t, int64_t>(
+      {{{ip1, 10}, {ip2, 20}}, {{ip1, 5}, {ip3, 15}}},
+      MAP(IPADDRESS(), BIGINT()));
+  auto expected = makeRowVector({makeMapVector<int128_t, int64_t>(
+      {{{ip1, 15}, {ip2, 20}, {ip3, 15}}}, MAP(IPADDRESS(), BIGINT()))});
+  testAggregations(
+      {makeRowVector({data})}, {}, {"map_union_sum(c0)"}, {expected});
+
+  // Test group-by aggregation with IPADDRESS keys.
+  auto groupByData = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 1, 2}),
+      makeMapVector<int128_t, int64_t>(
+          {{{ip1, 10}, {ip2, 20}},
+           {{ip1, 5}, {ip3, 15}},
+           {{ip1, 3}, {ip2, 7}},
+           {{ip3, 25}}},
+          MAP(IPADDRESS(), BIGINT())),
+  });
+
+  auto groupByExpected = makeRowVector({
+      makeFlatVector<int64_t>({1, 2}),
+      makeMapVector<int128_t, int64_t>(
+          {{{ip1, 13}, {ip2, 27}}, {{ip1, 5}, {ip3, 40}}},
+          MAP(IPADDRESS(), BIGINT())),
+  });
+
+  testAggregations(
+      {groupByData}, {"c0"}, {"map_union_sum(c1)"}, {groupByExpected});
+}
+
 } // namespace
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/MergeAggregateTest.cpp b/velox/functions/prestosql/aggregates/tests/MergeAggregateTest.cpp
index 26287d6bc5e..57a01878cdf 100644
--- a/velox/functions/prestosql/aggregates/tests/MergeAggregateTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/MergeAggregateTest.cpp
@@ -20,6 +20,7 @@
 #include "velox/functions/lib/TDigest.h"
 #include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 #include "velox/functions/lib/sfm/SfmSketch.h"
+#include "velox/functions/prestosql/aggregates/TDigestAccumulator.h"
 #include "velox/functions/prestosql/types/QDigestRegistration.h"
 #include "velox/functions/prestosql/types/QDigestType.h"
 #include "velox/functions/prestosql/types/SfmSketchRegistration.h"
@@ -33,6 +34,16 @@ using namespace facebook::velox::functions::aggregate::test;
 using namespace facebook::velox::functions::qdigest;
 using SfmSketchIn = facebook::velox::functions::sfm::SfmSketch;
 
+// Verify that TDigestAccumulator has a single, consistent definition. A
+// duplicate struct in the same namespace with a different layout would cause an
+// ODR violation, leading to memory corruption and SIGSEGV during aggregate
+// cleanup (see D101577660).
+static_assert(
+    sizeof(facebook::velox::aggregate::prestosql::TDigestAccumulator) ==
+    sizeof(double) +
+        sizeof(facebook::velox::functions::TDigest<
+               facebook::velox::StlAllocator<double>>));
+
 namespace facebook::velox::aggregate::test {
 namespace {
 
@@ -255,8 +266,9 @@ TEST_F(MergeAggregateTest, mergeQDigestDoubleMatchJava) {
   const std::string expectedMergedQDigest =
       "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";
 
-  ASSERT_TRUE(qdigestEquals<double>(
-      result.value<TypeKind::VARCHAR>(), expectedMergedQDigest));
+  ASSERT_TRUE(
+      qdigestEquals<double>(
+          result.value<TypeKind::VARCHAR>(), expectedMergedQDigest));
 }
 
 TEST_F(MergeAggregateTest, mergeQDigestBigIntMatchJava) {
@@ -281,8 +293,9 @@ TEST_F(MergeAggregateTest, mergeQDigestBigIntMatchJava) {
   const std::string expectedMergedQDigest =
       "AK5H4XoUru8/AAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAZAAAAAAAAAATAAAAAAAAAAAAABBABAAAAAAAAIAAAAAAAAAAEEAMAAAAAAAAgA8AAAAAAAAUQAEAAAAAAACAAAAAAAAAACBAEAAAAAAAAIANAAAAAAAAHEAQAAAAAAAAgBMAAAAAAAAAAAEAAAAAAACAAAAAAAAAACBAIAAAAAAAAIANAAAAAAAAFEAgAAAAAAAAgAAAAAAAAAAcQDkAAAAAAACADgAAAAAAABxAMgAAAAAAAIATAAAAAAAAAAAgAAAAAAAAgBcAAAAAAAAAAAEAAAAAAACAAAAAAAAAACBAQAAAAAAAAIAAAAAAAAAAIEBIAAAAAAAAgA8AAAAAAAAAAEAAAAAAAACAEQAAAAAAABxAQAAAAAAAAIAAAAAAAAAAEEBhAAAAAAAAgBcAAAAAAAAiQEAAAAAAAACAGwAAAAAAACJAAQAAAAAAAIA=";
 
-  ASSERT_TRUE(qdigestEquals<int64_t>(
-      result.value<TypeKind::VARCHAR>(), expectedMergedQDigest));
+  ASSERT_TRUE(
+      qdigestEquals<int64_t>(
+          result.value<TypeKind::VARCHAR>(), expectedMergedQDigest));
 }
 
 TEST_F(MergeAggregateTest, mergeQDigestRealMatchJava) {
@@ -308,8 +321,9 @@ TEST_F(MergeAggregateTest, mergeQDigestRealMatchJava) {
   const std::string expectedMergedQDigest =
       "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";
 
-  ASSERT_TRUE(qdigestEquals<float>(
-      result.value<TypeKind::VARCHAR>(), expectedMergedQDigest));
+  ASSERT_TRUE(
+      qdigestEquals<float>(
+          result.value<TypeKind::VARCHAR>(), expectedMergedQDigest));
 }
 
 TEST_F(MergeAggregateTest, mergeQDigestOneNullMatchJava) {
@@ -352,20 +366,20 @@ TEST_F(MergeAggregateTest, mergeSfmSketch) {
   auto vectors = makeRowVector({makeFlatVector<StringView>(
       {StringView(s1Binary), StringView(s2Binary)}, SFMSKETCH())});
 
-  auto result1 =
-      AssertQueryBuilder(PlanBuilder()
-                             .values({vectors})
-                             .singleAggregation({}, {"merge(c0)"}, {})
-                             .planNode())
-          .copyResults(pool());
-
-  auto result2 =
-      AssertQueryBuilder(PlanBuilder()
-                             .values({vectors})
-                             .partialAggregation({}, {"merge(c0)"}, {})
-                             .finalAggregation()
-                             .planNode())
-          .copyResults(pool());
+  auto result1 = AssertQueryBuilder(
+                     PlanBuilder()
+                         .values({vectors})
+                         .singleAggregation({}, {"merge(c0)"}, {})
+                         .planNode())
+                     .copyResults(pool());
+
+  auto result2 = AssertQueryBuilder(
+                     PlanBuilder()
+                         .values({vectors})
+                         .partialAggregation({}, {"merge(c0)"}, {})
+                         .finalAggregation()
+                         .planNode())
+                     .copyResults(pool());
 
   const std::string expectedMerge =
       "BwkAAAAIAAAAAAAAAAAAAAA7AQAAAAABAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAgAAAAgQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg";
diff --git a/velox/functions/prestosql/aggregates/tests/MinMaxByAggregationTest.cpp b/velox/functions/prestosql/aggregates/tests/MinMaxByAggregationTest.cpp
index e37c88acc63..0c052794d4d 100644
--- a/velox/functions/prestosql/aggregates/tests/MinMaxByAggregationTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/MinMaxByAggregationTest.cpp
@@ -37,6 +37,13 @@ struct TestParam {
   TypeKind comparisonType;
 };
 
+inline void PrintTo(const TestParam& param, std::ostream* os) {
+  *os << fmt::format(
+      "{}_{}",
+      TypeKindName::toName(param.valueType),
+      TypeKindName::toName(param.comparisonType));
+}
+
 const std::vector<TypeKind> kSupportedTypes = {
     TypeKind::BOOLEAN,
     TypeKind::TINYINT,
@@ -59,82 +66,82 @@ std::vector<TestParam> getTestParams() {
   return params;
 }
 
-#define EXECUTE_TEST_BY_VALUE_TYPE(testFunc, valueType)              \
-  do {                                                               \
-    switch (GetParam().comparisonType) {                             \
-      case TypeKind::BOOLEAN:                                        \
-        testFunc<valueType, bool>();                                 \
-        break;                                                       \
-      case TypeKind::TINYINT:                                        \
-        testFunc<valueType, int8_t>();                               \
-        break;                                                       \
-      case TypeKind::SMALLINT:                                       \
-        testFunc<valueType, int16_t>();                              \
-        break;                                                       \
-      case TypeKind::INTEGER:                                        \
-        testFunc<valueType, int32_t>();                              \
-        break;                                                       \
-      case TypeKind::BIGINT:                                         \
-        testFunc<valueType, int64_t>();                              \
-        break;                                                       \
-      case TypeKind::HUGEINT:                                        \
-        testFunc<valueType, int128_t>();                             \
-        break;                                                       \
-      case TypeKind::REAL:                                           \
-        testFunc<valueType, float>();                                \
-        break;                                                       \
-      case TypeKind::DOUBLE:                                         \
-        testFunc<valueType, double>();                               \
-        break;                                                       \
-      case TypeKind::VARCHAR:                                        \
-        testFunc<valueType, StringView>();                           \
-        break;                                                       \
-      case TypeKind::TIMESTAMP:                                      \
-        testFunc<valueType, Timestamp>();                            \
-        break;                                                       \
-      default:                                                       \
-        LOG(FATAL) << "Unsupported comparison type of minmax_by(): " \
-                   << mapTypeKindToName(GetParam().comparisonType);  \
-    }                                                                \
+#define EXECUTE_TEST_BY_VALUE_TYPE(testFunc, valueType)                \
+  do {                                                                 \
+    switch (GetParam().comparisonType) {                               \
+      case TypeKind::BOOLEAN:                                          \
+        testFunc<valueType, bool>();                                   \
+        break;                                                         \
+      case TypeKind::TINYINT:                                          \
+        testFunc<valueType, int8_t>();                                 \
+        break;                                                         \
+      case TypeKind::SMALLINT:                                         \
+        testFunc<valueType, int16_t>();                                \
+        break;                                                         \
+      case TypeKind::INTEGER:                                          \
+        testFunc<valueType, int32_t>();                                \
+        break;                                                         \
+      case TypeKind::BIGINT:                                           \
+        testFunc<valueType, int64_t>();                                \
+        break;                                                         \
+      case TypeKind::HUGEINT:                                          \
+        testFunc<valueType, int128_t>();                               \
+        break;                                                         \
+      case TypeKind::REAL:                                             \
+        testFunc<valueType, float>();                                  \
+        break;                                                         \
+      case TypeKind::DOUBLE:                                           \
+        testFunc<valueType, double>();                                 \
+        break;                                                         \
+      case TypeKind::VARCHAR:                                          \
+        testFunc<valueType, StringView>();                             \
+        break;                                                         \
+      case TypeKind::TIMESTAMP:                                        \
+        testFunc<valueType, Timestamp>();                              \
+        break;                                                         \
+      default:                                                         \
+        LOG(FATAL) << "Unsupported comparison type of minmax_by(): "   \
+                   << TypeKindName::toName(GetParam().comparisonType); \
+    }                                                                  \
   } while (0);
 
-#define EXECUTE_TEST(testFunc)                                  \
-  do {                                                          \
-    switch (GetParam().valueType) {                             \
-      case TypeKind::BOOLEAN:                                   \
-        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, bool);             \
-        break;                                                  \
-      case TypeKind::TINYINT:                                   \
-        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, int8_t);           \
-        break;                                                  \
-      case TypeKind::SMALLINT:                                  \
-        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, int16_t);          \
-        break;                                                  \
-      case TypeKind::INTEGER:                                   \
-        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, int32_t);          \
-        break;                                                  \
-      case TypeKind::BIGINT:                                    \
-        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, int64_t);          \
-        break;                                                  \
-      case TypeKind::HUGEINT:                                   \
-        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, int128_t);         \
-        break;                                                  \
-      case TypeKind::REAL:                                      \
-        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, float);            \
-        break;                                                  \
-      case TypeKind::DOUBLE:                                    \
-        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, double);           \
-        break;                                                  \
-      case TypeKind::VARCHAR:                                   \
-        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, StringView);       \
-        break;                                                  \
-      case TypeKind::TIMESTAMP:                                 \
-        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, Timestamp);        \
-        break;                                                  \
-      default:                                                  \
-        LOG(FATAL) << "Unsupported value type of minmax_by(): " \
-                   << mapTypeKindToName(GetParam().valueType);  \
-    }                                                           \
+#define EXECUTE_TEST(testFunc)                                    \
+  do {                                                            \
+    switch (GetParam().valueType) {                               \
+      case TypeKind::BOOLEAN:                                     \
+        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, bool);               \
+        break;                                                    \
+      case TypeKind::TINYINT:                                     \
+        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, int8_t);             \
+        break;                                                    \
+      case TypeKind::SMALLINT:                                    \
+        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, int16_t);            \
+        break;                                                    \
+      case TypeKind::INTEGER:                                     \
+        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, int32_t);            \
+        break;                                                    \
+      case TypeKind::BIGINT:                                      \
+        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, int64_t);            \
+        break;                                                    \
+      case TypeKind::HUGEINT:                                     \
+        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, int128_t);           \
+        break;                                                    \
+      case TypeKind::REAL:                                        \
+        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, float);              \
+        break;                                                    \
+      case TypeKind::DOUBLE:                                      \
+        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, double);             \
+        break;                                                    \
+      case TypeKind::VARCHAR:                                     \
+        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, StringView);         \
+        break;                                                    \
+      case TypeKind::TIMESTAMP:                                   \
+        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, Timestamp);          \
+        break;                                                    \
+      default:                                                    \
+        LOG(FATAL) << "Unsupported value type of minmax_by(): "   \
+                   << TypeKindName::toName(GetParam().valueType); \
+    }                                                             \
   } while (0);
 
 template <typename T>
@@ -194,7 +201,7 @@ class MinMaxByAggregationTestBase : public AggregationTestBase {
     }
     VELOX_FAIL(
         "Type {} is not found in rowType_: ",
-        mapTypeKindToName(kind),
+        TypeKindName::toName(kind),
         rowType_->toString());
   }
 
@@ -305,7 +312,7 @@ VectorPtr MinMaxByAggregationTestBase::buildDataVector(
       return buildDataVector<Timestamp>(size, values);
     default:
       LOG(FATAL) << "Unsupported value/comparison type of minmax_by(): "
-                 << mapTypeKindToName(kind);
+                 << TypeKindName::toName(kind);
   }
 }
 
@@ -369,7 +376,7 @@ void MinMaxByAggregationTestBase::SetUp() {
             type, buildDataVector<StringView>(numValues_));
         break;
       default:
-        LOG(FATAL) << "Unsupported data type: " << mapTypeKindToName(type);
+        LOG(FATAL) << "Unsupported data type: " << TypeKindName::toName(type);
     }
   }
   ASSERT_EQ(dataVectorsByType_.size(), kSupportedTypes.size());
@@ -722,11 +729,12 @@ class MinMaxByGroupByAggregationTest
           aggregate,
           groupByColumnName);
     }
-    SCOPED_TRACE(fmt::format(
-        "{} GROUP BY {}\nverifyDuckDbSql: {}",
-        aggregate,
-        groupByColumnName,
-        verifyDuckDbSql));
+    SCOPED_TRACE(
+        fmt::format(
+            "{} GROUP BY {}\nverifyDuckDbSql: {}",
+            aggregate,
+            groupByColumnName,
+            verifyDuckDbSql));
     testAggregations(
         vectors, {groupByColumnName}, {aggregate}, {}, verifyDuckDbSql);
   }
@@ -2507,32 +2515,33 @@ TEST_F(MinMaxByTest, nans) {
 }
 
 TEST_F(MinMaxByTest, TimestampWithTimezone) {
-  auto data = makeRowVector({// output column for min_by/max_by
-                             makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6, 7, 8}),
-                             // group by column
-                             makeFlatVector<int32_t>({1, 2, 2, 1, 1, 1, 2, 2}),
-                             // regular ordering
-                             makeFlatVector<int64_t>(
-                                 {pack(-1, 2),
-                                  pack(-3, 1),
-                                  pack(0, 4),
-                                  pack(2, 4),
-                                  pack(3, 1),
-                                  pack(-4, 5),
-                                  pack(1, 3),
-                                  pack(4, 0)},
-                                 TIMESTAMP_WITH_TIME_ZONE()),
-                             // with nulls
-                             makeNullableFlatVector<int64_t>(
-                                 {pack(-1, 2),
-                                  std::nullopt,
-                                  pack(0, 4),
-                                  pack(2, 4),
-                                  pack(3, 1),
-                                  std::nullopt,
-                                  pack(1, 3),
-                                  pack(4, 0)},
-                                 TIMESTAMP_WITH_TIME_ZONE())});
+  auto data = makeRowVector(
+      {// output column for min_by/max_by
+       makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6, 7, 8}),
+       // group by column
+       makeFlatVector<int32_t>({1, 2, 2, 1, 1, 1, 2, 2}),
+       // regular ordering
+       makeFlatVector<int64_t>(
+           {pack(-1, 2),
+            pack(-3, 1),
+            pack(0, 4),
+            pack(2, 4),
+            pack(3, 1),
+            pack(-4, 5),
+            pack(1, 3),
+            pack(4, 0)},
+           TIMESTAMP_WITH_TIME_ZONE()),
+       // with nulls
+       makeNullableFlatVector<int64_t>(
+           {pack(-1, 2),
+            std::nullopt,
+            pack(0, 4),
+            pack(2, 4),
+            pack(3, 1),
+            std::nullopt,
+            pack(1, 3),
+            pack(4, 0)},
+           TIMESTAMP_WITH_TIME_ZONE())});
 
   // Global aggregation.
   {
diff --git a/velox/functions/prestosql/aggregates/tests/NumericHistogramTest.cpp b/velox/functions/prestosql/aggregates/tests/NumericHistogramTest.cpp
index e4c16e04cf6..d7c6d858e43 100644
--- a/velox/functions/prestosql/aggregates/tests/NumericHistogramTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/NumericHistogramTest.cpp
@@ -629,5 +629,93 @@ TEST_F(NumericHistogramTest, threeArgsFloatFloat) {
   runThreeArgsTests<float, float>();
 }
 
+// Verify all-null input produces null output without crashing.
+// Exercises the mergeSameBuckets fix for nextIndex_ == 0.
+TEST_F(NumericHistogramTest, allNullInputTwoArgs) {
+  disableTestIncremental();
+  auto valuesAndWeights = makeRowVector({
+      makeNullableFlatVector<double>(
+          {std::nullopt, std::nullopt, std::nullopt}),
+  });
+
+  auto expected = makeRowVector({
+      makeNullableMapVector<double, double>({std::nullopt}),
+  });
+  testAggregations(
+      {valuesAndWeights}, {}, {"numeric_histogram(3, c0)"}, {expected});
+}
+
+// Verify all-null input produces null output for 3-arg variant.
+TEST_F(NumericHistogramTest, allNullInputThreeArgs) {
+  disableTestIncremental();
+  auto valuesAndWeights = makeRowVector({
+      makeNullableFlatVector<double>(
+          {std::nullopt, std::nullopt, std::nullopt}),
+      makeNullableFlatVector<double>({1, 2, 3}),
+  });
+
+  auto expected = makeRowVector({
+      makeNullableMapVector<double, double>({std::nullopt}),
+  });
+  testAggregations(
+      {valuesAndWeights}, {}, {"numeric_histogram(3, c0, c1)"}, {expected});
+}
+
+// Verify grouped aggregation where one group has all-null values.
+// Exercises the empty histogram code path in compact().
+TEST_F(NumericHistogramTest, groupedWithEmptyGroup) {
+  disableTestIncremental();
+  auto data = makeRowVector({
+      // group keys: group 0 gets all nulls, group 1 gets real values
+      makeNullableFlatVector<int32_t>({0, 0, 1, 1, 1}),
+      makeNullableFlatVector<double>(
+          {std::nullopt, std::nullopt, 10.0, 20.0, 30.0}),
+  });
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<int32_t>({0, 1}),
+      makeNullableMapVector<double, double>(
+          {std::nullopt, {{{10.0, 1}, {20.0, 1}, {30.0, 1}}}}),
+  });
+  testAggregations({data}, {"c0"}, {"numeric_histogram(3, c1)"}, {expected});
+}
+
+// Stress-test with a large number of entries that forces multiple compact
+// cycles. Validates unique_ptr cleanup in mergeAndReduceBuckets.
+TEST_F(NumericHistogramTest, largeInputStressTest) {
+  disableTestIncremental();
+  // Create 200 identical values. This forces multiple compact+reduce cycles
+  // with only 2 buckets, then mergeSameBuckets collapses them all.
+  std::vector<std::optional<double>> values(200, 42.0);
+
+  auto valuesAndWeights = makeRowVector({
+      makeNullableFlatVector<double>(values),
+  });
+
+  auto expected = makeRowVector({
+      makeMapVector<double, double>({
+          {{42.0, 200}},
+      }),
+  });
+  testAggregations(
+      {valuesAndWeights}, {}, {"numeric_histogram(2, c0)"}, {expected});
+}
+
+// Verify duplicate values are merged correctly by mergeSameBuckets.
+TEST_F(NumericHistogramTest, allDuplicateValues) {
+  disableTestIncremental();
+  auto valuesAndWeights = makeRowVector({
+      makeNullableFlatVector<double>({5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0}),
+  });
+
+  auto expected = makeRowVector({
+      makeMapVector<double, double>({
+          {{5.0, 8}},
+      }),
+  });
+  testAggregations(
+      {valuesAndWeights}, {}, {"numeric_histogram(3, c0)"}, {expected});
+}
+
 } // namespace
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/PrestoHasherTest.cpp b/velox/functions/prestosql/aggregates/tests/PrestoHasherTest.cpp
index 2f38263e52d..4f6d4ab1eac 100644
--- a/velox/functions/prestosql/aggregates/tests/PrestoHasherTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/PrestoHasherTest.cpp
@@ -433,7 +433,7 @@ TEST_F(PrestoHasherTest, timestampWithTimezone) {
 }
 
 TEST_F(PrestoHasherTest, ipAddress) {
-  auto makeIpAdressFromString = [](const std::string& ipAddr) -> int128_t {
+  auto makeIpAdressFromString = [](std::string_view ipAddr) -> int128_t {
     auto ret = ipaddress::tryGetIPv6asInt128FromString(ipAddr);
     return ret.value();
   };
diff --git a/velox/functions/prestosql/aggregates/tests/ReduceAggTest.cpp b/velox/functions/prestosql/aggregates/tests/ReduceAggTest.cpp
index f34d99980c5..153d95e5295 100644
--- a/velox/functions/prestosql/aggregates/tests/ReduceAggTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/ReduceAggTest.cpp
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
@@ -251,6 +252,52 @@ TEST_F(ReduceAggTest, arraysGroupBy) {
       {expected});
 }
 
+TEST_F(ReduceAggTest, nonConstantInitialValueGroupBy) {
+  auto data = makeRowVector(
+      {"k", "c0", "c1"},
+      {
+          makeFlatVector<int32_t>({1, 1, 2}),
+          makeFlatVector<int64_t>({2, 3, 20}),
+          makeArrayVector<int64_t>({{1, 2}, {1, 3}, {2, 20}}),
+      });
+
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .singleAggregation(
+                      {"k"},
+                      {"reduce_agg(c0, c1, "
+                       "(s, x) -> concat(s, array[x]), "
+                       "(s, s2) -> concat(s, s2))"})
+                  .planNode();
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan).copyResults(pool()),
+      "Initial value in reduce_agg must be constant");
+}
+
+TEST_F(ReduceAggTest, allNullInputSkipsInitialValueCheck) {
+  auto data = makeRowVector(
+      {"k", "c0", "c1"},
+      {
+          makeFlatVector<int32_t>({1, 1, 2, 2}),
+          makeConstant<int64_t>(std::nullopt, 4),
+          makeArrayVector<int64_t>({{1, 2}, {1, 2}, {2, 20}, {2, 20}}),
+      });
+
+  auto expected = makeRowVector({
+      makeFlatVector<int32_t>({1, 2}),
+      makeNullableArrayVector<int64_t>({std::nullopt, std::nullopt}),
+  });
+
+  testAggregations(
+      {data},
+      {"k"},
+      {"reduce_agg(c0, c1, "
+       "(s, x) -> concat(s, array[x]), "
+       "(s, s2) -> concat(s, s2))"},
+      {expected});
+}
+
 TEST_F(ReduceAggTest, differentInputAndCombine) {
   auto data = makeRowVector(
       {"k", "c0", "c1", "m"},
diff --git a/velox/functions/prestosql/aggregates/tests/ReservoirSampleTest.cpp b/velox/functions/prestosql/aggregates/tests/ReservoirSampleTest.cpp
new file mode 100644
index 00000000000..002dca17ba7
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/tests/ReservoirSampleTest.cpp
@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::functions::aggregate::test;
+
+namespace facebook::velox::aggregate::prestosql {
+
+namespace {
+
+class ReservoirSampleTest : public AggregationTestBase {
+ protected:
+  RowVectorPtr makeResultDouble(
+      int64_t seenCount,
+      const std::vector<std::optional<double>>& sample) {
+    std::vector<std::optional<std::vector<std::optional<double>>>> data = {
+        sample};
+    return makeRowVector({makeRowVector({
+        makeFlatVector<int64_t>({seenCount}),
+        makeNullableArrayVector<double>(data),
+    })});
+  }
+
+  VectorPtr makeNullArray(int count, const TypePtr& elementType) {
+    auto arrayType = ARRAY(elementType);
+    auto builder = BaseVector::create(arrayType, count, pool());
+    for (int i = 0; i < count; i++) {
+      builder->setNull(i, true);
+    }
+    return builder;
+  }
+
+  template <typename T>
+  VectorPtr makeFlatConstantVector(T value, int count) {
+    return makeFlatVector<T>(std::vector<T>(count, value));
+  }
+};
+
+TEST_F(ReservoirSampleTest, testNoInitialSample) {
+  auto data = makeRowVector({
+      makeNullArray(5, DOUBLE()),
+      makeFlatConstantVector<int64_t>(0, 5),
+      makeFlatVector<double>({1.0, 1.0, 1.0, 1.0, 1.0}),
+      makeFlatConstantVector<int32_t>(2, 5),
+  });
+
+  auto expected = makeResultDouble(5L, {1.0, 1.0});
+
+  testAggregations(
+      {data}, {}, {"reservoir_sample(c0, c1, c2, c3)"}, {expected});
+}
+
+TEST_F(ReservoirSampleTest, testLarge) {
+  const int sampleSize = 5000;
+  const int inputSize = 15000;
+
+  std::vector<double> inputValues(inputSize, 1.0);
+  std::vector<std::optional<double>> expectedSample(sampleSize, 1.0);
+
+  auto data = makeRowVector({
+      makeNullArray(inputSize, DOUBLE()),
+      makeFlatConstantVector<int64_t>(0, inputSize),
+      makeFlatVector<double>(inputValues),
+      makeFlatConstantVector<int32_t>(sampleSize, inputSize),
+  });
+
+  auto expected =
+      makeResultDouble(static_cast<int64_t>(inputSize), expectedSample);
+
+  testAggregations(
+      {data}, {}, {"reservoir_sample(c0, c1, c2, c3)"}, {expected});
+}
+
+TEST_F(ReservoirSampleTest, testInvalidSampleSizeZero) {
+  auto data = makeRowVector({
+      makeNullArray(5, DOUBLE()),
+      makeFlatConstantVector<int64_t>(0, 5),
+      makeFlatVector<double>({1.0, 1.0, 1.0, 1.0, 1.0}),
+      makeFlatConstantVector<int32_t>(0, 5),
+  });
+
+  EXPECT_THROW(
+      testAggregations(
+          {data}, {}, {"reservoir_sample(c0, c1, c2, c3)"}, "Throws exception"),
+      VeloxException);
+}
+
+TEST_F(ReservoirSampleTest, testInvalidSampleSizeNegative) {
+  auto data = makeRowVector({
+      makeNullArray(5, DOUBLE()),
+      makeFlatConstantVector<int64_t>(0, 5),
+      makeFlatVector<double>({1.0, 1.0, 1.0, 1.0, 1.0}),
+      makeFlatConstantVector<int32_t>(-1, 5),
+  });
+
+  EXPECT_THROW(
+      testAggregations(
+          {data}, {}, {"reservoir_sample(c0, c1, c2, c3)"}, "Throws exception"),
+      VeloxException);
+}
+
+TEST_F(ReservoirSampleTest, testInitialSampleSameSize) {
+  auto data = makeRowVector({
+      makeArrayVector<double>(
+          {std::vector<double>{1.0, 1.0},
+           std::vector<double>{1.0, 1.0},
+           std::vector<double>{1.0, 1.0},
+           std::vector<double>{1.0, 1.0},
+           std::vector<double>{1.0, 1.0}}),
+      makeFlatConstantVector<int64_t>(10, 5),
+      makeFlatVector<double>({1.0, 1.0, 1.0, 1.0, 1.0}),
+      makeFlatConstantVector<int32_t>(2, 5),
+  });
+
+  auto expected = makeResultDouble(15L, {1.0, 1.0});
+
+  testAggregations(
+      {data}, {}, {"reservoir_sample(c0, c1, c2, c3)"}, {expected});
+}
+
+TEST_F(ReservoirSampleTest, testInitialSampleWrongSize) {
+  auto data = makeRowVector({
+      makeArrayVector<double>(
+          {std::vector<double>{1.0, 1.0, 2.0},
+           std::vector<double>{1.0, 1.0, 2.0},
+           std::vector<double>{1.0, 1.0, 2.0},
+           std::vector<double>{1.0, 1.0, 2.0},
+           std::vector<double>{1.0, 1.0, 2.0}}),
+      makeFlatConstantVector<int64_t>(10, 5),
+      makeFlatVector<double>({1.0, 1.0, 1.0, 1.0, 1.0}),
+      makeFlatConstantVector<int32_t>(2, 5),
+  });
+
+  EXPECT_THROW(
+      testAggregations(
+          {data}, {}, {"reservoir_sample(c0, c1, c2, c3)"}, "Throws exception"),
+      VeloxException);
+}
+
+TEST_F(ReservoirSampleTest, testInitialSampleSmallerThanMaxSize) {
+  auto data = makeRowVector({
+      makeArrayVector<double>(
+          {std::vector<double>{1.0},
+           std::vector<double>{1.0},
+           std::vector<double>{1.0},
+           std::vector<double>{1.0},
+           std::vector<double>{1.0}}),
+      makeFlatConstantVector<int64_t>(1, 5),
+      makeFlatVector<double>({1.0, 1.0, 1.0, 1.0, 1.0}),
+      makeFlatConstantVector<int32_t>(2, 5),
+  });
+
+  auto expected = makeResultDouble(6L, {1.0, 1.0});
+
+  testAggregations(
+      {data}, {}, {"reservoir_sample(c0, c1, c2, c3)"}, {expected});
+}
+
+TEST_F(
+    ReservoirSampleTest,
+    testInitialSampleSeenCountSmallerThanInitialSample) {
+  auto data = makeRowVector({
+      makeArrayVector<double>(
+          {std::vector<double>{1.0, 1.0},
+           std::vector<double>{1.0, 1.0},
+           std::vector<double>{1.0, 1.0},
+           std::vector<double>{1.0, 1.0},
+           std::vector<double>{1.0, 1.0}}),
+      makeFlatConstantVector<int64_t>(1, 5),
+      makeFlatVector<double>({1.0, 1.0, 1.0, 1.0, 1.0}),
+      makeFlatConstantVector<int32_t>(2, 5),
+  });
+
+  EXPECT_THROW(
+      testAggregations(
+          {data}, {}, {"reservoir_sample(c0, c1, c2, c3)"}, "Throws exception"),
+      VeloxException);
+}
+
+TEST_F(ReservoirSampleTest, testValidResults) {
+  auto data = makeRowVector({
+      makeNullArray(10, DOUBLE()),
+      makeFlatConstantVector<int64_t>(0, 10),
+      makeFlatVector<double>(
+          {0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0}),
+      makeFlatConstantVector<int32_t>(4, 10),
+  });
+
+  auto result =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values({data})
+              .singleAggregation({}, {"reservoir_sample(c0, c1, c2, c3)"})
+              .planNode())
+          .copyResults(pool());
+
+  ASSERT_EQ(result->size(), 1);
+  auto rowResult = result->childAt(0)->as<RowVector>();
+  ASSERT_EQ(rowResult->size(), 1);
+
+  auto processedCount =
+      rowResult->childAt(0)->as<FlatVector<int64_t>>()->valueAt(0);
+  EXPECT_EQ(processedCount, 10L);
+
+  auto sampleArray = rowResult->childAt(1)->as<ArrayVector>();
+  ASSERT_EQ(sampleArray->size(), 1);
+
+  auto sampleSize = sampleArray->sizeAt(0);
+  EXPECT_EQ(sampleSize, 4);
+
+  std::set<double> allValues = {
+      0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
+  auto sampleElements = sampleArray->elements()->as<FlatVector<double>>();
+  auto offset = sampleArray->offsetAt(0);
+
+  for (int i = 0; i < sampleSize; i++) {
+    double value = sampleElements->valueAt(offset + i);
+    EXPECT_TRUE(allValues.count(value) > 0)
+        << "Sample contains value " << value << " which is not in input set";
+  }
+}
+
+} // namespace
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/tests/SetDigestAggregateTest.cpp b/velox/functions/prestosql/aggregates/tests/SetDigestAggregateTest.cpp
new file mode 100644
index 00000000000..d0da19cccd9
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/tests/SetDigestAggregateTest.cpp
@@ -0,0 +1,667 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/lib/SetDigest.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+#include "velox/functions/prestosql/types/SetDigestRegistration.h"
+
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::functions::aggregate::test;
+using namespace facebook::velox::functions;
+
+namespace facebook::velox::aggregate::test {
+
+namespace {
+
+using SetDigestType = functions::SetDigest<int64_t>;
+
+class SetDigestAggregateTest : public AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+    registerSetDigestType();
+  }
+
+  // Helper to deserialize and verify a SetDigest result.
+  void verifySetDigest(
+      const RowVectorPtr& result,
+      int64_t expectedCardinality,
+      bool expectExact = true,
+      int32_t rowIndex = 0) {
+    ASSERT_LT(rowIndex, result->size());
+    auto resultVector = result->childAt(result->type()->size() - 1)
+                            ->as<FlatVector<StringView>>();
+    ASSERT_FALSE(resultVector->isNullAt(rowIndex));
+
+    auto serialized = resultVector->valueAt(rowIndex);
+    auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+    SetDigestType digest(allocator.get());
+    auto status = digest.deserialize(serialized.data(), serialized.size());
+    ASSERT_TRUE(status.ok()) << status.message();
+
+    EXPECT_EQ(digest.cardinality(), expectedCardinality);
+    if (expectExact) {
+      EXPECT_TRUE(digest.isExact());
+    }
+  }
+
+  // Helper to verify result is null.
+  void verifySetDigestNull(const RowVectorPtr& result, int32_t rowIndex = 0) {
+    ASSERT_LT(rowIndex, result->size());
+    auto resultVector = result->childAt(result->type()->size() - 1)
+                            ->as<FlatVector<StringView>>();
+    EXPECT_TRUE(resultVector->isNullAt(rowIndex));
+  }
+
+  // Helper to create a serialized SetDigest from int64_t values.
+  std::string serializeSetDigest(const std::vector<int64_t>& values) {
+    auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+    SetDigestType digest(allocator.get());
+    for (auto value : values) {
+      digest.add(value);
+    }
+    auto size = digest.estimatedSerializedSize();
+    std::string buffer(size, '\0');
+    digest.serialize(buffer.data());
+    return buffer;
+  }
+
+  // Helper to run make_set_digest and get result.
+  RowVectorPtr runMakeSetDigest(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<std::string>& groupingKeys = {}) {
+    auto op = PlanBuilder()
+                  .values(input)
+                  .singleAggregation(groupingKeys, {"make_set_digest(c0)"})
+                  .planNode();
+    return AssertQueryBuilder(op).copyResults(pool());
+  }
+
+  // Helper to run merge_set_digest and get result.
+  RowVectorPtr runMergeSetDigest(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<std::string>& groupingKeys = {}) {
+    auto op = PlanBuilder()
+                  .values(input)
+                  .project({"cast(a0 as setdigest)"})
+                  .singleAggregation(groupingKeys, {"merge_set_digest(p0)"})
+                  .planNode();
+    return AssertQueryBuilder(op).copyResults(pool());
+  }
+};
+
+TEST_F(SetDigestAggregateTest, intValues) {
+  auto vectors = makeRowVector({
+      makeFlatVector<int64_t>({1, 1, 1, 2, 2, 3, 3, 3, 3}),
+  });
+
+  auto result = runMakeSetDigest({vectors});
+  verifySetDigest(result, 3);
+}
+
+TEST_F(SetDigestAggregateTest, withNullValues) {
+  auto vectors = makeRowVector({
+      makeNullableFlatVector<int64_t>(
+          {1, std::nullopt, 2, std::nullopt, 3, std::nullopt, 1}),
+  });
+
+  auto result = runMakeSetDigest({vectors});
+  verifySetDigest(result, 3);
+}
+
+TEST_F(SetDigestAggregateTest, allNullValues) {
+  auto vectors = makeRowVector({
+      makeNullableFlatVector<int64_t>(
+          {std::nullopt, std::nullopt, std::nullopt}),
+  });
+
+  auto result = runMakeSetDigest({vectors});
+  verifySetDigestNull(result);
+}
+
+TEST_F(SetDigestAggregateTest, emptyInput) {
+  auto vectors = makeRowVector({
+      makeFlatVector<int64_t>({}),
+  });
+
+  auto result = runMakeSetDigest({vectors});
+  verifySetDigestNull(result);
+}
+
+TEST_F(SetDigestAggregateTest, stringValues) {
+  auto vectors = makeRowVector({
+      makeFlatVector<std::string>(
+          {"apple",
+           "banana",
+           "apple",
+           "cherry",
+           "banana",
+           "a longer string with more than 12 characters",
+           "another extended string for testing",
+           "a longer string with more than 12 characters"}),
+  });
+
+  auto result = runMakeSetDigest({vectors});
+  verifySetDigest(result, 5);
+}
+
+TEST_F(SetDigestAggregateTest, groupBy) {
+  auto vectors = makeRowVector({
+      makeFlatVector<int32_t>({1, 1, 2, 2, 1, 2}),
+      makeFlatVector<int64_t>({10, 20, 30, 40, 10, 30}),
+  });
+
+  auto op = PlanBuilder()
+                .values({vectors})
+                .singleAggregation({"c0"}, {"make_set_digest(c1)"})
+                .planNode();
+
+  auto result = AssertQueryBuilder(op).copyResults(pool());
+
+  ASSERT_EQ(result->size(), 2);
+
+  auto groupVector = result->childAt(0)->as<FlatVector<int32_t>>();
+  auto digestVector = result->childAt(1)->as<FlatVector<StringView>>();
+
+  auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+
+  for (auto i = 0; i < result->size(); ++i) {
+    auto group = groupVector->valueAt(i);
+    auto serialized = digestVector->valueAt(i);
+
+    SetDigestType digest(allocator.get());
+    auto status = digest.deserialize(serialized.data(), serialized.size());
+    ASSERT_TRUE(status.ok()) << status.message();
+
+    if (group == 1) {
+      EXPECT_EQ(digest.cardinality(), 2);
+      EXPECT_TRUE(digest.isExact());
+    } else if (group == 2) {
+      EXPECT_EQ(digest.cardinality(), 2);
+      EXPECT_TRUE(digest.isExact());
+    }
+  }
+}
+
+TEST_F(SetDigestAggregateTest, differentNumericTypes) {
+  auto testType = [&](const std::string& typeStr, auto makeVector) {
+    auto result = runMakeSetDigest({makeRowVector({makeVector})});
+    verifySetDigest(result, 3);
+  };
+
+  testType("TINYINT", makeFlatVector<int8_t>({1, 2, 3, 1, 2}));
+  testType("SMALLINT", makeFlatVector<int16_t>({1, 2, 3, 1, 2}));
+  testType("INTEGER", makeFlatVector<int32_t>({1, 2, 3, 1, 2}));
+  testType("BIGINT", makeFlatVector<int64_t>({1, 2, 3, 1, 2}));
+}
+
+TEST_F(SetDigestAggregateTest, largeExactSet) {
+  std::vector<int64_t> values;
+  values.reserve(1000);
+  for (int64_t i = 0; i < 1000; ++i) {
+    values.push_back(i);
+  }
+
+  auto result =
+      runMakeSetDigest({makeRowVector({makeFlatVector<int64_t>(values)})});
+  verifySetDigest(result, 1000);
+}
+
+TEST_F(SetDigestAggregateTest, largeApproximateSet) {
+  std::vector<int64_t> values;
+  values.reserve(50000);
+  for (int64_t i = 0; i < 50000; ++i) {
+    values.push_back(i);
+  }
+
+  auto result =
+      runMakeSetDigest({makeRowVector({makeFlatVector<int64_t>(values)})});
+
+  auto serialized =
+      result->childAt(0)->as<FlatVector<StringView>>()->valueAt(0);
+  auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+  SetDigestType digest(allocator.get());
+  ASSERT_TRUE(digest.deserialize(serialized.data(), serialized.size()).ok());
+
+  EXPECT_FALSE(digest.isExact());
+
+  auto estimatedCardinality = digest.cardinality();
+  double errorRate = std::abs(estimatedCardinality - 50000) / 50000.0;
+
+  EXPECT_LT(errorRate, 0.05)
+      << "HLL estimate should be within 5% of actual. "
+      << "Actual: 50000, Estimated: " << estimatedCardinality;
+}
+
+TEST_F(SetDigestAggregateTest, partialAggregation) {
+  auto vectors = {
+      makeRowVector({makeFlatVector<int64_t>({1, 2, 3})}),
+      makeRowVector({makeFlatVector<int64_t>({3, 4, 5})}),
+      makeRowVector({makeFlatVector<int64_t>({5, 6, 7})}),
+  };
+
+  auto result = AssertQueryBuilder(
+                    PlanBuilder()
+                        .values(vectors)
+                        .partialAggregation({}, {"make_set_digest(c0)"})
+                        .intermediateAggregation()
+                        .finalAggregation()
+                        .planNode())
+                    .copyResults(pool());
+
+  verifySetDigest(result, 7);
+}
+
+TEST_F(SetDigestAggregateTest, roundTripSerialization) {
+  auto result = runMakeSetDigest(
+      {makeRowVector({makeFlatVector<int64_t>({1, 2, 3, 4, 5})})});
+
+  auto serialized =
+      result->childAt(0)->as<FlatVector<StringView>>()->valueAt(0);
+
+  auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+  SetDigestType digest1(allocator.get());
+  ASSERT_TRUE(digest1.deserialize(serialized.data(), serialized.size()).ok());
+
+  auto size1 = digest1.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest1.serialize(buffer1.data());
+
+  SetDigestType digest2(allocator.get());
+  ASSERT_TRUE(digest2.deserialize(buffer1.data(), size1).ok());
+
+  auto size2 = digest2.estimatedSerializedSize();
+  std::vector<char> buffer2(size2);
+  digest2.serialize(buffer2.data());
+
+  EXPECT_EQ(size1, size2);
+  EXPECT_EQ(
+      std::string(buffer1.begin(), buffer1.end()),
+      std::string(buffer2.begin(), buffer2.end()));
+}
+
+TEST_F(SetDigestAggregateTest, booleanValues) {
+  auto vectors = makeRowVector({
+      makeFlatVector<bool>({true, false, true, false, true}),
+  });
+
+  auto result = runMakeSetDigest({vectors});
+  verifySetDigest(result, 2);
+}
+
+TEST_F(SetDigestAggregateTest, javaCompatibilityInteger) {
+  // Tests serialization/deserialization round-trip to ensure compatibility
+  // with Java implementation. Unlike other tests which only verify
+  // cardinality, this explicitly tests that the serialized format can be
+  // deserialized correctly (serialize → deserialize → verify).
+  auto result = runMakeSetDigest(
+      {makeRowVector({makeFlatVector<int64_t>({1, 1, 1, 2, 2})})});
+
+  verifySetDigest(result, 2);
+
+  auto serialized =
+      result->childAt(0)->as<FlatVector<StringView>>()->valueAt(0);
+  auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+
+  SetDigestType digest(allocator.get());
+  ASSERT_TRUE(digest.deserialize(serialized.data(), serialized.size()).ok());
+
+  auto size = digest.estimatedSerializedSize();
+  std::vector<char> buffer(size);
+  digest.serialize(buffer.data());
+
+  SetDigestType digest2(allocator.get());
+  ASSERT_TRUE(digest2.deserialize(buffer.data(), size).ok());
+  EXPECT_EQ(digest2.cardinality(), 2);
+}
+
+TEST_F(SetDigestAggregateTest, javaCompatibilityString) {
+  auto result = runMakeSetDigest(
+      {makeRowVector({makeFlatVector<std::string>({"abc", "def"})})});
+
+  verifySetDigest(result, 2);
+
+  auto serialized =
+      result->childAt(0)->as<FlatVector<StringView>>()->valueAt(0);
+  auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+
+  SetDigestType digest(allocator.get());
+  ASSERT_TRUE(digest.deserialize(serialized.data(), serialized.size()).ok());
+
+  auto size = digest.estimatedSerializedSize();
+  std::vector<char> buffer(size);
+  digest.serialize(buffer.data());
+
+  SetDigestType digest2(allocator.get());
+  ASSERT_TRUE(digest2.deserialize(buffer.data(), size).ok());
+  EXPECT_EQ(digest2.cardinality(), 2);
+}
+
+TEST_F(SetDigestAggregateTest, floatValues) {
+  auto vectors = makeRowVector({
+      makeFlatVector<float>({1.2f, 2.3f, 1.2f, 3.4f, 2.3f}),
+  });
+
+  auto result = runMakeSetDigest({vectors});
+  verifySetDigest(result, 3);
+}
+
+TEST_F(SetDigestAggregateTest, doubleValues) {
+  auto vectors = makeRowVector({
+      makeFlatVector<double>({1.5, 2.7, 1.5, 3.9, 2.7}),
+  });
+
+  auto result = runMakeSetDigest({vectors});
+  verifySetDigest(result, 3);
+}
+
+TEST_F(SetDigestAggregateTest, dateValues) {
+  auto vectors = makeRowVector({
+      makeFlatVector<int32_t>(
+          {0, 18262, 0, -5, 18262}, // Various dates including epoch
+          DATE()),
+  });
+
+  auto result = runMakeSetDigest({vectors});
+  verifySetDigest(result, 3);
+}
+
+TEST_F(SetDigestAggregateTest, mergeBasic) {
+  auto data1 = makeRowVector({makeFlatVector<int64_t>({1, 2, 3})});
+  auto data2 = makeRowVector({makeFlatVector<int64_t>({3, 4, 5})});
+
+  std::vector<RowVectorPtr> digestVectors;
+  for (auto& data : {data1, data2}) {
+    digestVectors.push_back(runMakeSetDigest({data}));
+  }
+
+  auto result = runMergeSetDigest(digestVectors);
+  verifySetDigest(result, 5);
+}
+
+TEST_F(SetDigestAggregateTest, mergeWithNullValues) {
+  auto data1 = makeRowVector({makeFlatVector<int64_t>({1, 2})});
+
+  auto op1 = PlanBuilder()
+                 .values({data1})
+                 .singleAggregation({}, {"make_set_digest(c0)"})
+                 .planNode();
+  auto result1 = AssertQueryBuilder(op1).copyResults(pool());
+
+  auto combined = makeRowVector({
+      makeNullableFlatVector<StringView>(
+          {result1->childAt(0)->as<FlatVector<StringView>>()->valueAt(0),
+           std::nullopt,
+           result1->childAt(0)->as<FlatVector<StringView>>()->valueAt(0)}),
+  });
+
+  auto mergeOp = PlanBuilder()
+                     .values({combined})
+                     .project({"cast(c0 as setdigest)"})
+                     .singleAggregation({}, {"merge_set_digest(p0)"})
+                     .planNode();
+
+  auto result = AssertQueryBuilder(mergeOp).copyResults(pool());
+
+  ASSERT_EQ(result->size(), 1);
+  auto resultVector = result->childAt(0)->as<FlatVector<StringView>>();
+  ASSERT_FALSE(resultVector->isNullAt(0));
+
+  auto serialized = resultVector->valueAt(0);
+  auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+  SetDigestType digest(allocator.get());
+  auto status = digest.deserialize(serialized.data(), serialized.size());
+  ASSERT_TRUE(status.ok()) << status.message();
+
+  EXPECT_EQ(digest.cardinality(), 2);
+}
+
+TEST_F(SetDigestAggregateTest, mergeWithGroupBy) {
+  auto data1 = makeRowVector({
+      makeFlatVector<int32_t>({1, 1, 2, 2}),
+      makeFlatVector<int64_t>({10, 20, 30, 40}),
+  });
+
+  auto partialOp =
+      PlanBuilder()
+          .values({data1})
+          .singleAggregation({"c0"}, {"make_set_digest(c1) as digest"})
+          .planNode();
+  auto partialResult = AssertQueryBuilder(partialOp).copyResults(pool());
+
+  auto mergeOp = PlanBuilder()
+                     .values({partialResult})
+                     .project({"c0", "cast(digest as setdigest) as digest"})
+                     .singleAggregation({"c0"}, {"merge_set_digest(digest)"})
+                     .planNode();
+
+  auto result = AssertQueryBuilder(mergeOp).copyResults(pool());
+
+  ASSERT_EQ(result->size(), 2);
+
+  auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+  auto digestVector = result->childAt(1)->as<FlatVector<StringView>>();
+
+  for (auto i = 0; i < result->size(); ++i) {
+    auto serialized = digestVector->valueAt(i);
+
+    SetDigestType mergedDigest(allocator.get());
+    auto status =
+        mergedDigest.deserialize(serialized.data(), serialized.size());
+    ASSERT_TRUE(status.ok()) << status.message();
+
+    EXPECT_EQ(mergedDigest.cardinality(), 2);
+    EXPECT_TRUE(mergedDigest.isExact());
+  }
+}
+
+TEST_F(SetDigestAggregateTest, mergeDistributedAggregation) {
+  std::vector<RowVectorPtr> partialResults;
+
+  for (int64_t i = 0; i < 3; ++i) {
+    std::vector<int64_t> values;
+    for (int64_t j = i * 10; j < (i + 1) * 10; ++j) {
+      values.push_back(j);
+    }
+    partialResults.push_back(
+        runMakeSetDigest({makeRowVector({makeFlatVector<int64_t>(values)})}));
+  }
+
+  auto result = runMergeSetDigest(partialResults);
+  verifySetDigest(result, 30);
+}
+
+TEST_F(SetDigestAggregateTest, mergeLargeApproximateDigests) {
+  std::vector<RowVectorPtr> partialResults;
+
+  for (int64_t i = 0; i < 5; ++i) {
+    std::vector<int64_t> values;
+    values.reserve(20000);
+    for (int64_t j = i * 20000; j < (i + 1) * 20000; ++j) {
+      values.push_back(j);
+    }
+    partialResults.push_back(
+        runMakeSetDigest({makeRowVector({makeFlatVector<int64_t>(values)})}));
+  }
+
+  auto result = runMergeSetDigest(partialResults);
+
+  auto serialized =
+      result->childAt(0)->as<FlatVector<StringView>>()->valueAt(0);
+  auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+  SetDigestType mergedDigest(allocator.get());
+  ASSERT_TRUE(
+      mergedDigest.deserialize(serialized.data(), serialized.size()).ok());
+
+  EXPECT_FALSE(mergedDigest.isExact());
+
+  auto estimatedCardinality = mergedDigest.cardinality();
+  double errorRate = std::abs(estimatedCardinality - 100000) / 100000.0;
+
+  EXPECT_LT(errorRate, 0.05)
+      << "HLL estimate should be within 5% of actual. "
+      << "Actual: 100000, Estimated: " << estimatedCardinality;
+}
+
+TEST_F(SetDigestAggregateTest, mergeMakeSetDigestOutput) {
+  auto vectors = makeRowVector({
+      makeFlatVector<int32_t>({1, 1, 2, 2}),
+      makeFlatVector<int64_t>({10, 20, 30, 40}),
+  });
+
+  auto partialOp =
+      PlanBuilder()
+          .values({vectors})
+          .singleAggregation({"c0"}, {"make_set_digest(c1) as digest"})
+          .planNode();
+
+  auto partialResult = AssertQueryBuilder(partialOp).copyResults(pool());
+
+  auto mergeOp = PlanBuilder()
+                     .values({partialResult})
+                     .project({"cast(digest as setdigest) as digest"})
+                     .singleAggregation({}, {"merge_set_digest(digest)"})
+                     .planNode();
+
+  auto result = AssertQueryBuilder(mergeOp).copyResults(pool());
+
+  ASSERT_EQ(result->size(), 1);
+  auto resultVector = result->childAt(0)->as<FlatVector<StringView>>();
+  ASSERT_FALSE(resultVector->isNullAt(0));
+
+  auto serialized = resultVector->valueAt(0);
+
+  auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+  SetDigestType mergedDigest(allocator.get());
+  auto status = mergedDigest.deserialize(serialized.data(), serialized.size());
+  ASSERT_TRUE(status.ok()) << status.message();
+
+  EXPECT_EQ(mergedDigest.cardinality(), 4);
+  EXPECT_TRUE(mergedDigest.isExact());
+}
+
+TEST_F(SetDigestAggregateTest, mergeRoundTripSerialization) {
+  auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+
+  SetDigestType digest1(allocator.get());
+  digest1.add(1);
+  digest1.add(2);
+  digest1.add(3);
+
+  auto size1 = digest1.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest1.serialize(buffer1.data());
+
+  auto vectors = makeRowVector({
+      makeFlatVector<std::string>(
+          {std::string(buffer1.data(), size1)}, VARBINARY()),
+  });
+
+  auto op = PlanBuilder()
+                .values({vectors})
+                .project({"cast(c0 as setdigest)"})
+                .singleAggregation({}, {"merge_set_digest(p0)"})
+                .planNode();
+
+  auto result = AssertQueryBuilder(op).copyResults(pool());
+
+  auto serialized =
+      result->childAt(0)->as<FlatVector<StringView>>()->valueAt(0);
+
+  SetDigestType digest2(allocator.get());
+  auto status = digest2.deserialize(serialized.data(), serialized.size());
+  ASSERT_TRUE(status.ok()) << status.message();
+
+  auto size2 = digest2.estimatedSerializedSize();
+  std::vector<char> buffer2(size2);
+  digest2.serialize(buffer2.data());
+
+  SetDigestType digest3(allocator.get());
+  status = digest3.deserialize(buffer2.data(), size2);
+  ASSERT_TRUE(status.ok()) << status.message();
+
+  auto size3 = digest3.estimatedSerializedSize();
+  std::vector<char> buffer3(size3);
+  digest3.serialize(buffer3.data());
+
+  EXPECT_EQ(size2, size3);
+  EXPECT_EQ(digest2.cardinality(), 3);
+  EXPECT_EQ(digest3.cardinality(), 3);
+  EXPECT_EQ(
+      std::string(buffer2.begin(), buffer2.end()),
+      std::string(buffer3.begin(), buffer3.end()));
+}
+
+TEST_F(SetDigestAggregateTest, mergeSetDigestGlobalIntermediate) {
+  auto batch1 = makeRowVector({makeFlatVector<std::string>(
+      {serializeSetDigest({1, 2, 3})}, VARBINARY())});
+  auto batch2 = makeRowVector({makeFlatVector<std::string>(
+      {serializeSetDigest({4, 5, 6})}, VARBINARY())});
+  auto batch3 = makeRowVector({makeFlatVector<std::string>(
+      {serializeSetDigest({7, 8, 9})}, VARBINARY())});
+
+  auto result = AssertQueryBuilder(
+                    PlanBuilder()
+                        .values({batch1, batch2, batch3})
+                        .project({"cast(c0 as setdigest)"})
+                        .partialAggregation({}, {"merge_set_digest(p0)"})
+                        .finalAggregation()
+                        .planNode())
+                    .copyResults(pool());
+
+  verifySetDigest(result, 9);
+}
+
+TEST_F(SetDigestAggregateTest, mergeSetDigestGroupedIntermediate) {
+  auto batchWithKey1 = makeRowVector({
+      makeFlatVector<int32_t>({1, 2}),
+      makeFlatVector<std::string>(
+          {serializeSetDigest({1, 2, 3}), serializeSetDigest({10, 20})},
+          VARBINARY()),
+  });
+  auto batchWithKey2 = makeRowVector({
+      makeFlatVector<int32_t>({1, 2}),
+      makeFlatVector<std::string>(
+          {serializeSetDigest({4, 5, 6}), serializeSetDigest({30, 40})},
+          VARBINARY()),
+  });
+  auto batchWithKey3 = makeRowVector({
+      makeFlatVector<int32_t>({1, 2}),
+      makeFlatVector<std::string>(
+          {serializeSetDigest({7, 8, 9}), serializeSetDigest({50, 60})},
+          VARBINARY()),
+  });
+
+  auto result =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values({batchWithKey1, batchWithKey2, batchWithKey3})
+              .project({"c0", "cast(c1 as setdigest) as digest"})
+              .partialAggregation({"c0"}, {"merge_set_digest(digest)"})
+              .finalAggregation()
+              .planNode())
+          .copyResults(pool());
+
+  ASSERT_EQ(result->size(), 2);
+  verifySetDigest(result, 9, true, 0);
+  verifySetDigest(result, 6, true, 1);
+}
+
+} // namespace
+
+} // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/SumTest.cpp b/velox/functions/prestosql/aggregates/tests/SumTest.cpp
index c30257db0c8..e95ab24311e 100644
--- a/velox/functions/prestosql/aggregates/tests/SumTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/SumTest.cpp
@@ -15,10 +15,10 @@
  */
 
 #include "velox/common/base/tests/GTestUtils.h"
-#include "velox/exec/AggregationHook.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/functions/lib/aggregates/tests/SumTestBase.h"
+#include "velox/vector/AggregationHook.h"
 
 using facebook::velox::exec::test::PlanBuilder;
 using namespace facebook::velox::exec::test;
diff --git a/velox/functions/prestosql/aggregates/tests/VectorSumTest.cpp b/velox/functions/prestosql/aggregates/tests/VectorSumTest.cpp
new file mode 100644
index 00000000000..a74a0a6d4f6
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/tests/VectorSumTest.cpp
@@ -0,0 +1,633 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::functions::aggregate::test;
+
+namespace facebook::velox::aggregate::test {
+
+namespace {
+
+class VectorSumTest : public AggregationTestBase {};
+
+TEST_F(VectorSumTest, global) {
+  auto data = makeRowVector({
+      makeArrayVectorFromJson<int64_t>({
+          "[1, 2, 3, 0]",
+          "[10, 5, 4, 1]",
+          "[9, null, 5, 4]",
+      }),
+  });
+
+  auto expected = makeRowVector({
+      makeArrayVector<int64_t>({
+          {20, 7, 12, 5},
+      }),
+  });
+
+  testAggregations({data}, {}, {"vector_sum(c0)"}, {expected});
+}
+
+TEST_F(VectorSumTest, globalWithNulls) {
+  auto data = makeRowVector({
+      makeArrayVectorFromJson<int64_t>({
+          "[1, null, 3]",
+          "[10, 5, null]",
+          "[null, null, 5]",
+      }),
+  });
+
+  auto expected = makeRowVector({
+      makeArrayVector<int64_t>({
+          {11, 5, 8},
+      }),
+  });
+
+  testAggregations({data}, {}, {"vector_sum(c0)"}, {expected});
+}
+
+TEST_F(VectorSumTest, differentLengthsThrowsError) {
+  auto data = makeRowVector({
+      makeArrayVectorFromJson<int64_t>({
+          "[1, 2]",
+          "[10, 5, 4, 1]",
+      }),
+  });
+
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .singleAggregation({}, {"vector_sum(c0)"})
+                  .planNode();
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan).copyResults(pool()),
+      "All arrays must have the same length.");
+}
+
+TEST_F(VectorSumTest, emptyArrays) {
+  auto allEmptyArrays = makeRowVector({
+      makeArrayVector<int64_t>({
+          {},
+          {},
+          {},
+      }),
+  });
+
+  auto expectedEmpty = makeRowVector({
+      makeArrayVector<int64_t>({
+          {},
+      }),
+  });
+
+  testAggregations({allEmptyArrays}, {}, {"vector_sum(c0)"}, {expectedEmpty});
+}
+
+TEST_F(VectorSumTest, nullArrays) {
+  auto allNullArrays = makeRowVector(
+      {BaseVector::createNullConstant(ARRAY(BIGINT()), 3, pool())});
+
+  auto expectedNull = makeRowVector(
+      {BaseVector::createNullConstant(ARRAY(BIGINT()), 1, pool())});
+
+  testAggregations({allNullArrays}, {}, {"vector_sum(c0)"}, {expectedNull});
+}
+
+TEST_F(VectorSumTest, tinyintOverflow) {
+  const std::vector<std::vector<std::optional<int8_t>>> inputData = {
+      {{10, 20}},
+      {{100, 30}},
+      {{30, 50}},
+  };
+  auto data = makeRowVector({makeNullableArrayVector(inputData)});
+
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .singleAggregation({}, {"vector_sum(c0)"})
+                  .planNode();
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan).copyResults(pool()),
+      "integer overflow: 110 + 30");
+
+  const std::vector<std::vector<std::optional<int8_t>>> negInputData = {
+      {{-10, -20}},
+      {{-100, -30}},
+      {{-30, -50}},
+  };
+  data = makeRowVector({makeNullableArrayVector(negInputData)});
+
+  plan = PlanBuilder()
+             .values({data})
+             .singleAggregation({}, {"vector_sum(c0)"})
+             .planNode();
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan).copyResults(pool()),
+      "integer overflow: -110 + -30");
+}
+
+TEST_F(VectorSumTest, smallintOverflow) {
+  const int16_t largeValue = std::numeric_limits<int16_t>::max() - 20;
+  const int16_t smallValue = std::numeric_limits<int16_t>::min() + 20;
+
+  const std::vector<std::vector<std::optional<int16_t>>> inputData = {
+      {{10, 20}},
+      {{largeValue, 30}},
+      {{30, 50}},
+  };
+  auto data = makeRowVector({makeNullableArrayVector(inputData)});
+
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .singleAggregation({}, {"vector_sum(c0)"})
+                  .planNode();
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan).copyResults(pool()),
+      "integer overflow: 32757 + 30");
+
+  const std::vector<std::vector<std::optional<int16_t>>> negInputData = {
+      {{-10, -20}},
+      {{smallValue, -30}},
+      {{-30, -50}},
+  };
+  data = makeRowVector({makeNullableArrayVector(negInputData)});
+
+  plan = PlanBuilder()
+             .values({data})
+             .singleAggregation({}, {"vector_sum(c0)"})
+             .planNode();
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan).copyResults(pool()),
+      "integer overflow: -32758 + -30");
+}
+
+TEST_F(VectorSumTest, integerOverflow) {
+  const int32_t largeValue = std::numeric_limits<int32_t>::max() - 20;
+  const int32_t smallValue = std::numeric_limits<int32_t>::min() + 20;
+
+  const std::vector<std::vector<std::optional<int32_t>>> inputData = {
+      {{10, 20}},
+      {{largeValue, 30}},
+      {{30, 50}},
+  };
+  auto data = makeRowVector({makeNullableArrayVector(inputData)});
+
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .singleAggregation({}, {"vector_sum(c0)"})
+                  .planNode();
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan).copyResults(pool()),
+      "integer overflow: 2147483637 + 30");
+
+  const std::vector<std::vector<std::optional<int32_t>>> negInputData = {
+      {{-10, -20}},
+      {{smallValue, -30}},
+      {{-30, -50}},
+  };
+  data = makeRowVector({makeNullableArrayVector(negInputData)});
+
+  plan = PlanBuilder()
+             .values({data})
+             .singleAggregation({}, {"vector_sum(c0)"})
+             .planNode();
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan).copyResults(pool()),
+      "integer overflow: -2147483638 + -30");
+}
+
+TEST_F(VectorSumTest, bigintOverflow) {
+  const int64_t largeValue = std::numeric_limits<int64_t>::max() - 20;
+  const int64_t smallValue = std::numeric_limits<int64_t>::min() + 20;
+
+  const std::vector<std::vector<std::optional<int64_t>>> inputData = {
+      {{10, 20}},
+      {{largeValue, 30}},
+      {{30, 50}},
+  };
+  auto data = makeRowVector({makeNullableArrayVector(inputData)});
+
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .singleAggregation({}, {"vector_sum(c0)"})
+                  .planNode();
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan).copyResults(pool()),
+      "integer overflow: 9223372036854775797 + 30");
+
+  const std::vector<std::vector<std::optional<int64_t>>> negInputData = {
+      {{-10, -20}},
+      {{smallValue, -30}},
+      {{-30, -50}},
+  };
+  data = makeRowVector({makeNullableArrayVector(negInputData)});
+
+  plan = PlanBuilder()
+             .values({data})
+             .singleAggregation({}, {"vector_sum(c0)"})
+             .planNode();
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan).copyResults(pool()),
+      "integer overflow: -9223372036854775798 + -30");
+}
+
+TEST_F(VectorSumTest, floatNan) {
+  constexpr float kInf = std::numeric_limits<float>::infinity();
+  constexpr float kNan = std::numeric_limits<float>::quiet_NaN();
+
+  const std::vector<std::vector<std::optional<float>>> inputData = {
+      {{10.0F, 20.0F}},
+      {{kNan, 30.0F}},
+      {{30.0F, kInf}},
+  };
+  auto data = makeRowVector({makeNullableArrayVector(inputData)});
+
+  auto expected = makeRowVector({
+      makeArrayVector<float>({
+          {kNan, kInf},
+      }),
+  });
+
+  testAggregations({data}, {}, {"vector_sum(c0)"}, {expected});
+}
+
+TEST_F(VectorSumTest, doubleNan) {
+  constexpr double kInf = std::numeric_limits<double>::infinity();
+  constexpr double kNan = std::numeric_limits<double>::quiet_NaN();
+
+  const std::vector<std::vector<std::optional<double>>> inputData = {
+      {{10.0, 20.0}},
+      {{kNan, 30.0}},
+      {{30.0, kInf}},
+  };
+  auto data = makeRowVector({makeNullableArrayVector(inputData)});
+
+  auto expected = makeRowVector({
+      makeArrayVector<double>({
+          {kNan, kInf},
+      }),
+  });
+
+  testAggregations({data}, {}, {"vector_sum(c0)"}, {expected});
+}
+
+TEST_F(VectorSumTest, groupBy) {
+  const std::vector<std::vector<std::optional<int64_t>>> inputData1 = {
+      {{1, 2, 3}},
+  };
+  const std::vector<std::vector<std::optional<int64_t>>> inputData2 = {
+      {{10, 5, 4}},
+  };
+  const std::vector<std::vector<std::optional<int64_t>>> inputData3 = {
+      {{1, 2, 7}},
+  };
+  const std::vector<std::vector<std::optional<int64_t>>> inputData4 = {
+      {{9, 0, 5}},
+  };
+
+  auto batch1 = makeRowVector({
+      makeFlatVector<int64_t>({1}),
+      makeNullableArrayVector(inputData1),
+  });
+  auto batch2 = makeRowVector({
+      makeFlatVector<int64_t>({1}),
+      makeNullableArrayVector(inputData2),
+  });
+  auto batch3 = makeRowVector({
+      makeFlatVector<int64_t>({2}),
+      makeNullableArrayVector(inputData3),
+  });
+  auto batch4 = makeRowVector({
+      makeFlatVector<int64_t>({1}),
+      makeNullableArrayVector(inputData4),
+  });
+
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>({1, 2}),
+      makeArrayVector<int64_t>({
+          {20, 7, 12},
+          {1, 2, 7},
+      }),
+  });
+
+  testAggregations(
+      {batch1, batch2, batch3, batch4}, {"c0"}, {"vector_sum(c1)"}, {expected});
+}
+
+TEST_F(VectorSumTest, zerosSkipped) {
+  const std::vector<std::vector<std::optional<int64_t>>> inputData = {
+      {{0, 0, 0, 0}},
+      {{0, 0, 0, 0}},
+      {{0, 0, 0, 0}},
+  };
+  auto data = makeRowVector({makeNullableArrayVector(inputData)});
+
+  auto expected = makeRowVector({
+      makeArrayVector<int64_t>({
+          {0, 0, 0, 0},
+      }),
+  });
+
+  testAggregations({data}, {}, {"vector_sum(c0)"}, {expected});
+}
+
+TEST_F(VectorSumTest, mixedZerosNullsAndValues) {
+  const std::vector<std::vector<std::optional<int64_t>>> inputData = {
+      {{0, std::nullopt, 5, 0}},
+      {{std::nullopt, 0, 0, 3}},
+      {{7, 0, std::nullopt, 0}},
+  };
+  auto data = makeRowVector({makeNullableArrayVector(inputData)});
+
+  auto expected = makeRowVector({
+      makeArrayVector<int64_t>({
+          {7, 0, 5, 3},
+      }),
+  });
+
+  testAggregations({data}, {}, {"vector_sum(c0)"}, {expected});
+}
+
+TEST_F(VectorSumTest, allZerosAndNulls) {
+  const std::vector<std::vector<std::optional<int64_t>>> inputData = {
+      {{0, std::nullopt}},
+      {{std::nullopt, 0}},
+      {{0, 0}},
+  };
+  auto data = makeRowVector({makeNullableArrayVector(inputData)});
+
+  auto expected = makeRowVector({
+      makeArrayVector<int64_t>({
+          {0, 0},
+      }),
+  });
+
+  testAggregations({data}, {}, {"vector_sum(c0)"}, {expected});
+}
+
+TEST_F(VectorSumTest, zerosWithFloats) {
+  const std::vector<std::vector<std::optional<float>>> inputData = {
+      {{0.0F, 1.5F, 0.0F}},
+      {{3.5F, 0.0F, 0.0F}},
+      {{0.0F, 0.0F, 2.5F}},
+  };
+  auto data = makeRowVector({makeNullableArrayVector(inputData)});
+
+  auto expected = makeRowVector({
+      makeArrayVector<float>({
+          {3.5F, 1.5F, 2.5F},
+      }),
+  });
+
+  testAggregations({data}, {}, {"vector_sum(c0)"}, {expected});
+}
+
+TEST_F(VectorSumTest, zerosWithDoubles) {
+  const std::vector<std::vector<std::optional<double>>> inputData = {
+      {{0.0, 1.5, 0.0}},
+      {{3.5, 0.0, 0.0}},
+      {{0.0, 0.0, 2.5}},
+  };
+  auto data = makeRowVector({makeNullableArrayVector(inputData)});
+
+  auto expected = makeRowVector({
+      makeArrayVector<double>({
+          {3.5, 1.5, 2.5},
+      }),
+  });
+
+  testAggregations({data}, {}, {"vector_sum(c0)"}, {expected});
+}
+
+TEST_F(VectorSumTest, singleElement) {
+  const std::vector<std::vector<std::optional<int64_t>>> inputData = {
+      {{100}},
+      {{200}},
+      {{300}},
+  };
+  auto data = makeRowVector({makeNullableArrayVector(inputData)});
+
+  auto expected = makeRowVector({
+      makeArrayVector<int64_t>({
+          {600},
+      }),
+  });
+
+  testAggregations({data}, {}, {"vector_sum(c0)"}, {expected});
+}
+
+TEST_F(VectorSumTest, allNullElements) {
+  const std::vector<std::vector<std::optional<int64_t>>> inputData = {
+      {{std::nullopt, std::nullopt}},
+      {{std::nullopt, std::nullopt}},
+      {{std::nullopt, std::nullopt}},
+  };
+  auto data = makeRowVector({makeNullableArrayVector(inputData)});
+
+  const std::vector<std::vector<std::optional<int64_t>>> expectedData = {
+      {{std::nullopt, std::nullopt}},
+  };
+  auto expected = makeRowVector({makeNullableArrayVector(expectedData)});
+
+  testAggregations({data}, {}, {"vector_sum(c0)"}, {expected});
+}
+
+TEST_F(VectorSumTest, realType) {
+  const std::vector<std::vector<std::optional<float>>> inputData = {
+      {{1.5F, 2.5F, 0.0F}},
+      {{10.5F, 5.5F, 4.0F}},
+      {{9.0F, std::nullopt, 5.5F}},
+  };
+  auto data = makeRowVector({makeNullableArrayVector(inputData)});
+
+  auto expected = makeRowVector({
+      makeArrayVector<float>({
+          {21.0F, 8.0F, 9.5F},
+      }),
+  });
+
+  testAggregations({data}, {}, {"vector_sum(c0)"}, {expected});
+}
+
+TEST_F(VectorSumTest, doubleType) {
+  const std::vector<std::vector<std::optional<double>>> inputData = {
+      {{1.5, 2.5, 0.0}},
+      {{10.5, 5.5, 4.0}},
+      {{9.0, std::nullopt, 5.5}},
+  };
+  auto data = makeRowVector({makeNullableArrayVector(inputData)});
+
+  auto expected = makeRowVector({
+      makeArrayVector<double>({
+          {21.0, 8.0, 9.5},
+      }),
+  });
+
+  testAggregations({data}, {}, {"vector_sum(c0)"}, {expected});
+}
+
+TEST_F(VectorSumTest, multipleBatches) {
+  auto batch1 = makeRowVector({
+      makeArrayVector<int64_t>({{1, 2, 3}, {4, 5, 6}}),
+  });
+  auto batch2 = makeRowVector({
+      makeArrayVector<int64_t>({{10, 20, 30}, {40, 50, 60}}),
+  });
+
+  auto expected = makeRowVector({
+      makeArrayVector<int64_t>({{55, 77, 99}}),
+  });
+
+  testAggregations({batch1, batch2}, {}, {"vector_sum(c0)"}, {expected});
+}
+
+/// SQL equivalence tests verify vector_sum results by comparing against
+/// element-wise sums computed using individual sum() aggregations.
+/// This verifies that vector_sum(array[a,b,c]) equals array[sum(a), sum(b),
+/// sum(c)] when arrays are of equal length.
+class VectorSumSqlEquivalenceTest : public AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+  }
+};
+
+TEST_F(VectorSumSqlEquivalenceTest, equivalentToElementWiseSum) {
+  // Create data where we can verify vector_sum against element-wise sums.
+  // If we have rows with arrays [a0, a1], [b0, b1], [c0, c1]
+  // then vector_sum should equal [a0+b0+c0, a1+b1+c1]
+  // which is [sum of first elements, sum of second elements]
+  auto data = makeRowVector({
+      makeArrayVector<int64_t>({{1, 2}, {10, 20}, {100, 200}}),
+  });
+
+  // vector_sum result
+  auto vectorSumResult = AssertQueryBuilder(
+                             PlanBuilder()
+                                 .values({data})
+                                 .singleAggregation({}, {"vector_sum(c0)"})
+                                 .planNode())
+                             .copyResults(pool());
+
+  // Expected: [1+10+100, 2+20+200] = [111, 222]
+  auto expected = makeRowVector({
+      makeArrayVector<int64_t>({{111, 222}}),
+  });
+
+  assertEqualResults({expected}, {vectorSumResult});
+}
+
+TEST_F(VectorSumSqlEquivalenceTest, groupByEquivalence) {
+  // For group by, vector_sum should accumulate arrays within each group.
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 1, 2, 2}),
+      makeArrayVector<int64_t>({{1, 2}, {10, 20}, {100, 200}, {1000, 2000}}),
+  });
+
+  auto vectorSumResult = AssertQueryBuilder(
+                             PlanBuilder()
+                                 .values({data})
+                                 .singleAggregation({"c0"}, {"vector_sum(c1)"})
+                                 .planNode())
+                             .copyResults(pool());
+
+  // Group 1: [1,2] + [10,20] = [11, 22]
+  // Group 2: [100,200] + [1000,2000] = [1100, 2200]
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>({1, 2}),
+      makeArrayVector<int64_t>({{11, 22}, {1100, 2200}}),
+  });
+
+  assertEqualResults({expected}, {vectorSumResult});
+}
+
+TEST_F(VectorSumSqlEquivalenceTest, floatingPointPrecision) {
+  // Verify floating point accumulation works correctly
+  auto data = makeRowVector({
+      makeArrayVector<double>({{0.1, 0.2}, {0.3, 0.4}, {0.5, 0.6}}),
+  });
+
+  auto vectorSumResult = AssertQueryBuilder(
+                             PlanBuilder()
+                                 .values({data})
+                                 .singleAggregation({}, {"vector_sum(c0)"})
+                                 .planNode())
+                             .copyResults(pool());
+
+  // Expected: [0.1+0.3+0.5, 0.2+0.4+0.6] = [0.9, 1.2]
+  auto expected = makeRowVector({
+      makeArrayVector<double>({{0.9, 1.2}}),
+  });
+
+  assertEqualResults({expected}, {vectorSumResult});
+}
+
+TEST_F(VectorSumSqlEquivalenceTest, nullElementsSkipped) {
+  // Null elements are skipped, consistent with standard sum aggregate.
+  // Only positions where ALL inputs are null produce null in the output.
+  const std::vector<std::vector<std::optional<int64_t>>> inputData = {
+      {{1, std::nullopt, 3}},
+      {{10, 20, std::nullopt}},
+      {{std::nullopt, 30, 40}},
+  };
+  auto data = makeRowVector({makeNullableArrayVector(inputData)});
+
+  auto vectorSumResult = AssertQueryBuilder(
+                             PlanBuilder()
+                                 .values({data})
+                                 .singleAggregation({}, {"vector_sum(c0)"})
+                                 .planNode())
+                             .copyResults(pool());
+
+  // Expected: [1+10, 20+30, 3+40] = [11, 50, 43]
+  // Nulls are skipped (not treated as 0); all positions have at least
+  // one non-null value so no output element is null.
+  auto expected = makeRowVector({
+      makeArrayVector<int64_t>({{11, 50, 43}}),
+  });
+
+  assertEqualResults({expected}, {vectorSumResult});
+}
+
+TEST_F(VectorSumSqlEquivalenceTest, differentLengthArraysThrowsError) {
+  // Arrays of different lengths now throw an error
+  auto data = makeRowVector({
+      makeArrayVector<int64_t>({{1, 2, 3, 4}, {10, 20}, {100}}),
+  });
+
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .singleAggregation({}, {"vector_sum(c0)"})
+                  .planNode();
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan).copyResults(pool()),
+      "All arrays must have the same length.");
+}
+
+} // namespace
+
+} // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/benchmarks/ArrayConstructorBenchmark.cpp b/velox/functions/prestosql/benchmarks/ArrayConstructorBenchmark.cpp
index 4bcd170e272..42528cfd92c 100644
--- a/velox/functions/prestosql/benchmarks/ArrayConstructorBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/ArrayConstructorBenchmark.cpp
@@ -60,7 +60,7 @@ int main(int argc, char** argv) {
         .addBenchmarkSet(
             fmt::format(
                 "array_constructor_{}_{}{}",
-                mapTypeKindToName(type->kind()),
+                TypeKindName::toName(type->kind()),
                 withNulls ? "nulls" : "nullfree",
                 suffix),
             input)
diff --git a/velox/functions/prestosql/benchmarks/ArrayPositionBasic.h b/velox/functions/prestosql/benchmarks/ArrayPositionBasic.h
index 656fa9d854a..25ade62db6f 100644
--- a/velox/functions/prestosql/benchmarks/ArrayPositionBasic.h
+++ b/velox/functions/prestosql/benchmarks/ArrayPositionBasic.h
@@ -254,22 +254,23 @@ class ArrayPositionFunctionBasic : public exec::VectorFunction {
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
-    return {// array(T), T -> int64_t
-            exec::FunctionSignatureBuilder()
-                .typeVariable("T")
-                .returnType("bigint")
-                .argumentType("array(T)")
-                .argumentType("T")
-                .build(),
-
-            // array(T), T, int64_t -> int64_t
-            exec::FunctionSignatureBuilder()
-                .typeVariable("T")
-                .returnType("bigint")
-                .argumentType("array(T)")
-                .argumentType("T")
-                .argumentType("bigint")
-                .build()};
+    return {
+        // array(T), T -> int64_t
+        exec::FunctionSignatureBuilder()
+            .typeVariable("T")
+            .returnType("bigint")
+            .argumentType("array(T)")
+            .argumentType("T")
+            .build(),
+
+        // array(T), T, int64_t -> int64_t
+        exec::FunctionSignatureBuilder()
+            .typeVariable("T")
+            .returnType("bigint")
+            .argumentType("array(T)")
+            .argumentType("T")
+            .argumentType("bigint")
+            .build()};
   }
 };
 
diff --git a/velox/functions/prestosql/benchmarks/ArrayWriterBenchmark.cpp b/velox/functions/prestosql/benchmarks/ArrayWriterBenchmark.cpp
index 9688b5ce9ff..fcb65924583 100644
--- a/velox/functions/prestosql/benchmarks/ArrayWriterBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/ArrayWriterBenchmark.cpp
@@ -215,7 +215,7 @@ class ArrayWriterBenchmark : public functions::test::FunctionBenchmarkBase {
       auto other =
           compileExpression(fmt::format("{}(c0)", name), input->type());
       if (!hasSameResults(exprSetRef, other, input)) {
-        VELOX_UNREACHABLE(fmt::format("testing failed at function {}", name));
+        VELOX_UNREACHABLE("Testing failed at function: {}", name);
       }
     }
   }
diff --git a/velox/functions/prestosql/benchmarks/CMakeLists.txt b/velox/functions/prestosql/benchmarks/CMakeLists.txt
index 2b1d774aaa0..0d4e94c88db 100644
--- a/velox/functions/prestosql/benchmarks/CMakeLists.txt
+++ b/velox/functions/prestosql/benchmarks/CMakeLists.txt
@@ -32,9 +32,11 @@ set(
 )
 
 add_executable(velox_functions_prestosql_benchmarks_array_contains ArrayContainsBenchmark.cpp)
+velox_add_test_headers(velox_functions_prestosql_benchmarks_array_contains ArrayPositionBasic.h)
 target_link_libraries(velox_functions_prestosql_benchmarks_array_contains ${BENCHMARK_DEPENDENCIES})
 
 add_executable(velox_functions_prestosql_benchmarks_array_min_max ArrayMinMaxBenchmark.cpp)
+velox_add_test_headers(velox_functions_prestosql_benchmarks_array_min_max ArrayMinMaxBenchmark.h)
 target_link_libraries(velox_functions_prestosql_benchmarks_array_min_max ${BENCHMARK_DEPENDENCIES})
 
 add_executable(velox_functions_prestosql_benchmarks_array_position ArrayPositionBenchmark.cpp)
@@ -79,9 +81,15 @@ target_link_libraries(velox_functions_prestosql_benchmarks_bitwise ${BENCHMARK_D
 add_executable(velox_functions_prestosql_benchmarks_in InBenchmark.cpp)
 target_link_libraries(velox_functions_prestosql_benchmarks_in ${BENCHMARK_DEPENDENCIES})
 
+add_executable(velox_functions_prestosql_benchmarks_map_concat MapConcatBenchmark.cpp)
+target_link_libraries(velox_functions_prestosql_benchmarks_map_concat ${BENCHMARK_DEPENDENCIES})
+
 add_executable(velox_functions_prestosql_benchmarks_map_input MapInputBenchmark.cpp)
 target_link_libraries(velox_functions_prestosql_benchmarks_map_input ${BENCHMARK_DEPENDENCIES})
 
+add_executable(velox_functions_prestosql_benchmarks_map_intersect MapIntersectBenchmark.cpp)
+target_link_libraries(velox_functions_prestosql_benchmarks_map_intersect ${BENCHMARK_DEPENDENCIES})
+
 add_executable(velox_functions_benchmarks_url URLBenchmark.cpp)
 target_link_libraries(velox_functions_benchmarks_url ${BENCHMARK_DEPENDENCIES})
 
@@ -148,6 +156,9 @@ target_link_libraries(velox_functions_prestosql_benchmarks_zip_with ${BENCHMARK_
 add_executable(velox_functions_prestosql_benchmarks_map_zip_with MapZipWithBenchmark.cpp)
 target_link_libraries(velox_functions_prestosql_benchmarks_map_zip_with ${BENCHMARK_DEPENDENCIES})
 
+add_executable(velox_functions_prestosql_benchmarks_map_except MapExceptBenchmark.cpp)
+target_link_libraries(velox_functions_prestosql_benchmarks_map_except ${BENCHMARK_DEPENDENCIES})
+
 add_executable(velox_functions_prestosql_benchmarks_cardinality CardinalityBenchmark.cpp)
 target_link_libraries(velox_functions_prestosql_benchmarks_cardinality ${BENCHMARK_DEPENDENCIES})
 
diff --git a/velox/functions/prestosql/benchmarks/JsonExprBenchmark.cpp b/velox/functions/prestosql/benchmarks/JsonExprBenchmark.cpp
index 343d265ee5d..7e54d4e7419 100644
--- a/velox/functions/prestosql/benchmarks/JsonExprBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/JsonExprBenchmark.cpp
@@ -13,10 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/**
- * This file tests the performance of each JsonXXXFunction.call() with
- * expression framework and Velox vectors.
- */
+
 #include <folly/Benchmark.h>
 #include <folly/init/Init.h>
 #include "velox/functions/Registerer.h"
@@ -26,10 +23,15 @@
 #include "velox/functions/prestosql/types/JsonRegistration.h"
 #include "velox/functions/prestosql/types/JsonType.h"
 
+/// This file tests the performance of each JsonXXXFunction.call() with
+/// expression framework and Velox vectors.
+
 namespace facebook::velox::functions {
+
 void registerJsonVectorFunctions() {
   VELOX_REGISTER_VECTOR_FUNCTION(udf_json_extract, "json_extract");
 }
+
 } // namespace facebook::velox::functions
 
 namespace facebook::velox::functions::prestosql {
@@ -40,7 +42,7 @@ struct FollyIsJsonScalarFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
   FOLLY_ALWAYS_INLINE void call(bool& result, const arg_type<Json>& json) {
-    auto parsedJson = folly::parseJson(json);
+    auto parsedJson = folly::parseJson(std::string_view(json));
     result = parsedJson.isNumber() || parsedJson.isString() ||
         parsedJson.isBool() || parsedJson.isNull();
   }
@@ -59,10 +61,9 @@ struct FollyJsonExtractScalarFunction {
       out_type<Varchar>& result,
       const arg_type<Json>& json,
       const arg_type<Varchar>& jsonPath) {
-    const folly::StringPiece& jsonStringPiece = json;
-    const folly::StringPiece& jsonPathStringPiece = jsonPath;
+    // TODO: Remove explicit std::string_view cast.
     auto extractResult =
-        jsonExtractScalar(jsonStringPiece, jsonPathStringPiece);
+        jsonExtractScalar(std::string_view(json), std::string_view(jsonPath));
     if (extractResult.has_value()) {
       UDFOutputString::assign(result, *extractResult);
       return true;
@@ -80,8 +81,9 @@ struct FollyJsonExtractFunction {
       out_type<Json>& result,
       const arg_type<Json>& json,
       const arg_type<Varchar>& jsonPath) {
+    // TODO: Remove explicit std::string_view cast.
     auto extractResult =
-        jsonExtract(folly::StringPiece(json), folly::StringPiece(jsonPath));
+        jsonExtract(std::string_view(json), std::string_view(jsonPath));
     if (!extractResult.has_value() || extractResult.value().isNull()) {
       return false;
     }
@@ -101,7 +103,7 @@ struct FollyJsonArrayLengthFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
   FOLLY_ALWAYS_INLINE bool call(int64_t& result, const arg_type<Json>& json) {
-    auto parsedJson = folly::parseJson(json);
+    auto parsedJson = folly::parseJson(std::string_view(json));
     if (!parsedJson.isArray()) {
       return false;
     }
@@ -118,7 +120,7 @@ struct FollyJsonArrayContainsFunction {
   template <typename TInput>
   FOLLY_ALWAYS_INLINE bool
   call(bool& result, const arg_type<Json>& json, const TInput& value) {
-    auto parsedJson = folly::parseJson(json);
+    auto parsedJson = folly::parseJson(std::string_view(json));
     if (!parsedJson.isArray()) {
       return false;
     }
@@ -159,9 +161,9 @@ struct FollyJsonSizeFunction {
       int64_t& result,
       const arg_type<Json>& json,
       const arg_type<Varchar>& jsonPath) {
-    const folly::StringPiece& jsonStringPiece = json;
-    const folly::StringPiece& jsonPathStringPiece = jsonPath;
-    auto extractResult = jsonExtract(jsonStringPiece, jsonPathStringPiece);
+    // TODO: Remove explicit std::string_view cast.
+    auto extractResult =
+        jsonExtract(std::string_view(json), std::string_view(jsonPath));
     if (!extractResult.has_value()) {
       return false;
     }
@@ -241,7 +243,7 @@ struct SimdjsonParseFunction {
     } else {
       SIMDJSON_ASSIGN_OR_RAISE(auto doc, simdjsonParse(paddedJson));
       // Parse paddedJson again.
-      simdjsonParse(paddedJson).get(jsonDoc);
+      std::ignore = simdjsonParse(paddedJson).get(jsonDoc);
     }
     result = true;
     return simdjson::SUCCESS;
diff --git a/velox/functions/prestosql/benchmarks/MapConcatBenchmark.cpp b/velox/functions/prestosql/benchmarks/MapConcatBenchmark.cpp
new file mode 100644
index 00000000000..1c2c0e40516
--- /dev/null
+++ b/velox/functions/prestosql/benchmarks/MapConcatBenchmark.cpp
@@ -0,0 +1,314 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+#include <gflags/gflags.h>
+
+#include "velox/common/memory/Memory.h"
+#include "velox/functions/lib/benchmarks/FunctionBenchmarkBase.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/vector/tests/utils/VectorMaker.h"
+
+#include <algorithm>
+#include <numeric>
+#include <random>
+
+DEFINE_int32(batch_size, 10'000, "Number of rows per batch");
+DEFINE_int32(num_batches, 10, "Number of batches per iteration");
+DEFINE_int32(seed, 42, "Random seed for key shuffling");
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+
+namespace {
+
+class MapConcatBenchmark : public functions::test::FunctionBenchmarkBase {
+ public:
+  MapConcatBenchmark() {
+    functions::prestosql::registerAllScalarFunctions();
+  }
+
+  // Generate two map vectors with configurable key overlap and run the
+  // benchmark.
+  //
+  // overlapFraction: 0.0 = no overlap, 0.5 = half overlap, 1.0 = full overlap.
+  // mapSize: number of entries per map.
+  // sorted: if true, keys are in ascending order; if false, keys are shuffled.
+  unsigned
+  run(double overlapFraction, int mapSize, unsigned times, bool sorted) {
+    folly::BenchmarkSuspender suspender;
+
+    const int numRows{FLAGS_batch_size};
+
+    // Build key arrays.
+    std::vector<int64_t> keys1(mapSize);
+    std::iota(keys1.begin(), keys1.end(), 0);
+
+    int overlap{static_cast<int>(mapSize * overlapFraction)};
+    int shift{mapSize - overlap};
+    std::vector<int64_t> keys2(mapSize);
+    std::iota(keys2.begin(), keys2.end(), shift);
+
+    if (!sorted) {
+      std::default_random_engine gen(FLAGS_seed);
+      std::shuffle(keys1.begin(), keys1.end(), gen);
+      std::shuffle(keys2.begin(), keys2.end(), gen);
+    }
+
+    // Map1: shuffled keys from [0, mapSize).
+    auto map1 = maker().mapVector<int64_t, int64_t>(
+        numRows,
+        [&](auto /*row*/) { return mapSize; },
+        [&](auto /*row*/, auto entry) { return keys1[entry]; },
+        [](auto row, auto entry) { return row * 100 + entry; });
+
+    // Map2: shuffled keys from [shift, shift + mapSize).
+    auto map2 = maker().mapVector<int64_t, int64_t>(
+        numRows,
+        [&](auto /*row*/) { return mapSize; },
+        [&](auto /*row*/, auto entry) { return keys2[entry]; },
+        [](auto row, auto entry) { return row * 100 + entry + 1'000; });
+
+    auto data = maker().rowVector({"c0", "c1"}, {map1, map2});
+    auto exprSet =
+        compileExpression("map_concat(c0, c1)", asRowType(data->type()));
+
+    suspender.dismiss();
+
+    unsigned count{0};
+    for (unsigned i = 0; i < times * FLAGS_num_batches; ++i) {
+      count += evaluate(exprSet, data)->size();
+    }
+    return count;
+  }
+
+  // Dictionary-encoded variant.  Wraps flat maps in a dictionary layer.
+  unsigned
+  runDict(double overlapFraction, int mapSize, unsigned times, bool sorted) {
+    folly::BenchmarkSuspender suspender;
+
+    const int numRows{FLAGS_batch_size};
+
+    std::vector<int64_t> keys1(mapSize);
+    std::iota(keys1.begin(), keys1.end(), 0);
+
+    int overlap{static_cast<int>(mapSize * overlapFraction)};
+    int shift{mapSize - overlap};
+    std::vector<int64_t> keys2(mapSize);
+    std::iota(keys2.begin(), keys2.end(), shift);
+
+    if (!sorted) {
+      std::default_random_engine gen(FLAGS_seed);
+      std::shuffle(keys1.begin(), keys1.end(), gen);
+      std::shuffle(keys2.begin(), keys2.end(), gen);
+    }
+
+    auto flatMap1 = maker().mapVector<int64_t, int64_t>(
+        numRows,
+        [&](auto /*row*/) { return mapSize; },
+        [&](auto /*row*/, auto entry) { return keys1[entry]; },
+        [](auto row, auto entry) { return row * 100 + entry; });
+
+    auto flatMap2 = maker().mapVector<int64_t, int64_t>(
+        numRows,
+        [&](auto /*row*/) { return mapSize; },
+        [&](auto /*row*/, auto entry) { return keys2[entry]; },
+        [](auto row, auto entry) { return row * 100 + entry + 1'000; });
+
+    // Wrap in identity dictionary encoding.
+    auto indices =
+        maker().flatVector<int32_t>(numRows, [](auto row) { return row; });
+    auto map1 = BaseVector::wrapInDictionary(
+        BufferPtr(nullptr), indices->values(), numRows, flatMap1);
+    auto map2 = BaseVector::wrapInDictionary(
+        BufferPtr(nullptr), indices->values(), numRows, flatMap2);
+
+    auto data = maker().rowVector({"c0", "c1"}, {map1, map2});
+    auto exprSet =
+        compileExpression("map_concat(c0, c1)", asRowType(data->type()));
+
+    suspender.dismiss();
+
+    unsigned count{0};
+    for (unsigned i = 0; i < times * FLAGS_num_batches; ++i) {
+      count += evaluate(exprSet, data)->size();
+    }
+    return count;
+  }
+
+  // VARCHAR key variant.
+  unsigned
+  runVarchar(double overlapFraction, int mapSize, unsigned times, bool sorted) {
+    folly::BenchmarkSuspender suspender;
+
+    const int numRows{FLAGS_batch_size};
+
+    // Build string key arrays.
+    std::vector<std::string> keys1(mapSize);
+    for (int i = 0; i < mapSize; ++i) {
+      keys1[i] = fmt::format("key_{:06d}", i);
+    }
+
+    int overlap{static_cast<int>(mapSize * overlapFraction)};
+    int shift{mapSize - overlap};
+    std::vector<std::string> keys2(mapSize);
+    for (int i = 0; i < mapSize; ++i) {
+      keys2[i] = fmt::format("key_{:06d}", i + shift);
+    }
+
+    if (!sorted) {
+      std::default_random_engine gen(FLAGS_seed);
+      std::shuffle(keys1.begin(), keys1.end(), gen);
+      std::shuffle(keys2.begin(), keys2.end(), gen);
+    }
+
+    auto map1 = maker().mapVector<StringView, int64_t>(
+        numRows,
+        [&](auto /*row*/) { return mapSize; },
+        [&](auto /*row*/, auto entry) { return StringView(keys1[entry]); },
+        [](auto row, auto entry) { return row * 100 + entry; });
+
+    auto map2 = maker().mapVector<StringView, int64_t>(
+        numRows,
+        [&](auto /*row*/) { return mapSize; },
+        [&](auto /*row*/, auto entry) { return StringView(keys2[entry]); },
+        [](auto row, auto entry) { return row * 100 + entry + 1'000; });
+
+    auto data = maker().rowVector({"c0", "c1"}, {map1, map2});
+    auto exprSet =
+        compileExpression("map_concat(c0, c1)", asRowType(data->type()));
+
+    suspender.dismiss();
+
+    unsigned count{0};
+    for (unsigned i = 0; i < times * FLAGS_num_batches; ++i) {
+      count += evaluate(exprSet, data)->size();
+    }
+    return count;
+  }
+};
+
+// Map size 100.
+BENCHMARK_MULTI(noOverlap_100, n) {
+  MapConcatBenchmark benchmark;
+  return benchmark.run(0.0, 100, n, false);
+}
+
+BENCHMARK_MULTI(halfOverlap_100, n) {
+  MapConcatBenchmark benchmark;
+  return benchmark.run(0.5, 100, n, false);
+}
+
+BENCHMARK_MULTI(fullOverlap_100, n) {
+  MapConcatBenchmark benchmark;
+  return benchmark.run(1.0, 100, n, false);
+}
+
+// Map size 1000.
+BENCHMARK_MULTI(noOverlap_1000, n) {
+  MapConcatBenchmark benchmark;
+  return benchmark.run(0.0, 1'000, n, false);
+}
+
+BENCHMARK_MULTI(halfOverlap_1000, n) {
+  MapConcatBenchmark benchmark;
+  return benchmark.run(0.5, 1'000, n, false);
+}
+
+BENCHMARK_MULTI(fullOverlap_1000, n) {
+  MapConcatBenchmark benchmark;
+  return benchmark.run(1.0, 1'000, n, false);
+}
+
+BENCHMARK_DRAW_LINE();
+
+// Sorted keys, map size 100.
+BENCHMARK_MULTI(sorted_noOverlap_100, n) {
+  MapConcatBenchmark benchmark;
+  return benchmark.run(0.0, 100, n, true);
+}
+
+BENCHMARK_MULTI(sorted_halfOverlap_100, n) {
+  MapConcatBenchmark benchmark;
+  return benchmark.run(0.5, 100, n, true);
+}
+
+BENCHMARK_MULTI(sorted_fullOverlap_100, n) {
+  MapConcatBenchmark benchmark;
+  return benchmark.run(1.0, 100, n, true);
+}
+
+// Sorted keys, map size 1000.
+BENCHMARK_MULTI(sorted_noOverlap_1000, n) {
+  MapConcatBenchmark benchmark;
+  return benchmark.run(0.0, 1'000, n, true);
+}
+
+BENCHMARK_MULTI(sorted_halfOverlap_1000, n) {
+  MapConcatBenchmark benchmark;
+  return benchmark.run(0.5, 1'000, n, true);
+}
+
+BENCHMARK_MULTI(sorted_fullOverlap_1000, n) {
+  MapConcatBenchmark benchmark;
+  return benchmark.run(1.0, 1'000, n, true);
+}
+
+BENCHMARK_DRAW_LINE();
+
+// Dictionary-encoded maps, map size 100.
+BENCHMARK_MULTI(dict_noOverlap_100, n) {
+  MapConcatBenchmark benchmark;
+  return benchmark.runDict(0.0, 100, n, false);
+}
+
+BENCHMARK_MULTI(dict_halfOverlap_100, n) {
+  MapConcatBenchmark benchmark;
+  return benchmark.runDict(0.5, 100, n, false);
+}
+
+BENCHMARK_MULTI(dict_fullOverlap_100, n) {
+  MapConcatBenchmark benchmark;
+  return benchmark.runDict(1.0, 100, n, false);
+}
+
+BENCHMARK_DRAW_LINE();
+
+// VARCHAR keys, map size 100.
+BENCHMARK_MULTI(varchar_noOverlap_100, n) {
+  MapConcatBenchmark benchmark;
+  return benchmark.runVarchar(0.0, 100, n, false);
+}
+
+BENCHMARK_MULTI(varchar_halfOverlap_100, n) {
+  MapConcatBenchmark benchmark;
+  return benchmark.runVarchar(0.5, 100, n, false);
+}
+
+BENCHMARK_MULTI(varchar_fullOverlap_100, n) {
+  MapConcatBenchmark benchmark;
+  return benchmark.runVarchar(1.0, 100, n, false);
+}
+
+} // namespace
+
+int main(int argc, char** argv) {
+  folly::Init init{&argc, &argv};
+  facebook::velox::memory::MemoryManager::initialize(
+      facebook::velox::memory::MemoryManager::Options{});
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/functions/prestosql/benchmarks/MapExceptBenchmark.cpp b/velox/functions/prestosql/benchmarks/MapExceptBenchmark.cpp
new file mode 100644
index 00000000000..874814cdda1
--- /dev/null
+++ b/velox/functions/prestosql/benchmarks/MapExceptBenchmark.cpp
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+#include "velox/common/memory/Memory.h"
+#include "velox/functions/lib/benchmarks/FunctionBenchmarkBase.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+
+namespace {
+
+/// Benchmarks for map_except(map, array) covering:
+///   - Constant vs non-constant exclusion keys
+///   - Small vs large maps (early termination benefit)
+///   - Empty vs small vs large exclusion sets
+///   - Bigint vs varchar key types
+class MapExceptBenchmark : public functions::test::FunctionBenchmarkBase {
+ public:
+  MapExceptBenchmark() : FunctionBenchmarkBase() {
+    functions::prestosql::registerAllScalarFunctions();
+  }
+
+  /// Creates a RowVector with columns:
+  ///   c0: MAP<BIGINT, BIGINT> with mapSize entries per row (keys 0..mapSize-1)
+  ///   c1: ARRAY<BIGINT> with excludeSize elements per row (keys
+  ///   0..excludeSize-1)
+  RowVectorPtr makeBigintData(int mapSize, int excludeSize) {
+    const vector_size_t numRows = 1'000;
+    auto mapVector = vectorMaker_.mapVector<int64_t, int64_t>(
+        numRows,
+        [mapSize](auto) { return mapSize; },
+        [mapSize](auto idx) { return idx % mapSize; },
+        [](auto idx) { return idx * 10; });
+
+    auto excludeArray = vectorMaker_.arrayVector<int64_t>(
+        numRows,
+        [excludeSize](auto) { return excludeSize; },
+        [excludeSize](auto idx) {
+          return excludeSize > 0 ? idx % excludeSize : 0;
+        });
+
+    return vectorMaker_.rowVector({mapVector, excludeArray});
+  }
+
+  /// Creates a RowVector with columns:
+  ///   c0: MAP<VARCHAR, BIGINT> with mapSize entries per row
+  ///   c1: ARRAY<VARCHAR> with excludeSize elements per row
+  RowVectorPtr makeVarcharData(int mapSize, int excludeSize) {
+    const vector_size_t numRows = 1'000;
+    auto mapVector = vectorMaker_.mapVector<std::string, int64_t>(
+        numRows,
+        [mapSize](auto) { return mapSize; },
+        [mapSize](auto idx) { return std::to_string(idx % mapSize); },
+        [](auto idx) { return idx * 10; });
+
+    auto excludeArray = vectorMaker_.arrayVector<std::string>(
+        numRows,
+        [excludeSize](auto) { return excludeSize; },
+        [excludeSize](auto idx) {
+          return std::to_string(excludeSize > 0 ? idx % excludeSize : 0);
+        });
+
+    return vectorMaker_.rowVector({mapVector, excludeArray});
+  }
+
+  unsigned int run(
+      const RowVectorPtr& data,
+      const std::string& expression,
+      unsigned int times) {
+    folly::BenchmarkSuspender suspender;
+    auto exprSet = compileExpression(expression, asRowType(data->type()));
+    suspender.dismiss();
+
+    unsigned int cnt = 0;
+    for (unsigned int i = 0; i < times * 100; i++) {
+      cnt += evaluate(exprSet, data)->size();
+    }
+    return cnt;
+  }
+};
+
+// ============================================================================
+// Bigint keys, map size 100
+// Exercises: constant key optimization, out.reserve(), toExclude counter.
+// ============================================================================
+
+BENCHMARK_MULTI(bigint_map100_constExclude3, n) {
+  MapExceptBenchmark benchmark;
+  auto data = benchmark.makeBigintData(100, 3);
+  return benchmark.run(data, "map_except(c0, array_constructor(0, 1, 2))", n);
+}
+
+BENCHMARK_MULTI(bigint_map100_nonConstExclude3, n) {
+  MapExceptBenchmark benchmark;
+  auto data = benchmark.makeBigintData(100, 3);
+  return benchmark.run(data, "map_except(c0, c1)", n);
+}
+
+BENCHMARK_MULTI(bigint_map100_excludeEmpty, n) {
+  MapExceptBenchmark benchmark;
+  auto data = benchmark.makeBigintData(100, 0);
+  return benchmark.run(
+      data, "map_except(c0, array_constructor()::bigint[])", n);
+}
+
+BENCHMARK_MULTI(bigint_map100_nonConstExclude50, n) {
+  MapExceptBenchmark benchmark;
+  auto data = benchmark.makeBigintData(100, 50);
+  return benchmark.run(data, "map_except(c0, c1)", n);
+}
+
+// ============================================================================
+// Bigint keys, map size 1000
+// Exercises: early termination — after 3 exclusion keys are found, the
+// remaining ~997 entries skip the hash lookup entirely.
+// ============================================================================
+
+BENCHMARK_MULTI(bigint_map1000_constExclude3, n) {
+  MapExceptBenchmark benchmark;
+  auto data = benchmark.makeBigintData(1'000, 3);
+  return benchmark.run(data, "map_except(c0, array_constructor(0, 1, 2))", n);
+}
+
+BENCHMARK_MULTI(bigint_map1000_nonConstExclude3, n) {
+  MapExceptBenchmark benchmark;
+  auto data = benchmark.makeBigintData(1'000, 3);
+  return benchmark.run(data, "map_except(c0, c1)", n);
+}
+
+BENCHMARK_MULTI(bigint_map1000_constExclude10, n) {
+  MapExceptBenchmark benchmark;
+  auto data = benchmark.makeBigintData(1'000, 10);
+  return benchmark.run(
+      data,
+      "map_except(c0, array_constructor(0, 1, 2, 3, 4, 5, 6, 7, 8, 9))",
+      n);
+}
+
+// ============================================================================
+// Varchar keys, map size 100
+// Exercises: varchar fast path with inline string optimization, constant key
+// caching with searchKeyStrings_ lifetime management.
+// ============================================================================
+
+BENCHMARK_MULTI(varchar_map100_constExclude3, n) {
+  MapExceptBenchmark benchmark;
+  auto data = benchmark.makeVarcharData(100, 3);
+  return benchmark.run(
+      data, "map_except(c0, array_constructor('0', '1', '2'))", n);
+}
+
+BENCHMARK_MULTI(varchar_map100_nonConstExclude3, n) {
+  MapExceptBenchmark benchmark;
+  auto data = benchmark.makeVarcharData(100, 3);
+  return benchmark.run(data, "map_except(c0, c1)", n);
+}
+
+} // namespace
+
+int main(int argc, char** argv) {
+  folly::Init init{&argc, &argv};
+  memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/functions/prestosql/benchmarks/MapIntersectBenchmark.cpp b/velox/functions/prestosql/benchmarks/MapIntersectBenchmark.cpp
new file mode 100644
index 00000000000..c7b1a1ee2d4
--- /dev/null
+++ b/velox/functions/prestosql/benchmarks/MapIntersectBenchmark.cpp
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include "velox/benchmarks/ExpressionBenchmarkBuilder.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+using namespace facebook::velox;
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+  memory::MemoryManager::initialize({});
+
+  ExpressionBenchmarkBuilder benchmarkBuilder;
+  functions::prestosql::registerAllScalarFunctions();
+
+  auto* pool = benchmarkBuilder.pool();
+  auto& vm = benchmarkBuilder.vectorMaker();
+
+  // ---------------------------------------------------------------------------
+  // Scenario 1: Large map (100 entries), small key array (3 keys).
+  // Tests the early-exit (toFind) optimization — stops after finding 3 matches
+  // instead of scanning all 100 entries.
+  // ---------------------------------------------------------------------------
+  {
+    VectorFuzzer::Options options;
+    options.vectorSize = 1'000;
+    options.containerLength = 100;
+    options.containerVariableLength = false;
+    options.complexElementsMaxSize = 1'000'000;
+    VectorFuzzer fuzzer(options, pool);
+
+    auto mapVector = fuzzer.fuzz(MAP(INTEGER(), INTEGER()));
+
+    // Small constant key array: 3 keys.
+    auto keysVector = vm.arrayVector<int32_t>(
+        std::vector<std::vector<int32_t>>(1'000, {1, 50, 99}));
+
+    benchmarkBuilder
+        .addBenchmarkSet(
+            "large_map_small_keys_int", vm.rowVector({mapVector, keysVector}))
+        .addExpression("map_intersect", "map_intersect(c0, c1)")
+        .addExpression("map_subset", "map_subset(c0, c1)");
+  }
+
+  // ---------------------------------------------------------------------------
+  // Scenario 2: Small map (5 entries), large key array (50 keys).
+  // Tests the hash set reserve() optimization — pre-allocates for 50 keys.
+  // ---------------------------------------------------------------------------
+  {
+    VectorFuzzer::Options options;
+    options.vectorSize = 1'000;
+    options.containerLength = 5;
+    options.containerVariableLength = false;
+    options.complexElementsMaxSize = 1'000'000;
+    VectorFuzzer fuzzer(options, pool);
+
+    auto mapVector = fuzzer.fuzz(MAP(INTEGER(), INTEGER()));
+
+    std::vector<int32_t> manyKeys(50);
+    std::iota(manyKeys.begin(), manyKeys.end(), 0);
+    auto keysVector = vm.arrayVector<int32_t>(
+        std::vector<std::vector<int32_t>>(1'000, manyKeys));
+
+    benchmarkBuilder
+        .addBenchmarkSet(
+            "small_map_large_keys_int", vm.rowVector({mapVector, keysVector}))
+        .addExpression("map_intersect", "map_intersect(c0, c1)")
+        .addExpression("map_subset", "map_subset(c0, c1)");
+  }
+
+  // ---------------------------------------------------------------------------
+  // Scenario 3: Medium map (20 entries), medium key array (10 keys).
+  // Balanced workload — tests combined effect of all optimizations.
+  // ---------------------------------------------------------------------------
+  {
+    VectorFuzzer::Options options;
+    options.vectorSize = 1'000;
+    options.containerLength = 20;
+    options.containerVariableLength = false;
+    options.complexElementsMaxSize = 1'000'000;
+    VectorFuzzer fuzzer(options, pool);
+
+    auto mapVector = fuzzer.fuzz(MAP(INTEGER(), INTEGER()));
+
+    std::vector<int32_t> mediumKeys(10);
+    std::iota(mediumKeys.begin(), mediumKeys.end(), 0);
+    auto keysVector = vm.arrayVector<int32_t>(
+        std::vector<std::vector<int32_t>>(1'000, mediumKeys));
+
+    benchmarkBuilder
+        .addBenchmarkSet(
+            "medium_map_medium_keys_int", vm.rowVector({mapVector, keysVector}))
+        .addExpression("map_intersect", "map_intersect(c0, c1)")
+        .addExpression("map_subset", "map_subset(c0, c1)");
+  }
+
+  // ---------------------------------------------------------------------------
+  // Scenario 4: VARCHAR keys — large map, small key array.
+  // Tests the varchar-specific optimizations (inline string, F14FastSet).
+  // ---------------------------------------------------------------------------
+  {
+    VectorFuzzer::Options options;
+    options.vectorSize = 1'000;
+    options.containerLength = 50;
+    options.containerVariableLength = false;
+    options.stringLength = 10;
+    options.complexElementsMaxSize = 1'000'000;
+    VectorFuzzer fuzzer(options, pool);
+
+    auto mapVector = fuzzer.fuzz(MAP(VARCHAR(), INTEGER()));
+
+    auto keysVector =
+        vm.arrayVector<StringView>(std::vector<std::vector<StringView>>(
+            1'000, {StringView("abc"), StringView("xyz"), StringView("foo")}));
+
+    benchmarkBuilder
+        .addBenchmarkSet(
+            "large_map_small_keys_varchar",
+            vm.rowVector({mapVector, keysVector}))
+        .addExpression("map_intersect", "map_intersect(c0, c1)")
+        .addExpression("map_subset", "map_subset(c0, c1)");
+  }
+
+  // ---------------------------------------------------------------------------
+  // Scenario 5: Empty key array — tests the early-exit guard optimization.
+  // ---------------------------------------------------------------------------
+  {
+    VectorFuzzer::Options options;
+    options.vectorSize = 1'000;
+    options.containerLength = 50;
+    options.containerVariableLength = false;
+    options.complexElementsMaxSize = 1'000'000;
+    VectorFuzzer fuzzer(options, pool);
+
+    auto mapVector = fuzzer.fuzz(MAP(INTEGER(), INTEGER()));
+
+    auto keysVector = vm.arrayVector<int32_t>(
+        std::vector<std::vector<int32_t>>(1'000, std::vector<int32_t>{}));
+
+    benchmarkBuilder
+        .addBenchmarkSet(
+            "empty_keys_int", vm.rowVector({mapVector, keysVector}))
+        .addExpression("map_intersect", "map_intersect(c0, c1)")
+        .addExpression("map_subset", "map_subset(c0, c1)");
+  }
+
+  // ---------------------------------------------------------------------------
+  // Scenario 6: Constant keys (compile-time known).
+  // Tests the constant-key caching optimization in initialize().
+  // ---------------------------------------------------------------------------
+  {
+    VectorFuzzer::Options options;
+    options.vectorSize = 1'000;
+    options.containerLength = 50;
+    options.containerVariableLength = false;
+    options.complexElementsMaxSize = 1'000'000;
+    VectorFuzzer fuzzer(options, pool);
+
+    auto mapVector = fuzzer.fuzz(MAP(INTEGER(), INTEGER()));
+
+    benchmarkBuilder
+        .addBenchmarkSet("constant_keys_int", vm.rowVector({mapVector}))
+        .addExpression(
+            "map_intersect",
+            "map_intersect(c0, array_constructor(cast(1 as integer), cast(5 as integer), cast(10 as integer), cast(25 as integer), cast(42 as integer)))")
+        .addExpression(
+            "map_subset",
+            "map_subset(c0, array_constructor(cast(1 as integer), cast(5 as integer), cast(10 as integer), cast(25 as integer), cast(42 as integer)))");
+  }
+
+  benchmarkBuilder.registerBenchmarks();
+  benchmarkBuilder.testBenchmarks();
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/functions/prestosql/benchmarks/MapWriterBenchmarks.cpp b/velox/functions/prestosql/benchmarks/MapWriterBenchmarks.cpp
index aa705b198a2..5f445696926 100644
--- a/velox/functions/prestosql/benchmarks/MapWriterBenchmarks.cpp
+++ b/velox/functions/prestosql/benchmarks/MapWriterBenchmarks.cpp
@@ -220,7 +220,7 @@ class MapWriterBenchmark : public functions::test::FunctionBenchmarkBase {
       auto other =
           compileExpression(fmt::format("{}(c0)", name), input->type());
       if (!hasSameResults(exprSetRef, other, input)) {
-        VELOX_UNREACHABLE(fmt::format("testing failed at function {}", name));
+        VELOX_UNREACHABLE("Testing failed at function: {}", name);
       }
     }
   }
diff --git a/velox/functions/prestosql/benchmarks/NestedArrayWriterBenchmark.cpp b/velox/functions/prestosql/benchmarks/NestedArrayWriterBenchmark.cpp
index e2f4584a96e..6f990bc5607 100644
--- a/velox/functions/prestosql/benchmarks/NestedArrayWriterBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/NestedArrayWriterBenchmark.cpp
@@ -174,7 +174,7 @@ class NestedArrayWriterBenchmark
       auto other =
           compileExpression(fmt::format("{}(c0)", name), input->type());
       if (!hasSameResults(exprSetRef, other, input)) {
-        VELOX_UNREACHABLE(fmt::format("testing failed at function {}", name));
+        VELOX_UNREACHABLE("Testing failed at function: {}", name);
       }
     }
   }
diff --git a/velox/functions/prestosql/benchmarks/URLBenchmark.cpp b/velox/functions/prestosql/benchmarks/URLBenchmark.cpp
index 0cd63aedf06..4d0d6535dcb 100644
--- a/velox/functions/prestosql/benchmarks/URLBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/URLBenchmark.cpp
@@ -32,7 +32,7 @@ template <typename Fn, typename TOutString, typename TInputString>
 FOLLY_ALWAYS_INLINE bool
 runURIFn(Fn func, TOutString& result, TInputString& url) {
   try {
-    auto parsedUrl = folly::Uri(url);
+    auto parsedUrl = folly::Uri(std::string_view(url));
     auto datum = (parsedUrl.*func)();
     result.resize(datum.size());
     if (datum.size() != 0) {
@@ -123,7 +123,7 @@ struct FollyUrlExtractPortFunction {
 
   FOLLY_ALWAYS_INLINE bool call(int64_t& result, const arg_type<Varchar>& url) {
     try {
-      auto parsedUrl = folly::Uri(url);
+      auto parsedUrl = folly::Uri(std::string_view(url));
       result = parsedUrl.port();
     } catch (const folly::ConversionError&) {
       return false;
@@ -145,7 +145,7 @@ struct FollyUrlExtractParameterFunction {
       const arg_type<Varchar>& url,
       const arg_type<Varchar>& param) {
     try {
-      auto parsedUrl = folly::Uri(url);
+      auto parsedUrl = folly::Uri(std::string_view(url));
       auto params = parsedUrl.getQueryParams();
 
       for (const auto& pair : params) {
diff --git a/velox/functions/prestosql/coercion/CMakeLists.txt b/velox/functions/prestosql/coercion/CMakeLists.txt
new file mode 100644
index 00000000000..77ad88d4745
--- /dev/null
+++ b/velox/functions/prestosql/coercion/CMakeLists.txt
@@ -0,0 +1,21 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+velox_add_library(velox_presto_coercions PrestoCoercions.cpp HEADERS PrestoCoercions.h)
+
+velox_link_libraries(velox_presto_coercions velox_type)
+
+if(${VELOX_BUILD_TESTING})
+  add_subdirectory(tests)
+endif()
diff --git a/velox/functions/prestosql/coercion/PrestoCoercions.cpp b/velox/functions/prestosql/coercion/PrestoCoercions.cpp
new file mode 100644
index 00000000000..028c3aee27d
--- /dev/null
+++ b/velox/functions/prestosql/coercion/PrestoCoercions.cpp
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/prestosql/coercion/PrestoCoercions.h"
+
+namespace facebook::velox::functions::prestosql {
+
+namespace {
+
+// Complete Presto coercion rule set. Self-contained; intentionally does not
+// reference TypeCoercer::defaults() so changes to Velox defaults cannot
+// silently shift Presto semantics. Lower cost = preferred during overload
+// resolution.
+//
+// TODO: transcribe the full Presto Java `TypeCoercion` table. Today's set
+// matches Velox's defaults plus BIGINT -> REAL (Presto allows this lossy
+// conversion; Velox defaults do not).
+std::vector<CoercionEntry> prestoRules() {
+  std::vector<CoercionEntry> rules;
+
+  auto add = [&](const TypePtr& from, const std::vector<TypePtr>& to) {
+    int32_t cost = 0;
+    for (const auto& toType : to) {
+      rules.push_back({from, toType, ++cost});
+    }
+  };
+
+  add(TINYINT(),
+      {SMALLINT(), INTEGER(), BIGINT(), DECIMAL(3, 0), REAL(), DOUBLE()});
+  add(SMALLINT(), {INTEGER(), BIGINT(), DECIMAL(5, 0), REAL(), DOUBLE()});
+  add(INTEGER(), {BIGINT(), DECIMAL(10, 0), REAL(), DOUBLE()});
+  // Presto-specific: BIGINT -> REAL is added between DECIMAL and DOUBLE,
+  // mirroring the INTEGER row's ordering. This makes divide(real, bigint)
+  // resolve to divide(real, real) via BIGINT -> REAL (cost 2) instead of
+  // divide(double, double) via REAL -> DOUBLE + BIGINT -> DOUBLE (cost 1 +
+  // 3 = 4), matching Presto's overload resolution.
+  add(BIGINT(), {DECIMAL(19, 0), REAL(), DOUBLE()});
+  add(REAL(), {DOUBLE()});
+  add(DECIMAL(1, 0), {REAL(), DOUBLE()});
+  add(DATE(), {TIMESTAMP()});
+  add(UNKNOWN(),
+      {TINYINT(),
+       BOOLEAN(),
+       SMALLINT(),
+       INTEGER(),
+       BIGINT(),
+       REAL(),
+       DOUBLE(),
+       VARCHAR(),
+       VARBINARY()});
+
+  return rules;
+}
+
+} // namespace
+
+const TypeCoercer& typeCoercer() {
+  static const TypeCoercer instance{prestoRules()};
+  return instance;
+}
+
+} // namespace facebook::velox::functions::prestosql
diff --git a/velox/functions/prestosql/coercion/PrestoCoercions.h b/velox/functions/prestosql/coercion/PrestoCoercions.h
new file mode 100644
index 00000000000..2420bd88b29
--- /dev/null
+++ b/velox/functions/prestosql/coercion/PrestoCoercions.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/type/TypeCoercer.h"
+
+namespace facebook::velox::functions::prestosql {
+
+/// Coercion rule set for the Presto SQL dialect. Returned coercer is a
+/// singleton.
+const TypeCoercer& typeCoercer();
+
+} // namespace facebook::velox::functions::prestosql
diff --git a/velox/type/parser/tests/CMakeLists.txt b/velox/functions/prestosql/coercion/tests/CMakeLists.txt
similarity index 74%
rename from velox/type/parser/tests/CMakeLists.txt
rename to velox/functions/prestosql/coercion/tests/CMakeLists.txt
index 510caebe25d..64f010ac3b8 100644
--- a/velox/type/parser/tests/CMakeLists.txt
+++ b/velox/functions/prestosql/coercion/tests/CMakeLists.txt
@@ -12,16 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(velox_type_parser_test TypeParserTest.cpp)
+add_executable(velox_presto_coercions_test PrestoCoercionsTest.cpp)
 
-add_test(NAME velox_type_parser_test COMMAND velox_type_parser_test)
+add_test(velox_presto_coercions_test velox_presto_coercions_test)
 
 target_link_libraries(
-  velox_type_parser_test
-  velox_type_parser
-  velox_type
-  velox_presto_types
+  velox_presto_coercions_test
+  velox_presto_coercions
   GTest::gtest
   GTest::gtest_main
-  GTest::gmock
 )
diff --git a/velox/functions/prestosql/coercion/tests/PrestoCoercionsTest.cpp b/velox/functions/prestosql/coercion/tests/PrestoCoercionsTest.cpp
new file mode 100644
index 00000000000..2ae01a450fc
--- /dev/null
+++ b/velox/functions/prestosql/coercion/tests/PrestoCoercionsTest.cpp
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/prestosql/coercion/PrestoCoercions.h"
+
+#include <gtest/gtest.h>
+
+namespace facebook::velox::functions::prestosql {
+namespace {
+
+// Verifies the BIGINT row of the Presto coercion table. The relative
+// ordering DECIMAL < REAL < DOUBLE is load-bearing for overload resolution:
+// for `divide(real, bigint)`, BIGINT -> REAL (cost 2) must beat
+// REAL -> DOUBLE + BIGINT -> DOUBLE (cost 1 + 3 = 4) so the resolver picks
+// divide(real, real) and the result type is REAL -- matching Presto's
+// behavior.
+TEST(PrestoCoercionsTest, bigintRow) {
+  const auto& tc = typeCoercer();
+
+  auto toDecimal = tc.coerceTypeBase(BIGINT(), DECIMAL(19, 0));
+  auto toReal = tc.coerceTypeBase(BIGINT(), REAL());
+  auto toDouble = tc.coerceTypeBase(BIGINT(), DOUBLE());
+
+  ASSERT_TRUE(toDecimal.has_value());
+  ASSERT_TRUE(toReal.has_value());
+  ASSERT_TRUE(toDouble.has_value());
+
+  EXPECT_LT(toDecimal->cost, toReal->cost);
+  EXPECT_LT(toReal->cost, toDouble->cost);
+}
+
+// Sanity check on a representative subset of the Presto rule set.
+TEST(PrestoCoercionsTest, sanity) {
+  const auto& tc = typeCoercer();
+
+  EXPECT_TRUE(tc.coercible(INTEGER(), BIGINT()).has_value());
+  EXPECT_TRUE(tc.coercible(BIGINT(), DOUBLE()).has_value());
+  EXPECT_TRUE(tc.coercible(DATE(), TIMESTAMP()).has_value());
+  EXPECT_TRUE(tc.coercible(REAL(), DOUBLE()).has_value());
+  EXPECT_TRUE(tc.coercible(UNKNOWN(), VARCHAR()).has_value());
+}
+
+} // namespace
+} // namespace facebook::velox::functions::prestosql
diff --git a/velox/functions/prestosql/coverage/data/all_scalar_functions.txt b/velox/functions/prestosql/coverage/data/all_scalar_functions.txt
index 7faa98d22d9..15f5bb4f700 100644
--- a/velox/functions/prestosql/coverage/data/all_scalar_functions.txt
+++ b/velox/functions/prestosql/coverage/data/all_scalar_functions.txt
@@ -44,6 +44,7 @@ bing_tile_zoom_level
 bing_tiles_around
 binomial_cdf
 bit_count
+bit_length
 bitwise_and
 bitwise_arithmetic_shift_right
 bitwise_left_shift
@@ -86,6 +87,7 @@ day_of_month
 day_of_week
 day_of_year
 degrees
+dot_product
 dow
 doy
 e
@@ -130,6 +132,8 @@ geometry_nearest_points
 geometry_to_bing_tiles
 geometry_to_dissolved_bing_tiles
 geometry_union
+google_polyline_decode
+google_polyline_encode
 great_circle_distance
 greatest
 hamming_distance
@@ -173,6 +177,7 @@ json_format
 json_parse
 json_size
 key_sampling_percent
+l2_squared
 laplace_cdf
 last_day_of_month
 least
@@ -185,6 +190,7 @@ localtime
 localtimestamp
 log10
 log2
+longest_common_prefix
 lower
 lpad
 ltrim
@@ -254,6 +260,13 @@ rgb
 round
 rpad
 rtrim
+s2_cell_area_sq_km
+s2_cell_contains
+s2_cell_from_token
+s2_cell_level
+s2_cell_parent
+s2_cell_to_token
+s2_cells
 scale_qdigest
 second
 secure_rand
diff --git a/velox/functions/prestosql/fuzzer/AggregationFuzzerTest.cpp b/velox/functions/prestosql/fuzzer/AggregationFuzzerTest.cpp
index d8abf34fef2..ecf3cb4b6e2 100644
--- a/velox/functions/prestosql/fuzzer/AggregationFuzzerTest.cpp
+++ b/velox/functions/prestosql/fuzzer/AggregationFuzzerTest.cpp
@@ -30,6 +30,7 @@
 #include "velox/functions/prestosql/fuzzer/ApproxPercentileResultVerifier.h"
 #include "velox/functions/prestosql/fuzzer/ArbitraryResultVerifier.h"
 #include "velox/functions/prestosql/fuzzer/AverageResultVerifier.h"
+#include "velox/functions/prestosql/fuzzer/KHyperLogLogResultVerifier.h"
 #include "velox/functions/prestosql/fuzzer/MapUnionSumInputGenerator.h"
 #include "velox/functions/prestosql/fuzzer/MinMaxByResultVerifier.h"
 #include "velox/functions/prestosql/fuzzer/MinMaxInputGenerator.h"
@@ -44,6 +45,7 @@
 #include "velox/functions/prestosql/fuzzer/NumericHistogramInputGenerator.h"
 #include "velox/functions/prestosql/fuzzer/QDigestAggInputGenerator.h"
 #include "velox/functions/prestosql/fuzzer/QDigestAggResultVerifier.h"
+#include "velox/functions/prestosql/fuzzer/SetDigestResultVerifier.h"
 #include "velox/functions/prestosql/fuzzer/TDigestAggregateInputGenerator.h"
 #include "velox/functions/prestosql/fuzzer/TDigestAggregateResultVerifier.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
@@ -154,10 +156,25 @@ int main(int argc, char** argv) {
       "noisy_approx_set_sfm",
       "noisy_approx_distinct_sfm",
       "noisy_approx_set_sfm_from_index_and_zeros",
+      "reservoir_sample",
       // https://github.com/facebookincubator/velox/issues/13547
       "merge",
       // https://github.com/facebookincubator/velox/issues/14423
       "numeric_histogram",
+      "khyperloglog_agg", // TODO: Remove from skip list once the KHLL result
+      // verifier is added.
+      // The list below also contains their companion functions.
+      "convex_hull_agg",
+      "geometry_union_agg",
+      "geometry_union_agg_partial",
+      "geometry_union_agg_merge",
+      "geometry_union_agg_extract",
+      "geometry_union_agg_merge_extract",
+      "convex_hull_agg_partial",
+      "convex_hull_agg_merge",
+      "convex_hull_agg_extract",
+      "convex_hull_agg_merge_extract",
+
   };
 
   static const std::unordered_set<std::string> functionsRequireSortedInput = {
@@ -169,12 +186,14 @@ int main(int argc, char** argv) {
   using facebook::velox::exec::test::ApproxPercentileResultVerifier;
   using facebook::velox::exec::test::ArbitraryResultVerifier;
   using facebook::velox::exec::test::AverageResultVerifier;
+  using facebook::velox::exec::test::KHyperLogLogResultVerifier;
   using facebook::velox::exec::test::MinMaxByResultVerifier;
   using facebook::velox::exec::test::NoisyAvgResultVerifier;
   using facebook::velox::exec::test::NoisyCountIfResultVerifier;
   using facebook::velox::exec::test::NoisyCountResultVerifier;
   using facebook::velox::exec::test::NoisySumResultVerifier;
   using facebook::velox::exec::test::QDigestAggResultVerifier;
+  using facebook::velox::exec::test::SetDigestResultVerifier;
   using facebook::velox::exec::test::setupReferenceQueryRunner;
   using facebook::velox::exec::test::TDigestAggregateResultVerifier;
   using facebook::velox::exec::test::TransformResultVerifier;
@@ -206,6 +225,7 @@ int main(int argc, char** argv) {
            std::make_shared<ApproxPercentileResultVerifier>()},
           {"tdigest_agg", std::make_shared<TDigestAggregateResultVerifier>()},
           {"qdigest_agg", std::make_shared<QDigestAggResultVerifier>()},
+          {"khyperloglog_agg", std::make_shared<KHyperLogLogResultVerifier>()},
           {"arbitrary", std::make_shared<ArbitraryResultVerifier>()},
           {"any_value", nullptr},
           {"array_agg", makeArrayVerifier()},
@@ -233,6 +253,20 @@ int main(int argc, char** argv) {
           {"noisy_count_gaussian",
            std::make_shared<NoisyCountResultVerifier>()},
           {"noisy_sum_gaussian", std::make_shared<NoisySumResultVerifier>()},
+          {"convex_hull_agg", nullptr},
+          {"geometry_union_agg", nullptr},
+          {"geometry_union_agg_partial", nullptr},
+          {"geometry_union_agg_merge", nullptr},
+          {"geometry_union_agg_extract", nullptr},
+          {"geometry_union_agg_merge_extract", nullptr},
+          {"convex_hull_agg_partial", nullptr},
+          {"convex_hull_agg_merge", nullptr},
+          {"convex_hull_agg_extract", nullptr},
+          {"convex_hull_agg_merge_extract", nullptr},
+          {"make_set_digest", std::make_shared<SetDigestResultVerifier>()},
+          {"merge_set_digest", std::make_shared<SetDigestResultVerifier>()},
+          // Velox-only function, not available in Presto.
+          {"vector_sum", nullptr},
       };
 
   using Runner = facebook::velox::exec::test::AggregationFuzzerRunner;
diff --git a/velox/functions/prestosql/fuzzer/ApproxDistinctResultVerifier.h b/velox/functions/prestosql/fuzzer/ApproxDistinctResultVerifier.h
index 3d0e2eb43e6..49f2486a274 100644
--- a/velox/functions/prestosql/fuzzer/ApproxDistinctResultVerifier.h
+++ b/velox/functions/prestosql/fuzzer/ApproxDistinctResultVerifier.h
@@ -255,7 +255,7 @@ class ApproxDistinctResultVerifier : public ResultVerifier {
 
     // We expect large deviations (>2 stddev) in < 5% of values.
     if (numGroups >= 50) {
-      return largeGaps.size() <= 0.05 * numGroups;
+      return largeGaps.size() <= std::ceil(0.05 * numGroups);
     }
 
     return numGroups == 1 || largeGaps.empty();
diff --git a/velox/functions/prestosql/fuzzer/ApproxPercentileInputGenerator.h b/velox/functions/prestosql/fuzzer/ApproxPercentileInputGenerator.h
index 74fdc9048ac..7d3fe9736bc 100644
--- a/velox/functions/prestosql/fuzzer/ApproxPercentileInputGenerator.h
+++ b/velox/functions/prestosql/fuzzer/ApproxPercentileInputGenerator.h
@@ -56,8 +56,9 @@ class ApproxPercentileInputGenerator : public InputGenerator {
         percentile_ = pickPercentile(fuzzer, rng);
       }
 
-      inputs.push_back(BaseVector::createConstant(
-          DOUBLE(), percentile_.value(), size, pool));
+      inputs.push_back(
+          BaseVector::createConstant(
+              DOUBLE(), percentile_.value(), size, pool));
     } else {
       VELOX_CHECK(percentileType->isArray());
       VELOX_CHECK(percentileType->childAt(0)->isDouble());
diff --git a/velox/functions/prestosql/fuzzer/ApproxPercentileResultVerifier.h b/velox/functions/prestosql/fuzzer/ApproxPercentileResultVerifier.h
index 71b2b44d7d8..09b2b344043 100644
--- a/velox/functions/prestosql/fuzzer/ApproxPercentileResultVerifier.h
+++ b/velox/functions/prestosql/fuzzer/ApproxPercentileResultVerifier.h
@@ -250,9 +250,10 @@ class ApproxPercentileResultVerifier : public ResultVerifier {
 
     std::vector<std::string> projections = groupingKeys_;
     projections.push_back(fmt::format("{} as x", valueField));
-    projections.push_back(fmt::format(
-        "{} as w",
-        weightField.has_value() ? weightField.value() : "1::bigint"));
+    projections.push_back(
+        fmt::format(
+            "{} as w",
+            weightField.has_value() ? weightField.value() : "1::bigint"));
 
     PlanBuilder planBuilder;
     planBuilder.values(input).projectExpressions(inputProjections);
diff --git a/velox/functions/prestosql/fuzzer/ArbitraryResultVerifier.h b/velox/functions/prestosql/fuzzer/ArbitraryResultVerifier.h
index 337be08243b..946d8ff573e 100644
--- a/velox/functions/prestosql/fuzzer/ArbitraryResultVerifier.h
+++ b/velox/functions/prestosql/fuzzer/ArbitraryResultVerifier.h
@@ -51,8 +51,9 @@ class ArbitraryResultVerifier : public ResultVerifier {
     std::vector<std::string> projectColumns = groupingKeys;
     // Add a column of aggregateTypeSql_ of all nulls so that we can union the
     // oracle result with the actual result.
-    projectColumns.push_back(fmt::format(
-        "cast(NULL as {}) as {}", aggregateTypeSql_, aggregateName));
+    projectColumns.push_back(
+        fmt::format(
+            "cast(NULL as {}) as {}", aggregateTypeSql_, aggregateName));
     projectColumns.push_back("expected");
 
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
diff --git a/velox/functions/prestosql/fuzzer/CMakeLists.txt b/velox/functions/prestosql/fuzzer/CMakeLists.txt
index 880c5e23981..97df4d25620 100644
--- a/velox/functions/prestosql/fuzzer/CMakeLists.txt
+++ b/velox/functions/prestosql/fuzzer/CMakeLists.txt
@@ -13,12 +13,30 @@
 # limitations under the License.
 
 add_library(velox_aggregation_result_verifier MinMaxByResultVerifier.cpp)
+velox_add_test_headers(
+  velox_aggregation_result_verifier
+  ApproxDistinctResultVerifier.h
+  ApproxPercentileResultVerifier.h
+  ArbitraryResultVerifier.h
+  AverageResultVerifier.h
+  KHyperLogLogResultVerifier.h
+  MinMaxByResultVerifier.h
+  NoisyAvgResultVerifier.h
+  NoisyCountIfResultVerifier.h
+  NoisyCountResultVerifier.h
+  NoisySumResultVerifier.h
+  QDigestAggResultVerifier.h
+  SetDigestResultVerifier.h
+  TDigestAggregateResultVerifier.h
+)
 
 target_link_libraries(
   velox_aggregation_result_verifier
+  velox_common_hyperloglog
   velox_core
   velox_aggregation_fuzzer_base
   velox_exec_test_lib
+  velox_functions_lib
   velox_vector
   velox_vector_test_lib
 )
@@ -64,3 +82,32 @@ target_link_libraries(
   GTest::gtest
   GTest::gtest_main
 )
+
+velox_add_library(
+  velox_aggregation_input_generator
+  INTERFACE
+  HEADERS
+  ApproxDistinctInputGenerator.h
+  ApproxPercentileInputGenerator.h
+  ClassificationAggregationInputGenerator.h
+  DivideArgTypesGenerator.h
+  FbDatelistStringMergeAggregationInputGenerator.h
+  FloorCeilRoundArgTypesGenerator.h
+  MapUnionSumInputGenerator.h
+  MinMaxInputGenerator.h
+  ModulusArgTypesGenerator.h
+  MultiplyArgTypesGenerator.h
+  NoisyAvgInputGenerator.h
+  NoisyCountIfInputGenerator.h
+  NoisyCountInputGenerator.h
+  NoisySumInputGenerator.h
+  NumericHistogramInputGenerator.h
+  PlusMinusArgTypesGenerator.h
+  QDigestAggInputGenerator.h
+  SkipIPAddressArgTypesGenerator.h
+  TDigestAggregateInputGenerator.h
+  TruncateArgTypesGenerator.h
+  WindowOffsetInputGenerator.h
+)
+
+velox_add_library(velox_custome_expression_transformer INTERFACE HEADERS SortArrayTransformer.h)
diff --git a/velox/functions/prestosql/fuzzer/FloorAndRoundArgTypesGenerator.h b/velox/functions/prestosql/fuzzer/FloorCeilRoundArgTypesGenerator.h
similarity index 96%
rename from velox/functions/prestosql/fuzzer/FloorAndRoundArgTypesGenerator.h
rename to velox/functions/prestosql/fuzzer/FloorCeilRoundArgTypesGenerator.h
index 0127b1eb0c6..89ffc70b7ba 100644
--- a/velox/functions/prestosql/fuzzer/FloorAndRoundArgTypesGenerator.h
+++ b/velox/functions/prestosql/fuzzer/FloorCeilRoundArgTypesGenerator.h
@@ -20,7 +20,7 @@
 
 namespace facebook::velox::exec::test {
 
-class FloorAndRoundArgTypesGenerator : public fuzzer::ArgTypesGenerator {
+class FloorCeilRoundArgTypesGenerator : public fuzzer::ArgTypesGenerator {
  public:
   std::vector<TypePtr> generateArgs(
       const exec::FunctionSignature& signature,
diff --git a/velox/functions/prestosql/fuzzer/KHyperLogLogResultVerifier.h b/velox/functions/prestosql/fuzzer/KHyperLogLogResultVerifier.h
new file mode 100644
index 00000000000..737e6993f15
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/KHyperLogLogResultVerifier.h
@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/core/PlanNode.h"
+#include "velox/exec/fuzzer/ResultVerifier.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/lib/KHyperLogLog.h"
+
+namespace facebook::velox::exec::test {
+
+/// Result verifier for khyperloglog_agg aggregate function.
+/// Compares two KHyperLogLog results by deserializing and comparing their
+/// cardinality estimates.
+class KHyperLogLogResultVerifier : public ResultVerifier {
+ public:
+  bool supportsCompare() override {
+    return true;
+  }
+
+  bool supportsVerify() override {
+    return false;
+  }
+
+  void initialize(
+      const std::vector<RowVectorPtr>& /*input*/,
+      const std::vector<core::ExprPtr>& /*projections*/,
+      const std::vector<std::string>& groupingKeys,
+      const core::AggregationNode::Aggregate& /*aggregate*/,
+      const std::string& aggregateName) override {
+    keys_ = groupingKeys;
+    resultName_ = aggregateName;
+  }
+
+  void initializeWindow(
+      const std::vector<RowVectorPtr>& /*input*/,
+      const std::vector<core::ExprPtr>& /*projections*/,
+      const std::vector<std::string>& /*partitionByKeys*/,
+      const std::vector<SortingKeyAndOrder>& /*sortingKeysAndOrders*/,
+      const core::WindowNode::Function& /*function*/,
+      const std::string& /*frame*/,
+      const std::string& windowName) override {
+    keys_ = {"row_number"};
+    resultName_ = windowName;
+  }
+
+  bool compare(const RowVectorPtr& result, const RowVectorPtr& altResult)
+      override {
+    VELOX_CHECK_EQ(result->size(), altResult->size());
+
+    auto projection = keys_;
+    projection.push_back(resultName_);
+
+    auto sortByGroupingKeys = [&](const RowVectorPtr& input) {
+      auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+      auto builder = PlanBuilder(planNodeIdGenerator).values({input});
+      if (!keys_.empty()) {
+        builder = builder.orderBy(keys_, false);
+      }
+      auto sortByKeys = builder.project(projection).planNode();
+      return AssertQueryBuilder(sortByKeys).copyResults(input->pool());
+    };
+
+    auto sortedResult = sortByGroupingKeys(result);
+    auto sortedAltResult = sortByGroupingKeys(altResult);
+
+    VELOX_CHECK_EQ(sortedResult->size(), sortedAltResult->size());
+    auto size = sortedResult->size();
+    for (auto i = 0; i < size; i++) {
+      auto resultIsNull = sortedResult->childAt(resultName_)->isNullAt(i);
+      auto altResultIsNull = sortedAltResult->childAt(resultName_)->isNullAt(i);
+      if (resultIsNull || altResultIsNull) {
+        VELOX_CHECK(resultIsNull && altResultIsNull);
+        continue;
+      }
+
+      auto resultValue = sortedResult->childAt(resultName_)
+                             ->as<SimpleVector<StringView>>()
+                             ->valueAt(i);
+      auto altResultValue = sortedAltResult->childAt(resultName_)
+                                ->as<SimpleVector<StringView>>()
+                                ->valueAt(i);
+      if (resultValue == altResultValue) {
+        continue;
+      } else {
+        checkEquivalentKHyperLogLog(resultValue, altResultValue);
+      }
+    }
+    return true;
+  }
+
+  bool verify(const RowVectorPtr& /*result*/) override {
+    VELOX_UNSUPPORTED();
+  }
+
+  void reset() override {
+    keys_.clear();
+    resultName_.clear();
+  }
+
+ private:
+  // Relative error tolerance for approximate cardinality estimates.
+  static constexpr double kRelativeErrorTolerance = 0.05;
+
+  void checkEquivalentKHyperLogLog(
+      const StringView& result,
+      const StringView& altResult) {
+    auto pool = memory::MemoryManager::getInstance()->addLeafPool(
+        "KHyperLogLogResultVerifier");
+    HashStringAllocator allocator(pool.get());
+
+    auto resultKhllExpected =
+        common::hll::KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+            result.data(), result.size(), &allocator);
+    VELOX_CHECK(
+        resultKhllExpected.hasValue(),
+        "Failed to deserialize KHyperLogLog result");
+    auto& resultKhll = resultKhllExpected.value();
+
+    auto altResultKhllExpected =
+        common::hll::KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+            altResult.data(), altResult.size(), &allocator);
+    VELOX_CHECK(
+        altResultKhllExpected.hasValue(),
+        "Failed to deserialize KHyperLogLog altResult");
+    auto& altResultKhll = altResultKhllExpected.value();
+
+    int64_t resultCardinality = resultKhll->cardinality();
+    int64_t altResultCardinality = altResultKhll->cardinality();
+
+    // Check that both are in the same mode (exact or approximate).
+    VELOX_CHECK_EQ(resultKhll->isExact(), altResultKhll->isExact());
+
+    if (resultKhll->isExact()) {
+      // In exact mode, cardinalities must match exactly.
+      VELOX_CHECK_EQ(
+          resultCardinality,
+          altResultCardinality,
+          "KHyperLogLog cardinality should be exact but differs: {} vs. {}",
+          resultCardinality,
+          altResultCardinality);
+    } else {
+      // In approximate mode, allow tolerance for probabilistic data structure,
+      // 5% relative error or absolute difference of 1 for small cardinalities.
+      int64_t maxCardinality =
+          std::max(resultCardinality, altResultCardinality);
+      int64_t allowedDifference = std::max(
+          static_cast<int64_t>(1),
+          static_cast<int64_t>(maxCardinality * kRelativeErrorTolerance));
+
+      int64_t actualDifference =
+          std::abs(resultCardinality - altResultCardinality);
+
+      VELOX_CHECK_LE(
+          actualDifference,
+          allowedDifference,
+          "KHyperLogLog cardinality estimates differ: {} vs. {}",
+          resultCardinality,
+          altResultCardinality);
+    }
+  }
+
+  std::vector<std::string> keys_;
+  std::string resultName_;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/NoisySumResultVerifier.h b/velox/functions/prestosql/fuzzer/NoisySumResultVerifier.h
index 51295bb5edb..c698772f513 100644
--- a/velox/functions/prestosql/fuzzer/NoisySumResultVerifier.h
+++ b/velox/functions/prestosql/fuzzer/NoisySumResultVerifier.h
@@ -16,6 +16,8 @@
 
 #pragma once
 
+#include <boost/algorithm/string/join.hpp>
+#include <fmt/ranges.h>
 #include <cstdint>
 #include <string>
 #include "velox/core/PlanNode.h"
@@ -239,8 +241,8 @@ class NoisySumResultVerifier : public ResultVerifier {
     // Build partition by clause for window function
     std::string partitionBy;
     if (!partitionKeys.empty()) {
-      partitionBy =
-          fmt::format("partition by {}", fmt::join(partitionKeys, ", "));
+      partitionBy = fmt::format(
+          "partition by {}", boost::algorithm::join(partitionKeys, ", "));
     }
 
     // Use row_number() window function to identify first occurrence of each
diff --git a/velox/functions/prestosql/fuzzer/SetDigestResultVerifier.h b/velox/functions/prestosql/fuzzer/SetDigestResultVerifier.h
new file mode 100644
index 00000000000..3723a65359b
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/SetDigestResultVerifier.h
@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/common/memory/Memory.h"
+#include "velox/core/PlanNode.h"
+#include "velox/exec/fuzzer/ResultVerifier.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/lib/SetDigest.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/SimpleVector.h"
+
+namespace facebook::velox::exec::test {
+
+class SetDigestResultVerifier : public ResultVerifier {
+ public:
+  bool supportsCompare() override {
+    return true;
+  }
+
+  bool supportsVerify() override {
+    return false;
+  }
+
+  void initialize(
+      const std::vector<RowVectorPtr>& /*input*/,
+      const std::vector<core::ExprPtr>& /*projections*/,
+      const std::vector<std::string>& groupingKeys,
+      const core::AggregationNode::Aggregate& /*aggregate*/,
+      const std::string& aggregateName) override {
+    keys_ = groupingKeys;
+    resultName_ = aggregateName;
+  }
+
+  void initializeWindow(
+      const std::vector<RowVectorPtr>& /*input*/,
+      const std::vector<core::ExprPtr>& /*projections*/,
+      const std::vector<std::string>& /*partitionByKeys*/,
+      const std::vector<SortingKeyAndOrder>& /*sortingKeysAndOrders*/,
+      const core::WindowNode::Function& /*function*/,
+      const std::string& /*frame*/,
+      const std::string& windowName) override {
+    keys_ = {"row_number"};
+    resultName_ = windowName;
+  }
+
+  bool compare(const RowVectorPtr& result, const RowVectorPtr& altResult)
+      override {
+    VELOX_CHECK_EQ(result->size(), altResult->size());
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+    auto sortByGroupingKeys = [&](const RowVectorPtr& data) {
+      auto projection = keys_;
+      projection.push_back(resultName_);
+
+      auto builder = PlanBuilder(planNodeIdGenerator).values({data});
+      if (!keys_.empty()) {
+        builder = builder.orderBy(keys_, false);
+      }
+      auto sortByKeys = builder.project(projection).planNode();
+      return AssertQueryBuilder(sortByKeys).copyResults(data->pool());
+    };
+
+    auto sortedResult = sortByGroupingKeys(result);
+    auto sortedAltResult = sortByGroupingKeys(altResult);
+
+    VELOX_CHECK_EQ(sortedResult->size(), sortedAltResult->size());
+    auto size = sortedResult->size();
+    for (auto i = 0; i < size; i++) {
+      auto resultIsNull = sortedResult->childAt(resultName_)->isNullAt(i);
+      auto altResultIsNull = sortedAltResult->childAt(resultName_)->isNullAt(i);
+      if (resultIsNull || altResultIsNull) {
+        VELOX_CHECK(
+            resultIsNull && altResultIsNull,
+            "Null mismatch at row {}: result={}, altResult={}",
+            i,
+            resultIsNull,
+            altResultIsNull);
+        continue;
+      }
+
+      auto resultValue = sortedResult->childAt(resultName_)
+                             ->as<SimpleVector<StringView>>()
+                             ->valueAt(i);
+      auto altResultValue = sortedAltResult->childAt(resultName_)
+                                ->as<SimpleVector<StringView>>()
+                                ->valueAt(i);
+
+      if (resultValue == altResultValue) {
+        continue;
+      }
+
+      checkEquivalentSetDigest(resultValue, altResultValue);
+    }
+    return true;
+  }
+
+  bool verify(const RowVectorPtr& /*result*/) override {
+    VELOX_UNSUPPORTED();
+  }
+
+  void reset() override {
+    keys_.clear();
+    resultName_.clear();
+  }
+
+ private:
+  void checkEquivalentSetDigest(
+      const StringView& result,
+      const StringView& altResult) {
+    // Create a local pool and allocator for these SetDigest objects.
+    // SetDigest objects hold references to allocator memory, so the allocator
+    // must outlive them to avoid use-after-free.
+    auto pool = memory::memoryManager()->addLeafPool();
+    HashStringAllocator allocator(pool.get());
+
+    facebook::velox::functions::SetDigest<int64_t> resultDigest(&allocator);
+    facebook::velox::functions::SetDigest<int64_t> altResultDigest(&allocator);
+
+    // Deserialize SetDigests
+    auto resultStatus = resultDigest.deserialize(
+        result.data(), static_cast<int32_t>(result.size()));
+    VELOX_CHECK(
+        resultStatus.ok(),
+        "Failed to deserialize result SetDigest: {}",
+        resultStatus.message());
+
+    auto altResultStatus = altResultDigest.deserialize(
+        altResult.data(), static_cast<int32_t>(altResult.size()));
+    VELOX_CHECK(
+        altResultStatus.ok(),
+        "Failed to deserialize altResult SetDigest: {}",
+        altResultStatus.message());
+
+    // Extract cardinality and exactness mode
+    auto resultCardinality = resultDigest.cardinality();
+    auto altResultCardinality = altResultDigest.cardinality();
+    const bool resultIsExact = resultDigest.isExact();
+    const bool altResultIsExact = altResultDigest.isExact();
+
+    // For exact mode, cardinalities must match exactly
+    if (resultIsExact && altResultIsExact) {
+      VELOX_CHECK_EQ(
+          resultCardinality,
+          altResultCardinality,
+          "SetDigest exact cardinality mismatch: {} vs {}",
+          resultCardinality,
+          altResultCardinality);
+      return;
+    }
+
+    // For approximate mode or mixed modes, compare with error tolerance.
+    // SetDigest defaults to maxHashes=8192, so most fuzzer-generated data
+    // (typically <1000 values) will be exact. When approximate mode is
+    // triggered (>8192 unique values), allow 5% error tolerance.
+    if (resultCardinality == 0 && altResultCardinality == 0) {
+      return;
+    }
+
+    // Calculate relative error
+    const double maxCardinality = std::max(
+        static_cast<double>(resultCardinality),
+        static_cast<double>(altResultCardinality));
+    const double errorRate = std::abs(
+                                 static_cast<double>(resultCardinality) -
+                                 static_cast<double>(altResultCardinality)) /
+        maxCardinality;
+
+    VELOX_CHECK_LT(
+        errorRate,
+        kApproximateErrorTolerance,
+        "SetDigest cardinality mismatch: {} vs {} (error: {:.2%})",
+        resultCardinality,
+        altResultCardinality,
+        errorRate);
+  }
+
+  static constexpr double kApproximateErrorTolerance = 0.05;
+
+  std::vector<std::string> keys_;
+  std::string resultName_;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/SkipIPAddressArgTypesGenerator.h b/velox/functions/prestosql/fuzzer/SkipIPAddressArgTypesGenerator.h
new file mode 100644
index 00000000000..8dc79d8d2f4
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/SkipIPAddressArgTypesGenerator.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/exec/fuzzer/FuzzerUtil.h"
+#include "velox/expression/fuzzer/ArgTypesGenerator.h"
+#include "velox/expression/fuzzer/ArgumentTypeFuzzer.h"
+
+namespace facebook::velox::exec::test {
+
+/// Blocks types containing IPADDRESS in container positions (array elements,
+/// map keys, map values) which fail in Presto due to missing compareTo()
+/// implementation in Int128ArrayBlock. Used for functions that perform
+/// element-level comparison (e.g., array_union, array_sort, contains).
+/// See: https://github.com/prestodb/presto/issues/26836
+class SkipIPAddressArgTypesGenerator : public fuzzer::ArgTypesGenerator {
+ public:
+  std::vector<TypePtr> generateArgs(
+      const exec::FunctionSignature& signature,
+      const TypePtr& returnType,
+      fuzzer::FuzzerGenerator& rng) override {
+    // Use default ArgumentTypeFuzzer to generate types.
+    fuzzer::ArgumentTypeFuzzer fuzzer(signature, returnType, rng);
+
+    if (!fuzzer.fuzzArgumentTypes(0 /* maxVariadicArgs */)) {
+      // Cannot generate valid argument types.
+      return {};
+    }
+
+    auto argTypes = fuzzer.argumentTypes();
+
+    // Block types containing IPADDRESS in container positions.
+    // Presto throws: UnsupportedOperationException in
+    // Int128ArrayBlock.compareTo()
+    for (const auto& argType : argTypes) {
+      if (containsIPAddress(argType)) {
+        return {};
+      }
+    }
+
+    return argTypes;
+  }
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/TDigestAggregateInputGenerator.h b/velox/functions/prestosql/fuzzer/TDigestAggregateInputGenerator.h
index 08b39660aa8..8b78a0f139e 100644
--- a/velox/functions/prestosql/fuzzer/TDigestAggregateInputGenerator.h
+++ b/velox/functions/prestosql/fuzzer/TDigestAggregateInputGenerator.h
@@ -58,8 +58,9 @@ class TDigestAggregateInputGenerator : public InputGenerator {
         boost::random::uniform_real_distribution<double> dist(10.0, 1000.0);
         compression_ = dist(rng);
       }
-      inputs.push_back(BaseVector::createConstant(
-          DOUBLE(), compression_.value(), size, pool));
+      inputs.push_back(
+          BaseVector::createConstant(
+              DOUBLE(), compression_.value(), size, pool));
     }
 
     return inputs;
diff --git a/velox/functions/prestosql/fuzzer/TruncateArgTypesGenerator.h b/velox/functions/prestosql/fuzzer/TruncateArgTypesGenerator.h
index b898e865dd7..914f9e6c140 100644
--- a/velox/functions/prestosql/fuzzer/TruncateArgTypesGenerator.h
+++ b/velox/functions/prestosql/fuzzer/TruncateArgTypesGenerator.h
@@ -28,8 +28,14 @@ class TruncateArgTypesGenerator : public fuzzer::ArgTypesGenerator {
       FuzzerGenerator& rng) override {
     // Only the single-arg truncate function is supported because
     // ArgumentTypeFuzzer can generate argument types for the two-arg truncate
-    // function.
-    VELOX_CHECK_EQ(1, signature.argumentTypes().size());
+    // function. Since custom generators are prioritized over
+    // ArgumentTypeFuzzer, this generator is called for both signatures. Return
+    // empty to signal the fuzzer to skip this signature (returning nullptr in
+    // ExpressionFuzzer), allowing the two-arg signature to be handled by
+    // ArgumentTypeFuzzer.
+    if (signature.argumentTypes().size() != 1) {
+      return {};
+    }
     // Generates a decimal type following below formulas:
     // p = max(p1 - s1, 1)
     // s = 0
diff --git a/velox/functions/prestosql/fuzzer/WindowFuzzerTest.cpp b/velox/functions/prestosql/fuzzer/WindowFuzzerTest.cpp
index 67aa6fd3df8..bbea9a8a52a 100644
--- a/velox/functions/prestosql/fuzzer/WindowFuzzerTest.cpp
+++ b/velox/functions/prestosql/fuzzer/WindowFuzzerTest.cpp
@@ -26,10 +26,12 @@
 #include "velox/functions/prestosql/fuzzer/ApproxPercentileInputGenerator.h"
 #include "velox/functions/prestosql/fuzzer/ApproxPercentileResultVerifier.h"
 #include "velox/functions/prestosql/fuzzer/AverageResultVerifier.h"
+#include "velox/functions/prestosql/fuzzer/KHyperLogLogResultVerifier.h"
 #include "velox/functions/prestosql/fuzzer/MinMaxInputGenerator.h"
 #include "velox/functions/prestosql/fuzzer/NumericHistogramInputGenerator.h"
 #include "velox/functions/prestosql/fuzzer/QDigestAggInputGenerator.h"
 #include "velox/functions/prestosql/fuzzer/QDigestAggResultVerifier.h"
+#include "velox/functions/prestosql/fuzzer/SetDigestResultVerifier.h"
 #include "velox/functions/prestosql/fuzzer/TDigestAggregateInputGenerator.h"
 #include "velox/functions/prestosql/fuzzer/TDigestAggregateResultVerifier.h"
 #include "velox/functions/prestosql/fuzzer/WindowOffsetInputGenerator.h"
@@ -134,10 +136,23 @@ int main(int argc, char** argv) {
       "noisy_approx_set_sfm",
       "noisy_approx_distinct_sfm",
       "noisy_approx_set_sfm_from_index_and_zeros",
+      "reservoir_sample",
       // https://github.com/facebookincubator/velox/issues/13547
       "merge",
       // https://github.com/facebookincubator/velox/issues/14423
       "numeric_histogram",
+      "khyperloglog_agg", // TODO: Remove from skip list once the KHLL result
+      // verifier is added.
+      "convex_hull_agg",
+      "geometry_union_agg",
+      "geometry_union_agg_partial",
+      "geometry_union_agg_merge",
+      "geometry_union_agg_extract",
+      "geometry_union_agg_merge_extract",
+      "convex_hull_agg_partial",
+      "convex_hull_agg_merge",
+      "convex_hull_agg_extract",
+      "convex_hull_agg_merge_extract",
   };
 
   if (!FLAGS_presto_url.empty()) {
@@ -156,7 +171,9 @@ int main(int argc, char** argv) {
   using facebook::velox::exec::test::ApproxDistinctResultVerifier;
   using facebook::velox::exec::test::ApproxPercentileResultVerifier;
   using facebook::velox::exec::test::AverageResultVerifier;
+  using facebook::velox::exec::test::KHyperLogLogResultVerifier;
   using facebook::velox::exec::test::QDigestAggResultVerifier;
+  using facebook::velox::exec::test::SetDigestResultVerifier;
   using facebook::velox::exec::test::TDigestAggregateResultVerifier;
 
   static const std::unordered_map<
@@ -171,6 +188,7 @@ int main(int argc, char** argv) {
           {"approx_most_frequent", nullptr},
           {"tdigest_agg", std::make_shared<TDigestAggregateResultVerifier>()},
           {"qdigest_agg", std::make_shared<QDigestAggResultVerifier>()},
+          {"khyperloglog_agg", std::make_shared<KHyperLogLogResultVerifier>()},
           {"merge", nullptr},
           // Semantically inconsistent functions
           {"skewness", nullptr},
@@ -180,6 +198,8 @@ int main(int argc, char** argv) {
           {"max_data_size_for_stats", nullptr},
           {"sum_data_size_for_stats", nullptr},
           {"avg", std::make_shared<AverageResultVerifier>()},
+          {"make_set_digest", std::make_shared<SetDigestResultVerifier>()},
+          {"merge_set_digest", std::make_shared<SetDigestResultVerifier>()},
       };
 
   static const std::unordered_set<std::string> orderDependentFunctions = {
diff --git a/velox/functions/prestosql/geospatial/CMakeLists.txt b/velox/functions/prestosql/geospatial/CMakeLists.txt
index e4ff991f3cf..8bd97a429a9 100644
--- a/velox/functions/prestosql/geospatial/CMakeLists.txt
+++ b/velox/functions/prestosql/geospatial/CMakeLists.txt
@@ -11,6 +11,11 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-velox_add_library(velox_functions_geo GeometrySerde.cpp GeometryUtils.cpp)
+velox_add_library(velox_functions_geo GeometryUtils.cpp HEADERS GeometryUtils.h)
 
-velox_link_libraries(velox_functions_geo velox_functions_lib GEOS::geos)
+velox_link_libraries(
+  velox_functions_geo
+  velox_common_geospatial_serde
+  velox_functions_lib
+  GEOS::geos
+)
diff --git a/velox/functions/prestosql/geospatial/GeometryUtils.cpp b/velox/functions/prestosql/geospatial/GeometryUtils.cpp
index 4b74147e40f..0e2ad4be61c 100644
--- a/velox/functions/prestosql/geospatial/GeometryUtils.cpp
+++ b/velox/functions/prestosql/geospatial/GeometryUtils.cpp
@@ -13,21 +13,153 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 #include "velox/functions/prestosql/geospatial/GeometryUtils.h"
 #include <geos/geom/prep/PreparedGeometryFactory.h>
 #include <geos/operation/valid/IsSimpleOp.h>
 #include <geos/operation/valid/IsValidOp.h>
+#include <queue>
 #include "velox/common/base/Exceptions.h"
+#include "velox/common/geospatial/GeometryConstants.h"
 #include "velox/functions/prestosql/types/BingTileType.h"
 
 using geos::operation::valid::IsSimpleOp;
 using geos::operation::valid::IsValidOp;
 
+namespace {
+
+class SphericalExcessCalculator {
+  static constexpr double TWO_PI = 2 * M_PI;
+  static constexpr double THREE_PI = 3 * M_PI;
+
+  double sphericalExcess = 0.0;
+  double courseDelta = 0.0;
+
+  bool firstPoint = true;
+  double firstInitialBearing = 0.0;
+  double previousFinalBearing = 0.0;
+
+  double previousPhi = 0.0;
+  double previousCos = 0.0;
+  double previousSin = 0.0;
+  double previousTan = 0.0;
+  double previousLongitude = 0.0;
+
+  bool done = false;
+
+  static double toRadians(double deg) {
+    return deg * M_PI / 180.0;
+  }
+
+ public:
+  explicit SphericalExcessCalculator(const geos::geom::Coordinate& endPoint) {
+    previousPhi = toRadians(endPoint.y);
+    previousSin = std::sin(previousPhi);
+    previousCos = std::cos(previousPhi);
+    previousTan = std::tan(previousPhi / 2);
+    previousLongitude = toRadians(endPoint.x);
+  }
+
+  void add(const geos::geom::Coordinate& point) {
+    VELOX_CHECK(!done, "Computation of spherical excess is complete");
+
+    double phi = toRadians(point.y);
+    double tan = std::tan(phi / 2);
+    double longitude = toRadians(point.x);
+
+    VELOX_USER_CHECK(
+        (longitude != previousLongitude || phi != previousPhi),
+        "Polygon is not valid: it has two identical consecutive vertices");
+
+    double deltaLongitude = longitude - previousLongitude;
+    sphericalExcess += 2 *
+        std::atan2(std::tan(deltaLongitude / 2) * (previousTan + tan),
+                   1 + previousTan * tan);
+
+    double cos = std::cos(phi);
+    double sin = std::sin(phi);
+    double sinOfDeltaLongitude = std::sin(deltaLongitude);
+    double cosOfDeltaLongitude = std::cos(deltaLongitude);
+
+    // Initial bearing from previous to current
+    double y = sinOfDeltaLongitude * cos;
+    double x = previousCos * sin - previousSin * cos * cosOfDeltaLongitude;
+    double initialBearing = std::fmod(std::atan2(y, x) + TWO_PI, TWO_PI);
+
+    // Final bearing from previous to current = opposite of bearing from current
+    // to previous
+    double finalY = -sinOfDeltaLongitude * previousCos;
+    double finalX = previousSin * cos - previousCos * sin * cosOfDeltaLongitude;
+    double finalBearing = std::fmod(std::atan2(finalY, finalX) + M_PI, TWO_PI);
+
+    if (firstPoint) {
+      // Keep our initial bearing around, and we'll use it at the end
+      // with the last final bearing
+      firstInitialBearing = initialBearing;
+      firstPoint = false;
+    } else {
+      courseDelta +=
+          std::fmod(initialBearing - previousFinalBearing + THREE_PI, TWO_PI) -
+          M_PI;
+    }
+
+    courseDelta +=
+        std::fmod(finalBearing - initialBearing + THREE_PI, TWO_PI) - M_PI;
+
+    previousFinalBearing = finalBearing;
+    previousCos = cos;
+    previousSin = sin;
+    previousPhi = phi;
+    previousTan = tan;
+    previousLongitude = longitude;
+  }
+
+  double computeSphericalExcess() {
+    if (!done) {
+      courseDelta +=
+          std::fmod(
+              firstInitialBearing - previousFinalBearing + THREE_PI, TWO_PI) -
+          M_PI;
+
+      // The courseDelta should be 2Pi or - 2Pi, unless a pole is enclosed (and
+      // then it should be ~ 0) In which case we need to correct the spherical
+      // excess by 2Pi
+      if (std::abs(courseDelta) < M_PI / 4) {
+        sphericalExcess = std::abs(sphericalExcess) - TWO_PI;
+      }
+      done = true;
+    }
+    return sphericalExcess;
+  }
+
+  static double excessFromCoordinates(
+      const geos::geom::CoordinateSequence& coords) {
+    int start = 0;
+    size_t end = coords.size();
+    // Our calculations rely on not processing the same point twice
+    if (coords.getAt(end - 1).equals(coords.getAt(start))) {
+      end = end - 1;
+    }
+
+    // A path with less than 3 distinct points is not valid for calculating an
+    // area
+    VELOX_USER_CHECK(
+        end - start > 2,
+        "Polygon is not valid: a loop contains less then 3 vertices.");
+
+    // Initialize the calculator with the last point
+    SphericalExcessCalculator calculator(coords.getAt(end - 1));
+
+    for (int i = start; i < end; i++) {
+      calculator.add(coords.getAt(i));
+    }
+
+    return calculator.computeSphericalExcess();
+  }
+};
+} // namespace
+
 namespace facebook::velox::functions::geospatial {
 
-static constexpr double kRealMinLatitude = -90;
-static constexpr double kRealMaxLatitude = 90;
 static constexpr int32_t kMaxCoveringCount = 1'000'000;
 
 GeometryCollectionIterator::GeometryCollectionIterator(
@@ -85,12 +217,6 @@ std::vector<const geos::geom::Geometry*> flattenCollection(
   return result;
 }
 
-geos::geom::GeometryFactory* getGeometryFactory() {
-  thread_local static geos::geom::GeometryFactory::Ptr geometryFactory =
-      geos::geom::GeometryFactory::create();
-  return geometryFactory.get();
-}
-
 std::optional<std::string> geometryInvalidReason(
     const geos::geom::Geometry* geometry) {
   if (geometry == nullptr) {
@@ -150,18 +276,20 @@ std::optional<std::string> geometryInvalidReason(
 
 Status validateLatitudeLongitude(double latitude, double longitude) {
   if (FOLLY_UNLIKELY(
-          latitude < kRealMinLatitude || latitude > kRealMaxLatitude ||
-          longitude < BingTileType::kMinLongitude ||
-          longitude > BingTileType::kMaxLongitude || std::isnan(latitude) ||
-          std::isnan(longitude))) {
-    return Status::UserError(fmt::format(
-        "Latitude must be in range [{}, {}] and longitude must be in range [{}, {}]. Got latitude: {} and longitude: {}",
-        kRealMinLatitude,
-        kRealMaxLatitude,
-        BingTileType::kMinLongitude,
-        BingTileType::kMaxLongitude,
-        latitude,
-        longitude));
+          latitude < common::geospatial::kMinLatitude ||
+          latitude > common::geospatial::kMaxLatitude ||
+          longitude < common::geospatial::kMinLongitude ||
+          longitude > common::geospatial::kMaxLongitude ||
+          std::isnan(latitude) || std::isnan(longitude))) {
+    return Status::UserError(
+        fmt::format(
+            "Latitude must be in range [{}, {}] and longitude must be in range [{}, {}]. Got latitude: {} and longitude: {}",
+            common::geospatial::kMinLatitude,
+            common::geospatial::kMaxLatitude,
+            common::geospatial::kMinLongitude,
+            common::geospatial::kMaxLongitude,
+            latitude,
+            longitude));
   }
   return Status::OK();
 }
@@ -172,20 +300,22 @@ FOLLY_ALWAYS_INLINE void checkLatitudeLongitudeBounds(
     double latitude,
     double longitude) {
   if (FOLLY_UNLIKELY(
-          latitude > BingTileType::kMaxLatitude ||
-          latitude < BingTileType::kMinLatitude)) {
-    VELOX_USER_FAIL(fmt::format(
-        "Latitude span for the geometry must be in [{:.2f}, {:.2f}] range",
-        BingTileType::kMinLatitude,
-        BingTileType::kMaxLatitude));
+          latitude > common::geospatial::kMaxBingTileLatitude ||
+          latitude < common::geospatial::kMinBingTileLatitude)) {
+    VELOX_USER_FAIL(
+        fmt::format(
+            "Latitude span for the geometry must be in [{:.2f}, {:.2f}] range",
+            common::geospatial::kMinBingTileLatitude,
+            common::geospatial::kMaxBingTileLatitude));
   }
   if (FOLLY_UNLIKELY(
-          longitude > BingTileType::kMaxLongitude ||
-          longitude < BingTileType::kMinLongitude)) {
-    VELOX_USER_FAIL(fmt::format(
-        "Longitude span for the geometry must be in [{:.2f}, {:.2f}] range",
-        BingTileType::kMinLongitude,
-        BingTileType::kMaxLongitude));
+          longitude > common::geospatial::kMaxLongitude ||
+          longitude < common::geospatial::kMinLongitude)) {
+    VELOX_USER_FAIL(
+        fmt::format(
+            "Longitude span for the geometry must be in [{:.2f}, {:.2f}] range",
+            common::geospatial::kMinLongitude,
+            common::geospatial::kMaxLongitude));
   }
 }
 
@@ -392,6 +522,73 @@ std::vector<int64_t> getMinimalTilesCoveringGeometry(
   }
   return results;
 }
+std::vector<int64_t> getDissolvedTilesCoveringGeometry(
+    const geos::geom::Geometry& geometry,
+    int32_t zoom) {
+  std::vector<int64_t> rawTiles = getRawTilesCoveringGeometry(geometry, zoom);
+
+  const geos::geom::Envelope* envelope = geometry.getEnvelopeInternal();
+  checkLatitudeLongitudeBounds(envelope->getMinY(), envelope->getMinX());
+  checkLatitudeLongitudeBounds(envelope->getMaxY(), envelope->getMaxX());
+
+  std::vector<int64_t> results;
+  if (rawTiles.empty()) {
+    return results;
+  }
+
+  results.reserve(rawTiles.size());
+  std::set<int64_t> candidates;
+
+  auto tileComparator = [](int64_t a, int64_t b) {
+    uint8_t za = BingTileType::bingTileZoom(a),
+            zb = BingTileType::bingTileZoom(b);
+    if (za != zb) {
+      return za < zb;
+    }
+    return BingTileType::bingTileToQuadKey(a) <
+        BingTileType::bingTileToQuadKey(b);
+  };
+
+  std::priority_queue<int64_t, std::vector<int64_t>, decltype(tileComparator)>
+      queue(tileComparator);
+
+  for (auto t : rawTiles) {
+    queue.push(t);
+  }
+
+  while (!queue.empty()) {
+    int64_t candidate = queue.top();
+    queue.pop();
+
+    if (BingTileType::bingTileZoom(candidate) == 0) {
+      results.push_back(candidate);
+      continue;
+    }
+
+    auto parentZoom = BingTileType::bingTileZoom(candidate) - 1;
+    auto parentResult = BingTileType::bingTileParent(candidate, parentZoom);
+    VELOX_CHECK(parentResult.hasValue(), parentResult.error());
+    uint64_t parent = parentResult.value();
+    candidates.insert(candidate);
+
+    while (!queue.empty() &&
+           (BingTileType::bingTileParent(queue.top(), parentZoom).value() ==
+            parent)) {
+      candidates.insert(queue.top());
+      queue.pop();
+    }
+
+    if (candidates.size() == 4) {
+      // All siblings present, coalesce to parent
+      queue.push(static_cast<int64_t>(parent));
+    } else {
+      results.insert(results.end(), candidates.begin(), candidates.end());
+    }
+    candidates.clear();
+  }
+
+  return results;
+}
 
 bool isPointOrRectangle(const geos::geom::Geometry& geometry) {
   if (geometry.getGeometryTypeId() == geos::geom::GeometryTypeId::GEOS_POINT) {
@@ -427,4 +624,112 @@ bool isPointOrRectangle(const geos::geom::Geometry& geometry) {
   return true;
 }
 
+std::pair<double, double> computeSphericalCentroid(
+    const geos::geom::MultiPoint& multiPoint) {
+  VELOX_CHECK(
+      !multiPoint.isEmpty(),
+      "computeSphericalCentroid does not handle empty geometries");
+  auto numPoints = multiPoint.getNumGeometries();
+
+  // If only one point in the multipoint, return it
+  if (numPoints == 1) {
+    const geos::geom::Point* point =
+        static_cast<const geos::geom::Point*>(multiPoint.getGeometryN(0));
+    double longitude = point->getX();
+    double latitude = point->getY();
+
+    return {longitude, latitude};
+  }
+
+  // Convert all points to Cartesian coordinates and sum
+  double x3DTotal = 0.0;
+  double y3DTotal = 0.0;
+  double z3DTotal = 0.0;
+
+  for (int i = 0; i < numPoints; i++) {
+    const geos::geom::Point* point = multiPoint.getGeometryN(i);
+    double longitude = point->getX();
+    double latitude = point->getY();
+
+    // Convert to Cartesian coordinates
+    CartesianPoint cp(longitude, latitude);
+    x3DTotal += cp.getX();
+    y3DTotal += cp.getY();
+    z3DTotal += cp.getZ();
+  }
+
+  // Calculate the length of the centroid vector
+  double centroidVectorLength = std::sqrt(
+      x3DTotal * x3DTotal + y3DTotal * y3DTotal + z3DTotal * z3DTotal);
+
+  VELOX_CHECK(
+      centroidVectorLength != 0.0,
+      fmt::format(
+          "Unexpected error. Average vector length adds to zero ({}, {}, {})",
+          x3DTotal,
+          y3DTotal,
+          z3DTotal));
+
+  // Normalize and convert back to spherical coordinates
+  CartesianPoint centroid(
+      x3DTotal / centroidVectorLength,
+      y3DTotal / centroidVectorLength,
+      z3DTotal / centroidVectorLength);
+
+  return centroid.toSphericalPoint();
+}
+
+CartesianPoint::CartesianPoint(double longitude, double latitude) {
+  // Angle from North Pole down to Latitude, in Radians
+  double phi = (90.0 - latitude) * M_PI / 180.0;
+  double sinPhi = std::sin(phi);
+  // Angle from Greenwich to Longitude, in Radians
+  double theta = longitude * M_PI / 180.0;
+
+  x_ = BingTileType::kEarthRadiusKm * sinPhi * std::cos(theta);
+  y_ = BingTileType::kEarthRadiusKm * sinPhi * std::sin(theta);
+  z_ = BingTileType::kEarthRadiusKm * std::cos(phi);
+}
+
+CartesianPoint::CartesianPoint(double x, double y, double z)
+    : x_(x), y_(y), z_(z) {}
+
+std::pair<double, double> CartesianPoint::toSphericalPoint() const {
+  // Angle from North Pole down to Latitude, in Radians
+  double phi = std::atan2(std::sqrt(x_ * x_ + y_ * y_), z_);
+  // Angle from Greenwich to Longitude, in Radians
+  double theta = std::atan2(y_, x_);
+  double latitude = 90.0 - phi * 180.0 / M_PI;
+  double longitude = theta * 180.0 / M_PI;
+  return {longitude, latitude};
+}
+
+double getSphericalLength(const geos::geom::LineString& lineString) {
+  double sum = 0.0;
+  auto numPoints = lineString.getNumPoints();
+  auto lastPoint = lineString.getCoordinateN(0);
+
+  for (int i = 1; i < numPoints; i++) {
+    auto thisPoint = lineString.getCoordinateN(i);
+    sum += BingTileType::greatCircleDistance(
+        lastPoint.y, lastPoint.x, thisPoint.y, thisPoint.x);
+    lastPoint = thisPoint;
+  }
+
+  return sum;
+}
+
+double computeSphericalExcess(const geos::geom::Polygon& polygon) {
+  double sphericalExcess = std::abs(
+      SphericalExcessCalculator::excessFromCoordinates(
+          *polygon.getExteriorRing()->getCoordinates()));
+  auto interiorRingCount = polygon.getNumInteriorRing();
+  for (int i = 0; i < interiorRingCount; i++) {
+    sphericalExcess -= std::abs(
+        SphericalExcessCalculator::excessFromCoordinates(
+            *polygon.getInteriorRingN(i)->getCoordinates()));
+  }
+  return sphericalExcess;
+}
+
 } // namespace facebook::velox::functions::geospatial
diff --git a/velox/functions/prestosql/geospatial/GeometryUtils.h b/velox/functions/prestosql/geospatial/GeometryUtils.h
index 56372faa579..4bce818958d 100644
--- a/velox/functions/prestosql/geospatial/GeometryUtils.h
+++ b/velox/functions/prestosql/geospatial/GeometryUtils.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <fmt/ranges.h>
 #include <geos/geom/Geometry.h>
 #include <geos/io/WKTReader.h>
 
@@ -45,15 +46,15 @@ namespace facebook::velox::functions::geospatial {
 
 /// Utility macro used to wrap GEOS library calls in a try-catch block,
 /// throwing a velox::Status with error message if an exception is caught.
-#define GEOS_RETHROW(func, user_error_message)                             \
-  try {                                                                    \
-    func                                                                   \
-  } catch (const geos::util::UnsupportedOperationException& e) {           \
-    VELOX_USER_FAIL(fmt::format("Internal geometry error: {}", e.what())); \
-  } catch (const geos::util::AssertionFailedException& e) {                \
-    VELOX_FAIL(fmt::format("Internal geometry error: {}", e.what()));      \
-  } catch (const geos::util::GEOSException& e) {                           \
-    VELOX_FAIL(fmt::format("{}: {}", user_error_message, e.what()));       \
+#define GEOS_RETHROW(func, user_error_message)                   \
+  try {                                                          \
+    func                                                         \
+  } catch (const geos::util::UnsupportedOperationException& e) { \
+    VELOX_USER_FAIL("Internal geometry error: {}", e.what());    \
+  } catch (const geos::util::AssertionFailedException& e) {      \
+    VELOX_FAIL("Internal geometry error: {}", e.what());         \
+  } catch (const geos::util::GEOSException& e) {                 \
+    VELOX_FAIL("{}: {}", user_error_message, e.what());          \
   }
 
 class GeometryCollectionIterator {
@@ -66,8 +67,6 @@ class GeometryCollectionIterator {
   std::deque<const geos::geom::Geometry*> geometriesDeque;
 };
 
-geos::geom::GeometryFactory* getGeometryFactory();
-
 FOLLY_ALWAYS_INLINE const
     std::unordered_map<geos::geom::GeometryTypeId, std::string>&
     getGeosTypeToStringIdentifier() {
@@ -112,11 +111,12 @@ FOLLY_ALWAYS_INLINE Status validateType(
     std::string callerFunctionName) {
   geos::geom::GeometryTypeId type = geometry.getGeometryTypeId();
   if (!std::count(validTypes.begin(), validTypes.end(), type)) {
-    return Status::UserError(fmt::format(
-        "{} only applies to {}. Input type is: {}",
-        callerFunctionName,
-        fmt::join(getGeosTypeNames(validTypes), " or "),
-        getGeosTypeToStringIdentifier().at(type)));
+    return Status::UserError(
+        fmt::format(
+            "{} only applies to {}. Input type is: {}",
+            callerFunctionName,
+            fmt::join(getGeosTypeNames(validTypes), " or "),
+            getGeosTypeToStringIdentifier().at(type)));
   }
   return Status::OK();
 }
@@ -133,6 +133,18 @@ FOLLY_ALWAYS_INLINE bool isMultiType(const geos::geom::Geometry& geometry) {
   return std::count(multiTypes.begin(), multiTypes.end(), type);
 }
 
+FOLLY_ALWAYS_INLINE bool isGeometryCollection(
+    const geos::geom::Geometry& geometry) {
+  return geometry.getGeometryTypeId() ==
+      geos::geom::GeometryTypeId::GEOS_GEOMETRYCOLLECTION;
+}
+
+FOLLY_ALWAYS_INLINE bool hasGeometryCollection(
+    const geos::geom::Geometry& left,
+    const geos::geom::Geometry& right) {
+  return isGeometryCollection(left) || isGeometryCollection(right);
+}
+
 FOLLY_ALWAYS_INLINE bool isAtomicType(const geos::geom::Geometry& geometry) {
   geos::geom::GeometryTypeId type = geometry.getGeometryTypeId();
 
@@ -147,63 +159,6 @@ FOLLY_ALWAYS_INLINE bool isAtomicType(const geos::geom::Geometry& geometry) {
 std::optional<std::string> geometryInvalidReason(
     const geos::geom::Geometry* geometry);
 
-/// Determines if a ring of coordinates (from `start` to `end`) is oriented
-/// clockwise.
-FOLLY_ALWAYS_INLINE bool isClockwise(
-    const std::unique_ptr<geos::geom::CoordinateSequence>& coordinates,
-    size_t start,
-    size_t end) {
-  double sum = 0.0;
-  for (size_t i = start; i < end - 1; i++) {
-    const auto& p1 = coordinates->getAt(i);
-    const auto& p2 = coordinates->getAt(i + 1);
-    sum += (p2.x - p1.x) * (p2.y + p1.y);
-  }
-  return sum > 0.0;
-}
-
-/// Reverses the order of coordinates in the sequence between `start` and `end`
-FOLLY_ALWAYS_INLINE void reverse(
-    const std::unique_ptr<geos::geom::CoordinateSequence>& coordinates,
-    size_t start,
-    size_t end) {
-  for (size_t i = 0; i < (end - start) / 2; ++i) {
-    auto temp = coordinates->getAt(start + i);
-    coordinates->setAt(coordinates->getAt(end - 1 - i), start + i);
-    coordinates->setAt(temp, end - 1 - i);
-  }
-}
-
-/// Ensures that a polygon ring has the canonical orientation:
-/// - Exterior rings (shells) must be clockwise.
-/// - Interior rings (holes) must be counter-clockwise.
-FOLLY_ALWAYS_INLINE void canonicalizePolygonCoordinates(
-    const std::unique_ptr<geos::geom::CoordinateSequence>& coordinates,
-    size_t start,
-    size_t end,
-    bool isShell) {
-  bool isClockwiseFlag = isClockwise(coordinates, start, end);
-
-  if ((isShell && !isClockwiseFlag) || (!isShell && isClockwiseFlag)) {
-    reverse(coordinates, start, end);
-  }
-}
-
-/// Applies `canonicalizePolygonCoordinates` to all rings in a polygon.
-FOLLY_ALWAYS_INLINE void canonicalizePolygonCoordinates(
-    const std::unique_ptr<geos::geom::CoordinateSequence>& coordinates,
-    const std::vector<size_t>& partIndexes,
-    const std::vector<bool>& shellPart) {
-  for (size_t part = 0; part < partIndexes.size() - 1; part++) {
-    canonicalizePolygonCoordinates(
-        coordinates, partIndexes[part], partIndexes[part + 1], shellPart[part]);
-  }
-  if (!partIndexes.empty()) {
-    canonicalizePolygonCoordinates(
-        coordinates, partIndexes.back(), coordinates->size(), shellPart.back());
-  }
-}
-
 Status validateLatitudeLongitude(double latitude, double longitude);
 
 std::vector<const geos::geom::Geometry*> flattenCollection(
@@ -218,6 +173,59 @@ std::vector<int64_t> getMinimalTilesCoveringGeometry(
     int32_t zoom,
     uint8_t maxZoomShift);
 
+std::vector<int64_t> getDissolvedTilesCoveringGeometry(
+    const geos::geom::Geometry& geometry,
+    int32_t zoom);
+
 bool isPointOrRectangle(const geos::geom::Geometry& geometry);
 
+/// Computes the centroid of a non-empty MultiPoint geometry on a sphere.
+/// Uses 3D Cartesian coordinates to properly average points on a spherical
+/// surface.
+/// @param geometry A MultiPoint geometry (must not be empty)
+/// @return A pair of (longitude, latitude) in degrees representing the centroid
+std::pair<double, double> computeSphericalCentroid(
+    const geos::geom::MultiPoint& multiPoint);
+
+/// Represents a point in 3D Cartesian coordinates, useful for spherical
+/// geometry calculations. Provides conversions to/from spherical coordinates
+/// (longitude, latitude).
+class CartesianPoint {
+ public:
+  /// Constructs a CartesianPoint from a spherical point (longitude, latitude)
+  /// in degrees. Assumes the point is on Earth's surface.
+  /// @param longitude Longitude in degrees (x-coordinate in spherical system)
+  /// @param latitude Latitude in degrees (y-coordinate in spherical system)
+  CartesianPoint(double longitude, double latitude);
+
+  /// Constructs a CartesianPoint from Cartesian coordinates.
+  /// @param x X-coordinate in Cartesian system
+  /// @param y Y-coordinate in Cartesian system
+  /// @param z Z-coordinate in Cartesian system
+  CartesianPoint(double x, double y, double z);
+
+  double getX() const {
+    return x_;
+  }
+  double getY() const {
+    return y_;
+  }
+  double getZ() const {
+    return z_;
+  }
+
+  /// Converts this Cartesian point back to spherical coordinates.
+  /// @return A pair of (longitude, latitude) in degrees
+  std::pair<double, double> toSphericalPoint() const;
+
+ private:
+  double x_;
+  double y_;
+  double z_;
+};
+
+double getSphericalLength(const geos::geom::LineString& lineString);
+
+double computeSphericalExcess(const geos::geom::Polygon& polygon);
+
 } // namespace facebook::velox::functions::geospatial
diff --git a/velox/functions/prestosql/json/CMakeLists.txt b/velox/functions/prestosql/json/CMakeLists.txt
index ad048feb1d9..c424023abfc 100644
--- a/velox/functions/prestosql/json/CMakeLists.txt
+++ b/velox/functions/prestosql/json/CMakeLists.txt
@@ -18,6 +18,13 @@ velox_add_library(
   JsonStringUtil.cpp
   SIMDJsonExtractor.cpp
   SIMDJsonUtil.cpp
+  HEADERS
+  JsonExtractor.h
+  JsonPathTokenizer.h
+  JsonStringUtil.h
+  SIMDJsonExtractor.h
+  SIMDJsonUtil.h
+  SIMDJsonWrapper.h
 )
 
 velox_link_libraries(velox_functions_json velox_functions_lib simdjson::simdjson)
diff --git a/velox/functions/prestosql/json/JsonExtractor.cpp b/velox/functions/prestosql/json/JsonExtractor.cpp
index 78f38a55e58..d77dec70116 100644
--- a/velox/functions/prestosql/json/JsonExtractor.cpp
+++ b/velox/functions/prestosql/json/JsonExtractor.cpp
@@ -27,7 +27,6 @@
 #include "velox/functions/prestosql/json/JsonPathTokenizer.h"
 
 namespace facebook::velox::functions {
-
 namespace {
 
 using JsonVector = std::vector<const folly::dynamic*>;
@@ -35,9 +34,9 @@ using JsonVector = std::vector<const folly::dynamic*>;
 class JsonExtractor {
  public:
   // Use this method to get an instance of JsonExtractor given a json path.
-  static JsonExtractor& getInstance(folly::StringPiece path) {
+  static JsonExtractor& getInstance(std::string_view path) {
     // Pre-process
-    auto trimedPath = folly::trimWhitespace(path).str();
+    std::string trimedPath = folly::trimWhitespace(path).str();
 
     std::shared_ptr<JsonExtractor> op;
     if (kExtractorCache.count(trimedPath)) {
@@ -184,8 +183,8 @@ bool isScalarType(const std::optional<folly::dynamic>& json) {
 } // namespace
 
 std::optional<folly::dynamic> jsonExtract(
-    folly::StringPiece json,
-    folly::StringPiece path) {
+    std::string_view json,
+    std::string_view path) {
   try {
     // If extractor fails to parse the path, this will throw a VeloxUserError,
     // and we want to let this exception bubble up to the client. We only catch
@@ -201,15 +200,9 @@ std::optional<folly::dynamic> jsonExtract(
   return std::nullopt;
 }
 
-std::optional<folly::dynamic> jsonExtract(
-    const std::string& json,
-    const std::string& path) {
-  return jsonExtract(folly::StringPiece(json), folly::StringPiece(path));
-}
-
-std::optional<folly::dynamic> jsonExtract(
+std::optional<folly::dynamic> jsonExtractFromDynamic(
     const folly::dynamic& json,
-    folly::StringPiece path) {
+    std::string_view path) {
   try {
     return JsonExtractor::getInstance(path).extract(json);
   } catch (const folly::json::parse_error&) {
@@ -218,8 +211,8 @@ std::optional<folly::dynamic> jsonExtract(
 }
 
 std::optional<std::string> jsonExtractScalar(
-    folly::StringPiece json,
-    folly::StringPiece path) {
+    std::string_view json,
+    std::string_view path) {
   auto res = jsonExtract(json, path);
   // Not a scalar value
   if (isScalarType(res)) {
@@ -232,13 +225,4 @@ std::optional<std::string> jsonExtractScalar(
   return std::nullopt;
 }
 
-std::optional<std::string> jsonExtractScalar(
-    const std::string& json,
-    const std::string& path) {
-  folly::StringPiece jsonPiece{json};
-  folly::StringPiece pathPiece{path};
-
-  return jsonExtractScalar(jsonPiece, pathPiece);
-}
-
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/json/JsonExtractor.h b/velox/functions/prestosql/json/JsonExtractor.h
index 1a751d2d207..5aad82c7fe4 100644
--- a/velox/functions/prestosql/json/JsonExtractor.h
+++ b/velox/functions/prestosql/json/JsonExtractor.h
@@ -18,57 +18,46 @@
 
 #include <string>
 
-#include "folly/Range.h"
 #include "folly/dynamic.h"
 
 namespace facebook::velox::functions {
 
-/**
- * Extract a json object from path
- * @param json: A json object
- * @param path: Path to locate a json object. Following operators are supported
- *              "$"      Root member of a json structure no matter it's an
- *                       object or an array
- *              "./[]"   Child operator to get a children object
- *              "[]"     Subscript operator for array and map
- *              "*"      Wildcard for [], get all the elements of an array
- * @return Return json string object on success.
- *         On invalid json path, returns std::nullopt (not json null) value
- *         On non-json value, returns the original value.
- * Example:
- * For the following example: ,
- * "{\"store\":,
- *   {\"fruit\":\\[{\"weight\":8,\"type\":\"apple\"},
- *                 {\"weight\":9,\"type\":\"pear\"}],
- *    \"bicycle\":{\"price\":19.95,\"color\":\"red\"}
- *   },
- *  \"email\":\"amy@only_for_json_udf_test.net\",
- *  \"owner\":\"amy\",
- * }",
- * jsonExtract(json, "$.owner") = "amy",
- * jsonExtract(json, "$.store.fruit[0]") =
- *    "{\"weight\":8,\"type\":\"apple\"}",
- * jsonExtract(json, "$.non_exist_key") = NULL
- * jsonExtract(json, "$.store.fruit[*].type") = "[\"apple\", \"pear\"]"
- */
+/// Extract a json object from path
+/// @param json: A json object
+/// @param path: Path to locate a json object. Following operators are supported
+///              "$"      Root member of a json structure no matter it's an
+///                       object or an array
+///              "./[]"   Child operator to get a children object
+///              "[]"     Subscript operator for array and map
+///              "*"      Wildcard for [], get all the elements of an array
+/// @return Return json string object on success.
+///         On invalid json path, returns std::nullopt (not json null) value
+///         On non-json value, returns the original value.
+/// Example:
+/// For the following example: ,
+/// "{\"store\":,
+///   {\"fruit\":\\[{\"weight\":8,\"type\":\"apple\"},
+///                 {\"weight\":9,\"type\":\"pear\"}],
+///    \"bicycle\":{\"price\":19.95,\"color\":\"red\"}
+///   },
+///  \"email\":\"amy@only_for_json_udf_test.net\",
+///  \"owner\":\"amy\",
+/// }",
+/// jsonExtract(json, "$.owner") = "amy",
+/// jsonExtract(json, "$.store.fruit[0]") =
+///    "{\"weight\":8,\"type\":\"apple\"}",
+/// jsonExtract(json, "$.non_exist_key") = NULL
+/// jsonExtract(json, "$.store.fruit[*].type") = "[\"apple\", \"pear\"]"
 std::optional<folly::dynamic> jsonExtract(
-    folly::StringPiece json,
-    folly::StringPiece path);
+    std::string_view json,
+    std::string_view path);
 
-std::optional<folly::dynamic> jsonExtract(
+std::optional<folly::dynamic> jsonExtractFromDynamic(
     const folly::dynamic& json,
-    folly::StringPiece path);
-
-std::optional<std::string> jsonExtractScalar(
-    folly::StringPiece json,
-    folly::StringPiece path);
-
-std::optional<folly::dynamic> jsonExtract(
-    const std::string& json,
-    const std::string& path);
+    std::string_view path);
 
 std::optional<std::string> jsonExtractScalar(
-    const std::string& json,
-    const std::string& path);
+    std::string_view json,
+    std::string_view path);
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/json/SIMDJsonExtractor.cpp b/velox/functions/prestosql/json/SIMDJsonExtractor.cpp
index 2749e3ac7b9..da5272d0180 100644
--- a/velox/functions/prestosql/json/SIMDJsonExtractor.cpp
+++ b/velox/functions/prestosql/json/SIMDJsonExtractor.cpp
@@ -19,7 +19,7 @@
 namespace facebook::velox::functions {
 
 /* static */ SIMDJsonExtractor& SIMDJsonExtractor::getInstance(
-    folly::StringPiece path) {
+    std::string_view path) {
   // Cache tokenize operations in JsonExtractor across invocations in the same
   // thread for the same JsonPath.
   thread_local static std::
diff --git a/velox/functions/prestosql/json/SIMDJsonExtractor.h b/velox/functions/prestosql/json/SIMDJsonExtractor.h
index e002cb6622b..59885c6799a 100644
--- a/velox/functions/prestosql/json/SIMDJsonExtractor.h
+++ b/velox/functions/prestosql/json/SIMDJsonExtractor.h
@@ -82,7 +82,7 @@ class SIMDJsonExtractor {
   /// Use this method to get an instance of SIMDJsonExtractor given a JSON path.
   /// Uses a thread local cache, therefore the caller must ensure the returned
   /// instance is not passed between threads.
-  static SIMDJsonExtractor& getInstance(folly::StringPiece path);
+  static SIMDJsonExtractor& getInstance(std::string_view path);
 
  private:
   // Shouldn't instantiate directly - use getInstance().
diff --git a/velox/functions/prestosql/json/tests/JsonExtractorTest.cpp b/velox/functions/prestosql/json/tests/JsonExtractorTest.cpp
index 19b9b50a86a..45aaaef8b0e 100644
--- a/velox/functions/prestosql/json/tests/JsonExtractorTest.cpp
+++ b/velox/functions/prestosql/json/tests/JsonExtractorTest.cpp
@@ -20,9 +20,6 @@
 #include "gtest/gtest.h"
 #include "velox/common/base/VeloxException.h"
 
-using facebook::velox::VeloxUserError;
-using facebook::velox::functions::jsonExtract;
-using facebook::velox::functions::jsonExtractScalar;
 using folly::json::parse_error;
 using namespace std::string_literals;
 
@@ -36,27 +33,30 @@ using namespace std::string_literals;
 #define EXPECT_SCALAR_VALUE_NULL(json, path) \
   EXPECT_FALSE(jsonExtractScalar(json, path).has_value())
 
-#define EXPECT_JSON_VALUE_EQ(json, path, ret)        \
-  {                                                  \
-    auto val = json_format(jsonExtract(json, path)); \
-    EXPECT_TRUE(val.has_value());                    \
-    EXPECT_EQ(val.value(), ret);                     \
+#define EXPECT_JSON_VALUE_EQ(json, path, ret)       \
+  {                                                 \
+    auto val = jsonFormat(jsonExtract(json, path)); \
+    EXPECT_TRUE(val.has_value());                   \
+    EXPECT_EQ(val.value(), ret);                    \
   }
 
 #define EXPECT_JSON_VALUE_NULL(json, path) \
-  EXPECT_FALSE(json_format(jsonExtract(json, path)).has_value())
+  EXPECT_FALSE(jsonFormat(jsonExtract(json, path)).has_value())
 
 #define EXPECT_THROW_INVALID_ARGUMENT(json, path) \
   EXPECT_THROW(jsonExtract(json, path), VeloxUserError)
 
+namespace facebook::velox::functions::test {
 namespace {
-std::optional<std::string> json_format(
+
+std::optional<std::string> jsonFormat(
     const std::optional<folly::dynamic>& json) {
   if (json.has_value()) {
     return folly::toJson(json.value());
   }
   return std::nullopt;
 }
+
 } // namespace
 
 TEST(JsonExtractorTest, generalJsonTest) {
@@ -92,60 +92,60 @@ TEST(JsonExtractorTest, generalJsonTest) {
         "owner":"amy"})DELIM";
   // clang-format on
   std::replace(json.begin(), json.end(), '\'', '\"');
-  auto res = json_format(jsonExtract(json, "$.store.fruit[0].weight"s));
+  auto res = jsonFormat(jsonExtract(json, "$.store.fruit[0].weight"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("8", res.value());
-  res = json_format(jsonExtract(json, "$.store.fruit[1].weight"s));
+  res = jsonFormat(jsonExtract(json, "$.store.fruit[1].weight"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("9", res.value());
   EXPECT_FALSE(
-      json_format(jsonExtract(json, "$.store.fruit[2].weight"s)).has_value());
-  res = json_format(jsonExtract(json, "$.store.fruit[*].weight"s));
+      jsonFormat(jsonExtract(json, "$.store.fruit[2].weight"s)).has_value());
+  res = jsonFormat(jsonExtract(json, "$.store.fruit[*].weight"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("[8,9]", res.value());
-  res = json_format(jsonExtract(json, "$.store.fruit[*].type"s));
+  res = jsonFormat(jsonExtract(json, "$.store.fruit[*].type"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("[\"apple\",\"pear\"]", res.value());
-  res = json_format(jsonExtract(json, "$.store.book[0].price"s));
+  res = jsonFormat(jsonExtract(json, "$.store.book[0].price"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("8.95", res.value());
-  res = json_format(jsonExtract(json, "$.store.book[2].category"s));
+  res = jsonFormat(jsonExtract(json, "$.store.book[2].category"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("\"fiction\"", res.value());
-  res = json_format(jsonExtract(json, "$.store.basket[1]"s));
+  res = jsonFormat(jsonExtract(json, "$.store.basket[1]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("[3,4]", res.value());
-  res = json_format(jsonExtract(json, "$.store.basket[0]"s));
+  res = jsonFormat(jsonExtract(json, "$.store.basket[0]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ(
       folly::parseJson("[1,2,{\"a\":\"x\",\"b\":\"y\"}]"),
       folly::parseJson(res.value()));
   EXPECT_FALSE(
-      json_format(jsonExtract(json, "$.store.baskets[1]"s)).has_value());
-  res = json_format(jsonExtract(json, "$[\"e mail\"]"s));
+      jsonFormat(jsonExtract(json, "$.store.baskets[1]"s)).has_value());
+  res = jsonFormat(jsonExtract(json, "$[\"e mail\"]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("\"amy@only_for_json_udf_test.net\"", res.value());
-  res = json_format(jsonExtract(json, "$.owner"s));
+  res = jsonFormat(jsonExtract(json, "$.owner"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("\"amy\"", res.value());
-  res = json_format(
+  res = jsonFormat(
       jsonExtract("[[1.1,[2.1,2.2]],2,{\"a\":\"b\"}]"s, "$[0][1][1]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("2.2", res.value());
-  res = json_format(jsonExtract("[1,2,{\"a\":\"b\"}]"s, "$[1]"s));
+  res = jsonFormat(jsonExtract("[1,2,{\"a\":\"b\"}]"s, "$[1]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("2", res.value());
-  res = json_format(jsonExtract("[1,2,{\"a\":\"b\"}]"s, "$[2]"s));
+  res = jsonFormat(jsonExtract("[1,2,{\"a\":\"b\"}]"s, "$[2]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("{\"a\":\"b\"}", res.value());
   EXPECT_FALSE(
-      json_format(jsonExtract("[1,2,{\"a\":\"b\"}]"s, "$[3]"s)).has_value());
-  res = json_format(jsonExtract("[{\"a\":\"b\"}]"s, "$[0]"s));
+      jsonFormat(jsonExtract("[1,2,{\"a\":\"b\"}]"s, "$[3]"s)).has_value());
+  res = jsonFormat(jsonExtract("[{\"a\":\"b\"}]"s, "$[0]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("{\"a\":\"b\"}", res.value());
   EXPECT_FALSE(
-      json_format(jsonExtract("[{\"a\":\"b\"}]"s, "$[2]"s)).has_value());
-  res = json_format(jsonExtract("{\"a\":\"b\"}"s, " $ "s));
+      jsonFormat(jsonExtract("[{\"a\":\"b\"}]"s, "$[2]"s)).has_value());
+  res = jsonFormat(jsonExtract("{\"a\":\"b\"}"s, " $ "s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("{\"a\":\"b\"}", res.value());
 
@@ -161,7 +161,7 @@ TEST(JsonExtractorTest, generalJsonTest) {
   expected.append("[{\"key\":3,\"value\":6},{\"key\":4,\"value\":8},")
       .append("{\"key\":5,\"value\":10}]]");
   auto expectedJson = folly::parseJson(expected);
-  res = json_format(jsonExtract(json2, "$[*]"s));
+  res = jsonFormat(jsonExtract(json2, "$[*]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ(expectedJson, folly::parseJson(res.value()));
 
@@ -170,31 +170,31 @@ TEST(JsonExtractorTest, generalJsonTest) {
       .append("{\"key\":3,\"value\":6},")
       .append("{\"key\":4,\"value\":8},{\"value\":10,\"key\":5}]");
   expectedJson = folly::parseJson(expected);
-  res = json_format(jsonExtract(json2, "$[*][*]"s));
+  res = jsonFormat(jsonExtract(json2, "$[*][*]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ(expectedJson, folly::parseJson(res.value()));
 
-  res = json_format(jsonExtract(json2, "$[*][*].key"s));
+  res = jsonFormat(jsonExtract(json2, "$[*][*].key"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("[1,2,3,4,5]", res.value());
 
   expected = "[{\"key\":1,\"value\":2},{\"key\":3,\"value\":6}]";
   expectedJson = folly::parseJson(expected);
-  res = json_format(jsonExtract(json2, "$[*][0]"s));
+  res = jsonFormat(jsonExtract(json2, "$[*][0]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ(expectedJson, folly::parseJson(res.value()));
 
   expected = "{\"key\":5,\"value\":10}";
   expectedJson = folly::parseJson(expected);
-  res = json_format(jsonExtract(json2, "$[*][2]"s));
+  res = jsonFormat(jsonExtract(json2, "$[*][2]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ(expectedJson, folly::parseJson(res.value()));
 
   // TEST WiteSpaces in Path and Json
-  res = json_format(jsonExtract(json2, "$[*][*].key"s));
+  res = jsonFormat(jsonExtract(json2, "$[*][*].key"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("[1,2,3,4,5]", res.value());
-  res = json_format(
+  res = jsonFormat(
       jsonExtract(" [ [1.1,[2.1,2.2]],2, {\"a\": \"b\"}]"s, " $[0][1][1]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("2.2", res.value());
@@ -476,10 +476,13 @@ TEST(JsonExtractorTest, reextractJsonTest) {
         "e mail":"amy@only_for_json_udf_test.net",
         "owner":"amy"})DELIM";
   auto originalJsonObj = jsonExtract(json, "$");
-  // extract the same json json by giving the root path
-  auto reExtractedJsonObj = jsonExtract(originalJsonObj.value(), "$");
+
+  // Extract the same json json by giving the root path.
+  auto reExtractedJsonObj =
+      jsonExtractFromDynamic(originalJsonObj.value(), "$");
   ASSERT_TRUE(reExtractedJsonObj.has_value());
-  // expect the re-extracted json object to be the same as the original jsonObj
+
+  // Expect the re-extracted json object to be the same as the original jsonObj.
   EXPECT_EQ(originalJsonObj.value(), reExtractedJsonObj.value());
 }
 
@@ -515,7 +518,9 @@ TEST(JsonExtractorTest, jsonMultipleExtractsTest) {
         "owner":"amy"})DELIM";
   auto extract1 = jsonExtract(json, "$.store");
   ASSERT_TRUE(extract1.has_value());
-  auto extract2 = jsonExtract(extract1.value(), "$.fruit");
+  auto extract2 = jsonExtractFromDynamic(extract1.value(), "$.fruit");
   ASSERT_TRUE(extract2.has_value());
   EXPECT_EQ(jsonExtract(json, "$.store.fruit").value(), extract2.value());
 }
+
+} // namespace facebook::velox::functions::test
diff --git a/velox/functions/prestosql/registration/ArrayConcatRegistration.cpp b/velox/functions/prestosql/registration/ArrayConcatRegistration.cpp
index b3e2faa0594..d9528d5c23c 100644
--- a/velox/functions/prestosql/registration/ArrayConcatRegistration.cpp
+++ b/velox/functions/prestosql/registration/ArrayConcatRegistration.cpp
@@ -34,6 +34,8 @@ inline void registerArrayConcatFunctions(const std::string& prefix) {
   registerFunction<
       ParameterBinder<ArrayConcatFunction, T>,
       Array<T>,
+      Array<T>,
+      Array<T>,
       Variadic<Array<T>>>({prefix + "concat"});
 }
 } // namespace
diff --git a/velox/functions/prestosql/registration/ArrayFunctionsRegistration.cpp b/velox/functions/prestosql/registration/ArrayFunctionsRegistration.cpp
index f3a1730e78c..c021499fef3 100644
--- a/velox/functions/prestosql/registration/ArrayFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/ArrayFunctionsRegistration.cpp
@@ -16,6 +16,7 @@
 
 #include <string>
 
+#include "velox/expression/ExprRewriteRegistry.h"
 #include "velox/functions/Registerer.h"
 #include "velox/functions/lib/ArrayRemoveNullFunction.h"
 #include "velox/functions/lib/ArrayShuffle.h"
@@ -24,12 +25,17 @@
 #include "velox/functions/prestosql/ArrayConstructor.h"
 #include "velox/functions/prestosql/ArrayFunctions.h"
 #include "velox/functions/prestosql/ArraySort.h"
+#include "velox/functions/prestosql/ArraySubset.h"
+#include "velox/functions/prestosql/DotProduct.h"
+#include "velox/functions/prestosql/L2Norm.h"
 #include "velox/functions/prestosql/WidthBucketArray.h"
 #include "velox/functions/prestosql/types/JsonRegistration.h"
+#include "velox/type/SimpleFunctionApi.h"
 
 namespace facebook::velox::functions {
 extern void registerArrayConcatFunctions(const std::string& prefix);
 extern void registerArrayNGramsFunctions(const std::string& prefix);
+extern void registerArraySplitIntoChunksFunctions(const std::string& prefix);
 
 template <typename T>
 inline void registerArrayMinMaxFunctions(const std::string& prefix) {
@@ -123,6 +129,15 @@ inline void registerArrayRemoveFunctions(const std::string& prefix) {
       {prefix + "array_remove"});
 }
 
+template <typename T>
+inline void registerArraySubsetFunctions(const std::string& prefix) {
+  registerFunction<
+      ParameterBinder<ArraySubsetFunction, T>,
+      Array<T>,
+      Array<T>,
+      Array<int32_t>>({prefix + "array_subset"});
+}
+
 void registerInternalArrayFunctions() {
   VELOX_REGISTER_VECTOR_FUNCTION(
       udf_$internal$canonicalize, "$internal$canonicalize");
@@ -158,18 +173,22 @@ void registerArrayFunctions(const std::string& prefix) {
       makeArrayShuffle,
       getMetadataForArrayShuffle());
 
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_array_sort, prefix + "array_sort");
-  VELOX_REGISTER_VECTOR_FUNCTION(
-      udf_array_sort_desc, prefix + "array_sort_desc");
-
+  exec::registerStatefulVectorFunction(
+      prefix + "array_sort", arraySortSignatures(true), makeArraySortAsc);
+  exec::registerStatefulVectorFunction(
+      prefix + "array_sort_desc",
+      arraySortSignatures(false),
+      makeArraySortDesc);
   VELOX_REGISTER_VECTOR_FUNCTION(udf_array_max_by, prefix + "array_max_by");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_array_min_by, prefix + "array_min_by");
 
   VELOX_REGISTER_VECTOR_FUNCTION(udf_array_flatten, prefix + "flatten");
 
-  exec::registerExpressionRewrite([prefix](const auto& expr) {
-    return rewriteArraySortCall(prefix, expr);
-  });
+  auto checker = std::make_shared<SimpleComparisonChecker>();
+  expression::ExprRewriteRegistry::instance().registerRewrite(
+      [prefix, checker](const auto& expr) {
+        return rewriteArraySortCall(prefix, expr, checker);
+      });
 
   VELOX_REGISTER_VECTOR_FUNCTION(udf_array_sum, prefix + "array_sum");
   exec::registerStatefulVectorFunction(
@@ -213,6 +232,7 @@ void registerArrayFunctions(const std::string& prefix) {
 
   registerArrayConcatFunctions(prefix);
   registerArrayNGramsFunctions(prefix);
+  registerArraySplitIntoChunksFunctions(prefix);
 
   registerArrayRemoveFunctions<int8_t>(prefix);
   registerArrayRemoveFunctions<int16_t>(prefix);
@@ -342,5 +362,155 @@ void registerArrayFunctions(const std::string& prefix) {
   registerArrayNormalizeFunctions<int64_t>(prefix);
   registerArrayNormalizeFunctions<float>(prefix);
   registerArrayNormalizeFunctions<double>(prefix);
+
+  registerArraySubsetFunctions<int8_t>(prefix);
+  registerArraySubsetFunctions<int16_t>(prefix);
+  registerArraySubsetFunctions<int32_t>(prefix);
+  registerArraySubsetFunctions<int64_t>(prefix);
+  registerArraySubsetFunctions<int128_t>(prefix);
+  registerArraySubsetFunctions<float>(prefix);
+  registerArraySubsetFunctions<double>(prefix);
+  registerArraySubsetFunctions<bool>(prefix);
+  registerArraySubsetFunctions<Timestamp>(prefix);
+  registerArraySubsetFunctions<Date>(prefix);
+  registerArraySubsetFunctions<Varbinary>(prefix);
+  registerArraySubsetFunctions<Generic<T1>>(prefix);
+  registerFunction<
+      ArraySubsetVarcharFunction,
+      Array<Varchar>,
+      Array<Varchar>,
+      Array<int32_t>>({prefix + "array_subset"});
+  registerFunction<
+      ArraySubsetGenericFunction,
+      Array<Generic<T1>>,
+      Array<Generic<T1>>,
+      Array<int32_t>>({prefix + "array_subset"});
+
+  // Register l2_norm function for arrays
+  registerFunction<ArrayL2NormFunction, double, Array<int8_t>>(
+      {prefix + "l2_norm"});
+  registerFunction<ArrayL2NormFunction, double, Array<int16_t>>(
+      {prefix + "l2_norm"});
+  registerFunction<ArrayL2NormFunction, double, Array<int32_t>>(
+      {prefix + "l2_norm"});
+  registerFunction<ArrayL2NormFunction, double, Array<int64_t>>(
+      {prefix + "l2_norm"});
+  registerFunction<ArrayL2NormFunction, double, Array<float>>(
+      {prefix + "l2_norm"});
+  registerFunction<ArrayL2NormFunction, double, Array<double>>(
+      {prefix + "l2_norm"});
+
+  // Register l2_norm function for maps with numeric values
+  registerFunction<
+      ParameterBinder<MapL2NormFunction, Varchar, int8_t>,
+      double,
+      Map<Varchar, int8_t>>({prefix + "l2_norm"});
+  registerFunction<
+      ParameterBinder<MapL2NormFunction, Varchar, int16_t>,
+      double,
+      Map<Varchar, int16_t>>({prefix + "l2_norm"});
+  registerFunction<
+      ParameterBinder<MapL2NormFunction, Varchar, int32_t>,
+      double,
+      Map<Varchar, int32_t>>({prefix + "l2_norm"});
+  registerFunction<
+      ParameterBinder<MapL2NormFunction, Varchar, int64_t>,
+      double,
+      Map<Varchar, int64_t>>({prefix + "l2_norm"});
+  registerFunction<
+      ParameterBinder<MapL2NormFunction, Varchar, float>,
+      double,
+      Map<Varchar, float>>({prefix + "l2_norm"});
+  registerFunction<
+      ParameterBinder<MapL2NormFunction, Varchar, double>,
+      double,
+      Map<Varchar, double>>({prefix + "l2_norm"});
+
+  // Register l2_norm function for maps with integer keys
+  registerFunction<
+      ParameterBinder<MapL2NormFunction, int32_t, int32_t>,
+      double,
+      Map<int32_t, int32_t>>({prefix + "l2_norm"});
+  registerFunction<
+      ParameterBinder<MapL2NormFunction, int32_t, int64_t>,
+      double,
+      Map<int32_t, int64_t>>({prefix + "l2_norm"});
+  registerFunction<
+      ParameterBinder<MapL2NormFunction, int32_t, float>,
+      double,
+      Map<int32_t, float>>({prefix + "l2_norm"});
+  registerFunction<
+      ParameterBinder<MapL2NormFunction, int32_t, double>,
+      double,
+      Map<int32_t, double>>({prefix + "l2_norm"});
+  registerFunction<
+      ParameterBinder<MapL2NormFunction, int64_t, int64_t>,
+      double,
+      Map<int64_t, int64_t>>({prefix + "l2_norm"});
+  registerFunction<
+      ParameterBinder<MapL2NormFunction, int64_t, double>,
+      double,
+      Map<int64_t, double>>({prefix + "l2_norm"});
+
+  // Register dot_product for integer arrays only.
+  // Float and double array versions already exist in
+  // MathematicalFunctionsRegistration.cpp (DotProductArray,
+  // DotProductFloatArray) with different semantics: they return NaN for empty
+  // arrays to maintain compatibility with cosine_similarity and other distance
+  // functions there. Integer versions here return 0 for empty arrays.
+  registerFunction<
+      ParameterBinder<DotProductFunction, int8_t>,
+      int64_t,
+      Array<int8_t>,
+      Array<int8_t>>({prefix + "dot_product"});
+  registerFunction<
+      ParameterBinder<DotProductFunction, int16_t>,
+      int64_t,
+      Array<int16_t>,
+      Array<int16_t>>({prefix + "dot_product"});
+  registerFunction<
+      ParameterBinder<DotProductFunction, int32_t>,
+      int64_t,
+      Array<int32_t>,
+      Array<int32_t>>({prefix + "dot_product"});
+  registerFunction<
+      ParameterBinder<DotProductFunction, int64_t>,
+      int64_t,
+      Array<int64_t>,
+      Array<int64_t>>({prefix + "dot_product"});
+
+  // Register dot_product for maps with integer keys
+  registerFunction<
+      ParameterBinder<MapDotProductFunction, int32_t, int64_t>,
+      int64_t,
+      Map<int32_t, int64_t>,
+      Map<int32_t, int64_t>>({prefix + "dot_product"});
+  registerFunction<
+      ParameterBinder<MapDotProductFunction, int64_t, int64_t>,
+      int64_t,
+      Map<int64_t, int64_t>,
+      Map<int64_t, int64_t>>({prefix + "dot_product"});
+  registerFunction<
+      ParameterBinder<MapDotProductFunction, int32_t, double>,
+      double,
+      Map<int32_t, double>,
+      Map<int32_t, double>>({prefix + "dot_product"});
+  registerFunction<
+      ParameterBinder<MapDotProductFunction, int64_t, double>,
+      double,
+      Map<int64_t, double>,
+      Map<int64_t, double>>({prefix + "dot_product"});
+
+  // Register dot_product for maps with varchar keys
+  registerFunction<
+      ParameterBinder<MapDotProductFunction, Varchar, int64_t>,
+      int64_t,
+      Map<Varchar, int64_t>,
+      Map<Varchar, int64_t>>({prefix + "dot_product"});
+  registerFunction<
+      ParameterBinder<MapDotProductFunction, Varchar, double>,
+      double,
+      Map<Varchar, double>,
+      Map<Varchar, double>>({prefix + "dot_product"});
 }
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/ArraySplitIntoChunksRegistration.cpp b/velox/functions/prestosql/registration/ArraySplitIntoChunksRegistration.cpp
new file mode 100644
index 00000000000..72264e4d4fa
--- /dev/null
+++ b/velox/functions/prestosql/registration/ArraySplitIntoChunksRegistration.cpp
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/Registerer.h"
+#include "velox/functions/prestosql/ArrayFunctions.h"
+
+namespace facebook::velox::functions {
+namespace {
+template <typename T>
+inline void registerArraySplitIntoChunksFunctions(const std::string& prefix) {
+  registerFunction<
+      ParameterBinder<ArraySplitIntoChunksFunction, T>,
+      Array<Array<T>>,
+      Array<T>,
+      int32_t>({prefix + "array_split_into_chunks"});
+}
+
+} // namespace
+void registerArraySplitIntoChunksFunctions(const std::string& prefix) {
+  registerArraySplitIntoChunksFunctions<int8_t>(prefix);
+  registerArraySplitIntoChunksFunctions<int16_t>(prefix);
+  registerArraySplitIntoChunksFunctions<int32_t>(prefix);
+  registerArraySplitIntoChunksFunctions<int64_t>(prefix);
+  registerArraySplitIntoChunksFunctions<int128_t>(prefix);
+  registerArraySplitIntoChunksFunctions<float>(prefix);
+  registerArraySplitIntoChunksFunctions<double>(prefix);
+  registerArraySplitIntoChunksFunctions<bool>(prefix);
+  registerArraySplitIntoChunksFunctions<Timestamp>(prefix);
+  registerArraySplitIntoChunksFunctions<Date>(prefix);
+  registerArraySplitIntoChunksFunctions<Varchar>(prefix);
+  registerArraySplitIntoChunksFunctions<Varbinary>(prefix);
+  registerArraySplitIntoChunksFunctions<Generic<T1>>(prefix);
+}
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/BinaryFunctionsRegistration.cpp b/velox/functions/prestosql/registration/BinaryFunctionsRegistration.cpp
index 9d8789dcaa2..e0e1ca1dd99 100644
--- a/velox/functions/prestosql/registration/BinaryFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/BinaryFunctionsRegistration.cpp
@@ -44,9 +44,15 @@ void registerSimpleFunctions(const std::string& prefix) {
       {prefix + "spooky_hash_v2_32"});
   registerFunction<SpookyHashV264Function, Varbinary, Varbinary>(
       {prefix + "spooky_hash_v2_64"});
+  registerFunction<Fnv1_32Function, int32_t, Varbinary>({prefix + "fnv1_32"});
+  registerFunction<Fnv1_64Function, int64_t, Varbinary>({prefix + "fnv1_64"});
+  registerFunction<Fnv1a_32Function, int32_t, Varbinary>({prefix + "fnv1a_32"});
+  registerFunction<Fnv1a_64Function, int64_t, Varbinary>({prefix + "fnv1a_64"});
 
   registerFunction<ToHexFunction, Varchar, Varbinary>({prefix + "to_hex"});
   registerFunction<FromHexFunction, Varbinary, Varchar>({prefix + "from_hex"});
+  registerFunction<FromHexFunction, Varbinary, Varbinary>(
+      {prefix + "from_hex"});
   registerFunction<ToBase64Function, Varchar, Varbinary>(
       {prefix + "to_base64"});
 
@@ -55,10 +61,17 @@ void registerSimpleFunctions(const std::string& prefix) {
   registerFunction<FromBase64Function, Varbinary, Varbinary>(
       {prefix + "from_base64"});
 
+  registerFunction<FromBase32Function, Varbinary, Varchar>(
+      {prefix + "from_base32"});
+  registerFunction<FromBase32Function, Varbinary, Varbinary>(
+      {prefix + "from_base32"});
+
   registerFunction<ToBase64UrlFunction, Varchar, Varbinary>(
       {prefix + "to_base64url"});
   registerFunction<FromBase64UrlFunction, Varbinary, Varchar>(
       {prefix + "from_base64url"});
+  registerFunction<FromBase64UrlFunction, Varbinary, Varbinary>(
+      {prefix + "from_base64url"});
 
   registerFunction<FromBigEndian32, int32_t, Varbinary>(
       {prefix + "from_big_endian_32"});
diff --git a/velox/functions/prestosql/registration/CMakeLists.txt b/velox/functions/prestosql/registration/CMakeLists.txt
index 6ccb08b3b05..90a30002fff 100644
--- a/velox/functions/prestosql/registration/CMakeLists.txt
+++ b/velox/functions/prestosql/registration/CMakeLists.txt
@@ -17,6 +17,7 @@ velox_add_library(
   ArrayConcatRegistration.cpp
   ArrayFunctionsRegistration.cpp
   ArrayNGramsRegistration.cpp
+  ArraySplitIntoChunksRegistration.cpp
   BinaryFunctionsRegistration.cpp
   BingTileFunctionsRegistration.cpp
   BitwiseFunctionsRegistration.cpp
@@ -30,21 +31,31 @@ velox_add_library(
   IntegerFunctionsRegistration.cpp
   FloatingPointFunctionsRegistration.cpp
   JsonFunctionsRegistration.cpp
+  KHyperLogLogFunctionsRegistration.cpp
   MapFunctionsRegistration.cpp
   MathematicalFunctionsRegistration.cpp
   MathematicalOperatorsRegistration.cpp
   ProbabilityTrigonometricFunctionsRegistration.cpp
   RegistrationFunctions.cpp
+  SetDigestFunctionsRegistration.cpp
   SfmSketchFunctionsRegistration.cpp
   StringFunctionsRegistration.cpp
   TDigestFunctionsRegistration.cpp
   QDigestFunctionsRegistration.cpp
   URLFunctionsRegistration.cpp
+  HEADERS
+  RegistrationFunctions.h
 )
 
 if(VELOX_ENABLE_GEO)
   velox_compile_definitions(velox_functions_prestosql PRIVATE VELOX_ENABLE_GEO)
-  velox_sources(velox_functions_prestosql PRIVATE GeometryFunctionsRegistration.cpp)
+  velox_sources(
+    velox_functions_prestosql
+    PRIVATE
+      GeometryFunctionsRegistration.cpp
+      S2FunctionsRegistration.cpp
+      SphericalGeographyFunctionsRegistration.cpp
+  )
 endif()
 
 if(VELOX_ENABLE_FAISS)
diff --git a/velox/functions/prestosql/registration/ComparisonFunctionsRegistration.cpp b/velox/functions/prestosql/registration/ComparisonFunctionsRegistration.cpp
index dab8925e3d0..f30c1dc2b7f 100644
--- a/velox/functions/prestosql/registration/ComparisonFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/ComparisonFunctionsRegistration.cpp
@@ -19,6 +19,8 @@
 #include "velox/functions/prestosql/types/IPAddressType.h"
 #include "velox/functions/prestosql/types/IPPrefixRegistration.h"
 #include "velox/functions/prestosql/types/IPPrefixType.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneRegistration.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneRegistration.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 
@@ -33,6 +35,8 @@ void registerNonSimdizableScalar(const std::vector<std::string>& aliases) {
   registerFunction<T, TReturn, Timestamp, Timestamp>(aliases);
   registerFunction<T, TReturn, TimestampWithTimezone, TimestampWithTimezone>(
       aliases);
+  registerFunction<T, TReturn, Time, Time>(aliases);
+  registerFunction<T, TReturn, TimeWithTimezone, TimeWithTimezone>(aliases);
   registerFunction<T, TReturn, IPAddress, IPAddress>(aliases);
 }
 } // namespace
@@ -41,6 +45,7 @@ void registerComparisonFunctions(const std::string& prefix) {
   // Comparison functions also need TimestampWithTimezoneType,
   // independent of DateTimeFunctions
   registerTimestampWithTimeZoneType();
+  registerTimeWithTimezoneType();
   registerIPAddressType();
   registerIPPrefixType();
 
@@ -94,6 +99,14 @@ void registerComparisonFunctions(const std::string& prefix) {
       {prefix + "between"});
   registerFunction<BetweenFunction, bool, Timestamp, Timestamp, Timestamp>(
       {prefix + "between"});
+  registerFunction<BetweenFunction, bool, Time, Time, Time>(
+      {prefix + "between"});
+  registerFunction<
+      BetweenFunction,
+      bool,
+      TimeWithTimezone,
+      TimeWithTimezone,
+      TimeWithTimezone>({prefix + "between"});
   registerFunction<
       BetweenFunction,
       bool,
diff --git a/velox/functions/prestosql/registration/DateTimeFunctionsRegistration.cpp b/velox/functions/prestosql/registration/DateTimeFunctionsRegistration.cpp
index d57faae1d11..06b6d1f9fa5 100644
--- a/velox/functions/prestosql/registration/DateTimeFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/DateTimeFunctionsRegistration.cpp
@@ -16,6 +16,7 @@
 
 #include "velox/functions/Registerer.h"
 #include "velox/functions/prestosql/DateTimeFunctions.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneRegistration.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneRegistration.h"
 
 namespace facebook::velox::functions {
@@ -89,6 +90,12 @@ void registerSimpleFunctions(const std::string& prefix) {
       {prefix + "to_unixtime"});
 
   registerFromUnixtime(prefix + "from_unixtime");
+  registerFunction<CurrentTimeFunction, TimeWithTimezone>(
+      {prefix + "current_time"});
+  registerFunction<CurrentTimezoneFunction, Varchar>(
+      {prefix + "current_timezone"});
+  registerFunction<CurrentTimestampFunction, TimestampWithTimezone>(
+      {prefix + "current_timestamp", prefix + "now"});
 
   registerFunction<DateFunction, Date, Varchar>({prefix + "date"});
   registerFunction<DateFunction, Date, Timestamp>({prefix + "date"});
@@ -146,6 +153,35 @@ void registerSimpleFunctions(const std::string& prefix) {
   registerTimestampPlusInterval<TimestampWithTimezone>({prefix + "plus"});
   registerTimestampMinusInterval<TimestampWithTimezone>({prefix + "minus"});
 
+  // Register Time + Interval and Interval + Time functions
+  registerFunction<TimePlusInterval, Time, Time, IntervalDayTime>(
+      {prefix + "plus"});
+
+  registerFunction<IntervalPlusTime, Time, IntervalDayTime, Time>(
+      {prefix + "plus"});
+
+  // Register Time - Interval function
+  registerFunction<TimeMinusInterval, Time, Time, IntervalDayTime>(
+      {prefix + "minus"});
+
+  // Register Time - Time function (returns IntervalDayTime)
+  registerFunction<TimeMinusFunction, IntervalDayTime, Time, Time>(
+      {prefix + "minus"});
+
+  // Use optimized vector function for Time + IntervalYearMonth (identity
+  // function)
+  exec::registerVectorFunction(
+      prefix + "plus",
+      TimeIntervalYearMonthVectorFunction::signaturesPlus(),
+      std::make_unique<TimeIntervalYearMonthVectorFunction>());
+
+  // Use optimized vector function for Time - IntervalYearMonth (identity
+  // function). Only supports (time, interval), not (interval, time).
+  exec::registerVectorFunction(
+      prefix + "minus",
+      TimeIntervalYearMonthVectorFunction::signaturesMinus(),
+      std::make_unique<TimeIntervalYearMonthVectorFunction>());
+
   registerFunction<
       TimestampMinusFunction,
       IntervalDayTime,
@@ -183,6 +219,7 @@ void registerSimpleFunctions(const std::string& prefix) {
   registerFunction<HourFunction, int64_t, Date>({prefix + "hour"});
   registerFunction<HourFunction, int64_t, TimestampWithTimezone>(
       {prefix + "hour"});
+  registerFunction<HourFunction, int64_t, Time>({prefix + "hour"});
   registerFunction<HourFromIntervalFunction, int64_t, IntervalDayTime>(
       {prefix + "hour"});
 
@@ -197,6 +234,7 @@ void registerSimpleFunctions(const std::string& prefix) {
   registerFunction<MinuteFunction, int64_t, Date>({prefix + "minute"});
   registerFunction<MinuteFunction, int64_t, TimestampWithTimezone>(
       {prefix + "minute"});
+  registerFunction<MinuteFunction, int64_t, Time>({prefix + "minute"});
   registerFunction<MinuteFromIntervalFunction, int64_t, IntervalDayTime>(
       {prefix + "minute"});
 
@@ -204,6 +242,7 @@ void registerSimpleFunctions(const std::string& prefix) {
   registerFunction<SecondFunction, int64_t, Date>({prefix + "second"});
   registerFunction<SecondFunction, int64_t, TimestampWithTimezone>(
       {prefix + "second"});
+  registerFunction<SecondFunction, int64_t, Time>({prefix + "second"});
   registerFunction<SecondFromIntervalFunction, int64_t, IntervalDayTime>(
       {prefix + "second"});
 
@@ -213,6 +252,8 @@ void registerSimpleFunctions(const std::string& prefix) {
       {prefix + "millisecond"});
   registerFunction<MillisecondFunction, int64_t, TimestampWithTimezone>(
       {prefix + "millisecond"});
+  registerFunction<MillisecondFunction, int64_t, Time>(
+      {prefix + "millisecond"});
   registerFunction<MillisecondFromIntervalFunction, int64_t, IntervalDayTime>(
       {prefix + "millisecond"});
 
@@ -225,6 +266,8 @@ void registerSimpleFunctions(const std::string& prefix) {
       TimestampWithTimezone,
       Varchar,
       TimestampWithTimezone>({prefix + "date_trunc"});
+  registerFunction<DateTruncFunction, Time, Varchar, Time>(
+      {prefix + "date_trunc"});
   registerFunction<DateAddFunction, Date, Varchar, int64_t, Date>(
       {prefix + "date_add"});
   registerFunction<DateAddFunction, Timestamp, Varchar, int64_t, Timestamp>(
@@ -235,6 +278,8 @@ void registerSimpleFunctions(const std::string& prefix) {
       Varchar,
       int64_t,
       TimestampWithTimezone>({prefix + "date_add"});
+  registerFunction<DateAddFunction, Time, Varchar, int64_t, Time>(
+      {prefix + "date_add"});
   registerFunction<DateDiffFunction, int64_t, Varchar, Date, Date>(
       {prefix + "date_diff"});
   registerFunction<DateDiffFunction, int64_t, Varchar, Timestamp, Timestamp>(
@@ -245,6 +290,8 @@ void registerSimpleFunctions(const std::string& prefix) {
       Varchar,
       TimestampWithTimezone,
       TimestampWithTimezone>({prefix + "date_diff"});
+  registerFunction<DateDiffFunction, int64_t, Varchar, Time, Time>(
+      {prefix + "date_diff"});
   registerFunction<DateFormatFunction, Varchar, Timestamp, Varchar>(
       {prefix + "date_format"});
   registerFunction<DateFormatFunction, Varchar, TimestampWithTimezone, Varchar>(
@@ -281,6 +328,12 @@ void registerSimpleFunctions(const std::string& prefix) {
       TimestampWithTimezone,
       Varchar>({prefix + "at_timezone"});
 
+  registerFunction<
+      AtTimezoneTimeWithTimezoneFunction,
+      TimeWithTimezone,
+      TimeWithTimezone,
+      Varchar>({prefix + "at_timezone"});
+
   registerFunction<ToMillisecondFunction, int64_t, IntervalDayTime>(
       {prefix + "to_milliseconds"});
 
@@ -288,15 +341,21 @@ void registerSimpleFunctions(const std::string& prefix) {
       {prefix + "xxhash64_internal"});
   registerFunction<XxHash64TimestampFunction, int64_t, Timestamp>(
       {prefix + "xxhash64_internal"});
+  registerFunction<XxHash64TimeFunction, int64_t, Time>(
+      {prefix + "xxhash64_internal"});
 
   registerFunction<ParseDurationFunction, IntervalDayTime, Varchar>(
       {prefix + "parse_duration"});
+
+  registerFunction<LocalTimeFunction, Time>({prefix + "localtime"});
+  registerFunction<LocalTimestampFunction, Timestamp>(
+      {prefix + "localtimestamp"});
 }
 } // namespace
 
 void registerDateTimeFunctions(const std::string& prefix) {
   registerTimestampWithTimeZoneType();
-
+  registerTimeWithTimezoneType();
   registerSimpleFunctions(prefix);
 }
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/GeneralFunctionsRegistration.cpp b/velox/functions/prestosql/registration/GeneralFunctionsRegistration.cpp
index a33d0a62a6b..16d44eae2b6 100644
--- a/velox/functions/prestosql/registration/GeneralFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/GeneralFunctionsRegistration.cpp
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/expression/ExprConstants.h"
 #include "velox/expression/RegisterSpecialForm.h"
 #include "velox/functions/Registerer.h"
 #include "velox/functions/lib/IsNull.h"
@@ -22,6 +23,7 @@
 #include "velox/functions/prestosql/InPredicate.h"
 #include "velox/functions/prestosql/Reduce.h"
 #include "velox/functions/prestosql/types/IPAddressType.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 
 namespace facebook::velox::functions {
@@ -59,6 +61,8 @@ void registerAllGreatestLeastFunctions(const std::string& prefix) {
   registerGreatestLeastFunction<Timestamp>(prefix);
   registerGreatestLeastFunction<TimestampWithTimezone>(prefix);
   registerGreatestLeastFunction<IPAddress>(prefix);
+  registerGreatestLeastFunction<Time>(prefix);
+  registerGreatestLeastFunction<TimeWithTimezone>(prefix);
 }
 } // namespace
 
@@ -78,7 +82,7 @@ void registerAllSpecialFormGeneralFunctions() {
       bool,
       Generic<T1>,
       Variadic<Generic<T1>>>({"in"});
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_concat_row, "row_constructor");
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_concat_row, expression::kRowConstructor);
   registerIsNullFunction("is_null");
 }
 
@@ -87,6 +91,8 @@ void registerGeneralFunctions(const std::string& prefix) {
   registerElementAtFunction(prefix + "element_at", true);
 
   VELOX_REGISTER_VECTOR_FUNCTION(udf_transform, prefix + "transform");
+  VELOX_REGISTER_VECTOR_FUNCTION(
+      udf_transform_with_index, prefix + "transform_with_index");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_reduce, prefix + "reduce");
   registerReduceRewrites(prefix);
   VELOX_REGISTER_VECTOR_FUNCTION(udf_array_filter, prefix + "filter");
diff --git a/velox/functions/prestosql/registration/GeometryFunctionsRegistration.cpp b/velox/functions/prestosql/registration/GeometryFunctionsRegistration.cpp
index 8b35af9e4e7..478b568a252 100644
--- a/velox/functions/prestosql/registration/GeometryFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/GeometryFunctionsRegistration.cpp
@@ -19,6 +19,7 @@
 #include "velox/functions/prestosql/GeometryFunctions.h"
 #include "velox/functions/prestosql/types/BingTileType.h"
 #include "velox/functions/prestosql/types/GeometryRegistration.h"
+#include "velox/functions/prestosql/types/SphericalGeographyRegistration.h"
 
 namespace facebook::velox::functions {
 
@@ -31,10 +32,35 @@ void registerConstructors(const std::string& prefix) {
       {{prefix + "ST_GeomFromBinary"}});
   registerFunction<StAsTextFunction, Varchar, Geometry>(
       {{prefix + "ST_AsText"}});
+  registerFunction<SphericalAsTextFunction, Varchar, SphericalGeography>(
+      {{prefix + "ST_AsText"}});
   registerFunction<StAsBinaryFunction, Varbinary, Geometry>(
       {{prefix + "ST_AsBinary"}});
   registerFunction<StPointFunction, Geometry, double, double>(
       {{prefix + "ST_Point"}});
+  registerFunction<StLineFromTextFunction, Geometry, Varchar>(
+      {{prefix + "ST_LineFromText"}});
+  registerFunction<StLineStringFunction, Geometry, Array<Geometry>>(
+      {{prefix + "ST_LineString"}});
+  registerFunction<StMultiPointFunction, Geometry, Array<Geometry>>(
+      {{prefix + "ST_MultiPoint"}});
+  registerFunction<ToSphericalGeographyFunction, SphericalGeography, Geometry>(
+      {{prefix + "to_spherical_geography"}});
+  registerFunction<ToGeometryFunction, Geometry, SphericalGeography>(
+      {{prefix + "to_geometry"}});
+  registerFunction<
+      StSphericalCentroidFunction,
+      SphericalGeography,
+      SphericalGeography>({{prefix + "st_centroid"}});
+  registerFunction<
+      StSphericalDistanceFunction,
+      double,
+      SphericalGeography,
+      SphericalGeography>({{prefix + "st_distance"}});
+  registerFunction<StSphericalLengthFunction, double, SphericalGeography>(
+      {{prefix + "st_length"}});
+  registerFunction<StSphericalAreaFunction, double, SphericalGeography>(
+      {{prefix + "st_area"}});
 }
 
 void registerRelationPredicates(const std::string& prefix) {
@@ -120,7 +146,7 @@ void registerAccessors(const std::string& prefix) {
       {{prefix + "ST_InteriorRingN"}});
   registerFunction<StNumGeometriesFunction, int32_t, Geometry>(
       {{prefix + "ST_NumGeometries"}});
-  registerFunction<StNumInteriorRingFunction, int32_t, Geometry>(
+  registerFunction<StNumInteriorRingFunction, int64_t, Geometry>(
       {{prefix + "ST_NumInteriorRing"}});
   registerFunction<StConvexHullFunction, Geometry, Geometry>(
       {{prefix + "ST_ConvexHull"}});
@@ -143,7 +169,7 @@ void registerAccessors(const std::string& prefix) {
       std::make_unique<StCoordDimFunction>());
   registerFunction<StPointsFunction, Array<Geometry>, Geometry>(
       {{prefix + "ST_Points"}});
-  registerFunction<StNumPointsFunction, int32_t, Geometry>(
+  registerFunction<StNumPointsFunction, int64_t, Geometry>(
       {{prefix + "ST_NumPoints"}});
   registerFunction<StInteriorRingsFunction, Array<Geometry>, Geometry>(
       {{prefix + "ST_InteriorRings"}});
@@ -153,6 +179,8 @@ void registerAccessors(const std::string& prefix) {
       {{prefix + "geometry_as_geojson"}});
   registerFunction<GeometryFromGeoJsonFunction, Geometry, Varchar>(
       {{prefix + "geometry_from_geojson"}});
+  registerFunction<GeometryUnionFunction, Geometry, Array<Geometry>>(
+      {{prefix + "geometry_union"}});
   registerFunction<
       GeometryNearestPointsFunction,
       Array<Geometry>,
@@ -179,12 +207,18 @@ void registerBingTileGeometryFunctions(const std::string& prefix) {
       Array<BingTile>,
       Geometry,
       int32_t>({{prefix + "geometry_to_bing_tiles"}});
+  registerFunction<
+      GeometryToDissolvedBingTilesFunction,
+      Array<BingTile>,
+      Geometry,
+      int32_t>({{prefix + "geometry_to_dissolved_bing_tiles"}});
 }
 
 } // namespace
 
 void registerGeometryFunctions(const std::string& prefix) {
   registerGeometryType();
+  registerSphericalGeographyType();
   registerConstructors(prefix);
   registerRelationPredicates(prefix);
   registerOverlayOperations(prefix);
diff --git a/velox/functions/prestosql/registration/HyperLogFunctionsRegistration.cpp b/velox/functions/prestosql/registration/HyperLogFunctionsRegistration.cpp
index 67e2294bcf4..772e0d31d87 100644
--- a/velox/functions/prestosql/registration/HyperLogFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/HyperLogFunctionsRegistration.cpp
@@ -31,5 +31,8 @@ void registerHyperLogFunctions(const std::string& prefix) {
       Constant<double>>({prefix + "empty_approx_set"});
   registerFunction<EmptyApproxSetFunction, HyperLogLog>(
       {prefix + "empty_approx_set"});
+
+  registerFunction<MergeHllFunction, HyperLogLog, Array<HyperLogLog>>(
+      {prefix + "merge_hll"});
 }
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/KHyperLogLogFunctionsRegistration.cpp b/velox/functions/prestosql/registration/KHyperLogLogFunctionsRegistration.cpp
new file mode 100644
index 00000000000..c26d069d569
--- /dev/null
+++ b/velox/functions/prestosql/registration/KHyperLogLogFunctionsRegistration.cpp
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/Registerer.h"
+#include "velox/functions/prestosql/KHyperLogLogFunctions.h"
+#include "velox/functions/prestosql/types/KHyperLogLogRegistration.h"
+
+namespace facebook::velox::functions {
+
+void registerKHyperLogLogFunctions(const std::string& prefix) {
+  registerKHyperLogLogType();
+
+  registerFunction<KHyperLogLogCardinalityFunction, int64_t, KHyperLogLog>(
+      {prefix + "cardinality"});
+
+  registerFunction<
+      KHyperLogLogIntersectionCardinalityFunction,
+      int64_t,
+      KHyperLogLog,
+      KHyperLogLog>({prefix + "intersection_cardinality"});
+
+  registerFunction<
+      KHyperLogLogJaccardIndexFunction,
+      double,
+      KHyperLogLog,
+      KHyperLogLog>({prefix + "jaccard_index"});
+
+  registerFunction<
+      KHyperLogLogReidentificationPotentialFunction,
+      double,
+      KHyperLogLog,
+      int64_t>({prefix + "reidentification_potential"});
+
+  registerFunction<
+      KHyperLogLogUniquenessDistributionFunction,
+      Map<int64_t, double>,
+      KHyperLogLog>({prefix + "uniqueness_distribution"});
+
+  registerFunction<
+      KHyperLogLogUniquenessDistributionFunction,
+      Map<int64_t, double>,
+      KHyperLogLog,
+      int64_t>({prefix + "uniqueness_distribution"});
+
+  registerFunction<
+      MergeKHyperLogLogFunction,
+      KHyperLogLog,
+      Array<KHyperLogLog>>({prefix + "merge_khll"});
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/MapFunctionsRegistration.cpp b/velox/functions/prestosql/registration/MapFunctionsRegistration.cpp
index aba5494aed8..8aff8e06641 100644
--- a/velox/functions/prestosql/registration/MapFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/MapFunctionsRegistration.cpp
@@ -17,51 +17,222 @@
 #include "velox/expression/VectorFunction.h"
 #include "velox/functions/Registerer.h"
 #include "velox/functions/lib/MapConcat.h"
+#include "velox/functions/lib/MapFromEntries.h"
 #include "velox/functions/prestosql/Map.h"
+#include "velox/functions/prestosql/MapAppend.h"
+#include "velox/functions/prestosql/MapExcept.h"
 #include "velox/functions/prestosql/MapFunctions.h"
+#include "velox/functions/prestosql/MapIntersect.h"
 #include "velox/functions/prestosql/MapKeysByTopNValues.h"
+#include "velox/functions/prestosql/MapKeysOverlap.h"
 #include "velox/functions/prestosql/MapNormalize.h"
 #include "velox/functions/prestosql/MapSubset.h"
+#include "velox/functions/prestosql/MapSubsetKeyInRange.h"
 #include "velox/functions/prestosql/MapTopN.h"
 #include "velox/functions/prestosql/MapTopNKeys.h"
 #include "velox/functions/prestosql/MapTopNValues.h"
+#include "velox/functions/prestosql/MapTrimValues.h"
+#include "velox/functions/prestosql/MapUpdate.h"
+#include "velox/functions/prestosql/MapValuesInRange.h"
 #include "velox/functions/prestosql/MultimapFromEntries.h"
+#include "velox/functions/prestosql/RemapKeys.h"
 
 namespace facebook::velox::functions {
 
 namespace {
+template <typename T>
+void registerRemapKeysPrimitive(const std::string& prefix) {
+  registerFunction<
+      ParameterBinder<RemapKeysPrimitiveFunction, T>,
+      Map<T, Generic<T1>>,
+      Map<T, Generic<T1>>,
+      Array<T>,
+      Array<T>>({prefix + "remap_keys"});
+}
+
+void registerRemapKeys(const std::string& prefix) {
+  registerRemapKeysPrimitive<bool>(prefix);
+  registerRemapKeysPrimitive<int8_t>(prefix);
+  registerRemapKeysPrimitive<int16_t>(prefix);
+  registerRemapKeysPrimitive<int32_t>(prefix);
+  registerRemapKeysPrimitive<int64_t>(prefix);
+  registerRemapKeysPrimitive<float>(prefix);
+  registerRemapKeysPrimitive<double>(prefix);
+  registerRemapKeysPrimitive<Timestamp>(prefix);
+  registerRemapKeysPrimitive<Date>(prefix);
+
+  registerFunction<
+      RemapKeysVarcharFunction,
+      Map<Varchar, Generic<T1>>,
+      Map<Varchar, Generic<T1>>,
+      Array<Varchar>,
+      Array<Varchar>>({prefix + "remap_keys"});
+
+  registerFunction<
+      RemapKeysFunction,
+      Map<Generic<T1>, Generic<T2>>,
+      Map<Generic<T1>, Generic<T2>>,
+      Array<Generic<T1>>,
+      Array<Generic<T1>>>({prefix + "remap_keys"});
+}
+
+template <typename T>
+void registerMapIntersectPrimitive(const std::string& prefix) {
+  registerFunction<
+      ParameterBinder<MapIntersectPrimitiveFunction, T>,
+      Map<T, Generic<T1>>,
+      Map<T, Generic<T1>>,
+      Array<T>>({prefix + "map_intersect"});
+}
+
+void registerMapIntersect(const std::string& prefix) {
+  registerMapIntersectPrimitive<bool>(prefix);
+  registerMapIntersectPrimitive<int8_t>(prefix);
+  registerMapIntersectPrimitive<int16_t>(prefix);
+  registerMapIntersectPrimitive<int32_t>(prefix);
+  registerMapIntersectPrimitive<int64_t>(prefix);
+  registerMapIntersectPrimitive<float>(prefix);
+  registerMapIntersectPrimitive<double>(prefix);
+  registerMapIntersectPrimitive<Timestamp>(prefix);
+  registerMapIntersectPrimitive<Date>(prefix);
+
+  registerFunction<
+      MapIntersectVarcharFunction,
+      Map<Varchar, Generic<T1>>,
+      Map<Varchar, Generic<T1>>,
+      Array<Varchar>>({prefix + "map_intersect"});
+}
 
 template <typename T>
-void registerMapSubsetPrimitive(const std::string& prefix) {
+void registerMapExceptPrimitive(const std::string& prefix) {
   registerFunction<
-      ParameterBinder<MapSubsetPrimitiveFunction, T>,
+      ParameterBinder<MapExceptPrimitiveFunction, T>,
       Map<T, Generic<T1>>,
       Map<T, Generic<T1>>,
-      Array<T>>({prefix + "map_subset"});
+      Array<T>>({prefix + "map_except"});
 }
 
-void registerMapSubset(const std::string& prefix) {
-  registerMapSubsetPrimitive<bool>(prefix);
-  registerMapSubsetPrimitive<int8_t>(prefix);
-  registerMapSubsetPrimitive<int16_t>(prefix);
-  registerMapSubsetPrimitive<int32_t>(prefix);
-  registerMapSubsetPrimitive<int64_t>(prefix);
-  registerMapSubsetPrimitive<float>(prefix);
-  registerMapSubsetPrimitive<double>(prefix);
-  registerMapSubsetPrimitive<Timestamp>(prefix);
-  registerMapSubsetPrimitive<Date>(prefix);
+void registerMapExcept(const std::string& prefix) {
+  registerMapExceptPrimitive<bool>(prefix);
+  registerMapExceptPrimitive<int8_t>(prefix);
+  registerMapExceptPrimitive<int16_t>(prefix);
+  registerMapExceptPrimitive<int32_t>(prefix);
+  registerMapExceptPrimitive<int64_t>(prefix);
+  registerMapExceptPrimitive<float>(prefix);
+  registerMapExceptPrimitive<double>(prefix);
+  registerMapExceptPrimitive<Timestamp>(prefix);
+  registerMapExceptPrimitive<Date>(prefix);
 
   registerFunction<
-      MapSubsetVarcharFunction,
+      MapExceptVarcharFunction,
       Map<Varchar, Generic<T1>>,
       Map<Varchar, Generic<T1>>,
-      Array<Varchar>>({prefix + "map_subset"});
+      Array<Varchar>>({prefix + "map_except"});
+}
+
+template <typename T>
+void registerMapKeysOverlapPrimitive(const std::string& prefix) {
+  registerFunction<
+      ParameterBinder<MapKeysOverlapPrimitiveFunction, T>,
+      bool,
+      Map<T, Generic<T1>>,
+      Array<T>>({prefix + "map_keys_overlap"});
+}
+
+void registerMapKeysOverlap(const std::string& prefix) {
+  registerMapKeysOverlapPrimitive<bool>(prefix);
+  registerMapKeysOverlapPrimitive<int8_t>(prefix);
+  registerMapKeysOverlapPrimitive<int16_t>(prefix);
+  registerMapKeysOverlapPrimitive<int32_t>(prefix);
+  registerMapKeysOverlapPrimitive<int64_t>(prefix);
+  registerMapKeysOverlapPrimitive<float>(prefix);
+  registerMapKeysOverlapPrimitive<double>(prefix);
+  registerMapKeysOverlapPrimitive<Timestamp>(prefix);
+  registerMapKeysOverlapPrimitive<Date>(prefix);
+
+  registerFunction<
+      MapKeysOverlapVarcharFunction,
+      bool,
+      Map<Varchar, Generic<T1>>,
+      Array<Varchar>>({prefix + "map_keys_overlap"});
 
   registerFunction<
-      MapSubsetFunction,
+      MapKeysOverlapFunction,
+      bool,
+      Map<Generic<T1>, Generic<T2>>,
+      Array<Generic<T1>>>({prefix + "map_keys_overlap"});
+}
+
+template <typename Key>
+void registerMapAppendPrimitive(const std::string& prefix) {
+  registerFunction<
+      ParameterBinder<MapAppendPrimitiveFunction, Key>,
+      Map<Key, Generic<T1>>,
+      Map<Key, Generic<T1>>,
+      Array<Key>,
+      Array<Generic<T1>>>({prefix + "map_append"});
+}
+
+void registerMapAppend(const std::string& prefix) {
+  registerMapAppendPrimitive<bool>(prefix);
+  registerMapAppendPrimitive<int8_t>(prefix);
+  registerMapAppendPrimitive<int16_t>(prefix);
+  registerMapAppendPrimitive<int32_t>(prefix);
+  registerMapAppendPrimitive<int64_t>(prefix);
+  registerMapAppendPrimitive<float>(prefix);
+  registerMapAppendPrimitive<double>(prefix);
+  registerMapAppendPrimitive<Timestamp>(prefix);
+  registerMapAppendPrimitive<Date>(prefix);
+
+  registerFunction<
+      MapAppendVarcharFunction,
+      Map<Varchar, Generic<T1>>,
+      Map<Varchar, Generic<T1>>,
+      Array<Varchar>,
+      Array<Generic<T1>>>({prefix + "map_append"});
+
+  registerFunction<
+      MapAppendFunction,
+      Map<Generic<T1>, Generic<T2>>,
+      Map<Generic<T1>, Generic<T2>>,
+      Array<Generic<T1>>,
+      Array<Generic<T2>>>({prefix + "map_append"});
+}
+
+template <typename Key>
+void registerMapUpdatePrimitive(const std::string& prefix) {
+  registerFunction<
+      ParameterBinder<MapUpdatePrimitiveFunction, Key>,
+      Map<Key, Generic<T1>>,
+      Map<Key, Generic<T1>>,
+      Array<Key>,
+      Array<Generic<T1>>>({prefix + "map_update"});
+}
+
+void registerMapUpdate(const std::string& prefix) {
+  registerMapUpdatePrimitive<bool>(prefix);
+  registerMapUpdatePrimitive<int8_t>(prefix);
+  registerMapUpdatePrimitive<int16_t>(prefix);
+  registerMapUpdatePrimitive<int32_t>(prefix);
+  registerMapUpdatePrimitive<int64_t>(prefix);
+  registerMapUpdatePrimitive<float>(prefix);
+  registerMapUpdatePrimitive<double>(prefix);
+  registerMapUpdatePrimitive<Timestamp>(prefix);
+  registerMapUpdatePrimitive<Date>(prefix);
+
+  registerFunction<
+      MapUpdateVarcharFunction,
+      Map<Varchar, Generic<T1>>,
+      Map<Varchar, Generic<T1>>,
+      Array<Varchar>,
+      Array<Generic<T1>>>({prefix + "map_update"});
+
+  registerFunction<
+      MapUpdateFunction,
       Map<Generic<T1>, Generic<T2>>,
       Map<Generic<T1>, Generic<T2>>,
-      Array<Generic<T1>>>({prefix + "map_subset"});
+      Array<Generic<T1>>,
+      Array<Generic<T2>>>({prefix + "map_update"});
 }
 
 void registerMapRemoveNullValues(const std::string& prefix) {
@@ -88,8 +259,9 @@ void registerMapFunctions(const std::string& prefix) {
       udf_transform_values, prefix + "transform_values");
   registerMapFunction(prefix + "map", false /*allowDuplicateKeys*/);
   VELOX_REGISTER_VECTOR_FUNCTION(udf_map_entries, prefix + "map_entries");
-  VELOX_REGISTER_VECTOR_FUNCTION(
-      udf_map_from_entries, prefix + "map_from_entries");
+  registerMapFromEntriesFunction(
+      prefix + "map_from_entries", /*throwForNull=*/true);
+
   VELOX_REGISTER_VECTOR_FUNCTION(udf_map_keys, prefix + "map_keys");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_map_values, prefix + "map_values");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_map_zip_with, prefix + "map_zip_with");
@@ -103,6 +275,13 @@ void registerMapFunctions(const std::string& prefix) {
   VELOX_REGISTER_VECTOR_FUNCTION(
       udf_no_values_match, prefix + "no_values_match");
 
+  VELOX_REGISTER_VECTOR_FUNCTION(
+      udf_map_values_all_match, prefix + "map_values_all_match");
+  VELOX_REGISTER_VECTOR_FUNCTION(
+      udf_map_values_any_match, prefix + "map_values_any_match");
+  VELOX_REGISTER_VECTOR_FUNCTION(
+      udf_map_values_none_match, prefix + "map_values_none_match");
+
   registerMapConcatFunction(prefix + "map_concat");
 
   registerFunction<
@@ -134,7 +313,19 @@ void registerMapFunctions(const std::string& prefix) {
       Map<Orderable<T1>, Orderable<T2>>,
       int64_t>({prefix + "map_top_n_values"});
 
-  registerMapSubset(prefix);
+  registerMapSubset(prefix + "map_subset");
+
+  registerRemapKeys(prefix);
+
+  registerMapIntersect(prefix);
+
+  registerMapExcept(prefix);
+
+  registerMapKeysOverlap(prefix);
+
+  registerMapAppend(prefix);
+
+  registerMapUpdate(prefix);
 
   registerMapRemoveNullValues(prefix);
 
@@ -144,6 +335,76 @@ void registerMapFunctions(const std::string& prefix) {
       MapNormalizeFunction,
       Map<Varchar, double>,
       Map<Varchar, double>>({prefix + "map_normalize"});
+
+  // Register map_values_in_range for various key/value type combinations
+  // Helper lambda to reduce registration boilerplate
+  auto registerMapValuesInRange = [&prefix]<typename K, typename V>() {
+    registerFunction<
+        ParameterBinder<MapValuesInRangeFunction, K, V>,
+        Map<K, V>,
+        Map<K, V>,
+        V,
+        V>({prefix + "map_values_in_range"});
+  };
+
+  registerMapValuesInRange.template operator()<int64_t, int64_t>();
+  registerMapValuesInRange.template operator()<int64_t, double>();
+  registerMapValuesInRange.template operator()<int64_t, float>();
+  registerMapValuesInRange.template operator()<int32_t, int32_t>();
+  registerMapValuesInRange.template operator()<int32_t, double>();
+  registerMapValuesInRange.template operator()<int32_t, float>();
+  registerMapValuesInRange.template operator()<Varchar, int64_t>();
+  registerMapValuesInRange.template operator()<Varchar, double>();
+  registerMapValuesInRange.template operator()<Varchar, float>();
+
+  // Generic fallback for complex key types
+  registerFunction<
+      MapValuesInRangeGenericFunction,
+      Map<Generic<T1>, double>,
+      Map<Generic<T1>, double>,
+      double,
+      double>({prefix + "map_values_in_range"});
+
+  registerFunction<
+      MapTrimValuesFunction,
+      Map<Generic<T1>, Array<Generic<T2>>>,
+      Map<Generic<T1>, Array<Generic<T2>>>,
+      int64_t>({prefix + "map_trim_values"});
+
+  // Register map_subset_key_in_range for primitive key types.
+  // Boolean keys are intentionally not supported because element_at on the
+  // two possible keys provides the same functionality.
+  auto registerMapSubsetKeyInRangePrimitive = [&prefix]<typename K>() {
+    registerFunction<
+        ParameterBinder<MapSubsetKeyInRangeFunction, K>,
+        Map<K, Generic<T1>>,
+        Map<K, Generic<T1>>,
+        K,
+        K>({prefix + "map_subset_key_in_range"});
+  };
+
+  registerMapSubsetKeyInRangePrimitive.template operator()<int8_t>();
+  registerMapSubsetKeyInRangePrimitive.template operator()<int16_t>();
+  registerMapSubsetKeyInRangePrimitive.template operator()<int32_t>();
+  registerMapSubsetKeyInRangePrimitive.template operator()<int64_t>();
+  registerMapSubsetKeyInRangePrimitive.template operator()<float>();
+  registerMapSubsetKeyInRangePrimitive.template operator()<double>();
+  registerMapSubsetKeyInRangePrimitive.template operator()<Timestamp>();
+  registerMapSubsetKeyInRangePrimitive.template operator()<Date>();
+
+  registerFunction<
+      MapSubsetKeyInRangeVarcharFunction,
+      Map<Varchar, Generic<T1>>,
+      Map<Varchar, Generic<T1>>,
+      Varchar,
+      Varchar>({prefix + "map_subset_key_in_range"});
+
+  registerFunction<
+      MapSubsetKeyInRangeGenericFunction,
+      Map<Orderable<T1>, Generic<T2>>,
+      Map<Orderable<T1>, Generic<T2>>,
+      Orderable<T1>,
+      Orderable<T1>>({prefix + "map_subset_key_in_range"});
 }
 
 void registerMapAllowingDuplicates(
diff --git a/velox/functions/prestosql/registration/MathematicalFunctionsRegistration.cpp b/velox/functions/prestosql/registration/MathematicalFunctionsRegistration.cpp
index aedf99a8965..5e46780b92d 100644
--- a/velox/functions/prestosql/registration/MathematicalFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/MathematicalFunctionsRegistration.cpp
@@ -154,6 +154,7 @@ void registerMathematicalFunctions(const std::string& prefix = "") {
   VELOX_REGISTER_VECTOR_FUNCTION(udf_not, prefix + "not");
 
   registerDecimalFloor(prefix);
+  registerDecimalCeil(prefix);
   registerDecimalRound(prefix);
   registerDecimalTruncate(prefix);
 }
diff --git a/velox/functions/prestosql/registration/MathematicalOperatorsRegistration.cpp b/velox/functions/prestosql/registration/MathematicalOperatorsRegistration.cpp
index bab24264a6e..459b1c473f4 100644
--- a/velox/functions/prestosql/registration/MathematicalOperatorsRegistration.cpp
+++ b/velox/functions/prestosql/registration/MathematicalOperatorsRegistration.cpp
@@ -91,6 +91,8 @@ void registerMathOperators(const std::string& prefix = "") {
       IntervalYearMonth,
       double>({prefix + "divide"});
   registerBinaryFloatingPoint<ModulusFunction>({prefix + "mod"});
+  registerBinaryIntegral<PModIntFunction>({prefix + "pmod"});
+  registerBinaryFloatingPoint<PModFloatFunction>({prefix + "pmod"});
 }
 
 } // namespace
diff --git a/velox/functions/prestosql/registration/ProbabilityTrigonometricFunctionsRegistration.cpp b/velox/functions/prestosql/registration/ProbabilityTrigonometricFunctionsRegistration.cpp
index a2687b55814..818a3d9145b 100644
--- a/velox/functions/prestosql/registration/ProbabilityTrigonometricFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/ProbabilityTrigonometricFunctionsRegistration.cpp
@@ -93,6 +93,9 @@ void registerProbTrigFunctions(const std::string& prefix) {
       {prefix + "inverse_f_cdf"});
   registerFunction<InverseChiSquaredCdf, double, double, double>(
       {prefix + "inverse_chi_squared_cdf"});
+  registerFunction<TCDFFunction, double, double, double>({prefix + "t_cdf"});
+  registerFunction<InverseTCDFFunction, double, double, double>(
+      {prefix + "inverse_t_cdf"});
 }
 
 } // namespace
diff --git a/velox/functions/prestosql/registration/RegistrationFunctions.cpp b/velox/functions/prestosql/registration/RegistrationFunctions.cpp
index 6c163c3de31..03d275e5fde 100644
--- a/velox/functions/prestosql/registration/RegistrationFunctions.cpp
+++ b/velox/functions/prestosql/registration/RegistrationFunctions.cpp
@@ -16,6 +16,7 @@
 #include <string>
 #include "velox/functions/prestosql/IPAddressFunctions.h"
 #include "velox/functions/prestosql/UuidFunctions.h"
+#include "velox/functions/prestosql/types/P4HyperLogLogRegistration.h"
 
 namespace facebook::velox::functions {
 
@@ -29,8 +30,10 @@ extern void registerComparisonFunctions(const std::string& prefix);
 extern void registerDateTimeFunctions(const std::string& prefix);
 extern void registerGeneralFunctions(const std::string& prefix);
 extern void registerHyperLogFunctions(const std::string& prefix);
+extern void registerKHyperLogLogFunctions(const std::string& prefix);
 extern void registerTDigestFunctions(const std::string& prefix);
 extern void registerQDigestFunctions(const std::string& prefix);
+extern void registerSetDigestFunctions(const std::string& prefix);
 extern void registerSfmSketchFunctions(const std::string& prefix);
 extern void registerEnumFunctions(const std::string& prefix);
 extern void registerIntegerFunctions(const std::string& prefix);
@@ -47,6 +50,10 @@ extern void registerMapAllowingDuplicates(
 extern void registerBingTileFunctions(const std::string& prefix);
 #ifdef VELOX_ENABLE_GEO
 extern void registerGeometryFunctions(const std::string& prefix);
+extern void registerSphericalGeographyFunctions();
+#endif
+#ifdef VELOX_ENABLE_GEO
+extern void registerS2Functions(const std::string& prefix);
 #endif
 extern void registerInternalArrayFunctions();
 
@@ -113,6 +120,14 @@ void registerBingTileFunctions(const std::string& prefix) {
 void registerGeometryFunctions(const std::string& prefix) {
   functions::registerGeometryFunctions(prefix);
 }
+
+void registerSphericalGeographyFunctions() {
+  functions::registerSphericalGeographyFunctions();
+}
+
+void registerS2Functions(const std::string& prefix) {
+  functions::registerS2Functions(prefix);
+}
 #endif
 
 void registerGeneralFunctions(const std::string& prefix) {
@@ -140,6 +155,7 @@ void registerBitwiseFunctions(const std::string& prefix) {
 }
 
 void registerAllScalarFunctions(const std::string& prefix) {
+  registerP4HyperLogLogType();
   registerArithmeticFunctions(prefix);
   registerCheckedArithmeticFunctions(prefix);
   registerComparisonFunctions(prefix);
@@ -147,15 +163,19 @@ void registerAllScalarFunctions(const std::string& prefix) {
   registerArrayFunctions(prefix);
   registerJsonFunctions(prefix);
   registerHyperLogFunctions(prefix);
+  registerKHyperLogLogFunctions(prefix);
   registerTDigestFunctions(prefix);
   registerQDigestFunctions(prefix);
   registerSfmSketchFunctions(prefix);
+  registerSetDigestFunctions(prefix);
   registerEnumFunctions(prefix);
   registerIntegerFunctions(prefix);
   registerFloatingPointFunctions(prefix);
   registerBingTileFunctions(prefix);
 #ifdef VELOX_ENABLE_GEO
   registerGeometryFunctions(prefix);
+  registerSphericalGeographyFunctions();
+  registerS2Functions(prefix);
 #endif
   registerGeneralFunctions(prefix);
   registerDateTimeFunctions(prefix);
diff --git a/velox/functions/prestosql/registration/RegistrationFunctions.h b/velox/functions/prestosql/registration/RegistrationFunctions.h
index 26bda1cbb84..0ad07c32fd4 100644
--- a/velox/functions/prestosql/registration/RegistrationFunctions.h
+++ b/velox/functions/prestosql/registration/RegistrationFunctions.h
@@ -33,6 +33,8 @@ void registerJsonFunctions(const std::string& prefix = "");
 
 void registerHyperLogFunctions(const std::string& prefix = "");
 
+void registerKHyperLogLogFunctions(const std::string& prefix = "");
+
 void registerTDigestFunctions(const std::string& prefix = "");
 
 void registerQDigestFunctions(const std::string& prefix = "");
diff --git a/velox/functions/prestosql/registration/S2FunctionsRegistration.cpp b/velox/functions/prestosql/registration/S2FunctionsRegistration.cpp
new file mode 100644
index 00000000000..b56cc195d78
--- /dev/null
+++ b/velox/functions/prestosql/registration/S2FunctionsRegistration.cpp
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/Registerer.h"
+#include "velox/functions/prestosql/S2Functions.h"
+#include "velox/type/SimpleFunctionApi.h"
+
+namespace facebook::velox::functions {
+
+using namespace facebook::velox;
+
+void registerS2Functions(const std::string& prefix) {
+  registerFunction<S2CellAreaSqKmFunction, double, int64_t>(
+      {prefix + "s2_cell_area_sq_km"});
+  registerFunction<S2CellContainsFunction, bool, int64_t, int64_t>(
+      {prefix + "s2_cell_contains"});
+  registerFunction<S2CellFromTokenFunction, int64_t, Varchar>(
+      {prefix + "s2_cell_from_token"});
+  registerFunction<S2CellLevelFunction, int32_t, int64_t>(
+      {prefix + "s2_cell_level"});
+  registerFunction<S2CellParentFunction, int64_t, int64_t, int32_t>(
+      {prefix + "s2_cell_parent"});
+  registerFunction<S2CellToTokenFunction, Varchar, int64_t>(
+      {prefix + "s2_cell_to_token"});
+  // Two overloads of s2_cells: fixed-level and dissolved (mixed-level).
+  registerFunction<S2CellsFunction, Array<int64_t>, Geometry, int32_t>(
+      {prefix + "s2_cells"});
+  registerFunction<
+      S2CellsDissolvedFunction,
+      Array<int64_t>,
+      Geometry,
+      int32_t,
+      int32_t,
+      int32_t>({prefix + "s2_cells"});
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/SetDigestFunctionsRegistration.cpp b/velox/functions/prestosql/registration/SetDigestFunctionsRegistration.cpp
new file mode 100644
index 00000000000..4d225211901
--- /dev/null
+++ b/velox/functions/prestosql/registration/SetDigestFunctionsRegistration.cpp
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/Registerer.h"
+#include "velox/functions/prestosql/SetDigestFunctions.h"
+#include "velox/functions/prestosql/types/SetDigestRegistration.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
+
+namespace facebook::velox::functions {
+
+void registerSetDigestFunctions(const std::string& prefix) {
+  facebook::velox::registerSetDigestType();
+
+  // Register cardinality(setdigest) -> bigint
+  registerFunction<
+      CardinalitySetDigestFunction,
+      int64_t,
+      facebook::velox::SetDigest>({prefix + "cardinality"});
+
+  // Register intersection_cardinality(setdigest, setdigest) -> bigint
+  registerFunction<
+      IntersectionCardinalityFunction,
+      int64_t,
+      facebook::velox::SetDigest,
+      facebook::velox::SetDigest>({prefix + "intersection_cardinality"});
+
+  // Register jaccard_index(setdigest, setdigest) -> double
+  registerFunction<
+      JaccardIndexFunction,
+      double,
+      facebook::velox::SetDigest,
+      facebook::velox::SetDigest>({prefix + "jaccard_index"});
+
+  // Register hash_counts(setdigest) -> map(bigint, smallint)
+  registerFunction<
+      HashCountsFunction,
+      Map<int64_t, int16_t>,
+      facebook::velox::SetDigest>({prefix + "hash_counts"});
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/SphericalGeographyFunctionsRegistration.cpp b/velox/functions/prestosql/registration/SphericalGeographyFunctionsRegistration.cpp
new file mode 100644
index 00000000000..447a9904883
--- /dev/null
+++ b/velox/functions/prestosql/registration/SphericalGeographyFunctionsRegistration.cpp
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/types/SphericalGeographyRegistration.h"
+
+namespace facebook::velox::functions {
+
+void registerSphericalGeographyFunctions() {
+  registerSphericalGeographyType();
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/StringFunctionsRegistration.cpp b/velox/functions/prestosql/registration/StringFunctionsRegistration.cpp
index 39a8c694996..67125028508 100644
--- a/velox/functions/prestosql/registration/StringFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/StringFunctionsRegistration.cpp
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/expression/ExprRewriteRegistry.h"
 #include "velox/functions/Registerer.h"
 #include "velox/functions/lib/Re2Functions.h"
 #include "velox/functions/prestosql/RegexpReplace.h"
@@ -43,7 +44,13 @@ void registerSimpleFunctions(const std::string& prefix) {
       {prefix + "hamming_distance"});
   registerFunction<LevenshteinDistanceFunction, int64_t, Varchar, Varchar>(
       {prefix + "levenshtein_distance"});
+  registerFunction<JaroWinklerSimilarityFunction, double, Varchar, Varchar>(
+      {prefix + "jarowinkler_similarity"});
+  registerFunction<LongestCommonPrefixFunction, Varchar, Varchar, Varchar>(
+      {prefix + "longest_common_prefix"});
   registerFunction<LengthFunction, int64_t, Varchar>({prefix + "length"});
+  registerFunction<BitLengthFunction, int64_t, Varchar>(
+      {prefix + "bit_length"});
   registerFunction<XxHash64StringFunction, int64_t, Varchar>(
       {prefix + "xxhash64_internal"});
 
@@ -189,9 +196,10 @@ void registerSplitToMap(const std::string& prefix) {
       Varchar,
       Varchar,
       bool>({"$internal$split_to_map"});
-  exec::registerExpressionRewrite([prefix](const auto& expr) {
-    return rewriteSplitToMapCall(prefix, expr);
-  });
+  expression::ExprRewriteRegistry::instance().registerRewrite(
+      [prefix](const auto& expr) {
+        return rewriteSplitToMapCall(prefix, expr);
+      });
 }
 } // namespace
 
@@ -239,5 +247,8 @@ void registerStringFunctions(const std::string& prefix) {
   registerFunction<WordStemFunction, Varchar, Varchar>({prefix + "word_stem"});
   registerFunction<WordStemFunction, Varchar, Varchar, Varchar>(
       {prefix + "word_stem"});
+
+  registerFunction<KeySamplingPercentFunction, double, Varchar>(
+      {prefix + "key_sampling_percent"});
 }
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/TDigestFunctionsRegistration.cpp b/velox/functions/prestosql/registration/TDigestFunctionsRegistration.cpp
index 347fd851800..4c4465efb77 100644
--- a/velox/functions/prestosql/registration/TDigestFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/TDigestFunctionsRegistration.cpp
@@ -76,5 +76,11 @@ void registerTDigestFunctions(const std::string& prefix) {
       SimpleTDigest<double>,
       double,
       double>({prefix + "trimmed_mean"});
+  registerFunction<
+      WinsorizedMeanFunction,
+      double,
+      SimpleTDigest<double>,
+      double,
+      double>({prefix + "winsorized_mean"});
 }
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/ArgTypesGeneratorTest.cpp b/velox/functions/prestosql/tests/ArgTypesGeneratorTest.cpp
index 1cc8b8e4d0a..4f3da48e45c 100644
--- a/velox/functions/prestosql/tests/ArgTypesGeneratorTest.cpp
+++ b/velox/functions/prestosql/tests/ArgTypesGeneratorTest.cpp
@@ -15,7 +15,7 @@
  */
 #include "velox/expression/fuzzer/tests/ArgTypesGeneratorTestUtils.h"
 #include "velox/functions/prestosql/fuzzer/DivideArgTypesGenerator.h"
-#include "velox/functions/prestosql/fuzzer/FloorAndRoundArgTypesGenerator.h"
+#include "velox/functions/prestosql/fuzzer/FloorCeilRoundArgTypesGenerator.h"
 #include "velox/functions/prestosql/fuzzer/ModulusArgTypesGenerator.h"
 #include "velox/functions/prestosql/fuzzer/MultiplyArgTypesGenerator.h"
 #include "velox/functions/prestosql/fuzzer/PlusMinusArgTypesGenerator.h"
@@ -93,7 +93,7 @@ TEST_F(ArgTypesGeneratorTest, divide) {
 TEST_F(ArgTypesGeneratorTest, floor) {
   const auto& signature = getOnlySignature("floor");
   const auto generator =
-      std::make_shared<exec::test::FloorAndRoundArgTypesGenerator>();
+      std::make_shared<exec::test::FloorCeilRoundArgTypesGenerator>();
 
   assertReturnType(generator, signature, DECIMAL(10, 0));
   assertReturnType(generator, signature, DECIMAL(18, 0));
@@ -107,7 +107,7 @@ TEST_F(ArgTypesGeneratorTest, round) {
   VELOX_CHECK_EQ(signatures.size(), 2);
   bool isSingleArg = signatures[0]->argumentTypes().size() == 1;
   const auto generator =
-      std::make_shared<exec::test::FloorAndRoundArgTypesGenerator>();
+      std::make_shared<exec::test::FloorCeilRoundArgTypesGenerator>();
 
   const auto& singleArgSignature =
       isSingleArg ? *signatures[0] : *signatures[1];
diff --git a/velox/functions/prestosql/tests/ArithmeticTest.cpp b/velox/functions/prestosql/tests/ArithmeticTest.cpp
index e589ee78b70..03194066cc9 100644
--- a/velox/functions/prestosql/tests/ArithmeticTest.cpp
+++ b/velox/functions/prestosql/tests/ArithmeticTest.cpp
@@ -272,6 +272,49 @@ TEST_F(ArithmeticTest, modInt) {
   assertError<int64_t>("mod(c0, c1)", {10}, {0}, "Cannot divide by 0");
 }
 
+TEST_F(ArithmeticTest, pmod) {
+  // Positive modulo returns non-negative results for positive divisors.
+  std::vector<double> numerDouble = {0, 6, -7, 10, -10};
+  std::vector<double> denomDouble = {1, 2, 3, 3, 3};
+  std::vector<double> expectedDouble = {0, 0, 2, 1, 2};
+
+  assertExpression<double>(
+      "pmod(c0, c1)", numerDouble, denomDouble, expectedDouble);
+
+  // Division by zero returns NULL.
+  EXPECT_EQ(
+      std::nullopt,
+      evaluateOnce<double>(
+          "pmod(c0, c1)",
+          std::optional<double>(5.0),
+          std::optional<double>(0.0)));
+}
+
+TEST_F(ArithmeticTest, pmodInt) {
+  std::vector<int64_t> numerInt = {9, 10, -7, 0, -9};
+  std::vector<int64_t> denomInt = {3, 3, 3, 3, 3};
+  std::vector<int64_t> expectedInt = {0, 1, 2, 0, 0};
+
+  assertExpression<int64_t, int64_t>(
+      "pmod(c0, c1)", numerInt, denomInt, expectedInt);
+
+  // INT64_MIN % -1 edge case.
+  EXPECT_EQ(
+      0,
+      evaluateOnce<int64_t>(
+          "pmod(c0, c1)",
+          std::optional<int64_t>(std::numeric_limits<int64_t>::min()),
+          std::optional<int64_t>(-1)));
+
+  // Division by zero returns NULL.
+  EXPECT_EQ(
+      std::nullopt,
+      evaluateOnce<int64_t>(
+          "pmod(c0, c1)",
+          std::optional<int64_t>(10),
+          std::optional<int64_t>(0)));
+}
+
 TEST_F(ArithmeticTest, power) {
   std::vector<double> baseDouble = {
       0, 0, 0, -1, -1, -1, -9, 9.1, 10.1, 11.1, -11.1};
diff --git a/velox/functions/prestosql/tests/ArrayConcatTest.cpp b/velox/functions/prestosql/tests/ArrayConcatTest.cpp
index 446d8d7ed72..e7e73a41290 100644
--- a/velox/functions/prestosql/tests/ArrayConcatTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayConcatTest.cpp
@@ -124,7 +124,9 @@ TEST_F(ArrayConcatTest, arity) {
       "concat(c0, c1, c2, c3)", {array1, array4, array3, array2}, expected);
 
   testExpressionWithError(
-      "concat(c0)", {array1}, "There must be 2 or more arguments to concat");
+      "concat(c0)",
+      {array1},
+      "Scalar function signature is not supported: concat(ARRAY<BIGINT>).");
 
   std::stringstream expression;
   std::vector<VectorPtr> inputArrayVector;
diff --git a/velox/functions/prestosql/tests/ArrayConstructorTest.cpp b/velox/functions/prestosql/tests/ArrayConstructorTest.cpp
index af9f95ddf13..21f986eff32 100644
--- a/velox/functions/prestosql/tests/ArrayConstructorTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayConstructorTest.cpp
@@ -187,7 +187,8 @@ TEST_F(ArrayConstructorTest, literals) {
 
   // Add null literals.
   result = evaluate(
-      "array_constructor(1, 2, null, 4, null)", makeRowVector(ROW({}), 1));
+      "array_constructor(1, 2, null::bigint, 4, null::bigint)",
+      makeRowVector(ROW({}), 1));
   expected =
       makeNullableArrayVector<int64_t>({{1, 2, std::nullopt, 4, std::nullopt}});
   test::assertEqualVectors(expected, result);
diff --git a/velox/functions/prestosql/tests/ArrayExceptTest.cpp b/velox/functions/prestosql/tests/ArrayExceptTest.cpp
index 9efd241a2ef..2fe6db4e99d 100644
--- a/velox/functions/prestosql/tests/ArrayExceptTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayExceptTest.cpp
@@ -346,20 +346,20 @@ TEST_F(ArrayExceptTest, complexTypeRow) {
 
 // When one of the arrays is constant.
 TEST_F(ArrayExceptTest, constant) {
-  auto array1 = makeNullableArrayVector<int32_t>({
+  auto array1 = makeNullableArrayVector<int64_t>({
       {1, -2, 3, std::nullopt, 4, 5, 6, std::nullopt},
       {1, 2, -2, 1},
       {3, 8, std::nullopt},
       {1, 1, -2, -2, -2, 4, 8},
   });
-  auto expected = makeNullableArrayVector<int32_t>({
+  auto expected = makeNullableArrayVector<int64_t>({
       {3, std::nullopt, 5, 6},
       {2},
       {3, 8, std::nullopt},
       {8},
   });
   testExpr(expected, "array_except(C0, ARRAY[1,-2,4])", {array1});
-  expected = makeNullableArrayVector<int32_t>({
+  expected = makeNullableArrayVector<int64_t>({
       {},
       {4},
       {1, -2, 4},
@@ -369,7 +369,7 @@ TEST_F(ArrayExceptTest, constant) {
   testExpr(expected, "array_except(ARRAY[1,1,-2,1,-2,4,1,4,4], C0)", {array1});
 
   // Array containing NULLs.
-  expected = makeNullableArrayVector<int32_t>({
+  expected = makeNullableArrayVector<int64_t>({
       {-2, 3, 5, 6},
       {2, -2},
       {3, 8},
@@ -377,7 +377,7 @@ TEST_F(ArrayExceptTest, constant) {
   });
   testExpr(expected, "array_except(C0, ARRAY[1,NULL,4])", {array1});
 
-  expected = makeNullableArrayVector<int32_t>({
+  expected = makeNullableArrayVector<int64_t>({
       {},
       {std::nullopt, 4},
       {1, 4},
diff --git a/velox/functions/prestosql/tests/ArrayFlattenTest.cpp b/velox/functions/prestosql/tests/ArrayFlattenTest.cpp
index b14a3f917c1..5a468d89487 100644
--- a/velox/functions/prestosql/tests/ArrayFlattenTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayFlattenTest.cpp
@@ -25,12 +25,13 @@ namespace {
 
 class ArrayFlattenTest : public FunctionBaseTest {
  protected:
-  void testExpression(
+  VectorPtr testExpression(
       const std::string& expression,
       const std::vector<VectorPtr>& input,
       const VectorPtr& expected) {
     auto result = evaluate(expression, makeRowVector(input));
     assertEqualVectors(expected, result);
+    return result;
   }
 };
 
@@ -150,4 +151,23 @@ TEST_F(ArrayFlattenTest, constantArrayWithoutConsecutiveBaseElements) {
           {std::nullopt, 6, 5, std::nullopt}});
   testExpression("flatten(c0)", {constArrayOfArrays}, expected);
 }
+
+TEST_F(ArrayFlattenTest, arrayOfConstantArrayWithConsecutiveIndices) {
+  const auto baseVector = makeArrayVector<int64_t>({{1, 1}});
+  const auto constVector = BaseVector::wrapInConstant(3, 0, baseVector);
+
+  // Create arrays of array vector using above constant vector.
+  // [[1, 1]]
+  // [[1, 1]]
+  // [[1, 1]]
+  const auto arrayOfArrays = makeArrayVector({0, 1, 2}, constVector);
+
+  // [1, 1]
+  // [1, 1]
+  // [1, 1]
+  const auto expected = makeArrayVector<int64_t>({{1, 1}, {1, 1}, {1, 1}});
+
+  const auto actual = testExpression("flatten(c0)", {arrayOfArrays}, expected);
+  ASSERT_FALSE(actual->as<ArrayVector>()->hasOverlappingRanges());
+}
 } // namespace
diff --git a/velox/functions/prestosql/tests/ArrayIntersectTest.cpp b/velox/functions/prestosql/tests/ArrayIntersectTest.cpp
index 971d86f2ae4..928a6132f11 100644
--- a/velox/functions/prestosql/tests/ArrayIntersectTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayIntersectTest.cpp
@@ -555,13 +555,13 @@ TEST_F(ArrayIntersectTest, complexTypeRowNestedArrays) {
 
 // When one of the arrays is constant.
 TEST_F(ArrayIntersectTest, constant) {
-  auto array1 = makeNullableArrayVector<int32_t>({
+  auto array1 = makeNullableArrayVector<int64_t>({
       {1, -2, 3, std::nullopt, 4, 5, 6, std::nullopt},
       {1, 2, -2, 1},
       {3, 8, std::nullopt},
       {1, 1, -2, -2, -2, 4, 8},
   });
-  auto expected = makeNullableArrayVector<int32_t>({
+  auto expected = makeNullableArrayVector<int64_t>({
       {1, -2, 4},
       {1, -2},
       {},
@@ -573,7 +573,7 @@ TEST_F(ArrayIntersectTest, constant) {
       expected, "array_intersect(ARRAY[1,1,-2,1,-2,4,1,4,4], C0)", {array1});
 
   // Array containing NULLs.
-  expected = makeNullableArrayVector<int32_t>({
+  expected = makeNullableArrayVector<int64_t>({
       {1, std::nullopt, 4},
       {1},
       {std::nullopt},
@@ -586,17 +586,17 @@ TEST_F(ArrayIntersectTest, constant) {
 // Check that results are deterministic regardless of the encoding; literals
 // (constant exprs) and regular columns should always return the same results.
 TEST_F(ArrayIntersectTest, deterministic) {
-  auto c0 = makeNullableArrayVector<int32_t>({
+  auto c0 = makeNullableArrayVector<int64_t>({
       {1, -2, 3, std::nullopt, 4, 5, 6, std::nullopt},
       {4, -2, 6, std::nullopt, 1},
   });
-  auto c1 = makeNullableArrayVector<int32_t>({
+  auto c1 = makeNullableArrayVector<int64_t>({
       {1, 4, -2},
       {1, 4, -2},
   });
 
   // C0 then C1.
-  auto expectedC0C1 = makeNullableArrayVector<int32_t>({
+  auto expectedC0C1 = makeNullableArrayVector<int64_t>({
       {1, -2, 4},
       {4, -2, 1},
   });
@@ -604,7 +604,7 @@ TEST_F(ArrayIntersectTest, deterministic) {
   testExpr(expectedC0C1, "array_intersect(C0, C1)", {c0, c1});
 
   // C1 then C0.
-  auto expectedC1C0 = makeNullableArrayVector<int32_t>({
+  auto expectedC1C0 = makeNullableArrayVector<int64_t>({
       {1, 4, -2},
       {1, 4, -2},
   });
@@ -618,8 +618,8 @@ TEST_F(ArrayIntersectTest, dictionaryEncodedElementsInConstant) {
       test::TestingDictionaryArrayElementsFunction::signatures(),
       std::make_unique<test::TestingDictionaryArrayElementsFunction>());
 
-  auto array = makeArrayVector<int32_t>({{1, 3}, {2, 5}, {0, 6}});
-  auto expected = makeArrayVector<int32_t>({{1, 3}, {2}, {}});
+  auto array = makeArrayVector<int64_t>({{1, 3}, {2, 5}, {0, 6}});
+  auto expected = makeArrayVector<int64_t>({{1, 3}, {2}, {}});
   testExpr(
       expected,
       "array_intersect(c0, testing_dictionary_array_elements(ARRAY [2, 2, 3, 1, 2, 2]))",
diff --git a/velox/functions/prestosql/tests/ArrayShuffleTest.cpp b/velox/functions/prestosql/tests/ArrayShuffleTest.cpp
index 5129a69ed87..95a1f322cca 100644
--- a/velox/functions/prestosql/tests/ArrayShuffleTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayShuffleTest.cpp
@@ -95,8 +95,9 @@ class ArrayShuffleTest : public FunctionBaseTest {
       auto expectedArray = readerExpected[i].materialize();
 
       // Assert the two vectors contain the same elements (ignoring order).
-      ASSERT_TRUE(std::is_permutation(
-          actualArray.begin(), actualArray.end(), expectedArray.begin()))
+      ASSERT_TRUE(
+          std::is_permutation(
+              actualArray.begin(), actualArray.end(), expectedArray.begin()))
           << "Actual array " << printArray(actualArray) << " at " << i
           << " must produce a permutation of expected array "
           << printArray(expectedArray);
@@ -181,8 +182,9 @@ class ArrayShuffleTest : public FunctionBaseTest {
       auto actualArray = readerActual.readNullFree(i).materialize();
       auto expectedArray = readerExpected.readNullFree(i).materialize();
 
-      ASSERT_TRUE(std::is_permutation(
-          actualArray.begin(), actualArray.end(), expectedArray.begin()))
+      ASSERT_TRUE(
+          std::is_permutation(
+              actualArray.begin(), actualArray.end(), expectedArray.begin()))
           << "Actual " << inputVector->encoding() << " array "
           << printArray(actualArray) << " at " << i
           << " must produce a permutation of expected array "
diff --git a/velox/functions/prestosql/tests/ArraySortTest.cpp b/velox/functions/prestosql/tests/ArraySortTest.cpp
index 3a5512cd5b9..294be3690d9 100644
--- a/velox/functions/prestosql/tests/ArraySortTest.cpp
+++ b/velox/functions/prestosql/tests/ArraySortTest.cpp
@@ -46,7 +46,9 @@ using TestRowType = variant;
 class ArraySortTest : public FunctionBaseTest,
                       public testing::WithParamInterface<TypeKind> {
  protected:
-  ArraySortTest() : numValues_(10), numVectors_(5) {}
+  ArraySortTest() : numValues_(10), numVectors_(5) {
+    options_.parseIntegerAsBigint = false;
+  }
 
   void SetUp() override;
 
@@ -224,7 +226,8 @@ class ArraySortTest : public FunctionBaseTest,
         break;
       default:
         VELOX_FAIL(
-            "Unsupported data type of sort_array: {}", mapTypeKindToName(kind));
+            "Unsupported data type of sort_array: {}",
+            TypeKindName::toName(kind));
     }
   }
 
@@ -367,7 +370,8 @@ void ArraySortTest::SetUp() {
         break;
       default:
         VELOX_FAIL(
-            "Unsupported data type of sort_array: {}", mapTypeKindToName(type));
+            "Unsupported data type of sort_array: {}",
+            TypeKindName::toName(type));
     }
   }
   ASSERT_LE(dataVectorsByType_.size(), kSupportedTypes.size());
@@ -610,7 +614,7 @@ TEST_F(ArraySortTest, unsupporteLambda) {
 
 TEST_F(ArraySortTest, failOnMapTypeSort) {
   static const std::string kErrorMessage =
-      "Scalar function signature is not supported"_sv;
+      "Scalar function signature is not supported";
   auto data = makeRowVector({BaseVector::createNullConstant(
       ARRAY(MAP(BIGINT(), VARCHAR())), 8, pool())});
   auto testFail = [&](const std::string& name) {
diff --git a/velox/functions/prestosql/tests/ArraySplitIntoChunksTest.cpp b/velox/functions/prestosql/tests/ArraySplitIntoChunksTest.cpp
new file mode 100644
index 00000000000..428a9216993
--- /dev/null
+++ b/velox/functions/prestosql/tests/ArraySplitIntoChunksTest.cpp
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <optional>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+class ArraySplitIntoChunksTest : public test::FunctionBaseTest {
+ protected:
+  template <typename T>
+  void testSplitIntoChunks(
+      const std::vector<std::optional<T>>& inputArray,
+      int32_t sz,
+      const std::vector<std::optional<std::vector<std::optional<T>>>>&
+          expectedOutput) {
+    std::vector<std::optional<std::vector<std::optional<T>>>> inputVec(
+        {inputArray});
+    auto input = makeNullableArrayVector<T>(inputVec);
+    auto result = evaluate(
+        fmt::format("array_split_into_chunks(c0, {}::INTEGER)", sz),
+        makeRowVector({input}));
+
+    auto expected = makeNullableNestedArrayVector<T>({expectedOutput});
+    assertEqualVectors(expected, result);
+  }
+};
+
+TEST_F(ArraySplitIntoChunksTest, integers) {
+  testSplitIntoChunks<int64_t>({1, 2, 3}, 2, {{{1, 2}}, {{3}}});
+  testSplitIntoChunks<int64_t>({1, 2, 3, 4, 5}, 2, {{{1, 2}}, {{3, 4}}, {{5}}});
+  testSplitIntoChunks<int64_t>({2, 3, 4, 5}, 4, {{{2, 3, 4, 5}}});
+  testSplitIntoChunks<int64_t>(
+      {-66, 3, -66, 5}, 1, {{{-66}}, {{3}}, {{-66}}, {{5}}});
+}
+
+TEST_F(ArraySplitIntoChunksTest, evenSplit) {
+  testSplitIntoChunks<int64_t>(
+      {1, 2, 3, 4, 5, 6}, 2, {{{1, 2}}, {{3, 4}}, {{5, 6}}});
+}
+
+TEST_F(ArraySplitIntoChunksTest, chunkLargerThanArray) {
+  testSplitIntoChunks<int64_t>({1, 2, 3}, 5, {{{1, 2, 3}}});
+}
+
+TEST_F(ArraySplitIntoChunksTest, chunkEqualsArrayLength) {
+  testSplitIntoChunks<int64_t>({1, 2, 3}, 3, {{{1, 2, 3}}});
+}
+
+TEST_F(ArraySplitIntoChunksTest, chunkOfOne) {
+  testSplitIntoChunks<int64_t>({1, 2, 3, 4}, 1, {{{1}}, {{2}}, {{3}}, {{4}}});
+}
+
+TEST_F(ArraySplitIntoChunksTest, emptyArray) {
+  auto input = makeArrayVector<int64_t>({{}});
+  VELOX_ASSERT_THROW(
+      evaluate(
+          "array_split_into_chunks(c0, 2::INTEGER)", makeRowVector({input})),
+      "Cannot split an empty array.");
+}
+
+TEST_F(ArraySplitIntoChunksTest, strings) {
+  testSplitIntoChunks<std::string>({"a", "b", "c"}, 2, {{{"a", "b"}}, {{"c"}}});
+  testSplitIntoChunks<std::string>(
+      {"a", "b", "c", "d", "e"}, 2, {{{"a", "b"}}, {{"c", "d"}}, {{"e"}}});
+  testSplitIntoChunks<std::string>(
+      {"a", "b", "c", "d"}, 4, {{{"a", "b", "c", "d"}}});
+  testSplitIntoChunks<std::string>(
+      {"a", "b", "c", "d"}, 1, {{{"a"}}, {{"b"}}, {{"c"}}, {{"d"}}});
+}
+
+TEST_F(ArraySplitIntoChunksTest, doubles) {
+  testSplitIntoChunks<double>({1.0, 2.0, 3.0}, 2, {{{1.0, 2.0}}, {{3.0}}});
+  testSplitIntoChunks<double>(
+      {1.0, 2.0, 3.0, 4.0, 5.0}, 2, {{{1.0, 2.0}}, {{3.0, 4.0}}, {{5.0}}});
+  testSplitIntoChunks<double>(
+      {2.0, 3.0, 4.0, 5.0}, 4, {{{2.0, 3.0, 4.0, 5.0}}});
+  testSplitIntoChunks<double>(
+      {1.0, 2.0, 3.0, 4.0}, 1, {{{1.0}}, {{2.0}}, {{3.0}}, {{4.0}}});
+}
+
+TEST_F(ArraySplitIntoChunksTest, nullElements) {
+  testSplitIntoChunks<int64_t>(
+      {std::nullopt, 1, std::nullopt, 2},
+      2,
+      {{{std::nullopt, 1}}, {{std::nullopt, 2}}});
+}
+
+TEST_F(ArraySplitIntoChunksTest, nullInputs) {
+  auto input = makeNullableArrayVector<int64_t>(
+      {std::optional<std::vector<std::optional<int64_t>>>(std::nullopt)});
+  auto result = evaluate(
+      "array_split_into_chunks(c0, 2::INTEGER)", makeRowVector({input}));
+  ASSERT_TRUE(result->isNullAt(0));
+}
+
+TEST_F(ArraySplitIntoChunksTest, invalidChunkSize) {
+  auto input = makeArrayVector<int64_t>({{1, 2, 3}});
+  VELOX_ASSERT_THROW(
+      evaluate(
+          "array_split_into_chunks(c0, 0::INTEGER)", makeRowVector({input})),
+      "Invalid slice size: 0. Size must be greater than zero.");
+  VELOX_ASSERT_THROW(
+      evaluate(
+          "array_split_into_chunks(c0, -1::INTEGER)", makeRowVector({input})),
+      "Scalar function signature is not supported");
+}
+
+TEST_F(ArraySplitIntoChunksTest, tooManyChunks) {
+  // Create an array with 12001 elements.
+  std::vector<std::optional<int64_t>> largeArray;
+  largeArray.reserve(12'001);
+  for (int i = 0; i < 12'001; ++i) {
+    largeArray.push_back(i);
+  }
+  std::vector<std::optional<std::vector<std::optional<int64_t>>>> inputVec(
+      {largeArray});
+  auto input = makeNullableArrayVector<int64_t>(inputVec);
+  VELOX_ASSERT_THROW(
+      evaluate(
+          "array_split_into_chunks(c0, 1::INTEGER)", makeRowVector({input})),
+      "Cannot split array of size: 12001 into more than 10000 parts.");
+}
+} // namespace
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/ArraySubsetTest.cpp b/velox/functions/prestosql/tests/ArraySubsetTest.cpp
new file mode 100644
index 00000000000..54d4b0c901f
--- /dev/null
+++ b/velox/functions/prestosql/tests/ArraySubsetTest.cpp
@@ -0,0 +1,845 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+#include <random>
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class ArraySubsetTest : public test::FunctionBaseTest {
+ protected:
+  void testArraySubset(
+      const std::string& expression,
+      const std::vector<VectorPtr>& input,
+      const VectorPtr& expected) {
+    auto result = evaluate(expression, makeRowVector(input));
+    assertEqualVectors(expected, result);
+  }
+};
+
+TEST_F(ArraySubsetTest, integerArray) {
+  auto inputArray = makeArrayVector<int32_t>({
+      {1, 2, 3, 4, 5, 6},
+      {10, 20, 30, 40},
+      {},
+      {100, 200},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {1, 3, 5},
+      {2, 4, 6},
+      {1, 2},
+      {1, 2, 3},
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {1, 3, 5},
+      {20, 40},
+      {},
+      {100, 200},
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, constantIndices) {
+  auto inputArray = makeArrayVector<int32_t>({
+      {1, 2, 3, 4, 5},
+      {10, 20, 30},
+      {100, 200, 300, 400, 500},
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {1, 3, 5},
+      {10, 30},
+      {100, 300, 500},
+  });
+
+  auto result = evaluate(
+      "array_subset(c0, array_constructor(cast(1 as integer), cast(3 as integer), cast(5 as integer)))",
+      makeRowVector({inputArray}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(ArraySubsetTest, outOfBoundsIndices) {
+  auto inputArray = makeArrayVector<int32_t>({
+      {1, 2, 3},
+      {10, 20},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {1, 5, 2}, // Index 5 is out of bounds
+      {1, 3, 4}, // Indices 3 and 4 are out of bounds
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {1, 2}, // Only valid indices 1 and 2
+      {10}, // Only valid index 1
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, negativeAndZeroIndices) {
+  auto inputArray = makeArrayVector<int32_t>({
+      {1, 2, 3, 4, 5},
+      {10, 20, 30},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {-1, 0, 1, 3}, // Negative and zero indices should be ignored
+      {0, 2, -5}, // Only index 2 is valid
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {1, 3}, // Only indices 1 and 3 are valid
+      {20}, // Only index 2 is valid
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, duplicateIndices) {
+  auto inputArray = makeArrayVector<int32_t>({
+      {1, 2, 3, 4, 5},
+      {10, 20, 30},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {1, 1, 2, 2, 3}, // Duplicate indices
+      {2, 2, 1, 1}, // Duplicate indices
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {1, 2, 3}, // Duplicates removed, sorted order
+      {10, 20}, // Duplicates removed, sorted order (1-based: 1->10, 2->20)
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, emptyIndices) {
+  auto inputArray = makeArrayVector<int32_t>({
+      {1, 2, 3, 4, 5},
+      {10, 20, 30},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {},
+      {},
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {},
+      {},
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, emptyIndicesWithEmptyArray) {
+  // Test edge case: empty array with empty indices
+  auto inputArray = makeArrayVector<int32_t>({
+      {},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {},
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {},
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, emptyArrayWithValidIndices) {
+  // Test edge case: empty array with valid indices (should return empty)
+  auto inputArray = makeArrayVector<int32_t>({
+      {},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {1, 2, 3},
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {},
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, emptyArray) {
+  auto inputArray = makeArrayVector<int32_t>({
+      {},
+      {},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {1, 2, 3},
+      {1},
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {},
+      {},
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, nullElementsInArray) {
+  auto inputArray = makeNullableArrayVector<int32_t>({
+      {1, std::nullopt, 3, 4, std::nullopt},
+      {std::nullopt, 20, std::nullopt, 40},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {1, 2, 3, 5}, // Includes indices pointing to null elements
+      {1, 2, 3, 4}, // Includes indices pointing to null elements
+  });
+
+  // Null elements should be included in output
+  auto expected = makeNullableArrayVector<int32_t>({
+      {1, std::nullopt, 3, std::nullopt}, // Elements at indices 1, 2, 3, 5
+      {std::nullopt, 20, std::nullopt, 40}, // Elements at indices 1, 2, 3, 4
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, nullElementsInIndices) {
+  auto inputArray = makeArrayVector<int32_t>({
+      {1, 2, 3, 4, 5},
+      {10, 20, 30},
+  });
+
+  auto indices = makeNullableArrayVector<int32_t>({
+      {1, std::nullopt, 3, std::nullopt, 5}, // Null indices should be ignored
+      {std::nullopt, 2, std::nullopt}, // Null indices should be ignored
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {1, 3, 5}, // Only valid non-null indices
+      {20}, // Only valid non-null index
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, stringArray) {
+  auto inputArray = makeArrayVector<StringView>({
+      {"apple", "banana", "cherry", "date"},
+      {"hello", "world"},
+      {"a", "b", "c", "d", "e"},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {2, 4, 1},
+      {1, 2, 3},
+      {1, 3, 5},
+  });
+
+  auto expected = makeArrayVector<StringView>({
+      {"apple", "banana", "date"}, // Sorted by index: 1, 2, 4
+      {"hello", "world"}, // Indices 1, 2 (3 is out of bounds)
+      {"a", "c", "e"}, // Indices 1, 3, 5
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, floatArray) {
+  auto inputArray = makeArrayVector<float>({
+      {1.1f, 2.2f, 3.3f, 4.4f},
+      {10.5f, 20.5f, 30.5f},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {1, 3, 4},
+      {2, 1, 3},
+  });
+
+  auto expected = makeArrayVector<float>({
+      {1.1f, 3.3f, 4.4f},
+      {10.5f, 20.5f, 30.5f},
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, booleanArray) {
+  auto inputArray = makeArrayVector<bool>({
+      {true, false, true, false, true},
+      {false, true, false},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {1, 3, 5},
+      {2, 1, 3},
+  });
+
+  auto expected = makeArrayVector<bool>({
+      {true, true, true},
+      {false, true, false},
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, largeIndices) {
+  auto inputArray = makeArrayVector<int32_t>({
+      {1, 2, 3},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {1000, 2000, 1, 3000}, // Very large indices mixed with valid ones
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {1}, // Only index 1 is valid
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, singleElementArray) {
+  auto inputArray = makeArrayVector<int32_t>({
+      {42},
+      {100},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {1, 2, 3}, // Only index 1 is valid
+      {1}, // Valid index
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {42},
+      {100},
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, complexArray) {
+  // Test with array of arrays
+  auto innerArrays = makeArrayVector<int32_t>({
+      {1, 2},
+      {3, 4, 5},
+      {6},
+      {7, 8, 9, 10},
+  });
+
+  auto inputArray = makeArrayVector({0, 2, 4}, innerArrays);
+
+  auto indices = makeArrayVector<int32_t>({
+      {1, 2},
+      {2, 1},
+  });
+
+  // Row 0: array_subset([{1,2}, {3,4,5}], [1,2]) = [{1,2}, {3,4,5}]
+  // Row 1: array_subset([{6}, {7,8,9,10}], [2,1]) = [{6}, {7,8,9,10}] (sorted
+  // by index)
+  auto expectedInnerArrays = makeArrayVector<int32_t>({
+      {1, 2},
+      {3, 4, 5},
+      {6},
+      {7, 8, 9, 10},
+  });
+
+  auto expected = makeArrayVector({0, 2, 4}, expectedInnerArrays);
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, nullAtFirstIndex) {
+  // Test the specific case: array_subset(array[null,1], array[1]) = array[null]
+  std::vector<std::vector<std::optional<int32_t>>> inputData = {
+      {std::nullopt, 1}};
+  auto inputArray = makeNullableArrayVector(inputData);
+
+  auto indices = makeArrayVector<int32_t>({{1}});
+
+  std::vector<std::vector<std::optional<int32_t>>> expectedData = {
+      {std::nullopt}};
+  auto expected = makeNullableArrayVector(expectedData);
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, nullArguments) {
+  // Test when either argument is null, result should be null
+  auto inputArray = makeArrayVector<int32_t>({{1, 2, 3}});
+  auto indices = makeArrayVector<int32_t>({{1, 2}});
+
+  // Create null array and null indices with proper types
+  auto nullArray = BaseVector::createNullConstant(ARRAY(INTEGER()), 1, pool());
+  auto nullIndices =
+      BaseVector::createNullConstant(ARRAY(INTEGER()), 1, pool());
+
+  // Test null input array
+  auto result1 =
+      evaluate("array_subset(c0, c1)", makeRowVector({nullArray, indices}));
+  auto expected1 = BaseVector::createNullConstant(ARRAY(INTEGER()), 1, pool());
+  assertEqualVectors(expected1, result1);
+
+  // Test null indices array
+  auto result2 = evaluate(
+      "array_subset(c0, c1)", makeRowVector({inputArray, nullIndices}));
+  auto expected2 = BaseVector::createNullConstant(ARRAY(INTEGER()), 1, pool());
+  assertEqualVectors(expected2, result2);
+
+  // Test both null
+  auto result3 =
+      evaluate("array_subset(c0, c1)", makeRowVector({nullArray, nullIndices}));
+  auto expected3 = BaseVector::createNullConstant(ARRAY(INTEGER()), 1, pool());
+  assertEqualVectors(expected3, result3);
+}
+
+TEST_F(ArraySubsetTest, duplicateIndicesWithNullAndOutOfBounds) {
+  // Test the specific case: array_subset(array[null,1], array[1,1,3,1]) =
+  // array[null]
+  std::vector<std::vector<std::optional<int32_t>>> inputData = {
+      {std::nullopt, 1}};
+  auto inputArray = makeNullableArrayVector(inputData);
+
+  auto indices = makeArrayVector<int32_t>({{1, 1, 3, 1}});
+
+  std::vector<std::vector<std::optional<int32_t>>> expectedData = {
+      {std::nullopt}};
+  auto expected = makeNullableArrayVector(expectedData);
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, basicTest) {
+  auto inputArray = makeArrayVector<int32_t>({{1, 2, 3, 4, 5}});
+  auto indices = makeArrayVector<int32_t>({{1, 3, 5}});
+  auto expected = makeArrayVector<int32_t>({{1, 3, 5}});
+
+  auto result =
+      evaluate("array_subset(c0, c1)", makeRowVector({inputArray, indices}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(ArraySubsetTest, nullTest) {
+  // Test array_subset(array[null,1], array[1]) = array[null]
+  std::vector<std::vector<std::optional<int32_t>>> inputData = {
+      {std::nullopt, 1}};
+  auto inputArray = makeNullableArrayVector(inputData);
+  auto indices = makeArrayVector<int32_t>({{1}});
+  std::vector<std::vector<std::optional<int32_t>>> expectedData = {
+      {std::nullopt}};
+  auto expected = makeNullableArrayVector(expectedData);
+
+  auto result =
+      evaluate("array_subset(c0, c1)", makeRowVector({inputArray, indices}));
+  assertEqualVectors(expected, result);
+}
+
+// Custom fuzzer tests to compare array_subset with equivalent expression
+// using existing UDFs. The equivalent expression is:
+// transform(
+//   array_sort(array_distinct(filter(indices, i -> i IS NOT NULL AND i > 0 AND
+//   i <= cardinality(arr)))), i -> element_at(arr, i)
+// )
+//
+// Note: We already have explicit tests for NULL handling in ArraySubsetTest.
+// These fuzzer tests focus on comparing behavior with non-null inputs.
+class ArraySubsetFuzzerTest : public test::FunctionBaseTest {
+ protected:
+  // Helper to flatten vectors for consistent comparison across encodings
+  template <typename T>
+  static VectorPtr flatten(const std::shared_ptr<T>& vector) {
+    VectorPtr result = vector;
+    BaseVector::flattenVector(result);
+    return result;
+  }
+
+  // The expression below is equivalent to array_subset(c0, c1) using existing
+  // UDFs.
+  static constexpr const char* kEquivalentExpression =
+      "transform("
+      "  array_sort(array_distinct("
+      "    filter(c1, i -> i IS NOT NULL AND i > 0 AND i <= cardinality(c0))"
+      "  )),"
+      "  i -> element_at(c0, i)"
+      ")";
+
+  // Get a SelectivityVector that excludes rows where either input is null.
+  // This is because array_subset returns NULL when either input is NULL,
+  // but the equivalent expression may return empty array.
+  static SelectivityVector getNonNullRows(const RowVectorPtr& data) {
+    auto inputArray = data->childAt(0);
+    auto indices = data->childAt(1);
+    SelectivityVector nonNullRows(data->size());
+
+    for (vector_size_t i = 0; i < data->size(); ++i) {
+      if (inputArray->isNullAt(i) || indices->isNullAt(i)) {
+        nonNullRows.setValid(i, false);
+      }
+    }
+    nonNullRows.updateBounds();
+    return nonNullRows;
+  }
+
+  void testEquivalence(const RowVectorPtr& data) {
+    auto result = evaluate("array_subset(c0, c1)", data);
+    auto expected = evaluate(kEquivalentExpression, data);
+
+    // Get rows where neither input is null
+    auto nonNullRows = getNonNullRows(data);
+
+    // Compare only non-null rows (null propagation is tested separately)
+    nonNullRows.applyToSelected([&](vector_size_t row) {
+      ASSERT_TRUE(expected->equalValueAt(result.get(), row, row))
+          << "Mismatch at row " << row << ": expected "
+          << expected->toString(row) << ", got " << result->toString(row);
+    });
+  }
+
+  // Generate indices array with values in valid range [1, maxIndex].
+  // This ensures we actually test the subsetting logic, not just filtering.
+  ArrayVectorPtr makeValidIndicesArray(
+      vector_size_t numRows,
+      vector_size_t indicesPerRow,
+      int32_t maxIndex,
+      double nullRatio = 0.0) {
+    std::vector<std::vector<std::optional<int32_t>>> indicesData(numRows);
+    std::mt19937 rng(42); // Fixed seed for reproducibility
+
+    for (vector_size_t row = 0; row < numRows; ++row) {
+      indicesData[row].reserve(indicesPerRow);
+      for (vector_size_t i = 0; i < indicesPerRow; ++i) {
+        if (nullRatio > 0.0 &&
+            (rng() % 100) < static_cast<int>(nullRatio * 100)) {
+          indicesData[row].push_back(std::nullopt);
+        } else {
+          // Generate index in range [1, maxIndex] (1-based)
+          int32_t index = (rng() % maxIndex) + 1;
+          indicesData[row].push_back(index);
+        }
+      }
+    }
+
+    return makeNullableArrayVector(indicesData);
+  }
+
+  // Generate indices with mix of valid, invalid (out of bounds, zero,
+  // negative).
+  ArrayVectorPtr makeMixedIndicesArray(
+      vector_size_t numRows,
+      vector_size_t indicesPerRow,
+      int32_t maxValidIndex,
+      double nullRatio = 0.0) {
+    std::vector<std::vector<std::optional<int32_t>>> indicesData(numRows);
+    std::mt19937 rng(42);
+
+    for (vector_size_t row = 0; row < numRows; ++row) {
+      indicesData[row].reserve(indicesPerRow);
+      for (vector_size_t i = 0; i < indicesPerRow; ++i) {
+        if (nullRatio > 0.0 &&
+            (rng() % 100) < static_cast<int>(nullRatio * 100)) {
+          indicesData[row].push_back(std::nullopt);
+        } else {
+          int choice = rng() % 4;
+          if (choice == 0) {
+            // Valid index [1, maxValidIndex]
+            indicesData[row].push_back((rng() % maxValidIndex) + 1);
+          } else if (choice == 1) {
+            // Out of bounds (too large)
+            indicesData[row].push_back(maxValidIndex + (rng() % 100) + 1);
+          } else if (choice == 2) {
+            // Zero
+            indicesData[row].push_back(0);
+          } else {
+            // Negative
+            indicesData[row].push_back(-static_cast<int32_t>(rng() % 100) - 1);
+          }
+        }
+      }
+    }
+
+    return makeNullableArrayVector(indicesData);
+  }
+};
+
+// Fuzz test with flat vectors, no nulls, fixed-size arrays
+TEST_F(ArraySubsetFuzzerTest, fuzzFlatNoNulls) {
+  VectorFuzzer::Options options;
+  options.vectorSize = 100;
+  options.nullRatio = 0.0;
+  options.containerHasNulls = false;
+  options.containerLength = 10;
+  options.containerVariableLength = false;
+
+  VectorFuzzer fuzzer(options, pool());
+
+  for (auto i = 0; i < 10; ++i) {
+    // Generate random integer arrays
+    auto inputArray = fuzzer.fuzz(ARRAY(INTEGER()));
+
+    // Generate indices in valid range [1, containerLength] to actually test
+    // the subset extraction logic, not just the index filtering
+    auto indices = makeValidIndicesArray(
+        options.vectorSize, 5, options.containerLength, 0.0);
+
+    auto data = makeRowVector({inputArray, indices});
+    testEquivalence(data);
+  }
+}
+
+// Fuzz test with nulls in arrays and indices
+TEST_F(ArraySubsetFuzzerTest, fuzzWithNulls) {
+  VectorFuzzer::Options options;
+  options.vectorSize = 100;
+  options.nullRatio = 0.1;
+  options.containerHasNulls = true;
+  options.containerLength = 10;
+  options.containerVariableLength = true;
+
+  VectorFuzzer fuzzer(options, pool());
+
+  for (auto i = 0; i < 10; ++i) {
+    auto inputArray = fuzzer.fuzz(ARRAY(INTEGER()));
+    // Use mixed indices (valid, invalid, nulls) to test various edge cases
+    auto indices = makeMixedIndicesArray(
+        options.vectorSize, 8, options.containerLength, options.nullRatio);
+
+    auto data = makeRowVector({inputArray, indices});
+    testEquivalence(data);
+  }
+}
+
+// Fuzz test with dictionary-encoded vectors
+TEST_F(ArraySubsetFuzzerTest, fuzzDictionaryEncoded) {
+  VectorFuzzer::Options options;
+  options.vectorSize = 100;
+  options.nullRatio = 0.1;
+  options.containerHasNulls = true;
+  options.containerLength = 10;
+  options.containerVariableLength = true;
+
+  VectorFuzzer fuzzer(options, pool());
+
+  for (auto i = 0; i < 10; ++i) {
+    // Generate base vectors
+    auto baseInputArray = fuzzer.fuzz(ARRAY(INTEGER()));
+    auto baseIndices = makeMixedIndicesArray(
+        options.vectorSize, 8, options.containerLength, options.nullRatio);
+
+    // Wrap in dictionary encoding
+    auto inputArray = fuzzer.fuzzDictionary(baseInputArray, options.vectorSize);
+    auto indices = fuzzer.fuzzDictionary(baseIndices, options.vectorSize);
+
+    auto data = makeRowVector({inputArray, indices});
+
+    // Flatten for comparison
+    auto flatData = makeRowVector({flatten(inputArray), flatten(indices)});
+
+    // Verify results match between dictionary and flat encodings
+    auto result = evaluate("array_subset(c0, c1)", data);
+    auto expectedResult = evaluate("array_subset(c0, c1)", flatData);
+    assertEqualVectors(expectedResult, result);
+
+    // Also verify against the equivalent expression
+    testEquivalence(flatData);
+  }
+}
+
+// Fuzz test with variable-length arrays and high null ratio
+TEST_F(ArraySubsetFuzzerTest, fuzzVariableLengthWithHighNullRatio) {
+  VectorFuzzer::Options options;
+  options.vectorSize = 100;
+  options.nullRatio = 0.3;
+  options.containerHasNulls = true;
+  options.containerLength = 20;
+  options.containerVariableLength = true;
+
+  VectorFuzzer fuzzer(options, pool());
+
+  for (auto i = 0; i < 10; ++i) {
+    auto inputArray = fuzzer.fuzz(ARRAY(INTEGER()));
+    // Use high null ratio in indices to match the test's intent
+    auto indices = makeMixedIndicesArray(
+        options.vectorSize, 10, options.containerLength, options.nullRatio);
+
+    auto data = makeRowVector({inputArray, indices});
+    testEquivalence(data);
+  }
+}
+
+// Fuzz test with string arrays
+TEST_F(ArraySubsetFuzzerTest, fuzzStringArrays) {
+  VectorFuzzer::Options options;
+  options.vectorSize = 100;
+  options.nullRatio = 0.1;
+  options.containerHasNulls = true;
+  options.containerLength = 10;
+  options.containerVariableLength = true;
+  options.stringLength = 20;
+  options.stringVariableLength = true;
+
+  VectorFuzzer fuzzer(options, pool());
+
+  for (auto i = 0; i < 10; ++i) {
+    auto inputArray = fuzzer.fuzz(ARRAY(VARCHAR()));
+    auto indices = makeMixedIndicesArray(
+        options.vectorSize, 8, options.containerLength, options.nullRatio);
+
+    auto data = makeRowVector({inputArray, indices});
+    testEquivalence(data);
+  }
+}
+
+// Fuzz test with nested arrays (array of arrays)
+TEST_F(ArraySubsetFuzzerTest, fuzzNestedArrays) {
+  VectorFuzzer::Options options;
+  options.vectorSize = 50;
+  options.nullRatio = 0.1;
+  options.containerHasNulls = true;
+  options.containerLength = 5;
+  options.containerVariableLength = true;
+
+  VectorFuzzer fuzzer(options, pool());
+
+  for (auto i = 0; i < 10; ++i) {
+    auto inputArray = fuzzer.fuzz(ARRAY(ARRAY(INTEGER())));
+    auto indices = makeMixedIndicesArray(
+        options.vectorSize, 5, options.containerLength, options.nullRatio);
+
+    auto data = makeRowVector({inputArray, indices});
+    testEquivalence(data);
+  }
+}
+
+// Fuzz test with empty arrays
+TEST_F(ArraySubsetFuzzerTest, fuzzWithEmptyArrays) {
+  VectorFuzzer::Options options;
+  options.vectorSize = 100;
+  options.nullRatio = 0.1;
+  options.containerHasNulls = true;
+  // Use very small container length to increase likelihood of empty arrays
+  options.containerLength = 2;
+  options.containerVariableLength = true;
+
+  VectorFuzzer fuzzer(options, pool());
+
+  for (auto i = 0; i < 10; ++i) {
+    auto inputArray = fuzzer.fuzz(ARRAY(INTEGER()));
+    auto indices = makeMixedIndicesArray(
+        options.vectorSize, 3, options.containerLength, options.nullRatio);
+
+    auto data = makeRowVector({inputArray, indices});
+    testEquivalence(data);
+  }
+}
+
+// Fuzz test with various numeric types
+TEST_F(ArraySubsetFuzzerTest, fuzzVariousNumericTypes) {
+  VectorFuzzer::Options options;
+  options.vectorSize = 100;
+  options.nullRatio = 0.1;
+  options.containerHasNulls = true;
+  options.containerLength = 10;
+  options.containerVariableLength = true;
+
+  VectorFuzzer fuzzer(options, pool());
+
+  // Test with BIGINT
+  for (auto i = 0; i < 5; ++i) {
+    auto inputArray = fuzzer.fuzz(ARRAY(BIGINT()));
+    auto indices = makeMixedIndicesArray(
+        options.vectorSize, 8, options.containerLength, options.nullRatio);
+    auto data = makeRowVector({inputArray, indices});
+    testEquivalence(data);
+  }
+
+  // Test with DOUBLE
+  for (auto i = 0; i < 5; ++i) {
+    auto inputArray = fuzzer.fuzz(ARRAY(DOUBLE()));
+    auto indices = makeMixedIndicesArray(
+        options.vectorSize, 8, options.containerLength, options.nullRatio);
+    auto data = makeRowVector({inputArray, indices});
+    testEquivalence(data);
+  }
+
+  // Test with BOOLEAN
+  for (auto i = 0; i < 5; ++i) {
+    auto inputArray = fuzzer.fuzz(ARRAY(BOOLEAN()));
+    auto indices = makeMixedIndicesArray(
+        options.vectorSize, 8, options.containerLength, options.nullRatio);
+    auto data = makeRowVector({inputArray, indices});
+    testEquivalence(data);
+  }
+}
+
+// Fuzz test with constant vectors
+TEST_F(ArraySubsetFuzzerTest, fuzzConstantVectors) {
+  VectorFuzzer::Options options;
+  options.vectorSize = 100;
+  options.nullRatio = 0.0;
+  options.containerHasNulls = false;
+  options.containerLength = 5;
+  options.containerVariableLength = false;
+
+  VectorFuzzer fuzzer(options, pool());
+
+  for (auto i = 0; i < 10; ++i) {
+    // Create a constant input array
+    auto inputArray = fuzzer.fuzzConstant(ARRAY(INTEGER()), options.vectorSize);
+
+    // Create varying indices with mix of valid and invalid values
+    auto indices =
+        makeMixedIndicesArray(options.vectorSize, 5, options.containerLength);
+
+    auto data = makeRowVector({inputArray, indices});
+    testEquivalence(data);
+  }
+}
+
+// Stress test with large vectors
+TEST_F(ArraySubsetFuzzerTest, fuzzLargeVectors) {
+  VectorFuzzer::Options options;
+  options.vectorSize = 1000;
+  options.nullRatio = 0.1;
+  options.containerHasNulls = true;
+  options.containerLength = 50;
+  options.containerVariableLength = true;
+
+  VectorFuzzer fuzzer(options, pool());
+
+  for (auto i = 0; i < 5; ++i) {
+    auto inputArray = fuzzer.fuzz(ARRAY(INTEGER()));
+    auto indices = makeMixedIndicesArray(
+        options.vectorSize, 20, options.containerLength, options.nullRatio);
+
+    auto data = makeRowVector({inputArray, indices});
+    testEquivalence(data);
+  }
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/BinaryFunctionsTest.cpp b/velox/functions/prestosql/tests/BinaryFunctionsTest.cpp
index d5ceeea9a4b..f3fa396a140 100644
--- a/velox/functions/prestosql/tests/BinaryFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/BinaryFunctionsTest.cpp
@@ -329,6 +329,53 @@ TEST_F(BinaryFunctionsTest, xxhash64WithSeed) {
   EXPECT_NE(hexToDec("26C7827D889F6DA3"), xxhash64WithSeed("hello", 1224));
 }
 
+TEST_F(BinaryFunctionsTest, fnv1_32) {
+  const auto fnv1_32 = [&](std::optional<std::string> arg) {
+    return evaluateOnce<int32_t>("fnv1_32(c0)", VARBINARY(), arg);
+  };
+  EXPECT_EQ(std::nullopt, fnv1_32(std::nullopt));
+  EXPECT_EQ(0x811c9dc5, fnv1_32(""));
+  EXPECT_EQ(0x050c5d06, fnv1_32(hexToDec("19")));
+  EXPECT_EQ(0x050c5dea, fnv1_32(hexToDec("F5")));
+  EXPECT_EQ(0x087689bb, fnv1_32(hexToDec("0919")));
+  EXPECT_EQ(0x67a7fdec, fnv1_32(hexToDec("F50919")));
+  EXPECT_EQ(0x9f2263f3, fnv1_32(hexToDec("232706FC6BF50919")));
+}
+
+TEST_F(BinaryFunctionsTest, fnv1_64) {
+  const auto fnv1_64 = [&](std::optional<std::string> arg) {
+    return evaluateOnce<int64_t>("fnv1_64(c0)", VARBINARY(), arg);
+  };
+
+  EXPECT_EQ(std::nullopt, fnv1_64(std::nullopt));
+  EXPECT_EQ(0xcbf29ce484222325L, fnv1_64(""));
+  EXPECT_EQ(0x4a65ff96675a9f33L, fnv1_64(hexToDec("232706FC6BF50919")));
+}
+
+TEST_F(BinaryFunctionsTest, fnv1a_32) {
+  const auto fnv1a_32 = [&](std::optional<std::string> arg) {
+    return evaluateOnce<int32_t>("fnv1a_32(c0)", VARBINARY(), arg);
+  };
+
+  EXPECT_EQ(std::nullopt, fnv1a_32(std::nullopt));
+  EXPECT_EQ(0x811c9dc5, fnv1a_32(""));
+  EXPECT_EQ(0x1c0c8154, fnv1a_32(hexToDec("19")));
+  EXPECT_EQ(0x700b7290, fnv1a_32(hexToDec("F5")));
+  EXPECT_EQ(0x34881807, fnv1a_32(hexToDec("0919")));
+  EXPECT_EQ(0xeb80c366, fnv1a_32(hexToDec("F50919")));
+  EXPECT_EQ(0x0951d55f, fnv1a_32(hexToDec("232706FC6BF50919")));
+}
+
+TEST_F(BinaryFunctionsTest, fnv1a_64) {
+  const auto fnv1a_64 = [&](std::optional<std::string> arg) {
+    return evaluateOnce<int64_t>("fnv1a_64(c0)", VARBINARY(), arg);
+  };
+
+  EXPECT_EQ(std::nullopt, fnv1a_64(std::nullopt));
+  EXPECT_EQ(0xcbf29ce484222325L, fnv1a_64(""));
+  EXPECT_EQ(0x68addc0b0febac5fL, fnv1a_64(hexToDec("232706FC6BF50919")));
+}
+
 TEST_F(BinaryFunctionsTest, toHex) {
   const auto toHex = [&](std::optional<std::string> value) {
     return evaluateOnce<std::string>("to_hex(cast(c0 as varbinary))", value);
@@ -382,6 +429,23 @@ TEST_F(BinaryFunctionsTest, fromHex) {
   EXPECT_EQ(
       "12PasXXaWBQ0k1T88jiF",
       fromHexToBase64("D763DAB175DA5814349354FCF23885"));
+
+  // Test from_hex with VARBINARY input
+  const auto fromHexVarbinary = [&](std::optional<std::string> value) {
+    return evaluateOnce<std::string>(
+        "from_hex(cast(c0 as varbinary))", std::move(value));
+  };
+
+  EXPECT_EQ(std::nullopt, fromHexVarbinary(std::nullopt));
+  EXPECT_EQ("", fromHexVarbinary(""));
+  EXPECT_EQ("a", fromHexVarbinary("61"));
+  EXPECT_EQ("abc", fromHexVarbinary("616263"));
+  EXPECT_EQ("hello world", fromHexVarbinary("68656C6C6F20776F726C64"));
+  EXPECT_EQ(
+      "Hello World from Velox!",
+      fromHexVarbinary("48656C6C6F20576F726C642066726F6D2056656C6F7821"));
+
+  EXPECT_THROW(fromHexVarbinary("fff"), VeloxUserError);
 }
 
 TEST_F(BinaryFunctionsTest, toBase64) {
@@ -494,6 +558,25 @@ TEST_F(BinaryFunctionsTest, fromBase64Url) {
   EXPECT_THROW(fromBase64Url("YQ==="), VeloxUserError);
   EXPECT_THROW(fromBase64Url("YQ=+"), VeloxUserError);
   EXPECT_THROW(fromBase64Url("YQ=/"), VeloxUserError);
+
+  // Test from_base64url with VARBINARY input
+  const auto fromBase64UrlVarbinary = [&](std::optional<std::string> value) {
+    return evaluateOnce<std::string>(
+        "from_base64url(cast(c0 as varbinary))", std::move(value));
+  };
+
+  EXPECT_EQ(std::nullopt, fromBase64UrlVarbinary(std::nullopt));
+  EXPECT_EQ("", fromBase64UrlVarbinary(""));
+  EXPECT_EQ("a", fromBase64UrlVarbinary("YQ=="));
+  EXPECT_EQ("a", fromBase64UrlVarbinary("YQ"));
+  EXPECT_EQ("abc", fromBase64UrlVarbinary("YWJj"));
+  EXPECT_EQ("hello world", fromBase64UrlVarbinary("aGVsbG8gd29ybGQ="));
+  EXPECT_EQ(
+      "Hello World from Velox!",
+      fromBase64UrlVarbinary("SGVsbG8gV29ybGQgZnJvbSBWZWxveCE="));
+
+  EXPECT_EQ(fromHex("FF4FBF50"), fromBase64UrlVarbinary("_0-_UA=="));
+  EXPECT_THROW(fromBase64UrlVarbinary("YQ="), VeloxUserError);
 }
 
 TEST_F(BinaryFunctionsTest, fromBigEndian32) {
@@ -780,10 +863,11 @@ TEST_F(BinaryFunctionsTest, fromIEEE754Bits32) {
       std::isnan(fromIEEE754Bits32(
                      toIEEE754Bits32(std::numeric_limits<float>::quiet_NaN()))
                      .value()));
-  EXPECT_TRUE(std::isnan(
-      fromIEEE754Bits32(
-          toIEEE754Bits32(std::numeric_limits<float>::signaling_NaN()))
-          .value()));
+  EXPECT_TRUE(
+      std::isnan(
+          fromIEEE754Bits32(
+              toIEEE754Bits32(std::numeric_limits<float>::signaling_NaN()))
+              .value()));
   EXPECT_TRUE(
       std::isnan(fromIEEE754Bits32(toIEEE754Bits32(std::nan("nan"))).value()));
   VELOX_ASSERT_THROW(
@@ -866,4 +950,67 @@ TEST_F(BinaryFunctionsTest, murmur3_x64_128) {
   EXPECT_EQ(murmur3_x64_128(std::nullopt), std::nullopt);
 }
 
+TEST_F(BinaryFunctionsTest, fromBase32) {
+  const auto fromBase32 = [&](const std::optional<std::string>& value) {
+    // from_base32 allows VARCHAR and VARBINARY inputs.
+    auto result =
+        evaluateOnce<std::string>("from_base32(c0)", VARCHAR(), value);
+    auto otherResult =
+        evaluateOnce<std::string>("from_base32(c0)", VARBINARY(), value);
+
+    VELOX_CHECK_EQ(result.has_value(), otherResult.has_value());
+
+    if (!result.has_value()) {
+      return result;
+    }
+
+    EXPECT_EQ(result.value(), otherResult.value());
+    return result;
+  };
+
+  // Basic decoding tests
+  EXPECT_EQ("", fromBase32(""));
+  EXPECT_EQ("a", fromBase32("ME======"));
+  EXPECT_EQ("abc", fromBase32("MFRGG==="));
+  EXPECT_EQ("hello world", fromBase32("NBSWY3DPEB3W64TMMQ======"));
+
+  // Null handling
+  EXPECT_EQ(std::nullopt, fromBase32(std::nullopt));
+
+  // Test padding is optional (RFC 4648)
+  EXPECT_EQ("a", fromBase32("ME"));
+  EXPECT_EQ("abc", fromBase32("MFRGG"));
+
+  // Invalid input tests
+  VELOX_ASSERT_USER_THROW(fromBase32("1="), "Unrecognized character: 1");
+  VELOX_ASSERT_USER_THROW(fromBase32("M1======"), "Unrecognized character: 1");
+  VELOX_ASSERT_USER_THROW(fromBase32("M!======"), "Unrecognized character: !");
+
+  // Test lowercase is rejected
+  VELOX_ASSERT_USER_THROW(fromBase32("me======"), "Unrecognized character: m");
+  VELOX_ASSERT_USER_THROW(fromBase32("MFRGG===a"), "Unrecognized character: a");
+
+  // Test invalid Base32 characters 0, 1, 8, 9
+  VELOX_ASSERT_USER_THROW(fromBase32("M0======"), "Unrecognized character: 0");
+  VELOX_ASSERT_USER_THROW(fromBase32("M8======"), "Unrecognized character: 8");
+  VELOX_ASSERT_USER_THROW(fromBase32("M9======"), "Unrecognized character: 9");
+
+  // Test invalid input lengths (matching Google Guava's Base32 behavior)
+  // Invalid lengths mod 8 are: 1, 3, 6
+  // Single character (1 mod 8)
+  VELOX_ASSERT_USER_THROW(fromBase32("A"), "Invalid input length 1");
+  VELOX_ASSERT_USER_THROW(fromBase32("M======="), "Invalid input length 1");
+  // Three characters (3 mod 8)
+  VELOX_ASSERT_USER_THROW(fromBase32("XEV"), "Invalid input length 3");
+  VELOX_ASSERT_USER_THROW(fromBase32("ABC"), "Invalid input length 3");
+  // Six characters (6 mod 8)
+  VELOX_ASSERT_USER_THROW(fromBase32("ABCDEF"), "Invalid input length 6");
+  VELOX_ASSERT_USER_THROW(fromBase32("MFRGGM"), "Invalid input length 6");
+  // 11 characters (3 mod 8)
+  VELOX_ASSERT_USER_THROW(fromBase32("NBSWY3DPEB3"), "Invalid input length 11");
+  // 14 characters (6 mod 8)
+  VELOX_ASSERT_USER_THROW(
+      fromBase32("NBSWY3DPEB3W64"), "Invalid input length 14");
+}
+
 } // namespace
diff --git a/velox/functions/prestosql/tests/BingTileFunctionsTest.cpp b/velox/functions/prestosql/tests/BingTileFunctionsTest.cpp
index aeacc485422..b6e3673e897 100644
--- a/velox/functions/prestosql/tests/BingTileFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/BingTileFunctionsTest.cpp
@@ -459,8 +459,8 @@ TEST_F(BingTileFunctionsTest, bingTileChildrenZoom) {
   VELOX_ASSERT_USER_THROW(
       testBingTileChildren(0, 0, 2, 1), "Child zoom 1 must be >= tile zoom 2");
   VELOX_ASSERT_USER_THROW(
-      testBingTileChildren(0, 0, 1, 7),
-      "Difference between parent zoom (1) and child zoom (7) must be <= 5");
+      testBingTileChildren(0, 0, 1, 9),
+      "Difference between parent zoom (1) and child zoom (9) must be <= 7");
 
   {
     RowVectorPtr input = makeSingleXYZoomZoomRow(0, 0, 1, 7);
@@ -473,7 +473,7 @@ TEST_F(BingTileFunctionsTest, bingTileChildrenZoom) {
         evaluate("bing_tile_children(bing_tile(c0, c1, c2), c3)", input),
         "Difference between parent zoom (1) and child zoom (15) must be <= 10");
     queryCtx_->testingOverrideConfigUnsafe(
-        {{core::QueryConfig::kDebugBingTileChildrenMaxZoomShift, "5"}});
+        {{core::QueryConfig::kDebugBingTileChildrenMaxZoomShift, "6"}});
   }
 }
 
diff --git a/velox/functions/prestosql/tests/CMakeLists.txt b/velox/functions/prestosql/tests/CMakeLists.txt
index 50fb05afbe2..d672dc1fc50 100644
--- a/velox/functions/prestosql/tests/CMakeLists.txt
+++ b/velox/functions/prestosql/tests/CMakeLists.txt
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+add_subdirectory(resources)
 add_subdirectory(utils)
 
 add_executable(
@@ -43,15 +44,21 @@ add_executable(
   ArrayPositionTest.cpp
   ArrayRemoveTest.cpp
   ArrayShuffleTest.cpp
+  ArraySplitIntoChunksTest.cpp
   ArraySortTest.cpp
+  ArraySubsetTest.cpp
+  L2NormTest.cpp
   ArrayTopNTest.cpp
   ArraysOverlapTest.cpp
   ArraySumTest.cpp
   ArrayTrimTest.cpp
   ArrayUnionTest.cpp
+  DotProductTest.cpp
+  DotProductFuzzerTest.cpp
   ArgTypesGeneratorTest.cpp
   BinaryFunctionsTest.cpp
   BingTileCastTest.cpp
+  BingTileFunctionsTest.cpp
   BitwiseTest.cpp
   CardinalityTest.cpp
   CeilFloorTest.cpp
@@ -68,7 +75,10 @@ add_executable(
   GreatestLeastTest.cpp
   HyperLogLogCastTest.cpp
   HyperLogLogFunctionsTest.cpp
+  KHyperLogLogCastTest.cpp
+  KHyperLogLogFunctionsTest.cpp
   P4HyperLogLogCastTest.cpp
+  SetDigestCastTest.cpp
   InPredicateTest.cpp
   IntegerFunctionsTest.cpp
   IPAddressCastTest.cpp
@@ -79,15 +89,25 @@ add_executable(
   MapEntriesTest.cpp
   MapFilterTest.cpp
   MapFromEntriesTest.cpp
+  MapIntersectTest.cpp
+  MapKeysOverlapTest.cpp
   MapNormalizeTest.cpp
+  MapValuesInRangeTest.cpp
+  MapSubsetKeyInRangeTest.cpp
+  RemapKeysTest.cpp
   MapTopNTest.cpp
   MapTopNKeysTest.cpp
   MapTopNValuesTest.cpp
+  MapTrimValuesTest.cpp
   MapKeysAndValuesTest.cpp
   MapKeysByTopNValuesTest.cpp
   MapMatchTest.cpp
+  MapValuesMatchTest.cpp
+  MapAppendTest.cpp
+  MapUpdateTest.cpp
   MapTest.cpp
   MapZipWithTest.cpp
+  MapExceptTest.cpp
   MultimapFromEntriesTest.cpp
   NotTest.cpp
   ParsePrestoDataSizeTest.cpp
@@ -108,9 +128,11 @@ add_executable(
   SplitToMultiMapTest.cpp
   StringFunctionsTest.cpp
   TimestampWithTimeZoneCastTest.cpp
+  TimeWithTimezoneCastTest.cpp
   TransformKeysTest.cpp
   TransformTest.cpp
   TransformValuesTest.cpp
+  TransformWithIndexTest.cpp
   TrimFunctionsTest.cpp
   TypeOfTest.cpp
   TDigestCastTest.cpp
@@ -125,7 +147,7 @@ add_executable(
 )
 
 if(VELOX_ENABLE_GEO)
-  target_sources(velox_functions_test PRIVATE GeometryFunctionsTest.cpp)
+  target_sources(velox_functions_test PRIVATE GeometryFunctionsTest.cpp S2FunctionsTest.cpp)
 endif()
 
 if(VELOX_ENABLE_FAISS)
@@ -154,3 +176,5 @@ target_link_libraries(
   GTest::gmock
   GTest::gmock_main
 )
+
+velox_add_library(velox_cast_base_test_helper INTERFACE HEADERS CastBaseTest.h)
diff --git a/velox/functions/prestosql/tests/CardinalityTest.cpp b/velox/functions/prestosql/tests/CardinalityTest.cpp
index 144d73462f4..35c32bc9632 100644
--- a/velox/functions/prestosql/tests/CardinalityTest.cpp
+++ b/velox/functions/prestosql/tests/CardinalityTest.cpp
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#include "velox/functions/prestosql/Cardinality.h"
+#include "velox/functions/Registerer.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 
 using namespace facebook::velox;
@@ -24,14 +26,17 @@ namespace {
 
 class CardinalityTest : public FunctionBaseTest {
  protected:
+  template <typename TResult>
   void testArrayCardinality(
+      const std::string& functionName,
       std::function<vector_size_t(vector_size_t /* row */)> sizeAt,
       std::function<bool(vector_size_t /*row */)> isNullAt) {
     vector_size_t numRows = 100;
     auto arrayVector =
         makeArrayVector<int64_t>(numRows, sizeAt, valueAt, isNullAt);
-    auto result = evaluate<SimpleVector<int64_t>>(
-        "cardinality(c0)", makeRowVector({arrayVector}));
+    auto expr = fmt::format("{}(c0)", functionName);
+    auto result =
+        evaluate<SimpleVector<TResult>>(expr, makeRowVector({arrayVector}));
     for (vector_size_t i = 0; i < numRows; ++i) {
       EXPECT_EQ(result->isNullAt(i), arrayVector->isNullAt(i)) << "at " << i;
       if (!arrayVector->isNullAt(i)) {
@@ -40,14 +45,17 @@ class CardinalityTest : public FunctionBaseTest {
     }
   }
 
+  template <typename TResult>
   void testMapCardinality(
+      const std::string& functionName,
       std::function<vector_size_t(vector_size_t /* row */)> sizeAt,
       std::function<bool(vector_size_t /*row */)> isNullAt) {
     vector_size_t numRows = 100;
     auto mapVector = makeMapVector<int64_t, int64_t>(
         numRows, sizeAt, valueAt, valueAt, isNullAt);
-    auto result = evaluate<SimpleVector<int64_t>>(
-        "cardinality(c0)", makeRowVector({mapVector}));
+    auto expr = fmt::format("{}(c0)", functionName);
+    auto result =
+        evaluate<SimpleVector<TResult>>(expr, makeRowVector({mapVector}));
     for (vector_size_t i = 0; i < numRows; ++i) {
       EXPECT_EQ(result->isNullAt(i), mapVector->isNullAt(i)) << "at " << i;
       if (!mapVector->isNullAt(i)) {
@@ -56,6 +64,20 @@ class CardinalityTest : public FunctionBaseTest {
     }
   }
 
+  template <typename TResult>
+  void testArrayCardinality(const std::string& functionName) {
+    auto sizeAt = [](vector_size_t row) { return 1 + row % 7; };
+    testArrayCardinality<TResult>(functionName, sizeAt, nullptr);
+    testArrayCardinality<TResult>(functionName, sizeAt, nullEvery(5));
+  }
+
+  template <typename TResult>
+  void testMapCardinality(const std::string& functionName) {
+    auto sizeAt = [](vector_size_t row) { return 1 + row % 7; };
+    testMapCardinality<TResult>(functionName, sizeAt, nullptr);
+    testMapCardinality<TResult>(functionName, sizeAt, nullEvery(5));
+  }
+
   static inline vector_size_t valueAt(vector_size_t idx) {
     return idx + 1;
   }
@@ -63,13 +85,25 @@ class CardinalityTest : public FunctionBaseTest {
 } // namespace
 
 TEST_F(CardinalityTest, array) {
-  auto sizeAt = [](vector_size_t row) { return 1 + row % 7; };
-  testArrayCardinality(sizeAt, nullptr);
-  testArrayCardinality(sizeAt, nullEvery(5));
+  testArrayCardinality<int64_t>("cardinality");
 }
 
 TEST_F(CardinalityTest, map) {
-  auto sizeAt = [](vector_size_t row) { return 1 + row % 7; };
-  testMapCardinality(sizeAt, nullptr);
-  testMapCardinality(sizeAt, nullEvery(5));
+  testMapCardinality<int64_t>("cardinality");
+}
+
+TEST_F(CardinalityTest, arrayInteger) {
+  static constexpr std::string_view kCardinalityInteger{"cardinality_integer"};
+  registerFunction<functions::CardinalityFunction, int32_t, Array<Generic<T1>>>(
+      {std::string{kCardinalityInteger}});
+  testArrayCardinality<int32_t>(std::string{kCardinalityInteger});
+}
+
+TEST_F(CardinalityTest, mapInteger) {
+  static constexpr std::string_view kCardinalityInteger{"cardinality_integer"};
+  registerFunction<
+      functions::CardinalityFunction,
+      int32_t,
+      Map<Generic<T1>, Generic<T2>>>({std::string{kCardinalityInteger}});
+  testMapCardinality<int32_t>(std::string{kCardinalityInteger});
 }
diff --git a/velox/functions/prestosql/tests/CastBaseTest.h b/velox/functions/prestosql/tests/CastBaseTest.h
index 5428e49930e..8bbdf715533 100644
--- a/velox/functions/prestosql/tests/CastBaseTest.h
+++ b/velox/functions/prestosql/tests/CastBaseTest.h
@@ -209,8 +209,9 @@ class CastBaseTest : public FunctionBaseTest {
       std::optional<bool> isTryCast = std::nullopt) {
     const auto& fromType = input->type();
     const auto& toType = expected->type();
-    SCOPED_TRACE(fmt::format(
-        "Cast from {} to {}", fromType->toString(), toType->toString()));
+    SCOPED_TRACE(
+        fmt::format(
+            "Cast from {} to {}", fromType->toString(), toType->toString()));
     const auto copy = createCopy(input);
     // Test with flat encoding.
     {
diff --git a/velox/functions/prestosql/tests/ComparisonsTest.cpp b/velox/functions/prestosql/tests/ComparisonsTest.cpp
index b3655e2f9f3..370f9feb9bb 100644
--- a/velox/functions/prestosql/tests/ComparisonsTest.cpp
+++ b/velox/functions/prestosql/tests/ComparisonsTest.cpp
@@ -1450,7 +1450,7 @@ TEST_F(ComparisonsTest, IPPrefixType) {
 }
 
 TEST_F(ComparisonsTest, IpAddressType) {
-  auto makeIpAdressFromString = [](const std::string& ipAddr) -> int128_t {
+  auto makeIpAdressFromString = [](std::string_view ipAddr) -> int128_t {
     auto ret = ipaddress::tryGetIPv6asInt128FromString(ipAddr);
     return ret.value();
   };
diff --git a/velox/functions/prestosql/tests/DateTimeFunctionsTest.cpp b/velox/functions/prestosql/tests/DateTimeFunctionsTest.cpp
index c160fc1e2b2..73bd056819e 100644
--- a/velox/functions/prestosql/tests/DateTimeFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/DateTimeFunctionsTest.cpp
@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-#define XXH_INLINE_ALL
-#include <xxhash.h>
+#include "velox/common/base/XxHashInline.h"
 
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/external/tzdb/zoned_time.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 #include "velox/type/tz/TimeZoneMap.h"
 
@@ -84,6 +84,13 @@ class DateTimeFunctionsTest : public functions::test::FunctionBaseTest {
     });
   }
 
+  void setQuerySessionStartTime(int64_t sessionStartTime) {
+    queryCtx_->testingOverrideConfigUnsafe({
+        {core::QueryConfig::kSessionStartTime,
+         std::to_string(sessionStartTime)},
+    });
+  }
+
  public:
   // Helper class to manipulate timestamp with timezone types in tests. Provided
   // only for convenience.
@@ -147,12 +154,13 @@ class DateTimeFunctionsTest : public functions::test::FunctionBaseTest {
   }
 
   int32_t getCurrentDate(const std::optional<std::string>& timeZone) {
-    return parseDate(date::format(
-        "%Y-%m-%d",
-        timeZone.has_value()
-            ? tzdb::zoned_time(
-                  timeZone.value(), std::chrono::system_clock::now())
-            : tzdb::zoned_time(std::chrono::system_clock::now())));
+    return parseDate(
+        date::format(
+            "%Y-%m-%d",
+            timeZone.has_value()
+                ? tzdb::zoned_time(
+                      timeZone.value(), std::chrono::system_clock::now())
+                : tzdb::zoned_time(std::chrono::system_clock::now())));
   }
 };
 
@@ -165,7 +173,7 @@ bool operator==(
 
 TEST_F(DateTimeFunctionsTest, dateTruncSignatures) {
   auto signatures = getSignatureStrings("date_trunc");
-  ASSERT_EQ(3, signatures.size());
+  ASSERT_EQ(4, signatures.size());
 
   ASSERT_EQ(
       1,
@@ -173,6 +181,7 @@ TEST_F(DateTimeFunctionsTest, dateTruncSignatures) {
           "(varchar,timestamp with time zone) -> timestamp with time zone"));
   ASSERT_EQ(1, signatures.count("(varchar,date) -> date"));
   ASSERT_EQ(1, signatures.count("(varchar,timestamp) -> timestamp"));
+  ASSERT_EQ(1, signatures.count("(varchar,time) -> time"));
 }
 
 TEST_F(DateTimeFunctionsTest, parseDatetimeSignatures) {
@@ -269,8 +278,9 @@ TEST_F(DateTimeFunctionsTest, fromUnixtimeRountTrip) {
 TEST_F(DateTimeFunctionsTest, fromUnixtimeWithTimeZone) {
   const auto fromUnixtime = [&](std::optional<double> timestamp,
                                 std::optional<std::string> timezoneName) {
-    return TimestampWithTimezone::unpack(evaluateOnce<int64_t>(
-        "from_unixtime(c0, c1)", timestamp, timezoneName));
+    return TimestampWithTimezone::unpack(
+        evaluateOnce<int64_t>(
+            "from_unixtime(c0, c1)", timestamp, timezoneName));
   };
 
   // Check null behavior.
@@ -745,6 +755,42 @@ TEST_F(DateTimeFunctionsTest, hourDate) {
   EXPECT_EQ(0, hour(-18262));
 }
 
+TEST_F(DateTimeFunctionsTest, hourTime) {
+  const auto hour = [&](std::optional<int64_t> time) {
+    return evaluateOnce<int64_t>("hour(c0)", TIME(), time);
+  };
+
+  // null handling
+  EXPECT_EQ(std::nullopt, hour(std::nullopt));
+
+  // boundary tests - core optimization: simple integer division by
+  // kMillisInHour (3600000) lower boundary: 0 <= time < 86400000
+  EXPECT_EQ(0, hour(0)); // exactly midnight
+  EXPECT_EQ(0, hour(3599999)); // 00:59:59.999 - last millisecond of hour 0
+  EXPECT_EQ(1, hour(3600000)); // 01:00:00.000 - first millisecond of hour 1
+  EXPECT_EQ(23, hour(82800000)); // 23:00:00.000 - first millisecond of hour 23
+  EXPECT_EQ(23, hour(86399999)); // 23:59:59.999 - upper boundary exclusive
+
+  // representative samples across all hours
+  EXPECT_EQ(12, hour(43200000)); // noon exactly
+  EXPECT_EQ(18, hour(64800000)); // 18:00:00.000
+
+  // verify optimization correctness: hour = time / kMillisInHour
+  // random test cases to ensure division behaves correctly
+  EXPECT_EQ(5, hour(19800000)); // 05:30:00.000
+  EXPECT_EQ(10, hour(37800000)); // 10:30:00.000
+  EXPECT_EQ(15, hour(54000000)); // 15:00:00.000
+
+  // error conditions - invalid range validation
+  EXPECT_THROW(hour(-1), VeloxUserError); // negative time
+  EXPECT_THROW(
+      hour(86400000),
+      VeloxUserError); // exactly 24:00:00.000 (exclusive upper bound)
+  EXPECT_THROW(
+      hour(std::numeric_limits<int64_t>::max()),
+      VeloxUserError); // overflow case
+}
+
 TEST_F(DateTimeFunctionsTest, dayOfMonth) {
   const auto day = [&](std::optional<Timestamp> date) {
     return evaluateOnce<int64_t>("day_of_month(c0)", date);
@@ -1110,6 +1156,337 @@ TEST_F(DateTimeFunctionsTest, minusTimestamp) {
       "Could not convert Timestamp(-9223372036854776, 0) to milliseconds");
 }
 
+TEST_F(DateTimeFunctionsTest, timeIntervalDayTime) {
+  // Test TIME + IntervalDayTime and IntervalDayTime + TIME arithmetic
+
+  // Helper for Time + IntervalDayTime (also tests commutativity)
+  const auto testTimePlusIntervalCommutative =
+      [&](int64_t time, int64_t interval) -> std::optional<int64_t> {
+    auto result1 = evaluateOnce<int64_t>(
+        "plus(c0, c1)",
+        makeRowVector({
+            makeNullableFlatVector<int64_t>({time}, TIME()),
+            makeNullableFlatVector<int64_t>({interval}, INTERVAL_DAY_TIME()),
+        }));
+
+    auto result2 = evaluateOnce<int64_t>(
+        "plus(c0, c1)",
+        makeRowVector({
+            makeNullableFlatVector<int64_t>({interval}, INTERVAL_DAY_TIME()),
+            makeNullableFlatVector<int64_t>({time}, TIME()),
+        }));
+
+    EXPECT_EQ(result1, result2);
+    return result1;
+  };
+
+  // Basic hour addition: 03:04:05.321 + 3 hours = 06:04:05.321
+  // 03:04:05.321 = (3*3600 + 4*60 + 5)*1000 + 321 = 11045321 ms
+  // 3 hours = 3*60*60*1000 = 10800000 ms
+  // 06:04:05.321 = (6*3600 + 4*60 + 5)*1000 + 321 = 21845321 ms
+  const int64_t time1 = 11045321; // 03:04:05.321
+  const int64_t threeHours = 3 * kMillisInHour; // 3 hours
+  EXPECT_EQ(21845321, testTimePlusIntervalCommutative(time1, threeHours));
+
+  // Test 24-hour wraparound: 22:00:00 + 3 hours = 01:00:00
+  // 22:00:00 = 22*3600*1000 = 79200000 ms
+  // 01:00:00 = 1*3600*1000 = 3600000 ms
+  const int64_t time2 = 22 * kMillisInHour; // 22:00:00
+  EXPECT_EQ(3600000, testTimePlusIntervalCommutative(time2, threeHours));
+
+  // Test minute addition: 03:04:05.321 + 90 minutes = 04:34:05.321
+  // 90 minutes = 90*60*1000 = 5400000 ms
+  // 04:34:05.321 = (4*3600 + 34*60 + 5)*1000 + 321 = 16445321 ms
+  const int64_t ninetyMinutes = 90 * kMillisInMinute;
+  EXPECT_EQ(16445321, testTimePlusIntervalCommutative(time1, ninetyMinutes));
+
+  // Test negative intervals: 03:04:05.321 - 2 hours = 01:04:05.321
+  // 01:04:05.321 = (1*3600 + 4*60 + 5)*1000 + 321 = 3845321 ms
+  const int64_t twoHours = 2 * kMillisInHour;
+  EXPECT_EQ(3845321, testTimePlusIntervalCommutative(time1, -twoHours));
+
+  // Test negative wraparound: 01:00:00 - 3 hours = 22:00:00 (previous day)
+  // 01:00:00 = 1*3600*1000 = 3600000 ms
+  const int64_t time3 = kMillisInHour; // 01:00:00
+  EXPECT_EQ(79200000, testTimePlusIntervalCommutative(time3, -threeHours));
+
+  // Test millisecond precision: 03:04:05.321 + 679 milliseconds = 03:04:06.000
+  EXPECT_EQ(11046000, testTimePlusIntervalCommutative(time1, 679));
+
+  // Test day intervals (should not change time of day per Presto behavior)
+  // 12:30:45.123 = (12*3600 + 30*60 + 45)*1000 + 123 = 45045123 ms
+  const int64_t time4 = 45045123; // 12:30:45.123
+  const int64_t oneDay = kMillisInDay;
+  EXPECT_EQ(45045123, testTimePlusIntervalCommutative(time4, oneDay));
+}
+
+TEST_F(DateTimeFunctionsTest, timeMinusIntervalDayTime) {
+  // Test TIME - IntervalDayTime arithmetic (does not support Interval - Time)
+
+  const auto timeMinusInterval =
+      [&](int64_t time, int64_t interval) -> std::optional<int64_t> {
+    return evaluateOnce<int64_t>(
+        "minus(c0, c1)",
+        makeRowVector({
+            makeNullableFlatVector<int64_t>({time}, TIME()),
+            makeNullableFlatVector<int64_t>({interval}, INTERVAL_DAY_TIME()),
+        }));
+  };
+
+  // Basic hour subtraction: 06:04:05.321 - 3 hours = 03:04:05.321
+  // 06:04:05.321 = (6*3600 + 4*60 + 5)*1000 + 321 = 21845321 ms
+  // 3 hours = 3*60*60*1000 = 10800000 ms
+  // 03:04:05.321 = (3*3600 + 4*60 + 5)*1000 + 321 = 11045321 ms
+  const int64_t time1 = 21845321; // 06:04:05.321
+  const int64_t threeHours = 3 * kMillisInHour;
+  EXPECT_EQ(11045321, timeMinusInterval(time1, threeHours));
+
+  // Test 24-hour wraparound: 01:00:00 - 3 hours = 22:00:00 (previous day)
+  // 01:00:00 = 1*3600*1000 = 3600000 ms
+  // 22:00:00 = 22*3600*1000 = 79200000 ms
+  const int64_t time2 = kMillisInHour; // 01:00:00
+  EXPECT_EQ(79200000, timeMinusInterval(time2, threeHours));
+
+  // Test minute subtraction: 04:34:05.321 - 90 minutes = 03:04:05.321
+  // 04:34:05.321 = (4*3600 + 34*60 + 5)*1000 + 321 = 16445321 ms
+  // 90 minutes = 90*60*1000 = 5400000 ms
+  // 03:04:05.321 = (3*3600 + 4*60 + 5)*1000 + 321 = 11045321 ms
+  const int64_t time3 = 16445321; // 04:34:05.321
+  const int64_t ninetyMinutes = 90 * kMillisInMinute;
+  EXPECT_EQ(11045321, timeMinusInterval(time3, ninetyMinutes));
+
+  // Test millisecond precision: 03:04:06.000 - 679 milliseconds = 03:04:05.321
+  // 03:04:06.000 = (3*3600 + 4*60 + 6)*1000 = 11046000 ms
+  // 03:04:05.321 = (3*3600 + 4*60 + 5)*1000 + 321 = 11045321 ms
+  const int64_t time4 = 11046000; // 03:04:06.000
+  EXPECT_EQ(11045321, timeMinusInterval(time4, 679));
+
+  // Test day intervals (should not change time of day per Presto behavior)
+  // 12:30:45.123 = (12*3600 + 30*60 + 45)*1000 + 123 = 45045123 ms
+  const int64_t time5 = 45045123; // 12:30:45.123
+  const int64_t oneDay = kMillisInDay;
+  EXPECT_EQ(45045123, timeMinusInterval(time5, oneDay));
+
+  // Test subtracting negative intervals (double negative = addition)
+  // 03:04:05.321 - (-3 hours) = 03:04:05.321 + 3 hours = 06:04:05.321
+  // 03:04:05.321 = (3*3600 + 4*60 + 5)*1000 + 321 = 11045321 ms
+  // 06:04:05.321 = (6*3600 + 4*60 + 5)*1000 + 321 = 21845321 ms
+  const int64_t time6 = 11045321; // 03:04:05.321
+  EXPECT_EQ(21845321, timeMinusInterval(time6, -threeHours));
+
+  // Test negative interval with wraparound: 22:00:00 - (-3 hours) = 01:00:00
+  // 22:00:00 = 22*3600*1000 = 79200000 ms
+  // 01:00:00 = 1*3600*1000 = 3600000 ms
+  const int64_t time7 = 22 * kMillisInHour; // 22:00:00
+  EXPECT_EQ(3600000, timeMinusInterval(time7, -threeHours));
+}
+
+TEST_F(DateTimeFunctionsTest, timeMinusTime) {
+  // Test TIME - TIME arithmetic returning INTERVAL_DAY_TIME
+
+  const auto timeMinusTime = [&](int64_t time1,
+                                 int64_t time2) -> std::optional<int64_t> {
+    return evaluateOnce<int64_t>(
+        "minus(c0, c1)",
+        makeRowVector({
+            makeNullableFlatVector<int64_t>({time1}, TIME()),
+            makeNullableFlatVector<int64_t>({time2}, TIME()),
+        }));
+  };
+
+  // Test basic subtraction: 10:00:00 - 08:00:00 = 2 hours = 7200000 ms
+  const int64_t tenAM = 10 * kMillisInHour; // 36000000 ms
+  const int64_t eightAM = 8 * kMillisInHour; // 28800000 ms
+  const int64_t twoHours = 2 * kMillisInHour; // 7200000 ms
+  EXPECT_EQ(twoHours, timeMinusTime(tenAM, eightAM));
+
+  // Test reverse (negative result): 08:00:00 - 10:00:00 = -2 hours
+  EXPECT_EQ(-twoHours, timeMinusTime(eightAM, tenAM));
+
+  // Test same time: 10:00:00 - 10:00:00 = 0
+  EXPECT_EQ(0, timeMinusTime(tenAM, tenAM));
+
+  // Test with millisecond precision
+  // 12:30:45.123 - 06:04:05.321 = 23199802 ms
+  const int64_t time1 = 12 * kMillisInHour + 30 * kMillisInMinute +
+      45 * kMillisInSecond + 123; // 45045123
+  const int64_t time2 = 6 * kMillisInHour + 4 * kMillisInMinute +
+      5 * kMillisInSecond + 321; // 21845321
+  EXPECT_EQ(23199802, timeMinusTime(time1, time2));
+
+  // Test midnight cases
+  // 23:59:59.999 - 00:00:00.000 = 86399999 ms (almost full day)
+  const int64_t almostMidnight = kMillisInDay - 1; // 86399999
+  const int64_t midnight = 0;
+  EXPECT_EQ(86399999, timeMinusTime(almostMidnight, midnight));
+
+  // 00:00:00.000 - 23:59:59.999 = -86399999 ms (negative almost full day)
+  EXPECT_EQ(-86399999, timeMinusTime(midnight, almostMidnight));
+
+  // Test with NULL values
+  const auto timeMinusTimeWithNull =
+      [&](std::optional<int64_t> time1,
+          std::optional<int64_t> time2) -> std::optional<int64_t> {
+    return evaluateOnce<int64_t>(
+        "minus(c0, c1)",
+        makeRowVector({
+            makeNullableFlatVector<int64_t>({time1}, TIME()),
+            makeNullableFlatVector<int64_t>({time2}, TIME()),
+        }));
+  };
+
+  EXPECT_EQ(std::nullopt, timeMinusTimeWithNull(std::nullopt, std::nullopt));
+  EXPECT_EQ(std::nullopt, timeMinusTimeWithNull(tenAM, std::nullopt));
+  EXPECT_EQ(std::nullopt, timeMinusTimeWithNull(std::nullopt, eightAM));
+}
+
+// Comprehensive tests for TimePlusIntervalYearMonthVectorFunction optimizations
+// and IntervalYearMonthPlusTimeVectorFunction optimizations
+TEST_F(DateTimeFunctionsTest, timeIntervalYearMonthVectorOptimizations) {
+  // Helper to create interval year-month values (in months)
+  auto months = [](int32_t value) { return value; };
+
+  // Helper to create time values (milliseconds since midnight)
+  auto timeMs = [](int32_t hours,
+                   int32_t minutes = 0,
+                   int32_t seconds = 0,
+                   int32_t millis = 0) {
+    return static_cast<int64_t>(hours) * 3600000 +
+        static_cast<int64_t>(minutes) * 60000 +
+        static_cast<int64_t>(seconds) * 1000 + static_cast<int64_t>(millis);
+  };
+
+  // Helper to verify time +/- interval results (should be identity function)
+  // Tests commutativity for plus: interval + time gives the same result
+  // Tests minus: time - interval (only this ordering supported for minus)
+  auto testTimePlusMinusIntervalYearMonth =
+      [&](const VectorPtr& timeVector,
+          const VectorPtr& intervalVector,
+          const VectorPtr& expectedResult) {
+        // Test: Time + Interval
+        auto resultPlus1 = evaluate(
+            "plus(c0, c1)", makeRowVector({timeVector, intervalVector}));
+        assertEqualVectors(expectedResult, resultPlus1);
+
+        // Test: Interval + Time (commutative for plus)
+        auto resultPlus2 = evaluate(
+            "plus(c0, c1)", makeRowVector({intervalVector, timeVector}));
+        assertEqualVectors(expectedResult, resultPlus2);
+
+        // Test: Time - Interval (identity function, only this ordering)
+        auto resultMinus = evaluate(
+            "minus(c0, c1)", makeRowVector({timeVector, intervalVector}));
+        assertEqualVectors(expectedResult, resultMinus);
+      };
+
+  // TEST 1: Constant Vector Optimization - Non-null constant
+  {
+    const auto timeValue = timeMs(14, 30, 15, 123); // 14:30:15.123
+    const auto intervalValue = months(6); // 6 months
+
+    // Create constant vectors
+    auto constantTime =
+        BaseVector::createConstant(TIME(), timeValue, 1000, pool());
+    auto constantInterval = BaseVector::createConstant(
+        INTERVAL_YEAR_MONTH(), intervalValue, 1000, pool());
+
+    // Expected result should be same constant time (identity function)
+    auto expectedResult =
+        BaseVector::createConstant(TIME(), timeValue, 1000, pool());
+
+    // Test: Time + Interval, Interval + Time, and Time - Interval
+    testTimePlusMinusIntervalYearMonth(
+        constantTime, constantInterval, expectedResult);
+
+    // Verify the result is also constant encoded for efficiency
+    auto result = evaluate(
+        "plus(c0, c1)", makeRowVector({constantTime, constantInterval}));
+
+    EXPECT_TRUE(result->isConstantEncoding());
+    EXPECT_EQ(result->size(), 1000);
+    EXPECT_EQ(result->as<ConstantVector<int64_t>>()->valueAt(0), timeValue);
+  }
+
+  // TEST 2: Constant Vector Optimization - mixed null and non-null values
+  {
+    const auto intervalValue = months(12); // 12 months
+
+    // Create time vector with mixed null and non-null values to test null
+    // handling
+    auto timeVector = makeNullableFlatVector<int64_t>(
+        {std::nullopt, timeMs(17, 30, 0), std::nullopt}, TIME());
+
+    auto intervalVector = makeFlatVector<int32_t>(
+        {intervalValue, intervalValue, intervalValue}, INTERVAL_YEAR_MONTH());
+
+    // Expected result: null, non-null, null
+    auto expectedResult = makeNullableFlatVector<int64_t>(
+        {std::nullopt, timeMs(17, 30, 0), std::nullopt}, TIME());
+
+    // Test: Time + Interval, Interval + Time, and Time - Interval
+    testTimePlusMinusIntervalYearMonth(
+        timeVector, intervalVector, expectedResult);
+  }
+
+  // TEST 3: Flat Vector with Nulls
+  {
+    const std::vector<std::optional<int64_t>> timeValues = {
+        timeMs(10, 30, 0), // 10:30:00
+        std::nullopt, // null
+        timeMs(16, 45, 30), // 16:45:30
+        std::nullopt, // null
+        timeMs(20, 0, 0) // 20:00:00
+    };
+
+    const std::vector<int32_t> intervalValues = {
+        months(3), months(6), months(9), months(12), months(18)};
+
+    auto timeVector = makeNullableFlatVector<int64_t>(timeValues, TIME());
+    auto intervalVector =
+        makeFlatVector<int32_t>(intervalValues, INTERVAL_YEAR_MONTH());
+
+    // Expected result should preserve nulls and non-null values identically
+    auto expectedResult = makeNullableFlatVector<int64_t>(timeValues, TIME());
+
+    // Test: Time + Interval, Interval + Time, and Time - Interval
+    testTimePlusMinusIntervalYearMonth(
+        timeVector, intervalVector, expectedResult);
+  }
+
+  // TEST 4: Dictionary Vector (Fallback Path)
+  {
+    // Create base values for dictionary
+    const std::vector<int64_t> baseTimeValues = {
+        timeMs(9, 0, 0), // 09:00:00
+        timeMs(17, 30, 0), // 17:30:00
+        timeMs(12, 0, 0) // 12:00:00
+    };
+
+    // Create indices that repeat base values
+    const std::vector<vector_size_t> indices = {0, 1, 2, 0, 1, 2, 1, 0};
+
+    auto baseVector = makeFlatVector<int64_t>(baseTimeValues, TIME());
+
+    auto dictionaryTimeVector = wrapInDictionary(
+        makeIndices(indices), (vector_size_t)indices.size(), baseVector);
+
+    auto intervalVector = makeFlatVector<int32_t>(
+        std::vector<int32_t>(indices.size(), months(6)), INTERVAL_YEAR_MONTH());
+
+    // Expected result should decode dictionary and preserve values
+    std::vector<int64_t> expectedValues;
+    expectedValues.reserve(indices.size());
+    for (auto idx : indices) {
+      expectedValues.push_back(baseTimeValues[idx]);
+    }
+    auto expectedResult = makeFlatVector<int64_t>(expectedValues, TIME());
+
+    // Test: Time + Interval, Interval + Time, and Time - Interval
+    testTimePlusMinusIntervalYearMonth(
+        dictionaryTimeVector, intervalVector, expectedResult);
+  }
+}
+
 TEST_F(DateTimeFunctionsTest, minusTimestampWithTimezone) {
   auto minus = [&](const std::string& a, const std::string& b) {
     const auto sql =
@@ -1466,6 +1843,127 @@ TEST_F(DateTimeFunctionsTest, minuteTimestampWithTimezone) {
       29, minuteTimestampWithTimezone(TimestampWithTimezone(-1000, "+05:30")));
 }
 
+TEST_F(DateTimeFunctionsTest, minuteTime) {
+  const auto minute = [&](std::optional<int64_t> time) {
+    return evaluateOnce<int64_t>(
+        "minute(c0)",
+        makeRowVector({makeNullableFlatVector<int64_t>({time}, TIME())}));
+  };
+
+  // null handling
+  EXPECT_EQ(std::nullopt, minute(std::nullopt));
+
+  // edge cases: beginning and end of valid range
+  EXPECT_EQ(0, minute(0)); // 00:00:00.000
+  EXPECT_EQ(59, minute(86399999)); // 23:59:59.999
+
+  // boundary values for optimization testing
+  EXPECT_EQ(0, minute(59999)); // 00:00:59.999 - last second of first minute
+  EXPECT_EQ(1, minute(60000)); // 00:01:00.000 - first second of second minute
+  EXPECT_EQ(59, minute(3599999)); // 00:59:59.999 - last second of first hour
+  EXPECT_EQ(0, minute(3600000)); // 01:00:00.000 - first second of second hour
+
+  // time values spanning different hours to test optimization
+  EXPECT_EQ(
+      15,
+      minute(
+          15 * kMillisInMinute + 30 * kMillisInSecond + 123)); // 00:15:30.123
+  EXPECT_EQ(
+      30,
+      minute(5 * kMillisInHour + 30 * kMillisInMinute + 45000)); // 05:30:45.000
+  EXPECT_EQ(
+      45, minute(12 * kMillisInHour + 45 * kMillisInMinute)); // 12:45:00.000
+  EXPECT_EQ(0, minute(23 * kMillisInHour)); // 23:00:00.000
+
+  // comprehensive minute coverage for edge case testing
+  for (int m = 0; m < 60; ++m) {
+    EXPECT_EQ(m, minute(m * kMillisInMinute)); // exact minute boundaries
+    EXPECT_EQ(m, minute(m * kMillisInMinute + 500)); // mid-second
+    EXPECT_EQ(m, minute(m * kMillisInMinute + 59999)); // end of minute
+  }
+
+  // hour boundaries with different minute values
+  for (int h = 0; h < 24; ++h) {
+    EXPECT_EQ(0, minute(h * kMillisInHour)); // start of each hour
+    EXPECT_EQ(
+        30,
+        minute(
+            h * kMillisInHour + 30 * kMillisInMinute)); // 30 minutes into hour
+    EXPECT_EQ(
+        59,
+        minute(
+            h * kMillisInHour + 59 * kMillisInMinute +
+            59999)); // last moment of hour
+  }
+
+  // comprehensive data type coverage - test various millisecond precision
+  // values
+  EXPECT_EQ(
+      42,
+      minute(13 * kMillisInHour + 42 * kMillisInMinute + 1)); // precision: 1ms
+  EXPECT_EQ(
+      42,
+      minute(
+          13 * kMillisInHour + 42 * kMillisInMinute + 10)); // precision: 10ms
+  EXPECT_EQ(
+      42,
+      minute(
+          13 * kMillisInHour + 42 * kMillisInMinute + 100)); // precision: 100ms
+  EXPECT_EQ(
+      42,
+      minute(
+          13 * kMillisInHour + 42 * kMillisInMinute + 999)); // precision: 999ms
+
+  // performance critical values for optimization validation
+  int64_t performanceTestValues[] = {
+      0, // midnight
+      kMillisInHour / 2, // 30 minutes
+      kMillisInHour - 1, // 59:59.999
+      kMillisInHour, // 01:00:00.000
+      12 * kMillisInHour + 30 * kMillisInMinute, // 12:30:00.000 (noon+)
+      86399999 // 23:59:59.999 (end of day)
+  };
+
+  int64_t expectedMinutes[] = {0, 30, 59, 0, 30, 59};
+
+  for (size_t i = 0;
+       i < sizeof(performanceTestValues) / sizeof(performanceTestValues[0]);
+       ++i) {
+    EXPECT_EQ(expectedMinutes[i], minute(performanceTestValues[i]));
+  }
+}
+
+TEST_F(DateTimeFunctionsTest, minuteTimeInvalidRange) {
+  const auto minute = [&](int64_t time) {
+    return evaluateOnce<int64_t>(
+        "minute(c0)", makeRowVector({makeFlatVector<int64_t>({time}, TIME())}));
+  };
+
+  // test out-of-range values that should throw errors
+  VELOX_ASSERT_THROW(
+      minute(-1), "TIME value -1 is out of valid range [0, 86399999]");
+
+  VELOX_ASSERT_THROW(
+      minute(86400000),
+      "TIME value 86400000 is out of valid range [0, 86399999]");
+
+  VELOX_ASSERT_THROW(
+      minute(-86400000),
+      "TIME value -86400000 is out of valid range [0, 86399999]");
+
+  VELOX_ASSERT_THROW(
+      minute(std::numeric_limits<int64_t>::max()),
+      fmt::format(
+          "TIME value {} is out of valid range [0, 86399999]",
+          std::numeric_limits<int64_t>::max()));
+
+  VELOX_ASSERT_THROW(
+      minute(std::numeric_limits<int64_t>::min()),
+      fmt::format(
+          "TIME value {} is out of valid range [0, 86399999]",
+          std::numeric_limits<int64_t>::min()));
+}
+
 TEST_F(DateTimeFunctionsTest, second) {
   const auto second = [&](std::optional<Timestamp> timestamp) {
     return evaluateOnce<int64_t>("second(c0)", timestamp);
@@ -1515,6 +2013,52 @@ TEST_F(DateTimeFunctionsTest, secondTimestampWithTimezone) {
       59, secondTimestampWithTimezone(TimestampWithTimezone(-1000, "+05:30")));
 }
 
+TEST_F(DateTimeFunctionsTest, secondTime) {
+  const auto second = [&](std::optional<int64_t> time) {
+    return evaluateOnce<int64_t>("second(c0)", TIME(), time);
+  };
+
+  // null handling
+  EXPECT_EQ(std::nullopt, second(std::nullopt));
+
+  // boundary tests - optimization: (time / 1000) % 60
+  // lower boundary: 0 <= time < 86400000
+  EXPECT_EQ(0, second(0)); // exactly midnight - 00:00:00.000
+  EXPECT_EQ(0, second(999)); // 00:00:00.999 - last millisecond of second 0
+  EXPECT_EQ(1, second(1000)); // 00:00:01.000 - first millisecond of second 1
+  EXPECT_EQ(59, second(59000)); // 00:00:59.000 - first millisecond of second 59
+  EXPECT_EQ(0, second(60000)); // 00:01:00.000 - first second of next minute
+  EXPECT_EQ(59, second(86399000)); // 23:59:59.000
+  EXPECT_EQ(59, second(86399999)); // 23:59:59.999 - upper boundary exclusive
+
+  // representative test cases across different times
+  EXPECT_EQ(30, second(30000)); // 00:00:30.000
+  EXPECT_EQ(15, second(75000)); // 00:01:15.000
+  // 01:01:25 = 3600000 + 60000 + 25000 = 3685000
+  EXPECT_EQ(25, second(3685000)); // 01:01:25.000
+  EXPECT_EQ(3, second(3723123)); // 01:02:03.123
+
+  // verify optimization correctness with modulo boundary conditions
+  // seconds should cycle every 60 seconds regardless of hours/minutes
+  EXPECT_EQ(0, second(3600000)); // 01:00:00.000
+  EXPECT_EQ(30, second(3630000)); // 01:00:30.000
+  EXPECT_EQ(0, second(7200000)); // 02:00:00.000
+  EXPECT_EQ(45, second(43245000)); // 12:00:45.000
+
+  // test millisecond precision is correctly truncated
+  EXPECT_EQ(15, second(15123)); // 00:00:15.123
+  EXPECT_EQ(15, second(15999)); // 00:00:15.999
+
+  // error conditions - invalid range validation
+  EXPECT_THROW(second(-1), VeloxUserError); // negative time
+  EXPECT_THROW(
+      second(86400000),
+      VeloxUserError); // exactly 24:00:00.000 (exclusive upper bound)
+  EXPECT_THROW(
+      second(std::numeric_limits<int64_t>::max()),
+      VeloxUserError); // overflow case
+}
+
 TEST_F(DateTimeFunctionsTest, millisecond) {
   const auto millisecond = [&](std::optional<Timestamp> timestamp) {
     return evaluateOnce<int64_t>("millisecond(c0)", timestamp);
@@ -1568,6 +2112,111 @@ TEST_F(DateTimeFunctionsTest, millisecondTimestampWithTimezone) {
       millisecondTimestampWithTimezone(TimestampWithTimezone(-980, "+05:30")));
 }
 
+TEST_F(DateTimeFunctionsTest, millisecondTime) {
+  const auto millisecond = [&](std::optional<int64_t> time) {
+    return evaluateOnce<int64_t>("millisecond(c0)", TIME(), time);
+  };
+
+  // Null handling
+  EXPECT_EQ(std::nullopt, millisecond(std::nullopt));
+
+  // Basic cases
+  EXPECT_EQ(0, millisecond(0)); // 00:00:00.000
+  EXPECT_EQ(0, millisecond(1000)); // 00:00:01.000
+  EXPECT_EQ(123, millisecond(1123)); // 00:00:01.123
+  EXPECT_EQ(456, millisecond(2456)); // 00:00:02.456
+  EXPECT_EQ(999, millisecond(999)); // 00:00:00.999
+  EXPECT_EQ(123, millisecond(3661123)); // 01:01:01.123
+
+  // Boundary values
+  EXPECT_EQ(0, millisecond(86399000)); // 23:59:59.000
+  EXPECT_EQ(999, millisecond(86399999)); // 23:59:59.999 (max valid TIME)
+
+  // Different time components to verify only millisecond part matters
+  EXPECT_EQ(500, millisecond(3600500)); // 01:00:00.500
+  EXPECT_EQ(500, millisecond(7200500)); // 02:00:00.500
+  EXPECT_EQ(500, millisecond(43200500)); // 12:00:00.500
+
+  // Second boundaries
+  EXPECT_EQ(0, millisecond(60000)); // 00:01:00.000
+  EXPECT_EQ(999, millisecond(60999)); // 00:01:00.999
+  EXPECT_EQ(1, millisecond(60001)); // 00:01:00.001
+
+  // Comprehensive modulo testing - verify millisecond() == time % 1000
+  for (int64_t base : {0, 1000, 60000, 3600000, 86399000}) {
+    for (int64_t ms = 0; ms < 1000; ms += 100) {
+      int64_t timeValue = base + ms;
+      if (timeValue <= 86399999) { // Ensure within valid range
+        EXPECT_EQ(ms, millisecond(timeValue));
+      }
+    }
+  }
+
+  // Test all possible millisecond values (0-999) in first second
+  for (int64_t ms = 0; ms < 1000; ++ms) {
+    EXPECT_EQ(ms, millisecond(ms));
+  }
+
+  // Test across all hours to ensure hour component doesn't affect result
+  for (int hour = 0; hour < 24; ++hour) {
+    int64_t baseTime = hour * 3600000; // Convert hour to milliseconds
+    EXPECT_EQ(0, millisecond(baseTime)); // .000
+    EXPECT_EQ(1, millisecond(baseTime + 1)); // .001
+    EXPECT_EQ(500, millisecond(baseTime + 500)); // .500
+    EXPECT_EQ(999, millisecond(baseTime + 999)); // .999
+  }
+
+  // Test edge cases just before and after boundaries
+  EXPECT_EQ(998, millisecond(86399998)); // 23:59:59.998
+  EXPECT_EQ(1, millisecond(1001)); // 00:00:01.001
+  EXPECT_EQ(999, millisecond(1999)); // 00:00:01.999
+  EXPECT_EQ(0, millisecond(2000)); // 00:00:02.000
+
+  // Error cases - values outside valid TIME range [0, 86399999]
+  VELOX_ASSERT_THROW(
+      millisecond(-1), "TIME value -1 is out of range [0, 86400000)");
+  VELOX_ASSERT_THROW(
+      millisecond(-1000), "TIME value -1000 is out of range [0, 86400000)");
+  VELOX_ASSERT_THROW(
+      millisecond(86400000),
+      "TIME value 86400000 is out of range [0, 86400000)");
+  VELOX_ASSERT_THROW(
+      millisecond(100000000),
+      "TIME value 100000000 is out of range [0, 86400000)");
+
+  // Test vectorized execution with mixed valid values
+  auto timeVector = makeFlatVector<int64_t>(
+      {0, // 00:00:00.000
+       1123, // 00:00:01.123
+       60999, // 00:01:00.999
+       3661456, // 01:01:01.456
+       43200789, // 12:00:00.789
+       86399999}, // 23:59:59.999
+      TIME());
+
+  auto result = evaluate<FlatVector<int64_t>>(
+      "millisecond(c0)", makeRowVector({timeVector}));
+
+  auto expected = makeFlatVector<int64_t>({0, 123, 999, 456, 789, 999});
+  assertEqualVectors(expected, result);
+
+  // Test vectorized execution with nulls
+  auto timeVectorWithNulls = makeNullableFlatVector<int64_t>(
+      {0, // 00:00:00.000
+       std::nullopt, // null
+       1123, // 00:00:01.123
+       std::nullopt, // null
+       86399999}, // 23:59:59.999
+      TIME());
+
+  auto resultWithNulls = evaluate<FlatVector<int64_t>>(
+      "millisecond(c0)", makeRowVector({timeVectorWithNulls}));
+
+  auto expectedWithNulls = makeNullableFlatVector<int64_t>(
+      {0, std::nullopt, 123, std::nullopt, 999});
+  assertEqualVectors(expectedWithNulls, resultWithNulls);
+}
+
 TEST_F(DateTimeFunctionsTest, extractFromIntervalDayTime) {
   const auto millis = 5 * kMillisInDay + 7 * kMillisInHour +
       11 * kMillisInMinute + 13 * kMillisInSecond + 17;
@@ -2608,6 +3257,115 @@ TEST_F(DateTimeFunctionsTest, dateAddTimestampWithTimeZone) {
           "day", -45, "2023-04-26 02:30:00.000 America/Los_Angeles"));
 }
 
+TEST_F(DateTimeFunctionsTest, dateAddTime) {
+  const auto dateAdd = [&](const std::string& unit,
+                           std::optional<int32_t> value,
+                           std::optional<int64_t> time) {
+    return evaluateOnce<int64_t>(
+        fmt::format("date_add('{}', c0, c1)", unit),
+        {INTEGER(), TIME()},
+        value,
+        time);
+  };
+
+  // basic time additions
+  // add milliseconds
+  EXPECT_EQ(1000, dateAdd("millisecond", 1000, 0)); // 00:00:00.000 + 1s
+  EXPECT_EQ(500, dateAdd("millisecond", -500, 1000)); // 00:00:01.000 - 500ms
+  EXPECT_EQ(2000, dateAdd("millisecond", 1000, 1000)); // 00:00:01.000 + 1s
+
+  // add seconds
+  EXPECT_EQ(1000, dateAdd("second", 1, 0)); // 00:00:00 + 1s
+  EXPECT_EQ(0, dateAdd("second", -1, 1000)); // 00:00:01 - 1s
+  EXPECT_EQ(3661000, dateAdd("second", 3661, 0)); // 1 hour 1 minute 1 second
+
+  // add minutes
+  EXPECT_EQ(60000, dateAdd("minute", 1, 0)); // 00:00:00 + 1 minute
+  EXPECT_EQ(0, dateAdd("minute", -1, 60000)); // 00:01:00 - 1 minute
+  EXPECT_EQ(300000, dateAdd("minute", 5, 0)); // 00:00:00 + 5 minutes
+
+  // add hours
+  EXPECT_EQ(3600000, dateAdd("hour", 1, 0)); // 00:00:00 + 1 hour
+  EXPECT_EQ(0, dateAdd("hour", -1, 3600000)); // 01:00:00 - 1 hour
+  EXPECT_EQ(43200000, dateAdd("hour", 12, 0)); // 00:00:00 + 12 hours
+
+  // test wraparound behavior (24-hour modulo)
+  EXPECT_EQ(
+      3600000,
+      dateAdd("hour", 25, 0)); // 00:00:00 + 25 hours = 01:00:00 (wraps)
+  EXPECT_EQ(
+      82800000, dateAdd("hour", -1, 0)); // 00:00:00 - 1 hour = 23:00:00 (wraps)
+  EXPECT_EQ(
+      0, dateAdd("hour", 24, 0)); // 00:00:00 + 24 hours = 00:00:00 (wraps)
+  EXPECT_EQ(
+      0, dateAdd("hour", -24, 0)); // 00:00:00 - 24 hours = 00:00:00 (wraps)
+
+  // test real-world scenario: 09:30:15.500 + various units
+  int64_t morning = 9 * 3600000 + 30 * 60000 + 15 * 1000 + 500; // 34215500ms
+  EXPECT_EQ(34215750, dateAdd("millisecond", 250, morning)); // +250ms
+  EXPECT_EQ(34245500, dateAdd("second", 30, morning)); // +30s
+  EXPECT_EQ(35415500, dateAdd("minute", 20, morning)); // +20 minutes
+  EXPECT_EQ(48615500, dateAdd("hour", 4, morning)); // +4 hours
+
+  // test boundary values for TIME type (0 to 86399999 ms in a day)
+  EXPECT_EQ(0, dateAdd("millisecond", 0, 0)); // 00:00:00.000 + 0ms
+  EXPECT_EQ(
+      86399999, dateAdd("millisecond", 86399999, 0)); // 00:00:00.000 + max time
+  EXPECT_EQ(
+      0, dateAdd("millisecond", -86399999, 86399999)); // max time - max time
+
+  // test wraparound with large values
+  EXPECT_EQ(
+      1000,
+      dateAdd(
+          "millisecond",
+          86401000,
+          0)); // 00:00:00 + (24h + 1s) wraps to 00:00:01
+  EXPECT_EQ(
+      86398000,
+      dateAdd(
+          "millisecond",
+          -2000,
+          0)); // 00:00:00 - 2s wraps to 23:59:58
+
+  // negative additions
+  EXPECT_EQ(0, dateAdd("second", -60, 60000)); // 00:01:00 - 60s
+  EXPECT_EQ(0, dateAdd("minute", -60, 3600000)); // 01:00:00 - 60min
+  EXPECT_EQ(75600000, dateAdd("hour", -2, 82800000)); // 23:00:00 - 2h = 21:00
+
+  // test null handling
+  EXPECT_EQ(std::nullopt, dateAdd("second", 1, std::nullopt));
+  EXPECT_EQ(std::nullopt, dateAdd("second", std::nullopt, 1000));
+  EXPECT_EQ(std::nullopt, dateAdd("second", std::nullopt, std::nullopt));
+
+  // test invalid units (TIME only supports time-related units, not
+  // date-related, and not microsecond which is not supported in Presto)
+  VELOX_ASSERT_THROW(
+      dateAdd("microsecond", 1, 0), "microsecond is not a valid TIME field");
+  VELOX_ASSERT_THROW(dateAdd("day", 1, 0), "day is not a valid TIME field");
+  VELOX_ASSERT_THROW(dateAdd("week", 1, 0), "week is not a valid TIME field");
+  VELOX_ASSERT_THROW(dateAdd("month", 1, 0), "month is not a valid TIME field");
+  VELOX_ASSERT_THROW(
+      dateAdd("quarter", 1, 0), "quarter is not a valid TIME field");
+  VELOX_ASSERT_THROW(dateAdd("year", 1, 0), "year is not a valid TIME field");
+  VELOX_ASSERT_THROW(
+      dateAdd("invalid", 1, 0), "invalid is not a valid TIME field");
+
+  // edge cases: multiple full day additions
+  EXPECT_EQ(
+      7200000,
+      dateAdd("hour", 50, 0)); // 00:00:00 + 50 hours = 02:00:00 (wraps twice)
+  EXPECT_EQ(
+      0,
+      dateAdd("hour", 72, 0)); // 00:00:00 + 72 hours = 00:00:00 (wraps 3 times)
+
+  // test midnight transitions
+  EXPECT_EQ(
+      1000, dateAdd("millisecond", 2000, 86399000)); // 23:59:59 + 2s wraps
+  EXPECT_EQ(
+      86399000, dateAdd("millisecond", -1000, 0)); // 00:00:00 - 1s = 23:59:59
+}
+
 TEST_F(DateTimeFunctionsTest, dateDiffDate) {
   const auto dateDiff = [&](const std::string& unit,
                             std::optional<int32_t> date1,
@@ -3490,29 +4248,19 @@ TEST_F(DateTimeFunctionsTest, formatDateTime) {
   for (int i = 0; i < 31; i++) {
     std::string date("2022-08-" + std::to_string(i + 1));
     EXPECT_EQ(
-        std::to_string(i % 7 + 1),
-        formatDatetime(parseTimestamp(StringView{date}), "e"));
+        std::to_string(i % 7 + 1), formatDatetime(parseTimestamp(date), "e"));
   }
   EXPECT_EQ("000001", formatDatetime(parseTimestamp("2022-08-01"), "eeeeee"));
 
   // Day of week text - 'E'
   for (int i = 0; i < 31; i++) {
     std::string date("2022-08-" + std::to_string(i + 1));
+    EXPECT_EQ(daysShort[i % 7], formatDatetime(parseTimestamp(date), "E"));
+    EXPECT_EQ(daysShort[i % 7], formatDatetime(parseTimestamp(date), "EE"));
+    EXPECT_EQ(daysShort[i % 7], formatDatetime(parseTimestamp(date), "EEE"));
+    EXPECT_EQ(daysLong[i % 7], formatDatetime(parseTimestamp(date), "EEEE"));
     EXPECT_EQ(
-        daysShort[i % 7],
-        formatDatetime(parseTimestamp(StringView{date}), "E"));
-    EXPECT_EQ(
-        daysShort[i % 7],
-        formatDatetime(parseTimestamp(StringView{date}), "EE"));
-    EXPECT_EQ(
-        daysShort[i % 7],
-        formatDatetime(parseTimestamp(StringView{date}), "EEE"));
-    EXPECT_EQ(
-        daysLong[i % 7],
-        formatDatetime(parseTimestamp(StringView{date}), "EEEE"));
-    EXPECT_EQ(
-        daysLong[i % 7],
-        formatDatetime(parseTimestamp(StringView{date}), "EEEEEEEE"));
+        daysLong[i % 7], formatDatetime(parseTimestamp(date), "EEEEEEEE"));
   }
 
   // Year test cases - 'y'
@@ -3550,21 +4298,11 @@ TEST_F(DateTimeFunctionsTest, formatDateTime) {
   for (int i = 0; i < 12; i++) {
     auto month = i + 1;
     std::string date("2022-" + std::to_string(month) + "-01");
-    EXPECT_EQ(
-        std::to_string(month),
-        formatDatetime(parseTimestamp(StringView{date}), "M"));
-    EXPECT_EQ(
-        padNumber(month),
-        formatDatetime(parseTimestamp(StringView{date}), "MM"));
-    EXPECT_EQ(
-        monthsShort[i],
-        formatDatetime(parseTimestamp(StringView{date}), "MMM"));
-    EXPECT_EQ(
-        monthsLong[i],
-        formatDatetime(parseTimestamp(StringView{date}), "MMMM"));
-    EXPECT_EQ(
-        monthsLong[i],
-        formatDatetime(parseTimestamp(StringView{date}), "MMMMMMMM"));
+    EXPECT_EQ(std::to_string(month), formatDatetime(parseTimestamp(date), "M"));
+    EXPECT_EQ(padNumber(month), formatDatetime(parseTimestamp(date), "MM"));
+    EXPECT_EQ(monthsShort[i], formatDatetime(parseTimestamp(date), "MMM"));
+    EXPECT_EQ(monthsLong[i], formatDatetime(parseTimestamp(date), "MMMM"));
+    EXPECT_EQ(monthsLong[i], formatDatetime(parseTimestamp(date), "MMMMMMMM"));
   }
 
   // Day of month test cases - 'd'
@@ -3725,6 +4463,8 @@ TEST_F(DateTimeFunctionsTest, formatDateTime) {
   EXPECT_EQ("+05:30", formatDatetime(parseTimestamp("1970-01-01"), "ZZ"));
   EXPECT_EQ("+0530", formatDatetime(parseTimestamp("1970-01-01"), "Z"));
 
+  // Time zone test cases - 'z'
+  // Timezone that has an abbreviation
   EXPECT_EQ("IST", formatDatetime(parseTimestamp("1970-01-01"), "zzz"));
   EXPECT_EQ("IST", formatDatetime(parseTimestamp("1970-01-01"), "zz"));
   EXPECT_EQ("IST", formatDatetime(parseTimestamp("1970-01-01"), "z"));
@@ -3735,6 +4475,18 @@ TEST_F(DateTimeFunctionsTest, formatDateTime) {
       "India Standard Time",
       formatDatetime(parseTimestamp("1970-01-01"), "zzzzzzzzzzzzzzzzzzzzzz"));
 
+  // Timezone that has no abbreviations so uses GMT offset
+  setQueryTimeZone("Asia/Atyrau");
+  EXPECT_EQ("GMT+05:00", formatDatetime(parseTimestamp("1970-01-01"), "zzz"));
+  EXPECT_EQ("GMT+05:00", formatDatetime(parseTimestamp("1970-01-01"), "zz"));
+  EXPECT_EQ("GMT+05:00", formatDatetime(parseTimestamp("1970-01-01"), "z"));
+  EXPECT_EQ(
+      "West Kazakhstan Time",
+      formatDatetime(parseTimestamp("1970-01-01"), "zzzz"));
+  EXPECT_EQ(
+      "West Kazakhstan Time",
+      formatDatetime(parseTimestamp("1970-01-01"), "zzzzzzzzzzzzzzzzzzzzzz"));
+
   // Test daylight savings.
   setQueryTimeZone("America/Los_Angeles");
   EXPECT_EQ("PST", formatDatetime(parseTimestamp("1970-01-01"), "z"));
@@ -3983,11 +4735,9 @@ TEST_F(DateTimeFunctionsTest, dateFormat) {
   for (int i = 0; i < 8; i++) {
     std::string date("1996-01-0" + std::to_string(i + 1));
     // Full length name.
-    EXPECT_EQ(
-        daysLong[i % 7], dateFormat(parseTimestamp(StringView{date}), "%W"));
+    EXPECT_EQ(daysLong[i % 7], dateFormat(parseTimestamp(date), "%W"));
     // Abbreviated name.
-    EXPECT_EQ(
-        daysShort[i % 7], dateFormat(parseTimestamp(StringView{date}), "%a"));
+    EXPECT_EQ(daysShort[i % 7], dateFormat(parseTimestamp(date), "%a"));
   }
 
   // Month cases.
@@ -3996,23 +4746,19 @@ TEST_F(DateTimeFunctionsTest, dateFormat) {
     std::string monthNum = std::to_string(i + 1);
 
     // Full length name.
-    EXPECT_EQ(
-        monthsLong[i % 12], dateFormat(parseTimestamp(StringView{date}), "%M"));
+    EXPECT_EQ(monthsLong[i % 12], dateFormat(parseTimestamp(date), "%M"));
 
     // Abbreviated name.
-    EXPECT_EQ(
-        monthsShort[i % 12],
-        dateFormat(parseTimestamp(StringView{date}), "%b"));
+    EXPECT_EQ(monthsShort[i % 12], dateFormat(parseTimestamp(date), "%b"));
 
     // Numeric.
-    EXPECT_EQ(monthNum, dateFormat(parseTimestamp(StringView{date}), "%c"));
+    EXPECT_EQ(monthNum, dateFormat(parseTimestamp(date), "%c"));
 
     // Numeric 0-padded.
     if (i + 1 < 10) {
-      EXPECT_EQ(
-          "0" + monthNum, dateFormat(parseTimestamp(StringView{date}), "%m"));
+      EXPECT_EQ("0" + monthNum, dateFormat(parseTimestamp(date), "%m"));
     } else {
-      EXPECT_EQ(monthNum, dateFormat(parseTimestamp(StringView{date}), "%m"));
+      EXPECT_EQ(monthNum, dateFormat(parseTimestamp(date), "%m"));
     }
   }
 
@@ -4020,12 +4766,11 @@ TEST_F(DateTimeFunctionsTest, dateFormat) {
   for (int i = 1; i <= 31; i++) {
     std::string dayOfMonth = std::to_string(i);
     std::string date("1970-01-" + dayOfMonth);
-    EXPECT_EQ(dayOfMonth, dateFormat(parseTimestamp(StringView{date}), "%e"));
+    EXPECT_EQ(dayOfMonth, dateFormat(parseTimestamp(date), "%e"));
     if (i < 10) {
-      EXPECT_EQ(
-          "0" + dayOfMonth, dateFormat(parseTimestamp(StringView{date}), "%d"));
+      EXPECT_EQ("0" + dayOfMonth, dateFormat(parseTimestamp(date), "%d"));
     } else {
-      EXPECT_EQ(dayOfMonth, dateFormat(parseTimestamp(StringView{date}), "%d"));
+      EXPECT_EQ(dayOfMonth, dateFormat(parseTimestamp(date), "%d"));
     }
   }
 
@@ -5036,6 +5781,230 @@ TEST_F(DateTimeFunctionsTest, timestampWithTimezoneComparisons) {
   runAndCompare("c0 between c0 and c1", inputs, expectedBetween);
 }
 
+TEST_F(DateTimeFunctionsTest, timeComparisons) {
+  const auto eq = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>("c0 = c1", {TIME(), TIME()}, a, b);
+  };
+  const auto neq = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>("c0 != c1", {TIME(), TIME()}, a, b);
+  };
+  const auto lt = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>("c0 < c1", {TIME(), TIME()}, a, b);
+  };
+  const auto lte = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>("c0 <= c1", {TIME(), TIME()}, a, b);
+  };
+  const auto gt = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>("c0 > c1", {TIME(), TIME()}, a, b);
+  };
+  const auto gte = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>("c0 >= c1", {TIME(), TIME()}, a, b);
+  };
+  const auto between = [&](std::optional<int64_t> value,
+                           std::optional<int64_t> lower,
+                           std::optional<int64_t> upper) {
+    return evaluateOnce<bool>(
+        "c0 between c1 and c2", {TIME(), TIME(), TIME()}, value, lower, upper);
+  };
+
+  // test equality
+  EXPECT_EQ(true, eq(0, 0));
+  EXPECT_EQ(false, eq(0, 1000));
+  EXPECT_EQ(true, eq(3600000, 3600000)); // 01:00:00
+  EXPECT_EQ(std::nullopt, eq(std::nullopt, 0));
+  EXPECT_EQ(std::nullopt, eq(0, std::nullopt));
+
+  // test inequality
+  EXPECT_EQ(false, neq(0, 0));
+  EXPECT_EQ(true, neq(0, 1000));
+  EXPECT_EQ(false, neq(3600000, 3600000));
+
+  // test less than
+  EXPECT_EQ(false, lt(0, 0));
+  EXPECT_EQ(true, lt(0, 1000));
+  EXPECT_EQ(false, lt(1000, 0));
+  EXPECT_EQ(true, lt(3600000, 7200000)); // 01:00:00 < 02:00:00
+
+  // test less than or equal
+  EXPECT_EQ(true, lte(0, 0));
+  EXPECT_EQ(true, lte(0, 1000));
+  EXPECT_EQ(false, lte(1000, 0));
+
+  // test greater than
+  EXPECT_EQ(false, gt(0, 0));
+  EXPECT_EQ(false, gt(0, 1000));
+  EXPECT_EQ(true, gt(1000, 0));
+  EXPECT_EQ(true, gt(7200000, 3600000)); // 02:00:00 > 01:00:00
+
+  // test greater than or equal
+  EXPECT_EQ(true, gte(0, 0));
+  EXPECT_EQ(false, gte(0, 1000));
+  EXPECT_EQ(true, gte(1000, 0));
+
+  // test between
+  EXPECT_EQ(true, between(1000, 0, 2000));
+  EXPECT_EQ(true, between(0, 0, 2000)); // inclusive lower
+  EXPECT_EQ(true, between(2000, 0, 2000)); // inclusive upper
+  EXPECT_EQ(false, between(3000, 0, 2000));
+  EXPECT_EQ(false, between(0, 1000, 2000));
+  EXPECT_EQ(
+      true,
+      between(
+          3600000, 3600000, 7200000)); // 01:00:00 between 01:00:00 and 02:00:00
+  EXPECT_EQ(std::nullopt, between(std::nullopt, 0, 1000));
+  EXPECT_EQ(std::nullopt, between(500, std::nullopt, 1000));
+  EXPECT_EQ(std::nullopt, between(500, 0, std::nullopt));
+}
+
+TEST_F(DateTimeFunctionsTest, timeWithTimezoneComparisons) {
+  const auto eq = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>(
+        "c0 = c1", {TIME_WITH_TIME_ZONE(), TIME_WITH_TIME_ZONE()}, a, b);
+  };
+  const auto neq = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>(
+        "c0 != c1", {TIME_WITH_TIME_ZONE(), TIME_WITH_TIME_ZONE()}, a, b);
+  };
+  const auto lt = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>(
+        "c0 < c1", {TIME_WITH_TIME_ZONE(), TIME_WITH_TIME_ZONE()}, a, b);
+  };
+  const auto lte = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>(
+        "c0 <= c1", {TIME_WITH_TIME_ZONE(), TIME_WITH_TIME_ZONE()}, a, b);
+  };
+  const auto gt = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>(
+        "c0 > c1", {TIME_WITH_TIME_ZONE(), TIME_WITH_TIME_ZONE()}, a, b);
+  };
+  const auto gte = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>(
+        "c0 >= c1", {TIME_WITH_TIME_ZONE(), TIME_WITH_TIME_ZONE()}, a, b);
+  };
+  const auto between = [&](std::optional<int64_t> value,
+                           std::optional<int64_t> lower,
+                           std::optional<int64_t> upper) {
+    return evaluateOnce<bool>(
+        "c0 between c1 and c2",
+        {TIME_WITH_TIME_ZONE(), TIME_WITH_TIME_ZONE(), TIME_WITH_TIME_ZONE()},
+        value,
+        lower,
+        upper);
+  };
+
+  // test distinct_from - unlike regular comparison operators,
+  // distinct_from treats NULLs as values that can be compared
+  const auto distinctFrom = [&](std::optional<int64_t> a,
+                                std::optional<int64_t> b) {
+    return evaluateOnce<bool>(
+        "c0 is distinct from c1",
+        {TIME_WITH_TIME_ZONE(), TIME_WITH_TIME_ZONE()},
+        a,
+        b);
+  };
+
+  // Helper to parse TIME WITH TIME ZONE from string
+  const auto parse = [](const std::string& timeStr) -> std::optional<int64_t> {
+    auto result =
+        util::fromTimeWithTimezoneString(timeStr.c_str(), timeStr.size());
+    if (result.hasError()) {
+      throw std::runtime_error("Parse error: " + result.error().message());
+    }
+    return result.value();
+  };
+
+  // test equality - same UTC time in different timezones should be equal
+  EXPECT_EQ(true, eq(parse("00:00:00.000+00:00"), parse("01:00:00.000+01:00")));
+  EXPECT_EQ(true, eq(parse("12:30:45.123+00:00"), parse("20:30:45.123+08:00")));
+  EXPECT_EQ(
+      false, eq(parse("00:00:00.000+00:00"), parse("00:00:01.000+00:00")));
+  EXPECT_EQ(std::nullopt, eq(std::nullopt, parse("00:00:00.000+00:00")));
+
+  // test inequality
+  EXPECT_EQ(
+      true, neq(parse("00:00:00.000+00:00"), parse("00:00:00.000+01:00")));
+  EXPECT_EQ(
+      true, neq(parse("00:00:00.000+00:00"), parse("00:00:01.000+00:00")));
+  EXPECT_EQ(
+      true, neq(parse("01:00:00.000+01:00"), parse("01:00:00.000+03:00")));
+
+  // test less than
+  EXPECT_EQ(
+      false, lt(parse("00:00:00.000+00:00"), parse("00:00:00.000+01:00")));
+  EXPECT_EQ(true, lt(parse("00:00:01.000+01:00"), parse("00:00:00.000+00:00")));
+  EXPECT_EQ(
+      false, lt(parse("00:00:01.000+00:00"), parse("00:00:00.000+01:00")));
+  EXPECT_EQ(
+      false, lt(parse("01:00:00.000+01:00"), parse("02:00:00.000+03:00")));
+
+  // test less than or equal
+  EXPECT_EQ(
+      false, lte(parse("00:00:00.000+00:00"), parse("00:00:00.000+01:00")));
+  EXPECT_EQ(
+      false, lte(parse("00:00:01.000+00:00"), parse("00:00:00.000+01:00")));
+
+  // test greater than
+  EXPECT_EQ(true, gt(parse("00:00:00.000+00:00"), parse("00:00:00.000+01:00")));
+  EXPECT_EQ(
+      false, gt(parse("01:00:00.000+03:00"), parse("02:00:00.000+01:00")));
+
+  // test greater than or equal
+  EXPECT_EQ(
+      true, gte(parse("00:00:00.000+00:00"), parse("00:00:00.000+00:00")));
+  EXPECT_EQ(
+      true, gte(parse("00:00:00.000+00:00"), parse("00:00:01.000+01:00")));
+  EXPECT_EQ(
+      true, gte(parse("00:00:01.000+00:00"), parse("00:00:00.000+01:00")));
+
+  // test between
+  EXPECT_EQ(
+      true,
+      between(
+          parse("02:00:00.000+02:00"),
+          parse("00:00:00.000+01:00"),
+          parse("00:00:01.000+00:00")));
+  EXPECT_EQ(
+      std::nullopt,
+      between(
+          parse("00:00:00.500+00:00"),
+          parse("00:00:00.000+01:00"),
+          std::nullopt));
+
+  // test distinct from
+  // Same UTC time in different timezones should not be distinct
+  EXPECT_EQ(
+      false,
+      distinctFrom(parse("01:00:00.000+01:00"), parse("02:00:00.000+02:00")));
+
+  // Different times should be distinct
+  EXPECT_EQ(
+      true,
+      distinctFrom(parse("00:00:00.000+00:00"), parse("00:00:01.000+00:00")));
+  EXPECT_EQ(
+      true,
+      distinctFrom(parse("01:00:00.000+01:00"), parse("02:00:00.000+03:00")));
+
+  // NULL handling: NULL is distinct from non-NULL
+  EXPECT_EQ(true, distinctFrom(std::nullopt, parse("00:00:00.000+00:00")));
+
+  // NULL is NOT distinct from NULL
+  EXPECT_EQ(false, distinctFrom(std::nullopt, std::nullopt));
+
+  // Test edge cases with day wrap-around (normalization logic)
+  EXPECT_EQ(
+      false, eq(parse("01:00:00.000+08:00"), parse("02:00:00.000+00:00")));
+  EXPECT_EQ(
+      false, gt(parse("01:00:00.000+08:00"), parse("02:00:00.000+00:00")));
+
+  EXPECT_EQ(
+      false, eq(parse("23:00:00.000-08:00"), parse("16:00:00.000+08:00")));
+  EXPECT_EQ(true, lt(parse("23:00:00.000-08:00"), parse("18:00:00.000-14:00")));
+
+  EXPECT_EQ(
+      false, eq(parse("00:30:00.000-02:00"), parse("00:30:00.000+02:00")));
+  EXPECT_EQ(true, gt(parse("00:30:00.000-02:00"), parse("00:30:00.000+02:00")));
+}
+
 TEST_F(DateTimeFunctionsTest, castDateToTimestamp) {
   const int64_t kSecondsInDay = kMillisInDay / 1'000;
   const auto castDateToTimestamp = [&](const std::optional<int32_t> date) {
@@ -5361,6 +6330,99 @@ TEST_F(DateTimeFunctionsTest, atTimezoneTest) {
   EXPECT_EQ(at_timezone(std::nullopt, "Pacific/Fiji"), std::nullopt);
 }
 
+TEST_F(DateTimeFunctionsTest, atTimezoneTimeWithTimezoneTest) {
+  using namespace facebook::velox::util;
+
+  const auto at_timezone = [&](std::optional<int64_t> timeWithTimezone,
+                               std::optional<std::string> targetTimezone) {
+    return evaluateOnce<int64_t>(
+        "at_timezone(c0, c1)",
+        {TIME_WITH_TIME_ZONE(), VARCHAR()},
+        timeWithTimezone,
+        targetTimezone);
+  };
+
+  // Helper to create TIME WITH TIME ZONE values
+  const auto makeTimeWithTz = [](const std::string& timeStr) -> int64_t {
+    auto result = fromTimeWithTimezoneString(timeStr.c_str(), timeStr.size());
+    if (result.hasError()) {
+      throw std::runtime_error("Parse error: " + result.error().message());
+    }
+    return result.value();
+  };
+
+  // Test 1: Change from +05:30 to +08:00
+  // Input: 10:30:00+05:30 (which is 05:00:00 UTC)
+  // Output: Same UTC time (05:00:00 UTC) with +08:00 offset
+  auto input1 = makeTimeWithTz("10:30:00+05:30");
+  auto expected1 = makeTimeWithTz("13:00:00+08:00"); // Same UTC moment
+  EXPECT_EQ(at_timezone(input1, "+08:00"), expected1);
+
+  // Test 2: Change from -08:00 to +00:00 (UTC)
+  // Input: 14:00:00-08:00 (which is 22:00:00 UTC)
+  // Output: Same UTC time with +00:00 offset
+  auto input2 = makeTimeWithTz("14:00:00-08:00");
+  auto expected2 = makeTimeWithTz("22:00:00+00:00");
+  EXPECT_EQ(at_timezone(input2, "+00:00"), expected2);
+
+  // Test 3: Change from +00:00 to -05:00
+  // Input: 12:00:00+00:00 (which is 12:00:00 UTC)
+  // Output: Same UTC time with -05:00 offset
+  auto input3 = makeTimeWithTz("12:00:00+00:00");
+  auto expected3 = makeTimeWithTz("07:00:00-05:00");
+  EXPECT_EQ(at_timezone(input3, "-05:00"), expected3);
+
+  // Test 4: Change from +01:00 to -11:00
+  // Input: 23:30:00+01:00 (which is 22:30:00 UTC)
+  // Output: Same UTC time with -11:00 offset
+  auto input4 = makeTimeWithTz("23:30:00+01:00");
+  auto expected4 = makeTimeWithTz("11:30:00-11:00");
+  EXPECT_EQ(at_timezone(input4, "-11:00"), expected4);
+
+  // Test 5: With milliseconds - +05:30 to -08:00
+  // Input: 10:30:45.123+05:30 (which is 05:00:45.123 UTC)
+  // Output: Same UTC time with -08:00 offset
+  auto input5 = makeTimeWithTz("10:30:45.123+05:30");
+  auto expected5 = makeTimeWithTz("21:00:45.123-08:00");
+  EXPECT_EQ(at_timezone(input5, "-08:00"), expected5);
+
+  // Test 6: Different offset format - using +HH format
+  auto input6 = makeTimeWithTz("15:00:00+02:00");
+  auto expected6 = makeTimeWithTz("08:00:00-05:00");
+  EXPECT_EQ(at_timezone(input6, "-05"), expected6);
+
+  // Test 7: Different offset format - using +HH:mm format (Presto-compatible)
+  // Note: at_timezone uses allowCompactFormat=false to match Presto behavior,
+  // so we must use +HH:mm format, not +HHmm
+  auto input7 = makeTimeWithTz("08:15:30+00:00");
+  auto expected7 = makeTimeWithTz("13:45:30+05:30");
+  EXPECT_EQ(at_timezone(input7, "+05:30"), expected7);
+
+  // Test 8: Null input time
+  EXPECT_EQ(at_timezone(std::nullopt, "+05:00"), std::nullopt);
+
+  // Test 9: Null target timezone
+  EXPECT_EQ(
+      at_timezone(makeTimeWithTz("12:00:00+00:00"), std::nullopt),
+      std::nullopt);
+
+  // Test 10: Invalid timezone offset format should throw
+  EXPECT_THROW(
+      at_timezone(makeTimeWithTz("12:00:00+00:00"), "invalid"), VeloxUserError);
+
+  // Test 11: Timezone offset out of valid range should throw
+  EXPECT_THROW(
+      at_timezone(makeTimeWithTz("12:00:00+00:00"), "+15:00"), VeloxUserError);
+
+  EXPECT_THROW(
+      at_timezone(makeTimeWithTz("12:00:00+00:00"), "-15:00"), VeloxUserError);
+
+  // Test 12: timezone IANA Names should throw
+  EXPECT_THROW(
+      at_timezone(makeTimeWithTz("12:00:00+00:00"), "America/Los_Angeles"),
+      VeloxUserError);
+}
+
 TEST_F(DateTimeFunctionsTest, toMilliseconds) {
   EXPECT_EQ(
       123,
@@ -5494,3 +6556,564 @@ TEST_F(DateTimeFunctionsTest, xxHash64FunctionTimestamp) {
   EXPECT_EQ(
       7585368295023641328, xxhash64(parseTimestamp("1900-01-01 00:00:00.000")));
 }
+
+TEST_F(DateTimeFunctionsTest, xxHash64FunctionTime) {
+  const auto xxhash64 = [&](std::optional<int64_t> time) {
+    return evaluateOnce<int64_t>("xxhash64_internal(c0)", TIME(), time);
+  };
+
+  // Test NULL handling
+  EXPECT_EQ(std::nullopt, xxhash64(std::nullopt));
+
+  // Test determinism - same input should give same output
+  auto result1 = xxhash64(43200000);
+  auto result2 = xxhash64(43200000);
+  EXPECT_EQ(result1, result2);
+
+  // Test that different inputs give different outputs
+  auto hash0 = xxhash64(0);
+  auto hash1 = xxhash64(1);
+  auto hashNoon = xxhash64(43200000);
+  auto hashEnd = xxhash64(86399999);
+
+  EXPECT_NE(hash0, hash1);
+  EXPECT_NE(hash0, hashNoon);
+  EXPECT_NE(hash0, hashEnd);
+  EXPECT_NE(hashNoon, hashEnd);
+
+  // Test boundary values don't crash
+  EXPECT_TRUE(xxhash64(0).has_value());
+  EXPECT_TRUE(xxhash64(86399999).has_value());
+
+  // Test known hash values validated against Presto xxhash64
+  // Query: SELECT from_big_endian_64(xxhash64(to_big_endian_64(value)))
+  EXPECT_EQ(3803688792395291579, xxhash64(0)); // Midnight
+  EXPECT_EQ(-6980583299780818982, xxhash64(1)); // 1 millisecond after midnight
+  EXPECT_EQ(7848233046982034517, xxhash64(43200000)); // Noon (12:00:00.000)
+  EXPECT_EQ(
+      5892092673475229733, xxhash64(86399999)); // End of day (23:59:59.999)
+  EXPECT_EQ(-3599997350390034763, xxhash64(1234)); // Arbitrary value
+}
+
+TEST_F(DateTimeFunctionsTest, currentTimestamp) {
+  const auto callCurrentTimestamp =
+      [&](int64_t sessionStartTime,
+          const std::optional<std::string>& timeZone) {
+        if (timeZone.has_value()) {
+          setSessionStartTimeAndTimeZone(sessionStartTime, timeZone.value());
+        } else {
+          setQuerySessionStartTime(sessionStartTime);
+        }
+
+        auto rowVector = makeRowVector({});
+        rowVector->resize(1);
+
+        auto result = evaluate("current_timestamp()", rowVector);
+        DecodedVector decoded(*result);
+        return decoded.valueAt<int64_t>(0);
+      };
+
+  // Test without timezone
+  EXPECT_THROW(
+      {
+        try {
+          callCurrentTimestamp(0, std::nullopt);
+        } catch (const VeloxException& e) {
+          EXPECT_EQ(e.exceptionType(), VeloxException::Type::kUser);
+          throw;
+        }
+      },
+      VeloxException);
+
+  // Test with timezone America/Los_Angeles
+  auto laPacked = callCurrentTimestamp(1758499200000, "America/Los_Angeles");
+  auto la = TimestampWithTimezone::unpack(laPacked);
+  ASSERT_TRUE(la.has_value());
+
+  EXPECT_EQ(la->timezone_->name(), "America/Los_Angeles");
+  EXPECT_EQ(la->milliSeconds_, 1758499200000);
+}
+
+TEST_F(DateTimeFunctionsTest, localtime) {
+  const auto localtime = [&](int64_t sessionStartTime,
+                             const std::optional<std::string>& timeZone) {
+    if (timeZone.has_value()) {
+      setSessionStartTimeAndTimeZone(sessionStartTime, timeZone.value());
+    } else {
+      setQuerySessionStartTime(sessionStartTime);
+    }
+
+    auto rowVector = makeRowVector({});
+    rowVector->resize(1);
+    auto result = evaluate("localtime()", rowVector);
+    DecodedVector decoded(*result);
+    return decoded.valueAt<int64_t>(0);
+  };
+
+  auto utcVal = localtime(0, std::nullopt);
+  EXPECT_EQ(utcVal, 0);
+
+  auto localVal =
+      localtime(1758499200000, "America/Los_Angeles"); // Midnight UTC
+  EXPECT_EQ(localVal, 0);
+
+  // Test during daylight saving time
+  localVal = localtime(1710061200000, "America/Los_Angeles");
+  EXPECT_EQ(localVal, 32400000); // 9 AM UTC
+}
+
+TEST_F(DateTimeFunctionsTest, localTimestamp) {
+  const auto localTimestamp = [&](int64_t sessionStartTime,
+                                  const std::optional<std::string>& timeZone) {
+    if (timeZone.has_value()) {
+      setSessionStartTimeAndTimeZone(sessionStartTime, timeZone.value());
+    } else {
+      setQuerySessionStartTime(sessionStartTime);
+    }
+
+    return evaluateOnce<Timestamp>(
+        "localtimestamp()", makeRowVector(ROW({}), 1));
+  };
+
+  // ============================================================
+  // 1. Basic behavior (no timezone)
+  // ============================================================
+
+  // Epoch — zero nanos
+  {
+    auto tsUtc = localTimestamp(0, std::nullopt);
+    ASSERT_TRUE(tsUtc.has_value());
+    EXPECT_EQ(tsUtc->getSeconds(), 0);
+    EXPECT_EQ(tsUtc->getNanos(), 0);
+  }
+
+  // ============================================================
+  // 2. Basic behavior with timezone
+  // ============================================================
+
+  // Exact second boundary
+  {
+    const int64_t millis = 1758499200000; // exact second
+    auto tsExact = localTimestamp(millis, "America/Los_Angeles");
+
+    ASSERT_TRUE(tsExact.has_value());
+    EXPECT_EQ(tsExact.value().getSeconds(), millis / 1000);
+    EXPECT_EQ(tsExact.value().getNanos(), 0);
+  }
+
+  // Fractional milliseconds (nanos test)
+  {
+    const int64_t millisWithFraction = 1758499200123; // +123 ms
+    auto tsWithNanos =
+        localTimestamp(millisWithFraction, "America/Los_Angeles");
+
+    ASSERT_TRUE(tsWithNanos.has_value());
+    EXPECT_EQ(tsWithNanos.value().getSeconds(), millisWithFraction / 1000);
+    EXPECT_EQ(tsWithNanos.value().getNanos(), 123'000'000);
+  }
+
+  // ============================================================
+  // 3. DST FORWARD (Spring transition)
+  // America/Los_Angeles
+  // 2023-03-12 01:59:59 PST  →  03:00:00 PDT
+  // ============================================================
+
+  {
+    const int64_t beforeForward = 1678615199000; // 2023-03-12T09:59:59Z
+    auto tsBeforeForward = localTimestamp(beforeForward, "America/Los_Angeles");
+
+    ASSERT_TRUE(tsBeforeForward.has_value());
+    EXPECT_EQ(tsBeforeForward.value().getSeconds(), beforeForward / 1000);
+    EXPECT_EQ(tsBeforeForward.value().getNanos(), 0);
+
+    const int64_t afterForward = 1678615200000; // 2023-03-12T10:00:00Z
+    auto tsAfterForward = localTimestamp(afterForward, "America/Los_Angeles");
+
+    ASSERT_TRUE(tsAfterForward.has_value());
+    EXPECT_EQ(tsAfterForward.value().getSeconds(), afterForward / 1000);
+    EXPECT_EQ(tsAfterForward.value().getNanos(), 0);
+  }
+
+  // ============================================================
+  // 4. DST BACKWARD (Fall transition)
+  // America/Los_Angeles
+  // 2023-11-05 01:59:59 PDT  →  01:00:00 PST (repeated hour)
+  // ============================================================
+
+  {
+    const int64_t beforeBackward = 1699174799000; // 2023-11-05T08:59:59Z
+    auto tsBeforeBackward =
+        localTimestamp(beforeBackward, "America/Los_Angeles");
+
+    ASSERT_TRUE(tsBeforeBackward.has_value());
+    EXPECT_EQ(tsBeforeBackward.value().getSeconds(), beforeBackward / 1000);
+    EXPECT_EQ(tsBeforeBackward.value().getNanos(), 0);
+
+    const int64_t afterBackward = 1699174800000; // 2023-11-05T09:00:00Z
+    auto tsAfterBackward = localTimestamp(afterBackward, "America/Los_Angeles");
+
+    ASSERT_TRUE(tsAfterBackward.has_value());
+    EXPECT_EQ(tsAfterBackward.value().getSeconds(), afterBackward / 1000);
+    EXPECT_EQ(tsAfterBackward.value().getNanos(), 0);
+  }
+}
+
+TEST_F(DateTimeFunctionsTest, dateDiffTime) {
+  const auto dateDiff = [&](const std::string& unit,
+                            std::optional<int64_t> time1,
+                            std::optional<int64_t> time2) {
+    return evaluateOnce<int64_t>(
+        fmt::format("date_diff('{}', c0, c1)", unit),
+        {TIME(), TIME()},
+        time1,
+        time2);
+  };
+
+  // Basic time differences - following Presto's date_diff(unit, x1, x2) = x2 -
+  // x1 pattern
+
+  // Test millisecond differences
+  EXPECT_EQ(
+      1000, dateDiff("millisecond", 0, 1000)); // 00:00:00.000 to 00:00:01.000
+  EXPECT_EQ(
+      -1000,
+      dateDiff(
+          "millisecond", 1000, 0)); // 00:00:01.000 to 00:00:00.000 (negative)
+  EXPECT_EQ(0, dateDiff("millisecond", 1000, 1000)); // Same time
+  EXPECT_EQ(
+      500, dateDiff("millisecond", 500, 1000)); // 00:00:00.500 to 00:00:01.000
+
+  // Test second differences
+  EXPECT_EQ(1, dateDiff("second", 0, 1000)); // 1 second difference
+  EXPECT_EQ(-1, dateDiff("second", 1000, 0)); // Negative 1 second
+  EXPECT_EQ(0, dateDiff("second", 1000, 1000)); // Same time
+  EXPECT_EQ(30, dateDiff("second", 15000, 45000)); // 30 seconds (15s to 45s)
+  EXPECT_EQ(3661, dateDiff("second", 0, 3661000)); // 1 hour 1 minute 1 second
+
+  // Test minute differences
+  EXPECT_EQ(1, dateDiff("minute", 0, 60000)); // 1 minute (00:00 to 00:01)
+  EXPECT_EQ(-1, dateDiff("minute", 60000, 0)); // Negative 1 minute
+  EXPECT_EQ(0, dateDiff("minute", 60000, 60000)); // Same time
+  EXPECT_EQ(5, dateDiff("minute", 0, 300000)); // 5 minutes (00:00 to 00:05)
+  EXPECT_EQ(61, dateDiff("minute", 0, 3660000)); // 1 hour 1 minute
+
+  // Test hour differences
+  EXPECT_EQ(1, dateDiff("hour", 0, 3600000)); // 1 hour (00:00 to 01:00)
+  EXPECT_EQ(-1, dateDiff("hour", 3600000, 0)); // Negative 1 hour
+  EXPECT_EQ(0, dateDiff("hour", 3600000, 3600000)); // Same time
+  EXPECT_EQ(12, dateDiff("hour", 0, 43200000)); // 12 hours (00:00 to 12:00)
+  EXPECT_EQ(23, dateDiff("hour", 0, 82800000)); // 23 hours (00:00 to 23:00)
+
+  // Test boundary values for TIME type (0 to 86399999 ms in a day)
+  EXPECT_EQ(0, dateDiff("millisecond", 0, 0)); // 00:00:00.000 to 00:00:00.000
+  EXPECT_EQ(
+      86399999,
+      dateDiff("millisecond", 0, 86399999)); // 00:00:00.000 to 23:59:59.999
+  EXPECT_EQ(
+      -86399999,
+      dateDiff("millisecond", 86399999, 0)); // 23:59:59.999 to 00:00:00.000
+  EXPECT_EQ(
+      86399, dateDiff("second", 0, 86399999)); // Full day minus 1ms in seconds
+  EXPECT_EQ(
+      1439, dateDiff("minute", 0, 86399999)); // Full day minus 1ms in minutes
+  EXPECT_EQ(23, dateDiff("hour", 0, 86399999)); // Full day minus 1ms in hours
+
+  // Test fractional truncation behavior (consistent with Presto integer
+  // division)
+  EXPECT_EQ(0, dateDiff("second", 0, 999)); // 999ms < 1000ms, truncates to 0
+  EXPECT_EQ(
+      59, dateDiff("minute", 0, 3599999)); // 59.99999 minutes truncates to 59
+  EXPECT_EQ(0, dateDiff("hour", 0, 3599999)); // 0.99999 hours truncates to 0
+
+  // Test real-world scenario: 09:30:15.500 to 14:45:30.750
+  int64_t morning = 9 * 3600000 + 30 * 60000 + 15 * 1000 + 500; // 34215500ms
+  int64_t afternoon = 14 * 3600000 + 45 * 60000 + 30 * 1000 + 750; // 53130750ms
+
+  EXPECT_EQ(18915250, dateDiff("millisecond", morning, afternoon));
+  EXPECT_EQ(
+      18915,
+      dateDiff("second", morning, afternoon)); // 18915.25s truncated to 18915
+  EXPECT_EQ(
+      315,
+      dateDiff(
+          "minute", morning, afternoon)); // 315.254... minutes truncated to 315
+  EXPECT_EQ(
+      5, dateDiff("hour", morning, afternoon)); // 5.254... hours truncated to 5
+  EXPECT_EQ(
+      315,
+      dateDiff(
+          "minute", morning, afternoon)); // 315.254... minutes truncated to 315
+  EXPECT_EQ(
+      5, dateDiff("hour", morning, afternoon)); // 5.254... hours truncated to 5
+
+  // Test null handling (consistent with Presto null propagation)
+  EXPECT_EQ(std::nullopt, dateDiff("second", 1000, std::nullopt));
+  EXPECT_EQ(std::nullopt, dateDiff("second", std::nullopt, 1000));
+  EXPECT_EQ(std::nullopt, dateDiff("second", std::nullopt, std::nullopt));
+
+  // Test invalid units (TIME only supports millisecond, second, minute, and
+  // hour - microsecond is not supported in Presto)
+  VELOX_ASSERT_THROW(
+      dateDiff("microsecond", 0, 1000),
+      "microsecond is not a valid TIME field");
+  VELOX_ASSERT_THROW(dateDiff("day", 0, 1000), "day is not a valid TIME field");
+  VELOX_ASSERT_THROW(
+      dateDiff("week", 0, 1000), "week is not a valid TIME field");
+  VELOX_ASSERT_THROW(
+      dateDiff("month", 0, 1000), "month is not a valid TIME field");
+  VELOX_ASSERT_THROW(
+      dateDiff("quarter", 0, 1000), "quarter is not a valid TIME field");
+  VELOX_ASSERT_THROW(
+      dateDiff("year", 0, 1000), "year is not a valid TIME field");
+  VELOX_ASSERT_THROW(
+      dateDiff("invalid", 0, 1000), "invalid is not a valid TIME field");
+
+  // Additional edge cases
+  // Note: This represents going from 23:59:59.999 to 00:00:00.000 of next day,
+  // but since TIME type represents time within a single day, this results in
+  // negative difference
+  EXPECT_EQ(
+      -86399999,
+      dateDiff(
+          "millisecond",
+          86399999,
+          0)); // 23:59:59.999 to 00:00:00.000 (negative)
+}
+
+TEST_F(DateTimeFunctionsTest, dateDiffTimeVariableUnit) {
+  // This test validates that when the unit parameter is variable (passed as a
+  // column with different values per row), the function correctly processes
+  // each row with its own unit value rather than incorrectly caching a single
+  // unit. This tests batch processing with varying units in a single
+  // evaluation.
+  auto data = makeRowVector({
+      makeFlatVector<std::string>(
+          {"millisecond", "second", "minute", "hour", "millisecond"}),
+      makeFlatVector<int64_t>({0, 0, 0, 0, 1000}, TIME()),
+      makeFlatVector<int64_t>({1000, 1000, 60000, 3600000, 2000}, TIME()),
+  });
+
+  auto result = evaluate("date_diff(c0, c1, c2)", data);
+  auto expected = makeFlatVector<int64_t>({
+      1000, // millisecond: 0 to 1000
+      1, // second: 0 to 1000
+      1, // minute: 0 to 60000
+      1, // hour: 0 to 3600000
+      1000, // millisecond: 1000 to 2000
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(DateTimeFunctionsTest, dateTruncTimestampVariableUnit) {
+  // This test validates that when the unit parameter is variable (passed as a
+  // column with different values per row), date_trunc correctly processes each
+  // row with its own unit value rather than incorrectly caching a single unit.
+  auto timestamps = makeFlatVector<Timestamp>({
+      Timestamp(998474645, 321001234), // 2001-08-22 03:04:05.321001234
+      Timestamp(998474645, 321001234), // 2001-08-22 03:04:05.321001234
+      Timestamp(998474645, 321001234), // 2001-08-22 03:04:05.321001234
+      Timestamp(998474645, 321001234), // 2001-08-22 03:04:05.321001234
+      Timestamp(998474645, 321001234), // 2001-08-22 03:04:05.321001234
+  });
+
+  auto data = makeRowVector({
+      makeFlatVector<std::string>({"second", "minute", "hour", "day", "month"}),
+      timestamps,
+  });
+
+  auto result = evaluate("date_trunc(c0, c1)", data);
+
+  auto expected = makeFlatVector<Timestamp>({
+      Timestamp(998474645, 0), // second: 2001-08-22 03:04:05.000
+      Timestamp(998474640, 0), // minute: 2001-08-22 03:04:00.000
+      Timestamp(998474400, 0), // hour: 2001-08-22 03:00:00.000
+      Timestamp(998438400, 0), // day: 2001-08-22 00:00:00.000
+      Timestamp(996624000, 0), // month: 2001-08-01 00:00:00.000
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(DateTimeFunctionsTest, dateTruncDateVariableUnit) {
+  // This test validates that when the unit parameter is variable (passed as a
+  // column with different values per row), date_trunc correctly processes each
+  // row with its own unit value for DATE type.
+  auto dates = makeFlatVector<int32_t>(
+      {parseDate("2020-02-29"),
+       parseDate("2020-02-29"),
+       parseDate("2020-02-29"),
+       parseDate("2020-02-29")},
+      DATE());
+
+  auto data = makeRowVector({
+      makeFlatVector<std::string>({"day", "week", "month", "quarter"}),
+      dates,
+  });
+
+  auto result = evaluate("date_trunc(c0, c1)", data);
+
+  auto expected = makeFlatVector<int32_t>(
+      {parseDate("2020-02-29"), // day: same
+       parseDate("2020-02-24"), // week: Monday of that week
+       parseDate("2020-02-01"), // month: first day of month
+       parseDate("2020-01-01")}, // quarter: first day of quarter
+      DATE());
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(DateTimeFunctionsTest, dateTruncTime) {
+  const auto dateTrunc = [&](const std::string& unit,
+                             std::optional<int64_t> time) {
+    return evaluateOnce<int64_t>(
+        fmt::format("date_trunc('{}', c0)", unit), TIME(), time);
+  };
+
+  EXPECT_EQ(std::nullopt, dateTrunc("second", std::nullopt));
+
+  // TIME value: 03:04:05.321 = (3*3600 + 4*60 + 5)*1000 + 321 = 11045321 ms
+  const int64_t time1 = 11045321;
+
+  EXPECT_EQ(11045321, dateTrunc("millisecond", time1)); // no change
+  EXPECT_EQ(11045000, dateTrunc("second", time1)); // 03:04:05.000
+  EXPECT_EQ(11040000, dateTrunc("minute", time1)); // 03:04:00.000
+  EXPECT_EQ(10800000, dateTrunc("hour", time1)); // 03:00:00.000
+
+  // TIME value: 00:00:00.000 = 0 ms (midnight)
+  EXPECT_EQ(0, dateTrunc("millisecond", 0));
+  EXPECT_EQ(0, dateTrunc("second", 0));
+  EXPECT_EQ(0, dateTrunc("minute", 0));
+  EXPECT_EQ(0, dateTrunc("hour", 0));
+
+  // TIME value: 23:59:59.999 = (23*3600 + 59*60 + 59)*1000 + 999 = 86399999 ms
+  const int64_t time2 = 86399999;
+  EXPECT_EQ(86399999, dateTrunc("millisecond", time2)); // no change
+  EXPECT_EQ(86399000, dateTrunc("second", time2)); // 23:59:59.000
+  EXPECT_EQ(86340000, dateTrunc("minute", time2)); // 23:59:00.000
+  EXPECT_EQ(82800000, dateTrunc("hour", time2)); // 23:00:00.000
+
+  // TIME value: 12:30:45.123 = (12*3600 + 30*60 + 45)*1000 + 123 = 45045123 ms
+  const int64_t time3 = 45045123;
+  EXPECT_EQ(45045123, dateTrunc("millisecond", time3)); // no change
+  EXPECT_EQ(45045000, dateTrunc("second", time3)); // 12:30:45.000
+  EXPECT_EQ(45000000, dateTrunc("minute", time3)); // 12:30:00.000
+  EXPECT_EQ(43200000, dateTrunc("hour", time3)); // 12:00:00.000
+
+  // Invalid unit tests - TIME only supports millisecond, second, minute, and
+  // hour (microsecond is not supported in Presto)
+  VELOX_ASSERT_THROW(
+      dateTrunc("microsecond", time1), "microsecond is not a valid TIME field");
+  VELOX_ASSERT_THROW(dateTrunc("day", time1), "day is not a valid TIME field");
+  VELOX_ASSERT_THROW(
+      dateTrunc("week", time1), "week is not a valid TIME field");
+  VELOX_ASSERT_THROW(
+      dateTrunc("month", time1), "month is not a valid TIME field");
+  VELOX_ASSERT_THROW(
+      dateTrunc("quarter", time1), "quarter is not a valid TIME field");
+  VELOX_ASSERT_THROW(
+      dateTrunc("year", time1), "year is not a valid TIME field");
+}
+
+TEST_F(DateTimeFunctionsTest, dateAddTimestampVariableUnit) {
+  // This test validates that when the unit parameter is variable (passed as a
+  // column with different values per row), date_add correctly processes each
+  // row with its own unit value.
+  auto timestamps = makeFlatVector<Timestamp>({
+      Timestamp(0, 0), // 1970-01-01 00:00:00.000
+      Timestamp(0, 0), // 1970-01-01 00:00:00.000
+      Timestamp(0, 0), // 1970-01-01 00:00:00.000
+      Timestamp(0, 0), // 1970-01-01 00:00:00.000
+      Timestamp(0, 0), // 1970-01-01 00:00:00.000
+  });
+
+  auto data = makeRowVector({
+      makeFlatVector<std::string>({"second", "minute", "hour", "day", "month"}),
+      makeFlatVector<int64_t>({1, 1, 1, 1, 1}),
+      timestamps,
+  });
+
+  auto result = evaluate("date_add(c0, c1, c2)", data);
+
+  auto expected = makeFlatVector<Timestamp>({
+      Timestamp(1, 0), // second: 1970-01-01 00:00:01.000
+      Timestamp(60, 0), // minute: 1970-01-01 00:01:00.000
+      Timestamp(3600, 0), // hour: 1970-01-01 01:00:00.000
+      Timestamp(86400, 0), // day: 1970-01-02 00:00:00.000
+      Timestamp(2678400, 0), // month: 1970-02-01 00:00:00.000
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(DateTimeFunctionsTest, dateAddDateVariableUnit) {
+  // This test validates that when the unit parameter is variable (passed as a
+  // column with different values per row), date_add correctly processes each
+  // row with its own unit value for DATE type.
+  auto dates = makeFlatVector<int32_t>(
+      {parseDate("2020-01-31"),
+       parseDate("2020-01-31"),
+       parseDate("2020-01-31"),
+       parseDate("2020-01-31")},
+      DATE());
+
+  auto data = makeRowVector({
+      makeFlatVector<std::string>({"day", "week", "month", "year"}),
+      makeFlatVector<int64_t>({1, 1, 1, 1}),
+      dates,
+  });
+
+  auto result = evaluate("date_add(c0, c1, c2)", data);
+
+  auto expected = makeFlatVector<int32_t>(
+      {parseDate("2020-02-01"), // day: 2020-01-31 + 1 day
+       parseDate("2020-02-07"), // week: 2020-01-31 + 7 days
+       parseDate("2020-02-29"), // month: 2020-01-31 + 1 month (leap year)
+       parseDate("2021-01-31")}, // year: 2020-01-31 + 1 year
+      DATE());
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(DateTimeFunctionsTest, currentTime) {
+  auto testCurrentTime = [&](int64_t sessionStartTime,
+                             const std::string& zone,
+                             int64_t expectedMillis,
+                             int16_t expectedOffset) {
+    setSessionStartTimeAndTimeZone(sessionStartTime, zone);
+
+    auto packed = evaluateOnce<int64_t>(
+        "current_time()",
+        makeRowVector(ROW({}), 1),
+        std::nullopt,
+        TIME_WITH_TIME_ZONE());
+
+    ASSERT_TRUE(packed.has_value());
+
+    EXPECT_EQ(util::unpackMillisUtc(packed.value()), expectedMillis);
+    EXPECT_EQ(util::unpackZoneOffset(packed.value()), expectedOffset);
+  };
+
+  testCurrentTime(1710064800000, "UTC", 36000000, 0);
+  testCurrentTime(1710064800000, "Asia/Kolkata", 55800000, 1170);
+  testCurrentTime(1705312800000, "America/Los_Angeles", 7200000, 361);
+  testCurrentTime(1717243200000, "America/Los_Angeles", 18000000, 421);
+}
+
+TEST_F(DateTimeFunctionsTest, currentTimezone) {
+  {
+    setQueryTimeZone("Asia/Kolkata");
+    auto tz = evaluateOnce<std::string>(
+        "current_timezone()", makeRowVector(ROW({}), 1));
+    ASSERT_TRUE(tz.has_value());
+    EXPECT_EQ(tz.value(), "Asia/Kolkata");
+  }
+
+  {
+    setQueryTimeZone("America/New_York");
+    auto tz = evaluateOnce<std::string>(
+        "current_timezone()", makeRowVector(ROW({}), 1));
+    ASSERT_TRUE(tz.has_value());
+    EXPECT_EQ(tz.value(), "America/New_York");
+  }
+}
diff --git a/velox/functions/prestosql/tests/DecimalArithmeticTest.cpp b/velox/functions/prestosql/tests/DecimalArithmeticTest.cpp
index 70377a72d6d..ecebeb5b0c4 100644
--- a/velox/functions/prestosql/tests/DecimalArithmeticTest.cpp
+++ b/velox/functions/prestosql/tests/DecimalArithmeticTest.cpp
@@ -42,6 +42,24 @@ class DecimalArithmeticTest : public FunctionBaseTest {
     testOpDictVectors<EvalType>(expression, expected, input);
   }
 
+  // Returns a tester lambda that takes an InputType and an EvalType and which
+  // can be called to test the expression with specific input and expected
+  // output values. Currently only used by floorAndCeil test.
+  // See Issue #16464 for details.
+  template <typename InputType, TypeKind K>
+  std::function<void(InputType, typename TypeTraits<K>::NativeType)>
+  makeDecimalExprTester(
+      const TypePtr& inType,
+      const TypePtr& outType,
+      const std::string& exprStr) {
+    using EvalType = typename TypeTraits<K>::NativeType;
+    return [this, inType, outType, exprStr](InputType input, EvalType out) {
+      auto v = makeFlatVector<InputType>({input}, inType);
+      testDecimalExpr<K>(
+          makeFlatVector<EvalType>({out}, outType), exprStr, {v});
+    };
+  }
+
   template <typename T>
   void testOpDictVectors(
       const std::string& operation,
@@ -565,76 +583,173 @@ TEST_F(DecimalArithmeticTest, roundN) {
           DECIMAL(19, 5))});
 }
 
-TEST_F(DecimalArithmeticTest, floor) {
-  // short DECIMAL -> short DECIMAL.
-  testDecimalExpr<TypeKind::BIGINT>(
-      {makeFlatVector<int64_t>({0, 0, -1, 0, -1, 0, -1, 0, -1}, DECIMAL(2, 0))},
-      "floor(c0)",
-      {makeFlatVector<int64_t>(
-          {0, 1, -1, 49, -49, 50, -50, 99, -99}, DECIMAL(3, 2))});
-  testDecimalExpr<TypeKind::BIGINT>(
-      {makeFlatVector<int64_t>(
-          {123, -123, 123, -124, 123, -124, 123, -124, 123, -124, 123, -124},
-          DECIMAL(4, 0))},
-      "floor(c0)",
-      {makeFlatVector<int64_t>(
-          {12300,
-           -12300,
-           12301,
-           -12301,
-           12345,
-           -12345,
-           12349,
-           -12349,
-           12350,
-           -12350,
-           12399,
-           -12399},
-          DECIMAL(5, 2))});
-  testDecimalExpr<TypeKind::BIGINT>(
-      {makeFlatVector<int64_t>(
-          {DecimalUtil::kShortDecimalMax, DecimalUtil::kShortDecimalMin},
-          DECIMAL(18, 0))},
-      "floor(c0)",
-      {makeFlatVector<int64_t>(
-          {DecimalUtil::kShortDecimalMax, DecimalUtil::kShortDecimalMin},
-          DECIMAL(18, 0))});
+// Proposed new style for all these tests (and perhaps the SparkSQL equivalents)
+// tests to make them more readable and maintainable. A helper function was
+// added to the test class which returns a lambda which is then called to test
+// the expression with specific input and expected output values.
+// @TODO: Refactor other tests to use this style for clarity. See Issue #16464.
+
+TEST_F(DecimalArithmeticTest, floorAndCeil) {
+  // Short DECIMAL(3,2) -> Short DECIMAL(2.0).
+  // e.g. floor(0.49) = 0, floor(-0.49) = -1, ceil(0.49) = 1, ceil(-0.49) = 0
+  {
+    const auto inType = DECIMAL(3, 2);
+    const auto outType = DECIMAL(2, 0);
+    auto testFloor = makeDecimalExprTester<int64_t, TypeKind::BIGINT>(
+        inType, outType, "floor(c0)");
+    auto testCeil = makeDecimalExprTester<int64_t, TypeKind::BIGINT>(
+        inType, outType, "ceil(c0)");
+    testFloor(0, 0);
+    testFloor(1, 0);
+    testFloor(-1, -1);
+    testFloor(49, 0);
+    testFloor(-49, -1);
+    testFloor(50, 0);
+    testFloor(-50, -1);
+    testFloor(99, 0);
+    testFloor(-99, -1);
+    testCeil(0, 0);
+    testCeil(1, 1);
+    testCeil(-1, 0);
+    testCeil(49, 1);
+    testCeil(-49, 0);
+    testCeil(50, 1);
+    testCeil(-50, 0);
+    testCeil(99, 1);
+    testCeil(-99, 0);
+  }
 
-  // long DECIMAL -> long DECIMAL.
-  testDecimalExpr<TypeKind::HUGEINT>(
-      {makeFlatVector<int128_t>(
-          {0, 0, -1, 0, -1, 0, -1, 0, -1}, DECIMAL(19, 0))},
-      "floor(c0)",
-      {makeFlatVector<int128_t>(
-          {0, 1, -1, 49, -49, 50, -50, 99, -99}, DECIMAL(20, 2))});
-  testDecimalExpr<TypeKind::HUGEINT>(
-      {makeFlatVector<int128_t>(
-          {DecimalUtil::kPowersOfTen[33] - 1, -DecimalUtil::kPowersOfTen[33]},
-          DECIMAL(34, 0))},
-      "floor(c0)",
-      {makeFlatVector<int128_t>(
-          {DecimalUtil::kLongDecimalMax, DecimalUtil::kLongDecimalMin},
-          DECIMAL(38, 5))});
-  testDecimalExpr<TypeKind::HUGEINT>(
-      {makeFlatVector<int128_t>(
-          {DecimalUtil::kLongDecimalMax, DecimalUtil::kLongDecimalMin},
-          DECIMAL(38, 0))},
-      "floor(c0)",
-      {makeFlatVector<int128_t>(
-          {DecimalUtil::kLongDecimalMax, DecimalUtil::kLongDecimalMin},
-          DECIMAL(38, 0))});
+  // Short DECIMAL(5,2) -> Short DECIMAL(4,0).
+  // e.g. floor(123.45) = 123, floor(-123.45) = -124, ceil(123.45) = 124,
+  // ceil(-123.45) = -123
+  {
+    const auto inType = DECIMAL(5, 2);
+    const auto outType = DECIMAL(4, 0);
+    auto testFloor = makeDecimalExprTester<int64_t, TypeKind::BIGINT>(
+        inType, outType, "floor(c0)");
+    auto testCeil = makeDecimalExprTester<int64_t, TypeKind::BIGINT>(
+        inType, outType, "ceil(c0)");
+    testFloor(12300, 123);
+    testFloor(-12300, -123);
+    testFloor(12301, 123);
+    testFloor(-12301, -124);
+    testFloor(12345, 123);
+    testFloor(-12345, -124);
+    testFloor(12349, 123);
+    testFloor(-12349, -124);
+    testFloor(12350, 123);
+    testFloor(-12350, -124);
+    testFloor(12399, 123);
+    testFloor(-12399, -124);
+    testCeil(12300, 123);
+    testCeil(-12300, -123);
+    testCeil(12301, 124);
+    testCeil(-12301, -123);
+    testCeil(12345, 124);
+    testCeil(-12345, -123);
+    testCeil(12349, 124);
+    testCeil(-12349, -123);
+    testCeil(12350, 124);
+    testCeil(-12350, -123);
+    testCeil(12399, 124);
+    testCeil(-12399, -123);
+  }
 
-  // long DECIMAL -> short DECIMAL.
-  testDecimalExpr<TypeKind::BIGINT>(
-      {makeFlatVector<int64_t>({0, 0, -1, -1, 0}, DECIMAL(1, 0))},
-      "floor(c0)",
-      {makeFlatVector<int128_t>(
-          {1234567890123456789,
-           5000000000000000000,
-           -9000000000000000000,
-           -1000000000000000000,
-           0},
-          DECIMAL(19, 19))});
+  // Short DECIMAL(18,0) -> Short DECIMAL(18,0).
+  // Min and max are unchanged if there are no fractional digits.
+  {
+    const auto inType = DECIMAL(18, 0);
+    const auto outType = DECIMAL(18, 0);
+    auto testFloor = makeDecimalExprTester<int64_t, TypeKind::BIGINT>(
+        inType, outType, "floor(c0)");
+    auto testCeil = makeDecimalExprTester<int64_t, TypeKind::BIGINT>(
+        inType, outType, "ceil(c0)");
+    testFloor(DecimalUtil::kShortDecimalMax, DecimalUtil::kShortDecimalMax);
+    testFloor(DecimalUtil::kShortDecimalMin, DecimalUtil::kShortDecimalMin);
+    testCeil(DecimalUtil::kShortDecimalMax, DecimalUtil::kShortDecimalMax);
+    testCeil(DecimalUtil::kShortDecimalMin, DecimalUtil::kShortDecimalMin);
+  }
+
+  // Long DECIMAL(20,2) -> Long DECIMAL(19,0).
+  // e.g. floor(0.49) = 0, floor(-0.49) = -1, ceil(0.49) = 1, ceil(-0.49) = 0
+  {
+    const auto inType = DECIMAL(20, 2);
+    const auto outType = DECIMAL(19, 0);
+    auto testFloor = makeDecimalExprTester<int128_t, TypeKind::HUGEINT>(
+        inType, outType, "floor(c0)");
+    auto testCeil = makeDecimalExprTester<int128_t, TypeKind::HUGEINT>(
+        inType, outType, "ceil(c0)");
+    testFloor(0, 0);
+    testFloor(1, 0);
+    testFloor(-1, -1);
+    testFloor(49, 0);
+    testFloor(-49, -1);
+    testFloor(50, 0);
+    testFloor(-50, -1);
+    testFloor(99, 0);
+    testFloor(-99, -1);
+    testCeil(0, 0);
+    testCeil(1, 1);
+    testCeil(-1, 0);
+    testCeil(49, 1);
+    testCeil(-49, 0);
+    testCeil(50, 1);
+    testCeil(-50, 0);
+    testCeil(99, 1);
+    testCeil(-99, 0);
+  }
+
+  // Long DECIMAL(38,5) -> Long DECIMAL(34,0).
+  // Min and max are rounded to the nearest whole number within the range of the
+  // output type.
+  {
+    const auto inType = DECIMAL(38, 5);
+    const auto outType = DECIMAL(34, 0);
+    auto testFloor = makeDecimalExprTester<int128_t, TypeKind::HUGEINT>(
+        inType, outType, "floor(c0)");
+    auto testCeil = makeDecimalExprTester<int128_t, TypeKind::HUGEINT>(
+        inType, outType, "ceil(c0)");
+    testFloor(DecimalUtil::kLongDecimalMax, DecimalUtil::kPowersOfTen[33] - 1);
+    testFloor(DecimalUtil::kLongDecimalMin, -DecimalUtil::kPowersOfTen[33]);
+    testCeil(DecimalUtil::kLongDecimalMax, DecimalUtil::kPowersOfTen[33]);
+    testCeil(DecimalUtil::kLongDecimalMin, -DecimalUtil::kPowersOfTen[33] + 1);
+  }
+
+  // Long DECIMAL(38,0) -> Long DECIMAL(38,0).
+  // Min and max are unchanged if there are no fractional digits.
+  {
+    const auto inType = DECIMAL(38, 0);
+    const auto outType = DECIMAL(38, 0);
+    auto testFloor = makeDecimalExprTester<int128_t, TypeKind::HUGEINT>(
+        inType, outType, "floor(c0)");
+    auto testCeil = makeDecimalExprTester<int128_t, TypeKind::HUGEINT>(
+        inType, outType, "ceil(c0)");
+    testFloor(DecimalUtil::kLongDecimalMax, DecimalUtil::kLongDecimalMax);
+    testFloor(DecimalUtil::kLongDecimalMin, DecimalUtil::kLongDecimalMin);
+    testCeil(DecimalUtil::kLongDecimalMax, DecimalUtil::kLongDecimalMax);
+    testCeil(DecimalUtil::kLongDecimalMin, DecimalUtil::kLongDecimalMin);
+  }
+
+  // Long DECIMAL(19,19) -> Short DECIMAL(1,0).
+  // e.g. floor(0.1234567890123456789) = 0, ceil(0.1234567890123456789) = 1
+  {
+    const auto inType = DECIMAL(19, 19);
+    const auto outType = DECIMAL(1, 0);
+    auto testFloor = makeDecimalExprTester<int128_t, TypeKind::BIGINT>(
+        inType, outType, "floor(c0)");
+    auto testCeil = makeDecimalExprTester<int128_t, TypeKind::BIGINT>(
+        inType, outType, "ceil(c0)");
+    testFloor(int128_t{1234567890123456789}, 0);
+    testFloor(int128_t{5000000000000000000}, 0);
+    testFloor(int128_t{-9000000000000000000}, -1);
+    testFloor(int128_t{-1000000000000000000}, -1);
+    testFloor(int128_t{0}, 0);
+    testCeil(int128_t{1234567890123456789}, 1);
+    testCeil(int128_t{5000000000000000000}, 1);
+    testCeil(int128_t{-9000000000000000000}, 0);
+    testCeil(int128_t{-1000000000000000000}, 0);
+    testCeil(int128_t{0}, 0);
+  }
 }
 
 TEST_F(DecimalArithmeticTest, truncate) {
diff --git a/velox/functions/prestosql/tests/DistanceFunctionsTest.cpp b/velox/functions/prestosql/tests/DistanceFunctionsTest.cpp
index 7a0548737e5..ad793285641 100644
--- a/velox/functions/prestosql/tests/DistanceFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/DistanceFunctionsTest.cpp
@@ -84,10 +84,11 @@ TEST_F(DistanceFunctionsTest, cosineSimilarity) {
   auto rightMap =
       makeMapVector<StringView, double>({{{{"c"_sv, 1}, {"b"_sv, 3}}}});
 
-  EXPECT_FALSE(evaluateOnce<double>(
-                   "cosine_similarity(c0,c1)",
-                   makeRowVector({nullableLeftMap, rightMap}))
-                   .has_value());
+  EXPECT_FALSE(
+      evaluateOnce<double>(
+          "cosine_similarity(c0,c1)",
+          makeRowVector({nullableLeftMap, rightMap}))
+          .has_value());
 }
 
 TEST_F(DistanceFunctionsTest, cosineSimilarityArray) {
diff --git a/velox/functions/prestosql/tests/DotProductFuzzerTest.cpp b/velox/functions/prestosql/tests/DotProductFuzzerTest.cpp
new file mode 100644
index 00000000000..1df29eec844
--- /dev/null
+++ b/velox/functions/prestosql/tests/DotProductFuzzerTest.cpp
@@ -0,0 +1,352 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cstdint>
+#include <vector>
+
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class DotProductFuzzerTest : public test::FunctionBaseTest {
+ protected:
+  // The equivalent SQL expression for dot_product using existing UDFs.
+  // dot_product(array1, array2) is equivalent to:
+  // reduce(zip_with(c0, c1, (x, y) -> coalesce(x, 0) * coalesce(y, 0)),
+  //        CAST(0 AS BIGINT), (s, x) -> s + x, s -> s)
+  //
+  // Note: This only works for integer arrays where the result is BIGINT.
+  static constexpr const char* kEquivalentExpressionBigint =
+      "reduce(zip_with(c0, c1, (x, y) -> coalesce(CAST(x AS BIGINT), CAST(0 AS BIGINT)) * coalesce(CAST(y AS BIGINT), CAST(0 AS BIGINT))), "
+      "CAST(0 AS BIGINT), (s, x) -> s + x, s -> s)";
+
+  static constexpr const char* kEquivalentExpressionDouble =
+      "reduce(zip_with(c0, c1, (x, y) -> coalesce(CAST(x AS DOUBLE), CAST(0.0 AS DOUBLE)) * coalesce(CAST(y AS DOUBLE), CAST(0.0 AS DOUBLE))), "
+      "CAST(0.0 AS DOUBLE), (s, x) -> s + x, s -> s)";
+
+  // Get a SelectivityVector that excludes rows where either input is null.
+  static SelectivityVector getNonNullRows(const RowVectorPtr& data) {
+    auto array1 = data->childAt(0);
+    auto array2 = data->childAt(1);
+    SelectivityVector nonNullRows(data->size());
+
+    for (vector_size_t i = 0; i < data->size(); ++i) {
+      if (array1->isNullAt(i) || array2->isNullAt(i)) {
+        nonNullRows.setValid(i, false);
+      }
+    }
+    nonNullRows.updateBounds();
+    return nonNullRows;
+  }
+
+  // Check if two arrays have the same length at a given row.
+  static bool haveSameLength(
+      const VectorPtr& array1,
+      const VectorPtr& array2,
+      vector_size_t row) {
+    auto arr1 = array1->as<ArrayVector>();
+    auto arr2 = array2->as<ArrayVector>();
+    if (!arr1 || !arr2) {
+      return false;
+    }
+    return arr1->sizeAt(row) == arr2->sizeAt(row);
+  }
+
+  // Test that dot_product result is non-null when inputs are valid
+  // (same length, non-null).
+  void testDotProductProperties(const RowVectorPtr& data) {
+    auto nonNullRows = getNonNullRows(data);
+    if (nonNullRows.countSelected() == 0) {
+      return;
+    }
+
+    VectorPtr result;
+    try {
+      result = evaluate("try(dot_product(c0, c1))", data);
+    } catch (...) {
+      return;
+    }
+
+    if (!result) {
+      return;
+    }
+
+    auto array1 = data->childAt(0);
+    auto array2 = data->childAt(1);
+
+    for (auto i = 0; i < data->size(); ++i) {
+      if (!nonNullRows.isValid(i)) {
+        continue;
+      }
+
+      // If arrays have same length, result should be non-null
+      if (haveSameLength(array1, array2, i)) {
+        // Result can still be null if try() caught an overflow error
+        // so we don't assert non-null here
+      }
+    }
+  }
+
+  // Test equivalence between dot_product and the reduce+zip_with expression
+  // for integer arrays.
+  void testEquivalenceBigint(const RowVectorPtr& data) {
+    auto nonNullRows = getNonNullRows(data);
+    if (nonNullRows.countSelected() == 0) {
+      return;
+    }
+
+    VectorPtr result;
+    VectorPtr expected;
+    try {
+      result = evaluate("try(dot_product(c0, c1))", data);
+      expected =
+          evaluate(fmt::format("try({})", kEquivalentExpressionBigint), data);
+    } catch (...) {
+      return;
+    }
+
+    if (!result || !expected) {
+      return;
+    }
+
+    auto array1 = data->childAt(0);
+    auto array2 = data->childAt(1);
+
+    for (auto i = 0; i < data->size(); ++i) {
+      if (!nonNullRows.isValid(i)) {
+        continue;
+      }
+      // Only compare when arrays have the same length
+      if (haveSameLength(array1, array2, i)) {
+        // Both should be null or both should have same value
+        if (!result->isNullAt(i) && !expected->isNullAt(i)) {
+          ASSERT_TRUE(expected->equalValueAt(result.get(), i, i))
+              << "Mismatch at row " << i << ": expected "
+              << expected->toString(i) << ", got " << result->toString(i);
+        }
+      }
+    }
+  }
+
+  // Test equivalence for double arrays.
+  void testEquivalenceDouble(const RowVectorPtr& data) {
+    auto nonNullRows = getNonNullRows(data);
+    if (nonNullRows.countSelected() == 0) {
+      return;
+    }
+
+    VectorPtr result;
+    VectorPtr expected;
+    try {
+      result = evaluate("try(dot_product(c0, c1))", data);
+      expected =
+          evaluate(fmt::format("try({})", kEquivalentExpressionDouble), data);
+    } catch (...) {
+      return;
+    }
+
+    if (!result || !expected) {
+      return;
+    }
+
+    auto array1 = data->childAt(0);
+    auto array2 = data->childAt(1);
+
+    for (auto i = 0; i < data->size(); ++i) {
+      if (!nonNullRows.isValid(i)) {
+        continue;
+      }
+      if (haveSameLength(array1, array2, i)) {
+        if (!result->isNullAt(i) && !expected->isNullAt(i)) {
+          ASSERT_TRUE(expected->equalValueAt(result.get(), i, i))
+              << "Mismatch at row " << i << ": expected "
+              << expected->toString(i) << ", got " << result->toString(i);
+        }
+      }
+    }
+  }
+
+  // Helper to create fuzzer options with common settings.
+  VectorFuzzer::Options createFuzzerOptions(
+      vector_size_t vectorSize = 100,
+      double nullRatio = 0.1,
+      size_t containerLength = 10) {
+    VectorFuzzer::Options opts;
+    opts.vectorSize = vectorSize;
+    opts.nullRatio = nullRatio;
+    opts.containerLength = containerLength;
+    opts.containerVariableLength = true;
+    opts.containerHasNulls = true;
+    return opts;
+  }
+
+  // Helper to run fuzzer test with given type.
+  template <typename T>
+  void runFuzzerTest(
+      const TypePtr& elementType,
+      const VectorFuzzer::Options& opts,
+      bool isFloatingPoint = false) {
+    VectorFuzzer fuzzer(opts, pool());
+
+    auto arrayType = ARRAY(elementType);
+    auto array1 = fuzzer.fuzz(arrayType);
+    auto array2 = fuzzer.fuzz(arrayType);
+    auto data = makeRowVector({array1, array2});
+
+    if (isFloatingPoint) {
+      testEquivalenceDouble(data);
+    } else {
+      testEquivalenceBigint(data);
+    }
+    testDotProductProperties(data);
+  }
+};
+
+TEST_F(DotProductFuzzerTest, fuzzInteger) {
+  auto opts = createFuzzerOptions();
+  runFuzzerTest<int32_t>(INTEGER(), opts);
+}
+
+TEST_F(DotProductFuzzerTest, fuzzBigint) {
+  auto opts = createFuzzerOptions();
+  runFuzzerTest<int64_t>(BIGINT(), opts);
+}
+
+TEST_F(DotProductFuzzerTest, fuzzSmallint) {
+  auto opts = createFuzzerOptions();
+  runFuzzerTest<int16_t>(SMALLINT(), opts);
+}
+
+TEST_F(DotProductFuzzerTest, fuzzTinyint) {
+  auto opts = createFuzzerOptions();
+  runFuzzerTest<int8_t>(TINYINT(), opts);
+}
+
+TEST_F(DotProductFuzzerTest, fuzzHighNullRatio) {
+  auto opts = createFuzzerOptions(100, 0.5, 10);
+  runFuzzerTest<int32_t>(INTEGER(), opts);
+}
+
+TEST_F(DotProductFuzzerTest, fuzzLargeVectors) {
+  auto opts = createFuzzerOptions(500, 0.1, 20);
+  runFuzzerTest<int32_t>(INTEGER(), opts);
+}
+
+TEST_F(DotProductFuzzerTest, fuzzSmallContainers) {
+  auto opts = createFuzzerOptions(100, 0.1, 3);
+  runFuzzerTest<int32_t>(INTEGER(), opts);
+}
+
+// Test with matching array lengths to ensure we test the actual dot product
+// computation more frequently.
+TEST_F(DotProductFuzzerTest, fuzzMatchingLengths) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 10;
+  opts.containerVariableLength = false; // Fixed length
+  opts.containerHasNulls = true;
+
+  VectorFuzzer fuzzer(opts, pool());
+
+  auto array1 = fuzzer.fuzz(ARRAY(INTEGER()));
+  auto array2 = fuzzer.fuzz(ARRAY(INTEGER()));
+  auto data = makeRowVector({array1, array2});
+
+  testEquivalenceBigint(data);
+  testDotProductProperties(data);
+}
+
+// Stress test with many iterations
+TEST_F(DotProductFuzzerTest, fuzzStressTest) {
+  constexpr int kIterations = 50;
+
+  for (int iter = 0; iter < kIterations; ++iter) {
+    VectorFuzzer::Options opts;
+    opts.vectorSize = 50;
+    opts.nullRatio = 0.1;
+    opts.containerLength = 8;
+    opts.containerVariableLength = true;
+    opts.containerHasNulls = true;
+
+    VectorFuzzer fuzzer(opts, pool());
+
+    auto array1 = fuzzer.fuzz(ARRAY(INTEGER()));
+    auto array2 = fuzzer.fuzz(ARRAY(INTEGER()));
+    auto data = makeRowVector({array1, array2});
+
+    testEquivalenceBigint(data);
+  }
+}
+
+// Test map dot product with fuzzer
+TEST_F(DotProductFuzzerTest, fuzzMapIntegerKeys) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 50;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 5;
+  opts.containerVariableLength = true;
+  opts.containerHasNulls = true;
+
+  VectorFuzzer fuzzer(opts, pool());
+
+  auto map1 = fuzzer.fuzz(MAP(INTEGER(), BIGINT()));
+  auto map2 = fuzzer.fuzz(MAP(INTEGER(), BIGINT()));
+  auto data = makeRowVector({map1, map2});
+
+  // Just verify it doesn't crash with random inputs
+  VectorPtr result;
+  try {
+    result = evaluate("try(dot_product(c0, c1))", data);
+    ASSERT_NE(result, nullptr);
+  } catch (const VeloxUserError&) {
+    // Expected for some edge cases
+  }
+}
+
+TEST_F(DotProductFuzzerTest, fuzzMapVarcharKeys) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 50;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 5;
+  opts.containerVariableLength = true;
+  opts.containerHasNulls = true;
+  opts.stringLength = 10;
+  opts.stringVariableLength = true;
+
+  VectorFuzzer fuzzer(opts, pool());
+
+  auto map1 = fuzzer.fuzz(MAP(VARCHAR(), DOUBLE()));
+  auto map2 = fuzzer.fuzz(MAP(VARCHAR(), DOUBLE()));
+  auto data = makeRowVector({map1, map2});
+
+  // Just verify it doesn't crash with random inputs
+  VectorPtr result;
+  try {
+    result = evaluate("try(dot_product(c0, c1))", data);
+    ASSERT_NE(result, nullptr);
+  } catch (const VeloxUserError&) {
+    // Expected for some edge cases
+  }
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/DotProductTest.cpp b/velox/functions/prestosql/tests/DotProductTest.cpp
new file mode 100644
index 00000000000..16cc8ebf63a
--- /dev/null
+++ b/velox/functions/prestosql/tests/DotProductTest.cpp
@@ -0,0 +1,344 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <optional>
+#include <vector>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/type/StringView.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class DotProductTest : public test::FunctionBaseTest {
+ protected:
+  template <typename T>
+  using expected_t = std::conditional_t<std::is_integral_v<T>, int64_t, double>;
+
+  template <typename T>
+  void testDotProduct(
+      const std::vector<std::vector<T>>& array1,
+      const std::vector<std::vector<T>>& array2,
+      const std::vector<std::optional<expected_t<T>>>& expected) {
+    auto inputArray1 = makeArrayVector<T>(array1);
+    auto inputArray2 = makeArrayVector<T>(array2);
+    auto result = evaluate(
+        "dot_product(c0, c1)", makeRowVector({inputArray1, inputArray2}));
+    auto expectedVector = makeNullableFlatVector<expected_t<T>>(expected);
+    assertEqualVectors(expectedVector, result);
+  }
+};
+
+TEST_F(DotProductTest, integerArrays) {
+  testDotProduct<int32_t>(
+      {{1, 2, 3}, {4, 5, 6}},
+      {{4, 5, 6}, {1, 2, 3}},
+      {32, 32}); // 1*4 + 2*5 + 3*6 = 32
+}
+
+TEST_F(DotProductTest, bigintArrays) {
+  testDotProduct<int64_t>(
+      {{1, 2, 3, 4, 5}},
+      {{5, 4, 3, 2, 1}},
+      {35}); // 1*5 + 2*4 + 3*3 + 4*2 + 5*1 = 35
+}
+
+TEST_F(DotProductTest, doubleArrays) {
+  testDotProduct<double>(
+      {{1.5, 2.5, 3.5}},
+      {{2.0, 3.0, 4.0}},
+      {24.5}); // 1.5*2 + 2.5*3 + 3.5*4 = 3 + 7.5 + 14 = 24.5
+}
+
+TEST_F(DotProductTest, emptyArrays) {
+  testDotProduct<int32_t>({{}}, {{}}, {0}); // Empty arrays should return 0
+}
+
+TEST_F(DotProductTest, singleElement) {
+  testDotProduct<int32_t>({{5}}, {{7}}, {35}); // 5*7 = 35
+}
+
+TEST_F(DotProductTest, negativeNumbers) {
+  testDotProduct<int32_t>(
+      {{-1, -2, -3}}, {{4, 5, 6}}, {-32}); // (-1)*4 + (-2)*5 + (-3)*6 = -32
+}
+
+TEST_F(DotProductTest, mixedSigns) {
+  testDotProduct<int32_t>(
+      {{1, -2, 3}},
+      {{-4, 5, -6}},
+      {-32}); // 1*(-4) + (-2)*5 + 3*(-6) = -4 - 10 - 18 = -32
+}
+
+TEST_F(DotProductTest, zeros) {
+  testDotProduct<int32_t>(
+      {{0, 0, 0}}, {{1, 2, 3}}, {0}); // All zeros in one array
+}
+
+TEST_F(DotProductTest, nullElementsInArrays) {
+  // Null elements should be treated as zero
+  auto array1 = makeNullableArrayVector<int32_t>({
+      {1, std::nullopt, 3},
+      {std::nullopt, 2, std::nullopt},
+  });
+  auto array2 = makeNullableArrayVector<int32_t>({
+      {4, 5, 6},
+      {1, 2, 3},
+  });
+
+  auto result =
+      evaluate("dot_product(c0, c1)", makeRowVector({array1, array2}));
+  // Row 0: 1*4 + 0*5 + 3*6 = 4 + 0 + 18 = 22
+  // Row 1: 0*1 + 2*2 + 0*3 = 0 + 4 + 0 = 4
+  auto expected = makeFlatVector<int64_t>({22, 4});
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(DotProductTest, nullArguments) {
+  // Test when either argument is null
+  auto array = makeArrayVector<int32_t>({{1, 2, 3}});
+  auto nullArray = BaseVector::createNullConstant(ARRAY(INTEGER()), 1, pool());
+
+  // Test null first array
+  auto result1 =
+      evaluate("dot_product(c0, c1)", makeRowVector({nullArray, array}));
+  auto expected1 = BaseVector::createNullConstant(BIGINT(), 1, pool());
+  assertEqualVectors(expected1, result1);
+
+  // Test null second array
+  auto result2 =
+      evaluate("dot_product(c0, c1)", makeRowVector({array, nullArray}));
+  auto expected2 = BaseVector::createNullConstant(BIGINT(), 1, pool());
+  assertEqualVectors(expected2, result2);
+}
+
+TEST_F(DotProductTest, mismatchedLengthsThrows) {
+  auto array1 = makeArrayVector<int32_t>({{1, 2, 3}});
+  auto array2 = makeArrayVector<int32_t>({{1, 2}}); // Different length
+
+  VELOX_ASSERT_THROW(
+      evaluate("dot_product(c0, c1)", makeRowVector({array1, array2})),
+      "dot_product requires arrays of equal length");
+}
+
+TEST_F(DotProductTest, largeArrays) {
+  // Test with larger arrays
+  std::vector<int32_t> arr1(100);
+  std::vector<int32_t> arr2(100);
+  int64_t expectedResult = 0;
+  for (int i = 0; i < 100; ++i) {
+    arr1[i] = i + 1;
+    arr2[i] = i + 1;
+    expectedResult += static_cast<int64_t>(i + 1) * (i + 1);
+  }
+  testDotProduct<int32_t>({arr1}, {arr2}, {expectedResult});
+}
+
+TEST_F(DotProductTest, int8Arrays) {
+  testDotProduct<int8_t>({{1, 2, 3}}, {{4, 5, 6}}, {32});
+}
+
+TEST_F(DotProductTest, int16Arrays) {
+  testDotProduct<int16_t>(
+      {{100, 200, 300}},
+      {{4, 5, 6}},
+      {3200}); // 100*4 + 200*5 + 300*6 = 400 + 1000 + 1800 = 3200
+}
+
+TEST_F(DotProductTest, integerOverflow) {
+  constexpr auto kMax = std::numeric_limits<int64_t>::max();
+  auto array1 = makeArrayVector<int64_t>({{kMax, 1}});
+  auto array2 = makeArrayVector<int64_t>({{2, 1}});
+
+  VELOX_ASSERT_THROW(
+      evaluate("dot_product(c0, c1)", makeRowVector({array1, array2})), "");
+}
+
+TEST_F(DotProductTest, integerOverflowOnSum) {
+  constexpr auto kMax = std::numeric_limits<int64_t>::max();
+  auto array1 = makeArrayVector<int64_t>({{kMax, 1}});
+  auto array2 = makeArrayVector<int64_t>({{1, 1}});
+
+  VELOX_ASSERT_THROW(
+      evaluate("dot_product(c0, c1)", makeRowVector({array1, array2})), "");
+}
+
+TEST_F(DotProductTest, int32Overflow) {
+  constexpr auto kMax = std::numeric_limits<int32_t>::max();
+  // int32 max * int32 max fits in int64, so this should succeed.
+  testDotProduct<int32_t>(
+      {{kMax}}, {{kMax}}, {static_cast<int64_t>(kMax) * kMax});
+}
+
+TEST_F(DotProductTest, doubleNaN) {
+  constexpr auto kNaN = std::numeric_limits<double>::quiet_NaN();
+
+  auto array1 = makeArrayVector<double>({{kNaN, 1.0}});
+  auto array2 = makeArrayVector<double>({{1.0, 2.0}});
+
+  auto result =
+      evaluate("dot_product(c0, c1)", makeRowVector({array1, array2}));
+  auto flatResult = result->as<SimpleVector<double>>();
+  ASSERT_TRUE(std::isnan(flatResult->valueAt(0)));
+}
+
+TEST_F(DotProductTest, doubleNaNBothArrays) {
+  constexpr auto kNaN = std::numeric_limits<double>::quiet_NaN();
+
+  auto array1 = makeArrayVector<double>({{kNaN}});
+  auto array2 = makeArrayVector<double>({{kNaN}});
+
+  auto result =
+      evaluate("dot_product(c0, c1)", makeRowVector({array1, array2}));
+  auto flatResult = result->as<SimpleVector<double>>();
+  ASSERT_TRUE(std::isnan(flatResult->valueAt(0)));
+}
+
+TEST_F(DotProductTest, doubleInfTimesZero) {
+  constexpr auto kInf = std::numeric_limits<double>::infinity();
+
+  auto array1 = makeArrayVector<double>({{kInf}});
+  auto array2 = makeArrayVector<double>({{0.0}});
+
+  // inf * 0 = NaN per IEEE 754.
+  auto result =
+      evaluate("dot_product(c0, c1)", makeRowVector({array1, array2}));
+  auto flatResult = result->as<SimpleVector<double>>();
+  ASSERT_TRUE(std::isnan(flatResult->valueAt(0)));
+}
+
+TEST_F(DotProductTest, doubleNegativeInfTimesNegativeZero) {
+  constexpr auto kNegInf = -std::numeric_limits<double>::infinity();
+
+  auto array1 = makeArrayVector<double>({{kNegInf}});
+  auto array2 = makeArrayVector<double>({{-0.0}});
+
+  // -inf * -0 = NaN per IEEE 754.
+  auto result =
+      evaluate("dot_product(c0, c1)", makeRowVector({array1, array2}));
+  auto flatResult = result->as<SimpleVector<double>>();
+  ASSERT_TRUE(std::isnan(flatResult->valueAt(0)));
+}
+
+TEST_F(DotProductTest, doubleInfTimesInf) {
+  constexpr auto kInf = std::numeric_limits<double>::infinity();
+
+  // inf * inf = inf.
+  testDotProduct<double>({{kInf}}, {{kInf}}, {kInf});
+
+  // inf * -inf = -inf.
+  testDotProduct<double>({{kInf}}, {{-kInf}}, {-kInf});
+}
+
+TEST_F(DotProductTest, doubleOverflow) {
+  constexpr auto kMax = std::numeric_limits<double>::max();
+  constexpr auto kInf = std::numeric_limits<double>::infinity();
+  // max + max = inf (overflow to infinity for doubles).
+  testDotProduct<double>({{kMax, kMax}}, {{1.0, 1.0}}, {kInf});
+}
+
+TEST_F(DotProductTest, mapIntegerKeys) {
+  auto map1 = makeMapVector<int32_t, int64_t>({
+      {{1, 10}, {2, 20}},
+      {{1, 5}, {3, 15}},
+  });
+  auto map2 = makeMapVector<int32_t, int64_t>({
+      {{1, 3}, {2, 4}},
+      {{1, 2}, {2, 4}},
+  });
+
+  auto result = evaluate("dot_product(c0, c1)", makeRowVector({map1, map2}));
+  // Row 0: 10*3 + 20*4 = 30 + 80 = 110
+  // Row 1: 5*2 = 10 (key 3 not in map2, key 2 not in map1)
+  auto expected = makeFlatVector<int64_t>({110, 10});
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(DotProductTest, mapVarcharKeys) {
+  auto map1 = makeMapVector<StringView, double>({
+      {{"a", 1.0}, {"b", 2.0}},
+      {{"x", 5.0}, {"y", 10.0}},
+  });
+  auto map2 = makeMapVector<StringView, double>({
+      {{"a", 3.0}, {"c", 4.0}},
+      {{"y", 2.0}, {"z", 3.0}},
+  });
+
+  auto result = evaluate("dot_product(c0, c1)", makeRowVector({map1, map2}));
+  // Row 0: 1.0*3.0 = 3.0 (only 'a' matches)
+  // Row 1: 10.0*2.0 = 20.0 (only 'y' matches)
+  auto expected = makeFlatVector<double>({3.0, 20.0});
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(DotProductTest, mapNoMatchingKeys) {
+  auto map1 = makeMapVector<int32_t, int64_t>({
+      {{1, 10}, {2, 20}},
+  });
+  auto map2 = makeMapVector<int32_t, int64_t>({
+      {{3, 30}, {4, 40}},
+  });
+
+  auto result = evaluate("dot_product(c0, c1)", makeRowVector({map1, map2}));
+  // No matching keys, result should be 0
+  auto expected = makeFlatVector<int64_t>({0});
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(DotProductTest, mapEmptyMaps) {
+  auto map1 = makeMapVector<int32_t, int64_t>({
+      {},
+  });
+  auto map2 = makeMapVector<int32_t, int64_t>({
+      {},
+  });
+
+  auto result = evaluate("dot_product(c0, c1)", makeRowVector({map1, map2}));
+  auto expected = makeFlatVector<int64_t>({0});
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(DotProductTest, mapNullValues) {
+  // Null values in maps should be treated as zero
+  auto map1 = makeNullableMapVector<int32_t, int64_t>({
+      {{{1, 10}, {2, std::nullopt}}},
+  });
+  auto map2 = makeNullableMapVector<int32_t, int64_t>({
+      {{{1, 3}, {2, 4}}},
+  });
+
+  auto result = evaluate("dot_product(c0, c1)", makeRowVector({map1, map2}));
+  // Key 1: 10*3 = 30, Key 2: null*4 = 0 (null treated as zero)
+  auto expected = makeFlatVector<int64_t>({30});
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(DotProductTest, multipleRows) {
+  testDotProduct<int32_t>(
+      {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}, {1, 1, 1}},
+      {{1, 2, 3}, {1, 2, 3}, {1, 2, 3}, {1, 1, 1}},
+      {1, 2, 3, 3}); // Unit vectors and all-ones
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/ElementAtTest.cpp b/velox/functions/prestosql/tests/ElementAtTest.cpp
index 80bfb844b2d..292995c0cd8 100644
--- a/velox/functions/prestosql/tests/ElementAtTest.cpp
+++ b/velox/functions/prestosql/tests/ElementAtTest.cpp
@@ -232,6 +232,248 @@ TEST_F(ElementAtTest, mapWithDictionaryKeys) {
   }
 }
 
+TEST_F(ElementAtTest, flatMapTest) {
+  // Null map.
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({std::nullopt}),
+      evaluate(
+          "element_at(c0, 1)",
+          makeRowVector(
+              {makeFlatMapVectorFromJson<int64_t, int32_t>({"null"})})));
+
+  // Empty map.
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({std::nullopt}),
+      evaluate(
+          "element_at(c0, 1)",
+          makeRowVector(
+              {makeFlatMapVectorFromJson<int64_t, int32_t>({"{}"})})));
+
+  // Single row.
+  test::assertEqualVectors(
+      makeFlatVector<int32_t>({10}),
+      evaluate(
+          "element_at(c0, 1)",
+          makeRowVector({makeFlatMapVectorFromJson<int64_t, int32_t>(
+              {"{1:10, 2:20, 4:40, 5:50, 6:60}"})})));
+
+  // Multiple rows.
+  auto input = makeFlatMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 4:40, 5:50}",
+      "{1:11, 4:41}",
+      "{}",
+      "{2:23, 4:43}",
+  });
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({10, 11, std::nullopt, std::nullopt}),
+      evaluate("element_at(c0, 1)", makeRowVector({input})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({40, 41, std::nullopt, 43}),
+      evaluate("element_at(c0, 4)", makeRowVector({input})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>(
+          {50, std::nullopt, std::nullopt, std::nullopt}),
+      evaluate("element_at(c0, 5)", makeRowVector({input})));
+  // Key doesn't exist
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>(
+          {std::nullopt, std::nullopt, std::nullopt, std::nullopt}),
+      evaluate("element_at(c0, 7)", makeRowVector({input})));
+  // Column elementAt
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({10, 11, std::nullopt, std::nullopt}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector({input, makeConstant<int32_t>(1, 4)})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({20, 11, std::nullopt, 43}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector({input, makeFlatVector<int32_t>({2, 1, 1, 4})})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({10, 11, std::nullopt, std::nullopt}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {input,
+               BaseVector::wrapInConstant(
+                   4, 0, makeFlatVector<int32_t>({1, 2, 3, 4}))})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({20, std::nullopt, std::nullopt, 23}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {input,
+               BaseVector::wrapInConstant(
+                   4, 1, makeFlatVector<int32_t>({1, 2, 3, 4}))})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>(
+          {std::nullopt, std::nullopt, std::nullopt, std::nullopt}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {input,
+               BaseVector::wrapInConstant(
+                   4, 2, makeFlatVector<int32_t>({1, 2, 3, 4}))})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({40, 41, std::nullopt, 43}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {input,
+               BaseVector::wrapInConstant(
+                   4, 3, makeFlatVector<int32_t>({1, 2, 3, 4}))})));
+}
+
+TEST_F(ElementAtTest, flatMapTestDictionaryWrapped) {
+  vector_size_t size = 4, halved = 2;
+
+  auto base = makeFlatMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 4:40, 5:50}",
+      "{1:11, 4:41}",
+      "{}",
+      "{2:23, 4:43}",
+  });
+
+  auto same = [](vector_size_t row) { return row; };
+  auto shifted = [](auto row) { return (row + 2) % 4; };
+
+  // Same size between base vector and wrapped dictionary vector.
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({10, 11, std::nullopt, std::nullopt}),
+      evaluate(
+          "element_at(c0, 1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(size, same), size, base)})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({std::nullopt, std::nullopt, 10, 11}),
+      evaluate(
+          "element_at(c0, 1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(size, shifted), size, base)})));
+
+  // Cardinality mismatch between wrapped vector and base.
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({10, 11}),
+      evaluate(
+          "element_at(c0, 1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(halved, same), halved, base)})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({std::nullopt, std::nullopt}),
+      evaluate(
+          "element_at(c0, 1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(halved, shifted), halved, base)})));
+
+  // Column elementAt
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({10, 11, std::nullopt, std::nullopt}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(size, same), size, base),
+               makeConstant<int32_t>(1, size)})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({10, std::nullopt, std::nullopt, 43}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(size, same), size, base),
+               makeFlatVector<int32_t>({1, 2, 3, 4})})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({std::nullopt, std::nullopt, 10, 11}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(size, shifted), size, base),
+               makeConstant<int32_t>(1, size)})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({std::nullopt, 23, std::nullopt, 41}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(size, shifted), size, base),
+               makeFlatVector<int32_t>({1, 2, 3, 4})})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({10, 11}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(halved, same), halved, base),
+               makeConstant<int32_t>(1, halved)})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({10, std::nullopt}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(halved, same), halved, base),
+               makeFlatVector<int32_t>({1, 2})})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({std::nullopt, std::nullopt}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(halved, shifted), halved, base),
+               makeConstant<int32_t>(1, halved)})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({std::nullopt, 23}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(halved, shifted), halved, base),
+               makeFlatVector<int32_t>({1, 2})})));
+}
+
+TEST_F(ElementAtTest, flatMapTestConstantWrapped) {
+  auto base = makeFlatMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 4:40, 5:50}",
+      "{1:11, 4:41}",
+      "{}",
+      "{2:23, 4:43}",
+  });
+  test::assertEqualVectors(
+      makeConstant<int32_t>(10, 10),
+      evaluate(
+          "element_at(c0, 1)",
+          makeRowVector({BaseVector::wrapInConstant(10, 0, base)})));
+  test::assertEqualVectors(
+      makeConstant<int32_t>(11, 10),
+      evaluate(
+          "element_at(c0, 1)",
+          makeRowVector({BaseVector::wrapInConstant(10, 1, base)})));
+  test::assertEqualVectors(
+      makeConstant<int32_t>(10, 10),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {BaseVector::wrapInConstant(10, 0, base),
+               makeConstant<int32_t>(1, 10)})));
+  test::assertEqualVectors(
+      makeConstant<int32_t>(10, 10),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {BaseVector::wrapInConstant(10, 0, base),
+               BaseVector::wrapInConstant(
+                   10, 0, makeFlatVector<int32_t>({1, 2}))})));
+  test::assertEqualVectors(
+      makeConstant<int32_t>(20, 10),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {BaseVector::wrapInConstant(10, 0, base),
+               BaseVector::wrapInConstant(
+                   10, 1, makeFlatVector<int32_t>({1, 2}))})));
+  test::assertEqualVectors(
+      makeFlatVector<int32_t>({10, 20}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {BaseVector::wrapInConstant(2, 0, base),
+               makeFlatVector<int32_t>({1, 2})})));
+}
+
 TEST_F(ElementAtTest, arrayWithDictionaryElements) {
   {
     auto elementsIndices = makeIndices({6, 5, 4, 3, 2, 1, 0});
@@ -295,33 +537,44 @@ TEST_F(ElementAtTest, constantInputArray) {
 // #2 - allow out of bounds access for array and map.
 // #3 - allow negative indices.
 TEST_F(ElementAtTest, allFlavors1) {
-  // Case 1: Simple arrays and maps
-  auto arrayVector = makeArrayVector<int64_t>({{10, 11, 12}});
-  auto mapVector = getSimpleMapVector();
-
-  // #1
-  VELOX_ASSERT_THROW(
-      elementAtSimple("element_at(C0, 0)", {arrayVector}),
-      "SQL array indices start at 1");
-
-  EXPECT_EQ(
-      elementAtSimple("try(element_at(C0, 0))", {arrayVector}), std::nullopt);
+  // Case 1: Simple arrays and maps (also test constant inputs)
+  auto simpleArray = makeArrayVector<int64_t>({{10, 11, 12}});
+  auto simpleMap = getSimpleMapVector();
+
+  for (bool wrapInConstant : {false, true}) {
+    auto arrayVector = wrapInConstant
+        ? BaseVector::wrapInConstant(1, 0, simpleArray)
+        : simpleArray;
+    auto mapVector = wrapInConstant
+        ? BaseVector::wrapInConstant(1, 0, simpleMap)
+        : simpleMap;
+    // #1
+    VELOX_ASSERT_THROW(
+        elementAtSimple("element_at(C0, 0)", {arrayVector}),
+        "SQL array indices start at 1. Got 0.");
 
-  EXPECT_EQ(elementAtSimple("element_at(C0, 1)", {arrayVector}), 10);
-  EXPECT_EQ(elementAtSimple("element_at(C0, 2)", {arrayVector}), 11);
-  EXPECT_EQ(elementAtSimple("element_at(C0, 3)", {arrayVector}), 12);
+    EXPECT_EQ(
+        elementAtSimple("try(element_at(C0, 0))", {arrayVector}), std::nullopt);
 
-  // #2
-  EXPECT_EQ(elementAtSimple("element_at(C0, 4)", {arrayVector}), std::nullopt);
-  EXPECT_EQ(elementAtSimple("element_at(C0, 5)", {arrayVector}), std::nullopt);
-  EXPECT_EQ(elementAtSimple("element_at(C0, 1001)", {mapVector}), std::nullopt);
+    EXPECT_EQ(elementAtSimple("element_at(C0, 1)", {arrayVector}), 10);
+    EXPECT_EQ(elementAtSimple("element_at(C0, 2)", {arrayVector}), 11);
+    EXPECT_EQ(elementAtSimple("element_at(C0, 3)", {arrayVector}), 12);
 
-  // #3
-  EXPECT_EQ(elementAtSimple("element_at(C0, -1)", {arrayVector}), 12);
-  EXPECT_EQ(elementAtSimple("element_at(C0, -2)", {arrayVector}), 11);
-  EXPECT_EQ(elementAtSimple("element_at(C0, -3)", {arrayVector}), 10);
-  EXPECT_EQ(elementAtSimple("element_at(C0, -4)", {arrayVector}), std::nullopt);
+    // #2
+    EXPECT_EQ(
+        elementAtSimple("element_at(C0, 4)", {arrayVector}), std::nullopt);
+    EXPECT_EQ(
+        elementAtSimple("element_at(C0, 5)", {arrayVector}), std::nullopt);
+    EXPECT_EQ(
+        elementAtSimple("element_at(C0, 1001)", {mapVector}), std::nullopt);
 
+    // #3
+    EXPECT_EQ(elementAtSimple("element_at(C0, -1)", {arrayVector}), 12);
+    EXPECT_EQ(elementAtSimple("element_at(C0, -2)", {arrayVector}), 11);
+    EXPECT_EQ(elementAtSimple("element_at(C0, -3)", {arrayVector}), 10);
+    EXPECT_EQ(
+        elementAtSimple("element_at(C0, -4)", {arrayVector}), std::nullopt);
+  }
   // Case 2: Empty values vector
   auto emptyValues = makeFlatVector<int64_t>({});
   auto emptyKeys = makeFlatVector<int64_t>(std::vector<int64_t>{1});
@@ -341,7 +594,7 @@ TEST_F(ElementAtTest, allFlavors1) {
   // #1
   VELOX_ASSERT_THROW(
       elementAtSimple("element_at(C0, 0)", {emptyValuesArray}),
-      "SQL array indices start at 1");
+      "SQL array indices start at 1. Got 0.");
 
   // #2
   EXPECT_EQ(
@@ -371,7 +624,7 @@ TEST_F(ElementAtTest, allFlavors1) {
   // #1
   VELOX_ASSERT_THROW(
       elementAtSimple("element_at(C0, 0)", {emptyContainerNonEmptyValuesArray}),
-      "SQL array indices start at 1");
+      "SQL array indices start at 1. Got 0.");
 
   // #2
   EXPECT_EQ(
@@ -418,7 +671,7 @@ TEST_F(ElementAtTest, allFlavors1) {
           makeRowVector({partiallyEmptyArray}),
           rows,
           result),
-      "SQL array indices start at 1");
+      "SQL array indices start at 1. Got 0.");
 
   // #2
   auto expected = makeNullConstant(TypeKind::BIGINT, 1);
@@ -441,42 +694,52 @@ TEST_F(ElementAtTest, allFlavors1) {
 // #2 - do not allow out of bounds access for arrays.
 // #3 - do not allow negative indices.
 TEST_F(ElementAtTest, allFlavors2) {
-  // Case 1: Simple arrays and maps
-  auto arrayVector = makeArrayVector<int64_t>({{10, 11, 12}});
-  auto mapVector = getSimpleMapVector();
-
-  // #1
-  VELOX_ASSERT_THROW(
-      elementAtSimple("C0[0]", {arrayVector}), "SQL array indices start at 1");
-
-  EXPECT_EQ(elementAtSimple("try(C0[0])", {arrayVector}), std::nullopt);
-
-  EXPECT_EQ(elementAtSimple("C0[1]", {arrayVector}), 10);
-  EXPECT_EQ(elementAtSimple("C0[2]", {arrayVector}), 11);
-  EXPECT_EQ(elementAtSimple("C0[3]", {arrayVector}), 12);
-
-  // #2
-  VELOX_ASSERT_THROW(
-      elementAtSimple("C0[4]", {arrayVector}),
-      "Array subscript out of bounds.");
-  VELOX_ASSERT_THROW(
-      elementAtSimple("C0[5]", {arrayVector}),
-      "Array subscript out of bounds.");
-
-  EXPECT_EQ(elementAtSimple("try(C0[4])", {arrayVector}), std::nullopt);
-  EXPECT_EQ(elementAtSimple("try(C0[5])", {arrayVector}), std::nullopt);
-
-  // Maps are ok.
-  EXPECT_EQ(elementAtSimple("C0[1001]", {mapVector}), std::nullopt);
-
-  // #3
-  VELOX_ASSERT_THROW(
-      elementAtSimple("C0[-1]", {arrayVector}), "Array subscript is negative.");
-  VELOX_ASSERT_THROW(
-      elementAtSimple("C0[-4]", {arrayVector}), "Array subscript is negative.");
-
-  EXPECT_EQ(elementAtSimple("try(C0[-1])", {arrayVector}), std::nullopt);
-  EXPECT_EQ(elementAtSimple("try(C0[-4])", {arrayVector}), std::nullopt);
+  // Case 1: Simple arrays and maps (also test constant inputs)
+  auto simpleArray = makeArrayVector<int64_t>({{10, 11, 12}});
+  auto simpleMap = getSimpleMapVector();
+  for (bool wrapInConstant : {false, true}) {
+    auto arrayVector = wrapInConstant
+        ? BaseVector::wrapInConstant(1, 0, simpleArray)
+        : simpleArray;
+    auto mapVector = wrapInConstant
+        ? BaseVector::wrapInConstant(1, 0, simpleMap)
+        : simpleMap;
+    // #1
+    VELOX_ASSERT_THROW(
+        elementAtSimple("C0[0]", {arrayVector}),
+        "SQL array indices start at 1. Got 0.");
+
+    EXPECT_EQ(elementAtSimple("try(C0[0])", {arrayVector}), std::nullopt);
+
+    EXPECT_EQ(elementAtSimple("C0[1]", {arrayVector}), 10);
+    EXPECT_EQ(elementAtSimple("C0[2]", {arrayVector}), 11);
+    EXPECT_EQ(elementAtSimple("C0[3]", {arrayVector}), 12);
+
+    // #2
+    VELOX_ASSERT_THROW(
+        elementAtSimple("C0[4]", {arrayVector}),
+        "Array subscript index out of bounds, Index: 4 Array size: 3");
+    VELOX_ASSERT_THROW(
+        elementAtSimple("C0[5]", {arrayVector}),
+        "Array subscript index out of bounds, Index: 5 Array size: 3");
+
+    EXPECT_EQ(elementAtSimple("try(C0[4])", {arrayVector}), std::nullopt);
+    EXPECT_EQ(elementAtSimple("try(C0[5])", {arrayVector}), std::nullopt);
+
+    // Maps are ok.
+    EXPECT_EQ(elementAtSimple("C0[1001]", {mapVector}), std::nullopt);
+
+    // #3
+    VELOX_ASSERT_THROW(
+        elementAtSimple("C0[-1]", {arrayVector}),
+        "Array subscript index cannot be negative, Index: -1");
+    VELOX_ASSERT_THROW(
+        elementAtSimple("C0[-4]", {arrayVector}),
+        "Array subscript index cannot be negative, Index: -4");
+
+    EXPECT_EQ(elementAtSimple("try(C0[-1])", {arrayVector}), std::nullopt);
+    EXPECT_EQ(elementAtSimple("try(C0[-4])", {arrayVector}), std::nullopt);
+  }
 
   // Case 2: Empty values vector
   auto emptyValues = makeFlatVector<int64_t>({});
@@ -497,19 +760,20 @@ TEST_F(ElementAtTest, allFlavors2) {
   // #1
   VELOX_ASSERT_THROW(
       elementAtSimple("C0[0]", {emptyValuesArray}),
-      "SQL array indices start at 1");
+      "SQL array indices start at 1. Got 0.");
 
   // #2
   VELOX_ASSERT_THROW(
-      elementAtSimple("C0[4]", {arrayVector}),
-      "Array subscript out of bounds.");
+      elementAtSimple("C0[4]", {emptyValuesArray}),
+      "Array subscript index out of bounds, Index: 4 Array size: 0");
   EXPECT_EQ(elementAtSimple("try(C0[4])", {emptyValuesArray}), std::nullopt);
   // Maps are ok.
   EXPECT_EQ(elementAtSimple("C0[1001]", {emptyValuesMap}), std::nullopt);
 
   // #3
   VELOX_ASSERT_THROW(
-      elementAtSimple("C0[-1]", {arrayVector}), "Array subscript is negative.");
+      elementAtSimple("C0[-1]", {emptyValuesArray}),
+      "Array subscript index cannot be negative, Index: -1");
 
   // Case 3: Empty individual arrays/maps and non-empty values vector
   auto nonEmptyValues = makeFlatVector<int64_t>(std::vector<int64_t>{2});
@@ -529,12 +793,12 @@ TEST_F(ElementAtTest, allFlavors2) {
   // #1
   VELOX_ASSERT_THROW(
       elementAtSimple("C0[0]", {emptyContainerNonEmptyValuesArray}),
-      "SQL array indices start at 1");
+      "SQL array indices start at 1. Got 0.");
 
   // #2
   VELOX_ASSERT_THROW(
       elementAtSimple("C0[4]", {emptyContainerNonEmptyValuesArray}),
-      "Array subscript out of bounds.");
+      "Array subscript index out of bounds, Index: 4 Array size: 0");
   EXPECT_EQ(
       elementAtSimple("try(C0[4])", {emptyContainerNonEmptyValuesArray}),
       std::nullopt);
@@ -546,7 +810,7 @@ TEST_F(ElementAtTest, allFlavors2) {
   // #3
   VELOX_ASSERT_THROW(
       elementAtSimple("C0[-1]", {emptyContainerNonEmptyValuesArray}),
-      "Array subscript is negative.");
+      "Array subscript index cannot be negative, Index: -1");
 
   // Case 4: Intermittently empty individual arrays/maps and non-empty values
   // vector
@@ -576,13 +840,13 @@ TEST_F(ElementAtTest, allFlavors2) {
   VELOX_ASSERT_THROW(
       evaluate<SimpleVector<int64_t>>(
           "C0[0]", makeRowVector({partiallyEmptyArray}), rows, result),
-      "SQL array indices start at 1");
+      "SQL array indices start at 1. Got 0.");
 
   // #2
   VELOX_ASSERT_THROW(
       evaluate<SimpleVector<int64_t>>(
           "C0[4]", makeRowVector({partiallyEmptyArray}), rows, result),
-      "Array subscript out of bounds.");
+      "Array subscript index out of bounds, Index: 4 Array size: 0");
   auto expected = makeNullConstant(TypeKind::BIGINT, 1);
   evaluate<SimpleVector<int64_t>>(
       "try(C0[4])", makeRowVector({partiallyEmptyArray}), rows, result);
@@ -596,7 +860,7 @@ TEST_F(ElementAtTest, allFlavors2) {
   VELOX_ASSERT_THROW(
       evaluate<SimpleVector<int64_t>>(
           "C0[-1]", makeRowVector({partiallyEmptyArray}), rows, result),
-      "Array subscript is negative.");
+      "Array subscript index cannot be negative, Index: -1");
 }
 
 // Third flavor:
@@ -604,41 +868,49 @@ TEST_F(ElementAtTest, allFlavors2) {
 // #2 - do not allow out of bound access for arrays (throw).
 // #3 - null on negative indices.
 TEST_F(ElementAtTest, allFlavors3) {
-  auto arrayVector = makeArrayVector<int64_t>({{10, 11, 12}});
-  auto mapVector = getSimpleMapVector();
+  auto simpleArray = makeArrayVector<int64_t>({{10, 11, 12}});
+  auto simpleMap = getSimpleMapVector();
 
   exec::registerVectorFunction(
       "__f2",
       SubscriptImpl<false, true, false, false>::signatures(),
       std::make_unique<SubscriptImpl<false, true, false, false>>(false));
+  for (bool wrapInConstant : {false, true}) {
+    auto arrayVector = wrapInConstant
+        ? BaseVector::wrapInConstant(1, 0, simpleArray)
+        : simpleArray;
+    auto mapVector = wrapInConstant
+        ? BaseVector::wrapInConstant(1, 0, simpleMap)
+        : simpleMap;
+    // #1
+    EXPECT_EQ(elementAtSimple("__f2(C0, 0)", {arrayVector}), 10);
+    EXPECT_EQ(elementAtSimple("__f2(C0, 1)", {arrayVector}), 11);
+    EXPECT_EQ(elementAtSimple("__f2(C0, 2)", {arrayVector}), 12);
+
+    // #2
+    VELOX_ASSERT_THROW(
+        elementAtSimple("__f2(C0, 3)", {arrayVector}),
+        "Array subscript index out of bounds, Index: 3 Array size: 3");
+    VELOX_ASSERT_THROW(
+        elementAtSimple("__f2(C0, 4)", {arrayVector}),
+        "Array subscript index out of bounds, Index: 4 Array size: 3");
+    VELOX_ASSERT_THROW(
+        elementAtSimple("__f2(C0, 100)", {arrayVector}),
+        "Array subscript index out of bounds, Index: 100 Array size: 3");
+
+    EXPECT_EQ(elementAtSimple("try(__f2(C0, 3))", {arrayVector}), std::nullopt);
+    EXPECT_EQ(elementAtSimple("try(__f2(C0, 4))", {arrayVector}), std::nullopt);
+    EXPECT_EQ(
+        elementAtSimple("try(__f2(C0, 100))", {arrayVector}), std::nullopt);
 
-  // #1
-  EXPECT_EQ(elementAtSimple("__f2(C0, 0)", {arrayVector}), 10);
-  EXPECT_EQ(elementAtSimple("__f2(C0, 1)", {arrayVector}), 11);
-  EXPECT_EQ(elementAtSimple("__f2(C0, 2)", {arrayVector}), 12);
-
-  // #2
-  VELOX_ASSERT_THROW(
-      elementAtSimple("__f2(C0, 3)", {arrayVector}),
-      "Array subscript out of bounds.");
-  VELOX_ASSERT_THROW(
-      elementAtSimple("__f2(C0, 4)", {arrayVector}),
-      "Array subscript out of bounds.");
-  VELOX_ASSERT_THROW(
-      elementAtSimple("__f2(C0, 100)", {arrayVector}),
-      "Array subscript out of bounds.");
-
-  EXPECT_EQ(elementAtSimple("try(__f2(C0, 3))", {arrayVector}), std::nullopt);
-  EXPECT_EQ(elementAtSimple("try(__f2(C0, 4))", {arrayVector}), std::nullopt);
-  EXPECT_EQ(elementAtSimple("try(__f2(C0, 100))", {arrayVector}), std::nullopt);
-
-  // We still allow non-existent map keys, even if out of bounds is disabled for
-  // arrays.
-  EXPECT_EQ(elementAtSimple("__f2(C0, 1001)", {mapVector}), std::nullopt);
+    // We still allow non-existent map keys, even if out of bounds is disabled
+    // for arrays.
+    EXPECT_EQ(elementAtSimple("__f2(C0, 1001)", {mapVector}), std::nullopt);
 
-  // #3
-  EXPECT_EQ(elementAtSimple("__f2(C0, -1)", {mapVector}), std::nullopt);
-  EXPECT_EQ(elementAtSimple("__f2(C0, -5)", {mapVector}), std::nullopt);
+    // #3
+    EXPECT_EQ(elementAtSimple("__f2(C0, -1)", {mapVector}), std::nullopt);
+    EXPECT_EQ(elementAtSimple("__f2(C0, -5)", {mapVector}), std::nullopt);
+  }
 }
 
 // Fourth flavor:
@@ -646,25 +918,32 @@ TEST_F(ElementAtTest, allFlavors3) {
 // #2 - allow out of bound access (throw).
 // #3 - allow negative indices.
 TEST_F(ElementAtTest, allFlavors4) {
-  auto arrayVector = makeArrayVector<int64_t>({{10, 11, 12}});
-  auto mapVector = getSimpleMapVector();
+  auto simpleArray = makeArrayVector<int64_t>({{10, 11, 12}});
+  auto simpleMap = getSimpleMapVector();
 
   exec::registerVectorFunction(
       "__f3",
       SubscriptImpl<true, false, true, false>::signatures(),
       std::make_unique<SubscriptImpl<true, false, true, false>>(false));
-
-  EXPECT_EQ(elementAtSimple("__f3(C0, 0)", {arrayVector}), 10);
-  EXPECT_EQ(elementAtSimple("__f3(C0, 1)", {arrayVector}), 11);
-  EXPECT_EQ(elementAtSimple("__f3(C0, 2)", {arrayVector}), 12);
-  EXPECT_EQ(elementAtSimple("__f3(C0, 3)", {arrayVector}), std::nullopt);
-  EXPECT_EQ(elementAtSimple("__f3(C0, 4)", {arrayVector}), std::nullopt);
-  EXPECT_EQ(elementAtSimple("__f3(C0, -1)", {arrayVector}), 12);
-  EXPECT_EQ(elementAtSimple("__f3(C0, -2)", {arrayVector}), 11);
-  EXPECT_EQ(elementAtSimple("__f3(C0, -3)", {arrayVector}), 10);
-  EXPECT_EQ(elementAtSimple("__f3(C0, -4)", {arrayVector}), std::nullopt);
-
-  EXPECT_EQ(elementAtSimple("__f3(C0, 1001)", {mapVector}), std::nullopt);
+  for (bool wrapInConstant : {false, true}) {
+    auto arrayVector = wrapInConstant
+        ? BaseVector::wrapInConstant(1, 0, simpleArray)
+        : simpleArray;
+    auto mapVector = wrapInConstant
+        ? BaseVector::wrapInConstant(1, 0, simpleMap)
+        : simpleMap;
+    EXPECT_EQ(elementAtSimple("__f3(C0, 0)", {arrayVector}), 10);
+    EXPECT_EQ(elementAtSimple("__f3(C0, 1)", {arrayVector}), 11);
+    EXPECT_EQ(elementAtSimple("__f3(C0, 2)", {arrayVector}), 12);
+    EXPECT_EQ(elementAtSimple("__f3(C0, 3)", {arrayVector}), std::nullopt);
+    EXPECT_EQ(elementAtSimple("__f3(C0, 4)", {arrayVector}), std::nullopt);
+    EXPECT_EQ(elementAtSimple("__f3(C0, -1)", {arrayVector}), 12);
+    EXPECT_EQ(elementAtSimple("__f3(C0, -2)", {arrayVector}), 11);
+    EXPECT_EQ(elementAtSimple("__f3(C0, -3)", {arrayVector}), 10);
+    EXPECT_EQ(elementAtSimple("__f3(C0, -4)", {arrayVector}), std::nullopt);
+
+    EXPECT_EQ(elementAtSimple("__f3(C0, 1001)", {mapVector}), std::nullopt);
+  }
 }
 
 TEST_F(ElementAtTest, constantInputMap) {
@@ -1023,7 +1302,7 @@ TEST_F(ElementAtTest, errorStatesArray) {
   VELOX_ASSERT_THROW(
       testElementAt<int64_t>(
           "element_at(C0, C1)", {arrayVector, indicesVector}, expectedValueAt),
-      "SQL array indices start at 1");
+      "SQL array indices start at 1. Got 0.");
 
   testElementAt<int64_t>(
       "try(element_at(C0, C1))",
@@ -1288,8 +1567,9 @@ TEST_F(ElementAtTest, testCachingOptimizationComplexKey) {
     for (int i = 0; i < keysVector->size(); i += 3) {
       EXPECT_NE(
           cachedMap.end(),
-          cachedMap.find(facebook::velox::functions::detail::MapKey{
-              keysVector.get(), 0, 0}));
+          cachedMap.find(
+              facebook::velox::functions::detail::MapKey{
+                  keysVector.get(), 0, 0}));
     }
   };
 
diff --git a/velox/functions/prestosql/tests/GeometryFunctionsTest.cpp b/velox/functions/prestosql/tests/GeometryFunctionsTest.cpp
index 54725d1cf0c..d9a40a497c4 100644
--- a/velox/functions/prestosql/tests/GeometryFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/GeometryFunctionsTest.cpp
@@ -17,13 +17,14 @@
 #include <gtest/gtest.h>
 #include <array>
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/geospatial/GeometryConstants.h"
 #include "velox/common/testutil/OptionalEmpty.h"
-#include "velox/dwio/common/tests/utils/DataFiles.h"
+#include "velox/functions/prestosql/tests/resources/GeometryTestUtils.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
-#include "velox/functions/prestosql/types/BingTileType.h"
 
 using facebook::velox::functions::test::FunctionBaseTest;
 using namespace facebook::velox;
+using namespace facebook::velox::common::geospatial;
 
 class GeometryFunctionsTest : public FunctionBaseTest {
  public:
@@ -109,6 +110,33 @@ class GeometryFunctionsTest : public FunctionBaseTest {
     auto vec = makeNullableFlatVector<std::string>({input});
     return makeRowVector({vec});
   }
+
+  bool aboutEquals(double a, double b) {
+    double diff = std::abs(a - b);
+    double scale = std::max(std::abs(a), std::abs(b));
+    return diff <= std::max(1e-5, 1e-5 * scale);
+  }
+
+  // Generic helper for testing geometry functions that return a result of type
+  // T. Builds the expression as funcName(ST_GeometryFromText(c0)), or
+  // ST_AsText(funcName(ST_GeometryFromText(c0))) when wrapWithAsText is true.
+  template <typename T>
+  void assertResult(
+      const std::string& funcName,
+      const std::optional<std::string>& wkt,
+      const std::optional<T>& expected,
+      bool wrapWithAsText = false) {
+    std::string expr = wrapWithAsText
+        ? "ST_AsText(" + funcName + "(ST_GeometryFromText(c0)))"
+        : funcName + "(ST_GeometryFromText(c0))";
+    std::optional<T> result = evaluateOnce<T>(expr, wkt);
+    if (expected.has_value()) {
+      ASSERT_TRUE(result.has_value());
+      ASSERT_EQ(result.value(), expected.value());
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  }
 };
 
 TEST_F(GeometryFunctionsTest, errorStGeometryFromTextAndParsing) {
@@ -212,6 +240,11 @@ TEST_F(GeometryFunctionsTest, wktAndWkb) {
         "to_hex(ST_AsBinary(ST_GeomFromBinary(from_hex(c0))))", wkt);
   };
 
+  const auto wktRoundTripSpherical = [&](const std::optional<std::string>& a) {
+    return evaluateOnce<std::string>(
+        "ST_AsText(to_spherical_geography(ST_GeometryFromText(c0)))", a);
+  };
+
   const std::vector<std::string> wkts = {
       "POINT (1 2)",
       "LINESTRING (0 0, 10 10)",
@@ -244,6 +277,7 @@ TEST_F(GeometryFunctionsTest, wktAndWkb) {
   for (size_t i = 0; i < wkts.size(); i++) {
     assert(i < wkbs.size() && i < bigEndianWkbs.size());
     EXPECT_EQ(wkts[i], wktRoundTrip(wkts[i]));
+    EXPECT_EQ(wkts[i], wktRoundTripSpherical(wkts[i]));
     EXPECT_EQ(wkbs[i], wktToWkb(wkts[i]));
     EXPECT_EQ(wkts[i], wkbToWkT(wkbs[i]));
     EXPECT_EQ(wkbs[i], wkbRoundTrip(wkbs[i]));
@@ -273,10 +307,14 @@ TEST_F(GeometryFunctionsTest, wktAndWkb) {
   for (size_t i = 0; i < emptyGeometryWkts.size(); i++) {
     assert(i < emptyGeometryWkbs.size());
     EXPECT_EQ(wktRoundTrip(emptyGeometryWkts[i]), emptyGeometryWkts[i]);
+    EXPECT_EQ(
+        wktRoundTripSpherical(emptyGeometryWkts[i]), emptyGeometryWkts[i]);
     EXPECT_EQ(emptyGeometryWkbs[i], wktToWkb(emptyGeometryWkts[i]));
     EXPECT_EQ(emptyGeometryWkts[i], wkbToWkT(emptyGeometryWkbs[i]));
     EXPECT_EQ(emptyGeometryWkbs[i], wkbRoundTrip(emptyGeometryWkbs[i]));
   }
+  wktRoundTrip(
+      "POLYGON ((73.3644 -53.0331, 73.3652 -53.0327, 73.3661 -53.0327, 73.3677 -53.0323, 73.3686 -53.0324, 73.3691 -53.0326, 73.3698 -53.0333, 73.3699 -53.0342, 73.3692 -53.0346, 73.3695 -53.0348, 73.3698 -53.0344, 73.3707 -53.0345, 73.3713 -53.034, 73.3718 -53.0339, 73.3722 -53.0329, 73.3713 -53.0323, 73.3711 -53.0319, 73.3701 -53.0311, 73.3685 -53.0305, 73.3666 -53.0302, 73.366 -53.0299, 73.3655 -53.03, 73.3653 -53.0304, 73.3646 -53.031, 73.3636 -53.0308, 73.363 -53.0311, 73.3629 -53.0313, 73.3627 -53.0316, 73.3619 -53.0315, 73.3611 -53.0318, 73.3611 -53.0322, 73.3606 -53.0327, 73.3601 -53.0326, 73.3603 -53.0316, 73.361 -53.0312, 73.3617 -53.0311, 73.362 -53.0308, 73.3625 -53.0307, 73.3646 -53.03, 73.3656 -53.0293, 73.3669 -53.0293, 73.3684 -53.0301, 73.3701 -53.0304, 73.3705 -53.0298, 73.3711 -53.0293, 73.3712 -53.029, 73.3717 -53.0287, 73.3717 -53.0284, 73.3722 -53.0278, 73.3722 -53.0271, 73.3721 -53.0268, 73.3718 -53.0267, 73.3719 -53.0263, 73.373 -53.0266, 73.3735 -53.0273, 73.3761 -53.0272, 73.3765 -53.0274, 73.377 -53.0272, 73.3781 -53.0272, 73.3792 -53.0267, 73.3798 -53.0266, 73.3801 -53.0264, 73.3806 -53.0263, 73.3808 -53.0257, 73.3811 -53.0256, 73.3815 -53.0257, 73.3815 -53.0275, 73.3818 -53.0277, 73.3817 -53.028, 73.382 -53.0282, 73.382 -53.0284, 73.3815 -53.0287, 73.3825 -53.0288, 73.3831 -53.0284, 73.3839 -53.0286, 73.3847 -53.0284, 73.3854 -53.0285, 73.3872 -53.028, 73.3879 -53.0276, 73.3887 -53.0275, 73.3892 -53.0272, 73.3897 -53.0272, 73.3908 -53.0265, 73.3912 -53.0265, 73.3915 -53.0263, 73.3919 -53.0265, 73.3918 -53.027, 73.3911 -53.0275, 73.3905 -53.0276, 73.3905 -53.0278, 73.3901 -53.0279, 73.3902 -53.0282, 73.3898 -53.0285, 73.3885 -53.0287, 73.3874 -53.0291, 73.3874 -53.0293, 73.3872 -53.0294, 73.3862 -53.0292, 73.3839 -53.0293, 73.3836 -53.0291, 73.3832 -53.0294, 73.3836 -53.0298, 73.3843 -53.0297, 73.3847 -53.0299, 73.3849 -53.0296, 73.3853 -53.0296, 73.3858 -53.0299, 73.3862 -53.0299, 73.3861 -53.0295, 73.3866 -53.0293, 73.3868 -53.0294, 73.3869 -53.0296, 73.3866 -53.0299, 73.3863 -53.0299, 73.3865 -53.03, 73.3874 -53.0298, 73.388 -53.0298, 73.3882 -53.0293, 73.3891 -53.0292, 73.3898 -53.0292, 73.39 -53.0291, 73.39 -53.0288, 73.3903 -53.0286, 73.3908 -53.0285, 73.391 -53.0281, 73.3914 -53.028, 73.3923 -53.0284, 73.3923 -53.0292, 73.3926 -53.0294, 73.3926 -53.0296, 73.3922 -53.0297, 73.3916 -53.0303, 73.3916 -53.0306, 73.392 -53.0309, 73.3936 -53.0309, 73.3941 -53.0307, 73.3946 -53.031, 73.3947 -53.0308, 73.3951 -53.0307, 73.3954 -53.0309, 73.3952 -53.0312, 73.3955 -53.0313, 73.3965 -53.0316, 73.3977 -53.0317, 73.3979 -53.0313, 73.3977 -53.0309, 73.3972 -53.0307, 73.3968 -53.0301, 73.3962 -53.0297, 73.396 -53.029, 73.3951 -53.029, 73.3947 -53.0286, 73.3933 -53.0282, 73.393 -53.028, 73.3929 -53.0276, 73.3922 -53.0271, 73.3923 -53.0265, 73.3921 -53.0261, 73.3923 -53.0259, 73.3923 -53.0253, 73.3928 -53.0249, 73.3931 -53.024, 73.393 -53.0235, 73.3933 -53.023, 73.3931 -53.0228, 73.3931 -53.0222, 73.3937 -53.0221, 73.3928 -53.0218, 73.3925 -53.021, 73.3917 -53.0203, 73.3909 -53.0198, 73.3906 -53.0197, 73.3897 -53.0201, 73.3894 -53.0202, 73.3892 -53.02, 73.3893 -53.0195, 73.3901 -53.0193, 73.3905 -53.019, 73.3913 -53.019, 73.3916 -53.0185, 73.3927 -53.0184, 73.3936 -53.0177, 73.3943 -53.0175, 73.3944 -53.017, 73.3952 -53.0161, 73.3956 -53.016, 73.396 -53.0155, 73.3967 -53.0151, 73.3971 -53.015, 73.3974 -53.0147, 73.3985 -53.0143, 73.3995 -53.0142, 73.4 -53.0143, 73.4002 -53.0147, 73.4006 -53.0147, 73.4008 -53.0145, 73.4007 -53.014, 73.4011 -53.0138, 73.402 -53.0136, 73.4031 -53.0137, 73.404 -53.0132, 73.4054 -53.0133, 73.4063 -53.0138, 73.4071 -53.0135, 73.4078 -53.0137, 73.4083 -53.0136, 73.4084 -53.0131, 73.4087 -53.0129, 73.4093 -53.0129, 73.4106 -53.0132, 73.4116 -53.0128, 73.4118 -53.0122, 73.4109 -53.0121, 73.4104 -53.0117, 73.4104 -53.0114, 73.4109 -53.0108, 73.4118 -53.0106, 73.4118 -53.0103, 73.4114 -53.01, 73.4116 -53.009, 73.412 -53.0087, 73.4129 -53.0089, 73.4131 -53.0086, 73.4134 -53.0083, 73.414 -53.0083, 73.4145 -53.0085, 73.4145 -53.0082, 73.4147 -53.008, 73.4154 -53.008, 73.4158 -53.0085, 73.4157 -53.009, 73.4154 -53.0092, 73.415 -53.0091, 73.4147 -53.0089, 73.4147 -53.009, 73.4155 -53.0095, 73.4156 -53.0112, 73.4158 -53.0114, 73.4159 -53.0122, 73.4167 -53.013, 73.4165 -53.0144, 73.4162 -53.0148, 73.4136 -53.0163, 73.4135 -53.0169, 73.413 -53.0169, 73.4126 -53.0168, 73.4117 -53.0173, 73.41 -53.0184, 73.4085 -53.0198, 73.4085 -53.0204, 73.4083 -53.0207, 73.4085 -53.0209, 73.4085 -53.0212, 73.4092 -53.0222, 73.4102 -53.0231, 73.4105 -53.0235, 73.4104 -53.0237, 73.4097 -53.024, 73.4091 -53.0247, 73.4095 -53.0247, 73.4095 -53.025, 73.4102 -53.025, 73.4101 -53.0253, 73.4097 -53.0254, 73.4098 -53.0259, 73.4103 -53.0263, 73.4106 -53.0263, 73.4102 -53.0256, 73.4103 -53.0251, 73.4109 -53.0251, 73.4112 -53.0247, 73.4123 -53.0248, 73.4131 -53.0254, 73.4137 -53.0255, 73.4142 -53.0258, 73.4149 -53.0258, 73.4152 -53.0263, 73.4162 -53.0262, 73.4164 -53.0265, 73.4169 -53.0264, 73.4173 -53.0267, 73.4186 -53.0268, 73.419 -53.0271, 73.42 -53.0274, 73.4208 -53.0274, 73.4222 -53.0279, 73.4224 -53.0283, 73.4222 -53.0284, 73.4207 -53.0286, 73.4202 -53.029, 73.4203 -53.0294, 73.4211 -53.0296, 73.4212 -53.0301, 73.4201 -53.0311, 73.4184 -53.0318, 73.4178 -53.0318, 73.4175 -53.0316, 73.4167 -53.0318, 73.4161 -53.0325, 73.4149 -53.0325, 73.4144 -53.033, 73.414 -53.0331, 73.4138 -53.0334, 73.414 -53.0336, 73.4148 -53.0334, 73.4151 -53.0336, 73.4146 -53.0353, 73.4153 -53.0362, 73.4152 -53.0377, 73.4155 -53.0379, 73.4155 -53.0382, 73.4153 -53.0401, 73.4134 -53.0412, 73.4109 -53.042, 73.4096 -53.044, 73.4101 -53.0462, 73.4117 -53.0477, 73.4122 -53.0485, 73.4119 -53.0493, 73.4101 -53.0511, 73.4101 -53.0517, 73.4107 -53.0523, 73.4103 -53.0535, 73.4132 -53.0569, 73.4154 -53.0579, 73.4161 -53.0579, 73.4163 -53.0583, 73.4171 -53.0587, 73.423 -53.0615, 73.4235 -53.0618, 73.4237 -53.0621, 73.4246 -53.062, 73.4258 -53.0624, 73.426 -53.0628, 73.4266 -53.0627, 73.427 -53.063, 73.427 -53.0632, 73.4267 -53.0635, 73.4276 -53.0631, 73.4281 -53.0631, 73.4287 -53.0637, 73.4294 -53.0637, 73.4297 -53.0638, 73.4299 -53.0642, 73.4291 -53.0646, 73.429 -53.0651, 73.4286 -53.0652, 73.4285 -53.0657, 73.428 -53.0661, 73.4274 -53.0659, 73.4274 -53.0654, 73.427 -53.0651, 73.4273 -53.0648, 73.4281 -53.0647, 73.4276 -53.0644, 73.4271 -53.0643, 73.427 -53.064, 73.4265 -53.0639, 73.4265 -53.0641, 73.4267 -53.0643, 73.4267 -53.0645, 73.4251 -53.0653, 73.4242 -53.0652, 73.4237 -53.0646, 73.4225 -53.0648, 73.4221 -53.0647, 73.4219 -53.0644, 73.4215 -53.0644, 73.4212 -53.0642, 73.4205 -53.0643, 73.4198 -53.0639, 73.4198 -53.0637, 73.4192 -53.0638, 73.4188 -53.0635, 73.4189 -53.0632, 73.4194 -53.0632, 73.4194 -53.0624, 73.4191 -53.0621, 73.4185 -53.0621, 73.4177 -53.0625, 73.4174 -53.0628, 73.4166 -53.0627, 73.4159 -53.0624, 73.4158 -53.0621, 73.4151 -53.0621, 73.4142 -53.0617, 73.4138 -53.0614, 73.4111 -53.0603, 73.4105 -53.0595, 73.4098 -53.0592, 73.4094 -53.0593, 73.4087 -53.0593, 73.4071 -53.0577, 73.4054 -53.0575, 73.4049 -53.057, 73.4039 -53.0567, 73.4024 -53.0554, 73.4011 -53.0552, 73.4005 -53.0549, 73.3994 -53.0553, 73.3976 -53.0553, 73.3972 -53.055, 73.3963 -53.0549, 73.3962 -53.055, 73.3964 -53.0552, 73.3964 -53.0556, 73.3955 -53.0562, 73.3946 -53.0562, 73.394 -53.0557, 73.3937 -53.0557, 73.3937 -53.0561, 73.3942 -53.0564, 73.3942 -53.0569, 73.3938 -53.0572, 73.3906 -53.0582, 73.3894 -53.0584, 73.3891 -53.0586, 73.3883 -53.0586, 73.3882 -53.0589, 73.3877 -53.0593, 73.3859 -53.0606, 73.3851 -53.0608, 73.3848 -53.0606, 73.3848 -53.0602, 73.385 -53.06, 73.385 -53.0596, 73.3848 -53.0594, 73.384 -53.0591, 73.3836 -53.0595, 73.3834 -53.0615, 73.384 -53.0616, 73.3842 -53.0618, 73.3842 -53.0624, 73.384 -53.0626, 73.3841 -53.0628, 73.3841 -53.0646, 73.384 -53.0648, 73.384 -53.0657, 73.3867 -53.0656, 73.3873 -53.0657, 73.3879 -53.0652, 73.389 -53.0655, 73.3891 -53.0661, 73.3886 -53.0665, 73.3884 -53.0668, 73.3885 -53.0674, 73.3888 -53.0676, 73.3888 -53.0679, 73.3884 -53.0683, 73.3893 -53.0687, 73.3893 -53.0695, 73.3888 -53.0697, 73.3888 -53.0702, 73.389 -53.0703, 73.3896 -53.0703, 73.3901 -53.07, 73.3906 -53.0701, 73.3908 -53.0702, 73.3908 -53.0708, 73.3915 -53.0708, 73.3919 -53.0712, 73.392 -53.0716, 73.3916 -53.0719, 73.3923 -53.0724, 73.3927 -53.0729, 73.3925 -53.0734, 73.3919 -53.0734, 73.3913 -53.0739, 73.3907 -53.074, 73.3904 -53.0744, 73.3893 -53.0748, 73.3885 -53.0748, 73.3883 -53.0753, 73.3872 -53.076, 73.3867 -53.076, 73.3861 -53.0768, 73.3855 -53.0771, 73.3855 -53.0773, 73.3863 -53.0779, 73.3863 -53.079, 73.386 -53.0795, 73.3853 -53.0796, 73.385 -53.0792, 73.3834 -53.0781, 73.3818 -53.0775, 73.3808 -53.0769, 73.3794 -53.0764, 73.3788 -53.0764, 73.3776 -53.0768, 73.3775 -53.0771, 73.3773 -53.0773, 73.3768 -53.0773, 73.3763 -53.0776, 73.3758 -53.0775, 73.3757 -53.0771, 73.3764 -53.0769, 73.3756 -53.0769, 73.3755 -53.0766, 73.3757 -53.0764, 73.3762 -53.0763, 73.3765 -53.0761, 73.3759 -53.0759, 73.3758 -53.0755, 73.375 -53.0751, 73.375 -53.0747, 73.3749 -53.0746, 73.3741 -53.0744, 73.3735 -53.0747, 73.3729 -53.0745, 73.3727 -53.0741, 73.3727 -53.0733, 73.3731 -53.073, 73.3736 -53.0729, 73.3733 -53.0726, 73.3721 -53.0726, 73.3718 -53.0724, 73.3708 -53.0723, 73.3689 -53.0732, 73.367 -53.0737, 73.3654 -53.0738, 73.3645 -53.0738, 73.3638 -53.0743, 73.3638 -53.0748, 73.3625 -53.075, 73.3622 -53.0755, 73.3617 -53.0755, 73.3615 -53.0753, 73.3615 -53.0748, 73.3616 -53.0745, 73.3624 -53.0739, 73.3631 -53.0738, 73.3632 -53.0733, 73.3635 -53.073, 73.3654 -53.0726, 73.368 -53.0724, 73.3689 -53.0718, 73.3723 -53.0711, 73.374 -53.07, 73.3754 -53.0682, 73.3773 -53.0674, 73.3787 -53.0661, 73.3798 -53.0648, 73.3806 -53.0633, 73.3812 -53.0626, 73.3814 -53.062, 73.3819 -53.0614, 73.3817 -53.0609, 73.3818 -53.0604, 73.3816 -53.0597, 73.3818 -53.0592, 73.3824 -53.0587, 73.3824 -53.0581, 73.3827 -53.0579, 73.382 -53.057, 73.3821 -53.0565, 73.3815 -53.0561, 73.3816 -53.0556, 73.3812 -53.0552, 73.3812 -53.0549, 73.3816 -53.0548, 73.3815 -53.0538, 73.3818 -53.0535, 73.3813 -53.0533, 73.3813 -53.0529, 73.3818 -53.0525, 73.3815 -53.0522, 73.3812 -53.0516, 73.3807 -53.052, 73.38 -53.0518, 73.3799 -53.0511, 73.3796 -53.0509, 73.3795 -53.0505, 73.3796 -53.0498, 73.3806 -53.0499, 73.3802 -53.0497, 73.3804 -53.049, 73.3802 -53.0487, 73.3803 -53.0483, 73.3799 -53.0478, 73.3795 -53.0476, 73.3795 -53.0465, 73.3801 -53.0462, 73.3794 -53.046, 73.3786 -53.0453, 73.3779 -53.0454, 73.3777 -53.0453, 73.3778 -53.0451, 73.3774 -53.0451, 73.3773 -53.0454, 73.3769 -53.0454, 73.3768 -53.0451, 73.3772 -53.045, 73.3772 -53.0447, 73.3775 -53.0443, 73.3763 -53.0437, 73.3759 -53.0429, 73.3746 -53.0425, 73.3732 -53.0424, 73.3725 -53.0421, 73.3722 -53.0421, 73.3721 -53.0424, 73.3709 -53.0425, 73.3707 -53.0429, 73.3714 -53.0435, 73.3714 -53.0437, 73.3707 -53.0441, 73.3694 -53.0446, 73.3686 -53.0445, 73.3681 -53.0442, 73.3674 -53.0441, 73.3665 -53.0437, 73.3657 -53.0431, 73.3651 -53.0418, 73.3651 -53.0415, 73.3656 -53.041, 73.3661 -53.0402, 73.3676 -53.0396, 73.3678 -53.0393, 73.3696 -53.0393, 73.3701 -53.0392, 73.3702 -53.0389, 73.3708 -53.0388, 73.371 -53.0384, 73.371 -53.0378, 73.3706 -53.0376, 73.3705 -53.0371, 73.3709 -53.0364, 73.3699 -53.0356, 73.3697 -53.0351, 73.3693 -53.0353, 73.3688 -53.0353, 73.3682 -53.0349, 73.3677 -53.0349, 73.3674 -53.0345, 73.3669 -53.0345, 73.3667 -53.0342, 73.3648 -53.0339, 73.3654 -53.0344, 73.3654 -53.0347, 73.3644 -53.0349, 73.3639 -53.0351, 73.3625 -53.0351, 73.3616 -53.0348, 73.3614 -53.0343, 73.361 -53.0342, 73.3607 -53.0336, 73.3607 -53.0332, 73.3613 -53.0326, 73.3622 -53.0322, 73.3625 -53.0319, 73.363 -53.0319, 73.3633 -53.0321, 73.3632 -53.0327, 73.3634 -53.0329, 73.3634 -53.0334, 73.3643 -53.0333, 73.3644 -53.0331), (73.3938 -53.0223, 73.3938 -53.0222, 73.3937 -53.0221, 73.3938 -53.0222, 73.3938 -53.0223), (73.4095 -53.0252, 73.4094 -53.0253, 73.4095 -53.0253, 73.4095 -53.0253, 73.4095 -53.0252), (73.4162 -53.0267, 73.4163 -53.0267, 73.4163 -53.0266, 73.4162 -53.0267, 73.4162 -53.0267), (73.4259 -53.0629, 73.4259 -53.0631, 73.4263 -53.0632, 73.426 -53.063, 73.4259 -53.0629), (73.3805 -53.0503, 73.3801 -53.0504, 73.3806 -53.0505, 73.3806 -53.0508, 73.3807 -53.0508, 73.3809 -53.0505, 73.3805 -53.0503), (73.3809 -53.0512, 73.3811 -53.0513, 73.3812 -53.0514, 73.3812 -53.0512, 73.3809 -53.0512), (73.3783 -53.045, 73.378 -53.0449, 73.3778 -53.045, 73.378 -53.045, 73.3783 -53.045), (73.3899 -53.0275, 73.39 -53.0274, 73.3899 -53.0274, 73.3899 -53.0275, 73.3899 -53.0275), (73.3962 -53.0287, 73.3965 -53.0286, 73.3965 -53.0284, 73.397 -53.0279, 73.3969 -53.0273, 73.3965 -53.0269, 73.3971 -53.0267, 73.3968 -53.0266, 73.3967 -53.0263, 73.3972 -53.0263, 73.3974 -53.0266, 73.3989 -53.0263, 73.3988 -53.0262, 73.3983 -53.0262, 73.3982 -53.026, 73.3993 -53.0255, 73.3989 -53.025, 73.3987 -53.0249, 73.3986 -53.0253, 73.3978 -53.0255, 73.3976 -53.0254, 73.3976 -53.0252, 73.398 -53.0251, 73.3981 -53.0248, 73.3985 -53.0248, 73.397 -53.0246, 73.3962 -53.0249, 73.3959 -53.0252, 73.396 -53.0265, 73.3957 -53.0267, 73.3953 -53.0267, 73.3938 -53.026, 73.3935 -53.0261, 73.3936 -53.0263, 73.3941 -53.0264, 73.394 -53.0266, 73.3936 -53.0266, 73.3938 -53.0268, 73.3939 -53.0274, 73.395 -53.028, 73.395 -53.0284, 73.3962 -53.0287), (73.3825 -53.0548, 73.3828 -53.0554, 73.3828 -53.0559, 73.3834 -53.0562, 73.3837 -53.0566, 73.384 -53.0567, 73.3845 -53.0565, 73.385 -53.056, 73.3864 -53.055, 73.3871 -53.055, 73.3877 -53.0547, 73.3883 -53.0546, 73.3877 -53.054, 73.3877 -53.0537, 73.3879 -53.0535, 73.3896 -53.0531, 73.3899 -53.0529, 73.3905 -53.0529, 73.3917 -53.0532, 73.3921 -53.0536, 73.3928 -53.0538, 73.3929 -53.0537, 73.393 -53.0534, 73.3936 -53.053, 73.3948 -53.0528, 73.396 -53.053, 73.3968 -53.0526, 73.3981 -53.0526, 73.3985 -53.0525, 73.3982 -53.0522, 73.3985 -53.0513, 73.399 -53.0511, 73.3997 -53.0504, 73.4012 -53.0503, 73.4019 -53.0505, 73.403 -53.0514, 73.403 -53.0525, 73.4029 -53.0527, 73.403 -53.0531, 73.4038 -53.0536, 73.4042 -53.0545, 73.4052 -53.0549, 73.4056 -53.0546, 73.4054 -53.0526, 73.4056 -53.0518, 73.4061 -53.0512, 73.406 -53.0508, 73.4057 -53.0505, 73.4058 -53.05, 73.4054 -53.0497, 73.4054 -53.0493, 73.4048 -53.0487, 73.4048 -53.0483, 73.405 -53.0479, 73.4054 -53.0478, 73.4055 -53.0473, 73.4058 -53.0469, 73.4058 -53.0466, 73.4045 -53.0457, 73.4045 -53.0454, 73.4047 -53.0451, 73.4047 -53.045, 73.4039 -53.045, 73.4036 -53.0453, 73.403 -53.0455, 73.402 -53.0454, 73.4015 -53.0445, 73.4015 -53.0437, 73.4016 -53.0434, 73.4022 -53.0433, 73.4018 -53.043, 73.4015 -53.0429, 73.4011 -53.0432, 73.401 -53.0435, 73.4004 -53.0441, 73.4006 -53.0444, 73.4006 -53.0448, 73.4004 -53.0451, 73.3999 -53.0452, 73.3996 -53.0455, 73.3986 -53.0457, 73.3983 -53.0461, 73.396 -53.0459, 73.3954 -53.0461, 73.3952 -53.0466, 73.3937 -53.047, 73.3932 -53.0478, 73.3924 -53.0481, 73.3926 -53.0484, 73.3926 -53.0487, 73.3923 -53.0491, 73.3918 -53.0493, 73.3915 -53.0496, 73.3907 -53.0499, 73.3902 -53.0502, 73.3892 -53.0504, 73.3884 -53.051, 73.3876 -53.051, 73.3864 -53.0516, 73.3855 -53.0516, 73.3848 -53.052, 73.3845 -53.0524, 73.3843 -53.053, 73.3831 -53.0538, 73.3829 -53.0545, 73.3825 -53.0548))");
 }
 
 // Constructors and accessors
@@ -449,6 +487,7 @@ TEST_F(GeometryFunctionsTest, testStContains) {
       false);
   assertRelation(
       "ST_Contains", "LINESTRING (20 20, 30 30)", "POLYGON EMPTY", false);
+  assertRelation("ST_Contains", "POLYGON EMPTY", "POINT EMPTY", false);
 
   VELOX_ASSERT_USER_THROW(
       assertRelation(
@@ -514,6 +553,13 @@ TEST_F(GeometryFunctionsTest, testStCrosses) {
       "POLYGON ((0 0, 0 4, 4 4, 4 0, 0 0))",
       "LINESTRING (0 0, 0 4, 4 4, 4 0)",
       false);
+  assertRelation("ST_Crosses", "POLYGON EMPTY", "POINT (0 0)", false);
+  assertRelation(
+      "ST_Crosses",
+      "POLYGON ((0 0, 0 4, 4 4, 4 0, 0 0))",
+      "POINT EMPTY",
+      false);
+  assertRelation("ST_Crosses", "POLYGON EMPTY", "POINT EMPTY", false);
 
   VELOX_ASSERT_USER_THROW(
       assertRelation(
@@ -550,6 +596,13 @@ TEST_F(GeometryFunctionsTest, testStDisjoint) {
       "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))",
       "POLYGON ((4 4, 4 5, 5 5, 5 4, 4 4))",
       true);
+  assertRelation("ST_Disjoint", "POLYGON EMPTY", "POINT (0 0)", true);
+  assertRelation(
+      "ST_Disjoint",
+      "POLYGON ((0 0, 0 4, 4 4, 4 0, 0 0))",
+      "POINT EMPTY",
+      true);
+  assertRelation("ST_Disjoint", "POLYGON EMPTY", "POINT EMPTY", true);
 
   VELOX_ASSERT_USER_THROW(
       assertRelation(
@@ -590,6 +643,13 @@ TEST_F(GeometryFunctionsTest, testStEquals) {
       "MULTIPOLYGON (((1 1, 1 3, 3 3, 3 1, 1 1)), ((0 0, 0 2, 2 2, 2 0, 0 0)))",
       "POLYGON ((0 1, 3 1, 3 3, 0 3, 0 1))",
       false);
+  assertRelation("ST_Equals", "POLYGON EMPTY", "POINT (0 0)", false);
+  assertRelation(
+      "ST_Equals", "POLYGON ((0 0, 0 4, 4 4, 4 0, 0 0))", "POINT EMPTY", false);
+  // According to DE-9IM spec two empty geoms are not equal, but this is the
+  // current GEOS behavior
+  assertRelation("ST_Equals", "POLYGON EMPTY", "POINT EMPTY", true);
+
   // Invalid geometries.  This test might have to change when upgrading GEOS.
   assertRelation(
       "ST_Equals",
@@ -640,6 +700,13 @@ TEST_F(GeometryFunctionsTest, testStIntersects) {
       "POLYGON ((16.5 54, 16.5 54.1, 16.51 54.1, 16.8 54, 16.5 54))",
       "LINESTRING (16.6667 54.25, 16.8667 54.25)",
       false);
+  assertRelation("ST_Intersects", "POLYGON EMPTY", "POINT (0 0)", false);
+  assertRelation(
+      "ST_Intersects",
+      "POLYGON ((0 0, 0 4, 4 4, 4 0, 0 0))",
+      "POINT EMPTY",
+      false);
+  assertRelation("ST_Intersects", "POLYGON EMPTY", "POINT EMPTY", false);
 
   VELOX_ASSERT_USER_THROW(
       assertRelation(
@@ -694,6 +761,13 @@ TEST_F(GeometryFunctionsTest, testStOverlaps) {
       "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))",
       "POLYGON ((4 4, 4 5, 5 5, 5 4, 4 4))",
       false);
+  assertRelation("ST_Overlaps", "POLYGON EMPTY", "POINT (0 0)", false);
+  assertRelation(
+      "ST_Overlaps",
+      "POLYGON ((0 0, 0 4, 4 4, 4 0, 0 0))",
+      "POINT EMPTY",
+      false);
+  assertRelation("ST_Overlaps", "POLYGON EMPTY", "POINT EMPTY", false);
 
   VELOX_ASSERT_USER_THROW(
       assertRelation(
@@ -765,6 +839,13 @@ TEST_F(GeometryFunctionsTest, testStTouches) {
       "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))",
       "POLYGON ((3 3, 3 5, 5 5, 5 3, 3 3))",
       true);
+  assertRelation("ST_Touches", "POLYGON EMPTY", "POINT (0 0)", false);
+  assertRelation(
+      "ST_Touches",
+      "POLYGON ((0 0, 0 4, 4 4, 4 0, 0 0))",
+      "POINT EMPTY",
+      false);
+  assertRelation("ST_Touches", "POLYGON EMPTY", "POINT EMPTY", false);
 
   VELOX_ASSERT_USER_THROW(
       assertRelation(
@@ -840,6 +921,10 @@ TEST_F(GeometryFunctionsTest, testStWithin) {
       "POLYGON ((1 1, 1 5, 5 5, 5 1, 1 1))",
       "POLYGON ((0 0, 0 4, 4 4, 4 0, 0 0))",
       false);
+  assertRelation("ST_Within", "POLYGON EMPTY", "POINT (0 0)", false);
+  assertRelation(
+      "ST_Within", "POLYGON ((0 0, 0 4, 4 4, 4 0, 0 0))", "POINT EMPTY", false);
+  assertRelation("ST_Within", "POLYGON EMPTY", "POINT EMPTY", false);
 
   VELOX_ASSERT_USER_THROW(
       assertRelation(
@@ -882,6 +967,22 @@ TEST_F(GeometryFunctionsTest, testStDifference) {
       "POLYGON ((0 1, 3 1, 3 3, 0 3, 0 1))",
       "POLYGON ((0 1, 1 1, 1 0, 0 0, 0 1))");
 
+  assertOverlay(
+      "ST_Difference",
+      "POLYGON ((0 1, 1 1, 1 0, 0 0, 0 1))",
+      "POINT EMPTY",
+      "POLYGON ((0 1, 1 1, 1 0, 0 0, 0 1))");
+  assertOverlay(
+      "ST_Difference",
+      "POLYGON EMPTY",
+      "POINT (0 0)",
+      "GEOMETRYCOLLECTION EMPTY");
+  assertOverlay(
+      "ST_Difference",
+      "POLYGON EMPTY",
+      "POINT EMPTY",
+      "GEOMETRYCOLLECTION EMPTY");
+
   ASSERT_THROW(
       assertOverlay(
           "ST_Difference",
@@ -930,6 +1031,21 @@ TEST_F(GeometryFunctionsTest, testStIntersection) {
       "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))",
       "LINESTRING (0 0, 1 -1, 1 2)",
       "GEOMETRYCOLLECTION (LINESTRING (1 1, 1 0), POINT (0 0))");
+  assertOverlay(
+      "ST_Intersection",
+      "POLYGON ((0 1, 1 1, 1 0, 0 0, 0 1))",
+      "POINT EMPTY",
+      "GEOMETRYCOLLECTION EMPTY");
+  assertOverlay(
+      "ST_Intersection",
+      "POLYGON EMPTY",
+      "POINT (0 0)",
+      "GEOMETRYCOLLECTION EMPTY");
+  assertOverlay(
+      "ST_Intersection",
+      "POLYGON EMPTY",
+      "POINT EMPTY",
+      "GEOMETRYCOLLECTION EMPTY");
 
   ASSERT_THROW(
       assertOverlay(
@@ -1231,43 +1347,40 @@ TEST_F(GeometryFunctionsTest, testStIsSimpleValid) {
       "GEOMETRYCOLLECTION (POINT (1 2), POLYGON ((0 0, 0 1, 2 1, 1 1, 1 0, 0 0)))",
       false,
       false);
+  assertStIsValidSimpleFunc(
+      "MULTIPOLYGON (((18.6317421 49.9605785, 18.6318832 49.9607979, 18.6324683 49.9607312, 18.6332842 49.9605658, 18.6332003 49.9603557, 18.6339711 49.9602283, 18.6341994 49.9601905, 18.6343455 49.96016, 18.6344167 49.9601452, 18.6346696 49.9600919, 18.6349643 49.9600567, 18.6352271 49.9601455, 18.6354493 49.9600501, 18.6358024 49.9601071, 18.6358911 49.9600263, 18.6336542 49.9592453, 18.6334794 49.9591838, 18.6337483 49.9581339, 18.6335303 49.9580562, 18.6331284 49.9579122, 18.6324931 49.9576885, 18.6322503 49.9575998, 18.6321381 49.9581593, 18.6321172 49.9582692, 18.6324683 49.9583852, 18.6325255 49.9584004, 18.6327588 49.958489, 18.6324792 49.9588351, 18.6323941 49.9588049, 18.6323261 49.9587807, 18.6320354 49.9586789, 18.6319443 49.9592903, 18.6326731 49.9595648, 18.6331388 49.9594836, 18.6335981 49.959673, 18.6333065 49.9597934, 18.6328096 49.9600844, 18.6330209 49.9601348, 18.633424 49.9602597, 18.6332263 49.960317, 18.6315633 49.9597642, 18.6309331 49.9600741, 18.6317421 49.9605785)), ((18.6298591 49.9606201, 18.6298592 49.96062, 18.6298589 49.9606193, 18.6298591 49.9606201)))",
+      true,
+      true);
+  assertStIsValidSimpleFunc(
+      "MULTIPOLYGON (((18.6317421 49.9605785, 18.6318832 49.9607979, 18.6324683 49.9607312, 18.6332842 49.9605658, 18.6332003 49.9603557, 18.6339711 49.9602283, 18.6341994 49.9601905, 18.6343455 49.96016, 18.6344167 49.9601452, 18.6346696 49.9600919, 18.6349643 49.9600567, 18.6352271 49.9601455, 18.6354493 49.9600501, 18.6358024 49.9601071, 18.6358911 49.9600263, 18.6336542 49.9592453, 18.6334794 49.9591838, 18.6337483 49.9581339, 18.6335303 49.9580562, 18.6331284 49.9579122, 18.6324931 49.9576885, 18.6322503 49.9575998, 18.6321381 49.9581593, 18.6321172 49.9582692, 18.6324683 49.9583852, 18.6325255 49.9584004, 18.6327588 49.958489, 18.6324792 49.9588351, 18.6323941 49.9588049, 18.6323261 49.9587807, 18.6320354 49.9586789, 18.6319443 49.9592903, 18.6326731 49.9595648, 18.6331388 49.9594836, 18.6335981 49.959673, 18.6333065 49.9597934, 18.6328096 49.9600844, 18.6330209 49.9601348, 18.633424 49.9602597, 18.6332263 49.960317, 18.6315633 49.9597642, 18.6309331 49.9600741, 18.6317421 49.9605785)), ((18.6298591 49.9606201, 18.6298592 49.96062, 18.6298592 49.96062, 18.6298591 49.9606201)))",
+      false,
+      false);
 }
 
 TEST_F(GeometryFunctionsTest, testStArea) {
-  const auto testStAreaFunc = [&](std::optional<std::string> wkt,
-                                  std::optional<double> expectedArea) {
-    std::optional<double> result =
-        evaluateOnce<double>("ST_Area(ST_GeometryFromText(c0))", wkt);
-
-    if (wkt.has_value()) {
-      ASSERT_TRUE(result.has_value());
-      ASSERT_TRUE(expectedArea.has_value());
-      ASSERT_EQ(result.value(), expectedArea.value());
-    } else {
-      ASSERT_FALSE(result.has_value());
-    }
-  };
-
-  testStAreaFunc("POLYGON ((2 2, 2 6, 6 6, 6 2, 2 2))", 16.0);
-  testStAreaFunc("POLYGON EMPTY", 0.0);
-  testStAreaFunc("LINESTRING (1 4, 2 5)", 0.0);
-  testStAreaFunc("LINESTRING EMPTY", 0.0);
-  testStAreaFunc("POINT (1 4)", 0.0);
-  testStAreaFunc("POINT EMPTY", 0.0);
-  testStAreaFunc("GEOMETRYCOLLECTION EMPTY", 0.0);
+  assertResult<double>("ST_Area", "POLYGON ((2 2, 2 6, 6 6, 6 2, 2 2))", 16.0);
+  assertResult<double>("ST_Area", "POLYGON EMPTY", 0.0);
+  assertResult<double>("ST_Area", "LINESTRING (1 4, 2 5)", 0.0);
+  assertResult<double>("ST_Area", "LINESTRING EMPTY", 0.0);
+  assertResult<double>("ST_Area", "POINT (1 4)", 0.0);
+  assertResult<double>("ST_Area", "POINT EMPTY", 0.0);
+  assertResult<double>("ST_Area", "GEOMETRYCOLLECTION EMPTY", 0.0);
 
   // Test basic geometry collection. Area is the area of the polygon.
-  testStAreaFunc(
+  assertResult<double>(
+      "ST_Area",
       "GEOMETRYCOLLECTION (POINT (8 8), LINESTRING (5 5, 6 6), POLYGON ((1 1, 3 1, 3 4, 1 4, 1 1)))",
       6.0);
 
   // Test overlapping geometries. Area is the sum of the individual elements
-  testStAreaFunc(
+  assertResult<double>(
+      "ST_Area",
       "GEOMETRYCOLLECTION (POLYGON ((0 0, 2 0, 2 2, 0 2, 0 0)), POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1)))",
       8.0);
 
   // Test nested geometry collection
-  testStAreaFunc(
+  assertResult<double>(
+      "ST_Area",
       "GEOMETRYCOLLECTION (POLYGON ((0 0, 2 0, 2 2, 0 2, 0 0)), POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1)), GEOMETRYCOLLECTION (POINT (8 8), LINESTRING (5 5, 6 6), POLYGON ((1 1, 3 1, 3 4, 1 4, 1 1))))",
       14.0);
 }
@@ -1435,39 +1548,42 @@ TEST_F(GeometryFunctionsTest, testStBoundary) {
 }
 
 TEST_F(GeometryFunctionsTest, testStCentroid) {
-  const auto testStCentroidFunc =
-      [&](const std::optional<std::string>& wkt,
-          const std::optional<std::string>& expected) {
-        std::optional<std::string> result = evaluateOnce<std::string>(
-            "ST_AsText(ST_Centroid(ST_GeometryFromText(c0)))", wkt);
-
-        if (wkt.has_value()) {
-          ASSERT_TRUE(result.has_value());
-          ASSERT_TRUE(expected.has_value());
-          ASSERT_EQ(result.value(), expected.value());
-        } else {
-          ASSERT_FALSE(result.has_value());
-        }
-      };
-
-  testStCentroidFunc("LINESTRING EMPTY", "POINT EMPTY");
-  testStCentroidFunc("POINT (3 5)", "POINT (3 5)");
-  testStCentroidFunc("MULTIPOINT (1 2, 2 4, 3 6, 4 8)", "POINT (2.5 5)");
-  testStCentroidFunc("LINESTRING (1 1, 2 2, 3 3)", "POINT (2 2)");
-  testStCentroidFunc("MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))", "POINT (3 2)");
-  testStCentroidFunc("POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))", "POINT (2.5 2.5)");
-  testStCentroidFunc("POLYGON ((1 1, 5 1, 3 4, 1 1))", "POINT (3 2)");
-  testStCentroidFunc(
+  assertResult<std::string>(
+      "ST_Centroid", "LINESTRING EMPTY", std::nullopt, true);
+  assertResult<std::string>("ST_Centroid", "POINT (3 5)", "POINT (3 5)", true);
+  assertResult<std::string>(
+      "ST_Centroid", "MULTIPOINT (1 2, 2 4, 3 6, 4 8)", "POINT (2.5 5)", true);
+  assertResult<std::string>(
+      "ST_Centroid", "LINESTRING (1 1, 2 2, 3 3)", "POINT (2 2)", true);
+  assertResult<std::string>(
+      "ST_Centroid",
+      "MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))",
+      "POINT (3 2)",
+      true);
+  assertResult<std::string>(
+      "ST_Centroid",
+      "POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))",
+      "POINT (2.5 2.5)",
+      true);
+  assertResult<std::string>(
+      "ST_Centroid", "POLYGON ((1 1, 5 1, 3 4, 1 1))", "POINT (3 2)", true);
+  assertResult<std::string>(
+      "ST_Centroid",
       "MULTIPOLYGON (((1 1, 1 3, 3 3, 3 1, 1 1)), ((2 4, 2 6, 6 6, 6 4, 2 4)))",
-      "POINT (3.3333333333333335 4)");
-  testStCentroidFunc(
+      "POINT (3.3333333333333335 4)",
+      true);
+  assertResult<std::string>(
+      "ST_Centroid",
       "POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0), (1 1, 1 2, 2 2, 2 1, 1 1))",
-      "POINT (2.5416666666666665 2.5416666666666665)");
+      "POINT (2.5416666666666665 2.5416666666666665)",
+      true);
 
   VELOX_ASSERT_USER_THROW(
-      testStCentroidFunc(
+      assertResult<std::string>(
+          "ST_Centroid",
           "GEOMETRYCOLLECTION (POLYGON ((0 0, 2 0, 2 2, 0 2, 0 0)), POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1)), GEOMETRYCOLLECTION (POINT (8 8), LINESTRING (5 5, 6 6), POLYGON ((1 1, 3 1, 3 4, 1 4, 1 1))))",
-          std::nullopt),
+          std::nullopt,
+          true),
       "ST_Centroid only applies to Point or MultiPoint or LineString or MultiLineString or Polygon or MultiPolygon. Input type is: GeometryCollection");
 }
 
@@ -1540,39 +1656,37 @@ TEST_F(GeometryFunctionsTest, testSTMax) {
 }
 
 TEST_F(GeometryFunctionsTest, testStGeometryType) {
-  const auto testStGeometryTypeFunc =
-      [&](const std::optional<std::string>& wkt,
-          const std::optional<std::string>& expected) {
-        std::optional<std::string> result = evaluateOnce<std::string>(
-            "ST_GeometryType(ST_GeometryFromText(c0))", wkt);
-
-        if (wkt.has_value()) {
-          ASSERT_TRUE(result.has_value());
-          ASSERT_TRUE(expected.has_value());
-          ASSERT_EQ(result.value(), expected.value());
-        } else {
-          ASSERT_FALSE(result.has_value());
-        }
-      };
-
-  testStGeometryTypeFunc("POINT EMPTY", "ST_Point");
-  testStGeometryTypeFunc("POINT (3 5)", "ST_Point");
-  testStGeometryTypeFunc("LINESTRING EMPTY", "ST_LineString");
-  testStGeometryTypeFunc("LINESTRING (1 1, 2 2, 3 3)", "ST_LineString");
-  testStGeometryTypeFunc("LINEARRING EMPTY", "ST_LineString");
-  testStGeometryTypeFunc("POLYGON EMPTY", "ST_Polygon");
-  testStGeometryTypeFunc("POLYGON ((1 1, 4 1, 1 4, 1 1))", "ST_Polygon");
-  testStGeometryTypeFunc("MULTIPOINT EMPTY", "ST_MultiPoint");
-  testStGeometryTypeFunc("MULTIPOINT (1 2, 2 4, 3 6, 4 8)", "ST_MultiPoint");
-  testStGeometryTypeFunc("MULTILINESTRING EMPTY", "ST_MultiLineString");
-  testStGeometryTypeFunc(
-      "MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))", "ST_MultiLineString");
-  testStGeometryTypeFunc("MULTIPOLYGON EMPTY", "ST_MultiPolygon");
-  testStGeometryTypeFunc(
+  assertResult<std::string>("ST_GeometryType", "POINT EMPTY", "ST_Point");
+  assertResult<std::string>("ST_GeometryType", "POINT (3 5)", "ST_Point");
+  assertResult<std::string>(
+      "ST_GeometryType", "LINESTRING EMPTY", "ST_LineString");
+  assertResult<std::string>(
+      "ST_GeometryType", "LINESTRING (1 1, 2 2, 3 3)", "ST_LineString");
+  assertResult<std::string>(
+      "ST_GeometryType", "LINEARRING EMPTY", "ST_LineString");
+  assertResult<std::string>("ST_GeometryType", "POLYGON EMPTY", "ST_Polygon");
+  assertResult<std::string>(
+      "ST_GeometryType", "POLYGON ((1 1, 4 1, 1 4, 1 1))", "ST_Polygon");
+  assertResult<std::string>(
+      "ST_GeometryType", "MULTIPOINT EMPTY", "ST_MultiPoint");
+  assertResult<std::string>(
+      "ST_GeometryType", "MULTIPOINT (1 2, 2 4, 3 6, 4 8)", "ST_MultiPoint");
+  assertResult<std::string>(
+      "ST_GeometryType", "MULTILINESTRING EMPTY", "ST_MultiLineString");
+  assertResult<std::string>(
+      "ST_GeometryType",
+      "MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))",
+      "ST_MultiLineString");
+  assertResult<std::string>(
+      "ST_GeometryType", "MULTIPOLYGON EMPTY", "ST_MultiPolygon");
+  assertResult<std::string>(
+      "ST_GeometryType",
       "MULTIPOLYGON (((1 1, 1 3, 3 3, 3 1, 1 1)), ((2 4, 2 6, 6 6, 6 4, 2 4)))",
       "ST_MultiPolygon");
-  testStGeometryTypeFunc("GEOMETRYCOLLECTION EMPTY", "ST_GeomCollection");
-  testStGeometryTypeFunc(
+  assertResult<std::string>(
+      "ST_GeometryType", "GEOMETRYCOLLECTION EMPTY", "ST_GeomCollection");
+  assertResult<std::string>(
+      "ST_GeometryType",
       "GEOMETRYCOLLECTION (POLYGON ((0 0, 2 0, 2 2, 0 2, 0 0)), POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1)), GEOMETRYCOLLECTION (POINT (8 8), LINESTRING (5 5, 6 6), POLYGON ((1 1, 3 1, 3 4, 1 4, 1 1))))",
       "ST_GeomCollection");
 }
@@ -1705,92 +1819,47 @@ TEST_F(GeometryFunctionsTest, testStPolygon) {
 }
 
 TEST_F(GeometryFunctionsTest, testStIsClosed) {
-  const auto testStIsClosedFunc = [&](const std::optional<std::string>& wkt,
-                                      const std::optional<bool>& expected) {
-    std::optional<bool> result =
-        evaluateOnce<bool>("ST_IsClosed(ST_GeometryFromText(c0))", wkt);
-
-    if (wkt.has_value()) {
-      ASSERT_TRUE(result.has_value());
-      ASSERT_EQ(result.value(), expected.value());
-    } else {
-      ASSERT_FALSE(result.has_value());
-    }
-  };
-
-  testStIsClosedFunc("LINESTRING (1 1, 2 2, 1 3, 1 1)", true);
-  testStIsClosedFunc("LINESTRING (1 1, 2 2, 1 3)", false);
-  testStIsClosedFunc(
-      "MULTILINESTRING ((1 1, 2 2, 1 3, 1 1), (4 4, 5 5))", false);
-  testStIsClosedFunc(
+  assertResult<bool>("ST_IsClosed", "LINESTRING (1 1, 2 2, 1 3, 1 1)", true);
+  assertResult<bool>("ST_IsClosed", "LINESTRING (1 1, 2 2, 1 3)", false);
+  assertResult<bool>(
+      "ST_IsClosed",
+      "MULTILINESTRING ((1 1, 2 2, 1 3, 1 1), (4 4, 5 5))",
+      false);
+  assertResult<bool>(
+      "ST_IsClosed",
       "MULTILINESTRING ((1 1, 2 2, 1 3, 1 1), (4 4, 5 4, 5 5, 4 5, 4 4))",
       true);
 
   VELOX_ASSERT_USER_THROW(
-      testStIsClosedFunc("POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))", std::nullopt),
+      assertResult<bool>(
+          "ST_IsClosed", "POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))", std::nullopt),
       "ST_IsClosed only applies to LineString or MultiLineString. Input type is: Polygon");
 }
 
 TEST_F(GeometryFunctionsTest, testStIsEmpty) {
-  const auto testStIsClosedFunc = [&](const std::optional<std::string>& wkt,
-                                      const std::optional<bool>& expected) {
-    std::optional<bool> result =
-        evaluateOnce<bool>("ST_IsEmpty(ST_GeometryFromText(c0))", wkt);
-
-    if (wkt.has_value()) {
-      ASSERT_TRUE(result.has_value());
-      ASSERT_EQ(result.value(), expected.value());
-    } else {
-      ASSERT_FALSE(result.has_value());
-    }
-  };
-
-  testStIsClosedFunc("POINT (1.5 2.5)", false);
-  testStIsClosedFunc("POLYGON EMPTY", true);
+  assertResult<bool>("ST_IsEmpty", "POINT (1.5 2.5)", false);
+  assertResult<bool>("ST_IsEmpty", "POLYGON EMPTY", true);
 }
 
 TEST_F(GeometryFunctionsTest, testStIsRing) {
-  const auto testStIsRingFunc = [&](const std::optional<std::string>& wkt,
-                                    const std::optional<bool>& expected) {
-    std::optional<bool> result =
-        evaluateOnce<bool>("ST_IsRing(ST_GeometryFromText(c0))", wkt);
-
-    if (wkt.has_value()) {
-      ASSERT_TRUE(result.has_value());
-      ASSERT_EQ(result.value(), expected.value());
-    } else {
-      ASSERT_FALSE(result.has_value());
-    }
-  };
-
-  testStIsRingFunc("LINESTRING (8 4, 4 8)", false);
-  testStIsRingFunc("LINESTRING (0 0, 1 1, 0 2, 0 0)", true);
+  assertResult<bool>("ST_IsRing", "LINESTRING (8 4, 4 8)", false);
+  assertResult<bool>("ST_IsRing", "LINESTRING (0 0, 1 1, 0 2, 0 0)", true);
 
   VELOX_ASSERT_USER_THROW(
-      testStIsRingFunc("POLYGON ((2 0, 2 1, 3 1, 2 0))", true),
+      assertResult<bool>("ST_IsRing", "POLYGON ((2 0, 2 1, 3 1, 2 0))", true),
       "ST_IsRing only applies to LineString. Input type is: Polygon");
 }
 
 TEST_F(GeometryFunctionsTest, testStLength) {
-  const auto testStLengthFunc = [&](const std::optional<std::string>& wkt,
-                                    const std::optional<double>& expected) {
-    std::optional<double> result =
-        evaluateOnce<double>("ST_Length(ST_GeometryFromText(c0))", wkt);
-
-    if (wkt.has_value()) {
-      ASSERT_TRUE(result.has_value());
-      ASSERT_EQ(result.value(), expected.value());
-    } else {
-      ASSERT_FALSE(result.has_value());
-    }
-  };
-
-  testStLengthFunc("LINESTRING EMPTY", 0.0);
-  testStLengthFunc("LINESTRING (0 0, 2 2)", 2.8284271247461903);
-  testStLengthFunc("MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))", 6.0);
+  assertResult<double>("ST_Length", "LINESTRING EMPTY", 0.0);
+  assertResult<double>(
+      "ST_Length", "LINESTRING (0 0, 2 2)", 2.8284271247461903);
+  assertResult<double>(
+      "ST_Length", "MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))", 6.0);
 
   VELOX_ASSERT_USER_THROW(
-      testStLengthFunc("POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))", std::nullopt),
+      assertResult<double>(
+          "ST_Length", "POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))", std::nullopt),
       "ST_Length only applies to LineString or MultiLineString. Input type is: Polygon");
 }
 
@@ -1822,52 +1891,34 @@ TEST_F(GeometryFunctionsTest, testStPointN) {
 }
 
 TEST_F(GeometryFunctionsTest, testStStartPoint) {
-  const auto testStStartPointFunc =
-      [&](const std::optional<std::string>& wkt,
-          const std::optional<std::string>& expected) {
-        std::optional<std::string> result = evaluateOnce<std::string>(
-            "ST_AsText(ST_StartPoint(ST_GeometryFromText(c0)))", wkt);
-
-        if (expected.has_value()) {
-          ASSERT_TRUE(result.has_value());
-          ASSERT_EQ(result.value(), expected.value());
-        } else {
-          ASSERT_FALSE(result.has_value());
-        }
-      };
-
-  testStStartPointFunc("LINESTRING (8 4, 4 8, 5 6)", "POINT (8 4)");
-  testStStartPointFunc("LINESTRING (8 2, 4 12, 0 0)", "POINT (8 2)");
-  testStStartPointFunc("LINESTRING (0 0, 4 12, 2 2)", "POINT (0 0)");
-  testStStartPointFunc("LINESTRING EMPTY", std::nullopt);
+  assertResult<std::string>(
+      "ST_StartPoint", "LINESTRING (8 4, 4 8, 5 6)", "POINT (8 4)", true);
+  assertResult<std::string>(
+      "ST_StartPoint", "LINESTRING (8 2, 4 12, 0 0)", "POINT (8 2)", true);
+  assertResult<std::string>(
+      "ST_StartPoint", "LINESTRING (0 0, 4 12, 2 2)", "POINT (0 0)", true);
+  assertResult<std::string>(
+      "ST_StartPoint", "LINESTRING EMPTY", std::nullopt, true);
 
   VELOX_ASSERT_USER_THROW(
-      testStStartPointFunc("POINT (1 2)", std::nullopt),
+      assertResult<std::string>(
+          "ST_StartPoint", "POINT (1 2)", std::nullopt, true),
       "ST_StartPoint only applies to LineString. Input type is: Point");
 }
 
 TEST_F(GeometryFunctionsTest, testStEndPoint) {
-  const auto testStEndPointFunc =
-      [&](const std::optional<std::string>& wkt,
-          const std::optional<std::string>& expected) {
-        std::optional<std::string> result = evaluateOnce<std::string>(
-            "ST_AsText(ST_EndPoint(ST_GeometryFromText(c0)))", wkt);
-
-        if (expected.has_value()) {
-          ASSERT_TRUE(result.has_value());
-          ASSERT_EQ(result.value(), expected.value());
-        } else {
-          ASSERT_FALSE(result.has_value());
-        }
-      };
-
-  testStEndPointFunc("LINESTRING (8 4, 4 8, 5 6)", "POINT (5 6)");
-  testStEndPointFunc("LINESTRING (8 2, 4 12, 0 0)", "POINT (0 0)");
-  testStEndPointFunc("LINESTRING (0 0, 4 12, 2 2)", "POINT (2 2)");
-  testStEndPointFunc("LINESTRING EMPTY", std::nullopt);
+  assertResult<std::string>(
+      "ST_EndPoint", "LINESTRING (8 4, 4 8, 5 6)", "POINT (5 6)", true);
+  assertResult<std::string>(
+      "ST_EndPoint", "LINESTRING (8 2, 4 12, 0 0)", "POINT (0 0)", true);
+  assertResult<std::string>(
+      "ST_EndPoint", "LINESTRING (0 0, 4 12, 2 2)", "POINT (2 2)", true);
+  assertResult<std::string>(
+      "ST_EndPoint", "LINESTRING EMPTY", std::nullopt, true);
 
   VELOX_ASSERT_USER_THROW(
-      testStEndPointFunc("POINT (1 2)", std::nullopt),
+      assertResult<std::string>(
+          "ST_EndPoint", "POINT (1 2)", std::nullopt, true),
       "ST_EndPoint only applies to LineString. Input type is: Point");
 }
 
@@ -2006,208 +2057,228 @@ TEST_F(GeometryFunctionsTest, testStInteriorRingN) {
 }
 
 TEST_F(GeometryFunctionsTest, testStNumInteriorRing) {
-  const auto testStNumInteriorRingFunc =
-      [&](const std::optional<std::string>& wkt,
-          const std::optional<int32_t>& expected) {
-        std::optional<int32_t> result = evaluateOnce<int32_t>(
-            "ST_NumInteriorRing(ST_GeometryFromText(c0))", wkt);
-
-        if (expected.has_value()) {
-          ASSERT_TRUE(result.has_value());
-          ASSERT_EQ(result.value(), expected.value());
-        } else {
-          ASSERT_FALSE(result.has_value());
-        }
-      };
-
-  testStNumInteriorRingFunc("POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0))", 0);
-  testStNumInteriorRingFunc(
-      "POLYGON ((0 0, 8 0, 0 8, 0 0), (1 1, 1 5, 5 1, 1 1))", 1);
-  testStNumInteriorRingFunc("POLYGON EMPTY", std::nullopt);
+  assertResult<int64_t>(
+      "ST_NumInteriorRing", "POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0))", 0);
+  assertResult<int64_t>(
+      "ST_NumInteriorRing",
+      "POLYGON ((0 0, 8 0, 0 8, 0 0), (1 1, 1 5, 5 1, 1 1))",
+      1);
+  assertResult<int64_t>("ST_NumInteriorRing", "POLYGON EMPTY", std::nullopt);
 
   VELOX_ASSERT_USER_THROW(
-      testStNumInteriorRingFunc("LINESTRING (8 4, 5 7)", std::nullopt),
+      assertResult<int64_t>(
+          "ST_NumInteriorRing", "LINESTRING (8 4, 5 7)", std::nullopt),
       "ST_NumInteriorRing only applies to Polygon. Input type is: LineString");
 }
 
 TEST_F(GeometryFunctionsTest, testStNumGeometries) {
-  const auto testStNumGeometriesFunc =
-      [&](const std::optional<std::string>& wkt,
-          const std::optional<int32_t>& expected) {
-        std::optional<int32_t> result = evaluateOnce<int32_t>(
-            "ST_NumGeometries(ST_GeometryFromText(c0))", wkt);
-
-        if (expected.has_value()) {
-          ASSERT_TRUE(result.has_value());
-          ASSERT_EQ(result.value(), expected.value());
-        } else {
-          ASSERT_FALSE(result.has_value());
-        }
-      };
-
   // GeometryCollections with only empty geometries always return 0
-  testStNumGeometriesFunc("GEOMETRYCOLLECTION (POINT EMPTY, POINT EMPTY)", 0);
-  testStNumGeometriesFunc("GEOMETRYCOLLECTION (POINT EMPTY)", 0);
+  assertResult<int32_t>(
+      "ST_NumGeometries", "GEOMETRYCOLLECTION (POINT EMPTY, POINT EMPTY)", 0);
+  assertResult<int32_t>(
+      "ST_NumGeometries", "GEOMETRYCOLLECTION (POINT EMPTY)", 0);
   // GeometryCollections with at least 1 non-empty geometry return the number of
   // geometries
-  testStNumGeometriesFunc("GEOMETRYCOLLECTION(POINT EMPTY, POINT (1 2))", 2);
-
-  testStNumGeometriesFunc("POINT EMPTY", 0);
-  testStNumGeometriesFunc("GEOMETRYCOLLECTION EMPTY", 0);
-  testStNumGeometriesFunc("MULTIPOLYGON EMPTY", 0);
-  testStNumGeometriesFunc("POINT (1 2)", 1);
-  testStNumGeometriesFunc(
-      "LINESTRING(77.29 29.07,77.42 29.26,77.27 29.31,77.29 29.07)", 1);
-  testStNumGeometriesFunc("POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))", 1);
-  testStNumGeometriesFunc("MULTIPOINT (1 2, 2 4, 3 6, 4 8)", 4);
-  testStNumGeometriesFunc("MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))", 2);
-  testStNumGeometriesFunc(
+  assertResult<int32_t>(
+      "ST_NumGeometries", "GEOMETRYCOLLECTION(POINT EMPTY, POINT (1 2))", 2);
+
+  assertResult<int32_t>("ST_NumGeometries", "POINT EMPTY", 0);
+  assertResult<int32_t>("ST_NumGeometries", "GEOMETRYCOLLECTION EMPTY", 0);
+  assertResult<int32_t>("ST_NumGeometries", "MULTIPOLYGON EMPTY", 0);
+  assertResult<int32_t>("ST_NumGeometries", "POINT (1 2)", 1);
+  assertResult<int32_t>(
+      "ST_NumGeometries",
+      "LINESTRING(77.29 29.07,77.42 29.26,77.27 29.31,77.29 29.07)",
+      1);
+  assertResult<int32_t>(
+      "ST_NumGeometries", "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))", 1);
+  assertResult<int32_t>(
+      "ST_NumGeometries", "MULTIPOINT (1 2, 2 4, 3 6, 4 8)", 4);
+  assertResult<int32_t>(
+      "ST_NumGeometries", "MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))", 2);
+  assertResult<int32_t>(
+      "ST_NumGeometries",
       "MULTIPOLYGON (((1 1, 1 3, 3 3, 3 1, 1 1)), ((2 4, 2 6, 6 6, 6 4, 2 4)))",
       2);
-  testStNumGeometriesFunc(
-      "GEOMETRYCOLLECTION(POINT(2 3), LINESTRING (2 3, 3 4))", 2);
+  assertResult<int32_t>(
+      "ST_NumGeometries",
+      "GEOMETRYCOLLECTION(POINT(2 3), LINESTRING (2 3, 3 4))",
+      2);
 }
 
 TEST_F(GeometryFunctionsTest, testStConvexHull) {
-  const auto testStConvexHullFunc =
-      [&](const std::optional<std::string>& wkt,
-          const std::optional<std::string>& expected) {
-        std::optional<std::string> result = evaluateOnce<std::string>(
-            "ST_AsText(ST_ConvexHull(ST_GeometryFromText(c0)))", wkt);
-
-        if (expected.has_value()) {
-          ASSERT_TRUE(result.has_value());
-          ASSERT_EQ(result.value(), expected.value());
-        } else {
-          ASSERT_FALSE(result.has_value());
-        }
-      };
-
   // test empty geometry
-  testStConvexHullFunc("POINT EMPTY", "POINT EMPTY");
-  testStConvexHullFunc(
-      "GEOMETRYCOLLECTION (POINT (1 1), POINT EMPTY)", "POINT (1 1)");
-  testStConvexHullFunc(
+  assertResult<std::string>(
+      "ST_ConvexHull", "POINT EMPTY", "POINT EMPTY", true);
+  assertResult<std::string>(
+      "ST_ConvexHull",
+      "GEOMETRYCOLLECTION (POINT (1 1), POINT EMPTY)",
+      "POINT (1 1)",
+      true);
+  assertResult<std::string>(
+      "ST_ConvexHull",
       "GEOMETRYCOLLECTION (GEOMETRYCOLLECTION (POINT (1 1), GEOMETRYCOLLECTION (POINT (1 5), POINT (4 5), GEOMETRYCOLLECTION (POINT (3 4), POINT EMPTY))))",
-      "POLYGON ((1 1, 1 5, 4 5, 1 1))");
+      "POLYGON ((1 1, 1 5, 4 5, 1 1))",
+      true);
 
   // test single geometry
-  testStConvexHullFunc("POINT (1 1)", "POINT (1 1)");
-  testStConvexHullFunc(
-      "LINESTRING (1 1, 1 9, 2 2)", "POLYGON ((1 1, 1 9, 2 2, 1 1))");
+  assertResult<std::string>(
+      "ST_ConvexHull", "POINT (1 1)", "POINT (1 1)", true);
+  assertResult<std::string>(
+      "ST_ConvexHull",
+      "LINESTRING (1 1, 1 9, 2 2)",
+      "POLYGON ((1 1, 1 9, 2 2, 1 1))",
+      true);
 
   // convex single geometry
-  testStConvexHullFunc(
-      "LINESTRING (1 1, 1 9, 2 2, 1 1)", "POLYGON ((1 1, 1 9, 2 2, 1 1))");
-  testStConvexHullFunc(
+  assertResult<std::string>(
+      "ST_ConvexHull",
+      "LINESTRING (1 1, 1 9, 2 2, 1 1)",
+      "POLYGON ((1 1, 1 9, 2 2, 1 1))",
+      true);
+  assertResult<std::string>(
+      "ST_ConvexHull",
       "POLYGON ((0 0, 0 3, 2 4, 4 2, 3 0, 0 0))",
-      "POLYGON ((0 0, 0 3, 2 4, 4 2, 3 0, 0 0))");
+      "POLYGON ((0 0, 0 3, 2 4, 4 2, 3 0, 0 0))",
+      true);
 
   // non-convex geometry
-  testStConvexHullFunc(
-      "LINESTRING (1 1, 1 9, 2 2, 1 1, 4 0)", "POLYGON ((4 0, 1 1, 1 9, 4 0))");
-  testStConvexHullFunc(
+  assertResult<std::string>(
+      "ST_ConvexHull",
+      "LINESTRING (1 1, 1 9, 2 2, 1 1, 4 0)",
+      "POLYGON ((4 0, 1 1, 1 9, 4 0))",
+      true);
+  assertResult<std::string>(
+      "ST_ConvexHull",
       "POLYGON ((0 0, 0 3, 4 4, 1 1, 3 0, 0 0))",
-      "POLYGON ((0 0, 0 3, 4 4, 3 0, 0 0))");
+      "POLYGON ((0 0, 0 3, 4 4, 3 0, 0 0))",
+      true);
 
   // all points are on the same line
-  testStConvexHullFunc(
-      "LINESTRING (20 20, 30 30)", "LINESTRING (20 20, 30 30)");
-  testStConvexHullFunc(
+  assertResult<std::string>(
+      "ST_ConvexHull",
+      "LINESTRING (20 20, 30 30)",
+      "LINESTRING (20 20, 30 30)",
+      true);
+  assertResult<std::string>(
+      "ST_ConvexHull",
       "MULTILINESTRING ((0 0, 3 3), (1 1, 2 2), (2 2, 4 4), (5 5, 8 8))",
-      "LINESTRING (0 0, 8 8)");
-  testStConvexHullFunc(
-      "MULTIPOINT (0 1, 1 2, 2 3, 3 4, 4 5, 5 6)", "LINESTRING (0 1, 5 6)");
-  testStConvexHullFunc(
+      "LINESTRING (0 0, 8 8)",
+      true);
+  assertResult<std::string>(
+      "ST_ConvexHull",
+      "MULTIPOINT (0 1, 1 2, 2 3, 3 4, 4 5, 5 6)",
+      "LINESTRING (0 1, 5 6)",
+      true);
+  assertResult<std::string>(
+      "ST_ConvexHull",
       "GEOMETRYCOLLECTION (GEOMETRYCOLLECTION (POINT (2 2), POINT (1 1)), POINT(3 3))",
-      "LINESTRING (1 1, 3 3)");
+      "LINESTRING (1 1, 3 3)",
+      true);
 
   // not all points are on the same line
-  testStConvexHullFunc(
+  assertResult<std::string>(
+      "ST_ConvexHull",
       "MULTILINESTRING ((1 1, 5 1, 6 6), (2 4, 4 0), (2 -4, 4 4), (3 -2, 4 -3))",
-      "POLYGON ((2 -4, 1 1, 2 4, 6 6, 5 1, 4 -3, 2 -4))");
-  testStConvexHullFunc(
+      "POLYGON ((2 -4, 1 1, 2 4, 6 6, 5 1, 4 -3, 2 -4))",
+      true);
+  assertResult<std::string>(
+      "ST_ConvexHull",
       "MULTIPOINT (0 2, 1 0, 3 0, 4 0, 4 2, 2 2, 2 4)",
-      "POLYGON ((1 0, 0 2, 2 4, 4 2, 4 0, 1 0))");
-  testStConvexHullFunc(
+      "POLYGON ((1 0, 0 2, 2 4, 4 2, 4 0, 1 0))",
+      true);
+  assertResult<std::string>(
+      "ST_ConvexHull",
       "MULTIPOLYGON (((0 3, 2 0, 3 6, 0 3), (2 1, 2 3, 5 3, 5 1, 2 1), (1 7, 2 4, 4 2, 5 6, 3 8, 1 7)))",
-      "POLYGON ((2 0, 0 3, 1 7, 3 8, 5 6, 5 1, 2 0))");
-  testStConvexHullFunc(
+      "POLYGON ((2 0, 0 3, 1 7, 3 8, 5 6, 5 1, 2 0))",
+      true);
+  assertResult<std::string>(
+      "ST_ConvexHull",
       "GEOMETRYCOLLECTION (POINT (2 3), LINESTRING (2 8, 7 10), POINT (8 10), POLYGON ((4 4, 4 8, 9 8, 6 6, 6 4, 8 3, 6 1, 4 4)), POINT (4 2), LINESTRING (3 6, 5 5), POLYGON ((7 5, 7 6, 8 6, 8 5, 7 5)))",
-      "POLYGON ((6 1, 2 3, 2 8, 7 10, 8 10, 9 8, 8 3, 6 1))");
-  testStConvexHullFunc(
+      "POLYGON ((6 1, 2 3, 2 8, 7 10, 8 10, 9 8, 8 3, 6 1))",
+      true);
+  assertResult<std::string>(
+      "ST_ConvexHull",
       "GEOMETRYCOLLECTION (GEOMETRYCOLLECTION (POINT (2 3), LINESTRING (2 8, 7 10), GEOMETRYCOLLECTION (POINT (8 10))), POLYGON ((4 4, 4 8, 9 8, 6 6, 6 4, 8 3, 6 1, 4 4)), POINT (4 2), LINESTRING (3 6, 5 5), POLYGON ((7 5, 7 6, 8 6, 8 5, 7 5)))",
-      "POLYGON ((6 1, 2 3, 2 8, 7 10, 8 10, 9 8, 8 3, 6 1))");
+      "POLYGON ((6 1, 2 3, 2 8, 7 10, 8 10, 9 8, 8 3, 6 1))",
+      true);
 
   // single-element multi-geometries and geometry collections
-  testStConvexHullFunc(
-      "MULTILINESTRING ((1 1, 5 1, 6 6))", "POLYGON ((1 1, 6 6, 5 1, 1 1))");
-  testStConvexHullFunc(
+  assertResult<std::string>(
+      "ST_ConvexHull",
+      "MULTILINESTRING ((1 1, 5 1, 6 6))",
+      "POLYGON ((1 1, 6 6, 5 1, 1 1))",
+      true);
+  assertResult<std::string>(
+      "ST_ConvexHull",
       "MULTILINESTRING ((1 1, 5 1, 1 4, 5 4))",
-      "POLYGON ((1 1, 1 4, 5 4, 5 1, 1 1))");
-  testStConvexHullFunc("MULTIPOINT (0 2)", "POINT (0 2)");
-  testStConvexHullFunc(
+      "POLYGON ((1 1, 1 4, 5 4, 5 1, 1 1))",
+      true);
+  assertResult<std::string>(
+      "ST_ConvexHull", "MULTIPOINT (0 2)", "POINT (0 2)", true);
+  assertResult<std::string>(
+      "ST_ConvexHull",
       "MULTIPOLYGON (((0 3, 3 6, 2 0, 0 3)))",
-      "POLYGON ((2 0, 0 3, 3 6, 2 0))");
-  testStConvexHullFunc(
+      "POLYGON ((2 0, 0 3, 3 6, 2 0))",
+      true);
+  assertResult<std::string>(
+      "ST_ConvexHull",
       "MULTIPOLYGON (((0 0, 4 0, 4 4, 0 4, 2 2, 0 0)))",
-      "POLYGON ((0 0, 0 4, 4 4, 4 0, 0 0))");
-  testStConvexHullFunc("GEOMETRYCOLLECTION (POINT (2 3))", "POINT (2 3)");
-  testStConvexHullFunc(
+      "POLYGON ((0 0, 0 4, 4 4, 4 0, 0 0))",
+      true);
+  assertResult<std::string>(
+      "ST_ConvexHull", "GEOMETRYCOLLECTION (POINT (2 3))", "POINT (2 3)", true);
+  assertResult<std::string>(
+      "ST_ConvexHull",
       "GEOMETRYCOLLECTION (LINESTRING (1 1, 5 1, 6 6))",
-      "POLYGON ((1 1, 6 6, 5 1, 1 1))");
-  testStConvexHullFunc(
+      "POLYGON ((1 1, 6 6, 5 1, 1 1))",
+      true);
+  assertResult<std::string>(
+      "ST_ConvexHull",
       "GEOMETRYCOLLECTION (LINESTRING (1 1, 5 1, 1 4, 5 4))",
-      "POLYGON ((1 1, 1 4, 5 4, 5 1, 1 1))");
-  testStConvexHullFunc(
+      "POLYGON ((1 1, 1 4, 5 4, 5 1, 1 1))",
+      true);
+  assertResult<std::string>(
+      "ST_ConvexHull",
       "GEOMETRYCOLLECTION (POLYGON ((0 3, 3 6, 2 0, 0 3)))",
-      "POLYGON ((2 0, 0 3, 3 6, 2 0))");
-  testStConvexHullFunc(
+      "POLYGON ((2 0, 0 3, 3 6, 2 0))",
+      true);
+  assertResult<std::string>(
+      "ST_ConvexHull",
       "GEOMETRYCOLLECTION (POLYGON ((0 0, 4 0, 4 4, 0 4, 2 2, 0 0)))",
-      "POLYGON ((0 0, 0 4, 4 4, 4 0, 0 0))");
+      "POLYGON ((0 0, 0 4, 4 4, 4 0, 0 0))",
+      true);
+
+  // Geometries that should be bounded by a line or point
+  assertResult<std::string>(
+      "ST_ConvexHull", "LINESTRING (20 20, 20 20)", "POINT (20 20)", true);
+  assertResult<std::string>(
+      "ST_ConvexHull",
+      "POLYGON ((20 20, 20 20, 20 20, 20 20))",
+      "POINT (20 20)",
+      true);
+  assertResult<std::string>(
+      "ST_ConvexHull",
+      "POLYGON ((0 0, 0 20, 0 40, 0 60, 0 0))",
+      "LINESTRING (0 0, 0 60)",
+      true);
 }
 
 TEST_F(GeometryFunctionsTest, testStCoordDim) {
-  const auto testStCoordDimFunc = [&](const std::optional<std::string>& wkt,
-                                      const std::optional<int32_t>& expected) {
-    std::optional<int32_t> result =
-        evaluateOnce<int32_t>("ST_CoordDim(ST_GeometryFromText(c0))", wkt);
-
-    if (expected.has_value()) {
-      ASSERT_TRUE(result.has_value());
-      ASSERT_EQ(result.value(), expected.value());
-    } else {
-      ASSERT_FALSE(result.has_value());
-    }
-  };
-
-  testStCoordDimFunc("POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))", 2);
-  testStCoordDimFunc("POLYGON EMPTY))", 2);
-  testStCoordDimFunc("LINESTRING (1 1, 1 2)", 2);
-  testStCoordDimFunc("POINT (1 4)", 2);
-
-  testStCoordDimFunc("LINESTRING EMPTY", 2);
+  assertResult<int8_t>("ST_CoordDim", "POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))", 2);
+  assertResult<int8_t>("ST_CoordDim", "POLYGON EMPTY))", 2);
+  assertResult<int8_t>("ST_CoordDim", "LINESTRING (1 1, 1 2)", 2);
+  assertResult<int8_t>("ST_CoordDim", "POINT (1 4)", 2);
+  assertResult<int8_t>("ST_CoordDim", "LINESTRING EMPTY", 2);
 }
 
 TEST_F(GeometryFunctionsTest, testStDimension) {
-  const auto testStDimensionFunc = [&](const std::optional<std::string>& wkt,
-                                       const std::optional<int8_t>& expected) {
-    std::optional<int8_t> result =
-        evaluateOnce<int8_t>("ST_Dimension(ST_GeometryFromText(c0))", wkt);
-
-    if (expected.has_value()) {
-      ASSERT_TRUE(result.has_value());
-      ASSERT_EQ(result.value(), expected.value());
-    } else {
-      ASSERT_FALSE(result.has_value());
-    }
-  };
-
-  testStDimensionFunc("POLYGON EMPTY", 2);
-  testStDimensionFunc("POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))", 2);
-  testStDimensionFunc("LINESTRING EMPTY", 1);
-  testStDimensionFunc("POINT (1 4))", 0);
-}
+  assertResult<int8_t>("ST_Dimension", "POLYGON EMPTY", 2);
+  assertResult<int8_t>(
+      "ST_Dimension", "POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))", 2);
+  assertResult<int8_t>("ST_Dimension", "LINESTRING EMPTY", 1);
+  assertResult<int8_t>("ST_Dimension", "POINT (1 4))", 0);
+}
 
 TEST_F(GeometryFunctionsTest, testStBuffer) {
   const auto testStBufferFunc =
@@ -2263,71 +2334,95 @@ TEST_F(GeometryFunctionsTest, testStBuffer) {
 }
 
 TEST_F(GeometryFunctionsTest, testStExteriorRing) {
-  const auto testStExteriorRingFunc =
-      [&](const std::optional<std::string>& wkt,
-          const std::optional<std::string>& expected) {
-        std::optional<std::string> result = evaluateOnce<std::string>(
-            "ST_AsText(ST_ExteriorRing(ST_GeometryFromText(c0)))", wkt);
-
-        if (expected.has_value()) {
-          ASSERT_TRUE(result.has_value());
-          ASSERT_EQ(result.value(), expected.value());
-        } else {
-          ASSERT_FALSE(result.has_value());
-        }
-      };
-
-  testStExteriorRingFunc("POLYGON EMPTY", std::nullopt);
-  testStExteriorRingFunc(
-      "POLYGON ((1 1, 1 4, 4 1, 1 1))", "LINESTRING (1 1, 1 4, 4 1, 1 1)");
-
-  testStExteriorRingFunc(
+  assertResult<std::string>(
+      "ST_ExteriorRing", "POLYGON EMPTY", std::nullopt, true);
+  assertResult<std::string>(
+      "ST_ExteriorRing",
+      "POLYGON ((1 1, 1 4, 4 1, 1 1))",
+      "LINESTRING (1 1, 1 4, 4 1, 1 1)",
+      true);
+  assertResult<std::string>(
+      "ST_ExteriorRing",
       "POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0), (1 1, 1 2, 2 2, 2 1, 1 1))",
-      "LINESTRING (0 0, 0 5, 5 5, 5 0, 0 0)");
+      "LINESTRING (0 0, 0 5, 5 5, 5 0, 0 0)",
+      true);
 
   VELOX_ASSERT_USER_THROW(
-      testStExteriorRingFunc("LINESTRING (1 1, 2 2, 1 3)", std::nullopt),
+      assertResult<std::string>(
+          "ST_ExteriorRing", "LINESTRING (1 1, 2 2, 1 3)", std::nullopt, true),
       "ST_ExteriorRing only applies to Polygon. Input type is: LineString");
   VELOX_ASSERT_USER_THROW(
-      testStExteriorRingFunc(
+      assertResult<std::string>(
+          "ST_ExteriorRing",
           "MULTIPOLYGON (((1 1, 2 2, 1 3, 1 1)), ((4 4, 5 5, 4 6, 4 4)))",
-          std::nullopt),
+          std::nullopt,
+          true),
       "ST_ExteriorRing only applies to Polygon. Input type is: MultiPolygon");
 }
 
 TEST_F(GeometryFunctionsTest, testStEnvelope) {
-  const auto testStEnvelopeFunc =
-      [&](const std::optional<std::string>& wkt,
-          const std::optional<std::string>& expected) {
-        std::optional<std::string> result = evaluateOnce<std::string>(
-            "ST_AsText(ST_Envelope(ST_GeometryFromText(c0)))", wkt);
-
-        if (expected.has_value()) {
-          ASSERT_TRUE(result.has_value());
-          ASSERT_EQ(result.value(), expected.value());
-        } else {
-          ASSERT_FALSE(result.has_value());
-        }
-      };
-
-  testStEnvelopeFunc(
-      "MULTIPOINT (1 2, 2 4, 3 6, 4 8)", "POLYGON ((1 2, 1 8, 4 8, 4 2, 1 2))");
-  testStEnvelopeFunc("LINESTRING EMPTY", "POLYGON EMPTY");
-  testStEnvelopeFunc(
-      "LINESTRING (1 1, 2 2, 1 3)", "POLYGON ((1 1, 1 3, 2 3, 2 1, 1 1))");
-  testStEnvelopeFunc(
-      "LINESTRING (8 4, 5 7)", "POLYGON ((5 4, 5 7, 8 7, 8 4, 5 4))");
-  testStEnvelopeFunc(
+  assertResult<std::string>(
+      "st_envelope",
+      "MULTIPOINT (1 2, 2 4, 3 6, 4 8)",
+      "POLYGON ((1 2, 1 8, 4 8, 4 2, 1 2))",
+      true);
+  assertResult<std::string>(
+      "st_envelope",
+      "LINESTRING (1 1, 2 2, 1 3)",
+      "POLYGON ((1 1, 1 3, 2 3, 2 1, 1 1))",
+      true);
+  assertResult<std::string>(
+      "st_envelope",
+      "LINESTRING (8 4, 5 7)",
+      "POLYGON ((5 4, 5 7, 8 7, 8 4, 5 4))",
+      true);
+  assertResult<std::string>(
+      "st_envelope",
       "MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))",
-      "POLYGON ((1 1, 1 4, 5 4, 5 1, 1 1))");
-  testStEnvelopeFunc(
-      "POLYGON ((1 1, 4 1, 1 4, 1 1))", "POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))");
-  testStEnvelopeFunc(
+      "POLYGON ((1 1, 1 4, 5 4, 5 1, 1 1))",
+      true);
+  assertResult<std::string>(
+      "st_envelope",
+      "POLYGON ((1 1, 4 1, 1 4, 1 1))",
+      "POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))",
+      true);
+  assertResult<std::string>(
+      "st_envelope",
       "MULTIPOLYGON (((1 1, 1 3, 3 3, 3 1, 1 1)), ((0 0, 0 2, 2 2, 2 0, 0 0)))",
-      "POLYGON ((0 0, 0 3, 3 3, 3 0, 0 0))");
-  testStEnvelopeFunc(
+      "POLYGON ((0 0, 0 3, 3 3, 3 0, 0 0))",
+      true);
+  assertResult<std::string>(
+      "st_envelope",
       "GEOMETRYCOLLECTION (POINT (5 1), LINESTRING (3 4, 4 4))",
-      "POLYGON ((3 1, 3 4, 5 4, 5 1, 3 1))");
+      "POLYGON ((3 1, 3 4, 5 4, 5 1, 3 1))",
+      true);
+  assertResult<std::string>(
+      "st_envelope",
+      "MULTIPOLYGON (((119.094024 -27.2871725, 119.094124 -27.2846569, 119.094124 -27.2868119, 119.094024 -27.2871725)))",
+      "POLYGON ((119.094024 -27.2871725, 119.094024 -27.2846569, 119.094124 -27.2846569, 119.094124 -27.2871725, 119.094024 -27.2871725))",
+      true);
+
+  // Zero area envelope is valid
+  assertResult<std::string>(
+      "st_envelope",
+      "LINESTRING (1 1, 1 2)",
+      "POLYGON ((1 1, 1 2, 1 2, 1 1, 1 1))",
+      true);
+
+  assertResult<std::string>(
+      "st_envelope", "POLYGON EMPTY", "POLYGON EMPTY", true);
+  assertResult<std::string>(
+      "st_envelope", "MULTIPOLYGON EMPTY", "POLYGON EMPTY", true);
+  assertResult<std::string>(
+      "st_envelope", "GEOMETRYCOLLECTION EMPTY", "POLYGON EMPTY", true);
+  assertResult<std::string>(
+      "st_envelope", "POINT EMPTY", "POLYGON EMPTY", true);
+  assertResult<std::string>(
+      "st_envelope", "MULTIPOINT EMPTY", "POLYGON EMPTY", true);
+  assertResult<std::string>(
+      "st_envelope", "LINESTRING EMPTY", "POLYGON EMPTY", true);
+  assertResult<std::string>(
+      "st_envelope", "MULTILINESTRING EMPTY", "POLYGON EMPTY", true);
 }
 
 TEST_F(GeometryFunctionsTest, testStPoints) {
@@ -2484,38 +2579,30 @@ TEST_F(GeometryFunctionsTest, testStEnvelopeAsPts) {
 }
 
 TEST_F(GeometryFunctionsTest, testStNumPoints) {
-  const auto testStNumPointsFunc = [&](const std::optional<std::string>& wkt,
-                                       const std::optional<int32_t>& expected) {
-    std::optional<int32_t> result =
-        evaluateOnce<int32_t>("ST_NumPoints(ST_GeometryFromText(c0))", wkt);
-
-    if (expected.has_value()) {
-      ASSERT_TRUE(result.has_value());
-      ASSERT_EQ(result.value(), expected.value());
-    } else {
-      ASSERT_FALSE(result.has_value());
-    }
-  };
-
-  testStNumPointsFunc("POINT EMPTY", 0);
-  testStNumPointsFunc("MULTIPOINT EMPTY", 0);
-  testStNumPointsFunc("LINESTRING EMPTY", 0);
-  testStNumPointsFunc("MULTILINESTRING EMPTY", 0);
-  testStNumPointsFunc("POLYGON EMPTY", 0);
-  testStNumPointsFunc("MULTIPOLYGON EMPTY", 0);
-  testStNumPointsFunc("GEOMETRYCOLLECTION EMPTY", 0);
-
-  testStNumPointsFunc("POINT (1 2)", 1);
-  testStNumPointsFunc("MULTIPOINT (1 2, 2 4, 3 6, 4 8)", 4);
-  testStNumPointsFunc("LINESTRING (8 4, 5 7)", 2);
-  testStNumPointsFunc("MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))", 4);
-  testStNumPointsFunc("POLYGON ((0 0, 8 0, 0 8, 0 0))", 3);
-  testStNumPointsFunc(
-      "POLYGON ((0 0, 8 0, 0 8, 0 0), (1 1, 1 5, 5 1, 1 1))", 6);
-  testStNumPointsFunc(
+  assertResult<int64_t>("ST_NumPoints", "POINT EMPTY", 0);
+  assertResult<int64_t>("ST_NumPoints", "MULTIPOINT EMPTY", 0);
+  assertResult<int64_t>("ST_NumPoints", "LINESTRING EMPTY", 0);
+  assertResult<int64_t>("ST_NumPoints", "MULTILINESTRING EMPTY", 0);
+  assertResult<int64_t>("ST_NumPoints", "POLYGON EMPTY", 0);
+  assertResult<int64_t>("ST_NumPoints", "MULTIPOLYGON EMPTY", 0);
+  assertResult<int64_t>("ST_NumPoints", "GEOMETRYCOLLECTION EMPTY", 0);
+
+  assertResult<int64_t>("ST_NumPoints", "POINT (1 2)", 1);
+  assertResult<int64_t>("ST_NumPoints", "MULTIPOINT (1 2, 2 4, 3 6, 4 8)", 4);
+  assertResult<int64_t>("ST_NumPoints", "LINESTRING (8 4, 5 7)", 2);
+  assertResult<int64_t>(
+      "ST_NumPoints", "MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))", 4);
+  assertResult<int64_t>("ST_NumPoints", "POLYGON ((0 0, 8 0, 0 8, 0 0))", 3);
+  assertResult<int64_t>(
+      "ST_NumPoints",
+      "POLYGON ((0 0, 8 0, 0 8, 0 0), (1 1, 1 5, 5 1, 1 1))",
+      6);
+  assertResult<int64_t>(
+      "ST_NumPoints",
       "MULTIPOLYGON (((1 1, 1 3, 3 3, 3 1, 1 1)), ((2 4, 2 6, 6 6, 6 4, 2 4)))",
       8);
-  testStNumPointsFunc(
+  assertResult<int64_t>(
+      "ST_NumPoints",
       "GEOMETRYCOLLECTION (POINT (1 1), GEOMETRYCOLLECTION (LINESTRING (0 0, 1 1), GEOMETRYCOLLECTION (POLYGON ((2 2, 2 3, 3 3, 3 2, 2 2)))))",
       7);
 }
@@ -3228,39 +3315,27 @@ TEST_F(GeometryFunctionsTest, testGeometryToBingTiles) {
   // Geometries at boundaries of tiles
   testGeometryToBingTilesFunc("POINT (0 0)", 1, {{"3"}});
   testGeometryToBingTilesFunc(
-      fmt::format("POINT ({} 0)", BingTileType::kMinLongitude), 1, {{"2"}});
+      fmt::format("POINT ({} 0)", kMinLongitude), 1, {{"2"}});
   testGeometryToBingTilesFunc(
-      fmt::format("POINT ({} 0)", BingTileType::kMaxLongitude), 1, {{"3"}});
+      fmt::format("POINT ({} 0)", kMaxLongitude), 1, {{"3"}});
   testGeometryToBingTilesFunc(
-      fmt::format("POINT (0 {})", BingTileType::kMinLatitude), 1, {{"3"}});
+      fmt::format("POINT (0 {})", kMinBingTileLatitude), 1, {{"3"}});
   testGeometryToBingTilesFunc(
-      fmt::format("POINT (0 {})", BingTileType::kMaxLatitude), 1, {{"1"}});
+      fmt::format("POINT (0 {})", kMaxBingTileLatitude), 1, {{"1"}});
   testGeometryToBingTilesFunc(
-      fmt::format(
-          "POINT ({} {})",
-          BingTileType::kMinLongitude,
-          BingTileType::kMinLatitude),
+      fmt::format("POINT ({} {})", kMinLongitude, kMinBingTileLatitude),
       1,
       {{"2"}});
   testGeometryToBingTilesFunc(
-      fmt::format(
-          "POINT ({} {})",
-          BingTileType::kMinLongitude,
-          BingTileType::kMaxLatitude),
+      fmt::format("POINT ({} {})", kMinLongitude, kMaxBingTileLatitude),
       1,
       {{"0"}});
   testGeometryToBingTilesFunc(
-      fmt::format(
-          "POINT ({} {})",
-          BingTileType::kMaxLongitude,
-          BingTileType::kMaxLatitude),
+      fmt::format("POINT ({} {})", kMaxLongitude, kMaxBingTileLatitude),
       1,
       {{"1"}});
   testGeometryToBingTilesFunc(
-      fmt::format(
-          "POINT ({} {})",
-          BingTileType::kMaxLongitude,
-          BingTileType::kMinLatitude),
+      fmt::format("POINT ({} {})", kMaxLongitude, kMinBingTileLatitude),
       1,
       {{"3"}});
   testGeometryToBingTilesFunc("LINESTRING (-1 0, -2 0)", 1, {{"2"}});
@@ -3268,31 +3343,19 @@ TEST_F(GeometryFunctionsTest, testGeometryToBingTiles) {
   testGeometryToBingTilesFunc("LINESTRING (0 -1, 0 -2)", 1, {{"3"}});
   testGeometryToBingTilesFunc("LINESTRING (0 1, 0 2)", 1, {{"1"}});
   testGeometryToBingTilesFunc(
-      fmt::format(
-          "LINESTRING ({} 1, {} 2)",
-          BingTileType::kMinLongitude,
-          BingTileType::kMinLongitude),
+      fmt::format("LINESTRING ({} 1, {} 2)", kMinLongitude, kMinLongitude),
       1,
       {{"0"}});
   testGeometryToBingTilesFunc(
-      fmt::format(
-          "LINESTRING ({} -1, {} -2)",
-          BingTileType::kMinLongitude,
-          BingTileType::kMinLongitude),
+      fmt::format("LINESTRING ({} -1, {} -2)", kMinLongitude, kMinLongitude),
       1,
       {{"2"}});
   testGeometryToBingTilesFunc(
-      fmt::format(
-          "LINESTRING ({} 1, {} 2)",
-          BingTileType::kMaxLongitude,
-          BingTileType::kMaxLongitude),
+      fmt::format("LINESTRING ({} 1, {} 2)", kMaxLongitude, kMaxLongitude),
       1,
       {{"1"}});
   testGeometryToBingTilesFunc(
-      fmt::format(
-          "LINESTRING ({} -1, {} -2)",
-          BingTileType::kMaxLongitude,
-          BingTileType::kMaxLongitude),
+      fmt::format("LINESTRING ({} -1, {} -2)", kMaxLongitude, kMaxLongitude),
       1,
       {{"3"}});
 
@@ -3368,9 +3431,12 @@ TEST_F(GeometryFunctionsTest, testGeometryToBingTiles) {
       "POLYGON ((0 0, 0 10, 10 10, 0 0))", 1, {{"1", "3"}});
 
   // Empty geometries
-  testGeometryToBingTilesFunc("POINT EMPTY", 10, {{}});
-  testGeometryToBingTilesFunc("POLYGON EMPTY", 10, {{}});
-  testGeometryToBingTilesFunc("GEOMETRYCOLLECTION EMPTY", 10, {{}});
+  testGeometryToBingTilesFunc(
+      "POINT EMPTY", 10, common::testutil::optionalEmpty);
+  testGeometryToBingTilesFunc(
+      "POLYGON EMPTY", 10, common::testutil::optionalEmpty);
+  testGeometryToBingTilesFunc(
+      "GEOMETRYCOLLECTION EMPTY", 10, common::testutil::optionalEmpty);
 
   // Geometries at MIN_LONGITUDE/MAX_LATITUDE
   testGeometryToBingTilesFunc(
@@ -3378,14 +3444,11 @@ TEST_F(GeometryFunctionsTest, testGeometryToBingTiles) {
       8,
       {{"22200000"}});
   testGeometryToBingTilesFunc(
-      fmt::format("POINT ({} 0)", BingTileType::kMinLongitude), 5, {{"20000"}});
+      fmt::format("POINT ({} 0)", kMinLongitude), 5, {{"20000"}});
   testGeometryToBingTilesFunc(
-      fmt::format("POINT (0 {})", BingTileType::kMaxLatitude), 5, {{"10000"}});
+      fmt::format("POINT (0 {})", kMaxBingTileLatitude), 5, {{"10000"}});
   testGeometryToBingTilesFunc(
-      fmt::format(
-          "POINT ({} {})",
-          BingTileType::kMinLongitude,
-          BingTileType::kMaxLatitude),
+      fmt::format("POINT ({} {})", kMinLongitude, kMaxBingTileLatitude),
       5,
       {{"00000"}});
 
@@ -3454,3 +3517,1096 @@ TEST_F(GeometryFunctionsTest, testGeometryToBingTiles) {
           std::optional<std::string>("POLYGON ((0 0, 0 20, 20 20, 0 0))"),
           std::optional<int32_t>(14)));
 }
+
+TEST_F(GeometryFunctionsTest, testGeometryToDissolvedBingTiles) {
+  const auto testGeometryToDissolvedBingTilesFunc = [&](const std::optional<
+                                                            std::string>& wkt,
+                                                        const std::optional<
+                                                            int32_t> zoom,
+                                                        const std::optional<
+                                                            std::vector<
+                                                                std::optional<
+                                                                    std::
+                                                                        string>>>&
+                                                            expectedQuadKeys) {
+    std::vector<std::optional<std::string>> wktVec = {wkt};
+    auto inputWkt = makeNullableFlatVector<std::string>(wktVec);
+    std::vector<std::optional<int32_t>> zoomVec = {zoom};
+    auto inputZoom = makeNullableFlatVector<int32_t>(zoomVec);
+    auto inputVec = makeRowVector({inputWkt, inputZoom});
+
+    facebook::velox::VectorPtr output = evaluate(
+        "ARRAY_SORT(TRANSFORM(geometry_to_dissolved_bing_tiles(ST_GeometryFromText(c0), c1), x -> bing_tile_quadkey(x)))",
+        inputVec);
+
+    auto arrayVector =
+        std::dynamic_pointer_cast<facebook::velox::ArrayVector>(output);
+
+    if (expectedQuadKeys.has_value()) {
+      ASSERT_TRUE(arrayVector != nullptr);
+      auto expected = makeNullableArrayVector<std::string>({expectedQuadKeys});
+      facebook::velox::test::assertEqualVectors(expected, output);
+    } else {
+      ASSERT_TRUE(output->isNullAt(0));
+    }
+  };
+
+  // Empty geometries
+  testGeometryToDissolvedBingTilesFunc(
+      "POINT EMPTY", 0, common::testutil::optionalEmpty);
+  testGeometryToDissolvedBingTilesFunc(
+      "POINT EMPTY", 10, common::testutil::optionalEmpty);
+  testGeometryToDissolvedBingTilesFunc(
+      "POINT EMPTY", 23, common::testutil::optionalEmpty);
+  testGeometryToDissolvedBingTilesFunc(
+      "POLYGON EMPTY", 10, common::testutil::optionalEmpty);
+  testGeometryToDissolvedBingTilesFunc(
+      "GEOMETRYCOLLECTION EMPTY", 10, common::testutil::optionalEmpty);
+
+  // Geometries at tile borders
+  testGeometryToDissolvedBingTilesFunc("POINT (0 0)", 0, {{""}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} 0)", kMinLongitude), 0, {{""}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} 0)", kMaxLongitude), 0, {{""}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT (0 {})", kMinBingTileLatitude), 0, {{""}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT (0 {})", kMaxBingTileLatitude), 0, {{""}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} {})", kMinLongitude, kMinBingTileLatitude),
+      0,
+      {{""}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} {})", kMinLongitude, kMaxBingTileLatitude),
+      0,
+      {{""}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} {})", kMaxLongitude, kMaxBingTileLatitude),
+      0,
+      {{""}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} {})", kMaxLongitude, kMinBingTileLatitude),
+      0,
+      {{""}});
+  testGeometryToDissolvedBingTilesFunc("POINT (0 0)", 1, {{"3"}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} 0)", kMinLongitude), 1, {{"2"}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} 0)", kMaxLongitude), 1, {{"3"}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT (0 {})", kMinBingTileLatitude), 1, {{"3"}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT (0 {})", kMaxBingTileLatitude), 1, {{"1"}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} {})", kMinLongitude, kMinBingTileLatitude),
+      1,
+      {{"2"}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} {})", kMinLongitude, kMaxBingTileLatitude),
+      1,
+      {{"0"}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} {})", kMaxLongitude, kMaxBingTileLatitude),
+      1,
+      {{"1"}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} {})", kMaxLongitude, kMinBingTileLatitude),
+      1,
+      {{"3"}});
+  testGeometryToDissolvedBingTilesFunc("LINESTRING (-1 0, -2 0)", 1, {{"2"}});
+  testGeometryToDissolvedBingTilesFunc("LINESTRING (1 0, 2 0)", 1, {{"3"}});
+  testGeometryToDissolvedBingTilesFunc("LINESTRING (0 -1, 0 -2)", 1, {{"3"}});
+  testGeometryToDissolvedBingTilesFunc("LINESTRING (0 1, 0 2)", 1, {{"1"}});
+
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("LINESTRING ({} 1, {} 2)", kMinLongitude, kMinLongitude),
+      1,
+      {{"0"}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("LINESTRING ({} -1, {} -2)", kMinLongitude, kMinLongitude),
+      1,
+      {{"2"}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("LINESTRING ({} 1, {} 2)", kMaxLongitude, kMaxLongitude),
+      1,
+      {{"1"}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("LINESTRING ({} -1, {} -2)", kMaxLongitude, kMaxLongitude),
+      1,
+      {{"3"}});
+
+  // General Geometries
+  testGeometryToDissolvedBingTilesFunc("POINT (60 30.12)", 0, {{""}});
+  testGeometryToDissolvedBingTilesFunc(
+      "POINT (60 30.12)", 10, {{"1230301230"}});
+  testGeometryToDissolvedBingTilesFunc(
+      "POINT (60 30.12)", 15, {{"123030123010121"}});
+  testGeometryToDissolvedBingTilesFunc(
+      "POINT (60 30.12)", 16, {{"1230301230101212"}});
+  testGeometryToDissolvedBingTilesFunc(
+      "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))",
+      6,
+      {{"12222", "300000", "300001"}});
+  testGeometryToDissolvedBingTilesFunc(
+      "POLYGON ((0 0, 0 10, 10 10, 0 0))",
+      6,
+      {{"122220", "122221", "122222", "300000"}});
+  testGeometryToDissolvedBingTilesFunc(
+      "POLYGON ((10 10, -10 10, -20 -15, 10 10))", 3, {{"033", "122", "211"}});
+  testGeometryToDissolvedBingTilesFunc(
+      "POLYGON ((10 10, -10 10, -20 -15, 10 10))",
+      6,
+      {{"033321",
+        "033323",
+        "03333",
+        "122220",
+        "122221",
+        "122222",
+        "211101",
+        "211102",
+        "211103",
+        "211110",
+        "211111",
+        "211112",
+        "211120",
+        "211121"}});
+  testGeometryToDissolvedBingTilesFunc(
+      "GEOMETRYCOLLECTION (POINT (60 30.12))", 10, {{"1230301230"}});
+  testGeometryToDissolvedBingTilesFunc(
+      "GEOMETRYCOLLECTION (POINT (60 30.12))", 15, {{"123030123010121"}});
+  testGeometryToDissolvedBingTilesFunc(
+      "GEOMETRYCOLLECTION (POLYGON ((10 10, -10 10, -20 -15, 10 10)))",
+      3,
+      {{"033", "122", "211"}});
+  testGeometryToDissolvedBingTilesFunc(
+      "GEOMETRYCOLLECTION (POINT (60 30.12), POLYGON ((10 10, -10 10, -20 -15, 10 10)))",
+      3,
+      {{"033", "122", "123", "211"}});
+  testGeometryToDissolvedBingTilesFunc(
+      "GEOMETRYCOLLECTION (POINT (0.1 0.1), POINT(0.1 -0.1), POINT(-0.1 -0.1), POINT(-0.1 0.1))",
+      3,
+      {{"033", "122", "211", "300"}});
+
+  ASSERT_EQ(
+      2320,
+      evaluateOnce<int64_t>(
+          "cardinality(geometry_to_dissolved_bing_tiles(ST_GeometryFromText(c0), c1))",
+          std::optional<std::string>("POLYGON ((0 0, 0 20, 20 20, 0 0))"),
+          std::optional<int32_t>(14)));
+
+  // Invalid inputs
+  // Longitude out of range
+  VELOX_ASSERT_USER_THROW(
+      testGeometryToDissolvedBingTilesFunc(
+          "POINT (600 30.12)", 10, std::nullopt),
+      "Longitude span for the geometry must be in [-180.00, 180.00] range");
+  VELOX_ASSERT_USER_THROW(
+      testGeometryToDissolvedBingTilesFunc(
+          "POLYGON ((1000 10, -10 10, -20 -15, 1000 10))", 10, std::nullopt),
+      "Longitude span for the geometry must be in [-180.00, 180.00] range");
+  // Latitude out of range
+  VELOX_ASSERT_USER_THROW(
+      testGeometryToDissolvedBingTilesFunc(
+          "POINT (60 300.12)", 10, std::nullopt),
+      "Latitude span for the geometry must be in [-85.05, 85.05] range");
+  VELOX_ASSERT_USER_THROW(
+      testGeometryToDissolvedBingTilesFunc(
+          "POLYGON ((10 1000, -10 10, -20 -15, 10 1000))", 10, std::nullopt),
+      "Latitude span for the geometry must be in [-85.05, 85.05] range");
+  // Invalid zoom
+  VELOX_ASSERT_USER_THROW(
+      testGeometryToDissolvedBingTilesFunc(
+          "POINT (60 30.12)", -1, std::nullopt),
+      "Zoom level must be between 0 and 23");
+  VELOX_ASSERT_USER_THROW(
+      testGeometryToDissolvedBingTilesFunc(
+          "POINT (60 30.12)", 24, std::nullopt),
+      "Zoom level must be between 0 and 23");
+}
+
+TEST_F(GeometryFunctionsTest, testGeometryUnion) {
+  const auto testGeometryUnionFunc = [&](const std::optional<std::vector<
+                                             std::optional<std::string>>>& wkts,
+                                         const std::optional<std::string>&
+                                             expected) {
+    auto arrayVec = makeNullableArrayVector<std::string>({{wkts}});
+    auto input = makeRowVector(
+        {arrayVec, makeNullableFlatVector<std::string>({expected})});
+    std::optional<bool> result = evaluateOnce<bool>(
+        "ST_Equals(GEOMETRY_UNION(transform(c0, x -> ST_GEOMETRYFROMTEXT(x))), ST_GeometryFromText(c1))",
+        input);
+
+    if (expected.has_value()) {
+      ASSERT_TRUE(result.has_value());
+      ASSERT_TRUE(result.value());
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  testGeometryUnionFunc({{"POINT EMPTY", "POINT (1 1)"}}, "POINT (1 1)");
+  testGeometryUnionFunc({{"POINT (1 1)", "POINT (1 1)"}}, "POINT (1 1)");
+  testGeometryUnionFunc({{"POINT (1 1)"}}, "POINT (1 1)");
+  testGeometryUnionFunc(
+      {{"POINT (1 2)", "POINT (3 4)"}}, "MULTIPOINT (1 2, 3 4)");
+
+  testGeometryUnionFunc({{"LINESTRING (0 0, 1 1)"}}, "LINESTRING (0 0, 1 1)");
+
+  testGeometryUnionFunc({{"POINT EMPTY", "LINESTRING EMPTY"}}, "POLYGON EMPTY");
+
+  testGeometryUnionFunc(
+      {{"POINT EMPTY", "POLYGON EMPTY", "MULTIPOINT EMPTY"}}, "POLYGON EMPTY");
+  testGeometryUnionFunc(
+      {{"GEOMETRYCOLLECTION ( POLYGON ((2 2, 3 1, 1 1, 2 2)), POLYGON ((3 2, 4 1, 2 1, 3 2)) )",
+        "GEOMETRYCOLLECTION ( POLYGON ((4 2, 5 1, 3 1, 4 2)) )"}},
+      "POLYGON ((2.5 1.5, 3 2, 3.5 1.5, 4 2, 5 1, 4 1, 3 1, 2 1, 1 1, 2 2, 2.5 1.5))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1))", "POINT (5 2)"}},
+      "GEOMETRYCOLLECTION (POINT (5 2), POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1)))");
+
+  // Point test cases
+  testGeometryUnionFunc(
+      {{"POINT (1 2)", "POINT (1 2)", "POINT (1 2)"}}, "POINT (1 2)");
+
+  testGeometryUnionFunc({{"POINT EMPTY", "POINT (1 2)"}}, "POINT (1 2)");
+
+  testGeometryUnionFunc(
+      {{"POINT (1 2)", "POINT (3 4)"}}, "MULTIPOINT (1 2, 3 4)");
+
+  // Linestring test cases
+  testGeometryUnionFunc(
+      {{"LINESTRING (1 1, 2 2)",
+        "LINESTRING (1 1, 2 2)",
+        "LINESTRING (1 1, 2 2)"}},
+      "LINESTRING (1 1, 2 2)");
+
+  testGeometryUnionFunc(
+      {{"LINESTRING EMPTY", "LINESTRING (1 1, 2 2)"}}, "LINESTRING (1 1, 2 2)");
+
+  testGeometryUnionFunc(
+      {{"LINESTRING (1 1, 2 2, 3 3)", "LINESTRING (2 2, 3 3, 4 4)"}},
+      "LINESTRING (1 1, 2 2, 3 3, 4 4)");
+
+  testGeometryUnionFunc(
+      {{"LINESTRING (1 1, 2 2, 3 3)", "LINESTRING (1 2, 2 3, 3 4)"}},
+      "MULTILINESTRING ((1 1, 2 2, 3 3), (1 2, 2 3, 3 4))");
+
+  testGeometryUnionFunc(
+      {{"LINESTRING (1 1, 3 3)",
+        "LINESTRING (3 1, 2 2)",
+        "LINESTRING (2 2, 3 3)",
+        "LINESTRING (2 2, 1 3)"}},
+      "MULTILINESTRING ((1 1, 2 2, 3 3), (3 1, 1 3))");
+
+  // Polygon test cases
+  testGeometryUnionFunc(
+      {{"POLYGON ((2 2, 1 1, 3 1, 2 2))",
+        "POLYGON ((2 2, 1 1, 3 1, 2 2))",
+        "POLYGON ((2 2, 1 1, 3 1, 2 2))"}},
+      "POLYGON ((2 2, 1 1, 3 1, 2 2))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON EMPTY)", "POLYGON ((2 2, 1 1, 3 1, 2 2))"}},
+      "POLYGON ((2 2, 1 1, 3 1, 2 2))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((2 2, 3 1, 1 1, 2 2))",
+        "POLYGON ((3 2, 4 1, 2 1, 3 2))",
+        "POLYGON ((4 2, 5 1, 3 1, 4 2))"}},
+      "POLYGON ((1 1, 2 1, 3 1, 4 1, 5 1, 4 2, 3.5 1.5, 3 2, 2.5 1.5, 2 2, 1 1))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((2 2, 3 1, 1 1, 2 2))", "POLYGON ((4 2, 5 1, 3 1, 4 2))"}},
+      "MULTIPOLYGON (((1 1, 3 1, 2 2, 1 1)), ((3 1, 5 1, 4 2, 3 1)))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((2 2, 3 1, 1 1, 2 2))", "POLYGON ((5 2, 6 1, 4 1, 5 2))"}},
+      "MULTIPOLYGON (((1 1, 3 1, 2 2, 1 1)), ((4 1, 6 1, 5 2, 4 1)))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((1 1, 6 1, 6 6, 1 6, 1 1), (3 3, 4 3, 4 4, 3 4, 3 3))",
+        "POLYGON ((3 3, 4 3, 4 4, 3 4, 3 3))"}},
+      "POLYGON ((1 1, 6 1, 6 6, 1 6, 1 1))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((1 1, 6 1, 6 6, 1 6, 1 1), (3 3, 4 3, 4 4, 3 4, 3 3))",
+        "POLYGON ((2 2, 5 2, 5 5, 2 5, 2 2))"}},
+      "POLYGON ((1 1, 6 1, 6 6, 1 6, 1 1))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((1 1, 6 1, 6 6, 1 6, 1 1), (3 3, 4 3, 4 4, 3 4, 3 3))",
+        "POLYGON ((3.25 3.25, 3.75 3.25, 3.75 3.75, 3.25 3.75, 3.25 3.25))"}},
+      "MULTIPOLYGON (((1 1, 6 1, 6 6, 1 6, 1 1), (3 3, 4 3, 4 4, 3 4, 3 3)), ((3.25 3.25, 3.75 3.25, 3.75 3.75, 3.25 3.75, 3.25 3.25)))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((1 1, 6 1, 6 6, 1 6, 1 1), (3 3, 4 3, 4 4, 3 4, 3 3))",
+        "POLYGON ((3 3, 3 3.5, 3.5 3.5, 3.5 3, 3 3))",
+        "POLYGON ((3.5 3.5, 3.5 4, 4 4, 4 3.5, 3.5 3.5))",
+        "POLYGON ((3 3.5, 3 4, 3.5 4, 3.5 3.5, 3 3.5))",
+        "POLYGON ((3.5 3, 3.5 3.5, 4 3.5, 4 3, 3.5 3))"}},
+      "POLYGON ((1 1, 6 1, 6 6, 1 6, 1 1))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((1 3, 1 4, 6 4, 6 3, 1 3))",
+        "POLYGON ((3 1, 4 1, 4 6, 3 6, 3 1))"}},
+      "POLYGON ((3 1, 4 1, 4 3, 6 3, 6 4, 4 4, 4 6, 3 6, 3 4, 1 4, 1 3, 3 3, 3 1))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((1 3, 1 4, 3 4, 3 3, 1 3))",
+        "POLYGON ((3 3, 3 4, 4 4, 4 3, 3 3))",
+        "POLYGON ((4 3, 4 4, 6 4, 6 3, 4 3))",
+        "POLYGON ((3 1, 4 1, 4 3, 3 3, 3 1))",
+        "POLYGON ((3 4, 3 6, 4 6, 4 4, 3 4))"}},
+      "POLYGON ((3 1, 4 1, 4 3, 6 3, 6 4, 4 4, 4 6, 3 6, 3 4, 1 4, 1 3, 3 3, 3 1))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1))", "POINT (3 2)"}},
+      "POLYGON ((1 1, 3 1, 3 2, 3 3, 1 3, 1 1))");
+
+  // Multipoint test cases
+  testGeometryUnionFunc(
+      {{"MULTIPOINT ((1 2), (2 4), (3 6), (4 8))",
+        "MULTIPOINT ((1 2), (2 4), (3 6), (4 8))",
+        "MULTIPOINT ((1 2), (2 4), (3 6), (4 8))"}},
+      "MULTIPOINT ((1 2), (2 4), (3 6), (4 8))");
+
+  testGeometryUnionFunc(
+      {{"MULTIPOINT EMPTY", "MULTIPOINT ((1 2), (2 4), (3 6), (4 8))"}},
+      "MULTIPOINT ((1 2), (2 4), (3 6), (4 8))");
+
+  testGeometryUnionFunc(
+      {{"MULTIPOINT ((1 2), (2 4))", "MULTIPOINT ((3 6), (4 8))"}},
+      "MULTIPOINT ((1 2), (2 4), (3 6), (4 8))");
+
+  testGeometryUnionFunc(
+      {{"MULTIPOINT ((1 2), (2 4))",
+        "MULTIPOINT ((2 4), (3 6))",
+        "MULTIPOINT ((3 6), (4 8))"}},
+      "MULTIPOINT ((1 2), (2 4), (3 6), (4 8))");
+
+  // Multilinestring test cases
+  testGeometryUnionFunc(
+      {{"MULTILINESTRING ((1 5, 4 1), (2 5, 5 1))",
+        "MULTILINESTRING ((1 5, 4 1), (2 5, 5 1))",
+        "MULTILINESTRING ((1 5, 4 1), (2 5, 5 1))"}},
+      "MULTILINESTRING ((1 5, 4 1), (2 5, 5 1))");
+
+  testGeometryUnionFunc(
+      {{"MULTILINESTRING EMPTY", "MULTILINESTRING ((1 5, 4 1), (2 5, 5 1))"}},
+      "MULTILINESTRING ((1 5, 4 1), (2 5, 5 1))");
+
+  testGeometryUnionFunc(
+      {{"MULTILINESTRING ((1 5, 4 1), (3 5, 6 1))",
+        "MULTILINESTRING ((2 5, 5 1), (4 5, 7 1))"}},
+      "MULTILINESTRING ((1 5, 4 1), (2 5, 5 1), (3 5, 6 1), (4 5, 7 1))");
+
+  testGeometryUnionFunc(
+      {{"MULTILINESTRING ((1 5, 4 1), (3 5, 6 1))",
+        "MULTILINESTRING ((2 5, 5 1), (4 5, 7 1))",
+        "LINESTRING (1 3, 8 3)"}},
+      "MULTILINESTRING ((1 5, 4 1), (2 5, 5 1), (3 5, 6 1), (4 5, 7 1), (1 3, 8 3))");
+
+  // Multipolygon test cases
+  testGeometryUnionFunc(
+      {{"MULTIPOLYGON(((4 2, 5 1, 3 1, 4 2)), ((14 12, 15 11, 13 11, 14 12)))",
+        "MULTIPOLYGON(((4 2, 5 1, 3 1, 4 2)), ((14 12, 15 11, 13 11, 14 12)))"}},
+      "MULTIPOLYGON (((4 2, 3 1, 5 1, 4 2)), ((14 12, 13 11, 15 11, 14 12)))");
+
+  testGeometryUnionFunc(
+      {{"MULTIPOLYGON EMPTY",
+        "MULTIPOLYGON (((4 2, 5 1, 3 1, 4 2)), ((14 12, 15 11, 13 11, 14 12)))"}},
+      "MULTIPOLYGON (((4 2, 3 1, 5 1, 4 2)), ((14 12, 13 11, 15 11, 14 12)))");
+
+  testGeometryUnionFunc(
+      {{"MULTIPOLYGON ((( 0 0, 0 2, 2 2, 2 0, 0 0 )), (( 0 3, 0 5, 2 5, 2 3, 0 3 )))",
+        "MULTIPOLYGON ((( 3 0, 3 2, 5 2, 5 0, 3 0 )), (( 3 3, 3 5, 5 5, 5 3, 3 3 )))"}},
+      "MULTIPOLYGON (((0 0, 2 0, 2 2, 0 2, 0 0)), ((3 0, 5 0, 5 2, 3 2, 3 0)), ((0 3, 2 3, 2 5, 0 5, 0 3)), ((3 3, 5 3, 5 5, 3 5, 3 3)))");
+
+  testGeometryUnionFunc(
+      {{"MULTIPOLYGON (((2 2, 3 1, 1 1, 2 2)), ((3 2, 4 1, 2 1, 3 2)))",
+        "MULTIPOLYGON(((4 2, 5 1, 3 1, 4 2)))"}},
+      "POLYGON ((1 1, 2 1, 3 1, 4 1, 5 1, 4 2, 3.5 1.5, 3 2, 2.5 1.5, 2 2, 1 1))");
+
+  testGeometryUnionFunc(
+      {{"MULTIPOLYGON (((1 3, 1 4, 3 4, 3 3, 1 3)), ((3 3, 3 4, 4 4, 4 3, 3 3)), ((4 3, 4 4, 6 4, 6 3, 4 3)))",
+        "MULTIPOLYGON (((3 1, 4 1, 4 3, 3 3, 3 1)), ((3 4, 3 6, 4 6, 4 4, 3 4)))"}},
+      "POLYGON ((3 1, 4 1, 4 3, 6 3, 6 4, 4 4, 4 6, 3 6, 3 4, 1 4, 1 3, 3 3, 3 1))");
+
+  // GeometryCollection test cases
+  testGeometryUnionFunc(
+      {{"MULTIPOLYGON (((0 0, 2 0, 2 2, 0 2, 0 0)), ((3 0, 5 0, 5 2, 3 2, 3 0)))",
+        "GEOMETRYCOLLECTION ( POLYGON ((0 0, 2 0, 2 2, 0 2, 0 0)), POLYGON ((3 0, 5 0, 5 2, 3 2, 3 0)))",
+        "GEOMETRYCOLLECTION ( POLYGON ((0 0, 2 0, 2 2, 0 2, 0 0)), POLYGON ((3 0, 5 0, 5 2, 3 2, 3 0)))"}},
+      "MULTIPOLYGON (((0 0, 2 0, 2 2, 0 2, 0 0)), ((3 0, 5 0, 5 2, 3 2, 3 0)))");
+
+  testGeometryUnionFunc(
+      {{"GEOMETRYCOLLECTION EMPTY", "GEOMETRYCOLLECTION EMPTY"}},
+      "GEOMETRYCOLLECTION EMPTY");
+
+  testGeometryUnionFunc(
+      {{"GEOMETRYCOLLECTION EMPTY",
+        "GEOMETRYCOLLECTION ( POLYGON ((0 0, 2 0, 2 2, 0 2, 0 0)), POLYGON ((3 0, 5 0, 5 2, 3 2, 3 0)))"}},
+      "MULTIPOLYGON (((0 0, 2 0, 2 2, 0 2, 0 0)), ((3 0, 5 0, 5 2, 3 2, 3 0)))");
+
+  testGeometryUnionFunc(
+      {{"GEOMETRYCOLLECTION ( POLYGON ((2 2, 3 1, 1 1, 2 2)), POLYGON ((3 2, 4 1, 2 1, 3 2)) )",
+        "GEOMETRYCOLLECTION ( POLYGON ((4 2, 5 1, 3 1, 4 2)) )"}},
+      "POLYGON ((1 1, 2 1, 3 1, 4 1, 5 1, 4 2, 3.5 1.5, 3 2, 2.5 1.5, 2 2, 1 1))");
+
+  testGeometryUnionFunc(
+      {{"GEOMETRYCOLLECTION ( POLYGON (( 0 0, 0 2, 2 2, 2 0, 0 0 )), POLYGON (( 0 3, 0 5, 2 5, 2 3, 0 3 )) )",
+        "GEOMETRYCOLLECTION ( POLYGON (( 3 0, 3 2, 5 2, 5 0, 3 0 )), POLYGON (( 3 3, 3 5, 5 5, 5 3, 3 3 )) )"}},
+      "MULTIPOLYGON (((0 0, 2 0, 2 2, 0 2, 0 0)), ((3 0, 5 0, 5 2, 3 2, 3 0)), ((0 3, 2 3, 2 5, 0 5, 0 3)), ((3 3, 5 3, 5 5, 3 5, 3 3)))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1))", "LINESTRING (0 2, 5 2)"}},
+      "GEOMETRYCOLLECTION (MULTILINESTRING ((0 2, 1 2), (3 2, 5 2)), POLYGON ((1 1, 3 1, 3 2, 3 3, 1 3, 1 2, 1 1)))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1))", "LINESTRING (0 5, 5 5)"}},
+      "GEOMETRYCOLLECTION (LINESTRING (0 5, 5 5), POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1)))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1))", "POINT (5 2)"}},
+      "GEOMETRYCOLLECTION (POINT (5 2), POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1)))");
+
+  testGeometryUnionFunc({{"POINT EMPTY"}}, "POLYGON EMPTY");
+  testGeometryUnionFunc({{"MULTIPOINT EMPTY"}}, "POLYGON EMPTY");
+  testGeometryUnionFunc({{"POLYGON EMPTY"}}, "POLYGON EMPTY");
+  testGeometryUnionFunc({{"MULTIPOLYGON EMPTY"}}, "POLYGON EMPTY");
+  testGeometryUnionFunc({{"LINESTRING EMPTY"}}, "POLYGON EMPTY");
+  testGeometryUnionFunc({{"MULTILINESTRING EMPTY"}}, "POLYGON EMPTY");
+  testGeometryUnionFunc({{"GEOMETRYCOLLECTION EMPTY"}}, "POLYGON EMPTY");
+  testGeometryUnionFunc(
+      {{"GEOMETRYCOLLECTION EMPTY",
+        "MULTILINESTRING EMPTY",
+        "LINESTRING EMPTY",
+        "MULTIPOLYGON EMPTY",
+        "POLYGON EMPTY",
+        "MULTIPOINT EMPTY",
+        "POINT EMPTY"}},
+      "POLYGON EMPTY");
+
+  // Empty array should return null
+  testGeometryUnionFunc(common::testutil::optionalEmpty, std::nullopt);
+
+  // Null elements in input array should be ignored
+  testGeometryUnionFunc({{std::nullopt, "POINT (1 2)"}}, "POINT (1 2)");
+}
+
+TEST_F(GeometryFunctionsTest, testStLineFromText) {
+  const auto testStLineFromTextFunc =
+      [&](const std::optional<std::string>& wkt) {
+        auto res =
+            evaluateOnce<std::string>("ST_AsText(ST_LineFromText(c0))", wkt);
+
+        if (wkt.has_value()) {
+          ASSERT_TRUE(res.has_value());
+          ASSERT_EQ(wkt.value(), res.value());
+        } else {
+          ASSERT_FALSE(res.has_value());
+        }
+      };
+
+  testStLineFromTextFunc("LINESTRING EMPTY");
+  testStLineFromTextFunc("LINESTRING (1 1, 2 2, 1 3)");
+  VELOX_ASSERT_USER_THROW(
+      testStLineFromTextFunc("xyz"),
+      "Failed to parse WKT: ParseException: Unknown type: 'XYZ'");
+  VELOX_ASSERT_USER_THROW(
+      testStLineFromTextFunc("MULTILINESTRING EMPTY"),
+      "ST_LineFromText only applies to LineString. Input type is: MultiLineString");
+  VELOX_ASSERT_USER_THROW(
+      testStLineFromTextFunc("POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))"),
+      "ST_LineFromText only applies to LineString. Input type is: Polygon");
+  VELOX_ASSERT_USER_THROW(
+      testStLineFromTextFunc("LINESTRING (0 0)"),
+      "Failed to parse WKT: IllegalArgumentException: point array must contain 0 or >1 elements");
+  VELOX_ASSERT_USER_THROW(
+      testStLineFromTextFunc("LINESTRING (0 0, 1)"),
+      "Failed to parse WKT: ParseException: Expected number but encountered ')'");
+  testStLineFromTextFunc(std::nullopt);
+}
+
+TEST_F(GeometryFunctionsTest, testStLineString) {
+  const auto testStLineStringFunc = [&](const std::optional<std::vector<
+                                            std::optional<std::string>>>& wkts,
+                                        const std::optional<std::string>&
+                                            expected) {
+    auto arrayVec = makeNullableArrayVector<std::string>({{wkts}});
+    auto input = makeRowVector({arrayVec});
+    std::optional<std::string> result = evaluateOnce<std::string>(
+        "St_AsText(ST_LineString(transform(c0, x -> ST_GEOMETRYFROMTEXT(x))))",
+        input);
+
+    if (expected.has_value()) {
+      ASSERT_TRUE(result.has_value());
+      ASSERT_EQ(expected.value(), result.value());
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  // Happy cases
+  testStLineStringFunc(
+      {{"POINT (1 2)", "POINT (3 4)"}}, "LINESTRING (1 2, 3 4)");
+  testStLineStringFunc(
+      {{"POINT (1 2)", "POINT (3 4)", "POINT (5 6)"}},
+      "LINESTRING (1 2, 3 4, 5 6)");
+  testStLineStringFunc(
+      {{"POINT (1 2)", "POINT (3 4)", "POINT (5 6)", "POINT (7 8)"}},
+      "LINESTRING (1 2, 3 4, 5 6, 7 8)");
+
+  // < 2 Points returns empty
+  testStLineStringFunc({{"POINT (1 2)"}}, "LINESTRING EMPTY");
+  testStLineStringFunc(common::testutil::optionalEmpty, "LINESTRING EMPTY");
+  // Duplicate consecutive points throws exception
+  VELOX_ASSERT_USER_THROW(
+      testStLineStringFunc({{"POINT (1 2)", "POINT (1 2)"}}, std::nullopt),
+      "Repeated point sequence in ST_LineString: point 1,2 at index 1.");
+  // Only points can be passed
+  VELOX_ASSERT_USER_THROW(
+      testStLineStringFunc(
+          {{"POLYGON ((1 2, 3 4, 5 6, 1 2))", "POINT (1 2)"}}, std::nullopt),
+      "Non-point geometry in ST_LineString input at index 0.");
+  // Empty points are invalid
+  VELOX_ASSERT_USER_THROW(
+      testStLineStringFunc({{"POINT (1 2)", "POINT EMPTY"}}, std::nullopt),
+      "Empty point in ST_LineString input at index 1.");
+  VELOX_ASSERT_USER_THROW(
+      testStLineStringFunc(
+          {{"POINT (1 2)", "POINT EMPTY", "POINT (1 2)"}}, std::nullopt),
+      "Empty point in ST_LineString input at index 1.");
+  VELOX_ASSERT_USER_THROW(
+      testStLineStringFunc(
+          {{"POINT (1 2)", "POINT EMPTY", "POINT (1 2)", "POINT EMPTY"}},
+          std::nullopt),
+      "Empty point in ST_LineString input at index 1.");
+  VELOX_ASSERT_USER_THROW(
+      testStLineStringFunc({{"POINT EMPTY"}}, std::nullopt),
+      "Empty point in ST_LineString input at index 0.");
+
+  // Null elements in array are invalid
+  VELOX_ASSERT_USER_THROW(
+      testStLineStringFunc({{"POINT (1 2)", std::nullopt}}, std::nullopt),
+      "Invalid input to ST_LineString: input array contains null at index 1.");
+  VELOX_ASSERT_USER_THROW(
+      testStLineStringFunc({{std::nullopt, "POINT (1 2)"}}, std::nullopt),
+      "Invalid input to ST_LineString: input array contains null at index 0.");
+  VELOX_ASSERT_USER_THROW(
+      testStLineStringFunc(
+          std::vector<std::optional<std::string>>{std::nullopt}, std::nullopt),
+      "Invalid input to ST_LineString: input array contains null at index 0.");
+  VELOX_ASSERT_USER_THROW(
+      testStLineStringFunc(
+          std::vector<std::optional<std::string>>{std::nullopt, std::nullopt},
+          std::nullopt),
+      "Invalid input to ST_LineString: input array contains null at index 0.");
+}
+
+TEST_F(GeometryFunctionsTest, testStMultiPoint) {
+  const auto testStMultiPointFunc = [&](const std::optional<std::vector<
+                                            std::optional<std::string>>>& wkts,
+                                        const std::optional<std::string>&
+                                            expected) {
+    auto arrayVec = makeNullableArrayVector<std::string>({{wkts}});
+    auto input = makeRowVector({arrayVec});
+    std::optional<std::string> result = evaluateOnce<std::string>(
+        "St_AsText(ST_MultiPoint(transform(c0, x -> ST_GEOMETRYFROMTEXT(x))))",
+        input);
+
+    if (expected.has_value()) {
+      ASSERT_TRUE(result.has_value());
+      ASSERT_EQ(expected.value(), result.value());
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  // Happy cases
+  testStMultiPointFunc(
+      {{"POINT (1 2)", "POINT (3 4)"}}, "MULTIPOINT (1 2, 3 4)");
+  testStMultiPointFunc(
+      {{"POINT (1 2)", "POINT (3 4)", "POINT (5 6)"}},
+      "MULTIPOINT (1 2, 3 4, 5 6)");
+  testStMultiPointFunc(
+      {{"POINT (1 2)", "POINT (3 4)", "POINT (5 6)", "POINT (7 8)"}},
+      "MULTIPOINT (1 2, 3 4, 5 6, 7 8)");
+
+  // Duplicate points work
+  testStMultiPointFunc(
+      {{"POINT (1 2)", "POINT (1 2)"}}, "MULTIPOINT (1 2, 1 2)");
+  testStMultiPointFunc(
+      {{"POINT (1 2)", "POINT (3 4)", "POINT (1 2)"}},
+      "MULTIPOINT (1 2, 3 4, 1 2)");
+
+  // Single point
+  testStMultiPointFunc({{"POINT (1 2)"}}, "MULTIPOINT (1 2)");
+
+  // Empty array
+  testStMultiPointFunc(common::testutil::optionalEmpty, std::nullopt);
+
+  // Only points can be passed
+  VELOX_ASSERT_USER_THROW(
+      testStMultiPointFunc(
+          {{"POINT (7 8)", "LINESTRING (1 2, 3 4)"}}, std::nullopt),
+      "Non-point geometry in ST_MultiPoint input at index 1.");
+
+  VELOX_ASSERT_USER_THROW(
+      testStMultiPointFunc(
+          {{"POINT (7 8)", "MULTIPOINT ((1 2), (3 4))"}}, std::nullopt),
+      "Non-point geometry in ST_MultiPoint input at index 1.");
+
+  // Null elements in array are invalid
+  VELOX_ASSERT_USER_THROW(
+      testStMultiPointFunc({{"POINT (1 2)", std::nullopt}}, std::nullopt),
+      "Invalid input to ST_MultiPoint: input array contains null at index 1.");
+  VELOX_ASSERT_USER_THROW(
+      testStMultiPointFunc({{std::nullopt, "POINT (1 2)"}}, std::nullopt),
+      "Invalid input to ST_MultiPoint: input array contains null at index 0.");
+  VELOX_ASSERT_USER_THROW(
+      testStMultiPointFunc(
+          std::vector<std::optional<std::string>>{std::nullopt}, std::nullopt),
+      "Invalid input to ST_MultiPoint: input array contains null at index 0.");
+  VELOX_ASSERT_USER_THROW(
+      testStMultiPointFunc(
+          std::vector<std::optional<std::string>>{std::nullopt, std::nullopt},
+          std::nullopt),
+      "Invalid input to ST_MultiPoint: input array contains null at index 0.");
+
+  // Empty elements in array are invalid
+  VELOX_ASSERT_USER_THROW(
+      testStMultiPointFunc({{"POINT EMPTY"}}, std::nullopt),
+      "Empty point in ST_MultiPoint input at index 0.");
+  VELOX_ASSERT_USER_THROW(
+      testStMultiPointFunc({{"POINT (1 2)", "POINT EMPTY"}}, std::nullopt),
+      "Empty point in ST_MultiPoint input at index 1.");
+}
+
+TEST_F(GeometryFunctionsTest, testToFromSphericalGeography) {
+  const auto testToFromSphericalGeographyFunc = [&](const std::optional<
+                                                    std::string>& wkt) {
+    std::optional<std::string> result = evaluateOnce<std::string>(
+        "ST_AsText(to_geometry(to_spherical_geography(ST_GeometryFromText(c0))))",
+        wkt);
+
+    if (wkt.has_value()) {
+      ASSERT_TRUE(result.has_value());
+      ASSERT_EQ(wkt.value(), result.value());
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  // Happy cases
+  testToFromSphericalGeographyFunc("POINT EMPTY");
+  testToFromSphericalGeographyFunc("MULTIPOINT EMPTY");
+  testToFromSphericalGeographyFunc("POLYGON EMPTY");
+  testToFromSphericalGeographyFunc("MULTIPOLYGON EMPTY");
+  testToFromSphericalGeographyFunc("LINESTRING EMPTY");
+  testToFromSphericalGeographyFunc("MULTILINESTRING EMPTY");
+  testToFromSphericalGeographyFunc("GEOMETRYCOLLECTION EMPTY");
+
+  testToFromSphericalGeographyFunc("POINT (180 90)");
+  testToFromSphericalGeographyFunc("POINT (-180 -90)");
+  testToFromSphericalGeographyFunc("POINT (1 2)");
+  testToFromSphericalGeographyFunc("MULTIPOINT (1 2, 3 4, 5 6, 7 8)");
+  testToFromSphericalGeographyFunc("POLYGON ((1 3, 1 4, 3 4, 3 3, 1 3))");
+  testToFromSphericalGeographyFunc(
+      "MULTIPOLYGON (((0 0, 0 2, 2 2, 2 0, 0 0)), ((3 0, 3 2, 5 2, 5 0, 3 0)), ((0 3, 0 5, 2 5, 2 3, 0 3)), ((3 3, 3 5, 5 5, 5 3, 3 3)))");
+  testToFromSphericalGeographyFunc(
+      "GEOMETRYCOLLECTION (POINT (1 1), GEOMETRYCOLLECTION (LINESTRING (0 0, 1 1), GEOMETRYCOLLECTION (POLYGON ((2 2, 2 3, 3 3, 3 2, 2 2)))))");
+
+  // Error cases
+  VELOX_ASSERT_USER_THROW(
+      testToFromSphericalGeographyFunc("POINT (200 200)"),
+      "Latitude must be in range [-90, 90] and longitude must be in range [-180, 180]. Got latitude: 200 and longitude: 200");
+  VELOX_ASSERT_USER_THROW(
+      testToFromSphericalGeographyFunc(
+          "GEOMETRYCOLLECTION (POINT (1 1), GEOMETRYCOLLECTION (LINESTRING (0 0, 1 1), GEOMETRYCOLLECTION (POLYGON ((2 2, 2 -300, 3 3, 3 2, 2 2)))))"),
+      "Latitude must be in range [-90, 90] and longitude must be in range [-180, 180]. Got latitude: -300 and longitude: 0");
+}
+
+TEST_F(GeometryFunctionsTest, testStSphericalCentroid) {
+  const auto testStSphericalCentroidFunction = [&](const std::optional<
+                                                       std::string>& wkt,
+                                                   const std::optional<
+                                                       std::string>&
+                                                       expectedWkt) {
+    std::optional<std::string> result = evaluateOnce<std::string>(
+        "st_astext(to_geometry(st_centroid(to_spherical_geography(ST_GeometryFromText(c0)))))",
+        wkt);
+
+    if (expectedWkt.has_value()) {
+      ASSERT_TRUE(result.has_value());
+      ASSERT_EQ(result.value(), expectedWkt.value());
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  // Empty geometries return null. Note that functions that return empty
+  // geometries might choose any type, so we should cover all types.
+  testStSphericalCentroidFunction("POINT EMPTY", std::nullopt);
+  testStSphericalCentroidFunction("MULTIPOINT EMPTY", std::nullopt);
+  testStSphericalCentroidFunction("LINESTRING EMPTY", std::nullopt);
+  testStSphericalCentroidFunction("MULTILINESTRING EMPTY", std::nullopt);
+  testStSphericalCentroidFunction("POLYGON EMPTY", std::nullopt);
+  testStSphericalCentroidFunction("MULTIPOLYGON EMPTY", std::nullopt);
+  testStSphericalCentroidFunction("GEOMETRYCOLLECTION EMPTY", std::nullopt);
+
+  // Single point returns same point
+  testStSphericalCentroidFunction("POINT (3 5)", "POINT (3 5)");
+
+  // Single point in multipoint returns same point
+  testStSphericalCentroidFunction("MULTIPOINT (3 5)", "POINT (3 5)");
+
+  // Two points on opposite sides of equator at same longitude
+  testStSphericalCentroidFunction("MULTIPOINT (0 -45, 0 45)", "POINT (0 0)");
+
+  // Two points on equator at opposite longitudes
+  testStSphericalCentroidFunction("MULTIPOINT (45 0, -45 0)", "POINT (0 0)");
+
+  // Two antipodal points on the equator (0, 0) and (-180, 0)
+  // The result is arbitrary but GEOS calculates it as (-90 45)
+  testStSphericalCentroidFunction("MULTIPOINT (0 0, -180 0)", "POINT (-90 45)");
+
+  // Three points - the Java test expects (12.36780515862267, 0)
+  // We'll check with some tolerance
+  auto result = evaluateOnce<std::string>(
+      "st_astext(to_geometry(st_centroid(to_spherical_geography(ST_GeometryFromText(c0)))))",
+      std::optional<std::string>("MULTIPOINT (0 -45, 0 45, 30 0)"));
+  ASSERT_TRUE(result.has_value());
+
+  // Parse the result to check longitude is approximately 12.3678
+  std::string resultStr = result.value();
+  ASSERT_TRUE(resultStr.find("POINT (12.3678") != std::string::npos);
+
+  // Four symmetric points should give centroid at (0, 0)
+  testStSphericalCentroidFunction(
+      "MULTIPOINT (0 -45, 0 45, 30 0, -30 0)", "POINT (0 0)");
+
+  // Non-point/multipoint geometries should throw
+  VELOX_ASSERT_USER_THROW(
+      testStSphericalCentroidFunction("LINESTRING (0 0, 1 1)", std::nullopt),
+      "ST_Centroid[SphericalGeography] only applies to Point or MultiPoint. Input type is: LineString");
+
+  VELOX_ASSERT_USER_THROW(
+      testStSphericalCentroidFunction(
+          "POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))", std::nullopt),
+      "ST_Centroid[SphericalGeography] only applies to Point or MultiPoint. Input type is: Polygon");
+}
+TEST_F(GeometryFunctionsTest, testStSphericalDistance) {
+  const auto testStSphericalDistanceFunc = [&](const std::optional<std::string>&
+                                                   leftWkt,
+                                               const std::optional<std::string>&
+                                                   rightWkt,
+                                               const std::optional<double>&
+                                                   expected) {
+    std::optional<double> result = evaluateOnce<double>(
+        "st_distance(to_spherical_geography(ST_GeometryFromText(c0)), to_spherical_geography(ST_GeometryFromText(c1)))",
+        leftWkt,
+        rightWkt);
+
+    if (expected.has_value()) {
+      ASSERT_TRUE(aboutEquals(expected.value(), result.value()));
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  // Happy cases
+  testStSphericalDistanceFunc(
+      "POINT (-86.67 36.12)", "POINT (-118.40 33.94)", 2886448.973436703);
+  testStSphericalDistanceFunc(
+      "POINT (-118.40 33.94)", "POINT (-86.67 36.12)", 2886448.973436703);
+  testStSphericalDistanceFunc(
+      "POINT (-71.0589 42.3601)",
+      "POINT (-71.2290 42.4430)",
+      16734.69743457461);
+  testStSphericalDistanceFunc(
+      "POINT (-86.67 36.12)", "POINT (-86.67 36.12)", 0.0);
+
+  // Non-point geometries should throw
+  VELOX_ASSERT_USER_THROW(
+      testStSphericalDistanceFunc(
+          "POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))",
+          "POLYGON((0 0, 0 2, 2 2, 2 0, 0 0))",
+          std::nullopt),
+      "ST_Distance[SphericalGeography] only applies to Point. Input type is: Polygon");
+
+  // Empty points should return null
+  testStSphericalDistanceFunc("POINT EMPTY", "POINT (40 30)", std::nullopt);
+  testStSphericalDistanceFunc("POINT (20 10)", "POINT EMPTY", std::nullopt);
+  testStSphericalDistanceFunc("POINT EMPTY", "POINT EMPTY", std::nullopt);
+}
+
+TEST_F(GeometryFunctionsTest, testStSphericalLength) {
+  const auto testStSphericalLengthFunction =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<double>& expected) {
+        std::optional<double> result = evaluateOnce<double>(
+            "st_length(to_spherical_geography(ST_GeometryFromText(c0)))", wkt);
+
+        if (expected.has_value()) {
+          ASSERT_TRUE(aboutEquals(expected.value(), result.value()));
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  double length = 4350866.6362;
+
+  // Empty linestring returns null
+  testStSphericalLengthFunction("LINESTRING EMPTY", std::nullopt);
+
+  // ST_Length is equivalent to sums of ST_DISTANCE between points in the
+  // LineString
+  testStSphericalLengthFunction(
+      "LINESTRING (-71.05 42.36, -87.62 41.87, -122.41 37.77)", length);
+
+  // Linestring has same length as its reverse
+  testStSphericalLengthFunction(
+      "LINESTRING (-122.41 37.77, -87.62 41.87, -71.05 42.36)", length);
+
+  // Path north pole -> south pole -> north pole should be roughly the
+  // circumference of the Earth
+  testStSphericalLengthFunction(
+      "LINESTRING (0.0 90.0, 0.0 -90.0, 0.0 90.0)", 4.003e7);
+
+  // Empty multi-linestring returns null
+  testStSphericalLengthFunction("MULTILINESTRING EMPTY", std::nullopt);
+
+  // Multi-linestring with one path is equivalent to a single linestring
+  testStSphericalLengthFunction(
+      "MULTILINESTRING ((-71.05 42.36, -87.62 41.87, -122.41 37.77))", length);
+
+  // Multi-linestring with two disjoint paths has length equal to sum of lengths
+  // of lines
+  testStSphericalLengthFunction(
+      "MULTILINESTRING ((-71.05 42.36, -87.62 41.87, -122.41 37.77), (-73.05 42.36, -89.62 41.87, -124.41 37.77))",
+      2 * length);
+
+  // Multi-linestring with adjacent paths is equivalent to a single linestring
+  testStSphericalLengthFunction(
+      "MULTILINESTRING ((-71.05 42.36, -87.62 41.87), (-87.62 41.87, -122.41 37.77))",
+      length);
+
+  // Non-linestring geometries should throw
+  VELOX_ASSERT_USER_THROW(
+      testStSphericalLengthFunction(
+          "POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))", std::nullopt),
+      "ST_Length[SphericalGeography] only applies to LineString or MultiLineString. Input type is: Polygon");
+
+  // Invalid linestring should throw
+  VELOX_ASSERT_USER_THROW(
+      testStSphericalLengthFunction("LINESTRING (0.0)", std::nullopt),
+      "Failed to parse WKT: ParseException: Expected number but encountered ')'");
+}
+
+TEST_F(GeometryFunctionsTest, testDegeneratePolygons) {
+  const auto testDegeneratePolygonsFunc =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<std::string>& expected) {
+        auto res = evaluateOnce<std::string>(
+            "ST_AsText(ST_GeometryFromText(c0))", wkt);
+        if (expected.has_value()) {
+          ASSERT_TRUE(res.has_value());
+          ASSERT_EQ(expected.value(), res.value());
+        } else {
+          ASSERT_FALSE(res.has_value());
+        }
+      };
+
+  // Single polygon with CCW orientation - should orient to CW
+  testDegeneratePolygonsFunc(
+      "POLYGON ((1 2, 3 4, 5 7, 1 2))",
+      "POLYGON ((1 2, 5 7, 3 4, 1 2))"); // note: this should be fine
+
+  // Single polygons with zero area
+  testDegeneratePolygonsFunc(
+      "POLYGON ((1 2, 5 6, 3 4, 1 2))", "POLYGON ((1 2, 3 4, 5 6, 1 2))");
+
+  testDegeneratePolygonsFunc(
+      "POLYGON ((1 2, 3 4, 5 6, 1 2))", "POLYGON ((1 2, 5 6, 3 4, 1 2))");
+
+  // Single polygons with interior rings- should canonicalize so any shells have
+  // CW orientation and holes have CCW orientation.
+  testDegeneratePolygonsFunc(
+      "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 3 7, 7 7, 7 3, 3 3))",
+      "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3))");
+
+  testDegeneratePolygonsFunc(
+      "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3))",
+      "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3))");
+
+  // Multipolygons where polygons after the first are CCW for shell or CW for
+  // hole. These should be correctly oriented after serde.
+
+  // First polygon has CW shell and CCW hole, second polygon has CCW
+  // shell and CCW hole -> second polygon shell should be reoriented
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 20 0, 20 20, 0 20, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))",
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+
+  // First polygon has CW shell and CW hole, second polygon has CCW
+  // shell and CCW hole -> first polygon hole and second polygon shell should be
+  // reoriented
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 3 7, 7 7, 7 3, 3 3)), ((0 0, 20 0, 20 20, 0 20, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))",
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+
+  // First polygon has CCW shell and CW hole, second polygon has CCW
+  // shell and CW hole -> both polygons should have shell and hole reoriented
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 10 0, 10 10, 0 10, 0 0), (3 3, 3 7, 7 7, 7 3, 3 3)), ((0 0, 20 0, 20 20, 0 20, 0 0), (6 6, 6 14, 14 14, 14 6, 6 6)))",
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+
+  // First polygon has CCW shell and CCW hole, second polygon has CCW
+  // shell and CCW hole -> both polygons should have shells reoriented
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 10 0, 10 10, 0 10, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 20 0, 20 20, 0 20, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))",
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+
+  // First polygon has CW shell and CW hole, second polygon has CW
+  // shell and CW hole -> both polygons should have holes reoriented
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 3 7, 7 7, 7 3, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 6 14, 14 14, 14 6, 6 6)))",
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+
+  // MultiPolygons with zero-area rings. These rings are considered CCW before
+  // and after rotation, and can cause deformed multipolygons. This is being
+  // included to reach bug parity with Java, but we should alter these tests
+  // once we are able to implement the correct behavior!
+
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((1 1, 1 2, 1 3, 1 1)))",
+      "MULTIPOLYGON (((1 1, 1 3, 1 2, 1 1)))");
+
+  // First polygon has CW shell and CCW hole, second polygon has CW shell and
+  // zero-area hole
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 9 9, 14 14, 6 6)))",
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 9 9, 14 14, 6 6)))");
+
+  // First polygon has CW shell and CCW hole, second polygon has zero-area shell
+  // and CCW hole
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 0 10, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))",
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3), (0 0, 0 10, 0 20, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+
+  // First polygon has CW shell and CCW hole, second polygon has CW shell
+  // and zero-area hole
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 9 9, 14 14, 9 9, 6 6)))",
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 9 9, 14 14, 9 9, 6 6)))");
+
+  // First polygon has CW shell and CCW hole, second polygon has zero-area shell
+  // and zero-area hole
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 0 10, 0 0), (6 6, 9 9, 14 14, 6 6)))",
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3), (0 0, 0 10, 0 20, 0 0), (6 6, 9 9, 14 14, 6 6)))");
+
+  // First polygon has zero-area shell and CCW hole, second polygon has CW shell
+  // and CCW hole
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 0 10, 0 15, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6))))",
+      "MULTIPOLYGON (((0 0, 0 15, 0 10, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+
+  // First polygon has CW shell and zero-area hole, second polygon has CW shell
+  // and CCW hole-
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 9 3, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))",
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 9 3, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+
+  // First polygon has zero-area shell and zero-area hole, second polygon has CW
+  // shell and CCW hole
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 0 10, 0 5, 0 10, 0 0), (3 3, 7 3, 9 3, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))",
+      "MULTIPOLYGON (((0 0, 0 10, 0 5, 0 10, 0 0), (3 3, 7 3, 9 3, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+}
+
+TEST_F(GeometryFunctionsTest, testStSphericalArea) {
+  const auto testStSphericalAreaFunc =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<double>& expected) {
+        std::optional<double> result = evaluateOnce<double>(
+            "st_area(to_spherical_geography(ST_GeometryFromText(c0)))", wkt);
+
+        if (expected.has_value()) {
+          ASSERT_TRUE(aboutEquals(expected.value(), result.value()));
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  // Happy cases
+  testStSphericalAreaFunc("POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))", 123.64E8);
+  testStSphericalAreaFunc(
+      "POLYGON((-122.150124 37.486095, -122.149201 37.486606, -122.145725 37.486580, -122.145923 37.483961, -122.149324 37.482480, -122.150837 37.483238,  -122.150901 37.485392, -122.150124 37.486095))",
+      163290.93943428437);
+
+  double angleOfOneKm = 0.008993201943349;
+  testStSphericalAreaFunc(
+      fmt::format(
+          "POLYGON((0 0, {} 0, {} {}, 0 {}, 0 0))",
+          angleOfOneKm,
+          angleOfOneKm,
+          angleOfOneKm,
+          angleOfOneKm),
+      1E6);
+
+  // 1/4th of an hemisphere, ie 1/8th of the planet, should be close to 4PiR2/8
+  // = 637.58E11
+  testStSphericalAreaFunc("POLYGON((90 0, 0 0, 0 90, 90 0))", 637.58E11);
+
+  // A Polygon with a large hole
+  testStSphericalAreaFunc(
+      "POLYGON((90 0, 0 0, 0 90, 90 0), (89 1, 1 1, 1 89, 89 1))", 348.04E10);
+
+  // Empty input should return null
+  testStSphericalAreaFunc("POLYGON EMPTY", std::nullopt);
+  testStSphericalAreaFunc("MULTIPOLYGON EMPTY", std::nullopt);
+  // Empty invalid types return null rather than throw in java, so we do the
+  // same here.
+  testStSphericalAreaFunc("POINT EMPTY", std::nullopt);
+
+  // Invalid data types
+  VELOX_ASSERT_USER_THROW(
+      testStSphericalAreaFunc("POINT (0 1)", std::nullopt),
+      "ST_Area[SphericalGeography] only applies to Polygon or MultiPolygon. Input type is: Point");
+  VELOX_ASSERT_USER_THROW(
+      testStSphericalAreaFunc("MULTIPOINT (1 2, 3 4)", std::nullopt),
+      "ST_Area[SphericalGeography] only applies to Polygon or MultiPolygon. Input type is: MultiPoint");
+  VELOX_ASSERT_USER_THROW(
+      testStSphericalAreaFunc("LINESTRING (1 2, 3 4)", std::nullopt),
+      "ST_Area[SphericalGeography] only applies to Polygon or MultiPolygon. Input type is: LineString");
+  VELOX_ASSERT_USER_THROW(
+      testStSphericalAreaFunc(
+          "MULTILINESTRING ((0 0, 1 1), (2 2, 3 3))", std::nullopt),
+      "ST_Area[SphericalGeography] only applies to Polygon or MultiPolygon. Input type is: MultiLineString");
+  VELOX_ASSERT_USER_THROW(
+      testStSphericalAreaFunc(
+          "GEOMETRYCOLLECTION (POINT (1 2), LINESTRING (3 4, 5 6))",
+          std::nullopt),
+      "ST_Area[SphericalGeography] only applies to Polygon or MultiPolygon. Input type is: GeometryCollection");
+
+  // Invalid Polygon (duplicated point)
+  VELOX_ASSERT_USER_THROW(
+      testStSphericalAreaFunc(
+          "POLYGON((0 0, 0 1, 1 1, 1 1, 1 0, 0 0))", std::nullopt),
+      "Polygon is not valid: it has two identical consecutive vertices");
+
+  // Test areas for all 50 US states
+  for (const auto& [stateName, area] :
+       facebook::velox::geometry_test_utils::usStateAreas) {
+    const auto& wkt =
+        facebook::velox::geometry_test_utils::usStateWkts.at(stateName);
+    testStSphericalAreaFunc(std::optional<std::string>(wkt), area);
+  }
+
+  testStSphericalAreaFunc(
+      "POLYGON((-135 85, -45 85, 45 85, 135 85, -135 85))", 619.00E9);
+}
diff --git a/velox/functions/prestosql/tests/GreatestLeastTest.cpp b/velox/functions/prestosql/tests/GreatestLeastTest.cpp
index 028081ccf99..b9e9d7ed38d 100644
--- a/velox/functions/prestosql/tests/GreatestLeastTest.cpp
+++ b/velox/functions/prestosql/tests/GreatestLeastTest.cpp
@@ -19,6 +19,8 @@
 #include <optional>
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
+#include "velox/type/Time.h"
 
 using namespace facebook::velox;
 
@@ -286,6 +288,104 @@ TEST_F(GreatestLeastTest, leastDate) {
       DATE());
 }
 
+TEST_F(GreatestLeastTest, greatestLeastTime) {
+  using namespace facebook::velox::util;
+
+  // Helper to parse TIME from string
+  const auto parseTime = [](const std::string& timeStr) -> int64_t {
+    auto result = fromTimeString(timeStr.c_str(), timeStr.size());
+    if (result.hasError()) {
+      throw std::runtime_error("Parse error: " + result.error().message());
+    }
+    return result.value();
+  };
+
+  // Test greatest
+  runTest<int64_t>(
+      "greatest(c0, c1, c2)",
+      {
+          {parseTime("10:00:00"),
+           parseTime("00:00:00"),
+           parseTime("12:00:00.001")}, // c0
+          {parseTime("12:30:00"),
+           parseTime("12:00:00"),
+           parseTime("12:00:00.500")}, // c1
+          {parseTime("15:30:45.100"),
+           parseTime("23:59:59.999"),
+           parseTime("12:00:00.999")}, // c2
+      },
+      {parseTime("15:30:45.100"),
+       parseTime("23:59:59.999"),
+       parseTime("12:00:00.999")},
+      std::nullopt,
+      TIME(),
+      TIME());
+
+  // Test least
+  runTest<int64_t>(
+      "least(c0, c1, c2)",
+      {
+          {parseTime("10:00:00"),
+           parseTime("00:00:00"),
+           parseTime("12:00:00.001")}, // c0
+          {parseTime("12:30:00"),
+           parseTime("12:00:00"),
+           parseTime("12:00:00.500")}, // c1
+          {parseTime("15:30:45.100"),
+           parseTime("23:59:59.999"),
+           parseTime("12:00:00.999")}, // c2
+      },
+      {parseTime("10:00:00"), parseTime("00:00:00"), parseTime("12:00:00.001")},
+      std::nullopt,
+      TIME(),
+      TIME());
+}
+
+TEST_F(GreatestLeastTest, greatestLeastTimeWithTimezone) {
+  using namespace facebook::velox::util;
+
+  // Helper to parse TIME WITH TIME ZONE from string
+  const auto parseTimeWithTz = [](const std::string& timeStr) -> int64_t {
+    auto result = fromTimeWithTimezoneString(timeStr.c_str(), timeStr.size());
+    if (result.hasError()) {
+      throw std::runtime_error("Parse error: " + result.error().message());
+    }
+    return result.value();
+  };
+
+  // Test greatest
+  runTest<int64_t>(
+      "greatest(c0, c1, c2)",
+      {
+          {parseTimeWithTz("10:00:00+00:00"),
+           parseTimeWithTz("20:00:00-08:00")}, // c0
+          {parseTimeWithTz("10:00:00-08:00"),
+           parseTimeWithTz("23:59:59.999+00:00")}, // c1
+          {parseTimeWithTz("10:00:00+08:00"),
+           parseTimeWithTz("00:00:00+08:00")}, // c2
+      },
+      {parseTimeWithTz("10:00:00-08:00"), parseTimeWithTz("20:00:00-08:00")},
+      std::nullopt,
+      TIME_WITH_TIME_ZONE(),
+      TIME_WITH_TIME_ZONE());
+
+  // Test least
+  runTest<int64_t>(
+      "least(c0, c1, c2)",
+      {
+          {parseTimeWithTz("10:00:00+00:00"),
+           parseTimeWithTz("00:00:00-08:00")}, // c0
+          {parseTimeWithTz("10:00:00-08:00"),
+           parseTimeWithTz("23:59:59.999+00:00")}, // c1
+          {parseTimeWithTz("10:00:00+08:00"),
+           parseTimeWithTz("00:00:00+08:00")}, // c2
+      },
+      {parseTimeWithTz("10:00:00+08:00"), parseTimeWithTz("00:00:00+08:00")},
+      std::nullopt,
+      TIME_WITH_TIME_ZONE(),
+      TIME_WITH_TIME_ZONE());
+}
+
 TEST_F(GreatestLeastTest, greatestLeastIpAddress) {
   auto greatest = [&](const std::optional<std::string>& a,
                       const std::optional<std::string>& b,
@@ -324,6 +424,14 @@ TEST_F(GreatestLeastTest, greatestLeastIpAddress) {
       "255.255.255.255",
       "2001:0db8:0000:0000:0000:ff00:0042:832");
   EXPECT_FALSE(leastValueWithNulls.has_value());
+
+  // Case where raw comparison of values will give
+  // different result than comparison of IPAddress values byte by byte.
+  auto greatValue = greatest("ffff::1", "1::1", "1::2");
+  EXPECT_EQ("ffff::1", greatValue.value());
+
+  auto lessValue = least("ffff::1", "1::1", "ffff::2");
+  EXPECT_EQ("1::1", lessValue.value());
 }
 
 TEST_F(GreatestLeastTest, stringBuffersMoved) {
diff --git a/velox/functions/prestosql/tests/HyperLogLogFunctionsTest.cpp b/velox/functions/prestosql/tests/HyperLogLogFunctionsTest.cpp
index 040d1ce2f6f..83ca0f394d9 100644
--- a/velox/functions/prestosql/tests/HyperLogLogFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/HyperLogLogFunctionsTest.cpp
@@ -13,14 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/common/base/XxHashInline.h"
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/hyperloglog/SparseHll.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/functions/prestosql/types/HyperLogLogType.h"
-#define XXH_INLINE_ALL
-#include <xxhash.h>
 
-using facebook::velox::common::hll::DenseHll;
-using facebook::velox::common::hll::SparseHll;
+using namespace facebook::velox::common::hll;
 
 namespace facebook::velox {
 namespace {
@@ -32,22 +31,46 @@ uint64_t hashOne(T value) {
 
 class HyperLogLogFunctionsTest : public functions::test::FunctionBaseTest {
  protected:
+  template <typename TAllocator>
   static std::string serialize(
       int8_t indexBitLength,
-      const SparseHll& sparseHll) {
+      const SparseHll<TAllocator>& sparseHll) {
     std::string serialized;
     serialized.resize(sparseHll.serializedSize());
     sparseHll.serialize(indexBitLength, serialized.data());
     return serialized;
   }
 
-  static std::string serialize(DenseHll& denseHll) {
+  template <typename TAllocator>
+  static std::string serialize(DenseHll<TAllocator>& denseHll) {
     std::string serialized;
     serialized.resize(denseHll.serializedSize());
     denseHll.serialize(serialized.data());
     return serialized;
   }
 
+  // Creates sparse HLL with values from start (inclusive) to end (exclusive).
+  // modValue applies modulo operation if non-zero.
+  std::string
+  createSparse(int8_t indexBitLength, int start, int end, int modValue = 0) {
+    SparseHll<> hll{&allocator_};
+    for (int i = start; i < end; i++) {
+      hll.insertHash(hashOne(modValue ? (i % modValue) : i));
+    }
+    return serialize(indexBitLength, hll);
+  }
+
+  // Creates dense HLL with values from start (inclusive) to end (exclusive).
+  // modValue applies modulo operation if non-zero.
+  std::string
+  createDense(int8_t indexBitLength, int start, int end, int modValue = 0) {
+    DenseHll<> hll{indexBitLength, &allocator_};
+    for (int i = start; i < end; i++) {
+      hll.insertHash(hashOne(modValue ? (i % modValue) : i));
+    }
+    return serialize(hll);
+  }
+
   std::shared_ptr<memory::MemoryPool> pool_{
       memory::memoryManager()->addLeafPool()};
   HashStringAllocator allocator_{pool_.get()};
@@ -75,12 +98,7 @@ TEST_F(HyperLogLogFunctionsTest, cardinalitySparse) {
     return evaluateOnce<int64_t>("cardinality(c0)", HYPERLOGLOG(), input);
   };
 
-  SparseHll sparseHll{&allocator_};
-  for (int i = 0; i < 1'000; i++) {
-    sparseHll.insertHash(hashOne(i % 17));
-  }
-
-  auto serialized = serialize(11, sparseHll);
+  auto serialized = createSparse(11, 0, 1000, 17);
   EXPECT_EQ(17, cardinality(serialized));
 }
 
@@ -89,13 +107,14 @@ TEST_F(HyperLogLogFunctionsTest, cardinalityDense) {
     return evaluateOnce<int64_t>("cardinality(c0)", HYPERLOGLOG(), input);
   };
 
-  DenseHll denseHll{12, &allocator_};
+  DenseHll<> expectedHll{12, &allocator_};
   for (int i = 0; i < 10'000'000; i++) {
-    denseHll.insertHash(hashOne(i));
+    expectedHll.insertHash(hashOne(i));
   }
+  auto expectedCardinality = expectedHll.cardinality();
 
-  auto serialized = serialize(denseHll);
-  EXPECT_EQ(denseHll.cardinality(), cardinality(serialized));
+  auto serialized = createDense(12, 0, 10'000'000);
+  EXPECT_EQ(expectedCardinality, cardinality(serialized));
 }
 
 TEST_F(HyperLogLogFunctionsTest, emptyApproxSet) {
@@ -110,5 +129,180 @@ TEST_F(HyperLogLogFunctionsTest, emptyApproxSet) {
           "cardinality(empty_approx_set(0.1))", makeRowVector(ROW({}), 1)));
 }
 
+TEST_F(HyperLogLogFunctionsTest, mergeHll) {
+  // Test merging two HLL instances with different value ranges.
+  const int8_t indexBitLength = 12;
+
+  std::vector<std::string> serializedHlls = {
+      createSparse(indexBitLength, 0, 10),
+      createSparse(indexBitLength, 10, 20)};
+
+  auto elements = makeFlatVector(serializedHlls, HYPERLOGLOG());
+  auto arrayVector = makeArrayVector({0, 2}, elements);
+
+  auto cardinality = evaluateOnce<int64_t>(
+      "cardinality(merge_hll(c0))", makeRowVector({arrayVector}));
+
+  EXPECT_EQ(20, cardinality);
+}
+
+TEST_F(HyperLogLogFunctionsTest, mergeHllMixedSparseAndDense) {
+  // Test merging sparse and dense HLL instances.
+  const int8_t indexBitLength = 12;
+
+  std::vector<std::string> serializedHlls = {
+      createSparse(indexBitLength, 0, 50),
+      createDense(indexBitLength, 50, 2000)};
+
+  auto elements = makeFlatVector(serializedHlls, HYPERLOGLOG());
+  auto arrayVector = makeArrayVector({0, 2}, elements);
+
+  auto cardinality = evaluateOnce<int64_t>(
+      "cardinality(merge_hll(c0))", makeRowVector({arrayVector}));
+
+  EXPECT_EQ(1978, cardinality);
+}
+
+TEST_F(HyperLogLogFunctionsTest, mergeHllWithNull) {
+  auto serialized = createSparse(12, 0, 10);
+  auto elements = makeNullableFlatVector<std::string>(
+      {serialized, std::nullopt, serialized}, HYPERLOGLOG());
+  auto arrayVector = makeArrayVector({0, 3}, elements);
+
+  auto cardinality = evaluateOnce<int64_t>(
+      "cardinality(merge_hll(c0))", makeRowVector({arrayVector}));
+  EXPECT_EQ(10, cardinality);
+}
+
+TEST_F(HyperLogLogFunctionsTest, mergeHllEmpty) {
+  auto input = makeRowVector(
+      {makeArrayVectorFromJson<std::string>({"null"}, ARRAY(HYPERLOGLOG()))});
+  auto result = evaluate("merge_hll(c0)", input);
+  ASSERT_TRUE(result->isNullAt(0));
+}
+
+TEST_F(HyperLogLogFunctionsTest, mergeHllNullArray) {
+  auto input = makeRowVector({makeNullableArrayVector<std::string>(
+      {std::nullopt}, ARRAY(HYPERLOGLOG()))});
+  auto result = evaluate("merge_hll(c0)", input);
+  ASSERT_TRUE(result->isNullAt(0));
+}
+
+TEST_F(HyperLogLogFunctionsTest, mergeHllAllNulls) {
+  auto input = makeRowVector({makeArrayVectorFromJson<std::string>(
+      {"[null, null, null]"}, ARRAY(HYPERLOGLOG()))});
+  auto result = evaluate("merge_hll(c0)", input);
+  ASSERT_TRUE(result->isNullAt(0));
+}
+
+TEST_F(HyperLogLogFunctionsTest, mergeHllInvalidData) {
+  // Test with invalid HLL data format.
+  std::string invalidData = "invalid_hll_data";
+  auto elements = makeFlatVector<std::string>({invalidData}, HYPERLOGLOG());
+  auto arrayVector = makeArrayVector({0, 1}, elements);
+
+  VELOX_ASSERT_THROW(
+      evaluate("merge_hll(c0)", makeRowVector({arrayVector})),
+      "Invalid HLL data format");
+}
+
+TEST_F(HyperLogLogFunctionsTest, mergeHllMismatchedIndexBitLength) {
+  const int8_t indexBitLength1 = 11;
+  const int8_t indexBitLength2 = 12;
+
+  std::vector<std::string> serializedHlls = {
+      createSparse(indexBitLength1, 0, 5),
+      createSparse(indexBitLength2, 5, 10)};
+
+  auto elements = makeFlatVector(serializedHlls, HYPERLOGLOG());
+  auto arrayVector = makeArrayVector({0, 2}, elements);
+
+  VELOX_ASSERT_THROW(
+      evaluate("merge_hll(c0)", makeRowVector({arrayVector})),
+      "Cannot merge HLLs with different indexBitLength");
+}
+
+TEST_F(
+    HyperLogLogFunctionsTest,
+    mergeHllMismatchedIndexBitLengthDenseVsSparse) {
+  const int8_t indexBitLength1 = 11;
+  const int8_t indexBitLength2 = 12;
+
+  std::vector<std::string> serializedHlls = {
+      createSparse(indexBitLength1, 0, 50),
+      createDense(indexBitLength2, 50, 2000)};
+
+  auto elements = makeFlatVector(serializedHlls, HYPERLOGLOG());
+  auto arrayVector = makeArrayVector({0, 2}, elements);
+
+  VELOX_ASSERT_THROW(
+      evaluate("merge_hll(c0)", makeRowVector({arrayVector})),
+      "Cannot merge HLLs with different indexBitLength");
+}
+
+TEST_F(HyperLogLogFunctionsTest, mergeHllDenseFirstThenSparse) {
+  const int8_t indexBitLength = 12;
+
+  std::vector<std::string> serializedHlls = {
+      createDense(indexBitLength, 0, 2000),
+      createSparse(indexBitLength, 2000, 2050)};
+
+  auto elements = makeFlatVector(serializedHlls, HYPERLOGLOG());
+  auto arrayVector = makeArrayVector({0, 2}, elements);
+
+  auto cardinality = evaluateOnce<int64_t>(
+      "cardinality(merge_hll(c0))", makeRowVector({arrayVector}));
+
+  EXPECT_EQ(2035, cardinality);
+}
+
+TEST_F(HyperLogLogFunctionsTest, mergeHllDictionaryEncoded) {
+  // Test merge_hll can handle encoded array elements.
+  const int8_t indexBitLength = 12;
+
+  auto baseElements = makeFlatVector(
+      {createSparse(indexBitLength, 0, 10),
+       createSparse(indexBitLength, 10, 20)},
+      HYPERLOGLOG());
+
+  struct TestCase {
+    std::vector<vector_size_t> indices;
+    std::optional<std::vector<bool>> nulls;
+    int64_t expectedCardinality;
+  };
+
+  std::vector<TestCase> testCases = {
+      // Dictionary indices without nulls.
+      {{0, 1}, std::nullopt, 20},
+      {{1, 0}, std::nullopt, 20},
+      {{1, 1, 1}, std::nullopt, 10},
+      {{0, 0, 0, 0}, std::nullopt, 10},
+      {{1, 1, 0, 0, 1, 0}, std::nullopt, 20},
+      // Dictionary adds nulls: [1, null]
+      {{1, 0}, {{false, true}}, 10},
+      // Dictionary adds nulls: [null, 0, null]
+      {{0, 0, 0}, {{true, false, true}}, 10},
+      // Dictionary adds nulls: [null, null, 1, 1, null, 0]
+      {{0, 0, 1, 1, 0, 0}, {{true, true, false, false, true, false}}, 20},
+  };
+
+  for (const auto& testCase : testCases) {
+    auto indices = makeIndices(testCase.indices);
+    VectorPtr encodedElements;
+    if (testCase.nulls.has_value()) {
+      auto nulls = makeNulls(testCase.nulls.value());
+      encodedElements = BaseVector::wrapInDictionary(
+          nulls, indices, testCase.indices.size(), baseElements);
+    } else {
+      encodedElements = wrapInDictionary(indices, baseElements);
+    }
+    auto arrayVector = makeArrayVector(
+        {0, static_cast<int>(testCase.indices.size())}, encodedElements);
+    auto cardinality = evaluateOnce<int64_t>(
+        "cardinality(merge_hll(c0))", makeRowVector({arrayVector}));
+    EXPECT_EQ(testCase.expectedCardinality, cardinality);
+  }
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/tests/IPAddressFunctionsTest.cpp b/velox/functions/prestosql/tests/IPAddressFunctionsTest.cpp
index cecb8994c99..76d1add4b90 100644
--- a/velox/functions/prestosql/tests/IPAddressFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/IPAddressFunctionsTest.cpp
@@ -721,4 +721,48 @@ TEST_F(IPAddressFunctionsTest, IsPrivateIPTest) {
   EXPECT_EQ(std::nullopt, isPrivateIP(std::nullopt));
 }
 
+TEST_F(IPAddressFunctionsTest, ipVersionFromAddress) {
+  auto ipVersionFromAddress = [this](const std::optional<std::string>& input) {
+    return evaluateOnce<int64_t>("ip_version(cast(c0 as ipaddress))", input);
+  };
+
+  ASSERT_EQ(ipVersionFromAddress("1.2.3.4"), 4);
+  ASSERT_EQ(ipVersionFromAddress("255.255.255.255"), 4);
+  ASSERT_EQ(ipVersionFromAddress("::ffff:1.2.3.4"), 4);
+  ASSERT_EQ(ipVersionFromAddress("64:ff9b::17"), 6);
+  ASSERT_EQ(ipVersionFromAddress("2001:db8::1"), 6);
+  ASSERT_EQ(ipVersionFromAddress("::"), 6);
+  ASSERT_EQ(ipVersionFromAddress(std::nullopt), std::nullopt);
+}
+
+TEST_F(IPAddressFunctionsTest, ipVersionFromPrefix) {
+  auto ipVersionFromPrefix = [this](const std::optional<std::string>& input) {
+    return evaluateOnce<int64_t>("ip_version(cast(c0 as ipprefix))", input);
+  };
+
+  ASSERT_EQ(ipVersionFromPrefix("1.2.3.4/24"), 4);
+  ASSERT_EQ(ipVersionFromPrefix("192.168.0.0/16"), 4);
+  ASSERT_EQ(ipVersionFromPrefix("::ffff:1.2.3.4/24"), 4);
+  ASSERT_EQ(ipVersionFromPrefix("64:ff9b::17/64"), 6);
+  ASSERT_EQ(ipVersionFromPrefix("2001:db8::/32"), 6);
+  ASSERT_EQ(ipVersionFromPrefix("::1/128"), 6);
+  ASSERT_EQ(ipVersionFromPrefix(std::nullopt), std::nullopt);
+}
+
+TEST_F(IPAddressFunctionsTest, ipPrefixMaskLen) {
+  auto ipPrefixMaskLen = [this](const std::optional<std::string>& input) {
+    return evaluateOnce<int64_t>(
+        "ip_prefix_masklen(cast(c0 as ipprefix))", input);
+  };
+
+  ASSERT_EQ(ipPrefixMaskLen("1.2.3.4/24"), 24);
+  ASSERT_EQ(ipPrefixMaskLen("1.2.3.4/32"), 32);
+  ASSERT_EQ(ipPrefixMaskLen("0.0.0.0/0"), 0);
+  ASSERT_EQ(ipPrefixMaskLen("64:ff9b::17/64"), 64);
+  ASSERT_EQ(ipPrefixMaskLen("64:ff9b::17/128"), 128);
+  ASSERT_EQ(ipPrefixMaskLen("::1/128"), 128);
+  ASSERT_EQ(ipPrefixMaskLen("::/0"), 0);
+  ASSERT_EQ(ipPrefixMaskLen(std::nullopt), std::nullopt);
+}
+
 } // namespace facebook::velox::functions::prestosql
diff --git a/velox/functions/prestosql/tests/JsonCastTest.cpp b/velox/functions/prestosql/tests/JsonCastTest.cpp
index bd3019321de..7ab84abcfb8 100644
--- a/velox/functions/prestosql/tests/JsonCastTest.cpp
+++ b/velox/functions/prestosql/tests/JsonCastTest.cpp
@@ -1122,12 +1122,12 @@ TEST_F(JsonCastTest, toDouble) {
       JSON(),
       DOUBLE(),
       {"Infinity"_sv},
-      "The JSON document has an improper structure");
+      "The JSON element does not have the requested type");
   testThrow<JsonNativeType>(
       JSON(),
       DOUBLE(),
       {"NaN"_sv},
-      "The JSON document has an improper structure");
+      "The JSON element does not have the requested type");
 
   testThrow<JsonNativeType>(
       JSON(),
@@ -1822,3 +1822,18 @@ TEST_F(JsonCastTest, castFromJsonWithEscapingForSpecialUniocodeCharacters) {
   testCast(R"(["\u007F"])", "\u007F");
   testCast(R"(["\u008A"])", "\u008A");
 }
+
+TEST_F(JsonCastTest, uniqueErrorContextMessage) {
+  // Verify that exceptions thrown have the correct error context information.
+  testContextMessageOnThrow(
+      "cast((c0) as DOUBLE)",
+      makeRowVector({makeNullableFlatVector<JsonNativeType>({"\"abc\""_sv})}),
+      "Top-level Expression: cast((c0) as DOUBLE)");
+
+  // Test twice to ensure that the context is correctly generated for each
+  // expression and not cached and reused.
+  testContextMessageOnThrow(
+      "cast((c0) as BIGINT)",
+      makeRowVector({makeNullableFlatVector<JsonNativeType>({"\"abc\""_sv})}),
+      "Top-level Expression: cast((c0) as BIGINT)");
+}
diff --git a/velox/functions/prestosql/tests/JsonFunctionsTest.cpp b/velox/functions/prestosql/tests/JsonFunctionsTest.cpp
index d0b2e6ffe4e..12101b9adf8 100644
--- a/velox/functions/prestosql/tests/JsonFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/JsonFunctionsTest.cpp
@@ -251,6 +251,18 @@ TEST_F(JsonFunctionsTest, jsonFormat) {
   velox::test::assertEqualVectors(expected, result);
 }
 
+TEST_F(JsonFunctionsTest, jsonParseErrorContext) {
+  auto data = makeRowVector(
+      {makeFlatVector<StringView>({"1]"}), makeFlatVector<StringView>({"2]"})});
+  // Verify that exceptions thrown have the correct error context information.
+  testContextMessageOnThrow(
+      "json_parse(c0)", data, "Top-level Expression: json_parse(c0)");
+  // Test twice to ensure that the context is correctly generated for each
+  // expression and not cached and reused.
+  testContextMessageOnThrow(
+      "json_parse(c1)", data, "Top-level Expression: json_parse(c1)");
+}
+
 TEST_F(JsonFunctionsTest, jsonParse) {
   const auto jsonParse = [&](std::optional<std::string> value) {
     return evaluateOnce<StringView>("json_parse(c0)", value);
@@ -310,10 +322,13 @@ TEST_F(JsonFunctionsTest, jsonParse) {
       R"([{"response":"[\"fusil a peinture\",\"�uD83E\\uDE2Dau bois\"]"}])");
 
   VELOX_ASSERT_THROW(
-      jsonParse(R"({"k1":})"), "The JSON document has an improper structure");
+      jsonParse(R"({"k1":})"),
+      "The JSON element does not have the requested type");
   VELOX_ASSERT_THROW(
       jsonParse(R"({:"k1"})"), "The JSON document has an improper structure");
-  VELOX_ASSERT_THROW(jsonParse(R"(not_json)"), "Problem while parsing an atom");
+  // The exact exception message can change based on the simdjson version used.
+  // Instead, check that VeloxUserError for invalid Json is returned.
+  ASSERT_THROW(jsonParse(R"(not_json)"), VeloxUserError);
   VELOX_ASSERT_THROW(
       jsonParse("[1"),
       "JSON document ended early in the middle of an object or array");
@@ -736,7 +751,7 @@ TEST_F(JsonFunctionsTest, jsonArrayGet) {
     std::optional<StringView> s = json.has_value()
         ? std::make_optional(StringView(json.value()))
         : std::nullopt;
-    auto jsonInput = makeNullableFlatVector<std::string>({s}, jsontype);
+    auto jsonInput = makeNullableFlatVector<StringView>({s}, jsontype);
     auto indexInput = makeFlatVector<int64_t>(std::vector<int64_t>{index});
     return JsonFunctionsTest::jsonArrayGet(jsonInput, indexInput);
   };
@@ -1192,7 +1207,7 @@ TEST_F(JsonFunctionsTest, jsonExtractVarcharInput) {
     std::optional<StringView> s = json.has_value()
         ? std::make_optional(StringView(json.value()))
         : std::nullopt;
-    auto varcharInput = makeNullableFlatVector<std::string>({s}, VARCHAR());
+    auto varcharInput = makeNullableFlatVector<StringView>({s}, VARCHAR());
     auto pathInput = makeFlatVector<std::string>({path});
     return JsonFunctionsTest::jsonExtract(varcharInput, pathInput, wrapInTry);
   };
@@ -1226,11 +1241,12 @@ TEST_F(JsonFunctionsTest, jsonExtractVarcharInput) {
 
 TEST_F(JsonFunctionsTest, jsonStringToArrayCast) {
   // Array of strings.
-  auto data = makeRowVector({makeNullableFlatVector<std::string>(
-      {R"(["red","blue"])"_sv,
-       R"([null,null,"purple"])"_sv,
-       "[]"_sv,
-       "null"_sv})});
+  auto data = makeRowVector({makeNullableFlatVector<StringView>({
+      R"(["red","blue"])"_sv,
+      R"([null,null,"purple"])"_sv,
+      "[]"_sv,
+      "null"_sv,
+  })});
   auto expected = makeNullableArrayVector<StringView>(
       {{{"red"_sv, "blue"_sv}},
        {{std::nullopt, std::nullopt, "purple"_sv}},
@@ -1241,8 +1257,10 @@ TEST_F(JsonFunctionsTest, jsonStringToArrayCast) {
       "$internal$json_string_to_array_cast", ARRAY(VARCHAR()), data, expected);
 
   // Array of integers.
-  data = makeRowVector({makeNullableFlatVector<std::string>(
-      {R"(["10212","1015353"])"_sv, R"(["10322","285000"])"})});
+  data = makeRowVector({makeNullableFlatVector<StringView>({
+      R"(["10212","1015353"])"_sv,
+      R"(["10322","285000"])",
+  })});
   expected =
       makeNullableArrayVector<int64_t>({{10212, 1015353}, {10322, 285000}});
 
@@ -1252,19 +1270,21 @@ TEST_F(JsonFunctionsTest, jsonStringToArrayCast) {
 
 TEST_F(JsonFunctionsTest, jsonStringToMapCast) {
   // Map of strings.
-  auto data = makeRowVector({makeFlatVector<std::string>(
-      {R"({"red":1,"blue":2})"_sv,
-       R"({"green":3,"magenta":4})"_sv,
-       R"({"violet":1,"blue":2})"_sv,
-       R"({"yellow":1,"blue":2})"_sv,
-       R"({"purple":10,"cyan":5})"_sv})});
-
-  auto expected = makeMapVector<StringView, int64_t>(
-      {{{"red"_sv, 1}, {"blue"_sv, 2}},
-       {{"green"_sv, 3}, {"magenta"_sv, 4}},
-       {{"violet"_sv, 1}, {"blue"_sv, 2}},
-       {{"yellow"_sv, 1}, {"blue"_sv, 2}},
-       {{"purple"_sv, 10}, {"cyan"_sv, 5}}});
+  auto data = makeRowVector({makeFlatVector<StringView>({
+      R"({"red":1,"blue":2})"_sv,
+      R"({"green":3,"magenta":4})"_sv,
+      R"({"violet":1,"blue":2})"_sv,
+      R"({"yellow":1,"blue":2})"_sv,
+      R"({"purple":10,"cyan":5})"_sv,
+  })});
+
+  auto expected = makeMapVector<StringView, int64_t>({
+      {{"red"_sv, 1}, {"blue"_sv, 2}},
+      {{"green"_sv, 3}, {"magenta"_sv, 4}},
+      {{"violet"_sv, 1}, {"blue"_sv, 2}},
+      {{"yellow"_sv, 1}, {"blue"_sv, 2}},
+      {{"purple"_sv, 10}, {"cyan"_sv, 5}},
+  });
 
   checkInternalFn(
       "$internal$json_string_to_map_cast",
@@ -1275,12 +1295,13 @@ TEST_F(JsonFunctionsTest, jsonStringToMapCast) {
 
 TEST_F(JsonFunctionsTest, jsonStringToRowCast) {
   // Row of strings.
-  auto data = makeRowVector({makeFlatVector<std::string>(
-      {R"({"red":1,"blue":2})"_sv,
-       R"({"red":3,"blue":4})"_sv,
-       R"({"red":1,"blue":2})"_sv,
-       R"({"red":1,"blue":2})"_sv,
-       R"({"red":10,"blue":5})"_sv})});
+  auto data = makeRowVector({makeFlatVector<StringView>({
+      R"({"red":1,"blue":2})"_sv,
+      R"({"red":3,"blue":4})"_sv,
+      R"({"red":1,"blue":2})"_sv,
+      R"({"red":1,"blue":2})"_sv,
+      R"({"red":10,"blue":5})"_sv,
+  })});
 
   auto expected = makeRowVector(
       {makeFlatVector<int64_t>({1, 3, 1, 1, 10}),
diff --git a/velox/functions/prestosql/tests/KHyperLogLogCastTest.cpp b/velox/functions/prestosql/tests/KHyperLogLogCastTest.cpp
new file mode 100644
index 00000000000..e285d4942cb
--- /dev/null
+++ b/velox/functions/prestosql/tests/KHyperLogLogCastTest.cpp
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/tests/CastBaseTest.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+
+using namespace facebook::velox;
+
+class KHyperLogLogCastTest : public functions::test::CastBaseTest {};
+
+TEST_F(KHyperLogLogCastTest, toKHyperLogLog) {
+  testCast<StringView, StringView>(
+      VARBINARY(),
+      KHYPERLOGLOG(),
+      {"aaa"_sv, ""_sv, std::nullopt},
+      {"aaa"_sv, ""_sv, std::nullopt});
+  testCast<StringView, StringView>(
+      VARBINARY(),
+      KHYPERLOGLOG(),
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt},
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt});
+}
+
+TEST_F(KHyperLogLogCastTest, fromKHyperLogLog) {
+  testCast<StringView, StringView>(
+      KHYPERLOGLOG(),
+      VARBINARY(),
+      {"aaa"_sv, ""_sv, std::nullopt},
+      {"aaa"_sv, ""_sv, std::nullopt});
+  testCast<StringView, StringView>(
+      KHYPERLOGLOG(),
+      VARBINARY(),
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt},
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt});
+}
diff --git a/velox/functions/prestosql/tests/KHyperLogLogFunctionsTest.cpp b/velox/functions/prestosql/tests/KHyperLogLogFunctionsTest.cpp
new file mode 100644
index 00000000000..23a9843a0f3
--- /dev/null
+++ b/velox/functions/prestosql/tests/KHyperLogLogFunctionsTest.cpp
@@ -0,0 +1,690 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/functions/lib/KHyperLogLog.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+using namespace facebook::velox::common::hll;
+using namespace facebook::velox::functions::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class KHyperLogLogFunctionsTest : public functions::test::FunctionBaseTest {
+ protected:
+  void SetUp() override {
+    FunctionBaseTest::SetUp();
+    pool_ = memory::memoryManager()->addLeafPool();
+    allocator_ = std::make_unique<HashStringAllocator>(pool_.get());
+  }
+
+  // Helper to create a KHLL with specific value-UII pairs.
+  std::string createKHLL(
+      const std::vector<std::pair<int64_t, int64_t>>& valueUiiPairs) {
+    auto khll = std::make_unique<
+        common::hll::KHyperLogLog<int64_t, HashStringAllocator>>(
+        allocator_.get());
+
+    for (const auto& [value, uii] : valueUiiPairs) {
+      khll->add(value, uii);
+    }
+
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    return outputBuffer;
+  }
+
+  // Helper to create array of KHLLs for merge_khll SQL function.
+  VectorPtr createKHLLArray(const std::vector<std::string>& serializedKHLLs) {
+    return makeArrayVector<std::string>({serializedKHLLs}, KHYPERLOGLOG());
+  }
+
+  // Build a map from the result vector for easier verification.
+  std::map<int64_t, double> createResultMap(MapVector* mapVector) {
+    auto mapSize = mapVector->sizeAt(0);
+
+    auto offset = mapVector->offsetAt(0);
+    auto keys = mapVector->mapKeys()->as<SimpleVector<int64_t>>();
+    auto values = mapVector->mapValues()->as<SimpleVector<double>>();
+
+    std::map<int64_t, double> resultMap;
+    for (vector_size_t i = 0; i < mapSize; ++i) {
+      resultMap[keys->valueAt(offset + i)] = values->valueAt(offset + i);
+    }
+    return resultMap;
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_;
+  std::unique_ptr<HashStringAllocator> allocator_;
+};
+
+TEST_F(KHyperLogLogFunctionsTest, cardinalityBasic) {
+  auto serialized = createKHLL({{0, 10}, {1, 11}, {2, 12}});
+  auto input =
+      makeFlatVector<StringView>({StringView(serialized)}, KHYPERLOGLOG());
+  auto result = evaluate("cardinality(c0)", makeRowVector({input}));
+  auto expected = makeFlatVector<int64_t>({3});
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(KHyperLogLogFunctionsTest, mergeKhll) {
+  // Merge KHLLs with completely disjoint key sets.
+  {
+    auto khll1 = createKHLL({{0, 10}, {1, 11}, {2, 12}});
+    auto khll2 = createKHLL({{3, 13}, {4, 14}, {5, 15}});
+    auto khll3 = createKHLL({{6, 16}, {7, 17}, {8, 18}});
+
+    auto arrayInput = createKHLLArray({khll1, khll2, khll3});
+    auto result = evaluate("merge_khll(c0)", makeRowVector({arrayInput}));
+    EXPECT_FALSE(result->isNullAt(0));
+    EXPECT_EQ(result->type(), KHYPERLOGLOG());
+
+    auto cardinalityResult =
+        evaluate("cardinality(c0)", makeRowVector({result}));
+    auto expected = makeFlatVector<int64_t>({9});
+    assertEqualVectors(expected, cardinalityResult);
+  }
+
+  // Merge KHLLs with overlapping key sets.
+  {
+    auto khll1 = createKHLL({{0, 10}, {1, 11}, {2, 12}, {3, 13}, {4, 14}});
+    auto khll2 = createKHLL({{3, 13}, {4, 14}, {5, 15}, {6, 16}, {7, 17}});
+
+    auto arrayInput = createKHLLArray({khll1, khll2});
+    auto result = evaluate("merge_khll(c0)", makeRowVector({arrayInput}));
+
+    auto cardinalityResult =
+        evaluate("cardinality(c0)", makeRowVector({result}));
+    auto expected = makeFlatVector<int64_t>({8});
+    assertEqualVectors(expected, cardinalityResult);
+  }
+
+  // Merge KHLL with single element.
+  {
+    auto khll = createKHLL({{0, 10}, {1, 11}, {2, 12}});
+    auto arrayInput = createKHLLArray({khll});
+    auto result = evaluate("merge_khll(c0)", makeRowVector({arrayInput}));
+
+    auto cardinalityResult =
+        evaluate("cardinality(c0)", makeRowVector({result}));
+    auto expected = makeFlatVector<int64_t>({3});
+    assertEqualVectors(expected, cardinalityResult);
+  }
+
+  // Merge same KHLL multiple times.
+  {
+    auto khll = createKHLL({{0, 10}, {1, 11}, {2, 12}});
+    auto arrayInput = createKHLLArray({khll, khll, khll});
+    auto result = evaluate("merge_khll(c0)", makeRowVector({arrayInput}));
+
+    // Cardinality should still be 3.
+    auto cardinalityResult =
+        evaluate("cardinality(c0)", makeRowVector({result}));
+    auto expected = makeFlatVector<int64_t>({3});
+    assertEqualVectors(expected, cardinalityResult);
+  }
+
+  // Empty array
+  {
+    auto elements = makeFlatVector<StringView>({}, KHYPERLOGLOG());
+    auto arrayInput = makeArrayVector({0}, elements);
+    auto result = evaluate("merge_khll(c0)", makeRowVector({arrayInput}));
+
+    EXPECT_TRUE(result->isNullAt(0));
+  }
+
+  // Array with nulls
+  {
+    auto khll = createKHLL({{0, 10}, {1, 11}, {2, 12}});
+
+    std::vector<std::string> serializedData;
+    serializedData.push_back(khll);
+
+    auto elements = makeNullableFlatVector<StringView>(
+        {StringView(serializedData[0]),
+         std::nullopt,
+         StringView(serializedData[0])},
+        KHYPERLOGLOG());
+    auto arrayInput = makeArrayVector({0}, elements, {3});
+
+    auto result = evaluate("merge_khll(c0)", makeRowVector({arrayInput}));
+
+    EXPECT_FALSE(result->isNullAt(0));
+
+    auto cardinalityResult =
+        evaluate("cardinality(c0)", makeRowVector({result}));
+    auto expected = makeFlatVector<int64_t>({3});
+    assertEqualVectors(expected, cardinalityResult);
+  }
+
+  // All nulls in array
+  {
+    auto elements = makeNullableFlatVector<StringView>(
+        {std::nullopt, std::nullopt, std::nullopt}, KHYPERLOGLOG());
+    auto arrayInput = makeArrayVector({0}, elements, {3});
+    auto result = evaluate("merge_khll(c0)", makeRowVector({arrayInput}));
+
+    EXPECT_TRUE(result->isNullAt(0));
+  }
+
+  // Null array
+  {
+    auto nullArray =
+        makeNullableFlatVector<int64_t>({std::nullopt}, ARRAY(KHYPERLOGLOG()));
+    auto result = evaluate("merge_khll(c0)", makeRowVector({nullArray}));
+
+    EXPECT_TRUE(result->isNullAt(0));
+  }
+}
+
+TEST_F(KHyperLogLogFunctionsTest, intersectionCardinalityExact) {
+  {
+    auto khll1 = createKHLL({{0, 10}, {1, 11}, {2, 12}, {3, 13}, {4, 14}});
+    auto khll2 = createKHLL({{3, 13}, {4, 14}, {5, 15}, {6, 16}, {7, 17}});
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(khll1)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(khll2)}, KHYPERLOGLOG());
+
+    auto result = evaluate(
+        "intersection_cardinality(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<int64_t>({2});
+    assertEqualVectors(expected, result);
+  }
+
+  // Intersection cardinality of completely overlapping KHLLs.
+  {
+    auto khll = createKHLL({{0, 10}, {1, 11}, {2, 12}, {3, 13}, {4, 14}});
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(khll)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(khll)}, KHYPERLOGLOG());
+
+    auto result = evaluate(
+        "intersection_cardinality(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<int64_t>({5});
+    assertEqualVectors(expected, result);
+  }
+
+  // Intersection cardinality of empty sets.
+  {
+    auto emptyKhll = createKHLL({});
+    auto nonEmptyKhll = createKHLL({{0, 10}, {1, 11}, {2, 12}});
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(emptyKhll)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(nonEmptyKhll)}, KHYPERLOGLOG());
+
+    auto result = evaluate(
+        "intersection_cardinality(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<int64_t>({0});
+    assertEqualVectors(expected, result);
+
+    // Test in reverse order.
+    result = evaluate(
+        "intersection_cardinality(c0, c1)", makeRowVector({input2, input1}));
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    auto emptyKhll1 = createKHLL({});
+    auto emptyKhll2 = createKHLL({});
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(emptyKhll1)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(emptyKhll2)}, KHYPERLOGLOG());
+
+    auto result = evaluate(
+        "intersection_cardinality(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<int64_t>({0});
+    assertEqualVectors(expected, result);
+  }
+
+  // Intersection cardinality of completely disjoint sets
+  {
+    auto khll1 = createKHLL({{0, 10}, {1, 11}, {2, 12}});
+    auto khll2 = createKHLL({{100, 110}, {101, 111}, {102, 112}});
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(khll1)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(khll2)}, KHYPERLOGLOG());
+
+    auto result = evaluate(
+        "intersection_cardinality(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<int64_t>({0});
+    assertEqualVectors(expected, result);
+  }
+
+  // Intersection where one is a subset of the other.
+  {
+    auto khll1 = createKHLL(
+        {{0, 10},
+         {1, 11},
+         {2, 12},
+         {3, 13},
+         {4, 14},
+         {5, 15},
+         {6, 16},
+         {7, 17},
+         {8, 18},
+         {9, 19}});
+    auto khll2 = createKHLL({{2, 12}, {3, 13}, {4, 14}});
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(khll1)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(khll2)}, KHYPERLOGLOG());
+
+    auto result = evaluate(
+        "intersection_cardinality(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<int64_t>({3});
+    assertEqualVectors(expected, result);
+  }
+}
+
+TEST_F(KHyperLogLogFunctionsTest, intersectionCardinalityApproximate) {
+  // KHLL1: 0-4999 (5000 values), KHLL2: 2500-5499 (3000 values).
+  // Expected intersection: 2500-4999 (2500 elements).
+  {
+    auto khll1 = std::make_unique<
+        common::hll::KHyperLogLog<int64_t, HashStringAllocator>>(
+        allocator_.get());
+    auto khll2 = std::make_unique<
+        common::hll::KHyperLogLog<int64_t, HashStringAllocator>>(
+        allocator_.get());
+
+    for (int64_t i = 0; i < 5000; ++i) {
+      khll1->add(i, 100);
+    }
+
+    for (int64_t i = 2500; i < 5500; ++i) {
+      khll2->add(i, 100);
+    }
+
+    std::string serialized1(khll1->estimatedSerializedSize(), '\0');
+    khll1->serialize(serialized1.data());
+
+    std::string serialized2(khll2->estimatedSerializedSize(), '\0');
+    khll2->serialize(serialized2.data());
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(serialized1)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(serialized2)}, KHYPERLOGLOG());
+
+    auto result = evaluate(
+        "intersection_cardinality(c0, c1)", makeRowVector({input1, input2}));
+
+    // Allow 5% error for approximation
+    auto actualResult = result->as<FlatVector<int64_t>>()->valueAt(0);
+    EXPECT_NEAR(actualResult, 2500, 2500 * 0.05);
+  }
+
+  {
+    auto khll = std::make_unique<
+        common::hll::KHyperLogLog<int64_t, HashStringAllocator>>(
+        allocator_.get());
+
+    for (int64_t i = 0; i < 5000; ++i) {
+      khll->add(i, 100);
+    }
+
+    std::string serialized(khll->estimatedSerializedSize(), '\0');
+    khll->serialize(serialized.data());
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(serialized)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(serialized)}, KHYPERLOGLOG());
+
+    auto result = evaluate(
+        "intersection_cardinality(c0, c1)", makeRowVector({input1, input2}));
+
+    auto actualResult = result->as<FlatVector<int64_t>>()->valueAt(0);
+    EXPECT_NEAR(actualResult, 5000, 5000 * 0.05);
+  }
+}
+
+TEST_F(KHyperLogLogFunctionsTest, uniquenessDistribution) {
+  auto serialized = createKHLL(
+      {{0, 0}, {1, 0}, {1, 1}, {2, 0}, {2, 1}, {3, 0}, {3, 1}, {3, 2}});
+  auto input =
+      makeFlatVector<StringView>({StringView(serialized)}, KHYPERLOGLOG());
+
+  // Uniqueness distribution with default histogram size of 4.
+  {
+    auto result =
+        evaluate("uniqueness_distribution(c0)", makeRowVector({input}));
+
+    EXPECT_FALSE(result->isNullAt(0));
+    EXPECT_EQ(result->type()->kind(), TypeKind::MAP);
+
+    auto mapVector = result->as<MapVector>();
+    auto mapSize = mapVector->sizeAt(0);
+    EXPECT_EQ(mapSize, 4);
+
+    auto resultMap = createResultMap(mapVector);
+
+    std::map<int64_t, double> expected;
+    for (int i = 1; i <= mapSize; ++i) {
+      expected[i] = 0;
+    }
+    expected[1] = 0.25;
+    expected[2] = 0.5;
+    expected[3] = 0.25;
+
+    EXPECT_EQ(resultMap, expected);
+  }
+
+  // Uniqueness distribution with custom histogram size.
+  {
+    auto histSize = makeFlatVector<int64_t>({128});
+    auto result = evaluate(
+        "uniqueness_distribution(c0, c1)", makeRowVector({input, histSize}));
+
+    EXPECT_FALSE(result->isNullAt(0));
+    EXPECT_EQ(result->type()->kind(), TypeKind::MAP);
+
+    auto mapVector = result->as<MapVector>();
+    auto mapSize = mapVector->sizeAt(0);
+    EXPECT_EQ(mapSize, 128);
+
+    auto resultMap = createResultMap(mapVector);
+
+    std::map<int64_t, double> expected;
+    for (int i = 1; i <= mapSize; ++i) {
+      expected[i] = 0;
+    }
+    expected[1] = 0.25;
+    expected[2] = 0.5;
+    expected[3] = 0.25;
+
+    EXPECT_EQ(resultMap, expected);
+  }
+
+  // Uniqueness distribution with empty KHLL. Since minhashSize is 0, the
+  // histogram size is 0 and the returned map is empty.
+  {
+    auto emptyKhll = createKHLL({});
+    auto emptyInput =
+        makeFlatVector<StringView>({StringView(emptyKhll)}, KHYPERLOGLOG());
+    auto result =
+        evaluate("uniqueness_distribution(c0)", makeRowVector({emptyInput}));
+
+    EXPECT_FALSE(result->isNullAt(0));
+    auto mapVector = result->as<MapVector>();
+    auto mapSize = mapVector->sizeAt(0);
+    EXPECT_EQ(mapSize, 0);
+  }
+
+  // Null inputs
+  {
+    auto nullKhll =
+        makeNullableFlatVector<StringView>({std::nullopt}, KHYPERLOGLOG());
+    auto result =
+        evaluate("uniqueness_distribution(c0)", makeRowVector({nullKhll}));
+    EXPECT_TRUE(result->isNullAt(0));
+    auto nullHistSize = makeNullableFlatVector<int64_t>({std::nullopt});
+    result = evaluate(
+        "uniqueness_distribution(c0, c1)",
+        makeRowVector({input, nullHistSize}));
+    EXPECT_TRUE(result->isNullAt(0));
+  }
+}
+
+TEST_F(KHyperLogLogFunctionsTest, jaccardIndex) {
+  // Jaccard index with identical sets.
+  {
+    auto khll = createKHLL({{0, 10}, {1, 11}, {2, 12}, {3, 13}, {4, 14}});
+    auto input1 =
+        makeFlatVector<StringView>({StringView(khll)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(khll)}, KHYPERLOGLOG());
+
+    auto result =
+        evaluate("jaccard_index(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<double>({1.0});
+    assertEqualVectors(expected, result);
+  }
+
+  // Jaccard index with completely disjoint sets.
+  {
+    auto khll1 = createKHLL({{0, 10}, {1, 11}, {2, 12}});
+    auto khll2 = createKHLL({{100, 110}, {101, 111}, {102, 112}});
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(khll1)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(khll2)}, KHYPERLOGLOG());
+
+    auto result =
+        evaluate("jaccard_index(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<double>({0.0});
+    assertEqualVectors(expected, result);
+  }
+
+  // Jaccard index with some overlapping elements.
+  {
+    auto khll1 = createKHLL({{0, 10}, {1, 11}, {2, 12}, {3, 13}, {4, 14}});
+    auto khll2 = createKHLL({{3, 13}, {4, 14}, {5, 15}, {6, 16}, {7, 17}});
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(khll1)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(khll2)}, KHYPERLOGLOG());
+
+    auto result =
+        evaluate("jaccard_index(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<double>({0.2});
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    auto khll1 = createKHLL(
+        {{0, 10},
+         {1, 11},
+         {2, 12},
+         {3, 13},
+         {4, 14},
+         {5, 15},
+         {6, 16},
+         {7, 17},
+         {8, 18},
+         {9, 19}});
+    auto khll2 = createKHLL({{2, 12}, {3, 13}, {4, 14}});
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(khll1)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(khll2)}, KHYPERLOGLOG());
+
+    auto result =
+        evaluate("jaccard_index(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<double>({0.6666666666666666});
+    assertEqualVectors(expected, result);
+  }
+
+  // Jaccard index with both sets empty. Jaccard index of two empty sets is
+  // defined as 1.0
+  {
+    auto emptyKhll1 = createKHLL({});
+    auto emptyKhll2 = createKHLL({});
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(emptyKhll1)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(emptyKhll2)}, KHYPERLOGLOG());
+
+    auto result =
+        evaluate("jaccard_index(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<double>({1.0});
+    assertEqualVectors(expected, result);
+  }
+
+  // Jaccard index with an empty and non empty set.
+  {
+    auto emptyKhll = createKHLL({});
+    auto nonEmptyKhll = createKHLL({{0, 10}, {1, 11}, {2, 12}});
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(emptyKhll)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(nonEmptyKhll)}, KHYPERLOGLOG());
+
+    auto result =
+        evaluate("jaccard_index(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<double>({0.0});
+    assertEqualVectors(expected, result);
+
+    // Test in reverse order
+    result = evaluate("jaccard_index(c0, c1)", makeRowVector({input2, input1}));
+    assertEqualVectors(expected, result);
+  }
+}
+
+TEST_F(KHyperLogLogFunctionsTest, reidentificationPotential) {
+  // Different reidentification potential cases
+  {
+    auto khll = createKHLL({{0, 0}, {1, 0}, {2, 0}});
+    auto input = makeFlatVector<StringView>({StringView(khll)}, KHYPERLOGLOG());
+    auto threshold = makeFlatVector<int64_t>({2});
+
+    auto result = evaluate(
+        "reidentification_potential(c0, c1)",
+        makeRowVector({input, threshold}));
+    auto expected = makeFlatVector<double>({1.0});
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    auto khll = createKHLL({
+        {0, 0},
+        {0, 1},
+        {0, 2},
+        {0, 3},
+        {0, 4}, // Value 0: 5 UIIs
+        {1, 0},
+        {1, 1},
+        {1, 2},
+        {1, 3}, // Value 1: 4 UIIs
+        {2, 0},
+        {2, 1},
+        {2, 2} // Value 2: 3 UIIs
+    });
+    auto input = makeFlatVector<StringView>({StringView(khll)}, KHYPERLOGLOG());
+    auto threshold = makeFlatVector<int64_t>({2});
+
+    auto result = evaluate(
+        "reidentification_potential(c0, c1)",
+        makeRowVector({input, threshold}));
+    auto expected = makeFlatVector<double>({0.0});
+    assertEqualVectors(expected, result);
+  }
+
+  // 2 out of 3 values at risk.
+  {
+    auto khll = createKHLL({
+        {0, 0},
+        {0, 1}, // Value 0: 2 UIIs
+        {1, 0},
+        {1, 1},
+        {1, 2}, // Value 1: 3 UIIs
+        {2, 0} // Value 2: 1 UII
+    });
+    auto input = makeFlatVector<StringView>({StringView(khll)}, KHYPERLOGLOG());
+    auto threshold = makeFlatVector<int64_t>({2});
+
+    auto result = evaluate(
+        "reidentification_potential(c0, c1)",
+        makeRowVector({input, threshold}));
+    auto expected = makeFlatVector<double>({0.6666666666666666});
+    assertEqualVectors(expected, result);
+  }
+
+  // Reidentification potential with threshold of 0.
+  {
+    auto khll = createKHLL({{0, 0}, {1, 0}, {2, 0}});
+    auto input = makeFlatVector<StringView>({StringView(khll)}, KHYPERLOGLOG());
+    auto threshold = makeFlatVector<int64_t>({0});
+
+    auto result = evaluate(
+        "reidentification_potential(c0, c1)",
+        makeRowVector({input, threshold}));
+    auto expected = makeFlatVector<double>({0.0});
+    assertEqualVectors(expected, result);
+  }
+
+  // Reidentification potential with empty KHLL
+  {
+    auto emptyKhll = createKHLL({});
+    auto input =
+        makeFlatVector<StringView>({StringView(emptyKhll)}, KHYPERLOGLOG());
+    auto threshold = makeFlatVector<int64_t>({2});
+
+    auto result = evaluate(
+        "reidentification_potential(c0, c1)",
+        makeRowVector({input, threshold}));
+    auto expected = makeFlatVector<double>({0.0});
+    assertEqualVectors(expected, result);
+  }
+
+  // Reidentification potential with single value with multiple UIIs.
+  {
+    auto khll = createKHLL({{0, 0}, {0, 1}, {0, 2}});
+    auto input = makeFlatVector<StringView>({StringView(khll)}, KHYPERLOGLOG());
+    auto threshold = makeFlatVector<int64_t>({2});
+
+    auto result = evaluate(
+        "reidentification_potential(c0, c1)",
+        makeRowVector({input, threshold}));
+    auto expected = makeFlatVector<double>({0.0});
+    assertEqualVectors(expected, result);
+  }
+
+  // Null inputs
+  {
+    auto nullKhll =
+        makeNullableFlatVector<StringView>({std::nullopt}, KHYPERLOGLOG());
+    auto threshold = makeFlatVector<int64_t>({2});
+
+    auto result = evaluate(
+        "reidentification_potential(c0, c1)",
+        makeRowVector({nullKhll, threshold}));
+    EXPECT_TRUE(result->isNullAt(0));
+
+    auto khll = createKHLL({{0, 0}, {1, 0}});
+    auto input = makeFlatVector<StringView>({StringView(khll)}, KHYPERLOGLOG());
+    auto nullThreshold = makeNullableFlatVector<int64_t>({std::nullopt});
+    result = evaluate(
+        "reidentification_potential(c0, c1)",
+        makeRowVector({input, nullThreshold}));
+    EXPECT_TRUE(result->isNullAt(0));
+  }
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/L2NormTest.cpp b/velox/functions/prestosql/tests/L2NormTest.cpp
new file mode 100644
index 00000000000..e8f7f669070
--- /dev/null
+++ b/velox/functions/prestosql/tests/L2NormTest.cpp
@@ -0,0 +1,786 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cmath>
+#include <cstdint>
+#include <numbers>
+#include <optional>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/type/StringView.h"
+#include "velox/type/Type.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/SimpleVector.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class L2NormTest : public test::FunctionBaseTest {
+ protected:
+  template <typename T>
+  void testArrayL2Norm(
+      const std::vector<std::vector<std::optional<T>>>& input,
+      const std::vector<std::optional<double>>& expected) {
+    auto inputArray = makeNullableArrayVector(input);
+    auto result = evaluate("l2_norm(c0)", makeRowVector({inputArray}));
+
+    auto expectedVector = makeNullableFlatVector<double>(expected, DOUBLE());
+    assertEqualVectors(expectedVector, result);
+  }
+};
+
+// Test basic integer arrays
+TEST_F(L2NormTest, integerArray) {
+  // sqrt(3^2 + 4^2) = sqrt(9 + 16) = sqrt(25) = 5
+  testArrayL2Norm<int32_t>({{3, 4}}, {5.0});
+
+  // sqrt(1^2 + 2^2 + 2^2) = sqrt(1 + 4 + 4) = sqrt(9) = 3
+  testArrayL2Norm<int32_t>({{1, 2, 2}}, {3.0});
+
+  // sqrt(1^2) = 1
+  testArrayL2Norm<int32_t>({{1}}, {1.0});
+
+  // sqrt(0^2) = 0
+  testArrayL2Norm<int32_t>({{0}}, {0.0});
+}
+
+// Test double arrays
+TEST_F(L2NormTest, doubleArray) {
+  auto inputArray = makeArrayVector<double>({{3.0, 4.0}});
+  auto result = evaluate("l2_norm(c0)", makeRowVector({inputArray}));
+
+  auto expected = makeFlatVector<double>({5.0}, DOUBLE());
+  assertEqualVectors(expected, result);
+}
+
+// Test float arrays
+TEST_F(L2NormTest, floatArray) {
+  auto inputArray = makeArrayVector<float>({{3.0F, 4.0F}});
+  auto result = evaluate("l2_norm(c0)", makeRowVector({inputArray}));
+
+  auto expected = makeFlatVector<double>({5.0}, DOUBLE());
+  assertEqualVectors(expected, result);
+}
+
+// Test empty arrays - should return 0.0
+TEST_F(L2NormTest, emptyArray) {
+  auto inputArray = makeArrayVector<int32_t>({{}});
+  auto result = evaluate("l2_norm(c0)", makeRowVector({inputArray}));
+
+  auto expected = makeFlatVector<double>({0.0}, DOUBLE());
+  assertEqualVectors(expected, result);
+}
+
+// Test arrays with null elements - nulls are skipped
+TEST_F(L2NormTest, nullElementsInArray) {
+  // sqrt(3^2 + 4^2) = 5 (null is skipped)
+  testArrayL2Norm<int32_t>({{3, std::nullopt, 4}}, {5.0});
+
+  // sqrt(5^2) = 5 (nulls are skipped)
+  testArrayL2Norm<int32_t>({{std::nullopt, 5, std::nullopt}}, {5.0});
+
+  // All nulls - should return 0
+  testArrayL2Norm<int32_t>({{std::nullopt, std::nullopt}}, {0.0});
+}
+
+// Test null array - should return null
+TEST_F(L2NormTest, nullArray) {
+  auto nullArray = BaseVector::createNullConstant(ARRAY(INTEGER()), 1, pool());
+  auto result = evaluate("l2_norm(c0)", makeRowVector({nullArray}));
+
+  auto expected = BaseVector::createNullConstant(DOUBLE(), 1, pool());
+  assertEqualVectors(expected, result);
+}
+
+// Test negative numbers
+TEST_F(L2NormTest, negativeNumbers) {
+  // sqrt((-3)^2 + (-4)^2) = sqrt(9 + 16) = 5
+  testArrayL2Norm<int32_t>({{-3, -4}}, {5.0});
+
+  // sqrt((-3)^2 + 4^2) = sqrt(9 + 16) = 5
+  testArrayL2Norm<int32_t>({{-3, 4}}, {5.0});
+}
+
+// Test large arrays
+TEST_F(L2NormTest, largeArray) {
+  // Create array [1, 1, 1, ..., 1] with 100 ones
+  // sqrt(100 * 1^2) = sqrt(100) = 10
+  const std::vector<std::optional<int32_t>> ones(100, 1);
+  testArrayL2Norm<int32_t>({ones}, {10.0});
+}
+
+// Test multiple rows
+TEST_F(L2NormTest, multipleRows) {
+  auto inputArray = makeArrayVector<int32_t>({
+      {3, 4}, // sqrt(25) = 5
+      {1, 0}, // sqrt(1) = 1
+      {0, 0, 0}, // sqrt(0) = 0
+      {1, 2, 2}, // sqrt(9) = 3
+  });
+
+  auto result = evaluate("l2_norm(c0)", makeRowVector({inputArray}));
+  auto expected = makeFlatVector<double>({5.0, 1.0, 0.0, 3.0}, DOUBLE());
+  assertEqualVectors(expected, result);
+}
+
+// Test different integer types
+TEST_F(L2NormTest, differentIntegerTypes) {
+  // int8_t
+  auto inputInt8 = makeArrayVector<int8_t>({{3, 4}});
+  auto resultInt8 = evaluate("l2_norm(c0)", makeRowVector({inputInt8}));
+  auto expectedInt8 = makeFlatVector<double>({5.0}, DOUBLE());
+  assertEqualVectors(expectedInt8, resultInt8);
+
+  // int16_t
+  auto inputInt16 = makeArrayVector<int16_t>({{3, 4}});
+  auto resultInt16 = evaluate("l2_norm(c0)", makeRowVector({inputInt16}));
+  assertEqualVectors(expectedInt8, resultInt16);
+
+  // int64_t
+  auto inputInt64 = makeArrayVector<int64_t>({{3, 4}});
+  auto resultInt64 = evaluate("l2_norm(c0)", makeRowVector({inputInt64}));
+  assertEqualVectors(expectedInt8, resultInt64);
+}
+
+// Test unit vector (L2 norm should be 1)
+TEST_F(L2NormTest, unitVector) {
+  // A normalized unit vector
+  const double kInvSqrt2 = 1.0 / std::numbers::sqrt2;
+  auto inputArray = makeArrayVector<double>({{kInvSqrt2, kInvSqrt2}});
+  auto result = evaluate("l2_norm(c0)", makeRowVector({inputArray}));
+
+  // Result should be very close to 1.0
+  auto resultVector = result->as<SimpleVector<double>>();
+  ASSERT_NEAR(1.0, resultVector->valueAt(0), 1e-10);
+}
+
+// Test large values
+TEST_F(L2NormTest, largeValues) {
+  auto inputArray = makeArrayVector<double>({{1e10, 1e10}});
+  auto result = evaluate("l2_norm(c0)", makeRowVector({inputArray}));
+
+  auto resultVector = result->as<SimpleVector<double>>();
+  const double expected = std::numbers::sqrt2 * 1e10;
+  ASSERT_NEAR(expected, resultVector->valueAt(0), 1e5);
+}
+
+// Test small values
+TEST_F(L2NormTest, smallValues) {
+  auto inputArray = makeArrayVector<double>({{1e-10, 1e-10}});
+  auto result = evaluate("l2_norm(c0)", makeRowVector({inputArray}));
+
+  auto resultVector = result->as<SimpleVector<double>>();
+  const double expected = std::numbers::sqrt2 * 1e-10;
+  ASSERT_NEAR(expected, resultVector->valueAt(0), 1e-20);
+}
+
+// Test maps with varchar keys
+TEST_F(L2NormTest, mapVarcharKeys) {
+  auto mapVector = makeMapVector<StringView, int32_t>({
+      {{"a", 3}, {"b", 4}},
+  });
+
+  auto result = evaluate("l2_norm(c0)", makeRowVector({mapVector}));
+  auto expected = makeFlatVector<double>({5.0}, DOUBLE());
+  assertEqualVectors(expected, result);
+}
+
+// Test maps with integer keys
+TEST_F(L2NormTest, mapIntegerKeys) {
+  auto mapVector = makeMapVector<int32_t, int32_t>({
+      {{1, 3}, {2, 4}},
+  });
+
+  auto result = evaluate("l2_norm(c0)", makeRowVector({mapVector}));
+  auto expected = makeFlatVector<double>({5.0}, DOUBLE());
+  assertEqualVectors(expected, result);
+}
+
+// Test empty map
+TEST_F(L2NormTest, emptyMap) {
+  // Create an empty map using makeMapVector with offset-based constructor
+  auto keys = makeFlatVector<StringView>({});
+  auto values = makeFlatVector<int32_t>({});
+  auto mapVector = makeMapVector({0}, keys, values);
+
+  auto result = evaluate("l2_norm(c0)", makeRowVector({mapVector}));
+  auto expected = makeFlatVector<double>({0.0}, DOUBLE());
+  assertEqualVectors(expected, result);
+}
+
+// Test map with null values - nulls are skipped
+TEST_F(L2NormTest, mapWithNullValues) {
+  // Create a map with null values using offset-based constructor
+  auto keys = makeFlatVector<StringView>({"a", "b", "c"});
+  auto values = makeNullableFlatVector<int32_t>({3, std::nullopt, 4});
+  auto mapVector = makeMapVector({0}, keys, values);
+  auto result = evaluate("l2_norm(c0)", makeRowVector({mapVector}));
+
+  // sqrt(3^2 + 4^2) = 5 (null is skipped)
+  auto expected = makeFlatVector<double>({5.0}, DOUBLE());
+  assertEqualVectors(expected, result);
+}
+
+// Test map with double values
+TEST_F(L2NormTest, mapDoubleValues) {
+  auto mapVector = makeMapVector<StringView, double>({
+      {{"x", 3.0}, {"y", 4.0}},
+  });
+
+  auto result = evaluate("l2_norm(c0)", makeRowVector({mapVector}));
+  auto expected = makeFlatVector<double>({5.0}, DOUBLE());
+  assertEqualVectors(expected, result);
+}
+
+// Test null map
+TEST_F(L2NormTest, nullMap) {
+  auto nullMap =
+      BaseVector::createNullConstant(MAP(VARCHAR(), INTEGER()), 1, pool());
+  auto result = evaluate("l2_norm(c0)", makeRowVector({nullMap}));
+
+  auto expected = BaseVector::createNullConstant(DOUBLE(), 1, pool());
+  assertEqualVectors(expected, result);
+}
+
+// Test 3D vector
+TEST_F(L2NormTest, vector3D) {
+  // sqrt(1^2 + 2^2 + 3^2) = sqrt(1 + 4 + 9) = sqrt(14)
+  auto inputArray = makeArrayVector<double>({{1.0, 2.0, 3.0}});
+  auto result = evaluate("l2_norm(c0)", makeRowVector({inputArray}));
+
+  auto resultVector = result->as<SimpleVector<double>>();
+  ASSERT_NEAR(std::sqrt(14.0), resultVector->valueAt(0), 1e-10);
+}
+
+// Test high dimensional vector
+TEST_F(L2NormTest, highDimensionalVector) {
+  // 10D vector with all 1s: sqrt(10) ≈ 3.162
+  const std::vector<double> values(10, 1.0);
+  auto inputArray = makeArrayVector<double>({values});
+  auto result = evaluate("l2_norm(c0)", makeRowVector({inputArray}));
+
+  auto resultVector = result->as<SimpleVector<double>>();
+  ASSERT_NEAR(std::sqrt(10.0), resultVector->valueAt(0), 1e-10);
+}
+
+// Test Pythagorean quadruple: 2^2 + 3^2 + 6^2 = 49 = 7^2
+TEST_F(L2NormTest, pythagoreanQuadruple) {
+  auto inputArray = makeArrayVector<int32_t>({{2, 3, 6}});
+  auto result = evaluate("l2_norm(c0)", makeRowVector({inputArray}));
+
+  auto expected = makeFlatVector<double>({7.0}, DOUBLE());
+  assertEqualVectors(expected, result);
+}
+
+// Test with zeros and non-zeros mixed
+TEST_F(L2NormTest, mixedZerosAndNonZeros) {
+  // sqrt(0 + 0 + 5^2 + 0) = 5
+  testArrayL2Norm<int32_t>({{0, 0, 5, 0}}, {5.0});
+}
+
+// Test ML use case - feature vector normalization check
+TEST_F(L2NormTest, mlFeatureVector) {
+  // Common ML scenario: checking if a feature vector has unit L2 norm
+  // Feature embedding vector
+  const std::vector<double> embedding = {0.2, 0.4, 0.3, 0.1, 0.7, 0.5};
+  auto inputArray = makeArrayVector<double>({embedding});
+  auto result = evaluate("l2_norm(c0)", makeRowVector({inputArray}));
+
+  // Calculate expected L2 norm
+  double sumSquares = 0.0;
+  for (const double val : embedding) {
+    sumSquares += val * val;
+  }
+  const double expectedL2Norm = std::sqrt(sumSquares);
+
+  auto resultVector = result->as<SimpleVector<double>>();
+  ASSERT_NEAR(expectedL2Norm, resultVector->valueAt(0), 1e-10);
+}
+
+// Test sparse vector representation using map
+TEST_F(L2NormTest, sparseVectorMap) {
+  // Sparse vector: {index1: 3.0, index5: 4.0, index10: 0.0}
+  // L2 norm = sqrt(9 + 16 + 0) = 5
+  auto mapVector = makeMapVector<int64_t, double>({
+      {{1, 3.0}, {5, 4.0}, {10, 0.0}},
+  });
+
+  auto result = evaluate("l2_norm(c0)", makeRowVector({mapVector}));
+  auto expected = makeFlatVector<double>({5.0}, DOUBLE());
+  assertEqualVectors(expected, result);
+}
+
+// ============================================================================
+// OVERFLOW / UNDERFLOW TESTS
+// Verify that the scaled summation approach avoids overflow and underflow
+// that would occur with naive value * value accumulation.
+// ============================================================================
+
+// Test that very large values don't overflow to infinity.
+// Without scaling, 1e200 * 1e200 = +inf, and sqrt(+inf) = +inf.
+// With scaling, the result should be finite and correct.
+TEST_F(L2NormTest, overflowLargeDoubles) {
+  auto inputArray = makeArrayVector<double>({{1e200, 1e200}});
+  auto result = evaluate("l2_norm(c0)", makeRowVector({inputArray}));
+
+  auto resultVector = result->as<SimpleVector<double>>();
+  double actual = resultVector->valueAt(0);
+  double expected = std::numbers::sqrt2 * 1e200;
+  ASSERT_TRUE(std::isfinite(actual))
+      << "L2 norm of large values should be finite, got: " << actual;
+  ASSERT_NEAR(expected, actual, expected * 1e-10);
+}
+
+// Test with DBL_MAX-scale values: should not overflow.
+TEST_F(L2NormTest, overflowNearDbMax) {
+  constexpr double kLarge = 1e308;
+  auto inputArray = makeArrayVector<double>({{kLarge}});
+  auto result = evaluate("l2_norm(c0)", makeRowVector({inputArray}));
+
+  auto resultVector = result->as<SimpleVector<double>>();
+  double actual = resultVector->valueAt(0);
+  ASSERT_TRUE(std::isfinite(actual))
+      << "L2 norm near DBL_MAX should be finite, got: " << actual;
+  ASSERT_NEAR(kLarge, actual, kLarge * 1e-10);
+}
+
+// Test multiple large values that would overflow naive summation.
+TEST_F(L2NormTest, overflowMultipleLargeValues) {
+  constexpr double kLarge = 1e200;
+  auto inputArray = makeArrayVector<double>({{kLarge, kLarge, kLarge, kLarge}});
+  auto result = evaluate("l2_norm(c0)", makeRowVector({inputArray}));
+
+  auto resultVector = result->as<SimpleVector<double>>();
+  double actual = resultVector->valueAt(0);
+  double expected = 2.0 * kLarge; // sqrt(4) * 1e200
+  ASSERT_TRUE(std::isfinite(actual))
+      << "L2 norm of multiple large values should be finite, got: " << actual;
+  ASSERT_NEAR(expected, actual, expected * 1e-10);
+}
+
+// Test that very small values don't underflow to zero.
+// Without scaling, 1e-200 * 1e-200 = 0 (underflows), so sqrt(0) = 0.
+// With scaling, the result should be correct.
+TEST_F(L2NormTest, underflowSmallDoubles) {
+  auto inputArray = makeArrayVector<double>({{1e-200, 1e-200}});
+  auto result = evaluate("l2_norm(c0)", makeRowVector({inputArray}));
+
+  auto resultVector = result->as<SimpleVector<double>>();
+  double actual = resultVector->valueAt(0);
+  double expected = std::numbers::sqrt2 * 1e-200;
+  ASSERT_GT(actual, 0.0)
+      << "L2 norm of small values should not underflow to zero";
+  ASSERT_NEAR(expected, actual, expected * 1e-10);
+}
+
+// Test extremely small subnormal values.
+TEST_F(L2NormTest, underflowSubnormal) {
+  constexpr double kTiny = 5e-324; // smallest positive subnormal double
+  auto inputArray = makeArrayVector<double>({{kTiny}});
+  auto result = evaluate("l2_norm(c0)", makeRowVector({inputArray}));
+
+  auto resultVector = result->as<SimpleVector<double>>();
+  double actual = resultVector->valueAt(0);
+  ASSERT_GT(actual, 0.0) << "L2 norm of subnormal should not be zero";
+}
+
+// Test mixed large and small values.
+// The large value should dominate but the small value should not cause issues.
+TEST_F(L2NormTest, mixedLargeAndSmallValues) {
+  auto inputArray = makeArrayVector<double>({{1e200, 1e-200}});
+  auto result = evaluate("l2_norm(c0)", makeRowVector({inputArray}));
+
+  auto resultVector = result->as<SimpleVector<double>>();
+  double actual = resultVector->valueAt(0);
+  ASSERT_TRUE(std::isfinite(actual))
+      << "L2 norm with mixed magnitudes should be finite, got: " << actual;
+  ASSERT_NEAR(1e200, actual, 1e200 * 1e-10);
+}
+
+// Test overflow protection with map input.
+TEST_F(L2NormTest, overflowMap) {
+  constexpr double kLarge = 1e200;
+  auto mapVector = makeMapVector<StringView, double>({
+      {{"a", kLarge}, {"b", kLarge}},
+  });
+
+  auto result = evaluate("l2_norm(c0)", makeRowVector({mapVector}));
+  auto resultVector = result->as<SimpleVector<double>>();
+  double actual = resultVector->valueAt(0);
+  double expected = std::numbers::sqrt2 * kLarge;
+  ASSERT_TRUE(std::isfinite(actual))
+      << "Map L2 norm of large values should be finite, got: " << actual;
+  ASSERT_NEAR(expected, actual, expected * 1e-10);
+}
+
+// Test underflow protection with map input.
+TEST_F(L2NormTest, underflowMap) {
+  constexpr double kTiny = 1e-200;
+  auto mapVector = makeMapVector<StringView, double>({
+      {{"x", kTiny}, {"y", kTiny}},
+  });
+
+  auto result = evaluate("l2_norm(c0)", makeRowVector({mapVector}));
+  auto resultVector = result->as<SimpleVector<double>>();
+  double actual = resultVector->valueAt(0);
+  double expected = std::numbers::sqrt2 * kTiny;
+  ASSERT_GT(actual, 0.0)
+      << "Map L2 norm of small values should not underflow to zero";
+  ASSERT_NEAR(expected, actual, expected * 1e-10);
+}
+
+// Test that overflow protection works with nullable arrays containing large
+// values.
+TEST_F(L2NormTest, overflowWithNulls) {
+  constexpr double kLarge = 1e200;
+  testArrayL2Norm<double>(
+      {{kLarge, std::nullopt, kLarge}}, {std::numbers::sqrt2 * kLarge});
+}
+
+} // namespace
+
+// ============================================================================
+// CUSTOM FUZZER TESTS
+// These tests use VectorFuzzer to generate random inputs and verify that the
+// l2_norm function produces valid results (non-negative, finite for finite
+// inputs) and matches manual calculation using reduce.
+// ============================================================================
+
+class L2NormFuzzerTest : public test::FunctionBaseTest {
+ protected:
+  // Verify that L2 norm result is valid: non-negative and finite for
+  // finite inputs.
+  void verifyL2NormProperties(const RowVectorPtr& data) {
+    VectorPtr result;
+    try {
+      result = evaluate("l2_norm(c0)", data);
+    } catch (...) {
+      return;
+    }
+
+    if (!result) {
+      return;
+    }
+
+    auto resultVector = result->as<SimpleVector<double>>();
+    if (!resultVector) {
+      return;
+    }
+
+    for (auto i = 0; i < data->size(); ++i) {
+      if (data->childAt(0)->isNullAt(i)) {
+        ASSERT_TRUE(result->isNullAt(i))
+            << "Result should be null when input is null at row " << i;
+        continue;
+      }
+
+      if (result->isNullAt(i)) {
+        continue;
+      }
+
+      double l2norm = resultVector->valueAt(i);
+
+      ASSERT_GE(l2norm, 0.0) << "L2 norm must be non-negative at row " << i;
+
+      ASSERT_FALSE(std::isnan(l2norm))
+          << "L2 norm should not be NaN at row " << i;
+    }
+  }
+
+  // Compare l2_norm(array) against equivalent reduce expression:
+  // reduce(c0, CAST(0.0 AS DOUBLE), (s, x) -> s + x * x, s -> sqrt(s))
+  void testArrayEquivalence(const RowVectorPtr& data) {
+    VectorPtr result;
+    VectorPtr expected;
+
+    try {
+      result = evaluate("l2_norm(c0)", data);
+      expected = evaluate(
+          "reduce(c0, CAST(0.0 AS DOUBLE), (s, x) -> s + COALESCE(CAST(x AS DOUBLE) * CAST(x AS DOUBLE), 0.0), s -> sqrt(s))",
+          data);
+    } catch (...) {
+      return;
+    }
+
+    if (!result || !expected) {
+      return;
+    }
+
+    for (auto i = 0; i < data->size(); ++i) {
+      if (data->childAt(0)->isNullAt(i)) {
+        continue;
+      }
+
+      if (result->isNullAt(i) || expected->isNullAt(i)) {
+        continue;
+      }
+
+      auto resultVector = result->as<SimpleVector<double>>();
+      auto expectedVector = expected->as<SimpleVector<double>>();
+
+      if (!resultVector || !expectedVector) {
+        continue;
+      }
+
+      // Use relative tolerance for large values
+      double expectedVal = expectedVector->valueAt(i);
+      double resultVal = resultVector->valueAt(i);
+      double tolerance = std::max(1e-9, std::abs(expectedVal) * 1e-10);
+      ASSERT_NEAR(expectedVal, resultVal, tolerance) << "Mismatch at row " << i;
+    }
+  }
+};
+
+TEST_F(L2NormFuzzerTest, fuzzIntegerArrays) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 10;
+  opts.containerVariableLength = true;
+  opts.containerHasNulls = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (int iter = 0; iter < 10; ++iter) {
+    auto inputArray = fuzzer.fuzz(ARRAY(INTEGER()));
+    auto data = makeRowVector({inputArray});
+    verifyL2NormProperties(data);
+    testArrayEquivalence(data);
+  }
+}
+
+TEST_F(L2NormFuzzerTest, fuzzBigintArrays) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 10;
+  opts.containerVariableLength = true;
+  opts.containerHasNulls = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (int iter = 0; iter < 10; ++iter) {
+    auto inputArray = fuzzer.fuzz(ARRAY(BIGINT()));
+    auto data = makeRowVector({inputArray});
+    verifyL2NormProperties(data);
+    testArrayEquivalence(data);
+  }
+}
+
+TEST_F(L2NormFuzzerTest, fuzzDoubleArrays) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 10;
+  opts.containerVariableLength = true;
+  opts.containerHasNulls = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (int iter = 0; iter < 10; ++iter) {
+    auto inputArray = fuzzer.fuzz(ARRAY(DOUBLE()));
+    auto data = makeRowVector({inputArray});
+    verifyL2NormProperties(data);
+  }
+}
+
+TEST_F(L2NormFuzzerTest, fuzzFloatArrays) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 10;
+  opts.containerVariableLength = true;
+  opts.containerHasNulls = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (int iter = 0; iter < 10; ++iter) {
+    auto inputArray = fuzzer.fuzz(ARRAY(REAL()));
+    auto data = makeRowVector({inputArray});
+    verifyL2NormProperties(data);
+  }
+}
+
+TEST_F(L2NormFuzzerTest, fuzzSmallintArrays) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 10;
+  opts.containerVariableLength = true;
+  opts.containerHasNulls = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (int iter = 0; iter < 10; ++iter) {
+    auto inputArray = fuzzer.fuzz(ARRAY(SMALLINT()));
+    auto data = makeRowVector({inputArray});
+    verifyL2NormProperties(data);
+    testArrayEquivalence(data);
+  }
+}
+
+TEST_F(L2NormFuzzerTest, fuzzTinyintArrays) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 10;
+  opts.containerVariableLength = true;
+  opts.containerHasNulls = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (int iter = 0; iter < 10; ++iter) {
+    auto inputArray = fuzzer.fuzz(ARRAY(TINYINT()));
+    auto data = makeRowVector({inputArray});
+    verifyL2NormProperties(data);
+    testArrayEquivalence(data);
+  }
+}
+
+TEST_F(L2NormFuzzerTest, fuzzMapIntegerKeys) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 10;
+  opts.containerVariableLength = true;
+  opts.containerHasNulls = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (int iter = 0; iter < 10; ++iter) {
+    auto inputMap = fuzzer.fuzz(MAP(INTEGER(), INTEGER()));
+    auto data = makeRowVector({inputMap});
+    verifyL2NormProperties(data);
+  }
+}
+
+TEST_F(L2NormFuzzerTest, fuzzMapVarcharKeys) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 10;
+  opts.containerVariableLength = true;
+  opts.containerHasNulls = true;
+  opts.stringLength = 10;
+  opts.stringVariableLength = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (int iter = 0; iter < 10; ++iter) {
+    auto inputMap = fuzzer.fuzz(MAP(VARCHAR(), INTEGER()));
+    auto data = makeRowVector({inputMap});
+    verifyL2NormProperties(data);
+  }
+}
+
+TEST_F(L2NormFuzzerTest, fuzzMapDoubleValues) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 10;
+  opts.containerVariableLength = true;
+  opts.containerHasNulls = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (int iter = 0; iter < 10; ++iter) {
+    auto inputMap = fuzzer.fuzz(MAP(VARCHAR(), DOUBLE()));
+    auto data = makeRowVector({inputMap});
+    verifyL2NormProperties(data);
+  }
+}
+
+TEST_F(L2NormFuzzerTest, fuzzHighNullRatio) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.5;
+  opts.containerLength = 10;
+  opts.containerVariableLength = true;
+  opts.containerHasNulls = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (int iter = 0; iter < 10; ++iter) {
+    auto inputArray = fuzzer.fuzz(ARRAY(INTEGER()));
+    auto data = makeRowVector({inputArray});
+    verifyL2NormProperties(data);
+  }
+}
+
+TEST_F(L2NormFuzzerTest, fuzzLargeVectors) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 500;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 20;
+  opts.containerVariableLength = true;
+  opts.containerHasNulls = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (int iter = 0; iter < 5; ++iter) {
+    auto inputArray = fuzzer.fuzz(ARRAY(INTEGER()));
+    auto data = makeRowVector({inputArray});
+    verifyL2NormProperties(data);
+  }
+}
+
+TEST_F(L2NormFuzzerTest, fuzzDictionaryEncoded) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 10;
+  opts.containerVariableLength = true;
+  opts.containerHasNulls = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (int iter = 0; iter < 10; ++iter) {
+    auto baseArray = fuzzer.fuzz(ARRAY(INTEGER()));
+    auto inputArray = fuzzer.fuzzDictionary(baseArray, opts.vectorSize);
+    auto data = makeRowVector({inputArray});
+    verifyL2NormProperties(data);
+  }
+}
+
+TEST_F(L2NormFuzzerTest, fuzzEmptyContainers) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 1;
+  opts.containerVariableLength = true;
+  opts.containerHasNulls = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (int iter = 0; iter < 10; ++iter) {
+    auto inputArray = fuzzer.fuzz(ARRAY(INTEGER()));
+    auto data = makeRowVector({inputArray});
+    verifyL2NormProperties(data);
+  }
+}
+
+TEST_F(L2NormFuzzerTest, fuzzNoNulls) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.0;
+  opts.containerLength = 10;
+  opts.containerVariableLength = true;
+  opts.containerHasNulls = false;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (int iter = 0; iter < 10; ++iter) {
+    auto inputArray = fuzzer.fuzz(ARRAY(INTEGER()));
+    auto data = makeRowVector({inputArray});
+    verifyL2NormProperties(data);
+    testArrayEquivalence(data);
+  }
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/MapAppendTest.cpp b/velox/functions/prestosql/tests/MapAppendTest.cpp
new file mode 100644
index 00000000000..d675264d715
--- /dev/null
+++ b/velox/functions/prestosql/tests/MapAppendTest.cpp
@@ -0,0 +1,476 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/functions/prestosql/tests/utils/FuzzerTestUtils.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class MapAppendTest : public test::FunctionBaseTest {};
+
+TEST_F(MapAppendTest, basicIntegerMap) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20, 3:30}",
+          "{10:100, 20:200}",
+          "{}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[4, 5]",
+          "[30, 40]",
+          "[1, 2]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[40, 50]",
+          "[300, 400]",
+          "[10, 20]",
+      }),
+  });
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:30, 4:40, 5:50}",
+      "{10:100, 20:200, 30:300, 40:400}",
+      "{1:10, 2:20}",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapAppendTest, varcharKeyMap) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<std::string, int32_t>({
+          R"({"a": 1, "b": 2})",
+          R"({"x": 10})",
+      }),
+      makeArrayVectorFromJson<std::string>({
+          R"(["c", "d"])",
+          R"(["y", "z"])",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[3, 4]",
+          "[20, 30]",
+      }),
+  });
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expected = makeMapVectorFromJson<std::string, int32_t>({
+      R"({"a": 1, "b": 2, "c": 3, "d": 4})",
+      R"({"x": 10, "y": 20, "z": 30})",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapAppendTest, emptyArrays) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20}",
+          "{}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[]",
+          "[]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[]",
+          "[]",
+      }),
+  });
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20}",
+      "{}",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapAppendTest, nullValues) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[3, 4]",
+      }),
+      makeNullableArrayVector<int32_t>({
+          {std::nullopt, 40},
+      }),
+  });
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:null, 4:40}",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapAppendTest, duplicateKeyInNewKeys) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[3, 3]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[30, 40]",
+      }),
+  });
+
+  VELOX_ASSERT_THROW(
+      evaluate("map_append(c0, c1, c2)", data), "Duplicate key in keys array");
+}
+
+TEST_F(MapAppendTest, keyAlreadyExistsInMap) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[2, 3]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[30, 40]",
+      }),
+  });
+
+  VELOX_ASSERT_THROW(
+      evaluate("map_append(c0, c1, c2)", data),
+      "Key already exists in the map");
+}
+
+TEST_F(MapAppendTest, mismatchedArrayLengths) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[3, 4]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[30]",
+      }),
+  });
+
+  VELOX_ASSERT_THROW(
+      evaluate("map_append(c0, c1, c2)", data),
+      "Keys and values arrays must have the same length");
+}
+
+TEST_F(MapAppendTest, floatKeys) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<float, int32_t>({
+          "{1.5:10, 2.5:20}",
+      }),
+      makeArrayVectorFromJson<float>({
+          "[3.5, 4.5]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[30, 40]",
+      }),
+  });
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expected = makeMapVectorFromJson<float, int32_t>({
+      "{1.5:10, 2.5:20, 3.5:30, 4.5:40}",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapAppendTest, booleanKeys) {
+  auto data = makeRowVector({
+      makeMapVector<bool, int32_t>({{{true, 10}}}),
+      makeArrayVector<bool>({{false}}),
+      makeArrayVector<int32_t>({{20}}),
+  });
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expected = makeMapVector<bool, int32_t>({{{true, 10}, {false, 20}}});
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapAppendTest, nullKeysIgnored) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20}",
+      }),
+      makeNullableArrayVector<int64_t>({
+          {3, std::nullopt, 4},
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[30, 40, 50]",
+      }),
+  });
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:30, 4:50}",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapAppendTest, emptyMapWithNewEntries) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[1, 2, 3]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[10, 20, 30]",
+      }),
+  });
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:30}",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapAppendTest, complexValueTypes) {
+  // Create value arrays for the map
+  auto inputMapValues = makeArrayVectorFromJson<int32_t>({
+      "[1, 2]",
+      "[3, 4]",
+  });
+
+  // Create a map with keys [1, 2] and values [[1,2], [3,4]]
+  auto inputMap =
+      makeMapVector({0}, makeFlatVector<int64_t>({1, 2}), inputMapValues);
+
+  // Keys to append: [3, 4] (single row with 2 keys)
+  auto newKeys = makeArrayVectorFromJson<int64_t>({
+      "[3, 4]",
+  });
+
+  // Values to append: [[5,6], [7,8]] (single row with 2 array values)
+  auto newValues = makeNestedArrayVectorFromJson<int32_t>({
+      "[[5, 6], [7, 8]]",
+  });
+
+  auto data = makeRowVector({inputMap, newKeys, newValues});
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expectedValues = makeArrayVectorFromJson<int32_t>({
+      "[1, 2]",
+      "[3, 4]",
+      "[5, 6]",
+      "[7, 8]",
+  });
+
+  auto expected =
+      makeMapVector({0}, makeFlatVector<int64_t>({1, 2, 3, 4}), expectedValues);
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapAppendTest, largeMap) {
+  // Create a map with 10 entries and append 3 more
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20, 3:30, 4:40, 5:50, 6:60, 7:70, 8:80, 9:90, 10:100}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[11, 12, 13]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[110, 120, 130]",
+      }),
+  });
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:30, 4:40, 5:50, 6:60, 7:70, 8:80, 9:90, 10:100, 11:110, 12:120, 13:130}",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapAppendTest, timestampKeys) {
+  auto data = makeRowVector({
+      makeMapVector<Timestamp, int32_t>(
+          {{{Timestamp(1, 0), 10}, {Timestamp(2, 0), 20}}}),
+      makeArrayVector<Timestamp>({{Timestamp(3, 0), Timestamp(4, 0)}}),
+      makeArrayVector<int32_t>({{30, 40}}),
+  });
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expected = makeMapVector<Timestamp, int32_t>(
+      {{{Timestamp(1, 0), 10},
+        {Timestamp(2, 0), 20},
+        {Timestamp(3, 0), 30},
+        {Timestamp(4, 0), 40}}});
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapAppendTest, preserveMapOrder) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{5:50, 3:30, 1:10}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[2, 4]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[20, 40]",
+      }),
+  });
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{5:50, 3:30, 1:10, 2:20, 4:40}",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+} // namespace
+
+class MapAppendFuzzerTest : public test::FunctionBaseTest {
+ protected:
+  static SelectivityVector getNonNullRows(const RowVectorPtr& data) {
+    SelectivityVector nonNullRows(data->size());
+    for (vector_size_t i = 0; i < data->size(); ++i) {
+      bool hasNull = false;
+      for (vector_size_t j = 0; j < data->childrenSize(); ++j) {
+        if (data->childAt(j)->isNullAt(i)) {
+          hasNull = true;
+          break;
+        }
+      }
+      if (hasNull) {
+        nonNullRows.setValid(i, false);
+      }
+    }
+    nonNullRows.updateBounds();
+    return nonNullRows;
+  }
+
+  void testMapAppendProperties(const RowVectorPtr& data) {
+    auto nonNullRows = getNonNullRows(data);
+    if (nonNullRows.countSelected() == 0) {
+      return;
+    }
+
+    VectorPtr result;
+    try {
+      result = evaluate("try(map_append(c0, c1, c2))", data);
+    } catch (...) {
+      return;
+    }
+
+    if (!result) {
+      return;
+    }
+
+    auto inputMap = data->childAt(0);
+    auto inputMapVector = inputMap->as<MapVector>();
+    if (!inputMapVector) {
+      return;
+    }
+
+    for (auto i = 0; i < data->size(); ++i) {
+      if (!nonNullRows.isValid(i) || result->isNullAt(i)) {
+        continue;
+      }
+
+      if (inputMap->isNullAt(i)) {
+        continue;
+      }
+
+      auto resultMap = result->as<MapVector>();
+      if (!resultMap) {
+        continue;
+      }
+
+      auto origSize = inputMapVector->sizeAt(i);
+      auto resultSize = resultMap->sizeAt(i);
+      ASSERT_GE(resultSize, origSize)
+          << "Result map should be at least as large as input map at row " << i;
+    }
+  }
+
+  void runFuzzTest(const TypePtr& type, const test::FuzzerTestOptions& opts) {
+    test::FuzzerTestHelper helper(pool());
+    helper.runMapArrayArrayTestSameType(
+        type,
+        [this](
+            const VectorPtr& inputMap,
+            const VectorPtr& keys,
+            const VectorPtr& values) {
+          auto data = makeRowVector({inputMap, keys, values});
+          testMapAppendProperties(data);
+        },
+        opts);
+  }
+};
+
+TEST_F(MapAppendFuzzerTest, fuzzInteger) {
+  runFuzzTest(INTEGER(), {.vectorSize = 50, .containerLength = 5});
+}
+
+TEST_F(MapAppendFuzzerTest, fuzzBigint) {
+  runFuzzTest(BIGINT(), {.vectorSize = 50, .containerLength = 5});
+}
+
+TEST_F(MapAppendFuzzerTest, fuzzVarchar) {
+  runFuzzTest(VARCHAR(), {.vectorSize = 50, .containerLength = 5});
+}
+
+TEST_F(MapAppendFuzzerTest, fuzzDouble) {
+  runFuzzTest(DOUBLE(), {.vectorSize = 50, .containerLength = 5});
+}
+
+TEST_F(MapAppendFuzzerTest, fuzzHighNullRatio) {
+  runFuzzTest(
+      INTEGER(), {.vectorSize = 50, .nullRatio = 0.5, .containerLength = 5});
+}
+
+TEST_F(MapAppendFuzzerTest, fuzzSmallint) {
+  runFuzzTest(SMALLINT(), {.vectorSize = 50, .containerLength = 5});
+}
+
+TEST_F(MapAppendFuzzerTest, fuzzLargeVectors) {
+  runFuzzTest(INTEGER(), {.vectorSize = 200, .containerLength = 3});
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/MapExceptTest.cpp b/velox/functions/prestosql/tests/MapExceptTest.cpp
new file mode 100644
index 00000000000..2c8e326cdcd
--- /dev/null
+++ b/velox/functions/prestosql/tests/MapExceptTest.cpp
@@ -0,0 +1,382 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/functions/prestosql/tests/utils/FuzzerTestUtils.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class MapExceptTest : public test::FunctionBaseTest {
+ public:
+  template <typename T>
+  void testFloatNaNs() {
+    static const auto kNaN = std::numeric_limits<T>::quiet_NaN();
+    static const auto kSNaN = std::numeric_limits<T>::signaling_NaN();
+
+    // Case 1: Non-constant search keys.
+    auto data = makeRowVector(
+        {makeMapVectorFromJson<T, int32_t>({
+             "{1:10, NaN:20, 3:null, 4:40, 5:50, 6:60}",
+             "{NaN:20}",
+         }),
+         makeArrayVector<T>({{1, kNaN, 5}, {kSNaN, 3}})});
+
+    auto expected = makeMapVectorFromJson<T, int32_t>({
+        "{3:null, 4:40, 6:60}",
+        "{}",
+    });
+    auto result = evaluate("map_except(c0, c1)", data);
+    assertEqualVectors(expected, result);
+
+    // Case 2: Constant search keys.
+    data = makeRowVector(
+        {makeMapVectorFromJson<T, int32_t>({
+             "{1:10, NaN:20, 3:null, 4:40, 5:50, 6:60}",
+             "{NaN:20}",
+         }),
+         BaseVector::wrapInConstant(2, 0, makeArrayVector<T>({{1, kNaN, 5}}))});
+    expected = makeMapVectorFromJson<T, int32_t>({
+        "{3:null, 4:40, 6:60}",
+        "{}",
+    });
+    result = evaluate("map_except(c0, c1)", data);
+    assertEqualVectors(expected, result);
+  }
+};
+
+TEST_F(MapExceptTest, bigintKey) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20, 3:null, 4:40, 5:50, 6:60}",
+          "{1:10, 2:20, 4:40, 5:50}",
+          "{}",
+          "{2:20, 4:40, 6:60}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[1, 3, 5]",
+          "[1, 3, 5, 7]",
+          "[3, 5]",
+          "[1, 3]",
+      }),
+  });
+
+  // Constant keys.
+  auto result = evaluate("map_except(c0, array_constructor(1, 3, 5))", data);
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{2:20, 4:40, 6:60}",
+      "{2:20, 4:40}",
+      "{}",
+      "{2:20, 4:40, 6:60}",
+  });
+
+  assertEqualVectors(expected, result);
+
+  // Non-constant keys.
+  result = evaluate("map_except(c0, c1)", data);
+  assertEqualVectors(expected, result);
+
+  // Empty list of keys. Expect all map entries returned.
+  result = evaluate("map_except(c0, array_constructor()::bigint[])", data);
+
+  expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:null, 4:40, 5:50, 6:60}",
+      "{1:10, 2:20, 4:40, 5:50}",
+      "{}",
+      "{2:20, 4:40, 6:60}",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapExceptTest, varcharKey) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<std::string, int32_t>({
+          R"({"apple": 1, "banana": 2, "Cucurbitaceae": null, "date": 4, "eggplant": 5, "fig": 6})",
+          R"({"banana": 2, "orange": 4})",
+          R"({"banana": 2, "fig": 4, "date": 5})",
+      }),
+      makeArrayVectorFromJson<std::string>({
+          R"(["apple", "Cucurbitaceae", "fig"])",
+          R"(["apple", "Cucurbitaceae", "date", "eggplant"])",
+          R"(["fig"])",
+      }),
+  });
+
+  // Constant keys.
+  auto result = evaluate(
+      "map_except(c0, array_constructor('apple', 'some very looooong name', 'fig', 'Cucurbitaceae'))",
+      data);
+
+  auto expected = makeMapVectorFromJson<std::string, int32_t>({
+      R"({"banana": 2, "date": 4, "eggplant": 5})",
+      R"({"banana": 2, "orange": 4})",
+      R"({"banana": 2, "date": 5})",
+  });
+
+  assertEqualVectors(expected, result);
+
+  // Non-constant keys.
+  result = evaluate("map_except(c0, c1)", data);
+  assertEqualVectors(expected, result);
+
+  // Empty list of keys. Expect all map entries returned.
+  result = evaluate("map_except(c0, array_constructor()::varchar[])", data);
+
+  expected = makeMapVectorFromJson<std::string, int32_t>({
+      R"({"apple": 1, "banana": 2, "Cucurbitaceae": null, "date": 4, "eggplant": 5, "fig": 6})",
+      R"({"banana": 2, "orange": 4})",
+      R"({"banana": 2, "fig": 4, "date": 5})",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapExceptTest, floatNaNs) {
+  testFloatNaNs<float>();
+  testFloatNaNs<double>();
+}
+
+// Custom fuzzer tests
+
+// Custom fuzzer tests to compare map_except with equivalent expression
+// using existing UDFs. The equivalent expression is:
+// map_filter(map, (k, v) -> NOT contains(keys_array, k))
+//
+// Note: We already have explicit tests for NULL handling in MapExceptTest.
+// These fuzzer tests focus on comparing behavior with non-null inputs.
+class MapExceptFuzzerTest : public test::FunctionBaseTest {
+ protected:
+  // Helper to flatten vectors for consistent comparison across encodings
+  template <typename T>
+  static VectorPtr flatten(const std::shared_ptr<T>& vector) {
+    SelectivityVector allRows(vector->size());
+    auto result =
+        BaseVector::create(vector->type(), vector->size(), vector->pool());
+    result->copy(vector.get(), allRows, nullptr);
+    return result;
+  }
+
+  // The equivalent SQL expression for map_except using existing UDFs.
+  // map_except(map, keys_array) is equivalent to:
+  // map_filter(map, (k, v) -> NOT coalesce(contains(keys_array, k), false))
+  //
+  // Note: We use coalesce to handle the case where contains returns null
+  // (when comparing with null elements). map_except ignores null keys in
+  // the exclusion array, so we treat null as "not found" (false).
+  static constexpr const char* kEquivalentExpression =
+      "map_filter(c0, (k, v) -> NOT coalesce(contains(c1, k), false))";
+
+  // Get a SelectivityVector that excludes rows where either input is null.
+  // This is because map_except returns NULL when either input is NULL.
+  static SelectivityVector getNonNullRows(const RowVectorPtr& data) {
+    auto inputMap = data->childAt(0);
+    auto keysArray = data->childAt(1);
+    SelectivityVector nonNullRows(data->size());
+
+    for (vector_size_t i = 0; i < data->size(); ++i) {
+      if (inputMap->isNullAt(i) || keysArray->isNullAt(i)) {
+        nonNullRows.setValid(i, false);
+      }
+    }
+    nonNullRows.updateBounds();
+    return nonNullRows;
+  }
+
+  void testEquivalence(const RowVectorPtr& data) {
+    auto result = evaluate("map_except(c0, c1)", data);
+    auto expected = evaluate(kEquivalentExpression, data);
+
+    // Get rows where neither input is null
+    auto nonNullRows = getNonNullRows(data);
+
+    // Compare only non-null rows (null propagation is tested separately)
+    for (auto i = 0; i < data->size(); ++i) {
+      if (nonNullRows.isValid(i)) {
+        ASSERT_TRUE(expected->equalValueAt(result.get(), i, i))
+            << "Mismatch at row " << i << ": expected " << expected->toString(i)
+            << ", got " << result->toString(i);
+      }
+    }
+  }
+
+  void runFuzzTest(
+      const TypePtr& keyType,
+      const TypePtr& valueType,
+      const test::FuzzerTestOptions& opts) {
+    test::FuzzerTestHelper helper(pool());
+    helper.runMapArrayTest(
+        keyType,
+        valueType,
+        [this](const VectorPtr& inputMap, const VectorPtr& keysArray) {
+          auto data = makeRowVector({inputMap, keysArray});
+          testEquivalence(data);
+        },
+        opts);
+  }
+};
+
+// Fuzz test with flat vectors, no nulls, fixed-size maps
+TEST_F(MapExceptFuzzerTest, fuzzFlatNoNulls) {
+  runFuzzTest(
+      INTEGER(),
+      INTEGER(),
+      {.vectorSize = 100,
+       .nullRatio = 0.0,
+       .containerLength = 10,
+       .iterations = 10});
+}
+
+// Fuzz test with nulls in maps and keys array
+TEST_F(MapExceptFuzzerTest, fuzzWithNulls) {
+  runFuzzTest(
+      INTEGER(),
+      INTEGER(),
+      {.vectorSize = 100,
+       .containerLength = 10,
+       .containerHasNulls = true,
+       .containerVariableLength = true,
+       .iterations = 10});
+}
+
+// Fuzz test with dictionary-encoded vectors
+TEST_F(MapExceptFuzzerTest, fuzzDictionaryEncoded) {
+  test::FuzzerTestHelper helper(pool());
+  test::FuzzerTestOptions opts{
+      .vectorSize = 100,
+      .containerLength = 10,
+      .containerHasNulls = true,
+      .containerVariableLength = true};
+  auto fuzzer = helper.createFuzzer(opts);
+
+  for (auto i = 0; i < 10; ++i) {
+    auto baseInputMap = fuzzer.fuzz(MAP(INTEGER(), INTEGER()));
+    auto baseKeysArray = fuzzer.fuzz(ARRAY(INTEGER()));
+
+    auto inputMap = fuzzer.fuzzDictionary(baseInputMap, opts.vectorSize);
+    auto keysArray = fuzzer.fuzzDictionary(baseKeysArray, opts.vectorSize);
+
+    auto data = makeRowVector({inputMap, keysArray});
+    auto flatData = makeRowVector({flatten(inputMap), flatten(keysArray)});
+
+    auto result = evaluate("map_except(c0, c1)", data);
+    auto expectedResult = evaluate("map_except(c0, c1)", flatData);
+    assertEqualVectors(expectedResult, result);
+
+    testEquivalence(flatData);
+  }
+}
+
+// Fuzz test with variable-length maps and high null ratio
+TEST_F(MapExceptFuzzerTest, fuzzVariableLengthWithHighNullRatio) {
+  runFuzzTest(
+      INTEGER(),
+      INTEGER(),
+      {.vectorSize = 100,
+       .nullRatio = 0.3,
+       .containerLength = 20,
+       .containerHasNulls = true,
+       .containerVariableLength = true,
+       .iterations = 10});
+}
+
+// Fuzz test with string keys
+TEST_F(MapExceptFuzzerTest, fuzzStringKeys) {
+  runFuzzTest(
+      VARCHAR(),
+      INTEGER(),
+      {.vectorSize = 100,
+       .containerLength = 10,
+       .containerHasNulls = true,
+       .containerVariableLength = true,
+       .iterations = 10});
+}
+
+// Fuzz test with bigint keys
+TEST_F(MapExceptFuzzerTest, fuzzBigintKeys) {
+  runFuzzTest(
+      BIGINT(),
+      VARCHAR(),
+      {.vectorSize = 100,
+       .containerLength = 10,
+       .containerHasNulls = true,
+       .containerVariableLength = true,
+       .iterations = 10});
+}
+
+// Fuzz test with empty maps and arrays
+TEST_F(MapExceptFuzzerTest, fuzzWithEmptyContainers) {
+  runFuzzTest(
+      INTEGER(),
+      INTEGER(),
+      {.vectorSize = 100,
+       .containerLength = 2,
+       .containerHasNulls = true,
+       .containerVariableLength = true,
+       .iterations = 10});
+}
+
+// Fuzz test with various value types
+TEST_F(MapExceptFuzzerTest, fuzzVariousValueTypes) {
+  test::FuzzerTestOptions opts{
+      .vectorSize = 100,
+      .containerLength = 10,
+      .containerHasNulls = true,
+      .containerVariableLength = true,
+      .iterations = 5};
+
+  // Test with DOUBLE values
+  runFuzzTest(INTEGER(), DOUBLE(), opts);
+
+  // Test with BOOLEAN values
+  runFuzzTest(INTEGER(), BOOLEAN(), opts);
+
+  // Test with VARCHAR values
+  runFuzzTest(INTEGER(), VARCHAR(), opts);
+}
+
+// Fuzz test with constant vectors
+TEST_F(MapExceptFuzzerTest, fuzzConstantVectors) {
+  test::FuzzerTestHelper helper(pool());
+  test::FuzzerTestOptions opts{
+      .vectorSize = 100, .nullRatio = 0.0, .containerLength = 5};
+  auto fuzzer = helper.createFuzzer(opts);
+
+  for (auto i = 0; i < 10; ++i) {
+    auto inputMap = fuzzer.fuzz(MAP(INTEGER(), INTEGER()));
+    auto keysArray = fuzzer.fuzzConstant(ARRAY(INTEGER()), opts.vectorSize);
+
+    auto data = makeRowVector({inputMap, keysArray});
+    testEquivalence(data);
+  }
+}
+
+// Stress test with large vectors
+TEST_F(MapExceptFuzzerTest, fuzzLargeVectors) {
+  runFuzzTest(
+      INTEGER(),
+      INTEGER(),
+      {.vectorSize = 1000,
+       .containerLength = 50,
+       .containerHasNulls = true,
+       .containerVariableLength = true,
+       .iterations = 5});
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/MapFromEntriesTest.cpp b/velox/functions/prestosql/tests/MapFromEntriesTest.cpp
index 82ea6eebb15..ad7daa908a4 100644
--- a/velox/functions/prestosql/tests/MapFromEntriesTest.cpp
+++ b/velox/functions/prestosql/tests/MapFromEntriesTest.cpp
@@ -439,6 +439,9 @@ TEST_F(MapFromEntriesTest, unknownInputs) {
   test("try(map_from_entries(array_constructor(row_constructor(null, null))))");
   test("try(map_from_entries(array_constructor(null)))");
   test("try(map_from_entries(null))");
+
+  // Empty array of unknown type should produce an empty map without error.
+  test("map_from_entries(array_constructor())");
 }
 
 TEST_F(MapFromEntriesTest, nullRowEntriesWithSmallerChildren) {
diff --git a/velox/functions/prestosql/tests/MapIntersectTest.cpp b/velox/functions/prestosql/tests/MapIntersectTest.cpp
new file mode 100644
index 00000000000..7473c2700a2
--- /dev/null
+++ b/velox/functions/prestosql/tests/MapIntersectTest.cpp
@@ -0,0 +1,391 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/functions/prestosql/tests/utils/FuzzerTestUtils.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class MapIntersectTest : public test::FunctionBaseTest {
+ protected:
+  void testMapIntersect(
+      const std::string& expression,
+      const std::vector<VectorPtr>& input,
+      const VectorPtr& expected) {
+    auto result = evaluate(expression, makeRowVector(input));
+    assertEqualVectors(expected, result);
+  }
+};
+
+TEST_F(MapIntersectTest, integerMap) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}, {4, 40}},
+      {{5, 50}, {6, 60}, {7, 70}},
+      {},
+      {{8, 80}, {9, 90}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {1, 3},
+      {5, 7, 8},
+      {1, 2},
+      {8, 9, 10},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {3, 30}},
+      {{5, 50}, {7, 70}},
+      {},
+      {{8, 80}, {9, 90}},
+  });
+
+  testMapIntersect("map_intersect(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapIntersectTest, constantKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}},
+      {{1, 100}, {2, 200}, {3, 300}},
+      {{1, 1000}, {2, 2000}, {3, 3000}, {4, 4000}, {5, 5000}},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {3, 30}, {5, 50}},
+      {{1, 100}, {3, 300}},
+      {{1, 1000}, {3, 3000}, {5, 5000}},
+  });
+
+  auto result = evaluate(
+      "map_intersect(c0, array_constructor(cast(1 as integer), cast(3 as integer), cast(5 as integer)))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapIntersectTest, nonExistentKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+      {{4, 40}, {5, 50}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {4, 5, 6},
+      {1, 2, 3},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {},
+      {},
+  });
+
+  testMapIntersect("map_intersect(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapIntersectTest, duplicateKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}},
+      {{6, 60}, {7, 70}, {8, 80}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {1, 1, 2, 2, 3},
+      {6, 6, 7, 7},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+      {{6, 60}, {7, 70}},
+  });
+
+  testMapIntersect("map_intersect(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapIntersectTest, emptyKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+      {{4, 40}, {5, 50}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {},
+      {},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {},
+      {},
+  });
+
+  testMapIntersect("map_intersect(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapIntersectTest, emptyMap) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {},
+      {},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {1, 2, 3},
+      {4, 5},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {},
+      {},
+  });
+
+  testMapIntersect("map_intersect(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapIntersectTest, nullKeysInArray) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}},
+      {{6, 60}, {7, 70}, {8, 80}},
+  });
+
+  auto keys = makeNullableArrayVector<int32_t>({
+      {1, std::nullopt, 3, std::nullopt, 5},
+      {std::nullopt, 7, std::nullopt},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {3, 30}, {5, 50}},
+      {{7, 70}},
+  });
+
+  testMapIntersect("map_intersect(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapIntersectTest, stringMap) {
+  auto inputMap = makeMapVector<StringView, int32_t>({
+      {{"apple", 1}, {"banana", 2}, {"cherry", 3}, {"date", 4}},
+      {{"hello", 10}, {"world", 20}},
+      {{"a", 100}, {"b", 200}, {"c", 300}, {"d", 400}, {"e", 500}},
+  });
+
+  auto keys = makeArrayVector<StringView>({
+      {"banana", "date", "apple"},
+      {"hello", "world", "foo"},
+      {"a", "c", "e"},
+  });
+
+  auto expected = makeMapVector<StringView, int32_t>({
+      {{"apple", 1}, {"banana", 2}, {"date", 4}},
+      {{"hello", 10}, {"world", 20}},
+      {{"a", 100}, {"c", 300}, {"e", 500}},
+  });
+
+  testMapIntersect("map_intersect(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapIntersectTest, floatMap) {
+  auto inputMap = makeMapVector<float, float>({
+      {{1.1f, 10.1f}, {2.2f, 20.2f}, {3.3f, 30.3f}, {4.4f, 40.4f}},
+      {{5.5f, 50.5f}, {6.6f, 60.6f}, {7.7f, 70.7f}},
+  });
+
+  auto keys = makeArrayVector<float>({
+      {1.1f, 3.3f, 4.4f},
+      {5.5f, 6.6f, 8.8f},
+  });
+
+  auto expected = makeMapVector<float, float>({
+      {{1.1f, 10.1f}, {3.3f, 30.3f}, {4.4f, 40.4f}},
+      {{5.5f, 50.5f}, {6.6f, 60.6f}},
+  });
+
+  testMapIntersect("map_intersect(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapIntersectTest, booleanMap) {
+  auto inputMap = makeMapVector<bool, int32_t>({
+      {{true, 1}, {false, 0}},
+      {{true, 10}},
+      {{false, 100}},
+  });
+
+  auto keys = makeArrayVector<bool>({
+      {true},
+      {true, false},
+      {true, false},
+  });
+
+  auto expected = makeMapVector<bool, int32_t>({
+      {{true, 1}},
+      {{true, 10}},
+      {{false, 100}},
+  });
+
+  testMapIntersect("map_intersect(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapIntersectTest, nullArguments) {
+  auto inputMap =
+      makeMapVector<int32_t, int32_t>({{{1, 10}, {2, 20}, {3, 30}}});
+  auto keys = makeArrayVector<int32_t>({{1, 2}});
+
+  auto nullMap =
+      BaseVector::createNullConstant(MAP(INTEGER(), INTEGER()), 1, pool());
+  auto nullKeys = BaseVector::createNullConstant(ARRAY(INTEGER()), 1, pool());
+
+  auto result1 =
+      evaluate("map_intersect(c0, c1)", makeRowVector({nullMap, keys}));
+  auto expected1 =
+      BaseVector::createNullConstant(MAP(INTEGER(), INTEGER()), 1, pool());
+  assertEqualVectors(expected1, result1);
+
+  auto result2 =
+      evaluate("map_intersect(c0, c1)", makeRowVector({inputMap, nullKeys}));
+  auto expected2 =
+      BaseVector::createNullConstant(MAP(INTEGER(), INTEGER()), 1, pool());
+  assertEqualVectors(expected2, result2);
+
+  auto result3 =
+      evaluate("map_intersect(c0, c1)", makeRowVector({nullMap, nullKeys}));
+  auto expected3 =
+      BaseVector::createNullConstant(MAP(INTEGER(), INTEGER()), 1, pool());
+  assertEqualVectors(expected3, result3);
+}
+
+TEST_F(MapIntersectTest, partialMatch) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}},
+      {{6, 60}, {7, 70}, {8, 80}, {9, 90}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {1, 3, 5, 7, 9},
+      {6, 8, 10, 12},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {3, 30}, {5, 50}},
+      {{6, 60}, {8, 80}},
+  });
+
+  testMapIntersect("map_intersect(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapIntersectTest, singleElementMap) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}},
+      {{2, 20}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {1, 2, 3},
+      {2},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{1, 10}},
+      {{2, 20}},
+  });
+
+  testMapIntersect("map_intersect(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapIntersectTest, basicTest) {
+  auto inputMap = makeMapVector<int32_t, int32_t>(
+      {{{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}}});
+  auto keys = makeArrayVector<int32_t>({{1, 3, 5}});
+  auto expected =
+      makeMapVector<int32_t, int32_t>({{{1, 10}, {3, 30}, {5, 50}}});
+
+  auto result =
+      evaluate("map_intersect(c0, c1)", makeRowVector({inputMap, keys}));
+  assertEqualVectors(expected, result);
+}
+
+} // namespace
+
+class MapIntersectFuzzerTest : public test::FunctionBaseTest {
+ protected:
+  static constexpr const char* kEquivalentExpression =
+      "map_filter(c0, (k, v) -> coalesce(contains(c1, k), false))";
+
+  static SelectivityVector getNonNullRows(const RowVectorPtr& data) {
+    auto inputMap = data->childAt(0);
+    auto keys = data->childAt(1);
+    SelectivityVector nonNullRows(data->size());
+    for (vector_size_t i = 0; i < data->size(); ++i) {
+      if (inputMap->isNullAt(i) || keys->isNullAt(i)) {
+        nonNullRows.setValid(i, false);
+      }
+    }
+    nonNullRows.updateBounds();
+    return nonNullRows;
+  }
+
+  void testEquivalence(const RowVectorPtr& data) {
+    auto result = evaluate("map_intersect(c0, c1)", data);
+    auto expected = evaluate(kEquivalentExpression, data);
+    auto nonNullRows = getNonNullRows(data);
+    for (auto i = 0; i < data->size(); ++i) {
+      if (nonNullRows.isValid(i)) {
+        ASSERT_TRUE(expected->equalValueAt(result.get(), i, i))
+            << "Mismatch at row " << i << ": expected " << expected->toString(i)
+            << ", got " << result->toString(i);
+      }
+    }
+  }
+
+  void runFuzzTest(const TypePtr& type, const test::FuzzerTestOptions& opts) {
+    test::FuzzerTestHelper helper(pool());
+    helper.runMapArrayTest(
+        type,
+        type,
+        [this](const VectorPtr& inputMap, const VectorPtr& keys) {
+          auto data = makeRowVector({inputMap, keys});
+          testEquivalence(data);
+        },
+        opts);
+  }
+};
+
+TEST_F(MapIntersectFuzzerTest, fuzzInteger) {
+  runFuzzTest(INTEGER(), {.vectorSize = 100});
+}
+
+TEST_F(MapIntersectFuzzerTest, fuzzBigint) {
+  runFuzzTest(BIGINT(), {.vectorSize = 100});
+}
+
+TEST_F(MapIntersectFuzzerTest, fuzzVarchar) {
+  runFuzzTest(VARCHAR(), {.vectorSize = 100});
+}
+
+TEST_F(MapIntersectFuzzerTest, fuzzDouble) {
+  runFuzzTest(DOUBLE(), {.vectorSize = 100});
+}
+
+TEST_F(MapIntersectFuzzerTest, fuzzHighNullRatio) {
+  runFuzzTest(INTEGER(), {.vectorSize = 100, .nullRatio = 0.5});
+}
+
+TEST_F(MapIntersectFuzzerTest, fuzzSmallint) {
+  runFuzzTest(SMALLINT(), {.vectorSize = 100});
+}
+
+TEST_F(MapIntersectFuzzerTest, fuzzLargeVectors) {
+  runFuzzTest(INTEGER(), {.vectorSize = 500});
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/MapKeysOverlapTest.cpp b/velox/functions/prestosql/tests/MapKeysOverlapTest.cpp
new file mode 100644
index 00000000000..1a61a96e553
--- /dev/null
+++ b/velox/functions/prestosql/tests/MapKeysOverlapTest.cpp
@@ -0,0 +1,784 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class MapKeysOverlapTest : public test::FunctionBaseTest {
+ protected:
+  void testMapKeysOverlap(
+      const std::string& expression,
+      const std::vector<VectorPtr>& input,
+      const VectorPtr& expected) {
+    auto result = evaluate(expression, makeRowVector(input));
+    assertEqualVectors(expected, result);
+  }
+
+  // Helper to compare map_keys_overlap against equivalent expression.
+  // The equivalent expression is:
+  // cardinality(array_intersect(map_keys(c0), filter(c1, x -> x IS NOT NULL)))
+  // > 0
+  void testMapKeysOverlapAgainstEquivalent(const RowVectorPtr& data) {
+    auto udfResult = evaluate("map_keys_overlap(c0, c1)", data);
+
+    // Equivalent expression using existing UDFs:
+    // 1. Extract map keys: map_keys(c0)
+    // 2. Filter out nulls from the array: filter(c1, x -> x IS NOT NULL)
+    // 3. Find intersection: array_intersect(...)
+    // 4. Check if non-empty: cardinality(...) > 0
+    auto equivalentResult = evaluate(
+        "cardinality(array_intersect(map_keys(c0), filter(c1, x -> x IS NOT NULL))) > 0",
+        data);
+
+    assertEqualVectors(equivalentResult, udfResult);
+  }
+};
+
+TEST_F(MapKeysOverlapTest, basicIntegerKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+      {{4, 40}, {5, 50}},
+      {{6, 60}, {7, 70}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {1, 5},
+      {4},
+      {8, 9},
+  });
+
+  auto expected = makeFlatVector<bool>({true, true, false});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, stringKeys) {
+  auto inputMap = makeMapVector<StringView, int32_t>({
+      {{"a", 1}, {"b", 2}, {"c", 3}},
+      {{"x", 10}, {"y", 20}},
+      {{"p", 100}, {"q", 200}},
+  });
+
+  auto keys = makeArrayVector<StringView>({
+      {"a", "d"},
+      {"z"},
+      {"p"},
+  });
+
+  auto expected = makeFlatVector<bool>({true, false, true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, emptyMap) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {},
+      {{1, 10}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {1, 2},
+      {1},
+  });
+
+  auto expected = makeFlatVector<bool>({false, true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, emptyKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}},
+      {{3, 30}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {},
+      {},
+  });
+
+  auto expected = makeFlatVector<bool>({false, false});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, noMatchingKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+      {{4, 40}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {4, 5, 6},
+      {1, 2, 3},
+  });
+
+  auto expected = makeFlatVector<bool>({false, false});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, allKeysMatch) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {1, 2, 3},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, partialMatch) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}, {4, 40}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {3, 5, 6, 7},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, nullValuesInMap) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, std::nullopt}, {3, 30}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {2},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, nullKeysInArray) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  std::vector<std::vector<std::optional<int32_t>>> keyData = {
+      {std::nullopt, 4, 5},
+  };
+  auto keys = makeNullableArrayVector<int32_t>(keyData);
+
+  auto expected = makeFlatVector<bool>({false});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, nullKeysMatchInArray) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  std::vector<std::vector<std::optional<int32_t>>> keyData = {
+      {1, std::nullopt, 4},
+  };
+  auto keys = makeNullableArrayVector<int32_t>(keyData);
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, floatKeys) {
+  auto inputMap = makeMapVector<float, int32_t>({
+      {{1.5f, 10}, {2.5f, 20}, {3.5f, 30}},
+  });
+
+  auto keys = makeArrayVector<float>({
+      {1.5f, 10.5f},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, doubleKeys) {
+  auto inputMap = makeMapVector<double, int32_t>({
+      {{1.5, 10}, {2.5, 20}},
+  });
+
+  auto keys = makeArrayVector<double>({
+      {3.5, 4.5},
+  });
+
+  auto expected = makeFlatVector<bool>({false});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, booleanKeys) {
+  auto inputMap = makeMapVector<bool, int32_t>({
+      {{true, 10}, {false, 20}},
+      {{true, 30}},
+  });
+
+  auto keys = makeArrayVector<bool>({
+      {true},
+      {false},
+  });
+
+  auto expected = makeFlatVector<bool>({true, false});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, timestampKeys) {
+  auto inputMap = makeMapVector<Timestamp, int32_t>({
+      {{Timestamp(1, 0), 10}, {Timestamp(2, 0), 20}},
+  });
+
+  auto keys = makeArrayVector<Timestamp>({
+      {Timestamp(1, 0), Timestamp(100, 0)},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, complexValues) {
+  auto mapKeys = makeFlatVector<int32_t>({0, 1, 2});
+  auto innerArrays = makeArrayVector<int32_t>({
+      {1, 2},
+      {3, 4, 5},
+      {6},
+  });
+
+  auto inputMap = makeMapVector({0}, mapKeys, innerArrays);
+
+  auto keys = makeArrayVector<int32_t>({
+      {0, 5},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, largeMap) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{0, 0},
+       {1, 10},
+       {2, 20},
+       {3, 30},
+       {4, 40},
+       {5, 50},
+       {6, 60},
+       {7, 70},
+       {8, 80},
+       {9, 90}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {5, 15, 25},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, largeMapNoMatch) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{0, 0},
+       {1, 10},
+       {2, 20},
+       {3, 30},
+       {4, 40},
+       {5, 50},
+       {6, 60},
+       {7, 70},
+       {8, 80},
+       {9, 90}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {15, 25, 35},
+  });
+
+  auto expected = makeFlatVector<bool>({false});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, multipleRows) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}},
+      {{3, 30}, {4, 40}},
+      {{5, 50}, {6, 60}},
+      {{7, 70}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {2, 3},
+      {1, 2},
+      {5},
+      {8, 9},
+  });
+
+  auto expected = makeFlatVector<bool>({true, false, true, false});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, longStringKeys) {
+  auto inputMap = makeMapVector<StringView, int32_t>({
+      {{"very_long_key_name_1", 1},
+       {"very_long_key_name_2", 2},
+       {"very_long_key_name_3", 3}},
+  });
+
+  auto keys = makeArrayVector<StringView>({
+      {"very_long_key_name_2", "very_long_key_name_4"},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, singleKeyMatch) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {3},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, duplicateKeysInArray) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {1, 1, 1, 4, 5},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, varcharEmptyStrings) {
+  auto inputMap = makeMapVector<StringView, int32_t>({
+      {{"", 1}, {"a", 2}, {"b", 3}},
+  });
+
+  auto keys = makeArrayVector<StringView>({
+      {"", "c"},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, allNullKeysInArray) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}},
+  });
+
+  std::vector<std::vector<std::optional<int32_t>>> keyData = {
+      {std::nullopt, std::nullopt},
+  };
+  auto keys = makeNullableArrayVector<int32_t>(keyData);
+
+  auto expected = makeFlatVector<bool>({false});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, int8Keys) {
+  auto inputMap = makeMapVector<int8_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  auto keys = makeArrayVector<int8_t>({
+      {2, 5},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, int16Keys) {
+  auto inputMap = makeMapVector<int16_t, int32_t>({
+      {{100, 10}, {200, 20}},
+  });
+
+  auto keys = makeArrayVector<int16_t>({
+      {300, 400},
+  });
+
+  auto expected = makeFlatVector<bool>({false});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, int64Keys) {
+  auto inputMap = makeMapVector<int64_t, int32_t>({
+      {{1000000000, 10}, {2000000000, 20}},
+  });
+
+  auto keys = makeArrayVector<int64_t>({
+      {1000000000},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+// ============================================================================
+// Custom Fuzzer Tests
+// These tests compare map_keys_overlap against an equivalent expression:
+// cardinality(array_intersect(map_keys(c0), filter(c1, x -> x IS NOT NULL))) >
+// 0
+// ============================================================================
+
+TEST_F(MapKeysOverlapTest, fuzzIntegerKeys) {
+  // Create base data with representative edge cases
+  auto baseMap = makeMapVector<int64_t, int64_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+      {{4, 40}, {5, 50}},
+      {{6, 60}, {7, 70}, {8, 80}},
+      {}, // empty map
+      {{100, 1000}},
+  });
+
+  auto baseKeys = makeArrayVector<int64_t>({
+      {1, 5, 10},
+      {4, 6},
+      {9, 10, 11},
+      {1, 2, 3},
+      {100},
+  });
+
+  VectorFuzzer::Options options;
+  options.vectorSize = 1024;
+  options.nullRatio = 0.0; // Start without nulls
+
+  VectorFuzzer fuzzer(options, pool());
+
+  for (auto i = 0; i < 10; ++i) {
+    auto data = makeRowVector({
+        fuzzer.fuzzDictionary(baseMap, options.vectorSize),
+        fuzzer.fuzzDictionary(baseKeys, options.vectorSize),
+    });
+
+    testMapKeysOverlapAgainstEquivalent(data);
+
+    // Also test with flattened data
+    auto flatData = flatten<RowVector>(data);
+    testMapKeysOverlapAgainstEquivalent(flatData);
+  }
+}
+
+TEST_F(MapKeysOverlapTest, fuzzIntegerKeysWithNulls) {
+  // Create base data including null elements in the array
+  auto baseMap = makeMapVector<int64_t, int64_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+      {{4, 40}, {5, 50}},
+      {}, // empty map
+      {{100, 1000}, {200, 2000}},
+  });
+
+  std::vector<std::vector<std::optional<int64_t>>> keyData = {
+      {1, std::nullopt, 5},
+      {std::nullopt, 4},
+      {std::nullopt, std::nullopt},
+      {50, 100, std::nullopt},
+  };
+  auto baseKeys = makeNullableArrayVector<int64_t>(keyData);
+
+  VectorFuzzer::Options options;
+  options.vectorSize = 1024;
+  options.nullRatio = 0.1;
+
+  VectorFuzzer fuzzer(options, pool());
+
+  for (auto i = 0; i < 10; ++i) {
+    auto data = makeRowVector({
+        fuzzer.fuzzDictionary(baseMap, options.vectorSize),
+        fuzzer.fuzzDictionary(baseKeys, options.vectorSize),
+    });
+
+    testMapKeysOverlapAgainstEquivalent(data);
+  }
+}
+
+TEST_F(MapKeysOverlapTest, fuzzVarcharKeys) {
+  // Create base data with string keys
+  auto baseMap = makeMapVector<StringView, int64_t>({
+      {{"apple", 1}, {"banana", 2}, {"cherry", 3}},
+      {{"dog", 10}, {"elephant", 20}},
+      {}, // empty map
+      {{"xyz", 100}},
+      {{"a", 1}, {"b", 2}, {"c", 3}, {"d", 4}, {"e", 5}},
+  });
+
+  auto baseKeys = makeArrayVector<StringView>({
+      {"apple", "date"},
+      {"cat", "dog"},
+      {"foo", "bar"},
+      {"xyz"},
+      {"c", "f", "g"},
+  });
+
+  VectorFuzzer::Options options;
+  options.vectorSize = 1024;
+  options.nullRatio = 0.0;
+
+  VectorFuzzer fuzzer(options, pool());
+
+  for (auto i = 0; i < 10; ++i) {
+    auto data = makeRowVector({
+        fuzzer.fuzzDictionary(baseMap, options.vectorSize),
+        fuzzer.fuzzDictionary(baseKeys, options.vectorSize),
+    });
+
+    testMapKeysOverlapAgainstEquivalent(data);
+
+    // Also test with flattened data
+    auto flatData = flatten<RowVector>(data);
+    testMapKeysOverlapAgainstEquivalent(flatData);
+  }
+}
+
+TEST_F(MapKeysOverlapTest, fuzzVarcharKeysWithNulls) {
+  // Create base data with string keys and nullable arrays
+  auto baseMap = makeMapVector<StringView, int64_t>({
+      {{"apple", 1}, {"banana", 2}},
+      {{"cat", 10}},
+      {},
+      {{"xyz", 100}, {"abc", 200}},
+  });
+
+  std::vector<std::vector<std::optional<StringView>>> keyData = {
+      {StringView("apple"), std::nullopt, StringView("date")},
+      {std::nullopt, StringView("cat")},
+      {std::nullopt},
+      {StringView("abc"), std::nullopt},
+  };
+  auto baseKeys = makeNullableArrayVector<StringView>(keyData);
+
+  VectorFuzzer::Options options;
+  options.vectorSize = 1024;
+  options.nullRatio = 0.1;
+
+  VectorFuzzer fuzzer(options, pool());
+
+  for (auto i = 0; i < 10; ++i) {
+    auto data = makeRowVector({
+        fuzzer.fuzzDictionary(baseMap, options.vectorSize),
+        fuzzer.fuzzDictionary(baseKeys, options.vectorSize),
+    });
+
+    testMapKeysOverlapAgainstEquivalent(data);
+  }
+}
+
+TEST_F(MapKeysOverlapTest, fuzzRandomGeneratedData) {
+  // Use VectorFuzzer to generate completely random data
+  VectorFuzzer::Options options;
+  options.vectorSize = 100;
+  options.containerLength = 5;
+  options.containerVariableLength = true;
+  options.nullRatio = 0.1;
+
+  VectorFuzzer fuzzer(options, pool());
+
+  for (auto i = 0; i < 20; ++i) {
+    // Generate random map and array with int64 keys.
+    // Map keys must be non-null when normalizeMapKeys is true (default).
+    auto randomMap = fuzzer.fuzzMap(
+        fuzzer.fuzzFlatNotNull(BIGINT()),
+        fuzzer.fuzzFlat(BIGINT()),
+        options.vectorSize);
+    auto randomArray =
+        fuzzer.fuzzArray(fuzzer.fuzzFlat(BIGINT()), options.vectorSize);
+
+    auto data = makeRowVector({randomMap, randomArray});
+
+    testMapKeysOverlapAgainstEquivalent(data);
+  }
+}
+
+TEST_F(MapKeysOverlapTest, fuzzMixedScenarios) {
+  // Test with various combinations of empty/non-empty maps and arrays
+  auto baseMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}},
+      {{10, 100}, {20, 200}},
+      {}, // empty
+      {{1, 1}},
+      {{100, 1000}, {200, 2000}, {300, 3000}},
+  });
+
+  auto baseKeys = makeArrayVector<int32_t>({
+      {1, 2, 3, 100}, // partial match
+      {30, 40, 50}, // no match
+      {1, 2, 3}, // search in empty map
+      {1}, // exact match
+      {}, // empty search array
+  });
+
+  VectorFuzzer::Options options;
+  options.vectorSize = 500;
+  options.nullRatio = 0.0;
+
+  VectorFuzzer fuzzer(options, pool());
+
+  for (auto i = 0; i < 10; ++i) {
+    auto data = makeRowVector({
+        fuzzer.fuzzDictionary(baseMap, options.vectorSize),
+        fuzzer.fuzzDictionary(baseKeys, options.vectorSize),
+    });
+
+    testMapKeysOverlapAgainstEquivalent(data);
+
+    // Test with lazy vector generation
+    data = fuzzer.fuzzRowChildrenToLazy(data);
+    testMapKeysOverlapAgainstEquivalent(data);
+  }
+}
+
+TEST_F(MapKeysOverlapTest, fuzzLargeMapAndArray) {
+  // Create larger maps and arrays to stress test the implementation
+  // Use explicit initialization compatible with makeMapVector
+  auto baseMap = makeMapVector<int64_t, int64_t>({
+      {{0, 0},    {1, 10},   {2, 20},   {3, 30},   {4, 40},   {5, 50},
+       {6, 60},   {7, 70},   {8, 80},   {9, 90},   {10, 100}, {11, 110},
+       {12, 120}, {13, 130}, {14, 140}, {15, 150}, {16, 160}, {17, 170},
+       {18, 180}, {19, 190}, {20, 200}},
+      {}, // empty
+      {{1000, 10000}},
+      {{100, 1000}, {200, 2000}, {300, 3000}},
+  });
+
+  auto baseKeys = makeArrayVector<int64_t>({
+      {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20}, // match some keys
+      {100, 101, 102, 103, 104}, // no match in first map
+      {1000, 2000}, // match in third map
+      {100, 200, 400}, // partial match in fourth map
+  });
+
+  VectorFuzzer::Options options;
+  options.vectorSize = 500;
+  options.nullRatio = 0.0;
+
+  VectorFuzzer fuzzer(options, pool());
+
+  for (auto i = 0; i < 5; ++i) {
+    auto data = makeRowVector({
+        fuzzer.fuzzDictionary(baseMap, options.vectorSize),
+        fuzzer.fuzzDictionary(baseKeys, options.vectorSize),
+    });
+
+    testMapKeysOverlapAgainstEquivalent(data);
+  }
+}
+
+TEST_F(MapKeysOverlapTest, fuzzBooleanKeys) {
+  // Test with boolean keys
+  auto baseMap = makeMapVector<bool, int32_t>({
+      {{true, 10}, {false, 20}},
+      {{true, 30}},
+      {{false, 40}},
+      {},
+  });
+
+  auto baseKeys = makeArrayVector<bool>({
+      {true, false},
+      {false},
+      {true},
+      {true, false},
+  });
+
+  VectorFuzzer::Options options;
+  options.vectorSize = 256;
+  options.nullRatio = 0.0;
+
+  VectorFuzzer fuzzer(options, pool());
+
+  for (auto i = 0; i < 5; ++i) {
+    auto data = makeRowVector({
+        fuzzer.fuzzDictionary(baseMap, options.vectorSize),
+        fuzzer.fuzzDictionary(baseKeys, options.vectorSize),
+    });
+
+    testMapKeysOverlapAgainstEquivalent(data);
+  }
+}
+
+TEST_F(MapKeysOverlapTest, fuzzAllNullsInArray) {
+  // Specific test case where all elements in array are null
+  // map_keys_overlap should return false in this case
+  auto baseMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+      {{4, 40}},
+      {},
+  });
+
+  std::vector<std::vector<std::optional<int32_t>>> keyData = {
+      {std::nullopt, std::nullopt, std::nullopt},
+      {std::nullopt},
+      {std::nullopt, std::nullopt},
+  };
+  auto baseKeys = makeNullableArrayVector<int32_t>(keyData);
+
+  VectorFuzzer::Options options;
+  options.vectorSize = 256;
+  options.nullRatio = 0.0;
+
+  VectorFuzzer fuzzer(options, pool());
+
+  for (auto i = 0; i < 5; ++i) {
+    auto data = makeRowVector({
+        fuzzer.fuzzDictionary(baseMap, options.vectorSize),
+        fuzzer.fuzzDictionary(baseKeys, options.vectorSize),
+    });
+
+    testMapKeysOverlapAgainstEquivalent(data);
+  }
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/MapSubsetKeyInRangeTest.cpp b/velox/functions/prestosql/tests/MapSubsetKeyInRangeTest.cpp
new file mode 100644
index 00000000000..ae3e8b7effb
--- /dev/null
+++ b/velox/functions/prestosql/tests/MapSubsetKeyInRangeTest.cpp
@@ -0,0 +1,515 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class MapSubsetKeyInRangeTest : public test::FunctionBaseTest {};
+
+TEST_F(MapSubsetKeyInRangeTest, basicBigintKey) {
+  auto inputMap = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:30, 4:40, 5:50}",
+      "{7:70, 10:100, 14:140, 20:200}",
+      "{}",
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{2:20, 3:30, 4:40, 5:50}",
+      "{7:70, 10:100, 14:140}",
+      "{}",
+  });
+
+  auto result = evaluate(
+      "map_subset_key_in_range(c0, cast(2 as bigint), cast(14 as bigint))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapSubsetKeyInRangeTest, boundaryInclusivity) {
+  auto inputMap = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:30, 4:40, 5:50}",
+  });
+
+  // Bounds are inclusive: keys 1 and 5 should be included.
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:30, 4:40, 5:50}",
+  });
+
+  auto result = evaluate(
+      "map_subset_key_in_range(c0, cast(1 as bigint), cast(5 as bigint))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapSubsetKeyInRangeTest, allKeysInRange) {
+  auto inputMap = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:30}",
+      "{5:50}",
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:30}",
+      "{5:50}",
+  });
+
+  auto result = evaluate(
+      "map_subset_key_in_range(c0, cast(0 as bigint), cast(100 as bigint))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapSubsetKeyInRangeTest, allKeysOutOfRange) {
+  auto inputMap = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:30}",
+      "{100:1000, 200:2000}",
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{}",
+      "{}",
+  });
+
+  auto result = evaluate(
+      "map_subset_key_in_range(c0, cast(50 as bigint), cast(60 as bigint))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapSubsetKeyInRangeTest, lowGreaterThanHigh) {
+  auto inputMap = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:30, 4:40, 5:50}",
+      "{7:70, 14:140}",
+  });
+
+  // When low > high, the result is always an empty map.
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{}",
+      "{}",
+  });
+
+  auto result = evaluate(
+      "map_subset_key_in_range(c0, cast(14 as bigint), cast(7 as bigint))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapSubsetKeyInRangeTest, emptyMap) {
+  auto inputMap =
+      makeMapVectorFromJson<int64_t, int32_t>({"{}", "{}", "{1:10}"});
+
+  auto expected =
+      makeMapVectorFromJson<int64_t, int32_t>({"{}", "{}", "{1:10}"});
+
+  auto result = evaluate(
+      "map_subset_key_in_range(c0, cast(0 as bigint), cast(100 as bigint))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapSubsetKeyInRangeTest, nullMap) {
+  auto inputMap = makeNullableMapVector<int64_t, int32_t>({
+      std::nullopt,
+      {{{1, 10}, {2, 20}, {3, 30}}},
+      std::nullopt,
+  });
+
+  auto expected = makeNullableMapVector<int64_t, int32_t>({
+      std::nullopt,
+      {{{2, 20}}},
+      std::nullopt,
+  });
+
+  auto result = evaluate(
+      "map_subset_key_in_range(c0, cast(2 as bigint), cast(2 as bigint))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+// Per Velox default null behavior (void call, not callNullable), if low_key
+// is null the result is null regardless of input map contents.
+TEST_F(MapSubsetKeyInRangeTest, nullLowKey) {
+  auto inputMap = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:30}",
+      "{4:40, 5:50}",
+      "{}",
+  });
+
+  auto lowKeys = makeNullableFlatVector<int64_t>({
+      std::nullopt,
+      2,
+      std::nullopt,
+  });
+  auto highKeys = makeFlatVector<int64_t>({10, 4, 100});
+
+  // Row 0: low is null -> null. Row 1: normal -> {4:40}. Row 2: low is
+  // null -> null (even though input map is empty).
+  auto expected = makeNullableMapVector<int64_t, int32_t>({
+      std::nullopt,
+      {{{4, 40}}},
+      std::nullopt,
+  });
+
+  auto result = evaluate(
+      "map_subset_key_in_range(c0, c1, c2)",
+      makeRowVector({inputMap, lowKeys, highKeys}));
+  assertEqualVectors(expected, result);
+}
+
+// Per Velox default null behavior, if high_key is null the result is null.
+TEST_F(MapSubsetKeyInRangeTest, nullHighKey) {
+  auto inputMap = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:30}",
+      "{4:40, 5:50}",
+  });
+
+  auto lowKeys = makeFlatVector<int64_t>({1, 4});
+  auto highKeys = makeNullableFlatVector<int64_t>({std::nullopt, 5});
+
+  auto expected = makeNullableMapVector<int64_t, int32_t>({
+      std::nullopt,
+      {{{4, 40}, {5, 50}}},
+  });
+
+  auto result = evaluate(
+      "map_subset_key_in_range(c0, c1, c2)",
+      makeRowVector({inputMap, lowKeys, highKeys}));
+  assertEqualVectors(expected, result);
+}
+
+// Both bounds null -> null. Also covers the varchar specialization to make
+// sure default null handling applies there too.
+TEST_F(MapSubsetKeyInRangeTest, nullBothBoundsVarchar) {
+  auto inputMap = makeMapVectorFromJson<std::string, int32_t>({
+      R"({"a":1, "b":2, "c":3})",
+      R"({"x":10, "y":20})",
+  });
+
+  auto lowKeys = makeNullableFlatVector<std::string>({std::nullopt, "x"});
+  auto highKeys = makeNullableFlatVector<std::string>({std::nullopt, "y"});
+
+  auto expected = makeNullableMapVector<std::string, int32_t>({
+      std::nullopt,
+      {{{"x", 10}, {"y", 20}}},
+  });
+
+  auto result = evaluate(
+      "map_subset_key_in_range(c0, c1, c2)",
+      makeRowVector({inputMap, lowKeys, highKeys}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapSubsetKeyInRangeTest, nullValuesPreserved) {
+  auto inputMap = makeNullableMapVector<int64_t, int32_t>({
+      {{{1, 10}, {2, std::nullopt}, {3, 30}, {4, std::nullopt}, {5, 50}}},
+  });
+
+  auto expected = makeNullableMapVector<int64_t, int32_t>({
+      {{{2, std::nullopt}, {3, 30}, {4, std::nullopt}}},
+  });
+
+  auto result = evaluate(
+      "map_subset_key_in_range(c0, cast(2 as bigint), cast(4 as bigint))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapSubsetKeyInRangeTest, varcharKey) {
+  auto inputMap = makeMapVectorFromJson<std::string, int32_t>({
+      R"({"apple":1, "banana":2, "cherry":3, "date":4, "eggplant":5})",
+      R"({"x":10, "y":20, "z":30})",
+  });
+
+  auto expected = makeMapVectorFromJson<std::string, int32_t>({
+      R"({"banana":2, "cherry":3, "date":4})",
+      R"({})",
+  });
+
+  auto result = evaluate(
+      "map_subset_key_in_range(c0, 'banana', 'date')",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapSubsetKeyInRangeTest, varcharKeyBoundaryInclusive) {
+  auto inputMap = makeMapVectorFromJson<std::string, int32_t>({
+      R"({"apple":1, "banana":2, "cherry":3})",
+  });
+
+  auto expected = makeMapVectorFromJson<std::string, int32_t>({
+      R"({"apple":1, "banana":2, "cherry":3})",
+  });
+
+  auto result = evaluate(
+      "map_subset_key_in_range(c0, 'apple', 'cherry')",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapSubsetKeyInRangeTest, intKeyTypes) {
+  // Verify int32 (integer) keys work via primitive specialization.
+  auto inputMap = makeMapVectorFromJson<int32_t, int32_t>({
+      "{1:10, 2:20, 3:30, 4:40}",
+  });
+
+  auto expected = makeMapVectorFromJson<int32_t, int32_t>({
+      "{2:20, 3:30}",
+  });
+
+  auto result = evaluate(
+      "map_subset_key_in_range(c0, cast(2 as integer), cast(3 as integer))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapSubsetKeyInRangeTest, doubleKey) {
+  auto inputMap = makeMapVectorFromJson<double, int32_t>({
+      "{1.5:1, 2.5:2, 3.5:3, 4.5:4}",
+  });
+
+  auto expected = makeMapVectorFromJson<double, int32_t>({
+      "{2.5:2, 3.5:3}",
+  });
+
+  auto result = evaluate(
+      "map_subset_key_in_range(c0, 2.0, 4.0)", makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapSubsetKeyInRangeTest, sameLowAndHigh) {
+  auto inputMap = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:30}",
+      "{5:50}",
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{2:20}",
+      "{}",
+  });
+
+  auto result = evaluate(
+      "map_subset_key_in_range(c0, cast(2 as bigint), cast(2 as bigint))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapSubsetKeyInRangeTest, complexValues) {
+  // Map<bigint, array<int>>: verify generic value type is preserved.
+  auto inputMap = makeMapVector(
+      {0, 3},
+      makeFlatVector<int64_t>({1, 2, 3, 10, 20}),
+      makeArrayVectorFromJson<int32_t>({
+          "[1, 2]",
+          "[3, 4]",
+          "[5, 6]",
+          "[100]",
+          "[200]",
+      }));
+
+  auto expected = makeMapVector(
+      {0, 2},
+      makeFlatVector<int64_t>({2, 3, 10}),
+      makeArrayVectorFromJson<int32_t>({
+          "[3, 4]",
+          "[5, 6]",
+          "[100]",
+      }));
+
+  auto result = evaluate(
+      "map_subset_key_in_range(c0, cast(2 as bigint), cast(10 as bigint))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+// Exercises MapSubsetKeyInRangeGenericFunction (the Orderable<T1> fallback)
+// using an array key. Each input row carries its own pair of array bounds.
+TEST_F(MapSubsetKeyInRangeTest, arrayKeyGeneric) {
+  auto inputMap = makeMapVector(
+      {0, 2, 4},
+      makeArrayVectorFromJson<int32_t>({
+          "[1, 2, 3]",
+          "[4, 5]",
+          "[1, 2]",
+          "[7, 8]",
+          "[3, 4]",
+          "[6, 7]",
+      }),
+      makeFlatVector<int32_t>({10, 20, 30, 40, 50, 60}));
+
+  auto lowKeys = makeArrayVectorFromJson<int32_t>({
+      "[1, 2, 3]",
+      "[1, 2]",
+      "[3, 4]",
+  });
+  auto highKeys = makeArrayVectorFromJson<int32_t>({
+      "[4, 5]",
+      "[7, 8]",
+      "[3, 4]",
+  });
+
+  // Lexicographic order of arrays:
+  //   row 0: [1,2,3] <= [1,2,3] and [4,5] <= [4,5] -> both kept
+  //   row 1: [1,2] kept; [7,8] kept (= high)
+  //   row 2: [3,4] kept (= low = high), [6,7] excluded (> high)
+  auto expected = makeMapVector(
+      {0, 2, 4},
+      makeArrayVectorFromJson<int32_t>({
+          "[1, 2, 3]",
+          "[4, 5]",
+          "[1, 2]",
+          "[7, 8]",
+          "[3, 4]",
+      }),
+      makeFlatVector<int32_t>({10, 20, 30, 40, 50}));
+
+  auto result = evaluate(
+      "map_subset_key_in_range(c0, c1, c2)",
+      makeRowVector({inputMap, lowKeys, highKeys}));
+  assertEqualVectors(expected, result);
+}
+
+// Exercises the generic path with low > high — should yield an empty map.
+TEST_F(MapSubsetKeyInRangeTest, arrayKeyGenericLowGreaterThanHigh) {
+  auto inputMap = makeMapVector(
+      {0},
+      makeArrayVectorFromJson<int32_t>({
+          "[1, 2]",
+          "[3, 4]",
+          "[5, 6]",
+      }),
+      makeFlatVector<int32_t>({10, 20, 30}));
+
+  auto lowKeys = makeArrayVectorFromJson<int32_t>({"[5, 6]"});
+  auto highKeys = makeArrayVectorFromJson<int32_t>({"[1, 2]"});
+
+  auto expected = makeMapVector(
+      {0}, makeArrayVectorFromJson<int32_t>({}), makeFlatVector<int32_t>({}));
+
+  auto result = evaluate(
+      "map_subset_key_in_range(c0, c1, c2)",
+      makeRowVector({inputMap, lowKeys, highKeys}));
+  assertEqualVectors(expected, result);
+}
+
+// Exercises the generic path with row keys (an Orderable type).
+TEST_F(MapSubsetKeyInRangeTest, rowKeyGeneric) {
+  auto keyRows = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 3, 4}),
+      makeFlatVector<int32_t>({10, 20, 30, 40}),
+  });
+  auto inputMap = makeMapVector(
+      {0}, keyRows, makeFlatVector<int32_t>({100, 200, 300, 400}));
+
+  auto lowKeyRows = makeRowVector({
+      makeFlatVector<int32_t>({2}),
+      makeFlatVector<int32_t>({20}),
+  });
+  auto highKeyRows = makeRowVector({
+      makeFlatVector<int32_t>({3}),
+      makeFlatVector<int32_t>({30}),
+  });
+
+  // Rows compare lexicographically: only (2,20) and (3,30) are in [low, high].
+  auto expectedKeyRows = makeRowVector({
+      makeFlatVector<int32_t>({2, 3}),
+      makeFlatVector<int32_t>({20, 30}),
+  });
+  auto expected =
+      makeMapVector({0}, expectedKeyRows, makeFlatVector<int32_t>({200, 300}));
+
+  auto result = evaluate(
+      "map_subset_key_in_range(c0, c1, c2)",
+      makeRowVector({inputMap, lowKeyRows, highKeyRows}));
+  assertEqualVectors(expected, result);
+}
+
+// The generic path must reject keys containing null elements because
+// comparison on indeterminate values is not defined.
+TEST_F(MapSubsetKeyInRangeTest, genericKeyWithNullElementsThrows) {
+  auto inputMap = makeMapVector(
+      {0},
+      makeArrayVectorFromJson<int32_t>({
+          "[1, null]",
+          "[2, 3]",
+      }),
+      makeFlatVector<int32_t>({10, 20}));
+
+  auto lowKeys = makeArrayVectorFromJson<int32_t>({"[1, 1]"});
+  auto highKeys = makeArrayVectorFromJson<int32_t>({"[3, 3]"});
+
+  VELOX_ASSERT_THROW(
+      evaluate(
+          "map_subset_key_in_range(c0, c1, c2)",
+          makeRowVector({inputMap, lowKeys, highKeys})),
+      "Ordering nulls is not supported");
+}
+
+// Floating-point keys must use NaN-aware ordering: NaN > all non-NaN values
+// and NaN == NaN.
+TEST_F(MapSubsetKeyInRangeTest, doubleKeyNaN) {
+  static const auto kNaN = std::numeric_limits<double>::quiet_NaN();
+  static const auto kSNaN = std::numeric_limits<double>::signaling_NaN();
+
+  // A NaN key is included only when the upper bound is NaN. Bounds [1, 5]
+  // exclude NaN; bounds [1, NaN] include it; bounds [NaN, NaN] keep only NaN.
+  auto inputMap = makeMapVectorFromJson<double, int32_t>({
+      "{1.0:10, 2.0:20, NaN:99, 5.0:50}",
+      "{1.0:10, 2.0:20, NaN:99, 5.0:50}",
+      "{1.0:10, 2.0:20, NaN:99, 5.0:50}",
+  });
+
+  auto lowKeys = makeFlatVector<double>({1.0, 1.0, kNaN});
+  auto highKeys = makeFlatVector<double>({5.0, kSNaN, kNaN});
+
+  auto expected = makeMapVectorFromJson<double, int32_t>({
+      "{1.0:10, 2.0:20, 5.0:50}",
+      "{1.0:10, 2.0:20, NaN:99, 5.0:50}",
+      "{NaN:99}",
+  });
+
+  auto result = evaluate(
+      "map_subset_key_in_range(c0, c1, c2)",
+      makeRowVector({inputMap, lowKeys, highKeys}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapSubsetKeyInRangeTest, floatKeyNaN) {
+  static const auto kNaN = std::numeric_limits<float>::quiet_NaN();
+
+  auto inputMap = makeMapVectorFromJson<float, int32_t>({
+      "{1.0:10, 2.0:20, NaN:99}",
+  });
+
+  auto lowKeys = makeFlatVector<float>({2.0f});
+  auto highKeys = makeFlatVector<float>({kNaN});
+
+  // NaN is treated as the maximum, so [2.0, NaN] keeps 2.0 and NaN.
+  auto expected = makeMapVectorFromJson<float, int32_t>({
+      "{2.0:20, NaN:99}",
+  });
+
+  auto result = evaluate(
+      "map_subset_key_in_range(c0, c1, c2)",
+      makeRowVector({inputMap, lowKeys, highKeys}));
+  assertEqualVectors(expected, result);
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/MapTest.cpp b/velox/functions/prestosql/tests/MapTest.cpp
index a60955f331b..3ade245bcfa 100644
--- a/velox/functions/prestosql/tests/MapTest.cpp
+++ b/velox/functions/prestosql/tests/MapTest.cpp
@@ -308,7 +308,7 @@ TEST_F(MapTest, fewerValuesThanKeysInLast) {
       "try("
       "   if(c0, "
       "       map(c1, c2), "
-      "       cast(null as map(integer, integer))))",
+      "       cast(null as map(bigint, bigint))))",
       makeRowVector({condition, keys2, values2}));
   EXPECT_EQ(0, result->offsetAt(0));
   EXPECT_EQ(3, result->offsetAt(2));
diff --git a/velox/functions/prestosql/tests/MapTrimValuesTest.cpp b/velox/functions/prestosql/tests/MapTrimValuesTest.cpp
new file mode 100644
index 00000000000..d0cf010c820
--- /dev/null
+++ b/velox/functions/prestosql/tests/MapTrimValuesTest.cpp
@@ -0,0 +1,457 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cstdint>
+#include <optional>
+#include <random>
+
+#include <gtest/gtest.h>
+
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/type/StringView.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class MapTrimValuesTest : public test::FunctionBaseTest {};
+
+TEST_F(MapTrimValuesTest, basicTrimming) {
+  // Create input map: {1->[10,20,30], 2->[40,50,60]}
+  auto keys = makeFlatVector<int32_t>({1, 2});
+  auto valueArrays = makeArrayVector<int64_t>({{10, 20, 30}, {40, 50, 60}});
+  auto inputMap = makeMapVector({0}, keys, valueArrays);
+
+  auto result = evaluate("map_trim_values(c0, 2)", makeRowVector({inputMap}));
+
+  // Expected: {1->[10,20], 2->[40,50]}
+  auto expectedKeys = makeFlatVector<int32_t>({1, 2});
+  auto expectedValues = makeArrayVector<int64_t>({{10, 20}, {40, 50}});
+  auto expected = makeMapVector({0}, expectedKeys, expectedValues);
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapTrimValuesTest, trimToZero) {
+  // Create input map: {1->[10,20], 2->[30,40,50]}
+  auto keys = makeFlatVector<int32_t>({1, 2});
+  auto valueArrays = makeArrayVector<int64_t>({{10, 20}, {30, 40, 50}});
+  auto inputMap = makeMapVector({0}, keys, valueArrays);
+
+  auto result = evaluate("map_trim_values(c0, 0)", makeRowVector({inputMap}));
+
+  // Expected: {1->[], 2->[]}
+  auto expectedKeys = makeFlatVector<int32_t>({1, 2});
+  auto expectedValues = makeArrayVector<int64_t>({{}, {}});
+  auto expected = makeMapVector({0}, expectedKeys, expectedValues);
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapTrimValuesTest, trimLargerThanArraySize) {
+  // Create input map: {1->[10,20], 2->[30]}
+  auto keys = makeFlatVector<int32_t>({1, 2});
+  auto valueArrays = makeArrayVector<int64_t>({{10, 20}, {30}});
+  auto inputMap = makeMapVector({0}, keys, valueArrays);
+
+  auto result = evaluate("map_trim_values(c0, 100)", makeRowVector({inputMap}));
+
+  // Expected: {1->[10,20], 2->[30]} (no change)
+  auto expectedKeys = makeFlatVector<int32_t>({1, 2});
+  auto expectedValues = makeArrayVector<int64_t>({{10, 20}, {30}});
+  auto expected = makeMapVector({0}, expectedKeys, expectedValues);
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapTrimValuesTest, negativeN) {
+  // Create input map: {1->[10,20,30]}
+  auto keys = makeFlatVector<int32_t>({1});
+  auto valueArrays = makeArrayVector<int64_t>({{10, 20, 30}});
+  auto inputMap = makeMapVector({0}, keys, valueArrays);
+
+  auto result = evaluate("map_trim_values(c0, -1)", makeRowVector({inputMap}));
+
+  // Expected: {1->[10,20,30]} (no change)
+  auto expectedKeys = makeFlatVector<int32_t>({1});
+  auto expectedValues = makeArrayVector<int64_t>({{10, 20, 30}});
+  auto expected = makeMapVector({0}, expectedKeys, expectedValues);
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapTrimValuesTest, emptyMap) {
+  // Create empty input map
+  auto keys = makeFlatVector<int32_t>({});
+  auto valueArrays = makeArrayVector<int64_t>({});
+  auto inputMap = makeMapVector({0}, keys, valueArrays);
+
+  auto result = evaluate("map_trim_values(c0, 2)", makeRowVector({inputMap}));
+
+  // Expected: {} (empty map)
+  auto expectedKeys = makeFlatVector<int32_t>({});
+  auto expectedValues = makeArrayVector<int64_t>({});
+  auto expected = makeMapVector({0}, expectedKeys, expectedValues);
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapTrimValuesTest, emptyValueArrays) {
+  // Create input map: {1->[], 2->[]}
+  auto keys = makeFlatVector<int32_t>({1, 2});
+  auto valueArrays = makeArrayVector<int64_t>({{}, {}});
+  auto inputMap = makeMapVector({0}, keys, valueArrays);
+
+  auto result = evaluate("map_trim_values(c0, 5)", makeRowVector({inputMap}));
+
+  // Expected: {1->[], 2->[]} (no change)
+  auto expectedKeys = makeFlatVector<int32_t>({1, 2});
+  auto expectedValues = makeArrayVector<int64_t>({{}, {}});
+  auto expected = makeMapVector({0}, expectedKeys, expectedValues);
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapTrimValuesTest, nullValuesInArray) {
+  // Create input map: {1->[10,null,30], 2->[null,50]}
+  auto keys = makeFlatVector<int32_t>({1, 2});
+  auto valueArrays = makeNullableArrayVector<int64_t>(
+      {{10, std::nullopt, 30}, {std::nullopt, 50}});
+  auto inputMap = makeMapVector({0}, keys, valueArrays);
+
+  auto result = evaluate("map_trim_values(c0, 2)", makeRowVector({inputMap}));
+
+  // Expected: {1->[10,null], 2->[null,50]}
+  auto expectedKeys = makeFlatVector<int32_t>({1, 2});
+  auto expectedValues = makeNullableArrayVector<int64_t>(
+      {{10, std::nullopt}, {std::nullopt, 50}});
+  auto expected = makeMapVector({0}, expectedKeys, expectedValues);
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapTrimValuesTest, stringKeys) {
+  // Create input map: {'apple'->[1,2,3], 'banana'->[4,5,6]}
+  auto keys = makeFlatVector<StringView>({"apple", "banana"});
+  auto valueArrays = makeArrayVector<int64_t>({{1, 2, 3}, {4, 5, 6}});
+  auto inputMap = makeMapVector({0}, keys, valueArrays);
+
+  auto result = evaluate("map_trim_values(c0, 2)", makeRowVector({inputMap}));
+
+  // Expected: {'apple'->[1,2], 'banana'->[4,5]}
+  auto expectedKeys = makeFlatVector<StringView>({"apple", "banana"});
+  auto expectedValues = makeArrayVector<int64_t>({{1, 2}, {4, 5}});
+  auto expected = makeMapVector({0}, expectedKeys, expectedValues);
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapTrimValuesTest, stringValues) {
+  // Create input map: {1->['a','b','c'], 2->['d','e','f']}
+  auto keys = makeFlatVector<int32_t>({1, 2});
+  auto valueArrays =
+      makeArrayVector<StringView>({{"a", "b", "c"}, {"d", "e", "f"}});
+  auto inputMap = makeMapVector({0}, keys, valueArrays);
+
+  auto result = evaluate("map_trim_values(c0, 2)", makeRowVector({inputMap}));
+
+  // Expected: {1->['a','b'], 2->['d','e']}
+  auto expectedKeys = makeFlatVector<int32_t>({1, 2});
+  auto expectedValues = makeArrayVector<StringView>({{"a", "b"}, {"d", "e"}});
+  auto expected = makeMapVector({0}, expectedKeys, expectedValues);
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapTrimValuesTest, floatValues) {
+  // Create input map: {1->[1.1,2.2,3.3], 2->[4.4,5.5,6.6]}
+  auto keys = makeFlatVector<int32_t>({1, 2});
+  auto valueArrays =
+      makeArrayVector<double>({{1.1, 2.2, 3.3}, {4.4, 5.5, 6.6}});
+  auto inputMap = makeMapVector({0}, keys, valueArrays);
+
+  auto result = evaluate("map_trim_values(c0, 2)", makeRowVector({inputMap}));
+
+  // Expected: {1->[1.1,2.2], 2->[4.4,5.5]}
+  auto expectedKeys = makeFlatVector<int32_t>({1, 2});
+  auto expectedValues = makeArrayVector<double>({{1.1, 2.2}, {4.4, 5.5}});
+  auto expected = makeMapVector({0}, expectedKeys, expectedValues);
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapTrimValuesTest, singleElementArrays) {
+  // Create input map: {1->[100], 2->[200]}
+  auto keys = makeFlatVector<int32_t>({1, 2});
+  auto valueArrays = makeArrayVector<int64_t>({{100}, {200}});
+  auto inputMap = makeMapVector({0}, keys, valueArrays);
+
+  auto result = evaluate("map_trim_values(c0, 1)", makeRowVector({inputMap}));
+
+  // Expected: {1->[100], 2->[200]} (no change)
+  auto expectedKeys = makeFlatVector<int32_t>({1, 2});
+  auto expectedValues = makeArrayVector<int64_t>({{100}, {200}});
+  auto expected = makeMapVector({0}, expectedKeys, expectedValues);
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapTrimValuesTest, mixedArraySizes) {
+  // Create input map: {1->[10], 2->[20,30,40], 3->[50,60,70]}
+  auto keys = makeFlatVector<int32_t>({1, 2, 3});
+  auto valueArrays =
+      makeArrayVector<int64_t>({{10}, {20, 30, 40}, {50, 60, 70}});
+  auto inputMap = makeMapVector({0}, keys, valueArrays);
+
+  auto result = evaluate("map_trim_values(c0, 2)", makeRowVector({inputMap}));
+
+  // Expected: {1->[10], 2->[20,30], 3->[50,60]}
+  auto expectedKeys = makeFlatVector<int32_t>({1, 2, 3});
+  auto expectedValues = makeArrayVector<int64_t>({{10}, {20, 30}, {50, 60}});
+  auto expected = makeMapVector({0}, expectedKeys, expectedValues);
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapTrimValuesTest, booleanValues) {
+  // Create input map: {1->[true,false,true], 2->[false,true,false]}
+  auto keys = makeFlatVector<int32_t>({1, 2});
+  auto valueArrays =
+      makeArrayVector<bool>({{true, false, true}, {false, true, false}});
+  auto inputMap = makeMapVector({0}, keys, valueArrays);
+
+  auto result = evaluate("map_trim_values(c0, 2)", makeRowVector({inputMap}));
+
+  // Expected: {1->[true,false], 2->[false,true]}
+  auto expectedKeys = makeFlatVector<int32_t>({1, 2});
+  auto expectedValues = makeArrayVector<bool>({{true, false}, {false, true}});
+  auto expected = makeMapVector({0}, expectedKeys, expectedValues);
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapTrimValuesTest, trimToOne) {
+  // Create input map: {1->[10,20,30], 2->[40,50,60]}
+  auto keys = makeFlatVector<int32_t>({1, 2});
+  auto valueArrays = makeArrayVector<int64_t>({{10, 20, 30}, {40, 50, 60}});
+  auto inputMap = makeMapVector({0}, keys, valueArrays);
+
+  auto result = evaluate("map_trim_values(c0, 1)", makeRowVector({inputMap}));
+
+  // Expected: {1->[10], 2->[40]}
+  auto expectedKeys = makeFlatVector<int32_t>({1, 2});
+  auto expectedValues = makeArrayVector<int64_t>({{10}, {40}});
+  auto expected = makeMapVector({0}, expectedKeys, expectedValues);
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapTrimValuesTest, singleKeyMap) {
+  // Create input map: {1->[10,20,30,40,50]}
+  auto keys = makeFlatVector<int32_t>({1});
+  auto valueArrays = makeArrayVector<int64_t>({{10, 20, 30, 40, 50}});
+  auto inputMap = makeMapVector({0}, keys, valueArrays);
+
+  auto result = evaluate("map_trim_values(c0, 3)", makeRowVector({inputMap}));
+
+  // Expected: {1->[10,20,30]}
+  auto expectedKeys = makeFlatVector<int32_t>({1});
+  auto expectedValues = makeArrayVector<int64_t>({{10, 20, 30}});
+  auto expected = makeMapVector({0}, expectedKeys, expectedValues);
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapTrimValuesTest, multipleRows) {
+  // Create two rows with different maps
+  // Row 0: {1->[10,20,30], 2->[40,50,60]}
+  // Row 1: {3->[70,80,90], 4->[100,110,120]}
+  auto keys = makeFlatVector<int32_t>({1, 2, 3, 4});
+  auto valueArrays = makeArrayVector<int64_t>(
+      {{10, 20, 30}, {40, 50, 60}, {70, 80, 90}, {100, 110, 120}});
+  auto inputMap = makeMapVector({0, 2}, keys, valueArrays);
+
+  auto result = evaluate("map_trim_values(c0, 2)", makeRowVector({inputMap}));
+
+  // Expected:
+  // Row 0: {1->[10,20], 2->[40,50]}
+  // Row 1: {3->[70,80], 4->[100,110]}
+  auto expectedKeys = makeFlatVector<int32_t>({1, 2, 3, 4});
+  auto expectedValues =
+      makeArrayVector<int64_t>({{10, 20}, {40, 50}, {70, 80}, {100, 110}});
+  auto expected = makeMapVector({0, 2}, expectedKeys, expectedValues);
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapTrimValuesTest, nullMapValue) {
+  // Create input map where a value is null: {1->[10,20,30], 2->null}
+  auto keys = makeFlatVector<int32_t>({1, 2});
+  auto valueArrays =
+      makeNullableArrayVector<int64_t>({{{10, 20, 30}}, std::nullopt});
+  auto inputMap = makeMapVector({0}, keys, valueArrays);
+
+  auto result = evaluate("map_trim_values(c0, 2)", makeRowVector({inputMap}));
+
+  // Expected: {1->[10,20], 2->null}
+  auto expectedKeys = makeFlatVector<int32_t>({1, 2});
+  auto expectedValues =
+      makeNullableArrayVector<int64_t>({{{10, 20}}, std::nullopt});
+  auto expected = makeMapVector({0}, expectedKeys, expectedValues);
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapTrimValuesTest, nullMapValueNegativeN) {
+  // Create input map where a value is null: {1->[10,20,30], 2->null}
+  auto keys = makeFlatVector<int32_t>({1, 2});
+  auto valueArrays =
+      makeNullableArrayVector<int64_t>({{{10, 20, 30}}, std::nullopt});
+  auto inputMap = makeMapVector({0}, keys, valueArrays);
+
+  auto result = evaluate("map_trim_values(c0, -1)", makeRowVector({inputMap}));
+
+  // Expected: {1->[10,20,30], 2->null} (no change)
+  auto expectedKeys = makeFlatVector<int32_t>({1, 2});
+  auto expectedValues =
+      makeNullableArrayVector<int64_t>({{{10, 20, 30}}, std::nullopt});
+  auto expected = makeMapVector({0}, expectedKeys, expectedValues);
+
+  assertEqualVectors(expected, result);
+}
+
+} // namespace
+
+// ============================================================================
+// CUSTOM FUZZER TESTS
+// These tests use VectorFuzzer to generate random inputs and verify that
+// map_trim_values behaves correctly:
+// 1. When n >= 0, each value array is trimmed to at most n elements
+// 2. When n < 0, the original map is returned unchanged
+// 3. The result map has the same keys as the input map
+// ============================================================================
+
+class MapTrimValuesFuzzerTest : public test::FunctionBaseTest {
+ protected:
+  template <typename KeyType, typename ValueType>
+  void runFuzzerTest(
+      vector_size_t vectorSize,
+      double nullRatio,
+      size_t containerLength) {
+    VectorFuzzer::Options opts;
+    opts.vectorSize = vectorSize;
+    opts.nullRatio = nullRatio;
+    opts.containerLength = containerLength;
+    opts.containerVariableLength = true;
+    opts.containerHasNulls = true;
+
+    VectorFuzzer fuzzer(opts, pool());
+
+    auto mapType = MAP(
+        CppToType<KeyType>::create(), ARRAY(CppToType<ValueType>::create()));
+    auto inputMap = fuzzer.fuzz(mapType);
+
+    std::mt19937 rng(42);
+    std::uniform_int_distribution<int64_t> nDist(-5, 20);
+
+    for (int iter = 0; iter < 10; ++iter) {
+      int64_t n = nDist(rng);
+      auto nVector = makeConstant<int64_t>(n, vectorSize);
+      auto data = makeRowVector({inputMap, nVector});
+
+      VectorPtr result;
+      try {
+        result = evaluate("map_trim_values(c0, c1)", data);
+      } catch (...) {
+        continue;
+      }
+
+      if (!result) {
+        continue;
+      }
+
+      auto inputMapVector = inputMap->template as<MapVector>();
+      auto resultMapVector = result->template as<MapVector>();
+      if (!inputMapVector || !resultMapVector) {
+        continue;
+      }
+
+      for (vector_size_t row = 0; row < vectorSize; ++row) {
+        if (inputMap->isNullAt(row)) {
+          ASSERT_TRUE(result->isNullAt(row))
+              << "Result should be null when input is null at row " << row;
+          continue;
+        }
+
+        if (result->isNullAt(row)) {
+          continue;
+        }
+
+        ASSERT_EQ(inputMapVector->sizeAt(row), resultMapVector->sizeAt(row))
+            << "Map should have same number of entries at row " << row;
+
+        if (n < 0) {
+          ASSERT_TRUE(inputMap->equalValueAt(result.get(), row, row))
+              << "When n < 0, result should equal input at row " << row;
+        }
+      }
+    }
+  }
+};
+
+TEST_F(MapTrimValuesFuzzerTest, fuzzIntegerKeyIntegerValue) {
+  runFuzzerTest<int32_t, int64_t>(100, 0.1, 10);
+}
+
+TEST_F(MapTrimValuesFuzzerTest, fuzzBigintKeyBigintValue) {
+  runFuzzerTest<int64_t, int64_t>(100, 0.1, 10);
+}
+
+TEST_F(MapTrimValuesFuzzerTest, fuzzVarcharKeyIntegerValue) {
+  runFuzzerTest<StringView, int64_t>(100, 0.1, 10);
+}
+
+TEST_F(MapTrimValuesFuzzerTest, fuzzIntegerKeyVarcharValue) {
+  runFuzzerTest<int32_t, StringView>(100, 0.1, 10);
+}
+
+TEST_F(MapTrimValuesFuzzerTest, fuzzIntegerKeyDoubleValue) {
+  runFuzzerTest<int32_t, double>(100, 0.1, 10);
+}
+
+TEST_F(MapTrimValuesFuzzerTest, fuzzHighNullRatio) {
+  runFuzzerTest<int32_t, int64_t>(100, 0.5, 10);
+}
+
+TEST_F(MapTrimValuesFuzzerTest, fuzzLargeVectors) {
+  runFuzzerTest<int32_t, int64_t>(500, 0.1, 5);
+}
+
+TEST_F(MapTrimValuesFuzzerTest, fuzzSmallintKeySmallintValue) {
+  runFuzzerTest<int16_t, int16_t>(100, 0.1, 10);
+}
+
+TEST_F(MapTrimValuesFuzzerTest, fuzzBooleanValue) {
+  runFuzzerTest<int32_t, bool>(100, 0.1, 10);
+}
+
+TEST_F(MapTrimValuesFuzzerTest, fuzzEmptyContainers) {
+  runFuzzerTest<int32_t, int64_t>(100, 0.1, 2);
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/MapUpdateTest.cpp b/velox/functions/prestosql/tests/MapUpdateTest.cpp
new file mode 100644
index 00000000000..a492513bb72
--- /dev/null
+++ b/velox/functions/prestosql/tests/MapUpdateTest.cpp
@@ -0,0 +1,715 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class MapUpdateTest : public test::FunctionBaseTest {
+ public:
+  template <typename T>
+  void testFloatNaNs() {
+    static const auto kNaN = std::numeric_limits<T>::quiet_NaN();
+
+    auto data = makeRowVector({
+        makeMapVectorFromJson<T, int32_t>({
+            "{1:10, NaN:20, 3:30, 4:40, 5:50}",
+            "{NaN:20}",
+        }),
+        makeArrayVector<T>({{1, kNaN, 5}, {kNaN}}),
+        makeArrayVector<int32_t>({{100, 200, 500}, {999}}),
+    });
+
+    auto expected = makeMapVectorFromJson<T, int32_t>({
+        "{1:100, NaN:200, 3:30, 4:40, 5:500}",
+        "{NaN:999}",
+    });
+    auto result = evaluate("map_update(c0, c1, c2)", data);
+    assertEqualVectors(expected, result);
+  }
+};
+
+TEST_F(MapUpdateTest, basicUpdate) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20, 3:30}",
+          "{1:10, 2:20}",
+          "{}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[2, 3]",
+          "[1]",
+          "[1, 2]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[200, 300]",
+          "[100]",
+          "[10, 20]",
+      }),
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:200, 3:300}",
+      "{1:100, 2:20}",
+      "{1:10, 2:20}",
+  });
+
+  auto result = evaluate("map_update(c0, c1, c2)", data);
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapUpdateTest, addNewKeys) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20}",
+          "{}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[3, 4]",
+          "[1, 2, 3]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[30, 40]",
+          "[10, 20, 30]",
+      }),
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:30, 4:40}",
+      "{1:10, 2:20, 3:30}",
+  });
+
+  auto result = evaluate("map_update(c0, c1, c2)", data);
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapUpdateTest, mixedUpdateAndAdd) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20, 3:30}",
+          "{1:10, 2:20, 3:30, 4:40}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[2, 4, 5]",
+          "[1, 5]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[200, 400, 500]",
+          "[100, 500]",
+      }),
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:200, 3:30, 4:400, 5:500}",
+      "{1:100, 2:20, 3:30, 4:40, 5:500}",
+  });
+
+  auto result = evaluate("map_update(c0, c1, c2)", data);
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapUpdateTest, emptyKeysAndValues) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20, 3:30}",
+          "{}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[]",
+          "[]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[]",
+          "[]",
+      }),
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:30}",
+      "{}",
+  });
+
+  auto result = evaluate("map_update(c0, c1, c2)", data);
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapUpdateTest, nullValuesInInput) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:null, 3:30}",
+          "{1:null, 2:20}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[2, 4]",
+          "[1]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[200, 400]",
+          "[100]",
+      }),
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:200, 3:30, 4:400}",
+      "{1:100, 2:20}",
+  });
+
+  auto result = evaluate("map_update(c0, c1, c2)", data);
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapUpdateTest, nullValuesInUpdate) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20, 3:30}",
+          "{1:10, 2:20}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[2, 4]",
+          "[1, 3]",
+      }),
+      makeNullableArrayVector<int32_t>({
+          {std::nullopt, 400},
+          {std::nullopt, 300},
+      }),
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:null, 3:30, 4:400}",
+      "{1:null, 2:20, 3:300}",
+  });
+
+  auto result = evaluate("map_update(c0, c1, c2)", data);
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapUpdateTest, varcharKey) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<std::string, int32_t>({
+          R"({"apple": 1, "banana": 2, "cherry": 3})",
+          R"({"banana": 2, "orange": 4})",
+      }),
+      makeArrayVectorFromJson<std::string>({
+          R"(["apple", "date"])",
+          R"(["banana", "grape"])",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[100, 400]",
+          "[200, 500]",
+      }),
+  });
+
+  auto expected = makeMapVectorFromJson<std::string, int32_t>({
+      R"({"apple": 100, "banana": 2, "cherry": 3, "date": 400})",
+      R"({"banana": 200, "orange": 4, "grape": 500})",
+  });
+
+  auto result = evaluate("map_update(c0, c1, c2)", data);
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapUpdateTest, duplicateKeysInUpdateArrayThrows) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[1, 1, 2]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[100, 200, 300]",
+      }),
+  });
+
+  VELOX_ASSERT_THROW(
+      evaluate("map_update(c0, c1, c2)", data), "Duplicate key in keys array");
+}
+
+TEST_F(MapUpdateTest, mismatchedKeysValuesLengthThrows) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[1, 2, 3]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[100, 200]",
+      }),
+  });
+
+  VELOX_ASSERT_THROW(
+      evaluate("map_update(c0, c1, c2)", data),
+      "Keys and values arrays must have the same length");
+}
+
+TEST_F(MapUpdateTest, nullKeysInUpdateArrayAreIgnored) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20, 3:30}",
+      }),
+      makeNullableArrayVector<int64_t>({
+          {std::nullopt, 2, std::nullopt, 4},
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[100, 200, 300, 400]",
+      }),
+  });
+
+  auto expected =
+      makeMapVectorFromJson<int64_t, int32_t>({"{1:10, 2:200, 3:30, 4:400}"});
+
+  auto result = evaluate("map_update(c0, c1, c2)", data);
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapUpdateTest, floatNaNs) {
+  testFloatNaNs<float>();
+  testFloatNaNs<double>();
+}
+
+TEST_F(MapUpdateTest, booleanKey) {
+  auto data = makeRowVector({
+      makeMapVector<bool, int32_t>({{{true, 10}, {false, 20}}}),
+      makeArrayVector<bool>({{true}}),
+      makeArrayVector<int32_t>({{100}}),
+  });
+
+  auto expected = makeMapVector<bool, int32_t>({{{true, 100}, {false, 20}}});
+
+  auto result = evaluate("map_update(c0, c1, c2)", data);
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapUpdateTest, allKeysUpdated) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20, 3:30}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[1, 2, 3]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[100, 200, 300]",
+      }),
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:100, 2:200, 3:300}",
+  });
+
+  auto result = evaluate("map_update(c0, c1, c2)", data);
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapUpdateTest, largeMap) {
+  // Create a map with 10 entries and update/add 3
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20, 3:30, 4:40, 5:50, 6:60, 7:70, 8:80, 9:90, 10:100}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[5, 10, 11]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[500, 1000, 1100]",
+      }),
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:30, 4:40, 5:500, 6:60, 7:70, 8:80, 9:90, 10:1000, 11:1100}",
+  });
+
+  auto result = evaluate("map_update(c0, c1, c2)", data);
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapUpdateTest, timestampKeys) {
+  auto data = makeRowVector({
+      makeMapVector<Timestamp, int32_t>(
+          {{{Timestamp(1, 0), 10}, {Timestamp(2, 0), 20}}}),
+      makeArrayVector<Timestamp>({{Timestamp(2, 0), Timestamp(3, 0)}}),
+      makeArrayVector<int32_t>({{200, 30}}),
+  });
+
+  auto result = evaluate("map_update(c0, c1, c2)", data);
+
+  auto expected = makeMapVector<Timestamp, int32_t>(
+      {{{Timestamp(1, 0), 10}, {Timestamp(2, 0), 200}, {Timestamp(3, 0), 30}}});
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapUpdateTest, preserveUnchangedKeys) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{5:50, 3:30, 1:10}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[2, 4]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[20, 40]",
+      }),
+  });
+
+  auto result = evaluate("map_update(c0, c1, c2)", data);
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{5:50, 3:30, 1:10, 2:20, 4:40}",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapUpdateTest, updateToNull) {
+  // Using explicit vector type to avoid ambiguity
+  const std::vector<std::vector<std::optional<int32_t>>> valuesData = {
+      {std::nullopt},
+  };
+
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[1]",
+      }),
+      makeNullableArrayVector<int32_t>(valuesData),
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:null, 2:20}",
+  });
+
+  auto result = evaluate("map_update(c0, c1, c2)", data);
+  assertEqualVectors(expected, result);
+}
+
+// Tests specifically for order preservation behavior.
+TEST_F(MapUpdateTest, orderPreservationUpdateFirstKey) {
+  // Update the first key - it should remain in position 1.
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20, 3:30, 4:40, 5:50}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[1]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[100]",
+      }),
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:100, 2:20, 3:30, 4:40, 5:50}",
+  });
+
+  auto result = evaluate("map_update(c0, c1, c2)", data);
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapUpdateTest, orderPreservationUpdateMiddleKey) {
+  // Update the middle key - it should remain in its original position.
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20, 3:30, 4:40, 5:50}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[3]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[300]",
+      }),
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:300, 4:40, 5:50}",
+  });
+
+  auto result = evaluate("map_update(c0, c1, c2)", data);
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapUpdateTest, orderPreservationUpdateLastKey) {
+  // Update the last key - it should remain in its original position.
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20, 3:30, 4:40, 5:50}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[5]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[500]",
+      }),
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:30, 4:40, 5:500}",
+  });
+
+  auto result = evaluate("map_update(c0, c1, c2)", data);
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapUpdateTest, orderPreservationUpdateMultipleNonConsecutive) {
+  // Update multiple non-consecutive keys - they should all remain in place.
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20, 3:30, 4:40, 5:50}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[1, 3, 5]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[100, 300, 500]",
+      }),
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:100, 2:20, 3:300, 4:40, 5:500}",
+  });
+
+  auto result = evaluate("map_update(c0, c1, c2)", data);
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapUpdateTest, orderPreservationNewKeysAppendedInOrder) {
+  // New keys should be appended at the end in the order they appear
+  // in the update arrays.
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[5, 3, 4]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[50, 30, 40]",
+      }),
+  });
+
+  // New keys 5, 3, 4 should be appended in that order.
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 5:50, 3:30, 4:40}",
+  });
+
+  auto result = evaluate("map_update(c0, c1, c2)", data);
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapUpdateTest, orderPreservationMixedUpdateAndNewKeys) {
+  // Mix of updates and new keys - updates stay in place, new keys append.
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20, 3:30}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[2, 5, 4]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[200, 50, 40]",
+      }),
+  });
+
+  // Key 2 stays in position 2 with new value, keys 5 and 4 are appended.
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:200, 3:30, 5:50, 4:40}",
+  });
+
+  auto result = evaluate("map_update(c0, c1, c2)", data);
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapUpdateTest, orderPreservationVarcharKeys) {
+  // Test order preservation with varchar keys.
+  auto data = makeRowVector({
+      makeMapVectorFromJson<std::string, int32_t>({
+          R"({"alpha": 1, "beta": 2, "gamma": 3, "delta": 4})",
+      }),
+      makeArrayVectorFromJson<std::string>({
+          R"(["beta", "delta", "epsilon"])",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[200, 400, 500]",
+      }),
+  });
+
+  // beta and delta should stay in place, epsilon appended at end.
+  auto expected = makeMapVectorFromJson<std::string, int32_t>({
+      R"({"alpha": 1, "beta": 200, "gamma": 3, "delta": 400, "epsilon": 500})",
+  });
+
+  auto result = evaluate("map_update(c0, c1, c2)", data);
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapUpdateTest, orderPreservationUpdateKeysInReverseOrder) {
+  // Update keys are provided in reverse order of their position in input map.
+  // The output should preserve the original input map order, not the update
+  // array order.
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20, 3:30, 4:40}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[4, 2, 1]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[400, 200, 100]",
+      }),
+  });
+
+  // Keys should remain in original order: 1, 2, 3, 4 (not 4, 2, 1).
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:100, 2:200, 3:30, 4:400}",
+  });
+
+  auto result = evaluate("map_update(c0, c1, c2)", data);
+  assertEqualVectors(expected, result);
+}
+
+} // namespace
+
+// ============================================================================
+// CUSTOM FUZZER TESTS
+// These tests use VectorFuzzer to generate random inputs and verify
+// properties of the map_update function. Since map_update has complex error
+// conditions (duplicate keys, mismatched lengths), the tests use
+// try(map_update(...)) to gracefully handle errors and verify that:
+// - When the function succeeds, the result map size is correct
+// - Null handling is correct
+// ============================================================================
+
+class MapUpdateFuzzerTest : public test::FunctionBaseTest {
+ protected:
+  static SelectivityVector getNonNullRows(const RowVectorPtr& data) {
+    SelectivityVector nonNullRows(data->size());
+    for (vector_size_t i = 0; i < data->size(); ++i) {
+      bool hasNull = false;
+      for (vector_size_t j = 0; j < data->childrenSize(); ++j) {
+        if (data->childAt(j)->isNullAt(i)) {
+          hasNull = true;
+          break;
+        }
+      }
+      if (hasNull) {
+        nonNullRows.setValid(i, false);
+      }
+    }
+    nonNullRows.updateBounds();
+    return nonNullRows;
+  }
+
+  void testMapUpdateProperties(const RowVectorPtr& data) {
+    auto nonNullRows = getNonNullRows(data);
+    if (nonNullRows.countSelected() == 0) {
+      return;
+    }
+
+    VectorPtr result;
+    try {
+      result = evaluate("try(map_update(c0, c1, c2))", data);
+    } catch (...) {
+      return;
+    }
+
+    if (!result) {
+      return;
+    }
+
+    auto inputMap = data->childAt(0);
+    auto inputMapVector = inputMap->as<MapVector>();
+    if (!inputMapVector) {
+      return;
+    }
+
+    for (auto i = 0; i < data->size(); ++i) {
+      if (!nonNullRows.isValid(i) || result->isNullAt(i)) {
+        continue;
+      }
+
+      if (inputMap->isNullAt(i)) {
+        continue;
+      }
+
+      auto resultMap = result->as<MapVector>();
+      if (!resultMap) {
+        continue;
+      }
+
+      auto origSize = inputMapVector->sizeAt(i);
+      auto resultSize = resultMap->sizeAt(i);
+      ASSERT_GE(resultSize, origSize)
+          << "Result map should be at least as large as input map at row " << i;
+    }
+  }
+
+  template <typename KeyType, typename ValueType>
+  void runFuzzerTest(
+      const TypePtr& keyType,
+      const TypePtr& valueType,
+      vector_size_t vectorSize = 50,
+      double nullRatio = 0.1,
+      vector_size_t containerLength = 5) {
+    VectorFuzzer::Options opts;
+    opts.vectorSize = vectorSize;
+    opts.nullRatio = nullRatio;
+    opts.containerLength = containerLength;
+    VectorFuzzer fuzzer(opts, pool());
+
+    auto inputMap = fuzzer.fuzz(MAP(keyType, valueType));
+    auto keys = fuzzer.fuzz(ARRAY(keyType));
+    auto values = fuzzer.fuzz(ARRAY(valueType));
+    auto data = makeRowVector({inputMap, keys, values});
+    testMapUpdateProperties(data);
+  }
+};
+
+TEST_F(MapUpdateFuzzerTest, fuzzInteger) {
+  runFuzzerTest<int32_t, int32_t>(INTEGER(), INTEGER());
+}
+
+TEST_F(MapUpdateFuzzerTest, fuzzBigint) {
+  runFuzzerTest<int64_t, int64_t>(BIGINT(), BIGINT());
+}
+
+TEST_F(MapUpdateFuzzerTest, fuzzVarchar) {
+  runFuzzerTest<StringView, StringView>(VARCHAR(), VARCHAR());
+}
+
+TEST_F(MapUpdateFuzzerTest, fuzzDouble) {
+  runFuzzerTest<double, double>(DOUBLE(), DOUBLE());
+}
+
+TEST_F(MapUpdateFuzzerTest, fuzzHighNullRatio) {
+  runFuzzerTest<int32_t, int32_t>(INTEGER(), INTEGER(), 50, 0.5, 5);
+}
+
+TEST_F(MapUpdateFuzzerTest, fuzzSmallint) {
+  runFuzzerTest<int16_t, int16_t>(SMALLINT(), SMALLINT());
+}
+
+TEST_F(MapUpdateFuzzerTest, fuzzLargeVectors) {
+  runFuzzerTest<int32_t, int32_t>(INTEGER(), INTEGER(), 200, 0.1, 3);
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/MapValuesInRangeTest.cpp b/velox/functions/prestosql/tests/MapValuesInRangeTest.cpp
new file mode 100644
index 00000000000..863dcdee04e
--- /dev/null
+++ b/velox/functions/prestosql/tests/MapValuesInRangeTest.cpp
@@ -0,0 +1,587 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class MapValuesInRangeTest : public test::FunctionBaseTest {
+ protected:
+  void testMapValuesInRange(
+      const std::string& expression,
+      const std::vector<VectorPtr>& input,
+      const VectorPtr& expected) {
+    auto result = evaluate(expression, makeRowVector(input));
+    assertEqualVectors(expected, result);
+  }
+};
+
+TEST_F(MapValuesInRangeTest, basicInteger) {
+  auto inputMap = makeMapVectorFromJson<int64_t, int64_t>({
+      "{1:10, 2:20, 3:30, 4:40, 5:50}",
+      "{1:5, 2:15, 3:25, 4:35, 5:100}",
+      "{}",
+      "{1:1, 2:2, 3:3}",
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int64_t>({
+      "{2:20, 3:30, 4:40}",
+      "{2:15, 3:25, 4:35}",
+      "{}",
+      "{}",
+  });
+
+  auto result = evaluate(
+      "map_values_in_range(c0, cast(15 as bigint), cast(40 as bigint))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapValuesInRangeTest, basicDouble) {
+  auto inputMap = makeMapVectorFromJson<int64_t, double>({
+      "{1:1.5, 2:2.5, 3:3.5, 4:4.5, 5:5.5}",
+      "{1:0.5, 2:1.5, 3:10.5}",
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, double>({
+      "{2:2.5, 3:3.5, 4:4.5}",
+      "{}",
+  });
+
+  auto result =
+      evaluate("map_values_in_range(c0, 2.0, 5.0)", makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapValuesInRangeTest, varcharKey) {
+  auto inputMap = makeMapVectorFromJson<std::string, int64_t>({
+      R"({"apple":10, "banana":20, "cherry":30, "date":40})",
+      R"({"x":5, "y":50, "z":25})",
+  });
+
+  auto expected = makeMapVectorFromJson<std::string, int64_t>({
+      R"({"banana":20, "cherry":30})",
+      R"({"z":25})",
+  });
+
+  auto result = evaluate(
+      "map_values_in_range(c0, cast(15 as bigint), cast(35 as bigint))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapValuesInRangeTest, emptyMap) {
+  auto inputMap =
+      makeMapVectorFromJson<int64_t, int64_t>({"{}", "{}", "{1:10}"});
+
+  auto expected =
+      makeMapVectorFromJson<int64_t, int64_t>({"{}", "{}", "{1:10}"});
+
+  auto result = evaluate(
+      "map_values_in_range(c0, cast(0 as bigint), cast(100 as bigint))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapValuesInRangeTest, allValuesOutOfRange) {
+  auto inputMap = makeMapVectorFromJson<int64_t, int64_t>({
+      "{1:1, 2:2, 3:3}",
+      "{1:100, 2:200, 3:300}",
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int64_t>({
+      "{}",
+      "{}",
+  });
+
+  auto result = evaluate(
+      "map_values_in_range(c0, cast(50 as bigint), cast(60 as bigint))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapValuesInRangeTest, allValuesInRange) {
+  auto inputMap = makeMapVectorFromJson<int64_t, int64_t>({
+      "{1:10, 2:20, 3:30}",
+      "{1:15, 2:25}",
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int64_t>({
+      "{1:10, 2:20, 3:30}",
+      "{1:15, 2:25}",
+  });
+
+  auto result = evaluate(
+      "map_values_in_range(c0, cast(0 as bigint), cast(100 as bigint))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapValuesInRangeTest, boundaryValues) {
+  auto inputMap = makeMapVectorFromJson<int64_t, int64_t>({
+      "{1:10, 2:20, 3:30, 4:40, 5:50}",
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int64_t>({
+      "{1:10, 2:20, 3:30, 4:40, 5:50}",
+  });
+
+  auto result = evaluate(
+      "map_values_in_range(c0, cast(10 as bigint), cast(50 as bigint))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapValuesInRangeTest, nullValuesPreserved) {
+  auto inputMap = makeNullableMapVector<int64_t, int64_t>({
+      {{{1, 10}, {2, std::nullopt}, {3, 30}, {4, std::nullopt}, {5, 50}}},
+      {{{1, std::nullopt}, {2, 20}}},
+  });
+
+  auto expected = makeNullableMapVector<int64_t, int64_t>({
+      {{{2, std::nullopt}, {3, 30}, {4, std::nullopt}}},
+      {{{1, std::nullopt}, {2, 20}}},
+  });
+
+  auto result = evaluate(
+      "map_values_in_range(c0, cast(15 as bigint), cast(45 as bigint))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapValuesInRangeTest, floatValues) {
+  auto inputMap = makeMapVectorFromJson<int64_t, double>({
+      "{1:1.1, 2:2.2, 3:3.3, 4:4.4, 5:5.5}",
+      "{1:0.1, 2:10.1}",
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, double>({
+      "{2:2.2, 3:3.3, 4:4.4}",
+      "{}",
+  });
+
+  auto result =
+      evaluate("map_values_in_range(c0, 2.0, 5.0)", makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapValuesInRangeTest, negativeBounds) {
+  auto inputMap = makeMapVectorFromJson<int64_t, int64_t>({
+      "{1:-50, 2:-20, 3:0, 4:20, 5:50}",
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int64_t>({
+      "{2:-20, 3:0, 4:20}",
+  });
+
+  auto result = evaluate(
+      "map_values_in_range(c0, cast(-30 as bigint), cast(30 as bigint))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapValuesInRangeTest, singleElementMap) {
+  auto inputMap = makeMapVectorFromJson<int64_t, int64_t>({
+      "{1:25}",
+      "{1:5}",
+      "{1:100}",
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int64_t>({
+      "{1:25}",
+      "{}",
+      "{}",
+  });
+
+  auto result = evaluate(
+      "map_values_in_range(c0, cast(10 as bigint), cast(50 as bigint))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapValuesInRangeTest, int32KeyAndValue) {
+  auto inputMap = makeMapVectorFromJson<int32_t, int32_t>({
+      "{1:10, 2:20, 3:30, 4:40}",
+      "{1:5, 2:25, 3:45}",
+  });
+
+  auto expected = makeMapVectorFromJson<int32_t, int32_t>({
+      "{2:20, 3:30}",
+      "{2:25}",
+  });
+
+  auto result = evaluate(
+      "map_values_in_range(c0, cast(15 as integer), cast(35 as integer))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapValuesInRangeTest, varcharKeyDoubleValue) {
+  auto inputMap = makeMapVectorFromJson<std::string, double>({
+      R"({"a":1.5, "b":2.5, "c":3.5, "d":4.5})",
+      R"({"x":0.5, "y":5.5})",
+  });
+
+  auto expected = makeMapVectorFromJson<std::string, double>({
+      R"({"b":2.5, "c":3.5})",
+      "{}",
+  });
+
+  auto result =
+      evaluate("map_values_in_range(c0, 2.0, 4.0)", makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapValuesInRangeTest, sameLowerAndUpperBound) {
+  auto inputMap = makeMapVectorFromJson<int64_t, int64_t>({
+      "{1:10, 2:25, 3:25, 4:30}",
+      "{1:25, 2:25}",
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int64_t>({
+      "{2:25, 3:25}",
+      "{1:25, 2:25}",
+  });
+
+  auto result = evaluate(
+      "map_values_in_range(c0, cast(25 as bigint), cast(25 as bigint))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapValuesInRangeTest, largeMap) {
+  auto inputMap = makeMapVectorFromJson<int64_t, int64_t>({
+      "{1:10, 2:20, 3:30, 4:40, 5:50, 6:60, 7:70, 8:80, 9:90, 10:100}",
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int64_t>({
+      "{2:20, 3:30, 4:40, 5:50, 6:60, 7:70, 8:80}",
+  });
+
+  auto result = evaluate(
+      "map_values_in_range(c0, cast(20 as bigint), cast(80 as bigint))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapValuesInRangeTest, varcharKeyFloatValue) {
+  auto inputMap = makeMapVectorFromJson<std::string, float>({
+      R"({"temp1":20.5, "temp2":25.0, "temp3":30.5, "temp4":35.0})",
+      R"({"sensor1":10.0, "sensor2":50.0})",
+  });
+
+  auto expected = makeMapVectorFromJson<std::string, float>({
+      R"({"temp2":25.0, "temp3":30.5})",
+      "{}",
+  });
+
+  auto result = evaluate(
+      "map_values_in_range(c0, cast(22.0 as real), cast(32.0 as real))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapValuesInRangeTest, extremeValues) {
+  auto inputMap = makeMapVectorFromJson<int64_t, int64_t>({
+      "{1:-9223372036854775808, 2:0, 3:9223372036854775807}",
+  });
+
+  auto expected = makeMapVectorFromJson<int64_t, int64_t>({
+      "{2:0}",
+  });
+
+  auto result = evaluate(
+      "map_values_in_range(c0, cast(-100 as bigint), cast(100 as bigint))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+} // namespace
+
+// Custom fuzzer tests to compare map_values_in_range with equivalent expression
+// using existing UDFs. The equivalent expression is:
+// map_filter(map, (k, v) -> IF(v IS NULL, true, v >= lower_bound AND v <=
+// upper_bound))
+class MapValuesInRangeFuzzerTest : public test::FunctionBaseTest {
+ protected:
+  // Get a SelectivityVector that excludes rows where input map is null.
+  static SelectivityVector getNonNullRows(const RowVectorPtr& data) {
+    auto inputMap = data->childAt(0);
+    SelectivityVector nonNullRows(data->size());
+    for (vector_size_t i = 0; i < data->size(); ++i) {
+      if (inputMap->isNullAt(i)) {
+        nonNullRows.setValid(i, false);
+      }
+    }
+    nonNullRows.updateBounds();
+    return nonNullRows;
+  }
+
+  // Verify that map_values_in_range correctly filters values outside the range.
+  // Properties verified:
+  // 1. Result map size <= input map size
+  // 2. All non-null values in result are within [lowerBound, upperBound]
+  // 3. Null values are preserved
+  void testMapValuesInRangeProperties(
+      const RowVectorPtr& data,
+      double lowerBound,
+      double upperBound) {
+    auto nonNullRows = getNonNullRows(data);
+    if (nonNullRows.countSelected() == 0) {
+      return;
+    }
+
+    VectorPtr result;
+    try {
+      result = evaluate(
+          fmt::format(
+              "map_values_in_range(c0, cast({} as double), cast({} as double))",
+              lowerBound,
+              upperBound),
+          data);
+    } catch (...) {
+      return;
+    }
+
+    if (!result) {
+      return;
+    }
+
+    auto inputMap = data->childAt(0);
+    auto inputMapVector = inputMap->as<MapVector>();
+    if (!inputMapVector) {
+      return;
+    }
+
+    auto resultMap = result->as<MapVector>();
+    if (!resultMap) {
+      return;
+    }
+
+    for (auto i = 0; i < data->size(); ++i) {
+      if (!nonNullRows.isValid(i) || result->isNullAt(i)) {
+        continue;
+      }
+
+      if (inputMap->isNullAt(i)) {
+        continue;
+      }
+
+      auto origSize = inputMapVector->sizeAt(i);
+      auto resultSize = resultMap->sizeAt(i);
+      ASSERT_LE(resultSize, origSize)
+          << "Result map should be at most as large as input map at row " << i;
+    }
+  }
+
+  // Test equivalence with map_filter expression for double values.
+  void testEquivalenceDouble(
+      const RowVectorPtr& data,
+      double lowerBound,
+      double upperBound) {
+    auto nonNullRows = getNonNullRows(data);
+    if (nonNullRows.countSelected() == 0) {
+      return;
+    }
+
+    auto mapValuesInRangeExpr = fmt::format(
+        "map_values_in_range(c0, cast({} as double), cast({} as double))",
+        lowerBound,
+        upperBound);
+
+    // Equivalent expression: keep entries where value is null OR within bounds
+    auto equivalentExpr = fmt::format(
+        "map_filter(c0, (k, v) -> v IS NULL OR (v >= cast({} as double) AND v <= cast({} as double)))",
+        lowerBound,
+        upperBound);
+
+    VectorPtr result;
+    VectorPtr expected;
+    try {
+      result = evaluate(mapValuesInRangeExpr, data);
+      expected = evaluate(equivalentExpr, data);
+    } catch (...) {
+      return;
+    }
+
+    for (auto i = 0; i < data->size(); ++i) {
+      if (nonNullRows.isValid(i)) {
+        ASSERT_TRUE(expected->equalValueAt(result.get(), i, i))
+            << "Mismatch at row " << i << ": expected " << expected->toString(i)
+            << ", got " << result->toString(i);
+      }
+    }
+  }
+
+  // Test equivalence with map_filter expression for bigint values.
+  void testEquivalenceBigint(
+      const RowVectorPtr& data,
+      int64_t lowerBound,
+      int64_t upperBound) {
+    auto nonNullRows = getNonNullRows(data);
+    if (nonNullRows.countSelected() == 0) {
+      return;
+    }
+
+    auto mapValuesInRangeExpr = fmt::format(
+        "map_values_in_range(c0, cast({} as bigint), cast({} as bigint))",
+        lowerBound,
+        upperBound);
+
+    auto equivalentExpr = fmt::format(
+        "map_filter(c0, (k, v) -> v IS NULL OR (v >= cast({} as bigint) AND v <= cast({} as bigint)))",
+        lowerBound,
+        upperBound);
+
+    VectorPtr result;
+    VectorPtr expected;
+    try {
+      result = evaluate(mapValuesInRangeExpr, data);
+      expected = evaluate(equivalentExpr, data);
+    } catch (...) {
+      return;
+    }
+
+    for (auto i = 0; i < data->size(); ++i) {
+      if (nonNullRows.isValid(i)) {
+        ASSERT_TRUE(expected->equalValueAt(result.get(), i, i))
+            << "Mismatch at row " << i << ": expected " << expected->toString(i)
+            << ", got " << result->toString(i);
+      }
+    }
+  }
+};
+
+TEST_F(MapValuesInRangeFuzzerTest, fuzzIntegerKeyDoubleValue) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 10;
+  opts.containerVariableLength = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (auto i = 0; i < 10; ++i) {
+    auto inputMap = fuzzer.fuzz(MAP(INTEGER(), DOUBLE()));
+    auto data = makeRowVector({inputMap});
+    testEquivalenceDouble(data, -50.0, 50.0);
+    testMapValuesInRangeProperties(data, -50.0, 50.0);
+  }
+}
+
+TEST_F(MapValuesInRangeFuzzerTest, fuzzBigintKeyBigintValue) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 10;
+  opts.containerVariableLength = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (auto i = 0; i < 10; ++i) {
+    auto inputMap = fuzzer.fuzz(MAP(BIGINT(), BIGINT()));
+    auto data = makeRowVector({inputMap});
+    testEquivalenceBigint(data, -1000, 1000);
+    testMapValuesInRangeProperties(data, -1000.0, 1000.0);
+  }
+}
+
+TEST_F(MapValuesInRangeFuzzerTest, fuzzVarcharKeyDoubleValue) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 10;
+  opts.containerVariableLength = true;
+  opts.stringLength = 20;
+  opts.stringVariableLength = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (auto i = 0; i < 10; ++i) {
+    auto inputMap = fuzzer.fuzz(MAP(VARCHAR(), DOUBLE()));
+    auto data = makeRowVector({inputMap});
+    testEquivalenceDouble(data, 0.0, 100.0);
+    testMapValuesInRangeProperties(data, 0.0, 100.0);
+  }
+}
+
+TEST_F(MapValuesInRangeFuzzerTest, fuzzHighNullRatio) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.5;
+  opts.containerHasNulls = true;
+  opts.containerLength = 10;
+  opts.containerVariableLength = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (auto i = 0; i < 10; ++i) {
+    auto inputMap = fuzzer.fuzz(MAP(INTEGER(), DOUBLE()));
+    auto data = makeRowVector({inputMap});
+    testEquivalenceDouble(data, -100.0, 100.0);
+    testMapValuesInRangeProperties(data, -100.0, 100.0);
+  }
+}
+
+TEST_F(MapValuesInRangeFuzzerTest, fuzzSmallContainers) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 2;
+  opts.containerVariableLength = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (auto i = 0; i < 10; ++i) {
+    auto inputMap = fuzzer.fuzz(MAP(INTEGER(), DOUBLE()));
+    auto data = makeRowVector({inputMap});
+    testEquivalenceDouble(data, -10.0, 10.0);
+    testMapValuesInRangeProperties(data, -10.0, 10.0);
+  }
+}
+
+TEST_F(MapValuesInRangeFuzzerTest, fuzzLargeVectors) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 500;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 20;
+  opts.containerVariableLength = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (auto i = 0; i < 5; ++i) {
+    auto inputMap = fuzzer.fuzz(MAP(INTEGER(), DOUBLE()));
+    auto data = makeRowVector({inputMap});
+    testEquivalenceDouble(data, -1000.0, 1000.0);
+    testMapValuesInRangeProperties(data, -1000.0, 1000.0);
+  }
+}
+
+TEST_F(MapValuesInRangeFuzzerTest, fuzzNarrowBounds) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 10;
+  opts.containerVariableLength = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (auto i = 0; i < 10; ++i) {
+    auto inputMap = fuzzer.fuzz(MAP(INTEGER(), DOUBLE()));
+    auto data = makeRowVector({inputMap});
+    testEquivalenceDouble(data, -0.5, 0.5);
+    testMapValuesInRangeProperties(data, -0.5, 0.5);
+  }
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/MapValuesMatchTest.cpp b/velox/functions/prestosql/tests/MapValuesMatchTest.cpp
new file mode 100644
index 00000000000..73ba264a2e4
--- /dev/null
+++ b/velox/functions/prestosql/tests/MapValuesMatchTest.cpp
@@ -0,0 +1,472 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/LambdaParameterizedBaseTest.h"
+
+namespace facebook::velox::functions {
+namespace {
+
+class MapValuesMatchTest : public functions::test::LambdaParameterizedBaseTest {
+ protected:
+  void match(
+      const std::string& functionName,
+      const VectorPtr& input,
+      const std::string& lambda,
+      const std::vector<std::optional<bool>>& expected) {
+    const std::string expr =
+        fmt::format("{}(c0, x -> ({}))", functionName, lambda);
+    SCOPED_TRACE(expr);
+    auto result = evaluateParameterized(expr, makeRowVector({input}));
+    velox::test::assertEqualVectors(
+        makeNullableFlatVector<bool>(expected), result);
+  }
+
+  void allValuesMatch(
+      const VectorPtr& input,
+      const std::string& lambda,
+      const std::vector<std::optional<bool>>& expected) {
+    match("map_values_all_match", input, lambda, expected);
+  }
+
+  void anyValuesMatch(
+      const VectorPtr& input,
+      const std::string& lambda,
+      const std::vector<std::optional<bool>>& expected) {
+    match("map_values_any_match", input, lambda, expected);
+  }
+
+  void noneValuesMatch(
+      const VectorPtr& input,
+      const std::string& lambda,
+      const std::vector<std::optional<bool>>& expected) {
+    match("map_values_none_match", input, lambda, expected);
+  }
+};
+
+// =============================================================================
+// map_values_all_match tests
+// =============================================================================
+
+TEST_P(MapValuesMatchTest, allMatchBasic) {
+  auto data = makeMapVectorFromJson<int32_t, int64_t>({
+      "{1: 10, 2: 20, 3: 30}",
+      "{-1: 11, -2: 22}",
+  });
+
+  allValuesMatch(data, "x > 0", {true, true});
+  allValuesMatch(data, "x > 15", {false, false});
+  allValuesMatch(data, "x > 25", {false, false});
+  allValuesMatch(data, "x <= 30", {true, true});
+  allValuesMatch(data, "x <= 100", {true, true});
+  allValuesMatch(data, "x >= 10", {true, true});
+  allValuesMatch(data, "x >= 20", {false, false});
+}
+
+TEST_P(MapValuesMatchTest, allMatchNullPredicate) {
+  auto data = makeMapVectorFromJson<int32_t, int64_t>({
+      "{1: 10, 2: 20, 3: 30}",
+      "{-1: 11, -2: 22}",
+  });
+
+  // Predicate returns NULL for x=20 and false otherwise -> false (early exit).
+  allValuesMatch(data, "if(x = 20, null::boolean, false)", {false, false});
+  // Predicate returns NULL for x=20 and true otherwise -> NULL for row 0,
+  // true for row 1 (no 20 in second map).
+  allValuesMatch(data, "if(x = 20, null::boolean, true)", {std::nullopt, true});
+}
+
+TEST_P(MapValuesMatchTest, allMatchEmptyMap) {
+  auto data = makeMapVectorFromJson<int32_t, int64_t>({
+      "{}",
+  });
+  // Vacuously true.
+  allValuesMatch(data, "x > 0", {true});
+  allValuesMatch(data, "x < 0", {true});
+}
+
+TEST_P(MapValuesMatchTest, allMatchStringValues) {
+  auto data = makeMapVectorFromJson<int32_t, std::string>({
+      R"({1: "apple", 2: "banana", 3: "cherry"})",
+      R"({1: "dog", 2: "cat"})",
+  });
+
+  allValuesMatch(data, "length(x) > 2", {true, true});
+  // apple=5, banana=6, cherry=6 all > 4; dog=3, cat=3 not > 4
+  allValuesMatch(data, "length(x) > 4", {true, false});
+}
+
+TEST_P(MapValuesMatchTest, allMatchDoubleValues) {
+  auto data = makeMapVectorFromJson<int32_t, double>({
+      "{1: 1.5, 2: 2.5, 3: 3.5}",
+      "{1: 0.1, 2: 0.2}",
+  });
+
+  allValuesMatch(data, "x > 1.0", {true, false});
+  allValuesMatch(data, "x > 0.0", {true, true});
+  allValuesMatch(data, "x < 4.0", {true, true});
+}
+
+TEST_P(MapValuesMatchTest, allMatchVarcharKeys) {
+  auto data = makeMapVectorFromJson<std::string, int64_t>({
+      R"({"a": 10, "b": 20, "c": 30})",
+      R"({"x": 5, "y": 15})",
+  });
+
+  allValuesMatch(data, "x > 5", {true, false});
+  allValuesMatch(data, "x > 0", {true, true});
+}
+
+TEST_P(MapValuesMatchTest, allMatchNullMapValues) {
+  auto data = makeNullableMapVector<int32_t, int64_t>({
+      {{{1, 10}, {2, std::nullopt}, {3, 30}}},
+      {{{1, std::nullopt}, {2, std::nullopt}}},
+  });
+
+  // Row 0: 10>0=true, null->null, 30>0=true => NULL
+  // Row 1: null->null, null->null => NULL
+  allValuesMatch(data, "x > 0", {std::nullopt, std::nullopt});
+}
+
+TEST_P(MapValuesMatchTest, allMatchEquivalenceWithMapValues) {
+  auto data = makeMapVectorFromJson<int32_t, int64_t>({
+      "{1: 10, 2: 20, 3: 30}",
+      "{-1: 11, -2: 22}",
+      "{}",
+      "{1: 5}",
+  });
+
+  auto lambdas = {"x > 0", "x > 15", "x <= 30", "x = 10", "x % 2 = 0"};
+  for (const auto& lambda : lambdas) {
+    SCOPED_TRACE(lambda);
+    auto direct = evaluateParameterized(
+        fmt::format("map_values_all_match(c0, x -> ({}))", lambda),
+        makeRowVector({data}));
+    auto viaMapValues = evaluateParameterized(
+        fmt::format("all_match(map_values(c0), x -> ({}))", lambda),
+        makeRowVector({data}));
+    velox::test::assertEqualVectors(viaMapValues, direct);
+  }
+}
+
+TEST_P(MapValuesMatchTest, allMatchErrorPropagation) {
+  auto data = makeMapVectorFromJson<int32_t, int64_t>({
+      "{1: 10, 2: 0, 3: 20}",
+      "{1: 10, 2: 20}",
+  });
+
+  // Row 0: all non-error true, error propagates -> try wraps to NULL.
+  // Row 1: 10>0=true, 20>0=true -> true.
+  auto result = evaluateParameterized(
+      "try(map_values_all_match(c0, x -> (if(x = 0, 1/0 > 0, true))))",
+      makeRowVector({data}));
+  auto expected = makeNullableFlatVector<bool>({std::nullopt, true});
+  velox::test::assertEqualVectors(expected, result);
+}
+
+// =============================================================================
+// map_values_any_match tests
+// =============================================================================
+
+TEST_P(MapValuesMatchTest, anyMatchBasic) {
+  auto data = makeMapVectorFromJson<int32_t, int64_t>({
+      "{1: 10, 2: 20, 3: 30}",
+      "{-1: 11, -2: 22}",
+  });
+
+  anyValuesMatch(data, "x = 10", {true, false});
+  anyValuesMatch(data, "x = 22", {false, true});
+  anyValuesMatch(data, "x < 15", {true, true});
+  anyValuesMatch(data, "x < 0", {false, false});
+  anyValuesMatch(data, "x IN (20, 11)", {true, true});
+  anyValuesMatch(data, "x > 25", {true, false});
+}
+
+TEST_P(MapValuesMatchTest, anyMatchNullPredicate) {
+  auto data = makeMapVectorFromJson<int32_t, int64_t>({
+      "{1: 10, 2: 20, 3: 30}",
+      "{-1: 11, -2: 22}",
+  });
+
+  // Predicate returns NULL for x=20 and false otherwise.
+  // Row 0: false, null, false -> NULL (no true, has null)
+  // Row 1: false, false -> false
+  anyValuesMatch(
+      data, "if(x = 20, null::boolean, false)", {std::nullopt, false});
+  // Predicate returns NULL for x=20 and true otherwise.
+  // Row 0: true (early return on x=10)
+  // Row 1: true (early return on x=11)
+  anyValuesMatch(data, "if(x = 20, null::boolean, true)", {true, true});
+}
+
+TEST_P(MapValuesMatchTest, anyMatchEmptyMap) {
+  auto data = makeMapVectorFromJson<int32_t, int64_t>({
+      "{}",
+  });
+  anyValuesMatch(data, "x > 0", {false});
+  anyValuesMatch(data, "true", {false});
+}
+
+TEST_P(MapValuesMatchTest, anyMatchStringValues) {
+  auto data = makeMapVectorFromJson<int32_t, std::string>({
+      R"({1: "apple", 2: "banana", 3: "cherry"})",
+      R"({1: "dog", 2: "cat"})",
+  });
+
+  anyValuesMatch(data, "x = 'banana'", {true, false});
+  anyValuesMatch(data, "x = 'elephant'", {false, false});
+  anyValuesMatch(data, "length(x) > 5", {true, false});
+}
+
+TEST_P(MapValuesMatchTest, anyMatchDoubleValues) {
+  auto data = makeMapVectorFromJson<int32_t, double>({
+      "{1: 1.5, 2: 2.5, 3: 3.5}",
+      "{1: 0.1, 2: 0.2}",
+  });
+
+  anyValuesMatch(data, "x < 1.0", {false, true});
+  anyValuesMatch(data, "x > 3.0", {true, false});
+  anyValuesMatch(data, "x > 0.0", {true, true});
+}
+
+TEST_P(MapValuesMatchTest, anyMatchVarcharKeys) {
+  auto data = makeMapVectorFromJson<std::string, int64_t>({
+      R"({"a": 10, "b": 20, "c": 30})",
+      R"({"x": 5, "y": 15})",
+  });
+
+  anyValuesMatch(data, "x > 25", {true, false});
+  anyValuesMatch(data, "x > 0", {true, true});
+}
+
+TEST_P(MapValuesMatchTest, anyMatchNullMapValues) {
+  auto data = makeNullableMapVector<int32_t, int64_t>({
+      {{{1, 10}, {2, std::nullopt}, {3, 30}}},
+      {{{1, std::nullopt}, {2, std::nullopt}}},
+  });
+
+  // Row 0: 10>25=false, null->null, 30>25=true => true (early return)
+  // Row 1: null->null, null->null => NULL
+  anyValuesMatch(data, "x > 25", {true, std::nullopt});
+}
+
+TEST_P(MapValuesMatchTest, anyMatchConsistencyWithAnyValuesMatch) {
+  auto data = makeMapVectorFromJson<int32_t, int64_t>({
+      "{1: 10, 2: 20, 3: 30}",
+      "{-1: 11, -2: 22}",
+      "{}",
+      "{1: 5}",
+  });
+
+  auto lambdas = {"x > 15", "x = 10", "x < 0", "x IN (20, 11)", "x % 2 = 0"};
+  for (const auto& lambda : lambdas) {
+    SCOPED_TRACE(lambda);
+    auto newFn = evaluateParameterized(
+        fmt::format("map_values_any_match(c0, x -> ({}))", lambda),
+        makeRowVector({data}));
+    auto oldFn = evaluateParameterized(
+        fmt::format("any_values_match(c0, x -> ({}))", lambda),
+        makeRowVector({data}));
+    velox::test::assertEqualVectors(oldFn, newFn);
+  }
+}
+
+TEST_P(MapValuesMatchTest, anyMatchEquivalenceWithMapValues) {
+  auto data = makeMapVectorFromJson<int32_t, int64_t>({
+      "{1: 10, 2: 20, 3: 30}",
+      "{-1: 11, -2: 22}",
+      "{}",
+      "{1: 5}",
+  });
+
+  auto lambdas = {"x > 0", "x > 15", "x <= 30", "x = 10", "x % 2 = 0"};
+  for (const auto& lambda : lambdas) {
+    SCOPED_TRACE(lambda);
+    auto direct = evaluateParameterized(
+        fmt::format("map_values_any_match(c0, x -> ({}))", lambda),
+        makeRowVector({data}));
+    auto viaMapValues = evaluateParameterized(
+        fmt::format("any_match(map_values(c0), x -> ({}))", lambda),
+        makeRowVector({data}));
+    velox::test::assertEqualVectors(viaMapValues, direct);
+  }
+}
+
+TEST_P(MapValuesMatchTest, anyMatchErrorPropagation) {
+  auto data = makeMapVectorFromJson<int32_t, int64_t>({
+      "{1: 10, 2: 0, 3: 20}",
+      "{1: 0, 2: 0}",
+  });
+
+  // Row 0: x=10 -> true -> early return true.
+  // Row 1: x=0 -> error, x=0 -> error -> try wraps to NULL.
+  auto result = evaluateParameterized(
+      "try(map_values_any_match(c0, x -> (if(x = 0, 1/0 > 0, x > 5))))",
+      makeRowVector({data}));
+  auto expected = makeNullableFlatVector<bool>({true, std::nullopt});
+  velox::test::assertEqualVectors(expected, result);
+}
+
+// =============================================================================
+// map_values_none_match tests
+// =============================================================================
+
+TEST_P(MapValuesMatchTest, noneMatchBasic) {
+  auto data = makeMapVectorFromJson<int32_t, int64_t>({
+      "{1: 10, 2: 20, 3: 30}",
+      "{-1: 11, -2: 22}",
+  });
+
+  noneValuesMatch(data, "x = 7", {true, true});
+  noneValuesMatch(data, "x > 15", {false, false});
+  noneValuesMatch(data, "x > 25", {false, true});
+  noneValuesMatch(data, "x % 11 = 0", {true, false});
+  noneValuesMatch(data, "x < 0", {true, true});
+  noneValuesMatch(data, "x > 0", {false, false});
+}
+
+TEST_P(MapValuesMatchTest, noneMatchNullPredicate) {
+  auto data = makeMapVectorFromJson<int32_t, int64_t>({
+      "{1: 10, 2: 20, 3: 30}",
+      "{-1: 11, -2: 22}",
+  });
+
+  // Predicate returns NULL for x=20 and false otherwise.
+  // Row 0: false, null, false -> NULL (no true/earlyReturn, has null)
+  // Row 1: false, false -> true (initialValue preserved)
+  noneValuesMatch(
+      data, "if(x = 20, null::boolean, false)", {std::nullopt, true});
+  // Predicate returns NULL for x=20 and true otherwise.
+  // Row 0: true -> earlyReturn -> false
+  // Row 1: true -> earlyReturn -> false
+  noneValuesMatch(data, "if(x = 20, null::boolean, true)", {false, false});
+}
+
+TEST_P(MapValuesMatchTest, noneMatchEmptyMap) {
+  auto data = makeMapVectorFromJson<int32_t, int64_t>({
+      "{}",
+  });
+  // Vacuously true.
+  noneValuesMatch(data, "x > 0", {true});
+  noneValuesMatch(data, "true", {true});
+}
+
+TEST_P(MapValuesMatchTest, noneMatchStringValues) {
+  auto data = makeMapVectorFromJson<int32_t, std::string>({
+      R"({1: "apple", 2: "banana", 3: "cherry"})",
+      R"({1: "dog", 2: "cat"})",
+  });
+
+  noneValuesMatch(data, "x = 'banana'", {false, true});
+  noneValuesMatch(data, "x = 'elephant'", {true, true});
+  noneValuesMatch(data, "length(x) > 5", {false, true});
+}
+
+TEST_P(MapValuesMatchTest, noneMatchDoubleValues) {
+  auto data = makeMapVectorFromJson<int32_t, double>({
+      "{1: 1.5, 2: 2.5, 3: 3.5}",
+      "{1: 0.1, 2: 0.2}",
+  });
+
+  noneValuesMatch(data, "x > 10.0", {true, true});
+  noneValuesMatch(data, "x < 1.0", {true, false});
+  noneValuesMatch(data, "x > 0.0", {false, false});
+}
+
+TEST_P(MapValuesMatchTest, noneMatchVarcharKeys) {
+  auto data = makeMapVectorFromJson<std::string, int64_t>({
+      R"({"a": 10, "b": 20, "c": 30})",
+      R"({"x": 5, "y": 15})",
+  });
+
+  noneValuesMatch(data, "x > 25", {false, true});
+  noneValuesMatch(data, "x < 0", {true, true});
+}
+
+TEST_P(MapValuesMatchTest, noneMatchNullMapValues) {
+  auto data = makeNullableMapVector<int32_t, int64_t>({
+      {{{1, 10}, {2, std::nullopt}, {3, 30}}},
+      {{{1, std::nullopt}, {2, std::nullopt}}},
+  });
+
+  // Row 0: 10>25=false, null->null, 30>25=true => false (early return)
+  // Row 1: null->null, null->null => NULL
+  noneValuesMatch(data, "x > 25", {false, std::nullopt});
+}
+
+TEST_P(MapValuesMatchTest, noneMatchConsistencyWithNoValuesMatch) {
+  auto data = makeMapVectorFromJson<int32_t, int64_t>({
+      "{1: 10, 2: 20, 3: 30}",
+      "{-1: 11, -2: 22}",
+      "{}",
+      "{1: 5}",
+  });
+
+  auto lambdas = {"x > 15", "x = 10", "x < 0", "x IN (20, 11)", "x % 2 = 0"};
+  for (const auto& lambda : lambdas) {
+    SCOPED_TRACE(lambda);
+    auto newFn = evaluateParameterized(
+        fmt::format("map_values_none_match(c0, x -> ({}))", lambda),
+        makeRowVector({data}));
+    auto oldFn = evaluateParameterized(
+        fmt::format("no_values_match(c0, x -> ({}))", lambda),
+        makeRowVector({data}));
+    velox::test::assertEqualVectors(oldFn, newFn);
+  }
+}
+
+TEST_P(MapValuesMatchTest, noneMatchEquivalenceWithMapValues) {
+  auto data = makeMapVectorFromJson<int32_t, int64_t>({
+      "{1: 10, 2: 20, 3: 30}",
+      "{-1: 11, -2: 22}",
+      "{}",
+      "{1: 5}",
+  });
+
+  auto lambdas = {"x > 0", "x > 15", "x <= 30", "x = 10", "x % 2 = 0"};
+  for (const auto& lambda : lambdas) {
+    SCOPED_TRACE(lambda);
+    auto direct = evaluateParameterized(
+        fmt::format("map_values_none_match(c0, x -> ({}))", lambda),
+        makeRowVector({data}));
+    auto viaMapValues = evaluateParameterized(
+        fmt::format("none_match(map_values(c0), x -> ({}))", lambda),
+        makeRowVector({data}));
+    velox::test::assertEqualVectors(viaMapValues, direct);
+  }
+}
+
+TEST_P(MapValuesMatchTest, noneMatchErrorPropagation) {
+  auto data = makeMapVectorFromJson<int32_t, int64_t>({
+      "{1: 10, 2: 0, 3: 20}",
+      "{1: 0, 2: 0}",
+  });
+
+  // Row 0: x=10 -> true -> earlyReturn -> false.
+  // Row 1: x=0 -> error, x=0 -> error -> try wraps to NULL.
+  auto result = evaluateParameterized(
+      "try(map_values_none_match(c0, x -> (if(x = 0, 1/0 > 0, x > 5))))",
+      makeRowVector({data}));
+  auto expected = makeNullableFlatVector<bool>({false, std::nullopt});
+  velox::test::assertEqualVectors(expected, result);
+}
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    MapValuesMatchTest,
+    MapValuesMatchTest,
+    testing::ValuesIn(MapValuesMatchTest::getTestParams()));
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/MapZipWithTest.cpp b/velox/functions/prestosql/tests/MapZipWithTest.cpp
index 42f3c5287de..6d6297b5c4a 100644
--- a/velox/functions/prestosql/tests/MapZipWithTest.cpp
+++ b/velox/functions/prestosql/tests/MapZipWithTest.cpp
@@ -294,6 +294,30 @@ TEST_F(MapZipWithTest, fuzz) {
   }
 }
 
+TEST_F(MapZipWithTest, unknownType) {
+  auto makeFlatUnknownVector = [&](int size) {
+    auto vector =
+        BaseVector::create<FlatVector<UnknownValue>>(UNKNOWN(), size, pool());
+    for (int i = 0; i < size; ++i) {
+      vector->setNull(i, true);
+    }
+    return vector;
+  };
+
+  auto data = makeRowVector({
+      makeMapVector({0}, makeFlatUnknownVector(3), makeFlatUnknownVector(3)),
+      makeMapVector({0}, makeFlatUnknownVector(3), makeFlatUnknownVector(3)),
+  });
+
+  auto result =
+      evaluate("map_zip_with(c0, c1, (k, v1, v2) -> coalesce(v1, v2))", data);
+
+  auto expected =
+      makeMapVector({0}, makeFlatUnknownVector(3), makeFlatUnknownVector(3));
+
+  assertEqualVectors(expected, result);
+}
+
 TEST_F(MapZipWithTest, try) {
   auto data = makeRowVector(
       {makeMapVector<int64_t, int64_t>(
diff --git a/velox/functions/prestosql/tests/P4HyperLogLogCastTest.cpp b/velox/functions/prestosql/tests/P4HyperLogLogCastTest.cpp
index 5b2ab2d3a41..68e5e1f6ca6 100644
--- a/velox/functions/prestosql/tests/P4HyperLogLogCastTest.cpp
+++ b/velox/functions/prestosql/tests/P4HyperLogLogCastTest.cpp
@@ -13,35 +13,97 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/common/encode/Base64.h"
+
 #include "velox/functions/prestosql/tests/CastBaseTest.h"
+#include "velox/functions/prestosql/types/HyperLogLogType.h"
 #include "velox/functions/prestosql/types/P4HyperLogLogType.h"
 
 using namespace facebook::velox;
 
-class P4HyperLogLogCastTest : public functions::test::CastBaseTest {};
+class P4HyperLogLogCastTest : public functions::test::CastBaseTest {
+ protected:
+  // Helper to decode base64 to binary string
+  static std::string decodeBase64(const std::string& base64Str) {
+    return encoding::Base64::decode(base64Str);
+  }
+};
+
+TEST_F(P4HyperLogLogCastTest, nullValues) {
+  auto nullData = std::vector<std::optional<StringView>>{
+      std::nullopt, std::nullopt, std::nullopt, std::nullopt};
 
-TEST_F(P4HyperLogLogCastTest, toP4HyperLogLog) {
+  // HYPERLOGLOG from/to P4HYPERLOGLOG
   testCast<StringView, StringView>(
-      VARBINARY(),
-      P4HYPERLOGLOG(),
-      {"aaa"_sv, ""_sv, std::nullopt},
-      {"aaa"_sv, ""_sv, std::nullopt});
+      HYPERLOGLOG(), P4HYPERLOGLOG(), nullData, nullData);
   testCast<StringView, StringView>(
-      VARBINARY(),
-      P4HYPERLOGLOG(),
-      {std::nullopt, std::nullopt, std::nullopt, std::nullopt},
-      {std::nullopt, std::nullopt, std::nullopt, std::nullopt});
+      P4HYPERLOGLOG(), HYPERLOGLOG(), nullData, nullData);
 }
 
-TEST_F(P4HyperLogLogCastTest, fromP4HyperLogLog) {
+TEST_F(P4HyperLogLogCastTest, emptyValues) {
+  auto emptyData =
+      std::vector<std::optional<StringView>>{""_sv, ""_sv, ""_sv, ""_sv};
+
+  // HYPERLOGLOG from/to P4HYPERLOGLOG
   testCast<StringView, StringView>(
-      P4HYPERLOGLOG(),
-      VARBINARY(),
-      {"aaa"_sv, ""_sv, std::nullopt},
-      {"aaa"_sv, ""_sv, std::nullopt});
+      HYPERLOGLOG(), P4HYPERLOGLOG(), emptyData, emptyData);
   testCast<StringView, StringView>(
+      P4HYPERLOGLOG(), HYPERLOGLOG(), emptyData, emptyData);
+}
+
+TEST_F(P4HyperLogLogCastTest, nonEmptyValues) {
+  // SELECT cast(empty_approx_set(0.01625) as VARBINARY) as input1;
+  // SELECT cast(approx_set('test1', 0.01625) as VARBINARY) as input2;
+  // SELECT cast(approx_set('test_dense', 0.065) as VARBINARY) as input3;
+  std::string input1Binary = decodeBase64("AgwAAA==");
+  std::string input2Binary = decodeBase64("AgwBAELMwgM=");
+  std::string input3Binary = decodeBase64("AggBAED31hA=");
+
+  std::string expected1Binary = decodeBase64(
+      "AwwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=="); // Empty sparse → dense
+  std::string expected2Binary = decodeBase64(
+      "AwwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=="); // Sparse → dense
+  std::string expected3Binary = decodeBase64(
+      "AwgAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=="); // Dense → re-serialized
+
+  auto inputData = std::vector<std::optional<StringView>>{
+      StringView(input1Binary),
+      StringView(input2Binary),
+      StringView(input3Binary)};
+
+  auto expectedP4Data = std::vector<std::optional<StringView>>{
+      StringView(expected1Binary),
+      StringView(expected2Binary),
+      StringView(expected3Binary)};
+
+  // Test HYPERLOGLOG to P4HYPERLOGLOG conversion
+  testCast<StringView, StringView>(
+      HYPERLOGLOG(), P4HYPERLOGLOG(), inputData, expectedP4Data);
+
+  // Test P4HYPERLOGLOG to HYPERLOGLOG (should be direct copy)
+  testCast<StringView, StringView>(
+      P4HYPERLOGLOG(), HYPERLOGLOG(), expectedP4Data, expectedP4Data);
+}
+
+TEST_F(P4HyperLogLogCastTest, oldFormatSparseV1) {
+  // Test casting HLL with deprecated SPARSE_V1 format (tag = 0) to P4HLL
+
+  std::string sparseV1Binary = std::string(1, '\x00') + std::string(11, '\x00');
+
+  auto inputData =
+      std::vector<std::optional<StringView>>{StringView(sparseV1Binary)};
+
+  testThrow<StringView>(
+      HYPERLOGLOG(), P4HYPERLOGLOG(), inputData, "Invalid HyperLogLog format");
+}
+
+TEST_F(P4HyperLogLogCastTest, oldFormatDenseV1) {
+  // Test casting HLL with deprecated DENSE_V1 format (tag = 1) to P4HLL
+  std::string denseV1Binary = std::string(1, '\x01') + std::string(11, '\x00');
+
+  testThrow<StringView>(
+      HYPERLOGLOG(),
       P4HYPERLOGLOG(),
-      VARBINARY(),
-      {std::nullopt, std::nullopt, std::nullopt, std::nullopt},
-      {std::nullopt, std::nullopt, std::nullopt, std::nullopt});
+      {StringView(denseV1Binary)},
+      "Invalid HyperLogLog format");
 }
diff --git a/velox/functions/prestosql/tests/ProbabilityTest.cpp b/velox/functions/prestosql/tests/ProbabilityTest.cpp
index ce4974aeb1d..71d918630c2 100644
--- a/velox/functions/prestosql/tests/ProbabilityTest.cpp
+++ b/velox/functions/prestosql/tests/ProbabilityTest.cpp
@@ -853,5 +853,64 @@ TEST_F(ProbabilityTest, inverseChiSquaredCdf) {
       "inverseChiSquaredCdf Function: p must be in the interval [0, 1]");
 }
 
+TEST_F(ProbabilityTest, tCDF) {
+  const auto tCDF = [&](std::optional<double> df, std::optional<double> value) {
+    return evaluateOnce<double>("t_cdf(c0, c1)", df, value);
+  };
+
+  EXPECT_EQ(0.5, tCDF(1000, 0.0));
+  EXPECT_EQ(1.0, tCDF(1000, kInf));
+  EXPECT_EQ(0.0, tCDF(1000, -kInf));
+
+  EXPECT_EQ(std::nullopt, tCDF(std::nullopt, 0.5));
+  EXPECT_EQ(std::nullopt, tCDF(1000, std::nullopt));
+
+  VELOX_ASSERT_THROW(tCDF(0, 0.5), "df must be greater than 0");
+  VELOX_ASSERT_THROW(tCDF(-1, 0.5), "df must be greater than 0");
+
+  EXPECT_NEAR(0.95, tCDF(5, 2.015).value(), 0.001);
+  EXPECT_NEAR(0.05, tCDF(5, -2.015).value(), 0.001);
+
+  EXPECT_NEAR(0.975, tCDF(10, 2.228).value(), 0.001);
+  EXPECT_NEAR(0.025, tCDF(10, -2.228).value(), 0.001);
+
+  EXPECT_NEAR(0.99, tCDF(20, 2.528).value(), 0.001);
+
+  EXPECT_NEAR(0.90, tCDF(30, 1.310).value(), 0.001);
+
+  EXPECT_NEAR(0.95, tCDF(100, 1.660).value(), 0.001);
+}
+
+TEST_F(ProbabilityTest, inverseTCDF) {
+  const auto inverseTCDF = [&](std::optional<double> df,
+                               std::optional<double> p) {
+    return evaluateOnce<double>("inverse_t_cdf(c0, c1)", df, p);
+  };
+
+  EXPECT_EQ(0.0, inverseTCDF(1000, 0.5));
+  EXPECT_EQ(-kInf, inverseTCDF(1000, 0.0));
+  EXPECT_EQ(kInf, inverseTCDF(1000, 1.0));
+
+  EXPECT_EQ(std::nullopt, inverseTCDF(std::nullopt, 0.5));
+  EXPECT_EQ(std::nullopt, inverseTCDF(1000, std::nullopt));
+
+  VELOX_ASSERT_THROW(inverseTCDF(0, 0.5), "df must be greater than 0");
+  VELOX_ASSERT_THROW(inverseTCDF(-1, 0.5), "df must be greater than 0");
+  VELOX_ASSERT_THROW(inverseTCDF(3, -0.1), "p must be in the interval [0, 1]");
+  VELOX_ASSERT_THROW(inverseTCDF(3, 1.1), "p must be in the interval [0, 1]");
+
+  EXPECT_NEAR(2.015, inverseTCDF(5, 0.95).value(), 0.001);
+  EXPECT_NEAR(-2.015, inverseTCDF(5, 0.05).value(), 0.001);
+
+  EXPECT_NEAR(2.228, inverseTCDF(10, 0.975).value(), 0.001);
+  EXPECT_NEAR(-2.228, inverseTCDF(10, 0.025).value(), 0.001);
+
+  EXPECT_NEAR(2.528, inverseTCDF(20, 0.99).value(), 0.001);
+
+  EXPECT_NEAR(1.310, inverseTCDF(30, 0.90).value(), 0.001);
+
+  EXPECT_NEAR(1.660, inverseTCDF(100, 0.95).value(), 0.001);
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/tests/RegexpReplaceTest.cpp b/velox/functions/prestosql/tests/RegexpReplaceTest.cpp
index 008bb16e730..4eb2e234aba 100644
--- a/velox/functions/prestosql/tests/RegexpReplaceTest.cpp
+++ b/velox/functions/prestosql/tests/RegexpReplaceTest.cpp
@@ -157,7 +157,7 @@ TEST_F(RegexpReplaceTest, lambda) {
       (evaluate(
           "regexp_replace(c0, '\\w(\\w*)', x -> (concat(upper(x[1]), lower(x[2]))))",
           input)),
-      "Array subscript out of bounds");
+      "Array subscript index out of bounds, Index: 2 Array size: 1");
 
   result = evaluate(
       "regexp_replace(c0, '\\w(\\w*)', x -> try(concat(upper(x[1]), lower(x[2]))))",
@@ -211,7 +211,7 @@ TEST_F(RegexpReplaceTest, lambda) {
       (evaluate(
           "regexp_replace(c0, '(\\w)(\\w*)', x -> if (x[1] = 's', x[10], concat(upper(x[1]), lower(x[2]))))",
           input)),
-      "Array subscript out of bounds");
+      "Array subscript index out of bounds, Index: 10 Array size: 2");
 
   result = evaluate(
       "regexp_replace(c0, '(\\w)(\\w*)', x -> try(if (x[1] = 's', x[10], concat(upper(x[1]), lower(x[2])))))",
diff --git a/velox/functions/prestosql/tests/RemapKeysTest.cpp b/velox/functions/prestosql/tests/RemapKeysTest.cpp
new file mode 100644
index 00000000000..75f4a9a748b
--- /dev/null
+++ b/velox/functions/prestosql/tests/RemapKeysTest.cpp
@@ -0,0 +1,957 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <random>
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class RemapKeysTest : public test::FunctionBaseTest {
+ protected:
+  void testRemapKeys(
+      const std::string& expression,
+      const std::vector<VectorPtr>& input,
+      const VectorPtr& expected) {
+    auto result = evaluate(expression, makeRowVector(input));
+    assertEqualVectors(expected, result);
+  }
+
+  // Helper to build transform_keys CASE expression equivalent to remap_keys
+  // for integer keys. Returns a transform_keys expression that maps each
+  // oldKey to its corresponding newKey.
+  // Note: Integer literals are cast to INTEGER to match the key type (int32_t).
+  template <typename T>
+  std::string buildTransformKeysCaseExpression(
+      const std::vector<T>& oldKeys,
+      const std::vector<T>& newKeys) {
+    if (oldKeys.empty() || newKeys.empty()) {
+      return "transform_keys(c0, (k, v) -> k)";
+    }
+
+    size_t mappingSize = std::min(oldKeys.size(), newKeys.size());
+    std::stringstream ss;
+    ss << "transform_keys(c0, (k, v) -> CASE ";
+    for (size_t i = 0; i < mappingSize; ++i) {
+      ss << "WHEN k = CAST(" << oldKeys[i] << " AS INTEGER) THEN CAST("
+         << newKeys[i] << " AS INTEGER) ";
+    }
+    ss << "ELSE k END)";
+    return ss.str();
+  }
+
+  // Specialization for string keys
+  std::string buildTransformKeysCaseExpressionString(
+      const std::vector<std::string>& oldKeys,
+      const std::vector<std::string>& newKeys) {
+    if (oldKeys.empty() || newKeys.empty()) {
+      return "transform_keys(c0, (k, v) -> k)";
+    }
+
+    size_t mappingSize = std::min(oldKeys.size(), newKeys.size());
+    std::stringstream ss;
+    ss << "transform_keys(c0, (k, v) -> CASE ";
+    for (size_t i = 0; i < mappingSize; ++i) {
+      ss << "WHEN k = '" << oldKeys[i] << "' THEN '" << newKeys[i] << "' ";
+    }
+    ss << "ELSE k END)";
+    return ss.str();
+  }
+
+  // Generates random integer keys within a specified range
+  template <typename T>
+  std::vector<T> generateRandomIntegerKeys(
+      std::mt19937& rng,
+      size_t count,
+      T minVal,
+      T maxVal) {
+    std::uniform_int_distribution<T> dist(minVal, maxVal);
+    std::vector<T> keys;
+    keys.reserve(count);
+    for (size_t i = 0; i < count; ++i) {
+      keys.push_back(dist(rng));
+    }
+    return keys;
+  }
+
+  // Generates random string keys
+  std::vector<std::string> generateRandomStringKeys(
+      std::mt19937& rng,
+      size_t count) {
+    static const std::string chars =
+        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    std::uniform_int_distribution<size_t> lenDist(1, 10);
+    std::uniform_int_distribution<size_t> charDist(0, chars.size() - 1);
+
+    std::vector<std::string> keys;
+    keys.reserve(count);
+    for (size_t i = 0; i < count; ++i) {
+      size_t len = lenDist(rng);
+      std::string key;
+      key.reserve(len);
+      for (size_t j = 0; j < len; ++j) {
+        key += chars[charDist(rng)];
+      }
+      keys.push_back(key);
+    }
+    return keys;
+  }
+
+  // Helper to check if applying the key mapping would create duplicate keys
+  template <typename K>
+  bool wouldCreateDuplicateKeys(
+      const std::vector<K>& mapKeys,
+      const std::vector<K>& oldKeys,
+      const std::vector<K>& newKeys) {
+    size_t mappingSize = std::min(oldKeys.size(), newKeys.size());
+    std::unordered_set<K> resultKeys;
+
+    for (const auto& key : mapKeys) {
+      K resultKey = key;
+      for (size_t i = 0; i < mappingSize; ++i) {
+        if (key == oldKeys[i]) {
+          resultKey = newKeys[i];
+          break;
+        }
+      }
+      if (resultKeys.count(resultKey) > 0) {
+        return true;
+      }
+      resultKeys.insert(resultKey);
+    }
+    return false;
+  }
+
+  // Helper to wrap map data for makeMapVector (expects vector<vector<pair>>)
+  template <typename K, typename V>
+  std::vector<std::vector<std::pair<K, std::optional<V>>>> wrapMapData(
+      const std::vector<std::pair<K, std::optional<V>>>& data) {
+    return std::vector<std::vector<std::pair<K, std::optional<V>>>>{data};
+  }
+
+  // Helper to wrap array data for makeArrayVector (expects vector<vector<T>>)
+  template <typename T>
+  std::vector<std::vector<T>> wrapArrayData(const std::vector<T>& data) {
+    return std::vector<std::vector<T>>{data};
+  }
+};
+
+TEST_F(RemapKeysTest, basicIntegerKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+      {{4, 40}, {5, 50}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {1, 2},
+      {4},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {100, 200},
+      {400},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{100, 10}, {200, 20}, {3, 30}},
+      {{400, 40}, {5, 50}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, stringKeys) {
+  auto inputMap = makeMapVector<StringView, int32_t>({
+      {{"a", 1}, {"b", 2}, {"c", 3}},
+      {{"x", 10}, {"y", 20}},
+  });
+
+  auto oldKeys = makeArrayVector<StringView>({
+      {"a", "c"},
+      {"x"},
+  });
+
+  auto newKeys = makeArrayVector<StringView>({
+      {"alpha", "charlie"},
+      {"xray"},
+  });
+
+  auto expected = makeMapVector<StringView, int32_t>({
+      {{"alpha", 1}, {"b", 2}, {"charlie", 3}},
+      {{"xray", 10}, {"y", 20}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, emptyMap) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {1, 2},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {10, 20},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, emptyOldKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, noMatchingKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {4, 5, 6},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {40, 50, 60},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, mismatchedArrayLengths) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+      {{4, 40}, {5, 50}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {1, 2, 3},
+      {4, 5},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {100, 200},
+      {400, 500, 600},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{100, 10}, {200, 20}, {3, 30}},
+      {{400, 40}, {500, 50}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, nullValuesInMap) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, std::nullopt}, {3, 30}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {1, 2},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {100, 200},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{100, 10}, {200, std::nullopt}, {3, 30}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, nullKeysInArrays) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  auto oldKeys = makeNullableArrayVector<int32_t>({
+      {1, std::nullopt, 3},
+  });
+
+  auto newKeys = makeNullableArrayVector<int32_t>({
+      {100, std::nullopt, 300},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{100, 10}, {2, 20}, {300, 30}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, duplicateOldKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {1, 1, 2},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {100, 101, 200},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{101, 10}, {200, 20}, {3, 30}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, floatKeys) {
+  auto inputMap = makeMapVector<float, int32_t>({
+      {{1.5f, 10}, {2.5f, 20}, {3.5f, 30}},
+  });
+
+  auto oldKeys = makeArrayVector<float>({
+      {1.5f, 3.5f},
+  });
+
+  auto newKeys = makeArrayVector<float>({
+      {10.5f, 30.5f},
+  });
+
+  auto expected = makeMapVector<float, int32_t>({
+      {{10.5f, 10}, {2.5f, 20}, {30.5f, 30}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, booleanKeys) {
+  auto inputMap = makeMapVector<bool, int32_t>({
+      {{true, 10}, {false, 20}},
+  });
+
+  auto oldKeys = makeArrayVector<bool>({
+      {true},
+  });
+
+  auto newKeys = makeArrayVector<bool>({
+      {false},
+  });
+
+  auto expected = makeMapVector<bool, int32_t>({
+      {{false, 10}, {false, 20}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, complexValues) {
+  // Test with map of integer keys to array values
+  auto keys = makeFlatVector<int32_t>({0, 1, 2});
+  auto innerArrays = makeArrayVector<int32_t>({
+      {1, 2},
+      {3, 4, 5},
+      {6},
+  });
+
+  auto inputMap = makeMapVector({0}, keys, innerArrays);
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {0, 1},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {10, 11},
+  });
+
+  auto expectedKeys = makeFlatVector<int32_t>({10, 11, 2});
+  auto expectedInnerArrays = makeArrayVector<int32_t>({
+      {1, 2},
+      {3, 4, 5},
+      {6},
+  });
+
+  auto expected = makeMapVector({0}, expectedKeys, expectedInnerArrays);
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, allKeysRemapped) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {1, 2, 3},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {100, 200, 300},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{100, 10}, {200, 20}, {300, 30}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, partialRemapping) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}, {4, 40}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {2, 4},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {200, 400},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {200, 20}, {3, 30}, {400, 40}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, largeMap) {
+  // Create a map with 10 entries for testing
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{0, 0},
+       {1, 10},
+       {2, 20},
+       {3, 30},
+       {4, 40},
+       {5, 50},
+       {6, 60},
+       {7, 70},
+       {8, 80},
+       {9, 90}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {0, 5, 9},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {1000, 5000, 9000},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{1000, 0},
+       {1, 10},
+       {2, 20},
+       {3, 30},
+       {4, 40},
+       {5000, 50},
+       {6, 60},
+       {7, 70},
+       {8, 80},
+       {9000, 90}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, timestampKeys) {
+  auto inputMap = makeMapVector<Timestamp, int32_t>({
+      {{Timestamp(1, 0), 10}, {Timestamp(2, 0), 20}},
+  });
+
+  auto oldKeys = makeArrayVector<Timestamp>({
+      {Timestamp(1, 0)},
+  });
+
+  auto newKeys = makeArrayVector<Timestamp>({
+      {Timestamp(100, 0)},
+  });
+
+  auto expected = makeMapVector<Timestamp, int32_t>({
+      {{Timestamp(100, 0), 10}, {Timestamp(2, 0), 20}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, oldKeysLongerThanNewKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {1, 2, 3, 4, 5},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {100, 200},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{100, 10}, {200, 20}, {3, 30}, {4, 40}, {5, 50}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, newKeysLongerThanOldKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {1, 2},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {100, 200, 300, 400, 500},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{100, 10}, {200, 20}, {3, 30}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, significantSizeDifference) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}, {6, 60}, {7, 70}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {100},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{100, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}, {6, 60}, {7, 70}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, stringKeysWithDifferentSizes) {
+  auto inputMap = makeMapVector<StringView, int32_t>({
+      {{"apple", 1}, {"banana", 2}, {"cherry", 3}, {"date", 4}},
+  });
+
+  auto oldKeys = makeArrayVector<StringView>({
+      {"apple", "banana", "cherry", "date", "elderberry", "fig"},
+  });
+
+  auto newKeys = makeArrayVector<StringView>({
+      {"APPLE", "BANANA"},
+  });
+
+  auto expected = makeMapVector<StringView, int32_t>({
+      {{"APPLE", 1}, {"BANANA", 2}, {"cherry", 3}, {"date", 4}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+// ============================================================================
+// CUSTOM FUZZER TESTS
+// These tests compare remap_keys() against the equivalent transform_keys()
+// with CASE expression to ensure behavioral consistency.
+// ============================================================================
+
+// Simplified fuzzer test that uses the lambda-based makeMapVector API
+TEST_F(RemapKeysTest, fuzzerIntegerKeysSimplified) {
+  constexpr int kIterations = 1000;
+
+  std::mt19937 rng(42);
+  std::uniform_int_distribution<int32_t> keyDist(-100, 100);
+  std::uniform_int_distribution<int32_t> valueDist(-1000, 1000);
+  std::uniform_int_distribution<int> sizeDist(1, 10);
+
+  for (int iter = 0; iter < kIterations; ++iter) {
+    int mapSize = sizeDist(rng);
+
+    // Generate unique keys for the map
+    std::vector<int32_t> keys;
+    std::unordered_set<int32_t> usedKeys;
+    while (static_cast<int>(keys.size()) < mapSize) {
+      int32_t key = keyDist(rng);
+      if (usedKeys.find(key) == usedKeys.end()) {
+        usedKeys.insert(key);
+        keys.push_back(key);
+      }
+    }
+
+    std::vector<int32_t> values;
+    for (int i = 0; i < mapSize; ++i) {
+      values.push_back(valueDist(rng));
+    }
+
+    // Generate oldKeys/newKeys for mapping
+    int mappingSize = std::min(3, mapSize);
+    std::vector<int32_t> oldKeysVec, newKeysVec;
+    std::unordered_set<int32_t> mappedTo;
+
+    for (int i = 0; i < mappingSize; ++i) {
+      oldKeysVec.push_back(keys[i]);
+      int32_t newKey = keyDist(rng);
+      // Ensure new key doesn't create duplicates
+      while (usedKeys.count(newKey) > 0 && newKey != keys[i]) {
+        newKey = keyDist(rng);
+      }
+      newKeysVec.push_back(newKey);
+      if (newKey != keys[i]) {
+        usedKeys.insert(newKey);
+      }
+    }
+
+    // Create vectors using lambda-based API
+    auto inputMap = makeMapVector<int32_t, int32_t>(
+        1, // single row
+        [&](vector_size_t) { return static_cast<vector_size_t>(mapSize); },
+        [&](vector_size_t idx) { return keys[idx]; },
+        [&](vector_size_t idx) { return values[idx]; });
+
+    auto oldKeys = makeArrayVector<int32_t>(
+        1,
+        [&](vector_size_t) { return static_cast<vector_size_t>(mappingSize); },
+        [&](vector_size_t idx) { return oldKeysVec[idx]; });
+
+    auto newKeys = makeArrayVector<int32_t>(
+        1,
+        [&](vector_size_t) { return static_cast<vector_size_t>(mappingSize); },
+        [&](vector_size_t idx) { return newKeysVec[idx]; });
+
+    // Build equivalent transform_keys expression
+    std::string transformExpr =
+        buildTransformKeysCaseExpression(oldKeysVec, newKeysVec);
+
+    // Evaluate both expressions
+    auto remapResult = evaluate(
+        "remap_keys(c0, c1, c2)", makeRowVector({inputMap, oldKeys, newKeys}));
+    auto transformResult = evaluate(transformExpr, makeRowVector({inputMap}));
+
+    // Compare results
+    assertEqualVectors(transformResult, remapResult);
+  }
+}
+
+// Fuzzer test for string keys using lambda API
+TEST_F(RemapKeysTest, fuzzerStringKeysSimplified) {
+  constexpr int kIterations = 500;
+
+  std::mt19937 rng(123);
+  std::uniform_int_distribution<int32_t> valueDist(-1000, 1000);
+  std::uniform_int_distribution<int> sizeDist(1, 8);
+
+  for (int iter = 0; iter < kIterations; ++iter) {
+    int mapSize = sizeDist(rng);
+
+    // Generate unique string keys
+    std::vector<std::string> keys = generateRandomStringKeys(rng, mapSize * 2);
+    keys.resize(mapSize);
+    std::vector<int32_t> values;
+    for (int i = 0; i < mapSize; ++i) {
+      values.push_back(valueDist(rng));
+    }
+
+    // Generate mapping
+    int mappingSize = std::min(2, mapSize);
+    std::vector<std::string> oldKeysVec, newKeysVec;
+
+    for (int i = 0; i < mappingSize; ++i) {
+      oldKeysVec.push_back(keys[i]);
+      auto newKeyVec = generateRandomStringKeys(rng, 1);
+      newKeysVec.push_back(newKeyVec[0]);
+    }
+
+    // Create vectors using lambda-based API
+    auto inputMap = makeMapVector<StringView, int32_t>(
+        1,
+        [&](vector_size_t) { return static_cast<vector_size_t>(mapSize); },
+        [&](vector_size_t idx) { return StringView(keys[idx]); },
+        [&](vector_size_t idx) { return values[idx]; });
+
+    auto oldKeys = makeArrayVector<StringView>(
+        1,
+        [&](vector_size_t) { return static_cast<vector_size_t>(mappingSize); },
+        [&](vector_size_t idx) { return StringView(oldKeysVec[idx]); });
+
+    auto newKeys = makeArrayVector<StringView>(
+        1,
+        [&](vector_size_t) { return static_cast<vector_size_t>(mappingSize); },
+        [&](vector_size_t idx) { return StringView(newKeysVec[idx]); });
+
+    // Build equivalent transform_keys expression
+    std::string transformExpr =
+        buildTransformKeysCaseExpressionString(oldKeysVec, newKeysVec);
+
+    // Evaluate both expressions
+    try {
+      auto remapResult = evaluate(
+          "remap_keys(c0, c1, c2)",
+          makeRowVector({inputMap, oldKeys, newKeys}));
+      auto transformResult = evaluate(transformExpr, makeRowVector({inputMap}));
+      assertEqualVectors(transformResult, remapResult);
+    } catch (const VeloxUserError&) {
+      // Duplicate key errors are expected when mapping creates duplicates
+    }
+  }
+}
+
+// Edge case fuzzer test using lambda-based API
+TEST_F(RemapKeysTest, fuzzerEdgeCasesSimplified) {
+  // Test 1: Empty map with non-empty mapping
+  {
+    // Empty map
+    auto inputMap = makeMapVector<int32_t, int32_t>(
+        1,
+        [](vector_size_t) { return 0; }, // empty map
+        [](vector_size_t) { return 0; },
+        [](vector_size_t) { return 0; });
+
+    // oldKeys = [1, 2], newKeys = [10, 20]
+    std::vector<int32_t> oldKeysData = {1, 2};
+    std::vector<int32_t> newKeysData = {10, 20};
+    auto oldKeys = makeArrayVector<int32_t>(
+        1,
+        [](vector_size_t) { return 2; },
+        [&](vector_size_t idx) { return oldKeysData[idx]; });
+    auto newKeys = makeArrayVector<int32_t>(
+        1,
+        [](vector_size_t) { return 2; },
+        [&](vector_size_t idx) { return newKeysData[idx]; });
+
+    auto remapResult = evaluate(
+        "remap_keys(c0, c1, c2)", makeRowVector({inputMap, oldKeys, newKeys}));
+    auto transformResult =
+        evaluate("transform_keys(c0, (k, v) -> k)", makeRowVector({inputMap}));
+    assertEqualVectors(transformResult, remapResult);
+  }
+
+  // Test 2: Non-empty map with empty mapping
+  {
+    // inputMap = {1: 10, 2: 20}
+    std::vector<int32_t> mapKeys = {1, 2};
+    std::vector<int32_t> mapVals = {10, 20};
+    auto inputMap = makeMapVector<int32_t, int32_t>(
+        1,
+        [](vector_size_t) { return 2; },
+        [&](vector_size_t idx) { return mapKeys[idx]; },
+        [&](vector_size_t idx) { return mapVals[idx]; });
+
+    // Empty arrays
+    auto oldKeys = makeArrayVector<int32_t>(
+        1, [](vector_size_t) { return 0; }, [](vector_size_t) { return 0; });
+    auto newKeys = makeArrayVector<int32_t>(
+        1, [](vector_size_t) { return 0; }, [](vector_size_t) { return 0; });
+
+    auto remapResult = evaluate(
+        "remap_keys(c0, c1, c2)", makeRowVector({inputMap, oldKeys, newKeys}));
+    auto transformResult =
+        evaluate("transform_keys(c0, (k, v) -> k)", makeRowVector({inputMap}));
+    assertEqualVectors(transformResult, remapResult);
+  }
+
+  // Test 3: All keys remapped
+  {
+    // inputMap = {1: 10, 2: 20}
+    std::vector<int32_t> mapKeys = {1, 2};
+    std::vector<int32_t> mapVals = {10, 20};
+    auto inputMap = makeMapVector<int32_t, int32_t>(
+        1,
+        [](vector_size_t) { return 2; },
+        [&](vector_size_t idx) { return mapKeys[idx]; },
+        [&](vector_size_t idx) { return mapVals[idx]; });
+
+    // oldKeys = [1, 2], newKeys = [100, 200]
+    std::vector<int32_t> oldKeysData = {1, 2};
+    std::vector<int32_t> newKeysData = {100, 200};
+    auto oldKeys = makeArrayVector<int32_t>(
+        1,
+        [](vector_size_t) { return 2; },
+        [&](vector_size_t idx) { return oldKeysData[idx]; });
+    auto newKeys = makeArrayVector<int32_t>(
+        1,
+        [](vector_size_t) { return 2; },
+        [&](vector_size_t idx) { return newKeysData[idx]; });
+
+    auto remapResult = evaluate(
+        "remap_keys(c0, c1, c2)", makeRowVector({inputMap, oldKeys, newKeys}));
+    auto transformResult = evaluate(
+        "transform_keys(c0, (k, v) -> CASE WHEN k = CAST(1 AS INTEGER) THEN CAST(100 AS INTEGER) WHEN k = CAST(2 AS INTEGER) THEN CAST(200 AS INTEGER) ELSE k END)",
+        makeRowVector({inputMap}));
+    assertEqualVectors(transformResult, remapResult);
+  }
+
+  // Test 4: Partial remapping
+  {
+    // inputMap = {1: 10, 2: 20, 3: 30}
+    std::vector<int32_t> mapKeys = {1, 2, 3};
+    std::vector<int32_t> mapVals = {10, 20, 30};
+    auto inputMap = makeMapVector<int32_t, int32_t>(
+        1,
+        [](vector_size_t) { return 3; },
+        [&](vector_size_t idx) { return mapKeys[idx]; },
+        [&](vector_size_t idx) { return mapVals[idx]; });
+
+    // oldKeys = [1], newKeys = [100]
+    std::vector<int32_t> oldKeysData = {1};
+    std::vector<int32_t> newKeysData = {100};
+    auto oldKeys = makeArrayVector<int32_t>(
+        1,
+        [](vector_size_t) { return 1; },
+        [&](vector_size_t idx) { return oldKeysData[idx]; });
+    auto newKeys = makeArrayVector<int32_t>(
+        1,
+        [](vector_size_t) { return 1; },
+        [&](vector_size_t idx) { return newKeysData[idx]; });
+
+    auto remapResult = evaluate(
+        "remap_keys(c0, c1, c2)", makeRowVector({inputMap, oldKeys, newKeys}));
+    auto transformResult = evaluate(
+        "transform_keys(c0, (k, v) -> CASE WHEN k = CAST(1 AS INTEGER) THEN CAST(100 AS INTEGER) ELSE k END)",
+        makeRowVector({inputMap}));
+    assertEqualVectors(transformResult, remapResult);
+  }
+
+  // Test 5: Mismatched array lengths (uses min)
+  {
+    // inputMap = {1: 10, 2: 20}
+    std::vector<int32_t> mapKeys = {1, 2};
+    std::vector<int32_t> mapVals = {10, 20};
+    auto inputMap = makeMapVector<int32_t, int32_t>(
+        1,
+        [](vector_size_t) { return 2; },
+        [&](vector_size_t idx) { return mapKeys[idx]; },
+        [&](vector_size_t idx) { return mapVals[idx]; });
+
+    // oldKeys = [1, 2, 3, 4, 5], newKeys = [100, 200]
+    std::vector<int32_t> oldKeysData = {1, 2, 3, 4, 5};
+    std::vector<int32_t> newKeysData = {100, 200};
+    auto oldKeys = makeArrayVector<int32_t>(
+        1,
+        [](vector_size_t) { return 5; },
+        [&](vector_size_t idx) { return oldKeysData[idx]; });
+    auto newKeys = makeArrayVector<int32_t>(
+        1,
+        [](vector_size_t) { return 2; },
+        [&](vector_size_t idx) { return newKeysData[idx]; });
+
+    auto remapResult = evaluate(
+        "remap_keys(c0, c1, c2)", makeRowVector({inputMap, oldKeys, newKeys}));
+    auto transformResult = evaluate(
+        "transform_keys(c0, (k, v) -> CASE WHEN k = CAST(1 AS INTEGER) THEN CAST(100 AS INTEGER) WHEN k = CAST(2 AS INTEGER) THEN CAST(200 AS INTEGER) ELSE k END)",
+        makeRowVector({inputMap}));
+    assertEqualVectors(transformResult, remapResult);
+  }
+}
+
+// Fuzzer test using VectorFuzzer for stress testing
+TEST_F(RemapKeysTest, fuzzerWithVectorFuzzerSimplified) {
+  constexpr int kIterations = 500;
+  constexpr vector_size_t kBatchSize = 10;
+
+  VectorFuzzer::Options options;
+  options.vectorSize = kBatchSize;
+  options.nullRatio = 0.0;
+  options.containerLength = 5;
+  options.containerVariableLength = true;
+
+  VectorFuzzer fuzzer(options, pool());
+
+  for (int iter = 0; iter < kIterations; ++iter) {
+    auto mapType = MAP(INTEGER(), INTEGER());
+    auto inputMap = fuzzer.fuzzFlat(mapType);
+
+    // Use fixed mapping that won't cause duplicates
+    auto oldKeys = makeArrayVector<int32_t>(
+        kBatchSize,
+        [](vector_size_t) { return 2; },
+        [](vector_size_t row, vector_size_t idx) {
+          return static_cast<int32_t>(row * 1000 + idx);
+        });
+
+    auto newKeys = makeArrayVector<int32_t>(
+        kBatchSize,
+        [](vector_size_t) { return 2; },
+        [](vector_size_t row, vector_size_t idx) {
+          return static_cast<int32_t>(row * 1000 + idx + 10000);
+        });
+
+    // Verify remap_keys doesn't crash
+    try {
+      auto result = evaluate(
+          "remap_keys(c0, c1, c2)",
+          makeRowVector({inputMap, oldKeys, newKeys}));
+      ASSERT_NE(result, nullptr);
+    } catch (const VeloxUserError&) {
+      // Expected: duplicate keys, null keys
+    }
+  }
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/S2FunctionsTest.cpp b/velox/functions/prestosql/tests/S2FunctionsTest.cpp
new file mode 100644
index 00000000000..0d76786ce8c
--- /dev/null
+++ b/velox/functions/prestosql/tests/S2FunctionsTest.cpp
@@ -0,0 +1,295 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+
+namespace facebook::velox::functions {
+namespace {
+
+// A level-0 face cell covering approximately 1/6 of Earth's surface.
+constexpr int64_t kLevel0CellId{
+    static_cast<int64_t>(5'764'607'523'034'234'880ULL)};
+
+// A level-14 cell. kLevel20CellId is a level-20 descendant of this cell, so
+// s2_cell_parent(kLevel20CellId, 14) == kLevel14CellId.
+constexpr int64_t kLevel14CellId{
+    static_cast<int64_t>(9'260'949'543'246'102'528ULL)};
+
+// A level-20 descendant of kLevel14CellId.
+constexpr int64_t kLevel20CellId{
+    static_cast<int64_t>(9'260'949'539'409'362'944ULL)};
+
+// Hex tokens corresponding to the cell IDs above.
+constexpr std::string_view kLevel14Token{"8085808b"};
+constexpr std::string_view kLevel20Token{"8085808a1b5"};
+
+class S2FunctionsTest : public test::FunctionBaseTest {
+ protected:
+  // Evaluates s2_cells at a fixed level and returns the cell IDs.
+  std::vector<int64_t> cells(const std::string& wkt, int32_t level) {
+    return evaluate(
+               "s2_cells(ST_GeometryFromText(c0), c1)",
+               makeRowVector({
+                   makeFlatVector({wkt}),
+                   makeFlatVector<int32_t>({level}),
+               }))
+        ->variantAt(0)
+        .array<int64_t>();
+  }
+
+  // Evaluates dissolved s2_cells and returns the cell IDs.
+  std::vector<int64_t> cells(
+      const std::string& wkt,
+      int32_t minLevel,
+      int32_t maxLevel,
+      int32_t maxCells) {
+    return evaluate(
+               "s2_cells(ST_GeometryFromText(c0), c1, c2, c3)",
+               makeRowVector({
+                   makeFlatVector({wkt}),
+                   makeFlatVector<int32_t>({minLevel}),
+                   makeFlatVector<int32_t>({maxLevel}),
+                   makeFlatVector<int32_t>({maxCells}),
+               }))
+        ->variantAt(0)
+        .array<int64_t>();
+  }
+
+  // Returns the number of cells for convenience assertions.
+  size_t countCells(const std::string& wkt, int32_t level) {
+    return cells(wkt, level).size();
+  }
+
+  size_t countCells(
+      const std::string& wkt,
+      int32_t minLevel,
+      int32_t maxLevel,
+      int32_t maxCells) {
+    return cells(wkt, minLevel, maxLevel, maxCells).size();
+  }
+};
+
+TEST_F(S2FunctionsTest, parent) {
+  auto test = [&](int64_t cellId, int32_t level, int64_t expected) {
+    auto result = evaluateOnce<int64_t>(
+        "s2_cell_parent(c0, c1)", std::optional(cellId), std::optional(level));
+    ASSERT_TRUE(result.has_value());
+    EXPECT_EQ(expected, result.value());
+  };
+
+  test(kLevel20CellId, 14, kLevel14CellId);
+
+  // Same level returns same cell ID.
+  test(kLevel14CellId, 14, kLevel14CellId);
+
+  // Higher level returns same cell ID.
+  test(kLevel14CellId, 15, kLevel14CellId);
+
+  // Invalid level.
+  auto testThrows = [&](int32_t level, std::string_view message) {
+    VELOX_ASSERT_USER_THROW(
+        evaluateOnce<int64_t>(
+            "s2_cell_parent(c0, c1)",
+            std::optional(kLevel14CellId),
+            std::optional(level)),
+        message);
+  };
+  testThrows(-1, "s2_cell_parent: Level must be in [0, 30] range, got -1");
+  testThrows(31, "s2_cell_parent: Level must be in [0, 30] range, got 31");
+}
+
+TEST_F(S2FunctionsTest, areaSqKm) {
+  auto test = [&](int64_t cellId, double expected, double tolerance) {
+    auto result =
+        evaluateOnce<double>("s2_cell_area_sq_km(c0)", std::optional(cellId));
+    ASSERT_TRUE(result.has_value());
+    EXPECT_NEAR(expected, result.value(), tolerance);
+  };
+
+  // Level 0 cell (1/6 of Earth's surface).
+  test(kLevel0CellId, 85011012.18633142, 0.000001);
+
+  // Level 14 cell.
+  test(kLevel14CellId, 0.263649755299609, 0.000001);
+}
+
+TEST_F(S2FunctionsTest, fromToken) {
+  auto test = [&](std::string_view token, int64_t expected) {
+    auto result = evaluateOnce<int64_t>(
+        "s2_cell_from_token(c0)", std::optional(std::string(token)));
+    ASSERT_TRUE(result.has_value());
+    EXPECT_EQ(expected, result.value());
+  };
+
+  test(kLevel20Token, kLevel20CellId);
+  test(kLevel14Token, kLevel14CellId);
+
+  auto testThrows = [&](std::string_view token, std::string_view message) {
+    VELOX_ASSERT_USER_THROW(
+        evaluateOnce<int64_t>(
+            "s2_cell_from_token(c0)", std::optional(std::string(token))),
+        message);
+  };
+
+  // Invalid token.
+  testThrows("invalid", "s2_cell_from_token: Invalid cell token: invalid");
+
+  // Empty token.
+  testThrows("", "s2_cell_from_token: Empty cell token");
+}
+
+TEST_F(S2FunctionsTest, contains) {
+  // Level 14 cell contains its level 20 descendant.
+  auto contains = evaluateOnce<bool>(
+      "s2_cell_contains(c0, c1)",
+      std::optional(kLevel14CellId),
+      std::optional(kLevel20CellId));
+  ASSERT_TRUE(contains.has_value());
+  EXPECT_TRUE(contains.value());
+
+  // Reverse is false.
+  auto notContains = evaluateOnce<bool>(
+      "s2_cell_contains(c0, c1)",
+      std::optional(kLevel20CellId),
+      std::optional(kLevel14CellId));
+  ASSERT_TRUE(notContains.has_value());
+  EXPECT_FALSE(notContains.value());
+
+  // A cell contains itself.
+  auto containsSelf = evaluateOnce<bool>(
+      "s2_cell_contains(c0, c1)",
+      std::optional(kLevel14CellId),
+      std::optional(kLevel14CellId));
+  ASSERT_TRUE(containsSelf.has_value());
+  EXPECT_TRUE(containsSelf.value());
+
+  // Composes with s2_cell_from_token without casting.
+  auto composedResult = evaluateOnce<bool>(
+      "s2_cell_contains(s2_cell_from_token(c0), s2_cell_from_token(c1))",
+      std::optional(std::string(kLevel14Token)),
+      std::optional(std::string(kLevel20Token)));
+  ASSERT_TRUE(composedResult.has_value());
+  EXPECT_TRUE(composedResult.value());
+}
+
+TEST_F(S2FunctionsTest, level) {
+  auto level0 =
+      evaluateOnce<int32_t>("s2_cell_level(c0)", std::optional(kLevel0CellId));
+  ASSERT_TRUE(level0.has_value());
+  EXPECT_EQ(0, level0.value());
+
+  auto level14 =
+      evaluateOnce<int32_t>("s2_cell_level(c0)", std::optional(kLevel14CellId));
+  ASSERT_TRUE(level14.has_value());
+  EXPECT_EQ(14, level14.value());
+}
+
+TEST_F(S2FunctionsTest, toToken) {
+  auto test = [&](int64_t cellId, std::string_view expected) {
+    auto result = evaluateOnce<std::string>(
+        "s2_cell_to_token(c0)", std::optional(cellId));
+    ASSERT_TRUE(result.has_value());
+    EXPECT_EQ(expected, result.value());
+  };
+
+  test(kLevel20CellId, kLevel20Token);
+  test(kLevel14CellId, kLevel14Token);
+}
+
+TEST_F(S2FunctionsTest, cells) {
+  // A point produces exactly one cell.
+  EXPECT_EQ(1, countCells("POINT (0 0)", 10));
+
+  // A polygon produces multiple cells.
+  EXPECT_GT(countCells("POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))", 10), 1);
+
+  // Empty geometries produce an empty array.
+  EXPECT_EQ(0, countCells("GEOMETRYCOLLECTION EMPTY", 10));
+  EXPECT_EQ(0, countCells("POLYGON EMPTY", 10));
+
+  // Non-empty GeometryCollection produces cells for each sub-geometry.
+  EXPECT_GT(countCells("GEOMETRYCOLLECTION (POINT (0 0), POINT (1 1))", 10), 0);
+
+  // LineString produces multiple cells.
+  EXPECT_GT(countCells("LINESTRING (0 0, 1 1)", 10), 1);
+
+  // MultiPoint produces one cell per point.
+  EXPECT_EQ(3, countCells("MULTIPOINT (0 0, 10 10, 20 20)", 10));
+
+  // Round-trip: level-10 cell contains level-20 cell for same point.
+  auto level10Cells = cells("POINT (40.7128 -74.006)", 10);
+  auto level20Cells = cells("POINT (40.7128 -74.006)", 20);
+  ASSERT_EQ(1, level10Cells.size());
+  ASSERT_EQ(1, level20Cells.size());
+  auto containsResult = evaluateOnce<bool>(
+      "s2_cell_contains(c0, c1)",
+      std::optional(level10Cells[0]),
+      std::optional(level20Cells[0]));
+  ASSERT_TRUE(containsResult.has_value());
+  EXPECT_TRUE(containsResult.value());
+
+  // Level 0 and 30 edge cases.
+  for (int32_t level : {0, 30}) {
+    EXPECT_EQ(1, countCells("POINT (40.7128 -74.006)", level));
+  }
+
+  // Invalid levels.
+  for (int32_t level : {-1, 31}) {
+    VELOX_ASSERT_USER_THROW(
+        cells("POINT (0 0)", level),
+        "s2_cells: Level must be in [0, 30] range");
+  }
+}
+
+TEST_F(S2FunctionsTest, cellsDissolved) {
+  // Dissolved covering should produce fewer cells than fixed-level.
+  auto dissolvedCells =
+      cells("POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))", 4, 14, 100);
+  EXPECT_GT(dissolvedCells.size(), 0);
+  EXPECT_LE(dissolvedCells.size(), 100);
+  EXPECT_LT(
+      dissolvedCells.size(),
+      countCells("POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))", 14));
+
+  // All cells should have levels within [min_level, max_level].
+  for (auto cellId : dissolvedCells) {
+    auto cellLevel =
+        evaluateOnce<int32_t>("s2_cell_level(c0)", std::optional(cellId));
+    ASSERT_TRUE(cellLevel.has_value());
+    EXPECT_GE(cellLevel.value(), 4);
+    EXPECT_LE(cellLevel.value(), 14);
+  }
+
+  // Point produces exactly 1 cell.
+  EXPECT_EQ(1, countCells("POINT (0 0)", 0, 20, 100));
+
+  // Empty geometry produces an empty array.
+  EXPECT_EQ(0, countCells("GEOMETRYCOLLECTION EMPTY", 0, 20, 100));
+
+  // min_level > max_level.
+  VELOX_ASSERT_USER_THROW(
+      cells("POINT (0 0)", 15, 10, 100),
+      "s2_cells: min_level (15) must be <= max_level (10)");
+
+  // max_cells < 1.
+  VELOX_ASSERT_USER_THROW(
+      cells("POINT (0 0)", 0, 20, 0), "s2_cells: max_cells must be >= 1");
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/SequenceTest.cpp b/velox/functions/prestosql/tests/SequenceTest.cpp
index 7df2bc1927e..b09f13da247 100644
--- a/velox/functions/prestosql/tests/SequenceTest.cpp
+++ b/velox/functions/prestosql/tests/SequenceTest.cpp
@@ -16,7 +16,6 @@
 
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
-#include "velox/type/TimestampConversion.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::test;
@@ -525,3 +524,32 @@ TEST_F(SequenceTest, timestampIntervalExceedMaxEntries) {
       {startVector, stopVector, stepVector},
       "result of sequence function must not have more than 10000 entries");
 }
+
+// Test that total elements across all rows cannot overflow int32.
+// Even when individual sequences are within limits, the total across all rows
+// must not exceed vector_size_t max (int32_t max).
+TEST_F(SequenceTest, totalElementsExceedInt32Max) {
+  // Configure max elements per sequence to a large value so individual
+  // sequences pass validation.
+  const int32_t maxElementsPerSequence = 100'000'000;
+  execCtx_.queryCtx()->testingOverrideConfigUnsafe({
+      {core::QueryConfig::kMaxElementsSizeInRepeatAndSequence,
+       std::to_string(maxElementsPerSequence)},
+  });
+
+  // Create 30 rows, each producing 100M elements.
+  // Total: 30 * 100M = 3B elements, which exceeds int32 max (~2.1B).
+  const int32_t numRows = 30;
+  std::vector<int64_t> starts(numRows, 1);
+  std::vector<int64_t> stops(numRows, maxElementsPerSequence);
+
+  const auto startVector = makeFlatVector<int64_t>(starts);
+  const auto stopVector = makeFlatVector<int64_t>(stops);
+
+  auto data = makeRowVector({startVector, stopVector});
+  auto typedExpr = makeTypedExpr("sequence(C0, C1)", asRowType(data->type()));
+
+  exec::ExprSet exprSet({typedExpr}, &execCtx_);
+
+  VELOX_ASSERT_THROW(evaluate(exprSet, data), "SEQUENCE result too large");
+}
diff --git a/velox/functions/prestosql/tests/SetDigestCastTest.cpp b/velox/functions/prestosql/tests/SetDigestCastTest.cpp
new file mode 100644
index 00000000000..b2f3f46807b
--- /dev/null
+++ b/velox/functions/prestosql/tests/SetDigestCastTest.cpp
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/tests/CastBaseTest.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
+
+using namespace facebook::velox;
+
+class SetDigestCastTest : public functions::test::CastBaseTest {};
+
+TEST_F(SetDigestCastTest, toSetDigest) {
+  testCast<StringView, StringView>(
+      VARBINARY(),
+      SETDIGEST(),
+      {"aaa"_sv, ""_sv, std::nullopt},
+      {"aaa"_sv, ""_sv, std::nullopt});
+  testCast<StringView, StringView>(
+      VARBINARY(),
+      SETDIGEST(),
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt},
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt});
+}
+
+TEST_F(SetDigestCastTest, fromSetDigest) {
+  testCast<StringView, StringView>(
+      SETDIGEST(),
+      VARBINARY(),
+      {"aaa"_sv, ""_sv, std::nullopt},
+      {"aaa"_sv, ""_sv, std::nullopt});
+  testCast<StringView, StringView>(
+      SETDIGEST(),
+      VARBINARY(),
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt},
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt});
+}
diff --git a/velox/functions/prestosql/tests/SetDigestFunctionsTest.cpp b/velox/functions/prestosql/tests/SetDigestFunctionsTest.cpp
new file mode 100644
index 00000000000..fa94ab0d195
--- /dev/null
+++ b/velox/functions/prestosql/tests/SetDigestFunctionsTest.cpp
@@ -0,0 +1,551 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/base64.h>
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/functions/lib/SetDigest.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/functions/prestosql/types/SetDigestRegistration.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::functions::test;
+
+class SetDigestFunctionsTest : public FunctionBaseTest {
+ protected:
+  void SetUp() override {
+    FunctionBaseTest::SetUp();
+    registerSetDigestType();
+  }
+};
+
+TEST_F(SetDigestFunctionsTest, testCardinality) {
+  const auto cardinality = [&](const std::optional<std::string>& input) {
+    return evaluateOnce<int64_t>("cardinality(c0)", SETDIGEST(), input);
+  };
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  HashStringAllocator allocator(pool.get());
+  facebook::velox::functions::SetDigest<int64_t> digest(&allocator);
+
+  std::vector<int64_t> values;
+  for (int64_t i = 1; i <= 100; i++) {
+    digest.add(i);
+    values.push_back(i);
+  }
+
+  int64_t expectedCardinality = digest.cardinality();
+  ASSERT_EQ(100, expectedCardinality);
+
+  int32_t serializedSize = digest.estimatedSerializedSize();
+  std::vector<char> buffer(serializedSize);
+  digest.serialize(buffer.data());
+  std::string serializedDigest(buffer.begin(), buffer.end());
+
+  auto result = cardinality(serializedDigest);
+  ASSERT_EQ(expectedCardinality, result.value());
+
+  // Test with duplicates - should not increase cardinality
+  facebook::velox::functions::SetDigest<int64_t> digestWithDuplicates(
+      &allocator);
+  digestWithDuplicates.add(1L);
+  digestWithDuplicates.add(1L);
+  digestWithDuplicates.add(1L);
+  digestWithDuplicates.add(2L);
+  digestWithDuplicates.add(2L);
+
+  expectedCardinality = digestWithDuplicates.cardinality();
+  ASSERT_EQ(2, expectedCardinality);
+
+  serializedSize = digestWithDuplicates.estimatedSerializedSize();
+  buffer.resize(serializedSize);
+  digestWithDuplicates.serialize(buffer.data());
+  serializedDigest = std::string(buffer.begin(), buffer.end());
+
+  result = cardinality(serializedDigest);
+  ASSERT_EQ(expectedCardinality, result.value());
+}
+
+TEST_F(SetDigestFunctionsTest, testIntersectionCardinality) {
+  const auto intersectionCardinality =
+      [&](const std::optional<std::string>& input1,
+          const std::optional<std::string>& input2) {
+        return evaluateOnce<int64_t>(
+            "intersection_cardinality(c0, c1)",
+            {SETDIGEST(), SETDIGEST()},
+            input1,
+            input2);
+      };
+
+  // Create two SetDigest objects in C++ with known overlap
+  auto pool = memory::memoryManager()->addLeafPool();
+  HashStringAllocator allocator(pool.get());
+
+  facebook::velox::functions::SetDigest<int64_t> digest1(&allocator);
+  for (int64_t i = 1; i <= 10; i++) {
+    digest1.add(i);
+  }
+
+  facebook::velox::functions::SetDigest<int64_t> digest2(&allocator);
+  for (int64_t i = 5; i <= 15; i++) {
+    digest2.add(i);
+  }
+
+  int64_t expectedIntersection = facebook::velox::functions::SetDigest<
+      int64_t>::exactIntersectionCardinality(digest1, digest2);
+  ASSERT_EQ(6, expectedIntersection);
+
+  int32_t size1 = digest1.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest1.serialize(buffer1.data());
+  std::string serialized1(buffer1.begin(), buffer1.end());
+
+  int32_t size2 = digest2.estimatedSerializedSize();
+  std::vector<char> buffer2(size2);
+  digest2.serialize(buffer2.data());
+  std::string serialized2(buffer2.begin(), buffer2.end());
+
+  auto result = intersectionCardinality(serialized1, serialized2);
+  ASSERT_EQ(expectedIntersection, result.value());
+
+  // Test with no overlap
+  facebook::velox::functions::SetDigest<int64_t> digest3(&allocator);
+  for (int64_t i = 100; i <= 110; i++) {
+    digest3.add(i);
+  }
+
+  expectedIntersection = facebook::velox::functions::SetDigest<
+      int64_t>::exactIntersectionCardinality(digest1, digest3);
+  ASSERT_EQ(0, expectedIntersection);
+
+  int32_t size3 = digest3.estimatedSerializedSize();
+  std::vector<char> buffer3(size3);
+  digest3.serialize(buffer3.data());
+  std::string serialized3(buffer3.begin(), buffer3.end());
+
+  result = intersectionCardinality(serialized1, serialized3);
+  ASSERT_EQ(expectedIntersection, result.value());
+
+  // Test with full overlap (same digest)
+  expectedIntersection = facebook::velox::functions::SetDigest<
+      int64_t>::exactIntersectionCardinality(digest1, digest1);
+  result = intersectionCardinality(serialized1, serialized1);
+  ASSERT_EQ(expectedIntersection, result.value());
+
+  // Test with null inputs.
+  result = intersectionCardinality(std::nullopt, serialized1);
+  ASSERT_FALSE(result.has_value());
+
+  result = intersectionCardinality(serialized1, std::nullopt);
+  ASSERT_FALSE(result.has_value());
+
+  result = intersectionCardinality(std::nullopt, std::nullopt);
+  ASSERT_FALSE(result.has_value());
+}
+
+TEST_F(SetDigestFunctionsTest, testHashCounts) {
+  auto pool = memory::memoryManager()->addLeafPool();
+  HashStringAllocator allocator(pool.get());
+  facebook::velox::functions::SetDigest<int64_t> digest(&allocator);
+
+  digest.add(1L);
+  digest.add(1L);
+  digest.add(1L);
+  digest.add(2L);
+  digest.add(2L);
+  digest.add(3L);
+
+  auto expectedHashCounts = digest.getHashCounts();
+  ASSERT_EQ(3, expectedHashCounts.size());
+
+  int32_t size = digest.estimatedSerializedSize();
+  std::vector<char> buffer(size);
+  digest.serialize(buffer.data());
+
+  auto inputVector = BaseVector::create(SETDIGEST(), 1, execCtx_.pool());
+  auto flatVector = inputVector->as<FlatVector<StringView>>();
+  flatVector->set(0, StringView(buffer.data(), size));
+
+  auto result = evaluate("hash_counts(c0)", makeRowVector({inputVector}));
+
+  ASSERT_EQ(result->size(), 1);
+  auto mapVector = result->as<MapVector>();
+  ASSERT_NE(mapVector, nullptr);
+
+  ASSERT_EQ(mapVector->sizeAt(0), expectedHashCounts.size());
+
+  auto keys = mapVector->mapKeys()->as<SimpleVector<int64_t>>();
+  auto values = mapVector->mapValues()->as<SimpleVector<int16_t>>();
+
+  auto offset = mapVector->offsetAt(0);
+  auto mapSize = mapVector->sizeAt(0);
+
+  for (auto i = 0; i < mapSize; i++) {
+    auto key = keys->valueAt(offset + i);
+    auto value = values->valueAt(offset + i);
+
+    ASSERT_TRUE(expectedHashCounts.count(key) > 0);
+    ASSERT_EQ(expectedHashCounts.at(key), value);
+  }
+}
+
+TEST_F(SetDigestFunctionsTest, testHashCountsWithMerge) {
+  auto pool = memory::memoryManager()->addLeafPool();
+  HashStringAllocator allocator(pool.get());
+  facebook::velox::functions::SetDigest<int64_t> digest1(&allocator);
+  digest1.add(0L);
+  digest1.add(0L);
+  digest1.add(1L);
+
+  facebook::velox::functions::SetDigest<int64_t> digest2(&allocator);
+  digest2.add(0L);
+  digest2.add(0L);
+  digest2.add(2L);
+  digest2.add(2L);
+
+  int32_t size1 = digest1.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest1.serialize(buffer1.data());
+
+  auto inputVector1 = BaseVector::create(SETDIGEST(), 1, execCtx_.pool());
+  auto flatVector1 = inputVector1->as<FlatVector<StringView>>();
+  flatVector1->set(0, StringView(buffer1.data(), size1));
+
+  auto result1 = evaluate("hash_counts(c0)", makeRowVector({inputVector1}));
+  auto mapVector1 = result1->as<MapVector>();
+  ASSERT_NE(mapVector1, nullptr);
+
+  // Extract count values from digest1 (should be {1, 2})
+  auto values1 = mapVector1->mapValues()->as<SimpleVector<int16_t>>();
+  auto offset1 = mapVector1->offsetAt(0);
+  auto mapSize1 = mapVector1->sizeAt(0);
+
+  std::set<int16_t> countValues1;
+  for (auto i = 0; i < mapSize1; i++) {
+    countValues1.insert(values1->valueAt(offset1 + i));
+  }
+
+  std::set<int16_t> expected1 = {1, 2}; // hash(0)→2, hash(1)→1
+  ASSERT_EQ(countValues1, expected1);
+
+  digest1.mergeWith(digest2);
+
+  // Test hash_counts after merge
+  int32_t sizeMerged = digest1.estimatedSerializedSize();
+  std::vector<char> bufferMerged(sizeMerged);
+  digest1.serialize(bufferMerged.data());
+
+  auto inputVectorMerged = BaseVector::create(SETDIGEST(), 1, execCtx_.pool());
+  auto flatVectorMerged = inputVectorMerged->as<FlatVector<StringView>>();
+  flatVectorMerged->set(0, StringView(bufferMerged.data(), sizeMerged));
+
+  auto resultMerged =
+      evaluate("hash_counts(c0)", makeRowVector({inputVectorMerged}));
+  auto mapVectorMerged = resultMerged->as<MapVector>();
+  ASSERT_NE(mapVectorMerged, nullptr);
+
+  // Extract count values from merged digest (should be {1, 2, 4})
+  auto valuesMerged = mapVectorMerged->mapValues()->as<SimpleVector<int16_t>>();
+  auto offsetMerged = mapVectorMerged->offsetAt(0);
+  auto mapSizeMerged = mapVectorMerged->sizeAt(0);
+
+  std::set<int16_t> countValuesMerged;
+  for (auto i = 0; i < mapSizeMerged; i++) {
+    countValuesMerged.insert(valuesMerged->valueAt(offsetMerged + i));
+  }
+
+  std::set<int16_t> expectedMerged = {
+      1, 2, 4}; // hash(0)→4, hash(1)→1, hash(2)→2
+  ASSERT_EQ(countValuesMerged, expectedMerged);
+}
+
+TEST_F(SetDigestFunctionsTest, testIntersectionCardinalityApproximate) {
+  const auto intersectionCardinality =
+      [&](const std::optional<std::string>& input1,
+          const std::optional<std::string>& input2) {
+        return evaluateOnce<int64_t>(
+            "intersection_cardinality(c0, c1)",
+            {SETDIGEST(), SETDIGEST()},
+            input1,
+            input2);
+      };
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  HashStringAllocator allocator(pool.get());
+
+  // Test 1: Both digests approximate
+  // Approximate digest 1: values 0-9999 (10000 elements)
+  facebook::velox::functions::SetDigest<int64_t> approximateDigest1(&allocator);
+  for (int64_t i = 0; i < 10000; i++) {
+    approximateDigest1.add(i);
+  }
+  ASSERT_FALSE(approximateDigest1.isExact());
+
+  // Approximate digest 2: values 5000-14999 (10000 elements)
+  // Intersection: 5000-9999 (5000 elements)
+  // Union: 0-14999 (15000 elements)
+  // Expected Jaccard: 5000/15000 = 0.333
+  facebook::velox::functions::SetDigest<int64_t> approximateDigest2(&allocator);
+  for (int64_t i = 5000; i < 15000; i++) {
+    approximateDigest2.add(i);
+  }
+  ASSERT_FALSE(approximateDigest2.isExact());
+
+  int32_t approx1Size = approximateDigest1.estimatedSerializedSize();
+  std::vector<char> approx1Buffer(approx1Size);
+  approximateDigest1.serialize(approx1Buffer.data());
+  std::string serializedApprox1(approx1Buffer.begin(), approx1Buffer.end());
+
+  int32_t approx2Size = approximateDigest2.estimatedSerializedSize();
+  std::vector<char> approx2Buffer(approx2Size);
+  approximateDigest2.serialize(approx2Buffer.data());
+  std::string serializedApprox2(approx2Buffer.begin(), approx2Buffer.end());
+
+  // Test approximate mode with both digests being approximate
+  // approximateDigest1: 0-9999, approximateDigest2: 5000-14999
+  // Expected intersection: 5000 values (5000-9999)
+  auto result = intersectionCardinality(serializedApprox1, serializedApprox2);
+  ASSERT_TRUE(result.has_value());
+  // Allow reasonable margin of error for HyperLogLog and MinHash estimation
+  EXPECT_GE(result.value(), 3500);
+  EXPECT_LE(result.value(), 6500);
+
+  // Test approximate mode with same digest (self-intersection)
+  // Should return cardinality of the digest
+  result = intersectionCardinality(serializedApprox1, serializedApprox1);
+  ASSERT_TRUE(result.has_value());
+  int64_t cardinality = approximateDigest1.cardinality();
+  EXPECT_EQ(result.value(), cardinality);
+
+  // Test 2: Mixed mode - Exact digest (1000 elements) with Approximate digest
+  // This tests that MinHash can detect overlap when exact set is reasonably
+  // sized. Exact digest: values 0-999 (1000 elements, stays exact since < 8192)
+  facebook::velox::functions::SetDigest<int64_t> exactDigest(&allocator);
+  for (int64_t i = 0; i < 1000; i++) {
+    exactDigest.add(i);
+  }
+  ASSERT_TRUE(exactDigest.isExact());
+
+  // Approximate digest 3: values 0-9999 (10000 elements)
+  // Contains all elements from exactDigest
+  // Intersection: 0-999 (1000 elements)
+  // Union: 0-9999 (10000 elements)
+  // Expected Jaccard: 1000/10000 = 0.1
+  facebook::velox::functions::SetDigest<int64_t> approximateDigest3(&allocator);
+  for (int64_t i = 0; i < 10000; i++) {
+    approximateDigest3.add(i);
+  }
+  ASSERT_FALSE(approximateDigest3.isExact());
+
+  int32_t exactSize = exactDigest.estimatedSerializedSize();
+  std::vector<char> exactBuffer(exactSize);
+  exactDigest.serialize(exactBuffer.data());
+  std::string serializedExact(exactBuffer.begin(), exactBuffer.end());
+
+  int32_t approx3Size = approximateDigest3.estimatedSerializedSize();
+  std::vector<char> approx3Buffer(approx3Size);
+  approximateDigest3.serialize(approx3Buffer.data());
+  std::string serializedApprox3(approx3Buffer.begin(), approx3Buffer.end());
+
+  // Test mixed mode: exact (1000) ∩ approximate (10000 containing all exact)
+  result = intersectionCardinality(serializedExact, serializedApprox3);
+  ASSERT_TRUE(result.has_value());
+  // With 1000 elements, MinHash should be able to estimate the overlap
+  // Expected ~1000, but allow wider margin due to MinHash estimation variance
+  EXPECT_GE(result.value(), 600);
+  EXPECT_LE(result.value(), 1400);
+}
+
+TEST_F(SetDigestFunctionsTest, testJaccardIndex) {
+  const auto jaccardIndex = [&](const std::optional<std::string>& input1,
+                                const std::optional<std::string>& input2) {
+    return evaluateOnce<double>(
+        "jaccard_index(c0, c1)", {SETDIGEST(), SETDIGEST()}, input1, input2);
+  };
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  HashStringAllocator allocator(pool.get());
+
+  // Test 1: Identical sets - Jaccard index should be 1.0
+  facebook::velox::functions::SetDigest<int64_t> digest1(&allocator);
+  for (int64_t i = 1; i <= 100; i++) {
+    digest1.add(i);
+  }
+
+  int32_t size1 = digest1.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest1.serialize(buffer1.data());
+  std::string serialized1(buffer1.begin(), buffer1.end());
+
+  auto result = jaccardIndex(serialized1, serialized1);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_DOUBLE_EQ(result.value(), 1.0);
+
+  // Test 2: Disjoint sets - Jaccard index should be 0.0
+  facebook::velox::functions::SetDigest<int64_t> digest2(&allocator);
+  for (int64_t i = 101; i <= 200; i++) {
+    digest2.add(i);
+  }
+
+  int32_t size2 = digest2.estimatedSerializedSize();
+  std::vector<char> buffer2(size2);
+  digest2.serialize(buffer2.data());
+  std::string serialized2(buffer2.begin(), buffer2.end());
+
+  result = jaccardIndex(serialized1, serialized2);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_DOUBLE_EQ(result.value(), 0.0);
+
+  // Test 3: Partially overlapping sets
+  // digest1: 1-100, digest3: 50-150
+  // Intersection: 50-100 (51 elements)
+  // Union: 1-150 (150 elements)
+  // Expected Jaccard: 51/150 ≈ 0.34
+  facebook::velox::functions::SetDigest<int64_t> digest3(&allocator);
+  for (int64_t i = 50; i <= 150; i++) {
+    digest3.add(i);
+  }
+
+  int32_t size3 = digest3.estimatedSerializedSize();
+  std::vector<char> buffer3(size3);
+  digest3.serialize(buffer3.data());
+  std::string serialized3(buffer3.begin(), buffer3.end());
+
+  result = jaccardIndex(serialized1, serialized3);
+  ASSERT_TRUE(result.has_value());
+  // Exact expected value: 51/150 = 0.34
+  double expectedJaccard = 51.0 / 150.0;
+  EXPECT_NEAR(result.value(), expectedJaccard, 0.05);
+
+  // Test 4: One set is a subset of the other
+  // digest1: 1-100, digest4: 25-75 (subset of digest1)
+  // Intersection: 25-75 (51 elements)
+  // Union: 1-100 (100 elements)
+  // Expected Jaccard: 51/100 = 0.51
+  facebook::velox::functions::SetDigest<int64_t> digest4(&allocator);
+  for (int64_t i = 25; i <= 75; i++) {
+    digest4.add(i);
+  }
+
+  int32_t size4 = digest4.estimatedSerializedSize();
+  std::vector<char> buffer4(size4);
+  digest4.serialize(buffer4.data());
+  std::string serialized4(buffer4.begin(), buffer4.end());
+
+  result = jaccardIndex(serialized1, serialized4);
+  ASSERT_TRUE(result.has_value());
+  expectedJaccard = 51.0 / 100.0;
+  EXPECT_NEAR(result.value(), expectedJaccard, 0.05);
+
+  // Test 5: Small overlap
+  // digest1: 1-100, digest5: 95-200
+  // Intersection: 95-100 (6 elements)
+  // Union: 1-200 (200 elements)
+  // Expected Jaccard: 6/200 = 0.03
+  facebook::velox::functions::SetDigest<int64_t> digest5(&allocator);
+  for (int64_t i = 95; i <= 200; i++) {
+    digest5.add(i);
+  }
+
+  int32_t size5 = digest5.estimatedSerializedSize();
+  std::vector<char> buffer5(size5);
+  digest5.serialize(buffer5.data());
+  std::string serialized5(buffer5.begin(), buffer5.end());
+
+  result = jaccardIndex(serialized1, serialized5);
+  ASSERT_TRUE(result.has_value());
+  expectedJaccard = 6.0 / 200.0;
+  EXPECT_NEAR(result.value(), expectedJaccard, 0.05);
+
+  // Test with null inputs.
+  result = jaccardIndex(std::nullopt, serialized1);
+  ASSERT_FALSE(result.has_value());
+
+  result = jaccardIndex(serialized1, std::nullopt);
+  ASSERT_FALSE(result.has_value());
+
+  result = jaccardIndex(std::nullopt, std::nullopt);
+  ASSERT_FALSE(result.has_value());
+}
+
+TEST_F(SetDigestFunctionsTest, testJaccardIndexApproximate) {
+  const auto jaccardIndex = [&](const std::optional<std::string>& input1,
+                                const std::optional<std::string>& input2) {
+    return evaluateOnce<double>(
+        "jaccard_index(c0, c1)", {SETDIGEST(), SETDIGEST()}, input1, input2);
+  };
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  HashStringAllocator allocator(pool.get());
+
+  // Create large approximate digests
+  // digest1: 0-14999 (15000 elements)
+  facebook::velox::functions::SetDigest<int64_t> digest1(&allocator);
+  for (int64_t i = 0; i < 15000; i++) {
+    digest1.add(i);
+  }
+  ASSERT_FALSE(digest1.isExact());
+
+  // digest2: 5000-19999 (15000 elements)
+  // Intersection: 5000-14999 (10000 elements)
+  // Union: 0-19999 (20000 elements)
+  // Expected Jaccard: 10000/20000 = 0.5
+  facebook::velox::functions::SetDigest<int64_t> digest2(&allocator);
+  for (int64_t i = 5000; i < 20000; i++) {
+    digest2.add(i);
+  }
+  ASSERT_FALSE(digest2.isExact());
+
+  int32_t size1 = digest1.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest1.serialize(buffer1.data());
+  std::string serialized1(buffer1.begin(), buffer1.end());
+
+  int32_t size2 = digest2.estimatedSerializedSize();
+  std::vector<char> buffer2(size2);
+  digest2.serialize(buffer2.data());
+  std::string serialized2(buffer2.begin(), buffer2.end());
+
+  auto result = jaccardIndex(serialized1, serialized2);
+  ASSERT_TRUE(result.has_value());
+  // Expected value is 0.5, allow reasonable margin for approximation
+  EXPECT_GE(result.value(), 0.0);
+  EXPECT_LE(result.value(), 1.0);
+  EXPECT_NEAR(result.value(), 0.5, 0.15);
+
+  // Test with same approximate digest (self-similarity)
+  result = jaccardIndex(serialized1, serialized1);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_DOUBLE_EQ(result.value(), 1.0);
+
+  // Test with disjoint approximate sets
+  // digest3: 30000-44999 (15000 elements, no overlap with digest1)
+  facebook::velox::functions::SetDigest<int64_t> digest3(&allocator);
+  for (int64_t i = 30000; i < 45000; i++) {
+    digest3.add(i);
+  }
+  ASSERT_FALSE(digest3.isExact());
+
+  int32_t size3 = digest3.estimatedSerializedSize();
+  std::vector<char> buffer3(size3);
+  digest3.serialize(buffer3.data());
+  std::string serialized3(buffer3.begin(), buffer3.end());
+
+  result = jaccardIndex(serialized1, serialized3);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_NEAR(result.value(), 0.0, 0.1);
+}
diff --git a/velox/functions/prestosql/tests/SimpleComparisonMatcherTest.cpp b/velox/functions/prestosql/tests/SimpleComparisonMatcherTest.cpp
index a12f21e2ed4..0325f42b853 100644
--- a/velox/functions/prestosql/tests/SimpleComparisonMatcherTest.cpp
+++ b/velox/functions/prestosql/tests/SimpleComparisonMatcherTest.cpp
@@ -16,9 +16,8 @@
 #include <gtest/gtest.h>
 
 #include "velox/expression/VectorFunction.h"
-#include "velox/functions/prestosql/SimpleComparisonMatcher.h"
+#include "velox/functions/lib/SimpleComparisonMatcher.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
-#include "velox/parse/Expressions.h"
 #include "velox/parse/ExpressionsParser.h"
 #include "velox/parse/TypeResolver.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
@@ -43,7 +42,8 @@ class SimpleComparisonMatcherTest : public testing::Test,
       const RowTypePtr& rowType) {
     parse::ParseOptions options;
     options.functionPrefix = prefix_;
-    auto untyped = parse::parseExpr(text, options);
+    options.parseIntegerAsBigint = false;
+    auto untyped = parse::DuckSqlExpressionsParser(options).parseExpr(text);
     return core::Expressions::inferTypes(untyped, rowType, execCtx_->pool());
   }
 
@@ -69,7 +69,7 @@ class TestFunction : public exec::VectorFunction {
                 .typeVariable("T")
                 .returnType("array(T)")
                 .argumentType("array(T)")
-                .argumentType("function(T,T,bigint)")
+                .argumentType("function(T,T,integer)")
                 .build()};
   }
 };
@@ -80,8 +80,9 @@ TEST_F(SimpleComparisonMatcherTest, basic) {
       TestFunction::signatures(),
       std::make_unique<TestFunction>());
 
-  const auto inputType =
-      ROW({"a"}, {ARRAY(ROW({"f", "g"}, {BIGINT(), BIGINT()}))});
+  const auto inputType = ROW({"a"}, {ARRAY(ROW({"f", "g"}, INTEGER()))});
+
+  auto checker = std::make_unique<SimpleComparisonChecker>();
 
   auto testMatcher = [&](const std::string& expr,
                          std::optional<bool> lessThan) {
@@ -92,8 +93,7 @@ TEST_F(SimpleComparisonMatcherTest, basic) {
     auto lambdaExpr = std::dynamic_pointer_cast<const core::LambdaTypedExpr>(
         parsedExpr->inputs()[1]);
 
-    auto comparison =
-        functions::prestosql::isSimpleComparison(prefix_, *lambdaExpr);
+    auto comparison = checker->isSimpleComparison(prefix_, *lambdaExpr);
 
     ASSERT_EQ(lessThan.has_value(), comparison.has_value());
     if (lessThan.has_value()) {
diff --git a/velox/functions/prestosql/tests/StringFunctionsTest.cpp b/velox/functions/prestosql/tests/StringFunctionsTest.cpp
index 03dc87f6f54..a948d00e8bf 100644
--- a/velox/functions/prestosql/tests/StringFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/StringFunctionsTest.cpp
@@ -315,6 +315,10 @@ class StringFunctionsTest : public FunctionBaseTest {
       const std::string& left,
       const std::string& right);
 
+  double jaroWinklerSimilarity(
+      const std::string& left,
+      const std::string& right);
+
   using replace_input_test_t = std::vector<std::pair<
       std::tuple<std::string, std::string, std::string>,
       std::string>>;
@@ -1048,6 +1052,44 @@ TEST_F(StringFunctionsTest, length) {
   }
 }
 
+TEST_F(StringFunctionsTest, bitLength) {
+  const auto bitLength = [&](std::optional<std::string> arg) {
+    return evaluateOnce<int64_t>("bit_length(c0)", std::move(arg));
+  };
+
+  // Test basic cases
+  EXPECT_EQ(bitLength(""), 0);
+  EXPECT_EQ(bitLength("hello"), 40);
+
+  // Test non-ASCII characters
+  EXPECT_EQ(bitLength("hell o\u00EF"), 64);
+  EXPECT_EQ(bitLength("中123"), 48);
+
+  // Single byte characters
+  EXPECT_EQ(bitLength("a"), 8);
+  EXPECT_EQ(bitLength("ab"), 16);
+  EXPECT_EQ(bitLength("abc"), 24);
+
+  // Multi-byte UTF-8 characters
+  EXPECT_EQ(bitLength("é"), 16);
+  EXPECT_EQ(bitLength("€"), 24);
+  EXPECT_EQ(bitLength("\U0001F408"), 32);
+
+  // Mixed ASCII and Unicode
+  EXPECT_EQ(bitLength("hello世界"), 88);
+
+  // Test with null input
+  EXPECT_EQ(bitLength(std::nullopt), std::nullopt);
+
+  // Test constant vectors
+  auto rows = makeRowVector({makeRowVector(
+      {makeFlatVector<int32_t>(5, [](vector_size_t row) { return row; })})});
+  auto result = evaluate<SimpleVector<int64_t>>("bit_length('test')", rows);
+  for (int i = 0; i < 5; ++i) {
+    EXPECT_EQ(result->valueAt(i), 32);
+  }
+}
+
 TEST_F(StringFunctionsTest, startsWith) {
   auto startsWith = [&](const std::string& x, const std::string& y) {
     return evaluateOnce<bool>(
@@ -1415,6 +1457,122 @@ TEST_F(StringFunctionsTest, invalidLevenshteinDistance) {
       "The combined inputs size exceeded max Levenshtein distance combined input size");
 }
 
+double StringFunctionsTest::jaroWinklerSimilarity(
+    const std::string& left,
+    const std::string& right) {
+  return evaluateOnce<double>(
+             "jarowinkler_similarity(c0, c1)",
+             std::optional(left),
+             std::optional(right))
+      .value();
+}
+
+TEST_F(StringFunctionsTest, asciiJaroWinklerSimilarity) {
+  EXPECT_DOUBLE_EQ(jaroWinklerSimilarity("", ""), 1.0);
+  EXPECT_DOUBLE_EQ(jaroWinklerSimilarity("TRACE", "TRACE"), 1.0);
+  EXPECT_DOUBLE_EQ(jaroWinklerSimilarity("TRATE", "TRACE"), 0.91);
+  EXPECT_DOUBLE_EQ(jaroWinklerSimilarity("TRACE", "TRATE"), 0.91);
+  EXPECT_DOUBLE_EQ(jaroWinklerSimilarity("arnab", "aranb"), 0.95);
+  EXPECT_DOUBLE_EQ(jaroWinklerSimilarity("DwAyNE", "DuANE"), 0.84);
+
+  // Test edge cases with empty strings
+  EXPECT_DOUBLE_EQ(jaroWinklerSimilarity("abc", ""), 0.0);
+  EXPECT_DOUBLE_EQ(jaroWinklerSimilarity("", "xyz"), 0.0);
+}
+
+TEST_F(StringFunctionsTest, unicodeJaroWinklerSimilarity) {
+  // Test for non-ASCII
+  EXPECT_DOUBLE_EQ(jaroWinklerSimilarity("TRA\u00EFE", "TRACE"), 0.91);
+  EXPECT_DOUBLE_EQ(
+      jaroWinklerSimilarity(
+          "\u4FE1\u5FF5\u7231\u00EF\u671B", "\u4FE1\u5FF5\u7231\u5E0C\u671B"),
+      0.91);
+  EXPECT_DOUBLE_EQ(
+      jaroWinklerSimilarity(
+          "\u4FE1\u00EF\u7231y\u5E0C\u671B", "\u4FE1\u5FF5\u7231\u5E0C\u671B"),
+      0.84);
+}
+
+TEST_F(StringFunctionsTest, invalidJaroWinklerSimilarity) {
+  // Test for invalid utf-8 characters
+  VELOX_ASSERT_THROW(
+      jaroWinklerSimilarity("hello world", "a\xA9ü"),
+      "Invalid UTF-8 encoding in characters");
+  VELOX_ASSERT_THROW(
+      jaroWinklerSimilarity("hello world", "Ψ\xFF\xFFΣΓΔA"),
+      "Invalid UTF-8 encoding in characters");
+
+  // Test for maximum length
+  VELOX_ASSERT_THROW(
+      jaroWinklerSimilarity(std::string(1001, 'x'), std::string(1001, 'x')),
+      "The combined inputs for Jaro-Winkler similarity are too large");
+  VELOX_ASSERT_THROW(
+      jaroWinklerSimilarity("hello", std::string(500000, 'x')),
+      "The combined inputs for Jaro-Winkler similarity are too large");
+  VELOX_ASSERT_THROW(
+      jaroWinklerSimilarity(std::string(500000, 'x'), "hello"),
+      "The combined inputs for Jaro-Winkler similarity are too large");
+}
+
+TEST_F(StringFunctionsTest, longestCommonPrefix) {
+  const auto longestCommonPrefix = [&](std::optional<std::string> left,
+                                       std::optional<std::string> right) {
+    return evaluateOnce<std::string>(
+        "longest_common_prefix(c0, c1)", std::move(left), std::move(right));
+  };
+
+  // Test basic cases.
+  EXPECT_EQ(longestCommonPrefix("", ""), "");
+  EXPECT_EQ(longestCommonPrefix("", "hello"), "");
+  EXPECT_EQ(longestCommonPrefix("hello", ""), "");
+  EXPECT_EQ(longestCommonPrefix("hello", "hello"), "hello");
+  EXPECT_EQ(longestCommonPrefix("hello world", "hello"), "hello");
+  EXPECT_EQ(longestCommonPrefix("hello", "hello world"), "hello");
+  EXPECT_EQ(longestCommonPrefix("hello world", "hel wold"), "hel");
+  EXPECT_EQ(longestCommonPrefix("hel wold", "hello world"), "hel");
+
+  // Test for non-ASCII.
+  EXPECT_EQ(longestCommonPrefix("\u4FE1\u5FF5,\u7231,\u5E0C\u671B", ""), "");
+  EXPECT_EQ(longestCommonPrefix("", "\u4FE1\u5FF5,\u7231,\u5E0C\u671B"), "");
+  EXPECT_EQ(
+      longestCommonPrefix(
+          "\u4FE1\u5FF5,\u7231,\u5E0C\u671B",
+          "\u4FE1\u5FF5,\u7231,\u5E0C\u671B"),
+      "\u4FE1\u5FF5,\u7231,\u5E0C\u671B");
+  EXPECT_EQ(
+      longestCommonPrefix(
+          "\u4FE1\u5FF5,\u7221,\u5E0C\u671B",
+          "\u4FE1\u5FF5,\u7231,\u5E0C\u671B"),
+      "\u4FE1\u5FF5,");
+  EXPECT_EQ(
+      longestCommonPrefix("hello na\u00EFve world", "hello na\u00EFve"),
+      "hello na\u00EFve");
+
+  // Test null cases.
+  EXPECT_EQ(longestCommonPrefix(std::nullopt, "hello"), std::nullopt);
+  EXPECT_EQ(longestCommonPrefix("hello", std::nullopt), std::nullopt);
+  EXPECT_EQ(longestCommonPrefix(std::nullopt, std::nullopt), std::nullopt);
+
+  // Test different lengths.
+  EXPECT_EQ(longestCommonPrefix("a", "abcdef"), "a");
+  EXPECT_EQ(longestCommonPrefix("abcdef", "a"), "a");
+
+  // Additional Unicode tests.
+  EXPECT_EQ(longestCommonPrefix("café", "cat"), "ca");
+  EXPECT_EQ(longestCommonPrefix("préfix", "prefix"), "pr");
+  EXPECT_EQ(longestCommonPrefix("🚀🌟", "🚀🔥"), "🚀");
+  EXPECT_EQ(longestCommonPrefix("Ψ", "Ψmore"), "Ψ");
+  EXPECT_EQ(longestCommonPrefix("hellö", "hell"), "hell");
+
+  // Test for invalid UTF-8 characters.
+  VELOX_ASSERT_THROW(
+      longestCommonPrefix("hello world", "\x81"),
+      "Invalid UTF-8 encoding in characters");
+  VELOX_ASSERT_THROW(
+      longestCommonPrefix("hello world", "2\x81"),
+      "Invalid UTF-8 encoding in characters");
+}
+
 void StringFunctionsTest::testReplaceFlatVector(
     const replace_input_test_t& tests,
     bool withReplaceArgument,
@@ -1737,10 +1895,11 @@ TEST_F(StringFunctionsTest, toUtf8) {
   // during execution) to a vector of size 2 and passed on to to_utf8(). Here,
   // if the intermediate flat vector is created for a size > 2 then the function
   // throws.
-  EXPECT_NO_THROW(evaluateSimplified<FlatVector<bool>>(
-      "to_utf8(c0) = to_utf8('this')",
-      makeRowVector({makeNullableFlatVector<StringView>(
-          {std::nullopt, "test"_sv, std::nullopt})})));
+  EXPECT_NO_THROW(
+      evaluateSimplified<FlatVector<bool>>(
+          "to_utf8(c0) = to_utf8('this')",
+          makeRowVector({makeNullableFlatVector<StringView>(
+              {std::nullopt, "test"_sv, std::nullopt})})));
 }
 
 namespace {
@@ -2322,3 +2481,21 @@ TEST_F(StringFunctionsTest, xxHash64FunctionVarchar) {
   // Non-ASCII strings
   EXPECT_EQ(8176744303664166369, xxhash64("日本語"));
 }
+
+TEST_F(StringFunctionsTest, keySamplingPercent) {
+  const auto keySamplingPercent =
+      [&](const std::optional<std::string>& string) {
+        return evaluateOnce<double>("key_sampling_percent(c0)", string);
+      };
+
+  EXPECT_EQ(std::nullopt, keySamplingPercent(std::nullopt));
+  EXPECT_EQ(0.56, keySamplingPercent("abc"));
+  EXPECT_EQ(6.11561179120687E-153, keySamplingPercent("abcdefghskwkjadhwd"));
+  EXPECT_EQ(2.393674127734674E-93, keySamplingPercent("001yxzuj"));
+  EXPECT_EQ(0.48, keySamplingPercent("56wfythjhdhvgewuikwemn"));
+  EXPECT_EQ(0.7520703125, keySamplingPercent("special_#@,$|%/^~?{}+-"));
+  EXPECT_EQ(0.4, keySamplingPercent("     "));
+  EXPECT_EQ(0.28, keySamplingPercent(""));
+  EXPECT_EQ(
+      4.143659858002825E-274, keySamplingPercent("Hello World from Velox!"));
+}
diff --git a/velox/functions/prestosql/tests/TDigestFunctionsTest.cpp b/velox/functions/prestosql/tests/TDigestFunctionsTest.cpp
index f8c9e6c4d79..0b11aef552b 100644
--- a/velox/functions/prestosql/tests/TDigestFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/TDigestFunctionsTest.cpp
@@ -746,3 +746,129 @@ TEST_F(TDigestFunctionsTest, testTrimmedMean) {
     ASSERT_TRUE(abs(result.value() - expectedMean) / standardDeviation <= 0.05);
   }
 }
+
+TEST_F(TDigestFunctionsTest, testWinsorizedMean) {
+  const auto winsorizedMean = [&](const std::optional<std::string>& input,
+                                  const std::optional<double>& lowQuantile,
+                                  const std::optional<double>& highQuantile) {
+    return evaluateOnce<double>(
+        "winsorized_mean(c0, c1, c2)",
+        TDIGEST_DOUBLE,
+        input,
+        lowQuantile,
+        highQuantile);
+  };
+
+  // Create TDigest with uniform distribution.
+  facebook::velox::functions::TDigest<> tDigest;
+  std::vector<int16_t> positions;
+  std::vector<double> values;
+
+  std::mt19937 gen(42);
+  std::uniform_real_distribution<double> distribution(0.0, NUMBER_OF_ENTRIES);
+
+  for (int i = 0; i < NUMBER_OF_ENTRIES; i++) {
+    double value{distribution(gen)};
+    tDigest.add(positions, value);
+    values.push_back(value);
+  }
+  tDigest.compress(positions);
+  std::sort(values.begin(), values.end());
+
+  // Serialize TDigest.
+  auto serializedSize{tDigest.serializedByteSize()};
+  std::vector<char> buffer(serializedSize);
+  tDigest.serialize(buffer.data());
+  std::string serializedDigest(buffer.begin(), buffer.end());
+
+  // Full range (0, 1) should equal regular mean.
+  auto fullRangeResult{winsorizedMean(serializedDigest, 0.0, 1.0)};
+  double expectedFullMean{tDigest.sum() / tDigest.totalWeight()};
+  ASSERT_NEAR(
+      fullRangeResult.value(), expectedFullMean, expectedFullMean * 0.01);
+
+  // Test quantile pairs with computed expected values.
+  std::vector<std::pair<double, double>> quantilePairs = {
+      {0.1, 0.9},
+      {0.25, 0.75},
+      {0.01, 0.99},
+  };
+
+  for (const auto& [lowQuantile, highQuantile] : quantilePairs) {
+    int lowIndex{static_cast<int>(NUMBER_OF_ENTRIES * lowQuantile)};
+    int highIndex{static_cast<int>(NUMBER_OF_ENTRIES * highQuantile)};
+    double lowBound{values[lowIndex]};
+    double highBound{values[highIndex]};
+    double exactSum{0};
+    for (const auto& value : values) {
+      exactSum += std::max(lowBound, std::min(highBound, value));
+    }
+    double expectedMean{exactSum / NUMBER_OF_ENTRIES};
+
+    auto result{winsorizedMean(serializedDigest, lowQuantile, highQuantile)};
+    double standardDeviation{
+        std::sqrt(distribution.max() * distribution.max() / 12)};
+    ASSERT_TRUE(abs(result.value() - expectedMean) / standardDeviation <= 0.05);
+  }
+}
+
+TEST_F(TDigestFunctionsTest, testWinsorizedMeanEmptyDigest) {
+  // Empty TDigest should return NULL.
+  facebook::velox::functions::TDigest<> tDigest;
+  std::vector<int16_t> positions;
+  tDigest.compress(positions);
+  auto serializedSize{tDigest.serializedByteSize()};
+  std::vector<char> buffer(serializedSize);
+  tDigest.serialize(buffer.data());
+  std::string serializedDigest(buffer.begin(), buffer.end());
+
+  auto result = evaluateOnce<double>(
+      "winsorized_mean(c0, c1, c2)",
+      TDIGEST_DOUBLE,
+      std::optional<std::string>(serializedDigest),
+      std::optional<double>(0.1),
+      std::optional<double>(0.9));
+  ASSERT_FALSE(result.has_value());
+}
+
+TEST_F(TDigestFunctionsTest, testWinsorizedMeanInvalidBounds) {
+  // Create a simple TDigest.
+  facebook::velox::functions::TDigest<> tDigest;
+  std::vector<int16_t> positions;
+  tDigest.add(positions, 1.0);
+  tDigest.compress(positions);
+  auto serializedSize{tDigest.serializedByteSize()};
+  std::vector<char> buffer(serializedSize);
+  tDigest.serialize(buffer.data());
+  std::string serializedDigest(buffer.begin(), buffer.end());
+
+  // Out-of-range lower bound.
+  VELOX_ASSERT_THROW(
+      evaluateOnce<double>(
+          "winsorized_mean(c0, c1, c2)",
+          TDIGEST_DOUBLE,
+          std::optional<std::string>(serializedDigest),
+          std::optional<double>(-0.1),
+          std::optional<double>(0.5)),
+      "between 0 and 1");
+
+  // Out-of-range upper bound.
+  VELOX_ASSERT_THROW(
+      evaluateOnce<double>(
+          "winsorized_mean(c0, c1, c2)",
+          TDIGEST_DOUBLE,
+          std::optional<std::string>(serializedDigest),
+          std::optional<double>(0.0),
+          std::optional<double>(1.1)),
+      "between 0 and 1");
+
+  // Lower > upper.
+  VELOX_ASSERT_THROW(
+      evaluateOnce<double>(
+          "winsorized_mean(c0, c1, c2)",
+          TDIGEST_DOUBLE,
+          std::optional<std::string>(serializedDigest),
+          std::optional<double>(0.9),
+          std::optional<double>(0.1)),
+      "less than or equal");
+}
diff --git a/velox/functions/prestosql/tests/TimeWithTimezoneCastTest.cpp b/velox/functions/prestosql/tests/TimeWithTimezoneCastTest.cpp
new file mode 100644
index 00000000000..6d45ab601fb
--- /dev/null
+++ b/velox/functions/prestosql/tests/TimeWithTimezoneCastTest.cpp
@@ -0,0 +1,790 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/tests/CastBaseTest.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
+#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/type/Time.h"
+
+using facebook::velox::util::biasEncode;
+using facebook::velox::util::pack;
+
+namespace facebook::velox {
+namespace {
+
+inline int64_t getUTCMillis(
+    int64_t hours,
+    int64_t minutes = 0,
+    int64_t seconds = 0,
+    int64_t millis = 0) {
+  return hours * util::kMillisInHour + minutes * util::kMillisInMinute +
+      seconds * util::kMillisInSecond + millis;
+}
+
+class TimeWithTimezoneCastTest : public functions::test::CastBaseTest {
+ protected:
+  void setQueryTimeZone(const std::string& timeZone) {
+    queryCtx_->testingOverrideConfigUnsafe({
+        {core::QueryConfig::kSessionTimezone, timeZone},
+        {core::QueryConfig::kAdjustTimestampToTimezone, "true"},
+    });
+  }
+
+  void setQueryTimeZoneAndStartTime(
+      const std::string& timeZone,
+      int64_t startTimeMs) {
+    queryCtx_->testingOverrideConfigUnsafe({
+        {core::QueryConfig::kSessionTimezone, timeZone},
+        {core::QueryConfig::kAdjustTimestampToTimezone, "true"},
+        {core::QueryConfig::kSessionStartTime, std::to_string(startTimeMs)},
+    });
+  }
+
+  void disableAdjustTimestampToTimezone() {
+    queryCtx_->testingOverrideConfigUnsafe({
+        {core::QueryConfig::kAdjustTimestampToTimezone, "false"},
+    });
+  }
+
+  // Helper to pack TIME WITH TIME ZONE value
+  int64_t packTimeWithTZ(int64_t timeMillis, int16_t offsetMinutes) {
+    auto encodedOffset = biasEncode(offsetMinutes);
+    return pack(timeMillis, encodedOffset);
+  }
+};
+
+TEST_F(TimeWithTimezoneCastTest, toVarchar) {
+  // Test comprehensive scenarios: various times, timezones, boundary values,
+  // and nulls. Note: Time is stored in UTC, so when displaying, we convert
+  // UTC time to local time by adding the timezone offset.
+  auto input = makeNullableFlatVector<int64_t>(
+      {
+          // Constant values to test any regressions
+          // in pack and biasEncode functions.
+          58755883008,
+          // 11:31:37.123 UTC with timezone +05:30 -> displays as 17:01:37.123
+          169972216978,
+          // 11:31:37.123 UTC with timezone -05:00 -> displays as 06:31:37.123
+          169972216349,
+          // UTC time 06:11:37.123 with UTC timezone -> displays as
+          // 06:11:37.123+00:00
+          pack(getUTCMillis(6, 11, 37, 123), biasEncode(0)),
+          // UTC time 06:11:37.123 with -05:00 timezone -> displays as
+          // 01:11:37.123-05:00
+          pack(getUTCMillis(6, 11, 37, 123), biasEncode(-5 * 60)),
+          // UTC time 06:11:37.123 with +05:30 timezone -> displays as
+          // 11:41:37.123+05:30
+          pack(getUTCMillis(6, 11, 37, 123), biasEncode(5 * 60 + 30)),
+          // Boundary: Midnight UTC with UTC timezone
+          pack(0, biasEncode(0)),
+          // Boundary: Almost end of day UTC with UTC timezone
+          pack(getUTCMillis(23, 59, 59, 999), biasEncode(0)),
+          // Null value.
+          std::nullopt,
+          // UTC time 12:00:00 with +14:00 timezone -> displays as
+          // 02:00:00.000+14:00 (next day wrap)
+          pack(getUTCMillis(12), biasEncode(14 * 60)),
+          // UTC time 12:00:00 with -14:00 timezone -> displays as
+          // 22:00:00.000-14:00 (prev day wrap)
+          pack(getUTCMillis(12), biasEncode(-14 * 60)),
+          // Edge case: 1 millisecond after midnight UTC with UTC timezone
+          pack(1, biasEncode(0)),
+          // UTC time 12:34:56.789 with -04:30 timezone -> displays as
+          // 08:04:56.789-04:30
+          pack(getUTCMillis(12, 34, 56, 789), biasEncode(-4 * 60 - 30)),
+          // UTC time 09:08:07 with +05:45 timezone -> displays as
+          // 14:53:07.000+05:45
+          pack(getUTCMillis(9, 8, 7), biasEncode(5 * 60 + 45)),
+          // Another null value.
+          std::nullopt,
+      },
+      TIME_WITH_TIME_ZONE());
+
+  auto expected = makeNullableFlatVector<std::string>({
+      "03:59:04.698+00:00",
+      "17:01:37.123+05:30",
+      "06:31:37.123-05:00",
+      "06:11:37.123+00:00",
+      "01:11:37.123-05:00",
+      "11:41:37.123+05:30",
+      "00:00:00.000+00:00",
+      "23:59:59.999+00:00",
+      std::nullopt,
+      "02:00:00.000+14:00",
+      "22:00:00.000-14:00",
+      "00:00:00.001+00:00",
+      "08:04:56.789-04:30",
+      "14:53:07.000+05:45",
+      std::nullopt,
+  });
+
+  testCast(input, expected);
+}
+
+TEST_F(TimeWithTimezoneCastTest, fromVarchar) {
+  // Test casting VARCHAR to TIME WITH TIME ZONE with various formats.
+  // Note: Input strings represent local time, which gets converted to UTC for
+  // storage.
+  auto input = makeNullableFlatVector<std::string>({
+      // Basic format: H:m:s.SSS+HH:mm
+      "6:11:37.123+00:00",
+      "6:11:37.123-05:00", // Local 06:11:37.123 in UTC-5 = 11:11:37.123 UTC
+      "6:11:37.123+05:30", // Local 06:11:37.123 in UTC+5:30 = 00:41:37.123 UTC
+      // Format without milliseconds: H:m:s+HH:mm
+      "12:34:56+01:00", // Local 12:34:56 in UTC+1 = 11:34:56 UTC
+      "12:34:56-08:00", // Local 12:34:56 in UTC-8 = 20:34:56 UTC
+      // Compact format: H:m+HH:mm
+      "1:30+05:30", // Local 01:30 in UTC+5:30 = 20:00 UTC (prev day)
+      "23:45-07:00", // Local 23:45 in UTC-7 = 06:45 UTC (next day)
+      // Format with space before timezone: H:m:s.SSS +HH:mm
+      "14:22:11.456 +02:00", // Local 14:22:11.456 in UTC+2 = 12:22:11.456 UTC
+      "9:15:30.789 -04:30", // Local 09:15:30.789 in UTC-4:30 = 13:45:30.789 UTC
+      // Compact timezone format (no colon): H:m:s+HHmm
+      "3:4:5+0709", // Local 03:04:05 in UTC+7:09 = 19:55:05 UTC (prev day)
+      "15:45:30-0800", // Local 15:45:30 in UTC-8 = 23:45:30 UTC
+      // Short timezone format: H:m:s+HH
+      "8:30:00+05", // Local 08:30:00 in UTC+5 = 03:30:00 UTC
+      "16:45:30-08", // Local 16:45:30 in UTC-8 = 00:45:30 UTC (next day)
+      // Boundary: Midnight with UTC
+      "0:0:0.000+00:00",
+      // Boundary: Almost end of day
+      "23:59:59.999+00:00",
+      // Boundary: Maximum positive timezone offset (+14:00)
+      "12:00:00.000+14:00", // Local 12:00 in UTC+14 = 22:00 UTC (prev day)
+      // Boundary: Maximum negative timezone offset (-14:00)
+      "12:00:00.000-14:00", // Local 12:00 in UTC-14 = 02:00 UTC (next day)
+      // Edge case: 1 millisecond after midnight
+      "0:0:0.001+00:00",
+      // Various valid formats with different hour/minute combinations
+      "9:8:7.000+05:45", // Local 09:08:07 in UTC+5:45 = 03:23:07 UTC
+      "1:2:3+01:30", // Local 01:02:03 in UTC+1:30 = 23:32:03 UTC (prev day)
+      // Null value
+      std::nullopt,
+      // Compact format with space: H:m +HH
+      "7:30 +03", // Local 07:30 in UTC+3 = 04:30 UTC
+      "18:45 -06", // Local 18:45 in UTC-6 = 00:45 UTC (next day)
+      // Double-digit hours and minutes: HH:mm:ss.SSS+HH:mm
+      "06:11:37.123+00:00",
+      "12:34:56.789-04:30", // Local 12:34:56.789 in UTC-4:30 = 17:04:56.789 UTC
+      "03:59:04.698+00:00",
+      "17:01:37.123+05:30",
+      "06:31:37.123-05:00",
+  });
+
+  auto expected = makeNullableFlatVector<int64_t>(
+      {
+          // "6:11:37.123+00:00" -> UTC 06:11:37.123
+          pack(getUTCMillis(6, 11, 37, 123), biasEncode(0)),
+          // "6:11:37.123-05:00" -> UTC 11:11:37.123
+          pack(getUTCMillis(11, 11, 37, 123), biasEncode(-5 * 60)),
+          // "6:11:37.123+05:30" -> UTC 00:41:37.123
+          pack(getUTCMillis(0, 41, 37, 123), biasEncode(5 * 60 + 30)),
+          // "12:34:56+01:00" -> UTC 11:34:56
+          pack(getUTCMillis(11, 34, 56), biasEncode(1 * 60)),
+          // "12:34:56-08:00" -> UTC 20:34:56
+          pack(getUTCMillis(20, 34, 56), biasEncode(-8 * 60)),
+          // "1:30+05:30" -> UTC 20:00:00 (prev day wraps to 20:00)
+          pack(getUTCMillis(20, 0), biasEncode(5 * 60 + 30)),
+          // "23:45-07:00" -> UTC 06:45:00 (next day wraps to 06:45)
+          pack(getUTCMillis(6, 45), biasEncode(-7 * 60)),
+          // "14:22:11.456 +02:00" -> UTC 12:22:11.456
+          pack(getUTCMillis(12, 22, 11, 456), biasEncode(2 * 60)),
+          // "9:15:30.789 -04:30" -> UTC 13:45:30.789
+          pack(getUTCMillis(13, 45, 30, 789), biasEncode(-4 * 60 - 30)),
+          // "3:4:5+0709" -> UTC 19:55:05 (prev day wraps to 19:55:05)
+          pack(getUTCMillis(19, 55, 5), biasEncode(7 * 60 + 9)),
+          // "15:45:30-0800" -> UTC 23:45:30
+          pack(getUTCMillis(23, 45, 30), biasEncode(-8 * 60)),
+          // "8:30:00+05" -> UTC 03:30:00
+          pack(getUTCMillis(3, 30), biasEncode(5 * 60)),
+          // "16:45:30-08" -> UTC 00:45:30 (next day wraps to 00:45:30)
+          pack(getUTCMillis(0, 45, 30), biasEncode(-8 * 60)),
+          // "0:0:0.000+00:00" -> UTC 00:00:00.000
+          pack(0, biasEncode(0)),
+          // "23:59:59.999+00:00" -> UTC 23:59:59.999
+          pack(getUTCMillis(23, 59, 59, 999), biasEncode(0)),
+          // "12:00:00.000+14:00" -> UTC 22:00:00 (prev day wraps to 22:00)
+          pack(getUTCMillis(22, 0, 0), biasEncode(14 * 60)),
+          // "12:00:00.000-14:00" -> UTC 02:00:00 (next day wraps to 02:00)
+          pack(getUTCMillis(2, 0, 0), biasEncode(-14 * 60)),
+          // "0:0:0.001+00:00" -> UTC 00:00:00.001
+          pack(1, biasEncode(0)),
+          // "9:8:7.000+05:45" -> UTC 03:23:07
+          pack(getUTCMillis(3, 23, 7), biasEncode(5 * 60 + 45)),
+          // "1:2:3+01:30" -> UTC 23:32:03 (prev day wraps to 23:32:03)
+          pack(getUTCMillis(23, 32, 3), biasEncode(1 * 60 + 30)),
+          // Null value
+          std::nullopt,
+          // "7:30 +03" -> UTC 04:30
+          pack(getUTCMillis(4, 30), biasEncode(3 * 60)),
+          // "18:45 -06" -> UTC 00:45 (next day wraps to 00:45)
+          pack(getUTCMillis(0, 45), biasEncode(-6 * 60)),
+          // "06:11:37.123+00:00" -> UTC 06:11:37.123
+          pack(getUTCMillis(6, 11, 37, 123), biasEncode(0)),
+          // "12:34:56.789-04:30" -> UTC 17:04:56.789
+          pack(getUTCMillis(17, 4, 56, 789), biasEncode(-4 * 60 - 30)),
+          // Constant values to test any regressions
+          // in pack and biasEncode functions.
+          58755883008,
+          // 11:31:37.123 UTC with timezone +05:30 -> displays as 17:01:37.123
+          169972216978,
+          // 11:31:37.123 UTC with timezone -05:00 -> displays as 06:31:37.123
+          169972216349,
+      },
+      TIME_WITH_TIME_ZONE());
+
+  testCast(input, expected);
+}
+
+TEST_F(TimeWithTimezoneCastTest, fromVarcharInvalid) {
+  // Test invalid VARCHAR inputs that should throw errors.
+  auto testInvalidCast = [&](const std::string& input,
+                             const std::string& expectedError) {
+    VELOX_ASSERT_THROW(
+        evaluateCast(
+            VARCHAR(),
+            TIME_WITH_TIME_ZONE(),
+            makeRowVector({makeFlatVector<std::string>({input})})),
+        expectedError);
+  };
+
+  // Invalid: Missing timezone offset
+  testInvalidCast("12:34:56", "missing timezone offset");
+
+  // Invalid: Hour out of range (25 > 23)
+  testInvalidCast("25:00:00+00:00", "Invalid hour value");
+
+  // Invalid: Minute out of range (60 >= 60)
+  testInvalidCast("12:60:00+00:00", "Invalid minute value");
+
+  // Invalid: Second out of range (60 >= 60)
+  testInvalidCast("12:34:60+00:00", "Invalid second value");
+
+  // Invalid: Microsecond precision not supported (4 digits after decimal)
+  testInvalidCast("12:34:56.1234+00:00", "Microsecond precision not supported");
+
+  // Invalid: Timezone offset out of range (+15:00 > +14:00)
+  testInvalidCast("12:00:00+15:00", "out of range");
+
+  // Invalid: Timezone offset out of range (-15:00 < -14:00)
+  testInvalidCast("12:00:00-15:00", "out of range");
+
+  // Invalid: Missing time component
+  testInvalidCast("+05:00", "missing time component");
+
+  // Invalid: Empty string
+  testInvalidCast("", "empty string");
+
+  // Invalid: Malformed format (missing colon in time)
+  testInvalidCast("1234+00:00", "expected ':' after hour");
+
+  // Invalid: Trailing characters after timezone
+  testInvalidCast("12:34:56+00:00extra", "unexpected trailing characters");
+
+  // Invalid: Number of digits in timezone offset hours is not 2
+  testInvalidCast("12:34:56+1:00", "digits before ':' not equal to 2");
+
+  // Invalid: Number of digits in timezone offset hours is not 2
+  testInvalidCast("12:34:56+01:", "failed to parse minutes after ':'");
+
+  // Invalid: IANA/Named timezones not supported (e.g., America/Los_Angeles)
+  testInvalidCast("12:34:56 America/Los_Angeles", "missing timezone offset");
+
+  // Invalid: IANA/Named timezones not supported (e.g., UTC)
+  testInvalidCast("14:30:45 UTC", "missing timezone offset");
+
+  // Invalid: IANA/Named timezones not supported (e.g., Asia/Tokyo)
+  testInvalidCast("09:15:30.123 Asia/Tokyo", "missing timezone offset");
+}
+
+TEST_F(TimeWithTimezoneCastTest, toTime) {
+  // Test casting TIME WITH TIME ZONE to TIME extracts the local time component
+  // (UTC time converted to local time by adding the timezone offset),
+  // discarding the timezone information.
+  auto input = makeNullableFlatVector<int64_t>(
+      {
+          // UTC 06:11:37.123 with +00:00 -> Local 06:11:37.123
+          pack(getUTCMillis(6, 11, 37, 123), biasEncode(0)),
+          // UTC 06:11:37.123 with -05:00 -> Local 01:11:37.123
+          pack(getUTCMillis(6, 11, 37, 123), biasEncode(-5 * 60)),
+          // UTC 06:11:37.123 with +05:30 -> Local 11:41:37.123
+          pack(getUTCMillis(6, 11, 37, 123), biasEncode(5 * 60 + 30)),
+          // Boundary: Midnight UTC with +00:00 -> Local 00:00:00.000
+          pack(0, biasEncode(0)),
+          // Boundary: Almost end of day UTC with +00:00 -> Local 23:59:59.999
+          pack(getUTCMillis(23, 59, 59, 999), biasEncode(0)),
+          // Null value.
+          std::nullopt,
+          // UTC 12:30:00 with +14:00 -> Local 02:30:00 (next day wrap)
+          pack(getUTCMillis(12, 30), biasEncode(14 * 60)),
+          // UTC 12:30:00 with -14:00 -> Local 22:30:00 (prev day wrap)
+          pack(getUTCMillis(12, 30), biasEncode(-14 * 60)),
+          // Edge case: 1 millisecond after midnight UTC with +00:00 -> Local
+          // 00:00:00.001
+          pack(1, biasEncode(0)),
+          // UTC 15:45:30.500 with -08:00 -> Local 07:45:30.500
+          pack(getUTCMillis(15, 45, 30, 500), biasEncode(-8 * 60)),
+          // Another null value.
+          std::nullopt,
+      },
+      TIME_WITH_TIME_ZONE());
+
+  auto expected = makeNullableFlatVector<int64_t>(
+      {
+          // UTC 06:11:37.123 + 0 = 06:11:37.123
+          getUTCMillis(6, 11, 37, 123),
+          // UTC 06:11:37.123 - 5 hours = 01:11:37.123
+          getUTCMillis(1, 11, 37, 123),
+          // UTC 06:11:37.123 + 5:30 = 11:41:37.123
+          getUTCMillis(11, 41, 37, 123),
+          // Midnight
+          0,
+          // Almost end of day
+          getUTCMillis(23, 59, 59, 999),
+          // Null
+          std::nullopt,
+          // UTC 12:30 + 14 hours = 26:30 -> wraps to 02:30
+          getUTCMillis(2, 30),
+          // UTC 12:30 - 14 hours = -1:30 -> wraps to 22:30
+          getUTCMillis(22, 30),
+          // 1 millisecond after midnight
+          1,
+          // UTC 15:45:30.500 - 8 hours = 07:45:30.500
+          getUTCMillis(7, 45, 30, 500),
+          // Null
+          std::nullopt,
+      },
+      TIME());
+
+  testCast(input, expected);
+
+  // UTC 14:22:11.456 with +05:30 -> Local 19:52:11.456
+  const int64_t timeWithTz =
+      pack(getUTCMillis(14, 22, 11, 456), biasEncode(5 * 60 + 30));
+
+  auto inputConstantVector =
+      makeConstant(timeWithTz, 10, TIME_WITH_TIME_ZONE());
+
+  const int64_t expectedTime = getUTCMillis(19, 52, 11, 456);
+  auto expectedConstantVector = makeConstant(expectedTime, 10, TIME());
+
+  testCast(inputConstantVector, expectedConstantVector);
+}
+
+TEST_F(TimeWithTimezoneCastTest, fromTime) {
+  {
+    // Test casting TIME to TIME WITH TIME ZONE with various times
+    // TIME values are in local time, and get converted to UTC for storage
+    auto input = makeFlatVector<int64_t>(
+        {
+            0, // 00:00:00.000 (midnight) local
+            3 * kMillisInHour + 4 * kMillisInMinute + 5 * kMillisInSecond +
+                321, // 03:04:05.321 local
+            12 * kMillisInHour, // 12:00:00.000 (noon) local
+            23 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond +
+                999, // 23:59:59.999 (end of day) local
+        },
+        TIME());
+
+    setQueryTimeZone("America/Los_Angeles");
+    // LA is UTC-8, so offset is -8 * 60 = -480 minutes
+    // Local times are converted to UTC: local - (-8 hours) = local + 8 hours
+    auto expected = makeFlatVector<int64_t>(
+        {
+            // 00:00:00 local -> 08:00:00 UTC
+            packTimeWithTZ(8 * kMillisInHour, -480),
+            // 03:04:05.321 local -> 11:04:05.321 UTC
+            packTimeWithTZ(
+                11 * kMillisInHour + 4 * kMillisInMinute + 5 * kMillisInSecond +
+                    321,
+                -480),
+            // 12:00:00 local -> 20:00:00 UTC
+            packTimeWithTZ(20 * kMillisInHour, -480),
+            // 23:59:59.999 local -> 07:59:59.999 UTC (next day, wraps to
+            // 07:59:59.999)
+            packTimeWithTZ(
+                7 * kMillisInHour + 59 * kMillisInMinute +
+                    59 * kMillisInSecond + 999,
+                -480),
+        },
+        TIME_WITH_TIME_ZONE());
+
+    testCast(input, expected);
+  }
+
+  {
+    // Test with nulls
+    auto input = makeNullableFlatVector<int64_t>(
+        {0,
+         std::nullopt,
+         12 * kMillisInHour,
+         std::nullopt,
+         23 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond +
+             999},
+        TIME());
+
+    setQueryTimeZone("America/Los_Angeles");
+    // LA is UTC-8, local times are converted to UTC: local + 8 hours
+
+    auto expected = makeNullableFlatVector<int64_t>(
+        {// 00:00:00 local -> 08:00:00 UTC
+         packTimeWithTZ(8 * kMillisInHour, -480),
+         std::nullopt,
+         // 12:00:00 local -> 20:00:00 UTC
+         packTimeWithTZ(20 * kMillisInHour, -480),
+         std::nullopt,
+         // 23:59:59.999 local -> 07:59:59.999 UTC (wraps to next day)
+         packTimeWithTZ(
+             7 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond +
+                 999,
+             -480)},
+        TIME_WITH_TIME_ZONE());
+
+    testCast(input, expected);
+  }
+
+  {
+    // Test with different timezone (Asia/Shanghai, UTC+8)
+    auto input = makeFlatVector<int64_t>(
+        {
+            0,
+            12 * kMillisInHour,
+            23 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond +
+                999,
+        },
+        TIME());
+
+    setQueryTimeZone("Asia/Shanghai");
+
+    // Shanghai is UTC+8, so offset is 8 * 60 = 480 minutes
+    // Local times are converted to UTC: local - 8 hours
+    auto expected = makeFlatVector<int64_t>(
+        {
+            // 00:00:00 local -> 16:00:00 UTC (previous day, wraps to 16:00)
+            packTimeWithTZ(16 * kMillisInHour, 480),
+            // 12:00:00 local -> 04:00:00 UTC
+            packTimeWithTZ(4 * kMillisInHour, 480),
+            // 23:59:59.999 local -> 15:59:59.999 UTC
+            packTimeWithTZ(
+                15 * kMillisInHour + 59 * kMillisInMinute +
+                    59 * kMillisInSecond + 999,
+                480),
+        },
+        TIME_WITH_TIME_ZONE());
+
+    testCast(input, expected);
+  }
+
+  {
+    // Test with adjustTimestampToTimezone disabled
+    // When disabled, offset should be 0 (UTC)
+    auto input = makeFlatVector<int64_t>(
+        {
+            0,
+            3 * kMillisInHour + 4 * kMillisInMinute + 5 * kMillisInSecond + 321,
+            12 * kMillisInHour,
+        },
+        TIME());
+
+    setQueryTimeZone("Asia/Shanghai");
+    disableAdjustTimestampToTimezone();
+
+    // When adjustTimestampToTimezone is false, offset is 0 (UTC)
+    auto expected = makeFlatVector<int64_t>(
+        {
+            packTimeWithTZ(0, 0),
+            packTimeWithTZ(
+                3 * kMillisInHour + 4 * kMillisInMinute + 5 * kMillisInSecond +
+                    321,
+                0),
+            packTimeWithTZ(12 * kMillisInHour, 0),
+        },
+        TIME_WITH_TIME_ZONE());
+
+    testCast(input, expected);
+  }
+
+  {
+    // Test constant TIME vector cast to TIME WITH TIME ZONE (non-null)
+    auto constantTimeVector = BaseVector::wrapInConstant(
+        1000, 0, makeFlatVector<int64_t>({12 * kMillisInHour}, TIME()));
+
+    setQueryTimeZone("America/New_York");
+
+    // NY is UTC-5, so offset is -5 * 60 = -300 minutes
+    // 12:00:00 local -> 17:00:00 UTC
+    auto expected = BaseVector::wrapInConstant(
+        1000,
+        0,
+        makeFlatVector<int64_t>(
+            {packTimeWithTZ(17 * kMillisInHour, -300)}, TIME_WITH_TIME_ZONE()));
+
+    testCast(constantTimeVector, expected);
+  }
+
+  {
+    // Test constant TIME vector cast to TIME WITH TIME ZONE (null)
+    auto nullTimeVector = BaseVector::createNullConstant(TIME(), 500, pool());
+
+    setQueryTimeZone("America/Los_Angeles");
+
+    auto expected =
+        BaseVector::createNullConstant(TIME_WITH_TIME_ZONE(), 500, pool());
+
+    testCast(nullTimeVector, expected);
+  }
+
+  {
+    // Test constant TIME vector with different sizes
+    setQueryTimeZone("America/Los_Angeles");
+
+    for (auto size : {1, 10, 100, 1000}) {
+      auto constantTimeVector = BaseVector::wrapInConstant(
+          size,
+          0,
+          makeFlatVector<int64_t>(
+              {3 * kMillisInHour + 4 * kMillisInMinute + 5 * kMillisInSecond +
+               321},
+              TIME()));
+
+      // LA is UTC-8, so offset is -8 * 60 = -480 minutes
+      // 03:04:05.321 local -> 11:04:05.321 UTC
+      auto expected = BaseVector::wrapInConstant(
+          size,
+          0,
+          makeFlatVector<int64_t>(
+              {packTimeWithTZ(
+                  11 * kMillisInHour + 4 * kMillisInMinute +
+                      5 * kMillisInSecond + 321,
+                  -480)},
+              TIME_WITH_TIME_ZONE()));
+
+      testCast(constantTimeVector, expected);
+    }
+  }
+
+  {
+    // Test basic cast for completeness
+    auto input =
+        makeFlatVector<int64_t>({0, 12 * kMillisInHour, 86399999}, TIME());
+
+    setQueryTimeZone("America/Los_Angeles");
+
+    // LA is UTC-8, local times are converted to UTC: local + 8 hours
+    auto expected = makeFlatVector<int64_t>(
+        {
+            // 00:00:00 local -> 08:00:00 UTC
+            packTimeWithTZ(8 * kMillisInHour, -480),
+            // 12:00:00 local -> 20:00:00 UTC
+            packTimeWithTZ(20 * kMillisInHour, -480),
+            // 23:59:59.999 local -> 07:59:59.999 UTC (wraps to next day)
+            packTimeWithTZ(
+                7 * kMillisInHour + 59 * kMillisInMinute +
+                    59 * kMillisInSecond + 999,
+                -480),
+        },
+        TIME_WITH_TIME_ZONE());
+
+    testCast(input, expected);
+  }
+
+  {
+    // Test with session start time during DST (summer)
+    // 2023-07-15 12:00:00 UTC (during DST in America/Los_Angeles)
+    // LA is UTC-7 during DST, so offset is -7 * 60 = -420 minutes
+    int64_t sessionStartMs = 1689426000000LL; // 2023-07-15 12:00:00 UTC
+    auto input = makeFlatVector<int64_t>(
+        {
+            0,
+            12 * kMillisInHour,
+            23 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond +
+                999,
+        },
+        TIME());
+
+    setQueryTimeZoneAndStartTime("America/Los_Angeles", sessionStartMs);
+
+    // During DST, LA is UTC-7 (PDT), so offset is -420 minutes
+    // Local times are converted to UTC: local - (-7 hours) = local + 7 hours
+    auto expected = makeFlatVector<int64_t>(
+        {
+            // 00:00:00 local -> 07:00:00 UTC
+            packTimeWithTZ(7 * kMillisInHour, -420),
+            // 12:00:00 local -> 19:00:00 UTC
+            packTimeWithTZ(19 * kMillisInHour, -420),
+            // 23:59:59.999 local -> 06:59:59.999 UTC (next day wraps to
+            // 06:59:59.999)
+            packTimeWithTZ(
+                6 * kMillisInHour + 59 * kMillisInMinute +
+                    59 * kMillisInSecond + 999,
+                -420),
+        },
+        TIME_WITH_TIME_ZONE());
+
+    testCast(input, expected);
+  }
+
+  {
+    // Test with session start time during standard time (winter)
+    // 2023-01-15 12:00:00 UTC (during standard time in America/Los_Angeles)
+    // LA is UTC-8 during standard time, so offset is -8 * 60 = -480 minutes
+    int64_t sessionStartMs = 1673779200000LL; // 2023-01-15 12:00:00 UTC
+    auto input = makeFlatVector<int64_t>(
+        {
+            0,
+            12 * kMillisInHour,
+            23 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond +
+                999,
+        },
+        TIME());
+
+    setQueryTimeZoneAndStartTime("America/Los_Angeles", sessionStartMs);
+
+    // During standard time, LA is UTC-8 (PST), so offset is -480 minutes
+    // Local times are converted to UTC: local - (-8 hours) = local + 8 hours
+    auto expected = makeFlatVector<int64_t>(
+        {
+            // 00:00:00 local -> 08:00:00 UTC
+            packTimeWithTZ(8 * kMillisInHour, -480),
+            // 12:00:00 local -> 20:00:00 UTC
+            packTimeWithTZ(20 * kMillisInHour, -480),
+            // 23:59:59.999 local -> 07:59:59.999 UTC (next day wraps to
+            // 07:59:59.999)
+            packTimeWithTZ(
+                7 * kMillisInHour + 59 * kMillisInMinute +
+                    59 * kMillisInSecond + 999,
+                -480),
+        },
+        TIME_WITH_TIME_ZONE());
+
+    testCast(input, expected);
+  }
+}
+
+TEST_F(TimeWithTimezoneCastTest, fromTimeVerifyUtcStorage) {
+  // This test verifies that when casting TIME to TIME WITH TIME ZONE,
+  // the time component is stored as UTC milliseconds, not local milliseconds.
+  // TIME WITH TIME ZONE stores:
+  // - Upper 52 bits: UTC milliseconds since midnight
+  // - Lower 12 bits: timezone offset
+
+  {
+    // TIME '14:00:00' in America/Los_Angeles (UTC-8)
+    // Local time: 14:00:00 -> UTC time: 22:00:00
+    auto input = makeFlatVector<int64_t>(
+        {
+            14 * kMillisInHour, // 14:00:00 local
+        },
+        TIME());
+
+    setQueryTimeZone("America/Los_Angeles");
+    // LA is UTC-8, so offset is -8 * 60 = -480 minutes
+
+    // Cast TIME to TIME WITH TIME ZONE using testCast
+    auto expected = makeFlatVector<int64_t>(
+        {
+            packTimeWithTZ(22 * kMillisInHour, -480), // Expected: UTC 22:00
+        },
+        TIME_WITH_TIME_ZONE());
+
+    // This will fail with the current buggy implementation
+    testCast(input, expected);
+  }
+
+  {
+    // TIME '06:00:00' in Asia/Shanghai (UTC+8)
+    // Local time: 06:00:00 -> UTC time: 22:00:00 (previous day)
+    auto input = makeFlatVector<int64_t>(
+        {
+            6 * kMillisInHour, // 06:00:00 local
+        },
+        TIME());
+
+    setQueryTimeZone("Asia/Shanghai");
+    // Shanghai is UTC+8, so offset is 8 * 60 = 480 minutes
+
+    auto expected = makeFlatVector<int64_t>(
+        {
+            // BUG: This will fail because current code stores local time
+            // (06:00), not UTC time (22:00)
+            packTimeWithTZ(22 * kMillisInHour, 480), // Expected: UTC 22:00
+        },
+        TIME_WITH_TIME_ZONE());
+
+    testCast(input, expected);
+  }
+
+  {
+    // Test case 3: Round-trip test
+    // TIME -> TIME WITH TIME ZONE -> TIME should preserve the original value
+    auto input = makeFlatVector<int64_t>(
+        {
+            14 * kMillisInHour + 30 * kMillisInMinute, // 14:30:00
+        },
+        TIME());
+
+    setQueryTimeZone("America/Los_Angeles");
+
+    // First cast TIME to TIME WITH TIME ZONE
+    auto timeWithTzExpected = makeFlatVector<int64_t>(
+        {
+            // UTC time should be 22:30:00 (14:30 - (-8:00) = 22:30)
+            packTimeWithTZ(22 * kMillisInHour + 30 * kMillisInMinute, -480),
+        },
+        TIME_WITH_TIME_ZONE());
+
+    testCast(input, timeWithTzExpected);
+
+    // Then cast back to TIME - should preserve original local time
+    auto timeExpected = makeFlatVector<int64_t>(
+        {
+            14 * kMillisInHour + 30 * kMillisInMinute,
+        },
+        TIME());
+
+    testCast(timeWithTzExpected, timeExpected);
+  }
+
+  {
+    // Verify consistency with fromVarchar
+    // Casting "14:00:00-08:00" from VARCHAR should produce the same result
+    // as casting TIME '14:00:00' with America/Los_Angeles timezone
+
+    setQueryTimeZone("America/Los_Angeles");
+
+    // Cast TIME to TIME WITH TIME ZONE
+    auto timeInput = makeFlatVector<int64_t>({14 * kMillisInHour}, TIME());
+
+    // Cast VARCHAR to TIME WITH TIME ZONE
+    auto varcharInput = makeFlatVector<std::string>({"14:00:00.000-08:00"});
+
+    // Both should produce the same result: UTC 22:00:00 with offset -480
+    auto expected = makeFlatVector<int64_t>(
+        {
+            packTimeWithTZ(22 * kMillisInHour, -480),
+        },
+        TIME_WITH_TIME_ZONE());
+
+    // Test TIME cast
+    testCast(timeInput, expected);
+
+    // Test VARCHAR cast
+    testCast(varcharInput, expected);
+  }
+}
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/tests/TimestampWithTimeZoneCastTest.cpp b/velox/functions/prestosql/tests/TimestampWithTimeZoneCastTest.cpp
index d4f973e99fa..44b18a0803e 100644
--- a/velox/functions/prestosql/tests/TimestampWithTimeZoneCastTest.cpp
+++ b/velox/functions/prestosql/tests/TimestampWithTimeZoneCastTest.cpp
@@ -16,6 +16,7 @@
 
 #include "velox/functions/prestosql/tests/CastBaseTest.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/type/TimestampConversion.h"
 #include "velox/type/tz/TimeZoneMap.h"
 
 namespace facebook::velox {
@@ -36,6 +37,22 @@ class TimestampWithTimeZoneCastTest : public functions::test::CastBaseTest {
         TIMESTAMP_WITH_TIME_ZONE());
   }
 
+  // Helper to parse a timestamp with timezone string and return packed value
+  // e.g., "2023-08-05 10:15:00.000 Europe/London"
+  int64_t parseTimestampWithTz(const std::string& str) {
+    auto parsed =
+        util::fromTimestampWithTimezoneString(
+            str.c_str(), str.size(), util::TimestampParseMode::kPrestoCast)
+            .thenOrThrow(folly::identity, [&](const Status& status) {
+              VELOX_USER_FAIL("{}", status.message());
+            });
+
+    // The parsed timestamp is in local time, need to convert to UTC
+    auto ts = parsed.timestamp;
+    ts.toGMT(*parsed.timeZone);
+    return pack(ts.toMillis(), parsed.timeZone->id());
+  }
+
  protected:
   void setQueryTimeZone(const std::string& timeZone) {
     queryCtx_->testingOverrideConfigUnsafe({
@@ -44,6 +61,16 @@ class TimestampWithTimeZoneCastTest : public functions::test::CastBaseTest {
     });
   }
 
+  void setQueryTimeZoneAndStartTime(
+      const std::string& timeZone,
+      int64_t startTimeMs) {
+    queryCtx_->testingOverrideConfigUnsafe({
+        {core::QueryConfig::kSessionTimezone, timeZone},
+        {core::QueryConfig::kAdjustTimestampToTimezone, "true"},
+        {core::QueryConfig::kSessionStartTime, std::to_string(startTimeMs)},
+    });
+  }
+
   void disableAdjustTimestampToTimezone() {
     queryCtx_->testingOverrideConfigUnsafe({
         {core::QueryConfig::kAdjustTimestampToTimezone, "false"},
@@ -314,5 +341,351 @@ TEST_F(TimestampWithTimeZoneCastTest, fromDate) {
   test::assertEqualVectors(expected, result);
 }
 
+TEST_F(TimestampWithTimeZoneCastTest, fromTime) {
+  {
+    // Test casting TIME to TIMESTAMP WITH TIME ZONE with default session start
+    // time (epoch). TIME values represent time since midnight (in milliseconds)
+    auto input = makeFlatVector<int64_t>(
+        {
+            0, // 00:00:00.000 (midnight)
+            3 * kMillisInHour + 4 * kMillisInMinute + 5 * kMillisInSecond +
+                321, // 03:04:05.321
+            12 * kMillisInHour, // 12:00:00.000 (noon)
+            23 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond +
+                999, // 23:59:59.999 (end of day)
+        },
+        TIME());
+
+    setQueryTimeZone("America/Los_Angeles");
+
+    auto tzId = tz::getTimeZoneID("America/Los_Angeles");
+    // When session start time is not set (default = 0), uses epoch (1970-01-01)
+    // LA is -8 hours from UTC (PST), so 00:00:00 PST = 08:00:00 UTC
+    auto expected = makeFlatVector<int64_t>(
+        {
+            pack(8 * kMillisInHour, tzId), // 00:00:00.000 PST -> 08:00:00 UTC
+            pack(
+                3 * kMillisInHour + 4 * kMillisInMinute + 5 * kMillisInSecond +
+                    321 + 8 * kMillisInHour,
+                tzId), // 03:04:05.321 PST -> 11:04:05.321 UTC
+            pack(
+                12 * kMillisInHour + 8 * kMillisInHour,
+                tzId), // 12:00:00.000 PST -> 20:00:00 UTC
+            pack(
+                23 * kMillisInHour + 59 * kMillisInMinute +
+                    59 * kMillisInSecond + 999 + 8 * kMillisInHour,
+                tzId), // 23:59:59.999 PST -> 07:59:59.999 UTC (next day)
+        },
+        TIMESTAMP_WITH_TIME_ZONE());
+
+    auto result = evaluate(
+        "cast(c0 as timestamp with time zone)", makeRowVector({input}));
+    test::assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test casting TIME to TIMESTAMP WITH TIME ZONE with session start time set
+    // to 2023-01-15 10:30:00 UTC (1673780400000 ms)
+    // This should use the date from session start time (2023-01-15), not epoch
+    auto input = makeFlatVector<int64_t>(
+        {
+            0, // 00:00:00.000 (midnight)
+            12 * kMillisInHour, // 12:00:00.000 (noon)
+            23 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond +
+                999, // 23:59:59.999
+        },
+        TIME());
+
+    // Session start time: 2023-01-15 10:30:00 UTC = 1673779800000 ms
+    // In LA timezone (PST, -8 hours), this is 2023-01-15 02:30:00 PST
+    // The date portion is 2023-01-15, which is 19372 days from epoch
+    // 2023-01-15 00:00:00 UTC = 19372 * 86400 * 1000 = 1673740800000 ms
+    int64_t sessionStartMs = 1673779800000LL; // 2023-01-15 10:30:00 UTC
+    setQueryTimeZoneAndStartTime("America/Los_Angeles", sessionStartMs);
+
+    auto tzId = tz::getTimeZoneID("America/Los_Angeles");
+    // Date portion: 2023-01-15 in LA timezone = 2023-01-15 00:00:00 PST
+    // = 2023-01-15 08:00:00 UTC = 1673740800000 + 8*3600*1000 = 1673769600000
+    int64_t dateBaseMs = 1673769600000LL; // 2023-01-15 00:00:00 UTC
+    auto expected = makeFlatVector<int64_t>(
+        {
+            pack(
+                dateBaseMs,
+                tzId), // 2023-01-15 00:00:00.000 PST in UTC
+            pack(
+                dateBaseMs + 12 * kMillisInHour,
+                tzId), // 2023-01-15 12:00:00.000 PST in UTC
+            pack(
+                dateBaseMs + 23 * kMillisInHour + 59 * kMillisInMinute +
+                    59 * kMillisInSecond + 999,
+                tzId), // 2023-01-15 23:59:59.999 PST in UTC
+        },
+        TIMESTAMP_WITH_TIME_ZONE());
+
+    auto result = evaluate(
+        "cast(c0 as timestamp with time zone)", makeRowVector({input}));
+    test::assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test with nulls
+    auto input = makeNullableFlatVector<int64_t>(
+        {0,
+         std::nullopt,
+         12 * kMillisInHour,
+         std::nullopt,
+         23 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond +
+             999},
+        TIME());
+
+    setQueryTimeZone("America/Los_Angeles");
+
+    auto tzId = tz::getTimeZoneID("America/Los_Angeles");
+    auto expected = makeNullableFlatVector<int64_t>(
+        {pack(8 * kMillisInHour, tzId),
+         std::nullopt,
+         pack(12 * kMillisInHour + 8 * kMillisInHour, tzId),
+         std::nullopt,
+         pack(
+             23 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond +
+                 999 + 8 * kMillisInHour,
+             tzId)},
+        TIMESTAMP_WITH_TIME_ZONE());
+
+    auto result = evaluate(
+        "cast(c0 as timestamp with time zone)", makeRowVector({input}));
+    test::assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test with different timezone (Asia/Shanghai, +8 hours from UTC)
+    auto input = makeFlatVector<int64_t>(
+        {
+            0,
+            12 * kMillisInHour,
+            23 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond +
+                999,
+        },
+        TIME());
+
+    setQueryTimeZone("Asia/Shanghai");
+
+    auto tzId = tz::getTimeZoneID("Asia/Shanghai");
+    // Shanghai is +8 hours from UTC, so 00:00:00 Shanghai = 16:00:00 UTC (prev
+    // day)
+    auto expected = makeFlatVector<int64_t>(
+        {
+            pack(
+                -8 * kMillisInHour,
+                tzId), // 00:00:00 CST -> 16:00:00 UTC (prev day)
+            pack(
+                12 * kMillisInHour - 8 * kMillisInHour,
+                tzId), // 12:00:00 CST -> 04:00:00 UTC
+            pack(
+                23 * kMillisInHour + 59 * kMillisInMinute +
+                    59 * kMillisInSecond + 999 - 8 * kMillisInHour,
+                tzId), // 23:59:59.999 CST -> 15:59:59.999 UTC
+        },
+        TIMESTAMP_WITH_TIME_ZONE());
+
+    auto result = evaluate(
+        "cast(c0 as timestamp with time zone)", makeRowVector({input}));
+    test::assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test with adjustTimestampToTimezone disabled
+    // When disabled, TIME values are treated as already in UTC
+    auto input = makeFlatVector<int64_t>(
+        {
+            0,
+            3 * kMillisInHour + 4 * kMillisInMinute + 5 * kMillisInSecond + 321,
+            12 * kMillisInHour,
+        },
+        TIME());
+
+    setQueryTimeZone("Asia/Shanghai");
+    disableAdjustTimestampToTimezone();
+
+    auto tzId = tz::getTimeZoneID("Asia/Shanghai");
+    auto expected = makeFlatVector<int64_t>(
+        {
+            pack(0, tzId),
+            pack(
+                3 * kMillisInHour + 4 * kMillisInMinute + 5 * kMillisInSecond +
+                    321,
+                tzId),
+            pack(12 * kMillisInHour, tzId),
+        },
+        TIMESTAMP_WITH_TIME_ZONE());
+
+    auto result = evaluate(
+        "cast(c0 as timestamp with time zone)", makeRowVector({input}));
+    test::assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test constant TIME vector cast to TIMESTAMP WITH TIME ZONE (non-null)
+    // This tests the optimization path for constant vectors
+    auto constantTimeVector = BaseVector::wrapInConstant(
+        1000, 0, makeFlatVector<int64_t>({12 * kMillisInHour}, TIME()));
+
+    setQueryTimeZone("America/New_York");
+
+    auto tzId = tz::getTimeZoneID("America/New_York");
+    // NY is -5 hours from UTC (EST), so 12:00:00 EST = 17:00:00 UTC
+
+    auto result = evaluate(
+        "cast(c0 as timestamp with time zone)",
+        makeRowVector({constantTimeVector}));
+
+    // Should return a constant vector with the adjusted value
+    auto expected = BaseVector::wrapInConstant(
+        1000,
+        0,
+        makeFlatVector<int64_t>(
+            {pack(12 * kMillisInHour + 5 * kMillisInHour, tzId)},
+            TIMESTAMP_WITH_TIME_ZONE()));
+
+    test::assertEqualVectors(expected, result);
+    // Verify the result is actually constant-encoded (optimization worked)
+    ASSERT_TRUE(result->isConstantEncoding());
+  }
+
+  {
+    // Test constant TIME vector cast to TIMESTAMP WITH TIME ZONE (null)
+    // This tests the optimization path for null constant vectors
+    auto nullTimeVector = BaseVector::createNullConstant(TIME(), 500, pool());
+
+    setQueryTimeZone("America/Los_Angeles");
+
+    auto result = evaluate(
+        "cast(c0 as timestamp with time zone)",
+        makeRowVector({nullTimeVector}));
+
+    // Should return a null constant vector
+    auto expected =
+        BaseVector::createNullConstant(TIMESTAMP_WITH_TIME_ZONE(), 500, pool());
+
+    test::assertEqualVectors(expected, result);
+    // Verify the result is actually constant-encoded (optimization worked)
+    ASSERT_TRUE(result->isConstantEncoding());
+    ASSERT_TRUE(result->isNullAt(0));
+  }
+
+  {
+    // Test constant TIME vector with different sizes
+    // This ensures the optimization correctly handles different vector sizes
+    setQueryTimeZone("America/Los_Angeles");
+    auto tzId = tz::getTimeZoneID("America/Los_Angeles");
+
+    for (auto size : {1, 10, 100, 1000}) {
+      auto constantTimeVector = BaseVector::wrapInConstant(
+          size,
+          0,
+          makeFlatVector<int64_t>(
+              {3 * kMillisInHour + 4 * kMillisInMinute + 5 * kMillisInSecond +
+               321},
+              TIME()));
+
+      auto result = evaluate(
+          "cast(c0 as timestamp with time zone)",
+          makeRowVector({constantTimeVector}));
+
+      auto expected = BaseVector::wrapInConstant(
+          size,
+          0,
+          makeFlatVector<int64_t>(
+              {pack(
+                  3 * kMillisInHour + 4 * kMillisInMinute +
+                      5 * kMillisInSecond + 321 + 8 * kMillisInHour,
+                  tzId)},
+              TIMESTAMP_WITH_TIME_ZONE()));
+
+      test::assertEqualVectors(expected, result);
+      ASSERT_TRUE(result->isConstantEncoding());
+      ASSERT_EQ(result->size(), size);
+    }
+  }
+
+  {
+    // Test try_cast for TIME to TIMESTAMP WITH TIME ZONE
+    auto input =
+        makeFlatVector<int64_t>({0, 12 * kMillisInHour, 86399999}, TIME());
+
+    setQueryTimeZone("America/Los_Angeles");
+
+    auto tzId = tz::getTimeZoneID("America/Los_Angeles");
+    auto expected = makeFlatVector<int64_t>(
+        {
+            pack(8 * kMillisInHour, tzId), // 00:00:00 PST -> 08:00:00 UTC
+            pack(
+                12 * kMillisInHour + 8 * kMillisInHour,
+                tzId), // 12:00:00 PST -> 20:00:00 UTC
+            pack(
+                86399999 + 8 * kMillisInHour,
+                tzId), // 23:59:59.999 PST -> 07:59:59.999 UTC (next day)
+        },
+        TIMESTAMP_WITH_TIME_ZONE());
+
+    auto result = evaluate(
+        "try_cast(c0 as timestamp with time zone)", makeRowVector({input}));
+    test::assertEqualVectors(expected, result);
+  }
+}
+
+TEST_F(TimestampWithTimeZoneCastTest, toTime) {
+  // Test casting TIMESTAMP WITH TIME ZONE to TIME
+  // The TIME value should represent the local time in the given timezone
+  // This matches Presto's behavior (see TestTimestampWithTimeZone.java:34-59)
+
+  // Test data with named timezones to verify DST handling
+  // DST rules are applied based on the UTC timestamp's date, not current date
+  auto input = makeNullableFlatVector<int64_t>(
+      {// May 15, 2023 10:30:45.123 EDT (America/New_York in DST)
+       parseTimestampWithTz("2023-05-15 10:30:45.123 America/New_York"),
+       // January 10, 2023 08:15:30.500 GMT (Europe/London in standard time)
+       parseTimestampWithTz("2023-01-10 08:15:30.500 Europe/London"),
+       // January 15, 2023 09:30:00.000 EST (America/New_York in standard time)
+       parseTimestampWithTz("2023-01-15 09:30:00.000 America/New_York"),
+       // August 5, 2023 10:15:00.000 BST (Europe/London in DST)
+       parseTimestampWithTz("2023-08-05 10:15:00.000 Europe/London"),
+       // July 20, 2023 08:59:59.999 JST (Asia/Tokyo, no DST)
+       parseTimestampWithTz("2023-07-21 08:59:59.999 Asia/Tokyo"),
+       // Epoch in UTC
+       parseTimestampWithTz("1970-01-01 00:00:00.000 UTC"),
+       // December 24, 2023 22:00:00.000 PST (America/Los_Angeles in standard
+       // time)
+       parseTimestampWithTz("2023-12-24 22:00:00.000 America/Los_Angeles"),
+       // Null value
+       std::nullopt,
+       // Presto test case: 2001-01-22 03:04:05.321 +07:09
+       parseTimestampWithTz("2001-01-22 03:04:05.321 +07:09")},
+      TIMESTAMP_WITH_TIME_ZONE());
+
+  auto expected = makeNullableFlatVector<int64_t>(
+      {// 10:30:45.123
+       10 * kMillisInHour + 30 * kMillisInMinute + 45 * kMillisInSecond + 123,
+       // 08:15:30.500
+       8 * kMillisInHour + 15 * kMillisInMinute + 30 * kMillisInSecond + 500,
+       // 09:30:00.000 (EST, demonstrates standard time for America/New_York)
+       9 * kMillisInHour + 30 * kMillisInMinute,
+       // 10:15:00.000 (BST, demonstrates DST for Europe/London)
+       10 * kMillisInHour + 15 * kMillisInMinute,
+       // 08:59:59.999
+       8 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond + 999,
+       // 00:00:00.000
+       0,
+       // 22:00:00.000
+       22 * kMillisInHour,
+       // Null value
+       std::nullopt,
+       // 03:04:05.321
+       3 * kMillisInHour + 4 * kMillisInMinute + 5 * kMillisInSecond + 321},
+      TIME());
+
+  testCast(input, expected);
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/tests/TransformWithIndexTest.cpp b/velox/functions/prestosql/tests/TransformWithIndexTest.cpp
new file mode 100644
index 00000000000..2e854e91bf6
--- /dev/null
+++ b/velox/functions/prestosql/tests/TransformWithIndexTest.cpp
@@ -0,0 +1,657 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class TransformWithIndexTest : public test::FunctionBaseTest {};
+
+TEST_F(TransformWithIndexTest, basic) {
+  auto data = makeRowVector({
+      makeArrayVector<int64_t>({
+          {1, 2, 3},
+          {4, 5},
+          {6, 7, 8, 9},
+          {},
+      }),
+  });
+
+  // Transform each element to elem * index
+  auto result = evaluate("transform_with_index(c0, (x, i) -> x * i)", data);
+
+  // Expected: [[1*1, 2*2, 3*3], [4*1, 5*2], [6*1, 7*2, 8*3, 9*4], []]
+  auto expected = makeArrayVector<int64_t>({
+      {1, 4, 9},
+      {4, 10},
+      {6, 14, 24, 36},
+      {},
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(TransformWithIndexTest, useOnlyIndex) {
+  auto data = makeRowVector({
+      makeArrayVector<int64_t>({
+          {100, 200, 300},
+          {10, 20},
+          {},
+      }),
+  });
+
+  // Transform each element to just the index
+  auto result = evaluate("transform_with_index(c0, (x, i) -> i)", data);
+
+  // Expected: indices are 1-based
+  auto expected = makeArrayVector<int64_t>({
+      {1, 2, 3},
+      {1, 2},
+      {},
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(TransformWithIndexTest, useOnlyElement) {
+  auto data = makeRowVector({
+      makeArrayVector<int64_t>({
+          {1, 2, 3},
+          {4, 5},
+          {},
+      }),
+  });
+
+  // Transform each element using only the element (ignoring index)
+  auto result = evaluate("transform_with_index(c0, (x, i) -> x + 100)", data);
+
+  auto expected = makeArrayVector<int64_t>({
+      {101, 102, 103},
+      {104, 105},
+      {},
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(TransformWithIndexTest, stringArray) {
+  auto data = makeRowVector({
+      makeArrayVector<StringView>({
+          {"apple", "banana", "cherry"},
+          {"hello", "world"},
+          {},
+      }),
+  });
+
+  // Concatenate element with its index
+  auto result = evaluate(
+      "transform_with_index(c0, (x, i) -> concat(x, cast(i as varchar)))",
+      data);
+
+  auto expected = makeArrayVector<StringView>({
+      {"apple1", "banana2", "cherry3"},
+      {"hello1", "world2"},
+      {},
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(TransformWithIndexTest, nullElements) {
+  auto data = makeRowVector({
+      makeNullableArrayVector<int64_t>({
+          {1, std::nullopt, 3},
+          {std::nullopt, 5},
+          {6, 7, std::nullopt, 9},
+      }),
+  });
+
+  // When element is null, index is still available
+  auto result = evaluate("transform_with_index(c0, (x, i) -> i)", data);
+
+  // Indices are still generated for null elements
+  auto expected = makeArrayVector<int64_t>({
+      {1, 2, 3},
+      {1, 2},
+      {1, 2, 3, 4},
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(TransformWithIndexTest, nullElementsInComputation) {
+  auto data = makeRowVector({
+      makeNullableArrayVector<int64_t>({
+          {1, std::nullopt, 3},
+          {std::nullopt, 5},
+      }),
+  });
+
+  // When computing x + i, null element results in null
+  auto result = evaluate("transform_with_index(c0, (x, i) -> x + i)", data);
+
+  auto expected = makeNullableArrayVector<int64_t>({
+      {2, std::nullopt, 6},
+      {std::nullopt, 7},
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(TransformWithIndexTest, nullArray) {
+  auto data = makeRowVector({
+      makeNullableArrayVector<int64_t>({
+          {{1, 2, 3}},
+          std::nullopt,
+          {{4, 5}},
+      }),
+  });
+
+  auto result = evaluate("transform_with_index(c0, (x, i) -> x + i)", data);
+
+  auto expected = makeNullableArrayVector<int64_t>({
+      {{2, 4, 6}},
+      std::nullopt,
+      {{5, 7}},
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(TransformWithIndexTest, floatArray) {
+  auto data = makeRowVector({
+      makeArrayVector<double>({
+          {1.5, 2.5, 3.5},
+          {0.5, 0.25},
+      }),
+  });
+
+  // elem * index - need to cast index to double for multiplication
+  auto result = evaluate(
+      "transform_with_index(c0, (x, i) -> x * cast(i as double))", data);
+
+  auto expected = makeArrayVector<double>({
+      {1.5, 5.0, 10.5},
+      {0.5, 0.5},
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(TransformWithIndexTest, conditional) {
+  auto data = makeRowVector({
+      makeArrayVector<int64_t>({
+          {1, 2, 3, 4, 5},
+          {10, 20, 30},
+      }),
+  });
+
+  // Return element for odd indices, index for even indices
+  auto result =
+      evaluate("transform_with_index(c0, (x, i) -> if(i % 2 = 1, x, i))", data);
+
+  auto expected = makeArrayVector<int64_t>({
+      {1, 2, 3, 4, 5}, // indices 1, 2, 3, 4, 5: odd (1, 3, 5) -> elem, even (2,
+                       // 4) -> index
+      {10, 2, 30}, // indices 1, 2, 3: odd (1, 3) -> elem, even (2) -> index
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(TransformWithIndexTest, emptyArray) {
+  auto data = makeRowVector({
+      makeArrayVector<int64_t>({
+          {},
+          {},
+      }),
+  });
+
+  auto result = evaluate("transform_with_index(c0, (x, i) -> x * i)", data);
+
+  auto expected = makeArrayVector<int64_t>({
+      {},
+      {},
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(TransformWithIndexTest, singleElement) {
+  auto data = makeRowVector({
+      makeArrayVector<int64_t>({
+          {42},
+          {100},
+      }),
+  });
+
+  auto result = evaluate("transform_with_index(c0, (x, i) -> x + i)", data);
+
+  // index is 1-based, so single element gets index 1
+  auto expected = makeArrayVector<int64_t>({
+      {43},
+      {101},
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(TransformWithIndexTest, largeArray) {
+  std::vector<int64_t> largeInput;
+  std::vector<int64_t> largeExpected;
+  for (int64_t i = 0; i < 1000; ++i) {
+    largeInput.push_back(i);
+    largeExpected.push_back(i * (i + 1)); // elem * (1-based index)
+  }
+
+  auto data = makeRowVector({
+      makeArrayVector<int64_t>({largeInput}),
+  });
+
+  auto result = evaluate("transform_with_index(c0, (x, i) -> x * i)", data);
+
+  auto expected = makeArrayVector<int64_t>({largeExpected});
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(TransformWithIndexTest, typeChange) {
+  auto data = makeRowVector({
+      makeArrayVector<int32_t>({
+          {1, 2, 3},
+          {4, 5},
+      }),
+  });
+
+  // Transform to double
+  auto result = evaluate(
+      "transform_with_index(c0, (x, i) -> cast(x as double) / cast(i as double))",
+      data);
+
+  auto expected = makeArrayVector<double>({
+      {1.0, 1.0, 1.0},
+      {4.0, 2.5},
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(TransformWithIndexTest, captureClosure) {
+  auto data = makeRowVector({
+      makeArrayVector<int64_t>({
+          {1, 2, 3},
+          {4, 5, 6},
+      }),
+      makeFlatVector<int64_t>({10, 100}),
+  });
+
+  // Use captured variable c1 in the lambda
+  auto result =
+      evaluate("transform_with_index(c0, (x, i) -> x + i + c1)", data);
+
+  auto expected = makeArrayVector<int64_t>({
+      {12, 14, 16}, // 1+1+10, 2+2+10, 3+3+10
+      {105, 107, 109}, // 4+1+100, 5+2+100, 6+3+100
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(TransformWithIndexTest, booleanArray) {
+  auto data = makeRowVector({
+      makeArrayVector<bool>({
+          {true, false, true, false},
+          {false, true},
+      }),
+  });
+
+  // Return true for odd indices, false for even
+  auto result = evaluate("transform_with_index(c0, (x, i) -> i % 2 = 1)", data);
+
+  auto expected = makeArrayVector<bool>({
+      {true, false, true, false},
+      {true, false},
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(TransformWithIndexTest, nestedArray) {
+  // Test with array of arrays using a simpler construction
+  auto data = makeRowVector({
+      makeNestedArrayVectorFromJson<int64_t>({
+          "[[1, 2], [3, 4, 5]]",
+          "[[6], [7, 8], [9, 10, 11, 12]]",
+      }),
+  });
+
+  // Return the size of each inner array multiplied by index
+  auto result =
+      evaluate("transform_with_index(c0, (x, i) -> cardinality(x) * i)", data);
+
+  // Row 0: [[1,2], [3,4,5]] -> [size(2)*1, size(3)*2] = [2, 6]
+  // Row 1: [[6], [7,8], [9,10,11,12]] -> [size(1)*1, size(2)*2, size(4)*3] =
+  // [1, 4, 12]
+  auto expected = makeArrayVector<int64_t>({
+      {2, 6},
+      {1, 4, 12},
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+} // namespace
+
+// ============================================================================
+// CUSTOM FUZZER TESTS
+// These tests use VectorFuzzer to generate random inputs and verify
+// properties of transform_with_index:
+// 1. Output array size equals input array size
+// 2. When using only index, values are 1-based sequential (1, 2, 3, ...)
+// 3. Function handles nulls correctly
+// ============================================================================
+
+class TransformWithIndexFuzzerTest : public test::FunctionBaseTest {
+ protected:
+  static SelectivityVector getNonNullRows(const RowVectorPtr& data) {
+    SelectivityVector nonNullRows(data->size());
+    for (vector_size_t i = 0; i < data->size(); ++i) {
+      bool hasNull = false;
+      for (vector_size_t j = 0; j < data->childrenSize(); ++j) {
+        if (data->childAt(j)->isNullAt(i)) {
+          hasNull = true;
+          break;
+        }
+      }
+      if (hasNull) {
+        nonNullRows.setValid(i, false);
+      }
+    }
+    nonNullRows.updateBounds();
+    return nonNullRows;
+  }
+
+  void testSizePreservation(const RowVectorPtr& data) {
+    auto nonNullRows = getNonNullRows(data);
+    if (nonNullRows.countSelected() == 0) {
+      return;
+    }
+
+    VectorPtr result;
+    try {
+      result = evaluate("transform_with_index(c0, (x, i) -> i)", data);
+    } catch (...) {
+      return;
+    }
+
+    if (!result) {
+      return;
+    }
+
+    auto inputArray = data->childAt(0)->as<ArrayVector>();
+    auto resultArray = result->as<ArrayVector>();
+    if (!inputArray || !resultArray) {
+      return;
+    }
+
+    for (auto i = 0; i < data->size(); ++i) {
+      if (!nonNullRows.isValid(i) || result->isNullAt(i)) {
+        continue;
+      }
+
+      if (data->childAt(0)->isNullAt(i)) {
+        continue;
+      }
+
+      auto inputSize = inputArray->sizeAt(i);
+      auto resultSize = resultArray->sizeAt(i);
+      ASSERT_EQ(resultSize, inputSize)
+          << "Result array size should equal input array size at row " << i;
+    }
+  }
+
+  void testIndexValues(const RowVectorPtr& data) {
+    auto nonNullRows = getNonNullRows(data);
+    if (nonNullRows.countSelected() == 0) {
+      return;
+    }
+
+    VectorPtr result;
+    try {
+      result = evaluate("transform_with_index(c0, (x, i) -> i)", data);
+    } catch (...) {
+      return;
+    }
+
+    if (!result) {
+      return;
+    }
+
+    auto inputArray = data->childAt(0)->as<ArrayVector>();
+    auto resultArray = result->as<ArrayVector>();
+    if (!inputArray || !resultArray) {
+      return;
+    }
+
+    auto resultElements = resultArray->elements()->as<FlatVector<int64_t>>();
+    if (!resultElements) {
+      return;
+    }
+
+    for (auto i = 0; i < data->size(); ++i) {
+      if (!nonNullRows.isValid(i) || result->isNullAt(i)) {
+        continue;
+      }
+
+      if (data->childAt(0)->isNullAt(i)) {
+        continue;
+      }
+
+      auto offset = resultArray->offsetAt(i);
+      auto size = resultArray->sizeAt(i);
+      for (auto j = 0; j < size; ++j) {
+        auto expectedIndex = j + 1;
+        auto actualIndex = resultElements->valueAt(offset + j);
+        ASSERT_EQ(actualIndex, expectedIndex)
+            << "Index should be 1-based at row " << i << ", element " << j;
+      }
+    }
+  }
+
+  template <typename T>
+  void runFuzzerTest(
+      const TypePtr& elementType,
+      vector_size_t vectorSize,
+      double nullRatio) {
+    VectorFuzzer::Options opts;
+    opts.vectorSize = vectorSize;
+    opts.nullRatio = nullRatio;
+    opts.containerLength = 10;
+    opts.containerVariableLength = true;
+    VectorFuzzer fuzzer(opts, pool());
+
+    auto inputArray = fuzzer.fuzz(ARRAY(elementType));
+    auto data = makeRowVector({inputArray});
+    testSizePreservation(data);
+    testIndexValues(data);
+  }
+};
+
+TEST_F(TransformWithIndexFuzzerTest, fuzzInteger) {
+  runFuzzerTest<int64_t>(BIGINT(), 100, 0.1);
+}
+
+TEST_F(TransformWithIndexFuzzerTest, fuzzSmallint) {
+  runFuzzerTest<int16_t>(SMALLINT(), 100, 0.1);
+}
+
+TEST_F(TransformWithIndexFuzzerTest, fuzzDouble) {
+  runFuzzerTest<double>(DOUBLE(), 100, 0.1);
+}
+
+TEST_F(TransformWithIndexFuzzerTest, fuzzVarchar) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 10;
+  opts.containerVariableLength = true;
+  opts.stringLength = 20;
+  opts.stringVariableLength = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  auto inputArray = fuzzer.fuzz(ARRAY(VARCHAR()));
+  auto data = makeRowVector({inputArray});
+  testSizePreservation(data);
+}
+
+TEST_F(TransformWithIndexFuzzerTest, fuzzHighNullRatio) {
+  runFuzzerTest<int64_t>(BIGINT(), 100, 0.5);
+}
+
+TEST_F(TransformWithIndexFuzzerTest, fuzzLargeVectors) {
+  runFuzzerTest<int64_t>(BIGINT(), 500, 0.1);
+}
+
+TEST_F(TransformWithIndexFuzzerTest, fuzzEmptyContainers) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 2;
+  opts.containerVariableLength = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  auto inputArray = fuzzer.fuzz(ARRAY(INTEGER()));
+  auto data = makeRowVector({inputArray});
+  testSizePreservation(data);
+  testIndexValues(data);
+}
+
+TEST_F(TransformWithIndexFuzzerTest, fuzzWithElementTransformation) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 10;
+  opts.containerVariableLength = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (int iter = 0; iter < 10; ++iter) {
+    auto inputArray = fuzzer.fuzz(ARRAY(BIGINT()));
+    auto data = makeRowVector({inputArray});
+
+    VectorPtr result;
+    try {
+      result = evaluate("transform_with_index(c0, (x, i) -> x + i)", data);
+    } catch (...) {
+      continue;
+    }
+
+    if (!result) {
+      continue;
+    }
+
+    auto inputArrayVec = data->childAt(0)->as<ArrayVector>();
+    auto resultArray = result->as<ArrayVector>();
+    if (!inputArrayVec || !resultArray) {
+      continue;
+    }
+
+    for (auto i = 0; i < data->size(); ++i) {
+      if (data->childAt(0)->isNullAt(i) || result->isNullAt(i)) {
+        continue;
+      }
+
+      ASSERT_EQ(resultArray->sizeAt(i), inputArrayVec->sizeAt(i))
+          << "Result array size should equal input array size at row " << i;
+    }
+  }
+}
+
+TEST_F(TransformWithIndexFuzzerTest, fuzzDictionaryEncoded) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 10;
+  opts.containerVariableLength = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (int iter = 0; iter < 10; ++iter) {
+    auto baseArray = fuzzer.fuzz(ARRAY(BIGINT()));
+    auto dictArray = fuzzer.fuzzDictionary(baseArray, opts.vectorSize);
+
+    auto data = makeRowVector({dictArray});
+
+    VectorPtr result;
+    try {
+      result = evaluate("transform_with_index(c0, (x, i) -> i)", data);
+    } catch (...) {
+      continue;
+    }
+
+    if (!result) {
+      continue;
+    }
+
+    ASSERT_NE(result, nullptr);
+  }
+}
+
+TEST_F(TransformWithIndexFuzzerTest, fuzzConditionalTransformation) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.1;
+  opts.containerLength = 10;
+  opts.containerVariableLength = true;
+  VectorFuzzer fuzzer(opts, pool());
+
+  for (int iter = 0; iter < 10; ++iter) {
+    auto inputArray = fuzzer.fuzz(ARRAY(BIGINT()));
+    auto data = makeRowVector({inputArray});
+
+    VectorPtr result;
+    try {
+      result = evaluate(
+          "transform_with_index(c0, (x, i) -> if(i % 2 = 1, x, i))", data);
+    } catch (...) {
+      continue;
+    }
+
+    if (!result) {
+      continue;
+    }
+
+    auto inputArrayVec = data->childAt(0)->as<ArrayVector>();
+    auto resultArray = result->as<ArrayVector>();
+    if (!inputArrayVec || !resultArray) {
+      continue;
+    }
+
+    for (auto i = 0; i < data->size(); ++i) {
+      if (data->childAt(0)->isNullAt(i) || result->isNullAt(i)) {
+        continue;
+      }
+
+      ASSERT_EQ(resultArray->sizeAt(i), inputArrayVec->sizeAt(i))
+          << "Result array size should equal input array size at row " << i;
+    }
+  }
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/TypeOfTest.cpp b/velox/functions/prestosql/tests/TypeOfTest.cpp
index 10e7da270ee..060b22bc7ad 100644
--- a/velox/functions/prestosql/tests/TypeOfTest.cpp
+++ b/velox/functions/prestosql/tests/TypeOfTest.cpp
@@ -20,9 +20,13 @@
 #include "velox/functions/prestosql/types/GeometryType.h"
 #include "velox/functions/prestosql/types/HyperLogLogType.h"
 #include "velox/functions/prestosql/types/JsonType.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
 #include "velox/functions/prestosql/types/P4HyperLogLogType.h"
 #include "velox/functions/prestosql/types/QDigestType.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
+#include "velox/functions/prestosql/types/SphericalGeographyType.h"
 #include "velox/functions/prestosql/types/TDigestType.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 #include "velox/functions/prestosql/types/VarcharEnumType.h"
 
@@ -57,7 +61,10 @@ TEST_F(TypeOfTest, basic) {
   EXPECT_EQ("varbinary", typeOf(VARBINARY()));
 
   EXPECT_EQ("timestamp", typeOf(TIMESTAMP()));
+  EXPECT_EQ("timestamp utc", typeOf(TIMESTAMP_UTC()));
   EXPECT_EQ("date", typeOf(DATE()));
+  EXPECT_EQ("time", typeOf(TIME()));
+  EXPECT_EQ("time micro utc", typeOf(TIME_MICRO_UTC()));
 
   EXPECT_EQ("unknown", typeOf(UNKNOWN()));
 
@@ -75,13 +82,17 @@ TEST_F(TypeOfTest, basic) {
 
 TEST_F(TypeOfTest, customTypes) {
   EXPECT_EQ("timestamp with time zone", typeOf(TIMESTAMP_WITH_TIME_ZONE()));
+  EXPECT_EQ("time with time zone", typeOf(TIME_WITH_TIME_ZONE()));
   EXPECT_EQ("bingtile", typeOf(BINGTILE()));
   EXPECT_EQ("geometry", typeOf(GEOMETRY()));
+  EXPECT_EQ("sphericalgeography", typeOf(SPHERICAL_GEOGRAPHY()));
 
   EXPECT_EQ("json", typeOf(JSON()));
 
   EXPECT_EQ("HyperLogLog", typeOf(HYPERLOGLOG()));
+  EXPECT_EQ("KHyperLogLog", typeOf(KHYPERLOGLOG()));
   EXPECT_EQ("P4HyperLogLog", typeOf(P4HYPERLOGLOG()));
+  EXPECT_EQ("SetDigest", typeOf(SETDIGEST()));
 
   EXPECT_EQ("tdigest(double)", typeOf(TDIGEST(DOUBLE())));
 
diff --git a/velox/functions/prestosql/tests/URLFunctionsTest.cpp b/velox/functions/prestosql/tests/URLFunctionsTest.cpp
index 19742ba36f7..22de905d021 100644
--- a/velox/functions/prestosql/tests/URLFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/URLFunctionsTest.cpp
@@ -553,6 +553,20 @@ TEST_F(URLFunctionsTest, extractParameter) {
       extractParam(
           "http://example.com/path1/p.php?k1=v1&k2=v2&k3%3Dv3.1%3Dv3.2%26k4=v4",
           "k3"));
+
+  // Test zero-width match edge case - parameters that could result in
+  // zero-width regex matches should not cause infinite loops
+  EXPECT_EQ(
+      std::nullopt,
+      extractParam("http://example.com/path1/p.php?&&&", "param"));
+  EXPECT_EQ(
+      "value",
+      extractParam("http://example.com/path1/p.php?&&&param=value", "param"));
+  // Test consecutive empty parameters
+  EXPECT_EQ(
+      std::nullopt,
+      extractParam("http://example.com/path1/p.php?&=&=&", "nonexistent"));
+  EXPECT_EQ("", extractParam("http://example.com/path1/p.php?key=", "key"));
 }
 
 TEST_F(URLFunctionsTest, urlEncode) {
diff --git a/velox/functions/prestosql/tests/ZipTest.cpp b/velox/functions/prestosql/tests/ZipTest.cpp
index 92e9166a998..7abe61d5e0c 100644
--- a/velox/functions/prestosql/tests/ZipTest.cpp
+++ b/velox/functions/prestosql/tests/ZipTest.cpp
@@ -69,7 +69,7 @@ TEST_F(ZipTest, combineInt) {
 
   auto firstResult = makeNullableFlatVector<int64_t>(
       {1, 1, 1, 1, 2, 2, 2, std::nullopt, std::nullopt});
-  auto secondResult = makeNullableFlatVector<std::string>(
+  auto secondResult = makeNullableFlatVector<StringView>(
       {S("a"),
        S("a"),
        S("a"),
@@ -127,17 +127,19 @@ TEST_F(ZipTest, arity) {
   std::vector<VectorPtr> inputs;
   for (auto i = 0; i < 7; i++) {
     if (i % 2 == 0) {
-      inputs.push_back(makeArrayVectorFromJson<int32_t>({
-          "[1, 1, 1, 1]",
-          "[2, 2, 2]",
-          "[3, 3]",
-      }));
+      inputs.push_back(
+          makeArrayVectorFromJson<int32_t>({
+              "[1, 1, 1, 1]",
+              "[2, 2, 2]",
+              "[3, 3]",
+          }));
     } else {
-      inputs.push_back(makeArrayVectorFromJson<double>({
-          "[1.1, 1.1, 1.1, 1.1]",
-          "[2.2, 2.2, 2.2]",
-          "[3.3, 3.3]",
-      }));
+      inputs.push_back(
+          makeArrayVectorFromJson<double>({
+              "[1.1, 1.1, 1.1, 1.1]",
+              "[2.2, 2.2, 2.2]",
+              "[3.3, 3.3]",
+          }));
     }
   }
 
diff --git a/velox/functions/prestosql/tests/resources/CMakeLists.txt b/velox/functions/prestosql/tests/resources/CMakeLists.txt
new file mode 100644
index 00000000000..51a69e5016c
--- /dev/null
+++ b/velox/functions/prestosql/tests/resources/CMakeLists.txt
@@ -0,0 +1,15 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+velox_add_library(velox_geometry_test_utils INTERFACE HEADERS GeometryTestUtils.h)
diff --git a/velox/functions/prestosql/tests/resources/GeometryTestUtils.h b/velox/functions/prestosql/tests/resources/GeometryTestUtils.h
new file mode 100644
index 00000000000..5ab62c5eb0a
--- /dev/null
+++ b/velox/functions/prestosql/tests/resources/GeometryTestUtils.h
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string_view>
+#include <unordered_map>
+namespace facebook::velox::geometry_test_utils {
+
+const inline std::unordered_map<std::string_view, double> usStateAreas{
+    {{"AK", 1512029420919.75}, {"AL", 133798433564.089},
+     {"AR", 138078359306.101}, {"AZ", 295735747077.462},
+     {"CA", 409564647161.456}, {"CO", 269308715698.849},
+     {"CT", 12873955652.9009}, {"DE", 5083481242.97432},
+     {"FL", 149761362689.816}, {"GA", 152560105310.888},
+     {"HI", 14715710071.3397}, {"IA", 146458043140.78},
+     {"ID", 215644605503.279}, {"IL", 146057753165.062},
+     {"IN", 93432145009.3321}, {"KS", 213667500120.875},
+     {"KY", 104609030725.925}, {"LA", 122087680157.417},
+     {"MA", 20641289915.7922}, {"MD", 33030573282.338},
+     {"ME", 84380140281.5444}, {"MI", 150263386643.448},
+     {"MN", 217052585631.816}, {"MO", 180004456640.739},
+     {"MS", 123528032272.534}, {"MT", 381032417364.706},
+     {"NC", 130662589411.403}, {"ND", 181977969472.119},
+     {"NE", 198367040634.306}, {"NH", 23917283751.4951},
+     {"NJ", 19994599703.4562}, {"NM", 314665412870.469},
+     {"NV", 286314845000.724}, {"NY", 126235067447.09},
+     {"OH", 106856948024.766}, {"OK", 182094848972.64},
+     {"OR", 250811798127.051}, {"PA", 117328433660.695},
+     {"RI", 2665065564.06665}, {"SC", 80925225017.8581},
+     {"SD", 201400533632.426}, {"TN", 109289108111.592},
+     {"TX", 687081639377.503}, {"UT", 219262788661.858},
+     {"VA", 254920255235320},  {"VT", 24673886252.5229},
+     {"WA", 176010024082.492}, {"WI", 144941233960.424},
+     {"WV", 63015759782.3764}, {"WY", 253076654001.191}}};
+
+const inline std::
+    unordered_map<std::string_view, std::string_view>
+        usStateWkts{
+            {{"AL",
+              "POLYGON ((-87.359296 35.00118, -85.606675 34.984749, -85.431413 34.124869, -85.184951 32.859696, -85.069935 32.580372, -84.960397 32.421541, -85.004212 32.322956, -84.889196 32.262709, -85.058981 32.13674, -85.053504 32.01077, -85.141136 31.840985, -85.042551 31.539753, -85.113751 31.27686, -85.004212 31.003013, -85.497137 30.997536, -87.600282 30.997536, -87.633143 30.86609, -87.408589 30.674397, -87.446927 30.510088, -87.37025 30.427934, -87.518128 30.280057, -87.655051 30.247195, -87.90699 30.411504, -87.934375 30.657966, -88.011052 30.685351, -88.10416 30.499135, -88.137022 30.318396, -88.394438 30.367688, -88.471115 31.895754, -88.241084 33.796253, -88.098683 34.891641, -88.202745 34.995703, -87.359296 35.00118))"},
+             {"AK",
+              "MULTIPOLYGON (((-131.602021 55.117982, -131.569159 55.28229, -131.355558 55.183705, -131.38842 55.01392, -131.645836 55.035827, -131.602021 55.117982)), ((-131.832052 55.42469, -131.645836 55.304197, -131.749898 55.128935, -131.832052 55.189182, -131.832052 55.42469)), ((-132.976733 56.437924, -132.735747 56.459832, -132.631685 56.421493, -132.664547 56.273616, -132.878148 56.240754, -133.069841 56.333862, -132.976733 56.437924)), ((-133.595627 56.350293, -133.162949 56.317431, -133.05341 56.125739, -132.620732 55.912138, -132.472854 55.780691, -132.4619 55.671152, -132.357838 55.649245, -132.341408 55.506844, -132.166146 55.364444, -132.144238 55.238474, -132.029222 55.276813, -131.97993 55.178228, -131.958022 54.789365, -132.029222 54.701734, -132.308546 54.718165, -132.385223 54.915335, -132.483808 54.898904, -132.686455 55.046781, -132.746701 54.997489, -132.916486 55.046781, -132.889102 54.898904, -132.73027 54.937242, -132.626209 54.882473, -132.675501 54.679826, -132.867194 54.701734, -133.157472 54.95915, -133.239626 55.090597, -133.223195 55.22752, -133.453227 55.216566, -133.453227 55.320628, -133.277964 55.331582, -133.102702 55.42469, -133.17938 55.588998, -133.387503 55.62186, -133.420365 55.884753, -133.497042 56.0162, -133.639442 55.923092, -133.694212 56.070969, -133.546335 56.142169, -133.666827 56.311955, -133.595627 56.350293)), ((-133.738027 55.556137, -133.546335 55.490413, -133.414888 55.572568, -133.283441 55.534229, -133.420365 55.386352, -133.633966 55.430167, -133.738027 55.556137)), ((-133.907813 56.930849, -134.050213 57.029434, -133.885905 57.095157, -133.343688 57.002049, -133.102702 57.007526, -132.932917 56.82131, -132.620732 56.667956, -132.653593 56.55294, -132.817901 56.492694, -133.042456 56.520078, -133.201287 56.448878, -133.420365 56.492694, -133.66135 56.448878, -133.710643 56.684386, -133.688735 56.837741, -133.869474 56.843218, -133.907813 56.930849)), ((-134.115936 56.48174, -134.25286 56.558417, -134.400737 56.722725, -134.417168 56.848695, -134.296675 56.908941, -134.170706 56.848695, -134.143321 56.952757, -133.748981 56.772017, -133.710643 56.596755, -133.847566 56.574848, -133.935197 56.377678, -133.836612 56.322908, -133.957105 56.092877, -134.110459 56.142169, -134.132367 55.999769, -134.230952 56.070969, -134.291198 56.350293, -134.115936 56.48174)), ((-134.636246 56.28457, -134.669107 56.169554, -134.806031 56.235277, -135.178463 56.67891, -135.413971 56.810356, -135.331817 56.914418, -135.424925 57.166357, -135.687818 57.369004, -135.419448 57.566174, -135.298955 57.48402, -135.063447 57.418296, -134.849846 57.407343, -134.844369 57.248511, -134.636246 56.728202, -134.636246 56.28457)), ((-134.712923 58.223407, -134.373353 58.14673, -134.176183 58.157683, -134.187137 58.081006, -133.902336 57.807159, -134.099505 57.850975, -134.148798 57.757867, -133.935197 57.615466, -133.869474 57.363527, -134.083075 57.297804, -134.154275 57.210173, -134.499322 57.029434, -134.603384 57.034911, -134.6472 57.226604, -134.575999 57.341619, -134.608861 57.511404, -134.729354 57.719528, -134.707446 57.829067, -134.784123 58.097437, -134.91557 58.212453, -134.953908 58.409623, -134.712923 58.223407)), ((-135.857603 57.330665, -135.715203 57.330665, -135.567326 57.149926, -135.633049 57.023957, -135.857603 56.996572, -135.824742 57.193742, -135.857603 57.330665)), ((-136.279328 58.206976, -135.978096 58.201499, -135.780926 58.28913, -135.496125 58.168637, -135.64948 58.037191, -135.59471 57.987898, -135.45231 58.135776, -135.107263 58.086483, -134.91557 57.976944, -135.025108 57.779775, -134.937477 57.763344, -134.822462 57.500451, -135.085355 57.462112, -135.572802 57.675713, -135.556372 57.456635, -135.709726 57.369004, -135.890465 57.407343, -136.000004 57.544266, -136.208128 57.637374, -136.366959 57.829067, -136.569606 57.916698, -136.558652 58.075529, -136.421728 58.130299, -136.377913 58.267222, -136.279328 58.206976)), ((-147.079854 60.200582, -147.501579 59.948643, -147.53444 59.850058, -147.874011 59.784335, -147.80281 59.937689, -147.435855 60.09652, -147.205824 60.271782, -147.079854 60.200582)), ((-147.561825 60.578491, -147.616594 60.370367, -147.758995 60.156767, -147.956165 60.227967, -147.791856 60.474429, -147.561825 60.578491)), ((-147.786379 70.245291, -147.682318 70.201475, -147.162008 70.15766, -146.888161 70.185044, -146.510252 70.185044, -146.099482 70.146706, -145.858496 70.168614, -145.622988 70.08646, -145.195787 69.993352, -144.620708 69.971444, -144.461877 70.026213, -144.078491 70.059075, -143.914183 70.130275, -143.497935 70.141229, -143.503412 70.091936, -143.25695 70.119321, -142.747594 70.042644, -142.402547 69.916674, -142.079408 69.856428, -142.008207 69.801659, -141.712453 69.790705, -141.433129 69.697597, -141.378359 69.63735, -141.208574 69.686643, -141.00045 69.648304, -141.00045 60.304644, -140.53491 60.22249, -140.474664 60.310121, -139.987216 60.184151, -139.696939 60.342983, -139.088998 60.359413, -139.198537 60.091043, -139.045183 59.997935, -138.700135 59.910304, -138.623458 59.767904, -137.604747 59.242118, -137.445916 58.908024, -137.265177 59.001132, -136.827022 59.159963, -136.580559 59.16544, -136.465544 59.285933, -136.476498 59.466672, -136.301236 59.466672, -136.25742 59.625503, -135.945234 59.663842, -135.479694 59.800766, -135.025108 59.565257, -135.068924 59.422857, -134.959385 59.280456, -134.701969 59.247595, -134.378829 59.033994, -134.400737 58.973748, -134.25286 58.858732, -133.842089 58.727285, -133.173903 58.152206, -133.075318 57.998852, -132.867194 57.845498, -132.560485 57.505928, -132.253777 57.21565, -132.368792 57.095157, -132.05113 57.051341, -132.127807 56.876079, -131.870391 56.804879, -131.837529 56.602232, -131.580113 56.613186, -131.087188 56.405062, -130.78048 56.366724, -130.621648 56.268139, -130.468294 56.240754, -130.424478 56.142169, -130.101339 56.114785, -130.002754 55.994292, -130.150631 55.769737, -130.128724 55.583521, -129.986323 55.276813, -130.095862 55.200136, -130.336847 54.920812, -130.687372 54.718165, -130.785957 54.822227, -130.917403 54.789365, -131.010511 54.997489, -130.983126 55.08512, -131.092665 55.189182, -130.862634 55.298721, -130.928357 55.337059, -131.158389 55.200136, -131.284358 55.287767, -131.426759 55.238474, -131.843006 55.457552, -131.700606 55.698537, -131.963499 55.616383, -131.974453 55.49589, -132.182576 55.588998, -132.226392 55.704014, -132.083991 55.829984, -132.127807 55.955953, -132.324977 55.851892, -132.522147 56.076446, -132.642639 56.032631, -132.719317 56.218847, -132.527624 56.339339, -132.341408 56.339339, -132.396177 56.487217, -132.297592 56.67891, -132.450946 56.673433, -132.768609 56.837741, -132.993164 57.034911, -133.51895 57.177311, -133.507996 57.577128, -133.677781 57.62642, -133.639442 57.790728, -133.814705 57.834544, -134.072121 58.053622, -134.143321 58.168637, -134.586953 58.206976, -135.074401 58.502731, -135.282525 59.192825, -135.38111 59.033994, -135.337294 58.891593, -135.140124 58.617746, -135.189417 58.573931, -135.05797 58.349376, -135.085355 58.201499, -135.277048 58.234361, -135.430402 58.398669, -135.633049 58.426053, -135.91785 58.382238, -135.912373 58.617746, -136.087635 58.814916, -136.246466 58.75467, -136.876314 58.962794, -136.931084 58.902547, -136.586036 58.836824, -136.317666 58.672516, -136.213604 58.667039, -136.180743 58.535592, -136.043819 58.382238, -136.388867 58.294607, -136.591513 58.349376, -136.59699 58.212453, -136.859883 58.316515, -136.947514 58.393192, -137.111823 58.393192, -137.566409 58.590362, -137.900502 58.765624, -137.933364 58.869686, -138.11958 59.02304, -138.634412 59.132579, -138.919213 59.247595, -139.417615 59.379041, -139.746231 59.505011, -139.718846 59.641934, -139.625738 59.598119, -139.5162 59.68575, -139.625738 59.88292, -139.488815 59.992458, -139.554538 60.041751, -139.801 59.833627, -140.315833 59.696704, -140.92925 59.745996, -141.444083 59.871966, -141.46599 59.970551, -141.706976 59.948643, -141.964392 60.019843, -142.539471 60.085566, -142.873564 60.091043, -143.623905 60.036274, -143.892275 59.997935, -144.231845 60.140336, -144.65357 60.206059, -144.785016 60.29369, -144.834309 60.441568, -145.124586 60.430614, -145.223171 60.299167, -145.738004 60.474429, -145.820158 60.551106, -146.351421 60.408706, -146.608837 60.238921, -146.718376 60.397752, -146.608837 60.485383, -146.455483 60.463475, -145.951604 60.578491, -146.017328 60.666122, -146.252836 60.622307, -146.345944 60.737322, -146.565022 60.753753, -146.784099 61.044031, -146.866253 60.972831, -147.172962 60.934492, -147.271547 60.972831, -147.375609 60.879723, -147.758995 60.912584, -147.775426 60.808523, -148.032842 60.781138, -148.153334 60.819476, -148.065703 61.005692, -148.175242 61.000215, -148.350504 60.803046, -148.109519 60.737322, -148.087611 60.594922, -147.939734 60.441568, -148.027365 60.277259, -148.219058 60.332029, -148.273827 60.249875, -148.087611 60.217013, -147.983549 59.997935, -148.251919 59.95412, -148.399797 59.997935, -148.635305 59.937689, -148.755798 59.986981, -149.067984 59.981505, -149.05703 60.063659, -149.204907 60.008889, -149.287061 59.904827, -149.418508 59.997935, -149.582816 59.866489, -149.511616 59.806242, -149.741647 59.729565, -149.949771 59.718611, -150.031925 59.61455, -150.25648 59.521442, -150.409834 59.554303, -150.579619 59.444764, -150.716543 59.450241, -151.001343 59.225687, -151.308052 59.209256, -151.406637 59.280456, -151.592853 59.159963, -151.976239 59.253071, -151.888608 59.422857, -151.636669 59.483103, -151.47236 59.472149, -151.423068 59.537872, -151.127313 59.669319, -151.116359 59.778858, -151.505222 59.63098, -151.828361 59.718611, -151.8667 59.778858, -151.702392 60.030797, -151.423068 60.211536, -151.379252 60.359413, -151.297098 60.386798, -151.264237 60.545629, -151.406637 60.720892, -151.06159 60.786615, -150.404357 61.038554, -150.245526 60.939969, -150.042879 60.912584, -149.741647 61.016646, -150.075741 61.15357, -150.207187 61.257632, -150.47008 61.246678, -150.656296 61.29597, -150.711066 61.252155, -151.023251 61.180954, -151.165652 61.044031, -151.477837 61.011169, -151.800977 60.852338, -151.833838 60.748276, -152.080301 60.693507, -152.13507 60.578491, -152.310332 60.507291, -152.392486 60.304644, -152.732057 60.173197, -152.567748 60.069136, -152.704672 59.915781, -153.022334 59.888397, -153.049719 59.691227, -153.345474 59.620026, -153.438582 59.702181, -153.586459 59.548826, -153.761721 59.543349, -153.72886 59.433811, -154.117723 59.368087, -154.1944 59.066856, -153.750768 59.050425, -153.400243 58.968271, -153.301658 58.869686, -153.444059 58.710854, -153.679567 58.612269, -153.898645 58.606793, -153.920553 58.519161, -154.062953 58.4863, -153.99723 58.376761, -154.145107 58.212453, -154.46277 58.059098, -154.643509 58.059098, -154.818771 58.004329, -154.988556 58.015283, -155.120003 57.955037, -155.081664 57.872883, -155.328126 57.829067, -155.377419 57.708574, -155.547204 57.785251, -155.73342 57.549743, -156.045606 57.566174, -156.023698 57.440204, -156.209914 57.473066, -156.34136 57.418296, -156.34136 57.248511, -156.549484 56.985618, -156.883577 56.952757, -157.157424 56.832264, -157.20124 56.766541, -157.376502 56.859649, -157.672257 56.607709, -157.754411 56.67891, -157.918719 56.657002, -157.957058 56.514601, -158.126843 56.459832, -158.32949 56.48174, -158.488321 56.339339, -158.208997 56.295524, -158.510229 55.977861, -159.375585 55.873799, -159.616571 55.594475, -159.676817 55.654722, -159.643955 55.829984, -159.813741 55.857368, -160.027341 55.791645, -160.060203 55.720445, -160.394296 55.605429, -160.536697 55.473983, -160.580512 55.567091, -160.668143 55.457552, -160.865313 55.528752, -161.232268 55.358967, -161.506115 55.364444, -161.467776 55.49589, -161.588269 55.62186, -161.697808 55.517798, -161.686854 55.408259, -162.053809 55.074166, -162.179779 55.15632, -162.218117 55.03035, -162.470057 55.052258, -162.508395 55.249428, -162.661749 55.293244, -162.716519 55.222043, -162.579595 55.134412, -162.645319 54.997489, -162.847965 54.926289, -163.00132 55.079643, -163.187536 55.090597, -163.220397 55.03035, -163.034181 54.942719, -163.373752 54.800319, -163.14372 54.76198, -163.138243 54.696257, -163.329936 54.74555, -163.587352 54.614103, -164.085754 54.61958, -164.332216 54.531949, -164.354124 54.466226, -164.638925 54.389548, -164.847049 54.416933, -164.918249 54.603149, -164.710125 54.663395, -164.551294 54.88795, -164.34317 54.893427, -163.894061 55.041304, -163.532583 55.046781, -163.39566 54.904381, -163.291598 55.008443, -163.313505 55.128935, -163.105382 55.183705, -162.880827 55.183705, -162.579595 55.446598, -162.245502 55.682106, -161.807347 55.89023, -161.292514 55.983338, -161.078914 55.939523, -160.87079 55.999769, -160.816021 55.912138, -160.931036 55.813553, -160.805067 55.736876, -160.766728 55.857368, -160.509312 55.868322, -160.438112 55.791645, -160.27928 55.76426, -160.273803 55.857368, -160.536697 55.939523, -160.558604 55.994292, -160.383342 56.251708, -160.147834 56.399586, -159.830171 56.541986, -159.326293 56.667956, -158.959338 56.848695, -158.784076 56.782971, -158.641675 56.810356, -158.701922 56.925372, -158.658106 57.034911, -158.378782 57.264942, -157.995396 57.41282, -157.688688 57.609989, -157.705118 57.719528, -157.458656 58.497254, -157.07527 58.705377, -157.119086 58.869686, -158.039212 58.634177, -158.32949 58.661562, -158.40069 58.760147, -158.564998 58.803962, -158.619768 58.913501, -158.767645 58.864209, -158.860753 58.694424, -158.701922 58.480823, -158.893615 58.387715, -159.0634 58.420577, -159.392016 58.760147, -159.616571 58.929932, -159.731586 58.929932, -159.808264 58.803962, -159.906848 58.782055, -160.054726 58.886116, -160.235465 58.902547, -160.317619 59.072332, -160.854359 58.88064, -161.33633 58.743716, -161.374669 58.667039, -161.752577 58.552023, -161.938793 58.656085, -161.769008 58.776578, -161.829255 59.061379, -161.955224 59.36261, -161.703285 59.48858, -161.911409 59.740519, -162.092148 59.88292, -162.234548 60.091043, -162.448149 60.178674, -162.502918 59.997935, -162.760334 59.959597, -163.171105 59.844581, -163.66403 59.795289, -163.9324 59.806242, -164.162431 59.866489, -164.189816 60.02532, -164.386986 60.074613, -164.699171 60.29369, -164.962064 60.337506, -165.268773 60.578491, -165.060649 60.68803, -165.016834 60.890677, -165.175665 60.846861, -165.197573 60.972831, -165.120896 61.076893, -165.323543 61.170001, -165.34545 61.071416, -165.591913 61.109754, -165.624774 61.279539, -165.816467 61.301447, -165.920529 61.416463, -165.915052 61.558863, -166.106745 61.49314, -166.139607 61.630064, -165.904098 61.662925, -166.095791 61.81628, -165.756221 61.827233, -165.756221 62.013449, -165.674067 62.139419, -165.044219 62.539236, -164.912772 62.659728, -164.819664 62.637821, -164.874433 62.807606, -164.633448 63.097884, -164.425324 63.212899, -164.036462 63.262192, -163.73523 63.212899, -163.313505 63.037637, -163.039658 63.059545, -162.661749 63.22933, -162.272887 63.486746, -162.075717 63.514131, -162.026424 63.448408, -161.555408 63.448408, -161.13916 63.503177, -160.766728 63.771547, -160.766728 63.837271, -160.952944 64.08921, -160.974852 64.237087, -161.26513 64.395918, -161.374669 64.532842, -161.078914 64.494503, -160.79959 64.609519, -160.783159 64.719058, -161.144637 64.921705, -161.413007 64.762873, -161.664946 64.790258, -161.900455 64.702627, -162.168825 64.680719, -162.234548 64.620473, -162.541257 64.532842, -162.634365 64.384965, -162.787719 64.324718, -162.858919 64.49998, -163.045135 64.538319, -163.176582 64.401395, -163.253259 64.467119, -163.598306 64.565704, -164.304832 64.560227, -164.80871 64.450688, -165.000403 64.434257, -165.411174 64.49998, -166.188899 64.576658, -166.391546 64.636904, -166.484654 64.735489, -166.413454 64.872412, -166.692778 64.987428, -166.638008 65.113398, -166.462746 65.179121, -166.517516 65.337952, -166.796839 65.337952, -167.026871 65.381768, -167.47598 65.414629, -167.711489 65.496784, -168.072967 65.578938, -168.105828 65.682999, -167.541703 65.819923, -166.829701 66.049954, -166.3313 66.186878, -166.046499 66.110201, -165.756221 66.09377, -165.690498 66.203309, -165.86576 66.21974, -165.88219 66.312848, -165.186619 66.466202, -164.403417 66.581218, -163.981692 66.592172, -163.751661 66.553833, -163.872153 66.389525, -163.828338 66.274509, -163.915969 66.192355, -163.768091 66.060908, -163.494244 66.082816, -163.149197 66.060908, -162.749381 66.088293, -162.634365 66.039001, -162.371472 66.028047, -162.14144 66.077339, -161.840208 66.02257, -161.549931 66.241647, -161.341807 66.252601, -161.199406 66.208786, -161.128206 66.334755, -161.528023 66.395002, -161.911409 66.345709, -161.87307 66.510017, -162.174302 66.68528, -162.502918 66.740049, -162.601503 66.89888, -162.344087 66.937219, -162.015471 66.778388, -162.075717 66.652418, -161.916886 66.553833, -161.571838 66.438817, -161.489684 66.55931, -161.884024 66.718141, -161.714239 67.002942, -161.851162 67.052235, -162.240025 66.991988, -162.639842 67.008419, -162.700088 67.057712, -162.902735 67.008419, -163.740707 67.128912, -163.757138 67.254881, -164.009077 67.534205, -164.211724 67.638267, -164.534863 67.725898, -165.192096 67.966884, -165.493328 68.059992, -165.794559 68.081899, -166.243668 68.246208, -166.681824 68.339316, -166.703731 68.372177, -166.375115 68.42147, -166.227238 68.574824, -166.216284 68.881533, -165.329019 68.859625, -164.255539 68.930825, -163.976215 68.985595, -163.532583 69.138949, -163.110859 69.374457, -163.023228 69.609966, -162.842489 69.812613, -162.470057 69.982398, -162.311225 70.108367, -161.851162 70.311014, -161.779962 70.256245, -161.396576 70.239814, -160.837928 70.343876, -160.487404 70.453415, -159.649432 70.792985, -159.33177 70.809416, -159.298908 70.760123, -158.975769 70.798462, -158.658106 70.787508, -158.033735 70.831323, -157.420318 70.979201, -156.812377 71.285909, -156.565915 71.351633, -156.522099 71.296863, -155.585543 71.170894, -155.508865 71.083263, -155.832005 70.968247, -155.979882 70.96277, -155.974405 70.809416, -155.503388 70.858708, -155.476004 70.940862, -155.262403 71.017539, -155.191203 70.973724, -155.032372 71.148986, -154.566832 70.990155, -154.643509 70.869662, -154.353231 70.8368, -154.183446 70.7656, -153.931507 70.880616, -153.487874 70.886093, -153.235935 70.924431, -152.589656 70.886093, -152.26104 70.842277, -152.419871 70.606769, -151.817408 70.546523, -151.773592 70.486276, -151.187559 70.382214, -151.182082 70.431507, -150.760358 70.49723, -150.355064 70.491753, -150.349588 70.436984, -150.114079 70.431507, -149.867617 70.508184, -149.462323 70.519138, -149.177522 70.486276, -148.78866 70.404122, -148.607921 70.420553, -148.350504 70.305537, -148.202627 70.349353, -147.961642 70.316491, -147.786379 70.245291)), ((-152.94018 58.026237, -152.945657 57.982421, -153.290705 58.048145, -153.044242 58.305561, -152.819688 58.327469, -152.666333 58.562977, -152.496548 58.354853, -152.354148 58.426053, -152.080301 58.311038, -152.080301 58.152206, -152.480117 58.130299, -152.655379 58.059098, -152.94018 58.026237)), ((-153.958891 57.538789, -153.67409 57.670236, -153.931507 57.69762, -153.936983 57.812636, -153.723383 57.889313, -153.570028 57.834544, -153.548121 57.719528, -153.46049 57.796205, -153.455013 57.96599, -153.268797 57.889313, -153.235935 57.998852, -153.071627 57.933129, -152.874457 57.933129, -152.721103 57.993375, -152.469163 57.889313, -152.469163 57.599035, -152.151501 57.620943, -152.359625 57.42925, -152.74301 57.505928, -152.60061 57.379958, -152.710149 57.275896, -152.907319 57.325188, -152.912796 57.128019, -153.214027 57.073249, -153.312612 56.991095, -153.498828 57.067772, -153.695998 56.859649, -153.849352 56.837741, -154.013661 56.744633, -154.073907 56.969187, -154.303938 56.848695, -154.314892 56.919895, -154.523016 56.991095, -154.539447 57.193742, -154.742094 57.275896, -154.627078 57.511404, -154.227261 57.659282, -153.980799 57.648328, -153.958891 57.538789)), ((-154.53397 56.602232, -154.742094 56.399586, -154.807817 56.432447, -154.53397 56.602232)), ((-155.634835 55.923092, -155.476004 55.912138, -155.530773 55.704014, -155.793666 55.731399, -155.837482 55.802599, -155.634835 55.923092)), ((-159.890418 55.28229, -159.950664 55.068689, -160.257373 54.893427, -160.109495 55.161797, -160.005433 55.134412, -159.890418 55.28229)), ((-160.520266 55.358967, -160.33405 55.358967, -160.339527 55.249428, -160.525743 55.128935, -160.690051 55.211089, -160.794113 55.134412, -160.854359 55.320628, -160.79959 55.380875, -160.520266 55.358967)), ((-162.256456 54.981058, -162.234548 54.893427, -162.349564 54.838658, -162.437195 54.931766, -162.256456 54.981058)), ((-162.415287 63.634624, -162.563165 63.536039, -162.612457 63.62367, -162.415287 63.634624)), ((-162.80415 54.488133, -162.590549 54.449795, -162.612457 54.367641, -162.782242 54.373118, -162.80415 54.488133)), ((-165.548097 54.29644, -165.476897 54.181425, -165.630251 54.132132, -165.685021 54.252625, -165.548097 54.29644)), ((-165.73979 54.15404, -166.046499 54.044501, -166.112222 54.121178, -165.980775 54.219763, -165.73979 54.15404)), ((-166.364161 60.359413, -166.13413 60.397752, -166.084837 60.326552, -165.88219 60.342983, -165.685021 60.277259, -165.646682 59.992458, -165.750744 59.89935, -166.00816 59.844581, -166.062929 59.745996, -166.440838 59.855535, -166.6161 59.850058, -166.994009 59.992458, -167.125456 59.992458, -167.344534 60.074613, -167.421211 60.206059, -167.311672 60.238921, -166.93924 60.206059, -166.763978 60.310121, -166.577762 60.321075, -166.495608 60.392275, -166.364161 60.359413)), ((-166.375115 54.01164, -166.210807 53.934962, -166.5449 53.748746, -166.539423 53.715885, -166.117699 53.852808, -166.112222 53.776131, -166.282007 53.683023, -166.555854 53.622777, -166.583239 53.529669, -166.878994 53.431084, -167.13641 53.425607, -167.306195 53.332499, -167.623857 53.250345, -167.793643 53.337976, -167.459549 53.442038, -167.355487 53.425607, -167.103548 53.513238, -167.163794 53.611823, -167.021394 53.715885, -166.807793 53.666592, -166.785886 53.732316, -167.015917 53.754223, -167.141887 53.825424, -167.032348 53.945916, -166.643485 54.017116, -166.561331 53.880193, -166.375115 54.01164)), ((-168.790446 53.157237, -168.40706 53.34893, -168.385152 53.431084, -168.237275 53.524192, -168.007243 53.568007, -167.886751 53.518715, -167.842935 53.387268, -168.270136 53.244868, -168.500168 53.036744, -168.686384 52.965544, -168.790446 53.157237)), ((-169.74891 52.894344, -169.705095 52.795759, -169.962511 52.790282, -169.989896 52.856005, -169.74891 52.894344)), ((-170.148727 57.221127, -170.28565 57.128019, -170.313035 57.221127, -170.148727 57.221127)), ((-170.669036 52.697174, -170.603313 52.604066, -170.789529 52.538343, -170.816914 52.636928, -170.669036 52.697174)), ((-171.742517 63.716778, -170.94836 63.5689, -170.488297 63.69487, -170.280174 63.683916, -170.093958 63.612716, -170.044665 63.492223, -169.644848 63.4265, -169.518879 63.366254, -168.99857 63.338869, -168.686384 63.295053, -168.856169 63.147176, -169.108108 63.180038, -169.376478 63.152653, -169.513402 63.08693, -169.639372 62.939052, -169.831064 63.075976, -170.055619 63.169084, -170.263743 63.180038, -170.362328 63.2841, -170.866206 63.415546, -171.101715 63.421023, -171.463193 63.306007, -171.73704 63.366254, -171.852055 63.486746, -171.742517 63.716778)), ((-172.432611 52.390465, -172.41618 52.275449, -172.607873 52.253542, -172.569535 52.352127, -172.432611 52.390465)), ((-173.626584 52.14948, -173.495138 52.105664, -173.122706 52.111141, -173.106275 52.07828, -173.549907 52.028987, -173.626584 52.14948)), ((-174.322156 52.280926, -174.327632 52.379511, -174.185232 52.41785, -173.982585 52.319265, -174.059262 52.226157, -174.179755 52.231634, -174.141417 52.127572, -174.333109 52.116618, -174.738403 52.007079, -174.968435 52.039941, -174.902711 52.116618, -174.656249 52.105664, -174.322156 52.280926)), ((-176.469116 51.853725, -176.288377 51.870156, -176.288377 51.744186, -176.518409 51.760617, -176.80321 51.61274, -176.912748 51.80991, -176.792256 51.815386, -176.775825 51.963264, -176.627947 51.968741, -176.627947 51.859202, -176.469116 51.853725)), ((-177.153734 51.946833, -177.044195 51.897541, -177.120872 51.727755, -177.274226 51.678463, -177.279703 51.782525, -177.153734 51.946833)), ((-178.123152 51.919448, -177.953367 51.913971, -177.800013 51.793479, -177.964321 51.651078, -178.123152 51.919448)), ((173.107557 52.992929, 173.293773 52.927205, 173.304726 52.823143, 172.90491 52.762897, 172.642017 52.927205, 172.642017 53.003883, 173.107557 52.992929)))"},
+             {"AZ",
+              "POLYGON ((-109.042503 37.000263, -109.04798 31.331629, -111.074448 31.331629, -112.246513 31.704061, -114.815198 32.492741, -114.72209 32.717295, -114.524921 32.755634, -114.470151 32.843265, -114.524921 33.029481, -114.661844 33.034958, -114.727567 33.40739, -114.524921 33.54979, -114.497536 33.697668, -114.535874 33.933176, -114.415382 34.108438, -114.256551 34.174162, -114.136058 34.305608, -114.333228 34.448009, -114.470151 34.710902, -114.634459 34.87521, -114.634459 35.00118, -114.574213 35.138103, -114.596121 35.324319, -114.678275 35.516012, -114.738521 36.102045, -114.371566 36.140383, -114.251074 36.01989, -114.152489 36.025367, -114.048427 36.195153, -114.048427 37.000263, -110.499369 37.00574, -109.042503 37.000263))"},
+             {"AR",
+              "POLYGON ((-94.473842 36.501861, -90.152536 36.496384, -90.064905 36.304691, -90.218259 36.184199, -90.377091 35.997983, -89.730812 35.997983, -89.763673 35.811767, -89.911551 35.756997, -89.944412 35.603643, -90.130628 35.439335, -90.114197 35.198349, -90.212782 35.023087, -90.311367 34.995703, -90.251121 34.908072, -90.409952 34.831394, -90.481152 34.661609, -90.585214 34.617794, -90.568783 34.420624, -90.749522 34.365854, -90.744046 34.300131, -90.952169 34.135823, -90.891923 34.026284, -91.072662 33.867453, -91.231493 33.560744, -91.056231 33.429298, -91.143862 33.347144, -91.089093 33.13902, -91.16577 33.002096, -93.608485 33.018527, -94.041164 33.018527, -94.041164 33.54979, -94.183564 33.593606, -94.380734 33.544313, -94.484796 33.637421, -94.430026 35.395519, -94.616242 36.501861, -94.473842 36.501861))"},
+             {"CA",
+              "POLYGON ((-123.233256 42.006186, -122.378853 42.011663, -121.037003 41.995232, -120.001861 41.995232, -119.996384 40.264519, -120.001861 38.999346, -118.71478 38.101128, -117.498899 37.21934, -116.540435 36.501861, -115.85034 35.970598, -114.634459 35.00118, -114.634459 34.87521, -114.470151 34.710902, -114.333228 34.448009, -114.136058 34.305608, -114.256551 34.174162, -114.415382 34.108438, -114.535874 33.933176, -114.497536 33.697668, -114.524921 33.54979, -114.727567 33.40739, -114.661844 33.034958, -114.524921 33.029481, -114.470151 32.843265, -114.524921 32.755634, -114.72209 32.717295, -116.04751 32.624187, -117.126467 32.536556, -117.24696 32.668003, -117.252437 32.876127, -117.329114 33.122589, -117.471515 33.297851, -117.7837 33.538836, -118.183517 33.763391, -118.260194 33.703145, -118.413548 33.741483, -118.391641 33.840068, -118.566903 34.042715, -118.802411 33.998899, -119.218659 34.146777, -119.278905 34.26727, -119.558229 34.415147, -119.875891 34.40967, -120.138784 34.475393, -120.472878 34.448009, -120.64814 34.579455, -120.609801 34.858779, -120.670048 34.902595, -120.631709 35.099764, -120.894602 35.247642, -120.905556 35.450289, -121.004141 35.461243, -121.168449 35.636505, -121.283465 35.674843, -121.332757 35.784382, -121.716143 36.195153, -121.896882 36.315645, -121.935221 36.638785, -121.858544 36.6114, -121.787344 36.803093, -121.929744 36.978355, -122.105006 36.956447, -122.335038 37.115279, -122.417192 37.241248, -122.400761 37.361741, -122.515777 37.520572, -122.515777 37.783465, -122.329561 37.783465, -122.406238 38.15042, -122.488392 38.112082, -122.504823 37.931343, -122.701993 37.893004, -122.937501 38.029928, -122.97584 38.265436, -123.129194 38.451652, -123.331841 38.566668, -123.44138 38.698114, -123.737134 38.95553, -123.687842 39.032208, -123.824765 39.366301, -123.764519 39.552517, -123.85215 39.831841, -124.109566 40.105688, -124.361506 40.259042, -124.410798 40.439781, -124.158859 40.877937, -124.109566 41.025814, -124.158859 41.14083, -124.065751 41.442061, -124.147905 41.715908, -124.257444 41.781632, -124.213628 42.000709, -123.233256 42.006186))"},
+             {"CO",
+              "POLYGON ((-107.919731 41.003906, -105.728954 40.998429, -104.053011 41.003906, -102.053927 41.003906, -102.053927 40.001626, -102.042974 36.994786, -103.001438 37.000263, -104.337812 36.994786, -106.868158 36.994786, -107.421329 37.000263, -109.042503 37.000263, -109.042503 38.166851, -109.058934 38.27639, -109.053457 39.125316, -109.04798 40.998429, -107.919731 41.003906))"},
+             {"CT",
+              "POLYGON ((-73.053528 42.039048, -71.799309 42.022617, -71.799309 42.006186, -71.799309 41.414677, -71.859555 41.321569, -71.947186 41.338, -72.385341 41.261322, -72.905651 41.28323, -73.130205 41.146307, -73.371191 41.102491, -73.655992 40.987475, -73.727192 41.102491, -73.48073 41.21203, -73.55193 41.294184, -73.486206 42.050002, -73.053528 42.039048))"},
+             {"DE",
+              "POLYGON ((-75.414089 39.804456, -75.507197 39.683964, -75.611259 39.61824, -75.589352 39.459409, -75.441474 39.311532, -75.403136 39.065069, -75.189535 38.807653, -75.09095 38.796699, -75.047134 38.451652, -75.693413 38.462606, -75.786521 39.722302, -75.616736 39.831841, -75.414089 39.804456))"},
+             {"FL",
+              "POLYGON ((-85.497137 30.997536, -85.004212 31.003013, -84.867289 30.712735, -83.498053 30.647012, -82.216449 30.570335, -82.167157 30.356734, -82.046664 30.362211, -82.002849 30.564858, -82.041187 30.751074, -81.948079 30.827751, -81.718048 30.745597, -81.444201 30.707258, -81.383954 30.27458, -81.257985 29.787132, -80.967707 29.14633, -80.524075 28.461713, -80.589798 28.41242, -80.56789 28.094758, -80.381674 27.738757, -80.091397 27.021277, -80.03115 26.796723, -80.036627 26.566691, -80.146166 25.739673, -80.239274 25.723243, -80.337859 25.465826, -80.304997 25.383672, -80.49669 25.197456, -80.573367 25.241272, -80.759583 25.164595, -81.077246 25.120779, -81.170354 25.224841, -81.126538 25.378195, -81.351093 25.821827, -81.526355 25.903982, -81.679709 25.843735, -81.800202 26.090198, -81.833064 26.292844, -82.041187 26.517399, -82.09048 26.665276, -82.057618 26.878877, -82.172634 26.917216, -82.145249 26.791246, -82.249311 26.758384, -82.566974 27.300601, -82.692943 27.437525, -82.391711 27.837342, -82.588881 27.815434, -82.720328 27.689464, -82.851774 27.886634, -82.676512 28.434328, -82.643651 28.888914, -82.764143 28.998453, -82.802482 29.14633, -82.994175 29.179192, -83.218729 29.420177, -83.399469 29.518762, -83.410422 29.66664, -83.536392 29.721409, -83.640454 29.885717, -84.02384 30.104795, -84.357933 30.055502, -84.341502 29.902148, -84.451041 29.929533, -84.867289 29.743317, -85.310921 29.699501, -85.299967 29.80904, -85.404029 29.940487, -85.924338 30.236241, -86.29677 30.362211, -86.630863 30.395073, -86.910187 30.373165, -87.518128 30.280057, -87.37025 30.427934, -87.446927 30.510088, -87.408589 30.674397, -87.633143 30.86609, -87.600282 30.997536, -85.497137 30.997536))"},
+             {"GA",
+              "POLYGON ((-83.109191 35.00118, -83.322791 34.787579, -83.339222 34.683517, -83.005129 34.469916, -82.901067 34.486347, -82.747713 34.26727, -82.714851 34.152254, -82.55602 33.94413, -82.325988 33.81816, -82.194542 33.631944, -81.926172 33.462159, -81.937125 33.347144, -81.761863 33.160928, -81.493493 33.007573, -81.42777 32.843265, -81.416816 32.629664, -81.279893 32.558464, -81.121061 32.290094, -81.115584 32.120309, -80.885553 32.032678, -81.132015 31.693108, -81.175831 31.517845, -81.279893 31.364491, -81.290846 31.20566, -81.400385 31.13446, -81.444201 30.707258, -81.718048 30.745597, -81.948079 30.827751, -82.041187 30.751074, -82.002849 30.564858, -82.046664 30.362211, -82.167157 30.356734, -82.216449 30.570335, -83.498053 30.647012, -84.867289 30.712735, -85.004212 31.003013, -85.113751 31.27686, -85.042551 31.539753, -85.141136 31.840985, -85.053504 32.01077, -85.058981 32.13674, -84.889196 32.262709, -85.004212 32.322956, -84.960397 32.421541, -85.069935 32.580372, -85.184951 32.859696, -85.431413 34.124869, -85.606675 34.984749, -84.319594 34.990226, -83.618546 34.984749, -83.109191 35.00118))"},
+             {"HI",
+              "MULTIPOLYGON (((-155.634835 18.948267, -155.881297 19.035898, -155.919636 19.123529, -155.886774 19.348084, -156.062036 19.73147, -155.925113 19.857439, -155.826528 20.032702, -155.897728 20.147717, -155.87582 20.26821, -155.596496 20.12581, -155.284311 20.021748, -155.092618 19.868393, -155.092618 19.736947, -154.807817 19.523346, -154.983079 19.348084, -155.295265 19.26593, -155.514342 19.134483, -155.634835 18.948267)), ((-156.587823 21.029505, -156.472807 20.892581, -156.324929 20.952827, -156.00179 20.793996, -156.051082 20.651596, -156.379699 20.580396, -156.445422 20.60778, -156.461853 20.783042, -156.631638 20.821381, -156.697361 20.919966, -156.587823 21.029505)), ((-156.982162 21.210244, -157.080747 21.106182, -157.310779 21.106182, -157.239579 21.221198, -156.982162 21.210244)), ((-157.951581 21.697691, -157.842042 21.462183, -157.896811 21.325259, -158.110412 21.303352, -158.252813 21.582676, -158.126843 21.588153, -157.951581 21.697691)), ((-159.468693 22.228955, -159.353678 22.218001, -159.298908 22.113939, -159.33177 21.966061, -159.446786 21.872953, -159.764448 21.987969, -159.726109 22.152277, -159.468693 22.228955)))"},
+             {"ID",
+              "POLYGON ((-116.04751 49.000239, -116.04751 47.976051, -115.724371 47.696727, -115.718894 47.42288, -115.527201 47.302388, -115.324554 47.258572, -115.302646 47.187372, -114.930214 46.919002, -114.886399 46.809463, -114.623506 46.705401, -114.612552 46.639678, -114.322274 46.645155, -114.464674 46.272723, -114.492059 46.037214, -114.387997 45.88386, -114.568736 45.774321, -114.497536 45.670259, -114.546828 45.560721, -114.333228 45.456659, -114.086765 45.593582, -113.98818 45.703121, -113.807441 45.604536, -113.834826 45.522382, -113.736241 45.330689, -113.571933 45.128042, -113.45144 45.056842, -113.456917 44.865149, -113.341901 44.782995, -113.133778 44.772041, -113.002331 44.448902, -112.887315 44.394132, -112.783254 44.48724, -112.471068 44.481763, -112.241036 44.569394, -112.104113 44.520102, -111.868605 44.563917, -111.819312 44.509148, -111.616665 44.547487, -111.386634 44.75561, -111.227803 44.580348, -111.047063 44.476286, -111.047063 42.000709, -112.164359 41.995232, -114.04295 41.995232, -117.027882 42.000709, -117.027882 43.830007, -116.896436 44.158624, -116.97859 44.240778, -117.170283 44.257209, -117.241483 44.394132, -117.038836 44.750133, -116.934774 44.782995, -116.830713 44.930872, -116.847143 45.02398, -116.732128 45.144473, -116.671881 45.319735, -116.463758 45.61549, -116.545912 45.752413, -116.78142 45.823614, -116.918344 45.993399, -116.92382 46.168661, -117.055267 46.343923, -117.038836 46.426077, -117.044313 47.762451, -117.033359 49.000239, -116.04751 49.000239))"},
+             {"IL",
+              "POLYGON ((-90.639984 42.510065, -88.788778 42.493634, -87.802929 42.493634, -87.83579 42.301941, -87.682436 42.077386, -87.523605 41.710431, -87.529082 39.34987, -87.63862 39.169131, -87.512651 38.95553, -87.49622 38.780268, -87.62219 38.637868, -87.655051 38.506421, -87.83579 38.292821, -87.950806 38.27639, -87.923421 38.15042, -88.000098 38.101128, -88.060345 37.865619, -88.027483 37.799896, -88.15893 37.657496, -88.065822 37.482234, -88.476592 37.389126, -88.514931 37.285064, -88.421823 37.153617, -88.547792 37.071463, -88.914747 37.224817, -89.029763 37.213863, -89.183118 37.038601, -89.133825 36.983832, -89.292656 36.994786, -89.517211 37.279587, -89.435057 37.34531, -89.517211 37.537003, -89.517211 37.690357, -89.84035 37.903958, -89.949889 37.88205, -90.059428 38.013497, -90.355183 38.216144, -90.349706 38.374975, -90.179921 38.632391, -90.207305 38.725499, -90.10872 38.845992, -90.251121 38.917192, -90.470199 38.961007, -90.585214 38.867899, -90.661891 38.928146, -90.727615 39.256762, -91.061708 39.470363, -91.368417 39.727779, -91.494386 40.034488, -91.50534 40.237135, -91.417709 40.379535, -91.401278 40.560274, -91.121954 40.669813, -91.09457 40.823167, -90.963123 40.921752, -90.946692 41.097014, -91.111001 41.239415, -91.045277 41.414677, -90.656414 41.463969, -90.344229 41.589939, -90.311367 41.743293, -90.179921 41.809016, -90.141582 42.000709, -90.168967 42.126679, -90.393521 42.225264, -90.420906 42.329326, -90.639984 42.510065))"},
+             {"IN",
+              "POLYGON ((-85.990061 41.759724, -84.807042 41.759724, -84.807042 41.694001, -84.801565 40.500028, -84.817996 39.103408, -84.894673 39.059592, -84.812519 38.785745, -84.987781 38.780268, -85.173997 38.68716, -85.431413 38.730976, -85.42046 38.533806, -85.590245 38.451652, -85.655968 38.325682, -85.83123 38.27639, -85.924338 38.024451, -86.039354 37.958727, -86.263908 38.051835, -86.302247 38.166851, -86.521325 38.040881, -86.504894 37.931343, -86.729448 37.893004, -86.795172 37.991589, -87.047111 37.893004, -87.129265 37.788942, -87.381204 37.93682, -87.512651 37.903958, -87.600282 37.975158, -87.682436 37.903958, -87.934375 37.893004, -88.027483 37.799896, -88.060345 37.865619, -88.000098 38.101128, -87.923421 38.15042, -87.950806 38.27639, -87.83579 38.292821, -87.655051 38.506421, -87.62219 38.637868, -87.49622 38.780268, -87.512651 38.95553, -87.63862 39.169131, -87.529082 39.34987, -87.523605 41.710431, -87.42502 41.644708, -87.118311 41.644708, -86.822556 41.759724, -85.990061 41.759724))"},
+             {"IA",
+              "POLYGON ((-91.368417 43.501391, -91.215062 43.501391, -91.204109 43.353514, -91.056231 43.254929, -91.176724 43.134436, -91.143862 42.909881, -91.067185 42.75105, -90.711184 42.636034, -90.639984 42.510065, -90.420906 42.329326, -90.393521 42.225264, -90.168967 42.126679, -90.141582 42.000709, -90.179921 41.809016, -90.311367 41.743293, -90.344229 41.589939, -90.656414 41.463969, -91.045277 41.414677, -91.111001 41.239415, -90.946692 41.097014, -90.963123 40.921752, -91.09457 40.823167, -91.121954 40.669813, -91.401278 40.560274, -91.417709 40.379535, -91.527248 40.412397, -91.729895 40.615043, -91.833957 40.609566, -93.257961 40.582182, -94.632673 40.571228, -95.7664 40.587659, -95.881416 40.719105, -95.826646 40.976521, -95.925231 41.201076, -95.919754 41.453015, -96.095016 41.540646, -96.122401 41.67757, -96.062155 41.798063, -96.127878 41.973325, -96.264801 42.039048, -96.44554 42.488157, -96.631756 42.707235, -96.544125 42.855112, -96.511264 43.052282, -96.434587 43.123482, -96.560556 43.222067, -96.527695 43.397329, -96.582464 43.479483, -96.451017 43.501391, -91.368417 43.501391))"},
+             {"KS",
+              "POLYGON ((-101.90605 40.001626, -95.306337 40.001626, -95.207752 39.908518, -94.884612 39.831841, -95.109167 39.541563, -94.983197 39.442978, -94.824366 39.20747, -94.610765 39.158177, -94.616242 37.000263, -100.087706 37.000263, -102.042974 36.994786, -102.053927 40.001626, -101.90605 40.001626))"},
+             {"KY",
+              "POLYGON ((-83.903347 38.769315, -83.678792 38.632391, -83.519961 38.703591, -83.142052 38.626914, -83.032514 38.725499, -82.890113 38.758361, -82.846298 38.588575, -82.731282 38.561191, -82.594358 38.424267, -82.621743 38.123036, -82.50125 37.931343, -82.342419 37.783465, -82.293127 37.668449, -82.101434 37.553434, -81.969987 37.537003, -82.353373 37.268633, -82.720328 37.120755, -82.720328 37.044078, -82.868205 36.978355, -82.879159 36.890724, -83.070852 36.852385, -83.136575 36.742847, -83.673316 36.600446, -83.689746 36.584015, -84.544149 36.594969, -85.289013 36.627831, -85.486183 36.616877, -86.592525 36.655216, -87.852221 36.633308, -88.071299 36.677123, -88.054868 36.496384, -89.298133 36.507338, -89.418626 36.496384, -89.363857 36.622354, -89.215979 36.578538, -89.133825 36.983832, -89.183118 37.038601, -89.029763 37.213863, -88.914747 37.224817, -88.547792 37.071463, -88.421823 37.153617, -88.514931 37.285064, -88.476592 37.389126, -88.065822 37.482234, -88.15893 37.657496, -88.027483 37.799896, -87.934375 37.893004, -87.682436 37.903958, -87.600282 37.975158, -87.512651 37.903958, -87.381204 37.93682, -87.129265 37.788942, -87.047111 37.893004, -86.795172 37.991589, -86.729448 37.893004, -86.504894 37.931343, -86.521325 38.040881, -86.302247 38.166851, -86.263908 38.051835, -86.039354 37.958727, -85.924338 38.024451, -85.83123 38.27639, -85.655968 38.325682, -85.590245 38.451652, -85.42046 38.533806, -85.431413 38.730976, -85.173997 38.68716, -84.987781 38.780268, -84.812519 38.785745, -84.894673 39.059592, -84.817996 39.103408, -84.43461 39.103408, -84.231963 38.895284, -84.215533 38.807653, -83.903347 38.769315))"},
+             {"LA",
+              "POLYGON ((-93.608485 33.018527, -91.16577 33.002096, -91.072662 32.887081, -91.143862 32.843265, -91.154816 32.640618, -91.006939 32.514649, -90.985031 32.218894, -91.105524 31.988862, -91.341032 31.846462, -91.401278 31.621907, -91.499863 31.643815, -91.516294 31.27686, -91.636787 31.265906, -91.565587 31.068736, -91.636787 30.997536, -89.747242 30.997536, -89.845827 30.66892, -89.681519 30.449842, -89.643181 30.285534, -89.522688 30.181472, -89.818443 30.044549, -89.84035 29.945964, -89.599365 29.88024, -89.495303 30.039072, -89.287179 29.88024, -89.30361 29.754271, -89.424103 29.699501, -89.648657 29.748794, -89.621273 29.655686, -89.69795 29.513285, -89.506257 29.387316, -89.199548 29.348977, -89.09001 29.2011, -89.002379 29.179192, -89.16121 29.009407, -89.336472 29.042268, -89.484349 29.217531, -89.851304 29.310638, -89.851304 29.480424, -90.032043 29.425654, -90.021089 29.283254, -90.103244 29.151807, -90.23469 29.129899, -90.333275 29.277777, -90.563307 29.283254, -90.645461 29.129899, -90.798815 29.086084, -90.963123 29.179192, -91.09457 29.190146, -91.220539 29.436608, -91.445094 29.546147, -91.532725 29.529716, -91.620356 29.73784, -91.883249 29.710455, -91.888726 29.836425, -92.146142 29.715932, -92.113281 29.622824, -92.31045 29.535193, -92.617159 29.579009, -92.97316 29.715932, -93.2251 29.776178, -93.767317 29.726886, -93.838517 29.688547, -93.926148 29.787132, -93.690639 30.143133, -93.767317 30.334826, -93.696116 30.438888, -93.728978 30.575812, -93.630393 30.679874, -93.526331 30.93729, -93.542762 31.15089, -93.816609 31.556184, -93.822086 31.775262, -94.041164 31.994339, -94.041164 33.018527, -93.608485 33.018527))"},
+             {"ME",
+              "POLYGON ((-70.703921 43.057759, -70.824413 43.128959, -70.807983 43.227544, -70.966814 43.34256, -71.032537 44.657025, -71.08183 45.303304, -70.649151 45.440228, -70.720352 45.511428, -70.556043 45.664782, -70.386258 45.735983, -70.41912 45.796229, -70.260289 45.889337, -70.309581 46.064599, -70.210996 46.327492, -70.057642 46.415123, -69.997395 46.694447, -69.225147 47.461219, -69.044408 47.428357, -69.033454 47.242141, -68.902007 47.176418, -68.578868 47.285957, -68.376221 47.285957, -68.233821 47.357157, -67.954497 47.198326, -67.790188 47.066879, -67.779235 45.944106, -67.801142 45.675736, -67.456095 45.604536, -67.505388 45.48952, -67.417757 45.379982, -67.488957 45.281397, -67.346556 45.128042, -67.16034 45.160904, -66.979601 44.804903, -67.187725 44.646072, -67.308218 44.706318, -67.406803 44.596779, -67.549203 44.624164, -67.565634 44.531056, -67.75185 44.54201, -68.047605 44.328409, -68.118805 44.476286, -68.222867 44.48724, -68.173574 44.328409, -68.403606 44.251732, -68.458375 44.377701, -68.567914 44.311978, -68.82533 44.311978, -68.830807 44.459856, -68.984161 44.426994, -68.956777 44.322932, -69.099177 44.103854, -69.071793 44.043608, -69.258008 43.923115, -69.444224 43.966931, -69.553763 43.840961, -69.707118 43.82453, -69.833087 43.720469, -69.986442 43.742376, -70.030257 43.851915, -70.254812 43.676653, -70.194565 43.567114, -70.358873 43.528776, -70.369827 43.435668, -70.556043 43.320652, -70.703921 43.057759))"},
+             {"MD",
+              "POLYGON ((-79.4778 39.7220,-78.3600 39.7220,-75.7878 39.7220,-75.7809 39.5655,-75.7617 39.3152,-75.7329 38.9498,-75.6944 38.4611,-74.8581 38.4482,-74.9721 38.0200,-75.2316 38.0275,-75.6079 37.9962,-75.6230 37.9951,-75.6436 37.9464,-75.7288 37.9529,-75.8084 37.9117,-75.9512 37.9095,-75.9430 37.9464,-76.0584 37.9529,-76.2396 37.8889,-76.3454 37.9474,-76.4154 37.9669,-76.4703 38.0146,-76.5170 38.0275,-76.5363 38.0751,-76.6063 38.1464,-76.6928 38.1616,-76.7601 38.1670,-76.8494 38.1637,-76.9482 38.2080,-76.9908 38.2748,-77.0306 38.3093,-77.0114 38.3761,-77.0430 38.4009,-77.0897 38.3697,-77.1432 38.3697,-77.2627 38.3320,-77.3135 38.4525,-77.2737 38.5514,-77.2490 38.5954,-77.1281 38.6373,-77.1378 38.6737,-77.0760 38.7112,-77.0361 38.7187,-77.0416 38.7766,-77.0320 38.8451,-77.0708 38.9025,-77.1395 38.9570,-77.2335 38.9773,-77.2462 39.0240,-77.3431 39.0634,-77.4351 39.0717,-77.4636 39.0792,-77.5202 39.1218,-77.5092 39.1804,-77.4577 39.2269,-77.5666 39.3051,-77.6321 39.3067,-77.7159 39.3202,-77.7626 39.3383,-77.7544 39.3810,-77.7602 39.4288,-77.8038 39.4367,-77.7997 39.4606,-77.7859 39.5019,-77.8436 39.5062,-77.8217 39.5210,-77.8354 39.5337,-77.8656 39.5231,-77.8848 39.5591,-77.8821 39.6015,-77.9974 39.6078,-78.0222 39.6247,-78.1430 39.6924,-78.1924 39.6945,-78.2062 39.6839,-78.2419 39.6839,-78.2281 39.6586,-78.2776 39.6226,-78.3517 39.6438,-78.3765 39.6120,-78.4067 39.6036,-78.4177 39.5824,-78.4245 39.5750,-78.4232 39.5464,-78.4698 39.5146,-78.5687 39.5189,-78.6676 39.5337,-78.7390 39.5888,-78.7720 39.6015,-78.7363 39.6184,-78.7775 39.6438,-78.7912 39.6036,-78.8187 39.6036,-78.8571 39.5549,-78.9203 39.4913,-78.9725 39.4426,-79.0542 39.4834,-79.0604 39.4738,-79.1043 39.4553,-79.1936 39.3853,-79.2705 39.3449,-79.3282 39.3014,-79.4044 39.2535,-79.4696 39.2073,-79.4861 39.2051,-79.4861 39.2546,-79.4854 39.3444,-79.4840 39.3454,-79.4833 39.5316,-79.4772 39.7214,-79.4778 39.7220))"},
+             {"MA",
+              "POLYGON ((-70.917521 42.887974, -70.818936 42.871543, -70.780598 42.696281, -70.824413 42.55388, -70.983245 42.422434, -70.988722 42.269079, -70.769644 42.247172, -70.638197 42.08834, -70.660105 41.962371, -70.550566 41.929509, -70.539613 41.814493, -70.260289 41.715908, -69.937149 41.809016, -70.008349 41.672093, -70.484843 41.5516, -70.660105 41.546123, -70.764167 41.639231, -70.928475 41.611847, -70.933952 41.540646, -71.120168 41.496831, -71.196845 41.67757, -71.22423 41.710431, -71.328292 41.781632, -71.383061 42.01714, -71.530939 42.01714, -71.799309 42.006186, -71.799309 42.022617, -73.053528 42.039048, -73.486206 42.050002, -73.508114 42.08834, -73.267129 42.745573, -72.456542 42.729142, -71.29543 42.696281, -71.185891 42.789389, -70.917521 42.887974))"},
+             {"MI",
+              "MULTIPOLYGON (((-83.454238 41.732339, -84.807042 41.694001, -84.807042 41.759724, -85.990061 41.759724, -86.822556 41.759724, -86.619909 41.891171, -86.482986 42.115725, -86.357016 42.252649, -86.263908 42.444341, -86.209139 42.718189, -86.231047 43.013943, -86.526801 43.594499, -86.433693 43.813577, -86.499417 44.07647, -86.269385 44.34484, -86.220093 44.569394, -86.252954 44.689887, -86.088646 44.73918, -86.066738 44.903488, -85.809322 44.947303, -85.612152 45.128042, -85.628583 44.766564, -85.524521 44.750133, -85.393075 44.930872, -85.387598 45.237581, -85.305444 45.314258, -85.031597 45.363551, -85.119228 45.577151, -84.938489 45.75789, -84.713934 45.768844, -84.461995 45.653829, -84.215533 45.637398, -84.09504 45.494997, -83.908824 45.484043, -83.596638 45.352597, -83.4871 45.358074, -83.317314 45.144473, -83.454238 45.029457, -83.322791 44.88158, -83.273499 44.711795, -83.333745 44.339363, -83.536392 44.246255, -83.585684 44.054562, -83.82667 43.988839, -83.958116 43.758807, -83.908824 43.671176, -83.667839 43.589022, -83.481623 43.714992, -83.262545 43.972408, -82.917498 44.070993, -82.747713 43.994316, -82.643651 43.851915, -82.539589 43.435668, -82.523158 43.227544, -82.413619 42.975605, -82.517681 42.614127, -82.681989 42.559357, -82.687466 42.690804, -82.797005 42.652465, -82.922975 42.351234, -83.125621 42.236218, -83.185868 42.006186, -83.437807 41.814493, -83.454238 41.732339)), ((-85.508091 45.730506, -85.49166 45.610013, -85.623106 45.588105, -85.568337 45.75789, -85.508091 45.730506)), ((-87.589328 45.095181, -87.742682 45.199243, -87.649574 45.341643, -87.885083 45.363551, -87.791975 45.500474, -87.781021 45.675736, -87.989145 45.796229, -88.10416 45.922199, -88.531362 46.020784, -88.662808 45.987922, -89.09001 46.135799, -90.119674 46.338446, -90.229213 46.508231, -90.415429 46.568478, -90.026566 46.672539, -89.851304 46.793032, -89.413149 46.842325, -89.128348 46.990202, -88.996902 46.995679, -88.887363 47.099741, -88.575177 47.247618, -88.416346 47.373588, -88.180837 47.455742, -87.956283 47.384542, -88.350623 47.077833, -88.443731 46.973771, -88.438254 46.787555, -88.246561 46.929956, -87.901513 46.908048, -87.633143 46.809463, -87.392158 46.535616, -87.260711 46.486323, -87.008772 46.530139, -86.948526 46.469893, -86.696587 46.437031, -86.159846 46.667063, -85.880522 46.68897, -85.508091 46.678016, -85.256151 46.754694, -85.064458 46.760171, -85.02612 46.480847, -84.82895 46.442508, -84.63178 46.486323, -84.549626 46.4206, -84.418179 46.502754, -84.127902 46.530139, -84.122425 46.179615, -83.990978 46.031737, -83.793808 45.993399, -83.7719 46.091984, -83.580208 46.091984, -83.476146 45.987922, -83.563777 45.911245, -84.111471 45.976968, -84.374364 45.933153, -84.659165 46.053645, -84.741319 45.944106, -84.70298 45.850998, -84.82895 45.872906, -85.015166 46.00983, -85.338305 46.091984, -85.502614 46.097461, -85.661445 45.966014, -85.924338 45.933153, -86.209139 45.960537, -86.324155 45.905768, -86.351539 45.796229, -86.663725 45.703121, -86.647294 45.834568, -86.784218 45.861952, -86.838987 45.725029, -87.069019 45.719552, -87.17308 45.659305, -87.326435 45.423797, -87.611236 45.122565, -87.589328 45.095181)), ((-88.805209 47.976051, -89.057148 47.850082, -89.188594 47.833651, -89.177641 47.937713, -88.547792 48.173221, -88.668285 48.008913, -88.805209 47.976051)))"},
+             {"MN",
+              "POLYGON ((-92.014696 46.705401, -92.091373 46.749217, -92.29402 46.667063, -92.29402 46.075553, -92.354266 46.015307, -92.639067 45.933153, -92.869098 45.719552, -92.885529 45.577151, -92.770513 45.566198, -92.644544 45.440228, -92.75956 45.286874, -92.737652 45.117088, -92.808852 44.750133, -92.545959 44.569394, -92.337835 44.552964, -92.233773 44.443425, -91.927065 44.333886, -91.877772 44.202439, -91.592971 44.032654, -91.43414 43.994316, -91.242447 43.775238, -91.269832 43.616407, -91.215062 43.501391, -91.368417 43.501391, -96.451017 43.501391, -96.451017 45.297827, -96.681049 45.412843, -96.856311 45.604536, -96.582464 45.818137, -96.560556 45.933153, -96.598895 46.332969, -96.719387 46.437031, -96.801542 46.656109, -96.785111 46.924479, -96.823449 46.968294, -96.856311 47.609096, -97.053481 47.948667, -97.130158 48.140359, -97.16302 48.545653, -97.097296 48.682577, -97.228743 49.000239, -95.152983 49.000239, -95.152983 49.383625, -94.955813 49.372671, -94.824366 49.295994, -94.69292 48.775685, -94.588858 48.715438, -94.260241 48.699007, -94.221903 48.649715, -93.838517 48.627807, -93.794701 48.518268, -93.466085 48.545653, -93.466085 48.589469, -93.208669 48.644238, -92.984114 48.62233, -92.726698 48.540176, -92.655498 48.436114, -92.50762 48.447068, -92.370697 48.222514, -92.304974 48.315622, -92.053034 48.359437, -92.009219 48.266329, -91.713464 48.200606, -91.713464 48.112975, -91.565587 48.041775, -91.264355 48.080113, -91.083616 48.178698, -90.837154 48.238944, -90.749522 48.091067, -90.579737 48.123929, -90.377091 48.091067, -90.141582 48.112975, -89.873212 47.987005, -89.615796 48.008913, -89.637704 47.954144, -89.971797 47.828174, -90.437337 47.729589, -90.738569 47.625527, -91.171247 47.368111, -91.357463 47.20928, -91.642264 47.028541, -92.091373 46.787555, -92.014696 46.705401))"},
+             {"MS",
+              "POLYGON ((-88.471115 34.995703, -88.202745 34.995703, -88.098683 34.891641, -88.241084 33.796253, -88.471115 31.895754, -88.394438 30.367688, -88.503977 30.323872, -88.744962 30.34578, -88.843547 30.411504, -89.084533 30.367688, -89.418626 30.252672, -89.522688 30.181472, -89.643181 30.285534, -89.681519 30.449842, -89.845827 30.66892, -89.747242 30.997536, -91.636787 30.997536, -91.565587 31.068736, -91.636787 31.265906, -91.516294 31.27686, -91.499863 31.643815, -91.401278 31.621907, -91.341032 31.846462, -91.105524 31.988862, -90.985031 32.218894, -91.006939 32.514649, -91.154816 32.640618, -91.143862 32.843265, -91.072662 32.887081, -91.16577 33.002096, -91.089093 33.13902, -91.143862 33.347144, -91.056231 33.429298, -91.231493 33.560744, -91.072662 33.867453, -90.891923 34.026284, -90.952169 34.135823, -90.744046 34.300131, -90.749522 34.365854, -90.568783 34.420624, -90.585214 34.617794, -90.481152 34.661609, -90.409952 34.831394, -90.251121 34.908072, -90.311367 34.995703, -88.471115 34.995703))"},
+             {"MO",
+              "POLYGON ((-91.833957 40.609566, -91.729895 40.615043, -91.527248 40.412397, -91.417709 40.379535, -91.50534 40.237135, -91.494386 40.034488, -91.368417 39.727779, -91.061708 39.470363, -90.727615 39.256762, -90.661891 38.928146, -90.585214 38.867899, -90.470199 38.961007, -90.251121 38.917192, -90.10872 38.845992, -90.207305 38.725499, -90.179921 38.632391, -90.349706 38.374975, -90.355183 38.216144, -90.059428 38.013497, -89.949889 37.88205, -89.84035 37.903958, -89.517211 37.690357, -89.517211 37.537003, -89.435057 37.34531, -89.517211 37.279587, -89.292656 36.994786, -89.133825 36.983832, -89.215979 36.578538, -89.363857 36.622354, -89.418626 36.496384, -89.484349 36.496384, -89.539119 36.496384, -89.533642 36.249922, -89.730812 35.997983, -90.377091 35.997983, -90.218259 36.184199, -90.064905 36.304691, -90.152536 36.496384, -94.473842 36.501861, -94.616242 36.501861, -94.616242 37.000263, -94.610765 39.158177, -94.824366 39.20747, -94.983197 39.442978, -95.109167 39.541563, -94.884612 39.831841, -95.207752 39.908518, -95.306337 40.001626, -95.552799 40.264519, -95.7664 40.587659, -94.632673 40.571228, -93.257961 40.582182, -91.833957 40.609566))"},
+             {"MT",
+              "POLYGON ((-104.047534 49.000239, -104.042057 47.861036, -104.047534 45.944106, -104.042057 44.996596, -104.058488 44.996596, -105.91517 45.002073, -109.080842 45.002073, -111.05254 45.002073, -111.047063 44.476286, -111.227803 44.580348, -111.386634 44.75561, -111.616665 44.547487, -111.819312 44.509148, -111.868605 44.563917, -112.104113 44.520102, -112.241036 44.569394, -112.471068 44.481763, -112.783254 44.48724, -112.887315 44.394132, -113.002331 44.448902, -113.133778 44.772041, -113.341901 44.782995, -113.456917 44.865149, -113.45144 45.056842, -113.571933 45.128042, -113.736241 45.330689, -113.834826 45.522382, -113.807441 45.604536, -113.98818 45.703121, -114.086765 45.593582, -114.333228 45.456659, -114.546828 45.560721, -114.497536 45.670259, -114.568736 45.774321, -114.387997 45.88386, -114.492059 46.037214, -114.464674 46.272723, -114.322274 46.645155, -114.612552 46.639678, -114.623506 46.705401, -114.886399 46.809463, -114.930214 46.919002, -115.302646 47.187372, -115.324554 47.258572, -115.527201 47.302388, -115.718894 47.42288, -115.724371 47.696727, -116.04751 47.976051, -116.04751 49.000239, -111.50165 48.994762, -109.453274 49.000239, -104.047534 49.000239))"},
+             {"NE",
+              "POLYGON ((-103.324578 43.002989, -101.626726 42.997512, -98.499393 42.997512, -98.466531 42.94822, -97.951699 42.767481, -97.831206 42.866066, -97.688806 42.844158, -97.217789 42.844158, -96.692003 42.657942, -96.626279 42.515542, -96.44554 42.488157, -96.264801 42.039048, -96.127878 41.973325, -96.062155 41.798063, -96.122401 41.67757, -96.095016 41.540646, -95.919754 41.453015, -95.925231 41.201076, -95.826646 40.976521, -95.881416 40.719105, -95.7664 40.587659, -95.552799 40.264519, -95.306337 40.001626, -101.90605 40.001626, -102.053927 40.001626, -102.053927 41.003906, -104.053011 41.003906, -104.053011 43.002989, -103.324578 43.002989))"},
+             {"NV",
+              "POLYGON ((-117.027882 42.000709, -114.04295 41.995232, -114.048427 37.000263, -114.048427 36.195153, -114.152489 36.025367, -114.251074 36.01989, -114.371566 36.140383, -114.738521 36.102045, -114.678275 35.516012, -114.596121 35.324319, -114.574213 35.138103, -114.634459 35.00118, -115.85034 35.970598, -116.540435 36.501861, -117.498899 37.21934, -118.71478 38.101128, -120.001861 38.999346, -119.996384 40.264519, -120.001861 41.995232, -118.698349 41.989755, -117.027882 42.000709))"},
+             {"NH",
+              "POLYGON ((-71.08183 45.303304, -71.032537 44.657025, -70.966814 43.34256, -70.807983 43.227544, -70.824413 43.128959, -70.703921 43.057759, -70.818936 42.871543, -70.917521 42.887974, -71.185891 42.789389, -71.29543 42.696281, -72.456542 42.729142, -72.544173 42.80582, -72.533219 42.953697, -72.445588 43.008466, -72.456542 43.150867, -72.379864 43.572591, -72.204602 43.769761, -72.116971 43.994316, -72.02934 44.07647, -72.034817 44.322932, -71.700724 44.41604, -71.536416 44.585825, -71.629524 44.750133, -71.4926 44.914442, -71.503554 45.013027, -71.361154 45.270443, -71.131122 45.243058, -71.08183 45.303304))"},
+             {"NJ",
+              "POLYGON ((-74.236547 41.14083, -73.902454 40.998429, -74.022947 40.708151, -74.187255 40.642428, -74.274886 40.489074, -74.001039 40.412397, -73.979131 40.297381, -74.099624 39.760641, -74.411809 39.360824, -74.614456 39.245808, -74.795195 38.993869, -74.888303 39.158177, -75.178581 39.240331, -75.534582 39.459409, -75.55649 39.607286, -75.561967 39.629194, -75.507197 39.683964, -75.414089 39.804456, -75.145719 39.88661, -75.129289 39.963288, -74.82258 40.127596, -74.773287 40.215227, -75.058088 40.417874, -75.069042 40.543843, -75.195012 40.576705, -75.205966 40.691721, -75.052611 40.866983, -75.134765 40.971045, -74.882826 41.179168, -74.828057 41.288707, -74.69661 41.359907, -74.236547 41.14083))"},
+             {"NM",
+              "POLYGON ((-107.421329 37.000263, -106.868158 36.994786, -104.337812 36.994786, -103.001438 37.000263, -103.001438 36.501861, -103.039777 36.501861, -103.045254 34.01533, -103.067161 33.002096, -103.067161 31.999816, -106.616219 31.999816, -106.643603 31.901231, -106.528588 31.786216, -108.210008 31.786216, -108.210008 31.331629, -109.04798 31.331629, -109.042503 37.000263, -107.421329 37.000263))"},
+             {"NY",
+              "POLYGON ((-73.343806 45.013027, -73.332852 44.804903, -73.387622 44.618687, -73.294514 44.437948, -73.321898 44.246255, -73.436914 44.043608, -73.349283 43.769761, -73.404052 43.687607, -73.245221 43.523299, -73.278083 42.833204, -73.267129 42.745573, -73.508114 42.08834, -73.486206 42.050002, -73.55193 41.294184, -73.48073 41.21203, -73.727192 41.102491, -73.655992 40.987475, -73.22879 40.905321, -73.141159 40.965568, -72.774204 40.965568, -72.587988 40.998429, -72.28128 41.157261, -72.259372 41.042245, -72.100541 40.992952, -72.467496 40.845075, -73.239744 40.625997, -73.562884 40.582182, -73.776484 40.593136, -73.935316 40.543843, -74.022947 40.708151, -73.902454 40.998429, -74.236547 41.14083, -74.69661 41.359907, -74.740426 41.431108, -74.89378 41.436584, -75.074519 41.60637, -75.052611 41.754247, -75.173104 41.869263, -75.249781 41.863786, -75.35932 42.000709, -79.76278 42.000709, -79.76278 42.252649, -79.76278 42.269079, -79.149363 42.55388, -79.050778 42.690804, -78.853608 42.783912, -78.930285 42.953697, -79.012439 42.986559, -79.072686 43.260406, -78.486653 43.375421, -77.966344 43.369944, -77.75822 43.34256, -77.533665 43.233021, -77.391265 43.276836, -76.958587 43.271359, -76.695693 43.34256, -76.41637 43.523299, -76.235631 43.528776, -76.230154 43.802623, -76.137046 43.961454, -76.3616 44.070993, -76.312308 44.196962, -75.912491 44.366748, -75.764614 44.514625, -75.282643 44.848718, -74.828057 45.018503, -74.148916 44.991119, -73.343806 45.013027))"},
+             {"NC",
+              "POLYGON ((-80.978661 36.562108, -80.294043 36.545677, -79.510841 36.5402, -75.868676 36.551154, -75.75366 36.151337, -76.032984 36.189676, -76.071322 36.140383, -76.410893 36.080137, -76.460185 36.025367, -76.68474 36.008937, -76.673786 35.937736, -76.399939 35.987029, -76.3616 35.943213, -76.060368 35.992506, -75.961783 35.899398, -75.781044 35.937736, -75.715321 35.696751, -75.775568 35.581735, -75.89606 35.570781, -76.147999 35.324319, -76.482093 35.313365, -76.536862 35.14358, -76.394462 34.973795, -76.279446 34.940933, -76.493047 34.661609, -76.673786 34.694471, -76.991448 34.667086, -77.210526 34.60684, -77.555573 34.415147, -77.82942 34.163208, -77.971821 33.845545, -78.179944 33.916745, -78.541422 33.851022, -79.675149 34.80401, -80.797922 34.820441, -80.781491 34.935456, -80.934845 35.105241, -81.038907 35.044995, -81.044384 35.149057, -82.276696 35.198349, -82.550543 35.160011, -82.764143 35.066903, -83.109191 35.00118, -83.618546 34.984749, -84.319594 34.990226, -84.29221 35.225734, -84.09504 35.247642, -84.018363 35.41195, -83.7719 35.559827, -83.498053 35.565304, -83.251591 35.718659, -82.994175 35.773428, -82.775097 35.997983, -82.638174 36.063706, -82.610789 35.965121, -82.216449 36.156814, -82.03571 36.118475, -81.909741 36.304691, -81.723525 36.353984, -81.679709 36.589492, -80.978661 36.562108))"},
+             {"ND",
+              "POLYGON ((-97.228743 49.000239, -97.097296 48.682577, -97.16302 48.545653, -97.130158 48.140359, -97.053481 47.948667, -96.856311 47.609096, -96.823449 46.968294, -96.785111 46.924479, -96.801542 46.656109, -96.719387 46.437031, -96.598895 46.332969, -96.560556 45.933153, -104.047534 45.944106, -104.042057 47.861036, -104.047534 49.000239, -97.228743 49.000239))"},
+             {"OH",
+              "POLYGON ((-80.518598 41.978802, -80.518598 40.636951, -80.666475 40.582182, -80.595275 40.472643, -80.600752 40.319289, -80.737675 40.078303, -80.830783 39.711348, -81.219646 39.388209, -81.345616 39.344393, -81.455155 39.410117, -81.57017 39.267716, -81.685186 39.273193, -81.811156 39.0815, -81.783771 38.966484, -81.887833 38.873376, -82.03571 39.026731, -82.221926 38.785745, -82.172634 38.632391, -82.293127 38.577622, -82.331465 38.446175, -82.594358 38.424267, -82.731282 38.561191, -82.846298 38.588575, -82.890113 38.758361, -83.032514 38.725499, -83.142052 38.626914, -83.519961 38.703591, -83.678792 38.632391, -83.903347 38.769315, -84.215533 38.807653, -84.231963 38.895284, -84.43461 39.103408, -84.817996 39.103408, -84.801565 40.500028, -84.807042 41.694001, -83.454238 41.732339, -83.065375 41.595416, -82.933929 41.513262, -82.835344 41.589939, -82.616266 41.431108, -82.479343 41.381815, -82.013803 41.513262, -81.739956 41.485877, -81.444201 41.672093, -81.011523 41.852832, -80.518598 41.978802))"},
+             {"OK",
+              "POLYGON ((-100.087706 37.000263, -94.616242 37.000263, -94.616242 36.501861, -94.430026 35.395519, -94.484796 33.637421, -94.868182 33.74696, -94.966767 33.861976, -95.224183 33.960561, -95.289906 33.87293, -95.547322 33.878407, -95.602092 33.933176, -95.8376 33.834591, -95.936185 33.889361, -96.149786 33.840068, -96.346956 33.686714, -96.423633 33.774345, -96.631756 33.845545, -96.850834 33.845545, -96.922034 33.960561, -97.173974 33.736006, -97.256128 33.861976, -97.371143 33.823637, -97.458774 33.905791, -97.694283 33.982469, -97.869545 33.851022, -97.946222 33.987946, -98.088623 34.004376, -98.170777 34.113915, -98.36247 34.157731, -98.488439 34.064623, -98.570593 34.146777, -98.767763 34.135823, -98.986841 34.223454, -99.189488 34.2125, -99.260688 34.404193, -99.57835 34.415147, -99.698843 34.382285, -99.923398 34.573978, -100.000075 34.563024, -100.000075 36.501861, -101.812942 36.501861, -103.001438 36.501861, -103.001438 37.000263, -102.042974 36.994786, -100.087706 37.000263))"},
+             {"OR",
+              "POLYGON ((-123.211348 46.174138, -123.11824 46.185092, -122.904639 46.08103, -122.811531 45.960537, -122.762239 45.659305, -122.247407 45.549767, -121.809251 45.708598, -121.535404 45.725029, -121.217742 45.670259, -121.18488 45.604536, -120.637186 45.746937, -120.505739 45.697644, -120.209985 45.725029, -119.963522 45.823614, -119.525367 45.911245, -119.125551 45.933153, -118.988627 45.998876, -116.918344 45.993399, -116.78142 45.823614, -116.545912 45.752413, -116.463758 45.61549, -116.671881 45.319735, -116.732128 45.144473, -116.847143 45.02398, -116.830713 44.930872, -116.934774 44.782995, -117.038836 44.750133, -117.241483 44.394132, -117.170283 44.257209, -116.97859 44.240778, -116.896436 44.158624, -117.027882 43.830007, -117.027882 42.000709, -118.698349 41.989755, -120.001861 41.995232, -121.037003 41.995232, -122.378853 42.011663, -123.233256 42.006186, -124.213628 42.000709, -124.356029 42.115725, -124.432706 42.438865, -124.416275 42.663419, -124.553198 42.838681, -124.454613 43.002989, -124.383413 43.271359, -124.235536 43.55616, -124.169813 43.8081, -124.060274 44.657025, -124.076705 44.772041, -123.97812 45.144473, -123.939781 45.659305, -123.994551 45.944106, -123.945258 46.113892, -123.545441 46.261769, -123.370179 46.146753, -123.211348 46.174138))"},
+             {"PA",
+              "POLYGON ((-79.76278 42.252649, -79.76278 42.000709, -75.35932 42.000709, -75.249781 41.863786, -75.173104 41.869263, -75.052611 41.754247, -75.074519 41.60637, -74.89378 41.436584, -74.740426 41.431108, -74.69661 41.359907, -74.828057 41.288707, -74.882826 41.179168, -75.134765 40.971045, -75.052611 40.866983, -75.205966 40.691721, -75.195012 40.576705, -75.069042 40.543843, -75.058088 40.417874, -74.773287 40.215227, -74.82258 40.127596, -75.129289 39.963288, -75.145719 39.88661, -75.414089 39.804456, -75.616736 39.831841, -75.786521 39.722302, -79.477979 39.722302, -80.518598 39.722302, -80.518598 40.636951, -80.518598 41.978802, -80.332382 42.033571, -79.76278 42.269079, -79.76278 42.252649))"},
+             {"RI",
+              "MULTIPOLYGON (((-71.196845 41.67757, -71.120168 41.496831, -71.317338 41.474923, -71.196845 41.67757)), ((-71.530939 42.01714, -71.383061 42.01714, -71.328292 41.781632, -71.22423 41.710431, -71.344723 41.726862, -71.448785 41.578985, -71.481646 41.370861, -71.859555 41.321569, -71.799309 41.414677, -71.799309 42.006186, -71.530939 42.01714)))"},
+             {"SC",
+              "POLYGON ((-82.764143 35.066903, -82.550543 35.160011, -82.276696 35.198349, -81.044384 35.149057, -81.038907 35.044995, -80.934845 35.105241, -80.781491 34.935456, -80.797922 34.820441, -79.675149 34.80401, -78.541422 33.851022, -78.716684 33.80173, -78.935762 33.637421, -79.149363 33.380005, -79.187701 33.171881, -79.357487 33.007573, -79.582041 33.007573, -79.631334 32.887081, -79.866842 32.755634, -79.998289 32.613234, -80.206412 32.552987, -80.430967 32.399633, -80.452875 32.328433, -80.660998 32.246279, -80.885553 32.032678, -81.115584 32.120309, -81.121061 32.290094, -81.279893 32.558464, -81.416816 32.629664, -81.42777 32.843265, -81.493493 33.007573, -81.761863 33.160928, -81.937125 33.347144, -81.926172 33.462159, -82.194542 33.631944, -82.325988 33.81816, -82.55602 33.94413, -82.714851 34.152254, -82.747713 34.26727, -82.901067 34.486347, -83.005129 34.469916, -83.339222 34.683517, -83.322791 34.787579, -83.109191 35.00118, -82.764143 35.066903))"},
+             {"SD",
+              "POLYGON ((-104.047534 45.944106, -96.560556 45.933153, -96.582464 45.818137, -96.856311 45.604536, -96.681049 45.412843, -96.451017 45.297827, -96.451017 43.501391, -96.582464 43.479483, -96.527695 43.397329, -96.560556 43.222067, -96.434587 43.123482, -96.511264 43.052282, -96.544125 42.855112, -96.631756 42.707235, -96.44554 42.488157, -96.626279 42.515542, -96.692003 42.657942, -97.217789 42.844158, -97.688806 42.844158, -97.831206 42.866066, -97.951699 42.767481, -98.466531 42.94822, -98.499393 42.997512, -101.626726 42.997512, -103.324578 43.002989, -104.053011 43.002989, -104.058488 44.996596, -104.042057 44.996596, -104.047534 45.944106))"},
+             {"TN",
+              "POLYGON ((-88.054868 36.496384, -88.071299 36.677123, -87.852221 36.633308, -86.592525 36.655216, -85.486183 36.616877, -85.289013 36.627831, -84.544149 36.594969, -83.689746 36.584015, -83.673316 36.600446, -81.679709 36.589492, -81.723525 36.353984, -81.909741 36.304691, -82.03571 36.118475, -82.216449 36.156814, -82.610789 35.965121, -82.638174 36.063706, -82.775097 35.997983, -82.994175 35.773428, -83.251591 35.718659, -83.498053 35.565304, -83.7719 35.559827, -84.018363 35.41195, -84.09504 35.247642, -84.29221 35.225734, -84.319594 34.990226, -85.606675 34.984749, -87.359296 35.00118, -88.202745 34.995703, -88.471115 34.995703, -90.311367 34.995703, -90.212782 35.023087, -90.114197 35.198349, -90.130628 35.439335, -89.944412 35.603643, -89.911551 35.756997, -89.763673 35.811767, -89.730812 35.997983, -89.533642 36.249922, -89.539119 36.496384, -89.484349 36.496384, -89.418626 36.496384, -89.298133 36.507338, -88.054868 36.496384))"},
+             {"TX",
+              "POLYGON ((-101.812942 36.501861, -100.000075 36.501861, -100.000075 34.563024, -99.923398 34.573978, -99.698843 34.382285, -99.57835 34.415147, -99.260688 34.404193, -99.189488 34.2125, -98.986841 34.223454, -98.767763 34.135823, -98.570593 34.146777, -98.488439 34.064623, -98.36247 34.157731, -98.170777 34.113915, -98.088623 34.004376, -97.946222 33.987946, -97.869545 33.851022, -97.694283 33.982469, -97.458774 33.905791, -97.371143 33.823637, -97.256128 33.861976, -97.173974 33.736006, -96.922034 33.960561, -96.850834 33.845545, -96.631756 33.845545, -96.423633 33.774345, -96.346956 33.686714, -96.149786 33.840068, -95.936185 33.889361, -95.8376 33.834591, -95.602092 33.933176, -95.547322 33.878407, -95.289906 33.87293, -95.224183 33.960561, -94.966767 33.861976, -94.868182 33.74696, -94.484796 33.637421, -94.380734 33.544313, -94.183564 33.593606, -94.041164 33.54979, -94.041164 33.018527, -94.041164 31.994339, -93.822086 31.775262, -93.816609 31.556184, -93.542762 31.15089, -93.526331 30.93729, -93.630393 30.679874, -93.728978 30.575812, -93.696116 30.438888, -93.767317 30.334826, -93.690639 30.143133, -93.926148 29.787132, -93.838517 29.688547, -94.002825 29.68307, -94.523134 29.546147, -94.70935 29.622824, -94.742212 29.787132, -94.873659 29.672117, -94.966767 29.699501, -95.016059 29.557101, -94.911997 29.496854, -94.895566 29.310638, -95.081782 29.113469, -95.383014 28.867006, -95.985477 28.604113, -96.045724 28.647929, -96.226463 28.582205, -96.23194 28.642452, -96.478402 28.598636, -96.593418 28.724606, -96.664618 28.697221, -96.401725 28.439805, -96.593418 28.357651, -96.774157 28.406943, -96.801542 28.226204, -97.026096 28.039988, -97.256128 27.694941, -97.404005 27.333463, -97.513544 27.360848, -97.540929 27.229401, -97.425913 27.262263, -97.480682 26.99937, -97.557359 26.988416, -97.562836 26.840538, -97.469728 26.758384, -97.442344 26.457153, -97.332805 26.353091, -97.30542 26.161398, -97.217789 25.991613, -97.524498 25.887551, -97.650467 26.018997, -97.885976 26.06829, -98.198161 26.057336, -98.466531 26.221644, -98.669178 26.238075, -98.822533 26.369522, -99.030656 26.413337, -99.173057 26.539307, -99.266165 26.840538, -99.446904 27.021277, -99.424996 27.174632, -99.50715 27.33894, -99.479765 27.48134, -99.605735 27.640172, -99.709797 27.656603, -99.879582 27.799003, -99.934351 27.979742, -100.082229 28.14405, -100.29583 28.280974, -100.399891 28.582205, -100.498476 28.66436, -100.629923 28.905345, -100.673738 29.102515, -100.799708 29.244915, -101.013309 29.370885, -101.062601 29.458516, -101.259771 29.535193, -101.413125 29.754271, -101.851281 29.803563, -102.114174 29.792609, -102.338728 29.869286, -102.388021 29.765225, -102.629006 29.732363, -102.809745 29.524239, -102.919284 29.190146, -102.97953 29.184669, -103.116454 28.987499, -103.280762 28.982022, -103.527224 29.135376, -104.146119 29.381839, -104.266611 29.513285, -104.507597 29.639255, -104.677382 29.924056, -104.688336 30.181472, -104.858121 30.389596, -104.896459 30.570335, -105.005998 30.685351, -105.394861 30.855136, -105.602985 31.085167, -105.77277 31.167321, -105.953509 31.364491, -106.205448 31.468553, -106.38071 31.731446, -106.528588 31.786216, -106.643603 31.901231, -106.616219 31.999816, -103.067161 31.999816, -103.067161 33.002096, -103.045254 34.01533, -103.039777 36.501861, -103.001438 36.501861, -101.812942 36.501861))"},
+             {"UT",
+              "POLYGON ((-112.164359 41.995232, -111.047063 42.000709, -111.047063 40.998429, -109.04798 40.998429, -109.053457 39.125316, -109.058934 38.27639, -109.042503 38.166851, -109.042503 37.000263, -110.499369 37.00574, -114.048427 37.000263, -114.04295 41.995232, -112.164359 41.995232))"},
+             {"VT",
+              "POLYGON ((-71.503554 45.013027, -71.4926 44.914442, -71.629524 44.750133, -71.536416 44.585825, -71.700724 44.41604, -72.034817 44.322932, -72.02934 44.07647, -72.116971 43.994316, -72.204602 43.769761, -72.379864 43.572591, -72.456542 43.150867, -72.445588 43.008466, -72.533219 42.953697, -72.544173 42.80582, -72.456542 42.729142, -73.267129 42.745573, -73.278083 42.833204, -73.245221 43.523299, -73.404052 43.687607, -73.349283 43.769761, -73.436914 44.043608, -73.321898 44.246255, -73.294514 44.437948, -73.387622 44.618687, -73.332852 44.804903, -73.343806 45.013027, -72.308664 45.002073, -71.503554 45.013027))"},
+             {"VA",
+              "POLYGON ((-83.6753 36.6017,-83.5613 36.6519,-83.4432 36.6673,-83.3080 36.7108,-83.1974 36.7389,-83.1363 36.7433,-83.1047 36.8032,-83.1033 36.8302,-83.0704 36.8544,-83.0127 36.8478,-82.8534 36.9839,-82.7971 37.0086,-82.7360 37.0442,-82.3494 37.2664,-82.3027 37.3046,-82.0136 37.5054,-81.9681 37.5380,-81.9259 37.5139,-81.9707 37.4889,-81.9800 37.4563,-81.9374 37.4389,-81.9319 37.3592,-81.8619 37.3134,-81.7987 37.2872,-81.7259 37.2424,-81.6792 37.2008,-81.5549 37.2083,-81.4988 37.2588,-81.4856 37.2456,-81.4367 37.2742,-81.3675 37.3243,-81.2741 37.2653,-81.1560 37.2719,-80.9802 37.3025,-80.8566 37.3396,-80.8786 37.3876,-80.8511 37.4247,-80.7715 37.3702,-80.5518 37.4749,-80.5133 37.4792,-80.4803 37.4247,-80.3018 37.5097,-80.2798 37.5359,-80.3293 37.5380,-80.2249 37.6316,-80.3018 37.6903,-80.2551 37.7251,-80.2551 37.7707,-80.1961 37.8347,-80.1508 37.8749,-79.9722 38.0394,-79.9448 38.1302,-79.9063 38.1972,-79.7882 38.2684,-79.8129 38.3093,-79.7662 38.3589,-79.7401 38.3513,-79.7333 38.3869,-79.6893 38.4321,-79.6948 38.4987,-79.6495 38.5857,-79.5328 38.5492,-79.4724 38.4557,-79.3103 38.4149,-79.2087 38.5138,-79.1016 38.6576,-79.0851 38.6941,-79.1016 38.7112,-79.0576 38.7712,-79.0604 38.7926,-79.0247 38.7926,-78.9944 38.8504,-78.8736 38.7637,-78.7830 38.8857,-78.7198 38.9327,-78.7129 38.9071,-78.6291 38.9850,-78.6044 38.9658,-78.5522 39.0170,-78.5770 39.0384,-78.5083 39.0938,-78.4314 39.1492,-78.4039 39.1684,-78.4314 39.1939,-78.3380 39.3470,-78.3380 39.3853,-78.3469 39.4659,-77.9744 39.2283,-77.8302 39.1338,-77.7355 39.3130,-77.7090 39.3213,-77.6218 39.3043,-77.5686 39.3067,-77.4567 39.2248,-77.5226 39.1543,-77.5243 39.1277,-77.4687 39.0914,-77.4485 39.0720,-77.3427 39.0634,-77.2936 39.0456,-77.2459 39.0168,-77.2445 38.9829,-77.1834 38.9680,-77.1120 38.9250,-77.0464 38.8798,-77.0444 38.7538,-77.0409 38.7142,-77.1312 38.6635,-77.1285 38.6319,-77.2456 38.5935,-77.3094 38.4547,-77.3046 38.3904,-77.2188 38.3500,-77.0622 38.4041,-77.0265 38.4256,-76.9826 38.3039,-76.8851 38.2155,-76.5926 38.1745,-76.2424 37.9496,-76.0501 37.9561,-75.9416 37.9474,-75.9512 37.9085,-75.8002 37.9139,-75.6931 37.9539,-75.6477 37.9474,-75.6258 37.9962,-75.4596 38.0091,-74.9707 38.0373,-75.5777 37.3625,-75.8180 36.8994,-75.8043 36.5516,-76.1476 36.5516,-76.8617 36.5516,-76.9180 36.5516,-76.9180 36.5438,-77.1803 36.5505,-77.5278 36.5449,-80.2730 36.5427,-80.5971 36.5571,-80.7248 36.5626,-80.8511 36.5593,-81.1066 36.5681,-81.4746 36.5813,-81.5007 36.5802,-81.6792 36.5902,-81.6476 36.6122,-81.9237 36.6177,-81.9360 36.5935,-82.3961 36.5957,-82.9344 36.5935,-83.2654 36.5957,-83.6746 36.6023,-83.6753 36.6017))"},
+             {"WA",
+              "MULTIPOLYGON (((-117.033359 49.000239, -117.044313 47.762451, -117.038836 46.426077, -117.055267 46.343923, -116.92382 46.168661, -116.918344 45.993399, -118.988627 45.998876, -119.125551 45.933153, -119.525367 45.911245, -119.963522 45.823614, -120.209985 45.725029, -120.505739 45.697644, -120.637186 45.746937, -121.18488 45.604536, -121.217742 45.670259, -121.535404 45.725029, -121.809251 45.708598, -122.247407 45.549767, -122.762239 45.659305, -122.811531 45.960537, -122.904639 46.08103, -123.11824 46.185092, -123.211348 46.174138, -123.370179 46.146753, -123.545441 46.261769, -123.72618 46.300108, -123.874058 46.239861, -124.065751 46.327492, -124.027412 46.464416, -123.895966 46.535616, -124.098612 46.74374, -124.235536 47.285957, -124.31769 47.357157, -124.427229 47.740543, -124.624399 47.88842, -124.706553 48.184175, -124.597014 48.381345, -124.394367 48.288237, -123.983597 48.162267, -123.704273 48.167744, -123.424949 48.118452, -123.162056 48.167744, -123.036086 48.080113, -122.800578 48.08559, -122.636269 47.866512, -122.515777 47.882943, -122.493869 47.587189, -122.422669 47.318818, -122.324084 47.346203, -122.422669 47.576235, -122.395284 47.800789, -122.230976 48.030821, -122.362422 48.123929, -122.373376 48.288237, -122.471961 48.468976, -122.422669 48.600422, -122.488392 48.753777, -122.647223 48.775685, -122.795101 48.8907, -122.756762 49.000239, -117.033359 49.000239)), ((-122.718423 48.310145, -122.586977 48.35396, -122.608885 48.151313, -122.767716 48.227991, -122.718423 48.310145)), ((-123.025132 48.583992, -122.915593 48.715438, -122.767716 48.556607, -122.811531 48.419683, -123.041563 48.458022, -123.025132 48.583992)))"},
+             {"WV",
+              "POLYGON ((-80.518598 40.636951, -80.518598 39.722302, -79.477979 39.722302, -79.488933 39.20747, -79.291763 39.300578, -79.094593 39.470363, -78.963147 39.437501, -78.765977 39.585379, -78.470222 39.514178, -78.431884 39.623717, -78.267575 39.61824, -78.174467 39.694917, -78.004682 39.601809, -77.834897 39.601809, -77.719881 39.322485, -77.82942 39.130793, -78.349729 39.464886, -78.404499 39.169131, -78.870039 38.763838, -78.996008 38.851469, -79.209609 38.495467, -79.313671 38.413313, -79.477979 38.457129, -79.647764 38.594052, -79.724442 38.364021, -79.921611 38.177805, -79.998289 37.997066, -80.184505 37.849189, -80.294043 37.690357, -80.29952 37.509618, -80.474782 37.421987, -80.513121 37.482234, -80.967707 37.290541, -81.225123 37.235771, -81.362047 37.339833, -81.55374 37.208387, -81.679709 37.20291, -81.849494 37.285064, -81.986418 37.454849, -81.969987 37.537003, -82.101434 37.553434, -82.293127 37.668449, -82.342419 37.783465, -82.50125 37.931343, -82.621743 38.123036, -82.594358 38.424267, -82.331465 38.446175, -82.293127 38.577622, -82.172634 38.632391, -82.221926 38.785745, -82.03571 39.026731, -81.887833 38.873376, -81.783771 38.966484, -81.811156 39.0815, -81.685186 39.273193, -81.57017 39.267716, -81.455155 39.410117, -81.345616 39.344393, -81.219646 39.388209, -80.830783 39.711348, -80.737675 40.078303, -80.600752 40.319289, -80.595275 40.472643, -80.666475 40.582182, -80.518598 40.636951))"},
+             {"WI",
+              "POLYGON ((-90.415429 46.568478, -90.229213 46.508231, -90.119674 46.338446, -89.09001 46.135799, -88.662808 45.987922, -88.531362 46.020784, -88.10416 45.922199, -87.989145 45.796229, -87.781021 45.675736, -87.791975 45.500474, -87.885083 45.363551, -87.649574 45.341643, -87.742682 45.199243, -87.589328 45.095181, -87.627666 44.974688, -87.819359 44.95278, -87.983668 44.722749, -88.043914 44.563917, -87.928898 44.536533, -87.775544 44.640595, -87.611236 44.837764, -87.403112 44.914442, -87.238804 45.166381, -87.03068 45.22115, -87.047111 45.089704, -87.189511 44.969211, -87.468835 44.552964, -87.545512 44.322932, -87.540035 44.158624, -87.644097 44.103854, -87.737205 43.8793, -87.704344 43.687607, -87.791975 43.561637, -87.912467 43.249452, -87.885083 43.002989, -87.76459 42.783912, -87.802929 42.493634, -88.788778 42.493634, -90.639984 42.510065, -90.711184 42.636034, -91.067185 42.75105, -91.143862 42.909881, -91.176724 43.134436, -91.056231 43.254929, -91.204109 43.353514, -91.215062 43.501391, -91.269832 43.616407, -91.242447 43.775238, -91.43414 43.994316, -91.592971 44.032654, -91.877772 44.202439, -91.927065 44.333886, -92.233773 44.443425, -92.337835 44.552964, -92.545959 44.569394, -92.808852 44.750133, -92.737652 45.117088, -92.75956 45.286874, -92.644544 45.440228, -92.770513 45.566198, -92.885529 45.577151, -92.869098 45.719552, -92.639067 45.933153, -92.354266 46.015307, -92.29402 46.075553, -92.29402 46.667063, -92.091373 46.749217, -92.014696 46.705401, -91.790141 46.694447, -91.09457 46.864232, -90.837154 46.95734, -90.749522 46.88614, -90.886446 46.754694, -90.55783 46.584908, -90.415429 46.568478))"},
+             {"WY",
+              "POLYGON ((-109.080842 45.002073, -105.91517 45.002073, -104.058488 44.996596, -104.053011 43.002989, -104.053011 41.003906, -105.728954 40.998429, -107.919731 41.003906, -109.04798 40.998429, -111.047063 40.998429, -111.047063 42.000709, -111.047063 44.476286, -111.05254 45.002073, -109.080842 45.002073))"}}};
+
+} // namespace facebook::velox::geometry_test_utils
diff --git a/velox/functions/prestosql/tests/utils/CMakeLists.txt b/velox/functions/prestosql/tests/utils/CMakeLists.txt
index c9a16116f79..2e2e732cf63 100644
--- a/velox/functions/prestosql/tests/utils/CMakeLists.txt
+++ b/velox/functions/prestosql/tests/utils/CMakeLists.txt
@@ -13,6 +13,12 @@
 # limitations under the License.
 
 add_library(velox_functions_test_lib FunctionBaseTest.cpp)
+velox_add_test_headers(
+  velox_functions_test_lib
+  FunctionBaseTest.h
+  FuzzerTestUtils.h
+  LambdaParameterizedBaseTest.h
+)
 
 target_link_libraries(
   velox_functions_test_lib
diff --git a/velox/functions/prestosql/tests/utils/FunctionBaseTest.cpp b/velox/functions/prestosql/tests/utils/FunctionBaseTest.cpp
index 996d7f89862..d69109cc1c8 100644
--- a/velox/functions/prestosql/tests/utils/FunctionBaseTest.cpp
+++ b/velox/functions/prestosql/tests/utils/FunctionBaseTest.cpp
@@ -16,17 +16,16 @@
 #include "FunctionBaseTest.h"
 #include "velox/functions/FunctionRegistry.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
-#include "velox/functions/prestosql/types/P4HyperLogLogRegistration.h"
+#include "velox/functions/prestosql/types/KHyperLogLogRegistration.h"
 #include "velox/parse/TypeResolver.h"
 
 namespace facebook::velox::functions::test {
 
 void FunctionBaseTest::SetUpTestCase() {
   parse::registerTypeResolver();
-  // TODO: remove the registration of P4HyperLogLog here once it is registered
-  // through
-  // registerAllScalarFunctions().
-  registerP4HyperLogLogType();
+  // TODO: remove the registration of KHyperLogLog here once it is registered
+  // through registerAllScalarFunctions().
+  registerKHyperLogLogType();
   functions::prestosql::registerAllScalarFunctions();
   memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
 }
diff --git a/velox/functions/prestosql/tests/utils/FunctionBaseTest.h b/velox/functions/prestosql/tests/utils/FunctionBaseTest.h
index 2bd1c3f66d1..3aef0a213af 100644
--- a/velox/functions/prestosql/tests/utils/FunctionBaseTest.h
+++ b/velox/functions/prestosql/tests/utils/FunctionBaseTest.h
@@ -61,6 +61,17 @@ class FunctionBaseTest : public testing::Test,
     });
   }
 
+  void setSessionStartTimeAndTimeZone(
+      const int64_t sessionStartTimeMs,
+      const std::string& timeZoneName) {
+    queryCtx_->testingOverrideConfigUnsafe({
+        {core::QueryConfig::kSessionStartTime,
+         std::to_string(sessionStartTimeMs)},
+        {core::QueryConfig::kSessionTimezone, timeZoneName},
+        {core::QueryConfig::kAdjustTimestampToTimezone, "true"},
+    });
+  }
+
  protected:
   static void SetUpTestCase();
 
@@ -83,7 +94,7 @@ class FunctionBaseTest : public testing::Test,
   core::TypedExprPtr makeTypedExpr(
       const std::string& text,
       const RowTypePtr& rowType) {
-    auto untyped = parse::parseExpr(text, options_);
+    auto untyped = parse::DuckSqlExpressionsParser(options_).parseExpr(text);
     return core::Expressions::inferTypes(untyped, rowType, execCtx_.pool());
   }
 
@@ -244,9 +255,10 @@ class FunctionBaseTest : public testing::Test,
       std::optional<TArgs>... args) {
     return evaluateOnce<TReturn>(
         expr,
-        makeRowVector(unpackEvaluateParams<std::optional<TArgs>...>(
-            std::vector<TypePtr>{types},
-            std::forward<std::optional<TArgs>>(std::move(args))...)));
+        makeRowVector(
+            unpackEvaluateParams<std::optional<TArgs>...>(
+                std::vector<TypePtr>{types},
+                std::forward<std::optional<TArgs>>(std::move(args))...)));
   }
 
   template <typename TReturn, typename... TArgs>
@@ -255,8 +267,9 @@ class FunctionBaseTest : public testing::Test,
       std::optional<TArgs>... args) {
     return evaluateOnce<TReturn>(
         expr,
-        makeRowVector(unpackEvaluateParams<std::optional<TArgs>...>(
-            {}, std::forward<std::optional<TArgs>>(std::move(args))...)));
+        makeRowVector(
+            unpackEvaluateParams<std::optional<TArgs>...>(
+                {}, std::forward<std::optional<TArgs>>(std::move(args))...)));
   }
 
   // Convenience version to allow API users to specify a single type for
@@ -278,8 +291,10 @@ class FunctionBaseTest : public testing::Test,
       std::optional<TArgs>... args) {
     return evaluateOnce<TReturn>(
         expr,
-        makeRowVector(unpackEvaluateParams<std::optional<TArgs>...>(
-            {type}, std::forward<std::optional<TArgs>>(std::move(args))...)));
+        makeRowVector(
+            unpackEvaluateParams<std::optional<TArgs>...>(
+                {type},
+                std::forward<std::optional<TArgs>>(std::move(args))...)));
   }
 
   template <typename TReturn>
@@ -295,18 +310,11 @@ class FunctionBaseTest : public testing::Test,
                                : TReturn(result->valueAt(0));
   }
 
-  core::TypedExprPtr parseExpression(
-      const std::string& text,
-      const RowTypePtr& rowType) {
-    auto untyped = parse::parseExpr(text, options_);
-    return core::Expressions::inferTypes(untyped, rowType, pool());
-  }
-
   std::unique_ptr<exec::ExprSet> compileExpression(
       const std::string& expr,
       const RowTypePtr& rowType) {
     std::vector<core::TypedExprPtr> expressions = {
-        parseExpression(expr, rowType)};
+        makeTypedExpr(expr, rowType)};
     return std::make_unique<exec::ExprSet>(std::move(expressions), &execCtx_);
   }
 
@@ -316,12 +324,12 @@ class FunctionBaseTest : public testing::Test,
     std::vector<core::TypedExprPtr> expressions;
     expressions.reserve(exprs.size());
     for (const auto& expr : exprs) {
-      expressions.emplace_back(parseExpression(expr, rowType));
+      expressions.emplace_back(makeTypedExpr(expr, rowType));
     }
     return std::make_unique<exec::ExprSet>(std::move(expressions), &execCtx_);
   }
 
-  VectorPtr evaluate(
+  virtual VectorPtr evaluate(
       exec::ExprSet& exprSet,
       const RowVectorPtr& input,
       const std::optional<SelectivityVector>& rows = std::nullopt) {
@@ -339,7 +347,7 @@ class FunctionBaseTest : public testing::Test,
 
   /// Parses a timestamp string into Timestamp.
   /// Accepts strings formatted as 'YYYY-MM-DD HH:mm:ss[.nnn]'.
-  static Timestamp parseTimestamp(const std::string& text) {
+  static Timestamp parseTimestamp(std::string_view text) {
     return util::fromTimestampString(
                text.data(), text.size(), util::TimestampParseMode::kPrestoCast)
         .thenOrThrow(folly::identity, [&](const Status& status) {
@@ -347,12 +355,28 @@ class FunctionBaseTest : public testing::Test,
         });
   }
 
+  // TODO: Remove explicit std::string_view cast.
+  static Timestamp parseTimestamp(StringView text) {
+    return parseTimestamp(std::string_view(text));
+  }
+  static Timestamp parseTimestamp(const char* text) {
+    return parseTimestamp(std::string_view(text));
+  }
+
   /// Parses a date string into days since epoch.
   /// Accepts strings formatted as 'YYYY-MM-DD'.
-  static int32_t parseDate(const std::string& text) {
+  static int32_t parseDate(std::string_view text) {
     return DATE()->toDays(text);
   }
 
+  // TODO: Remove explicit std::string_view cast.
+  static int32_t parseDate(StringView text) {
+    return parseDate(std::string_view(text));
+  }
+  static int32_t parseDate(const char* text) {
+    return parseDate(std::string_view(text));
+  }
+
   /// Returns a vector of signatures for the given function name and return
   /// type.
   /// @param returnType The name of expected return type defined in function
@@ -378,6 +402,21 @@ class FunctionBaseTest : public testing::Test,
   core::ExecCtx execCtx_{pool_.get(), queryCtx_.get()};
   parse::ParseOptions options_;
 
+  void testContextMessageOnThrow(
+      const std::string& expression,
+      const RowVectorPtr& data,
+      const std::string& expectedContextMessage) {
+    try {
+      evaluate(expression, data);
+      FAIL() << "Expected an exception";
+    } catch (const VeloxUserError& e) {
+      ASSERT_TRUE(e.context().find(expectedContextMessage) != std::string::npos)
+          << "Expected additional context in error message to contain '"
+          << expectedContextMessage << "', but received '" << e.context()
+          << "'.";
+    }
+  }
+
  private:
   template <typename T>
   std::shared_ptr<T> castEvaluateResult(
diff --git a/velox/functions/prestosql/tests/utils/FuzzerTestUtils.h b/velox/functions/prestosql/tests/utils/FuzzerTestUtils.h
new file mode 100644
index 00000000000..9c95287254a
--- /dev/null
+++ b/velox/functions/prestosql/tests/utils/FuzzerTestUtils.h
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <functional>
+#include "velox/type/Type.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+namespace facebook::velox::functions::test {
+
+/// Configuration options for fuzzer tests.
+struct FuzzerTestOptions {
+  vector_size_t vectorSize = 100;
+  double nullRatio = 0.1;
+  size_t containerLength = 5;
+  bool containerHasNulls = false;
+  bool containerVariableLength = false;
+  size_t stringLength = 20;
+  bool stringVariableLength = true;
+  int iterations = 1;
+};
+
+/// Helper class for running fuzzer tests on map functions.
+/// Eliminates boilerplate code for VectorFuzzer setup across test files.
+class FuzzerTestHelper {
+ public:
+  explicit FuzzerTestHelper(memory::MemoryPool* pool) : pool_(pool) {}
+
+  /// Creates a VectorFuzzer with the given options.
+  VectorFuzzer createFuzzer(const FuzzerTestOptions& opts) {
+    VectorFuzzer::Options fuzzerOpts;
+    fuzzerOpts.vectorSize = opts.vectorSize;
+    fuzzerOpts.nullRatio = opts.nullRatio;
+    fuzzerOpts.containerLength = opts.containerLength;
+    fuzzerOpts.containerHasNulls = opts.containerHasNulls;
+    fuzzerOpts.containerVariableLength = opts.containerVariableLength;
+    fuzzerOpts.stringLength = opts.stringLength;
+    fuzzerOpts.stringVariableLength = opts.stringVariableLength;
+    return VectorFuzzer(fuzzerOpts, pool_);
+  }
+
+  /// Runs a fuzzer test for map functions that take (map, array) as input.
+  /// Used by: map_intersect, map_except
+  /// @param keyType The type for map keys and array elements
+  /// @param valueType The type for map values
+  /// @param testFn The test function to call with the generated vectors
+  ///               (inputMap, keysArray)
+  /// @param opts Optional configuration for the fuzzer
+  void runMapArrayTest(
+      const TypePtr& keyType,
+      const TypePtr& valueType,
+      std::function<void(const VectorPtr&, const VectorPtr&)> testFn,
+      const FuzzerTestOptions& opts = {}) {
+    auto fuzzer = createFuzzer(opts);
+    auto mapType = MAP(keyType, valueType);
+    auto arrayType = ARRAY(keyType);
+    for (int i = 0; i < opts.iterations; ++i) {
+      auto inputMap = fuzzer.fuzz(mapType);
+      auto keys = fuzzer.fuzz(arrayType);
+      testFn(inputMap, keys);
+    }
+  }
+
+  /// Runs a fuzzer test for map functions that take (map, array, array) as
+  /// input. Used by: map_append
+  /// @param keyType The type for map keys and key array elements
+  /// @param valueType The type for map values and value array elements
+  /// @param testFn The test function to call with the generated vectors
+  ///               (inputMap, keysArray, valuesArray)
+  /// @param opts Optional configuration for the fuzzer
+  void runMapArrayArrayTest(
+      const TypePtr& keyType,
+      const TypePtr& valueType,
+      std::function<void(const VectorPtr&, const VectorPtr&, const VectorPtr&)>
+          testFn,
+      const FuzzerTestOptions& opts = {}) {
+    auto fuzzer = createFuzzer(opts);
+    auto mapType = MAP(keyType, valueType);
+    auto keyArrayType = ARRAY(keyType);
+    auto valueArrayType = ARRAY(valueType);
+    for (int i = 0; i < opts.iterations; ++i) {
+      auto inputMap = fuzzer.fuzz(mapType);
+      auto keys = fuzzer.fuzz(keyArrayType);
+      auto values = fuzzer.fuzz(valueArrayType);
+      testFn(inputMap, keys, values);
+    }
+  }
+
+  /// Runs a fuzzer test for map functions with same key and value types.
+  /// Convenience overload for functions like map_append where key == value
+  /// type.
+  /// @param type The type for both keys and values
+  /// @param testFn The test function to call with the generated vectors
+  /// @param opts Optional configuration for the fuzzer
+  void runMapArrayArrayTestSameType(
+      const TypePtr& type,
+      std::function<void(const VectorPtr&, const VectorPtr&, const VectorPtr&)>
+          testFn,
+      const FuzzerTestOptions& opts = {}) {
+    runMapArrayArrayTest(type, type, testFn, opts);
+  }
+
+  /// Runs a fuzzer test for map functions that take (map, map) as input.
+  /// @param keyType The type for map keys
+  /// @param valueType The type for map values
+  /// @param testFn The test function to call with the generated vectors
+  /// @param opts Optional configuration for the fuzzer
+  void runMapMapTest(
+      const TypePtr& keyType,
+      const TypePtr& valueType,
+      std::function<void(const VectorPtr&, const VectorPtr&)> testFn,
+      const FuzzerTestOptions& opts = {}) {
+    auto fuzzer = createFuzzer(opts);
+    auto mapType = MAP(keyType, valueType);
+    for (int i = 0; i < opts.iterations; ++i) {
+      auto inputMap1 = fuzzer.fuzz(mapType);
+      auto inputMap2 = fuzzer.fuzz(mapType);
+      testFn(inputMap1, inputMap2);
+    }
+  }
+
+ private:
+  memory::MemoryPool* pool_;
+};
+
+} // namespace facebook::velox::functions::test
diff --git a/velox/functions/prestosql/tests/utils/LambdaParameterizedBaseTest.h b/velox/functions/prestosql/tests/utils/LambdaParameterizedBaseTest.h
index 665ce36b535..1aab616aaa2 100644
--- a/velox/functions/prestosql/tests/utils/LambdaParameterizedBaseTest.h
+++ b/velox/functions/prestosql/tests/utils/LambdaParameterizedBaseTest.h
@@ -34,7 +34,7 @@ class LambdaParameterizedBaseTest
       const std::string& expression,
       const RowVectorPtr& data) {
     std::vector<core::TypedExprPtr> parseExpr = {
-        parseExpression(expression, asRowType(data->type()))};
+        makeTypedExpr(expression, asRowType(data->type()))};
     auto exprSet = std::make_unique<exec::ExprSet>(
         std::move(parseExpr), &execCtxParametrized_);
 
diff --git a/velox/functions/prestosql/types/BigintEnumRegistration.cpp b/velox/functions/prestosql/types/BigintEnumRegistration.cpp
index 9cf15122631..e217b03216d 100644
--- a/velox/functions/prestosql/types/BigintEnumRegistration.cpp
+++ b/velox/functions/prestosql/types/BigintEnumRegistration.cpp
@@ -17,6 +17,7 @@
 #include "velox/functions/prestosql/types/BigintEnumRegistration.h"
 #include "velox/expression/CastExpr.h"
 #include "velox/functions/prestosql/types/BigintEnumType.h"
+#include "velox/type/CastRegistry.h"
 
 namespace facebook::velox {
 namespace {
@@ -29,17 +30,6 @@ class BigintEnumCastOperator : public exec::CastOperator {
     return kInstance;
   }
 
-  // Casting is supported from all integer types.
-  bool isSupportedFromType(const TypePtr& other) const override {
-    return BIGINT()->equivalent(*other) || TINYINT()->equivalent(*other) ||
-        SMALLINT()->equivalent(*other) || INTEGER()->equivalent(*other);
-  }
-
-  // Casting is only supported to BIGINT type.
-  bool isSupportedToType(const TypePtr& other) const override {
-    return BIGINT()->equivalent(*other);
-  }
-
   void castTo(
       const BaseVector& input,
       exec::EvalCtx& context,
@@ -132,6 +122,13 @@ class BigintEnumTypeFactory : public CustomTypeFactory {
 
 void registerBigintEnumType() {
   registerCustomType(
-      "bigint_enum", std::make_unique<const BigintEnumTypeFactory>());
+      "BIGINT_ENUM", std::make_unique<const BigintEnumTypeFactory>());
+  registerCastRules({
+      {.fromType = "TINYINT", .toType = "BIGINT_ENUM"},
+      {.fromType = "SMALLINT", .toType = "BIGINT_ENUM"},
+      {.fromType = "INTEGER", .toType = "BIGINT_ENUM"},
+      {.fromType = "BIGINT", .toType = "BIGINT_ENUM"},
+      {.fromType = "BIGINT_ENUM", .toType = "BIGINT"},
+  });
 }
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/BingTileRegistration.cpp b/velox/functions/prestosql/types/BingTileRegistration.cpp
index e5199935633..dbbf1bd277f 100644
--- a/velox/functions/prestosql/types/BingTileRegistration.cpp
+++ b/velox/functions/prestosql/types/BingTileRegistration.cpp
@@ -19,6 +19,7 @@
 #include "velox/common/fuzzer/ConstrainedGenerators.h"
 #include "velox/expression/CastExpr.h"
 #include "velox/functions/prestosql/types/BingTileType.h"
+#include "velox/type/CastRegistry.h"
 
 namespace facebook::velox {
 
@@ -33,24 +34,6 @@ class BingTileCastOperator final : public exec::CastOperator {
     return {std::shared_ptr<const CastOperator>{}, &kInstance};
   }
 
-  bool isSupportedFromType(const TypePtr& other) const override {
-    switch (other->kind()) {
-      case TypeKind::BIGINT:
-        return true;
-      default:
-        return false;
-    }
-  }
-
-  bool isSupportedToType(const TypePtr& other) const override {
-    switch (other->kind()) {
-      case TypeKind::BIGINT:
-        return true;
-      default:
-        return false;
-    }
-  }
-
   void castTo(
       const BaseVector& input,
       exec::EvalCtx& context,
@@ -137,7 +120,11 @@ class BingTileTypeFactory : public CustomTypeFactory {
 } // namespace
 
 void registerBingTileType() {
-  registerCustomType("bingtile", std::make_unique<const BingTileTypeFactory>());
+  registerCustomType("BINGTILE", std::make_unique<const BingTileTypeFactory>());
+  registerCastRules({
+      {.fromType = "BIGINT", .toType = "BINGTILE"},
+      {.fromType = "BINGTILE", .toType = "BIGINT"},
+  });
 }
 
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/BingTileType.cpp b/velox/functions/prestosql/types/BingTileType.cpp
index 469c7503062..f5b2a175616 100644
--- a/velox/functions/prestosql/types/BingTileType.cpp
+++ b/velox/functions/prestosql/types/BingTileType.cpp
@@ -19,16 +19,18 @@
 #include <algorithm>
 #include <optional>
 #include <string>
+#include "velox/common/geospatial/GeometryConstants.h"
 
 namespace facebook::velox {
 
 namespace {
 folly::Expected<int64_t, std::string> mapSize(uint8_t zoomLevel) {
   if (FOLLY_UNLIKELY(zoomLevel > BingTileType::kBingTileMaxZoomLevel)) {
-    return folly::makeUnexpected(fmt::format(
-        "Zoom level {} is greater than max zoom {}",
-        zoomLevel,
-        BingTileType::kBingTileMaxZoomLevel));
+    return folly::makeUnexpected(
+        fmt::format(
+            "Zoom level {} is greater than max zoom {}",
+            zoomLevel,
+            BingTileType::kBingTileMaxZoomLevel));
   }
   return 256L << zoomLevel;
 }
@@ -54,13 +56,14 @@ folly::Expected<uint32_t, std::string> longitudeToTileX(
     double longitude,
     uint8_t zoomLevel) {
   if (FOLLY_UNLIKELY(
-          longitude > BingTileType::kMaxLongitude ||
-          longitude < BingTileType::kMinLongitude)) {
-    return folly::makeUnexpected(fmt::format(
-        "Longitude {} is outside of valid range [{}, {}]",
-        longitude,
-        BingTileType::kMinLongitude,
-        BingTileType::kMaxLongitude));
+          longitude > common::geospatial::kMaxLongitude ||
+          longitude < common::geospatial::kMinLongitude)) {
+    return folly::makeUnexpected(
+        fmt::format(
+            "Longitude {} is outside of valid range [{}, {}]",
+            longitude,
+            common::geospatial::kMinLongitude,
+            common::geospatial::kMaxLongitude));
   }
   double x = (longitude + 180) / 360;
 
@@ -88,13 +91,14 @@ folly::Expected<uint32_t, std::string> latitudeToTileY(
     double latitude,
     uint8_t zoomLevel) {
   if (FOLLY_UNLIKELY(
-          latitude > BingTileType::kMaxLatitude ||
-          latitude < BingTileType::kMinLatitude)) {
-    return folly::makeUnexpected(fmt::format(
-        "Latitude {} is outside of valid range [{}, {}]",
-        latitude,
-        BingTileType::kMinLatitude,
-        BingTileType::kMaxLatitude));
+          latitude > common::geospatial::kMaxBingTileLatitude ||
+          latitude < common::geospatial::kMinBingTileLatitude)) {
+    return folly::makeUnexpected(
+        fmt::format(
+            "Latitude {} is outside of valid range [{}, {}]",
+            latitude,
+            common::geospatial::kMinBingTileLatitude,
+            common::geospatial::kMaxBingTileLatitude));
   }
   double sinLatitude = sin(latitude * M_PI / 180);
   double y = 0.5 - log((1 + sinLatitude) / (1 - sinLatitude)) / (4 * M_PI);
@@ -130,14 +134,14 @@ double addDistanceToLongitude(
           sin(bearingInRadians) * sin(radiusRatio) * cos(latitudeInRadians),
           cos(radiusRatio) - sin(latitudeInRadians) * sin(latitudeInRadians)));
 
-  if (newLongitude > BingTileType::kMaxLongitude) {
-    return BingTileType::kMinLongitude +
-        (newLongitude - BingTileType::kMaxLongitude);
+  if (newLongitude > common::geospatial::kMaxLongitude) {
+    return common::geospatial::kMinLongitude +
+        (newLongitude - common::geospatial::kMaxLongitude);
   }
 
-  if (newLongitude < BingTileType::kMinLongitude) {
-    return BingTileType::kMaxLongitude +
-        (newLongitude - BingTileType::kMinLongitude);
+  if (newLongitude < common::geospatial::kMinLongitude) {
+    return common::geospatial::kMaxLongitude +
+        (newLongitude - common::geospatial::kMinLongitude);
   }
 
   return newLongitude;
@@ -152,11 +156,11 @@ addDistanceToLatitude(double latitude, double radiusInKm, double bearing) {
   double newLatitude = toDegrees(asin(
       sin(latitudeInRadians) * cos(radiusRatio) +
       cos(latitudeInRadians) * sin(radiusRatio) * cos(bearingInRadians)));
-  if (newLatitude > BingTileType::kMaxLatitude) {
-    return BingTileType::kMaxLatitude;
+  if (newLatitude > common::geospatial::kMaxBingTileLatitude) {
+    return common::geospatial::kMaxBingTileLatitude;
   }
-  if (newLatitude < BingTileType::kMinLatitude) {
-    return BingTileType::kMinLatitude;
+  if (newLatitude < common::geospatial::kMinBingTileLatitude) {
+    return common::geospatial::kMinBingTileLatitude;
   }
   return newLatitude;
 }
@@ -245,8 +249,9 @@ folly::Expected<uint64_t, std::string> BingTileType::bingTileParent(
   uint32_t y = bingTileY(tile);
 
   if (FOLLY_UNLIKELY(tileZoom < parentZoom)) {
-    return folly::makeUnexpected(fmt::format(
-        "Parent zoom {} must be <= tile zoom {}", parentZoom, tileZoom));
+    return folly::makeUnexpected(
+        fmt::format(
+            "Parent zoom {} must be <= tile zoom {}", parentZoom, tileZoom));
   }
   uint8_t shift = tileZoom - parentZoom;
   return bingTileCoordsToInt((x >> shift), (y >> shift), parentZoom);
@@ -265,23 +270,26 @@ BingTileType::bingTileChildren(
   uint32_t y = bingTileY(tile);
 
   if (FOLLY_UNLIKELY(childZoom < tileZoom)) {
-    return folly::makeUnexpected(fmt::format(
-        "Child zoom {} must be >= tile zoom {}", childZoom, tileZoom));
+    return folly::makeUnexpected(
+        fmt::format(
+            "Child zoom {} must be >= tile zoom {}", childZoom, tileZoom));
   }
   if (FOLLY_UNLIKELY(childZoom > kBingTileMaxZoomLevel)) {
-    return folly::makeUnexpected(fmt::format(
-        "Child zoom {} must be <= max zoom {}",
-        childZoom,
-        kBingTileMaxZoomLevel));
+    return folly::makeUnexpected(
+        fmt::format(
+            "Child zoom {} must be <= max zoom {}",
+            childZoom,
+            kBingTileMaxZoomLevel));
   }
 
   uint8_t shift = childZoom - tileZoom;
   if (shift > maxZoomShift) {
-    return folly::makeUnexpected(fmt::format(
-        "Difference between parent zoom ({}) and child zoom ({}) must be <= {}",
-        tileZoom,
-        childZoom,
-        maxZoomShift));
+    return folly::makeUnexpected(
+        fmt::format(
+            "Difference between parent zoom ({}) and child zoom ({}) must be <= {}",
+            tileZoom,
+            childZoom,
+            maxZoomShift));
   }
   uint32_t xBase = (x << shift);
   uint32_t yBase = (y << shift);
@@ -301,10 +309,11 @@ folly::Expected<uint64_t, std::string> BingTileType::bingTileFromQuadKey(
     const std::string_view& quadKey) {
   size_t zoomLevelInt32 = quadKey.size();
   if (FOLLY_UNLIKELY(zoomLevelInt32 > kBingTileMaxZoomLevel)) {
-    return folly::makeUnexpected(fmt::format(
-        "Zoom level {} is greater than max zoom {}",
-        zoomLevelInt32,
-        kBingTileMaxZoomLevel));
+    return folly::makeUnexpected(
+        fmt::format(
+            "Zoom level {} is greater than max zoom {}",
+            zoomLevelInt32,
+            kBingTileMaxZoomLevel));
   }
   uint8_t zoomLevel = static_cast<uint8_t>(zoomLevelInt32);
   uint32_t tileX = 0;
@@ -433,8 +442,9 @@ BingTileType::bingTilesAround(
     uint8_t zoomLevel,
     double radiusInKm) {
   if (FOLLY_UNLIKELY(radiusInKm < 0 || radiusInKm > 1000)) {
-    return folly::makeUnexpected(fmt::format(
-        "Radius in km must between 0 and 1000, got {}", radiusInKm));
+    return folly::makeUnexpected(
+        fmt::format(
+            "Radius in km must between 0 and 1000, got {}", radiusInKm));
   }
   auto tileX = longitudeToTileX(longitude, zoomLevel);
   if (FOLLY_UNLIKELY(tileX.hasError())) {
@@ -501,9 +511,10 @@ BingTileType::bingTilesAround(
 
   uint32_t totalTileCount = tileCountX * tileCountY;
   if (totalTileCount > 1000000) {
-    return folly::makeUnexpected(fmt::format(
-        "The number of tiles covering input rectangle exceeds the limit of 1M. Number of tiles: {}.",
-        totalTileCount));
+    return folly::makeUnexpected(
+        fmt::format(
+            "The number of tiles covering input rectangle exceeds the limit of 1M. Number of tiles: {}.",
+            totalTileCount));
   }
 
   std::vector<uint64_t> result;
diff --git a/velox/functions/prestosql/types/BingTileType.h b/velox/functions/prestosql/types/BingTileType.h
index 745ace55a9f..8a3cb561d2c 100644
--- a/velox/functions/prestosql/types/BingTileType.h
+++ b/velox/functions/prestosql/types/BingTileType.h
@@ -64,11 +64,6 @@ class BingTileType final : public BigintType {
     return "BINGTILE";
   }
 
-  const std::vector<TypeParameter>& parameters() const override {
-    static const std::vector<TypeParameter> kEmpty = {};
-    return kEmpty;
-  }
-
   std::string toString() const override {
     return name();
   }
@@ -91,10 +86,6 @@ class BingTileType final : public BigintType {
   static constexpr uint8_t kBingTileZoomOffset = 31 - kBingTileZoomBitWidth;
   static constexpr uint64_t kBits23Mask = (1 << 24) - 1;
   static constexpr uint64_t kBits5Mask = (1 << 6) - 1;
-  static constexpr double kMaxLatitude = 85.05112878;
-  static constexpr double kMinLatitude = -85.05112878;
-  static constexpr double kMaxLongitude = 180.0;
-  static constexpr double kMinLongitude = -180.0;
   static constexpr uint16_t kTilePixels = 256;
   static constexpr double kEarthRadiusKm = 6371.01;
 
diff --git a/velox/functions/prestosql/types/CMakeLists.txt b/velox/functions/prestosql/types/CMakeLists.txt
index cd5fb608037..4fef6d19022 100644
--- a/velox/functions/prestosql/types/CMakeLists.txt
+++ b/velox/functions/prestosql/types/CMakeLists.txt
@@ -13,10 +13,12 @@
 # limitations under the License.
 
 add_subdirectory(parser)
+
 velox_add_library(
   velox_presto_types
   BigintEnumRegistration.cpp
   BigintEnumType.cpp
+  PrestoTypes.cpp
   BingTileRegistration.cpp
   BingTileType.cpp
   EnumTypeBase.cpp
@@ -25,17 +27,68 @@ velox_add_library(
   IPPrefixRegistration.cpp
   JsonCastOperator.cpp
   JsonRegistration.cpp
+  KHyperLogLogRegistration.cpp
   QDigestRegistration.cpp
   P4HyperLogLogRegistration.cpp
   SfmSketchRegistration.cpp
   TDigestRegistration.cpp
   TimestampWithTimeZoneRegistration.cpp
+  TimestampWithTimeZoneType.cpp
+  TimeWithTimezoneRegistration.cpp
+  TimeWithTimezoneType.cpp
+  IPAddressType.cpp
+  IPPrefixType.cpp
+  SetDigestRegistration.cpp
   UuidRegistration.cpp
+  UuidType.cpp
   VarcharEnumRegistration.cpp
   VarcharEnumType.cpp
+  HEADERS
+  BigintEnumRegistration.h
+  BigintEnumType.h
+  BingTileRegistration.h
+  BingTileType.h
+  EnumTypeBase.h
+  GeometryRegistration.h
+  GeometryType.h
+  HyperLogLogRegistration.h
+  HyperLogLogType.h
+  IPAddressRegistration.h
+  IPAddressType.h
+  IPPrefixRegistration.h
+  IPPrefixType.h
+  JsonCastOperator.h
+  JsonRegistration.h
+  JsonType.h
+  KHyperLogLogRegistration.h
+  KHyperLogLogType.h
+  P4HyperLogLogRegistration.h
+  P4HyperLogLogType.h
+  PrestoTypes.h
+  QDigestRegistration.h
+  QDigestType.h
+  SetDigestRegistration.h
+  SetDigestType.h
+  SfmSketchRegistration.h
+  SfmSketchType.h
+  SphericalGeographyRegistration.h
+  SphericalGeographyType.h
+  TDigestRegistration.h
+  TDigestType.h
+  TimeWithTimezoneRegistration.h
+  TimeWithTimezoneType.h
+  TimestampWithTimeZoneRegistration.h
+  TimestampWithTimeZoneType.h
+  UuidRegistration.h
+  UuidType.h
+  VarcharEnumRegistration.h
+  VarcharEnumType.h
 )
 if(VELOX_ENABLE_GEO)
-  velox_sources(velox_presto_types PRIVATE GeometryRegistration.cpp)
+  velox_sources(
+    velox_presto_types
+    PRIVATE GeometryRegistration.cpp SphericalGeographyRegistration.cpp
+  )
 endif()
 
 velox_link_libraries(
@@ -48,6 +101,7 @@ velox_link_libraries(
   velox_functions_lib_date_time_formatter
   velox_constrained_input_generators
   velox_presto_types_fuzzer_utils
+  velox_common_hyperloglog
 )
 
 if(${VELOX_BUILD_TESTING})
diff --git a/velox/functions/prestosql/types/EnumTypeBase.h b/velox/functions/prestosql/types/EnumTypeBase.h
index bafc72ed39e..18c0d9163d6 100644
--- a/velox/functions/prestosql/types/EnumTypeBase.h
+++ b/velox/functions/prestosql/types/EnumTypeBase.h
@@ -43,7 +43,7 @@ class EnumTypeBase : public TPhysical {
     return this == &other;
   }
 
-  const std::vector<TypeParameter>& parameters() const override {
+  std::span<const TypeParameter> parameters() const override {
     return parameters_;
   }
 
@@ -61,6 +61,22 @@ class EnumTypeBase : public TPhysical {
     return std::nullopt;
   }
 
+  /// Returns the value for a key name. If the key does not exist,
+  /// return std::nullopt.
+  std::optional<TValue> valueAt(const std::string& key) const {
+    const auto& map = forwardMap();
+    auto it = map.find(key);
+    if (it != map.end()) {
+      return it->second;
+    }
+    return std::nullopt;
+  }
+
+  /// Returns true if the enum has an entry for 'key'.
+  bool containsKey(const std::string& key) const {
+    return valueAt(key).has_value();
+  }
+
   const std::string& enumName() const {
     return name_;
   }
@@ -77,6 +93,14 @@ class EnumTypeBase : public TPhysical {
   template <typename EnumType>
   static std::shared_ptr<const EnumType> getCached(const TParameter& parameter);
 
+  const std::unordered_map<std::string, TValue>& forwardMap() const {
+    if constexpr (std::is_same_v<TParameter, LongEnumParameter>) {
+      return parameters_[0].longEnumLiteral->valuesMap;
+    } else {
+      return parameters_[0].varcharEnumLiteral->valuesMap;
+    }
+  }
+
   const std::vector<TypeParameter> parameters_;
   const std::string name_;
   const TReverseMap flippedMap_;
diff --git a/velox/functions/prestosql/types/GeometryType.h b/velox/functions/prestosql/types/GeometryType.h
index 63bfbc6a733..5bbbbe34f21 100644
--- a/velox/functions/prestosql/types/GeometryType.h
+++ b/velox/functions/prestosql/types/GeometryType.h
@@ -16,7 +16,6 @@
 
 #pragma once
 
-#include "velox/expression/CastExpr.h"
 #include "velox/type/SimpleFunctionApi.h"
 #include "velox/type/Type.h"
 
diff --git a/velox/functions/prestosql/types/IPAddressRegistration.cpp b/velox/functions/prestosql/types/IPAddressRegistration.cpp
index c046fe15591..0338226edd7 100644
--- a/velox/functions/prestosql/types/IPAddressRegistration.cpp
+++ b/velox/functions/prestosql/types/IPAddressRegistration.cpp
@@ -22,41 +22,12 @@
 #include "velox/expression/CastExpr.h"
 #include "velox/functions/prestosql/types/IPAddressType.h"
 #include "velox/functions/prestosql/types/IPPrefixType.h"
+#include "velox/type/CastRegistry.h"
 
 namespace facebook::velox {
 namespace {
 class IPAddressCastOperator : public exec::CastOperator {
  public:
-  bool isSupportedFromType(const TypePtr& other) const override {
-    switch (other->kind()) {
-      case TypeKind::VARBINARY:
-      case TypeKind::VARCHAR:
-        return true;
-      case TypeKind::ROW:
-        if (isIPPrefixType(other)) {
-          return true;
-        }
-        [[fallthrough]];
-      default:
-        return false;
-    }
-  }
-
-  bool isSupportedToType(const TypePtr& other) const override {
-    switch (other->kind()) {
-      case TypeKind::VARBINARY:
-      case TypeKind::VARCHAR:
-        return true;
-      case TypeKind::ROW:
-        if (isIPPrefixType(other)) {
-          return true;
-        }
-        [[fallthrough]];
-      default:
-        return false;
-    }
-  }
-
   void castTo(
       const BaseVector& input,
       exec::EvalCtx& context,
@@ -107,21 +78,10 @@ class IPAddressCastOperator : public exec::CastOperator {
       BaseVector& result) {
     auto* flatResult = result.as<FlatVector<StringView>>();
     const auto* ipaddresses = input.as<SimpleVector<int128_t>>();
-    folly::ByteArray16 addrBytes;
 
     context.applyToSelectedNoThrow(rows, [&](auto row) {
-      const auto intAddr = ipaddresses->valueAt(row);
-      memcpy(&addrBytes, &intAddr, ipaddress::kIPAddressBytes);
-
-      std::reverse(addrBytes.begin(), addrBytes.end());
-      folly::IPAddressV6 v6Addr(addrBytes);
-
       exec::StringWriter result(flatResult, row);
-      if (v6Addr.isIPv4Mapped()) {
-        result.append(v6Addr.createIPv4().str());
-      } else {
-        result.append(v6Addr.str());
-      }
+      result.append(IPADDRESS()->valueToString(ipaddresses->valueAt(row)));
       result.finalize();
     });
   }
@@ -136,8 +96,9 @@ class IPAddressCastOperator : public exec::CastOperator {
 
     context.applyToSelectedNoThrow(rows, [&](auto row) {
       const auto ipAddressString = ipAddressStrings->valueAt(row);
-      auto maybeIpAsInt128 =
-          ipaddress::tryGetIPv6asInt128FromString(ipAddressString);
+      // TODO: Remove explicit std::string_view cast.
+      auto maybeIpAsInt128 = ipaddress::tryGetIPv6asInt128FromString(
+          std::string_view(ipAddressString));
 
       if (maybeIpAsInt128.hasError()) {
         if (threadSkipErrorDetails()) {
@@ -283,6 +244,14 @@ class IPAddressTypeFactory : public CustomTypeFactory {
 
 void registerIPAddressType() {
   registerCustomType(
-      "ipaddress", std::make_unique<const IPAddressTypeFactory>());
+      "IPADDRESS", std::make_unique<const IPAddressTypeFactory>());
+  registerCastRules({
+      {.fromType = "VARCHAR", .toType = "IPADDRESS"},
+      {.fromType = "VARBINARY", .toType = "IPADDRESS"},
+      {.fromType = "IPPREFIX", .toType = "IPADDRESS"},
+      {.fromType = "IPADDRESS", .toType = "VARCHAR"},
+      {.fromType = "IPADDRESS", .toType = "VARBINARY"},
+      {.fromType = "IPADDRESS", .toType = "IPPREFIX"},
+  });
 }
 } // namespace facebook::velox
diff --git a/velox/common/base/TraceConfig.cpp b/velox/functions/prestosql/types/IPAddressType.cpp
similarity index 52%
rename from velox/common/base/TraceConfig.cpp
rename to velox/functions/prestosql/types/IPAddressType.cpp
index 5007be9a48c..2a9483d36e6 100644
--- a/velox/common/base/TraceConfig.cpp
+++ b/velox/functions/prestosql/types/IPAddressType.cpp
@@ -14,24 +14,17 @@
  * limitations under the License.
  */
 
-#include <utility>
-
-#include "velox/common/base/Exceptions.h"
-#include "velox/common/base/TraceConfig.h"
+#include "velox/functions/prestosql/types/IPAddressType.h"
 
 namespace facebook::velox {
 
-TraceConfig::TraceConfig(
-    std::string _queryNodeId,
-    std::string _queryTraceDir,
-    UpdateAndCheckTraceLimitCB _updateAndCheckTraceLimitCB,
-    std::string _taskRegExp,
-    bool _dryRun)
-    : queryNodeId(std::move(_queryNodeId)),
-      queryTraceDir(std::move(_queryTraceDir)),
-      updateAndCheckTraceLimitCB(std::move(_updateAndCheckTraceLimitCB)),
-      taskRegExp(std::move(_taskRegExp)),
-      dryRun(_dryRun) {
-  VELOX_CHECK(!queryNodeId.empty(), "The query trace node cannot be empty");
+std::string IPAddressType::valueToString(int128_t value) const {
+  auto bytes = ipaddress::toIPv6ByteArray(value);
+  folly::IPAddressV6 v6Addr(bytes);
+  if (v6Addr.isIPv4Mapped()) {
+    return v6Addr.createIPv4().str();
+  }
+  return v6Addr.str();
 }
+
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/IPAddressType.h b/velox/functions/prestosql/types/IPAddressType.h
index 3dd46b688d9..7b6fe3fe2bb 100644
--- a/velox/functions/prestosql/types/IPAddressType.h
+++ b/velox/functions/prestosql/types/IPAddressType.h
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #pragma once
 
 #include <folly/IPAddress.h>
@@ -21,8 +22,8 @@
 #include "velox/type/Type.h"
 
 namespace facebook::velox {
-
 namespace ipaddress {
+
 constexpr int kIPV4AddressBytes = 4;
 constexpr int kIPV4ToV6FFIndex = 10;
 constexpr int kIPV4ToV6Index = 12;
@@ -31,6 +32,7 @@ constexpr int kIPAddressBytes = 16;
 inline folly::ByteArray16 toIPv6ByteArray(const int128_t& ipAddr) {
   folly::ByteArray16 bytes{{0}};
   memcpy(bytes.data(), &ipAddr, sizeof(ipAddr));
+
   // Reverse because the velox is always on little endian system
   // and the byte array needs to be big endian (network byte order)
   std::reverse(bytes.begin(), bytes.end());
@@ -38,7 +40,7 @@ inline folly::ByteArray16 toIPv6ByteArray(const int128_t& ipAddr) {
 }
 
 inline folly::Expected<int128_t, folly::IPAddressFormatError>
-tryGetIPv6asInt128FromString(const std::string& ipAddressStr) {
+tryGetIPv6asInt128FromString(const std::string_view& ipAddressStr) {
   auto maybeIp = folly::IPAddress::tryFromString(ipAddressStr);
   if (maybeIp.hasError()) {
     return folly::makeUnexpected(maybeIp.error());
@@ -51,6 +53,7 @@ tryGetIPv6asInt128FromString(const std::string& ipAddressStr) {
   memcpy(&intAddr, &addrBytes, kIPAddressBytes);
   return intAddr;
 }
+
 } // namespace ipaddress
 
 class IPAddressType final : public HugeintType {
@@ -66,8 +69,8 @@ class IPAddressType final : public HugeintType {
     const auto leftAddrBytes = ipaddress::toIPv6ByteArray(left);
     const auto rightAddrBytes = ipaddress::toIPv6ByteArray(right);
     return memcmp(
-        leftAddrBytes.begin(),
-        rightAddrBytes.begin(),
+        leftAddrBytes.data(),
+        rightAddrBytes.data(),
         ipaddress::kIPAddressBytes);
   }
 
@@ -88,6 +91,12 @@ class IPAddressType final : public HugeintType {
     return name();
   }
 
+  /// Formats an int128_t IP address value as a dotted-decimal IPv4 string
+  /// (e.g., "192.168.1.1") or a colon-separated IPv6 string (e.g.,
+  /// "2001:db8::ff00:42:8329"). IPv4-mapped IPv6 addresses are returned in
+  /// IPv4 format.
+  std::string valueToString(int128_t value) const;
+
   folly::dynamic serialize() const override {
     folly::dynamic obj = folly::dynamic::object;
     obj["name"] = "Type";
diff --git a/velox/functions/prestosql/types/IPPrefixRegistration.cpp b/velox/functions/prestosql/types/IPPrefixRegistration.cpp
index 786210c74c4..d06c401c84e 100644
--- a/velox/functions/prestosql/types/IPPrefixRegistration.cpp
+++ b/velox/functions/prestosql/types/IPPrefixRegistration.cpp
@@ -21,33 +21,12 @@
 #include "velox/common/fuzzer/ConstrainedGenerators.h"
 #include "velox/expression/CastExpr.h"
 #include "velox/functions/prestosql/types/IPPrefixType.h"
+#include "velox/type/CastRegistry.h"
 
 namespace facebook::velox {
 namespace {
 class IPPrefixCastOperator : public exec::CastOperator {
  public:
-  bool isSupportedFromType(const TypePtr& other) const override {
-    switch (other->kind()) {
-      case TypeKind::VARCHAR:
-        return true;
-      case TypeKind::HUGEINT:
-        return isIPAddressType(other);
-      default:
-        return false;
-    }
-  }
-
-  bool isSupportedToType(const TypePtr& other) const override {
-    switch (other->kind()) {
-      case TypeKind::VARCHAR:
-        return true;
-      case TypeKind::HUGEINT:
-        return isIPAddressType(other);
-      default:
-        return false;
-    }
-  }
-
   void castTo(
       const BaseVector& input,
       exec::EvalCtx& context,
@@ -101,31 +80,11 @@ class IPPrefixCastOperator : public exec::CastOperator {
     const auto* prefix = rowVector->childAt(ipaddress::kIpPrefixRowIndex)
                              ->as<SimpleVector<int8_t>>();
     context.applyToSelectedNoThrow(rows, [&](auto row) {
-      const auto ipAddrVal = ipaddr->valueAt(row);
-      // The string representation of the last byte needs
-      // to be unsigned
-      const uint8_t prefixVal = prefix->valueAt(row);
-
-      // Copy the first 16 bytes into a ByteArray16.
-      folly::ByteArray16 addrBytes;
-      memcpy(&addrBytes, &ipAddrVal, ipaddress::kIPAddressBytes);
-      // Reverse the bytes to get the correct order. Similar to
-      // IPAddressType. We assume we're ALWAYS on a little endian machine.
-      // Note: for big endian, we should not reverse the bytes.
-      std::reverse(addrBytes.begin(), addrBytes.end());
-      // // Construct a V6 address from the ByteArray16.
-      folly::IPAddressV6 v6Addr(addrBytes);
-
-      // Inline func to get string for ipv4 or ipv6 string
-      const auto ipString =
-          (v6Addr.isIPv4Mapped()) ? v6Addr.createIPv4().str() : v6Addr.str();
-
-      // Format of string is {ipString}/{mask}
-      auto stringRet = fmt::format("{}/{}", ipString, prefixVal);
-
-      // Write the string to the result vector
       exec::StringWriter result(flatResult, row);
-      result.append(stringRet);
+      result.resize(IPPrefixType::kMaxStringSize);
+      auto str = IPPREFIX()->valueToString(
+          ipaddr->valueAt(row), prefix->valueAt(row), result.data());
+      result.resize(str.size());
       result.finalize();
     });
   }
@@ -170,7 +129,10 @@ class IPPrefixCastOperator : public exec::CastOperator {
 
     context.applyToSelectedNoThrow(rows, [&](auto row) {
       auto ipAddressStringView = decoded.valueAt<StringView>(row);
-      auto tryIpPrefix = ipaddress::tryParseIpPrefixString(ipAddressStringView);
+
+      // TODO: Remove explicit std::string_view cast.
+      auto tryIpPrefix = ipaddress::tryParseIpPrefixString(
+          std::string_view(ipAddressStringView));
       if (tryIpPrefix.hasError()) {
         context.setStatus(row, std::move(tryIpPrefix.error()));
         return;
@@ -208,6 +170,12 @@ class IPPrefixTypeFactory : public CustomTypeFactory {
 } // namespace
 
 void registerIPPrefixType() {
-  registerCustomType("ipprefix", std::make_unique<const IPPrefixTypeFactory>());
+  registerCustomType("IPPREFIX", std::make_unique<const IPPrefixTypeFactory>());
+  registerCastRules({
+      {.fromType = "VARCHAR", .toType = "IPPREFIX"},
+      {.fromType = "IPADDRESS", .toType = "IPPREFIX"},
+      {.fromType = "IPPREFIX", .toType = "VARCHAR"},
+      {.fromType = "IPPREFIX", .toType = "IPADDRESS"},
+  });
 }
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/IPPrefixType.cpp b/velox/functions/prestosql/types/IPPrefixType.cpp
new file mode 100644
index 00000000000..969468a5d19
--- /dev/null
+++ b/velox/functions/prestosql/types/IPPrefixType.cpp
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/types/IPPrefixType.h"
+
+#include <fmt/format.h>
+
+namespace facebook::velox {
+
+std::string_view IPPrefixType::valueToString(
+    int128_t ip,
+    int8_t prefixLength,
+    char* buffer) const {
+  auto ipStr = IPADDRESS()->valueToString(ip);
+  auto result = fmt::format_to_n(
+      buffer,
+      kMaxStringSize,
+      "{}/{}",
+      ipStr,
+      static_cast<uint8_t>(prefixLength));
+  return {buffer, result.size};
+}
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/IPPrefixType.h b/velox/functions/prestosql/types/IPPrefixType.h
index 1374b4df362..8266a87c2bb 100644
--- a/velox/functions/prestosql/types/IPPrefixType.h
+++ b/velox/functions/prestosql/types/IPPrefixType.h
@@ -23,8 +23,8 @@
 #include "velox/type/Type.h"
 
 namespace facebook::velox {
-
 namespace ipaddress {
+
 constexpr uint8_t kIPV4Bits = 32;
 constexpr uint8_t kIPV6Bits = 128;
 constexpr int kIPPrefixLengthIndex = 16;
@@ -50,7 +50,7 @@ inline folly::Expected<int8_t, Status> tryIpPrefixLengthFromIPAddressType(
 }
 
 inline folly::Expected<std::pair<int128_t, int8_t>, Status>
-tryParseIpPrefixString(folly::StringPiece ipprefixString) {
+tryParseIpPrefixString(std::string_view ipprefixString) {
   // Ensure '/' is present
   if (ipprefixString.find('/') == std::string::npos) {
     return folly::makeUnexpected(
@@ -92,8 +92,13 @@ tryParseIpPrefixString(folly::StringPiece ipprefixString) {
   memcpy(&intAddr, &addrBytes, ipaddress::kIPAddressBytes);
   return std::make_pair(intAddr, prefix);
 }
+
 }; // namespace ipaddress
 
+/// Represents an IP prefix as ROW<IPADDRESS, TINYINT>. The prefix length is
+/// stored as TINYINT (int8_t), so IPv6 prefix length 128 wraps to -128. Code
+/// that reads the prefix length must cast to uint8_t to recover the correct
+/// unsigned value.
 class IPPrefixType final : public RowType {
   IPPrefixType()
       : RowType(
@@ -119,6 +124,18 @@ class IPPrefixType final : public RowType {
     return name();
   }
 
+  /// Max string size: 39 (IPv6) + 1 (/) + 3 (prefix up to 128) = 43.
+  static constexpr int32_t kMaxStringSize = 43;
+
+  /// Formats an IP prefix as "ip/prefixLength" (e.g., "192.128.0.0/9" or
+  /// "2001:db8::/32").
+  /// @param ip IP address stored as int128_t.
+  /// @param prefixLength Prefix length in bits.
+  /// @param buffer Output buffer, pre-allocated with at least kMaxStringSize
+  /// bytes.
+  std::string_view valueToString(int128_t ip, int8_t prefixLength, char* buffer)
+      const;
+
   folly::dynamic serialize() const override {
     folly::dynamic obj = folly::dynamic::object;
     obj["name"] = "Type";
@@ -126,9 +143,8 @@ class IPPrefixType final : public RowType {
     return obj;
   }
 
-  const std::vector<TypeParameter>& parameters() const override {
-    static const std::vector<TypeParameter> kEmpty = {};
-    return kEmpty;
+  std::span<const TypeParameter> parameters() const override {
+    return {};
   }
 };
 
diff --git a/velox/functions/prestosql/types/JsonCastOperator.cpp b/velox/functions/prestosql/types/JsonCastOperator.cpp
index cca43a29d00..03c3bd4a92c 100644
--- a/velox/functions/prestosql/types/JsonCastOperator.cpp
+++ b/velox/functions/prestosql/types/JsonCastOperator.cpp
@@ -31,6 +31,8 @@ void generateJsonTyped(
     int row,
     std::string& result,
     const TypePtr& type,
+    bool isDate,
+    bool isDecimal,
     const std::shared_ptr<exec::CastHooks>& hooks) {
   auto value = input.valueAt(row);
 
@@ -50,9 +52,10 @@ void generateJsonTyped(
         std::is_same_v<T, double> || std::is_same_v<T, float>) {
       if constexpr (!legacyCast) {
         if (FOLLY_UNLIKELY(std::isinf(value) || std::isnan(value))) {
-          result.append(fmt::format(
-              "\"{}\"",
-              util::Converter<TypeKind::VARCHAR>::tryCast(value).value()));
+          result.append(
+              fmt::format(
+                  "\"{}\"",
+                  util::Converter<TypeKind::VARCHAR>::tryCast(value).value()));
         } else {
           result.append(
               util::Converter<TypeKind::VARCHAR>::tryCast(value).value());
@@ -79,13 +82,13 @@ void generateJsonTyped(
       result.append("\"");
       result.append(buffer);
       result.append("\"");
-    } else if (type->isDate()) {
+    } else if (isDate) {
       std::string stringValue = DATE()->toString(value);
       result.reserve(stringValue.size() + 2);
       result.append("\"");
       result.append(stringValue);
       result.append("\"");
-    } else if (type->isDecimal()) {
+    } else if (isDecimal) {
       result.append(DecimalUtil::toString(value, type));
     } else {
       folly::toAppend<std::string, T>(value, &result);
@@ -101,13 +104,20 @@ void generateJsonNonKeyTyped(
     FlatVector<StringView>& flatResult,
     const std::shared_ptr<exec::CastHooks>& hooks) {
   std::string result;
+  const auto& type = inputVector.type();
+  // Resolve type checks once before the loop to avoid per-element
+  // dynamic_cast calls in isDecimal() (which does two dynamic_casts
+  // to ShortDecimalType*/LongDecimalType* that always fail for plain
+  // integer types).
+  const bool isDate = type->isDate();
+  const bool isDecimal = type->isDecimal();
   context.applyToSelectedNoThrow(rows, [&](auto row) {
     if (inputVector.isNullAt(row)) {
       flatResult.set(row, "null");
     } else {
       result.clear();
       generateJsonTyped<T, legacyCast>(
-          inputVector, row, result, inputVector.type(), hooks);
+          inputVector, row, result, type, isDate, isDecimal, hooks);
 
       flatResult.set(row, StringView{result});
     }
@@ -122,6 +132,9 @@ void generateJsonKeyTyped(
     FlatVector<StringView>& flatResult,
     const std::shared_ptr<exec::CastHooks>& hooks) {
   std::string result;
+  const auto& type = inputVector.type();
+  const bool isDate = type->isDate();
+  const bool isDecimal = type->isDecimal();
   context.applyToSelectedNoThrow(rows, [&](auto row) {
     if (inputVector.isNullAt(row)) {
       VELOX_USER_FAIL("Map keys cannot be null.");
@@ -133,7 +146,7 @@ void generateJsonKeyTyped(
       }
 
       generateJsonTyped<T, legacyCast>(
-          inputVector, row, result, inputVector.type(), hooks);
+          inputVector, row, result, type, isDate, isDecimal, hooks);
 
       if constexpr (!std::is_same_v<T, StringView>) {
         result.append("\"");
@@ -1156,58 +1169,8 @@ simdjson::error_code castFromJsonOneRow(
   return simdjson::SUCCESS;
 }
 
-bool isSupportedBasicType(const TypePtr& type) {
-  switch (type->kind()) {
-    case TypeKind::BOOLEAN:
-    case TypeKind::BIGINT:
-    case TypeKind::INTEGER:
-    case TypeKind::SMALLINT:
-    case TypeKind::TINYINT:
-    case TypeKind::DOUBLE:
-    case TypeKind::REAL:
-    case TypeKind::VARCHAR:
-      return true;
-    default:
-      return false;
-  }
-}
 } // namespace
 
-bool JsonCastOperator::isSupportedFromType(const TypePtr& other) const {
-  if (isSupportedBasicType(other)) {
-    return true;
-  }
-
-  switch (other->kind()) {
-    case TypeKind::UNKNOWN:
-    case TypeKind::TIMESTAMP:
-      return true;
-    case TypeKind::ARRAY:
-      return isSupportedFromType(other->childAt(0));
-    case TypeKind::ROW:
-      for (const auto& child : other->as<TypeKind::ROW>().children()) {
-        if (!isSupportedFromType(child)) {
-          return false;
-        }
-      }
-      return true;
-    case TypeKind::MAP:
-      if (other->childAt(1)->isUnKnown()) {
-        if (other->childAt(0)->isUnKnown()) {
-          return true;
-        }
-        return isSupportedBasicType(other->childAt(0)) &&
-            !isJsonType(other->childAt(0));
-      }
-
-      return (
-          isSupportedBasicType(other->childAt(0)) &&
-          isSupportedFromType(other->childAt(1)));
-    default:
-      return false;
-  }
-}
-
 template <TypeKind kind>
 void JsonCastOperator::castFromJson(
     const BaseVector& input,
@@ -1251,35 +1214,6 @@ void JsonCastOperator::castFromJson(
   writer.finish();
 }
 
-bool JsonCastOperator::isSupportedToType(const TypePtr& other) const {
-  if (other->isDate()) {
-    return false;
-  }
-
-  if (isSupportedBasicType(other)) {
-    return true;
-  }
-
-  switch (other->kind()) {
-    case TypeKind::ARRAY:
-      return isSupportedToType(other->childAt(0));
-    case TypeKind::ROW:
-      for (const auto& child : other->as<TypeKind::ROW>().children()) {
-        if (!isSupportedToType(child)) {
-          return false;
-        }
-      }
-      return true;
-    case TypeKind::MAP:
-      return (
-          isSupportedBasicType(other->childAt(0)) &&
-          isSupportedToType(other->childAt(1)) &&
-          !isJsonType(other->childAt(0)));
-    default:
-      return false;
-  }
-}
-
 /// Converts an input vector of a supported type to Json type. The
 /// implementation follows the structure below.
 /// JsonOperator::castTo: type dispatch for castToJson
diff --git a/velox/functions/prestosql/types/JsonCastOperator.h b/velox/functions/prestosql/types/JsonCastOperator.h
index 22891e2dae1..22ef9aab7b4 100644
--- a/velox/functions/prestosql/types/JsonCastOperator.h
+++ b/velox/functions/prestosql/types/JsonCastOperator.h
@@ -23,10 +23,6 @@ namespace facebook::velox {
 /// Custom operator for casts from and to Json type.
 class JsonCastOperator : public exec::CastOperator {
  public:
-  bool isSupportedFromType(const TypePtr& other) const override;
-
-  bool isSupportedToType(const TypePtr& other) const override;
-
   void castTo(
       const BaseVector& input,
       exec::EvalCtx& context,
@@ -57,8 +53,8 @@ class JsonCastOperator : public exec::CastOperator {
       const SelectivityVector& rows,
       BaseVector& result) const;
 
-  inline static folly::once_flag initializeErrors_;
-  inline static std::exception_ptr errors_[simdjson::NUM_ERROR_CODES];
+  mutable folly::once_flag initializeErrors_;
+  mutable std::exception_ptr errors_[simdjson::NUM_ERROR_CODES];
   mutable std::string paddedInput_;
 };
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/JsonRegistration.cpp b/velox/functions/prestosql/types/JsonRegistration.cpp
index 4952aa0360e..b761119131e 100644
--- a/velox/functions/prestosql/types/JsonRegistration.cpp
+++ b/velox/functions/prestosql/types/JsonRegistration.cpp
@@ -19,6 +19,7 @@
 #include "velox/common/fuzzer/ConstrainedGenerators.h"
 #include "velox/functions/prestosql/types/JsonCastOperator.h"
 #include "velox/functions/prestosql/types/JsonType.h"
+#include "velox/type/CastRegistry.h"
 #include "velox/type/Type.h"
 
 namespace facebook::velox {
@@ -60,9 +61,151 @@ class JsonTypeFactory : public CustomTypeFactory {
         false);
   }
 };
+
+// Returns true if 'type' is a primitive scalar type usable as a MAP key in
+// JSON casts. JSON itself has VARCHAR kind so it passes here; callers that
+// need to reject JSON keys (e.g. JSON → MAP) check isJsonType separately.
+bool isValidJsonMapKey(const TypePtr& type) {
+  switch (type->kind()) {
+    case TypeKind::BOOLEAN:
+    case TypeKind::BIGINT:
+    case TypeKind::INTEGER:
+    case TypeKind::SMALLINT:
+    case TypeKind::TINYINT:
+    case TypeKind::DOUBLE:
+    case TypeKind::REAL:
+    case TypeKind::VARCHAR:
+      return true;
+    default:
+      return false;
+  }
+}
+
+// Validator for DECIMAL → JSON: only short decimals (precision ≤ 18) are
+// supported. Short decimals use TypeKind::BIGINT; long decimals use HUGEINT.
+bool canCastDecimalToJson(const TypePtr& from, const TypePtr& /*to*/) {
+  return from->kind() == TypeKind::BIGINT;
+}
+
+// Validator for ARRAY → JSON: element type must be castable to JSON.
+bool canCastArrayToJson(const TypePtr& from, const TypePtr& to) {
+  return CastRulesRegistry::instance().canCast(from->childAt(0), to);
+}
+
+// Validator for ROW → JSON: all child types must be castable to JSON.
+bool canCastRowToJson(const TypePtr& from, const TypePtr& to) {
+  for (auto i = 0; i < from->size(); ++i) {
+    if (!CastRulesRegistry::instance().canCast(from->childAt(i), to)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// Validator for MAP → JSON: key must be a valid JSON map key, value must be
+// castable to JSON. Special case: MAP<UNKNOWN, UNKNOWN> is allowed.
+// Note: JSON keys are allowed here (JSON has VARCHAR kind and passes
+// isValidJsonMapKey). The old isSupportedFromType had an inconsistency where
+// JSON keys were rejected only in the UNKNOWN-value branch but allowed
+// otherwise; we use the more permissive behavior consistently.
+bool canCastMapToJson(const TypePtr& from, const TypePtr& to) {
+  const auto& keyType = from->childAt(0);
+  const auto& valueType = from->childAt(1);
+  if (keyType->isUnknown() && valueType->isUnknown()) {
+    return true;
+  }
+  if (!isValidJsonMapKey(keyType)) {
+    return false;
+  }
+  return CastRulesRegistry::instance().canCast(valueType, to);
+}
+
+// Validator for JSON → ARRAY: element type must be castable from JSON.
+bool canCastJsonToArray(const TypePtr& from, const TypePtr& to) {
+  return CastRulesRegistry::instance().canCast(from, to->childAt(0));
+}
+
+// Validator for JSON → ROW: all child types must be castable from JSON.
+bool canCastJsonToRow(const TypePtr& from, const TypePtr& to) {
+  for (auto i = 0; i < to->size(); ++i) {
+    if (!CastRulesRegistry::instance().canCast(from, to->childAt(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// Validator for JSON → MAP: key must be a valid JSON map key and not JSON
+// itself, value must be castable from JSON.
+bool canCastJsonToMap(const TypePtr& from, const TypePtr& to) {
+  const auto& keyType = to->childAt(0);
+  const auto& valueType = to->childAt(1);
+  if (!isValidJsonMapKey(keyType) || isJsonType(keyType)) {
+    return false;
+  }
+  return CastRulesRegistry::instance().canCast(from, valueType);
+}
+
 } // namespace
 
 void registerJsonType() {
-  registerCustomType("json", std::make_unique<const JsonTypeFactory>());
+  registerCustomType("JSON", std::make_unique<const JsonTypeFactory>());
+  registerCastRules({
+      // TO JSON (from primitive types).
+      {.fromType = "UNKNOWN", .toType = "JSON"},
+      {.fromType = "BOOLEAN", .toType = "JSON"},
+      {.fromType = "TINYINT", .toType = "JSON"},
+      {.fromType = "SMALLINT", .toType = "JSON"},
+      {.fromType = "INTEGER", .toType = "JSON"},
+      {.fromType = "BIGINT", .toType = "JSON"},
+      {.fromType = "REAL", .toType = "JSON"},
+      {.fromType = "DOUBLE", .toType = "JSON"},
+      {.fromType = "VARCHAR", .toType = "JSON"},
+      {.fromType = "TIMESTAMP", .toType = "JSON"},
+      {.fromType = "DATE",
+       .toType = "JSON",
+       .implicitAllowed = false,
+       .validator = {}},
+      {.fromType = "DECIMAL",
+       .toType = "JSON",
+       .implicitAllowed = false,
+       .validator = canCastDecimalToJson},
+      // TO JSON (from container types with recursive validation).
+      {.fromType = "ARRAY",
+       .toType = "JSON",
+       .implicitAllowed = false,
+       .validator = canCastArrayToJson},
+      {.fromType = "ROW",
+       .toType = "JSON",
+       .implicitAllowed = false,
+       .validator = canCastRowToJson},
+      {.fromType = "MAP",
+       .toType = "JSON",
+       .implicitAllowed = false,
+       .validator = canCastMapToJson},
+      // FROM JSON (to primitive types).
+      // Note: JSON -> TIMESTAMP is not supported in Presto.
+      {.fromType = "JSON", .toType = "BOOLEAN"},
+      {.fromType = "JSON", .toType = "TINYINT"},
+      {.fromType = "JSON", .toType = "SMALLINT"},
+      {.fromType = "JSON", .toType = "INTEGER"},
+      {.fromType = "JSON", .toType = "BIGINT"},
+      {.fromType = "JSON", .toType = "REAL"},
+      {.fromType = "JSON", .toType = "DOUBLE"},
+      {.fromType = "JSON", .toType = "VARCHAR"},
+      // FROM JSON (to container types with recursive validation).
+      {.fromType = "JSON",
+       .toType = "ARRAY",
+       .implicitAllowed = false,
+       .validator = canCastJsonToArray},
+      {.fromType = "JSON",
+       .toType = "ROW",
+       .implicitAllowed = false,
+       .validator = canCastJsonToRow},
+      {.fromType = "JSON",
+       .toType = "MAP",
+       .implicitAllowed = false,
+       .validator = canCastJsonToMap},
+  });
 }
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/KHyperLogLogRegistration.cpp b/velox/functions/prestosql/types/KHyperLogLogRegistration.cpp
new file mode 100644
index 00000000000..ec726f8e217
--- /dev/null
+++ b/velox/functions/prestosql/types/KHyperLogLogRegistration.cpp
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/types/KHyperLogLogRegistration.h"
+
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+#include "velox/functions/prestosql/types/fuzzer_utils/KHyperLogLogInputGenerator.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+namespace {
+class KHyperLogLogTypeFactory : public CustomTypeFactory {
+ public:
+  TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
+    VELOX_CHECK(parameters.empty());
+    return KHYPERLOGLOG();
+  }
+
+  // KHyperLogLog should be treated as Varbinary during type castings.
+  exec::CastOperatorPtr getCastOperator() const override {
+    return nullptr;
+  }
+
+  AbstractInputGeneratorPtr getInputGenerator(
+      const InputGeneratorConfig& config) const override {
+    return std::static_pointer_cast<AbstractInputGenerator>(
+        std::make_shared<fuzzer::KHyperLogLogInputGenerator>(
+            config.seed_, config.nullRatio_, config.pool_));
+  }
+};
+} // namespace
+void registerKHyperLogLogType() {
+  registerCustomType(
+      "khyperloglog", std::make_unique<const KHyperLogLogTypeFactory>());
+}
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/KHyperLogLogRegistration.h b/velox/functions/prestosql/types/KHyperLogLogRegistration.h
new file mode 100644
index 00000000000..b084ca2f5c3
--- /dev/null
+++ b/velox/functions/prestosql/types/KHyperLogLogRegistration.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+namespace facebook::velox {
+
+void registerKHyperLogLogType();
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/KHyperLogLogType.h b/velox/functions/prestosql/types/KHyperLogLogType.h
new file mode 100644
index 00000000000..0cd7fd10a09
--- /dev/null
+++ b/velox/functions/prestosql/types/KHyperLogLogType.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/type/SimpleFunctionApi.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+
+class KHyperLogLogType final : public VarbinaryType {
+  KHyperLogLogType() = default;
+
+ public:
+  static std::shared_ptr<const KHyperLogLogType> get() {
+    VELOX_CONSTEXPR_SINGLETON KHyperLogLogType kInstance;
+    return {std::shared_ptr<const KHyperLogLogType>{}, &kInstance};
+  }
+
+  bool equivalent(const Type& other) const override {
+    // Pointer comparison works since this type is a singleton.
+    return this == &other;
+  }
+
+  const char* name() const override {
+    return "KHYPERLOGLOG";
+  }
+
+  std::string toString() const override {
+    return name();
+  }
+
+  folly::dynamic serialize() const override {
+    folly::dynamic obj = folly::dynamic::object;
+    obj["name"] = "Type";
+    obj["type"] = name();
+    return obj;
+  }
+
+  bool isOrderable() const override {
+    return false;
+  }
+};
+
+inline bool isKHyperLogLogType(const TypePtr& type) {
+  // Pointer comparison works since this type is a singleton.
+  return KHyperLogLogType::get() == type;
+}
+
+inline std::shared_ptr<const KHyperLogLogType> KHYPERLOGLOG() {
+  return KHyperLogLogType::get();
+}
+
+// Type to use for inputs and outputs of simple functions, e.g.
+// arg_type<KHyperLogLog> and out_type<KHyperLogLog>.
+struct KHyperLogLogT {
+  using type = Varbinary;
+  static constexpr const char* typeName = "khyperloglog";
+};
+
+using KHyperLogLog = CustomType<KHyperLogLogT>;
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/P4HyperLogLogRegistration.cpp b/velox/functions/prestosql/types/P4HyperLogLogRegistration.cpp
index f3e6c8d9cf9..34531e96a34 100644
--- a/velox/functions/prestosql/types/P4HyperLogLogRegistration.cpp
+++ b/velox/functions/prestosql/types/P4HyperLogLogRegistration.cpp
@@ -16,12 +16,122 @@
 
 #include "velox/functions/prestosql/types/P4HyperLogLogRegistration.h"
 
+#include "velox/common/hyperloglog/DenseHll.h"
+#include "velox/common/hyperloglog/SparseHll.h"
+#include "velox/expression/CastExpr.h"
+#include "velox/functions/prestosql/types/HyperLogLogType.h"
 #include "velox/functions/prestosql/types/P4HyperLogLogType.h"
 #include "velox/functions/prestosql/types/fuzzer_utils/P4HyperLogLogInputGenerator.h"
-#include "velox/type/Type.h"
+#include "velox/type/CastRegistry.h"
 
 namespace facebook::velox {
 namespace {
+
+class P4HyperLogLogCastOperator : public exec::CastOperator {
+ public:
+  void castTo(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      const TypePtr& /*resultType*/,
+      VectorPtr& result) const override {
+    context.ensureWritable(rows, P4HYPERLOGLOG(), result);
+
+    if (input.type()->equivalent(*HYPERLOGLOG())) {
+      // Cast from HYPERLOGLOG to P4HYPERLOGLOG - sparse to dense conversion
+      castFromHyperLogLog(input, context, rows, *result);
+    } else {
+      VELOX_UNSUPPORTED(
+          "Cast from {} to P4HyperLogLog not supported",
+          input.type()->toString());
+    }
+  }
+
+  void castFrom(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      const TypePtr& resultType,
+      VectorPtr& result) const override {
+    context.ensureWritable(rows, resultType, result);
+
+    if (resultType->equivalent(*HYPERLOGLOG())) {
+      // Cast to HYPERLOGLOG - direct copy (already dense)
+      directCopy(input, context, rows, *result);
+    } else {
+      VELOX_UNSUPPORTED(
+          "Cast from P4HyperLogLog to {} not supported",
+          resultType->toString());
+    }
+  }
+
+ private:
+  // Direct copy for P4HYPERLOGLOG to HYPERLOGLOG conversion.
+  // No conversion needed since P4HyperLogLog is already in dense format.
+  void directCopy(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      BaseVector& result) const {
+    auto* flatResult = result.as<FlatVector<StringView>>();
+    const auto* inputVector = input.as<SimpleVector<StringView>>();
+
+    flatResult->acquireSharedStringBuffers(&input);
+    context.applyToSelectedNoThrow(rows, [&](auto row) {
+      const auto data = inputVector->valueAt(row);
+      flatResult->setNoCopy(row, data);
+    });
+  }
+
+  // The meaningful conversion: HYPERLOGLOG to P4HYPERLOGLOG (sparse to dense)
+  static void castFromHyperLogLog(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      BaseVector& result) {
+    auto* flatResult = result.as<FlatVector<StringView>>();
+    const auto* hllInput = input.as<SimpleVector<StringView>>();
+
+    memory::MemoryPool* memoryPool = context.pool();
+    using SparseHll = common::hll::SparseHll<memory::MemoryPool>;
+    using DenseHll = common::hll::DenseHll<memory::MemoryPool>;
+    using common::hll::DenseHlls;
+    using common::hll::SparseHlls;
+
+    context.applyToSelectedNoThrow(rows, [&](auto row) {
+      const auto hllData = hllInput->valueAt(row);
+      exec::StringWriter writer(flatResult, row);
+
+      if (hllData.size() == 0 || hllData.data() == nullptr) {
+        writer.resize(0);
+        writer.finalize();
+        return;
+      }
+
+      if (SparseHlls::canDeserialize(hllData.data())) {
+        // Input is sparse - convert to dense
+        int8_t indexBitLength =
+            SparseHlls::deserializeIndexBitLength(hllData.data());
+
+        SparseHll sparseHll(hllData.data(), memoryPool);
+        DenseHll denseHll(indexBitLength, memoryPool);
+        sparseHll.toDense(denseHll);
+
+        int32_t serializedSize = denseHll.serializedSize();
+        writer.resize(serializedSize);
+        denseHll.serialize(writer.data());
+      } else if (DenseHlls::canDeserialize(hllData.data())) {
+        // Input is already dense - direct copy.
+        writer.copy_from(hllData);
+      } else {
+        VELOX_USER_FAIL("Invalid HyperLogLog format");
+      }
+
+      writer.finalize();
+    });
+  }
+};
+
 class P4HyperLogLogTypeFactory : public CustomTypeFactory {
  public:
   TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
@@ -29,20 +139,24 @@ class P4HyperLogLogTypeFactory : public CustomTypeFactory {
     return P4HYPERLOGLOG();
   }
 
-  // P4HyperLogLog should be treated as Varbinary during type castings.
   exec::CastOperatorPtr getCastOperator() const override {
-    return nullptr;
+    return std::make_shared<P4HyperLogLogCastOperator>();
   }
 
   AbstractInputGeneratorPtr getInputGenerator(
       const InputGeneratorConfig& config) const override {
-    return std::make_shared<fuzzer::P4HyperLogLogInputGenerator>(
-        config.seed_, config.nullRatio_, config.pool_);
+    return std::static_pointer_cast<AbstractInputGenerator>(
+        std::make_shared<fuzzer::P4HyperLogLogInputGenerator>(
+            config.seed_, config.nullRatio_, config.pool_));
   }
 };
 } // namespace
 void registerP4HyperLogLogType() {
   registerCustomType(
-      "p4hyperloglog", std::make_unique<const P4HyperLogLogTypeFactory>());
+      "P4HYPERLOGLOG", std::make_unique<const P4HyperLogLogTypeFactory>());
+  registerCastRules({
+      {.fromType = "HYPERLOGLOG", .toType = "P4HYPERLOGLOG"},
+      {.fromType = "P4HYPERLOGLOG", .toType = "HYPERLOGLOG"},
+  });
 }
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/PrestoTypes.cpp b/velox/functions/prestosql/types/PrestoTypes.cpp
new file mode 100644
index 00000000000..a749484e3b5
--- /dev/null
+++ b/velox/functions/prestosql/types/PrestoTypes.cpp
@@ -0,0 +1,258 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/types/PrestoTypes.h"
+
+#include <fmt/format.h>
+#include <velox/common/base/Exceptions.h>
+#include <iomanip>
+#include <sstream>
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/SimpleVector.h"
+
+namespace facebook::velox {
+
+namespace {
+bool isPlainArray(const Type& type) {
+  return type.isArray() && typeid(type) == typeid(ArrayType);
+}
+
+bool isPlainMap(const Type& type) {
+  return type.isMap() && typeid(type) == typeid(MapType);
+}
+
+bool isPlainRow(const Type& type) {
+  return type.isRow() && typeid(type) == typeid(RowType);
+}
+
+// Returns true if a ROW field name needs quoting in Presto SQL.
+// Field names that are not simple identifiers (letters, digits, underscores
+// starting with a letter or underscore) must be quoted.
+bool needsQuoting(const std::string& name) {
+  if (name.empty()) {
+    return false;
+  }
+  if (name[0] != '_' && !std::isalpha(name[0])) {
+    return true;
+  }
+  for (auto c : name) {
+    if (c != '_' && !std::isalnum(c)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+} // namespace
+
+std::string PrestoTypes::toSql(const TypePtr& type) {
+  if (isPlainArray(*type)) {
+    return fmt::format("ARRAY({})", toSql(type->childAt(0)));
+  }
+
+  if (isPlainMap(*type)) {
+    return fmt::format(
+        "MAP({}, {})", toSql(type->childAt(0)), toSql(type->childAt(1)));
+  }
+
+  if (isPlainRow(*type)) {
+    const auto& rowType = type->asRow();
+    std::stringstream sql;
+    sql << "ROW(";
+    for (auto i = 0; i < type->size(); ++i) {
+      if (i > 0) {
+        sql << ", ";
+      }
+      const auto& name = rowType.nameOf(i);
+      if (!name.empty()) {
+        if (needsQuoting(name)) {
+          sql << std::quoted(name, '"', '"') << " ";
+        } else {
+          sql << name << " ";
+        }
+      }
+      sql << toSql(type->childAt(i));
+    }
+    sql << ")";
+    return sql.str();
+  }
+
+  // Primitive types and custom types (e.g. IPPREFIX, BINGTILE).
+  // For parameterized types (e.g. TDIGEST(DOUBLE), DECIMAL(10, 2)),
+  // append parameters.
+  const auto& params = type->parameters();
+  if (params.empty()) {
+    return type->name();
+  }
+
+  std::stringstream sql;
+  sql << type->name() << "(";
+  for (auto i = 0; i < params.size(); ++i) {
+    if (i > 0) {
+      sql << ", ";
+    }
+    switch (params[i].kind) {
+      case TypeParameterKind::kType:
+        sql << toSql(params[i].type);
+        break;
+      case TypeParameterKind::kLongLiteral:
+        sql << params[i].longLiteral.value();
+        break;
+      default:
+        VELOX_UNSUPPORTED(
+            "Unsupported type parameter kind: {}",
+            TypeParameterKindName::toName(params[i].kind));
+    }
+  }
+  sql << ")";
+  return sql.str();
+}
+
+namespace {
+template <TypeKind kind>
+std::string scalarValueToString(
+    const DecodedVector& decoded,
+    vector_size_t index,
+    const TypePtr& type) {
+  using T = typename TypeTraits<kind>::NativeType;
+  return PrestoTypes::valueToString(decoded.valueAt<T>(index), type);
+}
+} // namespace
+
+std::string PrestoTypes::valueToString(
+    const DecodedVector& decoded,
+    vector_size_t index,
+    const TypePtr& type) {
+  if (decoded.isNullAt(index)) {
+    return "null";
+  }
+
+  if (isIPPrefixType(type)) {
+    auto* rowVector = decoded.base()->as<RowVector>();
+    const auto decodedIndex = decoded.index(index);
+    const auto ip =
+        rowVector->childAt(0)->as<SimpleVector<int128_t>>()->valueAt(
+            decodedIndex);
+    const auto prefixLength =
+        rowVector->childAt(1)->as<SimpleVector<int8_t>>()->valueAt(
+            decodedIndex);
+    char buffer[IPPrefixType::kMaxStringSize];
+    return std::string(IPPREFIX()->valueToString(ip, prefixLength, buffer));
+  }
+
+  if (type->isPrimitiveType()) {
+    return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+        scalarValueToString, type->kind(), decoded, index, type);
+  }
+
+  const auto decodedIndex = decoded.index(index);
+
+  if (type->isArray()) {
+    auto* arrayVector = decoded.base()->as<ArrayVector>();
+    const auto offset = arrayVector->offsetAt(decodedIndex);
+    const auto size = arrayVector->sizeAt(decodedIndex);
+    const auto& elements = arrayVector->elements();
+    DecodedVector decodedElements(*elements);
+    std::stringstream result;
+    result << "[";
+    for (auto i = 0; i < size; ++i) {
+      if (i > 0) {
+        result << ", ";
+      }
+      result << valueToString(decodedElements, offset + i, type->childAt(0));
+    }
+    result << "]";
+    return result.str();
+  }
+
+  if (type->isMap()) {
+    auto* mapVector = decoded.base()->as<MapVector>();
+    const auto offset = mapVector->offsetAt(decodedIndex);
+    const auto size = mapVector->sizeAt(decodedIndex);
+    const auto& keys = mapVector->mapKeys();
+    const auto& values = mapVector->mapValues();
+    DecodedVector decodedKeys(*keys);
+    DecodedVector decodedValues(*values);
+    std::stringstream result;
+    result << "{";
+    for (auto i = 0; i < size; ++i) {
+      if (i > 0) {
+        result << ", ";
+      }
+      result << valueToString(decodedKeys, offset + i, type->childAt(0)) << "="
+             << valueToString(decodedValues, offset + i, type->childAt(1));
+    }
+    result << "}";
+    return result.str();
+  }
+
+  if (type->isRow()) {
+    auto* rowVector = decoded.base()->as<RowVector>();
+    const auto& rowType = type->asRow();
+    std::stringstream result;
+    result << "{";
+    for (auto i = 0; i < rowVector->childrenSize(); ++i) {
+      if (i > 0) {
+        result << ", ";
+      }
+      const auto& child = rowVector->childAt(i);
+      DecodedVector decodedChild(*child);
+      const auto& fieldName = rowType.nameOf(i);
+      if (fieldName.empty()) {
+        result << "field" << i;
+      } else {
+        result << fieldName;
+      }
+      result << "="
+             << valueToString(decodedChild, decodedIndex, type->childAt(i));
+    }
+    result << "}";
+    return result.str();
+  }
+
+  return decoded.toString(index);
+}
+
+std::string PrestoTypes::timestampToPrestoString(Timestamp value) {
+  // Uses millisecond precision to match Presto Java's SqlTimestamp.JSON_FORMAT
+  // ("uuuu-MM-dd HH:mm:ss.SSS"). Sub-millisecond nanos are truncated.
+  // This is consistent with PrestoCastHooks (non-legacy mode), which sets the
+  // same options for CAST(timestamp AS varchar).
+  // TODO: Support microsecond precision for TIMESTAMP(6) if needed.
+  static const TimestampToStringOptions kPrestoOptions{
+      .precision = TimestampToStringOptions::Precision::kMilliseconds,
+      .zeroPaddingYear = true,
+      .dateTimeSeparator = ' ',
+  };
+  return value.toString(kPrestoOptions);
+}
+
+std::string PrestoTypes::toHex(StringView value) {
+  std::string result;
+  result.reserve(value.size() * 3);
+  for (size_t i = 0; i < value.size(); ++i) {
+    if (i > 0) {
+      result += ' ';
+    }
+    fmt::format_to(
+        std::back_inserter(result),
+        "{:02x}",
+        static_cast<uint8_t>(value.data()[i]));
+  }
+  return result;
+}
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/PrestoTypes.h b/velox/functions/prestosql/types/PrestoTypes.h
new file mode 100644
index 00000000000..b763277f07b
--- /dev/null
+++ b/velox/functions/prestosql/types/PrestoTypes.h
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <fmt/format.h>
+#include "velox/functions/prestosql/types/BingTileType.h"
+#include "velox/functions/prestosql/types/IPAddressType.h"
+#include "velox/functions/prestosql/types/IPPrefixType.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
+#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/functions/prestosql/types/UuidType.h"
+#include "velox/type/Type.h"
+#include "velox/vector/DecodedVector.h"
+
+namespace facebook::velox {
+
+/// Groups Presto-specific type operations: SQL type rendering and
+/// human-readable value formatting for Presto custom types (BINGTILE,
+/// IPADDRESS, UUID, IPPREFIX, TIMESTAMP WITH TIME ZONE, TIME WITH TIME ZONE)
+/// on top of the core Type::valueToString template.
+class PrestoTypes {
+ public:
+  /// Returns the Presto SQL string representation of the given type.
+  static std::string toSql(const TypePtr& type);
+
+  /// Formats a scalar value as a human-readable string using Presto type
+  /// conventions. Handles Presto custom types (IPADDRESS, UUID,
+  /// TIMESTAMP WITH TIME ZONE, TIME WITH TIME ZONE) in addition to core types
+  /// handled by Type::valueToString.
+  template <typename T>
+  static std::string valueToString(T value, const TypePtr& type);
+
+  /// Formats a value from a decoded vector as a human-readable string
+  /// matching Presto's output format. Returns "null" for null values.
+  /// Handles scalar types, composite types (IPPREFIX), and complex types
+  /// (ARRAY, MAP, ROW) with recursive rendering.
+  static std::string valueToString(
+      const DecodedVector& decoded,
+      vector_size_t index,
+      const TypePtr& type);
+
+ private:
+  // Formats a Timestamp in Presto format: space separator, millisecond
+  // precision, zero-padded year. Consistent with PrestoCastHooks (non-legacy)
+  // options for CAST(timestamp AS varchar).
+  static std::string timestampToPrestoString(Timestamp value);
+
+  // Formats binary data as space-separated hex bytes (e.g., "02 0c 01 00").
+  static std::string toHex(StringView value);
+};
+
+template <typename T>
+std::string PrestoTypes::valueToString(T value, const TypePtr& type) {
+  if constexpr (std::is_same_v<T, int128_t>) {
+    if (isIPAddressType(type)) {
+      return IPADDRESS()->valueToString(value);
+    }
+    if (isUuidType(type)) {
+      char buffer[UuidType::kStringSize];
+      return std::string(UUID()->valueToString(value, buffer));
+    }
+  } else if constexpr (std::is_same_v<T, int64_t>) {
+    if (isTimestampWithTimeZoneType(type)) {
+      return TIMESTAMP_WITH_TIME_ZONE()->valueToString(value);
+    }
+    if (isTimeWithTimeZone(type)) {
+      char buffer[TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize];
+      return std::string(TIME_WITH_TIME_ZONE()->valueToString(value, buffer));
+    }
+    if (isBingTileType(type)) {
+      return fmt::format(
+          "{{x={}, y={}, zoom={}}}",
+          BingTileType::bingTileX(value),
+          BingTileType::bingTileY(value),
+          BingTileType::bingTileZoom(value));
+    }
+  } else if constexpr (std::is_same_v<T, Timestamp>) {
+    return timestampToPrestoString(value);
+  } else if constexpr (std::is_same_v<T, StringView>) {
+    if (type->isVarbinary()) {
+      return toHex(value);
+    }
+  }
+  return type->valueToString(value);
+}
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/QDigestRegistration.cpp b/velox/functions/prestosql/types/QDigestRegistration.cpp
index d6fb7523eb8..af7f0ae5cec 100644
--- a/velox/functions/prestosql/types/QDigestRegistration.cpp
+++ b/velox/functions/prestosql/types/QDigestRegistration.cpp
@@ -37,7 +37,7 @@ class QDigestTypeFactory : public CustomTypeFactory {
   AbstractInputGeneratorPtr getInputGenerator(
       const InputGeneratorConfig& config) const override {
     VELOX_USER_CHECK_NOT_NULL(config.type_, "QDigest Type must be provided");
-    const auto& parameters = config.type_->parameters();
+    auto parameters = config.type_->parameters();
 
     VELOX_USER_CHECK(
         parameters.size() == 1 &&
diff --git a/velox/functions/prestosql/types/QDigestType.h b/velox/functions/prestosql/types/QDigestType.h
index 45b0eef5f33..e42adb08ab9 100644
--- a/velox/functions/prestosql/types/QDigestType.h
+++ b/velox/functions/prestosql/types/QDigestType.h
@@ -48,12 +48,12 @@ class QDigestType final : public VarbinaryType {
     return "QDIGEST";
   }
 
-  const std::vector<TypeParameter>& parameters() const override {
-    return parameters_;
+  std::span<const TypeParameter> parameters() const override {
+    return {&parameter_, 1};
   }
 
   std::string toString() const override {
-    return fmt::format("QDIGEST({})", parameters_[0].type->toString());
+    return fmt::format("QDIGEST({})", parameter_.type->toString());
   }
 
   folly::dynamic serialize() const override {
@@ -61,9 +61,7 @@ class QDigestType final : public VarbinaryType {
     obj["name"] = "Type";
     obj["type"] = name();
     folly::dynamic children = folly::dynamic::array;
-    for (auto& param : parameters_) {
-      children.push_back(param.type->serialize());
-    }
+    children.push_back(parameter_.type->serialize());
     obj["cTypes"] = children;
     return obj;
   }
@@ -73,10 +71,9 @@ class QDigestType final : public VarbinaryType {
   }
 
  private:
-  explicit QDigestType(const TypePtr& dataType)
-      : parameters_({TypeParameter(dataType)}) {}
+  explicit QDigestType(const TypePtr& dataType) : parameter_(dataType) {}
 
-  const std::vector<TypeParameter> parameters_;
+  const TypeParameter parameter_;
 };
 
 inline std::shared_ptr<const QDigestType> QDIGEST(const TypePtr& dataType) {
diff --git a/velox/functions/prestosql/types/SetDigestRegistration.cpp b/velox/functions/prestosql/types/SetDigestRegistration.cpp
new file mode 100644
index 00000000000..8bdf8749ddb
--- /dev/null
+++ b/velox/functions/prestosql/types/SetDigestRegistration.cpp
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/types/SetDigestRegistration.h"
+
+#include "velox/common/fuzzer/ConstrainedGenerators.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+namespace {
+class SetDigestTypeFactory : public CustomTypeFactory {
+ public:
+  TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
+    VELOX_CHECK(parameters.empty());
+    return SETDIGEST();
+  }
+
+  // SetDigest should be treated as Varbinary during type castings.
+  exec::CastOperatorPtr getCastOperator() const override {
+    return nullptr;
+  }
+
+  AbstractInputGeneratorPtr getInputGenerator(
+      const InputGeneratorConfig& config) const override {
+    return std::make_shared<fuzzer::SetDigestInputGenerator>(
+        config.seed_, SETDIGEST(), config.nullRatio_);
+  }
+};
+} // namespace
+void registerSetDigestType() {
+  registerCustomType(
+      "setdigest", std::make_unique<const SetDigestTypeFactory>());
+}
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/SetDigestRegistration.h b/velox/functions/prestosql/types/SetDigestRegistration.h
new file mode 100644
index 00000000000..fef3747a1d7
--- /dev/null
+++ b/velox/functions/prestosql/types/SetDigestRegistration.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+namespace facebook::velox {
+
+void registerSetDigestType();
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/SetDigestType.h b/velox/functions/prestosql/types/SetDigestType.h
new file mode 100644
index 00000000000..2dd2f3c19d4
--- /dev/null
+++ b/velox/functions/prestosql/types/SetDigestType.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/type/SimpleFunctionApi.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+
+class SetDigestType final : public VarbinaryType {
+  SetDigestType() = default;
+
+ public:
+  static std::shared_ptr<const SetDigestType> get() {
+    VELOX_CONSTEXPR_SINGLETON SetDigestType kInstance;
+    return {std::shared_ptr<const SetDigestType>{}, &kInstance};
+  }
+
+  bool equivalent(const Type& other) const override {
+    // Pointer comparison works since this type is a singleton.
+    return this == &other;
+  }
+
+  const char* name() const override {
+    return "SETDIGEST";
+  }
+
+  std::string toString() const override {
+    return name();
+  }
+
+  folly::dynamic serialize() const override {
+    folly::dynamic obj = folly::dynamic::object;
+    obj["name"] = "Type";
+    obj["type"] = name();
+    return obj;
+  }
+
+  bool isOrderable() const override {
+    return false;
+  }
+};
+
+inline bool isSetDigestType(const TypePtr& type) {
+  // Pointer comparison works since this type is a singleton.
+  return SetDigestType::get() == type;
+}
+
+inline std::shared_ptr<const SetDigestType> SETDIGEST() {
+  return SetDigestType::get();
+}
+
+// Type to use for inputs and outputs of simple functions, e.g.
+// arg_type<SetDigest> and out_type<SetDigest>.
+struct SetDigestT {
+  using type = Varbinary;
+  static constexpr const char* typeName = "setdigest";
+};
+
+using SetDigest = CustomType<SetDigestT>;
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/SphericalGeographyRegistration.cpp b/velox/functions/prestosql/types/SphericalGeographyRegistration.cpp
new file mode 100644
index 00000000000..cf5b02dac8e
--- /dev/null
+++ b/velox/functions/prestosql/types/SphericalGeographyRegistration.cpp
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/types/SphericalGeographyRegistration.h"
+
+#include "velox/expression/CastExpr.h"
+#include "velox/functions/prestosql/types/SphericalGeographyType.h"
+
+namespace facebook::velox {
+
+namespace {
+class SphericalGeographyTypeFactory : public CustomTypeFactory {
+ public:
+  TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
+    VELOX_CHECK(parameters.empty());
+    return SPHERICAL_GEOGRAPHY();
+  }
+
+  exec::CastOperatorPtr getCastOperator() const override {
+    return nullptr;
+  }
+
+  AbstractInputGeneratorPtr getInputGenerator(
+      const InputGeneratorConfig& /*config*/) const override {
+    return nullptr;
+  }
+};
+} // namespace
+
+void registerSphericalGeographyType() {
+  // Register the spherical_geography type with the type registry.
+  registerCustomType(
+      "sphericalgeography",
+      std::make_unique<const SphericalGeographyTypeFactory>());
+}
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/SphericalGeographyRegistration.h b/velox/functions/prestosql/types/SphericalGeographyRegistration.h
new file mode 100644
index 00000000000..34ab464a247
--- /dev/null
+++ b/velox/functions/prestosql/types/SphericalGeographyRegistration.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+namespace facebook::velox {
+
+void registerSphericalGeographyType();
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/SphericalGeographyType.h b/velox/functions/prestosql/types/SphericalGeographyType.h
new file mode 100644
index 00000000000..85f13a750f3
--- /dev/null
+++ b/velox/functions/prestosql/types/SphericalGeographyType.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/expression/CastExpr.h"
+#include "velox/type/SimpleFunctionApi.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+
+class SphericalGeographyType final : public VarbinaryType {
+  SphericalGeographyType() = default;
+
+ public:
+  static std::shared_ptr<const SphericalGeographyType> get() {
+    VELOX_CONSTEXPR_SINGLETON SphericalGeographyType kInstance;
+    return {std::shared_ptr<const SphericalGeographyType>{}, &kInstance};
+  }
+
+  bool equivalent(const Type& other) const override {
+    // Pointer comparison works since this type is a singleton.
+    return this == &other;
+  }
+
+  const char* name() const override {
+    return "SPHERICALGEOGRAPHY";
+  }
+
+  std::string toString() const override {
+    return name();
+  }
+
+  folly::dynamic serialize() const override {
+    folly::dynamic obj = folly::dynamic::object;
+    obj["name"] = "Type";
+    obj["type"] = name();
+    return obj;
+  }
+
+  bool isOrderable() const override {
+    return false;
+  }
+};
+
+FOLLY_ALWAYS_INLINE bool isSphericalGeographyType(const TypePtr& type) {
+  // Pointer comparison works since this type is a singleton.
+  return SphericalGeographyType::get() == type;
+}
+
+FOLLY_ALWAYS_INLINE std::shared_ptr<const SphericalGeographyType>
+SPHERICAL_GEOGRAPHY() {
+  return SphericalGeographyType::get();
+}
+
+// Type used for function registration.
+struct SphericalGeographyT {
+  using type = Varbinary;
+  static constexpr const char* typeName = "sphericalgeography";
+};
+
+using SphericalGeography = CustomType<SphericalGeographyT>;
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/TDigestType.h b/velox/functions/prestosql/types/TDigestType.h
index b4efaacd445..a3e48e183f8 100644
--- a/velox/functions/prestosql/types/TDigestType.h
+++ b/velox/functions/prestosql/types/TDigestType.h
@@ -39,12 +39,12 @@ class TDigestType final : public VarbinaryType {
     return "TDIGEST";
   }
 
-  const std::vector<TypeParameter>& parameters() const override {
-    return parameters_;
+  std::span<const TypeParameter> parameters() const override {
+    return {&parameter_, 1};
   }
 
   std::string toString() const override {
-    return fmt::format("TDIGEST({})", parameters_[0].type->toString());
+    return fmt::format("TDIGEST({})", parameter_.type->toString());
   }
 
   folly::dynamic serialize() const override {
@@ -52,9 +52,7 @@ class TDigestType final : public VarbinaryType {
     obj["name"] = "Type";
     obj["type"] = name();
     folly::dynamic children = folly::dynamic::array;
-    for (auto& param : parameters_) {
-      children.push_back(param.type->serialize());
-    }
+    children.push_back(parameter_.type->serialize());
     obj["cTypes"] = children;
     return obj;
   }
@@ -64,10 +62,9 @@ class TDigestType final : public VarbinaryType {
   }
 
  private:
-  explicit TDigestType(const TypePtr& dataType)
-      : parameters_({TypeParameter(dataType)}) {}
+  explicit TDigestType(const TypePtr& dataType) : parameter_(dataType) {}
 
-  const std::vector<TypeParameter> parameters_;
+  const TypeParameter parameter_;
 };
 
 inline bool isTDigestType(const TypePtr& type) {
diff --git a/velox/functions/prestosql/types/TimeWithTimezoneRegistration.cpp b/velox/functions/prestosql/types/TimeWithTimezoneRegistration.cpp
new file mode 100644
index 00000000000..d9ae4a355ed
--- /dev/null
+++ b/velox/functions/prestosql/types/TimeWithTimezoneRegistration.cpp
@@ -0,0 +1,282 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/prestosql/types/TimeWithTimezoneRegistration.h"
+
+#include "velox/expression/CastExpr.h"
+#include "velox/external/tzdb/time_zone.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
+#include "velox/functions/prestosql/types/fuzzer_utils/TimeWithTimezoneInputGenerator.h"
+#include "velox/type/CastRegistry.h"
+#include "velox/type/Time.h"
+#include "velox/type/Type.h"
+#include "velox/type/tz/TimeZoneMap.h"
+#include "velox/vector/DecodedVector.h"
+
+namespace facebook::velox {
+
+namespace {
+void castToTime(
+    const BaseVector& input,
+    exec::EvalCtx& context,
+    const SelectivityVector& rows,
+    BaseVector& result) {
+  auto* flatResult = result.asFlatVector<int64_t>();
+
+  auto convertToLocalTime = [](int64_t timeWithTimezone) {
+    int64_t millisUtc = util::unpackMillisUtc(timeWithTimezone);
+    auto timezoneMinutes = util::unpackZoneOffset(timeWithTimezone);
+    int16_t offsetMinutes = util::decodeTimezoneOffset(timezoneMinutes);
+    return util::utcToLocalTime(millisUtc, offsetMinutes);
+  };
+
+  if (input.isConstantEncoding()) {
+    const auto timeWithTimezone =
+        input.as<ConstantVector<int64_t>>()->valueAt(0);
+    context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
+      flatResult->set(row, convertToLocalTime(timeWithTimezone));
+    });
+    return;
+  }
+  const auto timeWithTimezones = input.as<FlatVector<int64_t>>();
+  context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
+    const auto timeWithTimezone = timeWithTimezones->valueAt(row);
+    flatResult->set(row, convertToLocalTime(timeWithTimezone));
+  });
+}
+
+void castToString(
+    const BaseVector& input,
+    exec::EvalCtx& context,
+    const SelectivityVector& rows,
+    BaseVector& result) {
+  auto* flatResult = result.asFlatVector<StringView>();
+  DecodedVector decoded(input, rows);
+  Buffer* buffer = flatResult->getBufferWithSpace(
+      rows.countSelected() *
+          TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize,
+      true /*exactSize*/);
+  char* rawBuffer = buffer->asMutable<char>() + buffer->size();
+  context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
+    const auto timeWithTimezone = decoded.valueAt<int64_t>(row);
+    auto output =
+        TIME_WITH_TIME_ZONE()->valueToString(timeWithTimezone, rawBuffer);
+    flatResult->setNoCopy(row, StringView(output.data(), output.size()));
+    rawBuffer += output.size();
+  });
+  buffer->setSize(rawBuffer - buffer->asMutable<char>());
+}
+
+void castFromString(
+    const BaseVector& input,
+    exec::EvalCtx& context,
+    const SelectivityVector& rows,
+    BaseVector& result) {
+  auto* flatResult = result.asFlatVector<int64_t>();
+  DecodedVector decoded(input, rows);
+
+  context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
+    const auto stringValue = decoded.valueAt<StringView>(row);
+
+    auto parseResult = util::fromTimeWithTimezoneString(stringValue);
+    if (parseResult.hasError()) {
+      context.setStatus(row, parseResult.error());
+      return;
+    }
+
+    flatResult->set(row, parseResult.value());
+  });
+}
+
+const tz::TimeZone* getTimeZoneFromConfig(const core::QueryConfig& config) {
+  const auto sessionTzName = config.sessionTimezone();
+
+  if (!sessionTzName.empty()) {
+    return tz::locateZone(sessionTzName);
+  }
+
+  return tz::locateZone(0); // GMT
+}
+
+// Calculate timezone offset in minutes at the given timestamp.
+// Since TIME has no date component, we use session start time to determine
+// which DST offset to apply.
+inline int16_t getTimezoneOffsetMinutes(
+    const tz::TimeZone* sessionTimeZone,
+    int64_t sessionStartTimeMs) {
+  if (auto offset = sessionTimeZone->offset()) {
+    return static_cast<int16_t>(offset->count());
+  }
+  auto sysTime = std::chrono::time_point<std::chrono::system_clock>(
+      std::chrono::milliseconds(sessionStartTimeMs));
+  auto info = sessionTimeZone->tz()->get_info(sysTime);
+  auto offsetMinutes =
+      std::chrono::duration_cast<std::chrono::minutes>(info.offset);
+  return static_cast<int16_t>(offsetMinutes.count());
+}
+
+// Pack time (in milliseconds since midnight) and timezone offset minutes
+inline int64_t packTimeWithTimeZone(
+    int64_t timeMillis,
+    int16_t timezoneOffsetMinutes) {
+  auto encodedOffset = util::biasEncode(timezoneOffsetMinutes);
+  return util::pack(timeMillis, encodedOffset);
+}
+
+void castFromTime(
+    const SimpleVector<int64_t>& inputVector,
+    exec::EvalCtx& context,
+    const SelectivityVector& rows,
+    int64_t* rawResults,
+    int16_t offsetMinutes) {
+  context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
+    const auto timeMillis = inputVector.valueAt(row);
+    // Convert local time to UTC before packing
+    const auto utcMillis = util::localToUtcTime(timeMillis, offsetMinutes);
+    rawResults[row] = packTimeWithTimeZone(utcMillis, offsetMinutes);
+  });
+}
+
+class TimeWithTimeZoneCastOperator final : public exec::CastOperator {
+  TimeWithTimeZoneCastOperator() = default;
+
+ public:
+  static std::shared_ptr<const CastOperator> get() {
+    VELOX_CONSTEXPR_SINGLETON TimeWithTimeZoneCastOperator kInstance;
+    return {std::shared_ptr<const CastOperator>{}, &kInstance};
+  }
+
+  void castTo(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      const TypePtr& resultType,
+      VectorPtr& result) const override {
+    context.ensureWritable(rows, resultType, result);
+
+    // Handle VARCHAR to TIME WITH TIME ZONE
+    if (input.type() == VARCHAR()) {
+      castFromString(input, context, rows, *result);
+      return;
+    }
+
+    if (input.type()->equivalent(*TIME())) {
+      const auto& config = context.execCtx()->queryCtx()->queryConfig();
+      const auto* sessionTimeZone = getTimeZoneFromConfig(config);
+      const auto sessionStartTimeMs = config.sessionStartTimeMs();
+      int16_t offsetMinutes =
+          getTimezoneOffsetMinutes(sessionTimeZone, sessionStartTimeMs);
+
+      if (input.isConstantEncoding()) {
+        auto constantInput = input.as<ConstantVector<int64_t>>();
+        if (constantInput->isNullAt(0)) {
+          result = BaseVector::createNullConstant(
+              resultType, rows.end(), context.pool());
+          return;
+        }
+
+        const auto timeMillis = constantInput->valueAt(0);
+        // Convert local time to UTC before packing
+        const auto utcMillis = util::localToUtcTime(timeMillis, offsetMinutes);
+        auto packedValue = packTimeWithTimeZone(utcMillis, offsetMinutes);
+
+        result = std::make_shared<ConstantVector<int64_t>>(
+            context.pool(),
+            rows.end(),
+            false, // isNull
+            resultType,
+            std::move(packedValue));
+        return;
+      }
+
+      auto* timeWithTzResult = result->asFlatVector<int64_t>();
+      timeWithTzResult->clearNulls(rows);
+      auto* rawResults = timeWithTzResult->mutableRawValues();
+
+      const auto inputVector = input.as<SimpleVector<int64_t>>();
+      castFromTime(*inputVector, context, rows, rawResults, offsetMinutes);
+      return;
+    } else {
+      VELOX_UNSUPPORTED(
+          "Cast from {} to TIME WITH TIME ZONE not yet supported",
+          input.type()->toString());
+    }
+  }
+
+  void castFrom(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      const TypePtr& resultType,
+      VectorPtr& result) const override {
+    context.ensureWritable(rows, resultType, result);
+
+    switch (resultType->kind()) {
+      case TypeKind::BIGINT:
+        if (resultType->equivalent(*TIME())) {
+          castToTime(input, context, rows, *result);
+          return;
+        }
+        break;
+      case TypeKind::VARCHAR:
+        castToString(input, context, rows, *result);
+        return;
+      default:
+        break;
+    }
+
+    VELOX_UNSUPPORTED(
+        "Cast from TIME WITH TIME ZONE to {} not yet supported",
+        resultType->toString());
+  }
+};
+
+class TimeWithTimezoneTypeFactory : public CustomTypeFactory {
+ public:
+  TimeWithTimezoneTypeFactory() = default;
+
+  TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
+    VELOX_CHECK(parameters.empty());
+    return TIME_WITH_TIME_ZONE();
+  }
+
+  exec::CastOperatorPtr getCastOperator() const override {
+    return TimeWithTimeZoneCastOperator::get();
+  }
+
+  AbstractInputGeneratorPtr getInputGenerator(
+      const InputGeneratorConfig& config) const override {
+    return std::make_shared<fuzzer::TimeWithTimezoneInputGenerator>(
+        config.seed_, config.nullRatio_);
+  }
+};
+
+} // namespace
+
+void registerTimeWithTimezoneType() {
+  registerCustomType(
+      "TIME WITH TIME ZONE",
+      std::make_unique<const TimeWithTimezoneTypeFactory>());
+  registerCastRules({
+      {.fromType = "TIME",
+       .toType = "TIME WITH TIME ZONE",
+       .implicitAllowed = true},
+      {.fromType = "VARCHAR", .toType = "TIME WITH TIME ZONE"},
+      {.fromType = "TIME WITH TIME ZONE", .toType = "TIME"},
+      {.fromType = "TIME WITH TIME ZONE", .toType = "VARCHAR"},
+  });
+}
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/TimeWithTimezoneRegistration.h b/velox/functions/prestosql/types/TimeWithTimezoneRegistration.h
new file mode 100644
index 00000000000..3be397f134f
--- /dev/null
+++ b/velox/functions/prestosql/types/TimeWithTimezoneRegistration.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+namespace facebook::velox {
+void registerTimeWithTimezoneType();
+}
diff --git a/velox/functions/prestosql/types/TimeWithTimezoneType.cpp b/velox/functions/prestosql/types/TimeWithTimezoneType.cpp
new file mode 100644
index 00000000000..c7832c10c7e
--- /dev/null
+++ b/velox/functions/prestosql/types/TimeWithTimezoneType.cpp
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
+
+#include "velox/type/Time.h"
+
+namespace facebook::velox {
+
+folly::dynamic TimeWithTimezoneType::serialize() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["name"] = "Type";
+  obj["type"] = name();
+  return obj;
+}
+
+std::string_view TimeWithTimezoneType::valueToString(
+    int64_t value,
+    char* buffer) const {
+  // TIME WITH TIME ZONE is encoded similarly to TIMESTAMP WITH TIME ZONE
+  // with the most significnat 52 bits representing the time component and the
+  // least 12 bits representing the timezone minutes. This is different from
+  // TIMESTAMP WITH TIMEZONE where the last 12 bits represent the timezone
+  // offset. The timezone offset minutes are stored by value, encoded in the
+  // type itself. This allows the type to be used in a timezone-agnostic manner.
+  //
+  // The time component is a 52 bit value representing the number of
+  // milliseconds since midnight in UTC.
+
+  int64_t millisUtc = util::unpackMillisUtc(value);
+
+  // Ensure time component is within valid range
+  VELOX_CHECK_GE(millisUtc, 0, "Time component is negative");
+  VELOX_CHECK_LE(millisUtc, util::kMillisInDay, "Time component is too large");
+
+  // TimeZone's are encoded as a 12 bit value.
+  // This represents a range of -14:00 to +14:00, with 0 representing UTC.
+  // The range is from -840 to 840 minutes, we thus encode by doing bias
+  // encoding and taking 840 as the bias.
+  auto timezoneMinutes = util::unpackZoneOffset(value);
+
+  VELOX_CHECK_GE(timezoneMinutes, 0, "Timezone offset is less than -14:00");
+  VELOX_CHECK_LE(
+      timezoneMinutes, 1680, "Timezone offset is greater than +14:00");
+
+  // Decode timezone offset from bias-encoded value
+  int16_t offsetMinutes = util::decodeTimezoneOffset(timezoneMinutes);
+  auto decodedMinutes = std::abs(offsetMinutes);
+
+  const auto isBehindUTCString = (offsetMinutes >= 0) ? "+" : "-";
+
+  // Convert UTC time to local time using utility function
+  // Example: If UTC time is 06:30:00 and timezone is +05:30,
+  // the local time is 12:00:00
+  int64_t millisLocal = util::utcToLocalTime(millisUtc, offsetMinutes);
+
+  int64_t hours = millisLocal / util::kMillisInHour;
+  int64_t remainingMs = millisLocal % util::kMillisInHour;
+  int64_t minutes = remainingMs / util::kMillisInMinute;
+  remainingMs = remainingMs % util::kMillisInMinute;
+  int64_t seconds = remainingMs / util::kMillisInSecond;
+  int64_t millis = remainingMs % util::kMillisInSecond;
+
+  int16_t offsetHours = decodedMinutes / util::kMinutesInHour;
+  int16_t remainingOffsetMinutes = decodedMinutes % util::kMinutesInHour;
+
+  fmt::format_to_n(
+      buffer,
+      kTimeWithTimezoneToVarcharRowSize,
+      "{:02d}:{:02d}:{:02d}.{:03d}{}{:02d}:{:02d}",
+      hours,
+      minutes,
+      seconds,
+      millis,
+      isBehindUTCString,
+      offsetHours,
+      remainingOffsetMinutes);
+  return {buffer, kTimeWithTimezoneToVarcharRowSize};
+}
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/TimeWithTimezoneType.h b/velox/functions/prestosql/types/TimeWithTimezoneType.h
new file mode 100644
index 00000000000..098f2b3a3cd
--- /dev/null
+++ b/velox/functions/prestosql/types/TimeWithTimezoneType.h
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/type/SimpleFunctionApi.h"
+#include "velox/type/Time.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+
+/// Represents TIME WITH TIME ZONE as a bigint.
+/// This type stores time with timezone information, typically encoded as:
+/// - Most significant bits: milliseconds since midnight UTC (similar to TIME)
+/// - Least significant bits : timezone information
+class TimeWithTimezoneType final : public BigintType {
+  constexpr TimeWithTimezoneType() : BigintType{ProvideCustomComparison{}} {}
+
+ public:
+  static constexpr int16_t kTimeWithTimezoneToVarcharRowSize = 18;
+
+  static std::shared_ptr<const TimeWithTimezoneType> get() {
+    VELOX_CONSTEXPR_SINGLETON TimeWithTimezoneType kInstance;
+    return {std::shared_ptr<const TimeWithTimezoneType>{}, &kInstance};
+  }
+
+  bool equivalent(const Type& other) const override {
+    // Pointer comparison works since this type is a singleton.
+    return this == &other;
+  }
+
+  int32_t compare(const int64_t& left, const int64_t& right) const override {
+    const int64_t leftNormalized = normalizeForComparison(left);
+    const int64_t rightNormalized = normalizeForComparison(right);
+
+    // Compare the normalized time values.
+    return leftNormalized < rightNormalized ? -1
+        : leftNormalized == rightNormalized ? 0
+                                            : 1;
+  }
+
+  uint64_t hash(const int64_t& value) const override {
+    return folly::hasher<int64_t>()(util::unpackMillisUtc(value));
+  }
+
+  const char* name() const override {
+    return "TIME WITH TIME ZONE";
+  }
+
+  std::string toString() const override {
+    return name();
+  }
+
+  /// Returns the time with timezone 'value' formatted as
+  /// HH:MM:SS.mmm+HH:MM.
+  /// @param value Packed time with timezone value.
+  /// @param buffer Pre-allocated output buffer of at least
+  /// kTimeWithTimezoneToVarcharRowSize (18) bytes.
+  std::string_view valueToString(int64_t value, char* buffer) const;
+
+  folly::dynamic serialize() const override;
+
+  static TypePtr deserialize(const folly::dynamic& /*obj*/) {
+    return TimeWithTimezoneType::get();
+  }
+
+  bool isOrderable() const override {
+    return true;
+  }
+
+  bool isComparable() const override {
+    return true;
+  }
+
+ private:
+  // Normalizes the UTC time to the range of a day.
+  //
+  // If the local time is outside the range of a day,
+  // this means that during storage there was a wrap around
+  // as UTC would have either exceeded the range of a day
+  // or would have been negative. We need to adjust the UTC
+  // value to restore the original value for comparison.
+  //
+  // For example, if the local time is 00:00:00.000+08:00, then
+  // the UTC time is 16:00:00.000 (the previous day). The previous day
+  // is lost in the conversion. We need to subtract a day to the UTC
+  // time for appropriate comparison.
+  //
+  // Similarly, if the local time is 23:59:59.999-08:00, then
+  // the UTC time is 07:59:59.999 (the next day). The next day
+  // is lost in the conversion. We need to add a day to the UTC
+  // time for appropriate comparison.
+  int64_t normalizeForComparison(int64_t value) const {
+    auto millisUtc = util::unpackMillisUtc(value);
+    auto zoneOffsetMinutes =
+        util::decodeTimezoneOffset(util::unpackZoneOffset(value));
+    auto localMillis = millisUtc + (zoneOffsetMinutes * util::kMillisInMinute);
+
+    if (localMillis < 0) {
+      millisUtc += util::kMillisInDay;
+    }
+
+    if (localMillis >= util::kMillisInDay) {
+      millisUtc -= util::kMillisInDay;
+    }
+    return millisUtc;
+  }
+};
+
+inline bool isTimeWithTimeZone(const TypePtr& other) {
+  return TimeWithTimezoneType::get() == other;
+}
+
+using TimeWithTimezoneTypePtr = std::shared_ptr<const TimeWithTimezoneType>;
+
+FOLLY_ALWAYS_INLINE TimeWithTimezoneTypePtr TIME_WITH_TIME_ZONE() {
+  return TimeWithTimezoneType::get();
+}
+
+struct TimeWithTimezoneT {
+  using type = int64_t;
+  static constexpr const char* typeName = "time with time zone";
+};
+
+using TimeWithTimezone = CustomType<TimeWithTimezoneT, true>;
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/TimestampWithTimeZoneRegistration.cpp b/velox/functions/prestosql/types/TimestampWithTimeZoneRegistration.cpp
index 5abda35c479..7dff342a38f 100644
--- a/velox/functions/prestosql/types/TimestampWithTimeZoneRegistration.cpp
+++ b/velox/functions/prestosql/types/TimestampWithTimeZoneRegistration.cpp
@@ -20,6 +20,7 @@
 #include "velox/functions/lib/DateTimeFormatter.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 #include "velox/functions/prestosql/types/fuzzer_utils/TimestampWithTimeZoneInputGenerator.h"
+#include "velox/type/CastRegistry.h"
 #include "velox/type/tz/TimeZoneMap.h"
 
 namespace facebook::velox {
@@ -34,6 +35,36 @@ const tz::TimeZone* getTimeZoneFromConfig(const core::QueryConfig& config) {
   return tz::locateZone(0); // GMT
 }
 
+// Helper function to calculate midnight in UTC for the given session start
+// time in the session timezone. This can be called once and reused for all
+// rows in a batch.
+int64_t calculateMidnightUtcMs(
+    int64_t sessionStartTimeMs,
+    const tz::TimeZone* sessionTimeZone) {
+  std::chrono::milliseconds localRepresentation;
+
+  if (sessionStartTimeMs != 0) {
+    // Convert session start time to local time in the timezone
+    localRepresentation = sessionTimeZone->to_local(
+        std::chrono::milliseconds(sessionStartTimeMs));
+  } else {
+    // Special case: when session start time is 0 (epoch), treat it as
+    // local representation of epoch (1970-01-01 00:00:00 in local time),
+    // not as UTC epoch converted to local time
+    localRepresentation = std::chrono::milliseconds(0);
+  }
+
+  // Truncate to start of day (midnight) in local time representation
+  auto localMidnight =
+      std::chrono::floor<std::chrono::days>(localRepresentation);
+
+  // Convert the local midnight representation back to UTC
+  auto utcMidnight = sessionTimeZone->to_sys(
+      std::chrono::duration_cast<std::chrono::milliseconds>(localMidnight));
+
+  return utcMidnight.count();
+}
+
 void castFromTimestamp(
     const SimpleVector<Timestamp>& inputVector,
     exec::EvalCtx& context,
@@ -184,6 +215,30 @@ void castToDate(
   });
 }
 
+void castToTime(
+    const BaseVector& input,
+    exec::EvalCtx& context,
+    const SelectivityVector& rows,
+    BaseVector& result) {
+  auto* flatResult = result.as<FlatVector<int64_t>>();
+  const auto* timestampVector = input.as<SimpleVector<int64_t>>();
+
+  context.applyToSelectedNoThrow(rows, [&](auto row) {
+    auto timestampWithTimezone = timestampVector->valueAt(row);
+    auto timestamp = unpackTimestampUtc(timestampWithTimezone);
+
+    // Convert the UTC timestamp to the timezone of the timestamp
+    timestamp.toTimezone(
+        *tz::locateZone(unpackZoneKeyId(timestampWithTimezone)));
+
+    // Extract time-of-day using std::chrono. floor() rounds towards
+    // negative infinity, so this correctly handles negative timestamps.
+    auto millis = std::chrono::milliseconds{timestamp.toMillis()};
+    auto timeOfDay = millis - std::chrono::floor<std::chrono::days>(millis);
+    flatResult->set(row, timeOfDay.count());
+  });
+}
+
 class TimestampWithTimeZoneCastOperator final : public exec::CastOperator {
   TimestampWithTimeZoneCastOperator() = default;
 
@@ -193,32 +248,6 @@ class TimestampWithTimeZoneCastOperator final : public exec::CastOperator {
     return {std::shared_ptr<const CastOperator>{}, &kInstance};
   }
 
-  bool isSupportedFromType(const TypePtr& other) const override {
-    switch (other->kind()) {
-      case TypeKind::TIMESTAMP:
-        return true;
-      case TypeKind::VARCHAR:
-        return true;
-      case TypeKind::INTEGER:
-        return other->isDate();
-      default:
-        return false;
-    }
-  }
-
-  bool isSupportedToType(const TypePtr& other) const override {
-    switch (other->kind()) {
-      case TypeKind::TIMESTAMP:
-        return true;
-      case TypeKind::VARCHAR:
-        return true;
-      case TypeKind::INTEGER:
-        return other->isDate();
-      default:
-        return false;
-    }
-  }
-
   void castTo(
       const BaseVector& input,
       exec::EvalCtx& context,
@@ -227,6 +256,52 @@ class TimestampWithTimeZoneCastOperator final : public exec::CastOperator {
       VectorPtr& result) const override {
     context.ensureWritable(rows, resultType, result);
 
+    if (input.typeKind() == TypeKind::BIGINT &&
+        input.type()->equivalent(*TIME())) {
+      const auto& config = context.execCtx()->queryCtx()->queryConfig();
+      const auto* sessionTimeZone = getTimeZoneFromConfig(config);
+      const auto sessionStartTimeMs = config.sessionStartTimeMs();
+
+      // Calculate midnight in UTC once (shared by both constant and
+      // non-constant paths)
+      const auto midnightUtcMs =
+          calculateMidnightUtcMs(sessionStartTimeMs, sessionTimeZone);
+
+      if (input.isConstantEncoding()) {
+        // Optimization for constant TIME input vectors
+        auto constantInput = input.as<ConstantVector<int64_t>>();
+        if (constantInput->isNullAt(0)) {
+          result = BaseVector::createNullConstant(
+              resultType, rows.end(), context.pool());
+          return;
+        }
+
+        const auto timeMillis = constantInput->valueAt(0);
+        auto packedValue =
+            pack(midnightUtcMs + timeMillis, sessionTimeZone->id());
+        result = std::make_shared<ConstantVector<int64_t>>(
+            context.pool(),
+            rows.end(),
+            false, // isNull
+            resultType,
+            std::move(packedValue));
+        return;
+      } else {
+        // Non-constant TIME input
+        auto* timestampWithTzResult = result->asFlatVector<int64_t>();
+        timestampWithTzResult->clearNulls(rows);
+        auto* rawResults = timestampWithTzResult->mutableRawValues();
+
+        const auto inputVector = input.as<SimpleVector<int64_t>>();
+        context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
+          const auto timeMillis = inputVector->valueAt(row);
+          const auto utcTimestampMs = midnightUtcMs + timeMillis;
+          rawResults[row] = pack(utcTimestampMs, sessionTimeZone->id());
+        });
+        return;
+      }
+    }
+
     auto* timestampWithTzResult = result->asFlatVector<int64_t>();
     timestampWithTzResult->clearNulls(rows);
 
@@ -264,6 +339,9 @@ class TimestampWithTimeZoneCastOperator final : public exec::CastOperator {
     } else if (resultType->kind() == TypeKind::INTEGER) {
       VELOX_CHECK(resultType->isDate());
       castToDate(input, context, rows, *result);
+    } else if (resultType->kind() == TypeKind::BIGINT) {
+      VELOX_CHECK(resultType->equivalent(*TIME()));
+      castToTime(input, context, rows, *result);
     } else {
       VELOX_UNSUPPORTED(
           "Cast from TIMESTAMP WITH TIME ZONE to {} not yet supported",
@@ -279,7 +357,6 @@ class TimestampWithTimeZoneTypeFactory : public CustomTypeFactory {
     return TIMESTAMP_WITH_TIME_ZONE();
   }
 
-  // Type casting from and to TimestampWithTimezone is not supported yet.
   exec::CastOperatorPtr getCastOperator() const override {
     return TimestampWithTimeZoneCastOperator::get();
   }
@@ -294,7 +371,25 @@ class TimestampWithTimeZoneTypeFactory : public CustomTypeFactory {
 
 void registerTimestampWithTimeZoneType() {
   registerCustomType(
-      "timestamp with time zone",
+      "TIMESTAMP WITH TIME ZONE",
       std::make_unique<const TimestampWithTimeZoneTypeFactory>());
+  // Lower cost = preferred during overload resolution. TIMESTAMP is closer
+  // to TIMESTAMP WITH TIME ZONE than DATE.
+  registerCastRules({
+      {.fromType = "TIMESTAMP",
+       .toType = "TIMESTAMP WITH TIME ZONE",
+       .implicitAllowed = true,
+       .cost = 1},
+      {.fromType = "VARCHAR", .toType = "TIMESTAMP WITH TIME ZONE"},
+      {.fromType = "DATE",
+       .toType = "TIMESTAMP WITH TIME ZONE",
+       .implicitAllowed = true,
+       .cost = 2},
+      {.fromType = "TIME", .toType = "TIMESTAMP WITH TIME ZONE"},
+      {.fromType = "TIMESTAMP WITH TIME ZONE", .toType = "TIMESTAMP"},
+      {.fromType = "TIMESTAMP WITH TIME ZONE", .toType = "VARCHAR"},
+      {.fromType = "TIMESTAMP WITH TIME ZONE", .toType = "DATE"},
+      {.fromType = "TIMESTAMP WITH TIME ZONE", .toType = "TIME"},
+  });
 }
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/TimestampWithTimeZoneType.cpp b/velox/functions/prestosql/types/TimestampWithTimeZoneType.cpp
new file mode 100644
index 00000000000..cc518fc23cc
--- /dev/null
+++ b/velox/functions/prestosql/types/TimestampWithTimeZoneType.cpp
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/functions/lib/DateTimeFormatter.h"
+#include "velox/type/tz/TimeZoneMap.h"
+
+namespace facebook::velox {
+
+std::string TimestampWithTimeZoneType::valueToString(int64_t value) const {
+  static auto kFormatter =
+      functions::buildJodaDateTimeFormatter("yyyy-MM-dd HH:mm:ss.SSS ZZZ")
+          .value();
+
+  auto timestamp = unpackTimestampUtc(value);
+  auto* timeZone = tz::locateZone(tz::getTimeZoneName(unpackZoneKeyId(value)));
+
+  auto maxSize = kFormatter->maxResultSize(timeZone);
+  std::string result(maxSize, '\0');
+  auto size = kFormatter->format(timestamp, timeZone, maxSize, result.data());
+  result.resize(size);
+  return result;
+}
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/TimestampWithTimeZoneType.h b/velox/functions/prestosql/types/TimestampWithTimeZoneType.h
index f902159b57a..6e067b86deb 100644
--- a/velox/functions/prestosql/types/TimestampWithTimeZoneType.h
+++ b/velox/functions/prestosql/types/TimestampWithTimeZoneType.h
@@ -27,8 +27,9 @@ constexpr int32_t kTimezoneMask = (1 << kMillisShift) - 1;
 // The maximum and minimum millis UTC we can represent in a
 // TimestampWithTimeZone value given the bits we have to store it.
 // We have 64 bits minus the bits for the time zone minus 1 for the sign bit.
-constexpr int64_t kMaxMillisUtc = (1L << (64 - (int64_t)kMillisShift - 1)) - 1L;
-constexpr int64_t kMinMillisUtc = (kMaxMillisUtc + 1) * -1;
+constexpr int64_t kMaxMillisUtc =
+    (1LL << (64 - (int64_t)kMillisShift - 1)) - 1LL;
+constexpr int64_t kMinMillisUtc = (kMaxMillisUtc + 1) * -1LL;
 
 inline int64_t unpackMillisUtc(int64_t dateTimeWithTimeZone) {
   return dateTimeWithTimeZone >> kMillisShift;
@@ -88,15 +89,13 @@ class TimestampWithTimeZoneType final : public BigintType {
     return "TIMESTAMP WITH TIME ZONE";
   }
 
-  const std::vector<TypeParameter>& parameters() const override {
-    static const std::vector<TypeParameter> kEmpty = {};
-    return kEmpty;
-  }
-
   std::string toString() const override {
     return name();
   }
 
+  /// Formats a packed value as "YYYY-MM-DD HH:MM:SS.mmm <timezone>".
+  std::string valueToString(int64_t value) const;
+
   folly::dynamic serialize() const override {
     folly::dynamic obj = folly::dynamic::object;
     obj["name"] = "Type";
diff --git a/velox/functions/prestosql/types/UuidRegistration.cpp b/velox/functions/prestosql/types/UuidRegistration.cpp
index e4c9781d893..39797eeef29 100644
--- a/velox/functions/prestosql/types/UuidRegistration.cpp
+++ b/velox/functions/prestosql/types/UuidRegistration.cpp
@@ -22,51 +22,15 @@
 
 #include "velox/expression/CastExpr.h"
 #include "velox/functions/prestosql/types/UuidType.h"
+#include "velox/type/CastRegistry.h"
 
 namespace facebook::velox {
 namespace {
-template <TypeKind>
-struct UuidWriter {
-  static void write(exec::StringWriter& writer, const uint8_t* uuidBytes) =
-      delete;
-};
-
 template <TypeKind>
 struct UuidParser {
   static int128_t parse(const StringView& uuidValue) = delete;
 };
 
-template <>
-struct UuidWriter<TypeKind::VARCHAR> {
-  static void write(exec::StringWriter& writer, const uint8_t* uuidBytes) {
-    writer.resize(36);
-    // Do not use boost::lexical_cast. It is very slow.
-
-    // 2 hex digits per each value in [0, 127] range (1 byte).
-    static const char* const kHexTable =
-        "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"
-        "202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f"
-        "404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f"
-        "606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f"
-        "808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f"
-        "a0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
-        "c0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
-        "e0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff";
-
-    size_t offset = 0;
-    for (auto i = 0; i < 16; ++i) {
-      writer.data()[offset] = kHexTable[uuidBytes[i] * 2];
-      writer.data()[offset + 1] = kHexTable[uuidBytes[i] * 2 + 1];
-
-      offset += 2;
-      if (i == 3 || i == 5 || i == 7 || i == 9) {
-        writer.data()[offset] = '-';
-        offset++;
-      }
-    }
-  }
-};
-
 template <>
 struct UuidParser<TypeKind::VARCHAR> {
   static int128_t parse(const StringView& uuidValue) {
@@ -77,14 +41,6 @@ struct UuidParser<TypeKind::VARCHAR> {
   }
 };
 
-template <>
-struct UuidWriter<TypeKind::VARBINARY> {
-  static void write(exec::StringWriter& writer, const uint8_t* uuidBytes) {
-    writer.resize(16);
-    memcpy(writer.data(), uuidBytes, 16);
-  }
-};
-
 template <>
 struct UuidParser<TypeKind::VARBINARY> {
   static int128_t parse(const StringView& uuidValue) {
@@ -96,14 +52,6 @@ struct UuidParser<TypeKind::VARBINARY> {
 
 class UuidCastOperator : public exec::CastOperator {
  public:
-  bool isSupportedFromType(const TypePtr& other) const override {
-    return VARCHAR()->equivalent(*other) || VARBINARY()->equivalent(*other);
-  }
-
-  bool isSupportedToType(const TypePtr& other) const override {
-    return VARCHAR()->equivalent(*other) || VARBINARY()->equivalent(*other);
-  }
-
   void castTo(
       const BaseVector& input,
       exec::EvalCtx& context,
@@ -151,12 +99,16 @@ class UuidCastOperator : public exec::CastOperator {
     const auto* uuids = input.as<SimpleVector<int128_t>>();
 
     context.applyToSelectedNoThrow(rows, [&](auto row) {
-      // Ensure UUID bytes are big endian.
-      const auto uuid = DecimalUtil::bigEndian(uuids->valueAt(row));
-      const auto* uuidBytes = reinterpret_cast<const uint8_t*>(&uuid);
-
+      const auto value = uuids->valueAt(row);
       exec::StringWriter writer(flatResult, row);
-      UuidWriter<KIND>::write(writer, uuidBytes);
+      if constexpr (KIND == TypeKind::VARCHAR) {
+        writer.resize(UuidType::kStringSize);
+        UUID()->valueToString(value, writer.data());
+      } else {
+        auto bigEndian = DecimalUtil::bigEndian(value);
+        writer.resize(16);
+        memcpy(writer.data(), &bigEndian, 16);
+      }
       writer.finalize();
     });
   }
@@ -201,6 +153,12 @@ class UuidTypeFactory : public CustomTypeFactory {
 } // namespace
 
 void registerUuidType() {
-  registerCustomType("uuid", std::make_unique<const UuidTypeFactory>());
+  registerCustomType("UUID", std::make_unique<const UuidTypeFactory>());
+  registerCastRules({
+      {.fromType = "VARCHAR", .toType = "UUID"},
+      {.fromType = "VARBINARY", .toType = "UUID"},
+      {.fromType = "UUID", .toType = "VARCHAR"},
+      {.fromType = "UUID", .toType = "VARBINARY"},
+  });
 }
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/UuidType.cpp b/velox/functions/prestosql/types/UuidType.cpp
new file mode 100644
index 00000000000..85df68d4af3
--- /dev/null
+++ b/velox/functions/prestosql/types/UuidType.cpp
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/types/UuidType.h"
+#include "velox/type/DecimalUtil.h"
+
+namespace facebook::velox {
+
+std::string_view UuidType::valueToString(int128_t value, char* buffer) const {
+  auto bigEndianValue = DecimalUtil::bigEndian(value);
+  const auto* bytes = reinterpret_cast<const uint8_t*>(&bigEndianValue);
+
+  // Do not use boost::lexical_cast. It is very slow.
+
+  // 2 hex digits per byte value. Lookup table avoids per-nibble branching.
+  static const char* const kHexTable =
+      "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"
+      "202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f"
+      "404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f"
+      "606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f"
+      "808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f"
+      "a0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
+      "c0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
+      "e0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff";
+
+  size_t offset = 0;
+  for (auto i = 0; i < 16; ++i) {
+    buffer[offset] = kHexTable[bytes[i] * 2];
+    buffer[offset + 1] = kHexTable[bytes[i] * 2 + 1];
+    offset += 2;
+    if (i == 3 || i == 5 || i == 7 || i == 9) {
+      buffer[offset++] = '-';
+    }
+  }
+  return {buffer, kStringSize};
+}
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/UuidType.h b/velox/functions/prestosql/types/UuidType.h
index e59257f9003..c6bd305434a 100644
--- a/velox/functions/prestosql/types/UuidType.h
+++ b/velox/functions/prestosql/types/UuidType.h
@@ -46,6 +46,13 @@ class UuidType final : public HugeintType {
     return name();
   }
 
+  static constexpr int32_t kStringSize = 36;
+
+  /// Formats an int128_t UUID value as xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
+  /// @param buffer Output buffer, pre-allocated with at least kStringSize
+  /// bytes.
+  std::string_view valueToString(int128_t value, char* buffer) const;
+
   folly::dynamic serialize() const override {
     folly::dynamic obj = folly::dynamic::object;
     obj["name"] = "Type";
diff --git a/velox/functions/prestosql/types/VarcharEnumRegistration.cpp b/velox/functions/prestosql/types/VarcharEnumRegistration.cpp
index 251450e0fa3..548cb5d678b 100644
--- a/velox/functions/prestosql/types/VarcharEnumRegistration.cpp
+++ b/velox/functions/prestosql/types/VarcharEnumRegistration.cpp
@@ -17,6 +17,7 @@
 #include "velox/functions/prestosql/types/VarcharEnumRegistration.h"
 #include "velox/expression/CastExpr.h"
 #include "velox/functions/prestosql/types/VarcharEnumType.h"
+#include "velox/type/CastRegistry.h"
 
 namespace facebook::velox {
 namespace {
@@ -29,16 +30,6 @@ class VarcharEnumCastOperator : public exec::CastOperator {
     return kInstance;
   }
 
-  // Casting is only supported from VARCHAR type.
-  bool isSupportedFromType(const TypePtr& other) const override {
-    return VARCHAR()->equivalent(*other);
-  }
-
-  // Casting is only supported to VARCHAR type.
-  bool isSupportedToType(const TypePtr& other) const override {
-    return VARCHAR()->equivalent(*other);
-  }
-
   void castTo(
       const BaseVector& input,
       exec::EvalCtx& context,
@@ -102,6 +93,10 @@ class VarcharEnumTypeFactory : public CustomTypeFactory {
 
 void registerVarcharEnumType() {
   registerCustomType(
-      "varchar_enum", std::make_unique<const VarcharEnumTypeFactory>());
+      "VARCHAR_ENUM", std::make_unique<const VarcharEnumTypeFactory>());
+  registerCastRules({
+      {.fromType = "VARCHAR", .toType = "VARCHAR_ENUM"},
+      {.fromType = "VARCHAR_ENUM", .toType = "VARCHAR"},
+  });
 }
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/fuzzer_utils/CMakeLists.txt b/velox/functions/prestosql/types/fuzzer_utils/CMakeLists.txt
index 56976eacf89..cd1ff1ff2c8 100644
--- a/velox/functions/prestosql/types/fuzzer_utils/CMakeLists.txt
+++ b/velox/functions/prestosql/types/fuzzer_utils/CMakeLists.txt
@@ -14,9 +14,18 @@
 velox_add_library(
   velox_presto_types_fuzzer_utils
   TimestampWithTimeZoneInputGenerator.cpp
+  TimeWithTimezoneInputGenerator.cpp
   HyperLogLogInputGenerator.cpp
+  KHyperLogLogInputGenerator.cpp
   P4HyperLogLogInputGenerator.cpp
   SfmSketchInputGenerator.cpp
+  HEADERS
+  HyperLogLogInputGenerator.h
+  KHyperLogLogInputGenerator.h
+  P4HyperLogLogInputGenerator.h
+  SfmSketchInputGenerator.h
+  TimeWithTimezoneInputGenerator.h
+  TimestampWithTimeZoneInputGenerator.h
 )
 
 velox_link_libraries(
diff --git a/velox/functions/prestosql/types/fuzzer_utils/HyperLogLogInputGenerator.h b/velox/functions/prestosql/types/fuzzer_utils/HyperLogLogInputGenerator.h
index 0d9a897df8a..e1da24bd6ba 100644
--- a/velox/functions/prestosql/types/fuzzer_utils/HyperLogLogInputGenerator.h
+++ b/velox/functions/prestosql/types/fuzzer_utils/HyperLogLogInputGenerator.h
@@ -22,7 +22,7 @@
 
 namespace facebook::velox::fuzzer {
 
-using facebook::velox::aggregate::prestosql::HllAccumulator;
+using common::hll::HllAccumulator;
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
diff --git a/velox/functions/prestosql/types/fuzzer_utils/KHyperLogLogInputGenerator.cpp b/velox/functions/prestosql/types/fuzzer_utils/KHyperLogLogInputGenerator.cpp
new file mode 100644
index 00000000000..7880b8565d7
--- /dev/null
+++ b/velox/functions/prestosql/types/fuzzer_utils/KHyperLogLogInputGenerator.cpp
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/types/fuzzer_utils/KHyperLogLogInputGenerator.h"
+
+#include "velox/common/fuzzer/Utils.h"
+#include "velox/functions/lib/KHyperLogLog.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+#include "velox/type/Variant.h"
+
+namespace facebook::velox::fuzzer {
+
+KHyperLogLogInputGenerator::KHyperLogLogInputGenerator(
+    const size_t seed,
+    const double nullRatio,
+    memory::MemoryPool* pool,
+    int32_t minNumValues)
+    : AbstractInputGenerator{seed, KHYPERLOGLOG(), nullptr, nullRatio},
+      minNumValues_{minNumValues},
+      pool_{pool} {
+  static const std::vector<TypePtr> kBaseTypes{
+      BIGINT(), VARCHAR(), DOUBLE(), UNKNOWN()};
+  baseType_ = kBaseTypes[rand<int32_t>(rng_, 0, kBaseTypes.size() - 1)];
+
+  maxSize_ = rand<int32_t>(rng_, 100, 5000);
+  static const std::vector<int32_t> kValidBuckets{64, 128, 256, 512, 1024};
+  hllBuckets_ = kValidBuckets[rand<int32_t>(rng_, 0, kValidBuckets.size() - 1)];
+}
+
+// General template for numeric types (double)
+template <typename T>
+variant KHyperLogLogInputGenerator::generateTyped() {
+  HashStringAllocator allocator{pool_};
+  common::hll::KHyperLogLog<int64_t, HashStringAllocator> khll{
+      maxSize_, hllBuckets_, &allocator};
+
+  auto numPairs = rand<int32_t>(rng_, minNumValues_, 10000);
+  for (auto i = 0; i < numPairs; ++i) {
+    auto value = rand<T>(rng_);
+    int64_t joinKey = std::hash<T>{}(value);
+    int64_t uii = rand<int64_t>(rng_);
+    khll.add(joinKey, uii);
+  }
+
+  auto size = khll.estimatedSerializedSize();
+  std::string buff(size, '\0');
+  khll.serialize(buff.data());
+  return variant::binary(std::move(buff));
+}
+
+// Specialization for int64_t
+template <>
+variant KHyperLogLogInputGenerator::generateTyped<int64_t>() {
+  HashStringAllocator allocator{pool_};
+  common::hll::KHyperLogLog<int64_t, HashStringAllocator> khll{
+      maxSize_, hllBuckets_, &allocator};
+
+  auto numPairs = rand<int32_t>(rng_, minNumValues_, 10000);
+  for (auto i = 0; i < numPairs; ++i) {
+    int64_t joinKey = rand<int64_t>(rng_);
+    int64_t uii = rand<int64_t>(rng_);
+    khll.add(joinKey, uii);
+  }
+
+  auto size = khll.estimatedSerializedSize();
+  std::string buff(size, '\0');
+  khll.serialize(buff.data());
+  return variant::binary(std::move(buff));
+}
+
+// Specialization for std::string (VARCHAR)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+template <>
+variant KHyperLogLogInputGenerator::generateTyped<std::string>() {
+  HashStringAllocator allocator{pool_};
+  common::hll::KHyperLogLog<int64_t, HashStringAllocator> khll{
+      maxSize_, hllBuckets_, &allocator};
+
+  static const std::vector<UTF8CharList> encodings{
+      UTF8CharList::ASCII,
+      UTF8CharList::UNICODE_CASE_SENSITIVE,
+      UTF8CharList::EXTENDED_UNICODE,
+      UTF8CharList::MATHEMATICAL_SYMBOLS};
+  std::wstring_convert<std::codecvt_utf8<char16_t>, char16_t> converter;
+
+  auto numPairs = rand<int32_t>(rng_, minNumValues_, 10000);
+  for (auto i = 0; i < numPairs; ++i) {
+    auto size = rand<int32_t>(rng_, 0, 100);
+    std::string result;
+    auto str = randString(rng_, size, encodings, result, converter);
+    int64_t joinKey = std::hash<std::string>{}(str);
+    int64_t uii = rand<int64_t>(rng_);
+    khll.add(joinKey, uii);
+  }
+
+  auto size = khll.estimatedSerializedSize();
+  std::string buff(size, '\0');
+  khll.serialize(buff.data());
+  return variant::binary(std::move(buff));
+}
+#pragma GCC diagnostic pop
+
+// Specialization for UnknownValue (NULL type)
+template <>
+variant KHyperLogLogInputGenerator::generateTyped<UnknownValue>() {
+  HashStringAllocator allocator{pool_};
+  common::hll::KHyperLogLog<int64_t, HashStringAllocator> khll{
+      maxSize_, hllBuckets_, &allocator};
+
+  // UnknownValue represents NULL, so create an empty KHyperLogLog
+  // since KHyperLogLog ignores NULL inputs
+
+  auto size = khll.estimatedSerializedSize();
+  std::string buff(size, '\0');
+  khll.serialize(buff.data());
+  return variant::binary(std::move(buff));
+}
+
+variant KHyperLogLogInputGenerator::generate() {
+  if (coinToss(rng_, nullRatio_)) {
+    return variant::null(type_->kind());
+  }
+
+  if (baseType_->isBigint()) {
+    return generateTyped<int64_t>();
+  } else if (baseType_->isVarchar()) {
+    return generateTyped<std::string>();
+  } else if (baseType_->isDouble()) {
+    return generateTyped<double>();
+  } else {
+    return generateTyped<UnknownValue>();
+  }
+}
+
+} // namespace facebook::velox::fuzzer
diff --git a/velox/functions/prestosql/types/fuzzer_utils/KHyperLogLogInputGenerator.h b/velox/functions/prestosql/types/fuzzer_utils/KHyperLogLogInputGenerator.h
new file mode 100644
index 00000000000..085810f29b8
--- /dev/null
+++ b/velox/functions/prestosql/types/fuzzer_utils/KHyperLogLogInputGenerator.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/type/Type.h"
+#include "velox/type/Variant.h"
+
+namespace facebook::velox::fuzzer {
+
+// Suppress warnings about deprecated declarations for AbstractInputGenerator
+// interface and std::hash usage in type conversions.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+class KHyperLogLogInputGenerator : public AbstractInputGenerator {
+ public:
+  KHyperLogLogInputGenerator(
+      const size_t seed,
+      const double nullRatio,
+      memory::MemoryPool* pool,
+      int32_t minNumValues = 1);
+
+  variant generate() override;
+
+ private:
+  template <typename T>
+  variant generateTyped();
+
+  TypePtr baseType_;
+  int32_t maxSize_;
+  int32_t hllBuckets_;
+  int32_t minNumValues_;
+  memory::MemoryPool* pool_;
+};
+#pragma GCC diagnostic pop
+
+} // namespace facebook::velox::fuzzer
diff --git a/velox/functions/prestosql/types/fuzzer_utils/TimeWithTimezoneInputGenerator.cpp b/velox/functions/prestosql/types/fuzzer_utils/TimeWithTimezoneInputGenerator.cpp
new file mode 100644
index 00000000000..691c1b78937
--- /dev/null
+++ b/velox/functions/prestosql/types/fuzzer_utils/TimeWithTimezoneInputGenerator.cpp
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/types/fuzzer_utils/TimeWithTimezoneInputGenerator.h"
+
+#include "velox/common/fuzzer/Utils.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
+#include "velox/type/Time.h"
+#include "velox/type/Variant.h"
+
+namespace facebook::velox::fuzzer {
+
+TimeWithTimezoneInputGenerator::TimeWithTimezoneInputGenerator(
+    size_t seed,
+    double nullRatio)
+    : AbstractInputGenerator(
+          seed,
+          TIME_WITH_TIME_ZONE(),
+          nullptr /*leafGenerator*/,
+          nullRatio) {}
+
+variant TimeWithTimezoneInputGenerator::generate() {
+  if (coinToss(rng_, nullRatio_)) {
+    return variant::null(type_->kind());
+  }
+
+  const int64_t timeMillis = rand<int64_t>(rng_, 0, util::kMillisInDay - 1);
+
+  // Use shared timezone generation utility (25% frequently used, 75% random)
+  int16_t timezoneOffsetMinutes = generateRandomTimezoneOffset(rng_);
+
+  const int16_t biasEncodedTimezone = util::biasEncode(timezoneOffsetMinutes);
+  return util::pack(timeMillis, biasEncodedTimezone);
+}
+
+} // namespace facebook::velox::fuzzer
diff --git a/velox/functions/prestosql/types/fuzzer_utils/TimeWithTimezoneInputGenerator.h b/velox/functions/prestosql/types/fuzzer_utils/TimeWithTimezoneInputGenerator.h
new file mode 100644
index 00000000000..a95f350c137
--- /dev/null
+++ b/velox/functions/prestosql/types/fuzzer_utils/TimeWithTimezoneInputGenerator.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/type/Type.h"
+
+namespace facebook::velox::fuzzer {
+
+/// Input generator for TIME WITH TIME ZONE type.
+/// Generates valid TIME WITH TIME ZONE values by combining:
+/// - Time component: milliseconds since midnight (0 to 86399999)
+/// - Timezone offset: bias-encoded minutes (-840 to 840 -> 0 to 1680)
+/// Biases selection toward US timezone offsets (including DST) for better
+/// coverage of DST-related edge cases.
+class TimeWithTimezoneInputGenerator : public AbstractInputGenerator {
+ public:
+  TimeWithTimezoneInputGenerator(size_t seed, double nullRatio);
+
+  Variant generate() override;
+};
+
+} // namespace facebook::velox::fuzzer
diff --git a/velox/functions/prestosql/types/fuzzer_utils/tests/CMakeLists.txt b/velox/functions/prestosql/types/fuzzer_utils/tests/CMakeLists.txt
index 5bb58b7c39c..abf03d5209e 100644
--- a/velox/functions/prestosql/types/fuzzer_utils/tests/CMakeLists.txt
+++ b/velox/functions/prestosql/types/fuzzer_utils/tests/CMakeLists.txt
@@ -15,7 +15,9 @@
 add_executable(
   velox_presto_types_fuzzer_utils_test
   TimestampWithTimeZoneInputGeneratorTest.cpp
+  TimeWithTimezoneInputGeneratorTest.cpp
   HyperLogLogInputGeneratorTest.cpp
+  KHyperLogLogInputGeneratorTest.cpp
   P4HyperLogLogInputGeneratorTest.cpp
   SfmSketchInputGeneratorTest.cpp
 )
diff --git a/velox/functions/prestosql/types/fuzzer_utils/tests/HyperLogLogInputGeneratorTest.cpp b/velox/functions/prestosql/types/fuzzer_utils/tests/HyperLogLogInputGeneratorTest.cpp
index 4c8f26a18ef..1fb3b08590c 100644
--- a/velox/functions/prestosql/types/fuzzer_utils/tests/HyperLogLogInputGeneratorTest.cpp
+++ b/velox/functions/prestosql/types/fuzzer_utils/tests/HyperLogLogInputGeneratorTest.cpp
@@ -18,6 +18,8 @@
 
 #include <gtest/gtest.h>
 
+#include "velox/common/hyperloglog/DenseHll.h"
+#include "velox/common/hyperloglog/SparseHll.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/type/Variant.h"
 
@@ -41,11 +43,11 @@ TEST_F(HyperLogLogInputGeneratorTest, generate) {
     const auto& value = generated.value<TypeKind::VARBINARY>();
     HashStringAllocator allocator{pool_.get()};
 
-    if (SparseHll::canDeserialize(value.data())) {
-      SparseHll hll(value.data(), &allocator);
+    if (common::hll::SparseHlls::canDeserialize(value.data())) {
+      common::hll::SparseHll<> hll(value.data(), &allocator);
       hll.cardinality();
-    } else if (DenseHll::canDeserialize(value.data())) {
-      DenseHll hll(value.data(), &allocator);
+    } else if (common::hll::DenseHlls::canDeserialize(value.data())) {
+      common::hll::DenseHll<> hll(value.data(), &allocator);
       hll.cardinality();
     } else {
       VELOX_FAIL("Invalid HLL value");
diff --git a/velox/functions/prestosql/types/fuzzer_utils/tests/KHyperLogLogInputGeneratorTest.cpp b/velox/functions/prestosql/types/fuzzer_utils/tests/KHyperLogLogInputGeneratorTest.cpp
new file mode 100644
index 00000000000..7af5aa2b8e8
--- /dev/null
+++ b/velox/functions/prestosql/types/fuzzer_utils/tests/KHyperLogLogInputGeneratorTest.cpp
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/types/fuzzer_utils/KHyperLogLogInputGenerator.h"
+
+#include <gtest/gtest.h>
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/functions/lib/KHyperLogLog.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+
+namespace facebook::velox::fuzzer::test {
+
+class KHyperLogLogInputGeneratorTest
+    : public functions::test::FunctionBaseTest {};
+
+TEST_F(KHyperLogLogInputGeneratorTest, generate) {
+  KHyperLogLogInputGenerator generator(1, 0.0, pool());
+
+  for (int i = 0; i < 10; ++i) {
+    auto result = generator.generate();
+    ASSERT_FALSE(result.isNull());
+    ASSERT_EQ(result.kind(), TypeKind::VARBINARY);
+
+    // Verify deserialization works
+    const auto& serialized = result.value<TypeKind::VARBINARY>();
+    HashStringAllocator allocator{pool()};
+    auto khll =
+        common::hll::KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+            serialized.data(), serialized.size(), &allocator);
+    ASSERT_TRUE(khll.hasValue())
+        << "Deserialization failed: " << khll.error().message();
+    ASSERT_NE(*khll, nullptr);
+    ASSERT_GE((*khll)->cardinality(), 0);
+  }
+}
+
+TEST_F(KHyperLogLogInputGeneratorTest, generateWithNulls) {
+  KHyperLogLogInputGenerator generator(1, 0.5, pool());
+
+  int nullCount = 0;
+  int nonNullCount = 0;
+
+  for (int i = 0; i < 100; ++i) {
+    auto result = generator.generate();
+    if (result.isNull()) {
+      nullCount++;
+    } else {
+      nonNullCount++;
+      ASSERT_EQ(result.kind(), TypeKind::VARBINARY);
+
+      // Verify deserialization works
+      const auto& serialized = result.value<TypeKind::VARBINARY>();
+      HashStringAllocator allocator{pool()};
+      auto khll =
+          common::hll::KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+              serialized.data(), serialized.size(), &allocator);
+      ASSERT_TRUE(khll.hasValue())
+          << "Deserialization failed: " << khll.error().message();
+    }
+  }
+
+  // With null ratio 0.5, we should have roughly half nulls
+  ASSERT_GT(nullCount, 0);
+  ASSERT_GT(nonNullCount, 0);
+}
+
+TEST_F(KHyperLogLogInputGeneratorTest, generateDifferentSeeds) {
+  KHyperLogLogInputGenerator generator1(1, 0.0, pool());
+  KHyperLogLogInputGenerator generator2(2, 0.0, pool());
+
+  auto result1 = generator1.generate();
+  auto result2 = generator2.generate();
+
+  ASSERT_FALSE(result1.isNull());
+  ASSERT_FALSE(result2.isNull());
+  ASSERT_EQ(result1.kind(), TypeKind::VARBINARY);
+  ASSERT_EQ(result2.kind(), TypeKind::VARBINARY);
+
+  // Different seeds should produce different results
+  const auto& serialized1 = result1.value<TypeKind::VARBINARY>();
+  const auto& serialized2 = result2.value<TypeKind::VARBINARY>();
+  ASSERT_NE(serialized1, serialized2);
+}
+
+} // namespace facebook::velox::fuzzer::test
diff --git a/velox/functions/prestosql/types/fuzzer_utils/tests/P4HyperLogLogInputGeneratorTest.cpp b/velox/functions/prestosql/types/fuzzer_utils/tests/P4HyperLogLogInputGeneratorTest.cpp
index 6d363b3f539..62f94d4e4c9 100644
--- a/velox/functions/prestosql/types/fuzzer_utils/tests/P4HyperLogLogInputGeneratorTest.cpp
+++ b/velox/functions/prestosql/types/fuzzer_utils/tests/P4HyperLogLogInputGeneratorTest.cpp
@@ -18,6 +18,7 @@
 
 #include <gtest/gtest.h>
 
+#include "velox/common/hyperloglog/DenseHll.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/type/Variant.h"
 
@@ -42,8 +43,8 @@ TEST_F(P4HyperLogLogInputGeneratorTest, generate) {
     HashStringAllocator allocator{pool_.get()};
 
     // P4HyperLogLog should only produce dense HLL format
-    if (DenseHll::canDeserialize(value.data())) {
-      DenseHll hll(value.data(), &allocator);
+    if (common::hll::DenseHlls::canDeserialize(value.data())) {
+      common::hll::DenseHll<> hll(value.data(), &allocator);
       hll.cardinality();
     } else {
       VELOX_FAIL("P4HyperLogLog should only produce dense HLL format");
diff --git a/velox/functions/prestosql/types/fuzzer_utils/tests/TimeWithTimezoneInputGeneratorTest.cpp b/velox/functions/prestosql/types/fuzzer_utils/tests/TimeWithTimezoneInputGeneratorTest.cpp
new file mode 100644
index 00000000000..93747cb7709
--- /dev/null
+++ b/velox/functions/prestosql/types/fuzzer_utils/tests/TimeWithTimezoneInputGeneratorTest.cpp
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/types/fuzzer_utils/TimeWithTimezoneInputGenerator.h"
+
+#include <gtest/gtest.h>
+#include <unordered_set>
+
+#include "velox/common/fuzzer/Utils.h"
+#include "velox/type/Time.h"
+#include "velox/type/Variant.h"
+
+namespace facebook::velox::fuzzer::test {
+
+TEST(TimeWithTimezoneInputGeneratorTest, generate) {
+  TimeWithTimezoneInputGenerator generator(123456, 0.1);
+
+  size_t numTrials = 100;
+  for (size_t i = 0; i < numTrials; ++i) {
+    variant generated = generator.generate();
+
+    if (generated.isNull()) {
+      continue;
+    }
+
+    generated.checkIsKind(TypeKind::BIGINT);
+    const auto value = generated.value<TypeKind::BIGINT>();
+
+    // Verify time component is in valid range [0, kMillisInDay)
+    const auto timeMillis = util::unpackMillisUtc(value);
+    EXPECT_GE(timeMillis, 0);
+    EXPECT_LT(timeMillis, util::kMillisInDay);
+
+    // Verify timezone offset is in valid bias-encoded range [0, 1680]
+    const auto timezoneOffset = util::unpackZoneOffset(value);
+    EXPECT_GE(timezoneOffset, 0);
+    EXPECT_LE(timezoneOffset, 2 * util::kTimeZoneBias);
+  }
+}
+
+TEST(TimeWithTimezoneInputGeneratorTest, generatesBothOffsetTypes) {
+  TimeWithTimezoneInputGenerator generator(12345, 0.0); // Fixed seed, no nulls
+
+  std::unordered_set<int16_t> frequentlyUsed(
+      kFrequentlyUsedTimezoneOffsets.begin(),
+      kFrequentlyUsedTimezoneOffsets.end());
+
+  bool foundFrequentlyUsed = false;
+  bool foundOther = false;
+
+  for (int i = 0; i < 100 && (!foundFrequentlyUsed || !foundOther); ++i) {
+    auto value = generator.generate().value<TypeKind::BIGINT>();
+    auto encoded = util::unpackZoneOffset(value);
+    auto offset = util::decodeTimezoneOffset(encoded);
+
+    if (frequentlyUsed.count(offset)) {
+      foundFrequentlyUsed = true;
+    } else {
+      foundOther = true;
+    }
+  }
+
+  EXPECT_TRUE(foundFrequentlyUsed);
+  EXPECT_TRUE(foundOther);
+}
+
+} // namespace facebook::velox::fuzzer::test
diff --git a/velox/functions/prestosql/types/parser/CMakeLists.txt b/velox/functions/prestosql/types/parser/CMakeLists.txt
index c08442ea2f2..8853b2fe5d4 100644
--- a/velox/functions/prestosql/types/parser/CMakeLists.txt
+++ b/velox/functions/prestosql/types/parser/CMakeLists.txt
@@ -45,6 +45,10 @@ velox_add_library(
   ${BISON_TypeParser_OUTPUTS}
   ${FLEX_TypeParserScanner_OUTPUTS}
   ParserUtil.cpp
+  HEADERS
+  ParserUtil.h
+  Scanner.h
+  TypeParser.h
 )
 velox_include_directories(
   velox_presto_type_parser
diff --git a/velox/functions/prestosql/types/parser/Scanner.h b/velox/functions/prestosql/types/parser/Scanner.h
index c8b23908384..2e212ca2aa0 100644
--- a/velox/functions/prestosql/types/parser/Scanner.h
+++ b/velox/functions/prestosql/types/parser/Scanner.h
@@ -35,7 +35,7 @@ class Scanner : public yyFlexLexer {
       const std::string_view input)
       : yyFlexLexer(&arg_yyin, &arg_yyout),
         outputType_(outputType),
-        input_(input){};
+        input_(input) {};
   int lex(Parser::semantic_type* yylval);
 
   void setType(TypePtr type) {
diff --git a/velox/functions/prestosql/types/parser/TypeParser.ll b/velox/functions/prestosql/types/parser/TypeParser.ll
index 1db257a117c..8bd29e4d2b7 100644
--- a/velox/functions/prestosql/types/parser/TypeParser.ll
+++ b/velox/functions/prestosql/types/parser/TypeParser.ll
@@ -39,7 +39,7 @@ QUOTED_ID         (['"']([^"\n]|"")*['"'])
 NUMBER            ([[:digit:]]+)
 SIGNED_INT        (-?[[:digit:]]+)
 VARIABLE          (VARCHAR|VARBINARY)
-WORD_WITH_PERIODS ([[:alpha:]_][[:alnum:]_]*)(\.([[:alpha:]_][[:alnum:]_]*))*
+WORD_WITH_SPECIAL_CHAR ([^:({ ,]+)(\.([^:({ ,]+))(\.([^:({ ,]+))
 
 %%
 
@@ -59,7 +59,7 @@ WORD_WITH_PERIODS ([[:alpha:]_][[:alnum:]_]*)(\.([[:alpha:]_][[:alnum:]_]*))*
 {NUMBER}           yylval->build<long long>(folly::to<long long>(YYText())); return Parser::token::NUMBER;
 {SIGNED_INT}       yylval->build<long long>(folly::to<long long>(YYText())); return Parser::token::SIGNED_INT;
 {WORD}             yylval->build<std::string>(YYText()); return Parser::token::WORD;
-{WORD_WITH_PERIODS}             yylval->build<std::string>(YYText()); return Parser::token::WORD_WITH_PERIODS;
+{WORD_WITH_SPECIAL_CHAR}             yylval->build<std::string>(YYText()); return Parser::token::WORD_WITH_SPECIAL_CHAR;
 {QUOTED_ID}        yylval->build<std::string>(YYText()); return Parser::token::QUOTED_ID;
 <<EOF>>            return Parser::token::YYEOF;
 .               /* no action on unmatched input */
diff --git a/velox/functions/prestosql/types/parser/TypeParser.yy b/velox/functions/prestosql/types/parser/TypeParser.yy
index 3544ca4c379..705174822fa 100644
--- a/velox/functions/prestosql/types/parser/TypeParser.yy
+++ b/velox/functions/prestosql/types/parser/TypeParser.yy
@@ -34,7 +34,7 @@
 }
 
 %token               LPAREN RPAREN COMMA PERIOD COLON ARRAY MAP ROW FUNCTION DECIMAL LBRACE RBRACE
-%token <std::string> WORD VARIABLE QUOTED_ID WORD_WITH_PERIODS
+%token <std::string> WORD VARIABLE QUOTED_ID WORD_WITH_SPECIAL_CHAR
 %token <long long>   NUMBER SIGNED_INT
 %token YYEOF         0
 
@@ -181,8 +181,7 @@ enum_kind : WORD { if ($1 != "BigintEnum" && $1 != "VarcharEnum" )
                 $$ = $1; }
                 ;
 
-enum_name : WORD_WITH_PERIODS { $$ = $1; }
-          | WORD { $$ = $1; }
+enum_name : WORD_WITH_SPECIAL_CHAR { $$ = $1; }
           ;
 
 enum_type : enum_name COLON enum_kind LPAREN enum_name enum_map_entries_json RPAREN
diff --git a/velox/functions/prestosql/types/parser/tests/TypeParserTest.cpp b/velox/functions/prestosql/types/parser/tests/TypeParserTest.cpp
index e2b6a62004a..8358ec4e062 100644
--- a/velox/functions/prestosql/types/parser/tests/TypeParserTest.cpp
+++ b/velox/functions/prestosql/types/parser/tests/TypeParserTest.cpp
@@ -46,6 +46,11 @@ static const TypePtr& TIMESTAMP_WITH_TIME_ZONE() {
   return instance;
 }
 
+static const TypePtr& TIME_WITH_TIME_ZONE() {
+  static const TypePtr instance{new CustomType()};
+  return instance;
+}
+
 class TypeFactory : public CustomTypeFactory {
  public:
   TypeFactory(const TypePtr& type) : type_(type) {}
@@ -76,6 +81,9 @@ class TypeParserTest : public ::testing::Test {
     registerCustomType(
         "timestamp with time zone",
         std::make_unique<const TypeFactory>(TIMESTAMP_WITH_TIME_ZONE()));
+    registerCustomType(
+        "time with time zone",
+        std::make_unique<const TypeFactory>(TIME_WITH_TIME_ZONE()));
   }
 };
 
@@ -102,6 +110,20 @@ TEST_F(TypeParserTest, varbinary) {
   ASSERT_EQ(*parseType("varbinary"), *VARBINARY());
 }
 
+TEST_F(TypeParserTest, timestamp) {
+  ASSERT_EQ(*parseType("timestamp"), *TIMESTAMP());
+  ASSERT_EQ(*parseType("timestamp utc"), *TIMESTAMP_UTC());
+}
+
+TEST_F(TypeParserTest, time) {
+  ASSERT_EQ(*parseType("time"), *TIME());
+  ASSERT_EQ(*parseType("time micro utc"), *TIME_MICRO_UTC());
+}
+
+TEST_F(TypeParserTest, timeWithTimeZoneType) {
+  ASSERT_EQ(*parseType("time with time zone"), *TIME_WITH_TIME_ZONE());
+}
+
 TEST_F(TypeParserTest, arrayType) {
   ASSERT_EQ(*parseType("array(bigint)"), *ARRAY(BIGINT()));
 
@@ -204,8 +226,9 @@ TEST_F(TypeParserTest, rowType) {
       *ROW({"12 tb", "b", "c"}, {BIGINT(), BIGINT(), BIGINT()}));
 
   ASSERT_EQ(
-      *parseType("row(\"a\" bigint, \"b\" array(varchar), "
-                 "\"c\" timestamp with time zone)"),
+      *parseType(
+          "row(\"a\" bigint, \"b\" array(varchar), "
+          "\"c\" timestamp with time zone)"),
       *ROW(
           {"a", "b", "c"},
           {BIGINT(), ARRAY(VARCHAR()), TIMESTAMP_WITH_TIME_ZONE()}));
@@ -265,11 +288,6 @@ TEST_F(TypeParserTest, rowType) {
 }
 
 TEST_F(TypeParserTest, typesWithSpaces) {
-  // Type is not registered.
-  VELOX_ASSERT_UNSUPPORTED_THROW(
-      parseType("row(time time with time zone)"),
-      "Failed to parse type [time with time zone]. Type not registered.");
-
   ASSERT_EQ(
       *parseType("timestamp with time zone"), *TIMESTAMP_WITH_TIME_ZONE());
 
@@ -281,10 +299,6 @@ TEST_F(TypeParserTest, typesWithSpaces) {
   ASSERT_EQ(
       *parseType("row(double double precision)"), *ROW({"double"}, {DOUBLE()}));
 
-  VELOX_ASSERT_THROW(
-      parseType("row(time with time zone)"),
-      "Failed to parse type [with time zone]");
-
   ASSERT_EQ(*parseType("row(double precision)"), *ROW({DOUBLE()}));
 
   ASSERT_EQ(
@@ -347,9 +361,10 @@ TEST_F(TypeParserTest, decimalType) {
 // Checks that type names can also be field names.
 TEST_F(TypeParserTest, fieldNames) {
   ASSERT_EQ(
-      *parseType("row(bigint bigint, map bigint, row bigint, array bigint, "
-                 "decimal bigint, function bigint, struct bigint, "
-                 "varchar map(bigint, tinyint), varbinary array(bigint))"),
+      *parseType(
+          "row(bigint bigint, map bigint, row bigint, array bigint, "
+          "decimal bigint, function bigint, struct bigint, "
+          "varchar map(bigint, tinyint), varbinary array(bigint))"),
       *ROW(
           {"bigint",
            "map",
@@ -395,12 +410,23 @@ TEST_F(TypeParserTest, bigintEnumBasic) {
           "test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2, \"HAPPY\":106071912278278})"),
       *BIGINT_ENUM(moodWithLargeValue));
 
-  // Enum name that is not in the form catalog.namespace.enum_name.
-  LongEnumParameter otherEnumInfo(
-      "someEnumType", {{"CURIOUS", 2}, {"HAPPY", 0}});
+  // Enum name with special characters.
+  LongEnumParameter enumInfoWithSpecialChar(
+      "test.en\\um.\"mood", {{"CURIOUS", 2}, {"HAPPY", 0}});
+  auto enumWithSpecialCharString =
+      "test.en\\um.\"mood:BigintEnum(test.en\\um.\"mood{\"CURIOUS\": 2, \"HAPPY\": 0})";
+  ASSERT_EQ(
+      *parseType(enumWithSpecialCharString),
+      *BIGINT_ENUM(enumInfoWithSpecialChar));
+
+  // Enum names should be in the format catalog.namespace.enum_name. This is
+  // because enum types are part of a UserDefinedType, which has a
+  // 3-part QualifiedObjectName as the type name.
   auto otherEnumString =
       "someEnumType:BigintEnum(someEnumType{\"CURIOUS\": 2, \"HAPPY\": 0})";
-  ASSERT_EQ(*parseType(otherEnumString), *BIGINT_ENUM(otherEnumInfo));
+  VELOX_ASSERT_THROW(
+      parseType(otherEnumString),
+      "Failed to parse type [someEnumType:BigintEnum(someEnumType{\"CURIOUS\": 2, \"HAPPY\": 0})]. syntax error, unexpected COLON, expecting WORD");
 
   // Array type with enum values.
   ASSERT_EQ(
@@ -486,19 +512,29 @@ TEST_F(TypeParserTest, varcharEnumBasic) {
           "test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"})"),
       *VARCHAR_ENUM(moodInfo));
 
-  // Enum name that is not in the form catalog.namespace.enum_name.
-  VarcharEnumParameter otherEnumInfo(
-      "someEnumType",
+  auto sameEnumDiffOrderMap =
+      "test.enum.mood:VarcharEnum(test.enum.mood{\"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"SAD\":\"KNHU2RJAKZAUYVKF\"})";
+  ASSERT_EQ(*parseType(sameEnumDiffOrderMap), *VARCHAR_ENUM(moodInfo));
+
+  // Enum name with special characters.
+  VarcharEnumParameter moodInfoSpecialChars(
+      "test.enum.\"mood/someMood\"",
       {{"CURIOUS", "someValue"},
        {"HAPPY", "some value"},
        {"SAD", "SOME VALUE"}});
+  ASSERT_EQ(
+      *parseType(
+          "test.enum.\"mood/someMood\":VarcharEnum(test.enum.\"mood/someMood\"{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"})"),
+      *VARCHAR_ENUM(moodInfoSpecialChars));
+
+  // Enum names should be in the format catalog.namespace.enum_name. This is
+  // because enum types are part of a UserDefinedType, which has a
+  // 3-part QualifiedObjectName as the type name.
   auto otherEnumString =
       "someEnumType:VarcharEnum(someEnumType{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"})";
-  ASSERT_EQ(*parseType(otherEnumString), *VARCHAR_ENUM(otherEnumInfo));
-
-  auto sameEnumDiffOrderMap =
-      "someEnumType:VarcharEnum(someEnumType{\"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"SAD\":\"KNHU2RJAKZAUYVKF\"})";
-  ASSERT_EQ(*parseType(sameEnumDiffOrderMap), *VARCHAR_ENUM(otherEnumInfo));
+  VELOX_ASSERT_THROW(
+      parseType(otherEnumString),
+      "Failed to parse type [someEnumType:VarcharEnum(someEnumType{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"})]. syntax error, unexpected COLON, expecting WORD");
 
   // Array type with enum values.
   ASSERT_EQ(
@@ -560,7 +596,7 @@ TEST_F(TypeParserTest, invalidVarcharEnums) {
   VELOX_ASSERT_THROW(
       parseType(
           "test.enum.mood:VarcharEnum(test.enum.mood\"CURIOUS\":\"2\", \"HAPPY\":\"happy\"})"),
-      "Failed to parse type [test.enum.mood:VarcharEnum(test.enum.mood\"CURIOUS\":\"2\", \"HAPPY\":\"happy\"})]. syntax error, unexpected QUOTED_ID, expecting LBRACE");
+      "Failed to parse type [test.enum.mood:VarcharEnum(test.enum.mood\"CURIOUS\":\"2\", \"HAPPY\":\"happy\"})]. syntax error, unexpected COLON, expecting LBRACE");
 
   // Invalid enum type with values of different types.
   VELOX_ASSERT_THROW(
diff --git a/velox/functions/prestosql/types/tests/BigintEnumTypeTest.cpp b/velox/functions/prestosql/types/tests/BigintEnumTypeTest.cpp
index 28f5a13ba1f..cf51591b141 100644
--- a/velox/functions/prestosql/types/tests/BigintEnumTypeTest.cpp
+++ b/velox/functions/prestosql/types/tests/BigintEnumTypeTest.cpp
@@ -84,5 +84,19 @@ TEST_F(BigintEnumTypeTest, keyAt) {
   // Test non-existent value
   ASSERT_EQ(moodEnum_->keyAt(999), std::nullopt);
 }
+
+TEST_F(BigintEnumTypeTest, valueAt) {
+  EXPECT_EQ(moodEnum_->valueAt("CURIOUS"), -2);
+  EXPECT_EQ(moodEnum_->valueAt("HAPPY"), 0);
+  EXPECT_EQ(moodEnum_->valueAt("unknown"), std::nullopt);
+}
+
+TEST_F(BigintEnumTypeTest, containsKey) {
+  EXPECT_TRUE(moodEnum_->containsKey("CURIOUS"));
+  EXPECT_TRUE(moodEnum_->containsKey("HAPPY"));
+  EXPECT_FALSE(moodEnum_->containsKey("curious"));
+  EXPECT_FALSE(moodEnum_->containsKey("unknown"));
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/tests/CMakeLists.txt b/velox/functions/prestosql/types/tests/CMakeLists.txt
index eba5b3d9f0b..7366c64a35e 100644
--- a/velox/functions/prestosql/types/tests/CMakeLists.txt
+++ b/velox/functions/prestosql/types/tests/CMakeLists.txt
@@ -15,19 +15,28 @@
 add_executable(
   velox_presto_types_test
   BingTileTypeTest.cpp
+  CustomTypeCoercionTest.cpp
   HyperLogLogTypeTest.cpp
   JsonTypeTest.cpp
+  KHyperLogLogTypeTest.cpp
   TimestampWithTimeZoneTypeTest.cpp
+  TimeWithTimezoneTypeTest.cpp
   TDigestTypeTest.cpp
   QDigestTypeTest.cpp
+  SetDigestTypeTest.cpp
   TypeTestBase.cpp
   UuidTypeTest.cpp
   IPAddressTypeTest.cpp
   IPPrefixTypeTest.cpp
+  PrestoTypesTest.cpp
 )
+velox_add_test_headers(velox_presto_types_test TypeTestBase.h)
 
 if(VELOX_ENABLE_GEO)
-  target_sources(velox_presto_types_test PRIVATE GeometryTypeTest.cpp)
+  target_sources(
+    velox_presto_types_test
+    PRIVATE GeometryTypeTest.cpp SphericalGeographyTypeTest.cpp
+  )
 endif()
 
 add_test(velox_presto_types_test velox_presto_types_test)
@@ -36,6 +45,7 @@ target_link_libraries(
   velox_presto_types_test
   velox_presto_types
   velox_presto_type_parser
+  velox_vector_test_lib
   Folly::folly
   GTest::gtest
   GTest::gtest_main
diff --git a/velox/functions/prestosql/types/tests/CustomTypeCoercionTest.cpp b/velox/functions/prestosql/types/tests/CustomTypeCoercionTest.cpp
new file mode 100644
index 00000000000..e5d8b8a5b0d
--- /dev/null
+++ b/velox/functions/prestosql/types/tests/CustomTypeCoercionTest.cpp
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/types/QDigestRegistration.h"
+#include "velox/functions/prestosql/types/QDigestType.h"
+#include "velox/functions/prestosql/types/TDigestRegistration.h"
+#include "velox/functions/prestosql/types/TDigestType.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneRegistration.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
+#include "velox/functions/prestosql/types/TimestampWithTimeZoneRegistration.h"
+#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/type/TypeCoercer.h"
+
+namespace facebook::velox {
+namespace {
+
+// Verifies implicit coercion rules registered by Presto custom types.
+class CustomTypeCoercionTest : public testing::Test {
+ protected:
+  void SetUp() override {
+    registerTimestampWithTimeZoneType();
+    registerTimeWithTimezoneType();
+    registerQDigestType();
+    registerTDigestType();
+  }
+};
+
+TEST_F(CustomTypeCoercionTest, timestampWithTimeZone) {
+  auto coercion = TypeCoercer::defaults().coerceTypeBase(
+      TIMESTAMP(), TIMESTAMP_WITH_TIME_ZONE()->name());
+  ASSERT_TRUE(coercion.has_value());
+  VELOX_EXPECT_EQ_TYPES(coercion->type, TIMESTAMP_WITH_TIME_ZONE());
+  EXPECT_EQ(coercion->cost, 1);
+
+  coercion = TypeCoercer::defaults().coerceTypeBase(
+      DATE(), TIMESTAMP_WITH_TIME_ZONE()->name());
+  ASSERT_TRUE(coercion.has_value());
+  VELOX_EXPECT_EQ_TYPES(coercion->type, TIMESTAMP_WITH_TIME_ZONE());
+  EXPECT_EQ(coercion->cost, 2);
+
+  // Reverse directions are explicit-only, not coercible.
+  ASSERT_FALSE(
+      TypeCoercer::defaults().coerceTypeBase(
+          TIMESTAMP_WITH_TIME_ZONE(), TIMESTAMP()->name()));
+  ASSERT_FALSE(
+      TypeCoercer::defaults().coerceTypeBase(
+          TIMESTAMP_WITH_TIME_ZONE(), DATE()->name()));
+}
+
+TEST_F(CustomTypeCoercionTest, timeWithTimeZone) {
+  auto coercion = TypeCoercer::defaults().coerceTypeBase(
+      TIME(), TIME_WITH_TIME_ZONE()->name());
+  ASSERT_TRUE(coercion.has_value());
+  VELOX_EXPECT_EQ_TYPES(coercion->type, TIME_WITH_TIME_ZONE());
+
+  // Reverse directions are explicit-only, not coercible.
+  ASSERT_FALSE(
+      TypeCoercer::defaults().coerceTypeBase(
+          TIME_WITH_TIME_ZONE(), TIME()->name()));
+  ASSERT_FALSE(
+      TypeCoercer::defaults().coerceTypeBase(
+          TIME_WITH_TIME_ZONE(), DATE()->name()));
+}
+
+TEST_F(CustomTypeCoercionTest, digests) {
+  EXPECT_FALSE(
+      TypeCoercer::defaults()
+          .coerceTypeBase(TDIGEST(DOUBLE()), "QDIGEST")
+          .has_value());
+  EXPECT_FALSE(
+      TypeCoercer::defaults()
+          .coerceTypeBase(QDIGEST(DOUBLE()), "TDIGEST")
+          .has_value());
+}
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/tests/GeometryTypeTest.cpp b/velox/functions/prestosql/types/tests/GeometryTypeTest.cpp
index f32ad65c7f2..0beb9f3f91a 100644
--- a/velox/functions/prestosql/types/tests/GeometryTypeTest.cpp
+++ b/velox/functions/prestosql/types/tests/GeometryTypeTest.cpp
@@ -29,7 +29,7 @@ class GeometryTypeTest : public testing::Test, public TypeTestBase {
 
 TEST_F(GeometryTypeTest, basic) {
   ASSERT_EQ(GEOMETRY()->name(), "GEOMETRY");
-  ASSERT_EQ(GEOMETRY()->kindName(), "VARBINARY");
+  ASSERT_STREQ(GEOMETRY()->kindName(), "VARBINARY");
   ASSERT_TRUE(GEOMETRY()->parameters().empty());
   ASSERT_EQ(GEOMETRY()->toString(), "GEOMETRY");
 
diff --git a/velox/functions/prestosql/types/tests/IPAddressTypeTest.cpp b/velox/functions/prestosql/types/tests/IPAddressTypeTest.cpp
index 2e15f7fb3a9..b9545634d7a 100644
--- a/velox/functions/prestosql/types/tests/IPAddressTypeTest.cpp
+++ b/velox/functions/prestosql/types/tests/IPAddressTypeTest.cpp
@@ -25,7 +25,7 @@ class IPAddressTypeTest : public testing::Test, public TypeTestBase {
     registerIPAddressType();
   }
 
-  int128_t getIPv6asInt128FromStringUnchecked(const std::string& ipAddr) {
+  int128_t getIPv6asInt128FromStringUnchecked(std::string_view ipAddr) {
     auto ret = ipaddress::tryGetIPv6asInt128FromString(ipAddr);
     return ret.value();
   }
@@ -123,4 +123,18 @@ TEST_F(IPAddressTypeTest, compare) {
           getIPv6asInt128FromStringUnchecked("::ffff:ffff:ffff"),
           getIPv6asInt128FromStringUnchecked("255.255.255.255")));
 }
+
+TEST_F(IPAddressTypeTest, valueToString) {
+  auto toString = [](std::string_view ip) {
+    return IPADDRESS()->valueToString(
+        ipaddress::tryGetIPv6asInt128FromString(ip).value());
+  };
+
+  EXPECT_EQ(toString("1.2.3.4"), "1.2.3.4");
+  EXPECT_EQ(toString("192.168.255.255"), "192.168.255.255");
+  EXPECT_EQ(toString("::1"), "::1");
+  EXPECT_EQ(toString("2001:db8::ff00:42:8329"), "2001:db8::ff00:42:8329");
+  EXPECT_EQ(toString("::ffff:1.2.3.4"), "1.2.3.4");
+}
+
 } // namespace facebook::velox::test
diff --git a/velox/functions/prestosql/types/tests/IPPrefixTypeTest.cpp b/velox/functions/prestosql/types/tests/IPPrefixTypeTest.cpp
index 1b6eed7c999..a27bf777828 100644
--- a/velox/functions/prestosql/types/tests/IPPrefixTypeTest.cpp
+++ b/velox/functions/prestosql/types/tests/IPPrefixTypeTest.cpp
@@ -29,7 +29,6 @@ class IPPrefixTypeTest : public testing::Test, public TypeTestBase {
 TEST_F(IPPrefixTypeTest, basic) {
   ASSERT_STREQ(IPPREFIX()->name(), "IPPREFIX");
   ASSERT_STREQ(IPPREFIX()->kindName(), "ROW");
-  ASSERT_EQ(IPPREFIX()->name(), "IPPREFIX");
   ASSERT_TRUE(IPPREFIX()->parameters().empty());
 
   ASSERT_TRUE(hasType("IPPREFIX"));
@@ -39,4 +38,24 @@ TEST_F(IPPrefixTypeTest, basic) {
 TEST_F(IPPrefixTypeTest, serde) {
   testTypeSerde(IPPREFIX());
 }
+
+TEST_F(IPPrefixTypeTest, valueToString) {
+  auto toString = [](std::string_view ip, int8_t prefixLength) {
+    auto ipValue = ipaddress::tryGetIPv6asInt128FromString(ip).value();
+    char buffer[IPPrefixType::kMaxStringSize];
+    return std::string(
+        IPPREFIX()->valueToString(ipValue, prefixLength, buffer));
+  };
+
+  EXPECT_EQ(toString("192.128.0.0", 9), "192.128.0.0/9");
+  EXPECT_EQ(toString("192.168.255.255", 32), "192.168.255.255/32");
+  EXPECT_EQ(toString("2001:db8::1", 32), "2001:db8::1/32");
+  EXPECT_EQ(toString("::ffff:1.2.3.4", -128), "1.2.3.4/128");
+  // Longest possible: full IPv6 + /128. Prefix length 128 is stored as -128
+  // in int8_t (TINYINT); valueToString casts to uint8_t for formatting.
+  EXPECT_EQ(
+      toString("1234:5678:90ab:cdef:1234:5678:90ab:cdef", -128),
+      "1234:5678:90ab:cdef:1234:5678:90ab:cdef/128");
+}
+
 } // namespace facebook::velox::test
diff --git a/velox/functions/prestosql/types/tests/KHyperLogLogTypeTest.cpp b/velox/functions/prestosql/types/tests/KHyperLogLogTypeTest.cpp
new file mode 100644
index 00000000000..25a6d694d1e
--- /dev/null
+++ b/velox/functions/prestosql/types/tests/KHyperLogLogTypeTest.cpp
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+#include "velox/functions/prestosql/types/KHyperLogLogRegistration.h"
+#include "velox/functions/prestosql/types/tests/TypeTestBase.h"
+
+namespace facebook::velox::test {
+
+class KHyperLogLogTypeTest : public testing::Test, public TypeTestBase {
+ public:
+  KHyperLogLogTypeTest() {
+    registerKHyperLogLogType();
+  }
+};
+
+TEST_F(KHyperLogLogTypeTest, basic) {
+  ASSERT_STREQ(KHYPERLOGLOG()->name(), "KHYPERLOGLOG");
+  ASSERT_EQ(KHYPERLOGLOG()->toString(), "KHYPERLOGLOG");
+  ASSERT_FALSE(KHYPERLOGLOG()->isOrderable());
+  ASSERT_TRUE(KHYPERLOGLOG()->equivalent(*KHYPERLOGLOG()));
+  ASSERT_FALSE(KHYPERLOGLOG()->equivalent(*BIGINT()));
+
+  ASSERT_TRUE(hasType("KHYPERLOGLOG"));
+  ASSERT_EQ(*getType("KHYPERLOGLOG", {}), *KHYPERLOGLOG());
+}
+
+TEST_F(KHyperLogLogTypeTest, isKHyperLogLogType) {
+  ASSERT_TRUE(isKHyperLogLogType(KHYPERLOGLOG()));
+  ASSERT_FALSE(isKHyperLogLogType(BIGINT()));
+  ASSERT_FALSE(isKHyperLogLogType(VARBINARY()));
+}
+
+TEST_F(KHyperLogLogTypeTest, serde) {
+  testTypeSerde(KHYPERLOGLOG());
+}
+
+} // namespace facebook::velox::test
diff --git a/velox/functions/prestosql/types/tests/PrestoTypesTest.cpp b/velox/functions/prestosql/types/tests/PrestoTypesTest.cpp
new file mode 100644
index 00000000000..568c4139df8
--- /dev/null
+++ b/velox/functions/prestosql/types/tests/PrestoTypesTest.cpp
@@ -0,0 +1,436 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/types/BingTileType.h"
+#include "velox/functions/prestosql/types/HyperLogLogType.h"
+#include "velox/functions/prestosql/types/IPAddressType.h"
+#include "velox/functions/prestosql/types/IPPrefixType.h"
+#include "velox/functions/prestosql/types/JsonType.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+#include "velox/functions/prestosql/types/P4HyperLogLogType.h"
+#include "velox/functions/prestosql/types/PrestoTypes.h"
+#include "velox/functions/prestosql/types/QDigestType.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
+#include "velox/functions/prestosql/types/SfmSketchType.h"
+#include "velox/functions/prestosql/types/TDigestType.h"
+#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/functions/prestosql/types/UuidType.h"
+#include "velox/type/Time.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+namespace facebook::velox {
+namespace {
+
+TEST(PrestoTypeSqlTest, primitive) {
+  EXPECT_EQ(PrestoTypes::toSql(BOOLEAN()), "BOOLEAN");
+  EXPECT_EQ(PrestoTypes::toSql(TINYINT()), "TINYINT");
+  EXPECT_EQ(PrestoTypes::toSql(SMALLINT()), "SMALLINT");
+  EXPECT_EQ(PrestoTypes::toSql(INTEGER()), "INTEGER");
+  EXPECT_EQ(PrestoTypes::toSql(BIGINT()), "BIGINT");
+  EXPECT_EQ(PrestoTypes::toSql(REAL()), "REAL");
+  EXPECT_EQ(PrestoTypes::toSql(DOUBLE()), "DOUBLE");
+  EXPECT_EQ(PrestoTypes::toSql(VARCHAR()), "VARCHAR");
+  EXPECT_EQ(PrestoTypes::toSql(VARBINARY()), "VARBINARY");
+  EXPECT_EQ(PrestoTypes::toSql(TIMESTAMP()), "TIMESTAMP");
+  EXPECT_EQ(PrestoTypes::toSql(DATE()), "DATE");
+  EXPECT_EQ(PrestoTypes::toSql(UNKNOWN()), "UNKNOWN");
+}
+
+TEST(PrestoTypeSqlTest, custom) {
+  EXPECT_EQ(
+      PrestoTypes::toSql(TIMESTAMP_WITH_TIME_ZONE()),
+      "TIMESTAMP WITH TIME ZONE");
+  EXPECT_EQ(PrestoTypes::toSql(JSON()), "JSON");
+  EXPECT_EQ(PrestoTypes::toSql(HYPERLOGLOG()), "HYPERLOGLOG");
+  EXPECT_EQ(PrestoTypes::toSql(KHYPERLOGLOG()), "KHYPERLOGLOG");
+  EXPECT_EQ(PrestoTypes::toSql(P4HYPERLOGLOG()), "P4HYPERLOGLOG");
+  EXPECT_EQ(PrestoTypes::toSql(TDIGEST(DOUBLE())), "TDIGEST(DOUBLE)");
+  EXPECT_EQ(PrestoTypes::toSql(QDIGEST(DOUBLE())), "QDIGEST(DOUBLE)");
+  EXPECT_EQ(PrestoTypes::toSql(QDIGEST(BIGINT())), "QDIGEST(BIGINT)");
+  EXPECT_EQ(PrestoTypes::toSql(SETDIGEST()), "SETDIGEST");
+  EXPECT_EQ(PrestoTypes::toSql(SFMSKETCH()), "SFMSKETCH");
+  EXPECT_EQ(PrestoTypes::toSql(IPADDRESS()), "IPADDRESS");
+  EXPECT_EQ(PrestoTypes::toSql(IPPREFIX()), "IPPREFIX");
+  EXPECT_EQ(PrestoTypes::toSql(UUID()), "UUID");
+  EXPECT_EQ(PrestoTypes::toSql(BINGTILE()), "BINGTILE");
+}
+
+TEST(PrestoTypeSqlTest, complex) {
+  EXPECT_EQ(PrestoTypes::toSql(ARRAY(BOOLEAN())), "ARRAY(BOOLEAN)");
+  EXPECT_EQ(
+      PrestoTypes::toSql(ARRAY(ARRAY(INTEGER()))), "ARRAY(ARRAY(INTEGER))");
+  EXPECT_EQ(
+      PrestoTypes::toSql(MAP(BOOLEAN(), INTEGER())), "MAP(BOOLEAN, INTEGER)");
+  EXPECT_EQ(
+      PrestoTypes::toSql(MAP(VARCHAR(), ARRAY(BIGINT()))),
+      "MAP(VARCHAR, ARRAY(BIGINT))");
+}
+
+TEST(PrestoTypeSqlTest, row) {
+  EXPECT_EQ(
+      PrestoTypes::toSql(ROW({{"a", BOOLEAN()}, {"b", INTEGER()}})),
+      "ROW(a BOOLEAN, b INTEGER)");
+  EXPECT_EQ(
+      PrestoTypes::toSql(
+          ROW({{"a_", BOOLEAN()}, {"b$", INTEGER()}, {"c d", INTEGER()}})),
+      "ROW(a_ BOOLEAN, \"b$\" INTEGER, \"c d\" INTEGER)");
+  // Unnamed fields.
+  EXPECT_EQ(
+      PrestoTypes::toSql(ROW({INTEGER(), BOOLEAN()})), "ROW(INTEGER, BOOLEAN)");
+  // Field names that need quoting.
+  EXPECT_EQ(
+      PrestoTypes::toSql(ROW(
+          {{"a with spaces", INTEGER()}, {"b with \"quotes\"", VARCHAR()}})),
+      "ROW(\"a with spaces\" INTEGER, \"b with \"\"quotes\"\"\" VARCHAR)");
+  EXPECT_EQ(
+      PrestoTypes::toSql(ROW({{"123", INTEGER()}})), "ROW(\"123\" INTEGER)");
+}
+
+TEST(PrestoTypeSqlTest, decimal) {
+  EXPECT_EQ(PrestoTypes::toSql(DECIMAL(10, 2)), "DECIMAL(10, 2)");
+  EXPECT_EQ(PrestoTypes::toSql(DECIMAL(38, 0)), "DECIMAL(38, 0)");
+  EXPECT_EQ(PrestoTypes::toSql(DECIMAL(3, 3)), "DECIMAL(3, 3)");
+}
+
+// Tests PrestoTypes::valueToString which extends Type::valueToString with
+// Presto custom type formatting. Tests are grouped by physical type and use
+// the same raw values to illustrate the difference in output.
+TEST(PrestoTypeSqlTest, valueToString) {
+  // int64_t types: BIGINT, DECIMAL, TIME, BINGTILE, TIMESTAMP WITH TIME ZONE,
+  // TIME WITH TIME ZONE. Same raw value 45'123 is formatted differently
+  // depending on the logical type.
+  {
+    const int64_t value = 45'123;
+
+    {
+      TypePtr type = BIGINT();
+      EXPECT_EQ(PrestoTypes::valueToString(value, type), "45123");
+    }
+    {
+      TypePtr type = DECIMAL(10, 2);
+      EXPECT_EQ(PrestoTypes::valueToString(value, type), "451.23");
+    }
+    {
+      // 45'123 ms since midnight = 00:00:45.123.
+      TypePtr type = TIME();
+      EXPECT_EQ(PrestoTypes::valueToString(value, type), "00:00:45.123");
+    }
+    {
+      TypePtr type = TIME_WITH_TIME_ZONE();
+      EXPECT_EQ(PrestoTypes::valueToString(value, type), "11:06:00.011-12:54");
+    }
+    {
+      TypePtr type = TIMESTAMP_WITH_TIME_ZONE();
+      EXPECT_EQ(
+          PrestoTypes::valueToString(value, type),
+          "1969-12-31 11:06:00.011 -12:54");
+    }
+    {
+      TypePtr type = BINGTILE();
+      EXPECT_EQ(
+          PrestoTypes::valueToString(value, type), "{x=0, y=45123, zoom=0}");
+    }
+  }
+
+  // int128_t types: HUGEINT, DECIMAL, IPADDRESS, UUID.
+  // Same raw value 45'123 is formatted differently depending on the logical
+  // type.
+  {
+    const int128_t value = 45'123;
+
+    {
+      TypePtr type = DECIMAL(38, 2);
+      EXPECT_EQ(PrestoTypes::valueToString(value, type), "451.23");
+    }
+    {
+      TypePtr type = IPADDRESS();
+      EXPECT_EQ(PrestoTypes::valueToString(value, type), "::b043");
+    }
+    {
+      TypePtr type = UUID();
+      EXPECT_EQ(
+          PrestoTypes::valueToString(value, type),
+          "00000000-0000-0000-0000-00000000b043");
+    }
+  }
+
+  // int32_t types: INTEGER, DATE.
+  {
+    const int32_t value = 45'123;
+
+    {
+      TypePtr type = INTEGER();
+      EXPECT_EQ(PrestoTypes::valueToString(value, type), "45123");
+    }
+    {
+      TypePtr type = DATE();
+      EXPECT_EQ(PrestoTypes::valueToString(value, type), "2093-07-17");
+    }
+  }
+
+  // StringView types: VARCHAR and JSON render the string content as-is.
+  // JSON values are already normalized by json_parse at execution time.
+  {
+    StringView value(R"({"a":1,"b":2})");
+
+    EXPECT_EQ(PrestoTypes::valueToString(value, VARCHAR()), value.str());
+    EXPECT_EQ(PrestoTypes::valueToString(value, JSON()), value.str());
+  }
+
+  // VARBINARY-based Presto types render as space-separated hex bytes.
+  {
+    StringView value("hello");
+    const std::string expected = "68 65 6c 6c 6f";
+
+    EXPECT_EQ(PrestoTypes::valueToString(value, VARBINARY()), expected);
+    EXPECT_EQ(PrestoTypes::valueToString(value, HYPERLOGLOG()), expected);
+    EXPECT_EQ(PrestoTypes::valueToString(value, KHYPERLOGLOG()), expected);
+    EXPECT_EQ(PrestoTypes::valueToString(value, P4HYPERLOGLOG()), expected);
+    EXPECT_EQ(PrestoTypes::valueToString(value, TDIGEST(DOUBLE())), expected);
+    EXPECT_EQ(PrestoTypes::valueToString(value, QDIGEST(DOUBLE())), expected);
+    EXPECT_EQ(PrestoTypes::valueToString(value, SETDIGEST()), expected);
+    EXPECT_EQ(PrestoTypes::valueToString(value, SFMSKETCH()), expected);
+  }
+
+  // Remaining scalar types.
+  EXPECT_EQ(PrestoTypes::valueToString(true, BOOLEAN()), "true");
+  EXPECT_EQ(
+      PrestoTypes::valueToString(static_cast<int8_t>(42), TINYINT()), "42");
+  EXPECT_EQ(
+      PrestoTypes::valueToString(static_cast<int16_t>(42), SMALLINT()), "42");
+  EXPECT_EQ(PrestoTypes::valueToString(1.5f, REAL()), "1.5");
+  EXPECT_EQ(PrestoTypes::valueToString(1.5, DOUBLE()), "1.5");
+  EXPECT_EQ(
+      PrestoTypes::valueToString(Timestamp(0, 0), TIMESTAMP()),
+      "1970-01-01 00:00:00.000");
+  // Non-zero nanos: verify millisecond truncation.
+  EXPECT_EQ(
+      PrestoTypes::valueToString(
+          Timestamp(1'705'320'000, 123'456'789), TIMESTAMP()),
+      "2024-01-15 12:00:00.123");
+  // Pre-1000 year: verify zero-padded year.
+  EXPECT_EQ(
+      PrestoTypes::valueToString(Timestamp(-62'135'596'800, 0), TIMESTAMP()),
+      "0001-01-01 00:00:00.000");
+}
+
+// Tests PrestoTypes::valueToString(DecodedVector) which handles nulls,
+// Presto custom types, and complex types. Uses dictionary-encoded vectors
+// with reversed indices to verify proper index handling.
+class PrestoTypesDecodedTest : public testing::Test,
+                               public test::VectorTestBase {
+ protected:
+  static void SetUpTestSuite() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
+
+TEST_F(PrestoTypesDecodedTest, nulls) {
+  auto dictionary = wrapInDictionary(
+      makeIndices({1, 0}),
+      makeNullableFlatVector<int64_t>({std::nullopt, int64_t{45'123}}));
+  DecodedVector decoded(*dictionary);
+  EXPECT_EQ(PrestoTypes::valueToString(decoded, 0, BIGINT()), "45123");
+  EXPECT_EQ(PrestoTypes::valueToString(decoded, 1, BIGINT()), "null");
+}
+
+// int64_t: BIGINT (built-in) vs TIMESTAMP WITH TIME ZONE (custom).
+// Same underlying vector, different type interpretation.
+TEST_F(PrestoTypesDecodedTest, bigintAndTimestampWithTimeZone) {
+  auto dictionary = wrapInDictionary(
+      makeIndices({1, 0}),
+      makeFlatVector<int64_t>({int64_t{45'123}, int64_t{45'124}}));
+  DecodedVector decoded(*dictionary);
+
+  EXPECT_EQ(PrestoTypes::valueToString(decoded, 0, BIGINT()), "45124");
+  EXPECT_EQ(PrestoTypes::valueToString(decoded, 1, BIGINT()), "45123");
+
+  EXPECT_EQ(
+      PrestoTypes::valueToString(decoded, 0, TIMESTAMP_WITH_TIME_ZONE()),
+      "1969-12-31 11:07:00.011 -12:53");
+  EXPECT_EQ(
+      PrestoTypes::valueToString(decoded, 1, TIMESTAMP_WITH_TIME_ZONE()),
+      "1969-12-31 11:06:00.011 -12:54");
+}
+
+// Array: same underlying vector interpreted as ARRAY(INTEGER) vs
+// ARRAY(DATE). Uses > 5 elements to verify no truncation.
+TEST_F(PrestoTypesDecodedTest, array) {
+  auto dictionary = wrapInDictionary(
+      makeIndices({1, 0}),
+      makeArrayVector<int32_t>({
+          {0, 1, 2, 3, 4, 5, 6},
+          {18'262, 18'263, 18'264, 18'265, 18'266, 18'267},
+      }));
+
+  DecodedVector decoded(*dictionary);
+
+  EXPECT_EQ(
+      PrestoTypes::valueToString(decoded, 0, ARRAY(INTEGER())),
+      "[18262, 18263, 18264, 18265, 18266, 18267]");
+  EXPECT_EQ(
+      PrestoTypes::valueToString(decoded, 1, ARRAY(INTEGER())),
+      "[0, 1, 2, 3, 4, 5, 6]");
+
+  EXPECT_EQ(
+      PrestoTypes::valueToString(decoded, 0, ARRAY(DATE())),
+      "[2020-01-01, 2020-01-02, 2020-01-03, 2020-01-04, 2020-01-05, 2020-01-06]");
+  EXPECT_EQ(
+      PrestoTypes::valueToString(decoded, 1, ARRAY(DATE())),
+      "[1970-01-01, 1970-01-02, 1970-01-03, 1970-01-04, 1970-01-05, 1970-01-06, 1970-01-07]");
+
+  // Empty array — same vector, different element types.
+  {
+    auto emptyDictionary =
+        wrapInDictionary(makeIndices({0}), makeArrayVector<int32_t>({{}}));
+    DecodedVector emptyDecoded(*emptyDictionary);
+    EXPECT_EQ(
+        PrestoTypes::valueToString(emptyDecoded, 0, ARRAY(INTEGER())), "[]");
+    EXPECT_EQ(
+        PrestoTypes::valueToString(emptyDecoded, 0, ARRAY(UNKNOWN())), "[]");
+    EXPECT_EQ(PrestoTypes::valueToString(emptyDecoded, 0, ARRAY(DATE())), "[]");
+  }
+}
+
+// Map: same underlying vector interpreted as MAP(INTEGER, INTEGER) vs
+// MAP(INTEGER, DATE). Uses > 5 entries to verify no truncation.
+TEST_F(PrestoTypesDecodedTest, map) {
+  auto dictionary = wrapInDictionary(
+      makeIndices({1, 0}),
+      makeMapVector<int32_t, int32_t>(
+          {{{1, 0}, {2, 1}, {3, 2}, {4, 3}, {5, 4}, {6, 5}},
+           {
+               {7, 18'262},
+               {8, 18'263},
+               {9, 18'264},
+               {10, 18'265},
+               {11, 18'266},
+               {12, 18'267},
+           }}));
+
+  DecodedVector decoded(*dictionary);
+
+  EXPECT_EQ(
+      PrestoTypes::valueToString(decoded, 0, MAP(INTEGER(), INTEGER())),
+      "{7=18262, 8=18263, 9=18264, 10=18265, 11=18266, 12=18267}");
+  EXPECT_EQ(
+      PrestoTypes::valueToString(decoded, 1, MAP(INTEGER(), INTEGER())),
+      "{1=0, 2=1, 3=2, 4=3, 5=4, 6=5}");
+
+  EXPECT_EQ(
+      PrestoTypes::valueToString(decoded, 0, MAP(INTEGER(), DATE())),
+      "{7=2020-01-01, 8=2020-01-02, 9=2020-01-03, 10=2020-01-04, 11=2020-01-05, 12=2020-01-06}");
+  EXPECT_EQ(
+      PrestoTypes::valueToString(decoded, 1, MAP(INTEGER(), DATE())),
+      "{1=1970-01-01, 2=1970-01-02, 3=1970-01-03, 4=1970-01-04, 5=1970-01-05, 6=1970-01-06}");
+
+  // Empty map — same vector, different value types.
+  {
+    auto emptyDictionary = wrapInDictionary(
+        makeIndices({0}), makeMapVector<int32_t, int32_t>({{}}));
+    DecodedVector emptyDecoded(*emptyDictionary);
+    EXPECT_EQ(
+        PrestoTypes::valueToString(emptyDecoded, 0, MAP(INTEGER(), INTEGER())),
+        "{}");
+    EXPECT_EQ(
+        PrestoTypes::valueToString(emptyDecoded, 0, MAP(INTEGER(), DATE())),
+        "{}");
+  }
+}
+
+// ROW (built-in) vs IPPREFIX (custom ROW type). Same underlying RowVector,
+// different type produces different output.
+TEST_F(PrestoTypesDecodedTest, rowAndIpPrefix) {
+  auto dictionary = wrapInDictionary(
+      makeIndices({1, 0}),
+      makeRowVector({
+          makeFlatVector<int128_t>({int128_t{45'123}, int128_t{45'124}}),
+          makeFlatVector<int8_t>({24, 8}),
+      }));
+
+  DecodedVector decoded(*dictionary);
+
+  EXPECT_EQ(PrestoTypes::valueToString(decoded, 0, IPPREFIX()), "::b044/8");
+  EXPECT_EQ(PrestoTypes::valueToString(decoded, 1, IPPREFIX()), "::b043/24");
+
+  // Same data interpreted as a plain ROW renders raw values.
+  {
+    auto rowType = ROW({{"ip", HUGEINT()}, {"prefix", TINYINT()}});
+    EXPECT_EQ(
+        PrestoTypes::valueToString(decoded, 0, rowType),
+        "{ip=45124, prefix=8}");
+    EXPECT_EQ(
+        PrestoTypes::valueToString(decoded, 1, rowType),
+        "{ip=45123, prefix=24}");
+  }
+
+  // Same data interpreted as ROW(UUID(), TINYINT()).
+  {
+    auto rowType = ROW({{"id", UUID()}, {"prefix", TINYINT()}});
+    EXPECT_EQ(
+        PrestoTypes::valueToString(decoded, 0, rowType),
+        "{id=00000000-0000-0000-0000-00000000b044, prefix=8}");
+    EXPECT_EQ(
+        PrestoTypes::valueToString(decoded, 1, rowType),
+        "{id=00000000-0000-0000-0000-00000000b043, prefix=24}");
+  }
+}
+
+// ROW with > 5 fields to verify no truncation.
+TEST_F(PrestoTypesDecodedTest, rowManyFields) {
+  auto dictionary = wrapInDictionary(
+      makeIndices({1, 0}),
+      makeRowVector({
+          makeFlatVector<int32_t>({1, 10}),
+          makeFlatVector<int32_t>({2, 20}),
+          makeFlatVector<int32_t>({3, 30}),
+          makeFlatVector<int32_t>({4, 40}),
+          makeFlatVector<int32_t>({5, 50}),
+          makeFlatVector<int32_t>({6, 60}),
+      }));
+
+  DecodedVector decoded(*dictionary);
+
+  // Same underlying data, but each field uses a different INTEGER-based type.
+  auto rowType = ROW(
+      {{"a", INTEGER()},
+       {"b", DATE()},
+       {"c", INTERVAL_YEAR_MONTH()},
+       {"d", INTEGER()},
+       {"e", DATE()},
+       {"f", INTERVAL_YEAR_MONTH()}});
+  EXPECT_EQ(
+      PrestoTypes::valueToString(decoded, 0, rowType),
+      "{a=10, b=1970-01-21, c=2-6, d=40, e=1970-02-20, f=5-0}");
+  EXPECT_EQ(
+      PrestoTypes::valueToString(decoded, 1, rowType),
+      "{a=1, b=1970-01-03, c=0-3, d=4, e=1970-01-06, f=0-6}");
+
+  // Unnamed fields use field0, field1, etc. like Presto.
+  auto unnamedRowType = ROW(folly::copy(rowType->children()));
+  EXPECT_EQ(
+      PrestoTypes::valueToString(decoded, 0, unnamedRowType),
+      "{field0=10, field1=1970-01-21, field2=2-6, field3=40, field4=1970-02-20, field5=5-0}");
+  EXPECT_EQ(
+      PrestoTypes::valueToString(decoded, 1, unnamedRowType),
+      "{field0=1, field1=1970-01-03, field2=0-3, field3=4, field4=1970-01-06, field5=0-6}");
+}
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/tests/SetDigestTypeTest.cpp b/velox/functions/prestosql/types/tests/SetDigestTypeTest.cpp
new file mode 100644
index 00000000000..f1ff72bf0df
--- /dev/null
+++ b/velox/functions/prestosql/types/tests/SetDigestTypeTest.cpp
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/prestosql/types/SetDigestType.h"
+#include "velox/functions/prestosql/types/SetDigestRegistration.h"
+#include "velox/functions/prestosql/types/tests/TypeTestBase.h"
+
+namespace facebook::velox::test {
+
+class SetDigestTypeTest : public testing::Test, public TypeTestBase {
+ public:
+  SetDigestTypeTest() {
+    registerSetDigestType();
+  }
+};
+
+TEST_F(SetDigestTypeTest, basic) {
+  ASSERT_STREQ(SETDIGEST()->name(), "SETDIGEST");
+  ASSERT_STREQ(SETDIGEST()->kindName(), "VARBINARY");
+  ASSERT_TRUE(SETDIGEST()->parameters().empty());
+  ASSERT_EQ(SETDIGEST()->toString(), "SETDIGEST");
+
+  ASSERT_TRUE(hasType("SETDIGEST"));
+  ASSERT_EQ(*getType("SETDIGEST", {}), *SETDIGEST());
+
+  ASSERT_FALSE(SETDIGEST()->isOrderable());
+}
+
+TEST_F(SetDigestTypeTest, isSetDigestType) {
+  ASSERT_TRUE(isSetDigestType(SETDIGEST()));
+  ASSERT_FALSE(isSetDigestType(BIGINT()));
+  ASSERT_FALSE(isSetDigestType(VARBINARY()));
+}
+
+TEST_F(SetDigestTypeTest, serde) {
+  testTypeSerde(SETDIGEST());
+}
+} // namespace facebook::velox::test
diff --git a/velox/functions/prestosql/types/tests/SphericalGeographyTypeTest.cpp b/velox/functions/prestosql/types/tests/SphericalGeographyTypeTest.cpp
new file mode 100644
index 00000000000..2a256ef115c
--- /dev/null
+++ b/velox/functions/prestosql/types/tests/SphericalGeographyTypeTest.cpp
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/types/SphericalGeographyType.h"
+#include "velox/functions/prestosql/types/SphericalGeographyRegistration.h"
+#include "velox/functions/prestosql/types/tests/TypeTestBase.h"
+
+namespace facebook::velox::test {
+
+class SphericalGeographyTypeTest : public testing::Test, public TypeTestBase {
+ public:
+  SphericalGeographyTypeTest() {
+    registerSphericalGeographyType();
+  }
+};
+
+TEST_F(SphericalGeographyTypeTest, basic) {
+  ASSERT_EQ(SPHERICAL_GEOGRAPHY()->name(), "SPHERICALGEOGRAPHY");
+  ASSERT_STREQ(SPHERICAL_GEOGRAPHY()->kindName(), "VARBINARY");
+  ASSERT_TRUE(SPHERICAL_GEOGRAPHY()->parameters().empty());
+  ASSERT_EQ(SPHERICAL_GEOGRAPHY()->toString(), "SPHERICALGEOGRAPHY");
+
+  ASSERT_TRUE(hasType("SPHERICALGEOGRAPHY"));
+  ASSERT_EQ(*getType("SPHERICALGEOGRAPHY", {}), *SPHERICAL_GEOGRAPHY());
+
+  ASSERT_FALSE(SPHERICAL_GEOGRAPHY()->isOrderable());
+}
+
+TEST_F(SphericalGeographyTypeTest, serde) {
+  testTypeSerde(SPHERICAL_GEOGRAPHY());
+}
+} // namespace facebook::velox::test
diff --git a/velox/functions/prestosql/types/tests/TimeWithTimezoneTypeTest.cpp b/velox/functions/prestosql/types/tests/TimeWithTimezoneTypeTest.cpp
new file mode 100644
index 00000000000..fef6266b85d
--- /dev/null
+++ b/velox/functions/prestosql/types/tests/TimeWithTimezoneTypeTest.cpp
@@ -0,0 +1,260 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneRegistration.h"
+#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/functions/prestosql/types/tests/TypeTestBase.h"
+#include "velox/type/Time.h"
+
+namespace facebook::velox::test {
+
+class TimeWithTimezoneTypeTest : public testing::Test, public TypeTestBase {
+ public:
+  TimeWithTimezoneTypeTest() {
+    registerTimeWithTimezoneType();
+  }
+};
+
+// Basic type properties test - similar to TimestampWithTimeZoneTypeTest
+TEST_F(TimeWithTimezoneTypeTest, basic) {
+  auto type = TIME_WITH_TIME_ZONE();
+
+  // Test type name and properties
+  ASSERT_STREQ(type->name(), "TIME WITH TIME ZONE");
+  ASSERT_STREQ(type->kindName(), "BIGINT");
+  ASSERT_EQ(type->toString(), "TIME WITH TIME ZONE");
+
+  // Test that type is registered and can be retrieved
+  ASSERT_TRUE(hasType("time with time zone"));
+  auto retrievedType = getType("time with time zone", {});
+  ASSERT_TRUE(retrievedType != nullptr);
+}
+
+// Test serialization/deserialization - similar to TimestampWithTimeZoneTypeTest
+TEST_F(TimeWithTimezoneTypeTest, serde) {
+  testTypeSerde(TIME_WITH_TIME_ZONE());
+}
+
+// Test type equivalence
+TEST_F(TimeWithTimezoneTypeTest, equivalent) {
+  auto type1 = TIME_WITH_TIME_ZONE();
+  auto type2 = TIME_WITH_TIME_ZONE();
+
+  // Since it's a singleton, they should be equivalent
+  ASSERT_TRUE(type1->equivalent(*type2));
+  ASSERT_TRUE(type2->equivalent(*type1));
+
+  // Test with different type
+  auto bigintType = BIGINT();
+  ASSERT_FALSE(type1->equivalent(*bigintType));
+}
+
+// Test basic properties
+TEST_F(TimeWithTimezoneTypeTest, properties) {
+  auto type = TIME_WITH_TIME_ZONE();
+
+  ASSERT_TRUE(type->isOrderable());
+  ASSERT_TRUE(type->isComparable());
+}
+
+// Test value to string conversion
+// Note: TIME WITH TIME ZONE stores time in UTC and displays it in local time
+// by adding the timezone offset to the UTC value
+TEST_F(TimeWithTimezoneTypeTest, valueToString) {
+  auto type = TIME_WITH_TIME_ZONE();
+  char buffer[TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize];
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+
+  // Test midnight UTC (00:00:00.000 UTC) at UTC+00:00
+  int64_t timeValue = 0;
+  int16_t timeZone = util::biasEncode(0); // UTC
+  auto value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "00:00:00.000+00:00");
+
+  // Test 01:00:00.000 UTC at UTC+00:00
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  value = util::pack(3600000, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "01:00:00.000+00:00");
+
+  // Test UTC 12:30:45.123 with UTC+00:00 → displays as 12:30:45.123+00:00
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  timeValue = 12 * 3600000 + 30 * 60000 + 45 * 1000 + 123;
+  value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "12:30:45.123+00:00");
+
+  // Test UTC 12:30:45.123 with UTC-08:00 (PST)
+  // → displays as 04:30:45.123-08:00 (12:30 - 8h = 04:30)
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  timeZone = util::biasEncode(-480); // PST
+  value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "04:30:45.123-08:00");
+
+  // Test UTC 12:30:45.123 with UTC-05:00 (EST)
+  // → displays as 07:30:45.123-05:00 (12:30 - 5h = 07:30)
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  timeZone = util::biasEncode(-300); // EST
+  value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "07:30:45.123-05:00");
+
+  // Test UTC 12:30:45.123 with UTC+00:00 (GMT)
+  // → displays as 12:30:45.123+00:00
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  timeZone = util::biasEncode(0); // GMT
+  value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "12:30:45.123+00:00");
+
+  // Test UTC 12:30:45.123 with UTC+01:00 (BST)
+  // → displays as 13:30:45.123+01:00 (12:30 + 1h = 13:30)
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  timeZone = util::biasEncode(60); // BST
+  value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "13:30:45.123+01:00");
+
+  // Test UTC 12:30:45.123 with UTC+09:00 (JST)
+  // → displays as 21:30:45.123+09:00 (12:30 + 9h = 21:30)
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  timeZone = util::biasEncode(540); // JST
+  value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "21:30:45.123+09:00");
+
+  // Test UTC 12:30:45.123 with UTC+10:00 (AEST)
+  // → displays as 22:30:45.123+10:00 (12:30 + 10h = 22:30)
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  timeZone = util::biasEncode(600); // AEST
+  value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "22:30:45.123+10:00");
+
+  // Test UTC 12:30:45.123 with UTC+11:00 (AEDT)
+  // → displays as 23:30:45.123+11:00 (12:30 + 11h = 23:30)
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  timeZone = util::biasEncode(660); // AEDT
+  value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "23:30:45.123+11:00");
+
+  // Test UTC 12:30:45.123 with UTC+13:00 (NZST)
+  // → displays as 01:30:45.123+13:00 (12:30 + 13h = 25:30 → wraps to 01:30)
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  timeZone = util::biasEncode(780); // NZST
+  value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "01:30:45.123+13:00");
+
+  // Test UTC 12:30:45.123 with UTC+14:00 (NZDT)
+  // → displays as 02:30:45.123+14:00 (12:30 + 14h = 26:30 → wraps to 02:30)
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  timeZone = util::biasEncode(840); // NZDT
+  value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "02:30:45.123+14:00");
+
+  // Test UTC 12:30:45.123 with UTC-14:00
+  // → displays as 22:30:45.123-14:00 (12:30 - 14h = -1:30 → wraps to 22:30)
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  timeZone = util::biasEncode(-840); // UTC-14:00
+  value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "22:30:45.123-14:00");
+}
+
+TEST_F(TimeWithTimezoneTypeTest, compare) {
+  auto compare = [](int32_t expected, int64_t left, int64_t right) {
+    ASSERT_EQ(expected, TIME_WITH_TIME_ZONE()->compare(left, right));
+  };
+
+  // Same UTC time: "12:30:45.123+01:00" == "11:30:45.123+00:00"
+  compare(
+      0,
+      util::pack(41445123, util::biasEncode(60)),
+      util::pack(41445123, util::biasEncode(0)));
+
+  // Different UTC times: "10:00:00.000+01:00" < "15:00:00.000+01:00"
+  compare(
+      -1,
+      util::pack(32400000, util::biasEncode(60)),
+      util::pack(50400000, util::biasEncode(60)));
+  // "15:00:00.000+01:00" > "10:00:00.000+01:00"
+  compare(
+      1,
+      util::pack(50400000, util::biasEncode(60)),
+      util::pack(32400000, util::biasEncode(60)));
+  // "10:00:00.000+01:00" < "15:00:00.000+03:00"
+  compare(
+      -1,
+      util::pack(32400000, util::biasEncode(60)),
+      util::pack(43200000, util::biasEncode(180)));
+
+  // Wrap-around normalization: "00:00:00.000+01:00" < "23:59:59.999+03:00"
+  compare(
+      -1,
+      util::pack(82800000, util::biasEncode(60)),
+      util::pack(75599999, util::biasEncode(180)));
+  // "15:00:00.000+03:00" > "10:00:00.000+01:00"
+  compare(
+      1,
+      util::pack(43200000, util::biasEncode(180)),
+      util::pack(32400000, util::biasEncode(60)));
+  // "23:59:59.999+03:00" > "00:00:00.000+01:00"
+  compare(
+      1,
+      util::pack(75599999, util::biasEncode(180)),
+      util::pack(82800000, util::biasEncode(60)));
+}
+
+TEST_F(TimeWithTimezoneTypeTest, hash) {
+  auto expectHashesEq = [](int64_t millis1,
+                           int16_t tzOffsetMinutes1,
+                           int64_t millis2,
+                           int16_t tzOffsetMinutes2) {
+    int64_t left = util::pack(millis1, util::biasEncode(tzOffsetMinutes1));
+    int64_t right = util::pack(millis2, util::biasEncode(tzOffsetMinutes2));
+
+    ASSERT_EQ(
+        TIME_WITH_TIME_ZONE()->hash(left), TIME_WITH_TIME_ZONE()->hash(right));
+  };
+
+  auto expectHashesNeq = [](int64_t millis1,
+                            int16_t tzOffsetMinutes1,
+                            int64_t millis2,
+                            int16_t tzOffsetMinutes2) {
+    int64_t left = util::pack(millis1, util::biasEncode(tzOffsetMinutes1));
+    int64_t right = util::pack(millis2, util::biasEncode(tzOffsetMinutes2));
+
+    ASSERT_NE(
+        TIME_WITH_TIME_ZONE()->hash(left), TIME_WITH_TIME_ZONE()->hash(right));
+  };
+
+  expectHashesEq(45045123, 60, 45045123, 180);
+  expectHashesEq(45045123, 60, 45045123, -840);
+  expectHashesEq(45045123, 180, 45045123, -840);
+  expectHashesEq(0, 180, 0, -840);
+
+  expectHashesNeq(36000000, 60, 54000000, 180);
+  expectHashesNeq(36000000, 60, 54000000, -840);
+  expectHashesNeq(36000000, 180, 54000000, -840);
+  expectHashesNeq(0, 180, 86399999, -840);
+}
+
+} // namespace facebook::velox::test
diff --git a/velox/functions/prestosql/types/tests/TimestampWithTimeZoneTypeTest.cpp b/velox/functions/prestosql/types/tests/TimestampWithTimeZoneTypeTest.cpp
index ab6f81f4a70..6df47613a2b 100644
--- a/velox/functions/prestosql/types/tests/TimestampWithTimeZoneTypeTest.cpp
+++ b/velox/functions/prestosql/types/tests/TimestampWithTimeZoneTypeTest.cpp
@@ -133,4 +133,22 @@ TEST_F(TimestampWithTimeZoneTypeTest, hash) {
   expectHashesNeq(-1639426440000, "+03:00", 1639426440000, "-14:00");
 }
 
+TEST_F(TimestampWithTimeZoneTypeTest, valueToString) {
+  // 1639426440000 ms = 2021-12-13 20:14:00.000 UTC.
+  auto packed = pack(1639426440000, tz::getTimeZoneID("America/Los_Angeles"));
+  ASSERT_EQ(
+      TIMESTAMP_WITH_TIME_ZONE()->valueToString(packed),
+      "2021-12-13 12:14:00.000 America/Los_Angeles");
+
+  packed = pack(1639426440000, tz::getTimeZoneID("+03:00"));
+  ASSERT_EQ(
+      TIMESTAMP_WITH_TIME_ZONE()->valueToString(packed),
+      "2021-12-13 23:14:00.000 +03:00");
+
+  packed = pack(0, tz::getTimeZoneID("UTC"));
+  ASSERT_EQ(
+      TIMESTAMP_WITH_TIME_ZONE()->valueToString(packed),
+      "1970-01-01 00:00:00.000 UTC");
+}
+
 } // namespace facebook::velox::test
diff --git a/velox/functions/prestosql/types/tests/UuidTypeTest.cpp b/velox/functions/prestosql/types/tests/UuidTypeTest.cpp
index 1bfeb3c32c3..75ec72533b9 100644
--- a/velox/functions/prestosql/types/tests/UuidTypeTest.cpp
+++ b/velox/functions/prestosql/types/tests/UuidTypeTest.cpp
@@ -14,8 +14,12 @@
  * limitations under the License.
  */
 #include "velox/functions/prestosql/types/UuidType.h"
+#include <boost/lexical_cast.hpp>
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_io.hpp>
 #include "velox/functions/prestosql/types/UuidRegistration.h"
 #include "velox/functions/prestosql/types/tests/TypeTestBase.h"
+#include "velox/type/DecimalUtil.h"
 
 namespace facebook::velox::test {
 
@@ -39,4 +43,29 @@ TEST_F(UuidTypeTest, basic) {
 TEST_F(UuidTypeTest, serde) {
   testTypeSerde(UUID());
 }
+
+TEST_F(UuidTypeTest, valueToString) {
+  // Round-trip: parse UUID string via the same path as CAST(varchar AS uuid),
+  // then format back via valueToString.
+  auto roundTrip = [](std::string_view uuidStr) {
+    auto uuid = boost::lexical_cast<boost::uuids::uuid>(uuidStr);
+    int128_t value;
+    memcpy(&value, &uuid, 16);
+    // boost::uuid is big-endian, convert to Velox's little-endian storage.
+    value = DecimalUtil::bigEndian(value);
+    char buffer[UuidType::kStringSize];
+    return std::string(UUID()->valueToString(value, buffer));
+  };
+
+  EXPECT_EQ(
+      roundTrip("12151fd2-7586-11e9-8f9e-2a86e4085a59"),
+      "12151fd2-7586-11e9-8f9e-2a86e4085a59");
+  EXPECT_EQ(
+      roundTrip("00000000-0000-0000-0000-000000000000"),
+      "00000000-0000-0000-0000-000000000000");
+  EXPECT_EQ(
+      roundTrip("ffffffff-ffff-ffff-ffff-ffffffffffff"),
+      "ffffffff-ffff-ffff-ffff-ffffffffffff");
+}
+
 } // namespace facebook::velox::test
diff --git a/velox/functions/prestosql/types/tests/VarcharEnumTypeTest.cpp b/velox/functions/prestosql/types/tests/VarcharEnumTypeTest.cpp
index 4ca7e25b34f..a8cbddf3299 100644
--- a/velox/functions/prestosql/types/tests/VarcharEnumTypeTest.cpp
+++ b/velox/functions/prestosql/types/tests/VarcharEnumTypeTest.cpp
@@ -79,5 +79,18 @@ TEST_F(VarcharEnumTypeTest, basic) {
 TEST_F(VarcharEnumTypeTest, serde) {
   testTypeSerde(colorEnum_);
 }
+
+TEST_F(VarcharEnumTypeTest, valueAt) {
+  EXPECT_EQ(colorEnum_->valueAt("RED"), "red");
+  EXPECT_EQ(colorEnum_->valueAt("BLUE"), "blue");
+  EXPECT_EQ(colorEnum_->valueAt("unknown"), std::nullopt);
+}
+
+TEST_F(VarcharEnumTypeTest, containsKey) {
+  EXPECT_TRUE(colorEnum_->containsKey("RED"));
+  EXPECT_FALSE(colorEnum_->containsKey("red"));
+  EXPECT_FALSE(colorEnum_->containsKey("unknown"));
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/window/CMakeLists.txt b/velox/functions/prestosql/window/CMakeLists.txt
index 17748049108..7bade45e2ae 100644
--- a/velox/functions/prestosql/window/CMakeLists.txt
+++ b/velox/functions/prestosql/window/CMakeLists.txt
@@ -21,6 +21,8 @@ velox_add_library(
   FirstLastValue.cpp
   LeadLag.cpp
   WindowFunctionsRegistration.cpp
+  HEADERS
+  WindowFunctionsRegistration.h
 )
 
 velox_link_libraries(velox_window velox_buffer velox_exec velox_functions_window Folly::folly)
diff --git a/velox/functions/prestosql/window/FirstLastValue.cpp b/velox/functions/prestosql/window/FirstLastValue.cpp
index 4fb12c153ce..6043d3392e9 100644
--- a/velox/functions/prestosql/window/FirstLastValue.cpp
+++ b/velox/functions/prestosql/window/FirstLastValue.cpp
@@ -37,8 +37,11 @@ class FirstLastValueFunction : public exec::WindowFunction {
       bool ignoreNulls,
       velox::memory::MemoryPool* pool)
       : WindowFunction(resultType, pool, nullptr), ignoreNulls_(ignoreNulls) {
-    VELOX_CHECK_NULL(args[0].constantValue);
-    valueIndex_ = args[0].index.value();
+    if (args[0].constantValue) {
+      constantValue_ = args[0].constantValue;
+    } else {
+      valueIndex_ = args[0].index.value();
+    }
 
     nulls_ = allocateNulls(0, pool_);
   }
@@ -56,6 +59,24 @@ class FirstLastValueFunction : public exec::WindowFunction {
       int32_t resultOffset,
       const VectorPtr& result) override {
     auto numRows = frameStarts->size() / sizeof(vector_size_t);
+
+    if (constantValue_) {
+      // Rows with empty frames should return null.
+      if (validRows.isAllSelected()) {
+        result->copy(constantValue_.get(), resultOffset, 0, numRows);
+      } else {
+        // Set constant for valid rows, null for invalid rows.
+        for (auto i = 0; i < numRows; ++i) {
+          if (validRows.isValid(i)) {
+            result->copy(constantValue_.get(), resultOffset + i, 0, 1);
+          } else {
+            result->setNull(resultOffset + i, true);
+          }
+        }
+      }
+      return;
+    }
+
     rowNumbers_.resize(numRows);
     if (validRows.hasSelections()) {
       if (ignoreNulls_) {
@@ -140,6 +161,9 @@ class FirstLastValueFunction : public exec::WindowFunction {
 
   const bool ignoreNulls_;
 
+  // Non-null when the argument is a constant expression.
+  VectorPtr constantValue_;
+
   // Index of the first_value / last_value argument column in the input row
   // vector. This is used to retrieve column values from the partition data.
   column_index_t valueIndex_;
diff --git a/velox/functions/prestosql/window/LeadLag.cpp b/velox/functions/prestosql/window/LeadLag.cpp
index 9d65351c76d..f02f59e6f49 100644
--- a/velox/functions/prestosql/window/LeadLag.cpp
+++ b/velox/functions/prestosql/window/LeadLag.cpp
@@ -30,7 +30,11 @@ class LeadLagFunction : public exec::WindowFunction {
       bool ignoreNulls,
       velox::memory::MemoryPool* pool)
       : WindowFunction(resultType, pool, nullptr), ignoreNulls_(ignoreNulls) {
-    valueIndex_ = args[0].index.value();
+    if (args[0].constantValue) {
+      constantValue_ = args[0].constantValue;
+    } else {
+      valueIndex_ = args[0].index.value();
+    }
 
     initializeOffset(args);
     initializeDefaultValue(args);
@@ -43,7 +47,9 @@ class LeadLagFunction : public exec::WindowFunction {
     partitionOffset_ = 0;
     ignoreNullsForPartition_ = false;
 
-    if (ignoreNulls_) {
+    // When the value is a constant, there are no per-row nulls to extract
+    // from the partition.
+    if (ignoreNulls_ && !constantValue_) {
       auto partitionSize = partition_->numRows();
       AlignedBuffer::reallocate<bool>(&nulls_, partitionSize);
 
@@ -67,6 +73,19 @@ class LeadLagFunction : public exec::WindowFunction {
 
     rowNumbers_.resize(numRows);
 
+    // When the value is a constant null and IGNORE NULLS is set, every row
+    // is null so lead/lag can never find a non-null value. Return the default
+    // value for all rows (or null if no default).
+    if (constantValue_ && ignoreNulls_ && constantValue_->isNullAt(0)) {
+      std::fill(rowNumbers_.begin(), rowNumbers_.end(), kDefaultValueRow);
+      for (auto i = 0; i < numRows; ++i) {
+        result->setNull(resultOffset + i, true);
+      }
+      setDefaultValue(result, resultOffset);
+      partitionOffset_ += numRows;
+      return;
+    }
+
     if (constantOffset_.has_value() || isConstantOffsetNull_) {
       setRowNumbersForConstantOffset();
     } else {
@@ -77,9 +96,25 @@ class LeadLagFunction : public exec::WindowFunction {
       }
     }
 
-    auto rowNumbersRange = folly::Range(rowNumbers_.data(), numRows);
-    partition_->extractColumn(
-        valueIndex_, rowNumbersRange, resultOffset, result);
+    if (constantValue_) {
+      // For constant value, write the constant for valid rows, null for
+      // kNullRow, and leave kDefaultValueRow for setDefaultValue to handle.
+      for (auto i = 0; i < numRows; ++i) {
+        if (rowNumbers_[i] == kNullRow) {
+          result->setNull(resultOffset + i, true);
+        } else if (rowNumbers_[i] == kDefaultValueRow) {
+          // Set null here; setDefaultValue will overwrite with actual default
+          // if one is specified.
+          result->setNull(resultOffset + i, true);
+        } else {
+          result->copy(constantValue_.get(), resultOffset + i, 0, 1);
+        }
+      }
+    } else {
+      auto rowNumbersRange = folly::Range(rowNumbers_.data(), numRows);
+      partition_->extractColumn(
+          valueIndex_, rowNumbersRange, resultOffset, result);
+    }
 
     setDefaultValue(result, resultOffset);
 
@@ -287,6 +322,9 @@ class LeadLagFunction : public exec::WindowFunction {
   // be skipped for them. Used for tracking this at the partition level.
   bool ignoreNullsForPartition_;
 
+  // Non-null when the value argument is a constant expression.
+  VectorPtr constantValue_;
+
   // Index of the 'value' argument.
   column_index_t valueIndex_;
 
diff --git a/velox/functions/prestosql/window/tests/LeadLagTest.cpp b/velox/functions/prestosql/window/tests/LeadLagTest.cpp
index d733f20d3c5..6b79f7d9744 100644
--- a/velox/functions/prestosql/window/tests/LeadLagTest.cpp
+++ b/velox/functions/prestosql/window/tests/LeadLagTest.cpp
@@ -433,6 +433,55 @@ TEST_P(LeadLagTest, emptyFrames) {
   }
 }
 
+// Verify that lead and lag handle constant value arguments. This can happen
+// when the optimizer constant-folds a column that is always the same value
+// within the window partition context.
+TEST_F(LeadLagTest, constantArgument) {
+  auto input = makeRowVector({
+      makeFlatVector<int32_t>({1, 1, 1, 2, 2}),
+      makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+  });
+
+  auto assertResults = [&](const std::string& function,
+                           const VectorPtr& expectedWindow) {
+    auto expected = makeRowVector({
+        input->childAt(0),
+        input->childAt(1),
+        expectedWindow,
+    });
+    WindowTestBase::testWindowFunction(
+        {input},
+        function,
+        "partition by c0 order by c1",
+        "rows between unbounded preceding and current row",
+        expected);
+  };
+
+  // Constant value: returns the constant, null when offset goes out of
+  // partition.
+  assertResults(
+      "lag('foo', 1)",
+      makeNullableFlatVector<StringView>(
+          {std::nullopt, "foo", "foo", std::nullopt, "foo"}));
+  assertResults(
+      "lead('foo', 1)",
+      makeNullableFlatVector<StringView>(
+          {"foo", "foo", std::nullopt, "foo", std::nullopt}));
+
+  // Null constant value returns null for all rows.
+  auto allNulls = makeAllNullFlatVector<StringView>(5);
+
+  assertResults("lag(null::varchar, 1)", allNulls);
+  assertResults("lead(null::varchar, 1)", allNulls);
+
+  // Constant null value with IGNORE NULLS and a default value. Every row is
+  // null so lead/lag can never find a non-null value. All rows should get the
+  // default value.
+  assertResults(
+      "lag(null::varchar, 1, 'default' IGNORE NULLS)",
+      makeConstant<StringView>("default", 5));
+}
+
 VELOX_INSTANTIATE_TEST_SUITE_P(LagTest, LeadLagTest, ::testing::Values("lag"));
 
 VELOX_INSTANTIATE_TEST_SUITE_P(
diff --git a/velox/functions/prestosql/window/tests/NthValueTest.cpp b/velox/functions/prestosql/window/tests/NthValueTest.cpp
index 29512668c64..e7ae24fc02c 100644
--- a/velox/functions/prestosql/window/tests/NthValueTest.cpp
+++ b/velox/functions/prestosql/window/tests/NthValueTest.cpp
@@ -346,6 +346,57 @@ TEST_F(NthValueTest, ignoreNulls) {
   }
 }
 
+// Verify that first_value, last_value, and nth_value handle constant value
+// arguments. This can happen when the optimizer constant-folds a column that
+// is always the same value within the window partition context.
+TEST_F(NthValueTest, constantArgument) {
+  auto input = makeRowVector({
+      makeFlatVector<int32_t>({1, 1, 1, 2, 2}),
+      makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+  });
+
+  // Use a frame clause that produces empty frames for the first row in each
+  // partition: "rows between 2 preceding and 1 preceding" is empty when
+  // there are fewer than 2 preceding rows.
+  auto assertResults = [&](const std::string& function,
+                           const VectorPtr& expectedWindow) {
+    auto expected = makeRowVector({
+        input->childAt(0),
+        input->childAt(1),
+        expectedWindow,
+    });
+    WindowTestBase::testWindowFunction(
+        {input},
+        function,
+        "partition by c0 order by c1",
+        "rows between 2 preceding and 1 preceding",
+        expected);
+  };
+
+  // Constant for valid frames, null for empty.
+  auto expected = makeNullableFlatVector<StringView>(
+      {std::nullopt, "foo", "foo", std::nullopt, "foo"});
+
+  assertResults("first_value('foo')", expected);
+  assertResults("last_value('foo')", expected);
+  assertResults("nth_value('foo', 1)", expected);
+
+  // Null constant value returns null for all rows.
+  auto allNulls = makeAllNullFlatVector<StringView>(5);
+
+  assertResults("first_value(null::varchar)", allNulls);
+  assertResults("last_value(null::varchar)", allNulls);
+  assertResults("nth_value(null::varchar, 1)", allNulls);
+
+  // nth_value with offset beyond frame returns null.
+  WindowTestBase::testWindowFunction(
+      {input},
+      "nth_value('foo', 100)",
+      "partition by c0 order by c1",
+      "rows between unbounded preceding and current row",
+      makeRowVector({input->childAt(0), input->childAt(1), allNulls}));
+}
+
 TEST_F(NthValueTest, frameStartsFromFollowing) {
   auto input = makeRowVector({
       makeNullableFlatVector<int64_t>({1, std::nullopt, 2}),
diff --git a/velox/functions/remote/benchmarks/LocalRemoteComparisonBenchmark.cpp b/velox/functions/remote/benchmarks/LocalRemoteComparisonBenchmark.cpp
index 40354c2a412..2914768e626 100644
--- a/velox/functions/remote/benchmarks/LocalRemoteComparisonBenchmark.cpp
+++ b/velox/functions/remote/benchmarks/LocalRemoteComparisonBenchmark.cpp
@@ -36,7 +36,7 @@ int main(int argc, char** argv) {
   memory::MemoryManager::initialize(memory::MemoryManager::Options{});
 
   auto param = startLocalThriftServiceAndGetParams();
-  RemoteVectorFunctionMetadata metadata;
+  RemoteThriftVectorFunctionMetadata metadata;
   metadata.location = param.serverAddress;
 
   // Register the remote adapter for PlusFunction
diff --git a/velox/functions/remote/client/CMakeLists.txt b/velox/functions/remote/client/CMakeLists.txt
index a41781bac28..c3e03f4e4d6 100644
--- a/velox/functions/remote/client/CMakeLists.txt
+++ b/velox/functions/remote/client/CMakeLists.txt
@@ -12,13 +12,20 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_functions_remote_thrift_client ThriftClient.cpp)
+velox_add_library(velox_functions_remote_thrift_client ThriftClient.cpp HEADERS ThriftClient.h)
 velox_link_libraries(
   velox_functions_remote_thrift_client
   PUBLIC remote_function_thrift FBThrift::thriftcpp2
 )
 
-velox_add_library(velox_functions_remote Remote.cpp)
+velox_add_library(
+  velox_functions_remote
+  Remote.cpp
+  RemoteVectorFunction.cpp
+  HEADERS
+  Remote.h
+  RemoteVectorFunction.h
+)
 velox_link_libraries(
   velox_functions_remote
   PUBLIC
diff --git a/velox/functions/remote/client/Remote.cpp b/velox/functions/remote/client/Remote.cpp
index 429782e779b..4bde370c557 100644
--- a/velox/functions/remote/client/Remote.cpp
+++ b/velox/functions/remote/client/Remote.cpp
@@ -17,149 +17,56 @@
 #include "velox/functions/remote/client/Remote.h"
 
 #include <folly/io/async/EventBase.h>
-#include "velox/expression/Expr.h"
-#include "velox/expression/VectorFunction.h"
+#include "velox/functions/remote/client/RemoteVectorFunction.h"
 #include "velox/functions/remote/client/ThriftClient.h"
 #include "velox/functions/remote/if/GetSerde.h"
-#include "velox/functions/remote/if/gen-cpp2/RemoteFunctionServiceAsyncClient.h"
-#include "velox/type/fbhive/HiveTypeSerializer.h"
-#include "velox/vector/VectorStream.h"
 
 namespace facebook::velox::functions {
 namespace {
 
-std::string serializeType(const TypePtr& type) {
-  // Use hive type serializer.
-  return type::fbhive::HiveTypeSerializer::serialize(type);
-}
-
-class RemoteFunction : public exec::VectorFunction {
+class RemoteThriftFunction : public RemoteVectorFunction {
  public:
-  RemoteFunction(
+  RemoteThriftFunction(
       const std::string& functionName,
       const std::vector<exec::VectorFunctionArg>& inputArgs,
-      const RemoteVectorFunctionMetadata& metadata)
-      : functionName_(functionName),
+      const RemoteThriftVectorFunctionMetadata& metadata)
+      : RemoteVectorFunction(functionName, inputArgs, metadata),
         location_(metadata.location),
-        thriftClient_(getThriftClient(location_, &eventBase_)),
-        serdeFormat_(metadata.serdeFormat),
-        serde_(getSerde(serdeFormat_)) {
-    std::vector<TypePtr> types;
-    types.reserve(inputArgs.size());
-    serializedInputTypes_.reserve(inputArgs.size());
-
-    for (const auto& arg : inputArgs) {
-      types.emplace_back(arg.type);
-      serializedInputTypes_.emplace_back(serializeType(arg.type));
-    }
-    remoteInputType_ = ROW(std::move(types));
+        client_(createClient(metadata)) {}
+
+  folly::coro::Task<std::unique_ptr<remote::RemoteFunctionResponse>>
+  invokeRemoteFunction(
+      const remote::RemoteFunctionRequest& request) const override {
+    auto remoteResponse = std::make_unique<remote::RemoteFunctionResponse>();
+    client_->invokeFunction(*remoteResponse, request);
+    co_return remoteResponse;
   }
 
-  void apply(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& outputType,
-      exec::EvalCtx& context,
-      VectorPtr& result) const override {
-    try {
-      applyRemote(rows, args, outputType, context, result);
-    } catch (const VeloxRuntimeError&) {
-      throw;
-    } catch (const std::exception&) {
-      context.setErrors(rows, std::current_exception());
-    }
+  std::string remoteLocationToString() const override {
+    return location_.describe();
   }
 
  private:
-  void applyRemote(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& outputType,
-      exec::EvalCtx& context,
-      VectorPtr& result) const {
-    // Create type and row vector for serialization.
-    auto remoteRowVector = std::make_shared<RowVector>(
-        context.pool(),
-        remoteInputType_,
-        BufferPtr{},
-        rows.end(),
-        std::move(args));
-
-    // Send to remote server.
-    remote::RemoteFunctionResponse remoteResponse;
-    remote::RemoteFunctionRequest request;
-    request.throwOnError_ref() = context.throwOnError();
-
-    auto functionHandle = request.remoteFunctionHandle_ref();
-    functionHandle->name_ref() = functionName_;
-    functionHandle->returnType_ref() = serializeType(outputType);
-    functionHandle->argumentTypes_ref() = serializedInputTypes_;
-
-    auto requestInputs = request.inputs_ref();
-    requestInputs->rowCount_ref() = remoteRowVector->size();
-    requestInputs->pageFormat_ref() = serdeFormat_;
-
-    // TODO: serialize only active rows.
-    requestInputs->payload_ref() = rowVectorToIOBuf(
-        remoteRowVector, rows.end(), *context.pool(), serde_.get());
-
-    try {
-      thriftClient_->sync_invokeFunction(remoteResponse, request);
-    } catch (const std::exception& e) {
-      VELOX_FAIL(
-          "Error while executing remote function '{}' at '{}': {}",
-          functionName_,
-          location_.describe(),
-          e.what());
-    }
-
-    auto outputRowVector = IOBufToRowVector(
-        remoteResponse.result().value().payload().value(),
-        ROW({outputType}),
-        *context.pool(),
-        serde_.get());
-    result = outputRowVector->childAt(0);
-
-    if (auto errorPayload = remoteResponse.result().value().errorPayload()) {
-      auto errorsRowVector = IOBufToRowVector(
-          *errorPayload, ROW({VARCHAR()}), *context.pool(), serde_.get());
-      auto errorsVector =
-          errorsRowVector->childAt(0)->asFlatVector<StringView>();
-      VELOX_CHECK(errorsVector, "Should be convertible to flat vector");
-
-      SelectivityVector selectedRows(errorsRowVector->size());
-      selectedRows.applyToSelected([&](vector_size_t i) {
-        if (errorsVector->isNullAt(i)) {
-          return;
-        }
-        try {
-          throw std::runtime_error(errorsVector->valueAt(i));
-        } catch (const std::exception&) {
-          context.setError(i, std::current_exception());
-        }
-      });
+  std::unique_ptr<IRemoteFunctionClient> createClient(
+      const RemoteThriftVectorFunctionMetadata& metadata) {
+    if (metadata.clientFactory) {
+      return metadata.clientFactory(metadata.location, &eventBase_);
     }
+    return getDefaultRemoteFunctionClient(metadata.location, &eventBase_);
   }
 
-  const std::string functionName_;
   folly::SocketAddress location_;
-
   folly::EventBase eventBase_;
-  std::unique_ptr<RemoteFunctionClient> thriftClient_;
-  remote::PageFormat serdeFormat_;
-  std::unique_ptr<VectorSerde> serde_;
 
-  // Structures we construct once to cache:
-  RowTypePtr remoteInputType_;
-  std::vector<std::string> serializedInputTypes_;
+  std::unique_ptr<IRemoteFunctionClient> client_;
 };
 
 std::shared_ptr<exec::VectorFunction> createRemoteFunction(
     const std::string& name,
     const std::vector<exec::VectorFunctionArg>& inputArgs,
     const core::QueryConfig& /*config*/,
-    const RemoteVectorFunctionMetadata& metadata) {
-  return std::make_unique<RemoteFunction>(name, inputArgs, metadata);
+    const RemoteThriftVectorFunctionMetadata& metadata) {
+  return std::make_unique<RemoteThriftFunction>(name, inputArgs, metadata);
 }
 
 } // namespace
@@ -167,11 +74,11 @@ std::shared_ptr<exec::VectorFunction> createRemoteFunction(
 void registerRemoteFunction(
     const std::string& name,
     std::vector<exec::FunctionSignaturePtr> signatures,
-    const RemoteVectorFunctionMetadata& metadata,
+    const RemoteThriftVectorFunctionMetadata& metadata,
     bool overwrite) {
   exec::registerStatefulVectorFunction(
       name,
-      signatures,
+      std::move(signatures),
       std::bind(
           createRemoteFunction,
           std::placeholders::_1,
diff --git a/velox/functions/remote/client/Remote.h b/velox/functions/remote/client/Remote.h
index a6a1e773dc8..f7b0e49216a 100644
--- a/velox/functions/remote/client/Remote.h
+++ b/velox/functions/remote/client/Remote.h
@@ -17,24 +17,27 @@
 #pragma once
 
 #include <folly/SocketAddress.h>
-#include "velox/expression/VectorFunction.h"
-#include "velox/functions/remote/if/gen-cpp2/RemoteFunction_types.h"
+#include "velox/functions/remote/client/RemoteVectorFunction.h"
+#include "velox/functions/remote/client/ThriftClient.h"
 
 namespace facebook::velox::functions {
 
-struct RemoteVectorFunctionMetadata : public exec::VectorFunctionMetadata {
-  /// Network address of the servr to communicate with. Note that this can hold
-  /// a network location (ip/port pair) or a unix domain socket path (see
-  /// SocketAddress::makeFromPath()).
+struct RemoteThriftVectorFunctionMetadata
+    : public RemoteVectorFunctionMetadata {
+  /// Network address of the server to communicate with using a thrift client.
+  /// Note that this can hold a network location (ip/port pair) or a unix domain
+  /// socket path (see SocketAddress::makeFromPath()).
   folly::SocketAddress location;
 
-  /// The serialization format to be used
-  remote::PageFormat serdeFormat{remote::PageFormat::PRESTO_PAGE};
+  /// Optional factory for creating remote function clients. If not set, the
+  /// default thrift client factory is used. This enables dependency injection
+  /// for testing with mock clients.
+  RemoteFunctionClientFactory clientFactory;
 };
 
 /// Registers a new remote function. It will use the meatadata defined in
-/// `RemoteVectorFunctionMetadata` to control the serialization format and
-/// remote server address.
+/// `RemoteThriftVectorFunctionMetadata` to control the serialization format,
+/// remote server address, and communicate with it using a thrift client.
 //
 /// Remote functions are registered as regular statufull functions (using the
 /// same internal catalog), and hence conflict if there already exists a
@@ -43,7 +46,7 @@ struct RemoteVectorFunctionMetadata : public exec::VectorFunctionMetadata {
 void registerRemoteFunction(
     const std::string& name,
     std::vector<exec::FunctionSignaturePtr> signatures,
-    const RemoteVectorFunctionMetadata& metadata = {},
+    const RemoteThriftVectorFunctionMetadata& metadata = {},
     bool overwrite = true);
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/remote/client/RemoteVectorFunction.cpp b/velox/functions/remote/client/RemoteVectorFunction.cpp
new file mode 100644
index 00000000000..57820b3e70d
--- /dev/null
+++ b/velox/functions/remote/client/RemoteVectorFunction.cpp
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/remote/client/RemoteVectorFunction.h"
+
+#include <folly/coro/BlockingWait.h>
+
+#include "velox/expression/VectorFunction.h"
+#include "velox/functions/remote/if/GetSerde.h"
+#include "velox/type/fbhive/HiveTypeSerializer.h"
+
+namespace facebook::velox::functions {
+namespace {
+
+std::string serializeType(const TypePtr& type) {
+  // Use hive type serializer.
+  return type::fbhive::HiveTypeSerializer::serialize(type);
+}
+
+} // namespace
+
+RemoteVectorFunction::RemoteVectorFunction(
+    const std::string& functionName,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const RemoteVectorFunctionMetadata& metadata)
+    : functionName_(functionName),
+      serdeFormat_(metadata.serdeFormat),
+      serde_(getSerde(serdeFormat_)),
+      serdeOptions_(
+          metadata.preserveEncoding
+              ? getSerdeOptions(serdeFormat_, metadata.preserveEncoding)
+              : nullptr),
+      preserveEncoding_(metadata.preserveEncoding) {
+  std::vector<TypePtr> types;
+  types.reserve(inputArgs.size());
+  serializedInputTypes_.reserve(inputArgs.size());
+
+  for (const auto& arg : inputArgs) {
+    types.emplace_back(arg.type);
+    serializedInputTypes_.emplace_back(serializeType(arg.type));
+  }
+  remoteInputType_ = ROW(std::move(types));
+}
+
+void RemoteVectorFunction::apply(
+    const SelectivityVector& rows,
+    std::vector<VectorPtr>& args,
+    const TypePtr& outputType,
+    exec::EvalCtx& context,
+    VectorPtr& result) const {
+  try {
+    applyRemote(rows, args, outputType, context, result);
+  } catch (const VeloxRuntimeError&) {
+    throw;
+  } catch (const std::exception&) {
+    context.setErrors(rows, std::current_exception());
+  }
+}
+
+void RemoteVectorFunction::applyRemote(
+    const SelectivityVector& rows,
+    std::vector<VectorPtr>& args,
+    const TypePtr& outputType,
+    exec::EvalCtx& context,
+    VectorPtr& result) const {
+  // Create type and row vector for serialization.
+  auto remoteRowVector = std::make_shared<RowVector>(
+      context.pool(),
+      remoteInputType_,
+      BufferPtr{},
+      rows.end(),
+      std::move(args));
+
+  // Create the thrift payload.
+  remote::RemoteFunctionRequest request;
+  request.throwOnError() = context.throwOnError();
+
+  auto functionHandle = request.remoteFunctionHandle();
+  functionHandle->name() = functionName_;
+  functionHandle->returnType() = serializeType(outputType);
+  functionHandle->argumentTypes() = serializedInputTypes_;
+
+  auto requestInputs = request.inputs();
+  requestInputs->rowCount() = remoteRowVector->size();
+  requestInputs->pageFormat() = serdeFormat_;
+
+  // TODO: serialize only active rows.
+  if (preserveEncoding_) {
+    requestInputs->payload_ref() = rowVectorToIOBufBatch(
+        remoteRowVector,
+        rows.end(),
+        *context.pool(),
+        serde_.get(),
+        serdeOptions_.get());
+  } else {
+    requestInputs->payload_ref() = rowVectorToIOBuf(
+        remoteRowVector, rows.end(), *context.pool(), serde_.get());
+  }
+
+  std::unique_ptr<remote::RemoteFunctionResponse> remoteResponse;
+
+  // Invoke function that communicates with the remote host.
+  try {
+    remoteResponse = folly::coro::blockingWait(invokeRemoteFunction(request));
+  } catch (const std::exception& e) {
+    VELOX_FAIL(
+        "Error while executing remote function '{}' at '{}': {}",
+        functionName_,
+        remoteLocationToString(),
+        e.what());
+  }
+
+  const auto& remoteResult = remoteResponse->result().value();
+  auto outputRowVector = IOBufToRowVector(
+      remoteResult.payload().value(),
+      ROW({outputType}),
+      *context.pool(),
+      serde_.get());
+  result = outputRowVector->childAt(0);
+
+  if (auto errorPayload = remoteResult.errorPayload()) {
+    auto errorsRowVector = IOBufToRowVector(
+        *errorPayload, ROW({VARCHAR()}), *context.pool(), serde_.get());
+    auto errorsVector = errorsRowVector->childAt(0)->asFlatVector<StringView>();
+    VELOX_CHECK(
+        errorsVector,
+        "Remote function error payload should be convertible to flat vector.");
+
+    SelectivityVector selectedRows(errorsRowVector->size());
+    selectedRows.applyToSelected([&](vector_size_t i) {
+      if (errorsVector->isNullAt(i)) {
+        return;
+      }
+      try {
+        VELOX_USER_FAIL("{}", errorsVector->valueAt(i));
+      } catch (const std::exception&) {
+        context.setError(i, std::current_exception());
+      }
+    });
+  }
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/remote/client/RemoteVectorFunction.h b/velox/functions/remote/client/RemoteVectorFunction.h
new file mode 100644
index 00000000000..1b2d2d5dbab
--- /dev/null
+++ b/velox/functions/remote/client/RemoteVectorFunction.h
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <folly/coro/Task.h>
+
+#include "velox/expression/VectorFunction.h"
+#include "velox/functions/remote/if/gen-cpp2/RemoteFunction_types.h"
+#include "velox/vector/VectorStream.h"
+
+namespace facebook::velox::functions {
+
+struct RemoteVectorFunctionMetadata : public exec::VectorFunctionMetadata {
+  /// The serialization format to be used to send batches of data to the remote
+  /// process.
+  remote::PageFormat serdeFormat{remote::PageFormat::PRESTO_PAGE};
+
+  /// Whether to preserve the input vector encoding in the request sent to
+  /// remote service.
+  bool preserveEncoding{false};
+};
+
+/// Main vector function logic. Needs to be extended with the transport-specific
+/// logic.
+class RemoteVectorFunction : public exec::VectorFunction {
+ public:
+  RemoteVectorFunction(
+      const std::string& functionName,
+      const std::vector<exec::VectorFunctionArg>& inputArgs,
+      const RemoteVectorFunctionMetadata& metadata);
+
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& outputType,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override;
+
+ protected:
+  // The actual function that communicates with the remote host.
+  // Returns a coroutine to allow the worker thread to yield while
+  // waiting for the remote response
+  virtual folly::coro::Task<std::unique_ptr<remote::RemoteFunctionResponse>>
+  invokeRemoteFunction(const remote::RemoteFunctionRequest& request) const = 0;
+
+  // A string representation of the remote host being connected to. Useful for
+  // exception messages.
+  virtual std::string remoteLocationToString() const = 0;
+
+ private:
+  void applyRemote(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& outputType,
+      exec::EvalCtx& context,
+      VectorPtr& result) const;
+
+  const std::string functionName_;
+
+  remote::PageFormat serdeFormat_;
+  std::unique_ptr<VectorSerde> serde_;
+  std::unique_ptr<VectorSerde::Options> serdeOptions_;
+  bool preserveEncoding_;
+
+  // Structures we construct once to cache:
+  RowTypePtr remoteInputType_;
+  std::vector<std::string> serializedInputTypes_;
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/remote/client/ThriftClient.cpp b/velox/functions/remote/client/ThriftClient.cpp
index 361d01c9816..351b7fd67c8 100644
--- a/velox/functions/remote/client/ThriftClient.cpp
+++ b/velox/functions/remote/client/ThriftClient.cpp
@@ -20,7 +20,7 @@
 namespace facebook::velox::functions {
 
 std::unique_ptr<RemoteFunctionClient> getThriftClient(
-    folly::SocketAddress location,
+    const folly::SocketAddress& location,
     folly::EventBase* eventBase) {
   auto sock = folly::AsyncSocket::newSocket(eventBase, location);
   return std::make_unique<RemoteFunctionClient>(
diff --git a/velox/functions/remote/client/ThriftClient.h b/velox/functions/remote/client/ThriftClient.h
index d65db015897..b2c8adec14b 100644
--- a/velox/functions/remote/client/ThriftClient.h
+++ b/velox/functions/remote/client/ThriftClient.h
@@ -24,8 +24,51 @@ namespace facebook::velox::functions {
 using RemoteFunctionClient =
     apache::thrift::Client<remote::RemoteFunctionService>;
 
+/// Abstract interface for the remote function client, enabling dependency
+/// injection and mocking in tests.
+class IRemoteFunctionClient {
+ public:
+  virtual ~IRemoteFunctionClient() = default;
+
+  /// Invokes the remote function synchronously.
+  virtual void invokeFunction(
+      remote::RemoteFunctionResponse& response,
+      const remote::RemoteFunctionRequest& request) = 0;
+};
+
+/// Default implementation that wraps the actual thrift client.
+class ThriftRemoteFunctionClient : public IRemoteFunctionClient {
+ public:
+  explicit ThriftRemoteFunctionClient(
+      std::unique_ptr<RemoteFunctionClient> client)
+      : client_(std::move(client)) {}
+
+  void invokeFunction(
+      remote::RemoteFunctionResponse& response,
+      const remote::RemoteFunctionRequest& request) override {
+    client_->sync_invokeFunction(response, request);
+  }
+
+ private:
+  std::unique_ptr<RemoteFunctionClient> client_;
+};
+
+/// Factory function type for creating remote function clients.
+/// Parameters: location (socket address), eventBase (for async operations)
+/// Returns: A unique_ptr to an IRemoteFunctionClient implementation.
+using RemoteFunctionClientFactory = std::function<std::unique_ptr<
+    IRemoteFunctionClient>(folly::SocketAddress, folly::EventBase*)>;
+
 std::unique_ptr<RemoteFunctionClient> getThriftClient(
-    folly::SocketAddress location,
+    const folly::SocketAddress& location,
     folly::EventBase* eventBase);
 
+/// Default factory that creates ThriftRemoteFunctionClient instances.
+inline std::unique_ptr<IRemoteFunctionClient> getDefaultRemoteFunctionClient(
+    const folly::SocketAddress& location,
+    folly::EventBase* eventBase) {
+  return std::make_unique<ThriftRemoteFunctionClient>(
+      getThriftClient(location, eventBase));
+}
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/remote/client/tests/RemoteFunctionTest.cpp b/velox/functions/remote/client/tests/RemoteFunctionTest.cpp
index af82db0810d..4371f19c754 100644
--- a/velox/functions/remote/client/tests/RemoteFunctionTest.cpp
+++ b/velox/functions/remote/client/tests/RemoteFunctionTest.cpp
@@ -19,6 +19,7 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <stdlib.h>
+#include <numeric>
 
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/tests/GTestUtils.h"
@@ -29,10 +30,13 @@
 #include "velox/functions/prestosql/StringFunctions.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/functions/remote/client/Remote.h"
+#include "velox/functions/remote/client/ThriftClient.h"
+#include "velox/functions/remote/if/GetSerde.h"
 #include "velox/functions/remote/if/gen-cpp2/RemoteFunctionService.h"
 #include "velox/functions/remote/server/RemoteFunctionService.h"
 #include "velox/functions/remote/utils/RemoteFunctionServiceProvider.h"
 #include "velox/serializers/PrestoSerializer.h"
+#include "velox/vector/VectorStream.h"
 
 using ::apache::thrift::ThriftServer;
 using ::facebook::velox::test::assertEqualVectors;
@@ -84,7 +88,7 @@ class RemoteFunctionTest
 
   // Registers a few remote functions to be used in this test.
   void registerRemoteFunctions(RemoteFunctionServiceParams params) {
-    RemoteVectorFunctionMetadata metadata;
+    RemoteThriftVectorFunctionMetadata metadata;
     metadata.serdeFormat = GetParam();
     metadata.location = params.serverAddress;
 
@@ -103,7 +107,7 @@ class RemoteFunctionTest
                                .build()};
     registerRemoteFunction("remote_fail", failSignatures, metadata);
 
-    RemoteVectorFunctionMetadata wrongMetadata = metadata;
+    RemoteThriftVectorFunctionMetadata wrongMetadata = metadata;
     wrongMetadata.location = folly::SocketAddress(); // empty address.
     registerRemoteFunction("remote_wrong_port", plusSignatures, wrongMetadata);
 
@@ -167,17 +171,28 @@ TEST_P(RemoteFunctionTest, string) {
 }
 
 TEST_P(RemoteFunctionTest, tryException) {
-  // remote_divide throws if denominator is 0.
+  // `remote_divide` throws if denominator is 0.
   auto numeratorVector = makeFlatVector<double>({0, 1, 4, 9, 16});
   auto denominatorVector = makeFlatVector<double>({0, 1, 2, 3, 4});
-  auto data = makeRowVector({numeratorVector, denominatorVector});
-  auto results =
-      evaluate<SimpleVector<double>>("TRY(remote_divide(c0, c1))", data);
+  auto inputData = makeRowVector({numeratorVector, denominatorVector});
 
-  ASSERT_EQ(results->size(), 5);
-  auto expected = makeFlatVector<double>({0 /* doesn't matter*/, 1, 2, 3, 4});
-  expected->setNull(0, true);
+  auto executeRemote = [&]() {
+    return evaluate<SimpleVector<double>>("remote_divide(c0, c1)", inputData);
+  };
+
+  // Ensure it throws and the right exception is propagated.
+  EXPECT_THROW(executeRemote(), VeloxRuntimeError);
+  try {
+    executeRemote();
+  } catch (const VeloxRuntimeError& e) {
+    EXPECT_THAT(e.message(), testing::HasSubstr("division by zero"));
+  }
 
+  // Execute wih a try() to ensure exceptions are collected but not thrown.
+  auto results =
+      evaluate<SimpleVector<double>>("TRY(remote_divide(c0, c1))", inputData);
+  auto expected = makeNullableFlatVector<double>({std::nullopt, 1, 2, 3, 4});
+  ASSERT_EQ(results->size(), 5);
   assertEqualVectors(expected, results);
 }
 
@@ -216,8 +231,9 @@ TEST_P(RemoteFunctionTest, tryErrorCode) {
 TEST_P(RemoteFunctionTest, opaque) {
   // TODO: Support opaque type serialization in SPARK_UNSAFE_ROW
   if (GetParam() == remote::PageFormat::SPARK_UNSAFE_ROW) {
-    GTEST_SKIP()
+    LOG(WARNING)
         << "opaque type serialization not supported in SPARK_UNSAFE_ROW";
+    return;
   }
   auto inputVector = makeFlatVector<std::shared_ptr<void>>(
       2,
@@ -251,6 +267,232 @@ TEST_P(RemoteFunctionTest, connectionError) {
   }
 }
 
+/// Mock implementation of IRemoteFunctionClient for testing without a real
+/// thrift server.
+class MockRemoteFunctionClient : public IRemoteFunctionClient {
+ public:
+  MOCK_METHOD(
+      void,
+      invokeFunction,
+      (remote::RemoteFunctionResponse&, const remote::RemoteFunctionRequest&),
+      (override));
+};
+
+/// Test fixture that uses mock clients instead of a real thrift server running
+/// in the same process.
+class MockRemoteFunctionTest : public functions::test::FunctionBaseTest {
+ public:
+  void SetUp() override {
+    mockClient_ =
+        std::make_shared<testing::NiceMock<MockRemoteFunctionClient>>();
+  }
+
+  void TearDown() override {
+    mockClient_.reset();
+  }
+
+  /// Registers a remote function with a mock client factory.
+  void registerMockRemoteFunction(
+      const std::string& name,
+      std::vector<exec::FunctionSignaturePtr> signatures) {
+    RemoteThriftVectorFunctionMetadata metadata;
+    metadata.serdeFormat = remote::PageFormat::PRESTO_PAGE;
+    // Location doesn't matter since we're using a mock client.
+    metadata.location = folly::SocketAddress("127.0.0.1", 12345);
+
+    // Capture mockClient_ by value (shared_ptr) so it stays alive.
+    auto mockClientPtr = mockClient_;
+    metadata.clientFactory =
+        [mockClientPtr](const folly::SocketAddress&, folly::EventBase*) {
+          // We need this level of indirection because clientFactory returns a
+          // unique_ptr so we wouldn't have a reference to the mock client.
+          class MockClientWrapper : public IRemoteFunctionClient {
+           public:
+            explicit MockClientWrapper(
+                std::shared_ptr<MockRemoteFunctionClient> mock)
+                : mock_(std::move(mock)) {}
+
+            void invokeFunction(
+                remote::RemoteFunctionResponse& response,
+                const remote::RemoteFunctionRequest& request) override {
+              mock_->invokeFunction(response, request);
+            }
+
+           private:
+            std::shared_ptr<MockRemoteFunctionClient> mock_;
+          };
+          return std::make_unique<MockClientWrapper>(mockClientPtr);
+        };
+
+    registerRemoteFunction(name, std::move(signatures), metadata);
+  }
+
+  /// Helper to set up a mock response with a serialized result vector.
+  void setMockResponse(
+      remote::RemoteFunctionResponse& response,
+      const RowVectorPtr& resultVector) {
+    auto serde = getSerde(remote::PageFormat::PRESTO_PAGE);
+    auto result = response.result();
+    result->rowCount() = resultVector->size();
+    result->pageFormat() = remote::PageFormat::PRESTO_PAGE;
+    result->payload() = rowVectorToIOBuf(resultVector, *pool(), serde.get());
+  }
+
+  /// Registers a mock remote function with signature (bigint, bigint) ->
+  /// bigint.
+  void registerMockRemotePlusFunction(const std::string& name) {
+    auto signatures = {exec::FunctionSignatureBuilder()
+                           .returnType("bigint")
+                           .argumentType("bigint")
+                           .argumentType("bigint")
+                           .build()};
+    registerMockRemoteFunction(name, std::move(signatures));
+  }
+
+ protected:
+  std::shared_ptr<testing::NiceMock<MockRemoteFunctionClient>> mockClient_;
+};
+
+TEST_F(MockRemoteFunctionTest, mockClientIsCalled) {
+  // Register a mock remote function.
+  auto signatures = {exec::FunctionSignatureBuilder()
+                         .returnType("bigint")
+                         .argumentType("bigint")
+                         .argumentType("bigint")
+                         .build()};
+  registerMockRemoteFunction("mock_plus", signatures);
+
+  // Set up the mock to return a valid response.
+  EXPECT_CALL(*mockClient_, invokeFunction)
+      .WillOnce([this](
+                    remote::RemoteFunctionResponse& response,
+                    const remote::RemoteFunctionRequest& /*request*/) {
+        // Return doubled values: input {1,2,3} + {1,2,3} = {2,4,6}
+        auto resultVector = makeRowVector({makeFlatVector<int64_t>({2, 4, 6})});
+        setMockResponse(response, resultVector);
+      });
+
+  auto inputVector = makeFlatVector<int64_t>({1, 2, 3});
+  auto results = evaluate<SimpleVector<int64_t>>(
+      "mock_plus(c0, c0)", makeRowVector({inputVector}));
+
+  // Verify the mock returned our expected values.
+  auto expected = makeFlatVector<int64_t>({2, 4, 6});
+  assertEqualVectors(expected, results);
+}
+
+TEST_F(MockRemoteFunctionTest, mockClientThrowsException) {
+  // Register a mock remote function.
+  auto signatures = {exec::FunctionSignatureBuilder()
+                         .returnType("bigint")
+                         .argumentType("bigint")
+                         .build()};
+  registerMockRemoteFunction("mock_throwing", signatures);
+
+  // Set up the mock to throw an exception.
+  EXPECT_CALL(*mockClient_, invokeFunction)
+      .WillOnce([](remote::RemoteFunctionResponse&,
+                   const remote::RemoteFunctionRequest&) {
+        throw std::runtime_error("Mock connection error");
+      });
+
+  auto inputVector = makeFlatVector<int64_t>({1, 2, 3});
+
+  // Verify the exception is propagated.
+  VELOX_ASSERT_THROW(
+      evaluate<SimpleVector<int64_t>>(
+          "mock_throwing(c0)", makeRowVector({inputVector})),
+      "Mock connection error");
+}
+
+TEST_F(MockRemoteFunctionTest, mockClientRepeatedCoroutineCalls) {
+  registerMockRemotePlusFunction("mock_repeated");
+
+  EXPECT_CALL(*mockClient_, invokeFunction)
+      .Times(3)
+      .WillRepeatedly([this](
+                          remote::RemoteFunctionResponse& response,
+                          const remote::RemoteFunctionRequest& /*request*/) {
+        auto resultVector =
+            makeRowVector({makeFlatVector<int64_t>({10, 20, 30})});
+        setMockResponse(response, resultVector);
+      });
+
+  for (int i = 0; i < 3; ++i) {
+    auto inputVector = makeFlatVector<int64_t>({1, 2, 3});
+    auto results = evaluate<SimpleVector<int64_t>>(
+        "mock_repeated(c0, c0)", makeRowVector({inputVector}));
+    auto expected = makeFlatVector<int64_t>({10, 20, 30});
+    assertEqualVectors(expected, results);
+  }
+}
+
+// Tests that exceptions thrown during the coroutine path don't leave the
+// function in a broken state.
+TEST_F(MockRemoteFunctionTest, coroutineExceptionThenRecovery) {
+  registerMockRemotePlusFunction("mock_recover");
+
+  // First call throws, second call succeeds.
+  EXPECT_CALL(*mockClient_, invokeFunction)
+      .WillOnce([](remote::RemoteFunctionResponse&,
+                   const remote::RemoteFunctionRequest&) {
+        throw std::runtime_error("Transient network error");
+      })
+      .WillOnce([this](
+                    remote::RemoteFunctionResponse& response,
+                    const remote::RemoteFunctionRequest& /*request*/) {
+        auto resultVector = makeRowVector({makeFlatVector<int64_t>({2, 4, 6})});
+        setMockResponse(response, resultVector);
+      });
+
+  auto inputVector = makeFlatVector<int64_t>({1, 2, 3});
+
+  // First call should fail.
+  VELOX_ASSERT_THROW(
+      evaluate<SimpleVector<int64_t>>(
+          "mock_recover(c0, c0)", makeRowVector({inputVector})),
+      "Transient network error");
+
+  // Second call should succeed, verifying the coroutine path recovers.
+  auto results = evaluate<SimpleVector<int64_t>>(
+      "mock_recover(c0, c0)", makeRowVector({inputVector}));
+  auto expected = makeFlatVector<int64_t>({2, 4, 6});
+  assertEqualVectors(expected, results);
+}
+
+// Tests the coroutine path with a larger batch
+TEST_F(MockRemoteFunctionTest, coroutineLargePayload) {
+  auto signatures = {exec::FunctionSignatureBuilder()
+                         .returnType("bigint")
+                         .argumentType("bigint")
+                         .build()};
+  registerMockRemoteFunction("mock_large", signatures);
+
+  constexpr int kSize = 1000;
+  std::vector<int64_t> expectedValues(kSize);
+  for (int i = 0; i < kSize; ++i) {
+    expectedValues[i] = i * 10;
+  }
+
+  EXPECT_CALL(*mockClient_, invokeFunction)
+      .WillOnce([this, &expectedValues](
+                    remote::RemoteFunctionResponse& response,
+                    const remote::RemoteFunctionRequest& /*request*/) {
+        auto resultVector =
+            makeRowVector({makeFlatVector<int64_t>(expectedValues)});
+        setMockResponse(response, resultVector);
+      });
+
+  std::vector<int64_t> inputValues(kSize);
+  std::iota(inputValues.begin(), inputValues.end(), 0);
+  auto inputVector = makeFlatVector<int64_t>(inputValues);
+  auto results = evaluate<SimpleVector<int64_t>>(
+      "mock_large(c0)", makeRowVector({inputVector}));
+
+  auto expected = makeFlatVector<int64_t>(expectedValues);
+  assertEqualVectors(expected, results);
+}
+
 VELOX_INSTANTIATE_TEST_SUITE_P(
     RemoteFunctionTestFixture,
     RemoteFunctionTest,
diff --git a/velox/functions/remote/if/CMakeLists.txt b/velox/functions/remote/if/CMakeLists.txt
index e88fe3cbdbf..b933d34b313 100644
--- a/velox/functions/remote/if/CMakeLists.txt
+++ b/velox/functions/remote/if/CMakeLists.txt
@@ -23,7 +23,7 @@ add_fbthrift_cpp_library(
 
 target_compile_options(remote_function_thrift PRIVATE -Wno-deprecated-declarations)
 
-velox_add_library(velox_functions_remote_get_serde GetSerde.cpp)
+velox_add_library(velox_functions_remote_get_serde GetSerde.cpp HEADERS GetSerde.h)
 velox_link_libraries(
   velox_functions_remote_get_serde
   PUBLIC remote_function_thrift velox_presto_serializer
diff --git a/velox/functions/remote/if/GetSerde.cpp b/velox/functions/remote/if/GetSerde.cpp
index 78f52d61479..91985e5a64d 100644
--- a/velox/functions/remote/if/GetSerde.cpp
+++ b/velox/functions/remote/if/GetSerde.cpp
@@ -30,4 +30,21 @@ std::unique_ptr<VectorSerde> getSerde(const remote::PageFormat& format) {
   }
   VELOX_UNREACHABLE();
 }
+
+std::unique_ptr<VectorSerde::Options> getSerdeOptions(
+    const remote::PageFormat& format,
+    bool preserveEncoding) {
+  switch (format) {
+    case remote::PageFormat::PRESTO_PAGE: {
+      auto options = std::make_unique<
+          serializer::presto::PrestoVectorSerde::PrestoOptions>();
+      options->preserveEncodings = preserveEncoding;
+      return options;
+    }
+    case remote::PageFormat::SPARK_UNSAFE_ROW:
+      return std::make_unique<VectorSerde::Options>();
+  }
+  VELOX_UNREACHABLE();
+}
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/remote/if/GetSerde.h b/velox/functions/remote/if/GetSerde.h
index b18a3c0342a..cbf5b923d84 100644
--- a/velox/functions/remote/if/GetSerde.h
+++ b/velox/functions/remote/if/GetSerde.h
@@ -17,6 +17,7 @@
 #pragma once
 
 #include "velox/functions/remote/if/gen-cpp2/RemoteFunction_types.h"
+#include "velox/vector/VectorStream.h"
 
 namespace facebook::velox {
 class VectorSerde;
@@ -26,4 +27,9 @@ namespace facebook::velox::functions {
 
 std::unique_ptr<VectorSerde> getSerde(const remote::PageFormat& format);
 
+/// Creates appropriate serde options based on format and configuration.
+std::unique_ptr<VectorSerde::Options> getSerdeOptions(
+    const remote::PageFormat& format,
+    bool preserveEncoding);
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/remote/if/RemoteFunction.thrift b/velox/functions/remote/if/RemoteFunction.thrift
index 559f0192c15..b1bde558242 100644
--- a/velox/functions/remote/if/RemoteFunction.thrift
+++ b/velox/functions/remote/if/RemoteFunction.thrift
@@ -14,8 +14,12 @@
  * limitations under the License.
  */
 
+package "facebook.com/velox/functions"
+
 namespace cpp2 facebook.velox.functions.remote
 namespace java.swift com.facebook.spark.remotefunctionserver.api
+namespace py3 facebook.velox.functions.remote
+namespace rust velox_functions_remote
 
 cpp_include "folly/io/IOBuf.h"
 
diff --git a/velox/functions/remote/server/CMakeLists.txt b/velox/functions/remote/server/CMakeLists.txt
index e193efbb651..06fba8893d2 100644
--- a/velox/functions/remote/server/CMakeLists.txt
+++ b/velox/functions/remote/server/CMakeLists.txt
@@ -13,6 +13,7 @@
 # limitations under the License.
 
 add_library(velox_functions_remote_server RemoteFunctionService.cpp)
+velox_add_test_headers(velox_functions_remote_server RemoteFunctionService.h)
 
 target_link_libraries(
   velox_functions_remote_server
diff --git a/velox/functions/remote/server/RemoteFunctionService.cpp b/velox/functions/remote/server/RemoteFunctionService.cpp
index e0eb6d06089..29122e7af19 100644
--- a/velox/functions/remote/server/RemoteFunctionService.cpp
+++ b/velox/functions/remote/server/RemoteFunctionService.cpp
@@ -60,8 +60,9 @@ std::vector<core::TypedExprPtr> getExpressions(
     const std::string& functionName) {
   std::vector<core::TypedExprPtr> inputs;
   for (size_t i = 0; i < inputType->size(); ++i) {
-    inputs.push_back(std::make_shared<core::FieldAccessTypedExpr>(
-        inputType->childAt(i), inputType->nameOf(i)));
+    inputs.push_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            inputType->childAt(i), inputType->nameOf(i)));
   }
 
   return {std::make_shared<core::CallTypedExpr>(
@@ -104,7 +105,7 @@ void RemoteFunctionServiceHandler::handleErrors(
       numRows,
       std::vector<VectorPtr>{flatVector});
   result->errorPayload() =
-      rowVectorToIOBuf(errorRowVector, *pool_, serde.get());
+      rowVectorToIOBufBatch(errorRowVector, *pool_, serde.get());
 }
 
 void RemoteFunctionServiceHandler::invokeFunction(
@@ -153,7 +154,7 @@ void RemoteFunctionServiceHandler::invokeFunction(
   result->rowCount() = outputRowVector->size();
   result->pageFormat() = serdeFormat;
   result->payload() =
-      rowVectorToIOBuf(outputRowVector, rows.end(), *pool_, serde.get());
+      rowVectorToIOBufBatch(outputRowVector, rows.end(), *pool_, serde.get());
 
   auto evalErrors = evalCtx.errors();
   if (evalErrors != nullptr && evalErrors->hasError()) {
diff --git a/velox/functions/remote/utils/CMakeLists.txt b/velox/functions/remote/utils/CMakeLists.txt
index fbf3c95640f..0bc8f5e7dfa 100644
--- a/velox/functions/remote/utils/CMakeLists.txt
+++ b/velox/functions/remote/utils/CMakeLists.txt
@@ -13,5 +13,6 @@
 # limitations under the License.
 
 add_library(velox_functions_remote_utils RemoteFunctionServiceProvider.cpp)
+velox_add_test_headers(velox_functions_remote_utils RemoteFunctionServiceProvider.h)
 
 target_link_libraries(velox_functions_remote_utils PUBLIC velox_functions_remote_server)
diff --git a/velox/functions/sparksql/Arithmetic.h b/velox/functions/sparksql/Arithmetic.h
index 627484682e3..215af7ab996 100644
--- a/velox/functions/sparksql/Arithmetic.h
+++ b/velox/functions/sparksql/Arithmetic.h
@@ -32,18 +32,35 @@ namespace facebook::velox::functions::sparksql {
 template <typename TExec>
 struct AbsFunction {
   template <typename T>
-  FOLLY_ALWAYS_INLINE void call(T& result, const T& a) {
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config,
+      const T* /*a*/) {
+    ansiEnabled_ = config.sparkAnsiEnabled();
+  }
+
+  template <typename T>
+  FOLLY_ALWAYS_INLINE Status call(T& result, const T& a) {
     if constexpr (std::is_integral_v<T>) {
       if (FOLLY_UNLIKELY(a == std::numeric_limits<T>::min())) {
-        // To be compatible with Spark's ANSI off mode, when the input is
-        // negative minimum value, returns the same value as input instead of
-        // throwing an error.
+        if (ansiEnabled_) {
+          // In ANSI mode, returns an overflow error.
+          if (threadSkipErrorDetails()) {
+            return Status::UserError();
+          }
+          return Status::UserError("Arithmetic overflow: abs({})", a);
+        }
+        // In ANSI off mode, returns the same negative minimum value.
         result = a;
-        return;
+        return Status::OK();
       }
     }
     result = std::abs(a);
+    return Status::OK();
   }
+
+ private:
+  bool ansiEnabled_ = false;
 };
 
 template <typename T>
@@ -541,18 +558,15 @@ struct RIntFunction {
 
 template <typename TExec>
 struct CheckedAddFunction {
-  VELOX_DEFINE_FUNCTION_TYPES(TExec);
   template <typename T>
   FOLLY_ALWAYS_INLINE Status call(T& result, const T& a, const T& b) {
     if constexpr (std::is_integral_v<T>) {
       T res;
-      bool overflow = __builtin_add_overflow(a, b, &res);
-      if (UNLIKELY(overflow)) {
-        if (threadSkipErrorDetails()) {
-          return Status::UserError();
-        }
-        return Status::UserError("Arithmetic overflow: {} + {}", a, b);
-      }
+      VELOX_USER_RETURN(
+          __builtin_add_overflow(a, b, &res),
+          "Arithmetic overflow: {} + {}",
+          a,
+          b);
       result = res;
     } else {
       result = a + b;
@@ -563,17 +577,14 @@ struct CheckedAddFunction {
 
 template <typename TExec>
 struct CheckedSubtractFunction {
-  VELOX_DEFINE_FUNCTION_TYPES(TExec);
   template <typename T>
   FOLLY_ALWAYS_INLINE Status call(T& result, const T& a, const T& b) {
     if constexpr (std::is_integral_v<T>) {
-      bool overflow = __builtin_sub_overflow(a, b, &result);
-      if (UNLIKELY(overflow)) {
-        if (threadSkipErrorDetails()) {
-          return Status::UserError();
-        }
-        return Status::UserError("Arithmetic overflow: {} - {}", a, b);
-      }
+      VELOX_USER_RETURN(
+          __builtin_sub_overflow(a, b, &result),
+          "Arithmetic overflow: {} - {}",
+          a,
+          b);
     } else {
       result = a - b;
     }
@@ -583,17 +594,14 @@ struct CheckedSubtractFunction {
 
 template <typename TExec>
 struct CheckedMultiplyFunction {
-  VELOX_DEFINE_FUNCTION_TYPES(TExec);
   template <typename T>
   FOLLY_ALWAYS_INLINE Status call(T& result, const T& a, const T& b) {
     if constexpr (std::is_integral_v<T>) {
-      bool overflow = __builtin_mul_overflow(a, b, &result);
-      if (UNLIKELY(overflow)) {
-        if (threadSkipErrorDetails()) {
-          return Status::UserError();
-        }
-        return Status::UserError("Arithmetic overflow: {} * {}", a, b);
-      }
+      VELOX_USER_RETURN(
+          __builtin_mul_overflow(a, b, &result),
+          "Arithmetic overflow: {} * {}",
+          a,
+          b);
     } else {
       result = a * b;
     }
@@ -603,23 +611,56 @@ struct CheckedMultiplyFunction {
 
 template <typename TExec>
 struct CheckedDivideFunction {
-  VELOX_DEFINE_FUNCTION_TYPES(TExec);
   template <typename T>
   FOLLY_ALWAYS_INLINE Status call(T& result, const T& a, const T& b) {
+    VELOX_USER_RETURN_EQ(b, 0, "division by zero");
+    if constexpr (std::is_integral_v<T>) {
+      VELOX_USER_RETURN(
+          a == std::numeric_limits<T>::min() && b == -1,
+          "Arithmetic overflow: {} / {}",
+          a,
+          b);
+    }
+    result = a / b;
+    return Status::OK();
+  }
+};
+
+/// Implements integral division with truncation towards zero.
+/// Returns Null if divisor is 0.
+template <typename TExec>
+struct IntegralDivideFunction {
+  template <typename T>
+  FOLLY_ALWAYS_INLINE bool call(int64_t& result, const T& a, const T& b) {
     if (b == 0) {
-      if (threadSkipErrorDetails()) {
-        return Status::UserError();
-      }
-      return Status::UserError("division by zero");
+      return false;
     }
-    if constexpr (std::is_integral_v<T>) {
-      if (UNLIKELY(a == std::numeric_limits<T>::min() && b == -1)) {
-        if (threadSkipErrorDetails()) {
-          return Status::UserError();
-        }
-        return Status::UserError("Arithmetic overflow: {} / {}", a, b);
-      }
+    // In Java, Long.MIN_VALUE is -2^63 and Long.MAX_VALUE is 2^63 - 1.
+    // Dividing Long.MIN_VALUE by -1 overflows because the positive
+    // result (+2^63) cannot be represented in a signed 64-bit integer.
+    // Java integer arithmetic wraps around on overflow (two's complement),
+    // so Long.MIN_VALUE / -1 evaluates to Long.MIN_VALUE itself instead
+    // of throwing an exception.
+    if (a == std::numeric_limits<int64_t>::min() && b == -1) {
+      result = a;
+      return true;
     }
+
+    result = a / b;
+    return true;
+  }
+};
+
+/// Implements integral division with truncation towards zero.
+/// Returns Error if divisor is 0 or overflow.
+template <typename TExec>
+struct CheckedIntegralDivideFunction {
+  template <typename T>
+  FOLLY_ALWAYS_INLINE Status call(int64_t& result, const T& a, const T& b) {
+    VELOX_USER_RETURN_EQ(b, 0, "Division by zero");
+    VELOX_USER_RETURN(
+        a == std::numeric_limits<int64_t>::min() && b == -1,
+        "Overflow in integral divide");
     result = a / b;
     return Status::OK();
   }
diff --git a/velox/functions/sparksql/ArrayGetFunction.cpp b/velox/functions/sparksql/ArrayGetFunction.cpp
index 72d1726cb39..f2e2c2ca4af 100644
--- a/velox/functions/sparksql/ArrayGetFunction.cpp
+++ b/velox/functions/sparksql/ArrayGetFunction.cpp
@@ -39,12 +39,13 @@ class ArrayGetFunction : public SubscriptImpl<
 
     // array(T), tinyint|smallint|integer|bigint -> T
     for (const auto& indexType : {"tinyint", "smallint", "integer", "bigint"}) {
-      signatures.push_back(exec::FunctionSignatureBuilder()
-                               .typeVariable("T")
-                               .returnType("T")
-                               .argumentType("array(T)")
-                               .argumentType(indexType)
-                               .build());
+      signatures.push_back(
+          exec::FunctionSignatureBuilder()
+              .typeVariable("T")
+              .returnType("T")
+              .argumentType("array(T)")
+              .argumentType(indexType)
+              .build());
     }
 
     return signatures;
diff --git a/velox/functions/sparksql/ArraySort.cpp b/velox/functions/sparksql/ArraySort.cpp
index 4467bc3cae2..79f3f10e2d4 100644
--- a/velox/functions/sparksql/ArraySort.cpp
+++ b/velox/functions/sparksql/ArraySort.cpp
@@ -14,243 +14,64 @@
  * limitations under the License.
  */
 #include "velox/functions/sparksql/ArraySort.h"
-
-#include <memory>
-#include "velox/common/base/Exceptions.h"
-#include "velox/expression/EvalCtx.h"
-#include "velox/expression/Expr.h"
-#include "velox/expression/VectorFunction.h"
-#include "velox/functions/lib/RowsTranslationUtil.h"
-#include "velox/functions/sparksql/Comparisons.h"
-#include "velox/type/Type.h"
-#include "velox/vector/BaseVector.h"
-#include "velox/vector/ComplexVector.h"
-#include "velox/vector/SelectivityVector.h"
-#include "velox/vector/SimpleVector.h"
-#include "velox/vector/TypeAliases.h"
+#include "velox/functions/sparksql/SimpleComparisonMatcher.h"
 
 namespace facebook::velox::functions::sparksql {
-namespace {
-
-void applyComplexType(
-    const SelectivityVector& rows,
-    ArrayVector* inputArray,
-    bool ascending,
-    bool nullsFirst,
-    exec::EvalCtx& context,
-    VectorPtr* resultElements) {
-  auto elementsVector = inputArray->elements();
-
-  // Allocate new vectors for indices.
-  BufferPtr indices = allocateIndices(elementsVector->size(), context.pool());
-  vector_size_t* rawIndices = indices->asMutable<vector_size_t>();
-
-  const CompareFlags flags{.nullsFirst = nullsFirst, .ascending = ascending};
-  // Note: Reusing offsets and sizes isn't safe if the input array had two
-  // arrays that had overlapping (but not identical) ranges in the input.
-  rows.applyToSelected([&](vector_size_t row) {
-    auto size = inputArray->sizeAt(row);
-    auto offset = inputArray->offsetAt(row);
-
-    for (auto i = 0; i < size; ++i) {
-      rawIndices[offset + i] = offset + i;
-    }
-    std::sort(
-        rawIndices + offset,
-        rawIndices + offset + size,
-        [&](vector_size_t& a, vector_size_t& b) {
-          return elementsVector->compare(elementsVector.get(), a, b, flags) < 0;
-        });
-  });
-
-  *resultElements = BaseVector::transpose(indices, std::move(elementsVector));
-}
-
-template <typename T>
-inline void swapWithNull(
-    FlatVector<T>* vector,
-    vector_size_t index,
-    vector_size_t nullIndex) {
-  // Values are already present in vector stringBuffers. Don't create additional
-  // copy.
-  if constexpr (std::is_same_v<T, StringView>) {
-    vector->setNoCopy(nullIndex, vector->valueAt(index));
-  } else {
-    vector->set(nullIndex, vector->valueAt(index));
-  }
-  vector->setNull(index, true);
-}
-
-template <TypeKind kind>
-void applyTyped(
-    const SelectivityVector& rows,
-    const ArrayVector* inputArray,
-    bool ascending,
-    bool nullsFirst,
-    exec::EvalCtx& context,
-    VectorPtr* resultElements) {
-  using T = typename TypeTraits<kind>::NativeType;
-
-  // Copy array elements to new vector.
-  const VectorPtr& inputElements = inputArray->elements();
-  SelectivityVector elementRows =
-      toElementRows(inputElements->size(), rows, inputArray);
-
-  *resultElements = BaseVector::create(
-      inputElements->type(), inputElements->size(), context.pool());
-  (*resultElements)
-      ->copy(inputElements.get(), elementRows, /*toSourceRow=*/nullptr);
-
-  auto flatResults = (*resultElements)->asFlatVector<T>();
-  T* resultRawValues = flatResults->mutableRawValues();
-
-  auto processRow = [&](vector_size_t row) {
-    auto size = inputArray->sizeAt(row);
-    auto offset = inputArray->offsetAt(row);
-    if (size == 0) {
-      return;
-    }
-    vector_size_t numNulls = 0;
-    if (nullsFirst) {
-      // Move nulls to beginning of array.
-      for (vector_size_t i = 0; i < size; ++i) {
-        if (flatResults->isNullAt(offset + i)) {
-          swapWithNull<T>(flatResults, offset + numNulls, offset + i);
-          ++numNulls;
-        }
-      }
-    } else {
-      // Move nulls to end of array.
-      for (vector_size_t i = size - 1; i >= 0; --i) {
-        if (flatResults->isNullAt(offset + i)) {
-          swapWithNull<T>(
-              flatResults, offset + size - numNulls - 1, offset + i);
-          ++numNulls;
-        }
-      }
-    }
-    // Exclude null values while sorting.
-    auto rowBegin = offset + (nullsFirst ? numNulls : 0);
-    auto rowEnd = rowBegin + size - numNulls;
-
-    if constexpr (kind == TypeKind::BOOLEAN) {
-      uint64_t* rawBits = flatResults->template mutableRawValues<uint64_t>();
-      auto numSetBits = bits::countBits(rawBits, rowBegin, rowEnd);
-      // If ascending, false is placed before true, otherwise true is placed
-      // before false.
-      bool smallerValue = !ascending;
-      auto mid = ascending ? rowEnd - numSetBits : rowBegin + numSetBits;
-      bits::fillBits(rawBits, rowBegin, mid, smallerValue);
-      bits::fillBits(rawBits, mid, rowEnd, !smallerValue);
-    } else {
-      if (ascending) {
-        std::sort(
-            resultRawValues + rowBegin, resultRawValues + rowEnd, Less<T>());
-      } else {
-        std::sort(
-            resultRawValues + rowBegin, resultRawValues + rowEnd, Greater<T>());
-      }
-    }
-  };
-
-  rows.applyToSelected(processRow);
-}
-} // namespace
-
-void ArraySort::apply(
-    const SelectivityVector& rows,
-    std::vector<VectorPtr>& args,
-    const TypePtr& /*outputType*/,
-    exec::EvalCtx& context,
-    VectorPtr& result) const {
-  auto& arg = args[0];
-
-  VectorPtr localResult;
-
-  // Input can be constant or flat.
-  if (arg->isConstantEncoding()) {
-    auto* constantArray = arg->as<ConstantVector<ComplexType>>();
-    const auto& flatArray = constantArray->valueVector();
-    const auto flatIndex = constantArray->index();
-
-    exec::LocalSingleRow singleRow(context, flatIndex);
-    localResult = applyFlat(*singleRow, flatArray, context);
-    localResult =
-        BaseVector::wrapInConstant(rows.end(), flatIndex, localResult);
-  } else {
-    localResult = applyFlat(rows, arg, context);
+std::shared_ptr<exec::VectorFunction> makeArraySortAsc(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config) {
+  // If the second argument is present, it must be a lambda.
+  if (inputArgs.size() == 2) {
+    return makeArraySortLambdaFunction(name, inputArgs, config, true, false);
   }
 
-  context.moveOrCopyResult(localResult, rows, result);
+  VELOX_CHECK_EQ(inputArgs.size(), 1);
+  // Nulls are considered largest.
+  return facebook::velox::functions::makeArraySort(
+      name,
+      inputArgs,
+      config,
+      true /*ascending*/,
+      false /*nullsFirst*/,
+      false /*throwOnNestedNull*/);
 }
 
-VectorPtr ArraySort::applyFlat(
-    const SelectivityVector& rows,
-    const VectorPtr& arg,
-    exec::EvalCtx& context) const {
-  ArrayVector* inputArray = arg->as<ArrayVector>();
-  VectorPtr resultElements;
-
-  auto typeKind = inputArray->elements()->typeKind();
-  if (typeKind == TypeKind::MAP || typeKind == TypeKind::ARRAY ||
-      typeKind == TypeKind::ROW) {
-    applyComplexType(
-        rows, inputArray, ascending_, nullsFirst_, context, &resultElements);
-  } else {
-    VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
-        applyTyped,
-        typeKind,
-        rows,
-        inputArray,
-        ascending_,
-        nullsFirst_,
-        context,
-        &resultElements);
-  }
-
-  return std::make_shared<ArrayVector>(
-      context.pool(),
-      inputArray->type(),
-      inputArray->nulls(),
-      rows.end(),
-      inputArray->offsets(),
-      inputArray->sizes(),
-      resultElements,
-      inputArray->getNullCount());
+std::shared_ptr<exec::VectorFunction> makeArraySortDesc(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config) {
+  VELOX_CHECK_EQ(inputArgs.size(), 2);
+  return makeArraySortLambdaFunction(name, inputArgs, config, false, false);
 }
 
-// Signature: array_sort(array(T)) -> array(T)
-std::vector<std::shared_ptr<exec::FunctionSignature>> arraySortSignatures() {
+// Signatures:
+//   array_sort_desc(array(T), function(T,U)) -> array(T)
+std::vector<std::shared_ptr<exec::FunctionSignature>>
+arraySortDescSignatures() {
   return {
       exec::FunctionSignatureBuilder()
-          .typeVariable("T")
-          .argumentType("array(T)")
+          .orderableTypeVariable("T")
+          .orderableTypeVariable("U")
           .returnType("array(T)")
+          .argumentType("array(T)")
+          .constantArgumentType("function(T,U)")
           .build(),
   };
 }
 
-std::shared_ptr<exec::VectorFunction> makeArraySort(
-    const std::string& name,
-    const std::vector<exec::VectorFunctionArg>& inputArgs,
-    const core::QueryConfig& /*config*/) {
-  VELOX_CHECK_EQ(inputArgs.size(), 1);
-  // Nulls are considered largest.
-  return std::make_shared<ArraySort>(/*ascending=*/true, /*nullsFirst=*/false);
-}
-
 // Signatures:
 //   sort_array(array(T)) -> array(T)
 //   sort_array(array(T), boolean) -> array(T)
 std::vector<std::shared_ptr<exec::FunctionSignature>> sortArraySignatures() {
   return {
       exec::FunctionSignatureBuilder()
-          .typeVariable("T")
+          .orderableTypeVariable("T")
           .argumentType("array(T)")
           .returnType("array(T)")
           .build(),
       exec::FunctionSignatureBuilder()
-          .typeVariable("T")
+          .orderableTypeVariable("T")
           .argumentType("array(T)")
           .constantArgumentType("boolean")
           .returnType("array(T)")
@@ -261,7 +82,7 @@ std::vector<std::shared_ptr<exec::FunctionSignature>> sortArraySignatures() {
 std::shared_ptr<exec::VectorFunction> makeSortArray(
     const std::string& name,
     const std::vector<exec::VectorFunctionArg>& inputArgs,
-    const core::QueryConfig& /*config*/) {
+    const core::QueryConfig& config) {
   VELOX_CHECK(
       inputArgs.size() == 1 || inputArgs.size() == 2,
       "Invalid number of arguments {}, expected 1 or 2",
@@ -278,6 +99,13 @@ std::shared_ptr<exec::VectorFunction> makeSortArray(
   }
   // Nulls are considered smallest.
   bool nullsFirst = ascending;
-  return std::make_shared<ArraySort>(ascending, nullsFirst);
+  return facebook::velox::functions::makeArraySort(
+      name,
+      inputArgs,
+      config,
+      ascending /*ascending*/,
+      nullsFirst /*nullsFirst*/,
+      false /*throwOnNestedNull*/);
 }
+
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/ArraySort.h b/velox/functions/sparksql/ArraySort.h
index dd83018ef3a..23f1d68f443 100644
--- a/velox/functions/sparksql/ArraySort.h
+++ b/velox/functions/sparksql/ArraySort.h
@@ -15,53 +15,31 @@
  */
 #pragma once
 
-#include "velox/expression/VectorFunction.h"
+#include "velox/functions/lib/ArraySort.h"
 
 namespace facebook::velox::functions::sparksql {
 
-class ArraySort : public exec::VectorFunction {
-  /// This class implements generic array sort function. Takes an array as input
-  /// and sorts it according to provided comparator |Cmp| as template parameter.
-  /// Additionally |nullsFirst| ctor parameter can be used to configure nulls
-  /// sort order. If |nullsFirst| is  true nulls are moved to front of array,
-  ///  otherwise nulls are moved to end of array.
-  ///
-  /// Sorts floating points as per following ascending order:
-  /// -Inf < Inf < NaN
-
- public:
-  explicit ArraySort(bool ascending, bool nullsFirst)
-      : ascending_(ascending), nullsFirst_(nullsFirst) {}
-
-  void apply(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& /* outputType */,
-      exec::EvalCtx& context,
-      VectorPtr& result) const override;
-
- private:
-  VectorPtr applyFlat(
-      const SelectivityVector& rows,
-      const VectorPtr& arg,
-      exec::EvalCtx& context) const;
-
-  const bool ascending_;
-  const bool nullsFirst_;
-};
-
-std::shared_ptr<exec::VectorFunction> makeArraySort(
+std::shared_ptr<exec::VectorFunction> makeArraySortAsc(
     const std::string& name,
     const std::vector<exec::VectorFunctionArg>& inputArgs,
     const core::QueryConfig& config);
 
-std::vector<std::shared_ptr<exec::FunctionSignature>> arraySortSignatures();
+// Sorts an array in descending order. The first argument is the array to sort,
+// and the second argument is a lambda function that maps the array elements
+// to the values to be sorted by.
+//
+// This function is only used in rewriteArraySortCall.
+std::shared_ptr<exec::VectorFunction> makeArraySortDesc(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config);
 
 std::shared_ptr<exec::VectorFunction> makeSortArray(
     const std::string& name,
     const std::vector<exec::VectorFunctionArg>& inputArgs,
     const core::QueryConfig& config);
 
+std::vector<std::shared_ptr<exec::FunctionSignature>> arraySortDescSignatures();
 std::vector<std::shared_ptr<exec::FunctionSignature>> sortArraySignatures();
 
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/AssertNotNull.cpp b/velox/functions/sparksql/AssertNotNull.cpp
new file mode 100644
index 00000000000..8a0525e747b
--- /dev/null
+++ b/velox/functions/sparksql/AssertNotNull.cpp
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/sparksql/AssertNotNull.h"
+
+namespace facebook::velox::functions::sparksql {
+namespace {
+
+// Asserts that the input value is not null. If any value in the specified rows
+// is null, throws a user error. Used by Spark's TableOutputResolver to enforce
+// NOT NULL column constraints during table inserts.
+class AssertNotNullFunction final : public exec::VectorFunction {
+ public:
+  explicit AssertNotNullFunction(
+      std::string errMsg = "Null value appeared in non-nullable field")
+      : errMsg_(std::move(errMsg)) {}
+
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& /* outputType */,
+      exec::EvalCtx& context,
+      VectorPtr& result) const final {
+    const auto& input = args[0];
+    if (input->mayHaveNulls() && input->rawNulls()) {
+      context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
+        VELOX_USER_CHECK(!input->isNullAt(row), "{}", errMsg_);
+      });
+    }
+    context.moveOrCopyResult(input, rows, result);
+  }
+
+ private:
+  const std::string errMsg_;
+};
+} // namespace
+
+std::vector<std::shared_ptr<exec::FunctionSignature>>
+assertNotNullSignatures() {
+  return {
+      exec::FunctionSignatureBuilder()
+          .typeVariable("T")
+          .returnType("T")
+          .argumentType("T")
+          .build(),
+      exec::FunctionSignatureBuilder()
+          .typeVariable("T")
+          .returnType("T")
+          .argumentType("T")
+          .constantArgumentType("varchar")
+          .build()};
+}
+
+std::shared_ptr<exec::VectorFunction> makeAssertNotNull(
+    const std::string& /* name */,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& /* config */) {
+  if (inputArgs.size() == 2 && inputArgs[1].constantValue &&
+      !inputArgs[1].constantValue->isNullAt(0)) {
+    auto constantExpr =
+        inputArgs[1].constantValue->as<ConstantVector<StringView>>();
+    return std::make_shared<AssertNotNullFunction>(
+        constantExpr->valueAt(0).str());
+  }
+  return std::make_shared<AssertNotNullFunction>();
+}
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/AssertNotNull.h b/velox/functions/sparksql/AssertNotNull.h
new file mode 100644
index 00000000000..e5697c0245f
--- /dev/null
+++ b/velox/functions/sparksql/AssertNotNull.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/VectorFunction.h"
+
+namespace facebook::velox::functions::sparksql {
+
+std::vector<std::shared_ptr<exec::FunctionSignature>> assertNotNullSignatures();
+
+std::shared_ptr<exec::VectorFunction> makeAssertNotNull(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config);
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/CMakeLists.txt b/velox/functions/sparksql/CMakeLists.txt
index 3ae83a3dbce..0c14fb179ab 100644
--- a/velox/functions/sparksql/CMakeLists.txt
+++ b/velox/functions/sparksql/CMakeLists.txt
@@ -17,12 +17,16 @@ velox_add_library(
   velox_functions_spark_impl
   ArrayGetFunction.cpp
   ArraySort.cpp
+  AssertNotNull.cpp
+  SequenceFunction.cpp
+  Transform.cpp
   CharVarcharUtils.cpp
   Comparisons.cpp
   ConcatWs.cpp
   DecimalArithmetic.cpp
   DecimalCeil.cpp
   DecimalCompare.cpp
+  FilterFunction.cpp
   Hash.cpp
   In.cpp
   LeastGreatest.cpp
@@ -32,7 +36,59 @@ velox_add_library(
   Size.cpp
   String.cpp
   TimestampUtils.cpp
+  Transform.cpp
   UnscaledValueFunction.cpp
+  HEADERS
+  Arena.h
+  Arithmetic.h
+  ArrayAppend.h
+  ArrayConcat.h
+  ArrayFlattenFunction.h
+  ArrayInsert.h
+  ArrayMinMaxFunction.h
+  ArrayPrepend.h
+  ArraySort.h
+  AssertNotNull.h
+  Base64Function.h
+  Bitwise.h
+  CharTypeWriteSideCheck.h
+  CharVarcharUtils.h
+  Comparisons.h
+  ConcatWs.h
+  DateTimeFunctions.h
+  DecimalArithmetic.h
+  DecimalCeil.h
+  DecimalUtil.h
+  Factorial.h
+  GetJsonObject.h
+  Hash.h
+  In.h
+  InitcapFunction.h
+  JsonObjectKeys.h
+  LambdaIndexUtil.h
+  LeastGreatest.h
+  LuhnCheckFunction.h
+  MaskFunction.h
+  MightContain.h
+  MonotonicallyIncreasingId.h
+  RaiseError.h
+  Rand.h
+  RandStr.h
+  ReadSidePaddingFunction.h
+  RegexFunctions.h
+  SimpleComparisonMatcher.h
+  Size.h
+  SparkPartitionId.h
+  Split.h
+  String.h
+  StringToMap.h
+  TimestampUtils.h
+  ToJson.h
+  ToPrettyString.h
+  UnBase64Function.h
+  UnscaledValueFunction.h
+  Uuid.h
+  VarcharTypeWriteSideCheck.h
 )
 
 velox_link_libraries(
diff --git a/velox/functions/sparksql/Comparisons.h b/velox/functions/sparksql/Comparisons.h
index 7038b5550e1..6d358fd2135 100644
--- a/velox/functions/sparksql/Comparisons.h
+++ b/velox/functions/sparksql/Comparisons.h
@@ -126,13 +126,14 @@ std::shared_ptr<exec::VectorFunction> makeGreaterThanOrEqual(
 inline std::vector<std::shared_ptr<exec::FunctionSignature>>
 comparisonSignatures() {
   std::vector<std::shared_ptr<exec::FunctionSignature>> signatures;
-  signatures.emplace_back(exec::FunctionSignatureBuilder()
-                              .integerVariable("a_precision")
-                              .integerVariable("a_scale")
-                              .returnType("boolean")
-                              .argumentType("DECIMAL(a_precision, a_scale)")
-                              .argumentType("DECIMAL(a_precision, a_scale)")
-                              .build());
+  signatures.emplace_back(
+      exec::FunctionSignatureBuilder()
+          .integerVariable("a_precision")
+          .integerVariable("a_scale")
+          .returnType("boolean")
+          .argumentType("DECIMAL(a_precision, a_scale)")
+          .argumentType("DECIMAL(a_precision, a_scale)")
+          .build());
   for (const auto& inputType :
        {"tinyint",
         "smallint",
@@ -147,11 +148,12 @@ comparisonSignatures() {
         "date",
         "interval day to second",
         "interval year to month"}) {
-    signatures.emplace_back(exec::FunctionSignatureBuilder()
-                                .returnType("boolean")
-                                .argumentType(inputType)
-                                .argumentType(inputType)
-                                .build());
+    signatures.emplace_back(
+        exec::FunctionSignatureBuilder()
+            .returnType("boolean")
+            .argumentType(inputType)
+            .argumentType(inputType)
+            .build());
   }
   return signatures;
 }
@@ -164,7 +166,9 @@ struct BetweenFunction {
       const TInput& value,
       const TInput& low,
       const TInput& high) {
-    result = value >= low && value <= high;
+    GreaterOrEqual<TInput> gte;
+    LessOrEqual<TInput> lte;
+    result = gte(value, low) && lte(value, high);
   }
 };
 
diff --git a/velox/functions/sparksql/DateTimeFunctions.h b/velox/functions/sparksql/DateTimeFunctions.h
index 5dba18c95d7..eda5472097a 100644
--- a/velox/functions/sparksql/DateTimeFunctions.h
+++ b/velox/functions/sparksql/DateTimeFunctions.h
@@ -435,6 +435,7 @@ struct GetTimestampFunction {
       } else {
         invalidFormat_ = true;
       }
+      isConstantTimeFormat_ = true;
     }
   }
 
@@ -779,6 +780,51 @@ struct WeekdayFunction {
   }
 };
 
+template <typename T>
+struct DayNameFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  static constexpr std::string_view kDayNames[] =
+      {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Varchar>& result,
+      const arg_type<Date>& date) {
+    // Based on the fact that the Unix epoch is Thursday.
+    auto dayOfWeek = (4 + date) % 7;
+    if (dayOfWeek < 0) {
+      dayOfWeek += 7;
+    }
+    result.append(StringView(kDayNames[dayOfWeek]));
+  }
+};
+
+template <typename T>
+struct MonthNameFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  static constexpr std::string_view kMonthNames[] = {
+      "Jan",
+      "Feb",
+      "Mar",
+      "Apr",
+      "May",
+      "Jun",
+      "Jul",
+      "Aug",
+      "Sep",
+      "Oct",
+      "Nov",
+      "Dec"};
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Varchar>& result,
+      const arg_type<Date>& date) {
+    const auto tm = getDateTime(date);
+    result.append(kMonthNames[tm.tm_mon]);
+  }
+};
+
 template <typename T>
 struct NextDayFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
@@ -960,37 +1006,40 @@ struct SecondsToTimestampFunction {
   VELOX_DEFINE_FUNCTION_TYPES(TExec);
 
   template <typename T>
-  FOLLY_ALWAYS_INLINE void call(out_type<Timestamp>& result, T seconds) {
+  FOLLY_ALWAYS_INLINE bool call(out_type<Timestamp>& result, T seconds) {
     if constexpr (std::is_integral_v<T>) {
       result = Timestamp(static_cast<int64_t>(seconds), 0);
+      return true;
     } else {
+      if (FOLLY_UNLIKELY(!std::isfinite(seconds))) {
+        return false;
+      }
+
       // Cast to double and check bounds to prevent ensuing overflow.
       const double secondsD = static_cast<double>(seconds);
 
       if (secondsD >= kMaxSecondsD) {
         result = Timestamp(kMaxSeconds, kMaxNanoseconds);
-        return;
-      }
-      if (secondsD <= kMinSecondsD) {
+      } else if (secondsD <= kMinSecondsD) {
         result = Timestamp(kMinSeconds, kMinNanoseconds);
-        return;
-      }
-
-      // Scale to microseconds and truncate toward zero.
-      const double microsD = secondsD * Timestamp::kMicrosecondsInSecond;
-      const int64_t micros = static_cast<int64_t>(microsD);
-
-      // Split into whole seconds and remaining microseconds.
-      int64_t wholeSeconds = micros / util::kMicrosPerSec;
-      int64_t remainingMicros = micros % util::kMicrosPerSec;
-      if (remainingMicros < 0) {
-        wholeSeconds -= 1;
-        remainingMicros += util::kMicrosPerSec;
+      } else {
+        // Scale to microseconds and truncate toward zero.
+        const double microsD = secondsD * Timestamp::kMicrosecondsInSecond;
+        const int64_t micros = static_cast<int64_t>(microsD);
+
+        // Split into whole seconds and remaining microseconds.
+        int64_t wholeSeconds = micros / Timestamp::kMicrosecondsInSecond;
+        int64_t remainingMicros = micros % Timestamp::kMicrosecondsInSecond;
+        if (remainingMicros < 0) {
+          wholeSeconds -= 1;
+          remainingMicros += Timestamp::kMicrosecondsInSecond;
+        }
+
+        const int64_t nano =
+            remainingMicros * Timestamp::kNanosecondsInMicrosecond;
+        result = Timestamp(wholeSeconds, nano);
       }
-
-      const int64_t nano =
-          remainingMicros * Timestamp::kNanosecondsInMicrosecond;
-      result = Timestamp(wholeSeconds, nano);
+      return true;
     }
   }
 
@@ -1050,11 +1099,12 @@ template <typename T>
 struct TimestampAddFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
+  template <typename TInput>
   FOLLY_ALWAYS_INLINE void initialize(
       const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& config,
       const arg_type<Varchar>* unitString,
-      const int32_t* /*value*/,
+      const TInput* /*value*/,
       const arg_type<Timestamp>* /*timestamp*/) {
     VELOX_USER_CHECK_NOT_NULL(unitString);
     std::string unitStr(*unitString);
@@ -1068,10 +1118,11 @@ struct TimestampAddFunction {
     sessionTimeZone_ = getTimeZoneFromConfig(config);
   }
 
+  template <typename TInput>
   FOLLY_ALWAYS_INLINE void call(
       out_type<Timestamp>& result,
       const arg_type<Varchar>& /*unitString*/,
-      const int32_t value,
+      const TInput value,
       const arg_type<Timestamp>& timestamp) {
     const auto unit = unit_.value();
     result = addToTimestamp(unit, value, timestamp, sessionTimeZone_);
@@ -1082,4 +1133,125 @@ struct TimestampAddFunction {
   std::optional<DateTimeUnit> unit_ = std::nullopt;
 };
 
+template <typename TExec>
+struct MonthsBetweenFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config,
+      const arg_type<Timestamp>* /*timestamp1*/,
+      const arg_type<Timestamp>* /*timestamp2*/,
+      const arg_type<bool>* /*roundOff*/) {
+    sessionTimeZone_ = getTimeZoneFromConfig(config);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<double>& result,
+      const arg_type<Timestamp>& timestamp1,
+      const arg_type<Timestamp>& timestamp2,
+      const arg_type<bool>& roundOff) {
+    const auto dateTime1 = getDateTime(timestamp1, sessionTimeZone_);
+    const auto dateTime2 = getDateTime(timestamp2, sessionTimeZone_);
+    result = monthsBetween(dateTime1, dateTime2, roundOff);
+  }
+
+ private:
+  FOLLY_ALWAYS_INLINE bool isEndDayOfMonth(const std::tm& tm) {
+    return tm.tm_mday == util::getMaxDayOfMonth(getYear(tm), getMonth(tm));
+  }
+
+  FOLLY_ALWAYS_INLINE double
+  monthsBetween(const std::tm& tm1, const std::tm& tm2, bool roundOff) {
+    const double monthDiff =
+        (tm1.tm_year - tm2.tm_year) * kMonthInYear + tm1.tm_mon - tm2.tm_mon;
+    if (tm1.tm_mday == tm2.tm_mday ||
+        (isEndDayOfMonth(tm1) && isEndDayOfMonth(tm2))) {
+      return monthDiff;
+    }
+    const auto secondsInDay1 = tm1.tm_hour * kSecondsInHour +
+        tm1.tm_min * kSecondsInMinute + tm1.tm_sec;
+    const auto secondsInDay2 = tm2.tm_hour * kSecondsInHour +
+        tm2.tm_min * kSecondsInMinute + tm2.tm_sec;
+    const auto secondsDiff = (tm1.tm_mday - tm2.tm_mday) * kSecondsInDay +
+        secondsInDay1 - secondsInDay2;
+    const auto diff =
+        monthDiff + static_cast<double>(secondsDiff) / kSecondsInMonth;
+    if (roundOff) {
+      return round(diff * kRoundingPrecision) / kRoundingPrecision;
+    }
+    return diff;
+  }
+
+  // Precision factor for 8 decimal places rounding.
+  static constexpr int64_t kRoundingPrecision = 1e8;
+  static constexpr int64_t kSecondsInMonth = kSecondsInDay * 31;
+  const tz::TimeZone* sessionTimeZone_ = nullptr;
+};
+
+template <typename T>
+struct DateFormatFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config,
+      const arg_type<Timestamp>* /*timestamp*/,
+      const arg_type<Varchar>* formatString) {
+    legacyFormatter_ = config.sparkLegacyDateFormatter();
+    sessionTimeZone_ = getTimeZoneFromConfig(config);
+    if (formatString != nullptr) {
+      auto formatter = detail::initializeFormatter(
+          std::string_view(*formatString), legacyFormatter_);
+      if (formatter) {
+        formatter_ = formatter;
+        maxResultSize_ = formatter_->maxResultSize(sessionTimeZone_);
+      } else {
+        invalidFormat_ = true;
+      }
+      isConstFormat_ = true;
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Varchar>& result,
+      const arg_type<Timestamp>& timestamp,
+      const arg_type<Varchar>& formatString) {
+    if (invalidFormat_) {
+      return false;
+    }
+    if (!isConstFormat_) {
+      auto formatter = detail::initializeFormatter(
+          std::string_view(formatString), legacyFormatter_);
+      if (!formatter) {
+        return false;
+      }
+      formatter_ = formatter;
+      maxResultSize_ = formatter_->maxResultSize(sessionTimeZone_);
+    }
+
+    format(timestamp, sessionTimeZone_, maxResultSize_, result);
+    return true;
+  }
+
+ private:
+  FOLLY_ALWAYS_INLINE void format(
+      const Timestamp& timestamp,
+      const tz::TimeZone* timeZone,
+      uint32_t maxResultSize,
+      out_type<Varchar>& result) const {
+    result.reserve(maxResultSize);
+    const auto resultSize =
+        formatter_->format(timestamp, timeZone, maxResultSize, result.data());
+    result.resize(resultSize);
+  }
+
+  const tz::TimeZone* sessionTimeZone_{nullptr};
+  std::shared_ptr<DateTimeFormatter> formatter_;
+  bool isConstFormat_{false};
+  bool legacyFormatter_{false};
+  bool invalidFormat_{false};
+  uint32_t maxResultSize_;
+};
+
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/DecimalArithmetic.cpp b/velox/functions/sparksql/DecimalArithmetic.cpp
index 26fb694b1fe..6a26142f3c0 100644
--- a/velox/functions/sparksql/DecimalArithmetic.cpp
+++ b/velox/functions/sparksql/DecimalArithmetic.cpp
@@ -181,7 +181,14 @@ struct DecimalAddSubtractBase {
 
     // Scale up the whole part and scale down the fraction part to combine them.
     fraction = reduceScale(TResult(fraction), higherScale - rScale);
-    const auto whole = TResult(aWhole) + TResult(bWhole) + TResult(carryToLeft);
+    // Use __builtin_add_overflow to avoid undefined behavior from signed
+    // integer overflow when both whole parts are large.
+    TResult whole;
+    if (__builtin_add_overflow(TResult(aWhole), TResult(bWhole), &whole) ||
+        __builtin_add_overflow(whole, TResult(carryToLeft), &whole)) {
+      overflow = true;
+      return 0;
+    }
     return decimalAddResult(whole, TResult(fraction), rScale, overflow);
   }
 
@@ -328,6 +335,50 @@ struct DecimalSubtractFunction : DecimalAddSubtractBase {
   }
 };
 
+// Decimal add function that returns error on overflow.
+template <typename TExec, bool allowPrecisionLoss>
+struct CheckedDecimalAddFunction : DecimalAddSubtractBase {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename A, typename B>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      A* /*a*/,
+      B* /*b*/) {
+    initializeBase<allowPrecisionLoss>(inputTypes);
+  }
+
+  template <typename R, typename A, typename B>
+  Status call(R& out, const A& a, const B& b) {
+    bool valid = applyAdd<R, A, B>(out, a, b);
+    VELOX_USER_RETURN(!valid, "Decimal overflow in add");
+    return Status::OK();
+  }
+};
+
+// Decimal subtract function that returns error on overflow.
+template <typename TExec, bool allowPrecisionLoss>
+struct CheckedDecimalSubtractFunction : DecimalAddSubtractBase {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename A, typename B>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      A* /*a*/,
+      B* /*b*/) {
+    initializeBase<allowPrecisionLoss>(inputTypes);
+  }
+
+  template <typename R, typename A, typename B>
+  Status call(R& out, const A& a, const B& b) {
+    bool valid = applyAdd<R, A, B>(out, a, B(-b));
+    VELOX_USER_RETURN(!valid, "Decimal overflow in subtract");
+    return Status::OK();
+  }
+};
+
 template <typename TExec, bool allowPrecisionLoss>
 struct DecimalMultiplyFunction {
   VELOX_DEFINE_FUNCTION_TYPES(TExec);
@@ -442,6 +493,21 @@ struct DecimalMultiplyFunction {
   int32_t deltaScale_;
 };
 
+// Decimal multiply function that returns error on overflow.
+template <typename TExec, bool allowPrecisionLoss>
+struct CheckedDecimalMultiplyFunction
+    : DecimalMultiplyFunction<TExec, allowPrecisionLoss> {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename R, typename A, typename B>
+  Status call(R& out, const A& a, const B& b) {
+    bool valid = DecimalMultiplyFunction<TExec, allowPrecisionLoss>::
+        template call<R, A, B>(out, a, b);
+    VELOX_USER_RETURN(!valid, "Decimal overflow in multiply");
+    return Status::OK();
+  }
+};
+
 template <typename TExec, bool allowPrecisionLoss>
 struct DecimalDivideFunction {
   VELOX_DEFINE_FUNCTION_TYPES(TExec);
@@ -455,7 +521,8 @@ struct DecimalDivideFunction {
     auto [aPrecision, aScale] = getDecimalPrecisionScale(*inputTypes[0]);
     auto [bPrecision, bScale] = getDecimalPrecisionScale(*inputTypes[1]);
     auto [rPrecision, rScale] =
-        computeResultPrecisionScale(aPrecision, aScale, bPrecision, bScale);
+        DecimalUtil::computeDivideResultPrecisionScale<allowPrecisionLoss>(
+            aPrecision, aScale, bPrecision, bScale);
     rPrecision_ = rPrecision;
     aRescale_ = rScale - aScale + bScale;
   }
@@ -469,36 +536,116 @@ struct DecimalDivideFunction {
   }
 
  private:
-  // When allowing precision loss, computes the result precision and scale
-  // following Hive's formulas. When denying precision loss, calculates the
-  // number of whole digits and fraction digits. If the total number of digits
-  // exceed 38, we reduce both the number of fraction digits and whole digits to
-  // fit within this limit.
-  static std::pair<uint8_t, uint8_t> computeResultPrecisionScale(
-      uint8_t aPrecision,
-      uint8_t aScale,
-      uint8_t bPrecision,
-      uint8_t bScale) {
-    if constexpr (allowPrecisionLoss) {
-      auto scale = std::max(6, aScale + bPrecision + 1);
-      auto precision = aPrecision - aScale + bScale + scale;
-      return DecimalUtil::adjustPrecisionScale(precision, scale);
-    } else {
-      auto wholeDigits = std::min(38, aPrecision - aScale + bScale);
-      auto fractionDigits = std::min(38, std::max(6, aScale + bPrecision + 1));
-      auto diff = (wholeDigits + fractionDigits) - 38;
-      if (diff > 0) {
-        fractionDigits -= diff / 2 + 1;
-        wholeDigits = 38 - fractionDigits;
-      }
-      return DecimalUtil::bounded(wholeDigits + fractionDigits, fractionDigits);
+  uint8_t aRescale_;
+  uint8_t rPrecision_;
+};
+
+// Decimal integral divide function implementation.
+struct DecimalIntegralDivideBase {
+  void initializeBase(const std::vector<TypePtr>& inputTypes) {
+    auto [aPrecision, aScale] = getDecimalPrecisionScale(*inputTypes[0]);
+    auto bScale = getDecimalPrecisionScale(*inputTypes[1]).second;
+    rPrecision_ = computeResultPrecision(aPrecision, aScale, bScale);
+    aRescale_ = std::max<int8_t>(0, bScale - aScale);
+    bRescale_ = std::max<int8_t>(0, aScale - bScale);
+  }
+
+  // Computes the quotient of 'a' and 'b' and stores it in 'out'. Returns false
+  // if the result exceeds rPrecision_ or if overflow occurs during scaling.
+  // Following Spark's behavior, the result is truncated to int64_t if it
+  // exceeds int64_t range.
+  template <typename A, typename B>
+  bool computeQuotient(int64_t& out, const A& a, const B& b) {
+    // Determine sign and convert to absolute values.
+    bool isNegative = (a < 0) != (b < 0);
+    int128_t absA = static_cast<int128_t>(a < 0 ? -a : a);
+    int128_t absB = static_cast<int128_t>(b < 0 ? -b : b);
+
+    // Scale values, checking for overflow.
+    int128_t scaledA;
+    int128_t scaledB;
+    if (__builtin_mul_overflow(
+            absA, velox::DecimalUtil::kPowersOfTen[aRescale_], &scaledA) ||
+        __builtin_mul_overflow(
+            absB, velox::DecimalUtil::kPowersOfTen[bRescale_], &scaledB)) {
+      return false;
     }
+
+    if (scaledA < scaledB) {
+      out = 0;
+      return true;
+    }
+
+    int128_t quotient = scaledA / scaledB;
+    quotient = isNegative ? -quotient : quotient;
+
+    if (!velox::DecimalUtil::valueInPrecisionRange(quotient, rPrecision_)) {
+      return false;
+    }
+    out = static_cast<int64_t>(quotient);
+    return true;
   }
 
+ private:
+  static uint8_t
+  computeResultPrecision(uint8_t aPrecision, uint8_t aScale, uint8_t bScale) {
+    auto intPrecision = aPrecision - aScale + bScale;
+    if (intPrecision == 0) {
+      intPrecision = 1;
+    }
+    return DecimalUtil::bounded(intPrecision, 0).first;
+  }
+
+ protected:
   uint8_t aRescale_;
+  uint8_t bRescale_;
   uint8_t rPrecision_;
 };
 
+// Decimal integral divide function that returns null on division by zero or
+// overflow.
+template <typename TExec>
+struct DecimalIntegralDivideFunction : DecimalIntegralDivideBase {
+  template <typename A, typename B>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      A* /*a*/,
+      B* /*b*/) {
+    initializeBase(inputTypes);
+  }
+
+  template <typename A, typename B>
+  bool call(int64_t& out, const A& a, const B& b) {
+    if (b == 0) {
+      return false;
+    }
+    return computeQuotient(out, a, b);
+  }
+};
+
+// Decimal integral divide function that returns error on division by zero or
+// overflow.
+template <typename TExec>
+struct CheckedDecimalIntegralDivideFunction : DecimalIntegralDivideBase {
+  template <typename A, typename B>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      A* /*a*/,
+      B* /*b*/) {
+    initializeBase(inputTypes);
+  }
+
+  template <typename A, typename B>
+  Status call(int64_t& out, const A& a, const B& b) {
+    VELOX_USER_RETURN_EQ(b, 0, "Division by zero");
+    VELOX_USER_RETURN(
+        !computeQuotient(out, a, b), "Overflow in integral divide");
+    return Status::OK();
+  }
+};
+
 template <template <class> typename Func>
 void registerDecimalBinary(
     const std::string& name,
@@ -605,6 +752,30 @@ using DivideFunctionAllowPrecisionLoss = DecimalDivideFunction<TExec, true>;
 template <typename TExec>
 using DivideFunctionDenyPrecisionLoss = DecimalDivideFunction<TExec, false>;
 
+template <typename TExec>
+using CheckedAddFunctionAllowPrecisionLoss =
+    CheckedDecimalAddFunction<TExec, true>;
+
+template <typename TExec>
+using CheckedAddFunctionDenyPrecisionLoss =
+    CheckedDecimalAddFunction<TExec, false>;
+
+template <typename TExec>
+using CheckedSubtractFunctionAllowPrecisionLoss =
+    CheckedDecimalSubtractFunction<TExec, true>;
+
+template <typename TExec>
+using CheckedSubtractFunctionDenyPrecisionLoss =
+    CheckedDecimalSubtractFunction<TExec, false>;
+
+template <typename TExec>
+using CheckedMultiplyFunctionAllowPrecisionLoss =
+    CheckedDecimalMultiplyFunction<TExec, true>;
+
+template <typename TExec>
+using CheckedMultiplyFunctionDenyPrecisionLoss =
+    CheckedDecimalMultiplyFunction<TExec, false>;
+
 std::vector<exec::SignatureVariable> getDivideConstraintsDenyPrecisionLoss() {
   std::string wholeDigits = fmt::format(
       "min(38, {a_precision} - {a_scale} + {b_scale})",
@@ -672,6 +843,25 @@ void registerDecimalDivide(
       LongDecimal<P1, S1>,
       ShortDecimal<P2, S2>>({functionName}, constraints);
 }
+
+template <template <class> typename Func>
+void registerIntegralDecimalDivide(const std::string& functionName) {
+  // (short, short) -> int64_t
+  registerFunction<Func, int64_t, ShortDecimal<P1, S1>, ShortDecimal<P2, S2>>(
+      {functionName});
+
+  // (long, long) -> int64_t
+  registerFunction<Func, int64_t, LongDecimal<P1, S1>, LongDecimal<P2, S2>>(
+      {functionName});
+
+  // (short, long) -> int64_t
+  registerFunction<Func, int64_t, ShortDecimal<P1, S1>, LongDecimal<P2, S2>>(
+      {functionName});
+
+  // (long, short) -> int64_t
+  registerFunction<Func, int64_t, LongDecimal<P1, S1>, ShortDecimal<P2, S2>>(
+      {functionName});
+}
 } // namespace
 
 void registerDecimalAdd(const std::string& prefix) {
@@ -681,6 +871,11 @@ void registerDecimalAdd(const std::string& prefix) {
   registerDecimalBinary<AddFunctionDenyPrecisionLoss>(
       prefix + "add" + kDenyPrecisionLoss,
       makeConstraints(rPrecision, rScale, false));
+  registerDecimalBinary<CheckedAddFunctionAllowPrecisionLoss>(
+      prefix + "checked_add", makeConstraints(rPrecision, rScale, true));
+  registerDecimalBinary<CheckedAddFunctionDenyPrecisionLoss>(
+      prefix + "checked_add" + kDenyPrecisionLoss,
+      makeConstraints(rPrecision, rScale, false));
 }
 
 void registerDecimalSubtract(const std::string& prefix) {
@@ -690,6 +885,11 @@ void registerDecimalSubtract(const std::string& prefix) {
   registerDecimalBinary<SubtractFunctionDenyPrecisionLoss>(
       prefix + "subtract" + kDenyPrecisionLoss,
       makeConstraints(rPrecision, rScale, false));
+  registerDecimalBinary<CheckedSubtractFunctionAllowPrecisionLoss>(
+      prefix + "checked_subtract", makeConstraints(rPrecision, rScale, true));
+  registerDecimalBinary<CheckedSubtractFunctionDenyPrecisionLoss>(
+      prefix + "checked_subtract" + kDenyPrecisionLoss,
+      makeConstraints(rPrecision, rScale, false));
 }
 
 void registerDecimalMultiply(const std::string& prefix) {
@@ -706,6 +906,11 @@ void registerDecimalMultiply(const std::string& prefix) {
   registerDecimalBinary<MultiplyFunctionDenyPrecisionLoss>(
       prefix + "multiply" + kDenyPrecisionLoss,
       makeConstraints(rPrecision, rScale, false));
+  registerDecimalBinary<CheckedMultiplyFunctionAllowPrecisionLoss>(
+      prefix + "checked_multiply", makeConstraints(rPrecision, rScale, true));
+  registerDecimalBinary<CheckedMultiplyFunctionDenyPrecisionLoss>(
+      prefix + "checked_multiply" + kDenyPrecisionLoss,
+      makeConstraints(rPrecision, rScale, false));
 }
 
 void registerDecimalDivide(const std::string& prefix) {
@@ -715,4 +920,10 @@ void registerDecimalDivide(const std::string& prefix) {
       prefix + "divide" + kDenyPrecisionLoss,
       getDivideConstraintsDenyPrecisionLoss());
 }
+
+void registerDecimalIntegralDivide(const std::string& prefix) {
+  registerIntegralDecimalDivide<DecimalIntegralDivideFunction>(prefix + "div");
+  registerIntegralDecimalDivide<CheckedDecimalIntegralDivideFunction>(
+      prefix + "checked_div");
+}
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/DecimalArithmetic.h b/velox/functions/sparksql/DecimalArithmetic.h
index f1a94ce01a9..a6f8ff77d30 100644
--- a/velox/functions/sparksql/DecimalArithmetic.h
+++ b/velox/functions/sparksql/DecimalArithmetic.h
@@ -27,4 +27,6 @@ void registerDecimalMultiply(const std::string& prefix);
 
 void registerDecimalDivide(const std::string& prefix);
 
+void registerDecimalIntegralDivide(const std::string& prefix);
+
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/DecimalUtil.h b/velox/functions/sparksql/DecimalUtil.h
index 3b339cb6c7c..62d8d43f48f 100644
--- a/velox/functions/sparksql/DecimalUtil.h
+++ b/velox/functions/sparksql/DecimalUtil.h
@@ -210,6 +210,33 @@ class DecimalUtil {
     }
   }
 
+  /// When allowing precision loss, computes the result precision and scale
+  /// following Hive's formulas. When denying precision loss, calculates the
+  /// number of whole digits and fraction digits. If the total number of digits
+  /// exceed 38, we reduce both the number of fraction digits and whole digits
+  /// to fit within this limit.
+  template <bool allowPrecisionLoss>
+  static std::pair<uint8_t, uint8_t> computeDivideResultPrecisionScale(
+      uint8_t aPrecision,
+      uint8_t aScale,
+      uint8_t bPrecision,
+      uint8_t bScale) {
+    if constexpr (allowPrecisionLoss) {
+      auto scale = std::max(6, aScale + bPrecision + 1);
+      auto precision = aPrecision - aScale + bScale + scale;
+      return adjustPrecisionScale(precision, scale);
+    } else {
+      auto wholeDigits = std::min(38, aPrecision - aScale + bScale);
+      auto fractionDigits = std::min(38, std::max(6, aScale + bPrecision + 1));
+      auto diff = (wholeDigits + fractionDigits) - 38;
+      if (diff > 0) {
+        fractionDigits -= diff / 2 + 1;
+        wholeDigits = 38 - fractionDigits;
+      }
+      return bounded(wholeDigits + fractionDigits, fractionDigits);
+    }
+  }
+
   /// This method is used when the function is registered with
   /// ``allowPrecisionLoss`` being false. Caps precision and scale at 38.
   static std::pair<uint8_t, uint8_t> bounded(
diff --git a/velox/functions/sparksql/FilterFunction.cpp b/velox/functions/sparksql/FilterFunction.cpp
new file mode 100644
index 00000000000..5a8dc989feb
--- /dev/null
+++ b/velox/functions/sparksql/FilterFunction.cpp
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/lib/FilterFunctionBase.h"
+#include "velox/functions/sparksql/LambdaIndexUtil.h"
+
+namespace facebook::velox::functions::sparksql {
+namespace {
+
+/// Spark's filter function supports both signatures:
+/// 1. filter(array, x -> predicate) - element only
+/// 2. filter(array, (x, i) -> predicate) - element + index (Spark-specific)
+///
+/// See Spark documentation:
+/// https://spark.apache.org/docs/latest/api/sql/index.html#filter
+class FilterFunction : public ArrayFilterFunctionBase {
+ public:
+  /// Returns both base signature and Spark-specific signature with index.
+  static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
+    auto sigs = ArrayFilterFunctionBase::signatures();
+    // Add Spark-specific signature: array(T), function(T, integer, boolean) ->
+    // array(T). Spark uses IntegerType (32-bit) for the index parameter.
+    sigs.push_back(
+        exec::FunctionSignatureBuilder()
+            .typeVariable("T")
+            .returnType("array(T)")
+            .argumentType("array(T)")
+            .argumentType("function(T,integer,boolean)")
+            .build());
+    return sigs;
+  }
+
+ private:
+  // Adds index vector to lambda arguments if the lambda expects it.
+  void addIndexVector(
+      const std::vector<VectorPtr>& args,
+      const ArrayVectorPtr& flatArray,
+      vector_size_t numElements,
+      exec::EvalCtx& context,
+      std::vector<VectorPtr>& lambdaArgs) const override {
+    // Check the lambda function type to see if it expects 2 input arguments.
+    // function(T, boolean) has 2 children (input T, output boolean) -> 1 arg.
+    // function(T, integer, boolean) has 3 children -> 2 args (element + index).
+    if (args[1]->type()->size() == 3) {
+      lambdaArgs.push_back(
+          createIndexVector(flatArray, numElements, context.pool()));
+    }
+  }
+};
+
+} // namespace
+
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
+    udf_spark_filter,
+    FilterFunction::signatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
+    std::make_unique<FilterFunction>());
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/GetJsonObject.h b/velox/functions/sparksql/GetJsonObject.h
index 638ed744f48..e0d11f5f5e0 100644
--- a/velox/functions/sparksql/GetJsonObject.h
+++ b/velox/functions/sparksql/GetJsonObject.h
@@ -16,7 +16,10 @@
 
 #pragma once
 
-#include <boost/regex.hpp>
+#include <folly/Likely.h>
+#include <cstring>
+
+#include "velox/core/QueryConfig.h"
 #include "velox/functions/Macros.h"
 #include "velox/functions/lib/JsonUtil.h"
 #include "velox/functions/prestosql/json/SIMDJsonUtil.h"
@@ -24,6 +27,147 @@
 
 namespace facebook::velox::functions::sparksql {
 
+namespace detail {
+// Normalizes the JSON path to be Spark-compatible.
+//
+// Rules applied:
+// 1. Removes single quotes in bracket notation (e.g., "$['a']" -> "$[a]").
+// 2. Removes spaces after dots (e.g., "$. a" -> "$.a").
+// 3. Removes trailing spaces after root symbol (e.g., "$ " -> "$").
+// 4. Invalid cases return "-1":
+//    - Empty path or path not starting with '$'.
+//    - Space between ($ or ]) and dot (e.g., "$ .a").
+//    - Space between [ and field name (e.g., "$[' a']").
+//    - Consecutive dots (e.g., "$..a").
+//    - Dot at the end (e.g., "$.a. ").
+class JsonPathNormalizer {
+ public:
+  // The state transitions: kAfterDollar --> kAfterDot <--> kToken
+  //                            |               /|\            |
+  //                            |                |             |
+  //                            |----> kInSquareBrackets <-----|
+  enum class State { kAfterDollar, kAfterDot, kToken, kInSquareBrackets };
+
+  std::string normalize(StringView jsonPath) {
+    // First, remove single quotes for bracket notation
+    std::string path = removeSingleQuotes(jsonPath);
+    if (path.empty() || path[0] != '$') {
+      return "-1";
+    }
+    std::string normalized;
+    normalized.reserve(path.size() - 1);
+
+    // Initialize state.
+    state_ = State::kAfterDollar;
+    for (size_t i = 1; i < path.size(); ++i) {
+      const char c = path[i];
+      if (c == ' ') {
+        if (state_ == State::kToken || state_ == State::kInSquareBrackets) {
+          // Spaces within tokens and quare brackets are preserved.
+          normalized.push_back(c);
+        }
+        continue;
+      }
+      switch (state_) {
+        case State::kAfterDollar: {
+          if (!tryConvertToAfterDot(c, path[i - 1])) {
+            return "-1";
+          }
+          // i + 1 is safe because removeSingleQuotes ensures at least one
+          // char (']') after.
+          if (!tryConvertToInSquareBrackets(c, path[i + 1])) {
+            return "-1";
+          }
+          break;
+        }
+        case State::kAfterDot: {
+          if (c == '.') {
+            // Consecutive dots are invalid.
+            return "-1";
+          }
+          state_ = State::kToken;
+          break;
+        }
+        case State::kToken: {
+          if (c == '.') {
+            state_ = State::kAfterDot;
+          } else if (!tryConvertToInSquareBrackets(c, path[i + 1])) {
+            return "-1";
+          }
+          break;
+        }
+        case State::kInSquareBrackets: {
+          if (!tryConvertToAfterDot(c, path[i - 1])) {
+            return "-1";
+          }
+          break;
+        }
+      }
+      normalized.push_back(c);
+    }
+
+    if (state_ == State::kAfterDot) {
+      // Trailing dot is invalid.
+      return "-1";
+    }
+
+    return normalized;
+  }
+
+ private:
+  // Spark's json path requires field name surrounded by single quotes if it is
+  // specified in "[]". But simdjson lib requires not. This method just removes
+  // such single quotes to adapt to simdjson lib, e.g., converts "['a']['b']" to
+  // "[a][b]".
+  std::string removeSingleQuotes(StringView jsonPath) {
+    std::string result(jsonPath.data(), jsonPath.size());
+    size_t pairEnd = 0;
+    while (true) {
+      auto pairBegin = result.find("['", pairEnd);
+      if (pairBegin == std::string::npos) {
+        break;
+      }
+      pairEnd = result.find(']', pairBegin);
+      // If expected pattern, like ['a'], is not found.
+      if (pairEnd == std::string::npos || result[pairEnd - 1] != '\'') {
+        return "-1";
+      }
+      result.erase(pairEnd - 1, 1);
+      result.erase(pairBegin + 1, 1);
+      pairEnd -= 2;
+    }
+    return result;
+  }
+
+  // Try to convert state to kAfterDot if currentChar is '.'.
+  bool tryConvertToAfterDot(char currentChar, char previousChar) {
+    if (currentChar == '.') {
+      if (previousChar == ' ' && state_ != State::kToken) {
+        // Spaces before '.' are invalid.
+        return false;
+      }
+      state_ = State::kAfterDot;
+    }
+    return true;
+  }
+
+  // Try to convert state to kInSquareBrackets if currentChar is '['.
+  bool tryConvertToInSquareBrackets(char currentChar, char nextChar) {
+    if (currentChar == '[') {
+      if (nextChar == ' ') {
+        // Spaces between '[' and field are invalid.
+        return false;
+      }
+      state_ = State::kInSquareBrackets;
+    }
+    return true;
+  }
+
+  State state_{State::kAfterDollar};
+};
+
+} // namespace detail
+
 /// Parses a JSON string and returns the value at the specified path.
 /// Simdjson On-Demand API is used to parse JSON string.
 /// get_json_object(jsonString, path) -> value
@@ -40,7 +184,7 @@ struct GetJsonObjectFunction {
       const arg_type<Varchar>* /*json*/,
       const arg_type<Varchar>* jsonPath) {
     if (jsonPath != nullptr && checkJsonPath(*jsonPath)) {
-      jsonPath_ = normalizeJsonPath(*jsonPath);
+      jsonPath_ = pathNormalizer_.normalize(*jsonPath);
     }
   }
 
@@ -52,8 +196,15 @@ struct GetJsonObjectFunction {
     if (!checkJsonPath(jsonPath)) {
       return false;
     }
+    // Check if json has invalid escape sequence.
+    if (hasInvalidEscapedChar(json.data(), json.size())) {
+      return false;
+    }
+    const auto formattedJsonPath = jsonPath_.has_value()
+        ? jsonPath_.value()
+        : pathNormalizer_.normalize(jsonPath);
     // jsonPath is "$".
-    if (jsonPath.size() == 1) {
+    if (formattedJsonPath.empty()) {
       result.append(json);
       return true;
     }
@@ -62,8 +213,6 @@ struct GetJsonObjectFunction {
     if (simdjsonParseIncomplete(paddedJson).get(jsonDoc)) {
       return false;
     }
-    const auto formattedJsonPath =
-        jsonPath_.has_value() ? jsonPath_.value() : normalizeJsonPath(jsonPath);
     try {
       // Can return error result or throw exception possibly.
       auto rawResult = jsonDoc.at_path(formattedJsonPath);
@@ -89,51 +238,7 @@ struct GetJsonObjectFunction {
  private:
   FOLLY_ALWAYS_INLINE bool checkJsonPath(StringView jsonPath) {
     // Spark requires the first char in jsonPath is '$'.
-    if (jsonPath.empty() || jsonPath.data()[0] != '$') {
-      return false;
-    }
-    return true;
-  }
-
-  // Spark's json path requires field name surrounded by single quotes if it is
-  // specified in "[]". But simdjson lib requires not. This method just removes
-  // such single quotes to adapt to simdjson lib, e.g., converts "['a']['b']" to
-  // "[a][b]".
-  std::string removeSingleQuotes(StringView jsonPath) {
-    // Skip the initial "$".
-    std::string result(jsonPath.data() + 1, jsonPath.size() - 1);
-    size_t pairEnd = 0;
-    while (true) {
-      auto pairBegin = result.find("['", pairEnd);
-      if (pairBegin == std::string::npos) {
-        break;
-      }
-      pairEnd = result.find("]", pairBegin);
-      // If expected pattern, like ['a'], is not found.
-      if (pairEnd == std::string::npos || result[pairEnd - 1] != '\'') {
-        return "-1";
-      }
-      result.erase(pairEnd - 1, 1);
-      result.erase(pairBegin + 1, 1);
-      pairEnd -= 2;
-    }
-    return result;
-  }
-
-  // Normalizes the JSON path to be Spark-compatible:
-  // - Removes single quotes in bracket notation
-  // - Removes spaces after dots (e.g., "$. a" -> "$.a")
-  std::string normalizeJsonPath(StringView jsonPath) {
-    // First, remove single quotes for bracket notation
-    const std::string& path = removeSingleQuotes(jsonPath);
-    if (path == "-1") {
-      return path;
-    }
-
-    // Use Boost regex to find and remove spaces after dots
-    // Pattern: "dot + one or more spaces" -> "dot"
-    static const boost::regex dotSpaceRegex("\\.\\s+");
-    return boost::regex_replace(path, dotSpaceRegex, ".");
+    return std::string_view{jsonPath}.starts_with('$');
   }
 
   // Extracts a string representation from a simdjson result. Handles various
@@ -190,13 +295,9 @@ struct GetJsonObjectFunction {
         }
         return false;
       }
-      case simdjson::ondemand::json_type::object: {
-        // For nested case, e.g., for "{"my": {"hello": 10}}", "$.my" will
-        // return an object type.
-        ss << rawResult;
-        result.append(ss.str());
-        return true;
-      }
+      // For nested case, e.g., for "{"my": {"hello": 10}}",
+      // "$.my" will return an object type.
+      case simdjson::ondemand::json_type::object:
       case simdjson::ondemand::json_type::array: {
         ss << rawResult;
         result.append(ss.str());
@@ -225,8 +326,68 @@ struct GetJsonObjectFunction {
     return false;
   }
 
+  // Checks for invalid escape sequences in JSON string.
+  // Note: We only search for '\' which is ASCII (0x5C) and cannot appear
+  // as a continuation byte in valid UTF-8 (continuation bytes are 0x80-0xBF).
+  // So we can safely scan byte-by-byte regardless of encoding.
+  // See the valid escape sequences in Jackson's JSON parser:
+  // https://github.com/FasterXML/jackson-core/blob/jackson-core-2.19.2/src/main/java/com/fasterxml/jackson/core/json/ReaderBasedJsonParser.java#L2648
+  FOLLY_ALWAYS_INLINE bool hasInvalidEscapedChar(
+      const char* json,
+      size_t size) {
+    const char* end = json + size;
+    const char* pos = json;
+
+    while ((pos = static_cast<const char*>(std::memchr(
+                pos, '\\', static_cast<size_t>(end - pos)))) != nullptr) {
+      const auto remaining = static_cast<size_t>(end - pos);
+      if (FOLLY_UNLIKELY(remaining < 2)) {
+        return false; // Incomplete escape at end, let parser handle it.
+      }
+
+      switch (pos[1]) {
+        case '"':
+          [[fallthrough]];
+        case '\\':
+          [[fallthrough]];
+        case '/':
+          [[fallthrough]];
+        case 'b':
+          [[fallthrough]];
+        case 'f':
+          [[fallthrough]];
+        case 'n':
+          [[fallthrough]];
+        case 'r':
+          [[fallthrough]];
+        case 't':
+          pos += 2;
+          break;
+        case 'u':
+          // Validate \uXXXX.
+          if (FOLLY_UNLIKELY(remaining < 6) || !isHexDigit(pos[2]) ||
+              !isHexDigit(pos[3]) || !isHexDigit(pos[4]) ||
+              !isHexDigit(pos[5])) {
+            return true;
+          }
+          pos += 6;
+          break;
+        default:
+          return true; // Invalid escape character.
+      }
+    }
+    return false;
+  }
+
+  static FOLLY_ALWAYS_INLINE bool isHexDigit(char c) {
+    auto uc = static_cast<unsigned char>(c);
+    return (uc - '0' < 10U) || ((uc | 0x20) - 'a' < 6U);
+  }
+
   // Used for constant json path.
   std::optional<std::string> jsonPath_;
+
+  detail::JsonPathNormalizer pathNormalizer_;
 };
 
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/LambdaIndexUtil.h b/velox/functions/sparksql/LambdaIndexUtil.h
new file mode 100644
index 00000000000..63f1a4c5d32
--- /dev/null
+++ b/velox/functions/sparksql/LambdaIndexUtil.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/common/base/BitUtil.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::functions::sparksql {
+
+/// Creates an index vector where each element contains its 0-based position
+/// within its respective array. For example, if we have arrays [a, b] and
+/// [c, d, e], the index vector will be [0, 1, 0, 1, 2].
+/// Spark uses IntegerType (32-bit) for the index parameter.
+inline VectorPtr createIndexVector(
+    const ArrayVectorPtr& flatArray,
+    vector_size_t numElements,
+    memory::MemoryPool* pool) {
+  auto indexVector =
+      BaseVector::create<FlatVector<int32_t>>(INTEGER(), numElements, pool);
+
+  auto* rawOffsets = flatArray->rawOffsets();
+  auto* rawSizes = flatArray->rawSizes();
+  auto* rawNulls = flatArray->rawNulls();
+  auto* rawIndices = indexVector->mutableRawValues();
+
+  for (vector_size_t row = 0; row < flatArray->size(); ++row) {
+    if (rawNulls && bits::isBitNull(rawNulls, row)) {
+      continue;
+    }
+    auto offset = rawOffsets[row];
+    auto size = rawSizes[row];
+    for (vector_size_t i = 0; i < size; ++i) {
+      rawIndices[offset + i] = i;
+    }
+  }
+
+  return indexVector;
+}
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/LeastGreatest.cpp b/velox/functions/sparksql/LeastGreatest.cpp
index 24a77b0c875..926e9bec7f7 100644
--- a/velox/functions/sparksql/LeastGreatest.cpp
+++ b/velox/functions/sparksql/LeastGreatest.cpp
@@ -149,19 +149,21 @@ std::vector<std::shared_ptr<exec::FunctionSignature>> leastSignatures() {
   std::vector<std::shared_ptr<exec::FunctionSignature>> signatures;
 
   for (const auto& type : types) {
-    signatures.emplace_back(exec::FunctionSignatureBuilder()
-                                .returnType(type)
-                                .argumentType(type)
-                                .variableArity(type)
-                                .build());
+    signatures.emplace_back(
+        exec::FunctionSignatureBuilder()
+            .returnType(type)
+            .argumentType(type)
+            .variableArity(type)
+            .build());
   }
-  signatures.emplace_back(exec::FunctionSignatureBuilder()
-                              .integerVariable("p")
-                              .integerVariable("s")
-                              .returnType("decimal(p,s)")
-                              .argumentType("decimal(p,s)")
-                              .variableArity("decimal(p,s)")
-                              .build());
+  signatures.emplace_back(
+      exec::FunctionSignatureBuilder()
+          .integerVariable("p")
+          .integerVariable("s")
+          .returnType("decimal(p,s)")
+          .argumentType("decimal(p,s)")
+          .variableArity("decimal(p,s)")
+          .build());
   return signatures;
 }
 
diff --git a/velox/functions/sparksql/MakeTimestamp.cpp b/velox/functions/sparksql/MakeTimestamp.cpp
index 08286a9204c..644a18847db 100644
--- a/velox/functions/sparksql/MakeTimestamp.cpp
+++ b/velox/functions/sparksql/MakeTimestamp.cpp
@@ -32,12 +32,12 @@ std::optional<Timestamp> makeTimeStampFromDecodedArgs(
     DecodedVector* microsVector) {
   // Check hour.
   auto hour = hourVector->valueAt<int32_t>(row);
-  if (hour < 0 || hour > 24) {
+  if (hour < 0 || hour >= 24) {
     return std::nullopt;
   }
   // Check minute.
   auto minute = minuteVector->valueAt<int32_t>(row);
-  if (minute < 0 || minute > 60) {
+  if (minute < 0 || minute >= 60) {
     return std::nullopt;
   }
   // Check microseconds.
diff --git a/velox/functions/sparksql/Map.cpp b/velox/functions/sparksql/Map.cpp
index 82e18d5ddab..d1446a0ef90 100644
--- a/velox/functions/sparksql/Map.cpp
+++ b/velox/functions/sparksql/Map.cpp
@@ -159,10 +159,10 @@ class MapFunction : public exec::VectorFunction {
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
-    // For the purpose of testing we introduce up to 6 inputs
+    // Support up to 10 key-value pairs (20 arguments) for MAP() function.
     // array(K), array(V) -> map(K,V)
     std::vector<std::shared_ptr<exec::FunctionSignature>> signatures;
-    constexpr int kNumberOfSignatures = 3;
+    constexpr int kNumberOfSignatures = 10;
     signatures.reserve(kNumberOfSignatures);
     for (int i = 1; i <= kNumberOfSignatures; i++) {
       auto builder = exec::FunctionSignatureBuilder()
diff --git a/velox/functions/sparksql/Rand.h b/velox/functions/sparksql/Rand.h
index 01cf174861a..1fd02468ae7 100644
--- a/velox/functions/sparksql/Rand.h
+++ b/velox/functions/sparksql/Rand.h
@@ -15,35 +15,58 @@
  */
 #pragma once
 
+#include <folly/Random.h>
+
 #include "velox/functions/Macros.h"
+#include "velox/functions/lib/XORShiftRandom.h"
 
 namespace facebook::velox::functions::sparksql {
 
+/// Spark SQL rand([seed]) - Returns a random double in [0.0, 1.0).
+/// Uses XORShift algorithm for Spark-compatible reproducibility.
+/// Generator is initialized with (seed + sparkPartitionId) to match Spark's
+/// per-partition determinism.
+///
+/// Note: Even with a constant seed, different rows produce different outputs
+/// as the generator advances, so is_deterministic is set to false.
 template <typename T>
 struct RandFunction {
   static constexpr bool is_deterministic = false;
 
+  /// Initialize for unseeded variant: rand().
+  /// Uses a random seed from folly::Random to match Spark's behavior where
+  /// unseeded rand() generates different values across executions.
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config) {
+    const auto partitionId = config.sparkPartitionId();
+    // Use folly::Random to generate a random seed for unseeded rand().
+    int64_t seed = folly::Random::rand64();
+    generator_.setSeed(seed + partitionId);
+  }
+
+  /// Initialize for seeded variant: rand(seed).
   template <typename TInput>
   FOLLY_ALWAYS_INLINE void initialize(
       const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& config,
       const TInput* seedInput) {
     const auto partitionId = config.sparkPartitionId();
-    int64_t seed = seedInput ? (int64_t)*seedInput : 0;
-    generator_.seed(seed + partitionId);
+    int64_t seed = seedInput ? static_cast<int64_t>(*seedInput) : 0;
+    generator_.setSeed(seed + partitionId);
   }
 
   FOLLY_ALWAYS_INLINE void call(double& result) {
-    result = folly::Random::randDouble01();
+    result = generator_.nextDouble();
   }
 
   template <typename TInput>
   FOLLY_ALWAYS_INLINE void callNullable(double& result, TInput /*seedInput*/) {
-    result = folly::Random::randDouble01(generator_);
+    result = generator_.nextDouble();
   }
 
  private:
-  std::mt19937 generator_;
+  functions::XORShiftRandom generator_;
 };
 
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/RandStr.h b/velox/functions/sparksql/RandStr.h
new file mode 100644
index 00000000000..5b93a0d3158
--- /dev/null
+++ b/velox/functions/sparksql/RandStr.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cstdlib>
+
+#include "velox/core/QueryConfig.h"
+#include "velox/functions/Macros.h"
+#include "velox/functions/lib/XORShiftRandom.h"
+
+namespace facebook::velox::functions::sparksql {
+
+/// Spark SQL randstr(length, seed) - Returns a string of the specified
+/// length with characters chosen uniformly at random from 0-9, a-z, A-Z.
+/// Generator is initialized with (seed + sparkPartitionId) to match Spark's
+/// per-partition determinism using XORShift algorithm for Spark compatibility.
+///
+/// Note: Spark's analyzer always provides a seed (either user-specified or
+/// auto-generated), so only the seeded variant is needed.
+///
+/// Note: Even with a constant seed, different rows produce different outputs
+/// as the generator advances, so is_deterministic is set to false.
+template <typename T>
+struct RandStrFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  static constexpr bool is_deterministic = false;
+
+  /// Initialize for seeded variant: randstr(length, seed).
+  /// Both length and seed must be non-null constants.
+  template <typename TLen, typename TSeed>
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config,
+      const TLen* length,
+      const TSeed* seed) {
+    VELOX_USER_CHECK_NOT_NULL(
+        length, "length argument must be a constant value");
+    VELOX_USER_CHECK_NOT_NULL(seed, "seed argument must be a constant value");
+    VELOX_USER_CHECK_GE(
+        static_cast<int64_t>(*length), 0, "length must be non-negative");
+    length_ = static_cast<int32_t>(*length);
+    generator_.setSeed(static_cast<int64_t>(*seed) + config.sparkPartitionId());
+  }
+
+  /// Uses the seeded XORShift generator for Spark-compatible reproducibility.
+  /// Matches Spark's ExpressionImplUtils.randStr implementation.
+  template <typename TLen, typename TSeed>
+  FOLLY_ALWAYS_INLINE void
+  call(out_type<Varchar>& out, TLen /*length*/, TSeed /*seed*/) {
+    out.resize(length_);
+    for (auto i = 0; i < length_; ++i) {
+      // Spark uses Math.abs(rng.nextInt() % 62) to select characters.
+      int v = std::abs(generator_.nextInt() % 62);
+      if (v < 10) {
+        out.data()[i] = '0' + v;
+      } else if (v < 36) {
+        out.data()[i] = 'a' + (v - 10);
+      } else {
+        out.data()[i] = 'A' + (v - 36);
+      }
+    }
+  }
+
+ private:
+  int32_t length_{0};
+  functions::XORShiftRandom generator_;
+};
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/SequenceFunction.cpp b/velox/functions/sparksql/SequenceFunction.cpp
new file mode 100644
index 00000000000..dd2770e2766
--- /dev/null
+++ b/velox/functions/sparksql/SequenceFunction.cpp
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/lib/Sequence.h"
+
+namespace facebook::velox::functions::sparksql {
+namespace {
+
+std::vector<std::shared_ptr<exec::FunctionSignature>> sequenceSignatures() {
+  // Integer types: 2-arg (start, stop) and 3-arg (start, stop, step).
+  std::vector<std::shared_ptr<exec::FunctionSignature>> signatures = {
+      exec::FunctionSignatureBuilder()
+          .returnType("array(bigint)")
+          .argumentType("bigint")
+          .argumentType("bigint")
+          .build(),
+      exec::FunctionSignatureBuilder()
+          .returnType("array(bigint)")
+          .argumentType("bigint")
+          .argumentType("bigint")
+          .argumentType("bigint")
+          .build(),
+      exec::FunctionSignatureBuilder()
+          .returnType("array(integer)")
+          .argumentType("integer")
+          .argumentType("integer")
+          .build(),
+      exec::FunctionSignatureBuilder()
+          .returnType("array(integer)")
+          .argumentType("integer")
+          .argumentType("integer")
+          .argumentType("integer")
+          .build(),
+      exec::FunctionSignatureBuilder()
+          .returnType("array(smallint)")
+          .argumentType("smallint")
+          .argumentType("smallint")
+          .build(),
+      exec::FunctionSignatureBuilder()
+          .returnType("array(smallint)")
+          .argumentType("smallint")
+          .argumentType("smallint")
+          .argumentType("smallint")
+          .build(),
+      exec::FunctionSignatureBuilder()
+          .returnType("array(tinyint)")
+          .argumentType("tinyint")
+          .argumentType("tinyint")
+          .build(),
+      exec::FunctionSignatureBuilder()
+          .returnType("array(tinyint)")
+          .argumentType("tinyint")
+          .argumentType("tinyint")
+          .argumentType("tinyint")
+          .build(),
+  };
+  return signatures;
+}
+
+std::shared_ptr<exec::VectorFunction> makeSequence(
+    const std::string& /* name */,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& /* config */) {
+  switch (inputArgs[0].type->kind()) {
+    case TypeKind::BIGINT:
+      return std::make_shared<SequenceFunction<int64_t, int64_t>>();
+    // Use K=int64_t for INTEGER to avoid conflicting with the
+    // add<int32_t, int32_t> specialization used for date year-to-month
+    // intervals. getStep handles reading the step vector as int32_t when
+    // isDate is false.
+    case TypeKind::INTEGER:
+      return std::make_shared<SequenceFunction<int32_t, int64_t>>();
+    case TypeKind::SMALLINT:
+      return std::make_shared<SequenceFunction<int16_t, int16_t>>();
+    case TypeKind::TINYINT:
+      return std::make_shared<SequenceFunction<int8_t, int8_t>>();
+    default:
+      VELOX_UNREACHABLE(
+          "Unexpected type for Spark sequence: {}",
+          inputArgs[0].type->toString());
+  }
+}
+
+} // namespace
+
+VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
+    udf_spark_sequence,
+    sequenceSignatures(),
+    makeSequence);
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/SimpleComparisonMatcher.h b/velox/functions/sparksql/SimpleComparisonMatcher.h
new file mode 100644
index 00000000000..d754d61d0e8
--- /dev/null
+++ b/velox/functions/sparksql/SimpleComparisonMatcher.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/functions/lib/SimpleComparisonMatcher.h"
+
+namespace facebook::velox::functions::sparksql {
+
+namespace {
+inline const std::string eq = "equalto";
+inline const std::string lt = "lessthan";
+inline const std::string gt = "greaterthan";
+} // namespace
+
+class SparkComparisonMatcher : public ComparisonMatcher {
+ public:
+  SparkComparisonMatcher(
+      const std::string& prefix,
+      const std::vector<std::shared_ptr<Matcher>>& inputMatchers,
+      std::string* op)
+      : ComparisonMatcher(prefix, inputMatchers, op) {}
+
+  bool exprNameMatch(const std::string& name) override {
+    return name == prefix_ + eq || name == prefix_ + lt || name == prefix_ + gt;
+  }
+};
+
+class SparkSimpleComparisonChecker : public SimpleComparisonChecker {
+ public:
+  ~SparkSimpleComparisonChecker() override = default;
+
+ protected:
+  std::shared_ptr<Matcher> comparison(
+      const std::string& prefix,
+      const std::shared_ptr<Matcher>& left,
+      const std::shared_ptr<Matcher>& right,
+      std::string* op) override {
+    return std::make_shared<SparkComparisonMatcher>(
+        prefix, std::vector<std::shared_ptr<Matcher>>{left, right}, op);
+  }
+
+  std::string eqName(const std::string& prefix) override {
+    return prefix + eq;
+  }
+
+  std::string ltName(const std::string& prefix) override {
+    return prefix + lt;
+  }
+
+  std::string gtName(const std::string& prefix) override {
+    return prefix + gt;
+  }
+};
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/String.cpp b/velox/functions/sparksql/String.cpp
index 8e72c8614cc..4b7b47a24f3 100644
--- a/velox/functions/sparksql/String.cpp
+++ b/velox/functions/sparksql/String.cpp
@@ -18,14 +18,12 @@
 #include "velox/functions/lib/string/StringCore.h"
 
 namespace facebook::velox::functions::sparksql {
+namespace {
 
 using namespace stringCore;
-namespace {
 
 template <bool isAscii>
-int32_t instr(
-    const folly::StringPiece haystack,
-    const folly::StringPiece needle) {
+int32_t instr(const std::string_view haystack, const std::string_view needle) {
   int32_t offset = haystack.find(needle);
   if constexpr (isAscii) {
     return offset + 1;
@@ -58,13 +56,18 @@ class Instr : public exec::VectorFunction {
       selected.applyToSelected([&](vector_size_t row) {
         auto h = haystack->valueAt<StringView>(row);
         auto n = needle->valueAt<StringView>(row);
-        output->set(row, instr<true>(h, n));
+
+        // TODO: Remove explicit std::string_view cast.
+        output->set(row, instr<true>(std::string_view(h), std::string_view(n)));
       });
     } else {
       selected.applyToSelected([&](vector_size_t row) {
         auto h = haystack->valueAt<StringView>(row);
         auto n = needle->valueAt<StringView>(row);
-        output->set(row, instr<false>(h, n));
+
+        // TODO: Remove explicit std::string_view cast.
+        output->set(
+            row, instr<false>(std::string_view(h), std::string_view(n)));
       });
     }
   }
diff --git a/velox/functions/sparksql/String.h b/velox/functions/sparksql/String.h
index 46b4080db3b..40255147d31 100644
--- a/velox/functions/sparksql/String.h
+++ b/velox/functions/sparksql/String.h
@@ -167,9 +167,11 @@ struct Sha1HexStringFunction {
   void call(out_type<Varchar>& result, const arg_type<Varbinary>& input) {
     static const int kSha1Length = 20;
     result.resize(kSha1Length * 2);
+    VELOX_SUPPRESS_DEPRECATED_WARNING
     folly::ssl::OpenSSLHash::sha1(
         folly::MutableByteRange((uint8_t*)result.data(), kSha1Length),
         folly::ByteRange((const uint8_t*)input.data(), input.size()));
+    VELOX_UNSUPPRESS_DEPRECATED_WARNING
     encodeDigestToBase16((uint8_t*)result.data(), kSha1Length);
   }
 };
diff --git a/velox/functions/sparksql/ToJson.h b/velox/functions/sparksql/ToJson.h
index 8e53f2ffec1..e4b81a886e8 100644
--- a/velox/functions/sparksql/ToJson.h
+++ b/velox/functions/sparksql/ToJson.h
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#pragma once
 
 #include <vector>
 #include "velox/expression/ComplexViewTypes.h"
@@ -34,8 +35,10 @@ template <typename T>
 std::enable_if_t<std::is_floating_point_v<T>, void>
 append(T value, std::string& result, bool isMapKey) {
   if (!isMapKey && FOLLY_UNLIKELY(std::isinf(value) || std::isnan(value))) {
-    result.append(fmt::format(
-        "\"{}\"", util::Converter<TypeKind::VARCHAR>::tryCast(value).value()));
+    result.append(
+        fmt::format(
+            "\"{}\"",
+            util::Converter<TypeKind::VARCHAR>::tryCast(value).value()));
   } else {
     result.append(util::Converter<TypeKind::VARCHAR>::tryCast(value).value());
   }
@@ -91,7 +94,7 @@ void toJson(
 
 // Convert primitive-type input to Json string.
 template <>
-void toJson<TypeKind::BOOLEAN>(
+inline void toJson<TypeKind::BOOLEAN>(
     const exec::GenericView& input,
     std::string& result,
     const JsonOptions& /*options*/,
@@ -103,7 +106,7 @@ void toJson<TypeKind::BOOLEAN>(
 }
 
 template <>
-void toJson<TypeKind::TINYINT>(
+inline void toJson<TypeKind::TINYINT>(
     const exec::GenericView& input,
     std::string& result,
     const JsonOptions& /*options*/,
@@ -113,7 +116,7 @@ void toJson<TypeKind::TINYINT>(
 }
 
 template <>
-void toJson<TypeKind::SMALLINT>(
+inline void toJson<TypeKind::SMALLINT>(
     const exec::GenericView& input,
     std::string& result,
     const JsonOptions& /*options*/,
@@ -123,7 +126,7 @@ void toJson<TypeKind::SMALLINT>(
 }
 
 template <>
-void toJson<TypeKind::INTEGER>(
+inline void toJson<TypeKind::INTEGER>(
     const exec::GenericView& input,
     std::string& result,
     const JsonOptions& /*options*/,
@@ -137,7 +140,7 @@ void toJson<TypeKind::INTEGER>(
 }
 
 template <>
-void toJson<TypeKind::BIGINT>(
+inline void toJson<TypeKind::BIGINT>(
     const exec::GenericView& input,
     std::string& result,
     const JsonOptions& /*options*/,
@@ -151,7 +154,7 @@ void toJson<TypeKind::BIGINT>(
 }
 
 template <>
-void toJson<TypeKind::HUGEINT>(
+inline void toJson<TypeKind::HUGEINT>(
     const exec::GenericView& input,
     std::string& result,
     const JsonOptions& /*options*/,
@@ -162,7 +165,7 @@ void toJson<TypeKind::HUGEINT>(
 }
 
 template <>
-void toJson<TypeKind::REAL>(
+inline void toJson<TypeKind::REAL>(
     const exec::GenericView& input,
     std::string& result,
     const JsonOptions& /*options*/,
@@ -172,7 +175,7 @@ void toJson<TypeKind::REAL>(
 }
 
 template <>
-void toJson<TypeKind::DOUBLE>(
+inline void toJson<TypeKind::DOUBLE>(
     const exec::GenericView& input,
     std::string& result,
     const JsonOptions& /*options*/,
@@ -182,26 +185,26 @@ void toJson<TypeKind::DOUBLE>(
 }
 
 template <>
-void toJson<TypeKind::VARCHAR>(
+inline void toJson<TypeKind::VARCHAR>(
     const exec::GenericView& input,
     std::string& result,
     const JsonOptions& /*options*/,
     bool isMapKey) {
   auto value = input.castTo<Varchar>();
   if (!isMapKey) {
-    folly::json::escapeString(value, result, {});
+    folly::json::escapeString(std::string_view(value), result, {});
   } else {
     // toJson<TypeKind::MAP> wraps the key with double quotes.
     // To avoid duplicate quotes, we strip the surrounding quotes after
     // escaping.
     std::string quotedString;
-    folly::json::escapeString(value, quotedString, {});
+    folly::json::escapeString(std::string_view(value), quotedString, {});
     result.append(quotedString.substr(1, quotedString.size() - 2));
   }
 }
 
 template <>
-void toJson<TypeKind::TIMESTAMP>(
+inline void toJson<TypeKind::TIMESTAMP>(
     const exec::GenericView& input,
     std::string& result,
     const JsonOptions& options,
@@ -224,7 +227,7 @@ void toJson<TypeKind::TIMESTAMP>(
 
 // Convert complex-type input to Json string.
 template <>
-void toJson<TypeKind::ROW>(
+inline void toJson<TypeKind::ROW>(
     const exec::GenericView& input,
     std::string& result,
     const JsonOptions& options,
@@ -272,7 +275,7 @@ void toJson<TypeKind::ROW>(
 }
 
 template <>
-void toJson<TypeKind::ARRAY>(
+inline void toJson<TypeKind::ARRAY>(
     const exec::GenericView& input,
     std::string& result,
     const JsonOptions& options,
@@ -295,7 +298,7 @@ void toJson<TypeKind::ARRAY>(
 }
 
 template <>
-void toJson<TypeKind::MAP>(
+inline void toJson<TypeKind::MAP>(
     const exec::GenericView& input,
     std::string& result,
     const JsonOptions& options,
diff --git a/velox/functions/sparksql/ToPrettyString.h b/velox/functions/sparksql/ToPrettyString.h
new file mode 100644
index 00000000000..627e5c7aedb
--- /dev/null
+++ b/velox/functions/sparksql/ToPrettyString.h
@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <fmt/format.h>
+#include "velox/expression/CastExpr.h"
+#include "velox/functions/Udf.h"
+#include "velox/type/Conversions.h"
+#include "velox/type/Timestamp.h"
+#include "velox/type/tz/TimeZoneMap.h"
+
+namespace facebook::velox::functions::sparksql {
+namespace detail {
+static const StringView kNull = "NULL";
+}
+
+/// to_pretty_string(x) -> varchar
+/// Returns pretty string for int8, int16, int32, int64, bool, Date, Varchar. It
+/// has one difference with casting value to string:
+/// 1) It prints null input as "NULL" rather than producing null output.
+template <typename TExec>
+struct ToPrettyStringFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  // Results refer to strings in the first argument.
+  static constexpr int32_t reuse_strings_from_arg = 0;
+
+  template <typename A>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      A* /*a*/) {
+    inputType_ = inputTypes[0];
+  }
+
+  template <typename TInput>
+  Status callNullable(out_type<Varchar>& result, const TInput* input) {
+    if (input) {
+      if constexpr (std::is_same_v<TInput, StringView>) {
+        result.setNoCopy(*input);
+        return Status::OK();
+      }
+      if constexpr (std::is_same_v<TInput, int32_t>) {
+        if (inputType_->isDate()) {
+          try {
+            auto output = DATE()->toString(*input);
+            result.append(output);
+          } catch (const std::exception& e) {
+            return Status::Invalid(e.what());
+          }
+          return Status::OK();
+        }
+      }
+      const auto castResult =
+          util::Converter<TypeKind::VARCHAR, void, util::SparkCastPolicy>::
+              tryCast(*input);
+      VELOX_DCHECK(!castResult.hasError());
+      result.copy_from(castResult.value());
+    } else {
+      result.setNoCopy(detail::kNull);
+    }
+    return Status::OK();
+  }
+
+ private:
+  TypePtr inputType_;
+};
+
+/// Returns pretty string for varbinary. It has several differences with
+/// cast(varbinary as string):
+/// 1) It prints null input as "NULL" rather than producing null output.
+/// 2) It prints binary value as hex string representation rather than UTF-8.
+/// The pretty string is composed of the hex digits of bytes and spaces between
+/// them. E.g., the result of to_pretty_string("abc") is "[31 32 33]".
+template <typename TExec>
+struct ToPrettyStringVarbinaryFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename TInput>
+  void callNullable(out_type<Varchar>& result, const TInput* input) {
+    if (input) {
+      // One byte spares 2 char, and with the spaces and the boxes.
+      // Byte size: 2 * input->size(), spaces size: input->size() - 1, boxes
+      // size: 2, its sum is 1 + 3 * input->size().
+      result.resize(1 + 3 * input->size());
+      char* const startPosition = result.data();
+      char* pos = startPosition;
+      *pos++ = '[';
+      for (auto i = 0; i < input->size(); i++) {
+        fmt::format_to(pos, "{:02X}", static_cast<int>(input->data()[i]));
+        pos += 2;
+        *pos++ = ' ';
+      }
+      *--pos = ']';
+    } else {
+      result.setNoCopy(detail::kNull);
+    }
+  }
+};
+
+/// Returns pretty string for Timestamp. It has one difference with
+/// cast(timestamp as string):
+/// 1) It prints null input as "NULL" rather than producing null output.
+template <typename TExec>
+struct ToPrettyStringTimestampFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config,
+      const arg_type<Timestamp>* /*timestamp*/) {
+    auto timezone = config.sessionTimezone();
+    if (!timezone.empty()) {
+      options_.timeZone = tz::locateZone(timezone);
+    }
+    timestampRowSize_ = getMaxStringLength(options_);
+  }
+
+  Status callNullable(
+      out_type<Varchar>& result,
+      const arg_type<Timestamp>* timestamp) {
+    if (timestamp) {
+      Timestamp inputValue(*timestamp);
+      try {
+        if (options_.timeZone) {
+          inputValue.toTimezone(*(options_.timeZone));
+        }
+        result.reserve(timestampRowSize_);
+        const auto stringView =
+            Timestamp::tsToStringView(inputValue, options_, result.data());
+        result.resize(stringView.size());
+      } catch (const std::exception& e) {
+        return Status::Invalid(
+            "Invalid timestamp in to_pretty_string: {}", e.what());
+      }
+    } else {
+      result.setNoCopy(detail::kNull);
+    }
+    return Status::OK();
+  }
+
+ private:
+  TimestampToStringOptions options_ = {
+      .precision = TimestampToStringOptions::Precision::kMicroseconds,
+      .leadingPositiveSign = true,
+      .skipTrailingZeros = true,
+      .zeroPaddingYear = true,
+      .dateTimeSeparator = ' ',
+  };
+  std::string::size_type timestampRowSize_;
+};
+
+/// Returns pretty string for short decimal and long decimal. It has one
+/// difference with cast(decimal as string):
+/// 1) It prints null input as "NULL" rather than producing null output.
+template <typename TExec>
+struct ToPrettyStringDecimalFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename A>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      A* /*a*/) {
+    auto [precision, scale] = getDecimalPrecisionScale(*inputTypes[0]);
+    precision_ = precision;
+    scale_ = scale;
+    maxRowSize_ = velox::DecimalUtil::maxStringViewSize(precision, scale);
+  }
+
+  template <typename TInput>
+  void callNullable(out_type<Varchar>& result, const TInput* input) {
+    if (input) {
+      if (StringView::isInline(maxRowSize_)) {
+        DecimalUtil::castToString<TInput>(
+            *input, scale_, maxRowSize_, inlined_);
+        result.setNoCopy(inlined_);
+      } else {
+        result.reserve(maxRowSize_);
+        auto actualSize = DecimalUtil::castToString<TInput>(
+            *input, scale_, maxRowSize_, result.data());
+        result.resize(actualSize);
+      }
+    } else {
+      result.setNoCopy(detail::kNull);
+    }
+  }
+
+ private:
+  uint8_t precision_;
+  uint8_t scale_;
+  int32_t maxRowSize_;
+  char inlined_[StringView::kInlineSize];
+};
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/Transform.cpp b/velox/functions/sparksql/Transform.cpp
new file mode 100644
index 00000000000..899b0a5bb66
--- /dev/null
+++ b/velox/functions/sparksql/Transform.cpp
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/lib/TransformFunctionBase.h"
+#include "velox/functions/sparksql/LambdaIndexUtil.h"
+
+namespace facebook::velox::functions::sparksql {
+namespace {
+
+/// Spark's transform function supports both signatures:
+/// 1. transform(array, x -> expr) - element only
+/// 2. transform(array, (x, i) -> expr) - element + index (Spark-specific)
+///
+/// See Spark documentation:
+/// https://spark.apache.org/docs/latest/api/sql/index.html#transform
+class TransformFunction : public TransformFunctionBase {
+ public:
+  /// Returns both base signature and Spark-specific signature with index.
+  static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
+    auto sigs = TransformFunctionBase::signatures();
+    // Add Spark-specific signature: array(T), function(T, integer, U) ->
+    // array(U). Spark uses IntegerType (32-bit) for the index parameter.
+    sigs.push_back(
+        exec::FunctionSignatureBuilder()
+            .typeVariable("T")
+            .typeVariable("U")
+            .returnType("array(U)")
+            .argumentType("array(T)")
+            .argumentType("function(T, integer, U)")
+            .build());
+    return sigs;
+  }
+
+ private:
+  // Adds index vector to lambda arguments if the lambda expects it.
+  void addIndexVector(
+      const std::vector<VectorPtr>& args,
+      const ArrayVectorPtr& flatArray,
+      vector_size_t numElements,
+      exec::EvalCtx& context,
+      std::vector<VectorPtr>& lambdaArgs) const override {
+    // Check the lambda function type to see if it expects 2 input arguments.
+    // function(T, U) has 2 children (input T, output U) -> 1 input arg.
+    // function(T, integer, U) has 3 children (input T, index integer, output U)
+    // -> 2 input args.
+    if (args[1]->type()->size() == 3) {
+      lambdaArgs.push_back(
+          createIndexVector(flatArray, numElements, context.pool()));
+    }
+  }
+};
+
+} // namespace
+
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
+    udf_spark_transform,
+    TransformFunction::signatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
+    std::make_unique<TransformFunction>());
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/aggregates/ApproxPercentileAggregate.cpp b/velox/functions/sparksql/aggregates/ApproxPercentileAggregate.cpp
new file mode 100644
index 00000000000..b618b200109
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/ApproxPercentileAggregate.cpp
@@ -0,0 +1,224 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/expression/FunctionSignature.h"
+#include "velox/functions/lib/aggregates/ApproxPercentileAggregateBase.h"
+
+namespace facebook::velox::functions::aggregate::sparksql {
+
+using Idx = ApproxPercentileIntermediateTypeChildIndex;
+
+namespace {
+
+/// Spark accuracy policy: accuracy is an int32 representing the reciprocal
+/// of epsilon (e.g., 10000 means epsilon = 1/10000).
+struct SparkAccuracyPolicy {
+  static constexpr int32_t kDefaultAccuracy = 10000;
+
+  static bool isDefaultAccuracy(int32_t /*accuracy*/) {
+    // Spark always has a valid accuracy (defaults to 10000), never "missing".
+    return false;
+  }
+
+  template <typename T>
+  static void setOnAccumulator(
+      detail::KllSketchAccumulator<T>* accumulator,
+      int32_t accuracy) {
+    // Spark accuracy is the reciprocal of epsilon.
+    double epsilon = 1.0 / accuracy;
+    accumulator->setAccuracy(epsilon);
+  }
+
+  static void checkSetAccuracy(
+      DecodedVector& decodedAccuracy,
+      const SelectivityVector& rows,
+      int32_t& accuracy) {
+    if (decodedAccuracy.isConstantMapping()) {
+      VELOX_USER_CHECK(
+          !decodedAccuracy.isNullAt(0), "The accuracy must not be null.");
+      checkAndSet(accuracy, decodedAccuracy.valueAt<int32_t>(0));
+    } else {
+      rows.applyToSelected([&](auto row) {
+        VELOX_USER_CHECK(
+            !decodedAccuracy.isNullAt(row), "The accuracy must not be null.");
+        const auto currentAccuracy = decodedAccuracy.valueAt<int32_t>(row);
+        if (accuracy == kDefaultAccuracy) {
+          checkAndSet(accuracy, currentAccuracy);
+        }
+        VELOX_USER_CHECK_EQ(
+            currentAccuracy, accuracy, "Accuracy argument must be constant");
+      });
+    }
+  }
+
+  static void checkAndSetFromIntermediate(
+      int32_t& accuracy,
+      int32_t inputAccuracy) {
+    checkAndSet(accuracy, inputAccuracy);
+  }
+
+ private:
+  static void checkAndSet(int32_t& accuracy, int32_t inputAccuracy) {
+    VELOX_USER_CHECK(
+        inputAccuracy > 0 &&
+            inputAccuracy <= std::numeric_limits<int32_t>::max(),
+        "The accuracy must be between (0, 2147483647], got {}",
+        inputAccuracy);
+    accuracy = inputAccuracy;
+  }
+};
+
+template <typename T>
+using ApproxPercentileAggregate = ApproxPercentileAggregateBase<
+    T,
+    /*kHasWeight=*/false,
+    SparkAccuracyPolicy,
+    /*AccuracyIntermediateType=*/int32_t>;
+
+void addSignatures(
+    const std::string& inputType,
+    std::vector<std::shared_ptr<exec::AggregateFunctionSignature>>&
+        signatures) {
+  std::string intermediateType = fmt::format(
+      "row(array(double), boolean, integer, integer, bigint, {0}, {0}, array({0}), array(integer))",
+      inputType);
+
+  // Signature 1: approx_percentile(T, double) -> T (single percentile, default
+  // accuracy).
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType(inputType)
+          .intermediateType(intermediateType)
+          .argumentType(inputType)
+          .argumentType("double")
+          .build());
+  // Signature 2: approx_percentile(T, double, integer) -> T (single percentile,
+  // explicit accuracy).
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType(inputType)
+          .intermediateType(intermediateType)
+          .argumentType(inputType)
+          .argumentType("double")
+          .argumentType("integer")
+          .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType(inputType)
+          .intermediateType(intermediateType)
+          .argumentType(inputType)
+          .argumentType("double")
+          .argumentType("bigint")
+          .build());
+  // Signature 3: approx_percentile(T, array(double)) -> array(T) (percentile
+  // array, default accuracy).
+  std::string arrayReturnType = fmt::format("array({})", inputType);
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType(arrayReturnType)
+          .intermediateType(intermediateType)
+          .argumentType(inputType)
+          .argumentType("array(double)")
+          .build());
+  // Signature 4: approx_percentile(T, array(double), integer) -> array(T)
+  // (percentile array, explicit accuracy).
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType(arrayReturnType)
+          .intermediateType(intermediateType)
+          .argumentType(inputType)
+          .argumentType("array(double)")
+          .argumentType("integer")
+          .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType(arrayReturnType)
+          .intermediateType(intermediateType)
+          .argumentType(inputType)
+          .argumentType("array(double)")
+          .argumentType("bigint")
+          .build());
+}
+
+} // namespace
+
+exec::AggregateRegistrationResult registerApproxPercentileAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
+  const std::vector<std::string> kSupportedInputTypes = {
+      "tinyint", "smallint", "integer", "bigint", "real", "double"};
+  for (const auto& inputType : kSupportedInputTypes) {
+    addSignatures(inputType, signatures);
+  }
+
+  auto functionName = prefix + "approx_percentile";
+  return exec::registerAggregateFunction(
+      functionName,
+      std::move(signatures),
+      [functionName = functionName](
+          core::AggregationNode::Step step,
+          const std::vector<TypePtr>& argTypes,
+          const TypePtr& resultType,
+          const core::QueryConfig& config) -> std::unique_ptr<exec::Aggregate> {
+        const auto isRawInput = exec::isRawInput(step);
+        const auto fixedRandomSeed =
+            config.debugAggregationApproxPercentileFixedRandomSeed();
+        const bool hasAccuracy = isRawInput ? (argTypes.size() == 3) : false;
+
+        TypePtr type;
+        if (!isRawInput && exec::isPartialOutput(step)) {
+          type = argTypes[0]->asRow().childAt(static_cast<int>(Idx::kMinValue));
+        } else if (isRawInput) {
+          type = argTypes[0];
+        } else if (resultType->isArray()) {
+          type = resultType->as<TypeKind::ARRAY>().elementType();
+        } else {
+          type = resultType;
+        }
+
+        switch (type->kind()) {
+          case TypeKind::TINYINT:
+            return std::make_unique<ApproxPercentileAggregate<int8_t>>(
+                /*hasWeight=*/false, hasAccuracy, resultType, fixedRandomSeed);
+          case TypeKind::SMALLINT:
+            return std::make_unique<ApproxPercentileAggregate<int16_t>>(
+                /*hasWeight=*/false, hasAccuracy, resultType, fixedRandomSeed);
+          case TypeKind::INTEGER:
+            return std::make_unique<ApproxPercentileAggregate<int32_t>>(
+                /*hasWeight=*/false, hasAccuracy, resultType, fixedRandomSeed);
+          case TypeKind::BIGINT:
+            return std::make_unique<ApproxPercentileAggregate<int64_t>>(
+                /*hasWeight=*/false, hasAccuracy, resultType, fixedRandomSeed);
+          case TypeKind::REAL:
+            return std::make_unique<ApproxPercentileAggregate<float>>(
+                /*hasWeight=*/false, hasAccuracy, resultType, fixedRandomSeed);
+          case TypeKind::DOUBLE:
+            return std::make_unique<ApproxPercentileAggregate<double>>(
+                /*hasWeight=*/false, hasAccuracy, resultType, fixedRandomSeed);
+          default:
+            VELOX_USER_FAIL(
+                "Unsupported input type for {}: {}",
+                functionName,
+                argTypes[0]->toString());
+        }
+      },
+      withCompanionFunctions,
+      overwrite);
+}
+
+} // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/ApproxPercentileAggregate.h b/velox/functions/sparksql/aggregates/ApproxPercentileAggregate.h
new file mode 100644
index 00000000000..f1cc7e8e37e
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/ApproxPercentileAggregate.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+#include "velox/exec/AggregateUtil.h"
+
+namespace facebook::velox::functions::aggregate::sparksql {
+
+exec::AggregateRegistrationResult registerApproxPercentileAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+} // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/AverageAggregate.cpp b/velox/functions/sparksql/aggregates/AverageAggregate.cpp
index 623657df3a7..7397e1da544 100644
--- a/velox/functions/sparksql/aggregates/AverageAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/AverageAggregate.cpp
@@ -16,6 +16,7 @@
 
 #include "velox/functions/sparksql/aggregates/AverageAggregate.h"
 #include "velox/functions/lib/aggregates/AverageAggregateBase.h"
+#include "velox/functions/sparksql/aggregates/DecimalAverageAggregate.h"
 
 using namespace facebook::velox::functions::aggregate;
 
@@ -74,6 +75,37 @@ class AverageAggregate
   }
 };
 
+TypePtr getAvgResultType(const TypePtr& rawInputType) {
+  auto [p, s] = getDecimalPrecisionScale(*rawInputType.get());
+  // In Spark,
+  // final avg result precision = input precision + 4
+  // final avg result scale = input scale + 4
+  return DECIMAL(
+      std::min<uint8_t>(LongDecimalType::kMaxPrecision, p + 4),
+      std::min<uint8_t>(LongDecimalType::kMaxPrecision, s + 4));
+}
+
+std::unique_ptr<exec::Aggregate> getDecimalAverageAggregate(
+    core::AggregationNode::Step step,
+    const std::vector<TypePtr>& argTypes,
+    const TypePtr& resultType) {
+  auto inputType = argTypes[0];
+  VELOX_USER_CHECK(inputType->isDecimal());
+  auto avgType = getAvgResultType(inputType);
+  if (inputType->isShortDecimal()) {
+    if (avgType->isShortDecimal()) {
+      return std::make_unique<exec::SimpleAggregateAdapter<
+          DecimalAverageAggregate<int64_t, int64_t>>>(
+          step, argTypes, resultType);
+    }
+    return std::make_unique<exec::SimpleAggregateAdapter<
+        DecimalAverageAggregate<int64_t, int128_t>>>(
+        step, argTypes, resultType);
+  }
+  return std::make_unique<exec::SimpleAggregateAdapter<
+      DecimalAverageAggregate<int128_t, int128_t>>>(step, argTypes, resultType);
+}
+
 } // namespace
 
 /// Count is BIGINT() while sum and the final aggregates type depends on
@@ -92,20 +124,25 @@ exec::AggregateRegistrationResult registerAverage(
 
   for (const auto& inputType :
        {"smallint", "integer", "bigint", "real", "double"}) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType("double")
-                             .intermediateType("row(double,bigint)")
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType("double")
+            .intermediateType("row(double,bigint)")
+            .argumentType(inputType)
+            .build());
   }
 
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .integerVariable("a_precision")
-                           .integerVariable("a_scale")
-                           .argumentType("DECIMAL(a_precision, a_scale)")
-                           .intermediateType("varbinary")
-                           .returnType("DECIMAL(a_precision, a_scale)")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .integerVariable("a_precision")
+          .integerVariable("a_scale")
+          .integerVariable("i_precision", "min(38, a_precision + 10)")
+          .integerVariable("r_precision", "min(38, a_precision + 4)")
+          .integerVariable("r_scale", "min(38, a_scale + 4)")
+          .argumentType("DECIMAL(a_precision, a_scale)")
+          .intermediateType("ROW(DECIMAL(i_precision, a_scale), BIGINT)")
+          .returnType("DECIMAL(r_precision, r_scale)")
+          .build());
 
   return exec::registerAggregateFunction(
       name,
@@ -118,7 +155,7 @@ exec::AggregateRegistrationResult registerAverage(
           -> std::unique_ptr<exec::Aggregate> {
         VELOX_CHECK_LE(
             argTypes.size(), 1, "{} takes at most one argument", name);
-        auto inputType = argTypes[0];
+        const auto& inputType = argTypes[0];
         if (exec::isRawInput(step)) {
           switch (inputType->kind()) {
             case TypeKind::SMALLINT:
@@ -129,16 +166,26 @@ exec::AggregateRegistrationResult registerAverage(
                   AverageAggregate<int32_t, double, double>>(resultType);
             case TypeKind::BIGINT: {
               if (inputType->isShortDecimal()) {
-                return std::make_unique<DecimalAverageAggregateBase<int64_t>>(
-                    resultType);
+                auto precision =
+                    getDecimalPrecisionScale(*inputType.get()).first;
+                // Spark has an optimization rule named DecimalAggregate that
+                // converts input data to a Long for average calculation when
+                // the input data is of type decimal and the precision is <= 11.
+                // Therefore, the precision of the decimal inputs received by
+                // the decimal average is guaranteed to be > 11. Since the
+                // precision of the intermediate sum is input precision + 10, it
+                // will definitely be > 21, which means the intermediate sum
+                // will always be a long decimal. We can directly assume that
+                // the physical type of the intermediate sum is int128_t.
+                VELOX_USER_CHECK_GT(precision, 11);
+                return getDecimalAverageAggregate(step, argTypes, resultType);
               }
               return std::make_unique<
                   AverageAggregate<int64_t, double, double>>(resultType);
             }
             case TypeKind::HUGEINT: {
               if (inputType->isLongDecimal()) {
-                return std::make_unique<DecimalAverageAggregateBase<int128_t>>(
-                    resultType);
+                return getDecimalAverageAggregate(step, argTypes, resultType);
               }
               VELOX_NYI();
             }
@@ -162,28 +209,24 @@ exec::AggregateRegistrationResult registerAverage(
                   resultType);
             case TypeKind::DOUBLE:
             case TypeKind::ROW:
+              if (inputType->childAt(0)->isDecimal()) {
+                return std::make_unique<
+                    exec::SimpleAggregateAdapter<DecimalAverageAggregate<
+                        int128_t /*unused*/,
+                        int128_t /*unused*/>>>(step, argTypes, resultType);
+              }
               return std::make_unique<
                   AverageAggregate<int64_t, double, double>>(resultType);
             case TypeKind::BIGINT:
-              return std::make_unique<DecimalAverageAggregateBase<int64_t>>(
-                  resultType);
+              VELOX_USER_CHECK(resultType->isShortDecimal());
+              return std::make_unique<exec::SimpleAggregateAdapter<
+                  DecimalAverageAggregate<int64_t /*unused*/, int64_t>>>(
+                  step, argTypes, resultType);
             case TypeKind::HUGEINT:
-              return std::make_unique<DecimalAverageAggregateBase<int128_t>>(
-                  resultType);
-            case TypeKind::VARBINARY:
-              if (inputType->isLongDecimal()) {
-                return std::make_unique<DecimalAverageAggregateBase<int128_t>>(
-                    resultType);
-              } else if (
-                  inputType->isShortDecimal() ||
-                  inputType->kind() == TypeKind::VARBINARY) {
-                // If the input and out type are VARBINARY, then the
-                // LongDecimalWithOverflowState is used and the template type
-                // does not matter.
-                return std::make_unique<DecimalAverageAggregateBase<int64_t>>(
-                    resultType);
-              }
-              [[fallthrough]];
+              VELOX_USER_CHECK(resultType->isLongDecimal());
+              return std::make_unique<exec::SimpleAggregateAdapter<
+                  DecimalAverageAggregate<int128_t /*unused*/, int128_t>>>(
+                  step, argTypes, resultType);
             default:
               VELOX_FAIL(
                   "Unsupported result type for final aggregation: {}",
diff --git a/velox/functions/sparksql/aggregates/BitmapConstructAggAggregate.cpp b/velox/functions/sparksql/aggregates/BitmapConstructAggAggregate.cpp
new file mode 100644
index 00000000000..194dd35aa7a
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/BitmapConstructAggAggregate.cpp
@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/sparksql/aggregates/BitmapConstructAggAggregate.h"
+
+#include <cstring>
+
+#include "velox/common/base/BitUtil.h"
+#include "velox/exec/SimpleAggregateAdapter.h"
+#include "velox/expression/FunctionSignature.h"
+
+namespace facebook::velox::functions::aggregate::sparksql {
+
+namespace {
+
+// Spark bitmap_construct_agg uses a fixed-size bitmap of 4096 bytes (32768
+// bits). Each input value in [0, 32767] maps to a single bit in the bitmap.
+// See org.apache.spark.sql.catalyst.expressions.BitmapConstructAgg.
+constexpr int32_t kBitmapNumBytes = 4096;
+constexpr int64_t kBitmapNumBits = static_cast<int64_t>(kBitmapNumBytes) * 8;
+
+// Validates that a bitmap position is within [0, kBitmapNumBits).
+void validateBitmapPosition(int64_t position) {
+  VELOX_USER_CHECK_GE(position, 0, "Bitmap position out of bounds");
+  VELOX_USER_CHECK_LT(
+      position, kBitmapNumBits, "Bitmap position out of bounds");
+}
+
+class BitmapConstructAggAggregate {
+ public:
+  using InputType = Row<int64_t>;
+
+  using IntermediateType = Varbinary;
+
+  using OutputType = Varbinary;
+
+  // Non-default null behavior: the aggregate always produces a non-null result
+  // (an all-zeros bitmap) even when all inputs are null or the group is empty.
+  static constexpr bool default_null_behavior_ = false;
+
+  struct AccumulatorType {
+    // Pointer to the 4096-byte bitmap stored in external memory.
+    uint8_t* data_{nullptr};
+    // Header for the HashStringAllocator-managed allocation.
+    HashStringAllocator::Header* header_{nullptr};
+
+    static constexpr bool is_fixed_size_ = false;
+    static constexpr bool use_external_memory_ = true;
+
+    explicit AccumulatorType(
+        HashStringAllocator* /*allocator*/,
+        BitmapConstructAggAggregate* /*fn*/) {}
+
+    bool addInput(
+        HashStringAllocator* allocator,
+        exec::optional_arg_type<int64_t> position) {
+      if (!position.has_value()) {
+        return false;
+      }
+      validateBitmapPosition(position.value());
+      init(allocator);
+      bits::setBit(data_, static_cast<uint64_t>(position.value()));
+      return true;
+    }
+
+    bool combine(
+        HashStringAllocator* allocator,
+        exec::optional_arg_type<IntermediateType> other) {
+      if (!other.has_value()) {
+        return false;
+      }
+      auto serialized = other.value();
+      VELOX_CHECK_EQ(
+          serialized.size(),
+          kBitmapNumBytes,
+          "Unexpected intermediate bitmap size");
+      init(allocator);
+      bits::orBits(
+          reinterpret_cast<uint64_t*>(data_),
+          reinterpret_cast<const uint64_t*>(serialized.data()),
+          0,
+          kBitmapNumBits);
+      return true;
+    }
+
+    // Always produce a non-null result (all-zeros bitmap for empty groups)
+    // to match Spark's bitmap_construct_agg semantics.
+    bool writeIntermediateResult(
+        bool /*nonNullGroup*/,
+        exec::out_type<IntermediateType>& out) {
+      return writeResult(out);
+    }
+
+    bool writeFinalResult(
+        bool /*nonNullGroup*/,
+        exec::out_type<OutputType>& out) {
+      return writeResult(out);
+    }
+
+    void destroy(HashStringAllocator* allocator) {
+      if (header_) {
+        allocator->free(header_);
+        header_ = nullptr;
+        data_ = nullptr;
+      }
+    }
+
+   private:
+    bool writeResult(exec::out_type<Varbinary>& out) {
+      out.resize(kBitmapNumBytes);
+      if (data_) {
+        std::memcpy(out.data(), data_, kBitmapNumBytes);
+      } else {
+        std::memset(out.data(), 0, kBitmapNumBytes);
+      }
+      return true;
+    }
+
+    void init(HashStringAllocator* allocator) {
+      if (!data_) {
+        header_ = allocator->allocate(kBitmapNumBytes);
+        data_ = reinterpret_cast<uint8_t*>(header_->begin());
+        std::memset(data_, 0, kBitmapNumBytes);
+      }
+    }
+  };
+};
+
+} // namespace
+
+exec::AggregateRegistrationResult registerBitmapConstructAggAggregate(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
+      exec::AggregateFunctionSignatureBuilder()
+          .argumentType("bigint")
+          .intermediateType("varbinary")
+          .returnType("varbinary")
+          .build()};
+
+  return exec::registerAggregateFunction(
+      name,
+      std::move(signatures),
+      [name](
+          core::AggregationNode::Step step,
+          const std::vector<TypePtr>& argTypes,
+          const TypePtr& resultType,
+          const core::QueryConfig& config) -> std::unique_ptr<exec::Aggregate> {
+        VELOX_CHECK_EQ(
+            argTypes.size(), 1, "{} takes exactly one argument", name);
+        return std::make_unique<
+            exec::SimpleAggregateAdapter<BitmapConstructAggAggregate>>(
+            step, argTypes, resultType, &config);
+      },
+      withCompanionFunctions,
+      overwrite);
+}
+
+} // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/BitmapConstructAggAggregate.h b/velox/functions/sparksql/aggregates/BitmapConstructAggAggregate.h
new file mode 100644
index 00000000000..bb7cca19960
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/BitmapConstructAggAggregate.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+#include "velox/exec/AggregateUtil.h"
+
+namespace facebook::velox::functions::aggregate::sparksql {
+
+exec::AggregateRegistrationResult registerBitmapConstructAggAggregate(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+} // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/BitwiseXorAggregate.cpp b/velox/functions/sparksql/aggregates/BitwiseXorAggregate.cpp
index 13c3deeba7d..5b38d917a1e 100644
--- a/velox/functions/sparksql/aggregates/BitwiseXorAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/BitwiseXorAggregate.cpp
@@ -65,12 +65,12 @@ class BitwiseXorAggregate : public BitwiseAggregateBase<T> {
 
 } // namespace
 
-exec::AggregateRegistrationResult registerBitwiseXorAggregate(
+std::vector<exec::AggregateRegistrationResult> registerBitwiseXorAggregate(
     const std::string& prefix,
     bool withCompanionFunctions,
     bool overwrite) {
   return functions::aggregate::registerBitwise<BitwiseXorAggregate>(
-      prefix + "bit_xor", withCompanionFunctions, false, overwrite);
+      {prefix + "bit_xor"}, false, withCompanionFunctions, false, overwrite);
 }
 
 } // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/BitwiseXorAggregate.h b/velox/functions/sparksql/aggregates/BitwiseXorAggregate.h
index 083b31dacab..76f9a1d6b2b 100644
--- a/velox/functions/sparksql/aggregates/BitwiseXorAggregate.h
+++ b/velox/functions/sparksql/aggregates/BitwiseXorAggregate.h
@@ -17,12 +17,13 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 #include "velox/exec/AggregateUtil.h"
 
 namespace facebook::velox::functions::aggregate::sparksql {
 
-exec::AggregateRegistrationResult registerBitwiseXorAggregate(
+std::vector<exec::AggregateRegistrationResult> registerBitwiseXorAggregate(
     const std::string& name,
     bool withCompanionFunctions,
     bool overwrite);
diff --git a/velox/functions/sparksql/aggregates/BloomFilterAggAggregate.cpp b/velox/functions/sparksql/aggregates/BloomFilterAggAggregate.cpp
index 89a0a0c4a20..81a68ea3c6e 100644
--- a/velox/functions/sparksql/aggregates/BloomFilterAggAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/BloomFilterAggAggregate.cpp
@@ -66,7 +66,8 @@ class BloomFilterAggAggregate : public exec::Aggregate {
       : Aggregate(resultType),
         defaultExpectedNumItems_(config.sparkBloomFilterExpectedNumItems()),
         defaultNumBits_(config.sparkBloomFilterNumBits()),
-        maxNumBits_(config.sparkBloomFilterMaxNumBits()) {}
+        maxNumBits_(config.sparkBloomFilterMaxNumBits()),
+        maxNumItems_(config.sparkBloomFilterMaxNumItems()) {}
 
   int32_t accumulatorFixedWidthSize() const override {
     return sizeof(BloomFilterAccumulator);
@@ -221,7 +222,8 @@ class BloomFilterAggAggregate : public exec::Aggregate {
         DecodedVector decodedNumBits(*args[2], rows);
         setConstantArgument("numBits", numBits_, decodedNumBits);
       } else {
-        numBits_ = estimatedNumItems_ * 8;
+        numBits_ =
+            BloomFilter<>::optimalNumOfBits(estimatedNumItems_, maxNumItems_);
       }
     } else {
       estimatedNumItems_ = defaultExpectedNumItems_;
@@ -277,6 +279,7 @@ class BloomFilterAggAggregate : public exec::Aggregate {
   const int64_t defaultExpectedNumItems_;
   const int64_t defaultNumBits_;
   const int64_t maxNumBits_;
+  const int64_t maxNumItems_;
 
   // Reusable instance of DecodedVector for decoding input vectors.
   DecodedVector decodedRaw_;
diff --git a/velox/functions/sparksql/aggregates/CMakeLists.txt b/velox/functions/sparksql/aggregates/CMakeLists.txt
index 679bb243a7c..32b53b6d39b 100644
--- a/velox/functions/sparksql/aggregates/CMakeLists.txt
+++ b/velox/functions/sparksql/aggregates/CMakeLists.txt
@@ -13,7 +13,9 @@
 # limitations under the License.
 velox_add_library(
   velox_functions_spark_aggregates
+  ApproxPercentileAggregate.cpp
   AverageAggregate.cpp
+  BitmapConstructAggAggregate.cpp
   BitwiseXorAggregate.cpp
   BloomFilterAggAggregate.cpp
   CentralMomentsAggregate.cpp
@@ -28,6 +30,21 @@ velox_add_library(
   RegrReplacementAggregate.cpp
   SumAggregate.cpp
   VarianceAggregate.cpp
+  HEADERS
+  ApproxPercentileAggregate.h
+  AverageAggregate.h
+  BitmapConstructAggAggregate.h
+  BitwiseXorAggregate.h
+  BloomFilterAggAggregate.h
+  CentralMomentsAggregate.h
+  CollectListAggregate.h
+  CovarianceAggregate.h
+  DecimalAverageAggregate.h
+  DecimalSumAggregate.h
+  Register.h
+  RegrReplacementAggregate.h
+  SumAggregate.h
+  VarianceAggregate.h
 )
 
 velox_link_libraries(
diff --git a/velox/functions/sparksql/aggregates/CollectListAggregate.cpp b/velox/functions/sparksql/aggregates/CollectListAggregate.cpp
index c85d7eff358..4e779a0b5e8 100644
--- a/velox/functions/sparksql/aggregates/CollectListAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/CollectListAggregate.cpp
@@ -38,14 +38,18 @@ class CollectListAggregate {
   /// behavior can only be achieved when the default-null behavior is disabled.
   static constexpr bool default_null_behavior_ = false;
 
-  static bool toIntermediate(
-      exec::out_type<Array<Generic<T1>>>& out,
-      exec::optional_arg_type<Generic<T1>> in) {
-    if (in.has_value()) {
-      out.add_item().copy_from(in.value());
-      return true;
-    }
-    return false;
+  // Whether null input values should be ignored. Defaults to true.
+  // NOTE: toIntermediate() was intentionally removed because it is static and
+  // cannot access the runtime ignoreNulls_ config. Without it, partial
+  // aggregation uses the accumulator path, which correctly respects the config.
+  bool ignoreNulls_{true};
+
+  void initialize(
+      core::AggregationNode::Step /*step*/,
+      const std::vector<TypePtr>& /*argTypes*/,
+      const TypePtr& /*resultType*/,
+      const core::QueryConfig& config) {
+    ignoreNulls_ = config.sparkCollectListIgnoreNulls();
   }
 
   struct AccumulatorType {
@@ -53,8 +57,8 @@ class CollectListAggregate {
 
     explicit AccumulatorType(
         HashStringAllocator* /*allocator*/,
-        CollectListAggregate* /*fn*/)
-        : elements_{} {}
+        CollectListAggregate* fn)
+        : elements_{}, ignoreNulls_(fn->ignoreNulls_) {}
 
     static constexpr bool is_fixed_size_ = false;
 
@@ -65,9 +69,15 @@ class CollectListAggregate {
         elements_.appendValue(data, allocator);
         return true;
       }
+      if (!ignoreNulls_) {
+        elements_.appendValue(data, allocator);
+        return true;
+      }
       return false;
     }
 
+    bool ignoreNulls_;
+
     bool combine(
         HashStringAllocator* allocator,
         exec::optional_arg_type<IntermediateType> other) {
@@ -122,12 +132,11 @@ AggregateRegistrationResult registerCollectList(
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
-          const core::QueryConfig& /*config*/)
-          -> std::unique_ptr<exec::Aggregate> {
+          const core::QueryConfig& config) -> std::unique_ptr<exec::Aggregate> {
         VELOX_CHECK_EQ(
             argTypes.size(), 1, "{} takes at most one argument", name);
         return std::make_unique<SimpleAggregateAdapter<CollectListAggregate>>(
-            step, argTypes, resultType);
+            step, argTypes, resultType, &config);
       },
       withCompanionFunctions,
       overwrite);
diff --git a/velox/functions/sparksql/aggregates/CollectSetAggregate.cpp b/velox/functions/sparksql/aggregates/CollectSetAggregate.cpp
index 15ae6dc5514..6615b6ad4b1 100644
--- a/velox/functions/sparksql/aggregates/CollectSetAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/CollectSetAggregate.cpp
@@ -18,19 +18,235 @@
 namespace facebook::velox::functions::aggregate::sparksql {
 namespace {
 
-// Null inputs are excluded by setting 'ignoreNulls' as true.
-// Empty arrays are returned for empty groups by setting 'nullForEmpty'
-// as false.
-template <typename T>
-using SparkSetAggAggregate = SetAggAggregate<T, true, false>;
-
-// NaN inputs are treated as distinct values.
-template <typename T>
-using FloatSetAggAggregateNaNUnaware = SetAggAggregate<
-    T,
-    true,
-    false,
-    velox::aggregate::prestosql::FloatSetAccumulatorNaNUnaware<T>>;
+// Spark collect_set aggregate with runtime ignoreNulls flag.
+// The ignoreNulls_ flag is initialized via setConstantInputs() from the
+// constant boolean argument provided at plan construction time.
+template <
+    typename T,
+    typename AccumulatorType = velox::aggregate::prestosql::SetAccumulator<T>>
+class SparkCollectSetAggregate
+    : public SetAggAggregate<T, false, false, AccumulatorType> {
+  using Base = SetAggAggregate<T, false, false, AccumulatorType>;
+  using SBase = SetBaseAggregate<T, false, false, AccumulatorType>;
+
+ public:
+  explicit SparkCollectSetAggregate(const TypePtr& resultType)
+      : Base(resultType) {}
+
+  void setConstantInputs(
+      const std::vector<VectorPtr>& constantInputs) override {
+    // In the raw input step, constantInputs has 2 entries: [data, boolean].
+    // In the intermediate/final step or companion functions, the boolean
+    // constant may not be present — skip in those cases.
+    if (constantInputs.size() >= 2 && constantInputs[1] != nullptr &&
+        !constantInputs[1]->isNullAt(0)) {
+      ignoreNulls_ = constantInputs[1]->as<ConstantVector<bool>>()->valueAt(0);
+    }
+  }
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    SBase::decoded_.decode(*args[0], rows);
+    rows.applyToSelected([&](vector_size_t i) {
+      auto* group = groups[i];
+      SBase::clearNull(group);
+      auto tracker = SBase::trackRowSize(group);
+      if (ignoreNulls_) {
+        SBase::value(group)->addNonNullValue(
+            SBase::decoded_, i, SBase::allocator_);
+      } else {
+        SBase::value(group)->addValue(SBase::decoded_, i, SBase::allocator_);
+      }
+    });
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    SBase::decoded_.decode(*args[0], rows);
+    SBase::clearNull(group);
+    auto* accumulator = SBase::value(group);
+    auto tracker = SBase::trackRowSize(group);
+    rows.applyToSelected([&](vector_size_t i) {
+      if (ignoreNulls_) {
+        accumulator->addNonNullValue(SBase::decoded_, i, SBase::allocator_);
+      } else {
+        accumulator->addValue(SBase::decoded_, i, SBase::allocator_);
+      }
+    });
+  }
+
+  void toIntermediate(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      VectorPtr& result) const override {
+    // When ignoreNulls is true, we must not wrap null input values into
+    // [null] arrays, because the final/intermediate node uses the default
+    // ignoreNulls_=false and would preserve those null elements. Instead,
+    // output empty arrays for null elements so that addIntermediateResults
+    // sees no null elements to preserve.
+    if (!ignoreNulls_) {
+      Base::toIntermediate(rows, args, result);
+      return;
+    }
+
+    const auto& elements = args[0];
+    const auto numRows = rows.size();
+
+    auto* pool = SBase::allocator_->pool();
+    BufferPtr nulls = allocateNulls(numRows, pool);
+    memcpy(
+        nulls->asMutable<uint64_t>(),
+        rows.asRange().bits(),
+        bits::nbytes(numRows));
+
+    // For ignoreNulls=true: null input elements get size=0 (empty array),
+    // non-null elements get size=1 as usual.
+    BufferPtr offsets = allocateOffsets(numRows, pool);
+    auto* rawOffsets = offsets->asMutable<vector_size_t>();
+
+    BufferPtr sizes = allocateSizes(numRows, pool);
+    auto* rawSizes = sizes->asMutable<vector_size_t>();
+
+    vector_size_t offset = 0;
+    rows.applyToSelected([&](vector_size_t i) {
+      rawOffsets[i] = offset;
+      if (elements->isNullAt(i)) {
+        rawSizes[i] = 0;
+      } else {
+        rawSizes[i] = 1;
+        offset++;
+      }
+    });
+
+    // Build a compacted elements vector with only non-null values.
+    auto nonNullCount = offset;
+    auto compactedElements =
+        BaseVector::create(elements->type(), nonNullCount, pool);
+    vector_size_t idx = 0;
+    rows.applyToSelected([&](vector_size_t i) {
+      if (!elements->isNullAt(i)) {
+        compactedElements->copy(elements.get(), idx++, i, 1);
+      }
+    });
+
+    result = std::make_shared<ArrayVector>(
+        pool,
+        ARRAY(elements->type()),
+        nulls,
+        numRows,
+        offsets,
+        sizes,
+        std::move(compactedElements));
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    SBase::decoded_.decode(*args[0], rows);
+    auto baseArray = SBase::decoded_.base()->template as<ArrayVector>();
+    SBase::decodedElements_.decode(*baseArray->elements());
+    rows.applyToSelected([&](vector_size_t i) {
+      if (SBase::decoded_.isNullAt(i)) {
+        return;
+      }
+      auto* group = groups[i];
+      SBase::clearNull(group);
+      auto tracker = SBase::trackRowSize(group);
+      auto decodedIndex = SBase::decoded_.index(i);
+      // Intermediate results already have null filtering applied by the
+      // partial step. Always preserve all elements (including nulls) here.
+      SBase::value(group)->addValues(
+          *baseArray, decodedIndex, SBase::decodedElements_, SBase::allocator_);
+    });
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    SBase::decoded_.decode(*args[0], rows);
+    auto baseArray = SBase::decoded_.base()->template as<ArrayVector>();
+    SBase::decodedElements_.decode(*baseArray->elements());
+    auto* accumulator = SBase::value(group);
+    auto tracker = SBase::trackRowSize(group);
+    rows.applyToSelected([&](vector_size_t i) {
+      if (SBase::decoded_.isNullAt(i)) {
+        return;
+      }
+      SBase::clearNull(group);
+      auto decodedIndex = SBase::decoded_.index(i);
+      // Intermediate results already have null filtering applied by the
+      // partial step. Always preserve all elements (including nulls) here.
+      accumulator->addValues(
+          *baseArray, decodedIndex, SBase::decodedElements_, SBase::allocator_);
+    });
+  }
+
+ private:
+  // Default to true (Spark's default: IGNORE NULLS). Updated by
+  // setConstantInputs() when a 2-arg signature provides explicit value.
+  // Only used in addRawInput (partial/single step); intermediate/final
+  // steps always preserve all elements from the partial output.
+  bool ignoreNulls_{true};
+};
+
+std::unique_ptr<exec::Aggregate> createSetAgg(
+    const TypeKind typeKind,
+    const TypePtr& inputType,
+    const TypePtr& resultType) {
+  switch (typeKind) {
+    case TypeKind::BOOLEAN:
+      return std::make_unique<SparkCollectSetAggregate<bool>>(resultType);
+    case TypeKind::TINYINT:
+      return std::make_unique<SparkCollectSetAggregate<int8_t>>(resultType);
+    case TypeKind::SMALLINT:
+      return std::make_unique<SparkCollectSetAggregate<int16_t>>(resultType);
+    case TypeKind::INTEGER:
+      return std::make_unique<SparkCollectSetAggregate<int32_t>>(resultType);
+    case TypeKind::BIGINT:
+      return std::make_unique<SparkCollectSetAggregate<int64_t>>(resultType);
+    case TypeKind::HUGEINT:
+      VELOX_CHECK(
+          inputType->isLongDecimal(),
+          "Non-decimal use of HUGEINT is not supported");
+      return std::make_unique<SparkCollectSetAggregate<int128_t>>(resultType);
+    case TypeKind::REAL:
+      return std::make_unique<SparkCollectSetAggregate<
+          float,
+          velox::aggregate::prestosql::FloatSetAccumulatorNaNUnaware<float>>>(
+          resultType);
+    case TypeKind::DOUBLE:
+      return std::make_unique<SparkCollectSetAggregate<
+          double,
+          velox::aggregate::prestosql::FloatSetAccumulatorNaNUnaware<double>>>(
+          resultType);
+    case TypeKind::TIMESTAMP:
+      return std::make_unique<SparkCollectSetAggregate<Timestamp>>(resultType);
+    case TypeKind::VARBINARY:
+      [[fallthrough]];
+    case TypeKind::VARCHAR:
+      return std::make_unique<SparkCollectSetAggregate<StringView>>(resultType);
+    case TypeKind::ARRAY:
+      [[fallthrough]];
+    case TypeKind::ROW:
+      return std::make_unique<SparkCollectSetAggregate<ComplexType>>(
+          resultType);
+    case TypeKind::UNKNOWN:
+      return std::make_unique<SparkCollectSetAggregate<UnknownValue>>(
+          resultType);
+    default:
+      VELOX_UNSUPPORTED("Unsupported type {}", TypeKindName::toName(typeKind));
+  }
+}
 
 } // namespace
 
@@ -39,73 +255,34 @@ void registerCollectSetAggAggregate(
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures = {
+      // collect_set(T) -> array(T): default ignoreNulls=true (Spark default).
+      exec::AggregateFunctionSignatureBuilder()
+          .typeVariable("T")
+          .returnType("array(T)")
+          .intermediateType("array(T)")
+          .argumentType("T")
+          .build(),
+      // collect_set(T, ignoreNulls) -> array(T): explicit ignoreNulls flag.
       exec::AggregateFunctionSignatureBuilder()
           .typeVariable("T")
           .returnType("array(T)")
           .intermediateType("array(T)")
           .argumentType("T")
+          .constantArgumentType("boolean")
           .build()};
 
-  auto name = prefix + "collect_set";
   exec::registerAggregateFunction(
-      name,
+      prefix + "collect_set",
       std::move(signatures),
-      [name](
-          core::AggregationNode::Step step,
-          const std::vector<TypePtr>& argTypes,
-          const TypePtr& resultType,
-          const core::QueryConfig& /*config*/)
+      [](core::AggregationNode::Step /*step*/,
+         const std::vector<TypePtr>& argTypes,
+         const TypePtr& resultType,
+         const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
-        VELOX_CHECK_EQ(argTypes.size(), 1);
-
-        const bool isRawInput = exec::isRawInput(step);
-        const TypePtr& inputType =
-            isRawInput ? argTypes[0] : argTypes[0]->childAt(0);
-        const TypeKind typeKind = inputType->kind();
-
-        switch (typeKind) {
-          case TypeKind::BOOLEAN:
-            return std::make_unique<SparkSetAggAggregate<bool>>(resultType);
-          case TypeKind::TINYINT:
-            return std::make_unique<SparkSetAggAggregate<int8_t>>(resultType);
-          case TypeKind::SMALLINT:
-            return std::make_unique<SparkSetAggAggregate<int16_t>>(resultType);
-          case TypeKind::INTEGER:
-            return std::make_unique<SparkSetAggAggregate<int32_t>>(resultType);
-          case TypeKind::BIGINT:
-            return std::make_unique<SparkSetAggAggregate<int64_t>>(resultType);
-          case TypeKind::HUGEINT:
-            VELOX_CHECK(
-                inputType->isLongDecimal(),
-                "Non-decimal use of HUGEINT is not supported");
-            return std::make_unique<SparkSetAggAggregate<int128_t>>(resultType);
-          case TypeKind::REAL:
-            return std::make_unique<FloatSetAggAggregateNaNUnaware<float>>(
-                resultType);
-          case TypeKind::DOUBLE:
-            return std::make_unique<FloatSetAggAggregateNaNUnaware<double>>(
-                resultType);
-          case TypeKind::TIMESTAMP:
-            return std::make_unique<SparkSetAggAggregate<Timestamp>>(
-                resultType);
-          case TypeKind::VARBINARY:
-            [[fallthrough]];
-          case TypeKind::VARCHAR:
-            return std::make_unique<SparkSetAggAggregate<StringView>>(
-                resultType);
-          case TypeKind::ARRAY:
-            [[fallthrough]];
-          case TypeKind::ROW:
-            return std::make_unique<SparkSetAggAggregate<ComplexType>>(
-                resultType);
-          case TypeKind::UNKNOWN:
-            return std::make_unique<SparkSetAggAggregate<UnknownValue>>(
-                resultType);
-          default:
-            VELOX_UNSUPPORTED(
-                "Unsupported type {}", mapTypeKindToName(typeKind));
-        }
+        const TypePtr& inputType = argTypes[0];
+        return createSetAgg(inputType->kind(), inputType, resultType);
       },
+      {.ignoreDuplicates = true},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/sparksql/aggregates/CovarianceAggregate.cpp b/velox/functions/sparksql/aggregates/CovarianceAggregate.cpp
index e9a7ea7840c..4a79502a7ad 100644
--- a/velox/functions/sparksql/aggregates/CovarianceAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/CovarianceAggregate.cpp
@@ -90,8 +90,7 @@ template <
     typename TAccumulator,
     typename TIntermediateInput,
     typename TIntermediateResult,
-    template <bool>
-    class TResultAccessor>
+    template <bool> class TResultAccessor>
 exec::AggregateRegistrationResult registerCovariance(
     const std::string& name,
     bool withCompanionFunctions,
diff --git a/velox/functions/sparksql/aggregates/DecimalAverageAggregate.h b/velox/functions/sparksql/aggregates/DecimalAverageAggregate.h
new file mode 100644
index 00000000000..6a35f09f995
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/DecimalAverageAggregate.h
@@ -0,0 +1,246 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/exec/SimpleAggregateAdapter.h"
+#include "velox/functions/sparksql/DecimalUtil.h"
+
+namespace facebook::velox::functions::aggregate::sparksql {
+namespace detail {
+
+inline TypePtr getSumType(const TypePtr& rawInputType) {
+  if (rawInputType->isRow()) {
+    return rawInputType->childAt(0);
+  }
+  auto [p, s] = getDecimalPrecisionScale(*rawInputType.get());
+  // In Spark,
+  // intermediate sum precision = input precision + 10
+  // intermediate sum scale = input scale
+  return DECIMAL(std::min<uint8_t>(LongDecimalType::kMaxPrecision, p + 10), s);
+}
+
+} // namespace detail
+
+/// @tparam TInputType The raw input data type.
+/// @tparam TResultType The type of the output average value.
+template <typename TInputType, typename TResultType>
+class DecimalAverageAggregate {
+ public:
+  using InputType = Row<TInputType>;
+
+  using IntermediateType = Row</*sum*/ int128_t,
+                               /*count*/ int64_t>;
+
+  using OutputType = TResultType;
+
+  /// Spark's decimal sum doesn't have the concept of a null group, each group
+  /// is initialized with an initial value, where sum = 0 and count = 0. The
+  /// final agg may fallback to being executed in Spark, so the meaning of the
+  /// intermediate data should be consistent with Spark. Therefore, we need to
+  /// use the parameter nonNullGroup in writeIntermediateResult to output a null
+  /// group as sum = 0, count = 0. nonNullGroup is only available when
+  /// default-null behavior is disabled.
+  static constexpr bool default_null_behavior_ = false;
+
+  void initialize(
+      core::AggregationNode::Step step,
+      const std::vector<TypePtr>& argTypes,
+      const TypePtr& resultType) {
+    VELOX_CHECK_EQ(argTypes.size(), 1);
+    auto inputType = argTypes[0];
+    this->sumType_ = detail::getSumType(inputType);
+    this->resultType_ = resultType;
+  }
+
+  static bool toIntermediate(
+      exec::out_type<Row<int128_t, int64_t>>& out,
+      exec::optional_arg_type<TInputType> in) {
+    if (in.has_value()) {
+      out.copy_from(std::make_tuple(in.value(), 1));
+    } else {
+      out.copy_from(std::make_tuple(0, 0));
+    }
+    return true;
+  }
+
+  /// This struct stores the sum of input values, overflow during accumulation,
+  /// and the count number of the input values. If the count is not 0, then if
+  /// sum is nullopt that means an overflow has happened. For null group, the
+  /// variables in accumulator should be meaningless, so the values of sum and
+  /// count are ignored in both writeIntermediateResult and writeFinalResult.
+  struct AccumulatorType {
+    std::optional<int128_t> sum{0};
+    int64_t overflow{0};
+    int64_t count{0};
+
+    DecimalAverageAggregate* fn;
+
+    static constexpr bool is_aligned_ = true;
+
+    AccumulatorType() = delete;
+
+    AccumulatorType(
+        HashStringAllocator* /*allocator*/,
+        DecimalAverageAggregate* fn)
+        : fn(fn) {}
+
+    bool addInput(
+        HashStringAllocator* /*allocator*/,
+        exec::optional_arg_type<TInputType> data) {
+      if (!data.has_value()) {
+        return false;
+      }
+      if (!sum.has_value()) {
+        // sum is initialized to 0. When it is nullopt, it implies that the
+        // count number of the input values must not be 0.
+        VELOX_CHECK(count != 0);
+        return true;
+      }
+      int128_t result;
+      overflow +=
+          DecimalUtil::addWithOverflow(result, data.value(), sum.value());
+      sum = result;
+      count += 1;
+      return true;
+    }
+
+    bool combine(
+        HashStringAllocator* /*allocator*/,
+        exec::optional_arg_type<Row<int128_t, int64_t>> other) {
+      if (!other.has_value()) {
+        return false;
+      }
+      auto const otherSum = other.value().template at<0>();
+      auto const otherCount = other.value().template at<1>();
+
+      // otherCount is never null.
+      VELOX_CHECK(otherCount.has_value());
+      if (count == 0 && otherCount.value() == 0) {
+        // Both accumulators have no input values, no need to do the
+        // combination.
+        return false;
+      }
+
+      bool currentOverflow = count > 0 && !sum.has_value();
+      bool otherOverflow = otherCount.value() > 0 && !otherSum.has_value();
+      if (currentOverflow || otherOverflow) {
+        sum = std::nullopt;
+        count += otherCount.value();
+      } else {
+        int128_t result;
+        overflow +=
+            DecimalUtil::addWithOverflow(result, otherSum.value(), sum.value());
+        sum = result;
+        count += otherCount.value();
+      }
+      return true;
+    }
+
+    bool writeIntermediateResult(
+        bool nonNullGroup,
+        exec::out_type<IntermediateType>& out) {
+      if (!nonNullGroup) {
+        // If a group is null, all values in this group are null. In Spark, this
+        // group will be the initial value, where sum is 0 and count is 0.
+        out =
+            std::make_tuple(static_cast<int128_t>(0), static_cast<int64_t>(0));
+      } else {
+        if (!sum.has_value()) {
+          // Sum should be set to null on overflow.
+          out.template set_null_at<0>();
+          out.template get_writer_at<1>() = count;
+        } else {
+          auto adjustedSum =
+              DecimalUtil::adjustSumForOverflow(sum.value(), overflow);
+          if (adjustedSum.has_value()) {
+            out = std::make_tuple(adjustedSum.value(), count);
+          } else {
+            out.template set_null_at<0>();
+            out.template get_writer_at<1>() = count;
+          }
+        }
+      }
+      return true;
+    }
+
+    bool writeFinalResult(bool nonNullGroup, exec::out_type<OutputType>& out) {
+      if (!nonNullGroup || count == 0) {
+        // In Spark, if all inputs are null, count will be 0, and the result of
+        // average value will be null.
+        return false;
+      }
+      auto finalResult = computeFinalResult();
+      if (finalResult.has_value()) {
+        out = static_cast<TResultType>(finalResult.value());
+        return true;
+      }
+      // Sum should be set to null on overflow.
+      return false;
+    }
+
+   private:
+    std::optional<int128_t> computeFinalResult() const {
+      if (!sum.has_value()) {
+        return std::nullopt;
+      }
+      const auto adjustedSum =
+          DecimalUtil::adjustSumForOverflow(sum.value(), overflow);
+      if (!adjustedSum.has_value()) {
+        // Found overflow during computing adjusted sum.
+        return std::nullopt;
+      }
+
+      auto [resultPrecision, resultScale] =
+          getDecimalPrecisionScale(*fn->resultType_.get());
+      auto [sumPrecision, sumScale] =
+          getDecimalPrecisionScale(*fn->sumType_.get());
+
+      // Spark use DECIMAL(20,0) to represent long value.
+      static const uint8_t countPrecision = 20;
+      static const uint8_t countScale = 0;
+
+      auto [dividePrecision, divideScale] =
+          functions::sparksql::DecimalUtil::computeDivideResultPrecisionScale<
+              true>(sumPrecision, sumScale, countPrecision, countScale);
+      divideScale = std::max<uint8_t>(divideScale, resultScale);
+      auto sumRescale = divideScale - sumScale + countScale;
+      int128_t avg;
+      bool overflow = false;
+      functions::sparksql::DecimalUtil::
+          divideWithRoundUp<int128_t, int128_t, int128_t>(
+              avg, adjustedSum.value(), count, sumRescale, overflow);
+      if (overflow) {
+        return std::nullopt;
+      }
+      TResultType rescaledValue;
+      const auto status =
+          DecimalUtil::rescaleWithRoundUp<int128_t, TResultType>(
+              avg,
+              dividePrecision,
+              divideScale,
+              resultPrecision,
+              resultScale,
+              rescaledValue);
+      return status.ok() ? std::optional<int128_t>(rescaledValue)
+                         : std::nullopt;
+    }
+  };
+
+  TypePtr resultType_;
+  TypePtr sumType_;
+};
+
+} // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/DecimalSumAggregate.h b/velox/functions/sparksql/aggregates/DecimalSumAggregate.h
index 90600879daf..f2fa1757562 100644
--- a/velox/functions/sparksql/aggregates/DecimalSumAggregate.h
+++ b/velox/functions/sparksql/aggregates/DecimalSumAggregate.h
@@ -30,9 +30,8 @@ class DecimalSumAggregate {
  public:
   using InputType = Row<TInputType>;
 
-  using IntermediateType =
-      Row</*sum*/ TSumType,
-          /*isEmpty*/ bool>;
+  using IntermediateType = Row</*sum*/ TSumType,
+                               /*isEmpty*/ bool>;
 
   using OutputType = TSumType;
 
diff --git a/velox/functions/sparksql/aggregates/FirstLastAggregate.cpp b/velox/functions/sparksql/aggregates/FirstLastAggregate.cpp
index 232ecf859be..4422953ca6a 100644
--- a/velox/functions/sparksql/aggregates/FirstLastAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/FirstLastAggregate.cpp
@@ -444,13 +444,14 @@ AggregateRegistrationResult registerFirstLast(
           .returnType("T")
           .build()};
 
-  signatures.push_back(AggregateFunctionSignatureBuilder()
-                           .integerVariable("a_precision")
-                           .integerVariable("a_scale")
-                           .argumentType("DECIMAL(a_precision, a_scale)")
-                           .intermediateType("DECIMAL(a_precision, a_scale)")
-                           .returnType("DECIMAL(a_precision, a_scale)")
-                           .build());
+  signatures.push_back(
+      AggregateFunctionSignatureBuilder()
+          .integerVariable("a_precision")
+          .integerVariable("a_scale")
+          .argumentType("DECIMAL(a_precision, a_scale)")
+          .intermediateType("DECIMAL(a_precision, a_scale)")
+          .returnType("DECIMAL(a_precision, a_scale)")
+          .build());
 
   return registerAggregateFunction(
       name,
diff --git a/velox/functions/sparksql/aggregates/MinMaxAggregate.cpp b/velox/functions/sparksql/aggregates/MinMaxAggregate.cpp
index 591db8f95d1..9d0186b428b 100644
--- a/velox/functions/sparksql/aggregates/MinMaxAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/MinMaxAggregate.cpp
@@ -25,12 +25,13 @@ exec::AggregateRegistrationResult registerMin(
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .orderableTypeVariable("T")
-                           .returnType("T")
-                           .intermediateType("T")
-                           .argumentType("T")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .orderableTypeVariable("T")
+          .returnType("T")
+          .intermediateType("T")
+          .argumentType("T")
+          .build());
   return exec::registerAggregateFunction(
       name,
       std::move(signatures),
@@ -45,7 +46,7 @@ exec::AggregateRegistrationResult registerMin(
             TimestampPrecision::kMicroseconds);
         return factory(step, argTypes, resultType, config);
       },
-      {false /*orderSensitive*/},
+      {.ignoreDuplicates = true, .orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
@@ -55,12 +56,13 @@ exec::AggregateRegistrationResult registerMax(
     bool withCompanionFunctions,
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .orderableTypeVariable("T")
-                           .returnType("T")
-                           .intermediateType("T")
-                           .argumentType("T")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .orderableTypeVariable("T")
+          .returnType("T")
+          .intermediateType("T")
+          .argumentType("T")
+          .build());
   return exec::registerAggregateFunction(
       name,
       std::move(signatures),
@@ -75,7 +77,7 @@ exec::AggregateRegistrationResult registerMax(
             TimestampPrecision::kMicroseconds);
         return factory(step, argTypes, resultType, config);
       },
-      {false /*orderSensitive*/},
+      {.ignoreDuplicates = true, .orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/sparksql/aggregates/MinMaxByAggregate.cpp b/velox/functions/sparksql/aggregates/MinMaxByAggregate.cpp
index eee3881f3a1..0d23e130cf5 100644
--- a/velox/functions/sparksql/aggregates/MinMaxByAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/MinMaxByAggregate.cpp
@@ -78,8 +78,12 @@ std::string toString(const std::vector<TypePtr>& types) {
 }
 
 template <
-    template <typename U, typename V, bool B1, class C, bool B2>
-    class Aggregate,
+    template <
+        typename U,
+        typename V,
+        bool B1,
+        class C,
+        bool B2> class Aggregate,
     bool isMaxFunc>
 exec::AggregateRegistrationResult registerMinMaxBy(
     const std::string& name,
@@ -87,14 +91,15 @@ exec::AggregateRegistrationResult registerMinMaxBy(
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
   // V, C -> row(V, C) -> V.
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .typeVariable("V")
-                           .orderableTypeVariable("C")
-                           .returnType("V")
-                           .intermediateType("row(V,C)")
-                           .argumentType("V")
-                           .argumentType("C")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .typeVariable("V")
+          .orderableTypeVariable("C")
+          .returnType("V")
+          .intermediateType("row(V,C)")
+          .argumentType("V")
+          .argumentType("C")
+          .build());
   const std::vector<std::string> supportedCompareTypes = {
       "boolean",
       "tinyint",
@@ -136,6 +141,7 @@ exec::AggregateRegistrationResult registerMinMaxBy(
               resultType, valueType, compareType, errorMessage);
         }
       },
+      {.ignoreDuplicates = true},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/sparksql/aggregates/ModeAggregate.cpp b/velox/functions/sparksql/aggregates/ModeAggregate.cpp
index f43b2ebe4ae..c13e8abacff 100644
--- a/velox/functions/sparksql/aggregates/ModeAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/ModeAggregate.cpp
@@ -586,7 +586,7 @@ void registerModeAggregate(
                 inputType->toString());
         }
       },
-      {false /*orderSensitive*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/sparksql/aggregates/Register.cpp b/velox/functions/sparksql/aggregates/Register.cpp
index 16a12e1c38d..d62249f527f 100644
--- a/velox/functions/sparksql/aggregates/Register.cpp
+++ b/velox/functions/sparksql/aggregates/Register.cpp
@@ -16,7 +16,9 @@
 
 #include "velox/functions/sparksql/aggregates/Register.h"
 
+#include "velox/functions/sparksql/aggregates/ApproxPercentileAggregate.h"
 #include "velox/functions/sparksql/aggregates/AverageAggregate.h"
+#include "velox/functions/sparksql/aggregates/BitmapConstructAggAggregate.h"
 #include "velox/functions/sparksql/aggregates/BitwiseXorAggregate.h"
 #include "velox/functions/sparksql/aggregates/BloomFilterAggAggregate.h"
 #include "velox/functions/sparksql/aggregates/CentralMomentsAggregate.h"
@@ -56,6 +58,8 @@ void registerAggregateFunctions(
   registerFirstLastAggregates(prefix, withCompanionFunctions, overwrite);
   registerMinMaxAggregates(prefix, withCompanionFunctions, overwrite);
   registerMinMaxByAggregates(prefix, withCompanionFunctions, overwrite);
+  registerBitmapConstructAggAggregate(
+      prefix + "bitmap_construct_agg", withCompanionFunctions, overwrite);
   registerBitwiseXorAggregate(prefix, withCompanionFunctions, overwrite);
   registerBloomFilterAggAggregate(
       prefix + "bloom_filter_agg", withCompanionFunctions, overwrite);
@@ -68,6 +72,7 @@ void registerAggregateFunctions(
   registerModeAggregate(prefix, withCompanionFunctions, overwrite);
   registerVarianceAggregate(prefix, withCompanionFunctions, overwrite);
   registerCovarianceAggregates(prefix, withCompanionFunctions, overwrite);
+  registerApproxPercentileAggregate(prefix, withCompanionFunctions, overwrite);
 }
 
 } // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/RegrReplacementAggregate.cpp b/velox/functions/sparksql/aggregates/RegrReplacementAggregate.cpp
index 05c841e20cb..3514e0ab8e9 100644
--- a/velox/functions/sparksql/aggregates/RegrReplacementAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/RegrReplacementAggregate.cpp
@@ -23,10 +23,9 @@ namespace {
 class RegrReplacementAggregate {
  public:
   using InputType = Row<double>;
-  using IntermediateType =
-      Row</*n*/ double,
-          /*avg*/ double,
-          /*m2*/ double>;
+  using IntermediateType = Row</*n*/ double,
+                               /*avg*/ double,
+                               /*m2*/ double>;
   using OutputType = double;
 
   static bool toIntermediate(
diff --git a/velox/functions/sparksql/aggregates/SumAggregate.cpp b/velox/functions/sparksql/aggregates/SumAggregate.cpp
index 6102f74cbce..92244d96c1d 100644
--- a/velox/functions/sparksql/aggregates/SumAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/SumAggregate.cpp
@@ -129,11 +129,12 @@ exec::AggregateRegistrationResult registerSum(
   };
 
   for (const auto& inputType : {"tinyint", "smallint", "integer", "bigint"}) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType("bigint")
-                             .intermediateType("bigint")
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType("bigint")
+            .intermediateType("bigint")
+            .argumentType(inputType)
+            .build());
   }
 
   return exec::registerAggregateFunction(
@@ -206,7 +207,6 @@ exec::AggregateRegistrationResult registerSum(
                 inputType->childAt(0),
                 inputType->childAt(0));
           }
-            [[fallthrough]];
           default:
             VELOX_UNREACHABLE(
                 "Unknown input type for {} aggregation {}",
diff --git a/velox/functions/sparksql/aggregates/tests/ApproxPercentileAggregateTest.cpp b/velox/functions/sparksql/aggregates/tests/ApproxPercentileAggregateTest.cpp
new file mode 100644
index 00000000000..cff351a856a
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/tests/ApproxPercentileAggregateTest.cpp
@@ -0,0 +1,676 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <algorithm>
+#include <cmath>
+#include <iomanip>
+
+#include "velox/common/base/RandomUtil.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+#include "velox/functions/sparksql/aggregates/Register.h"
+
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::functions::aggregate::test;
+
+namespace facebook::velox::functions::aggregate::sparksql::test {
+
+namespace {
+
+constexpr int32_t kSparkDefaultAccuracy = 10000;
+
+std::vector<TypePtr>
+getArgTypes(const TypePtr& dataType, int32_t accuracy, bool isArray) {
+  std::vector<TypePtr> argTypes;
+  argTypes.push_back(dataType);
+  if (!isArray) {
+    argTypes.push_back(DOUBLE());
+  } else {
+    argTypes.push_back(ARRAY(DOUBLE()));
+  }
+  // Always pass accuracy parameter to ensure consistency across aggregation
+  // stages.
+  if (accuracy >= 0) {
+    argTypes.push_back(BIGINT());
+  }
+  return argTypes;
+}
+
+// Build a function call string for spark_approx_percentile.
+std::string
+functionCall(bool keyed, double percentile, int32_t accuracy, bool isArray) {
+  std::ostringstream buf;
+  // Use fixed notation with enough precision to ensure double values
+  // are correctly parsed (e.g., 0.5 instead of 5e-1).
+  buf << std::fixed << std::setprecision(6);
+  int columnIndex = keyed ? 1 : 0;
+  buf << "spark_approx_percentile(c" << columnIndex++;
+  buf << ", ";
+  if (!isArray) {
+    buf << percentile;
+  } else {
+    buf << "ARRAY[";
+    for (int i = 0; i < 3; ++i) {
+      buf << (i == 0 ? "" : ",") << percentile;
+    }
+    buf << ']';
+  }
+  // Always pass accuracy parameter to ensure consistency across aggregation
+  // stages. Use default value (10000) when accuracy is 0.
+  if (accuracy >= 0) {
+    buf << ", " << (accuracy == 0 ? kSparkDefaultAccuracy : accuracy);
+  }
+  buf << ')';
+  return buf.str();
+}
+
+class ApproxPercentileAggregateTest : public AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+    // Register Spark aggregate functions with "spark_" prefix.
+    registerAggregateFunctions("spark_");
+    random::setSeed(0);
+    // Set fixed random seed for reproducible test results.
+    queryConfig_
+        [core::QueryConfig::kDebugAggregationApproxPercentileFixedRandomSeed] =
+            "0";
+  }
+
+  // Test global aggregation (no grouping keys).
+  template <typename T>
+  void testGlobalAgg(
+      const VectorPtr& values,
+      double percentile,
+      int32_t accuracy,
+      std::optional<T> expectedResult) {
+    SCOPED_TRACE(
+        fmt::format("percentile={} accuracy={}", percentile, accuracy));
+    auto rows = makeRowVector({values});
+
+    std::string expected;
+    std::string expectedArray;
+    if (!expectedResult.has_value()) {
+      expected = "SELECT NULL";
+      expectedArray = "SELECT NULL";
+    } else if (
+        (std::is_same<T, float>::value && std::isnan(expectedResult.value())) ||
+        (std::is_same<T, double>::value &&
+         std::isnan(expectedResult.value()))) {
+      expected = "SELECT 'NaN'";
+      expectedArray = fmt::format("SELECT ARRAY[{0},{0},{0}]", "'NaN'");
+    } else if (
+        (std::is_same<T, float>::value &&
+         expectedResult.value() == std::numeric_limits<float>::infinity()) ||
+        (std::is_same<T, double>::value &&
+         expectedResult.value() == std::numeric_limits<double>::infinity())) {
+      expected = "SELECT 'INFINITY'";
+      expectedArray = fmt::format("SELECT ARRAY[{0},{0},{0}]", "'INFINITY'");
+    } else if (
+        (std::is_same<T, float>::value &&
+         expectedResult.value() == -std::numeric_limits<float>::infinity()) ||
+        (std::is_same<T, double>::value &&
+         expectedResult.value() == -std::numeric_limits<double>::infinity())) {
+      expected = "SELECT '-INFINITY'";
+      expectedArray = fmt::format("SELECT ARRAY[{0},{0},{0}]", "'-INFINITY'");
+    } else {
+      expected = fmt::format("SELECT {}", expectedResult.value());
+      expectedArray =
+          fmt::format("SELECT ARRAY[{0},{0},{0}]", expectedResult.value());
+    }
+
+    // Test single percentile.
+    enableTestStreaming();
+    testAggregations(
+        {rows},
+        {},
+        {functionCall(false, percentile, accuracy, false)},
+        expected,
+        queryConfig_);
+
+    // Test percentile array (3 identical percentiles).
+    testAggregations(
+        {rows},
+        {},
+        {functionCall(false, percentile, accuracy, true)},
+        expectedArray,
+        queryConfig_);
+
+    // Companion functions of approx_percentile do not support test streaming
+    // because intermediate results are KLL that has non-deterministic shape.
+    disableTestStreaming();
+    testAggregationsWithCompanion(
+        {rows},
+        [](PlanBuilder& /*builder*/) {},
+        {},
+        {functionCall(false, percentile, accuracy, false)},
+        {getArgTypes(values->type(), accuracy, false)},
+        {},
+        expected,
+        queryConfig_);
+  }
+
+  // Test global aggregation with NaN and Infinity values for floating point.
+  template <typename T>
+  void testNaN() {
+    const T nan = std::is_same_v<T, float> ? std::nanf("") : std::nan("");
+    vector_size_t size = 10;
+    auto values = makeFlatVector<T>(size, [nan](auto row) {
+      if (row > 8)
+        return -std::numeric_limits<T>::infinity();
+      else if (row > 7)
+        return std::numeric_limits<T>::infinity();
+      else if (row > 6)
+        return nan;
+      else
+        return (T)row;
+    });
+
+    // Test various percentiles with special floating point values.
+    testGlobalAgg<T>(values, 0.05, 10000, -std::numeric_limits<T>::infinity());
+    testGlobalAgg<T>(values, 0.11, 10000, 0.0);
+    testGlobalAgg<T>(values, 0.55, 10000, 4.0);
+    testGlobalAgg<T>(values, 0.85, 10000, std::numeric_limits<T>::infinity());
+    testGlobalAgg<T>(values, 0.95, 10000, nan);
+  }
+
+  // Test group-by aggregation.
+  void testGroupByAgg(
+      const VectorPtr& keys,
+      const VectorPtr& values,
+      double percentile,
+      int32_t accuracy,
+      const RowVectorPtr& expectedResult) {
+    auto rows = makeRowVector({keys, values});
+
+    enableTestStreaming();
+    testAggregations(
+        {rows},
+        {"c0"},
+        {functionCall(true, percentile, accuracy, false)},
+        {expectedResult},
+        queryConfig_);
+
+    // Companion functions of approx_percentile do not support test streaming
+    // because intermediate results are KLL that has non-deterministic shape.
+    disableTestStreaming();
+    testAggregationsWithCompanion(
+        {rows},
+        [](PlanBuilder& /*builder*/) {},
+        {"c0"},
+        {functionCall(true, percentile, accuracy, false)},
+        {getArgTypes(values->type(), accuracy, false)},
+        {},
+        {expectedResult},
+        queryConfig_);
+
+    // Test percentile array.
+    {
+      SCOPED_TRACE("Percentile array");
+      auto resultValues = expectedResult->childAt(1);
+      RowVectorPtr expected = nullptr;
+      auto size = resultValues->size();
+      if (resultValues->nulls() &&
+          bits::countNonNulls(resultValues->rawNulls(), 0, size) == 0) {
+        expected = makeRowVector(
+            {expectedResult->childAt(0),
+             BaseVector::createNullConstant(
+                 ARRAY(resultValues->type()), size, pool())});
+      } else {
+        auto elements = BaseVector::create(
+            resultValues->type(), 3 * resultValues->size(), pool());
+        auto offsets = allocateOffsets(resultValues->size(), pool());
+        auto rawOffsets = offsets->asMutable<vector_size_t>();
+        auto sizes = allocateSizes(resultValues->size(), pool());
+        auto rawSizes = sizes->asMutable<vector_size_t>();
+        for (int i = 0; i < resultValues->size(); ++i) {
+          rawOffsets[i] = 3 * i;
+          rawSizes[i] = 3;
+          elements->copy(resultValues.get(), 3 * i + 0, i, 1);
+          elements->copy(resultValues.get(), 3 * i + 1, i, 1);
+          elements->copy(resultValues.get(), 3 * i + 2, i, 1);
+        }
+        expected = makeRowVector(
+            {expectedResult->childAt(0),
+             std::make_shared<ArrayVector>(
+                 pool(),
+                 ARRAY(elements->type()),
+                 nullptr,
+                 resultValues->size(),
+                 offsets,
+                 sizes,
+                 elements)});
+      }
+
+      enableTestStreaming();
+      testAggregations(
+          {rows},
+          {"c0"},
+          {functionCall(true, percentile, accuracy, true)},
+          {expected},
+          queryConfig_);
+    }
+  }
+
+ private:
+  std::unordered_map<std::string, std::string> queryConfig_;
+};
+
+// Test global aggregation with basic integer values.
+TEST_F(ApproxPercentileAggregateTest, globalAgg) {
+  vector_size_t size = 1'000;
+  auto values =
+      makeFlatVector<int32_t>(size, [](auto row) { return row % 23; });
+
+  // Test with default accuracy.
+  testGlobalAgg<int32_t>(values, 0.5, 0, 11);
+  // Test with explicit accuracy (10000 is Spark default).
+  testGlobalAgg<int32_t>(values, 0.5, 10000, 11);
+  // Test with higher accuracy.
+  testGlobalAgg<int32_t>(values, 0.5, 20000, 11);
+
+  // Test with null values.
+  auto valuesWithNulls = makeFlatVector<int32_t>(
+      size, [](auto row) { return row % 23; }, nullEvery(7));
+
+  testGlobalAgg<int32_t>(valuesWithNulls, 0.5, 0, 11);
+  testGlobalAgg<int32_t>(valuesWithNulls, 0.5, 10000, 11);
+}
+
+// Test group-by aggregation with integer values.
+TEST_F(ApproxPercentileAggregateTest, groupByAgg) {
+  vector_size_t size = 1'000;
+  auto keys = makeFlatVector<int32_t>(size, [](auto row) { return row % 7; });
+  auto values = makeFlatVector<int32_t>(
+      size, [](auto row) { return (row / 7) % 23 + row % 7; });
+
+  // Test with default accuracy.
+  auto expectedResult = makeRowVector(
+      {makeFlatVector(std::vector<int32_t>{0, 1, 2, 3, 4, 5, 6}),
+       makeFlatVector(std::vector<int32_t>{11, 12, 13, 14, 15, 16, 17})});
+  testGroupByAgg(keys, values, 0.5, 0, expectedResult);
+  testGroupByAgg(keys, values, 0.5, 10000, expectedResult);
+
+  // Test with null values.
+  auto valuesWithNulls = makeFlatVector<int32_t>(
+      size, [](auto row) { return (row / 7) % 23 + row % 7; }, nullEvery(11));
+
+  expectedResult = makeRowVector(
+      {makeFlatVector(std::vector<int32_t>{0, 1, 2, 3, 4, 5, 6}),
+       makeFlatVector(std::vector<int32_t>{11, 12, 13, 14, 15, 16, 17})});
+  testGroupByAgg(keys, valuesWithNulls, 0.5, 0, expectedResult);
+  testGroupByAgg(keys, valuesWithNulls, 0.5, 10000, expectedResult);
+}
+
+// Test Partial + Final aggregation mode (simulating distributed execution).
+TEST_F(ApproxPercentileAggregateTest, partialFinal) {
+  // Make sure partial aggregation runs out of memory after first batch.
+  CursorParameters params;
+  params.queryCtx = velox::core::QueryCtx::create(executor_.get());
+  params.queryCtx->testingOverrideConfigUnsafe({
+      {core::QueryConfig::kMaxPartialAggregationMemory, "300000"},
+  });
+
+  auto data = {
+      makeRowVector({
+          makeFlatVector<int32_t>(1'024, [](auto row) { return row % 117; }),
+          makeFlatVector<int32_t>(1'024, [](auto /*row*/) { return 10; }),
+      }),
+      makeRowVector({
+          makeFlatVector<int32_t>(1'024, [](auto row) { return row % 5; }),
+          makeFlatVector<int32_t>(1'024, [](auto /*row*/) { return 15; }),
+      }),
+      makeRowVector({
+          makeFlatVector<int32_t>(1'024, [](auto row) { return row % 7; }),
+          makeFlatVector<int32_t>(1'024, [](auto /*row*/) { return 20; }),
+      }),
+  };
+
+  // Build partial + final aggregation plan.
+  params.planNode =
+      PlanBuilder()
+          .values(data)
+          .project({"c0", "c1", "0.9995"})
+          .partialAggregation({"c0"}, {"spark_approx_percentile(c1, p2)"})
+          .finalAggregation()
+          .planNode();
+
+  auto expected = makeRowVector({
+      makeFlatVector<int32_t>(117, [](auto row) { return row; }),
+      makeFlatVector<int32_t>(117, [](auto row) { return row < 7 ? 20 : 10; }),
+  });
+  exec::test::assertQuery(params, {expected});
+  waitForAllTasksToBeDeleted();
+}
+
+// Test Partial + Final group-by aggregation.
+TEST_F(ApproxPercentileAggregateTest, partialFinalGroupBy) {
+  // Build test data with two groups.
+  auto groupKeys = makeFlatVector<int32_t>({1, 1, 1, 2, 2, 2});
+  auto values = makeFlatVector<int32_t>({3, 6, 9, 7, 10, 8});
+  auto inputRows = makeRowVector({groupKeys, values});
+
+  // Build Partial + Final plan with group-by.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values({inputRows})
+          .partialAggregation({"c0"}, {"spark_approx_percentile(c1, 0.5)"})
+          .finalAggregation()
+          .planNode();
+
+  // Expected: group 1 -> 6, group 2 -> 8.
+  auto expectedResult = makeRowVector(
+      {makeFlatVector<int32_t>({1, 2}), makeFlatVector<int32_t>({6, 8})});
+
+  AssertQueryBuilder(plan).assertResults(expectedResult);
+}
+
+// Test final aggregation accuracy by merging multiple partial results.
+TEST_F(ApproxPercentileAggregateTest, finalAggregateAccuracy) {
+  auto batch = makeRowVector(
+      {makeFlatVector<int32_t>(1000, [](auto row) { return row; })});
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  std::vector<std::shared_ptr<const core::PlanNode>> sources;
+  // Create 10 partial aggregation sources.
+  for (int i = 0; i < 10; ++i) {
+    sources.push_back(PlanBuilder(planNodeIdGenerator)
+                          .values({batch})
+                          .partialAggregation(
+                              {}, {"spark_approx_percentile(c0, 0.005, 10000)"})
+                          .planNode());
+  }
+  // Merge all partial results in final aggregation.
+  auto op = PlanBuilder(planNodeIdGenerator)
+                .localPartitionRoundRobin(sources)
+                .finalAggregation()
+                .planNode();
+  assertQuery(op, "SELECT 5");
+}
+
+// Test with non-flat (dictionary wrapped) percentile array.
+TEST_F(ApproxPercentileAggregateTest, nonFlatPercentileArray) {
+  auto indices = AlignedBuffer::allocate<vector_size_t>(3, pool());
+  auto rawIndices = indices->asMutable<vector_size_t>();
+  std::iota(rawIndices, rawIndices + indices->size(), 0);
+  auto percentiles = std::make_shared<ArrayVector>(
+      pool(),
+      ARRAY(DOUBLE()),
+      nullptr,
+      1,
+      AlignedBuffer::allocate<vector_size_t>(1, pool(), 0),
+      AlignedBuffer::allocate<vector_size_t>(1, pool(), 3),
+      BaseVector::wrapInDictionary(
+          nullptr, indices, 3, makeFlatVector<double>({0, 0.5, 1})));
+  auto rows = makeRowVector({
+      makeFlatVector<int32_t>(10, folly::identity),
+      BaseVector::wrapInConstant(1, 0, percentiles),
+  });
+  auto plan = PlanBuilder()
+                  .values({rows})
+                  .singleAggregation({}, {"spark_approx_percentile(c0, c1)"})
+                  .planNode();
+  auto expected = makeRowVector({makeArrayVector<int32_t>({{0, 5, 9}})});
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+// Test when all input values are NULL.
+TEST_F(ApproxPercentileAggregateTest, noInput) {
+  const int size = 1000;
+  auto keys = makeFlatVector<int32_t>(size, [](auto row) { return row % 7; });
+  auto values = makeFlatVector<int32_t>(size, [](auto row) { return row % 6; });
+  auto nullValues = makeNullConstant(TypeKind::INTEGER, size);
+
+  // Test global aggregation with all nulls.
+  testGlobalAgg<int32_t>(nullValues, 0.5, 0, std::nullopt);
+
+  // Test group-by aggregation with all nulls.
+  {
+    auto expected = makeRowVector(
+        {makeFlatVector<int32_t>({0, 1, 2, 3, 4, 5, 6}),
+         makeNullConstant(TypeKind::INTEGER, 7)});
+
+    testGroupByAgg(keys, nullValues, 0.5, 0, expected);
+  }
+
+  // Test when all inputs are masked out.
+  {
+    auto testWithMask = [&](bool groupBy, const RowVectorPtr& expected) {
+      std::vector<std::string> groupingKeys;
+      if (groupBy) {
+        groupingKeys.push_back("c0");
+      }
+      auto plan =
+          PlanBuilder()
+              .values({makeRowVector({keys, values})})
+              .project(
+                  {"c0", "c1", "array_constructor(0.5) as pct", "c1 > 6 as m1"})
+              .singleAggregation(
+                  groupingKeys,
+                  {"spark_approx_percentile(c1, 0.5)",
+                   "spark_approx_percentile(c1, 0.5, 10000)",
+                   "spark_approx_percentile(c1, pct)",
+                   "spark_approx_percentile(c1, pct, 10000)"},
+                  {"m1", "m1", "m1", "m1"})
+              .planNode();
+
+      AssertQueryBuilder(plan).assertResults(expected);
+    };
+
+    // Global aggregation with mask.
+    std::vector<VectorPtr> children{4};
+    std::fill_n(children.begin(), 2, makeNullConstant(TypeKind::INTEGER, 1));
+    std::fill_n(
+        children.begin() + 2,
+        2,
+        BaseVector::createNullConstant(ARRAY(INTEGER()), 1, pool()));
+    auto expected1 = makeRowVector(children);
+    testWithMask(false, expected1);
+
+    // Group-by aggregation with mask.
+    children.resize(5);
+    children[0] = makeFlatVector<int32_t>({0, 1, 2, 3, 4, 5, 6});
+    std::fill_n(
+        children.begin() + 1, 2, makeNullConstant(TypeKind::INTEGER, 7));
+    std::fill_n(
+        children.begin() + 3,
+        2,
+        BaseVector::createNullConstant(ARRAY(INTEGER()), 7, pool()));
+    auto expected2 = makeRowVector(children);
+    testWithMask(true, expected2);
+  }
+}
+
+// Test that null percentile parameter throws an error.
+TEST_F(ApproxPercentileAggregateTest, nullPercentile) {
+  auto values = makeFlatVector<int32_t>({1, 2, 3, 4});
+  auto percentileOfDouble = makeConstant<double>(std::nullopt, 4);
+  auto rows = makeRowVector({values, percentileOfDouble});
+
+  // Test null percentile for spark_approx_percentile(value, percentile).
+  VELOX_ASSERT_THROW(
+      testAggregations(
+          {rows}, {}, {"spark_approx_percentile(c0, c1)"}, "SELECT NULL"),
+      "Percentile cannot be null");
+
+  // Test null array percentile (entire array is null, not array with null
+  // elements). Note: Spark does not allow null elements within the percentile
+  // array. The percentile array itself can be null, which should throw an
+  // error.
+  auto percentileOfArrayOfDouble =
+      BaseVector::createNullConstant(ARRAY(DOUBLE()), 4, pool());
+  rows = makeRowVector({values, percentileOfArrayOfDouble});
+
+  // Test null array percentile for spark_approx_percentile(value, percentiles).
+  // When the entire percentile array is null, it triggers the null check
+  // in ArrayVector and throws "Percentile array cannot contain nulls".
+  VELOX_ASSERT_THROW(
+      testAggregations(
+          {rows}, {}, {"spark_approx_percentile(c0, c1)"}, "SELECT NULL"),
+      "Percentile array cannot contain nulls");
+}
+
+// Test with NaN values in floating point inputs.
+TEST_F(ApproxPercentileAggregateTest, nanPercentile) {
+  testNaN<float>();
+  testNaN<double>();
+}
+
+// Test with various numeric input types supported by Spark.
+// KLL sketch uses std::upper_bound to estimate percentile, so for 10 elements
+// {1,2,3,4,5,6,7,8,9,10}, the 50th percentile (weight=5) returns 6.
+TEST_F(ApproxPercentileAggregateTest, numericTypes) {
+  // Test TINYINT.
+  {
+    auto values = makeFlatVector<int8_t>({1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
+    testGlobalAgg<int8_t>(values, 0.5, 0, 6);
+  }
+
+  // Test SMALLINT.
+  {
+    auto values = makeFlatVector<int16_t>({1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
+    testGlobalAgg<int16_t>(values, 0.5, 0, 6);
+  }
+
+  // Test BIGINT.
+  {
+    auto values = makeFlatVector<int64_t>({1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
+    testGlobalAgg<int64_t>(values, 0.5, 0, 6);
+  }
+
+  // Test REAL (float).
+  {
+    auto values = makeFlatVector<float>(
+        {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f});
+    testGlobalAgg<float>(values, 0.5, 0, 6.0f);
+  }
+
+  // Test DOUBLE.
+  {
+    auto values = makeFlatVector<double>(
+        {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0});
+    testGlobalAgg<double>(values, 0.5, 0, 6.0);
+  }
+}
+
+// Test edge cases for percentile parameter values.
+TEST_F(ApproxPercentileAggregateTest, percentileEdgeCases) {
+  auto values = makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
+
+  // Test percentile = 0.0 (minimum).
+  testGlobalAgg<int32_t>(values, 0.0, 0, 1);
+
+  // Test percentile = 1.0 (maximum).
+  testGlobalAgg<int32_t>(values, 1.0, 0, 10);
+
+  // Test percentile = 0.25 (Q1).
+  testGlobalAgg<int32_t>(values, 0.25, 0, 3);
+
+  // Test percentile = 0.75 (Q3).
+  testGlobalAgg<int32_t>(values, 0.75, 0, 8);
+}
+
+// Test accuracy parameter boundary values.
+TEST_F(ApproxPercentileAggregateTest, accuracyBoundary) {
+  auto values = makeFlatVector<int32_t>(1000, [](auto row) { return row; });
+  auto rows = makeRowVector({values});
+
+  // Test with minimum valid accuracy - allow 480-520 range due to low accuracy.
+  {
+    auto plan =
+        PlanBuilder()
+            .values({rows})
+            .singleAggregation({}, {"spark_approx_percentile(c0, 0.5, 1)"})
+            .planNode();
+    auto result = AssertQueryBuilder(plan).copyResults(pool());
+    auto resultValue =
+        result->childAt(0)->as<SimpleVector<int32_t>>()->valueAt(0);
+    EXPECT_GE(resultValue, 480)
+        << "Result " << resultValue << " is below minimum expected 480";
+    EXPECT_LE(resultValue, 520)
+        << "Result " << resultValue << " is above maximum expected 520";
+  }
+
+  // Test with high accuracy - should be more precise.
+  testGlobalAgg<int32_t>(values, 0.5, 100000, 500);
+}
+
+// Test percentile array with multiple distinct percentiles.
+TEST_F(ApproxPercentileAggregateTest, multiplePercentiles) {
+  auto values = makeFlatVector<int32_t>(100, [](auto row) { return row; });
+  auto percentiles = makeArrayVector<double>({{0.1, 0.5, 0.9}});
+  auto rows = makeRowVector({
+      values,
+      BaseVector::wrapInConstant(100, 0, percentiles),
+  });
+
+  // Test with array of different percentiles [0.1, 0.5, 0.9].
+  auto plan = PlanBuilder()
+                  .values({rows})
+                  .singleAggregation({}, {"spark_approx_percentile(c0, c1)"})
+                  .planNode();
+
+  // Expected: approximately [10, 50, 90].
+  auto expected = makeRowVector({makeArrayVector<int32_t>({{10, 50, 90}})});
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+// Test that invalid accuracy throws an error.
+TEST_F(ApproxPercentileAggregateTest, invalidAccuracy) {
+  auto values = makeFlatVector<int32_t>({1, 2, 3, 4, 5});
+  auto rows = makeRowVector({values});
+
+  // Accuracy = 0 is invalid.
+  VELOX_ASSERT_THROW(
+      testAggregations(
+          {rows}, {}, {"spark_approx_percentile(c0, 0.5, 0)"}, "SELECT 3"),
+      "The accuracy must be between (0, 2147483647]");
+}
+
+// Test single row input.
+TEST_F(ApproxPercentileAggregateTest, singleRow) {
+  auto values = makeFlatVector<int32_t>(1, [](auto /*row*/) { return 42; });
+  testGlobalAgg<int32_t>(values, 0.5, 0, 42);
+  testGlobalAgg<int32_t>(values, 0.0, 0, 42);
+  testGlobalAgg<int32_t>(values, 1.0, 0, 42);
+}
+
+// Test large dataset for stress testing.
+TEST_F(ApproxPercentileAggregateTest, largeDataset) {
+  vector_size_t size = 100'000;
+  auto values = makeFlatVector<int32_t>(size, [](auto row) { return row; });
+  auto rows = makeRowVector({values});
+
+  // Median of 0..99999 should be approximately 50000, allow ±5 error.
+  auto plan =
+      PlanBuilder()
+          .values({rows})
+          .singleAggregation({}, {"spark_approx_percentile(c0, 0.5, 10000)"})
+          .planNode();
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+  auto resultValue =
+      result->childAt(0)->as<SimpleVector<int32_t>>()->valueAt(0);
+  EXPECT_GE(resultValue, 49995)
+      << "Result " << resultValue << " is below minimum expected 49995";
+  EXPECT_LE(resultValue, 50005)
+      << "Result " << resultValue << " is above maximum expected 50005";
+}
+
+} // namespace
+} // namespace facebook::velox::functions::aggregate::sparksql::test
diff --git a/velox/functions/sparksql/aggregates/tests/AverageAggregationTest.cpp b/velox/functions/sparksql/aggregates/tests/AverageAggregationTest.cpp
index 93057ef155a..9fe507c138b 100644
--- a/velox/functions/sparksql/aggregates/tests/AverageAggregationTest.cpp
+++ b/velox/functions/sparksql/aggregates/tests/AverageAggregationTest.cpp
@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <folly/init/Init.h>
 
-#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 #include "velox/functions/sparksql/aggregates/Register.h"
@@ -30,12 +30,55 @@ class AverageAggregationTest : public AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    registerAggregateFunctions("spark_");
+    disableTestIncremental();
+    registerAggregateFunctions("spark_", true);
+  }
+
+  void testGlobalAverage(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<RowVectorPtr>& expected,
+      const std::vector<TypePtr>& argTypes) {
+    testAggregations(
+        input,
+        {},
+        {"spark_avg(c0)"},
+        {},
+        expected,
+        /*config*/ {});
+  }
+
+  core::PlanNodePtr createMergeExtractDecimal(
+      const RowVectorPtr& intermediateInput,
+      const TypePtr& intermediateType,
+      const TypePtr& resultType) {
+    core::AggregationNode::Aggregate avgAggregate;
+    avgAggregate.call = std::make_shared<core::CallTypedExpr>(
+        resultType,
+        "spark_avg_merge_extract_DECIMAL",
+        std::vector<core::TypedExprPtr>{
+            std::make_shared<core::FieldAccessTypedExpr>(
+                intermediateType, "c0")});
+    avgAggregate.rawInputTypes = {intermediateType};
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto child =
+        PlanBuilder(planNodeIdGenerator).values({intermediateInput}).planNode();
+
+    return std::make_shared<core::AggregationNode>(
+        planNodeIdGenerator->next(),
+        core::AggregationNode::Step::kSingle,
+        std::vector<core::FieldAccessTypedExprPtr>{},
+        std::vector<core::FieldAccessTypedExprPtr>{},
+        std::vector<std::string>{"c0"},
+        std::vector{avgAggregate},
+        /*ignoreNullKeys=*/false,
+        /*noGroupsSpanBatches=*/false,
+        std::move(child));
   }
 };
 
 TEST_F(AverageAggregationTest, avgAllNulls) {
-  vector_size_t size = 1'000;
+  const vector_size_t size = 1'000;
   // Have two row vectors a least as it triggers different code paths.
   std::vector<RowVectorPtr> vectors = {
       makeRowVector({
@@ -110,5 +153,210 @@ TEST_F(AverageAggregationTest, avgAllNulls) {
   assertQuery(plan, expected);
 }
 
+TEST_F(AverageAggregationTest, avgDecimal) {
+  const int64_t kRescale = DecimalUtil::kPowersOfTen[4];
+  // Short decimal aggregation.
+  auto shortDecimal = makeNullableFlatVector<int64_t>(
+      {1'000, 2'000, 3'000, 4'000, 5'000, std::nullopt}, DECIMAL(12, 1));
+  auto shortDecimalInput = makeRowVector({shortDecimal});
+  auto shortDecimalExpected = makeRowVector(
+      {makeConstant<int64_t>(3'000 * kRescale, 1, DECIMAL(16, 5))});
+  testGlobalAverage(
+      {shortDecimalInput}, {shortDecimalExpected}, {DECIMAL(12, 1)});
+
+  // Long decimal aggregation.
+  auto longDecimalInput = makeRowVector({makeNullableFlatVector<int128_t>(
+      {HugeInt::build(10, 100),
+       HugeInt::build(10, 200),
+       HugeInt::build(10, 300),
+       HugeInt::build(10, 400),
+       HugeInt::build(10, 500),
+       std::nullopt},
+      DECIMAL(23, 4))});
+  auto longDecimalExpected = makeRowVector({makeConstant<int128_t>(
+      HugeInt::build(10, 300) * kRescale, 1, DECIMAL(27, 8))});
+  testGlobalAverage(
+      {longDecimalInput}, {longDecimalExpected}, {DECIMAL(23, 4)});
+
+  // The total sum overflows the max int128_t limit.
+  std::vector<int128_t> rawVector;
+  auto nullExpected = makeRowVector({makeNullableFlatVector(
+      std::vector<std::optional<int128_t>>{std::nullopt}, DECIMAL(38, 4))});
+  for (int i = 0; i < 10; ++i) {
+    rawVector.push_back(DecimalUtil::kLongDecimalMax);
+  }
+  testGlobalAverage(
+      {makeRowVector({makeFlatVector<int128_t>(rawVector, DECIMAL(38, 0))})},
+      {nullExpected},
+      {DECIMAL(38, 4)});
+
+  // The total sum underflows the min int128_t limit.
+  rawVector.clear();
+  for (int i = 0; i < 10; ++i) {
+    rawVector.push_back(DecimalUtil::kLongDecimalMin);
+  }
+  testGlobalAverage(
+      {makeRowVector({makeFlatVector<int128_t>(rawVector, DECIMAL(38, 0))})},
+      {nullExpected},
+      {DECIMAL(38, 4)});
+
+  // Test constant vector.
+  testGlobalAverage(
+      {makeRowVector({makeConstant<int64_t>(100, 10, DECIMAL(12, 2))})},
+      {makeRowVector(
+          {makeConstant<int64_t>(100 * kRescale, 1, DECIMAL(16, 6))})},
+      {DECIMAL(10, 2)});
+  auto newSize = shortDecimal->size() * 2;
+  auto indices = makeIndices(newSize, [&](int row) { return row / 2; });
+  auto dictVector = wrapInDictionary(indices, newSize, shortDecimal);
+  testGlobalAverage(
+      {makeRowVector({dictVector})}, {shortDecimalExpected}, {DECIMAL(12, 1)});
+
+  // Decimal average aggregation with multiple groups.
+  auto inputRows = {
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({1, 1}),
+           makeFlatVector<int64_t>({37220, 53450}, DECIMAL(15, 2))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({2, 2}),
+           makeFlatVector<int64_t>({10410, 9250}, DECIMAL(15, 2))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({3, 3}),
+           makeFlatVector<int64_t>({-12783, 0}, DECIMAL(15, 2))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({1, 2}),
+           makeFlatVector<int64_t>({23178, 41093}, DECIMAL(15, 2))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({2, 3}),
+           makeFlatVector<int64_t>({-10023, 5290}, DECIMAL(15, 2))}),
+  };
+  auto expectedResult = {
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({1}),
+           makeFlatVector(std::vector<int128_t>{379493333}, DECIMAL(19, 6))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({2}),
+           makeFlatVector(std::vector<int128_t>{126825000}, DECIMAL(19, 6))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({3}),
+           makeFlatVector(std::vector<int128_t>{-24976667}, DECIMAL(19, 6))})};
+  testAggregations(
+      inputRows,
+      {"c0"},
+      {"spark_avg(c1)"},
+      expectedResult,
+      /*config*/ {});
+
+  // dividePrecision greater than resultScale in computeFinalResult.
+  auto valueA = HugeInt::parse("11999999998800000000");
+  auto valueB = HugeInt::parse("12000000000000000000");
+  auto longDecimalInputRows = {makeRowVector(
+      {makeNullableFlatVector<int32_t>({1, 1, 1, 1, 1, 1, 1}),
+       makeFlatVector<int128_t>(
+           {valueA, valueA, valueA, valueB, valueB, valueB, valueB},
+           DECIMAL(38, 18))})};
+
+  auto longDecimalExpectedResult = {makeRowVector(
+      {makeNullableFlatVector<int32_t>({1}),
+       makeFlatVector(
+           std::vector<int128_t>{HugeInt::parse("119999999994857142857143")},
+           DECIMAL(38, 22))})};
+
+  testAggregations(
+      longDecimalInputRows,
+      {"c0"},
+      {"spark_avg(c1)"},
+      longDecimalExpectedResult);
+}
+
+TEST_F(AverageAggregationTest, avgDecimalWithMultipleRowVectors) {
+  const int64_t kRescale = DecimalUtil::kPowersOfTen[4];
+  auto inputRows = {
+      makeRowVector({makeFlatVector<int128_t>({100, 200}, DECIMAL(28, 2))}),
+      makeRowVector({makeFlatVector<int128_t>({300, 400}, DECIMAL(28, 2))}),
+      makeRowVector({makeFlatVector<int128_t>({500, 600}, DECIMAL(28, 2))}),
+  };
+  auto expectedResult = {makeRowVector(
+      {makeFlatVector(std::vector<int128_t>{350 * kRescale}, DECIMAL(32, 6))})};
+  testGlobalAverage(inputRows, expectedResult, {DECIMAL(28, 2)});
+}
+
+TEST_F(AverageAggregationTest, avgDecimalEmptyInput) {
+  auto inputRows = {
+      makeRowVector({makeFlatVector<int128_t>({}, DECIMAL(28, 2))}),
+  };
+  auto expectedResult = {makeRowVector({makeNullableFlatVector(
+      std::vector<std::optional<int128_t>>{std::nullopt}, DECIMAL(32, 6))})};
+  testGlobalAverage(inputRows, expectedResult, {DECIMAL(28, 2)});
+}
+
+TEST_F(AverageAggregationTest, avgDecimalZeroCount) {
+  auto intermediateInput = makeRowVector({makeRowVector(
+      {makeFlatVector<int128_t>(std::vector<int128_t>{0, 0, 0}, DECIMAL(22, 1)),
+       makeFlatVector<int64_t>(std::vector<int64_t>{0, 0, 0})})});
+
+  auto plan = createMergeExtractDecimal(
+      intermediateInput, ROW({DECIMAL(22, 1), BIGINT()}), DECIMAL(16, 5));
+
+  auto expected = makeRowVector({makeNullableFlatVector<int64_t>(
+      std::vector<std::optional<int64_t>>{std::nullopt}, DECIMAL(16, 5))});
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(AverageAggregationTest, avgDecimalCompanionPartial) {
+  std::vector<int64_t> shortDecimalRawVector;
+  int128_t sum = 0;
+  for (int i = 0; i < 100; ++i) {
+    shortDecimalRawVector.emplace_back(i * 1000);
+    sum += i * 1000;
+  }
+
+  auto input = makeRowVector(
+      {makeFlatVector<int64_t>(shortDecimalRawVector, DECIMAL(12, 1))});
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .singleAggregation({}, {"spark_avg_partial(c0)"})
+                  .planNode();
+  const std::vector<int128_t> sumVector = {sum};
+  const std::vector<int64_t> count = {100};
+  const auto expected = makeRowVector({makeRowVector(
+      {makeFlatVector<int128_t>(sumVector, DECIMAL(22, 1)),
+       makeFlatVector<int64_t>(count)})});
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(AverageAggregationTest, avgDecimalCompanionMerge) {
+  auto intermediateInput = makeRowVector({makeRowVector(
+      {makeFlatVector<int128_t>(
+           std::vector<int128_t>{1000, 2000, 3000}, DECIMAL(22, 1)),
+       makeFlatVector<int64_t>(std::vector<int64_t>{10, 10, 10})})});
+
+  auto plan = PlanBuilder()
+                  .values({intermediateInput})
+                  .singleAggregation({}, {"spark_avg_merge(c0)"})
+                  .planNode();
+  auto expected = makeRowVector({makeRowVector(
+      {makeFlatVector<int128_t>(std::vector<int128_t>{6000}, DECIMAL(22, 1)),
+       makeFlatVector<int64_t>(std::vector<int64_t>{30})})});
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(AverageAggregationTest, avgDecimalCompanionMergeExtract) {
+  auto intermediateInput = makeRowVector({makeRowVector(
+      {makeFlatVector<int128_t>(
+           std::vector<int128_t>{1000, 2000, 3000}, DECIMAL(22, 1)),
+       makeFlatVector<int64_t>(std::vector<int64_t>{10, 10, 10})})});
+
+  // Intermediate sum type is DECIMAL(22, 1), so the input type is
+  // DECIMAL(22-10,1)=DECIMAL(12,1), and the result type is
+  // DECIMAL(12+4,1+4)=DECIMAL(16,5)
+  auto plan = createMergeExtractDecimal(
+      intermediateInput, ROW({DECIMAL(22, 1), BIGINT()}), DECIMAL(16, 5));
+
+  auto expected = makeRowVector(
+      {makeFlatVector<int64_t>(std::vector<int64_t>{2000000}, DECIMAL(16, 5))});
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
 } // namespace
 } // namespace facebook::velox::functions::aggregate::sparksql::test
diff --git a/velox/functions/sparksql/aggregates/tests/BitmapConstructAggAggregateTest.cpp b/velox/functions/sparksql/aggregates/tests/BitmapConstructAggAggregateTest.cpp
new file mode 100644
index 00000000000..d1087c03ba6
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/tests/BitmapConstructAggAggregateTest.cpp
@@ -0,0 +1,240 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/BitUtil.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+#include "velox/functions/sparksql/aggregates/Register.h"
+
+namespace facebook::velox::functions::aggregate::sparksql::test {
+namespace {
+
+constexpr int32_t kBitmapNumBytes = 4096;
+
+class BitmapConstructAggAggregateTest
+    : public aggregate::test::AggregationTestBase {
+ public:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+    registerAggregateFunctions("");
+  }
+
+  // Returns a 4096-byte bitmap string with the specified bits set.
+  std::string makeBitmapString(const std::vector<int64_t>& positions) {
+    std::string bitmap(kBitmapNumBytes, '\0');
+    auto* data = reinterpret_cast<uint8_t*>(bitmap.data());
+    for (auto position : positions) {
+      bits::setBit(data, position);
+    }
+    return bitmap;
+  }
+
+  // Returns a single-row VARBINARY vector containing the bitmap.
+  VectorPtr makeBitmapWithBits(const std::vector<int64_t>& positions) {
+    return makeFlatVector({makeBitmapString(positions)}, VARBINARY());
+  }
+};
+
+TEST_F(BitmapConstructAggAggregateTest, basic) {
+  // Single group, several bit positions.
+  auto input = makeRowVector({makeFlatVector<int64_t>({0, 1, 7, 8, 100})});
+  auto expected = makeBitmapWithBits({0, 1, 7, 8, 100});
+
+  testAggregations(
+      {input}, {}, {"bitmap_construct_agg(c0)"}, {makeRowVector({expected})});
+}
+
+TEST_F(BitmapConstructAggAggregateTest, allNullInputReturnsZeroBitmap) {
+  // Spark contract: nullable = false, so all-null input produces all-zeros.
+  auto input = makeRowVector({makeNullableFlatVector<int64_t>(
+      {std::nullopt, std::nullopt, std::nullopt})});
+  auto expected = makeBitmapWithBits({});
+
+  testAggregations(
+      {input}, {}, {"bitmap_construct_agg(c0)"}, {makeRowVector({expected})});
+}
+
+TEST_F(BitmapConstructAggAggregateTest, emptyInputReturnsZeroBitmap) {
+  auto input = makeRowVector({makeFlatVector<int64_t>({})});
+  auto expected = makeBitmapWithBits({});
+
+  testAggregations(
+      {input}, {}, {"bitmap_construct_agg(c0)"}, {makeRowVector({expected})});
+}
+
+TEST_F(BitmapConstructAggAggregateTest, mixedNullAndValid) {
+  // Mix of null and valid values.
+  auto input = makeRowVector({makeNullableFlatVector<int64_t>(
+      {std::nullopt, 5, std::nullopt, 10, std::nullopt})});
+  auto expected = makeBitmapWithBits({5, 10});
+
+  testAggregations(
+      {input}, {}, {"bitmap_construct_agg(c0)"}, {makeRowVector({expected})});
+}
+
+TEST_F(BitmapConstructAggAggregateTest, groupBy) {
+  // Test with group-by: two groups, including one all-null group.
+  auto input = makeRowVector({
+      makeFlatVector<int32_t>({1, 1, 2, 2, 2}),
+      makeNullableFlatVector<int64_t>(
+          {0, 100, std::nullopt, std::nullopt, std::nullopt}),
+  });
+
+  // Group 1: bits 0 and 100 set. Group 2: all-zeros (all-null input).
+  auto bitmap1 = makeBitmapString({0, 100});
+  auto bitmap2 = makeBitmapString({});
+  auto expected = makeRowVector({
+      makeFlatVector<int32_t>({1, 2}),
+      makeFlatVector<StringView>(
+          {StringView(bitmap1), StringView(bitmap2)}, VARBINARY()),
+  });
+
+  testAggregations(
+      {input}, {"c0"}, {"bitmap_construct_agg(c1)"}, {}, {expected});
+}
+
+TEST_F(BitmapConstructAggAggregateTest, boundaryPositions) {
+  // Test min and max valid positions.
+  auto input = makeRowVector({makeFlatVector<int64_t>({0, 32767})});
+  auto expected = makeBitmapWithBits({0, 32767});
+
+  testAggregations(
+      {input}, {}, {"bitmap_construct_agg(c0)"}, {makeRowVector({expected})});
+}
+
+TEST_F(BitmapConstructAggAggregateTest, invalidPositionNegative) {
+  auto input = makeRowVector({makeFlatVector<int64_t>({-1})});
+  VELOX_ASSERT_THROW(
+      testAggregations(
+          {input},
+          {},
+          {"bitmap_construct_agg(c0)"},
+          std::vector<RowVectorPtr>{}),
+      "Bitmap position out of bounds");
+}
+
+TEST_F(BitmapConstructAggAggregateTest, invalidPositionTooLarge) {
+  auto input = makeRowVector({makeFlatVector<int64_t>({32768})});
+  VELOX_ASSERT_THROW(
+      testAggregations(
+          {input},
+          {},
+          {"bitmap_construct_agg(c0)"},
+          std::vector<RowVectorPtr>{}),
+      "Bitmap position out of bounds");
+}
+
+TEST_F(BitmapConstructAggAggregateTest, duplicatePositions) {
+  // Duplicate positions should result in same bitmap as unique.
+  auto input = makeRowVector({makeFlatVector<int64_t>({5, 5, 5, 10, 10})});
+  auto expected = makeBitmapWithBits({5, 10});
+
+  testAggregations(
+      {input}, {}, {"bitmap_construct_agg(c0)"}, {makeRowVector({expected})});
+}
+
+TEST_F(BitmapConstructAggAggregateTest, partialAndFinalAggregation) {
+  // Test that partial -> final merge works correctly.
+  // Split data across multiple batches to exercise intermediate merge.
+  auto batch1 = makeRowVector({makeFlatVector<int64_t>({0, 1, 2})});
+  auto batch2 = makeRowVector({makeFlatVector<int64_t>({3, 4, 5})});
+  auto expected = makeBitmapWithBits({0, 1, 2, 3, 4, 5});
+
+  testAggregations(
+      {batch1, batch2},
+      {},
+      {"bitmap_construct_agg(c0)"},
+      {makeRowVector({expected})});
+}
+
+TEST_F(BitmapConstructAggAggregateTest, invalidIntermediateSizeTooSmall) {
+  std::string tinyBitmap(1, '\xFF');
+  auto input = makeRowVector(
+      {makeFlatVector<StringView>({StringView(tinyBitmap)}, VARBINARY())});
+
+  auto plan =
+      exec::test::PlanBuilder()
+          .values({input})
+          .finalAggregation({}, {"bitmap_construct_agg(c0)"}, {{BIGINT()}})
+          .planNode();
+
+  VELOX_ASSERT_THROW(
+      exec::test::AssertQueryBuilder(plan).copyResults(pool()),
+      "Unexpected intermediate bitmap size");
+}
+
+TEST_F(BitmapConstructAggAggregateTest, invalidIntermediateSizeTooLarge) {
+  std::string bigBitmap(8192, '\x00');
+  auto input = makeRowVector(
+      {makeFlatVector<StringView>({StringView(bigBitmap)}, VARBINARY())});
+
+  auto plan =
+      exec::test::PlanBuilder()
+          .values({input})
+          .finalAggregation({}, {"bitmap_construct_agg(c0)"}, {{BIGINT()}})
+          .planNode();
+
+  VELOX_ASSERT_THROW(
+      exec::test::AssertQueryBuilder(plan).copyResults(pool()),
+      "Unexpected intermediate bitmap size");
+}
+
+TEST_F(BitmapConstructAggAggregateTest, nullIntermediateInFinalAggregation) {
+  // A null intermediate should be skipped; the result should still be a valid
+  // all-zeros bitmap (non-null output).
+  auto input = makeRowVector(
+      {makeNullableFlatVector<StringView>({std::nullopt}, VARBINARY())});
+
+  auto plan =
+      exec::test::PlanBuilder()
+          .values({input})
+          .finalAggregation({}, {"bitmap_construct_agg(c0)"}, {{BIGINT()}})
+          .planNode();
+
+  auto expected = makeRowVector({makeBitmapWithBits({})});
+  exec::test::AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(BitmapConstructAggAggregateTest, mergeMultipleIntermediates) {
+  // Two batches with disjoint positions exercise the 64-bit OR combine logic.
+  auto batch1 = makeRowVector({makeFlatVector<int64_t>({0})});
+  auto batch2 = makeRowVector({makeFlatVector<int64_t>({15})});
+  auto expected = makeBitmapWithBits({0, 15});
+
+  testAggregations(
+      {batch1, batch2},
+      {},
+      {"bitmap_construct_agg(c0)"},
+      {makeRowVector({expected})});
+}
+
+TEST_F(BitmapConstructAggAggregateTest, mergeOverlappingIntermediates) {
+  // Two batches with overlapping positions — OR produces union.
+  auto batch1 = makeRowVector({makeFlatVector<int64_t>({0})});
+  auto batch2 = makeRowVector({makeFlatVector<int64_t>({0, 1})});
+  auto expected = makeBitmapWithBits({0, 1});
+
+  testAggregations(
+      {batch1, batch2},
+      {},
+      {"bitmap_construct_agg(c0)"},
+      {makeRowVector({expected})});
+}
+
+} // namespace
+} // namespace facebook::velox::functions::aggregate::sparksql::test
diff --git a/velox/functions/sparksql/aggregates/tests/BloomFilterAggAggregateTest.cpp b/velox/functions/sparksql/aggregates/tests/BloomFilterAggAggregateTest.cpp
index d36fe420a91..3c02be15806 100644
--- a/velox/functions/sparksql/aggregates/tests/BloomFilterAggAggregateTest.cpp
+++ b/velox/functions/sparksql/aggregates/tests/BloomFilterAggAggregateTest.cpp
@@ -48,7 +48,7 @@ class BloomFilterAggAggregateTest
 TEST_F(BloomFilterAggAggregateTest, basic) {
   auto vectors = {makeRowVector({makeFlatVector<int64_t>(
       100, [](vector_size_t row) { return row % 9; })})};
-  auto expected = {makeRowVector({getSerializedBloomFilter(4)})};
+  auto expected = {makeRowVector({getSerializedBloomFilter(11)})};
   testAggregations(vectors, {}, {"bloom_filter_agg(c0, 5, 64)"}, expected);
 }
 
@@ -56,12 +56,15 @@ TEST_F(BloomFilterAggAggregateTest, bloomFilterAggArgument) {
   auto vectors = {makeRowVector({makeFlatVector<int64_t>(
       100, [](vector_size_t row) { return row % 9; })})};
 
-  auto expected1 = {makeRowVector({getSerializedBloomFilter(3)})};
+  auto expected1 = {makeRowVector({getSerializedBloomFilter(13)})};
   testAggregations(vectors, {}, {"bloom_filter_agg(c0, 6)"}, expected1);
 
-  // This capacity is kMaxNumBits / 16.
-  auto expected2 = {makeRowVector({getSerializedBloomFilter(262144)})};
+  auto expected2 = {makeRowVector({getSerializedBloomFilter(524'288)})};
   testAggregations(vectors, {}, {"bloom_filter_agg(c0)"}, expected2);
+
+  // Max bits case: bloom filter is at its largest possible size.
+  auto expected3 = {makeRowVector({getSerializedBloomFilter(4'194'304)})};
+  testAggregations(vectors, {}, {"bloom_filter_agg(c0, 10000000)"}, expected3);
 }
 
 TEST_F(BloomFilterAggAggregateTest, emptyInput) {
diff --git a/velox/functions/sparksql/aggregates/tests/CMakeLists.txt b/velox/functions/sparksql/aggregates/tests/CMakeLists.txt
index cb95097f93f..5e27ad17d11 100644
--- a/velox/functions/sparksql/aggregates/tests/CMakeLists.txt
+++ b/velox/functions/sparksql/aggregates/tests/CMakeLists.txt
@@ -14,7 +14,9 @@
 
 add_executable(
   velox_functions_spark_aggregates_test
+  ApproxPercentileAggregateTest.cpp
   AverageAggregationTest.cpp
+  BitmapConstructAggAggregateTest.cpp
   BitwiseXorAggregationTest.cpp
   BloomFilterAggAggregateTest.cpp
   CentralMomentsAggregationTest.cpp
diff --git a/velox/functions/sparksql/aggregates/tests/CollectListAggregateTest.cpp b/velox/functions/sparksql/aggregates/tests/CollectListAggregateTest.cpp
index 73088a47b62..a5935df9b43 100644
--- a/velox/functions/sparksql/aggregates/tests/CollectListAggregateTest.cpp
+++ b/velox/functions/sparksql/aggregates/tests/CollectListAggregateTest.cpp
@@ -123,5 +123,60 @@ TEST_F(CollectListAggregateTest, allNullsInput) {
       {expected},
       {});
 }
+
+std::unordered_map<std::string, std::string> makeConfig(bool ignoreNulls) {
+  return {{"spark.collect_list.ignore_nulls", ignoreNulls ? "true" : "false"}};
+}
+
+TEST_F(CollectListAggregateTest, respectNulls) {
+  // When ignoreNulls is false (RESPECT NULLS), nulls should be included.
+  auto input = makeRowVector({makeNullableFlatVector<int32_t>(
+      {1, 2, std::nullopt, 4, std::nullopt, 6})});
+  auto expected = makeRowVector({makeNullableArrayVector<int32_t>(
+      std::vector<std::vector<std::optional<int32_t>>>{
+          {1, 2, std::nullopt, 4, std::nullopt, 6}})});
+  std::vector<RowVectorPtr> expectedResult{expected};
+  testAggregations(
+      {input},
+      {},
+      {"spark_collect_list(c0)"},
+      expectedResult,
+      makeConfig(false));
+}
+
+TEST_F(CollectListAggregateTest, respectNullsGroupBy) {
+  auto data = makeRowVector(
+      {makeFlatVector<int32_t>({0, 0, 1, 1, 1}),
+       makeNullableFlatVector<int64_t>({std::nullopt, 1, 2, std::nullopt, 3})});
+  auto expected = makeRowVector(
+      {makeFlatVector<int32_t>({0, 1}),
+       makeNullableArrayVector<int64_t>(
+           std::vector<std::vector<std::optional<int64_t>>>{
+               {std::nullopt, 1}, {2, std::nullopt, 3}})});
+  std::vector<RowVectorPtr> expectedResult{expected};
+  testAggregations(
+      {data},
+      {"c0"},
+      {"spark_collect_list(c1)"},
+      {"c0", "a0"},
+      expectedResult,
+      makeConfig(false));
+}
+
+TEST_F(CollectListAggregateTest, respectNullsAllNulls) {
+  // When all inputs are null and ignoreNulls is false, output should be an
+  // array of nulls (not an empty array).
+  auto input = makeRowVector({makeAllNullFlatVector<int32_t>(3)});
+  auto expected = makeRowVector({makeNullableArrayVector<int32_t>(
+      std::vector<std::vector<std::optional<int32_t>>>{
+          {std::nullopt, std::nullopt, std::nullopt}})});
+  std::vector<RowVectorPtr> expectedResult{expected};
+  testAggregations(
+      {input},
+      {},
+      {"spark_collect_list(c0)"},
+      expectedResult,
+      makeConfig(false));
+}
 } // namespace
 } // namespace facebook::velox::functions::aggregate::sparksql::test
diff --git a/velox/functions/sparksql/aggregates/tests/CollectSetAggregateTest.cpp b/velox/functions/sparksql/aggregates/tests/CollectSetAggregateTest.cpp
index 64ece852b24..57d62c02bf6 100644
--- a/velox/functions/sparksql/aggregates/tests/CollectSetAggregateTest.cpp
+++ b/velox/functions/sparksql/aggregates/tests/CollectSetAggregateTest.cpp
@@ -43,7 +43,11 @@ TEST_F(CollectSetAggregateTest, global) {
   });
 
   testAggregations(
-      {data}, {}, {"collect_set(c0)"}, {"spark_array_sort(a0)"}, {expected});
+      {data},
+      {},
+      {"collect_set(c0, true)"},
+      {"spark_array_sort(a0)"},
+      {expected});
 
   // Null inputs.
   data = makeRowVector({
@@ -56,7 +60,11 @@ TEST_F(CollectSetAggregateTest, global) {
   });
 
   testAggregations(
-      {data}, {}, {"collect_set(c0)"}, {"spark_array_sort(a0)"}, {expected});
+      {data},
+      {},
+      {"collect_set(c0, true)"},
+      {"spark_array_sort(a0)"},
+      {expected});
 
   // All inputs are null.
   data = makeRowVector({
@@ -68,7 +76,11 @@ TEST_F(CollectSetAggregateTest, global) {
   });
 
   testAggregations(
-      {data}, {}, {"collect_set(c0)"}, {"spark_array_sort(a0)"}, {expected});
+      {data},
+      {},
+      {"collect_set(c0, true)"},
+      {"spark_array_sort(a0)"},
+      {expected});
 
   // NaN inputs are treated as distinct values.
   data = makeRowVector({
@@ -89,7 +101,11 @@ TEST_F(CollectSetAggregateTest, global) {
   });
 
   testAggregations(
-      {data}, {}, {"collect_set(c0)"}, {"spark_array_sort(a0)"}, {expected});
+      {data},
+      {},
+      {"collect_set(c0, true)"},
+      {"spark_array_sort(a0)"},
+      {expected});
 }
 
 TEST_F(CollectSetAggregateTest, noInputRow) {
@@ -98,7 +114,7 @@ TEST_F(CollectSetAggregateTest, noInputRow) {
   auto expected = makeRowVector({
       makeArrayVectorFromJson<int32_t>({"[]"}),
   });
-  testAggregations({data}, {}, {"collect_set(c0)"}, {}, {expected});
+  testAggregations({data}, {}, {"collect_set(c0, true)"}, {}, {expected});
 
   // No input row passes aggregate filter.
   const auto size = 1'000;
@@ -111,7 +127,7 @@ TEST_F(CollectSetAggregateTest, noInputRow) {
 
   auto op = exec::test::PlanBuilder()
                 .values({data})
-                .singleAggregation({}, {"collect_set(c0)"}, {"c1"})
+                .singleAggregation({}, {"collect_set(c0, true)"}, {"c1"})
                 .planNode();
   assertQuery(op, expected);
 
@@ -128,7 +144,7 @@ TEST_F(CollectSetAggregateTest, noInputRow) {
   });
   op = exec::test::PlanBuilder()
            .values({data})
-           .singleAggregation({"c0"}, {"collect_set(c1)"}, {"c2"})
+           .singleAggregation({"c0"}, {"collect_set(c1, true)"}, {"c2"})
            .planNode();
   assertQuery(op, expected);
 }
@@ -147,7 +163,7 @@ TEST_F(CollectSetAggregateTest, groupBy) {
   testAggregations(
       {data, data, data},
       {"c0"},
-      {"collect_set(c1)"},
+      {"collect_set(c1, true)"},
       {"c0", "spark_array_sort(a0)"},
       {expected});
 
@@ -178,7 +194,7 @@ TEST_F(CollectSetAggregateTest, groupBy) {
   testAggregations(
       {data, data, data},
       {"c0"},
-      {"collect_set(c1)"},
+      {"collect_set(c1, true)"},
       {"c0", "spark_array_sort(a0)"},
       {expected});
 
@@ -209,7 +225,7 @@ TEST_F(CollectSetAggregateTest, groupBy) {
   testAggregations(
       {data, data, data},
       {"c0"},
-      {"collect_set(c1)"},
+      {"collect_set(c1, true)"},
       {"c0", "spark_array_sort(a0)"},
       {expected});
 
@@ -222,7 +238,7 @@ TEST_F(CollectSetAggregateTest, groupBy) {
   });
 
   testFailingAggregations(
-      {data}, {"c0"}, {"collect_set(c1)"}, "Unsupported type MAP");
+      {data}, {"c0"}, {"collect_set(c1, true)"}, "Unsupported type MAP");
 }
 
 TEST_F(CollectSetAggregateTest, arrayWithNestedNulls) {
@@ -240,7 +256,11 @@ TEST_F(CollectSetAggregateTest, arrayWithNestedNulls) {
       {"[[1, 2, 3], [3, 4, 2, 6, 7], [4 ,5], [4 ,5, null]]"})});
 
   testAggregations(
-      {data}, {}, {"collect_set(c0)"}, {"spark_array_sort(a0)"}, {expected});
+      {data},
+      {},
+      {"collect_set(c0, true)"},
+      {"spark_array_sort(a0)"},
+      {expected});
 }
 
 TEST_F(CollectSetAggregateTest, rowWithNestedNull) {
@@ -261,7 +281,11 @@ TEST_F(CollectSetAggregateTest, rowWithNestedNull) {
   });
 
   testAggregations(
-      {data}, {}, {"collect_set(c0)"}, {"spark_array_sort(a0)"}, {expected});
+      {data},
+      {},
+      {"collect_set(c0, true)"},
+      {"spark_array_sort(a0)"},
+      {expected});
 }
 
 TEST_F(CollectSetAggregateTest, unknownType) {
@@ -272,14 +296,173 @@ TEST_F(CollectSetAggregateTest, unknownType) {
   auto expected = makeRowVector({
       makeArrayVectorFromJson<int32_t>({"[]"}),
   });
-  testAggregations({data}, {}, {"collect_set(c0)"}, {}, {expected});
+  testAggregations({data}, {}, {"collect_set(c0, true)"}, {}, {expected});
 
   // The grouping key is of UNKONWN type.
   expected = makeRowVector({
       makeNullConstant(TypeKind::UNKNOWN, 1),
       makeArrayVectorFromJson<int32_t>({"[]"}),
   });
-  testAggregations({data}, {"c0"}, {"collect_set(c0)"}, {}, {expected});
+  testAggregations({data}, {"c0"}, {"collect_set(c0, true)"}, {}, {expected});
+}
+
+// Verify the 1-arg collect_set(c0) defaults to ignoring nulls (Spark default).
+TEST_F(CollectSetAggregateTest, defaultIgnoreNulls) {
+  auto data = makeRowVector({
+      makeNullableFlatVector<int32_t>(
+          {1, 2, std::nullopt, 4, 5, std::nullopt, 4, 2}),
+  });
+
+  auto expected = makeRowVector({
+      makeArrayVectorFromJson<int32_t>({"[1, 2, 4, 5]"}),
+  });
+
+  // 1-arg signature: no explicit ignoreNulls boolean.
+  testAggregations(
+      {data}, {}, {"collect_set(c0)"}, {"spark_array_sort(a0)"}, {expected});
+
+  // All null inputs — returns empty array (nulls ignored).
+  data = makeRowVector({
+      makeAllNullFlatVector<int32_t>(5),
+  });
+
+  expected = makeRowVector({
+      makeArrayVectorFromJson<int32_t>({"[]"}),
+  });
+
+  testAggregations({data}, {}, {"collect_set(c0)"}, {}, {expected});
+}
+
+// Verify that collect_set(c0, true) correctly ignores null inputs.
+TEST_F(CollectSetAggregateTest, explicitIgnoreNullsTrue) {
+  auto data = makeRowVector({
+      makeNullableFlatVector<int32_t>(
+          {1, 2, std::nullopt, 4, 5, std::nullopt, 4, 2}),
+  });
+
+  auto expected = makeRowVector({
+      makeArrayVectorFromJson<int32_t>({"[1, 2, 4, 5]"}),
+  });
+
+  testAggregations(
+      {data},
+      {},
+      {"collect_set(c0, true)"},
+      {"spark_array_sort(a0)"},
+      {expected});
+
+  // All null inputs with ignoreNulls=true — returns empty array.
+  data = makeRowVector({
+      makeAllNullFlatVector<int32_t>(5),
+  });
+
+  expected = makeRowVector({
+      makeArrayVectorFromJson<int32_t>({"[]"}),
+  });
+
+  testAggregations({data}, {}, {"collect_set(c0, true)"}, {}, {expected});
+}
+
+TEST_F(CollectSetAggregateTest, respectNullsGlobal) {
+  // Mixed values and nulls.
+  auto data = makeRowVector({
+      makeNullableFlatVector<int32_t>(
+          {1, 2, std::nullopt, 4, 5, std::nullopt, 4, 2, 6, 7}),
+  });
+
+  auto expected = makeRowVector({
+      makeNullableArrayVector<int32_t>(
+          std::vector<std::vector<std::optional<int32_t>>>{
+              {1, 2, 4, 5, 6, 7, std::nullopt}}),
+  });
+
+  // Pass ignoreNulls=false as a constant boolean argument.
+  testAggregations(
+      {data},
+      {},
+      {"collect_set(c0, false)"},
+      {"spark_array_sort(a0)"},
+      {expected});
+
+  // All inputs are null — should return array with a single null element.
+  data = makeRowVector({
+      makeAllNullFlatVector<int32_t>(5),
+  });
+
+  expected = makeRowVector({
+      makeNullableArrayVector<int32_t>(
+          std::vector<std::vector<std::optional<int32_t>>>{{std::nullopt}}),
+  });
+
+  testAggregations({data}, {}, {"collect_set(c0, false)"}, {}, {expected});
+
+  // No null inputs — should behave same as collect_set.
+  data = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 3, 2, 1}),
+  });
+
+  expected = makeRowVector({
+      makeArrayVectorFromJson<int32_t>({"[1, 2, 3]"}),
+  });
+
+  testAggregations(
+      {data},
+      {},
+      {"collect_set(c0, false)"},
+      {"spark_array_sort(a0)"},
+      {expected});
+}
+
+TEST_F(CollectSetAggregateTest, respectNullsGroupBy) {
+  auto data = makeRowVector({
+      makeFlatVector<int16_t>({1, 1, 2, 2, 2, 1, 2, 1, 2, 1}),
+      makeNullableFlatVector<int32_t>(
+          {1,
+           std::nullopt,
+           3,
+           std::nullopt,
+           5,
+           std::nullopt,
+           3,
+           std::nullopt,
+           6,
+           1}),
+  });
+
+  // With RESPECT NULLS (ignoreNulls=false), null is included in the result set.
+  auto expected = makeRowVector({
+      makeFlatVector<int16_t>({1, 2}),
+      makeNullableArrayVector<int32_t>(
+          std::vector<std::vector<std::optional<int32_t>>>{
+              {1, std::nullopt}, {3, 5, 6, std::nullopt}}),
+  });
+
+  testAggregations(
+      {data},
+      {"c0"},
+      {"collect_set(c1, false)"},
+      {"c0", "spark_array_sort(a0)"},
+      {expected});
+
+  // All inputs null for a group.
+  data = makeRowVector({
+      makeFlatVector<int16_t>({1, 1, 2, 2}),
+      makeNullableFlatVector<int32_t>({1, 2, std::nullopt, std::nullopt}),
+  });
+
+  expected = makeRowVector({
+      makeFlatVector<int16_t>({1, 2}),
+      makeNullableArrayVector<int32_t>(
+          std::vector<std::vector<std::optional<int32_t>>>{
+              {1, 2}, {std::nullopt}}),
+  });
+
+  testAggregations(
+      {data},
+      {"c0"},
+      {"collect_set(c1, false)"},
+      {"c0", "spark_array_sort(a0)"},
+      {expected});
 }
 
 } // namespace
diff --git a/velox/functions/sparksql/aggregates/tests/FirstAggregateTest.cpp b/velox/functions/sparksql/aggregates/tests/FirstAggregateTest.cpp
index 45fde445610..b80dede536c 100644
--- a/velox/functions/sparksql/aggregates/tests/FirstAggregateTest.cpp
+++ b/velox/functions/sparksql/aggregates/tests/FirstAggregateTest.cpp
@@ -14,12 +14,13 @@
  * limitations under the License.
  */
 
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 #include "velox/functions/sparksql/aggregates/Register.h"
 
+using namespace facebook::velox::common::testutil;
 using namespace facebook::velox::functions::aggregate::test;
 using facebook::velox::exec::test::AssertQueryBuilder;
 using facebook::velox::exec::test::PlanBuilder;
@@ -533,7 +534,7 @@ TEST_F(FirstAggregateTest, spillingAndSorting) {
   auto results = AssertQueryBuilder(plan).copyResults(pool());
   exec::test::assertEqualResults({expected}, {results});
 
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillDirectory = TempDirectoryPath::create();
 
   exec::TestScopedSpillInjection scopedSpillInjection(100);
   results = AssertQueryBuilder(plan)
diff --git a/velox/functions/sparksql/aggregates/tests/SumAggregationTest.cpp b/velox/functions/sparksql/aggregates/tests/SumAggregationTest.cpp
index aa0e4762a7c..4d04781dc75 100644
--- a/velox/functions/sparksql/aggregates/tests/SumAggregationTest.cpp
+++ b/velox/functions/sparksql/aggregates/tests/SumAggregationTest.cpp
@@ -14,9 +14,12 @@
  * limitations under the License.
  */
 
+#include "velox/exec/AggregateUtil.h"
+#include "velox/exec/SimpleAggregateAdapter.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/functions/lib/aggregates/tests/SumTestBase.h"
+#include "velox/functions/sparksql/aggregates/DecimalSumAggregate.h"
 #include "velox/functions/sparksql/aggregates/Register.h"
 
 using facebook::velox::exec::test::PlanBuilder;
@@ -108,6 +111,148 @@ class SumAggregationTest : public SumTestBase {
         {expected},
         {});
   }
+
+  // Registers a dummy sum aggregate function whose result type cannot be
+  // resolved from the intermediate type. The "i_precision" variable is
+  // intentionally added to fail the intermediate-to-result type resolving.
+  exec::AggregateRegistrationResult registerDummySum(const std::string& name) {
+    std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
+        exec::AggregateFunctionSignatureBuilder()
+            .integerVariable("a_precision")
+            .integerVariable("a_scale")
+            .integerVariable("i_precision", "min(38, a_precision + 10)")
+            .integerVariable("r_precision", "min(38, a_precision + 10)")
+            .integerVariable("r_scale", "min(38, a_scale)")
+            .argumentType("DECIMAL(a_precision, a_scale)")
+            .intermediateType("ROW(DECIMAL(i_precision, r_scale), boolean)")
+            .returnType("DECIMAL(r_precision, r_scale)")
+            .build(),
+    };
+
+    return exec::registerAggregateFunction(
+        name,
+        std::move(signatures),
+        [this, name](
+            core::AggregationNode::Step step,
+            const std::vector<TypePtr>& argTypes,
+            const TypePtr& resultType,
+            const core::QueryConfig& /*config*/)
+            -> std::unique_ptr<exec::Aggregate> {
+          VELOX_CHECK_EQ(
+              argTypes.size(), 1, "{} takes only one argument", name);
+          auto inputType = argTypes[0];
+          switch (inputType->kind()) {
+            case TypeKind::BIGINT: {
+              if (inputType->isShortDecimal()) {
+                return constructDecimalSumAgg(
+                    step,
+                    argTypes,
+                    resultType,
+                    inputType,
+                    getDecimalSumType(resultType));
+              }
+              VELOX_NYI();
+            }
+            case TypeKind::HUGEINT: {
+              VELOX_CHECK(inputType->isLongDecimal());
+              // If inputType is long decimal,
+              // its output type is always long decimal.
+              return constructDecimalSumAgg(
+                  step,
+                  argTypes,
+                  resultType,
+                  inputType,
+                  getDecimalSumType(resultType));
+            }
+            case TypeKind::ROW: {
+              VELOX_DCHECK(!exec::isRawInput(step));
+              // For the intermediate aggregation step, input intermediate sum
+              // type is equal to final result sum type.
+              return constructDecimalSumAgg(
+                  step,
+                  argTypes,
+                  resultType,
+                  inputType->childAt(0),
+                  inputType->childAt(0));
+            }
+            default:
+              VELOX_NYI();
+          }
+        },
+        /*registerCompanionFunctions=*/true,
+        /*overwrite=*/true);
+  }
+
+ private:
+  // Copied from SumAggregate.cpp
+  TypePtr getDecimalSumType(const TypePtr& resultType) {
+    if (resultType->isRow()) {
+      // If the resultType is ROW, then the type if sum is the type of the first
+      // child of the ROW.
+      return resultType->childAt(0);
+    }
+    return resultType;
+  }
+
+  // Copied from SumAggregate.cpp
+  std::unique_ptr<exec::Aggregate> constructDecimalSumAgg(
+      core::AggregationNode::Step step,
+      const std::vector<TypePtr>& argTypes,
+      const TypePtr& resultType,
+      const TypePtr& inputType,
+      const TypePtr& sumType) {
+    uint8_t precision = getDecimalPrecisionScale(*sumType).first;
+    switch (precision) {
+      // The sum precision is calculated from the input precision with the
+      // formula min(p + 10, 38). Therefore, the sum precision must >= 11.
+#define PRECISION_CASE(precision)                                         \
+  case precision:                                                         \
+    if (inputType->isShortDecimal() && sumType->isShortDecimal()) {       \
+      return std::make_unique<exec::SimpleAggregateAdapter<               \
+          DecimalSumAggregate<int64_t, int64_t, precision>>>(             \
+          step, argTypes, resultType);                                    \
+    } else if (inputType->isShortDecimal() && sumType->isLongDecimal()) { \
+      return std::make_unique<exec::SimpleAggregateAdapter<               \
+          DecimalSumAggregate<int64_t, int128_t, precision>>>(            \
+          step, argTypes, resultType);                                    \
+    } else {                                                              \
+      return std::make_unique<exec::SimpleAggregateAdapter<               \
+          DecimalSumAggregate<int128_t, int128_t, precision>>>(           \
+          step, argTypes, resultType);                                    \
+    }
+      PRECISION_CASE(11)
+      PRECISION_CASE(12)
+      PRECISION_CASE(13)
+      PRECISION_CASE(14)
+      PRECISION_CASE(15)
+      PRECISION_CASE(16)
+      PRECISION_CASE(17)
+      PRECISION_CASE(18)
+      PRECISION_CASE(19)
+      PRECISION_CASE(20)
+      PRECISION_CASE(21)
+      PRECISION_CASE(22)
+      PRECISION_CASE(23)
+      PRECISION_CASE(24)
+      PRECISION_CASE(25)
+      PRECISION_CASE(26)
+      PRECISION_CASE(27)
+      PRECISION_CASE(28)
+      PRECISION_CASE(29)
+      PRECISION_CASE(30)
+      PRECISION_CASE(31)
+      PRECISION_CASE(32)
+      PRECISION_CASE(33)
+      PRECISION_CASE(34)
+      PRECISION_CASE(35)
+      PRECISION_CASE(36)
+      PRECISION_CASE(37)
+      PRECISION_CASE(38)
+#undef PRECISION_CASE
+      default:
+        VELOX_UNREACHABLE();
+    }
+  }
 };
 
 TEST_F(SumAggregationTest, overflow) {
@@ -486,5 +631,95 @@ TEST_F(SumAggregationTest, sumFloat) {
       {"spark_sum(c0)"},
       "SELECT sum(c0) FROM tmp");
 }
+
+// Spark executes aggregates using a mix of partial, intermediate, and final
+// aggregate functions. The planner translates Spark's aggregate modes into
+// corresponding Velox companion functions and assigns the "single" step to
+// Velox’s AggregationNode. This test verifies that such a plan can execute
+// successfully.
+TEST_F(SumAggregationTest, sumDistinct) {
+  auto input = makeRowVector({
+      makeFlatVector<int32_t>(100, [&](auto row) { return row; }),
+      makeFlatVector<int32_t>(100, [&](auto row) { return row * 2; }),
+  });
+  createDuckDbTable({input});
+
+  auto plan =
+      PlanBuilder()
+          .values({input})
+          .singleAggregation({"c0"}, {"avg_partial(c1)"})
+          .singleAggregation({"c0"}, {"avg_merge(a0)"})
+          .singleAggregation({}, {"sum_partial(c0)", "avg_merge(a0)"})
+          .singleAggregation(
+              {},
+              {"sum_merge_extract_bigint(a0)", "avg_merge_extract_double(a1)"})
+          .planNode();
+
+  assertQuery(plan, "SELECT sum(distinct c0), avg(c1) from tmp");
+}
+
+// A dummy sum aggregate function is registered for testing. This function's
+// result type cannot be inferred from the intermediate type. This test verifies
+// that the companion functions can be registered and that the plan executes
+// successfully.
+TEST_F(SumAggregationTest, dummySum) {
+  registerDummySum("dummy_sum");
+
+  auto input = makeRowVector({
+      makeFlatVector<int64_t>(
+          100, [&](auto row) { return row; }, nullptr, DECIMAL(18, 2)),
+      makeFlatVector<int32_t>(100, [&](auto row) { return row * 2; }),
+  });
+  createDuckDbTable({input});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto child =
+      PlanBuilder(planNodeIdGenerator)
+          .values({input})
+          .singleAggregation({"c0"}, {"avg_partial(c1)"})
+          .singleAggregation({"c0"}, {"avg_merge(a0)"})
+          .singleAggregation({}, {"dummy_sum_partial(c0)", "avg_merge(a0)"})
+          .planNode();
+
+  // "PlanBuilder::aggregation" relies on "inferTypes" to resolve the result
+  // type from intermediate type. In this test, we manually construct the
+  // AggregationNode to bypass the type inferring.
+  std::vector<core::AggregationNode::Aggregate> aggregates;
+  core::AggregationNode::Aggregate sumAggregate;
+  // Create the aggregate function: dummy_sum_merge_extract(a0).
+  sumAggregate.call = std::make_shared<core::CallTypedExpr>(
+      DECIMAL(28, 2),
+      "dummy_sum_merge_extract",
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(
+              ROW({DECIMAL(28, 2), BOOLEAN()}), "a0")});
+  sumAggregate.rawInputTypes = {ROW({DECIMAL(28, 2), BOOLEAN()})};
+  aggregates.emplace_back(sumAggregate);
+
+  core::AggregationNode::Aggregate avgAggregate;
+  // Create the aggregate function: avg_merge_extract_double(a1).
+  avgAggregate.call = std::make_shared<core::CallTypedExpr>(
+      DOUBLE(),
+      "avg_merge_extract_double",
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(
+              ROW({DOUBLE(), BIGINT()}), "a1")});
+  avgAggregate.rawInputTypes = {ROW({DOUBLE(), BIGINT()})};
+  aggregates.emplace_back(avgAggregate);
+
+  auto plan = std::make_shared<core::AggregationNode>(
+      planNodeIdGenerator->next(),
+      core::AggregationNode::Step::kSingle,
+      std::vector<core::FieldAccessTypedExprPtr>{},
+      std::vector<core::FieldAccessTypedExprPtr>{},
+      std::vector<std::string>{"c0", "c1"},
+      std::move(aggregates),
+      /*ignoreNullKeys=*/false,
+      /*noGroupsSpanBatches=*/false,
+      std::move(child));
+
+  assertQuery(plan, "SELECT sum(distinct c0), avg(c1) from tmp");
+}
+
 } // namespace
 } // namespace facebook::velox::functions::aggregate::sparksql::test
diff --git a/velox/functions/sparksql/benchmarks/CMakeLists.txt b/velox/functions/sparksql/benchmarks/CMakeLists.txt
index 1321fcbadbd..efe56b8328c 100644
--- a/velox/functions/sparksql/benchmarks/CMakeLists.txt
+++ b/velox/functions/sparksql/benchmarks/CMakeLists.txt
@@ -78,3 +78,11 @@ target_link_libraries(
   Folly::folly
   Folly::follybenchmark
 )
+
+add_executable(velox_sparksql_benchmarks_cast CastBenchmark.cpp)
+target_link_libraries(
+  velox_sparksql_benchmarks_cast
+  velox_functions_spark
+  velox_benchmark_builder
+  velox_vector_test_lib
+)
diff --git a/velox/functions/sparksql/benchmarks/CastBenchmark.cpp b/velox/functions/sparksql/benchmarks/CastBenchmark.cpp
new file mode 100644
index 00000000000..dfcab8372ed
--- /dev/null
+++ b/velox/functions/sparksql/benchmarks/CastBenchmark.cpp
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include "velox/benchmarks/ExpressionBenchmarkBuilder.h"
+#include "velox/functions/sparksql/registration/Register.h"
+
+using namespace facebook;
+
+using namespace facebook::velox;
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+  memory::MemoryManager::initialize(memory::MemoryManager::Options{});
+  functions::sparksql::registerFunctions("");
+
+  ExpressionBenchmarkBuilder benchmarkBuilder;
+  const vector_size_t vectorSize = 1000;
+  auto vectorMaker = benchmarkBuilder.vectorMaker();
+  auto decimalInput = vectorMaker.flatVector<int64_t>(
+      vectorSize, [&](auto j) { return 12345 * j; }, nullptr, DECIMAL(9, 2));
+  auto shortDecimalInput = vectorMaker.flatVector<int64_t>(
+      vectorSize,
+      [&](auto j) { return 123456789 * j; },
+      nullptr,
+      DECIMAL(18, 6));
+  auto smallDecimalInput = vectorMaker.flatVector<int64_t>(
+      vectorSize,
+      [&](auto j) { return 123456789 * j; },
+      nullptr,
+      DECIMAL(18, 17));
+  auto longDecimalInput = vectorMaker.flatVector<int128_t>(
+      vectorSize,
+      [&](auto j) {
+        return facebook::velox::HugeInt::build(12345 * j, 56789 * j + 12345);
+      },
+      nullptr,
+      DECIMAL(38, 16));
+
+  benchmarkBuilder
+      .addBenchmarkSet(
+          "cast_decimal_as_varchar",
+          vectorMaker.rowVector(
+              {"decimal", "short_decimal", "small_decimal", "long_decimal"},
+              {
+                  decimalInput,
+                  shortDecimalInput,
+                  smallDecimalInput,
+                  longDecimalInput,
+              }))
+      .addExpression(
+          "cast_decimal_to_inline_string", "cast (decimal as varchar)")
+      .addExpression("cast_short_decimal", "cast (short_decimal as varchar)")
+      .addExpression("cast_small_decimal", "cast (small_decimal as varchar)")
+      .addExpression("cast_long_decimal", "cast (long_decimal as varchar)")
+      .withIterations(100)
+      .disableTesting();
+
+  benchmarkBuilder.registerBenchmarks();
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/functions/sparksql/benchmarks/FunctionBenchmark.cpp b/velox/functions/sparksql/benchmarks/FunctionBenchmark.cpp
index f6e276fea5e..aeba3e0083f 100644
--- a/velox/functions/sparksql/benchmarks/FunctionBenchmark.cpp
+++ b/velox/functions/sparksql/benchmarks/FunctionBenchmark.cpp
@@ -29,7 +29,7 @@ class FunctionBenchmark : public functions::test::FunctionBenchmarkBase {
   }
 
   void run() {
-    volatile int total = 0;
+    int total = 0;
     for (auto i = 0; i < 1000; i++) {
       auto functions = getFunctionSignatures();
       auto size = functions.size();
diff --git a/velox/functions/sparksql/fuzzer/CMakeLists.txt b/velox/functions/sparksql/fuzzer/CMakeLists.txt
index 4caa7a87f39..2c3c9403920 100644
--- a/velox/functions/sparksql/fuzzer/CMakeLists.txt
+++ b/velox/functions/sparksql/fuzzer/CMakeLists.txt
@@ -82,6 +82,10 @@ add_library(
   ${GRPC_SRCS}
   SparkQueryRunner.cpp
   SparkQueryRunnerToSqlPlanNodeVisitor.cpp
+  # Headers listed as sources (not FILE_SET) because they include generated
+  # proto files that only exist after the custom_command runs.
+  SparkQueryRunner.h
+  SparkQueryRunnerToSqlPlanNodeVisitor.h
 )
 
 target_include_directories(velox_spark_query_runner PUBLIC ${PROJECT_BINARY_DIR}/spark/connect/)
@@ -118,3 +122,14 @@ target_link_libraries(
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
 endif()
+
+velox_add_library(
+  velox_spark_aggregation_fuzzer_lib
+  INTERFACE
+  HEADERS
+  AddSubtractArgTypesGenerator.h
+  DivideArgTypesGenerator.h
+  MakeTimestampArgTypesGenerator.h
+  MultiplyArgTypesGenerator.h
+  UnscaledValueArgTypesGenerator.h
+)
diff --git a/velox/functions/sparksql/fuzzer/SparkAggregationFuzzerTest.cpp b/velox/functions/sparksql/fuzzer/SparkAggregationFuzzerTest.cpp
index 5026dbe8309..adb7ee0d6fd 100644
--- a/velox/functions/sparksql/fuzzer/SparkAggregationFuzzerTest.cpp
+++ b/velox/functions/sparksql/fuzzer/SparkAggregationFuzzerTest.cpp
@@ -30,6 +30,9 @@
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/serializers/UnsafeRowSerializer.h"
 
+DECLARE_int32(batch_size);
+DECLARE_int32(num_batches);
+
 DEFINE_int64(
     seed,
     0,
@@ -56,31 +59,40 @@ int main(int argc, char** argv) {
   folly::Init init(&argc, &argv);
 
   facebook::velox::functions::prestosql::registerInternalFunctions();
-  if (!isRegisteredNamedVectorSerde(
-          facebook::velox::VectorSerde::Kind::kPresto)) {
+  if (!facebook::velox::isRegisteredNamedVectorSerde("Presto")) {
     facebook::velox::serializer::presto::PrestoVectorSerde::
         registerNamedVectorSerde();
   }
-  if (!isRegisteredNamedVectorSerde(
-          facebook::velox::VectorSerde::Kind::kCompactRow)) {
+  if (!facebook::velox::isRegisteredNamedVectorSerde("CompactRow")) {
     facebook::velox::serializer::CompactRowVectorSerde::
         registerNamedVectorSerde();
   }
-  if (!isRegisteredNamedVectorSerde(
-          facebook::velox::VectorSerde::Kind::kUnsafeRow)) {
+  if (!facebook::velox::isRegisteredNamedVectorSerde("UnsafeRow")) {
     facebook::velox::serializer::spark::UnsafeRowVectorSerde::
         registerNamedVectorSerde();
   }
   facebook::velox::memory::MemoryManager::initialize(
       facebook::velox::memory::MemoryManager::Options{});
 
+  // Spark reference execution uses gRPC and can be sensitive to large
+  // payloads. Keep generated input sizes modest to reduce transport and
+  // memory pressure.
+  FLAGS_batch_size = 40;
+  FLAGS_num_batches = 4;
+
   // Spark does not provide user-accessible aggregate functions with the
   // following names.
   std::unordered_set<std::string> skipFunctions = {
       "bloom_filter_agg",
+      // Velox registers a 2-arg collect_set(T, boolean) signature that Spark
+      // doesn't support. The fuzzer may pick this signature and fail.
+      "collect_set",
       "first_ignore_null",
       "last_ignore_null",
       "regr_replacement",
+      // https://github.com/facebookincubator/velox/issues/17124
+      // Correctness mismatches and OOM during KLL sketch operations.
+      "approx_percentile",
   };
 
   using facebook::velox::exec::test::TransformResultVerifier;
diff --git a/velox/functions/sparksql/fuzzer/SparkQueryRunner.cpp b/velox/functions/sparksql/fuzzer/SparkQueryRunner.cpp
index 451ce15c83a..1dd50dbb683 100644
--- a/velox/functions/sparksql/fuzzer/SparkQueryRunner.cpp
+++ b/velox/functions/sparksql/fuzzer/SparkQueryRunner.cpp
@@ -26,12 +26,13 @@
 #include "arrow/status.h"
 #include "grpc/grpc.h" // @manual
 #include "velox/common/base/Fs.h"
+#include "velox/common/testutil/TempFilePath.h"
+#include "velox/dwio/common/Arena.h"
 #include "velox/dwio/common/WriterFactory.h"
 #include "velox/dwio/parquet/writer/Writer.h"
 #include "velox/exec/fuzzer/FuzzerUtil.h"
 #include "velox/exec/fuzzer/PrestoSql.h"
 #include "velox/exec/tests/utils/QueryAssertions.h"
-#include "velox/exec/tests/utils/TempFilePath.h"
 #include "velox/functions/sparksql/fuzzer/SparkQueryRunnerToSqlPlanNodeVisitor.h"
 #include "velox/functions/sparksql/fuzzer/spark/connect/base.pb.h"
 #include "velox/functions/sparksql/fuzzer/spark/connect/relations.pb.h"
@@ -40,6 +41,10 @@
 using namespace spark::connect;
 
 namespace facebook::velox::functions::sparksql::fuzzer {
+using namespace facebook::velox::common::testutil;
+
+using dwio::common::ArenaCreate;
+
 namespace {
 
 void writeToFile(
@@ -141,19 +146,20 @@ SparkQueryRunner::executeAndReturnVector(const core::PlanNodePtr& plan) {
       }
 
       auto writerPool = aggregatePool()->addAggregateChild("writer");
-      std::vector<std::shared_ptr<exec::test::TempFilePath>> tempFiles;
+      std::vector<std::shared_ptr<TempFilePath>> tempFiles;
       tempFiles.reserve(inputMap.size());
       for (const auto& [tableName, input] : inputMap) {
-        auto tempFile = exec::test::TempFilePath::create();
+        auto tempFile = TempFilePath::create();
         tempFiles.emplace_back(tempFile);
         const auto& filePath = tempFile->getPath();
         writeToFile(filePath, input, writerPool.get());
         // Create temporary view for this table in Spark by reading the
         // generated Parquet file.
-        execute(fmt::format(
-            "CREATE OR REPLACE TEMPORARY VIEW {} AS (SELECT * from parquet.`file://{}`);",
-            tableName,
-            filePath));
+        execute(
+            fmt::format(
+                "CREATE OR REPLACE TEMPORARY VIEW {} AS (SELECT * from parquet.`file://{}`);",
+                tableName,
+                filePath));
       }
 
       // Run the query.
@@ -177,21 +183,20 @@ SparkQueryRunner::executeAndReturnVector(const core::PlanNodePtr& plan) {
 
 std::vector<RowVectorPtr> SparkQueryRunner::execute(
     const std::string& content) {
-  auto sql = google::protobuf::Arena::CreateMessage<SQL>(&arena_);
+  auto sql = ArenaCreate<SQL>(&arena_);
   sql->set_query(content);
 
-  auto relation = google::protobuf::Arena::CreateMessage<Relation>(&arena_);
+  auto relation = ArenaCreate<Relation>(&arena_);
   relation->set_allocated_sql(sql);
 
-  auto plan = google::protobuf::Arena::CreateMessage<Plan>(&arena_);
+  auto plan = ArenaCreate<Plan>(&arena_);
   plan->set_allocated_root(relation);
 
-  auto context = google::protobuf::Arena::CreateMessage<UserContext>(&arena_);
+  auto context = ArenaCreate<UserContext>(&arena_);
   context->set_user_id(userId_);
   context->set_user_name(userName_);
 
-  auto request =
-      google::protobuf::Arena::CreateMessage<ExecutePlanRequest>(&arena_);
+  auto request = ArenaCreate<ExecutePlanRequest>(&arena_);
   request->set_session_id(sessionId_);
   request->set_allocated_user_context(context);
   request->set_allocated_plan(plan);
diff --git a/velox/functions/sparksql/fuzzer/SparkQueryRunner.h b/velox/functions/sparksql/fuzzer/SparkQueryRunner.h
index 9e27629f4b0..d7c54ed3e4b 100644
--- a/velox/functions/sparksql/fuzzer/SparkQueryRunner.h
+++ b/velox/functions/sparksql/fuzzer/SparkQueryRunner.h
@@ -44,9 +44,11 @@ class SparkQueryRunner : public velox::exec::test::ReferenceQueryRunner {
         userId_(userId),
         userName_(userName),
         sessionId_(generateUUID()),
-        stub_(spark::connect::SparkConnectService::NewStub(grpc::CreateChannel(
-            coordinatorUri,
-            grpc::InsecureChannelCredentials()))) {
+        stub_(
+            spark::connect::SparkConnectService::NewStub(
+                grpc::CreateChannel(
+                    coordinatorUri,
+                    grpc::InsecureChannelCredentials()))) {
     pool_ = aggregatePool()->addLeafChild("leaf");
     copyPool_ = aggregatePool()->addLeafChild("copy");
   };
diff --git a/velox/functions/sparksql/fuzzer/SparkQueryRunnerToSqlPlanNodeVisitor.h b/velox/functions/sparksql/fuzzer/SparkQueryRunnerToSqlPlanNodeVisitor.h
index febe8278065..63b38915867 100644
--- a/velox/functions/sparksql/fuzzer/SparkQueryRunnerToSqlPlanNodeVisitor.h
+++ b/velox/functions/sparksql/fuzzer/SparkQueryRunnerToSqlPlanNodeVisitor.h
@@ -93,6 +93,16 @@ class SparkQueryRunnerToSqlPlanNodeVisitor
     VELOX_NYI();
   }
 
+  void visit(const core::MarkSortedNode&, core::PlanNodeVisitorContext&)
+      const override {
+    VELOX_NYI();
+  }
+
+  void visit(const core::EnforceDistinctNode&, core::PlanNodeVisitorContext&)
+      const override {
+    VELOX_NYI();
+  }
+
   void visit(const core::MergeExchangeNode&, core::PlanNodeVisitorContext&)
       const override {
     VELOX_NYI();
@@ -186,6 +196,11 @@ class SparkQueryRunnerToSqlPlanNodeVisitor
       const override {
     VELOX_NYI();
   }
+
+  void visit(const core::MixedUnionNode&, core::PlanNodeVisitorContext&)
+      const override {
+    VELOX_NYI();
+  }
 };
 
 } // namespace facebook::velox::functions::sparksql::fuzzer
diff --git a/velox/functions/sparksql/registration/CMakeLists.txt b/velox/functions/sparksql/registration/CMakeLists.txt
index 93d15ce84a9..bb54b4f4213 100644
--- a/velox/functions/sparksql/registration/CMakeLists.txt
+++ b/velox/functions/sparksql/registration/CMakeLists.txt
@@ -28,6 +28,8 @@ velox_add_library(
   RegisterSpecialForm.cpp
   RegisterString.cpp
   RegisterUrl.cpp
+  HEADERS
+  Register.h
 )
 
 # GCC 12 has a bug where it does not respect "pragma ignore" directives and ends
diff --git a/velox/functions/sparksql/registration/RegisterArray.cpp b/velox/functions/sparksql/registration/RegisterArray.cpp
index ed4863e0126..c0b9eba9951 100644
--- a/velox/functions/sparksql/registration/RegisterArray.cpp
+++ b/velox/functions/sparksql/registration/RegisterArray.cpp
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/expression/ExprRewriteRegistry.h"
 #include "velox/functions/lib/ArrayRemoveNullFunction.h"
 #include "velox/functions/lib/ArrayShuffle.h"
 #include "velox/functions/lib/RegistrationHelpers.h"
@@ -26,6 +27,7 @@
 #include "velox/functions/sparksql/ArrayMinMaxFunction.h"
 #include "velox/functions/sparksql/ArrayPrepend.h"
 #include "velox/functions/sparksql/ArraySort.h"
+#include "velox/functions/sparksql/SimpleComparisonMatcher.h"
 
 namespace facebook::velox::functions {
 
@@ -33,7 +35,6 @@ namespace facebook::velox::functions {
 // vector function definition.
 // Higher order functions.
 void registerSparkArrayFunctions(const std::string& prefix) {
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_transform, prefix + "transform");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_reduce, prefix + "aggregate");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_array_constructor, prefix + "array");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_array_contains, prefix + "array_contains");
@@ -44,12 +45,12 @@ void registerSparkArrayFunctions(const std::string& prefix) {
   VELOX_REGISTER_VECTOR_FUNCTION(udf_array_position, prefix + "array_position");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_zip, prefix + "arrays_zip");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_any_match, prefix + "exists");
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_array_filter, prefix + "filter");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_all_match, prefix + "forall");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_zip_with, prefix + "zip_with");
 }
 
 namespace sparksql {
+
 template <typename T>
 inline void registerArrayConcatFunction(const std::string& prefix) {
   registerFunction<
@@ -214,11 +215,23 @@ void registerArrayFunctions(const std::string& prefix) {
   registerArrayRemoveFunctions(prefix);
   registerArrayPrependFunctions(prefix);
   registerSparkArrayFunctions(prefix);
+  // Register Spark-specific filter with index support.
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_spark_filter, prefix + "filter");
+  // Register Spark-specific transform with index support.
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_spark_transform, prefix + "transform");
   // Register array sort functions.
   exec::registerStatefulVectorFunction(
-      prefix + "array_sort", arraySortSignatures(), makeArraySort);
+      prefix + "array_sort", arraySortSignatures(true), makeArraySortAsc);
+  exec::registerStatefulVectorFunction(
+      prefix + "array_sort_desc", arraySortDescSignatures(), makeArraySortDesc);
   exec::registerStatefulVectorFunction(
       prefix + "sort_array", sortArraySignatures(), makeSortArray);
+
+  auto checker = std::make_shared<SparkSimpleComparisonChecker>();
+  expression::ExprRewriteRegistry::instance().registerRewrite(
+      [prefix, checker](const auto& expr) {
+        return rewriteArraySortCall(prefix, expr, checker);
+      });
   exec::registerStatefulVectorFunction(
       prefix + "array_repeat",
       repeatSignatures(),
@@ -242,6 +255,7 @@ void registerArrayFunctions(const std::string& prefix) {
       makeArrayShuffleWithCustomSeed,
       getMetadataForArrayShuffle());
   registerIntegerSliceFunction(prefix);
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_spark_sequence, prefix + "sequence");
   registerFunction<
       ArrayAppendFunction,
       Array<Generic<T1>>,
diff --git a/velox/functions/sparksql/registration/RegisterDatetime.cpp b/velox/functions/sparksql/registration/RegisterDatetime.cpp
index c3b758ce3f8..694bab5f498 100644
--- a/velox/functions/sparksql/registration/RegisterDatetime.cpp
+++ b/velox/functions/sparksql/registration/RegisterDatetime.cpp
@@ -56,7 +56,7 @@ void registerDatetimeFunctions(const std::string& prefix) {
   registerFunction<DateAddFunction, Date, Date, int8_t>({prefix + "date_add"});
   registerFunction<DateAddFunction, Date, Date, int16_t>({prefix + "date_add"});
   registerFunction<DateAddFunction, Date, Date, int32_t>({prefix + "date_add"});
-  registerFunction<FormatDateTimeFunction, Varchar, Timestamp, Varchar>(
+  registerFunction<DateFormatFunction, Varchar, Timestamp, Varchar>(
       {prefix + "date_format"});
   registerFunction<DateFromUnixDateFunction, Date, int32_t>(
       {prefix + "date_from_unix_date"});
@@ -65,12 +65,13 @@ void registerDatetimeFunctions(const std::string& prefix) {
   registerFunction<DateSubFunction, Date, Date, int32_t>({prefix + "date_sub"});
   registerFunction<DayFunction, int32_t, Date>(
       {prefix + "day", prefix + "dayofmonth"});
-  registerFunction<DayOfYearFunction, int32_t, Date>(
-      {prefix + "doy", prefix + "dayofyear"});
+  registerFunction<DayNameFunction, Varchar, Date>({prefix + "dayname"});
+  registerFunction<DayOfYearFunction, int32_t, Date>({prefix + "dayofyear"});
   registerFunction<DayOfWeekFunction, int32_t, Date>({prefix + "dayofweek"});
   registerFunction<WeekdayFunction, int32_t, Date>({prefix + "weekday"});
   registerFunction<QuarterFunction, int32_t, Date>({prefix + "quarter"});
   registerFunction<MonthFunction, int32_t, Date>({prefix + "month"});
+  registerFunction<MonthNameFunction, Varchar, Date>({prefix + "monthname"});
   registerFunction<NextDayFunction, Date, Date, Varchar>({prefix + "next_day"});
   registerFunction<GetTimestampFunction, Timestamp, Varchar, Varchar>(
       {prefix + "get_timestamp"});
@@ -111,6 +112,14 @@ void registerDatetimeFunctions(const std::string& prefix) {
       Varchar,
       int32_t,
       Timestamp>({prefix + "timestampadd"});
+  registerFunction<
+      TimestampAddFunction,
+      Timestamp,
+      Varchar,
+      int64_t,
+      Timestamp>({prefix + "timestampadd"});
+  registerFunction<MonthsBetweenFunction, double, Timestamp, Timestamp, bool>(
+      {prefix + "months_between"});
 }
 
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/registration/RegisterMap.cpp b/velox/functions/sparksql/registration/RegisterMap.cpp
index 0faba9aef7f..19f9f05fc60 100644
--- a/velox/functions/sparksql/registration/RegisterMap.cpp
+++ b/velox/functions/sparksql/registration/RegisterMap.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 #include "velox/functions/lib/MapConcat.h"
+#include "velox/functions/lib/MapFromEntries.h"
 #include "velox/functions/lib/RegistrationHelpers.h"
 #include "velox/functions/sparksql/Size.h"
 
@@ -25,6 +26,8 @@ extern void registerElementAtFunction(
 void registerSparkMapFunctions(const std::string& prefix) {
   VELOX_REGISTER_VECTOR_FUNCTION(
       udf_map_allow_duplicates, prefix + "map_from_arrays");
+  registerMapFromEntriesFunction(
+      prefix + "map_from_entries", /*throwForNull=*/false);
   // Spark and Presto map_filter function has the same definition:
   //   function expression corresponds to body, arguments to signature
   VELOX_REGISTER_VECTOR_FUNCTION(udf_map_filter, prefix + "map_filter");
diff --git a/velox/functions/sparksql/registration/RegisterMath.cpp b/velox/functions/sparksql/registration/RegisterMath.cpp
index bcd98564474..0575a7aaa26 100644
--- a/velox/functions/sparksql/registration/RegisterMath.cpp
+++ b/velox/functions/sparksql/registration/RegisterMath.cpp
@@ -107,6 +107,8 @@ void registerMathFunctions(const std::string& prefix) {
   registerBinaryNumeric<MultiplyFunction>({prefix + "multiply"});
   registerFunction<DivideFunction, double, double, double>({prefix + "divide"});
   registerBinaryNumeric<RemainderFunction>({prefix + "remainder"});
+  registerBinaryIntegralWithTReturn<IntegralDivideFunction, int64_t>(
+      {prefix + "div"});
   registerUnaryNumeric<UnaryMinusFunction>({prefix + "unaryminus"});
   registerFunction<
       UnaryMinusFunction,
@@ -121,6 +123,7 @@ void registerMathFunctions(const std::string& prefix) {
   registerDecimalSubtract(prefix);
   registerDecimalMultiply(prefix);
   registerDecimalDivide(prefix);
+  registerDecimalIntegralDivide(prefix);
   registerFunction<sparksql::IsNanFunction, bool, float>({prefix + "isnan"});
   registerFunction<sparksql::IsNanFunction, bool, double>({prefix + "isnan"});
 
@@ -128,6 +131,8 @@ void registerMathFunctions(const std::string& prefix) {
   registerBinaryNumeric<CheckedSubtractFunction>({prefix + "checked_subtract"});
   registerBinaryNumeric<CheckedMultiplyFunction>({prefix + "checked_multiply"});
   registerBinaryNumeric<CheckedDivideFunction>({prefix + "checked_divide"});
+  registerBinaryIntegralWithTReturn<CheckedIntegralDivideFunction, int64_t>(
+      {prefix + "checked_div"});
   registerFunction<sparksql::FactorialFunction, int64_t, int32_t>(
       {prefix + "factorial"});
 }
diff --git a/velox/functions/sparksql/registration/RegisterMisc.cpp b/velox/functions/sparksql/registration/RegisterMisc.cpp
index 9c08846fc1e..2c570f4abf2 100644
--- a/velox/functions/sparksql/registration/RegisterMisc.cpp
+++ b/velox/functions/sparksql/registration/RegisterMisc.cpp
@@ -15,6 +15,7 @@
  */
 #include "velox/expression/SpecialFormRegistry.h"
 #include "velox/functions/lib/RegistrationHelpers.h"
+#include "velox/functions/sparksql/AssertNotNull.h"
 #include "velox/functions/sparksql/In.h"
 #include "velox/functions/sparksql/MonotonicallyIncreasingId.h"
 #include "velox/functions/sparksql/RaiseError.h"
@@ -24,6 +25,11 @@
 
 namespace facebook::velox::functions::sparksql {
 void registerMiscFunctions(const std::string& prefix) {
+  exec::registerStatefulVectorFunction(
+      prefix + "assert_not_null",
+      assertNotNullSignatures(),
+      makeAssertNotNull,
+      exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build());
   registerFunction<MonotonicallyIncreasingIdFunction, int64_t>(
       {prefix + "monotonically_increasing_id"});
   registerFunction<RaiseErrorFunction, UnknownValue, Varchar>(
diff --git a/velox/functions/sparksql/registration/RegisterSpecialForm.cpp b/velox/functions/sparksql/registration/RegisterSpecialForm.cpp
index 8e722b4bedc..5fd3b4963fc 100644
--- a/velox/functions/sparksql/registration/RegisterSpecialForm.cpp
+++ b/velox/functions/sparksql/registration/RegisterSpecialForm.cpp
@@ -27,8 +27,7 @@
 
 namespace facebook::velox::functions {
 void registerSparkSpecialFormFunctions() {
-  VELOX_REGISTER_VECTOR_FUNCTION(
-      udf_concat_row, exec::RowConstructorCallToSpecialForm::kRowConstructor);
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_concat_row, expression::kRowConstructor);
 }
 
 namespace sparksql {
diff --git a/velox/functions/sparksql/registration/RegisterString.cpp b/velox/functions/sparksql/registration/RegisterString.cpp
index 0fad619931b..6669af0cf06 100644
--- a/velox/functions/sparksql/registration/RegisterString.cpp
+++ b/velox/functions/sparksql/registration/RegisterString.cpp
@@ -15,6 +15,7 @@
  */
 #include "velox/expression/SpecialFormRegistry.h"
 #include "velox/functions/lib/Re2Functions.h"
+#include "velox/functions/lib/RegistrationHelpers.h"
 #include "velox/functions/lib/UpperLower.h"
 #include "velox/functions/prestosql/StringFunctions.h"
 #include "velox/functions/prestosql/URLFunctions.h"
@@ -24,10 +25,12 @@
 #include "velox/functions/sparksql/InitcapFunction.h"
 #include "velox/functions/sparksql/LuhnCheckFunction.h"
 #include "velox/functions/sparksql/MaskFunction.h"
+#include "velox/functions/sparksql/RandStr.h"
 #include "velox/functions/sparksql/ReadSidePaddingFunction.h"
 #include "velox/functions/sparksql/Split.h"
 #include "velox/functions/sparksql/String.h"
 #include "velox/functions/sparksql/StringToMap.h"
+#include "velox/functions/sparksql/ToPrettyString.h"
 #include "velox/functions/sparksql/UnBase64Function.h"
 #include "velox/functions/sparksql/VarcharTypeWriteSideCheck.h"
 
@@ -38,8 +41,51 @@ void registerSparkStringFunctions(const std::string& prefix) {
 }
 
 namespace sparksql {
+
+void registerToPrettyStringFunctions(const std::string& prefix) {
+  const std::vector<std::string> aliases = {prefix + "to_pretty_string"};
+  registerUnaryIntegralWithTReturn<ToPrettyStringFunction, Varchar>(aliases);
+  registerUnaryFloatingPointWithTReturn<ToPrettyStringFunction, Varchar>(
+      aliases);
+  registerFunction<ToPrettyStringFunction, Varchar, bool>(aliases);
+  registerFunction<ToPrettyStringFunction, Varchar, Varchar>(aliases);
+  registerFunction<ToPrettyStringVarbinaryFunction, Varchar, Varbinary>(
+      aliases);
+  registerFunction<ToPrettyStringFunction, Varchar, Date>(aliases);
+  registerFunction<ToPrettyStringTimestampFunction, Varchar, Timestamp>(
+      aliases);
+  registerFunction<ToPrettyStringFunction, Varchar, UnknownValue>(aliases);
+  registerFunction<
+      ToPrettyStringDecimalFunction,
+      Varchar,
+      ShortDecimal<P1, S1>>(aliases);
+  registerFunction<ToPrettyStringDecimalFunction, Varchar, LongDecimal<P1, S1>>(
+      aliases);
+}
+
 void registerStringFunctions(const std::string& prefix) {
   registerSparkStringFunctions(prefix);
+  // randstr(length, seed) - Spark's analyzer always provides a seed.
+  registerFunction<
+      RandStrFunction,
+      Varchar,
+      Constant<int16_t>,
+      Constant<int32_t>>({prefix + "randstr"});
+  registerFunction<
+      RandStrFunction,
+      Varchar,
+      Constant<int16_t>,
+      Constant<int64_t>>({prefix + "randstr"});
+  registerFunction<
+      RandStrFunction,
+      Varchar,
+      Constant<int32_t>,
+      Constant<int32_t>>({prefix + "randstr"});
+  registerFunction<
+      RandStrFunction,
+      Varchar,
+      Constant<int32_t>,
+      Constant<int64_t>>({prefix + "randstr"});
   registerFunction<StartsWithFunction, bool, Varchar, Varchar>(
       {prefix + "startswith"});
   registerFunction<EndsWithFunction, bool, Varchar, Varchar>(
@@ -182,6 +228,8 @@ void registerStringFunctions(const std::string& prefix) {
   registerFunction<UnBase64Function, Varbinary, Varchar>({prefix + "unbase64"});
 
   registerFunction<InitCapFunction, Varchar, Varchar>({prefix + "initcap"});
+
+  registerToPrettyStringFunctions(prefix);
 }
 } // namespace sparksql
 } // namespace facebook::velox::functions
diff --git a/velox/functions/sparksql/specialforms/CMakeLists.txt b/velox/functions/sparksql/specialforms/CMakeLists.txt
index 5c110bc4240..7d9c980a473 100644
--- a/velox/functions/sparksql/specialforms/CMakeLists.txt
+++ b/velox/functions/sparksql/specialforms/CMakeLists.txt
@@ -22,6 +22,15 @@ velox_add_library(
   MakeDecimal.cpp
   SparkCastExpr.cpp
   SparkCastHooks.cpp
+  HEADERS
+  AtLeastNNonNulls.h
+  DecimalRound.h
+  FromJson.h
+  GetArrayStructFields.h
+  GetStructField.h
+  MakeDecimal.h
+  SparkCastExpr.h
+  SparkCastHooks.h
 )
 
 velox_link_libraries(
diff --git a/velox/functions/sparksql/specialforms/MakeDecimal.cpp b/velox/functions/sparksql/specialforms/MakeDecimal.cpp
index 029bb5cb1af..30b58700fe6 100644
--- a/velox/functions/sparksql/specialforms/MakeDecimal.cpp
+++ b/velox/functions/sparksql/specialforms/MakeDecimal.cpp
@@ -114,10 +114,12 @@ class MakeDecimalFunction final : public exec::VectorFunction {
   std::exception_ptr overflowException(
       int64_t unscaled,
       uint8_t resultPrecision) const {
-    return std::make_exception_ptr(std::overflow_error(fmt::format(
-        "Unscaled value {} too large for precision {}.",
-        unscaled,
-        resultPrecision)));
+    return std::make_exception_ptr(
+        std::overflow_error(
+            fmt::format(
+                "Unscaled value {} too large for precision {}.",
+                unscaled,
+                resultPrecision)));
   }
 
   const uint8_t resultPrecision_;
diff --git a/velox/functions/sparksql/specialforms/SparkCastExpr.cpp b/velox/functions/sparksql/specialforms/SparkCastExpr.cpp
index c9c32f76c03..d2b53944ce1 100644
--- a/velox/functions/sparksql/specialforms/SparkCastExpr.cpp
+++ b/velox/functions/sparksql/specialforms/SparkCastExpr.cpp
@@ -17,6 +17,32 @@
 #include "velox/functions/sparksql/specialforms/SparkCastExpr.h"
 
 namespace facebook::velox::functions::sparksql {
+namespace {
+
+bool isIntegralType(const TypePtr& type) {
+  return type == TINYINT() || type == SMALLINT() || type == INTEGER() ||
+      type == BIGINT();
+}
+
+} // namespace
+
+bool SparkCastCallToSpecialForm::isAnsiSupported(
+    const TypePtr& fromType,
+    const TypePtr& toType) {
+  // String to Boolean, Integer, or Date types support ANSI mode.
+  if (fromType->isVarchar()) {
+    if (toType->isBoolean() || toType->isDate()) {
+      return true;
+    }
+    if (isIntegralType(toType)) {
+      // For string-to-integral casts, ANSI mode rejects invalid formats (e.g.
+      // decimal points) instead of returning NULL.
+      return true;
+    }
+  }
+
+  return false;
+}
 
 exec::ExprPtr SparkCastCallToSpecialForm::constructSpecialForm(
     const TypePtr& type,
@@ -28,17 +54,24 @@ exec::ExprPtr SparkCastCallToSpecialForm::constructSpecialForm(
       1,
       "CAST statements expect exactly 1 argument, received {}.",
       compiledChildren.size());
+
+  const auto& fromType = compiledChildren[0]->type();
+
   // In Spark SQL (with ANSI mode off), both CAST and TRY_CAST behave like
-  // Velox's try_cast, so we set 'isTryCast' to true by default in CastExpr.
-  // The distinction between CAST (ANSI off) and TRY_CAST is limited to
-  // overflow handling, which is managed by the 'allowOverflow' flag in
+  // Velox's try_cast, so we set 'isTryCast' to true when ANSI is disabled or
+  // the specific cast operation doesn't support ANSI mode.
+  const bool isTryCast =
+      !config.sparkAnsiEnabled() || !isAnsiSupported(fromType, type);
+
+  // For ANSI-supported casts, CAST mirrors TRY_CAST when ANSI is disabled.
+  // The distinction is controlled by the 'allowOverflow' flag in
   // SparkCastHooks.
   return std::make_shared<SparkCastExpr>(
       type,
       std::move(compiledChildren[0]),
       trackCpuUsage,
-      true,
-      std::make_shared<SparkCastHooks>(config, true));
+      isTryCast,
+      std::make_shared<SparkCastHooks>(config, isTryCast));
 }
 
 exec::ExprPtr SparkTryCastCallToSpecialForm::constructSpecialForm(
@@ -49,8 +82,10 @@ exec::ExprPtr SparkTryCastCallToSpecialForm::constructSpecialForm(
   VELOX_CHECK_EQ(
       compiledChildren.size(),
       1,
-      "TRY CAST statements expect exactly 1 argument, received {}.",
+      "TRY_CAST statements expect exactly 1 argument, received {}.",
       compiledChildren.size());
+
+  // TRY_CAST always uses allowOverflow=false to return NULL on cast failures.
   return std::make_shared<SparkCastExpr>(
       type,
       std::move(compiledChildren[0]),
@@ -58,4 +93,5 @@ exec::ExprPtr SparkTryCastCallToSpecialForm::constructSpecialForm(
       true,
       std::make_shared<SparkCastHooks>(config, false));
 }
+
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/specialforms/SparkCastExpr.h b/velox/functions/sparksql/specialforms/SparkCastExpr.h
index 6b9e7e5d1c1..aa3fee83f07 100644
--- a/velox/functions/sparksql/specialforms/SparkCastExpr.h
+++ b/velox/functions/sparksql/specialforms/SparkCastExpr.h
@@ -23,17 +23,18 @@ namespace facebook::velox::functions::sparksql {
 
 class SparkCastExpr : public exec::CastExpr {
  public:
-  /// @param type The target type of the cast expression
-  /// @param expr The expression to cast
-  /// @param trackCpuUsage Whether to track CPU usage
   SparkCastExpr(
       TypePtr type,
-      exec::ExprPtr&& expr,
+      exec::ExprPtr&& input,
       bool trackCpuUsage,
       bool isTryCast,
-      std::shared_ptr<SparkCastHooks> hooks)
-      : exec::CastExpr(type, std::move(expr), trackCpuUsage, isTryCast, hooks) {
-  }
+      std::shared_ptr<exec::CastHooks> hooks)
+      : exec::CastExpr(
+            std::move(type),
+            std::move(input),
+            trackCpuUsage,
+            isTryCast,
+            std::move(hooks)) {}
 };
 
 class SparkCastCallToSpecialForm : public exec::CastCallToSpecialForm {
@@ -43,6 +44,14 @@ class SparkCastCallToSpecialForm : public exec::CastCallToSpecialForm {
       std::vector<exec::ExprPtr>&& compiledChildren,
       bool trackCpuUsage,
       const core::QueryConfig& config) override;
+
+ private:
+  /// Determines if ANSI mode is supported for casting from fromType to toType.
+  /// TODO: Remove this function once all cast operations support ANSI mode.
+  /// @param fromType The source type of the cast
+  /// @param toType The target type of the cast
+  /// @return true if ANSI mode is supported for this cast, false otherwise
+  static bool isAnsiSupported(const TypePtr& fromType, const TypePtr& toType);
 };
 
 class SparkTryCastCallToSpecialForm : public exec::TryCastCallToSpecialForm {
diff --git a/velox/functions/sparksql/specialforms/SparkCastHooks.h b/velox/functions/sparksql/specialforms/SparkCastHooks.h
index 22f6a299995..2bae4d264e9 100644
--- a/velox/functions/sparksql/specialforms/SparkCastHooks.h
+++ b/velox/functions/sparksql/specialforms/SparkCastHooks.h
@@ -78,6 +78,10 @@ class SparkCastHooks : public exec::CastHooks {
 
   exec::PolicyType getPolicy() const override;
 
+  bool isScientific() const override {
+    return true;
+  }
+
  private:
   // Casts a number to a timestamp. The number is treated as the number of
   // seconds since the epoch (1970-01-01 00:00:00 UTC).
diff --git a/velox/functions/sparksql/tests/ArithmeticTest.cpp b/velox/functions/sparksql/tests/ArithmeticTest.cpp
index 8c6fb665550..7efb55ef083 100644
--- a/velox/functions/sparksql/tests/ArithmeticTest.cpp
+++ b/velox/functions/sparksql/tests/ArithmeticTest.cpp
@@ -16,6 +16,7 @@
 #include <cstdint>
 #include <limits>
 
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
 
 namespace facebook::velox::functions::sparksql::test {
@@ -189,6 +190,13 @@ class ArithmeticTest : public SparkFunctionBaseTest {
     return evaluateOnce<double>("divide(c0, c1)", numerator, denominator);
   }
 
+  template <typename T>
+  std::optional<int64_t> div(
+      std::optional<T> numerator,
+      std::optional<T> denominator) {
+    return evaluateOnce<int64_t>("div(c0, c1)", numerator, denominator);
+  }
+
   template <typename T>
   std::optional<T> checkedAdd(
       const std::optional<T> a,
@@ -217,6 +225,13 @@ class ArithmeticTest : public SparkFunctionBaseTest {
     return evaluateOnce<T>("checked_subtract(c0, c1)", a, b);
   }
 
+  template <typename T>
+  std::optional<int64_t> checkedDiv(
+      std::optional<T> numerator,
+      std::optional<T> denominator) {
+    return evaluateOnce<int64_t>("checked_div(c0, c1)", numerator, denominator);
+  }
+
   template <typename T>
   std::optional<T> abs(const std::optional<T> input) {
     return evaluateOnce<T>("abs(c0)", input);
@@ -264,13 +279,21 @@ class ArithmeticTest : public SparkFunctionBaseTest {
   }
 
   template <typename T>
-  void assertErrorForcheckedSubtract(
+  void assertErrorForCheckedSubtract(
       const std::optional<T> a,
       const std::optional<T> b,
       const std::string& errorMessage) {
     assertErrorForCheckedArithmetic("checked_subtract", a, b, errorMessage);
   }
 
+  template <typename T>
+  void assertErrorForCheckedDiv(
+      const std::optional<T> a,
+      const std::optional<T> b,
+      const std::string& errorMessage) {
+    assertErrorForCheckedArithmetic("checked_div", a, b, errorMessage);
+  }
+
   static constexpr float kNan = std::numeric_limits<float>::quiet_NaN();
   static constexpr double kNanDouble = std::numeric_limits<double>::quiet_NaN();
   static constexpr float kInf = std::numeric_limits<float>::infinity();
@@ -324,6 +347,23 @@ TEST_F(ArithmeticTest, Divide) {
   EXPECT_TRUE(std::isnan(divide(kInf, -kInf).value_or(0)));
 }
 
+TEST_F(ArithmeticTest, div) {
+  // Division by zero is always null.
+  EXPECT_EQ(div<int64_t>(1, 0), std::nullopt);
+  EXPECT_EQ(div<int64_t>(0, 0), std::nullopt);
+  EXPECT_EQ(div<int64_t>(INT64_MIN, 0), std::nullopt);
+
+  EXPECT_EQ(div<int64_t>(INT64_MIN, -1), INT64_MIN);
+
+  EXPECT_EQ(div<int8_t>(INT8_MAX, INT8_MIN), 0);
+  EXPECT_EQ(div<int16_t>(INT16_MIN, INT16_MAX), -1);
+  EXPECT_EQ(div<int32_t>(INT32_MAX, INT32_MIN), 0);
+  EXPECT_EQ(div<int64_t>(INT64_MIN, INT64_MAX), -1);
+
+  EXPECT_EQ(div<int64_t>(2, 3), 0);
+  EXPECT_EQ(div<int64_t>(3, 2), 1);
+}
+
 TEST_F(ArithmeticTest, acosh) {
   const auto acosh = [&](std::optional<double> a) {
     return evaluateOnce<double>("acosh(c0)", a);
@@ -695,13 +735,13 @@ TEST_F(ArithmeticTest, checkedAdd) {
 }
 
 TEST_F(ArithmeticTest, checkedSubtract) {
-  assertErrorForcheckedSubtract<int8_t>(
+  assertErrorForCheckedSubtract<int8_t>(
       INT8_MIN, 1, "Arithmetic overflow: -128 - 1");
-  assertErrorForcheckedSubtract<int16_t>(
+  assertErrorForCheckedSubtract<int16_t>(
       INT16_MIN, 1, "Arithmetic overflow: -32768 - 1");
-  assertErrorForcheckedSubtract<int32_t>(
+  assertErrorForCheckedSubtract<int32_t>(
       INT32_MIN, 1, "Arithmetic overflow: -2147483648 - 1");
-  assertErrorForcheckedSubtract<int64_t>(
+  assertErrorForCheckedSubtract<int64_t>(
       INT64_MIN, 1, "Arithmetic overflow: -9223372036854775808 - 1");
   EXPECT_EQ(checkedSubtract<float>(kInf, 1), kInf);
   EXPECT_EQ(checkedSubtract<double>(kInfDouble, 1), kInfDouble);
@@ -734,31 +774,72 @@ TEST_F(ArithmeticTest, checkedDivide) {
   EXPECT_EQ(checkedDivide<double>(kInfDouble, 1), kInfDouble);
 }
 
+TEST_F(ArithmeticTest, checkedDiv) {
+  EXPECT_EQ(checkedDiv<int8_t>(INT8_MAX, INT8_MIN), 0);
+  EXPECT_EQ(checkedDiv<int16_t>(INT16_MIN, INT16_MAX), -1);
+  EXPECT_EQ(checkedDiv<int32_t>(INT32_MAX, INT32_MIN), 0);
+  EXPECT_EQ(checkedDiv<int64_t>(INT64_MIN, INT64_MAX), -1);
+
+  EXPECT_EQ(checkedDiv<int64_t>(2, 3), 0);
+  EXPECT_EQ(checkedDiv<int64_t>(3, 2), 1);
+  // Division by zero is always null.
+  assertErrorForCheckedDiv<int64_t>(1, 0, "Division by zero");
+  // Division overflow.
+  assertErrorForCheckedDiv<int64_t>(
+      INT64_MIN, -1, "Overflow in integral divide");
+}
+
 TEST_F(ArithmeticTest, abs) {
-  EXPECT_EQ(abs<int8_t>(-127), 127);
+  for (const auto& ansiEnabled : {"false", "true"}) {
+    queryCtx_->testingOverrideConfigUnsafe(
+        {{core::QueryConfig::kSparkAnsiEnabled, ansiEnabled}});
+
+    EXPECT_EQ(abs<int8_t>(-127), 127);
+    EXPECT_EQ(abs<int16_t>(-32767), 32767);
+    EXPECT_EQ(abs<int32_t>(-2147483647), 2147483647);
+    EXPECT_EQ(abs<int64_t>(-9223372036854775807), 9223372036854775807);
+
+    EXPECT_EQ(abs<float>(-99999.9999f), 99999.9999f);
+    EXPECT_EQ(
+        abs<float>(std::numeric_limits<float>::lowest()),
+        std::numeric_limits<float>::max());
+    EXPECT_EQ(abs<double>(-99999.9999), 99999.9999);
+    EXPECT_EQ(
+        abs<double>(std::numeric_limits<double>::lowest()),
+        std::numeric_limits<double>::max());
+  }
+}
+
+TEST_F(ArithmeticTest, absMinValueOverflow) {
+  // Test abs with ANSI off.
+  queryCtx_->testingOverrideConfigUnsafe(
+      {{core::QueryConfig::kSparkAnsiEnabled, "false"}});
+
   EXPECT_EQ(
       abs<int8_t>(std::numeric_limits<int8_t>::min()),
       std::numeric_limits<int8_t>::min());
-  EXPECT_EQ(abs<int16_t>(-32767), 32767);
   EXPECT_EQ(
       abs<int16_t>(std::numeric_limits<int16_t>::min()),
       std::numeric_limits<int16_t>::min());
-  EXPECT_EQ(abs<int32_t>(-2147483647), 2147483647);
   EXPECT_EQ(
       abs<int32_t>(std::numeric_limits<int32_t>::min()),
       std::numeric_limits<int32_t>::min());
-  EXPECT_EQ(abs<int64_t>(-9223372036854775807), 9223372036854775807);
   EXPECT_EQ(
       abs<int64_t>(std::numeric_limits<int64_t>::min()),
       std::numeric_limits<int64_t>::min());
-  EXPECT_EQ(abs<float>(-99999.9999f), 99999.9999f);
-  EXPECT_EQ(
-      abs<float>(std::numeric_limits<float>::lowest()),
-      std::numeric_limits<float>::max());
-  EXPECT_EQ(abs<double>(-99999.9999), 99999.9999);
-  EXPECT_EQ(
-      abs<double>(std::numeric_limits<double>::lowest()),
-      std::numeric_limits<double>::max());
+
+  // Test abs with ANSI on.
+  queryCtx_->testingOverrideConfigUnsafe(
+      {{core::QueryConfig::kSparkAnsiEnabled, "true"}});
+
+  VELOX_ASSERT_THROW(
+      abs<int8_t>(std::numeric_limits<int8_t>::min()), "Arithmetic overflow");
+  VELOX_ASSERT_THROW(
+      abs<int16_t>(std::numeric_limits<int16_t>::min()), "Arithmetic overflow");
+  VELOX_ASSERT_THROW(
+      abs<int32_t>(std::numeric_limits<int32_t>::min()), "Arithmetic overflow");
+  VELOX_ASSERT_THROW(
+      abs<int64_t>(std::numeric_limits<int64_t>::min()), "Arithmetic overflow");
 }
 
 class LogNTest : public SparkFunctionBaseTest {
diff --git a/velox/functions/sparksql/tests/ArrayMaxTest.cpp b/velox/functions/sparksql/tests/ArrayMaxTest.cpp
index 530417852da..cb0244c50bc 100644
--- a/velox/functions/sparksql/tests/ArrayMaxTest.cpp
+++ b/velox/functions/sparksql/tests/ArrayMaxTest.cpp
@@ -195,9 +195,10 @@ TYPED_TEST(ArrayMaxFloatingPointTest, basic) {
   EXPECT_FLOAT_EQ(
       this->template arrayMax<T>({-0.00001, -0.0002, 0.0001}).value(), 0.0001);
 
-  EXPECT_TRUE(std::isnan(
-      this->template arrayMax<T>({kMin, -0.0001, -0.0002, -0.0003, kMax, kNaN})
-          .value()));
+  EXPECT_TRUE(
+      std::isnan(this->template arrayMax<T>(
+                         {kMin, -0.0001, -0.0002, -0.0003, kMax, kNaN})
+                     .value()));
 }
 
 } // namespace
diff --git a/velox/functions/sparksql/tests/ArraySortTest.cpp b/velox/functions/sparksql/tests/ArraySortTest.cpp
index 1247e020239..a648ab291b5 100644
--- a/velox/functions/sparksql/tests/ArraySortTest.cpp
+++ b/velox/functions/sparksql/tests/ArraySortTest.cpp
@@ -16,6 +16,7 @@
 
 #include <optional>
 
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/functions/sparksql/tests/ArraySortTestData.h"
 #include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
@@ -30,11 +31,33 @@ using facebook::velox::functions::test::FunctionBaseTest;
 
 class ArraySortTest : public SparkFunctionBaseTest {
  protected:
+  ArraySortTest() {
+    options_.parseIntegerAsBigint = false;
+  }
+
   void testArraySort(const VectorPtr& input, const VectorPtr& expected) {
     auto result = evaluate("array_sort(c0)", makeRowVector({input}));
     assertEqualVectors(expected, result);
   }
 
+  void testArraySort(
+      const std::string& lamdaExpr,
+      bool asc,
+      const VectorPtr& input,
+      const VectorPtr& expected) {
+    std::string name = asc ? "array_sort" : "array_sort_desc";
+    auto result = evaluate(
+        fmt::format("{}(c0, {})", name, lamdaExpr), makeRowVector({input}));
+    assertEqualVectors(expected, result);
+
+    SelectivityVector firstRow(1);
+    result = evaluate(
+        fmt::format("{}(c0, {})", name, lamdaExpr),
+        makeRowVector({input}),
+        firstRow);
+    assertEqualVectors(expected->slice(0, 1), result);
+  }
+
   template <typename T>
   void testInt() {
     auto input = makeNullableArrayVector(intInput<T>());
@@ -104,10 +127,14 @@ TEST_F(ArraySortTest, array) {
   testArraySort(input, expected);
 }
 
-TEST_F(ArraySortTest, map) {
+// Map is not orderable, so sorting is not supported.
+TEST_F(ArraySortTest, failOnMapTypeSort) {
   auto input = makeArrayOfMapVector(mapInput());
-  auto expected = makeArrayOfMapVector(mapAscNullLargest());
-  testArraySort(input, expected);
+  const std::string kErrorMessage =
+      "Scalar function signature is not supported";
+
+  VELOX_ASSERT_THROW(
+      evaluate("array_sort(c0)", makeRowVector({input})), kErrorMessage);
 }
 
 TEST_F(ArraySortTest, row) {
@@ -140,5 +167,60 @@ TEST_F(ArraySortTest, constant) {
   expected = makeConstantArray<int64_t>(size, {6, 6, 6, 6});
   assertEqualVectors(expected, result);
 }
+
+TEST_F(ArraySortTest, lambda) {
+  auto data = makeNullableArrayVector<std::string>({
+      {"abc123", "abc", std::nullopt, "abcd"},
+      {std::nullopt, "x", "xyz123", "xyz"},
+  });
+
+  auto sortedAsc = makeNullableArrayVector<std::string>({
+      {"abc", "abcd", "abc123", std::nullopt},
+      {"x", "xyz", "xyz123", std::nullopt},
+  });
+
+  auto sortedDesc = makeNullableArrayVector<std::string>({
+      {"abc123", "abcd", "abc", std::nullopt},
+      {"xyz123", "xyz", "x", std::nullopt},
+  });
+
+  // Different ways to sort by length ascending.
+  testArraySort("x -> length(x)", true, data, sortedAsc);
+  testArraySort("x -> length(x) * -1", false, data, sortedAsc);
+  testArraySort(
+      "(x, y) -> if(lessthan(length(x), length(y)), -1, if(greaterthan(length(x), length(y)), 1, 0))",
+      true,
+      data,
+      sortedAsc);
+  testArraySort(
+      "(x, y) -> if(lessthan(length(x), length(y)), -1, if(equalto(length(x), length(y)), 0, 1))",
+      true,
+      data,
+      sortedAsc);
+
+  // Different ways to sort by length descending.
+  testArraySort("x -> length(x)", false, data, sortedDesc);
+  testArraySort("x -> length(x) * -1", true, data, sortedDesc);
+  testArraySort(
+      "(x, y) -> if(lessthan(length(x), length(y)), 1, if(greaterthan(length(x), length(y)), -1, 0))",
+      true,
+      data,
+      sortedDesc);
+  testArraySort(
+      "(x, y) -> if(lessthan(length(x), length(y)), 1, if(equalto(length(x), length(y)), 0, -1))",
+      true,
+      data,
+      sortedDesc);
+}
+
+TEST_F(ArraySortTest, unsupporteLambda) {
+  auto data = makeRowVector({
+      makeNullableArrayVector(intInput<int32_t>()),
+  });
+
+  VELOX_ASSERT_THROW(
+      evaluate("array_sort(c0, (a, b) -> 0)", data),
+      "array_sort with comparator lambda that cannot be rewritten into a transform is not supported");
+}
 } // namespace
 } // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/ArraySortTestData.h b/velox/functions/sparksql/tests/ArraySortTestData.h
index 38de4684e34..4a96e9b8ecd 100644
--- a/velox/functions/sparksql/tests/ArraySortTestData.h
+++ b/velox/functions/sparksql/tests/ArraySortTestData.h
@@ -248,7 +248,11 @@ arrayInput() {
       // Top level null elements.
       {{A({1, 3}), std::nullopt, A({2, 1})}},
       // Array with null values.
-      {{A({std::nullopt, 6}), A({3, std::nullopt}), A({std::nullopt, 8})}},
+      {{A({std::nullopt, 6}),
+        A({3, std::nullopt}),
+        A({std::nullopt, 8}),
+        std::nullopt,
+        A({})}},
   };
 }
 
@@ -261,7 +265,11 @@ arrayAscNullSmallest() {
       {{std::nullopt, std::nullopt}},
       {{A({1, 3}), A({1, 3, 5}), A({2, 1})}},
       {{std::nullopt, A({1, 3}), A({2, 1})}},
-      {{A({std::nullopt, 6}), A({std::nullopt, 8}), A({3, std::nullopt})}},
+      {{std::nullopt,
+        A({}),
+        A({std::nullopt, 6}),
+        A({std::nullopt, 8}),
+        A({3, std::nullopt})}},
   };
 }
 
@@ -274,7 +282,11 @@ arrayAscNullLargest() {
       {{std::nullopt, std::nullopt}},
       {{A({1, 3}), A({1, 3, 5}), A({2, 1})}},
       {{A({1, 3}), A({2, 1}), std::nullopt}},
-      {{A({3, std::nullopt}), A({std::nullopt, 6}), A({std::nullopt, 8})}},
+      {{A({}),
+        A({3, std::nullopt}),
+        A({std::nullopt, 6}),
+        A({std::nullopt, 8}),
+        std::nullopt}},
   };
 }
 
diff --git a/velox/functions/sparksql/tests/AssertNotNullTest.cpp b/velox/functions/sparksql/tests/AssertNotNullTest.cpp
new file mode 100644
index 00000000000..85cb8d05026
--- /dev/null
+++ b/velox/functions/sparksql/tests/AssertNotNullTest.cpp
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class AssertNotNullTest : public SparkFunctionBaseTest {
+ protected:
+  template <typename T>
+  void testAssertNotNull(
+      const std::vector<std::optional<T>>& input,
+      const std::vector<T>& expected) {
+    auto inputVector = makeNullableFlatVector<T>(input);
+    auto result = evaluate("assert_not_null(c0)", makeRowVector({inputVector}));
+    auto expectedVector = makeFlatVector<T>(expected);
+    velox::test::assertEqualVectors(expectedVector, result);
+  }
+};
+
+TEST_F(AssertNotNullTest, integer) {
+  testAssertNotNull<int32_t>({1, 2, 3}, {1, 2, 3});
+}
+
+TEST_F(AssertNotNullTest, bigint) {
+  testAssertNotNull<int64_t>({10, 20, 30}, {10, 20, 30});
+}
+
+TEST_F(AssertNotNullTest, varchar) {
+  testAssertNotNull<StringView>(
+      {StringView("hello"), StringView("world")},
+      {StringView("hello"), StringView("world")});
+}
+
+TEST_F(AssertNotNullTest, boolean) {
+  testAssertNotNull<bool>({true, false, true}, {true, false, true});
+}
+
+TEST_F(AssertNotNullTest, nullInput) {
+  auto input = makeNullableFlatVector<int32_t>({1, std::nullopt, 3});
+  VELOX_ASSERT_THROW(
+      evaluate("assert_not_null(c0)", makeRowVector({input})),
+      "Null value appeared in non-nullable field");
+}
+
+TEST_F(AssertNotNullTest, allNulls) {
+  auto input = makeNullableFlatVector<int64_t>(
+      {std::nullopt, std::nullopt, std::nullopt});
+  VELOX_ASSERT_THROW(
+      evaluate("assert_not_null(c0)", makeRowVector({input})),
+      "Null value appeared in non-nullable field");
+}
+
+TEST_F(AssertNotNullTest, complexType) {
+  auto arrayVector = makeNullableArrayVector<int32_t>(
+      std::vector<std::vector<std::optional<int32_t>>>{
+          {{1, 2, 3}}, {{4, 5}}, {{6}}});
+  auto row = makeRowVector(std::vector<VectorPtr>{arrayVector});
+  auto result = evaluate("assert_not_null(c0)", row);
+  velox::test::assertEqualVectors(arrayVector, result);
+}
+
+TEST_F(AssertNotNullTest, complexTypeWithNull) {
+  auto arrayVector = makeNullableArrayVector<int32_t>(
+      std::vector<std::optional<std::vector<std::optional<int32_t>>>>{
+          {{{1, 2, 3}}}, std::nullopt, {{{6}}}});
+  auto row = makeRowVector(std::vector<VectorPtr>{arrayVector});
+  VELOX_ASSERT_THROW(
+      evaluate("assert_not_null(c0)", row),
+      "Null value appeared in non-nullable field");
+}
+
+TEST_F(AssertNotNullTest, customErrorMessage) {
+  auto input = makeNullableFlatVector<int32_t>({1, std::nullopt, 3});
+  VELOX_ASSERT_THROW(
+      evaluate(
+          "assert_not_null(c0, 'custom error message')",
+          makeRowVector({input})),
+      "custom error message");
+}
+
+TEST_F(AssertNotNullTest, nullErrorMessage) {
+  // When errMsg constant is NULL, use default error message.
+  auto input = makeNullableFlatVector<int32_t>({1, std::nullopt, 3});
+  VELOX_ASSERT_THROW(
+      evaluate(
+          "assert_not_null(c0, cast(null as varchar))", makeRowVector({input})),
+      "Null value appeared in non-nullable field");
+}
+
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/CMakeLists.txt b/velox/functions/sparksql/tests/CMakeLists.txt
index ad1b5833d4e..707b7ed2b08 100644
--- a/velox/functions/sparksql/tests/CMakeLists.txt
+++ b/velox/functions/sparksql/tests/CMakeLists.txt
@@ -27,6 +27,7 @@ add_executable(
   ArrayShuffleTest.cpp
   ArrayUnionTest.cpp
   ArgTypesGeneratorTest.cpp
+  AssertNotNullTest.cpp
   AtLeastNNonNullsTest.cpp
   Base64Test.cpp
   BitwiseTest.cpp
@@ -40,6 +41,7 @@ add_executable(
   DecimalUtilTest.cpp
   ElementAtTest.cpp
   FactorialTest.cpp
+  FilterTest.cpp
   FromJsonTest.cpp
   FromToJsonRoundTripTest.cpp
   GetArrayStructFieldsTest.cpp
@@ -55,23 +57,29 @@ add_executable(
   MakeDecimalTest.cpp
   MakeTimestampTest.cpp
   MapConcatTest.cpp
+  MapFromEntriesTest.cpp
   MapTest.cpp
   MaskTest.cpp
   MightContainTest.cpp
   MonotonicallyIncreasingIdTest.cpp
   RaiseErrorTest.cpp
+  RandStrTest.cpp
   RandTest.cpp
   ReadSidePaddingFunctionTest.cpp
   RegexFunctionsTest.cpp
+  SequenceTest.cpp
   SliceTest.cpp
   SizeTest.cpp
   SortArrayTest.cpp
   SparkCastExprTest.cpp
+  XORShiftRandomTest.cpp
   SparkPartitionIdTest.cpp
   SplitTest.cpp
   StringTest.cpp
   StringToMapTest.cpp
   ToJsonTest.cpp
+  ToPrettyStringTest.cpp
+  TransformTest.cpp
   UnBase64Test.cpp
   UnscaledValueFunctionTest.cpp
   UpperLowerTest.cpp
@@ -79,6 +87,7 @@ add_executable(
   VarcharTypeWriteSideCheckTest.cpp
   XxHash64Test.cpp
 )
+velox_add_test_headers(velox_functions_spark_test JsonTestUtil.h)
 
 add_test(velox_functions_spark_test velox_functions_spark_test)
 
@@ -106,3 +115,7 @@ target_link_libraries(
   GTest::gtest
   GTest::gtest_main
 )
+
+velox_add_library(velox_array_sort_test_lib INTERFACE HEADERS ArraySortTestData.h)
+
+velox_add_library(velox_spark_function_base INTERFACE HEADERS SparkFunctionBaseTest.h)
diff --git a/velox/functions/sparksql/tests/ComparisonsTest.cpp b/velox/functions/sparksql/tests/ComparisonsTest.cpp
index e3990581e85..dac573712af 100644
--- a/velox/functions/sparksql/tests/ComparisonsTest.cpp
+++ b/velox/functions/sparksql/tests/ComparisonsTest.cpp
@@ -25,6 +25,7 @@ namespace {
 static constexpr double kInf = std::numeric_limits<double>::infinity();
 static constexpr float kInfF = std::numeric_limits<float>::infinity();
 static constexpr auto kNaN = std::numeric_limits<double>::quiet_NaN();
+static constexpr auto kNaNF = std::numeric_limits<float>::quiet_NaN();
 
 class ComparisonsTest : public SparkFunctionBaseTest {
  protected:
@@ -355,8 +356,6 @@ TEST_F(ComparisonsTest, between) {
   EXPECT_EQ(between<double>(1, std::nullopt, 3), std::nullopt);
   EXPECT_EQ(between<double>(kNaN, std::nullopt, 4), std::nullopt);
   EXPECT_EQ(between<double>(kNaN, 1, 5), false);
-  EXPECT_EQ(between<double>(0, -1, kNaN), false);
-  EXPECT_EQ(between<double>(kNaN, 0, kNaN), false);
   EXPECT_EQ(between<double>(kInf, 0, kInf), true);
   EXPECT_EQ(between<float>(kInfF, 0, kInfF), true);
   EXPECT_EQ(between<double>(kInf, 2.0, 5.0), false);
@@ -364,7 +363,15 @@ TEST_F(ComparisonsTest, between) {
   EXPECT_EQ(between<float>(kInfF, 1.0, 6.0), false);
   EXPECT_EQ(between<float>(-kInfF, 1.0, 6.0), false);
   EXPECT_EQ(between<float>(kInfF, -kInfF, kInfF), true);
-  EXPECT_EQ(between<double>(kInf, -kInf, kNaN), false);
+
+  // Spark NaN semantics: NaN == NaN and NaN > everything.
+  EXPECT_EQ(between<double>(0, -1, kNaN), true);
+  EXPECT_EQ(between<double>(kNaN, 0, kNaN), true);
+  EXPECT_EQ(between<double>(kInf, -kInf, kNaN), true);
+  EXPECT_EQ(between<double>(kNaN, kNaN, kNaN), true);
+  EXPECT_EQ(between<float>(kNaNF, kNaNF, kNaNF), true);
+  EXPECT_EQ(between<float>(0.0f, -1.0f, kNaNF), true);
+  EXPECT_EQ(between<float>(kNaNF, 0.0f, kNaNF), true);
 }
 
 TEST_F(ComparisonsTest, decimal) {
diff --git a/velox/functions/sparksql/tests/DateTimeFunctionsTest.cpp b/velox/functions/sparksql/tests/DateTimeFunctionsTest.cpp
index f26cbc020af..117a464f50d 100644
--- a/velox/functions/sparksql/tests/DateTimeFunctionsTest.cpp
+++ b/velox/functions/sparksql/tests/DateTimeFunctionsTest.cpp
@@ -42,10 +42,6 @@ class DateTimeFunctionsTest : public SparkFunctionBaseTest {
   static constexpr int8_t kMaxTinyint = std::numeric_limits<int8_t>::max();
   static constexpr int64_t kMinBigint = std::numeric_limits<int64_t>::min();
   static constexpr int64_t kMaxBigint = std::numeric_limits<int64_t>::max();
-  static constexpr float kLowestFloat = std::numeric_limits<float>::lowest();
-  static constexpr float kMaxFloat = std::numeric_limits<float>::max();
-  static constexpr double kLowestDouble = std::numeric_limits<double>::lowest();
-  static constexpr double kMaxDouble = std::numeric_limits<double>::max();
 
  protected:
   void setQueryTimeZone(const std::string& timeZone) {
@@ -662,6 +658,44 @@ TEST_F(DateTimeFunctionsTest, weekdayDate) {
   EXPECT_EQ(4, weekday(parseDate("1582-10-15")));
 }
 
+TEST_F(DateTimeFunctionsTest, dayNameDate) {
+  const auto dayName = [&](std::optional<int32_t> date) {
+    return evaluateOnce<std::string>("dayname(c0)", DATE(), date);
+  };
+
+  EXPECT_EQ(std::nullopt, dayName(std::nullopt));
+  EXPECT_EQ("Thu", dayName(0)); // 1970-01-01
+  EXPECT_EQ("Wed", dayName(-1)); // 1969-12-31
+  EXPECT_EQ("Tue", dayName(-2)); // 1969-12-30
+  EXPECT_EQ("Sun", dayName(parseDate("2023-08-20")));
+  EXPECT_EQ("Mon", dayName(parseDate("2023-08-21")));
+  EXPECT_EQ("Tue", dayName(parseDate("2023-08-22")));
+  EXPECT_EQ("Wed", dayName(parseDate("2023-08-23")));
+  EXPECT_EQ("Thu", dayName(parseDate("2023-08-24")));
+  EXPECT_EQ("Fri", dayName(parseDate("2023-08-25")));
+  EXPECT_EQ("Sat", dayName(parseDate("2023-08-26")));
+  EXPECT_EQ(
+      "Fri", dayName(parseDate("1582-10-15"))); // Gregorian calendar start.
+}
+
+TEST_F(DateTimeFunctionsTest, monthNameDate) {
+  const auto monthName = [&](std::optional<int32_t> date) {
+    return evaluateOnce<std::string>("monthname(c0)", DATE(), date);
+  };
+
+  // Test epoch date (1970-01-01).
+  EXPECT_EQ("Jan", monthName(0));
+
+  // Test various months across different years.
+  EXPECT_EQ("Jan", monthName(parseDate("2017-01-27")));
+  EXPECT_EQ("Feb", monthName(parseDate("2008-02-20")));
+  EXPECT_EQ("May", monthName(parseDate("2011-05-06")));
+  EXPECT_EQ("Aug", monthName(parseDate("2023-08-20")));
+  EXPECT_EQ("Aug", monthName(parseDate("2023-08-21")));
+  EXPECT_EQ(
+      "Oct", monthName(parseDate("1582-10-15"))); // Gregorian calendar start.
+}
+
 TEST_F(DateTimeFunctionsTest, dateDiffDate) {
   const auto dateDiff = [&](std::optional<int32_t> endDate,
                             std::optional<int32_t> startDate) {
@@ -1208,11 +1242,17 @@ TEST_F(DateTimeFunctionsTest, secondsToTimestamp) {
       secondsToTimestamp<float>(1.1234567),
       parseTimestamp("1970-01-01 00:00:01.123456"));
   EXPECT_EQ(
-      secondsToTimestamp<float>(kMaxFloat),
+      secondsToTimestamp<float>(std::numeric_limits<float>::max()),
       parseTimestamp("+294247-01-10 04:00:54.775807"));
   EXPECT_EQ(
-      secondsToTimestamp<float>(kLowestFloat),
+      secondsToTimestamp<float>(std::numeric_limits<float>::lowest()),
       parseTimestamp("-290308-12-21 19:59:05.224192"));
+  EXPECT_EQ(
+      secondsToTimestamp<float>(std::numeric_limits<float>::quiet_NaN()),
+      std::nullopt);
+  EXPECT_EQ(
+      secondsToTimestamp<float>(std::numeric_limits<float>::infinity()),
+      std::nullopt);
 
   // Tests using double seconds as input.
   EXPECT_EQ(
@@ -1249,11 +1289,17 @@ TEST_F(DateTimeFunctionsTest, secondsToTimestamp) {
       secondsToTimestamp<double>(1.1234567),
       parseTimestamp("1970-01-01 00:00:01.123456"));
   EXPECT_EQ(
-      secondsToTimestamp<double>(kLowestDouble),
+      secondsToTimestamp<double>(std::numeric_limits<double>::lowest()),
       parseTimestamp("-290308-12-21 19:59:05.224192"));
   EXPECT_EQ(
-      secondsToTimestamp<double>(kMaxDouble),
+      secondsToTimestamp<double>(std::numeric_limits<double>::max()),
       parseTimestamp("+294247-01-10 04:00:54.775807"));
+  EXPECT_EQ(
+      secondsToTimestamp<double>(std::numeric_limits<double>::quiet_NaN()),
+      std::nullopt);
+  EXPECT_EQ(
+      secondsToTimestamp<double>(std::numeric_limits<double>::infinity()),
+      std::nullopt);
 }
 
 TEST_F(DateTimeFunctionsTest, timestampToMicros) {
@@ -1697,14 +1743,26 @@ TEST_F(DateTimeFunctionsTest, timestampadd) {
         fmt::format("timestampadd('{}', c0, c1)", unit), value, timestamp);
   };
 
+  const auto timestampaddBigint = [&](const std::string& unit,
+                                      std::optional<int64_t> value,
+                                      std::optional<Timestamp> timestamp) {
+    return evaluateOnce<Timestamp>(
+        fmt::format("timestampadd('{}', c0, c1)", unit), value, timestamp);
+  };
+
   // Check null behaviors.
   EXPECT_EQ(std::nullopt, timestampadd("second", 1, std::nullopt));
   EXPECT_EQ(std::nullopt, timestampadd("month", std::nullopt, Timestamp(0, 0)));
+  EXPECT_EQ(
+      std::nullopt, timestampaddBigint("month", std::nullopt, Timestamp(0, 0)));
 
   // Check invalid units.
   VELOX_ASSERT_THROW(
       timestampadd("invalid_unit", 1, Timestamp(0, 0)),
       "Unsupported datetime unit: invalid_unit");
+  VELOX_ASSERT_THROW(
+      timestampaddBigint("invalid_unit", 1, Timestamp(0, 0)),
+      "Unsupported datetime unit: invalid_unit");
 
   EXPECT_EQ(
       Timestamp(1551348061, 999) /*2019-02-28 10:01:01.000000*/,
@@ -1712,6 +1770,12 @@ TEST_F(DateTimeFunctionsTest, timestampadd) {
           "microsecond",
           60 * 1000000 + 500,
           Timestamp(1551348000, 999'500'999) /*2019-02-28 10:00:00.999500*/));
+  EXPECT_EQ(
+      Timestamp(1551348061, 999) /*2019-02-28 10:01:01.000000*/,
+      timestampaddBigint(
+          "microsecond",
+          60 * 1000000 + 500,
+          Timestamp(1551348000, 999'500'999) /*2019-02-28 10:00:00.999500*/));
   EXPECT_EQ(
       Timestamp(1551348061, 999'999) /*2019-02-28 10:01:01.000*/,
       timestampadd(
@@ -1796,5 +1860,84 @@ TEST_F(DateTimeFunctionsTest, timestampadd) {
           10,
           Timestamp(1582970400, 500'999'999) /*2020-02-29 10:00:00.500*/));
 }
+
+TEST_F(DateTimeFunctionsTest, monthsBetween) {
+  const auto monthsBetween = [&](std::optional<Timestamp> timestamp1,
+                                 std::optional<Timestamp> timestamp2,
+                                 std::optional<bool> roundOff) {
+    return evaluateOnce<double>(
+        "months_between(c0, c1, c2)", timestamp1, timestamp2, roundOff);
+  };
+
+  EXPECT_EQ(
+      3.94959677,
+      monthsBetween(
+          parseTimestamp("1997-02-28 10:30:00"),
+          parseTimestamp("1996-10-30"),
+          true));
+  EXPECT_EQ(
+      3.9495967741935485,
+      monthsBetween(
+          parseTimestamp("1997-02-28 10:30:00"),
+          parseTimestamp("1996-10-30"),
+          false));
+  EXPECT_EQ(
+      3.9495949074074073,
+      monthsBetween(
+          parseTimestamp("1997-02-28 10:30:00"),
+          parseTimestamp("1996-10-30 00:00:05"),
+          false));
+  EXPECT_EQ(
+      -3.9495949074074073,
+      monthsBetween(
+          parseTimestamp("1996-10-30 00:00:05"),
+          parseTimestamp("1997-02-28 10:30:00"),
+          false));
+  // `timestamp1` and `timestamp2` both are the last day of month.
+  EXPECT_EQ(
+      11,
+      monthsBetween(
+          parseTimestamp("1997-02-28 10:30:00"),
+          parseTimestamp("1996-03-31 11:00:00"),
+          true));
+  // `timestamp1` and `timestamp2` are on the same day of month.
+  EXPECT_EQ(
+      11,
+      monthsBetween(
+          parseTimestamp("1997-02-28 10:30:00"),
+          parseTimestamp("1996-03-28 11:00:00"),
+          true));
+  EXPECT_EQ(
+      11,
+      monthsBetween(
+          parseTimestamp("1997-02-21 10:30:00"),
+          parseTimestamp("1996-03-21 11:00:00"),
+          true));
+}
+TEST_F(DateTimeFunctionsTest, dateFormat) {
+  const auto dateFormat = [&](std::optional<Timestamp> timestamp,
+                              std::optional<std::string> format) {
+    return evaluateOnce<std::string>("date_format(c0, c1)", timestamp, format);
+  };
+
+  // Check invalid format.
+  EXPECT_THROW(dateFormat(parseTimestamp("1970-01-01"), "u"), VeloxUserError);
+  EXPECT_THROW(
+      dateFormat(parseTimestamp("1970-01-01"), "'abcd"), VeloxUserError);
+
+  // Check Simple tests.
+  EXPECT_EQ("AD", dateFormat(parseTimestamp("1970-01-01"), "G"));
+  EXPECT_EQ("19", dateFormat(parseTimestamp("1900-01-01"), "C"));
+  EXPECT_EQ("2020", dateFormat(parseTimestamp("2020-01-01"), "Y"));
+  EXPECT_EQ("1", dateFormat(parseTimestamp("2022-01-01"), "D"));
+  EXPECT_EQ("1", dateFormat(parseTimestamp("2022-01-01"), "d"));
+  EXPECT_EQ("AM", dateFormat(parseTimestamp("2022-01-01 00:00:00"), "a"));
+  EXPECT_EQ(
+      "2022-01-01 00:00:00",
+      dateFormat(parseTimestamp("2022-01-01"), "yyyy-MM-dd HH:mm:ss"));
+
+  enableLegacyFormatter();
+  EXPECT_EQ("4", dateFormat(parseTimestamp("1970-01-01"), "u"));
+}
 } // namespace
 } // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/DecimalArithmeticTest.cpp b/velox/functions/sparksql/tests/DecimalArithmeticTest.cpp
index ff5e50da809..fb89d0e756a 100644
--- a/velox/functions/sparksql/tests/DecimalArithmeticTest.cpp
+++ b/velox/functions/sparksql/tests/DecimalArithmeticTest.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/functions/sparksql/DecimalArithmetic.h"
+#include <fmt/format.h>
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/core/Expressions.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
@@ -44,8 +45,9 @@ class DecimalArithmeticTest : public SparkFunctionBaseTest {
         "At least one input vector is needed for arithmetic function test.");
     std::vector<core::TypedExprPtr> inputExprs;
     for (int i = 0; i < inputs.size(); ++i) {
-      inputExprs.emplace_back(std::make_shared<core::FieldAccessTypedExpr>(
-          inputs[i]->type(), fmt::format("c{}", i)));
+      inputExprs.emplace_back(
+          std::make_shared<core::FieldAccessTypedExpr>(
+              inputs[i]->type(), fmt::format("c{}", i)));
     }
     auto expr = std::make_shared<const core::CallTypedExpr>(
         expected->type(), std::move(inputExprs), functionName);
@@ -69,6 +71,289 @@ class DecimalArithmeticTest : public SparkFunctionBaseTest {
     }
     return makeNullableFlatVector<int128_t>(numbers, type);
   }
+
+  template <typename T, typename U>
+  std::optional<int64_t> div(
+      const TypePtr& tType,
+      const TypePtr& uType,
+      std::optional<T> t,
+      std::optional<U> u) {
+    return evaluateOnce<int64_t>("div(c0, c1)", {tType, uType}, t, u);
+  }
+
+  template <typename T, typename U>
+  std::optional<int64_t> checked_div(
+      const TypePtr& tType,
+      const TypePtr& uType,
+      std::optional<T> t,
+      std::optional<U> u) {
+    return evaluateOnce<int64_t>("checked_div(c0, c1)", {tType, uType}, t, u);
+  }
+
+  // Checked tests use evaluateOnce (scalar) rather than testArithmeticFunction
+  // (batch) because error assertions need std::optional returns to verify both
+  // try() -> nullopt and bare -> throw behaviors.
+  template <typename T, typename U>
+  std::optional<int128_t> checkedDecimalArithmetic(
+      const std::string& func,
+      const TypePtr& tType,
+      const TypePtr& uType,
+      std::optional<T> t,
+      std::optional<U> u) {
+    return evaluateOnce<int128_t>(
+        fmt::format("{}(c0, c1)", func), {tType, uType}, t, u);
+  }
+
+  template <typename T, typename U>
+  std::optional<int128_t> checkedAdd(
+      const TypePtr& tType,
+      const TypePtr& uType,
+      std::optional<T> t,
+      std::optional<U> u) {
+    return checkedDecimalArithmetic("checked_add", tType, uType, t, u);
+  }
+
+  template <typename T, typename U>
+  std::optional<int128_t> checkedSubtract(
+      const TypePtr& tType,
+      const TypePtr& uType,
+      std::optional<T> t,
+      std::optional<U> u) {
+    return checkedDecimalArithmetic("checked_subtract", tType, uType, t, u);
+  }
+
+  template <typename T, typename U>
+  void assertErrorForCheckedDecimalArithmetic(
+      const std::string& func,
+      const TypePtr& tType,
+      const TypePtr& uType,
+      std::optional<T> t,
+      std::optional<U> u,
+      const std::string& errorMessage) {
+    auto res = evaluateOnce<int128_t>(
+        fmt::format("try({}(c0, c1))", func), {tType, uType}, t, u);
+    ASSERT_TRUE(!res.has_value());
+    VELOX_ASSERT_USER_THROW(
+        (evaluateOnce<int128_t>(
+            fmt::format("{}(c0, c1)", func), {tType, uType}, t, u)),
+        errorMessage);
+  }
+
+  template <typename T, typename U>
+  void assertErrorForCheckedAdd(
+      const TypePtr& tType,
+      const TypePtr& uType,
+      std::optional<T> t,
+      std::optional<U> u,
+      const std::string& errorMessage) {
+    assertErrorForCheckedDecimalArithmetic(
+        "checked_add", tType, uType, t, u, errorMessage);
+  }
+
+  template <typename T, typename U>
+  void assertErrorForCheckedSubtract(
+      const TypePtr& tType,
+      const TypePtr& uType,
+      std::optional<T> t,
+      std::optional<U> u,
+      const std::string& errorMessage) {
+    assertErrorForCheckedDecimalArithmetic(
+        "checked_subtract", tType, uType, t, u, errorMessage);
+  }
+
+  template <typename T, typename U>
+  std::optional<int128_t> checkedMultiply(
+      const TypePtr& tType,
+      const TypePtr& uType,
+      std::optional<T> t,
+      std::optional<U> u) {
+    return checkedDecimalArithmetic("checked_multiply", tType, uType, t, u);
+  }
+
+  template <typename T, typename U>
+  void assertErrorForCheckedMultiply(
+      const TypePtr& tType,
+      const TypePtr& uType,
+      std::optional<T> t,
+      std::optional<U> u,
+      const std::string& errorMessage) {
+    assertErrorForCheckedDecimalArithmetic(
+        "checked_multiply", tType, uType, t, u, errorMessage);
+  }
+
+  /// Runs the common normal and overflow test cases for checked add.
+  void testCheckedAddCommon(const std::string& suffix = "") {
+    const std::string func = "checked_add" + suffix;
+
+    // All input type combinations.
+    EXPECT_EQ(
+        (checkedDecimalArithmetic<int64_t, int64_t>(
+            func, DECIMAL(18, 2), DECIMAL(18, 2), 100, 200)),
+        300);
+    EXPECT_EQ(
+        (checkedDecimalArithmetic<int64_t, int128_t>(
+            func, DECIMAL(18, 2), DECIMAL(20, 2), 100, 200)),
+        300);
+    EXPECT_EQ(
+        (checkedDecimalArithmetic<int128_t, int64_t>(
+            func, DECIMAL(20, 2), DECIMAL(18, 2), 100, 200)),
+        300);
+    EXPECT_EQ(
+        (checkedDecimalArithmetic<int128_t, int128_t>(
+            func, DECIMAL(20, 2), DECIMAL(20, 2), 100, 200)),
+        300);
+
+    // Adding with zero.
+    EXPECT_EQ(
+        (checkedDecimalArithmetic<int64_t, int64_t>(
+            func, DECIMAL(18, 2), DECIMAL(18, 2), 0, 100)),
+        100);
+
+    // Adding negative numbers.
+    EXPECT_EQ(
+        (checkedDecimalArithmetic<int64_t, int64_t>(
+            func, DECIMAL(18, 2), DECIMAL(18, 2), -100, 50)),
+        -50);
+
+    // Result precision capped at 38, no overflow.
+    EXPECT_EQ(
+        (checkedDecimalArithmetic<int128_t, int128_t>(
+            func, DECIMAL(38, 0), DECIMAL(38, 0), 100, 200)),
+        300);
+
+    // Near-boundary success: large values through addLarge path, but fits.
+    EXPECT_EQ(
+        (checkedDecimalArithmetic<int128_t, int128_t>(
+            func,
+            DECIMAL(38, 0),
+            DECIMAL(38, 0),
+            HugeInt::parse("49999999999999999999999999999999999999"),
+            HugeInt::parse("49999999999999999999999999999999999999"))),
+        HugeInt::parse("99999999999999999999999999999999999998"));
+
+    // Positive overflow should throw; try() should return NULL.
+    assertErrorForCheckedDecimalArithmetic<int128_t, int128_t>(
+        func,
+        DECIMAL(38, 0),
+        DECIMAL(38, 0),
+        HugeInt::parse("99999999999999999999999999999999999999"),
+        HugeInt::parse("99999999999999999999999999999999999999"),
+        "Decimal overflow in add");
+
+    // Positive overflow with large positive and small positive.
+    assertErrorForCheckedDecimalArithmetic<int128_t, int128_t>(
+        func,
+        DECIMAL(38, 0),
+        DECIMAL(38, 0),
+        HugeInt::parse("99999999999999999999999999999999999999"),
+        1,
+        "Decimal overflow in add");
+
+    // Negative overflow should throw; try() should return NULL.
+    assertErrorForCheckedDecimalArithmetic<int128_t, int128_t>(
+        func,
+        DECIMAL(38, 0),
+        DECIMAL(38, 0),
+        HugeInt::parse("-99999999999999999999999999999999999999"),
+        HugeInt::parse("-99999999999999999999999999999999999999"),
+        "Decimal overflow in add");
+
+    // Negative overflow with large negative and small negative.
+    assertErrorForCheckedDecimalArithmetic<int128_t, int128_t>(
+        func,
+        DECIMAL(38, 0),
+        DECIMAL(38, 0),
+        HugeInt::parse("-99999999999999999999999999999999999999"),
+        -1,
+        "Decimal overflow in add");
+  }
+
+  /// Runs the common normal and overflow test cases for checked subtract.
+  void testCheckedSubtractCommon(const std::string& suffix = "") {
+    const std::string func = "checked_subtract" + suffix;
+
+    // All input type combinations.
+    EXPECT_EQ(
+        (checkedDecimalArithmetic<int64_t, int64_t>(
+            func, DECIMAL(18, 2), DECIMAL(18, 2), 300, 200)),
+        100);
+    EXPECT_EQ(
+        (checkedDecimalArithmetic<int64_t, int128_t>(
+            func, DECIMAL(18, 2), DECIMAL(20, 2), 300, 200)),
+        100);
+    EXPECT_EQ(
+        (checkedDecimalArithmetic<int128_t, int64_t>(
+            func, DECIMAL(20, 2), DECIMAL(18, 2), 300, 200)),
+        100);
+    EXPECT_EQ(
+        (checkedDecimalArithmetic<int128_t, int128_t>(
+            func, DECIMAL(20, 2), DECIMAL(20, 2), 300, 200)),
+        100);
+
+    // Subtracting zero.
+    EXPECT_EQ(
+        (checkedDecimalArithmetic<int64_t, int64_t>(
+            func, DECIMAL(18, 2), DECIMAL(18, 2), 100, 0)),
+        100);
+
+    // Subtracting negative (effectively adding).
+    EXPECT_EQ(
+        (checkedDecimalArithmetic<int64_t, int64_t>(
+            func, DECIMAL(18, 2), DECIMAL(18, 2), 100, -50)),
+        150);
+
+    // Result precision capped at 38, no overflow.
+    EXPECT_EQ(
+        (checkedDecimalArithmetic<int128_t, int128_t>(
+            func, DECIMAL(38, 0), DECIMAL(38, 0), 300, 200)),
+        100);
+
+    // Near-boundary success: large values through addLarge path, but fits.
+    EXPECT_EQ(
+        (checkedDecimalArithmetic<int128_t, int128_t>(
+            func,
+            DECIMAL(38, 0),
+            DECIMAL(38, 0),
+            HugeInt::parse("49999999999999999999999999999999999999"),
+            HugeInt::parse("-49999999999999999999999999999999999999"))),
+        HugeInt::parse("99999999999999999999999999999999999998"));
+
+    // Negative overflow should throw; try() should return NULL.
+    assertErrorForCheckedDecimalArithmetic<int128_t, int128_t>(
+        func,
+        DECIMAL(38, 0),
+        DECIMAL(38, 0),
+        HugeInt::parse("-99999999999999999999999999999999999999"),
+        HugeInt::parse("99999999999999999999999999999999999999"),
+        "Decimal overflow in subtract");
+
+    // Negative overflow with large negative and small positive.
+    assertErrorForCheckedDecimalArithmetic<int128_t, int128_t>(
+        func,
+        DECIMAL(38, 0),
+        DECIMAL(38, 0),
+        HugeInt::parse("-99999999999999999999999999999999999999"),
+        1,
+        "Decimal overflow in subtract");
+
+    // Positive overflow should throw; try() should return NULL.
+    assertErrorForCheckedDecimalArithmetic<int128_t, int128_t>(
+        func,
+        DECIMAL(38, 0),
+        DECIMAL(38, 0),
+        HugeInt::parse("99999999999999999999999999999999999999"),
+        HugeInt::parse("-99999999999999999999999999999999999999"),
+        "Decimal overflow in subtract");
+
+    // Positive overflow with large positive and small negative.
+    assertErrorForCheckedDecimalArithmetic<int128_t, int128_t>(
+        func,
+        DECIMAL(38, 0),
+        DECIMAL(38, 0),
+        HugeInt::parse("99999999999999999999999999999999999999"),
+        -1,
+        "Decimal overflow in subtract");
+  }
 };
 
 TEST_F(DecimalArithmeticTest, add) {
@@ -714,5 +999,237 @@ TEST_F(DecimalArithmeticTest, ceil) {
            0},
           DECIMAL(19, 19))});
 }
+
+TEST_F(DecimalArithmeticTest, div) {
+  EXPECT_EQ((div<int64_t, int64_t>(DECIMAL(7, 1), DECIMAL(8, 2), 10, 200)), 0L);
+  EXPECT_EQ((div<int64_t, int64_t>(DECIMAL(7, 1), DECIMAL(8, 2), 24, 110)), 2L);
+  EXPECT_EQ((div<int64_t, int64_t>(DECIMAL(7, 1), DECIMAL(8, 2), 12, 110)), 1L);
+  EXPECT_EQ(
+      (div<int64_t, int64_t>(DECIMAL(7, 1), DECIMAL(8, 2), 20, 0)),
+      std::nullopt);
+  EXPECT_EQ((div<int64_t, int64_t>(DECIMAL(7, 1), DECIMAL(8, 2), 91, 200)), 4L);
+  EXPECT_EQ(
+      (div<int64_t, int64_t>(DECIMAL(7, 1), DECIMAL(8, 2), 100, 200)), 5L);
+  EXPECT_EQ(
+      (div<int64_t, int64_t>(DECIMAL(7, 1), DECIMAL(8, 2), -92, 200)), -4L);
+  EXPECT_EQ(
+      (div<int64_t, int64_t>(DECIMAL(7, 1), DECIMAL(8, 2), 100, -190)), -5L);
+  EXPECT_EQ(
+      (div<int64_t, int64_t>(DECIMAL(7, 1), DECIMAL(8, 2), -100, -190)), 5L);
+
+  EXPECT_EQ(
+      (div<int64_t, int128_t>(DECIMAL(7, 1), DECIMAL(38, 2), 10, 200)), 0L);
+  EXPECT_EQ(
+      (div<int64_t, int128_t>(DECIMAL(7, 1), DECIMAL(38, 2), 24, 110)), 2L);
+  EXPECT_EQ(
+      (div<int64_t, int128_t>(DECIMAL(7, 1), DECIMAL(38, 2), 12, 110)), 1L);
+  EXPECT_EQ(
+      (div<int64_t, int128_t>(DECIMAL(7, 1), DECIMAL(38, 2), 20, 0L)),
+      std::nullopt);
+  EXPECT_EQ(
+      (div<int64_t, int128_t>(
+          DECIMAL(7, 1),
+          DECIMAL(38, 2),
+          0,
+          HugeInt::parse("99999999999999999999999999999999999999"))),
+      0L);
+
+  EXPECT_EQ(
+      (div<int128_t, int64_t>(DECIMAL(38, 1), DECIMAL(7, 4), 10, 20000)), 0L);
+  EXPECT_EQ(
+      (div<int128_t, int64_t>(DECIMAL(38, 1), DECIMAL(7, 4), 25, 11000)), 2L);
+  EXPECT_EQ(
+      (div<int128_t, int64_t>(DECIMAL(38, 1), DECIMAL(7, 4), 26, 11000)), 2L);
+  EXPECT_EQ(
+      (div<int128_t, int64_t>(DECIMAL(38, 1), DECIMAL(7, 4), 20, 0L)),
+      std::nullopt);
+  EXPECT_EQ(
+      (div<int128_t, int64_t>(
+          DECIMAL(38, 1),
+          DECIMAL(7, 4),
+          HugeInt::parse("99999999999999999999999999999999999"),
+          1L)),
+      687399551400672280L);
+
+  EXPECT_EQ(
+      (div<int128_t, int128_t>(DECIMAL(38, 0), DECIMAL(38, 6), 10, 2100000)),
+      4L);
+  EXPECT_EQ(
+      (div<int128_t, int128_t>(DECIMAL(38, 0), DECIMAL(38, 6), 10, 2900000)),
+      3L);
+  EXPECT_EQ(
+      (div<int128_t, int128_t>(DECIMAL(38, 0), DECIMAL(38, 6), 20, 0)),
+      std::nullopt);
+  EXPECT_EQ(
+      (div<int128_t, int128_t>(
+          DECIMAL(38, 0),
+          DECIMAL(38, 6),
+          HugeInt::parse("99999999999999999999999999999999999999"),
+          1)),
+      std::nullopt);
+}
+
+TEST_F(DecimalArithmeticTest, checkedDiv) {
+  EXPECT_EQ(
+      (checked_div<int64_t, int64_t>(DECIMAL(7, 1), DECIMAL(8, 2), 10, 200)),
+      0L);
+  EXPECT_EQ(
+      (checked_div<int64_t, int128_t>(DECIMAL(7, 1), DECIMAL(38, 2), 12, 110)),
+      1L);
+  EXPECT_EQ(
+      (checked_div<int128_t, int64_t>(
+          DECIMAL(38, 1), DECIMAL(7, 4), 25, 11000)),
+      2L);
+  EXPECT_EQ(
+      (checked_div<int128_t, int128_t>(
+          DECIMAL(38, 0), DECIMAL(38, 6), 10, 2900000)),
+      3L);
+
+  VELOX_ASSERT_USER_THROW(
+      (checked_div<int64_t, int64_t>(DECIMAL(7, 1), DECIMAL(8, 2), 91, 0)),
+      "Division by zero");
+  VELOX_ASSERT_USER_THROW(
+      (checked_div<int128_t, int128_t>(DECIMAL(37, 1), DECIMAL(38, 2), 91, 0)),
+      "Division by zero");
+  VELOX_ASSERT_USER_THROW(
+      (checked_div<int128_t, int128_t>(
+          DECIMAL(38, 0),
+          DECIMAL(38, 6),
+          HugeInt::parse("99999999999999999999999999999999999999"),
+          1)),
+      "Overflow in integral divide");
+}
+
+TEST_F(DecimalArithmeticTest, checkedAdd) {
+  testCheckedAddCommon();
+}
+
+TEST_F(DecimalArithmeticTest, checkedSubtract) {
+  testCheckedSubtractCommon();
+}
+
+TEST_F(DecimalArithmeticTest, checkedAddDenyPrecisionLoss) {
+  const std::string denyPrecisionLoss = "_deny_precision_loss";
+  testCheckedAddCommon(denyPrecisionLoss);
+
+  // Overflow during scale alignment should throw instead of returning null.
+  // These cases only overflow under deny-precision-loss because the full scale
+  // is preserved (not reduced), requiring a larger rescale factor.
+  assertErrorForCheckedDecimalArithmetic<int128_t, int128_t>(
+      "checked_add" + denyPrecisionLoss,
+      DECIMAL(38, 3),
+      DECIMAL(38, 7),
+      HugeInt::parse("-99999999999999999999999999999999990000"),
+      -100,
+      "Decimal overflow in add");
+
+  assertErrorForCheckedDecimalArithmetic<int128_t, int128_t>(
+      "checked_add" + denyPrecisionLoss,
+      DECIMAL(38, 3),
+      DECIMAL(38, 7),
+      HugeInt::parse("99999999999999999999999999999999999000"),
+      9999999,
+      "Decimal overflow in add");
+}
+
+TEST_F(DecimalArithmeticTest, checkedSubtractDenyPrecisionLoss) {
+  const std::string denyPrecisionLoss = "_deny_precision_loss";
+  testCheckedSubtractCommon(denyPrecisionLoss);
+
+  // Overflow during scale alignment should throw instead of returning null.
+  // These cases only overflow under deny-precision-loss because the full scale
+  // is preserved (not reduced), requiring a larger rescale factor.
+  assertErrorForCheckedDecimalArithmetic<int128_t, int128_t>(
+      "checked_subtract" + denyPrecisionLoss,
+      DECIMAL(38, 3),
+      DECIMAL(38, 7),
+      HugeInt::parse("-99999999999999999999999999999999990000"),
+      100,
+      "Decimal overflow in subtract");
+
+  assertErrorForCheckedDecimalArithmetic<int128_t, int128_t>(
+      "checked_subtract" + denyPrecisionLoss,
+      DECIMAL(38, 3),
+      DECIMAL(38, 7),
+      HugeInt::parse("99999999999999999999999999999999999000"),
+      -9999999,
+      "Decimal overflow in subtract");
+}
+
+TEST_F(DecimalArithmeticTest, checkedMultiply) {
+  // Normal cases: DECIMAL(17,3) * DECIMAL(17,3) -> result precision 35 (long).
+  // 1.000 * 2.000 = 2.000000 (unscaled: 1000 * 2000 = 2000000).
+  EXPECT_EQ(
+      (checkedMultiply<int64_t, int64_t>(
+          DECIMAL(17, 3), DECIMAL(17, 3), 1000, 2000)),
+      2000000);
+  EXPECT_EQ(
+      (checkedMultiply<int64_t, int128_t>(
+          DECIMAL(17, 3), DECIMAL(20, 3), 1000, 2000)),
+      2000000);
+  EXPECT_EQ(
+      (checkedMultiply<int128_t, int64_t>(
+          DECIMAL(20, 3), DECIMAL(17, 3), 1000, 2000)),
+      2000000);
+  EXPECT_EQ(
+      (checkedMultiply<int128_t, int128_t>(
+          DECIMAL(20, 3), DECIMAL(20, 3), 1000, 2000)),
+      2000000);
+
+  // Multiplying by zero.
+  EXPECT_EQ(
+      (checkedMultiply<int64_t, int64_t>(
+          DECIMAL(17, 3), DECIMAL(17, 3), 0, 2000)),
+      0);
+
+  // Multiplying negative numbers: (-1.000) * 2.000 = -2.000000.
+  EXPECT_EQ(
+      (checkedMultiply<int64_t, int64_t>(
+          DECIMAL(17, 3), DECIMAL(17, 3), -1000, 2000)),
+      -2000000);
+
+  // Result precision capped at 38, no overflow (small values).
+  // DECIMAL(38,0) * DECIMAL(38,0) -> result precision capped at 38, scale 0.
+  EXPECT_EQ(
+      (checkedMultiply<int128_t, int128_t>(
+          DECIMAL(38, 0), DECIMAL(38, 0), 100, 200)),
+      20000);
+
+  // Near-boundary success: large values that just fit.
+  // 1e18 * 1e19 = 1e37, which fits in DECIMAL(38,0).
+  EXPECT_EQ(
+      (checkedMultiply<int128_t, int128_t>(
+          DECIMAL(38, 0),
+          DECIMAL(38, 0),
+          HugeInt::parse("1000000000000000000"),
+          HugeInt::parse("10000000000000000000"))),
+      HugeInt::parse("10000000000000000000000000000000000000"));
+
+  // Positive overflow should throw.
+  // 1e19 * 1e19 = 1e38, which exceeds max DECIMAL(38,0).
+  assertErrorForCheckedMultiply<int128_t, int128_t>(
+      DECIMAL(38, 0),
+      DECIMAL(38, 0),
+      HugeInt::parse("10000000000000000000"),
+      HugeInt::parse("10000000000000000000"),
+      "Decimal overflow in multiply");
+
+  // Negative overflow should throw (positive * negative -> overflow).
+  assertErrorForCheckedMultiply<int128_t, int128_t>(
+      DECIMAL(38, 0),
+      DECIMAL(38, 0),
+      HugeInt::parse("10000000000000000000"),
+      HugeInt::parse("-10000000000000000000"),
+      "Decimal overflow in multiply");
+
+  // Negative * negative overflow should throw (result is positive but too
+  // large).
+  assertErrorForCheckedMultiply<int128_t, int128_t>(
+      DECIMAL(38, 0),
+      DECIMAL(38, 0),
+      HugeInt::parse("-10000000000000000000"),
+      HugeInt::parse("-10000000000000000000"),
+      "Decimal overflow in multiply");
+}
 } // namespace
 } // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/DecimalRoundTest.cpp b/velox/functions/sparksql/tests/DecimalRoundTest.cpp
index c2ba472b0ca..c1f6dc4d578 100644
--- a/velox/functions/sparksql/tests/DecimalRoundTest.cpp
+++ b/velox/functions/sparksql/tests/DecimalRoundTest.cpp
@@ -35,14 +35,16 @@ class DecimalRoundTest : public SparkFunctionBaseTest {
       if (castScale) {
         // It is a common case in Spark for the second argument to be cast from
         // bigint to integer.
-        inputs.emplace_back(std::make_shared<core::CastTypedExpr>(
-            INTEGER(),
-            std::make_shared<core::ConstantTypedExpr>(
-                BIGINT(), variant((int64_t)scale)),
-            true /*nullOnFailure*/));
+        inputs.emplace_back(
+            std::make_shared<core::CastTypedExpr>(
+                INTEGER(),
+                std::make_shared<core::ConstantTypedExpr>(
+                    BIGINT(), variant((int64_t)scale)),
+                true /*nullOnFailure*/));
       } else {
-        inputs.emplace_back(std::make_shared<core::ConstantTypedExpr>(
-            INTEGER(), variant(scale)));
+        inputs.emplace_back(
+            std::make_shared<core::ConstantTypedExpr>(
+                INTEGER(), variant(scale)));
       }
     }
 
diff --git a/velox/functions/sparksql/tests/DecimalUtilTest.cpp b/velox/functions/sparksql/tests/DecimalUtilTest.cpp
index 1b63019ed12..8eef6858de7 100644
--- a/velox/functions/sparksql/tests/DecimalUtilTest.cpp
+++ b/velox/functions/sparksql/tests/DecimalUtilTest.cpp
@@ -35,6 +35,19 @@ class DecimalUtilTest : public testing::Test {
     ASSERT_EQ(overflow, expectedOverflow);
     ASSERT_EQ(r, expectedResult);
   }
+
+  template <bool allowPrecisionLoss>
+  void testComputeDivideResultPrecisionScale(
+      const uint8_t aPrecision,
+      const uint8_t aScale,
+      const uint8_t bPrecision,
+      const uint8_t bScale,
+      std::pair<uint8_t, uint8_t> expected) {
+    ASSERT_EQ(
+        DecimalUtil::computeDivideResultPrecisionScale<allowPrecisionLoss>(
+            aPrecision, aScale, bPrecision, bScale),
+        expected);
+  }
 };
 } // namespace
 
@@ -72,4 +85,19 @@ TEST_F(DecimalUtilTest, bounded) {
   testBounded(40, 3, {38, 3});
   testBounded(44, 42, {38, 38});
 }
+
+TEST_F(DecimalUtilTest, computeDivideResultPrecisionScale) {
+  // Test with allowPrecisionLoss = true.
+  testComputeDivideResultPrecisionScale<true>(10, 2, 5, 1, {17, 8});
+  testComputeDivideResultPrecisionScale<true>(38, 10, 10, 5, {38, 6});
+  testComputeDivideResultPrecisionScale<true>(1, 0, 1, 0, {7, 6});
+  testComputeDivideResultPrecisionScale<true>(20, 2, 20, 2, {38, 18});
+
+  // Test with allowPrecisionLoss = false.
+  testComputeDivideResultPrecisionScale<false>(10, 2, 5, 1, {17, 8});
+  testComputeDivideResultPrecisionScale<false>(38, 10, 5, 3, {38, 11});
+  testComputeDivideResultPrecisionScale<false>(1, 0, 1, 0, {7, 6});
+  testComputeDivideResultPrecisionScale<false>(30, 5, 10, 5, {38, 11});
+}
+
 } // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/FilterTest.cpp b/velox/functions/sparksql/tests/FilterTest.cpp
new file mode 100644
index 00000000000..ebea98a4350
--- /dev/null
+++ b/velox/functions/sparksql/tests/FilterTest.cpp
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+using namespace facebook::velox::test;
+
+class FilterTest : public SparkFunctionBaseTest {
+ protected:
+  void testFilter(
+      const std::string& expression,
+      const VectorPtr& input,
+      const VectorPtr& expected) {
+    auto result = evaluate(expression, makeRowVector({input}));
+    assertEqualVectors(expected, result);
+  }
+};
+
+// Test filter with element-only lambda: filter(array, x -> greaterthan(x, 0)).
+TEST_F(FilterTest, elementOnly) {
+  auto input = makeArrayVectorFromJson<int64_t>({
+      "[1, -2, 3, -4, 5]",
+      "[10, 20]",
+      "[-1, -2]",
+      "[]",
+      "null",
+  });
+
+  auto expected = makeArrayVectorFromJson<int64_t>({
+      "[1, 3, 5]",
+      "[10, 20]",
+      "[]",
+      "[]",
+      "null",
+  });
+
+  testFilter("filter(c0, x -> greaterthan(x, 0))", input, expected);
+}
+
+// Test filter with element-only lambda containing null elements.
+TEST_F(FilterTest, elementOnlyWithNulls) {
+  auto input = makeArrayVectorFromJson<int64_t>({
+      "[1, null, 3]",
+      "[null, null]",
+      "[4, 5, null]",
+  });
+
+  // Null elements: predicate returns null, treated as false (filtered out).
+  auto expected = makeArrayVectorFromJson<int64_t>({
+      "[1, 3]",
+      "[]",
+      "[4, 5]",
+  });
+
+  testFilter("filter(c0, x -> greaterthan(x, 0))", input, expected);
+}
+
+// Test filter with element + index lambda:
+// filter(array, (x, i) -> greaterthan(x, i)).
+TEST_F(FilterTest, elementWithIndex) {
+  auto input = makeArrayVectorFromJson<int64_t>({
+      "[0, 2, 3]",
+      "[10, 0, 30]",
+      "[0, 1, 2]",
+      "[]",
+      "null",
+  });
+
+  // Expected: keep elements where x > i (0-based index)
+  // [0>0=F, 2>1=T, 3>2=T] -> [2, 3]
+  // [10>0=T, 0>1=F, 30>2=T] -> [10, 30]
+  // [0>0=F, 1>1=F, 2>2=F] -> []
+  // [] -> []
+  // null -> null
+  auto expected = makeArrayVectorFromJson<int64_t>({
+      "[2, 3]",
+      "[10, 30]",
+      "[]",
+      "[]",
+      "null",
+  });
+
+  testFilter("filter(c0, (x, i) -> greaterthan(x, i))", input, expected);
+}
+
+// Test filter with index-only usage: filter(array, (x, i) -> lessthan(i, 2)).
+TEST_F(FilterTest, indexOnly) {
+  auto input = makeArrayVectorFromJson<int64_t>({
+      "[100, 200, 300, 400]",
+      "[1, 2]",
+      "[42]",
+      "[]",
+  });
+
+  // Expected: keep first 2 elements (index < 2)
+  auto expected = makeArrayVectorFromJson<int64_t>({
+      "[100, 200]",
+      "[1, 2]",
+      "[42]",
+      "[]",
+  });
+
+  testFilter("filter(c0, (x, i) -> lessthan(i, 2))", input, expected);
+}
+
+// Test filter with element + index and null elements.
+TEST_F(FilterTest, elementWithIndexAndNulls) {
+  auto input = makeArrayVectorFromJson<int64_t>({
+      "[1, null, 3]",
+      "[null, 5]",
+  });
+
+  // For (x, i) -> greaterthan(x, i):
+  // [1>0=T, null>1=null(F), 3>2=T] -> [1, 3]
+  // [null>0=null(F), 5>1=T] -> [5]
+  auto expected = makeArrayVectorFromJson<int64_t>({
+      "[1, 3]",
+      "[5]",
+  });
+
+  testFilter("filter(c0, (x, i) -> greaterthan(x, i))", input, expected);
+}
+
+// Test filter with isnotnull predicate.
+TEST_F(FilterTest, isNotNull) {
+  auto input = makeArrayVectorFromJson<int64_t>({
+      "[0, null, 2, 3, null]",
+      "[null, null]",
+      "[1, 2, 3]",
+  });
+
+  auto expected = makeArrayVectorFromJson<int64_t>({
+      "[0, 2, 3]",
+      "[]",
+      "[1, 2, 3]",
+  });
+
+  testFilter("filter(c0, x -> isnotnull(x))", input, expected);
+}
+
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/GetJsonObjectTest.cpp b/velox/functions/sparksql/tests/GetJsonObjectTest.cpp
index d16327d3ad6..54b09fa7365 100644
--- a/velox/functions/sparksql/tests/GetJsonObjectTest.cpp
+++ b/velox/functions/sparksql/tests/GetJsonObjectTest.cpp
@@ -46,6 +46,9 @@ TEST_F(GetJsonObjectTest, basic) {
   EXPECT_EQ(
       getJsonObject(R"({"name": "Alice", "age": 5, "id": "001"})", "$"),
       R"({"name": "Alice", "age": 5, "id": "001"})");
+  EXPECT_EQ(
+      getJsonObject(R"({"name": "Alice", "age": 5, "id": "001"})", "$  "),
+      R"({"name": "Alice", "age": 5, "id": "001"})");
   EXPECT_EQ(
       getJsonObject(R"({"name": "Alice", "age": 5, "id": "001"})", "$.age"),
       "5");
@@ -69,7 +72,16 @@ TEST_F(GetJsonObjectTest, basic) {
   EXPECT_EQ(getJsonObject(R"({"a b": "1"})", "$. a b"), "1");
   EXPECT_EQ(getJsonObject(R"({"two spaces": "1"})", "$.  two spaces"), "1");
   EXPECT_EQ(getJsonObject(R"({"a": "1"})", "$.a "), std::nullopt);
+  EXPECT_EQ(getJsonObject(R"({"a ": "1"})", "$.a "), "1");
   EXPECT_EQ(getJsonObject(R"({"a b": "1"})", "$.a b "), std::nullopt);
+  EXPECT_EQ(getJsonObject(R"({ "a b": "1" })", "$['a b']"), "1");
+  EXPECT_EQ(getJsonObject(R"({ "a b ": "1" })", "$['a b ']"), "1");
+  EXPECT_EQ(getJsonObject(R"({ " a b": "1" })", "$[' a b']"), std::nullopt);
+  EXPECT_EQ(getJsonObject(R"({ "a b": "1" })", "$[ 'a b']"), std::nullopt);
+  EXPECT_EQ(getJsonObject(R"({ "a b": "1" })", "$['a b' ]"), std::nullopt);
+  EXPECT_EQ(getJsonObject(R"({"a": {"a b": 1}})", "$.a['a b']"), "1");
+  EXPECT_EQ(
+      getJsonObject(R"({"a": {" a b": 1}})", "$.a[' a b']"), std::nullopt);
   EXPECT_EQ(
       getJsonObject(R"({"two spaces": "1"})", "$.  two spaces "), std::nullopt);
   EXPECT_EQ(getJsonObject(R"({"a": "1"})", "$ .a"), std::nullopt);
@@ -77,6 +89,8 @@ TEST_F(GetJsonObjectTest, basic) {
       getJsonObject(R"({"my": {"hello": true}})", "$.  my.  hello"), "true");
   EXPECT_EQ(
       getJsonObject(R"({"my": {"hello": true}})", "$.my.  hello"), "true");
+  EXPECT_EQ(getJsonObject(R"({"a$ ": {"b": 10}})", "$.a$ .b"), "10");
+  EXPECT_EQ(getJsonObject(R"({"a$. b": {"c": 10}})", "$.a$. b"), std::nullopt);
   // Json object as result.
   EXPECT_EQ(
       getJsonObject(
@@ -106,6 +120,18 @@ TEST_F(GetJsonObjectTest, basic) {
           R"([{"my": {"info": {"name": "Alice"}}}, {"other": ["v1", "v2"]}])",
           "$[1].other[1]"),
       "v2");
+
+  // Valid escape sequences: \", \\, \/, \b, \f, \n, \r, \t, \uXXXX.
+  EXPECT_EQ(getJsonObject(R"({"hello": "a\"b"})", "$.hello"), R"(a"b)");
+  EXPECT_EQ(getJsonObject(R"({"hello": "a\\b"})", "$.hello"), R"(a\b)");
+  EXPECT_EQ(getJsonObject(R"({"hello": "a\/b"})", "$.hello"), "a/b");
+  EXPECT_EQ(getJsonObject(R"({"hello": "a\bb"})", "$.hello"), "a\bb");
+  EXPECT_EQ(getJsonObject(R"({"hello": "a\fb"})", "$.hello"), "a\fb");
+  EXPECT_EQ(getJsonObject(R"({"hello": "a\nb"})", "$.hello"), "a\nb");
+  EXPECT_EQ(getJsonObject(R"({"hello": "a\rb"})", "$.hello"), "a\rb");
+  EXPECT_EQ(getJsonObject(R"({"hello": "a\tb"})", "$.hello"), "a\tb");
+  EXPECT_EQ(getJsonObject(R"({"hello": "\u0041"})", "$.hello"), "A");
+  EXPECT_EQ(getJsonObject(R"({"hello": "\u000A"})", "$.hello"), "\n");
 }
 
 TEST_F(GetJsonObjectTest, nullResult) {
@@ -130,6 +156,17 @@ TEST_F(GetJsonObjectTest, nullResult) {
           R"([{"my": {"info": {"name": "Alice"quoted""}}}, {"other": ["v1", "v2"]}])",
           "$[0].my.info.name"),
       std::nullopt);
+
+  // Invalid escape sequence.
+  EXPECT_EQ(getJsonObject(R"({"hello": "\x"})", "$.hello"), std::nullopt);
+  EXPECT_EQ(
+      getJsonObject(R"({"hello": "test", "invalid": "\@"})", "$.hello"),
+      std::nullopt);
+  EXPECT_EQ(getJsonObject(R"({"hello": "\๑"})", "$.hello"), std::nullopt);
+  // Invalid unicode escape sequences.
+  EXPECT_EQ(getJsonObject(R"({"hello": "\u"})", "$.hello"), std::nullopt);
+  EXPECT_EQ(getJsonObject(R"({"hello": "\u123"})", "$.hello"), std::nullopt);
+  EXPECT_EQ(getJsonObject(R"({"hello": "\uGHIJ"})", "$.hello"), std::nullopt);
 }
 
 TEST_F(GetJsonObjectTest, incompleteJson) {
diff --git a/velox/functions/sparksql/tests/HashTest.cpp b/velox/functions/sparksql/tests/HashTest.cpp
index ff506f2ddd6..effeac777a9 100644
--- a/velox/functions/sparksql/tests/HashTest.cpp
+++ b/velox/functions/sparksql/tests/HashTest.cpp
@@ -174,8 +174,9 @@ TEST_F(HashTest, array) {
 
   assertEqualVectors(
       makeFlatVector<int32_t>({-559580957, 1765031574, 42}),
-      hash(makeNullableArrayVector<int32_t>(
-          {{1, std::nullopt}, {std::nullopt, 2}, {std::nullopt}})));
+      hash(
+          makeNullableArrayVector<int32_t>(
+              {{1, std::nullopt}, {std::nullopt, 2}, {std::nullopt}})));
 
   // Nested array.
   {
@@ -269,10 +270,11 @@ TEST_F(HashTest, unknown) {
 
   assertEqualVectors(
       makeFlatVector<int32_t>({42, 42}),
-      hash(makeNullableArrayVector<UnknownValue>({
-          {std::nullopt, std::nullopt},
-          {std::nullopt, std::nullopt, std::nullopt},
-      })));
+      hash(
+          makeNullableArrayVector<UnknownValue>({
+              {std::nullopt, std::nullopt},
+              {std::nullopt, std::nullopt, std::nullopt},
+          })));
 
   auto mapVector = makeNullableMapVector<UnknownValue, UnknownValue>({
       std::nullopt,
diff --git a/velox/functions/sparksql/tests/InTest.cpp b/velox/functions/sparksql/tests/InTest.cpp
index ba1ea5ffcdb..a740aa362bd 100644
--- a/velox/functions/sparksql/tests/InTest.cpp
+++ b/velox/functions/sparksql/tests/InTest.cpp
@@ -83,8 +83,9 @@ class InTest : public SparkFunctionBaseTest {
         rhsArrayVector = wrapInDictionary(indices, rhs.size(), rhsArrayVector);
       }
 
-      args.push_back(std::make_shared<core::ConstantTypedExpr>(
-          BaseVector::wrapInConstant(1, 0, rhsArrayVector)));
+      args.push_back(
+          std::make_shared<core::ConstantTypedExpr>(
+              BaseVector::wrapInConstant(1, 0, rhsArrayVector)));
       return exec::ExprSet(
           {std::make_shared<core::CallTypedExpr>(BOOLEAN(), args, "in")},
           &execCtx_);
diff --git a/velox/functions/sparksql/tests/MakeDecimalTest.cpp b/velox/functions/sparksql/tests/MakeDecimalTest.cpp
index 68caea881d5..ab63020938c 100644
--- a/velox/functions/sparksql/tests/MakeDecimalTest.cpp
+++ b/velox/functions/sparksql/tests/MakeDecimalTest.cpp
@@ -29,8 +29,9 @@ class MakeDecimalTest : public SparkFunctionBaseTest {
     std::vector<core::TypedExprPtr> inputs = {
         std::make_shared<core::FieldAccessTypedExpr>(BIGINT(), "c0")};
     if (nullOnOverflow.has_value()) {
-      inputs.emplace_back(std::make_shared<core::ConstantTypedExpr>(
-          BOOLEAN(), variant(nullOnOverflow.value())));
+      inputs.emplace_back(
+          std::make_shared<core::ConstantTypedExpr>(
+              BOOLEAN(), variant(nullOnOverflow.value())));
     }
     auto makeDecimal = std::make_shared<const core::CallTypedExpr>(
         outputType, std::move(inputs), "make_decimal");
diff --git a/velox/functions/sparksql/tests/MakeTimestampTest.cpp b/velox/functions/sparksql/tests/MakeTimestampTest.cpp
index 5e83dacc309..9e2409ee4bd 100644
--- a/velox/functions/sparksql/tests/MakeTimestampTest.cpp
+++ b/velox/functions/sparksql/tests/MakeTimestampTest.cpp
@@ -157,13 +157,15 @@ TEST_F(MakeTimestampTest, errors) {
        1,
        1,
        1,
+       1,
+       1,
        1});
-  const auto month = makeFlatVector<int32_t>({1, 1, 0, 13, 1, 1, 1, 1});
-  const auto day = makeFlatVector<int32_t>({1, 1, 1, 1, 0, 32, 1, 1});
-  const auto hour = makeFlatVector<int32_t>({1, 1, 1, 1, 1, 1, 25, 1});
-  const auto minute = makeFlatVector<int32_t>({1, 1, 1, 1, 1, 1, 1, 61});
+  const auto month = makeFlatVector<int32_t>({1, 1, 0, 13, 1, 1, 1, 1, 1, 1});
+  const auto day = makeFlatVector<int32_t>({1, 1, 1, 1, 0, 32, 1, 1, 1, 1});
+  const auto hour = makeFlatVector<int32_t>({1, 1, 1, 1, 1, 1, 25, 1, 24, 1});
+  const auto minute = makeFlatVector<int32_t>({1, 1, 1, 1, 1, 1, 1, 61, 1, 60});
   const auto micros =
-      makeFlatVector<int64_t>({1, 1, 1, 1, 1, 1, 1, 1}, microsType);
+      makeFlatVector<int64_t>({1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, microsType);
   auto data = makeRowVector({year, month, day, hour, minute, micros});
   testInvalidInputs(data);
 
diff --git a/velox/functions/sparksql/tests/MapFromEntriesTest.cpp b/velox/functions/sparksql/tests/MapFromEntriesTest.cpp
new file mode 100644
index 00000000000..9aa88483459
--- /dev/null
+++ b/velox/functions/sparksql/tests/MapFromEntriesTest.cpp
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <cstdint>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/ArrayConstructor.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+std::optional<std::vector<std::pair<int32_t, std::optional<int32_t>>>>
+makeOptional(
+    const std::vector<std::pair<int32_t, std::optional<int32_t>>>& vector) {
+  return std::make_optional(vector);
+}
+
+class MapFromEntriesTest : public SparkFunctionBaseTest {
+ protected:
+  // Create an MAP vector of size 1 using specified 'keys' and 'values' vector.
+  VectorPtr makeSingleRowMapVector(
+      const VectorPtr& keys,
+      const VectorPtr& values) {
+    BufferPtr offsets = allocateOffsets(1, pool());
+    BufferPtr sizes = allocateSizes(1, pool());
+    sizes->asMutable<vector_size_t>()[0] = keys->size();
+
+    return std::make_shared<MapVector>(
+        pool(),
+        MAP(keys->type(), values->type()),
+        nullptr,
+        1,
+        offsets,
+        sizes,
+        keys,
+        values);
+  }
+
+  void verifyMapFromEntries(const VectorPtr& input, const VectorPtr& expected) {
+    const std::string expr = fmt::format("map_from_entries({})", "c0");
+    auto result = evaluate(expr, makeRowVector({input}));
+    assertEqualVectors(expected, result);
+  }
+};
+} // namespace
+
+TEST_F(MapFromEntriesTest, nullMapEntries) {
+  auto rowType = ROW({INTEGER(), INTEGER()});
+  {
+    std::vector<std::vector<std::optional<std::tuple<int32_t, int32_t>>>> data =
+        {
+            {std::nullopt},
+            {{{1, 11}}},
+        };
+    auto input = makeArrayOfRowVector(data, rowType);
+    auto expected = makeNullableMapVector<int32_t, int32_t>(
+        {std::nullopt, makeOptional({{1, 11}})});
+    verifyMapFromEntries(input, expected);
+  }
+  {
+    // Create array(row(a,b)) where a, b sizes are 0 because all row(a, b)
+    // values are null.
+    std::vector<std::vector<std::optional<std::tuple<int32_t, int32_t>>>> data =
+        {
+            {std::nullopt, std::nullopt, std::nullopt},
+            {std::nullopt},
+        };
+    auto input = makeArrayOfRowVector(data, rowType);
+    auto rowInput = input->as<ArrayVector>();
+    rowInput->elements()->as<RowVector>()->childAt(0)->resize(0);
+    rowInput->elements()->as<RowVector>()->childAt(1)->resize(0);
+
+    auto expected =
+        makeNullableMapVector<int32_t, int32_t>({std::nullopt, std::nullopt});
+    verifyMapFromEntries(input, expected);
+  }
+}
+
+TEST_F(MapFromEntriesTest, nullKeys) {
+  auto rowType = ROW({INTEGER(), INTEGER()});
+  std::vector<std::vector<variant>> data = {
+      {variant::row({variant::null(TypeKind::INTEGER), 0})},
+      {variant::row({1, 11})}};
+  auto input = makeArrayOfRowVector(rowType, data);
+  VELOX_ASSERT_THROW(
+      evaluate("map_from_entries(c0)", makeRowVector({input})),
+      "map key cannot be null");
+}
+
+TEST_F(MapFromEntriesTest, arrayOfConstantRowOfNulls) {
+  RowVectorPtr rowVector =
+      makeRowVector({makeFlatVector<int32_t>(0), makeFlatVector<int32_t>(0)});
+  rowVector->resize(1);
+  rowVector->setNull(0, true);
+  rowVector->childAt(0)->resize(0);
+  rowVector->childAt(1)->resize(0);
+  EXPECT_EQ(rowVector->childAt(0)->size(), 0);
+  EXPECT_EQ(rowVector->childAt(1)->size(), 0);
+
+  VectorPtr rowVectorConstant = BaseVector::wrapInConstant(4, 0, rowVector);
+
+  auto offsets = makeIndices({0, 2});
+  auto sizes = makeIndices({2, 2});
+
+  auto arrayVector = std::make_shared<ArrayVector>(
+      pool(),
+      ARRAY(ROW({INTEGER(), INTEGER()})),
+      nullptr,
+      2,
+      offsets,
+      sizes,
+      rowVectorConstant);
+  VectorPtr result =
+      evaluate("map_from_entries(c0)", makeRowVector({arrayVector}));
+  for (int i = 0; i < result->size(); i++) {
+    EXPECT_TRUE(result->isNullAt(i));
+  }
+}
+
+TEST_F(MapFromEntriesTest, unknownInputs) {
+  facebook::velox::functions::registerArrayConstructor("array_constructor");
+  auto expectedType = MAP(UNKNOWN(), UNKNOWN());
+  auto test = [&](const std::string& query) {
+    auto result = evaluate(query, makeRowVector({makeFlatVector<int32_t>(2)}));
+    ASSERT_TRUE(result->type()->equivalent(*expectedType));
+  };
+  VELOX_ASSERT_THROW(
+      evaluate(
+          "map_from_entries(array_constructor(row_constructor(null, null)))",
+          makeRowVector({makeFlatVector<int32_t>(2)})),
+      "map key cannot be null");
+  test("map_from_entries(array_constructor(null))");
+  test("map_from_entries(null)");
+}
+
+TEST_F(MapFromEntriesTest, nullRowEntriesWithSmallerChildren) {
+  // Row vector is of size 3, childrens are of size 2 since row 2 is null.
+  auto rowVector = makeRowVector(
+      {makeNullableFlatVector<int32_t>({std::nullopt, 2}),
+       makeFlatVector<int32_t>({1, 2})});
+  rowVector->appendNulls(1);
+  rowVector->setNull(2, true);
+
+  // Array [(null,1), (2,2), null]
+  auto arrayVector = makeArrayVector({0}, rowVector);
+  VELOX_ASSERT_THROW(
+      evaluate("map_from_entries(c0)", makeRowVector({arrayVector})),
+      "map key cannot be null");
+}
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/MapTest.cpp b/velox/functions/sparksql/tests/MapTest.cpp
index ec54879e20c..f26fa8fb685 100644
--- a/velox/functions/sparksql/tests/MapTest.cpp
+++ b/velox/functions/sparksql/tests/MapTest.cpp
@@ -149,6 +149,69 @@ TEST_F(MapTest, wide) {
       mapVector);
 }
 
+TEST_F(MapTest, tenKeyValuePairs) {
+  // Test map function with 10 key-value pairs (20 arguments).
+  auto key1 = makeFlatVector<int64_t>({1, 11, 21});
+  auto val1 = makeFlatVector<std::string>({"a", "aa", "aaa"});
+  auto key2 = makeFlatVector<int64_t>({2, 12, 22});
+  auto val2 = makeFlatVector<std::string>({"b", "bb", "bbb"});
+  auto key3 = makeFlatVector<int64_t>({3, 13, 23});
+  auto val3 = makeFlatVector<std::string>({"c", "cc", "ccc"});
+  auto key4 = makeFlatVector<int64_t>({4, 14, 24});
+  auto val4 = makeFlatVector<std::string>({"d", "dd", "ddd"});
+  auto key5 = makeFlatVector<int64_t>({5, 15, 25});
+  auto val5 = makeFlatVector<std::string>({"e", "ee", "eee"});
+  auto key6 = makeFlatVector<int64_t>({6, 16, 26});
+  auto val6 = makeFlatVector<std::string>({"f", "ff", "fff"});
+  auto key7 = makeFlatVector<int64_t>({7, 17, 27});
+  auto val7 = makeFlatVector<std::string>({"g", "gg", "ggg"});
+  auto key8 = makeFlatVector<int64_t>({8, 18, 28});
+  auto val8 = makeFlatVector<std::string>({"h", "hh", "hhh"});
+  auto key9 = makeFlatVector<int64_t>({9, 19, 29});
+  auto val9 = makeFlatVector<std::string>({"i", "ii", "iii"});
+  auto key10 = makeFlatVector<int64_t>({10, 20, 30});
+  auto val10 = makeFlatVector<std::string>({"j", "jj", "jjj"});
+
+  auto expectedMap = makeMapVector<int64_t, std::string>(
+      {{{1, "a"},
+        {2, "b"},
+        {3, "c"},
+        {4, "d"},
+        {5, "e"},
+        {6, "f"},
+        {7, "g"},
+        {8, "h"},
+        {9, "i"},
+        {10, "j"}},
+       {{11, "aa"},
+        {12, "bb"},
+        {13, "cc"},
+        {14, "dd"},
+        {15, "ee"},
+        {16, "ff"},
+        {17, "gg"},
+        {18, "hh"},
+        {19, "ii"},
+        {20, "jj"}},
+       {{21, "aaa"},
+        {22, "bbb"},
+        {23, "ccc"},
+        {24, "ddd"},
+        {25, "eee"},
+        {26, "fff"},
+        {27, "ggg"},
+        {28, "hhh"},
+        {29, "iii"},
+        {30, "jjj"}}});
+
+  testMap(
+      "map(c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, "
+      "c15, c16, c17, c18, c19)",
+      {key1, val1, key2, val2, key3, val3, key4, val4, key5,  val5,
+       key6, val6, key7, val7, key8, val8, key9, val9, key10, val10},
+      expectedMap);
+}
+
 TEST_F(MapTest, errorCases) {
   auto inputVectorInt64 = makeNullableFlatVector<int64_t>({1, 2, 3});
   auto inputVectorDouble = makeNullableFlatVector<double>({4.0, 5.0, 6.0});
@@ -164,17 +227,19 @@ TEST_F(MapTest, errorCases) {
       {inputVectorInt64, inputVectorDouble, inputVectorInt64},
       "Scalar function signature is not supported: map(BIGINT, DOUBLE, BIGINT)");
 
+  // Test with 22 arguments (11 pairs) - exceeds the maximum of 10 key-value
+  // pairs supported by the map function.
   testMapFails(
-      "map(c0, c1, c2, c3, c4, c5, c6, c7)",
-      {inputVectorDouble,
-       inputVectorDouble,
-       inputVectorDouble,
-       inputVectorDouble,
-       inputVectorDouble,
-       inputVectorDouble,
-       inputVectorDouble,
+      "map(c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21)",
+      {inputVectorDouble, inputVectorDouble, inputVectorDouble,
+       inputVectorDouble, inputVectorDouble, inputVectorDouble,
+       inputVectorDouble, inputVectorDouble, inputVectorDouble,
+       inputVectorDouble, inputVectorDouble, inputVectorDouble,
+       inputVectorDouble, inputVectorDouble, inputVectorDouble,
+       inputVectorDouble, inputVectorDouble, inputVectorDouble,
+       inputVectorDouble, inputVectorDouble, inputVectorDouble,
        inputVectorDouble},
-      "Scalar function signature is not supported: map(DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE)");
+      "Scalar function signature is not supported: map(DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE)");
 
   // Types of args.
   testMapFails(
diff --git a/velox/functions/sparksql/tests/MightContainTest.cpp b/velox/functions/sparksql/tests/MightContainTest.cpp
index 21afb39e726..e9f98076d01 100644
--- a/velox/functions/sparksql/tests/MightContainTest.cpp
+++ b/velox/functions/sparksql/tests/MightContainTest.cpp
@@ -33,11 +33,13 @@ class MightContainTest : public SparkFunctionBaseTest {
     auto selected = SelectivityVector(value->size());
     std::vector<core::TypedExprPtr> args;
     if (serialized.has_value()) {
-      args.push_back(std::make_shared<core::ConstantTypedExpr>(
-          VARBINARY(), variant::binary(serialized.value())));
+      args.push_back(
+          std::make_shared<core::ConstantTypedExpr>(
+              VARBINARY(), variant::binary(serialized.value())));
     } else {
-      args.push_back(std::make_shared<core::ConstantTypedExpr>(
-          VARBINARY(), variant::null(TypeKind::VARBINARY)));
+      args.push_back(
+          std::make_shared<core::ConstantTypedExpr>(
+              VARBINARY(), variant::null(TypeKind::VARBINARY)));
     }
     args.push_back(
         std::make_shared<core::FieldAccessTypedExpr>(BIGINT(), "c0"));
diff --git a/velox/functions/sparksql/tests/RandStrTest.cpp b/velox/functions/sparksql/tests/RandStrTest.cpp
new file mode 100644
index 00000000000..7c49c8ec36c
--- /dev/null
+++ b/velox/functions/sparksql/tests/RandStrTest.cpp
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class RandStrTest : public SparkFunctionBaseTest {
+ public:
+  RandStrTest() {
+    // Allow parsing literal integers as INTEGER, not BIGINT.
+    options_.parseIntegerAsBigint = false;
+  }
+
+  std::optional<StringView>
+  randstrSeed(int32_t len, int64_t seed, int32_t partitionIdx = 0) {
+    setSparkPartitionId(partitionIdx);
+    return evaluateOnce<StringView>(
+        fmt::format("randstr({}, {})", len, seed), makeRowVector(ROW({}), 1));
+  }
+};
+
+TEST_F(RandStrTest, lengthAndCharset) {
+  auto s0 = randstrSeed(0, 42);
+  ASSERT_TRUE(s0.has_value());
+  EXPECT_EQ(s0->size(), 0);
+
+  auto s5 = randstrSeed(5, 42);
+  ASSERT_TRUE(s5.has_value());
+  EXPECT_EQ(s5->size(), 5);
+
+  // Check that all characters are from [0-9a-zA-Z].
+  auto sv = s5.value();
+  for (size_t i = 0; i < sv.size(); ++i) {
+    const char c = sv.data()[i];
+    const bool ok = (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') ||
+        (c >= 'A' && c <= 'Z');
+    EXPECT_TRUE(ok) << "Unexpected char: " << c;
+  }
+}
+
+TEST_F(RandStrTest, seededDeterminismAndPartition) {
+  auto a1 = randstrSeed(10, 1234, 0);
+  auto a2 = randstrSeed(10, 1234, 0);
+  ASSERT_TRUE(a1.has_value());
+  ASSERT_TRUE(a2.has_value());
+  // Same seed and partition -> same result.
+  EXPECT_EQ(a1.value(), a2.value());
+
+  // Different partition should change sequence.
+  auto b = randstrSeed(10, 1234, 1);
+  ASSERT_TRUE(b.has_value());
+  EXPECT_NE(a1.value(), b.value());
+}
+
+TEST_F(RandStrTest, differentSeedsProduceDifferentResults) {
+  auto r1 = randstrSeed(8, 111);
+  auto r2 = randstrSeed(8, 222);
+  auto r3 = randstrSeed(8, 333);
+  ASSERT_TRUE(r1.has_value());
+  ASSERT_TRUE(r2.has_value());
+  ASSERT_TRUE(r3.has_value());
+  // Different seeds should produce different results.
+  EXPECT_NE(r1.value(), r2.value());
+  EXPECT_NE(r1.value(), r3.value());
+  EXPECT_NE(r2.value(), r3.value());
+}
+
+TEST_F(RandStrTest, negativeLengthError) {
+  setSparkPartitionId(0);
+  VELOX_ASSERT_THROW(
+      evaluateOnce<StringView>("randstr(-1, 42)", makeRowVector(ROW({}), 1)),
+      "length must be non-negative");
+}
+
+TEST_F(RandStrTest, nonConstantSeedError) {
+  setSparkPartitionId(0);
+  // Non-constant seed should throw an error.
+  VELOX_ASSERT_THROW(
+      evaluateOnce<StringView>("randstr(5, c0)", std::optional<int32_t>(42)),
+      "seed argument must be a constant value");
+}
+
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/SequenceTest.cpp b/velox/functions/sparksql/tests/SequenceTest.cpp
new file mode 100644
index 00000000000..6512681dcec
--- /dev/null
+++ b/velox/functions/sparksql/tests/SequenceTest.cpp
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <optional>
+
+#include <gtest/gtest.h>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::functions::test;
+
+namespace facebook::velox::functions::sparksql::test {
+using namespace facebook::velox::test;
+
+class SequenceTest : public SparkFunctionBaseTest {};
+
+TEST_F(SequenceTest, ascending) {
+  auto result = evaluate(
+      "sequence(c0, c1)",
+      makeRowVector({
+          makeFlatVector<int64_t>({1, 3}),
+          makeFlatVector<int64_t>({5, 6}),
+      }));
+  auto expected = makeArrayVector<int64_t>({{1, 2, 3, 4, 5}, {3, 4, 5, 6}});
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(SequenceTest, descending) {
+  auto result = evaluate(
+      "sequence(c0, c1)",
+      makeRowVector({
+          makeFlatVector<int64_t>({5}),
+          makeFlatVector<int64_t>({1}),
+      }));
+  auto expected = makeArrayVector<int64_t>({{5, 4, 3, 2, 1}});
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(SequenceTest, withStep) {
+  auto result = evaluate(
+      "sequence(c0, c1, c2)",
+      makeRowVector({
+          makeFlatVector<int64_t>({1, 5}),
+          makeFlatVector<int64_t>({10, 1}),
+          makeFlatVector<int64_t>({3, -2}),
+      }));
+  auto expected = makeArrayVector<int64_t>({{1, 4, 7, 10}, {5, 3, 1}});
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(SequenceTest, singleElement) {
+  auto result = evaluate(
+      "sequence(c0, c1)",
+      makeRowVector({
+          makeFlatVector<int64_t>({5}),
+          makeFlatVector<int64_t>({5}),
+      }));
+  auto expected = makeArrayVector<int64_t>({{5}});
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(SequenceTest, integerType) {
+  auto result = evaluate(
+      "sequence(c0, c1)",
+      makeRowVector({
+          makeFlatVector<int32_t>({1, 5}),
+          makeFlatVector<int32_t>({5, 1}),
+      }));
+  auto expected = makeArrayVector<int32_t>({{1, 2, 3, 4, 5}, {5, 4, 3, 2, 1}});
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(SequenceTest, integerWithStep) {
+  auto result = evaluate(
+      "sequence(c0, c1, c2)",
+      makeRowVector({
+          makeFlatVector<int32_t>({1}),
+          makeFlatVector<int32_t>({9}),
+          makeFlatVector<int32_t>({2}),
+      }));
+  auto expected = makeArrayVector<int32_t>({{1, 3, 5, 7, 9}});
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(SequenceTest, smallintType) {
+  auto result = evaluate(
+      "sequence(c0, c1)",
+      makeRowVector({
+          makeFlatVector<int16_t>({1, 5}),
+          makeFlatVector<int16_t>({5, 1}),
+      }));
+  auto expected = makeArrayVector<int16_t>({{1, 2, 3, 4, 5}, {5, 4, 3, 2, 1}});
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(SequenceTest, tinyintType) {
+  auto result = evaluate(
+      "sequence(c0, c1)",
+      makeRowVector({
+          makeFlatVector<int8_t>({1, 5}),
+          makeFlatVector<int8_t>({5, 1}),
+      }));
+  auto expected = makeArrayVector<int8_t>({{1, 2, 3, 4, 5}, {5, 4, 3, 2, 1}});
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(SequenceTest, nullInputs) {
+  auto start = makeNullableFlatVector<int64_t>({std::nullopt, 1, 1});
+  auto stop = makeNullableFlatVector<int64_t>({5, std::nullopt, 3});
+  auto result = evaluate("sequence(c0, c1)", makeRowVector({start, stop}));
+
+  auto expected = makeNullableArrayVector<int64_t>(
+      {std::nullopt,
+       std::nullopt,
+       std::optional<std::vector<std::optional<int64_t>>>({{1, 2, 3}})});
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(SequenceTest, nullStep) {
+  auto start = makeNullableFlatVector<int64_t>({1});
+  auto stop = makeNullableFlatVector<int64_t>({5});
+  auto step = makeNullableFlatVector<int64_t>({std::nullopt});
+  auto result =
+      evaluate("sequence(c0, c1, c2)", makeRowVector({start, stop, step}));
+
+  auto expected = makeNullableArrayVector<int64_t>(
+      {std::optional<std::vector<std::optional<int64_t>>>(std::nullopt)});
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(SequenceTest, stepZeroError) {
+  VELOX_ASSERT_THROW(
+      evaluate(
+          "sequence(c0, c1, c2)",
+          makeRowVector({
+              makeFlatVector<int64_t>({1}),
+              makeFlatVector<int64_t>({5}),
+              makeFlatVector<int64_t>({0}),
+          })),
+      "step must not be zero");
+}
+
+TEST_F(SequenceTest, wrongDirectionError) {
+  VELOX_ASSERT_THROW(
+      evaluate(
+          "sequence(c0, c1, c2)",
+          makeRowVector({
+              makeFlatVector<int64_t>({1}),
+              makeFlatVector<int64_t>({5}),
+              makeFlatVector<int64_t>({-1}),
+          })),
+      "sequence stop value should be greater than or equal to start value if "
+      "step is greater than zero otherwise stop should be less than or equal "
+      "to start");
+}
+
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/SortArrayTest.cpp b/velox/functions/sparksql/tests/SortArrayTest.cpp
index fa0449a37f9..c205a56e65a 100644
--- a/velox/functions/sparksql/tests/SortArrayTest.cpp
+++ b/velox/functions/sparksql/tests/SortArrayTest.cpp
@@ -18,6 +18,7 @@
 #include <limits>
 #include <optional>
 
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/functions/sparksql/registration/Register.h"
 #include "velox/functions/sparksql/tests/ArraySortTestData.h"
@@ -153,13 +154,16 @@ TEST_F(SortArrayTest, array) {
       makeNullableNestedArrayVector(reverseNested(expected)));
 }
 
-TEST_F(SortArrayTest, map) {
+// Map is not orderable, so sorting is not supported.
+TEST_F(SortArrayTest, failOnMapTypeSort) {
   auto input = makeArrayOfMapVector(mapInput());
-  auto expected = mapAscNullSmallest();
-  testSortArray(
-      input,
-      makeArrayOfMapVector(expected),
-      makeArrayOfMapVector(reverseNested(expected)));
+  const std::string kErrorMessage =
+      "Scalar function signature is not supported";
+
+  VELOX_ASSERT_THROW(
+      evaluate("sort_array(c0)", makeRowVector({input})), kErrorMessage);
+  VELOX_ASSERT_THROW(
+      evaluate("sort_array(c0, true)", makeRowVector({input})), kErrorMessage);
 }
 
 TEST_F(SortArrayTest, row) {
diff --git a/velox/functions/sparksql/tests/SparkCastExprTest.cpp b/velox/functions/sparksql/tests/SparkCastExprTest.cpp
index d92d4fdd273..008ac8e615e 100644
--- a/velox/functions/sparksql/tests/SparkCastExprTest.cpp
+++ b/velox/functions/sparksql/tests/SparkCastExprTest.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "velox/core/QueryConfig.h"
 #include "velox/functions/prestosql/tests/CastBaseTest.h"
 #include "velox/functions/sparksql/registration/Register.h"
 #include "velox/parse/TypeResolver.h"
@@ -30,6 +31,182 @@ class SparkCastExprTest : public functions::test::CastBaseTest {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   }
 
+  void setAnsiSupport(bool value) {
+    queryCtx_->testingOverrideConfigUnsafe(
+        {{core::QueryConfig::kSparkAnsiEnabled, std::to_string(value)}});
+  }
+
+  void testBoolToTimestamp() {
+    testCast(
+        makeFlatVector<bool>({true, false}),
+        makeFlatVector<Timestamp>({
+            Timestamp(0, 1000),
+            Timestamp(0, 0),
+        }));
+  }
+
+  template <typename T>
+  void testIntegralToTimestampCast() {
+    testCast(
+        makeNullableFlatVector<T>({
+            0,
+            1,
+            std::numeric_limits<T>::max(),
+            std::numeric_limits<T>::min(),
+            std::nullopt,
+        }),
+        makeNullableFlatVector<Timestamp>(
+            {Timestamp(0, 0),
+             Timestamp(1, 0),
+             Timestamp(std::numeric_limits<T>::max(), 0),
+             Timestamp(std::numeric_limits<T>::min(), 0),
+             std::nullopt}));
+  }
+
+  void testIntToTimestamp() {
+    // Cast bigint as timestamp.
+    testCast(
+        makeNullableFlatVector<int64_t>({
+            0,
+            1727181032,
+            -1727181032,
+            9223372036855,
+            -9223372036856,
+            std::numeric_limits<int64_t>::max(),
+            std::numeric_limits<int64_t>::min(),
+        }),
+        makeNullableFlatVector<Timestamp>({
+            Timestamp(0, 0),
+            Timestamp(1727181032, 0),
+            Timestamp(-1727181032, 0),
+            Timestamp(9223372036854, 775'807'000),
+            Timestamp(-9223372036855, 224'192'000),
+            Timestamp(9223372036854, 775'807'000),
+            Timestamp(-9223372036855, 224'192'000),
+        }));
+
+    // Cast tinyint/smallint/integer as timestamp.
+    testIntegralToTimestampCast<int8_t>();
+    testIntegralToTimestampCast<int16_t>();
+    testIntegralToTimestampCast<int32_t>();
+  }
+
+  void testTinyIntToBinary() {
+    testCast<int8_t, std::string>(
+        TINYINT(),
+        VARBINARY(),
+        {18,
+         -26,
+         0,
+         110,
+         std::numeric_limits<int8_t>::max(),
+         std::numeric_limits<int8_t>::min()},
+        {std::string("\x12", 1),
+         std::string("\xE6", 1),
+         std::string("\0", 1),
+         std::string("\x6E", 1),
+         std::string("\x7F", 1),
+         std::string("\x80", 1)});
+  }
+
+  void testSmallintToBinary() {
+    testCast<int16_t, std::string>(
+        SMALLINT(),
+        VARBINARY(),
+        {180,
+         -199,
+         0,
+         12300,
+         std::numeric_limits<int16_t>::max(),
+         std::numeric_limits<int16_t>::min()},
+        {std::string("\0\xB4", 2),
+         std::string("\xFF\x39", 2),
+         std::string("\0\0", 2),
+         std::string("\x30\x0C", 2),
+         std::string("\x7F\xFF", 2),
+         std::string("\x80\00", 2)});
+  }
+
+  void testIntegerToBinary() {
+    testCast<int32_t, std::string>(
+        INTEGER(),
+        VARBINARY(),
+        {18,
+         -26,
+         0,
+         180000,
+         std::numeric_limits<int32_t>::max(),
+         std::numeric_limits<int32_t>::min()},
+        {std::string("\0\0\0\x12", 4),
+         std::string("\xFF\xFF\xFF\xE6", 4),
+         std::string("\0\0\0\0", 4),
+         std::string("\0\x02\xBF\x20", 4),
+         std::string("\x7F\xFF\xFF\xFF", 4),
+         std::string("\x80\0\0\0", 4)});
+  }
+
+  void testBigIntToBinary() {
+    testCast<int64_t, std::string>(
+        BIGINT(),
+        VARBINARY(),
+        {123456,
+         -256789,
+         0,
+         180000,
+         std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::min()},
+        {std::string("\0\0\0\0\0\x01\xE2\x40", 8),
+         std::string("\xFF\xFF\xFF\xFF\xFF\xFC\x14\xEB", 8),
+         std::string("\0\0\0\0\0\0\0\0", 8),
+         std::string("\0\0\0\0\0\x02\xBF\x20", 8),
+         std::string("\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 8),
+         std::string("\x80\x00\x00\x00\x00\x00\x00\x00", 8)});
+  }
+
+  void testFloatToTimestamp() {
+    testCast(
+        makeFlatVector<float>({
+            0.0,
+            1727181032.0,
+            -1727181032.0,
+            std::numeric_limits<float>::max(),
+            std::numeric_limits<float>::min(),
+        }),
+        makeNullableFlatVector<Timestamp>({
+            Timestamp(0, 0),
+            Timestamp(1727181056, 0),
+            Timestamp(-1727181056, 0),
+            Timestamp(9223372036854, 775'807'000),
+            Timestamp(0, 0),
+        }));
+  }
+
+  void testDoubleToTimestamp() {
+    testCast(
+        makeFlatVector<double>({
+            0.0,
+            1727181032.0,
+            -1727181032.0,
+            9223372036855.999,
+            -9223372036856.999,
+            1.79769e+308,
+            std::numeric_limits<double>::max(),
+            -std::numeric_limits<double>::max(),
+            std::numeric_limits<double>::min(),
+        }),
+        makeNullableFlatVector<Timestamp>({
+            Timestamp(0, 0),
+            Timestamp(1727181032, 0),
+            Timestamp(-1727181032, 0),
+            Timestamp(9223372036854, 775'807'000),
+            Timestamp(-9223372036855, 224'192'000),
+            Timestamp(9223372036854, 775'807'000),
+            Timestamp(9223372036854, 775'807'000),
+            Timestamp(-9223372036855, 224'192'000),
+            Timestamp(0, 0),
+        }));
+  }
+
   template <typename T>
   void testDecimalToIntegralCasts() {
     auto shortFlat = makeNullableFlatVector<int64_t>(
@@ -92,21 +269,97 @@ class SparkCastExprTest : public functions::test::CastBaseTest {
              std::nullopt}));
   }
 
-  template <typename T>
-  void testIntegralToTimestampCast() {
+  void testDecimalToIntegral() {
+    testDecimalToIntegralCasts<int64_t>();
+    testDecimalToIntegralCasts<int32_t>();
+    testDecimalToIntegralCasts<int16_t>();
+    testDecimalToIntegralCasts<int8_t>();
+  }
+
+  void testDecimalToString() {
     testCast(
-        makeNullableFlatVector<T>({
-            0,
-            1,
-            std::numeric_limits<T>::max(),
-            std::numeric_limits<T>::min(),
-            std::nullopt,
-        }),
-        makeNullableFlatVector<Timestamp>(
-            {Timestamp(0, 0),
-             Timestamp(1, 0),
-             Timestamp(std::numeric_limits<T>::max(), 0),
-             Timestamp(std::numeric_limits<T>::min(), 0),
+        makeFlatVector<int64_t>(
+            {100, 1230, 12345, 0, -100, -1230, -12345}, DECIMAL(10, 2)),
+        makeFlatVector<std::string>(
+            {"1.00", "12.30", "123.45", "0.00", "-1.00", "-12.30", "-123.45"}));
+
+    testCast(
+        makeFlatVector<int64_t>(
+            {100000, 123000, 123450, 0, -100000, -123000, -123450},
+            DECIMAL(10, 3)),
+        makeFlatVector<std::string>(
+            {"100.000",
+             "123.000",
+             "123.450",
+             "0.000",
+             "-100.000",
+             "-123.000",
+             "-123.450"}));
+
+    testCast(
+        makeFlatVector<int128_t>(
+            {HugeInt::build(0, 10000000000),
+             HugeInt::build(0, 12300000000),
+             HugeInt::build(0, 12345000000),
+             HugeInt::build(0, 0),
+             HugeInt::build(0, 55),
+             HugeInt::build(0, 1),
+             -HugeInt::build(0, 3),
+             -HugeInt::build(0, 10000000000),
+             -HugeInt::build(0, 12300000000),
+             -HugeInt::build(0, 12345000000)},
+            DECIMAL(20, 10)),
+        makeFlatVector<std::string>(
+            {"1.0000000000",
+             "1.2300000000",
+             "1.2345000000",
+             "0E-10",
+             "5.5E-9",
+             "1E-10",
+             "-3E-10",
+             "-1.0000000000",
+             "-1.2300000000",
+             "-1.2345000000"}));
+
+    testCast(
+        makeFlatVector<int64_t>({100, 200, 300}, DECIMAL(10, 0)),
+        makeFlatVector<std::string>({"100", "200", "300"}));
+
+    testCast(
+        makeFlatVector<int64_t>(
+            {0, 12, 55, 120, 1200, -3, -12, -120}, DECIMAL(10, 8)),
+        makeFlatVector<std::string>(
+            {"0E-8",
+             "1.2E-7",
+             "5.5E-7",
+             "0.00000120",
+             "0.00001200",
+             "-3E-8",
+             "-1.2E-7",
+             "-0.00000120"}));
+
+    testCast(
+        makeNullableFlatVector<int64_t>(
+            {100, std::nullopt, 1230, std::nullopt}, DECIMAL(10, 2)),
+        makeNullableFlatVector<std::string>(
+            {"1.00", std::nullopt, "12.30", std::nullopt}));
+
+    // Keep one non-scientific long-decimal baseline for larger magnitudes.
+    testCast(
+        makeNullableFlatVector<int128_t>(
+            {DecimalUtil::kLongDecimalMin,
+             0,
+             DecimalUtil::kLongDecimalMax,
+             HugeInt::build(0xFFFFFFFFFFFFFFFFull, 0xFFFFFFFFFFFFFFFFull),
+             HugeInt::build(0xffff, 0xffffffffffffffff),
+             std::nullopt},
+            DECIMAL(38, 5)),
+        makeNullableFlatVector<std::string>(
+            {"-999999999999999999999999999999999.99999",
+             "0.00000",
+             "999999999999999999999999999999999.99999",
+             "-0.00001",
+             "12089258196146291747.06175",
              std::nullopt}));
   }
 
@@ -138,226 +391,963 @@ class SparkCastExprTest : public functions::test::CastBaseTest {
         }),
         makeFlatVector<T>(expected));
   }
+
+  void testTimestampToInt() {
+    // Cast timestamp as bigint.
+    testCast(
+        makeFlatVector<Timestamp>({
+            Timestamp(0, 0),
+            Timestamp(1, 0),
+            Timestamp(10, 0),
+            Timestamp(-1, 0),
+            Timestamp(-10, 0),
+            Timestamp(-1, 500000),
+            Timestamp(-2, 999999),
+            Timestamp(-10, 999999),
+            Timestamp(1, 999999),
+            Timestamp(-1, 1),
+            Timestamp(1234567, 500000),
+            Timestamp(-9876543, 1234),
+            Timestamp(1727181032, 0),
+            Timestamp(-1727181032, 0),
+            Timestamp(9223372036854, 775'807'000),
+            Timestamp(-9223372036855, 224'192'000),
+        }),
+        makeNullableFlatVector<int64_t>({
+            0,
+            1,
+            10,
+            -1,
+            -10,
+            -1,
+            -2,
+            -10,
+            1,
+            -1,
+            1234567,
+            -9876543,
+            1727181032,
+            -1727181032,
+            9223372036854,
+            -9223372036855,
+        }));
+
+    // Cast timestamp as tinyint/smallint/integer.
+    testTimestampToIntegralCast<int8_t>();
+    testTimestampToIntegralCast<int16_t>();
+    testTimestampToIntegralCast<int32_t>();
+  }
+
+  void testTimestampToString() {
+    testCast<Timestamp, std::string>(
+        "string",
+        {
+            Timestamp(-946684800, 0),
+            Timestamp(-7266, 0),
+            Timestamp(0, 0),
+            Timestamp(946684800, 0),
+            Timestamp(9466848000, 0),
+            Timestamp(94668480000, 0),
+            Timestamp(946729316, 0),
+            Timestamp(946729316, 123),
+            Timestamp(946729316, 100000000),
+            Timestamp(946729316, 129900000),
+            Timestamp(946729316, 123456789),
+            Timestamp(7266, 0),
+            Timestamp(-50049331200, 0),
+            Timestamp(253405036800, 0),
+            Timestamp(-62480037600, 0),
+            std::nullopt,
+        },
+        {
+            "1940-01-02 00:00:00",
+            "1969-12-31 21:58:54",
+            "1970-01-01 00:00:00",
+            "2000-01-01 00:00:00",
+            "2269-12-29 00:00:00",
+            "4969-12-04 00:00:00",
+            "2000-01-01 12:21:56",
+            "2000-01-01 12:21:56",
+            "2000-01-01 12:21:56.1",
+            "2000-01-01 12:21:56.1299",
+            "2000-01-01 12:21:56.123456",
+            "1970-01-01 02:01:06",
+            "0384-01-01 08:00:00",
+            "+10000-02-01 16:00:00",
+            "-0010-02-01 10:00:00",
+            std::nullopt,
+        });
+
+    std::vector<std::optional<Timestamp>> input = {
+        Timestamp(-946684800, 0),
+        Timestamp(-7266, 0),
+        Timestamp(0, 0),
+        Timestamp(61, 10),
+        Timestamp(3600, 0),
+        Timestamp(946684800, 0),
+
+        Timestamp(946729316, 0),
+        Timestamp(946729316, 123),
+        Timestamp(946729316, 100000000),
+        Timestamp(946729316, 129900000),
+        Timestamp(946729316, 123456789),
+        Timestamp(7266, 0),
+        std::nullopt,
+    };
+
+    setTimezone("America/Los_Angeles");
+    testCast<Timestamp, std::string>(
+        "string",
+        input,
+        {
+            "1940-01-01 16:00:00",
+            "1969-12-31 13:58:54",
+            "1969-12-31 16:00:00",
+            "1969-12-31 16:01:01",
+            "1969-12-31 17:00:00",
+            "1999-12-31 16:00:00",
+            "2000-01-01 04:21:56",
+            "2000-01-01 04:21:56",
+            "2000-01-01 04:21:56.1",
+            "2000-01-01 04:21:56.1299",
+            "2000-01-01 04:21:56.123456",
+            "1969-12-31 18:01:06",
+            std::nullopt,
+        });
+    setTimezone("Asia/Shanghai");
+    testCast<Timestamp, std::string>(
+        "string",
+        input,
+        {
+            "1940-01-02 08:00:00",
+            "1970-01-01 05:58:54",
+            "1970-01-01 08:00:00",
+            "1970-01-01 08:01:01",
+            "1970-01-01 09:00:00",
+            "2000-01-01 08:00:00",
+            "2000-01-01 20:21:56",
+            "2000-01-01 20:21:56",
+            "2000-01-01 20:21:56.1",
+            "2000-01-01 20:21:56.1299",
+            "2000-01-01 20:21:56.123456",
+            "1970-01-01 10:01:06",
+            std::nullopt,
+        });
+  }
+
+  void testInvalidDate() {
+    testInvalidCast<int8_t>(
+        "date", {12}, "Cast from TINYINT to DATE is not supported", TINYINT());
+    testInvalidCast<int16_t>(
+        "date",
+        {1234},
+        "Cast from SMALLINT to DATE is not supported",
+        SMALLINT());
+    testInvalidCast<int32_t>(
+        "date",
+        {1234},
+        "Cast from INTEGER to DATE is not supported",
+        INTEGER());
+    testInvalidCast<int64_t>(
+        "date", {1234}, "Cast from BIGINT to DATE is not supported", BIGINT());
+
+    testInvalidCast<float>(
+        "date", {12.99}, "Cast from REAL to DATE is not supported", REAL());
+    testInvalidCast<double>(
+        "date", {12.99}, "Cast from DOUBLE to DATE is not supported", DOUBLE());
+  }
+
+  void testStringToBoolean() {
+    // Valid strings for true (case-insensitive): t, true, y, yes, 1.
+    testCast<std::string, bool>(
+        "boolean",
+        {"t", "T", "true", "TRUE", "TrUe", "y", "Y", "yes", "YES", "YeS", "1"},
+        {true, true, true, true, true, true, true, true, true, true, true});
+
+    // Valid strings for false (case-insensitive): f, false, n, no, 0.
+    testCast<std::string, bool>(
+        "boolean",
+        {"f", "F", "false", "FALSE", "FaLsE", "n", "N", "no", "NO", "nO", "0"},
+        {false,
+         false,
+         false,
+         false,
+         false,
+         false,
+         false,
+         false,
+         false,
+         false,
+         false});
+
+    // Whitespace should be trimmed.
+    testCast<std::string, bool>(
+        "boolean",
+        {" true", "false ", " 1 ", "  yes  ", "  no  "},
+        {true, false, true, true, false});
+
+    // NULL values should remain NULL.
+    testCast<std::string, bool>(
+        "boolean",
+        {"true", std::nullopt, "false", std::nullopt},
+        {true, std::nullopt, false, std::nullopt});
+  }
+
+  void testStringToTimestamp() {
+    std::vector<std::optional<std::string>> input{
+        "1970-01-01",
+        "1970-01-01 00:00:00-02:00",
+        "1970-01-01 00:00:00 +02:00",
+        "2000-01-01",
+        "1970-01-01 00:00:00",
+        "2000-01-01 12:21:56",
+        std::nullopt,
+        "2015-03-18T12:03:17",
+        "2015-03-18T12:03:17Z",
+        "2015-03-18 12:03:17",
+        "2015-03-18T12:03:17",
+        "2015-03-18 12:03:17.123",
+        "2015-03-18T12:03:17.123",
+        "2015-03-18T12:03:17.456",
+        "2015-03-18 12:03:17.456",
+    };
+    std::vector<std::optional<Timestamp>> expected{
+        Timestamp(0, 0),
+        Timestamp(7200, 0),
+        Timestamp(-7200, 0),
+        Timestamp(946684800, 0),
+        Timestamp(0, 0),
+        Timestamp(946729316, 0),
+        std::nullopt,
+        Timestamp(1426680197, 0),
+        Timestamp(1426680197, 0),
+        Timestamp(1426680197, 0),
+        Timestamp(1426680197, 0),
+        Timestamp(1426680197, 123000000),
+        Timestamp(1426680197, 123000000),
+        Timestamp(1426680197, 456000000),
+        Timestamp(1426680197, 456000000),
+    };
+    testCast<std::string, Timestamp>("timestamp", input, expected);
+
+    setTimezone("Asia/Shanghai");
+    testCast<std::string, Timestamp>(
+        "timestamp",
+        {"1970-01-01 00:00:00",
+         "1970-01-01 08:00:00",
+         "1970-01-01 08:00:59",
+         "1970"},
+        {Timestamp(-8 * 3600, 0),
+         Timestamp(0, 0),
+         Timestamp(59, 0),
+         Timestamp(-8 * 3600, 0)});
+  }
+
+  void testStringToDate() {
+    testCast<std::string, int32_t>(
+        "date",
+        {"1970-01-01",
+         "2020-01-01",
+         "2135-11-09",
+         "1969-12-27",
+         "1812-04-15",
+         "1920-01-02",
+         "12345-12-18",
+         "1970-1-2",
+         "1970-01-2",
+         "1970-1-02",
+         "+1970-01-02",
+         " 1970-01-01",
+         std::nullopt},
+        {0,
+         18262,
+         60577,
+         -5,
+         -57604,
+         -18262,
+         3789742,
+         1,
+         1,
+         1,
+         1,
+         0,
+         std::nullopt},
+        VARCHAR(),
+        DATE());
+    testCast<std::string, int32_t>(
+        "date",
+        {"12345",
+         "2015",
+         "2015-03",
+         "2015-03-18T",
+         "2015-03-18T123123",
+         "2015-03-18 123142",
+         "2015-03-18 (BC)"},
+        {3789391, 16436, 16495, 16512, 16512, 16512, 16512},
+        VARCHAR(),
+        DATE());
+  }
+
+  void testFromString() {
+    // String with leading and trailing whitespaces.
+    testCast<std::string, int8_t>(
+        "tinyint", {"\n\f\r\t\n\u001F 123\u000B\u001C\u001D\u001E"}, {123});
+    testCast<std::string, int32_t>(
+        "integer", {"\n\f\r\t\n\u001F 123\u000B\u001C\u001D\u001E"}, {123});
+    testCast<std::string, int64_t>(
+        "bigint", {"\n\f\r\t\n\u001F 123\u000B\u001C\u001D\u001E"}, {123});
+    testCast<std::string, int32_t>(
+        "date",
+        {"\n\f\r\t\n\u001F 2015-03-18T\u000B\u001C\u001D\u001E"},
+        {16512},
+        VARCHAR(),
+        DATE());
+    testCast<std::string, float>(
+        "real", {"\n\f\r\t\n\u001F 123.0\u000B\u001C\u001D\u001E"}, {123.0});
+    testCast<std::string, double>(
+        "double", {"\n\f\r\t\n\u001F 123.0\u000B\u001C\u001D\u001E"}, {123.0});
+    testCast<std::string, Timestamp>(
+        "timestamp",
+        {"\n\f\r\t\n\u001F 2000-01-01 12:21:56\u000B\u001C\u001D\u001E"},
+        {Timestamp(946729316, 0)});
+    testCast(
+        makeFlatVector<StringView>(
+            {" 9999999999.99",
+             "9999999999.99 ",
+             "\n\f\r\t\n\u001F 9999999999.99\u000B\u001C\u001D\u001E",
+             " -3E+2",
+             "-3E+2 ",
+             "\u000B\u001C\u001D-3E+2\u001E\n\f\r\t\n\u001F "}),
+        makeFlatVector<int64_t>(
+            {999'999'999'999,
+             999'999'999'999,
+             999'999'999'999,
+             -30000,
+             -30000,
+             -30000},
+            DECIMAL(12, 2)));
+  }
+
+  void testPrimitiveValidCornerCases() {
+    // To integer.
+    {
+      // Valid strings.
+      testCast<std::string, int8_t>("tinyint", {"+1"}, {1});
+      testCast<std::string, int8_t>("tinyint", {"-1"}, {-1});
+
+      testCast<double, int8_t>("tinyint", {127.1}, {127});
+
+      testCast<double, int64_t>("bigint", {12345.12}, {12345});
+      testCast<double, int64_t>("bigint", {12345.67}, {12345});
+    }
+
+    // To floating-point.
+    {
+      testCast<std::string, float>("real", {"1."}, {1.0});
+      testCast<std::string, float>("real", {"1"}, {1});
+      testCast<std::string, float>("real", {"infinity"}, {kInf});
+      testCast<std::string, float>("real", {"-infinity"}, {-kInf});
+      testCast<std::string, float>("real", {"nan"}, {kNan});
+      testCast<std::string, float>("real", {"InfiNiTy"}, {kInf});
+      testCast<std::string, float>("real", {"-InfiNiTy"}, {-kInf});
+      testCast<std::string, float>("real", {"nAn"}, {kNan});
+    }
+
+    // To boolean.
+    {
+      testCast<int8_t, bool>("boolean", {1}, {true});
+      testCast<int8_t, bool>("boolean", {0}, {false});
+      testCast<int8_t, bool>("boolean", {12}, {true});
+      testCast<int8_t, bool>("boolean", {-1}, {true});
+
+      testCast<std::string, bool>("boolean", {"1"}, {true});
+      testCast<std::string, bool>("boolean", {"t"}, {true});
+      testCast<std::string, bool>("boolean", {"y"}, {true});
+      testCast<std::string, bool>("boolean", {"yes"}, {true});
+      testCast<std::string, bool>("boolean", {"true"}, {true});
+
+      testCast<std::string, bool>("boolean", {"0"}, {false});
+      testCast<std::string, bool>("boolean", {"f"}, {false});
+      testCast<std::string, bool>("boolean", {"n"}, {false});
+      testCast<std::string, bool>("boolean", {"no"}, {false});
+      testCast<std::string, bool>("boolean", {"false"}, {false});
+
+      testCast<std::string, bool>(
+          "boolean",
+          {"t",
+           "T",
+           "true",
+           "TRUE",
+           "TrUe",
+           "y",
+           "Y",
+           "yes",
+           "YES",
+           "YeS",
+           "1"},
+          {true, true, true, true, true, true, true, true, true, true, true});
+
+      testCast<std::string, bool>(
+          "boolean",
+          {"f",
+           "F",
+           "false",
+           "FALSE",
+           "FaLsE",
+           "n",
+           "N",
+           "no",
+           "NO",
+           "nO",
+           "0"},
+          {false,
+           false,
+           false,
+           false,
+           false,
+           false,
+           false,
+           false,
+           false,
+           false,
+           false});
+
+      testCast<std::string, bool>(
+          "boolean",
+          {" true", "false ", " 1 ", "  yes  ", "  no  "},
+          {true, false, true, true, false});
+
+      testCast<std::string, bool>(
+          "boolean",
+          {"true", std::nullopt, "false", std::nullopt},
+          {true, std::nullopt, false, std::nullopt});
+    }
+
+    // To string.
+    {
+      testCast<float, std::string>("varchar", {kInf}, {"Infinity"});
+      testCast<float, std::string>("varchar", {kNan}, {"NaN"});
+    }
+  }
+
+  void testTruncate() {
+    testCast<Timestamp, int32_t>("integer", {Timestamp(17, 500'000'000)}, {17});
+
+    testCast<Timestamp, int32_t>("integer", {Timestamp(17, 1'000)}, {17});
+
+    testCast<Timestamp, int32_t>("integer", {Timestamp(17, 999'999'000)}, {17});
+
+    testCast<Timestamp, int32_t>("integer", {Timestamp(17, 600'000'000)}, {17});
+
+    testCast<Timestamp, int32_t>("integer", {Timestamp(17, 400'000'000)}, {17});
+
+    testCast<Timestamp, int32_t>("integer", {Timestamp(17, 555'000'000)}, {17});
+
+    testCast<Timestamp, int32_t>("integer", {Timestamp(12 * 3600, 0)}, {43200});
+    testCast<Timestamp, int32_t>(
+        "integer", {Timestamp(12 * 3600, 120'000'000)}, {43200});
+
+    testCast<Timestamp, int32_t>(
+        "integer", {Timestamp(12 * 3600, 345'600'000)}, {43200});
+
+    testCast<Timestamp, int32_t>(
+        "integer", {Timestamp(1 * 3600 + 2 * 60 + 3, 555'550'000)}, {3723});
+
+    testCast<Timestamp, int64_t>(
+        "bigint", {Timestamp(1 * 3600 + 2 * 60 + 3, 555'550'000)}, {3723L});
+
+    testCast<Timestamp, int32_t>(
+        "integer", {Timestamp(23 * 3600 + 59 * 60 + 59, 999'900'000)}, {86399});
+
+    testCast<Timestamp, int64_t>(
+        "bigint", {Timestamp(23 * 3600 + 59 * 60 + 59, 999'900'000)}, {86399L});
+  }
+
+  void testTryCasts() {
+    testTryCast<std::string, int8_t>(
+        "tinyint",
+        {"-",
+         "-0",
+         " @w 123",
+         "123 ",
+         "  122",
+         "",
+         "-12-3",
+         "1234",
+         "-129",
+         "1.1.1",
+         "1..",
+         "1.abc",
+         "..",
+         "-..",
+         "125.5",
+         "127",
+         "-128",
+         "1.2"},
+        {std::nullopt,
+         0,
+         std::nullopt,
+         123,
+         122,
+         std::nullopt,
+         std::nullopt,
+         std::nullopt,
+         std::nullopt,
+         std::nullopt,
+         std::nullopt,
+         std::nullopt,
+         std::nullopt,
+         std::nullopt,
+         std::nullopt,
+         127,
+         -128,
+         std::nullopt});
+
+    testTryCast<double, int32_t>(
+        "integer",
+        {1e12, 2.5, 3.6, 100.44, -100.101},
+        {std::nullopt, 2, 3, 100, -100});
+    testTryCast<int64_t, int8_t>("tinyint", {456}, {std::nullopt});
+    testTryCast<int64_t, int16_t>("smallint", {1234567}, {std::nullopt});
+    testTryCast<int64_t, int32_t>("integer", {2147483649}, {std::nullopt});
+
+    testTryCast<std::string, int16_t>("smallint", {"52769"}, {std::nullopt});
+    testTryCast<std::string, int32_t>(
+        "integer", {"17515055537"}, {std::nullopt});
+    testTryCast<std::string, int32_t>(
+        "integer", {"-17515055537"}, {std::nullopt});
+    testTryCast<std::string, int64_t>(
+        "bigint", {"9663372036854775809"}, {std::nullopt});
+    testTryCast<int64_t, int8_t>(
+        "tinyint", {456}, {std::nullopt}, DECIMAL(6, 0));
+  }
+
+  void testOverflow() {
+    testCast<int16_t, int8_t>("tinyint", {456}, {-56});
+    testCast<int32_t, int8_t>("tinyint", {266}, {10});
+    testCast<int64_t, int8_t>("tinyint", {1234}, {-46});
+    testCast<int64_t, int16_t>("smallint", {1234567}, {-10617});
+    testCast<double, int8_t>("tinyint", {127.8}, {127});
+    testCast<double, int8_t>("tinyint", {129.9}, {-127});
+    testCast<double, int16_t>("smallint", {1234567.89}, {-10617});
+    testCast<double, int64_t>(
+        "bigint", {std::numeric_limits<double>::max()}, {9223372036854775807});
+    testCast<double, int64_t>(
+        "bigint", {std::numeric_limits<double>::quiet_NaN()}, {0});
+    auto shortFlat = makeNullableFlatVector<int64_t>(
+        {-3000,
+         -2600,
+         -2300,
+         -2000,
+         -1000,
+         0,
+         55000,
+         57490,
+         5755,
+         6900,
+         7200,
+         std::nullopt},
+        DECIMAL(5, 1));
+    testCast(
+        shortFlat,
+        makeNullableFlatVector<int8_t>(
+            {-44, -4, 26, 56, -100, 0, 124, 117, 63, -78, -48, std::nullopt}),
+        false);
+    testCast(
+        makeNullableFlatVector<int64_t>({214748364890}, DECIMAL(12, 2)),
+        makeNullableFlatVector<int8_t>({0}),
+        false);
+    testCast(
+        makeNullableFlatVector<int64_t>({214748364890}, DECIMAL(12, 2)),
+        makeNullableFlatVector<int32_t>({-2147483648}),
+        false);
+    testCast(
+        makeNullableFlatVector<int64_t>({214748364890}, DECIMAL(12, 2)),
+        makeNullableFlatVector<int64_t>({2147483648}),
+        false);
+  }
+
+  void testRecursiveTryCast() {
+    // Test array elements.
+    testCast(
+        makeArrayVector<StringView>({
+            {"1", "2", "3"},
+            {"4", "a", "6"},
+            {"b", "c", "d"},
+        }),
+        makeNullableArrayVector<int64_t>({
+            {1, 2, 3},
+            {4, std::nullopt, 6},
+            {std::nullopt, std::nullopt, std::nullopt},
+        }),
+        true);
+
+    // Test map values (Spark doesn't allow casting if the map keys can become
+    // null).
+    testCast(
+        makeMapVectorFromJson<int64_t, std::string>({
+            R"( {1:"1", 2:"2", 3:"3"} )",
+            R"( {1:"4", 2:"a", 3:"6"} )",
+            R"( {1:"b", 2:"c", 3:"d"} )",
+        }),
+        makeMapVectorFromJson<int64_t, int64_t>({
+            "{1:1, 2:2, 3:3}",
+            "{1:4, 2:null, 3:6}",
+            "{1:null, 2:null, 3:null}",
+        }),
+        true);
+
+    // Test row fields.
+    testCast(
+        makeRowVector(
+            {makeFlatVector<StringView>({"1", "4", "b"}),
+             makeFlatVector<StringView>({"2", "a", "c"}),
+             makeFlatVector<StringView>({"3", "6", "d"})}),
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({1, 4, std::nullopt}),
+             makeNullableFlatVector<int64_t>({2, std::nullopt, std::nullopt}),
+             makeNullableFlatVector<int64_t>({3, 6, std::nullopt})}),
+        true);
+
+    // Test nested arrays.
+    testCast(
+        makeNestedArrayVectorFromJson<std::string>({
+            R"( [["1", "2", "3"], ["4", "a", "6"]] )",
+            R"( [["b", "c", "d"], ["x", "7", "z"]] )",
+        }),
+        makeNestedArrayVectorFromJson<int64_t>({
+            "[[1, 2, 3], [4, null, 6]]",
+            "[[null, null, null], [null, 7, null]]",
+        }),
+        true);
+  }
 };
 
-TEST_F(SparkCastExprTest, date) {
-  testCast<std::string, int32_t>(
-      "date",
-      {"1970-01-01",
-       "2020-01-01",
-       "2135-11-09",
-       "1969-12-27",
-       "1812-04-15",
-       "1920-01-02",
-       "12345-12-18",
-       "1970-1-2",
-       "1970-01-2",
-       "1970-1-02",
-       "+1970-01-02",
-       " 1970-01-01",
-       std::nullopt},
-      {0,
-       18262,
-       60577,
-       -5,
-       -57604,
-       -18262,
-       3789742,
-       1,
-       1,
-       1,
-       1,
-       0,
-       std::nullopt},
-      VARCHAR(),
-      DATE());
-  testCast<std::string, int32_t>(
-      "date",
-      {"12345",
-       "2015",
-       "2015-03",
-       "2015-03-18T",
-       "2015-03-18T123123",
-       "2015-03-18 123142",
-       "2015-03-18 (BC)"},
-      {3789391, 16436, 16495, 16512, 16512, 16512, 16512},
-      VARCHAR(),
-      DATE());
+class SparkCastExprTestAnsiOn : public SparkCastExprTest {
+ protected:
+  void SetUp() override {
+    SparkCastExprTest::SetUp();
+    setAnsiSupport(true);
+  }
+};
+
+class SparkCastExprTestAnsiOff : public SparkCastExprTest {
+ protected:
+  void SetUp() override {
+    SparkCastExprTest::SetUp();
+    setAnsiSupport(false);
+  }
+};
+
+// ============================================================================
+// ANSI ON Tests
+// ============================================================================
+
+TEST_F(SparkCastExprTestAnsiOn, boolToTimestamp) {
+  testBoolToTimestamp();
 }
 
-TEST_F(SparkCastExprTest, decimalToIntegral) {
-  testDecimalToIntegralCasts<int64_t>();
-  testDecimalToIntegralCasts<int32_t>();
-  testDecimalToIntegralCasts<int16_t>();
-  testDecimalToIntegralCasts<int8_t>();
+TEST_F(SparkCastExprTestAnsiOn, intToTimestamp) {
+  testIntToTimestamp();
 }
 
-TEST_F(SparkCastExprTest, invalidDate) {
-  testInvalidCast<int8_t>(
-      "date", {12}, "Cast from TINYINT to DATE is not supported", TINYINT());
-  testInvalidCast<int16_t>(
-      "date",
-      {1234},
-      "Cast from SMALLINT to DATE is not supported",
-      SMALLINT());
-  testInvalidCast<int32_t>(
-      "date", {1234}, "Cast from INTEGER to DATE is not supported", INTEGER());
-  testInvalidCast<int64_t>(
-      "date", {1234}, "Cast from BIGINT to DATE is not supported", BIGINT());
-
-  testInvalidCast<float>(
-      "date", {12.99}, "Cast from REAL to DATE is not supported", REAL());
-  testInvalidCast<double>(
-      "date", {12.99}, "Cast from DOUBLE to DATE is not supported", DOUBLE());
+TEST_F(SparkCastExprTestAnsiOn, tinyIntToBinary) {
+  testTinyIntToBinary();
+}
 
-  // Parsing ill-formated dates.
-  testCast<std::string, int32_t>(
-      "date", {"2012-Oct-23"}, {std::nullopt}, VARCHAR(), DATE());
-  testCast<std::string, int32_t>(
-      "date", {"2015-03-18X"}, {std::nullopt}, VARCHAR(), DATE());
-  testCast<std::string, int32_t>(
-      "date", {"2015/03/18"}, {std::nullopt}, VARCHAR(), DATE());
-  testCast<std::string, int32_t>(
-      "date", {"2015.03.18"}, {std::nullopt}, VARCHAR(), DATE());
-  testCast<std::string, int32_t>(
-      "date", {"20150318"}, {std::nullopt}, VARCHAR(), DATE());
-  testCast<std::string, int32_t>(
-      "date", {"2015-031-8"}, {std::nullopt}, VARCHAR(), DATE());
-  testCast<std::string, int32_t>(
-      "date", {"-1-1-1"}, {std::nullopt}, VARCHAR(), DATE());
-  testCast<std::string, int32_t>(
-      "date", {"-11-1-1"}, {std::nullopt}, VARCHAR(), DATE());
-  testCast<std::string, int32_t>(
-      "date", {"-111-1-1"}, {std::nullopt}, VARCHAR(), DATE());
-  testCast<std::string, int32_t>(
-      "date", {"- 1111-1-1"}, {std::nullopt}, VARCHAR(), DATE());
+TEST_F(SparkCastExprTestAnsiOn, smallintToBinary) {
+  testSmallintToBinary();
 }
 
-TEST_F(SparkCastExprTest, stringToTimestamp) {
-  std::vector<std::optional<std::string>> input{
-      "1970-01-01",
-      "1970-01-01 00:00:00-02:00",
-      "1970-01-01 00:00:00 +02:00",
-      "2000-01-01",
-      "1970-01-01 00:00:00",
-      "2000-01-01 12:21:56",
-      std::nullopt,
-      "2015-03-18T12:03:17",
-      "2015-03-18T12:03:17Z",
-      "2015-03-18 12:03:17",
-      "2015-03-18T12:03:17",
-      "2015-03-18 12:03:17.123",
-      "2015-03-18T12:03:17.123",
-      "2015-03-18T12:03:17.456",
-      "2015-03-18 12:03:17.456",
+TEST_F(SparkCastExprTestAnsiOn, integerToBinary) {
+  testIntegerToBinary();
+}
+
+TEST_F(SparkCastExprTestAnsiOn, bigIntToBinary) {
+  testBigIntToBinary();
+}
+
+TEST_F(SparkCastExprTestAnsiOn, decimalToString) {
+  testDecimalToString();
+}
+
+TEST_F(SparkCastExprTestAnsiOn, decimalToIntegral) {
+  testDecimalToIntegral();
+}
+
+TEST_F(SparkCastExprTestAnsiOn, floatToTimestamp) {
+  testFloatToTimestamp();
+}
+
+TEST_F(SparkCastExprTestAnsiOn, doubleToTimestamp) {
+  testDoubleToTimestamp();
+}
+
+TEST_F(SparkCastExprTestAnsiOn, timestampToInt) {
+  testTimestampToInt();
+}
+
+TEST_F(SparkCastExprTestAnsiOn, timestampToString) {
+  testTimestampToString();
+}
+
+TEST_F(SparkCastExprTestAnsiOn, testInvalidDate) {
+  auto expected = [](const std::string& v) {
+    return fmt::format(
+        "Cannot cast VARCHAR '{}' to DATE.  Unable to parse date value: \"{}\". "
+        "Valid date string patterns include ([y]y*, [y]y*-[m]m*, "
+        "[y]y*-[m]m*-[d]d*, [y]y*-[m]m*-[d]d* *, "
+        "[y]y*-[m]m*-[d]d*T*), and any pattern prefixed with [+-]",
+        v,
+        v);
+  };
+  testInvalidCast<std::string>(
+      "date", {"2012-Oct-23"}, expected("2012-Oct-23"), VARCHAR());
+  testInvalidCast<std::string>(
+      "date", {"2015-03-18X"}, expected("2015-03-18X"), VARCHAR());
+  testInvalidCast<std::string>(
+      "date", {"2015/03/18"}, expected("2015/03/18"), VARCHAR());
+  testInvalidCast<std::string>(
+      "date", {"2015.03.18"}, expected("2015.03.18"), VARCHAR());
+  testInvalidCast<std::string>(
+      "date", {"20150318"}, expected("20150318"), VARCHAR());
+  testInvalidCast<std::string>(
+      "date", {"2015-031-8"}, expected("2015-031-8"), VARCHAR());
+  testInvalidCast<std::string>(
+      "date", {"-1-1-1"}, expected("-1-1-1"), VARCHAR());
+  testInvalidCast<std::string>(
+      "date", {"-11-1-1"}, expected("-11-1-1"), VARCHAR());
+  testInvalidCast<std::string>(
+      "date", {"-111-1-1"}, expected("-111-1-1"), VARCHAR());
+  testInvalidCast<std::string>(
+      "date", {"- 1111-1-1"}, expected("- 1111-1-1"), VARCHAR());
+  testInvalidDate();
+}
+
+TEST_F(SparkCastExprTestAnsiOn, stringToBoolean) {
+  testStringToBoolean();
+  auto testInvalidString = [this](const std::string& value) {
+    auto input = makeRowVector({makeFlatVector<std::string>({value})});
+    VELOX_ASSERT_THROW(evaluate("cast(c0 as boolean)", input), "Cannot cast");
+  };
+
+  testInvalidString("invalid");
+  testInvalidString("tru");
+  testInvalidString("2");
+  testInvalidString("-1");
+  testInvalidString("on");
+  testInvalidString("off");
+  testInvalidString("");
+  testInvalidString(" ");
+  testInvalidString("nan");
+}
+
+TEST_F(SparkCastExprTestAnsiOn, stringToTimestamp) {
+  testStringToTimestamp();
+}
+
+TEST_F(SparkCastExprTestAnsiOn, stringToDate) {
+  testStringToDate();
+  auto testInvalidDate = [this](const std::string& value) {
+    auto input = makeRowVector({makeFlatVector<std::string>({value})});
+    VELOX_ASSERT_THROW(
+        (evaluateCast(VARCHAR(), DATE(), input, false)),
+        "Unable to parse date value");
+  };
+
+  testInvalidDate("2012-Oct-23");
+  testInvalidDate("2015/03/18");
+  testInvalidDate("2015-13-01");
+  testInvalidDate("2015-02-30");
+}
+
+TEST_F(SparkCastExprTestAnsiOn, fromString) {
+  testFromString();
+}
+
+TEST_F(SparkCastExprTestAnsiOn, primitiveInvalidCornerCase) {
+  // To integer - ANSI ON (throws on error).
+  {
+    auto testInvalidThrows =
+        [this](const std::string& type, const std::string& value) {
+          auto input = makeRowVector({makeFlatVector<std::string>({value})});
+          VELOX_ASSERT_THROW(
+              (evaluate(fmt::format("cast(c0 as {})", type), input)), "");
+        };
+
+    // Invalid strings should throw.
+    testInvalidThrows("tinyint", "1234567");
+    testInvalidThrows("tinyint", "1a");
+    testInvalidThrows("tinyint", "");
+    testInvalidThrows("integer", "1'234'567");
+    testInvalidThrows("integer", "1,234,567");
+    testInvalidThrows("bigint", "infinity");
+    testInvalidThrows("bigint", "nan");
+    testInvalidThrows("bigint", "abc");
+    testInvalidThrows("bigint", "+");
+    testInvalidThrows("bigint", "-");
+
+    // Overflow should throw.
+    testInvalidThrows("tinyint", "128");
+    testInvalidThrows("tinyint", "-129");
+    testInvalidThrows("smallint", "32768");
+    testInvalidThrows("smallint", "-32769");
+    testInvalidThrows("integer", "2147483648");
+    testInvalidThrows("integer", "-2147483649");
+  }
+}
+
+TEST_F(SparkCastExprTestAnsiOn, primitiveValidCornerCases) {
+  testPrimitiveValidCornerCases();
+
+  auto testInvalidString = [this](const std::string& value) {
+    auto input = makeRowVector({makeFlatVector<std::string>({value})});
+    VELOX_ASSERT_THROW(evaluate("cast(c0 as boolean)", input), "Cannot cast");
   };
-  std::vector<std::optional<Timestamp>> expected{
-      Timestamp(0, 0),
-      Timestamp(7200, 0),
-      Timestamp(-7200, 0),
-      Timestamp(946684800, 0),
-      Timestamp(0, 0),
-      Timestamp(946729316, 0),
-      std::nullopt,
-      Timestamp(1426680197, 0),
-      Timestamp(1426680197, 0),
-      Timestamp(1426680197, 0),
-      Timestamp(1426680197, 0),
-      Timestamp(1426680197, 123000000),
-      Timestamp(1426680197, 123000000),
-      Timestamp(1426680197, 456000000),
-      Timestamp(1426680197, 456000000),
+
+  testInvalidString("invalid");
+  testInvalidString("tru");
+  testInvalidString("2");
+  testInvalidString("-1");
+  testInvalidString("on");
+  testInvalidString("off");
+  testInvalidString("");
+  testInvalidString(" ");
+  testInvalidString("nan");
+  auto testInvalidThrows =
+      [this](const std::string& type, const std::string& value) {
+        auto input = makeRowVector({makeFlatVector<std::string>({value})});
+        VELOX_ASSERT_THROW(
+            (evaluate(fmt::format("cast(c0 as {})", type), input)), "");
+      };
+
+  // Invalid strings should throw.
+  testInvalidThrows("tinyint", "1234567");
+  testInvalidThrows("tinyint", "1a");
+  testInvalidThrows("tinyint", "");
+  testInvalidThrows("integer", "1'234'567");
+  testInvalidThrows("integer", "1,234,567");
+  testInvalidThrows("bigint", "infinity");
+  testInvalidThrows("bigint", "nan");
+  testInvalidThrows("bigint", "abc");
+  testInvalidThrows("bigint", "+");
+  testInvalidThrows("bigint", "-");
+
+  // Overflow should throw.
+  testInvalidThrows("tinyint", "128");
+  testInvalidThrows("tinyint", "-129");
+  testInvalidThrows("smallint", "32768");
+  testInvalidThrows("smallint", "-32769");
+  testInvalidThrows("integer", "2147483648");
+  testInvalidThrows("integer", "-2147483649");
+
+  testCast<std::string, int64_t>(
+      "bigint", {"123", "-456", "+789", "  999  "}, {123, -456, 789, 999});
+  testCast<std::string, int32_t>(
+      "integer", {"123", "-456", "+789", "  999  "}, {123, -456, 789, 999});
+  testCast<std::string, int16_t>(
+      "smallint", {"123", "-456", "+789", "  999  "}, {123, -456, 789, 999});
+  testCast<std::string, int8_t>(
+      "tinyint", {"12", "-45", "+78", "  99  "}, {12, -45, 78, 99});
+
+  auto testDecimalThrows = [this](
+                               const std::string& type,
+                               const std::string& value) {
+    auto input = makeRowVector({makeFlatVector<std::string>({value})});
+    VELOX_ASSERT_THROW(
+        (evaluate(fmt::format("cast(c0 as {})", type), input)), "Cannot cast");
   };
-  testCast<std::string, Timestamp>("timestamp", input, expected);
-
-  setTimezone("Asia/Shanghai");
-  testCast<std::string, Timestamp>(
-      "timestamp",
-      {"1970-01-01 00:00:00",
-       "1970-01-01 08:00:00",
-       "1970-01-01 08:00:59",
-       "1970"},
-      {Timestamp(-8 * 3600, 0),
-       Timestamp(0, 0),
-       Timestamp(59, 0),
-       Timestamp(-8 * 3600, 0)});
-}
-
-TEST_F(SparkCastExprTest, intToTimestamp) {
-  // Cast bigint as timestamp.
+
+  testDecimalThrows("bigint", "123.45");
+  testDecimalThrows("integer", "456.78");
+  testDecimalThrows("smallint", "78.9");
+  testDecimalThrows("tinyint", "12.3");
+  testDecimalThrows("tinyint", "1.2");
+  testDecimalThrows("tinyint", "-1.8");
+}
+
+TEST_F(SparkCastExprTestAnsiOn, truncate) {
+  testTruncate();
+}
+
+TEST_F(SparkCastExprTestAnsiOn, tryCasts) {
+  testTryCasts();
+}
+
+TEST_F(SparkCastExprTestAnsiOn, overflow) {
+  // Overflow protection not enabled yet, see velox#16579
+}
+
+TEST_F(SparkCastExprTestAnsiOn, recursiveTryCast) {
+  testRecursiveTryCast();
+}
+
+// ============================================================================
+// ANSI OFF Tests
+// ============================================================================
+
+TEST_F(SparkCastExprTestAnsiOff, boolToTimestamp) {
+  testBoolToTimestamp();
+}
+
+TEST_F(SparkCastExprTestAnsiOff, intToTimestamp) {
+  testIntToTimestamp();
+}
+
+TEST_F(SparkCastExprTestAnsiOff, tinyIntToBinary) {
+  testTinyIntToBinary();
+}
+
+TEST_F(SparkCastExprTestAnsiOff, smallintToBinary) {
+  testSmallintToBinary();
+}
+
+TEST_F(SparkCastExprTestAnsiOff, integerToBinary) {
+  testIntegerToBinary();
+}
+
+TEST_F(SparkCastExprTestAnsiOff, bigIntToBinary) {
+  testBigIntToBinary();
+}
+
+TEST_F(SparkCastExprTestAnsiOff, decimalToIntegral) {
+  testDecimalToIntegral();
+}
+
+TEST_F(SparkCastExprTestAnsiOff, decimalToString) {
+  testDecimalToString();
+}
+
+TEST_F(SparkCastExprTestAnsiOff, floatToTimestamp) {
+  testFloatToTimestamp();
   testCast(
-      makeNullableFlatVector<int64_t>({
-          0,
-          1727181032,
-          -1727181032,
-          9223372036855,
-          -9223372036856,
-          std::numeric_limits<int64_t>::max(),
-          std::numeric_limits<int64_t>::min(),
-      }),
+      makeFlatVector<float>({kInf, kNan, -kInf}),
       makeNullableFlatVector<Timestamp>({
-          Timestamp(0, 0),
-          Timestamp(1727181032, 0),
-          Timestamp(-1727181032, 0),
-          Timestamp(9223372036854, 775'807'000),
-          Timestamp(-9223372036855, 224'192'000),
-          Timestamp(9223372036854, 775'807'000),
-          Timestamp(-9223372036855, 224'192'000),
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
       }));
-
-  // Cast tinyint/smallint/integer as timestamp.
-  testIntegralToTimestampCast<int8_t>();
-  testIntegralToTimestampCast<int16_t>();
-  testIntegralToTimestampCast<int32_t>();
 }
 
-TEST_F(SparkCastExprTest, timestampToInt) {
-  // Cast timestamp as bigint.
+TEST_F(SparkCastExprTestAnsiOff, doubleToTimestamp) {
+  testDoubleToTimestamp();
   testCast(
-      makeFlatVector<Timestamp>(
-          {Timestamp(0, 0),
-           Timestamp(1, 0),
-           Timestamp(10, 0),
-           Timestamp(-1, 0),
-           Timestamp(-10, 0),
-           Timestamp(-1, 500000),
-           Timestamp(-2, 999999),
-           Timestamp(-10, 999999),
-           Timestamp(1, 999999),
-           Timestamp(-1, 1),
-           Timestamp(1234567, 500000),
-           Timestamp(-9876543, 1234),
-           Timestamp(1727181032, 0),
-           Timestamp(-1727181032, 0),
-           Timestamp(9223372036854, 775'807'000),
-           Timestamp(-9223372036855, 224'192'000),
-           Timestamp(9223372036856, 0)}),
-      makeNullableFlatVector<int64_t>({
-          0,
-          1,
-          10,
-          -1,
-          -10,
-          -1,
-          -2,
-          -10,
-          1,
-          -1,
-          1234567,
-          -9876543,
-          1727181032,
-          -1727181032,
-          9223372036854,
-          -9223372036855,
+      makeFlatVector<double>({
+          kInf,
+          kNan,
+          -kInf,
+      }),
+      makeNullableFlatVector<Timestamp>({
+          std::nullopt,
+          std::nullopt,
           std::nullopt,
       }));
+}
 
-  // Cast timestamp as tinyint/smallint/integer.
-  testTimestampToIntegralCast<int8_t>();
-  testTimestampToIntegralCast<int16_t>();
-  testTimestampToIntegralCast<int32_t>();
-
-  // Cast overflowed timestamp as tinyint/smallint/integer.
+TEST_F(SparkCastExprTestAnsiOff, timestampToInt) {
+  testTimestampToInt();
+  testCast<Timestamp, int64_t>(
+      "bigint", {Timestamp(9223372036856, 0)}, {std::nullopt});
   testTimestampToIntegralCastOverflow<int8_t>({
       -102,
       -1,
@@ -378,64 +1368,95 @@ TEST_F(SparkCastExprTest, timestampToInt) {
   });
 }
 
-TEST_F(SparkCastExprTest, doubleToTimestamp) {
-  testCast(
-      makeFlatVector<double>({
-          0.0,
-          1727181032.0,
-          -1727181032.0,
-          9223372036855.999,
-          -9223372036856.999,
-          1.79769e+308,
-          std::numeric_limits<double>::max(),
-          -std::numeric_limits<double>::max(),
-          std::numeric_limits<double>::min(),
-          kInf,
-          kNan,
-          -kInf,
-      }),
-      makeNullableFlatVector<Timestamp>({
-          Timestamp(0, 0),
-          Timestamp(1727181032, 0),
-          Timestamp(-1727181032, 0),
-          Timestamp(9223372036854, 775'807'000),
-          Timestamp(-9223372036855, 224'192'000),
-          Timestamp(9223372036854, 775'807'000),
-          Timestamp(9223372036854, 775'807'000),
-          Timestamp(-9223372036855, 224'192'000),
-          Timestamp(0, 0),
-          std::nullopt,
-          std::nullopt,
-          std::nullopt,
-      }));
+TEST_F(SparkCastExprTestAnsiOff, timestampToString) {
+  testTimestampToString();
 }
 
-TEST_F(SparkCastExprTest, floatToTimestamp) {
-  testCast(
-      makeFlatVector<float>({
-          0.0,
-          1727181032.0,
-          -1727181032.0,
-          std::numeric_limits<float>::max(),
-          std::numeric_limits<float>::min(),
-          kInf,
-          kNan,
-          -kInf,
-      }),
-      makeNullableFlatVector<Timestamp>({
-          Timestamp(0, 0),
-          Timestamp(1727181056, 0),
-          Timestamp(-1727181056, 0),
-          Timestamp(9223372036854, 775'807'000),
-          Timestamp(0, 0),
-          std::nullopt,
-          std::nullopt,
-          std::nullopt,
-      }));
+TEST_F(SparkCastExprTestAnsiOff, testInvalidDate) {
+  testInvalidDate();
+  // Parsing ill-formated dates.
+  testCast<std::string, int32_t>(
+      "date", {"2012-Oct-23"}, {std::nullopt}, VARCHAR(), DATE());
+  testCast<std::string, int32_t>(
+      "date", {"2015-03-18X"}, {std::nullopt}, VARCHAR(), DATE());
+  testCast<std::string, int32_t>(
+      "date", {"2015/03/18"}, {std::nullopt}, VARCHAR(), DATE());
+  testCast<std::string, int32_t>(
+      "date", {"2015.03.18"}, {std::nullopt}, VARCHAR(), DATE());
+  testCast<std::string, int32_t>(
+      "date", {"20150318"}, {std::nullopt}, VARCHAR(), DATE());
+  testCast<std::string, int32_t>(
+      "date", {"2015-031-8"}, {std::nullopt}, VARCHAR(), DATE());
+  testCast<std::string, int32_t>(
+      "date", {"-1-1-1"}, {std::nullopt}, VARCHAR(), DATE());
+  testCast<std::string, int32_t>(
+      "date", {"-11-1-1"}, {std::nullopt}, VARCHAR(), DATE());
+  testCast<std::string, int32_t>(
+      "date", {"-111-1-1"}, {std::nullopt}, VARCHAR(), DATE());
+  testCast<std::string, int32_t>(
+      "date", {"- 1111-1-1"}, {std::nullopt}, VARCHAR(), DATE());
+}
+
+TEST_F(SparkCastExprTestAnsiOff, stringToBoolean) {
+  testStringToBoolean();
+
+  testCast<std::string, bool>(
+      "boolean",
+      {"invalid", "tru", "2", "-1", "on", "off", "nan", "", " "},
+      {std::nullopt,
+       std::nullopt,
+       std::nullopt,
+       std::nullopt,
+       std::nullopt,
+       std::nullopt,
+       std::nullopt,
+       std::nullopt,
+       std::nullopt});
+
+  testCast<std::string, bool>(
+      "boolean",
+      {"true", "invalid", "false", std::nullopt, "1", "2", "0"},
+      {true, std::nullopt, false, std::nullopt, true, std::nullopt, false});
+}
+
+TEST_F(SparkCastExprTestAnsiOff, stringToTimestamp) {
+  testStringToTimestamp();
+  testCast<std::string, Timestamp>("timestamp", {"INVALID"}, {std::nullopt});
+}
+
+TEST_F(SparkCastExprTestAnsiOff, stringToDate) {
+  testStringToDate();
+  testCast<std::string, int32_t>(
+      "date",
+      {"2012-Oct-23", /*Invalid format*/
+       "2015/03/18", /*Wrong separator*/
+       "2015-13-01", /*Invalid month*/
+       "2015-02-30"}, /*Invalid day*/
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt},
+      VARCHAR(),
+      DATE());
+}
+
+TEST_F(SparkCastExprTestAnsiOff, fromString) {
+  testFromString();
 }
 
-TEST_F(SparkCastExprTest, primitiveInvalidCornerCases) {
-  // To integer.
+TEST_F(SparkCastExprTestAnsiOff, primitiveInvalidCornerCase) {
+  // To floating-point - invalid strings return null
+  testCast<std::string, float>("real", {"1.2a"}, {std::nullopt});
+  testCast<std::string, float>("real", {"1.2.3"}, {std::nullopt});
+
+  // To boolean - invalid strings return null
+  testCast<std::string, bool>("boolean", {"1.7E308"}, {std::nullopt});
+  testCast<std::string, bool>("boolean", {"nan"}, {std::nullopt});
+  testCast<std::string, bool>("boolean", {"12"}, {std::nullopt});
+  testCast<std::string, bool>("boolean", {"-1"}, {std::nullopt});
+  testCast<std::string, bool>("boolean", {"tr"}, {std::nullopt});
+  testCast<std::string, bool>("boolean", {"tru"}, {std::nullopt});
+  testCast<std::string, bool>("boolean", {"on"}, {std::nullopt});
+  testCast<std::string, bool>("boolean", {"off"}, {std::nullopt});
+
+  // To integer
   {
     // Invalid strings.
     testCast<std::string, int8_t>("tinyint", {"1234567"}, {std::nullopt});
@@ -445,141 +1466,70 @@ TEST_F(SparkCastExprTest, primitiveInvalidCornerCases) {
     testCast<std::string, int32_t>("integer", {"1,234,567"}, {std::nullopt});
     testCast<std::string, int64_t>("bigint", {"infinity"}, {std::nullopt});
     testCast<std::string, int64_t>("bigint", {"nan"}, {std::nullopt});
-  }
+    testCast<std::string, int64_t>(
+        "bigint",
+        {"abc", "+", "-", "  "},
+        {std::nullopt, std::nullopt, std::nullopt, std::nullopt});
 
-  // To floating-point.
-  {
-    // Invalid strings.
-    testCast<std::string, float>("real", {"1.2a"}, {std::nullopt});
-    testCast<std::string, float>("real", {"1.2.3"}, {std::nullopt});
-  }
-
-  // To boolean.
-  {
-    testCast<std::string, bool>("boolean", {"1.7E308"}, {std::nullopt});
-    testCast<std::string, bool>("boolean", {"nan"}, {std::nullopt});
-    testCast<std::string, bool>("boolean", {"12"}, {std::nullopt});
-    testCast<std::string, bool>("boolean", {"-1"}, {std::nullopt});
-    testCast<std::string, bool>("boolean", {"tr"}, {std::nullopt});
-    testCast<std::string, bool>("boolean", {"tru"}, {std::nullopt});
-    testCast<std::string, bool>("boolean", {"on"}, {std::nullopt});
-    testCast<std::string, bool>("boolean", {"off"}, {std::nullopt});
+    // Overflow cases.
+    testCast<std::string, int8_t>(
+        "tinyint",
+        {"128", "-129", "1000"},
+        {std::nullopt, std::nullopt, std::nullopt});
+    testCast<std::string, int16_t>(
+        "smallint", {"32768", "-32769"}, {std::nullopt, std::nullopt});
   }
 }
 
-TEST_F(SparkCastExprTest, primitiveValidCornerCases) {
-  // To integer.
-  {
-    // Valid strings.
-    testCast<std::string, int8_t>("tinyint", {"1.2"}, {1});
-    testCast<std::string, int8_t>("tinyint", {"1.23444"}, {1});
-    testCast<std::string, int8_t>("tinyint", {".2355"}, {0});
-    testCast<std::string, int8_t>("tinyint", {"-1.8"}, {-1});
-    testCast<std::string, int8_t>("tinyint", {"+1"}, {1});
-    testCast<std::string, int8_t>("tinyint", {"1."}, {1});
-    testCast<std::string, int8_t>("tinyint", {"-1"}, {-1});
-    testCast<std::string, int8_t>("tinyint", {"-1."}, {-1});
-    testCast<std::string, int8_t>("tinyint", {"0."}, {0});
-    testCast<std::string, int8_t>("tinyint", {"."}, {0});
-    testCast<std::string, int8_t>("tinyint", {"-."}, {0});
-
-    testCast<int32_t, int8_t>("tinyint", {1234567}, {-121});
-    testCast<int32_t, int8_t>("tinyint", {-1234567}, {121});
-    testCast<double, int8_t>("tinyint", {12345.67}, {57});
-    testCast<double, int8_t>("tinyint", {-12345.67}, {-57});
-    testCast<double, int8_t>("tinyint", {127.1}, {127});
-    testCast<float, int64_t>("bigint", {kInf}, {9223372036854775807});
-    testCast<float, int64_t>("bigint", {kNan}, {0});
-    testCast<float, int32_t>("integer", {kNan}, {0});
-    testCast<float, int16_t>("smallint", {kNan}, {0});
-    testCast<float, int8_t>("tinyint", {kNan}, {0});
-
-    testCast<double, int64_t>("bigint", {12345.12}, {12345});
-    testCast<double, int64_t>("bigint", {12345.67}, {12345});
-  }
-
-  // To floating-point.
-  {
-    testCast<double, float>("real", {1.7E308}, {kInf});
+TEST_F(SparkCastExprTestAnsiOff, primitiveValidCornerCases) {
+  testPrimitiveValidCornerCases();
 
-    testCast<std::string, float>("real", {"1.7E308"}, {kInf});
-    testCast<std::string, float>("real", {"1."}, {1.0});
-    testCast<std::string, float>("real", {"1"}, {1});
-    testCast<std::string, float>("real", {"infinity"}, {kInf});
-    testCast<std::string, float>("real", {"-infinity"}, {-kInf});
-    testCast<std::string, float>("real", {"nan"}, {kNan});
-    testCast<std::string, float>("real", {"InfiNiTy"}, {kInf});
-    testCast<std::string, float>("real", {"-InfiNiTy"}, {-kInf});
-    testCast<std::string, float>("real", {"nAn"}, {kNan});
-  }
+  testCast<std::string, int64_t>(
+      "bigint", {"123", "-456", "+789", "  999  "}, {123, -456, 789, 999});
+  testCast<std::string, int32_t>(
+      "integer", {"123", "-456", "+789", "  999  "}, {123, -456, 789, 999});
+  testCast<std::string, int16_t>(
+      "smallint", {"123", "-456", "+789", "  999  "}, {123, -456, 789, 999});
+  testCast<std::string, int8_t>(
+      "tinyint", {"12", "-45", "+78", "  99  "}, {12, -45, 78, 99});
 
-  // To boolean.
-  {
-    testCast<int8_t, bool>("boolean", {1}, {true});
-    testCast<int8_t, bool>("boolean", {0}, {false});
-    testCast<int8_t, bool>("boolean", {12}, {true});
-    testCast<int8_t, bool>("boolean", {-1}, {true});
-    testCast<double, bool>("boolean", {1.0}, {true});
-    testCast<double, bool>("boolean", {1.1}, {true});
-    testCast<double, bool>("boolean", {0.1}, {true});
-    testCast<double, bool>("boolean", {-0.1}, {true});
-    testCast<double, bool>("boolean", {-1.0}, {true});
-    testCast<float, bool>("boolean", {kNan}, {false});
-    testCast<float, bool>("boolean", {kInf}, {true});
-    testCast<double, bool>("boolean", {0.0000000000001}, {true});
-
-    testCast<std::string, bool>("boolean", {"1"}, {true});
-    testCast<std::string, bool>("boolean", {"t"}, {true});
-    testCast<std::string, bool>("boolean", {"y"}, {true});
-    testCast<std::string, bool>("boolean", {"yes"}, {true});
-    testCast<std::string, bool>("boolean", {"true"}, {true});
-
-    testCast<std::string, bool>("boolean", {"0"}, {false});
-    testCast<std::string, bool>("boolean", {"f"}, {false});
-    testCast<std::string, bool>("boolean", {"n"}, {false});
-    testCast<std::string, bool>("boolean", {"no"}, {false});
-    testCast<std::string, bool>("boolean", {"false"}, {false});
-  }
-
-  // To string.
-  {
-    testCast<float, std::string>("varchar", {kInf}, {"Infinity"});
-    testCast<float, std::string>("varchar", {kNan}, {"NaN"});
-  }
-}
+  testCast<float, int64_t>("bigint", {kNan}, {0});
+  testCast<float, int32_t>("integer", {kNan}, {0});
+  testCast<float, int16_t>("smallint", {kNan}, {0});
+  testCast<float, int8_t>("tinyint", {kNan}, {0});
 
-TEST_F(SparkCastExprTest, truncate) {
-  // Testing truncate cast from double to int.
-  testCast<int32_t, int8_t>(
-      "tinyint", {1111111, 2, 3, 1000, -100101}, {71, 2, 3, -24, -5});
-}
+  testCast<std::string, int8_t>("tinyint", {"1.2"}, {1});
+  testCast<std::string, int8_t>("tinyint", {"1.23444"}, {1});
+  testCast<std::string, int8_t>("tinyint", {".2355"}, {0});
+  testCast<std::string, int8_t>("tinyint", {"-1.8"}, {-1});
+  testCast<std::string, int8_t>("tinyint", {"1."}, {1});
+  testCast<std::string, int8_t>("tinyint", {"-1."}, {-1});
+  testCast<std::string, int8_t>("tinyint", {"0."}, {0});
+  testCast<std::string, int8_t>("tinyint", {"."}, {0});
+  testCast<std::string, int8_t>("tinyint", {"-."}, {0});
+
+  testCast<int32_t, int8_t>("tinyint", {1234567}, {-121});
+  testCast<int32_t, int8_t>("tinyint", {-1234567}, {121});
+
+  testCast<double, int8_t>("tinyint", {12345.67}, {57});
+  testCast<double, int8_t>("tinyint", {-12345.67}, {-57});
+  testCast<float, int64_t>("bigint", {kInf}, {9223372036854775807});
 
-TEST_F(SparkCastExprTest, tryCast) {
-  testTryCast<std::string, int8_t>(
-      "tinyint",
-      {"-",
-       "-0",
-       " @w 123",
-       "123 ",
-       "  122",
-       "",
-       "-12-3",
-       "1234",
-       "-129",
-       "1.1.1",
-       "1..",
-       "1.abc",
-       "..",
-       "-..",
-       "125.5",
-       "127",
-       "-128",
-       "1.2"},
+  testCast<double, float>("real", {1.7E308}, {kInf});
+
+  testCast<double, bool>("boolean", {1.0}, {true});
+  testCast<double, bool>("boolean", {1.1}, {true});
+  testCast<double, bool>("boolean", {0.1}, {true});
+  testCast<double, bool>("boolean", {-0.1}, {true});
+  testCast<double, bool>("boolean", {-1.0}, {true});
+  testCast<float, bool>("boolean", {kNan}, {false});
+  testCast<float, bool>("boolean", {kInf}, {true});
+  testCast<double, bool>("boolean", {0.0000000000001}, {true});
+
+  testCast<std::string, bool>(
+      "boolean",
+      {"invalid", "tru", "2", "-1", "on", "off", "nan", "", " "},
       {std::nullopt,
-       0,
-       std::nullopt,
-       123,
-       122,
        std::nullopt,
        std::nullopt,
        std::nullopt,
@@ -587,350 +1537,60 @@ TEST_F(SparkCastExprTest, tryCast) {
        std::nullopt,
        std::nullopt,
        std::nullopt,
-       std::nullopt,
-       std::nullopt,
-       std::nullopt,
-       127,
-       -128,
        std::nullopt});
 
-  testTryCast<double, int32_t>(
-      "integer",
-      {1e12, 2.5, 3.6, 100.44, -100.101},
-      {std::nullopt, 2, 3, 100, -100});
-  testTryCast<int64_t, int8_t>("tinyint", {456}, {std::nullopt});
-  testTryCast<int64_t, int16_t>("smallint", {1234567}, {std::nullopt});
-  testTryCast<int64_t, int32_t>("integer", {2147483649}, {std::nullopt});
-
-  testTryCast<std::string, int16_t>("smallint", {"52769"}, {std::nullopt});
-  testTryCast<std::string, int32_t>("integer", {"17515055537"}, {std::nullopt});
-  testTryCast<std::string, int32_t>(
-      "integer", {"-17515055537"}, {std::nullopt});
-  testTryCast<std::string, int64_t>(
-      "bigint", {"9663372036854775809"}, {std::nullopt});
-  testTryCast<int64_t, int8_t>("tinyint", {456}, {std::nullopt}, DECIMAL(6, 0));
-}
-
-TEST_F(SparkCastExprTest, overflow) {
-  testCast<int16_t, int8_t>("tinyint", {456}, {-56});
-  testCast<int32_t, int8_t>("tinyint", {266}, {10});
-  testCast<int64_t, int8_t>("tinyint", {1234}, {-46});
-  testCast<int64_t, int16_t>("smallint", {1234567}, {-10617});
-  testCast<double, int8_t>("tinyint", {127.8}, {127});
-  testCast<double, int8_t>("tinyint", {129.9}, {-127});
-  testCast<double, int16_t>("smallint", {1234567.89}, {-10617});
-  testCast<double, int64_t>(
-      "bigint", {std::numeric_limits<double>::max()}, {9223372036854775807});
-  testCast<double, int64_t>(
-      "bigint", {std::numeric_limits<double>::quiet_NaN()}, {0});
-  auto shortFlat = makeNullableFlatVector<int64_t>(
-      {-3000,
-       -2600,
-       -2300,
-       -2000,
-       -1000,
-       0,
-       55000,
-       57490,
-       5755,
-       6900,
-       7200,
-       std::nullopt},
-      DECIMAL(5, 1));
-  testCast(
-      shortFlat,
-      makeNullableFlatVector<int8_t>(
-          {-44, -4, 26, 56, -100, 0, 124, 117, 63, -78, -48, std::nullopt}),
-      false);
-  testCast(
-      makeNullableFlatVector<int64_t>({214748364890}, DECIMAL(12, 2)),
-      makeNullableFlatVector<int8_t>({0}),
-      false);
-  testCast(
-      makeNullableFlatVector<int64_t>({214748364890}, DECIMAL(12, 2)),
-      makeNullableFlatVector<int32_t>({-2147483648}),
-      false);
-  testCast(
-      makeNullableFlatVector<int64_t>({214748364890}, DECIMAL(12, 2)),
-      makeNullableFlatVector<int64_t>({2147483648}),
-      false);
+  testCast<std::string, bool>(
+      "boolean",
+      {"true", "invalid", "false", std::nullopt, "1", "2", "0"},
+      {true, std::nullopt, false, std::nullopt, true, std::nullopt, false});
 
-  testCast<std::string, int8_t>("tinyint", {"166"}, {std::nullopt});
-  testCast<std::string, int16_t>("smallint", {"52769"}, {std::nullopt});
-  testCast<std::string, int32_t>("integer", {"17515055537"}, {std::nullopt});
-  testCast<std::string, int32_t>("integer", {"-17515055537"}, {std::nullopt});
-  testCast<std::string, int64_t>(
-      "bigint", {"9663372036854775809"}, {std::nullopt});
+  {
+    // Invalid strings.
+    testCast<std::string, int8_t>("tinyint", {"1234567"}, {std::nullopt});
+    testCast<std::string, int8_t>("tinyint", {"1a"}, {std::nullopt});
+    testCast<std::string, int8_t>("tinyint", {""}, {std::nullopt});
+    testCast<std::string, int32_t>("integer", {"1'234'567"}, {std::nullopt});
+    testCast<std::string, int32_t>("integer", {"1,234,567"}, {std::nullopt});
+    testCast<std::string, int64_t>("bigint", {"infinity"}, {std::nullopt});
+    testCast<std::string, int64_t>("bigint", {"nan"}, {std::nullopt});
+    testCast<std::string, int64_t>(
+        "bigint",
+        {"abc", "+", "-", "  "},
+        {std::nullopt, std::nullopt, std::nullopt, std::nullopt});
+
+    // Overflow cases.
+    testCast<std::string, int8_t>(
+        "tinyint",
+        {"128", "-129", "1000"},
+        {std::nullopt, std::nullopt, std::nullopt});
+    testCast<std::string, int16_t>(
+        "smallint", {"32768", "-32769"}, {std::nullopt, std::nullopt});
+  }
 }
 
-TEST_F(SparkCastExprTest, timestampToString) {
-  testCast<Timestamp, std::string>(
-      "string",
-      {
-          Timestamp(-946684800, 0),
-          Timestamp(-7266, 0),
-          Timestamp(0, 0),
-          Timestamp(946684800, 0),
-          Timestamp(9466848000, 0),
-          Timestamp(94668480000, 0),
-          Timestamp(946729316, 0),
-          Timestamp(946729316, 123),
-          Timestamp(946729316, 100000000),
-          Timestamp(946729316, 129900000),
-          Timestamp(946729316, 123456789),
-          Timestamp(7266, 0),
-          Timestamp(-50049331200, 0),
-          Timestamp(253405036800, 0),
-          Timestamp(-62480037600, 0),
-          std::nullopt,
-      },
-      {
-          "1940-01-02 00:00:00",
-          "1969-12-31 21:58:54",
-          "1970-01-01 00:00:00",
-          "2000-01-01 00:00:00",
-          "2269-12-29 00:00:00",
-          "4969-12-04 00:00:00",
-          "2000-01-01 12:21:56",
-          "2000-01-01 12:21:56",
-          "2000-01-01 12:21:56.1",
-          "2000-01-01 12:21:56.1299",
-          "2000-01-01 12:21:56.123456",
-          "1970-01-01 02:01:06",
-          "0384-01-01 08:00:00",
-          "+10000-02-01 16:00:00",
-          "-0010-02-01 10:00:00",
-          std::nullopt,
-      });
-
-  std::vector<std::optional<Timestamp>> input = {
-      Timestamp(-946684800, 0),
-      Timestamp(-7266, 0),
-      Timestamp(0, 0),
-      Timestamp(61, 10),
-      Timestamp(3600, 0),
-      Timestamp(946684800, 0),
-
-      Timestamp(946729316, 0),
-      Timestamp(946729316, 123),
-      Timestamp(946729316, 100000000),
-      Timestamp(946729316, 129900000),
-      Timestamp(946729316, 123456789),
-      Timestamp(7266, 0),
-      std::nullopt,
-  };
+TEST_F(SparkCastExprTestAnsiOff, truncate) {
+  testCast<int32_t, int8_t>(
+      "tinyint", {1111111, 2, 3, 1000, -100101}, {71, 2, 3, -24, -5});
+  testTruncate();
+}
 
-  setTimezone("America/Los_Angeles");
-  testCast<Timestamp, std::string>(
-      "string",
-      input,
-      {
-          "1940-01-01 16:00:00",
-          "1969-12-31 13:58:54",
-          "1969-12-31 16:00:00",
-          "1969-12-31 16:01:01",
-          "1969-12-31 17:00:00",
-          "1999-12-31 16:00:00",
-          "2000-01-01 04:21:56",
-          "2000-01-01 04:21:56",
-          "2000-01-01 04:21:56.1",
-          "2000-01-01 04:21:56.1299",
-          "2000-01-01 04:21:56.123456",
-          "1969-12-31 18:01:06",
-          std::nullopt,
-      });
-  setTimezone("Asia/Shanghai");
-  testCast<Timestamp, std::string>(
-      "string",
-      input,
-      {
-          "1940-01-02 08:00:00",
-          "1970-01-01 05:58:54",
-          "1970-01-01 08:00:00",
-          "1970-01-01 08:01:01",
-          "1970-01-01 09:00:00",
-          "2000-01-01 08:00:00",
-          "2000-01-01 20:21:56",
-          "2000-01-01 20:21:56",
-          "2000-01-01 20:21:56.1",
-          "2000-01-01 20:21:56.1299",
-          "2000-01-01 20:21:56.123456",
-          "1970-01-01 10:01:06",
-          std::nullopt,
-      });
+TEST_F(SparkCastExprTestAnsiOff, tryCasts) {
+  testTryCasts();
 }
+TEST_F(SparkCastExprTestAnsiOff, overflow) {
+  testOverflow();
 
-TEST_F(SparkCastExprTest, fromString) {
-  // String with leading and trailing whitespaces.
-  testCast<std::string, int8_t>(
-      "tinyint", {"\n\f\r\t\n\u001F 123\u000B\u001C\u001D\u001E"}, {123});
-  testCast<std::string, int32_t>(
-      "integer", {"\n\f\r\t\n\u001F 123\u000B\u001C\u001D\u001E"}, {123});
+  // String overflow cases return null in non-ANSI mode
+  testCast<std::string, int8_t>("tinyint", {"166"}, {std::nullopt});
+  testCast<std::string, int16_t>("smallint", {"52769"}, {std::nullopt});
+  testCast<std::string, int32_t>("integer", {"17515055537"}, {std::nullopt});
+  testCast<std::string, int32_t>("integer", {"-17515055537"}, {std::nullopt});
   testCast<std::string, int64_t>(
-      "bigint", {"\n\f\r\t\n\u001F 123\u000B\u001C\u001D\u001E"}, {123});
-  testCast<std::string, int32_t>(
-      "date",
-      {"\n\f\r\t\n\u001F 2015-03-18T\u000B\u001C\u001D\u001E"},
-      {16512},
-      VARCHAR(),
-      DATE());
-  testCast<std::string, float>(
-      "real", {"\n\f\r\t\n\u001F 123.0\u000B\u001C\u001D\u001E"}, {123.0});
-  testCast<std::string, double>(
-      "double", {"\n\f\r\t\n\u001F 123.0\u000B\u001C\u001D\u001E"}, {123.0});
-  testCast<std::string, Timestamp>(
-      "timestamp",
-      {"\n\f\r\t\n\u001F 2000-01-01 12:21:56\u000B\u001C\u001D\u001E"},
-      {Timestamp(946729316, 0)});
-  testCast(
-      makeFlatVector<StringView>(
-          {" 9999999999.99",
-           "9999999999.99 ",
-           "\n\f\r\t\n\u001F 9999999999.99\u000B\u001C\u001D\u001E",
-           " -3E+2",
-           "-3E+2 ",
-           "\u000B\u001C\u001D-3E+2\u001E\n\f\r\t\n\u001F "}),
-      makeFlatVector<int64_t>(
-          {999'999'999'999,
-           999'999'999'999,
-           999'999'999'999,
-           -30000,
-           -30000,
-           -30000},
-          DECIMAL(12, 2)));
-}
-
-TEST_F(SparkCastExprTest, tinyintToBinary) {
-  testCast<int8_t, std::string>(
-      TINYINT(),
-      VARBINARY(),
-      {18,
-       -26,
-       0,
-       110,
-       std::numeric_limits<int8_t>::max(),
-       std::numeric_limits<int8_t>::min()},
-      {std::string("\x12", 1),
-       std::string("\xE6", 1),
-       std::string("\0", 1),
-       std::string("\x6E", 1),
-       std::string("\x7F", 1),
-       std::string("\x80", 1)});
-}
-
-TEST_F(SparkCastExprTest, smallintToBinary) {
-  testCast<int16_t, std::string>(
-      SMALLINT(),
-      VARBINARY(),
-      {180,
-       -199,
-       0,
-       12300,
-       std::numeric_limits<int16_t>::max(),
-       std::numeric_limits<int16_t>::min()},
-      {std::string("\0\xB4", 2),
-       std::string("\xFF\x39", 2),
-       std::string("\0\0", 2),
-       std::string("\x30\x0C", 2),
-       std::string("\x7F\xFF", 2),
-       std::string("\x80\00", 2)});
-}
-
-TEST_F(SparkCastExprTest, integerToBinary) {
-  testCast<int32_t, std::string>(
-      INTEGER(),
-      VARBINARY(),
-      {18,
-       -26,
-       0,
-       180000,
-       std::numeric_limits<int32_t>::max(),
-       std::numeric_limits<int32_t>::min()},
-      {std::string("\0\0\0\x12", 4),
-       std::string("\xFF\xFF\xFF\xE6", 4),
-       std::string("\0\0\0\0", 4),
-       std::string("\0\x02\xBF\x20", 4),
-       std::string("\x7F\xFF\xFF\xFF", 4),
-       std::string("\x80\0\0\0", 4)});
-}
-
-TEST_F(SparkCastExprTest, bigintToBinary) {
-  testCast<int64_t, std::string>(
-      BIGINT(),
-      VARBINARY(),
-      {123456,
-       -256789,
-       0,
-       180000,
-       std::numeric_limits<int64_t>::max(),
-       std::numeric_limits<int64_t>::min()},
-      {std::string("\0\0\0\0\0\x01\xE2\x40", 8),
-       std::string("\xFF\xFF\xFF\xFF\xFF\xFC\x14\xEB", 8),
-       std::string("\0\0\0\0\0\0\0\0", 8),
-       std::string("\0\0\0\0\0\x02\xBF\x20", 8),
-       std::string("\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 8),
-       std::string("\x80\x00\x00\x00\x00\x00\x00\x00", 8)});
-}
-
-TEST_F(SparkCastExprTest, boolToTimestamp) {
-  testCast(
-      makeFlatVector<bool>({true, false}),
-      makeFlatVector<Timestamp>({
-          Timestamp(0, 1000),
-          Timestamp(0, 0),
-      }));
+      "bigint", {"9663372036854775809"}, {std::nullopt});
 }
 
-TEST_F(SparkCastExprTest, recursiveTryCast) {
-  // Test array elements.
-  testCast(
-      makeArrayVector<StringView>({
-          {"1", "2", "3"},
-          {"4", "a", "6"},
-          {"b", "c", "d"},
-      }),
-      makeNullableArrayVector<int64_t>({
-          {1, 2, 3},
-          {4, std::nullopt, 6},
-          {std::nullopt, std::nullopt, std::nullopt},
-      }));
-
-  // Test map values (Spark doesn't allow casting if the map keys can become
-  // null).
-  testCast(
-      makeMapVectorFromJson<int64_t, std::string>({
-          R"( {1:"1", 2:"2", 3:"3"} )",
-          R"( {1:"4", 2:"a", 3:"6"} )",
-          R"( {1:"b", 2:"c", 3:"d"} )",
-      }),
-      makeMapVectorFromJson<int64_t, int64_t>({
-          "{1:1, 2:2, 3:3}",
-          "{1:4, 2:null, 3:6}",
-          "{1:null, 2:null, 3:null}",
-      }));
-
-  // Test row fields.
-  testCast(
-      makeRowVector(
-          {makeFlatVector<StringView>({"1", "4", "b"}),
-           makeFlatVector<StringView>({"2", "a", "c"}),
-           makeFlatVector<StringView>({"3", "6", "d"})}),
-      makeRowVector(
-          {makeNullableFlatVector<int64_t>({1, 4, std::nullopt}),
-           makeNullableFlatVector<int64_t>({2, std::nullopt, std::nullopt}),
-           makeNullableFlatVector<int64_t>({3, 6, std::nullopt})}));
-
-  // Test nested arrays.
-  testCast(
-      makeNestedArrayVectorFromJson<std::string>({
-          R"( [["1", "2", "3"], ["4", "a", "6"]] )",
-          R"( [["b", "c", "d"], ["x", "7", "z"]] )",
-      }),
-      makeNestedArrayVectorFromJson<int64_t>({
-          "[[1, 2, 3], [4, null, 6]]",
-          "[[null, null, null], [null, 7, null]]",
-      }));
+TEST_F(SparkCastExprTestAnsiOff, recursiveTryCast) {
+  testRecursiveTryCast();
 }
-
 } // namespace
 } // namespace facebook::velox::test
diff --git a/velox/functions/sparksql/tests/ToJsonTest.cpp b/velox/functions/sparksql/tests/ToJsonTest.cpp
index 9ce1959cc20..dbcb54c256b 100644
--- a/velox/functions/sparksql/tests/ToJsonTest.cpp
+++ b/velox/functions/sparksql/tests/ToJsonTest.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/OptionalEmpty.h"
 #include "velox/functions/sparksql/tests/JsonTestUtil.h"
 
 using namespace facebook::velox::test;
@@ -53,9 +54,9 @@ TEST_F(ToJsonTest, basicStruct) {
 
 TEST_F(ToJsonTest, basicArray) {
   auto input = makeNullableArrayVector<int64_t>(
-      {{{1}},
-       {{2, std::nullopt, 3}},
-       {std::vector<std::optional<int64_t>>{}},
+      {std::vector<std::optional<int64_t>>{1},
+       std::vector<std::optional<int64_t>>{2, std::nullopt, 3},
+       common::testutil::optionalEmpty,
        std::nullopt});
   auto expected = makeNullableFlatVector<std::string>(
       {R"([1])", R"([2,null,3])", R"([])", std::nullopt});
@@ -65,20 +66,24 @@ TEST_F(ToJsonTest, basicArray) {
 TEST_F(ToJsonTest, basicMap) {
   // MAP(VARCHAR, BIGINT)
   auto input = makeNullableMapVector<std::string, int64_t>(
-      {{{{"a", 1}, {"b", 2}, {"c", 3}}},
+      {std::vector<std::pair<std::string, std::optional<int64_t>>>{
+           {"a", 1}, {"b", 2}, {"c", 3}},
        std::nullopt,
-       {std::vector<std::pair<std::string, std::optional<int64_t>>>{}},
-       {{{"a", 1}, {"b", std::nullopt}}}});
+       common::testutil::optionalEmpty,
+       std::vector<std::pair<std::string, std::optional<int64_t>>>{
+           {"a", 1}, {"b", std::nullopt}}});
   auto expected = makeNullableFlatVector<std::string>(
       {R"({"a":1,"b":2,"c":3})", std::nullopt, R"({})", R"({"a":1,"b":null})"});
   testToJson(input, expected);
 
   // MAP(BIGINT, VARCHAR)
   input = makeNullableMapVector<int64_t, std::string>(
-      {{{{1, "a"}, {2, "b"}, {3, "c"}}},
+      {std::vector<std::pair<int64_t, std::optional<std::string>>>{
+           {1, "a"}, {2, "b"}, {3, "c"}},
        std::nullopt,
-       {std::vector<std::pair<int64_t, std::optional<std::string>>>{}},
-       {{{1, "a"}, {2, std::nullopt}}}});
+       common::testutil::optionalEmpty,
+       std::vector<std::pair<int64_t, std::optional<std::string>>>{
+           {1, "a"}, {2, std::nullopt}}});
   expected = makeNullableFlatVector<std::string>(
       {R"({"1":"a","2":"b","3":"c"})",
        std::nullopt,
@@ -284,10 +289,10 @@ TEST_F(ToJsonTest, nestedMap) {
   auto data1 = makeNullableFlatVector<int32_t>(
       {0, 18321, -25567, 2932896, std::nullopt}, DateType::get());
   auto data2 = makeNullableArrayVector<std::string>(
-      {{{"a", "b", std::nullopt}},
-       {std::vector<std::optional<std::string>>{}},
-       {{"d", "e"}},
-       {{"f", std::nullopt, "h"}},
+      {std::vector<std::optional<std::string>>{"a", "b", std::nullopt},
+       common::testutil::optionalEmpty,
+       std::vector<std::optional<std::string>>{"d", "e"},
+       std::vector<std::optional<std::string>>{"f", std::nullopt, "h"},
        std::nullopt});
   auto data3 = makeNullableFlatVector<double>(
       {1.0, kNaNDouble, kInfDouble, -kInfDouble, std::nullopt});
diff --git a/velox/functions/sparksql/tests/ToPrettyStringTest.cpp b/velox/functions/sparksql/tests/ToPrettyStringTest.cpp
new file mode 100644
index 00000000000..f260c673fe0
--- /dev/null
+++ b/velox/functions/sparksql/tests/ToPrettyStringTest.cpp
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <string>
+
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+namespace facebook::velox::functions::sparksql::test {
+class ToPrettyStringTest : public SparkFunctionBaseTest {
+ protected:
+  template <typename T>
+  std::optional<std::string> toPrettyString(std::optional<T> arg) {
+    return evaluateOnce<std::string>("to_pretty_string(c0)", arg);
+  }
+
+  template <TypeKind KIND>
+  void testDecimalExpr(
+      const VectorPtr& expected,
+      const std::string& expression,
+      const std::vector<VectorPtr>& input) {
+    using EvalType = typename velox::TypeTraits<KIND>::NativeType;
+    auto result =
+        evaluate<SimpleVector<EvalType>>(expression, makeRowVector(input));
+    velox::test::assertEqualVectors(expected, result);
+  }
+
+  void setQueryTimeZone(const std::string& timeZone) {
+    queryCtx_->testingOverrideConfigUnsafe({
+        {core::QueryConfig::kSessionTimezone, timeZone},
+        {core::QueryConfig::kAdjustTimestampToTimezone, "true"},
+    });
+  }
+
+  const std::string kNull = "NULL";
+};
+
+TEST_F(ToPrettyStringTest, toPrettyStringTest) {
+  EXPECT_EQ(toPrettyString<int8_t>(1), "1");
+  EXPECT_EQ(toPrettyString<int16_t>(1), "1");
+  EXPECT_EQ(toPrettyString<int32_t>(1), "1");
+  EXPECT_EQ(toPrettyString<int64_t>(1), "1");
+  EXPECT_EQ(toPrettyString<float>(1.0), "1.0");
+  EXPECT_EQ(toPrettyString<double>(1.0), "1.0");
+  EXPECT_EQ(toPrettyString<bool>(true), "true");
+  EXPECT_EQ(toPrettyString<StringView>("str"), "str");
+  EXPECT_EQ(
+      toPrettyString<StringView>("str_is_not_inline"), "str_is_not_inline");
+  EXPECT_EQ(toPrettyString<int8_t>(std::nullopt), kNull);
+}
+
+TEST_F(ToPrettyStringTest, date) {
+  EXPECT_EQ(
+      evaluateOnce<std::string>(
+          "to_pretty_string(c0)", DATE(), std::optional<int32_t>(18262)),
+      "2020-01-01");
+}
+
+TEST_F(ToPrettyStringTest, binary) {
+  auto toPrettyStringBinary = [&](const std::optional<std::string>& input) {
+    return evaluateOnce<std::string>("to_pretty_string(c0)", VARBINARY(), input)
+        .value();
+  };
+
+  EXPECT_EQ(toPrettyStringBinary("abcdef"), "[61 62 63 64 65 66]");
+
+  EXPECT_EQ(toPrettyStringBinary("ABC."), "[41 42 43 2E]");
+}
+
+TEST_F(ToPrettyStringTest, timestamp) {
+  EXPECT_EQ(
+      toPrettyString<Timestamp>(Timestamp(946729316, 123)),
+      "2000-01-01 12:21:56");
+
+  setQueryTimeZone("America/Los_Angeles");
+  EXPECT_EQ(
+      toPrettyString<Timestamp>(Timestamp(946729316, 123)),
+      "2000-01-01 04:21:56");
+
+  EXPECT_EQ(toPrettyString<Timestamp>(std::nullopt), kNull);
+}
+
+TEST_F(ToPrettyStringTest, decimal) {
+  testDecimalExpr<TypeKind::VARCHAR>(
+      {makeFlatVector<StringView>({"0.123", "0.552", "0.000"})},
+      "to_pretty_string(c0)",
+      {makeFlatVector<int64_t>({123, 552, 0}, DECIMAL(3, 3))});
+
+  testDecimalExpr<TypeKind::VARCHAR>(
+      {makeFlatVector<StringView>(
+          {"12345678901234.56789",
+           "55555555555555.55555",
+           "0.00000",
+           StringView(kNull)})},
+      "to_pretty_string(c0)",
+      {makeNullableFlatVector<int128_t>(
+          {1234567890123456789, 5555555555555555555, 0, std::nullopt},
+          DECIMAL(19, 5))});
+}
+
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/TransformTest.cpp b/velox/functions/sparksql/tests/TransformTest.cpp
new file mode 100644
index 00000000000..b623f17f6f2
--- /dev/null
+++ b/velox/functions/sparksql/tests/TransformTest.cpp
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+using namespace facebook::velox::test;
+
+class TransformTest : public SparkFunctionBaseTest {
+ protected:
+  void testTransform(
+      const std::string& expression,
+      const VectorPtr& input,
+      const VectorPtr& expected) {
+    auto result = evaluate(expression, makeRowVector({input}));
+    assertEqualVectors(expected, result);
+  }
+};
+
+// Test transform with element-only lambda: transform(array, x -> x * 2).
+TEST_F(TransformTest, elementOnly) {
+  auto input = makeArrayVectorFromJson<int64_t>({
+      "[1, 2, 3]",
+      "[4, 5]",
+      "[6]",
+      "[]",
+      "null",
+  });
+
+  auto expected = makeArrayVectorFromJson<int64_t>({
+      "[2, 4, 6]",
+      "[8, 10]",
+      "[12]",
+      "[]",
+      "null",
+  });
+
+  testTransform("transform(c0, x -> x * 2)", input, expected);
+}
+
+// Test transform with element-only lambda containing null elements.
+TEST_F(TransformTest, elementOnlyWithNulls) {
+  auto input = makeArrayVectorFromJson<int64_t>({
+      "[1, null, 3]",
+      "[null, null]",
+      "[4, 5, null]",
+  });
+
+  auto expected = makeArrayVectorFromJson<int64_t>({
+      "[2, null, 6]",
+      "[null, null]",
+      "[8, 10, null]",
+  });
+
+  testTransform("transform(c0, x -> x * 2)", input, expected);
+}
+
+// Test transform with element + index lambda: transform(array, (x, i) -> x + i)
+TEST_F(TransformTest, elementWithIndex) {
+  auto input = makeArrayVectorFromJson<int64_t>({
+      "[10, 20, 30]",
+      "[100, 200]",
+      "[1000]",
+      "[]",
+      "null",
+  });
+
+  // Expected: element + index
+  // [10+0, 20+1, 30+2] = [10, 21, 32]
+  // [100+0, 200+1] = [100, 201]
+  // [1000+0] = [1000]
+  // [] = []
+  // null = null
+  auto expected = makeArrayVectorFromJson<int64_t>({
+      "[10, 21, 32]",
+      "[100, 201]",
+      "[1000]",
+      "[]",
+      "null",
+  });
+
+  testTransform("transform(c0, (x, i) -> add(x, i))", input, expected);
+}
+
+// Test transform with index-only usage: transform(array, (x, i) -> i)
+TEST_F(TransformTest, indexOnly) {
+  auto input = makeArrayVectorFromJson<int64_t>({
+      "[100, 200, 300]",
+      "[1, 2]",
+      "[42]",
+      "[]",
+  });
+
+  // Expected: just the indices (as INTEGER/int32, matching Spark's IntegerType)
+  auto expected = makeArrayVectorFromJson<int32_t>({
+      "[0, 1, 2]",
+      "[0, 1]",
+      "[0]",
+      "[]",
+  });
+
+  testTransform("transform(c0, (x, i) -> i)", input, expected);
+}
+
+// Test transform with index and null elements.
+TEST_F(TransformTest, elementWithIndexAndNulls) {
+  auto input = makeArrayVectorFromJson<int64_t>({
+      "[1, null, 3]",
+      "[null, 5]",
+  });
+
+  // Expected: element + index, null elements stay null
+  // [1+0, null, 3+2] = [1, null, 5]
+  // [null, 5+1] = [null, 6]
+  auto expected = makeArrayVectorFromJson<int64_t>({
+      "[1, null, 5]",
+      "[null, 6]",
+  });
+
+  testTransform("transform(c0, (x, i) -> add(x, i))", input, expected);
+}
+
+// Test transform with index multiplication.
+TEST_F(TransformTest, indexMultiplication) {
+  auto input = makeArrayVectorFromJson<int64_t>({
+      "[1, 2, 3, 4]",
+      "[10, 20]",
+  });
+
+  // Expected: element * (index + 1)
+  // [1*1, 2*2, 3*3, 4*4] = [1, 4, 9, 16]
+  // [10*1, 20*2] = [10, 40]
+  auto expected = makeArrayVectorFromJson<int64_t>({
+      "[1, 4, 9, 16]",
+      "[10, 40]",
+  });
+
+  testTransform(
+      "transform(c0, (x, i) -> multiply(x, add(i, 1)))", input, expected);
+}
+
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/UpperLowerTest.cpp b/velox/functions/sparksql/tests/UpperLowerTest.cpp
index 6484348e831..57b9739be64 100644
--- a/velox/functions/sparksql/tests/UpperLowerTest.cpp
+++ b/velox/functions/sparksql/tests/UpperLowerTest.cpp
@@ -83,6 +83,25 @@ TEST_F(UpperLowerTest, lowerGreek) {
   EXPECT_EQ("πασdž", lower("ΠΑΣDž"));
   EXPECT_EQ("πασσ", lower("ΠΑΣσ"));
   EXPECT_EQ("πασд", lower("ΠΑΣД"));
+  // Σ not preceded by a cased character.
+  EXPECT_EQ("hello σ", lower("hello Σ"));
+  EXPECT_EQ("hello σ world", lower("hello Σ world"));
+  EXPECT_EQ("ab σ", lower("ab Σ"));
+  EXPECT_EQ("   σ", lower("   Σ"));
+  EXPECT_EQ("σ", lower("Σ"));
+  EXPECT_EQ("中文σ", lower("中文Σ"));
+  EXPECT_EQ("ab中σ中", lower("ab中Σ中"));
+  // Σ preceded by a cased character.
+  EXPECT_EQ("abς中", lower("abΣ中"));
+  EXPECT_EQ("abς<", lower("abΣ<"));
+  EXPECT_EQ("hello'ς", lower("hello'Σ"));
+  EXPECT_EQ("hello.ς", lower("hello.Σ"));
+  EXPECT_EQ("a\u0301ς", lower("a\u0301Σ"));
+  EXPECT_EQ("σσς", lower("ΣΣΣ"));
+  EXPECT_EQ("aσbς", lower("aΣbΣ"));
+  EXPECT_EQ("helloς", lower("helloΣ"));
+  // Σ preceded by CJK character which breaks the cased chain → σ
+  EXPECT_EQ("汉字σ!", lower("汉字Σ!"));
 }
 
 TEST_F(UpperLowerTest, upperAscii) {
diff --git a/velox/functions/sparksql/tests/XORShiftRandomTest.cpp b/velox/functions/sparksql/tests/XORShiftRandomTest.cpp
new file mode 100644
index 00000000000..f066f3fbefe
--- /dev/null
+++ b/velox/functions/sparksql/tests/XORShiftRandomTest.cpp
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/lib/XORShiftRandom.h"
+
+#include <gtest/gtest.h>
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+using facebook::velox::functions::XORShiftRandom;
+
+class XORShiftRandomTest : public testing::Test {};
+
+// Character pool matching Spark's randstr implementation.
+constexpr char kPool[] =
+    "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+constexpr int kPoolSize = 62;
+
+// Helper to generate randstr output using XORShiftRandom.
+// Matches Spark's ExpressionImplUtils.randStr implementation.
+std::string generateRandStr(int64_t seed, int32_t length) {
+  XORShiftRandom rng;
+  rng.setSeed(seed);
+  std::string result(length, '\0');
+  for (int32_t i = 0; i < length; ++i) {
+    // Spark uses Math.abs(rng.nextInt() % 62) to select characters.
+    int v = std::abs(rng.nextInt() % 62);
+    if (v < 10) {
+      result[i] = '0' + v;
+    } else if (v < 36) {
+      result[i] = 'a' + (v - 10);
+    } else {
+      result[i] = 'A' + (v - 36);
+    }
+  }
+  return result;
+}
+
+// Test that XORShiftRandom produces the same results as Spark's XORShiftRandom.
+// Expected values from Spark's RandomSuite.scala:
+// - randstr(1, 0) = "c"
+// - randstr(5, 0) = "ceV0P"
+// - randstr(10, 0) = "ceV0PXaR2I"
+TEST_F(XORShiftRandomTest, sparkCompatibility) {
+  EXPECT_EQ(generateRandStr(0, 1), "c");
+  EXPECT_EQ(generateRandStr(0, 5), "ceV0P");
+  EXPECT_EQ(generateRandStr(0, 10), "ceV0PXaR2I");
+}
+
+// Test determinism: same seed produces same sequence.
+TEST_F(XORShiftRandomTest, determinism) {
+  XORShiftRandom rng1, rng2;
+  rng1.setSeed(12345);
+  rng2.setSeed(12345);
+
+  for (int i = 0; i < 100; ++i) {
+    EXPECT_EQ(rng1.nextInt(1000), rng2.nextInt(1000));
+  }
+}
+
+// Test that different seeds produce different sequences.
+TEST_F(XORShiftRandomTest, differentSeeds) {
+  XORShiftRandom rng1, rng2;
+  rng1.setSeed(1);
+  rng2.setSeed(2);
+
+  // Collect first 10 values from each
+  std::vector<int32_t> seq1, seq2;
+  for (int i = 0; i < 10; ++i) {
+    seq1.push_back(rng1.nextInt(1000));
+    seq2.push_back(rng2.nextInt(1000));
+  }
+
+  // Sequences should differ
+  EXPECT_NE(seq1, seq2);
+}
+
+// Test bound parameter works correctly.
+TEST_F(XORShiftRandomTest, boundParameter) {
+  XORShiftRandom rng;
+  rng.setSeed(42);
+
+  for (int i = 0; i < 1000; ++i) {
+    int32_t val = rng.nextInt(10);
+    EXPECT_GE(val, 0);
+    EXPECT_LT(val, 10);
+  }
+}
+
+// Test nextDouble() returns values in [0.0, 1.0) range.
+TEST_F(XORShiftRandomTest, nextDoubleRange) {
+  XORShiftRandom rng;
+  rng.setSeed(42);
+
+  for (int i = 0; i < 1000; ++i) {
+    double val = rng.nextDouble();
+    EXPECT_GE(val, 0.0);
+    EXPECT_LT(val, 1.0);
+  }
+}
+
+// Test nextDouble() determinism: same seed produces same sequence.
+TEST_F(XORShiftRandomTest, nextDoubleDeterminism) {
+  XORShiftRandom rng1, rng2;
+  rng1.setSeed(12345);
+  rng2.setSeed(12345);
+
+  for (int i = 0; i < 100; ++i) {
+    EXPECT_EQ(rng1.nextDouble(), rng2.nextDouble());
+  }
+}
+
+// Test nextDouble() produces different sequences for different seeds.
+TEST_F(XORShiftRandomTest, nextDoubleDifferentSeeds) {
+  XORShiftRandom rng1, rng2;
+  rng1.setSeed(1);
+  rng2.setSeed(2);
+
+  std::vector<double> seq1, seq2;
+  for (int i = 0; i < 10; ++i) {
+    seq1.push_back(rng1.nextDouble());
+    seq2.push_back(rng2.nextDouble());
+  }
+
+  EXPECT_NE(seq1, seq2);
+}
+
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/XxHash64Test.cpp b/velox/functions/sparksql/tests/XxHash64Test.cpp
index c375a7a1d30..75aa3de0870 100644
--- a/velox/functions/sparksql/tests/XxHash64Test.cpp
+++ b/velox/functions/sparksql/tests/XxHash64Test.cpp
@@ -184,8 +184,9 @@ TEST_F(XxHash64Test, array) {
 
   assertEqualVectors(
       makeFlatVector<int64_t>({-6698625589789238999, 8420071140774656230, 42}),
-      xxhash64(makeNullableArrayVector<int32_t>(
-          {{1, std::nullopt}, {std::nullopt, 2}, {std::nullopt}})));
+      xxhash64(
+          makeNullableArrayVector<int32_t>(
+              {{1, std::nullopt}, {std::nullopt, 2}, {std::nullopt}})));
 
   // Nested array.
   {
@@ -286,10 +287,11 @@ TEST_F(XxHash64Test, unknown) {
 
   assertEqualVectors(
       makeFlatVector<int64_t>({42, 42}),
-      xxhash64(makeNullableArrayVector<UnknownValue>({
-          {std::nullopt, std::nullopt},
-          {std::nullopt, std::nullopt, std::nullopt},
-      })));
+      xxhash64(
+          makeNullableArrayVector<UnknownValue>({
+              {std::nullopt, std::nullopt},
+              {std::nullopt, std::nullopt, std::nullopt},
+          })));
 
   auto mapVector = makeNullableMapVector<UnknownValue, UnknownValue>({
       std::nullopt,
diff --git a/velox/functions/sparksql/window/CMakeLists.txt b/velox/functions/sparksql/window/CMakeLists.txt
index 124363f8ece..79c298744db 100644
--- a/velox/functions/sparksql/window/CMakeLists.txt
+++ b/velox/functions/sparksql/window/CMakeLists.txt
@@ -11,7 +11,12 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-velox_add_library(velox_functions_spark_window WindowFunctionsRegistration.cpp)
+velox_add_library(
+  velox_functions_spark_window
+  WindowFunctionsRegistration.cpp
+  HEADERS
+  WindowFunctionsRegistration.h
+)
 
 velox_link_libraries(
   velox_functions_spark_window
diff --git a/velox/functions/sparksql/window/tests/CMakeLists.txt b/velox/functions/sparksql/window/tests/CMakeLists.txt
index 84526d933e1..6f5c5197255 100644
--- a/velox/functions/sparksql/window/tests/CMakeLists.txt
+++ b/velox/functions/sparksql/window/tests/CMakeLists.txt
@@ -17,6 +17,7 @@ set(
   velox_core
   velox_exec
   velox_exec_test_lib
+  velox_functions_spark_aggregates
   velox_functions_spark_window
   velox_functions_window_test_lib
   velox_vector_fuzzer
diff --git a/velox/functions/sparksql/window/tests/SparkWindowTest.cpp b/velox/functions/sparksql/window/tests/SparkWindowTest.cpp
index 92478c7bcf1..9ab312b3bfe 100644
--- a/velox/functions/sparksql/window/tests/SparkWindowTest.cpp
+++ b/velox/functions/sparksql/window/tests/SparkWindowTest.cpp
@@ -14,7 +14,10 @@
  * limitations under the License.
  */
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/functions/lib/window/tests/WindowTestBase.h"
+#include "velox/functions/sparksql/aggregates/Register.h"
 #include "velox/functions/sparksql/window/WindowFunctionsRegistration.h"
 
 using namespace facebook::velox::exec::test;
@@ -106,5 +109,98 @@ VELOX_INSTANTIATE_TEST_SUITE_P(
     SparkWindowTest,
     testing::ValuesIn(getSparkWindowTestParams()));
 
+class SparkAggregateWindowLimitMemoryTest
+    : public exec::test::OperatorTestBase {
+ public:
+  static void SetUpTestCase() {
+    OperatorTestBase::SetUpTestCase();
+    OperatorTestBase::setupMemory(
+        192 << 20, // allocatorCapacity
+        192 << 20, // arbitratorCapacity
+        0, // arbitratorReservedCapacity
+        0, // memoryPoolInitCapacity
+        0, // memoryPoolReservedCapacity
+        0, // memoryPoolMinReclaimBytes
+        0 // memoryPoolAbortCapacityLimit
+    );
+  }
+
+  void SetUp() override {
+    exec::test::OperatorTestBase::SetUp();
+    velox::functions::aggregate::sparksql::registerAggregateFunctions("");
+  }
+};
+
+// This test limits the memory capacity to check that string buffers are cleared
+// in time during the aggregation window function processing.
+// Without timely clearing the string buffers, the memory usage would exceed
+// the limit and cause failure.
+// The capacity is calculated as:
+//   1. size of input data: 1 rows * 32KB (the length of the string) = 32KB
+//   2. size of RowContainer: ((1,024 rows * 32KB (data))) * 3 +
+//   32KB(Accumulator) = 96MB
+//      (Accumulators will be destroyed when processing a new partition.)
+//   3. size of results: 10 rows * 32KB * 2 (column 'd' and the result column) =
+//      640KB
+//   4. other overheads
+//    Total: ~ 96MB
+// If we don't clear the string buffers in time, the size of the string buffers
+// would be at least 1,024 rows * 32KB * 3 = 96MB. If we don't destroy the
+// previously created accumulator, the memory size of accumulators accumulated
+// will be (32KB * 1024 rows * 3) = 96MB. So without the fix, we need capacity
+// to be set to more than 96MB + 96MB + 96MB = 288MB to pass the test. We set
+// the capacity to 192MB here to verify that our fixes work.
+TEST_F(
+    SparkAggregateWindowLimitMemoryTest,
+    clearStringBuffersAndAccumulatorsInTime) {
+  constexpr vector_size_t size = 1'024 * 3;
+  constexpr vector_size_t resultSize = 10;
+  // For this test, it is important to create a single-row partition.
+  // When we process a new partition, we will call 'fillArgVectors' in
+  // 'AggregateWindow'. Single-row partition can let us call 'fillArgVectors' as
+  // many as possible. If we don't call 'prepareForReuse' in 'fillArgVectors',
+  // the string buffers will accumulate and cause high memory usage.
+  auto data = makeRowVector(
+      {"d", "p"},
+      {// Payload Data.
+       makeConstant(std::string(32 * 1024, 'a'), size),
+       // Partition key.
+       makeFlatVector<int16_t>(size, [](auto row) { return row; })});
+
+  createDuckDbTable({data});
+
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .streamingWindow({"first(d) over (partition by p)"})
+                  // We use LIMIT clause here to limit the result size to limit
+                  // the memory consumed by results.
+                  // Besides, we set offset to 'size - resultSize' to make the
+                  // Window operator process all window partitions. In this way,
+                  // if we don't clear the string buffers during the window
+                  // function processing, the string buffers would accumulate to
+                  // cause high memory usage.
+                  // TODO: remove the use of LIMIT clause
+                  // after fixing
+                  // https://github.com/facebookincubator/velox/issues/16210
+                  .limit(size - resultSize, resultSize, true)
+                  .planNode();
+
+  const auto realResultSize =
+      AssertQueryBuilder(plan)
+          .serialExecution(true)
+          // Because we set offset to 'size - resultSize' in the LIMIT clause,
+          // the Window operator will produce intermediate results that will be
+          // discarded by LIMIT clause.
+          // Set preferred output batch rows to 10 to limit the memory
+          // consumed by these intermediate results.
+          // By limiting the memory consumed by input and intermediate results,
+          // we can know that the reason why we can pass this test is that we
+          // clear the string buffers in time during the window function
+          // processing.
+          .config(core::QueryConfig::kPreferredOutputBatchRows, resultSize)
+          .countResults();
+  ASSERT_EQ(realResultSize, resultSize);
+}
+
 } // namespace
 } // namespace facebook::velox::window::test
diff --git a/velox/functions/tests/CMakeLists.txt b/velox/functions/tests/CMakeLists.txt
index f81597f3f30..87445ad0824 100644
--- a/velox/functions/tests/CMakeLists.txt
+++ b/velox/functions/tests/CMakeLists.txt
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 add_executable(velox_function_registry_test FunctionRegistryTest.cpp)
+velox_add_test_headers(velox_function_registry_test RegistryTestUtil.h)
 
 add_test(NAME velox_function_registry_test COMMAND velox_function_registry_test)
 
diff --git a/velox/functions/tests/DynamicTypeFuncDemo.cpp b/velox/functions/tests/DynamicTypeFuncDemo.cpp
index 1e656e51de0..b79920cc099 100644
--- a/velox/functions/tests/DynamicTypeFuncDemo.cpp
+++ b/velox/functions/tests/DynamicTypeFuncDemo.cpp
@@ -137,7 +137,8 @@ void runDynamicTypeTest(
   std::shared_ptr<core::QueryCtx> queryCtx{core::QueryCtx::create()};
   core::ExecCtx execCtx{pool, queryCtx.get()};
   SelectivityVector rows(elementSize);
-  auto untypedExpr = parse::parseExpr("dynamic_row_udf(c0)", {});
+  auto untypedExpr =
+      parse::DuckSqlExpressionsParser().parseExpr("dynamic_row_udf(c0)");
   auto parsedExpr =
       core::Expressions::inferTypes(untypedExpr, inputVector->type(), pool);
   exec::ExprSet exprSet({parsedExpr}, &execCtx);
diff --git a/velox/functions/tests/FunctionRegistryTest.cpp b/velox/functions/tests/FunctionRegistryTest.cpp
index a2c88e09d1b..eb82368afdd 100644
--- a/velox/functions/tests/FunctionRegistryTest.cpp
+++ b/velox/functions/tests/FunctionRegistryTest.cpp
@@ -104,7 +104,8 @@ class FunctionRegistryTest : public testing::Test {
     VELOX_EXPECT_EQ_TYPES(type, expected);
 
     std::vector<TypePtr> coercions;
-    type = resolveFunctionWithCoercions(functionName, types, coercions);
+    type = resolveFunctionWithCoercions(
+        functionName, types, coercions, TypeCoercer::defaults());
     VELOX_EXPECT_EQ_TYPES(type, expected);
 
     if (expected != nullptr) {
@@ -115,16 +116,62 @@ class FunctionRegistryTest : public testing::Test {
     }
   }
 
-  void testCoercions(
+  struct ResolveFuncs {
+    std::function<TypePtr(const std::string&, const std::vector<TypePtr>&)>
+        resolveFunc;
+
+    std::function<TypePtr(
+        const std::string&,
+        const std::vector<TypePtr>&,
+        std::vector<TypePtr>&)>
+        resolveWithCoercionsFunc;
+
+    static ResolveFuncs function() {
+      return {
+          .resolveFunc = resolveFunction,
+          .resolveWithCoercionsFunc = [](const auto& name,
+                                         const auto& argTypes,
+                                         auto& coercions) -> TypePtr {
+            return resolveFunctionWithCoercions(
+                name, argTypes, coercions, TypeCoercer::defaults());
+          },
+      };
+    }
+
+    static ResolveFuncs specialForm() {
+      return {
+          .resolveFunc = [](const auto& name, const auto& argTypes) -> TypePtr {
+            try {
+              return resolveCallableSpecialForm(name, argTypes);
+            } catch (const VeloxException&) {
+              return nullptr;
+            }
+          },
+          .resolveWithCoercionsFunc = [](const auto& name,
+                                         const auto& argTypes,
+                                         auto& coercions) -> TypePtr {
+            try {
+              return resolveCallableSpecialFormWithCoercions(
+                  name, argTypes, coercions, TypeCoercer::defaults());
+            } catch (const VeloxException&) {
+              return nullptr;
+            }
+          },
+      };
+    }
+  };
+
+  void testCoercionsInt(
       const std::string& name,
       const std::vector<TypePtr>& argTypes,
+      const ResolveFuncs& resolveFuncs,
       const TypePtr& expectedReturnType,
       const std::vector<TypePtr>& expectedCoercions) {
-    auto type = resolveFunction(name, argTypes);
+    auto type = resolveFuncs.resolveFunc(name, argTypes);
     ASSERT_TRUE(type == nullptr);
 
     std::vector<TypePtr> coercions;
-    type = resolveFunctionWithCoercions(name, argTypes, coercions);
+    type = resolveFuncs.resolveWithCoercionsFunc(name, argTypes, coercions);
 
     VELOX_EXPECT_EQ_TYPES(type, expectedReturnType);
 
@@ -133,9 +180,10 @@ class FunctionRegistryTest : public testing::Test {
 
     for (auto i = 0; i < coercions.size(); ++i) {
       if (expectedCoercions[i] == nullptr) {
-        EXPECT_EQ(coercions[i], nullptr);
+        EXPECT_EQ(coercions[i], nullptr) << "Expected no coercion at " << i
+                                         << ": " << coercions[i]->toString();
       } else {
-        ASSERT_NE(coercions[i], nullptr);
+        ASSERT_NE(coercions[i], nullptr) << "at " << i;
         EXPECT_EQ(*coercions[i], *expectedCoercions[i])
             << "Expected: " << expectedCoercions[i]->toString()
             << ", but got: " << coercions[i]->toString();
@@ -143,15 +191,16 @@ class FunctionRegistryTest : public testing::Test {
     }
   }
 
-  void testNoCoercions(
+  void testNoCoercionsInt(
       const std::string& name,
       const std::vector<TypePtr>& argTypes,
+      const ResolveFuncs& resolveFuncs,
       const TypePtr& expectedReturnType) {
-    auto type = resolveFunction(name, argTypes);
+    auto type = resolveFuncs.resolveFunc(name, argTypes);
     VELOX_EXPECT_EQ_TYPES(type, expectedReturnType);
 
     std::vector<TypePtr> coercions;
-    type = resolveFunctionWithCoercions(name, argTypes, coercions);
+    type = resolveFuncs.resolveWithCoercionsFunc(name, argTypes, coercions);
 
     VELOX_EXPECT_EQ_TYPES(type, expectedReturnType);
 
@@ -161,17 +210,72 @@ class FunctionRegistryTest : public testing::Test {
     }
   }
 
-  void testCannotResolve(
+  void testCannotResolveInt(
       const std::string& name,
-      const std::vector<TypePtr>& argTypes) {
-    auto type = resolveFunction(name, argTypes);
+      const std::vector<TypePtr>& argTypes,
+      const ResolveFuncs& resolveFuncs) {
+    auto type = resolveFuncs.resolveFunc(name, argTypes);
     ASSERT_TRUE(type == nullptr);
 
     std::vector<TypePtr> coercions;
-    type = resolveFunctionWithCoercions(name, argTypes, coercions);
+    type = resolveFuncs.resolveWithCoercionsFunc(name, argTypes, coercions);
     ASSERT_TRUE(type == nullptr);
   }
 
+  void testCoercions(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes,
+      const TypePtr& expectedReturnType,
+      const std::vector<TypePtr>& expectedCoercions) {
+    testCoercionsInt(
+        name,
+        argTypes,
+        ResolveFuncs::function(),
+        expectedReturnType,
+        expectedCoercions);
+  }
+
+  void testNoCoercions(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes,
+      const TypePtr& expectedReturnType) {
+    testNoCoercionsInt(
+        name, argTypes, ResolveFuncs::function(), expectedReturnType);
+  }
+
+  void testCannotResolve(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes) {
+    testCannotResolveInt(name, argTypes, ResolveFuncs::function());
+  }
+
+  void testSpecialFormCoercions(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes,
+      const TypePtr& expectedReturnType,
+      const std::vector<TypePtr>& expectedCoercions) {
+    testCoercionsInt(
+        name,
+        argTypes,
+        ResolveFuncs::specialForm(),
+        expectedReturnType,
+        expectedCoercions);
+  }
+
+  void testSpecialFormNoCoercions(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes,
+      const TypePtr& expectedReturnType) {
+    testNoCoercionsInt(
+        name, argTypes, ResolveFuncs::specialForm(), expectedReturnType);
+  }
+
+  void testSpecialFormCannotResolve(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes) {
+    testCannotResolveInt(name, argTypes, ResolveFuncs::specialForm());
+  }
+
   exec::FunctionSignaturePtr makeSignature(
       const std::string& returnType,
       const std::vector<std::string>& argTypes) {
@@ -184,6 +288,60 @@ class FunctionRegistryTest : public testing::Test {
 
     return builder.build();
   }
+
+  void testVectorFunctionWithMetadataCoercions(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes,
+      const TypePtr& expectedReturnType,
+      const std::vector<TypePtr>& expectedCoercions,
+      bool expectedDeterministic) {
+    std::vector<TypePtr> coercions;
+    auto result = resolveVectorFunctionWithMetadataWithCoercions(
+        name, argTypes, coercions, TypeCoercer::defaults());
+    ASSERT_TRUE(result.has_value());
+    VELOX_EXPECT_EQ_TYPES(result->first, expectedReturnType);
+    EXPECT_EQ(result->second.deterministic, expectedDeterministic);
+
+    EXPECT_EQ(coercions.size(), expectedCoercions.size());
+    for (auto i = 0; i < coercions.size(); ++i) {
+      if (expectedCoercions[i] == nullptr) {
+        EXPECT_EQ(coercions[i], nullptr) << "Expected no coercion at " << i
+                                         << ": " << coercions[i]->toString();
+      } else {
+        ASSERT_NE(coercions[i], nullptr) << "at " << i;
+        EXPECT_EQ(*coercions[i], *expectedCoercions[i])
+            << "Expected: " << expectedCoercions[i]->toString()
+            << ", but got: " << coercions[i]->toString();
+      }
+    }
+  }
+
+  void testVectorFunctionWithMetadataNoCoercions(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes,
+      const TypePtr& expectedReturnType,
+      bool expectedDeterministic) {
+    std::vector<TypePtr> coercions;
+    auto result = resolveVectorFunctionWithMetadataWithCoercions(
+        name, argTypes, coercions, TypeCoercer::defaults());
+    ASSERT_TRUE(result.has_value());
+    VELOX_EXPECT_EQ_TYPES(result->first, expectedReturnType);
+    EXPECT_EQ(result->second.deterministic, expectedDeterministic);
+
+    EXPECT_EQ(coercions.size(), argTypes.size());
+    for (const auto& coercion : coercions) {
+      EXPECT_EQ(coercion, nullptr);
+    }
+  }
+
+  void testVectorFunctionWithMetadataCannotResolve(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes) {
+    std::vector<TypePtr> coercions;
+    auto result = resolveVectorFunctionWithMetadataWithCoercions(
+        name, argTypes, coercions, TypeCoercer::defaults());
+    EXPECT_FALSE(result.has_value());
+  }
 };
 
 TEST_F(FunctionRegistryTest, removeFunction) {
@@ -503,6 +661,23 @@ TEST_F(FunctionRegistryTest, isDeterministic) {
   ASSERT_FALSE(isDeterministic("not_found_function").has_value());
 }
 
+TEST_F(FunctionRegistryTest, isDefaultNullBehavior) {
+  functions::prestosql::registerAllScalarFunctions();
+
+  // Functions with default null behavior.
+  ASSERT_TRUE(isDefaultNullBehavior("eq").value());
+  ASSERT_TRUE(isDefaultNullBehavior("plus").value());
+  ASSERT_TRUE(isDefaultNullBehavior("substr").value());
+
+  // Functions with non-default null behavior.
+  ASSERT_FALSE(isDefaultNullBehavior("distinct_from").value());
+  ASSERT_FALSE(isDefaultNullBehavior("in").value());
+
+  // Not found functions.
+  ASSERT_FALSE(isDefaultNullBehavior("cast").has_value());
+  ASSERT_FALSE(isDefaultNullBehavior("not_found_function").has_value());
+}
+
 TEST_F(FunctionRegistryTest, companionFunction) {
   functions::prestosql::registerAllScalarFunctions();
   aggregate::prestosql::registerAllAggregateFunctions();
@@ -513,16 +688,50 @@ TEST_F(FunctionRegistryTest, companionFunction) {
       "array_agg_extract", "arbitrary_extract", "bitwise_and_agg_extract"};
 
   for (const auto& function : functions) {
-    ASSERT_FALSE(exec::simpleFunctions()
-                     .getFunctionSignaturesAndMetadata(function)
-                     .front()
-                     .first.companionFunction);
+    ASSERT_FALSE(
+        exec::simpleFunctions()
+            .getFunctionSignaturesAndMetadata(function)
+            .front()
+            .first.companionFunction);
   }
   for (const auto& function : companionFunctions) {
     ASSERT_TRUE(exec::getVectorFunctionMetadata(function)->companionFunction);
   }
 }
 
+TEST_F(FunctionRegistryTest, getFunctionSignaturesAndMetadata) {
+  registerFunction<MetadataTestFuncAllSet, int32_t, int32_t>(
+      {"metadata_test_all_set"});
+  registerFunction<MetadataTestFuncDefaults, int32_t, int32_t>(
+      {"metadata_test_defaults"});
+
+  const auto& registry = exec::simpleFunctions();
+
+  {
+    auto result =
+        registry.getFunctionSignaturesAndMetadata("metadata_test_all_set");
+    ASSERT_EQ(result.size(), 1);
+    const auto& metadata = result[0].first;
+    EXPECT_FALSE(metadata.supportsFlattening);
+    EXPECT_FALSE(metadata.deterministic);
+    EXPECT_FALSE(metadata.defaultNullBehavior);
+    EXPECT_FALSE(metadata.companionFunction);
+    EXPECT_EQ(metadata.owner, "test-owner-team");
+  }
+
+  {
+    auto result =
+        registry.getFunctionSignaturesAndMetadata("metadata_test_defaults");
+    ASSERT_EQ(result.size(), 1);
+    const auto& metadata = result[0].first;
+    EXPECT_FALSE(metadata.supportsFlattening);
+    EXPECT_TRUE(metadata.deterministic);
+    EXPECT_TRUE(metadata.defaultNullBehavior);
+    EXPECT_FALSE(metadata.companionFunction);
+    EXPECT_TRUE(metadata.owner.empty());
+  }
+}
+
 template <typename T>
 struct TestFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
@@ -608,6 +817,8 @@ TEST_F(FunctionRegistryTest, resolveFunctionWithCoercions) {
     registerFunction<DummySimpleFunction, int64_t, int64_t, int64_t>({"foo"});
     registerFunction<DummySimpleFunction, float, float, float>({"foo"});
     registerFunction<DummySimpleFunction, double, double, double>({"foo"});
+    registerFunction<DummySimpleFunction, Timestamp, Timestamp, Timestamp>(
+        {"foo"});
 
     testCoercions(
         "foo", {TINYINT(), TINYINT()}, INTEGER(), {INTEGER(), INTEGER()});
@@ -620,6 +831,11 @@ TEST_F(FunctionRegistryTest, resolveFunctionWithCoercions) {
     testCoercions("foo", {TINYINT(), REAL()}, REAL(), {REAL(), nullptr});
     testCoercions("foo", {REAL(), TINYINT()}, REAL(), {nullptr, REAL()});
 
+    testCoercions(
+        "foo", {TIMESTAMP(), DATE()}, {TIMESTAMP()}, {nullptr, TIMESTAMP()});
+    testCoercions(
+        "foo", {DATE(), DATE()}, {TIMESTAMP()}, {TIMESTAMP(), TIMESTAMP()});
+
     testNoCoercions("foo", {INTEGER(), INTEGER()}, INTEGER());
     testNoCoercions("foo", {REAL(), REAL()}, REAL());
     testNoCoercions("foo", {DOUBLE(), DOUBLE()}, DOUBLE());
@@ -658,7 +874,7 @@ TEST_F(FunctionRegistryTest, resolveFunctionWithCoercions) {
     testCannotResolve("foo", {TINYINT(), VARCHAR()});
   }
 
-  // Coercions with complex types are not supported yet.
+  // Coercions with complex types.
   {
     SCOPE_EXIT {
       removeFunction("foo");
@@ -673,10 +889,18 @@ TEST_F(FunctionRegistryTest, resolveFunctionWithCoercions) {
         },
         std::make_unique<DummyVectorFunction>());
 
-    testCannotResolve("foo", {ARRAY(TINYINT()), SMALLINT()});
+    testCoercions(
+        "foo",
+        {ARRAY(TINYINT()), SMALLINT()},
+        INTEGER(),
+        {ARRAY(INTEGER()), INTEGER()});
+
+    testNoCoercions("foo", {ARRAY(INTEGER()), INTEGER()}, INTEGER());
+
+    testCannotResolve("foo", {ARRAY(VARCHAR()), SMALLINT()});
   }
 
-  // Coercions with variable number of arguments are not supported yet.
+  // Coercions with variable number of arguments.
   {
     SCOPE_EXIT {
       removeFunction("foo");
@@ -687,21 +911,27 @@ TEST_F(FunctionRegistryTest, resolveFunctionWithCoercions) {
         {velox::exec::FunctionSignatureBuilder()
              .returnType("bigint")
              .argumentType("bigint")
-             .argumentType("bigint")
-             .variableArity()
+             .variableArity("bigint")
              .build(),
          velox::exec::FunctionSignatureBuilder()
              .returnType("double")
              .argumentType("double")
-             .argumentType("double")
-             .variableArity()
+             .variableArity("double")
              .build()},
         std::make_unique<DummyVectorFunction>());
 
-    testCannotResolve("foo", {TINYINT(), SMALLINT(), INTEGER()});
+    testCoercions(
+        "foo",
+        {TINYINT(), SMALLINT(), INTEGER()},
+        BIGINT(),
+        {BIGINT(), BIGINT(), BIGINT()});
+
+    testNoCoercions("foo", {BIGINT(), BIGINT(), BIGINT()}, BIGINT());
+
+    testCannotResolve("foo", {TINYINT(), SMALLINT(), VARCHAR()});
   }
 
-  // Coercions with generic types are not supported yet.
+  // Coercions with generic types.
   {
     SCOPE_EXIT {
       removeFunction("foo");
@@ -717,7 +947,11 @@ TEST_F(FunctionRegistryTest, resolveFunctionWithCoercions) {
              .build()},
         std::make_unique<DummyVectorFunction>());
 
-    testCannotResolve("foo", {TINYINT(), REAL()});
+    testCoercions("foo", {TINYINT(), REAL()}, REAL(), {REAL(), nullptr});
+
+    testNoCoercions("foo", {INTEGER(), INTEGER()}, INTEGER());
+
+    testCannotResolve("foo", {TINYINT(), VARCHAR()});
   }
 }
 
@@ -746,11 +980,93 @@ TEST_F(FunctionRegistryTest, resolveSpecialForms) {
   ASSERT_EQ(*tryResult, *REAL());
 }
 
+TEST_F(FunctionRegistryTest, resolveIfWithCoercions) {
+  testSpecialFormCoercions(
+      "if",
+      {BOOLEAN(), UNKNOWN(), BIGINT()},
+      BIGINT(),
+      {nullptr, BIGINT(), nullptr});
+
+  testSpecialFormCoercions(
+      "if",
+      {BOOLEAN(), BIGINT(), UNKNOWN()},
+      BIGINT(),
+      {nullptr, nullptr, BIGINT()});
+
+  testSpecialFormCoercions(
+      "if",
+      {BOOLEAN(), SMALLINT(), INTEGER()},
+      INTEGER(),
+      {nullptr, INTEGER(), nullptr});
+
+  testSpecialFormCoercions(
+      "if",
+      {BOOLEAN(), INTEGER(), SMALLINT()},
+      INTEGER(),
+      {nullptr, nullptr, INTEGER()});
+
+  testSpecialFormNoCoercions(
+      "if", {BOOLEAN(), INTEGER(), INTEGER()}, INTEGER());
+
+  testSpecialFormCannotResolve("if", {BOOLEAN(), INTEGER(), VARCHAR()});
+}
+
+TEST_F(FunctionRegistryTest, resolveSwitchWithCoercions) {
+  testSpecialFormCoercions(
+      "switch",
+      {BOOLEAN(),
+       UNKNOWN(),
+       BOOLEAN(),
+       INTEGER(),
+       BOOLEAN(),
+       BIGINT(),
+       SMALLINT()},
+      BIGINT(),
+      {nullptr, BIGINT(), nullptr, BIGINT(), nullptr, nullptr, BIGINT()});
+
+  testSpecialFormCoercions(
+      "switch",
+      {BOOLEAN(),
+       BIGINT(),
+       BOOLEAN(),
+       INTEGER(),
+       BOOLEAN(),
+       UNKNOWN(),
+       SMALLINT()},
+      BIGINT(),
+      {nullptr, nullptr, nullptr, BIGINT(), nullptr, BIGINT(), BIGINT()});
+
+  testSpecialFormCoercions(
+      "switch",
+      {BOOLEAN(),
+       TINYINT(),
+       BOOLEAN(),
+       INTEGER(),
+       BOOLEAN(),
+       UNKNOWN(),
+       BIGINT()},
+      BIGINT(),
+      {nullptr, BIGINT(), nullptr, BIGINT(), nullptr, BIGINT(), nullptr});
+}
+
+TEST_F(FunctionRegistryTest, resolveCoalesceWithCoercions) {
+  testSpecialFormCoercions(
+      "coalesce", {UNKNOWN(), BIGINT()}, BIGINT(), {BIGINT(), nullptr});
+
+  testSpecialFormCoercions(
+      "coalesce", {BIGINT(), UNKNOWN()}, BIGINT(), {nullptr, BIGINT()});
+
+  testSpecialFormCoercions(
+      "coalesce",
+      {SMALLINT(), INTEGER(), BIGINT(), TINYINT()},
+      BIGINT(),
+      {BIGINT(), BIGINT(), nullptr, BIGINT()});
+}
+
 TEST_F(FunctionRegistryTest, resolveRowConstructor) {
   auto result = resolveFunctionOrCallableSpecialForm(
       "row_constructor", {INTEGER(), BOOLEAN(), DOUBLE()});
-  ASSERT_EQ(
-      *result, *ROW({"c1", "c2", "c3"}, {INTEGER(), BOOLEAN(), DOUBLE()}));
+  ASSERT_EQ(*result, *ROW({"", "", ""}, {INTEGER(), BOOLEAN(), DOUBLE()}));
 }
 
 TEST_F(FunctionRegistryTest, resolveFunctionNotSpecialForm) {
@@ -827,5 +1143,63 @@ TEST_F(FunctionRegistryTest, ipPrefixRegistration) {
   EXPECT_FALSE(result->second.supportsFlattening);
 }
 
+TEST_F(FunctionRegistryTest, resolveVectorFunctionWithMetadataWithCoercions) {
+  removeFunction("bar");
+
+  SCOPE_EXIT {
+    removeFunction("bar");
+    removeFunction("bar_nondet");
+  };
+
+  exec::registerVectorFunction(
+      "bar",
+      {
+          makeSignature("integer", {"integer", "integer"}),
+          makeSignature("bigint", {"bigint", "bigint"}),
+          makeSignature("real", {"real", "real"}),
+      },
+      std::make_unique<DummyVectorFunction>(),
+      exec::VectorFunctionMetadataBuilder().deterministic(true).build());
+
+  // Register a non-deterministic function to verify metadata is correctly
+  // returned (not just default metadata).
+  exec::registerVectorFunction(
+      "bar_nondet",
+      {
+          makeSignature("integer", {"integer", "integer"}),
+          makeSignature("bigint", {"bigint", "bigint"}),
+      },
+      std::make_unique<DummyVectorFunction>(),
+      exec::VectorFunctionMetadataBuilder().deterministic(false).build());
+
+  // Test exact match - no coercions needed.
+  testVectorFunctionWithMetadataNoCoercions(
+      "bar", {INTEGER(), INTEGER()}, INTEGER(), true);
+
+  // Test coercions are applied.
+  testVectorFunctionWithMetadataCoercions(
+      "bar", {TINYINT(), TINYINT()}, INTEGER(), {INTEGER(), INTEGER()}, true);
+
+  // Test partial coercions - one arg needs coercion, the other doesn't.
+  testVectorFunctionWithMetadataCoercions(
+      "bar", {TINYINT(), REAL()}, REAL(), {REAL(), nullptr}, true);
+
+  // Test that metadata is correctly returned for non-deterministic function.
+  // This verifies we're returning actual function metadata, not defaults.
+  testVectorFunctionWithMetadataCoercions(
+      "bar_nondet",
+      {TINYINT(), TINYINT()},
+      INTEGER(),
+      {INTEGER(), INTEGER()},
+      false);
+
+  // Test function not found.
+  testVectorFunctionWithMetadataCannotResolve(
+      "non_existent_function", {INTEGER(), INTEGER()});
+
+  // Test incompatible types - cannot resolve.
+  testVectorFunctionWithMetadataCannotResolve("bar", {TINYINT(), VARCHAR()});
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/functions/tests/RegistryTestUtil.h b/velox/functions/tests/RegistryTestUtil.h
index 4f1132ede02..cf9c562fefd 100644
--- a/velox/functions/tests/RegistryTestUtil.h
+++ b/velox/functions/tests/RegistryTestUtil.h
@@ -109,6 +109,29 @@ struct IPPrefixFunc {
   }
 };
 
+// Non-deterministic, uses callNullable (defaultNullBehavior=false), has owner.
+template <typename T>
+struct MetadataTestFuncAllSet {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+  static constexpr bool is_deterministic = false;
+  static constexpr std::string_view owner = "test-owner-team";
+
+  FOLLY_ALWAYS_INLINE bool callNullable(int32_t& result, const int32_t* input) {
+    result = input ? *input : 0;
+    return true;
+  }
+};
+
+// Deterministic (default), uses call (defaultNullBehavior=true), no owner.
+template <typename T>
+struct MetadataTestFuncDefaults {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(int32_t& result, int32_t input) {
+    result = input;
+  }
+};
+
 class VectorFuncOne : public velox::exec::VectorFunction {
  public:
   void apply(
diff --git a/velox/package-lock.json b/velox/package-lock.json
new file mode 100644
index 00000000000..793d78ba5dd
--- /dev/null
+++ b/velox/package-lock.json
@@ -0,0 +1,6 @@
+{
+  "name": "velox",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}
diff --git a/velox/parse/CMakeLists.txt b/velox/parse/CMakeLists.txt
index b092eca3b03..7ad4a91d768 100644
--- a/velox/parse/CMakeLists.txt
+++ b/velox/parse/CMakeLists.txt
@@ -11,13 +11,32 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-velox_add_library(velox_parse_expression Expressions.cpp)
+velox_add_library(
+  velox_parse_expression
+  ExprRewriter.cpp
+  Expressions.cpp
+  SqlExpressionsParser.cpp
+  HEADERS
+  ExprRewriter.h
+  Expressions.h
+  IExpr.h
+  SqlExpressionsParser.h
+  TypeResolver.h
+)
 velox_link_libraries(velox_parse_expression velox_type velox_parse_utils velox_expression)
 
-velox_add_library(velox_parse_parser ExpressionsParser.cpp QueryPlanner.cpp)
+velox_add_library(
+  velox_parse_parser
+  ExpressionsParser.cpp
+  QueryPlanner.cpp
+  HEADERS
+  DuckLogicalOperator.h
+  ExpressionsParser.h
+  QueryPlanner.h
+)
 velox_link_libraries(velox_parse_parser velox_parse_expression velox_type velox_duckdb_parser)
 
-velox_add_library(velox_parse_utils TypeResolver.cpp)
+velox_add_library(velox_parse_utils TypeResolver.cpp HEADERS PlanNodeIdGenerator.h)
 velox_link_libraries(
   velox_parse_utils
   velox_buffer
@@ -30,3 +49,5 @@ velox_link_libraries(
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
 endif()
+
+velox_add_library(velox_plan_node_id_generator INTERFACE HEADERS PlanNodeIdGenerator.h)
diff --git a/velox/parse/ExprRewriter.cpp b/velox/parse/ExprRewriter.cpp
new file mode 100644
index 00000000000..186f9d17afe
--- /dev/null
+++ b/velox/parse/ExprRewriter.cpp
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/parse/ExprRewriter.h"
+
+#include "velox/parse/Expressions.h"
+
+namespace facebook::velox::core {
+
+namespace {
+
+std::vector<ExprPtr> rewriteAll(
+    const std::vector<ExprPtr>& exprs,
+    const ExprRewriter::Transform& transform) {
+  std::vector<ExprPtr> result;
+  result.reserve(exprs.size());
+  for (const auto& expr : exprs) {
+    result.push_back(ExprRewriter::rewrite(expr, transform));
+  }
+  return result;
+}
+
+std::vector<SortKey> rewriteSortKeys(
+    const std::vector<SortKey>& keys,
+    const ExprRewriter::Transform& transform) {
+  std::vector<SortKey> result;
+  result.reserve(keys.size());
+  for (const auto& key : keys) {
+    result.push_back(
+        {ExprRewriter::rewrite(key.expr, transform),
+         key.ascending,
+         key.nullsFirst});
+  }
+  return result;
+}
+
+} // namespace
+
+ExprPtr ExprRewriter::rewrite(const ExprPtr& expr, const Transform& transform) {
+  switch (expr->kind()) {
+    case IExpr::Kind::kAggregate: {
+      auto* agg = expr->as<AggregateCallExpr>();
+      auto rewritten = std::make_shared<AggregateCallExpr>(
+          agg->name(),
+          rewriteAll(agg->inputs(), transform),
+          agg->isDistinct(),
+          agg->filter() ? rewrite(agg->filter(), transform) : nullptr,
+          rewriteSortKeys(agg->orderBy(), transform),
+          agg->alias());
+      return transform(std::move(rewritten));
+    }
+    case IExpr::Kind::kWindow: {
+      auto* window = expr->as<WindowCallExpr>();
+      std::optional<WindowCallExpr::Frame> frame = window->frame();
+      if (frame.has_value()) {
+        if (frame->startValue) {
+          frame->startValue = rewrite(frame->startValue, transform);
+        }
+        if (frame->endValue) {
+          frame->endValue = rewrite(frame->endValue, transform);
+        }
+      }
+      auto rewritten = std::make_shared<WindowCallExpr>(
+          window->name(),
+          rewriteAll(window->inputs(), transform),
+          rewriteAll(window->partitionKeys(), transform),
+          rewriteSortKeys(window->orderByKeys(), transform),
+          std::move(frame),
+          window->isIgnoreNulls(),
+          window->alias());
+      return transform(std::move(rewritten));
+    }
+    default: {
+      const auto& inputs = expr->inputs();
+      if (inputs.empty()) {
+        return transform(expr);
+      }
+      return transform(expr->replaceInputs(rewriteAll(inputs, transform)));
+    }
+  }
+}
+
+} // namespace facebook::velox::core
diff --git a/velox/parse/ExprRewriter.h b/velox/parse/ExprRewriter.h
new file mode 100644
index 00000000000..6a58665f45a
--- /dev/null
+++ b/velox/parse/ExprRewriter.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/parse/IExpr.h"
+
+namespace facebook::velox::core {
+
+/// Rewrites an IExpr tree bottom-up. Recurses into all constituent expressions
+/// of each node (args, filter, orderBy, partitionKeys, frame values), rebuilds
+/// the node from the rewritten parts, then applies the transform to the result.
+///
+/// Usage:
+///   // Rename field accesses.
+///   auto result = ExprRewriter::rewrite(expr, [&](const ExprPtr& e) {
+///     if (auto* field = e->as<FieldAccessExpr>()) {
+///       if (field->isRootColumn()) {
+///         auto it = mapping.find(field->name());
+///         if (it != mapping.end()) {
+///           return std::make_shared<FieldAccessExpr>(
+///               it->second, field->alias());
+///         }
+///       }
+///     }
+///     return e;
+///   });
+class ExprRewriter {
+ public:
+  /// Called on each node after its children have been rewritten. Receives
+  /// either a leaf node or a node rebuilt from already-transformed children.
+  /// Returns the node unchanged or a replacement.
+  using Transform = std::function<ExprPtr(const ExprPtr&)>;
+
+  /// Rewrites 'expr' bottom-up: first rewrites all children, rebuilds the
+  /// node, then applies 'transform'.
+  ///
+  /// Lambda and subquery expressions are not recursed into. Lambda arguments
+  /// may shadow outer names, requiring scope tracking that this rewriter does
+  /// not provide. The transform can handle these directly if needed.
+  static ExprPtr rewrite(const ExprPtr& expr, const Transform& transform);
+};
+
+} // namespace facebook::velox::core
diff --git a/velox/parse/Expressions.cpp b/velox/parse/Expressions.cpp
index 330fa209a20..6079dfa37df 100644
--- a/velox/parse/Expressions.cpp
+++ b/velox/parse/Expressions.cpp
@@ -15,8 +15,55 @@
  */
 #include "velox/parse/Expressions.h"
 
+#include "velox/common/EnumDefine.h"
+
 namespace facebook::velox::core {
 
+namespace {
+const auto& windowTypeNames() {
+  static const folly::F14FastMap<WindowCallExpr::WindowType, std::string_view>
+      kNames = {
+          {WindowCallExpr::WindowType::kRows, "ROWS"},
+          {WindowCallExpr::WindowType::kRange, "RANGE"},
+          {WindowCallExpr::WindowType::kGroups, "GROUPS"},
+      };
+  return kNames;
+}
+
+const auto& boundTypeNames() {
+  static const folly::F14FastMap<WindowCallExpr::BoundType, std::string_view>
+      kNames = {
+          {WindowCallExpr::BoundType::kCurrentRow, "CURRENT ROW"},
+          {WindowCallExpr::BoundType::kUnboundedPreceding,
+           "UNBOUNDED PRECEDING"},
+          {WindowCallExpr::BoundType::kUnboundedFollowing,
+           "UNBOUNDED FOLLOWING"},
+          {WindowCallExpr::BoundType::kPreceding, "PRECEDING"},
+          {WindowCallExpr::BoundType::kFollowing, "FOLLOWING"},
+      };
+  return kNames;
+}
+
+const auto& kindNames() {
+  static const folly::F14FastMap<IExpr::Kind, std::string_view> kNames = {
+      {IExpr::Kind::kInput, "Input"},
+      {IExpr::Kind::kFieldAccess, "FieldAccess"},
+      {IExpr::Kind::kCall, "Call"},
+      {IExpr::Kind::kCast, "Cast"},
+      {IExpr::Kind::kConstant, "Constant"},
+      {IExpr::Kind::kLambda, "Lambda"},
+      {IExpr::Kind::kSubquery, "Subquery"},
+      {IExpr::Kind::kAggregate, "Aggregate"},
+      {IExpr::Kind::kWindow, "Window"},
+  };
+  return kNames;
+}
+} // namespace
+
+VELOX_DEFINE_EMBEDDED_ENUM_NAME(IExpr, Kind, kindNames)
+VELOX_DEFINE_EMBEDDED_ENUM_NAME(WindowCallExpr, WindowType, windowTypeNames);
+VELOX_DEFINE_EMBEDDED_ENUM_NAME(WindowCallExpr, BoundType, boundTypeNames);
+
 bool FieldAccessExpr::operator==(const IExpr& other) const {
   if (!other.is(Kind::kFieldAccess)) {
     return false;
@@ -72,6 +119,253 @@ std::string CallExpr::toString() const {
   return appendAliasIfExists(buf);
 }
 
+bool AggregateCallExpr::operator==(const IExpr& other) const {
+  if (!other.is(Kind::kAggregate)) {
+    return false;
+  }
+
+  auto* otherAgg = other.as<AggregateCallExpr>();
+  if (name() != otherAgg->name() || distinct_ != otherAgg->distinct_) {
+    return false;
+  }
+
+  // Compare filter.
+  if ((filter_ == nullptr) != (otherAgg->filter_ == nullptr)) {
+    return false;
+  }
+  if (filter_ != nullptr && *filter_ != *otherAgg->filter_) {
+    return false;
+  }
+
+  // Compare orderBy.
+  if (orderBy_.size() != otherAgg->orderBy_.size()) {
+    return false;
+  }
+  for (size_t i = 0; i < orderBy_.size(); ++i) {
+    if (orderBy_[i].ascending != otherAgg->orderBy_[i].ascending ||
+        orderBy_[i].nullsFirst != otherAgg->orderBy_[i].nullsFirst ||
+        *orderBy_[i].expr != *otherAgg->orderBy_[i].expr) {
+      return false;
+    }
+  }
+
+  return compareAliasAndInputs(other);
+}
+
+size_t AggregateCallExpr::localHash() const {
+  auto hash = std::hash<std::string>{}(name());
+  hash = bits::hashMix(hash, std::hash<bool>{}(distinct_));
+  if (filter_ != nullptr) {
+    hash = bits::hashMix(hash, filter_->hash());
+  }
+  for (const auto& key : orderBy_) {
+    hash = bits::hashMix(hash, key.expr->hash());
+    hash = bits::hashMix(hash, std::hash<bool>{}(key.ascending));
+    hash = bits::hashMix(hash, std::hash<bool>{}(key.nullsFirst));
+  }
+  return hash;
+}
+
+std::string AggregateCallExpr::toString() const {
+  std::ostringstream out;
+  out << name() << "(";
+  if (distinct_) {
+    out << "DISTINCT ";
+  }
+  for (size_t i = 0; i < inputs().size(); ++i) {
+    if (i > 0) {
+      out << ",";
+    }
+    out << inputs()[i]->toString();
+  }
+  out << ")";
+  if (filter_ != nullptr) {
+    out << " FILTER(WHERE " << filter_->toString() << ")";
+  }
+  if (!orderBy_.empty()) {
+    out << " ORDER BY ";
+    for (size_t i = 0; i < orderBy_.size(); ++i) {
+      if (i > 0) {
+        out << ",";
+      }
+      out << orderBy_[i].expr->toString();
+      out << (orderBy_[i].ascending ? " ASC" : " DESC");
+      out << (orderBy_[i].nullsFirst ? " NULLS FIRST" : " NULLS LAST");
+    }
+  }
+  return appendAliasIfExists(out.str());
+}
+
+bool WindowCallExpr::operator==(const IExpr& other) const {
+  if (!other.is(Kind::kWindow)) {
+    return false;
+  }
+
+  auto* otherWin = other.as<WindowCallExpr>();
+  if (name() != otherWin->name() || ignoreNulls_ != otherWin->ignoreNulls_) {
+    return false;
+  }
+
+  // Compare partition keys.
+  if (partitionKeys_.size() != otherWin->partitionKeys_.size()) {
+    return false;
+  }
+  for (size_t i = 0; i < partitionKeys_.size(); ++i) {
+    if (*partitionKeys_[i] != *otherWin->partitionKeys_[i]) {
+      return false;
+    }
+  }
+
+  // Compare order by keys.
+  if (orderByKeys_.size() != otherWin->orderByKeys_.size()) {
+    return false;
+  }
+  for (size_t i = 0; i < orderByKeys_.size(); ++i) {
+    if (orderByKeys_[i].ascending != otherWin->orderByKeys_[i].ascending ||
+        orderByKeys_[i].nullsFirst != otherWin->orderByKeys_[i].nullsFirst ||
+        *orderByKeys_[i].expr != *otherWin->orderByKeys_[i].expr) {
+      return false;
+    }
+  }
+
+  // Compare frame.
+  if (frame_.has_value() != otherWin->frame_.has_value()) {
+    return false;
+  }
+  if (frame_.has_value()) {
+    const auto& frame = frame_.value();
+    const auto& otherFrame = otherWin->frame_.value();
+    if (frame.type != otherFrame.type ||
+        frame.startType != otherFrame.startType ||
+        frame.endType != otherFrame.endType) {
+      return false;
+    }
+    if ((frame.startValue == nullptr) != (otherFrame.startValue == nullptr)) {
+      return false;
+    }
+    if (frame.startValue != nullptr &&
+        *frame.startValue != *otherFrame.startValue) {
+      return false;
+    }
+    if ((frame.endValue == nullptr) != (otherFrame.endValue == nullptr)) {
+      return false;
+    }
+    if (frame.endValue != nullptr && *frame.endValue != *otherFrame.endValue) {
+      return false;
+    }
+  }
+
+  return compareAliasAndInputs(other);
+}
+
+size_t WindowCallExpr::localHash() const {
+  auto hash = std::hash<std::string>{}(name());
+  hash = bits::hashMix(hash, std::hash<bool>{}(ignoreNulls_));
+  for (const auto& key : partitionKeys_) {
+    hash = bits::hashMix(hash, key->hash());
+  }
+  for (const auto& key : orderByKeys_) {
+    hash = bits::hashMix(hash, key.expr->hash());
+    hash = bits::hashMix(hash, std::hash<bool>{}(key.ascending));
+    hash = bits::hashMix(hash, std::hash<bool>{}(key.nullsFirst));
+  }
+  if (frame_.has_value()) {
+    hash =
+        bits::hashMix(hash, std::hash<int>{}(static_cast<int>(frame_->type)));
+    hash = bits::hashMix(
+        hash, std::hash<int>{}(static_cast<int>(frame_->startType)));
+    hash = bits::hashMix(
+        hash, std::hash<int>{}(static_cast<int>(frame_->endType)));
+  }
+  return hash;
+}
+
+std::string WindowCallExpr::toString() const {
+  std::ostringstream out;
+  out << name() << "(";
+  for (size_t i = 0; i < inputs().size(); ++i) {
+    if (i > 0) {
+      out << ",";
+    }
+    out << inputs()[i]->toString();
+  }
+  out << ") OVER (";
+
+  bool needsSpace = false;
+  if (!partitionKeys_.empty()) {
+    out << "PARTITION BY ";
+    for (size_t i = 0; i < partitionKeys_.size(); ++i) {
+      if (i > 0) {
+        out << ",";
+      }
+      out << partitionKeys_[i]->toString();
+    }
+    needsSpace = true;
+  }
+
+  if (!orderByKeys_.empty()) {
+    if (needsSpace) {
+      out << " ";
+    }
+    out << "ORDER BY ";
+    for (size_t i = 0; i < orderByKeys_.size(); ++i) {
+      if (i > 0) {
+        out << ",";
+      }
+      out << orderByKeys_[i].expr->toString();
+      out << (orderByKeys_[i].ascending ? " ASC" : " DESC");
+      out << (orderByKeys_[i].nullsFirst ? " NULLS FIRST" : " NULLS LAST");
+    }
+    needsSpace = true;
+  }
+
+  if (frame_.has_value()) {
+    if (needsSpace) {
+      out << " ";
+    }
+    const auto& frame = frame_.value();
+    switch (frame.type) {
+      case WindowType::kRows:
+        out << "ROWS";
+        break;
+      case WindowType::kRange:
+        out << "RANGE";
+        break;
+      case WindowType::kGroups:
+        out << "GROUPS";
+        break;
+    }
+    out << " BETWEEN ";
+
+    auto formatBound = [&](BoundType boundType, const ExprPtr& value) {
+      switch (boundType) {
+        case BoundType::kUnboundedPreceding:
+          out << "UNBOUNDED PRECEDING";
+          break;
+        case BoundType::kPreceding:
+          out << value->toString() << " PRECEDING";
+          break;
+        case BoundType::kCurrentRow:
+          out << "CURRENT ROW";
+          break;
+        case BoundType::kFollowing:
+          out << value->toString() << " FOLLOWING";
+          break;
+        case BoundType::kUnboundedFollowing:
+          out << "UNBOUNDED FOLLOWING";
+          break;
+      }
+    };
+
+    formatBound(frame.startType, frame.startValue);
+    out << " AND ";
+    formatBound(frame.endType, frame.endValue);
+  }
+
+  out << ")";
+  return appendAliasIfExists(out.str());
+}
+
 bool CastExpr::operator==(const IExpr& other) const {
   if (!other.is(Kind::kCast)) {
     return false;
@@ -88,7 +382,11 @@ size_t CastExpr::localHash() const {
 
 std::string CastExpr::toString() const {
   return appendAliasIfExists(
-      "cast(" + input()->toString() + " as " + type_->toString() + ")");
+      fmt::format(
+          "{}({} as {})",
+          isTryCast_ ? "try_cast" : "cast",
+          input()->toString(),
+          type_->toString()));
 }
 
 bool ConstantExpr::operator==(const IExpr& other) const {
@@ -138,4 +436,34 @@ std::string LambdaExpr::toString() const {
   return out.str();
 }
 
+std::string ConcatExpr::toString() const {
+  std::ostringstream out;
+  out << "row(";
+  for (size_t i = 0; i < inputs().size(); ++i) {
+    if (i > 0) {
+      out << ", ";
+    }
+    out << inputs()[i]->toString() << " as " << fieldNames_[i];
+  }
+  out << ")";
+  return appendAliasIfExists(out.str());
+}
+
+bool ConcatExpr::operator==(const IExpr& other) const {
+  if (!other.is(Kind::kConcat)) {
+    return false;
+  }
+  auto* otherConcat = other.as<ConcatExpr>();
+  return fieldNames_ == otherConcat->fieldNames_ &&
+      compareAliasAndInputs(other);
+}
+
+size_t ConcatExpr::localHash() const {
+  size_t hash = 0;
+  for (const auto& name : fieldNames_) {
+    hash = bits::hashMix(hash, std::hash<std::string>{}(name));
+  }
+  return hash;
+}
+
 } // namespace facebook::velox::core
diff --git a/velox/parse/Expressions.h b/velox/parse/Expressions.h
index a38dea051f1..9049175e59c 100644
--- a/velox/parse/Expressions.h
+++ b/velox/parse/Expressions.h
@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include "velox/common/EnumDeclare.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/parse/IExpr.h"
 #include "velox/type/Variant.h"
@@ -33,6 +34,10 @@ class InputExpr : public IExpr {
     return std::make_shared<InputExpr>();
   }
 
+  ExprPtr dropAlias() const override {
+    return std::make_shared<InputExpr>();
+  }
+
   bool operator==(const IExpr& other) const override {
     return other.is(Kind::kInput);
   }
@@ -49,13 +54,16 @@ class FieldAccessExpr : public IExpr {
   FieldAccessExpr(
       std::string name,
       std::optional<std::string> alias,
-      std::vector<ExprPtr>&& inputs =
-          std::vector<ExprPtr>{std::make_shared<const InputExpr>()})
+      std::vector<ExprPtr> inputs)
       : IExpr{IExpr::Kind::kFieldAccess, std::move(inputs), std::move(alias)},
         name_{std::move(name)} {
     VELOX_USER_CHECK_EQ(IExpr::inputs().size(), 1);
   }
 
+  FieldAccessExpr(std::string name, std::optional<std::string> alias)
+      : IExpr{IExpr::Kind::kFieldAccess, {std::make_shared<const InputExpr>()}, std::move(alias)},
+        name_{std::move(name)} {}
+
   const std::string& name() const {
     return name_;
   }
@@ -72,6 +80,14 @@ class FieldAccessExpr : public IExpr {
         name_, alias(), std::move(newInputs));
   }
 
+  ExprPtr withAlias(const std::string& alias) const override {
+    return std::make_shared<FieldAccessExpr>(name_, alias, inputs());
+  }
+
+  ExprPtr dropAlias() const override {
+    return std::make_shared<FieldAccessExpr>(name_, std::nullopt, inputs());
+  }
+
   bool operator==(const IExpr& other) const override;
 
   size_t localHash() const override;
@@ -85,11 +101,11 @@ class FieldAccessExpr : public IExpr {
 class CallExpr : public IExpr {
  public:
   CallExpr(
-      std::string&& funcName,
-      std::vector<ExprPtr>&& inputs,
+      std::string name,
+      std::vector<ExprPtr> inputs,
       std::optional<std::string> alias)
       : IExpr{IExpr::Kind::kCall, std::move(inputs), std::move(alias)},
-        name_{std::move(funcName)} {
+        name_{std::move(name)} {
     VELOX_USER_CHECK(!name_.empty());
   }
 
@@ -105,27 +121,239 @@ class CallExpr : public IExpr {
         folly::copy(name()), std::move(newInputs), alias());
   }
 
+  ExprPtr withAlias(const std::string& alias) const override {
+    return std::make_shared<CallExpr>(name(), inputs(), alias);
+  }
+
+  ExprPtr dropAlias() const override {
+    return std::make_shared<CallExpr>(name(), inputs(), std::nullopt);
+  }
+
   bool operator==(const IExpr& other) const override;
 
   size_t localHash() const override;
 
   VELOX_DEFINE_CLASS_NAME(CallExpr)
 
+ protected:
+  // For subclasses that use a different Kind (e.g., AggregateCallExpr).
+  CallExpr(
+      Kind kind,
+      std::string name,
+      std::vector<ExprPtr> inputs,
+      std::optional<std::string> alias)
+      : IExpr{kind, std::move(inputs), std::move(alias)},
+        name_{std::move(name)} {
+    VELOX_USER_CHECK(!name_.empty());
+  }
+
  private:
   const std::string name_;
 };
 
+/// Sort specification for ORDER BY clauses in aggregate and window functions.
+struct SortKey {
+  ExprPtr expr;
+  bool ascending;
+  bool nullsFirst;
+};
+
+/// An aggregate function call with DISTINCT, FILTER, and ORDER BY options.
+/// Extends CallExpr so it can be used anywhere a CallExpr is expected (e.g.,
+/// type resolution). Carries options as part of the IExpr tree so they
+/// survive expression composition.
+class AggregateCallExpr : public CallExpr {
+ public:
+  AggregateCallExpr(
+      std::string name,
+      std::vector<ExprPtr> args,
+      bool distinct,
+      ExprPtr filter,
+      std::vector<SortKey> orderBy,
+      std::optional<std::string> alias = std::nullopt)
+      : CallExpr(
+            IExpr::Kind::kAggregate,
+            std::move(name),
+            std::move(args),
+            std::move(alias)),
+        distinct_(distinct),
+        filter_(std::move(filter)),
+        orderBy_(std::move(orderBy)) {}
+
+  bool isDistinct() const {
+    return distinct_;
+  }
+
+  const ExprPtr& filter() const {
+    return filter_;
+  }
+
+  const std::vector<SortKey>& orderBy() const {
+    return orderBy_;
+  }
+
+  std::string toString() const override;
+
+  ExprPtr replaceInputs(std::vector<ExprPtr> newInputs) const override {
+    VELOX_CHECK_NULL(
+        filter_, "Cannot replace inputs on AggregateCallExpr with filter");
+    VELOX_CHECK(
+        orderBy_.empty(),
+        "Cannot replace inputs on AggregateCallExpr with orderBy");
+    return std::make_shared<AggregateCallExpr>(
+        name(), std::move(newInputs), distinct_, filter_, orderBy_, alias());
+  }
+
+  ExprPtr withAlias(const std::string& alias) const override {
+    return std::make_shared<AggregateCallExpr>(
+        name(), inputs(), distinct_, filter_, orderBy_, alias);
+  }
+
+  ExprPtr dropAlias() const final {
+    return std::make_shared<AggregateCallExpr>(
+        name(), inputs(), distinct_, filter_, orderBy_, std::nullopt);
+  }
+
+  bool operator==(const IExpr& other) const override;
+
+  VELOX_DEFINE_CLASS_NAME(AggregateCallExpr)
+
+ protected:
+  size_t localHash() const override;
+
+ private:
+  const bool distinct_;
+  const ExprPtr filter_;
+  const std::vector<SortKey> orderBy_;
+};
+
+/// Window function call with partition keys, ordering, frame, and ignore nulls.
+/// Extends CallExpr so it can be used anywhere a CallExpr is expected (e.g.,
+/// type resolution). Carries window specifications as part of the IExpr tree.
+class WindowCallExpr : public CallExpr {
+ public:
+  enum class WindowType { kRange, kRows, kGroups };
+
+  VELOX_DECLARE_EMBEDDED_ENUM_NAME(WindowType);
+
+  enum class BoundType {
+    kUnboundedPreceding,
+    kPreceding,
+    kCurrentRow,
+    kFollowing,
+    kUnboundedFollowing,
+  };
+
+  VELOX_DECLARE_EMBEDDED_ENUM_NAME(BoundType);
+
+  struct Frame {
+    WindowType type;
+    BoundType startType;
+    ExprPtr startValue;
+    BoundType endType;
+    ExprPtr endValue;
+  };
+
+  WindowCallExpr(
+      std::string name,
+      std::vector<ExprPtr> args,
+      std::vector<ExprPtr> partitionKeys,
+      std::vector<SortKey> orderByKeys,
+      std::optional<Frame> frame,
+      bool ignoreNulls,
+      std::optional<std::string> alias = std::nullopt)
+      : CallExpr(
+            IExpr::Kind::kWindow,
+            std::move(name),
+            std::move(args),
+            std::move(alias)),
+        partitionKeys_(std::move(partitionKeys)),
+        orderByKeys_(std::move(orderByKeys)),
+        frame_(std::move(frame)),
+        ignoreNulls_(ignoreNulls) {}
+
+  const std::vector<ExprPtr>& partitionKeys() const {
+    return partitionKeys_;
+  }
+
+  const std::vector<SortKey>& orderByKeys() const {
+    return orderByKeys_;
+  }
+
+  const std::optional<Frame>& frame() const {
+    return frame_;
+  }
+
+  bool isIgnoreNulls() const {
+    return ignoreNulls_;
+  }
+
+  std::string toString() const override;
+
+  ExprPtr replaceInputs(std::vector<ExprPtr> newInputs) const override {
+    VELOX_CHECK(
+        partitionKeys_.empty(),
+        "Cannot replace inputs on WindowCallExpr with partitionKeys");
+    VELOX_CHECK(
+        orderByKeys_.empty(),
+        "Cannot replace inputs on WindowCallExpr with orderByKeys");
+    return std::make_shared<WindowCallExpr>(
+        name(),
+        std::move(newInputs),
+        partitionKeys_,
+        orderByKeys_,
+        frame_,
+        ignoreNulls_,
+        alias());
+  }
+
+  ExprPtr withAlias(const std::string& alias) const override {
+    return std::make_shared<WindowCallExpr>(
+        name(),
+        inputs(),
+        partitionKeys_,
+        orderByKeys_,
+        frame_,
+        ignoreNulls_,
+        alias);
+  }
+
+  ExprPtr dropAlias() const final {
+    return std::make_shared<WindowCallExpr>(
+        name(),
+        inputs(),
+        partitionKeys_,
+        orderByKeys_,
+        frame_,
+        ignoreNulls_,
+        std::nullopt);
+  }
+
+  bool operator==(const IExpr& other) const override;
+
+  VELOX_DEFINE_CLASS_NAME(WindowCallExpr)
+
+ protected:
+  size_t localHash() const override;
+
+ private:
+  const std::vector<ExprPtr> partitionKeys_;
+  const std::vector<SortKey> orderByKeys_;
+  const std::optional<Frame> frame_;
+  const bool ignoreNulls_;
+};
+
 class ConstantExpr : public IExpr,
                      public std::enable_shared_from_this<ConstantExpr> {
  public:
-  ConstantExpr(TypePtr type, variant value, std::optional<std::string> alias)
+  ConstantExpr(TypePtr type, Variant value, std::optional<std::string> alias)
       : IExpr{IExpr::Kind::kConstant, {}, std::move(alias)},
         type_{std::move(type)},
         value_{std::move(value)} {}
 
   std::string toString() const override;
 
-  const variant& value() const {
+  const Variant& value() const {
     return value_;
   }
 
@@ -138,6 +366,14 @@ class ConstantExpr : public IExpr,
     return std::make_shared<ConstantExpr>(type(), value(), alias());
   }
 
+  ExprPtr withAlias(const std::string& alias) const override {
+    return std::make_shared<ConstantExpr>(type(), value(), alias);
+  }
+
+  ExprPtr dropAlias() const override {
+    return std::make_shared<ConstantExpr>(type(), value(), std::nullopt);
+  }
+
   bool operator==(const IExpr& other) const override;
 
   size_t localHash() const override;
@@ -146,7 +382,7 @@ class ConstantExpr : public IExpr,
 
  private:
   const TypePtr type_;
-  const variant value_;
+  const Variant value_;
 };
 
 class CastExpr : public IExpr, public std::enable_shared_from_this<CastExpr> {
@@ -176,6 +412,15 @@ class CastExpr : public IExpr, public std::enable_shared_from_this<CastExpr> {
         type(), newInputs[0], isTryCast_, alias());
   }
 
+  ExprPtr withAlias(const std::string& alias) const override {
+    return std::make_shared<CastExpr>(type(), input(), isTryCast_, alias);
+  }
+
+  ExprPtr dropAlias() const override {
+    return std::make_shared<CastExpr>(
+        type(), input(), isTryCast_, std::nullopt);
+  }
+
   bool operator==(const IExpr& other) const override;
 
   size_t localHash() const override;
@@ -214,6 +459,10 @@ class LambdaExpr : public IExpr,
     return std::make_shared<LambdaExpr>(arguments(), body());
   }
 
+  ExprPtr dropAlias() const override {
+    return std::make_shared<LambdaExpr>(arguments(), body());
+  }
+
   std::string toString() const override;
 
   bool operator==(const IExpr& other) const override;
@@ -226,4 +475,40 @@ class LambdaExpr : public IExpr,
   const std::vector<std::string> arguments_;
   const ExprPtr body_;
 };
+
+/// Named ROW constructor. Carries field names alongside child expressions
+/// through the unresolved expression tree.
+class ConcatExpr : public IExpr {
+ public:
+  ConcatExpr(std::vector<std::string> fieldNames, std::vector<ExprPtr> inputs)
+      : IExpr(IExpr::Kind::kConcat, std::move(inputs)),
+        fieldNames_(std::move(fieldNames)) {
+    VELOX_CHECK_EQ(fieldNames_.size(), this->inputs().size());
+  }
+
+  const std::vector<std::string>& fieldNames() const {
+    return fieldNames_;
+  }
+
+  std::string toString() const override;
+
+  ExprPtr replaceInputs(std::vector<ExprPtr> newInputs) const override {
+    return std::make_shared<ConcatExpr>(fieldNames_, std::move(newInputs));
+  }
+
+  ExprPtr dropAlias() const override {
+    return std::make_shared<ConcatExpr>(fieldNames_, inputs());
+  }
+
+  bool operator==(const IExpr& other) const override;
+
+  size_t localHash() const override;
+
+ private:
+  const std::vector<std::string> fieldNames_;
+};
+
+using AggregateCallExprPtr = std::shared_ptr<const AggregateCallExpr>;
+using WindowCallExprPtr = std::shared_ptr<const WindowCallExpr>;
+
 } // namespace facebook::velox::core
diff --git a/velox/parse/ExpressionsParser.cpp b/velox/parse/ExpressionsParser.cpp
index a04a29a6860..ede3dd2c1c1 100644
--- a/velox/parse/ExpressionsParser.cpp
+++ b/velox/parse/ExpressionsParser.cpp
@@ -14,37 +14,52 @@
  * limitations under the License.
  */
 #include "velox/parse/ExpressionsParser.h"
-#include "velox/duckdb/conversion/DuckParser.h"
 
 namespace facebook::velox::parse {
+namespace {
 
-core::ExprPtr parseExpr(const std::string& expr, const ParseOptions& options) {
-  facebook::velox::duckdb::ParseOptions duckConversionOptions;
-  duckConversionOptions.parseDecimalAsDouble = options.parseDecimalAsDouble;
-  duckConversionOptions.parseIntegerAsBigint = options.parseIntegerAsBigint;
-  duckConversionOptions.parseInListAsArray = options.parseInListAsArray;
-  duckConversionOptions.functionPrefix = options.functionPrefix;
-  return facebook::velox::duckdb::parseExpr(expr, duckConversionOptions);
+facebook::velox::duckdb::ParseOptions toDuckOptions(
+    const ParseOptions& options) {
+  facebook::velox::duckdb::ParseOptions duckOptions;
+  duckOptions.parseDecimalAsDouble = options.parseDecimalAsDouble;
+  duckOptions.parseIntegerAsBigint = options.parseIntegerAsBigint;
+  duckOptions.parseInListAsArray = options.parseInListAsArray;
+  duckOptions.correctWindowFrameDefault = options.correctWindowFrameDefault;
+  duckOptions.functionPrefix = options.functionPrefix;
+  return duckOptions;
 }
+} // namespace
 
-std::vector<core::ExprPtr> parseMultipleExpressions(
-    const std::string& expr,
-    const ParseOptions& options) {
-  facebook::velox::duckdb::ParseOptions duckConversionOptions;
-  duckConversionOptions.parseDecimalAsDouble = options.parseDecimalAsDouble;
-  duckConversionOptions.parseIntegerAsBigint = options.parseIntegerAsBigint;
-  duckConversionOptions.functionPrefix = options.functionPrefix;
-  return facebook::velox::duckdb::parseMultipleExpressions(
-      expr, duckConversionOptions);
+DuckSqlExpressionsParser::DuckSqlExpressionsParser(const ParseOptions& options)
+    : options_{toDuckOptions(options)} {}
+
+core::ExprPtr DuckSqlExpressionsParser::parseExpr(const std::string& expr) {
+  return facebook::velox::duckdb::parseExpr(expr, options_);
+}
+
+std::vector<core::ExprPtr> DuckSqlExpressionsParser::parseExprs(
+    const std::string& expr) {
+  return facebook::velox::duckdb::parseMultipleExpressions(expr, options_);
 }
 
-OrderByClause parseOrderByExpr(const std::string& expr) {
-  auto orderBy = facebook::velox::duckdb::parseOrderByExpr(expr);
+OrderByClause DuckSqlExpressionsParser::parseOrderByExpr(
+    const std::string& expr) {
+  return facebook::velox::duckdb::parseOrderByExpr(expr);
+}
+
+core::AggregateCallExprPtr DuckSqlExpressionsParser::parseAggregateExpr(
+    const std::string& expr) {
+  return facebook::velox::duckdb::parseAggregateExpr(expr, options_);
+}
+
+core::WindowCallExprPtr DuckSqlExpressionsParser::parseWindowExpr(
+    const std::string& expr) {
+  return facebook::velox::duckdb::parseWindowExpr(expr, options_);
+}
 
-  return {
-      .expr = std::move(orderBy.expr),
-      .ascending = orderBy.ascending,
-      .nullsFirst = orderBy.nullsFirst};
+core::ExprPtr DuckSqlExpressionsParser::parseScalarOrWindowExpr(
+    const std::string& expr) {
+  return facebook::velox::duckdb::parseScalarOrWindowExpr(expr, options_);
 }
 
 } // namespace facebook::velox::parse
diff --git a/velox/parse/ExpressionsParser.h b/velox/parse/ExpressionsParser.h
index e4ee66b27f0..c760c1adc42 100644
--- a/velox/parse/ExpressionsParser.h
+++ b/velox/parse/ExpressionsParser.h
@@ -15,7 +15,8 @@
  */
 #pragma once
 
-#include "velox/parse/IExpr.h"
+#include "velox/duckdb/conversion/DuckParser.h"
+#include "velox/parse/SqlExpressionsParser.h"
 
 namespace facebook::velox::parse {
 
@@ -23,29 +24,48 @@ namespace facebook::velox::parse {
 struct ParseOptions {
   // Retain legacy behavior by default.
   bool parseDecimalAsDouble = true;
+
+  // TODO: Replace or add a new flag with behavior that matches Presto and Spark
+  // where small integer literals are INTEGER and large ones are BIGINT, instead
+  // of this all-or-nothing flag.
   bool parseIntegerAsBigint = true;
+
   // Controls whether to parse the values in an IN list as separate arguments or
   // as a single array argument.
   bool parseInListAsArray = true;
 
+  // DuckDB defaults the window frame end bound to CURRENT ROW even when ORDER
+  // BY is absent. The SQL standard requires UNBOUNDED FOLLOWING in that case.
+  // When true, corrects this default.
+  bool correctWindowFrameDefault = false;
+
   /// SQL functions could be registered with different prefixes by the user.
   /// This parameter is the registered prefix of presto or spark functions,
   /// which helps generate the correct Velox expression.
   std::string functionPrefix;
 };
 
-core::ExprPtr parseExpr(const std::string& expr, const ParseOptions& options);
+/// Parses SQL expressions using DuckDB SQL dialect:
+/// https://duckdb.org/docs/stable/sql/dialect/overview
+class DuckSqlExpressionsParser : public SqlExpressionsParser {
+ public:
+  DuckSqlExpressionsParser(const ParseOptions& options = {});
 
-struct OrderByClause {
-  core::ExprPtr expr;
-  bool ascending;
-  bool nullsFirst;
-};
+  core::ExprPtr parseExpr(const std::string& expr) override;
+
+  std::vector<core::ExprPtr> parseExprs(const std::string& expr) override;
 
-OrderByClause parseOrderByExpr(const std::string& expr);
+  OrderByClause parseOrderByExpr(const std::string& expr) override;
 
-std::vector<core::ExprPtr> parseMultipleExpressions(
-    const std::string& expr,
-    const ParseOptions& options);
+  core::AggregateCallExprPtr parseAggregateExpr(
+      const std::string& expr) override;
+
+  core::WindowCallExprPtr parseWindowExpr(const std::string& expr) override;
+
+  core::ExprPtr parseScalarOrWindowExpr(const std::string& expr) override;
+
+ private:
+  const facebook::velox::duckdb::ParseOptions options_;
+};
 
 } // namespace facebook::velox::parse
diff --git a/velox/parse/IExpr.h b/velox/parse/IExpr.h
index a8fe79d66ef..e42abdd017b 100644
--- a/velox/parse/IExpr.h
+++ b/velox/parse/IExpr.h
@@ -16,10 +16,13 @@
 #pragma once
 
 #include <fmt/format.h>
+#include <folly/container/F14Map.h>
+#include <folly/container/F14Set.h>
 #include <memory>
 #include <optional>
 #include <string>
 #include <vector>
+#include "velox/common/EnumDeclare.h"
 #include "velox/common/base/BitUtil.h"
 #include "velox/common/base/Exceptions.h"
 
@@ -39,8 +42,13 @@ class IExpr {
     kConstant = 4,
     kLambda = 5,
     kSubquery = 6,
+    kConcat = 7,
+    kAggregate = 8,
+    kWindow = 9,
   };
 
+  VELOX_DECLARE_EMBEDDED_ENUM_NAME(Kind)
+
   explicit IExpr(
       Kind kind,
       std::vector<ExprPtr> inputs,
@@ -53,6 +61,10 @@ class IExpr {
     return kind_;
   }
 
+  std::string_view kindName() const {
+    return toName(kind_);
+  }
+
   bool is(Kind kind) const {
     return kind_ == kind;
   }
@@ -82,8 +94,20 @@ class IExpr {
 
   virtual std::string toString() const = 0;
 
+  /// Returns a copy of this expression with the given inputs.
   virtual ExprPtr replaceInputs(std::vector<ExprPtr> newInputs) const = 0;
 
+  /// Returns a copy of this expression with the the new alias added.
+  ///
+  /// The last alias added will win if called multiple times. Throws in case the
+  /// subclass does not implement it.
+  virtual ExprPtr withAlias(const std::string& alias) const {
+    VELOX_FAIL("Unable to add alias to expression '{}'", *this);
+  }
+
+  /// Returns a copy of this expression with the alias removed.
+  virtual ExprPtr dropAlias() const = 0;
+
   size_t hash() const {
     size_t hash = localHash();
     for (size_t i = 0; i < inputs_.size(); ++i) {
@@ -101,6 +125,10 @@ class IExpr {
 
   virtual bool operator==(const IExpr& other) const = 0;
 
+  friend std::ostream& operator<<(std::ostream& os, const IExpr& expr) {
+    return os << expr.toString();
+  }
+
  protected:
   // Returns a hash that include values specific to the expression. Doesn't
   // include inputs, kind or alias.
@@ -148,4 +176,33 @@ struct IExprEqual {
   }
 };
 
+/// Hash set for ExprPtr using semantic equality (compares expression values,
+/// not pointers).
+using ExprSet = folly::F14FastSet<ExprPtr, IExprHash, IExprEqual>;
+
+/// Hash map with ExprPtr keys using semantic equality (compares expression
+/// values, not pointers).
+template <typename V>
+using ExprMap = folly::F14FastMap<ExprPtr, V, IExprHash, IExprEqual>;
+
 } // namespace facebook::velox::core
+
+template <>
+struct fmt::formatter<facebook::velox::core::IExpr>
+    : fmt::formatter<std::string> {
+  auto format(const facebook::velox::core::IExpr& expr, format_context& ctx)
+      const {
+    return fmt::formatter<std::string>::format(expr.toString(), ctx);
+  }
+};
+
+// For ExprPtr (shared_ptr)
+template <>
+struct fmt::formatter<facebook::velox::core::ExprPtr>
+    : fmt::formatter<std::string> {
+  auto format(const facebook::velox::core::ExprPtr& expr, format_context& ctx)
+      const {
+    return fmt::formatter<std::string>::format(
+        expr ? expr->toString() : "null", ctx);
+  }
+};
diff --git a/velox/parse/QueryPlanner.cpp b/velox/parse/QueryPlanner.cpp
index 6590453c289..3b2a7b1ede0 100644
--- a/velox/parse/QueryPlanner.cpp
+++ b/velox/parse/QueryPlanner.cpp
@@ -58,8 +58,9 @@ struct QueryContext {
   MakeTableScan makeTableScan;
   bool isInDelimJoin{false};
 
-  QueryContext(const std::unordered_map<std::string, std::vector<RowVectorPtr>>&
-                   _inMemoryTables)
+  QueryContext(
+      const std::unordered_map<std::string, std::vector<RowVectorPtr>>&
+          _inMemoryTables)
       : inMemoryTables{_inMemoryTables} {}
 
   std::string nextNodeId() {
@@ -182,8 +183,9 @@ PlanNodePtr toVeloxPlan(
         children.push_back(rowVector->childAt(columnIds[i]));
       }
     }
-    data.push_back(std::make_shared<RowVector>(
-        pool, rowType, nullptr, rowVector->size(), children));
+    data.push_back(
+        std::make_shared<RowVector>(
+            pool, rowType, nullptr, rowVector->size(), children));
   }
 
   return std::make_shared<ValuesNode>(queryContext.nextNodeId(), data);
@@ -436,8 +438,9 @@ PlanNodePtr toVeloxPlan(
       } else {
         identityProjection = false;
         projectNames.push_back(queryContext.nextColumnName("_p"));
-        fieldInputs.push_back(std::make_shared<FieldAccessTypedExpr>(
-            input->type(), projectNames.back()));
+        fieldInputs.push_back(
+            std::make_shared<FieldAccessTypedExpr>(
+                input->type(), projectNames.back()));
       }
     }
 
@@ -463,8 +466,9 @@ PlanNodePtr toVeloxPlan(
     } else {
       identityProjection = false;
       projectNames.push_back(queryContext.nextColumnName("_p"));
-      groupingKeys.push_back(std::make_shared<FieldAccessTypedExpr>(
-          groupingExpr->type(), projectNames.back()));
+      groupingKeys.push_back(
+          std::make_shared<FieldAccessTypedExpr>(
+              groupingExpr->type(), projectNames.back()));
     }
   }
 
@@ -491,7 +495,8 @@ PlanNodePtr toVeloxPlan(
       std::vector<FieldAccessTypedExprPtr>{}, // preGroupedKeys
       names,
       std::move(aggregates),
-      false, // ignoreNullKeys
+      /*ignoreNullKeys=*/false,
+      /*noGroupsSpanBatches=*/false,
       source);
 }
 
@@ -836,8 +841,9 @@ PlanNodePtr processDelimGetJoin(
     names.push_back(queryContext.nextColumnName("_delim"));
     auto rightIndex = delimAlias[i];
     auto type = rightType->childAt(rightIndex);
-    exprs.push_back(std::make_shared<FieldAccessTypedExpr>(
-        type, rightType->nameOf(rightIndex)));
+    exprs.push_back(
+        std::make_shared<FieldAccessTypedExpr>(
+            type, rightType->nameOf(rightIndex)));
   }
   for (auto i = 0; i < rightType->size(); ++i) {
     names.push_back(rightType->nameOf(i));
@@ -887,8 +893,9 @@ PlanNodePtr processDelimGetJoin(
     names.push_back(queryContext.nextColumnName("_delim"));
     auto rightIndex = delimAlias[i];
     auto type = rightType->childAt(rightIndex);
-    exprs.push_back(std::make_shared<FieldAccessTypedExpr>(
-        type, rightType->nameOf(rightIndex)));
+    exprs.push_back(
+        std::make_shared<FieldAccessTypedExpr>(
+            type, rightType->nameOf(rightIndex)));
   }
   for (auto i = 0; i < rightType->size(); ++i) {
     names.push_back(rightType->nameOf(i));
diff --git a/velox/parse/SqlExpressionsParser.cpp b/velox/parse/SqlExpressionsParser.cpp
new file mode 100644
index 00000000000..3dfc49fa796
--- /dev/null
+++ b/velox/parse/SqlExpressionsParser.cpp
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/parse/SqlExpressionsParser.h"
+
+namespace facebook::velox::parse {
+
+std::string OrderByClause::toString() const {
+  return fmt::format(
+      "{} {} NULLS {}",
+      expr->toString(),
+      (ascending ? "ASC" : "DESC"),
+      (nullsFirst ? "FIRST" : "LAST"));
+}
+
+} // namespace facebook::velox::parse
diff --git a/velox/parse/SqlExpressionsParser.h b/velox/parse/SqlExpressionsParser.h
new file mode 100644
index 00000000000..031e70a6b3b
--- /dev/null
+++ b/velox/parse/SqlExpressionsParser.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <string>
+#include "velox/parse/Expressions.h"
+#include "velox/parse/IExpr.h"
+
+namespace facebook::velox::parse {
+
+/// Represents a single ORDER BY key with sort direction and nulls ordering.
+struct OrderByClause {
+  core::ExprPtr expr;
+  bool ascending;
+  bool nullsFirst;
+
+  std::string toString() const;
+};
+
+class SqlExpressionsParser {
+ public:
+  virtual ~SqlExpressionsParser() = default;
+
+  /// Parses a single expression. Throws on error.
+  virtual core::ExprPtr parseExpr(const std::string& expr) = 0;
+
+  /// Parses a comma-separated list of expressions. Throws on error.
+  virtual std::vector<core::ExprPtr> parseExprs(const std::string& expr) = 0;
+
+  /// Parses an expression that represents an ORDER BY clause. Throws on error.
+  virtual OrderByClause parseOrderByExpr(const std::string& expr) = 0;
+
+  /// Parses an aggregate function call with optional FILTER, ORDER BY,
+  /// and DISTINCT. Always returns an AggregateCallExpr. Throws on error.
+  virtual core::AggregateCallExprPtr parseAggregateExpr(
+      const std::string& expr) = 0;
+
+  /// Parses a window function expression. Returns a WindowCallExpr.
+  /// Throws on error.
+  virtual core::WindowCallExprPtr parseWindowExpr(const std::string& expr) = 0;
+
+  /// Parses a SQL expression that can be either a scalar expression or a
+  /// window function. Returns a WindowCallExpr (kWindow kind) for window
+  /// functions, or a regular ExprPtr for scalar expressions.
+  virtual core::ExprPtr parseScalarOrWindowExpr(const std::string& expr) = 0;
+};
+
+} // namespace facebook::velox::parse
diff --git a/velox/parse/TypeResolver.cpp b/velox/parse/TypeResolver.cpp
index 1ae655be18c..298b97524bd 100644
--- a/velox/parse/TypeResolver.cpp
+++ b/velox/parse/TypeResolver.cpp
@@ -22,7 +22,7 @@
 #include "velox/functions/FunctionRegistry.h"
 #include "velox/parse/Expressions.h"
 #include "velox/type/Type.h"
-#include "velox/vector/VariantToVector.h"
+#include "velox/vector/BaseVector.h"
 
 namespace facebook::velox::parse {
 namespace {
@@ -64,6 +64,15 @@ TypePtr resolveType(
     inputTypes.emplace_back(input->type());
   }
 
+  if (expr->name() == "row_constructor") {
+    const auto numInput = inputTypes.size();
+    std::vector<std::string> names(numInput);
+    for (auto i = 0; i < numInput; i++) {
+      names[i] = fmt::format("c{}", i + 1);
+    }
+    return ROW(std::move(names), std::move(inputTypes));
+  }
+
   if (auto resolvedType =
           exec::resolveTypeForSpecialForm(expr->name(), inputTypes)) {
     return resolvedType;
@@ -324,23 +333,16 @@ TypedExprPtr Expressions::inferTypes(
   }
 
   if (auto constant = std::dynamic_pointer_cast<const ConstantExpr>(expr)) {
-    if (constant->type()->kind() == TypeKind::ARRAY) {
-      // Transform variant vector into an ArrayVector, then wrap it into a
-      // ConstantVector<ComplexType>.
-      VELOX_CHECK_NOT_NULL(
-          pool, "parsing array literals requires a memory pool");
-      VectorPtr constantVector;
-      if (constant->value().isNull()) {
-        constantVector =
-            BaseVector::createNullConstant(constant->type(), 1, pool);
-      } else {
-        constantVector =
-            variantToVector(constant->type(), constant->value(), pool);
-      }
-      return std::make_shared<ConstantTypedExpr>(constantVector);
+    if (constant->type()->isPrimitiveType() || constant->value().isNull()) {
+      return std::make_shared<ConstantTypedExpr>(
+          constant->type(), constant->value());
     }
-    return std::make_shared<ConstantTypedExpr>(
-        constant->type(), constant->value());
+
+    VELOX_CHECK_NOT_NULL(
+        pool, "parsing complex literals requires a memory pool");
+    auto constantVector = BaseVector::createConstant(
+        constant->type(), constant->value(), 1, pool);
+    return std::make_shared<ConstantTypedExpr>(constantVector);
   }
 
   if (auto cast = std::dynamic_pointer_cast<const CastExpr>(expr)) {
@@ -496,7 +498,7 @@ TypedExprPtr Expressions::tryResolveCallWithLambdas(
   }
 
   // Resolve lambda arguments.
-  exec::SignatureBinder binder(*signature, childTypes);
+  exec::SignatureBinder binder(*signature, childTypes, TypeCoercer::defaults());
   binder.tryBind();
   for (auto i = 0; i < numArgs; ++i) {
     if (signature->isLambdaArgumentAt(i)) {
diff --git a/velox/parse/tests/ExprTest.cpp b/velox/parse/tests/ExprTest.cpp
index 79444db7094..b0b09070b06 100644
--- a/velox/parse/tests/ExprTest.cpp
+++ b/velox/parse/tests/ExprTest.cpp
@@ -66,5 +66,20 @@ TEST_F(ExprTest, hashMap) {
   }
 }
 
+TEST_F(ExprTest, dropAlias) {
+  EXPECT_EQ(parse("a + b")->dropAlias()->toString(), R"(plus("a","b"))");
+  EXPECT_EQ(parse("a + b as c")->dropAlias()->toString(), R"(plus("a","b"))");
+
+  EXPECT_EQ(
+      parse("cast(a as date)")->dropAlias()->toString(),
+      R"(cast("a" as DATE))");
+  EXPECT_EQ(
+      parse("cast(a as date) as b")->dropAlias()->toString(),
+      R"(cast("a" as DATE))");
+
+  EXPECT_EQ(parse("a + 10")->dropAlias()->toString(), R"(plus("a",10))");
+  EXPECT_EQ(parse("a + 10 as b")->dropAlias()->toString(), R"(plus("a",10))");
+}
+
 } // namespace
 } // namespace facebook::velox::core
diff --git a/velox/python/CMakeLists.txt b/velox/python/CMakeLists.txt
index 0e52234931f..0568aac6453 100644
--- a/velox/python/CMakeLists.txt
+++ b/velox/python/CMakeLists.txt
@@ -99,7 +99,12 @@ pyvelox_add_module(plan_builder MODULE plan_builder/plan_builder.cpp)
 target_link_libraries(plan_builder PRIVATE velox_py_plan_builder_lib)
 
 # pyvelox.runner library:
-add_library(velox_py_local_runner_lib runner/PyLocalRunner.cpp runner/PyConnectors.cpp)
+add_library(
+  velox_py_local_runner_lib
+  runner/PyLocalRunner.cpp
+  runner/PyLocalDebuggerRunner.cpp
+  runner/PyConnectors.cpp
+)
 target_include_directories(
   velox_py_local_runner_lib
   PUBLIC ${PROJECT_SOURCE_DIR}/velox/external/xxhash
@@ -119,6 +124,7 @@ target_link_libraries(
   velox_dwio_dwrf_writer
   pybind11::module
 )
+target_compile_options(velox_py_local_runner_lib PRIVATE -Wno-missing-field-initializers)
 
 pyvelox_add_module(runner MODULE runner/runner.cpp)
 target_link_libraries(runner PRIVATE velox_py_local_runner_lib)
diff --git a/velox/python/arrow/arrow.pyi b/velox/python/arrow/arrow.pyi
index aec7a8b1c5f..37aed8dd939 100644
--- a/velox/python/arrow/arrow.pyi
+++ b/velox/python/arrow/arrow.pyi
@@ -15,7 +15,7 @@
 # pyre-unsafe
 
 from pyvelox.vector import Vector
-from pyarrow import Array
+from pyarrow import Array, RecordBatch
 
-def to_velox(array: Array) -> Vector: ...
+def to_velox(array: Array | RecordBatch) -> Vector: ...
 def to_arrow(vector: Vector) -> Array: ...
diff --git a/velox/python/file/PyFile.cpp b/velox/python/file/PyFile.cpp
index 56aa9105cff..e7ad6304bfa 100644
--- a/velox/python/file/PyFile.cpp
+++ b/velox/python/file/PyFile.cpp
@@ -17,6 +17,7 @@
 #include "velox/python/file/PyFile.h"
 #include <fmt/format.h>
 #include <folly/String.h>
+#include "velox/common/io/IoStatistics.h"
 #include "velox/dwio/common/ReaderFactory.h"
 
 namespace facebook::velox::py {
@@ -55,10 +56,13 @@ PyType PyFile::getSchema() {
                         ->openFileForRead(filePath_);
     auto input = std::make_unique<dwio::common::BufferedInput>(
         std::shared_ptr<ReadFile>(std::move(readFile)), *leafPool);
-    auto reader =
-        dwio::common::getReaderFactory(fileFormat_)
-            ->createReader(
-                std::move(input), dwio::common::ReaderOptions{leafPool.get()});
+    auto dataIoStats = std::make_shared<io::IoStatistics>();
+    auto metadataIoStats = std::make_shared<io::IoStatistics>();
+    dwio::common::ReaderOptions readerOptions(leafPool.get());
+    readerOptions.setDataIoStats(dataIoStats);
+    readerOptions.setMetadataIoStats(metadataIoStats);
+    auto reader = dwio::common::getReaderFactory(fileFormat_)
+                      ->createReader(std::move(input), readerOptions);
     fileSchema_ = reader->rowType();
   }
   return PyType{fileSchema_};
diff --git a/velox/python/legacy/pyvelox.cpp b/velox/python/legacy/pyvelox.cpp
index d8de1fea3e0..6d5511de7a9 100644
--- a/velox/python/legacy/pyvelox.cpp
+++ b/velox/python/legacy/pyvelox.cpp
@@ -19,6 +19,11 @@
 #include "conversion.h"
 #include "serde.h"
 #include "signatures.h"
+#include "velox/external/utf8proc/utf8procImpl.h"
+
+#ifndef PYVELOX_VERSION
+#define PYVELOX_VERSION dev
+#endif
 
 namespace facebook::velox::py {
 using namespace velox;
@@ -88,8 +93,7 @@ static VectorPtr variantsToFlatVector(
     const std::vector<velox::variant>& variants,
     facebook::velox::memory::MemoryPool* pool) {
   using NativeType = typename TypeTraits<T>::NativeType;
-  constexpr bool kNeedsHolder =
-      (T == TypeKind::VARCHAR || T == TypeKind::VARBINARY);
+  constexpr bool kNeedsHolder = is_string_kind(T);
 
   TypePtr type = createScalarType(T);
   auto result =
@@ -291,8 +295,7 @@ static void addExpressionBindings(
           },
           "Evaluates the expression, taking in a map from names to input vectors")
       .def_static("from_string", [](std::string& str) {
-        parse::ParseOptions opts;
-        return IExprWrapper{parse::parseExpr(str, opts)};
+        return IExprWrapper{parse::DuckSqlExpressionsParser().parseExpr(str)};
       });
 }
 
diff --git a/velox/python/legacy/pyvelox.h b/velox/python/legacy/pyvelox.h
index a95956a407b..a47d8e691ab 100644
--- a/velox/python/legacy/pyvelox.h
+++ b/velox/python/legacy/pyvelox.h
@@ -304,9 +304,10 @@ inline void addDataTypeBindings(
   mapType.def("key_type", &MapType::keyType, "Return the key type");
   mapType.def("value_type", &MapType::valueType, "Return the value type");
 
-  rowType.def(py::init<
-              std::vector<std::string>,
-              std::vector<std::shared_ptr<const Type>>>());
+  rowType.def(
+      py::init<
+          std::vector<std::string>,
+          std::vector<std::shared_ptr<const Type>>>());
   rowType.def("size", &RowType::size, "Return the number of columns");
   rowType.def(
       "child_at",
diff --git a/velox/python/plan_builder/PyPlanBuilder.cpp b/velox/python/plan_builder/PyPlanBuilder.cpp
index fc5ccae96fc..4cae31b6ce0 100644
--- a/velox/python/plan_builder/PyPlanBuilder.cpp
+++ b/velox/python/plan_builder/PyPlanBuilder.cpp
@@ -23,6 +23,8 @@
 #include "velox/connectors/tpch/TpchConnectorSplit.h"
 #include "velox/core/PlanNode.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/parse/ExpressionsParser.h"
+#include "velox/parse/TypeResolver.h"
 #include "velox/python/vector/PyVector.h"
 #include "velox/tpch/gen/TpchGen.h"
 
@@ -96,8 +98,8 @@ PyPlanBuilder& PyPlanBuilder::tableWrite(
 
 PyPlanBuilder& PyPlanBuilder::tableScan(
     const PyType& outputSchema,
-    const py::dict& aliases,
-    const py::dict& subfields,
+    const std::unordered_map<std::string, std::string>& aliases,
+    const std::unordered_map<std::string, std::vector<int64_t>>& subfields,
     const std::vector<std::string>& filters,
     const std::string& remainingFilter,
     const std::string& rowIndexColumnName,
@@ -112,21 +114,6 @@ PyPlanBuilder& PyPlanBuilder::tableScan(
     throw std::runtime_error("Output schema must be a ROW().");
   }
 
-  // If there are any aliases, convert to std container and add to the builder.
-  std::unordered_map<std::string, std::string> aliasMap;
-
-  if (!aliases.empty()) {
-    for (const auto& item : aliases) {
-      if (!py::isinstance<py::str>(item.first) ||
-          !py::isinstance<py::str>(item.second)) {
-        throw std::runtime_error(
-            "Keys and values from aliases map need to be strings.");
-      }
-      aliasMap[item.first.cast<std::string>()] =
-          item.second.cast<std::string>();
-    }
-  }
-
   // If there are subfields, create the appropriate structures and add to the
   // scan.
   if (!subfields.empty() || !rowIndexColumnName.empty()) {
@@ -137,31 +124,22 @@ PyPlanBuilder& PyPlanBuilder::tableScan(
       auto type = outputRowSchema->childAt(i);
       std::vector<common::Subfield> requiredSubfields;
 
-      py::object key = py::cast(name);
-
       // Check if the column was aliased by the user.
-      auto it = aliasMap.find(name);
-      auto hiveName = it == aliasMap.end() ? name : it->second;
-
-      if (subfields.contains(key)) {
-        py::handle value = subfields[key];
-        if (!py::isinstance<py::list>(value)) {
-          throw std::runtime_error(
-              "Subfield map value should be a list of integers.");
-        }
-
-        auto values = value.cast<std::vector<int64_t>>();
+      auto it = aliases.find(name);
+      auto hiveName = it == aliases.end() ? name : it->second;
 
-        // TODO: Assume for now they are fields in a flap map.
-        for (const auto& subfield : values) {
+      auto subfieldIt = subfields.find(name);
+      if (subfieldIt != subfields.end()) {
+        // TODO: Assume for now they are fields in a flat map.
+        for (const auto& subfield : subfieldIt->second) {
           requiredSubfields.emplace_back(
               fmt::format("{}[{}]", hiveName, subfield));
         }
       }
 
       auto columnType = (name == rowIndexColumnName)
-          ? HiveColumnHandle::ColumnType::kRowIndex
-          : HiveColumnHandle::ColumnType::kRegular;
+          ? FileColumnHandle::ColumnType::kRowIndex
+          : FileColumnHandle::ColumnType::kRegular;
 
       auto columnHandle = std::make_shared<HiveColumnHandle>(
           hiveName, columnType, type, type, std::move(requiredSubfields));
@@ -181,7 +159,7 @@ PyPlanBuilder& PyPlanBuilder::tableScan(
   }
 
   builder.outputType(outputRowSchema)
-      .columnAliases(std::move(aliasMap))
+      .columnAliases(aliases)
       .connectorId(connectorId)
       .endTableScan();
 
@@ -189,8 +167,9 @@ PyPlanBuilder& PyPlanBuilder::tableScan(
   std::vector<std::shared_ptr<connector::ConnectorSplit>> splits;
   if (inputFiles.has_value()) {
     for (const auto& inputFile : *inputFiles) {
-      splits.push_back(std::make_shared<connector::hive::HiveConnectorSplit>(
-          connectorId, inputFile.filePath(), inputFile.fileFormat()));
+      splits.push_back(
+          std::make_shared<connector::hive::HiveConnectorSplit>(
+              connectorId, inputFile.filePath(), inputFile.fileFormat()));
     }
   }
 
@@ -306,7 +285,8 @@ PyPlanBuilder& PyPlanBuilder::indexLookupJoin(
         rightKeys,
         tableScanNode,
         {},
-        /*includeMatchColumn=*/false,
+        /*filter=*/"",
+        /*hasMarker=*/false,
         output,
         joinType);
   } else {
@@ -342,6 +322,33 @@ PyPlanBuilder& PyPlanBuilder::sortedMerge(
   return *this;
 }
 
+PyPlanBuilder& PyPlanBuilder::markSorted(
+    const std::string& markerKey,
+    const std::vector<std::string>& sortingKeys) {
+  // Parse sorting keys using the DuckDB parser (same as orderBy).
+  std::vector<std::string> keyNames;
+  std::vector<core::SortOrder> sortingOrders;
+
+  for (const auto& key : sortingKeys) {
+    auto orderBy = parse::DuckSqlExpressionsParser().parseOrderByExpr(key);
+    auto typedExpr = core::Expressions::inferTypes(
+        orderBy.expr, planBuilder_.planNode()->outputType(), pool_.get());
+
+    auto fieldExpr =
+        std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(typedExpr);
+    if (!fieldExpr) {
+      throw std::runtime_error(
+          "markSorted sorting key must be a column reference: " + key);
+    }
+
+    keyNames.push_back(fieldExpr->name());
+    sortingOrders.emplace_back(orderBy.ascending, orderBy.nullsFirst);
+  }
+
+  planBuilder_.markSorted(markerKey, keyNames, sortingOrders);
+  return *this;
+}
+
 PyPlanBuilder& PyPlanBuilder::tpchGen(
     const std::string& tableName,
     const std::vector<std::string>& columns,
@@ -359,8 +366,9 @@ PyPlanBuilder& PyPlanBuilder::tpchGen(
   // Generate one split per part.
   std::vector<std::shared_ptr<connector::ConnectorSplit>> splits;
   for (size_t i = 0; i < numParts; ++i) {
-    splits.push_back(std::make_shared<connector::tpch::TpchConnectorSplit>(
-        connectorId, numParts, i));
+    splits.push_back(
+        std::make_shared<connector::tpch::TpchConnectorSplit>(
+            connectorId, numParts, i));
   }
 
   planContext_->scanFiles[planBuilder_.planNode()->id()] = std::move(splits);
diff --git a/velox/python/plan_builder/PyPlanBuilder.h b/velox/python/plan_builder/PyPlanBuilder.h
index b9b1bbbb773..8c3f50f0276 100644
--- a/velox/python/plan_builder/PyPlanBuilder.h
+++ b/velox/python/plan_builder/PyPlanBuilder.h
@@ -175,8 +175,8 @@ class PyPlanBuilder {
   ///  )
   PyPlanBuilder& tableScan(
       const PyType& outputSchema,
-      const pybind11::dict& aliases,
-      const pybind11::dict& subfields,
+      const std::unordered_map<std::string, std::string>& aliases,
+      const std::unordered_map<std::string, std::vector<int64_t>>& subfields,
       const std::vector<std::string>& filters,
       const std::string& remainingFilter,
       const std::string& rowIndexColumnName,
@@ -344,6 +344,20 @@ class PyPlanBuilder {
       const std::vector<std::string>& keys,
       const std::vector<std::optional<PyPlanNode>>& sources);
 
+  /// Adds a MarkSorted node that validates sortedness of input data.
+  /// For each input row, adds a boolean column indicating whether the row
+  /// is in sorted order relative to the previous row (based on the specified
+  /// sorting keys).
+  ///
+  /// @param markerKey The name of the output boolean column.
+  /// @param sortingKeys List of columns that define the sort order. The
+  /// strings can be column names and optionally contain the sort orientation
+  /// and null handling (e.g., "col", "col DESC", "col NULLS FIRST",
+  /// "col DESC NULLS FIRST").
+  PyPlanBuilder& markSorted(
+      const std::string& markerKey,
+      const std::vector<std::string>& sortingKeys);
+
   /// Generates TPC-H data on the fly using dbgen. Note that generating data on
   /// the fly is not terribly efficient, so for performance evaluation one
   /// should generate data using this node, write it to output storage files,
diff --git a/velox/python/plan_builder/plan_builder.cpp b/velox/python/plan_builder/plan_builder.cpp
index 9b0b1fc219a..733c1e15e55 100644
--- a/velox/python/plan_builder/plan_builder.cpp
+++ b/velox/python/plan_builder/plan_builder.cpp
@@ -95,8 +95,9 @@ PYBIND11_MODULE(plan_builder, m) {
           "table_scan",
           &velox::py::PyPlanBuilder::tableScan,
           py::arg("output_schema") = velox::py::PyType{},
-          py::arg("aliases") = py::dict{},
-          py::arg("subfields") = py::dict{},
+          py::arg("aliases") = std::unordered_map<std::string, std::string>{},
+          py::arg("subfields") =
+              std::unordered_map<std::string, std::vector<int64_t>>{},
           py::arg("filters") = std::vector<std::string>{},
           py::arg("remaining_filter") = "",
           py::arg("row_index") = "",
@@ -334,6 +335,23 @@ PYBIND11_MODULE(plan_builder, m) {
           keys: The sorting keys.
           sources: The list of sources to merge.
       )"))
+      .def(
+          "mark_sorted",
+          &velox::py::PyPlanBuilder::markSorted,
+          py::arg("marker_key"),
+          py::arg("sorting_keys"),
+          py::doc(R"(
+        Adds a MarkSorted node that validates sortedness of input data.
+        For each input row, adds a boolean column indicating whether the row
+        is in sorted order relative to the previous row.
+
+        Args:
+          marker_key: The name of the output boolean column.
+          sorting_keys: List of columns that define the sort order. The
+                        strings can be column names and optionally contain
+                        the sort orientation and null handling (e.g., "col",
+                        "col DESC", "col NULLS FIRST", "col DESC NULLS FIRST").
+      )"))
       .def(
           "tpch_gen",
           &velox::py::PyPlanBuilder::tpchGen,
diff --git a/velox/python/plan_builder/plan_builder.pyi b/velox/python/plan_builder/plan_builder.pyi
index 26d0d9c9c54..a23e2444323 100644
--- a/velox/python/plan_builder/plan_builder.pyi
+++ b/velox/python/plan_builder/plan_builder.pyi
@@ -19,6 +19,7 @@ from typing import Optional
 
 from pyvelox.file import File
 from pyvelox.type import Type
+from pyvelox.vector import Vector
 
 class JoinType(Enum):
     INNER = 1
@@ -28,6 +29,7 @@ class JoinType(Enum):
 
 class PlanNode:
     def name(self) -> str: ...
+    def id(self) -> str: ...
     def serialize(self) -> str: ...
     def to_string(self) -> str: ...
 
@@ -52,6 +54,14 @@ class PlanBuilder:
         num_parts: int = 1,
         connector_id: str = "tpch",
     ) -> PlanBuilder: ...
+    def values(
+        self,
+        values: list[Vector],
+    ) -> PlanBuilder: ...
+    def project(
+        self,
+        projections: list[str],
+    ) -> PlanBuilder: ...
     def hash_join(
         self,
         left_keys: list[str],
@@ -85,6 +95,11 @@ class PlanBuilder:
         ordinal_column: Optional[str] = None,
         empty_unnest_value_name: Optional[str] = None,
     ) -> PlanBuilder: ...
+    def mark_sorted(
+        self,
+        marker_key: str,
+        sorting_keys: list[str],
+    ) -> PlanBuilder: ...
     def get_plan_node(self) -> PlanNode: ...
     def new_builder(self) -> PlanBuilder: ...
     def id(self) -> str: ...
diff --git a/velox/python/runner/PyConnectors.cpp b/velox/python/runner/PyConnectors.cpp
index 5357985b8c1..c94204e6188 100644
--- a/velox/python/runner/PyConnectors.cpp
+++ b/velox/python/runner/PyConnectors.cpp
@@ -15,6 +15,10 @@
  */
 
 #include "velox/python/runner/PyConnectors.h"
+
+#include <stdexcept>
+
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/connectors/tpch/TpchConnector.h"
 
@@ -35,7 +39,8 @@ void registerConnector(
   TConnectorFactory factory;
   auto connector = factory.newConnector(
       connectorId, configBase, folly::getGlobalCPUExecutor().get());
-  connector::registerConnector(connector);
+  connector::ConnectorRegistry::global().insert(
+      connector->connectorId(), connector);
   connectorRegistry().insert(connectorId);
 }
 
@@ -57,7 +62,8 @@ void registerTpch(
 
 // Is it ok to unregister connectors that were not registered.
 void unregister(const std::string& connectorId) {
-  if (!facebook::velox::connector::unregisterConnector(connectorId)) {
+  if (!facebook::velox::connector::ConnectorRegistry::global().erase(
+          connectorId)) {
     throw std::runtime_error(
         fmt::format("Unable to unregister connector '{}'", connectorId));
   }
diff --git a/velox/python/runner/PyConnectors.h b/velox/python/runner/PyConnectors.h
index 0c3dfa7bf52..98401105c5c 100644
--- a/velox/python/runner/PyConnectors.h
+++ b/velox/python/runner/PyConnectors.h
@@ -16,7 +16,8 @@
 
 #pragma once
 
-#include <pybind11/embed.h>
+#include <string>
+#include <unordered_map>
 
 namespace facebook::velox::py {
 
diff --git a/velox/python/runner/PyLocalDebuggerRunner.cpp b/velox/python/runner/PyLocalDebuggerRunner.cpp
new file mode 100644
index 00000000000..51296a66c6d
--- /dev/null
+++ b/velox/python/runner/PyLocalDebuggerRunner.cpp
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/python/runner/PyLocalDebuggerRunner.h"
+
+namespace facebook::velox::py {
+
+namespace py = pybind11;
+
+void PyLocalDebuggerRunner::setBreakpoint(const std::string& planNodeId) {
+  breakpoints_[planNodeId] = nullptr;
+}
+
+void PyLocalDebuggerRunner::setHook(
+    const std::string& planNodeId,
+    pybind11::function callback) {
+  // Capture the Python callback and outputPool in a C++ lambda.
+  // The lambda will be called when the breakpoint is hit.
+  auto pool = outputPool_;
+  breakpoints_[planNodeId] = [callback = std::move(callback),
+                              pool](const RowVectorPtr& vector) -> bool {
+    // Acquire the GIL before calling Python code.
+    py::gil_scoped_acquire acquire;
+
+    // Create a PyVector from the RowVectorPtr.
+    PyVector pyVector(vector, pool);
+
+    // Call the Python function and get the result.
+    py::object result = callback(pyVector);
+
+    // Convert the result to bool.
+    return result.cast<bool>();
+  };
+}
+
+exec::CursorParameters PyLocalDebuggerRunner::createCursorParameters(
+    int32_t maxDrivers) {
+  return exec::CursorParameters{
+      .planNode = planNode_,
+      .maxDrivers = maxDrivers,
+      .queryCtx = core::QueryCtx::Builder()
+                      .queryConfig(core::QueryConfig(queryConfigs_))
+                      .pool(rootPool_)
+                      .build(),
+      .outputPool = outputPool_,
+      .serialExecution = true,
+      .breakpoints = breakpoints_,
+  };
+}
+
+} // namespace facebook::velox::py
diff --git a/velox/python/runner/PyLocalDebuggerRunner.h b/velox/python/runner/PyLocalDebuggerRunner.h
new file mode 100644
index 00000000000..405627c09b0
--- /dev/null
+++ b/velox/python/runner/PyLocalDebuggerRunner.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+#include <string>
+
+#include "velox/python/runner/PyLocalRunner.h"
+
+namespace facebook::velox::py {
+
+/// A debugger-enabled extension of PyLocalRunner.
+class PyLocalDebuggerRunner : public PyLocalRunner {
+ public:
+  using PyLocalRunner::PyLocalRunner;
+
+  PyLocalDebuggerRunner(
+      const PyPlanNode& pyPlanNode,
+      const std::shared_ptr<memory::MemoryPool>& pool,
+      const std::shared_ptr<folly::CPUThreadPoolExecutor>& executor)
+      : PyLocalRunner(pyPlanNode, pool, executor) {}
+
+  /// Sets a breakpoint at the specified plan node with no callback.
+  /// The breakpoint will always stop execution.
+  ///
+  /// @param planNodeId The ID of the plan node where execution should pause.
+  void setBreakpoint(const std::string& planNodeId);
+
+  /// Sets a breakpoint at the specified plan node with a Python callback.
+  ///
+  /// The callback is invoked with a PyVector when the breakpoint is hit.
+  /// If the callback returns True, execution stops and the vector is produced.
+  /// If the callback returns False, execution continues without stopping.
+  ///
+  /// @param planNodeId The ID of the plan node where the hook is installed.
+  /// @param callback Python function that takes a PyVector and returns bool.
+  void setHook(const std::string& planNodeId, pybind11::function callback);
+
+ protected:
+  exec::CursorParameters createCursorParameters(int32_t maxDrivers) override;
+
+ private:
+  exec::CursorParameters::TBreakpointMap breakpoints_;
+};
+
+} // namespace facebook::velox::py
diff --git a/velox/python/runner/PyLocalRunner.cpp b/velox/python/runner/PyLocalRunner.cpp
index 9b8df9bfda0..31eb290d316 100644
--- a/velox/python/runner/PyLocalRunner.cpp
+++ b/velox/python/runner/PyLocalRunner.cpp
@@ -54,16 +54,40 @@ exec::Split preparedSplit(
 
 namespace py = pybind11;
 
-PyVector PyTaskIterator::Iterator::operator*() const {
+PyTaskIterator::PyTaskIterator(
+    std::shared_ptr<memory::MemoryPool> pool,
+    std::shared_ptr<exec::TaskCursor> cursor)
+    : outputPool_(std::move(pool)), cursor_(std::move(cursor)) {
+  if (outputPool_ == nullptr) {
+    throw std::runtime_error(
+        "Memory pool cannot be nullptr when constructing PyTaskIterator.");
+  }
+  if (cursor_ == nullptr) {
+    throw std::runtime_error(
+        "Cursor cannot be nullptr when constructing PyTaskIterator.");
+  }
+}
+
+PyVector PyTaskIterator::next() {
+  if (!cursor_->moveNext()) {
+    vector_ = nullptr;
+    throw py::stop_iteration(); // Raise StopIteration when done.
+  }
+  vector_ = cursor_->current();
   return PyVector{vector_, outputPool_};
 }
 
-void PyTaskIterator::Iterator::advance() {
-  if (cursor_ && cursor_->moveNext()) {
-    vector_ = cursor_->current();
-  } else {
+PyVector PyTaskIterator::step(const std::string& planId) {
+  if (!cursor_->moveStep(planId)) {
     vector_ = nullptr;
+    throw py::stop_iteration(); // Raise StopIteration when done.
   }
+  vector_ = cursor_->current();
+  return PyVector{vector_, outputPool_};
+}
+
+std::string PyTaskIterator::at() const {
+  return cursor_->at();
 }
 
 PyLocalRunner::PyLocalRunner(
@@ -92,26 +116,23 @@ void PyLocalRunner::addQueryConfig(
   queryConfigs_[configName] = configValue;
 }
 
-py::iterator PyLocalRunner::execute(int32_t maxDrivers) {
-  if (pyIterator_) {
-    throw std::runtime_error("PyLocalRunner can only be executed once.");
-  }
-
-  // Create query context.
-  auto queryCtx = core::QueryCtx::create(
-      executor_.get(),
-      core::QueryConfig(queryConfigs_),
-      {},
-      cache::AsyncDataCache::getInstance(),
-      rootPool_);
-
-  // Initialize task cursor and task.
-  cursor_ = exec::TaskCursor::create({
+exec::CursorParameters PyLocalRunner::createCursorParameters(
+    int32_t maxDrivers) {
+  return exec::CursorParameters{
       .planNode = planNode_,
       .maxDrivers = maxDrivers,
-      .queryCtx = queryCtx,
+      .queryCtx = core::QueryCtx::Builder()
+                      .executor(executor_.get())
+                      .queryConfig(core::QueryConfig(queryConfigs_))
+                      .pool(rootPool_)
+                      .build(),
       .outputPool = outputPool_,
-  });
+  };
+}
+
+PyTaskIterator PyLocalRunner::execute(int32_t maxDrivers) {
+  // Initialize task cursor and task.
+  cursor_ = exec::TaskCursor::create(createCursorParameters(maxDrivers));
 
   // Add any files passed by the client during plan building.
   for (auto& [scanId, splits] : scanFiles_) {
@@ -120,14 +141,13 @@ py::iterator PyLocalRunner::execute(int32_t maxDrivers) {
     }
     cursor_->task()->noMoreSplits(scanId);
   }
+  scanFiles_.clear();
 
   {
     std::lock_guard<std::mutex> guard(taskRegistryLock());
     taskRegistry().push_back(cursor_->task());
   }
-
-  pyIterator_ = std::make_shared<PyTaskIterator>(cursor_, outputPool_);
-  return py::make_iterator(pyIterator_->begin(), pyIterator_->end());
+  return PyTaskIterator{outputPool_, cursor_};
 }
 
 std::string PyLocalRunner::printPlanWithStats() const {
diff --git a/velox/python/runner/PyLocalRunner.h b/velox/python/runner/PyLocalRunner.h
index 5153579351d..b41c0a48da2 100644
--- a/velox/python/runner/PyLocalRunner.h
+++ b/velox/python/runner/PyLocalRunner.h
@@ -16,17 +16,56 @@
 
 #pragma once
 
-#include <pybind11/embed.h>
-
 #include "velox/core/PlanNode.h"
 #include "velox/exec/Cursor.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/python/plan_builder/PyPlanBuilder.h"
 #include "velox/python/type/PyType.h"
+#include "velox/python/vector/PyVector.h"
 
 namespace facebook::velox::py {
 
-class PyTaskIterator;
+/// Iterator class that extracts PyVectors from a TaskCursor created by a Runner
+/// such as PyLocalRunner, providing an iterable API for Python.
+class PyTaskIterator {
+ public:
+  PyTaskIterator(
+      std::shared_ptr<memory::MemoryPool> pool,
+      std::shared_ptr<exec::TaskCursor> cursor);
+
+  PyTaskIterator& iter() {
+    return *this;
+  }
+
+  PyVector next();
+
+  /// Steps through execution, returning either the input to the next operator
+  /// with a breakpoint installed, or the next task output. If no breakpoints
+  /// are set, then step() behaves like next().
+  ///
+  /// If @p planId is non-empty, only stops at a breakpoint whose plan node ID
+  /// matches @p planId; breakpoints for other plan nodes are skipped
+  /// automatically.
+  PyVector step(const std::string& planId = "");
+
+  std::optional<PyVector> current() const {
+    if (!vector_) {
+      return std::nullopt;
+    }
+    return PyVector{vector_, outputPool_};
+  }
+
+  /// Returns the plan node ID where the cursor is currently stopped. This is
+  /// useful for debugging to know where in the plan the execution has paused.
+  std::string at() const;
+
+ private:
+  std::shared_ptr<memory::MemoryPool> outputPool_;
+  std::shared_ptr<exec::TaskCursor> cursor_;
+
+  // Stores the current vector being iterated on.
+  RowVectorPtr vector_{nullptr};
+};
 
 /// A C++ wrapper to allow Python clients to execute plans using TaskCursor.
 ///
@@ -36,11 +75,13 @@ class PyTaskIterator;
 /// @param executor The executor that will be used by drivers.
 class PyLocalRunner {
  public:
-  explicit PyLocalRunner(
+  PyLocalRunner(
       const PyPlanNode& pyPlanNode,
       const std::shared_ptr<memory::MemoryPool>& pool,
       const std::shared_ptr<folly::CPUThreadPoolExecutor>& executor);
 
+  virtual ~PyLocalRunner() = default;
+
   /// Add a split to scan an entire file.
   ///
   /// @param pyFile The Python File object describin the file path and format.
@@ -60,18 +101,30 @@ class PyLocalRunner {
       const std::string& configName,
       const std::string& configValue);
 
-  /// Execute the task and returns an iterable to the output vectors.
+  /// Execute the task and returns an iterable to the output vectors. It's the
+  /// caller's responsibility to ensure that the iterator will outlive the
+  /// runner. This is guaranteed in the Python API by using pybind's
+  /// py::keep_alive<>.
+  ///
+  /// Can be executed many times; it returns a new TaskIterator object with its
+  /// own task cursor underneath. Consumes all splits whenever execute() is
+  /// called.
   ///
   /// @param maxDrivers Maximum number of drivers to use when executing the
   /// plan.
-  pybind11::iterator execute(int32_t maxDrivers = 1);
+  PyTaskIterator execute(int32_t maxDrivers = 1);
 
   /// Prints a descriptive debug message containing plan and execution stats.
   /// If the task hasn't finished, will print the plan with the current stats.
   std::string printPlanWithStats() const;
 
- private:
-  friend class PyTaskIterator;
+ protected:
+  /// Creates the CursorParameters used to execute the plan. Can be overridden
+  /// by subclasses to customize execution behavior.
+  ///
+  /// @param maxDrivers Maximum number of drivers to use when executing the
+  /// plan.
+  virtual exec::CursorParameters createCursorParameters(int32_t maxDrivers);
 
   // Memory pools and thread pool to be used by queryCtx.
   std::shared_ptr<memory::MemoryPool> rootPool_;
@@ -84,9 +137,6 @@ class PyLocalRunner {
   // The task cursor that executed the Velox Task.
   std::shared_ptr<exec::TaskCursor> cursor_;
 
-  // The Python iterator that exposes output vectors.
-  std::shared_ptr<PyTaskIterator> pyIterator_;
-
   // Pointer to the list of splits to be added to the task.
   TScanFiles scanFiles_;
 
@@ -94,60 +144,6 @@ class PyLocalRunner {
   TQueryConfigs queryConfigs_;
 };
 
-// Iterator class that wraps around a PyLocalRunner and provides an iterable API
-// for Python. It needs to provide a .begin() and .end() methods, and the object
-// returned by them needs to be comparable and incrementable.
-class PyTaskIterator {
- public:
-  explicit PyTaskIterator(
-      const std::shared_ptr<exec::TaskCursor>& cursor,
-      const std::shared_ptr<memory::MemoryPool>& pool)
-      : outputPool_(pool), cursor_(cursor) {}
-
-  class Iterator {
-   public:
-    Iterator() {}
-
-    explicit Iterator(
-        const std::shared_ptr<exec::TaskCursor>& cursor,
-        const std::shared_ptr<memory::MemoryPool>& pool)
-        : outputPool_(pool), cursor_(cursor) {
-      // Advance to the first batch.
-      advance();
-    }
-
-    PyVector operator*() const;
-
-    void advance();
-
-    Iterator& operator++() {
-      advance();
-      return *this;
-    }
-
-    bool operator==(const Iterator& other) const {
-      return vector_ == other.vector_;
-    }
-
-   private:
-    std::shared_ptr<memory::MemoryPool> outputPool_;
-    std::shared_ptr<exec::TaskCursor> cursor_;
-    RowVectorPtr vector_{nullptr};
-  };
-
-  Iterator begin() const {
-    return Iterator(cursor_, outputPool_);
-  }
-
-  Iterator end() const {
-    return Iterator();
-  }
-
- private:
-  std::shared_ptr<memory::MemoryPool> outputPool_;
-  std::shared_ptr<exec::TaskCursor> cursor_;
-};
-
 /// To avoid desctruction order issues during shutdown, this function will
 /// iterate over any pending tasks created by this module and wait for their
 /// task and drivers to finish.
diff --git a/velox/python/runner/runner.cpp b/velox/python/runner/runner.cpp
index dd26b69df89..6d58cbbee33 100644
--- a/velox/python/runner/runner.cpp
+++ b/velox/python/runner/runner.cpp
@@ -14,11 +14,13 @@
  * limitations under the License.
  */
 
+#include <folly/system/HardwareConcurrency.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include "velox/python/init/PyInit.h"
 
 #include "velox/python/runner/PyConnectors.h"
+#include "velox/python/runner/PyLocalDebuggerRunner.h"
 #include "velox/python/runner/PyLocalRunner.h"
 
 namespace py = pybind11;
@@ -32,11 +34,43 @@ PYBIND11_MODULE(runner, m) {
   // is about to exit.
   static auto rootPool = velox::memory::memoryManager()->addRootPool();
   static auto executor = std::make_shared<folly::CPUThreadPoolExecutor>(
-      std::thread::hardware_concurrency());
+      folly::available_concurrency());
 
-  // execute() returns an iterator to Vectors.
+  // TaskIterator iterates over Vectors.
   py::module::import("pyvelox.vector");
 
+  /// Iterator class that exposes vectors being created by a Runner in
+  /// execution.
+  py::class_<velox::py::PyTaskIterator>(m, "TaskIterator")
+      .def("__next__", &velox::py::PyTaskIterator::next, py::keep_alive<0, 1>())
+      .def("next", &velox::py::PyTaskIterator::next, py::keep_alive<0, 1>())
+      .def(
+          "step",
+          &velox::py::PyTaskIterator::step,
+          py::arg("plan_id") = "",
+          py::keep_alive<0, 1>(),
+          py::doc(R"(
+        Steps through execution, returning either the input to the next
+        operator with a breakpoint installed, or the next task output.
+        If no breakpoints are set, then step() behaves like next().
+
+        If plan_id is specified, only stops at a breakpoint matching the
+        given plan node ID; breakpoints for other nodes are skipped.
+          )"))
+      .def(
+          "current",
+          &velox::py::PyTaskIterator::current,
+          py::keep_alive<0, 1>())
+      .def("at", &velox::py::PyTaskIterator::at, py::doc(R"(
+        Returns the plan node ID where the cursor is currently stopped.
+        This is useful for debugging to know where in the plan the
+        execution has paused.
+          )"))
+      .def(
+          "__iter__",
+          &velox::py::PyTaskIterator::iter,
+          py::return_value_policy::reference_internal);
+
   py::class_<velox::py::PyLocalRunner>(m, "LocalRunner")
       // Only expose the plan node through the Python API.
       .def(py::init([](const velox::py::PyPlanNode& planNode) {
@@ -46,6 +80,8 @@ PYBIND11_MODULE(runner, m) {
           "execute",
           &velox::py::PyLocalRunner::execute,
           py::arg("max_drivers") = 1,
+          // Keep 'self' alive while iterator is used.
+          py::keep_alive<0, 1>(),
           py::doc(R"(
         Executes a given plan returning an iterator to the output produced
         by the root plan node.
@@ -92,6 +128,41 @@ PYBIND11_MODULE(runner, m) {
           configValue: The configuration value.
           )"));
 
+  py::class_<velox::py::PyLocalDebuggerRunner, velox::py::PyLocalRunner>(
+      m, "LocalDebuggerRunner")
+      // Only expose the plan node through the Python API.
+      .def(py::init([](const velox::py::PyPlanNode& planNode) {
+        return velox::py::PyLocalDebuggerRunner{planNode, rootPool, executor};
+      }))
+      .def(
+          "set_breakpoint",
+          &velox::py::PyLocalDebuggerRunner::setBreakpoint,
+          py::arg("plan_node_id"),
+          py::doc(R"(
+        Sets a breakpoint at the specified plan node. The breakpoint will
+        always stop execution.
+
+        Args:
+          plan_node_id: The ID of the plan node where execution should pause.
+          )"))
+      .def(
+          "set_hook",
+          &velox::py::PyLocalDebuggerRunner::setHook,
+          py::arg("plan_node_id"),
+          py::arg("callback"),
+          py::doc(R"(
+        Sets a breakpoint with a callback at the specified plan node.
+
+        The callback is invoked with a Vector when the breakpoint is hit.
+        If the callback returns True, execution stops and the vector is
+        produced. If the callback returns False, execution continues
+        without stopping.
+
+        Args:
+          plan_node_id: The ID of the plan node where the hook is installed.
+          callback: Python function that takes a Vector and returns bool.
+          )"));
+
   m.def(
        "register_hive",
        &velox::py::registerHive,
diff --git a/velox/python/runner/runner.pyi b/velox/python/runner/runner.pyi
index d511692552b..85170380f69 100644
--- a/velox/python/runner/runner.pyi
+++ b/velox/python/runner/runner.pyi
@@ -25,6 +25,10 @@ class LocalRunner:
     def add_query_config(self, config_name: str, config_value: str) -> None: ...
     def print_plan_with_stats(self) -> str: ...
 
+class LocalDebuggerRunner(LocalRunner):
+    def __init__(self, PlanNode) -> None: ...
+    def set_breakpoint(self, plan_node_id: str) -> None: ...
+
 def register_hive(str) -> None: ...
 def register_tpch(str) -> None: ...
 def unregister(str) -> None: ...
diff --git a/velox/python/type/PyType.h b/velox/python/type/PyType.h
index 7fc2dfdc6c5..2d170ee18a7 100644
--- a/velox/python/type/PyType.h
+++ b/velox/python/type/PyType.h
@@ -16,7 +16,7 @@
 
 #pragma once
 
-#include <pybind11/embed.h>
+#include "velox/functions/prestosql/types/JsonType.h"
 #include "velox/type/Type.h"
 
 namespace facebook::velox::py {
@@ -43,9 +43,11 @@ class PyType {
   // Factory functions:
 
   static PyType createRowType(
-      const std::vector<std::string>& names,
+      std::vector<std::string> names,
       const std::vector<PyType>& pyTypes) {
     std::vector<TypePtr> types;
+    types.reserve(pyTypes.size());
+
     for (const auto& pyType : pyTypes) {
       types.emplace_back(pyType.type());
     }
@@ -53,7 +55,7 @@ class PyType {
     if (names.empty()) {
       return PyType{ROW(std::move(types))};
     }
-    return PyType{ROW(folly::copy(names), std::move(types))};
+    return PyType{ROW(std::move(names), std::move(types))};
   }
 
   static PyType createMapType(const PyType& keyType, const PyType& valueType) {
@@ -104,6 +106,10 @@ class PyType {
     return PyType{VARBINARY()};
   }
 
+  static PyType createJson() {
+    return PyType{JSON()};
+  }
+
  private:
   TypePtr type_;
 };
diff --git a/velox/python/type/type.cpp b/velox/python/type/type.cpp
index fa32615eb92..28f56db1b60 100644
--- a/velox/python/type/type.cpp
+++ b/velox/python/type/type.cpp
@@ -42,6 +42,8 @@ PYBIND11_MODULE(type, m) {
   m.def("VARCHAR", &velox::py::PyType::createVarchar);
   m.def("VARBINARY", &velox::py::PyType::createVarbinary);
 
+  m.def("JSON", &velox::py::PyType::createJson);
+
   m.def("DATE", &velox::py::PyType::createDate);
 
   m.def("ARRAY", &velox::py::PyType::createArrayType, py::arg("elements_type"));
diff --git a/velox/python/type/type.pyi b/velox/python/type/type.pyi
index 6d7f95fccd3..c918928f3b1 100644
--- a/velox/python/type/type.pyi
+++ b/velox/python/type/type.pyi
@@ -28,6 +28,7 @@ def DATE() -> Type: ...
 def DOUBLE() -> Type: ...
 def VARCHAR() -> Type: ...
 def VARBINARY() -> Type: ...
+def JSON() -> Type: ...
 def ARRAY(elements_type: Type) -> Type: ...
 def MAP(key_type: Type, value_type: Type) -> Type: ...
 def ROW(names: List[str] = [], types: List[Type] = []) -> Type: ...
diff --git a/velox/python/vector/PyVector.cpp b/velox/python/vector/PyVector.cpp
index 0df59ad16f0..529355c9028 100644
--- a/velox/python/vector/PyVector.cpp
+++ b/velox/python/vector/PyVector.cpp
@@ -45,8 +45,9 @@ PyVector PyVector::childAt(vector_size_t idx) const {
   if (auto rowVector = std::dynamic_pointer_cast<RowVector>(vector_)) {
     return PyVector{rowVector->childAt(idx), pool_};
   }
-  throw std::runtime_error(fmt::format(
-      "Can only call child_at() on RowVector, but got '{}'", toString()));
+  throw std::runtime_error(
+      fmt::format(
+          "Can only call child_at() on RowVector, but got '{}'", toString()));
 }
 
 } // namespace facebook::velox::py
diff --git a/velox/python/vector/PyVector.h b/velox/python/vector/PyVector.h
index 9d20b6d7889..d2e96c401fe 100644
--- a/velox/python/vector/PyVector.h
+++ b/velox/python/vector/PyVector.h
@@ -16,7 +16,6 @@
 
 #pragma once
 
-#include <pybind11/embed.h>
 #include "velox/python/type/PyType.h"
 #include "velox/vector/BaseVector.h"
 
diff --git a/velox/row/CMakeLists.txt b/velox/row/CMakeLists.txt
index 91e0266dcf7..10b3b35d7f8 100644
--- a/velox/row/CMakeLists.txt
+++ b/velox/row/CMakeLists.txt
@@ -12,7 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_row_fast CompactRow.cpp UnsafeRowFast.cpp)
+velox_add_library(
+  velox_row_fast
+  CompactRow.cpp
+  UnsafeRowFast.cpp
+  HEADERS
+  CompactRow.h
+  UnsafeRow.h
+  UnsafeRowFast.h
+)
 
 velox_link_libraries(velox_row_fast PUBLIC velox_vector)
 
diff --git a/velox/row/CompactRow.cpp b/velox/row/CompactRow.cpp
index 2dec9694271..362d590a003 100644
--- a/velox/row/CompactRow.cpp
+++ b/velox/row/CompactRow.cpp
@@ -455,7 +455,7 @@ int32_t CompactRow::variableWidthRowSize(vector_size_t index) const {
       return rowRowSize(index);
     default:
       VELOX_UNREACHABLE(
-          "Unexpected type kind: {}", mapTypeKindToName(typeKind_));
+          "Unexpected type kind: {}", TypeKindName::toName(typeKind_));
   };
 }
 
@@ -718,7 +718,7 @@ int32_t CompactRow::serializeVariableWidth(vector_size_t index, char* buffer)
       return serializeRow(index, buffer);
     default:
       VELOX_UNREACHABLE(
-          "Unexpected type kind: {}", mapTypeKindToName(typeKind_));
+          "Unexpected type kind: {}", TypeKindName::toName(typeKind_));
   };
 }
 
@@ -1051,7 +1051,7 @@ ArrayVectorPtr deserializeArrays(
 
   VectorPtr elements;
   const auto& elementType = type->childAt(0);
-  if (elementType->isUnKnown()) {
+  if (elementType->isUnknown()) {
     elements =
         deserializeUnknownArrays(elementType, data, arraySizes, offsets, pool);
   } else if (elementType->isFixedWidth()) {
@@ -1145,16 +1145,12 @@ VectorPtr deserialize(
     case TypeKind::VARCHAR:
     case TypeKind::VARBINARY:
       return deserializeStrings(type, data, nulls, offsets, pool);
-      break;
     case TypeKind::ARRAY:
       return deserializeArrays(type, data, nulls, offsets, pool);
-      break;
     case TypeKind::MAP:
       return deserializeMaps(type, data, nulls, offsets, pool);
-      break;
     case TypeKind::ROW:
       return deserializeRows(type, data, nulls, offsets, pool);
-      break;
     default:
       VELOX_UNREACHABLE("{}", type->toString());
   }
diff --git a/velox/row/CompactRow.h b/velox/row/CompactRow.h
index b3e30927b88..63b3a2c0e3e 100644
--- a/velox/row/CompactRow.h
+++ b/velox/row/CompactRow.h
@@ -153,9 +153,9 @@ class CompactRow {
   bool supportsBulkCopy_{false};
 
   // ROW type only. Number of bytes used by null flags.
-  size_t rowNullBytes_;
+  size_t rowNullBytes_{0};
 
   // Fixed-width types only. Number of bytes used for a single value.
-  size_t valueBytes_;
+  size_t valueBytes_{0};
 };
 } // namespace facebook::velox::row
diff --git a/velox/row/UnsafeRow.h b/velox/row/UnsafeRow.h
index 8188016c4e8..3083b41bcc9 100644
--- a/velox/row/UnsafeRow.h
+++ b/velox/row/UnsafeRow.h
@@ -421,7 +421,7 @@ FOLLY_ALWAYS_INLINE size_t serializedSizeInBytes<TypeKind::VARBINARY>() {
 /// Returns the number of bytes needed to serialized fixed-width type. Throws if
 /// 'type' is not fixed-width.
 FOLLY_ALWAYS_INLINE size_t serializedSizeInBytes(const TypePtr& type) {
-  if (type->isUnKnown()) {
+  if (type->isUnknown()) {
     return 0;
   }
   return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
diff --git a/velox/row/UnsafeRowFast.cpp b/velox/row/UnsafeRowFast.cpp
index 9e27a229d20..9f7222dc88e 100644
--- a/velox/row/UnsafeRowFast.cpp
+++ b/velox/row/UnsafeRowFast.cpp
@@ -161,7 +161,7 @@ int32_t UnsafeRowFast::variableWidthRowSize(vector_size_t index) const {
       return rowRowSize(index);
     default:
       VELOX_UNREACHABLE(
-          "Unexpected type kind: {}", mapTypeKindToName(typeKind_));
+          "Unexpected type kind: {}", TypeKindName::toName(typeKind_));
   };
 }
 
@@ -228,7 +228,7 @@ int32_t UnsafeRowFast::serializeVariableWidth(vector_size_t index, char* buffer)
       return serializeRow(index, buffer);
     default:
       VELOX_UNREACHABLE(
-          "Unexpected type kind: {}", mapTypeKindToName(typeKind_));
+          "Unexpected type kind: {}", TypeKindName::toName(typeKind_));
   };
 }
 
@@ -912,7 +912,7 @@ ArrayVectorPtr deserializeArrays(
 
   VectorPtr elements;
   const auto& elementType = type->childAt(0);
-  if (elementType->isUnKnown()) {
+  if (elementType->isUnknown()) {
     elements = deserializeUnknownArrays(elementType, data, arraySizes, pool);
   } else if (isFixedWidth(elementType)) {
     elements = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
@@ -1023,16 +1023,12 @@ VectorPtr deserialize(
     case TypeKind::VARCHAR:
     case TypeKind::VARBINARY:
       return deserializeStrings(type, data, nulls, offsets, pool);
-      break;
     case TypeKind::ARRAY:
       return deserializeArrays(type, data, nulls, pool);
-      break;
     case TypeKind::MAP:
       return deserializeMaps(type, data, nulls, pool);
-      break;
     case TypeKind::ROW:
       return deserializeRows(type, data, nulls, offsets, pool);
-      break;
     default:
       VELOX_UNREACHABLE("{}", type->toString());
   }
diff --git a/velox/row/tests/UnsafeRowTest.cpp b/velox/row/tests/UnsafeRowTest.cpp
index b0eea1ae61d..9a30611d242 100644
--- a/velox/row/tests/UnsafeRowTest.cpp
+++ b/velox/row/tests/UnsafeRowTest.cpp
@@ -216,5 +216,11 @@ TEST_F(UnsafeRowTest, nestedMaps) {
   testRoundTrip(data);
 }
 
+TEST_F(UnsafeRowTest, constantVector) {
+  auto data =
+      makeRowVector({BaseVector::createNullConstant(ROW({}), 1, pool_.get())});
+  testRoundTrip(data);
+}
+
 } // namespace
 } // namespace facebook::velox::row
diff --git a/velox/serializers/CMakeLists.txt b/velox/serializers/CMakeLists.txt
index 1237095fec3..dc14ee5c637 100644
--- a/velox/serializers/CMakeLists.txt
+++ b/velox/serializers/CMakeLists.txt
@@ -11,6 +11,24 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+velox_add_library(
+  velox_key_encoder
+  KeyDecoder.cpp
+  KeyEncoder.cpp
+  HEADERS
+  KeyDecoder.h
+  KeyEncoder.h
+)
+
+velox_link_libraries(
+  velox_key_encoder
+  velox_common_base
+  velox_core
+  velox_memory
+  velox_type
+  velox_vector
+)
+
 velox_add_library(
   velox_presto_serializer
   CompactRowSerializer.cpp
@@ -24,7 +42,22 @@ velox_add_library(
   PrestoSerializerSerializationUtils.cpp
   PrestoVectorLexer.cpp
   RowSerializer.cpp
+  SerializedPageFile.cpp
   VectorStream.cpp
+  HEADERS
+  CompactRowSerializer.h
+  PrestoBatchVectorSerializer.h
+  PrestoHeader.h
+  PrestoIterativeVectorSerializer.h
+  PrestoSerializer.h
+  PrestoSerializerDeserializationUtils.h
+  PrestoSerializerEstimationUtils.h
+  PrestoSerializerSerializationUtils.h
+  PrestoVectorLexer.h
+  RowSerializer.h
+  SerializedPageFile.h
+  UnsafeRowSerializer.h
+  VectorStream.h
 )
 
 velox_link_libraries(velox_presto_serializer velox_vector velox_row_fast)
diff --git a/velox/serializers/CompactRowSerializer.cpp b/velox/serializers/CompactRowSerializer.cpp
index 140582381b4..f2c91108877 100644
--- a/velox/serializers/CompactRowSerializer.cpp
+++ b/velox/serializers/CompactRowSerializer.cpp
@@ -85,19 +85,34 @@ CompactRowVectorSerde::createIterativeSerializer(
 namespace {
 std::unique_ptr<RowIterator> compactRowIteratorFactory(
     ByteInputStream* source,
-    std::unique_ptr<BufferInputStream> uncompressedStream,
-    std::unique_ptr<folly::IOBuf> uncompressedBuf,
-    size_t endOffset) {
-  if (source != nullptr) {
-    VELOX_CHECK_NULL(uncompressedStream);
-    VELOX_CHECK_NULL(uncompressedBuf);
-    return std::make_unique<RowIteratorImpl>(source, endOffset);
-  } else {
-    VELOX_CHECK_NOT_NULL(uncompressedStream);
-    VELOX_CHECK_NOT_NULL(uncompressedBuf);
+    const VectorSerde::Options* options) {
+  const auto header = detail::RowGroupHeader::read(source);
+  if (!header.compressed) {
     return std::make_unique<RowIteratorImpl>(
-        std::move(uncompressedStream), std::move(uncompressedBuf), endOffset);
+        source, header.uncompressedSize + source->tellp());
   }
+
+  const auto compressionKind = options == nullptr
+      ? VectorSerde::Options().compressionKind
+      : options->compressionKind;
+  VELOX_DCHECK_NE(
+      compressionKind, common::CompressionKind::CompressionKind_NONE);
+  auto compressBuf = folly::IOBuf::create(header.compressedSize);
+  source->readBytes(compressBuf->writableData(), header.compressedSize);
+  compressBuf->append(header.compressedSize);
+
+  // Process chained uncompressed results IOBufs.
+  const auto codec = common::compressionKindToCodec(compressionKind);
+  auto uncompressedBuf =
+      codec->uncompress(compressBuf.get(), header.uncompressedSize);
+
+  auto uncompressedStream = std::make_unique<BufferInputStream>(
+      byteRangesFromIOBuf(uncompressedBuf.get()));
+  const std::streampos initialSize = uncompressedStream->tellp();
+  return std::make_unique<RowIteratorImpl>(
+      std::move(uncompressedStream),
+      std::move(uncompressedBuf),
+      header.uncompressedSize + initialSize);
 }
 } // namespace
 
@@ -159,8 +174,15 @@ void CompactRowVectorSerde::registerVectorSerde() {
 // static
 void CompactRowVectorSerde::registerNamedVectorSerde() {
   velox::registerNamedVectorSerde(
-      VectorSerde::Kind::kCompactRow,
-      std::make_unique<CompactRowVectorSerde>());
+      kSerdeKind, std::make_unique<CompactRowVectorSerde>());
+}
+
+// static
+void CompactRowVectorSerde::tryRegisterNamedVectorSerde() {
+  if (!velox::isRegisteredNamedVectorSerde(kSerdeKind)) {
+    velox::registerNamedVectorSerde(
+        kSerdeKind, std::make_unique<CompactRowVectorSerde>());
+  }
 }
 
 } // namespace facebook::velox::serializer
diff --git a/velox/serializers/CompactRowSerializer.h b/velox/serializers/CompactRowSerializer.h
index aa38b948adb..815a929b120 100644
--- a/velox/serializers/CompactRowSerializer.h
+++ b/velox/serializers/CompactRowSerializer.h
@@ -22,7 +22,7 @@ namespace facebook::velox::serializer {
 
 class CompactRowVectorSerde : public VectorSerde {
  public:
-  CompactRowVectorSerde() : VectorSerde(VectorSerde::Kind::kCompactRow) {}
+  CompactRowVectorSerde() : VectorSerde(kSerdeKind) {}
 
   void estimateSerializedSize(
       const row::CompactRow* compactRow,
@@ -53,8 +53,25 @@ class CompactRowVectorSerde : public VectorSerde {
       velox::memory::MemoryPool* pool,
       const Options* options = nullptr) override;
 
+  /// Registers this serde as the global default vector serde. Throws if a
+  /// default serde is already registered.
   static void registerVectorSerde();
+
+  /// Registers this serde in the named serde registry under kSerdeKind.
+  /// Throws if a serde with the same name is already registered.
   static void registerNamedVectorSerde();
+
+  /// Registers this serde in the named serde registry under kSerdeKind only
+  /// if not already registered. No-op if a serde with the same name exists.
+  static void tryRegisterNamedVectorSerde();
+
+  /// Returns the name of this serde kind.
+  static const std::string& name() {
+    return kSerdeKind;
+  }
+
+ private:
+  inline static const std::string kSerdeKind{"CompactRow"};
 };
 
 } // namespace facebook::velox::serializer
diff --git a/velox/serializers/KeyDecoder.cpp b/velox/serializers/KeyDecoder.cpp
new file mode 100644
index 00000000000..87dcfeac833
--- /dev/null
+++ b/velox/serializers/KeyDecoder.cpp
@@ -0,0 +1,379 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/serializers/KeyDecoder.h"
+
+#include <cstring>
+#include <limits>
+#include <type_traits>
+
+#include <folly/lang/Bits.h>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/type/Timestamp.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::serializer {
+namespace {
+
+// Validates if a type is a valid index column type.
+// Only primitive scalar types are supported except UNKNOWN and HUGEINT.
+bool isValidIndexColumnType(const TypePtr& type) {
+  return type->isPrimitiveType() && type->kind() != TypeKind::UNKNOWN &&
+      type->kind() != TypeKind::HUGEINT;
+}
+
+std::vector<vector_size_t> getKeyChannels(
+    const RowTypePtr& inputType,
+    const std::vector<std::string>& keyColumns) {
+  std::vector<vector_size_t> keyChannels;
+  keyChannels.reserve(keyColumns.size());
+  for (const auto& keyColumn : keyColumns) {
+    keyChannels.emplace_back(inputType->getChildIdx(keyColumn));
+  }
+  return keyChannels;
+}
+
+RowTypePtr makeOutputType(
+    const RowTypePtr& inputType,
+    const std::vector<std::string>& keyColumns) {
+  const auto keyChannels = getKeyChannels(inputType, keyColumns);
+  std::vector<TypePtr> childTypes;
+  childTypes.reserve(keyChannels.size());
+  for (const auto channel : keyChannels) {
+    childTypes.push_back(inputType->childAt(channel));
+  }
+  return ROW(keyColumns, std::move(childTypes));
+}
+
+vector_size_t checkedVectorSize(size_t size) {
+  VELOX_CHECK_LE(
+      size,
+      static_cast<size_t>(std::numeric_limits<vector_size_t>::max()),
+      "Row count exceeds vector_size_t maximum: {}",
+      size);
+  return static_cast<vector_size_t>(size);
+}
+
+column_index_t checkedColumnIndex(size_t index) {
+  VELOX_CHECK_LE(
+      index,
+      static_cast<size_t>(std::numeric_limits<column_index_t>::max()),
+      "Column index exceeds column_index_t maximum: {}",
+      index);
+  return static_cast<column_index_t>(index);
+}
+
+StringView makeStringView(std::string_view value) {
+  VELOX_CHECK_LE(
+      value.size(),
+      static_cast<size_t>(std::numeric_limits<int32_t>::max()),
+      "Decoded string exceeds StringView maximum length: {}",
+      value.size());
+  return StringView(value.data(), static_cast<int32_t>(value.size()));
+}
+
+struct Cursor {
+  const std::string_view encodedKey;
+  size_t offset_{0};
+
+  explicit Cursor(std::string_view encodedKey) : encodedKey{encodedKey} {}
+
+  uint8_t readRawByte() {
+    VELOX_CHECK_LT(
+        offset_,
+        encodedKey.size(),
+        "Malformed encoded key: unexpected end of key at offset {}",
+        offset());
+    return static_cast<uint8_t>(encodedKey.at(offset_++));
+  }
+
+  template <typename T>
+  T readRawBytes() {
+    VELOX_CHECK_GE(
+        remaining(),
+        sizeof(T),
+        "Malformed encoded key: need {} byte(s) at offset {}, only {} byte(s) remain",
+        sizeof(T),
+        offset(),
+        remaining());
+
+    T value;
+    auto* bytes = reinterpret_cast<uint8_t*>(&value);
+    for (size_t i = 0; i < sizeof(T); ++i) {
+      bytes[i] = readRawByte();
+    }
+    return value;
+  }
+
+  size_t offset() const {
+    return offset_;
+  }
+
+  size_t remaining() const {
+    return encodedKey.size() - offset_;
+  }
+};
+
+// Reverses KeyEncoder's bytewise inversion for descending sort order.
+FOLLY_ALWAYS_INLINE uint8_t decodeByte(uint8_t value, bool descending) {
+  return descending ? static_cast<uint8_t>(0xff ^ value) : value;
+}
+
+bool decodeNullMarker(Cursor& cursor, bool nullLast) {
+  const auto marker = cursor.readRawByte();
+  const auto nullByte = static_cast<uint8_t>(nullLast);
+  const auto nonNullByte = static_cast<uint8_t>(!nullLast);
+  VELOX_CHECK(
+      marker == nullByte || marker == nonNullByte,
+      "Malformed encoded key: invalid null marker {} at offset {}",
+      static_cast<uint32_t>(marker),
+      cursor.offset() - 1);
+  return marker == nullByte;
+}
+
+template <typename T>
+T decodeFixedWidth(Cursor& cursor, bool descending) {
+  using UnsignedT = std::make_unsigned_t<T>;
+
+  UnsignedT value = cursor.readRawBytes<UnsignedT>();
+  if (descending) {
+    value = ~value;
+  }
+  value = folly::Endian::big(value);
+
+  if constexpr (std::is_signed_v<T>) {
+    constexpr int kSignBitShift = sizeof(T) * 8 - 1;
+    value ^= (UnsignedT{1} << kSignBitShift);
+  }
+
+  return static_cast<T>(value);
+}
+
+bool decodeBoolean(Cursor& cursor, bool descending) {
+  const auto decoded = decodeByte(cursor.readRawByte(), descending);
+  VELOX_CHECK(
+      decoded == 1 || decoded == 2,
+      "Malformed encoded key: invalid boolean byte {} at offset {}",
+      static_cast<uint32_t>(decoded),
+      cursor.offset() - 1);
+  return decoded == 2;
+}
+
+std::string decodeString(Cursor& cursor, bool descending) {
+  std::string result;
+
+  while (true) {
+    const auto decoded = decodeByte(cursor.readRawByte(), descending);
+    if (decoded == 0) {
+      return result;
+    }
+
+    if (decoded == 1) {
+      const auto decodedEscaped = decodeByte(cursor.readRawByte(), descending);
+      VELOX_CHECK(
+          decodedEscaped == 0 || decodedEscaped == 1,
+          "Malformed encoded key: invalid escaped string byte {} at offset {}",
+          static_cast<uint32_t>(decodedEscaped),
+          cursor.offset() - 1);
+      result.push_back(static_cast<char>(decodedEscaped));
+      continue;
+    }
+
+    result.push_back(static_cast<char>(decoded));
+  }
+}
+
+double decodeDouble(Cursor& cursor, bool descending) {
+  constexpr uint64_t kSignBit = 1ULL << 63;
+
+  const uint64_t orderedValue = decodeFixedWidth<uint64_t>(cursor, descending);
+  const uint64_t bits = (orderedValue & kSignBit) != 0
+      ? (orderedValue ^ kSignBit)
+      : ~orderedValue;
+
+  double result;
+  std::memcpy(&result, &bits, sizeof(result));
+  return result;
+}
+
+float decodeReal(Cursor& cursor, bool descending) {
+  constexpr uint32_t kSignBit = 1U << 31;
+
+  const uint32_t orderedValue = decodeFixedWidth<uint32_t>(cursor, descending);
+  const uint32_t bits = (orderedValue & kSignBit) != 0
+      ? (orderedValue ^ kSignBit)
+      : ~orderedValue;
+
+  float result;
+  std::memcpy(&result, &bits, sizeof(result));
+  return result;
+}
+
+void decodeValue(
+    Cursor& cursor,
+    const TypePtr& type,
+    const core::SortOrder& sortOrder,
+    vector_size_t row,
+    VectorPtr& output) {
+  const bool nullLast = !sortOrder.isNullsFirst();
+  const bool descending = !sortOrder.isAscending();
+
+  if (decodeNullMarker(cursor, nullLast)) {
+    output->setNull(row, true);
+    return;
+  }
+
+  if (type->isDate()) {
+    output->asFlatVector<int32_t>()->set(
+        row, decodeFixedWidth<int32_t>(cursor, descending));
+    return;
+  }
+
+  switch (type->kind()) {
+    case TypeKind::BIGINT:
+      output->asFlatVector<int64_t>()->set(
+          row, decodeFixedWidth<int64_t>(cursor, descending));
+      return;
+    case TypeKind::INTEGER:
+      output->asFlatVector<int32_t>()->set(
+          row, decodeFixedWidth<int32_t>(cursor, descending));
+      return;
+    case TypeKind::SMALLINT:
+      output->asFlatVector<int16_t>()->set(
+          row, decodeFixedWidth<int16_t>(cursor, descending));
+      return;
+    case TypeKind::TINYINT:
+      output->asFlatVector<int8_t>()->set(
+          row, decodeFixedWidth<int8_t>(cursor, descending));
+      return;
+    case TypeKind::DOUBLE:
+      output->asFlatVector<double>()->set(
+          row, decodeDouble(cursor, descending));
+      return;
+    case TypeKind::REAL:
+      output->asFlatVector<float>()->set(row, decodeReal(cursor, descending));
+      return;
+    case TypeKind::BOOLEAN:
+      output->asFlatVector<bool>()->set(row, decodeBoolean(cursor, descending));
+      return;
+    case TypeKind::VARCHAR:
+    case TypeKind::VARBINARY: {
+      const auto value = decodeString(cursor, descending);
+      output->asFlatVector<StringView>()->set(row, makeStringView(value));
+      return;
+    }
+    case TypeKind::TIMESTAMP: {
+      const auto seconds = decodeFixedWidth<int64_t>(cursor, descending);
+      const auto nanos = decodeFixedWidth<uint64_t>(cursor, descending);
+      output->asFlatVector<Timestamp>()->set(row, Timestamp(seconds, nanos));
+      return;
+    }
+    case TypeKind::HUGEINT:
+    case TypeKind::ARRAY:
+    case TypeKind::MAP:
+    case TypeKind::ROW:
+    case TypeKind::UNKNOWN:
+    case TypeKind::FUNCTION:
+    case TypeKind::OPAQUE:
+    case TypeKind::INVALID:
+      VELOX_UNSUPPORTED("Unsupported type: {}", type->kind());
+  }
+}
+
+} // namespace
+
+// static.
+std::unique_ptr<KeyDecoder> KeyDecoder::create(
+    const std::vector<std::string>& keyColumns,
+    RowTypePtr inputType,
+    std::vector<core::SortOrder> sortOrders,
+    memory::MemoryPool* pool) {
+  return std::unique_ptr<KeyDecoder>(new KeyDecoder(
+      keyColumns, std::move(inputType), std::move(sortOrders), pool));
+}
+
+KeyDecoder::KeyDecoder(
+    const std::vector<std::string>& keyColumns,
+    RowTypePtr inputType,
+    std::vector<core::SortOrder> sortOrders,
+    memory::MemoryPool* pool)
+    : outputType_{makeOutputType(inputType, keyColumns)},
+      sortOrders_{std::move(sortOrders)},
+      pool_{pool} {
+  VELOX_CHECK_GT(outputType_->size(), 0);
+  VELOX_CHECK_EQ(
+      outputType_->size(),
+      sortOrders_.size(),
+      "Size mismatch between key columns and sort orders");
+
+  for (size_t i = 0; i < outputType_->size(); ++i) {
+    const auto column = checkedColumnIndex(i);
+    const auto& columnType = outputType_->childAt(column);
+    VELOX_CHECK(
+        isValidIndexColumnType(columnType),
+        "Unsupported type for index column '{}': {}",
+        outputType_->nameOf(column),
+        columnType->toString());
+  }
+}
+
+RowVectorPtr KeyDecoder::decode(
+    std::span<const std::string_view> encodedKeys) const {
+  const auto numRows = checkedVectorSize(encodedKeys.size());
+  std::vector<VectorPtr> children;
+  children.reserve(outputType_->size());
+  for (size_t i = 0; i < outputType_->size(); ++i) {
+    const auto column = checkedColumnIndex(i);
+    children.push_back(
+        BaseVector::create(outputType_->childAt(column), numRows, pool_));
+  }
+
+  for (vector_size_t row = 0; row < numRows; ++row) {
+    Cursor cursor(encodedKeys[static_cast<size_t>(row)]);
+    for (size_t column = 0; column < outputType_->size(); ++column) {
+      const auto columnIndex = checkedColumnIndex(column);
+      decodeValue(
+          cursor,
+          outputType_->childAt(columnIndex),
+          sortOrders_[column],
+          row,
+          children.at(column));
+    }
+
+    VELOX_CHECK_EQ(
+        cursor.remaining(),
+        0,
+        "Malformed encoded key: {} trailing byte(s) remain after decoding row {}",
+        cursor.remaining(),
+        row);
+  }
+
+  return std::make_shared<RowVector>(
+      pool_, outputType_, nullptr, numRows, std::move(children));
+}
+
+RowVectorPtr KeyDecoder::decode(
+    std::span<const std::string> encodedKeys) const {
+  std::vector<std::string_view> views;
+  views.reserve(encodedKeys.size());
+  for (const auto& key : encodedKeys) {
+    views.emplace_back(key);
+  }
+  return decode(std::span<const std::string_view>(views));
+}
+
+} // namespace facebook::velox::serializer
diff --git a/velox/serializers/KeyDecoder.h b/velox/serializers/KeyDecoder.h
new file mode 100644
index 00000000000..aaa4da7eed9
--- /dev/null
+++ b/velox/serializers/KeyDecoder.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <memory>
+#include <span>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include "velox/common/memory/Memory.h"
+#include "velox/core/PlanNode.h"
+#include "velox/type/Type.h"
+#include "velox/vector/ComplexVector.h"
+
+namespace facebook::velox::serializer {
+
+/// KeyDecoder decodes byte-comparable keys produced by KeyEncoder back into
+/// Velox vectors. The decoded RowVector contains only the key columns, in the
+/// same order passed to create().
+///
+/// Floating point values round-trip through KeyEncoder's canonicalized
+/// representation. In particular, all NaNs decode as canonical quiet NaNs and
+/// -0.0 decodes as +0.0.
+class KeyDecoder {
+ public:
+  /// Factory method to create a KeyDecoder instance.
+  ///
+  /// @param keyColumns Names of columns included in the encoded key, in order
+  /// @param inputType Row type used to look up column types by name
+  /// @param sortOrders Sort order for each key column (ascending/descending,
+  ///                   nulls first/last)
+  /// @param pool Memory pool for allocations
+  /// @return Unique pointer to a new KeyDecoder instance
+  static std::unique_ptr<KeyDecoder> create(
+      const std::vector<std::string>& keyColumns,
+      RowTypePtr inputType,
+      std::vector<core::SortOrder> sortOrders,
+      memory::MemoryPool* pool);
+
+  /// Decodes byte-comparable keys back into a RowVector of key columns.
+  RowVectorPtr decode(std::span<const std::string_view> encodedKeys) const;
+
+  /// Convenience overload for string-backed encoded keys.
+  RowVectorPtr decode(std::span<const std::string> encodedKeys) const;
+
+  /// Returns the decoded output type. This contains only the key columns in
+  /// the order passed to create().
+  const RowTypePtr& outputType() const {
+    return outputType_;
+  }
+
+  /// Returns the sort orders for each key column.
+  const std::vector<core::SortOrder>& sortOrders() const {
+    return sortOrders_;
+  }
+
+ private:
+  KeyDecoder(
+      const std::vector<std::string>& keyColumns,
+      RowTypePtr inputType,
+      std::vector<core::SortOrder> sortOrders,
+      memory::MemoryPool* pool);
+
+  const RowTypePtr outputType_;
+  const std::vector<core::SortOrder> sortOrders_;
+  memory::MemoryPool* const pool_;
+};
+
+} // namespace facebook::velox::serializer
diff --git a/velox/serializers/KeyEncoder.cpp b/velox/serializers/KeyEncoder.cpp
new file mode 100644
index 00000000000..5f70a79ddfc
--- /dev/null
+++ b/velox/serializers/KeyEncoder.cpp
@@ -0,0 +1,1390 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/serializers/KeyEncoder.h"
+
+#include "velox/common/base/SimdUtil.h"
+#include "velox/type/Timestamp.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::serializer {
+namespace {
+
+bool validateBound(
+    const IndexBound& indexBound,
+    const std::vector<std::string>& indexColumns) {
+  if (indexBound.bound == nullptr || indexBound.bound->size() == 0) {
+    return false;
+  }
+
+  const auto& rowType = asRowType(indexBound.bound->type());
+  if (rowType->size() != indexColumns.size()) {
+    return false;
+  }
+  for (const auto& columnName : indexColumns) {
+    if (!rowType->containsChild(columnName)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+} // namespace
+
+bool IndexBounds::validate() const {
+  if (!lowerBound.has_value() && !upperBound.has_value()) {
+    return false;
+  }
+
+  if (lowerBound.has_value() &&
+      !validateBound(lowerBound.value(), indexColumns)) {
+    return false;
+  }
+
+  if (upperBound.has_value() &&
+      !validateBound(upperBound.value(), indexColumns)) {
+    return false;
+  }
+
+  if (lowerBound.has_value() && upperBound.has_value()) {
+    if (!lowerBound->bound->type()->equivalent(*upperBound->bound->type())) {
+      return false;
+    }
+    if (lowerBound->bound->size() != upperBound->bound->size()) {
+      return false;
+    }
+    if (lowerBound->bound->size() == 0) {
+      return false;
+    }
+  }
+  return true;
+}
+
+TypePtr IndexBounds::type() const {
+  const RowVectorPtr& boundVector =
+      lowerBound.has_value() ? lowerBound->bound : upperBound->bound;
+  return boundVector->type();
+}
+
+std::string IndexBounds::toString() const {
+  std::stringstream ss;
+  ss << "IndexBounds{indexColumns=[";
+  for (size_t i = 0; i < indexColumns.size(); ++i) {
+    if (i > 0) {
+      ss << ", ";
+    }
+    ss << indexColumns[i];
+  }
+  ss << "]";
+
+  const auto formatBound =
+      [&ss](const char* name, const std::optional<IndexBound>& bound) {
+        if (!bound.has_value()) {
+          ss << ", " << name << "=unbounded";
+        } else {
+          ss << ", " << name << "=" << (bound->inclusive ? "[" : "(");
+          ss << bound->bound->toString(0, bound->bound->size());
+          ss << (bound->inclusive ? "]" : ")");
+        }
+      };
+
+  formatBound("lowerBound", lowerBound);
+  formatBound("upperBound", upperBound);
+
+  ss << "}";
+  return ss.str();
+}
+
+std::string EncodedKeyBounds::toString() const {
+  std::stringstream ss;
+  ss << "EncodedKeyBounds{lowerKey=";
+  if (lowerKey.has_value()) {
+    ss << folly::hexlify(lowerKey.value());
+  } else {
+    ss << "unbounded";
+  }
+  ss << ", upperKey=";
+  if (upperKey.has_value()) {
+    ss << folly::hexlify(upperKey.value());
+  } else {
+    ss << "unbounded";
+  }
+  ss << "}";
+  return ss.str();
+}
+
+vector_size_t IndexBounds::numRows() const {
+  if (lowerBound.has_value()) {
+    return lowerBound->bound->size();
+  }
+  VELOX_CHECK(upperBound.has_value());
+  return upperBound->bound->size();
+}
+
+void IndexBounds::set(IndexBound lower, IndexBound upper) {
+  lowerBound = std::move(lower);
+  upperBound = std::move(upper);
+  VELOX_CHECK(validate());
+}
+
+void IndexBounds::clear() {
+  lowerBound.reset();
+  upperBound.reset();
+}
+
+bool KeyEncoder::IncrementedBoundsResult::allSucceeded() const {
+  return bounds != nullptr && succeededIndices == nullptr;
+}
+
+namespace {
+// Validates if a type is a valid index column type.
+// Only primitive scalar types are supported except UNKNOWN and HUGEINT.
+bool isValidIndexColumnType(const TypePtr& type) {
+  return type->isPrimitiveType() && type->kind() != TypeKind::UNKNOWN &&
+      type->kind() != TypeKind::HUGEINT;
+}
+
+static constexpr int64_t DOUBLE_EXP_BIT_MASK = 0x7FF0000000000000L;
+static constexpr int64_t DOUBLE_SIGNIF_BIT_MASK = 0x000FFFFFFFFFFFFFL;
+
+static constexpr int32_t FLOAT_EXP_BIT_MASK = 0x7F800000;
+static constexpr int32_t FLOAT_SIGNIF_BIT_MASK = 0x007FFFFF;
+
+static constexpr size_t kNullByteSize = 1;
+
+// Converts a double to its int64_t bit representation, normalizing all NaN
+// values to a canonical quiet NaN (0x7ff8000000000000L). This ensures
+// consistent key encoding since different NaN bit patterns should compare
+// equal.
+FOLLY_ALWAYS_INLINE int64_t doubleToLong(double value) {
+  const int64_t* result = reinterpret_cast<const int64_t*>(&value);
+
+  if (((*result & DOUBLE_EXP_BIT_MASK) == DOUBLE_EXP_BIT_MASK) &&
+      (*result & DOUBLE_SIGNIF_BIT_MASK) != 0L) {
+    return 0x7ff8000000000000L;
+  }
+  return *result;
+}
+
+// Converts a float to its int32_t bit representation, normalizing all NaN
+// values to a canonical quiet NaN (0x7fc00000). This ensures consistent key
+// encoding since different NaN bit patterns should compare equal.
+FOLLY_ALWAYS_INLINE int32_t floatToInt(float value) {
+  const int32_t* result = reinterpret_cast<const int32_t*>(&value);
+
+  if (((*result & FLOAT_EXP_BIT_MASK) == FLOAT_EXP_BIT_MASK) &&
+      (*result & FLOAT_SIGNIF_BIT_MASK) != 0L) {
+    return 0x7fc00000;
+  }
+  return *result;
+}
+
+FOLLY_ALWAYS_INLINE void encodeByte(int8_t value, bool descending, char*& out) {
+  if (descending) {
+    *out = 0xff ^ value;
+  } else {
+    *out = value;
+  }
+  ++out;
+}
+
+// Template for encoding integers (signed and unsigned).
+// For signed types: flips the sign bit for lexicographic ordering.
+// Converts to big-endian and applies descending transformation if needed.
+template <typename T>
+FOLLY_ALWAYS_INLINE void encodeInt(T value, bool descending, char*& out) {
+  using UnsignedT = std::make_unsigned_t<T>;
+
+  // Flip sign bit for signed types for lexicographic ordering
+  if constexpr (std::is_signed_v<T>) {
+    constexpr int kSignBitShift = sizeof(T) * 8 - 1;
+    value ^= 1ULL << kSignBitShift;
+  }
+
+  // Convert to big-endian
+  value = folly::Endian::big(value);
+
+  // Apply descending transformation if needed (branchless)
+  // If descending is true, XOR with all 1s; if false, XOR with 0
+  const UnsignedT mask = -static_cast<UnsignedT>(descending);
+  value ^= mask;
+
+  std::memcpy(out, &value, sizeof(value));
+  out += sizeof(value);
+}
+
+FOLLY_ALWAYS_INLINE void
+encodeString(const char* data, size_t size, bool descending, char*& out) {
+  size_t offset = 0;
+  constexpr size_t kBatchSize = xsimd::batch<uint8_t>::size;
+
+  // Precompute XOR mask for descending transformation
+  const uint8_t xorMask = descending ? 0xFF : 0x00;
+
+  // Process in SIMD batches to find bytes needing escaping
+  if (size >= kBatchSize) {
+    const auto zero = xsimd::batch<uint8_t>::broadcast(0);
+    const auto one = xsimd::batch<uint8_t>::broadcast(1);
+    const auto xorBatch = xsimd::batch<uint8_t>::broadcast(xorMask);
+
+    while (offset + kBatchSize <= size) {
+      auto batch = xsimd::batch<uint8_t>::load_unaligned(
+          reinterpret_cast<const uint8_t*>(data + offset));
+
+      // Check which bytes need escaping (are 0 or 1)
+      const auto needsEscape = (batch == zero) | (batch == one);
+      const auto hasEscapes = !simd::none(needsEscape);
+
+      if (!hasEscapes) {
+        // Fast path: no bytes need escaping, bulk copy the entire batch
+        // Apply descending transformation branchlessly (no-op if xorBatch is
+        // all zeros)
+        batch = batch ^ xorBatch;
+        batch.store_unaligned(reinterpret_cast<uint8_t*>(out));
+        out += kBatchSize;
+        offset += kBatchSize;
+      } else {
+        // Some bytes need escaping, process byte-by-byte for this batch
+        for (size_t i = 0; i < kBatchSize; ++i) {
+          const uint8_t byte = data[offset + i];
+          if (byte == 0 || byte == 1) {
+            encodeByte(1, descending, out);
+            encodeByte(byte, descending, out);
+          } else {
+            encodeByte(byte, descending, out);
+          }
+        }
+        offset += kBatchSize;
+      }
+    }
+  }
+
+  // Process remaining bytes
+  for (; offset < size; ++offset) {
+    const uint8_t byte = data[offset];
+    if (byte == 0 || byte == 1) {
+      encodeByte(1, descending, out);
+      encodeByte(byte, descending, out);
+    } else {
+      encodeByte(byte, descending, out);
+    }
+  }
+
+  // Write terminator
+  encodeByte(0, descending, out);
+}
+
+FOLLY_ALWAYS_INLINE size_t stringEncodedSize(const char* data, size_t size) {
+  size_t countZeros{0};
+  size_t countOnes{0};
+  size_t offset{0};
+
+  // Process bytes in SIMD batches
+  constexpr size_t kBatchSize = xsimd::batch<uint8_t>::size;
+  if (size >= kBatchSize) {
+    const auto zero = xsimd::batch<uint8_t>::broadcast(0);
+    const auto one = xsimd::batch<uint8_t>::broadcast(1);
+
+    for (; offset + kBatchSize <= size; offset += kBatchSize) {
+      auto batch = xsimd::batch<uint8_t>::load_unaligned(
+          reinterpret_cast<const uint8_t*>(data + offset));
+
+      // Count bytes that equal 0
+      const auto isZero = (batch == zero);
+      const auto zeroMask = simd::toBitMask(isZero);
+      countZeros += __builtin_popcount(zeroMask);
+
+      // Count bytes that equal 1
+      const auto isOne = (batch == one);
+      const auto oneMask = simd::toBitMask(isOne);
+      countOnes += __builtin_popcount(oneMask);
+    }
+  }
+
+  // Process remaining bytes using standard algorithms
+  const auto* remaining = reinterpret_cast<const uint8_t*>(data + offset);
+  const auto remainingSize = size - offset;
+
+  countZeros += std::count(remaining, remaining + remainingSize, 0);
+  countOnes += std::count(remaining, remaining + remainingSize, 1);
+
+  // Each 0 or 1 byte needs 2 bytes (escape byte + actual byte)
+  // Other bytes need 1 byte
+  // Plus 1 terminator byte
+  return size + countZeros + countOnes + 1;
+}
+
+FOLLY_ALWAYS_INLINE void encodeBool(bool value, char*& out) {
+  encodeByte(value, /*descending=*/false, out);
+}
+
+// Forward declarations for functions used in estimateEncodedColumnSize
+void addDateEncodedSize(
+    const folly::Range<const vector_size_t*>& nonNullRows,
+    vector_size_t** nonNullSizePtrs);
+
+template <TypeKind KIND>
+void addColumnEncodedSizeTyped(
+    const DecodedVector& decodedSource,
+    const folly::Range<const vector_size_t*>& nonNullRows,
+    vector_size_t** nonNullSizePtrs);
+
+void estimateEncodedColumnSize(
+    const DecodedVector& decodedSource,
+    const folly::Range<const vector_size_t*>& rows,
+    std::vector<vector_size_t>& sizes,
+    Scratch& scratch) {
+  const auto numRows = rows.size();
+  folly::Range<const vector_size_t*> nonNullRows = rows;
+  vector_size_t** nonNullSizePtrs = nullptr;
+
+  ScratchPtr<uint64_t, 64> nullsHolder(scratch);
+  ScratchPtr<vector_size_t, 64> nonNullsHolder(scratch);
+  ScratchPtr<vector_size_t*, 64> nonNullSizePtrsHolder(scratch);
+
+  if (decodedSource.mayHaveNulls()) {
+    auto* nulls = nullsHolder.get(bits::nwords(numRows));
+    for (auto row = 0; row < numRows; ++row) {
+      bits::clearNull(nulls, row);
+      if (decodedSource.isNullAt(rows[row])) {
+        bits::setNull(nulls, row);
+        sizes[row] += kNullByteSize;
+      }
+    }
+
+    auto* nonNulls = nonNullsHolder.get(numRows);
+    const auto numNonNull = simd::indicesOfSetBits(nulls, 0, numRows, nonNulls);
+    if (numNonNull == 0) {
+      return;
+    }
+
+    auto* const nonNullSizes = sizes.data();
+    nonNullSizePtrs = nonNullSizePtrsHolder.get(numNonNull);
+    for (int32_t i = 0; i < numNonNull; ++i) {
+      nonNullSizePtrs[i] = &nonNullSizes[nonNulls[i]];
+    }
+
+    simd::transpose(
+        rows.data(),
+        folly::Range<const vector_size_t*>(nonNulls, numNonNull),
+        nonNulls);
+    nonNullRows = folly::Range<const vector_size_t*>(nonNulls, numNonNull);
+  } else {
+    // No nulls, all rows are non-null - create size pointers for all rows
+    nonNullSizePtrs = nonNullSizePtrsHolder.get(numRows);
+    for (int32_t i = 0; i < numRows; ++i) {
+      nonNullSizePtrs[i] = &sizes[i];
+    }
+  }
+
+  // Process data for non-null rows only (or all rows if no nulls)
+  if (decodedSource.base()->type()->isDate()) {
+    for (auto i = 0; i < nonNullRows.size(); ++i) {
+      *nonNullSizePtrs[i] += (kNullByteSize + sizeof(int32_t));
+    }
+  } else {
+    VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+        addColumnEncodedSizeTyped,
+        decodedSource.base()->typeKind(),
+        decodedSource,
+        nonNullRows,
+        nonNullSizePtrs);
+  }
+}
+
+template <TypeKind KIND>
+void addColumnEncodedSizeTyped(
+    const DecodedVector& decodedSource,
+    const folly::Range<const vector_size_t*>& nonNullRows,
+    vector_size_t** nonNullSizePtrs) {
+  // Handle variable-width types
+  if constexpr (KIND == TypeKind::VARCHAR || KIND == TypeKind::VARBINARY) {
+    for (auto i = 0; i < nonNullRows.size(); ++i) {
+      const auto view = decodedSource.valueAt<StringView>(nonNullRows[i]);
+      *nonNullSizePtrs[i] +=
+          kNullByteSize + stringEncodedSize(view.data(), view.size());
+    }
+  } else {
+    // Fixed-width scalar types
+    const auto elementSize = decodedSource.base()->type()->cppSizeInBytes();
+    for (auto i = 0; i < nonNullRows.size(); ++i) {
+      *nonNullSizePtrs[i] += (kNullByteSize + elementSize);
+    }
+  }
+}
+
+std::vector<vector_size_t> getKeyChannels(
+    const RowTypePtr& inputType,
+    const std::vector<std::string>& keyColumns) {
+  std::vector<vector_size_t> keyChannels;
+  keyChannels.reserve(keyColumns.size());
+  for (const auto& keyColumn : keyColumns) {
+    keyChannels.emplace_back(inputType->getChildIdx(keyColumn));
+  }
+  return keyChannels;
+}
+
+// Wrapper functions for backward compatibility and readability
+FOLLY_ALWAYS_INLINE void
+encodeLong(int64_t value, bool descending, char*& out) {
+  encodeInt(value, descending, out);
+}
+
+FOLLY_ALWAYS_INLINE void
+encodeUnsignedLong(uint64_t value, bool descending, char*& out) {
+  encodeInt(value, descending, out);
+}
+
+FOLLY_ALWAYS_INLINE void
+encodeShort(int16_t value, bool descending, char*& out) {
+  encodeInt(value, descending, out);
+}
+
+FOLLY_ALWAYS_INLINE void
+encodeInteger(int32_t value, bool descending, char*& out) {
+  encodeInt(value, descending, out);
+}
+
+FOLLY_ALWAYS_INLINE void
+encodeUnsignedInteger(uint32_t value, bool descending, char*& out) {
+  encodeInt(value, descending, out);
+}
+
+void encodeBigInt(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  const bool mayHaveNulls = decodedVector.mayHaveNulls();
+  if (mayHaveNulls) {
+    for (auto row = 0; row < numRows; ++row) {
+      if (decodedVector.isNullAt(row)) {
+        // Encode null indicator only
+        encodeBool(nullLast, rowOffsets[row]);
+      } else {
+        // Encode non-null indicator followed by data
+        encodeBool(!nullLast, rowOffsets[row]);
+        const auto value = decodedVector.valueAt<int64_t>(row);
+        encodeLong(value, descending, rowOffsets[row]);
+      }
+    }
+  } else {
+    for (auto row = 0; row < numRows; ++row) {
+      // Encode non-null indicator followed by data
+      encodeBool(!nullLast, rowOffsets[row]);
+      const auto value = decodedVector.valueAt<int64_t>(row);
+      encodeLong(value, descending, rowOffsets[row]);
+    }
+  }
+}
+
+void encodeBoolean(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  const bool mayHaveNulls = decodedVector.mayHaveNulls();
+  if (mayHaveNulls) {
+    for (auto row = 0; row < numRows; ++row) {
+      if (decodedVector.isNullAt(row)) {
+        // Encode null indicator only
+        encodeBool(nullLast, rowOffsets[row]);
+      } else {
+        // Encode non-null indicator followed by data
+        encodeBool(!nullLast, rowOffsets[row]);
+        const auto value = decodedVector.valueAt<bool>(row);
+        encodeByte(
+            static_cast<int8_t>(value ? 2 : 1), descending, rowOffsets[row]);
+      }
+    }
+  } else {
+    for (auto row = 0; row < numRows; ++row) {
+      // Encode non-null indicator followed by data
+      encodeBool(!nullLast, rowOffsets[row]);
+      const auto value = decodedVector.valueAt<bool>(row);
+      encodeByte(
+          static_cast<int8_t>(value ? 2 : 1), descending, rowOffsets[row]);
+    }
+  }
+}
+
+void encodeDouble(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  const bool mayHaveNulls = decodedVector.mayHaveNulls();
+  if (mayHaveNulls) {
+    for (auto row = 0; row < numRows; ++row) {
+      if (decodedVector.isNullAt(row)) {
+        // Encode null indicator only
+        encodeBool(nullLast, rowOffsets[row]);
+      } else {
+        // Encode non-null indicator followed by data
+        encodeBool(!nullLast, rowOffsets[row]);
+        const auto value = decodedVector.valueAt<double>(row);
+        int64_t longValue = doubleToLong(value);
+        // Normalize -0.0 to +0.0 by clearing sign bit when value is zero
+        if ((longValue & ~(1L << 63)) == 0) {
+          longValue = 0;
+        }
+        if ((longValue & (1L << 63)) != 0) {
+          longValue = ~longValue;
+        } else {
+          longValue = longValue ^ (1L << 63);
+        }
+        encodeUnsignedLong(longValue, descending, rowOffsets[row]);
+      }
+    }
+  } else {
+    for (auto row = 0; row < numRows; ++row) {
+      // Encode non-null indicator followed by data
+      encodeBool(!nullLast, rowOffsets[row]);
+      const auto value = decodedVector.valueAt<double>(row);
+      int64_t longValue = doubleToLong(value);
+      // Normalize -0.0 to +0.0 by clearing sign bit when value is zero
+      if ((longValue & ~(1L << 63)) == 0) {
+        longValue = 0;
+      }
+      if ((longValue & (1L << 63)) != 0) {
+        longValue = ~longValue;
+      } else {
+        longValue = longValue ^ (1L << 63);
+      }
+      encodeUnsignedLong(longValue, descending, rowOffsets[row]);
+    }
+  }
+}
+
+void encodeReal(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  const bool mayHaveNulls = decodedVector.mayHaveNulls();
+  if (mayHaveNulls) {
+    for (auto row = 0; row < numRows; ++row) {
+      if (decodedVector.isNullAt(row)) {
+        // Encode null indicator only
+        encodeBool(nullLast, rowOffsets[row]);
+      } else {
+        // Encode non-null indicator followed by data
+        encodeBool(!nullLast, rowOffsets[row]);
+        const auto value = decodedVector.valueAt<float>(row);
+        int32_t intValue = floatToInt(value);
+        // Normalize -0.0 to +0.0 by clearing sign bit when value is zero
+        if ((intValue & ~(1 << 31)) == 0) {
+          intValue = 0;
+        }
+        if ((intValue & (1L << 31)) != 0) {
+          intValue = ~intValue;
+        } else {
+          intValue = intValue ^ (1L << 31);
+        }
+        encodeUnsignedInteger(intValue, descending, rowOffsets[row]);
+      }
+    }
+  } else {
+    for (auto row = 0; row < numRows; ++row) {
+      // Encode non-null indicator followed by data
+      encodeBool(!nullLast, rowOffsets[row]);
+      const auto value = decodedVector.valueAt<float>(row);
+      int32_t intValue = floatToInt(value);
+      // Normalize -0.0 to +0.0 by clearing sign bit when value is zero
+      if ((intValue & ~(1 << 31)) == 0) {
+        intValue = 0;
+      }
+      if ((intValue & (1L << 31)) != 0) {
+        intValue = ~intValue;
+      } else {
+        intValue = intValue ^ (1L << 31);
+      }
+      encodeUnsignedInteger(intValue, descending, rowOffsets[row]);
+    }
+  }
+}
+
+void encodeTinyInt(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  const bool mayHaveNulls = decodedVector.mayHaveNulls();
+  if (mayHaveNulls) {
+    for (auto row = 0; row < numRows; ++row) {
+      if (decodedVector.isNullAt(row)) {
+        // Encode null indicator only
+        encodeBool(nullLast, rowOffsets[row]);
+      } else {
+        // Encode non-null indicator followed by data
+        encodeBool(!nullLast, rowOffsets[row]);
+        const auto value = decodedVector.valueAt<int8_t>(row);
+        encodeByte(
+            static_cast<int8_t>(value ^ 0x80), descending, rowOffsets[row]);
+      }
+    }
+  } else {
+    for (auto row = 0; row < numRows; ++row) {
+      // Encode non-null indicator followed by data
+      encodeBool(!nullLast, rowOffsets[row]);
+      const auto value = decodedVector.valueAt<int8_t>(row);
+      encodeByte(
+          static_cast<int8_t>(value ^ 0x80), descending, rowOffsets[row]);
+    }
+  }
+}
+
+void encodeSmallInt(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  const bool mayHaveNulls = decodedVector.mayHaveNulls();
+  if (mayHaveNulls) {
+    for (auto row = 0; row < numRows; ++row) {
+      if (decodedVector.isNullAt(row)) {
+        // Encode null indicator only
+        encodeBool(nullLast, rowOffsets[row]);
+      } else {
+        // Encode non-null indicator followed by data
+        encodeBool(!nullLast, rowOffsets[row]);
+        const auto value = decodedVector.valueAt<int16_t>(row);
+        encodeShort(value, descending, rowOffsets[row]);
+      }
+    }
+  } else {
+    for (auto row = 0; row < numRows; ++row) {
+      // Encode non-null indicator followed by data
+      encodeBool(!nullLast, rowOffsets[row]);
+      const auto value = decodedVector.valueAt<int16_t>(row);
+      encodeShort(value, descending, rowOffsets[row]);
+    }
+  }
+}
+
+void encodeIntegerType(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  const bool mayHaveNulls = decodedVector.mayHaveNulls();
+  if (mayHaveNulls) {
+    for (auto row = 0; row < numRows; ++row) {
+      if (decodedVector.isNullAt(row)) {
+        // Encode null indicator only
+        encodeBool(nullLast, rowOffsets[row]);
+      } else {
+        // Encode non-null indicator followed by data
+        encodeBool(!nullLast, rowOffsets[row]);
+        const auto value = decodedVector.valueAt<int32_t>(row);
+        encodeInteger(value, descending, rowOffsets[row]);
+      }
+    }
+  } else {
+    for (auto row = 0; row < numRows; ++row) {
+      // Encode non-null indicator followed by data
+      encodeBool(!nullLast, rowOffsets[row]);
+      const auto value = decodedVector.valueAt<int32_t>(row);
+      encodeInteger(value, descending, rowOffsets[row]);
+    }
+  }
+}
+
+void encodeStringType(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  const bool mayHaveNulls = decodedVector.mayHaveNulls();
+  if (mayHaveNulls) {
+    for (auto row = 0; row < numRows; ++row) {
+      if (decodedVector.isNullAt(row)) {
+        // Encode null indicator only
+        encodeBool(nullLast, rowOffsets[row]);
+      } else {
+        // Encode non-null indicator followed by data
+        encodeBool(!nullLast, rowOffsets[row]);
+        const auto value = decodedVector.valueAt<StringView>(row);
+        encodeString(value.data(), value.size(), descending, rowOffsets[row]);
+      }
+    }
+  } else {
+    for (auto row = 0; row < numRows; ++row) {
+      // Encode non-null indicator followed by data
+      encodeBool(!nullLast, rowOffsets[row]);
+      const auto value = decodedVector.valueAt<StringView>(row);
+      encodeString(value.data(), value.size(), descending, rowOffsets[row]);
+    }
+  }
+}
+
+// Encodes Timestamp type column for all rows in columnar fashion.
+// When comparing Timestamp, first compare seconds and then compare nanos, so
+// when encoding, just encode seconds and nanos in sequence (similar to
+// PrefixSortEncoder).
+void encodeTimestamp(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  const bool mayHaveNulls = decodedVector.mayHaveNulls();
+  if (mayHaveNulls) {
+    for (auto row = 0; row < numRows; ++row) {
+      if (decodedVector.isNullAt(row)) {
+        // Encode null indicator only
+        encodeBool(nullLast, rowOffsets[row]);
+      } else {
+        // Encode non-null indicator followed by data
+        encodeBool(!nullLast, rowOffsets[row]);
+        const auto value = decodedVector.valueAt<Timestamp>(row);
+        // Encode seconds (int64_t) followed by nanos (uint64_t)
+        encodeLong(value.getSeconds(), descending, rowOffsets[row]);
+        encodeUnsignedLong(value.getNanos(), descending, rowOffsets[row]);
+      }
+    }
+  } else {
+    for (auto row = 0; row < numRows; ++row) {
+      // Encode non-null indicator followed by data
+      encodeBool(!nullLast, rowOffsets[row]);
+      const auto value = decodedVector.valueAt<Timestamp>(row);
+      // Encode seconds (int64_t) followed by nanos (uint64_t)
+      encodeLong(value.getSeconds(), descending, rowOffsets[row]);
+      encodeUnsignedLong(value.getNanos(), descending, rowOffsets[row]);
+    }
+  }
+}
+
+// Encodes Date type column for all rows in columnar fashion.
+void encodeDate(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  const bool mayHaveNulls = decodedVector.mayHaveNulls();
+  if (mayHaveNulls) {
+    for (auto row = 0; row < numRows; ++row) {
+      if (decodedVector.isNullAt(row)) {
+        // Encode null indicator only
+        encodeBool(nullLast, rowOffsets[row]);
+      } else {
+        // Encode non-null indicator followed by data
+        encodeBool(!nullLast, rowOffsets[row]);
+        const auto value = decodedVector.valueAt<int32_t>(row);
+        encodeInteger(value, descending, rowOffsets[row]);
+      }
+    }
+  } else {
+    for (auto row = 0; row < numRows; ++row) {
+      // Encode non-null indicator followed by data
+      encodeBool(!nullLast, rowOffsets[row]);
+      const auto value = decodedVector.valueAt<int32_t>(row);
+      encodeInteger(value, descending, rowOffsets[row]);
+    }
+  }
+}
+
+// Template function to encode column data for a specific type kind
+template <TypeKind Kind>
+void encodeColumnTyped(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  if constexpr (Kind == TypeKind::BIGINT) {
+    encodeBigInt(decodedVector, numRows, descending, nullLast, rowOffsets);
+  } else if constexpr (Kind == TypeKind::BOOLEAN) {
+    encodeBoolean(decodedVector, numRows, descending, nullLast, rowOffsets);
+  } else if constexpr (Kind == TypeKind::DOUBLE) {
+    encodeDouble(decodedVector, numRows, descending, nullLast, rowOffsets);
+  } else if constexpr (Kind == TypeKind::REAL) {
+    encodeReal(decodedVector, numRows, descending, nullLast, rowOffsets);
+  } else if constexpr (Kind == TypeKind::TINYINT) {
+    encodeTinyInt(decodedVector, numRows, descending, nullLast, rowOffsets);
+  } else if constexpr (Kind == TypeKind::SMALLINT) {
+    encodeSmallInt(decodedVector, numRows, descending, nullLast, rowOffsets);
+  } else if constexpr (Kind == TypeKind::INTEGER) {
+    encodeIntegerType(decodedVector, numRows, descending, nullLast, rowOffsets);
+  } else if constexpr (Kind == TypeKind::TIMESTAMP) {
+    encodeTimestamp(decodedVector, numRows, descending, nullLast, rowOffsets);
+  } else if constexpr (
+      Kind == TypeKind::VARCHAR || Kind == TypeKind::VARBINARY) {
+    encodeStringType(decodedVector, numRows, descending, nullLast, rowOffsets);
+  } else {
+    VELOX_UNSUPPORTED("Unsupported type: {}", Kind);
+  }
+}
+
+bool incrementStringValue(std::string* value, bool descending) {
+  if (!descending) {
+    // Ascending order: append the smallest possible byte (null byte) to get the
+    // immediate next string. For any string s, s < s + '\0' < s + '\x01' < ...
+    value->push_back('\0');
+    return true;
+  }
+  // Descending order: decrement is only possible if the string ends with
+  // '\0'. This is the inverse of the increment operation - truncate the
+  // trailing null byte. This approach aligns with Apache Kudu's
+  // DecrementStringCell.
+  //
+  // For strings not ending with '\0', there is no finite immediate
+  // predecessor (e.g., predecessor of "abc" would be "ab\xFF\xFF\xFF..." with
+  // infinite 0xFF bytes). Return false to signal caller should use exclusive
+  // bounds.
+  if (value->empty() || value->back() != '\0') {
+    return false;
+  }
+  value->pop_back();
+  return true;
+}
+
+template <TypeKind KIND>
+bool setMinValueTyped(VectorPtr& result, vector_size_t row) {
+  using T = typename TypeTraits<KIND>::NativeType;
+
+  if constexpr (KIND == TypeKind::BOOLEAN) {
+    auto* flatVector = result->asChecked<FlatVector<bool>>();
+    flatVector->set(row, false);
+    return true;
+  }
+
+  if constexpr (
+      KIND == TypeKind::TINYINT || KIND == TypeKind::SMALLINT ||
+      KIND == TypeKind::INTEGER || KIND == TypeKind::BIGINT) {
+    auto* flatVector = result->asChecked<FlatVector<T>>();
+    flatVector->set(row, std::numeric_limits<T>::min());
+    return true;
+  }
+
+  if constexpr (KIND == TypeKind::REAL || KIND == TypeKind::DOUBLE) {
+    auto* flatVector = result->asChecked<FlatVector<T>>();
+    flatVector->set(row, -std::numeric_limits<T>::infinity());
+    return true;
+  }
+
+  if constexpr (KIND == TypeKind::VARCHAR || KIND == TypeKind::VARBINARY) {
+    auto* flatVector = result->asChecked<FlatVector<StringView>>();
+    flatVector->set(row, StringView(""));
+    return true;
+  }
+
+  if constexpr (KIND == TypeKind::TIMESTAMP) {
+    auto* flatVector = result->asChecked<FlatVector<Timestamp>>();
+    flatVector->set(row, std::numeric_limits<Timestamp>::min());
+    return true;
+  }
+
+  VELOX_UNSUPPORTED("Cannot set min value for column type: {}", KIND);
+}
+
+template <TypeKind KIND>
+bool setMaxValueTyped(VectorPtr& result, vector_size_t row) {
+  using T = typename TypeTraits<KIND>::NativeType;
+
+  if constexpr (KIND == TypeKind::BOOLEAN) {
+    auto* flatVector = result->asChecked<FlatVector<bool>>();
+    flatVector->set(row, true);
+    return true;
+  }
+
+  if constexpr (
+      KIND == TypeKind::TINYINT || KIND == TypeKind::SMALLINT ||
+      KIND == TypeKind::INTEGER || KIND == TypeKind::BIGINT) {
+    auto* flatVector = result->asChecked<FlatVector<T>>();
+    flatVector->set(row, std::numeric_limits<T>::max());
+    return true;
+  }
+
+  if constexpr (KIND == TypeKind::REAL || KIND == TypeKind::DOUBLE) {
+    auto* flatVector = result->asChecked<FlatVector<T>>();
+    flatVector->set(row, std::numeric_limits<T>::infinity());
+    return true;
+  }
+
+  if constexpr (KIND == TypeKind::TIMESTAMP) {
+    auto* flatVector = result->asChecked<FlatVector<Timestamp>>();
+    flatVector->set(row, std::numeric_limits<Timestamp>::max());
+    return true;
+  }
+
+  if constexpr (KIND == TypeKind::VARCHAR || KIND == TypeKind::VARBINARY) {
+    // For max string value, we can't represent it directly, but we can use
+    // a very large string. However, this is problematic. For now, return false.
+    return false;
+  }
+
+  VELOX_UNSUPPORTED("Cannot set max value for column type: {}", KIND);
+}
+
+template <TypeKind KIND>
+bool incrementColumnValueTyped(
+    const VectorPtr& column,
+    vector_size_t row,
+    VectorPtr& result,
+    bool descending) {
+  using T = typename TypeTraits<KIND>::NativeType;
+
+  if constexpr (KIND == TypeKind::BOOLEAN) {
+    const auto* inputVector = column->asChecked<FlatVector<bool>>();
+    auto* resultVector = result->asChecked<FlatVector<bool>>();
+    const auto value = inputVector->valueAt(row);
+    if (!descending) {
+      // Ascending: false -> true, true cannot increment
+      if (value) {
+        // Overflow: wrap around to min value (false) for proper bound encoding.
+        resultVector->set(row, false);
+        return false;
+      }
+      resultVector->set(row, true);
+    } else {
+      // Descending: true -> false, false cannot decrement
+      if (!value) {
+        // Underflow: wrap around to max value (true) for proper bound encoding.
+        resultVector->set(row, true);
+        return false;
+      }
+      resultVector->set(row, false);
+    }
+    return true;
+  }
+
+  if constexpr (
+      KIND == TypeKind::TINYINT || KIND == TypeKind::SMALLINT ||
+      KIND == TypeKind::INTEGER || KIND == TypeKind::BIGINT) {
+    const auto* inputVector = column->asChecked<FlatVector<T>>();
+    auto* resultVector = result->asChecked<FlatVector<T>>();
+    const auto value = inputVector->valueAt(row);
+    if (!descending) {
+      // Ascending: increment
+      if (value == std::numeric_limits<T>::max()) {
+        // Overflow: wrap around to min value for proper bound encoding.
+        resultVector->set(row, std::numeric_limits<T>::min());
+        return false;
+      }
+      resultVector->set(row, value + 1);
+    } else {
+      // Descending: decrement
+      if (value == std::numeric_limits<T>::min()) {
+        // Underflow: wrap around to max value for proper bound encoding.
+        resultVector->set(row, std::numeric_limits<T>::max());
+        return false;
+      }
+      resultVector->set(row, value - 1);
+    }
+    return true;
+  }
+
+  if constexpr (KIND == TypeKind::REAL || KIND == TypeKind::DOUBLE) {
+    const auto* inputVector = column->asChecked<FlatVector<T>>();
+    auto* resultVector = result->asChecked<FlatVector<T>>();
+    const auto value = inputVector->valueAt(row);
+    if (!descending) {
+      // Ascending: increment to next representable value
+      if (std::isinf(value) && value > 0) {
+        // Overflow: wrap around to min value (-inf) for proper bound encoding.
+        resultVector->set(row, -std::numeric_limits<T>::infinity());
+        return false;
+      }
+      resultVector->set(
+          row, std::nextafter(value, std::numeric_limits<T>::infinity()));
+    } else {
+      // Descending: decrement to previous representable value
+      if (std::isinf(value) && value < 0) {
+        // Underflow: wrap around to max value (+inf) for proper bound encoding.
+        resultVector->set(row, std::numeric_limits<T>::infinity());
+        return false;
+      }
+      resultVector->set(
+          row, std::nextafter(value, -std::numeric_limits<T>::infinity()));
+    }
+    return true;
+  }
+
+  if constexpr (KIND == TypeKind::VARCHAR || KIND == TypeKind::VARBINARY) {
+    // For strings, increment/decrement the string representation.
+    const auto* inputVector = column->asChecked<FlatVector<StringView>>();
+    auto* resultVector = result->asChecked<FlatVector<StringView>>();
+    const auto value = inputVector->valueAt(row);
+    std::string incrementedStr(value.data(), value.size());
+    if (!incrementStringValue(&incrementedStr, descending)) {
+      VELOX_CHECK(descending);
+      // Descending underflow: should not happen in practice as VARCHAR
+      // filter conversion is not supported for descending order.
+      VELOX_UNREACHABLE(
+          "Unexpected string underflow during descending bound increment");
+    }
+    resultVector->set(row, StringView(incrementedStr));
+    return true;
+  }
+
+  if constexpr (KIND == TypeKind::TIMESTAMP) {
+    const auto* inputVector = column->asChecked<FlatVector<Timestamp>>();
+    auto* resultVector = result->asChecked<FlatVector<Timestamp>>();
+    const auto value = inputVector->valueAt(row);
+    if (!descending) {
+      // Ascending: increment nanos first, then seconds if nanos overflow
+      const auto nanos = value.getNanos();
+      VELOX_DCHECK_LE(nanos, Timestamp::kMaxNanos);
+      const auto seconds = value.getSeconds();
+      VELOX_DCHECK_LE(seconds, Timestamp::kMaxSeconds);
+      if (nanos < Timestamp::kMaxNanos) {
+        resultVector->set(row, Timestamp(seconds, nanos + 1));
+      } else if (seconds < Timestamp::kMaxSeconds) {
+        resultVector->set(row, Timestamp(seconds + 1, 0));
+      } else {
+        // Overflow: wrap around to min timestamp for proper bound encoding.
+        resultVector->set(row, Timestamp(Timestamp::kMinSeconds, 0));
+        return false;
+      }
+    } else {
+      // Descending: decrement nanos first, then seconds if nanos underflow
+      const auto nanos = value.getNanos();
+      const auto seconds = value.getSeconds();
+      if (nanos > 0) {
+        resultVector->set(row, Timestamp(seconds, nanos - 1));
+      } else if (seconds > Timestamp::kMinSeconds) {
+        resultVector->set(row, Timestamp(seconds - 1, Timestamp::kMaxNanos));
+      } else {
+        // Underflow: wrap around to max timestamp for proper bound encoding.
+        resultVector->set(
+            row, Timestamp(Timestamp::kMaxSeconds, Timestamp::kMaxNanos));
+        return false;
+      }
+    }
+    return true;
+  }
+
+  VELOX_UNSUPPORTED("Cannot increment column type: {}", KIND);
+}
+
+// Handles incrementing or decrementing null column values based on sort order.
+// Returns true if operation succeeds, false otherwise.
+bool incrementNullColumnValue(
+    const VectorPtr& column,
+    vector_size_t row,
+    bool descending,
+    bool nullLast,
+    VectorPtr& result) {
+  // For descending order, "next" value after null (or min in sort order) is
+  // MAX. For ascending order, "next" value after null (or min in sort order) is
+  // MIN.
+  result->setNull(row, false);
+  const auto ret = descending
+      ? VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+            setMaxValueTyped, column->typeKind(), result, row)
+      : VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+            setMinValueTyped, column->typeKind(), result, row);
+
+  VELOX_CHECK(
+      ret,
+      "Cannot set {} value for type {} when incrementing NULL",
+      descending ? "max" : "min",
+      column->type()->toString());
+
+  // Nulls first: increment succeeded, return true.
+  // Nulls last: null is at end of sort order, reset for carry, return false.
+  return !nullLast;
+}
+
+// Increments or decrements a column value at the given row index based on sort
+// order. Returns true if increment/decrement succeeds, false if value
+// overflows/underflows.
+bool incrementColumnValue(
+    const VectorPtr& column,
+    vector_size_t row,
+    bool descending,
+    bool nullLast,
+    VectorPtr& result) {
+  if (column->isNullAt(row)) {
+    return incrementNullColumnValue(column, row, descending, nullLast, result);
+  }
+
+  return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+      incrementColumnValueTyped,
+      column->typeKind(),
+      column,
+      row,
+      result,
+      descending);
+}
+} // namespace
+
+// static.
+std::unique_ptr<KeyEncoder> KeyEncoder::create(
+    std::vector<std::string> keyColumns,
+    RowTypePtr inputType,
+    std::vector<core::SortOrder> sortOrders,
+    memory::MemoryPool* pool) {
+  return std::unique_ptr<KeyEncoder>(new KeyEncoder(
+      std::move(keyColumns),
+      std::move(inputType),
+      std::move(sortOrders),
+      pool));
+}
+
+KeyEncoder::KeyEncoder(
+    std::vector<std::string> keyColumns,
+    RowTypePtr inputType,
+    std::vector<core::SortOrder> sortOrders,
+    memory::MemoryPool* pool)
+    : inputType_{std::move(inputType)},
+      sortOrders_{std::move(sortOrders)},
+      keyChannels_{getKeyChannels(inputType_, keyColumns)},
+      pool_{pool},
+      childDecodedVectors_{keyColumns.size()} {
+  VELOX_CHECK(!childDecodedVectors_.empty());
+  VELOX_CHECK_EQ(
+      keyChannels_.size(),
+      sortOrders_.size(),
+      "Size mismatch between key columns and sort orders");
+
+  // Validate that all index columns are valid types
+  for (size_t i = 0; i < keyChannels_.size(); ++i) {
+    const auto& columnType = inputType_->childAt(keyChannels_[i]);
+    VELOX_CHECK(
+        isValidIndexColumnType(columnType),
+        "Unsupported type for index column '{}': {}",
+        keyColumns[i],
+        columnType->toString());
+  }
+}
+
+void KeyEncoder::encodeColumn(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  const auto typeKind = decodedVector.base()->typeKind();
+  if (decodedVector.base()->type()->isDate()) {
+    encodeDate(decodedVector, numRows, descending, nullLast, rowOffsets);
+  } else {
+    VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+        encodeColumnTyped,
+        typeKind,
+        decodedVector,
+        numRows,
+        descending,
+        nullLast,
+        rowOffsets);
+  }
+}
+
+KeyEncoder::IncrementedBoundsResult KeyEncoder::createIncrementedBounds(
+    const RowVectorPtr& bounds) const {
+  const auto& children = bounds->children();
+  const auto numRows = bounds->size();
+  const auto numKeyColumns = keyChannels_.size();
+  VELOX_CHECK_EQ(children.size(), numKeyColumns);
+
+  // Create vectors for incrementing values.
+  std::vector<VectorPtr> incrementedChildren;
+  incrementedChildren.reserve(numKeyColumns);
+  for (const auto& child : children) {
+    incrementedChildren.push_back(
+        BaseVector::create(child->type(), numRows, pool_));
+  }
+
+  // Copy all values from the source rows.
+  for (size_t i = 0; i < numKeyColumns; ++i) {
+    incrementedChildren[i]->copy(children[i].get(), 0, 0, numRows);
+  }
+
+  // Track succeeded rows directly in indices buffer.
+  auto indicesBuffer = allocateIndices(numRows, pool_);
+  auto* rawIndices = indicesBuffer->asMutable<vector_size_t>();
+  vector_size_t numSucceeded{0};
+
+  // Process each row independently.
+  for (vector_size_t row = 0; row < numRows; ++row) {
+    // Increment from rightmost key column (least significant) to leftmost.
+    // Stop when we find a column that can be incremented.
+    for (int col = numKeyColumns - 1; col >= 0; --col) {
+      const bool descending = !sortOrders_[col].isAscending();
+      const bool nullLast = !sortOrders_[col].isNullsFirst();
+      if (FOLLY_LIKELY(incrementColumnValue(
+              incrementedChildren[col],
+              row,
+              descending,
+              nullLast,
+              incrementedChildren[col]))) {
+        rawIndices[numSucceeded++] = row;
+        break;
+      }
+    }
+  }
+
+  if (numSucceeded == 0) {
+    return {nullptr, nullptr};
+  }
+
+  // If all rows succeeded, return incrementedChildren directly without
+  // wrapping.
+  if (numSucceeded == numRows) {
+    return {
+        std::make_shared<RowVector>(
+            pool_,
+            bounds->type(),
+            nullptr,
+            numRows,
+            std::move(incrementedChildren)),
+        nullptr};
+  }
+  VELOX_CHECK_LT(numSucceeded, numRows);
+
+  // Wrap children in place with dictionary using succeeded indices.
+  for (auto& child : incrementedChildren) {
+    child = BaseVector::wrapInDictionary(
+        nullptr, indicesBuffer, numSucceeded, child);
+  }
+  return {
+      std::make_shared<RowVector>(
+          pool_,
+          bounds->type(),
+          nullptr,
+          numSucceeded,
+          std::move(incrementedChildren)),
+      std::move(indicesBuffer)};
+}
+
+uint64_t KeyEncoder::estimateEncodedSize() {
+  const auto numRows = decodedVector_.size();
+  encodedSizes_.resize(numRows, 0);
+
+  // Process each key channel in columnar order.
+  for (auto i = 0; i < keyChannels_.size(); ++i) {
+    ScratchPtr<vector_size_t, 128> decodedRowsHolder(scratch_);
+    auto* decodedRows = decodedRowsHolder.get(numRows);
+    for (auto row = 0; row < numRows; ++row) {
+      decodedRows[row] = decodedVector_.index(row);
+    }
+
+    estimateEncodedColumnSize(
+        childDecodedVectors_[i],
+        folly::Range<const vector_size_t*>(decodedRows, numRows),
+        encodedSizes_,
+        scratch_);
+  }
+  return std::accumulate(encodedSizes_.begin(), encodedSizes_.end(), 0);
+}
+
+std::vector<std::string> KeyEncoder::encode(const RowVectorPtr& input) {
+  std::vector<char> buffer;
+  std::vector<std::string_view> encodedKeys;
+  // Call the templated encode method with a buffer allocator lambda
+  encode(input, encodedKeys, [&buffer](size_t size) -> void* {
+    buffer.resize(size);
+    return buffer.data();
+  });
+
+  // Copy encoded keys to result.
+  std::vector<std::string> result;
+  result.reserve(encodedKeys.size());
+  for (const auto& key : encodedKeys) {
+    result.emplace_back(key.data(), key.size());
+  }
+  return result;
+}
+
+std::vector<EncodedKeyBounds> KeyEncoder::encodeIndexBounds(
+    const IndexBounds& indexBounds) {
+  VELOX_CHECK(indexBounds.validate());
+
+  const auto numRows = indexBounds.numRows();
+  std::vector<EncodedKeyBounds> results(numRows);
+
+  // Encode lower bounds if present.
+  if (indexBounds.lowerBound.has_value()) {
+    const auto& lowerBound = indexBounds.lowerBound.value();
+    RowVectorPtr lowerBoundToEncode = lowerBound.bound;
+
+    // For exclusive lower bound, bump up all rows before encoding.
+    if (!lowerBound.inclusive) {
+      const auto incrementedResult =
+          createIncrementedBounds(lowerBoundToEncode);
+      // All rows must succeed for lower bound increment.
+      VELOX_CHECK_NOT_NULL(
+          incrementedResult.bounds,
+          "Failed to bump up lower bound for exclusive range");
+      VELOX_CHECK_NULL(
+          incrementedResult.succeededIndices,
+          "Failed to bump up lower bound for exclusive range");
+      lowerBoundToEncode = incrementedResult.bounds;
+    }
+
+    auto encodedKeys = encode(lowerBoundToEncode);
+    VELOX_CHECK_EQ(encodedKeys.size(), numRows);
+    for (vector_size_t row = 0; row < numRows; ++row) {
+      results[row].lowerKey = std::move(encodedKeys[row]);
+    }
+  }
+
+  // Encode upper bounds if present.
+  if (indexBounds.upperBound.has_value()) {
+    const auto& upperBound = indexBounds.upperBound.value();
+
+    // For inclusive upper bound, bump up rows before encoding.
+    // Failed rows will have unbounded upper bound (std::nullopt).
+    if (upperBound.inclusive) {
+      const auto incrementedResult = createIncrementedBounds(upperBound.bound);
+
+      // Only encode if there are any succeeded rows.
+      if (incrementedResult.bounds != nullptr) {
+        const auto numSucceeded = incrementedResult.bounds->size();
+        auto encodedKeys = encode(incrementedResult.bounds);
+        VELOX_CHECK_EQ(encodedKeys.size(), numSucceeded);
+
+        // Map encoded keys back to original row indices.
+        if (incrementedResult.allSucceeded()) {
+          VELOX_CHECK_EQ(numSucceeded, numRows);
+          // All rows succeeded - direct mapping.
+          for (vector_size_t i = 0; i < numSucceeded; ++i) {
+            results[i].upperKey = std::move(encodedKeys[i]);
+          }
+        } else {
+          VELOX_CHECK_LT(numSucceeded, numRows);
+          // Partial success - use indices to map back.
+          const auto* rawIndices =
+              incrementedResult.succeededIndices->as<vector_size_t>();
+          for (vector_size_t i = 0; i < numSucceeded; ++i) {
+            results[rawIndices[i]].upperKey = std::move(encodedKeys[i]);
+          }
+        }
+      }
+      // Failed rows keep upperKey as std::nullopt (unbounded).
+    } else {
+      // Exclusive upper bound - encode directly.
+      auto encodedKeys = encode(upperBound.bound);
+      VELOX_CHECK_EQ(encodedKeys.size(), numRows);
+      for (vector_size_t row = 0; row < numRows; ++row) {
+        results[row].upperKey = std::move(encodedKeys[row]);
+      }
+    }
+  }
+
+  return results;
+}
+
+} // namespace facebook::velox::serializer
diff --git a/velox/serializers/KeyEncoder.h b/velox/serializers/KeyEncoder.h
new file mode 100644
index 00000000000..01ec8192e63
--- /dev/null
+++ b/velox/serializers/KeyEncoder.h
@@ -0,0 +1,307 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <functional>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/memory/Scratch.h"
+#include "velox/core/PlanNode.h"
+#include "velox/type/Type.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/DecodedVector.h"
+
+namespace facebook::velox::serializer {
+
+/// A single index bound (lower or upper) with inclusive flag.
+/// Used to represent either a lower or upper bound for index filtering.
+/// The bound vector must be non-null with at least 1 row. To represent an
+/// unbounded range, use std::nullopt in the host IndexBounds instead of a
+/// null bound vector.
+struct IndexBound {
+  /// Bound values. For single-row bounds, this contains exactly 1 row.
+  /// For multi-row bounds (batch processing), this may contain N rows.
+  /// Must be non-null with at least 1 row.
+  RowVectorPtr bound;
+  /// Whether this bound is inclusive. If true, the bound value is included
+  /// in the range; if false, it's excluded.
+  bool inclusive{true};
+};
+
+/// Represents bounds for index-based filtering with optional lower and upper
+/// bounds. Used to define a range of values for index columns that can be
+/// encoded into byte-comparable keys for efficient filtering.
+struct IndexBounds {
+  /// The top-level column names that form the index. These columns must exist
+  /// in the input data and define the order of columns in the encoded key.
+  std::vector<std::string> indexColumns;
+  /// Lower bound for the index range. std::nullopt means unbounded (no lower
+  /// bound).
+  std::optional<IndexBound> lowerBound;
+  /// Upper bound for the index range. std::nullopt means unbounded (no upper
+  /// bound).
+  std::optional<IndexBound> upperBound;
+
+  /// Sets both bounds and validates them. Throws if validation fails.
+  /// The indexColumns must be set before calling this method.
+  void set(IndexBound lower, IndexBound upper);
+
+  /// Clears both lower and upper bounds. The indexColumns are preserved.
+  void clear();
+
+  /// Returns the type from the bound vectors.
+  /// Extracts the type from lowerBound if available, otherwise from upperBound.
+  /// At least one bound must be present (non-null).
+  TypePtr type() const;
+
+  /// Returns the number of rows in the bounds. Requires at least one bound
+  /// to be present. If both bounds exist, they must have the same row count.
+  vector_size_t numRows() const;
+
+  /// Validates that the bounds are well-formed:
+  /// - At least one bound (lower or upper) must be present (non-null)
+  /// - Each non-null bound must have at least 1 row
+  /// - If both bounds are present, they must have the same number of rows
+  /// Returns true if valid, false otherwise.
+  bool validate() const;
+
+  /// Returns a human-readable string representation of the bounds.
+  std::string toString() const;
+};
+
+/// Encoded representation of index bounds as byte-comparable strings.
+/// These keys can be compared lexicographically to perform range filtering.
+struct EncodedKeyBounds {
+  /// Encoded lower bound key. If present, represents the minimum key value
+  /// (inclusive or exclusive based on IndexBound.inclusive).
+  std::optional<std::string> lowerKey;
+  /// Encoded upper bound key. If present, represents the maximum key value
+  /// (inclusive or exclusive based on IndexBound.inclusive).
+  std::optional<std::string> upperKey;
+
+  /// Returns true if this represents a point lookup (both bounds present and
+  /// equal).
+  bool isPointLookup() const {
+    return lowerKey.has_value() && upperKey.has_value() &&
+        lowerKey.value() == upperKey.value();
+  }
+
+  /// Returns a human-readable string representation with hex-encoded keys.
+  std::string toString() const;
+};
+
+/// KeyEncoder encodes multi-column keys into byte-comparable strings that
+/// preserve the sort order defined by the column types and sort orders.
+/// This enables efficient range-based filtering and comparison of composite
+/// keys.
+///
+/// The encoding is designed such that:
+/// - Lexicographic comparison of encoded keys matches the logical comparison
+///   of the original values
+/// - Null values are sorted according to the specified sort order (nulls
+///   first/last)
+/// - Ascending/descending sort orders are respected
+/// - Only scalar types are supported (e.g., integers, floats, strings,
+///   booleans, dates). Complex types (arrays, maps, rows) are not supported.
+///
+/// Example usage:
+///   auto keyEncoder = KeyEncoder::create(
+///       {"col1", "col2"}, rowType, sortOrders, pool);
+///   std::vector<std::string_view> encodedKeys;
+///   HashStringAllocator allocator(pool);
+///   keyEncoder->encode(inputVector, encodedKeys,
+///       [&allocator](size_t size) { return allocator.allocate(size); });
+class KeyEncoder {
+ public:
+  /// Factory method to create a KeyEncoder instance.
+  ///
+  /// @param keyColumns Names of columns to include in the encoded key, in order
+  /// @param inputType Row type of the input data containing these columns
+  /// @param sortOrders Sort order for each key column (ascending/descending,
+  ///                   nulls first/last)
+  /// @param pool Memory pool for allocations
+  /// @return Unique pointer to a new KeyEncoder instance
+  static std::unique_ptr<KeyEncoder> create(
+      std::vector<std::string> keyColumns,
+      RowTypePtr inputType,
+      std::vector<core::SortOrder> sortOrders,
+      memory::MemoryPool* pool);
+
+  /// Type alias for buffer allocator function.
+  /// Takes estimated size in bytes and returns a pointer to the allocated
+  /// buffer.
+  using BufferAllocator = std::function<void*(size_t)>;
+
+  /// Encodes the key columns from the input vector into byte-comparable keys.
+  ///
+  /// Each row in the input produces one encoded key string. The keys can be
+  /// compared lexicographically, and the comparison result will match the
+  /// logical comparison based on the specified sort orders.
+  ///
+  /// @tparam Container A container type for std::string_view that supports
+  ///                   reserve(), size(), and emplace_back() operations.
+  /// @param input Input vector containing rows to encode
+  /// @param encodedKeys Output container to store the encoded key strings
+  ///                    (views into allocated buffer)
+  /// @param bufferAllocator Allocator function that takes estimated size and
+  ///                        returns pointer to allocated buffer
+  template <typename Container>
+  void encode(
+      const VectorPtr& input,
+      Container& encodedKeys,
+      const BufferAllocator& bufferAllocator);
+
+  /// Encodes index bounds into byte-comparable boundary keys.
+  ///
+  /// The implementation normalizes all bounds to half-open interval format
+  /// [lower_bound, upper_bound) to ease range scan processing:
+  /// - Lower bounds: Always converted to inclusive
+  ///   - Exclusive lower bound (x > 5) → incremented to inclusive (x >= 6)
+  ///   - Inclusive lower bound (x >= 5) → stays as is
+  /// - Upper bounds: Always converted to exclusive
+  ///   - Inclusive upper bound (x <= 10) → incremented to exclusive (x < 11)
+  ///   - Exclusive upper bound (x < 10) → stays as is
+  ///
+  /// Increment failure handling:
+  /// - Lower bound increment fails → returns std::nullopt (encoding failed,
+  ///   cannot establish valid range start)
+  /// - Upper bound increment fails → upperKey set to std::nullopt (treated as
+  ///   unbounded upper range)
+  ///
+  /// Increment fails when values are at their maximum (e.g., INT_MAX, strings
+  /// with all \xFF characters, or nulls in NULLS_LAST ordering).
+  ///
+  /// Takes an IndexBounds containing lower and/or upper bounds and encodes them
+  /// into EncodedKeyBounds for efficient range comparison. Returns a vector
+  /// with one EncodedKeyBounds per row in 'indexBounds'. Each row is encoded
+  /// into a byte-comparable key string. Throws if any lower bound fails to bump
+  /// up (for exclusive bounds). For upper bound bump up failures, the upperKey
+  /// is set to std::nullopt (unbounded).
+  std::vector<EncodedKeyBounds> encodeIndexBounds(
+      const IndexBounds& indexBounds);
+
+  /// Returns the sort orders for each index column.
+  const std::vector<core::SortOrder>& sortOrders() const {
+    return sortOrders_;
+  }
+
+ private:
+  KeyEncoder(
+      std::vector<std::string> keyColumns,
+      RowTypePtr inputType,
+      std::vector<core::SortOrder> sortOrders,
+      memory::MemoryPool* pool);
+
+  uint64_t estimateEncodedSize();
+
+  // Encodes a RowVector and returns encoded keys as strings.
+  // Each row in the input vector produces one encoded key string.
+  std::vector<std::string> encode(const RowVectorPtr& input);
+
+  // Creates a new row vector with the key columns incremented by 1 for each
+  // row. For each row, the increment starts from the rightmost (least
+  // significant) column and propagates left on overflow until successful or all
+  // columns overflow.
+  //
+  // Returns:
+  // - bounds: A RowVector containing only successfully incremented rows. If all
+  //   rows succeed, children are direct copies. If some rows fail, children are
+  //   dictionary-wrapped to reference only succeeded rows. Returns nullptr if
+  //   no rows succeed.
+  // - succeededIndices: Buffer containing original row indices that succeeded.
+  //   Returns nullptr if all rows succeed (no dictionary needed) or if no rows
+  //   succeed.
+  struct IncrementedBoundsResult {
+    RowVectorPtr bounds;
+    BufferPtr succeededIndices;
+
+    // Returns true if all rows succeeded (no dictionary wrapping needed).
+    bool allSucceeded() const;
+  };
+  IncrementedBoundsResult createIncrementedBounds(
+      const RowVectorPtr& bounds) const;
+
+  // Encodes a single column for all rows.
+  void encodeColumn(
+      const DecodedVector& decodedVector,
+      vector_size_t numRows,
+      bool descending,
+      bool nullLast,
+      std::vector<char*>& rowOffsets);
+
+  const RowTypePtr inputType_;
+  const std::vector<core::SortOrder> sortOrders_;
+  const std::vector<vector_size_t> keyChannels_;
+  memory::MemoryPool* const pool_;
+
+  // Reusable buffers.
+  DecodedVector decodedVector_;
+  std::vector<DecodedVector> childDecodedVectors_;
+  std::vector<vector_size_t> encodedSizes_;
+  Scratch scratch_;
+};
+
+// Template implementation
+template <typename Container>
+void KeyEncoder::encode(
+    const VectorPtr& input,
+    Container& encodedKeys,
+    const BufferAllocator& bufferAllocator) {
+  VELOX_CHECK_GT(input->size(), 0);
+  SCOPE_EXIT {
+    encodedSizes_.clear();
+  };
+  decodedVector_.decode(*input, /*loadLazy=*/true);
+  const auto* rowBase = decodedVector_.base()->asChecked<RowVector>();
+  const auto& children = rowBase->children();
+  for (auto i = 0; i < keyChannels_.size(); ++i) {
+    childDecodedVectors_[i].decode(*children[keyChannels_[i]]);
+  }
+  const auto totalBytes = estimateEncodedSize();
+  auto* const allocated = static_cast<char*>(bufferAllocator(totalBytes));
+
+  const auto numRows = input->size();
+  const auto numKeys = keyChannels_.size();
+
+  // Compute buffer start offsets for each row
+  std::vector<char*> rowOffsets(numRows);
+  rowOffsets[0] = allocated;
+  for (auto row = 1; row < numRows; ++row) {
+    rowOffsets[row] = rowOffsets[row - 1] + encodedSizes_[row - 1];
+  }
+
+  // Encode column-by-column for better cache locality
+  for (auto i = 0; i < numKeys; ++i) {
+    const bool nullLast = !sortOrders_[i].isNullsFirst();
+    const bool descending = !sortOrders_[i].isAscending();
+    const auto& decodedVector = childDecodedVectors_[i];
+
+    // Encode column data for all rows (null indicator is encoded within each
+    // type's encoding function)
+    encodeColumn(decodedVector, numRows, descending, nullLast, rowOffsets);
+  }
+
+  // Build encoded keys string views
+  encodedKeys.reserve(encodedKeys.size() + numRows);
+  size_t offset{0};
+  for (auto row = 0; row < numRows; ++row) {
+    encodedKeys.emplace_back(allocated + offset, encodedSizes_[row]);
+    offset += encodedSizes_[row];
+    VELOX_CHECK_EQ(rowOffsets[row], allocated + offset);
+  }
+}
+
+} // namespace facebook::velox::serializer
diff --git a/velox/serializers/PrestoHeader.cpp b/velox/serializers/PrestoHeader.cpp
index 5e2b36b38c1..bfa44989eb7 100644
--- a/velox/serializers/PrestoHeader.cpp
+++ b/velox/serializers/PrestoHeader.cpp
@@ -21,8 +21,9 @@ namespace facebook::velox::serializer::presto::detail {
 /* static */ Expected<PrestoHeader> PrestoHeader::read(
     ByteInputStream* source) {
   if (source->remainingSize() < kHeaderSize) {
-    return folly::makeUnexpected(Status::Invalid(
-        fmt::format("{} bytes for header", source->remainingSize())));
+    return folly::makeUnexpected(
+        Status::Invalid(
+            fmt::format("{} bytes for header", source->remainingSize())));
   }
   PrestoHeader header;
   header.numRows = source->read<int32_t>();
@@ -36,12 +37,15 @@ namespace facebook::velox::serializer::presto::detail {
         Status::Invalid(fmt::format("negative numRows: {}", header.numRows)));
   }
   if (header.uncompressedSize < 0) {
-    return folly::makeUnexpected(Status::Invalid(
-        fmt::format("negative uncompressedSize: {}", header.uncompressedSize)));
+    return folly::makeUnexpected(
+        Status::Invalid(
+            fmt::format(
+                "negative uncompressedSize: {}", header.uncompressedSize)));
   }
   if (header.compressedSize < 0) {
-    return folly::makeUnexpected(Status::Invalid(
-        fmt::format("negative compressedSize: {}", header.compressedSize)));
+    return folly::makeUnexpected(
+        Status::Invalid(
+            fmt::format("negative compressedSize: {}", header.compressedSize)));
   }
 
   return header;
diff --git a/velox/serializers/PrestoIterativeVectorSerializer.cpp b/velox/serializers/PrestoIterativeVectorSerializer.cpp
index de73cd7f1cc..2165ecebbe2 100644
--- a/velox/serializers/PrestoIterativeVectorSerializer.cpp
+++ b/velox/serializers/PrestoIterativeVectorSerializer.cpp
@@ -91,9 +91,17 @@ void PrestoIterativeVectorSerializer::flush(OutputStream* out) {
         opts_.minCompressionRatio,
         out);
   } else {
-    if (numCompressionToSkip_ > 0) {
-      const auto noCompressionCodec = common::compressionKindToCodec(
-          common::CompressionKind::CompressionKind_NONE);
+    // Safe to share across threads because NoCompressionCodec is stateless.
+    // Do NOT change to a different CompressionKind without removing 'static'.
+    static const auto noCompressionCodec = common::compressionKindToCodec(
+        common::CompressionKind::CompressionKind_NONE);
+    if (opts_.minCompressionPageSizeBytes > 0 &&
+        streamArena_->size() <
+            static_cast<size_t>(opts_.minCompressionPageSizeBytes)) {
+      auto [size, ignore] = flushStreams(
+          streams_, numRows_, *streamArena_, *noCompressionCodec, 1, out);
+      stats_.compressionSkippedBytes += size;
+    } else if (numCompressionToSkip_ > 0) {
       auto [size, ignore] = flushStreams(
           streams_, numRows_, *streamArena_, *noCompressionCodec, 1, out);
       stats_.compressionSkippedBytes += size;
@@ -122,18 +130,18 @@ PrestoIterativeVectorSerializer::runtimeStats() {
   std::unordered_map<std::string, RuntimeCounter> map;
   if (stats_.compressionInputBytes != 0) {
     map.emplace(
-        kCompressionInputBytes,
+        std::string(kCompressionInputBytes),
         RuntimeCounter(
             stats_.compressionInputBytes, RuntimeCounter::Unit::kBytes));
   }
   if (stats_.compressedBytes != 0) {
     map.emplace(
-        kCompressedBytes,
+        std::string(kCompressedBytes),
         RuntimeCounter(stats_.compressedBytes, RuntimeCounter::Unit::kBytes));
   }
   if (stats_.compressionSkippedBytes != 0) {
     map.emplace(
-        kCompressionSkippedBytes,
+        std::string(kCompressionSkippedBytes),
         RuntimeCounter(
             stats_.compressionSkippedBytes, RuntimeCounter::Unit::kBytes));
   }
diff --git a/velox/serializers/PrestoSerializer.cpp b/velox/serializers/PrestoSerializer.cpp
index 2217c2eed22..b7f6d011244 100644
--- a/velox/serializers/PrestoSerializer.cpp
+++ b/velox/serializers/PrestoSerializer.cpp
@@ -88,6 +88,10 @@ PrestoVectorSerde::PrestoOptions toPrestoOptions(
       dynamic_cast<const PrestoVectorSerde::PrestoOptions*>(options);
   VELOX_CHECK_NOT_NULL(
       prestoOptions, "Serde options are not Presto-compatible");
+  VELOX_CHECK(
+      !(prestoOptions->useLosslessTimestamp &&
+        prestoOptions->useMicrosecondPrecision),
+      "useLosslessTimestamp and useMicrosecondPrecision are mutually exclusive");
   return *prestoOptions;
 }
 } // namespace
@@ -262,7 +266,16 @@ void PrestoVectorSerde::registerVectorSerde() {
 void PrestoVectorSerde::registerNamedVectorSerde() {
   detail::initBitsToMapOnce();
   velox::registerNamedVectorSerde(
-      VectorSerde::Kind::kPresto, std::make_unique<PrestoVectorSerde>());
+      kSerdeKind, std::make_unique<PrestoVectorSerde>());
+}
+
+// static
+void PrestoVectorSerde::tryRegisterNamedVectorSerde() {
+  if (!velox::isRegisteredNamedVectorSerde(kSerdeKind)) {
+    detail::initBitsToMapOnce();
+    velox::registerNamedVectorSerde(
+        kSerdeKind, std::make_unique<PrestoVectorSerde>());
+  }
 }
 
 /* static */ Status PrestoVectorSerde::lex(
diff --git a/velox/serializers/PrestoSerializer.h b/velox/serializers/PrestoSerializer.h
index a079e232b8a..ce6cee6f074 100644
--- a/velox/serializers/PrestoSerializer.h
+++ b/velox/serializers/PrestoSerializer.h
@@ -69,6 +69,12 @@ class PrestoVectorSerde : public VectorSerde {
     /// currently used for spilling. Is false by default.
     bool useLosslessTimestamp{false};
 
+    /// When true, interprets serialized timestamp values as microseconds
+    /// instead of milliseconds. Used when the source data contains timestamps
+    /// in microsecond precision (e.g., TIMESTAMP_MICROSECONDS Presto type).
+    /// Mutually exclusive with useLosslessTimestamp.
+    bool useMicrosecondPrecision{false};
+
     /// Serializes nulls of structs before the columns. Used to allow
     /// single pass reading of in spilling.
     ///
@@ -82,7 +88,7 @@ class PrestoVectorSerde : public VectorSerde {
     bool preserveEncodings{false};
   };
 
-  PrestoVectorSerde() : VectorSerde(Kind::kPresto) {}
+  PrestoVectorSerde() : VectorSerde(kSerdeKind) {}
 
   /// Adds the serialized sizes of the rows of 'vector' in 'ranges[i]' to
   /// '*sizes[i]'.
@@ -185,8 +191,25 @@ class PrestoVectorSerde : public VectorSerde {
       std::vector<Token>& out,
       const Options* options = nullptr);
 
+  /// Registers this serde as the global default vector serde. Throws if a
+  /// default serde is already registered.
   static void registerVectorSerde();
+
+  /// Registers this serde in the named serde registry under kSerdeKind.
+  /// Throws if a serde with the same name is already registered.
   static void registerNamedVectorSerde();
+
+  /// Registers this serde in the named serde registry under kSerdeKind only
+  /// if not already registered. No-op if a serde with the same name exists.
+  static void tryRegisterNamedVectorSerde();
+
+  /// Returns the name of this serde kind.
+  static const std::string& name() {
+    return kSerdeKind;
+  }
+
+ private:
+  inline static const std::string kSerdeKind{"Presto"};
 };
 
 class PrestoOutputStreamListener : public OutputStreamListener {
diff --git a/velox/serializers/PrestoSerializerDeserializationUtils.cpp b/velox/serializers/PrestoSerializerDeserializationUtils.cpp
index 633937c38b6..2f9b3e843ea 100644
--- a/velox/serializers/PrestoSerializerDeserializationUtils.cpp
+++ b/velox/serializers/PrestoSerializerDeserializationUtils.cpp
@@ -180,6 +180,7 @@ void readRowVectorStructNulls(
 
 std::string readLengthPrefixedString(ByteInputStream* source) {
   int32_t size = source->read<int32_t>();
+  VELOX_CHECK_GE(size, 0, "Invalid serialized string size: {}", size);
   std::string value;
   value.resize(size);
   source->readBytes(&value[0], size);
@@ -596,6 +597,38 @@ void readLosslessTimestampValues(
   }
 }
 
+Timestamp readMicrosecondTimestamp(ByteInputStream* source) {
+  int64_t micros = source->read<int64_t>();
+  return Timestamp::fromMicros(micros);
+}
+
+void readMicrosecondTimestampValues(
+    ByteInputStream* source,
+    vector_size_t size,
+    vector_size_t offset,
+    const BufferPtr& nulls,
+    vector_size_t nullCount,
+    const BufferPtr& values) {
+  auto rawValues = values->asMutable<Timestamp>();
+  checkValuesSize<Timestamp>(values, nulls, size, offset);
+  if (nullCount > 0) {
+    int32_t toClear = offset;
+    bits::forEachSetBit(
+        nulls->as<uint64_t>(), offset, offset + size, [&](int32_t row) {
+          // Set the values between the last non-null and this to type default.
+          for (; toClear < row; ++toClear) {
+            rawValues[toClear] = Timestamp();
+          }
+          rawValues[row] = readMicrosecondTimestamp(source);
+          toClear = row + 1;
+        });
+  } else {
+    for (int32_t row = offset; row < offset + size; ++row) {
+      rawValues[row] = readMicrosecondTimestamp(source);
+    }
+  }
+}
+
 template <typename T>
 void readValues(
     ByteInputStream* source,
@@ -718,6 +751,16 @@ void read(
           values);
       return;
     }
+    if (opts.useMicrosecondPrecision) {
+      readMicrosecondTimestampValues(
+          source,
+          numNewValues,
+          resultOffset,
+          flatResult->nulls(),
+          nullCount,
+          values);
+      return;
+    }
   }
   if constexpr (std::is_same_v<T, int128_t>) {
     if (type->isLongDecimal()) {
@@ -866,7 +909,7 @@ void read<OpaqueType>(
   for (int32_t i = 0; i < numNewValues; ++i) {
     int32_t offset = offsets[i];
     auto sv = StringView(rawString + previousOffset, offset - previousOffset);
-    auto opaqueValue = deserialization(sv);
+    auto opaqueValue = deserialization(std::string(sv));
     rawValues[resultOffset + i] = opaqueValue;
     previousOffset = offset;
   }
diff --git a/velox/serializers/PrestoSerializerEstimationUtils.cpp b/velox/serializers/PrestoSerializerEstimationUtils.cpp
index b5ffeeaea2d..203dd637201 100644
--- a/velox/serializers/PrestoSerializerEstimationUtils.cpp
+++ b/velox/serializers/PrestoSerializerEstimationUtils.cpp
@@ -357,6 +357,14 @@ void estimateWrapperSerializedSize(
   std::vector<IndexRange> newRanges;
   std::vector<vector_size_t*> newSizes;
   const BaseVector* wrapped = wrapper->wrappedVector();
+  if (!wrapper->mayHaveNulls()) {
+    int64_t totalSize = 0;
+    for (int32_t i = 0; i < ranges.size(); ++i) {
+      totalSize += ranges[i].size;
+    }
+    newRanges.reserve(totalSize);
+    newSizes.reserve(totalSize);
+  }
   for (int32_t i = 0; i < ranges.size(); ++i) {
     int32_t numNulls = 0;
     auto end = ranges[i].begin + ranges[i].size;
@@ -381,6 +389,14 @@ void expandRepeatedRanges(
     vector_size_t** sizes,
     std::vector<IndexRange>* childRanges,
     std::vector<vector_size_t*>* childSizes) {
+  if (!vector->mayHaveNulls()) {
+    int64_t totalSize = 0;
+    for (int32_t i = 0; i < ranges.size(); ++i) {
+      totalSize += ranges[i].size;
+    }
+    childRanges->reserve(totalSize);
+    childSizes->reserve(totalSize);
+  }
   for (int32_t i = 0; i < ranges.size(); ++i) {
     int32_t begin = ranges[i].begin;
     int32_t end = begin + ranges[i].size;
diff --git a/velox/serializers/PrestoSerializerSerializationUtils.cpp b/velox/serializers/PrestoSerializerSerializationUtils.cpp
index f4321c5c8e4..4792ddbb4c0 100644
--- a/velox/serializers/PrestoSerializerSerializationUtils.cpp
+++ b/velox/serializers/PrestoSerializerSerializationUtils.cpp
@@ -139,6 +139,7 @@ void serializeWrappedRanges(
     VectorStream* stream,
     Scratch& scratch) {
   std::vector<IndexRange> newRanges;
+  newRanges.reserve(rangesTotalSize(ranges));
   const bool mayHaveNulls = vector->mayHaveNulls();
   const VectorPtr& wrapped = BaseVector::wrappedVectorShared(vector);
   for (int32_t i = 0; i < ranges.size(); ++i) {
@@ -373,6 +374,11 @@ void serializeRowVectorRanges(
   }
   auto rowVector = vector->as<RowVector>();
   std::vector<IndexRange> childRanges;
+  size_t totalOffsets = 0;
+  for (const auto& range : ranges) {
+    totalOffsets += range.size;
+  }
+  childRanges.reserve(totalOffsets);
   for (int32_t i = 0; i < ranges.size(); ++i) {
     auto begin = ranges[i].begin;
     auto end = begin + ranges[i].size;
@@ -400,8 +406,12 @@ void serializeArrayVectorRanges(
   auto arrayVector = vector->as<ArrayVector>();
   auto rawSizes = arrayVector->rawSizes();
   auto rawOffsets = arrayVector->rawOffsets();
+  size_t totalOffsets = 0;
+  for (const auto& range : ranges) {
+    totalOffsets += range.size;
+  }
   std::vector<IndexRange> childRanges;
-  childRanges.reserve(ranges.size());
+  childRanges.reserve(totalOffsets);
   for (int32_t i = 0; i < ranges.size(); ++i) {
     int32_t begin = ranges[i].begin;
     int32_t end = begin + ranges[i].size;
@@ -529,8 +539,9 @@ void serializeIPPrefix(
       // the ipaddress porition as big endian whereas Velox stores it as little
       auto javaIPPrefix =
           toJavaIPPrefixType(ip->valueAt(rows[i]), prefix->valueAt(rows[i]));
-      stream->values().appendStringView(std::string_view(
-          (const char*)javaIPPrefix.data(), javaIPPrefix.size()));
+      stream->values().appendStringView(
+          std::string_view(
+              (const char*)javaIPPrefix.data(), javaIPPrefix.size()));
     }
     return;
   }
@@ -558,8 +569,8 @@ void copyWords(
     const T* values,
     Conv&& conv = {}) {
   for (auto i = 0; i < numIndices; ++i) {
-    folly::storeUnaligned(
-        destination + i * sizeof(T), conv(values[indices[i]]));
+    folly::storeUnaligned<T>(
+        destination + i * sizeof(T), static_cast<T>(conv(values[indices[i]])));
   }
 }
 
@@ -576,8 +587,9 @@ void copyWordsWithRows(
     return;
   }
   for (auto i = 0; i < numIndices; ++i) {
-    folly::storeUnaligned(
-        destination + i * sizeof(T), conv(values[rows[indices[i]]]));
+    folly::storeUnaligned<T>(
+        destination + i * sizeof(T),
+        static_cast<T>(conv(values[rows[indices[i]]])));
   }
 }
 
@@ -761,7 +773,7 @@ void serializeFlatVector<TypeKind::BOOLEAN>(
     uint64_t word = bitsToBytes(reinterpret_cast<uint8_t*>(valueBits)[i]);
     auto* target = output + i * 8;
     if (i < numBytes - 1) {
-      folly::storeUnaligned(target, word);
+      folly::storeUnaligned<uint64_t>(target, word);
     } else {
       memcpy(target, &word, numValueBits - i * 8);
     }
diff --git a/velox/serializers/PrestoSerializerSerializationUtils.h b/velox/serializers/PrestoSerializerSerializationUtils.h
index ea184107392..eb40fac56d4 100644
--- a/velox/serializers/PrestoSerializerSerializationUtils.h
+++ b/velox/serializers/PrestoSerializerSerializationUtils.h
@@ -60,8 +60,8 @@ void initBitsToMapOnce();
 FOLLY_ALWAYS_INLINE std::array<int8_t, ipaddress::kIPPrefixBytes>
 toJavaIPPrefixType(int128_t currentIpBytes, int8_t prefix) {
   std::array<int8_t, ipaddress::kIPPrefixBytes> byteArray{{0}};
-  memcpy(&byteArray, &currentIpBytes, sizeof(currentIpBytes));
-  memcpy((byteArray.begin() + sizeof(currentIpBytes)), &prefix, sizeof(prefix));
+  memcpy(&byteArray[0], &currentIpBytes, sizeof(currentIpBytes));
+  memcpy(&byteArray[sizeof(currentIpBytes)], &prefix, sizeof(prefix));
   if constexpr (folly::kIsLittleEndian) {
     std::reverse(byteArray.begin(), byteArray.begin() + sizeof(currentIpBytes));
     return byteArray;
diff --git a/velox/serializers/PrestoVectorLexer.cpp b/velox/serializers/PrestoVectorLexer.cpp
index 89bf2e4d2d4..a57dfb6ac39 100644
--- a/velox/serializers/PrestoVectorLexer.cpp
+++ b/velox/serializers/PrestoVectorLexer.cpp
@@ -248,7 +248,7 @@ PrestoVectorLexer::lexBytes(int32_t numBytes, TokenType tokenType, char* dst) {
 }
 
 void PrestoVectorLexer::commit(TokenType tokenType) {
-  const auto newPtr = source_.begin();
+  const auto* newPtr = source_.data();
   assert(committedPtr_ <= newPtr);
   assert(
       int64_t(newPtr - committedPtr_) <=
diff --git a/velox/serializers/PrestoVectorLexer.h b/velox/serializers/PrestoVectorLexer.h
index f00a4ebc857..c39b74d5017 100644
--- a/velox/serializers/PrestoVectorLexer.h
+++ b/velox/serializers/PrestoVectorLexer.h
@@ -50,7 +50,7 @@ namespace detail {
 class PrestoVectorLexer {
  public:
   explicit PrestoVectorLexer(std::string_view source)
-      : source_(source), committedPtr_(source.begin()) {}
+      : source_{source}, committedPtr_{source.data()} {}
 
   Status lex(std::vector<Token>& out) &&;
 
diff --git a/velox/serializers/RowSerializer.cpp b/velox/serializers/RowSerializer.cpp
index dc434ad5623..79b112b4621 100644
--- a/velox/serializers/RowSerializer.cpp
+++ b/velox/serializers/RowSerializer.cpp
@@ -85,7 +85,7 @@ bool RowIteratorImpl::hasNext() const {
   return source_->tellp() < endOffset_;
 }
 
-std::unique_ptr<std::string> RowIteratorImpl::next() {
+std::unique_ptr<std::string> RowIteratorImpl::nextRow() {
   const auto rowSize = readRowSize();
   auto serializedBuffer = std::make_unique<std::string>();
   serializedBuffer->reserve(rowSize);
diff --git a/velox/serializers/RowSerializer.h b/velox/serializers/RowSerializer.h
index 4ab11847cfb..376b9de8895 100644
--- a/velox/serializers/RowSerializer.h
+++ b/velox/serializers/RowSerializer.h
@@ -173,18 +173,18 @@ class RowSerializer : public IterativeVectorSerializer {
     std::unordered_map<std::string, RuntimeCounter> map;
     if (stats_.compressionInputBytes != 0) {
       map.emplace(
-          kCompressionInputBytes,
+          std::string(kCompressionInputBytes),
           RuntimeCounter(
               stats_.compressionInputBytes, RuntimeCounter::Unit::kBytes));
     }
     if (stats_.compressedBytes != 0) {
       map.emplace(
-          kCompressedBytes,
+          std::string(kCompressedBytes),
           RuntimeCounter(stats_.compressedBytes, RuntimeCounter::Unit::kBytes));
     }
     if (stats_.compressionSkippedBytes != 0) {
       map.emplace(
-          kCompressionSkippedBytes,
+          std::string(kCompressionSkippedBytes),
           RuntimeCounter(
               stats_.compressionSkippedBytes, RuntimeCounter::Unit::kBytes));
     }
@@ -265,7 +265,7 @@ class RowSerializer : public IterativeVectorSerializer {
 /// Usage:
 /// RowIteratorImpl iterator(source, endOffset);
 /// while (iterator.hasNext()) {
-///   auto next = iterator.next();
+///   auto next = iterator.nextRow();
 ///   ...Process the data in next...
 /// }
 class RowIteratorImpl : public velox::RowIterator {
@@ -281,7 +281,11 @@ class RowIteratorImpl : public velox::RowIterator {
 
   bool hasNext() const override;
 
-  std::unique_ptr<std::string> next() override;
+  std::unique_ptr<std::string> nextRow() override;
+
+  std::vector<std::string_view> nextBatch(size_t maxRows) override {
+    VELOX_UNSUPPORTED("nextBatch is not supported");
+  }
 
  private:
   TRowSize readRowSize();
@@ -301,9 +305,7 @@ class RowIteratorImpl : public velox::RowIterator {
 
 using RowIteratorFactory = std::function<std::unique_ptr<RowIterator>(
     ByteInputStream*,
-    std::unique_ptr<BufferInputStream>,
-    std::unique_ptr<folly::IOBuf>,
-    size_t)>;
+    const VectorSerde::Options*)>;
 
 template <typename SerializeView>
 class RowDeserializer {
@@ -312,17 +314,18 @@ class RowDeserializer {
       ByteInputStream* source,
       std::vector<SerializeView>& serializedRows,
       std::vector<std::unique_ptr<std::string>>& serializedBuffers,
-      RowIteratorFactory rowIteratorFactory,
+      const RowIteratorFactory& rowIteratorFactory,
       const VectorSerde::Options* options) {
     while (!source->atEnd()) {
       std::unique_ptr<velox::RowIterator> rowIterator =
-          createNextRowIter(source, options, rowIteratorFactory);
+          rowIteratorFactory(source, options);
       while (rowIterator->hasNext()) {
-        serializedBuffers.emplace_back(rowIterator->next());
+        serializedBuffers.emplace_back(rowIterator->nextRow());
         if constexpr (std::is_same_v<SerializeView, std::string_view>) {
-          serializedRows.push_back(std::string_view(
-              serializedBuffers.back()->data(),
-              serializedBuffers.back()->size()));
+          serializedRows.push_back(
+              std::string_view(
+                  serializedBuffers.back()->data(),
+                  serializedBuffers.back()->size()));
         } else {
           serializedRows.push_back(serializedBuffers.back()->data());
         }
@@ -344,21 +347,21 @@ class RowDeserializer {
       std::unique_ptr<velox::RowIterator>& sourceRowIterator,
       std::vector<SerializeView>& serializedRows,
       std::vector<std::unique_ptr<std::string>>& serializedBuffers,
-      RowIteratorFactory rowIteratorFactory,
+      const RowIteratorFactory& rowIteratorFactory,
       const VectorSerde::Options* options) {
     auto remainingRows = maxRows;
     if (sourceRowIterator == nullptr) {
       VELOX_CHECK(!source->atEnd());
-      sourceRowIterator =
-          createNextRowIter(source, options, rowIteratorFactory);
+      sourceRowIterator = rowIteratorFactory(source, options);
     }
     while (remainingRows > 0) {
       while (sourceRowIterator->hasNext()) {
-        serializedBuffers.emplace_back(sourceRowIterator->next());
+        serializedBuffers.emplace_back(sourceRowIterator->nextRow());
         if constexpr (std::is_same_v<SerializeView, std::string_view>) {
-          serializedRows.push_back(std::string_view(
-              serializedBuffers.back()->data(),
-              serializedBuffers.back()->size()));
+          serializedRows.push_back(
+              std::string_view(
+                  serializedBuffers.back()->data(),
+                  serializedBuffers.back()->size()));
         } else {
           serializedRows.push_back(serializedBuffers.back()->data());
         }
@@ -372,46 +375,10 @@ class RowDeserializer {
           sourceRowIterator.reset();
           break;
         }
-        sourceRowIterator =
-            createNextRowIter(source, options, rowIteratorFactory);
+        sourceRowIterator = rowIteratorFactory(source, options);
       }
     }
     return maxRows - remainingRows;
   }
-
- private:
-  static std::unique_ptr<velox::RowIterator> createNextRowIter(
-      ByteInputStream* source,
-      const VectorSerde::Options* options,
-      RowIteratorFactory& rowIteratorFactory) {
-    const auto header = detail::RowGroupHeader::read(source);
-    if (!header.compressed) {
-      return rowIteratorFactory(
-          source, nullptr, nullptr, header.uncompressedSize + source->tellp());
-    }
-
-    const auto compressionKind = options == nullptr
-        ? VectorSerde::Options().compressionKind
-        : options->compressionKind;
-    VELOX_DCHECK_NE(
-        compressionKind, common::CompressionKind::CompressionKind_NONE);
-    auto compressBuf = folly::IOBuf::create(header.compressedSize);
-    source->readBytes(compressBuf->writableData(), header.compressedSize);
-    compressBuf->append(header.compressedSize);
-
-    // Process chained uncompressed results IOBufs.
-    const auto codec = common::compressionKindToCodec(compressionKind);
-    auto uncompressedBuf =
-        codec->uncompress(compressBuf.get(), header.uncompressedSize);
-
-    auto uncompressedStream = std::make_unique<BufferInputStream>(
-        byteRangesFromIOBuf(uncompressedBuf.get()));
-    const std::streampos initialSize = uncompressedStream->tellp();
-    return rowIteratorFactory(
-        nullptr,
-        std::move(uncompressedStream),
-        std::move(uncompressedBuf),
-        header.uncompressedSize + initialSize);
-  }
 };
 } // namespace facebook::velox::serializer
diff --git a/velox/serializers/SerializedPageFile.cpp b/velox/serializers/SerializedPageFile.cpp
new file mode 100644
index 00000000000..6e6d3e9a540
--- /dev/null
+++ b/velox/serializers/SerializedPageFile.cpp
@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/serializers/SerializedPageFile.h"
+#include <cstdint>
+#include <memory>
+#include "velox/common/file/FileSystems.h"
+
+namespace facebook::velox::serializer {
+std::unique_ptr<SerializedPageFile> SerializedPageFile::create(
+    uint32_t id,
+    const std::string& pathPrefix,
+    const std::string& fileCreateConfig,
+    IoStats* ioStats) {
+  return std::unique_ptr<SerializedPageFile>(
+      new SerializedPageFile(id, pathPrefix, fileCreateConfig, ioStats));
+}
+
+SerializedPageFile::SerializedPageFile(
+    uint32_t id,
+    const std::string& pathPrefix,
+    const std::string& fileCreateConfig,
+    IoStats* ioStats)
+    : id_(id), path_(fmt::format("{}-{}", pathPrefix, ordinalCounter_++)) {
+  auto fs = filesystems::getFileSystem(path_, nullptr);
+  file_ = fs->openFileForWrite(
+      path_,
+      filesystems::FileOptions{
+          {{filesystems::FileOptions::kFileCreateConfig.toString(),
+            fileCreateConfig}},
+          nullptr,
+          std::nullopt,
+          false,
+          true,
+          true,
+          std::nullopt,
+          ioStats});
+}
+
+void SerializedPageFile::finish() {
+  VELOX_CHECK_NOT_NULL(file_);
+  size_ = file_->size();
+  file_->close();
+  file_ = nullptr;
+}
+
+uint64_t SerializedPageFile::size() {
+  if (file_ != nullptr) {
+    return file_->size();
+  }
+  return size_;
+}
+
+uint64_t SerializedPageFile::write(std::unique_ptr<folly::IOBuf> iobuf) {
+  auto writtenBytes = iobuf->computeChainDataLength();
+  file_->append(std::move(iobuf));
+  return writtenBytes;
+}
+
+SerializedPageFileWriter::SerializedPageFileWriter(
+    const std::string& pathPrefix,
+    uint64_t targetFileSize,
+    uint64_t writeBufferSize,
+    const std::string& fileCreateConfig,
+    std::unique_ptr<VectorSerde::Options> serdeOptions,
+    VectorSerde* serde,
+    memory::MemoryPool* pool,
+    IoStats* ioStats)
+    : pathPrefix_(pathPrefix),
+      targetFileSize_(targetFileSize),
+      writeBufferSize_(writeBufferSize),
+      fileCreateConfig_(fileCreateConfig),
+      serdeOptions_(std::move(serdeOptions)),
+      pool_(pool),
+      serde_(serde),
+      ioStats_(ioStats) {}
+
+SerializedPageFile* SerializedPageFileWriter::ensureFile() {
+  if ((currentFile_ != nullptr) && (currentFile_->size() > targetFileSize_)) {
+    closeFile();
+  }
+  if (currentFile_ == nullptr) {
+    currentFile_ = SerializedPageFile::create(
+        nextFileId_++,
+        fmt::format("{}-{}", pathPrefix_, finishedFiles_.size()),
+        fileCreateConfig_,
+        ioStats_);
+  }
+  return currentFile_.get();
+}
+
+void SerializedPageFileWriter::closeFile() {
+  if (currentFile_ == nullptr) {
+    return;
+  }
+  currentFile_->finish();
+  const auto& fileInfo = currentFile_->fileInfo();
+  updateFileStats(fileInfo);
+  finishedFiles_.push_back(fileInfo);
+  currentFile_.reset();
+}
+
+size_t SerializedPageFileWriter::numFinishedFiles() const {
+  return finishedFiles_.size();
+}
+
+uint64_t SerializedPageFileWriter::flush() {
+  if (batch_ == nullptr) {
+    return 0;
+  }
+
+  auto* file = ensureFile();
+  VELOX_CHECK_NOT_NULL(file);
+
+  IOBufOutputStream out(
+      *pool_, nullptr, std::max<int64_t>(64 * 1024, batch_->size()));
+  uint64_t flushTimeNs{0};
+  {
+    NanosecondTimer timer(&flushTimeNs);
+    batch_->flush(&out);
+  }
+  batch_.reset();
+
+  uint64_t writeTimeNs{0};
+  uint64_t writtenBytes{0};
+  auto iobuf = out.getIOBuf();
+  {
+    NanosecondTimer timer(&writeTimeNs);
+    writtenBytes = file->write(std::move(iobuf));
+  }
+  updateWriteStats(writtenBytes, flushTimeNs, writeTimeNs);
+  return writtenBytes;
+}
+
+uint64_t SerializedPageFileWriter::write(
+    const RowVectorPtr& rows,
+    const folly::Range<IndexRange*>& indices) {
+  if (rows == nullptr || rows->size() == 0 || indices.size() == 0) {
+    return 0;
+  }
+
+  checkNotFinished();
+
+  uint64_t timeNs{0};
+  {
+    NanosecondTimer timer(&timeNs);
+    if (batch_ == nullptr) {
+      batch_ = std::make_unique<VectorStreamGroup>(pool_, serde_);
+      batch_->createStreamTree(
+          std::static_pointer_cast<const RowType>(rows->type()),
+          1'000,
+          serdeOptions_.get());
+    }
+    batch_->append(rows, indices);
+  }
+  updateAppendStats(rows->size(), timeNs);
+  if (batch_->size() < writeBufferSize_) {
+    return 0;
+  }
+  return flush();
+}
+
+void SerializedPageFileWriter::finishFile() {
+  checkNotFinished();
+  flush();
+  closeFile();
+  VELOX_CHECK_NULL(currentFile_);
+}
+
+std::vector<SerializedPageFile::FileInfo> SerializedPageFileWriter::finish() {
+  checkNotFinished();
+  auto finishGuard = folly::makeGuard([this]() { finished_ = true; });
+
+  finishFile();
+  return std::move(finishedFiles_);
+}
+
+SerializedPageFileReader::SerializedPageFileReader(
+    const std::string& path,
+    uint64_t bufferSize,
+    const RowTypePtr& type,
+    VectorSerde* serde,
+    std::unique_ptr<VectorSerde::Options> readOptions,
+    memory::MemoryPool* pool,
+    IoStats* ioStats)
+    : readOptions_(std::move(readOptions)),
+      pool_(pool),
+      serde_(serde),
+      type_(type) {
+  auto fs = filesystems::getFileSystem(path, nullptr);
+  auto file =
+      fs->openFileForRead(path, filesystems::FileOptions{.stats = ioStats});
+  input_ = std::make_unique<common::FileInputStream>(
+      std::move(file), bufferSize, pool_);
+}
+
+bool SerializedPageFileReader::nextBatch(RowVectorPtr& rowVector) {
+  if (input_->atEnd()) {
+    updateFinalStats();
+    return false;
+  }
+
+  uint64_t timeNs{0};
+  {
+    NanosecondTimer timer{&timeNs};
+    VectorStreamGroup::read(
+        input_.get(), pool_, type_, serde_, &rowVector, readOptions_.get());
+  }
+  updateSerializationTimeStats(timeNs);
+  return true;
+}
+} // namespace facebook::velox::serializer
diff --git a/velox/serializers/SerializedPageFile.h b/velox/serializers/SerializedPageFile.h
new file mode 100644
index 00000000000..ac152f0ea30
--- /dev/null
+++ b/velox/serializers/SerializedPageFile.h
@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <folly/io/IOBuf.h>
+#include <cstdint>
+#include <memory>
+#include "velox/common/file/File.h"
+#include "velox/common/file/FileInputStream.h"
+#include "velox/serializers/VectorStream.h"
+
+namespace facebook::velox::serializer {
+
+/// Represents a file for writing the serialized pages into a disk file.
+class SerializedPageFile {
+ public:
+  /// FileInfo struct containing the essential file information.
+  struct FileInfo {
+    uint32_t id;
+    std::string path;
+    uint64_t size;
+  };
+
+  static std::unique_ptr<SerializedPageFile> create(
+      uint32_t id,
+      const std::string& pathPrefix,
+      const std::string& fileCreateConfig,
+      IoStats* ioStats);
+
+  uint32_t id() const {
+    return id_;
+  }
+
+  uint64_t size();
+
+  std::string path() const {
+    return path_;
+  }
+
+  FileInfo fileInfo() const {
+    return {id_, path_, (file_ != nullptr ? file_->size() : size_)};
+  }
+
+  uint64_t write(std::unique_ptr<folly::IOBuf> iobuf);
+
+  WriteFile* file() {
+    return file_.get();
+  }
+
+  /// Finishes writing and flushes any unwritten data.
+  void finish();
+
+ private:
+  static inline std::atomic_int32_t ordinalCounter_{0};
+
+  SerializedPageFile(
+      uint32_t id,
+      const std::string& pathPrefix,
+      const std::string& fileCreateConfig,
+      IoStats* ioStats);
+
+  const uint32_t id_;
+
+  const std::string path_;
+
+  uint64_t size_{0};
+
+  std::unique_ptr<WriteFile> file_;
+};
+
+/// Used to write 'RowVector' as serialized page data to a sequence of files.
+class SerializedPageFileWriter {
+ public:
+  /// 'compressionKind' specifies the compression to use. 'pathPrefix' is a
+  /// file path prefix. 'targetFileSize' is the target byte size of a single
+  /// file. 'writeBufferSize' specifies the size limit of the buffered data
+  /// before write to file. 'fileCreateConfig' specifies the file layout on
+  /// remote storage which is storage system specific. 'serdeOptions' specifies
+  /// the serialization options to use. 'serde' specifies the VectorSerde
+  /// instance to use. 'pool' is used for buffering. 'ioStats' is used
+  /// to collect filesystem I/O stats.
+  SerializedPageFileWriter(
+      const std::string& pathPrefix,
+      uint64_t targetFileSize,
+      uint64_t writeBufferSize,
+      const std::string& fileCreateConfig,
+      std::unique_ptr<VectorSerde::Options> serdeOptions,
+      VectorSerde* serde,
+      memory::MemoryPool* pool,
+      IoStats* ioStats);
+
+  // TODO(jtan6): Remove after other dependencies switch to the new ctor.
+  SerializedPageFileWriter(
+      const std::string& pathPrefix,
+      uint64_t targetFileSize,
+      uint64_t writeBufferSize,
+      const std::string& fileCreateConfig,
+      std::unique_ptr<VectorSerde::Options> serdeOptions,
+      VectorSerde* serde,
+      memory::MemoryPool* pool)
+      : SerializedPageFileWriter(
+            pathPrefix,
+            targetFileSize,
+            writeBufferSize,
+            fileCreateConfig,
+            std::move(serdeOptions),
+            serde,
+            pool,
+            nullptr) {}
+
+  virtual ~SerializedPageFileWriter() = default;
+
+  /// Adds 'rows' for the positions in 'indices' into 'this'.
+  /// Returns the size to write.
+  uint64_t write(
+      const RowVectorPtr& rows,
+      const folly::Range<IndexRange*>& indices);
+
+  /// Closes the current output file if any. Subsequent calls to write will
+  /// start a new one.
+  void finishFile();
+
+  /// Returns the number of current finished files.
+  size_t numFinishedFiles() const;
+
+  /// Finishes this file writer and returns the written file info.
+  /// NOTE: we don't allow write to a file writer after finish.
+  std::vector<SerializedPageFile::FileInfo> finish();
+
+ protected:
+  // Invoked upon each vector append.
+  virtual void updateAppendStats(
+      uint64_t /* numRows */,
+      uint64_t /* serializationTimeNs */) {}
+
+  // Invoked upon each serialized page write to disk.
+  virtual void updateWriteStats(
+      uint64_t /* writtenBytes */,
+      uint64_t /* flushTimeNs */,
+      uint64_t /* fileWriteTimeNs */) {}
+
+  // Invoked upon each file close.
+  virtual void updateFileStats(const SerializedPageFile::FileInfo& /* file */) {
+  }
+
+  // Closes the current open file pointed by 'currentFile_'.
+  virtual void closeFile();
+
+  // Writes data from 'batch_' to the current output file. Returns the actual
+  // written size.
+  virtual uint64_t flush();
+
+  FOLLY_ALWAYS_INLINE void checkNotFinished() const {
+    VELOX_CHECK(!finished_, "SerializedPageFileWriter has finished");
+  }
+
+  // Returns an open file for write. If there is no open file, then
+  // the function creates a new one. If the current open file exceeds the
+  // target file size limit, then it first closes the current one and then
+  // creates a new one. 'currentFile_' points to the current open file.
+  SerializedPageFile* ensureFile();
+
+  const std::string pathPrefix_;
+  const uint64_t targetFileSize_;
+  const uint64_t writeBufferSize_;
+  const std::string fileCreateConfig_;
+
+  const std::unique_ptr<VectorSerde::Options> serdeOptions_;
+  memory::MemoryPool* const pool_;
+  VectorSerde* const serde_;
+  IoStats* const ioStats_;
+
+  bool finished_{false};
+  uint32_t nextFileId_{0};
+  std::unique_ptr<VectorStreamGroup> batch_;
+  std::unique_ptr<SerializedPageFile> currentFile_;
+  std::vector<SerializedPageFile::FileInfo> finishedFiles_;
+};
+
+/// Used to read the serialized page data from a single file generated by
+/// 'SerializedPageFileWriter'.
+class SerializedPageFileReader {
+ public:
+  /// 'path' is the file path to read from. 'bufferSize' is the read buffer
+  /// size. 'type' is the row type of the data. 'serde' is the VectorSerde
+  /// instance to use. 'readOptions' specifies the deserialization options.
+  /// 'pool' is used for buffering. 'ioStats' is used to collect
+  /// filesystem I/O stats such as wsServiceTime.
+  SerializedPageFileReader(
+      const std::string& path,
+      uint64_t bufferSize,
+      const RowTypePtr& type,
+      VectorSerde* serde,
+      std::unique_ptr<VectorSerde::Options> readOptions,
+      memory::MemoryPool* pool,
+      IoStats* ioStats);
+
+  virtual ~SerializedPageFileReader() = default;
+
+  bool nextBatch(RowVectorPtr& rowVector);
+
+ protected:
+  virtual void updateFinalStats() {}
+
+  virtual void updateSerializationTimeStats(uint64_t /* timeNs */) {}
+
+  const std::unique_ptr<VectorSerde::Options> readOptions_;
+
+  memory::MemoryPool* const pool_;
+
+  VectorSerde* const serde_;
+
+  const RowTypePtr type_;
+
+  std::unique_ptr<common::FileInputStream> input_;
+};
+
+} // namespace facebook::velox::serializer
diff --git a/velox/serializers/UnsafeRowSerializer.cpp b/velox/serializers/UnsafeRowSerializer.cpp
index 36f952e8f1b..12eaf65005b 100644
--- a/velox/serializers/UnsafeRowSerializer.cpp
+++ b/velox/serializers/UnsafeRowSerializer.cpp
@@ -19,6 +19,39 @@
 #include "velox/serializers/RowSerializer.h"
 
 namespace facebook::velox::serializer::spark {
+namespace {
+std::unique_ptr<RowIterator> unsafeRowIteratorFactory(
+    ByteInputStream* source,
+    const VectorSerde::Options* options) {
+  const auto header = detail::RowGroupHeader::read(source);
+  if (!header.compressed) {
+    return std::make_unique<RowIteratorImpl>(
+        source, header.uncompressedSize + source->tellp());
+  }
+
+  const auto compressionKind = options == nullptr
+      ? VectorSerde::Options().compressionKind
+      : options->compressionKind;
+  VELOX_DCHECK_NE(
+      compressionKind, common::CompressionKind::CompressionKind_NONE);
+  auto compressBuf = folly::IOBuf::create(header.compressedSize);
+  source->readBytes(compressBuf->writableData(), header.compressedSize);
+  compressBuf->append(header.compressedSize);
+
+  // Process chained uncompressed results IOBufs.
+  const auto codec = common::compressionKindToCodec(compressionKind);
+  auto uncompressedBuf =
+      codec->uncompress(compressBuf.get(), header.uncompressedSize);
+
+  auto uncompressedStream = std::make_unique<BufferInputStream>(
+      byteRangesFromIOBuf(uncompressedBuf.get()));
+  const std::streampos initialSize = uncompressedStream->tellp();
+  return std::make_unique<RowIteratorImpl>(
+      std::move(uncompressedStream),
+      std::move(uncompressedBuf),
+      header.uncompressedSize + initialSize);
+}
+} // namespace
 
 void UnsafeRowVectorSerde::estimateSerializedSize(
     const row::UnsafeRowFast* unsafeRow,
@@ -49,23 +82,35 @@ void UnsafeRowVectorSerde::deserialize(
       source,
       serializedRows,
       serializedBuffers,
-      [](auto* source,
-         auto uncompressedStream,
-         auto uncompressedBuf,
-         auto endOffset) {
-        if (source != nullptr) {
-          VELOX_CHECK_NULL(uncompressedStream);
-          VELOX_CHECK_NULL(uncompressedBuf);
-          return std::make_unique<RowIteratorImpl>(source, endOffset);
-        } else {
-          VELOX_CHECK_NOT_NULL(uncompressedStream);
-          VELOX_CHECK_NOT_NULL(uncompressedBuf);
-          return std::make_unique<RowIteratorImpl>(
-              std::move(uncompressedStream),
-              std::move(uncompressedBuf),
-              endOffset);
-        }
-      },
+      unsafeRowIteratorFactory,
+      options);
+
+  if (serializedRows.empty()) {
+    *result = BaseVector::create<RowVector>(type, 0, pool);
+    return;
+  }
+
+  *result = std::dynamic_pointer_cast<RowVector>(
+      row::UnsafeRowFast::deserialize(serializedRows, type, pool));
+}
+
+void UnsafeRowVectorSerde::deserialize(
+    ByteInputStream* source,
+    std::unique_ptr<RowIterator>& sourceRowIterator,
+    uint64_t maxRows,
+    RowTypePtr type,
+    RowVectorPtr* result,
+    velox::memory::MemoryPool* pool,
+    const Options* options) {
+  std::vector<char*> serializedRows;
+  std::vector<std::unique_ptr<std::string>> serializedBuffers;
+  RowDeserializer<char*>::deserialize(
+      source,
+      maxRows,
+      sourceRowIterator,
+      serializedRows,
+      serializedBuffers,
+      unsafeRowIteratorFactory,
       options);
 
   if (serializedRows.empty()) {
@@ -85,7 +130,15 @@ void UnsafeRowVectorSerde::registerVectorSerde() {
 // static
 void UnsafeRowVectorSerde::registerNamedVectorSerde() {
   velox::registerNamedVectorSerde(
-      VectorSerde::Kind::kUnsafeRow, std::make_unique<UnsafeRowVectorSerde>());
+      kSerdeKind, std::make_unique<UnsafeRowVectorSerde>());
+}
+
+// static
+void UnsafeRowVectorSerde::tryRegisterNamedVectorSerde() {
+  if (!velox::isRegisteredNamedVectorSerde(kSerdeKind)) {
+    velox::registerNamedVectorSerde(
+        kSerdeKind, std::make_unique<UnsafeRowVectorSerde>());
+  }
 }
 
 } // namespace facebook::velox::serializer::spark
diff --git a/velox/serializers/UnsafeRowSerializer.h b/velox/serializers/UnsafeRowSerializer.h
index e859d8f2cc0..0062cfecdaf 100644
--- a/velox/serializers/UnsafeRowSerializer.h
+++ b/velox/serializers/UnsafeRowSerializer.h
@@ -21,7 +21,7 @@ namespace facebook::velox::serializer::spark {
 
 class UnsafeRowVectorSerde : public VectorSerde {
  public:
-  UnsafeRowVectorSerde() : VectorSerde(VectorSerde::Kind::kUnsafeRow) {}
+  UnsafeRowVectorSerde() : VectorSerde(kSerdeKind) {}
 
   void estimateSerializedSize(
       const row::UnsafeRowFast* unsafeRow,
@@ -44,7 +44,33 @@ class UnsafeRowVectorSerde : public VectorSerde {
       RowVectorPtr* result,
       const Options* options) override;
 
+  void deserialize(
+      ByteInputStream* source,
+      std::unique_ptr<RowIterator>& sourceRowIterator,
+      uint64_t maxRows,
+      RowTypePtr type,
+      RowVectorPtr* result,
+      velox::memory::MemoryPool* pool,
+      const Options* options = nullptr) override;
+
+  /// Registers this serde as the global default vector serde. Throws if a
+  /// default serde is already registered.
   static void registerVectorSerde();
+
+  /// Registers this serde in the named serde registry under kSerdeKind.
+  /// Throws if a serde with the same name is already registered.
   static void registerNamedVectorSerde();
+
+  /// Registers this serde in the named serde registry under kSerdeKind only
+  /// if not already registered. No-op if a serde with the same name exists.
+  static void tryRegisterNamedVectorSerde();
+
+  /// Returns the name of this serde kind.
+  static const std::string& name() {
+    return kSerdeKind;
+  }
+
+ private:
+  inline static const std::string kSerdeKind{"UnsafeRow"};
 };
 } // namespace facebook::velox::serializer::spark
diff --git a/velox/serializers/VectorStream.cpp b/velox/serializers/VectorStream.cpp
index 5ac9015c4d7..00bd6d718ed 100644
--- a/velox/serializers/VectorStream.cpp
+++ b/velox/serializers/VectorStream.cpp
@@ -342,6 +342,10 @@ void VectorStream::append(folly::Range<const Timestamp*> values) {
       appendOne(value.getSeconds());
       appendOne(value.getNanos());
     }
+  } else if (opts_.useMicrosecondPrecision) {
+    for (auto& value : values) {
+      appendOne(value.toMicros());
+    }
   } else {
     for (auto& value : values) {
       appendOne(value.toMillis());
diff --git a/velox/serializers/VectorStream.h b/velox/serializers/VectorStream.h
index 0d52dbbc15c..fe065f732a7 100644
--- a/velox/serializers/VectorStream.h
+++ b/velox/serializers/VectorStream.h
@@ -80,7 +80,8 @@ class VectorStream {
       VELOX_CHECK_EQ(header_.size, kHeaderSize);
     }
     header_.size = name.size() + sizeof(int32_t);
-    folly::storeUnaligned<int32_t>(header_.buffer, name.size());
+    folly::storeUnaligned<int32_t>(
+        header_.buffer, static_cast<int32_t>(name.size()));
     ::memcpy(header_.buffer + sizeof(int32_t), &name[0], name.size());
   }
 
diff --git a/velox/serializers/tests/CMakeLists.txt b/velox/serializers/tests/CMakeLists.txt
index b6a3e61b641..c81bf66d369 100644
--- a/velox/serializers/tests/CMakeLists.txt
+++ b/velox/serializers/tests/CMakeLists.txt
@@ -11,18 +11,41 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-add_executable(
-  velox_serializer_test
+add_executable(velox_key_encoder_test KeyDecoderTest.cpp KeyEncoderTest.cpp)
+
+add_test(
+  NAME velox_key_encoder_test
+  COMMAND velox_key_encoder_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+target_link_libraries(
+  velox_key_encoder_test
+  velox_exec
+  velox_exec_test_lib
+  velox_key_encoder
+  velox_functions_prestosql
+  velox_vector_fuzzer
+  velox_vector_test_lib
+  GTest::gtest
+  GTest::gtest_main
+  GTest::gmock
+)
+
+# Split velox_serializer_test into individual test binaries for parallel
+# execution.
+set(
+  VELOX_SERIALIZER_TEST_SOURCES
   CompactRowSerializerTest.cpp
   PrestoOutputStreamListenerTest.cpp
   PrestoSerializerTest.cpp
+  SerializedPageFileTest.cpp
   UnsafeRowSerializerTest.cpp
 )
 
-add_test(velox_serializer_test velox_serializer_test)
-
-target_link_libraries(
-  velox_serializer_test
+set(
+  VELOX_SERIALIZER_TEST_DEPS
+  velox_expression_test_utility
   velox_presto_serializer
   velox_vector_test_lib
   velox_vector_fuzzer
@@ -32,6 +55,12 @@ target_link_libraries(
   glog::glog
 )
 
+velox_add_grouped_tests(
+  PREFIX velox_serializer_test
+  SOURCES ${VELOX_SERIALIZER_TEST_SOURCES}
+  DEPS ${VELOX_SERIALIZER_TEST_DEPS}
+)
+
 if(VELOX_ENABLE_BENCHMARKS)
   add_executable(velox_serializer_benchmark SerializerBenchmark.cpp)
 
diff --git a/velox/serializers/tests/CompactRowSerializerTest.cpp b/velox/serializers/tests/CompactRowSerializerTest.cpp
index 5bcfae91c3d..2467ba0e343 100644
--- a/velox/serializers/tests/CompactRowSerializerTest.cpp
+++ b/velox/serializers/tests/CompactRowSerializerTest.cpp
@@ -67,13 +67,11 @@ class CompactRowSerializerTest : public ::testing::Test,
   void SetUp() override {
     pool_ = memory::memoryManager()->addLeafPool();
     deregisterVectorSerde();
-    deregisterNamedVectorSerde(VectorSerde::Kind::kCompactRow);
+    deregisterNamedVectorSerde("CompactRow");
     serializer::CompactRowVectorSerde::registerVectorSerde();
     serializer::CompactRowVectorSerde::registerNamedVectorSerde();
-    ASSERT_EQ(getVectorSerde()->kind(), VectorSerde::Kind::kCompactRow);
-    ASSERT_EQ(
-        getNamedVectorSerde(VectorSerde::Kind::kCompactRow)->kind(),
-        VectorSerde::Kind::kCompactRow);
+    ASSERT_EQ(getVectorSerde()->kind(), "CompactRow");
+    ASSERT_EQ(getNamedVectorSerde("CompactRow")->kind(), "CompactRow");
     appendRow_ = GetParam().appendRow;
     compressionKind_ = GetParam().compressionKind;
     microBatchDeserialize_ = GetParam().microBatchDeserialize;
@@ -82,7 +80,7 @@ class CompactRowSerializerTest : public ::testing::Test,
 
   void TearDown() override {
     deregisterVectorSerde();
-    deregisterNamedVectorSerde(VectorSerde::Kind::kCompactRow);
+    deregisterNamedVectorSerde("CompactRow");
   }
 
   void serialize(RowVectorPtr rowVector, std::ostream* output) {
@@ -325,6 +323,14 @@ TEST_P(CompactRowSerializerTest, fuzz) {
 VELOX_INSTANTIATE_TEST_SUITE_P(
     CompactRowSerializerTest,
     CompactRowSerializerTest,
-    testing::ValuesIn(CompactRowSerializerTest::getTestParams()));
+    testing::ValuesIn(CompactRowSerializerTest::getTestParams()),
+    [](const testing::TestParamInfo<TestParam>& info) {
+      return fmt::format(
+          "{}_{}_{}",
+          compressionKindToString(info.param.compressionKind),
+          info.param.appendRow ? "append" : "batch",
+          info.param.microBatchDeserialize ? "rowDeserialize"
+                                           : "batchDeserialize");
+    });
 } // namespace
 } // namespace facebook::velox::serializer
diff --git a/velox/serializers/tests/KeyDecoderTest.cpp b/velox/serializers/tests/KeyDecoderTest.cpp
new file mode 100644
index 00000000000..391e0b46a62
--- /dev/null
+++ b/velox/serializers/tests/KeyDecoderTest.cpp
@@ -0,0 +1,396 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/serializers/KeyDecoder.h"
+
+#include <cstring>
+#include <limits>
+
+#include <fmt/format.h>
+#include <gtest/gtest.h>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/serializers/KeyEncoder.h"
+#include "velox/type/Timestamp.h"
+#include "velox/type/Type.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+namespace facebook::velox::serializer::test {
+namespace {
+
+class KeyDecoderTest : public velox::exec::test::OperatorTestBase {
+ protected:
+  template <typename T>
+  static T& checkedReference(const std::unique_ptr<T>& pointer) {
+    VELOX_CHECK_NOT_NULL(pointer.get());
+    // @lint-ignore NULLSAFECLANG nullable-dereference
+    return *pointer;
+  }
+
+  RowVectorPtr encodeAndDecode(
+      const RowVectorPtr& input,
+      const std::vector<std::string>& keyColumns,
+      const std::vector<velox::core::SortOrder>& sortOrders) {
+    auto encoder = KeyEncoder::create(
+        keyColumns, asRowType(input->type()), sortOrders, pool_.get());
+    auto decoder = KeyDecoder::create(
+        keyColumns, asRowType(input->type()), sortOrders, pool_.get());
+    auto& keyEncoder = checkedReference(encoder);
+    auto& keyDecoder = checkedReference(decoder);
+
+    std::vector<char> buffer;
+    std::vector<std::string_view> encodedKeys;
+    keyEncoder.encode(input, encodedKeys, [&buffer](size_t size) -> void* {
+      buffer.resize(size);
+      return buffer.data();
+    });
+
+    return keyDecoder.decode(std::span<const std::string_view>(encodedKeys));
+  }
+
+  std::vector<std::string> encodeToStrings(
+      const RowVectorPtr& input,
+      const std::vector<std::string>& keyColumns,
+      const std::vector<velox::core::SortOrder>& sortOrders) {
+    auto encoder = KeyEncoder::create(
+        keyColumns, asRowType(input->type()), sortOrders, pool_.get());
+    auto& keyEncoder = checkedReference(encoder);
+
+    std::vector<char> buffer;
+    std::vector<std::string_view> encodedViews;
+    keyEncoder.encode(input, encodedViews, [&buffer](size_t size) -> void* {
+      buffer.resize(size);
+      return buffer.data();
+    });
+
+    std::vector<std::string> encodedKeys;
+    encodedKeys.reserve(encodedViews.size());
+    for (const auto encodedView : encodedViews) {
+      encodedKeys.emplace_back(encodedView.data(), encodedView.size());
+    }
+    return encodedKeys;
+  }
+
+  RowVectorPtr projectKeyColumns(
+      const RowVectorPtr& input,
+      const std::vector<std::string>& keyColumns) {
+    const auto inputType = asRowType(input->type());
+
+    std::vector<TypePtr> childTypes;
+    std::vector<VectorPtr> children;
+    childTypes.reserve(keyColumns.size());
+    children.reserve(keyColumns.size());
+
+    for (const auto& keyColumn : keyColumns) {
+      const auto channel = inputType->getChildIdx(keyColumn);
+      childTypes.push_back(inputType->childAt(channel));
+      children.push_back(input->childAt(channel));
+    }
+
+    return std::make_shared<RowVector>(
+        pool_.get(),
+        ROW(keyColumns, childTypes),
+        nullptr,
+        input->size(),
+        children);
+  }
+
+  std::vector<velox::core::SortOrder> repeatedSortOrders(
+      size_t count,
+      const velox::core::SortOrder& sortOrder) {
+    return std::vector<velox::core::SortOrder>(count, sortOrder);
+  }
+
+  static StringView stringView(std::string_view value) {
+    VELOX_CHECK_LE(
+        value.size(),
+        static_cast<size_t>(std::numeric_limits<int32_t>::max()),
+        "Test string exceeds StringView maximum length: {}",
+        value.size());
+    return StringView(value.data(), static_cast<int32_t>(value.size()));
+  }
+
+  static double bitsToDouble(uint64_t bits) {
+    double value;
+    std::memcpy(&value, &bits, sizeof(value));
+    return value;
+  }
+
+  static float bitsToFloat(uint32_t bits) {
+    float value;
+    std::memcpy(&value, &bits, sizeof(value));
+    return value;
+  }
+
+  static uint64_t doubleToBits(double value) {
+    uint64_t bits;
+    std::memcpy(&bits, &value, sizeof(bits));
+    return bits;
+  }
+
+  static uint32_t floatToBits(float value) {
+    uint32_t bits;
+    std::memcpy(&bits, &value, sizeof(bits));
+    return bits;
+  }
+};
+
+TEST_F(KeyDecoderTest, roundTripAllSupportedTypesWithoutNulls) {
+  const std::string varchar0("alpha");
+  const std::string varchar1({char(0), char(1), 'b', 'e', 't', 'a'});
+  const std::string varchar2("omega");
+
+  const std::string binary0({char(0), char(1), char(2)});
+  const std::string binary1({char(0xff), char(0), char(1)});
+  const std::string binary2("bin");
+
+  auto input = makeRowVector(
+      {makeFlatVector<int64_t>({-9, 0, 99}),
+       makeFlatVector<int32_t>({-1234, 0, 5678}),
+       makeFlatVector<int16_t>({-12, 0, 12}),
+       makeFlatVector<int8_t>({-5, 0, 5}),
+       makeFlatVector<double>({-12.5, 0.5, 42.25}),
+       makeFlatVector<float>({-3.5f, 0.25f, 7.75f}),
+       makeFlatVector<bool>({true, false, true}),
+       makeFlatVector<StringView>(
+           {stringView(varchar0), stringView(varchar1), stringView(varchar2)},
+           VARCHAR()),
+       makeFlatVector<StringView>(
+           {stringView(binary0), stringView(binary1), stringView(binary2)},
+           VARBINARY()),
+       makeFlatVector<Timestamp>(
+           {Timestamp(-100, 1), Timestamp(0, 0), Timestamp(123, 999'999'999)}),
+       makeFlatVector<int32_t>({-1, 0, 365}, DATE())});
+
+  const std::vector<std::string> keyColumns = {
+      "c8", "c0", "c10", "c7", "c3", "c9", "c1", "c6", "c2", "c4", "c5"};
+
+  const auto expected = projectKeyColumns(input, keyColumns);
+  for (const auto& sortOrder :
+       {velox::core::kAscNullsFirst,
+        velox::core::kAscNullsLast,
+        velox::core::kDescNullsFirst,
+        velox::core::kDescNullsLast}) {
+    SCOPED_TRACE(
+        fmt::format(
+            "sortOrder={}{}",
+            sortOrder.isAscending() ? "ASC" : "DESC",
+            sortOrder.isNullsFirst() ? "_NULLS_FIRST" : "_NULLS_LAST"));
+    const auto decoded = encodeAndDecode(
+        input, keyColumns, repeatedSortOrders(keyColumns.size(), sortOrder));
+    velox::test::assertEqualVectors(expected, decoded);
+  }
+}
+
+TEST_F(KeyDecoderTest, roundTripAllSupportedTypesWithNulls) {
+  const std::string varchar0("alpha");
+  const std::string varchar2({char(0), char(1), 't', 'a', 'i', 'l'});
+
+  const std::string binary0({char(0), char(1)});
+  const std::string binary2({char(0xfe), char(0xff)});
+
+  auto input = makeRowVector(
+      {makeNullableFlatVector<int64_t>({-9, std::nullopt, 99}),
+       makeNullableFlatVector<int32_t>({-1234, std::nullopt, 5678}),
+       makeNullableFlatVector<int16_t>({-12, std::nullopt, 12}),
+       makeNullableFlatVector<int8_t>({-5, std::nullopt, 5}),
+       makeNullableFlatVector<double>({-12.5, std::nullopt, 42.25}),
+       makeNullableFlatVector<float>({-3.5f, std::nullopt, 7.75f}),
+       makeNullableFlatVector<bool>({true, std::nullopt, false}),
+       makeNullableFlatVector<StringView>(
+           {stringView(varchar0), std::nullopt, stringView(varchar2)},
+           VARCHAR()),
+       makeNullableFlatVector<StringView>(
+           {stringView(binary0), std::nullopt, stringView(binary2)},
+           VARBINARY()),
+       makeNullableFlatVector<Timestamp>(
+           {Timestamp(-100, 1), std::nullopt, Timestamp(123, 999'999'999)}),
+       makeNullableFlatVector<int32_t>({-1, std::nullopt, 365}, DATE())});
+
+  const std::vector<std::string> keyColumns = {
+      "c9", "c7", "c1", "c10", "c3", "c8", "c0", "c6", "c2", "c4", "c5"};
+
+  const auto expected = projectKeyColumns(input, keyColumns);
+  for (const auto& sortOrder :
+       {velox::core::kAscNullsFirst,
+        velox::core::kAscNullsLast,
+        velox::core::kDescNullsFirst,
+        velox::core::kDescNullsLast}) {
+    SCOPED_TRACE(
+        fmt::format(
+            "sortOrder={}{}",
+            sortOrder.isAscending() ? "ASC" : "DESC",
+            sortOrder.isNullsFirst() ? "_NULLS_FIRST" : "_NULLS_LAST"));
+    const auto decoded = encodeAndDecode(
+        input, keyColumns, repeatedSortOrders(keyColumns.size(), sortOrder));
+    velox::test::assertEqualVectors(expected, decoded);
+  }
+}
+
+TEST_F(KeyDecoderTest, roundTripWithMixedSortOrders) {
+  auto input = makeRowVector(
+      {makeNullableFlatVector<int64_t>({7, 3, std::nullopt}),
+       makeNullableFlatVector<StringView>(
+           {stringView("a"), stringView("b"), std::nullopt}, VARCHAR()),
+       makeNullableFlatVector<Timestamp>(
+           {Timestamp(1, 10), Timestamp(2, 20), std::nullopt}),
+       makeNullableFlatVector<float>({1.5f, std::nullopt, -2.5f}),
+       makeNullableFlatVector<int32_t>({10, std::nullopt, -10}, DATE())});
+
+  const std::vector<std::string> keyColumns = {"c4", "c1", "c0", "c3", "c2"};
+  const std::vector<velox::core::SortOrder> sortOrders = {
+      velox::core::kDescNullsLast,
+      velox::core::kAscNullsFirst,
+      velox::core::kDescNullsFirst,
+      velox::core::kAscNullsLast,
+      velox::core::kDescNullsLast,
+  };
+
+  const auto decoded = encodeAndDecode(input, keyColumns, sortOrders);
+  const auto expected = projectKeyColumns(input, keyColumns);
+  velox::test::assertEqualVectors(expected, decoded);
+}
+
+TEST_F(KeyDecoderTest, fuzzRoundTripSupportedKeyTypes) {
+  const auto rowType =
+      ROW({"c0", "c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "c10"},
+          {BIGINT(),
+           INTEGER(),
+           SMALLINT(),
+           TINYINT(),
+           DOUBLE(),
+           REAL(),
+           BOOLEAN(),
+           VARCHAR(),
+           VARBINARY(),
+           TIMESTAMP(),
+           DATE()});
+
+  const std::vector<std::string> keyColumns = {
+      "c8", "c0", "c10", "c7", "c3", "c9", "c1", "c6", "c2", "c4", "c5"};
+  const std::vector<std::vector<velox::core::SortOrder>> sortOrderSets = {
+      repeatedSortOrders(keyColumns.size(), velox::core::kAscNullsFirst),
+      repeatedSortOrders(keyColumns.size(), velox::core::kAscNullsLast),
+      repeatedSortOrders(keyColumns.size(), velox::core::kDescNullsFirst),
+      repeatedSortOrders(keyColumns.size(), velox::core::kDescNullsLast),
+      {velox::core::kDescNullsLast,
+       velox::core::kAscNullsFirst,
+       velox::core::kDescNullsFirst,
+       velox::core::kAscNullsLast,
+       velox::core::kDescNullsLast,
+       velox::core::kAscNullsFirst,
+       velox::core::kDescNullsFirst,
+       velox::core::kAscNullsLast,
+       velox::core::kDescNullsLast,
+       velox::core::kAscNullsFirst,
+       velox::core::kDescNullsFirst},
+  };
+
+  VectorFuzzer::Options options;
+  options.vectorSize = 64;
+  options.nullRatio = 0.2;
+  options.stringLength = 32;
+  options.stringVariableLength = true;
+  options.timestampPrecision =
+      VectorFuzzer::Options::TimestampPrecision::kNanoSeconds;
+  VectorFuzzer fuzzer(options, pool_.get());
+
+  constexpr int32_t kNumIterations = 20;
+  for (int32_t iteration = 0; iteration < kNumIterations; ++iteration) {
+    SCOPED_TRACE(fmt::format("iteration={}", iteration));
+    const auto input = fuzzer.fuzzInputFlatRow(rowType);
+    const auto expected = projectKeyColumns(input, keyColumns);
+
+    for (size_t sortOrderIndex = 0; sortOrderIndex < sortOrderSets.size();
+         ++sortOrderIndex) {
+      SCOPED_TRACE(fmt::format("sortOrderIndex={}", sortOrderIndex));
+      const auto& sortOrders = sortOrderSets.at(sortOrderIndex);
+      const auto encodedKeys = encodeToStrings(input, keyColumns, sortOrders);
+      auto decoder =
+          KeyDecoder::create(keyColumns, rowType, sortOrders, pool_.get());
+      auto& keyDecoder = checkedReference(decoder);
+
+      const auto decoded =
+          keyDecoder.decode(std::span<const std::string>(encodedKeys));
+      velox::test::assertEqualVectors(expected, decoded);
+      EXPECT_EQ(encodedKeys, encodeToStrings(decoded, keyColumns, sortOrders));
+    }
+  }
+}
+
+TEST_F(KeyDecoderTest, floatingPointValuesAreCanonicalized) {
+  auto input = makeRowVector(
+      {makeFlatVector<double>(
+           {bitsToDouble(0x8000000000000000ULL),
+            bitsToDouble(0x7ff0000000000001ULL),
+            1.5}),
+       makeFlatVector<float>(
+           {bitsToFloat(0x80000000U), bitsToFloat(0x7f800001U), -2.5f})});
+
+  const auto decoded = encodeAndDecode(
+      input,
+      {"c0", "c1"},
+      {velox::core::kAscNullsFirst, velox::core::kAscNullsFirst});
+
+  const auto* doubleValues = decoded->childAt(0)->asFlatVector<double>();
+  const auto* floatValues = decoded->childAt(1)->asFlatVector<float>();
+
+  EXPECT_EQ(doubleToBits(doubleValues->valueAt(0)), 0);
+  EXPECT_EQ(floatToBits(floatValues->valueAt(0)), 0);
+
+  EXPECT_EQ(doubleToBits(doubleValues->valueAt(1)), 0x7ff8000000000000ULL);
+  EXPECT_EQ(floatToBits(floatValues->valueAt(1)), 0x7fc00000U);
+
+  EXPECT_EQ(doubleValues->valueAt(2), 1.5);
+  EXPECT_EQ(floatValues->valueAt(2), -2.5f);
+}
+
+TEST_F(KeyDecoderTest, malformedEncodedKeysThrow) {
+  auto decoder = KeyDecoder::create(
+      {"c0", "c1"},
+      ROW({"c0", "c1"}, {BIGINT(), VARCHAR()}),
+      {velox::core::kAscNullsFirst, velox::core::kAscNullsFirst},
+      pool_.get());
+  auto& keyDecoder = checkedReference(decoder);
+
+  {
+    const std::vector<std::string_view> encodedKeys = {
+        std::string_view("\x01\x80", 2)};
+    VELOX_ASSERT_THROW(
+        keyDecoder.decode(std::span<const std::string_view>(encodedKeys)),
+        "Malformed");
+  }
+
+  {
+    const std::vector<std::string_view> encodedKeys = {
+        std::string_view("\x01\x80\x00", 3)};
+    VELOX_ASSERT_THROW(
+        keyDecoder.decode(std::span<const std::string_view>(encodedKeys)),
+        "Malformed");
+  }
+
+  {
+    const std::vector<std::string_view> encodedKeys = {std::string_view(
+        "\x01\x80\x00\x00\x00\x00\x00\x00\x00\x01\x01\x02\x00", 13)};
+    VELOX_ASSERT_THROW(
+        keyDecoder.decode(std::span<const std::string_view>(encodedKeys)),
+        "invalid escaped string byte");
+  }
+}
+
+} // namespace
+} // namespace facebook::velox::serializer::test
diff --git a/velox/serializers/tests/KeyEncoderTest.cpp b/velox/serializers/tests/KeyEncoderTest.cpp
new file mode 100644
index 00000000000..5b3a58e22bf
--- /dev/null
+++ b/velox/serializers/tests/KeyEncoderTest.cpp
@@ -0,0 +1,10941 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/serializers/KeyEncoder.h"
+
+#include <fmt/ranges.h>
+#include <folly/init/Init.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <algorithm>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/core/PlanNode.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/type/Type.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+namespace facebook::velox::serializer::test {
+namespace {
+
+class KeyEncoderTest : public velox::exec::test::OperatorTestBase {
+ protected:
+  void SetUp() override {
+    OperatorTestBase::SetUp();
+  }
+
+  static int lexicographicalCompare(
+      const std::string& key1,
+      const std::string& key2) {
+    const auto begin1 = reinterpret_cast<const unsigned char*>(key1.data());
+    const auto end1 = begin1 + key1.size();
+    const auto begin2 = reinterpret_cast<const unsigned char*>(key2.data());
+    const auto end2 = begin2 + key2.size();
+    bool lessThan = std::lexicographical_compare(begin1, end1, begin2, end2);
+
+    bool equal = std::equal(begin1, end1, begin2, end2);
+
+    return lessThan ? -1 : (equal ? 0 : 1);
+  }
+
+  // Helper method to test a specific sort order
+  void encodeTestWithSortOrder(
+      const std::vector<velox::RowVectorPtr>& inputs,
+      const std::vector<std::string>& sortingKeys,
+      const velox::core::SortOrder& sortOrder) {
+    ASSERT_FALSE(inputs.empty());
+    const auto inputType = asRowType(inputs[0]->type());
+
+    // Build key column types string
+    std::vector<std::string> keyColumnTypes;
+    keyColumnTypes.reserve(sortingKeys.size());
+    for (const auto& key : sortingKeys) {
+      auto child = inputType->findChild(key);
+      if (child) {
+        keyColumnTypes.push_back(child->toString());
+      }
+    }
+
+    SCOPED_TRACE(
+        fmt::format(
+            "Sort order: {}, nullsFirst: {}, Key columns: [{}]",
+            sortOrder.isAscending() ? "ASC" : "DESC",
+            sortOrder.isNullsFirst(),
+            folly::join(", ", keyColumnTypes)));
+
+    // Create KeyEncoder - always create a new one for each test
+    auto keyEncoder = KeyEncoder::create(
+        sortingKeys,
+        inputType,
+        std::vector<velox::core::SortOrder>{sortingKeys.size(), sortOrder},
+        pool_.get());
+
+    for (const auto& input : inputs) {
+      // Encode the keys
+      std::vector<char> buffer;
+      std::vector<std::string_view> encodedKeys;
+      keyEncoder->encode(input, encodedKeys, [&buffer](size_t size) -> void* {
+        buffer.resize(size);
+        return buffer.data();
+      });
+
+      // Sort indices based on encoded keys (lexicographic comparison)
+      std::vector<velox::vector_size_t> encodedIndices(input->size());
+      std::iota(encodedIndices.begin(), encodedIndices.end(), 0);
+      std::sort(
+          encodedIndices.begin(),
+          encodedIndices.end(),
+          [&encodedKeys](velox::vector_size_t a, velox::vector_size_t b) {
+            return lexicographicalCompare(
+                       std::string(encodedKeys[a]),
+                       std::string(encodedKeys[b])) < 0;
+          });
+
+      // Build orderBy specification strings for all sorting keys
+      std::vector<std::string> orderBySpecs;
+      orderBySpecs.reserve(sortingKeys.size());
+      for (const auto& key : sortingKeys) {
+        std::string spec = key;
+        if (!sortOrder.isAscending()) {
+          spec += " DESC";
+        }
+        if (sortOrder.isNullsFirst()) {
+          spec += " NULLS FIRST";
+        } else {
+          spec += " NULLS LAST";
+        }
+        orderBySpecs.push_back(spec);
+      }
+
+      // Use AssertQueryBuilder to create Velox OrderBy plan
+      velox::exec::test::AssertQueryBuilder queryBuilder{
+          velox::exec::test::PlanBuilder()
+              .values({input})
+              .orderBy(orderBySpecs, /*isPartial=*/false)
+              .planNode(),
+          duckDbQueryRunner_};
+
+      // Execute the plan and get results
+      auto veloxResult = queryBuilder.copyResults(pool_.get());
+
+      // Compare results - reorder input based on encoded key sort order
+      auto encodedResult = velox::BaseVector::create(
+          inputType, encodedIndices.size(), pool_.get());
+      for (size_t i = 0; i < encodedIndices.size(); ++i) {
+        encodedResult->copy(input.get(), i, encodedIndices[i], 1);
+      }
+
+      // Verify both results match
+      velox::test::assertEqualVectors(encodedResult, veloxResult);
+    }
+  }
+
+  // Test method to validate KeyEncoder encoding against Velox OrderBy operator
+  // Tests all four sort orders: AscNullsFirst, AscNullsLast, DescNullsFirst,
+  // DescNullsLast
+  void encodeTest(
+      const std::vector<velox::RowVectorPtr>& inputs,
+      const std::vector<std::string>& sortingKeys) {
+    encodeTestWithSortOrder(inputs, sortingKeys, velox::core::kAscNullsFirst);
+    encodeTestWithSortOrder(inputs, sortingKeys, velox::core::kAscNullsLast);
+    encodeTestWithSortOrder(inputs, sortingKeys, velox::core::kDescNullsFirst);
+    encodeTestWithSortOrder(inputs, sortingKeys, velox::core::kDescNullsLast);
+  }
+
+  // Helper functions to create single-row RowVectors for index bound tests.
+  velox::RowVectorPtr makeIntRow(int32_t v) {
+    return makeRowVector({makeFlatVector<int32_t>({v})});
+  }
+
+  velox::RowVectorPtr makeIntRow(int32_t v1, int32_t v2) {
+    return makeRowVector(
+        {makeFlatVector<int32_t>({v1}), makeFlatVector<int32_t>({v2})});
+  }
+
+  velox::RowVectorPtr makeBigIntRow(int64_t v) {
+    return makeRowVector({makeFlatVector<int64_t>({v})});
+  }
+
+  velox::RowVectorPtr makeBigIntRow(int64_t v1, int64_t v2) {
+    return makeRowVector(
+        {makeFlatVector<int64_t>({v1}), makeFlatVector<int64_t>({v2})});
+  }
+
+  struct EncodeIndexBoundsTestCase {
+    std::vector<std::string> indexColumns;
+    std::optional<IndexBound> lowerBound;
+    std::optional<IndexBound> upperBound;
+    std::optional<velox::RowVectorPtr> expectedLowerBound;
+    std::optional<velox::RowVectorPtr> expectedUpperBound;
+    velox::core::SortOrder sortOrder = velox::core::kAscNullsFirst;
+    bool expectedFailure = false;
+
+    std::string debugString() const {
+      auto vectorToString = [](const velox::VectorPtr& vec) -> std::string {
+        if (vec->isNullAt(0)) {
+          return "null";
+        }
+
+        const auto typeKind = vec->typeKind();
+        switch (typeKind) {
+          case velox::TypeKind::BIGINT: {
+            const auto* flatVec = vec->as<velox::FlatVector<int64_t>>();
+            return std::to_string(flatVec->valueAt(0));
+          }
+          case velox::TypeKind::INTEGER: {
+            const auto* flatVec = vec->as<velox::FlatVector<int32_t>>();
+            return std::to_string(flatVec->valueAt(0));
+          }
+          case velox::TypeKind::SMALLINT: {
+            const auto* flatVec = vec->as<velox::FlatVector<int16_t>>();
+            return std::to_string(flatVec->valueAt(0));
+          }
+          case velox::TypeKind::TINYINT: {
+            const auto* flatVec = vec->as<velox::FlatVector<int8_t>>();
+            return std::to_string(static_cast<int>(flatVec->valueAt(0)));
+          }
+          case velox::TypeKind::DOUBLE: {
+            const auto* flatVec = vec->as<velox::FlatVector<double>>();
+            return std::to_string(flatVec->valueAt(0));
+          }
+          case velox::TypeKind::REAL: {
+            const auto* flatVec = vec->as<velox::FlatVector<float>>();
+            return std::to_string(flatVec->valueAt(0));
+          }
+          case velox::TypeKind::BOOLEAN: {
+            const auto* flatVec = vec->as<velox::FlatVector<bool>>();
+            return flatVec->valueAt(0) ? "true" : "false";
+          }
+          case velox::TypeKind::VARCHAR:
+          case velox::TypeKind::VARBINARY: {
+            const auto* flatVec =
+                vec->as<velox::FlatVector<velox::StringView>>();
+            return flatVec->valueAt(0).str();
+          }
+          case velox::TypeKind::TIMESTAMP: {
+            const auto* flatVec =
+                vec->as<velox::FlatVector<velox::Timestamp>>();
+            return flatVec->valueAt(0).toString();
+          }
+          default:
+            return fmt::format(
+                "<unknown type: {}>", static_cast<int>(typeKind));
+        }
+      };
+
+      std::vector<std::string> parts;
+
+      parts.push_back(
+          fmt::format("columns=[{}]", folly::join(", ", indexColumns)));
+
+      // Add sort order information
+      std::string soStr = sortOrder.isAscending() ? "ASC" : "DESC";
+      soStr += sortOrder.isNullsFirst() ? "_NULLS_FIRST" : "_NULLS_LAST";
+      parts.push_back(fmt::format("sortOrder={}", soStr));
+
+      if (lowerBound.has_value()) {
+        const auto& bound = lowerBound.value();
+        std::vector<std::string> values;
+        values.reserve(bound.bound->childrenSize());
+        for (size_t i = 0; i < bound.bound->childrenSize(); ++i) {
+          values.emplace_back(vectorToString(bound.bound->childAt(i)));
+        }
+        parts.push_back(
+            fmt::format(
+                "lower={}[{}]",
+                bound.inclusive ? ">=" : ">",
+                folly::join(", ", values)));
+      } else {
+        parts.emplace_back("lower=null");
+      }
+
+      if (upperBound.has_value()) {
+        const auto& bound = upperBound.value();
+        std::vector<std::string> values;
+        values.reserve(bound.bound->childrenSize());
+        for (size_t i = 0; i < bound.bound->childrenSize(); ++i) {
+          values.push_back(vectorToString(bound.bound->childAt(i)));
+        }
+        parts.push_back(
+            fmt::format(
+                "upper={}[{}]",
+                bound.inclusive ? "<=" : "<",
+                folly::join(", ", values)));
+      } else {
+        parts.emplace_back("upper=null");
+      }
+
+      if (expectedLowerBound.has_value()) {
+        const auto& bound = expectedLowerBound.value();
+        std::vector<std::string> values;
+        values.reserve(bound->childrenSize());
+        for (size_t i = 0; i < bound->childrenSize(); ++i) {
+          values.push_back(vectorToString(bound->childAt(i)));
+        }
+        parts.push_back(
+            fmt::format("expected_lower=[{}]", folly::join(", ", values)));
+      } else {
+        parts.emplace_back("expected_lower=null");
+      }
+
+      if (expectedUpperBound.has_value()) {
+        const auto& bound = expectedUpperBound.value();
+        std::vector<std::string> values;
+        values.reserve(bound->childrenSize());
+        for (size_t i = 0; i < bound->childrenSize(); ++i) {
+          values.push_back(vectorToString(bound->childAt(i)));
+        }
+        parts.push_back(
+            fmt::format("expected_upper=[{}]", folly::join(", ", values)));
+      } else {
+        parts.emplace_back("expected_upper=null");
+      }
+
+      return folly::join(", ", parts);
+    }
+  };
+
+  // Test method to validate KeyEncoder encodeIndexBounds against expected
+  // encoded bounds
+  void testIndexBounds(const EncodeIndexBoundsTestCase& testCase) {
+    IndexBounds indexBounds;
+    indexBounds.indexColumns = testCase.indexColumns;
+    indexBounds.lowerBound = testCase.lowerBound;
+    indexBounds.upperBound = testCase.upperBound;
+
+    ASSERT_TRUE(indexBounds.validate());
+
+    const auto inputType = asRowType(indexBounds.type());
+    const std::vector<velox::core::SortOrder> sortOrders(
+        testCase.indexColumns.size(), testCase.sortOrder);
+    auto keyEncoder = KeyEncoder::create(
+        indexBounds.indexColumns, inputType, sortOrders, pool_.get());
+
+    if (testCase.expectedFailure) {
+      // For lower bound bump failures, expect exception to be thrown.
+      VELOX_ASSERT_THROW(
+          keyEncoder->encodeIndexBounds(indexBounds),
+          "Failed to bump up lower bound");
+      return;
+    }
+
+    const auto encodedBounds = keyEncoder->encodeIndexBounds(indexBounds);
+
+    ASSERT_EQ(encodedBounds.size(), 1);
+
+    const auto& result = encodedBounds[0];
+
+    // Verify presence of keys matches expectations
+    EXPECT_EQ(
+        result.lowerKey.has_value(), testCase.expectedLowerBound.has_value());
+    EXPECT_EQ(
+        result.upperKey.has_value(), testCase.expectedUpperBound.has_value());
+
+    // Encode expected bounds and verify they match
+    if (testCase.expectedLowerBound.has_value()) {
+      ASSERT_TRUE(result.lowerKey.has_value());
+      std::vector<char> expectedBuffer;
+      std::vector<std::string_view> expectedKeys;
+      keyEncoder->encode(
+          testCase.expectedLowerBound.value(),
+          expectedKeys,
+          [&expectedBuffer](size_t size) -> void* {
+            expectedBuffer.resize(size);
+            return expectedBuffer.data();
+          });
+      EXPECT_EQ(expectedKeys.size(), 1);
+      EXPECT_EQ(result.lowerKey.value(), std::string(expectedKeys[0]));
+    }
+
+    if (testCase.expectedUpperBound.has_value()) {
+      ASSERT_TRUE(result.upperKey.has_value());
+      std::vector<char> expectedBuffer;
+      std::vector<std::string_view> expectedKeys;
+      keyEncoder->encode(
+          testCase.expectedUpperBound.value(),
+          expectedKeys,
+          [&expectedBuffer](size_t size) -> void* {
+            expectedBuffer.resize(size);
+            return expectedBuffer.data();
+          });
+      EXPECT_EQ(expectedKeys.size(), 1);
+      EXPECT_EQ(result.upperKey.value(), std::string(expectedKeys[0]));
+    }
+  }
+
+  // Helper method to create test cases for all sort orders with sort
+  // order-specific expected values
+  std::vector<EncodeIndexBoundsTestCase> createIndexBoundEncodeTestCases(
+      const std::vector<std::string>& indexColumns,
+      const std::optional<IndexBound>& lowerBound,
+      const std::optional<IndexBound>& upperBound,
+      const std::optional<velox::RowVectorPtr>& ascNullsFirstExpectedLowerBound,
+      const std::optional<velox::RowVectorPtr>& ascNullsFirstExpectedUpperBound,
+      const std::optional<velox::RowVectorPtr>& ascNullsLastExpectedLowerBound,
+      const std::optional<velox::RowVectorPtr>& ascNullsLastExpectedUpperBound,
+      const std::optional<velox::RowVectorPtr>&
+          descNullsFirstExpectedLowerBound,
+      const std::optional<velox::RowVectorPtr>&
+          descNullsFirstExpectedUpperBound,
+      const std::optional<velox::RowVectorPtr>& descNullsLastExpectedLowerBound,
+      const std::optional<velox::RowVectorPtr>&
+          descNullsLastExpectedUpperBound) {
+    const std::vector<velox::core::SortOrder> sortOrders = {
+        velox::core::kAscNullsFirst,
+        velox::core::kAscNullsLast,
+        velox::core::kDescNullsFirst,
+        velox::core::kDescNullsLast,
+    };
+
+    std::vector<EncodeIndexBoundsTestCase> testCases;
+    testCases.reserve(sortOrders.size());
+
+    for (const auto& sortOrder : sortOrders) {
+      std::optional<velox::RowVectorPtr> expectedLowerBound;
+      std::optional<velox::RowVectorPtr> expectedUpperBound;
+
+      if (sortOrder.isAscending() && sortOrder.isNullsFirst()) {
+        expectedLowerBound = ascNullsFirstExpectedLowerBound;
+        expectedUpperBound = ascNullsFirstExpectedUpperBound;
+      } else if (sortOrder.isAscending() && !sortOrder.isNullsFirst()) {
+        expectedLowerBound = ascNullsLastExpectedLowerBound;
+        expectedUpperBound = ascNullsLastExpectedUpperBound;
+      } else if (!sortOrder.isAscending() && sortOrder.isNullsFirst()) {
+        expectedLowerBound = descNullsFirstExpectedLowerBound;
+        expectedUpperBound = descNullsFirstExpectedUpperBound;
+      } else { // DESC NULLS_LAST
+        expectedLowerBound = descNullsLastExpectedLowerBound;
+        expectedUpperBound = descNullsLastExpectedUpperBound;
+      }
+
+      testCases.push_back({
+          .indexColumns = indexColumns,
+          .lowerBound = lowerBound,
+          .upperBound = upperBound,
+          .expectedLowerBound = expectedLowerBound,
+          .expectedUpperBound = expectedUpperBound,
+          .sortOrder = sortOrder,
+      });
+    }
+
+    return testCases;
+  }
+
+  void runIndexBoundTests(
+      const std::vector<std::string>& indexColumns,
+      const std::optional<IndexBound>& lowerBound,
+      const std::optional<IndexBound>& upperBound,
+      const std::optional<velox::RowVectorPtr>& ascNullsFirstExpectedLowerBound,
+      const std::optional<velox::RowVectorPtr>& ascNullsFirstExpectedUpperBound,
+      const std::optional<velox::RowVectorPtr>& ascNullsLastExpectedLowerBound,
+      const std::optional<velox::RowVectorPtr>& ascNullsLastExpectedUpperBound,
+      const std::optional<velox::RowVectorPtr>&
+          descNullsFirstExpectedLowerBound,
+      const std::optional<velox::RowVectorPtr>&
+          descNullsFirstExpectedUpperBound,
+      const std::optional<velox::RowVectorPtr>& descNullsLastExpectedLowerBound,
+      const std::optional<velox::RowVectorPtr>&
+          descNullsLastExpectedUpperBound) {
+    auto testCases = createIndexBoundEncodeTestCases(
+        indexColumns,
+        lowerBound,
+        upperBound,
+        ascNullsFirstExpectedLowerBound,
+        ascNullsFirstExpectedUpperBound,
+        ascNullsLastExpectedLowerBound,
+        ascNullsLastExpectedUpperBound,
+        descNullsFirstExpectedLowerBound,
+        descNullsFirstExpectedUpperBound,
+        descNullsLastExpectedLowerBound,
+        descNullsLastExpectedUpperBound);
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+};
+} // namespace
+
+TEST_F(KeyEncoderTest, indexBounds) {
+  const auto boundRow = makeRowVector({makeNullableFlatVector<int32_t>({2})});
+  // Test valid bounds with lower bound.
+  IndexBounds boundsWithLower;
+  boundsWithLower.indexColumns = {"c0"};
+  boundsWithLower.lowerBound = IndexBound{boundRow, true};
+  EXPECT_TRUE(boundsWithLower.validate());
+  EXPECT_EQ(
+      boundsWithLower.toString(),
+      "IndexBounds{indexColumns=[c0], lowerBound=[0: {2}], upperBound=unbounded}");
+  EXPECT_EQ(boundsWithLower.type()->toString(), boundRow->type()->toString());
+  EXPECT_EQ(boundsWithLower.numRows(), 1);
+
+  // Test valid bounds with upper bound.
+  IndexBounds boundsWithUpper;
+  boundsWithUpper.indexColumns = {"c0"};
+  boundsWithUpper.upperBound = IndexBound{boundRow, false};
+  EXPECT_TRUE(boundsWithUpper.validate());
+  EXPECT_EQ(
+      boundsWithUpper.toString(),
+      "IndexBounds{indexColumns=[c0], lowerBound=unbounded, upperBound=(0: {2})}");
+  EXPECT_EQ(boundsWithUpper.numRows(), 1);
+
+  // Test valid bounds with both.
+  IndexBounds boundsWithBoth;
+  boundsWithBoth.indexColumns = {"c0"};
+  boundsWithBoth.lowerBound = IndexBound{boundRow, true};
+  boundsWithBoth.upperBound = IndexBound{boundRow, false};
+  EXPECT_TRUE(boundsWithBoth.validate());
+  EXPECT_EQ(
+      boundsWithBoth.toString(),
+      "IndexBounds{indexColumns=[c0], lowerBound=[0: {2}], upperBound=(0: {2})}");
+
+  // Test invalid bounds with no bounds.
+  IndexBounds noBounds;
+  noBounds.indexColumns = {"c0"};
+  EXPECT_FALSE(noBounds.validate());
+
+  // Test multi-row bounds (valid with multi-row support).
+  auto twoRowBound =
+      makeRowVector({makeNullableFlatVector<int32_t>({2, std::nullopt})});
+  IndexBounds twoRowBounds;
+  twoRowBounds.indexColumns = {"c0"};
+  twoRowBounds.lowerBound = IndexBound{twoRowBound, true};
+  EXPECT_TRUE(twoRowBounds.validate());
+  EXPECT_EQ(twoRowBounds.numRows(), 2);
+
+  // Test invalid bounds with extra index columns.
+  IndexBounds extraColBounds;
+  extraColBounds.indexColumns = {"c0", "c1", "c2"};
+  extraColBounds.lowerBound = IndexBound{boundRow, true};
+  EXPECT_FALSE(extraColBounds.validate());
+
+  extraColBounds.lowerBound = std::nullopt;
+  extraColBounds.upperBound = IndexBound{boundRow, true};
+  EXPECT_FALSE(extraColBounds.validate());
+
+  const auto multiColumnBoundRow = makeRowVector(
+      {makeNullableFlatVector<int32_t>({2}),
+       makeNullableFlatVector<int32_t>({1})});
+  IndexBounds multiColumnBounds;
+  multiColumnBounds.indexColumns = {"c0", "c1"};
+  multiColumnBounds.lowerBound = IndexBound{multiColumnBoundRow, true};
+  multiColumnBounds.upperBound = IndexBound{multiColumnBoundRow, false};
+  EXPECT_TRUE(multiColumnBounds.validate());
+  EXPECT_EQ(
+      multiColumnBounds.toString(),
+      "IndexBounds{indexColumns=[c0, c1], lowerBound=[0: {2, 1}], upperBound=(0: {2, 1})}");
+
+  IndexBounds missingColBounds;
+  missingColBounds.indexColumns = {"c0"};
+  missingColBounds.upperBound = IndexBound{multiColumnBoundRow, false};
+  EXPECT_FALSE(missingColBounds.validate());
+
+  // Test set() and clear() methods.
+  const auto lowerRow = makeRowVector({makeNullableFlatVector<int32_t>({10})});
+  const auto upperRow = makeRowVector({makeNullableFlatVector<int32_t>({20})});
+
+  IndexBounds bounds;
+  bounds.indexColumns = {"c0"};
+  EXPECT_FALSE(bounds.validate());
+
+  bounds.set(IndexBound{lowerRow, true}, IndexBound{upperRow, false});
+  EXPECT_TRUE(bounds.validate());
+  EXPECT_TRUE(bounds.lowerBound.has_value());
+  EXPECT_TRUE(bounds.upperBound.has_value());
+  EXPECT_TRUE(bounds.lowerBound->inclusive);
+  EXPECT_FALSE(bounds.upperBound->inclusive);
+  EXPECT_EQ(bounds.numRows(), 1);
+  EXPECT_EQ(
+      bounds.toString(),
+      "IndexBounds{indexColumns=[c0], lowerBound=[0: {10}], upperBound=(0: {20})}");
+
+  bounds.clear();
+  EXPECT_FALSE(bounds.lowerBound.has_value());
+  EXPECT_FALSE(bounds.upperBound.has_value());
+  EXPECT_FALSE(bounds.validate());
+
+  bounds.set(IndexBound{upperRow, false}, IndexBound{lowerRow, true});
+  EXPECT_TRUE(bounds.validate());
+  EXPECT_EQ(bounds.numRows(), 1);
+
+  // Test numRows() with multiple row bounds.
+  const auto multipleRows =
+      makeRowVector({makeNullableFlatVector<int32_t>({1, 2, 3})});
+  IndexBounds multiRowBounds;
+  multiRowBounds.indexColumns = {"c0"};
+  multiRowBounds.lowerBound = IndexBound{multipleRows, true};
+  EXPECT_EQ(multiRowBounds.numRows(), 3);
+
+  IndexBounds multiRowBothBounds;
+  multiRowBothBounds.indexColumns = {"c0"};
+  multiRowBothBounds.lowerBound = IndexBound{multipleRows, true};
+  multiRowBothBounds.upperBound = IndexBound{multipleRows, false};
+  EXPECT_EQ(multiRowBothBounds.numRows(), 3);
+
+  // Test invalid bounds with empty bound.
+  const auto emptyRows = makeRowVector({makeFlatVector<int32_t>({})});
+  IndexBounds emptyLowerBounds;
+  emptyLowerBounds.indexColumns = {"c0"};
+  emptyLowerBounds.lowerBound = IndexBound{emptyRows, true};
+  EXPECT_FALSE(emptyLowerBounds.validate());
+}
+
+TEST_F(KeyEncoderTest, indexBoundsType) {
+  struct TestCase {
+    std::string name;
+    std::vector<std::string> indexColumns;
+    std::optional<RowVectorPtr> lowerBoundRow;
+    std::optional<RowVectorPtr> upperBoundRow;
+    bool lowerInclusive;
+    bool upperInclusive;
+    // Expected type is always the type from lowerBoundRow if present,
+    // otherwise from upperBoundRow
+  };
+
+  std::vector<TestCase> testCases = {
+      // Lower bound only - single column
+      {
+          .name = "lower_bound_only_single_column",
+          .indexColumns = {"key"},
+          .lowerBoundRow =
+              makeRowVector({"key"}, {makeNullableFlatVector<int32_t>({42})}),
+          .upperBoundRow = std::nullopt,
+          .lowerInclusive = true,
+          .upperInclusive = false,
+      },
+      // Upper bound only - single column
+      {
+          .name = "upper_bound_only_single_column",
+          .indexColumns = {"key"},
+          .lowerBoundRow = std::nullopt,
+          .upperBoundRow =
+              makeRowVector({"key"}, {makeNullableFlatVector<int64_t>({100})}),
+          .lowerInclusive = false,
+          .upperInclusive = true,
+      },
+      // Both bounds - single column
+      {
+          .name = "both_bounds_single_column",
+          .indexColumns = {"col"},
+          .lowerBoundRow =
+              makeRowVector({"col"}, {makeNullableFlatVector<double>({1.5})}),
+          .upperBoundRow =
+              makeRowVector({"col"}, {makeNullableFlatVector<double>({10.5})}),
+          .lowerInclusive = true,
+          .upperInclusive = false,
+      },
+      // Lower bound only - multi column
+      {
+          .name = "lower_bound_only_multi_column",
+          .indexColumns = {"col1", "col2"},
+          .lowerBoundRow = makeRowVector(
+              {"col1", "col2"},
+              {makeNullableFlatVector<int64_t>({100}),
+               makeNullableFlatVector<std::string>({"test"})}),
+          .upperBoundRow = std::nullopt,
+          .lowerInclusive = true,
+          .upperInclusive = false,
+      },
+      // Upper bound only - multi column
+      {
+          .name = "upper_bound_only_multi_column",
+          .indexColumns = {"a", "b", "c"},
+          .lowerBoundRow = std::nullopt,
+          .upperBoundRow = makeRowVector(
+              {"a", "b", "c"},
+              {makeNullableFlatVector<int32_t>({1}),
+               makeNullableFlatVector<int32_t>({2}),
+               makeNullableFlatVector<int32_t>({3})}),
+          .lowerInclusive = false,
+          .upperInclusive = true,
+      },
+      // Both bounds - multi column
+      {
+          .name = "both_bounds_multi_column",
+          .indexColumns = {"x", "y"},
+          .lowerBoundRow = makeRowVector(
+              {"x", "y"},
+              {makeNullableFlatVector<bool>({true}),
+               makeNullableFlatVector<float>({1.0f})}),
+          .upperBoundRow = makeRowVector(
+              {"x", "y"},
+              {makeNullableFlatVector<bool>({false}),
+               makeNullableFlatVector<float>({9.0f})}),
+          .lowerInclusive = false,
+          .upperInclusive = false,
+      },
+      // Timestamp type
+      {
+          .name = "timestamp_type",
+          .indexColumns = {"ts"},
+          .lowerBoundRow = makeRowVector(
+              {"ts"},
+              {makeNullableFlatVector<Timestamp>({Timestamp(1000, 500)})}),
+          .upperBoundRow = std::nullopt,
+          .lowerInclusive = true,
+          .upperInclusive = false,
+      },
+      // VARCHAR type
+      {
+          .name = "varchar_type",
+          .indexColumns = {"name"},
+          .lowerBoundRow = std::nullopt,
+          .upperBoundRow = makeRowVector(
+              {"name"}, {makeNullableFlatVector<std::string>({"hello"})}),
+          .lowerInclusive = false,
+          .upperInclusive = true,
+      },
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.name);
+
+    IndexBounds bounds;
+    bounds.indexColumns = testCase.indexColumns;
+    if (testCase.lowerBoundRow.has_value()) {
+      bounds.lowerBound =
+          IndexBound{testCase.lowerBoundRow.value(), testCase.lowerInclusive};
+    }
+    if (testCase.upperBoundRow.has_value()) {
+      bounds.upperBound =
+          IndexBound{testCase.upperBoundRow.value(), testCase.upperInclusive};
+    }
+
+    ASSERT_TRUE(bounds.validate());
+
+    const auto type = bounds.type();
+    ASSERT_NE(type, nullptr);
+    EXPECT_EQ(type->kind(), TypeKind::ROW);
+
+    // type() should return lowerBound's type when present, otherwise
+    // upperBound's type
+    const auto& expectedRow = testCase.lowerBoundRow.has_value()
+        ? testCase.lowerBoundRow.value()
+        : testCase.upperBoundRow.value();
+    EXPECT_TRUE(type->equivalent(*expectedRow->type()));
+
+    const auto rowType = asRowType(type);
+    EXPECT_EQ(rowType->size(), testCase.indexColumns.size());
+    for (size_t i = 0; i < testCase.indexColumns.size(); ++i) {
+      EXPECT_EQ(rowType->nameOf(i), testCase.indexColumns[i]);
+      EXPECT_EQ(
+          rowType->childAt(i)->kind(), expectedRow->childAt(i)->type()->kind());
+    }
+  }
+}
+
+TEST_F(KeyEncoderTest, longTypeWithoutNulls) {
+  struct {
+    std::vector<std::vector<int64_t>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<int64_t> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          rowValues.push_back(column[row]);
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row
+      {{{1}, {2}, {3}}},
+      // All same values
+      {{{5, 5, 5}, {10, 10, 10}, {15, 15, 15}}},
+      // Ascending order in first column
+      {{{1, 2, 3, 4}, {100, 100, 100, 100}, {50, 50, 50, 50}}},
+      // Descending order in first column
+      {{{10, 9, 8, 7}, {0, 0, 0, 0}, {5, 5, 5, 5}}},
+      // Mixed positive and negative values
+      {{{-5, 0, 5}, {-10, -5, 0}, {10, 5, 0}}},
+      // Edge values: min and max int64_t
+      {{{std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::max(),
+         0},
+        {-1, 0, 1},
+        {100, 200, 300}}},
+      // All zeros
+      {{{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}},
+      // Duplicate values across rows
+      {{{1, 2, 1, 2}, {3, 3, 4, 4}, {5, 5, 5, 5}}},
+      // Large spread of values
+      {{{-1000000, -1, 0, 1, 1000000},
+        {999999, 500000, 0, -500000, -999999},
+        {42, 42, 42, 42, 42}}},
+      // Values that differ only in last column
+      {{{1, 1, 1}, {2, 2, 2}, {3, 4, 5}}},
+      // Values that differ only in first column
+      {{{1, 2, 3}, {100, 100, 100}, {200, 200, 200}}},
+      // Alternating pattern
+      {{{1, -1, 1, -1, 1, -1}, {2, -2, 2, -2, 2, -2}, {3, -3, 3, -3, 3, -3}}},
+      // Sequential values
+      {{{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
+        {10, 11, 12, 13, 14, 15, 16, 17, 18, 19},
+        {20, 21, 22, 23, 24, 25, 26, 27, 28, 29}}},
+      // Powers of 2
+      {{{1, 2, 4, 8, 16, 32, 64},
+        {128, 256, 512, 1024, 2048, 4096, 8192},
+        {16384, 32768, 65536, 131072, 262144, 524288, 1048576}}},
+      // Negative progression
+      {{{-1, -2, -4, -8}, {-16, -32, -64, -128}, {0, 0, 0, 0}}},
+      // Mix of edge cases and regular values
+      {{{std::numeric_limits<int64_t>::min(), -1000, -1, 0},
+        {1,
+         1000,
+         std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::max()},
+        {42, 43, 44, 45}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeFlatVector<int64_t>(testCase.columnValues[0]),
+         makeFlatVector<int64_t>(testCase.columnValues[1]),
+         makeFlatVector<int64_t>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    // Test all four sort orders
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, longTypeWithNulls) {
+  struct {
+    std::vector<std::vector<std::optional<int64_t>>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          if (column[row].has_value()) {
+            rowValues.push_back(std::to_string(column[row].value()));
+          } else {
+            rowValues.emplace_back("null");
+          }
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row with null
+      {{{std::nullopt}, {1}, {2}}},
+      // Single row without null (nullable type)
+      {{{1}, {2}, {3}}},
+      // All nulls
+      {{{std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt}}},
+      // Null at beginning of first column
+      {{{std::nullopt, 1, 2}, {10, 20, 30}, {100, 200, 300}}},
+      // Null at end of first column
+      {{{1, 2, std::nullopt}, {10, 20, 30}, {100, 200, 300}}},
+      // Null in middle of first column
+      {{{1, std::nullopt, 2}, {10, 20, 30}, {100, 200, 300}}},
+      // Nulls in all positions across different columns
+      {{{std::nullopt, 1, 2, 3},
+        {1, std::nullopt, 2, 3},
+        {1, 2, std::nullopt, 3}}},
+      // Multiple nulls in same row
+      {{{std::nullopt, 1, 2}, {std::nullopt, 1, 2}, {std::nullopt, 1, 2}}},
+      // Alternating null and non-null in first column
+      {{{std::nullopt, 1, std::nullopt, 2, std::nullopt, 3},
+        {10, 10, 10, 10, 10, 10},
+        {20, 20, 20, 20, 20, 20}}},
+      // Same values, different null positions
+      {{{1, 1, std::nullopt}, {2, std::nullopt, 2}, {3, 3, 3}}},
+      // Nulls with edge values
+      {{{std::nullopt,
+         std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::max()},
+        {0, std::nullopt, 0},
+        {100, 200, std::nullopt}}},
+      // Nulls with zeros
+      {{{std::nullopt, 0, std::nullopt}, {0, std::nullopt, 0}, {0, 0, 0}}},
+      // Nulls with positive and negative values
+      {{{std::nullopt, -5, 5},
+        {-10, std::nullopt, 10},
+        {std::nullopt, -15, std::nullopt}}},
+      // Duplicate non-null values with nulls
+      {{{1, 1, std::nullopt, std::nullopt},
+        {2, 2, 2, std::nullopt},
+        {3, std::nullopt, 3, 3}}},
+      // Ascending order with nulls scattered
+      {{{std::nullopt, 1, 2, 3, std::nullopt},
+        {10, std::nullopt, 20, std::nullopt, 30},
+        {std::nullopt, std::nullopt, 100, 200, 300}}},
+      // Descending order with nulls scattered
+      {{{std::nullopt, 3, 2, 1, std::nullopt},
+        {30, std::nullopt, 20, std::nullopt, 10},
+        {std::nullopt, std::nullopt, 300, 200, 100}}},
+      // Only first column has nulls
+      {{{std::nullopt, std::nullopt, 1, 2}, {10, 20, 30, 40}, {5, 6, 7, 8}}},
+      // Only middle column has nulls
+      {{{1, 2, 3, 4},
+        {std::nullopt, std::nullopt, 10, 20},
+        {100, 200, 300, 400}}},
+      // Only last column has nulls
+      {{{1, 2, 3, 4},
+        {10, 20, 30, 40},
+        {std::nullopt, std::nullopt, 100, 200}}},
+      // All columns have at least one null
+      {{{std::nullopt, 1, 2, 3, 4},
+        {1, std::nullopt, 2, 3, 4},
+        {1, 2, std::nullopt, 3, 4}}},
+      // Null vs non-null with same other column values
+      {{{std::nullopt, 1}, {100, 100}, {200, 200}}},
+      // Large spread with nulls
+      {{{std::nullopt, -1000000, 0, 1000000, std::nullopt},
+        {999999, std::nullopt, 0, std::nullopt, -999999},
+        {std::nullopt, 42, std::nullopt, 42, std::nullopt}}},
+      // Sequential with nulls at boundaries
+      {{{std::nullopt, 0, 1, 2, 3, std::nullopt},
+        {std::nullopt, 10, 11, 12, 13, std::nullopt},
+        {std::nullopt, 20, 21, 22, 23, std::nullopt}}},
+      // Powers of 2 with nulls
+      {{{std::nullopt, 1, 2, 4, 8, std::nullopt},
+        {16, std::nullopt, 32, 64, std::nullopt, 128},
+        {std::nullopt, 256, std::nullopt, 512, std::nullopt, 1024}}},
+      // Mix of nulls and regular values testing sort order edge cases
+      {{{std::nullopt, std::nullopt, 0, 0},
+        {std::nullopt, 1, std::nullopt, 1},
+        {2, std::nullopt, 2, std::nullopt}}},
+      // All max values
+      {{{std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::max()},
+        {std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::max()},
+        {std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::max()}}},
+      // All min values
+      {{{std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::min()},
+        {std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::min()},
+        {std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::min()}}},
+      // Max values with nulls
+      {{{std::nullopt, std::numeric_limits<int64_t>::max(), std::nullopt},
+        {std::numeric_limits<int64_t>::max(),
+         std::nullopt,
+         std::numeric_limits<int64_t>::max()},
+        {std::nullopt, std::nullopt, std::numeric_limits<int64_t>::max()}}},
+      // Min values with nulls
+      {{{std::nullopt, std::numeric_limits<int64_t>::min(), std::nullopt},
+        {std::numeric_limits<int64_t>::min(),
+         std::nullopt,
+         std::numeric_limits<int64_t>::min()},
+        {std::nullopt, std::nullopt, std::numeric_limits<int64_t>::min()}}},
+      // Mix of max and min values
+      {{{std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::max()},
+        {std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::min()},
+        {std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::max()}}},
+      // Mix of max, min, and nulls
+      {{{std::nullopt,
+         std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::min()},
+        {std::numeric_limits<int64_t>::max(),
+         std::nullopt,
+         std::numeric_limits<int64_t>::min()},
+        {std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::max(),
+         std::nullopt}}},
+      // Max in first column only
+      {{{std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::max(),
+         1,
+         2},
+        {100, 200, 300, 400},
+        {5, 6, 7, 8}}},
+      // Min in first column only
+      {{{std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::min(),
+         1,
+         2},
+        {100, 200, 300, 400},
+        {5, 6, 7, 8}}},
+      // Max and min in different columns
+      {{{std::numeric_limits<int64_t>::max(), 1, 2},
+        {1, std::numeric_limits<int64_t>::min(), 2},
+        {1, 2, std::numeric_limits<int64_t>::max()}}},
+      // Adjacent to max (max-1, max)
+      {{{std::numeric_limits<int64_t>::max() - 1,
+         std::numeric_limits<int64_t>::max(),
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int64_t>::max() - 1,
+         std::numeric_limits<int64_t>::max()},
+        {std::numeric_limits<int64_t>::max(),
+         std::nullopt,
+         std::numeric_limits<int64_t>::max() - 1}}},
+      // Adjacent to min (min, min+1)
+      {{{std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::min() + 1,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::min() + 1},
+        {std::numeric_limits<int64_t>::min() + 1,
+         std::nullopt,
+         std::numeric_limits<int64_t>::min()}}},
+      // Boundary transitions with nulls (min, null, 0, null, max)
+      {{{std::numeric_limits<int64_t>::min(),
+         std::nullopt,
+         0,
+         std::nullopt,
+         std::numeric_limits<int64_t>::max()},
+        {std::nullopt,
+         std::numeric_limits<int64_t>::min(),
+         std::nullopt,
+         std::numeric_limits<int64_t>::max(),
+         std::nullopt},
+        {0, 0, 0, 0, 0}}},
+      // Duplicate max values with nulls
+      {{{std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::max(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::max(),
+         std::nullopt},
+        {std::numeric_limits<int64_t>::max(),
+         std::nullopt,
+         std::nullopt,
+         std::numeric_limits<int64_t>::max()}}},
+      // Duplicate min values with nulls
+      {{{std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::min(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::min(),
+         std::nullopt},
+        {std::numeric_limits<int64_t>::min(),
+         std::nullopt,
+         std::nullopt,
+         std::numeric_limits<int64_t>::min()}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeNullableFlatVector<int64_t>(testCase.columnValues[0]),
+         makeNullableFlatVector<int64_t>(testCase.columnValues[1]),
+         makeNullableFlatVector<int64_t>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    // Test all four sort orders (ASC/DESC x NULLS FIRST/NULLS LAST)
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, integerTypeWithoutNulls) {
+  struct {
+    std::vector<std::vector<int32_t>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<int32_t> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          rowValues.push_back(column[row]);
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row
+      {{{1}, {2}, {3}}},
+      // All same values
+      {{{5, 5, 5}, {10, 10, 10}, {15, 15, 15}}},
+      // Ascending order
+      {{{1, 2, 3, 4}, {100, 100, 100, 100}, {50, 50, 50, 50}}},
+      // Descending order
+      {{{10, 9, 8, 7}, {0, 0, 0, 0}, {5, 5, 5, 5}}},
+      // Mixed positive and negative values
+      {{{-5, 0, 5}, {-10, -5, 0}, {10, 5, 0}}},
+      // Edge values: min and max int32_t
+      {{{std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::max(),
+         0},
+        {-1, 0, 1},
+        {100, 200, 300}}},
+      // All zeros
+      {{{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}},
+      // Duplicate values
+      {{{1, 2, 1, 2}, {3, 3, 4, 4}, {5, 5, 5, 5}}},
+      // Large spread
+      {{{-1000000, -1, 0, 1, 1000000},
+        {999999, 500000, 0, -500000, -999999},
+        {42, 42, 42, 42, 42}}},
+      // Values differing only in last column
+      {{{1, 1, 1}, {2, 2, 2}, {3, 4, 5}}},
+      // Values differing only in first column
+      {{{1, 2, 3}, {100, 100, 100}, {200, 200, 200}}},
+      // Alternating pattern
+      {{{1, -1, 1, -1}, {2, -2, 2, -2}, {3, -3, 3, -3}}},
+      // All max values
+      {{{std::numeric_limits<int32_t>::max(),
+         std::numeric_limits<int32_t>::max()},
+        {std::numeric_limits<int32_t>::max(),
+         std::numeric_limits<int32_t>::max()},
+        {std::numeric_limits<int32_t>::max(),
+         std::numeric_limits<int32_t>::max()}}},
+      // All min values
+      {{{std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::min()},
+        {std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::min()},
+        {std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::min()}}},
+      // Mix of max and min
+      {{{std::numeric_limits<int32_t>::max(),
+         std::numeric_limits<int32_t>::min()},
+        {std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::max()},
+        {0, 0}}},
+      // Adjacent to max (max-1, max)
+      {{{std::numeric_limits<int32_t>::max() - 1,
+         std::numeric_limits<int32_t>::max()},
+        {std::numeric_limits<int32_t>::max(),
+         std::numeric_limits<int32_t>::max() - 1},
+        {0, 1}}},
+      // Adjacent to min (min, min+1)
+      {{{std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::min() + 1},
+        {std::numeric_limits<int32_t>::min() + 1,
+         std::numeric_limits<int32_t>::min()},
+        {0, 1}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeFlatVector<int32_t>(testCase.columnValues[0]),
+         makeFlatVector<int32_t>(testCase.columnValues[1]),
+         makeFlatVector<int32_t>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    // Test all four sort orders
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, integerTypeWithNulls) {
+  struct {
+    std::vector<std::vector<std::optional<int32_t>>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          if (column[row].has_value()) {
+            rowValues.push_back(std::to_string(column[row].value()));
+          } else {
+            rowValues.emplace_back("null");
+          }
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row with null
+      {{{std::nullopt}, {1}, {2}}},
+      // Single row without null (nullable type)
+      {{{1}, {2}, {3}}},
+      // All nulls
+      {{{std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt}}},
+      // Null at beginning with max value
+      {{{std::nullopt, 1, std::numeric_limits<int32_t>::max()},
+        {10, 20, 30},
+        {100, 200, 300}}},
+      // Null at end with min value
+      {{{1, std::numeric_limits<int32_t>::min(), std::nullopt},
+        {10, 20, 30},
+        {100, 200, 300}}},
+      // Null in middle
+      {{{1, std::nullopt, 2}, {10, 20, 30}, {100, 200, 300}}},
+      // Nulls in all positions across different columns with edge values
+      {{{std::nullopt, 1, std::numeric_limits<int32_t>::max(), 3},
+        {1, std::nullopt, 2, std::numeric_limits<int32_t>::min()},
+        {std::numeric_limits<int32_t>::min(), 2, std::nullopt, 3}}},
+      // Multiple nulls in same row
+      {{{std::nullopt, 1, 2}, {std::nullopt, 1, 2}, {std::nullopt, 1, 2}}},
+      // Alternating null and non-null with boundaries
+      {{{std::nullopt,
+         std::numeric_limits<int32_t>::max(),
+         std::nullopt,
+         2,
+         std::nullopt,
+         std::numeric_limits<int32_t>::min()},
+        {10, 10, 10, 10, 10, 10},
+        {20, 20, 20, 20, 20, 20}}},
+      // Same values, different null positions
+      {{{1, 1, std::nullopt}, {2, std::nullopt, 2}, {3, 3, 3}}},
+      // Mixed edge values with nulls
+      {{{std::nullopt,
+         std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::max()},
+        {0, std::nullopt, 0},
+        {100, 200, std::nullopt}}},
+      // Nulls with zeros and boundaries
+      {{{std::nullopt, 0, std::numeric_limits<int32_t>::max()},
+        {0, std::nullopt, std::numeric_limits<int32_t>::min()},
+        {0, 0, 0}}},
+      // Nulls with positive and negative including extremes
+      {{{std::nullopt, -5, std::numeric_limits<int32_t>::max()},
+        {std::numeric_limits<int32_t>::min(), std::nullopt, 10},
+        {std::nullopt, -15, std::nullopt}}},
+      // Duplicate non-null values with nulls
+      {{{1, 1, std::nullopt, std::nullopt},
+        {2, 2, 2, std::nullopt},
+        {3, std::nullopt, 3, 3}}},
+      // Ascending order with nulls and max values
+      {{{std::nullopt, 1, 2, std::numeric_limits<int32_t>::max(), std::nullopt},
+        {10, std::nullopt, 20, std::nullopt, 30},
+        {std::nullopt, std::nullopt, 100, 200, 300}}},
+      // Descending order with nulls and min values
+      {{{std::nullopt,
+         std::numeric_limits<int32_t>::max(),
+         2,
+         std::numeric_limits<int32_t>::min(),
+         std::nullopt},
+        {30, std::nullopt, 20, std::nullopt, 10},
+        {std::nullopt, std::nullopt, 300, 200, 100}}},
+      // Only first column has nulls with boundaries
+      {{{std::nullopt,
+         std::nullopt,
+         std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::max()},
+        {10, 20, 30, 40},
+        {5, 6, 7, 8}}},
+      // Only middle column has nulls
+      {{{1, 2, 3, 4},
+        {std::nullopt, std::nullopt, 10, 20},
+        {100, 200, 300, 400}}},
+      // Only last column has nulls with max
+      {{{1, 2, 3, std::numeric_limits<int32_t>::max()},
+        {10, 20, 30, 40},
+        {std::nullopt,
+         std::nullopt,
+         100,
+         std::numeric_limits<int32_t>::min()}}},
+      // All columns have at least one null mixed with extremes
+      {{{std::nullopt, std::numeric_limits<int32_t>::max(), 2, 3, 4},
+        {1, std::nullopt, std::numeric_limits<int32_t>::min(), 3, 4},
+        {1, 2, std::nullopt, std::numeric_limits<int32_t>::max(), 4}}},
+      // Null vs non-null with same other column values
+      {{{std::nullopt, 1}, {100, 100}, {200, 200}}},
+      // Large spread with nulls and boundaries
+      {{{std::nullopt,
+         -1000000,
+         std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::max(),
+         std::nullopt},
+        {999999, std::nullopt, 0, std::nullopt, -999999},
+        {std::nullopt, 42, std::nullopt, 42, std::nullopt}}},
+      // Sequential with nulls at boundaries
+      {{{std::nullopt,
+         0,
+         1,
+         std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::max(),
+         std::nullopt},
+        {std::nullopt, 10, 11, 12, 13, std::nullopt},
+        {std::nullopt, 20, 21, 22, 23, std::nullopt}}},
+      // Mix of nulls and regular values testing sort order
+      {{{std::nullopt, std::nullopt, 0, 0},
+        {std::nullopt, 1, std::nullopt, 1},
+        {2, std::nullopt, 2, std::nullopt}}},
+      // Max and min together in different positions
+      {{{std::numeric_limits<int32_t>::max(),
+         std::numeric_limits<int32_t>::min(),
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int32_t>::max(),
+         std::numeric_limits<int32_t>::min()},
+        {std::numeric_limits<int32_t>::min(),
+         std::nullopt,
+         std::numeric_limits<int32_t>::max()}}},
+      // Adjacent to max with nulls (max-1, max)
+      {{{std::numeric_limits<int32_t>::max() - 1,
+         std::numeric_limits<int32_t>::max(),
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int32_t>::max() - 1,
+         std::numeric_limits<int32_t>::max()},
+        {std::numeric_limits<int32_t>::max(),
+         std::nullopt,
+         std::numeric_limits<int32_t>::max() - 1}}},
+      // Adjacent to min with nulls (min, min+1)
+      {{{std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::min() + 1,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::min() + 1},
+        {std::numeric_limits<int32_t>::min() + 1,
+         std::nullopt,
+         std::numeric_limits<int32_t>::min()}}},
+      // Boundary transitions with nulls (min, null, 0, null, max)
+      {{{std::numeric_limits<int32_t>::min(),
+         std::nullopt,
+         0,
+         std::nullopt,
+         std::numeric_limits<int32_t>::max()},
+        {std::nullopt,
+         std::numeric_limits<int32_t>::min(),
+         std::nullopt,
+         std::numeric_limits<int32_t>::max(),
+         std::nullopt},
+        {0, 0, 0, 0, 0}}},
+      // Duplicate max values with nulls
+      {{{std::numeric_limits<int32_t>::max(),
+         std::numeric_limits<int32_t>::max(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int32_t>::max(),
+         std::numeric_limits<int32_t>::max(),
+         std::nullopt},
+        {std::numeric_limits<int32_t>::max(),
+         std::nullopt,
+         std::nullopt,
+         std::numeric_limits<int32_t>::max()}}},
+      // Duplicate min values with nulls
+      {{{std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::min(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::min(),
+         std::nullopt},
+        {std::numeric_limits<int32_t>::min(),
+         std::nullopt,
+         std::nullopt,
+         std::numeric_limits<int32_t>::min()}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeNullableFlatVector<int32_t>(testCase.columnValues[0]),
+         makeNullableFlatVector<int32_t>(testCase.columnValues[1]),
+         makeNullableFlatVector<int32_t>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, shortTypeWithoutNulls) {
+  struct {
+    std::vector<std::vector<int16_t>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<int16_t> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          rowValues.push_back(column[row]);
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row
+      {{{1}, {2}, {3}}},
+      // All same values
+      {{{5, 5, 5}, {10, 10, 10}, {15, 15, 15}}},
+      // Ascending order
+      {{{1, 2, 3, 4}, {100, 100, 100, 100}, {50, 50, 50, 50}}},
+      // Descending order
+      {{{10, 9, 8, 7}, {0, 0, 0, 0}, {5, 5, 5, 5}}},
+      // Mixed positive and negative values
+      {{{-5, 0, 5}, {-10, -5, 0}, {10, 5, 0}}},
+      // Edge values: min and max int16_t
+      {{{std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::max(),
+         0},
+        {-1, 0, 1},
+        {100, 200, 300}}},
+      // All zeros
+      {{{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}},
+      // Duplicate values
+      {{{1, 2, 1, 2}, {3, 3, 4, 4}, {5, 5, 5, 5}}},
+      // Large spread (within int16 range)
+      {{{-30000, -1, 0, 1, 30000},
+        {20000, 10000, 0, -10000, -20000},
+        {42, 42, 42, 42, 42}}},
+      // Values differing only in last column
+      {{{1, 1, 1}, {2, 2, 2}, {3, 4, 5}}},
+      // Values differing only in first column
+      {{{1, 2, 3}, {100, 100, 100}, {200, 200, 200}}},
+      // Alternating pattern
+      {{{1, -1, 1, -1}, {2, -2, 2, -2}, {3, -3, 3, -3}}},
+      // All max values
+      {{{std::numeric_limits<int16_t>::max(),
+         std::numeric_limits<int16_t>::max()},
+        {std::numeric_limits<int16_t>::max(),
+         std::numeric_limits<int16_t>::max()},
+        {std::numeric_limits<int16_t>::max(),
+         std::numeric_limits<int16_t>::max()}}},
+      // All min values
+      {{{std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::min()},
+        {std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::min()},
+        {std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::min()}}},
+      // Mix of max and min
+      {{{std::numeric_limits<int16_t>::max(),
+         std::numeric_limits<int16_t>::min()},
+        {std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::max()},
+        {0, 0}}},
+      // Adjacent to max (max-1, max)
+      {{{std::numeric_limits<int16_t>::max() - 1,
+         std::numeric_limits<int16_t>::max()},
+        {std::numeric_limits<int16_t>::max(),
+         std::numeric_limits<int16_t>::max() - 1},
+        {0, 1}}},
+      // Adjacent to min (min, min+1)
+      {{{std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::min() + 1},
+        {std::numeric_limits<int16_t>::min() + 1,
+         std::numeric_limits<int16_t>::min()},
+        {0, 1}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeFlatVector<int16_t>(testCase.columnValues[0]),
+         makeFlatVector<int16_t>(testCase.columnValues[1]),
+         makeFlatVector<int16_t>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, shortTypeWithNulls) {
+  struct {
+    std::vector<std::vector<std::optional<int16_t>>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          if (column[row].has_value()) {
+            rowValues.push_back(std::to_string(column[row].value()));
+          } else {
+            rowValues.emplace_back("null");
+          }
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row with null
+      {{{std::nullopt}, {1}, {2}}},
+      // Single row without null (nullable type)
+      {{{1}, {2}, {3}}},
+      // All nulls
+      {{{std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt}}},
+      // Null at beginning with max value
+      {{{std::nullopt, 1, std::numeric_limits<int16_t>::max()},
+        {10, 20, 30},
+        {100, 200, 300}}},
+      // Null at end with min value
+      {{{1, std::numeric_limits<int16_t>::min(), std::nullopt},
+        {10, 20, 30},
+        {100, 200, 300}}},
+      // Null in middle
+      {{{1, std::nullopt, 2}, {10, 20, 30}, {100, 200, 300}}},
+      // Nulls in all positions across different columns with edge values
+      {{{std::nullopt, 1, std::numeric_limits<int16_t>::max(), 3},
+        {1, std::nullopt, 2, std::numeric_limits<int16_t>::min()},
+        {std::numeric_limits<int16_t>::min(), 2, std::nullopt, 3}}},
+      // Multiple nulls in same row
+      {{{std::nullopt, 1, 2}, {std::nullopt, 1, 2}, {std::nullopt, 1, 2}}},
+      // Alternating null and non-null with boundaries
+      {{{std::nullopt,
+         std::numeric_limits<int16_t>::max(),
+         std::nullopt,
+         2,
+         std::nullopt,
+         std::numeric_limits<int16_t>::min()},
+        {10, 10, 10, 10, 10, 10},
+        {20, 20, 20, 20, 20, 20}}},
+      // Same values, different null positions
+      {{{1, 1, std::nullopt}, {2, std::nullopt, 2}, {3, 3, 3}}},
+      // Mixed edge values with nulls
+      {{{std::nullopt,
+         std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::max()},
+        {0, std::nullopt, 0},
+        {100, 200, std::nullopt}}},
+      // Nulls with zeros and boundaries
+      {{{std::nullopt, 0, std::numeric_limits<int16_t>::max()},
+        {0, std::nullopt, std::numeric_limits<int16_t>::min()},
+        {0, 0, 0}}},
+      // Nulls with positive and negative including extremes
+      {{{std::nullopt, -5, std::numeric_limits<int16_t>::max()},
+        {std::numeric_limits<int16_t>::min(), std::nullopt, 10},
+        {std::nullopt, -15, std::nullopt}}},
+      // Duplicate non-null values with nulls
+      {{{1, 1, std::nullopt, std::nullopt},
+        {2, 2, 2, std::nullopt},
+        {3, std::nullopt, 3, 3}}},
+      // Ascending order with nulls and max values
+      {{{std::nullopt, 1, 2, std::numeric_limits<int16_t>::max(), std::nullopt},
+        {10, std::nullopt, 20, std::nullopt, 30},
+        {std::nullopt, std::nullopt, 100, 200, 300}}},
+      // Descending order with nulls and min values
+      {{{std::nullopt,
+         std::numeric_limits<int16_t>::max(),
+         2,
+         std::numeric_limits<int16_t>::min(),
+         std::nullopt},
+        {30, std::nullopt, 20, std::nullopt, 10},
+        {std::nullopt, std::nullopt, 300, 200, 100}}},
+      // Only first column has nulls with boundaries
+      {{{std::nullopt,
+         std::nullopt,
+         std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::max()},
+        {10, 20, 30, 40},
+        {5, 6, 7, 8}}},
+      // Only middle column has nulls
+      {{{1, 2, 3, 4},
+        {std::nullopt, std::nullopt, 10, 20},
+        {100, 200, 300, 400}}},
+      // Only last column has nulls with max
+      {{{1, 2, 3, std::numeric_limits<int16_t>::max()},
+        {10, 20, 30, 40},
+        {std::nullopt,
+         std::nullopt,
+         100,
+         std::numeric_limits<int16_t>::min()}}},
+      // All columns have at least one null mixed with extremes
+      {{{std::nullopt, std::numeric_limits<int16_t>::max(), 2, 3, 4},
+        {1, std::nullopt, std::numeric_limits<int16_t>::min(), 3, 4},
+        {1, 2, std::nullopt, std::numeric_limits<int16_t>::max(), 4}}},
+      // Null vs non-null with same other column values
+      {{{std::nullopt, 1}, {100, 100}, {200, 200}}},
+      // Large spread with nulls and boundaries (within int16 range)
+      {{{std::nullopt,
+         -30000,
+         std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::max(),
+         std::nullopt},
+        {20000, std::nullopt, 0, std::nullopt, -20000},
+        {std::nullopt, 42, std::nullopt, 42, std::nullopt}}},
+      // Mix of nulls and regular values testing sort order
+      {{{std::nullopt, std::nullopt, 0, 0},
+        {std::nullopt, 1, std::nullopt, 1},
+        {2, std::nullopt, 2, std::nullopt}}},
+      // Max and min together in different positions
+      {{{std::numeric_limits<int16_t>::max(),
+         std::numeric_limits<int16_t>::min(),
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int16_t>::max(),
+         std::numeric_limits<int16_t>::min()},
+        {std::numeric_limits<int16_t>::min(),
+         std::nullopt,
+         std::numeric_limits<int16_t>::max()}}},
+      // Adjacent to max with nulls (max-1, max)
+      {{{std::numeric_limits<int16_t>::max() - 1,
+         std::numeric_limits<int16_t>::max(),
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int16_t>::max() - 1,
+         std::numeric_limits<int16_t>::max()},
+        {std::numeric_limits<int16_t>::max(),
+         std::nullopt,
+         std::numeric_limits<int16_t>::max() - 1}}},
+      // Adjacent to min with nulls (min, min+1)
+      {{{std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::min() + 1,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::min() + 1},
+        {std::numeric_limits<int16_t>::min() + 1,
+         std::nullopt,
+         std::numeric_limits<int16_t>::min()}}},
+      // Boundary transitions with nulls (min, null, 0, null, max)
+      {{{std::numeric_limits<int16_t>::min(),
+         std::nullopt,
+         0,
+         std::nullopt,
+         std::numeric_limits<int16_t>::max()},
+        {std::nullopt,
+         std::numeric_limits<int16_t>::min(),
+         std::nullopt,
+         std::numeric_limits<int16_t>::max(),
+         std::nullopt},
+        {0, 0, 0, 0, 0}}},
+      // Duplicate max values with nulls
+      {{{std::numeric_limits<int16_t>::max(),
+         std::numeric_limits<int16_t>::max(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int16_t>::max(),
+         std::numeric_limits<int16_t>::max(),
+         std::nullopt},
+        {std::numeric_limits<int16_t>::max(),
+         std::nullopt,
+         std::nullopt,
+         std::numeric_limits<int16_t>::max()}}},
+      // Duplicate min values with nulls
+      {{{std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::min(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::min(),
+         std::nullopt},
+        {std::numeric_limits<int16_t>::min(),
+         std::nullopt,
+         std::nullopt,
+         std::numeric_limits<int16_t>::min()}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeNullableFlatVector<int16_t>(testCase.columnValues[0]),
+         makeNullableFlatVector<int16_t>(testCase.columnValues[1]),
+         makeNullableFlatVector<int16_t>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, byteTypeWithoutNulls) {
+  struct {
+    std::vector<std::vector<int8_t>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<int> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          rowValues.push_back(static_cast<int>(column[row]));
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row
+      {{{1}, {2}, {3}}},
+      // All same values
+      {{{5, 5, 5}, {10, 10, 10}, {15, 15, 15}}},
+      // Ascending order
+      {{{1, 2, 3, 4}, {100, 100, 100, 100}, {50, 50, 50, 50}}},
+      // Descending order
+      {{{10, 9, 8, 7}, {0, 0, 0, 0}, {5, 5, 5, 5}}},
+      // Mixed positive and negative values
+      {{{-5, 0, 5}, {-10, -5, 0}, {10, 5, 0}}},
+      // Edge values: min and max int8_t
+      {{{std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::max(),
+         0},
+        {-1, 0, 1},
+        {100, 50, 25}}},
+      // All zeros
+      {{{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}},
+      // Duplicate values
+      {{{1, 2, 1, 2}, {3, 3, 4, 4}, {5, 5, 5, 5}}},
+      // Large spread (within int8 range)
+      {{{-120, -1, 0, 1, 120}, {100, 50, 0, -50, -100}, {42, 42, 42, 42, 42}}},
+      // Values differing only in last column
+      {{{1, 1, 1}, {2, 2, 2}, {3, 4, 5}}},
+      // Values differing only in first column
+      {{{1, 2, 3}, {100, 100, 100}, {50, 50, 50}}},
+      // Alternating pattern
+      {{{1, -1, 1, -1}, {2, -2, 2, -2}, {3, -3, 3, -3}}},
+      // All max values (127)
+      {{{std::numeric_limits<int8_t>::max(),
+         std::numeric_limits<int8_t>::max()},
+        {std::numeric_limits<int8_t>::max(),
+         std::numeric_limits<int8_t>::max()},
+        {std::numeric_limits<int8_t>::max(),
+         std::numeric_limits<int8_t>::max()}}},
+      // All min values (-128)
+      {{{std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::min()},
+        {std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::min()},
+        {std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::min()}}},
+      // Mix of max and min
+      {{{std::numeric_limits<int8_t>::max(),
+         std::numeric_limits<int8_t>::min()},
+        {std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::max()},
+        {0, 0}}},
+      // Adjacent to max (max-1, max)
+      {{{std::numeric_limits<int8_t>::max() - 1,
+         std::numeric_limits<int8_t>::max()},
+        {std::numeric_limits<int8_t>::max(),
+         std::numeric_limits<int8_t>::max() - 1},
+        {0, 1}}},
+      // Adjacent to min (min, min+1)
+      {{{std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::min() + 1},
+        {std::numeric_limits<int8_t>::min() + 1,
+         std::numeric_limits<int8_t>::min()},
+        {0, 1}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeFlatVector<int8_t>(testCase.columnValues[0]),
+         makeFlatVector<int8_t>(testCase.columnValues[1]),
+         makeFlatVector<int8_t>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, byteTypeWithNulls) {
+  struct {
+    std::vector<std::vector<std::optional<int8_t>>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          if (column[row].has_value()) {
+            rowValues.push_back(
+                std::to_string(static_cast<int>(column[row].value())));
+          } else {
+            rowValues.emplace_back("null");
+          }
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row with null
+      {{{std::nullopt}, {1}, {2}}},
+      // Single row without null (nullable type)
+      {{{1}, {2}, {3}}},
+      // All nulls
+      {{{std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt}}},
+      // Null at beginning with max value
+      {{{std::nullopt, 1, std::numeric_limits<int8_t>::max()},
+        {10, 20, 30},
+        {100, 50, 25}}},
+      // Null at end with min value
+      {{{1, std::numeric_limits<int8_t>::min(), std::nullopt},
+        {10, 20, 30},
+        {100, 50, 25}}},
+      // Null in middle
+      {{{1, std::nullopt, 2}, {10, 20, 30}, {100, 50, 25}}},
+      // Nulls in all positions across different columns with edge values
+      {{{std::nullopt, 1, std::numeric_limits<int8_t>::max(), 3},
+        {1, std::nullopt, 2, std::numeric_limits<int8_t>::min()},
+        {std::numeric_limits<int8_t>::min(), 2, std::nullopt, 3}}},
+      // Multiple nulls in same row
+      {{{std::nullopt, 1, 2}, {std::nullopt, 1, 2}, {std::nullopt, 1, 2}}},
+      // Alternating null and non-null with boundaries
+      {{{std::nullopt,
+         std::numeric_limits<int8_t>::max(),
+         std::nullopt,
+         2,
+         std::nullopt,
+         std::numeric_limits<int8_t>::min()},
+        {10, 10, 10, 10, 10, 10},
+        {20, 20, 20, 20, 20, 20}}},
+      // Same values, different null positions
+      {{{1, 1, std::nullopt}, {2, std::nullopt, 2}, {3, 3, 3}}},
+      // Mixed edge values with nulls
+      {{{std::nullopt,
+         std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::max()},
+        {0, std::nullopt, 0},
+        {100, 50, std::nullopt}}},
+      // Nulls with zeros and boundaries
+      {{{std::nullopt, 0, std::numeric_limits<int8_t>::max()},
+        {0, std::nullopt, std::numeric_limits<int8_t>::min()},
+        {0, 0, 0}}},
+      // Nulls with positive and negative including extremes
+      {{{std::nullopt, -5, std::numeric_limits<int8_t>::max()},
+        {std::numeric_limits<int8_t>::min(), std::nullopt, 10},
+        {std::nullopt, -15, std::nullopt}}},
+      // Duplicate non-null values with nulls
+      {{{1, 1, std::nullopt, std::nullopt},
+        {2, 2, 2, std::nullopt},
+        {3, std::nullopt, 3, 3}}},
+      // Ascending order with nulls and max values
+      {{{std::nullopt, 1, 2, std::numeric_limits<int8_t>::max(), std::nullopt},
+        {10, std::nullopt, 20, std::nullopt, 30},
+        {std::nullopt, std::nullopt, 100, 50, 25}}},
+      // Descending order with nulls and min values
+      {{{std::nullopt,
+         std::numeric_limits<int8_t>::max(),
+         2,
+         std::numeric_limits<int8_t>::min(),
+         std::nullopt},
+        {30, std::nullopt, 20, std::nullopt, 10},
+        {std::nullopt, std::nullopt, 100, 50, 25}}},
+      // Only first column has nulls with boundaries
+      {{{std::nullopt,
+         std::nullopt,
+         std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::max()},
+        {10, 20, 30, 40},
+        {5, 6, 7, 8}}},
+      // Only middle column has nulls
+      {{{1, 2, 3, 4}, {std::nullopt, std::nullopt, 10, 20}, {100, 50, 25, 10}}},
+      // Only last column has nulls with max
+      {{{1, 2, 3, std::numeric_limits<int8_t>::max()},
+        {10, 20, 30, 40},
+        {std::nullopt, std::nullopt, 100, std::numeric_limits<int8_t>::min()}}},
+      // All columns have at least one null mixed with extremes
+      {{{std::nullopt, std::numeric_limits<int8_t>::max(), 2, 3, 4},
+        {1, std::nullopt, std::numeric_limits<int8_t>::min(), 3, 4},
+        {1, 2, std::nullopt, std::numeric_limits<int8_t>::max(), 4}}},
+      // Null vs non-null with same other column values
+      {{{std::nullopt, 1}, {100, 100}, {50, 50}}},
+      // Large spread with nulls and boundaries (within int8 range)
+      {{{std::nullopt,
+         -120,
+         std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::max(),
+         std::nullopt},
+        {100, std::nullopt, 0, std::nullopt, -100},
+        {std::nullopt, 42, std::nullopt, 42, std::nullopt}}},
+      // Mix of nulls and regular values testing sort order
+      {{{std::nullopt, std::nullopt, 0, 0},
+        {std::nullopt, 1, std::nullopt, 1},
+        {2, std::nullopt, 2, std::nullopt}}},
+      // Max and min together in different positions
+      {{{std::numeric_limits<int8_t>::max(),
+         std::numeric_limits<int8_t>::min(),
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int8_t>::max(),
+         std::numeric_limits<int8_t>::min()},
+        {std::numeric_limits<int8_t>::min(),
+         std::nullopt,
+         std::numeric_limits<int8_t>::max()}}},
+      // Adjacent to max with nulls (max-1, max)
+      {{{std::numeric_limits<int8_t>::max() - 1,
+         std::numeric_limits<int8_t>::max(),
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int8_t>::max() - 1,
+         std::numeric_limits<int8_t>::max()},
+        {std::numeric_limits<int8_t>::max(),
+         std::nullopt,
+         std::numeric_limits<int8_t>::max() - 1}}},
+      // Adjacent to min with nulls (min, min+1)
+      {{{std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::min() + 1,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::min() + 1},
+        {std::numeric_limits<int8_t>::min() + 1,
+         std::nullopt,
+         std::numeric_limits<int8_t>::min()}}},
+      // Boundary transitions with nulls (min, null, 0, null, max)
+      {{{std::numeric_limits<int8_t>::min(),
+         std::nullopt,
+         0,
+         std::nullopt,
+         std::numeric_limits<int8_t>::max()},
+        {std::nullopt,
+         std::numeric_limits<int8_t>::min(),
+         std::nullopt,
+         std::numeric_limits<int8_t>::max(),
+         std::nullopt},
+        {0, 0, 0, 0, 0}}},
+      // Duplicate max values with nulls
+      {{{std::numeric_limits<int8_t>::max(),
+         std::numeric_limits<int8_t>::max(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int8_t>::max(),
+         std::numeric_limits<int8_t>::max(),
+         std::nullopt},
+        {std::numeric_limits<int8_t>::max(),
+         std::nullopt,
+         std::nullopt,
+         std::numeric_limits<int8_t>::max()}}},
+      // Duplicate min values with nulls
+      {{{std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::min(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::min(),
+         std::nullopt},
+        {std::numeric_limits<int8_t>::min(),
+         std::nullopt,
+         std::nullopt,
+         std::numeric_limits<int8_t>::min()}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeNullableFlatVector<int8_t>(testCase.columnValues[0]),
+         makeNullableFlatVector<int8_t>(testCase.columnValues[1]),
+         makeNullableFlatVector<int8_t>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, doubleTypeWithoutNulls) {
+  struct {
+    std::vector<std::vector<double>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          rowValues.push_back(std::to_string(column[row]));
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row
+      {{{1.0}, {2.0}, {3.0}}},
+      // All same values
+      {{{5.5, 5.5, 5.5}, {10.5, 10.5, 10.5}, {15.5, 15.5, 15.5}}},
+      // Ascending order
+      {{{1.1, 2.2, 3.3, 4.4},
+        {100.5, 100.5, 100.5, 100.5},
+        {50.5, 50.5, 50.5, 50.5}}},
+      // Descending order
+      {{{10.9, 9.8, 8.7, 7.6}, {0.0, 0.0, 0.0, 0.0}, {5.5, 5.5, 5.5, 5.5}}},
+      // Mixed positive and negative values
+      {{{-5.5, 0.0, 5.5}, {-10.5, -5.5, 0.0}, {10.5, 5.5, 0.0}}},
+      // All zeros
+      {{{0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}}},
+      // Positive and negative zero
+      {{{0.0, -0.0, 0.0}, {-0.0, 0.0, -0.0}, {0.0, 0.0, 0.0}}},
+      // Positive infinity
+      {{{std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::infinity()},
+        {1.0, 2.0},
+        {3.0, 4.0}}},
+      // Negative infinity
+      {{{-std::numeric_limits<double>::infinity(),
+         -std::numeric_limits<double>::infinity()},
+        {1.0, 2.0},
+        {3.0, 4.0}}},
+      // Mix of infinity and regular values
+      {{{-std::numeric_limits<double>::infinity(),
+         0.0,
+         std::numeric_limits<double>::infinity()},
+        {-1.0, 0.0, 1.0},
+        {100.0, 200.0, 300.0}}},
+      // Both infinities together
+      {{{-std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::infinity()},
+        {std::numeric_limits<double>::infinity(),
+         -std::numeric_limits<double>::infinity()},
+        {0.0, 0.0}}},
+      // Edge values with infinity
+      {{{-std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::lowest(),
+         std::numeric_limits<double>::lowest(),
+         0.0,
+         std::numeric_limits<double>::max(),
+         std::numeric_limits<double>::infinity()},
+        {1.0, 2.0, 3.0, 4.0, 5.0, 6.0},
+        {10.0, 20.0, 30.0, 40.0, 50.0, 60.0}}},
+      // All positive infinity
+      {{{std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::infinity()},
+        {std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::infinity()},
+        {std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::infinity()}}},
+      // All negative infinity
+      {{{-std::numeric_limits<double>::infinity(),
+         -std::numeric_limits<double>::infinity()},
+        {-std::numeric_limits<double>::infinity(),
+         -std::numeric_limits<double>::infinity()},
+        {-std::numeric_limits<double>::infinity(),
+         -std::numeric_limits<double>::infinity()}}},
+      // Max values
+      {{{std::numeric_limits<double>::max(),
+         std::numeric_limits<double>::max()},
+        {std::numeric_limits<double>::max(),
+         std::numeric_limits<double>::max()},
+        {std::numeric_limits<double>::max(),
+         std::numeric_limits<double>::max()}}},
+      // Min positive values
+      {{{std::numeric_limits<double>::lowest(),
+         std::numeric_limits<double>::lowest()},
+        {std::numeric_limits<double>::lowest(),
+         std::numeric_limits<double>::lowest()},
+        {std::numeric_limits<double>::lowest(),
+         std::numeric_limits<double>::lowest()}}},
+      // Lowest values (most negative)
+      {{{std::numeric_limits<double>::lowest(),
+         std::numeric_limits<double>::lowest()},
+        {std::numeric_limits<double>::lowest(),
+         std::numeric_limits<double>::lowest()},
+        {std::numeric_limits<double>::lowest(),
+         std::numeric_limits<double>::lowest()}}},
+      // Mix of max, min, and infinity
+      {{{-std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::lowest(),
+         std::numeric_limits<double>::max(),
+         std::numeric_limits<double>::infinity()},
+        {std::numeric_limits<double>::lowest(), 0.0, 1.0, 2.0},
+        {-1.0, -2.0, -3.0, -4.0}}},
+      // Very small and very large values
+      {{{-1e308, -1e100, -1e-308, 0.0, 1e-308, 1e100, 1e308},
+        {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0},
+        {2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0}}},
+      // Fractional values
+      {{{0.1, 0.01, 0.001, 0.0001},
+        {-0.1, -0.01, -0.001, -0.0001},
+        {1.5, 2.5, 3.5, 4.5}}},
+      // Values differing only in last column
+      {{{1.5, 1.5, 1.5}, {2.5, 2.5, 2.5}, {3.5, 4.5, 5.5}}},
+      // Values differing only in first column
+      {{{1.5, 2.5, 3.5}, {100.5, 100.5, 100.5}, {200.5, 200.5, 200.5}}},
+      {{{1.0f, 0.0f, -0.0f}, {0.0f, 1.0f, 0.0f}, {-0.0f, 0.0f, 1.0f}}}};
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeFlatVector<double>(testCase.columnValues[0]),
+         makeFlatVector<double>(testCase.columnValues[1]),
+         makeFlatVector<double>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, doubleTypeWithNulls) {
+  struct {
+    std::vector<std::vector<std::optional<double>>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          if (column[row].has_value()) {
+            rowValues.push_back(std::to_string(column[row].value()));
+          } else {
+            rowValues.emplace_back("null");
+          }
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row with null
+      {{{std::nullopt}, {1.0}, {2.0}}},
+      // Single row without null (nullable type)
+      {{{1.0}, {2.0}, {3.0}}},
+      // All nulls
+      {{{std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt}}},
+      // Null at beginning with infinity
+      {{{std::nullopt, 1.0, std::numeric_limits<double>::infinity()},
+        {10.0, 20.0, 30.0},
+        {100.0, 200.0, 300.0}}},
+      // Null at end with negative infinity
+      {{{1.0, -std::numeric_limits<double>::infinity(), std::nullopt},
+        {10.0, 20.0, 30.0},
+        {100.0, 200.0, 300.0}}},
+      // Null in middle
+      {{{1.0, std::nullopt, 2.0}, {10.0, 20.0, 30.0}, {100.0, 200.0, 300.0}}},
+      // Nulls with both infinities
+      {{{std::nullopt,
+         -std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::infinity()},
+        {std::numeric_limits<double>::infinity(),
+         std::nullopt,
+         -std::numeric_limits<double>::infinity()},
+        {0.0, 1.0, std::nullopt}}},
+      // Multiple nulls in same row
+      {{{std::nullopt, 1.0, 2.0},
+        {std::nullopt, 1.0, 2.0},
+        {std::nullopt, 1.0, 2.0}}},
+      // Alternating null and non-null with infinities
+      {{{std::nullopt,
+         std::numeric_limits<double>::infinity(),
+         std::nullopt,
+         2.0,
+         std::nullopt,
+         -std::numeric_limits<double>::infinity()},
+        {10.0, 10.0, 10.0, 10.0, 10.0, 10.0},
+        {20.0, 20.0, 20.0, 20.0, 20.0, 20.0}}},
+      // Same values, different null positions
+      {{{1.5, 1.5, std::nullopt}, {2.5, std::nullopt, 2.5}, {3.5, 3.5, 3.5}}},
+      // Nulls with zeros
+      {{{std::nullopt, 0.0, std::nullopt},
+        {0.0, std::nullopt, 0.0},
+        {0.0, 0.0, 0.0}}},
+      // Nulls with positive and negative values
+      {{{std::nullopt, -5.5, 5.5},
+        {-10.5, std::nullopt, 10.5},
+        {std::nullopt, -15.5, std::nullopt}}},
+      // Duplicate non-null values with nulls
+      {{{1.5, 1.5, std::nullopt, std::nullopt},
+        {2.5, 2.5, 2.5, std::nullopt},
+        {3.5, std::nullopt, 3.5, 3.5}}},
+      // Ascending order with nulls and infinity
+      {{{std::nullopt,
+         1.0,
+         2.0,
+         std::numeric_limits<double>::infinity(),
+         std::nullopt},
+        {10.0, std::nullopt, 20.0, std::nullopt, 30.0},
+        {std::nullopt, std::nullopt, 100.0, 200.0, 300.0}}},
+      // Descending order with nulls and negative infinity
+      {{{std::nullopt,
+         std::numeric_limits<double>::infinity(),
+         2.0,
+         -std::numeric_limits<double>::infinity(),
+         std::nullopt},
+        {30.0, std::nullopt, 20.0, std::nullopt, 10.0},
+        {std::nullopt, std::nullopt, 300.0, 200.0, 100.0}}},
+      // Only first column has nulls with infinities
+      {{{std::nullopt,
+         std::nullopt,
+         -std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::infinity()},
+        {10.0, 20.0, 30.0, 40.0},
+        {5.0, 6.0, 7.0, 8.0}}},
+      // Only middle column has nulls
+      {{{1.0, 2.0, 3.0, 4.0},
+        {std::nullopt, std::nullopt, 10.0, 20.0},
+        {100.0, 200.0, 300.0, 400.0}}},
+      // Only last column has nulls with infinity
+      {{{1.0, 2.0, 3.0, std::numeric_limits<double>::infinity()},
+        {10.0, 20.0, 30.0, 40.0},
+        {std::nullopt,
+         std::nullopt,
+         100.0,
+         -std::numeric_limits<double>::infinity()}}},
+      // All columns have at least one null mixed with infinities
+      {{{std::nullopt, std::numeric_limits<double>::infinity(), 2.0, 3.0, 4.0},
+        {1.0, std::nullopt, -std::numeric_limits<double>::infinity(), 3.0, 4.0},
+        {1.0,
+         2.0,
+         std::nullopt,
+         std::numeric_limits<double>::infinity(),
+         4.0}}},
+      // Null vs non-null with same other column values
+      {{{std::nullopt, 1.0}, {100.0, 100.0}, {200.0, 200.0}}},
+      // Mix of null, infinity, and regular values
+      {{{std::nullopt,
+         -std::numeric_limits<double>::infinity(),
+         0.0,
+         std::numeric_limits<double>::infinity(),
+         std::nullopt},
+        {std::numeric_limits<double>::infinity(),
+         std::nullopt,
+         0.0,
+         std::nullopt,
+         -std::numeric_limits<double>::infinity()},
+        {std::nullopt, 1.0, std::nullopt, 2.0, std::nullopt}}},
+      // All positive infinity with nulls
+      {{{std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::infinity(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::infinity(),
+         std::nullopt},
+        {std::numeric_limits<double>::infinity(),
+         std::nullopt,
+         std::nullopt,
+         std::numeric_limits<double>::infinity()}}},
+      // All negative infinity with nulls
+      {{{-std::numeric_limits<double>::infinity(),
+         -std::numeric_limits<double>::infinity(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         -std::numeric_limits<double>::infinity(),
+         -std::numeric_limits<double>::infinity(),
+         std::nullopt},
+        {-std::numeric_limits<double>::infinity(),
+         std::nullopt,
+         std::nullopt,
+         -std::numeric_limits<double>::infinity()}}},
+      // Max values with nulls
+      {{{std::nullopt, std::numeric_limits<double>::max(), std::nullopt},
+        {std::numeric_limits<double>::max(),
+         std::nullopt,
+         std::numeric_limits<double>::max()},
+        {std::nullopt, std::nullopt, std::numeric_limits<double>::max()}}},
+      // Lowest values with nulls
+      {{{std::nullopt, std::numeric_limits<double>::lowest(), std::nullopt},
+        {std::numeric_limits<double>::lowest(),
+         std::nullopt,
+         std::numeric_limits<double>::lowest()},
+        {std::nullopt, std::nullopt, std::numeric_limits<double>::lowest()}}},
+      // Mix of max, lowest, infinity and nulls
+      {{{std::nullopt,
+         std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::max()},
+        {std::numeric_limits<double>::lowest(),
+         std::nullopt,
+         -std::numeric_limits<double>::infinity()},
+        {0.0, 1.0, std::nullopt}}},
+      // Very small and very large values with nulls
+      {{{std::nullopt, 1e-308, 1e308, std::nullopt},
+        {1e308, std::nullopt, -1e308, -1e-308},
+        {std::nullopt, 0.0f, std::nullopt, 0.0f}}},
+      // Positive and negative zero with nulls
+      {{{std::nullopt, 0.0, -0.0f},
+        {0.0f, std::nullopt, 0.0f},
+        {-0.0f, 0.0f, std::nullopt}}}};
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeNullableFlatVector<double>(testCase.columnValues[0]),
+         makeNullableFlatVector<double>(testCase.columnValues[1]),
+         makeNullableFlatVector<double>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, floatTypeWithoutNulls) {
+  struct {
+    std::vector<std::vector<float>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          rowValues.push_back(std::to_string(column[row]));
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row
+      {{{1.0f}, {2.0f}, {3.0f}}},
+      // All same values
+      {{{5.5f, 5.5f, 5.5f}, {10.5f, 10.5f, 10.5f}, {15.5f, 15.5f, 15.5f}}},
+      // Ascending order
+      {{{1.1f, 2.2f, 3.3f, 4.4f},
+        {100.5f, 100.5f, 100.5f, 100.5f},
+        {50.5f, 50.5f, 50.5f, 50.5f}}},
+      // Descending order
+      {{{10.9f, 9.8f, 8.7f, 7.6f},
+        {0.0f, 0.0f, 0.0f, 0.0f},
+        {5.5f, 5.5f, 5.5f, 5.5f}}},
+      // Mixed positive and negative values
+      {{{-5.5f, 0.0f, 5.5f}, {-10.5f, -5.5f, 0.0f}, {10.5f, 5.5f, 0.0f}}},
+      // All zeros
+      {{{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}}},
+      // Positive and negative zero
+      {{{0.0f, -0.0f, 0.0f}, {-0.0f, 0.0f, -0.0f}, {0.0f, 0.0f, 0.0f}}},
+      // Positive infinity
+      {{{std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::infinity()},
+        {1.0f, 2.0f},
+        {3.0f, 4.0f}}},
+      // Negative infinity
+      {{{-std::numeric_limits<float>::infinity(),
+         -std::numeric_limits<float>::infinity()},
+        {1.0f, 2.0f},
+        {3.0f, 4.0f}}},
+      // Mix of infinity and regular values
+      {{{-std::numeric_limits<float>::infinity(),
+         0.0f,
+         std::numeric_limits<float>::infinity()},
+        {-1.0f, 0.0f, 1.0f},
+        {100.0f, 200.0f, 300.0f}}},
+      // Both infinities together
+      {{{-std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::infinity()},
+        {std::numeric_limits<float>::infinity(),
+         -std::numeric_limits<float>::infinity()},
+        {0.0f, 0.0f}}},
+      // Edge values with infinity
+      {{{-std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::lowest(),
+         std::numeric_limits<float>::lowest(),
+         0.0f,
+         std::numeric_limits<float>::max(),
+         std::numeric_limits<float>::infinity()},
+        {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f},
+        {10.0f, 20.0f, 30.0f, 40.0f, 50.0f, 60.0f}}},
+      // All positive infinity
+      {{{std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::infinity()},
+        {std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::infinity()},
+        {std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::infinity()}}},
+      // All negative infinity
+      {{{-std::numeric_limits<float>::infinity(),
+         -std::numeric_limits<float>::infinity()},
+        {-std::numeric_limits<float>::infinity(),
+         -std::numeric_limits<float>::infinity()},
+        {-std::numeric_limits<float>::infinity(),
+         -std::numeric_limits<float>::infinity()}}},
+      // Max values
+      {{{std::numeric_limits<float>::max(), std::numeric_limits<float>::max()},
+        {std::numeric_limits<float>::max(), std::numeric_limits<float>::max()},
+        {std::numeric_limits<float>::max(),
+         std::numeric_limits<float>::max()}}},
+      // Min positive values
+      {{{std::numeric_limits<float>::lowest(),
+         std::numeric_limits<float>::lowest()},
+        {std::numeric_limits<float>::lowest(),
+         std::numeric_limits<float>::lowest()},
+        {std::numeric_limits<float>::lowest(),
+         std::numeric_limits<float>::lowest()}}},
+      // Lowest values (most negative)
+      {{{std::numeric_limits<float>::lowest(),
+         std::numeric_limits<float>::lowest()},
+        {std::numeric_limits<float>::lowest(),
+         std::numeric_limits<float>::lowest()},
+        {std::numeric_limits<float>::lowest(),
+         std::numeric_limits<float>::lowest()}}},
+      // Mix of max, min, and infinity
+      {{{-std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::lowest(),
+         std::numeric_limits<float>::max(),
+         std::numeric_limits<float>::infinity()},
+        {std::numeric_limits<float>::lowest(), 0.0f, 1.0f, 2.0f},
+        {-1.0f, -2.0f, -3.0f, -4.0f}}},
+      // Very small and very large values
+      {{{-1e38f, -1e10f, -1e-38f, 0.0f, 1e-38f, 1e10f, 1e38f},
+        {1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f},
+        {2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f}}},
+      // Fractional values
+      {{{0.1f, 0.01f, 0.001f, 0.0001f},
+        {-0.1f, -0.01f, -0.001f, -0.0001f},
+        {1.5f, 2.5f, 3.5f, 4.5f}}},
+      // Values differing only in last column
+      {{{1.5f, 1.5f, 1.5f}, {2.5f, 2.5f, 2.5f}, {3.5f, 4.5f, 5.5f}}},
+      // Values differing only in first column
+      {{{1.5f, 2.5f, 3.5f},
+        {100.5f, 100.5f, 100.5f},
+        {200.5f, 200.5f, 200.5f}}},
+      {{{1.0f, 0.0f, -0.0f}, {0.0f, 1.0f, 0.0f}, {-0.0f, 0.0f, 1.0f}}}};
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeFlatVector<float>(testCase.columnValues[0]),
+         makeFlatVector<float>(testCase.columnValues[1]),
+         makeFlatVector<float>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, floatTypeWithNulls) {
+  struct {
+    std::vector<std::vector<std::optional<float>>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          if (column[row].has_value()) {
+            rowValues.push_back(std::to_string(column[row].value()));
+          } else {
+            rowValues.emplace_back("null");
+          }
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row with null
+      {{{std::nullopt}, {1.0f}, {2.0f}}},
+      // Single row without null (nullable type)
+      {{{1.0f}, {2.0f}, {3.0f}}},
+      // All nulls
+      {{{std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt}}},
+      // Null at beginning with infinity
+      {{{std::nullopt, 1.0f, std::numeric_limits<float>::infinity()},
+        {10.0f, 20.0f, 30.0f},
+        {100.0f, 200.0f, 300.0f}}},
+      // Null at end with negative infinity
+      {{{1.0f, -std::numeric_limits<float>::infinity(), std::nullopt},
+        {10.0f, 20.0f, 30.0f},
+        {100.0f, 200.0f, 300.0f}}},
+      // Null in middle
+      {{{1.0f, std::nullopt, 2.0f},
+        {10.0f, 20.0f, 30.0f},
+        {100.0f, 200.0f, 300.0f}}},
+      // Nulls with both infinities
+      {{{std::nullopt,
+         -std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::infinity()},
+        {std::numeric_limits<float>::infinity(),
+         std::nullopt,
+         -std::numeric_limits<float>::infinity()},
+        {0.0f, 1.0f, std::nullopt}}},
+      // Multiple nulls in same row
+      {{{std::nullopt, 1.0f, 2.0f},
+        {std::nullopt, 1.0f, 2.0f},
+        {std::nullopt, 1.0f, 2.0f}}},
+      // Alternating null and non-null with infinities
+      {{{std::nullopt,
+         std::numeric_limits<float>::infinity(),
+         std::nullopt,
+         2.0f,
+         std::nullopt,
+         -std::numeric_limits<float>::infinity()},
+        {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f},
+        {20.0f, 20.0f, 20.0f, 20.0f, 20.0f, 20.0f}}},
+      // Same values, different null positions
+      {{{1.5f, 1.5f, std::nullopt},
+        {2.5f, std::nullopt, 2.5f},
+        {3.5f, 3.5f, 3.5f}}},
+      // Nulls with zeros
+      {{{std::nullopt, 0.0f, std::nullopt},
+        {0.0f, std::nullopt, 0.0f},
+        {0.0f, 0.0f, 0.0f}}},
+      // Nulls with positive and negative values
+      {{{std::nullopt, -5.5f, 5.5f},
+        {-10.5f, std::nullopt, 10.5f},
+        {std::nullopt, -15.5f, std::nullopt}}},
+      // Duplicate non-null values with nulls
+      {{{1.5f, 1.5f, std::nullopt, std::nullopt},
+        {2.5f, 2.5f, 2.5f, std::nullopt},
+        {3.5f, std::nullopt, 3.5f, 3.5f}}},
+      // Ascending order with nulls and infinity
+      {{{std::nullopt,
+         1.0f,
+         2.0f,
+         std::numeric_limits<float>::infinity(),
+         std::nullopt},
+        {10.0f, std::nullopt, 20.0f, std::nullopt, 30.0f},
+        {std::nullopt, std::nullopt, 100.0f, 200.0f, 300.0f}}},
+      // Descending order with nulls and negative infinity
+      {{{std::nullopt,
+         std::numeric_limits<float>::infinity(),
+         2.0f,
+         -std::numeric_limits<float>::infinity(),
+         std::nullopt},
+        {30.0f, std::nullopt, 20.0f, std::nullopt, 10.0f},
+        {std::nullopt, std::nullopt, 300.0f, 200.0f, 100.0f}}},
+      // Only first column has nulls with infinities
+      {{{std::nullopt,
+         std::nullopt,
+         -std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::infinity()},
+        {10.0f, 20.0f, 30.0f, 40.0f},
+        {5.0f, 6.0f, 7.0f, 8.0f}}},
+      // Only middle column has nulls
+      {{{1.0f, 2.0f, 3.0f, 4.0f},
+        {std::nullopt, std::nullopt, 10.0f, 20.0f},
+        {100.0f, 200.0f, 300.0f, 400.0f}}},
+      // Only last column has nulls with infinity
+      {{{1.0f, 2.0f, 3.0f, std::numeric_limits<float>::infinity()},
+        {10.0f, 20.0f, 30.0f, 40.0f},
+        {std::nullopt,
+         std::nullopt,
+         100.0f,
+         -std::numeric_limits<float>::infinity()}}},
+      // All columns have at least one null mixed with infinities
+      {{{std::nullopt,
+         std::numeric_limits<float>::infinity(),
+         2.0f,
+         3.0f,
+         4.0f},
+        {1.0f,
+         std::nullopt,
+         -std::numeric_limits<float>::infinity(),
+         3.0f,
+         4.0f},
+        {1.0f,
+         2.0f,
+         std::nullopt,
+         std::numeric_limits<float>::infinity(),
+         4.0f}}},
+      // Null vs non-null with same other column values
+      {{{std::nullopt, 1.0f}, {100.0f, 100.0f}, {200.0f, 200.0f}}},
+      // Mix of null, infinity, and regular values
+      {{{std::nullopt,
+         -std::numeric_limits<float>::infinity(),
+         0.0f,
+         std::numeric_limits<float>::infinity(),
+         std::nullopt},
+        {std::numeric_limits<float>::infinity(),
+         std::nullopt,
+         0.0f,
+         std::nullopt,
+         -std::numeric_limits<float>::infinity()},
+        {std::nullopt, 1.0f, std::nullopt, 2.0f, std::nullopt}}},
+      // All positive infinity with nulls
+      {{{std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::infinity(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::infinity(),
+         std::nullopt},
+        {std::numeric_limits<float>::infinity(),
+         std::nullopt,
+         std::nullopt,
+         std::numeric_limits<float>::infinity()}}},
+      // All negative infinity with nulls
+      {{{-std::numeric_limits<float>::infinity(),
+         -std::numeric_limits<float>::infinity(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         -std::numeric_limits<float>::infinity(),
+         -std::numeric_limits<float>::infinity(),
+         std::nullopt},
+        {-std::numeric_limits<float>::infinity(),
+         std::nullopt,
+         std::nullopt,
+         -std::numeric_limits<float>::infinity()}}},
+      // Max values with nulls
+      {{{std::nullopt, std::numeric_limits<float>::max(), std::nullopt},
+        {std::numeric_limits<float>::max(),
+         std::nullopt,
+         std::numeric_limits<float>::max()},
+        {std::nullopt, std::nullopt, std::numeric_limits<float>::max()}}},
+      // Lowest values with nulls
+      {{{std::nullopt, std::numeric_limits<float>::lowest(), std::nullopt},
+        {std::numeric_limits<float>::lowest(),
+         std::nullopt,
+         std::numeric_limits<float>::lowest()},
+        {std::nullopt, std::nullopt, std::numeric_limits<float>::lowest()}}},
+      // Mix of max, lowest, infinity and nulls
+      {{{std::nullopt,
+         std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::max()},
+        {std::numeric_limits<float>::lowest(),
+         std::nullopt,
+         -std::numeric_limits<float>::infinity()},
+        {0.0f, 1.0f, std::nullopt}}},
+      // Very small and very large values with nulls
+      {{{std::nullopt, 1e-38f, 1e38f, std::nullopt},
+        {1e38f, std::nullopt, -1e38f, -1e-38f},
+        {std::nullopt, 0.0f, std::nullopt, 0.0f}}},
+      // Positive and negative zero with nulls
+      {{{std::nullopt, 0.0f, -0.0f},
+        {0.0f, std::nullopt, 0.0f},
+        {-0.0f, 0.0f, std::nullopt}}}};
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeNullableFlatVector<float>(testCase.columnValues[0]),
+         makeNullableFlatVector<float>(testCase.columnValues[1]),
+         makeNullableFlatVector<float>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, booleanTypeWithoutNulls) {
+  struct {
+    std::vector<std::vector<bool>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          rowValues.emplace_back(column[row] ? "true" : "false");
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row (true)
+      {{{true}, {false}, {true}}},
+      // Single row (false)
+      {{{false}, {true}, {false}}},
+      // All true values
+      {{{true, true, true}, {true, true, true}, {true, true, true}}},
+      // All false values
+      {{{false, false, false}, {false, false, false}, {false, false, false}}},
+      // Mixed true/false values
+      {{{true, false, true, false},
+        {false, true, false, true},
+        {true, true, false, false}}},
+      // Alternating true/false
+      {{{true, false, true, false},
+        {false, true, false, true},
+        {true, false, true, false}}},
+      // Values differing only in last column
+      {{{true, true, true}, {false, false, false}, {true, false, true}}},
+      // Values differing only in first column
+      {{{true, false, true}, {false, false, false}, {true, true, true}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeFlatVector<bool>(testCase.columnValues[0]),
+         makeFlatVector<bool>(testCase.columnValues[1]),
+         makeFlatVector<bool>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, booleanTypeWithNulls) {
+  struct {
+    std::vector<std::vector<std::optional<bool>>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          if (column[row].has_value()) {
+            rowValues.emplace_back(column[row].value() ? "true" : "false");
+          } else {
+            rowValues.emplace_back("null");
+          }
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single null
+      {{{std::nullopt}, {true}, {false}}},
+      // All nulls
+      {{{std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt}}},
+      // Null with true
+      {{{std::nullopt, true}, {true, false}, {false, true}}},
+      // Null with false
+      {{{std::nullopt, false}, {false, true}, {true, false}}},
+      // Nulls at different positions
+      {{{std::nullopt, true, false},
+        {true, std::nullopt, false},
+        {true, false, std::nullopt}}},
+      // Alternating null/true/false
+      {{{std::nullopt, true, false, std::nullopt},
+        {true, std::nullopt, true, false},
+        {false, true, std::nullopt, true}}},
+      // Only first column has nulls
+      {{{std::nullopt, std::nullopt, true},
+        {true, false, true},
+        {false, true, false}}},
+      // Only middle column has nulls
+      {{{true, false, true},
+        {std::nullopt, std::nullopt, true},
+        {false, true, false}}},
+      // Only last column has nulls
+      {{{true, false, true},
+        {false, true, false},
+        {std::nullopt, std::nullopt, true}}},
+      // All columns have at least one null
+      {{{std::nullopt, true, false},
+        {true, std::nullopt, false},
+        {true, false, std::nullopt}}},
+      // Mix of null/true/false values
+      {{{std::nullopt, true, false, std::nullopt},
+        {true, std::nullopt, false, true},
+        {false, true, std::nullopt, false}}},
+      // Null vs non-null with same other column values
+      {{{std::nullopt, true}, {false, false}, {true, true}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeNullableFlatVector<bool>(testCase.columnValues[0]),
+         makeNullableFlatVector<bool>(testCase.columnValues[1]),
+         makeNullableFlatVector<bool>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, stringTypeWithoutNulls) {
+  struct {
+    std::vector<std::vector<std::string>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          rowValues.push_back(fmt::format("'{}'", column[row]));
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row
+      {{{"apple"}, {"dog"}, {"x"}}},
+      // All same values
+      {{{"same", "same", "same"},
+        {"same", "same", "same"},
+        {"same", "same", "same"}}},
+      // Ascending order (lexicographically)
+      {{{"a", "b", "c", "d"},
+        {"alpha", "alpha", "alpha", "alpha"},
+        {"x", "x", "x", "x"}}},
+      // Descending order (lexicographically)
+      {{{"zebra", "yak", "xray", "wolf"},
+        {"delta", "delta", "delta", "delta"},
+        {"z", "z", "z", "z"}}},
+      // Empty string as minimum
+      {{{"", "a", "aa", "aaa"},
+        {"empty", "empty", "empty", "empty"},
+        {"test", "test", "test", "test"}}},
+      // Empty strings
+      {{{"", "", ""}, {"", "", ""}, {"", "", ""}}},
+      // Single character strings
+      {{{"a", "b", "c"}, {"x", "y", "z"}, {"1", "2", "3"}}},
+      // Multi-character strings
+      {{{"apple", "banana", "cherry"},
+        {"dog", "elephant", "fox"},
+        {"red", "green", "blue"}}},
+      // Strings with spaces
+      {{{"hello world", "foo bar", "test case"},
+        {"space test", "another test", "final test"},
+        {"a b c", "x y z", "1 2 3"}}},
+      // Strings with special characters
+      {{{"hello!", "world?", "test@"},
+        {"special#", "chars$", "here%"},
+        {"more^", "symbols&", "data*"}}},
+      // Strings differing only in case
+      {{{"apple", "Apple", "APPLE"},
+        {"test", "test", "test"},
+        {"value", "value", "value"}}},
+      // Strings differing only in length
+      {{{"a", "aa", "aaa"}, {"b", "bb", "bbb"}, {"c", "cc", "ccc"}}},
+      // Strings differing only in last character
+      {{{"testa", "testb", "testc"},
+        {"valuex", "valuey", "valuez"},
+        {"item1", "item2", "item3"}}},
+      // Very long strings
+      {{{"this_is_a_very_long_string_that_contains_many_characters_to_test_encoding",
+         "another_extremely_long_string_with_different_content_for_testing_purposes",
+         "yet_another_long_string_to_ensure_proper_handling_of_large_data"},
+        {"long_value_1", "long_value_2", "long_value_3"},
+        {"x", "y", "z"}}},
+      // Strings with numbers
+      {{{"test123", "value456", "item789"},
+        {"abc123", "def456", "ghi789"},
+        {"1a2b3c", "4d5e6f", "7g8h9i"}}},
+      // Strings with unicode characters (if supported)
+      {{{"café", "naïve", "résumé"},
+        {"hello", "world", "test"},
+        {"α", "β", "γ"}}},
+      // Duplicate strings
+      {{{"apple", "apple", "banana", "banana"},
+        {"test", "test", "value", "value"},
+        {"x", "y", "x", "y"}}},
+      // Prefixes of each other
+      {{{"a", "ab", "abc", "abcd"},
+        {"test", "test", "test", "test"},
+        {"x", "x", "x", "x"}}},
+      // Mixed empty and non-empty
+      {{{"", "a", "", "b"},
+        {"empty", "", "mixed", ""},
+        {"test", "test", "", ""}}},
+      // Strings with tabs and newlines
+      {{{"hello\tworld", "test\ncase", "value\r\ndata"},
+        {"tab\there", "new\nline", "return\rchar"},
+        {"a", "b", "c"}}},
+      // Numeric strings (lexicographic vs numeric order)
+      {{{"1", "10", "2", "20"},
+        {"100", "200", "300", "400"},
+        {"a", "b", "c", "d"}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeFlatVector<std::string_view>(std::vector<std::string_view>(
+             testCase.columnValues[0].begin(), testCase.columnValues[0].end())),
+         makeFlatVector<std::string_view>(std::vector<std::string_view>(
+             testCase.columnValues[1].begin(), testCase.columnValues[1].end())),
+         makeFlatVector<std::string_view>(std::vector<std::string_view>(
+             testCase.columnValues[2].begin(),
+             testCase.columnValues[2].end()))});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, stringTypeWithNulls) {
+  struct {
+    std::vector<std::vector<std::optional<std::string>>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          if (column[row].has_value()) {
+            rowValues.push_back(fmt::format("'{}'", column[row].value()));
+          } else {
+            rowValues.emplace_back("null");
+          }
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single null
+      {{{std::nullopt}, {"test"}, {"value"}}},
+      // All nulls
+      {{{std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt}}},
+      // Null with empty string
+      {{{std::nullopt, ""}, {"test", "test"}, {"value", "value"}}},
+      // Null with non-empty strings
+      {{{std::nullopt, "apple", "banana"},
+        {"test", "test", "test"},
+        {"x", "y", "z"}}},
+      // Nulls at different positions (beginning, middle, end)
+      {{{std::nullopt, "a", "b", "c"},
+        {"a", std::nullopt, "b", "c"},
+        {"a", "b", std::nullopt, "c"}}},
+      // Empty string vs null
+      {{{std::nullopt, "", "a"}, {"", std::nullopt, "a"}, {"a", "a", "a"}}},
+      // Nulls with various string lengths
+      {{{std::nullopt, "a", "ab", "abc"},
+        {"test", std::nullopt, "testing", "t"},
+        {"x", "y", std::nullopt, "z"}}},
+      // Duplicate strings with nulls
+      {{{std::nullopt, "apple", "apple", std::nullopt},
+        {"test", std::nullopt, "test", std::nullopt},
+        {"x", "x", std::nullopt, "x"}}},
+      // Ascending with nulls
+      {{{std::nullopt, "a", "b", "c"},
+        {"alpha", std::nullopt, "beta", "gamma"},
+        {std::nullopt, "x", "y", "z"}}},
+      // Descending with nulls
+      {{{std::nullopt, "zebra", "yak", "wolf"},
+        {"delta", std::nullopt, "charlie", "bravo"},
+        {std::nullopt, "z", "y", "x"}}},
+      // Only first column has nulls
+      {{{std::nullopt, std::nullopt, "a", "b"},
+        {"test1", "test2", "test3", "test4"},
+        {"x", "y", "z", "w"}}},
+      // Only middle column has nulls
+      {{{"apple", "banana", "cherry"},
+        {std::nullopt, std::nullopt, "test"},
+        {"x", "y", "z"}}},
+      // Only last column has nulls
+      {{{"apple", "banana", "cherry"},
+        {"dog", "elephant", "fox"},
+        {std::nullopt, std::nullopt, "red"}}},
+      // All columns have at least one null
+      {{{std::nullopt, "a", "b", "c"},
+        {"test", std::nullopt, "value", "data"},
+        {"x", "y", std::nullopt, "z"}}},
+      // All columns have nulls in same rows
+      {{{std::nullopt, "a", std::nullopt, "c"},
+        {std::nullopt, "test", std::nullopt, "value"},
+        {std::nullopt, "x", std::nullopt, "z"}}},
+      // Null vs non-null with same other values
+      {{{std::nullopt, "apple"}, {"test", "test"}, {"value", "value"}}},
+      // Mix of empty string, null, and regular strings
+      {{{std::nullopt, "", "a", "apple"},
+        {"", std::nullopt, "b", "banana"},
+        {"test", "test", std::nullopt, ""}}},
+      // Nulls with strings containing spaces
+      {{{std::nullopt, "hello world", "foo bar"},
+        {"test case", std::nullopt, "another test"},
+        {std::nullopt, "a b c", std::nullopt}}},
+      // Nulls with strings containing special characters
+      {{{std::nullopt, "hello!", "world?"},
+        {"special#", std::nullopt, "chars$"},
+        {"more^", std::nullopt, "data*"}}},
+      // Nulls with strings differing only in case
+      {{{std::nullopt, "apple", "Apple", "APPLE"},
+        {"test", std::nullopt, "test", "test"},
+        {"value", "value", std::nullopt, "value"}}},
+      // Nulls with strings differing only in length
+      {{{std::nullopt, "a", "aa", "aaa"},
+        {"b", std::nullopt, "bb", "bbb"},
+        {"c", "cc", std::nullopt, "ccc"}}},
+      // Nulls with very long strings
+      {{{std::nullopt,
+         "this_is_a_very_long_string_that_contains_many_characters",
+         "another_long_string"},
+        {"test", std::nullopt, "value"},
+        {"x", "y", std::nullopt}}},
+      // Nulls with strings containing numbers
+      {{{std::nullopt, "test123", "value456"},
+        {"abc123", std::nullopt, "def456"},
+        {"1a2b3c", "4d5e6f", std::nullopt}}},
+      // Nulls with unicode characters
+      {{{std::nullopt, "café", "naïve"},
+        {"hello", std::nullopt, "world"},
+        {"α", "β", std::nullopt}}},
+      // Nulls with prefixes
+      {{{std::nullopt, "a", "ab", "abc"},
+        {"test", std::nullopt, "test", "test"},
+        {"x", "x", std::nullopt, "x"}}},
+      // Multiple nulls in same row
+      {{{std::nullopt, "a", std::nullopt},
+        {std::nullopt, "b", std::nullopt},
+        {std::nullopt, "c", std::nullopt}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+
+    // Convert std::optional<std::string> to std::optional<std::string_view>
+    std::vector<std::optional<std::string_view>> col0, col1, col2;
+    for (const auto& val : testCase.columnValues[0]) {
+      col0.push_back(
+          val.has_value() ? std::optional<std::string_view>(val.value())
+                          : std::nullopt);
+    }
+    for (const auto& val : testCase.columnValues[1]) {
+      col1.push_back(
+          val.has_value() ? std::optional<std::string_view>(val.value())
+                          : std::nullopt);
+    }
+    for (const auto& val : testCase.columnValues[2]) {
+      col2.push_back(
+          val.has_value() ? std::optional<std::string_view>(val.value())
+                          : std::nullopt);
+    }
+
+    const auto input = makeRowVector(
+        {makeNullableFlatVector<std::string_view>(col0),
+         makeNullableFlatVector<std::string_view>(col1),
+         makeNullableFlatVector<std::string_view>(col2)});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    // Test all four sort orders
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, timestampTypeWithoutNulls) {
+  struct {
+    std::vector<std::vector<velox::Timestamp>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          rowValues.push_back(column[row].toString());
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row
+      {{{velox::Timestamp(1, 0)},
+        {velox::Timestamp(2, 0)},
+        {velox::Timestamp(3, 0)}}},
+      // All same values
+      {{{velox::Timestamp(5, 100), velox::Timestamp(5, 100)},
+        {velox::Timestamp(10, 200), velox::Timestamp(10, 200)},
+        {velox::Timestamp(15, 300), velox::Timestamp(15, 300)}}},
+      // Ascending order in first column (by seconds)
+      {{{velox::Timestamp(1, 0),
+         velox::Timestamp(2, 0),
+         velox::Timestamp(3, 0)},
+        {velox::Timestamp(100, 0),
+         velox::Timestamp(100, 0),
+         velox::Timestamp(100, 0)},
+        {velox::Timestamp(50, 0),
+         velox::Timestamp(50, 0),
+         velox::Timestamp(50, 0)}}},
+      // Descending order in first column (by seconds)
+      {{{velox::Timestamp(10, 0),
+         velox::Timestamp(9, 0),
+         velox::Timestamp(8, 0)},
+        {velox::Timestamp(0, 0),
+         velox::Timestamp(0, 0),
+         velox::Timestamp(0, 0)},
+        {velox::Timestamp(5, 0),
+         velox::Timestamp(5, 0),
+         velox::Timestamp(5, 0)}}},
+      // Mixed positive and negative seconds
+      {{{velox::Timestamp(-5, 0),
+         velox::Timestamp(0, 0),
+         velox::Timestamp(5, 0)},
+        {velox::Timestamp(-10, 0),
+         velox::Timestamp(-5, 0),
+         velox::Timestamp(0, 0)},
+        {velox::Timestamp(10, 0),
+         velox::Timestamp(5, 0),
+         velox::Timestamp(0, 0)}}},
+      // Same seconds, different nanos
+      {{{velox::Timestamp(100, 1),
+         velox::Timestamp(100, 2),
+         velox::Timestamp(100, 3)},
+        {velox::Timestamp(200, 100),
+         velox::Timestamp(200, 200),
+         velox::Timestamp(200, 300)},
+        {velox::Timestamp(300, 999),
+         velox::Timestamp(300, 998),
+         velox::Timestamp(300, 997)}}},
+      // Edge values: valid min and max seconds for Timestamp
+      // kMinSeconds = INT64_MIN / 1000 - 1, kMaxSeconds = INT64_MAX / 1000
+      {{{velox::Timestamp::min(),
+         velox::Timestamp::max(),
+         velox::Timestamp(0, 0)},
+        {velox::Timestamp(-1, 0),
+         velox::Timestamp(0, 0),
+         velox::Timestamp(1, 0)},
+        {velox::Timestamp(100, 0),
+         velox::Timestamp(200, 0),
+         velox::Timestamp(300, 0)}}},
+      // All zeros
+      {{{velox::Timestamp(0, 0),
+         velox::Timestamp(0, 0),
+         velox::Timestamp(0, 0)},
+        {velox::Timestamp(0, 0),
+         velox::Timestamp(0, 0),
+         velox::Timestamp(0, 0)},
+        {velox::Timestamp(0, 0),
+         velox::Timestamp(0, 0),
+         velox::Timestamp(0, 0)}}},
+      // Duplicate values across rows
+      {{{velox::Timestamp(1, 100),
+         velox::Timestamp(2, 200),
+         velox::Timestamp(1, 100),
+         velox::Timestamp(2, 200)},
+        {velox::Timestamp(3, 300),
+         velox::Timestamp(3, 300),
+         velox::Timestamp(4, 400),
+         velox::Timestamp(4, 400)},
+        {velox::Timestamp(5, 500),
+         velox::Timestamp(5, 500),
+         velox::Timestamp(5, 500),
+         velox::Timestamp(5, 500)}}},
+      // Large spread of values
+      {{{velox::Timestamp(-1000000, 0),
+         velox::Timestamp(-1, 0),
+         velox::Timestamp(0, 0),
+         velox::Timestamp(1, 0),
+         velox::Timestamp(1000000, 0)},
+        {velox::Timestamp(999999, 0),
+         velox::Timestamp(500000, 0),
+         velox::Timestamp(0, 0),
+         velox::Timestamp(-500000, 0),
+         velox::Timestamp(-999999, 0)},
+        {velox::Timestamp(42, 0),
+         velox::Timestamp(42, 0),
+         velox::Timestamp(42, 0),
+         velox::Timestamp(42, 0),
+         velox::Timestamp(42, 0)}}},
+      // Values that differ only in last column
+      {{{velox::Timestamp(1, 0),
+         velox::Timestamp(1, 0),
+         velox::Timestamp(1, 0)},
+        {velox::Timestamp(2, 0),
+         velox::Timestamp(2, 0),
+         velox::Timestamp(2, 0)},
+        {velox::Timestamp(3, 0),
+         velox::Timestamp(4, 0),
+         velox::Timestamp(5, 0)}}},
+      // Values that differ only in first column
+      {{{velox::Timestamp(1, 0),
+         velox::Timestamp(2, 0),
+         velox::Timestamp(3, 0)},
+        {velox::Timestamp(100, 0),
+         velox::Timestamp(100, 0),
+         velox::Timestamp(100, 0)},
+        {velox::Timestamp(200, 0),
+         velox::Timestamp(200, 0),
+         velox::Timestamp(200, 0)}}},
+      // Nanos ordering within same second
+      {{{velox::Timestamp(1, 0),
+         velox::Timestamp(1, 500000000),
+         velox::Timestamp(1, 999999999)},
+        {velox::Timestamp(2, 999999999),
+         velox::Timestamp(2, 500000000),
+         velox::Timestamp(2, 0)},
+        {velox::Timestamp(3, 123456789),
+         velox::Timestamp(3, 123456789),
+         velox::Timestamp(3, 123456789)}}},
+      // All min values
+      {{{velox::Timestamp::min(),
+         velox::Timestamp::min(),
+         velox::Timestamp::min()},
+        {velox::Timestamp::min(),
+         velox::Timestamp::min(),
+         velox::Timestamp::min()},
+        {velox::Timestamp::min(),
+         velox::Timestamp::min(),
+         velox::Timestamp::min()}}},
+      // All max values
+      {{{velox::Timestamp::max(),
+         velox::Timestamp::max(),
+         velox::Timestamp::max()},
+        {velox::Timestamp::max(),
+         velox::Timestamp::max(),
+         velox::Timestamp::max()},
+        {velox::Timestamp::max(),
+         velox::Timestamp::max(),
+         velox::Timestamp::max()}}},
+      // Min to max range in single column
+      {{{velox::Timestamp::min(),
+         velox::Timestamp(0, 0),
+         velox::Timestamp::max()},
+        {velox::Timestamp::min(),
+         velox::Timestamp(0, 0),
+         velox::Timestamp::max()},
+        {velox::Timestamp::min(),
+         velox::Timestamp(0, 0),
+         velox::Timestamp::max()}}},
+      // Min and max with max nanos
+      {{{velox::Timestamp(velox::Timestamp::min().getSeconds(), 999999999),
+         velox::Timestamp(velox::Timestamp::max().getSeconds(), 999999999)},
+        {velox::Timestamp(velox::Timestamp::min().getSeconds(), 0),
+         velox::Timestamp(velox::Timestamp::max().getSeconds(), 0)},
+        {velox::Timestamp(0, 999999999), velox::Timestamp(0, 0)}}},
+      // Alternating min and max
+      {{{velox::Timestamp::min(),
+         velox::Timestamp::max(),
+         velox::Timestamp::min(),
+         velox::Timestamp::max()},
+        {velox::Timestamp::max(),
+         velox::Timestamp::min(),
+         velox::Timestamp::max(),
+         velox::Timestamp::min()},
+        {velox::Timestamp::min(),
+         velox::Timestamp::min(),
+         velox::Timestamp::max(),
+         velox::Timestamp::max()}}}};
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeFlatVector<velox::Timestamp>(testCase.columnValues[0]),
+         makeFlatVector<velox::Timestamp>(testCase.columnValues[1]),
+         makeFlatVector<velox::Timestamp>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    // Test all four sort orders
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, timestampTypeWithNulls) {
+  struct {
+    std::vector<std::vector<std::optional<velox::Timestamp>>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          if (column[row].has_value()) {
+            rowValues.push_back(column[row].value().toString());
+          } else {
+            rowValues.emplace_back("null");
+          }
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row with null
+      {{{std::nullopt}, {velox::Timestamp(1, 0)}, {velox::Timestamp(2, 0)}}},
+      // Single row without null (nullable type)
+      {{{velox::Timestamp(1, 0)},
+        {velox::Timestamp(2, 0)},
+        {velox::Timestamp(3, 0)}}},
+      // All nulls
+      {{{std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt}}},
+      // Null at beginning of first column
+      {{{std::nullopt, velox::Timestamp(1, 0), velox::Timestamp(2, 0)},
+        {velox::Timestamp(10, 0),
+         velox::Timestamp(20, 0),
+         velox::Timestamp(30, 0)},
+        {velox::Timestamp(100, 0),
+         velox::Timestamp(200, 0),
+         velox::Timestamp(300, 0)}}},
+      // Null at end of first column
+      {{{velox::Timestamp(1, 0), velox::Timestamp(2, 0), std::nullopt},
+        {velox::Timestamp(10, 0),
+         velox::Timestamp(20, 0),
+         velox::Timestamp(30, 0)},
+        {velox::Timestamp(100, 0),
+         velox::Timestamp(200, 0),
+         velox::Timestamp(300, 0)}}},
+      // Null in middle of first column
+      {{{velox::Timestamp(1, 0), std::nullopt, velox::Timestamp(2, 0)},
+        {velox::Timestamp(10, 0),
+         velox::Timestamp(20, 0),
+         velox::Timestamp(30, 0)},
+        {velox::Timestamp(100, 0),
+         velox::Timestamp(200, 0),
+         velox::Timestamp(300, 0)}}},
+      // Nulls in all positions across different columns
+      {{{std::nullopt,
+         velox::Timestamp(1, 0),
+         velox::Timestamp(2, 0),
+         velox::Timestamp(3, 0)},
+        {velox::Timestamp(1, 0),
+         std::nullopt,
+         velox::Timestamp(2, 0),
+         velox::Timestamp(3, 0)},
+        {velox::Timestamp(1, 0),
+         velox::Timestamp(2, 0),
+         std::nullopt,
+         velox::Timestamp(3, 0)}}},
+      // Multiple nulls in same row
+      {{{std::nullopt, velox::Timestamp(1, 0), velox::Timestamp(2, 0)},
+        {std::nullopt, velox::Timestamp(10, 0), velox::Timestamp(20, 0)},
+        {std::nullopt, velox::Timestamp(100, 0), velox::Timestamp(200, 0)}}},
+      // Alternating nulls and values
+      {{{std::nullopt,
+         velox::Timestamp(1, 0),
+         std::nullopt,
+         velox::Timestamp(2, 0)},
+        {velox::Timestamp(10, 0),
+         std::nullopt,
+         velox::Timestamp(20, 0),
+         std::nullopt},
+        {std::nullopt,
+         velox::Timestamp(100, 0),
+         std::nullopt,
+         velox::Timestamp(200, 0)}}},
+      // Nulls with valid edge values for Timestamp
+      // kMinSeconds = INT64_MIN / 1000 - 1, kMaxSeconds = INT64_MAX / 1000
+      {{{std::nullopt, velox::Timestamp::min(), velox::Timestamp::max()},
+        {velox::Timestamp(0, 0), std::nullopt, velox::Timestamp(1, 0)},
+        {velox::Timestamp(-1, 0), velox::Timestamp(0, 0), std::nullopt}}},
+      // Null with varying nanos
+      {{{std::nullopt,
+         velox::Timestamp(1, 100),
+         velox::Timestamp(1, 200),
+         velox::Timestamp(1, 300)},
+        {velox::Timestamp(2, 100),
+         std::nullopt,
+         velox::Timestamp(2, 200),
+         velox::Timestamp(2, 300)},
+        {velox::Timestamp(3, 100),
+         velox::Timestamp(3, 200),
+         std::nullopt,
+         velox::Timestamp(3, 300)}}},
+      // Dense nulls at boundaries
+      {{{std::nullopt,
+         std::nullopt,
+         velox::Timestamp(1, 0),
+         velox::Timestamp(2, 0),
+         std::nullopt,
+         std::nullopt},
+        {velox::Timestamp(10, 0),
+         velox::Timestamp(20, 0),
+         std::nullopt,
+         std::nullopt,
+         velox::Timestamp(30, 0),
+         velox::Timestamp(40, 0)},
+        {std::nullopt,
+         velox::Timestamp(100, 0),
+         std::nullopt,
+         velox::Timestamp(200, 0),
+         std::nullopt,
+         velox::Timestamp(300, 0)}}},
+      // All min values with some nulls
+      {{{velox::Timestamp::min(), std::nullopt, velox::Timestamp::min()},
+        {std::nullopt, velox::Timestamp::min(), velox::Timestamp::min()},
+        {velox::Timestamp::min(), velox::Timestamp::min(), std::nullopt}}},
+      // All max values with some nulls
+      {{{velox::Timestamp::max(), std::nullopt, velox::Timestamp::max()},
+        {std::nullopt, velox::Timestamp::max(), velox::Timestamp::max()},
+        {velox::Timestamp::max(), velox::Timestamp::max(), std::nullopt}}},
+      // Min to max range with nulls
+      {{{std::nullopt,
+         velox::Timestamp::min(),
+         velox::Timestamp(0, 0),
+         velox::Timestamp::max()},
+        {velox::Timestamp::min(),
+         std::nullopt,
+         velox::Timestamp(0, 0),
+         velox::Timestamp::max()},
+        {velox::Timestamp::min(),
+         velox::Timestamp(0, 0),
+         std::nullopt,
+         velox::Timestamp::max()}}},
+      // Min and max with max nanos and nulls
+      {{{std::nullopt,
+         velox::Timestamp(velox::Timestamp::min().getSeconds(), 999999999),
+         velox::Timestamp(velox::Timestamp::max().getSeconds(), 999999999)},
+        {velox::Timestamp(velox::Timestamp::min().getSeconds(), 0),
+         std::nullopt,
+         velox::Timestamp(velox::Timestamp::max().getSeconds(), 0)},
+        {velox::Timestamp(0, 999999999),
+         velox::Timestamp(0, 0),
+         std::nullopt}}},
+      // Alternating min, max and nulls
+      {{{velox::Timestamp::min(),
+         std::nullopt,
+         velox::Timestamp::max(),
+         std::nullopt},
+        {std::nullopt,
+         velox::Timestamp::max(),
+         std::nullopt,
+         velox::Timestamp::min()},
+        {velox::Timestamp::max(),
+         velox::Timestamp::min(),
+         std::nullopt,
+         std::nullopt}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeNullableFlatVector<velox::Timestamp>(testCase.columnValues[0]),
+         makeNullableFlatVector<velox::Timestamp>(testCase.columnValues[1]),
+         makeNullableFlatVector<velox::Timestamp>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    // Test all four sort orders (ASC/DESC x NULLS FIRST/NULLS LAST)
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, keyColumnsOutOfOrder) {
+  // Create a dataset with multiple columns of different types
+  // Columns: BIGINT, VARCHAR, DOUBLE, BOOLEAN, INTEGER, SMALLINT
+  const auto input = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4, 5}), // c0: BIGINT
+      makeFlatVector<std::string>(
+          {"apple", "banana", "cherry", "date", "elderberry"}), // c1: VARCHAR
+      makeFlatVector<double>({1.5, 2.5, 3.5, 4.5, 5.5}), // c2: DOUBLE
+      makeFlatVector<bool>({true, false, true, false, true}), // c3: BOOLEAN
+      makeFlatVector<int32_t>({10, 20, 30, 40, 50}), // c4: INTEGER
+      makeFlatVector<int16_t>({100, 200, 300, 400, 500}), // c5: SMALLINT
+  });
+
+  // Test various key column orderings to ensure KeyEncoder works correctly
+  // regardless of column order
+
+  // Original order - all columns
+  {
+    SCOPED_TRACE("Original order - all columns");
+    const std::vector<std::string> keyColumns = {
+        "c0", "c1", "c2", "c3", "c4", "c5"};
+    encodeTest({input}, keyColumns);
+  }
+
+  // Reverse order - all columns
+  {
+    SCOPED_TRACE("Reverse order - all columns");
+    const std::vector<std::string> keyColumns = {
+        "c5", "c4", "c3", "c2", "c1", "c0"};
+    encodeTest({input}, keyColumns);
+  }
+
+  // Random order - subset of columns
+  {
+    SCOPED_TRACE("Random order - subset of columns");
+    const std::vector<std::string> keyColumns = {"c2", "c5", "c0", "c3"};
+    encodeTest({input}, keyColumns);
+  }
+
+  // Another random order - different subset
+  {
+    SCOPED_TRACE("Another random order - different subset");
+    const std::vector<std::string> keyColumns = {"c4", "c1", "c3"};
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, errorNonExistentColumn) {
+  const auto input = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      makeFlatVector<int32_t>({4, 5, 6}),
+  });
+
+  const std::vector<std::string> keyColumns = {"c0", "nonexistent"};
+  const std::vector<velox::core::SortOrder> sortOrders = {
+      velox::core::kAscNullsFirst, velox::core::kAscNullsFirst};
+
+  VELOX_ASSERT_THROW(
+      KeyEncoder::create(
+          keyColumns, asRowType(input->type()), sortOrders, pool_.get()),
+      "Field not found");
+}
+
+TEST_F(KeyEncoderTest, errorMismatchedSortOrders) {
+  const auto input = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      makeFlatVector<int32_t>({4, 5, 6}),
+  });
+
+  const std::vector<std::string> keyColumns = {"c0", "c1"};
+  const std::vector<velox::core::SortOrder> sortOrders = {
+      velox::core::kAscNullsFirst}; // Only one sort order for two columns
+
+  VELOX_ASSERT_THROW(
+      KeyEncoder::create(
+          keyColumns, asRowType(input->type()), sortOrders, pool_.get()),
+      "Size mismatch");
+}
+
+TEST_F(KeyEncoderTest, errorEmptyKeyColumns) {
+  const auto input = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      makeFlatVector<int32_t>({4, 5, 6}),
+  });
+
+  const std::vector<std::string> keyColumns = {}; // Empty key columns
+  const std::vector<velox::core::SortOrder> sortOrders = {};
+
+  VELOX_ASSERT_THROW(
+      KeyEncoder::create(
+          keyColumns, asRowType(input->type()), sortOrders, pool_.get()),
+      "");
+}
+
+TEST_F(KeyEncoderTest, sortOrders) {
+  const auto input = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      makeFlatVector<int32_t>({4, 5, 6}),
+      makeFlatVector<std::string>({"a", "b", "c"}),
+  });
+
+  // Single column with different sort orders.
+  {
+    const std::vector<std::string> keyColumns = {"c0"};
+    for (const auto& sortOrder :
+         {velox::core::kAscNullsFirst,
+          velox::core::kAscNullsLast,
+          velox::core::kDescNullsFirst,
+          velox::core::kDescNullsLast}) {
+      const std::vector<velox::core::SortOrder> sortOrders = {sortOrder};
+      auto keyEncoder = KeyEncoder::create(
+          keyColumns, asRowType(input->type()), sortOrders, pool_.get());
+      ASSERT_EQ(keyEncoder->sortOrders().size(), 1);
+      EXPECT_EQ(keyEncoder->sortOrders()[0], sortOrder);
+    }
+  }
+
+  // Multiple columns with different sort orders.
+  {
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+    const std::vector<velox::core::SortOrder> sortOrders = {
+        velox::core::kAscNullsFirst,
+        velox::core::kDescNullsLast,
+        velox::core::kAscNullsLast,
+    };
+    auto keyEncoder = KeyEncoder::create(
+        keyColumns, asRowType(input->type()), sortOrders, pool_.get());
+    ASSERT_EQ(keyEncoder->sortOrders().size(), 3);
+    EXPECT_EQ(keyEncoder->sortOrders()[0], velox::core::kAscNullsFirst);
+    EXPECT_EQ(keyEncoder->sortOrders()[1], velox::core::kDescNullsLast);
+    EXPECT_EQ(keyEncoder->sortOrders()[2], velox::core::kAscNullsLast);
+  }
+}
+
+TEST_F(KeyEncoderTest, unsupportedIndexColumnType) {
+  // Test ARRAY type
+  {
+    const auto input = makeRowVector({
+        makeArrayVector<int64_t>({{1, 2}, {3, 4}, {5, 6}}),
+    });
+
+    const std::vector<std::string> keyColumns = {"c0"};
+    const std::vector<velox::core::SortOrder> sortOrders = {
+        velox::core::kAscNullsFirst};
+
+    VELOX_ASSERT_THROW(
+        KeyEncoder::create(
+            keyColumns, asRowType(input->type()), sortOrders, pool_.get()),
+        "Unsupported type for index column 'c0': ARRAY<BIGINT>");
+  }
+
+  // Test MAP type
+  {
+    auto input = makeRowVector({
+        makeMapVector<int64_t, int64_t>({{{1, 2}, {3, 4}}, {{5, 6}}}),
+    });
+
+    const std::vector<std::string> keyColumns = {"c0"};
+    const std::vector<velox::core::SortOrder> sortOrders = {
+        velox::core::kAscNullsFirst};
+
+    VELOX_ASSERT_THROW(
+        KeyEncoder::create(
+            keyColumns, asRowType(input->type()), sortOrders, pool_.get()),
+        "Unsupported type for index column 'c0': MAP<BIGINT,BIGINT>");
+  }
+
+  // Test ROW (struct) type
+  {
+    auto input = makeRowVector({
+        makeRowVector({
+            makeFlatVector<int64_t>({1, 2, 3}),
+            makeFlatVector<int32_t>({4, 5, 6}),
+        }),
+    });
+
+    const std::vector<std::string> keyColumns = {"c0"};
+    const std::vector<velox::core::SortOrder> sortOrders = {
+        velox::core::kAscNullsFirst};
+
+    VELOX_ASSERT_THROW(
+        KeyEncoder::create(
+            keyColumns, asRowType(input->type()), sortOrders, pool_.get()),
+        "Unsupported type for index column 'c0': ROW<c0:BIGINT,c1:INTEGER>");
+  }
+
+  // Test UNKNOWN type
+  {
+    auto input = makeRowVector({
+        velox::BaseVector::createNullConstant(velox::UNKNOWN(), 3, pool_.get()),
+    });
+
+    const std::vector<std::string> keyColumns = {"c0"};
+    const std::vector<velox::core::SortOrder> sortOrders = {
+        velox::core::kAscNullsFirst};
+
+    VELOX_ASSERT_THROW(
+        KeyEncoder::create(
+            keyColumns, asRowType(input->type()), sortOrders, pool_.get()),
+        "Unsupported type for index column 'c0': UNKNOWN");
+  }
+
+  // Test OPAQUE type
+  {
+    // Define a simple test class for opaque type
+    class TestOpaqueClass {};
+
+    // Create an opaque type vector
+    auto opaqueType = velox::OpaqueType::create<TestOpaqueClass>();
+    auto opaqueValue = std::make_shared<TestOpaqueClass>();
+    auto opaqueVector = velox::BaseVector::createConstant(
+        opaqueType, velox::variant::opaque(opaqueValue), 3, pool_.get());
+
+    auto input = makeRowVector({opaqueVector});
+
+    const std::vector<std::string> keyColumns = {"c0"};
+    const std::vector<velox::core::SortOrder> sortOrders = {
+        velox::core::kAscNullsFirst};
+
+    VELOX_ASSERT_THROW(
+        KeyEncoder::create(
+            keyColumns, asRowType(input->type()), sortOrders, pool_.get()),
+        "Unsupported type for index column 'c0': OPAQUE");
+  }
+
+  // Test HUGEINT type
+  {
+    using HugeintType = velox::TypeTraits<velox::TypeKind::HUGEINT>::NativeType;
+    auto input = makeRowVector({
+        makeFlatVector<HugeintType>({0, 1}),
+    });
+
+    const std::vector<std::string> keyColumns = {"c0"};
+    const std::vector<velox::core::SortOrder> sortOrders = {
+        velox::core::kAscNullsFirst};
+
+    VELOX_ASSERT_THROW(
+        KeyEncoder::create(
+            keyColumns, asRowType(input->type()), sortOrders, pool_.get()),
+        "Unsupported type for index column 'c0': HUGEINT");
+  }
+}
+
+TEST_F(KeyEncoderTest, encodeFuzz) {
+  // Seed for deterministic testing
+  const size_t seed = 123456;
+
+  // Supported scalar types for KeyEncoder (excluding complex types like
+  // arrays/maps)
+  const std::vector<velox::TypePtr> supportedTypes = {
+      velox::BIGINT(),
+      velox::INTEGER(),
+      velox::SMALLINT(),
+      velox::TINYINT(),
+      velox::DOUBLE(),
+      velox::REAL(),
+      velox::BOOLEAN(),
+      velox::VARCHAR(),
+      velox::DATE(),
+      velox::TIMESTAMP()};
+
+  // VectorFuzzer options
+  velox::VectorFuzzer::Options options;
+  options.vectorSize = 100;
+  options.nullRatio = 0.2; // 20% nulls
+  options.stringLength = 50;
+  options.stringVariableLength = true;
+  options.containerLength = 10;
+  options.containerVariableLength = true;
+  options.allowLazyVector = true;
+  options.allowSlice = true;
+  options.allowConstantVector = true;
+  options.allowDictionaryVector = true;
+
+  // Run fuzzer iterations
+  const int numIterations = 50;
+  for (int iter = 0; iter < numIterations; ++iter) {
+    // Create fuzzer with iteration-specific seed for variation
+    velox::VectorFuzzer fuzzer(options, pool_.get(), seed + iter);
+
+    // Generate random number of columns (1 to 5)
+    const size_t numColumns = fuzzer.randInRange(1, 5);
+
+    // Generate random row type with supported scalar types
+    std::vector<std::string> columnNames;
+    std::vector<velox::TypePtr> columnTypes;
+    for (size_t i = 0; i < numColumns; ++i) {
+      columnNames.push_back(fmt::format("c{}", i));
+      // Pick a random supported type
+      const size_t typeIndex = fuzzer.randInRange(0, supportedTypes.size() - 1);
+      columnTypes.push_back(supportedTypes[typeIndex]);
+    }
+
+    // Create row type
+    auto rowType = velox::ROW(std::move(columnNames), std::move(columnTypes));
+
+    // Generate multiple input vectors with different encodings (3 to 10
+    // vectors per iteration)
+    const size_t numInputVectors = fuzzer.randInRange(3, 10);
+    std::vector<velox::RowVectorPtr> inputs;
+    inputs.reserve(numInputVectors);
+
+    for (size_t i = 0; i < numInputVectors; ++i) {
+      // Use fuzzInputRow which generates RowVectors without top-level
+      // nulls (i.e., no null rows, only nullable child vectors)
+      inputs.push_back(fuzzer.fuzzInputRow(rowType));
+    }
+
+    SCOPED_TRACE(
+        fmt::format(
+            "Iteration {}: {} input vectors, {} columns, types: [{}]",
+            iter,
+            numInputVectors,
+            numColumns,
+            folly::join(", ", rowType->names())));
+
+    // Create key column names
+    // 80% of the time: randomize the order
+    // 20% of the time: follow the same order as input vector columns
+    std::vector<std::string> keyColumns;
+    keyColumns.reserve(numColumns);
+    for (size_t i = 0; i < numColumns; ++i) {
+      keyColumns.push_back(fmt::format("c{}", i));
+    }
+
+    // Randomize key column order 80% of the time
+    if (fuzzer.coinToss(0.8)) {
+      // Shuffle the key columns to test if KeyEncoder can handle
+      // different orders
+      std::mt19937 rng(seed + iter + 1000);
+      std::shuffle(keyColumns.begin(), keyColumns.end(), rng);
+      SCOPED_TRACE(
+          fmt::format(
+              "Randomized key column order: [{}]",
+              folly::join(", ", keyColumns)));
+    } else {
+      SCOPED_TRACE("Using original key column order (same as input vector)");
+    }
+
+    // Test all input vectors with the same KeyEncoder configuration
+    encodeTest(inputs, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, encodeIndexBoundsWithBigIntType) {
+  // Test Case 1: Both bounds inclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{.bound = makeBigIntRow(10), .inclusive = true},
+        IndexBound{.bound = makeBigIntRow(100), .inclusive = true},
+        makeBigIntRow(10), // ASC_NULLS_FIRST lower
+        makeBigIntRow(101), // ASC_NULLS_FIRST upper
+        makeBigIntRow(10), // ASC_NULLS_LAST lower
+        makeBigIntRow(101), // ASC_NULLS_LAST upper
+        makeBigIntRow(10), // DESC_NULLS_FIRST lower
+        makeBigIntRow(99), // DESC_NULLS_FIRST upper
+        makeBigIntRow(10), // DESC_NULLS_LAST lower
+        makeBigIntRow(99)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 2: Both bounds exclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{.bound = makeBigIntRow(10), .inclusive = false},
+        IndexBound{.bound = makeBigIntRow(100), .inclusive = false},
+        makeBigIntRow(11), // ASC_NULLS_FIRST lower
+        makeBigIntRow(100), // ASC_NULLS_FIRST upper
+        makeBigIntRow(11), // ASC_NULLS_LAST lower
+        makeBigIntRow(100), // ASC_NULLS_LAST upper
+        makeBigIntRow(9), // DESC_NULLS_FIRST lower
+        makeBigIntRow(100), // DESC_NULLS_FIRST upper
+        makeBigIntRow(9), // DESC_NULLS_LAST lower
+        makeBigIntRow(100)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 3: Lower inclusive, upper exclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{.bound = makeBigIntRow(10), .inclusive = true},
+        IndexBound{.bound = makeBigIntRow(100), .inclusive = false},
+        makeBigIntRow(10), // ASC_NULLS_FIRST lower
+        makeBigIntRow(100), // ASC_NULLS_FIRST upper
+        makeBigIntRow(10), // ASC_NULLS_LAST lower
+        makeBigIntRow(100), // ASC_NULLS_LAST upper
+        makeBigIntRow(10), // DESC_NULLS_FIRST lower
+        makeBigIntRow(100), // DESC_NULLS_FIRST upper
+        makeBigIntRow(10), // DESC_NULLS_LAST lower
+        makeBigIntRow(100)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 4: Only lower bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{.bound = makeBigIntRow(10), .inclusive = true},
+        std::nullopt,
+        makeBigIntRow(10), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeBigIntRow(10), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeBigIntRow(10), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeBigIntRow(10), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 5: Only upper bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        std::nullopt,
+        IndexBound{.bound = makeBigIntRow(100), .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeBigIntRow(101), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeBigIntRow(101), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeBigIntRow(99), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeBigIntRow(99)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 6: Multi-column, both inclusive
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{.bound = makeBigIntRow(10, 20), .inclusive = true},
+        IndexBound{.bound = makeBigIntRow(100, 100), .inclusive = true},
+        makeBigIntRow(10, 20), // ASC_NULLS_FIRST lower
+        makeBigIntRow(100, 101), // ASC_NULLS_FIRST upper
+        makeBigIntRow(10, 20), // ASC_NULLS_LAST lower
+        makeBigIntRow(100, 101), // ASC_NULLS_LAST upper
+        makeBigIntRow(10, 20), // DESC_NULLS_FIRST lower
+        makeBigIntRow(100, 99), // DESC_NULLS_FIRST upper
+        makeBigIntRow(10, 20), // DESC_NULLS_LAST lower
+        makeBigIntRow(100, 99)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 7-1: Upper bound at max value (overflow case)
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{.bound = makeBigIntRow(0), .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int64_t>(
+                {std::numeric_limits<int64_t>::max()})}),
+            .inclusive = true},
+        makeBigIntRow(0), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        makeBigIntRow(0), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeBigIntRow(0), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int64_t>(
+            {std::numeric_limits<int64_t>::max() -
+             1})}), // DESC_NULLS_FIRST upper
+        makeBigIntRow(0), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int64_t>(
+            {std::numeric_limits<int64_t>::max() -
+             1})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 7-2: Upper bound at max value (overflow case)
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{.bound = makeBigIntRow(0), .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int64_t>(
+                {std::numeric_limits<int64_t>::min()})}),
+            .inclusive = true},
+        makeBigIntRow(0), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int64_t>(
+            {std::numeric_limits<int64_t>::min() +
+             1})}), // ASC_NULLS_FIRST upper (overflow)
+        makeBigIntRow(0), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int64_t>(
+            {std::numeric_limits<int64_t>::min() +
+             1})}), // ASC_NULLS_LAST upper (overflow)
+        makeBigIntRow(0), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeBigIntRow(0), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 8: Only lower bound, exclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{.bound = makeBigIntRow(10), .inclusive = false},
+        std::nullopt,
+        makeBigIntRow(11), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeBigIntRow(11), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeBigIntRow(9), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeBigIntRow(9), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 9: Only upper bound, exclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        std::nullopt,
+        IndexBound{.bound = makeBigIntRow(100), .inclusive = false},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeBigIntRow(100), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeBigIntRow(100), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeBigIntRow(100), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeBigIntRow(100)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 10: Multi-column, both exclusive
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{.bound = makeBigIntRow(10, 20), .inclusive = false},
+        IndexBound{.bound = makeBigIntRow(100, 100), .inclusive = false},
+        makeBigIntRow(10, 21), // ASC_NULLS_FIRST lower
+        makeBigIntRow(100, 100), // ASC_NULLS_FIRST upper
+        makeBigIntRow(10, 21), // ASC_NULLS_LAST lower
+        makeBigIntRow(100, 100), // ASC_NULLS_LAST upper
+        makeBigIntRow(10, 19), // DESC_NULLS_FIRST lower
+        makeBigIntRow(100, 100), // DESC_NULLS_FIRST upper
+        makeBigIntRow(10, 19), // DESC_NULLS_LAST lower
+        makeBigIntRow(100, 100)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 11: Multi-column, lower inclusive upper exclusive
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{.bound = makeBigIntRow(10, 20), .inclusive = true},
+        IndexBound{.bound = makeBigIntRow(100, 100), .inclusive = false},
+        makeBigIntRow(10, 20), // ASC_NULLS_FIRST lower
+        makeBigIntRow(100, 100), // ASC_NULLS_FIRST upper
+        makeBigIntRow(10, 20), // ASC_NULLS_LAST lower
+        makeBigIntRow(100, 100), // ASC_NULLS_LAST upper
+        makeBigIntRow(10, 20), // DESC_NULLS_FIRST lower
+        makeBigIntRow(100, 100), // DESC_NULLS_FIRST upper
+        makeBigIntRow(10, 20), // DESC_NULLS_LAST lower
+        makeBigIntRow(100, 100)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 12: Multi-column, only lower bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{.bound = makeBigIntRow(10, 20), .inclusive = true},
+        std::nullopt,
+        makeBigIntRow(10, 20), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeBigIntRow(10, 20), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeBigIntRow(10, 20), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeBigIntRow(10, 20), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 13: Multi-column, only upper bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        std::nullopt,
+        IndexBound{.bound = makeBigIntRow(100, 100), .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeBigIntRow(100, 101), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeBigIntRow(100, 101), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeBigIntRow(100, 99), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeBigIntRow(100, 99)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 14-1: Multi-column at max values (overflow)
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{.bound = makeBigIntRow(0, 0), .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({1}),
+                 makeFlatVector<int64_t>(
+                     {std::numeric_limits<int64_t>::max()})}),
+            .inclusive = true},
+        makeBigIntRow(0, 0), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({2}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::min()})}), // ASC_NULLS_FIRST
+                                                           // upper
+        makeBigIntRow(0, 0), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({2}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::min()})}), // ASC_NULLS_LAST
+                                                           // upper
+        makeBigIntRow(0, 0), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({1}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::max() -
+                  1})}), // DESC_NULLS_FIRST upper
+        makeBigIntRow(0, 0), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({1}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::max() -
+                  1})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 14-2: Multi-column at max values
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{.bound = makeBigIntRow(0, 0), .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({1}),
+                 makeFlatVector<int64_t>(
+                     {std::numeric_limits<int64_t>::min()})}),
+            .inclusive = true},
+        makeBigIntRow(0, 0), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({1}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::min() +
+                  1})}), // ASC_NULLS_FIRST
+                         // upper
+        makeBigIntRow(0, 0), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({1}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::min() + 1})}), // ASC_NULLS_LAST
+                                                               // upper
+        makeBigIntRow(0, 0), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({0}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::max()})}), // DESC_NULLS_FIRST
+                                                           // upper
+        makeBigIntRow(0, 0), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({0}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::max()})})); // DESC_NULLS_LAST
+                                                            // upper
+  }
+
+  // Test Case 14-3: Multi-column at max values (overflow)
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{.bound = makeBigIntRow(0, 0), .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({std::numeric_limits<int64_t>::max()}),
+                 makeFlatVector<int64_t>(
+                     {std::numeric_limits<int64_t>::max()})}),
+            .inclusive = true},
+        makeBigIntRow(0, 0), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        makeBigIntRow(0, 0), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeBigIntRow(0, 0), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({std::numeric_limits<int64_t>::max()}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::max() -
+                  1})}), // DESC_NULLS_FIRST upper
+        makeBigIntRow(0, 0), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({std::numeric_limits<int64_t>::max()}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::max() -
+                  1})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 15: Multi-column, only lower bound, exclusive
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{.bound = makeBigIntRow(10, 20), .inclusive = false},
+        std::nullopt,
+        makeBigIntRow(10, 21), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeBigIntRow(10, 21), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeBigIntRow(10, 19), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeBigIntRow(10, 19), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 16: Multi-column, only upper bound, exclusive
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        std::nullopt,
+        IndexBound{.bound = makeBigIntRow(100, 100), .inclusive = false},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeBigIntRow(100, 100), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeBigIntRow(100, 100), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeBigIntRow(100, 100), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeBigIntRow(100, 100)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 17: Single column with null in lower bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int64_t>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{.bound = makeBigIntRow(100), .inclusive = true},
+        makeRowVector({makeNullableFlatVector<int64_t>(
+            {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeBigIntRow(101), // ASC_NULLS_FIRST upper
+        makeRowVector({makeNullableFlatVector<int64_t>(
+            {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeBigIntRow(101), // ASC_NULLS_LAST upper
+        makeRowVector({makeNullableFlatVector<int64_t>(
+            {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeBigIntRow(99), // DESC_NULLS_FIRST upper
+        makeRowVector({makeNullableFlatVector<int64_t>(
+            {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeBigIntRow(99)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 18: Single column with null in upper bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{.bound = makeBigIntRow(10), .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int64_t>({std::nullopt})}),
+            .inclusive = true},
+        makeBigIntRow(10), // ASC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<int64_t>(
+            {std::numeric_limits<int64_t>::min()})}), // ASC_NULLS_FIRST upper
+        makeBigIntRow(10), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeBigIntRow(10), // DESC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<int64_t>(
+            {std::numeric_limits<int64_t>::max()})}), // DESC_NULLS_FIRST upper
+        makeBigIntRow(10), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 19: Multi-column with null in first column of lower bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int64_t>({std::nullopt}),
+                 makeFlatVector<int64_t>({20})}),
+            .inclusive = true},
+        IndexBound{.bound = makeBigIntRow(100, 100), .inclusive = true},
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({20})}), // ASC_NULLS_FIRST lower
+        makeBigIntRow(100, 101), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({20})}), // ASC_NULLS_LAST lower
+        makeBigIntRow(100, 101), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({20})}), // DESC_NULLS_FIRST lower
+        makeBigIntRow(100, 99), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({20})}), // DESC_NULLS_LAST lower
+        makeBigIntRow(100, 99)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 20: Multi-column with null in second column of lower bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({10}),
+                 makeNullableFlatVector<int64_t>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{.bound = makeBigIntRow(100, 100), .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeNullableFlatVector<int64_t>(
+                 {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeBigIntRow(100, 101), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeNullableFlatVector<int64_t>(
+                 {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeBigIntRow(100, 101), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeNullableFlatVector<int64_t>(
+                 {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeBigIntRow(100, 99), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeNullableFlatVector<int64_t>(
+                 {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeBigIntRow(100, 99)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 21: Multi-column with null in first column of upper bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{.bound = makeBigIntRow(10, 20), .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int64_t>({std::nullopt}),
+                 makeFlatVector<int64_t>({100})}),
+            .inclusive = true},
+        makeBigIntRow(10, 20), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({101})}), // ASC_NULLS_FIRST upper
+        makeBigIntRow(10, 20), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({101})}), // ASC_NULLS_LAST upper
+        makeBigIntRow(10, 20), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({99})}), // DESC_NULLS_FIRST upper
+        makeBigIntRow(10, 20), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({99})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 22: Multi-column with null in second column of upper bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{.bound = makeBigIntRow(10, 20), .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({100}),
+                 makeNullableFlatVector<int64_t>({std::nullopt})}),
+            .inclusive = true},
+        makeBigIntRow(10, 20), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeNullableFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::min()})}), // ASC_NULLS_FIRST
+                                                           // upper
+        makeBigIntRow(10, 20), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({101}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::min()})}), // ASC_NULLS_LAST
+                                                           // upper
+        makeBigIntRow(10, 20), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeNullableFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::max()})}), // DESC_NULLS_FIRST
+                                                           // upper
+        makeBigIntRow(10, 20), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({99}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::max()})})); // DESC_NULLS_LAST
+                                                            // upper
+  }
+
+  // Test Case 23: Both bounds with nulls in different columns
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int64_t>({std::nullopt}),
+                 makeFlatVector<int64_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({100}),
+                 makeNullableFlatVector<int64_t>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeNullableFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::min()})}), // ASC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({101}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::min()})}), // ASC_NULLS_LAST
+                                                           // upper
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeNullableFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::max()})}), // DESC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({99}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::max()})})); // DESC_NULLS_LAST
+                                                            // upper
+  }
+
+  // Test lower bound bump failures
+  // Test Case 24-1: Single column lower bound bump failure - exclusive bound
+  // at max value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeBigIntRow(std::numeric_limits<int64_t>::max()),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsFirst;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+  // Test Case 24-2: Single column lower bound bump failure - exclusive bound
+  // at max value with null.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound =
+            makeRowVector({makeNullableFlatVector<int64_t>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 25-1: Multiple columns lower bound bump failure - all columns
+  // at max value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeBigIntRow(
+            std::numeric_limits<int64_t>::max(),
+            std::numeric_limits<int64_t>::max()),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+  // Test Case 25-2: Multiple columns lower bound bump failure - all columns
+  // at max value with null.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeNullableFlatVector<int64_t>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+}
+
+TEST_F(KeyEncoderTest, encodeIndexBoundsWithIntegerType) {
+  // Test Case 1: Both bounds inclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{.bound = makeIntRow(10), .inclusive = true},
+        IndexBound{.bound = makeIntRow(100), .inclusive = true},
+        makeIntRow(10), // ASC_NULLS_FIRST lower
+        makeIntRow(101), // ASC_NULLS_FIRST upper
+        makeIntRow(10), // ASC_NULLS_LAST lower
+        makeIntRow(101), // ASC_NULLS_LAST upper
+        makeIntRow(10), // DESC_NULLS_FIRST lower
+        makeIntRow(99), // DESC_NULLS_FIRST upper
+        makeIntRow(10), // DESC_NULLS_LAST lower
+        makeIntRow(99)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 2: Both bounds exclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{.bound = makeIntRow(10), .inclusive = false},
+        IndexBound{.bound = makeIntRow(100), .inclusive = false},
+        makeIntRow(11), // ASC_NULLS_FIRST lower
+        makeIntRow(100), // ASC_NULLS_FIRST upper
+        makeIntRow(11), // ASC_NULLS_LAST lower
+        makeIntRow(100), // ASC_NULLS_LAST upper
+        makeIntRow(9), // DESC_NULLS_FIRST lower
+        makeIntRow(100), // DESC_NULLS_FIRST upper
+        makeIntRow(9), // DESC_NULLS_LAST lower
+        makeIntRow(100)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 3: Lower inclusive, upper exclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{.bound = makeIntRow(10), .inclusive = true},
+        IndexBound{.bound = makeIntRow(100), .inclusive = false},
+        makeIntRow(10), // ASC_NULLS_FIRST lower
+        makeIntRow(100), // ASC_NULLS_FIRST upper
+        makeIntRow(10), // ASC_NULLS_LAST lower
+        makeIntRow(100), // ASC_NULLS_LAST upper
+        makeIntRow(10), // DESC_NULLS_FIRST lower
+        makeIntRow(100), // DESC_NULLS_FIRST upper
+        makeIntRow(10), // DESC_NULLS_LAST lower
+        makeIntRow(100)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 4: Only lower bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{.bound = makeIntRow(10), .inclusive = true},
+        std::nullopt,
+        makeIntRow(10), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeIntRow(10), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeIntRow(10), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeIntRow(10), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 5: Only upper bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        std::nullopt,
+        IndexBound{.bound = makeIntRow(100), .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeIntRow(101), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeIntRow(101), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeIntRow(99), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeIntRow(99)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 6: Multi-column, both inclusive
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{.bound = makeIntRow(10, 20), .inclusive = true},
+        IndexBound{.bound = makeIntRow(100, 100), .inclusive = true},
+        makeIntRow(10, 20), // ASC_NULLS_FIRST lower
+        makeIntRow(100, 101), // ASC_NULLS_FIRST upper
+        makeIntRow(10, 20), // ASC_NULLS_LAST lower
+        makeIntRow(100, 101), // ASC_NULLS_LAST upper
+        makeIntRow(10, 20), // DESC_NULLS_FIRST lower
+        makeIntRow(100, 99), // DESC_NULLS_FIRST upper
+        makeIntRow(10, 20), // DESC_NULLS_LAST lower
+        makeIntRow(100, 99)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 7-1: Upper bound at max value (overflow case)
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{.bound = makeIntRow(0), .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int32_t>(
+                {std::numeric_limits<int32_t>::max()})}),
+            .inclusive = true},
+        makeIntRow(0), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        makeIntRow(0), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeIntRow(0), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int32_t>(
+            {std::numeric_limits<int32_t>::max() -
+             1})}), // DESC_NULLS_FIRST upper
+        makeIntRow(0), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int32_t>(
+            {std::numeric_limits<int32_t>::max() -
+             1})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 7-2: Upper bound at min value (overflow case)
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{.bound = makeIntRow(0), .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int32_t>(
+                {std::numeric_limits<int32_t>::min()})}),
+            .inclusive = true},
+        makeIntRow(0), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int32_t>(
+            {std::numeric_limits<int32_t>::min() +
+             1})}), // ASC_NULLS_FIRST upper (overflow)
+        makeIntRow(0), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int32_t>(
+            {std::numeric_limits<int32_t>::min() +
+             1})}), // ASC_NULLS_LAST upper (overflow)
+        makeIntRow(0), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeIntRow(0), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 8: Only lower bound, exclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{.bound = makeIntRow(10), .inclusive = false},
+        std::nullopt,
+        makeIntRow(11), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeIntRow(11), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeIntRow(9), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeIntRow(9), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 9: Only upper bound, exclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        std::nullopt,
+        IndexBound{.bound = makeIntRow(100), .inclusive = false},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeIntRow(100), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeIntRow(100), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeIntRow(100), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeIntRow(100)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 10: Multi-column, both exclusive
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{.bound = makeIntRow(10, 20), .inclusive = false},
+        IndexBound{.bound = makeIntRow(100, 100), .inclusive = false},
+        makeIntRow(10, 21), // ASC_NULLS_FIRST lower
+        makeIntRow(100, 100), // ASC_NULLS_FIRST upper
+        makeIntRow(10, 21), // ASC_NULLS_LAST lower
+        makeIntRow(100, 100), // ASC_NULLS_LAST upper
+        makeIntRow(10, 19), // DESC_NULLS_FIRST lower
+        makeIntRow(100, 100), // DESC_NULLS_FIRST upper
+        makeIntRow(10, 19), // DESC_NULLS_LAST lower
+        makeIntRow(100, 100)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 11: Multi-column, lower inclusive upper exclusive
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{.bound = makeIntRow(10, 20), .inclusive = true},
+        IndexBound{.bound = makeIntRow(100, 100), .inclusive = false},
+        makeIntRow(10, 20), // ASC_NULLS_FIRST lower
+        makeIntRow(100, 100), // ASC_NULLS_FIRST upper
+        makeIntRow(10, 20), // ASC_NULLS_LAST lower
+        makeIntRow(100, 100), // ASC_NULLS_LAST upper
+        makeIntRow(10, 20), // DESC_NULLS_FIRST lower
+        makeIntRow(100, 100), // DESC_NULLS_FIRST upper
+        makeIntRow(10, 20), // DESC_NULLS_LAST lower
+        makeIntRow(100, 100)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 12: Multi-column, only lower bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{.bound = makeIntRow(10, 20), .inclusive = true},
+        std::nullopt,
+        makeIntRow(10, 20), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeIntRow(10, 20), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeIntRow(10, 20), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeIntRow(10, 20), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 13: Multi-column, only upper bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        std::nullopt,
+        IndexBound{.bound = makeIntRow(100, 100), .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeIntRow(100, 101), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeIntRow(100, 101), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeIntRow(100, 99), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeIntRow(100, 99)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 14-1: Multi-column at max values (overflow)
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{.bound = makeIntRow(0, 0), .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({1}),
+                 makeFlatVector<int32_t>(
+                     {std::numeric_limits<int32_t>::max()})}),
+            .inclusive = true},
+        makeIntRow(0, 0), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({2}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::min()})}), // ASC_NULLS_FIRST
+                                                           // upper
+        makeIntRow(0, 0), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({2}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::min()})}), // ASC_NULLS_LAST
+                                                           // upper
+        makeIntRow(0, 0), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({1}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::max() -
+                  1})}), // DESC_NULLS_FIRST upper
+        makeIntRow(0, 0), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({1}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::max() -
+                  1})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 14-2: Multi-column at min values
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{.bound = makeIntRow(0, 0), .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({1}),
+                 makeFlatVector<int32_t>(
+                     {std::numeric_limits<int32_t>::min()})}),
+            .inclusive = true},
+        makeIntRow(0, 0), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({1}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::min() +
+                  1})}), // ASC_NULLS_FIRST
+                         // upper
+        makeIntRow(0, 0), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({1}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::min() + 1})}), // ASC_NULLS_LAST
+                                                               // upper
+        makeIntRow(0, 0), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({0}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::max()})}), // DESC_NULLS_FIRST
+                                                           // upper
+        makeIntRow(0, 0), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({0}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::max()})})); // DESC_NULLS_LAST
+                                                            // upper
+  }
+
+  // Test Case 14-3: Multi-column at max values (overflow)
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{.bound = makeIntRow(0, 0), .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({std::numeric_limits<int32_t>::max()}),
+                 makeFlatVector<int32_t>(
+                     {std::numeric_limits<int32_t>::max()})}),
+            .inclusive = true},
+        makeIntRow(0, 0), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        makeIntRow(0, 0), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeIntRow(0, 0), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({std::numeric_limits<int32_t>::max()}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::max() -
+                  1})}), // DESC_NULLS_FIRST upper
+        makeIntRow(0, 0), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({std::numeric_limits<int32_t>::max()}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::max() -
+                  1})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 15: Multi-column, only lower bound, exclusive
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{.bound = makeIntRow(10, 20), .inclusive = false},
+        std::nullopt,
+        makeIntRow(10, 21), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeIntRow(10, 21), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeIntRow(10, 19), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeIntRow(10, 19), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 16: Multi-column, only upper bound, exclusive
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        std::nullopt,
+        IndexBound{.bound = makeIntRow(100, 100), .inclusive = false},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeIntRow(100, 100), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeIntRow(100, 100), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeIntRow(100, 100), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeIntRow(100, 100)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 17: Single column with null in lower bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int32_t>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{.bound = makeIntRow(100), .inclusive = true},
+        makeRowVector({makeNullableFlatVector<int32_t>(
+            {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeIntRow(101), // ASC_NULLS_FIRST upper
+        makeRowVector({makeNullableFlatVector<int32_t>(
+            {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeIntRow(101), // ASC_NULLS_LAST upper
+        makeRowVector({makeNullableFlatVector<int32_t>(
+            {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeIntRow(99), // DESC_NULLS_FIRST upper
+        makeRowVector({makeNullableFlatVector<int32_t>(
+            {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeIntRow(99)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 18: Single column with null in upper bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{.bound = makeIntRow(10), .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int32_t>({std::nullopt})}),
+            .inclusive = true},
+        makeIntRow(10), // ASC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<int32_t>(
+            {std::numeric_limits<int32_t>::min()})}), // ASC_NULLS_FIRST upper
+        makeIntRow(10), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeIntRow(10), // DESC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<int32_t>(
+            {std::numeric_limits<int32_t>::max()})}), // DESC_NULLS_FIRST
+                                                      // upper
+        makeIntRow(10), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 19: Multi-column with null in first column of lower bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int32_t>({std::nullopt}),
+                 makeFlatVector<int32_t>({20})}),
+            .inclusive = true},
+        IndexBound{.bound = makeIntRow(100, 100), .inclusive = true},
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({20})}), // ASC_NULLS_FIRST lower
+        makeIntRow(100, 101), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({20})}), // ASC_NULLS_LAST lower
+        makeIntRow(100, 101), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({20})}), // DESC_NULLS_FIRST lower
+        makeIntRow(100, 99), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({20})}), // DESC_NULLS_LAST lower
+        makeIntRow(100, 99)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 20: Multi-column with null in second column of lower bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({10}),
+                 makeNullableFlatVector<int32_t>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{.bound = makeIntRow(100, 100), .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeNullableFlatVector<int32_t>(
+                 {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeIntRow(100, 101), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeNullableFlatVector<int32_t>(
+                 {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeIntRow(100, 101), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeNullableFlatVector<int32_t>(
+                 {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeIntRow(100, 99), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeNullableFlatVector<int32_t>(
+                 {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeIntRow(100, 99)); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 21: Multi-column with null in first column of upper bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{.bound = makeIntRow(10, 20), .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int32_t>({std::nullopt}),
+                 makeFlatVector<int32_t>({100})}),
+            .inclusive = true},
+        makeIntRow(10, 20), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({101})}), // ASC_NULLS_FIRST upper
+        makeIntRow(10, 20), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({101})}), // ASC_NULLS_LAST upper
+        makeIntRow(10, 20), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({99})}), // DESC_NULLS_FIRST upper
+        makeIntRow(10, 20), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({99})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 22: Multi-column with null in second column of upper bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{.bound = makeIntRow(10, 20), .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({100}),
+                 makeNullableFlatVector<int32_t>({std::nullopt})}),
+            .inclusive = true},
+        makeIntRow(10, 20), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeNullableFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::min()})}), // ASC_NULLS_FIRST
+                                                           // upper
+        makeIntRow(10, 20), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({101}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::min()})}), // ASC_NULLS_LAST
+                                                           // upper
+        makeIntRow(10, 20), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeNullableFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::max()})}), // DESC_NULLS_FIRST
+                                                           // upper
+        makeIntRow(10, 20), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({99}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::max()})})); // DESC_NULLS_LAST
+                                                            // upper
+  }
+
+  // Test Case 23: Both bounds with nulls in different columns
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int32_t>({std::nullopt}),
+                 makeFlatVector<int32_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({100}),
+                 makeNullableFlatVector<int32_t>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeNullableFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::min()})}), // ASC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({101}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::min()})}), // ASC_NULLS_LAST
+                                                           // upper
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeNullableFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::max()})}), // DESC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({99}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::max()})})); // DESC_NULLS_LAST
+                                                            // upper
+  }
+
+  // Test lower bound bump failures
+  // Test Case 24-1: Single column lower bound bump failure - exclusive bound
+  // at max value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeIntRow(std::numeric_limits<int32_t>::max()),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsFirst;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+  // Test Case 24-2: Single column lower bound bump failure - exclusive bound
+  // at max value with null.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound =
+            makeRowVector({makeNullableFlatVector<int32_t>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 25-1: Multiple columns lower bound bump failure - all columns
+  // at max value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeIntRow(
+            std::numeric_limits<int32_t>::max(),
+            std::numeric_limits<int32_t>::max()),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+  // Test Case 25-2: Multiple columns lower bound bump failure - all columns
+  // at max value with null.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeNullableFlatVector<int32_t>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+}
+
+TEST_F(KeyEncoderTest, encodeIndexBoundsWithSmallIntType) {
+  // Test Case 1: Both bounds inclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({100})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int16_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({10})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int16_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({10})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({99})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 2: Both bounds exclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({10})}),
+            .inclusive = false},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({100})}),
+            .inclusive = false},
+        makeRowVector({makeFlatVector<int16_t>({11})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({11})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int16_t>({100})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<int16_t>({9})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({9})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 3: Lower inclusive, upper exclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({100})}),
+            .inclusive = false},
+        makeRowVector({makeFlatVector<int16_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({10})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int16_t>({100})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({10})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 4: Only lower bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({10})}),
+            .inclusive = true},
+        std::nullopt,
+        makeRowVector({makeFlatVector<int16_t>({10})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({10})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({10})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 5: Only upper bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({100})}),
+            .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({101})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int16_t>({101})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({99})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({99})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 6: Multi-column, both inclusive
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({10}), makeFlatVector<int16_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({100}),
+                 makeFlatVector<int16_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({99})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 7-1: Upper bound at max value (overflow case)
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>(
+                {std::numeric_limits<int16_t>::max()})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int16_t>({0})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector({makeFlatVector<int16_t>({0})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeRowVector({makeFlatVector<int16_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int16_t>(
+            {std::numeric_limits<int16_t>::max() -
+             1})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int16_t>(
+            {std::numeric_limits<int16_t>::max() -
+             1})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 7-2: Upper bound at min value (overflow case)
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>(
+                {std::numeric_limits<int16_t>::min()})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int16_t>({0})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int16_t>(
+            {std::numeric_limits<int16_t>::min() +
+             1})}), // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector({makeFlatVector<int16_t>({0})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int16_t>(
+            {std::numeric_limits<int16_t>::min() +
+             1})}), // ASC_NULLS_LAST upper (overflow)
+        makeRowVector({makeFlatVector<int16_t>({0})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({0})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 8: Only lower bound, exclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({10})}),
+            .inclusive = false},
+        std::nullopt,
+        makeRowVector({makeFlatVector<int16_t>({11})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({11})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<int16_t>({9})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({9})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 9: Only upper bound, exclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({100})}),
+            .inclusive = false},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int16_t>({100})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 10: Multi-column, both exclusive
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({10}), makeFlatVector<int16_t>({20})}),
+            .inclusive = false},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({100}),
+                 makeFlatVector<int16_t>({100})}),
+            .inclusive = false},
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({21})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({21})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({19})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({19})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 11: Multi-column, lower inclusive upper exclusive
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({10}), makeFlatVector<int16_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({100}),
+                 makeFlatVector<int16_t>({100})}),
+            .inclusive = false},
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 12: Multi-column, only lower bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({10}), makeFlatVector<int16_t>({20})}),
+            .inclusive = true},
+        std::nullopt,
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 13: Multi-column, only upper bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({100}),
+                 makeFlatVector<int16_t>({100})}),
+            .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({101})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({101})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({99})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({99})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 14-1: Multi-column at max values (overflow)
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({0}), makeFlatVector<int16_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({1}),
+                 makeFlatVector<int16_t>(
+                     {std::numeric_limits<int16_t>::max()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({2}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::min()})}), // ASC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({2}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::min()})}), // ASC_NULLS_LAST
+                                                           // upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({1}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::max() -
+                  1})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({1}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::max() -
+                  1})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 14-2: Multi-column at min values
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({0}), makeFlatVector<int16_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({1}),
+                 makeFlatVector<int16_t>(
+                     {std::numeric_limits<int16_t>::min()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({1}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::min() +
+                  1})}), // ASC_NULLS_FIRST
+                         // upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({1}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::min() + 1})}), // ASC_NULLS_LAST
+                                                               // upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::max()})}), // DESC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::max()})})); // DESC_NULLS_LAST
+                                                            // upper
+  }
+
+  // Test Case 14-3: Multi-column at max values (overflow)
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({0}), makeFlatVector<int16_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({std::numeric_limits<int16_t>::max()}),
+                 makeFlatVector<int16_t>(
+                     {std::numeric_limits<int16_t>::max()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({std::numeric_limits<int16_t>::max()}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::max() -
+                  1})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({std::numeric_limits<int16_t>::max()}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::max() -
+                  1})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 15: Multi-column, only lower bound, exclusive
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({10}), makeFlatVector<int16_t>({20})}),
+            .inclusive = false},
+        std::nullopt,
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({21})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({21})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({19})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({19})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 16: Multi-column, only upper bound, exclusive
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({100}),
+                 makeFlatVector<int16_t>({100})}),
+            .inclusive = false},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 17: Single column with null in lower bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int16_t>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({100})}),
+            .inclusive = true},
+        makeRowVector({makeNullableFlatVector<int16_t>(
+            {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeNullableFlatVector<int16_t>(
+            {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int16_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeNullableFlatVector<int16_t>(
+            {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeNullableFlatVector<int16_t>(
+            {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({99})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 18: Single column with null in upper bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int16_t>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int16_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<int16_t>(
+            {std::numeric_limits<int16_t>::min()})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({10})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<int16_t>(
+            {std::numeric_limits<int16_t>::max()})}), // DESC_NULLS_FIRST
+                                                      // upper
+        makeRowVector({makeFlatVector<int16_t>({10})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 19: Multi-column with null in first column of lower bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int16_t>({std::nullopt}),
+                 makeFlatVector<int16_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({100}),
+                 makeFlatVector<int16_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({99})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 20: Multi-column with null in second column of lower bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({10}),
+                 makeNullableFlatVector<int16_t>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({100}),
+                 makeFlatVector<int16_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeNullableFlatVector<int16_t>(
+                 {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeNullableFlatVector<int16_t>(
+                 {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeNullableFlatVector<int16_t>(
+                 {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeNullableFlatVector<int16_t>(
+                 {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({99})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 21: Multi-column with null in first column of upper bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({10}), makeFlatVector<int16_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int16_t>({std::nullopt}),
+                 makeFlatVector<int16_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({99})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 22: Multi-column with null in second column of upper bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({10}), makeFlatVector<int16_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({100}),
+                 makeNullableFlatVector<int16_t>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeNullableFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::min()})}), // ASC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({101}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::min()})}), // ASC_NULLS_LAST
+                                                           // upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeNullableFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::max()})}), // DESC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({99}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::max()})})); // DESC_NULLS_LAST
+                                                            // upper
+  }
+
+  // Test Case 23: Both bounds with nulls in different columns
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int16_t>({std::nullopt}),
+                 makeFlatVector<int16_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({100}),
+                 makeNullableFlatVector<int16_t>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeNullableFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::min()})}), // ASC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({101}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::min()})}), // ASC_NULLS_LAST
+                                                           // upper
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeNullableFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::max()})}), // DESC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({99}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::max()})})); // DESC_NULLS_LAST
+                                                            // upper
+  }
+
+  // Test lower bound bump failures
+  // Test Case 24-1: Single column lower bound bump failure - exclusive
+  // bound at max value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<int16_t>({std::numeric_limits<int16_t>::max()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsFirst;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+  // Test Case 24-2: Single column lower bound bump failure - exclusive
+  // bound at max value with null.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound =
+            makeRowVector({makeNullableFlatVector<int16_t>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 25-1: Multiple columns lower bound bump failure - all
+  // columns at max value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<int16_t>({std::numeric_limits<int16_t>::max()}),
+             makeFlatVector<int16_t>({std::numeric_limits<int16_t>::max()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+  // Test Case 25-2: Multiple columns lower bound bump failure - all
+  // columns at max value with null.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeNullableFlatVector<int16_t>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+}
+
+TEST_F(KeyEncoderTest, encodeIndexBoundsWithTinyIntType) {
+  // Test Case 1: Both bounds inclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({5})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({50})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int8_t>({5})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({51})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({51})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({49})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({49})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 2: Both bounds exclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({5})}),
+            .inclusive = false},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({50})}),
+            .inclusive = false},
+        makeRowVector({makeFlatVector<int8_t>({6})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({50})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({6})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({50})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<int8_t>({4})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({50})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({4})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({50})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 3: Lower inclusive, upper exclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({5})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({50})}),
+            .inclusive = false},
+        makeRowVector({makeFlatVector<int8_t>({5})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({50})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({50})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({50})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({50})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 4: Only lower bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({5})}),
+            .inclusive = true},
+        std::nullopt,
+        makeRowVector({makeFlatVector<int8_t>({5})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 5: Only upper bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({50})}),
+            .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({51})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({51})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({49})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({49})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 6: Multi-column, both inclusive
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({5}), makeFlatVector<int8_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({50}), makeFlatVector<int8_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({99})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 7-1: Upper bound at max value (overflow case)
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({std::numeric_limits<int8_t>::max()})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int8_t>({0})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector({makeFlatVector<int8_t>({0})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeRowVector({makeFlatVector<int8_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>(
+            {std::numeric_limits<int8_t>::max() -
+             1})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>(
+            {std::numeric_limits<int8_t>::max() -
+             1})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 7-2: Upper bound at min value (overflow case)
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({std::numeric_limits<int8_t>::min()})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int8_t>({0})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>(
+            {std::numeric_limits<int8_t>::min() +
+             1})}), // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector({makeFlatVector<int8_t>({0})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>(
+            {std::numeric_limits<int8_t>::min() +
+             1})}), // ASC_NULLS_LAST upper (overflow)
+        makeRowVector({makeFlatVector<int8_t>({0})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({0})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 8: Only lower bound, exclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({5})}),
+            .inclusive = false},
+        std::nullopt,
+        makeRowVector({makeFlatVector<int8_t>({6})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({6})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<int8_t>({4})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({4})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 9: Only upper bound, exclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({50})}),
+            .inclusive = false},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({50})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({50})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({50})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({50})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 10: Multi-column, both exclusive
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({5}), makeFlatVector<int8_t>({10})}),
+            .inclusive = false},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({50}), makeFlatVector<int8_t>({100})}),
+            .inclusive = false},
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({11})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({11})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({9})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({9})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 11: Multi-column, lower inclusive upper exclusive
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({5}), makeFlatVector<int8_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({50}), makeFlatVector<int8_t>({100})}),
+            .inclusive = false},
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 12: Multi-column, only lower bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({5}), makeFlatVector<int8_t>({10})}),
+            .inclusive = true},
+        std::nullopt,
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 13: Multi-column, only upper bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({50}), makeFlatVector<int8_t>({100})}),
+            .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({101})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({101})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({99})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({99})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 14-1: Multi-column at max values (overflow)
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({0}), makeFlatVector<int8_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({1}),
+                 makeFlatVector<int8_t>({std::numeric_limits<int8_t>::max()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({2}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::min()})}), // ASC_NULLS_FIRST
+                                                          // upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({2}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::min()})}), // ASC_NULLS_LAST
+                                                          // upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({1}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::max() -
+                  1})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({1}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::max() -
+                  1})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 14-2: Multi-column at min values
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({0}), makeFlatVector<int8_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({1}),
+                 makeFlatVector<int8_t>({std::numeric_limits<int8_t>::min()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({1}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::min() + 1})}), // ASC_NULLS_FIRST
+                                                              // upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({1}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::min() + 1})}), // ASC_NULLS_LAST
+                                                              // upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::max()})}), // DESC_NULLS_FIRST
+                                                          // upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::max()})})); // DESC_NULLS_LAST
+                                                           // upper
+  }
+
+  // Test Case 14-3: Multi-column at max values (overflow)
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({0}), makeFlatVector<int8_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({std::numeric_limits<int8_t>::max()}),
+                 makeFlatVector<int8_t>({std::numeric_limits<int8_t>::max()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({std::numeric_limits<int8_t>::max()}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::max() -
+                  1})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({std::numeric_limits<int8_t>::max()}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::max() -
+                  1})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 15: Multi-column, only lower bound, exclusive
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({5}), makeFlatVector<int8_t>({10})}),
+            .inclusive = false},
+        std::nullopt,
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({11})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({11})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({9})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({9})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 16: Multi-column, only upper bound, exclusive
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({50}), makeFlatVector<int8_t>({100})}),
+            .inclusive = false},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 17: Single column with null in lower bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound =
+                makeRowVector({makeNullableFlatVector<int8_t>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({50})}),
+            .inclusive = true},
+        makeRowVector({makeNullableFlatVector<int8_t>(
+            {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({51})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeNullableFlatVector<int8_t>(
+            {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({51})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeNullableFlatVector<int8_t>(
+            {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({49})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeNullableFlatVector<int8_t>(
+            {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({49})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 18: Single column with null in upper bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({5})}),
+            .inclusive = true},
+        IndexBound{
+            .bound =
+                makeRowVector({makeNullableFlatVector<int8_t>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int8_t>({5})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<int8_t>(
+            {std::numeric_limits<int8_t>::min()})}), // ASC_NULLS_FIRST
+                                                     // upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<int8_t>(
+            {std::numeric_limits<int8_t>::max()})}), // DESC_NULLS_FIRST
+                                                     // upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 19: Multi-column with null in first column of lower bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int8_t>({std::nullopt}),
+                 makeFlatVector<int8_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({50}), makeFlatVector<int8_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({99})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 20: Multi-column with null in second column of lower bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({5}),
+                 makeNullableFlatVector<int8_t>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({50}), makeFlatVector<int8_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeNullableFlatVector<int8_t>(
+                 {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeNullableFlatVector<int8_t>(
+                 {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeNullableFlatVector<int8_t>(
+                 {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeNullableFlatVector<int8_t>(
+                 {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({99})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 21: Multi-column with null in first column of upper bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({5}), makeFlatVector<int8_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int8_t>({std::nullopt}),
+                 makeFlatVector<int8_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({99})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 22: Multi-column with null in second column of upper bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({5}), makeFlatVector<int8_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({50}),
+                 makeNullableFlatVector<int8_t>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeNullableFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::min()})}), // ASC_NULLS_FIRST
+                                                          // upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({51}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::min()})}), // ASC_NULLS_LAST
+                                                          // upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeNullableFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::max()})}), // DESC_NULLS_FIRST
+                                                          // upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({49}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::max()})})); // DESC_NULLS_LAST
+                                                           // upper
+  }
+
+  // Test Case 23: Both bounds with nulls in different columns
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int8_t>({std::nullopt}),
+                 makeFlatVector<int8_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({50}),
+                 makeNullableFlatVector<int8_t>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeNullableFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::min()})}), // ASC_NULLS_FIRST
+                                                          // upper
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({51}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::min()})}), // ASC_NULLS_LAST
+                                                          // upper
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeNullableFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::max()})}), // DESC_NULLS_FIRST
+                                                          // upper
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({49}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::max()})})); // DESC_NULLS_LAST
+                                                           // upper
+  }
+
+  // Test lower bound bump failures
+  // Test Case 24-1: Single column lower bound bump failure - exclusive
+  // bound at max value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<int8_t>({std::numeric_limits<int8_t>::max()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsFirst;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+  // Test Case 24-2: Single column lower bound bump failure - exclusive
+  // bound at max value with null.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound =
+            makeRowVector({makeNullableFlatVector<int8_t>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 25-1: Multiple columns lower bound bump failure - all
+  // columns at max value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<int8_t>({std::numeric_limits<int8_t>::max()}),
+             makeFlatVector<int8_t>({std::numeric_limits<int8_t>::max()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+  // Test Case 25-2: Multiple columns lower bound bump failure - all
+  // columns at max value with null.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeNullableFlatVector<int8_t>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+}
+
+TEST_F(KeyEncoderTest, encodeIndexBoundsWithBoolType) {
+  // Test Case 1: Both bounds inclusive (false to true)
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<bool>({false})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<bool>({true})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<bool>({false})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow - can't increment
+                      // true)
+        makeRowVector({makeFlatVector<bool>({false})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeRowVector(
+            {makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<bool>({false})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<bool>({false})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 2: Upper bound exclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<bool>({false})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<bool>({true})}),
+            .inclusive = false},
+        makeRowVector({makeFlatVector<bool>({false})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<bool>({true})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<bool>({false})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<bool>({true})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<bool>({true})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<bool>({false})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<bool>({true})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 3: Only lower bound (false)
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<bool>({false})}),
+            .inclusive = true},
+        std::nullopt,
+        makeRowVector({makeFlatVector<bool>({false})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<bool>({false})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<bool>({false})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 4: Only upper bound (true)
+  {
+    runIndexBoundTests(
+        {"c0"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<bool>({true})}),
+            .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        std::nullopt, // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<bool>({false})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 5: Single column with null in lower bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound =
+                makeRowVector({makeNullableFlatVector<bool>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<bool>({true})}),
+            .inclusive = true},
+        makeRowVector({makeNullableFlatVector<bool>(
+            {std::nullopt})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector({makeNullableFlatVector<bool>(
+            {std::nullopt})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeRowVector({makeNullableFlatVector<bool>(
+            {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeNullableFlatVector<bool>(
+            {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<bool>({false})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 6: Single column with null in upper bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<bool>({false})}),
+            .inclusive = true},
+        IndexBound{
+            .bound =
+                makeRowVector({makeNullableFlatVector<bool>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<bool>({false})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeNullableFlatVector<bool>({false})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<bool>({false})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeNullableFlatVector<bool>({true})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<bool>({false})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 7: Multi-column, both inclusive (bool + bool)
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<bool>({false}), makeFlatVector<bool>({false})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<bool>({true}), makeFlatVector<bool>({true})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({false})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({false})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({false})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({false})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 8: Multi-column with null in first column of lower bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<bool>({std::nullopt}),
+                 makeFlatVector<bool>({false})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<bool>({true}), makeFlatVector<bool>({true})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeNullableFlatVector<bool>({std::nullopt}),
+             makeFlatVector<bool>({false})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector(
+            {makeNullableFlatVector<bool>({std::nullopt}),
+             makeFlatVector<bool>({false})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeRowVector(
+            {makeNullableFlatVector<bool>({std::nullopt}),
+             makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeNullableFlatVector<bool>({std::nullopt}),
+             makeFlatVector<bool>({false})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({false})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 9: Lower bound bump failure - exclusive bound at max value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<bool>({true})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsFirst;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 10: Lower bound bump failure - exclusive bound with null at end
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector({makeNullableFlatVector<bool>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 11: Multi-column lower bound bump failure - all columns at max
+  // value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<bool>({true}), makeFlatVector<bool>({true})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 12: Multi-column lower bound bump failure - all columns at max
+  // value with null
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<bool>({std::nullopt}),
+             makeNullableFlatVector<bool>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 13: Multi-column point lookup where the lower (second) column
+  // hits max value (true) in ASC order. This tests carry-over behavior when
+  // incrementing - when c1 is true, the increment should carry over to c0,
+  // resulting in (true, false).
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<bool>({false}), makeFlatVector<bool>({true})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<bool>({false}), makeFlatVector<bool>({true})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({true})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({false})}), // ASC_NULLS_FIRST upper
+                                              // (carry-over)
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({true})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({false})}), // ASC_NULLS_LAST upper
+                                              // (carry-over)
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({true})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({true})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({false})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 14: Multi-column point lookup where the lower (second) column
+  // hits min value (false) in DESC order. This tests carry-over behavior when
+  // decrementing - when c1 is false, the decrement should carry over to c0,
+  // resulting in (false, true).
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<bool>({true}), makeFlatVector<bool>({false})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<bool>({true}), makeFlatVector<bool>({false})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({false})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({true})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({false})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({true})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({true})}), // DESC_NULLS_FIRST upper
+                                             // (carry-over)
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({false})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({true})})); // DESC_NULLS_LAST upper
+                                              // (carry-over)
+  }
+}
+
+TEST_F(KeyEncoderTest, encodeIndexBoundsWithRealType) {
+  // Test Case 1: Both bounds inclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<float>({10.5f})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<float>({100.5f})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            std::numeric_limits<float>::infinity())})}), // ASC_NULLS_FIRST
+                                                         // upper
+        makeRowVector({makeFlatVector<float>({10.5f})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            std::numeric_limits<float>::infinity())})}), // ASC_NULLS_LAST
+                                                         // upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            -std::numeric_limits<float>::infinity())})}), // DESC_NULLS_FIRST
+                                                          // upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            -std::numeric_limits<float>::infinity())})})); // DESC_NULLS_LAST
+                                                           // upper
+  }
+
+  // Test Case 2: Both bounds exclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<float>({10.5f})}),
+            .inclusive = false},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<float>({100.5f})}),
+            .inclusive = false},
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            10.5f,
+            std::numeric_limits<float>::infinity())})}), // ASC_NULLS_FIRST
+                                                         // lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            10.5f,
+            std::numeric_limits<float>::infinity())})}), // ASC_NULLS_LAST
+                                                         // lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            10.5f,
+            -std::numeric_limits<float>::infinity())})}), // DESC_NULLS_FIRST
+                                                          // lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            10.5f,
+            -std::numeric_limits<float>::infinity())})}), // DESC_NULLS_LAST
+                                                          // lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 3: Lower inclusive, upper exclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<float>({10.5f})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<float>({100.5f})}),
+            .inclusive = false},
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<float>({10.5f})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 4: Only lower bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<float>({10.5f})}),
+            .inclusive = true},
+        std::nullopt,
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<float>({10.5f})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 5: Only upper bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<float>({100.5f})}),
+            .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            std::numeric_limits<float>::infinity())})}), // ASC_NULLS_FIRST
+                                                         // upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            std::numeric_limits<float>::infinity())})}), // ASC_NULLS_LAST
+                                                         // upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            -std::numeric_limits<float>::infinity())})}), // DESC_NULLS_FIRST
+                                                          // upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            -std::numeric_limits<float>::infinity())})})); // DESC_NULLS_LAST
+                                                           // upper
+  }
+
+  // Test Case 6: Multi-column, both inclusive
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<float>({10.5f}),
+                 makeFlatVector<float>({20.5f})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<float>({100.5f}),
+                 makeFlatVector<float>({100.5f})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<float>({10.5f}),
+             makeFlatVector<float>({20.5f})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 std::numeric_limits<float>::infinity())})}), // ASC_NULLS_FIRST
+                                                              // upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f}),
+             makeFlatVector<float>({20.5f})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 std::numeric_limits<float>::infinity())})}), // ASC_NULLS_LAST
+                                                              // upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f}),
+             makeFlatVector<float>({20.5f})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 -std::numeric_limits<
+                     float>::infinity())})}), // DESC_NULLS_FIRST
+                                              // upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f}),
+             makeFlatVector<float>({20.5f})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 -std::numeric_limits<
+                     float>::infinity())})})); // DESC_NULLS_LAST
+                                               // upper
+  }
+
+  // Test Case 7: Single column with null in lower bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound =
+                makeRowVector({makeNullableFlatVector<float>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<float>({100.5f})}),
+            .inclusive = true},
+        makeRowVector({makeNullableFlatVector<float>(
+            {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            std::numeric_limits<float>::infinity())})}), // ASC_NULLS_FIRST
+                                                         // upper
+        makeRowVector({makeNullableFlatVector<float>(
+            {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            std::numeric_limits<float>::infinity())})}), // ASC_NULLS_LAST
+                                                         // upper
+        makeRowVector({makeNullableFlatVector<float>(
+            {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            -std::numeric_limits<float>::infinity())})}), // DESC_NULLS_FIRST
+                                                          // upper
+        makeRowVector({makeNullableFlatVector<float>(
+            {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            -std::numeric_limits<float>::infinity())})})); // DESC_NULLS_LAST
+                                                           // upper
+  }
+
+  // Test Case 8: Single column with null in upper bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<float>({10.5f})}),
+            .inclusive = true},
+        IndexBound{
+            .bound =
+                makeRowVector({makeNullableFlatVector<float>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<float>(
+            {-std::numeric_limits<float>::infinity()})}), // ASC_NULLS_FIRST
+                                                          // upper
+        makeRowVector({makeFlatVector<float>({10.5f})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<float>(
+            {std::numeric_limits<float>::infinity()})}), // DESC_NULLS_FIRST
+                                                         // upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 9: Multi-column with null in first column of lower bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<float>({std::nullopt}),
+                 makeFlatVector<float>({20.5f})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<float>({100.5f}),
+                 makeFlatVector<float>({100.5f})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeNullableFlatVector<float>({std::nullopt}),
+             makeFlatVector<float>({20.5f})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 std::numeric_limits<float>::infinity())})}), // ASC_NULLS_FIRST
+                                                              // upper
+        makeRowVector(
+            {makeNullableFlatVector<float>({std::nullopt}),
+             makeFlatVector<float>({20.5f})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 std::numeric_limits<float>::infinity())})}), // ASC_NULLS_LAST
+                                                              // upper
+        makeRowVector(
+            {makeNullableFlatVector<float>({std::nullopt}),
+             makeFlatVector<float>({20.5f})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 -std::numeric_limits<
+                     float>::infinity())})}), // DESC_NULLS_FIRST
+                                              // upper
+        makeRowVector(
+            {makeNullableFlatVector<float>({std::nullopt}),
+             makeFlatVector<float>({20.5f})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 -std::numeric_limits<
+                     float>::infinity())})})); // DESC_NULLS_LAST
+                                               // upper
+  }
+
+  // Test Case 10: Multi-column with null in second column of lower bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<float>({10.5f}),
+                 makeNullableFlatVector<float>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<float>({100.5f}),
+                 makeFlatVector<float>({100.5f})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<float>({10.5f}),
+             makeNullableFlatVector<float>(
+                 {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 std::numeric_limits<float>::infinity())})}), // ASC_NULLS_FIRST
+                                                              // upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f}),
+             makeNullableFlatVector<float>(
+                 {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 std::numeric_limits<float>::infinity())})}), // ASC_NULLS_LAST
+                                                              // upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f}),
+             makeNullableFlatVector<float>(
+                 {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 -std::numeric_limits<
+                     float>::infinity())})}), // DESC_NULLS_FIRST
+                                              // upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f}),
+             makeNullableFlatVector<float>(
+                 {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 -std::numeric_limits<
+                     float>::infinity())})})); // DESC_NULLS_LAST
+                                               // upper
+  }
+
+  // Test Case 11: Lower bound bump failure - exclusive bound at positive
+  // infinity
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<float>({std::numeric_limits<float>::infinity()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsFirst;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 12: Lower bound bump failure - exclusive bound with null at end
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector({makeNullableFlatVector<float>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 13: Multi-column lower bound bump failure - all columns at max
+  // value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<float>({std::numeric_limits<float>::infinity()}),
+             makeFlatVector<float>({std::numeric_limits<float>::infinity()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 14: Multi-column lower bound bump failure - all columns at max
+  // value with null
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<float>({std::nullopt}),
+             makeNullableFlatVector<float>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 15: Multi-column point lookup where the lower (second) column
+  // hits positive infinity in ASC order. This tests carry-over behavior when
+  // incrementing - when c1 is at +infinity, the increment should carry over
+  // to c0, resulting in (nextafter(c0, +inf), -inf).
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<float>({100.5f}),
+                 makeFlatVector<float>(
+                     {std::numeric_limits<float>::infinity()})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<float>({100.5f}),
+                 makeFlatVector<float>(
+                     {std::numeric_limits<float>::infinity()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>(
+                 {std::numeric_limits<float>::infinity()})}), // ASC_NULLS_FIRST
+                                                              // lower
+        makeRowVector(
+            {makeFlatVector<float>({std::nextafter(
+                 100.5f, std::numeric_limits<float>::infinity())}),
+             makeFlatVector<float>({-std::numeric_limits<
+                 float>::infinity()})}), // ASC_NULLS_FIRST
+                                         // upper
+                                         // (carry-over)
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>(
+                 {std::numeric_limits<float>::infinity()})}), // ASC_NULLS_LAST
+                                                              // lower
+        makeRowVector(
+            {makeFlatVector<float>({std::nextafter(
+                 100.5f, std::numeric_limits<float>::infinity())}),
+             makeFlatVector<float>(
+                 {-std::numeric_limits<float>::infinity()})}), // ASC_NULLS_LAST
+                                                               // upper
+                                                               // (carry-over)
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::numeric_limits<
+                 float>::infinity()})}), // DESC_NULLS_FIRST
+                                         // lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 std::numeric_limits<float>::infinity(),
+                 -std::numeric_limits<
+                     float>::infinity())})}), // DESC_NULLS_FIRST
+                                              // upper
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>(
+                 {std::numeric_limits<float>::infinity()})}), // DESC_NULLS_LAST
+                                                              // lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 std::numeric_limits<float>::infinity(),
+                 -std::numeric_limits<
+                     float>::infinity())})})); // DESC_NULLS_LAST
+                                               // upper
+  }
+
+  // Test Case 16: Multi-column point lookup where the lower (second) column
+  // hits negative infinity in DESC order. This tests carry-over behavior when
+  // decrementing - when c1 is at -infinity, the decrement should carry over
+  // to c0, resulting in (nextafter(c0, -inf), +inf).
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<float>({100.5f}),
+                 makeFlatVector<float>(
+                     {-std::numeric_limits<float>::infinity()})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<float>({100.5f}),
+                 makeFlatVector<float>(
+                     {-std::numeric_limits<float>::infinity()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({-std::numeric_limits<
+                 float>::infinity()})}), // ASC_NULLS_FIRST
+                                         // lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 -std::numeric_limits<float>::infinity(),
+                 std::numeric_limits<float>::infinity())})}), // ASC_NULLS_FIRST
+                                                              // upper
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>(
+                 {-std::numeric_limits<float>::infinity()})}), // ASC_NULLS_LAST
+                                                               // lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 -std::numeric_limits<float>::infinity(),
+                 std::numeric_limits<float>::infinity())})}), // ASC_NULLS_LAST
+                                                              // upper
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({-std::numeric_limits<
+                 float>::infinity()})}), // DESC_NULLS_FIRST
+                                         // lower
+        makeRowVector(
+            {makeFlatVector<float>({std::nextafter(
+                 100.5f, -std::numeric_limits<float>::infinity())}),
+             makeFlatVector<float>({std::numeric_limits<
+                 float>::infinity()})}), // DESC_NULLS_FIRST
+                                         // upper
+                                         // (carry-over)
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({-std::numeric_limits<
+                 float>::infinity()})}), // DESC_NULLS_LAST
+                                         // lower
+        makeRowVector(
+            {makeFlatVector<float>({std::nextafter(
+                 100.5f, -std::numeric_limits<float>::infinity())}),
+             makeFlatVector<float>({std::numeric_limits<
+                 float>::infinity()})})); // DESC_NULLS_LAST
+                                          // upper
+                                          // (carry-over)
+  }
+}
+
+TEST_F(KeyEncoderTest, encodeIndexBoundsWithDoubleType) {
+  // Test Case 1: Both bounds inclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<double>({10.5})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<double>({100.5})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            std::numeric_limits<double>::infinity())})}), // ASC_NULLS_FIRST
+                                                          // upper
+        makeRowVector({makeFlatVector<double>({10.5})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            std::numeric_limits<double>::infinity())})}), // ASC_NULLS_LAST
+                                                          // upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            -std::numeric_limits<double>::infinity())})}), // DESC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            -std::numeric_limits<double>::infinity())})})); // DESC_NULLS_LAST
+                                                            // upper
+  }
+
+  // Test Case 2: Both bounds exclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<double>({10.5})}),
+            .inclusive = false},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<double>({100.5})}),
+            .inclusive = false},
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            10.5,
+            std::numeric_limits<double>::infinity())})}), // ASC_NULLS_FIRST
+                                                          // lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            10.5,
+            std::numeric_limits<double>::infinity())})}), // ASC_NULLS_LAST
+                                                          // lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            10.5,
+            -std::numeric_limits<double>::infinity())})}), // DESC_NULLS_FIRST
+                                                           // lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            10.5,
+            -std::numeric_limits<double>::infinity())})}), // DESC_NULLS_LAST
+                                                           // lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 3: Lower inclusive, upper exclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<double>({10.5})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<double>({100.5})}),
+            .inclusive = false},
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<double>({10.5})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 4: Only lower bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<double>({10.5})}),
+            .inclusive = true},
+        std::nullopt,
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<double>({10.5})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 5: Only upper bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<double>({100.5})}),
+            .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            std::numeric_limits<double>::infinity())})}), // ASC_NULLS_FIRST
+                                                          // upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            std::numeric_limits<double>::infinity())})}), // ASC_NULLS_LAST
+                                                          // upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            -std::numeric_limits<double>::infinity())})}), // DESC_NULLS_FIRST
+                                                           // upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            -std::numeric_limits<double>::infinity())})})); // DESC_NULLS_LAST
+                                                            // upper
+  }
+
+  // Test Case 6: Multi-column, both inclusive
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<double>({10.5}),
+                 makeFlatVector<double>({20.5})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<double>({100.5}),
+                 makeFlatVector<double>({100.5})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<double>({10.5}),
+             makeFlatVector<double>({20.5})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 std::numeric_limits<
+                     double>::infinity())})}), // ASC_NULLS_FIRST
+                                               // upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5}),
+             makeFlatVector<double>({20.5})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 std::numeric_limits<double>::infinity())})}), // ASC_NULLS_LAST
+                                                               // upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5}),
+             makeFlatVector<double>({20.5})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 -std::numeric_limits<
+                     double>::infinity())})}), // DESC_NULLS_FIRST
+                                               // upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5}),
+             makeFlatVector<double>({20.5})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 -std::numeric_limits<
+                     double>::infinity())})})); // DESC_NULLS_LAST
+                                                // upper
+  }
+
+  // Test Case 7: Single column with null in lower bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound =
+                makeRowVector({makeNullableFlatVector<double>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<double>({100.5})}),
+            .inclusive = true},
+        makeRowVector({makeNullableFlatVector<double>(
+            {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            std::numeric_limits<double>::infinity())})}), // ASC_NULLS_FIRST
+                                                          // upper
+        makeRowVector({makeNullableFlatVector<double>(
+            {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            std::numeric_limits<double>::infinity())})}), // ASC_NULLS_LAST
+                                                          // upper
+        makeRowVector({makeNullableFlatVector<double>(
+            {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            -std::numeric_limits<double>::infinity())})}), // DESC_NULLS_FIRST
+                                                           // upper
+        makeRowVector({makeNullableFlatVector<double>(
+            {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            -std::numeric_limits<double>::infinity())})})); // DESC_NULLS_LAST
+                                                            // upper
+  }
+
+  // Test Case 8: Single column with null in upper bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<double>({10.5})}),
+            .inclusive = true},
+        IndexBound{
+            .bound =
+                makeRowVector({makeNullableFlatVector<double>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<double>(
+            {-std::numeric_limits<double>::infinity()})}), // ASC_NULLS_FIRST
+                                                           // upper
+        makeRowVector({makeFlatVector<double>({10.5})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<double>(
+            {std::numeric_limits<double>::infinity()})}), // DESC_NULLS_FIRST
+                                                          // upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST
+                       // upper
+  }
+
+  // Test Case 9: Multi-column with null in first column of lower bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<double>({std::nullopt}),
+                 makeFlatVector<double>({20.5})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<double>({100.5}),
+                 makeFlatVector<double>({100.5})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeNullableFlatVector<double>({std::nullopt}),
+             makeFlatVector<double>({20.5})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 std::numeric_limits<
+                     double>::infinity())})}), // ASC_NULLS_FIRST
+                                               // upper
+        makeRowVector(
+            {makeNullableFlatVector<double>({std::nullopt}),
+             makeFlatVector<double>({20.5})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 std::numeric_limits<double>::infinity())})}), // ASC_NULLS_LAST
+                                                               // upper
+        makeRowVector(
+            {makeNullableFlatVector<double>({std::nullopt}),
+             makeFlatVector<double>({20.5})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 -std::numeric_limits<
+                     double>::infinity())})}), // DESC_NULLS_FIRST
+                                               // upper
+        makeRowVector(
+            {makeNullableFlatVector<double>({std::nullopt}),
+             makeFlatVector<double>({20.5})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 -std::numeric_limits<
+                     double>::infinity())})})); // DESC_NULLS_LAST
+                                                // upper
+  }
+
+  // Test Case 10: Multi-column with null in second column of lower bound
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<double>({10.5}),
+                 makeNullableFlatVector<double>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<double>({100.5}),
+                 makeFlatVector<double>({100.5})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<double>({10.5}),
+             makeNullableFlatVector<double>(
+                 {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 std::numeric_limits<
+                     double>::infinity())})}), // ASC_NULLS_FIRST
+                                               // upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5}),
+             makeNullableFlatVector<double>(
+                 {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 std::numeric_limits<double>::infinity())})}), // ASC_NULLS_LAST
+                                                               // upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5}),
+             makeNullableFlatVector<double>(
+                 {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 -std::numeric_limits<
+                     double>::infinity())})}), // DESC_NULLS_FIRST
+                                               // upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5}),
+             makeNullableFlatVector<double>(
+                 {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 -std::numeric_limits<
+                     double>::infinity())})})); // DESC_NULLS_LAST
+                                                // upper
+  }
+
+  // Test Case 11: Lower bound bump failure - exclusive bound at positive
+  // infinity
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<double>(
+            {std::numeric_limits<double>::infinity()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsFirst;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 12: Lower bound bump failure - exclusive bound with null at end
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound =
+            makeRowVector({makeNullableFlatVector<double>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 13: Multi-column lower bound bump failure - all columns at max
+  // value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<double>({std::numeric_limits<double>::infinity()}),
+             makeFlatVector<double>(
+                 {std::numeric_limits<double>::infinity()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 14: Multi-column lower bound bump failure - all columns at max
+  // value with null
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<double>({std::nullopt}),
+             makeNullableFlatVector<double>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 15: Multi-column point lookup where the lower (second) column
+  // hits positive infinity in ASC order. This tests carry-over behavior when
+  // incrementing - when c1 is at +infinity, the increment should carry over
+  // to c0, resulting in (nextafter(c0, +inf), -inf).
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<double>({100.5}),
+                 makeFlatVector<double>(
+                     {std::numeric_limits<double>::infinity()})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<double>({100.5}),
+                 makeFlatVector<double>(
+                     {std::numeric_limits<double>::infinity()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::numeric_limits<
+                 double>::infinity()})}), // ASC_NULLS_FIRST
+                                          // lower
+        makeRowVector(
+            {makeFlatVector<double>({std::nextafter(
+                 100.5, std::numeric_limits<double>::infinity())}),
+             makeFlatVector<double>({-std::numeric_limits<
+                 double>::infinity()})}), // ASC_NULLS_FIRST
+                                          // upper
+                                          // (carry-over)
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>(
+                 {std::numeric_limits<double>::infinity()})}), // ASC_NULLS_LAST
+                                                               // lower
+        makeRowVector(
+            {makeFlatVector<double>({std::nextafter(
+                 100.5, std::numeric_limits<double>::infinity())}),
+             makeFlatVector<double>({-std::numeric_limits<
+                 double>::infinity()})}), // ASC_NULLS_LAST
+                                          // upper
+                                          // (carry-over)
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::numeric_limits<
+                 double>::infinity()})}), // DESC_NULLS_FIRST
+                                          // lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 std::numeric_limits<double>::infinity(),
+                 -std::numeric_limits<
+                     double>::infinity())})}), // DESC_NULLS_FIRST
+                                               // upper
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::numeric_limits<
+                 double>::infinity()})}), // DESC_NULLS_LAST
+                                          // lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 std::numeric_limits<double>::infinity(),
+                 -std::numeric_limits<
+                     double>::infinity())})})); // DESC_NULLS_LAST
+                                                // upper
+  }
+
+  // Test Case 16: Multi-column point lookup where the lower (second) column
+  // hits negative infinity in DESC order. This tests carry-over behavior when
+  // decrementing - when c1 is at -infinity, the decrement should carry over
+  // to c0, resulting in (nextafter(c0, -inf), +inf).
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<double>({100.5}),
+                 makeFlatVector<double>(
+                     {-std::numeric_limits<double>::infinity()})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<double>({100.5}),
+                 makeFlatVector<double>(
+                     {-std::numeric_limits<double>::infinity()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({-std::numeric_limits<
+                 double>::infinity()})}), // ASC_NULLS_FIRST
+                                          // lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 -std::numeric_limits<double>::infinity(),
+                 std::numeric_limits<
+                     double>::infinity())})}), // ASC_NULLS_FIRST
+                                               // upper
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({-std::numeric_limits<
+                 double>::infinity()})}), // ASC_NULLS_LAST
+                                          // lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 -std::numeric_limits<double>::infinity(),
+                 std::numeric_limits<double>::infinity())})}), // ASC_NULLS_LAST
+                                                               // upper
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({-std::numeric_limits<
+                 double>::infinity()})}), // DESC_NULLS_FIRST
+                                          // lower
+        makeRowVector(
+            {makeFlatVector<double>({std::nextafter(
+                 100.5, -std::numeric_limits<double>::infinity())}),
+             makeFlatVector<double>({std::numeric_limits<
+                 double>::infinity()})}), // DESC_NULLS_FIRST
+                                          // upper
+                                          // (carry-over)
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({-std::numeric_limits<
+                 double>::infinity()})}), // DESC_NULLS_LAST
+                                          // lower
+        makeRowVector(
+            {makeFlatVector<double>({std::nextafter(
+                 100.5, -std::numeric_limits<double>::infinity())}),
+             makeFlatVector<double>({std::numeric_limits<
+                 double>::infinity()})})); // DESC_NULLS_LAST
+                                           // upper
+                                           // (carry-over)
+  }
+}
+
+TEST_F(KeyEncoderTest, encodeIndexBoundsWithTimestampType) {
+  // Test Case 1: Both bounds inclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<velox::Timestamp>(
+                {velox::Timestamp(10, 100)})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<velox::Timestamp>(
+                {velox::Timestamp(100, 200)})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 201)})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 201)})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 199)})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 199)})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 2: Both bounds exclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<velox::Timestamp>(
+                {velox::Timestamp(10, 100)})}),
+            .inclusive = false},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<velox::Timestamp>(
+                {velox::Timestamp(100, 200)})}),
+            .inclusive = false},
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 101)})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 200)})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 101)})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 200)})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 99)})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 200)})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 99)})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 200)})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 3: Lower inclusive, upper exclusive
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<velox::Timestamp>(
+                {velox::Timestamp(10, 100)})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<velox::Timestamp>(
+                {velox::Timestamp(100, 200)})}),
+            .inclusive = false},
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 200)})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 200)})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 200)})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 200)})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 4: Only lower bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<velox::Timestamp>(
+                {velox::Timestamp(10, 100)})}),
+            .inclusive = true},
+        std::nullopt,
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 5: Only upper bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<velox::Timestamp>(
+                {velox::Timestamp(100, 200)})}),
+            .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 201)})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 201)})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 199)})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 199)})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 6: Single column with null in lower bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<velox::Timestamp>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<velox::Timestamp>(
+                {velox::Timestamp(100, 200)})}),
+            .inclusive = true},
+        makeRowVector({makeNullableFlatVector<velox::Timestamp>(
+            {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 201)})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeNullableFlatVector<velox::Timestamp>(
+            {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 201)})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeNullableFlatVector<velox::Timestamp>(
+            {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 199)})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeNullableFlatVector<velox::Timestamp>(
+            {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 199)})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 7: Multi-column, both inclusive
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<velox::Timestamp>({velox::Timestamp(10, 100)}),
+                 makeFlatVector<velox::Timestamp>(
+                     {velox::Timestamp(20, 200)})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+                 makeFlatVector<velox::Timestamp>(
+                     {velox::Timestamp(200, 400)})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(10, 100)}),
+             makeFlatVector<velox::Timestamp>(
+                 {velox::Timestamp(20, 200)})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>(
+                 {velox::Timestamp(200, 401)})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(10, 100)}),
+             makeFlatVector<velox::Timestamp>(
+                 {velox::Timestamp(20, 200)})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>(
+                 {velox::Timestamp(200, 401)})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(10, 100)}),
+             makeFlatVector<velox::Timestamp>(
+                 {velox::Timestamp(20, 200)})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>(
+                 {velox::Timestamp(200, 399)})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(10, 100)}),
+             makeFlatVector<velox::Timestamp>(
+                 {velox::Timestamp(20, 200)})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>(
+                 {velox::Timestamp(200, 399)})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 8: Lower bound bump failure - exclusive bound at max value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp::max()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsFirst;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 9: Lower bound bump failure - exclusive bound with null at end
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<velox::Timestamp>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 10: Multi-column lower bound bump failure - all columns at max
+  // value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp::max()}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp::max()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 11: Multi-column lower bound bump failure - all columns at max
+  // value with null
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<velox::Timestamp>({std::nullopt}),
+             makeNullableFlatVector<velox::Timestamp>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 12: Multi-column point lookup where the lower (second) column
+  // hits max value in ASC order. This tests carry-over behavior when
+  // incrementing - when c1 is at Timestamp::max(), the increment should carry
+  // over to c0, resulting in (c0+1nanos, Timestamp::min()).
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+                 makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                     velox::Timestamp::kMaxSeconds,
+                     velox::Timestamp::kMaxNanos)})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+                 makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                     velox::Timestamp::kMaxSeconds,
+                     velox::Timestamp::kMaxNanos)})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMaxSeconds,
+                 velox::Timestamp::kMaxNanos)})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 301)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMinSeconds, 0)})}), // ASC_NULLS_FIRST upper
+                                                        // (carry-over)
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMaxSeconds,
+                 velox::Timestamp::kMaxNanos)})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 301)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMinSeconds, 0)})}), // ASC_NULLS_LAST upper
+                                                        // (carry-over)
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMaxSeconds,
+                 velox::Timestamp::kMaxNanos)})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMaxSeconds,
+                 velox::Timestamp::kMaxNanos - 1)})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMaxSeconds,
+                 velox::Timestamp::kMaxNanos)})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMaxSeconds,
+                 velox::Timestamp::kMaxNanos - 1)})})); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 13: Multi-column point lookup where the lower (second) column
+  // hits min value in DESC order. This tests carry-over behavior when
+  // decrementing - when c1 is at Timestamp::min(), the decrement should carry
+  // over to c0, resulting in (c0-1nanos, Timestamp::max()).
+  {
+    runIndexBoundTests(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+                 makeFlatVector<velox::Timestamp>(
+                     {velox::Timestamp(velox::Timestamp::kMinSeconds, 0)})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+                 makeFlatVector<velox::Timestamp>(
+                     {velox::Timestamp(velox::Timestamp::kMinSeconds, 0)})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMinSeconds, 0)})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMinSeconds, 1)})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMinSeconds, 0)})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMinSeconds, 1)})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMinSeconds,
+                 0)})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 299)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMaxSeconds,
+                 velox::Timestamp::kMaxNanos)})}), // DESC_NULLS_FIRST upper
+                                                   // (carry-over)
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMinSeconds, 0)})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 299)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMaxSeconds,
+                 velox::Timestamp::kMaxNanos)})})); // DESC_NULLS_LAST upper
+                                                    // (carry-over)
+  }
+}
+
+TEST_F(KeyEncoderTest, encodeIndexBoundsWithStringType) {
+  // Helper to create string with embedded null byte (for increment result)
+  auto makeStringWithNull = [](const std::string& s) {
+    return s + std::string(1, '\0');
+  };
+
+  // Test Case 1: Both bounds inclusive
+  // For ascending order: increment appends '\0' (e.g., "orange" ->
+  // "orange\0") For descending order: decrement only works if string ends
+  // with '\0', otherwise increment fails and we get unbounded upper
+  // (std::nullopt)
+  {
+    EncodeIndexBoundsTestCase ascNullsFirstTestCase;
+    ascNullsFirstTestCase.indexColumns = {"c0"};
+    ascNullsFirstTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"apple"})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.sortOrder = velox::core::kAscNullsFirst;
+    ascNullsFirstTestCase.expectedLowerBound =
+        makeRowVector({makeFlatVector<std::string>({"apple"})});
+    ascNullsFirstTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({makeStringWithNull("orange")})});
+    SCOPED_TRACE(ascNullsFirstTestCase.debugString());
+    testIndexBounds(ascNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase ascNullsLastTestCase;
+    ascNullsLastTestCase.indexColumns = {"c0"};
+    ascNullsLastTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"apple"})}),
+        .inclusive = true};
+    ascNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+        .inclusive = true};
+    ascNullsLastTestCase.sortOrder = velox::core::kAscNullsLast;
+    ascNullsLastTestCase.expectedLowerBound =
+        makeRowVector({makeFlatVector<std::string>({"apple"})});
+    ascNullsLastTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({makeStringWithNull("orange")})});
+    SCOPED_TRACE(ascNullsLastTestCase.debugString());
+    testIndexBounds(ascNullsLastTestCase);
+
+    // For DESC order, decrement fails on "orange" which throws
+    // VELOX_UNREACHABLE because VARCHAR filter conversion is disabled for
+    // descending order.
+    {
+      EncodeIndexBoundsTestCase descNullsFirstTestCase;
+      descNullsFirstTestCase.indexColumns = {"c0"};
+      descNullsFirstTestCase.lowerBound = IndexBound{
+          .bound = makeRowVector({makeFlatVector<std::string>({"apple"})}),
+          .inclusive = true};
+      descNullsFirstTestCase.upperBound = IndexBound{
+          .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+          .inclusive = true};
+      descNullsFirstTestCase.sortOrder = velox::core::kDescNullsFirst;
+      SCOPED_TRACE(descNullsFirstTestCase.debugString());
+      VELOX_ASSERT_THROW(
+          testIndexBounds(descNullsFirstTestCase),
+          "Unexpected string underflow during descending bound increment");
+    }
+
+    {
+      EncodeIndexBoundsTestCase descNullsLastTestCase;
+      descNullsLastTestCase.indexColumns = {"c0"};
+      descNullsLastTestCase.lowerBound = IndexBound{
+          .bound = makeRowVector({makeFlatVector<std::string>({"apple"})}),
+          .inclusive = true};
+      descNullsLastTestCase.upperBound = IndexBound{
+          .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+          .inclusive = true};
+      descNullsLastTestCase.sortOrder = velox::core::kDescNullsLast;
+      SCOPED_TRACE(descNullsLastTestCase.debugString());
+      VELOX_ASSERT_THROW(
+          testIndexBounds(descNullsLastTestCase),
+          "Unexpected string underflow during descending bound increment");
+    }
+  }
+
+  // Test Case 2: Only lower bound
+  {
+    runIndexBoundTests(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<std::string>({"apple"})}),
+            .inclusive = true},
+        std::nullopt,
+        makeRowVector(
+            {makeFlatVector<std::string>({"apple"})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<std::string>({"apple"})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<std::string>({"apple"})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<std::string>({"apple"})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+  }
+
+  // Test Case 3: Only upper bound (inclusive)
+  // For ASC: increment appends '\0'
+  // For DESC: decrement fails on "orange" which throws VELOX_UNREACHABLE
+  // because VARCHAR filter conversion is disabled for descending order.
+  {
+    EncodeIndexBoundsTestCase ascNullsFirstTestCase;
+    ascNullsFirstTestCase.indexColumns = {"c0"};
+    ascNullsFirstTestCase.lowerBound = std::nullopt;
+    ascNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.sortOrder = velox::core::kAscNullsFirst;
+    ascNullsFirstTestCase.expectedLowerBound = std::nullopt;
+    ascNullsFirstTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({makeStringWithNull("orange")})});
+    SCOPED_TRACE(ascNullsFirstTestCase.debugString());
+    testIndexBounds(ascNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase ascNullsLastTestCase;
+    ascNullsLastTestCase.indexColumns = {"c0"};
+    ascNullsLastTestCase.lowerBound = std::nullopt;
+    ascNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+        .inclusive = true};
+    ascNullsLastTestCase.sortOrder = velox::core::kAscNullsLast;
+    ascNullsLastTestCase.expectedLowerBound = std::nullopt;
+    ascNullsLastTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({makeStringWithNull("orange")})});
+    SCOPED_TRACE(ascNullsLastTestCase.debugString());
+    testIndexBounds(ascNullsLastTestCase);
+
+    // For DESC order, decrement fails on "orange" which throws
+    // VELOX_UNREACHABLE because VARCHAR filter conversion is disabled for
+    // descending order.
+    {
+      EncodeIndexBoundsTestCase descNullsFirstTestCase;
+      descNullsFirstTestCase.indexColumns = {"c0"};
+      descNullsFirstTestCase.lowerBound = std::nullopt;
+      descNullsFirstTestCase.upperBound = IndexBound{
+          .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+          .inclusive = true};
+      descNullsFirstTestCase.sortOrder = velox::core::kDescNullsFirst;
+      SCOPED_TRACE(descNullsFirstTestCase.debugString());
+      VELOX_ASSERT_THROW(
+          testIndexBounds(descNullsFirstTestCase),
+          "Unexpected string underflow during descending bound increment");
+    }
+
+    {
+      EncodeIndexBoundsTestCase descNullsLastTestCase;
+      descNullsLastTestCase.indexColumns = {"c0"};
+      descNullsLastTestCase.lowerBound = std::nullopt;
+      descNullsLastTestCase.upperBound = IndexBound{
+          .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+          .inclusive = true};
+      descNullsLastTestCase.sortOrder = velox::core::kDescNullsLast;
+      SCOPED_TRACE(descNullsLastTestCase.debugString());
+      VELOX_ASSERT_THROW(
+          testIndexBounds(descNullsLastTestCase),
+          "Unexpected string underflow during descending bound increment");
+    }
+  }
+
+  // Test Case 4: String ending with '\0' - decrement should work
+  // This tests the Kudu-aligned behavior where decrement truncates trailing
+  // '\0'
+  {
+    std::string stringWithNull = makeStringWithNull("abc");
+
+    EncodeIndexBoundsTestCase descTestCase;
+    descTestCase.indexColumns = {"c0"};
+    descTestCase.lowerBound = std::nullopt;
+    descTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({stringWithNull})}),
+        .inclusive = true};
+    descTestCase.sortOrder = velox::core::kDescNullsFirst;
+    descTestCase.expectedLowerBound = std::nullopt;
+    // Decrement of "abc\0" should give "abc"
+    descTestCase.expectedUpperBound =
+        makeRowVector({makeFlatVector<std::string>({"abc"})});
+    SCOPED_TRACE(descTestCase.debugString());
+    testIndexBounds(descTestCase);
+  }
+
+  // Test Case 5: Empty string lower bound
+  {
+    EncodeIndexBoundsTestCase ascNullsFirstTestCase;
+    ascNullsFirstTestCase.indexColumns = {"c0"};
+    ascNullsFirstTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({""})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"abc"})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.sortOrder = velox::core::kAscNullsFirst;
+    ascNullsFirstTestCase.expectedLowerBound =
+        makeRowVector({makeFlatVector<std::string>({""})});
+    ascNullsFirstTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({makeStringWithNull("abc")})});
+    SCOPED_TRACE(ascNullsFirstTestCase.debugString());
+    testIndexBounds(ascNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase ascNullsLastTestCase;
+    ascNullsLastTestCase.indexColumns = {"c0"};
+    ascNullsLastTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({""})}),
+        .inclusive = true};
+    ascNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"abc"})}),
+        .inclusive = true};
+    ascNullsLastTestCase.sortOrder = velox::core::kAscNullsLast;
+    ascNullsLastTestCase.expectedLowerBound =
+        makeRowVector({makeFlatVector<std::string>({""})});
+    ascNullsLastTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({makeStringWithNull("abc")})});
+    SCOPED_TRACE(ascNullsLastTestCase.debugString());
+    testIndexBounds(ascNullsLastTestCase);
+
+    // For DESC order, decrement fails on "abc" which throws VELOX_UNREACHABLE
+    // because VARCHAR filter conversion is disabled for descending order.
+    {
+      EncodeIndexBoundsTestCase descNullsFirstTestCase;
+      descNullsFirstTestCase.indexColumns = {"c0"};
+      descNullsFirstTestCase.lowerBound = IndexBound{
+          .bound = makeRowVector({makeFlatVector<std::string>({""})}),
+          .inclusive = true};
+      descNullsFirstTestCase.upperBound = IndexBound{
+          .bound = makeRowVector({makeFlatVector<std::string>({"abc"})}),
+          .inclusive = true};
+      descNullsFirstTestCase.sortOrder = velox::core::kDescNullsFirst;
+      SCOPED_TRACE(descNullsFirstTestCase.debugString());
+      VELOX_ASSERT_THROW(
+          testIndexBounds(descNullsFirstTestCase),
+          "Unexpected string underflow during descending bound increment");
+    }
+
+    {
+      EncodeIndexBoundsTestCase descNullsLastTestCase;
+      descNullsLastTestCase.indexColumns = {"c0"};
+      descNullsLastTestCase.lowerBound = IndexBound{
+          .bound = makeRowVector({makeFlatVector<std::string>({""})}),
+          .inclusive = true};
+      descNullsLastTestCase.upperBound = IndexBound{
+          .bound = makeRowVector({makeFlatVector<std::string>({"abc"})}),
+          .inclusive = true};
+      descNullsLastTestCase.sortOrder = velox::core::kDescNullsLast;
+      SCOPED_TRACE(descNullsLastTestCase.debugString());
+      VELOX_ASSERT_THROW(
+          testIndexBounds(descNullsLastTestCase),
+          "Unexpected string underflow during descending bound increment");
+    }
+  }
+
+  // Test Case 6: Multi-column, both inclusive
+  // For multi-column, increment works on rightmost column first
+  {
+    EncodeIndexBoundsTestCase ascNullsFirstTestCase;
+    ascNullsFirstTestCase.indexColumns = {"c0", "c1"};
+    ascNullsFirstTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"apple"}),
+             makeFlatVector<std::string>({"banana"})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeFlatVector<std::string>({"peach"})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.sortOrder = velox::core::kAscNullsFirst;
+    ascNullsFirstTestCase.expectedLowerBound = makeRowVector(
+        {makeFlatVector<std::string>({"apple"}),
+         makeFlatVector<std::string>({"banana"})});
+    ascNullsFirstTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({"orange"}),
+         makeFlatVector<std::string>({makeStringWithNull("peach")})});
+    SCOPED_TRACE(ascNullsFirstTestCase.debugString());
+    testIndexBounds(ascNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase ascNullsLastTestCase;
+    ascNullsLastTestCase.indexColumns = {"c0", "c1"};
+    ascNullsLastTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"apple"}),
+             makeFlatVector<std::string>({"banana"})}),
+        .inclusive = true};
+    ascNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeFlatVector<std::string>({"peach"})}),
+        .inclusive = true};
+    ascNullsLastTestCase.sortOrder = velox::core::kAscNullsLast;
+    ascNullsLastTestCase.expectedLowerBound = makeRowVector(
+        {makeFlatVector<std::string>({"apple"}),
+         makeFlatVector<std::string>({"banana"})});
+    ascNullsLastTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({"orange"}),
+         makeFlatVector<std::string>({makeStringWithNull("peach")})});
+    SCOPED_TRACE(ascNullsLastTestCase.debugString());
+    testIndexBounds(ascNullsLastTestCase);
+
+    // For DESC order, decrement fails on rightmost column "peach",
+    // which throws VELOX_UNREACHABLE because VARCHAR filter conversion is
+    // disabled for descending order.
+    {
+      EncodeIndexBoundsTestCase descNullsFirstTestCase;
+      descNullsFirstTestCase.indexColumns = {"c0", "c1"};
+      descNullsFirstTestCase.lowerBound = IndexBound{
+          .bound = makeRowVector(
+              {makeFlatVector<std::string>({"apple"}),
+               makeFlatVector<std::string>({"banana"})}),
+          .inclusive = true};
+      descNullsFirstTestCase.upperBound = IndexBound{
+          .bound = makeRowVector(
+              {makeFlatVector<std::string>({"orange"}),
+               makeFlatVector<std::string>({"peach"})}),
+          .inclusive = true};
+      descNullsFirstTestCase.sortOrder = velox::core::kDescNullsFirst;
+      SCOPED_TRACE(descNullsFirstTestCase.debugString());
+      VELOX_ASSERT_THROW(
+          testIndexBounds(descNullsFirstTestCase),
+          "Unexpected string underflow during descending bound increment");
+    }
+
+    {
+      EncodeIndexBoundsTestCase descNullsLastTestCase;
+      descNullsLastTestCase.indexColumns = {"c0", "c1"};
+      descNullsLastTestCase.lowerBound = IndexBound{
+          .bound = makeRowVector(
+              {makeFlatVector<std::string>({"apple"}),
+               makeFlatVector<std::string>({"banana"})}),
+          .inclusive = true};
+      descNullsLastTestCase.upperBound = IndexBound{
+          .bound = makeRowVector(
+              {makeFlatVector<std::string>({"orange"}),
+               makeFlatVector<std::string>({"peach"})}),
+          .inclusive = true};
+      descNullsLastTestCase.sortOrder = velox::core::kDescNullsLast;
+      SCOPED_TRACE(descNullsLastTestCase.debugString());
+      VELOX_ASSERT_THROW(
+          testIndexBounds(descNullsLastTestCase),
+          "Unexpected string underflow during descending bound increment");
+    }
+  }
+
+  // Test Case 7: Single column with null in lower bound
+  // For null in lower bound with inclusive, the lower bound stays as null
+  // For upper bound, ASC order appends '\0', DESC order fails decrement
+  {
+    EncodeIndexBoundsTestCase ascNullsFirstTestCase;
+    ascNullsFirstTestCase.indexColumns = {"c0"};
+    ascNullsFirstTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.sortOrder = velox::core::kAscNullsFirst;
+    ascNullsFirstTestCase.expectedLowerBound =
+        makeRowVector({makeNullableFlatVector<std::string>({std::nullopt})});
+    ascNullsFirstTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({makeStringWithNull("orange")})});
+    SCOPED_TRACE(ascNullsFirstTestCase.debugString());
+    testIndexBounds(ascNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase ascNullsLastTestCase;
+    ascNullsLastTestCase.indexColumns = {"c0"};
+    ascNullsLastTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = true};
+    ascNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+        .inclusive = true};
+    ascNullsLastTestCase.sortOrder = velox::core::kAscNullsLast;
+    ascNullsLastTestCase.expectedLowerBound =
+        makeRowVector({makeNullableFlatVector<std::string>({std::nullopt})});
+    ascNullsLastTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({makeStringWithNull("orange")})});
+    SCOPED_TRACE(ascNullsLastTestCase.debugString());
+    testIndexBounds(ascNullsLastTestCase);
+
+    // For DESC order, decrement fails on "orange" which throws
+    // VELOX_UNREACHABLE because VARCHAR filter conversion is disabled for
+    // descending order.
+    {
+      EncodeIndexBoundsTestCase descNullsFirstTestCase;
+      descNullsFirstTestCase.indexColumns = {"c0"};
+      descNullsFirstTestCase.lowerBound = IndexBound{
+          .bound = makeRowVector(
+              {makeNullableFlatVector<std::string>({std::nullopt})}),
+          .inclusive = true};
+      descNullsFirstTestCase.upperBound = IndexBound{
+          .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+          .inclusive = true};
+      descNullsFirstTestCase.sortOrder = velox::core::kDescNullsFirst;
+      SCOPED_TRACE(descNullsFirstTestCase.debugString());
+      VELOX_ASSERT_THROW(
+          testIndexBounds(descNullsFirstTestCase),
+          "Unexpected string underflow during descending bound increment");
+    }
+
+    {
+      EncodeIndexBoundsTestCase descNullsLastTestCase;
+      descNullsLastTestCase.indexColumns = {"c0"};
+      descNullsLastTestCase.lowerBound = IndexBound{
+          .bound = makeRowVector(
+              {makeNullableFlatVector<std::string>({std::nullopt})}),
+          .inclusive = true};
+      descNullsLastTestCase.upperBound = IndexBound{
+          .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+          .inclusive = true};
+      descNullsLastTestCase.sortOrder = velox::core::kDescNullsLast;
+      SCOPED_TRACE(descNullsLastTestCase.debugString());
+      VELOX_ASSERT_THROW(
+          testIndexBounds(descNullsLastTestCase),
+          "Unexpected string underflow during descending bound increment");
+    }
+  }
+
+  // Test Case 8: Single column with null in upper bound
+  // Incrementing null in ASC_NULLS_FIRST gives empty string ""
+  // For ASC_NULLS_LAST, incrementing null gives "" (carry to first column)
+  // For DESC orders, decrement fails on strings
+  {
+    // ASC_NULLS_FIRST: null sorts first, incrementing gives ""
+    EncodeIndexBoundsTestCase ascNullsFirstTestCase;
+    ascNullsFirstTestCase.indexColumns = {"c0"};
+    ascNullsFirstTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"apple"})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.sortOrder = velox::core::kAscNullsFirst;
+    ascNullsFirstTestCase.expectedLowerBound =
+        makeRowVector({makeFlatVector<std::string>({"apple"})});
+    ascNullsFirstTestCase.expectedUpperBound =
+        makeRowVector({makeFlatVector<std::string>({""})});
+    SCOPED_TRACE(ascNullsFirstTestCase.debugString());
+    testIndexBounds(ascNullsFirstTestCase);
+
+    // ASC_NULLS_LAST: null is at end, incrementing null resets to ""
+    // For single column, this causes carry with no more columns,
+    // so the upper bound becomes unbounded (nullopt)
+    {
+      EncodeIndexBoundsTestCase ascNullsLastTestCase;
+      ascNullsLastTestCase.indexColumns = {"c0"};
+      ascNullsLastTestCase.lowerBound = IndexBound{
+          .bound = makeRowVector({makeFlatVector<std::string>({"apple"})}),
+          .inclusive = true};
+      ascNullsLastTestCase.upperBound = IndexBound{
+          .bound = makeRowVector(
+              {makeNullableFlatVector<std::string>({std::nullopt})}),
+          .inclusive = true};
+      ascNullsLastTestCase.sortOrder = velox::core::kAscNullsLast;
+      ascNullsLastTestCase.expectedLowerBound =
+          makeRowVector({makeFlatVector<std::string>({"apple"})});
+      // Single column null with NULLS_LAST: carry causes overflow, no upper
+      // bound
+      ascNullsLastTestCase.expectedUpperBound = std::nullopt;
+      SCOPED_TRACE(ascNullsLastTestCase.debugString());
+      testIndexBounds(ascNullsLastTestCase);
+    }
+
+    // DESC_NULLS_FIRST: null sorts first (min), incrementing null requires
+    // setMaxValueTyped which fails for strings
+    {
+      EncodeIndexBoundsTestCase descNullsFirstTestCase;
+      descNullsFirstTestCase.indexColumns = {"c0"};
+      descNullsFirstTestCase.lowerBound = IndexBound{
+          .bound = makeRowVector({makeFlatVector<std::string>({"apple"})}),
+          .inclusive = true};
+      descNullsFirstTestCase.upperBound = IndexBound{
+          .bound = makeRowVector(
+              {makeNullableFlatVector<std::string>({std::nullopt})}),
+          .inclusive = true};
+      descNullsFirstTestCase.sortOrder = velox::core::kDescNullsFirst;
+      SCOPED_TRACE(descNullsFirstTestCase.debugString());
+      VELOX_ASSERT_THROW(
+          testIndexBounds(descNullsFirstTestCase),
+          "Cannot set max value for type VARCHAR when incrementing NULL");
+    }
+
+    // DESC_NULLS_LAST: null is at end, incrementing null requires
+    // setMaxValueTyped which fails for strings
+    {
+      EncodeIndexBoundsTestCase descNullsLastTestCase;
+      descNullsLastTestCase.indexColumns = {"c0"};
+      descNullsLastTestCase.lowerBound = IndexBound{
+          .bound = makeRowVector({makeFlatVector<std::string>({"apple"})}),
+          .inclusive = true};
+      descNullsLastTestCase.upperBound = IndexBound{
+          .bound = makeRowVector(
+              {makeNullableFlatVector<std::string>({std::nullopt})}),
+          .inclusive = true};
+      descNullsLastTestCase.sortOrder = velox::core::kDescNullsLast;
+      SCOPED_TRACE(descNullsLastTestCase.debugString());
+      VELOX_ASSERT_THROW(
+          testIndexBounds(descNullsLastTestCase),
+          "Cannot set max value for type VARCHAR when incrementing NULL");
+    }
+  }
+
+  // Test Case 9: Multi-column with null in first column lower bound
+  // For ASC order, upper bound appends '\0' to rightmost column
+  // For DESC order, decrement fails on rightmost column "peach"
+  {
+    EncodeIndexBoundsTestCase ascNullsFirstTestCase;
+    ascNullsFirstTestCase.indexColumns = {"c0", "c1"};
+    ascNullsFirstTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<std::string>({std::nullopt}),
+             makeFlatVector<std::string>({"banana"})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeFlatVector<std::string>({"peach"})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.sortOrder = velox::core::kAscNullsFirst;
+    ascNullsFirstTestCase.expectedLowerBound = makeRowVector(
+        {makeNullableFlatVector<std::string>({std::nullopt}),
+         makeFlatVector<std::string>({"banana"})});
+    ascNullsFirstTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({"orange"}),
+         makeFlatVector<std::string>({makeStringWithNull("peach")})});
+    SCOPED_TRACE(ascNullsFirstTestCase.debugString());
+    testIndexBounds(ascNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase ascNullsLastTestCase;
+    ascNullsLastTestCase.indexColumns = {"c0", "c1"};
+    ascNullsLastTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<std::string>({std::nullopt}),
+             makeFlatVector<std::string>({"banana"})}),
+        .inclusive = true};
+    ascNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeFlatVector<std::string>({"peach"})}),
+        .inclusive = true};
+    ascNullsLastTestCase.sortOrder = velox::core::kAscNullsLast;
+    ascNullsLastTestCase.expectedLowerBound = makeRowVector(
+        {makeNullableFlatVector<std::string>({std::nullopt}),
+         makeFlatVector<std::string>({"banana"})});
+    ascNullsLastTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({"orange"}),
+         makeFlatVector<std::string>({makeStringWithNull("peach")})});
+    SCOPED_TRACE(ascNullsLastTestCase.debugString());
+    testIndexBounds(ascNullsLastTestCase);
+
+    // DESC order: decrement fails on both columns which throws
+    // VELOX_UNREACHABLE because VARCHAR filter conversion is disabled for
+    // descending order.
+    {
+      EncodeIndexBoundsTestCase descNullsFirstTestCase;
+      descNullsFirstTestCase.indexColumns = {"c0", "c1"};
+      descNullsFirstTestCase.lowerBound = IndexBound{
+          .bound = makeRowVector(
+              {makeNullableFlatVector<std::string>({std::nullopt}),
+               makeFlatVector<std::string>({"banana"})}),
+          .inclusive = true};
+      descNullsFirstTestCase.upperBound = IndexBound{
+          .bound = makeRowVector(
+              {makeFlatVector<std::string>({"orange"}),
+               makeFlatVector<std::string>({"peach"})}),
+          .inclusive = true};
+      descNullsFirstTestCase.sortOrder = velox::core::kDescNullsFirst;
+      SCOPED_TRACE(descNullsFirstTestCase.debugString());
+      VELOX_ASSERT_THROW(
+          testIndexBounds(descNullsFirstTestCase),
+          "Unexpected string underflow during descending bound increment");
+    }
+
+    {
+      EncodeIndexBoundsTestCase descNullsLastTestCase;
+      descNullsLastTestCase.indexColumns = {"c0", "c1"};
+      descNullsLastTestCase.lowerBound = IndexBound{
+          .bound = makeRowVector(
+              {makeNullableFlatVector<std::string>({std::nullopt}),
+               makeFlatVector<std::string>({"banana"})}),
+          .inclusive = true};
+      descNullsLastTestCase.upperBound = IndexBound{
+          .bound = makeRowVector(
+              {makeFlatVector<std::string>({"orange"}),
+               makeFlatVector<std::string>({"peach"})}),
+          .inclusive = true};
+      descNullsLastTestCase.sortOrder = velox::core::kDescNullsLast;
+      SCOPED_TRACE(descNullsLastTestCase.debugString());
+      VELOX_ASSERT_THROW(
+          testIndexBounds(descNullsLastTestCase),
+          "Unexpected string underflow during descending bound increment");
+    }
+  }
+
+  // Test Case 10: Multi-column with null in second column lower bound
+  {
+    EncodeIndexBoundsTestCase ascNullsFirstTestCase;
+    ascNullsFirstTestCase.indexColumns = {"c0", "c1"};
+    ascNullsFirstTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"apple"}),
+             makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeFlatVector<std::string>({"peach"})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.sortOrder = velox::core::kAscNullsFirst;
+    ascNullsFirstTestCase.expectedLowerBound = makeRowVector(
+        {makeFlatVector<std::string>({"apple"}),
+         makeNullableFlatVector<std::string>({std::nullopt})});
+    ascNullsFirstTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({"orange"}),
+         makeFlatVector<std::string>({makeStringWithNull("peach")})});
+    SCOPED_TRACE(ascNullsFirstTestCase.debugString());
+    testIndexBounds(ascNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase ascNullsLastTestCase;
+    ascNullsLastTestCase.indexColumns = {"c0", "c1"};
+    ascNullsLastTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"apple"}),
+             makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = true};
+    ascNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeFlatVector<std::string>({"peach"})}),
+        .inclusive = true};
+    ascNullsLastTestCase.sortOrder = velox::core::kAscNullsLast;
+    // For NULLS_LAST, null is at the end, no increment needed for lower bound
+    ascNullsLastTestCase.expectedLowerBound = makeRowVector(
+        {makeFlatVector<std::string>({"apple"}),
+         makeNullableFlatVector<std::string>({std::nullopt})});
+    ascNullsLastTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({"orange"}),
+         makeFlatVector<std::string>({makeStringWithNull("peach")})});
+    SCOPED_TRACE(ascNullsLastTestCase.debugString());
+    testIndexBounds(ascNullsLastTestCase);
+
+    // DESC order: decrement fails which throws VELOX_UNREACHABLE
+    // because VARCHAR filter conversion is disabled for descending order.
+    {
+      EncodeIndexBoundsTestCase descNullsFirstTestCase;
+      descNullsFirstTestCase.indexColumns = {"c0", "c1"};
+      descNullsFirstTestCase.lowerBound = IndexBound{
+          .bound = makeRowVector(
+              {makeFlatVector<std::string>({"apple"}),
+               makeNullableFlatVector<std::string>({std::nullopt})}),
+          .inclusive = true};
+      descNullsFirstTestCase.upperBound = IndexBound{
+          .bound = makeRowVector(
+              {makeFlatVector<std::string>({"orange"}),
+               makeFlatVector<std::string>({"peach"})}),
+          .inclusive = true};
+      descNullsFirstTestCase.sortOrder = velox::core::kDescNullsFirst;
+      SCOPED_TRACE(descNullsFirstTestCase.debugString());
+      VELOX_ASSERT_THROW(
+          testIndexBounds(descNullsFirstTestCase),
+          "Unexpected string underflow during descending bound increment");
+    }
+
+    {
+      EncodeIndexBoundsTestCase descNullsLastTestCase;
+      descNullsLastTestCase.indexColumns = {"c0", "c1"};
+      descNullsLastTestCase.lowerBound = IndexBound{
+          .bound = makeRowVector(
+              {makeFlatVector<std::string>({"apple"}),
+               makeNullableFlatVector<std::string>({std::nullopt})}),
+          .inclusive = true};
+      descNullsLastTestCase.upperBound = IndexBound{
+          .bound = makeRowVector(
+              {makeFlatVector<std::string>({"orange"}),
+               makeFlatVector<std::string>({"peach"})}),
+          .inclusive = true};
+      descNullsLastTestCase.sortOrder = velox::core::kDescNullsLast;
+      SCOPED_TRACE(descNullsLastTestCase.debugString());
+      VELOX_ASSERT_THROW(
+          testIndexBounds(descNullsLastTestCase),
+          "Unexpected string underflow during descending bound increment");
+    }
+  }
+
+  // Test Case 11: Multi-column with null in upper bound
+  // For ASC_NULLS_FIRST, null sorts first so incrementing null gives ""
+  // For ASC_NULLS_LAST, null sorts last, increment first column
+  // For DESC orders, decrement fails on first column string
+  {
+    EncodeIndexBoundsTestCase ascNullsFirstTestCase;
+    ascNullsFirstTestCase.indexColumns = {"c0", "c1"};
+    ascNullsFirstTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"apple"}),
+             makeFlatVector<std::string>({"banana"})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.sortOrder = velox::core::kAscNullsFirst;
+    ascNullsFirstTestCase.expectedLowerBound = makeRowVector(
+        {makeFlatVector<std::string>({"apple"}),
+         makeFlatVector<std::string>({"banana"})});
+    // Incrementing null in NULLS_FIRST gives ""
+    ascNullsFirstTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({"orange"}),
+         makeFlatVector<std::string>({""})});
+    SCOPED_TRACE(ascNullsFirstTestCase.debugString());
+    testIndexBounds(ascNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase ascNullsLastTestCase;
+    ascNullsLastTestCase.indexColumns = {"c0", "c1"};
+    ascNullsLastTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"apple"}),
+             makeFlatVector<std::string>({"banana"})}),
+        .inclusive = true};
+    ascNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = true};
+    ascNullsLastTestCase.sortOrder = velox::core::kAscNullsLast;
+    ascNullsLastTestCase.expectedLowerBound = makeRowVector(
+        {makeFlatVector<std::string>({"apple"}),
+         makeFlatVector<std::string>({"banana"})});
+    // Null at NULLS_LAST resets to "" for carry, increment first column
+    ascNullsLastTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({makeStringWithNull("orange")}),
+         makeFlatVector<std::string>({""})});
+    SCOPED_TRACE(ascNullsLastTestCase.debugString());
+    testIndexBounds(ascNullsLastTestCase);
+
+    // DESC order: decrement fails on null in second column, then fails on
+    // first column "orange" which throws VELOX_UNREACHABLE because VARCHAR
+    // filter conversion is disabled for descending order.
+    {
+      EncodeIndexBoundsTestCase descNullsFirstTestCase;
+      descNullsFirstTestCase.indexColumns = {"c0", "c1"};
+      descNullsFirstTestCase.lowerBound = IndexBound{
+          .bound = makeRowVector(
+              {makeFlatVector<std::string>({"apple"}),
+               makeFlatVector<std::string>({"banana"})}),
+          .inclusive = true};
+      descNullsFirstTestCase.upperBound = IndexBound{
+          .bound = makeRowVector(
+              {makeFlatVector<std::string>({"orange"}),
+               makeNullableFlatVector<std::string>({std::nullopt})}),
+          .inclusive = true};
+      descNullsFirstTestCase.sortOrder = velox::core::kDescNullsFirst;
+      SCOPED_TRACE(descNullsFirstTestCase.debugString());
+      VELOX_ASSERT_THROW(
+          testIndexBounds(descNullsFirstTestCase),
+          "Cannot set max value for type VARCHAR when incrementing NULL");
+    }
+
+    {
+      EncodeIndexBoundsTestCase descNullsLastTestCase;
+      descNullsLastTestCase.indexColumns = {"c0", "c1"};
+      descNullsLastTestCase.lowerBound = IndexBound{
+          .bound = makeRowVector(
+              {makeFlatVector<std::string>({"apple"}),
+               makeFlatVector<std::string>({"banana"})}),
+          .inclusive = true};
+      descNullsLastTestCase.upperBound = IndexBound{
+          .bound = makeRowVector(
+              {makeFlatVector<std::string>({"orange"}),
+               makeNullableFlatVector<std::string>({std::nullopt})}),
+          .inclusive = true};
+      descNullsLastTestCase.sortOrder = velox::core::kDescNullsLast;
+      SCOPED_TRACE(descNullsLastTestCase.debugString());
+      VELOX_ASSERT_THROW(
+          testIndexBounds(descNullsLastTestCase),
+          "Cannot set max value for type VARCHAR when incrementing NULL");
+    }
+  }
+
+  // Test lower bound bump failures
+  // Test Case 11: Single column lower bound bump failure - exclusive bound
+  // with empty string. For DESC order, decrement fails which throws
+  // VELOX_UNREACHABLE because VARCHAR filter conversion is disabled for
+  // descending order.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({""})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kDescNullsFirst;
+    SCOPED_TRACE(testCase.debugString());
+    VELOX_ASSERT_THROW(
+        testIndexBounds(testCase),
+        "Unexpected string underflow during descending bound increment");
+  }
+
+  // Test Case 12: Single column lower bound bump failure - exclusive bound
+  // with null at end
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 13: Multi-column lower bound bump failure - all columns with
+  // empty strings. For DESC order, decrement fails which throws
+  // VELOX_UNREACHABLE because VARCHAR filter conversion is disabled for
+  // descending order.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({""}),
+             makeFlatVector<std::string>({""})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kDescNullsFirst;
+    SCOPED_TRACE(testCase.debugString());
+    VELOX_ASSERT_THROW(
+        testIndexBounds(testCase),
+        "Unexpected string underflow during descending bound increment");
+  }
+
+  // Test Case 14: Multi-column lower bound bump failure - all columns at max
+  // value with null
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<std::string>({std::nullopt}),
+             makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+}
+
+// Test column separator with string + integer columns
+TEST_F(KeyEncoderTest, columnSeparatorTest) {
+  const std::vector<std::string> keyColumns = {"c0", "c1"};
+
+  // Test with multiple input datasets
+  const std::vector<velox::RowVectorPtr> inputs = {
+      makeRowVector({
+          makeFlatVector<std::string>({"0000", "00000"}),
+          makeFlatVector<int32_t>({0, 0}),
+      }),
+      makeRowVector(
+          {makeFlatVector<std::string>({"0000", "00000"}),
+           makeFlatVector<int32_t>({1, 1})})};
+
+  // Test all 4 sort order combinations
+  const std::vector<velox::core::SortOrder> sortOrders = {
+      velox::core::kAscNullsFirst,
+      velox::core::kAscNullsLast,
+      velox::core::kDescNullsFirst,
+      velox::core::kDescNullsLast,
+  };
+
+  for (const auto& input : inputs) {
+    SCOPED_TRACE(fmt::format("input:{}", input->toString(0, input->size())));
+    for (const auto& sortOrder : sortOrders) {
+      SCOPED_TRACE(
+          fmt::format(
+              "sortOrder: {} {}",
+              sortOrder.isAscending() ? "ASC" : "DESC",
+              sortOrder.isNullsFirst() ? "NULLS_FIRST" : "NULLS_LAST"));
+
+      auto encoder = KeyEncoder::create(
+          keyColumns,
+          asRowType(input->type()),
+          {sortOrder, sortOrder},
+          pool_.get());
+
+      // Use the public encode() method
+      std::vector<char> buffer;
+      std::vector<std::string_view> encodedKeys;
+      encoder->encode(input, encodedKeys, [&buffer](size_t size) -> void* {
+        buffer.resize(size);
+        return buffer.data();
+      });
+
+      // Verify we got 2 distinct keys
+      EXPECT_EQ(encodedKeys.size(), 2);
+      EXPECT_NE(encodedKeys[0], encodedKeys[1]);
+
+      if (sortOrder.isAscending()) {
+        EXPECT_LT(encodedKeys[0], encodedKeys[1]);
+      } else {
+        EXPECT_GT(encodedKeys[0], encodedKeys[1]);
+      }
+    }
+  }
+}
+
+// Tests for incrementNullColumnValue fix - verifies that incrementing NULL
+// values throws when the type doesn't support min/max representation.
+TEST_F(KeyEncoderTest, encodeIndexBoundsNullIncrementThrows) {
+  // Test Case 1: VARCHAR + DESC + NULLS_FIRST - incrementing NULL needs max
+  // value, which throws for strings since there's no max string representation.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kDescNullsFirst;
+    SCOPED_TRACE(testCase.debugString());
+    VELOX_ASSERT_THROW(
+        testIndexBounds(testCase),
+        "Cannot set max value for type VARCHAR when incrementing NULL");
+  }
+
+  // Test Case 2: VARCHAR + DESC + NULLS_LAST - resetting NULL for carry needs
+  // max value, which throws for strings.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kDescNullsLast;
+    SCOPED_TRACE(testCase.debugString());
+    VELOX_ASSERT_THROW(
+        testIndexBounds(testCase),
+        "Cannot set max value for type VARCHAR when incrementing NULL");
+  }
+
+  // Test Case 3: Multi-column with VARCHAR + DESC - second column NULL needs
+  // max value for carry, which throws.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<int64_t>({5}),
+             makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kDescNullsFirst;
+    SCOPED_TRACE(testCase.debugString());
+    VELOX_ASSERT_THROW(
+        testIndexBounds(testCase),
+        "Cannot set max value for type VARCHAR when incrementing NULL");
+  }
+
+  // Test Case 4: Integer + ASC + NULLS_FIRST - incrementing NULL gives
+  // MIN_VALUE which is supported.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound =
+            makeRowVector({makeNullableFlatVector<int64_t>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsFirst;
+    testCase.expectedLowerBound =
+        makeBigIntRow(std::numeric_limits<int64_t>::min());
+    testCase.expectedUpperBound = std::nullopt;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 5: Integer + DESC + NULLS_FIRST - incrementing NULL gives
+  // MAX_VALUE which is supported.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound =
+            makeRowVector({makeNullableFlatVector<int64_t>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kDescNullsFirst;
+    testCase.expectedLowerBound =
+        makeBigIntRow(std::numeric_limits<int64_t>::max());
+    testCase.expectedUpperBound = std::nullopt;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 6: Integer + ASC + NULLS_LAST - NULL is at end, can't increment,
+  // returns nullopt (single column overflow).
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound =
+            makeRowVector({makeNullableFlatVector<int64_t>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 7: VARCHAR + ASC + NULLS_FIRST - incrementing NULL gives empty
+  // string (MIN_VALUE), which is supported.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsFirst;
+    testCase.expectedLowerBound =
+        makeRowVector({makeFlatVector<std::string>({""})});
+    testCase.expectedUpperBound = std::nullopt;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 8: Multi-column carry behavior - when rightmost column
+  // overflows, it should reset and carry to the next column.
+  // (5, NULL) with ASC NULLS_LAST -> (6, MIN_VALUE) for integers
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<int64_t>({5}),
+             makeNullableFlatVector<int64_t>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    // NULL is at end in NULLS_LAST, so it overflows and carries to c0
+    // c0 increments from 5 to 6, c1 resets to MIN_VALUE
+    testCase.expectedLowerBound =
+        makeBigIntRow(6, std::numeric_limits<int64_t>::min());
+    testCase.expectedUpperBound = std::nullopt;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 9: Multi-column carry behavior with DESC NULLS_LAST
+  // (5, NULL) with DESC NULLS_LAST -> (4, MAX_VALUE) for integers
+  // In DESC order, "increment" means decrement, and NULL at end overflows
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = std::nullopt;
+    testCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<int64_t>({5}),
+             makeNullableFlatVector<int64_t>({std::nullopt})}),
+        .inclusive = true};
+    testCase.sortOrder = velox::core::kDescNullsLast;
+    // For inclusive upper bound, we increment to make it exclusive
+    // NULL is at end in NULLS_LAST (for DESC), so it overflows and carries
+    // c0 decrements from 5 to 4, c1 resets to MAX_VALUE (which is min in DESC
+    // order)
+    testCase.expectedLowerBound = std::nullopt;
+    testCase.expectedUpperBound =
+        makeBigIntRow(4, std::numeric_limits<int64_t>::max());
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+}
+
+// Tests for multiple rows in index bounds
+TEST_F(KeyEncoderTest, encodeIndexBoundsMultipleRows) {
+  // Test Case 1: Multiple rows - all succeed
+  {
+    IndexBounds indexBounds;
+    indexBounds.indexColumns = {"c0"};
+    indexBounds.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<int64_t>({1, 10, 100})}),
+        .inclusive = true};
+    indexBounds.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<int64_t>({5, 50, 500})}),
+        .inclusive = true};
+
+    ASSERT_TRUE(indexBounds.validate());
+
+    const auto inputType = asRowType(indexBounds.type());
+    const std::vector<velox::core::SortOrder> sortOrders(
+        indexBounds.indexColumns.size(), velox::core::kAscNullsFirst);
+    auto keyEncoder = KeyEncoder::create(
+        indexBounds.indexColumns, inputType, sortOrders, pool_.get());
+
+    const auto encodedBounds = keyEncoder->encodeIndexBounds(indexBounds);
+
+    // Should succeed with 3 results
+    ASSERT_EQ(encodedBounds.size(), 3);
+
+    // Verify each row has both lower and upper keys
+    for (size_t i = 0; i < 3; ++i) {
+      EXPECT_TRUE(encodedBounds[i].lowerKey.has_value())
+          << "Row " << i << " should have lowerKey";
+      EXPECT_TRUE(encodedBounds[i].upperKey.has_value())
+          << "Row " << i << " should have upperKey";
+    }
+
+    // Verify keys are different across rows
+    EXPECT_NE(encodedBounds[0].lowerKey, encodedBounds[1].lowerKey);
+    EXPECT_NE(encodedBounds[1].lowerKey, encodedBounds[2].lowerKey);
+  }
+
+  // Test Case 2: Multiple rows - one lower bound fails (throws)
+  {
+    IndexBounds indexBounds;
+    indexBounds.indexColumns = {"c0"};
+    // Second row has max value with exclusive bound - should fail to bump up
+    indexBounds.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<int64_t>(
+            {1, std::numeric_limits<int64_t>::max(), 100})}),
+        .inclusive = false};
+    indexBounds.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<int64_t>({5, 50, 500})}),
+        .inclusive = true};
+
+    ASSERT_TRUE(indexBounds.validate());
+
+    const auto inputType = asRowType(indexBounds.type());
+    const std::vector<velox::core::SortOrder> sortOrders(
+        indexBounds.indexColumns.size(), velox::core::kAscNullsFirst);
+    auto keyEncoder = KeyEncoder::create(
+        indexBounds.indexColumns, inputType, sortOrders, pool_.get());
+
+    // Should throw because one lower bound fails to bump up
+    VELOX_ASSERT_THROW(
+        keyEncoder->encodeIndexBounds(indexBounds),
+        "Failed to bump up lower bound");
+  }
+
+  // Test Case 3: Multiple rows - one upper bound fails (only that row gets
+  // nullopt)
+  {
+    IndexBounds indexBounds;
+    indexBounds.indexColumns = {"c0"};
+    indexBounds.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<int64_t>({1, 10, 100})}),
+        .inclusive = true};
+    // Second row has max value with inclusive bound - should fail to bump up
+    indexBounds.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<int64_t>(
+            {5, std::numeric_limits<int64_t>::max(), 500})}),
+        .inclusive = true};
+
+    ASSERT_TRUE(indexBounds.validate());
+
+    const auto inputType = asRowType(indexBounds.type());
+    const std::vector<velox::core::SortOrder> sortOrders(
+        indexBounds.indexColumns.size(), velox::core::kAscNullsFirst);
+    auto keyEncoder = KeyEncoder::create(
+        indexBounds.indexColumns, inputType, sortOrders, pool_.get());
+
+    const auto encodedBounds = keyEncoder->encodeIndexBounds(indexBounds);
+
+    // Should succeed with 3 results
+    ASSERT_EQ(encodedBounds.size(), 3);
+
+    // All rows should have lower keys
+    for (size_t i = 0; i < 3; ++i) {
+      EXPECT_TRUE(encodedBounds[i].lowerKey.has_value())
+          << "Row " << i << " should have lowerKey";
+    }
+
+    // Only row 1 (max value) should have nullopt upper key
+    EXPECT_TRUE(encodedBounds[0].upperKey.has_value())
+        << "Row 0 should have upperKey";
+    EXPECT_FALSE(encodedBounds[1].upperKey.has_value())
+        << "Row 1 should not have upperKey (unbounded due to overflow)";
+    EXPECT_TRUE(encodedBounds[2].upperKey.has_value())
+        << "Row 2 should have upperKey";
+  }
+
+  // Test Case 4: Multiple rows - multiple upper bounds fail (mixed success)
+  {
+    IndexBounds indexBounds;
+    indexBounds.indexColumns = {"c0"};
+    indexBounds.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<int64_t>({1, 10, 100, 1000})}),
+        .inclusive = true};
+    // Rows 0 and 2 have max value with inclusive bound - should fail to bump up
+    indexBounds.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<int64_t>(
+            {std::numeric_limits<int64_t>::max(),
+             50,
+             std::numeric_limits<int64_t>::max(),
+             5000})}),
+        .inclusive = true};
+
+    ASSERT_TRUE(indexBounds.validate());
+
+    const auto inputType = asRowType(indexBounds.type());
+    const std::vector<velox::core::SortOrder> sortOrders(
+        indexBounds.indexColumns.size(), velox::core::kAscNullsFirst);
+    auto keyEncoder = KeyEncoder::create(
+        indexBounds.indexColumns, inputType, sortOrders, pool_.get());
+
+    const auto encodedBounds = keyEncoder->encodeIndexBounds(indexBounds);
+
+    // Should succeed with 4 results
+    ASSERT_EQ(encodedBounds.size(), 4);
+
+    // All rows should have lower keys
+    for (size_t i = 0; i < 4; ++i) {
+      EXPECT_TRUE(encodedBounds[i].lowerKey.has_value())
+          << "Row " << i << " should have lowerKey";
+    }
+
+    // Rows 0 and 2 (max values) should have nullopt upper key
+    // Rows 1 and 3 should have upper key
+    EXPECT_FALSE(encodedBounds[0].upperKey.has_value())
+        << "Row 0 should not have upperKey (unbounded due to overflow)";
+    EXPECT_TRUE(encodedBounds[1].upperKey.has_value())
+        << "Row 1 should have upperKey";
+    EXPECT_FALSE(encodedBounds[2].upperKey.has_value())
+        << "Row 2 should not have upperKey (unbounded due to overflow)";
+    EXPECT_TRUE(encodedBounds[3].upperKey.has_value())
+        << "Row 3 should have upperKey";
+  }
+
+  // Test Case 5: Multiple rows - some upper bounds fail to bump (exclusive at
+  // max value) - treat as no bound
+  {
+    IndexBounds indexBounds;
+    indexBounds.indexColumns = {"c0"};
+    indexBounds.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<int64_t>({1, 10, 100, 1000})}),
+        .inclusive = true};
+    // Rows 0 and 2 have max value with exclusive bound - should fail to bump up
+    // and be treated as no upper bound
+    indexBounds.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<int64_t>(
+            {std::numeric_limits<int64_t>::max(),
+             50,
+             std::numeric_limits<int64_t>::max(),
+             5000})}),
+        .inclusive = true};
+
+    ASSERT_TRUE(indexBounds.validate());
+
+    const auto inputType = asRowType(indexBounds.type());
+    const std::vector<velox::core::SortOrder> sortOrders(
+        indexBounds.indexColumns.size(), velox::core::kAscNullsFirst);
+    auto keyEncoder = KeyEncoder::create(
+        indexBounds.indexColumns, inputType, sortOrders, pool_.get());
+
+    const auto encodedBounds = keyEncoder->encodeIndexBounds(indexBounds);
+
+    // Should succeed with 4 results
+    ASSERT_EQ(encodedBounds.size(), 4);
+
+    // All rows should have lower keys
+    for (size_t i = 0; i < 4; ++i) {
+      EXPECT_TRUE(encodedBounds[i].lowerKey.has_value())
+          << "Row " << i << " should have lowerKey";
+    }
+
+    // Rows 0 and 2 (max values with exclusive bound) should have nullopt upper
+    // key Rows 1 and 3 should have upper key
+    EXPECT_FALSE(encodedBounds[0].upperKey.has_value())
+        << "Row 0 should not have upperKey (unbounded due to overflow)";
+    EXPECT_TRUE(encodedBounds[1].upperKey.has_value())
+        << "Row 1 should have upperKey";
+    EXPECT_FALSE(encodedBounds[2].upperKey.has_value())
+        << "Row 2 should not have upperKey (unbounded due to overflow)";
+    EXPECT_TRUE(encodedBounds[3].upperKey.has_value())
+        << "Row 3 should have upperKey";
+  }
+
+  // Test Case 6: Multiple rows - multiple lower bounds fail (should throw)
+  {
+    IndexBounds indexBounds;
+    indexBounds.indexColumns = {"c0"};
+    // Rows 0 and 2 have max value with exclusive bound - should fail to bump up
+    indexBounds.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<int64_t>(
+            {std::numeric_limits<int64_t>::max(),
+             10,
+             std::numeric_limits<int64_t>::max(),
+             1000})}),
+        .inclusive = false};
+    indexBounds.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<int64_t>({5, 50, 500, 5000})}),
+        .inclusive = true};
+
+    ASSERT_TRUE(indexBounds.validate());
+
+    const auto inputType = asRowType(indexBounds.type());
+    const std::vector<velox::core::SortOrder> sortOrders(
+        indexBounds.indexColumns.size(), velox::core::kAscNullsFirst);
+    auto keyEncoder = KeyEncoder::create(
+        indexBounds.indexColumns, inputType, sortOrders, pool_.get());
+
+    // Should throw because some lower bounds fail to bump up
+    VELOX_ASSERT_THROW(
+        keyEncoder->encodeIndexBounds(indexBounds),
+        "Failed to bump up lower bound");
+  }
+
+  // Test Case 7: Multiple rows - all upper bounds fail (all rows get nullopt
+  // upper key)
+  {
+    IndexBounds indexBounds;
+    indexBounds.indexColumns = {"c0"};
+    indexBounds.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<int64_t>({1, 10, 100})}),
+        .inclusive = true};
+    // All rows have max value with inclusive bound - all should fail to bump up
+    indexBounds.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<int64_t>(
+            {std::numeric_limits<int64_t>::max(),
+             std::numeric_limits<int64_t>::max(),
+             std::numeric_limits<int64_t>::max()})}),
+        .inclusive = true};
+
+    ASSERT_TRUE(indexBounds.validate());
+
+    const auto inputType = asRowType(indexBounds.type());
+    const std::vector<velox::core::SortOrder> sortOrders(
+        indexBounds.indexColumns.size(), velox::core::kAscNullsFirst);
+    auto keyEncoder = KeyEncoder::create(
+        indexBounds.indexColumns, inputType, sortOrders, pool_.get());
+
+    const auto encodedBounds = keyEncoder->encodeIndexBounds(indexBounds);
+
+    // Should succeed with 3 results
+    ASSERT_EQ(encodedBounds.size(), 3);
+
+    // All rows should have lower keys
+    for (size_t i = 0; i < 3; ++i) {
+      EXPECT_TRUE(encodedBounds[i].lowerKey.has_value())
+          << "Row " << i << " should have lowerKey";
+    }
+
+    // All rows should have nullopt upper key (all overflowed)
+    for (size_t i = 0; i < 3; ++i) {
+      EXPECT_FALSE(encodedBounds[i].upperKey.has_value())
+          << "Row " << i
+          << " should not have upperKey (unbounded due to overflow)";
+    }
+  }
+
+  // Test Case 8: Multiple rows - all rows fail for both lower and upper bounds
+  // Lower bound failure takes precedence and throws
+  {
+    IndexBounds indexBounds;
+    indexBounds.indexColumns = {"c0"};
+    // All rows have max value with exclusive bound - all should fail to bump up
+    indexBounds.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<int64_t>(
+            {std::numeric_limits<int64_t>::max(),
+             std::numeric_limits<int64_t>::max(),
+             std::numeric_limits<int64_t>::max()})}),
+        .inclusive = false};
+    // All rows also have max value with inclusive bound
+    indexBounds.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<int64_t>(
+            {std::numeric_limits<int64_t>::max(),
+             std::numeric_limits<int64_t>::max(),
+             std::numeric_limits<int64_t>::max()})}),
+        .inclusive = true};
+
+    ASSERT_TRUE(indexBounds.validate());
+
+    const auto inputType = asRowType(indexBounds.type());
+    const std::vector<velox::core::SortOrder> sortOrders(
+        indexBounds.indexColumns.size(), velox::core::kAscNullsFirst);
+    auto keyEncoder = KeyEncoder::create(
+        indexBounds.indexColumns, inputType, sortOrders, pool_.get());
+
+    // Should throw because all lower bounds fail to bump up
+    VELOX_ASSERT_THROW(
+        keyEncoder->encodeIndexBounds(indexBounds),
+        "Failed to bump up lower bound");
+  }
+
+  // Test Case 9: Multiple rows - lower bound is not specified at all
+  {
+    IndexBounds indexBounds;
+    indexBounds.indexColumns = {"c0"};
+    indexBounds.lowerBound = std::nullopt;
+    indexBounds.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<int64_t>({5, 50, 500})}),
+        .inclusive = true};
+
+    ASSERT_TRUE(indexBounds.validate());
+
+    const auto inputType = asRowType(indexBounds.type());
+    const std::vector<velox::core::SortOrder> sortOrders(
+        indexBounds.indexColumns.size(), velox::core::kAscNullsFirst);
+    auto keyEncoder = KeyEncoder::create(
+        indexBounds.indexColumns, inputType, sortOrders, pool_.get());
+
+    const auto encodedBounds = keyEncoder->encodeIndexBounds(indexBounds);
+
+    // Should succeed with 3 results
+    ASSERT_EQ(encodedBounds.size(), 3);
+
+    // All rows should NOT have lower keys (unbounded)
+    for (size_t i = 0; i < 3; ++i) {
+      EXPECT_FALSE(encodedBounds[i].lowerKey.has_value())
+          << "Row " << i << " should not have lowerKey (unbounded)";
+    }
+
+    // All rows should have upper keys
+    for (size_t i = 0; i < 3; ++i) {
+      EXPECT_TRUE(encodedBounds[i].upperKey.has_value())
+          << "Row " << i << " should have upperKey";
+    }
+  }
+
+  // Test Case 10: Multiple rows - upper bound is not specified at all
+  {
+    IndexBounds indexBounds;
+    indexBounds.indexColumns = {"c0"};
+    indexBounds.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<int64_t>({1, 10, 100})}),
+        .inclusive = true};
+    indexBounds.upperBound = std::nullopt;
+
+    ASSERT_TRUE(indexBounds.validate());
+
+    const auto inputType = asRowType(indexBounds.type());
+    const std::vector<velox::core::SortOrder> sortOrders(
+        indexBounds.indexColumns.size(), velox::core::kAscNullsFirst);
+    auto keyEncoder = KeyEncoder::create(
+        indexBounds.indexColumns, inputType, sortOrders, pool_.get());
+
+    const auto encodedBounds = keyEncoder->encodeIndexBounds(indexBounds);
+
+    // Should succeed with 3 results
+    ASSERT_EQ(encodedBounds.size(), 3);
+
+    // All rows should have lower keys
+    for (size_t i = 0; i < 3; ++i) {
+      EXPECT_TRUE(encodedBounds[i].lowerKey.has_value())
+          << "Row " << i << " should have lowerKey";
+    }
+
+    // All rows should NOT have upper keys (unbounded)
+    for (size_t i = 0; i < 3; ++i) {
+      EXPECT_FALSE(encodedBounds[i].upperKey.has_value())
+          << "Row " << i << " should not have upperKey (unbounded)";
+    }
+  }
+
+  // Test Case 11: Multiple rows - both bounds are not specified at all
+  {
+    IndexBounds indexBounds;
+    indexBounds.indexColumns = {"c0"};
+    indexBounds.lowerBound = std::nullopt;
+    indexBounds.upperBound = std::nullopt;
+
+    ASSERT_FALSE(indexBounds.validate());
+  }
+}
+
+// Tests for non-flat encoding types (ConstantVector, DictionaryVector) in index
+// bounds across different data types.
+TEST_F(KeyEncoderTest, encodeIndexBoundsWithNonFlatEncoding) {
+  // Test case struct for non-flat encoding tests
+  struct NonFlatEncodingTestCase {
+    std::string name;
+    IndexBounds indexBounds;
+    velox::core::SortOrder sortOrder;
+    bool expectThrow{false};
+    std::string expectedErrorMsg;
+    // Expected results (only used when expectThrow is false)
+    size_t expectedNumResults{1};
+    std::optional<RowVectorPtr> expectedLowerBound;
+    std::optional<RowVectorPtr> expectedUpperBound;
+
+    std::string debugString() const {
+      return fmt::format(
+          "name={}, sortOrder={} {}",
+          name,
+          sortOrder.isAscending() ? "ASC" : "DESC",
+          sortOrder.isNullsFirst() ? "NULLS_FIRST" : "NULLS_LAST");
+    }
+  };
+
+  auto runTestCase = [this](const NonFlatEncodingTestCase& testCase) {
+    SCOPED_TRACE(testCase.debugString());
+
+    ASSERT_TRUE(testCase.indexBounds.validate());
+
+    const auto inputType = asRowType(testCase.indexBounds.type());
+    const std::vector<velox::core::SortOrder> sortOrders(
+        testCase.indexBounds.indexColumns.size(), testCase.sortOrder);
+    auto keyEncoder = KeyEncoder::create(
+        testCase.indexBounds.indexColumns, inputType, sortOrders, pool_.get());
+
+    if (testCase.expectThrow) {
+      VELOX_ASSERT_THROW(
+          keyEncoder->encodeIndexBounds(testCase.indexBounds),
+          testCase.expectedErrorMsg);
+      return;
+    }
+
+    const auto encodedBounds =
+        keyEncoder->encodeIndexBounds(testCase.indexBounds);
+    ASSERT_EQ(encodedBounds.size(), testCase.expectedNumResults);
+
+    for (size_t i = 0; i < testCase.expectedNumResults; ++i) {
+      EXPECT_EQ(
+          encodedBounds[i].lowerKey.has_value(),
+          testCase.expectedLowerBound.has_value())
+          << "Row " << i;
+      EXPECT_EQ(
+          encodedBounds[i].upperKey.has_value(),
+          testCase.expectedUpperBound.has_value())
+          << "Row " << i;
+    }
+
+    // Verify encoded keys match expected values
+    if (testCase.expectedLowerBound.has_value()) {
+      std::vector<char> expectedBuffer;
+      std::vector<std::string_view> expectedKeys;
+      keyEncoder->encode(
+          testCase.expectedLowerBound.value(),
+          expectedKeys,
+          [&expectedBuffer](size_t size) -> void* {
+            expectedBuffer.resize(size);
+            return expectedBuffer.data();
+          });
+      EXPECT_EQ(
+          encodedBounds[0].lowerKey.value(), std::string(expectedKeys[0]));
+    }
+
+    if (testCase.expectedUpperBound.has_value()) {
+      std::vector<char> expectedBuffer;
+      std::vector<std::string_view> expectedKeys;
+      keyEncoder->encode(
+          testCase.expectedUpperBound.value(),
+          expectedKeys,
+          [&expectedBuffer](size_t size) -> void* {
+            expectedBuffer.resize(size);
+            return expectedBuffer.data();
+          });
+      EXPECT_EQ(
+          encodedBounds[0].upperKey.value(), std::string(expectedKeys[0]));
+    }
+  };
+
+  // Helper to create IndexBounds
+  auto makeIndexBounds = [](const std::vector<std::string>& columns,
+                            std::optional<IndexBound> lower,
+                            std::optional<IndexBound> upper) {
+    IndexBounds bounds;
+    bounds.indexColumns = columns;
+    bounds.lowerBound = std::move(lower);
+    bounds.upperBound = std::move(upper);
+    return bounds;
+  };
+
+  // ==========================================================================
+  // Test BIGINT type with non-flat encodings
+  // ==========================================================================
+  {
+    SCOPED_TRACE("BIGINT");
+
+    std::vector<NonFlatEncodingTestCase> testCases;
+
+    // Test Case 1: ConstantVector for both bounds (inclusive)
+    testCases.push_back({
+        .name = "ConstantVector both bounds inclusive",
+        .indexBounds = makeIndexBounds(
+            {"c0"},
+            IndexBound{
+                .bound = makeRowVector({makeConstant<int64_t>(10, 1)}),
+                .inclusive = true},
+            IndexBound{
+                .bound = makeRowVector({makeConstant<int64_t>(100, 1)}),
+                .inclusive = true}),
+        .sortOrder = velox::core::kAscNullsFirst,
+        .expectedLowerBound = makeBigIntRow(10),
+        .expectedUpperBound = makeBigIntRow(101),
+    });
+
+    // Test Case 2: DictionaryVector for both bounds
+    auto baseBigint = makeFlatVector<int64_t>({50, 100, 120});
+    testCases.push_back({
+        .name = "DictionaryVector both bounds",
+        .indexBounds = makeIndexBounds(
+            {"c0"},
+            IndexBound{
+                .bound = makeRowVector({BaseVector::wrapInDictionary(
+                    nullptr, makeIndices({1}), 1, baseBigint)}),
+                .inclusive = true},
+            IndexBound{
+                .bound = makeRowVector({BaseVector::wrapInDictionary(
+                    nullptr, makeIndices({2}), 1, baseBigint)}),
+                .inclusive = false}),
+        .sortOrder = velox::core::kAscNullsFirst,
+        .expectedLowerBound = makeBigIntRow(100),
+        .expectedUpperBound = makeBigIntRow(120),
+    });
+
+    // Test Case 3: Multiple rows with ConstantVector
+    testCases.push_back({
+        .name = "Multiple rows with ConstantVector",
+        .indexBounds = makeIndexBounds(
+            {"c0"},
+            IndexBound{
+                .bound = makeRowVector({makeConstant<int64_t>(42, 3)}),
+                .inclusive = false},
+            IndexBound{
+                .bound = makeRowVector({makeConstant<int64_t>(100, 3)}),
+                .inclusive = true}),
+        .sortOrder = velox::core::kAscNullsFirst,
+        .expectedNumResults = 3,
+        .expectedLowerBound = makeBigIntRow(43),
+        .expectedUpperBound = makeBigIntRow(101),
+    });
+
+    // Test Case 4: Mixed encoding - ConstantVector lower, FlatVector upper
+    testCases.push_back({
+        .name = "Mixed: ConstantVector lower, FlatVector upper",
+        .indexBounds = makeIndexBounds(
+            {"c0"},
+            IndexBound{
+                .bound = makeRowVector({makeConstant<int64_t>(5, 1)}),
+                .inclusive = true},
+            IndexBound{.bound = makeBigIntRow(50), .inclusive = true}),
+        .sortOrder = velox::core::kAscNullsFirst,
+        .expectedLowerBound = makeBigIntRow(5),
+        .expectedUpperBound = makeBigIntRow(51),
+    });
+
+    // Test Case 5: Null ConstantVector with exclusive lower bound (should
+    // throw)
+    testCases.push_back({
+        .name = "Null ConstantVector lower bound exclusive - throws",
+        .indexBounds = makeIndexBounds(
+            {"c0"},
+            IndexBound{
+                .bound = makeRowVector(
+                    {makeConstant<int64_t>(std::nullopt, 1, BIGINT())}),
+                .inclusive = false},
+            IndexBound{.bound = makeBigIntRow(100), .inclusive = true}),
+        .sortOrder = velox::core::kAscNullsLast,
+        .expectThrow = true,
+        .expectedErrorMsg = "Failed to bump up lower bound",
+    });
+
+    for (const auto& testCase : testCases) {
+      runTestCase(testCase);
+    }
+  }
+
+  // ==========================================================================
+  // Test INTEGER type with non-flat encodings
+  // ==========================================================================
+  {
+    SCOPED_TRACE("INTEGER");
+
+    std::vector<NonFlatEncodingTestCase> testCases;
+
+    testCases.push_back({
+        .name = "ConstantVector both bounds inclusive",
+        .indexBounds = makeIndexBounds(
+            {"c0"},
+            IndexBound{
+                .bound = makeRowVector({makeConstant<int32_t>(10, 1)}),
+                .inclusive = true},
+            IndexBound{
+                .bound = makeRowVector({makeConstant<int32_t>(100, 1)}),
+                .inclusive = true}),
+        .sortOrder = velox::core::kAscNullsFirst,
+        .expectedLowerBound = makeIntRow(10),
+        .expectedUpperBound = makeIntRow(101),
+    });
+
+    auto baseInt = makeFlatVector<int32_t>({50, 100, 120});
+    testCases.push_back({
+        .name = "DictionaryVector both bounds",
+        .indexBounds = makeIndexBounds(
+            {"c0"},
+            IndexBound{
+                .bound = makeRowVector({BaseVector::wrapInDictionary(
+                    nullptr, makeIndices({1}), 1, baseInt)}),
+                .inclusive = true},
+            IndexBound{
+                .bound = makeRowVector({BaseVector::wrapInDictionary(
+                    nullptr, makeIndices({2}), 1, baseInt)}),
+                .inclusive = false}),
+        .sortOrder = velox::core::kAscNullsFirst,
+        .expectedLowerBound = makeIntRow(100),
+        .expectedUpperBound = makeIntRow(120),
+    });
+
+    for (const auto& testCase : testCases) {
+      runTestCase(testCase);
+    }
+  }
+
+  // ==========================================================================
+  // Test SMALLINT type with non-flat encodings
+  // ==========================================================================
+  {
+    SCOPED_TRACE("SMALLINT");
+
+    std::vector<NonFlatEncodingTestCase> testCases;
+
+    testCases.push_back({
+        .name = "ConstantVector both bounds inclusive",
+        .indexBounds = makeIndexBounds(
+            {"c0"},
+            IndexBound{
+                .bound = makeRowVector({makeConstant<int16_t>(10, 1)}),
+                .inclusive = true},
+            IndexBound{
+                .bound = makeRowVector({makeConstant<int16_t>(100, 1)}),
+                .inclusive = true}),
+        .sortOrder = velox::core::kAscNullsFirst,
+        .expectedLowerBound = makeRowVector({makeFlatVector<int16_t>({10})}),
+        .expectedUpperBound = makeRowVector({makeFlatVector<int16_t>({101})}),
+    });
+
+    auto baseSmallint = makeFlatVector<int16_t>({50, 100, 120});
+    testCases.push_back({
+        .name = "DictionaryVector both bounds",
+        .indexBounds = makeIndexBounds(
+            {"c0"},
+            IndexBound{
+                .bound = makeRowVector({BaseVector::wrapInDictionary(
+                    nullptr, makeIndices({1}), 1, baseSmallint)}),
+                .inclusive = true},
+            IndexBound{
+                .bound = makeRowVector({BaseVector::wrapInDictionary(
+                    nullptr, makeIndices({2}), 1, baseSmallint)}),
+                .inclusive = false}),
+        .sortOrder = velox::core::kAscNullsFirst,
+        .expectedLowerBound = makeRowVector({makeFlatVector<int16_t>({100})}),
+        .expectedUpperBound = makeRowVector({makeFlatVector<int16_t>({120})}),
+    });
+
+    for (const auto& testCase : testCases) {
+      runTestCase(testCase);
+    }
+  }
+
+  // ==========================================================================
+  // Test TINYINT type with non-flat encodings
+  // ==========================================================================
+  {
+    SCOPED_TRACE("TINYINT");
+
+    std::vector<NonFlatEncodingTestCase> testCases;
+
+    testCases.push_back({
+        .name = "ConstantVector both bounds inclusive",
+        .indexBounds = makeIndexBounds(
+            {"c0"},
+            IndexBound{
+                .bound = makeRowVector({makeConstant<int8_t>(10, 1)}),
+                .inclusive = true},
+            IndexBound{
+                .bound = makeRowVector({makeConstant<int8_t>(100, 1)}),
+                .inclusive = true}),
+        .sortOrder = velox::core::kAscNullsFirst,
+        .expectedLowerBound = makeRowVector({makeFlatVector<int8_t>({10})}),
+        .expectedUpperBound = makeRowVector({makeFlatVector<int8_t>({101})}),
+    });
+
+    auto baseTinyint = makeFlatVector<int8_t>({50, 100, 120});
+    testCases.push_back({
+        .name = "DictionaryVector both bounds",
+        .indexBounds = makeIndexBounds(
+            {"c0"},
+            IndexBound{
+                .bound = makeRowVector({BaseVector::wrapInDictionary(
+                    nullptr, makeIndices({1}), 1, baseTinyint)}),
+                .inclusive = true},
+            IndexBound{
+                .bound = makeRowVector({BaseVector::wrapInDictionary(
+                    nullptr, makeIndices({2}), 1, baseTinyint)}),
+                .inclusive = false}),
+        .sortOrder = velox::core::kAscNullsFirst,
+        .expectedLowerBound = makeRowVector({makeFlatVector<int8_t>({100})}),
+        .expectedUpperBound = makeRowVector({makeFlatVector<int8_t>({120})}),
+    });
+
+    for (const auto& testCase : testCases) {
+      runTestCase(testCase);
+    }
+  }
+
+  // ==========================================================================
+  // Test DOUBLE type with non-flat encodings
+  // ==========================================================================
+  {
+    SCOPED_TRACE("DOUBLE");
+
+    std::vector<NonFlatEncodingTestCase> testCases;
+
+    testCases.push_back({
+        .name = "ConstantVector both bounds inclusive",
+        .indexBounds = makeIndexBounds(
+            {"c0"},
+            IndexBound{
+                .bound = makeRowVector({makeConstant<double>(10.0, 1)}),
+                .inclusive = true},
+            IndexBound{
+                .bound = makeRowVector({makeConstant<double>(100.0, 1)}),
+                .inclusive = false}),
+        .sortOrder = velox::core::kAscNullsFirst,
+        .expectedLowerBound = makeRowVector({makeFlatVector<double>({10.0})}),
+        .expectedUpperBound = makeRowVector({makeFlatVector<double>({100.0})}),
+    });
+
+    auto baseDouble = makeFlatVector<double>({50.0, 100.0, 120.0});
+    testCases.push_back({
+        .name = "DictionaryVector both bounds",
+        .indexBounds = makeIndexBounds(
+            {"c0"},
+            IndexBound{
+                .bound = makeRowVector({BaseVector::wrapInDictionary(
+                    nullptr, makeIndices({1}), 1, baseDouble)}),
+                .inclusive = true},
+            IndexBound{
+                .bound = makeRowVector({BaseVector::wrapInDictionary(
+                    nullptr, makeIndices({2}), 1, baseDouble)}),
+                .inclusive = false}),
+        .sortOrder = velox::core::kAscNullsFirst,
+        .expectedLowerBound = makeRowVector({makeFlatVector<double>({100.0})}),
+        .expectedUpperBound = makeRowVector({makeFlatVector<double>({120.0})}),
+    });
+
+    for (const auto& testCase : testCases) {
+      runTestCase(testCase);
+    }
+  }
+
+  // ==========================================================================
+  // Test REAL type with non-flat encodings
+  // ==========================================================================
+  {
+    SCOPED_TRACE("REAL");
+
+    std::vector<NonFlatEncodingTestCase> testCases;
+
+    testCases.push_back({
+        .name = "ConstantVector both bounds inclusive",
+        .indexBounds = makeIndexBounds(
+            {"c0"},
+            IndexBound{
+                .bound = makeRowVector({makeConstant<float>(10.0f, 1)}),
+                .inclusive = true},
+            IndexBound{
+                .bound = makeRowVector({makeConstant<float>(100.0f, 1)}),
+                .inclusive = false}),
+        .sortOrder = velox::core::kAscNullsFirst,
+        .expectedLowerBound = makeRowVector({makeFlatVector<float>({10.0f})}),
+        .expectedUpperBound = makeRowVector({makeFlatVector<float>({100.0f})}),
+    });
+
+    auto baseFloat = makeFlatVector<float>({50.0f, 100.0f, 120.0f});
+    testCases.push_back({
+        .name = "DictionaryVector both bounds",
+        .indexBounds = makeIndexBounds(
+            {"c0"},
+            IndexBound{
+                .bound = makeRowVector({BaseVector::wrapInDictionary(
+                    nullptr, makeIndices({1}), 1, baseFloat)}),
+                .inclusive = true},
+            IndexBound{
+                .bound = makeRowVector({BaseVector::wrapInDictionary(
+                    nullptr, makeIndices({2}), 1, baseFloat)}),
+                .inclusive = false}),
+        .sortOrder = velox::core::kAscNullsFirst,
+        .expectedLowerBound = makeRowVector({makeFlatVector<float>({100.0f})}),
+        .expectedUpperBound = makeRowVector({makeFlatVector<float>({120.0f})}),
+    });
+
+    for (const auto& testCase : testCases) {
+      runTestCase(testCase);
+    }
+  }
+
+  // ==========================================================================
+  // Test VARCHAR type with non-flat encodings
+  // ==========================================================================
+  {
+    SCOPED_TRACE("VARCHAR");
+
+    std::vector<NonFlatEncodingTestCase> testCases;
+
+    testCases.push_back({
+        .name = "ConstantVector both bounds",
+        .indexBounds = makeIndexBounds(
+            {"c0"},
+            IndexBound{
+                .bound = makeRowVector({makeConstant<StringView>(
+                    StringView("apple"), 1, VARCHAR())}),
+                .inclusive = true},
+            IndexBound{
+                .bound = makeRowVector({makeConstant<StringView>(
+                    StringView("orange"), 1, VARCHAR())}),
+                .inclusive = false}),
+        .sortOrder = velox::core::kAscNullsFirst,
+        .expectedLowerBound = makeRowVector(
+            {makeFlatVector<StringView>({StringView("apple")}, VARCHAR())}),
+        .expectedUpperBound = makeRowVector(
+            {makeFlatVector<StringView>({StringView("orange")}, VARCHAR())}),
+    });
+
+    auto baseVarchar = makeFlatVector<StringView>(
+        {StringView("apple"), StringView("banana"), StringView("cherry")},
+        VARCHAR());
+    testCases.push_back({
+        .name = "DictionaryVector both bounds",
+        .indexBounds = makeIndexBounds(
+            {"c0"},
+            IndexBound{
+                .bound = makeRowVector({BaseVector::wrapInDictionary(
+                    nullptr, makeIndices({1}), 1, baseVarchar)}),
+                .inclusive = true},
+            IndexBound{
+                .bound = makeRowVector({BaseVector::wrapInDictionary(
+                    nullptr, makeIndices({2}), 1, baseVarchar)}),
+                .inclusive = false}),
+        .sortOrder = velox::core::kAscNullsFirst,
+        .expectedLowerBound = makeRowVector(
+            {makeFlatVector<StringView>({StringView("banana")}, VARCHAR())}),
+        .expectedUpperBound = makeRowVector(
+            {makeFlatVector<StringView>({StringView("cherry")}, VARCHAR())}),
+    });
+
+    for (const auto& testCase : testCases) {
+      runTestCase(testCase);
+    }
+  }
+
+  // ==========================================================================
+  // Test multi-column with mixed encodings
+  // ==========================================================================
+  {
+    SCOPED_TRACE("Multi-column mixed encodings");
+
+    auto baseC0 = makeFlatVector<int64_t>({20, 30, 40});
+
+    std::vector<NonFlatEncodingTestCase> testCases;
+
+    testCases.push_back({
+        .name = "ConstantVector + FlatVector lower, DictionaryVector + "
+                "ConstantVector upper",
+        .indexBounds = makeIndexBounds(
+            {"c0", "c1"},
+            IndexBound{
+                .bound = makeRowVector(
+                    {makeConstant<int64_t>(10, 1),
+                     makeFlatVector<int64_t>({100})}),
+                .inclusive = true},
+            IndexBound{
+                .bound = makeRowVector(
+                    {BaseVector::wrapInDictionary(
+                         nullptr, makeIndices({1}), 1, baseC0),
+                     makeConstant<int64_t>(200, 1)}),
+                .inclusive = true}),
+        .sortOrder = velox::core::kAscNullsFirst,
+        .expectedLowerBound = makeBigIntRow(10, 100),
+        .expectedUpperBound = makeBigIntRow(30, 201),
+    });
+
+    for (const auto& testCase : testCases) {
+      runTestCase(testCase);
+    }
+  }
+}
+TEST_F(KeyEncoderTest, encodedKeyBoundsToString) {
+  // Test case 1: Both bounds populated
+  {
+    EncodedKeyBounds bounds;
+    bounds.lowerKey = std::string("\x01\x02\x03", 3);
+    bounds.upperKey = std::string("\xAB\xCD\xEF", 3);
+    const auto str = bounds.toString();
+    EXPECT_EQ(str, "EncodedKeyBounds{lowerKey=010203, upperKey=abcdef}");
+  }
+
+  // Test case 2: Lower bound only (upper is unbounded)
+  {
+    EncodedKeyBounds bounds;
+    bounds.lowerKey = std::string("\x00\xFF", 2);
+    bounds.upperKey = std::nullopt;
+    const auto str = bounds.toString();
+    EXPECT_EQ(str, "EncodedKeyBounds{lowerKey=00ff, upperKey=unbounded}");
+  }
+
+  // Test case 3: Upper bound only (lower is unbounded)
+  {
+    EncodedKeyBounds bounds;
+    bounds.lowerKey = std::nullopt;
+    bounds.upperKey = std::string("\xDE\xAD\xBE\xEF", 4);
+    const auto str = bounds.toString();
+    EXPECT_EQ(str, "EncodedKeyBounds{lowerKey=unbounded, upperKey=deadbeef}");
+  }
+
+  // Test case 4: Both unbounded
+  {
+    EncodedKeyBounds bounds;
+    bounds.lowerKey = std::nullopt;
+    bounds.upperKey = std::nullopt;
+    const auto str = bounds.toString();
+    EXPECT_EQ(str, "EncodedKeyBounds{lowerKey=unbounded, upperKey=unbounded}");
+  }
+
+  // Test case 5: Empty strings
+  {
+    EncodedKeyBounds bounds;
+    bounds.lowerKey = "";
+    bounds.upperKey = "";
+    const auto str = bounds.toString();
+    EXPECT_EQ(str, "EncodedKeyBounds{lowerKey=, upperKey=}");
+  }
+}
+TEST(EncodedKeyBoundsTest, isPointLookup) {
+  struct TestCase {
+    std::optional<std::string> lowerKey;
+    std::optional<std::string> upperKey;
+    bool expected;
+
+    std::string debugString() const {
+      auto keyStr = [](const std::optional<std::string>& key) -> std::string {
+        return key.has_value() ? fmt::format("\"{}\"", key.value()) : "nullopt";
+      };
+      return fmt::format(
+          "lowerKey={}, upperKey={}, expected={}",
+          keyStr(lowerKey),
+          keyStr(upperKey),
+          expected);
+    }
+  };
+
+  const std::vector<TestCase> testCases = {
+      {"abc", "abc", true},
+      {"abc", "def", false},
+      {"abc", std::nullopt, false},
+      {std::nullopt, "abc", false},
+      {std::nullopt, std::nullopt, false},
+      {"", "", true},
+      {std::string("\x00\xFF", 2), std::string("\x00\xFF", 2), true},
+      {std::string("\x00\xFF", 2), std::string("\x00\xFE", 2), false},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    EncodedKeyBounds bounds;
+    bounds.lowerKey = testCase.lowerKey;
+    bounds.upperKey = testCase.upperKey;
+    EXPECT_EQ(bounds.isPointLookup(), testCase.expected);
+  }
+}
+
+} // namespace facebook::velox::serializer::test
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  folly::Init init{&argc, &argv, false};
+  return RUN_ALL_TESTS();
+}
diff --git a/velox/serializers/tests/PrestoSerializerTest.cpp b/velox/serializers/tests/PrestoSerializerTest.cpp
index c4f41f7d69f..644d69a576b 100644
--- a/velox/serializers/tests/PrestoSerializerTest.cpp
+++ b/velox/serializers/tests/PrestoSerializerTest.cpp
@@ -18,7 +18,7 @@
 #include <folly/Random.h>
 #include <gtest/gtest.h>
 #include <vector>
-#include "folly/experimental/EventCount.h"
+#include "folly/synchronization/EventCount.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/memory/ByteStream.h"
 #include "velox/functions/prestosql/types/IPAddressType.h"
@@ -123,8 +123,11 @@ class PrestoSerializerTest
         serdeOptions == nullptr ? false : serdeOptions->nullsFirst;
     const bool preserveEncodings =
         serdeOptions == nullptr ? false : serdeOptions->preserveEncodings;
+    const bool useMicrosecondPrecision =
+        serdeOptions == nullptr ? false : serdeOptions->useMicrosecondPrecision;
     serializer::presto::PrestoVectorSerde::PrestoOptions paramOptions{
         useLosslessTimestamp, kind, 0.8, nullsFirst, preserveEncodings};
+    paramOptions.useMicrosecondPrecision = useMicrosecondPrecision;
 
     return paramOptions;
   }
@@ -1157,6 +1160,40 @@ TEST_P(PrestoSerializerTest, timestampWithNanosecondPrecision) {
   assertEqualVectors(deserialized, expectedOutputWithLostPrecision);
 }
 
+TEST_P(PrestoSerializerTest, timestampMicrosecondPrecision) {
+  auto timestamps = makeFlatVector<Timestamp>({
+      Timestamp::fromMicros(1704067200000000),
+      Timestamp::fromMicros(1704153600000000),
+      Timestamp::fromMicros(-1000000),
+      Timestamp::fromMicros(0),
+  });
+
+  serializer::presto::PrestoVectorSerde::PrestoOptions opts;
+  opts.useMicrosecondPrecision = true;
+  testRoundTrip(timestamps, &opts);
+}
+
+TEST_P(PrestoSerializerTest, timestampMicrosecondPrecisionSomeNulls) {
+  auto timestamps = makeNullableFlatVector<Timestamp>(
+      {Timestamp::fromMicros(1704067200000000),
+       std::nullopt,
+       Timestamp::fromMicros(0),
+       std::nullopt});
+
+  serializer::presto::PrestoVectorSerde::PrestoOptions opts;
+  opts.useMicrosecondPrecision = true;
+  testRoundTrip(timestamps, &opts);
+}
+
+TEST_P(PrestoSerializerTest, timestampMicrosecondPrecisionAllNulls) {
+  auto timestamps = makeNullableFlatVector<Timestamp>(
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt});
+
+  serializer::presto::PrestoVectorSerde::PrestoOptions opts;
+  opts.useMicrosecondPrecision = true;
+  testRoundTrip(timestamps, &opts);
+}
+
 TEST_P(PrestoSerializerTest, longDecimal) {
   std::vector<int128_t> decimalValues(102);
   decimalValues[0] = DecimalUtil::kLongDecimalMin;
@@ -1719,6 +1756,108 @@ TEST_P(PrestoSerializerTest, checksum) {
       "Received corrupted serialized page.");
 }
 
+TEST_P(PrestoSerializerTest, minCompressionPageSizeBytes) {
+  if (GetParam() == common::CompressionKind::CompressionKind_NONE) {
+    GTEST_SKIP() << "Compression skip only applies with compression enabled";
+  }
+
+  auto rowVector = makeTestVector(10);
+  auto rowType = asRowType(rowVector->type());
+
+  auto options = getParamSerdeOptions(nullptr);
+  options.minCompressionPageSizeBytes = 1 << 30;
+
+  auto arena = std::make_unique<StreamArena>(pool_.get());
+  auto serializer = serde_->createIterativeSerializer(
+      rowType, rowVector->size(), arena.get(), &options);
+  serializer->append(rowVector);
+  facebook::velox::serializer::presto::PrestoOutputStreamListener listener;
+  std::ostringstream output;
+  OStreamOutputStream out(&output, &listener);
+  serializer->flush(&out);
+
+  auto stats = serializer->runtimeStats();
+  EXPECT_GT(stats.count("compressionSkippedBytes"), 0);
+  EXPECT_EQ(stats.count("compressionInputBytes"), 0);
+
+  auto arena2 = std::make_unique<StreamArena>(pool_.get());
+  options.minCompressionPageSizeBytes = 1;
+  auto serializer2 = serde_->createIterativeSerializer(
+      rowType, rowVector->size(), arena2.get(), &options);
+  serializer2->append(rowVector);
+  std::ostringstream output2;
+  OStreamOutputStream out2(&output2, &listener);
+  serializer2->flush(&out2);
+
+  auto stats2 = serializer2->runtimeStats();
+  EXPECT_GT(stats2.count("compressionInputBytes"), 0);
+  EXPECT_EQ(stats2.count("compressionSkippedBytes"), 0);
+}
+
+TEST_P(PrestoSerializerTest, minCompressionPageSizeBytesDisabledAtZero) {
+  if (GetParam() == common::CompressionKind::CompressionKind_NONE) {
+    GTEST_SKIP() << "Compression skip only applies with compression enabled";
+  }
+
+  auto rowVector = makeTestVector(10);
+  auto rowType = asRowType(rowVector->type());
+
+  auto options = getParamSerdeOptions(nullptr);
+  options.minCompressionPageSizeBytes = 0;
+
+  auto arena = std::make_unique<StreamArena>(pool_.get());
+  auto serializer = serde_->createIterativeSerializer(
+      rowType, rowVector->size(), arena.get(), &options);
+  serializer->append(rowVector);
+  facebook::velox::serializer::presto::PrestoOutputStreamListener listener;
+  std::ostringstream output;
+  OStreamOutputStream out(&output, &listener);
+  serializer->flush(&out);
+
+  auto stats = serializer->runtimeStats();
+  EXPECT_GT(stats.count("compressionInputBytes"), 0);
+  EXPECT_EQ(stats.count("compressionSkippedBytes"), 0);
+}
+
+TEST_P(PrestoSerializerTest, minCompressionPageSizeBytesAtBoundary) {
+  if (GetParam() == common::CompressionKind::CompressionKind_NONE) {
+    GTEST_SKIP() << "Compression skip only applies with compression enabled";
+  }
+
+  auto rowVector = makeTestVector(10);
+  auto rowType = asRowType(rowVector->type());
+  facebook::velox::serializer::presto::PrestoOutputStreamListener listener;
+
+  auto options = getParamSerdeOptions(nullptr);
+  options.minCompressionPageSizeBytes = 0;
+
+  // Measure the arena size produced by appending the row vector. Flush is
+  // unnecessary because the arena is filled by append and the size check in
+  // flush() reads the same value.
+  auto measureArena = std::make_unique<StreamArena>(pool_.get());
+  auto measureSerializer = serde_->createIterativeSerializer(
+      rowType, rowVector->size(), measureArena.get(), &options);
+  measureSerializer->append(rowVector);
+  const auto pageSize = measureArena->size();
+
+  options.minCompressionPageSizeBytes = static_cast<int32_t>(pageSize);
+  auto arena = std::make_unique<StreamArena>(pool_.get());
+  auto serializer = serde_->createIterativeSerializer(
+      rowType, rowVector->size(), arena.get(), &options);
+  serializer->append(rowVector);
+  ASSERT_EQ(arena->size(), pageSize)
+      << "Arena size after append must match measured size for the boundary "
+         "comparison to be meaningful";
+  std::ostringstream output;
+  OStreamOutputStream out(&output, &listener);
+  serializer->flush(&out);
+
+  auto stats = serializer->runtimeStats();
+  EXPECT_GT(stats.count("compressionInputBytes"), 0)
+      << "Page size exactly at threshold should attempt compression (strict <)";
+  EXPECT_EQ(stats.count("compressionSkippedBytes"), 0);
+}
+
 INSTANTIATE_TEST_SUITE_P(
     PrestoSerializerTest,
     PrestoSerializerTest,
@@ -1934,13 +2073,11 @@ class PrestoSerializerBatchEstimateSizeTest : public testing::Test,
     if (!isRegisteredVectorSerde()) {
       serializer::presto::PrestoVectorSerde::registerVectorSerde();
     }
-    ASSERT_EQ(getVectorSerde()->kind(), VectorSerde::Kind::kPresto);
-    if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kPresto)) {
+    ASSERT_EQ(getVectorSerde()->kind(), "Presto");
+    if (!isRegisteredNamedVectorSerde("Presto")) {
       serializer::presto::PrestoVectorSerde::registerNamedVectorSerde();
     }
-    ASSERT_EQ(
-        getNamedVectorSerde(VectorSerde::Kind::kPresto)->kind(),
-        VectorSerde::Kind::kPresto);
+    ASSERT_EQ(getNamedVectorSerde("Presto")->kind(), "Presto");
 
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   }
diff --git a/velox/serializers/tests/SerializedPageFileTest.cpp b/velox/serializers/tests/SerializedPageFileTest.cpp
new file mode 100644
index 00000000000..b97e36fbdb4
--- /dev/null
+++ b/velox/serializers/tests/SerializedPageFileTest.cpp
@@ -0,0 +1,561 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/serializers/SerializedPageFile.h"
+#include <boost/random/uniform_int_distribution.hpp>
+#include <folly/Random.h>
+#include <gtest/gtest.h>
+#include <vector>
+#include "folly/synchronization/EventCount.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
+#include "velox/expression/fuzzer/FuzzerToolkit.h"
+#include "velox/serializers/CompactRowSerializer.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/serializers/UnsafeRowSerializer.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+using namespace facebook::velox::serializer;
+using namespace facebook::velox::common::testutil;
+
+enum class SerdeType { kPresto, kCompactRow, kUnsafeRow };
+
+struct TestParams {
+  SerdeType serdeType;
+  common::CompressionKind compressionKind;
+};
+
+class SerializedPageFileTest : public ::testing::TestWithParam<TestParams>,
+                               public VectorTestBase {
+ protected:
+  static void SetUpTestSuite() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    const auto& params = GetParam();
+
+    deregisterVectorSerde();
+    deregisterNamedVectorSerde("Presto");
+    deregisterNamedVectorSerde("CompactRow");
+    deregisterNamedVectorSerde("UnsafeRow");
+
+    setupSerde(params.serdeType);
+    filesystems::registerLocalFileSystem();
+    tempDirPath_ = TempDirectoryPath::create();
+    compressionKind_ = params.compressionKind;
+  }
+
+  void TearDown() override {
+    deregisterVectorSerde();
+    deregisterNamedVectorSerde("Presto");
+    deregisterNamedVectorSerde("CompactRow");
+    deregisterNamedVectorSerde("UnsafeRow");
+  }
+
+  void setupSerde(SerdeType serdeType) {
+    switch (serdeType) {
+      case SerdeType::kPresto:
+        serializer::presto::PrestoVectorSerde::registerVectorSerde();
+        serializer::presto::PrestoVectorSerde::registerNamedVectorSerde();
+        serde_ = getNamedVectorSerde("Presto");
+        break;
+      case SerdeType::kCompactRow:
+        serializer::CompactRowVectorSerde::registerVectorSerde();
+        serializer::CompactRowVectorSerde::registerNamedVectorSerde();
+        serde_ = getNamedVectorSerde("CompactRow");
+        break;
+      case SerdeType::kUnsafeRow:
+        serializer::spark::UnsafeRowVectorSerde::registerVectorSerde();
+        serializer::spark::UnsafeRowVectorSerde::registerNamedVectorSerde();
+        serde_ = getNamedVectorSerde("UnsafeRow");
+        break;
+    }
+  }
+
+  std::unique_ptr<VectorSerde::Options> createSerdeOptions() {
+    const auto& params = GetParam();
+    switch (params.serdeType) {
+      case SerdeType::kPresto:
+        return std::make_unique<
+            serializer::presto::PrestoVectorSerde::PrestoOptions>(
+            false, // useLosslessTimestamp
+            compressionKind_, // compressionKind
+            0.8, // minCompressionRatio
+            false, // nullsFirst
+            false); // preserveEncodings
+      case SerdeType::kCompactRow:
+      case SerdeType::kUnsafeRow:
+        return std::make_unique<VectorSerde::Options>(compressionKind_, 0.8);
+    }
+    return nullptr;
+  }
+
+  RowVectorPtr createTestVector(int32_t numRows) {
+    VectorFuzzer fuzzer({.vectorSize = static_cast<size_t>(numRows)}, pool());
+    auto rowType = ROW({"a", "b", "c"}, {BIGINT(), VARCHAR(), DOUBLE()});
+    return fuzzer.fuzzRow(rowType);
+  }
+
+  std::string getTestFilePath(const std::string& name = "test") {
+    return fmt::format("{}/{}", tempDirPath_->getPath(), name);
+  }
+
+  std::unique_ptr<folly::IOBuf> createTestIOBuf(
+      const std::string& data = "test_data") {
+    return folly::IOBuf::copyBuffer(data);
+  }
+
+  VectorSerde* serde_{nullptr};
+  std::shared_ptr<TempDirectoryPath> tempDirPath_;
+  common::CompressionKind compressionKind_;
+};
+
+TEST_P(SerializedPageFileTest, serializedPageFileBasic) {
+  const std::string pathPrefix = getTestFilePath();
+  const uint32_t kFileId = 123;
+
+  auto pageFile =
+      SerializedPageFile::create(kFileId, pathPrefix, "", /*ioStats=*/nullptr);
+
+  EXPECT_EQ(pageFile->id(), kFileId);
+  EXPECT_TRUE(pageFile->path().find(pathPrefix) == 0);
+  EXPECT_EQ(pageFile->size(), 0);
+  EXPECT_NE(pageFile->file(), nullptr);
+
+  auto iobuf = createTestIOBuf("test data for file");
+  const uint64_t dataSize = iobuf->computeChainDataLength();
+  const uint64_t written = pageFile->write(std::move(iobuf));
+
+  EXPECT_EQ(written, dataSize);
+  EXPECT_EQ(pageFile->size(), dataSize);
+
+  auto fileInfo = pageFile->fileInfo();
+  EXPECT_EQ(fileInfo.id, kFileId);
+  EXPECT_EQ(fileInfo.path, pageFile->path());
+  EXPECT_EQ(fileInfo.size, dataSize);
+
+  pageFile->finish();
+  EXPECT_EQ(pageFile->size(), dataSize);
+  EXPECT_EQ(pageFile->file(), nullptr);
+}
+
+TEST_P(SerializedPageFileTest, serializedPageFileMultipleWrites) {
+  const uint32_t kFileId = 1;
+  const uint32_t kNumWrites = 10;
+
+  const std::string pathPrefix = getTestFilePath();
+  auto pageFile =
+      SerializedPageFile::create(kFileId, pathPrefix, "", /*ioStats=*/nullptr);
+
+  uint64_t totalSize = 0;
+  for (int i = 0; i < kNumWrites; ++i) {
+    auto data = fmt::format("chunk_{}", i);
+    auto iobuf = createTestIOBuf(data);
+    const uint64_t chunkSize = iobuf->computeChainDataLength();
+    const uint64_t written = pageFile->write(std::move(iobuf));
+    totalSize += chunkSize;
+
+    EXPECT_EQ(written, chunkSize);
+    EXPECT_EQ(pageFile->size(), totalSize);
+  }
+
+  pageFile->finish();
+  EXPECT_EQ(pageFile->size(), totalSize);
+}
+
+TEST_P(SerializedPageFileTest, serializedPageFileWriterBasicOperations) {
+  const std::string pathPrefix = getTestFilePath();
+  const uint64_t kTargetFileSize = 1024;
+  const uint64_t kWriteBufferSize = 512;
+  const uint32_t kRowCount = 100;
+
+  auto serdeOptions = createSerdeOptions();
+
+  SerializedPageFileWriter writer(
+      pathPrefix,
+      kTargetFileSize,
+      kWriteBufferSize,
+      "",
+      std::move(serdeOptions),
+      serde_,
+      pool());
+
+  EXPECT_EQ(writer.numFinishedFiles(), 0);
+
+  auto rowVector = createTestVector(kRowCount);
+  IndexRange range{0, kRowCount};
+  folly::Range<IndexRange*> ranges(&range, 1);
+
+  writer.write(rowVector, ranges);
+
+  writer.finishFile();
+  const auto numFinishedFiles = writer.numFinishedFiles();
+  const auto fileInfos = writer.finish();
+
+  EXPECT_EQ(numFinishedFiles, 1);
+  EXPECT_EQ(fileInfos.size(), numFinishedFiles);
+
+  for (const auto& fileInfo : fileInfos) {
+    EXPECT_FALSE(fileInfo.path.empty());
+    EXPECT_GT(fileInfo.size, 0);
+  }
+}
+
+TEST_P(SerializedPageFileTest, serializedPageFileWriterMultipleBatches) {
+  const uint64_t kTargetFileSize = 1024; // Increased target size
+  const uint64_t kWriteBufferSize = 512; // Smaller buffer to force more flushes
+  const uint32_t kNumWrites = 30; // Fewer writes but larger data
+  const uint32_t kRowsPerBatch = 100; // More rows to generate more data
+
+  const std::string pathPrefix = getTestFilePath();
+  auto serdeOptions = createSerdeOptions();
+
+  SerializedPageFileWriter writer(
+      pathPrefix,
+      kTargetFileSize,
+      kWriteBufferSize,
+      "",
+      std::move(serdeOptions),
+      serde_,
+      pool());
+
+  for (uint32_t i = 0; i < kNumWrites; ++i) {
+    auto rowVector = createTestVector(kRowsPerBatch);
+    IndexRange range{0, kRowsPerBatch};
+    folly::Range<IndexRange*> ranges(&range, 1);
+    writer.write(rowVector, ranges);
+  }
+
+  auto fileInfos = writer.finish();
+  EXPECT_GT(fileInfos.size(), 1);
+
+  uint64_t totalFileSize = 0;
+  for (const auto& fileInfo : fileInfos) {
+    totalFileSize += fileInfo.size;
+  }
+  EXPECT_GT(totalFileSize, 0);
+}
+
+TEST_P(SerializedPageFileTest, serializedPageFileWriterFinishMultipleTimes) {
+  const std::string pathPrefix = getTestFilePath();
+  const uint64_t kTargetFileSize = 1024;
+  const uint64_t kWriteBufferSize = 512;
+  const uint32_t kRowCount = 10;
+
+  auto serdeOptions = createSerdeOptions();
+
+  SerializedPageFileWriter writer(
+      pathPrefix,
+      kTargetFileSize,
+      kWriteBufferSize,
+      "",
+      std::move(serdeOptions),
+      serde_,
+      pool());
+
+  auto rowVector = createTestVector(kRowCount);
+  IndexRange range{0, kRowCount};
+  folly::Range<IndexRange*> ranges(&range, 1);
+  writer.write(rowVector, ranges);
+
+  auto fileInfos = writer.finish();
+  EXPECT_EQ(fileInfos.size(), 1);
+
+  VELOX_ASSERT_THROW(
+      writer.write(rowVector, ranges), "SerializedPageFileWriter has finished");
+}
+
+TEST_P(SerializedPageFileTest, serializedPageRoundTripBasic) {
+  constexpr uint64_t kTargetFileSize = 2048;
+  constexpr uint64_t kWriteBufferSize = 512;
+  constexpr uint64_t kReadBufferSize = 1024;
+
+  const std::string pathPrefix = getTestFilePath();
+  auto writeOptions = createSerdeOptions();
+  auto readOptions = createSerdeOptions();
+
+  SerializedPageFileWriter writer(
+      pathPrefix,
+      kTargetFileSize,
+      kWriteBufferSize,
+      "",
+      std::move(writeOptions),
+      serde_,
+      pool());
+
+  auto originalVector = createTestVector(100);
+  IndexRange range{0, 100};
+  folly::Range<IndexRange*> ranges(&range, 1);
+  writer.write(originalVector, ranges);
+
+  auto fileInfos = writer.finish();
+
+  // Since we only write once with a small vector (100 rows) and large target
+  // file size (2048 bytes), there should be exactly one file created
+  ASSERT_EQ(fileInfos.size(), 1);
+
+  const auto& filePath = fileInfos[0].path;
+  SerializedPageFileReader reader(
+      filePath,
+      kReadBufferSize,
+      asRowType(originalVector->type()),
+      serde_,
+      createSerdeOptions(),
+      pool(),
+      /*ioStats=*/nullptr);
+
+  RowVectorPtr readVector;
+  bool hasData = reader.nextBatch(readVector);
+  EXPECT_TRUE(hasData);
+
+  // Verify that the data content is identical
+  test::assertEqualVectors(originalVector, readVector);
+
+  // Verify there's no more data after the first batch
+  hasData = reader.nextBatch(readVector);
+  EXPECT_FALSE(hasData);
+}
+
+TEST_P(SerializedPageFileTest, serializedPageRoundTripMultipleBatches) {
+  const uint64_t kTargetFileSize = 256;
+  const uint64_t kWriteBufferSize = 100;
+  const uint64_t kReadBufferSize = 256;
+  const uint32_t kNumWrites = 30;
+  const uint32_t kRowsPerBatch = 50;
+  const auto pathPrefix = getTestFilePath();
+
+  SerializedPageFileWriter writer(
+      pathPrefix,
+      kTargetFileSize,
+      kWriteBufferSize,
+      "",
+      createSerdeOptions(),
+      serde_,
+      pool());
+
+  std::vector<RowVectorPtr> originalVectors;
+  IndexRange range{0, kRowsPerBatch};
+  folly::Range<IndexRange*> ranges(&range, 1);
+  for (int i = 0; i < kNumWrites; ++i) {
+    auto vector = createTestVector(kRowsPerBatch);
+    originalVectors.push_back(vector);
+    writer.write(vector, ranges);
+  }
+
+  auto fileInfos = writer.finish();
+  ASSERT_GT(fileInfos.size(), 1);
+
+  // Read from ALL files that were created and collect all the data
+  std::vector<RowVectorPtr> readVectors;
+
+  for (const auto& fileInfo : fileInfos) {
+    SerializedPageFileReader reader(
+        fileInfo.path,
+        kReadBufferSize,
+        asRowType(originalVectors[0]->type()),
+        serde_,
+        createSerdeOptions(),
+        pool(),
+        /*ioStats=*/nullptr);
+
+    RowVectorPtr readVector;
+    while (reader.nextBatch(readVector)) {
+      EXPECT_NE(readVector, nullptr);
+      EXPECT_EQ(
+          readVector->type()->toString(),
+          originalVectors[0]->type()->toString());
+      readVectors.push_back(readVector);
+    }
+  }
+
+  test::assertEqualVectors(
+      fuzzer::mergeRowVectors(originalVectors, pool()),
+      fuzzer::mergeRowVectors(readVectors, pool()));
+}
+
+TEST_P(SerializedPageFileTest, roundTripWithComplexTypes) {
+  // Skip UnsafeRow for complex types as it has limitations with nested
+  // structures
+  if (GetParam().serdeType == SerdeType::kUnsafeRow) {
+    GTEST_SKIP() << "UnsafeRow does not support complex nested types";
+  }
+
+  const uint64_t kTargetFileSize = 1024; // Small to encourage multiple files
+  const uint64_t kWriteBufferSize = 256;
+  const uint64_t kReadBufferSize = 512;
+  const uint64_t kNumWrites = 20;
+  const uint64_t kBatchSize = 30;
+  const std::string pathPrefix = getTestFilePath();
+
+  SerializedPageFileWriter writer(
+      pathPrefix,
+      kTargetFileSize,
+      kWriteBufferSize,
+      "",
+      createSerdeOptions(),
+      serde_,
+      pool());
+
+  VectorFuzzer fuzzer({.vectorSize = kBatchSize}, pool());
+  auto complexType =
+      ROW({"int_field", "string_field", "array_field", "map_field"},
+          {BIGINT(), VARCHAR(), ARRAY(INTEGER()), MAP(VARCHAR(), DOUBLE())});
+
+  // Write multiple batches with complex data
+  std::vector<RowVectorPtr> originalVectors;
+  for (int i = 0; i < kNumWrites; ++i) {
+    auto vector = fuzzer.fuzzRow(complexType);
+    originalVectors.push_back(vector);
+    IndexRange range{0, kBatchSize};
+    folly::Range<IndexRange*> ranges(&range, 1);
+    writer.write(vector, ranges);
+  }
+
+  auto fileInfos = writer.finish();
+  ASSERT_GT(fileInfos.size(), 1);
+
+  // Read from ALL files that were created and collect all the data
+  std::vector<RowVectorPtr> readVectors;
+
+  for (const auto& fileInfo : fileInfos) {
+    SerializedPageFileReader reader(
+        fileInfo.path,
+        kReadBufferSize,
+        asRowType(originalVectors[0]->type()),
+        serde_,
+        createSerdeOptions(),
+        pool(),
+        /*ioStats=*/nullptr);
+
+    RowVectorPtr readVector;
+    while (reader.nextBatch(readVector)) {
+      EXPECT_NE(readVector, nullptr);
+      EXPECT_EQ(
+          readVector->type()->toString(),
+          originalVectors[0]->type()->toString());
+      readVectors.push_back(readVector);
+    }
+  }
+
+  // Compare the concatenated vectors for exact data equality
+  test::assertEqualVectors(
+      fuzzer::mergeRowVectors(originalVectors, pool()),
+      fuzzer::mergeRowVectors(readVectors, pool()));
+}
+TEST_P(SerializedPageFileTest, emptyBatches) {
+  const std::string pathPrefix = getTestFilePath();
+  const uint64_t kTargetFileSize = 1024;
+  const uint64_t kWriteBufferSize = 512;
+
+  SerializedPageFileWriter writer(
+      pathPrefix,
+      kTargetFileSize,
+      kWriteBufferSize,
+      "",
+      createSerdeOptions(),
+      serde_,
+      pool());
+
+  auto rowType = ROW({"a", "b", "c"}, {BIGINT(), VARCHAR(), DOUBLE()});
+  auto emptyVector = BaseVector::create<RowVector>(rowType, 0, pool());
+
+  IndexRange range{0, 0};
+  folly::Range<IndexRange*> ranges(&range, 1);
+  writer.write(emptyVector, ranges);
+
+  auto fileInfos = writer.finish();
+  EXPECT_EQ(fileInfos.size(), 0);
+}
+
+// Generate test parameters for different serde types and compression kinds
+std::vector<TestParams> generateTestParams() {
+  std::vector<TestParams> params;
+
+  std::vector<SerdeType> serdeTypes = {
+      SerdeType::kPresto,
+  };
+
+  std::vector<common::CompressionKind> compressionKinds = {
+      common::CompressionKind::CompressionKind_NONE,
+      common::CompressionKind::CompressionKind_ZLIB,
+      common::CompressionKind::CompressionKind_SNAPPY,
+      common::CompressionKind::CompressionKind_ZSTD,
+      common::CompressionKind::CompressionKind_LZ4,
+      common::CompressionKind::CompressionKind_GZIP};
+
+  for (const auto& serdeType : serdeTypes) {
+    for (const auto& compressionKind : compressionKinds) {
+      params.push_back({serdeType, compressionKind});
+    }
+  }
+
+  return params;
+}
+
+// Custom test name generator
+std::string testNameGenerator(
+    const ::testing::TestParamInfo<TestParams>& info) {
+  std::string serdeName;
+  switch (info.param.serdeType) {
+    case SerdeType::kPresto:
+      serdeName = "Presto";
+      break;
+    case SerdeType::kCompactRow:
+      serdeName = "CompactRow";
+      break;
+    case SerdeType::kUnsafeRow:
+      serdeName = "UnsafeRow";
+      break;
+    default:
+      VELOX_UNSUPPORTED();
+  }
+
+  std::string compressionName;
+  switch (info.param.compressionKind) {
+    case common::CompressionKind::CompressionKind_NONE:
+      compressionName = "NoCompression";
+      break;
+    case common::CompressionKind::CompressionKind_ZLIB:
+      compressionName = "ZLIB";
+      break;
+    case common::CompressionKind::CompressionKind_SNAPPY:
+      compressionName = "Snappy";
+      break;
+    case common::CompressionKind::CompressionKind_ZSTD:
+      compressionName = "ZSTD";
+      break;
+    case common::CompressionKind::CompressionKind_LZ4:
+      compressionName = "LZ4";
+      break;
+    case common::CompressionKind::CompressionKind_GZIP:
+      compressionName = "GZIP";
+      break;
+    default:
+      VELOX_UNSUPPORTED();
+  }
+
+  return serdeName + "_" + compressionName;
+}
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    SerializedPageFileTest,
+    SerializedPageFileTest,
+    ::testing::ValuesIn(generateTestParams()),
+    testNameGenerator);
diff --git a/velox/serializers/tests/UnsafeRowSerializerTest.cpp b/velox/serializers/tests/UnsafeRowSerializerTest.cpp
index 36642caf993..54cb64a1501 100644
--- a/velox/serializers/tests/UnsafeRowSerializerTest.cpp
+++ b/velox/serializers/tests/UnsafeRowSerializerTest.cpp
@@ -26,9 +26,15 @@ using namespace facebook::velox;
 struct TestParam {
   common::CompressionKind compressionKind;
   bool appendRow;
-
-  TestParam(common::CompressionKind _compressionKind, bool _appendRow)
-      : compressionKind(_compressionKind), appendRow(_appendRow) {}
+  bool microBatchDeserialize;
+
+  TestParam(
+      common::CompressionKind _compressionKind,
+      bool _appendRow,
+      bool _microBatchDeserialize)
+      : compressionKind(_compressionKind),
+        appendRow(_appendRow),
+        microBatchDeserialize(_microBatchDeserialize) {}
 };
 
 class UnsafeRowSerializerTest : public ::testing::Test,
@@ -37,12 +43,18 @@ class UnsafeRowSerializerTest : public ::testing::Test,
  public:
   static std::vector<TestParam> getTestParams() {
     static std::vector<TestParam> testParams = {
-        {common::CompressionKind::CompressionKind_NONE, false},
-        {common::CompressionKind::CompressionKind_ZLIB, true},
-        {common::CompressionKind::CompressionKind_SNAPPY, false},
-        {common::CompressionKind::CompressionKind_ZSTD, true},
-        {common::CompressionKind::CompressionKind_LZ4, false},
-        {common::CompressionKind::CompressionKind_GZIP, true}};
+        {common::CompressionKind::CompressionKind_NONE, false, false},
+        {common::CompressionKind::CompressionKind_NONE, false, true},
+        {common::CompressionKind::CompressionKind_ZLIB, true, false},
+        {common::CompressionKind::CompressionKind_ZLIB, true, true},
+        {common::CompressionKind::CompressionKind_SNAPPY, false, false},
+        {common::CompressionKind::CompressionKind_SNAPPY, false, true},
+        {common::CompressionKind::CompressionKind_ZSTD, true, false},
+        {common::CompressionKind::CompressionKind_ZSTD, true, true},
+        {common::CompressionKind::CompressionKind_LZ4, false, false},
+        {common::CompressionKind::CompressionKind_LZ4, false, true},
+        {common::CompressionKind::CompressionKind_GZIP, true, false},
+        {common::CompressionKind::CompressionKind_GZIP, true, true}};
     return testParams;
   }
 
@@ -54,21 +66,20 @@ class UnsafeRowSerializerTest : public ::testing::Test,
   void SetUp() override {
     pool_ = memory::memoryManager()->addLeafPool();
     deregisterVectorSerde();
-    deregisterNamedVectorSerde(VectorSerde::Kind::kCompactRow);
+    deregisterNamedVectorSerde("CompactRow");
     serializer::spark::UnsafeRowVectorSerde::registerVectorSerde();
     serializer::spark::UnsafeRowVectorSerde::registerNamedVectorSerde();
-    ASSERT_EQ(getVectorSerde()->kind(), VectorSerde::Kind::kUnsafeRow);
-    ASSERT_EQ(
-        getNamedVectorSerde(VectorSerde::Kind::kUnsafeRow)->kind(),
-        VectorSerde::Kind::kUnsafeRow);
+    ASSERT_EQ(getVectorSerde()->kind(), "UnsafeRow");
+    ASSERT_EQ(getNamedVectorSerde("UnsafeRow")->kind(), "UnsafeRow");
     appendRow_ = GetParam().appendRow;
     compressionKind_ = GetParam().compressionKind;
+    microBatchDeserialize_ = GetParam().microBatchDeserialize;
     options_ = std::make_unique<VectorSerde::Options>(compressionKind_, 0.8);
   }
 
   void TearDown() override {
     deregisterVectorSerde();
-    deregisterNamedVectorSerde(VectorSerde::Kind::kUnsafeRow);
+    deregisterNamedVectorSerde("UnsafeRow");
   }
 
   void serialize(RowVectorPtr rowVector, std::ostream* output) {
@@ -131,14 +142,121 @@ class UnsafeRowSerializerTest : public ::testing::Test,
     return std::make_unique<BufferInputStream>(std::move(ranges));
   }
 
+  std::unique_ptr<ByteInputStream> toByteStream(
+      const std::string_view& input,
+      size_t pageSize = 32) {
+    auto rawBytes = reinterpret_cast<uint8_t*>(const_cast<char*>(input.data()));
+    size_t offset = 0;
+    std::vector<ByteRange> ranges;
+
+    // Split the input buffer into many different pages.
+    while (offset < input.length()) {
+      ranges.push_back({
+          rawBytes + offset,
+          std::min<int32_t>(pageSize, input.length() - offset),
+          0,
+      });
+      offset += pageSize;
+    }
+
+    return std::make_unique<BufferInputStream>(std::move(ranges));
+  }
+
+  RowVectorPtr concatenateRowVectors(
+      const std::vector<RowVectorPtr>& rowVectors,
+      velox::memory::MemoryPool* pool) {
+    if (rowVectors.empty()) {
+      return nullptr;
+    }
+
+    // Ensure all RowVectors have the same schema.
+    auto rowType = rowVectors.front()->type();
+    for (const auto& rowVector : rowVectors) {
+      VELOX_CHECK(
+          rowVector->type()->equivalent(*rowType),
+          "RowVectors must have the same schema");
+    }
+
+    // Calculate total size.
+    vector_size_t totalSize = 0;
+    for (const auto& rowVector : rowVectors) {
+      totalSize += rowVector->size();
+    }
+
+    // Create nulls buffer if any input has nulls
+    BufferPtr nulls = nullptr;
+    for (const auto& rowVector : rowVectors) {
+      if (rowVector->nulls()) {
+        nulls = AlignedBuffer::allocate<bool>(totalSize, pool, bits::kNotNull);
+        break;
+      }
+    }
+
+    // Concatenate child vectors.
+    std::vector<VectorPtr> concatenatedChildren;
+    for (size_t i = 0; i < rowType->size(); ++i) {
+      std::vector<VectorPtr> childVectors;
+      for (const auto& rowVector : rowVectors) {
+        childVectors.push_back(rowVector->childAt(i));
+      }
+      concatenatedChildren.push_back(
+          BaseVector::create(rowType->childAt(i), totalSize, pool));
+      vector_size_t offset = 0;
+      for (const auto& childVector : childVectors) {
+        concatenatedChildren.back()->copy(
+            childVector.get(), offset, 0, childVector->size());
+        offset += childVector->size();
+      }
+    }
+
+    // Copy nulls if needed
+    if (nulls != nullptr) {
+      auto rawNulls = nulls->asMutable<uint64_t>();
+      vector_size_t offset = 0;
+      for (const auto& rowVector : rowVectors) {
+        if (rowVector->nulls()) {
+          bits::copyBits(
+              rowVector->nulls()->as<uint64_t>(),
+              0,
+              rawNulls,
+              offset,
+              rowVector->size());
+        }
+        offset += rowVector->size();
+      }
+    }
+
+    return std::make_shared<RowVector>(
+        pool, rowType, nulls, totalSize, std::move(concatenatedChildren));
+  }
+
   RowVectorPtr deserialize(
       std::shared_ptr<const RowType> rowType,
       const std::vector<std::string_view>& input) {
     auto byteStream = toByteStream(input);
-
     RowVectorPtr result;
-    getVectorSerde()->deserialize(
-        byteStream.get(), pool_.get(), rowType, &result, options_.get());
+    if (microBatchDeserialize_) {
+      static constexpr int32_t kBatchSize = 3;
+      std::unique_ptr<RowIterator> rowIterator;
+      std::vector<RowVectorPtr> results;
+      while (!byteStream->atEnd() ||
+             (rowIterator != nullptr && rowIterator->hasNext())) {
+        results.emplace_back();
+        dynamic_cast<serializer::spark::UnsafeRowVectorSerde*>(getVectorSerde())
+            ->deserialize(
+                byteStream.get(),
+                rowIterator,
+                kBatchSize,
+                rowType,
+                &results.back(),
+                pool_.get(),
+                options_.get());
+      }
+      result = concatenateRowVectors(results, pool_.get());
+    } else {
+      getVectorSerde()->deserialize(
+          byteStream.get(), pool_.get(), rowType, &result, options_.get());
+    }
     return result;
   }
 
@@ -206,6 +324,7 @@ class UnsafeRowSerializerTest : public ::testing::Test,
   common::CompressionKind compressionKind_;
   std::unique_ptr<VectorSerde::Options> options_;
   bool appendRow_;
+  bool microBatchDeserialize_;
 };
 
 // These expected binary buffers were samples taken using Spark's java code.
@@ -512,4 +631,12 @@ TEST_P(UnsafeRowSerializerTest, multiPage) {
 VELOX_INSTANTIATE_TEST_SUITE_P(
     UnsafeRowSerializerTest,
     UnsafeRowSerializerTest,
-    testing::ValuesIn(UnsafeRowSerializerTest::getTestParams()));
+    testing::ValuesIn(UnsafeRowSerializerTest::getTestParams()),
+    [](const testing::TestParamInfo<TestParam>& info) {
+      return fmt::format(
+          "{}_{}_{}",
+          compressionKindToString(info.param.compressionKind),
+          info.param.appendRow ? "append" : "batch",
+          info.param.microBatchDeserialize ? "rowDeserialize"
+                                           : "batchDeserialize");
+    });
diff --git a/velox/tool/trace/AggregationReplayer.cpp b/velox/tool/trace/AggregationReplayer.cpp
index 1c397461a8a..79c3e3ba304 100644
--- a/velox/tool/trace/AggregationReplayer.cpp
+++ b/velox/tool/trace/AggregationReplayer.cpp
@@ -39,6 +39,7 @@ core::PlanNodePtr AggregationReplayer::createPlanNode(
       aggregationNode->globalGroupingSets(),
       aggregationNode->groupId(),
       aggregationNode->ignoreNullKeys(),
+      aggregationNode->noGroupsSpanBatches(),
       source);
 }
 } // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/AggregationReplayer.h b/velox/tool/trace/AggregationReplayer.h
index 3613cff3324..0b8c2fcb812 100644
--- a/velox/tool/trace/AggregationReplayer.h
+++ b/velox/tool/trace/AggregationReplayer.h
@@ -29,6 +29,7 @@ class AggregationReplayer : public OperatorReplayerBase {
       const std::string& taskId,
       const std::string& nodeId,
       const std::string& operatorType,
+      const std::string& spillBaseDir,
       const std::string& driverIds,
       uint64_t queryCapacity,
       folly::Executor* executor)
@@ -38,6 +39,7 @@ class AggregationReplayer : public OperatorReplayerBase {
             taskId,
             nodeId,
             operatorType,
+            spillBaseDir,
             driverIds,
             queryCapacity,
             executor) {}
diff --git a/velox/tool/trace/CMakeLists.txt b/velox/tool/trace/CMakeLists.txt
index 4f655353eeb..43fd8a75130 100644
--- a/velox/tool/trace/CMakeLists.txt
+++ b/velox/tool/trace/CMakeLists.txt
@@ -18,14 +18,37 @@ add_library(
   FilterProjectReplayer.cpp
   HashJoinReplayer.cpp
   IndexLookupJoinReplayer.cpp
+  MergeJoinReplayer.cpp
   OperatorReplayerBase.cpp
+  OrderByReplayer.cpp
   PartitionedOutputReplayer.cpp
   TableScanReplayer.cpp
   TableWriterReplayer.cpp
+  TopNRowNumberReplayer.cpp
+  TraceReplayerConfigPrompt.cpp
   TraceReplayRunner.cpp
   TraceReplayTaskRunner.cpp
   UnnestReplayer.cpp
 )
+velox_add_test_headers(
+  velox_query_trace_replayer_base
+  AggregationReplayer.h
+  FilterProjectReplayer.h
+  HashJoinReplayer.h
+  IndexLookupJoinReplayer.h
+  MergeJoinReplayer.h
+  OperatorReplayerBase.h
+  OrderByReplayer.h
+  PartitionedOutputReplayer.h
+  TableScanReplayer.h
+  TableWriterReplayer.h
+  TopNRowNumberReplayer.h
+  TraceFileToolRunner.h
+  TraceReplayRunner.h
+  TraceReplayTaskRunner.h
+  TraceReplayerConfigPrompt.h
+  UnnestReplayer.h
+)
 
 target_link_libraries(
   velox_query_trace_replayer_base
diff --git a/velox/tool/trace/FilterProjectReplayer.cpp b/velox/tool/trace/FilterProjectReplayer.cpp
index 0a7a4b523a0..d6b86c61183 100644
--- a/velox/tool/trace/FilterProjectReplayer.cpp
+++ b/velox/tool/trace/FilterProjectReplayer.cpp
@@ -15,8 +15,8 @@
  */
 
 #include "velox/tool/trace/FilterProjectReplayer.h"
-#include "velox/exec/TraceUtil.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/trace/TraceUtil.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
@@ -65,10 +65,8 @@ core::PlanNodePtr FilterProjectReplayer::createPlanNode(
 bool FilterProjectReplayer::isFilterProject(
     const core::PlanNode* filterNode) const {
   const auto* projectNode =
-      dynamic_cast<const core::ProjectNode*>(core::PlanNode::findFirstNode(
-          planFragment_.get(), [this](const core::PlanNode* node) {
-            return node->id() == std::to_string(std::stoull(nodeId_) + 1);
-          }));
+      dynamic_cast<const core::ProjectNode*>(core::PlanNode::findNodeById(
+          planFragment_.get(), std::to_string(std::stoull(nodeId_) + 1)));
   return projectNode != nullptr && projectNode->name() == "Project" &&
       projectNode->sources().size() == 1 &&
       projectNode->sources().front()->id() == nodeId_;
diff --git a/velox/tool/trace/FilterProjectReplayer.h b/velox/tool/trace/FilterProjectReplayer.h
index 2df1f679ac2..a5a6bfc6c77 100644
--- a/velox/tool/trace/FilterProjectReplayer.h
+++ b/velox/tool/trace/FilterProjectReplayer.h
@@ -43,6 +43,7 @@ class FilterProjectReplayer : public OperatorReplayerBase {
             taskId,
             nodeId,
             operatorType,
+            "",
             driverIds,
             queryCapacity,
             executor) {}
diff --git a/velox/tool/trace/HashJoinReplayer.cpp b/velox/tool/trace/HashJoinReplayer.cpp
index c39a7f61112..478233aae4c 100644
--- a/velox/tool/trace/HashJoinReplayer.cpp
+++ b/velox/tool/trace/HashJoinReplayer.cpp
@@ -15,8 +15,8 @@
  */
 
 #include "velox/tool/trace/HashJoinReplayer.h"
-#include "velox/exec/TraceUtil.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/trace/TraceUtil.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
diff --git a/velox/tool/trace/HashJoinReplayer.h b/velox/tool/trace/HashJoinReplayer.h
index f0277753582..d8d09ae3a1d 100644
--- a/velox/tool/trace/HashJoinReplayer.h
+++ b/velox/tool/trace/HashJoinReplayer.h
@@ -29,6 +29,7 @@ class HashJoinReplayer final : public OperatorReplayerBase {
       const std::string& taskId,
       const std::string& nodeId,
       const std::string& operatorType,
+      const std::string& spillBaseDir,
       const std::string& driverIds,
       uint64_t queryCapacity,
       folly::Executor* executor)
@@ -38,6 +39,7 @@ class HashJoinReplayer final : public OperatorReplayerBase {
             taskId,
             nodeId,
             operatorType,
+            spillBaseDir,
             driverIds,
             queryCapacity,
             executor) {}
diff --git a/velox/tool/trace/IndexLookupJoinReplayer.cpp b/velox/tool/trace/IndexLookupJoinReplayer.cpp
index feea3bc558c..942ae54a4ff 100644
--- a/velox/tool/trace/IndexLookupJoinReplayer.cpp
+++ b/velox/tool/trace/IndexLookupJoinReplayer.cpp
@@ -15,30 +15,102 @@
  */
 
 #include "velox/tool/trace/IndexLookupJoinReplayer.h"
-#include "velox/exec/TraceUtil.h"
+#include "velox/common/Casts.h"
+#include "velox/connectors/Connector.h"
+#include "velox/exec/OperatorTraceReader.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/trace/TraceUtil.h"
+#include "velox/tool/trace/TraceReplayTaskRunner.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
 
 namespace facebook::velox::tool::trace {
+
 core::PlanNodePtr IndexLookupJoinReplayer::createPlanNode(
     const core::PlanNode* node,
     const core::PlanNodeId& nodeId,
     const core::PlanNodePtr& source) const {
   const auto* indexLookupJoinNode =
-      dynamic_cast<const core::IndexLookupJoinNode*>(node);
-  VELOX_CHECK_NOT_NULL(indexLookupJoinNode);
+      checkedPointerCast<const core::IndexLookupJoinNode>(node);
+
+  // Re-create the lookup source node with a unique node ID to avoid conflicts
+  // with the replay plan's generated node IDs (e.g., TraceScanNode).
+  const auto* lookupSource = checkedPointerCast<const core::TableScanNode>(
+      indexLookupJoinNode->lookupSource().get());
+  auto replayLookupSource = std::make_shared<core::TableScanNode>(
+      planNodeIdGenerator_->next(),
+      lookupSource->outputType(),
+      lookupSource->tableHandle(),
+      lookupSource->assignments());
+
   return std::make_shared<core::IndexLookupJoinNode>(
       nodeId,
       indexLookupJoinNode->joinType(),
       indexLookupJoinNode->leftKeys(),
       indexLookupJoinNode->rightKeys(),
       indexLookupJoinNode->joinConditions(),
-      indexLookupJoinNode->includeMatchColumn(),
-      source, // Probe side
-      indexLookupJoinNode->lookupSource(), // Index side
+      indexLookupJoinNode->filter(),
+      indexLookupJoinNode->hasMarker(),
+      source,
+      replayLookupSource,
       indexLookupJoinNode->outputType());
 }
+
+RowVectorPtr IndexLookupJoinReplayer::run(
+    bool copyResults,
+    bool cursorCopyResult) {
+  auto queryCtx = createQueryCtx();
+  const auto plan = createPlan();
+
+  // Find the IndexLookupJoinNode to get the index source node ID.
+  const auto* replayNode =
+      core::PlanNode::findNodeById(plan.get(), replayPlanNodeId_);
+  VELOX_CHECK_NOT_NULL(replayNode);
+  const auto* indexLookupJoinNode =
+      checkedPointerCast<const core::IndexLookupJoinNode>(replayNode);
+  const auto indexSourceNodeId = indexLookupJoinNode->lookupSource()->id();
+
+  TraceReplayTaskRunner traceTaskRunner(plan, std::move(queryCtx));
+  traceTaskRunner.maxDrivers(static_cast<int32_t>(driverIds_.size()))
+      .cursorCopyResult(cursorCopyResult);
+
+  // Provide the traced index splits if the lookup source needs them.
+  const auto indexSplits = getIndexSplits();
+  if (!indexSplits.empty()) {
+    traceTaskRunner.splits(
+        indexSourceNodeId,
+        std::vector<exec::Split>(indexSplits.begin(), indexSplits.end()));
+  }
+
+  auto [task, result] = traceTaskRunner.run(copyResults);
+  printStats(task);
+  return result;
+}
+
+std::vector<exec::Split> IndexLookupJoinReplayer::getIndexSplits() const {
+  std::vector<std::string> splitInfoDirs;
+  splitInfoDirs.reserve(driverIds_.size());
+  for (const auto driverId : driverIds_) {
+    splitInfoDirs.push_back(
+        exec::trace::getOpTraceDirectory(
+            nodeTraceDir_, pipelineIds_.front(), driverId));
+  }
+  const auto serializedSplits =
+      exec::trace::OperatorTraceSplitReader(
+          splitInfoDirs, memory::MemoryManager::getInstance()->tracePool())
+          .read();
+
+  std::vector<exec::Split> splits;
+  for (const auto& serializedSplit : serializedSplits) {
+    folly::dynamic splitInfoObject{folly::parseJson(serializedSplit)};
+    const auto split =
+        ISerializable::deserialize<connector::ConnectorSplit>(splitInfoObject);
+    splits.emplace_back(
+        std::const_pointer_cast<connector::ConnectorSplit>(split));
+  }
+  return splits;
+}
+
 } // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/IndexLookupJoinReplayer.h b/velox/tool/trace/IndexLookupJoinReplayer.h
index da721c7c8ea..79108574b97 100644
--- a/velox/tool/trace/IndexLookupJoinReplayer.h
+++ b/velox/tool/trace/IndexLookupJoinReplayer.h
@@ -17,6 +17,7 @@
 #pragma once
 
 #include "velox/core/PlanNode.h"
+#include "velox/exec/Split.h"
 #include "velox/tool/trace/OperatorReplayerBase.h"
 
 namespace facebook::velox::tool::trace {
@@ -38,14 +39,22 @@ class IndexLookupJoinReplayer : public OperatorReplayerBase {
             taskId,
             nodeId,
             operatorType,
+            "",
             driverIds,
             queryCapacity,
             executor) {}
 
+  /// Overrides to provide index splits to the task during replay.
+  RowVectorPtr run(bool copyResults = true, bool cursorCopyResult = false)
+      override;
+
  private:
   core::PlanNodePtr createPlanNode(
       const core::PlanNode* node,
       const core::PlanNodeId& nodeId,
       const core::PlanNodePtr& source) const override;
+
+  // Reads traced index splits from the trace directory.
+  std::vector<exec::Split> getIndexSplits() const;
 };
 } // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/MergeJoinReplayer.cpp b/velox/tool/trace/MergeJoinReplayer.cpp
new file mode 100644
index 00000000000..73b17e3fb8f
--- /dev/null
+++ b/velox/tool/trace/MergeJoinReplayer.cpp
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/tool/trace/MergeJoinReplayer.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/trace/TraceUtil.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+namespace facebook::velox::tool::trace {
+core::PlanNodePtr MergeJoinReplayer::createPlanNode(
+    const core::PlanNode* node,
+    const core::PlanNodeId& nodeId,
+    const core::PlanNodePtr& source) const {
+  const auto* mergeJoinNode = dynamic_cast<const core::MergeJoinNode*>(node);
+  return std::make_shared<core::MergeJoinNode>(
+      nodeId,
+      mergeJoinNode->joinType(),
+      mergeJoinNode->leftKeys(),
+      mergeJoinNode->rightKeys(),
+      mergeJoinNode->filter(),
+      source,
+      PlanBuilder(planNodeIdGenerator_)
+          .traceScan(
+              nodeTraceDir_,
+              pipelineIds_.at(1), // Right side
+              driverIds_,
+              exec::trace::getDataType(planFragment_, nodeId_, 1))
+          .planNode(),
+      mergeJoinNode->outputType());
+}
+} // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/MergeJoinReplayer.h b/velox/tool/trace/MergeJoinReplayer.h
new file mode 100644
index 00000000000..fb3cb027041
--- /dev/null
+++ b/velox/tool/trace/MergeJoinReplayer.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/core/PlanNode.h"
+#include "velox/tool/trace/OperatorReplayerBase.h"
+
+namespace facebook::velox::tool::trace {
+/// The replayer to replay the traced 'MergeJoin' operator.
+class MergeJoinReplayer final : public OperatorReplayerBase {
+ public:
+  MergeJoinReplayer(
+      const std::string& rootDir,
+      const std::string& queryId,
+      const std::string& taskId,
+      const std::string& nodeId,
+      const std::string& operatorType,
+      const std::string& spillBaseDir,
+      const std::string& driverIds,
+      uint64_t queryCapacity,
+      folly::Executor* executor)
+      : OperatorReplayerBase(
+            rootDir,
+            queryId,
+            taskId,
+            nodeId,
+            operatorType,
+            spillBaseDir,
+            driverIds,
+            queryCapacity,
+            executor) {}
+
+ private:
+  core::PlanNodePtr createPlanNode(
+      const core::PlanNode* node,
+      const core::PlanNodeId& nodeId,
+      const core::PlanNodePtr& source) const override;
+};
+} // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/OperatorReplayerBase.cpp b/velox/tool/trace/OperatorReplayerBase.cpp
index 4f30816c056..6ade5ece5f2 100644
--- a/velox/tool/trace/OperatorReplayerBase.cpp
+++ b/velox/tool/trace/OperatorReplayerBase.cpp
@@ -18,26 +18,28 @@
 
 #include <utility>
 
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/core/PlanNode.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/TaskTraceReader.h"
-#include "velox/exec/TraceUtil.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/exec/trace/TraceUtil.h"
 #include "velox/tool/trace/OperatorReplayerBase.h"
 
 #include "velox/tool/trace/TraceReplayTaskRunner.h"
 
 using namespace facebook::velox;
+using namespace facebook::velox::common::testutil;
 
 namespace facebook::velox::tool::trace {
 OperatorReplayerBase::OperatorReplayerBase(
-    std::string traceDir,
-    std::string queryId,
-    std::string taskId,
-    std::string nodeId,
-    std::string nodeName,
+    const std::string& traceDir,
+    const std::string& queryId,
+    const std::string& taskId,
+    const std::string& nodeId,
+    const std::string& nodeName,
+    const std::string& spillBaseDir,
     const std::string& driverIds,
     uint64_t queryCapacity,
     folly::Executor* executor)
@@ -48,6 +50,7 @@ OperatorReplayerBase::OperatorReplayerBase(
       taskTraceDir_(
           exec::trace::getTaskTraceDirectory(traceDir, queryId_, taskId_)),
       nodeTraceDir_(exec::trace::getNodeTraceDirectory(taskTraceDir_, nodeId_)),
+      spillBaseDir_(spillBaseDir),
       fs_(filesystems::getFileSystem(taskTraceDir_, nullptr)),
       pipelineIds_(exec::trace::listPipelineIds(nodeTraceDir_, fs_)),
       driverIds_(
@@ -62,7 +65,7 @@ OperatorReplayerBase::OperatorReplayerBase(
   VELOX_USER_CHECK(!taskId_.empty());
   VELOX_USER_CHECK(!nodeId_.empty());
   VELOX_USER_CHECK(!nodeName_.empty());
-  if (nodeName_ == "HashJoin") {
+  if (nodeName_ == "HashJoin" || nodeName_ == "MergeJoin") {
     VELOX_USER_CHECK_EQ(pipelineIds_.size(), 2);
   } else {
     VELOX_USER_CHECK_EQ(pipelineIds_.size(), 1);
@@ -72,31 +75,39 @@ OperatorReplayerBase::OperatorReplayerBase(
   const auto taskMetaReader = exec::trace::TaskTraceMetadataReader(
       taskTraceDir_, memory::MemoryManager::getInstance()->tracePool());
   queryConfigs_ = taskMetaReader.queryConfigs();
+  LOG(INFO) << "Query configs:\n";
+  for (const auto& [key, value] : queryConfigs_) {
+    LOG(INFO) << fmt::format("\t{}: {}", key, value);
+  }
   connectorConfigs_ = taskMetaReader.connectorProperties();
   planFragment_ = taskMetaReader.queryPlan();
   queryConfigs_[core::QueryConfig::kQueryTraceEnabled] = "false";
 }
 
-RowVectorPtr OperatorReplayerBase::run(bool copyResults) {
+RowVectorPtr OperatorReplayerBase::run(
+    bool copyResults,
+    bool cursorCopyResult) {
   auto queryCtx = createQueryCtx();
-  std::shared_ptr<exec::test::TempDirectoryPath> spillDirectory;
-  if (queryCtx->queryConfig().spillEnabled()) {
-    spillDirectory = exec::test::TempDirectoryPath::create();
+  std::shared_ptr<TempDirectoryPath> localSpillDirectory;
+  if (queryCtx->queryConfig().spillEnabled() && spillBaseDir_.empty()) {
+    localSpillDirectory = TempDirectoryPath::create();
   }
 
   TraceReplayTaskRunner traceTaskRunner(createPlan(), std::move(queryCtx));
   auto [task, result] =
       traceTaskRunner.maxDrivers(driverIds_.size())
-          .spillDirectory(spillDirectory ? spillDirectory->getPath() : "")
+          .spillDirectory(
+              localSpillDirectory != nullptr ? localSpillDirectory->getPath()
+                                             : spillBaseDir_)
+          .cursorCopyResult(cursorCopyResult)
           .run(copyResults);
   printStats(task);
   return result;
 }
 
 core::PlanNodePtr OperatorReplayerBase::createPlan() {
-  const auto* replayNode = core::PlanNode::findFirstNode(
-      planFragment_.get(),
-      [this](const core::PlanNode* node) { return node->id() == nodeId_; });
+  const auto* replayNode =
+      core::PlanNode::findNodeById(planFragment_.get(), nodeId_);
 
   if (replayNode->sources().empty()) {
     return exec::test::PlanBuilder()
@@ -147,12 +158,12 @@ OperatorReplayerBase::replayNodeFactory(const core::PlanNode* node) const {
 
 void OperatorReplayerBase::printStats(
     const std::shared_ptr<exec::Task>& task) const {
-  const auto planStats = exec::toPlanStats(task->taskStats());
-  const auto& stats = planStats.at(replayPlanNodeId_);
-  for (const auto& [name, operatorStats] : stats.operatorStats) {
-    LOG(INFO) << "Stats of replaying operator " << name << " : "
-              << operatorStats->toString();
-  }
+  const auto taskStats = exec::toPlanStats(task->taskStats());
+  const auto& nodeStats = taskStats.at(replayPlanNodeId_);
+  LOG(INFO) << "Stats of replaying execution:";
+  LOG(INFO) << nodeStats.toString(
+      /*includeInputStats=*/true,
+      /*includeRuntimeStats=*/true);
   LOG(INFO) << "Memory usage: " << task->pool()->treeMemoryUsage(false);
 }
 } // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/OperatorReplayerBase.h b/velox/tool/trace/OperatorReplayerBase.h
index ab82e1c8f31..167a5b951ad 100644
--- a/velox/tool/trace/OperatorReplayerBase.h
+++ b/velox/tool/trace/OperatorReplayerBase.h
@@ -29,11 +29,12 @@ namespace facebook::velox::tool::trace {
 class OperatorReplayerBase {
  public:
   OperatorReplayerBase(
-      std::string traceDir,
-      std::string queryId,
-      std::string taskId,
-      std::string nodeId,
-      std::string nodeName,
+      const std::string& traceDir,
+      const std::string& queryId,
+      const std::string& taskId,
+      const std::string& nodeId,
+      const std::string& nodeName,
+      const std::string& spillBaseDir,
       const std::string& driverIds,
       uint64_t queryCapacity,
       folly::Executor* executor);
@@ -45,7 +46,23 @@ class OperatorReplayerBase {
   OperatorReplayerBase& operator=(OperatorReplayerBase&& other) noexcept =
       delete;
 
-  virtual RowVectorPtr run(bool copyResults = true);
+  /// @deprecated Use the two-parameter version instead. This overload exists
+  ///        for backward compatibility and will be removed once all subclasses
+  ///        migrate to the new interface.
+  virtual RowVectorPtr run(bool copyResults) {
+    return run(copyResults, /*cursorCopyResult=*/false);
+  }
+
+  /// Runs the replayer with control over both result copying and cursor
+  /// per-batch copying.
+  /// @param copyResults If true, copies and returns all results as a single
+  ///        RowVector. If false, returns nullptr.
+  /// @param cursorCopyResult If true, each output batch is deep copied as it's
+  ///        consumed by the cursor. This can be expensive for complex nested
+  ///        types. Default is false.
+  virtual RowVectorPtr run(
+      bool copyResults = true,
+      bool cursorCopyResult = false);
 
  protected:
   virtual core::PlanNodePtr createPlanNode(
@@ -63,6 +80,7 @@ class OperatorReplayerBase {
   const std::string nodeName_;
   const std::string taskTraceDir_;
   const std::string nodeTraceDir_;
+  const std::string spillBaseDir_;
   const std::shared_ptr<filesystems::FileSystem> fs_;
   const std::vector<uint32_t> pipelineIds_;
   const std::vector<uint32_t> driverIds_;
diff --git a/velox/tool/trace/OrderByReplayer.cpp b/velox/tool/trace/OrderByReplayer.cpp
new file mode 100644
index 00000000000..e6e44718cd6
--- /dev/null
+++ b/velox/tool/trace/OrderByReplayer.cpp
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/tool/trace/OrderByReplayer.h"
+#include "velox/exec/OperatorTraceReader.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+namespace facebook::velox::tool::trace {
+core::PlanNodePtr OrderByReplayer::createPlanNode(
+    const core::PlanNode* node,
+    const core::PlanNodeId& nodeId,
+    const core::PlanNodePtr& source) const {
+  const auto* orderByNode = dynamic_cast<const core::OrderByNode*>(node);
+  return std::make_shared<core::OrderByNode>(
+      nodeId,
+      orderByNode->sortingKeys(),
+      orderByNode->sortingOrders(),
+      orderByNode->isPartial(),
+      source);
+}
+} // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/OrderByReplayer.h b/velox/tool/trace/OrderByReplayer.h
new file mode 100644
index 00000000000..825d6c8a5f1
--- /dev/null
+++ b/velox/tool/trace/OrderByReplayer.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/core/PlanNode.h"
+#include "velox/tool/trace/OperatorReplayerBase.h"
+
+namespace facebook::velox::tool::trace {
+/// The replayer to replay the traced 'OrderBy' operator.
+class OrderByReplayer : public OperatorReplayerBase {
+ public:
+  OrderByReplayer(
+      const std::string& traceDir,
+      const std::string& queryId,
+      const std::string& taskId,
+      const std::string& nodeId,
+      const std::string& operatorType,
+      const std::string& spillBaseDir,
+      const std::string& driverIds,
+      uint64_t queryCapacity,
+      folly::Executor* executor)
+      : OperatorReplayerBase(
+            traceDir,
+            queryId,
+            taskId,
+            nodeId,
+            operatorType,
+            spillBaseDir,
+            driverIds,
+            queryCapacity,
+            executor) {}
+
+ private:
+  core::PlanNodePtr createPlanNode(
+      const core::PlanNode* node,
+      const core::PlanNodeId& nodeId,
+      const core::PlanNodePtr& source) const override;
+};
+} // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/PartitionedOutputReplayer.cpp b/velox/tool/trace/PartitionedOutputReplayer.cpp
index 48c7a6b1459..87ff324fac0 100644
--- a/velox/tool/trace/PartitionedOutputReplayer.cpp
+++ b/velox/tool/trace/PartitionedOutputReplayer.cpp
@@ -18,9 +18,9 @@
 
 #include "velox/common/memory/Memory.h"
 #include "velox/exec/PartitionedOutput.h"
-#include "velox/exec/TraceUtil.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/trace/TraceUtil.h"
 #include "velox/tool/trace/PartitionedOutputReplayer.h"
 
 using namespace facebook::velox;
@@ -109,7 +109,7 @@ PartitionedOutputReplayer::PartitionedOutputReplayer(
     const std::string& queryId,
     const std::string& taskId,
     const std::string& nodeId,
-    VectorSerde::Kind serdeKind,
+    std::string serdeKind,
     const std::string& operatorType,
     const std::string& driverIds,
     uint64_t queryCapacity,
@@ -121,15 +121,13 @@ PartitionedOutputReplayer::PartitionedOutputReplayer(
           taskId,
           nodeId,
           operatorType,
+          "",
           driverIds,
           queryCapacity,
           executor),
-      originalNode_(dynamic_cast<const core::PartitionedOutputNode*>(
-          core::PlanNode::findFirstNode(
-              planFragment_.get(),
-              [this](const core::PlanNode* node) {
-                return node->id() == nodeId_;
-              }))),
+      originalNode_(
+          dynamic_cast<const core::PartitionedOutputNode*>(
+              core::PlanNode::findNodeById(planFragment_.get(), nodeId_))),
       serdeKind_(serdeKind),
       consumerCb_(consumerCb) {
   VELOX_CHECK_NOT_NULL(originalNode_);
@@ -138,13 +136,16 @@ PartitionedOutputReplayer::PartitionedOutputReplayer(
       std::make_shared<folly::NamedThreadFactory>("Consumer"));
 }
 
-RowVectorPtr PartitionedOutputReplayer::run(bool /*unused*/) {
+RowVectorPtr PartitionedOutputReplayer::run(
+    bool /*copyResults*/,
+    bool /*cursorCopyResult*/) {
   const auto task = Task::create(
       "local://partitioned-output-replayer",
       core::PlanFragment{createPlan()},
       0,
       createQueryContext(queryConfigs_, executor_.get()),
-      Task::ExecutionMode::kParallel);
+      Task::ExecutionMode::kParallel,
+      exec::Consumer{});
   task->start(driverIds_.size());
 
   consumeAllData(
diff --git a/velox/tool/trace/PartitionedOutputReplayer.h b/velox/tool/trace/PartitionedOutputReplayer.h
index 99a450bc3a9..29f8a1e39e1 100644
--- a/velox/tool/trace/PartitionedOutputReplayer.h
+++ b/velox/tool/trace/PartitionedOutputReplayer.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <folly/system/HardwareConcurrency.h>
 #include <utility>
 
 #include "velox/core/PlanNode.h"
@@ -45,14 +46,14 @@ class PartitionedOutputReplayer final : public OperatorReplayerBase {
       const std::string& queryId,
       const std::string& taskId,
       const std::string& nodeId,
-      VectorSerde::Kind serdeKind,
+      std::string serdeKind,
       const std::string& operatorType,
       const std::string& driverIds,
       uint64_t queryCapacity,
       folly::Executor* executor,
       const ConsumerCallBack& consumerCb = [](auto partition, auto page) {});
 
-  RowVectorPtr run(bool /*unused*/) override;
+  RowVectorPtr run(bool /*copyResults*/, bool /*cursorCopyResult*/) override;
 
  private:
   core::PlanNodePtr createPlanNode(
@@ -61,12 +62,12 @@ class PartitionedOutputReplayer final : public OperatorReplayerBase {
       const core::PlanNodePtr& source) const override;
 
   const core::PartitionedOutputNode* const originalNode_;
-  const VectorSerde::Kind serdeKind_;
+  const std::string serdeKind_;
   const std::shared_ptr<exec::OutputBufferManager> bufferManager_{
       exec::OutputBufferManager::getInstanceRef()};
   const std::unique_ptr<folly::Executor> executor_{
       std::make_unique<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency(),
+          folly::available_concurrency(),
           std::make_shared<folly::NamedThreadFactory>("Driver"))};
   const ConsumerCallBack consumerCb_;
   std::unique_ptr<folly::CPUThreadPoolExecutor> consumerExecutor_;
diff --git a/velox/tool/trace/TableScanReplayer.cpp b/velox/tool/trace/TableScanReplayer.cpp
index 78dcc6612a8..fa1b35ea328 100644
--- a/velox/tool/trace/TableScanReplayer.cpp
+++ b/velox/tool/trace/TableScanReplayer.cpp
@@ -18,9 +18,9 @@
 
 #include "velox/connectors/hive/HiveConnectorSplit.h"
 #include "velox/exec/OperatorTraceReader.h"
-#include "velox/exec/TraceUtil.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/trace/TraceUtil.h"
 #include "velox/tool/trace/TraceReplayTaskRunner.h"
 
 using namespace facebook::velox;
@@ -29,10 +29,11 @@ using namespace facebook::velox::exec::test;
 
 namespace facebook::velox::tool::trace {
 
-RowVectorPtr TableScanReplayer::run(bool copyResults) {
+RowVectorPtr TableScanReplayer::run(bool copyResults, bool cursorCopyResult) {
   TraceReplayTaskRunner traceTaskRunner(createPlan(), createQueryCtx());
   auto [task, result] = traceTaskRunner.maxDrivers(driverIds_.size())
                             .splits(replayPlanNodeId_, getSplits())
+                            .cursorCopyResult(cursorCopyResult)
                             .run(copyResults);
   printStats(task);
   return result;
@@ -54,8 +55,9 @@ core::PlanNodePtr TableScanReplayer::createPlanNode(
 std::vector<exec::Split> TableScanReplayer::getSplits() const {
   std::vector<std::string> splitInfoDirs;
   for (const auto driverId : driverIds_) {
-    splitInfoDirs.push_back(exec::trace::getOpTraceDirectory(
-        nodeTraceDir_, pipelineIds_.front(), driverId));
+    splitInfoDirs.push_back(
+        exec::trace::getOpTraceDirectory(
+            nodeTraceDir_, pipelineIds_.front(), driverId));
   }
   const auto splitStrs =
       exec::trace::OperatorTraceSplitReader(
diff --git a/velox/tool/trace/TableScanReplayer.h b/velox/tool/trace/TableScanReplayer.h
index 58121851368..0aec56ec6a2 100644
--- a/velox/tool/trace/TableScanReplayer.h
+++ b/velox/tool/trace/TableScanReplayer.h
@@ -42,11 +42,13 @@ class TableScanReplayer final : public OperatorReplayerBase {
             taskId,
             nodeId,
             operatorType,
+            "",
             driverIds,
             queryCapacity,
             executor) {}
 
-  RowVectorPtr run(bool copyResults = true) override;
+  RowVectorPtr run(bool copyResults = true, bool cursorCopyResult = false)
+      override;
 
  private:
   core::PlanNodePtr createPlanNode(
diff --git a/velox/tool/trace/TableWriterReplayer.cpp b/velox/tool/trace/TableWriterReplayer.cpp
index d17511f73bb..9b76b76ba35 100644
--- a/velox/tool/trace/TableWriterReplayer.cpp
+++ b/velox/tool/trace/TableWriterReplayer.cpp
@@ -17,8 +17,8 @@
 #include <folly/executors/IOThreadPoolExecutor.h>
 
 #include "velox/exec/TableWriter.h"
-#include "velox/exec/TraceUtil.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/trace/TraceUtil.h"
 #include "velox/tool/trace/TableWriterReplayer.h"
 
 using namespace facebook::velox;
@@ -41,6 +41,18 @@ makeHiveInsertTableHandle(
   const auto storageFormat = tracedHandle->storageFormat();
   const auto serdeParameters = tracedHandle->serdeParameters();
   const auto writerOptions = tracedHandle->writerOptions();
+  LOG(INFO) << "Traced serde parameters:";
+  for (const auto& [key, value] : serdeParameters) {
+    LOG(INFO) << fmt::format("\t{}: {}", key, value);
+  }
+  LOG(INFO) << fmt::format(
+      "Traced writer options: {}", writerOptions ? "present" : "null");
+  LOG(INFO) << "Traced storage parameters:";
+  for (const auto& [key, value] : tracedHandle->storageParameters()) {
+    LOG(INFO) << fmt::format("\t{}: {}", key, value);
+  }
+  LOG(INFO) << fmt::format(
+      "Storage format: {}", dwio::common::toString(storageFormat));
   return std::make_shared<connector::hive::HiveInsertTableHandle>(
       inputColumns,
       std::make_shared<connector::hive::LocationHandle>(
@@ -53,8 +65,11 @@ makeHiveInsertTableHandle(
           : std::make_shared<connector::hive::HiveBucketProperty>(
                 *tracedHandle->bucketProperty()),
       compressionKind,
-      std::unordered_map<std::string, std::string>{},
-      writerOptions);
+      serdeParameters,
+      writerOptions,
+      tracedHandle->ensureFiles(),
+      tracedHandle->fileNameGenerator(),
+      tracedHandle->storageParameters());
 }
 
 std::shared_ptr<core::InsertTableHandle> createInsertTableHanlde(
diff --git a/velox/tool/trace/TableWriterReplayer.h b/velox/tool/trace/TableWriterReplayer.h
index 52563d5cc93..03ff2843a9f 100644
--- a/velox/tool/trace/TableWriterReplayer.h
+++ b/velox/tool/trace/TableWriterReplayer.h
@@ -42,6 +42,7 @@ class TableWriterReplayer final : public OperatorReplayerBase {
             taskId,
             nodeId,
             operatorType,
+            "",
             driverIds,
             queryCapacity,
             executor),
diff --git a/velox/tool/trace/TopNRowNumberReplayer.cpp b/velox/tool/trace/TopNRowNumberReplayer.cpp
new file mode 100644
index 00000000000..13f4fc291c2
--- /dev/null
+++ b/velox/tool/trace/TopNRowNumberReplayer.cpp
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/tool/trace/TopNRowNumberReplayer.h"
+#include "velox/common/Casts.h"
+#include "velox/exec/OperatorTraceReader.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+namespace facebook::velox::tool::trace {
+core::PlanNodePtr TopNRowNumberReplayer::createPlanNode(
+    const core::PlanNode* node,
+    const core::PlanNodeId& nodeId,
+    const core::PlanNodePtr& source) const {
+  const auto* topNRowNumberNode =
+      checkedPointerCast<const core::TopNRowNumberNode>(node);
+  const auto generateRowNumber = topNRowNumberNode->generateRowNumber();
+  return std::make_shared<core::TopNRowNumberNode>(
+      nodeId,
+      topNRowNumberNode->rankFunction(),
+      topNRowNumberNode->partitionKeys(),
+      topNRowNumberNode->sortingKeys(),
+      topNRowNumberNode->sortingOrders(),
+      generateRowNumber
+          ? std::make_optional(topNRowNumberNode->outputType()->names().back())
+          : std::nullopt,
+      topNRowNumberNode->limit(),
+      source);
+}
+} // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/TopNRowNumberReplayer.h b/velox/tool/trace/TopNRowNumberReplayer.h
new file mode 100644
index 00000000000..93e4e8fed4e
--- /dev/null
+++ b/velox/tool/trace/TopNRowNumberReplayer.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/core/PlanNode.h"
+#include "velox/tool/trace/OperatorReplayerBase.h"
+
+namespace facebook::velox::tool::trace {
+/// The replayer to replay the traced 'TopNRowNumber' operator.
+class TopNRowNumberReplayer : public OperatorReplayerBase {
+ public:
+  TopNRowNumberReplayer(
+      const std::string& traceDir,
+      const std::string& queryId,
+      const std::string& taskId,
+      const std::string& nodeId,
+      const std::string& operatorType,
+      const std::string& spillBaseDir,
+      const std::string& driverIds,
+      uint64_t queryCapacity,
+      folly::Executor* executor)
+      : OperatorReplayerBase(
+            traceDir,
+            queryId,
+            taskId,
+            nodeId,
+            operatorType,
+            spillBaseDir,
+            driverIds,
+            queryCapacity,
+            executor) {}
+
+ private:
+  core::PlanNodePtr createPlanNode(
+      const core::PlanNode* node,
+      const core::PlanNodeId& nodeId,
+      const core::PlanNodePtr& source) const override;
+};
+} // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/TraceFileToolRunner.h b/velox/tool/trace/TraceFileToolRunner.h
index bc9457b0055..387111690ff 100644
--- a/velox/tool/trace/TraceFileToolRunner.h
+++ b/velox/tool/trace/TraceFileToolRunner.h
@@ -20,7 +20,7 @@
 #include <gflags/gflags.h>
 #include <string>
 #include "velox/common/file/FileSystems.h"
-#include "velox/common/file/Utils.h"
+#include "velox/common/file/FileUtils.h"
 
 DECLARE_string(source_root_dir);
 DECLARE_string(dest_root_dir);
diff --git a/velox/tool/trace/TraceReplayRunner.cpp b/velox/tool/trace/TraceReplayRunner.cpp
index 9a2687c36ad..d133307fc44 100644
--- a/velox/tool/trace/TraceReplayRunner.cpp
+++ b/velox/tool/trace/TraceReplayRunner.cpp
@@ -15,16 +15,18 @@
  */
 
 #include "velox/tool/trace/TraceReplayRunner.h"
+#include <folly/system/HardwareConcurrency.h>
 
 #include <gflags/gflags.h>
 
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/memory/Memory.h"
 #include "velox/common/memory/SharedArbitrator.h"
+#include "velox/connectors/Connector.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
 #include "velox/connectors/hive/HiveDataSink.h"
-#include "velox/connectors/hive/TableHandle.h"
 #include "velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.h"
 #include "velox/connectors/hive/storage_adapters/gcs/RegisterGcsFileSystem.h"
 #include "velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.h"
@@ -35,7 +37,7 @@
 #include "velox/exec/OperatorTraceReader.h"
 #include "velox/exec/PartitionFunction.h"
 #include "velox/exec/TaskTraceReader.h"
-#include "velox/exec/TraceUtil.h"
+#include "velox/exec/trace/TraceUtil.h"
 #include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 #include "velox/parse/TypeResolver.h"
@@ -45,10 +47,14 @@
 #include "velox/tool/trace/FilterProjectReplayer.h"
 #include "velox/tool/trace/HashJoinReplayer.h"
 #include "velox/tool/trace/IndexLookupJoinReplayer.h"
+#include "velox/tool/trace/MergeJoinReplayer.h"
 #include "velox/tool/trace/OperatorReplayerBase.h"
+#include "velox/tool/trace/OrderByReplayer.h"
 #include "velox/tool/trace/PartitionedOutputReplayer.h"
 #include "velox/tool/trace/TableScanReplayer.h"
 #include "velox/tool/trace/TableWriterReplayer.h"
+#include "velox/tool/trace/TopNRowNumberReplayer.h"
+#include "velox/tool/trace/TraceReplayerConfigPrompt.h"
 #include "velox/tool/trace/UnnestReplayer.h"
 #include "velox/type/Type.h"
 
@@ -102,21 +108,31 @@ DEFINE_uint64(
     0,
     "Specify the query memory capacity limit in GB. If it is zero, then there is no limit.");
 DEFINE_bool(copy_results, false, "Copy the replaying results.");
+DEFINE_bool(
+    cursor_copy_result,
+    false,
+    "Enable per-batch copying in TaskCursor. When false (default), avoids "
+    "expensive deep copies of complex nested types during output consumption. "
+    "Only enable for debugging or when output vectors need to be retained.");
 DEFINE_string(
     function_prefix,
     "",
     "Prefix for the scalar and aggregate functions.");
+DEFINE_string(
+    spill_directory,
+    "",
+    "Base directory for spilling. If not specified, a local temporary directory will be used.");
 
 namespace facebook::velox::tool::trace {
 namespace {
-VectorSerde::Kind getVectorSerdeKind() {
+std::string getVectorSerdeKind() {
   switch (FLAGS_shuffle_serialization_format) {
     case 0:
-      return VectorSerde::Kind::kPresto;
+      return "Presto";
     case 1:
-      return VectorSerde::Kind::kCompactRow;
+      return "CompactRow";
     case 2:
-      return VectorSerde::Kind::kUnsafeRow;
+      return "UnsafeRow";
     default:
       VELOX_UNSUPPORTED(
           "Unsupported shuffle serialization format: {}",
@@ -233,18 +249,32 @@ void printSummary(
 } // namespace
 
 TraceReplayRunner::TraceReplayRunner()
-    : cpuExecutor_(std::make_unique<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency() *
-              FLAGS_driver_cpu_executor_hw_multiplier,
-          std::make_shared<folly::NamedThreadFactory>(
-              "TraceReplayCpuConnector"))),
-      ioExecutor_(std::make_unique<folly::IOThreadPoolExecutor>(
-          std::thread::hardware_concurrency() *
-              FLAGS_hive_connector_executor_hw_multiplier,
-          std::make_shared<folly::NamedThreadFactory>(
-              "TraceReplayIoConnector"))) {}
+    : cpuExecutor_(
+          std::make_unique<folly::CPUThreadPoolExecutor>(
+              folly::available_concurrency() *
+                  FLAGS_driver_cpu_executor_hw_multiplier,
+              std::make_shared<folly::NamedThreadFactory>(
+                  "TraceReplayCpuConnector"))),
+      ioExecutor_(
+          std::make_unique<folly::IOThreadPoolExecutor>(
+              folly::available_concurrency() *
+                  FLAGS_hive_connector_executor_hw_multiplier,
+              std::make_shared<folly::NamedThreadFactory>(
+                  "TraceReplayIoConnector"))) {}
+
+TraceReplayRunner::~TraceReplayRunner() {
+  // Explicitly unregister all connectors before the runner is destroyed.
+  // This ensures file handles are closed while folly::RequestContext is still
+  // valid, preventing use-after-free during program shutdown when the static
+  // connector map is destroyed after RequestContext.
+  connector::ConnectorRegistry::unregisterAll();
+}
 
 void TraceReplayRunner::init() {
+  // Prompt user for configs interactively (unless --fast is set)
+  TraceReplayerConfigPrompt prompt;
+  prompt.run();
+
   VELOX_USER_CHECK(!FLAGS_root_dir.empty(), "--root_dir must be provided");
   VELOX_USER_CHECK(!FLAGS_node_id.empty(), "--node_id must be provided");
 
@@ -279,13 +309,13 @@ void TraceReplayRunner::init() {
   if (!isRegisteredVectorSerde()) {
     serializer::presto::PrestoVectorSerde::registerVectorSerde();
   }
-  if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kPresto)) {
+  if (!isRegisteredNamedVectorSerde("Presto")) {
     serializer::presto::PrestoVectorSerde::registerNamedVectorSerde();
   }
-  if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kCompactRow)) {
+  if (!isRegisteredNamedVectorSerde("CompactRow")) {
     serializer::CompactRowVectorSerde::registerNamedVectorSerde();
   }
-  if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kUnsafeRow)) {
+  if (!isRegisteredNamedVectorSerde("UnsafeRow")) {
     serializer::spark::UnsafeRowVectorSerde::registerNamedVectorSerde();
   }
 
@@ -314,6 +344,17 @@ TraceReplayRunner::createReplayer() const {
     VELOX_USER_CHECK(
         !FLAGS_table_writer_output_dir.empty(),
         "--table_writer_output_dir is required");
+    const std::string writerConnectorId = "test-hive";
+    if (!connector::ConnectorRegistry::tryGet(writerConnectorId)) {
+      connector::hive::HiveConnectorFactory factory;
+      const auto hiveConnector = factory.newConnector(
+          writerConnectorId,
+          std::make_shared<config::ConfigBase>(
+              std::unordered_map<std::string, std::string>()),
+          ioExecutor_.get());
+      connector::ConnectorRegistry::global().insert(
+          hiveConnector->connectorId(), hiveConnector);
+    }
     replayer = std::make_unique<tool::trace::TableWriterReplayer>(
         FLAGS_root_dir,
         FLAGS_query_id,
@@ -331,6 +372,7 @@ TraceReplayRunner::createReplayer() const {
         FLAGS_task_id,
         FLAGS_node_id,
         traceNodeName,
+        FLAGS_spill_directory,
         FLAGS_driver_ids,
         queryCapacityBytes,
         cpuExecutor_.get());
@@ -350,14 +392,15 @@ TraceReplayRunner::createReplayer() const {
         taskTraceMetadataReader_->connectorId(FLAGS_node_id);
     VELOX_CHECK(connectorId.has_value());
 
-    if (!connector::hasConnector(connectorId.value())) {
+    if (!connector::ConnectorRegistry::tryGet(connectorId.value())) {
       connector::hive::HiveConnectorFactory factory;
       const auto hiveConnector = factory.newConnector(
           connectorId.value(),
           std::make_shared<config::ConfigBase>(
               std::unordered_map<std::string, std::string>()),
           ioExecutor_.get());
-      connector::registerConnector(hiveConnector);
+      connector::ConnectorRegistry::global().insert(
+          hiveConnector->connectorId(), hiveConnector);
     }
     replayer = std::make_unique<tool::trace::TableScanReplayer>(
         FLAGS_root_dir,
@@ -385,6 +428,7 @@ TraceReplayRunner::createReplayer() const {
         FLAGS_task_id,
         FLAGS_node_id,
         traceNodeName,
+        FLAGS_spill_directory,
         FLAGS_driver_ids,
         queryCapacityBytes,
         cpuExecutor_.get());
@@ -398,6 +442,17 @@ TraceReplayRunner::createReplayer() const {
         FLAGS_driver_ids,
         queryCapacityBytes,
         cpuExecutor_.get());
+  } else if (traceNodeName == "MergeJoin") {
+    replayer = std::make_unique<tool::trace::MergeJoinReplayer>(
+        FLAGS_root_dir,
+        FLAGS_query_id,
+        FLAGS_task_id,
+        FLAGS_node_id,
+        traceNodeName,
+        FLAGS_spill_directory,
+        FLAGS_driver_ids,
+        queryCapacityBytes,
+        cpuExecutor_.get());
   } else if (traceNodeName == "Unnest") {
     replayer = std::make_unique<tool::trace::UnnestReplayer>(
         FLAGS_root_dir,
@@ -408,6 +463,28 @@ TraceReplayRunner::createReplayer() const {
         FLAGS_driver_ids,
         queryCapacityBytes,
         cpuExecutor_.get());
+  } else if (traceNodeName == "OrderBy") {
+    replayer = std::make_unique<tool::trace::OrderByReplayer>(
+        FLAGS_root_dir,
+        FLAGS_query_id,
+        FLAGS_task_id,
+        FLAGS_node_id,
+        traceNodeName,
+        FLAGS_spill_directory,
+        FLAGS_driver_ids,
+        queryCapacityBytes,
+        cpuExecutor_.get());
+  } else if (traceNodeName == "TopNRowNumber") {
+    replayer = std::make_unique<tool::trace::TopNRowNumberReplayer>(
+        FLAGS_root_dir,
+        FLAGS_query_id,
+        FLAGS_task_id,
+        FLAGS_node_id,
+        traceNodeName,
+        FLAGS_spill_directory,
+        FLAGS_driver_ids,
+        queryCapacityBytes,
+        cpuExecutor_.get());
   } else {
     VELOX_UNSUPPORTED("Unsupported operator type: {}", traceNodeName);
   }
@@ -427,6 +504,6 @@ void TraceReplayRunner::run() {
     return;
   }
   VELOX_USER_CHECK(!FLAGS_task_id.empty(), "--task_id must be provided");
-  createReplayer()->run(FLAGS_copy_results);
+  createReplayer()->run(FLAGS_copy_results, FLAGS_cursor_copy_result);
 }
 } // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/TraceReplayRunner.h b/velox/tool/trace/TraceReplayRunner.h
index c38cfa1415e..3f0cf6611b1 100644
--- a/velox/tool/trace/TraceReplayRunner.h
+++ b/velox/tool/trace/TraceReplayRunner.h
@@ -47,7 +47,7 @@ namespace facebook::velox::tool::trace {
 class TraceReplayRunner {
  public:
   TraceReplayRunner();
-  virtual ~TraceReplayRunner() = default;
+  virtual ~TraceReplayRunner();
 
   /// Initializes the trace replay runner by setting the velox runtime
   /// environment for the trace replay. It is invoked before run().
diff --git a/velox/tool/trace/TraceReplayTaskRunner.cpp b/velox/tool/trace/TraceReplayTaskRunner.cpp
index 541d5605e63..7cdf1405faf 100644
--- a/velox/tool/trace/TraceReplayTaskRunner.cpp
+++ b/velox/tool/trace/TraceReplayTaskRunner.cpp
@@ -74,6 +74,12 @@ TraceReplayTaskRunner& TraceReplayTaskRunner::splits(
   return *this;
 }
 
+TraceReplayTaskRunner& TraceReplayTaskRunner::cursorCopyResult(
+    bool copyResult) {
+  cursorParams_.copyResult = copyResult;
+  return *this;
+}
+
 void TraceReplayTaskRunner::addSplits(exec::Task* task) {
   for (auto& [nodeId, nodeSplits] : splits_) {
     for (auto& split : nodeSplits) {
diff --git a/velox/tool/trace/TraceReplayTaskRunner.h b/velox/tool/trace/TraceReplayTaskRunner.h
index c791d512a55..71c638cbf3d 100644
--- a/velox/tool/trace/TraceReplayTaskRunner.h
+++ b/velox/tool/trace/TraceReplayTaskRunner.h
@@ -28,6 +28,10 @@ class TraceReplayTaskRunner {
       std::shared_ptr<core::QueryCtx> queryCtx) {
     cursorParams_.planNode = std::move(plan);
     cursorParams_.queryCtx = std::move(queryCtx);
+    // Disable per-batch copying in MultiThreadedTaskCursor by default to avoid
+    // expensive deep copies of complex nested types. The final result copy is
+    // handled in run() if needed.
+    cursorParams_.copyResult = false;
     VELOX_CHECK_NOT_NULL(cursorParams_.planNode);
     VELOX_CHECK_NOT_NULL(cursorParams_.queryCtx);
   }
@@ -49,6 +53,11 @@ class TraceReplayTaskRunner {
       const core::PlanNodeId& planNodeId,
       std::vector<exec::Split> splits);
 
+  /// Enable or disable per-batch copying in TaskCursor. When true, each output
+  /// batch is copied as it's consumed, which can be expensive for complex
+  /// nested types. Default is false.
+  TraceReplayTaskRunner& cursorCopyResult(bool copyResult);
+
  private:
   void addSplits(exec::Task* task);
 
diff --git a/velox/tool/trace/TraceReplayerConfigPrompt.cpp b/velox/tool/trace/TraceReplayerConfigPrompt.cpp
new file mode 100644
index 00000000000..d037a9cbc5f
--- /dev/null
+++ b/velox/tool/trace/TraceReplayerConfigPrompt.cpp
@@ -0,0 +1,257 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/tool/trace/TraceReplayerConfigPrompt.h"
+
+#include <gflags/gflags.h>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+DEFINE_bool(
+    fast,
+    false,
+    "Skip interactive prompts and use existing gflag values directly. "
+    "Use this flag when you already know the config values and want to "
+    "bypass the interactive configuration.");
+
+DECLARE_string(root_dir);
+DECLARE_string(query_id);
+DECLARE_string(task_id);
+DECLARE_string(node_id);
+DECLARE_string(driver_ids);
+DECLARE_string(table_writer_output_dir);
+
+namespace facebook::velox::tool::trace {
+
+namespace {
+constexpr const char* kColorReset = "\033[0m";
+constexpr const char* kColorBold = "\033[1m";
+constexpr const char* kColorGreen = "\033[32m";
+constexpr const char* kColorYellow = "\033[33m";
+constexpr const char* kColorCyan = "\033[36m";
+
+// Reads a line from stdin, trimming leading/trailing whitespace.
+std::string readLine() {
+  std::string input;
+  std::getline(std::cin, input);
+
+  // Trim leading whitespace
+  size_t start = input.find_first_not_of(" \t\n\r");
+  if (start == std::string::npos) {
+    return "";
+  }
+
+  // Trim trailing whitespace
+  size_t end = input.find_last_not_of(" \t\n\r");
+  return input.substr(start, end - start + 1);
+}
+
+// Prints a separator line for visual clarity.
+void printSeparator() {
+  std::cout << kColorCyan
+            << "============================================================"
+            << kColorReset << std::endl;
+}
+
+// Prints a header for the config prompt session.
+void printHeader() {
+  std::cout << std::endl;
+  printSeparator();
+  std::cout << kColorBold << kColorGreen
+            << "          Trace Replayer Configuration Prompt" << kColorReset
+            << std::endl;
+  printSeparator();
+  std::cout << std::endl;
+  std::cout << "Enter config values or press " << kColorYellow << "Enter"
+            << kColorReset << " to keep current gflag value." << std::endl;
+  std::cout << std::endl;
+}
+
+// Prints the equivalent command with --fast flag for future use.
+void printFastCommand() {
+  std::ostringstream cmd;
+  cmd << "--fast";
+
+  if (!FLAGS_root_dir.empty()) {
+    cmd << " \\\n  --root_dir=\"" << FLAGS_root_dir << "\"";
+  }
+  if (!FLAGS_query_id.empty()) {
+    cmd << " \\\n  --query_id=\"" << FLAGS_query_id << "\"";
+  }
+  if (!FLAGS_task_id.empty()) {
+    cmd << " \\\n  --task_id=\"" << FLAGS_task_id << "\"";
+  }
+  if (!FLAGS_node_id.empty()) {
+    cmd << " \\\n  --node_id=\"" << FLAGS_node_id << "\"";
+  }
+  if (!FLAGS_driver_ids.empty()) {
+    cmd << " \\\n  --driver_ids=\"" << FLAGS_driver_ids << "\"";
+  }
+  if (!FLAGS_table_writer_output_dir.empty()) {
+    cmd << " \\\n  --table_writer_output_dir=\""
+        << FLAGS_table_writer_output_dir << "\"";
+  }
+
+  std::cout << std::endl;
+  printSeparator();
+  std::cout << kColorBold << kColorGreen << "Quick Command for Next Run"
+            << kColorReset << std::endl;
+  printSeparator();
+  std::cout << std::endl;
+  std::cout
+      << "To skip prompts next time, copy and run with the following flags:\n"
+      << std::endl;
+  std::cout << kColorYellow << cmd.str() << kColorReset << std::endl;
+  std::cout << std::endl;
+  printSeparator();
+  std::cout << std::endl;
+}
+
+// Prompts for a single config value.
+// @param configName The name of the config (for display purposes).
+// @param currentValue The current value from gflag.
+// @param description A brief description of what this config is for.
+// @param required Whether this config is required (cannot be empty).
+// @return The final value (either user input or the original gflag value).
+std::string promptForConfig(
+    const std::string& configName,
+    const std::string& currentValue,
+    const std::string& description,
+    bool required) {
+  std::cout << kColorBold << configName << kColorReset << std::endl;
+  std::cout << "  " << description << std::endl;
+  std::cout << "  Current gflag value: " << kColorYellow
+            << (currentValue.empty() ? "(empty)" : currentValue) << kColorReset
+            << std::endl;
+
+  if (required) {
+    std::cout << "  " << kColorCyan << "[REQUIRED]" << kColorReset << std::endl;
+  }
+
+  std::cout << "  Enter new value: ";
+  std::string input = readLine();
+
+  std::string finalValue = input.empty() ? currentValue : input;
+
+  if (required && finalValue.empty()) {
+    std::cout << kColorYellow << "  Warning: This config is required but empty."
+              << kColorReset << std::endl;
+  }
+
+  std::cout << "  Using: " << kColorGreen << finalValue << kColorReset
+            << std::endl;
+  std::cout << std::endl;
+
+  return finalValue;
+}
+} // namespace
+
+void TraceReplayerConfigPrompt::run() {
+  if (FLAGS_fast) {
+    std::cout << kColorCyan << "[--fast mode] "
+              << "Skipping interactive prompts, using existing gflag values."
+              << kColorReset << std::endl;
+    std::cout << std::endl;
+
+    // Print summary of current config values
+    std::cout << kColorBold << "Current Configuration:" << kColorReset
+              << std::endl;
+    std::cout << "  root_dir: " << FLAGS_root_dir << std::endl;
+    std::cout << "  query_id: " << FLAGS_query_id << std::endl;
+    std::cout << "  task_id: "
+              << (FLAGS_task_id.empty() ? "(empty - summary mode)"
+                                        : FLAGS_task_id)
+              << std::endl;
+    std::cout << "  node_id: " << FLAGS_node_id << std::endl;
+    std::cout << "  driver_ids: "
+              << (FLAGS_driver_ids.empty() ? "(all drivers)" : FLAGS_driver_ids)
+              << std::endl;
+    std::cout << "  table_writer_output_dir: "
+              << (FLAGS_table_writer_output_dir.empty()
+                      ? "(not set)"
+                      : FLAGS_table_writer_output_dir)
+              << std::endl;
+    std::cout << std::endl;
+    return;
+  }
+
+  printHeader();
+
+  // Prompt for critical required configs
+  FLAGS_root_dir = promptForConfig(
+      "--root_dir",
+      FLAGS_root_dir,
+      "Root directory where the replayer reads traced data",
+      true);
+
+  FLAGS_query_id = promptForConfig(
+      "--query_id", FLAGS_query_id, "The target query id to replay", true);
+
+  FLAGS_task_id = promptForConfig(
+      "--task_id",
+      FLAGS_task_id,
+      "The target task id to replay (leave empty for summary mode)",
+      false);
+
+  FLAGS_node_id = promptForConfig(
+      "--node_id", FLAGS_node_id, "The target node id to replay", true);
+
+  // Prompt for optional configs
+  std::cout << kColorBold << "Optional Configs:" << kColorReset << std::endl;
+  std::cout << std::endl;
+
+  FLAGS_driver_ids = promptForConfig(
+      "--driver_ids",
+      FLAGS_driver_ids,
+      "A comma-separated list of target driver ids",
+      false);
+
+  FLAGS_table_writer_output_dir = promptForConfig(
+      "--table_writer_output_dir",
+      FLAGS_table_writer_output_dir,
+      "Output directory for TableWriter (required for TableWrite replays)",
+      false);
+
+  printSeparator();
+  std::cout << kColorGreen << "Configuration complete!" << kColorReset
+            << std::endl;
+  std::cout << std::endl;
+
+  // Print summary
+  std::cout << kColorBold << "Final Configuration Summary:" << kColorReset
+            << std::endl;
+  std::cout << "  root_dir: " << FLAGS_root_dir << std::endl;
+  std::cout << "  query_id: " << FLAGS_query_id << std::endl;
+  std::cout << "  task_id: "
+            << (FLAGS_task_id.empty() ? "(empty - summary mode)"
+                                      : FLAGS_task_id)
+            << std::endl;
+  std::cout << "  node_id: " << FLAGS_node_id << std::endl;
+  std::cout << "  driver_ids: "
+            << (FLAGS_driver_ids.empty() ? "(all drivers)" : FLAGS_driver_ids)
+            << std::endl;
+  std::cout << "  table_writer_output_dir: "
+            << (FLAGS_table_writer_output_dir.empty()
+                    ? "(not set)"
+                    : FLAGS_table_writer_output_dir)
+            << std::endl;
+
+  // Print the fast command for next time
+  printFastCommand();
+}
+
+} // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/TraceReplayerConfigPrompt.h b/velox/tool/trace/TraceReplayerConfigPrompt.h
new file mode 100644
index 00000000000..cc44fc66a58
--- /dev/null
+++ b/velox/tool/trace/TraceReplayerConfigPrompt.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <gflags/gflags.h>
+#include <string>
+
+DECLARE_bool(fast);
+
+namespace facebook::velox::tool::trace {
+
+/// A utility class that prompts users to enter critical configs for trace
+/// replay. It displays the current gflag setting and allows users to override
+/// or confirm the value interactively.
+///
+/// When --fast flag is set, prompts are skipped and existing gflag values are
+/// used directly.
+class TraceReplayerConfigPrompt {
+ public:
+  TraceReplayerConfigPrompt() = default;
+  ~TraceReplayerConfigPrompt() = default;
+
+  /// Prompts the user to enter or confirm all critical configs for trace
+  /// replay. This includes root_dir, query_id, task_id, and node_id.
+  /// If a gflag is already set, it shows the current value and allows the user
+  /// to press Enter to keep it or type a new value to override.
+  ///
+  /// If --fast flag is set, skips all prompts and uses existing gflag values.
+  /// After configuration, prints the equivalent command with --fast for future
+  /// use.
+  void run();
+};
+
+} // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/UnnestReplayer.cpp b/velox/tool/trace/UnnestReplayer.cpp
index 76a0fa5a65b..c0382fbbe29 100644
--- a/velox/tool/trace/UnnestReplayer.cpp
+++ b/velox/tool/trace/UnnestReplayer.cpp
@@ -16,8 +16,8 @@
 
 #include "velox/tool/trace/UnnestReplayer.h"
 
-#include "velox/exec/TraceUtil.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/trace/TraceUtil.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
@@ -36,7 +36,7 @@ core::PlanNodePtr UnnestReplayer::createPlanNode(
       unnestNode->unnestVariables(),
       unnestNode->unnestNames(),
       unnestNode->ordinalityName(),
-      unnestNode->emptyUnnestValueName(),
+      unnestNode->markerName(),
       source);
 }
 } // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/UnnestReplayer.h b/velox/tool/trace/UnnestReplayer.h
index 87ab6c69ea3..9dfacb820ee 100644
--- a/velox/tool/trace/UnnestReplayer.h
+++ b/velox/tool/trace/UnnestReplayer.h
@@ -38,6 +38,7 @@ class UnnestReplayer : public OperatorReplayerBase {
             taskId,
             nodeId,
             operatorType,
+            "",
             driverIds,
             queryCapacity,
             executor) {}
diff --git a/velox/tool/trace/tests/AggregationReplayerTest.cpp b/velox/tool/trace/tests/AggregationReplayerTest.cpp
index 4b995affa23..7491dc89431 100644
--- a/velox/tool/trace/tests/AggregationReplayerTest.cpp
+++ b/velox/tool/trace/tests/AggregationReplayerTest.cpp
@@ -21,20 +21,20 @@
 #include <memory>
 #include <string>
 
-#include "folly/experimental/EventCount.h"
+#include "folly/synchronization/EventCount.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/hyperloglog/SparseHll.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/dwio/dwrf/writer/Writer.h"
 #include "velox/exec/PartitionFunction.h"
 #include "velox/exec/TableWriter.h"
-#include "velox/exec/TraceUtil.h"
 #include "velox/exec/tests/utils/ArbitratorTestUtil.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/exec/trace/TraceUtil.h"
 #include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 #include "velox/serializers/PrestoSerializer.h"
@@ -271,6 +271,7 @@ TEST_F(AggregationReplayerTest, hashAggregationTest) {
                                        traceNodeId_,
                                        "Aggregation",
                                        "",
+                                       "",
                                        0,
                                        executor_.get())
                                        .run();
@@ -286,6 +287,7 @@ TEST_F(AggregationReplayerTest, hashAggregationTest) {
         runner.init();
         runner.run();
       }
+      resetHiveConnector();
 
       FLAGS_task_id = task->taskId();
       FLAGS_driver_ids = "";
@@ -295,6 +297,7 @@ TEST_F(AggregationReplayerTest, hashAggregationTest) {
         runner.init();
         runner.run();
       }
+      resetHiveConnector();
     }
   }
 }
@@ -337,6 +340,7 @@ TEST_F(AggregationReplayerTest, streamingAggregateTest) {
                                        traceNodeId_,
                                        "Aggregation",
                                        "",
+                                       "",
                                        0,
                                        executor_.get())
                                        .run();
@@ -352,6 +356,7 @@ TEST_F(AggregationReplayerTest, streamingAggregateTest) {
         runner.init();
         runner.run();
       }
+      resetHiveConnector();
 
       FLAGS_task_id = task->taskId();
       FLAGS_driver_ids = "";
@@ -361,6 +366,7 @@ TEST_F(AggregationReplayerTest, streamingAggregateTest) {
         runner.init();
         runner.run();
       }
+      resetHiveConnector();
     }
   }
 }
diff --git a/velox/tool/trace/tests/CMakeLists.txt b/velox/tool/trace/tests/CMakeLists.txt
index 6a60503f3ce..e91704366b0 100644
--- a/velox/tool/trace/tests/CMakeLists.txt
+++ b/velox/tool/trace/tests/CMakeLists.txt
@@ -18,10 +18,14 @@ add_executable(
   FilterProjectReplayerTest.cpp
   HashJoinReplayerTest.cpp
   IndexLookupJoinReplayerTest.cpp
+  MergeJoinReplayerTest.cpp
+  OrderByReplayerTest.cpp
   PartitionedOutputReplayerTest.cpp
-  TraceFileToolTest.cpp
   TableScanReplayerTest.cpp
   TableWriterReplayerTest.cpp
+  TopNRowNumberReplayerTest.cpp
+  TraceFileToolTest.cpp
+  TraceReplayerConfigPromptTest.cpp
   UnnestReplayerTest.cpp
 )
 
diff --git a/velox/tool/trace/tests/FilterProjectReplayerTest.cpp b/velox/tool/trace/tests/FilterProjectReplayerTest.cpp
index 9c4ff740fab..42a2629f60c 100644
--- a/velox/tool/trace/tests/FilterProjectReplayerTest.cpp
+++ b/velox/tool/trace/tests/FilterProjectReplayerTest.cpp
@@ -20,16 +20,16 @@
 #include <string>
 #include <utility>
 
-#include <folly/experimental/EventCount.h>
+#include <folly/synchronization/EventCount.h>
 
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/exec/PartitionFunction.h"
-#include "velox/exec/TraceUtil.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/exec/trace/TraceUtil.h"
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/tool/trace/FilterProjectReplayer.h"
 
@@ -277,8 +277,8 @@ TEST_F(FilterProjectReplayerTest, projectOnly) {
                               .run();
   assertEqualResults({result}, {replayingResult1, replayingResult2});
 
-  const auto taskTraceDir =
-      exec::trace::getTaskTraceDirectory(traceRoot, *task);
+  const auto taskTraceDir = exec::trace::getTaskTraceDirectory(
+      traceRoot, task->queryCtx()->queryId(), task->taskId());
   const auto opTraceDir =
       exec::trace::getOpTraceDirectory(taskTraceDir, projectNodeId_, 0, 0);
   const auto opTraceDataFile = exec::trace::getOpTraceInputFilePath(opTraceDir);
diff --git a/velox/tool/trace/tests/HashJoinReplayerTest.cpp b/velox/tool/trace/tests/HashJoinReplayerTest.cpp
index 6d04cefe787..e93f46ea230 100644
--- a/velox/tool/trace/tests/HashJoinReplayerTest.cpp
+++ b/velox/tool/trace/tests/HashJoinReplayerTest.cpp
@@ -19,21 +19,21 @@
 
 #include <string>
 
-#include <folly/experimental/EventCount.h>
+#include <folly/synchronization/EventCount.h>
 
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/file/tests/FaultyFileSystem.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/exec/OperatorTraceReader.h"
 #include "velox/exec/PartitionFunction.h"
 #include "velox/exec/PlanNodeStats.h"
-#include "velox/exec/TraceUtil.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/exec/trace/TraceUtil.h"
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/tool/trace/HashJoinReplayer.h"
 #include "velox/tool/trace/TraceReplayRunner.h"
@@ -229,8 +229,9 @@ TEST_F(HashJoinReplayerTest, basic) {
                                    task->taskId(),
                                    traceNodeId_,
                                    "HashJoin",
-                                   "",
-                                   0,
+                                   /*spillBaseDir=*/"",
+                                   /*driverIds=*/"",
+                                   /*queryCapacity=*/0,
                                    executor_.get())
                                    .run();
   assertEqualResults({result}, {replayingResult});
@@ -279,8 +280,8 @@ TEST_F(HashJoinReplayerTest, partialDriverIds) {
   assertEqualResults({result}, {traceResult});
 
   const auto taskId = task->taskId();
-  const auto taskTraceDir =
-      exec::trace::getTaskTraceDirectory(traceRoot, *task);
+  const auto taskTraceDir = exec::trace::getTaskTraceDirectory(
+      traceRoot, task->queryCtx()->queryId(), task->taskId());
   const auto opTraceDir =
       exec::trace::getOpTraceDirectory(taskTraceDir, traceNodeId_, 0, 0);
   const auto opTraceDataFile = exec::trace::getOpTraceInputFilePath(opTraceDir);
@@ -301,6 +302,7 @@ TEST_F(HashJoinReplayerTest, partialDriverIds) {
             task->taskId(),
             traceNodeId_,
             "HashJoin",
+            "",
             "0",
             0,
             executor_.get())
@@ -313,6 +315,7 @@ TEST_F(HashJoinReplayerTest, partialDriverIds) {
       task->taskId(),
       traceNodeId_,
       "HashJoin",
+      "",
       "1,3",
       0,
       executor_.get())
@@ -342,8 +345,8 @@ TEST_F(HashJoinReplayerTest, runner) {
   }
   auto traceResult = traceBuilder.copyResults(pool(), task);
 
-  const auto taskTraceDir =
-      exec::trace::getTaskTraceDirectory(traceRoot, *task);
+  const auto taskTraceDir = exec::trace::getTaskTraceDirectory(
+      traceRoot, task->queryCtx()->queryId(), task->taskId());
   const auto probeOperatorTraceDir = exec::trace::getOpTraceDirectory(
       taskTraceDir,
       traceNodeId_,
@@ -452,7 +455,10 @@ DEBUG_ONLY_TEST_F(HashJoinReplayerTest, hashBuildSpill) {
   const auto& stats = taskStats.at(traceNodeId_);
   auto opStats = toOperatorStats(task->taskStats());
   ASSERT_GT(
-      opStats.at("HashBuild").runtimeStats[Operator::kSpillWrites].sum, 0);
+      opStats.at("HashBuild")
+          .runtimeStats[std::string(Operator::kSpillWrites)]
+          .sum,
+      0);
   ASSERT_GT(stats.spilledBytes, 0);
   ASSERT_GT(stats.spilledRows, 0);
   ASSERT_GT(stats.spilledFiles, 0);
@@ -468,6 +474,7 @@ DEBUG_ONLY_TEST_F(HashJoinReplayerTest, hashBuildSpill) {
                                    traceNodeId_,
                                    "HashJoin",
                                    "",
+                                   "",
                                    0,
                                    executor_.get())
                                    .run();
@@ -533,7 +540,10 @@ DEBUG_ONLY_TEST_F(HashJoinReplayerTest, hashProbeSpill) {
   const auto& stats = taskStats.at(traceNodeId_);
   auto opStats = toOperatorStats(task->taskStats());
   ASSERT_GT(
-      opStats.at("HashProbe").runtimeStats[Operator::kSpillWrites].sum, 0);
+      opStats.at("HashProbe")
+          .runtimeStats[std::string(Operator::kSpillWrites)]
+          .sum,
+      0);
 
   ASSERT_GT(stats.spilledBytes, 0);
   ASSERT_GT(stats.spilledRows, 0);
@@ -550,6 +560,7 @@ DEBUG_ONLY_TEST_F(HashJoinReplayerTest, hashProbeSpill) {
                                    traceNodeId_,
                                    "HashJoin",
                                    "",
+                                   "",
                                    0,
                                    executor_.get())
                                    .run();
diff --git a/velox/tool/trace/tests/IndexLookupJoinReplayerTest.cpp b/velox/tool/trace/tests/IndexLookupJoinReplayerTest.cpp
index 62da7fec24d..bda7ba48be0 100644
--- a/velox/tool/trace/tests/IndexLookupJoinReplayerTest.cpp
+++ b/velox/tool/trace/tests/IndexLookupJoinReplayerTest.cpp
@@ -19,17 +19,18 @@
 
 #include <string>
 
-#include <folly/experimental/EventCount.h>
+#include <folly/synchronization/EventCount.h>
 
 #include "velox/common/file/tests/FaultyFileSystem.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
+#include "velox/connectors/ConnectorRegistry.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/exec/PartitionFunction.h"
-#include "velox/exec/TraceUtil.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/exec/tests/utils/TestIndexStorageConnector.h"
+#include "velox/exec/trace/TraceUtil.h"
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/tool/trace/IndexLookupJoinReplayer.h"
 
@@ -62,18 +63,21 @@ class IndexLookupJoinReplayerTest : public HiveConnectorTestBase {
     velox::exec::trace::registerDummySourceSerDe();
     core::ITypedExpr::registerSerDe();
     registerPartitionFunctionSerDe();
-    auto connectorCpuExecutor =
-        std::make_unique<folly::CPUThreadPoolExecutor>(128);
-    TestIndexConnectorFactory::registerConnector(connectorCpuExecutor.get());
     TestIndexTableHandle::registerSerDe();
     TestIndexColumnHandle::registerSerDe();
+    TestIndexConnectorSplit::registerSerDe();
+  }
+
+  void SetUp() override {
+    HiveConnectorTestBase::SetUp();
+    TestIndexConnectorFactory::registerConnector(connectorCpuExecutor_.get());
   }
 
   void TearDown() override {
     probeInput_.clear();
     indexInput_.clear();
     HiveConnectorTestBase::TearDown();
-    connector::unregisterConnector(kTestIndexConnectorName);
+    connector::ConnectorRegistry::global().erase(kTestIndexConnectorName);
   }
 
   // Create index table with the given key and value inputs.
@@ -117,6 +121,7 @@ class IndexLookupJoinReplayerTest : public HiveConnectorTestBase {
         /*dependentTypes=*/dependentTypes,
         /*allowDuplicates=*/true,
         /*hasProbedFlag=*/false,
+        /*hasCountFlag=*/false,
         /*minTableSizeForParallelJoinBuild=*/1,
         pool_.get());
 
@@ -139,7 +144,8 @@ class IndexLookupJoinReplayerTest : public HiveConnectorTestBase {
     }
 
     // Build the table index.
-    table->prepareJoinTable({}, BaseHashTable::kNoSpillInputStartPartitionBit);
+    table->prepareJoinTable(
+        {}, BaseHashTable::kNoSpillInputStartPartitionBit, 1'000'000);
     return std::make_shared<TestIndexTable>(
         keyType, std::move(valueType), std::move(table));
   }
@@ -147,9 +153,13 @@ class IndexLookupJoinReplayerTest : public HiveConnectorTestBase {
   // Makes index table handle with the specified index table and async lookup
   // flag.
   static std::shared_ptr<TestIndexTableHandle> makeIndexTableHandle(
-      const std::shared_ptr<TestIndexTable>& indexTable) {
+      const std::shared_ptr<TestIndexTable>& indexTable,
+      bool needsIndexSplit = false) {
     return std::make_shared<TestIndexTableHandle>(
-        kTestIndexConnectorName, indexTable, /*asyncLookup*/ false);
+        kTestIndexConnectorName,
+        indexTable,
+        /*asyncLookup=*/false,
+        needsIndexSplit);
   }
 
   struct PlanWithSplits {
@@ -262,7 +272,8 @@ TEST_F(IndexLookupJoinReplayerTest, test) {
               rightKeys,
               std::dynamic_pointer_cast<const core::TableScanNode>(indexScan),
               /*joinConditions=*/{},
-              /*includeMatchColumn=*/false,
+              /*filter=*/"",
+              /*hasMarker=*/false,
               concat(probeType_, indexType_)->names(),
               core::JoinType::kInner)
           .capturePlanNodeId(traceNodeId_)
@@ -304,4 +315,91 @@ TEST_F(IndexLookupJoinReplayerTest, test) {
   assertEqualResults({results}, {replayingResult});
 }
 
+TEST_F(IndexLookupJoinReplayerTest, testWithIndexSplits) {
+  // Test that index splits are traced and replayed correctly when
+  // needsIndexSplit is true.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId probeScanId;
+
+  const auto indexTable = createIndexTable(
+      /*numEqualJoinKeys=*/1,
+      makeRowVector(
+          indexType_->names(),
+          {makeFlatVector<int64_t>({1, 2, 3}),
+           makeFlatVector<int32_t>({10, 20, 30}),
+           makeFlatVector<int16_t>({100, 200, 300}),
+           makeFlatVector<StringView>({"a", "b", "c"})}),
+      makeRowVector(
+          {"u4", "u5"},
+          {makeFlatVector<int64_t>({1000, 2000, 3000}),
+           makeFlatVector<StringView>({"x", "y", "z"})}));
+
+  // Create handle with needsIndexSplit=true.
+  auto indexTableHandle =
+      makeIndexTableHandle(indexTable, /*needsIndexSplit=*/true);
+
+  connector::ColumnHandleMap columnHandles;
+  for (const auto& name : indexType_->names()) {
+    columnHandles[name] = std::make_shared<TestIndexColumnHandle>(name);
+  }
+
+  auto indexScan = std::make_shared<core::TableScanNode>(
+      planNodeIdGenerator->next(), indexType_, indexTableHandle, columnHandles);
+  const auto indexScanId = indexScan->id();
+
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .tableScan(probeType_)
+          .capturePlanNodeId(probeScanId)
+          .indexLookupJoin(
+              leftKeys,
+              rightKeys,
+              std::dynamic_pointer_cast<const core::TableScanNode>(indexScan),
+              /*joinConditions=*/{},
+              /*filter=*/"",
+              /*hasMarker=*/false,
+              concat(probeType_, indexType_)->names(),
+              core::JoinType::kInner)
+          .capturePlanNodeId(traceNodeId_)
+          .planNode();
+
+  const auto testDir = TempDirectoryPath::create();
+  const auto traceRoot = fmt::format("{}/{}", testDir->getPath(), "traceRoot");
+  std::shared_ptr<Task> task;
+
+  const auto sourceFilePath = TempFilePath::create();
+  writeToFile(sourceFilePath->getPath(), probeInput_);
+
+  // Provide index splits to the original query.
+  auto results =
+      AssertQueryBuilder(plan)
+          .config(core::QueryConfig::kQueryTraceEnabled, true)
+          .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+          .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+          .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+          .config(core::QueryConfig::kQueryTraceNodeId, traceNodeId_)
+          .splits(
+              probeScanId,
+              {Split(makeHiveConnectorSplit(sourceFilePath->getPath()))})
+          .splits(
+              indexScanId,
+              {Split(
+                  std::make_shared<TestIndexConnectorSplit>(
+                      kTestIndexConnectorName))})
+          .copyResults(pool(), task);
+
+  // Replay and verify the results match.
+  const auto replayingResult = IndexLookupJoinReplayer(
+                                   traceRoot,
+                                   task->queryCtx()->queryId(),
+                                   task->taskId(),
+                                   traceNodeId_,
+                                   "IndexLookupJoin",
+                                   "",
+                                   0,
+                                   executor_.get())
+                                   .run();
+  assertEqualResults({results}, {replayingResult});
+}
+
 } // namespace facebook::velox::tool::trace::test
diff --git a/velox/tool/trace/tests/MergeJoinReplayerTest.cpp b/velox/tool/trace/tests/MergeJoinReplayerTest.cpp
new file mode 100644
index 00000000000..949e84c4587
--- /dev/null
+++ b/velox/tool/trace/tests/MergeJoinReplayerTest.cpp
@@ -0,0 +1,334 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include <string>
+
+#include "velox/common/testutil/TempDirectoryPath.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/dwio/common/tests/utils/BatchMaker.h"
+#include "velox/exec/OperatorTraceReader.h"
+#include "velox/exec/PartitionFunction.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/trace/TraceUtil.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/tool/trace/MergeJoinReplayer.h"
+#include "velox/tool/trace/TraceReplayRunner.h"
+
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::common::testutil;
+
+namespace facebook::velox::tool::trace::test {
+class MergeJoinReplayerTest : public HiveConnectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+    HiveConnectorTestBase::SetUpTestCase();
+    if (!isRegisteredVectorSerde()) {
+      serializer::presto::PrestoVectorSerde::registerVectorSerde();
+    }
+    Type::registerSerDe();
+    common::Filter::registerSerDe();
+    connector::hive::HiveConnector::registerSerDe();
+    core::PlanNode::registerSerDe();
+    velox::exec::trace::registerDummySourceSerDe();
+    core::ITypedExpr::registerSerDe();
+    registerPartitionFunctionSerDe();
+  }
+
+  void TearDown() override {
+    probeInput_.clear();
+    buildInput_.clear();
+    HiveConnectorTestBase::TearDown();
+  }
+
+  struct PlanWithSplits {
+    core::PlanNodePtr plan;
+    core::PlanNodeId probeScanId;
+    core::PlanNodeId buildScanId;
+    std::unordered_map<core::PlanNodeId, std::vector<exec::Split>> splits;
+
+    explicit PlanWithSplits(
+        const core::PlanNodePtr& _plan,
+        const core::PlanNodeId& _probeScanId = "",
+        const core::PlanNodeId& _buildScanId = "",
+        const std::unordered_map<
+            core::PlanNodeId,
+            std::vector<velox::exec::Split>>& _splits = {})
+        : plan(_plan),
+          probeScanId(_probeScanId),
+          buildScanId(_buildScanId),
+          splits(_splits) {}
+  };
+
+  RowTypePtr concat(const RowTypePtr& a, const RowTypePtr& b) {
+    std::vector<std::string> names = a->names();
+    std::vector<TypePtr> types = a->children();
+
+    for (auto i = 0; i < b->size(); ++i) {
+      names.push_back(b->nameOf(i));
+      types.push_back(b->childAt(i));
+    }
+
+    return ROW(std::move(names), std::move(types));
+  }
+
+  std::vector<RowVectorPtr>
+  makeVectors(int32_t count, int32_t rowsPerVector, const RowTypePtr& rowType) {
+    std::vector<RowVectorPtr> vectors;
+    vectors.reserve(count);
+
+    for (int32_t i = 0; i < count; ++i) {
+      const int32_t startRow = i * rowsPerVector;
+      std::vector<VectorPtr> children;
+
+      for (int32_t col = 0; col < rowType->size(); ++col) {
+        const auto& type = rowType->childAt(col);
+
+        // First column is the join key and must be sorted
+        if (col == 0) {
+          if (type->kind() == TypeKind::BIGINT) {
+            children.push_back(
+                makeFlatVector<int64_t>(rowsPerVector, [startRow](auto row) {
+                  return startRow + row;
+                }));
+          } else {
+            VELOX_FAIL("Unsupported join key type: {}", type->toString());
+          }
+        } else {
+          // Other columns can have random data using BatchMaker
+          children.push_back(VELOX_DYNAMIC_TYPE_DISPATCH(
+              velox::test::BatchMaker::createVector,
+              type->kind(),
+              type,
+              rowsPerVector,
+              *pool()));
+        }
+      }
+
+      vectors.push_back(makeRowVector(rowType->names(), children));
+    }
+
+    return vectors;
+  }
+
+  std::vector<Split> makeSplits(
+      const std::vector<RowVectorPtr>& inputs,
+      const std::string& path,
+      memory::MemoryPool* writerPool) {
+    std::vector<Split> splits;
+    for (auto i = 0; i < 4; ++i) {
+      const std::string filePath = fmt::format("{}/{}", path, i);
+      writeToFile(filePath, inputs);
+      splits.emplace_back(makeHiveConnectorSplit(filePath));
+    }
+
+    return splits;
+  }
+
+  PlanWithSplits createPlan(
+      const std::string& tableDir,
+      core::JoinType joinType,
+      const std::vector<std::string>& probeKeys,
+      const std::vector<std::string>& buildKeys,
+      const std::vector<RowVectorPtr>& probeInput,
+      const std::vector<RowVectorPtr>& buildInput) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    const std::vector<Split> probeSplits =
+        makeSplits(probeInput, fmt::format("{}/probe", tableDir), pool());
+    const std::vector<Split> buildSplits =
+        makeSplits(buildInput, fmt::format("{}/build", tableDir), pool());
+    core::PlanNodeId probeScanId;
+    core::PlanNodeId buildScanId;
+    const auto outputColumns = concat(
+                                   asRowType(buildInput_[0]->type()),
+                                   asRowType(probeInput_[0]->type()))
+                                   ->names();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .tableScan(probeType_)
+                    .capturePlanNodeId(probeScanId)
+                    .mergeJoin(
+                        probeKeys,
+                        buildKeys,
+                        PlanBuilder(planNodeIdGenerator)
+                            .tableScan(buildType_)
+                            .capturePlanNodeId(buildScanId)
+                            .planNode(),
+                        /*filter=*/"",
+                        outputColumns,
+                        joinType)
+                    .capturePlanNodeId(traceNodeId_)
+                    .planNode();
+    return PlanWithSplits{
+        plan,
+        probeScanId,
+        buildScanId,
+        {{probeScanId, probeSplits}, {buildScanId, buildSplits}}};
+  }
+
+  core::PlanNodeId traceNodeId_;
+  RowTypePtr probeType_{
+      ROW({"t0", "t1", "t2", "t3"}, {BIGINT(), VARCHAR(), SMALLINT(), REAL()})};
+
+  RowTypePtr buildType_{
+      ROW({"u0", "u1", "u2", "u3"},
+          {BIGINT(), INTEGER(), SMALLINT(), VARCHAR()})};
+  std::vector<RowVectorPtr> probeInput_ = makeVectors(5, 100, probeType_);
+  std::vector<RowVectorPtr> buildInput_ = makeVectors(3, 100, buildType_);
+
+  const std::vector<std::string> probeKeys_{"t0"};
+  const std::vector<std::string> buildKeys_{"u0"};
+  const std::shared_ptr<TempDirectoryPath> testDir_ =
+      TempDirectoryPath::create();
+  const std::string tableDir_ =
+      fmt::format("{}/{}", testDir_->getPath(), "table");
+};
+
+TEST_F(MergeJoinReplayerTest, basic) {
+  const auto planWithSplits = createPlan(
+      tableDir_,
+      core::JoinType::kInner,
+      probeKeys_,
+      buildKeys_,
+      probeInput_,
+      buildInput_);
+  AssertQueryBuilder builder(planWithSplits.plan);
+  for (const auto& [planNodeId, nodeSplits] : planWithSplits.splits) {
+    builder.splits(planNodeId, nodeSplits);
+  }
+  const auto result = builder.copyResults(pool());
+
+  const auto traceRoot =
+      fmt::format("{}/{}/traceRoot/", testDir_->getPath(), "basic");
+  std::shared_ptr<Task> task;
+  auto tracePlanWithSplits = createPlan(
+      tableDir_,
+      core::JoinType::kInner,
+      probeKeys_,
+      buildKeys_,
+      probeInput_,
+      buildInput_);
+  AssertQueryBuilder traceBuilder(tracePlanWithSplits.plan);
+  traceBuilder.config(core::QueryConfig::kQueryTraceEnabled, true)
+      .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+      .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+      .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+      .config(core::QueryConfig::kQueryTraceNodeId, traceNodeId_);
+  for (const auto& [planNodeId, nodeSplits] : tracePlanWithSplits.splits) {
+    traceBuilder.splits(planNodeId, nodeSplits);
+  }
+  auto traceResult = traceBuilder.copyResults(pool(), task);
+
+  assertEqualResults({result}, {traceResult});
+
+  const auto taskId = task->taskId();
+  const auto replayingResult = MergeJoinReplayer(
+                                   traceRoot,
+                                   task->queryCtx()->queryId(),
+                                   task->taskId(),
+                                   traceNodeId_,
+                                   "MergeJoin",
+                                   /*spillBaseDir=*/"",
+                                   /*driverIds=*/"",
+                                   /*queryCapacity=*/0,
+                                   executor_.get())
+                                   .run();
+  assertEqualResults({result}, {replayingResult});
+}
+
+TEST_F(MergeJoinReplayerTest, runner) {
+  const auto testDir = TempDirectoryPath::create();
+  const auto traceRoot = fmt::format("{}/{}", testDir->getPath(), "traceRoot");
+  std::shared_ptr<Task> task;
+  auto tracePlanWithSplits = createPlan(
+      tableDir_,
+      core::JoinType::kInner,
+      probeKeys_,
+      buildKeys_,
+      probeInput_,
+      buildInput_);
+  AssertQueryBuilder traceBuilder(tracePlanWithSplits.plan);
+  traceBuilder.config(core::QueryConfig::kEnableOperatorBatchSizeStats, true)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+      .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+      .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+      .config(core::QueryConfig::kQueryTraceNodeId, traceNodeId_);
+  for (const auto& [planNodeId, nodeSplits] : tracePlanWithSplits.splits) {
+    traceBuilder.splits(planNodeId, nodeSplits);
+  }
+  auto traceResult = traceBuilder.copyResults(pool(), task);
+
+  const auto taskTraceDir = exec::trace::getTaskTraceDirectory(
+      traceRoot, task->queryCtx()->queryId(), task->taskId());
+  const auto leftOperatorTraceDir = exec::trace::getOpTraceDirectory(
+      taskTraceDir,
+      traceNodeId_,
+      /*pipelineId=*/0,
+      /*driverId=*/0);
+  const auto leftSummary =
+      exec::trace::OperatorTraceSummaryReader(leftOperatorTraceDir, pool())
+          .read();
+  ASSERT_EQ(leftSummary.opType, "MergeJoin");
+  ASSERT_GT(leftSummary.peakMemory, 0);
+  ASSERT_GT(leftSummary.inputRows, 0);
+  // NOTE: the input bytes is 0 because of the lazy materialization.
+  ASSERT_EQ(leftSummary.inputBytes, 0);
+  ASSERT_EQ(leftSummary.rawInputRows, 0);
+  ASSERT_EQ(leftSummary.rawInputBytes, 0);
+
+  const auto rightOperatorTraceDir = exec::trace::getOpTraceDirectory(
+      taskTraceDir,
+      traceNodeId_,
+      /*pipelineId=*/1,
+      /*driverId=*/0);
+  const auto rightSummary =
+      exec::trace::OperatorTraceSummaryReader(rightOperatorTraceDir, pool())
+          .read();
+  ASSERT_EQ(rightSummary.opType, "CallbackSink");
+  // NOTE: CallbackSink does not have its own memory pool.
+  ASSERT_EQ(rightSummary.peakMemory, 0);
+  ASSERT_GT(rightSummary.inputRows, 0);
+  // NOTE: the input bytes is 0 because of the lazy materialization.
+  ASSERT_EQ(rightSummary.inputBytes, 0);
+  ASSERT_EQ(rightSummary.rawInputRows, 0);
+  ASSERT_EQ(rightSummary.rawInputBytes, 0);
+
+  FLAGS_root_dir = traceRoot;
+  FLAGS_query_id = task->queryCtx()->queryId();
+  FLAGS_task_id = task->taskId();
+  FLAGS_node_id = traceNodeId_;
+  FLAGS_summary = true;
+  {
+    TraceReplayRunner runner;
+    runner.init();
+    runner.run();
+  }
+
+  FLAGS_task_id = task->taskId();
+  FLAGS_driver_ids = "";
+  FLAGS_summary = false;
+  {
+    TraceReplayRunner runner;
+    runner.init();
+    runner.run();
+  }
+}
+} // namespace facebook::velox::tool::trace::test
diff --git a/velox/tool/trace/tests/OrderByReplayerTest.cpp b/velox/tool/trace/tests/OrderByReplayerTest.cpp
new file mode 100644
index 00000000000..428769198b0
--- /dev/null
+++ b/velox/tool/trace/tests/OrderByReplayerTest.cpp
@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include <string>
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/exec/PartitionFunction.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/trace/TraceUtil.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/tool/trace/OrderByReplayer.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::core;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::connector;
+using namespace facebook::velox::connector::hive;
+using namespace facebook::velox::common::testutil;
+
+namespace facebook::velox::tool::trace::test {
+class OrderByReplayerTest : public HiveConnectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+    HiveConnectorTestBase::SetUpTestCase();
+    filesystems::registerLocalFileSystem();
+    if (!isRegisteredVectorSerde()) {
+      serializer::presto::PrestoVectorSerde::registerVectorSerde();
+    }
+    Type::registerSerDe();
+    common::Filter::registerSerDe();
+    connector::hive::HiveConnector::registerSerDe();
+    core::PlanNode::registerSerDe();
+    velox::exec::trace::registerDummySourceSerDe();
+    core::ITypedExpr::registerSerDe();
+    registerPartitionFunctionSerDe();
+  }
+
+  void TearDown() override {
+    input_.clear();
+    HiveConnectorTestBase::TearDown();
+  }
+
+  std::vector<RowVectorPtr>
+  makeVectors(int32_t count, int32_t rowsPerVector, const RowTypePtr& rowType) {
+    return HiveConnectorTestBase::makeVectors(rowType, count, rowsPerVector);
+  }
+
+  std::vector<Split> makeSplits(
+      const std::vector<RowVectorPtr>& inputs,
+      const std::string& path) {
+    std::vector<Split> splits;
+    for (auto i = 0; i < 4; ++i) {
+      const std::string filePath = fmt::format("{}/{}", path, i);
+      writeToFile(filePath, inputs);
+      splits.emplace_back(makeHiveConnectorSplit(filePath));
+    }
+
+    return splits;
+  }
+
+  struct PlanWithSplits {
+    core::PlanNodePtr plan;
+    core::PlanNodeId scanId;
+    std::vector<exec::Split> splits;
+
+    explicit PlanWithSplits(
+        const core::PlanNodePtr& _plan,
+        const core::PlanNodeId& _scanId = "",
+        const std::vector<velox::exec::Split>& _splits = {})
+        : plan(_plan), scanId(_scanId), splits(_splits) {}
+  };
+
+  PlanWithSplits createPlan(bool isPartial = false) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId scanId;
+
+    auto builder = PlanBuilder(planNodeIdGenerator)
+                       .tableScan(inputType_)
+                       .capturePlanNodeId(scanId)
+                       .orderBy({"c0"}, isPartial);
+
+    auto plan = builder.capturePlanNodeId(orderById_).planNode();
+
+    const std::vector<Split> splits =
+        makeSplits(input_, fmt::format("{}/splits", testDir_->getPath()));
+    return PlanWithSplits{plan, scanId, splits};
+  }
+
+  core::PlanNodeId orderById_;
+  RowTypePtr inputType_{ROW({"c0", "c1"}, {BIGINT(), VARCHAR()})};
+
+  std::vector<RowVectorPtr> input_ = makeVectors(5, 100, inputType_);
+
+  const std::shared_ptr<TempDirectoryPath> testDir_ =
+      TempDirectoryPath::create();
+};
+
+TEST_F(OrderByReplayerTest, basic) {
+  input_ = {makeRowVector(
+      {makeFlatVector<int64_t>(100, [](auto row) { return 99 - row; }),
+       makeFlatVector<std::string>(
+           100, [](auto row) { return fmt::format("str_{}", row); })})};
+
+  const auto planWithSplits = createPlan();
+  AssertQueryBuilder builder(planWithSplits.plan);
+  const auto result = builder.splits(planWithSplits.splits).copyResults(pool());
+
+  const auto traceRoot =
+      fmt::format("{}/{}/traceRoot/", testDir_->getPath(), "basic");
+  std::shared_ptr<Task> task;
+  auto tracePlanWithSplits = createPlan();
+  AssertQueryBuilder traceBuilder(tracePlanWithSplits.plan);
+  traceBuilder.maxDrivers(4)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+      .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+      .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+      .config(core::QueryConfig::kQueryTraceNodeId, orderById_);
+  auto traceResult =
+      traceBuilder.splits(tracePlanWithSplits.splits).copyResults(pool(), task);
+
+  assertEqualResults({result}, {traceResult});
+
+  const auto replayingResult = OrderByReplayer(
+                                   traceRoot,
+                                   task->queryCtx()->queryId(),
+                                   task->taskId(),
+                                   orderById_,
+                                   "OrderBy",
+                                   "",
+                                   "",
+                                   0,
+                                   executor_.get())
+                                   .run();
+  assertEqualResults({result}, {replayingResult});
+}
+
+TEST_F(OrderByReplayerTest, partial) {
+  input_ = {makeRowVector(
+      {makeFlatVector<int64_t>(100, [](auto row) { return row % 10; }),
+       makeFlatVector<std::string>(
+           100, [](auto row) { return fmt::format("data_{}", row); })})};
+
+  const auto planWithSplits = createPlan(true);
+  AssertQueryBuilder builder(planWithSplits.plan);
+  const auto result = builder.splits(planWithSplits.splits).copyResults(pool());
+
+  const auto traceRoot =
+      fmt::format("{}/{}/traceRoot/", testDir_->getPath(), "partial");
+  std::shared_ptr<Task> task;
+  auto tracePlanWithSplits = createPlan(true);
+  AssertQueryBuilder traceBuilder(tracePlanWithSplits.plan);
+  traceBuilder.maxDrivers(4)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+      .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+      .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+      .config(core::QueryConfig::kQueryTraceNodeId, orderById_);
+  auto traceResult =
+      traceBuilder.splits(tracePlanWithSplits.splits).copyResults(pool(), task);
+
+  assertEqualResults({result}, {traceResult});
+
+  const auto replayingResult = OrderByReplayer(
+                                   traceRoot,
+                                   task->queryCtx()->queryId(),
+                                   task->taskId(),
+                                   orderById_,
+                                   "OrderBy",
+                                   "",
+                                   "",
+                                   0,
+                                   executor_.get())
+                                   .run();
+  assertEqualResults({result}, {replayingResult});
+}
+
+} // namespace facebook::velox::tool::trace::test
diff --git a/velox/tool/trace/tests/PartitionedOutputReplayerTest.cpp b/velox/tool/trace/tests/PartitionedOutputReplayerTest.cpp
index e30398a44c9..20a3cf0e040 100644
--- a/velox/tool/trace/tests/PartitionedOutputReplayerTest.cpp
+++ b/velox/tool/trace/tests/PartitionedOutputReplayerTest.cpp
@@ -21,13 +21,13 @@
 #include "folly/dynamic.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/exec/OperatorTraceReader.h"
 #include "velox/exec/PartitionFunction.h"
-#include "velox/exec/TraceUtil.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/exec/trace/TraceUtil.h"
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/tool/trace/PartitionedOutputReplayer.h"
 
@@ -36,17 +36,15 @@ using namespace facebook::velox::core;
 using namespace facebook::velox::common;
 using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
+using namespace facebook::velox::common::testutil;
 
 namespace facebook::velox::tool::trace::test {
 class PartitionedOutputReplayerTest
     : public HiveConnectorTestBase,
-      public testing::WithParamInterface<VectorSerde::Kind> {
+      public testing::WithParamInterface<std::string> {
  public:
-  static std::vector<VectorSerde::Kind> getTestParams() {
-    const std::vector<VectorSerde::Kind> kinds(
-        {VectorSerde::Kind::kPresto,
-         VectorSerde::Kind::kCompactRow,
-         VectorSerde::Kind::kUnsafeRow});
+  static std::vector<std::string> getTestParams() {
+    const std::vector<std::string> kinds({"Presto", "CompactRow", "UnsafeRow"});
     return kinds;
   }
 
@@ -114,7 +112,8 @@ class PartitionedOutputReplayerTest
               std::to_string(8UL << 20)},
              {core::QueryConfig::kMaxOutputBufferSize,
               std::to_string(8UL << 20)}}),
-        Task::ExecutionMode::kParallel);
+        Task::ExecutionMode::kParallel,
+        exec::Consumer{});
     return task;
   }
 
@@ -162,7 +161,7 @@ TEST_P(PartitionedOutputReplayerTest, defaultConsumer) {
                       "",
                       0,
                       executor_.get())
-                      .run(false));
+                      .run(false, false));
 }
 
 TEST_P(PartitionedOutputReplayerTest, basic) {
@@ -237,8 +236,8 @@ TEST_P(PartitionedOutputReplayerTest, basic) {
         });
 
     // Verified that the trace summary has been written properly.
-    const auto taskTraceDir =
-        exec::trace::getTaskTraceDirectory(traceRoot, *originalTask);
+    const auto taskTraceDir = exec::trace::getTaskTraceDirectory(
+        traceRoot, originalTask->queryCtx()->queryId(), originalTask->taskId());
     originalTask.reset();
 
     {
@@ -259,7 +258,7 @@ TEST_P(PartitionedOutputReplayerTest, basic) {
           [&](auto partition, auto page) {
             replayedPartitionedResults[partition].push_back(std::move(page));
           })
-          .run(false);
+          .run(false, false);
 
       ASSERT_EQ(replayedPartitionedResults.size(), testParam.numPartitions);
       for (uint32_t partition = 0; partition < testParam.numPartitions;
diff --git a/velox/tool/trace/tests/TableScanReplayerTest.cpp b/velox/tool/trace/tests/TableScanReplayerTest.cpp
index 91cf139cbd7..b60c712adc8 100644
--- a/velox/tool/trace/tests/TableScanReplayerTest.cpp
+++ b/velox/tool/trace/tests/TableScanReplayerTest.cpp
@@ -22,14 +22,14 @@
 
 #include "folly/dynamic.h"
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/exec/OperatorTraceReader.h"
 #include "velox/exec/PartitionFunction.h"
-#include "velox/exec/TraceUtil.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/exec/trace/TraceUtil.h"
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/tool/trace/TableScanReplayer.h"
 #include "velox/tool/trace/TraceReplayRunner.h"
@@ -122,8 +122,8 @@ TEST_F(TableScanReplayerTest, runner) {
           .splits(makeHiveConnectorSplits(splitFiles))
           .copyResults(pool(), task);
 
-  const auto taskTraceDir =
-      exec::trace::getTaskTraceDirectory(traceRoot, *task);
+  const auto taskTraceDir = exec::trace::getTaskTraceDirectory(
+      traceRoot, task->queryCtx()->queryId(), task->taskId());
   const auto taskTraceReader =
       exec::trace::TaskTraceMetadataReader(taskTraceDir, pool());
   const auto connectorId = taskTraceReader.connectorId(traceNodeId_);
@@ -297,7 +297,7 @@ TEST_F(TableScanReplayerTest, subfieldPrunning) {
   connector::ColumnHandleMap assignments;
   assignments["e"] = std::make_shared<HiveColumnHandle>(
       "e",
-      HiveColumnHandle::ColumnType::kRegular,
+      FileColumnHandle::ColumnType::kRegular,
       columnType,
       columnType,
       std::move(requiredSubfields));
@@ -308,9 +308,9 @@ TEST_F(TableScanReplayerTest, subfieldPrunning) {
                         .endTableScan()
                         .capturePlanNodeId(traceNodeId_)
                         .planNode();
-  const auto split = makeHiveConnectorSplit(filePath->getPath());
-  const auto results =
-      AssertQueryBuilder(plan).split(split).copyResults(pool());
+  const auto results = AssertQueryBuilder(plan)
+                           .split(makeHiveConnectorSplit(filePath->getPath()))
+                           .copyResults(pool());
 
   const auto testDir = TempDirectoryPath::create();
   const auto traceRoot = fmt::format("{}/{}", testDir->getPath(), "traceRoot");
@@ -322,7 +322,7 @@ TEST_F(TableScanReplayerTest, subfieldPrunning) {
           .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
           .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
           .config(core::QueryConfig::kQueryTraceNodeId, traceNodeId_)
-          .split(split)
+          .split(makeHiveConnectorSplit(filePath->getPath()))
           .copyResults(pool(), task);
 
   assertEqualResults({results}, {traceResult});
diff --git a/velox/tool/trace/tests/TableWriterReplayerTest.cpp b/velox/tool/trace/tests/TableWriterReplayerTest.cpp
index c5b2d3bf556..f358ceb0515 100644
--- a/velox/tool/trace/tests/TableWriterReplayerTest.cpp
+++ b/velox/tool/trace/tests/TableWriterReplayerTest.cpp
@@ -23,15 +23,15 @@
 #include "folly/dynamic.h"
 #include "velox/common/base/Fs.h"
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/exec/OperatorTraceReader.h"
 #include "velox/exec/PartitionFunction.h"
 #include "velox/exec/TableWriter.h"
-#include "velox/exec/TraceUtil.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/exec/trace/TraceUtil.h"
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/tool/trace/TableWriterReplayer.h"
 #include "velox/tool/trace/TraceReplayRunner.h"
@@ -194,8 +194,9 @@ class TableWriterReplayerTest : public HiveConnectorTestBase {
 
     for (auto& path : fs::recursive_directory_iterator(directoryPath)) {
       if (path.is_regular_file()) {
-        splits.push_back(HiveConnectorTestBase::makeHiveConnectorSplits(
-            path.path().string(), 1, fileFormat_)[0]);
+        splits.push_back(
+            HiveConnectorTestBase::makeHiveConnectorSplits(
+                path.path().string(), 1, fileFormat_)[0]);
       }
     }
 
@@ -247,7 +248,8 @@ class TableWriterReplayerTest : public HiveConnectorTestBase {
         std::vector<core::FieldAccessTypedExprPtr>{},
         aggregateNames,
         aggregates,
-        false, // ignoreNullKeys
+        /*ignoreNullKeys=*/false,
+        /*noGroupsSpanBatches=*/false,
         source);
   }
 
@@ -286,8 +288,8 @@ TEST_F(TableWriterReplayerTest, runner) {
           .split(makeHiveConnectorSplit(sourceFilePath->getPath()))
           .copyResults(pool(), task);
 
-  const auto taskTraceDir =
-      exec::trace::getTaskTraceDirectory(traceRoot, *task);
+  const auto taskTraceDir = exec::trace::getTaskTraceDirectory(
+      traceRoot, task->queryCtx()->queryId(), task->taskId());
   const auto opTraceDir = exec::trace::getOpTraceDirectory(
       taskTraceDir,
       traceNodeId,
@@ -313,6 +315,7 @@ TEST_F(TableWriterReplayerTest, runner) {
     runner.init();
     runner.run();
   }
+  resetHiveConnector();
 
   const auto traceOutputDir = TempDirectoryPath::create();
   FLAGS_task_id = task->taskId();
@@ -324,6 +327,7 @@ TEST_F(TableWriterReplayerTest, runner) {
     runner.init();
     runner.run();
   }
+  resetHiveConnector();
 }
 
 TEST_F(TableWriterReplayerTest, basic) {
@@ -372,7 +376,8 @@ TEST_F(TableWriterReplayerTest, basic) {
   // Second column contains details about written files.
   const auto details = results->childAt(TableWriteTraits::kFragmentChannel)
                            ->as<FlatVector<StringView>>();
-  const folly::dynamic obj = folly::parseJson(details->valueAt(1));
+  const folly::dynamic obj =
+      folly::parseJson(std::string_view(details->valueAt(1)));
   const auto fileWriteInfos = obj["fileWriteInfos"];
   ASSERT_EQ(1, fileWriteInfos.size());
 
@@ -382,12 +387,107 @@ TEST_F(TableWriterReplayerTest, basic) {
 
   const auto copy =
       AssertQueryBuilder(plan)
-          .split(makeHiveConnectorSplit(fmt::format(
-              "{}/{}", targetDirectoryPath->getPath(), writeFileName)))
+          .split(makeHiveConnectorSplit(
+              fmt::format(
+                  "{}/{}", targetDirectoryPath->getPath(), writeFileName)))
           .copyResults(pool());
   assertEqualResults({data}, {copy});
 }
 
+TEST_F(TableWriterReplayerTest, serdeParametersPreserved) {
+  vector_size_t size = 1'000;
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>(size, [](auto row) { return row; }),
+      makeFlatVector<int32_t>(
+          size, [](auto row) { return row * 2; }, nullEvery(7)),
+  });
+  auto sourceFilePath = TempFilePath::create();
+  writeToFile(sourceFilePath->getPath(), data);
+
+  const std::unordered_map<std::string, std::string> serdeParams = {
+      {"test.param.one", "value1"},
+      {"test.param.two", "42"},
+  };
+
+  auto rowType = asRowType(data->type());
+  auto targetDirectoryPath = TempDirectoryPath::create();
+  auto insertHandle = std::make_shared<core::InsertTableHandle>(
+      kHiveConnectorId,
+      makeHiveInsertTableHandle(
+          rowType->names(),
+          rowType->children(),
+          {},
+          nullptr,
+          makeLocationHandle(
+              targetDirectoryPath->getPath(),
+              std::nullopt,
+              connector::hive::LocationHandle::TableType::kNew),
+          fileFormat_,
+          std::nullopt,
+          serdeParams));
+
+  std::string traceNodeId;
+  auto plan =
+      PlanBuilder()
+          .tableScan(rowType)
+          .addNode(addTableWriter(
+              rowType, rowType->names(), std::nullopt, insertHandle, false))
+          .capturePlanNodeId(traceNodeId)
+          .project({TableWriteTraits::rowCountColumnName()})
+          .singleAggregation(
+              {},
+              {fmt::format("sum({})", TableWriteTraits::rowCountColumnName())})
+          .planNode();
+
+  const auto testDir = TempDirectoryPath::create();
+  const auto traceRoot = fmt::format("{}/{}", testDir->getPath(), "traceRoot");
+  std::shared_ptr<Task> task;
+  AssertQueryBuilder(plan)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+      .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+      .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+      .config(core::QueryConfig::kQueryTraceNodeId, traceNodeId)
+      .split(makeHiveConnectorSplit(sourceFilePath->getPath()))
+      .copyResults(pool(), task);
+
+  const auto traceOutputDir = TempDirectoryPath::create();
+  const auto result = TableWriterReplayer(
+                          traceRoot,
+                          task->queryCtx()->queryId(),
+                          task->taskId(),
+                          "1",
+                          "TableWriter",
+                          "",
+                          0,
+                          executor_.get(),
+                          traceOutputDir->getPath())
+                          .run();
+
+  const auto taskTraceDir = exec::trace::getTaskTraceDirectory(
+      traceRoot, task->queryCtx()->queryId(), task->taskId());
+  const auto taskMetaReader =
+      exec::trace::TaskTraceMetadataReader(taskTraceDir, pool());
+  const auto queryPlan = taskMetaReader.queryPlan();
+  const auto* replayNode = core::PlanNode::findFirstNode(
+      queryPlan.get(),
+      [&](const auto* node) { return node->id() == traceNodeId; });
+  ASSERT_NE(replayNode, nullptr);
+  const auto* tableWriteNode =
+      dynamic_cast<const core::TableWriteNode*>(replayNode);
+  ASSERT_NE(tableWriteNode, nullptr);
+  const auto tracedHandle =
+      std::dynamic_pointer_cast<const connector::hive::HiveInsertTableHandle>(
+          tableWriteNode->insertTableHandle()->connectorInsertTableHandle());
+  ASSERT_NE(tracedHandle, nullptr);
+  const auto& tracedSerdeParams = tracedHandle->serdeParameters();
+  ASSERT_EQ(tracedSerdeParams.size(), serdeParams.size());
+  for (const auto& [key, value] : serdeParams) {
+    ASSERT_EQ(tracedSerdeParams.count(key), 1);
+    ASSERT_EQ(tracedSerdeParams.at(key), value);
+  }
+}
+
 TEST_F(TableWriterReplayerTest, partitionWrite) {
   const int32_t numPartitions = 4;
   const int32_t numBatches = 2;
diff --git a/velox/tool/trace/tests/TopNRowNumberReplayerTest.cpp b/velox/tool/trace/tests/TopNRowNumberReplayerTest.cpp
new file mode 100644
index 00000000000..ffb84a4cf3a
--- /dev/null
+++ b/velox/tool/trace/tests/TopNRowNumberReplayerTest.cpp
@@ -0,0 +1,396 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include <string>
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/exec/PartitionFunction.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/trace/TraceUtil.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/tool/trace/TopNRowNumberReplayer.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::core;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::connector;
+using namespace facebook::velox::connector::hive;
+using namespace facebook::velox::common::testutil;
+
+namespace facebook::velox::tool::trace::test {
+class TopNRowNumberReplayerTest : public HiveConnectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+    HiveConnectorTestBase::SetUpTestCase();
+    filesystems::registerLocalFileSystem();
+    if (!isRegisteredVectorSerde()) {
+      serializer::presto::PrestoVectorSerde::registerVectorSerde();
+    }
+    Type::registerSerDe();
+    common::Filter::registerSerDe();
+    connector::hive::HiveConnector::registerSerDe();
+    core::PlanNode::registerSerDe();
+    velox::exec::trace::registerDummySourceSerDe();
+    core::ITypedExpr::registerSerDe();
+    registerPartitionFunctionSerDe();
+  }
+
+  void TearDown() override {
+    input_.clear();
+    HiveConnectorTestBase::TearDown();
+  }
+
+  std::vector<RowVectorPtr>
+  makeVectors(int32_t count, int32_t rowsPerVector, const RowTypePtr& rowType) {
+    return HiveConnectorTestBase::makeVectors(rowType, count, rowsPerVector);
+  }
+
+  std::vector<Split> makeSplits(
+      const std::vector<RowVectorPtr>& inputs,
+      const std::string& path) {
+    std::vector<Split> splits;
+    for (auto i = 0; i < 4; ++i) {
+      const std::string filePath = fmt::format("{}/{}", path, i);
+      writeToFile(filePath, inputs);
+      splits.emplace_back(makeHiveConnectorSplit(filePath));
+    }
+
+    return splits;
+  }
+
+  struct PlanWithSplits {
+    core::PlanNodePtr plan;
+    core::PlanNodeId scanId;
+    std::vector<exec::Split> splits;
+
+    explicit PlanWithSplits(
+        const core::PlanNodePtr& _plan,
+        const core::PlanNodeId& _scanId = "",
+        const std::vector<velox::exec::Split>& _splits = {})
+        : plan(_plan), scanId(_scanId), splits(_splits) {}
+  };
+
+  PlanWithSplits createPlan(
+      int32_t limit,
+      bool generateRowNumber = true,
+      const std::vector<std::string>& partitionKeys = {"c0"},
+      const std::vector<std::string>& sortingKeys = {"c1"}) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId scanId;
+
+    auto builder =
+        PlanBuilder(planNodeIdGenerator)
+            .tableScan(inputType_)
+            .capturePlanNodeId(scanId)
+            .topNRowNumber(
+                partitionKeys, sortingKeys, limit, generateRowNumber);
+
+    auto plan = builder.capturePlanNodeId(topNRowNumberId_).planNode();
+
+    const std::vector<Split> splits =
+        makeSplits(input_, fmt::format("{}/splits", testDir_->getPath()));
+    return PlanWithSplits{plan, scanId, splits};
+  }
+
+  PlanWithSplits createRankPlan(
+      std::string_view function,
+      int32_t limit,
+      bool generateRowNumber = true,
+      const std::vector<std::string>& partitionKeys = {"c0"},
+      const std::vector<std::string>& sortingKeys = {"c1"}) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId scanId;
+
+    auto builder =
+        PlanBuilder(planNodeIdGenerator)
+            .tableScan(inputType_)
+            .capturePlanNodeId(scanId)
+            .topNRank(
+                function, partitionKeys, sortingKeys, limit, generateRowNumber);
+
+    auto plan = builder.capturePlanNodeId(topNRowNumberId_).planNode();
+
+    const std::vector<Split> splits =
+        makeSplits(input_, fmt::format("{}/splits", testDir_->getPath()));
+    return PlanWithSplits{plan, scanId, splits};
+  }
+
+  core::PlanNodeId topNRowNumberId_;
+  RowTypePtr inputType_{ROW({"c0", "c1"}, {BIGINT(), VARCHAR()})};
+
+  std::vector<RowVectorPtr> input_ = makeVectors(5, 100, inputType_);
+
+  const std::shared_ptr<TempDirectoryPath> testDir_ =
+      TempDirectoryPath::create();
+};
+
+TEST_F(TopNRowNumberReplayerTest, basic) {
+  input_ = {makeRowVector(
+      {makeFlatVector<int64_t>(100, [](auto row) { return row % 10; }),
+       makeFlatVector<std::string>(
+           100, [](auto row) { return fmt::format("str_{}", 99 - row); })})};
+
+  const auto planWithSplits = createPlan(5, true);
+  AssertQueryBuilder builder(planWithSplits.plan);
+  const auto result =
+      builder.maxDrivers(1).splits(planWithSplits.splits).copyResults(pool());
+
+  const auto traceRoot =
+      fmt::format("{}/{}/traceRoot/", testDir_->getPath(), "basic");
+  std::shared_ptr<Task> task;
+  auto tracePlanWithSplits = createPlan(5, true);
+  AssertQueryBuilder traceBuilder(tracePlanWithSplits.plan);
+  traceBuilder.maxDrivers(1)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+      .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+      .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+      .config(core::QueryConfig::kQueryTraceNodeId, topNRowNumberId_);
+  auto traceResult =
+      traceBuilder.splits(tracePlanWithSplits.splits).copyResults(pool(), task);
+
+  assertEqualResults({result}, {traceResult});
+
+  const auto replayingResult = TopNRowNumberReplayer(
+                                   traceRoot,
+                                   task->queryCtx()->queryId(),
+                                   task->taskId(),
+                                   topNRowNumberId_,
+                                   "TopNRowNumber",
+                                   "",
+                                   "",
+                                   0,
+                                   executor_.get())
+                                   .run();
+  assertEqualResults({result}, {replayingResult});
+}
+
+TEST_F(TopNRowNumberReplayerTest, withoutRowNumber) {
+  input_ = {makeRowVector(
+      {makeFlatVector<int64_t>(100, [](auto row) { return row % 10; }),
+       makeFlatVector<std::string>(
+           100, [](auto row) { return fmt::format("data_{}", row); })})};
+
+  const auto planWithSplits = createPlan(10, false);
+  AssertQueryBuilder builder(planWithSplits.plan);
+  const auto result =
+      builder.maxDrivers(1).splits(planWithSplits.splits).copyResults(pool());
+
+  const auto traceRoot =
+      fmt::format("{}/{}/traceRoot/", testDir_->getPath(), "withoutRowNumber");
+  std::shared_ptr<Task> task;
+  auto tracePlanWithSplits = createPlan(10, false);
+  AssertQueryBuilder traceBuilder(tracePlanWithSplits.plan);
+  traceBuilder.maxDrivers(1)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+      .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+      .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+      .config(core::QueryConfig::kQueryTraceNodeId, topNRowNumberId_);
+  auto traceResult =
+      traceBuilder.splits(tracePlanWithSplits.splits).copyResults(pool(), task);
+
+  assertEqualResults({result}, {traceResult});
+
+  const auto replayingResult = TopNRowNumberReplayer(
+                                   traceRoot,
+                                   task->queryCtx()->queryId(),
+                                   task->taskId(),
+                                   topNRowNumberId_,
+                                   "TopNRowNumber",
+                                   "",
+                                   "",
+                                   0,
+                                   executor_.get())
+                                   .run();
+  assertEqualResults({result}, {replayingResult});
+}
+
+TEST_F(TopNRowNumberReplayerTest, multiplePartitions) {
+  input_ = {makeRowVector(
+      {makeFlatVector<int64_t>(100, [](auto row) { return row % 5; }),
+       makeFlatVector<std::string>(
+           100, [](auto row) { return fmt::format("value_{}", 99 - row); })})};
+
+  const auto planWithSplits = createPlan(3, true);
+  AssertQueryBuilder builder(planWithSplits.plan);
+  const auto result =
+      builder.maxDrivers(1).splits(planWithSplits.splits).copyResults(pool());
+
+  const auto traceRoot = fmt::format(
+      "{}/{}/traceRoot/", testDir_->getPath(), "multiplePartitions");
+  std::shared_ptr<Task> task;
+  auto tracePlanWithSplits = createPlan(3, true);
+  AssertQueryBuilder traceBuilder(tracePlanWithSplits.plan);
+  traceBuilder.maxDrivers(1)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+      .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+      .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+      .config(core::QueryConfig::kQueryTraceNodeId, topNRowNumberId_);
+  auto traceResult =
+      traceBuilder.splits(tracePlanWithSplits.splits).copyResults(pool(), task);
+
+  assertEqualResults({result}, {traceResult});
+
+  const auto replayingResult = TopNRowNumberReplayer(
+                                   traceRoot,
+                                   task->queryCtx()->queryId(),
+                                   task->taskId(),
+                                   topNRowNumberId_,
+                                   "TopNRowNumber",
+                                   "",
+                                   "",
+                                   0,
+                                   executor_.get())
+                                   .run();
+  assertEqualResults({result}, {replayingResult});
+}
+
+TEST_F(TopNRowNumberReplayerTest, noPartitionKeys) {
+  input_ = {makeRowVector(
+      {makeFlatVector<int64_t>(100, [](auto row) { return row; }),
+       makeFlatVector<std::string>(
+           100, [](auto row) { return fmt::format("str_{}", 99 - row); })})};
+
+  const auto planWithSplits = createPlan(5, true, {}, {"c1"});
+  AssertQueryBuilder builder(planWithSplits.plan);
+  const auto result =
+      builder.maxDrivers(1).splits(planWithSplits.splits).copyResults(pool());
+
+  const auto traceRoot =
+      fmt::format("{}/{}/traceRoot/", testDir_->getPath(), "noPartitionKeys");
+  std::shared_ptr<Task> task;
+  auto tracePlanWithSplits = createPlan(5, true, {}, {"c1"});
+  AssertQueryBuilder traceBuilder(tracePlanWithSplits.plan);
+  traceBuilder.maxDrivers(1)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+      .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+      .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+      .config(core::QueryConfig::kQueryTraceNodeId, topNRowNumberId_);
+  auto traceResult =
+      traceBuilder.splits(tracePlanWithSplits.splits).copyResults(pool(), task);
+
+  assertEqualResults({result}, {traceResult});
+
+  const auto replayingResult = TopNRowNumberReplayer(
+                                   traceRoot,
+                                   task->queryCtx()->queryId(),
+                                   task->taskId(),
+                                   topNRowNumberId_,
+                                   "TopNRowNumber",
+                                   "",
+                                   "",
+                                   0,
+                                   executor_.get())
+                                   .run();
+  assertEqualResults({result}, {replayingResult});
+}
+
+TEST_F(TopNRowNumberReplayerTest, multipleSortingKeys) {
+  inputType_ = ROW({"c0", "c1", "c2"}, {BIGINT(), BIGINT(), VARCHAR()});
+  input_ = {makeRowVector(
+      {makeFlatVector<int64_t>(100, [](auto row) { return row % 5; }),
+       makeFlatVector<int64_t>(100, [](auto row) { return row / 10; }),
+       makeFlatVector<std::string>(
+           100, [](auto row) { return fmt::format("str_{}", 99 - row); })})};
+
+  const auto planWithSplits = createPlan(3, true, {"c0"}, {"c1 DESC", "c2"});
+  AssertQueryBuilder builder(planWithSplits.plan);
+  const auto result =
+      builder.maxDrivers(1).splits(planWithSplits.splits).copyResults(pool());
+
+  const auto traceRoot = fmt::format(
+      "{}/{}/traceRoot/", testDir_->getPath(), "multipleSortingKeys");
+  std::shared_ptr<Task> task;
+  auto tracePlanWithSplits = createPlan(3, true, {"c0"}, {"c1 DESC", "c2"});
+  AssertQueryBuilder traceBuilder(tracePlanWithSplits.plan);
+  traceBuilder.maxDrivers(1)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+      .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+      .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+      .config(core::QueryConfig::kQueryTraceNodeId, topNRowNumberId_);
+  auto traceResult =
+      traceBuilder.splits(tracePlanWithSplits.splits).copyResults(pool(), task);
+
+  assertEqualResults({result}, {traceResult});
+
+  const auto replayingResult = TopNRowNumberReplayer(
+                                   traceRoot,
+                                   task->queryCtx()->queryId(),
+                                   task->taskId(),
+                                   topNRowNumberId_,
+                                   "TopNRowNumber",
+                                   "",
+                                   "",
+                                   0,
+                                   executor_.get())
+                                   .run();
+  assertEqualResults({result}, {replayingResult});
+}
+
+TEST_F(TopNRowNumberReplayerTest, limitOne) {
+  input_ = {makeRowVector(
+      {makeFlatVector<int64_t>(100, [](auto row) { return row % 10; }),
+       makeFlatVector<std::string>(
+           100, [](auto row) { return fmt::format("str_{}", 99 - row); })})};
+
+  const auto planWithSplits = createPlan(1, true);
+  AssertQueryBuilder builder(planWithSplits.plan);
+  const auto result =
+      builder.maxDrivers(1).splits(planWithSplits.splits).copyResults(pool());
+
+  const auto traceRoot =
+      fmt::format("{}/{}/traceRoot/", testDir_->getPath(), "limitOne");
+  std::shared_ptr<Task> task;
+  auto tracePlanWithSplits = createPlan(1, true);
+  AssertQueryBuilder traceBuilder(tracePlanWithSplits.plan);
+  traceBuilder.maxDrivers(1)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+      .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+      .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+      .config(core::QueryConfig::kQueryTraceNodeId, topNRowNumberId_);
+  auto traceResult =
+      traceBuilder.splits(tracePlanWithSplits.splits).copyResults(pool(), task);
+
+  assertEqualResults({result}, {traceResult});
+
+  const auto replayingResult = TopNRowNumberReplayer(
+                                   traceRoot,
+                                   task->queryCtx()->queryId(),
+                                   task->taskId(),
+                                   topNRowNumberId_,
+                                   "TopNRowNumber",
+                                   "",
+                                   "",
+                                   0,
+                                   executor_.get())
+                                   .run();
+  assertEqualResults({result}, {replayingResult});
+}
+
+} // namespace facebook::velox::tool::trace::test
diff --git a/velox/tool/trace/tests/TraceFileToolTest.cpp b/velox/tool/trace/tests/TraceFileToolTest.cpp
index 4c84384c88a..f5662dbbdb6 100644
--- a/velox/tool/trace/tests/TraceFileToolTest.cpp
+++ b/velox/tool/trace/tests/TraceFileToolTest.cpp
@@ -21,13 +21,13 @@
 
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/tests/FaultyFileSystem.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/exec/PartitionFunction.h"
-#include "velox/exec/TraceUtil.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/exec/trace/TraceUtil.h"
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/tool/trace/HashJoinReplayer.h"
 #include "velox/tool/trace/TraceFileToolRunner.h"
@@ -251,6 +251,7 @@ TEST_F(TraceFileToolTest, basic) {
                                      traceNodeId_,
                                      "HashJoin",
                                      "",
+                                     "",
                                      0,
                                      executor_.get())
                                      .run();
diff --git a/velox/tool/trace/tests/TraceReplayerConfigPromptTest.cpp b/velox/tool/trace/tests/TraceReplayerConfigPromptTest.cpp
new file mode 100644
index 00000000000..b90f443b79a
--- /dev/null
+++ b/velox/tool/trace/tests/TraceReplayerConfigPromptTest.cpp
@@ -0,0 +1,235 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include <sstream>
+
+#include "velox/tool/trace/TraceReplayerConfigPrompt.h"
+
+DECLARE_string(root_dir);
+DECLARE_string(query_id);
+DECLARE_string(task_id);
+DECLARE_string(node_id);
+DECLARE_string(driver_ids);
+DECLARE_string(table_writer_output_dir);
+
+namespace facebook::velox::tool::trace::test {
+namespace {
+
+class TraceReplayerConfigPromptTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    // Save original flag values
+    originalRootDir_ = FLAGS_root_dir;
+    originalQueryId_ = FLAGS_query_id;
+    originalTaskId_ = FLAGS_task_id;
+    originalNodeId_ = FLAGS_node_id;
+    originalDriverIds_ = FLAGS_driver_ids;
+    originalTableWriterOutputDir_ = FLAGS_table_writer_output_dir;
+    originalFast_ = FLAGS_fast;
+
+    // Reset flags to empty/default state
+    FLAGS_root_dir = "";
+    FLAGS_query_id = "";
+    FLAGS_task_id = "";
+    FLAGS_node_id = "";
+    FLAGS_driver_ids = "";
+    FLAGS_table_writer_output_dir = "";
+    FLAGS_fast = false;
+  }
+
+  void TearDown() override {
+    // Restore original flag values
+    FLAGS_root_dir = originalRootDir_;
+    FLAGS_query_id = originalQueryId_;
+    FLAGS_task_id = originalTaskId_;
+    FLAGS_node_id = originalNodeId_;
+    FLAGS_driver_ids = originalDriverIds_;
+    FLAGS_table_writer_output_dir = originalTableWriterOutputDir_;
+    FLAGS_fast = originalFast_;
+
+    // Restore cin buffer if it was redirected
+    if (originalCinBuf_ != nullptr) {
+      std::cin.rdbuf(originalCinBuf_);
+      originalCinBuf_ = nullptr;
+    }
+  }
+
+  // Helper to redirect stdin from a string
+  void setStdinInput(const std::string& input) {
+    stdinStream_ = std::make_unique<std::istringstream>(input);
+    originalCinBuf_ = std::cin.rdbuf(stdinStream_->rdbuf());
+  }
+
+  std::string originalRootDir_;
+  std::string originalQueryId_;
+  std::string originalTaskId_;
+  std::string originalNodeId_;
+  std::string originalDriverIds_;
+  std::string originalTableWriterOutputDir_;
+  bool originalFast_;
+  std::unique_ptr<std::istringstream> stdinStream_;
+  std::streambuf* originalCinBuf_{nullptr};
+};
+
+TEST_F(TraceReplayerConfigPromptTest, fastModeSkipsPrompts) {
+  // Set up flags with values
+  FLAGS_root_dir = "/test/root";
+  FLAGS_query_id = "query-123";
+  FLAGS_task_id = "task-456";
+  FLAGS_node_id = "node-789";
+  FLAGS_fast = true;
+
+  // Redirect stdout to capture output
+  std::ostringstream capturedOutput;
+  std::streambuf* originalCoutBuf = std::cout.rdbuf(capturedOutput.rdbuf());
+
+  TraceReplayerConfigPrompt prompt;
+  prompt.run();
+
+  // Restore stdout
+  std::cout.rdbuf(originalCoutBuf);
+
+  // Verify flags remain unchanged
+  EXPECT_EQ(FLAGS_root_dir, "/test/root");
+  EXPECT_EQ(FLAGS_query_id, "query-123");
+  EXPECT_EQ(FLAGS_task_id, "task-456");
+  EXPECT_EQ(FLAGS_node_id, "node-789");
+
+  // Verify output indicates fast mode
+  std::string output = capturedOutput.str();
+  EXPECT_TRUE(output.find("--fast mode") != std::string::npos);
+  EXPECT_TRUE(output.find("Skipping interactive prompts") != std::string::npos);
+}
+
+TEST_F(TraceReplayerConfigPromptTest, interactivePromptsSetFlags) {
+  // Simulate user entering values for all prompts
+  setStdinInput(
+      "/root/dir\n" // root_dir
+      "query-id-1\n" // query_id
+      "task-id-1\n" // task_id
+      "node-id-1\n" // node_id
+      "0,1,2\n" // driver_ids
+      "/output/dir\n"); // table_writer_output_dir
+
+  std::ostringstream capturedOutput;
+  std::streambuf* originalCoutBuf = std::cout.rdbuf(capturedOutput.rdbuf());
+
+  FLAGS_fast = false;
+  TraceReplayerConfigPrompt prompt;
+  prompt.run();
+
+  std::cout.rdbuf(originalCoutBuf);
+
+  EXPECT_EQ(FLAGS_root_dir, "/root/dir");
+  EXPECT_EQ(FLAGS_query_id, "query-id-1");
+  EXPECT_EQ(FLAGS_task_id, "task-id-1");
+  EXPECT_EQ(FLAGS_node_id, "node-id-1");
+  EXPECT_EQ(FLAGS_driver_ids, "0,1,2");
+  EXPECT_EQ(FLAGS_table_writer_output_dir, "/output/dir");
+}
+
+TEST_F(TraceReplayerConfigPromptTest, interactivePromptsShowFastCommand) {
+  // Simulate user entering values
+  setStdinInput(
+      "/root/dir\n"
+      "query-123\n"
+      "task-456\n"
+      "node-789\n"
+      "\n" // empty driver_ids
+      "\n"); // empty table_writer_output_dir
+
+  std::ostringstream capturedOutput;
+  std::streambuf* originalCoutBuf = std::cout.rdbuf(capturedOutput.rdbuf());
+
+  FLAGS_fast = false;
+  TraceReplayerConfigPrompt prompt;
+  prompt.run();
+
+  std::cout.rdbuf(originalCoutBuf);
+
+  std::string output = capturedOutput.str();
+  // Should show how to run with --fast next time
+  EXPECT_TRUE(output.find("--fast") != std::string::npos);
+  EXPECT_TRUE(output.find("--root_dir") != std::string::npos);
+  EXPECT_TRUE(output.find("--query_id") != std::string::npos);
+}
+
+TEST_F(TraceReplayerConfigPromptTest, interactivePromptsKeepExistingValues) {
+  // Set up existing flag values
+  FLAGS_root_dir = "/existing/root";
+  FLAGS_query_id = "existing-query";
+  FLAGS_task_id = "existing-task";
+  FLAGS_node_id = "existing-node";
+  FLAGS_driver_ids = "1,2,3";
+  FLAGS_table_writer_output_dir = "/existing/output";
+
+  // Simulate user pressing Enter for all prompts (keep existing values)
+  setStdinInput("\n\n\n\n\n\n");
+
+  std::ostringstream capturedOutput;
+  std::streambuf* originalCoutBuf = std::cout.rdbuf(capturedOutput.rdbuf());
+
+  FLAGS_fast = false;
+  TraceReplayerConfigPrompt prompt;
+  prompt.run();
+
+  std::cout.rdbuf(originalCoutBuf);
+
+  // All flags should remain unchanged
+  EXPECT_EQ(FLAGS_root_dir, "/existing/root");
+  EXPECT_EQ(FLAGS_query_id, "existing-query");
+  EXPECT_EQ(FLAGS_task_id, "existing-task");
+  EXPECT_EQ(FLAGS_node_id, "existing-node");
+  EXPECT_EQ(FLAGS_driver_ids, "1,2,3");
+  EXPECT_EQ(FLAGS_table_writer_output_dir, "/existing/output");
+}
+
+TEST_F(TraceReplayerConfigPromptTest, interactivePromptsPartialOverride) {
+  // Set up existing flag values
+  FLAGS_root_dir = "/existing/root";
+  FLAGS_query_id = "existing-query";
+  FLAGS_task_id = "";
+  FLAGS_node_id = "existing-node";
+
+  // Simulate: keep root_dir, keep query_id, enter new task_id, keep node_id,
+  // etc.
+  setStdinInput(
+      "\n" // keep root_dir
+      "\n" // keep query_id
+      "new-task-id\n" // override task_id
+      "\n" // keep node_id
+      "\n" // keep driver_ids
+      "\n"); // keep table_writer_output_dir
+
+  std::ostringstream capturedOutput;
+  std::streambuf* originalCoutBuf = std::cout.rdbuf(capturedOutput.rdbuf());
+
+  FLAGS_fast = false;
+  TraceReplayerConfigPrompt prompt;
+  prompt.run();
+
+  std::cout.rdbuf(originalCoutBuf);
+
+  EXPECT_EQ(FLAGS_root_dir, "/existing/root");
+  EXPECT_EQ(FLAGS_query_id, "existing-query");
+  EXPECT_EQ(FLAGS_task_id, "new-task-id");
+  EXPECT_EQ(FLAGS_node_id, "existing-node");
+}
+
+} // namespace
+} // namespace facebook::velox::tool::trace::test
diff --git a/velox/tool/trace/tests/UnnestReplayerTest.cpp b/velox/tool/trace/tests/UnnestReplayerTest.cpp
index 0686693a1cc..0a32d0c3425 100644
--- a/velox/tool/trace/tests/UnnestReplayerTest.cpp
+++ b/velox/tool/trace/tests/UnnestReplayerTest.cpp
@@ -19,13 +19,13 @@
 #include <string>
 
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/exec/PartitionFunction.h"
-#include "velox/exec/TraceUtil.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/exec/trace/TraceUtil.h"
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/tool/trace/UnnestReplayer.h"
 
@@ -35,6 +35,7 @@ using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
 using namespace facebook::velox::connector;
 using namespace facebook::velox::connector::hive;
+using namespace facebook::velox::common::testutil;
 
 namespace facebook::velox::tool::trace::test {
 class UnnestReplayerTest : public HiveConnectorTestBase {
diff --git a/velox/tpcds/gen/CMakeLists.txt b/velox/tpcds/gen/CMakeLists.txt
index e08e9ca0ca4..4e5d40aa864 100644
--- a/velox/tpcds/gen/CMakeLists.txt
+++ b/velox/tpcds/gen/CMakeLists.txt
@@ -16,7 +16,14 @@
 add_subdirectory(utils)
 add_subdirectory(dsdgen)
 
-velox_add_library(velox_tpcds_gen TpcdsGen.cpp DSDGenIterator.cpp)
+velox_add_library(
+  velox_tpcds_gen
+  TpcdsGen.cpp
+  DSDGenIterator.cpp
+  HEADERS
+  DSDGenIterator.h
+  TpcdsGen.h
+)
 velox_include_directories(
   velox_tpcds_gen
   PUBLIC "$<BUILD_LOCAL_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/dsdgen/include>"
diff --git a/velox/tpcds/gen/TpcdsGen.cpp b/velox/tpcds/gen/TpcdsGen.cpp
index 6dc4979a122..feca666d22e 100644
--- a/velox/tpcds/gen/TpcdsGen.cpp
+++ b/velox/tpcds/gen/TpcdsGen.cpp
@@ -27,8 +27,8 @@ namespace {
 // parent tables (TBL_CATALOG_SALES, TBL_STORE_SALES, or TBL_WEB_SALES) is 16.
 static constexpr vector_size_t kMaxParentTableRows = 16;
 
-std::unordered_map<std::string, Table> tpcdsTableMap() {
-  static const std::unordered_map<std::string, Table> map{
+std::unordered_map<std::string_view, Table> tpcdsTableMap() {
+  static const std::unordered_map<std::string_view, Table> map{
       {"call_center", Table::TBL_CALL_CENTER},
       {"catalog_page", Table::TBL_CATALOG_PAGE},
       {"catalog_returns", Table::TBL_CATALOG_RETURNS},
@@ -57,8 +57,8 @@ std::unordered_map<std::string, Table> tpcdsTableMap() {
   return map;
 }
 
-std::unordered_map<Table, std::string> invertTpcdsTableMap() {
-  std::unordered_map<Table, std::string> inverted;
+std::unordered_map<Table, std::string_view> invertTpcdsTableMap() {
+  std::unordered_map<Table, std::string_view> inverted;
   for (const auto& [key, value] : tpcdsTableMap()) {
     inverted.emplace(value, key);
   }
@@ -821,7 +821,7 @@ const RowTypePtr getTableSchema(Table table) {
   }
 }
 
-std::string toTableName(Table table) {
+std::string_view toTableName(Table table) {
   auto inverted = invertTpcdsTableMap();
   auto it = inverted.find(table);
   if (it != inverted.end()) {
@@ -830,7 +830,7 @@ std::string toTableName(Table table) {
   VELOX_UNREACHABLE("Invalid TPC-DS table: {}", static_cast<uint8_t>(table));
 }
 
-Table fromTableName(const std::string& tableName) {
+Table fromTableName(std::string_view tableName) {
   auto map = tpcdsTableMap();
   auto it = map.find(tableName);
   if (it != map.end()) {
diff --git a/velox/tpcds/gen/TpcdsGen.h b/velox/tpcds/gen/TpcdsGen.h
index 37b3f6d8266..028100623ed 100644
--- a/velox/tpcds/gen/TpcdsGen.h
+++ b/velox/tpcds/gen/TpcdsGen.h
@@ -85,12 +85,13 @@ static const auto tables = {
     tpcds::Table::TBL_WEB_SITE};
 
 /// Returns table name as a string.
-std::string toTableName(Table table);
+std::string_view toTableName(Table table);
 
 /// Returns the schema (RowType) for a particular TPC-DS table.
 const velox::RowTypePtr getTableSchema(Table table);
 
-Table fromTableName(const std::string_view& tableName);
+/// Returns TPC-DS table enum corresponding to name.
+Table fromTableName(std::string_view tableName);
 
 /// Returns a row vector containing at most `maxRows` rows of the `table`,
 /// starting at `offset`, with the given `scaleFactor`. DSDGen allows data
diff --git a/velox/tpcds/gen/dsdgen/StringBuffer.cpp b/velox/tpcds/gen/dsdgen/StringBuffer.cpp
index a198a230d15..14a37d26e88 100644
--- a/velox/tpcds/gen/dsdgen/StringBuffer.cpp
+++ b/velox/tpcds/gen/dsdgen/StringBuffer.cpp
@@ -26,12 +26,12 @@
 
 #include <assert.h>
 #include <stdio.h>
-#include "config.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 #ifndef USE_STDLIB_H
 #include <malloc.h>
 #endif
-#include "StringBuffer.h"
+#include "velox/tpcds/gen/dsdgen/include/StringBuffer.h"
 
 /*
  * Routine: AddBuffer
diff --git a/velox/tpcds/gen/dsdgen/address.cpp b/velox/tpcds/gen/dsdgen/address.cpp
index f9729cc56e0..adfff67b62d 100644
--- a/velox/tpcds/gen/dsdgen/address.cpp
+++ b/velox/tpcds/gen/dsdgen/address.cpp
@@ -24,18 +24,18 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "address.h"
+#include "velox/tpcds/gen/dsdgen/include/address.h"
 #include <stdio.h>
-#include "columns.h"
-#include "config.h"
-#include "dist.h"
-#include "genrand.h"
-#include "permute.h"
-#include "porting.h"
-#include "r_params.h"
-#include "scaling.h"
-#include "tables.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/permute.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 static int s_nCountyCount = 0;
 static int s_nCityCount = 0;
diff --git a/velox/tpcds/gen/dsdgen/build_support.cpp b/velox/tpcds/gen/dsdgen/build_support.cpp
index 782c4f50b6d..62cf1210e57 100644
--- a/velox/tpcds/gen/dsdgen/build_support.cpp
+++ b/velox/tpcds/gen/dsdgen/build_support.cpp
@@ -25,24 +25,24 @@
  */
 
 #include <stdio.h>
-#include "config.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 #ifndef WIN32
 #include <netinet/in.h>
 #endif
 #include <math.h>
-#include "StringBuffer.h"
-#include "build_support.h"
-#include "columns.h"
-#include "constants.h"
-#include "decimal.h"
-#include "dist.h"
-#include "error_msg.h"
-#include "genrand.h"
-#include "r_params.h"
-#include "scaling.h"
-#include "tables.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/StringBuffer.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/error_msg.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 /*
  * Routine: hierarchy_item
diff --git a/velox/tpcds/gen/dsdgen/date.cpp b/velox/tpcds/gen/dsdgen/date.cpp
index 10002b35a69..301812499fe 100644
--- a/velox/tpcds/gen/dsdgen/date.cpp
+++ b/velox/tpcds/gen/dsdgen/date.cpp
@@ -25,16 +25,16 @@
  */
 
 #include <stdlib.h>
-#include "config.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 #ifndef USE_STDLIB_H
 #include <malloc.h>
 #endif
 #include <math.h>
 #include <stdio.h>
-#include "date.h"
-#include "dist.h"
-#include "mathops.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/mathops.h"
 
 #define D_CHARS "ymdYMD24" /* valid characters in a DBGDATE setting */
 #define MIN_DATE_INT 18000101
diff --git a/velox/tpcds/gen/dsdgen/dbgen_version.cpp b/velox/tpcds/gen/dsdgen/dbgen_version.cpp
index 3addeafd48c..549693cda30 100644
--- a/velox/tpcds/gen/dsdgen/dbgen_version.cpp
+++ b/velox/tpcds/gen/dsdgen/dbgen_version.cpp
@@ -24,16 +24,16 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "dbgen_version.h"
+#include "velox/tpcds/gen/dsdgen/include/dbgen_version.h"
 #include <stdio.h>
 #include <time.h>
-#include "build_support.h"
-#include "columns.h"
-#include "config.h"
-#include "dist.h"
-#include "misc.h"
-#include "porting.h"
-#include "tables.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
 
 /*
  * Routine:
diff --git a/velox/tpcds/gen/dsdgen/decimal.cpp b/velox/tpcds/gen/dsdgen/decimal.cpp
index 82969a948f0..b0d2987197b 100644
--- a/velox/tpcds/gen/dsdgen/decimal.cpp
+++ b/velox/tpcds/gen/dsdgen/decimal.cpp
@@ -24,15 +24,15 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "config.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 #ifndef USE_STDLIB_H
 #include <malloc.h>
 #endif
 #include <stdio.h>
-#include "decimal.h"
-#include "dist.h"
-#include "mathops.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/mathops.h"
 
 /*
  * Routine: itodec(int src, decimal_t *dest)
diff --git a/velox/tpcds/gen/dsdgen/dist.cpp b/velox/tpcds/gen/dsdgen/dist.cpp
index 05e45eb5af1..442ae340e5d 100644
--- a/velox/tpcds/gen/dsdgen/dist.cpp
+++ b/velox/tpcds/gen/dsdgen/dist.cpp
@@ -24,8 +24,8 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "config.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 
 #include <assert.h>
 #include <fcntl.h>
@@ -38,10 +38,10 @@
 #define OPTION_START '-'
 #endif
 #ifdef _WIN32
-#include <io.h>
+#include <io.h> // @manual
 #include <search.h>
 #include <stdlib.h>
-#include <winsock.h>
+#include <winsock.h> // @manual
 #else
 #include <netinet/in.h>
 #include <sys/stat.h>
@@ -53,15 +53,15 @@
 #ifndef USE_STDLIB_H
 #include <malloc.h>
 #endif
-#include "config.h"
-#include "date.h"
-#include "dcomp.h"
-#include "decimal.h"
-#include "dist.h"
-#include "error_msg.h"
-#include "genrand.h"
-#include "r_params.h"
-#include "tpcds_idx.hpp"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/dcomp.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/error_msg.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
+#include "velox/tpcds/gen/dsdgen/include/tpcds_idx.hpp"
 #ifdef TEST
 option_t options[] = {
     {"DISTRIBUTIONS",
@@ -84,9 +84,9 @@ struct {
 static int load_dist(d_idx_t* d);
 
 #include <stdio.h>
-#include "config.h"
-#include "porting.h"
-#include "r_params.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
 
 /*
  * Routine: release(char *param_name, char *msg)
@@ -371,7 +371,7 @@ int load_dists() {
   read_ptr = tpcds_idx + tpcds_idx_len - (entry_count * IDX_SIZE);
   for (int i = 0; i < entry_count; i++) {
     d_idx_t entry;
-    memset(&entry, 0, sizeof(const d_idx_t));
+    memset(reinterpret_cast<uint8_t*>(&entry), 0, sizeof(const d_idx_t));
     memcpy(entry.name, read_ptr, D_NAME_LEN);
     read_ptr += D_NAME_LEN;
     entry.name[D_NAME_LEN] = '\0';
diff --git a/velox/tpcds/gen/dsdgen/error_msg.cpp b/velox/tpcds/gen/dsdgen/error_msg.cpp
index bc6996ea29f..6202bf70d30 100644
--- a/velox/tpcds/gen/dsdgen/error_msg.cpp
+++ b/velox/tpcds/gen/dsdgen/error_msg.cpp
@@ -24,14 +24,14 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "error_msg.h"
+#include "velox/tpcds/gen/dsdgen/include/error_msg.h"
 #include <stdio.h>
 #include <algorithm>
 #include <cstdint>
 #include <vector>
-#include "config.h"
-#include "grammar_support.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/grammar_support.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 static int* LN;
 static char* FN;
 
diff --git a/velox/tpcds/gen/dsdgen/genrand.cpp b/velox/tpcds/gen/dsdgen/genrand.cpp
index ed8a0aa627d..ae36aece1e2 100644
--- a/velox/tpcds/gen/dsdgen/genrand.cpp
+++ b/velox/tpcds/gen/dsdgen/genrand.cpp
@@ -26,23 +26,23 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include "config.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 #ifdef WIN32
 #include <limits.h>
 #include <search.h>
 #endif
-#include "config.h"
-#include "date.h"
-#include "decimal.h"
-#include "dist.h"
-#include "genrand.h"
-#include "params.h"
-#include "porting.h"
-#include "r_params.h"
-
-#include "columns.h"
-#include "tables.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/params.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
+
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
 
 static long Mult = 16807; /* the multiplier */
 static long nQ = 127773; /* the quotient MAXINT / Mult */
diff --git a/velox/tpcds/gen/dsdgen/include/address.h b/velox/tpcds/gen/dsdgen/include/address.h
index 8a7595e67f1..40a0c02719f 100644
--- a/velox/tpcds/gen/dsdgen/include/address.h
+++ b/velox/tpcds/gen/dsdgen/include/address.h
@@ -27,8 +27,8 @@
 #ifndef DS_ADDRESS_H
 #define DS_ADDRESS_H
 
-#include "constants.h" // @manual
-#include "dist.h" // @manual
+#include "velox/tpcds/gen/dsdgen/include/constants.h" // @manual
+#include "velox/tpcds/gen/dsdgen/include/dist.h" // @manual
 
 #define DS_ADDR_SUITE_NUM 0
 #define DS_ADDR_STREET_NUM 1
diff --git a/velox/tpcds/gen/dsdgen/include/append_info.h b/velox/tpcds/gen/dsdgen/include/append_info.h
index 771152b8897..863889deb67 100644
--- a/velox/tpcds/gen/dsdgen/include/append_info.h
+++ b/velox/tpcds/gen/dsdgen/include/append_info.h
@@ -30,7 +30,7 @@
 #include <stdbool.h>
 #include <stdlib.h>
 
-#include "decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
 
 typedef void* append_info;
 
diff --git a/velox/tpcds/gen/dsdgen/include/build_support.h b/velox/tpcds/gen/dsdgen/include/build_support.h
index af83385acb9..80bf2af481e 100644
--- a/velox/tpcds/gen/dsdgen/include/build_support.h
+++ b/velox/tpcds/gen/dsdgen/include/build_support.h
@@ -27,11 +27,11 @@
 #ifndef BUILD_SUPPORT_H
 #define BUILD_SUPPORT_H
 
-#include "columns.h"
-#include "date.h"
-#include "decimal.h"
-#include "dist.h"
-#include "pricing.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/pricing.h"
 
 void bitmap_to_dist(
     void* pDest,
diff --git a/velox/tpcds/gen/dsdgen/include/date.h b/velox/tpcds/gen/dsdgen/include/date.h
index 82dd580a373..fee42cb6cbc 100644
--- a/velox/tpcds/gen/dsdgen/include/date.h
+++ b/velox/tpcds/gen/dsdgen/include/date.h
@@ -29,7 +29,7 @@
 
 #include <string>
 #include <vector>
-#include "mathops.h"
+#include "velox/tpcds/gen/dsdgen/include/mathops.h"
 
 typedef struct DATE_T {
   int flags;
diff --git a/velox/tpcds/gen/dsdgen/include/dbgen_version.h b/velox/tpcds/gen/dsdgen/include/dbgen_version.h
index df64cc0e60c..16f8d8a373f 100644
--- a/velox/tpcds/gen/dsdgen/include/dbgen_version.h
+++ b/velox/tpcds/gen/dsdgen/include/dbgen_version.h
@@ -27,7 +27,7 @@
 #ifndef DBGEN_VERSION_H
 #define DBGEN_VERSION_H
 
-#include "dist.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
 
 int mk_dbgen_version(
     void* pDest,
diff --git a/velox/tpcds/gen/dsdgen/include/dcomp.h b/velox/tpcds/gen/dsdgen/include/dcomp.h
index 56146bae5db..d73786f597b 100644
--- a/velox/tpcds/gen/dsdgen/include/dcomp.h
+++ b/velox/tpcds/gen/dsdgen/include/dcomp.h
@@ -27,10 +27,10 @@
 #ifndef DCOMP_H
 #define DCOMP_H
 
-#include "config.h"
-#include "dist.h"
-#include "grammar.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/grammar.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 
 /*
  * query template grammar definition
diff --git a/velox/tpcds/gen/dsdgen/include/decimal.h b/velox/tpcds/gen/dsdgen/include/decimal.h
index ec53c7a8d72..9958ce07d7b 100644
--- a/velox/tpcds/gen/dsdgen/include/decimal.h
+++ b/velox/tpcds/gen/dsdgen/include/decimal.h
@@ -27,10 +27,10 @@
 #ifndef R_DECIMAL_H
 #define R_DECIMAL_H
 #include <stdio.h>
-#include "config.h"
-#include "dist.h"
-#include "mathops.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/mathops.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 
 #define FL_INIT 0x0004
 
diff --git a/velox/tpcds/gen/dsdgen/include/dist.h b/velox/tpcds/gen/dsdgen/include/dist.h
index c287ccf854c..738f1927629 100644
--- a/velox/tpcds/gen/dsdgen/include/dist.h
+++ b/velox/tpcds/gen/dsdgen/include/dist.h
@@ -27,21 +27,21 @@
 #pragma once
 #include <folly/Singleton.h>
 #include <folly/Synchronized.h>
+#include <algorithm>
 #include <cstdint>
+#include <iostream>
 #include <string>
 #include <unordered_map>
-#include "algorithm"
-#include "columns.h"
-#include "config.h"
-#include "iostream"
-#include "tables.h"
-#include "vector"
+#include <vector>
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
 
 #ifndef STREAMS_H
 #define STREAMS_H
 #endif
-#include "constants.h"
-#include "tables.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
 
 #ifndef R_DIST_H
 #define R_DIST_H
@@ -1746,7 +1746,7 @@ struct DSDGenContext {
        0,
        TIME_START,
        TIME_END,
-       TIME,
+       TIMET,
        -1,
        NULL,
        0,
@@ -2651,17 +2651,17 @@ struct DSDGenContext {
       {0, 128, 0, 0, SS_PRICING, STORE_SALES, SS_PRICING, 0},
       {0, 32, 0, 0, SS_NULLS, STORE_SALES, SS_NULLS, 0},
       {0, 0, 0, 0, SS_PERMUTATION, STORE_SALES, SS_PERMUTATION, 0},
-      {0, 1, 0, 0, T_TIME_SK, TIME, T_TIME_SK, 0},
-      {0, 1, 0, 0, T_TIME_ID, TIME, T_TIME_ID, 0},
-      {0, 1, 0, 0, T_TIME, TIME, T_TIME, 0},
-      {0, 1, 0, 0, T_HOUR, TIME, T_HOUR, 0},
-      {0, 1, 0, 0, T_MINUTE, TIME, T_MINUTE, 0},
-      {0, 1, 0, 0, T_SECOND, TIME, T_SECOND, 0},
-      {0, 1, 0, 0, T_AM_PM, TIME, T_AM_PM, 0},
-      {0, 1, 0, 0, T_SHIFT, TIME, T_SHIFT, 0},
-      {0, 1, 0, 0, T_SUB_SHIFT, TIME, T_SUB_SHIFT, 0},
-      {0, 1, 0, 0, T_MEAL_TIME, TIME, T_MEAL_TIME, 0},
-      {0, 2, 0, 0, T_NULLS, TIME, T_NULLS, 0},
+      {0, 1, 0, 0, T_TIME_SK, TIMET, T_TIME_SK, 0},
+      {0, 1, 0, 0, T_TIME_ID, TIMET, T_TIME_ID, 0},
+      {0, 1, 0, 0, T_TIME, TIMET, T_TIME, 0},
+      {0, 1, 0, 0, T_HOUR, TIMET, T_HOUR, 0},
+      {0, 1, 0, 0, T_MINUTE, TIMET, T_MINUTE, 0},
+      {0, 1, 0, 0, T_SECOND, TIMET, T_SECOND, 0},
+      {0, 1, 0, 0, T_AM_PM, TIMET, T_AM_PM, 0},
+      {0, 1, 0, 0, T_SHIFT, TIMET, T_SHIFT, 0},
+      {0, 1, 0, 0, T_SUB_SHIFT, TIMET, T_SUB_SHIFT, 0},
+      {0, 1, 0, 0, T_MEAL_TIME, TIMET, T_MEAL_TIME, 0},
+      {0, 2, 0, 0, T_NULLS, TIMET, T_NULLS, 0},
       {0, 1, 0, 0, W_WAREHOUSE_SK, WAREHOUSE, W_WAREHOUSE_SK, 0},
       {0, 1, 0, 0, W_WAREHOUSE_ID, WAREHOUSE, W_WAREHOUSE_ID, 0},
       {0, 80, 0, 0, W_WAREHOUSE_NAME, WAREHOUSE, W_WAREHOUSE_NAME, 0},
diff --git a/velox/tpcds/gen/dsdgen/include/genrand.h b/velox/tpcds/gen/dsdgen/include/genrand.h
index 562cb272f7b..71ef82b7e1a 100644
--- a/velox/tpcds/gen/dsdgen/include/genrand.h
+++ b/velox/tpcds/gen/dsdgen/include/genrand.h
@@ -27,10 +27,10 @@
 #ifndef GENRAND_H
 #define GENRAND_H
 
-#include "address.h"
-#include "date.h"
-#include "decimal.h"
-#include "dist.h"
+#include "velox/tpcds/gen/dsdgen/include/address.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
 
 extern rng_t Streams[];
 
diff --git a/velox/tpcds/gen/dsdgen/include/load.h b/velox/tpcds/gen/dsdgen/include/load.h
index 59e0476e4b2..0ea190c713a 100644
--- a/velox/tpcds/gen/dsdgen/include/load.h
+++ b/velox/tpcds/gen/dsdgen/include/load.h
@@ -26,7 +26,7 @@
 
 #ifndef LOAD_H
 #define LOAD_H
-#include "tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
 void load_init(void);
 void load_close(void);
 int create_table(int nTable);
diff --git a/velox/tpcds/gen/dsdgen/include/nulls.h b/velox/tpcds/gen/dsdgen/include/nulls.h
index e3a982bafb9..4164d854e2b 100644
--- a/velox/tpcds/gen/dsdgen/include/nulls.h
+++ b/velox/tpcds/gen/dsdgen/include/nulls.h
@@ -27,7 +27,7 @@
 #ifndef R_NULLCHECK_H
 #define R_NULLCHECK_H
 
-#include "dist.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
 
 int nullCheck(int nColumn, DSDGenContext& dsdGenContext);
 void nullSet(ds_key_t* pDest, int nStream, DSDGenContext& dsdGenContext);
diff --git a/velox/tpcds/gen/dsdgen/include/params.h b/velox/tpcds/gen/dsdgen/include/params.h
index ffb8f6e50c4..7646eeffe70 100644
--- a/velox/tpcds/gen/dsdgen/include/params.h
+++ b/velox/tpcds/gen/dsdgen/include/params.h
@@ -27,8 +27,8 @@
 #ifndef QGEN_PARAMS_H
 #define QGEN_PARAMS_H
 
-#include "build_support.h"
-#include "r_params.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
 
 #ifdef DECLARER
 #else
diff --git a/velox/tpcds/gen/dsdgen/include/porting.h b/velox/tpcds/gen/dsdgen/include/porting.h
index 4c1abfacb81..af15abf176d 100644
--- a/velox/tpcds/gen/dsdgen/include/porting.h
+++ b/velox/tpcds/gen/dsdgen/include/porting.h
@@ -61,7 +61,7 @@
 #include <sys/time.h>
 #endif
 
-#include "config.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
 
 typedef HUGE_TYPE ds_key_t;
 
diff --git a/velox/tpcds/gen/dsdgen/include/pricing.h b/velox/tpcds/gen/dsdgen/include/pricing.h
index 726f7e97bae..0b9820aa1f6 100644
--- a/velox/tpcds/gen/dsdgen/include/pricing.h
+++ b/velox/tpcds/gen/dsdgen/include/pricing.h
@@ -26,7 +26,7 @@
 
 #ifndef PRICING_H
 #define PRICING_H
-#include "decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
 
 typedef struct DS_LIMITS_T {
   int nId;
diff --git a/velox/tpcds/gen/dsdgen/include/r_params.h b/velox/tpcds/gen/dsdgen/include/r_params.h
index b44bb7a1233..3bdfa40f2d5 100644
--- a/velox/tpcds/gen/dsdgen/include/r_params.h
+++ b/velox/tpcds/gen/dsdgen/include/r_params.h
@@ -24,7 +24,7 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "dist.h" // @manual
+#include "velox/tpcds/gen/dsdgen/include/dist.h" // @manual
 
 #ifndef R_PARAMS_H
 #define R_PARAMS_H
diff --git a/velox/tpcds/gen/dsdgen/include/scaling.h b/velox/tpcds/gen/dsdgen/include/scaling.h
index 699f21bee2d..f48568b32a5 100644
--- a/velox/tpcds/gen/dsdgen/include/scaling.h
+++ b/velox/tpcds/gen/dsdgen/include/scaling.h
@@ -24,7 +24,7 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "dist.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
 
 #ifndef SCALING_H
 #define SCALING_H
diff --git a/velox/tpcds/gen/dsdgen/include/scd.h b/velox/tpcds/gen/dsdgen/include/scd.h
index 8759ac11e21..b65f3621a49 100644
--- a/velox/tpcds/gen/dsdgen/include/scd.h
+++ b/velox/tpcds/gen/dsdgen/include/scd.h
@@ -27,8 +27,8 @@
 #ifndef SCD_H
 #define SCD_H
 
-#include "decimal.h"
-#include "tables.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
 
 extern char arBKeys[MAX_TABLE][17];
 int setSCDKeys(
diff --git a/velox/tpcds/gen/dsdgen/include/skip_days.h b/velox/tpcds/gen/dsdgen/include/skip_days.h
index dc3a116be8e..0b516c76d82 100644
--- a/velox/tpcds/gen/dsdgen/include/skip_days.h
+++ b/velox/tpcds/gen/dsdgen/include/skip_days.h
@@ -27,9 +27,9 @@
 #ifndef R_SKIP_DAYS_H
 #define R_SKIP_DAYS_H
 
-#include "config.h"
-#include "dist.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 
 ds_key_t
 skipDays(int nTable, ds_key_t* pRemainder, DSDGenContext& dsdGenContext);
diff --git a/velox/tpcds/gen/dsdgen/include/sparse.h b/velox/tpcds/gen/dsdgen/include/sparse.h
index 95f3e1df1b8..7ff2aa2b7ae 100644
--- a/velox/tpcds/gen/dsdgen/include/sparse.h
+++ b/velox/tpcds/gen/dsdgen/include/sparse.h
@@ -24,7 +24,7 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "dist.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
 
 int initSparseKeys(
     int nTable,
diff --git a/velox/tpcds/gen/dsdgen/include/tables.h b/velox/tpcds/gen/dsdgen/include/tables.h
index 75a8b6e4977..610087469d8 100644
--- a/velox/tpcds/gen/dsdgen/include/tables.h
+++ b/velox/tpcds/gen/dsdgen/include/tables.h
@@ -48,7 +48,7 @@
 #define STORE 15
 #define STORE_RETURNS 16
 #define STORE_SALES 17
-#define TIME 18
+#define TIMET 18
 #define WAREHOUSE 19
 #define WEB_PAGE 20
 #define WEB_RETURNS 21
diff --git a/velox/tpcds/gen/dsdgen/include/tdef_functions.h b/velox/tpcds/gen/dsdgen/include/tdef_functions.h
index 548f4e398a5..6fc7d393b60 100644
--- a/velox/tpcds/gen/dsdgen/include/tdef_functions.h
+++ b/velox/tpcds/gen/dsdgen/include/tdef_functions.h
@@ -26,8 +26,8 @@
 
 #ifndef TDEF_FUNCTIONS_H
 #define TDEF_FUNCTIONS_H
-#include "dist.h"
-#include "tables.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
 
 /*
 * table functions.
diff --git a/velox/tpcds/gen/dsdgen/include/tdefs.h b/velox/tpcds/gen/dsdgen/include/tdefs.h
index bed965e850f..dd105b79a02 100644
--- a/velox/tpcds/gen/dsdgen/include/tdefs.h
+++ b/velox/tpcds/gen/dsdgen/include/tdefs.h
@@ -28,10 +28,10 @@
 #define TDEFS_H
 
 #include <stdio.h>
-#include "columns.h"
-#include "dist.h"
-#include "tables.h"
-#include "tdef_functions.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdef_functions.h"
 
 #define tdefIsFlagSet(t, f) (tdefs[t].flags & f)
 ds_key_t GetRowcountByName(char* szName, DSDGenContext& dsdGenContext);
diff --git a/velox/tpcds/gen/dsdgen/include/template.h b/velox/tpcds/gen/dsdgen/include/template.h
index 164b33b342d..4ad5dec4b08 100644
--- a/velox/tpcds/gen/dsdgen/include/template.h
+++ b/velox/tpcds/gen/dsdgen/include/template.h
@@ -26,10 +26,10 @@
 
 #ifndef TEMPLATE_H
 #define TEMPLATE_H
-#include "StringBuffer.h"
-#include "expr.h" // @manual
-#include "list.h" // @manual
-#include "substitution.h" // @manual
+#include "velox/tpcds/gen/dsdgen/include/StringBuffer.h"
+#include "velox/tpcds/gen/dsdgen/include/expr.h" // @manual
+#include "velox/tpcds/gen/dsdgen/include/list.h" // @manual
+#include "velox/tpcds/gen/dsdgen/include/substitution.h" // @manual
 
 /*  Replacement flags */
 #define REPL_FL_NONE 0x0001 /*  no effect on result set size */
diff --git a/velox/tpcds/gen/dsdgen/include/w_call_center.h b/velox/tpcds/gen/dsdgen/include/w_call_center.h
index 58a9ce236fa..70eb393609a 100644
--- a/velox/tpcds/gen/dsdgen/include/w_call_center.h
+++ b/velox/tpcds/gen/dsdgen/include/w_call_center.h
@@ -26,12 +26,12 @@
 
 #ifndef W_CALL_CENTER_H
 #define W_CALL_CENTER_H
-#include "address.h"
-#include "constants.h"
-#include "date.h"
-#include "decimal.h"
-#include "dist.h"
-#include "pricing.h"
+#include "velox/tpcds/gen/dsdgen/include/address.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/pricing.h"
 
 #define MIN_CC_TAX_PERCENTAGE "0.00"
 #define MAX_CC_TAX_PERCENTAGE "0.12"
diff --git a/velox/tpcds/gen/dsdgen/include/w_catalog_page.h b/velox/tpcds/gen/dsdgen/include/w_catalog_page.h
index 99c07e15e31..1157d978f60 100644
--- a/velox/tpcds/gen/dsdgen/include/w_catalog_page.h
+++ b/velox/tpcds/gen/dsdgen/include/w_catalog_page.h
@@ -27,9 +27,9 @@
 #ifndef CATALOG_PAGE_H
 #define CATALOG_PAGE_H
 
-#include "constants.h"
-#include "dist.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 
 int mk_w_catalog_page(
     void* info_arr,
diff --git a/velox/tpcds/gen/dsdgen/include/w_catalog_returns.h b/velox/tpcds/gen/dsdgen/include/w_catalog_returns.h
index 13b6b1caf67..aa75a8dbefd 100644
--- a/velox/tpcds/gen/dsdgen/include/w_catalog_returns.h
+++ b/velox/tpcds/gen/dsdgen/include/w_catalog_returns.h
@@ -27,8 +27,8 @@
 #ifndef W_CATALOG_RETURNS_H
 #define W_CATALOG_RETURNS_H
 
-#include "dist.h"
-#include "pricing.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/pricing.h"
 
 int mk_w_catalog_returns(
     void* row,
diff --git a/velox/tpcds/gen/dsdgen/include/w_catalog_sales.h b/velox/tpcds/gen/dsdgen/include/w_catalog_sales.h
index 5c70a691984..dce335d5cd0 100644
--- a/velox/tpcds/gen/dsdgen/include/w_catalog_sales.h
+++ b/velox/tpcds/gen/dsdgen/include/w_catalog_sales.h
@@ -27,8 +27,8 @@
 #ifndef W_CATALOG_SALES_H
 #define W_CATALOG_SALES_H
 
-#include "dist.h"
-#include "pricing.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/pricing.h"
 
 int mk_w_catalog_sales(
     void* info_arr,
diff --git a/velox/tpcds/gen/dsdgen/include/w_customer.h b/velox/tpcds/gen/dsdgen/include/w_customer.h
index 9b97f8d3d16..252f34fffe5 100644
--- a/velox/tpcds/gen/dsdgen/include/w_customer.h
+++ b/velox/tpcds/gen/dsdgen/include/w_customer.h
@@ -27,9 +27,9 @@
 #ifndef W_CUSTOMER_H
 #define W_CUSTOMER_H
 
-#include "constants.h"
-#include "dist.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 
 int mk_w_customer(
     void* info_arr,
diff --git a/velox/tpcds/gen/dsdgen/include/w_customer_address.h b/velox/tpcds/gen/dsdgen/include/w_customer_address.h
index 38802200966..81c14affe7f 100644
--- a/velox/tpcds/gen/dsdgen/include/w_customer_address.h
+++ b/velox/tpcds/gen/dsdgen/include/w_customer_address.h
@@ -26,10 +26,10 @@
 
 #ifndef W_CUSTOMER_ADDRESS_H
 #define W_CUSTOMER_ADDRESS_H
-#include "address.h"
-#include "constants.h"
-#include "dist.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/address.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 
 int mk_w_customer_address(
     void* info_arr,
diff --git a/velox/tpcds/gen/dsdgen/include/w_customer_demographics.h b/velox/tpcds/gen/dsdgen/include/w_customer_demographics.h
index dda132cac9b..e5db58c6b5f 100644
--- a/velox/tpcds/gen/dsdgen/include/w_customer_demographics.h
+++ b/velox/tpcds/gen/dsdgen/include/w_customer_demographics.h
@@ -27,8 +27,8 @@
 #ifndef W_CUSTOMER_DEMOGRAPHICS_H
 #define W_CUSTOMER_DEMOGRAPHICS_H
 
-#include "dist.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 
 /***
 *** CD_xxx Customer Demographcis Defines
diff --git a/velox/tpcds/gen/dsdgen/include/w_datetbl.h b/velox/tpcds/gen/dsdgen/include/w_datetbl.h
index 10566b387cb..fcdad6159db 100644
--- a/velox/tpcds/gen/dsdgen/include/w_datetbl.h
+++ b/velox/tpcds/gen/dsdgen/include/w_datetbl.h
@@ -29,9 +29,9 @@
 #ifndef W_DATETBL_H
 #define W_DATETBL_H
 
-#include "constants.h" // @manual
-#include "dist.h" // @manual
-#include "porting.h" // @manual
+#include "velox/tpcds/gen/dsdgen/include/constants.h" // @manual
+#include "velox/tpcds/gen/dsdgen/include/dist.h" // @manual
+#include "velox/tpcds/gen/dsdgen/include/porting.h" // @manual
 
 int mk_w_date(void* info_arr, ds_key_t kIndex, DSDGenContext& dsdGenContext);
 
diff --git a/velox/tpcds/gen/dsdgen/include/w_household_demographics.h b/velox/tpcds/gen/dsdgen/include/w_household_demographics.h
index 12d83102747..e3b2ef026a6 100644
--- a/velox/tpcds/gen/dsdgen/include/w_household_demographics.h
+++ b/velox/tpcds/gen/dsdgen/include/w_household_demographics.h
@@ -27,8 +27,8 @@
 #ifndef W_HOUSEHOLD_DEMOGRAPHICS_H
 #define W_HOUSEHOLD_DEMOGRAPHICS_H
 
-#include "dist.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 
 int mk_w_household_demographics(
     void* info_arr,
diff --git a/velox/tpcds/gen/dsdgen/include/w_income_band.h b/velox/tpcds/gen/dsdgen/include/w_income_band.h
index 00572c4a64d..9856cbc85d1 100644
--- a/velox/tpcds/gen/dsdgen/include/w_income_band.h
+++ b/velox/tpcds/gen/dsdgen/include/w_income_band.h
@@ -24,8 +24,8 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "dist.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 
 int mk_w_income_band(
     void* info_arr,
diff --git a/velox/tpcds/gen/dsdgen/include/w_inventory.h b/velox/tpcds/gen/dsdgen/include/w_inventory.h
index fc7293efc12..705b1978fb6 100644
--- a/velox/tpcds/gen/dsdgen/include/w_inventory.h
+++ b/velox/tpcds/gen/dsdgen/include/w_inventory.h
@@ -24,8 +24,8 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "dist.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 
 int mk_w_inventory(
     void* info_arr,
diff --git a/velox/tpcds/gen/dsdgen/include/w_item.h b/velox/tpcds/gen/dsdgen/include/w_item.h
index dc4964c21a7..375cf5ee665 100644
--- a/velox/tpcds/gen/dsdgen/include/w_item.h
+++ b/velox/tpcds/gen/dsdgen/include/w_item.h
@@ -27,9 +27,9 @@
 #ifndef W_ITEM_H
 #define W_ITEM_H
 
-#include "constants.h"
-#include "decimal.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 
 #define I_PROMO_PERCENTAGE \
   20 /* percent of items that have associated promotions */
diff --git a/velox/tpcds/gen/dsdgen/include/w_promotion.h b/velox/tpcds/gen/dsdgen/include/w_promotion.h
index ebb4b284be1..f38a275f647 100644
--- a/velox/tpcds/gen/dsdgen/include/w_promotion.h
+++ b/velox/tpcds/gen/dsdgen/include/w_promotion.h
@@ -27,9 +27,9 @@
 #ifndef W_PROMOTION_H
 #define W_PROMOTION_H
 
-#include "constants.h"
-#include "decimal.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 
 int mk_w_promotion(
     void* info_arr,
diff --git a/velox/tpcds/gen/dsdgen/include/w_reason.h b/velox/tpcds/gen/dsdgen/include/w_reason.h
index 87643f1e1ed..71b2257fc6b 100644
--- a/velox/tpcds/gen/dsdgen/include/w_reason.h
+++ b/velox/tpcds/gen/dsdgen/include/w_reason.h
@@ -27,9 +27,9 @@
 #ifndef W_REASON_H
 #define W_REASON_H
 
-#include "constants.h"
-#include "dist.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 
 int mk_w_reason(void* info_arr, ds_key_t kIndex, DSDGenContext& dsdGenContext);
 
diff --git a/velox/tpcds/gen/dsdgen/include/w_ship_mode.h b/velox/tpcds/gen/dsdgen/include/w_ship_mode.h
index 33b210a859a..6c118e7b1cd 100644
--- a/velox/tpcds/gen/dsdgen/include/w_ship_mode.h
+++ b/velox/tpcds/gen/dsdgen/include/w_ship_mode.h
@@ -27,9 +27,9 @@
 #ifndef W_SHIP_MODE_H
 #define W_SHIP_MODE_H
 
-#include "constants.h"
-#include "dist.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 
 int mk_w_ship_mode(
     void* info_arr,
diff --git a/velox/tpcds/gen/dsdgen/include/w_store.h b/velox/tpcds/gen/dsdgen/include/w_store.h
index b8b5b6af381..3c445ef5715 100644
--- a/velox/tpcds/gen/dsdgen/include/w_store.h
+++ b/velox/tpcds/gen/dsdgen/include/w_store.h
@@ -27,8 +27,8 @@
 #ifndef W_STORE_H
 #define W_STORE_H
 
-#include "address.h"
-#include "decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/address.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
 
 int mk_w_store(void* info_arr, ds_key_t kIndex, DSDGenContext& dsdGenContext);
 
diff --git a/velox/tpcds/gen/dsdgen/include/w_store_returns.h b/velox/tpcds/gen/dsdgen/include/w_store_returns.h
index 1e97c02fa5f..6047b97e2fe 100644
--- a/velox/tpcds/gen/dsdgen/include/w_store_returns.h
+++ b/velox/tpcds/gen/dsdgen/include/w_store_returns.h
@@ -26,8 +26,8 @@
 
 #ifndef W_STORE_RETURNS_H
 #define W_STORE_RETURNS_H
-#include "decimal.h"
-#include "pricing.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/pricing.h"
 
 #define SR_SAME_CUSTOMER 80
 
diff --git a/velox/tpcds/gen/dsdgen/include/w_store_sales.h b/velox/tpcds/gen/dsdgen/include/w_store_sales.h
index dfa5cee7e9d..5affc56f4c7 100644
--- a/velox/tpcds/gen/dsdgen/include/w_store_sales.h
+++ b/velox/tpcds/gen/dsdgen/include/w_store_sales.h
@@ -27,8 +27,8 @@
 #ifndef W_STORE_SALES_H
 #define W_STORE_SALES_H
 
-#include "constants.h"
-#include "pricing.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/pricing.h"
 
 int mk_w_store_sales(
     void* info_arr,
diff --git a/velox/tpcds/gen/dsdgen/include/w_timetbl.h b/velox/tpcds/gen/dsdgen/include/w_timetbl.h
index f87e1b50757..685c76e2160 100644
--- a/velox/tpcds/gen/dsdgen/include/w_timetbl.h
+++ b/velox/tpcds/gen/dsdgen/include/w_timetbl.h
@@ -30,9 +30,9 @@
 #ifndef W_TIME_TBL_H
 #define W_TIME_TBL_H
 
-#include "constants.h"
-#include "dist.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 
 int mk_w_time(void* info_arr, ds_key_t kIndex, DSDGenContext& dsdGenContext);
 
diff --git a/velox/tpcds/gen/dsdgen/include/w_warehouse.h b/velox/tpcds/gen/dsdgen/include/w_warehouse.h
index 2c5ab99a271..34dd34044cd 100644
--- a/velox/tpcds/gen/dsdgen/include/w_warehouse.h
+++ b/velox/tpcds/gen/dsdgen/include/w_warehouse.h
@@ -27,8 +27,8 @@
 #ifndef W_WAREHOUSE_H
 #define W_WAREHOUSE_H
 
-#include "address.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/address.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 
 int mk_w_warehouse(
     void* info_arr,
diff --git a/velox/tpcds/gen/dsdgen/include/w_web_page.h b/velox/tpcds/gen/dsdgen/include/w_web_page.h
index 3559df7e20a..b2da00a5789 100644
--- a/velox/tpcds/gen/dsdgen/include/w_web_page.h
+++ b/velox/tpcds/gen/dsdgen/include/w_web_page.h
@@ -24,9 +24,9 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "constants.h"
-#include "dist.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 
 int mk_w_web_page(
     void* info_arr,
diff --git a/velox/tpcds/gen/dsdgen/include/w_web_returns.h b/velox/tpcds/gen/dsdgen/include/w_web_returns.h
index ca1da4d7553..7414cea0eb4 100644
--- a/velox/tpcds/gen/dsdgen/include/w_web_returns.h
+++ b/velox/tpcds/gen/dsdgen/include/w_web_returns.h
@@ -24,8 +24,8 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "dist.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 #ifndef W_WEB_RETURNS_H
 #define W_WEB_RETURNS_H
 
diff --git a/velox/tpcds/gen/dsdgen/include/w_web_sales.h b/velox/tpcds/gen/dsdgen/include/w_web_sales.h
index 54f267feb9f..929c12323d4 100644
--- a/velox/tpcds/gen/dsdgen/include/w_web_sales.h
+++ b/velox/tpcds/gen/dsdgen/include/w_web_sales.h
@@ -24,8 +24,8 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "porting.h"
-#include "pricing.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/pricing.h"
 
 /***
 *** WS_xxx Web Sales Defines
diff --git a/velox/tpcds/gen/dsdgen/include/w_web_site.h b/velox/tpcds/gen/dsdgen/include/w_web_site.h
index b010d42059c..dba1660271a 100644
--- a/velox/tpcds/gen/dsdgen/include/w_web_site.h
+++ b/velox/tpcds/gen/dsdgen/include/w_web_site.h
@@ -27,9 +27,9 @@
 #ifndef W_WEB_SITE_H
 #define W_WEB_SITE_H
 
-#include "address.h"
-#include "constants.h"
-#include "decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/address.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
 
 #define WEB_MIN_TAX_PERCENTAGE "0.00"
 #define WEB_MAX_TAX_PERCENTAGE "0.12"
diff --git a/velox/tpcds/gen/dsdgen/join.cpp b/velox/tpcds/gen/dsdgen/join.cpp
index 667f796eaeb..de2e8d58088 100644
--- a/velox/tpcds/gen/dsdgen/join.cpp
+++ b/velox/tpcds/gen/dsdgen/join.cpp
@@ -25,24 +25,24 @@
  */
 
 #include <stdio.h>
-#include "build_support.h"
-#include "columns.h"
-#include "config.h"
-#include "constants.h"
-#include "date.h"
-#include "decimal.h"
-#include "dist.h"
-#include "error_msg.h"
-#include "genrand.h"
-#include "porting.h"
-#include "r_params.h"
-#include "scaling.h"
-#include "scd.h"
-#include "sparse.h"
-#include "tables.h"
-#include "tdefs.h"
-#include "tpcds.idx.h"
-#include "w_web_sales.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/error_msg.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/scd.h"
+#include "velox/tpcds/gen/dsdgen/include/sparse.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/tpcds.idx.h"
+#include "velox/tpcds/gen/dsdgen/include/w_web_sales.h"
 
 ds_key_t web_join(int col, ds_key_t join_key, DSDGenContext& dsdGenContext);
 
@@ -106,7 +106,6 @@ static ds_key_t date_join(
       genrand_integer(
           &nTemp, DIST_UNIFORM, nMin * 2, nMax * 2, 0, from_col, dsdGenContext);
       return (join_count + nTemp);
-      break;
     case WEB_SITE:
     case WEB_PAGE:
       return (web_join(from_col, join_count, dsdGenContext));
@@ -441,7 +440,7 @@ ds_key_t mk_join(
           dsdGenContext);
       return (
           date_join(nFromTable, from_col, join_count, nYear, dsdGenContext));
-    case TIME:
+    case TIMET:
       return (time_join(nFromTable, from_col, join_count, dsdGenContext));
       /* the rest of the tables use standard, uniform joins */
     default:
diff --git a/velox/tpcds/gen/dsdgen/list.cpp b/velox/tpcds/gen/dsdgen/list.cpp
index 5fa294f6c2b..cd1e9d5733c 100644
--- a/velox/tpcds/gen/dsdgen/list.cpp
+++ b/velox/tpcds/gen/dsdgen/list.cpp
@@ -24,13 +24,13 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "list.h"
+#include "velox/tpcds/gen/dsdgen/include/list.h"
 #include <assert.h>
 #include <stdio.h>
 #include <cstdint>
-#include "config.h"
-#include "error_msg.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/error_msg.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 
 /*
  * Routine:
diff --git a/velox/tpcds/gen/dsdgen/load.cpp b/velox/tpcds/gen/dsdgen/load.cpp
index 6d115a55567..3d6d35ce094 100644
--- a/velox/tpcds/gen/dsdgen/load.cpp
+++ b/velox/tpcds/gen/dsdgen/load.cpp
@@ -24,9 +24,9 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "config.h"
-#include "porting.h"
-#include "tables.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
 
 #ifdef SQLSERVER
 // ODBC headers
diff --git a/velox/tpcds/gen/dsdgen/misc.cpp b/velox/tpcds/gen/dsdgen/misc.cpp
index 8e9189df571..f71074a33ff 100644
--- a/velox/tpcds/gen/dsdgen/misc.cpp
+++ b/velox/tpcds/gen/dsdgen/misc.cpp
@@ -30,24 +30,24 @@
 #include <stdio.h>
 #include <time.h>
 #include <cstdint>
-#include "config.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 #ifndef USE_STDLIB_H
 #include <malloc.h>
 #endif
 #include <fcntl.h>
 #ifdef AIX
-#include <sys/mode.h>
+#include <sys/mode.h> // @manual
 #endif /* AIX */
 #include <sys/stat.h>
 #include <sys/types.h>
-#include "date.h"
-#include "decimal.h"
-#include "dist.h"
-#include "genrand.h"
-#include "misc.h"
-#include "r_params.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 static const char* alpha_num =
     "0123456789abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ,";
diff --git a/velox/tpcds/gen/dsdgen/nulls.cpp b/velox/tpcds/gen/dsdgen/nulls.cpp
index afdac3b747f..63afde4a1d1 100644
--- a/velox/tpcds/gen/dsdgen/nulls.cpp
+++ b/velox/tpcds/gen/dsdgen/nulls.cpp
@@ -24,11 +24,11 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "nulls.h"
-#include "config.h"
-#include "genrand.h"
-#include "porting.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 /*
  * Routine: nullCheck(int nColumn, DSDGenContext& dsdGenContext)
diff --git a/velox/tpcds/gen/dsdgen/parallel.cpp b/velox/tpcds/gen/dsdgen/parallel.cpp
index 87f4957a355..c576fb95c72 100644
--- a/velox/tpcds/gen/dsdgen/parallel.cpp
+++ b/velox/tpcds/gen/dsdgen/parallel.cpp
@@ -25,12 +25,12 @@
  */
 
 #include <stdio.h>
-#include "config.h"
-#include "genrand.h"
-#include "porting.h"
-#include "r_params.h"
-#include "scaling.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 /*
  * Routine: split_work(int tnum, worker_t *w)
diff --git a/velox/tpcds/gen/dsdgen/permute.cpp b/velox/tpcds/gen/dsdgen/permute.cpp
index 54066adf89d..9dfa7c52cab 100644
--- a/velox/tpcds/gen/dsdgen/permute.cpp
+++ b/velox/tpcds/gen/dsdgen/permute.cpp
@@ -24,13 +24,13 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "config.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 #ifndef USE_STDLIB_H
 #include <malloc.h>
 #endif
 #include <stdio.h>
-#include "genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
 
 /*
  * Routine: MakePermutation(int nSize)
diff --git a/velox/tpcds/gen/dsdgen/pricing.cpp b/velox/tpcds/gen/dsdgen/pricing.cpp
index 37263360768..73d9967a554 100644
--- a/velox/tpcds/gen/dsdgen/pricing.cpp
+++ b/velox/tpcds/gen/dsdgen/pricing.cpp
@@ -24,17 +24,17 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "pricing.h"
+#include "velox/tpcds/gen/dsdgen/include/pricing.h"
 #include <stdio.h>
-#include "columns.h"
-#include "config.h"
-#include "constants.h"
-#include "decimal.h"
-#include "dist.h"
-#include "error_msg.h"
-#include "genrand.h"
-#include "porting.h"
-#include "w_web_sales.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/error_msg.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/w_web_sales.h"
 
 #define MAX_LIMIT 12
 static const ds_limits_t aPriceLimits[MAX_LIMIT] = {
diff --git a/velox/tpcds/gen/dsdgen/r_params.cpp b/velox/tpcds/gen/dsdgen/r_params.cpp
index 245cd52a257..af80ecbb9a0 100644
--- a/velox/tpcds/gen/dsdgen/r_params.cpp
+++ b/velox/tpcds/gen/dsdgen/r_params.cpp
@@ -27,16 +27,16 @@
 /*
  * parameter handling functions
  */
-#include "r_params.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
 #include <cassert>
 #include <cstdint>
-#include "config.h"
-#include "dist.h"
-#include "porting.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 #define PARAM_MAX_LEN 80
 #define MAX_LINE_LEN 120
diff --git a/velox/tpcds/gen/dsdgen/scaling.cpp b/velox/tpcds/gen/dsdgen/scaling.cpp
index f77d37c2080..3992128e35d 100644
--- a/velox/tpcds/gen/dsdgen/scaling.cpp
+++ b/velox/tpcds/gen/dsdgen/scaling.cpp
@@ -24,24 +24,24 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
 #include <assert.h>
 #include <stdio.h>
 #include <cmath>
-#include "columns.h"
-#include "config.h"
-#include "constants.h"
-#include "dist.h"
-#include "error_msg.h"
-#include "genrand.h"
-#include "parallel.h"
-#include "porting.h"
-#include "r_params.h"
-#include "scd.h"
-#include "tdef_functions.h"
-#include "tdefs.h"
-#include "tpcds.idx.h"
-#include "w_inventory.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/error_msg.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
+#include "velox/tpcds/gen/dsdgen/include/scd.h"
+#include "velox/tpcds/gen/dsdgen/include/tdef_functions.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/tpcds.idx.h"
+#include "velox/tpcds/gen/dsdgen/include/w_inventory.h"
 
 void setUpdateScaling(int table, DSDGenContext& dsdGenContext);
 int row_skip(int tbl, ds_key_t count, DSDGenContext& dsdGenContext);
@@ -217,7 +217,8 @@ ds_key_t getIDCount(int nTable, DSDGenContext& dsdGenContext) {
  */
 ds_key_t get_rowcount(int table, DSDGenContext& dsdGenContext) {
   static double nScale;
-  int nTable, nMultiplier, i, nBadScale = 0, nRowcountOffset = 0;
+  int nTable, nMultiplier, i, nRowcountOffset = 0;
+  // int nBadScale = 0;
   tdef* pTdef;
 
   if (!dsdGenContext.get_rowcount_init) {
@@ -270,7 +271,7 @@ ds_key_t get_rowcount(int table, DSDGenContext& dsdGenContext) {
               dsdGenContext);
           break;
         case 300:
-          nBadScale = QERR_BAD_SCALE;
+          // nBadScale = QERR_BAD_SCALE;
           dsdGenContext.arRowcount[nTable].kBaseRowcount = dist_weight(
               NULL,
               "rowcounts",
@@ -279,7 +280,7 @@ ds_key_t get_rowcount(int table, DSDGenContext& dsdGenContext) {
               dsdGenContext);
           break;
         case 100:
-          nBadScale = QERR_BAD_SCALE;
+          // nBadScale = QERR_BAD_SCALE;
           dsdGenContext.arRowcount[nTable].kBaseRowcount = dist_weight(
               NULL,
               "rowcounts",
@@ -288,7 +289,7 @@ ds_key_t get_rowcount(int table, DSDGenContext& dsdGenContext) {
               dsdGenContext);
           break;
         case 10:
-          nBadScale = QERR_BAD_SCALE;
+          // nBadScale = QERR_BAD_SCALE;
           dsdGenContext.arRowcount[nTable].kBaseRowcount = dist_weight(
               NULL,
               "rowcounts",
@@ -297,7 +298,7 @@ ds_key_t get_rowcount(int table, DSDGenContext& dsdGenContext) {
               dsdGenContext);
           break;
         case 1:
-          nBadScale = QERR_QUALIFICATION_SCALE;
+          // nBadScale = QERR_QUALIFICATION_SCALE;
           dsdGenContext.arRowcount[nTable].kBaseRowcount = dist_weight(
               NULL,
               "rowcounts",
@@ -306,7 +307,7 @@ ds_key_t get_rowcount(int table, DSDGenContext& dsdGenContext) {
               dsdGenContext);
           break;
         default:
-          nBadScale = QERR_BAD_SCALE;
+          // nBadScale = QERR_BAD_SCALE;
           int mem =
               dist_member(NULL, "rowcounts", nTable + 1, 3, dsdGenContext);
           switch (mem) {
diff --git a/velox/tpcds/gen/dsdgen/scd.cpp b/velox/tpcds/gen/dsdgen/scd.cpp
index 55d10897e75..81d32c85b9e 100644
--- a/velox/tpcds/gen/dsdgen/scd.cpp
+++ b/velox/tpcds/gen/dsdgen/scd.cpp
@@ -24,21 +24,21 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "scd.h"
+#include "velox/tpcds/gen/dsdgen/include/scd.h"
 #include <stdio.h>
-#include "build_support.h"
-#include "config.h"
-#include "constants.h"
-#include "dist.h"
-#include "genrand.h"
-#include "parallel.h"
-#include "params.h"
-#include "permute.h"
-#include "porting.h"
-#include "scaling.h"
-#include "tables.h"
-#include "tdef_functions.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/params.h"
+#include "velox/tpcds/gen/dsdgen/include/permute.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdef_functions.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 /* an array of the most recent business key for each table */
 char arBKeys[MAX_TABLE][17];
@@ -143,8 +143,7 @@ int setSCDKeys(
 ds_key_t
 scd_join(int tbl, int col, ds_key_t jDate, DSDGenContext& dsdGenContext) {
   ds_key_t res, kRowcount;
-  static int jMinimumDataDate, jMaximumDataDate, jH1DataDate, jT1DataDate,
-      jT2DataDate;
+  static int jMinimumDataDate, jMaximumDataDate, jT1DataDate, jT2DataDate;
   date_t dtTemp;
 
   if (!dsdGenContext.scd_join_init) {
@@ -152,7 +151,6 @@ scd_join(int tbl, int col, ds_key_t jDate, DSDGenContext& dsdGenContext) {
     jMinimumDataDate = dtTemp.julian;
     strtodt(&dtTemp, DATA_END_DATE);
     jMaximumDataDate = dtTemp.julian;
-    jH1DataDate = jMinimumDataDate + (jMaximumDataDate - jMinimumDataDate) / 2;
     jT2DataDate = (jMaximumDataDate - jMinimumDataDate) / 3;
     jT1DataDate = jMinimumDataDate + jT2DataDate;
     jT2DataDate += jT1DataDate;
diff --git a/velox/tpcds/gen/dsdgen/skip_days.cpp b/velox/tpcds/gen/dsdgen/skip_days.cpp
index 4ca687b4303..70badd3f0ed 100644
--- a/velox/tpcds/gen/dsdgen/skip_days.cpp
+++ b/velox/tpcds/gen/dsdgen/skip_days.cpp
@@ -24,12 +24,12 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "skip_days.h"
-#include "constants.h"
-#include "date.h"
-#include "dist.h"
-#include "parallel.h"
-#include "scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/skip_days.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
 
 ds_key_t
 skipDays(int nTable, ds_key_t* pRemainder, DSDGenContext& dsdGenContext) {
diff --git a/velox/tpcds/gen/dsdgen/sparse.cpp b/velox/tpcds/gen/dsdgen/sparse.cpp
index 2611f9ff2a7..7a79f1fd47c 100644
--- a/velox/tpcds/gen/dsdgen/sparse.cpp
+++ b/velox/tpcds/gen/dsdgen/sparse.cpp
@@ -24,13 +24,13 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "sparse.h"
-#include "config.h"
-#include "error_msg.h"
-#include "genrand.h"
-#include "porting.h"
-#include "scaling.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/sparse.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/error_msg.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 /*
  * Routine: initSparseKeys()
diff --git a/velox/tpcds/gen/dsdgen/tdef_functions.cpp b/velox/tpcds/gen/dsdgen/tdef_functions.cpp
index c276a7a39e0..989870cd664 100644
--- a/velox/tpcds/gen/dsdgen/tdef_functions.cpp
+++ b/velox/tpcds/gen/dsdgen/tdef_functions.cpp
@@ -24,32 +24,32 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "tdef_functions.h"
-#include "dbgen_version.h"
-#include "w_call_center.h"
-#include "w_catalog_page.h"
-#include "w_catalog_returns.h"
-#include "w_catalog_sales.h"
-#include "w_customer.h"
-#include "w_customer_address.h"
-#include "w_customer_demographics.h"
-#include "w_datetbl.h"
-#include "w_household_demographics.h"
-#include "w_income_band.h"
-#include "w_inventory.h"
-#include "w_item.h"
-#include "w_promotion.h"
-#include "w_reason.h"
-#include "w_ship_mode.h"
-#include "w_store.h"
-#include "w_store_returns.h"
-#include "w_store_sales.h"
-#include "w_timetbl.h"
-#include "w_warehouse.h"
-#include "w_web_page.h"
-#include "w_web_returns.h"
-#include "w_web_sales.h"
-#include "w_web_site.h"
+#include "velox/tpcds/gen/dsdgen/include/tdef_functions.h"
+#include "velox/tpcds/gen/dsdgen/include/dbgen_version.h"
+#include "velox/tpcds/gen/dsdgen/include/w_call_center.h"
+#include "velox/tpcds/gen/dsdgen/include/w_catalog_page.h"
+#include "velox/tpcds/gen/dsdgen/include/w_catalog_returns.h"
+#include "velox/tpcds/gen/dsdgen/include/w_catalog_sales.h"
+#include "velox/tpcds/gen/dsdgen/include/w_customer.h"
+#include "velox/tpcds/gen/dsdgen/include/w_customer_address.h"
+#include "velox/tpcds/gen/dsdgen/include/w_customer_demographics.h"
+#include "velox/tpcds/gen/dsdgen/include/w_datetbl.h"
+#include "velox/tpcds/gen/dsdgen/include/w_household_demographics.h"
+#include "velox/tpcds/gen/dsdgen/include/w_income_band.h"
+#include "velox/tpcds/gen/dsdgen/include/w_inventory.h"
+#include "velox/tpcds/gen/dsdgen/include/w_item.h"
+#include "velox/tpcds/gen/dsdgen/include/w_promotion.h"
+#include "velox/tpcds/gen/dsdgen/include/w_reason.h"
+#include "velox/tpcds/gen/dsdgen/include/w_ship_mode.h"
+#include "velox/tpcds/gen/dsdgen/include/w_store.h"
+#include "velox/tpcds/gen/dsdgen/include/w_store_returns.h"
+#include "velox/tpcds/gen/dsdgen/include/w_store_sales.h"
+#include "velox/tpcds/gen/dsdgen/include/w_timetbl.h"
+#include "velox/tpcds/gen/dsdgen/include/w_warehouse.h"
+#include "velox/tpcds/gen/dsdgen/include/w_web_page.h"
+#include "velox/tpcds/gen/dsdgen/include/w_web_returns.h"
+#include "velox/tpcds/gen/dsdgen/include/w_web_sales.h"
+#include "velox/tpcds/gen/dsdgen/include/w_web_site.h"
 
 table_func_t w_tdef_funcs[] = {
     {"call_center", mk_w_call_center, {NULL, NULL}, NULL},
diff --git a/velox/tpcds/gen/dsdgen/tdefs.cpp b/velox/tpcds/gen/dsdgen/tdefs.cpp
index 72e37ffb838..51ff9606376 100644
--- a/velox/tpcds/gen/dsdgen/tdefs.cpp
+++ b/velox/tpcds/gen/dsdgen/tdefs.cpp
@@ -24,16 +24,16 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 #include <stdio.h>
-#include "columns.h"
-#include "config.h"
-#include "genrand.h"
-#include "porting.h"
-#include "r_params.h"
-#include "scaling.h"
-#include "tables.h"
-#include "tdef_functions.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdef_functions.h"
 
 /*
  * Routine: get_rowcount(int table)
diff --git a/velox/tpcds/gen/dsdgen/text.cpp b/velox/tpcds/gen/dsdgen/text.cpp
index a7cb3b9bf6d..7484be0053f 100644
--- a/velox/tpcds/gen/dsdgen/text.cpp
+++ b/velox/tpcds/gen/dsdgen/text.cpp
@@ -27,12 +27,12 @@
 #include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include "config.h"
-#include "date.h"
-#include "decimal.h"
-#include "dist.h"
-#include "genrand.h"
-#include "porting.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
 
 /*
  * Routine: mk_sentence()
@@ -163,8 +163,8 @@ void gen_text(
 
 #ifdef TEST
 #define DECLARER
-#include "r_driver.h"
-#include "r_params.h"
+#include "velox/tpcds/gen/dsdgen/include/r_driver.h" // @manual
+#include "velox/tpcds/gen/dsdgen/include/r_params.h" // @manual
 
 typedef struct {
   char* name;
diff --git a/velox/tpcds/gen/dsdgen/w_call_center.cpp b/velox/tpcds/gen/dsdgen/w_call_center.cpp
index 7665a9e4beb..562ed4be6c3 100644
--- a/velox/tpcds/gen/dsdgen/w_call_center.cpp
+++ b/velox/tpcds/gen/dsdgen/w_call_center.cpp
@@ -24,25 +24,25 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_call_center.h"
-
-#include "append_info.h"
-#include "build_support.h"
-#include "columns.h"
-#include "config.h"
-#include "date.h"
-#include "decimal.h"
-#include "dist.h"
-#include "genrand.h"
-#include "misc.h"
-#include "nulls.h"
-#include "parallel.h"
-#include "porting.h"
-#include "r_params.h"
-#include "scaling.h"
-#include "scd.h"
-#include "tables.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/w_call_center.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/scd.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 #include <assert.h>
 #include <stdio.h>
@@ -70,8 +70,8 @@ int mk_w_call_center(
     void* info_arr,
     ds_key_t index,
     DSDGenContext& dsdGenContext) {
-  int32_t jDateStart, nDaysPerRevision;
-  int32_t nSuffix, bFirstRecord = 0, nFieldChangeFlags, jDateEnd, nDateRange;
+  int32_t jDateStart;
+  int32_t nSuffix, bFirstRecord = 0, nFieldChangeFlags;
   char *cp = nullptr, *sName1 = nullptr, *sName2 = nullptr;
   decimal_t dMinTaxPercentage, dMaxTaxPercentage;
   tdef* pTdef = getSimpleTdefsByNumber(CALL_CENTER, dsdGenContext);
@@ -85,10 +85,6 @@ int mk_w_call_center(
 
   strtodt(&dTemp, DATA_START_DATE);
   jDateStart = dttoj(&dTemp) - WEB_SITE;
-  strtodt(&dTemp, DATA_END_DATE);
-  jDateEnd = dttoj(&dTemp);
-  nDateRange = jDateEnd - jDateStart + 1;
-  nDaysPerRevision = nDateRange / pTdef->nParam + 1;
   nScale = get_dbl("SCALE", dsdGenContext);
 
   r->cc_division_id = -1;
@@ -130,8 +126,9 @@ int mk_w_call_center(
         dsdGenContext);
     if (nSuffix > 0) {
       snprintf(r->cc_name, RS_CC_NAME + 1, "%s_%d", cp, nSuffix);
-    } else
+    } else {
       strcpy(r->cc_name, cp);
+    }
 
     mk_address(&r->cc_address, CC_ADDRESS, dsdGenContext);
     bFirstRecord = 1;
diff --git a/velox/tpcds/gen/dsdgen/w_catalog_page.cpp b/velox/tpcds/gen/dsdgen/w_catalog_page.cpp
index 0e1e13dafba..995fad7b60f 100644
--- a/velox/tpcds/gen/dsdgen/w_catalog_page.cpp
+++ b/velox/tpcds/gen/dsdgen/w_catalog_page.cpp
@@ -24,21 +24,21 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_catalog_page.h"
+#include "velox/tpcds/gen/dsdgen/include/w_catalog_page.h"
 
-#include "append_info.h"
-#include "build_support.h"
-#include "config.h"
-#include "constants.h"
-#include "date.h"
-#include "decimal.h"
-#include "genrand.h"
-#include "misc.h"
-#include "nulls.h"
-#include "porting.h"
-#include "scaling.h"
-#include "tables.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 #include <stdio.h>
 
diff --git a/velox/tpcds/gen/dsdgen/w_catalog_returns.cpp b/velox/tpcds/gen/dsdgen/w_catalog_returns.cpp
index 1b125a5feb9..f76c0c97bd6 100644
--- a/velox/tpcds/gen/dsdgen/w_catalog_returns.cpp
+++ b/velox/tpcds/gen/dsdgen/w_catalog_returns.cpp
@@ -24,19 +24,19 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_catalog_returns.h"
+#include "velox/tpcds/gen/dsdgen/include/w_catalog_returns.h"
 #include <stdio.h>
-#include "build_support.h"
-#include "columns.h"
-#include "config.h"
-#include "constants.h"
-#include "genrand.h"
-#include "nulls.h"
-#include "parallel.h"
-#include "porting.h"
-#include "tables.h"
-#include "tdefs.h"
-#include "w_catalog_sales.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/w_catalog_sales.h"
 
 /*
  * Routine: mk_catalog_returns()
@@ -137,7 +137,8 @@ int mk_w_catalog_returns(
       mk_join(CR_RETURNED_DATE_SK, DATET, sale->cs_ship_date_sk, dsdGenContext);
 
   /* the call center determines the time of the return */
-  r->cr_returned_time_sk = mk_join(CR_RETURNED_TIME_SK, TIME, 1, dsdGenContext);
+  r->cr_returned_time_sk =
+      mk_join(CR_RETURNED_TIME_SK, TIMET, 1, dsdGenContext);
 
   r->cr_ship_mode_sk = mk_join(CR_SHIP_MODE_SK, SHIP_MODE, 1, dsdGenContext);
   r->cr_warehouse_sk = mk_join(CR_WAREHOUSE_SK, WAREHOUSE, 1, dsdGenContext);
diff --git a/velox/tpcds/gen/dsdgen/w_catalog_sales.cpp b/velox/tpcds/gen/dsdgen/w_catalog_sales.cpp
index ae5d982197c..4eff2f3cc58 100644
--- a/velox/tpcds/gen/dsdgen/w_catalog_sales.cpp
+++ b/velox/tpcds/gen/dsdgen/w_catalog_sales.cpp
@@ -24,26 +24,26 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_catalog_sales.h"
-
-#include "append_info.h"
-#include "build_support.h"
-#include "columns.h"
-#include "config.h"
-#include "constants.h"
-#include "date.h"
-#include "decimal.h"
-#include "genrand.h"
-#include "nulls.h"
-#include "parallel.h"
-#include "params.h"
-#include "permute.h"
-#include "porting.h"
-#include "scaling.h"
-#include "scd.h"
-#include "tables.h"
-#include "tdefs.h"
-#include "w_catalog_returns.h"
+#include "velox/tpcds/gen/dsdgen/include/w_catalog_sales.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/params.h"
+#include "velox/tpcds/gen/dsdgen/include/permute.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/scd.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/w_catalog_returns.h"
 
 #include <stdio.h>
 
@@ -101,7 +101,7 @@ W_CATALOG_SALES_TBL* mk_catalog_sales_master(
 
   r->cs_sold_date_sk = dsdGenContext.jDate;
   r->cs_sold_time_sk =
-      mk_join(CS_SOLD_TIME_SK, TIME, r->cs_call_center_sk, dsdGenContext);
+      mk_join(CS_SOLD_TIME_SK, TIMET, r->cs_call_center_sk, dsdGenContext);
   r->cs_call_center_sk = (r->cs_sold_date_sk == -1)
       ? -1
       : mk_join(
diff --git a/velox/tpcds/gen/dsdgen/w_customer.cpp b/velox/tpcds/gen/dsdgen/w_customer.cpp
index c6ccc795336..b13301ad49d 100644
--- a/velox/tpcds/gen/dsdgen/w_customer.cpp
+++ b/velox/tpcds/gen/dsdgen/w_customer.cpp
@@ -24,21 +24,21 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_customer.h"
-
-#include "append_info.h"
-#include "build_support.h"
-#include "columns.h"
-#include "config.h"
-#include "constants.h"
-#include "genrand.h"
-#include "nulls.h"
-#include "porting.h"
-#include "tables.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/w_customer.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 #include <stdio.h>
-#include "parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
 /* extern tdef w_tdefs[]; */
 
 /*
@@ -61,7 +61,6 @@ int mk_w_customer(
     DSDGenContext& dsdGenContext) {
   int nTemp;
 
-  int nBaseDate;
   /* begin locals declarations */
   int nNameIndex, nGender;
   struct W_CUSTOMER_TBL* r;
@@ -70,10 +69,6 @@ int mk_w_customer(
   tdef* pT = getSimpleTdefsByNumber(CUSTOMER, dsdGenContext);
   r = &dsdGenContext.g_w_customer;
 
-  date_t min_date;
-  strtodt(&min_date, DATE_MINIMUM);
-  nBaseDate = dttoj(&min_date);
-
   strtodt(&dtBirthMax, "1992-12-31");
   strtodt(&dtBirthMin, "1924-01-01");
   strtodt(&dtToday, TODAYS_DATE);
diff --git a/velox/tpcds/gen/dsdgen/w_customer_address.cpp b/velox/tpcds/gen/dsdgen/w_customer_address.cpp
index 12f5a4e77c3..83b827c6de7 100644
--- a/velox/tpcds/gen/dsdgen/w_customer_address.cpp
+++ b/velox/tpcds/gen/dsdgen/w_customer_address.cpp
@@ -24,19 +24,19 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_customer_address.h"
+#include "velox/tpcds/gen/dsdgen/include/w_customer_address.h"
 
-#include "append_info.h"
-#include "build_support.h"
-#include "columns.h"
-#include "config.h"
-#include "date.h"
-#include "decimal.h"
-#include "genrand.h"
-#include "nulls.h"
-#include "porting.h"
-#include "tables.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 #include <stdio.h>
 
diff --git a/velox/tpcds/gen/dsdgen/w_customer_demographics.cpp b/velox/tpcds/gen/dsdgen/w_customer_demographics.cpp
index 41f20eca0c1..87686bfb070 100644
--- a/velox/tpcds/gen/dsdgen/w_customer_demographics.cpp
+++ b/velox/tpcds/gen/dsdgen/w_customer_demographics.cpp
@@ -24,19 +24,19 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_customer_demographics.h"
+#include "velox/tpcds/gen/dsdgen/include/w_customer_demographics.h"
 
-#include "append_info.h"
-#include "build_support.h"
-#include "columns.h"
-#include "config.h"
-#include "constants.h"
-#include "genrand.h"
-#include "nulls.h"
-#include "porting.h"
-#include "sparse.h"
-#include "tables.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/sparse.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 #include <stdio.h>
 
diff --git a/velox/tpcds/gen/dsdgen/w_datetbl.cpp b/velox/tpcds/gen/dsdgen/w_datetbl.cpp
index 4fd6a870ba3..2617448d8b8 100644
--- a/velox/tpcds/gen/dsdgen/w_datetbl.cpp
+++ b/velox/tpcds/gen/dsdgen/w_datetbl.cpp
@@ -24,18 +24,18 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_datetbl.h"
+#include "velox/tpcds/gen/dsdgen/include/w_datetbl.h"
 
-#include "append_info.h"
-#include "build_support.h"
-#include "columns.h"
-#include "config.h"
-#include "genrand.h"
-#include "nulls.h"
-#include "parallel.h"
-#include "porting.h"
-#include "tables.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 #include <stdio.h>
 
diff --git a/velox/tpcds/gen/dsdgen/w_household_demographics.cpp b/velox/tpcds/gen/dsdgen/w_household_demographics.cpp
index b71dfdf33b0..ae1fc527d29 100644
--- a/velox/tpcds/gen/dsdgen/w_household_demographics.cpp
+++ b/velox/tpcds/gen/dsdgen/w_household_demographics.cpp
@@ -24,18 +24,18 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_household_demographics.h"
+#include "velox/tpcds/gen/dsdgen/include/w_household_demographics.h"
 
-#include "append_info.h"
-#include "build_support.h"
-#include "columns.h"
-#include "config.h"
-#include "genrand.h"
-#include "nulls.h"
-#include "porting.h"
-#include "sparse.h"
-#include "tables.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/sparse.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 #include <stdio.h>
 
diff --git a/velox/tpcds/gen/dsdgen/w_income_band.cpp b/velox/tpcds/gen/dsdgen/w_income_band.cpp
index be692badcd5..a60eba75afa 100644
--- a/velox/tpcds/gen/dsdgen/w_income_band.cpp
+++ b/velox/tpcds/gen/dsdgen/w_income_band.cpp
@@ -24,17 +24,17 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_income_band.h"
+#include "velox/tpcds/gen/dsdgen/include/w_income_band.h"
 
-#include "append_info.h"
-#include "build_support.h"
-#include "columns.h"
-#include "config.h"
-#include "genrand.h"
-#include "nulls.h"
-#include "porting.h"
-#include "tables.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 #include <stdio.h>
 
diff --git a/velox/tpcds/gen/dsdgen/w_inventory.cpp b/velox/tpcds/gen/dsdgen/w_inventory.cpp
index e6ff446dc57..4ca16d01478 100644
--- a/velox/tpcds/gen/dsdgen/w_inventory.cpp
+++ b/velox/tpcds/gen/dsdgen/w_inventory.cpp
@@ -24,21 +24,21 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_inventory.h"
+#include "velox/tpcds/gen/dsdgen/include/w_inventory.h"
 
-#include "append_info.h"
-#include "build_support.h"
-#include "columns.h"
-#include "config.h"
-#include "constants.h"
-#include "date.h"
-#include "genrand.h"
-#include "nulls.h"
-#include "porting.h"
-#include "scaling.h"
-#include "scd.h"
-#include "tables.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/scd.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 #include <stdio.h>
 
diff --git a/velox/tpcds/gen/dsdgen/w_item.cpp b/velox/tpcds/gen/dsdgen/w_item.cpp
index f3721c87131..2fd7b8b5fb7 100644
--- a/velox/tpcds/gen/dsdgen/w_item.cpp
+++ b/velox/tpcds/gen/dsdgen/w_item.cpp
@@ -24,19 +24,19 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_item.h"
-
-#include "append_info.h"
-#include "build_support.h"
-#include "columns.h"
-#include "config.h"
-#include "genrand.h"
-#include "misc.h"
-#include "nulls.h"
-#include "porting.h"
-#include "scd.h"
-#include "tables.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/w_item.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/scd.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 #include <stdio.h>
 
diff --git a/velox/tpcds/gen/dsdgen/w_promotion.cpp b/velox/tpcds/gen/dsdgen/w_promotion.cpp
index 9a470076a2a..c45b8fdb85f 100644
--- a/velox/tpcds/gen/dsdgen/w_promotion.cpp
+++ b/velox/tpcds/gen/dsdgen/w_promotion.cpp
@@ -24,18 +24,18 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_promotion.h"
+#include "velox/tpcds/gen/dsdgen/include/w_promotion.h"
 
-#include "append_info.h"
-#include "build_support.h"
-#include "columns.h"
-#include "config.h"
-#include "genrand.h"
-#include "misc.h"
-#include "nulls.h"
-#include "porting.h"
-#include "tables.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 #include <stdio.h>
 
@@ -63,7 +63,6 @@ int mk_w_promotion(
 
   /* begin locals declarations */
   date_t start_date;
-  ds_key_t nTemp;
   int nFlags;
   tdef* pTdef = getSimpleTdefsByNumber(PROMOTION, dsdGenContext);
 
@@ -80,7 +79,6 @@ int mk_w_promotion(
   nullSet(&pTdef->kNullBitMap, P_NULLS, dsdGenContext);
   r->p_promo_sk = index;
   mk_bkey(&r->p_promo_id[0], index, P_PROMO_ID);
-  nTemp = index;
   r->p_start_date_id = start_date.julian +
       genrand_integer(NULL,
                       DIST_UNIFORM,
diff --git a/velox/tpcds/gen/dsdgen/w_reason.cpp b/velox/tpcds/gen/dsdgen/w_reason.cpp
index 3bd98bebfa3..b046a870702 100644
--- a/velox/tpcds/gen/dsdgen/w_reason.cpp
+++ b/velox/tpcds/gen/dsdgen/w_reason.cpp
@@ -24,17 +24,17 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_reason.h"
+#include "velox/tpcds/gen/dsdgen/include/w_reason.h"
 
-#include "append_info.h"
-#include "build_support.h"
-#include "columns.h"
-#include "config.h"
-#include "genrand.h"
-#include "nulls.h"
-#include "porting.h"
-#include "tables.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 #include <stdio.h>
 
diff --git a/velox/tpcds/gen/dsdgen/w_ship_mode.cpp b/velox/tpcds/gen/dsdgen/w_ship_mode.cpp
index cd8ddaf8dba..718d900b74f 100644
--- a/velox/tpcds/gen/dsdgen/w_ship_mode.cpp
+++ b/velox/tpcds/gen/dsdgen/w_ship_mode.cpp
@@ -24,17 +24,17 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_ship_mode.h"
+#include "velox/tpcds/gen/dsdgen/include/w_ship_mode.h"
 
-#include "append_info.h"
-#include "build_support.h"
-#include "columns.h"
-#include "config.h"
-#include "genrand.h"
-#include "nulls.h"
-#include "porting.h"
-#include "tables.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 #include <stdio.h>
 
diff --git a/velox/tpcds/gen/dsdgen/w_store.cpp b/velox/tpcds/gen/dsdgen/w_store.cpp
index 093639e2721..9ac8958ad1f 100644
--- a/velox/tpcds/gen/dsdgen/w_store.cpp
+++ b/velox/tpcds/gen/dsdgen/w_store.cpp
@@ -24,23 +24,23 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_store.h"
+#include "velox/tpcds/gen/dsdgen/include/w_store.h"
 
-#include "append_info.h"
-#include "build_support.h"
-#include "config.h"
-#include "constants.h"
-#include "date.h"
-#include "decimal.h"
-#include "genrand.h"
-#include "misc.h"
-#include "nulls.h"
-#include "parallel.h"
-#include "porting.h"
-#include "scaling.h"
-#include "scd.h"
-#include "tables.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/scd.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 #include <stdio.h>
 #include <string>
@@ -55,7 +55,7 @@ int mk_w_store(void* info_arr, ds_key_t index, DSDGenContext& dsdGenContext) {
   /* begin locals declarations */
   static decimal_t dRevMin, dRevMax;
   char *sName1 = nullptr, *sName2 = nullptr, *szTemp = nullptr;
-  int32_t nHierarchyTotal, nStoreType, nPercentage, nDaysOpen, nMin, nMax;
+  int32_t nStoreType, nPercentage, nDaysOpen, nMin, nMax;
   static date_t tDate;
   static decimal_t min_rev_growth, max_rev_growth, dMinTaxPercentage,
       dMaxTaxPercentage;
@@ -65,8 +65,6 @@ int mk_w_store(void* info_arr, ds_key_t index, DSDGenContext& dsdGenContext) {
   r = &dsdGenContext.g_w_store;
 
   if (!dsdGenContext.mk_w_store_init) {
-    nHierarchyTotal = static_cast<int>(get_rowcount(DIVISIONS, dsdGenContext));
-    nHierarchyTotal *= static_cast<int>(get_rowcount(COMPANY, dsdGenContext));
     strtodt(&tDate, DATE_MINIMUM);
     strtodec(&min_rev_growth, STORE_MIN_REV_GROWTH);
     strtodec(&max_rev_growth, STORE_MAX_REV_GROWTH);
diff --git a/velox/tpcds/gen/dsdgen/w_store_returns.cpp b/velox/tpcds/gen/dsdgen/w_store_returns.cpp
index c1ed71a03df..2e5e7d450e6 100644
--- a/velox/tpcds/gen/dsdgen/w_store_returns.cpp
+++ b/velox/tpcds/gen/dsdgen/w_store_returns.cpp
@@ -24,19 +24,19 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_store_returns.h"
+#include "velox/tpcds/gen/dsdgen/include/w_store_returns.h"
 #include <stdio.h>
-#include "build_support.h"
-#include "columns.h"
-#include "config.h"
-#include "genrand.h"
-#include "nulls.h"
-#include "parallel.h"
-#include "porting.h"
-#include "pricing.h"
-#include "tables.h"
-#include "tdefs.h"
-#include "w_store_sales.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/pricing.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/w_store_sales.h"
 
 /*
  * Routine: mk_store_returns()
diff --git a/velox/tpcds/gen/dsdgen/w_store_sales.cpp b/velox/tpcds/gen/dsdgen/w_store_sales.cpp
index d1df4764dc6..6778efcb3da 100644
--- a/velox/tpcds/gen/dsdgen/w_store_sales.cpp
+++ b/velox/tpcds/gen/dsdgen/w_store_sales.cpp
@@ -24,24 +24,24 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_store_sales.h"
+#include "velox/tpcds/gen/dsdgen/include/w_store_sales.h"
 
-#include "append_info.h"
-#include "build_support.h"
-#include "columns.h"
-#include "config.h"
-#include "constants.h"
-#include "decimal.h"
-#include "genrand.h"
-#include "nulls.h"
-#include "parallel.h"
-#include "permute.h"
-#include "porting.h"
-#include "scaling.h"
-#include "scd.h"
-#include "tables.h"
-#include "tdefs.h"
-#include "w_store_returns.h"
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/permute.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/scd.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/w_store_returns.h"
 
 // ds_key_t
 // skipDays(int nTable, ds_key_t* pRemainder, DSDGenContext& dsdGenContext);
@@ -54,14 +54,12 @@ W_STORE_SALES_TBL* mk_master_store_sales(
     ds_key_t index,
     DSDGenContext& dsdGenContext) {
   decimal_t dMin, dMax;
-  int nMaxItemCount;
   struct W_STORE_SALES_TBL* r;
   r = &dsdGenContext.g_w_store_sales;
 
   if (!dsdGenContext.mk_master_store_sales_init) {
     strtodec(&dMin, "1.00");
     strtodec(&dMax, "100000.00");
-    nMaxItemCount = 20;
     dsdGenContext.pStoreSalesItemPermutation = makePermutation(
         dsdGenContext.nStoreSalesItemCount =
             static_cast<int>(getIDCount(ITEM, dsdGenContext)),
@@ -75,7 +73,7 @@ W_STORE_SALES_TBL* mk_master_store_sales(
   }
 
   r->ss_sold_store_sk = mk_join(SS_SOLD_STORE_SK, STORE, 1, dsdGenContext);
-  r->ss_sold_time_sk = mk_join(SS_SOLD_TIME_SK, TIME, 1, dsdGenContext);
+  r->ss_sold_time_sk = mk_join(SS_SOLD_TIME_SK, TIMET, 1, dsdGenContext);
   r->ss_sold_date_sk = mk_join(SS_SOLD_DATE_SK, DATET, 1, dsdGenContext);
   r->ss_sold_customer_sk =
       mk_join(SS_SOLD_CUSTOMER_SK, CUSTOMER, 1, dsdGenContext);
diff --git a/velox/tpcds/gen/dsdgen/w_timetbl.cpp b/velox/tpcds/gen/dsdgen/w_timetbl.cpp
index a62c4a17a66..4d91f96fbb9 100644
--- a/velox/tpcds/gen/dsdgen/w_timetbl.cpp
+++ b/velox/tpcds/gen/dsdgen/w_timetbl.cpp
@@ -24,20 +24,20 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_timetbl.h"
+#include "velox/tpcds/gen/dsdgen/include/w_timetbl.h"
 
-#include "append_info.h"
-#include "build_support.h"
-#include "config.h"
-#include "constants.h"
-#include "date.h"
-#include "decimal.h"
-#include "genrand.h"
-#include "misc.h"
-#include "nulls.h"
-#include "porting.h"
-#include "tables.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 #include <stdio.h>
 
@@ -48,7 +48,7 @@ int mk_w_time(void* info_arr, ds_key_t index, DSDGenContext& dsdGenContext) {
   /* begin locals declarations */
   int nTemp;
   struct W_TIME_TBL* r;
-  tdef* pT = getSimpleTdefsByNumber(TIME, dsdGenContext);
+  tdef* pT = getSimpleTdefsByNumber(TIMET, dsdGenContext);
 
   r = &dsdGenContext.g_w_time;
 
@@ -67,7 +67,7 @@ int mk_w_time(void* info_arr, ds_key_t index, DSDGenContext& dsdGenContext) {
   dist_member(&r->t_sub_shift, "hours", r->t_hour + 1, 4, dsdGenContext);
   dist_member(&r->t_meal_time, "hours", r->t_hour + 1, 5, dsdGenContext);
 
-  void* info = append_info_get(info_arr, TIME);
+  void* info = append_info_get(info_arr, TIMET);
   append_row_start(info);
   append_key(T_TIME_SK, info, r->t_time_sk);
   append_varchar(T_TIME_ID, info, r->t_time_id);
diff --git a/velox/tpcds/gen/dsdgen/w_warehouse.cpp b/velox/tpcds/gen/dsdgen/w_warehouse.cpp
index 4a7d76945f2..1c7f70115ee 100644
--- a/velox/tpcds/gen/dsdgen/w_warehouse.cpp
+++ b/velox/tpcds/gen/dsdgen/w_warehouse.cpp
@@ -24,21 +24,21 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_warehouse.h"
+#include "velox/tpcds/gen/dsdgen/include/w_warehouse.h"
 
-#include "address.h"
-#include "append_info.h"
-#include "build_support.h"
-#include "config.h"
-#include "constants.h"
-#include "date.h"
-#include "decimal.h"
-#include "genrand.h"
-#include "misc.h"
-#include "nulls.h"
-#include "porting.h"
-#include "tables.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/address.h"
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 #include <stdio.h>
 
diff --git a/velox/tpcds/gen/dsdgen/w_web_page.cpp b/velox/tpcds/gen/dsdgen/w_web_page.cpp
index 23d39eeffe5..22504fb60a5 100644
--- a/velox/tpcds/gen/dsdgen/w_web_page.cpp
+++ b/velox/tpcds/gen/dsdgen/w_web_page.cpp
@@ -24,22 +24,22 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_web_page.h"
+#include "velox/tpcds/gen/dsdgen/include/w_web_page.h"
 
-#include "append_info.h"
-#include "build_support.h"
-#include "config.h"
-#include "constants.h"
-#include "date.h"
-#include "decimal.h"
-#include "genrand.h"
-#include "misc.h"
-#include "nulls.h"
-#include "porting.h"
-#include "scaling.h"
-#include "scd.h"
-#include "tables.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/scd.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 #include <stdio.h>
 
@@ -66,7 +66,6 @@ int mk_w_web_page(
     DSDGenContext& dsdGenContext) {
   int32_t bFirstRecord = 0, nFieldChangeFlags;
   date_t dToday;
-  ds_key_t nConcurrent, nRevisions;
 
   /* begin locals declarations */
   int32_t nTemp, nAccess;
@@ -86,10 +85,6 @@ int mk_w_web_page(
       CURRENT_DAY);
   strtodt(&dToday, szTemp.data());
   /* set up for the SCD handling */
-  nConcurrent =
-      static_cast<int>(get_rowcount(CONCURRENT_WEB_SITES, dsdGenContext));
-  nRevisions =
-      static_cast<int>(get_rowcount(WEB_PAGE, dsdGenContext) / nConcurrent);
 
   nullSet(&pT->kNullBitMap, WP_NULLS, dsdGenContext);
   r->wp_page_sk = index;
diff --git a/velox/tpcds/gen/dsdgen/w_web_returns.cpp b/velox/tpcds/gen/dsdgen/w_web_returns.cpp
index afd479ba863..2fc68eba8f8 100644
--- a/velox/tpcds/gen/dsdgen/w_web_returns.cpp
+++ b/velox/tpcds/gen/dsdgen/w_web_returns.cpp
@@ -24,21 +24,21 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_web_returns.h"
+#include "velox/tpcds/gen/dsdgen/include/w_web_returns.h"
 #include <stdio.h>
-#include "build_support.h"
-#include "config.h"
-#include "date.h"
-#include "decimal.h"
-#include "error_msg.h"
-#include "genrand.h"
-#include "misc.h"
-#include "nulls.h"
-#include "porting.h"
-#include "pricing.h"
-#include "tables.h"
-#include "tdefs.h"
-#include "w_web_sales.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/error_msg.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/pricing.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/w_web_sales.h"
 
 /*
  * Routine: mk_web_returns()
@@ -92,7 +92,8 @@ int mk_w_web_returns(void* row, ds_key_t index, DSDGenContext& dsdGenContext) {
    * mk_join, based on sales date */
   r->wr_returned_date_sk =
       mk_join(WR_RETURNED_DATE_SK, DATET, sale->ws_ship_date_sk, dsdGenContext);
-  r->wr_returned_time_sk = mk_join(WR_RETURNED_TIME_SK, TIME, 1, dsdGenContext);
+  r->wr_returned_time_sk =
+      mk_join(WR_RETURNED_TIME_SK, TIMET, 1, dsdGenContext);
 
   /* most items are returned by the people they were shipped to, but some are
    * returned by other folks
diff --git a/velox/tpcds/gen/dsdgen/w_web_sales.cpp b/velox/tpcds/gen/dsdgen/w_web_sales.cpp
index e91618fbdf2..29d565e8fed 100644
--- a/velox/tpcds/gen/dsdgen/w_web_sales.cpp
+++ b/velox/tpcds/gen/dsdgen/w_web_sales.cpp
@@ -24,26 +24,26 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_web_sales.h"
-
-#include "append_info.h"
-#include "build_support.h"
-#include "config.h"
-#include "constants.h"
-#include "date.h"
-#include "decimal.h"
-#include "genrand.h"
-#include "misc.h"
-#include "nulls.h"
-#include "parallel.h"
-#include "permute.h"
-#include "porting.h"
-#include "pricing.h"
-#include "scaling.h"
-#include "scd.h"
-#include "tables.h"
-#include "tdefs.h"
-#include "w_web_returns.h"
+#include "velox/tpcds/gen/dsdgen/include/w_web_sales.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/permute.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/pricing.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/scd.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/w_web_returns.h"
 
 #include <stdio.h>
 
@@ -83,7 +83,7 @@ W_WEB_SALES_TBL* mk_web_sales_master(
    */
 
   r->ws_sold_date_sk = mk_join(WS_SOLD_DATE_SK, DATET, 1, dsdGenContext);
-  r->ws_sold_time_sk = mk_join(WS_SOLD_TIME_SK, TIME, 1, dsdGenContext);
+  r->ws_sold_time_sk = mk_join(WS_SOLD_TIME_SK, TIMET, 1, dsdGenContext);
   r->ws_bill_customer_sk =
       mk_join(WS_BILL_CUSTOMER_SK, CUSTOMER, 1, dsdGenContext);
   r->ws_bill_cdemo_sk =
diff --git a/velox/tpcds/gen/dsdgen/w_web_site.cpp b/velox/tpcds/gen/dsdgen/w_web_site.cpp
index 10f2312d086..96c67527336 100644
--- a/velox/tpcds/gen/dsdgen/w_web_site.cpp
+++ b/velox/tpcds/gen/dsdgen/w_web_site.cpp
@@ -24,22 +24,22 @@
  * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
  */
 
-#include "w_web_site.h"
+#include "velox/tpcds/gen/dsdgen/include/w_web_site.h"
 
-#include "address.h"
-#include "append_info.h"
-#include "build_support.h"
-#include "columns.h"
-#include "config.h"
-#include "constants.h"
-#include "genrand.h"
-#include "misc.h"
-#include "nulls.h"
-#include "porting.h"
-#include "scaling.h"
-#include "scd.h"
-#include "tables.h"
-#include "tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/address.h"
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/scd.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
 
 #include <stdio.h>
 
diff --git a/velox/tpcds/gen/utils/CMakeLists.txt b/velox/tpcds/gen/utils/CMakeLists.txt
index 78986bf151a..a3bf6c09093 100644
--- a/velox/tpcds/gen/utils/CMakeLists.txt
+++ b/velox/tpcds/gen/utils/CMakeLists.txt
@@ -12,5 +12,5 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_tpcds_append_info append_info-c.cpp)
+velox_add_library(velox_tpcds_append_info append_info-c.cpp HEADERS append_info-c.h)
 velox_link_libraries(velox_tpcds_append_info PRIVATE velox_vector fmt::fmt)
diff --git a/velox/tpch/gen/CMakeLists.txt b/velox/tpch/gen/CMakeLists.txt
index 558e6a89f77..ce9fc42b669 100644
--- a/velox/tpch/gen/CMakeLists.txt
+++ b/velox/tpch/gen/CMakeLists.txt
@@ -14,7 +14,14 @@
 
 add_subdirectory(dbgen)
 
-velox_add_library(velox_tpch_gen DBGenIterator.cpp TpchGen.cpp)
+velox_add_library(
+  velox_tpch_gen
+  DBGenIterator.cpp
+  TpchGen.cpp
+  HEADERS
+  DBGenIterator.h
+  TpchGen.h
+)
 
 velox_include_directories(velox_tpch_gen PRIVATE dbgen/include)
 
diff --git a/velox/tpch/gen/dbgen/bm_utils.cpp b/velox/tpch/gen/dbgen/bm_utils.cpp
index b52d2f5b7ee..fcab31f2b6c 100644
--- a/velox/tpch/gen/dbgen/bm_utils.cpp
+++ b/velox/tpch/gen/dbgen/bm_utils.cpp
@@ -107,7 +107,7 @@ char* getenv PROTO((const char* name));
 namespace facebook::velox::tpch::dbgen {
 
 void usage();
-void permute_dist(distribution* d, seed_t* seed);
+void permute_dist(distribution* d, seed_t* seed, DBGenContext* ctx);
 
 /*
  * tpch_env_config: look for a environmental variable setting and return its
@@ -297,7 +297,6 @@ void read_dist(const char* path, const char* name, distribution* target) {
     fprintf(stderr, "Read error on dist '%s'\n", name);
     exit(1);
   }
-  target->permute = reinterpret_cast<long*>(NULL);
   return;
 }
 
@@ -305,16 +304,21 @@ void read_dist(const char* path, const char* name, distribution* target) {
  * agg_str(set, count) build an aggregated string from count unique
  * selections taken from set
  */
-void agg_str(distribution* set, long count, seed_t* seed, char* dest) {
+void agg_str(
+    distribution* set,
+    long count,
+    seed_t* seed,
+    char* dest,
+    DBGenContext* ctx) {
   distribution* d;
   int i;
 
   d = set;
   *dest = '\0';
 
-  permute_dist(d, seed);
+  permute_dist(d, seed, ctx);
   for (i = 0; i < count; i++) {
-    strcat(dest, DIST_MEMBER(set, DIST_PERMUTE(d, i)));
+    strcat(dest, DIST_MEMBER(set, ctx->permute[i]));
     strcat(dest, " ");
   }
   *(dest + static_cast<int>(strlen(dest)) - 1) = '\0';
diff --git a/velox/tpch/gen/dbgen/build.cpp b/velox/tpch/gen/dbgen/build.cpp
index 0fae068922f..4f0692185a8 100644
--- a/velox/tpch/gen/dbgen/build.cpp
+++ b/velox/tpch/gen/dbgen/build.cpp
@@ -268,7 +268,11 @@ long mk_part(DSS_HUGE index, part_t* p, DBGenContext* ctx) {
 
   p->partkey = index;
   agg_str(
-      &colors, static_cast<long>(P_NAME_SCL), &ctx->Seed[P_NAME_SD], p->name);
+      &colors,
+      static_cast<long>(P_NAME_SCL),
+      &ctx->Seed[P_NAME_SD],
+      p->name,
+      ctx);
   RANDOM(temp, P_MFG_MIN, P_MFG_MAX, &ctx->Seed[P_MFG_SD]);
   sprintf(p->mfgr, partSzFormat, P_MFG_TAG, temp);
   RANDOM(brnd, P_BRND_MIN, P_BRND_MAX, &ctx->Seed[P_BRND_SD]);
diff --git a/velox/tpch/gen/dbgen/dbgen_gunk.cpp b/velox/tpch/gen/dbgen/dbgen_gunk.cpp
index 0a57b4e7705..13a2ade51c3 100644
--- a/velox/tpch/gen/dbgen/dbgen_gunk.cpp
+++ b/velox/tpch/gen/dbgen/dbgen_gunk.cpp
@@ -72,10 +72,6 @@ static void cleanup_dist(distribution* target) {
     }
     free(target->list);
   }
-  /* Allocated from permute_dist */
-  if (target->permute) {
-    free(target->permute);
-  }
 }
 
 void cleanup_dists(void) {
diff --git a/velox/tpch/gen/dbgen/include/dbgen/dss.h b/velox/tpch/gen/dbgen/include/dbgen/dss.h
index 34174c5e18f..749b4678525 100644
--- a/velox/tpch/gen/dbgen/include/dbgen/dss.h
+++ b/velox/tpch/gen/dbgen/include/dbgen/dss.h
@@ -129,14 +129,12 @@ typedef struct {
   int count;
   int max;
   set_member* list;
-  long* permute;
 } distribution;
 /*
  * some handy access functions
  */
 #define DIST_SIZE(d) d->count
 #define DIST_MEMBER(d, i) (reinterpret_cast<set_member*>((d)->list + i))->text
-#define DIST_PERMUTE(d, i) (d->permute[i])
 
 typedef struct {
   const char* name;
@@ -171,7 +169,12 @@ long unjulian PROTO((long date));
 long dssncasecmp PROTO((const char* s1, const char* s2, int n));
 long dsscasecmp PROTO((const char* s1, const char* s2));
 int pick_str PROTO((distribution * s, seed_t* seed, char* target));
-void agg_str PROTO((distribution * set, long count, seed_t* seed, char* dest));
+void agg_str PROTO(
+    (distribution * set,
+     long count,
+     seed_t* seed,
+     char* dest,
+     DBGenContext* ctx));
 void read_dist
     PROTO((const char* path, const char* name, distribution* target));
 void embed_str
@@ -517,6 +520,13 @@ int dbg_print(int dt, FILE* tgt, void* data, int len, int eol);
 #define BBB_OFFSET_SD 47
 
 struct DBGenContext {
+  ~DBGenContext() {
+    if (permute) {
+      free(permute);
+      permute = nullptr;
+    }
+  }
+
   seed_t Seed[MAX_STREAM + 1] = {
       {PART, 1, 0, 1}, /* P_MFG_SD     0 */
       {PART, 46831694, 0, 1}, /* P_BRND_SD    1 */
@@ -590,6 +600,7 @@ struct DBGenContext {
   };
 
   long scale_factor = 1;
+  long* permute = nullptr;
 };
 
 } // namespace facebook::velox::tpch::dbgen
diff --git a/velox/tpch/gen/dbgen/permute.cpp b/velox/tpch/gen/dbgen/permute.cpp
index 48e52cd454a..619293b0068 100644
--- a/velox/tpch/gen/dbgen/permute.cpp
+++ b/velox/tpch/gen/dbgen/permute.cpp
@@ -34,7 +34,7 @@ namespace facebook::velox::tpch::dbgen {
 
 DSS_HUGE NextRand(DSS_HUGE seed);
 void permute(long* set, int cnt, seed_t* seed);
-void permute_dist(distribution* d, seed_t* seed);
+void permute_dist(distribution* d, seed_t* seed, DBGenContext* ctx);
 long seed;
 char* eol[2] = {" ", "},"};
 
@@ -44,8 +44,8 @@ char* eol[2] = {" ", "},"};
 
 void permute(long* a, int c, seed_t* seed) {
   int i;
-  static DSS_HUGE source;
-  static long temp;
+  DSS_HUGE source;
+  long temp;
 
   if (a != reinterpret_cast<long*>(NULL)) {
     for (i = 0; i < c; i++) {
@@ -59,17 +59,18 @@ void permute(long* a, int c, seed_t* seed) {
   return;
 }
 
-void permute_dist(distribution* d, seed_t* seed) {
+void permute_dist(distribution* d, seed_t* seed, DBGenContext* ctx) {
   int i;
 
   if (d != NULL) {
-    if (d->permute == reinterpret_cast<long*>(NULL)) {
-      d->permute = reinterpret_cast<long*>(malloc(sizeof(long) * DIST_SIZE(d)));
-      MALLOC_CHECK(d->permute);
+    if (ctx->permute == reinterpret_cast<long*>(NULL)) {
+      ctx->permute =
+          reinterpret_cast<long*>(malloc(sizeof(long) * DIST_SIZE(d)));
+      MALLOC_CHECK(ctx->permute);
     }
     for (i = 0; i < DIST_SIZE(d); i++)
-      *(d->permute + i) = i;
-    permute(d->permute, DIST_SIZE(d), seed);
+      *(ctx->permute + i) = i;
+    permute(ctx->permute, DIST_SIZE(d), seed);
   } else
     INTERNAL_ERROR("Bad call to permute_dist");
 
diff --git a/velox/type/CMakeLists.txt b/velox/type/CMakeLists.txt
index d489c611024..5db3fd476a8 100644
--- a/velox/type/CMakeLists.txt
+++ b/velox/type/CMakeLists.txt
@@ -15,12 +15,12 @@ if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
 endif()
 
-add_subdirectory(parser)
 add_subdirectory(tz)
 add_subdirectory(fbhive)
 
 velox_add_library(
   velox_type
+  CastRegistry.cpp
   Conversions.cpp
   DecimalUtil.cpp
   Filter.cpp
@@ -29,6 +29,7 @@ velox_add_library(
   StringView.cpp
   StringView.h
   Subfield.cpp
+  Time.cpp
   Timestamp.cpp
   TimestampConversion.cpp
   Tokenizer.cpp
@@ -37,6 +38,32 @@ velox_add_library(
   TypeEncodingUtil.cpp
   TypeUtil.cpp
   Variant.cpp
+  WideRangeDateConversion.cpp
+  HEADERS
+  CastRegistry.h
+  CastRule.h
+  Conversions.h
+  CppToType.h
+  DecimalUtil.h
+  FastDate.h
+  Filter.h
+  FloatingPointUtil.h
+  HugeInt.h
+  OpaqueCustomTypes.h
+  SimpleFunctionApi.h
+  Subfield.h
+  Time.h
+  Timestamp.h
+  TimestampConversion.h
+  Tokenizer.h
+  Tree.h
+  Type.h
+  TypeCoercer.h
+  TypeEncodingUtil.h
+  TypeSerde.h
+  TypeUtil.h
+  Variant.h
+  WideRangeDateConversion.h
 )
 
 velox_link_libraries(
diff --git a/velox/type/CastRegistry.cpp b/velox/type/CastRegistry.cpp
new file mode 100644
index 00000000000..3a18e94eaac
--- /dev/null
+++ b/velox/type/CastRegistry.cpp
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/type/CastRegistry.h"
+
+namespace facebook::velox {
+
+// static
+CastRulesRegistry& CastRulesRegistry::instance() {
+  static CastRulesRegistry registry;
+  return registry;
+}
+
+void CastRulesRegistry::registerCastRules(const std::vector<CastRule>& rules) {
+  auto lockedRules = rules_.wlock();
+
+  for (const auto& rule : rules) {
+    auto key = std::make_pair(rule.fromType, rule.toType);
+
+    auto it = lockedRules->find(key);
+    if (it != lockedRules->end()) {
+      VELOX_CHECK(
+          it->second == rule,
+          "Conflicting CastRule for {} -> {}: existing={}, new={}",
+          rule.fromType,
+          rule.toType,
+          it->second.toString(),
+          rule.toString());
+      continue;
+    }
+
+    (*lockedRules)[key] = rule;
+  }
+}
+
+void CastRulesRegistry::unregisterCastRules(const std::string& typeName) {
+  auto lockedRules = rules_.wlock();
+
+  for (auto it = lockedRules->begin(); it != lockedRules->end();) {
+    if (it->second.fromType == typeName || it->second.toType == typeName) {
+      it = lockedRules->erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
+bool CastRulesRegistry::canCast(const TypePtr& fromType, const TypePtr& toType)
+    const {
+  return castCostImpl(fromType, toType, /*requireImplicit=*/false).has_value();
+}
+
+std::optional<int32_t> CastRulesRegistry::canCoerce(
+    const TypePtr& fromType,
+    const TypePtr& toType) const {
+  return castCostImpl(fromType, toType, /*requireImplicit=*/true);
+}
+
+std::optional<int32_t> CastRulesRegistry::castCostImpl(
+    const TypePtr& fromType,
+    const TypePtr& toType,
+    bool requireImplicit) const {
+  VELOX_CHECK_NOT_NULL(fromType, "fromType must not be null");
+  VELOX_CHECK_NOT_NULL(toType, "toType must not be null");
+
+  // Same type is always allowed with zero cost.
+  if (fromType->equivalent(*toType)) {
+    return 0;
+  }
+
+  const auto fromName = fromType->name();
+  const auto toName = toType->name();
+
+  // Try direct rule lookup first. This handles primitives and custom types
+  // including those with children like IPPREFIX (which extends RowType).
+  auto rule = findRule(fromName, toName);
+  if (rule) {
+    if (requireImplicit && !rule->implicitAllowed) {
+      return std::nullopt;
+    }
+    if (rule->validator && !rule->validator(fromType, toType)) {
+      return std::nullopt;
+    }
+    return requireImplicit ? rule->cost : 0;
+  }
+
+  // No explicit rule. For container types (ARRAY, MAP, ROW) with the same
+  // base type, recursively check children and sum costs.
+  if (fromName == toName && fromType->size() > 0) {
+    if (fromType->size() != toType->size()) {
+      return std::nullopt;
+    }
+    int32_t totalCost = 0;
+    for (auto i = 0; i < fromType->size(); ++i) {
+      auto childCost = castCostImpl(
+          fromType->childAt(i), toType->childAt(i), requireImplicit);
+      if (!childCost) {
+        return std::nullopt;
+      }
+      totalCost += *childCost;
+    }
+    return totalCost;
+  }
+
+  // Different base types with children — not supported.
+  return std::nullopt;
+}
+
+std::optional<CastRule> CastRulesRegistry::findRule(
+    const std::string& fromTypeName,
+    const std::string& toTypeName) const {
+  auto lockedRules = rules_.rlock();
+  auto it = lockedRules->find(std::make_pair(fromTypeName, toTypeName));
+  if (it == lockedRules->end()) {
+    return std::nullopt;
+  }
+  return it->second;
+}
+
+void CastRulesRegistry::clear() {
+  rules_.wlock()->clear();
+}
+
+void registerCastRules(const std::vector<CastRule>& rules) {
+  for (const auto& rule : rules) {
+    // At least one side must be a registered custom type with a CastOperator,
+    // otherwise the cast has no execution path.
+    VELOX_CHECK(
+        getCustomTypeCastOperator(rule.fromType) != nullptr ||
+            getCustomTypeCastOperator(rule.toType) != nullptr,
+        "CastRule {} -> {} requires at least one side to be a registered "
+        "custom type with a CastOperator",
+        rule.fromType,
+        rule.toType);
+  }
+  CastRulesRegistry::instance().registerCastRules(rules);
+}
+
+void unregisterCastRules(const std::string& typeName) {
+  CastRulesRegistry::instance().unregisterCastRules(typeName);
+}
+
+} // namespace facebook::velox
diff --git a/velox/type/CastRegistry.h b/velox/type/CastRegistry.h
new file mode 100644
index 00000000000..9289717a593
--- /dev/null
+++ b/velox/type/CastRegistry.h
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include <folly/Hash.h>
+#include <folly/Synchronized.h>
+
+#include "velox/type/CastRule.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+
+/// Registry for cast rules between types. Provides lookup for determining
+/// whether casts are supported and whether they can be implicit (coercible).
+///
+/// Rules are registered via the registerCastRules() free function, typically
+/// called alongside registerCustomType() in register*Type() functions.
+/// This keeps rules co-located with the type while storing them in a global
+/// registry for centralized querying.
+class CastRulesRegistry {
+ public:
+  static CastRulesRegistry& instance();
+
+  /// Register cast rules. Rules are validated for duplicates — if a rule
+  /// for the same (fromType, toType) pair already exists, it must be
+  /// identical, otherwise registration fails.
+  void registerCastRules(const std::vector<CastRule>& rules);
+
+  /// Unregister all rules involving the given type name.
+  void unregisterCastRules(const std::string& typeName);
+
+  /// Check if cast is supported (explicit or implicit). Handles container
+  /// types (ARRAY, MAP, ROW) by recursively checking children.
+  bool canCast(const TypePtr& fromType, const TypePtr& toType) const;
+
+  /// Check if implicit coercion is allowed. Returns the coercion cost if
+  /// allowed, or std::nullopt if not. For container types (ARRAY, MAP, ROW),
+  /// returns the sum of children coercion costs.
+  std::optional<int32_t> canCoerce(
+      const TypePtr& fromType,
+      const TypePtr& toType) const;
+
+  /// Clear all registered rules. Used for testing.
+  void clear();
+
+ private:
+  CastRulesRegistry() = default;
+
+  // Unified implementation. When requireImplicit is true, returns the cost
+  // of implicit coercion. When false, returns 0 for any supported cast.
+  // Returns nullopt if the cast/coercion is not supported.
+  std::optional<int32_t> castCostImpl(
+      const TypePtr& fromType,
+      const TypePtr& toType,
+      bool requireImplicit) const;
+
+  std::optional<CastRule> findRule(
+      const std::string& fromTypeName,
+      const std::string& toTypeName) const;
+
+  struct PairHash {
+    size_t operator()(const std::pair<std::string, std::string>& p) const {
+      return folly::hash::hash_combine(
+          std::hash<std::string>{}(p.first),
+          std::hash<std::string>{}(p.second));
+    }
+  };
+
+  // Maps (fromType, toType) pairs to their cast rules.
+  folly::Synchronized<std::unordered_map<
+      std::pair<std::string, std::string>,
+      CastRule,
+      PairHash>>
+      rules_;
+};
+
+/// Register cast rules for custom types. Call this after registerCustomType()
+/// in register*Type() functions. Validates that at least one type in each rule
+/// has a registered CastOperator.
+///
+/// Example:
+///   registerCastRules({
+///       {"TIMESTAMP", "TIMESTAMP WITH TIME ZONE", true},
+///       {"DATE", "TIMESTAMP WITH TIME ZONE", true},
+///   });
+void registerCastRules(const std::vector<CastRule>& rules);
+
+/// Unregister all cast rules involving the given type name.
+void unregisterCastRules(const std::string& typeName);
+
+} // namespace facebook::velox
diff --git a/velox/type/CastRule.h b/velox/type/CastRule.h
new file mode 100644
index 00000000000..f1925fd7588
--- /dev/null
+++ b/velox/type/CastRule.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <fmt/format.h>
+
+#include <functional>
+#include <memory>
+#include <string>
+
+namespace facebook::velox {
+
+class Type;
+using TypePtr = std::shared_ptr<const Type>;
+
+/// Optional validator for type-specific compatibility checks
+/// (e.g., DECIMAL precision/scale).
+using CastValidator =
+    std::function<bool(const TypePtr& from, const TypePtr& to)>;
+
+/// Represents a cast rule between two types.
+struct CastRule {
+  /// Source type name (e.g., "BIGINT", "TIMESTAMP").
+  std::string fromType;
+
+  /// Target type name (e.g., "DOUBLE", "VARCHAR").
+  std::string toType;
+
+  /// If true, cast can happen implicitly during type coercion.
+  bool implicitAllowed{false};
+
+  /// Cost of this cast for overload resolution. Lower cost is preferred.
+  /// Built-in coercions use incrementing costs (e.g., TINYINT->SMALLINT=1,
+  /// TINYINT->INTEGER=2). Custom type rules should use costs that make
+  /// sense relative to built-in costs.
+  int32_t cost{1};
+
+  /// Optional validator for parameter-aware type checks.
+  CastValidator validator{};
+
+  /// Compare rules by type names, implicitAllowed, and cost. Excludes
+  /// 'validator' because std::function has no meaningful equality semantics.
+  bool operator==(const CastRule& other) const {
+    return fromType == other.fromType && toType == other.toType &&
+        implicitAllowed == other.implicitAllowed && cost == other.cost;
+  }
+
+  std::string toString() const {
+    return fmt::format(
+        "CastRule({} -> {}, implicit={}, cost={}, hasValidator={})",
+        fromType,
+        toType,
+        implicitAllowed,
+        cost,
+        validator != nullptr);
+  }
+};
+
+} // namespace facebook::velox
diff --git a/velox/type/Conversions.h b/velox/type/Conversions.h
index b0c175a9fdd..a4d92453f6f 100644
--- a/velox/type/Conversions.h
+++ b/velox/type/Conversions.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <fmt/compile.h>
 #include <folly/Conv.h>
 #include <folly/Expected.h>
 #include <cctype>
@@ -24,6 +25,7 @@
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/Status.h"
 #include "velox/type/CppToType.h"
+#include "velox/type/StringView.h"
 #include "velox/type/TimestampConversion.h"
 #include "velox/type/Type.h"
 
@@ -127,8 +129,9 @@ Expected<bool> castToBoolean(const char* data, size_t len) {
     }
   }
 
-  return folly::makeUnexpected(Status::UserError(
-      "Cannot cast {} to BOOLEAN", std::string_view(data, len)));
+  return folly::makeUnexpected(
+      Status::UserError(
+          "Cannot cast {} to BOOLEAN", std::string_view(data, len)));
 }
 
 namespace detail {
@@ -140,8 +143,9 @@ Expected<T> callFollyTo(const F& v) {
     if (threadSkipErrorDetails()) {
       return folly::makeUnexpected(Status::UserError());
     }
-    return folly::makeUnexpected(Status::UserError(
-        "{}", folly::makeConversionError(result.error(), "").what()));
+    return folly::makeUnexpected(
+        Status::UserError(
+            "{}", folly::makeConversionError(result.error(), "").what()));
   }
 
   return result.value();
@@ -164,7 +168,7 @@ struct Converter<TypeKind::BOOLEAN, void, TPolicy> {
     return detail::callFollyTo<T>(v);
   }
 
-  static Expected<T> tryCast(folly::StringPiece v) {
+  static Expected<T> tryCast(std::string_view v) {
     return castToBoolean<TPolicy>(v.data(), v.size());
   }
 
@@ -235,8 +239,9 @@ struct Converter<TypeKind::BOOLEAN, void, TPolicy> {
   }
 
   static Expected<T> tryCast(const Timestamp&) {
-    return folly::makeUnexpected(Status::UserError(
-        "Conversion of Timestamp to Boolean is not supported"));
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Conversion of Timestamp to Boolean is not supported"));
   }
 };
 
@@ -265,14 +270,15 @@ struct Converter<
     return folly::makeUnexpected(Status::UserError(kErrorMessage));
   }
 
-  static Expected<T> convertStringToInt(const folly::StringPiece v) {
+  static Expected<T> convertStringToInt(const std::string_view v) {
     // Handling integer target cases
     T result = 0;
     int index = 0;
     int len = v.size();
     if (len == 0) {
-      return folly::makeUnexpected(Status::UserError(
-          "Cannot cast an empty string to an integral value."));
+      return folly::makeUnexpected(
+          Status::UserError(
+              "Cannot cast an empty string to an integral value."));
     }
 
     // Setting negative flag
@@ -281,8 +287,9 @@ struct Converter<
     bool decimalPoint = false;
     if (v[0] == '-' || v[0] == '+') {
       if (len == 1) {
-        return folly::makeUnexpected(Status::UserError(
-            "Cannot cast an '{}' string to an integral value.", v[0]));
+        return folly::makeUnexpected(
+            Status::UserError(
+                "Cannot cast an '{}' string to an integral value.", v[0]));
       }
       negative = v[0] == '-';
       index = 1;
@@ -328,7 +335,7 @@ struct Converter<
     return result;
   }
 
-  static Expected<T> tryCast(folly::StringPiece v) {
+  static Expected<T> tryCast(std::string_view v) {
     if constexpr (TPolicy::truncate) {
       return convertStringToInt(v);
     } else {
@@ -339,7 +346,7 @@ struct Converter<
 
   static Expected<T> tryCast(const StringView& v) {
     if constexpr (TPolicy::truncate) {
-      return convertStringToInt(folly::StringPiece(v));
+      return convertStringToInt(std::string_view(v));
     } else {
       auto trimmed = trimWhiteSpace(v.data(), v.size());
       return detail::callFollyTo<T>(trimmed);
@@ -500,12 +507,12 @@ struct Converter<
     return detail::callFollyTo<T>(v);
   }
 
-  static Expected<T> tryCast(folly::StringPiece v) {
-    return tryCast<folly::StringPiece>(v);
+  static Expected<T> tryCast(std::string_view v) {
+    return tryCast<std::string_view>(v);
   }
 
   static Expected<T> tryCast(const StringView& v) {
-    return tryCast<folly::StringPiece>(folly::StringPiece(v));
+    return tryCast<std::string_view>(std::string_view(v));
   }
 
   static Expected<T> tryCast(const std::string& v) {
@@ -555,8 +562,9 @@ struct Converter<
   }
 
   static Expected<T> tryCast(const Timestamp&) {
-    return folly::makeUnexpected(Status::UserError(
-        "Conversion of Timestamp to Real or Double is not supported"));
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Conversion of Timestamp to Real or Double is not supported"));
   }
 };
 
@@ -590,14 +598,18 @@ struct Converter<TypeKind::VARCHAR, void, TPolicy> {
       }
       if ((val > -10'000'000 && val <= -0.001) ||
           (val >= 0.001 && val < 10'000'000) || val == 0.0) {
-        auto str = fmt::format("{}", val);
+        auto str = fmt::format(FMT_COMPILE("{}"), val);
         normalizeStandardNotation(str);
         return str;
       }
       // Precision of float is at most 8 significant decimal digits. Precision
       // of double is at most 17 significant decimal digits.
-      auto str =
-          fmt::format(std::is_same_v<T, float> ? "{:.7E}" : "{:.16E}", val);
+      std::string str;
+      if constexpr (std::is_same_v<T, float>) {
+        str = fmt::format(FMT_COMPILE("{:.7E}"), val);
+      } else {
+        str = fmt::format(FMT_COMPILE("{:.16E}"), val);
+      }
       normalizeScientificNotation(str);
       return str;
     }
@@ -680,7 +692,7 @@ struct Converter<TypeKind::TIMESTAMP, void, TPolicy> {
         Status::UserError("Conversion to Timestamp is not supported"));
   }
 
-  static Expected<Timestamp> tryCast(folly::StringPiece v) {
+  static Expected<Timestamp> tryCast(std::string_view v) {
     return fromTimestampString(
         v.data(), v.size(), TimestampParseMode::kPrestoCast);
   }
diff --git a/velox/type/CppToType.h b/velox/type/CppToType.h
index f8d3c6d821f..e52125aa8dc 100644
--- a/velox/type/CppToType.h
+++ b/velox/type/CppToType.h
@@ -91,6 +91,20 @@ struct CppToType<double> : public CppToTypeBase<TypeKind::DOUBLE> {};
 template <>
 struct CppToType<Timestamp> : public CppToTypeBase<TypeKind::TIMESTAMP> {};
 
+template <>
+struct CppToType<Time> : public CppToTypeBase<TypeKind::BIGINT> {
+  static auto create() {
+    return TIME();
+  }
+};
+
+template <>
+struct CppToType<TimeMicroUtc> : public CppToTypeBase<TypeKind::BIGINT> {
+  static auto create() {
+    return TIME_MICRO_UTC();
+  }
+};
+
 // TODO: maybe do something smarter than just matching any shared_ptr, e.g. we
 // can declare "registered" types explicitly
 template <typename T>
diff --git a/velox/type/DecimalUtil.cpp b/velox/type/DecimalUtil.cpp
index b78c6f6a4cb..057eacd38fd 100644
--- a/velox/type/DecimalUtil.cpp
+++ b/velox/type/DecimalUtil.cpp
@@ -20,9 +20,7 @@
 namespace facebook::velox {
 namespace {
 std::string formatDecimal(uint8_t scale, int128_t unscaledValue) {
-  VELOX_DCHECK_GE(scale, 0);
-  VELOX_DCHECK_LT(
-      static_cast<size_t>(scale), sizeof(DecimalUtil::kPowersOfTen));
+  VELOX_DCHECK_LT(scale, std::size(DecimalUtil::kPowersOfTen));
   const bool isFraction = (scale > 0);
   if (unscaledValue == 0) {
     if (isFraction) {
@@ -226,7 +224,7 @@ parseDecimalComponents(const char* s, size_t size, DecimalComponents& out) {
             "Non-digit character is not allowed in the exponent part.");
       }
     }
-    out.exponent = folly::to<int32_t>(folly::StringPiece(s + pos, size - pos));
+    out.exponent = folly::to<int32_t>(std::string_view(s + pos, size - pos));
     return Status::OK();
   }
   return pos == size ? Status::OK() : Status::UserError("Chars are invalid.");
@@ -238,7 +236,7 @@ parseDecimalComponents(const char* s, size_t size, DecimalComponents& out) {
 Status parseHugeInt(const DecimalComponents& decimalComponents, int128_t& out) {
   // Parse the whole digits.
   if (decimalComponents.wholeDigits.size() > 0) {
-    const auto tryValue = folly::tryTo<int128_t>(folly::StringPiece(
+    const auto tryValue = folly::tryTo<int128_t>(std::string_view(
         decimalComponents.wholeDigits.data(),
         decimalComponents.wholeDigits.size()));
     if (tryValue.hasError()) {
@@ -256,7 +254,7 @@ Status parseHugeInt(const DecimalComponents& decimalComponents, int128_t& out) {
       return Status::UserError("Value too large.");
     }
     const auto tryValue = folly::tryTo<int128_t>(
-        folly::StringPiece(decimalComponents.fractionalDigits.data(), length));
+        std::string_view(decimalComponents.fractionalDigits.data(), length));
     if (tryValue.hasError()) {
       return Status::UserError("Value too large.");
     }
diff --git a/velox/type/DecimalUtil.h b/velox/type/DecimalUtil.h
index 581c776f7c9..89bdddafc59 100644
--- a/velox/type/DecimalUtil.h
+++ b/velox/type/DecimalUtil.h
@@ -83,6 +83,9 @@ class DecimalUtil {
   static constexpr int128_t kShortDecimalMax =
       kPowersOfTen[ShortDecimalType::kMaxPrecision] - 1;
 
+  /// Scale threshold for scientific notation.
+  static constexpr int32_t kMinScientificNotationScale = 6;
+
   static constexpr uint64_t kInt64Mask = ~(static_cast<uint64_t>(1) << 63);
   static constexpr uint128_t kInt128Mask = (static_cast<uint128_t>(1) << 127);
 
@@ -335,17 +338,34 @@ class DecimalUtil {
   /// @param scale The scale of decimal.
   /// @param maxSize The estimated max size of string.
   /// @param startPosition The start position to write from.
-  /// @return The actual size of the string.
+  /// @param isScientific Whether to format small magnitude decimals using
+  /// scientific notation (Spark-compatible). When true, absolute values less
+  /// than 1e-6 are formatted in scientific notation. For example:
+  /// - With scale=20 and value=1: "1E-20" (scientific) vs
+  /// "0.00000000000000000001" (normal)
+  /// @return The number of characters written starting from startPosition.
   template <typename T>
   static size_t castToString(
       T unscaledValue,
       int32_t scale,
       int32_t maxSize,
-      char* const startPosition) {
+      char* const startPosition,
+      bool isScientific = false) {
     char* writePosition = startPosition;
     if (unscaledValue == 0) {
       *writePosition++ = '0';
-      if (scale > 0) {
+      if (isScientific && scale > kMinScientificNotationScale) {
+        *writePosition++ = 'E';
+        auto exp =
+            std::to_chars(writePosition, startPosition + maxSize, -scale);
+        VELOX_DCHECK_EQ(
+            exp.ec,
+            std::errc(),
+            "Failed to cast exponent value to varchar: {}",
+            std::make_error_code(exp.ec).message());
+        VELOX_DCHECK_LE(exp.ptr - startPosition, maxSize);
+        writePosition = exp.ptr;
+      } else if (scale > 0) {
         *writePosition++ = '.';
         // Append trailing zeros.
         std::memset(writePosition, '0', scale);
@@ -356,6 +376,43 @@ class DecimalUtil {
         *writePosition++ = '-';
         unscaledValue = -unscaledValue;
       }
+      if (isScientific) {
+        if (scale >= kMinScientificNotationScale &&
+            unscaledValue < DecimalUtil::kPowersOfTen
+                                [scale - kMinScientificNotationScale]) {
+          // Use scientific notation if the absolute value is less than 1e-6.
+          // This is consistent with Spark's behavior.
+          const auto digits = countDigits(unscaledValue);
+          auto coefficientBuf = std::vector<char>(digits);
+          const auto coefficient = std::to_chars(
+              coefficientBuf.data(),
+              coefficientBuf.data() + digits,
+              unscaledValue);
+          VELOX_DCHECK_EQ(
+              coefficient.ec,
+              std::errc(),
+              "Failed to cast coefficient to varchar.");
+          VELOX_DCHECK_EQ(coefficient.ptr, coefficientBuf.data() + digits);
+          *writePosition++ = coefficientBuf[0];
+          if (coefficient.ptr - coefficientBuf.data() > 1) {
+            *writePosition++ = '.';
+            size_t toCopy = digits - 1;
+            std::memcpy(writePosition, coefficientBuf.data() + 1, toCopy);
+            writePosition += toCopy;
+          }
+          *writePosition++ = 'E';
+          const auto adjusted = digits - 1 - scale;
+          auto exp = std::to_chars(
+              writePosition, writePosition + maxSize - digits - 2, adjusted);
+          VELOX_DCHECK_EQ(
+              exp.ec,
+              std::errc(),
+              "Failed to cast exponent value to varchar: {}",
+              std::make_error_code(exp.ec).message());
+          writePosition = exp.ptr;
+          return writePosition - startPosition;
+        }
+      }
       auto [position, errorCode] = std::to_chars(
           writePosition,
           writePosition + maxSize,
diff --git a/velox/type/FastDate.h b/velox/type/FastDate.h
new file mode 100644
index 00000000000..30b15a600fd
--- /dev/null
+++ b/velox/type/FastDate.h
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+// The Gregorian-date algorithms below are adapted from supplementary code
+// to the paper:
+//
+//   Cassio Neri and Lorenz Schneider,
+//   "Euclidean Affine Functions and their Application to Calendar
+//   Algorithms" (2022).
+//
+// Original source:
+//   https://github.com/benjoffe/fast-date-benchmarks/blob/main/algorithms/neri_schneider.hpp
+//   (which mirrors the reference implementation from the paper)
+//
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2022 Cassio Neri <cassio.neri@gmail.com>
+// SPDX-FileCopyrightText: 2022 Lorenz Schneider <schneider@em-lyon.com>
+
+#include <cstdint>
+
+namespace facebook::velox {
+
+/// Result of converting an epoch-day to a Gregorian (year, month, day).
+/// Year is signed (proleptic Gregorian), month is 1-12, day is 1-31.
+struct YearMonthDay {
+  int32_t year;
+  uint32_t month;
+  uint32_t day;
+};
+
+namespace fast_date {
+
+// Era shift used by the Neri-Schneider algorithm. The paper calls this
+// `s`; 82 was chosen so the supported range covers everything Velox can
+// natively store.
+inline constexpr uint32_t kEraShift = 82u;
+
+// Epoch-day offset (paper's `K`): added to dayNumber so the algorithm
+// operates on a non-negative integer for the entire supported range.
+inline constexpr uint32_t kEpochOffset = 719468u + 146097u * kEraShift;
+
+// Year offset (paper's `L`): subtracted from the algorithm's internal
+// "year-within-era" representation to recover a real proleptic-Gregorian
+// year.
+inline constexpr uint32_t kYearOffset = 400u * kEraShift;
+
+// Supported input ranges (computed from the algorithm's affine arithmetic).
+//
+// Note on the boundary years: the algorithm is parameterized from March,
+// not January. Its exact range is [Mar 1 kYearMin, Feb 28 kYearMax], not
+// [Jan 1 kYearMin, Dec 31 kYearMax]. For the inverse direction, callers
+// should restrict to year ∈ (kYearMin, kYearMax) — strictly excluding the
+// boundary years — to avoid the month-dependent wrinkle. The forward
+// direction has no such caveat because rata-die is monotonic.
+inline constexpr int32_t kRataDieMin = -12'699'422; // 1 Mar -32800
+inline constexpr int32_t kRataDieMax = 1'061'042'401; // 28 Feb 2906945
+inline constexpr int32_t kYearMin = -32800;
+inline constexpr int32_t kYearMax = 2'906'945;
+
+} // namespace fast_date
+
+/// Converts an epoch-day count (days since 1970-01-01) to the corresponding
+/// proleptic Gregorian (year, month, day). Exact for any dayNumber in
+/// [fast_date::kRataDieMin, fast_date::kRataDieMax]; results outside that
+/// range are undefined. The supported range covers ~3 million years
+/// centered on the epoch — vastly wider than any practical Velox DATE.
+///
+/// Variable mapping (Neri-Schneider 2022, §5):
+///   Paper | Local                | Meaning
+///   ------|----------------------|---------------------------------------
+///   N     | shiftedDay           | day-since-epoch rebased to be non-neg
+///   N_1   | centuryNumerator     | numerator for the century division
+///   C     | century              | century within the era
+///   N_C   | dayWithinCentury     | day within the century
+///   N_2   | yearNumerator        | numerator for year-within-century
+///   P_2   | yearProduct          | 64-bit multiply-shift reciprocal
+///   Z     | yearWithinCentury    | year within the century
+///   N_Y   | dayWithinYear        | day within the (March-based) year
+///   Y     | yearWithinEra        | year within the era
+///   N_3   | monthNumerator       | numerator for the month/day division
+///   M     | monthFromMarch       | month index counted from March
+///   D     | dayOfMonthZeroBased  | zero-based day-of-month
+///   J     | janFebAdjust         | 1 if Jan/Feb of next calendar year
+inline YearMonthDay daysToYmd(int32_t dayNumber) {
+  using namespace fast_date;
+  const uint32_t shiftedDay = static_cast<uint32_t>(dayNumber) + kEpochOffset;
+  // Century.
+  const uint32_t centuryNumerator = 4u * shiftedDay + 3u;
+  const uint32_t century = centuryNumerator / 146097u;
+  const uint32_t dayWithinCentury = centuryNumerator % 146097u / 4u;
+  // Year within century.
+  const uint32_t yearNumerator = 4u * dayWithinCentury + 3u;
+  const uint64_t yearProduct = uint64_t{2939745u} * yearNumerator;
+  const uint32_t yearWithinCentury = static_cast<uint32_t>(yearProduct >> 32);
+  const uint32_t dayWithinYear =
+      static_cast<uint32_t>(yearProduct & 0xFFFF'FFFFull) / 2939745u / 4u;
+  const uint32_t yearWithinEra = 100u * century + yearWithinCentury;
+  // Month and day within year (year here starts at March).
+  const uint32_t monthNumerator = 2141u * dayWithinYear + 197913u;
+  const uint32_t monthFromMarch = monthNumerator / 65536u;
+  const uint32_t dayOfMonthZeroBased = monthNumerator % 65536u / 2141u;
+  // Years are counted from March, so January/February belong to the next
+  // calendar year; correct that here.
+  const uint32_t janFebAdjust = dayWithinYear >= 306u ? 1u : 0u;
+  YearMonthDay out;
+  out.year = static_cast<int32_t>(yearWithinEra - kYearOffset) +
+      static_cast<int32_t>(janFebAdjust);
+  out.month = janFebAdjust ? monthFromMarch - 12u : monthFromMarch;
+  out.day = dayOfMonthZeroBased + 1u;
+  return out;
+}
+
+/// Inverse of daysToYmd. Safe for year ∈ (fast_date::kYearMin,
+/// fast_date::kYearMax) — strictly between the two boundaries — for any
+/// month and day. At the boundary years themselves, only the algorithm's
+/// March-based partial year is exact (see the constants' comment); use
+/// WideRangeDateConversion::daysSinceEpochFromDate for those instead.
+///
+/// Variable mapping (Neri-Schneider 2022, §6):
+///   Paper  | Local                | Meaning
+///   -------|----------------------|--------------------------------------
+///   J      | janFebAdjust         | 1 if input month is Jan/Feb
+///   Y      | shiftedYear          | year within the era after Jan/Feb fix
+///   M      | monthFromMarch       | month index counted from March
+///   D      | dayOfMonthZeroBased  | zero-based day-of-month
+///   C      | century              | century within the era
+///   y_star | yearDays             | days from era start to year start
+///   m_star | monthDays            | days from year start to month start
+///   N      | shiftedRataDie       | shifted day-since-epoch (pre-offset)
+inline int32_t ymdToDays(int32_t year, uint32_t month, uint32_t day) {
+  using namespace fast_date;
+  const uint32_t janFebAdjust = month <= 2u ? 1u : 0u;
+  const uint32_t shiftedYear =
+      (static_cast<uint32_t>(year) + kYearOffset) - janFebAdjust;
+  const uint32_t monthFromMarch = janFebAdjust ? month + 12u : month;
+  const uint32_t dayOfMonthZeroBased = day - 1u;
+  const uint32_t century = shiftedYear / 100u;
+  const uint32_t yearDays = 1461u * shiftedYear / 4u - century + century / 4u;
+  const uint32_t monthDays = (979u * monthFromMarch - 2919u) / 32u;
+  const uint32_t shiftedRataDie = yearDays + monthDays + dayOfMonthZeroBased;
+  return static_cast<int32_t>(shiftedRataDie - kEpochOffset);
+}
+
+} // namespace facebook::velox
diff --git a/velox/type/Filter.cpp b/velox/type/Filter.cpp
index dfa059a94b1..7a978705e20 100644
--- a/velox/type/Filter.cpp
+++ b/velox/type/Filter.cpp
@@ -20,124 +20,57 @@
 #include <set>
 #include <string>
 
-#include "velox/common/base/Exceptions.h"
 #include "velox/type/Filter.h"
 
+#include "velox/common/EnumDefine.h"
+
 namespace facebook::velox::common {
 
-std::string Filter::toString() const {
-  std::string strKind;
-  switch (kind_) {
-    case FilterKind::kAlwaysFalse:
-      strKind = "AlwaysFalse";
-      break;
-    case FilterKind::kAlwaysTrue:
-      strKind = "AlwaysTrue";
-      break;
-    case FilterKind::kIsNull:
-      strKind = "IsNull";
-      break;
-    case FilterKind::kIsNotNull:
-      strKind = "IsNotNull";
-      break;
-    case FilterKind::kBoolValue:
-      strKind = "BoolValue";
-      break;
-    case FilterKind::kBigintRange:
-      strKind = "BigintRange";
-      break;
-    case FilterKind::kNegatedBigintRange:
-      strKind = "NegatedBigintRange";
-      break;
-    case FilterKind::kBigintValuesUsingHashTable:
-      strKind = "BigintValuesUsingHashTable";
-      break;
-    case FilterKind::kBigintValuesUsingBitmask:
-      strKind = "BigintValuesUsingBitmask";
-      break;
-    case FilterKind::kNegatedBigintValuesUsingHashTable:
-      strKind = "NegatedBigintValuesUsingHashTable";
-      break;
-    case FilterKind::kNegatedBigintValuesUsingBitmask:
-      strKind = "NegatedBigintValuesUsingBitmask";
-      break;
-    case FilterKind::kDoubleRange:
-      strKind = "DoubleRange";
-      break;
-    case FilterKind::kFloatRange:
-      strKind = "FloatRange";
-      break;
-    case FilterKind::kBytesRange:
-      strKind = "BytesRange";
-      break;
-    case FilterKind::kNegatedBytesRange:
-      strKind = "NegatedBytesRange";
-      break;
-    case FilterKind::kBytesValues:
-      strKind = "BytesValues";
-      break;
-    case FilterKind::kNegatedBytesValues:
-      strKind = "NegatedBytesValues";
-      break;
-    case FilterKind::kBigintMultiRange:
-      strKind = "BigintMultiRange";
-      break;
-    case FilterKind::kMultiRange:
-      strKind = "MultiRange";
-      break;
-    case FilterKind::kHugeintRange:
-      strKind = "HugeintRange";
-      break;
-    case FilterKind::kTimestampRange:
-      strKind = "TimestampRange";
-      break;
-    case FilterKind::kHugeintValuesUsingHashTable:
-      strKind = "HugeintValuesUsingHashTable";
-      break;
+namespace {
+const auto& filterKindNames() {
+  static const folly::F14FastMap<FilterKind, std::string_view> kNames = {
+      {FilterKind::kAlwaysFalse, "AlwaysFalse"},
+      {FilterKind::kAlwaysTrue, "AlwaysTrue"},
+      {FilterKind::kIsNull, "IsNull"},
+      {FilterKind::kIsNotNull, "IsNotNull"},
+      {FilterKind::kBoolValue, "BoolValue"},
+      {FilterKind::kBigintRange, "BigintRange"},
+      {FilterKind::kNegatedBigintRange, "NegatedBigintRange"},
+      {FilterKind::kBigintValuesUsingHashTable, "BigintValuesUsingHashTable"},
+      {FilterKind::kBigintValuesUsingBitmask, "BigintValuesUsingBitmask"},
+      {FilterKind::kNegatedBigintValuesUsingHashTable,
+       "NegatedBigintValuesUsingHashTable"},
+      {FilterKind::kNegatedBigintValuesUsingBitmask,
+       "NegatedBigintValuesUsingBitmask"},
+      {FilterKind::kDoubleRange, "DoubleRange"},
+      {FilterKind::kFloatRange, "FloatRange"},
+      {FilterKind::kBytesRange, "BytesRange"},
+      {FilterKind::kNegatedBytesRange, "NegatedBytesRange"},
+      {FilterKind::kBytesValues, "BytesValues"},
+      {FilterKind::kNegatedBytesValues, "NegatedBytesValues"},
+      {FilterKind::kBigintMultiRange, "BigintMultiRange"},
+      {FilterKind::kMultiRange, "MultiRange"},
+      {FilterKind::kHugeintRange, "HugeintRange"},
+      {FilterKind::kTimestampRange, "TimestampRange"},
+      {FilterKind::kHugeintValuesUsingHashTable, "HugeintValuesUsingHashTable"},
+      {FilterKind::kBigintValuesUsingBloomFilter,
+       "BigintValuesUsingBloomFilter"},
   };
+  return kNames;
+}
+} // namespace
 
+VELOX_DEFINE_ENUM_NAME(FilterKind, filterKindNames);
+
+std::string Filter::toString() const {
   return fmt::format(
       "Filter({}, {}, {})",
-      strKind,
+      kindName(),
       deterministic_ ? "deterministic" : "nondeterministic",
-      nullAllowed_ ? "null allowed" : "null not allowed");
+      nullAllowed_ ? "with nulls" : "no nulls");
 }
 
 namespace {
-std::unordered_map<FilterKind, std::string> filterKindNames() {
-  return {
-      {FilterKind::kAlwaysFalse, "kAlwaysFalse"},
-      {FilterKind::kAlwaysTrue, "kAlwaysTrue"},
-      {FilterKind::kIsNull, "kIsNull"},
-      {FilterKind::kIsNotNull, "kIsNotNull"},
-      {FilterKind::kBoolValue, "kBoolValue"},
-      {FilterKind::kBigintRange, "kBigintRange"},
-      {FilterKind::kBigintValuesUsingHashTable, "kBigintValuesUsingHashTable"},
-      {FilterKind::kBigintValuesUsingBitmask, "kBigintValuesUsingBitmask"},
-      {FilterKind::kNegatedBigintRange, "kNegatedBigintRange"},
-      {FilterKind::kNegatedBigintValuesUsingHashTable,
-       "kNegatedBigintValuesUsingHashTable"},
-      {FilterKind::kNegatedBigintValuesUsingBitmask,
-       "kNegatedBigintValuesUsingBitmask"},
-      {FilterKind::kDoubleRange, "kDoubleRange"},
-      {FilterKind::kFloatRange, "kFloatRange"},
-      {FilterKind::kBytesRange, "kBytesRange"},
-      {FilterKind::kNegatedBytesRange, "kNegatedBytesRange"},
-      {FilterKind::kBytesValues, "kBytesValues"},
-      {FilterKind::kNegatedBytesValues, "kNegatedBytesValues"},
-      {FilterKind::kBigintMultiRange, "kBigintMultiRange"},
-      {FilterKind::kMultiRange, "kMultiRange"},
-      {FilterKind::kHugeintRange, "kHugeintRange"},
-      {FilterKind::kTimestampRange, "kTimestampRange"},
-      {FilterKind::kHugeintValuesUsingHashTable,
-       "kHugeintValuesUsingHashTable"},
-  };
-}
-
-const char* filterKindName(FilterKind kind) {
-  static const auto kNames = filterKindNames();
-  return kNames.at(kind).c_str();
-}
 
 bool deserializeNullAllowed(const folly::dynamic& obj) {
   return obj["nullAllowed"].asBool();
@@ -182,6 +115,8 @@ void Filter::registerSerDe() {
       "BigintValuesUsingHashTable", BigintValuesUsingHashTable::create);
   registry.Register(
       "BigintValuesUsingBitmask", BigintValuesUsingBitmask::create);
+  registry.Register(
+      "BigintValuesUsingBloomFilter", BigintValuesUsingBloomFilter::create);
   registry.Register(
       "NegatedBigintValuesUsingHashTable",
       NegatedBigintValuesUsingHashTable::create);
@@ -201,16 +136,15 @@ void Filter::registerSerDe() {
   registry.Register("TimestampRange", TimestampRange::create);
 }
 
-folly::dynamic Filter::serializeBase(std::string_view name) const {
+folly::dynamic Filter::serializeBase() const {
   folly::dynamic obj = folly::dynamic::object;
-  obj["name"] = name;
+  obj["name"] = kindName();
   obj["nullAllowed"] = nullAllowed_;
-  obj["kind"] = filterKindName(kind_);
   return obj;
 }
 
 folly::dynamic AlwaysFalse::serialize() const {
-  return Filter::serializeBase("AlwaysFalse");
+  return Filter::serializeBase();
 }
 
 std::unique_ptr<Filter> AlwaysFalse::create(const folly::dynamic& /*obj*/) {
@@ -218,7 +152,7 @@ std::unique_ptr<Filter> AlwaysFalse::create(const folly::dynamic& /*obj*/) {
 }
 
 folly::dynamic AlwaysTrue::serialize() const {
-  return Filter::serializeBase("AlwaysTrue");
+  return Filter::serializeBase();
 }
 
 std::unique_ptr<Filter> AlwaysTrue::create(const folly::dynamic& /*obj*/) {
@@ -226,7 +160,7 @@ std::unique_ptr<Filter> AlwaysTrue::create(const folly::dynamic& /*obj*/) {
 }
 
 folly::dynamic IsNull::serialize() const {
-  return Filter::serializeBase("IsNull");
+  return Filter::serializeBase();
 }
 
 std::unique_ptr<Filter> IsNull::create(const folly::dynamic& /*obj*/) {
@@ -234,7 +168,7 @@ std::unique_ptr<Filter> IsNull::create(const folly::dynamic& /*obj*/) {
 }
 
 folly::dynamic IsNotNull::serialize() const {
-  return Filter::serializeBase("IsNotNull");
+  return Filter::serializeBase();
 }
 
 std::unique_ptr<Filter> IsNotNull::create(const folly::dynamic& /*obj*/) {
@@ -242,7 +176,7 @@ std::unique_ptr<Filter> IsNotNull::create(const folly::dynamic& /*obj*/) {
 }
 
 folly::dynamic BoolValue::serialize() const {
-  auto obj = Filter::serializeBase("BoolValue");
+  auto obj = Filter::serializeBase();
   obj["value"] = value_;
   return obj;
 }
@@ -254,13 +188,16 @@ std::unique_ptr<Filter> BoolValue::create(const folly::dynamic& obj) {
 }
 
 bool BoolValue::testingEquals(const Filter& other) const {
-  auto otherBoolValue = dynamic_cast<const BoolValue*>(&other);
-  return otherBoolValue != nullptr && Filter::testingBaseEquals(other) &&
-      (value_ == otherBoolValue->value_);
+  if (const auto* otherBoolValue =
+          Filter::testingBaseEquals<BoolValue>(other)) {
+    return value_ == otherBoolValue->value_;
+  }
+
+  return false;
 }
 
 folly::dynamic BigintRange::serialize() const {
-  auto obj = Filter::serializeBase("BigintRange");
+  auto obj = Filter::serializeBase();
   obj["lower"] = lower_;
   obj["upper"] = upper_;
   return obj;
@@ -274,14 +211,15 @@ std::unique_ptr<Filter> BigintRange::create(const folly::dynamic& obj) {
 }
 
 bool BigintRange::testingEquals(const Filter& other) const {
-  auto otherBigintRange = dynamic_cast<const BigintRange*>(&other);
-  return otherBigintRange != nullptr && Filter::testingBaseEquals(other) &&
-      (lower_ == otherBigintRange->lower_) &&
-      (upper_ == otherBigintRange->upper_);
+  if (const auto* otherRange = Filter::testingBaseEquals<BigintRange>(other)) {
+    return (lower_ == otherRange->lower_) && (upper_ == otherRange->upper_);
+  }
+
+  return false;
 }
 
 folly::dynamic NegatedBigintRange::serialize() const {
-  auto obj = Filter::serializeBase("NegatedBigintRange");
+  auto obj = Filter::serializeBase();
   obj["lower"] = nonNegated_->lower();
   obj["upper"] = nonNegated_->upper();
   return obj;
@@ -295,15 +233,16 @@ std::unique_ptr<Filter> NegatedBigintRange::create(const folly::dynamic& obj) {
 }
 
 bool NegatedBigintRange::testingEquals(const Filter& other) const {
-  auto otherNegatedBigintRange =
-      dynamic_cast<const NegatedBigintRange*>(&other);
-  return otherNegatedBigintRange != nullptr &&
-      Filter::testingBaseEquals(other) &&
-      nonNegated_->testingEquals(*(otherNegatedBigintRange->nonNegated_));
+  if (const auto* otherRange =
+          Filter::testingBaseEquals<NegatedBigintRange>(other)) {
+    return nonNegated_->testingEquals(*(otherRange->nonNegated_));
+  }
+
+  return false;
 }
 
 folly::dynamic HugeintRange::serialize() const {
-  auto obj = Filter::serializeBase("HugeintRange");
+  auto obj = Filter::serializeBase();
   obj["lower"] = std::to_string(lower_);
   obj["upper"] = std::to_string(upper_);
   return obj;
@@ -317,14 +256,15 @@ std::unique_ptr<Filter> HugeintRange::create(const folly::dynamic& obj) {
 }
 
 bool HugeintRange::testingEquals(const Filter& other) const {
-  auto otherHugeintRange = dynamic_cast<const HugeintRange*>(&other);
-  return otherHugeintRange != nullptr && Filter::testingBaseEquals(other) &&
-      lower_ == otherHugeintRange->lower_ &&
-      upper_ == otherHugeintRange->upper_;
+  if (const auto* otherRange = Filter::testingBaseEquals<HugeintRange>(other)) {
+    return lower_ == otherRange->lower_ && upper_ == otherRange->upper_;
+  }
+
+  return false;
 }
 
 folly::dynamic TimestampRange::serialize() const {
-  auto obj = Filter::serializeBase("TimestampRange");
+  auto obj = Filter::serializeBase();
   obj["lower"] = lower_.serialize();
   obj["upper"] = upper_.serialize();
   return obj;
@@ -338,14 +278,16 @@ std::unique_ptr<Filter> TimestampRange::create(const folly::dynamic& obj) {
 }
 
 bool TimestampRange::testingEquals(const Filter& other) const {
-  auto otherTimestampRange = dynamic_cast<const TimestampRange*>(&other);
-  return otherTimestampRange != nullptr && Filter::testingBaseEquals(other) &&
-      (lower_ == otherTimestampRange->lower_) &&
-      (upper_ == otherTimestampRange->upper_);
+  if (const auto* otherRange =
+          Filter::testingBaseEquals<TimestampRange>(other)) {
+    return (lower_ == otherRange->lower_) && (upper_ == otherRange->upper_);
+  }
+
+  return false;
 }
 
 folly::dynamic BigintValuesUsingHashTable::serialize() const {
-  auto obj = Filter::serializeBase("BigintValuesUsingHashTable");
+  auto obj = Filter::serializeBase();
   obj["min"] = min_;
   obj["max"] = max_;
 
@@ -370,28 +312,31 @@ std::unique_ptr<Filter> BigintValuesUsingHashTable::create(
 }
 
 bool BigintValuesUsingHashTable::testingEquals(const Filter& other) const {
-  auto otherBigintValues =
-      dynamic_cast<const BigintValuesUsingHashTable*>(&other);
-  bool res = otherBigintValues != nullptr && Filter::testingBaseEquals(other) &&
-      min_ == otherBigintValues->min_ && max_ == otherBigintValues->max_ &&
-      values_.size() == otherBigintValues->values_.size();
-
-  if (!res) {
-    return false;
-  }
+  if (const auto* otherBigintValues =
+          Filter::testingBaseEquals<BigintValuesUsingHashTable>(other)) {
+    bool res = min_ == otherBigintValues->min_ &&
+        max_ == otherBigintValues->max_ &&
+        values_.size() == otherBigintValues->values_.size();
 
-  // values_ can be compared pair-wise since they are sorted.
-  for (size_t i = 0; i < values_.size(); ++i) {
-    if (values_.at(i) != otherBigintValues->values_.at(i)) {
+    if (!res) {
       return false;
     }
+
+    // values_ can be compared pair-wise since they are sorted.
+    for (size_t i = 0; i < values_.size(); ++i) {
+      if (values_[i] != otherBigintValues->values_[i]) {
+        return false;
+      }
+    }
+
+    return true;
   }
 
-  return true;
+  return false;
 }
 
 folly::dynamic BigintValuesUsingBitmask::serialize() const {
-  auto obj = Filter::serializeBase("BigintValuesUsingBitmask");
+  auto obj = Filter::serializeBase();
   obj["min"] = min_;
   obj["max"] = max_;
 
@@ -418,27 +363,77 @@ std::unique_ptr<Filter> BigintValuesUsingBitmask::create(
 }
 
 bool BigintValuesUsingBitmask::testingEquals(const Filter& other) const {
-  auto otherBigintValues =
-      dynamic_cast<const BigintValuesUsingBitmask*>(&other);
-  bool res = otherBigintValues != nullptr && Filter::testingBaseEquals(other) &&
-      min_ == otherBigintValues->min_ && max_ == otherBigintValues->max_ &&
-      bitmask_.size() == otherBigintValues->bitmask_.size();
+  if (const auto* otherBigintValues =
+          Filter::testingBaseEquals<BigintValuesUsingBitmask>(other)) {
+    bool res = min_ == otherBigintValues->min_ &&
+        max_ == otherBigintValues->max_ &&
+        bitmask_.size() == otherBigintValues->bitmask_.size();
 
-  if (!res) {
-    return false;
+    if (!res) {
+      return false;
+    }
+
+    for (size_t i = 0; i < bitmask_.size(); ++i) {
+      if (bitmask_.at(i) != otherBigintValues->bitmask_.at(i)) {
+        return false;
+      }
+    }
+
+    return true;
   }
 
-  for (size_t i = 0; i < bitmask_.size(); ++i) {
-    if (bitmask_.at(i) != otherBigintValues->bitmask_.at(i)) {
-      return false;
+  return false;
+}
+
+folly::dynamic BigintValuesUsingBloomFilter::serialize() const {
+  auto obj = Filter::serializeBase();
+  folly::dynamic words = folly::dynamic::array;
+  for (auto& block : blocks_) {
+    for (auto word : block.data) {
+      words.push_back(word);
     }
   }
+  obj["numHashes"] = xsimd::batch<uint32_t>::size;
+  obj["blockWords"] = words;
+  return obj;
+}
 
-  return true;
+std::unique_ptr<Filter> BigintValuesUsingBloomFilter::create(
+    const folly::dynamic& obj) {
+  VELOX_USER_CHECK_EQ(
+      obj["numHashes"].asInt(),
+      xsimd::batch<uint32_t>::size,
+      "Cannot deserialize BigintValuesUsingBloomFilter serialized on hardware with different SIMD length");
+  auto nullAllowed = deserializeNullAllowed(obj);
+  std::vector<SplitBlockBloomFilter::Block> blocks;
+  int i = 0;
+  SplitBlockBloomFilter::Block current{};
+  for (auto& word : obj["blockWords"]) {
+    current.data[i++] = word.asInt();
+    if (i == xsimd::batch<uint32_t>::size) {
+      blocks.push_back(current);
+      i = 0;
+    }
+  }
+  return std::unique_ptr<BigintValuesUsingBloomFilter>(
+      new BigintValuesUsingBloomFilter(nullAllowed, std::move(blocks)));
+}
+
+bool BigintValuesUsingBloomFilter::testingEquals(const Filter& other) const {
+  auto* typedOther =
+      Filter::testingBaseEquals<BigintValuesUsingBloomFilter>(other);
+  if (!typedOther) {
+    return false;
+  }
+  return blocks_.size() == typedOther->blocks_.size() &&
+      memcmp(
+          blocks_.data(),
+          typedOther->blocks_.data(),
+          blocks_.size() * sizeof(SplitBlockBloomFilter::Block)) == 0;
 }
 
 folly::dynamic NegatedBigintValuesUsingHashTable::serialize() const {
-  auto obj = Filter::serializeBase("NegatedBigintValuesUsingHashTable");
+  auto obj = Filter::serializeBase();
   obj["nonNegated"] = nonNegated_->serialize();
   return obj;
 }
@@ -458,15 +453,16 @@ std::unique_ptr<Filter> NegatedBigintValuesUsingHashTable::create(
 
 bool NegatedBigintValuesUsingHashTable::testingEquals(
     const Filter& other) const {
-  auto otherNegatedBigintValues =
-      dynamic_cast<const NegatedBigintValuesUsingHashTable*>(&other);
-  return otherNegatedBigintValues != nullptr &&
-      Filter::testingBaseEquals(other) &&
-      nonNegated_->testingEquals(*(otherNegatedBigintValues->nonNegated_));
+  if (const auto* otherNegated =
+          Filter::testingBaseEquals<NegatedBigintValuesUsingHashTable>(other)) {
+    return nonNegated_->testingEquals(*(otherNegated->nonNegated_));
+  }
+
+  return false;
 }
 
 folly::dynamic NegatedBigintValuesUsingBitmask::serialize() const {
-  auto obj = Filter::serializeBase("NegatedBigintValuesUsingBitmask");
+  auto obj = Filter::serializeBase();
   obj["min"] = min_;
   obj["max"] = max_;
   obj["nonNegated"] = nonNegated_->serialize();
@@ -486,27 +482,12 @@ std::unique_ptr<Filter> NegatedBigintValuesUsingBitmask::create(
 }
 
 bool NegatedBigintValuesUsingBitmask::testingEquals(const Filter& other) const {
-  auto otherNegatedBigintValues =
-      dynamic_cast<const NegatedBigintValuesUsingBitmask*>(&other);
-  return otherNegatedBigintValues != nullptr &&
-      Filter::testingBaseEquals(other) &&
-      nonNegated_->testingEquals(*(otherNegatedBigintValues->nonNegated_));
-}
-
-template <>
-folly::dynamic FloatingPointRange<float>::serialize() const {
-  auto obj = AbstractRange::serializeBase("FloatRange");
-  obj["lower"] = lower_;
-  obj["upper"] = upper_;
-  return obj;
-}
+  if (const auto* otherNegated =
+          Filter::testingBaseEquals<NegatedBigintValuesUsingBitmask>(other)) {
+    return nonNegated_->testingEquals(*(otherNegated->nonNegated_));
+  }
 
-template <>
-folly::dynamic FloatingPointRange<double>::serialize() const {
-  auto obj = AbstractRange::serializeBase("DoubleRange");
-  obj["lower"] = lower_;
-  obj["upper"] = upper_;
-  return obj;
+  return false;
 }
 
 std::unique_ptr<Filter> AbstractRange::create(const folly::dynamic& obj) {
@@ -541,7 +522,7 @@ std::unique_ptr<Filter> AbstractRange::create(const folly::dynamic& obj) {
 }
 
 folly::dynamic BytesRange::serialize() const {
-  auto obj = AbstractRange::serializeBase("BytesRange");
+  auto obj = AbstractRange::serializeBase();
   obj["lower"] = lower_;
   obj["upper"] = upper_;
   obj["singleValue"] = singleValue_;
@@ -567,14 +548,17 @@ std::unique_ptr<Filter> BytesRange::create(const folly::dynamic& obj) {
 }
 
 bool BytesRange::testingEquals(const Filter& other) const {
-  auto otherBytesRange = dynamic_cast<const BytesRange*>(&other);
-  return otherBytesRange != nullptr && Filter::testingBaseEquals(other) &&
-      lower_ == otherBytesRange->lower_ && upper_ == otherBytesRange->upper_ &&
-      singleValue_ == otherBytesRange->singleValue_;
+  if (const auto* otherRange =
+          AbstractRange::testingBaseEquals<BytesRange>(other)) {
+    return lower_ == otherRange->lower_ && upper_ == otherRange->upper_ &&
+        singleValue_ == otherRange->singleValue_;
+  }
+
+  return false;
 }
 
 folly::dynamic NegatedBytesRange::serialize() const {
-  auto obj = Filter::serializeBase("NegatedBytesRange");
+  auto obj = Filter::serializeBase();
   obj["nonNegated"] = nonNegated_->serialize();
   return obj;
 }
@@ -593,14 +577,16 @@ std::unique_ptr<Filter> NegatedBytesRange::create(const folly::dynamic& obj) {
 }
 
 bool NegatedBytesRange::testingEquals(const Filter& other) const {
-  auto otherNegatedBytesRange = dynamic_cast<const NegatedBytesRange*>(&other);
-  return otherNegatedBytesRange != nullptr &&
-      Filter::testingBaseEquals(other) &&
-      nonNegated_->testingEquals(*(otherNegatedBytesRange->nonNegated_));
+  if (const auto* otherNegated =
+          Filter::testingBaseEquals<NegatedBytesRange>(other)) {
+    return nonNegated_->testingEquals(*(otherNegated->nonNegated_));
+  }
+
+  return false;
 }
 
 folly::dynamic BytesValues::serialize() const {
-  auto obj = Filter::serializeBase("BytesValues");
+  auto obj = Filter::serializeBase();
   folly::dynamic values = folly::dynamic::array;
   for (auto v : values_) {
     values.push_back(v);
@@ -623,34 +609,37 @@ std::unique_ptr<Filter> BytesValues::create(const folly::dynamic& obj) {
 }
 
 bool BytesValues::testingEquals(const Filter& other) const {
-  auto otherBytesValues = dynamic_cast<const BytesValues*>(&other);
-  auto res = otherBytesValues != nullptr && Filter::testingBaseEquals(other) &&
-      lower_ == otherBytesValues->lower_ &&
-      upper_ == otherBytesValues->upper_ &&
-      values_.size() == otherBytesValues->values_.size() &&
-      lengths_.size() == otherBytesValues->lengths_.size();
-
-  if (!res) {
-    return false;
-  }
-
-  for (const auto& v : values_) {
-    if (!otherBytesValues->values_.contains(v)) {
+  if (const auto* otherBytesValues =
+          Filter::testingBaseEquals<BytesValues>(other)) {
+    auto res = lower_ == otherBytesValues->lower_ &&
+        upper_ == otherBytesValues->upper_ &&
+        values_.size() == otherBytesValues->values_.size() &&
+        lengths_.size() == otherBytesValues->lengths_.size();
+
+    if (!res) {
       return false;
     }
-  }
 
-  for (auto l : lengths_) {
-    if (!otherBytesValues->lengths_.contains(l)) {
-      return false;
+    for (const auto& v : values_) {
+      if (!otherBytesValues->values_.contains(v)) {
+        return false;
+      }
     }
+
+    for (auto l : lengths_) {
+      if (!otherBytesValues->lengths_.contains(l)) {
+        return false;
+      }
+    }
+
+    return true;
   }
 
-  return true;
+  return false;
 }
 
 folly::dynamic BigintMultiRange::serialize() const {
-  auto obj = Filter::serializeBase("BigintMultiRange");
+  auto obj = Filter::serializeBase();
   folly::dynamic arr = folly::dynamic::array;
   for (const auto& r : ranges_) {
     arr.push_back(r->serialize());
@@ -665,34 +654,36 @@ std::unique_ptr<Filter> BigintMultiRange::create(const folly::dynamic& obj) {
   std::vector<std::unique_ptr<BigintRange>> ranges;
   ranges.reserve(arr.size());
   for (const auto& r : arr) {
-    ranges.push_back(std::make_unique<BigintRange>(
-        *ISerializable::deserialize<BigintRange>(r)));
+    ranges.push_back(
+        std::make_unique<BigintRange>(
+            *ISerializable::deserialize<BigintRange>(r)));
   }
   return std::make_unique<BigintMultiRange>(std::move(ranges), nullAllowed);
 }
 
 bool BigintMultiRange::testingEquals(const Filter& other) const {
-  auto otherBigintMultiRange = dynamic_cast<const BigintMultiRange*>(&other);
-  auto res = otherBigintMultiRange != nullptr &&
-      Filter::testingBaseEquals(other) &&
-      ranges_.size() == otherBigintMultiRange->ranges_.size();
+  if (const auto* otherMultiRange =
+          Filter::testingBaseEquals<BigintMultiRange>(other)) {
+    auto res = ranges_.size() == otherMultiRange->ranges_.size();
 
-  if (!res) {
-    return false;
-  }
-
-  for (size_t i = 0; i < ranges_.size(); ++i) {
-    if (!(ranges_.at(i)->testingEquals(
-            *(otherBigintMultiRange->ranges_.at(i))))) {
+    if (!res) {
       return false;
     }
+
+    for (size_t i = 0; i < ranges_.size(); ++i) {
+      if (!(ranges_.at(i)->testingEquals(*(otherMultiRange->ranges_.at(i))))) {
+        return false;
+      }
+    }
+
+    return true;
   }
 
-  return true;
+  return false;
 }
 
 folly::dynamic NegatedBytesValues::serialize() const {
-  auto obj = Filter::serializeBase("NegatedBytesValues");
+  auto obj = Filter::serializeBase();
   obj["nonNegated"] = nonNegated_->serialize();
   return obj;
 }
@@ -707,15 +698,16 @@ std::unique_ptr<Filter> NegatedBytesValues::create(const folly::dynamic& obj) {
 }
 
 bool NegatedBytesValues::testingEquals(const Filter& other) const {
-  auto otherNegatedBytesValues =
-      dynamic_cast<const NegatedBytesValues*>(&other);
-  return otherNegatedBytesValues != nullptr &&
-      Filter::testingBaseEquals(other) &&
-      nonNegated_->testingEquals((*(otherNegatedBytesValues->nonNegated_)));
+  if (const auto* otherNegated =
+          Filter::testingBaseEquals<NegatedBytesValues>(other)) {
+    return nonNegated_->testingEquals((*(otherNegated->nonNegated_)));
+  }
+
+  return false;
 }
 
 folly::dynamic MultiRange::serialize() const {
-  auto obj = Filter::serializeBase("MultiRange");
+  auto obj = Filter::serializeBase();
   folly::dynamic arr = folly::dynamic::array;
   for (const auto& f : filters_) {
     arr.push_back(f->serialize());
@@ -739,23 +731,25 @@ std::unique_ptr<Filter> MultiRange::create(const folly::dynamic& obj) {
 }
 
 bool MultiRange::testingEquals(const Filter& other) const {
-  auto otherMultiRange = dynamic_cast<const MultiRange*>(&other);
-  auto res = otherMultiRange != nullptr && Filter::testingBaseEquals(other) &&
-
-      filters_.size() == otherMultiRange->filters_.size();
+  if (const auto* otherMultiRange =
+          Filter::testingBaseEquals<MultiRange>(other)) {
+    auto res = filters_.size() == otherMultiRange->filters_.size();
 
-  if (!res) {
-    return false;
-  }
-
-  for (size_t i = 0; i < filters_.size(); ++i) {
-    if (!filters_.at(i)->testingEquals(
-            *(otherMultiRange->filters_.at(i)->clone()))) {
+    if (!res) {
       return false;
     }
+
+    for (size_t i = 0; i < filters_.size(); ++i) {
+      if (!filters_.at(i)->testingEquals(
+              *(otherMultiRange->filters_.at(i)->clone()))) {
+        return false;
+      }
+    }
+
+    return true;
   }
 
-  return true;
+  return false;
 }
 
 BigintValuesUsingBitmask::BigintValuesUsingBitmask(
@@ -785,13 +779,6 @@ BigintValuesUsingBitmask::BigintValuesUsingBitmask(
   }
 }
 
-bool BigintValuesUsingBitmask::testInt64(int64_t value) const {
-  if (value < min_ || value > max_) {
-    return false;
-  }
-  return bitmask_[value - min_];
-}
-
 std::vector<int64_t> BigintValuesUsingBitmask::values() const {
   std::vector<int64_t> values;
   for (int i = 0; i < bitmask_.size(); i++) {
@@ -868,98 +855,6 @@ BigintValuesUsingHashTable::BigintValuesUsingHashTable(
   std::sort(values_.begin(), values_.end());
 }
 
-bool BigintValuesUsingHashTable::testInt64(int64_t value) const {
-  if (containsEmptyMarker_ && value == kEmptyMarker) {
-    return true;
-  }
-  if (value < min_ || value > max_) {
-    return false;
-  }
-  uint32_t pos = (value * M) & sizeMask_;
-  for (auto i = pos; i <= pos + sizeMask_; i++) {
-    int32_t idx = i & sizeMask_;
-    int64_t l = hashTable_[idx];
-    if (l == kEmptyMarker) {
-      return false;
-    }
-    if (l == value) {
-      return true;
-    }
-  }
-  return false;
-}
-
-xsimd::batch_bool<int64_t> BigintValuesUsingHashTable::testValues(
-    xsimd::batch<int64_t> x) const {
-  auto outOfRange = (x < xsimd::broadcast<int64_t>(min_)) |
-      (x > xsimd::broadcast<int64_t>(max_));
-  if (simd::toBitMask(outOfRange) == simd::allSetBitMask<int64_t>()) {
-    return xsimd::batch_bool<int64_t>(false);
-  }
-  if (containsEmptyMarker_) {
-    return Filter::testValues(x);
-  }
-  auto allEmpty = xsimd::broadcast<int64_t>(kEmptyMarker);
-  // Temporarily casted to unsigned to suppress overflow error.
-  auto indices = simd::reinterpretBatch<int64_t>(
-      simd::reinterpretBatch<uint64_t>(x) * M & sizeMask_);
-  auto data =
-      simd::maskGather(allEmpty, ~outOfRange, hashTable_.data(), indices);
-  // The lanes with kEmptyMarker missed, the lanes matching x hit and the other
-  // lanes must check next positions.
-
-  auto result = x == data;
-  auto resultBits = simd::toBitMask(result);
-  auto missed = simd::toBitMask(data == allEmpty);
-  static_assert(decltype(result)::size <= 16);
-  uint16_t unresolved = simd::allSetBitMask<int64_t>() ^ (resultBits | missed);
-  if (!unresolved) {
-    return result;
-  }
-  constexpr int kAlign = xsimd::default_arch::alignment();
-  constexpr int kArraySize = xsimd::batch<int64_t>::size;
-  alignas(kAlign) int64_t indicesArray[kArraySize];
-  alignas(kAlign) int64_t valuesArray[kArraySize];
-  (indices + 1).store_aligned(indicesArray);
-  x.store_aligned(valuesArray);
-  while (unresolved) {
-    auto lane = bits::getAndClearLastSetBit(unresolved);
-    // Loop for each unresolved (not hit and
-    // not empty) until finding hit or empty.
-    int64_t index = indicesArray[lane];
-    int64_t value = valuesArray[lane];
-    auto allValue = xsimd::broadcast<int64_t>(value);
-    for (;;) {
-      auto line = xsimd::load_unaligned(hashTable_.data() + index);
-
-      if (simd::toBitMask(line == allValue)) {
-        resultBits |= 1 << lane;
-        break;
-      }
-      if (simd::toBitMask(line == allEmpty)) {
-        resultBits &= ~(1 << lane);
-        break;
-      }
-      index += line.size;
-      if (index > sizeMask_) {
-        index = 0;
-      }
-    }
-  }
-  return simd::fromBitMask<int64_t>(resultBits);
-}
-
-xsimd::batch_bool<int32_t> BigintValuesUsingHashTable::testValues(
-    xsimd::batch<int32_t> x) const {
-  // Calls 4x64 twice since the hash table is 64 bits wide in any
-  // case. A 32-bit hash table would be possible but all the use
-  // cases seen are in the 64 bit range.
-  auto first = simd::toBitMask(testValues(simd::getHalf<int64_t, 0>(x)));
-  auto second = simd::toBitMask(testValues(simd::getHalf<int64_t, 1>(x)));
-  return simd::fromBitMask<int32_t>(
-      first | (second << xsimd::batch<int64_t>::size));
-}
-
 bool BigintValuesUsingHashTable::testInt64Range(
     int64_t min,
     int64_t max,
@@ -984,7 +879,7 @@ bool BigintValuesUsingHashTable::testInt64Range(
 }
 
 folly::dynamic HugeintValuesUsingHashTable::serialize() const {
-  auto obj = Filter::serializeBase("HugeintValuesUsingHashTable");
+  auto obj = Filter::serializeBase();
   obj["min_lower"] = HugeInt::lower(min_);
   obj["min_upper"] = HugeInt::upper(min_);
   obj["max_lower"] = HugeInt::lower(max_);
@@ -1038,22 +933,24 @@ bool HugeintValuesUsingHashTable::testInt128(const int128_t& value) const {
 }
 
 bool HugeintValuesUsingHashTable::testingEquals(const Filter& other) const {
-  auto otherHugeintValues =
-      dynamic_cast<const HugeintValuesUsingHashTable*>(&other);
-  bool res = otherHugeintValues != nullptr &&
-      Filter::testingBaseEquals(other) && min_ == otherHugeintValues->min_ &&
-      max_ == otherHugeintValues->max_ &&
-      values_.size() == otherHugeintValues->values_.size();
-  if (!res) {
-    return false;
-  }
-
-  for (auto value : values_) {
-    if (!otherHugeintValues->values_.contains(value)) {
+  if (const auto* otherHugeintValues =
+          Filter::testingBaseEquals<HugeintValuesUsingHashTable>(other)) {
+    bool res = min_ == otherHugeintValues->min_ &&
+        max_ == otherHugeintValues->max_ &&
+        values_.size() == otherHugeintValues->values_.size();
+    if (!res) {
       return false;
     }
+
+    for (auto value : values_) {
+      if (!otherHugeintValues->values_.contains(value)) {
+        return false;
+      }
+    }
+    return true;
   }
-  return true;
+
+  return false;
 }
 
 NegatedBigintValuesUsingBitmask::NegatedBigintValuesUsingBitmask(
@@ -1250,6 +1147,20 @@ BigintMultiRange::BigintMultiRange(
   }
 }
 
+std::string BigintMultiRange::toString() const {
+  std::ostringstream out;
+  out << "BigintMultiRange: [";
+  for (auto i = 0; i < ranges_.size(); i++) {
+    if (i > 0) {
+      out << ", ";
+    }
+    out << fmt::format("[{}, {}]", ranges_[i]->lower(), ranges_[i]->upper());
+  }
+
+  out << "] " << (nullAllowed_ ? "with nulls" : "no nulls");
+  return out.str();
+}
+
 namespace {
 int compareRanges(const char* lhs, size_t length, const std::string& rhs) {
   int size = std::min(length, rhs.length());
@@ -1362,24 +1273,26 @@ bool NegatedBytesRange::testBytesRange(
 std::unique_ptr<Filter> NegatedBytesRange::toMultiRange() const {
   std::vector<std::unique_ptr<Filter>> accepted;
   if (!isLowerUnbounded()) {
-    accepted.push_back(std::make_unique<BytesRange>(
-        "",
-        true,
-        false,
-        lower(),
-        false,
-        !testBytes(lower().data(), lower().length()),
-        false));
+    accepted.push_back(
+        std::make_unique<BytesRange>(
+            "",
+            true,
+            false,
+            lower(),
+            false,
+            !testBytes(lower().data(), lower().length()),
+            false));
   }
   if (!isUpperUnbounded()) {
-    accepted.push_back(std::make_unique<BytesRange>(
-        upper(),
-        false,
-        !testBytes(upper().data(), upper().length()),
-        "",
-        true,
-        false,
-        false));
+    accepted.push_back(
+        std::make_unique<BytesRange>(
+            upper(),
+            false,
+            !testBytes(upper().data(), upper().length()),
+            "",
+            true,
+            false,
+            false));
   }
 
   if (accepted.size() == 0) {
@@ -1665,8 +1578,9 @@ std::unique_ptr<Filter> MultiRange::mergeWith(const Filter* other) const {
       }
 
       if (!byteValues.empty()) {
-        merged.emplace_back(std::make_unique<BytesValues>(
-            std::move(byteValues), bothNullAllowed));
+        merged.emplace_back(
+            std::make_unique<BytesValues>(
+                std::move(byteValues), bothNullAllowed));
       }
 
       if (merged.empty()) {
@@ -1756,29 +1670,27 @@ std::unique_ptr<Filter> combineRangesAndNegatedValues(
   std::vector<std::unique_ptr<BigintRange>> outRanges;
 
   for (int i = 0; i < ranges.size(); ++i) {
-    auto it =
-        std::lower_bound(rejects.begin(), rejects.end(), ranges[i]->lower());
-    int64_t start = ranges[i]->lower();
-    int64_t end;
-
-    while (it != rejects.end()) {
-      end = *it - 1;
-      if (start >= ranges[i]->lower() && end < ranges[i]->upper()) {
-        if (start <= end) {
-          outRanges.emplace_back(
-              std::make_unique<common::BigintRange>(start, end, false));
-        }
-        start = *it + 1;
-        ++it;
-      } else {
+    const int64_t rangeLower{ranges[i]->lower()};
+    const int64_t rangeUpper{ranges[i]->upper()};
+    auto begin = std::lower_bound(rejects.begin(), rejects.end(), rangeLower);
+    auto end = std::upper_bound(begin, rejects.end(), rangeUpper);
+
+    int64_t start{rangeLower};
+    bool finished{false};
+    for (auto it = begin; it != end; ++it) {
+      if (*it > start) {
+        outRanges.emplace_back(
+            std::make_unique<common::BigintRange>(start, *it - 1, false));
+      }
+      if (*it == std::numeric_limits<int64_t>::max()) {
+        finished = true;
         break;
       }
+      start = *it + 1;
     }
-    end = ranges[i]->upper();
-    if (start <= end && start >= ranges[i]->lower() &&
-        end <= ranges[i]->upper()) {
+    if (!finished && start <= rangeUpper) {
       outRanges.emplace_back(
-          std::make_unique<common::BigintRange>(start, end, false));
+          std::make_unique<common::BigintRange>(start, rangeUpper, false));
     }
   }
 
@@ -1830,16 +1742,19 @@ std::unique_ptr<Filter> combineNegatedRangeOnIntRanges(
   for (int i = 0; i < ranges.size(); ++i) {
     if (negatedUpper < ranges[i]->lower() ||
         ranges[i]->upper() < negatedLower) {
-      outRanges.emplace_back(std::make_unique<BigintRange>(
-          ranges[i]->lower(), ranges[i]->upper(), false));
+      outRanges.emplace_back(
+          std::make_unique<BigintRange>(
+              ranges[i]->lower(), ranges[i]->upper(), false));
     } else {
       if (ranges[i]->lower() < negatedLower) {
-        outRanges.emplace_back(std::make_unique<BigintRange>(
-            ranges[i]->lower(), negatedLower - 1, false));
+        outRanges.emplace_back(
+            std::make_unique<BigintRange>(
+                ranges[i]->lower(), negatedLower - 1, false));
       }
       if (negatedUpper < ranges[i]->upper()) {
-        outRanges.emplace_back(std::make_unique<BigintRange>(
-            negatedUpper + 1, ranges[i]->upper(), false));
+        outRanges.emplace_back(
+            std::make_unique<BigintRange>(
+                negatedUpper + 1, ranges[i]->upper(), false));
       }
     }
   }
@@ -1855,8 +1770,9 @@ std::vector<std::unique_ptr<BigintRange>> negatedValuesToRanges(
   std::vector<std::unique_ptr<BigintRange>> res;
   res.reserve(values.size() + 1);
   if (*back > std::numeric_limits<int64_t>::min()) {
-    res.emplace_back(std::make_unique<BigintRange>(
-        std::numeric_limits<int64_t>::min(), *back - 1, false));
+    res.emplace_back(
+        std::make_unique<BigintRange>(
+            std::numeric_limits<int64_t>::min(), *back - 1, false));
   }
   while (front != values.end()) {
     if (*back + 1 <= *front - 1) {
@@ -1867,8 +1783,9 @@ std::vector<std::unique_ptr<BigintRange>> negatedValuesToRanges(
     ++back;
   }
   if (*back < std::numeric_limits<int64_t>::max()) {
-    res.emplace_back(std::make_unique<BigintRange>(
-        *back + 1, std::numeric_limits<int64_t>::max(), false));
+    res.emplace_back(
+        std::make_unique<BigintRange>(
+            *back + 1, std::numeric_limits<int64_t>::max(), false));
   }
   return res;
 }
@@ -1899,6 +1816,7 @@ std::unique_ptr<Filter> BigintRange::mergeWith(const Filter* other) const {
     case FilterKind::kNegatedBigintRange:
     case FilterKind::kBigintValuesUsingBitmask:
     case FilterKind::kBigintValuesUsingHashTable:
+    case FilterKind::kBigintValuesUsingBloomFilter:
       return other->mergeWith(this);
     case FilterKind::kBigintMultiRange: {
       auto otherMultiRange = dynamic_cast<const BigintMultiRange*>(other);
@@ -1980,8 +1898,9 @@ std::unique_ptr<Filter> NegatedBigintRange::mergeWith(
       bool bothNullAllowed = nullAllowed_ && other->testNull();
       auto otherRange = static_cast<const BigintRange*>(other);
       std::vector<std::unique_ptr<common::BigintRange>> rangeList;
-      rangeList.emplace_back(std::make_unique<BigintRange>(
-          otherRange->lower(), otherRange->upper(), false));
+      rangeList.emplace_back(
+          std::make_unique<BigintRange>(
+              otherRange->lower(), otherRange->upper(), false));
       return combineNegatedRangeOnIntRanges(
           this->lower(), this->upper(), rangeList, bothNullAllowed);
     }
@@ -1999,17 +1918,20 @@ std::unique_ptr<Filter> NegatedBigintRange::mergeWith(
         int64_t bigLower = otherNegatedRange->lower();
         int64_t bigUpper = otherNegatedRange->upper();
         if (smallLower > std::numeric_limits<int64_t>::min()) {
-          outRanges.emplace_back(std::make_unique<common::BigintRange>(
-              std::numeric_limits<int64_t>::min(), smallLower - 1, false));
+          outRanges.emplace_back(
+              std::make_unique<common::BigintRange>(
+                  std::numeric_limits<int64_t>::min(), smallLower - 1, false));
         }
         if (smallUpper < std::numeric_limits<int64_t>::max() &&
             bigLower > std::numeric_limits<int64_t>::min()) {
-          outRanges.emplace_back(std::make_unique<common::BigintRange>(
-              smallUpper + 1, bigLower - 1, false));
+          outRanges.emplace_back(
+              std::make_unique<common::BigintRange>(
+                  smallUpper + 1, bigLower - 1, false));
         }
         if (bigUpper < std::numeric_limits<int64_t>::max()) {
-          outRanges.emplace_back(std::make_unique<common::BigintRange>(
-              bigUpper + 1, std::numeric_limits<int64_t>::max(), false));
+          outRanges.emplace_back(
+              std::make_unique<common::BigintRange>(
+                  bigUpper + 1, std::numeric_limits<int64_t>::max(), false));
         }
         return combineBigintRanges(std::move(outRanges), bothNullAllowed);
       }
@@ -2029,6 +1951,7 @@ std::unique_ptr<Filter> NegatedBigintRange::mergeWith(
     }
     case FilterKind::kBigintValuesUsingHashTable:
     case FilterKind::kBigintValuesUsingBitmask:
+    case FilterKind::kBigintValuesUsingBloomFilter:
       return other->mergeWith(this);
     case FilterKind::kNegatedBigintValuesUsingHashTable:
     case FilterKind::kNegatedBigintValuesUsingBitmask: {
@@ -2084,6 +2007,7 @@ std::unique_ptr<Filter> BigintValuesUsingHashTable::mergeWith(
       return mergeWith(min, max, other);
     }
     case FilterKind::kBigintValuesUsingBitmask:
+    case FilterKind::kBigintValuesUsingBloomFilter:
       return other->mergeWith(this);
     case FilterKind::kBigintMultiRange: {
       auto otherMultiRange = dynamic_cast<const BigintMultiRange*>(other);
@@ -2157,6 +2081,7 @@ std::unique_ptr<Filter> BigintValuesUsingBitmask::mergeWith(
     case FilterKind::kAlwaysTrue:
     case FilterKind::kAlwaysFalse:
     case FilterKind::kIsNull:
+    case FilterKind::kBigintValuesUsingBloomFilter:
       return other->mergeWith(this);
     case FilterKind::kIsNotNull:
       return std::make_unique<BigintValuesUsingBitmask>(*this, false);
@@ -2246,9 +2171,9 @@ std::unique_ptr<Filter> NegatedBigintValuesUsingHashTable::mergeWith(
     case FilterKind::kBigintValuesUsingHashTable:
     case FilterKind::kBigintValuesUsingBitmask:
     case FilterKind::kBigintRange:
-    case FilterKind::kBigintMultiRange: {
+    case FilterKind::kBigintMultiRange:
+    case FilterKind::kBigintValuesUsingBloomFilter:
       return other->mergeWith(this);
-    }
     case FilterKind::kNegatedBigintValuesUsingHashTable: {
       auto otherNegated =
           static_cast<const NegatedBigintValuesUsingHashTable*>(other);
@@ -2286,9 +2211,9 @@ std::unique_ptr<Filter> NegatedBigintValuesUsingBitmask::mergeWith(
     case FilterKind::kBigintValuesUsingBitmask:
     case FilterKind::kBigintRange:
     case FilterKind::kNegatedBigintRange:
-    case FilterKind::kBigintMultiRange: {
+    case FilterKind::kBigintMultiRange:
+    case FilterKind::kBigintValuesUsingBloomFilter:
       return other->mergeWith(this);
-    }
     case FilterKind::kNegatedBigintValuesUsingHashTable: {
       auto otherHashTable =
           dynamic_cast<const NegatedBigintValuesUsingHashTable*>(other);
@@ -2326,9 +2251,9 @@ std::unique_ptr<Filter> BigintMultiRange::mergeWith(const Filter* other) const {
     case FilterKind::kBigintRange:
     case FilterKind::kNegatedBigintRange:
     case FilterKind::kBigintValuesUsingBitmask:
-    case FilterKind::kBigintValuesUsingHashTable: {
+    case FilterKind::kBigintValuesUsingHashTable:
+    case FilterKind::kBigintValuesUsingBloomFilter:
       return other->mergeWith(this);
-    }
     case FilterKind::kBigintMultiRange: {
       std::vector<std::unique_ptr<BigintRange>> newRanges;
       for (const auto& range : ranges_) {
@@ -2382,6 +2307,70 @@ std::unique_ptr<Filter> BigintMultiRange::mergeWith(const Filter* other) const {
   }
 }
 
+std::unique_ptr<Filter> BigintValuesUsingBloomFilter::mergeWith(
+    const Filter* other) const {
+  switch (other->kind()) {
+    case FilterKind::kAlwaysFalse:
+    case FilterKind::kAlwaysTrue:
+    case FilterKind::kIsNull:
+      return other->mergeWith(this);
+    case FilterKind::kIsNotNull:
+      return clone(false);
+    case FilterKind::kBigintRange: {
+      auto* filter = other->as<BigintRange>();
+      // If the hash table or bitmask generated is not small enough to fit in
+      // cache, we would rather not merging it.
+      int64_t range;
+      if (__builtin_sub_overflow(filter->upper(), filter->lower(), &range) ||
+          range > 100'000) {
+        return other->clone();
+      }
+      std::vector<int64_t> values;
+      values.reserve(range + 1);
+      for (int64_t i = filter->lower(); i <= filter->upper(); ++i) {
+        if (testInt64(i)) {
+          values.push_back(i);
+        }
+      }
+      return createBigintValues(values, nullAllowed_ && other->testNull());
+    }
+    case FilterKind::kBigintValuesUsingHashTable: {
+      auto* filter = other->as<BigintValuesUsingHashTable>();
+      auto values = filter->values();
+      int64_t size = 0;
+      for (int64_t i = 0; i < values.size(); ++i) {
+        if (testInt64(values[i])) {
+          values[size++] = values[i];
+        }
+      }
+      values.resize(size);
+      return createBigintValues(values, nullAllowed_ && other->testNull());
+    }
+    case FilterKind::kBigintValuesUsingBitmask: {
+      auto* filter = other->as<BigintValuesUsingBitmask>();
+      std::vector<int64_t> values;
+      values.reserve(filter->max() - filter->min() + 1);
+      for (int64_t i = filter->min(); i <= filter->max(); ++i) {
+        if (filter->testInt64(i) && testInt64(i)) {
+          values.push_back(i);
+        }
+      }
+      return createBigintValues(values, nullAllowed_ && other->testNull());
+    }
+    case FilterKind::kNegatedBigintRange:
+    case FilterKind::kNegatedBigintValuesUsingHashTable:
+    case FilterKind::kNegatedBigintValuesUsingBitmask:
+    case FilterKind::kBigintMultiRange:
+    case FilterKind::kBigintValuesUsingBloomFilter:
+      // Bloom filter allows false positive so dropping it will not affect
+      // correctness.  We can do so if we think merging will not improve
+      // performance.
+      return other->clone();
+    default:
+      VELOX_FAIL("Cannot merge {} with {}", kindName(), other->kindName());
+  }
+}
+
 namespace {
 // compareResult = left < right for upper, right < left for lower
 bool mergeExclusive(int compareResult, bool left, bool right) {
@@ -2674,32 +2663,36 @@ std::unique_ptr<Filter> NegatedBytesValues::mergeWith(
       ranges.reserve(rejectedValues.size() + 1);
       auto back = rejectedValues.begin();
       auto front = ++(rejectedValues.begin());
-      ranges.emplace_back(std::make_unique<BytesRange>(
-          bytesRangeOther->lower(),
-          bytesRangeOther->lowerUnbounded(),
-          loExclusive,
-          *back,
-          false, // not unbounded
-          true, // exclusive
-          false));
+      ranges.emplace_back(
+          std::make_unique<BytesRange>(
+              bytesRangeOther->lower(),
+              bytesRangeOther->lowerUnbounded(),
+              loExclusive,
+              *back,
+              false, // not unbounded
+              true, // exclusive
+              false));
       while (front != rejectedValues.end()) {
-        ranges.emplace_back(std::make_unique<BytesRange>(
-            *back, false, true, *front, false, true, false));
+        ranges.emplace_back(
+            std::make_unique<BytesRange>(
+                *back, false, true, *front, false, true, false));
         ++front;
         ++back;
       }
-      ranges.emplace_back(std::make_unique<BytesRange>(
-          *back,
-          false,
-          true,
-          bytesRangeOther->upper(),
-          bytesRangeOther->upperUnbounded(),
-          hiExclusive,
-          false));
+      ranges.emplace_back(
+          std::make_unique<BytesRange>(
+              *back,
+              false,
+              true,
+              bytesRangeOther->upper(),
+              bytesRangeOther->upperUnbounded(),
+              hiExclusive,
+              false));
       return std::make_unique<MultiRange>(std::move(ranges), bothNullAllowed);
     }
     default:
       VELOX_UNREACHABLE();
   }
 }
+
 } // namespace facebook::velox::common
diff --git a/velox/type/Filter.h b/velox/type/Filter.h
index 28cfd58b923..5b3fd8c6b13 100644
--- a/velox/type/Filter.h
+++ b/velox/type/Filter.h
@@ -15,18 +15,13 @@
  */
 #pragma once
 
-#include <algorithm>
-#include <cmath>
-#include <memory>
-#include <sstream>
-#include <string>
-#include <vector>
-
 #include <folly/Range.h>
 #include <folly/container/F14Set.h>
-
+#include <xsimd/xsimd.hpp>
+#include "velox/common/EnumDeclare.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/SimdUtil.h"
+#include "velox/common/base/SplitBlockBloomFilter.h"
 #include "velox/common/serialization/Serializable.h"
 #include "velox/type/StringView.h"
 #include "velox/type/Subfield.h"
@@ -57,17 +52,19 @@ enum class FilterKind {
   kHugeintRange,
   kTimestampRange,
   kHugeintValuesUsingHashTable,
+  kBigintValuesUsingBloomFilter,
 };
 
+VELOX_DECLARE_ENUM_NAME(FilterKind);
+
 class Filter;
 using FilterPtr = std::shared_ptr<Filter>;
 
 using SubfieldFilters = std::unordered_map<Subfield, FilterPtr>;
 
-/**
- * A simple filter (e.g. comparison with literal) that can be applied
- * efficiently while extracting values from an ORC stream.
- */
+/// A simple filter (e.g. comparison with literal) that can be applied
+/// efficiently while extracting values from an ORC, DWRF, Parquet, or Nimble
+/// stream.
 class Filter : public velox::ISerializable {
  protected:
   Filter(bool _deterministic, bool _nullAllowed, FilterKind _kind)
@@ -80,15 +77,37 @@ class Filter : public velox::ISerializable {
 
   static void registerSerDe();
 
-  // Templates parametrized on filter need to know determinism at compile
-  // time. If this is false, deterministic() will be consulted at
-  // runtime.
+  /// Templates parametrized on filter need to know determinism at compile
+  /// time. If this is false, deterministic() will be consulted at
+  /// runtime.
   static constexpr bool deterministic = true;
 
   FilterKind kind() const {
     return kind_;
   }
 
+  std::string_view kindName() const {
+    return FilterKindName::toName(kind_);
+  }
+
+  bool is(FilterKind kind) const {
+    return kind_ == kind;
+  }
+
+  /// @pre The caller must ensure this filter's kind matches TFilter.
+  template <typename TFilter>
+  TFilter* as() {
+    static_assert(std::is_base_of_v<Filter, TFilter>);
+    return static_cast<TFilter*>(this);
+  }
+
+  /// @pre The caller must ensure this filter's kind matches TFilter.
+  template <typename TFilter>
+  const TFilter* as() const {
+    static_assert(std::is_base_of_v<Filter, TFilter>);
+    return static_cast<const TFilter*>(this);
+  }
+
   bool nullAllowed() const {
     return nullAllowed_;
   }
@@ -98,60 +117,45 @@ class Filter : public velox::ISerializable {
   virtual std::unique_ptr<Filter> clone(
       std::optional<bool> nullAllowed = std::nullopt) const = 0;
 
-  /**
-   * A filter becomes non-deterministic when applies to nested column,
-   * e.g. a[1] > 10 is non-deterministic because > 10 filter applies only to
-   * some positions, e.g. first entry in a set of entries that correspond to a
-   * single top-level position.
-   */
-  virtual bool isDeterministic() const {
+  /// A filter becomes non-deterministic when applied to a nested column,
+  /// e.g. a[1] > 10 is non-deterministic because > 10 filter applies only to
+  /// some positions, e.g. first entry in a set of entries that correspond to a
+  /// single top-level position.
+  bool isDeterministic() const {
     return deterministic_;
   }
 
-  /**
-   * When a filter applied to a nested column fails, the whole top-level
-   * position should fail. To enable this functionality, the filter keeps track
-   * of the boundaries of top-level positions and allows the caller to find out
-   * where the current top-level position started and how far it continues.
-   * @return number of positions from the start of the current top-level
-   * position up to the current position (excluding current position)
-   */
-  virtual int getPrecedingPositionsToFail() const {
+  /// When a filter applied to a nested column fails, the whole top-level
+  /// position should fail. To enable this functionality, the filter keeps track
+  /// of the boundaries of top-level positions and allows the caller to find out
+  /// where the current top-level position started and how far it continues.
+  /// @return number of positions from the start of the current top-level
+  /// position up to the current position (excluding current position)
+  int getPrecedingPositionsToFail() const {
     return 0;
   }
 
-  /**
-   * Only used in test code.
-   * @return Whether an object is the same as itself.
-   */
+  /// Only used in test code.
+  /// @return Whether an object is the same as itself.
   virtual bool testingEquals(const Filter& other) const = 0;
 
-  bool testingBaseEquals(const Filter& other) const {
-    return deterministic_ == other.isDeterministic() &&
-        nullAllowed_ == other.nullAllowed_ && kind_ == other.kind();
-  }
-
-  /**
-   * @return number of positions remaining until the end of the current
-   * top-level position
-   */
-  virtual int getSucceedingPositionsToFail() const {
+  /// @return number of positions remaining until the end of the current
+  /// top-level position
+  int getSucceedingPositionsToFail() const {
     return 0;
   }
 
-  virtual bool testNull() const {
+  bool testNull() const {
     return nullAllowed_;
   }
 
-  /**
-   * Used to apply is [not] null filters to complex types, e.g.
-   * a[1] is null AND a[3] is not null, where a is an array(array(T)).
-   *
-   * In these case, the exact values are not known, but it is known whether they
-   * are null or not. Furthermore, for some positions only nulls are allowed
-   * (a[1] is null), for others only non-nulls (a[3] is not null), and for the
-   * rest both are allowed (a[2] and a[N], where N > 3).
-   */
+  /// Used to apply is [not] null filters to complex types, e.g.
+  /// a[1] is null AND a[3] is not null, where a is an array(array(T)).
+  ///
+  /// In these case, the exact values are not known, but it is known whether
+  /// they are null or not. Furthermore, for some positions only nulls are
+  /// allowed (a[1] is null), for others only non-nulls (a[3] is not null), and
+  /// for the rest both are allowed (a[2] and a[N], where N > 3).
   virtual bool testNonNull() const {
     VELOX_UNSUPPORTED("{}: testNonNull() is not supported.", toString());
   }
@@ -200,39 +204,41 @@ class Filter : public velox::ISerializable {
     VELOX_UNSUPPORTED("{}: testBytes() is not supported.", toString());
   }
 
+  virtual bool testStringView(const StringView& view) const {
+    return testBytes(view.data(), view.size());
+  }
+
   virtual bool testTimestamp(const Timestamp& /* unused */) const {
     VELOX_UNSUPPORTED("{}: testTimestamp() is not supported.", toString());
   }
 
-  // Returns true if it is useful to call testLength before other
-  // tests. This should be true for string IN and equals because it is
-  // possible to fail these based on the length alone. This would
-  // typically be false of string ranges because these cannot be
-  // generally decided without looking at the string itself.
+  /// Returns true if it is useful to call testLength before other
+  /// tests. This should be true for string IN and equals because it is
+  /// possible to fail these based on the length alone. This would
+  /// typically be false of string ranges because these cannot be
+  /// generally decided without looking at the string itself.
   virtual bool hasTestLength() const {
     return false;
   }
 
-  /**
-   * Filters like string equality and IN, as well as conditions on cardinality
-   * of lists and maps can be at least partly decided by looking at lengths
-   * alone. If this is false, then no further checks are needed. If true,
-   * eventual filters on the data itself need to be evaluated.
-   */
+  /// Filters like string equality and IN, as well as conditions on cardinality
+  /// of lists and maps can be at least partly decided by looking at lengths
+  /// alone. If this is false, then no further checks are needed. If true,
+  /// eventual filters on the data itself need to be evaluated.
   virtual bool testLength(int32_t /* unused */) const {
     VELOX_UNSUPPORTED("{}: testLength() is not supported.", toString());
   }
 
-  // Tests multiple lengths at a time.
+  /// Tests multiple lengths at a time.
   virtual xsimd::batch_bool<int32_t> testLengths(
       xsimd::batch<int32_t> lengths) const {
     return genericTestValues(
         lengths, [this](int32_t x) { return testLength(x); });
   }
 
-  // Returns true if at least one value in the specified range can pass the
-  // filter. The range is defined as all values between min and max inclusive
-  // plus null if hasNull is true.
+  /// Returns true if at least one value in the specified range can pass the
+  /// filter. The range is defined as all values between min and max inclusive
+  /// plus null if hasNull is true.
   virtual bool
   testInt64Range(int64_t /*min*/, int64_t /*max*/, bool /*hasNull*/) const {
     VELOX_UNSUPPORTED("{}: testInt64Range() is not supported.", toString());
@@ -245,9 +251,9 @@ class Filter : public velox::ISerializable {
     VELOX_UNSUPPORTED("{}: testInt128Range() is not supported.", toString());
   }
 
-  // Returns true if at least one value in the specified range can pass the
-  // filter. The range is defined as all values between min and max inclusive
-  // plus null if hasNull is true.
+  /// Returns true if at least one value in the specified range can pass the
+  /// filter. The range is defined as all values between min and max inclusive
+  /// plus null if hasNull is true.
   virtual bool testDoubleRange(double /*min*/, double /*max*/, bool /*hasNull*/)
       const {
     VELOX_UNSUPPORTED("{}: testDoubleRange() is not supported.", toString());
@@ -267,7 +273,7 @@ class Filter : public velox::ISerializable {
     VELOX_UNSUPPORTED("{}: testTimestampRange() is not supported.", toString());
   }
 
-  // Combines this filter with another filter using 'AND' logic.
+  /// Combines this filter with another filter using 'AND' logic.
   virtual std::unique_ptr<Filter> mergeWith(const Filter* /*other*/) const {
     VELOX_UNSUPPORTED("{}: mergeWith() is not supported.", toString());
   }
@@ -285,18 +291,23 @@ class Filter : public velox::ISerializable {
   virtual std::string toString() const;
 
  protected:
-  folly::dynamic serializeBase(std::string_view name) const;
+  template <typename TFilter>
+  const TFilter* testingBaseEquals(const Filter& other) const {
+    if (deterministic_ == other.isDeterministic() &&
+        nullAllowed_ == other.nullAllowed_ && kind_ == other.kind()) {
+      return other.as<TFilter>();
+    }
 
- protected:
-  const bool nullAllowed_;
+    return nullptr;
+  }
 
- private:
-  const bool deterministic_;
-  const FilterKind kind_;
+  folly::dynamic serializeBase() const;
 
+ protected:
   template <typename T, typename F>
-  xsimd::batch_bool<T> genericTestValues(xsimd::batch<T> batch, F&& testValue)
-      const {
+  static xsimd::batch_bool<T> genericTestValues(
+      xsimd::batch<T> batch,
+      F&& testValue) {
     constexpr int N = decltype(batch)::size;
     constexpr int kAlign = decltype(batch)::arch_type::alignment();
     alignas(kAlign) T data[N];
@@ -307,6 +318,12 @@ class Filter : public velox::ISerializable {
     }
     return xsimd::broadcast<T>(0) != xsimd::load_aligned(res);
   }
+
+  const bool nullAllowed_;
+
+ private:
+  const bool deterministic_;
+  const FilterKind kind_;
 };
 
 /// TODO Check if this filter is needed. This should not be passed down.
@@ -319,7 +336,7 @@ class AlwaysFalse final : public Filter {
   static std::unique_ptr<Filter> create(const folly::dynamic& /*obj*/);
 
   bool testingEquals(const Filter& other) const final {
-    return Filter::testingBaseEquals(other);
+    return Filter::testingBaseEquals<AlwaysFalse>(other);
   }
 
   std::unique_ptr<Filter> clone(
@@ -331,10 +348,6 @@ class AlwaysFalse final : public Filter {
     return false;
   }
 
-  bool testNull() const final {
-    return false;
-  }
-
   bool testInt64(int64_t /* unused */) const final {
     return false;
   }
@@ -415,11 +428,7 @@ class AlwaysTrue final : public Filter {
   static std::unique_ptr<Filter> create(const folly::dynamic& /*obj*/);
 
   bool testingEquals(const Filter& other) const final {
-    return Filter::testingBaseEquals(other);
-  }
-
-  bool testNull() const final {
-    return true;
+    return Filter::testingBaseEquals<AlwaysTrue>(other);
   }
 
   bool testNonNull() const final {
@@ -501,7 +510,7 @@ class IsNull final : public Filter {
   static std::unique_ptr<Filter> create(const folly::dynamic& /*obj*/);
 
   bool testingEquals(const Filter& other) const final {
-    return Filter::testingBaseEquals(other);
+    return Filter::testingBaseEquals<IsNull>(other);
   }
 
   std::unique_ptr<Filter> clone(
@@ -589,7 +598,7 @@ class IsNotNull final : public Filter {
   static std::unique_ptr<Filter> create(const folly::dynamic& /*obj*/);
 
   bool testingEquals(const Filter& other) const final {
-    return Filter::testingBaseEquals(other);
+    return Filter::testingBaseEquals<IsNotNull>(other);
   }
 
   std::unique_ptr<Filter> clone(
@@ -1017,12 +1026,101 @@ class BigintValuesUsingHashTable final : public Filter {
     }
   }
 
-  bool testInt64(int64_t value) const final;
-  xsimd::batch_bool<int64_t> testValues(xsimd::batch<int64_t>) const final;
-  xsimd::batch_bool<int32_t> testValues(xsimd::batch<int32_t>) const final;
+  bool testInt64(int64_t value) const final {
+    if (containsEmptyMarker_ && value == kEmptyMarker) {
+      return true;
+    }
+    if (value < min_ || value > max_) {
+      return false;
+    }
+    uint32_t pos = (value * M) & sizeMask_;
+    for (auto i = pos; i <= pos + sizeMask_; i++) {
+      int32_t idx = i & sizeMask_;
+      int64_t l = hashTable_[idx];
+      if (l == kEmptyMarker) {
+        return false;
+      }
+      if (l == value) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  xsimd::batch_bool<int64_t> testValues(xsimd::batch<int64_t> x) const final {
+    auto outOfRange = (x < xsimd::broadcast<int64_t>(min_)) |
+        (x > xsimd::broadcast<int64_t>(max_));
+    if (simd::all(outOfRange)) {
+      return xsimd::batch_bool<int64_t>(false);
+    }
+    if (containsEmptyMarker_) {
+      return Filter::testValues(x);
+    }
+    auto allEmpty = xsimd::broadcast<int64_t>(kEmptyMarker);
+    // Temporarily casted to unsigned to suppress overflow error.
+    auto indices = simd::reinterpretBatch<int64_t>(
+        simd::reinterpretBatch<uint64_t>(x) * M & sizeMask_);
+    auto data =
+        simd::maskGather(allEmpty, ~outOfRange, hashTable_.data(), indices);
+    // The lanes with kEmptyMarker missed, the lanes matching x hit and the
+    // other lanes must check next positions.
+
+    auto result = x == data;
+    auto resultBits = simd::toBitMask(result);
+    auto missed = simd::toBitMask(data == allEmpty);
+    static_assert(decltype(result)::size <= 16);
+    uint16_t unresolved =
+        simd::allSetBitMask<int64_t>() ^ (resultBits | missed);
+    if (!unresolved) {
+      return result;
+    }
+    constexpr int kAlign = xsimd::default_arch::alignment();
+    constexpr int kArraySize = xsimd::batch<int64_t>::size;
+    alignas(kAlign) int64_t indicesArray[kArraySize];
+    alignas(kAlign) int64_t valuesArray[kArraySize];
+    (indices + 1).store_aligned(indicesArray);
+    x.store_aligned(valuesArray);
+    while (unresolved) {
+      auto lane = bits::getAndClearLastSetBit(unresolved);
+      // Loop for each unresolved (not hit and
+      // not empty) until finding hit or empty.
+      int64_t index = indicesArray[lane];
+      int64_t value = valuesArray[lane];
+      auto allValue = xsimd::broadcast<int64_t>(value);
+      for (;;) {
+        auto line = xsimd::load_unaligned(hashTable_.data() + index);
+
+        if (simd::any(line == allValue)) {
+          resultBits |= 1 << lane;
+          break;
+        }
+        if (simd::any(line == allEmpty)) {
+          resultBits &= ~(1 << lane);
+          break;
+        }
+        index += line.size;
+        if (index > sizeMask_) {
+          index = 0;
+        }
+      }
+    }
+    return simd::fromBitMask<int64_t>(resultBits);
+  }
+
+  xsimd::batch_bool<int32_t> testValues(xsimd::batch<int32_t> x) const final {
+    // Calls 4x64 twice since the hash table is 64 bits wide in any
+    // case. A 32-bit hash table would be possible but all the use
+    // cases seen are in the 64 bit range.
+    auto first = simd::toBitMask(testValues(simd::getHalf<int64_t, 0>(x)));
+    auto second = simd::toBitMask(testValues(simd::getHalf<int64_t, 1>(x)));
+    return simd::fromBitMask<int32_t>(
+        first | (second << xsimd::batch<int64_t>::size));
+  }
+
   xsimd::batch_bool<int16_t> testValues(xsimd::batch<int16_t> x) const final {
-    return Filter::testValues(x);
+    return genericTestValues(x, [this](int16_t x) { return testInt64(x); });
   }
+
   bool testInt64Range(int64_t min, int64_t max, bool hashNull) const final;
 
   std::unique_ptr<Filter> mergeWith(const Filter* other) const final;
@@ -1058,7 +1156,8 @@ class BigintValuesUsingHashTable final : public Filter {
   mergeWith(int64_t min, int64_t max, const Filter* other) const;
 
   static constexpr int64_t kEmptyMarker = 0xdeadbeefbadefeedL;
-  // from Murmur hash
+
+  // From Murmur hash.
   static constexpr uint64_t M = 0xc6a4a7935bd1e995L;
 
   const int64_t min_;
@@ -1161,7 +1260,12 @@ class BigintValuesUsingBitmask final : public Filter {
 
   std::vector<int64_t> values() const;
 
-  bool testInt64(int64_t value) const final;
+  bool testInt64(int64_t value) const final {
+    if (value < min_ || value > max_) {
+      return false;
+    }
+    return bitmask_[value - min_];
+  }
 
   bool testInt64Range(int64_t min, int64_t max, bool hasNull) const final;
 
@@ -1186,6 +1290,85 @@ class BigintValuesUsingBitmask final : public Filter {
   const int64_t max_;
 };
 
+class BigintValuesUsingBloomFilter final : public Filter {
+ public:
+  static int64_t numBlocks(int64_t capacity) {
+    return SplitBlockBloomFilter::numBlocks(capacity, 0.01);
+  }
+
+  BigintValuesUsingBloomFilter(int64_t capacity, bool nullAllowed)
+      : Filter(true, nullAllowed, FilterKind::kBigintValuesUsingBloomFilter),
+        blocks_(numBlocks(capacity)),
+        filter_(blocks_) {}
+
+  bool testInt64(int64_t value) const final {
+    return filter_.mayContain(hash(value));
+  }
+
+  xsimd::batch_bool<int64_t> testValues(xsimd::batch<int64_t> x) const final {
+    return genericTestValues(x, [this](int64_t x) { return testInt64(x); });
+  }
+
+  xsimd::batch_bool<int32_t> testValues(xsimd::batch<int32_t> x) const final {
+    return genericTestValues(x, [this](int32_t x) { return testInt64(x); });
+  }
+
+  xsimd::batch_bool<int16_t> testValues(xsimd::batch<int16_t> x) const final {
+    return genericTestValues(x, [this](int16_t x) { return testInt64(x); });
+  }
+
+  bool testInt64Range(int64_t /*min*/, int64_t /*max*/, bool /*hasNull*/)
+      const final {
+    return true;
+  }
+
+  std::unique_ptr<Filter> clone(
+      std::optional<bool> nullAllowed) const override {
+    return std::unique_ptr<BigintValuesUsingBloomFilter>(
+        new BigintValuesUsingBloomFilter(
+            nullAllowed.value_or(nullAllowed_), blocks_));
+  }
+
+  folly::dynamic serialize() const override;
+
+  static std::unique_ptr<Filter> create(const folly::dynamic& obj);
+
+  bool testingEquals(const Filter& other) const override;
+
+  std::unique_ptr<Filter> mergeWith(const Filter* other) const override;
+
+  void insert(int64_t value) {
+    filter_.insert(hash(value));
+  }
+
+  uint64_t blockIndex(int64_t value) const {
+    return filter_.blockIndex(hash(value));
+  }
+
+  int64_t blocksByteSize() const {
+    return blocks_.size() * sizeof(SplitBlockBloomFilter::Block);
+  }
+
+ private:
+  static uint64_t hash(int64_t value) {
+    // Simple multiplication hash like the one in BigintValuesUsingHashTable
+    // does not distribute values evenly.  Maybe we need to reconsider the hash
+    // choice in BigintValuesUsingHashTable as well in the future.
+    return folly::hasher<int64_t>()(value);
+  }
+
+  // Private constructor used by clone() and create().
+  BigintValuesUsingBloomFilter(
+      bool nullAllowed,
+      std::vector<SplitBlockBloomFilter::Block> blocks)
+      : Filter(true, nullAllowed, FilterKind::kBigintValuesUsingBloomFilter),
+        blocks_(std::move(blocks)),
+        filter_(blocks_) {}
+
+  std::vector<SplitBlockBloomFilter::Block> blocks_;
+  SplitBlockBloomFilter filter_;
+};
+
 // NOT IN-list filter for integral data types. Implemented as a hash table. Good
 // for large number of rejected values that do not fit within a small range.
 class NegatedBigintValuesUsingHashTable final : public Filter {
@@ -1370,16 +1553,30 @@ class AbstractRange : public Filter {
       FilterKind kind)
       : Filter(true, nullAllowed, kind),
         lowerUnbounded_(lowerUnbounded),
-        lowerExclusive_(lowerExclusive),
+        lowerExclusive_(lowerUnbounded ? true : lowerExclusive),
         upperUnbounded_(upperUnbounded),
-        upperExclusive_(upperExclusive) {
+        upperExclusive_(upperUnbounded ? true : upperExclusive) {
     VELOX_CHECK(
         !lowerUnbounded_ || !upperUnbounded_,
-        "A range filter must have  a lower or upper  bound");
+        "A range filter must have a lower or upper bound");
   }
 
-  folly::dynamic serializeBase(std::string_view name) const {
-    auto obj = Filter::serializeBase(name);
+  template <typename TFilter>
+  const TFilter* testingBaseEquals(const Filter& other) const {
+    if (const auto* otherRange = Filter::testingBaseEquals<TFilter>(other)) {
+      if (lowerUnbounded_ == otherRange->lowerUnbounded_ &&
+          lowerExclusive_ == otherRange->lowerExclusive_ &&
+          upperUnbounded_ == otherRange->upperUnbounded_ &&
+          upperExclusive_ == otherRange->upperExclusive_) {
+        return otherRange;
+      }
+    }
+
+    return nullptr;
+  }
+
+  folly::dynamic serializeBase() const {
+    auto obj = Filter::serializeBase();
     obj["lowerUnbounded"] = lowerUnbounded_;
     obj["lowerExclusive"] = lowerExclusive_;
     obj["upperUnbounded"] = upperUnbounded_;
@@ -1448,7 +1645,12 @@ class FloatingPointRange final : public AbstractRange {
     VELOX_CHECK(upperUnbounded_ || !std::isnan(upper_));
   }
 
-  folly::dynamic serialize() const override;
+  folly::dynamic serialize() const override {
+    auto obj = AbstractRange::serializeBase();
+    obj["lower"] = lower_;
+    obj["upper"] = upper_;
+    return obj;
+  }
 
   double lower() const {
     return lower_;
@@ -1546,17 +1748,32 @@ class FloatingPointRange final : public AbstractRange {
 
   std::string toString() const override;
 
-  bool testingEquals(const Filter& other) const final;
+  bool testingEquals(const Filter& other) const final {
+    if (const auto* otherRange =
+            AbstractRange::testingBaseEquals<FloatingPointRange<T>>(other)) {
+      return (lowerUnbounded_ ||
+              approximatelyEqual(lower_, otherRange->lower_)) &&
+          (upperUnbounded_ || approximatelyEqual(upper_, otherRange->upper_));
+    }
+
+    return false;
+  }
 
  private:
+  static bool approximatelyEqual(T a, T b) {
+    return std::fabs(a - b) < std::numeric_limits<T>::epsilon();
+  }
+
   std::string toString(const std::string& name) const {
     return fmt::format(
         "{}: {}{}, {}{} {}",
         name,
-        (lowerExclusive_ || lowerUnbounded_) ? "(" : "[",
+        (lowerUnbounded_ || lowerExclusive_) ? "(" : "[",
         lowerUnbounded_ ? "-inf" : std::to_string(lower_),
+        // "nan" is considered valid value(s) and
+        // "nan > +inf" so "nan" is the upper bound in case of unbounded range.
         upperUnbounded_ ? "nan" : std::to_string(upper_),
-        (upperExclusive_ && !upperUnbounded_) ? ")" : "]",
+        (upperUnbounded_ || upperExclusive_) ? ")" : "]",
         nullAllowed_ ? "with nulls" : "no nulls");
   }
 
@@ -1629,18 +1846,6 @@ inline std::string FloatingPointRange<float>::toString() const {
   return toString("FloatRange");
 }
 
-template <>
-inline bool FloatingPointRange<float>::testingEquals(
-    const Filter& other) const {
-  return toString() == other.toString();
-}
-
-template <>
-inline bool FloatingPointRange<double>::testingEquals(
-    const Filter& other) const {
-  return toString() == other.toString();
-}
-
 template <>
 inline xsimd::batch_bool<double> FloatingPointRange<double>::testValues(
     xsimd::batch<double> x) const {
@@ -1649,8 +1854,12 @@ inline xsimd::batch_bool<double> FloatingPointRange<double>::testValues(
 
 template <>
 inline xsimd::batch_bool<float> FloatingPointRange<double>::testValues(
-    xsimd::batch<float>) const {
-  VELOX_FAIL("Not defined for double filter");
+    xsimd::batch<float> x) const {
+  // Slow path for schema evolution:  handles the case where double filter is
+  // applied to float data (e.g., reading float column with double type
+  // request). Falls back to element-by-element testing as batch processing
+  // requires type matching.
+  return Filter::testValues(x);
 }
 
 template <>
@@ -1684,10 +1893,10 @@ class BytesRange final : public AbstractRange {
   /// the filter.
   /// @param nullAllowed Null values are passing the filter if true.
   BytesRange(
-      const std::string& lower,
+      std::string lower,
       bool lowerUnbounded,
       bool lowerExclusive,
-      const std::string& upper,
+      std::string upper,
       bool upperUnbounded,
       bool upperExclusive,
       bool nullAllowed)
@@ -1698,8 +1907,10 @@ class BytesRange final : public AbstractRange {
             upperExclusive,
             nullAllowed,
             FilterKind::kBytesRange),
-        lower_(lower),
-        upper_(upper),
+        lower_(std::move(lower)),
+        upper_(std::move(upper)),
+        lowerView_(lower_),
+        upperView_(upper_),
         singleValue_(
             !lowerExclusive_ && !upperExclusive_ && !lowerUnbounded_ &&
             !upperUnbounded_ && lower_ == upper_) {
@@ -1717,6 +1928,8 @@ class BytesRange final : public AbstractRange {
             FilterKind::kBytesRange),
         lower_(other.lower_),
         upper_(other.upper_),
+        lowerView_(lower_),
+        upperView_(upper_),
         singleValue_(other.singleValue_) {}
 
   folly::dynamic serialize() const override;
@@ -1744,6 +1957,35 @@ class BytesRange final : public AbstractRange {
 
   bool testBytes(const char* value, int32_t length) const final;
 
+  bool testStringView(const StringView& view) const final {
+    if (singleValue_) {
+      return view == lowerView_;
+    }
+    if (!lowerUnbounded_) {
+      if (lowerExclusive_) {
+        if (view <= lowerView_) {
+          return false;
+        }
+      } else {
+        if (view < lowerView_) {
+          return false;
+        }
+      }
+    }
+    if (!upperUnbounded_) {
+      if (upperExclusive_) {
+        if (view >= upperView_) {
+          return false;
+        }
+      } else {
+        if (view > upperView_) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
   bool testBytesRange(
       std::optional<std::string_view> min,
       std::optional<std::string_view> max,
@@ -1798,6 +2040,8 @@ class BytesRange final : public AbstractRange {
  private:
   const std::string lower_;
   const std::string upper_;
+  const StringView lowerView_;
+  const StringView upperView_;
   const bool singleValue_;
 };
 
@@ -1816,19 +2060,19 @@ class NegatedBytesRange final : public Filter {
   /// the filter.
   /// @param nullAllowed Null values are passing the filter if true.
   NegatedBytesRange(
-      const std::string& lower,
+      std::string lower,
       bool lowerUnbounded,
       bool lowerExclusive,
-      const std::string& upper,
+      std::string upper,
       bool upperUnbounded,
       bool upperExclusive,
       bool nullAllowed)
       : Filter(true, nullAllowed, FilterKind::kNegatedBytesRange) {
     nonNegated_ = std::make_unique<BytesRange>(
-        lower,
+        std::move(lower),
         lowerUnbounded,
         lowerExclusive,
-        upper,
+        std::move(upper),
         upperUnbounded,
         upperExclusive,
         nullAllowed);
@@ -1856,14 +2100,18 @@ class NegatedBytesRange final : public Filter {
     return !nonNegated_->testBytes(value, length);
   }
 
+  bool testStringView(const StringView& view) const final {
+    return !nonNegated_->testStringView(view);
+  }
+
   bool testBytesRange(
       std::optional<std::string_view> min,
       std::optional<std::string_view> max,
       bool hasNull) const final;
 
   bool testLength(int length) const final {
-    // a range nearly never covers all values of a particular length,
-    // so at least one value of each length is probably accepted
+    // A range almost never covers all values of a particular length,
+    // so at least one value of each length is probably accepted.
     return true;
   }
 
@@ -2067,6 +2315,7 @@ class BytesValues final : public Filter {
 class BigintMultiRange final : public Filter {
  public:
   /// @param ranges List of range filters. Must contain at least two entries.
+  /// Ranges must be sorted in ascending order and must not overlap.
   /// @param nullAllowed Null values are passing the filter if true. nullAllowed
   /// flags in the 'ranges' filters are ignored.
   BigintMultiRange(
@@ -2092,15 +2341,7 @@ class BigintMultiRange final : public Filter {
     return ranges_;
   }
 
-  std::string toString() const override {
-    std::ostringstream out;
-    out << "BigintMultiRange: [";
-    for (const auto& range : ranges_) {
-      out << " " << range->toString();
-    }
-    out << " ]" << (nullAllowed_ ? "with nulls" : "no nulls");
-    return out.str();
-  }
+  std::string toString() const override;
 
   bool testingEquals(const Filter& other) const final;
 
@@ -2136,7 +2377,7 @@ class NegatedBytesValues final : public Filter {
   }
 
   bool testLength(int32_t /* unused */) const final {
-    // it is very rare that we will reject all strings of a given length
+    // It is very rare that we will reject all strings of a given length
     // using a NegatedBytesValues filter.
     return true;
   }
@@ -2250,16 +2491,16 @@ static inline bool applyFilter(TFilter& filter, const std::string& value) {
 }
 
 template <typename TFilter>
-static inline bool applyFilter(TFilter& filter, folly::StringPiece value) {
+static inline bool applyFilter(TFilter& filter, std::string_view value) {
   return filter.testBytes(value.data(), value.size());
 }
 
 template <typename TFilter>
 static inline bool applyFilter(TFilter& filter, StringView value) {
-  return filter.testBytes(value.data(), value.size());
+  return filter.testStringView(value);
 }
 
-// Creates a hash or bitmap based IN filter depending on value distribution.
+/// Create a hash or bitmap based IN filter depending on value distribution.
 std::unique_ptr<Filter> createBigintValues(
     const std::vector<int64_t>& values,
     bool nullAllowed);
@@ -2268,9 +2509,19 @@ std::unique_ptr<Filter> createHugeintValues(
     const std::vector<int128_t>& values,
     bool nullAllowed);
 
-// Creates a hash or bitmap based NOT IN filter depending on value distribution.
+/// Create a hash or bitmap based NOT IN filter depending on value distribution.
 std::unique_ptr<Filter> createNegatedBigintValues(
     const std::vector<int64_t>& values,
     bool nullAllowed);
 
 } // namespace facebook::velox::common
+
+template <>
+struct fmt::formatter<facebook::velox::common::FilterKind>
+    : formatter<std::string> {
+  auto format(facebook::velox::common::FilterKind s, format_context& ctx)
+      const {
+    return formatter<std::string>::format(
+        std::string(facebook::velox::common::FilterKindName::toName(s)), ctx);
+  }
+};
diff --git a/velox/type/HugeInt.cpp b/velox/type/HugeInt.cpp
index 45e4a3079da..2c4012e1193 100644
--- a/velox/type/HugeInt.cpp
+++ b/velox/type/HugeInt.cpp
@@ -49,20 +49,20 @@ int128_t HugeInt::parse(const std::string& str) {
     // it more robust.
     int128_t cur = str[idx] - '0';
     if ((result > max / 10)) {
-      VELOX_FAIL(fmt::format("{} is out of range of int128_t", str));
+      VELOX_FAIL("Value is out of range of int128_t: {}", str);
     }
 
     int128_t num = cur - (max % 10);
     if (result == (max / 10)) {
       if (negative) {
         if (num > 1) {
-          VELOX_FAIL(fmt::format("{} is out of range of int128_t", str));
+          VELOX_FAIL("Value is out of range of int128_t: {}", str);
         } else if (num == 1) {
           return min;
         }
       } else {
         if (num > 0) {
-          VELOX_FAIL(fmt::format("{} is out of range of int128_t", str));
+          VELOX_FAIL("Value is out of range of int128_t: {}", str);
         } else if (num == 0) {
           return max;
         }
diff --git a/velox/type/HugeInt.h b/velox/type/HugeInt.h
index eda86d3f40a..aa85d01f73b 100644
--- a/velox/type/HugeInt.h
+++ b/velox/type/HugeInt.h
@@ -13,8 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <folly/dynamic.h>
-#include <sstream>
 #include <string>
 #include "velox/common/base/BitUtil.h"
 #include "velox/common/base/Exceptions.h"
diff --git a/velox/type/OpaqueCustomTypes.h b/velox/type/OpaqueCustomTypes.h
index 5229cc86305..907f742c687 100644
--- a/velox/type/OpaqueCustomTypes.h
+++ b/velox/type/OpaqueCustomTypes.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include "velox/common/base/Exceptions.h"
 #include "velox/type/SimpleFunctionApi.h"
 #include "velox/type/Type.h"
 
@@ -34,14 +35,19 @@ class CastOperator;
 template <typename T, const char* customTypeName>
 class OpaqueCustomTypeRegister {
  public:
-  static bool registerType() {
-    return facebook::velox::registerCustomType(
-        customTypeName, std::make_unique<const TypeFactory>());
-  }
+  using SerializeValueFunc = OpaqueType::SerializeFunc<T>;
+  using DeserializeValueFunc = OpaqueType::DeserializeFunc<T>;
 
-  static bool unregisterType() {
-    return facebook::velox::unregisterCustomType(customTypeName);
-  }
+  // @param serializeValueFunc Optional serialization function for values of
+  // type T.
+  // @param deserializeValueFunc Optional deserialization function for values of
+  // type T. Both serializeValueFunc and deserializeValueFunc must be specified
+  // or not together.
+  static bool registerType(
+      SerializeValueFunc serializeValueFunc = nullptr,
+      DeserializeValueFunc deserializeValueFunc = nullptr);
+
+  static bool unregisterType();
 
   // Type used in the simple function interface as CustomType<TypeT>.
   struct TypeT {
@@ -51,13 +57,17 @@ class OpaqueCustomTypeRegister {
 
   using SimpleType = CustomType<TypeT>;
 
+  class VeloxType;
+  using VeloxTypePtr = std::shared_ptr<const VeloxType>;
+
   class VeloxType : public OpaqueType {
    public:
     VeloxType() : OpaqueType(std::type_index(typeid(T))) {}
 
-    static const TypePtr& get() {
-      static const TypePtr instance{new VeloxType()};
-      return instance;
+    static const VeloxTypePtr& get() {
+      static const VeloxType kInstance;
+      static const VeloxTypePtr kInstancePtr{TypePtr{}, &kInstance};
+      return kInstancePtr;
     }
 
     static const std::shared_ptr<const exec::CastOperator>& getCastOperator() {
@@ -76,13 +86,20 @@ class OpaqueCustomTypeRegister {
     std::string toString() const override {
       return customTypeName;
     }
+
+    folly::dynamic serialize() const override {
+      folly::dynamic obj = folly::dynamic::object;
+      obj["name"] = "Type";
+      obj["type"] = customTypeName;
+      return obj;
+    }
   };
 
-  static const TypePtr& singletonTypePtr() {
+  static const VeloxTypePtr& singletonTypePtr() {
     return VeloxType::get();
   }
 
-  static const TypePtr& get() {
+  static const VeloxTypePtr& get() {
     return VeloxType::get();
   }
 
@@ -107,4 +124,34 @@ class OpaqueCustomTypeRegister {
     }
   };
 };
+
+template <typename T, const char* customTypeName>
+bool OpaqueCustomTypeRegister<T, customTypeName>::registerType(
+    SerializeValueFunc serializeValueFunc,
+    DeserializeValueFunc deserializeValueFunc) {
+  VELOX_USER_CHECK(
+      ((serializeValueFunc && deserializeValueFunc) ||
+       (!serializeValueFunc && !deserializeValueFunc)),
+      "Both serialization and deserialization functions need to be registered for custom type {}",
+      customTypeName);
+  if (registerCustomType(
+          customTypeName, std::make_unique<const TypeFactory>())) {
+    if (serializeValueFunc && deserializeValueFunc) {
+      OpaqueType::registerSerialization<T>(
+          customTypeName, serializeValueFunc, deserializeValueFunc);
+    }
+    return true;
+  }
+  return false;
+}
+
+template <typename T, const char* customTypeName>
+bool OpaqueCustomTypeRegister<T, customTypeName>::unregisterType() {
+  if (unregisterCustomType(customTypeName)) {
+    OpaqueType::unregisterSerialization(singletonTypePtr(), customTypeName);
+    return true;
+  }
+  return false;
+}
+
 } // namespace facebook::velox
diff --git a/velox/type/SimpleFunctionApi.h b/velox/type/SimpleFunctionApi.h
index 12f41f137f5..2b628e17732 100644
--- a/velox/type/SimpleFunctionApi.h
+++ b/velox/type/SimpleFunctionApi.h
@@ -234,6 +234,14 @@ struct Varchar {
   Varchar() {}
 };
 
+struct TimestampUtcT {
+  using type = Timestamp;
+
+  static constexpr const char* typeName = "timestamp utc";
+};
+
+using TimestampUtc = CustomType<TimestampUtcT>;
+
 // Type to use for inputs and outputs of simple functions with BigintEnum types.
 // E.g. arg_type<BigintEnum<E1>> and out_type<BigintEnum<E1>>.
 template <typename E>
@@ -298,6 +306,13 @@ struct CppToType<Varbinary> : public CppToTypeBase<TypeKind::VARBINARY> {};
 template <>
 struct CppToType<Date> : public CppToTypeBase<TypeKind::INTEGER> {};
 
+template <>
+struct CppToType<TimestampUtc> : public CppToTypeBase<TypeKind::TIMESTAMP> {
+  static auto create() {
+    return TimestampUtcType::get();
+  }
+};
+
 template <typename T>
 struct CppToType<Generic<T>> : public CppToTypeBase<TypeKind::UNKNOWN> {};
 
@@ -354,20 +369,31 @@ template <>
 struct SimpleTypeTrait<Varbinary> : public TypeTraits<TypeKind::VARBINARY> {};
 
 template <>
-struct SimpleTypeTrait<Date> : public SimpleTypeTrait<int32_t> {
+struct SimpleTypeTrait<Date> : public TypeTraits<TypeKind::INTEGER> {
   static constexpr const char* name = "DATE";
 };
 
 template <>
-struct SimpleTypeTrait<IntervalDayTime> : public SimpleTypeTrait<int64_t> {
+struct SimpleTypeTrait<IntervalDayTime> : public TypeTraits<TypeKind::BIGINT> {
   static constexpr const char* name = "INTERVAL DAY TO SECOND";
 };
 
 template <>
-struct SimpleTypeTrait<IntervalYearMonth> : public SimpleTypeTrait<int32_t> {
+struct SimpleTypeTrait<IntervalYearMonth>
+    : public TypeTraits<TypeKind::INTEGER> {
   static constexpr const char* name = "INTERVAL YEAR TO MONTH";
 };
 
+template <>
+struct SimpleTypeTrait<Time> : public TypeTraits<TypeKind::BIGINT> {
+  static constexpr const char* name = "TIME";
+};
+
+template <>
+struct SimpleTypeTrait<TimeMicroUtc> : public TypeTraits<TypeKind::BIGINT> {
+  static constexpr const char* name = "TIME MICRO UTC";
+};
+
 template <typename T, bool comparable, bool orderable>
 struct SimpleTypeTrait<Generic<T, comparable, orderable>> {
   static constexpr TypeKind typeKind = TypeKind::INVALID;
@@ -401,7 +427,7 @@ struct SimpleTypeTrait<CustomType<T, providesCustomComparison>>
   static constexpr bool isFixedWidth = physical_t::isFixedWidth;
 
   // This is different than the physical type name.
-  static constexpr char* name = T::typeName;
+  static constexpr const char* name = T::typeName;
 };
 
 /// MaterializeType template.
@@ -462,14 +488,14 @@ template <>
 struct MaterializeType<Varchar> {
   using nullable_t = std::string;
   using null_free_t = std::string;
-  static constexpr bool requiresMaterialization = false;
+  static constexpr bool requiresMaterialization = true;
 };
 
 template <>
 struct MaterializeType<Varbinary> {
   using nullable_t = std::string;
   using null_free_t = std::string;
-  static constexpr bool requiresMaterialization = false;
+  static constexpr bool requiresMaterialization = true;
 };
 
 } // namespace facebook::velox
diff --git a/velox/type/StringView.cpp b/velox/type/StringView.cpp
index 1b8f2e07f5e..a339c0e6f84 100644
--- a/velox/type/StringView.cpp
+++ b/velox/type/StringView.cpp
@@ -15,11 +15,14 @@
  */
 
 #include "velox/type/StringView.h"
+
+#include <folly/dynamic.h>
+
 #include "velox/common/base/SimdUtil.h"
 
 namespace facebook::velox {
-
 namespace {
+
 int32_t linearSearchSimple(
     StringView key,
     const StringView* strings,
@@ -134,4 +137,9 @@ int32_t StringView::linearSearch(
   return linearSearchSimple(key, strings, indices, numStrings);
 #endif
 }
+
+StringView::operator folly::dynamic() const {
+  return folly::dynamic(folly::StringPiece(data(), size()));
+}
+
 } // namespace facebook::velox
diff --git a/velox/type/StringView.h b/velox/type/StringView.h
index 797172de501..55f57822c66 100644
--- a/velox/type/StringView.h
+++ b/velox/type/StringView.h
@@ -23,26 +23,52 @@
 #include <folly/FBString.h>
 #include <folly/Format.h>
 #include <folly/Range.h>
-#include <folly/dynamic.h>
 
 #include <fmt/format.h>
 
 #include "velox/common/base/BitUtil.h"
 #include "velox/common/base/Exceptions.h"
 
+namespace folly {
+struct dynamic;
+}
+
 namespace facebook::velox {
 
-// Variable length string or binary type for use in vectors. This has
-// semantics similar to std::string_view or folly::StringPiece and
-// exposes a subset of the interface. If the string is 12 characters
-// or less, it is inlined and no reference is held. If it is longer, a
-// reference to the string is held and the 4 first characters are
-// cached in the StringView. This allows failing comparisons early and
-// reduces the CPU cache working set when dealing with short strings.
-//
-// Adapted from TU Munich Umbra and CWI DuckDB.
-//
-// TODO: Extend the interface to parity with folly::StringPiece as needed.
+/// C++ container to store a variable length string (or binary type) optimized
+/// for use in Vectors.
+///
+/// StringView provides a lightweight, non-owning view of string data with
+/// semantics similar to std::string or std::string_view. It implements the
+/// following space optimization:
+///
+/// - Strings <= 12 bytes: Fully inlined, no heap allocation or pointer
+///     indirection.
+/// - Strings > 12 bytes: Stores pointer + caches first 4 bytes as prefix.
+///
+/// The prefix caching enables early comparison failures and reduces CPU cache
+/// pressure when working with large sets of strings.
+///
+/// Memory Layout (16 bytes total):
+/// - 4 bytes: size.
+/// - 4 bytes: prefix (first 4 chars, or part of inline data).
+/// - 8 bytes: either inline data continuation OR pointer to external data.
+///
+/// Key Characteristics:
+/// - Non-owning: Does not manage lifetime of referenced data.
+/// - Immutable: Provides const access to underlying data.
+/// - Efficient comparisons: Uses prefix and size for fast inequality checks.
+/// - Zero-overhead for small strings: Fully inlined with no allocations.
+///
+/// Conversions:
+/// - Implicit: from char*, std::string_view (const& only).
+/// - Explicit: from std::string, folly::StringPiece.
+///
+/// Safety Notes:
+/// - StringView does NOT own the data it references.
+/// - Callers must ensure referenced data outlives the StringView.
+/// - Conversion to views from temporaries is explicitly deleted to prevent
+///   dangling references to inlined data.
 struct StringView {
  public:
   using value_type = char;
@@ -69,7 +95,17 @@ struct StringView {
       // small string: inlined. Zero the last 8 bytes first to allow for whole
       // word comparison.
       value_.data = nullptr;
+#ifdef __GNUC__
+      // Use asm volatile to prevent GCC's interprocedural analysis from
+      // incorrectly concluding that size could exceed kInlineSize. This is a
+      // workaround for a false positive -Wstringop-overflow warning when GCC
+      // cannot prove the size constraint through deep template inlining.
+      auto sz = static_cast<size_t>(size_);
+      asm volatile("" : "+r"(sz));
+      memcpy(prefix_, data, sz);
+#else
       memcpy(prefix_, data, size_);
+#endif
     } else {
       // large string: store pointer
       memcpy(prefix_, data, kPrefixSize);
@@ -77,20 +113,16 @@ struct StringView {
     }
   }
 
-  static StringView makeInline(std::string str) {
-    VELOX_DCHECK(isInline(str.size()));
-    return StringView{str};
-  }
-
-  // Making StringView implicitly constructible/convertible from char* and
-  // string literals, in order to allow for a more flexible API and optional
-  // interoperability. E.g:
-  //
-  //   StringView sv = "literal";
-  //   std::optional<StringView> osv = "literal";
-  //
-  /* implicit */ StringView(const char* data)
+  /// Enabling StringView to be implicitly constructed from char* and
+  /// string literals, in order to allow for a more flexible API and optional
+  /// interoperability. E.g:
+  ///
+  /// >  StringView sv = "literal";
+  /// >  std::optional<StringView> osv = "literal";
+  ///
+  /* implicit */ StringView(const char* FOLLY_NONNULL data)
       : StringView(data, strlen(data)) {}
+  /* implicit */ StringView(std::nullptr_t) = delete;
 
   explicit StringView(const folly::fbstring& value)
       : StringView(value.data(), value.size()) {}
@@ -111,7 +143,19 @@ struct StringView {
     return size <= kInlineSize;
   }
 
-  const char* data() && = delete;
+  /// Convenience method to create an inline StringView. The API client is
+  /// reponsible for providing a string that is small enough to fit inline
+  /// (i.e <= kInlineSize).
+  static StringView makeInline(std::string_view input) {
+    VELOX_DCHECK(
+        isInline(input.size()),
+        "StringView::makeInline() requires an input string that fits "
+        "inline (got string size of {}).",
+        input.size());
+    return StringView{input};
+  }
+
+  const char* data() const&& = delete;
   const char* data() const& {
     return isInline() ? prefix_ : value_.data;
   }
@@ -149,9 +193,9 @@ struct StringView {
                size_ - kPrefixSize) == 0;
   }
 
-  // Returns 0, if this == other
-  //       < 0, if this < other
-  //       > 0, if this > other
+  /// Returns 0, if this == other
+  ///       < 0, if this < other
+  ///       > 0, if this > other
   int32_t compare(const StringView& other) const {
     if (prefixAsInt() != other.prefixAsInt()) {
       // The result is decided on prefix. The shorter will be less because the
@@ -179,43 +223,63 @@ struct StringView {
                    : std::strong_ordering::equal;
   }
 
-  operator folly::StringPiece() && = delete;
-  operator folly::StringPiece() const& {
+  /// Conversion to folly::StringPiece can only be done explicitly. For example,
+  /// this is ok:
+  ///
+  /// > StringView sv();
+  /// > folly::StringPiece sp(sv);
+  ///
+  /// but no:
+  ///
+  /// > StringView sv();
+  /// > folly::StringPiece sp = sv;
+  ///
+  /// Note that we also explicitly disable conversion from a temporary (rvalue)
+  /// because this could have resulted in a folly::StringPiece wrapping around a
+  /// temporary buffer, if the StringView was inlined:
+  ///
+  /// > folly::StringPiece sp(StringView()); // unsafe, won't compile.
+  ///
+  explicit operator folly::StringPiece() const&& = delete;
+  explicit operator folly::StringPiece() const& {
     return folly::StringPiece(data(), size());
   }
 
-  operator std::string() const {
+  /// Similarly, conversion to std::string can only be done explicitly, since
+  /// this may result in an allocation and string copy.
+  ///
+  /// Note that in this case it is ok to enable conversion from a temporary
+  /// (rvalue) StringView since its contents will be copied into the
+  /// std::string.
+  ///
+  /// > std::string str(StringView()); // ok
+  explicit operator std::string() const {
     return std::string(data(), size());
   }
 
-  std::string str() const {
-    return *this;
-  }
-
-  std::string getString() const {
-    return *this;
-  }
-
-  std::string materialize() const {
-    return *this;
-  }
-
-  operator folly::dynamic() && = delete;
-  operator folly::dynamic() const& {
-    return folly::dynamic(folly::StringPiece(data(), size()));
-  }
-
-  operator std::string_view() && = delete;
-  explicit operator std::string_view() const& {
+  /// Conversion to std::string_view are allowed to be implicit, as long as they
+  /// are not from a temporary (rvalue) StringView, for the same reasons
+  /// described above.
+  /* implicit */ operator std::string_view() const&& = delete;
+  /* implicit */ operator std::string_view() const& {
     return std::string_view(data(), size());
   }
 
-  const char* begin() && = delete;
+  /// TODO: Should make this explicit-only.
+  ///
+  /// Note that in this case it is ok to enable conversion from a temporary
+  /// (rvalue) StringView since its contents will be copied into the
+  /// folly::dynamic.
+  ///
+  /// > folly::dynamic str(StringView()); // ok
+  /* implicit */ operator folly::dynamic() const;
+
+  const char* begin() const&& = delete;
   const char* begin() const& {
     return data();
   }
 
-  const char* end() && = delete;
+  const char* end() const&& = delete;
   const char* end() const& {
     return data() + size();
   }
@@ -224,13 +288,28 @@ struct StringView {
     return size() == 0;
   }
 
-  /// Searches for 'key == strings[i]'for i >= 0 < numStrings. If
-  /// 'indices' is given. searches for 'key ==
-  /// strings[indices[i]]. Returns the first i for which the strings
-  /// match or -1 if no match is found. Uses SIMD to accelerate the
-  /// search. Accesses StringView bodies in 32 byte vectors, thus
-  /// expects up to 31 bytes of addressable padding after out of
-  /// line strings. This is the case for velox Buffers.
+  /// Convenience common std::string conversion aliases.
+  std::string str() const {
+    return std::string(*this);
+  }
+
+  std::string getString() const {
+    return std::string(*this);
+  }
+
+  std::string materialize() const {
+    return std::string(*this);
+  }
+
+  /// Searches for 'key == strings[i]' for i >= 0 < numStrings.
+  ///
+  /// If 'indices' is given, searches for 'key == strings[indices[i]]'. Returns
+  /// the first i for which the strings match or -1 if no match is found. Uses
+  /// SIMD to accelerate the search.
+  ///
+  /// Accesses StringView bodies in 32 byte vectors, thus expects up to 31 bytes
+  /// of addressable padding after out of line strings. This is the case for
+  /// velox Buffers.
   static int32_t linearSearch(
       StringView key,
       const StringView* strings,
@@ -238,11 +317,11 @@ struct StringView {
       int32_t numStrings);
 
  private:
-  inline int64_t sizeAndPrefixAsInt64() const {
+  int64_t sizeAndPrefixAsInt64() const {
     return reinterpret_cast<const int64_t*>(this)[0];
   }
 
-  inline int64_t inlinedAsInt64() const {
+  int64_t inlinedAsInt64() const {
     return reinterpret_cast<const int64_t*>(this)[1];
   }
 
@@ -268,6 +347,16 @@ inline StringView operator""_sv(const char* str, size_t len) {
   return StringView(str, len);
 }
 
+// Specializations needed for string conversion in folly/Conv.h.
+template <class TString>
+inline void toAppend(const StringView& value, TString* result) {
+  result->append(value);
+}
+
+inline size_t estimateSpaceNeeded(const StringView& value) {
+  return value.size();
+}
+
 } // namespace facebook::velox
 
 namespace std {
@@ -280,6 +369,7 @@ struct hash<::facebook::velox::StringView> {
 } // namespace std
 
 namespace folly {
+
 template <>
 struct hasher<::facebook::velox::StringView> {
   size_t operator()(const ::facebook::velox::StringView view) const {
diff --git a/velox/type/Subfield.cpp b/velox/type/Subfield.cpp
index 7c0f9bb84ab..449b37d7604 100644
--- a/velox/type/Subfield.cpp
+++ b/velox/type/Subfield.cpp
@@ -14,8 +14,10 @@
  * limitations under the License.
  */
 #include "velox/type/Subfield.h"
+
 #include <boost/algorithm/string/replace.hpp>
 #include <folly/container/F14Map.h>
+#include "velox/common/EnumDefine.h"
 #include "velox/type/Tokenizer.h"
 
 namespace facebook::velox::common {
diff --git a/velox/type/Subfield.h b/velox/type/Subfield.h
index 437f3d6cf4d..7b4607eb1b0 100644
--- a/velox/type/Subfield.h
+++ b/velox/type/Subfield.h
@@ -16,9 +16,10 @@
 #pragma once
 
 #include <fmt/format.h>
+#include <folly/hash/Hash.h>
 #include <ostream>
 
-#include "velox/common/Enums.h"
+#include "velox/common/EnumDeclare.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/Macros.h"
 
@@ -87,6 +88,14 @@ class Subfield {
       return dynamic_cast<const T*>(this);
     }
 
+    template <typename T>
+    const T* asChecked() const {
+      auto* ptr = dynamic_cast<const T*>(this);
+      VELOX_CHECK_NOT_NULL(
+          ptr, "PathElement is not of expected type. Actual kind: {}", kind_);
+      return ptr;
+    }
+
    private:
     const SubfieldKind kind_;
   };
@@ -133,7 +142,7 @@ class Subfield {
     }
 
     size_t hash() const override {
-      return std::hash<std::string>()(name_);
+      return folly::hasher<std::string_view>()(name_);
     }
 
     std::string toString() const override {
@@ -199,7 +208,7 @@ class Subfield {
     }
 
     size_t hash() const override {
-      return std::hash<std::string>()(index_);
+      return folly::hasher<std::string_view>()(index_);
     }
 
     std::string toString() const override;
diff --git a/velox/type/Time.cpp b/velox/type/Time.cpp
new file mode 100644
index 00000000000..02316083fca
--- /dev/null
+++ b/velox/type/Time.cpp
@@ -0,0 +1,360 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/type/Time.h"
+#include <charconv>
+#include "velox/type/TimestampConversion.h"
+
+namespace facebook::velox::util {
+
+namespace {
+
+// Helper: Parse a number from the given position using std::from_chars
+bool parseNumber(const char* data, size_t size, size_t& pos, int32_t& result) {
+  if (pos >= size) {
+    return false;
+  }
+
+  const char* start = data + pos;
+  const char* end = data + size;
+
+  auto parseResult = std::from_chars(start, end, result);
+  if (parseResult.ec != std::errc{}) {
+    return false;
+  }
+
+  // Update position
+  pos += (parseResult.ptr - start);
+  return true;
+}
+
+// Helper: Parse fractional seconds (milliseconds)
+Expected<int32_t>
+parseFractionalSeconds(const char* data, size_t size, size_t& pos) {
+  if (pos >= size || data[pos] != '.') {
+    return 0; // No fractional part
+  }
+
+  pos++; // Skip the '.'
+
+  if (pos >= size) {
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Invalid time format: fractional seconds incomplete"));
+  }
+
+  // Parse fractional seconds (milliseconds)
+  int32_t fractionalPart = 0;
+
+  const char* start = data + pos;
+  const char* end = data + size;
+
+  auto parseResult = std::from_chars(start, end, fractionalPart);
+  if (parseResult.ec != std::errc{}) {
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Invalid time format: failed to parse fractional seconds"));
+  }
+
+  size_t digitCount = parseResult.ptr - start;
+  pos += digitCount;
+
+  // Check that we don't have more than 3 digits (millisecond precision)
+  if (digitCount > 3) {
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Invalid time format: Microsecond precision not supported"));
+  }
+
+  // Convert to milliseconds by padding with zeros if needed
+  // e.g., .1 -> 100ms, .12 -> 120ms, .123 -> 123ms
+  for (size_t i = digitCount; i < 3; i++) {
+    fractionalPart *= 10;
+  }
+
+  return fractionalPart;
+}
+
+// Helper: Validate time components
+Status validateTimeComponents(const TimeComponents& components) {
+  if (components.hour < 0 || components.hour >= kHoursPerDay) {
+    return Status::UserError("Invalid hour value: {}", components.hour);
+  }
+  if (components.minute < 0 || components.minute >= kMinsPerHour) {
+    return Status::UserError("Invalid minute value: {}", components.minute);
+  }
+  if (components.second < 0 || components.second >= kSecsPerMinute) {
+    return Status::UserError("Invalid second value: {}", components.second);
+  }
+  if (components.millis < 0 || components.millis >= kMsecsPerSec) {
+    return Status::UserError(
+        "Invalid millisecond value: {}", components.millis);
+  }
+  return Status::OK();
+}
+
+// Helper: Convert time components to milliseconds since midnight
+Expected<int64_t> timeComponentsToMillis(const TimeComponents& components) {
+  int64_t result = static_cast<int64_t>(components.hour) * kMillisInHour +
+      static_cast<int64_t>(components.minute) * kMillisInMinute +
+      static_cast<int64_t>(components.second) * kMillisInSecond +
+      static_cast<int64_t>(components.millis);
+
+  // Validate time range (0 to 86399999 ms in a day)
+  if (result < 0 || result >= kMillisInDay) {
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Time value {} is out of range [0, {})", result, kMillisInDay));
+  }
+
+  return result;
+}
+
+// Helper: Parse time components from string (H:m[:s[.SSS]])
+Expected<TimeComponents> parseTimeComponents(const char* buf, size_t len) {
+  TimeComponents components;
+  size_t pos = 0;
+
+  // Parse hour (required, 1-2 digits)
+  if (!parseNumber(buf, len, pos, components.hour)) {
+    return folly::makeUnexpected(
+        Status::UserError("Invalid time format: failed to parse hour"));
+  }
+
+  // Skip first ':'
+  if (pos >= len || buf[pos] != ':') {
+    return folly::makeUnexpected(
+        Status::UserError("Invalid time format: expected ':' after hour"));
+  }
+  pos++;
+
+  // Parse minute (required, 1-2 digits)
+  if (!parseNumber(buf, len, pos, components.minute)) {
+    return folly::makeUnexpected(
+        Status::UserError("Invalid time format: failed to parse minute"));
+  }
+
+  // Check if there's a second ':' for seconds (OPTIONAL)
+  if (pos < len && buf[pos] == ':') {
+    pos++; // Skip the ':'
+
+    // Parse second (optional, 1-2 digits)
+    if (!parseNumber(buf, len, pos, components.second)) {
+      return folly::makeUnexpected(
+          Status::UserError("Invalid time format: failed to parse second"));
+    }
+
+    // Parse optional fractional seconds
+    auto millisResult = parseFractionalSeconds(buf, len, pos);
+    if (millisResult.hasError()) {
+      return folly::makeUnexpected(millisResult.error());
+    }
+    components.millis = millisResult.value();
+  }
+  // If no second ':', seconds and millis remain at 0 (default)
+
+  // Check for trailing characters
+  if (pos < len) {
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Invalid time format: unexpected trailing characters at position {}",
+            pos));
+  }
+
+  return components;
+}
+
+} // namespace
+
+Expected<int64_t> fromTimeString(const char* buf, size_t len) {
+  auto componentsResult = parseTimeComponents(buf, len);
+  if (componentsResult.hasError()) {
+    return folly::makeUnexpected(componentsResult.error());
+  }
+
+  auto components = componentsResult.value();
+
+  // Validate all components
+  auto validationStatus = validateTimeComponents(components);
+  if (!validationStatus.ok()) {
+    return folly::makeUnexpected(validationStatus);
+  }
+
+  // Convert to milliseconds since midnight
+  return timeComponentsToMillis(components);
+}
+
+Expected<int16_t>
+parseTimezoneOffset(const char* buf, size_t len, bool allowCompactFormat) {
+  if (len < 2) {
+    return folly::makeUnexpected(
+        Status::UserError("Invalid timezone offset: too short"));
+  }
+
+  char sign = buf[0];
+  if (sign != '+' && sign != '-') {
+    return folly::makeUnexpected(
+        Status::UserError("Invalid timezone offset: must start with + or -"));
+  }
+
+  int signMultiplier = (sign == '+') ? 1 : -1;
+
+  // Start parsing after the sign
+  size_t pos = 1;
+  const size_t startPos = pos;
+
+  // Parse offset hours/minutes
+  // Supports formats based on allowCompactFormat flag:
+  // Always supported:
+  //   1. +HH:mm (e.g., +07:09) - colon separates hours and minutes
+  //   2. +HH (e.g., +07) - exactly 2 digits, no colon
+  // Conditionally supported (allowCompactFormat=true):
+  //   3. +HHmm (e.g., +0709) - exactly 4 digits, no colon
+
+  int32_t offsetHours = 0;
+  int32_t offsetMinutes = 0;
+
+  // Try to parse as many digits as we can for hours
+  if (!parseNumber(buf, len, pos, offsetHours)) {
+    return folly::makeUnexpected(
+        Status::UserError("Invalid timezone offset: failed to parse hours"));
+  }
+
+  size_t digitsRead = pos - startPos;
+
+  // Check what comes next
+  if (pos < len && buf[pos] == ':') {
+    // Format: +HH:mm
+    // Hours should be 2 digits only when followed by colon
+    if (digitsRead != 2) {
+      return folly::makeUnexpected(
+          Status::UserError(
+              "Invalid timezone offset format: digits before ':' not equal to 2"));
+    }
+    pos++; // Skip ':'
+    if (!parseNumber(buf, len, pos, offsetMinutes)) {
+      return folly::makeUnexpected(
+          Status::UserError(
+              "Invalid timezone offset: failed to parse minutes after ':'"));
+    }
+  } else if (digitsRead == 4) {
+    // Format: +HHmm (e.g., +0709)
+    // Only allowed if allowCompactFormat is true
+    if (!allowCompactFormat) {
+      return folly::makeUnexpected(
+          Status::UserError(
+              "Invalid timezone offset format: compact format +HHmm not allowed, use +HH:mm or +HH"));
+    }
+    // Extract last 2 digits as minutes
+    offsetMinutes = offsetHours % 100;
+    offsetHours = offsetHours / 100;
+  } else if (digitsRead != 2) {
+    // Valid : 2
+    //    Format: +HH (e.g., +07)
+    //    Minutes remain 0
+    // Invalid: 1, 3, or 5+ digits without colon
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Invalid timezone offset format: expected +HH:mm or +HH"));
+  }
+
+  // Check for trailing characters
+  if (pos < len) {
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Invalid timezone offset: unexpected trailing characters at position {}",
+            pos));
+  }
+
+  // Calculate total offset in minutes
+  auto totalOffsetMinutes =
+      (signMultiplier * (offsetHours * 60 + offsetMinutes));
+
+  // Validate timezone offset range (-840 to 840 minutes, i.e., -14:00 to
+  // +14:00)
+  if (totalOffsetMinutes < -kTimeZoneBias ||
+      totalOffsetMinutes > kTimeZoneBias) {
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Timezone offset {} minutes is out of range [-840, 840]",
+            totalOffsetMinutes));
+  }
+
+  return static_cast<int16_t>(totalOffsetMinutes);
+}
+
+Expected<int64_t> fromTimeWithTimezoneString(
+    const char* buf,
+    size_t len,
+    bool allowCompactFormat) {
+  if (len == 0) {
+    return folly::makeUnexpected(
+        Status::UserError("Invalid time with timezone: empty string"));
+  }
+
+  // Find timezone offset marker (+ or -)
+  // Search from right to left for better performance
+  std::string_view sv(buf, len);
+  auto tzPos = sv.find_last_of("+-");
+  int tzStartPos =
+      (tzPos != std::string_view::npos) ? static_cast<int>(tzPos) : -1;
+
+  if (tzStartPos == -1) {
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Invalid time with timezone: missing timezone offset"));
+  }
+
+  // Extract time component (before timezone, trimming optional space)
+  int timeEndPos = tzStartPos;
+  if (timeEndPos > 0 && buf[timeEndPos - 1] == ' ') {
+    timeEndPos--; // Remove space before timezone
+  }
+
+  if (timeEndPos == 0) {
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Invalid time with timezone: missing time component"));
+  }
+
+  // Parse time component
+  auto timeResult = fromTimeString(buf, timeEndPos);
+  if (timeResult.hasError()) {
+    return folly::makeUnexpected(timeResult.error());
+  }
+
+  int64_t millisLocal = timeResult.value();
+
+  // Parse timezone offset, passing through the allowCompactFormat flag
+  auto tzOffsetResult = parseTimezoneOffset(
+      buf + tzStartPos, len - tzStartPos, allowCompactFormat);
+  if (tzOffsetResult.hasError()) {
+    return folly::makeUnexpected(tzOffsetResult.error());
+  }
+
+  int16_t offsetMinutes = tzOffsetResult.value();
+
+  // Convert local time to UTC using utility function
+  // Example: 12:00:00+05:30 means the local time is 12:00 in UTC+5:30
+  // To get UTC time, we subtract 5:30, resulting in 06:30:00 UTC
+  int64_t millisUtc = localToUtcTime(millisLocal, offsetMinutes);
+
+  // Encode timezone offset and pack with time
+  int16_t encodedTimezone = biasEncode(offsetMinutes);
+  return pack(millisUtc, encodedTimezone);
+}
+
+} // namespace facebook::velox::util
diff --git a/velox/type/Time.h b/velox/type/Time.h
new file mode 100644
index 00000000000..d0329d92901
--- /dev/null
+++ b/velox/type/Time.h
@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include "velox/common/base/Status.h"
+#include "velox/type/StringView.h"
+
+namespace facebook::velox::util {
+
+// Constants for time calculations (aligned with TimestampConversion.h)
+constexpr const int64_t kMillisInSecond = 1000;
+constexpr const int64_t kMillisInMinute = 60 * kMillisInSecond;
+constexpr const int64_t kMillisInHour = 60 * kMillisInMinute;
+constexpr const int64_t kMillisInDay = 24 * kMillisInHour;
+
+/// Represents parsed time components
+struct TimeComponents {
+  int32_t hour = 0;
+  int32_t minute = 0;
+  int32_t second = 0;
+  int32_t millis = 0;
+};
+
+/// Parse a TIME string (H:m[:s[.SSS]] format)
+/// Supports formats:
+/// - "H:m" -> "1:30"
+/// - "H:m:s" -> "1:30:45"
+/// - "H:m:s.SSS" -> "1:30:45.123"
+///
+/// Returns milliseconds since midnight (0 to 86399999)
+/// Returns Unexpected with UserError status if parsing fails
+Expected<int64_t> fromTimeString(const char* buf, size_t len);
+
+inline Expected<int64_t> fromTimeString(const StringView& str) {
+  return fromTimeString(str.data(), str.size());
+}
+
+// Constants for TIME WITH TIME ZONE encoding
+constexpr int32_t kMillisShift = 12;
+constexpr int32_t kTimezoneMask = (1 << kMillisShift) - 1;
+constexpr int16_t kTimeZoneBias = 840;
+constexpr int16_t kMinutesInHour = 60;
+
+/// Unpacks the milliseconds since midnight from a packed TIME WITH TIME ZONE
+/// value
+inline int64_t unpackMillisUtc(int64_t timeWithTimeZone) {
+  return timeWithTimeZone >> kMillisShift;
+}
+
+/// Unpacks the timezone offset from a packed TIME WITH TIME ZONE value
+inline int16_t unpackZoneOffset(int64_t timeWithTimeZone) {
+  return timeWithTimeZone & kTimezoneMask;
+}
+
+/// Packs milliseconds since midnight and timezone offset into a 64-bit value
+/// The packed value stores time in the upper bits and timezone in the lower 12
+/// bits
+inline int64_t pack(int64_t millisUtc, int16_t timeZoneKey) {
+  return (millisUtc << kMillisShift) | (timeZoneKey & kTimezoneMask);
+}
+
+/// Encodes timezone offset using bias encoding to ensure positive values
+/// This aligns with the bias encoding used in Presto for offsets
+/// Converts timezone offset from range [-840, 840] to [0, 1680]
+/// 0 -> 0
+/// [-840, -1] -> [1, 840]
+/// [1, 840] -> [841, 1680]
+inline int16_t biasEncode(int16_t timeZoneOffsetMinutes) {
+  VELOX_CHECK(
+      -kTimeZoneBias <= timeZoneOffsetMinutes &&
+          timeZoneOffsetMinutes <= kTimeZoneBias,
+      "Timezone offset must be between -840 and 840 minutes. Got: {}",
+      timeZoneOffsetMinutes);
+
+  if (timeZoneOffsetMinutes == 0) {
+    return 0;
+  }
+  if (timeZoneOffsetMinutes < 0) {
+    return timeZoneOffsetMinutes + kTimeZoneBias + 1;
+  }
+  return timeZoneOffsetMinutes + kTimeZoneBias;
+}
+
+/// Decode timezone offset from bias-encoded value
+/// Converts from bias-encoded range [0, 1680] to signed offset [-840, 840]
+/// This is the inverse of biasEncode():
+///   - 0 → 0 (UTC)
+///   - [1, 840] → [-840, -1] (negative offsets)
+///   - [841, 1680] → [1, 840] (positive offsets)
+///
+/// @param encodedTimezone Bias-encoded timezone [0, 1680]
+/// @return Timezone offset in minutes [-840, 840]
+inline int16_t decodeTimezoneOffset(int16_t encodedTimezone) {
+  if (encodedTimezone == 0) {
+    return 0;
+  }
+  if (encodedTimezone <= kTimeZoneBias) {
+    return encodedTimezone - kTimeZoneBias - 1;
+  }
+  return encodedTimezone - kTimeZoneBias;
+}
+
+/// Parse a TIME WITH TIME ZONE string and return packed 64-bit value
+/// Supports formats (with optional space before timezone):
+/// - "H:m+HH:mm" or "H:m +HH:mm" -> "1:30+05:30" or "1:30 +05:30"
+/// - "H:m:s+HH:mm" or "H:m:s +HH:mm" -> "1:30:45+05:30"
+/// - "H:m:s.SSS+HH:mm" -> "1:30:45.123+05:30"
+/// - "H:m+HHmm" -> "1:30+0530" (only if allowCompactFormat=true)
+/// - "H:m+HH" or "H:m +HH" -> "1:30+05" or "1:30 +05"
+/// - "H:m:s+HH" -> "1:30:45+05"
+/// - "H:m:s.SSS+HH" -> "1:30:45.123+05"
+///
+/// @param buf Pointer to the TIME WITH TIME ZONE string
+/// @param len Length of the string
+/// @param allowCompactFormat If true, accepts +HHmm format for timezone offset.
+///                           Default is true for backward compatibility.
+/// @return Packed 64-bit value where the upper bits contain milliseconds
+///         since midnight and the lower 12 bits contain the bias-encoded
+///         timezone offset.
+/// @return Unexpected with UserError status if parsing fails
+Expected<int64_t> fromTimeWithTimezoneString(
+    const char* buf,
+    size_t len,
+    bool allowCompactFormat = true);
+
+inline Expected<int64_t> fromTimeWithTimezoneString(
+    const StringView& str,
+    bool allowCompactFormat = true) {
+  return fromTimeWithTimezoneString(str.data(), str.size(), allowCompactFormat);
+}
+
+/// Parse timezone offset from string
+/// Supports formats:
+/// - "+HH:mm" or "-HH:mm" -> "+05:30", "-08:00"
+/// - "+HH" or "-HH" -> "+05", "-08"
+/// - "+HHmm" or "-HHmm" -> "+0530", "-0800" (only if allowCompactFormat=true)
+///
+/// @param buf Pointer to the timezone offset string
+/// @param len Length of the string
+/// @param allowCompactFormat If true, accepts +HHmm format in addition to
+///                           Presto-compatible formats (+HH:mm, +HH).
+///                           Default is true for backward compatibility.
+/// @return Timezone offset in minutes (-840 to 840)
+/// @return Unexpected with UserError status if parsing fails
+Expected<int16_t> parseTimezoneOffset(
+    const char* buf,
+    size_t len,
+    bool allowCompactFormat = true);
+
+inline Expected<int16_t> parseTimezoneOffset(
+    const StringView& str,
+    bool allowCompactFormat = true) {
+  return parseTimezoneOffset(str.data(), str.size(), allowCompactFormat);
+}
+
+/// Convert UTC time to local time by adding timezone offset
+/// Handles day boundary wrap-around (since max timezone offset is ±14 hours,
+/// only one day boundary crossing is possible)
+///
+/// @param millisUtc UTC time in milliseconds since midnight [0, kMillisInDay)
+/// @param offsetMinutes Timezone offset in minutes [-840, 840]
+/// @return Local time in milliseconds since midnight [0, kMillisInDay)
+inline int64_t utcToLocalTime(int64_t millisUtc, int16_t offsetMinutes) {
+  VELOX_DCHECK_GE(millisUtc, 0);
+  VELOX_DCHECK_LT(millisUtc, kMillisInDay);
+  int64_t millisLocal = millisUtc + (offsetMinutes * kMillisInMinute);
+
+  // Handle wrap-around for local time
+  if (millisLocal < 0) {
+    millisLocal += kMillisInDay;
+  } else if (millisLocal >= kMillisInDay) {
+    millisLocal -= kMillisInDay;
+  }
+
+  return millisLocal;
+}
+
+/// Convert local time to UTC by subtracting timezone offset
+/// Handles day boundary wrap-around (since max timezone offset is ±14 hours,
+/// only one day boundary crossing is possible)
+///
+/// @param millisLocal Local time in milliseconds since midnight [0,
+/// kMillisInDay)
+/// @param offsetMinutes Timezone offset in minutes [-840, 840]
+/// @return UTC time in milliseconds since midnight [0, kMillisInDay)
+inline int64_t localToUtcTime(int64_t millisLocal, int16_t offsetMinutes) {
+  int64_t millisUtc = millisLocal - (offsetMinutes * kMillisInMinute);
+
+  // Handle wrap-around for UTC time
+  if (millisUtc < 0) {
+    millisUtc += kMillisInDay;
+  } else if (millisUtc >= kMillisInDay) {
+    millisUtc -= kMillisInDay;
+  }
+
+  return millisUtc;
+}
+
+} // namespace facebook::velox::util
diff --git a/velox/type/Timestamp.cpp b/velox/type/Timestamp.cpp
index e159596cab9..b5c876ee57b 100644
--- a/velox/type/Timestamp.cpp
+++ b/velox/type/Timestamp.cpp
@@ -14,14 +14,37 @@
  * limitations under the License.
  */
 #include "velox/type/Timestamp.h"
+
 #include <charconv>
 #include <chrono>
+
+#include <folly/dynamic.h>
+
 #include "velox/common/base/CountBits.h"
 #include "velox/external/tzdb/exception.h"
+#include "velox/type/FastDate.h"
+#include "velox/type/WideRangeDateConversion.h"
 #include "velox/type/tz/TimeZoneMap.h"
 
 namespace facebook::velox {
 
+Timestamp Timestamp::create(const folly::dynamic& obj) {
+  auto seconds = obj["seconds"].asInt();
+  auto nanos = obj["nanos"].asInt();
+  return Timestamp(seconds, nanos);
+}
+
+Timestamp::operator folly::dynamic() const {
+  return folly::dynamic(seconds_);
+}
+
+folly::dynamic Timestamp::serialize() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["seconds"] = seconds_;
+  obj["nanos"] = nanos_;
+  return obj;
+}
+
 // static
 Timestamp Timestamp::fromDaysAndNanos(int32_t days, int64_t nanos) {
   int64_t seconds =
@@ -135,43 +158,40 @@ const int16_t daysBeforeFirstDayOfMonth[][12] = {
 } // namespace
 
 bool Timestamp::epochToCalendarUtc(int64_t epoch, std::tm& tm) {
-  constexpr int kDaysPerYear = 365;
   int64_t days = epoch / kSecondsPerDay;
   int64_t rem = epoch % kSecondsPerDay;
-  while (rem < 0) {
+  if (rem < 0) {
     rem += kSecondsPerDay;
     --days;
   }
-  tm.tm_hour = rem / kSecondsPerHour;
-  rem = rem % kSecondsPerHour;
-  tm.tm_min = rem / 60;
-  tm.tm_sec = rem % 60;
-  tm.tm_wday = (4 + days) % 7;
-  if (tm.tm_wday < 0) {
-    tm.tm_wday += 7;
-  }
-  int64_t y = 1970;
-  if (y + days / kDaysPerYear <= -kLeapYearOffset + 10) {
-    return false;
-  }
-  bool leapYear;
-  while (days < 0 || days >= kDaysPerYear + (leapYear = isLeap(y))) {
-    auto newy = y + days / kDaysPerYear - (days < 0);
-    days -= daysBetweenYears(y, newy);
-    y = newy;
-  }
-  y -= kTmYearBase;
-  if (y > std::numeric_limits<decltype(tm.tm_year)>::max() ||
-      y < std::numeric_limits<decltype(tm.tm_year)>::min()) {
-    return false;
+  // Fast path: Neri-Schneider 2022 covers ~3 million years centered on the
+  // epoch — vastly wider than any practical Velox DATE / TIMESTAMP.
+  // Inputs outside this range delegate to WideRangeDateConversion.
+  if (FOLLY_LIKELY(
+          days >= fast_date::kRataDieMin && days <= fast_date::kRataDieMax)) {
+    tm.tm_hour = rem / kSecondsPerHour;
+    rem = rem % kSecondsPerHour;
+    tm.tm_min = rem / 60;
+    tm.tm_sec = rem % 60;
+    tm.tm_wday = (4 + days) % 7;
+    if (tm.tm_wday < 0) {
+      tm.tm_wday += 7;
+    }
+    const auto ymd = daysToYmd(static_cast<int32_t>(days));
+    const int64_t y = static_cast<int64_t>(ymd.year) - kTmYearBase;
+    if (y > std::numeric_limits<decltype(tm.tm_year)>::max() ||
+        y < std::numeric_limits<decltype(tm.tm_year)>::min()) {
+      return false;
+    }
+    tm.tm_year = static_cast<int>(y);
+    const auto* monthOffsets = daysBeforeFirstDayOfMonth[isLeap(ymd.year)];
+    tm.tm_mon = static_cast<int>(ymd.month) - 1;
+    tm.tm_mday = static_cast<int>(ymd.day);
+    tm.tm_yday = monthOffsets[tm.tm_mon] + tm.tm_mday - 1;
+    tm.tm_isdst = 0;
+    return true;
   }
-  tm.tm_year = y;
-  tm.tm_yday = days;
-  auto* months = daysBeforeFirstDayOfMonth[leapYear];
-  tm.tm_mon = std::upper_bound(months, months + 12, days) - months - 1;
-  tm.tm_mday = days - months[tm.tm_mon] + 1;
-  tm.tm_isdst = 0;
-  return true;
+  return WideRangeDateConversion::epochToCalendarUtc(epoch, tm);
 }
 
 // static
@@ -202,7 +222,7 @@ StringView Timestamp::tmToStringView(
     uint64_t nanos,
     const TimestampToStringOptions& options,
     char* const startPosition) {
-  VELOX_DCHECK_LT(nanos, 1'000'000'000);
+  VELOX_CHECK_LT(nanos, 1'000'000'000);
 
   const auto appendDigits = [](const int value,
                                const std::optional<uint32_t> minWidth,
@@ -352,10 +372,6 @@ std::string::size_type getMaxStringLength(
   }
 }
 
-void parseTo(folly::StringPiece in, ::facebook::velox::Timestamp& out) {
-  // TODO Implement
-}
-
 } // namespace facebook::velox
 
 namespace std {
diff --git a/velox/type/Timestamp.h b/velox/type/Timestamp.h
index b57520a1dd6..73748c6ba6f 100644
--- a/velox/type/Timestamp.h
+++ b/velox/type/Timestamp.h
@@ -15,15 +15,16 @@
  */
 #pragma once
 
-#include <iomanip>
-#include <sstream>
+#include <ostream>
 #include <string>
 
-#include <folly/dynamic.h>
-
 #include "velox/common/base/CheckedArithmetic.h"
 #include "velox/type/StringView.h"
 
+namespace folly {
+struct dynamic;
+}
+
 namespace facebook::velox {
 
 namespace tz {
@@ -125,11 +126,7 @@ struct Timestamp {
   // Returns the current unix timestamp (ms precision).
   static Timestamp now();
 
-  static Timestamp create(const folly::dynamic& obj) {
-    auto seconds = obj["seconds"].asInt();
-    auto nanos = obj["nanos"].asInt();
-    return Timestamp(seconds, nanos);
-  }
+  static Timestamp create(const folly::dynamic& obj);
 
   int64_t getSeconds() const {
     return seconds_;
@@ -428,16 +425,9 @@ struct Timestamp {
     return toString();
   }
 
-  operator folly::dynamic() const {
-    return folly::dynamic(seconds_);
-  }
+  operator folly::dynamic() const;
 
-  folly::dynamic serialize() const {
-    folly::dynamic obj = folly::dynamic::object;
-    obj["seconds"] = seconds_;
-    obj["nanos"] = nanos_;
-    return obj;
-  }
+  folly::dynamic serialize() const;
 
   // Pretty printer for gtest.
   friend void PrintTo(const Timestamp& timestamp, std::ostream* os) {
@@ -449,8 +439,6 @@ struct Timestamp {
   uint64_t nanos_;
 };
 
-void parseTo(folly::StringPiece in, ::facebook::velox::Timestamp& out);
-
 template <typename T>
 void toAppend(const ::facebook::velox::Timestamp& value, T* result) {
   result->append(value.toString());
diff --git a/velox/type/TimestampConversion.cpp b/velox/type/TimestampConversion.cpp
index 0cdef8a3dde..4ce2ff0a6a9 100644
--- a/velox/type/TimestampConversion.cpp
+++ b/velox/type/TimestampConversion.cpp
@@ -44,7 +44,9 @@
 #include <folly/Expected.h>
 #include "velox/common/base/CheckedArithmetic.h"
 #include "velox/common/base/Exceptions.h"
+#include "velox/type/FastDate.h"
 #include "velox/type/HugeInt.h"
+#include "velox/type/WideRangeDateConversion.h"
 #include "velox/type/tz/TimeZoneMap.h"
 
 namespace facebook::velox::util {
@@ -53,58 +55,6 @@ constexpr int32_t kLeapDays[] =
     {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
 constexpr int32_t kNormalDays[] =
     {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
-constexpr int32_t kCumulativeDays[] =
-    {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365};
-constexpr int32_t kCumulativeLeapDays[] =
-    {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366};
-
-constexpr int32_t kCumulativeYearDays[] = {
-    0,      365,    730,    1096,   1461,   1826,   2191,   2557,   2922,
-    3287,   3652,   4018,   4383,   4748,   5113,   5479,   5844,   6209,
-    6574,   6940,   7305,   7670,   8035,   8401,   8766,   9131,   9496,
-    9862,   10227,  10592,  10957,  11323,  11688,  12053,  12418,  12784,
-    13149,  13514,  13879,  14245,  14610,  14975,  15340,  15706,  16071,
-    16436,  16801,  17167,  17532,  17897,  18262,  18628,  18993,  19358,
-    19723,  20089,  20454,  20819,  21184,  21550,  21915,  22280,  22645,
-    23011,  23376,  23741,  24106,  24472,  24837,  25202,  25567,  25933,
-    26298,  26663,  27028,  27394,  27759,  28124,  28489,  28855,  29220,
-    29585,  29950,  30316,  30681,  31046,  31411,  31777,  32142,  32507,
-    32872,  33238,  33603,  33968,  34333,  34699,  35064,  35429,  35794,
-    36160,  36525,  36890,  37255,  37621,  37986,  38351,  38716,  39082,
-    39447,  39812,  40177,  40543,  40908,  41273,  41638,  42004,  42369,
-    42734,  43099,  43465,  43830,  44195,  44560,  44926,  45291,  45656,
-    46021,  46387,  46752,  47117,  47482,  47847,  48212,  48577,  48942,
-    49308,  49673,  50038,  50403,  50769,  51134,  51499,  51864,  52230,
-    52595,  52960,  53325,  53691,  54056,  54421,  54786,  55152,  55517,
-    55882,  56247,  56613,  56978,  57343,  57708,  58074,  58439,  58804,
-    59169,  59535,  59900,  60265,  60630,  60996,  61361,  61726,  62091,
-    62457,  62822,  63187,  63552,  63918,  64283,  64648,  65013,  65379,
-    65744,  66109,  66474,  66840,  67205,  67570,  67935,  68301,  68666,
-    69031,  69396,  69762,  70127,  70492,  70857,  71223,  71588,  71953,
-    72318,  72684,  73049,  73414,  73779,  74145,  74510,  74875,  75240,
-    75606,  75971,  76336,  76701,  77067,  77432,  77797,  78162,  78528,
-    78893,  79258,  79623,  79989,  80354,  80719,  81084,  81450,  81815,
-    82180,  82545,  82911,  83276,  83641,  84006,  84371,  84736,  85101,
-    85466,  85832,  86197,  86562,  86927,  87293,  87658,  88023,  88388,
-    88754,  89119,  89484,  89849,  90215,  90580,  90945,  91310,  91676,
-    92041,  92406,  92771,  93137,  93502,  93867,  94232,  94598,  94963,
-    95328,  95693,  96059,  96424,  96789,  97154,  97520,  97885,  98250,
-    98615,  98981,  99346,  99711,  100076, 100442, 100807, 101172, 101537,
-    101903, 102268, 102633, 102998, 103364, 103729, 104094, 104459, 104825,
-    105190, 105555, 105920, 106286, 106651, 107016, 107381, 107747, 108112,
-    108477, 108842, 109208, 109573, 109938, 110303, 110669, 111034, 111399,
-    111764, 112130, 112495, 112860, 113225, 113591, 113956, 114321, 114686,
-    115052, 115417, 115782, 116147, 116513, 116878, 117243, 117608, 117974,
-    118339, 118704, 119069, 119435, 119800, 120165, 120530, 120895, 121260,
-    121625, 121990, 122356, 122721, 123086, 123451, 123817, 124182, 124547,
-    124912, 125278, 125643, 126008, 126373, 126739, 127104, 127469, 127834,
-    128200, 128565, 128930, 129295, 129661, 130026, 130391, 130756, 131122,
-    131487, 131852, 132217, 132583, 132948, 133313, 133678, 134044, 134409,
-    134774, 135139, 135505, 135870, 136235, 136600, 136966, 137331, 137696,
-    138061, 138427, 138792, 139157, 139522, 139888, 140253, 140618, 140983,
-    141349, 141714, 142079, 142444, 142810, 143175, 143540, 143905, 144271,
-    144636, 145001, 145366, 145732, 146097,
-};
 
 namespace {
 
@@ -744,28 +694,26 @@ int32_t getMaxDayOfMonth(int32_t year, int32_t month) {
 
 Expected<int64_t>
 daysSinceEpochFromDate(int32_t year, int32_t month, int32_t day) {
-  int64_t daysSinceEpoch = 0;
-
-  if (!isValidDate(year, month, day)) {
-    if (threadSkipErrorDetails()) {
-      return folly::makeUnexpected(Status::UserError());
+  // Fast path: years strictly inside the fast-date inverse algorithm's
+  // exact domain. The algorithm's date range is bounded by Mar 1 kYearMin
+  // and Feb 28 kYearMax, not the full calendar year on either end, so the
+  // boundary years are excluded entirely to avoid the month-dependent
+  // wrinkle. Loses 2 years of fast-path coverage out of ~3 million —
+  // negligible. Years outside the strict range delegate to
+  // WideRangeDateConversion, which validates and handles the full
+  // [kMinYear, kMaxYear] domain via the loop-based fallback.
+  if (FOLLY_LIKELY(year > fast_date::kYearMin && year < fast_date::kYearMax)) {
+    if (!isValidDate(year, month, day)) {
+      if (threadSkipErrorDetails()) {
+        return folly::makeUnexpected(Status::UserError());
+      }
+      return folly::makeUnexpected(
+          Status::UserError("Date out of range: {}-{}-{}", year, month, day));
     }
-    return folly::makeUnexpected(
-        Status::UserError("Date out of range: {}-{}-{}", year, month, day));
-  }
-  while (year < 1970) {
-    year += kYearInterval;
-    daysSinceEpoch -= kDaysPerYearInterval;
+    return static_cast<int64_t>(ymdToDays(
+        year, static_cast<uint32_t>(month), static_cast<uint32_t>(day)));
   }
-  while (year >= 2370) {
-    year -= kYearInterval;
-    daysSinceEpoch += kDaysPerYearInterval;
-  }
-  daysSinceEpoch += kCumulativeYearDays[year - 1970];
-  daysSinceEpoch += isLeapYear(year) ? kCumulativeLeapDays[month - 1]
-                                     : kCumulativeDays[month - 1];
-  daysSinceEpoch += day - 1;
-  return daysSinceEpoch;
+  return WideRangeDateConversion::daysSinceEpochFromDate(year, month, day);
 }
 
 Expected<int64_t> daysSinceEpochFromWeekDate(
@@ -776,8 +724,9 @@ Expected<int64_t> daysSinceEpochFromWeekDate(
     if (threadSkipErrorDetails()) {
       return folly::makeUnexpected(Status::UserError());
     }
-    return folly::makeUnexpected(Status::UserError(
-        "Date out of range: {}-{}-{}", weekYear, weekOfYear, dayOfWeek));
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Date out of range: {}-{}-{}", weekYear, weekOfYear, dayOfWeek));
   }
 
   return daysSinceEpochFromDate(weekYear, 1, 4)
@@ -801,8 +750,13 @@ Expected<int64_t> daysSinceEpochFromWeekOfMonthDate(
     if (threadSkipErrorDetails()) {
       return folly::makeUnexpected(Status::UserError());
     }
-    return folly::makeUnexpected(Status::UserError(
-        "Date out of range: {}-{}-{}-{}", year, month, weekOfMonth, dayOfWeek));
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Date out of range: {}-{}-{}-{}",
+            year,
+            month,
+            weekOfMonth,
+            dayOfWeek));
   }
 
   // Adjusts the year and month to ensure month is within the range 1-12,
@@ -860,27 +814,30 @@ Expected<int32_t> fromDateString(const char* str, size_t len, ParseMode mode) {
 
     switch (mode) {
       case ParseMode::kPrestoCast:
-        return folly::makeUnexpected(Status::UserError(
-            "Unable to parse date value: \"{}\". "
-            "Valid date string pattern is (YYYY-MM-DD), "
-            "and can be prefixed with [+-]",
-            std::string(str, len)));
+        return folly::makeUnexpected(
+            Status::UserError(
+                "Unable to parse date value: \"{}\". "
+                "Valid date string pattern is (YYYY-MM-DD), "
+                "and can be prefixed with [+-]",
+                std::string(str, len)));
       case ParseMode::kSparkCast:
-        return folly::makeUnexpected(Status::UserError(
-            "Unable to parse date value: \"{}\". "
-            "Valid date string patterns include "
-            "([y]y*, [y]y*-[m]m*, [y]y*-[m]m*-[d]d*, "
-            "[y]y*-[m]m*-[d]d* *, [y]y*-[m]m*-[d]d*T*), "
-            "and any pattern prefixed with [+-]",
-            std::string(str, len)));
+        return folly::makeUnexpected(
+            Status::UserError(
+                "Unable to parse date value: \"{}\". "
+                "Valid date string patterns include "
+                "([y]y*, [y]y*-[m]m*, [y]y*-[m]m*-[d]d*, "
+                "[y]y*-[m]m*-[d]d* *, [y]y*-[m]m*-[d]d*T*), "
+                "and any pattern prefixed with [+-]",
+                std::string(str, len)));
       case ParseMode::kIso8601:
-        return folly::makeUnexpected(Status::UserError(
-            "Unable to parse date value: \"{}\". "
-            "Valid date string patterns include "
-            "([y]y*, [y]y*-[m]m*, [y]y*-[m]m*-[d]d*, "
-            "[y]y*-[m]m*-[d]d* *), "
-            "and any pattern prefixed with [+-]",
-            std::string(str, len)));
+        return folly::makeUnexpected(
+            Status::UserError(
+                "Unable to parse date value: \"{}\". "
+                "Valid date string patterns include "
+                "([y]y*, [y]y*-[m]m*, [y]y*-[m]m*-[d]d*, "
+                "[y]y*-[m]m*-[d]d* *), "
+                "and any pattern prefixed with [+-]",
+                std::string(str, len)));
       default:
         VELOX_UNREACHABLE();
     }
diff --git a/velox/type/Tokenizer.cpp b/velox/type/Tokenizer.cpp
index 06196c5d6ec..e21c2f88673 100644
--- a/velox/type/Tokenizer.cpp
+++ b/velox/type/Tokenizer.cpp
@@ -136,7 +136,7 @@ std::unique_ptr<Subfield::PathElement> Tokenizer::matchUnquotedSubscript() {
   }
   int end = index_;
 
-  std::string token = path_.substr(start, end);
+  std::string token = path_.substr(start, end - start);
 
   // an empty unquoted token is not allowed
   if (token.empty()) {
diff --git a/velox/type/Type.cpp b/velox/type/Type.cpp
index 53d05fe2911..52f1b5c084d 100644
--- a/velox/type/Type.cpp
+++ b/velox/type/Type.cpp
@@ -16,15 +16,24 @@
 
 #include <velox/type/Type.h>
 
+#include <folly/dynamic.h>
+
+#include "velox/common/EnumDefine.h"
+#include "velox/type/TypeSerde.h"
+
 #include <boost/algorithm/string.hpp>
 #include <fmt/format.h>
 #include <folly/Demangle.h>
+#include <folly/hash/Hash.h>
 #include <re2/re2.h>
 
 #include <sstream>
 #include <typeindex>
 
+#include "velox/external/tzdb/exception.h"
+#include "velox/type/CastRegistry.h"
 #include "velox/type/DecimalUtil.h"
+#include "velox/type/Time.h"
 #include "velox/type/TimestampConversion.h"
 
 namespace std {
@@ -39,8 +48,8 @@ struct hash<facebook::velox::TypeKind> {
 namespace facebook::velox {
 namespace {
 bool isColumnNameRequiringEscaping(const std::string& name) {
-  static const std::string re("^[a-zA-Z_][a-zA-Z0-9_]*$");
-  return !RE2::FullMatch(name, re);
+  static const re2::RE2 pattern("^[a-zA-Z_][a-zA-Z0-9_]*$");
+  return !RE2::FullMatch(name, pattern);
 }
 
 const auto& typeKindNames() {
@@ -252,6 +261,80 @@ TypePtr Type::create(const folly::dynamic& obj) {
   }
 }
 
+template <TypeKind KIND>
+folly::dynamic ScalarType<KIND>::serialize() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["name"] = "Type";
+  obj["type"] = TypeTraits<KIND>::name;
+  return obj;
+}
+
+template folly::dynamic ScalarType<TypeKind::BOOLEAN>::serialize() const;
+template folly::dynamic ScalarType<TypeKind::TINYINT>::serialize() const;
+template folly::dynamic ScalarType<TypeKind::SMALLINT>::serialize() const;
+template folly::dynamic ScalarType<TypeKind::INTEGER>::serialize() const;
+template folly::dynamic ScalarType<TypeKind::BIGINT>::serialize() const;
+template folly::dynamic ScalarType<TypeKind::REAL>::serialize() const;
+template folly::dynamic ScalarType<TypeKind::DOUBLE>::serialize() const;
+template folly::dynamic ScalarType<TypeKind::VARCHAR>::serialize() const;
+template folly::dynamic ScalarType<TypeKind::VARBINARY>::serialize() const;
+template folly::dynamic ScalarType<TypeKind::TIMESTAMP>::serialize() const;
+template folly::dynamic ScalarType<TypeKind::HUGEINT>::serialize() const;
+template folly::dynamic ScalarType<TypeKind::UNKNOWN>::serialize() const;
+template folly::dynamic ScalarType<TypeKind::OPAQUE>::serialize() const;
+
+template <TypeKind KIND>
+folly::dynamic DecimalType<KIND>::serialize() const {
+  auto obj = ScalarType<KIND>::serialize();
+  obj["type"] = name();
+  obj["precision"] = precision();
+  obj["scale"] = scale();
+  return obj;
+}
+
+template folly::dynamic DecimalType<TypeKind::BIGINT>::serialize() const;
+template folly::dynamic DecimalType<TypeKind::HUGEINT>::serialize() const;
+
+folly::dynamic UnknownType::serialize() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["name"] = "Type";
+  obj["type"] = TypeTraits<TypeKind::UNKNOWN>::name;
+  return obj;
+}
+
+folly::dynamic IntervalDayTimeType::serialize() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["name"] = "IntervalDayTimeType";
+  obj["type"] = name();
+  return obj;
+}
+
+TypePtr IntervalDayTimeType::deserialize(const folly::dynamic& /*obj*/) {
+  return IntervalDayTimeType::get();
+}
+
+folly::dynamic IntervalYearMonthType::serialize() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["name"] = "IntervalYearMonthType";
+  obj["type"] = name();
+  return obj;
+}
+
+TypePtr IntervalYearMonthType::deserialize(const folly::dynamic& /*obj*/) {
+  return IntervalYearMonthType::get();
+}
+
+folly::dynamic DateType::serialize() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["name"] = "DateType";
+  obj["type"] = name();
+  return obj;
+}
+
+TypePtr DateType::deserialize(const folly::dynamic& /*obj*/) {
+  return DateType::get();
+}
+
 // static
 void Type::registerSerDe() {
   auto& registry = velox::DeserializationRegistryForSharedPtr();
@@ -263,6 +346,8 @@ void Type::registerSerDe() {
   registry.Register(
       "IntervalYearMonthType", IntervalYearMonthType::deserialize);
   registry.Register("DateType", DateType::deserialize);
+  registry.Register("TimestampUtcType", TimestampUtcType::deserialize);
+  registry.Register("TimeType", TimeTypeFactory::deserialize);
 }
 
 std::string ArrayType::toString() const {
@@ -275,7 +360,7 @@ const TypePtr& ArrayType::childAt(uint32_t idx) const {
 }
 
 ArrayType::ArrayType(TypePtr child)
-    : child_{std::move(child)}, parameters_{{TypeParameter(child_)}} {}
+    : child_{std::move(child)}, parameter_{child_} {}
 
 bool ArrayType::equivalent(const Type& other) const {
   if (&other == this) {
@@ -336,7 +421,7 @@ const char* MapType::nameOf(uint32_t idx) const {
 MapType::MapType(TypePtr keyType, TypePtr valueType)
     : keyType_{std::move(keyType)},
       valueType_{std::move(valueType)},
-      parameters_{{TypeParameter(keyType_), TypeParameter(valueType_)}} {}
+      parameters_{TypeParameter(keyType_), TypeParameter(valueType_)} {}
 
 std::string MapType::toString() const {
   return "MAP<" + keyType()->toString() + "," + valueType()->toString() + ">";
@@ -457,37 +542,36 @@ const RowType::NameToIndex* RowType::ensureNameToIndex() const {
 }
 
 namespace {
-template <typename T>
-std::string makeFieldNotFoundErrorMessage(
-    const T& name,
+std::string formatAvailableFields(
     const std::vector<std::string>& availableNames) {
   static constexpr auto kMaxFields = 50;
 
   const auto numAvailable = availableNames.size();
 
-  std::stringstream errorMessage;
-  errorMessage << "Field not found: " << name << ". Available fields are: ";
+  std::stringstream result;
   for (auto i = 0; i < numAvailable && i < kMaxFields; ++i) {
     if (i > 0) {
-      errorMessage << ", ";
+      result << ", ";
     }
-    errorMessage << availableNames[i];
+    result << availableNames[i];
   }
 
   if (numAvailable > kMaxFields) {
-    errorMessage << ", ..." << (numAvailable - kMaxFields) << " more";
+    result << ", ..." << (numAvailable - kMaxFields) << " more";
   }
 
-  errorMessage << ".";
-  return errorMessage.str();
+  return result.str();
 }
 } // namespace
 
-const TypePtr& RowType::findChild(folly::StringPiece name) const {
+const TypePtr& RowType::findChild(std::string_view name) const {
   if (auto i = getChildIdxIfExists(name)) {
     return children_[*i];
   }
-  VELOX_USER_FAIL(makeFieldNotFoundErrorMessage(name, names_));
+  VELOX_USER_FAIL(
+      "Field not found: {}. Available fields are: {}.",
+      name,
+      formatAvailableFields(names_));
 }
 
 bool RowType::isOrderable() const {
@@ -511,7 +595,10 @@ bool RowType::containsChild(std::string_view name) const {
 uint32_t RowType::getChildIdx(std::string_view name) const {
   auto index = getChildIdxIfExists(name);
   if (!index.has_value()) {
-    VELOX_USER_FAIL(makeFieldNotFoundErrorMessage(name, names_));
+    VELOX_USER_FAIL(
+        "Field not found: {}. Available fields are: {}.",
+        name,
+        formatAvailableFields(names_));
   }
   return index.value();
 }
@@ -567,11 +654,12 @@ bool RowType::equals(const Type& other) const {
 }
 
 size_t RowType::hashKind() const {
-  if (!hashKindComputed_.load(std::memory_order_relaxed)) {
-    hashKind_ = TypeBase<TypeKind::ROW>::hashKind();
-    hashKindComputed_ = true;
+  auto hashKind = hashKind_.load(std::memory_order_relaxed);
+  if (hashKind == 0) {
+    hashKind = TypeBase<TypeKind::ROW>::hashKind();
+    hashKind_.store(hashKind, std::memory_order_relaxed);
   }
-  return hashKind_;
+  return hashKind;
 }
 
 void RowType::printChildren(std::stringstream& ss, std::string_view delimiter)
@@ -634,8 +722,9 @@ folly::dynamic SerializedTypeCache::serialize() {
   // populated.
   std::vector<std::pair<int32_t, const folly::dynamic*>> cacheEntries;
   for (const auto& [_, pair] : cache_) {
-    cacheEntries.emplace_back(std::make_pair<int32_t, const folly::dynamic*>(
-        (int32_t)pair.first, &pair.second));
+    cacheEntries.emplace_back(
+        std::make_pair<int32_t, const folly::dynamic*>(
+            (int32_t)pair.first, &pair.second));
   }
 
   std::sort(cacheEntries.begin(), cacheEntries.end(), [](auto& a, auto& b) {
@@ -839,9 +928,6 @@ folly::dynamic FunctionType::serialize() const {
   return obj;
 }
 
-OpaqueType::OpaqueType(const std::type_index& typeIndex)
-    : typeIndex_(typeIndex) {}
-
 bool OpaqueType::equivalent(const Type& other) const {
   if (&other == this) {
     return true;
@@ -906,6 +992,15 @@ std::shared_ptr<const OpaqueType> OpaqueType::deserializeExtra(
   return nullptr;
 }
 
+bool OpaqueType::unregisterSerialization(
+    const OpaqueTypePtr& opaqueType,
+    const std::string& persistentName) {
+  VELOX_CHECK_NOT_NULL(opaqueType);
+  auto& registry = OpaqueSerdeRegistry::get();
+  registry.reverse.erase(persistentName);
+  return registry.mapping.erase(opaqueType->typeIndex_);
+}
+
 void OpaqueType::clearSerializationRegistry() {
   auto& registry = OpaqueSerdeRegistry::get();
   registry.mapping.clear();
@@ -1010,6 +1105,10 @@ VELOX_DEFINE_SCALAR_ACCESSOR(VARBINARY);
 
 #undef VELOX_DEFINE_SCALAR_ACCESSOR
 
+TypePtr TIMESTAMP_UTC() {
+  return TimestampUtcType::get();
+}
+
 TypePtr UNKNOWN() {
   return TypeFactory<TypeKind::UNKNOWN>::create();
 }
@@ -1158,7 +1257,11 @@ std::unordered_set<std::string> getCustomTypeNames() {
 
 bool unregisterCustomType(const std::string& name) {
   auto uppercaseName = boost::algorithm::to_upper_copy(name);
-  return typeFactories().erase(uppercaseName) == 1;
+  bool removed = typeFactories().erase(uppercaseName) == 1;
+  if (removed) {
+    CastRulesRegistry::instance().unregisterCastRules(uppercaseName);
+  }
+  return removed;
 }
 
 const CustomTypeFactory* FOLLY_NULLABLE
@@ -1316,7 +1419,7 @@ std::string DateType::toIso8601(int32_t days) {
   return result;
 }
 
-int32_t DateType::toDays(folly::StringPiece in) const {
+int32_t DateType::toDays(std::string_view in) const {
   return toDays(in.data(), in.size());
 }
 
@@ -1343,9 +1446,12 @@ const SingletonTypeMap& singletonBuiltInTypes() {
       {"VARCHAR", VARCHAR()},
       {"VARBINARY", VARBINARY()},
       {"TIMESTAMP", TIMESTAMP()},
+      {"TIMESTAMP UTC", TIMESTAMP_UTC()},
       {"INTERVAL DAY TO SECOND", INTERVAL_DAY_TIME()},
       {"INTERVAL YEAR TO MONTH", INTERVAL_YEAR_MONTH()},
       {"DATE", DATE()},
+      {"TIME", TIME()},
+      {"TIME MICRO UTC", TIME_MICRO_UTC()},
       {"UNKNOWN", UNKNOWN()},
   };
   return kTypes;
@@ -1496,6 +1602,258 @@ std::string getOpaqueAliasForTypeId(std::type_index typeIndex) {
   return it->second;
 }
 
+namespace {
+
+const auto& timePrecisionNames() {
+  static const folly::F14FastMap<TimePrecision, std::string_view> kNames = {
+      {TimePrecision::kMilliseconds, "MILLISECONDS"},
+      {TimePrecision ::kMicroseconds, "MICROSECONDS"}};
+  return kNames;
+}
+
+} // namespace
+
+VELOX_DEFINE_ENUM_NAME(TimePrecision, timePrecisionNames);
+
+namespace {
+
+const auto& typeParameterKindNames() {
+  static const folly::F14FastMap<TypeParameterKind, std::string_view> kNames = {
+      {TypeParameterKind::kType, "kType"},
+      {TypeParameterKind::kLongLiteral, "kLongLiteral"},
+      {TypeParameterKind::kLongEnumLiteral, "kLongEnumLiteral"},
+      {TypeParameterKind::kVarcharEnumLiteral, "kVarcharEnumLiteral"},
+  };
+  return kNames;
+}
+
+} // namespace
+
+VELOX_DEFINE_ENUM_NAME(TypeParameterKind, typeParameterKindNames);
+
+folly::dynamic TimestampUtcType::serialize() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["name"] = "TimestampUtcType";
+  obj["type"] = name();
+  return obj;
+}
+
+template <TimePrecision kPrecision, bool kLocalTime>
+folly::dynamic TimeType<kPrecision, kLocalTime>::serialize() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["name"] = "TimeType";
+  obj["type"] = name();
+  // Only include precision and localTime if they differ from defaults
+  // (milliseconds and local time) for backward compatibility.
+  if (kPrecision != TimePrecision::kMilliseconds) {
+    obj["precision"] = static_cast<int>(kPrecision);
+  }
+  if (!kLocalTime) {
+    obj["localTime"] = kLocalTime;
+  }
+  return obj;
+}
+
+// Explicit template instantiations for TimeType.
+template class TimeType<TimePrecision::kMilliseconds, true>;
+template class TimeType<TimePrecision::kMicroseconds, false>;
+
+// static
+TypePtr TimeTypeFactory::deserialize(const folly::dynamic& obj) {
+  // Default to millseconds and local time for backward compatibility.
+  auto precision = obj.get_ptr("precision")
+      ? static_cast<TimePrecision>(obj["precision"].asInt())
+      : TimePrecision::kMilliseconds;
+  bool localTime = obj.get_ptr("localTime") ? obj["localTime"].asBool() : true;
+
+  if (precision == TimePrecision::kMilliseconds) {
+    VELOX_USER_CHECK(
+        localTime,
+        "TimeType with millisecond precision and local time zone is not used.");
+    return static_cast<TypePtr>(TIME());
+  }
+  VELOX_USER_CHECK(
+      !localTime,
+      "TimeType with microsecond precision and UTC time zone is not used.");
+  return static_cast<TypePtr>(TIME_MICRO_UTC());
+}
+
+StringView TimeMilliPrecisionType::valueToString(
+    int64_t value,
+    char* const startPos) const {
+  // Ensure the value is within valid TIME range
+  VELOX_USER_CHECK(
+      !(value < getMin() || value > getMax()),
+      "TIME value {} is out of range [{}, {}]",
+      value,
+      getMin(),
+      getMax());
+
+  int64_t hours = value / kMillisInHour;
+  int64_t remainingMs = value % kMillisInHour;
+  int64_t minutes = remainingMs / kMillisInMinute;
+  remainingMs = remainingMs % kMillisInMinute;
+  int64_t seconds = remainingMs / kMillisInSecond;
+  int64_t millis = remainingMs % kMillisInSecond;
+
+  // TIME is represented as milliseconds since midnight
+  // Convert to HH:mm:ss.SSS format
+  fmt::format_to_n(
+      startPos,
+      timeToVarcharRowSize(),
+      "{:02d}:{:02d}:{:02d}.{:03d}",
+      hours,
+      minutes,
+      seconds,
+      millis);
+  return StringView{startPos, timeToVarcharRowSize()};
+}
+
+int64_t TimeMilliPrecisionType::valueToTime(const StringView& timeStr) const {
+  return util::fromTimeString(timeStr).thenOrThrow(
+      folly::identity,
+      [&](const Status& status) { VELOX_USER_FAIL("{}", status.message()); });
+}
+
+int64_t TimeMilliPrecisionType::valueToTime(
+    const StringView& timeStr,
+    const tz::TimeZone* timeZone,
+    int64_t sessionStartTimeMs) const {
+  // First parse the time string normally to get local time
+  int64_t parsedTimeMillis = valueToTime(timeStr);
+
+  // Apply timezone conversion if provided
+  if (FOLLY_UNLIKELY(!timeZone)) {
+    return parsedTimeMillis;
+  }
+
+  // Get the day boundary from session start time
+  auto sessionStartTime = std::chrono::milliseconds{sessionStartTimeMs};
+  auto systemDayStart =
+      std::chrono::duration_cast<std::chrono::days>(sessionStartTime);
+
+  // Create a local timestamp for the current day with the parsed time
+  auto localSystemTime =
+      std::chrono::duration_cast<std::chrono::milliseconds>(systemDayStart)
+          .count() +
+      parsedTimeMillis;
+
+  // Convert from local time to UTC with proper exception handling
+  std::chrono::milliseconds utcTime;
+  try {
+    utcTime = timeZone->to_sys(std::chrono::milliseconds{localSystemTime});
+  } catch (const facebook::velox::tzdb::ambiguous_local_time&) {
+    // If the time is ambiguous during DST fall-back, pick the earlier
+    // possibility to be consistent with Presto.
+    utcTime = timeZone->to_sys(
+        std::chrono::milliseconds{localSystemTime},
+        tz::TimeZone::TChoose::kEarliest);
+  } catch (const facebook::velox::tzdb::nonexistent_local_time&) {
+    // If the time does not exist during DST spring-forward, fail the
+    // conversion.
+    VELOX_USER_FAIL(
+        "Cannot cast VARCHAR '{}' to TIME. Time does not exist due to DST gap.",
+        std::string(timeStr));
+  }
+
+  int64_t adjustedTime =
+      (utcTime % std::chrono::milliseconds{kMillisInDay}).count();
+
+  // Handle day wrapping
+  if (adjustedTime < 0) {
+    adjustedTime += kMillisInDay;
+  } else if (adjustedTime >= kMillisInDay) {
+    adjustedTime -= kMillisInDay;
+  }
+
+  return adjustedTime;
+}
+
+// static
+std::string TimeMicroPrecisionUtcType::toCompactIso8601(int64_t microseconds) {
+  int64_t hours = microseconds / util::kMicrosPerHour;
+  microseconds %= util::kMicrosPerHour;
+  int64_t minutes = microseconds / util::kMicrosPerMinute;
+  microseconds %= util::kMicrosPerMinute;
+  int64_t seconds = microseconds / util::kMicrosPerSec;
+  int64_t remainingMicros = microseconds % util::kMicrosPerSec;
+
+  std::string result = fmt::format("{:02d}:{:02d}", hours, minutes);
+  if (seconds > 0 || remainingMicros > 0) {
+    result += fmt::format(":{:02d}", seconds);
+    if (remainingMicros > 0) {
+      if (remainingMicros % 1000 == 0) {
+        result += fmt::format(".{:03d}", remainingMicros / 1000);
+      } else {
+        result += fmt::format(".{:06d}", remainingMicros);
+      }
+    }
+  }
+  return result;
+}
+
+// Default hash for leaf scalar types: mix in kind + RTTI to distinguish
+// singleton overlay types that share a TypeKind with their base (e.g.,
+// IntervalDayTimeType and plain BIGINT both have TypeKind::BIGINT;
+// DateType and IntervalYearMonthType both share TypeKind::INTEGER).
+// NOTE: This default is only correct when equality is fully determined by
+// (TypeKind, typeid). Types with additional state MUST override hash() just
+// as they override equals(): see RowType, DecimalType, OpaqueType, and the
+// compound types (ArrayType, MapType, FunctionType).
+size_t Type::hash() const noexcept {
+  // Offset by 1 to differentiate bool type from empty hash.
+  return folly::hash::hash_combine(
+      static_cast<size_t>(kind()) + 1,
+      std::hash<std::type_index>{}(std::type_index(typeid(*this))));
+}
+
+size_t RowType::hash() const noexcept {
+  size_t result = static_cast<size_t>(TypeKind::ROW) + 1;
+  for (uint32_t i = 0; i < size(); ++i) {
+    result =
+        folly::hash::hash_combine(result, std::hash<std::string>{}(names_[i]));
+    result = folly::hash::hash_combine(result, children_[i]->hash());
+  }
+  return result;
+}
+
+size_t ArrayType::hash() const noexcept {
+  return folly::hash::hash_combine(
+      static_cast<size_t>(TypeKind::ARRAY) + 1, child_->hash());
+}
+
+size_t MapType::hash() const noexcept {
+  size_t result = static_cast<size_t>(TypeKind::MAP) + 1;
+  result = folly::hash::hash_combine(result, keyType_->hash());
+  result = folly::hash::hash_combine(result, valueType_->hash());
+  return result;
+}
+
+size_t FunctionType::hash() const noexcept {
+  size_t result = static_cast<size_t>(TypeKind::FUNCTION) + 1;
+  for (const auto& child : children_) {
+    result = folly::hash::hash_combine(result, child->hash());
+  }
+  return result;
+}
+
+size_t OpaqueType::hash() const noexcept {
+  return folly::hash::hash_combine(
+      static_cast<size_t>(TypeKind::OPAQUE) + 1,
+      std::hash<std::type_index>{}(typeIndex_));
+}
+
+template <TypeKind KIND>
+size_t DecimalType<KIND>::hash() const noexcept {
+  size_t result = static_cast<size_t>(KIND) + 1;
+  result = folly::hash::hash_combine(result, static_cast<size_t>(precision()));
+  result = folly::hash::hash_combine(result, static_cast<size_t>(scale()));
+  return result;
+}
+
+template size_t DecimalType<TypeKind::BIGINT>::hash() const noexcept;
+template size_t DecimalType<TypeKind::HUGEINT>::hash() const noexcept;
+
 std::string stringifyTruncatedElementList(
     size_t size,
     const std::function<void(std::stringstream&, size_t)>& stringifyElement,
diff --git a/velox/type/Type.h b/velox/type/Type.h
index 8076aae7d0f..41eb9efa8ef 100644
--- a/velox/type/Type.h
+++ b/velox/type/Type.h
@@ -16,11 +16,8 @@
 #pragma once
 
 #include <folly/CPortability.h>
-#include <folly/Hash.h>
 #include <folly/Random.h>
-#include <folly/Range.h>
 #include <folly/container/F14Set.h>
-#include <folly/dynamic.h>
 
 #include <cstdint>
 #include <cstring>
@@ -29,12 +26,13 @@
 #include <limits>
 #include <memory>
 #include <optional>
+#include <span>
 #include <string>
 #include <type_traits>
 #include <typeindex>
 #include <vector>
 
-#include <velox/common/Enums.h>
+#include <velox/common/EnumDeclare.h>
 #include "velox/common/base/BitUtil.h"
 #include "velox/common/base/ClassName.h"
 #include "velox/common/base/Exceptions.h"
@@ -44,6 +42,11 @@
 #include "velox/type/StringView.h"
 #include "velox/type/Timestamp.h"
 #include "velox/type/Tree.h"
+#include "velox/type/tz/TimeZoneMap.h"
+
+namespace folly {
+struct dynamic;
+}
 
 namespace facebook::velox {
 
@@ -94,21 +97,6 @@ enum class TypeKind : int8_t {
 
 VELOX_DECLARE_ENUM_NAME(TypeKind);
 
-/// Deprecated.
-inline TypeKind mapNameToTypeKind(const std::string& name) {
-  return TypeKindName::toTypeKind(name);
-}
-
-[[deprecated("Use TypeKindName::tryToTypeKind")]]
-inline std::optional<TypeKind> tryMapNameToTypeKind(const std::string& name) {
-  return TypeKindName::tryToTypeKind(name);
-}
-
-/// Deprecated.
-inline std::string mapTypeKindToName(const TypeKind& typeKind) {
-  return std::string(TypeKindName::toName(typeKind));
-}
-
 template <TypeKind KIND>
 class ScalarType;
 class ShortDecimalType;
@@ -377,6 +365,17 @@ struct TypeTraits<TypeKind::OPAQUE> {
   static constexpr const char* name = "OPAQUE";
 };
 
+// Convenience constexpr function to check for string-like and nested type
+// kinds.
+constexpr bool is_string_kind(TypeKind kind) {
+  return kind == TypeKind::VARCHAR || kind == TypeKind::VARBINARY;
+}
+
+constexpr bool is_nested_kind(TypeKind kind) {
+  return kind == TypeKind::ARRAY || kind == TypeKind::MAP ||
+      kind == TypeKind::ROW;
+}
+
 template <TypeKind KIND>
 struct TypeFactory;
 
@@ -450,6 +449,8 @@ enum class TypeParameterKind {
   kVarcharEnumLiteral,
 };
 
+VELOX_DECLARE_ENUM_NAME(TypeParameterKind);
+
 struct TypeParameter {
   const TypeParameterKind kind;
 
@@ -569,7 +570,7 @@ class Type : public Tree<const TypePtr>, public velox::ISerializable {
   virtual const char* name() const = 0;
 
   /// Returns a possibly empty list of type parameters.
-  virtual const std::vector<TypeParameter>& parameters() const = 0;
+  virtual std::span<const TypeParameter> parameters() const = 0;
 
   /// Returns physical type name. Multiple logical types may share the same
   /// physical type backing and therefore return the same physical type name.
@@ -593,10 +594,13 @@ class Type : public Tree<const TypePtr>, public velox::ISerializable {
   /// Examples: Two RowTypes are equivalent if the children types are
   /// equivalent, but the children names could be different. Two OpaqueTypes are
   /// equivalent if the typeKind matches, but the typeIndex could be different.
+  /// Note: The hashKind() function provides a hash consistent with
+  /// equivalent().
   virtual bool equivalent(const Type& other) const = 0;
 
   /// For Complex types (Row, Array, Map, Opaque): types are strongly matched.
   /// For primitive types: same as equivalent.
+  /// Note: The hash() function provides a hash consistent with this operator==.
   virtual bool operator==(const Type& other) const {
     return this->equals(other);
   }
@@ -618,6 +622,12 @@ class Type : public Tree<const TypePtr>, public velox::ISerializable {
   /// Recursive kind hashing (uses only TypeKind).
   virtual size_t hashKind() const;
 
+  /// Recursive hash consistent with operator==: includes ROW field names,
+  /// DECIMAL precision/scale, OPAQUE type identity, and RTTI for singleton
+  /// overlay types. Subclasses that override equals() must override hash() too
+  /// to maintain the invariant: a == b ⟹ hash(a) == hash(b).
+  virtual size_t hash() const noexcept;
+
   /// Recursive kind match (uses only TypeKind).
   bool kindEquals(const TypePtr& other) const;
 
@@ -642,7 +652,7 @@ class Type : public Tree<const TypePtr>, public velox::ISerializable {
   VELOX_FLUENT_CAST(Map, MAP)
   VELOX_FLUENT_CAST(Row, ROW)
   VELOX_FLUENT_CAST(Opaque, OPAQUE)
-  VELOX_FLUENT_CAST(UnKnown, UNKNOWN)
+  VELOX_FLUENT_CAST(Unknown, UNKNOWN)
   VELOX_FLUENT_CAST(Function, FUNCTION)
 
   const ShortDecimalType& asShortDecimal() const;
@@ -654,6 +664,8 @@ class Type : public Tree<const TypePtr>, public velox::ISerializable {
 
   bool isIntervalDayTime() const;
 
+  bool isTime() const;
+
   bool isDate() const;
 
   bool containsUnknown() const;
@@ -673,6 +685,7 @@ class Type : public Tree<const TypePtr>, public velox::ISerializable {
   /// are same. Two OpaqueTypes are == if the typeKind and the typeIndex are
   /// same.
   /// For primitive types: same as equivalent.
+  /// Note: The hash() function provides a hash consistent with operator==.
   virtual bool equals(const Type& other) const {
     VELOX_CHECK(this->isPrimitiveType());
     return this->equivalent(other);
@@ -736,9 +749,8 @@ class TypeBase : public Type {
     return TypeTraits<KIND>::name;
   }
 
-  const std::vector<TypeParameter>& parameters() const override {
-    static const std::vector<TypeParameter> kEmpty = {};
-    return kEmpty;
+  std::span<const TypeParameter> parameters() const override {
+    return {};
   }
 };
 
@@ -763,6 +775,10 @@ class CanProvideCustomComparisonType : public TypeBase<KIND> {
         "Type {} is marked as providesCustomComparison but did not implement hash.");
     VELOX_FAIL("Type {} does not provide custom hash", this->name());
   }
+
+  // Bring the 0-arg Type::hash() (structural type hash) into scope alongside
+  // the 1-arg hash(value) overload above.
+  using Type::hash;
 };
 
 template <TypeKind KIND>
@@ -810,16 +826,13 @@ class ScalarType : public CanProvideCustomComparisonType<KIND> {
     return Type::hasSameTypeId(other);
   }
 
-  // TODO: velox implementation is in cpp
-  folly::dynamic serialize() const override {
-    folly::dynamic obj = folly::dynamic::object;
-    obj["name"] = "Type";
-    obj["type"] = TypeTraits<KIND>::name;
-    return obj;
-  }
+  folly::dynamic serialize() const override;
 };
 
 /// This class represents the fixed-point numbers.
+std::pair<uint8_t, uint8_t> getDecimalPrecisionScale(const Type& type);
+TypePtr DECIMAL(uint8_t precision, uint8_t scale);
+
 /// The parameter "precision" represents the number of digits the
 /// Decimal Type can support and "scale" represents the number of digits to
 /// the right of the decimal point.
@@ -840,6 +853,11 @@ class DecimalType : public ScalarType<KIND> {
         otherDecimal.scale() == scale());
   }
 
+  size_t hash() const noexcept override;
+  // Bring hash(value) from CanProvideCustomComparisonType into scope alongside
+  // the 0-arg hash() override above.
+  using ScalarType<KIND>::hash;
+
   inline uint8_t precision() const {
     return parameters_[0].longLiteral.value();
   }
@@ -856,18 +874,80 @@ class DecimalType : public ScalarType<KIND> {
     return fmt::format("DECIMAL({}, {})", precision(), scale());
   }
 
-  folly::dynamic serialize() const override {
-    auto obj = ScalarType<KIND>::serialize();
-    obj["type"] = name();
-    obj["precision"] = precision();
-    obj["scale"] = scale();
-    return obj;
-  }
+  folly::dynamic serialize() const override;
 
-  const std::vector<TypeParameter>& parameters() const override {
+  std::span<const TypeParameter> parameters() const override {
     return parameters_;
   }
 
+  /// Returns the minimum DECIMAL precision needed to represent all values
+  /// of 'kind' without loss. E.g. SMALLINT needs precision 5 since max
+  /// value is 32767 (5 digits). Returns std::nullopt for non-integer types.
+  static std::optional<uint8_t> minPrecisionForInteger(TypeKind kind) {
+    switch (kind) {
+      case TypeKind::TINYINT:
+        return 3;
+      case TypeKind::SMALLINT:
+        return 5;
+      case TypeKind::INTEGER:
+        return 10;
+      case TypeKind::BIGINT:
+        return 19;
+      default:
+        return std::nullopt;
+    }
+  }
+
+  /// Returns true if this DECIMAL can be coerced to the target DECIMAL
+  /// without precision loss. For integers, first map to the natural DECIMAL
+  /// via minPrecisionForInteger (e.g. INTEGER → DECIMAL(10,0)), then call
+  /// this method. The rule is: (p1 - s1) <= (p2 - s2) && s1 <= s2.
+  bool isCoercibleTo(const Type& target) const {
+    auto [targetPrecision, targetScale] = getDecimalPrecisionScale(target);
+    return precision() - scale() <= targetPrecision - targetScale &&
+        scale() <= targetScale;
+  }
+
+  /// Returns the narrowest DECIMAL that can represent values from both
+  /// 'lhs' and 'rhs' (each may be integer or decimal). Returns nullptr
+  /// if the result would exceed DECIMAL(38, s).
+  static TypePtr commonSuperType(const TypePtr& lhs, const TypePtr& rhs) {
+    auto extractComponents = [](const TypePtr& type,
+                                int32_t& integerDigits,
+                                uint8_t& scale) -> bool {
+      if (type->isDecimal()) {
+        auto [precision, s] = getDecimalPrecisionScale(*type);
+        integerDigits = precision - s;
+        scale = s;
+        return true;
+      }
+      if (auto precision = minPrecisionForInteger(type->kind())) {
+        integerDigits = *precision;
+        scale = 0;
+        return true;
+      }
+      return false;
+    };
+
+    int32_t lhsDigits = 0;
+    int32_t rhsDigits = 0;
+    uint8_t lhsScale = 0;
+    uint8_t rhsScale = 0;
+
+    if (!extractComponents(lhs, lhsDigits, lhsScale) ||
+        !extractComponents(rhs, rhsDigits, rhsScale)) {
+      return nullptr;
+    }
+
+    auto scale = std::max(lhsScale, rhsScale);
+    auto integerDigits = std::max(lhsDigits, rhsDigits);
+    auto precision = std::min(38, integerDigits + scale);
+    if (precision - scale < integerDigits) {
+      return nullptr;
+    }
+    return DECIMAL(precision, scale);
+  }
+
  protected:
   DecimalType(const uint8_t precision, const uint8_t scale)
       : parameters_{TypeParameter(precision), TypeParameter(scale)} {
@@ -888,7 +968,7 @@ class DecimalType : public ScalarType<KIND> {
   }
 
  private:
-  const std::vector<TypeParameter> parameters_;
+  const std::array<TypeParameter, 2> parameters_;
 };
 
 class ShortDecimalType final : public DecimalType<TypeKind::BIGINT> {
@@ -934,8 +1014,6 @@ FOLLY_ALWAYS_INLINE bool isDecimalName(const std::string& name) {
   return (name == "DECIMAL");
 }
 
-std::pair<uint8_t, uint8_t> getDecimalPrecisionScale(const Type& type);
-
 class UnknownType : public CanProvideCustomComparisonType<TypeKind::UNKNOWN> {
  public:
   using CanProvideCustomComparisonType<
@@ -969,12 +1047,7 @@ class UnknownType : public CanProvideCustomComparisonType<TypeKind::UNKNOWN> {
     return Type::hasSameTypeId(other);
   }
 
-  folly::dynamic serialize() const override {
-    folly::dynamic obj = folly::dynamic::object;
-    obj["name"] = "Type";
-    obj["type"] = TypeTraits<TypeKind::UNKNOWN>::name;
-    return obj;
-  }
+  folly::dynamic serialize() const override;
 };
 
 class ArrayType : public TypeBase<TypeKind::ARRAY> {
@@ -1023,15 +1096,16 @@ class ArrayType : public TypeBase<TypeKind::ARRAY> {
 
   folly::dynamic serialize() const override;
 
-  const std::vector<TypeParameter>& parameters() const override {
-    return parameters_;
+  std::span<const TypeParameter> parameters() const override {
+    return {&parameter_, 1};
   }
 
  protected:
   bool equals(const Type& other) const override;
+  size_t hash() const noexcept override;
 
   const TypePtr child_;
-  const std::vector<TypeParameter> parameters_;
+  const TypeParameter parameter_;
 };
 
 using ArrayTypePtr = std::shared_ptr<const ArrayType>;
@@ -1079,17 +1153,18 @@ class MapType : public TypeBase<TypeKind::MAP> {
 
   folly::dynamic serialize() const override;
 
-  const std::vector<TypeParameter>& parameters() const override {
+  std::span<const TypeParameter> parameters() const override {
     return parameters_;
   }
 
  protected:
   bool equals(const Type& other) const override;
+  size_t hash() const noexcept override;
 
  private:
   TypePtr keyType_;
   TypePtr valueType_;
-  const std::vector<TypeParameter> parameters_;
+  const std::array<TypeParameter, 2> parameters_;
 };
 
 using MapTypePtr = std::shared_ptr<const MapType>;
@@ -1152,7 +1227,7 @@ class RowType : public TypeBase<TypeKind::ROW> {
 
   /// Returns type of the first child with matching name. Throws if child with
   /// this name doesn't exist.
-  const TypePtr& findChild(folly::StringPiece name) const;
+  const TypePtr& findChild(std::string_view name) const;
 
   /// Returns true if child with specified name exists.
   bool containsChild(std::string_view name) const;
@@ -1191,7 +1266,7 @@ class RowType : public TypeBase<TypeKind::ROW> {
     return names_;
   }
 
-  const std::vector<TypeParameter>& parameters() const override {
+  std::span<const TypeParameter> parameters() const override {
     const auto* parameters = parameters_.load(std::memory_order_acquire);
     if (parameters) [[likely]] {
       return *parameters;
@@ -1211,6 +1286,7 @@ class RowType : public TypeBase<TypeKind::ROW> {
 
  protected:
   bool equals(const Type& other) const override;
+  size_t hash() const noexcept override;
 
  private:
   const std::vector<TypeParameter>* ensureParameters() const;
@@ -1220,8 +1296,7 @@ class RowType : public TypeBase<TypeKind::ROW> {
   const std::vector<TypePtr> children_;
   mutable std::atomic<std::vector<TypeParameter>*> parameters_{nullptr};
   mutable std::atomic<NameToIndex*> nameToIndex_{nullptr};
-  mutable std::atomic_bool hashKindComputed_{false};
-  mutable std::atomic_size_t hashKind_;
+  mutable std::atomic_size_t hashKind_{0};
 };
 
 using RowTypePtr = std::shared_ptr<const RowType>;
@@ -1263,12 +1338,13 @@ class FunctionType : public TypeBase<TypeKind::FUNCTION> {
 
   folly::dynamic serialize() const override;
 
-  const std::vector<TypeParameter>& parameters() const override {
+  std::span<const TypeParameter> parameters() const override {
     return parameters_;
   }
 
  protected:
   bool equals(const Type& other) const override;
+  size_t hash() const noexcept override;
 
  private:
   static std::vector<TypePtr> allChildren(
@@ -1290,7 +1366,7 @@ class OpaqueType : public TypeBase<TypeKind::OPAQUE> {
   template <typename T>
   using DeserializeFunc = std::function<std::shared_ptr<T>(const std::string&)>;
 
-  explicit OpaqueType(const std::type_index& typeIndex);
+  explicit OpaqueType(std::type_index typeIndex) : typeIndex_{typeIndex} {}
 
   uint32_t size() const override {
     return 0;
@@ -1304,7 +1380,7 @@ class OpaqueType : public TypeBase<TypeKind::OPAQUE> {
 
   bool equivalent(const Type& other) const override;
 
-  const std::type_index& typeIndex() const {
+  std::type_index typeIndex() const {
     return typeIndex_;
   }
 
@@ -1364,10 +1440,20 @@ class OpaqueType : public TypeBase<TypeKind::OPAQUE> {
         deserializeTypeErased);
   }
 
+  // This function is used to remove the serialization/deserialization functions
+  // for a type. It reverses the state changes made by registerSerialization
+  // function.
+  // @return true if the functions are found and removed
+  // successfully. False otherwise.
+  static bool unregisterSerialization(
+      const std::shared_ptr<const OpaqueType>& opaqueType,
+      const std::string& persistentName);
+
   static void clearSerializationRegistry();
 
  protected:
   bool equals(const Type& other) const override;
+  size_t hash() const noexcept override;
 
  private:
   const std::type_index typeIndex_;
@@ -1379,6 +1465,8 @@ class OpaqueType : public TypeBase<TypeKind::OPAQUE> {
       DeserializeFunc<void> deserialize = nullptr);
 };
 
+using OpaqueTypePtr = std::shared_ptr<const OpaqueType>;
+
 using IntegerType = ScalarType<TypeKind::INTEGER>;
 using BooleanType = ScalarType<TypeKind::BOOLEAN>;
 using TinyintType = ScalarType<TypeKind::TINYINT>;
@@ -1391,6 +1479,37 @@ using TimestampType = ScalarType<TypeKind::TIMESTAMP>;
 using VarcharType = ScalarType<TypeKind::VARCHAR>;
 using VarbinaryType = ScalarType<TypeKind::VARBINARY>;
 
+// Timestamp type in UTC that is not subject to session timezone adjustment.
+class TimestampUtcType final : public TimestampType {
+ public:
+  static std::shared_ptr<const TimestampUtcType> get() {
+    VELOX_CONSTEXPR_SINGLETON TimestampUtcType kInstance;
+    return {std::shared_ptr<const TimestampUtcType>{}, &kInstance};
+  }
+
+  const char* name() const override {
+    return "TIMESTAMP UTC";
+  }
+
+  bool equivalent(const Type& other) const override {
+    // Pointer comparison works since this type is a singleton.
+    return this == &other;
+  }
+
+  std::string toString() const override {
+    return name();
+  }
+
+  folly::dynamic serialize() const override;
+
+  static TypePtr deserialize(const folly::dynamic& /*obj*/) {
+    return TimestampUtcType::get();
+  }
+
+ protected:
+  constexpr TimestampUtcType() = default;
+};
+
 constexpr long kMillisInSecond = 1000;
 constexpr long kMillisInMinute = 60 * kMillisInSecond;
 constexpr long kMillisInHour = 60 * kMillisInMinute;
@@ -1425,16 +1544,9 @@ class IntervalDayTimeType final : public BigintType {
   /// Perhaps, Type::valueToString(variant)?
   std::string valueToString(int64_t value) const;
 
-  folly::dynamic serialize() const override {
-    folly::dynamic obj = folly::dynamic::object;
-    obj["name"] = "IntervalDayTimeType";
-    obj["type"] = name();
-    return obj;
-  }
+  folly::dynamic serialize() const override;
 
-  static TypePtr deserialize(const folly::dynamic& /*obj*/) {
-    return IntervalDayTimeType::get();
-  }
+  static TypePtr deserialize(const folly::dynamic& obj);
 };
 
 FOLLY_ALWAYS_INLINE std::shared_ptr<const IntervalDayTimeType>
@@ -1476,16 +1588,9 @@ class IntervalYearMonthType final : public IntegerType {
   /// represented as 1-2; -14 months would be represents as -1-2.
   std::string valueToString(int32_t value) const;
 
-  folly::dynamic serialize() const override {
-    folly::dynamic obj = folly::dynamic::object;
-    obj["name"] = "IntervalYearMonthType";
-    obj["type"] = name();
-    return obj;
-  }
+  folly::dynamic serialize() const override;
 
-  static TypePtr deserialize(const folly::dynamic& /*obj*/) {
-    return IntervalYearMonthType::get();
-  }
+  static TypePtr deserialize(const folly::dynamic& obj);
 };
 
 FOLLY_ALWAYS_INLINE std::shared_ptr<const IntervalYearMonthType>
@@ -1526,20 +1631,13 @@ class DateType final : public IntegerType {
   /// as an ISO 8601-formatted string.
   static std::string toIso8601(int32_t days);
 
-  int32_t toDays(folly::StringPiece in) const;
+  int32_t toDays(std::string_view in) const;
 
   int32_t toDays(const char* in, size_t len) const;
 
-  folly::dynamic serialize() const override {
-    folly::dynamic obj = folly::dynamic::object;
-    obj["name"] = "DateType";
-    obj["type"] = name();
-    return obj;
-  }
+  folly::dynamic serialize() const override;
 
-  static TypePtr deserialize(const folly::dynamic& /*obj*/) {
-    return DateType::get();
-  }
+  static TypePtr deserialize(const folly::dynamic& obj);
 };
 
 FOLLY_ALWAYS_INLINE std::shared_ptr<const DateType> DATE() {
@@ -1555,6 +1653,175 @@ FOLLY_ALWAYS_INLINE bool Type::isDate() const {
   return this == DATE().get();
 }
 
+enum class TimePrecision : int8_t {
+  kMilliseconds = 3, // Presto: milliseconds since midnight (10^3 ms = 1 second)
+  kMicroseconds = 6, // Spark: microseconds since midnight (10^6 μs = 1 second)
+};
+
+VELOX_DECLARE_ENUM_NAME(TimePrecision);
+
+/// Base template class for TIME types with configurable precision and timezone
+/// mode.
+/// - Presto: milliseconds since midnight (local timezone).
+/// - Spark: microseconds since midnight (timezone unaware).
+/// @tparam kPrecision Time precision (milliseconds or microseconds).
+/// @tparam kLocalTime True for local time representation, false for UTC.
+template <TimePrecision kPrecision, bool kLocalTime>
+class TimeType : public BigintType {
+ public:
+  std::string toString() const override {
+    return name();
+  }
+
+  constexpr int64_t getMin() const {
+    return 0;
+  }
+
+  /// Maximum valid time value based on precision. For milliseconds:
+  /// 23:59:59.999 (86,399,999 ms). For microseconds: 23:59:59.999999
+  /// (86,399,999,999 μs).
+  constexpr int64_t getMax() const {
+    return kPrecision == TimePrecision::kMilliseconds
+        ? kMillisInDay - 1
+        : static_cast<int64_t>(kMillisInDay) * 1000 - 1;
+  }
+
+  /// When casting from TIME to varchar, the resultant varchar size depends on
+  /// precision: 12 bytes for milliseconds (HH:MM:SS.mmm), 15 bytes for
+  /// microseconds (HH:MM:SS.mmmmmm).
+  static constexpr int32_t timeToVarcharRowSize() {
+    return kPrecision == TimePrecision::kMilliseconds ? 12 : 15;
+  }
+
+  folly::dynamic serialize() const override;
+
+ protected:
+  constexpr TimeType() = default;
+};
+
+struct TimeTypeFactory {
+  static TypePtr deserialize(const folly::dynamic& obj);
+};
+
+// TimeType with millisecond precision in local timezone (Presto-compatible).
+class TimeMilliPrecisionType final
+    : public TimeType<TimePrecision::kMilliseconds, true> {
+ public:
+  static std::shared_ptr<const TimeMilliPrecisionType> get() {
+    VELOX_CONSTEXPR_SINGLETON TimeMilliPrecisionType kInstance;
+    return {std::shared_ptr<const TimeMilliPrecisionType>{}, &kInstance};
+  }
+
+  const char* name() const override {
+    return "TIME";
+  }
+
+  bool equivalent(const Type& other) const override {
+    // Pointer comparison works since this type is a singleton.
+    return this == &other;
+  }
+
+  /// Returns the time 'value' (milliseconds since midnight) formatted as
+  /// HH:MM:SS.mmm.
+  /// It is the callers responsiblity to ensure that the value is in range
+  /// and converted to the right time zone.
+  StringView valueToString(int64_t value, char* const startPos) const;
+
+  /// Parses a time string in HH:MM:SS[.sss] format and returns milliseconds
+  /// since midnight. It is the caller's responsibility to ensure that the
+  /// input string is valid and handle error conditions as needed.
+  int64_t valueToTime(const StringView& timeStr) const;
+
+  /// Parses a time string in HH:MM:SS[.sss] format and returns milliseconds
+  /// since midnight, applying timezone conversion if provided.
+  /// @param timeStr The time string to parse
+  /// @param timeZone Optional timezone for conversion
+  /// @param sessionStartTimeMs Session start time in milliseconds for timezone
+  /// calculations
+  int64_t valueToTime(
+      const StringView& timeStr,
+      const tz::TimeZone* timeZone,
+      int64_t sessionStartTimeMs) const;
+
+ private:
+  constexpr TimeMilliPrecisionType() = default;
+};
+
+// TimeType with microsecond precision, timezone unaware (Spark compatible).
+class TimeMicroPrecisionUtcType final
+    : public TimeType<TimePrecision::kMicroseconds, false> {
+ public:
+  static std::shared_ptr<const TimeMicroPrecisionUtcType> get() {
+    VELOX_CONSTEXPR_SINGLETON TimeMicroPrecisionUtcType kInstance;
+    return {std::shared_ptr<const TimeMicroPrecisionUtcType>{}, &kInstance};
+  }
+
+  const char* name() const override {
+    return "TIME MICRO UTC";
+  }
+
+  bool equivalent(const Type& other) const override {
+    // Pointer comparison works since this type is a singleton.
+    return this == &other;
+  }
+
+  /// Converts microseconds since midnight to a compact ISO-8601 time string by
+  /// following rules:
+  /// - Base format is HH:MM.
+  /// - Seconds are included only if seconds > 0 or fractional seconds > 0.
+  /// - Fractional seconds are included only if microseconds > 0.
+  /// - Fractional precision is 3 digits (milliseconds) if microseconds are
+  ///   divisible by 1000, otherwise 6 digits (microseconds).
+  /// The output will be one of the following ISO-8601 formats:
+  /// - HH:mm
+  /// - HH:mm:ss
+  /// - HH:mm:ss.SSS
+  /// - HH:mm:ss.SSSSSS
+  /// Examples (microseconds -> string):
+  /// - 0 -> "00:00"
+  /// - 1 -> "00:00:00.000001"
+  /// - 100'000 -> "00:00:00.100"
+  /// - 1'000'000 -> "00:00:01"
+  /// - 1'000 -> "00:00:00.001"
+  /// - 38'000 -> "00:00:00.038"
+  /// - 38'001 -> "00:00:00.038001"
+  /// - 38'100 -> "00:00:00.038100"
+  /// - 29'288'000'000 -> "08:08:08"
+  /// - 36'775'038'000 -> "10:12:55.038"
+  /// - 86'399'999'999 -> "23:59:59.999999"
+  static std::string toCompactIso8601(int64_t microseconds);
+
+ private:
+  constexpr TimeMicroPrecisionUtcType() = default;
+};
+
+// Convenience pointer type (defaults to millisecond precision and local
+// timezone).
+using TimeTypePtr = std::shared_ptr<const TimeMilliPrecisionType>;
+FOLLY_ALWAYS_INLINE TimeTypePtr TIME() {
+  return TimeMilliPrecisionType::get();
+}
+
+using TimeMicroPrecisionUtcTypePtr =
+    std::shared_ptr<const TimeMicroPrecisionUtcType>;
+FOLLY_ALWAYS_INLINE TimeMicroPrecisionUtcTypePtr TIME_MICRO_UTC() {
+  return TimeMicroPrecisionUtcType::get();
+}
+
+FOLLY_ALWAYS_INLINE bool Type::isTime() const {
+  return (this == TIME().get()) || (this == TIME_MICRO_UTC().get());
+}
+
+struct Time {
+ private:
+  Time() {}
+};
+
+struct TimeMicroUtc {
+ private:
+  TimeMicroUtc() {}
+};
+
 /// Used as T for SimpleVector subclasses that wrap another vector when
 /// the wrapped vector is of a complex type. Applies to
 /// DictionaryVector, SequenceVector and ConstantVector. This must have
@@ -1712,7 +1979,8 @@ std::shared_ptr<const OpaqueType> OPAQUE() {
       }                                                                       \
       default:                                                                \
         VELOX_FAIL(                                                           \
-            "not a scalar type! kind: {}", mapTypeKindToName(typeKind));      \
+            "not a scalar type! kind: {}",                                    \
+            ::facebook::velox::TypeKindName::toName(typeKind));               \
     }                                                                         \
   }()
 
@@ -1766,7 +2034,8 @@ std::shared_ptr<const OpaqueType> OPAQUE() {
       }                                                                  \
       default:                                                           \
         VELOX_FAIL(                                                      \
-            "not a scalar type! kind: {}", mapTypeKindToName(typeKind)); \
+            "not a scalar type! kind: {}",                               \
+            ::facebook::velox::TypeKindName::toName(typeKind));          \
     }                                                                    \
   }()
 
@@ -1830,7 +2099,9 @@ std::shared_ptr<const OpaqueType> OPAQUE() {
             __VA_ARGS__);                                                     \
       }                                                                       \
       default:                                                                \
-        VELOX_FAIL("not a known type kind: {}", mapTypeKindToName(typeKind)); \
+        VELOX_FAIL(                                                           \
+            "not a known type kind: {}",                                      \
+            ::facebook::velox::TypeKindName::toName(typeKind));               \
     }                                                                         \
   }()
 
@@ -1917,7 +2188,9 @@ std::shared_ptr<const OpaqueType> OPAQUE() {
         return PREFIX<::facebook::velox::TypeKind::ROW> SUFFIX(__VA_ARGS__);   \
       }                                                                        \
       default:                                                                 \
-        VELOX_FAIL("not a known type kind: {}", mapTypeKindToName(typeKind));  \
+        VELOX_FAIL(                                                            \
+            "not a known type kind: {}",                                       \
+            ::facebook::velox::TypeKindName::toName(typeKind));                \
     }                                                                          \
   }()
 
@@ -1959,51 +2232,53 @@ std::shared_ptr<const OpaqueType> OPAQUE() {
 #define VELOX_SCALAR_ACCESSOR(KIND) \
   std::shared_ptr<const ScalarType<TypeKind::KIND>> KIND()
 
-#define VELOX_STATIC_FIELD_DYNAMIC_DISPATCH(CLASS, FIELD, typeKind)           \
-  [&]() {                                                                     \
-    switch (typeKind) {                                                       \
-      case ::facebook::velox::TypeKind::BOOLEAN: {                            \
-        return CLASS<::facebook::velox::TypeKind::BOOLEAN>::FIELD;            \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::INTEGER: {                            \
-        return CLASS<::facebook::velox::TypeKind::INTEGER>::FIELD;            \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::TINYINT: {                            \
-        return CLASS<::facebook::velox::TypeKind::TINYINT>::FIELD;            \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::SMALLINT: {                           \
-        return CLASS<::facebook::velox::TypeKind::SMALLINT>::FIELD;           \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::BIGINT: {                             \
-        return CLASS<::facebook::velox::TypeKind::BIGINT>::FIELD;             \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::REAL: {                               \
-        return CLASS<::facebook::velox::TypeKind::REAL>::FIELD;               \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::DOUBLE: {                             \
-        return CLASS<::facebook::velox::TypeKind::DOUBLE>::FIELD;             \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::VARCHAR: {                            \
-        return CLASS<::facebook::velox::TypeKind::VARCHAR>::FIELD;            \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::VARBINARY: {                          \
-        return CLASS<::facebook::velox::TypeKind::VARBINARY>::FIELD;          \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::TIMESTAMP: {                          \
-        return CLASS<::facebook::velox::TypeKind::TIMESTAMP>::FIELD;          \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::ARRAY: {                              \
-        return CLASS<::facebook::velox::TypeKind::ARRAY>::FIELD;              \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::MAP: {                                \
-        return CLASS<::facebook::velox::TypeKind::MAP>::FIELD;                \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::ROW: {                                \
-        return CLASS<::facebook::velox::TypeKind::ROW>::FIELD;                \
-      }                                                                       \
-      default:                                                                \
-        VELOX_FAIL("not a known type kind: {}", mapTypeKindToName(typeKind)); \
-    }                                                                         \
+#define VELOX_STATIC_FIELD_DYNAMIC_DISPATCH(CLASS, FIELD, typeKind)  \
+  [&]() {                                                            \
+    switch (typeKind) {                                              \
+      case ::facebook::velox::TypeKind::BOOLEAN: {                   \
+        return CLASS<::facebook::velox::TypeKind::BOOLEAN>::FIELD;   \
+      }                                                              \
+      case ::facebook::velox::TypeKind::INTEGER: {                   \
+        return CLASS<::facebook::velox::TypeKind::INTEGER>::FIELD;   \
+      }                                                              \
+      case ::facebook::velox::TypeKind::TINYINT: {                   \
+        return CLASS<::facebook::velox::TypeKind::TINYINT>::FIELD;   \
+      }                                                              \
+      case ::facebook::velox::TypeKind::SMALLINT: {                  \
+        return CLASS<::facebook::velox::TypeKind::SMALLINT>::FIELD;  \
+      }                                                              \
+      case ::facebook::velox::TypeKind::BIGINT: {                    \
+        return CLASS<::facebook::velox::TypeKind::BIGINT>::FIELD;    \
+      }                                                              \
+      case ::facebook::velox::TypeKind::REAL: {                      \
+        return CLASS<::facebook::velox::TypeKind::REAL>::FIELD;      \
+      }                                                              \
+      case ::facebook::velox::TypeKind::DOUBLE: {                    \
+        return CLASS<::facebook::velox::TypeKind::DOUBLE>::FIELD;    \
+      }                                                              \
+      case ::facebook::velox::TypeKind::VARCHAR: {                   \
+        return CLASS<::facebook::velox::TypeKind::VARCHAR>::FIELD;   \
+      }                                                              \
+      case ::facebook::velox::TypeKind::VARBINARY: {                 \
+        return CLASS<::facebook::velox::TypeKind::VARBINARY>::FIELD; \
+      }                                                              \
+      case ::facebook::velox::TypeKind::TIMESTAMP: {                 \
+        return CLASS<::facebook::velox::TypeKind::TIMESTAMP>::FIELD; \
+      }                                                              \
+      case ::facebook::velox::TypeKind::ARRAY: {                     \
+        return CLASS<::facebook::velox::TypeKind::ARRAY>::FIELD;     \
+      }                                                              \
+      case ::facebook::velox::TypeKind::MAP: {                       \
+        return CLASS<::facebook::velox::TypeKind::MAP>::FIELD;       \
+      }                                                              \
+      case ::facebook::velox::TypeKind::ROW: {                       \
+        return CLASS<::facebook::velox::TypeKind::ROW>::FIELD;       \
+      }                                                              \
+      default:                                                       \
+        VELOX_FAIL(                                                  \
+            "not a known type kind: {}",                             \
+            ::facebook::velox::TypeKindName::toName(typeKind));      \
+    }                                                                \
   }()
 
 #define VELOX_STATIC_FIELD_DYNAMIC_DISPATCH_ALL(CLASS, FIELD, typeKind)   \
@@ -2033,6 +2308,8 @@ VELOX_SCALAR_ACCESSOR(TIMESTAMP);
 VELOX_SCALAR_ACCESSOR(VARCHAR);
 VELOX_SCALAR_ACCESSOR(VARBINARY);
 
+TypePtr TIMESTAMP_UTC();
+
 TypePtr UNKNOWN();
 
 template <TypeKind KIND>
@@ -2148,6 +2425,11 @@ inline std::string to(const int128_t& value) {
   return std::to_string(value);
 }
 
+template <typename T>
+inline T to(const velox::StringView& value) {
+  return to<T>(std::string_view(value.data(), value.size()));
+}
+
 template <>
 inline std::string to(const velox::StringView& value) {
   return std::string(value.data(), value.size());
@@ -2280,6 +2562,7 @@ bool registerOpaqueType(const std::string& alias) {
 template <typename Class>
 bool unregisterOpaqueType(const std::string& alias) {
   auto typeIndex = std::type_index(typeid(Class));
+  OpaqueType::unregisterSerialization(OpaqueType::create<Class>(), alias);
   return getTypeIndexByOpaqueAlias().erase(alias) == 1 &&
       getOpaqueAliasByTypeIndex().erase(typeIndex) == 1;
 }
@@ -2321,114 +2604,45 @@ void toAppend(
 /// Appends type's SQL string to 'out'. Uses DuckDB SQL.
 void toTypeSql(const TypePtr& type, std::ostream& out);
 
-/// Cache of serialized RowType instances. Useful to reduce the size of
-/// serialized expressions and plans. Disabled by default. Not thread safe.
-///
-/// To enable, call 'serializedTypeCache().enable()'. This enables the cache for
-/// the current thread. To disable, call 'serializedTypeCache().disable()'.
-/// While enables, type serialization will use the cache and serialize the types
-/// using IDs stored in the cache. The caller is responsible for saving
-/// serialized types from the cache and using these to hidrate
-/// 'deserializedTypeCache()' before deserializing the types.
-class SerializedTypeCache {
- public:
-  struct Options {
-    // Caching applies to RowType's with at least this many fields.
-    size_t minRowTypeSize = 10;
-  };
-
-  bool isEnabled() const {
-    return enabled_;
-  }
-
-  const Options& options() const {
-    return options_;
-  }
-
-  void enable(const Options& options = {.minRowTypeSize = 10}) {
-    enabled_ = true;
-    options_ = options;
-  }
-
-  void disable() {
-    enabled_ = false;
-  }
-
-  size_t size() const {
-    return cache_.size();
-  }
-
-  void clear() {
-    cache_.clear();
-  }
-
-  /// Returns the ID of the type if it is in the cache. Returns std::nullopt if
-  /// type is not found in the cache. Cache key is type instance pointer. Hence,
-  /// equal but different instances are stored separately.
-  std::optional<int32_t> get(const Type& type) const;
-
-  /// Stores the type in the cache. Returns the ID of the type. Reports an error
-  /// if type is already present in the cache. IDs are monotonically increasing.
-  /// Serialized type may refer to types stored previously in the cache. When
-  /// deserializing type cache, make sure to deserialize types in the order of
-  /// cache IDs.
-  int32_t put(const Type& type, folly::dynamic serialized);
-
-  /// Serialized the types stored in the cache. Use
-  /// DeserializedTypeCache::deserialize to deserialize.
-  folly::dynamic serialize();
-
- private:
-  bool enabled_{false};
-  Options options_;
-  folly::F14FastMap<const Type*, std::pair<int32_t, folly::dynamic>> cache_;
-};
-
-/// Thread local cache of serialized RowType instances. Used by
-/// RowType::serialize.
-SerializedTypeCache& serializedTypeCache();
-
-/// Thread local cache of deserialized RowType instances. Used when
-/// deserializing Type objects.
-class DeserializedTypeCache {
- public:
-  void deserialize(const folly::dynamic& obj);
-
-  size_t size() const {
-    return cache_.size();
-  }
-
-  const TypePtr& get(int32_t id) const;
-
-  void clear() {
-    cache_.clear();
-  }
-
- private:
-  folly::F14FastMap<int32_t, TypePtr> cache_;
-};
-
-DeserializedTypeCache& deserializedTypeCache();
-
 template <typename T>
 std::string Type::valueToString(T value) const {
   if constexpr (std::is_same_v<T, bool>) {
     return value ? "true" : "false";
+
   } else if constexpr (std::is_same_v<T, std::shared_ptr<void>>) {
     return "<opaque>";
-  } else if constexpr (
-      std::is_same_v<T, int64_t> || std::is_same_v<T, int128_t>) {
+
+  } else if constexpr (std::is_same_v<T, int128_t>) {
     if (isDecimal()) {
       return LongDecimalType::toString(value, *this);
-    } else {
-      return velox::to<std::string>(value);
     }
+    return velox::to<std::string>(value);
+
+  } else if constexpr (std::is_same_v<T, int64_t>) {
+    if (isDecimal()) {
+      return LongDecimalType::toString(value, *this);
+    }
+    if (isIntervalDayTime()) {
+      return INTERVAL_DAY_TIME()->valueToString(value);
+    }
+    if (TIME()->equivalent(*this)) {
+      char buffer[TimeMilliPrecisionType::timeToVarcharRowSize()];
+      return std::string(TIME()->valueToString(value, buffer));
+    }
+    if (TIME_MICRO_UTC()->equivalent(*this)) {
+      return TimeMicroPrecisionUtcType::toCompactIso8601(value);
+    }
+    return velox::to<std::string>(value);
+
   } else if constexpr (std::is_same_v<T, int32_t>) {
     if (isDate()) {
       return DATE()->toString(value);
-    } else {
-      return velox::to<std::string>(value);
     }
+    if (isIntervalYearMonth()) {
+      return INTERVAL_YEAR_MONTH()->valueToString(value);
+    }
+    return velox::to<std::string>(value);
+
   } else {
     return velox::to<std::string>(value);
   }
@@ -2448,6 +2662,15 @@ std::string stringifyTruncatedElementList(
 
 } // namespace facebook::velox
 
+namespace std {
+template <>
+struct hash<facebook::velox::Type> {
+  size_t operator()(const facebook::velox::Type& type) const noexcept {
+    return type.hash();
+  }
+};
+} // namespace std
+
 namespace folly {
 template <>
 struct hasher<::facebook::velox::UnknownValue> {
@@ -2468,7 +2691,7 @@ class FormatValue<facebook::velox::TypeKind> {
   template <typename FormatCallback>
   void format(FormatArg& arg, FormatCallback& cb) const {
     return format_value::formatString(
-        facebook::velox::mapTypeKindToName(type_), arg, cb);
+        facebook::velox::TypeKindName::toName(type_), arg, cb);
   }
 
  private:
@@ -2500,7 +2723,7 @@ struct fmt::formatter<facebook::velox::TypeKind> : fmt::formatter<string_view> {
   template <typename FormatContext>
   auto format(facebook::velox::TypeKind k, FormatContext& ctx) const {
     return formatter<string_view>::format(
-        facebook::velox::mapTypeKindToName(k), ctx);
+        facebook::velox::TypeKindName::toName(k), ctx);
   }
 };
 
diff --git a/velox/type/TypeCoercer.cpp b/velox/type/TypeCoercer.cpp
index 8e369739683..af02e700a89 100644
--- a/velox/type/TypeCoercer.cpp
+++ b/velox/type/TypeCoercer.cpp
@@ -15,6 +15,8 @@
  */
 #include "velox/type/TypeCoercer.h"
 
+#include "velox/type/CastRegistry.h"
+
 namespace facebook::velox {
 
 int64_t Coercion::overallCost(const std::vector<Coercion>& coercions) {
@@ -30,45 +32,314 @@ int64_t Coercion::overallCost(const std::vector<Coercion>& coercions) {
 
 namespace {
 
-std::unordered_map<std::pair<std::string, std::string>, Coercion>
-allowedCoercions() {
-  std::unordered_map<std::pair<std::string, std::string>, Coercion> coercions;
+std::vector<CoercionEntry> defaultRules() {
+  std::vector<CoercionEntry> rules;
 
   auto add = [&](const TypePtr& from, const std::vector<TypePtr>& to) {
     int32_t cost = 0;
     for (const auto& toType : to) {
-      coercions.emplace(
-          std::make_pair<std::string, std::string>(
-              from->kindName(), toType->kindName()),
-          Coercion{.type = toType, .cost = ++cost});
+      rules.push_back({from, toType, ++cost});
     }
   };
 
-  add(TINYINT(), {SMALLINT(), INTEGER(), BIGINT(), REAL(), DOUBLE()});
-  add(SMALLINT(), {INTEGER(), BIGINT(), REAL(), DOUBLE()});
-  add(INTEGER(), {BIGINT(), REAL(), DOUBLE()});
-  add(BIGINT(), {DOUBLE()});
+  add(TINYINT(),
+      {SMALLINT(), INTEGER(), BIGINT(), DECIMAL(3, 0), REAL(), DOUBLE()});
+  add(SMALLINT(), {INTEGER(), BIGINT(), DECIMAL(5, 0), REAL(), DOUBLE()});
+  add(INTEGER(), {BIGINT(), DECIMAL(10, 0), REAL(), DOUBLE()});
+  add(BIGINT(), {DECIMAL(19, 0), DOUBLE()});
   add(REAL(), {DOUBLE()});
+  add(DECIMAL(1, 0), {REAL(), DOUBLE()});
+  add(DATE(), {TIMESTAMP()});
+  add(UNKNOWN(),
+      {TINYINT(),
+       BOOLEAN(),
+       SMALLINT(),
+       INTEGER(),
+       BIGINT(),
+       REAL(),
+       DOUBLE(),
+       VARCHAR(),
+       VARBINARY()});
 
-  return coercions;
+  return rules;
 }
+
 } // namespace
 
+TypeCoercer::TypeCoercer(const std::vector<CoercionEntry>& rules) {
+  // Tracks costs already used for a given source type to enforce uniqueness.
+  std::unordered_map<std::string, std::unordered_set<int32_t>> costsByFrom;
+
+  for (const auto& entry : rules) {
+    VELOX_CHECK_NOT_NULL(entry.from, "CoercionEntry.from must not be null");
+    VELOX_CHECK_NOT_NULL(entry.to, "CoercionEntry.to must not be null");
+
+    // Built-in -> built-in only. Custom-type coercions go through
+    // CastRulesRegistry and must not appear in a TypeCoercer rule set.
+    //
+    // Timing note: customTypeExists() checks the global custom-type
+    // registry at construction time. Today's TypeCoercer instances are
+    // lazy Meyers singletons (TypeCoercer::defaults(),
+    // presto::typeCoercer()) initialized on first use, so by then all
+    // relevant custom types are registered. If a future caller
+    // constructs a TypeCoercer eagerly (e.g., during static
+    // initialization), a rule with a name not yet registered as custom
+    // could pass this check but later collide with that type. Keep
+    // TypeCoercer construction lazy.
+    VELOX_CHECK(
+        !customTypeExists(entry.from->name()),
+        "CoercionEntry.from must be a built-in type, got custom type {}",
+        entry.from->name());
+    VELOX_CHECK(
+        !customTypeExists(entry.to->name()),
+        "CoercionEntry.to must be a built-in type, got custom type {}",
+        entry.to->name());
+
+    if (entry.from->isDecimal()) {
+      // DECIMAL -> DECIMAL is not honored: the same-name short-circuit at
+      // the top of coerceTypeBase returns cost 0 before the rule lookup
+      // runs. Reject these entries so users don't silently believe a
+      // rule is in effect.
+      VELOX_CHECK(
+          !entry.to->isDecimal(),
+          "DECIMAL -> DECIMAL coercion is not customizable via TypeCoercer. "
+          "DECIMAL -> DECIMAL reconciliation is handled by the type system "
+          "(LongDecimalType::commonSuperType). Rejecting rule {} -> {}.",
+          entry.from->toString(),
+          entry.to->toString());
+
+      // Source DECIMAL must be the canonical placeholder DECIMAL(1, 0).
+      // Source (p, s) is irrelevant at lookup -- the rule fires for any
+      // DECIMAL(p, s) -- so allowing other values here would create a
+      // false impression that callers can scope a rule to a particular
+      // precision or scale.
+      VELOX_CHECK(
+          entry.from->equivalent(*DECIMAL(1, 0)),
+          "Source DECIMAL in CoercionEntry must be DECIMAL(1, 0); got {}. "
+          "TypeCoercer does not distinguish source decimals by (p, s).",
+          entry.from->toString());
+    }
+
+    // Cost must be unique per source type so overload resolution has a
+    // deterministic preference order.
+    auto& seen = costsByFrom[entry.from->name()];
+    VELOX_CHECK(
+        seen.insert(entry.cost).second,
+        "Duplicate cost {} for source type {} in TypeCoercer rule set",
+        entry.cost,
+        entry.from->name());
+
+    // Reject duplicate (fromName, toName) pairs. This guards in particular
+    // against the common DECIMAL footgun: all decimals share the same name,
+    // so multiple {SOURCE, DECIMAL(p, s), cost} entries with different
+    // (p, s) collide on the same map key. Only one DECIMAL rule per source
+    // is supported (the minimum-width decimal -- see CoercionEntry doc).
+    auto [it, inserted] = rules_.emplace(
+        std::make_pair(entry.from->name(), entry.to->name()),
+        Coercion{.type = entry.to, .cost = entry.cost});
+    VELOX_CHECK(
+        inserted,
+        "Duplicate coercion rule {} -> {} in TypeCoercer rule set",
+        entry.from->name(),
+        entry.to->name());
+  }
+}
+
 // static
+const TypeCoercer& TypeCoercer::defaults() {
+  static const TypeCoercer instance{defaultRules()};
+  return instance;
+}
+
+std::optional<Coercion> TypeCoercer::coerceTypeBase(
+    const TypePtr& fromType,
+    const TypePtr& toType) const {
+  if (fromType->name() == toType->name()) {
+    return Coercion{.type = fromType, .cost = 0};
+  }
+
+  // Check this coercer's rule set first.
+  auto it = rules_.find({fromType->name(), toType->name()});
+  if (it != rules_.end()) {
+    if (toType->isDecimal() && it->second.type->isDecimal()) {
+      if (it->second.type->isShortDecimal()) {
+        if (!it->second.type->asShortDecimal().isCoercibleTo(*toType)) {
+          return std::nullopt;
+        }
+      } else {
+        if (!it->second.type->asLongDecimal().isCoercibleTo(*toType)) {
+          return std::nullopt;
+        }
+      }
+      return Coercion{.type = toType, .cost = it->second.cost};
+    }
+    return it->second;
+  }
+
+  // Fall back to CastRulesRegistry for custom-type coercions. Custom-type
+  // names are dialect-distinct in practice, so the global registry doesn't
+  // cross-contaminate dialects.
+  if (auto cost = CastRulesRegistry::instance().canCoerce(fromType, toType)) {
+    return Coercion{.type = toType, .cost = *cost};
+  }
+
+  return std::nullopt;
+}
+
 std::optional<Coercion> TypeCoercer::coerceTypeBase(
     const TypePtr& fromType,
-    const std::string& toTypeName) {
-  static const auto kAllowedCoercions = allowedCoercions();
+    const std::string& toTypeName) const {
   if (fromType->name() == toTypeName) {
     return Coercion{.type = fromType, .cost = 0};
   }
 
-  auto it = kAllowedCoercions.find({fromType->name(), toTypeName});
-  if (it != kAllowedCoercions.end()) {
+  // Check this coercer's rule set first.
+  auto it = rules_.find({fromType->name(), toTypeName});
+  if (it != rules_.end()) {
     return it->second;
   }
 
+  // Fall back to CastRulesRegistry for custom type coercions. Skip
+  // parameterized types -- we cannot construct the target type without knowing
+  // its type parameters.
+  // getCustomType() returns nullptr for built-in types. Callers must not
+  // pass parametric custom type names (e.g., "BIGINT_ENUM") because their
+  // factories throw when called with empty parameters. SignatureBinder
+  // guards against this by checking typeSignature.parameters().empty().
+  if (fromType->size() == 0 && fromType->parameters().empty()) {
+    if (auto toType = getCustomType(toTypeName, {})) {
+      if (auto cost =
+              CastRulesRegistry::instance().canCoerce(fromType, toType)) {
+        return Coercion{.type = std::move(toType), .cost = *cost};
+      }
+    }
+  }
+
   return std::nullopt;
 }
 
+std::optional<int32_t> TypeCoercer::coercible(
+    const TypePtr& fromType,
+    const TypePtr& toType) const {
+  if (fromType->isUnknown()) {
+    if (toType->isUnknown()) {
+      return 0;
+    }
+    return 1;
+  }
+
+  if (fromType->size() == 0) {
+    if (auto coercion = coerceTypeBase(fromType, toType)) {
+      return coercion->cost;
+    }
+
+    return std::nullopt;
+  }
+
+  if (fromType->name() != toType->name() ||
+      fromType->size() != toType->size()) {
+    return std::nullopt;
+  }
+
+  int32_t totalCost = 0;
+  for (auto i = 0; i < fromType->size(); i++) {
+    if (auto cost = coercible(fromType->childAt(i), toType->childAt(i))) {
+      totalCost += cost.value();
+    } else {
+      return std::nullopt;
+    }
+  }
+
+  return totalCost;
+}
+
+namespace {
+
+TypePtr leastCommonSuperRowType(
+    const TypeCoercer& coercer,
+    const RowType& a,
+    const RowType& b) {
+  std::vector<std::string> childNames;
+  childNames.reserve(a.size());
+
+  const auto& aNames = a.names();
+  const auto& bNames = b.names();
+
+  for (auto i = 0; i < a.size(); i++) {
+    if (aNames[i] == bNames[i]) {
+      childNames.push_back(aNames[i]);
+    } else {
+      childNames.push_back("");
+    }
+  }
+
+  std::vector<TypePtr> childTypes;
+  childTypes.reserve(a.size());
+  for (auto i = 0; i < a.size(); i++) {
+    if (auto childType =
+            coercer.leastCommonSuperType(a.childAt(i), b.childAt(i))) {
+      childTypes.push_back(childType);
+    } else {
+      return nullptr;
+    }
+  }
+
+  return ROW(std::move(childNames), std::move(childTypes));
+}
+
+} // namespace
+
+TypePtr TypeCoercer::leastCommonSuperType(const TypePtr& a, const TypePtr& b)
+    const {
+  if (a->isUnknown()) {
+    return b;
+  }
+
+  if (b->isUnknown()) {
+    return a;
+  }
+
+  if (a->size() != b->size()) {
+    return nullptr;
+  }
+
+  if (a->size() == 0) {
+    if (a->isDecimal() || b->isDecimal()) {
+      if (auto result = LongDecimalType::commonSuperType(a, b)) {
+        return result;
+      }
+    }
+
+    if (coerceTypeBase(a, b)) {
+      return b;
+    }
+
+    if (coerceTypeBase(b, a)) {
+      return a;
+    }
+
+    return nullptr;
+  }
+
+  if (a->name() != b->name()) {
+    return nullptr;
+  }
+
+  if (a->name() == TypeKindName::toName(TypeKind::ROW)) {
+    return leastCommonSuperRowType(*this, a->asRow(), b->asRow());
+  }
+
+  std::vector<TypeParameter> childTypes;
+  childTypes.reserve(a->size());
+  for (auto i = 0; i < a->size(); i++) {
+    if (auto childType = leastCommonSuperType(a->childAt(i), b->childAt(i))) {
+      childTypes.push_back(TypeParameter(childType));
+    } else {
+      return nullptr;
+    }
+  }
+
+  return getType(a->name(), childTypes);
+}
+
 } // namespace facebook::velox
diff --git a/velox/type/TypeCoercer.h b/velox/type/TypeCoercer.h
index 46251e918b4..5f2154b36ad 100644
--- a/velox/type/TypeCoercer.h
+++ b/velox/type/TypeCoercer.h
@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include <folly/hash/Hash.h>
 #include "velox/type/Type.h"
 
 namespace facebook::velox {
@@ -71,15 +72,158 @@ struct Coercion {
   }
 };
 
+/// One entry in a TypeCoercer's rule set.
+///
+/// DECIMAL handling: rules are keyed by (from->name(), to->name()), and all
+/// decimal types share name "DECIMAL". A coercer therefore holds at most one
+/// DECIMAL rule per source type. The 'to' field on that rule must be the
+/// minimum-width decimal that fits every value of the source type (e.g.,
+/// TINYINT -> DECIMAL(3, 0)). Lookup at coerceTypeBase(from, target) widens
+/// the stored minimum-width decimal to the caller's requested target if
+/// isCoercibleTo allows; the rule's cost is preserved.
+struct CoercionEntry {
+  TypePtr from;
+  TypePtr to;
+  int32_t cost;
+};
+
+/// Type coercion rules. Each instance owns a complete rule set and
+/// is immutable after construction. Velox ships a default instance
+/// (TypeCoercer::defaults()) holding today's conservative built-in rules;
+/// each SQL dialect can ship its own complete instance with rules that match
+/// the dialect's semantics.
+///
+/// Coercion is a planning-time concern: by the time a Velox Task is
+/// constructed, every type mismatch is already an explicit Cast node. Runtime
+/// expression evaluators do not consult TypeCoercer.
+///
+/// Customization scope. The rule set determines coercion between primitive
+/// types (TINYINT, SMALLINT, INTEGER, BIGINT, REAL, DOUBLE, BOOLEAN,
+/// VARCHAR, VARBINARY, DATE, TIMESTAMP, UNKNOWN); a dialect has full
+/// control over which pairs are allowed and at what cost.
+///
+/// Cost magnitudes. Overload resolution sums per-argument coercion costs
+/// (Coercion::overallCost) to compare candidate signatures. For sums to
+/// be meaningful, every CoercionEntry.cost in a single TypeCoercer
+/// instance must be in the same small magnitude -- today's defaults use
+/// costs 1-9, one per source-type series. A dialect that mixes costs of
+/// vastly different magnitudes (e.g., 1-10 for some entries, 100-1000
+/// for others) will produce surprising tie-breaking. There is no
+/// hardcoded surcharge added at lookup time: the dialect's rule cost is
+/// returned verbatim, including for INT -> DECIMAL widening -- the rule's
+/// stored cost applies to every compatible target (p, s).
+///
+/// DECIMAL handling is two-step: the dialect's rule resolves a
+/// fixed-(p, s) decimal, then the type system's generic DECIMAL->DECIMAL
+/// compatibility widens it to the caller's request. Rule keys collapse on
+/// the name "DECIMAL" regardless of (p, s) -- one rule per
+/// (sourceName, targetName) pair on each side.
+///
+/// Source DECIMAL: a dialect registers one rule per (DECIMAL, target).
+/// The source must be DECIMAL(1, 0) (the canonical placeholder -- see
+/// CoercionEntry doc); the rule fires for any actual DECIMAL(p, s) source
+/// because the source's precision/scale is not part of the lookup key.
+///
+/// Target DECIMAL: a dialect registers one rule per (source, DECIMAL),
+/// with the rule's stored target serving as the minimum-width decimal
+/// that holds every value of the source (e.g., INTEGER -> DECIMAL(10, 0)).
+/// At lookup, the type system extends this fixed target to the caller's
+/// requested (p, s) via ShortDecimalType / LongDecimalType isCoercibleTo
+/// -- the dialect does not control widening; it picks only the
+/// minimum-width target.
+///
+/// DECIMAL -> DECIMAL is **not customizable** by dialects. Rule entries
+/// with both source and target DECIMAL are not honored: the same-name
+/// short-circuit at the top of coerceTypeBase returns cost 0 for any two
+/// DECIMALs regardless of (p, s) before the rule lookup runs.
+/// Precision/scale reconciliation between two DECIMALs is hardcoded in
+/// the type system -- LongDecimalType::commonSuperType inside
+/// leastCommonSuperType for plan-level operations (UNION, CASE result
+/// type, etc.), and SignatureBinder's integer-parameter binding for
+/// function signatures of the form DECIMAL(P, S). Dialects that need
+/// non-standard DECIMAL->DECIMAL semantics must extend the type system,
+/// not TypeCoercer.
+///
+/// Container types (ARRAY, MAP, ROW) and FUNCTION/OPAQUE are not
+/// customizable directly -- coercibility for those is structural (names and
+/// arities must match, children are recursed element-wise, see
+/// coercible()), so a dialect controls their behavior only indirectly via
+/// element-type rules.
+///
+/// Custom types (e.g. JSON, TIMESTAMP WITH TIME ZONE) are out of scope for
+/// TypeCoercer; they're coerced via the global CastRulesRegistry registered
+/// alongside registerCustomType().
 class TypeCoercer {
  public:
+  /// Construct from a complete rule set. Rules are frozen on construction.
+  /// Dialect-specific factories (e.g. presto::typeCoercer()) build a
+  /// TypeCoercer and expose it as a singleton rather than mutating an
+  /// existing instance.
+  explicit TypeCoercer(const std::vector<CoercionEntry>& rules);
+
+  /// Velox's default coercer holding today's conservative built-in rules.
+  /// Used by callers that have not selected a dialect-specific coercer.
+  static const TypeCoercer& defaults();
+
+  /// Checks if 'fromType' can be implicitly converted to 'toType' via a
+  /// single rule lookup. Does NOT recurse into container children -- for
+  /// container coercibility (e.g., ARRAY<INT> vs ARRAY<BIGINT>), use
+  /// coercible() instead.
+  ///
+  /// Prefer this over the string overload when the target type is available,
+  /// as it avoids reconstructing the type from a name (which can throw for
+  /// parametric custom types like BigintEnum).
+  ///
+  /// For DECIMAL targets, the rule's stored type is the minimum-width
+  /// decimal for the source. If 'toType' is a wider DECIMAL that the
+  /// minimum can be coerced to (per ShortDecimalType / LongDecimalType
+  /// isCoercibleTo), the returned Coercion carries 'toType' and the rule's
+  /// cost. If 'toType' is too narrow, returns nullopt.
+  ///
+  /// @return "to" type and cost if conversion is possible.
+  std::optional<Coercion> coerceTypeBase(
+      const TypePtr& fromType,
+      const TypePtr& toType) const;
+
   /// Checks if the base of 'fromType' can be implicitly converted to a type
-  /// with the given name.
+  /// with the given name. Used by SignatureBinder which only has a type name.
   ///
   /// @return "to" type and cost if conversion is possible.
-  static std::optional<Coercion> coerceTypeBase(
+  std::optional<Coercion> coerceTypeBase(
       const TypePtr& fromType,
-      const std::string& toTypeName);
+      const std::string& toTypeName) const;
+
+  /// Checks if 'fromType' can be implicitly converted to 'toType', recursing
+  /// into container children. For primitives this delegates to
+  /// coerceTypeBase(); for containers (ARRAY, MAP, ROW, FUNCTION) the names
+  /// and arities must match, then each child must be element-wise coercible.
+  ///
+  /// @return Total cost (sum of child costs for containers) if possible.
+  /// std::nullopt otherwise.
+  std::optional<int32_t> coercible(
+      const TypePtr& fromType,
+      const TypePtr& toType) const;
+
+  /// Returns least common type for 'a' and 'b', i.e. a type that both 'a' and
+  /// 'b' are coercible to. Returns nullptr if no such type exists.
+  ///
+  /// When `a` and `b` are ROW types with different field names, the resulting
+  /// ROW has empty field names for any positions where the corresponding field
+  /// names do not match.
+  TypePtr leastCommonSuperType(const TypePtr& a, const TypePtr& b) const;
+
+ private:
+  struct PairHash {
+    size_t operator()(const std::pair<std::string, std::string>& p) const {
+      return folly::hash::hash_combine(
+          std::hash<std::string>{}(p.first),
+          std::hash<std::string>{}(p.second));
+    }
+  };
+
+  // Flat map: (fromName, toName) -> Coercion{type, cost}.
+  std::unordered_map<std::pair<std::string, std::string>, Coercion, PairHash>
+      rules_;
 };
 
 } // namespace facebook::velox
diff --git a/velox/type/TypeSerde.h b/velox/type/TypeSerde.h
new file mode 100644
index 00000000000..b5613e7bd39
--- /dev/null
+++ b/velox/type/TypeSerde.h
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <folly/container/F14Map.h>
+#include <folly/dynamic.h>
+
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+
+/// Cache of serialized RowType instances. Useful to reduce the size of
+/// serialized expressions and plans. Disabled by default. Not thread safe.
+///
+/// To enable, call 'serializedTypeCache().enable()'. This enables the cache for
+/// the current thread. To disable, call 'serializedTypeCache().disable()'.
+/// While enables, type serialization will use the cache and serialize the types
+/// using IDs stored in the cache. The caller is responsible for saving
+/// serialized types from the cache and using these to hidrate
+/// 'deserializedTypeCache()' before deserializing the types.
+class SerializedTypeCache {
+ public:
+  struct Options {
+    // Caching applies to RowType's with at least this many fields.
+    size_t minRowTypeSize = 10;
+  };
+
+  bool isEnabled() const {
+    return enabled_;
+  }
+
+  const Options& options() const {
+    return options_;
+  }
+
+  void enable(const Options& options = {.minRowTypeSize = 10}) {
+    enabled_ = true;
+    options_ = options;
+  }
+
+  void disable() {
+    enabled_ = false;
+  }
+
+  size_t size() const {
+    return cache_.size();
+  }
+
+  void clear() {
+    cache_.clear();
+  }
+
+  /// Returns the ID of the type if it is in the cache. Returns std::nullopt if
+  /// type is not found in the cache. Cache key is type instance pointer. Hence,
+  /// equal but different instances are stored separately.
+  std::optional<int32_t> get(const Type& type) const;
+
+  /// Stores the type in the cache. Returns the ID of the type. Reports an error
+  /// if type is already present in the cache. IDs are monotonically increasing.
+  /// Serialized type may refer to types stored previously in the cache. When
+  /// deserializing type cache, make sure to deserialize types in the order of
+  /// cache IDs.
+  int32_t put(const Type& type, folly::dynamic serialized);
+
+  /// Serialized the types stored in the cache. Use
+  /// DeserializedTypeCache::deserialize to deserialize.
+  folly::dynamic serialize();
+
+ private:
+  bool enabled_{false};
+  Options options_;
+  folly::F14FastMap<const Type*, std::pair<int32_t, folly::dynamic>> cache_;
+};
+
+/// Thread local cache of serialized RowType instances. Used by
+/// RowType::serialize.
+SerializedTypeCache& serializedTypeCache();
+
+/// Thread local cache of deserialized RowType instances. Used when
+/// deserializing Type objects.
+class DeserializedTypeCache {
+ public:
+  void deserialize(const folly::dynamic& obj);
+
+  size_t size() const {
+    return cache_.size();
+  }
+
+  const TypePtr& get(int32_t id) const;
+
+  void clear() {
+    cache_.clear();
+  }
+
+ private:
+  folly::F14FastMap<int32_t, TypePtr> cache_;
+};
+
+DeserializedTypeCache& deserializedTypeCache();
+
+} // namespace facebook::velox
diff --git a/velox/type/TypeUtil.cpp b/velox/type/TypeUtil.cpp
index fc2645e5b74..01bb38445a8 100644
--- a/velox/type/TypeUtil.cpp
+++ b/velox/type/TypeUtil.cpp
@@ -18,10 +18,9 @@
 
 namespace facebook::velox::type {
 
-velox::RowTypePtr concatRowTypes(
-    const std::vector<velox::RowTypePtr>& rowTypes) {
+RowTypePtr concatRowTypes(const std::vector<RowTypePtr>& rowTypes) {
   std::vector<std::string> columnNames;
-  std::vector<velox::TypePtr> columnTypes;
+  std::vector<TypePtr> columnTypes;
   for (auto& rowType : rowTypes) {
     columnNames.insert(
         columnNames.end(), rowType->names().begin(), rowType->names().end());
@@ -30,7 +29,28 @@ velox::RowTypePtr concatRowTypes(
         rowType->children().begin(),
         rowType->children().end());
   }
-  return velox::ROW(std::move(columnNames), std::move(columnTypes));
+  return ROW(std::move(columnNames), std::move(columnTypes));
+}
+
+TypePtr tryGetHomogeneousRowChild(const TypePtr& type) {
+  VELOX_DCHECK(type != nullptr);
+  if (type->kind() != TypeKind::ROW) {
+    return nullptr;
+  }
+
+  const auto childCount = type->size();
+  if (childCount == 0) {
+    return nullptr; // No child type to infer
+  }
+
+  const auto& first = type->childAt(0);
+  for (size_t i = 1; i < childCount; ++i) {
+    const auto& child = type->childAt(i);
+    if (!(*first == *child)) {
+      return nullptr;
+    }
+  }
+  return first;
 }
 
 } // namespace facebook::velox::type
diff --git a/velox/type/TypeUtil.h b/velox/type/TypeUtil.h
index ae03cc2570e..00a6d346b55 100644
--- a/velox/type/TypeUtil.h
+++ b/velox/type/TypeUtil.h
@@ -22,7 +22,11 @@
 
 namespace facebook::velox::type {
 
-velox::RowTypePtr concatRowTypes(
-    const std::vector<velox::RowTypePtr>& rowTypes);
+RowTypePtr concatRowTypes(const std::vector<RowTypePtr>& rowTypes);
+
+/// Returns the common child type if 'type' is a Row where all children are
+/// the same. Returns nullptr otherwise. Empty row returns nullptr.
+/// @pre 'type' must not be null.
+TypePtr tryGetHomogeneousRowChild(const TypePtr& type);
 
 } // namespace facebook::velox::type
diff --git a/velox/type/Variant.cpp b/velox/type/Variant.cpp
index 8799a83d172..304acbfcc04 100644
--- a/velox/type/Variant.cpp
+++ b/velox/type/Variant.cpp
@@ -23,22 +23,21 @@
 #include "velox/type/FloatingPointUtil.h"
 
 namespace facebook::velox {
-
 namespace {
 
-bool dispatchDynamicVariantEquality(
+std::optional<bool> dispatchDynamicVariantEquality(
     const Variant& a,
     const Variant& b,
-    const bool& enableNullEqualsNull);
+    CompareFlags::NullHandlingMode nullHandlingMode);
 
-template <bool nullEqualsNull>
-bool evaluateNullEquality(const Variant& a, const Variant& b) {
-  if constexpr (nullEqualsNull) {
-    if (a.isNull() && b.isNull()) {
-      return true;
-    }
+std::optional<bool> evaluateNullEquality(
+    const Variant& a,
+    const Variant& b,
+    CompareFlags::NullHandlingMode nullHandlingMode) {
+  if (nullHandlingMode == CompareFlags::NullHandlingMode::kNullAsValue) {
+    return a.isNull() && b.isNull();
   }
-  return false;
+  return std::nullopt;
 }
 
 template <TypeKind KIND>
@@ -47,10 +46,10 @@ struct VariantEquality;
 // scalars
 template <TypeKind KIND>
 struct VariantEquality {
-  template <bool NullEqualsNull>
-  static bool equals(const Variant& a, const Variant& b) {
+  template <CompareFlags::NullHandlingMode nullHandlingMode>
+  static std::optional<bool> equals(const Variant& a, const Variant& b) {
     if (a.isNull() || b.isNull()) {
-      return evaluateNullEquality<NullEqualsNull>(a, b);
+      return evaluateNullEquality(a, b, nullHandlingMode);
     }
     return a.value<KIND>() == b.value<KIND>();
   }
@@ -59,10 +58,10 @@ struct VariantEquality {
 // timestamp
 template <>
 struct VariantEquality<TypeKind::TIMESTAMP> {
-  template <bool NullEqualsNull>
-  static bool equals(const Variant& a, const Variant& b) {
+  template <CompareFlags::NullHandlingMode nullHandlingMode>
+  static std::optional<bool> equals(const Variant& a, const Variant& b) {
     if (a.isNull() || b.isNull()) {
-      return evaluateNullEquality<NullEqualsNull>(a, b);
+      return evaluateNullEquality(a, b, nullHandlingMode);
     } else {
       return a.value<TypeKind::TIMESTAMP>() == b.value<TypeKind::TIMESTAMP>();
     }
@@ -72,34 +71,42 @@ struct VariantEquality<TypeKind::TIMESTAMP> {
 // array
 template <>
 struct VariantEquality<TypeKind::ARRAY> {
-  template <bool NullEqualsNull>
-  static bool equals(const Variant& a, const Variant& b) {
+  template <CompareFlags::NullHandlingMode nullHandlingMode>
+  static std::optional<bool> equals(const Variant& a, const Variant& b) {
     if (a.isNull() || b.isNull()) {
-      return evaluateNullEquality<NullEqualsNull>(a, b);
+      return evaluateNullEquality(a, b, nullHandlingMode);
     }
     auto& aArray = a.value<TypeKind::ARRAY>();
     auto& bArray = b.value<TypeKind::ARRAY>();
     if (aArray.size() != bArray.size()) {
       return false;
     }
+    bool isComparisonIndeterminate = false;
     for (size_t i = 0; i != aArray.size(); ++i) {
       // todo(youknowjack): switch outside the loop
-      bool result =
-          dispatchDynamicVariantEquality(aArray[i], bArray[i], NullEqualsNull);
-      if (!result) {
-        return false;
+      auto compareResult = dispatchDynamicVariantEquality(
+          aArray[i], bArray[i], nullHandlingMode);
+      if (compareResult.has_value()) {
+        if (!compareResult.value()) {
+          return false;
+        }
+      } else {
+        isComparisonIndeterminate = true;
       }
     }
+    if (isComparisonIndeterminate) {
+      return std::nullopt;
+    }
     return true;
   }
 };
 
 template <>
 struct VariantEquality<TypeKind::ROW> {
-  template <bool NullEqualsNull>
-  static bool equals(const Variant& a, const Variant& b) {
+  template <CompareFlags::NullHandlingMode nullHandlingMode>
+  static std::optional<bool> equals(const Variant& a, const Variant& b) {
     if (a.isNull() || b.isNull()) {
-      return evaluateNullEquality<NullEqualsNull>(a, b);
+      return evaluateNullEquality(a, b, nullHandlingMode);
     }
     auto& aRow = a.value<TypeKind::ROW>();
     auto& bRow = b.value<TypeKind::ROW>();
@@ -109,23 +116,31 @@ struct VariantEquality<TypeKind::ROW> {
       return false;
     }
     // compare array values
+    bool isComparisonIndeterminate = false;
     for (size_t i = 0; i != aRow.size(); ++i) {
-      bool result =
-          dispatchDynamicVariantEquality(aRow[i], bRow[i], NullEqualsNull);
-      if (!result) {
-        return false;
+      auto compareResult =
+          dispatchDynamicVariantEquality(aRow[i], bRow[i], nullHandlingMode);
+      if (compareResult.has_value()) {
+        if (!compareResult.value()) {
+          return false;
+        }
+      } else {
+        isComparisonIndeterminate = true;
       }
     }
+    if (isComparisonIndeterminate) {
+      return std::nullopt;
+    }
     return true;
   }
 };
 
 template <>
 struct VariantEquality<TypeKind::MAP> {
-  template <bool NullEqualsNull>
-  static bool equals(const Variant& a, const Variant& b) {
+  template <CompareFlags::NullHandlingMode nullHandlingMode>
+  static std::optional<bool> equals(const Variant& a, const Variant& b) {
     if (a.isNull() || b.isNull()) {
-      return evaluateNullEquality<NullEqualsNull>(a, b);
+      return evaluateNullEquality(a, b, nullHandlingMode);
     }
 
     auto& aMap = a.value<TypeKind::MAP>();
@@ -135,33 +150,76 @@ struct VariantEquality<TypeKind::MAP> {
       return false;
     }
     // compare map values
+    bool isComparisonIndeterminate = false;
     for (auto it_a = aMap.begin(), it_b = bMap.begin();
          it_a != aMap.end() && it_b != bMap.end();
          ++it_a, ++it_b) {
-      if (dispatchDynamicVariantEquality(
-              it_a->first, it_b->first, NullEqualsNull) &&
-          dispatchDynamicVariantEquality(
-              it_a->second, it_b->second, NullEqualsNull)) {
-        continue;
+      auto keysCompareResult = dispatchDynamicVariantEquality(
+          it_a->first, it_b->first, nullHandlingMode);
+      if (keysCompareResult.has_value()) {
+        if (!keysCompareResult.value()) {
+          return false;
+        }
       } else {
-        return false;
+        isComparisonIndeterminate = true;
       }
+
+      auto valuesCompareResult = dispatchDynamicVariantEquality(
+          it_a->second, it_b->second, nullHandlingMode);
+      if (valuesCompareResult.has_value()) {
+        if (!valuesCompareResult.value()) {
+          return false;
+        }
+      } else {
+        isComparisonIndeterminate = true;
+      }
+    }
+    if (isComparisonIndeterminate) {
+      return std::nullopt;
     }
     return true;
   }
 };
 
-bool dispatchDynamicVariantEquality(
+std::optional<bool> dispatchDynamicVariantEquality(
     const Variant& a,
     const Variant& b,
-    const bool& enableNullEqualsNull) {
-  if (enableNullEqualsNull) {
-    return VELOX_DYNAMIC_TYPE_DISPATCH_METHOD(
-        VariantEquality, equals<true>, a.kind(), a, b);
+    CompareFlags::NullHandlingMode nullHandlingMode) {
+  if (nullHandlingMode == CompareFlags::NullHandlingMode::kNullAsValue) {
+    return VELOX_DYNAMIC_TYPE_DISPATCH_METHOD_ALL(
+        VariantEquality,
+        equals<CompareFlags::NullHandlingMode::kNullAsValue>,
+        a.kind(),
+        a,
+        b);
+  }
+  return VELOX_DYNAMIC_TYPE_DISPATCH_METHOD_ALL(
+      VariantEquality,
+      equals<CompareFlags::NullHandlingMode::kNullAsIndeterminate>,
+      a.kind(),
+      a,
+      b);
+}
+
+folly::dynamic doubleToDynamic(double val) {
+  if (std::isinf(val) || std::isnan(val)) {
+    return folly::to<std::string>(val);
+  } else {
+    return val;
   }
-  return VELOX_DYNAMIC_TYPE_DISPATCH_METHOD(
-      VariantEquality, equals<false>, a.kind(), a, b);
 }
+
+double dynamicToDouble(const folly::dynamic& val) {
+  if (val.isString()) {
+    return folly::to<double>(val.asString());
+  } else if (val.isDouble()) {
+    return val.asDouble();
+  } else if (val.isInt()) {
+    return val.asInt();
+  }
+  VELOX_FAIL("Unexpected value type: {}", val.typeName());
+}
+
 } // namespace
 
 std::string encloseWithQuote(std::string str) {
@@ -182,14 +240,14 @@ std::string stringifyFloatingPointerValue(T val) {
 }
 
 void Variant::throwCheckIsKindError(TypeKind kind) const {
-  throw std::invalid_argument{fmt::format(
+  VELOX_USER_FAIL(
       "wrong kind! {} != {}",
-      mapTypeKindToName(kind_),
-      mapTypeKindToName(kind))};
+      TypeKindName::toName(kind_),
+      TypeKindName::toName(kind));
 }
 
 void Variant::throwCheckPtrError() const {
-  throw std::invalid_argument{"missing Variant value"};
+  VELOX_USER_FAIL("missing Variant value");
 }
 
 std::string Variant::toString(const TypePtr& type) const {
@@ -212,8 +270,10 @@ std::string Variant::toString(const TypePtr& type) const {
       return str;
     }
     case TypeKind::HUGEINT: {
-      VELOX_CHECK(type->isLongDecimal());
-      return DecimalUtil::toString(value<TypeKind::HUGEINT>(), type);
+      if (type->isLongDecimal()) {
+        return DecimalUtil::toString(value<TypeKind::HUGEINT>(), type);
+      }
+      return folly::to<std::string>(value<TypeKind::HUGEINT>());
     }
     case TypeKind::TINYINT:
       [[fallthrough]];
@@ -343,6 +403,11 @@ const folly::json::serialization_opts& getOpts() {
 } // namespace
 
 std::string Variant::toJson(const TypePtr& type) const {
+  VELOX_CHECK(type);
+  return toJson(*type);
+}
+
+std::string Variant::toJson(const Type& type) const {
   // todo(youknowjack): consistent story around std::stringifying, converting,
   // and other basic operations. Stringification logic should not be specific
   // to variants; it should be consistent for all map representations
@@ -351,9 +416,7 @@ std::string Variant::toJson(const TypePtr& type) const {
     return "null";
   }
 
-  VELOX_CHECK(type);
-
-  VELOX_CHECK_EQ(this->kind(), type->kind(), "Wrong type in Variant::toJson");
+  VELOX_CHECK_EQ(this->kind(), type.kind(), "Wrong type in Variant::toJson");
 
   switch (kind_) {
     case TypeKind::MAP: {
@@ -366,9 +429,9 @@ std::string Variant::toJson(const TypePtr& type) const {
           b += ",";
         }
         b += "{\"key\":";
-        b += pair.first.toJson(type->childAt(0));
+        b += pair.first.toJson(type.childAt(0));
         b += ",\"value\":";
-        b += pair.second.toJson(type->childAt(1));
+        b += pair.second.toJson(type.childAt(1));
         b += "}";
         first = false;
       }
@@ -383,13 +446,13 @@ std::string Variant::toJson(const TypePtr& type) const {
       uint32_t idx = 0;
       VELOX_CHECK_EQ(
           row.size(),
-          type->size(),
+          type.size(),
           "Wrong number of fields in a struct in Variant::toJson");
       for (auto& v : row) {
         if (!first) {
           b += ",";
         }
-        b += v.toJson(type->childAt(idx++));
+        b += v.toJson(type.childAt(idx++));
         first = false;
       }
       b += "]";
@@ -400,7 +463,7 @@ std::string Variant::toJson(const TypePtr& type) const {
       std::string b{};
       b += "[";
       bool first = true;
-      auto arrayElementType = type->childAt(0);
+      auto arrayElementType = type.childAt(0);
       for (auto& v : array) {
         if (!first) {
           b += ",";
@@ -423,20 +486,22 @@ std::string Variant::toJson(const TypePtr& type) const {
       return target;
     }
     case TypeKind::HUGEINT: {
-      VELOX_CHECK(type->isLongDecimal());
-      return DecimalUtil::toString(value<TypeKind::HUGEINT>(), type);
+      if (type.isLongDecimal()) {
+        return DecimalUtil::toString(value<TypeKind::HUGEINT>(), type);
+      }
+      return folly::to<std::string>(value<TypeKind::HUGEINT>());
     }
     case TypeKind::TINYINT:
       [[fallthrough]];
     case TypeKind::SMALLINT:
       [[fallthrough]];
     case TypeKind::INTEGER:
-      if (type->isDate()) {
+      if (type.isDate()) {
         return '"' + DATE()->toString(value<TypeKind::INTEGER>()) + '"';
       }
       [[fallthrough]];
     case TypeKind::BIGINT:
-      if (type->isShortDecimal()) {
+      if (type.isShortDecimal()) {
         return DecimalUtil::toString(value<TypeKind::BIGINT>(), type);
       }
       [[fallthrough]];
@@ -455,7 +520,7 @@ std::string Variant::toJson(const TypePtr& type) const {
       return stringifyFloatingPointerValue<double>(value<TypeKind::DOUBLE>());
     }
     case TypeKind::TIMESTAMP: {
-      auto& timestamp = value<TypeKind::TIMESTAMP>();
+      const auto& timestamp = value<TypeKind::TIMESTAMP>();
       return '"' + timestamp.toString() + '"';
     }
     case TypeKind::OPAQUE: {
@@ -476,7 +541,8 @@ std::string Variant::toJson(const TypePtr& type) const {
   }
 
   VELOX_UNSUPPORTED(
-      "Unsupported: given type {} is not json-ready", mapTypeKindToName(kind_));
+      "Unsupported: given type {} is not json-ready",
+      TypeKindName::toName(kind_));
 }
 
 // This is the unsafe older implementation of toJson. It is kept here for
@@ -549,8 +615,10 @@ std::string Variant::toJsonUnsafe(const TypePtr& type) const {
       return target;
     }
     case TypeKind::HUGEINT: {
-      VELOX_CHECK(type && type->isLongDecimal());
-      return DecimalUtil::toString(value<TypeKind::HUGEINT>(), type);
+      if (type && type->isLongDecimal()) {
+        return DecimalUtil::toString(value<TypeKind::HUGEINT>(), type);
+      }
+      return folly::to<std::string>(value<TypeKind::HUGEINT>());
     }
     case TypeKind::TINYINT:
       [[fallthrough]];
@@ -602,7 +670,8 @@ std::string Variant::toJsonUnsafe(const TypePtr& type) const {
   }
 
   VELOX_UNSUPPORTED(
-      "Unsupported: given type {} is not json-ready", mapTypeKindToName(kind_));
+      "Unsupported: given type {} is not json-ready",
+      TypeKindName::toName(kind_));
 }
 
 void serializeOpaque(
@@ -624,7 +693,7 @@ void serializeOpaque(
 folly::dynamic Variant::serialize() const {
   folly::dynamic variantObj = folly::dynamic::object;
 
-  variantObj["type"] = mapTypeKindToName(kind_);
+  variantObj["type"] = std::string(TypeKindName::toName(kind_));
   auto& objValue = variantObj["value"];
   if (isNull()) {
     objValue = nullptr;
@@ -685,11 +754,11 @@ folly::dynamic Variant::serialize() const {
       break;
     }
     case TypeKind::REAL: {
-      objValue = value<TypeKind::REAL>();
+      objValue = doubleToDynamic(value<TypeKind::REAL>());
       break;
     }
     case TypeKind::DOUBLE: {
-      objValue = value<TypeKind::DOUBLE>();
+      objValue = doubleToDynamic(value<TypeKind::DOUBLE>());
       break;
     }
     case TypeKind::VARCHAR: {
@@ -735,7 +804,7 @@ Variant deserializeOpaque(const folly::dynamic& variantobj) {
 }
 
 Variant Variant::create(const folly::dynamic& variantobj) {
-  TypeKind kind = mapNameToTypeKind(variantobj["type"].asString());
+  TypeKind kind = TypeKindName::toTypeKind(variantobj["type"].asString());
   const folly::dynamic& obj = variantobj["value"];
 
   if (obj.isNull()) {
@@ -788,19 +857,9 @@ Variant Variant::create(const folly::dynamic& variantobj) {
       return Variant(obj.asBool());
     }
     case TypeKind::REAL:
-      if (obj.isInt()) {
-        // folly::parseJson() parses eg: "2293699590479675400"
-        // to int64 instead of double, and asDouble() will throw
-        // "folly::ConversionError: Loss of precision", so we do
-        // the check here to make it more robust.
-        return Variant::create<TypeKind::REAL>(obj.asInt());
-      }
-      return Variant::create<TypeKind::REAL>(obj.asDouble());
+      return Variant::create<TypeKind::REAL>(dynamicToDouble(obj));
     case TypeKind::DOUBLE: {
-      if (obj.isInt()) {
-        return Variant::create<TypeKind::DOUBLE>(obj.asInt());
-      }
-      return Variant::create<TypeKind::DOUBLE>(obj.asDouble());
+      return Variant::create<TypeKind::DOUBLE>(dynamicToDouble(obj));
     }
     case TypeKind::OPAQUE: {
       return deserializeOpaque(variantobj);
@@ -871,14 +930,24 @@ bool Variant::equals(const Variant& other) const {
   return value<KIND>() == other.value<KIND>();
 }
 
-bool Variant::equals(const Variant& other) const {
+std::optional<bool> Variant::equals(
+    const Variant& other,
+    CompareFlags::NullHandlingMode nullHandlingMode) const {
   if (other.kind_ != this->kind_) {
     return false;
   }
-  if (other.isNull()) {
-    return this->isNull();
+  if (nullHandlingMode == CompareFlags::NullHandlingMode::kNullAsValue &&
+      !this->isNull() && !other.isNull()) {
+    return VELOX_DYNAMIC_TYPE_DISPATCH_ALL(equals, kind_, other);
   }
-  return VELOX_DYNAMIC_TYPE_DISPATCH_ALL(equals, kind_, other);
+  return dispatchDynamicVariantEquality(*this, other, nullHandlingMode);
+}
+
+bool Variant::equals(const Variant& other) const {
+  std::optional<bool> compareResult =
+      this->equals(other, CompareFlags::NullHandlingMode::kNullAsValue);
+  VELOX_CHECK(compareResult.has_value());
+  return compareResult.value();
 }
 
 template <TypeKind KIND>
@@ -968,7 +1037,7 @@ bool equalsFloatingPointWithEpsilonTyped(const Variant& a, const Variant& b) {
 
   // Check if the numbers are really close -- needed
   // when comparing numbers near zero.
-  if (fabs(f1 - f2) < kEpsilon) {
+  if (fabs(f1 - f2) < Variant::kEpsilon) {
     return true;
   }
 
@@ -1054,7 +1123,7 @@ bool compareComplexTypeWithEpsilon<TypeKind::MAP>(
 }
 } // namespace
 
-// Uses kEpsilon to compare floating point types (REAL and DOUBLE).
+// Uses Variant::kEpsilon to compare floating point types (REAL and DOUBLE).
 // For testing purposes.
 bool Variant::equalsWithEpsilon(const Variant& other) const {
   if (other.kind_ != this->kind_) {
@@ -1102,13 +1171,6 @@ void Variant::verifyArrayElements(const std::vector<Variant>& inputs) {
   }
 }
 
-bool Variant::equalsWithNullEqualsNull(const Variant& other) const {
-  if (other.kind_ != this->kind_) {
-    return false;
-  }
-  return dispatchDynamicVariantEquality(*this, other, true);
-}
-
 TypePtr Variant::inferType() const {
   switch (kind_) {
     case TypeKind::MAP: {
diff --git a/velox/type/Variant.h b/velox/type/Variant.h
index 9e0829cb7fa..0c1fdd7ffae 100644
--- a/velox/type/Variant.h
+++ b/velox/type/Variant.h
@@ -22,6 +22,7 @@
 #include <folly/Conv.h>
 
 #include "folly/dynamic.h"
+#include "velox/common/base/CompareFlags.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/type/Conversions.h"
 #include "velox/type/CppToType.h"
@@ -29,13 +30,89 @@
 
 namespace facebook::velox {
 
-// Constant used in comparison of REAL and DOUBLE values.
-constexpr double kEpsilon{0.00001};
-
-// note: while this is not intended for use in real critical code paths,
-//       it's probably worthwhile to make it not completely suck
-// todo(youknowjack): make this class not completely suck
-
+/// Variant is a dynamically-typed container that can hold values of any Velox
+/// type, providing a type-safe way to work with heterogeneous data at runtime.
+///
+/// A Variant encapsulates a value along with its TypeKind, supporting all Velox
+/// types including scalars (INTEGER, VARCHAR, DOUBLE, etc.), complex types
+/// (ARRAY, MAP, ROW), and special types (TIMESTAMP, OPAQUE). Variants can also
+/// represent null values of any type.
+///
+/// Note that Variants only store the physical type of a variable (the
+/// TypeKind), and not its logical type (TypePtr). Variants also do not store
+/// the field names of a row/struct.
+///
+/// **IMPORTANT**: Variants are NOT intended for performance-critical code
+/// paths. For production workloads processing large amounts of data, use
+/// Vectors instead:
+///
+/// ## Supported Types
+///
+/// Scalar types:
+/// - Numeric: BOOLEAN, TINYINT, SMALLINT, INTEGER, BIGINT, HUGEINT, REAL,
+///   DOUBLE
+/// - String: VARCHAR, VARBINARY
+/// - Temporal: TIMESTAMP, DATE (via INTEGER)
+/// - Special: UNKNOWN (null variant)
+///
+/// Complex types:
+/// - ARRAY: Ordered collection of Variants (all elements must have same
+///   TypeKind)
+/// - MAP: Key-value mapping of Variants
+/// - ROW: Heterogeneous tuple of Variants
+///
+/// Special types:
+/// - OPAQUE: Type-erased wrapper for custom C++ objects
+///
+/// ## Construction and Factory Methods
+///
+/// Variants can be created via:
+/// - Implicit constructors from native types: `Variant(42)`, `Variant("hello")`
+/// - Explicit factory methods: `Variant::create<KIND>(value)`
+/// - Type-specific factories: `Variant::array()`, `Variant::map()`,
+///   `Variant::row()`
+/// - Null values: `Variant::null(TypeKind)` or `Variant(TypeKind)`
+/// - Deserialization: `Variant::create(folly::dynamic)`
+///
+/// ## Type Safety and Value Access
+///
+/// Variants provide runtime type checking:
+/// - `kind()` returns the TypeKind
+/// - `value<KIND>()` extracts the value (throws if wrong type)
+/// - `isNull()` checks for null values
+/// - `inferType()` returns the full Type descriptor
+///
+/// ## Example Usage
+///
+/// ```cpp
+/// // Creating variants
+/// Variant intVar = 42;                    // INTEGER
+/// Variant strVar = "hello";               // VARCHAR
+/// Variant dblVar = 3.14;                  // DOUBLE
+/// Variant nullVar = Variant::null(TypeKind::INTEGER);
+///
+/// // Complex types
+/// Variant arr = Variant::array({Variant(1), Variant(2), Variant(3)});
+/// Variant map = Variant::map({{Variant("key"), Variant("value")}});
+/// Variant row = Variant::row({Variant(1), Variant("test"), Variant(3.14)});
+///
+/// // Accessing values
+/// int32_t i = intVar.value<TypeKind::INTEGER>();
+/// std::string s = strVar.value<TypeKind::VARCHAR>();
+/// const auto& elements = arr.value<TypeKind::ARRAY>();
+///
+/// // Serialization
+/// auto serialized = arr.serialize();              // to folly::dynamic
+/// auto deserialized = Variant::create(serialized); // from folly::dynamic
+/// assert(arr == deserialized);
+/// ```
+///
+/// ## Memory and Lifetime
+///
+/// - Variants own their data and perform deep copies on assignment.
+/// - Values are heap-allocated (except for primitive types).
+/// - Variants are movable and copyable with expected semantics
+/// - For OPAQUE types, Variants hold shared_ptr, allowing shared ownership.
 class Variant;
 
 namespace detail {
@@ -62,8 +139,7 @@ struct VariantTypeTraits<
     KIND,
     usesCustomComparison,
     std::enable_if_t<
-        TypeTraits<KIND>::isPrimitiveType && KIND != TypeKind::VARCHAR &&
-            KIND != TypeKind::VARBINARY,
+        TypeTraits<KIND>::isPrimitiveType && !is_string_kind(KIND),
         void>> {
   using native_type = typename TypeTraits<KIND>::NativeType;
   using stored_type =
@@ -75,10 +151,8 @@ template <TypeKind KIND, bool usesCustomComparison>
 struct VariantTypeTraits<
     KIND,
     usesCustomComparison,
-    std::enable_if_t<
-        KIND == TypeKind::VARCHAR || KIND == TypeKind::VARBINARY,
-        void>> {
-  using native_type = folly::StringPiece;
+    std::enable_if_t<is_string_kind(KIND), void>> {
+  using native_type = std::string_view;
   using stored_type =
       TypeStorage<scalar_stored_type<KIND>, KIND, usesCustomComparison>;
   using value_type = scalar_stored_type<KIND>;
@@ -132,93 +206,65 @@ struct VariantTypeTraits<TypeKind::OPAQUE, usesCustomComparison> {
 } // namespace detail
 
 class Variant {
- private:
-  Variant(TypeKind kind, void* ptr, bool usesCustomComparison = false)
-      : ptr_{ptr}, kind_{kind}, usesCustomComparison_(usesCustomComparison) {}
-
-  template <TypeKind KIND>
-  bool lessThan(const Variant& other) const;
-
-  template <TypeKind KIND>
-  bool equals(const Variant& other) const;
-
-  template <TypeKind KIND>
-  uint64_t hash() const;
-
-  template <bool usesCustomComparison, TypeKind KIND>
-  void typedDestroy() {
-    delete static_cast<const typename detail::VariantTypeTraits<
-        KIND,
-        usesCustomComparison>::stored_type*>(ptr_);
-    ptr_ = nullptr;
-  }
-
-  template <bool usesCustomComparison, TypeKind KIND>
-  void typedCopy(const void* other) {
-    using stored_type = typename detail::
-        VariantTypeTraits<KIND, usesCustomComparison>::stored_type;
-    ptr_ = new stored_type{*static_cast<const stored_type*>(other)};
-  }
+ public:
+  /// Constructs a NULL variant with type set to UNKNOWN.
+  Variant()
+      : ptr_{nullptr}, kind_{TypeKind::UNKNOWN}, usesCustomComparison_(false) {}
 
-  void dynamicCopy(const void* p, const TypeKind kind) {
-    if (usesCustomComparison_) {
-      VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH_ALL(typedCopy, true, kind, p);
-    } else {
-      VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH_ALL(typedCopy, false, kind, p);
-    }
-  }
+  /* implicit */ Variant(TypeKind kind)
+      : ptr_{nullptr}, kind_{kind}, usesCustomComparison_(false) {}
 
-  void dynamicFree() {
-    if (usesCustomComparison_) {
-      VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH_ALL(typedDestroy, true, kind_);
-    } else {
-      VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH_ALL(typedDestroy, false, kind_);
+  Variant(const Variant& other)
+      : ptr_{nullptr},
+        kind_{other.kind_},
+        usesCustomComparison_(other.usesCustomComparison_) {
+    auto op = other.ptr_;
+    if (op != nullptr) {
+      dynamicCopy(other.ptr_, other.kind_);
     }
   }
 
-  [[noreturn]] void throwCheckIsKindError(TypeKind kind) const;
-
-  [[noreturn]] void throwCheckPtrError() const;
+  /// String construction methods.
+  // Support construction from velox::StringView as well as std::string_view.
+  /* implicit */ Variant(StringView view) : Variant{std::string_view{view}} {}
 
- public:
-  struct Hasher {
-    size_t operator()(Variant const& input) const noexcept {
-      return input.hash();
-    }
-  };
+  // Break ties between implicit conversions to StringView/std::string_view.
+  /* implicit */ Variant(std::string str)
+      : ptr_{new std::string{std::move(str)}},
+        kind_{TypeKind::VARCHAR},
+        usesCustomComparison_(false) {}
 
-  struct NullEqualsNullsComparator {
-    bool operator()(const Variant& a, const Variant& b) const {
-      return a.equalsWithNullEqualsNull(b);
-    }
-  };
+  /* implicit */ Variant(const char* str)
+      : ptr_{new std::string{str}},
+        kind_{TypeKind::VARCHAR},
+        usesCustomComparison_(false) {}
 
-#define VELOX_VARIANT_SCALAR_MEMBERS(KIND)                                \
+#define VELOX_VARIANT_SCALAR_CONSTRUCTOR(KIND)                            \
   /* implicit */ Variant(                                                 \
       typename detail::VariantTypeTraits<KIND, false>::native_type v)     \
       : ptr_{new detail::VariantTypeTraits<KIND, false>::stored_type{v}}, \
         kind_{KIND},                                                      \
         usesCustomComparison_{false} {}
 
-  VELOX_VARIANT_SCALAR_MEMBERS(TypeKind::BOOLEAN)
-  VELOX_VARIANT_SCALAR_MEMBERS(TypeKind::TINYINT)
-  VELOX_VARIANT_SCALAR_MEMBERS(TypeKind::SMALLINT)
-  VELOX_VARIANT_SCALAR_MEMBERS(TypeKind::INTEGER)
-  VELOX_VARIANT_SCALAR_MEMBERS(TypeKind::BIGINT)
-  VELOX_VARIANT_SCALAR_MEMBERS(TypeKind::HUGEINT)
-  VELOX_VARIANT_SCALAR_MEMBERS(TypeKind::REAL)
-  VELOX_VARIANT_SCALAR_MEMBERS(TypeKind::DOUBLE)
+  VELOX_VARIANT_SCALAR_CONSTRUCTOR(TypeKind::BOOLEAN)
+  VELOX_VARIANT_SCALAR_CONSTRUCTOR(TypeKind::TINYINT)
+  VELOX_VARIANT_SCALAR_CONSTRUCTOR(TypeKind::SMALLINT)
+  VELOX_VARIANT_SCALAR_CONSTRUCTOR(TypeKind::INTEGER)
+  VELOX_VARIANT_SCALAR_CONSTRUCTOR(TypeKind::BIGINT)
+  VELOX_VARIANT_SCALAR_CONSTRUCTOR(TypeKind::HUGEINT)
+  VELOX_VARIANT_SCALAR_CONSTRUCTOR(TypeKind::REAL)
+  VELOX_VARIANT_SCALAR_CONSTRUCTOR(TypeKind::DOUBLE)
   // VARBINARY conflicts with VARCHAR, so we don't gen these methods
-  // VELOX_VARIANT_SCALAR_MEMBERS(TypeKind::VARBINARY);
-  VELOX_VARIANT_SCALAR_MEMBERS(TypeKind::TIMESTAMP)
-  VELOX_VARIANT_SCALAR_MEMBERS(TypeKind::UNKNOWN)
-#undef VELOX_VARIANT_SCALAR_MEMBERS
+  // VELOX_VARIANT_SCALAR_CONSTRUCTOR(TypeKind::VARBINARY);
+  VELOX_VARIANT_SCALAR_CONSTRUCTOR(TypeKind::TIMESTAMP)
+  VELOX_VARIANT_SCALAR_CONSTRUCTOR(TypeKind::UNKNOWN)
+#undef VELOX_VARIANT_SCALAR_CONSTRUCTOR
 
   /* implicit */ Variant(
       typename detail::VariantTypeTraits<TypeKind::VARCHAR, false>::native_type
           v)
       : ptr_{new detail::VariantTypeTraits<TypeKind::VARCHAR, false>::
-                 stored_type{v.str()}},
+                 stored_type{std::string(v)}},
         kind_{TypeKind::VARCHAR},
         usesCustomComparison_{false} {}
 
@@ -233,6 +279,189 @@ class Variant {
           bool> = true>
   /* implicit */ Variant(const T& v) : Variant(static_cast<int64_t>(v)) {}
 
+  // Move constructor.
+  Variant(Variant&& other) noexcept
+      : ptr_{other.ptr_},
+        kind_{other.kind_},
+        usesCustomComparison_(other.usesCustomComparison_) {
+    other.ptr_ = nullptr;
+  }
+
+  ~Variant() {
+    if (ptr_ != nullptr) {
+      dynamicFree();
+    }
+  }
+
+  /// Creates a non-null Variant of the specified TypeKind with the provided
+  /// value.
+  ///
+  /// This factory method provides explicit control over the Variant's TypeKind
+  /// and is particularly useful for:
+  ///
+  /// - Creating variants for complex types (ARRAY, MAP, ROW, VARCHAR,
+  ///   VARBINARY) that require std::vector or std::map containers
+  /// - Disambiguating between similar types (e.g., VARCHAR vs VARBINARY)
+  /// - Creating variants when the TypeKind is determined at runtime or from
+  ///   template parameters
+  ///
+  /// @tparam KIND The TypeKind of the variant to create (e.g., TypeKind::ARRAY,
+  ///              TypeKind::VARCHAR, TypeKind::INTEGER)
+  /// @param v The value to store in the variant. The type must match the
+  ///          expected value_type for the given KIND:
+  ///          - Scalar types: Native C++ type (int8_t, int32_t, float, etc.)
+  ///          - VARCHAR/VARBINARY: std::string
+  ///          - ARRAY/ROW: std::vector<Variant>
+  ///          - MAP: std::map<Variant, Variant>
+  ///          - TIMESTAMP: Timestamp
+  ///          - OPAQUE: OpaqueCapsule
+  ///          The parameter is passed by value and moved into the Variant.
+  ///
+  /// @return A new non-null Variant containing the provided value
+  ///
+  /// Example usage:
+  ///   // Create an array variant
+  ///   auto arr = Variant::create<TypeKind::ARRAY>(
+  ///       std::vector<Variant>{Variant(1), Variant(2), Variant(3)});
+  ///
+  ///   // Create a string variant (disambiguating VARCHAR)
+  ///   auto str = Variant::create<TypeKind::VARCHAR>(std::string("hello"));
+  ///
+  ///   // Create a map variant
+  ///   std::map<Variant, Variant> m = {{Variant(1), Variant("one")}};
+  ///   auto mapVar = Variant::create<TypeKind::MAP>(std::move(m));
+  template <TypeKind KIND>
+  static Variant create(
+      typename detail::VariantTypeTraits<KIND, false>::value_type v) {
+    return Variant{
+        KIND,
+        new typename detail::VariantTypeTraits<KIND, false>::stored_type{
+            std::move(v)},
+    };
+  }
+
+  // Explicit specializations for other non-deep copied string types.
+  template <TypeKind KIND>
+  static std::enable_if_t<is_string_kind(KIND), Variant> create(StringView v) {
+    return create<KIND>(std::string(v));
+  }
+
+  template <TypeKind KIND>
+  static std::enable_if_t<is_string_kind(KIND), Variant> create(
+      std::string_view v) {
+    return create<KIND>(std::string(v));
+  }
+
+  template <TypeKind KIND>
+  static std::enable_if_t<is_string_kind(KIND), Variant> create(const char* v) {
+    return create<KIND>(std::string(v));
+  }
+
+  /// Creates a non-null Variant by deducing the TypeKind from the C++ template
+  /// type parameter.
+  ///
+  /// This overload automatically maps C++ types to their corresponding TypeKind
+  /// using CppToType traits. Note that while this function provides a more
+  /// convenient way to map directly from a C++ type to TypeKind, it is not
+  /// guaranteed that every TypeKind will have a direct C++ type mapping. So
+  /// this is mostly useful for test code.
+  ///
+  /// @tparam T The C++ type that determines the TypeKind (e.g., int32_t maps to
+  ///           TypeKind::INTEGER, std::string maps to TypeKind::VARCHAR)
+  /// @param v The value to store in the variant. Must be of type value_type for
+  ///          the deduced TypeKind. The parameter is passed by const reference
+  ///          and copied into the Variant.
+  ///
+  /// @return A new non-null Variant containing the provided value
+  ///
+  /// Example usage:
+  ///   // Deduce TypeKind::INTEGER from int32_t
+  ///   auto intVar = Variant::create<int32_t>(42);
+  ///
+  ///   // Deduce TypeKind::DOUBLE from double
+  ///   auto doubleVar = Variant::create<double>(3.14);
+  ///
+  /// Note: For most scalar types, the implicit Variant constructors are more
+  /// convenient (e.g., Variant(42) instead of Variant::create<int32_t>(42)).
+  /// This method is primarily useful when type deduction from template
+  /// parameters is needed or for consistency with the TypeKind-based overload.
+  template <typename T>
+  static Variant create(
+      const typename detail::VariantTypeTraits<CppToType<T>::typeKind, false>::
+          value_type& v) {
+    return create<CppToType<T>::typeKind>(v);
+  }
+
+  /// Deserializes a Variant from a folly::dynamic object.
+  ///
+  /// This method reconstructs a Variant from its serialized representation,
+  /// serving as the inverse operation of serialize(). It parses a
+  /// folly::dynamic object that contains type metadata and value data, and
+  /// creates the corresponding Variant.
+  ///
+  /// @param obj A folly::dynamic object containing the serialized Variant data.
+  ///            The object must have the following structure:
+  ///            - "type": A string field specifying the TypeKind name (e.g.,
+  ///              "INTEGER", "VARCHAR", "ARRAY", "MAP", "ROW", "TIMESTAMP")
+  ///            - "value": The actual value, whose format depends on the type:
+  ///
+  ///              Scalar types (BOOLEAN, TINYINT, SMALLINT, INTEGER, BIGINT,
+  ///              HUGEINT, REAL, DOUBLE, VARCHAR):
+  ///                The primitive value directly (int, double, string, bool)
+  ///
+  ///              VARBINARY:
+  ///                Base64-encoded string representation of binary data
+  ///
+  ///              ARRAY or ROW:
+  ///                folly::dynamic array where each element is a serialized
+  ///                Variant object (recursive structure)
+  ///
+  ///              MAP:
+  ///                folly::dynamic object with two fields:
+  ///                - "keys": Array of serialized Variant objects
+  ///                - "values": Array of serialized Variant objects
+  ///                Both arrays must have the same length
+  ///
+  ///              TIMESTAMP:
+  ///                folly::dynamic object with two fields:
+  ///                - "seconds": Integer seconds since epoch
+  ///                - "nanos": Integer nanoseconds component
+  ///
+  ///              Null values:
+  ///                null (nullptr in folly::dynamic)
+  ///
+  /// @return A Variant containing the deserialized value
+  ///
+  /// @throws VeloxUserError if the object structure is invalid (e.g., unknown
+  ///         type name, malformed value data, mismatched array sizes for maps)
+  ///
+  /// Example usage:
+  ///   // Deserialize a scalar value
+  ///   folly::dynamic obj = folly::dynamic::object("type", "INTEGER")
+  ///                                               ("value", 42);
+  ///   auto var = Variant::create(obj);
+  ///
+  ///   // Deserialize an array
+  ///   folly::dynamic arrObj = folly::dynamic::object
+  ///     ("type", "ARRAY")
+  ///     ("value", folly::dynamic::array(
+  ///       folly::dynamic::object("type", "INTEGER")("value", 1),
+  ///       folly::dynamic::object("type", "INTEGER")("value", 2)
+  ///     ));
+  ///   auto arrVar = Variant::create(arrObj);
+  ///
+  ///   // Round-trip serialization/deserialization
+  ///   Variant original = Variant::array({Variant(1), Variant(2)});
+  ///   auto serialized = original.serialize();
+  ///   auto deserialized = Variant::create(serialized);
+  ///   // original == deserialized
+  ///
+  /// Note: This method is commonly used for persistence, network transmission,
+  /// or interfacing with JSON-based systems. For creating Variants from native
+  /// C++ values, use the template-based create() methods or constructors
+  /// instead.
+  static Variant create(const folly::dynamic& obj);
+
   static Variant row(const std::vector<Variant>& inputs) {
     return {
         TypeKind::ROW,
@@ -276,10 +505,11 @@ class Variant {
   static Variant typeWithCustomComparison(
       typename TypeTraits<KIND>::NativeType input,
       const TypePtr& type) {
+    using variant_traits = detail::VariantTypeTraits<KIND, true>;
     return {
         KIND,
-        new typename detail::VariantTypeTraits<KIND, true>::stored_type{
-            input,
+        new typename variant_traits::stored_type{
+            typename variant_traits::value_type{std::move(input)},
             std::dynamic_pointer_cast<
                 const CanProvideCustomComparisonType<KIND>>(type)},
         true};
@@ -300,8 +530,6 @@ class Variant {
     return {TypeKind::OPAQUE, new detail::OpaqueCapsule{type, input}};
   }
 
-  static void verifyArrayElements(const std::vector<Variant>& inputs);
-
   static Variant array(const std::vector<Variant>& inputs) {
     verifyArrayElements(inputs);
     return {
@@ -320,68 +548,83 @@ class Variant {
             std::move(inputs)}};
   }
 
-  Variant()
-      : ptr_{nullptr}, kind_{TypeKind::INVALID}, usesCustomComparison_(false) {}
-
-  /* implicit */ Variant(TypeKind kind)
-      : ptr_{nullptr}, kind_{kind}, usesCustomComparison_(false) {}
+  static void verifyArrayElements(const std::vector<Variant>& inputs);
 
-  Variant(const Variant& other)
-      : ptr_{nullptr},
-        kind_{other.kind_},
-        usesCustomComparison_(other.usesCustomComparison_) {
-    auto op = other.ptr_;
-    if (op != nullptr) {
-      dynamicCopy(other.ptr_, other.kind_);
-    }
+  static Variant null(TypeKind kind) {
+    return Variant{kind};
   }
 
-  // Support construction from StringView as well as StringPiece.
-  /* implicit */ Variant(StringView view) : Variant{folly::StringPiece{view}} {}
+  static Variant binary(std::string val) {
+    return Variant{TypeKind::VARBINARY, new std::string{std::move(val)}};
+  }
 
-  // Break ties between implicit conversions to StringView/StringPiece.
-  /* implicit */ Variant(std::string str)
-      : ptr_{new std::string{std::move(str)}},
-        kind_{TypeKind::VARCHAR},
-        usesCustomComparison_(false) {}
+ private:
+  Variant(TypeKind kind, void* ptr, bool usesCustomComparison = false)
+      : ptr_{ptr}, kind_{kind}, usesCustomComparison_(usesCustomComparison) {}
 
-  /* implicit */ Variant(const char* str)
-      : ptr_{new std::string{str}},
-        kind_{TypeKind::VARCHAR},
-        usesCustomComparison_(false) {}
+  template <TypeKind KIND>
+  bool lessThan(const Variant& other) const;
 
   template <TypeKind KIND>
-  static Variant create(
-      typename detail::VariantTypeTraits<KIND, false>::value_type&& v) {
-    return Variant{
-        KIND,
-        new typename detail::VariantTypeTraits<KIND, false>::stored_type{
-            std::move(v)}};
-  }
+  bool equals(const Variant& other) const;
 
   template <TypeKind KIND>
-  static Variant create(
-      const typename detail::VariantTypeTraits<KIND, false>::value_type& v) {
-    return Variant{
+  uint64_t hash() const;
+
+  template <bool usesCustomComparison, TypeKind KIND>
+  void typedDestroy() {
+    delete static_cast<const typename detail::VariantTypeTraits<
         KIND,
-        new typename detail::VariantTypeTraits<KIND, false>::stored_type{v}};
+        usesCustomComparison>::stored_type*>(ptr_);
+    ptr_ = nullptr;
   }
 
-  template <typename T>
-  static Variant create(const typename detail::VariantTypeTraits<
-                        CppToType<T>::typeKind,
-                        false>::value_type& v) {
-    return create<CppToType<T>::typeKind>(v);
+  template <bool usesCustomComparison, TypeKind KIND>
+  void typedCopy(const void* other) {
+    using stored_type = typename detail::
+        VariantTypeTraits<KIND, usesCustomComparison>::stored_type;
+    ptr_ = new stored_type{*static_cast<const stored_type*>(other)};
   }
 
-  static Variant null(TypeKind kind) {
-    return Variant{kind};
+  void dynamicCopy(const void* p, const TypeKind kind) {
+    if (usesCustomComparison_) {
+      VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH_ALL(typedCopy, true, kind, p);
+    } else {
+      VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH_ALL(typedCopy, false, kind, p);
+    }
   }
 
-  static Variant binary(std::string val) {
-    return Variant{TypeKind::VARBINARY, new std::string{std::move(val)}};
+  void dynamicFree() {
+    if (usesCustomComparison_) {
+      VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH_ALL(typedDestroy, true, kind_);
+    } else {
+      VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH_ALL(typedDestroy, false, kind_);
+    }
   }
 
+  [[noreturn]] void throwCheckIsKindError(TypeKind kind) const;
+
+  [[noreturn]] void throwCheckPtrError() const;
+
+ public:
+  // Constant used in comparison of REAL and DOUBLE values.
+  static constexpr double kEpsilon{0.00001};
+
+  struct Hasher {
+    size_t operator()(Variant const& input) const noexcept {
+      return input.hash();
+    }
+  };
+
+  struct NullEqualsNullsComparator {
+    bool operator()(const Variant& a, const Variant& b) const {
+      auto compareResult =
+          a.equals(b, CompareFlags::NullHandlingMode::kNullAsValue);
+      VELOX_CHECK(compareResult.has_value());
+      return compareResult.value();
+    }
+  };
+
   Variant& operator=(const Variant& other) {
     if (ptr_ != nullptr) {
       dynamicFree();
@@ -409,24 +652,29 @@ class Variant {
 
   bool operator<(const Variant& other) const;
 
+  /// Compares two `Variant`s using the provided `nullHandlingMode`.
+  ///
+  /// Returns:
+  ///  - `std::nullopt` when `nullHandlingMode` is `kNullAsIndeterminate` and
+  ///     the comparison is indeterminate.
+  ///  - `true` or `false` when `nullHandlingMode` is `kNullAsValue` and the
+  ///     comparison is determinate.
+  ///
+  /// See `CompareFlags::NullHandlingMode` for the interpretation of the
+  /// null-handling semantics for different types.
+  std::optional<bool> equals(
+      const Variant& other,
+      CompareFlags::NullHandlingMode nullHandlingMode) const;
+
+  /// Shortcut for equals(..., CompareFlags::NullHandlingMode::kNullAsValue).
+  /// Treats two null Variants as equal and returns false for any comparison
+  /// involving a null value and a non-null value.
   bool equals(const Variant& other) const;
 
-  bool equalsWithNullEqualsNull(const Variant& other) const;
-
-  Variant(Variant&& other) noexcept
-      : ptr_{other.ptr_},
-        kind_{other.kind_},
-        usesCustomComparison_(other.usesCustomComparison_) {
-    other.ptr_ = nullptr;
-  }
+  std::string toJson(const TypePtr& type) const;
 
-  ~Variant() {
-    if (ptr_ != nullptr) {
-      dynamicFree();
-    }
-  }
+  std::string toJson(const Type& type) const;
 
-  std::string toJson(const TypePtr& type) const;
   std::string toJsonUnsafe(const TypePtr& type = nullptr) const;
 
   /// Used by python binding, do not change signature.
@@ -443,8 +691,6 @@ class Variant {
 
   folly::dynamic serialize() const;
 
-  static Variant create(const folly::dynamic& obj);
-
   bool hasValue() const {
     return !isNull();
   }
@@ -729,6 +975,7 @@ class Variant {
   // problem
   const void* ptr_;
   TypeKind kind_;
+
   // If the Variant represents the value of a type that provides custom
   // comparisons.
   bool usesCustomComparison_;
diff --git a/velox/type/WideRangeDateConversion.cpp b/velox/type/WideRangeDateConversion.cpp
new file mode 100644
index 00000000000..ade2290c4b1
--- /dev/null
+++ b/velox/type/WideRangeDateConversion.cpp
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/type/WideRangeDateConversion.h"
+
+#include <algorithm>
+#include <limits>
+#include "velox/common/base/VeloxException.h"
+#include "velox/type/TimestampConversion.h"
+
+namespace facebook::velox {
+namespace {
+
+constexpr int kTmYearBase = 1900;
+constexpr int64_t kLeapYearOffset = 4'000'000'000LL;
+constexpr int64_t kSecondsPerHour = 3600;
+constexpr int64_t kSecondsPerDay = 24 * kSecondsPerHour;
+
+inline bool isLeap(int64_t y) {
+  return y % 4 == 0 && (y % 100 != 0 || y % 400 == 0);
+}
+
+inline int64_t leapThroughEndOf(int64_t y) {
+  // Add a large offset so the calculation works for negative years.
+  y += kLeapYearOffset;
+  return y / 4 - y / 100 + y / 400;
+}
+
+inline int64_t daysBetweenYears(int64_t y1, int64_t y2) {
+  return 365 * (y2 - y1) + leapThroughEndOf(y2 - 1) - leapThroughEndOf(y1 - 1);
+}
+
+constexpr int16_t kDaysBeforeFirstDayOfMonth[][12] = {
+    {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334},
+    {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335},
+};
+
+constexpr int32_t kCumulativeDays[] =
+    {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365};
+constexpr int32_t kCumulativeLeapDays[] =
+    {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366};
+
+// Days from 1970-01-01 to the start of each year in [1970, 2370].
+// The inverse path uses this table for years inside the era and
+// 400-year-step loops for years outside it.
+constexpr int32_t kCumulativeYearDays[] = {
+    0,      365,    730,    1096,   1461,   1826,   2191,   2557,   2922,
+    3287,   3652,   4018,   4383,   4748,   5113,   5479,   5844,   6209,
+    6574,   6940,   7305,   7670,   8035,   8401,   8766,   9131,   9496,
+    9862,   10227,  10592,  10957,  11323,  11688,  12053,  12418,  12784,
+    13149,  13514,  13879,  14245,  14610,  14975,  15340,  15706,  16071,
+    16436,  16801,  17167,  17532,  17897,  18262,  18628,  18993,  19358,
+    19723,  20089,  20454,  20819,  21184,  21550,  21915,  22280,  22645,
+    23011,  23376,  23741,  24106,  24472,  24837,  25202,  25567,  25933,
+    26298,  26663,  27028,  27394,  27759,  28124,  28489,  28855,  29220,
+    29585,  29950,  30316,  30681,  31046,  31411,  31777,  32142,  32507,
+    32872,  33238,  33603,  33968,  34333,  34699,  35064,  35429,  35794,
+    36160,  36525,  36890,  37255,  37621,  37986,  38351,  38716,  39082,
+    39447,  39812,  40177,  40543,  40908,  41273,  41638,  42004,  42369,
+    42734,  43099,  43465,  43830,  44195,  44560,  44926,  45291,  45656,
+    46021,  46387,  46752,  47117,  47482,  47847,  48212,  48577,  48942,
+    49308,  49673,  50038,  50403,  50769,  51134,  51499,  51864,  52230,
+    52595,  52960,  53325,  53691,  54056,  54421,  54786,  55152,  55517,
+    55882,  56247,  56613,  56978,  57343,  57708,  58074,  58439,  58804,
+    59169,  59535,  59900,  60265,  60630,  60996,  61361,  61726,  62091,
+    62457,  62822,  63187,  63552,  63918,  64283,  64648,  65013,  65379,
+    65744,  66109,  66474,  66840,  67205,  67570,  67935,  68301,  68666,
+    69031,  69396,  69762,  70127,  70492,  70857,  71223,  71588,  71953,
+    72318,  72684,  73049,  73414,  73779,  74145,  74510,  74875,  75240,
+    75606,  75971,  76336,  76701,  77067,  77432,  77797,  78162,  78528,
+    78893,  79258,  79623,  79989,  80354,  80719,  81084,  81450,  81815,
+    82180,  82545,  82911,  83276,  83641,  84006,  84371,  84736,  85101,
+    85466,  85832,  86197,  86562,  86927,  87293,  87658,  88023,  88388,
+    88754,  89119,  89484,  89849,  90215,  90580,  90945,  91310,  91676,
+    92041,  92406,  92771,  93137,  93502,  93867,  94232,  94598,  94963,
+    95328,  95693,  96059,  96424,  96789,  97154,  97520,  97885,  98250,
+    98615,  98981,  99346,  99711,  100076, 100442, 100807, 101172, 101537,
+    101903, 102268, 102633, 102998, 103364, 103729, 104094, 104459, 104825,
+    105190, 105555, 105920, 106286, 106651, 107016, 107381, 107747, 108112,
+    108477, 108842, 109208, 109573, 109938, 110303, 110669, 111034, 111399,
+    111764, 112130, 112495, 112860, 113225, 113591, 113956, 114321, 114686,
+    115052, 115417, 115782, 116147, 116513, 116878, 117243, 117608, 117974,
+    118339, 118704, 119069, 119435, 119800, 120165, 120530, 120895, 121260,
+    121625, 121990, 122356, 122721, 123086, 123451, 123817, 124182, 124547,
+    124912, 125278, 125643, 126008, 126373, 126739, 127104, 127469, 127834,
+    128200, 128565, 128930, 129295, 129661, 130026, 130391, 130756, 131122,
+    131487, 131852, 132217, 132583, 132948, 133313, 133678, 134044, 134409,
+    134774, 135139, 135505, 135870, 136235, 136600, 136966, 137331, 137696,
+    138061, 138427, 138792, 139157, 139522, 139888, 140253, 140618, 140983,
+    141349, 141714, 142079, 142444, 142810, 143175, 143540, 143905, 144271,
+    144636, 145001, 145366, 145732, 146097,
+};
+
+} // namespace
+
+bool WideRangeDateConversion::epochToCalendarUtc(int64_t epoch, std::tm& tm) {
+  constexpr int kDaysPerYear = 365;
+  int64_t days = epoch / kSecondsPerDay;
+  int64_t rem = epoch % kSecondsPerDay;
+  if (rem < 0) {
+    rem += kSecondsPerDay;
+    --days;
+  }
+  tm.tm_hour = rem / kSecondsPerHour;
+  rem = rem % kSecondsPerHour;
+  tm.tm_min = rem / 60;
+  tm.tm_sec = rem % 60;
+  tm.tm_wday = (4 + days) % 7;
+  if (tm.tm_wday < 0) {
+    tm.tm_wday += 7;
+  }
+  int64_t y = 1970;
+  if (y + days / kDaysPerYear <= -kLeapYearOffset + 10) {
+    return false;
+  }
+  bool leapYear;
+  while (days < 0 || days >= kDaysPerYear + (leapYear = isLeap(y))) {
+    auto newy = y + days / kDaysPerYear - (days < 0);
+    days -= daysBetweenYears(y, newy);
+    y = newy;
+  }
+  y -= kTmYearBase;
+  if (y > std::numeric_limits<decltype(tm.tm_year)>::max() ||
+      y < std::numeric_limits<decltype(tm.tm_year)>::min()) {
+    return false;
+  }
+  tm.tm_year = y;
+  tm.tm_yday = days;
+  const auto* months = kDaysBeforeFirstDayOfMonth[leapYear];
+  tm.tm_mon = std::upper_bound(months, months + 12, days) - months - 1;
+  tm.tm_mday = days - months[tm.tm_mon] + 1;
+  tm.tm_isdst = 0;
+  return true;
+}
+
+Expected<int64_t> WideRangeDateConversion::daysSinceEpochFromDate(
+    int32_t year,
+    int32_t month,
+    int32_t day) {
+  if (!util::isValidDate(year, month, day)) {
+    if (threadSkipErrorDetails()) {
+      return folly::makeUnexpected(Status::UserError());
+    }
+    return folly::makeUnexpected(
+        Status::UserError("Date out of range: {}-{}-{}", year, month, day));
+  }
+  int64_t daysSinceEpoch = 0;
+  while (year < 1970) {
+    year += util::kYearInterval;
+    daysSinceEpoch -= util::kDaysPerYearInterval;
+  }
+  while (year >= 2370) {
+    year -= util::kYearInterval;
+    daysSinceEpoch += util::kDaysPerYearInterval;
+  }
+  daysSinceEpoch += kCumulativeYearDays[year - 1970];
+  daysSinceEpoch += util::isLeapYear(year) ? kCumulativeLeapDays[month - 1]
+                                           : kCumulativeDays[month - 1];
+  daysSinceEpoch += day - 1;
+  return daysSinceEpoch;
+}
+
+} // namespace facebook::velox
diff --git a/velox/type/WideRangeDateConversion.h b/velox/type/WideRangeDateConversion.h
new file mode 100644
index 00000000000..301a8e82671
--- /dev/null
+++ b/velox/type/WideRangeDateConversion.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cstdint>
+#include <ctime>
+#include "velox/common/base/Status.h"
+
+namespace facebook::velox {
+
+/// Loop-based date conversion that handles the full validation range
+/// [kMinYear, kMaxYear]. Slower than the Neri-Schneider fast path in
+/// FastDate.h, but covers inputs outside that fast path's exact domain
+/// (~3M years centered on the epoch). Used as the fallback inside
+/// Timestamp::epochToCalendarUtc and util::daysSinceEpochFromDate.
+///
+/// Exposed as a real production class (not a test-only helper) so the
+/// fast/fallback equivalence can be asserted directly from tests, and so
+/// the benchmark file can compare without duplicating the loop body.
+class WideRangeDateConversion {
+ public:
+  /// Converts seconds-since-epoch to a calendar-UTC std::tm using the
+  /// loop-based path. Returns false if the result year does not fit in
+  /// std::tm::tm_year or the input is otherwise unrepresentable.
+  static bool epochToCalendarUtc(int64_t epoch, std::tm& tm);
+
+  /// Converts a (year, month, day) triple to days-since-epoch using the
+  /// loop-based path. Validates the input against [kMinYear, kMaxYear];
+  /// returns Status::UserError ("Date out of range: ...") on invalid
+  /// input.
+  static Expected<int64_t>
+  daysSinceEpochFromDate(int32_t year, int32_t month, int32_t day);
+};
+
+} // namespace facebook::velox
diff --git a/velox/type/fbhive/CMakeLists.txt b/velox/type/fbhive/CMakeLists.txt
index c6e7aa62319..ed71509a4aa 100644
--- a/velox/type/fbhive/CMakeLists.txt
+++ b/velox/type/fbhive/CMakeLists.txt
@@ -12,7 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_type_fbhive HiveTypeParser.cpp HiveTypeSerializer.cpp)
+velox_add_library(
+  velox_type_fbhive
+  HiveTypeParser.cpp
+  HiveTypeSerializer.cpp
+  HEADERS
+  HiveTypeParser.h
+  HiveTypeSerializer.h
+)
 
 velox_link_libraries(velox_type_fbhive velox_type)
 
diff --git a/velox/type/fbhive/HiveTypeParser.cpp b/velox/type/fbhive/HiveTypeParser.cpp
index 910b1b8e986..66e4ee305a9 100644
--- a/velox/type/fbhive/HiveTypeParser.cpp
+++ b/velox/type/fbhive/HiveTypeParser.cpp
@@ -23,10 +23,10 @@
 #include "velox/common/base/Exceptions.h"
 
 namespace facebook::velox::type::fbhive {
-
 namespace {
+
 /// Returns true only if 'str' contains digits.
-bool isPositiveInteger(const std::string& str) {
+bool isPositiveInteger(std::string_view str) {
   return !str.empty() &&
       std::find_if(str.begin(), str.end(), [](unsigned char c) {
         return !std::isdigit(c);
@@ -37,6 +37,17 @@ bool isSupportedSpecialChar(char c) {
   static std::unordered_set<char> supported{'_', '$', '#'};
   return supported.count(c) == 1;
 }
+
+/// Returns whether `prefix` is non-empty case-insensitive prefix of `input`.
+bool isPrefix(std::string_view input, std::string_view prefix) {
+  return prefix.size() > 0 && input.size() >= prefix.size() &&
+      std::equal(
+             prefix.begin(),
+             prefix.end(),
+             input.begin(),
+             folly::AsciiCaseInsensitive{});
+}
+
 } // namespace
 
 HiveTypeParser::HiveTypeParser() {
@@ -47,6 +58,8 @@ HiveTypeParser::HiveTypeParser() {
   setupMetadata<TokenType::Integer, TypeKind::INTEGER>({"integer", "int"});
   setupMetadata<TokenType::Long, TypeKind::BIGINT>("bigint");
   setupMetadata<TokenType::Date, TypeKind::INTEGER>("date");
+  setupMetadata<TokenType::Time, TypeKind::BIGINT>("time");
+  setupMetadata<TokenType::TimeMicroUtc, TypeKind::BIGINT>("time_micro_utc");
   setupMetadata<TokenType::Float, TypeKind::REAL>({"float", "real"});
   setupMetadata<TokenType::Double, TypeKind::DOUBLE>("double");
   setupMetadata<TokenType::Decimal, TypeKind::BIGINT>("decimal");
@@ -69,15 +82,15 @@ HiveTypeParser::HiveTypeParser() {
   setupMetadata<TokenType::EndOfStream, TypeKind::INVALID>();
 }
 
-TypePtr HiveTypeParser::parse(const std::string& ser) {
-  remaining_ = folly::StringPiece(ser);
+TypePtr HiveTypeParser::parse(std::string_view input) {
+  remaining_ = input;
   Result result = parseType();
   VELOX_CHECK(
       remaining_.size() == 0 || TokenType::EndOfStream == lookAhead(),
       "Input remaining after parsing the Hive type \"{}\"\n"
       "Remaining: \"{}\"",
-      ser,
-      remaining_.toString());
+      input,
+      remaining_);
   return result.type;
 }
 
@@ -88,8 +101,8 @@ Result HiveTypeParser::parseType() {
   if (!nt.isValidType()) {
     VELOX_FAIL(
         "Unexpected token {} at {}. typeKind = {}",
-        nt.value.toString(),
-        remaining_.toString(),
+        nt.value,
+        remaining_,
         nt.typeKind());
   }
 
@@ -98,18 +111,22 @@ Result HiveTypeParser::parseType() {
       eatToken(TokenType::LeftRoundBracket);
       Token precision = nextToken();
       VELOX_CHECK(
-          isPositiveInteger(precision.value.toString()),
+          isPositiveInteger(precision.value),
           "Decimal precision must be a positive integer");
       eatToken(TokenType::Comma);
       Token scale = nextToken();
       VELOX_CHECK(
-          isPositiveInteger(scale.value.toString()),
+          isPositiveInteger(scale.value),
           "Decimal scale must be a positive integer");
       eatToken(TokenType::RightRoundBracket);
       return Result{DECIMAL(
           std::atoi(precision.value.data()), std::atoi(scale.value.data()))};
     } else if (nt.metadata->tokenString[0] == "date") {
       return Result{DATE()};
+    } else if (nt.metadata->tokenString[0] == "time") {
+      return Result{TIME()};
+    } else if (nt.metadata->tokenString[0] == "time_micro_utc") {
+      return Result{TIME_MICRO_UTC()};
     }
     auto scalarType = createScalarType(nt.typeKind());
     VELOX_CHECK_NOT_NULL(
@@ -119,18 +136,26 @@ Result HiveTypeParser::parseType() {
       eatToken(TokenType::LeftRoundBracket);
       Token length = nextToken();
       VELOX_CHECK(
-          isPositiveInteger(length.value.toString()),
+          isPositiveInteger(length.value),
           "Varchar length must be a positive integer");
       eatToken(TokenType::RightRoundBracket);
     }
     return Result{scalarType};
   } else if (nt.isOpaqueType()) {
     eatToken(TokenType::StartSubType);
-    folly::StringPiece innerTypeName =
+    std::string_view innerTypeName =
         eatToken(TokenType::Identifier, true).value;
     eatToken(TokenType::EndSubType);
 
-    auto typeIndex = getTypeIdForOpaqueTypeAlias(innerTypeName.str());
+    // TODO: `getTypeIdForOpaqueTypeAlias()` should take a std::string_view so
+    // we don't need to needlessly construct a std::string.
+    std::string aliasName(innerTypeName);
+    // If the alias is registered as a custom type (via
+    // OpaqueCustomTypeRegister), return it to respect the singleton semantics.
+    if (auto customType = getCustomType(aliasName, /*parameters=*/{})) {
+      return Result{customType};
+    }
+    auto typeIndex = getTypeIdForOpaqueTypeAlias(aliasName);
     auto instance = std::make_shared<const OpaqueType>(typeIndex);
     return Result{instance};
   } else {
@@ -155,7 +180,8 @@ Result HiveTypeParser::parseType() {
         return Result{velox::ARRAY(resultList.typelist.at(0))};
       }
       default:
-        VELOX_FAIL("unsupported kind: " + mapTypeKindToName(nt.typeKind()));
+        VELOX_FAIL(
+            "Unsupported kind: '{}'", TypeKindName::toName(nt.typeKind()));
     }
   }
 }
@@ -163,6 +189,7 @@ Result HiveTypeParser::parseType() {
 ResultList HiveTypeParser::parseTypeList(bool hasFieldNames) {
   std::vector<TypePtr> subTypeList{};
   std::vector<std::string> names{};
+
   eatToken(TokenType::StartSubType);
   while (true) {
     if (TokenType::EndSubType == lookAhead()) {
@@ -170,11 +197,11 @@ ResultList HiveTypeParser::parseTypeList(bool hasFieldNames) {
       return ResultList{std::move(subTypeList), std::move(names)};
     }
 
-    folly::StringPiece fieldName;
+    std::string_view fieldName;
     if (hasFieldNames) {
       fieldName = eatToken(TokenType::Identifier, true).value;
       eatToken(TokenType::Colon);
-      names.push_back(fieldName.toString());
+      names.emplace_back(fieldName);
     }
 
     Result result = parseType();
@@ -196,7 +223,7 @@ Token HiveTypeParser::eatToken(TokenType tokenType, bool ignorePredefined) {
     return token;
   }
 
-  VELOX_FAIL("Unexpected token " + token.remaining.toString());
+  VELOX_FAIL("Unexpected token '{}'", token.remaining);
 }
 
 Token HiveTypeParser::nextToken(bool ignorePredefined) {
@@ -206,29 +233,28 @@ Token HiveTypeParser::nextToken(bool ignorePredefined) {
 }
 
 TokenAndRemaining HiveTypeParser::nextToken(
-    folly::StringPiece sp,
+    std::string_view sv,
     bool ignorePredefined) const {
-  while (!sp.empty() && isspace(sp.front())) {
-    sp.advance(1);
+  while (!sv.empty() && isspace(sv.front())) {
+    sv.remove_prefix(1);
   }
 
-  if (sp.empty()) {
-    return makeExtendedToken(getMetadata(TokenType::EndOfStream), sp, 0);
+  if (sv.empty()) {
+    return makeExtendedToken(getMetadata(TokenType::EndOfStream), sv, 0);
   }
 
   if (!ignorePredefined) {
     for (auto& metadata : metadata_) {
       for (auto& token : metadata->tokenString) {
-        folly::StringPiece match(token);
-        if (match.size() > 0 &&
-            sp.startsWith(match, folly::AsciiCaseInsensitive{})) {
-          return makeExtendedToken(metadata.get(), sp, match.size());
+        std::string_view match(token);
+        if (isPrefix(sv, match)) {
+          return makeExtendedToken(metadata.get(), sv, match.size());
         }
       }
     }
   }
 
-  auto iter = sp.cbegin();
+  auto iter = sv.cbegin();
   size_t len = 0;
   while (isalnum(*iter) || isSupportedSpecialChar(*iter)) {
     ++len;
@@ -236,10 +262,10 @@ TokenAndRemaining HiveTypeParser::nextToken(
   }
 
   if (len > 0) {
-    return makeExtendedToken(getMetadata(TokenType::Identifier), sp, len);
+    return makeExtendedToken(getMetadata(TokenType::Identifier), sv, len);
   }
 
-  VELOX_FAIL("Bad Token at " + sp.toString());
+  VELOX_FAIL("Bad Token at '{}'", sv);
 }
 
 TokenType Token::tokenType() const {
@@ -272,15 +298,15 @@ int8_t HiveTypeParser::makeTokenId(TokenType tokenType) const {
 
 TokenAndRemaining HiveTypeParser::makeExtendedToken(
     TokenMetadata* tokenMetadata,
-    folly::StringPiece sp,
+    std::string_view sv,
     size_t len) const {
-  folly::StringPiece spmatch(sp.cbegin(), sp.cbegin() + len);
-  sp.advance(len);
+  std::string_view spmatch{sv.data(), len};
+  sv.remove_prefix(len);
 
   TokenAndRemaining result;
   result.metadata = tokenMetadata;
   result.value = spmatch;
-  result.remaining = sp;
+  result.remaining = sv;
   return result;
 }
 
diff --git a/velox/type/fbhive/HiveTypeParser.h b/velox/type/fbhive/HiveTypeParser.h
index afb99c488ce..1fc6b40a666 100644
--- a/velox/type/fbhive/HiveTypeParser.h
+++ b/velox/type/fbhive/HiveTypeParser.h
@@ -22,7 +22,6 @@
 #include <string>
 #include <vector>
 
-#include <folly/Range.h>
 #include "velox/type/Type.h"
 
 namespace facebook::velox::type::fbhive {
@@ -53,6 +52,11 @@ enum class TokenType {
   Identifier,
   EndOfStream,
   Decimal,
+  // TimeMicroUtc must precede Time so the longer keyword is matched first
+  // by the prefix-iteration tokenizer (the same trick used for Timestamp
+  // vs Time).
+  TimeMicroUtc,
+  Time,
   LeftRoundBracket,
   RightRoundBracket,
   MaxTokenType
@@ -77,7 +81,7 @@ struct TokenMetadata {
 
 struct Token {
   TokenMetadata* metadata;
-  folly::StringPiece value;
+  std::string_view value;
 
   TokenType tokenType() const;
 
@@ -93,7 +97,7 @@ struct Token {
 };
 
 struct TokenAndRemaining : public Token {
-  folly::StringPiece remaining;
+  std::string_view remaining;
 };
 
 struct Result {
@@ -109,7 +113,7 @@ class HiveTypeParser {
  public:
   HiveTypeParser();
 
-  TypePtr parse(const std::string& ser);
+  TypePtr parse(std::string_view input);
 
  private:
   int8_t makeTokenId(TokenType tokenType) const;
@@ -125,12 +129,12 @@ class HiveTypeParser {
   Token nextToken(bool ignorePredefined = false);
 
   TokenAndRemaining nextToken(
-      folly::StringPiece sp,
+      std::string_view sv,
       bool ignorePredefined = false) const;
 
   TokenAndRemaining makeExtendedToken(
       TokenMetadata* tokenMetadata,
-      folly::StringPiece sp,
+      std::string_view sv,
       size_t len) const;
 
   template <TokenType KIND, velox::TypeKind TYPEKIND>
@@ -149,7 +153,7 @@ class HiveTypeParser {
   TokenMetadata* getMetadata(TokenType type) const;
 
   std::vector<std::unique_ptr<TokenMetadata>> metadata_;
-  folly::StringPiece remaining_;
+  std::string_view remaining_;
 };
 
 } // namespace facebook::velox::type::fbhive
diff --git a/velox/type/fbhive/HiveTypeSerializer.cpp b/velox/type/fbhive/HiveTypeSerializer.cpp
index 6d2dce82053..5a2c3e37471 100644
--- a/velox/type/fbhive/HiveTypeSerializer.cpp
+++ b/velox/type/fbhive/HiveTypeSerializer.cpp
@@ -58,7 +58,7 @@ std::string HiveTypeSerializer::visit(const Type& type) const {
       return "opaque<" + typeAlias + ">";
     }
     default:
-      VELOX_UNSUPPORTED("unsupported type: " + type.toString());
+      VELOX_UNSUPPORTED("Unsupported type: {}", type.toString());
   }
 }
 
diff --git a/velox/type/fbhive/tests/HiveTypeParserTests.cpp b/velox/type/fbhive/tests/HiveTypeParserTests.cpp
index c35e8bffaca..46f75016bac 100644
--- a/velox/type/fbhive/tests/HiveTypeParserTests.cpp
+++ b/velox/type/fbhive/tests/HiveTypeParserTests.cpp
@@ -21,6 +21,7 @@
 #include "gtest/gtest-test-part.h"
 #include "gtest/gtest.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/type/OpaqueCustomTypes.h"
 #include "velox/type/fbhive/HiveTypeParser.h"
 
 using facebook::velox::TypeKind;
@@ -128,7 +129,7 @@ TEST(FbHive, badParse) {
       "Unexpected token uniontype at < bigint , int, float");
   VELOX_ASSERT_THROW(parser.parse("badid"), "Unexpected token badid at ");
   VELOX_ASSERT_THROW(
-      parser.parse("struct<int, bigint>"), "Unexpected token  bigint>");
+      parser.parse("struct<int, bigint>"), "Unexpected token ' bigint>'");
   VELOX_ASSERT_THROW(parser.parse("list<>"), "Unexpected token list at <>");
   VELOX_ASSERT_THROW(
       parser.parse("map<>"), "wrong param count for map type def");
@@ -140,7 +141,7 @@ TEST(FbHive, badParse) {
   VELOX_ASSERT_THROW(
       parser.parse("map<int>"), "wrong param count for map type def");
   VELOX_ASSERT_THROW(
-      parser.parse("decimal<20, 10>"), "Unexpected token 20, 10>");
+      parser.parse("decimal<20, 10>"), "Unexpected token '20, 10>'");
   VELOX_ASSERT_THROW(parser.parse("decimal(20, 10>"), "Unexpected token ");
   VELOX_ASSERT_THROW(
       parser.parse("decimal(a, 10)"),
@@ -183,6 +184,8 @@ TEST(FbHive, parseOpaque) {
   HiveTypeParser parser;
   auto t = parser.parse("opaque<bar>");
   ASSERT_EQ(t->toString(), "OPAQUE<facebook::velox::type::fbhive::Foo>");
+  EXPECT_EQ(t->kind(), TypeKind::OPAQUE);
+  EXPECT_FALSE(customTypeExists("bar"));
   unregisterOpaqueType<Foo>("bar");
 }
 
@@ -195,4 +198,19 @@ TEST(FbHive, parseUnregisteredOpaque) {
       "Could not find type 'Foo'. Did you call registerOpaqueType?");
   unregisterOpaqueType<Foo>("bar");
 }
+
+struct CustomFoo {};
+constexpr char kCustomFooName[] = "CustomFoo";
+using CustomFooRegistrar = OpaqueCustomTypeRegister<CustomFoo, kCustomFooName>;
+
+TEST(FbHive, parseOpaqueCustomTypeReturnsSingleton) {
+  CustomFooRegistrar::registerType();
+  HiveTypeParser parser;
+  auto parsed = parser.parse("opaque<CustomFoo>");
+  // The parser must return the registered custom-type singleton so that
+  // pointer equality with the type produced by CustomType<TypeT> in UDF
+  // signatures holds.
+  EXPECT_EQ(parsed.get(), CustomFooRegistrar::singletonTypePtr().get());
+  CustomFooRegistrar::unregisterType();
+}
 } // namespace facebook::velox::type::fbhive
diff --git a/velox/type/fbhive/tests/HiveTypeSerializerTests.cpp b/velox/type/fbhive/tests/HiveTypeSerializerTests.cpp
index b8975cc745b..d4f91cdb815 100644
--- a/velox/type/fbhive/tests/HiveTypeSerializerTests.cpp
+++ b/velox/type/fbhive/tests/HiveTypeSerializerTests.cpp
@@ -57,6 +57,6 @@ TEST(HiveTypeSerializer, unregisteredOpaque) {
 TEST(HiveTypeSerializer, unsupported) {
   std::shared_ptr<const Type> type = UNKNOWN();
   VELOX_ASSERT_THROW(
-      HiveTypeSerializer::serialize(type), "unsupported type: UNKNOWN");
+      HiveTypeSerializer::serialize(type), "Unsupported type: UNKNOWN");
 }
 } // namespace facebook::velox::type::fbhive
diff --git a/velox/type/parser/CMakeLists.txt b/velox/type/parser/CMakeLists.txt
deleted file mode 100644
index e6f46ebc461..00000000000
--- a/velox/type/parser/CMakeLists.txt
+++ /dev/null
@@ -1,50 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-if(${VELOX_BUILD_TESTING})
-  add_subdirectory(tests)
-endif()
-
-bison_target(
-  TypeParser
-  TypeParser.yy
-  ${CMAKE_CURRENT_BINARY_DIR}/TypeParser.yy.cc
-  DEFINES_FILE ${CMAKE_CURRENT_BINARY_DIR}/TypeParser.yy.h
-  COMPILE_FLAGS "-Werror -Wno-deprecated"
-)
-
-flex_target(
-  TypeParserScanner
-  TypeParser.ll
-  ${CMAKE_CURRENT_BINARY_DIR}/Scanner.cpp
-  COMPILE_FLAGS "-Cf --prefix=veloxtpdeprecated"
-)
-
-add_flex_bison_dependency(TypeParserScanner TypeParser)
-
-if(VELOX_MONO_LIBRARY)
-  add_custom_target(
-    velox_type_parser_gen_src
-    DEPENDS ${BISON_TypeParser_OUTPUTS} ${FLEX_TypeParserScanner_OUTPUTS}
-  )
-  add_dependencies(velox velox_type_parser_gen_src)
-endif()
-velox_add_library(
-  velox_type_parser
-  ${BISON_TypeParser_OUTPUTS}
-  ${FLEX_TypeParserScanner_OUTPUTS}
-  ParserUtil.cpp
-)
-velox_include_directories(velox_type_parser PRIVATE ${PROJECT_BINARY_DIR} ${FLEX_INCLUDE_DIRS})
-velox_link_libraries(velox_type_parser velox_common_base)
diff --git a/velox/type/parser/ParserUtil.cpp b/velox/type/parser/ParserUtil.cpp
deleted file mode 100644
index 0412991e4c2..00000000000
--- a/velox/type/parser/ParserUtil.cpp
+++ /dev/null
@@ -1,198 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <boost/algorithm/string.hpp>
-#include <string>
-#include "velox/type/Type.h"
-
-namespace facebook::velox {
-
-TypePtr typeFromString(
-    const std::string& type,
-    bool failIfNotRegistered = true) {
-  auto upper = type;
-  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
-  if (upper == "INT") {
-    upper = "INTEGER";
-  } else if (upper == "DOUBLE PRECISION") {
-    upper = "DOUBLE";
-  }
-  auto inferredType = getType(upper, {});
-  if (failIfNotRegistered == true && inferredType == nullptr) {
-    VELOX_UNSUPPORTED("Failed to parse type [{}]. Type not registered.", type);
-  }
-  return inferredType;
-}
-
-TypePtr customTypeWithChildren(
-    const std::string& name,
-    const std::vector<TypePtr>& children) {
-  std::vector<TypeParameter> params;
-  params.reserve(children.size());
-  for (auto& child : children) {
-    params.emplace_back(child);
-  }
-  auto type = getType(name, params);
-  VELOX_CHECK_NOT_NULL(
-      type, "Failed to parse custom type with children [{}]", name);
-  return type;
-}
-
-std::pair<std::string, std::shared_ptr<const Type>> inferTypeWithSpaces(
-    std::vector<std::string>& words,
-    bool cannotHaveFieldName = false) {
-  VELOX_CHECK_GE(words.size(), 2);
-  const auto& fieldName = words[0];
-  const auto allWords = folly::join(" ", words);
-  // Fail if cannotHaveFieldName = true.
-  auto type = typeFromString(allWords, cannotHaveFieldName);
-  if (type) {
-    return std::make_pair("", type);
-  }
-  return std::make_pair(
-      fieldName, typeFromString(allWords.substr(fieldName.size() + 1)));
-}
-
-namespace {
-std::array<int, 256> base32CharMap() {
-  std::array<int, 256> map{};
-  map.fill(-1);
-  const std::string base32Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
-
-  for (size_t i = 0; i < base32Chars.size(); ++i) {
-    char upper = base32Chars[i];
-    char lower = std::tolower(upper);
-    map[static_cast<unsigned char>(upper)] = static_cast<int>(i);
-    map[static_cast<unsigned char>(lower)] = static_cast<int>(i);
-  }
-  return map;
-}
-
-static const std::array<int, 256> base32Map = base32CharMap();
-
-std::string base32Decode(const std::string& encoded) {
-  std::vector<uint8_t> decodedBytes;
-  int buffer = 0;
-  int bitsLeft = 0;
-
-  for (char c : encoded) {
-    // Skip padding and whitespace.
-    if (c == '=' || std::isspace(static_cast<unsigned char>(c))) {
-      continue;
-    }
-
-    int val = base32Map[static_cast<unsigned char>(c)];
-    VELOX_CHECK_NE(
-        val,
-        -1,
-        "Failed to parse value {}, invalid Base32 character: {}",
-        encoded,
-        c);
-
-    buffer = (buffer << 5) | val;
-    bitsLeft += 5;
-    if (bitsLeft >= 8) {
-      bitsLeft -= 8;
-      decodedBytes.push_back((buffer >> bitsLeft) & 0xFF);
-    }
-  }
-  std::string decoded(decodedBytes.begin(), decodedBytes.end());
-
-  return decoded;
-}
-
-// The values map of the enum type is passed into this function in the format:
-// "[["CURIOUS",-2], ["HAPPY",0]]" as an array of key-value pairs (as opposed
-// to a JSON map like "{"CURIOUS":-2, "HAPPY":0}") so that the function can
-// fail on duplicate keys and values. folly::parseJson on a JSON map will
-// silently drop duplicate elements.
-template <typename T>
-std::unordered_map<std::string, T> parseMapFromString(
-    const std::string& input) {
-  folly::dynamic obj = folly::parseJson(input);
-  VELOX_CHECK(
-      obj.isArray(),
-      "Expected an array of key-value pairs for input: {}",
-      input);
-  std::unordered_map<std::string, T> result;
-  std::unordered_set<T> seenValues;
-
-  for (const auto& pair : obj) {
-    VELOX_CHECK(
-        pair.isArray() && pair.size() == 2 && pair[0].isString(),
-        "Failed to parse map: {}, each element must be have a string key.",
-        input);
-    std::string key = boost::algorithm::to_upper_copy(pair[0].asString());
-    VELOX_CHECK(
-        !result.contains(key),
-        "Failed to parse map: {}, duplicate key found: {}",
-        input,
-        key);
-    T value;
-    if constexpr (std::is_same_v<T, int64_t>) {
-      VELOX_CHECK(
-          pair[1].isInt(),
-          "Failed to parse map: {}, each element must have an integer value.",
-          input);
-      value = pair[1].asInt();
-    } else if constexpr (std::is_same_v<T, std::string>) {
-      VELOX_CHECK(
-          pair[1].isString(),
-          "Failed to parse map: {}, each element must have a string value.",
-          input);
-      // For a VarcharEnum map where the values are strings, the values from the
-      // Presto coordinator are received as base32-encoded strings to match the
-      // standard Presto TypeSignature format.
-      // Hence decode the value before creating a VarcharEnumParameter.
-      // https://github.com/prestodb/presto/blob/master/presto-common/src/main/java/com/facebook/presto/common/type/VarcharEnumType.java#L128
-      value = base32Decode(pair[1].asString());
-    } else {
-      VELOX_UNSUPPORTED(
-          "parseMapFromString is only supported for int64_t and std::string values.");
-    }
-    VELOX_CHECK(
-        seenValues.insert(value).second,
-        "Failed to parse map: {}, duplicate value found: {}",
-        input,
-        value);
-
-    result[key] = value;
-  }
-  return result;
-}
-} // namespace
-
-TypePtr getEnumType(
-    const std::string& enumType,
-    const std::string& enumName,
-    const std::string& valuesMap) {
-  std::vector<TypeParameter> params;
-  if (enumType == "BigintEnum") {
-    LongEnumParameter longEnumParameter(
-        enumName, parseMapFromString<int64_t>(valuesMap));
-    params.emplace_back(TypeParameter(longEnumParameter));
-    return getType("BIGINT_ENUM", params);
-  } else if (enumType == "VarcharEnum") {
-    VarcharEnumParameter varcharEnumParameter(
-        enumName, parseMapFromString<std::string>(valuesMap));
-    params.emplace_back(TypeParameter(varcharEnumParameter));
-    return getType("VARCHAR_ENUM", params);
-  }
-
-  VELOX_UNREACHABLE(
-      "Invalid type {}, expected BigintEnum or VarcharEnum", enumType);
-}
-} // namespace facebook::velox
diff --git a/velox/type/parser/ParserUtil.h b/velox/type/parser/ParserUtil.h
deleted file mode 100644
index 2238323c38e..00000000000
--- a/velox/type/parser/ParserUtil.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <string>
-#include "velox/type/Type.h"
-
-namespace facebook::velox {
-
-/// Normalize Presto types such as INT and DOUBLE PRECISION and convert to Velox
-/// type.
-TypePtr typeFromString(
-    const std::string& type,
-    bool failIfNotRegistered = true);
-
-TypePtr customTypeWithChildren(
-    const std::string& name,
-    const std::vector<TypePtr>& children);
-
-/// Creates a LongEnumParameter with the enumName and valuesMap and passes it in
-/// as a parameter to BIGINT_ENUM type to return an enum Type.
-/// The valuesMap is assumed to have a format of "[["CURIOUS",-2], ["HAPPY",0]]"
-/// so that folly::parseJson can be used to parse and throw on duplicate keys
-/// and/or values.
-TypePtr getEnumType(
-    const std::string& enumType,
-    const std::string& enumName,
-    const std::string& valuesMap);
-
-/// Convert words with spaces to a Velox type.
-/// First check if all the words are a Velox type.
-/// Then check if the first word is a field name and the remaining words are a
-/// Velox type. If cannotHaveFieldName = true, then all words must be a Velox
-/// type.
-std::pair<std::string, TypePtr> inferTypeWithSpaces(
-    std::vector<std::string>& words,
-    bool cannotHaveFieldName = false);
-
-} // namespace facebook::velox
diff --git a/velox/type/parser/Scanner.h b/velox/type/parser/Scanner.h
deleted file mode 100644
index 3af178e5f49..00000000000
--- a/velox/type/parser/Scanner.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <cmath>
-#include <iostream>
-#include <sstream>
-#include <string>
-#include <unordered_map>
-
-#include "velox/common/base/Exceptions.h"
-#include "velox/type/Type.h"
-
-namespace facebook::velox::type {
-
-/// velox/type/parser has been moved to velox/functions/prestosql/types/parser.
-/// This file is for backward compatibility and will be removed once Presto is
-/// updated with the new Velox version.
-class Scanner : public yyFlexLexer {
- public:
-  Scanner(
-      std::istream& arg_yyin,
-      std::ostream& arg_yyout,
-      TypePtr& outputType,
-      const std::string_view input)
-      : yyFlexLexer(&arg_yyin, &arg_yyout),
-        outputType_(outputType),
-        input_(input){};
-  int lex(Parser::semantic_type* yylval);
-
-  void setType(TypePtr type) {
-    outputType_ = std::move(type);
-  }
-
-  // Store input to print it as part of the error message.
-  std::string_view input() {
-    return input_;
-  }
-
- private:
-  TypePtr& outputType_;
-  const std::string_view input_;
-};
-} // namespace facebook::velox::type
diff --git a/velox/type/parser/TypeParser.h b/velox/type/parser/TypeParser.h
deleted file mode 100644
index 489f65d4816..00000000000
--- a/velox/type/parser/TypeParser.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <string>
-#include "velox/type/Type.h"
-
-namespace facebook::velox {
-/// velox/type/parser has been moved to velox/functions/prestosql/types/parser.
-/// This file is for backward compatibility and will be removed once Presto is
-/// updated with the new Velox version.
-
-/// Parses a type string in Presto format to
-/// Velox type. Example type strings:
-///    row(col0 bigint, varchar)
-///    array(bigint)
-///    map(bigint, array(bigint))
-///    function(bigint,bigint,bigint)
-/// The parsing is case-insensitive. i.e. 'Row' and 'row' are equal.
-/// Field names for rows are optional.
-/// Quoted field names are supported.
-/// All custom types need to be registered. An error is thrown otherwise.
-/// Uses the Type::getType API to convert a string to Velox type.
-TypePtr parseType(const std::string& typeText);
-
-} // namespace facebook::velox
diff --git a/velox/type/parser/TypeParser.ll b/velox/type/parser/TypeParser.ll
deleted file mode 100644
index 5961ac8baae..00000000000
--- a/velox/type/parser/TypeParser.ll
+++ /dev/null
@@ -1,86 +0,0 @@
-%{
-#include <vector>
-#include <memory>
-#include <map>
-
-#include "velox/type/parser/TypeParser.yy.h"  // @manual
-#include "velox/type/parser/Scanner.h"
-
-#define YY_DECL int facebook::velox::type::Scanner::lex(facebook::velox::type::Parser::semantic_type *yylval)
-%}
-
-%option c++ noyywrap noyylineno nodefault caseless ecs
-
-A   [A|a]
-B   [B|b]
-C   [C|c]
-D   [D|d]
-E   [E|e]
-F   [F|f]
-G   [G|g]
-H   [H|h]
-I   [I|i]
-J   [J|j]
-K   [K|k]
-L   [L|l]
-M   [M|m]
-O   [O|o]
-P   [P|p]
-R   [R|r]
-S   [S|s]
-T   [T|t]
-U   [U|u]
-W   [W|w]
-X   [X|x]
-Y   [Y|y]
-Z   [Z|z]
-
-WORD              ([[:alpha:][:alnum:]_]*)
-QUOTED_ID         (['"']([^"\n]|"")*['"'])
-NUMBER            ([[:digit:]]+)
-SIGNED_INT        (-?[[:digit:]]+)
-VARIABLE          (VARCHAR|VARBINARY)
-WORD_WITH_PERIODS ([[:alpha:]_][[:alnum:]_]*)(\.([[:alpha:]_][[:alnum:]_]*))*
-
-%%
-
-"("                return Parser::token::LPAREN;
-")"                return Parser::token::RPAREN;
-"{"                return Parser::token::LBRACE;
-"}"                return Parser::token::RBRACE;
-","                return Parser::token::COMMA;
-"."                return Parser::token::PERIOD;
-":"                return Parser::token::COLON;
-(ARRAY)            return Parser::token::ARRAY;
-(MAP)              return Parser::token::MAP;
-(FUNCTION)         return Parser::token::FUNCTION;
-(DECIMAL)          return Parser::token::DECIMAL;
-(ROW)              return Parser::token::ROW;
-{VARIABLE}         yylval->build<std::string>(YYText()); return Parser::token::VARIABLE;
-{NUMBER}           yylval->build<long long>(folly::to<int>(YYText())); return Parser::token::NUMBER;
-{SIGNED_INT}       yylval->build<long long>(folly::to<int>(YYText())); return Parser::token::SIGNED_INT;
-{WORD}             yylval->build<std::string>(YYText()); return Parser::token::WORD;
-{WORD_WITH_PERIODS}             yylval->build<std::string>(YYText()); return Parser::token::WORD_WITH_PERIODS;
-{QUOTED_ID}        yylval->build<std::string>(YYText()); return Parser::token::QUOTED_ID;
-<<EOF>>            return Parser::token::YYEOF;
-.               /* no action on unmatched input */
-
-%%
-
-int yyFlexLexer::yylex() {
-    throw std::runtime_error("Bad call to yyFlexLexer::yylex()");
-}
-
-#include "velox/type/parser/TypeParser.h"
-
-facebook::velox::TypePtr facebook::velox::parseType(const std::string& typeText)
- {
-    std::istringstream is(typeText);
-    std::ostringstream os;
-    facebook::velox::TypePtr type;
-    facebook::velox::type::Scanner scanner{is, os, type, typeText};
-    facebook::velox::type::Parser parser{ &scanner };
-    parser.parse();
-    VELOX_CHECK(type, "Failed to parse type [{}]", typeText);
-    return type;
-}
diff --git a/velox/type/parser/TypeParser.yy b/velox/type/parser/TypeParser.yy
deleted file mode 100644
index 8f7992c1754..00000000000
--- a/velox/type/parser/TypeParser.yy
+++ /dev/null
@@ -1,196 +0,0 @@
-%{
-#include <FlexLexer.h>
-#include "velox/common/base/Exceptions.h"
-#include "velox/type/Type.h"
-#include "velox/type/parser/ParserUtil.h"
-%}
-%require "3.0.4"
-%language "C++"
-
-%define parser_class_name {Parser}
-%define api.namespace {facebook::velox::type}
-%define api.value.type variant
-%parse-param {Scanner* scanner}
-%define parse.error verbose
-
-%code requires
-{
-    namespace facebook::velox::type {
-        class Scanner;
-    } // namespace facebook::velox::type
-    namespace facebook::velox {
-        class Type;
-    } // namespace facebook::velox
-    struct RowArguments {
-       std::vector<std::string> names;
-       std::vector<std::shared_ptr<const facebook::velox::Type>> types;
-    };
-} // %code requires
-
-%code
-{
-    #include "velox/type/parser/Scanner.h"
-
-    #define yylex(x) scanner->lex(x)
-}
-
-%token               LPAREN RPAREN COMMA PERIOD COLON ARRAY MAP ROW FUNCTION DECIMAL LBRACE RBRACE
-%token <std::string> WORD VARIABLE QUOTED_ID WORD_WITH_PERIODS
-%token <long long>   NUMBER SIGNED_INT
-%token YYEOF         0
-
-%nterm <std::shared_ptr<const Type>> type type_single_word
-%nterm <std::shared_ptr<const Type>> special_type function_type decimal_type row_type array_type map_type variable_type custom_type_with_children enum_type
-%nterm <RowArguments> type_list_opt_names
-%nterm <std::vector<std::shared_ptr<const Type>>> type_list
-%nterm <std::pair<std::string, std::shared_ptr<const Type>>> named_type
-%nterm <std::vector<std::string>> type_with_spaces
-%nterm <std::string> field_name enum_name enum_kind enum_map_entry enum_map_entries enum_map_entries_json
-
-%start type_spec
-
-%%
-
-/* The grammar entry point. */
-type_spec : type                 { scanner->setType($1); }
-          | error                { yyerrok; }
-          ;
-
-type : type_single_word  { $$ = $1; }
-     | type_with_spaces  { $$ = inferTypeWithSpaces($1, true).second; }
-     ;
-
-type_single_word : WORD         { $$ = typeFromString($1); } // Handles most primitive types (e.g. bigint, etc).
-                 | special_type { $$ = $1; }
-
-special_type : array_type     { $$ = $1; }
-             | map_type       { $$ = $1; }
-             | row_type       { $$ = $1; }
-             | function_type  { $$ = $1; }
-             | variable_type  { $$ = $1; }
-             | decimal_type   { $$ = $1; }
-             | custom_type_with_children { $$ = $1; }
-             | enum_type { $$ = $1; }
-
-/*
- * Types with spaces have at least two words. They are joined in an
- * std::vector here, and resolved by `inferTypeWithSpaces()`. The first
- * word is special to allow for tokens such as "map", "array", etc, to
- * be used as field names.
- */
-type_with_spaces : type_with_spaces WORD  { $1.push_back($2); $$ = std::move($1); }
-                 | field_name WORD        { $$.push_back($1); $$.push_back($2); }
-                 ;
-
-/* List of allowed field names. */
-field_name : WORD     { $$ = $1; }
-           | ARRAY    { $$ = "array"; }
-           | MAP      { $$ = "map"; }
-           | FUNCTION { $$ = "function"; }
-           | DECIMAL  { $$ = "decimal"; }
-           | ROW      { $$ = "row"; }
-           | VARIABLE { $$ = $1; }
-           ;
-
-/*
- * Varchar and varbinary have an optional `(int)`
- * e.g. both `varchar` and `varchar(4)` are valid.
- */
-variable_type : VARIABLE LPAREN NUMBER RPAREN  { $$ = typeFromString($1); }
-              | VARIABLE                       { $$ = typeFromString($1); }
-              ;
-
-decimal_type : DECIMAL LPAREN NUMBER COMMA NUMBER RPAREN { $$ = DECIMAL($3, $5); }
-             ;
-
-array_type : ARRAY LPAREN type RPAREN { $$ = ARRAY($3); }
-           ;
-
-map_type : MAP LPAREN type COMMA type RPAREN { $$ = MAP($3, $5); }
-         ;
-
-function_type : FUNCTION LPAREN type_list RPAREN { auto returnType = $3.back(); $3.pop_back();
-                                                   $$ = FUNCTION(std::move($3), returnType); }
-
-row_type : ROW LPAREN type_list_opt_names RPAREN  { $$ = ROW(std::move($3.names), std::move($3.types)); }
-         ;
-
-custom_type_with_children : WORD LPAREN type_list RPAREN { $$ = customTypeWithChildren($1, $3); }
-
-/* Consecutive list of types, separated by a comma. */
-type_list : type                   { $$.push_back($1); }
-          | type_list COMMA type   { $1.push_back($3); $$ = std::move($1); }
-          ;
-
-/*
- * Consecutive list of types which can optionally have a "name".
- * Only allowed inside row definitions.
- */
-type_list_opt_names : type_list_opt_names COMMA named_type   { $1.names.push_back($3.first);
-                                                               $1.types.push_back($3.second);
-                                                               $$.names = std::move($1.names);
-                                                               $$.types = std::move($1.types); }
-                    | named_type                             { $$.names.push_back($1.first); $$.types.push_back($1.second); }
-                    ;
-
-/*
- * Named type is a type definition with an optional name. The name can be
- * quoted. Since types with spaces are allowed, there is potential ambiguity
- * in definitions with multiple words, for example:
- *
- * > my type
- *
- * Is "my" the name and "type" the type, or "my type" is the type name? We first
- * check if there is a type matching all words ("my type"), and if not, check if
- * there is a type matching all but the first wor ("type") and assume the first
- * ("my") to be the field name. See `inferTypeWithSpaces()`.
- */
-named_type : type_single_word        { $$ = std::make_pair("", $1); }
-           | field_name special_type { $$ = std::make_pair($1, $2); }
-           | type_with_spaces        { $$ = inferTypeWithSpaces($1, false); }
-           | QUOTED_ID type          { $1.erase(0, 1); $1.pop_back(); $$ = std::make_pair($1, $2); }  // Remove the quotes.
-           ;
-/*
- * Enum types have a format of:
- * "test.enum.mood:BigintEnum(test.enum.mood{"CURIOUS":2, "HAPPY":0})"
- * where "test.enum.mood" is the enum name, "BigintEnum" is the enum kind,
- * and "CURIOUS":2, "HAPPY":0 are the enum values.
- * These values are passed as parameters to BIGINT_ENUM type.
- */
-enum_map_entries : enum_map_entry { $$ = $1; }
-            | enum_map_entries COMMA enum_map_entry { $$ = $1 + ", " + $3; }
-            ;
-
-/*
- * Formats the values map like "[["CURIOUS",-2], ["HAPPY",0]]"
- * so that it can be parsed as an array of pairs using folly::parseJson in getEnumType.
- */
-enum_map_entries_json : LBRACE enum_map_entries RBRACE {$$ = "[" + $2 + "]"; }
-                    ;
-
-enum_map_entry : QUOTED_ID COLON SIGNED_INT {  $$ = "[" + $1 + "," + std::to_string($3) + "]"; }
-               | QUOTED_ID COLON NUMBER     {  $$ = "[" + $1 + "," + std::to_string($3) + "]"; }
-               | QUOTED_ID COLON QUOTED_ID  {  $$ = "[" + $1 + "," + $3 + "]"; }
-               ;
-
-enum_kind : WORD { if ($1 != "BigintEnum" && $1 != "VarcharEnum" )
-                    {
-                        std::string msg = "Invalid type " + $1 + ", expected BigintEnum or VarcharEnum";
-                        error(msg.c_str());
-                    }
-                $$ = $1; }
-                ;
-
-enum_name : WORD_WITH_PERIODS { $$ = $1; }
-          | WORD { $$ = $1; }
-          ;
-
-enum_type : enum_name COLON enum_kind LPAREN enum_name enum_map_entries_json RPAREN
-          { $$ = getEnumType($3, $1, $6); }
-          ;
-
-%%
-
-void facebook::velox::type::Parser::error(const std::string& msg) {
-  VELOX_UNSUPPORTED("Failed to parse type [{}]. {}", scanner->input(), msg);
-}
diff --git a/velox/type/parser/tests/TypeParserTest.cpp b/velox/type/parser/tests/TypeParserTest.cpp
deleted file mode 100644
index aa2bb0484dd..00000000000
--- a/velox/type/parser/tests/TypeParserTest.cpp
+++ /dev/null
@@ -1,569 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <gtest/gtest.h>
-
-#include "velox/common/base/tests/GTestUtils.h"
-#include "velox/functions/prestosql/types/BigintEnumRegistration.h"
-#include "velox/functions/prestosql/types/BigintEnumType.h"
-#include "velox/functions/prestosql/types/VarcharEnumRegistration.h"
-#include "velox/functions/prestosql/types/VarcharEnumType.h"
-#include "velox/type/parser/TypeParser.h"
-
-namespace facebook::velox {
-namespace {
-
-class CustomType : public VarcharType {
- public:
-  CustomType() = default;
-
-  bool equivalent(const Type& other) const override {
-    // Pointer comparison works since this type is a singleton.
-    return this == &other;
-  }
-};
-
-static const TypePtr& JSON() {
-  static const TypePtr instance{new CustomType()};
-  return instance;
-}
-
-static const TypePtr& TIMESTAMP_WITH_TIME_ZONE() {
-  static const TypePtr instance{new CustomType()};
-  return instance;
-}
-
-class TypeFactory : public CustomTypeFactory {
- public:
-  TypeFactory(const TypePtr& type) : type_(type) {}
-
-  TypePtr getType(
-      const std::vector<TypeParameter>& /*parameters*/) const override {
-    return type_;
-  }
-
-  exec::CastOperatorPtr getCastOperator() const override {
-    return nullptr;
-  }
-
-  AbstractInputGeneratorPtr getInputGenerator(
-      const InputGeneratorConfig& /*config*/) const override {
-    return nullptr;
-  }
-
- private:
-  TypePtr type_;
-};
-
-class TypeParserTest : public ::testing::Test {
- private:
-  void SetUp() override {
-    // Register custom types with and without spaces.
-    registerCustomType("json", std::make_unique<const TypeFactory>(JSON()));
-    registerCustomType(
-        "timestamp with time zone",
-        std::make_unique<const TypeFactory>(TIMESTAMP_WITH_TIME_ZONE()));
-  }
-};
-
-TEST_F(TypeParserTest, booleanType) {
-  ASSERT_EQ(*parseType("boolean"), *BOOLEAN());
-}
-
-TEST_F(TypeParserTest, integerType) {
-  ASSERT_EQ(*parseType("int"), *INTEGER());
-  ASSERT_EQ(*parseType("integer"), *INTEGER());
-}
-
-TEST_F(TypeParserTest, varcharType) {
-  ASSERT_EQ(*parseType("varchar"), *VARCHAR());
-  ASSERT_EQ(*parseType("varchar(4)"), *VARCHAR());
-}
-
-TEST_F(TypeParserTest, charType) {
-  VELOX_ASSERT_UNSUPPORTED_THROW(parseType("char"), "");
-  VELOX_ASSERT_UNSUPPORTED_THROW(parseType("char(4)"), "");
-}
-
-TEST_F(TypeParserTest, varbinary) {
-  ASSERT_EQ(*parseType("varbinary"), *VARBINARY());
-}
-
-TEST_F(TypeParserTest, arrayType) {
-  ASSERT_EQ(*parseType("array(bigint)"), *ARRAY(BIGINT()));
-
-  ASSERT_EQ(*parseType("array(int)"), *ARRAY(INTEGER()));
-  ASSERT_EQ(*parseType("array(integer)"), *ARRAY(INTEGER()));
-
-  ASSERT_EQ(*parseType("array(array(bigint))"), *ARRAY(ARRAY(BIGINT())));
-
-  ASSERT_EQ(*parseType("array(array(int))"), *ARRAY(ARRAY(INTEGER())));
-
-  ASSERT_EQ(
-      *parseType("array(timestamp with time zone)"),
-      *ARRAY(TIMESTAMP_WITH_TIME_ZONE()));
-
-  ASSERT_EQ(*parseType("array(DECIMAL(10,5))"), *ARRAY(DECIMAL(10, 5)));
-}
-
-TEST_F(TypeParserTest, mapType) {
-  ASSERT_EQ(*parseType("map(bigint,bigint)"), *MAP(BIGINT(), BIGINT()));
-
-  ASSERT_EQ(
-      *parseType("map(timestamp with time zone,bigint)"),
-      *MAP(TIMESTAMP_WITH_TIME_ZONE(), BIGINT()));
-
-  ASSERT_EQ(
-      *parseType("map(timestamp with time zone, timestamp with time zone)"),
-      *MAP(TIMESTAMP_WITH_TIME_ZONE(), TIMESTAMP_WITH_TIME_ZONE()));
-
-  ASSERT_EQ(
-      *parseType("map(json, timestamp with time zone)"),
-      *MAP(JSON(), TIMESTAMP_WITH_TIME_ZONE()));
-
-  ASSERT_EQ(
-      *parseType("map(bigint,array(bigint))"), *MAP(BIGINT(), ARRAY(BIGINT())));
-
-  ASSERT_EQ(
-      *parseType("map(timestamp with time zone, varchar)"),
-      *MAP(TIMESTAMP_WITH_TIME_ZONE(), VARCHAR()));
-
-  ASSERT_EQ(
-      *parseType("map(bigint,map(bigint,map(varchar,bigint)))"),
-      *MAP(BIGINT(), MAP(BIGINT(), MAP(VARCHAR(), BIGINT()))));
-
-  ASSERT_EQ(
-      *parseType("maP(DECIMAL(10,5), DECIMAL(20, 4))"),
-      *MAP(DECIMAL(10, 5), DECIMAL(20, 4)));
-
-  // Complex types as map keys.
-  ASSERT_EQ(
-      *parseType("map(row(bigint),bigint)"), *MAP(ROW({BIGINT()}), BIGINT()));
-
-  ASSERT_EQ(
-      *parseType("map(array(double),bigint)"), *MAP(ARRAY(DOUBLE()), BIGINT()));
-
-  ASSERT_EQ(
-      *parseType("map(map(tinyint, varchar),bigint)"),
-      *MAP(MAP(TINYINT(), VARCHAR()), BIGINT()));
-}
-
-TEST_F(TypeParserTest, invalidType) {
-  VELOX_ASSERT_THROW(
-      parseType("blah()"),
-      "Failed to parse type [blah()]. "
-      "syntax error, unexpected RPAREN");
-
-  VELOX_ASSERT_THROW(parseType("array()"), "Failed to parse type [array()]");
-
-  VELOX_ASSERT_THROW(parseType("map()"), "Failed to parse type [map()]");
-
-  VELOX_ASSERT_THROW(parseType("x"), "Failed to parse type [x]");
-
-  // Ensure this is not treated as a row type.
-  VELOX_ASSERT_UNSUPPORTED_THROW(
-      parseType("rowxxx(a)"), "Failed to parse type [a]. Type not registered.");
-}
-
-TEST_F(TypeParserTest, rowType) {
-  // Unnamed fields.
-  ASSERT_EQ(
-      *parseType("row(bigint,varchar, real, timestamp with time zone)"),
-      *ROW({BIGINT(), VARCHAR(), REAL(), TIMESTAMP_WITH_TIME_ZONE()}));
-
-  ASSERT_EQ(
-      *parseType("row(a bigint,b varchar,c real)"),
-      *ROW({"a", "b", "c"}, {BIGINT(), VARCHAR(), REAL()}));
-
-  ASSERT_EQ(
-      *parseType("row(a timestamp with time zone,b json,c real)"),
-      *ROW({"a", "b", "c"}, {TIMESTAMP_WITH_TIME_ZONE(), JSON(), REAL()}));
-
-  ASSERT_EQ(
-      *parseType("row(a bigint,b array(bigint),c row(a decimal(10,5)))"),
-      *ROW(
-          {"a", "b", "c"},
-          {BIGINT(), ARRAY(BIGINT()), ROW({"a"}, {DECIMAL(10, 5)})}));
-
-  // Quoted field name starting with number and scalar type.
-  ASSERT_EQ(
-      *parseType("row(\"12 tb\" bigint,b bigint,c bigint)"),
-      *ROW({"12 tb", "b", "c"}, {BIGINT(), BIGINT(), BIGINT()}));
-
-  ASSERT_EQ(
-      *parseType("row(\"a\" bigint, \"b\" array(varchar), "
-                 "\"c\" timestamp with time zone)"),
-      *ROW(
-          {"a", "b", "c"},
-          {BIGINT(), ARRAY(VARCHAR()), TIMESTAMP_WITH_TIME_ZONE()}));
-
-  ASSERT_EQ(
-      *parseType("row(a varchar(10),b row(a bigint))"),
-      *ROW({"a", "b"}, {VARCHAR(), ROW({"a"}, {BIGINT()})}));
-
-  ASSERT_EQ(
-      *parseType("array(row(col0 bigint,col1 double))"),
-      *ARRAY(ROW({"col0", "col1"}, {BIGINT(), DOUBLE()})));
-
-  ASSERT_EQ(
-      *parseType("row(col0 array(row(col0 bigint,col1 double)))"),
-      *ROW({"col0"}, {ARRAY(ROW({"col0", "col1"}, {BIGINT(), DOUBLE()}))}));
-
-  ASSERT_EQ(*parseType("row(bigint,varchar)"), *ROW({BIGINT(), VARCHAR()}));
-
-  ASSERT_EQ(
-      *parseType("row(bigint,array(bigint),row(a bigint))"),
-      *ROW({BIGINT(), ARRAY(BIGINT()), ROW({"a"}, {BIGINT()})}));
-
-  ASSERT_EQ(
-      *parseType("row(varchar(10),b row(bigint))"),
-      *ROW({"", "b"}, {VARCHAR(), ROW({BIGINT()})}));
-
-  ASSERT_EQ(
-      *parseType("array(row(col0 bigint,double))"),
-      *ARRAY(ROW({"col0", ""}, {BIGINT(), DOUBLE()})));
-
-  ASSERT_EQ(
-      *parseType("row(col0 array(row(bigint,double)))"),
-      *ROW({"col0"}, {ARRAY(ROW({BIGINT(), DOUBLE()}))}));
-
-  ASSERT_EQ(
-      *parseType("row(double double precision)"), *ROW({"double"}, {DOUBLE()}));
-
-  ASSERT_EQ(*parseType("row(double precision)"), *ROW({DOUBLE()}));
-
-  ASSERT_EQ(
-      *parseType("RoW(a bigint,b varchar)"),
-      *ROW({"a", "b"}, {BIGINT(), VARCHAR()}));
-
-  ASSERT_EQ(*parseType("row(array(Json))"), *ROW({ARRAY(JSON())}));
-
-  VELOX_ASSERT_UNSUPPORTED_THROW(
-      *parseType("row(col0 row(array(HyperLogLog)))"),
-      "Failed to parse type [HyperLogLog]. Type not registered.");
-
-  // Field type canonicalization.
-  ASSERT_EQ(*parseType("row(col iNt)"), *ROW({"col"}, {INTEGER()}));
-
-  // Can only have names within rows.
-  VELOX_ASSERT_UNSUPPORTED_THROW(
-      parseType("asd bigint"),
-      "Failed to parse type [asd bigint]. Type not registered.");
-}
-
-TEST_F(TypeParserTest, typesWithSpaces) {
-  // Type is not registered.
-  VELOX_ASSERT_UNSUPPORTED_THROW(
-      parseType("row(time time with time zone)"),
-      "Failed to parse type [time with time zone]. Type not registered.");
-
-  ASSERT_EQ(
-      *parseType("timestamp with time zone"), *TIMESTAMP_WITH_TIME_ZONE());
-
-  // Type is registered.
-  ASSERT_EQ(
-      *parseType("row(col0 timestamp with time zone)"),
-      *ROW({"col0"}, {TIMESTAMP_WITH_TIME_ZONE()}));
-
-  ASSERT_EQ(
-      *parseType("row(double double precision)"), *ROW({"double"}, {DOUBLE()}));
-
-  VELOX_ASSERT_THROW(
-      parseType("row(time with time zone)"),
-      "Failed to parse type [with time zone]");
-
-  ASSERT_EQ(*parseType("row(double precision)"), *ROW({DOUBLE()}));
-
-  ASSERT_EQ(
-      *parseType("row(INTERval DAY TO SECOND)"), *ROW({INTERVAL_DAY_TIME()}));
-
-  ASSERT_EQ(
-      *parseType("row(INTERVAL YEAR TO month)"), *ROW({INTERVAL_YEAR_MONTH()}));
-
-  // quoted field name with valid type with spaces.
-  ASSERT_EQ(
-      *parseType(
-          "row(\"timestamp with time zone\" timestamp with time zone,\"double\" double)"),
-      *ROW(
-          {"timestamp with time zone", "double"},
-          {TIMESTAMP_WITH_TIME_ZONE(), DOUBLE()}));
-
-  // quoted filed name with special characters & spaces
-  ASSERT_EQ(
-      *parseType("row(\"Nested Some more weirdtt +- \\:\\: charact\" varchar)"),
-      *ROW({"Nested Some more weirdtt +- \\:\\: charact"}, {VARCHAR()}));
-
-  // quoted field name with invalid type with spaces.
-  VELOX_ASSERT_UNSUPPORTED_THROW(
-      parseType(
-          "row(\"timestamp with time zone\" timestamp timestamp with time zone)"),
-      "Failed to parse type [timestamp timestamp with time zone]. Type not registered.");
-}
-
-TEST_F(TypeParserTest, intervalYearToMonthType) {
-  ASSERT_EQ(
-      *parseType("row(interval interval year to month)"),
-      *ROW({"interval"}, {INTERVAL_YEAR_MONTH()}));
-
-  ASSERT_EQ(
-      *parseType("row(interval year to month)"), *ROW({INTERVAL_YEAR_MONTH()}));
-}
-
-TEST_F(TypeParserTest, functionType) {
-  ASSERT_EQ(
-      *parseType("function(bigint,bigint,bigint)"),
-      *FUNCTION({BIGINT(), BIGINT()}, BIGINT()));
-  ASSERT_EQ(
-      *parseType("function(bigint,array(varchar),varchar)"),
-      *FUNCTION({BIGINT(), ARRAY(VARCHAR())}, VARCHAR()));
-}
-
-TEST_F(TypeParserTest, decimalType) {
-  ASSERT_EQ(*parseType("decimal(10, 5)"), *DECIMAL(10, 5));
-  ASSERT_EQ(*parseType("decimal(20,10)"), *DECIMAL(20, 10));
-
-  VELOX_ASSERT_THROW(parseType("decimal"), "Failed to parse type [decimal]");
-  VELOX_ASSERT_THROW(
-      parseType("decimal()"), "Failed to parse type [decimal()]");
-  VELOX_ASSERT_THROW(
-      parseType("decimal(20)"), "Failed to parse type [decimal(20)]");
-  VELOX_ASSERT_THROW(
-      parseType("decimal(, 20)"), "Failed to parse type [decimal(, 20)]");
-}
-
-// Checks that type names can also be field names.
-TEST_F(TypeParserTest, fieldNames) {
-  ASSERT_EQ(
-      *parseType("row(bigint bigint, map bigint, row bigint, array bigint, "
-                 "decimal bigint, function bigint, struct bigint, "
-                 "varchar map(bigint, tinyint), varbinary array(bigint))"),
-      *ROW(
-          {"bigint",
-           "map",
-           "row",
-           "array",
-           "decimal",
-           "function",
-           "struct",
-           "varchar",
-           "varbinary"},
-          {BIGINT(),
-           BIGINT(),
-           BIGINT(),
-           BIGINT(),
-           BIGINT(),
-           BIGINT(),
-           BIGINT(),
-           MAP(BIGINT(), TINYINT()),
-           ARRAY(BIGINT())}));
-}
-
-TEST_F(TypeParserTest, bigintEnumBasic) {
-  registerBigintEnumType();
-  LongEnumParameter moodInfo("test.enum.mood", {{"CURIOUS", 2}, {"HAPPY", 0}});
-  ASSERT_EQ(
-      *parseType(
-          "test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":2, \"HAPPY\":0})"),
-      *BIGINT_ENUM(moodInfo));
-
-  // Parse negative integers.
-  LongEnumParameter moodWithNegativeValue(
-      "test.enum.mood", {{"CURIOUS", -2}, {"HAPPY", 0}});
-  ASSERT_EQ(
-      *parseType(
-          "test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2, \"HAPPY\":0})"),
-      *BIGINT_ENUM(moodWithNegativeValue));
-
-  // Enum name that is not in the form catalog.namespace.enum_name.
-  LongEnumParameter otherEnumInfo(
-      "someEnumType", {{"CURIOUS", 2}, {"HAPPY", 0}});
-  auto otherEnumString =
-      "someEnumType:BigintEnum(someEnumType{\"CURIOUS\": 2, \"HAPPY\": 0})";
-  ASSERT_EQ(*parseType(otherEnumString), *BIGINT_ENUM(otherEnumInfo));
-
-  // Array type with enum values.
-  ASSERT_EQ(
-      *parseType(
-          "array(test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":2, \"HAPPY\":0}))"),
-      *ARRAY(BIGINT_ENUM(moodInfo)));
-
-  // Map type with enum values.
-  ASSERT_EQ(
-      *parseType(
-          "map(test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2, \"HAPPY\":0}), bigint)"),
-      *MAP(BIGINT_ENUM(moodWithNegativeValue), BIGINT()));
-  ASSERT_EQ(
-      *parseType(
-          "map(bigint,test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2, \"HAPPY\":0}))"),
-      *MAP(BIGINT(), BIGINT_ENUM(moodWithNegativeValue)));
-
-  // Row type with enum values.
-  ASSERT_EQ(
-      *parseType(
-          "row(test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2, \"HAPPY\":0}))"),
-      *ROW({BIGINT_ENUM(moodWithNegativeValue)}));
-  ASSERT_EQ(
-      *parseType(
-          "row(c0 test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2,\"HAPPY\":0}))"),
-      *ROW({"c0"}, {BIGINT_ENUM(moodWithNegativeValue)}));
-}
-
-TEST_F(TypeParserTest, invalidBigintEnums) {
-  // Duplicate keys.
-  VELOX_ASSERT_THROW(
-      parseType(
-          "test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2, \"CURIOUS\":0})"),
-      "Failed to parse map: [[\"CURIOUS\",-2], [\"CURIOUS\",0]], duplicate key found: CURIOUS");
-  VELOX_ASSERT_THROW(
-      parseType(
-          "test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2, \"Curious\":0})"),
-      "Failed to parse map: [[\"CURIOUS\",-2], [\"Curious\",0]], duplicate key found: CURIOUS");
-
-  // Duplicate values.
-  VELOX_ASSERT_THROW(
-      parseType(
-          "test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2, \"HAPPY\":-2})"),
-      "Failed to parse map: [[\"CURIOUS\",-2], [\"HAPPY\",-2]], duplicate value found: -2");
-
-  // Invalid enum type SmallintEnum.
-  VELOX_ASSERT_THROW(
-      parseType(
-          "test.enum.mood:SmallintEnum(test.enum.mood{\"CURIOUS\":-2, \"HAPPY\":0})"),
-      "Failed to parse type [test.enum.mood:SmallintEnum(test.enum.mood{\"CURIOUS\":-2, \"HAPPY\":0})]. Invalid type SmallintEnum, expected BigintEnum or VarcharEnum");
-
-  // Invalid format: missing ":"
-  VELOX_ASSERT_THROW(
-      parseType("testNoColon(test.enum.mood{“CURIOUS”:-2, “HAPPY”:0})"),
-      "Failed to parse type [testNoColon(test.enum.mood{“CURIOUS”:-2, “HAPPY”:0})]. syntax error, unexpected LBRACE, expecting COLON");
-
-  // Invalid format: missing "("
-  VELOX_ASSERT_THROW(
-      parseType(
-          "test.enum.mood:BigintEnum(test.enum.moodCURIOUS”:-2, “HAPPY”:0})"),
-      "Failed to parse type [test.enum.mood:BigintEnum(test.enum.moodCURIOUS”:-2, “HAPPY”:0})]. syntax error, unexpected COLON, expecting LBRACE");
-
-  // Invalid enum type with non integral values.
-  VELOX_ASSERT_THROW(
-      parseType(
-          "test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\": \"varchar value\", \"HAPPY\": \"0\"})"),
-      "Failed to parse map: [[\"CURIOUS\",\"varchar value\"], [\"HAPPY\",\"0\"]], each element must have an integer value.");
-  VELOX_ASSERT_THROW(
-      parseType(
-          "test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\": 1.1, \"HAPPY\": -1.0})"),
-      "Failed to parse type [test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\": 1.1, \"HAPPY\": -1.0})]. syntax error, unexpected PERIOD, expecting COMMA or RBRACE");
-}
-
-TEST_F(TypeParserTest, varcharEnumBasic) {
-  registerVarcharEnumType();
-  VarcharEnumParameter moodInfo(
-      "test.enum.mood",
-      {{"CURIOUS", "someValue"},
-       {"HAPPY", "some value"},
-       {"SAD", "SOME VALUE"}});
-  ASSERT_EQ(
-      *parseType(
-          "test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"})"),
-      *VARCHAR_ENUM(moodInfo));
-
-  // Enum name that is not in the form catalog.namespace.enum_name.
-  VarcharEnumParameter otherEnumInfo(
-      "someEnumType",
-      {{"CURIOUS", "someValue"},
-       {"HAPPY", "some value"},
-       {"SAD", "SOME VALUE"}});
-  auto otherEnumString =
-      "someEnumType:VarcharEnum(someEnumType{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"})";
-  ASSERT_EQ(*parseType(otherEnumString), *VARCHAR_ENUM(otherEnumInfo));
-
-  auto sameEnumDiffOrderMap =
-      "someEnumType:VarcharEnum(someEnumType{\"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"SAD\":\"KNHU2RJAKZAUYVKF\"})";
-  ASSERT_EQ(*parseType(sameEnumDiffOrderMap), *VARCHAR_ENUM(otherEnumInfo));
-
-  // Array type with enum values.
-  ASSERT_EQ(
-      *parseType(
-          "array(test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"}))"),
-      *ARRAY(VARCHAR_ENUM(moodInfo)));
-
-  // Map type with enum values.
-  ASSERT_EQ(
-      *parseType(
-          "map(test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"}), bigint)"),
-      *MAP(VARCHAR_ENUM(moodInfo), BIGINT()));
-  ASSERT_EQ(
-      *parseType(
-          "map(bigint,test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"}))"),
-      *MAP(BIGINT(), VARCHAR_ENUM(moodInfo)));
-
-  // Row type with enum values.
-  ASSERT_EQ(
-      *parseType(
-          "row(test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"}))"),
-      *ROW({VARCHAR_ENUM(moodInfo)}));
-  ASSERT_EQ(
-      *parseType(
-          "row(c0 test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"}))"),
-      *ROW({"c0"}, {VARCHAR_ENUM(moodInfo)}));
-}
-
-TEST_F(TypeParserTest, invalidVarcharEnums) {
-  // Duplicate keys or values.
-  VELOX_ASSERT_THROW(
-      parseType(
-          "test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"CURIOUS\":\"ONXW2ZJAOZQWY5LF\"})"),
-      "Failed to parse map: [[\"CURIOUS\",\"ONXW2ZKWMFWHKZI=\"], [\"CURIOUS\",\"ONXW2ZJAOZQWY5LF\"]], duplicate key found: CURIOUS");
-
-  VELOX_ASSERT_THROW(
-      parseType(
-          "test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"curious\":\"ONXW2ZJAOZQWY5LF\"})"),
-      "Failed to parse map: [[\"CURIOUS\",\"ONXW2ZKWMFWHKZI=\"], [\"curious\",\"ONXW2ZJAOZQWY5LF\"]], duplicate key found: CURIOUS");
-
-  VELOX_ASSERT_THROW(
-      parseType(
-          "test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZKWMFWHKZI=\"})"),
-      "Failed to parse map: [[\"CURIOUS\",\"ONXW2ZKWMFWHKZI=\"], [\"HAPPY\",\"ONXW2ZKWMFWHKZI=\"]], duplicate value found: someValue");
-
-  // Invalid base 32 encoded values.
-  VELOX_ASSERT_THROW(
-      parseType(
-          "test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"12345\", \"HAPPY\":\"ONXW2ZKWMFWHKZI=\"})"),
-      "Failed to parse value 12345, invalid Base32 character: 1");
-
-  // Invalid format: missing ":"
-  VELOX_ASSERT_THROW(
-      parseType(
-          "testNoColon(test.enum.mood{\"CURIOUS\":\"2\", \"HAPPY\":\"happy\"})"),
-      "Failed to parse type [testNoColon(test.enum.mood{\"CURIOUS\":\"2\", \"HAPPY\":\"happy\"})]. syntax error, unexpected LBRACE, expecting COLON");
-
-  // Invalid format: missing "{"
-  VELOX_ASSERT_THROW(
-      parseType(
-          "test.enum.mood:VarcharEnum(test.enum.mood\"CURIOUS\":\"2\", \"HAPPY\":\"happy\"})"),
-      "Failed to parse type [test.enum.mood:VarcharEnum(test.enum.mood\"CURIOUS\":\"2\", \"HAPPY\":\"happy\"})]. syntax error, unexpected QUOTED_ID, expecting LBRACE");
-
-  // Invalid enum type with values of different types.
-  VELOX_ASSERT_THROW(
-      parseType(
-          "test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\": 0, \"HAPPY\":\"happy\"})"),
-      "Failed to parse map: [[\"CURIOUS\",0], [\"HAPPY\",\"happy\"]], each element must have a string value.");
-  VELOX_ASSERT_THROW(
-      parseType(
-          "test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\": 0, \"HAPPY\":1})"),
-      "Failed to parse map: [[\"CURIOUS\",0], [\"HAPPY\",1]], each element must have a string value.");
-}
-
-} // namespace
-} // namespace facebook::velox
diff --git a/velox/type/tests/CMakeLists.txt b/velox/type/tests/CMakeLists.txt
index ce5eab72aeb..a2c53ecaeb8 100644
--- a/velox/type/tests/CMakeLists.txt
+++ b/velox/type/tests/CMakeLists.txt
@@ -15,12 +15,15 @@ add_subdirectory(utils)
 
 add_executable(
   velox_type_test
+  CastRegistryTest.cpp
   ConversionsTest.cpp
   DecimalTest.cpp
+  FastDateTest.cpp
   FilterTest.cpp
   FilterSerDeTest.cpp
   FloatingPointUtilTest.cpp
   HugeIntTest.cpp
+  OpaqueCustomTypesTest.cpp
   StringViewTest.cpp
   SubfieldTest.cpp
   TimestampConversionTest.cpp
@@ -37,6 +40,7 @@ target_link_libraries(
   velox_type
   velox_type_test_lib
   velox_common_base
+  velox_expression
   Folly::folly
   GTest::gtest
   GTest::gtest_main
@@ -121,4 +125,17 @@ if(VELOX_ENABLE_BENCHMARKS)
     GTest::gtest_main
     glog::glog
   )
+
+  add_executable(velox_date_conversion_benchmark DateConversionBenchmark.cpp)
+
+  target_link_libraries(
+    velox_date_conversion_benchmark
+    velox_type
+    velox_external_date
+    Folly::folly
+    Folly::follybenchmark
+    glog::glog
+  )
 endif()
+
+velox_add_library(velox_type_filter_builder INTERFACE HEADERS SubfieldFiltersBuilder.h)
diff --git a/velox/type/tests/CastRegistryTest.cpp b/velox/type/tests/CastRegistryTest.cpp
new file mode 100644
index 00000000000..46b9b76b265
--- /dev/null
+++ b/velox/type/tests/CastRegistryTest.cpp
@@ -0,0 +1,422 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/type/CastRegistry.h"
+
+#include <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+namespace {
+
+class CastRulesRegistryTest : public testing::Test {
+ protected:
+  void SetUp() override {
+    CastRulesRegistry::instance().clear();
+  }
+
+  void TearDown() override {
+    CastRulesRegistry::instance().clear();
+  }
+
+  // Register rules directly on the registry, bypassing the free function's
+  // CastOperator validation. Used for testing registry mechanics with
+  // synthetic type names.
+  void registerRules(const std::vector<CastRule>& rules) {
+    CastRulesRegistry::instance().registerCastRules(rules);
+  }
+};
+
+TEST_F(CastRulesRegistryTest, canCastAndCanCoerce) {
+  registerRules({
+      {.fromType = "BIGINT",
+       .toType = "DOUBLE",
+       .implicitAllowed = true,
+       .cost = 3,
+       .validator = {}},
+      {.fromType = "DOUBLE",
+       .toType = "VARCHAR",
+       .implicitAllowed = false,
+       .validator = {}},
+  });
+
+  // Same type is always allowed.
+  EXPECT_TRUE(CastRulesRegistry::instance().canCast(BIGINT(), BIGINT()));
+  EXPECT_EQ(CastRulesRegistry::instance().canCoerce(BIGINT(), BIGINT()), 0);
+
+  // Implicit rule: BIGINT -> DOUBLE allows both cast and coerce.
+  EXPECT_TRUE(CastRulesRegistry::instance().canCast(BIGINT(), DOUBLE()));
+  EXPECT_TRUE(CastRulesRegistry::instance().canCoerce(BIGINT(), DOUBLE()));
+
+  // Explicit-only rule: DOUBLE -> VARCHAR allows cast but not coerce.
+  EXPECT_TRUE(CastRulesRegistry::instance().canCast(DOUBLE(), VARCHAR()));
+  EXPECT_FALSE(CastRulesRegistry::instance().canCoerce(DOUBLE(), VARCHAR()));
+
+  // Unregistered: VARCHAR -> BIGINT.
+  EXPECT_FALSE(CastRulesRegistry::instance().canCast(VARCHAR(), BIGINT()));
+  EXPECT_FALSE(CastRulesRegistry::instance().canCoerce(VARCHAR(), BIGINT()));
+}
+
+TEST_F(CastRulesRegistryTest, unregisterRules) {
+  registerRules({
+      {.fromType = "BIGINT",
+       .toType = "CUSTOM_TYPE",
+       .implicitAllowed = true,
+       .validator = {}},
+      {.fromType = "CUSTOM_TYPE",
+       .toType = "VARCHAR",
+       .implicitAllowed = false,
+       .validator = {}},
+  });
+
+  unregisterCastRules("CUSTOM_TYPE");
+
+  // After unregistering, re-registering with different flags should work
+  // (no conflict because old rules were removed).
+  EXPECT_NO_THROW(registerRules({
+      {.fromType = "BIGINT",
+       .toType = "CUSTOM_TYPE",
+       .implicitAllowed = false,
+       .validator = {}},
+  }));
+}
+
+TEST_F(CastRulesRegistryTest, duplicateRulesAllowedIfIdentical) {
+  registerRules({
+      {.fromType = "BIGINT",
+       .toType = "CUSTOM_TYPE",
+       .implicitAllowed = true,
+       .validator = {}},
+  });
+
+  // Identical rule should not throw.
+  EXPECT_NO_THROW(registerRules({
+      {.fromType = "BIGINT",
+       .toType = "CUSTOM_TYPE",
+       .implicitAllowed = true,
+       .validator = {}},
+  }));
+}
+
+TEST_F(CastRulesRegistryTest, conflictingRulesThrow) {
+  registerRules({
+      {.fromType = "BIGINT",
+       .toType = "CUSTOM_TYPE",
+       .implicitAllowed = true,
+       .validator = {}},
+  });
+
+  // Different implicitAllowed flag should throw.
+  EXPECT_THROW(
+      registerRules({
+          {.fromType = "BIGINT",
+           .toType = "CUSTOM_TYPE",
+           .implicitAllowed = false,
+           .validator = {}},
+      }),
+      VeloxException);
+}
+
+TEST_F(CastRulesRegistryTest, canCoerceCost) {
+  registerRules({
+      {.fromType = "BIGINT",
+       .toType = "DOUBLE",
+       .implicitAllowed = true,
+       .cost = 5,
+       .validator = {}},
+  });
+
+  // Primitive coercion returns the rule's cost.
+  EXPECT_EQ(CastRulesRegistry::instance().canCoerce(BIGINT(), DOUBLE()), 5);
+
+  // Container types sum children costs.
+  EXPECT_EQ(
+      CastRulesRegistry::instance().canCoerce(ARRAY(BIGINT()), ARRAY(DOUBLE())),
+      5);
+  EXPECT_EQ(
+      CastRulesRegistry::instance().canCoerce(
+          MAP(BIGINT(), BIGINT()), MAP(DOUBLE(), DOUBLE())),
+      10);
+  EXPECT_EQ(
+      CastRulesRegistry::instance().canCoerce(
+          ROW({BIGINT(), BIGINT(), BIGINT()}),
+          ROW({DOUBLE(), DOUBLE(), DOUBLE()})),
+      15);
+
+  // No coercion returns nullopt.
+  EXPECT_FALSE(CastRulesRegistry::instance().canCoerce(DOUBLE(), BIGINT()));
+
+  // Mixed costs: different rules contribute different costs in the same
+  // container.
+  registerRules({
+      {.fromType = "VARCHAR",
+       .toType = "INTEGER",
+       .implicitAllowed = true,
+       .cost = 3,
+       .validator = {}},
+  });
+  EXPECT_EQ(
+      CastRulesRegistry::instance().canCoerce(
+          ROW({BIGINT(), VARCHAR()}), ROW({DOUBLE(), INTEGER()})),
+      8);
+  EXPECT_EQ(
+      CastRulesRegistry::instance().canCoerce(
+          MAP(VARCHAR(), BIGINT()), MAP(INTEGER(), DOUBLE())),
+      8);
+
+  // Nested containers: cost comes from the leaf rule only.
+  EXPECT_EQ(
+      CastRulesRegistry::instance().canCoerce(
+          ARRAY(ARRAY(BIGINT())), ARRAY(ARRAY(DOUBLE()))),
+      5);
+}
+
+TEST_F(CastRulesRegistryTest, parametricTypeCasting) {
+  // Rule for element types: BIGINT -> DOUBLE.
+  registerRules({
+      {.fromType = "BIGINT",
+       .toType = "DOUBLE",
+       .implicitAllowed = true,
+       .validator = {}},
+  });
+
+  // ARRAY<BIGINT> -> ARRAY<DOUBLE> via recursive element check.
+  EXPECT_TRUE(
+      CastRulesRegistry::instance().canCast(ARRAY(BIGINT()), ARRAY(DOUBLE())));
+  EXPECT_TRUE(
+      CastRulesRegistry::instance().canCoerce(
+          ARRAY(BIGINT()), ARRAY(DOUBLE())));
+
+  // Negative: ARRAY<DOUBLE> -> ARRAY<BIGINT> (no reverse rule).
+  EXPECT_FALSE(
+      CastRulesRegistry::instance().canCast(ARRAY(DOUBLE()), ARRAY(BIGINT())));
+}
+
+TEST_F(CastRulesRegistryTest, nestedParametricTypes) {
+  registerRules({
+      {.fromType = "BIGINT",
+       .toType = "DOUBLE",
+       .implicitAllowed = true,
+       .validator = {}},
+  });
+
+  // ARRAY<ARRAY<BIGINT>> -> ARRAY<ARRAY<DOUBLE>>.
+  EXPECT_TRUE(
+      CastRulesRegistry::instance().canCast(
+          ARRAY(ARRAY(BIGINT())), ARRAY(ARRAY(DOUBLE()))));
+}
+
+TEST_F(CastRulesRegistryTest, mapTypeCasting) {
+  registerRules({
+      {.fromType = "BIGINT",
+       .toType = "DOUBLE",
+       .implicitAllowed = true,
+       .validator = {}},
+  });
+
+  // MAP<BIGINT, VARCHAR> -> MAP<DOUBLE, VARCHAR>.
+  EXPECT_TRUE(
+      CastRulesRegistry::instance().canCast(
+          MAP(BIGINT(), VARCHAR()), MAP(DOUBLE(), VARCHAR())));
+
+  // Negative: MAP<VARCHAR, BIGINT> -> MAP<BIGINT, VARCHAR> (no
+  // VARCHAR->BIGINT rule).
+  EXPECT_FALSE(
+      CastRulesRegistry::instance().canCast(
+          MAP(VARCHAR(), BIGINT()), MAP(BIGINT(), VARCHAR())));
+}
+
+TEST_F(CastRulesRegistryTest, mismatchedChildCount) {
+  // ROW(BIGINT) vs ROW(BIGINT, VARCHAR) — different child counts.
+  EXPECT_FALSE(
+      CastRulesRegistry::instance().canCast(
+          ROW({BIGINT()}), ROW({BIGINT(), VARCHAR()})));
+}
+
+TEST_F(CastRulesRegistryTest, differentContainerBaseTypes) {
+  registerRules({
+      {.fromType = "BIGINT",
+       .toType = "DOUBLE",
+       .implicitAllowed = true,
+       .validator = {}},
+  });
+
+  // Different container base types are not supported (e.g. ARRAY -> MAP).
+  EXPECT_FALSE(
+      CastRulesRegistry::instance().canCast(
+          ARRAY(BIGINT()), MAP(BIGINT(), DOUBLE())));
+}
+
+TEST_F(CastRulesRegistryTest, rowTypeCasting) {
+  registerRules({
+      {.fromType = "BIGINT",
+       .toType = "DOUBLE",
+       .implicitAllowed = true,
+       .validator = {}},
+  });
+
+  // ROW({BIGINT}) -> ROW({DOUBLE}) via recursive child check.
+  EXPECT_TRUE(
+      CastRulesRegistry::instance().canCast(ROW({BIGINT()}), ROW({DOUBLE()})));
+  EXPECT_TRUE(
+      CastRulesRegistry::instance().canCoerce(
+          ROW({BIGINT()}), ROW({DOUBLE()})));
+}
+
+TEST_F(CastRulesRegistryTest, containerCoercionExplicitOnlyRule) {
+  // Register an explicit-only rule (implicitAllowed=false).
+  registerRules({
+      {.fromType = "VARCHAR",
+       .toType = "BIGINT",
+       .implicitAllowed = false,
+       .validator = {}},
+  });
+
+  // Explicit cast on a container with explicit-only element rule succeeds.
+  EXPECT_TRUE(
+      CastRulesRegistry::instance().canCast(ARRAY(VARCHAR()), ARRAY(BIGINT())));
+
+  // Implicit coercion on a container with explicit-only element rule fails.
+  EXPECT_FALSE(
+      CastRulesRegistry::instance().canCoerce(
+          ARRAY(VARCHAR()), ARRAY(BIGINT())));
+}
+
+TEST_F(CastRulesRegistryTest, clearRemovesAllRules) {
+  registerRules({
+      {.fromType = "BIGINT",
+       .toType = "CUSTOM_TYPE",
+       .implicitAllowed = true,
+       .validator = {}},
+  });
+
+  CastRulesRegistry::instance().clear();
+
+  // After clear, the previously registered rule should no longer be found.
+  // Re-registering with different flags should not conflict.
+  EXPECT_NO_THROW(registerRules({
+      {.fromType = "BIGINT",
+       .toType = "CUSTOM_TYPE",
+       .implicitAllowed = false,
+       .validator = {}},
+  }));
+}
+
+TEST_F(CastRulesRegistryTest, explicitOnlyCastNotCoercible) {
+  // Register an explicit-only rule (implicitAllowed=false).
+  registerRules({
+      {.fromType = "VARCHAR",
+       .toType = "BIGINT",
+       .implicitAllowed = false,
+       .validator = {}},
+  });
+
+  // Explicit cast is allowed.
+  EXPECT_TRUE(CastRulesRegistry::instance().canCast(VARCHAR(), BIGINT()));
+
+  // Implicit coercion is not allowed.
+  EXPECT_FALSE(CastRulesRegistry::instance().canCoerce(VARCHAR(), BIGINT()));
+}
+
+TEST_F(CastRulesRegistryTest, validatorRejectsCast) {
+  auto rejectAll = [](const TypePtr&, const TypePtr&) { return false; };
+
+  registerRules({
+      {.fromType = "BIGINT",
+       .toType = "DOUBLE",
+       .implicitAllowed = true,
+       .validator = rejectAll},
+  });
+
+  // Rule exists but validator rejects — both canCast and canCoerce return
+  // false.
+  EXPECT_FALSE(CastRulesRegistry::instance().canCast(BIGINT(), DOUBLE()));
+  EXPECT_FALSE(CastRulesRegistry::instance().canCoerce(BIGINT(), DOUBLE()));
+}
+
+TEST_F(CastRulesRegistryTest, decimalPrecisionValidator) {
+  auto decimalWideningValidator = [](const TypePtr& from, const TypePtr& to) {
+    if (!from->isDecimal() || !to->isDecimal()) {
+      return false;
+    }
+    const auto [fromPrecision, fromScale] = getDecimalPrecisionScale(*from);
+    const auto [toPrecision, toScale] = getDecimalPrecisionScale(*to);
+    return toPrecision >= fromPrecision && toScale >= fromScale;
+  };
+
+  registerRules({
+      {.fromType = "DECIMAL",
+       .toType = "DECIMAL",
+       .implicitAllowed = true,
+       .validator = decimalWideningValidator},
+  });
+
+  // Widening: DECIMAL(10,2) -> DECIMAL(15,4).
+  EXPECT_TRUE(
+      CastRulesRegistry::instance().canCast(DECIMAL(10, 2), DECIMAL(15, 4)));
+  EXPECT_TRUE(
+      CastRulesRegistry::instance().canCoerce(DECIMAL(10, 2), DECIMAL(15, 4)));
+
+  // Narrowing: DECIMAL(15,4) -> DECIMAL(10,2) — rejected by validator.
+  EXPECT_FALSE(
+      CastRulesRegistry::instance().canCast(DECIMAL(15, 4), DECIMAL(10, 2)));
+
+  // Same type: always allowed (short-circuits before validator).
+  EXPECT_TRUE(
+      CastRulesRegistry::instance().canCast(DECIMAL(10, 2), DECIMAL(10, 2)));
+}
+
+TEST_F(CastRulesRegistryTest, standaloneRegistration) {
+  registerRules({
+      {.fromType = "TIMESTAMP",
+       .toType = "CUSTOM_TZ",
+       .implicitAllowed = true,
+       .validator = {}},
+      {.fromType = "CUSTOM_TZ",
+       .toType = "VARCHAR",
+       .implicitAllowed = false,
+       .validator = {}},
+  });
+
+  // Verify rules were registered (test via unregister + re-register).
+  unregisterCastRules("CUSTOM_TZ");
+
+  // After unregister, can re-register with different flags.
+  EXPECT_NO_THROW(registerRules({
+      {.fromType = "TIMESTAMP",
+       .toType = "CUSTOM_TZ",
+       .implicitAllowed = false,
+       .validator = {}},
+  }));
+}
+
+TEST_F(CastRulesRegistryTest, rejectsRulesWithoutCastOperator) {
+  // The free function registerCastRules() validates that at least one side
+  // has a registered custom type with a CastOperator.
+  EXPECT_THROW(
+      registerCastRules({
+          {.fromType = "BIGINT",
+           .toType = "NONEXISTENT_TYPE",
+           .implicitAllowed = true,
+           .validator = {}},
+      }),
+      VeloxException);
+}
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/type/tests/ConversionsTest.cpp b/velox/type/tests/ConversionsTest.cpp
index f099a6e3095..635eb080d9f 100644
--- a/velox/type/tests/ConversionsTest.cpp
+++ b/velox/type/tests/ConversionsTest.cpp
@@ -300,7 +300,7 @@ TEST_F(ConversionsTest, toBoolean) {
   }
 }
 
-TEST_F(ConversionsTest, toIntegeralTypes) {
+TEST_F(ConversionsTest, toIntegralTypes) {
   // From double.
   {
     // When TRUNCATE = false.
diff --git a/velox/type/tests/DateConversionBenchmark.cpp b/velox/type/tests/DateConversionBenchmark.cpp
new file mode 100644
index 00000000000..9cdf875b4ac
--- /dev/null
+++ b/velox/type/tests/DateConversionBenchmark.cpp
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+#include <random>
+#include "velox/external/date/date.h"
+#include "velox/type/FastDate.h"
+#include "velox/type/Timestamp.h"
+#include "velox/type/TimestampConversion.h"
+#include "velox/type/WideRangeDateConversion.h"
+
+using namespace facebook::velox;
+
+namespace {
+
+constexpr int32_t kNumValues = 1'000'000;
+
+// Workloads with different ranges of input days. "Tight" represents typical
+// query data; "wide" exercises the algorithm closer to its limits.
+std::vector<int32_t> tightDays;
+std::vector<int32_t> wideDays;
+
+struct Ymd {
+  int32_t year;
+  uint32_t month;
+  uint32_t day;
+};
+std::vector<Ymd> tightYmd;
+std::vector<Ymd> wideYmd;
+
+void fillDays(std::vector<int32_t>& out, int32_t lo, int32_t hi) {
+  std::mt19937 rng{0xBEEF};
+  std::uniform_int_distribution<int32_t> dist{lo, hi};
+  out.resize(kNumValues);
+  for (auto& d : out) {
+    d = dist(rng);
+  }
+}
+
+void fillYmd(std::vector<Ymd>& out, const std::vector<int32_t>& days) {
+  out.clear();
+  out.reserve(days.size());
+  for (int32_t d : days) {
+    const date::year_month_day ymd{date::sys_days{date::days{d}}};
+    out.push_back(
+        Ymd{
+            static_cast<int32_t>(static_cast<int64_t>(ymd.year())),
+            static_cast<unsigned>(ymd.month()),
+            static_cast<unsigned>(ymd.day()),
+        });
+  }
+}
+
+// --- Forward direction: epoch-seconds -> std::tm -------------------------
+// Two contestants:
+//   wide_range  → WideRangeDateConversion::epochToCalendarUtc
+//                 (the loop-based fallback that lived inline in
+//                 Timestamp::epochToCalendarUtc before this PR).
+//   neri_schneider → Timestamp::epochToCalendarUtc (the patched public API,
+//                 which uses the Neri-Schneider 2022 fast path for in-range
+//                 inputs).
+// Both fill the full std::tm including tm_hour/tm_min/tm_sec/tm_wday, so
+// the only differing component is the calendar-conversion algorithm.
+
+__attribute__((noinline)) uint64_t
+runWideRange(const std::vector<int32_t>& days) {
+  uint64_t sum = 0;
+  std::tm tm;
+  for (int32_t d : days) {
+    WideRangeDateConversion::epochToCalendarUtc(int64_t{d} * 86400, tm);
+    sum += static_cast<uint64_t>(tm.tm_year) +
+        static_cast<uint64_t>(tm.tm_mon) + static_cast<uint64_t>(tm.tm_mday);
+  }
+  return sum;
+}
+
+__attribute__((noinline)) uint64_t
+runNeriSchneider(const std::vector<int32_t>& days) {
+  uint64_t sum = 0;
+  std::tm tm;
+  for (int32_t d : days) {
+    Timestamp::epochToCalendarUtc(int64_t{d} * 86400, tm);
+    sum += static_cast<uint64_t>(tm.tm_year) +
+        static_cast<uint64_t>(tm.tm_mon) + static_cast<uint64_t>(tm.tm_mday);
+  }
+  return sum;
+}
+
+BENCHMARK(wide_range_tight) {
+  folly::doNotOptimizeAway(runWideRange(tightDays));
+}
+BENCHMARK_RELATIVE(neri_schneider_tight) {
+  folly::doNotOptimizeAway(runNeriSchneider(tightDays));
+}
+
+BENCHMARK_DRAW_LINE();
+
+BENCHMARK(wide_range_wide) {
+  folly::doNotOptimizeAway(runWideRange(wideDays));
+}
+BENCHMARK_RELATIVE(neri_schneider_wide) {
+  folly::doNotOptimizeAway(runNeriSchneider(wideDays));
+}
+
+BENCHMARK_DRAW_LINE();
+
+// --- Inverse direction: (year, month, day) -> epoch-days -----------------
+// Same contestant pair, both validating via isValidDate and wrapping the
+// result in Expected<int64_t>.
+
+__attribute__((noinline)) uint64_t runWideRangeInv(const std::vector<Ymd>& v) {
+  uint64_t s = 0;
+  for (const auto& x : v) {
+    s += static_cast<uint64_t>(
+        WideRangeDateConversion::daysSinceEpochFromDate(x.year, x.month, x.day)
+            .value());
+  }
+  return s;
+}
+
+__attribute__((noinline)) uint64_t
+runNeriSchneiderInv(const std::vector<Ymd>& v) {
+  uint64_t s = 0;
+  for (const auto& x : v) {
+    s += static_cast<uint64_t>(
+        util::daysSinceEpochFromDate(x.year, x.month, x.day).value());
+  }
+  return s;
+}
+
+BENCHMARK(wide_range_inv_tight) {
+  folly::doNotOptimizeAway(runWideRangeInv(tightYmd));
+}
+BENCHMARK_RELATIVE(neri_schneider_inv_tight) {
+  folly::doNotOptimizeAway(runNeriSchneiderInv(tightYmd));
+}
+
+BENCHMARK_DRAW_LINE();
+
+BENCHMARK(wide_range_inv_wide) {
+  folly::doNotOptimizeAway(runWideRangeInv(wideYmd));
+}
+BENCHMARK_RELATIVE(neri_schneider_inv_wide) {
+  folly::doNotOptimizeAway(runNeriSchneiderInv(wideYmd));
+}
+
+} // namespace
+
+int main(int argc, char** argv) {
+  folly::Init init{&argc, &argv};
+
+  // Tight workload: roughly 1900-2040.
+  fillDays(tightDays, -25'567, 25'567);
+  // Wide workload: bounded by the algorithm's exact range. Still spans
+  // ~3 million years, far wider than any practical Velox DATE.
+  fillDays(wideDays, fast_date::kRataDieMin, fast_date::kRataDieMax);
+
+  // Build matching y/m/d inputs for the inverse direction by running the
+  // same days through the vendored Hinnant date library (used as the
+  // ground-truth reference, not as a bench contestant).
+  fillYmd(tightYmd, tightDays);
+  fillYmd(wideYmd, wideDays);
+
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/type/tests/DecimalTest.cpp b/velox/type/tests/DecimalTest.cpp
index 7bed69a9dab..0d5ad1013d6 100644
--- a/velox/type/tests/DecimalTest.cpp
+++ b/velox/type/tests/DecimalTest.cpp
@@ -135,11 +135,12 @@ void testCastFromString(
     int toScale,
     const std::vector<T>& expectedUnscaleValues) {
   for (int i = 0; i < inputs.size(); ++i) {
-    SCOPED_TRACE(fmt::format(
-        "Index: {}, input: {}, expectedUnscaleValue: {}.",
-        i,
-        inputs[i],
-        expectedUnscaleValues[i]));
+    SCOPED_TRACE(
+        fmt::format(
+            "Index: {}, input: {}, expectedUnscaleValue: {}.",
+            i,
+            inputs[i],
+            expectedUnscaleValues[i]));
     T decimalValue;
     auto status = DecimalUtil::castFromString<T>(
         StringView(inputs[i]), toPrecision, toScale, decimalValue);
@@ -314,16 +315,21 @@ TEST(DecimalTest, valueInPrecisionRange) {
   ASSERT_TRUE(DecimalUtil::valueInPrecisionRange<int64_t>(999, 3));
   ASSERT_FALSE(DecimalUtil::valueInPrecisionRange<int64_t>(1000, 3));
   ASSERT_FALSE(DecimalUtil::valueInPrecisionRange<int64_t>(1234, 3));
-  ASSERT_TRUE(DecimalUtil::valueInPrecisionRange<int64_t>(
-      DecimalUtil::kShortDecimalMax, ShortDecimalType::kMaxPrecision));
-  ASSERT_FALSE(DecimalUtil::valueInPrecisionRange<int64_t>(
-      DecimalUtil::kShortDecimalMax + 1, ShortDecimalType::kMaxPrecision));
-  ASSERT_TRUE(DecimalUtil::valueInPrecisionRange<int128_t>(
-      DecimalUtil::kLongDecimalMax, LongDecimalType::kMaxPrecision));
-  ASSERT_FALSE(DecimalUtil::valueInPrecisionRange<int128_t>(
-      DecimalUtil::kLongDecimalMax + 1, LongDecimalType::kMaxPrecision));
-  ASSERT_FALSE(DecimalUtil::valueInPrecisionRange<int128_t>(
-      DecimalUtil::kLongDecimalMin - 1, LongDecimalType::kMaxPrecision));
+  ASSERT_TRUE(
+      DecimalUtil::valueInPrecisionRange<int64_t>(
+          DecimalUtil::kShortDecimalMax, ShortDecimalType::kMaxPrecision));
+  ASSERT_FALSE(
+      DecimalUtil::valueInPrecisionRange<int64_t>(
+          DecimalUtil::kShortDecimalMax + 1, ShortDecimalType::kMaxPrecision));
+  ASSERT_TRUE(
+      DecimalUtil::valueInPrecisionRange<int128_t>(
+          DecimalUtil::kLongDecimalMax, LongDecimalType::kMaxPrecision));
+  ASSERT_FALSE(
+      DecimalUtil::valueInPrecisionRange<int128_t>(
+          DecimalUtil::kLongDecimalMax + 1, LongDecimalType::kMaxPrecision));
+  ASSERT_FALSE(
+      DecimalUtil::valueInPrecisionRange<int128_t>(
+          DecimalUtil::kLongDecimalMin - 1, LongDecimalType::kMaxPrecision));
 }
 
 TEST(DecimalTest, computeAverage) {
diff --git a/velox/type/tests/FastDateTest.cpp b/velox/type/tests/FastDateTest.cpp
new file mode 100644
index 00000000000..213a6d6e41a
--- /dev/null
+++ b/velox/type/tests/FastDateTest.cpp
@@ -0,0 +1,360 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/type/FastDate.h"
+
+#include <gtest/gtest.h>
+#include <array>
+#include <random>
+#include "velox/external/date/date.h"
+#include "velox/type/Timestamp.h"
+#include "velox/type/TimestampConversion.h"
+#include "velox/type/WideRangeDateConversion.h"
+
+namespace facebook::velox::test {
+namespace {
+
+// Returns the (year, month, day) computed by Howard Hinnant's date library,
+// which we use as the ground truth.
+YearMonthDay hinnantYmd(int32_t dayNumber) {
+  const date::sys_days sd{date::days{dayNumber}};
+  const date::year_month_day ymd{sd};
+  return YearMonthDay{
+      static_cast<int32_t>(static_cast<int64_t>(ymd.year())),
+      static_cast<unsigned>(ymd.month()),
+      static_cast<unsigned>(ymd.day()),
+  };
+}
+
+void expectEq(int32_t dayNumber, YearMonthDay got, YearMonthDay want) {
+  EXPECT_EQ(got.year, want.year) << "day=" << dayNumber;
+  EXPECT_EQ(got.month, want.month) << "day=" << dayNumber;
+  EXPECT_EQ(got.day, want.day) << "day=" << dayNumber;
+}
+
+TEST(FastDateTest, knownDates) {
+  // (input days since epoch, expected y, m, d). Hand-verifiable cases.
+  const std::array<std::tuple<int32_t, int32_t, uint32_t, uint32_t>, 9> cases =
+      {{
+          {0, 1970, 1, 1}, // Epoch.
+          {1, 1970, 1, 2},
+          {-1, 1969, 12, 31},
+          {31, 1970, 2, 1},
+          {59, 1970, 3, 1}, // 1970 not a leap year.
+          {365, 1971, 1, 1},
+          {-365, 1969, 1, 1},
+          {11016, 2000, 2, 29}, // Leap day in a 400-year leap year.
+          {-25509, 1900, 2, 28}, // 1900 not a leap year (no Feb 29).
+      }};
+
+  for (const auto& [d, y, m, day] : cases) {
+    SCOPED_TRACE(testing::Message() << "dayNumber=" << d);
+    const auto got = daysToYmd(d);
+    EXPECT_EQ(got.year, y);
+    EXPECT_EQ(got.month, m);
+    EXPECT_EQ(got.day, day);
+  }
+}
+
+TEST(FastDateTest, matchesHinnantOnTightRange) {
+  // Walk every day across roughly +/- 600 years from epoch. This covers all
+  // Gregorian rule transitions of practical interest (centuries, 400-year
+  // boundaries, leap years).
+  for (int32_t d = -219145; d <= 219145; ++d) {
+    const auto got = daysToYmd(d);
+    const auto want = hinnantYmd(d);
+    if (got.year != want.year || got.month != want.month ||
+        got.day != want.day) {
+      FAIL() << "Mismatch at day=" << d << ": got " << got.year << '-'
+             << got.month << '-' << got.day << " want " << want.year << '-'
+             << want.month << '-' << want.day;
+    }
+  }
+}
+
+TEST(FastDateTest, matchesHinnantOnRandomFullRange) {
+  // 2M random days uniformly across the algorithm's exact range. Spans
+  // roughly 3 million years centered on the epoch; behavior outside this
+  // range is undefined per FastDate.h.
+  std::mt19937 rng{0xC0FFEEu};
+  std::uniform_int_distribution<int32_t> dist{
+      fast_date::kRataDieMin, fast_date::kRataDieMax};
+  for (int i = 0; i < 2'000'000; ++i) {
+    const int32_t d = dist(rng);
+    const auto got = daysToYmd(d);
+    const auto want = hinnantYmd(d);
+    ASSERT_EQ(got.year, want.year) << "day=" << d;
+    ASSERT_EQ(got.month, want.month) << "day=" << d;
+    ASSERT_EQ(got.day, want.day) << "day=" << d;
+  }
+}
+
+TEST(FastDateTest, boundaries) {
+  // Days at every century and 400-year boundary across the algorithm's
+  // exact range. Boundaries are where Gregorian rules diverge most.
+  for (int32_t centuryYear = fast_date::kYearMin + 100;
+       centuryYear <= fast_date::kYearMax - 100;
+       centuryYear += 100) {
+    const auto sd =
+        date::sys_days{date::year{centuryYear} / date::month{3} / date::day{1}};
+    const int32_t d = sd.time_since_epoch().count();
+    const auto got = daysToYmd(d);
+    const auto want = hinnantYmd(d);
+    expectEq(d, got, want);
+  }
+}
+
+// --- Public-API random-input cross-checks (fuzzer-style) -----------------
+// These verify the patched Velox functions (Timestamp::epochToCalendarUtc and
+// util::daysSinceEpochFromDate), not just the inner FastDate.h primitives.
+// Three distributions per direction:
+//   tight:     ~+/- 70 years from epoch (the realistic-data case).
+//   wide:      across the full fast_date::kRataDie range (algorithm domain).
+//   fallback:  way outside the algorithm range, exercising the legacy loop.
+//
+// Each distribution gets 2M random samples, cross-checked against
+// date::year_month_day from velox/external/date/date.h.
+
+namespace {
+constexpr int64_t kSecondsPerDay = 86'400;
+
+// Floor-division: seconds -> days, treating negative remainders correctly.
+int64_t epochToDays(int64_t epoch) {
+  int64_t d = epoch / kSecondsPerDay;
+  int64_t r = epoch % kSecondsPerDay;
+  if (r < 0) {
+    --d;
+  }
+  return d;
+}
+
+// Reference y/m/d for any int64 day count (Hinnant supports the full range).
+struct ReferenceYmd {
+  int64_t year;
+  uint32_t month;
+  uint32_t day;
+};
+ReferenceYmd hinnantRef(int64_t days) {
+  const date::sys_days sd{date::days{days}};
+  const date::year_month_day ymd{sd};
+  return {
+      static_cast<int64_t>(ymd.year()),
+      static_cast<unsigned>(ymd.month()),
+      static_cast<unsigned>(ymd.day()),
+  };
+}
+
+// Asserts that two std::tm structs agree on every field a caller of
+// epochToCalendarUtc could observe. tm_isdst is set to 0 by both paths.
+void expectTmEqual(const std::tm& a, const std::tm& b, int64_t epoch) {
+  EXPECT_EQ(a.tm_year, b.tm_year) << "epoch=" << epoch;
+  EXPECT_EQ(a.tm_mon, b.tm_mon) << "epoch=" << epoch;
+  EXPECT_EQ(a.tm_mday, b.tm_mday) << "epoch=" << epoch;
+  EXPECT_EQ(a.tm_yday, b.tm_yday) << "epoch=" << epoch;
+  EXPECT_EQ(a.tm_wday, b.tm_wday) << "epoch=" << epoch;
+  EXPECT_EQ(a.tm_hour, b.tm_hour) << "epoch=" << epoch;
+  EXPECT_EQ(a.tm_min, b.tm_min) << "epoch=" << epoch;
+  EXPECT_EQ(a.tm_sec, b.tm_sec) << "epoch=" << epoch;
+  EXPECT_EQ(a.tm_isdst, b.tm_isdst) << "epoch=" << epoch;
+}
+} // namespace
+
+TEST(FastDateTest, fuzzEpochToCalendarUtcMatchesHinnant) {
+  std::mt19937_64 rng{0xFAB1Eull};
+  // Tight: realistic Velox data (~1900-2040).
+  std::uniform_int_distribution<int64_t> tight{
+      -25'567 * kSecondsPerDay, 25'567 * kSecondsPerDay};
+  // Wide: full algorithmic range (~3M years).
+  std::uniform_int_distribution<int64_t> wide{
+      static_cast<int64_t>(fast_date::kRataDieMin) * kSecondsPerDay,
+      static_cast<int64_t>(fast_date::kRataDieMax) * kSecondsPerDay};
+  // Fallback: outside the algorithm range on both sides of the epoch,
+  // exercising the legacy 400-year-step loop. Bound by the generous
+  // validation range (~+/- 290M years) but kept far enough from int64
+  // limits that seconds * 86400 doesn't overflow.
+  const int64_t fallbackPositiveStart =
+      static_cast<int64_t>(fast_date::kRataDieMax + 1) * kSecondsPerDay;
+  const int64_t fallbackPositiveEnd =
+      (static_cast<int64_t>(fast_date::kYearMax) + 100'000) * 365 *
+      kSecondsPerDay;
+  const int64_t fallbackNegativeEnd =
+      static_cast<int64_t>(fast_date::kRataDieMin - 1) * kSecondsPerDay;
+  const int64_t fallbackNegativeStart =
+      -(static_cast<int64_t>(fast_date::kYearMax) + 100'000) * 365 *
+      kSecondsPerDay;
+  std::uniform_int_distribution<int64_t> fallbackPositive{
+      fallbackPositiveStart, fallbackPositiveEnd};
+  std::uniform_int_distribution<int64_t> fallbackNegative{
+      fallbackNegativeStart, fallbackNegativeEnd};
+  // Random non-zero seconds-of-day so tm_hour/tm_min/tm_sec are exercised.
+  std::uniform_int_distribution<int64_t> secondsOfDay{0, kSecondsPerDay - 1};
+
+  auto check = [](int64_t epoch) {
+    std::tm fastTm;
+    std::tm wideTm;
+    if (!Timestamp::epochToCalendarUtc(epoch, fastTm)) {
+      // Out-of-range outputs are an acceptable "false" return on both
+      // paths; just verify the wide path agrees and skip.
+      ASSERT_FALSE(WideRangeDateConversion::epochToCalendarUtc(epoch, wideTm))
+          << "epoch=" << epoch;
+      return;
+    }
+    ASSERT_TRUE(WideRangeDateConversion::epochToCalendarUtc(epoch, wideTm))
+        << "epoch=" << epoch;
+    // Full std::tm equality: y/m/d, yday, wday, hour, min, sec, isdst.
+    expectTmEqual(fastTm, wideTm, epoch);
+    // Independent cross-check of the date fields against Hinnant.
+    const auto want = hinnantRef(epochToDays(epoch));
+    ASSERT_EQ(fastTm.tm_year + 1900, want.year) << "epoch=" << epoch;
+    ASSERT_EQ(fastTm.tm_mon + 1, want.month) << "epoch=" << epoch;
+    ASSERT_EQ(static_cast<unsigned>(fastTm.tm_mday), want.day)
+        << "epoch=" << epoch;
+  };
+
+  for (int i = 0; i < 2'000'000; ++i) {
+    check(tight(rng) + secondsOfDay(rng));
+  }
+  for (int i = 0; i < 2'000'000; ++i) {
+    check(wide(rng) + secondsOfDay(rng));
+  }
+  // Fewer fallback samples per side — per-call cost is much higher (the
+  // legacy loop runs many iterations for years far from epoch).
+  for (int i = 0; i < 500'000; ++i) {
+    check(fallbackPositive(rng) + secondsOfDay(rng));
+  }
+  for (int i = 0; i < 500'000; ++i) {
+    check(fallbackNegative(rng) + secondsOfDay(rng));
+  }
+}
+
+TEST(FastDateTest, fuzzDaysSinceEpochFromDateMatchesHinnant) {
+  std::mt19937_64 rng{0xCAFEull};
+
+  auto check = [](int32_t year, uint32_t month, uint32_t day) {
+    auto got = util::daysSinceEpochFromDate(year, month, day);
+    if (got.hasError()) {
+      return;
+    }
+    const date::sys_days sd{
+        date::year{year} / date::month{month} / date::day{day}};
+    const int64_t want = sd.time_since_epoch().count();
+    ASSERT_EQ(got.value(), want)
+        << "y=" << year << " m=" << month << " d=" << day;
+  };
+
+  // Tight: realistic Velox years.
+  std::uniform_int_distribution<int32_t> tightYear{1900, 2040};
+  // Wide: algorithm domain.
+  std::uniform_int_distribution<int32_t> wideYear{
+      fast_date::kYearMin, fast_date::kYearMax};
+  // Fallback: outside the algorithm range on both sides, exercising the
+  // legacy 400-year step loops. Year stays within isValidDate's accepted
+  // [kMinYear, kMaxYear] range.
+  std::uniform_int_distribution<int32_t> fallbackPositiveYear{
+      fast_date::kYearMax + 1, fast_date::kYearMax + 1'000'000};
+  std::uniform_int_distribution<int32_t> fallbackNegativeYear{
+      fast_date::kYearMin - 1'000'000, fast_date::kYearMin - 1};
+
+  // Pick a valid day for the (year, month) pair so we don't trip
+  // isValidDate's "31 Feb"-style rejections.
+  auto sample = [&rng](int32_t year) {
+    const uint32_t month = std::uniform_int_distribution<uint32_t>{1, 12}(rng);
+    const date::year_month_day_last lastOfMonth{
+        date::year{year} / date::month{month} / date::last};
+    const uint32_t maxDay =
+        static_cast<unsigned>(static_cast<date::day>(lastOfMonth.day()));
+    const uint32_t day =
+        std::uniform_int_distribution<uint32_t>{1, maxDay}(rng);
+    return std::make_tuple(year, month, day);
+  };
+
+  for (int i = 0; i < 2'000'000; ++i) {
+    auto [y, m, d] = sample(tightYear(rng));
+    check(y, m, d);
+  }
+  for (int i = 0; i < 2'000'000; ++i) {
+    auto [y, m, d] = sample(wideYear(rng));
+    check(y, m, d);
+  }
+  for (int i = 0; i < 500'000; ++i) {
+    auto [y, m, d] = sample(fallbackPositiveYear(rng));
+    check(y, m, d);
+  }
+  for (int i = 0; i < 500'000; ++i) {
+    auto [y, m, d] = sample(fallbackNegativeYear(rng));
+    check(y, m, d);
+  }
+}
+
+// Verifies that the patched fast path agrees with WideRangeDateConversion
+// at every value within ±10 of the four range boundaries. An off-by-one
+// in the dispatch range or in the algorithm's stated exact range would
+// silently route a few inputs to the wrong branch — this catches that.
+TEST(FastDateTest, fastEqualsWideRangeAtBoundaries) {
+  // Forward direction: ±10 days around kRataDieMin and kRataDieMax.
+  const int32_t forwardBoundaries[] = {
+      fast_date::kRataDieMin, fast_date::kRataDieMax};
+  for (int32_t boundary : forwardBoundaries) {
+    for (int32_t delta = -10; delta <= 10; ++delta) {
+      const int32_t days = boundary + delta;
+      // Mix in non-trivial seconds-of-day: 12:34:56 UTC.
+      const int64_t epoch =
+          static_cast<int64_t>(days) * kSecondsPerDay + 45'296;
+      std::tm fastTm;
+      std::tm wideTm;
+      ASSERT_TRUE(Timestamp::epochToCalendarUtc(epoch, fastTm))
+          << "days=" << days;
+      ASSERT_TRUE(WideRangeDateConversion::epochToCalendarUtc(epoch, wideTm))
+          << "days=" << days;
+      expectTmEqual(fastTm, wideTm, epoch);
+    }
+  }
+
+  // Inverse direction: ±10 years around kYearMin and kYearMax. The date
+  // is chosen per boundary to lie *one day outside* the algorithm's
+  // exact range [Mar 1 kYearMin, Feb 28 kYearMax] at the boundary year:
+  //   kYearMin → Feb 28 — one day before Mar 1 kYearMin
+  //   kYearMax → Mar  1 — one day after  Feb 28 kYearMax
+  // This way, a future relaxation of the dispatch from strict (`<`) to
+  // inclusive (`<=`) would route a UB input to the fast path at either
+  // boundary, and the fast/wide mismatch (or crash) would fail this
+  // test. A single in-range date for both boundaries would only catch
+  // the regression at one end.
+  const struct {
+    int32_t boundary;
+    uint32_t month;
+    uint32_t day;
+  } inverseBoundaries[] = {
+      {fast_date::kYearMin, 2u, 28u},
+      {fast_date::kYearMax, 3u, 1u},
+  };
+  for (const auto& bound : inverseBoundaries) {
+    for (int32_t delta = -10; delta <= 10; ++delta) {
+      const int32_t year = bound.boundary + delta;
+      const auto fastResult =
+          util::daysSinceEpochFromDate(year, bound.month, bound.day);
+      const auto wideResult = WideRangeDateConversion::daysSinceEpochFromDate(
+          year, bound.month, bound.day);
+      ASSERT_EQ(fastResult.hasError(), wideResult.hasError()) << "y=" << year;
+      if (!fastResult.hasError()) {
+        EXPECT_EQ(fastResult.value(), wideResult.value()) << "y=" << year;
+      }
+    }
+  }
+}
+
+} // namespace
+} // namespace facebook::velox::test
diff --git a/velox/type/tests/FilterBenchmark.cpp b/velox/type/tests/FilterBenchmark.cpp
index c699b4da1e9..2cc3f437150 100644
--- a/velox/type/tests/FilterBenchmark.cpp
+++ b/velox/type/tests/FilterBenchmark.cpp
@@ -14,15 +14,10 @@
  * limitations under the License.
  */
 
-#include <limits>
 #include "folly/Benchmark.h"
-#include "folly/Portability.h"
 #include "folly/Random.h"
-#include "folly/Varint.h"
 #include "folly/init/Init.h"
-#include "folly/lang/Bits.h"
-#include "velox/dwio/common/exception/Exception.h"
-
+#include "velox/common/base/SimdUtil.h"
 #include "velox/type/Filter.h"
 
 using namespace facebook::velox;
diff --git a/velox/type/tests/FilterSerDeTest.cpp b/velox/type/tests/FilterSerDeTest.cpp
index 0b4c52c1a90..21a7dfa9fb8 100644
--- a/velox/type/tests/FilterSerDeTest.cpp
+++ b/velox/type/tests/FilterSerDeTest.cpp
@@ -149,8 +149,9 @@ TEST_F(FilterSerDeTest, multiFilter) {
   std::vector<int64_t> values{3, 7, 18};
   filters.emplace_back(
       std::make_unique<BigintValuesUsingHashTable>(1, 10, values, true));
-  filters.emplace_back(std::make_unique<BytesRange>(
-      "ABCD", true, true, "FFFF", false, true, false));
+  filters.emplace_back(
+      std::make_unique<BytesRange>(
+          "ABCD", true, true, "FFFF", false, true, false));
 
   MultiRange multiRange(std::move(filters), true);
   testSerde(multiRange);
diff --git a/velox/type/tests/FilterTest.cpp b/velox/type/tests/FilterTest.cpp
index ac78b5f86f4..16989c83863 100644
--- a/velox/type/tests/FilterTest.cpp
+++ b/velox/type/tests/FilterTest.cpp
@@ -26,7 +26,9 @@
 
 #include <gtest/gtest.h>
 
-using namespace facebook::velox;
+namespace facebook::velox {
+namespace {
+
 using namespace facebook::velox::common;
 using namespace facebook::velox::exec;
 
@@ -39,8 +41,7 @@ TEST(FilterTest, alwaysFalse) {
   EXPECT_FALSE(alwaysFalse.testNull());
 
   EXPECT_EQ(
-      "Filter(AlwaysFalse, deterministic, null not allowed)",
-      alwaysFalse.toString());
+      "Filter(AlwaysFalse, deterministic, no nulls)", alwaysFalse.toString());
 }
 
 TEST(FilterTest, alwaysTrue) {
@@ -63,7 +64,7 @@ TEST(FilterTest, alwaysTrue) {
       simd::allSetBitMask<int16_t>(),
       simd::toBitMask(alwaysTrue.testValues(int16s)));
   EXPECT_EQ(
-      "Filter(AlwaysTrue, deterministic, null allowed)", alwaysTrue.toString());
+      "Filter(AlwaysTrue, deterministic, with nulls)", alwaysTrue.toString());
 }
 
 TEST(FilterTest, isNotNull) {
@@ -86,7 +87,7 @@ TEST(FilterTest, isNull) {
   EXPECT_FALSE(isNull.testInt128Range(0, 0, false));
   EXPECT_TRUE(isNull.testInt128Range(0, 0, true));
 
-  EXPECT_EQ("Filter(IsNull, deterministic, null allowed)", isNull.toString());
+  EXPECT_EQ("Filter(IsNull, deterministic, with nulls)", isNull.toString());
 }
 
 // Applies 'filter' to all T type lanes of 'values' and compares the result to
@@ -103,7 +104,7 @@ void checkSimd(const Filter* filter, const T* values, ScalarTest scalarTest) {
 
 TEST(FilterTest, bigIntRange) {
   // x = 1
-  auto filter = equal(1, false);
+  std::unique_ptr<common::Filter> filter = equal(1, false);
   auto testInt64 = [&](int64_t x) { return filter->testInt64(x); };
   EXPECT_TRUE(filter->testInt64(1));
 
@@ -211,6 +212,52 @@ TEST(FilterTest, bigIntRange) {
   }
 }
 
+TEST(FilterTest, bigIntRangeBoundaryOverflow) {
+  auto filter = greaterThan(std::numeric_limits<int64_t>::max());
+  EXPECT_EQ(filter->kind(), common::FilterKind::kAlwaysFalse);
+  EXPECT_FALSE(filter->testInt64(std::numeric_limits<int64_t>::max()));
+  EXPECT_FALSE(filter->testInt64(std::numeric_limits<int64_t>::min()));
+  EXPECT_FALSE(filter->testInt64(0));
+
+  filter = lessThan(std::numeric_limits<int64_t>::min());
+  EXPECT_EQ(filter->kind(), common::FilterKind::kAlwaysFalse);
+  EXPECT_FALSE(filter->testInt64(std::numeric_limits<int64_t>::min()));
+  EXPECT_FALSE(filter->testInt64(std::numeric_limits<int64_t>::max()));
+  EXPECT_FALSE(filter->testInt64(0));
+
+  filter = greaterThan(std::numeric_limits<int64_t>::max(), true);
+  EXPECT_EQ(filter->kind(), common::FilterKind::kIsNull);
+  EXPECT_FALSE(filter->testInt64(std::numeric_limits<int64_t>::max()));
+  EXPECT_TRUE(filter->testNull());
+
+  filter = lessThan(std::numeric_limits<int64_t>::min(), true);
+  EXPECT_EQ(filter->kind(), common::FilterKind::kIsNull);
+  EXPECT_FALSE(filter->testInt64(std::numeric_limits<int64_t>::min()));
+  EXPECT_TRUE(filter->testNull());
+
+  filter = greaterThan(std::numeric_limits<int64_t>::max() - 1);
+  EXPECT_EQ(filter->kind(), common::FilterKind::kBigintRange);
+  EXPECT_TRUE(filter->testInt64(std::numeric_limits<int64_t>::max()));
+  EXPECT_FALSE(filter->testInt64(std::numeric_limits<int64_t>::max() - 1));
+
+  filter = lessThan(std::numeric_limits<int64_t>::min() + 1);
+  EXPECT_EQ(filter->kind(), common::FilterKind::kBigintRange);
+  EXPECT_TRUE(filter->testInt64(std::numeric_limits<int64_t>::min()));
+  EXPECT_FALSE(filter->testInt64(std::numeric_limits<int64_t>::min() + 1));
+}
+
+TEST(FilterTest, hugeintRangeBoundaryOverflow) {
+  auto filter = greaterThanHugeint(std::numeric_limits<int128_t>::max());
+  EXPECT_EQ(filter->kind(), common::FilterKind::kAlwaysFalse);
+  EXPECT_FALSE(filter->testInt128(std::numeric_limits<int128_t>::max()));
+  EXPECT_FALSE(filter->testInt128(0));
+
+  filter = lessThanHugeint(std::numeric_limits<int128_t>::min());
+  EXPECT_EQ(filter->kind(), common::FilterKind::kAlwaysFalse);
+  EXPECT_FALSE(filter->testInt128(std::numeric_limits<int128_t>::min()));
+  EXPECT_FALSE(filter->testInt128(0));
+}
+
 TEST(FilterTest, negatedBigintRange) {
   auto filter = notEqual(1, false);
   EXPECT_FALSE(filter->testNull());
@@ -614,6 +661,70 @@ TEST(FilterTest, negatedBigintValuesEdgeCases) {
   EXPECT_TRUE(not_equal->testInt64(1));
 }
 
+TEST(FilterTest, bigintValuesUsingBloomFilter) {
+  BigintValuesUsingBloomFilter filter(10, false);
+  folly::F14FastSet<int64_t> inserted;
+  for (int64_t x : {2, 3, 5, 7, 11, 13, 17, 19}) {
+    filter.insert(x);
+    inserted.insert(x);
+  }
+  ASSERT_FALSE(filter.testNull());
+  for (int i = 0; i < 20; ++i) {
+    ASSERT_EQ(filter.testInt64(i), inserted.contains(i));
+  }
+  ASSERT_TRUE(filter.testInt64Range(20, 30, true));
+  ASSERT_TRUE(filter.testingEquals(filter));
+  Filter::registerSerDe();
+  auto serialized = filter.serialize();
+  auto deserialized =
+      ISerializable::deserialize<BigintValuesUsingBloomFilter>(serialized);
+  ASSERT_TRUE(deserialized->testingEquals(filter));
+  ASSERT_FALSE(filter.testInt64(23));
+  filter.insert(23);
+  ASSERT_TRUE(filter.testInt64(23));
+  ASSERT_FALSE(deserialized->testingEquals(filter));
+  ASSERT_TRUE(filter.clone(std::nullopt)->testingEquals(filter));
+  auto nullAllowedClone = filter.clone(true);
+  ASSERT_TRUE(nullAllowedClone->testNull());
+  ASSERT_TRUE(nullAllowedClone->clone(false)->testingEquals(filter));
+}
+
+TEST(FilterTest, bigintValuesUsingBloomFilterMergeWith) {
+  BigintValuesUsingBloomFilter filter(4, false);
+  for (int64_t x : {2, 3, 5, 7}) {
+    filter.insert(x);
+  }
+  auto test = [&](const Filter& other, const Filter& expected) {
+    auto merged = filter.mergeWith(&other);
+    ASSERT_TRUE(merged->testingEquals(expected));
+    auto merged2 = other.mergeWith(&filter);
+    ASSERT_TRUE(merged->testingEquals(*merged2));
+  };
+  {
+    SCOPED_TRACE("BigintRange");
+    test(BigintRange(2, 5, true), *createBigintValues({2, 3, 5}, false));
+  }
+  {
+    SCOPED_TRACE("Huge BigintRange");
+    BigintRange other(-1, INT64_MAX, true);
+    test(other, other);
+  }
+  {
+    SCOPED_TRACE("BigintValuesUsingHashTable");
+    std::vector<int64_t> otherValues = {INT64_MIN, 0, 3, 6, 9, INT64_MAX};
+    BigintValuesUsingHashTable other(
+        otherValues.front(), otherValues.back(), otherValues, true);
+    test(other, *createBigintValues({3}, false));
+  }
+  {
+    SCOPED_TRACE("BigintValuesUsingBitmask");
+    std::vector<int64_t> otherValues = {0, 3, 6, 9};
+    BigintValuesUsingBitmask other(
+        otherValues.front(), otherValues.back(), otherValues, true);
+    test(other, *createBigintValues({3}, false));
+  }
+}
+
 TEST(FilterTest, bigintMultiRange) {
   // x between 1 and 10 or x between 100 and 120
   auto filter = bigintOr(between(1, 10), between(100, 120));
@@ -639,6 +750,71 @@ TEST(FilterTest, bigintMultiRange) {
   EXPECT_FALSE(filter->testInt64Range(15, 45, true));
 }
 
+TEST(FilterTest, bigintOrWithBoundaryOverflow) {
+  auto filter = bigintOr(
+      greaterThan(std::numeric_limits<int64_t>::max()), between(1, 10));
+  EXPECT_EQ(filter->kind(), common::FilterKind::kBigintRange);
+  EXPECT_TRUE(filter->testInt64(5));
+  EXPECT_FALSE(filter->testInt64(50));
+
+  filter =
+      bigintOr(between(1, 10), lessThan(std::numeric_limits<int64_t>::min()));
+  EXPECT_EQ(filter->kind(), common::FilterKind::kBigintRange);
+  EXPECT_TRUE(filter->testInt64(5));
+  EXPECT_FALSE(filter->testInt64(50));
+
+  filter = bigintOr(
+      greaterThan(std::numeric_limits<int64_t>::max()),
+      lessThan(std::numeric_limits<int64_t>::min()));
+  EXPECT_EQ(filter->kind(), common::FilterKind::kAlwaysFalse);
+  EXPECT_FALSE(filter->testInt64(0));
+  EXPECT_FALSE(filter->testInt64(std::numeric_limits<int64_t>::max()));
+  EXPECT_FALSE(filter->testInt64(std::numeric_limits<int64_t>::min()));
+
+  filter = bigintOr(
+      greaterThan(std::numeric_limits<int64_t>::max(), true),
+      lessThan(std::numeric_limits<int64_t>::min(), true));
+  EXPECT_EQ(filter->kind(), common::FilterKind::kIsNull);
+  EXPECT_FALSE(filter->testInt64(0));
+  EXPECT_TRUE(filter->testNull());
+
+  filter = bigintOr(
+      greaterThan(std::numeric_limits<int64_t>::max()),
+      lessThan(std::numeric_limits<int64_t>::min(), true));
+  EXPECT_EQ(filter->kind(), common::FilterKind::kIsNull);
+  EXPECT_FALSE(filter->testInt64(0));
+  EXPECT_TRUE(filter->testNull());
+
+  filter = bigintOr(
+      greaterThan(std::numeric_limits<int64_t>::max(), true),
+      lessThan(std::numeric_limits<int64_t>::min()));
+  EXPECT_EQ(filter->kind(), common::FilterKind::kIsNull);
+  EXPECT_FALSE(filter->testInt64(0));
+  EXPECT_TRUE(filter->testNull());
+
+  filter = bigintOr(
+      greaterThan(std::numeric_limits<int64_t>::max(), true), between(1, 10));
+  EXPECT_EQ(filter->kind(), common::FilterKind::kBigintRange);
+  EXPECT_TRUE(filter->testInt64(5));
+  EXPECT_FALSE(filter->testInt64(50));
+  EXPECT_TRUE(filter->testNull());
+
+  filter = bigintOr(
+      between(1, 10), lessThan(std::numeric_limits<int64_t>::min(), true));
+  EXPECT_EQ(filter->kind(), common::FilterKind::kBigintRange);
+  EXPECT_TRUE(filter->testInt64(5));
+  EXPECT_FALSE(filter->testInt64(50));
+  EXPECT_TRUE(filter->testNull());
+
+  filter = bigintOr(
+      greaterThan(std::numeric_limits<int64_t>::max()),
+      lessThan(std::numeric_limits<int64_t>::min()),
+      between(100, 200));
+  EXPECT_EQ(filter->kind(), common::FilterKind::kBigintRange);
+  EXPECT_TRUE(filter->testInt64(150));
+  EXPECT_FALSE(filter->testInt64(50));
+}
+
 TEST(FilterTest, boolValue) {
   auto boolValueTrue = boolEqual(true);
   EXPECT_TRUE(boolValueTrue->testBool(true));
@@ -725,6 +901,32 @@ TEST(FilterTest, doubleRange) {
   EXPECT_FALSE(filter->testDouble(1));
   EXPECT_TRUE(filter->testDouble(3));
   EXPECT_TRUE(filter->testDouble(100));
+
+  // Test DoubleRange filter with float batch (schema evolution slow path).
+  // When a double filter is applied to float data, it falls back to
+  // element-by-element testing instead of SIMD batch processing.
+  filter = betweenDouble(1.2, 3.4);
+  {
+    auto verifyFloat = [&](float x) { return filter->testFloat(x); };
+    float n8[] = {1.0f, std::nanf("nan"), 3.4f, 3.1f, -1e20f, 0.0f, 1.1f, 1.2f};
+    checkSimd(filter.get(), n8, verifyFloat);
+  }
+
+  filter = lessThanOrEqualDouble(1.2);
+  {
+    auto verifyFloat = [&](float x) { return filter->testFloat(x); };
+    float n8[] = {
+        1.0f, std::nanf("nan"), 1.3f, 1e20f, -1e20f, 0.0f, 1.1f, 1.2f};
+    checkSimd(filter.get(), n8, verifyFloat);
+  }
+
+  filter = greaterThanDouble(1.2);
+  {
+    auto verifyFloat = [&](float x) { return filter->testFloat(x); };
+    float n8[] = {
+        1.0f, std::nanf("nan"), 1.3f, 1e20f, -1e20f, 0.0f, 1.1f, 1.2f};
+    checkSimd(filter.get(), n8, verifyFloat);
+  }
 }
 
 TEST(FilterTest, floatRange) {
@@ -792,11 +994,17 @@ TEST(FilterTest, floatRange) {
   EXPECT_TRUE(filter->testFloat(100));
 }
 
+bool testBytes(const Filter& filter, std::string_view value) {
+  bool result = filter.testBytes(value.data(), value.size());
+  VELOX_CHECK_EQ(filter.testStringView(StringView(value)), result);
+  return result;
+}
+
 TEST(FilterTest, bytesRange) {
   {
     auto filter = equal("abc");
-    EXPECT_TRUE(filter->testBytes("abc", 3));
-    EXPECT_FALSE(filter->testBytes("acb", 3));
+    EXPECT_TRUE(testBytes(*filter, "abc"));
+    EXPECT_FALSE(testBytes(*filter, "acb"));
     EXPECT_TRUE(filter->testLength(3));
     // The bit for lane 2 should be set.
     int32_t lens[] = {0, 1, 3, 0, 4, 10, 11, 12};
@@ -804,8 +1012,8 @@ TEST(FilterTest, bytesRange) {
         4, simd::toBitMask(filter->testLengths(xsimd::load_unaligned(lens))));
 
     EXPECT_FALSE(filter->testNull());
-    EXPECT_FALSE(filter->testBytes("apple", 5));
-    EXPECT_FALSE(filter->testBytes(nullptr, 0));
+    EXPECT_FALSE(testBytes(*filter, "apple"));
+    EXPECT_FALSE(testBytes(*filter, {}));
     EXPECT_FALSE(filter->testLength(4));
 
     EXPECT_TRUE(filter->testBytesRange("abc", "abc", false));
@@ -824,132 +1032,132 @@ TEST(FilterTest, bytesRange) {
 
     // = ''
     filter = equal("");
-    EXPECT_TRUE(filter->testBytes(nullptr, 0));
-    EXPECT_FALSE(filter->testBytes("abc", 3));
+    EXPECT_TRUE(testBytes(*filter, {}));
+    EXPECT_FALSE(testBytes(*filter, "abc"));
   }
 
   char const* theBestOfTimes =
       "It was the best of times, it was the worst of times, it was the age of wisdom, it was the age of foolishness, it was the epoch of belief, it was the epoch of incredulity,...";
   auto filter = lessThanOrEqual(theBestOfTimes);
-  EXPECT_TRUE(filter->testBytes(theBestOfTimes, std::strlen(theBestOfTimes)));
-  EXPECT_TRUE(filter->testBytes(theBestOfTimes, 5));
-  EXPECT_TRUE(filter->testBytes(theBestOfTimes, 50));
-  EXPECT_TRUE(filter->testBytes(theBestOfTimes, 100));
+  EXPECT_TRUE(testBytes(*filter, theBestOfTimes));
+  EXPECT_TRUE(testBytes(*filter, {theBestOfTimes, 5}));
+  EXPECT_TRUE(testBytes(*filter, {theBestOfTimes, 50}));
+  EXPECT_TRUE(testBytes(*filter, {theBestOfTimes, 100}));
   // testLength is true of all lengths for a range filter.
   EXPECT_TRUE(filter->testLength(1));
   EXPECT_TRUE(filter->testLength(1000));
 
   EXPECT_FALSE(filter->testNull());
-  EXPECT_FALSE(filter->testBytes("Zzz", 3));
-  EXPECT_FALSE(filter->testBytes("It was the best of times, zzz", 30));
+  EXPECT_FALSE(testBytes(*filter, "Zzz"));
+  EXPECT_FALSE(testBytes(*filter, {"It was the best of times, zzz", 30}));
 
   EXPECT_TRUE(filter->testBytesRange("Apple", "banana", false));
   EXPECT_FALSE(filter->testBytesRange("Pear", "Plum", false));
   EXPECT_FALSE(filter->testBytesRange("apple", "banana", false));
 
   filter = greaterThanOrEqual("abc");
-  EXPECT_TRUE(filter->testBytes("abc", 3));
-  EXPECT_TRUE(filter->testBytes("ad", 2));
-  EXPECT_TRUE(filter->testBytes("apple", 5));
-  EXPECT_TRUE(filter->testBytes("banana", 6));
+  EXPECT_TRUE(testBytes(*filter, "abc"));
+  EXPECT_TRUE(testBytes(*filter, "ad"));
+  EXPECT_TRUE(testBytes(*filter, "apple"));
+  EXPECT_TRUE(testBytes(*filter, "banana"));
 
   EXPECT_FALSE(filter->testNull());
-  EXPECT_FALSE(filter->testBytes("ab", 2));
-  EXPECT_FALSE(filter->testBytes("_abc", 4));
+  EXPECT_FALSE(testBytes(*filter, "ab"));
+  EXPECT_FALSE(testBytes(*filter, "_abc"));
 
   filter = between("apple", "banana");
-  EXPECT_TRUE(filter->testBytes("apple", 5));
-  EXPECT_TRUE(filter->testBytes("banana", 6));
-  EXPECT_TRUE(filter->testBytes("avocado", 7));
+  EXPECT_TRUE(testBytes(*filter, "apple"));
+  EXPECT_TRUE(testBytes(*filter, "banana"));
+  EXPECT_TRUE(testBytes(*filter, "avocado"));
 
   EXPECT_FALSE(filter->testNull());
-  EXPECT_FALSE(filter->testBytes("camel", 5));
-  EXPECT_FALSE(filter->testBytes("_abc", 4));
+  EXPECT_FALSE(testBytes(*filter, "camel"));
+  EXPECT_FALSE(testBytes(*filter, "_abc"));
 
   filter = std::make_unique<BytesRange>(
       "apple", false, true, "banana", false, false, false);
-  EXPECT_TRUE(filter->testBytes("banana", 6));
-  EXPECT_TRUE(filter->testBytes("avocado", 7));
+  EXPECT_TRUE(testBytes(*filter, "banana"));
+  EXPECT_TRUE(testBytes(*filter, "avocado"));
 
   EXPECT_FALSE(filter->testNull());
-  EXPECT_FALSE(filter->testBytes("apple", 5));
-  EXPECT_FALSE(filter->testBytes("camel", 5));
-  EXPECT_FALSE(filter->testBytes("_abc", 4));
+  EXPECT_FALSE(testBytes(*filter, "apple"));
+  EXPECT_FALSE(testBytes(*filter, "camel"));
+  EXPECT_FALSE(testBytes(*filter, "_abc"));
 
   filter = std::make_unique<BytesRange>(
       "apple", false, true, "banana", false, true, false);
-  EXPECT_TRUE(filter->testBytes("avocado", 7));
+  EXPECT_TRUE(testBytes(*filter, "avocado"));
 
   EXPECT_FALSE(filter->testNull());
-  EXPECT_FALSE(filter->testBytes("apple", 5));
-  EXPECT_FALSE(filter->testBytes("banana", 6));
-  EXPECT_FALSE(filter->testBytes("camel", 5));
-  EXPECT_FALSE(filter->testBytes("_abc", 4));
+  EXPECT_FALSE(testBytes(*filter, "apple"));
+  EXPECT_FALSE(testBytes(*filter, "banana"));
+  EXPECT_FALSE(testBytes(*filter, "camel"));
+  EXPECT_FALSE(testBytes(*filter, "_abc"));
 
   // < b
   filter = lessThan("b");
-  EXPECT_TRUE(filter->testBytes("a", 1));
-  EXPECT_FALSE(filter->testBytes("b", 1));
-  EXPECT_FALSE(filter->testBytes("c", 1));
-  EXPECT_TRUE(filter->testBytes(nullptr, 0));
+  EXPECT_TRUE(testBytes(*filter, "a"));
+  EXPECT_FALSE(testBytes(*filter, "b"));
+  EXPECT_FALSE(testBytes(*filter, "c"));
+  EXPECT_TRUE(testBytes(*filter, {}));
   EXPECT_FALSE(filter->testBytesRange("b", "c", false));
 
   // <= b
   filter = lessThanOrEqual("b");
-  EXPECT_TRUE(filter->testBytes("a", 1));
-  EXPECT_TRUE(filter->testBytes("b", 1));
-  EXPECT_FALSE(filter->testBytes("c", 1));
-  EXPECT_TRUE(filter->testBytes(nullptr, 0));
+  EXPECT_TRUE(testBytes(*filter, "a"));
+  EXPECT_TRUE(testBytes(*filter, "b"));
+  EXPECT_FALSE(testBytes(*filter, "c"));
+  EXPECT_TRUE(testBytes(*filter, {}));
   EXPECT_TRUE(filter->testBytesRange("b", "c", false));
 
   // >= b
   filter = greaterThanOrEqual("b");
-  EXPECT_FALSE(filter->testBytes("a", 1));
-  EXPECT_TRUE(filter->testBytes("b", 1));
-  EXPECT_TRUE(filter->testBytes("c", 1));
-  EXPECT_FALSE(filter->testBytes(nullptr, 0));
+  EXPECT_FALSE(testBytes(*filter, "a"));
+  EXPECT_TRUE(testBytes(*filter, "b"));
+  EXPECT_TRUE(testBytes(*filter, "c"));
+  EXPECT_FALSE(testBytes(*filter, {}));
   EXPECT_TRUE(filter->testBytesRange("a", "b", false));
 
   // > b
   filter = greaterThan("b");
-  EXPECT_FALSE(filter->testBytes("a", 1));
-  EXPECT_FALSE(filter->testBytes("b", 1));
-  EXPECT_TRUE(filter->testBytes("c", 1));
-  EXPECT_FALSE(filter->testBytes(nullptr, 0));
+  EXPECT_FALSE(testBytes(*filter, "a"));
+  EXPECT_FALSE(testBytes(*filter, "b"));
+  EXPECT_TRUE(testBytes(*filter, "c"));
+  EXPECT_FALSE(testBytes(*filter, {}));
   EXPECT_FALSE(filter->testBytesRange("a", "b", false));
 
   // < ''
   filter = lessThan("");
-  EXPECT_FALSE(filter->testBytes(nullptr, 0));
-  EXPECT_FALSE(filter->testBytes("abc", 3));
+  EXPECT_FALSE(testBytes(*filter, {}));
+  EXPECT_FALSE(testBytes(*filter, "abc"));
 
   // <= ''
   filter = lessThanOrEqual("");
-  EXPECT_TRUE(filter->testBytes(nullptr, 0));
-  EXPECT_FALSE(filter->testBytes("abc", 3));
+  EXPECT_TRUE(testBytes(*filter, {}));
+  EXPECT_FALSE(testBytes(*filter, "abc"));
 
   // > ''
   filter = greaterThan("");
-  EXPECT_FALSE(filter->testBytes(nullptr, 0));
-  EXPECT_TRUE(filter->testBytes("abc", 3));
+  EXPECT_FALSE(testBytes(*filter, {}));
+  EXPECT_TRUE(testBytes(*filter, "abc"));
 
   // >= ''
   filter = greaterThanOrEqual("");
-  EXPECT_TRUE(filter->testBytes(nullptr, 0));
-  EXPECT_TRUE(filter->testBytes("abc", 3));
+  EXPECT_TRUE(testBytes(*filter, {}));
+  EXPECT_TRUE(testBytes(*filter, "abc"));
 }
 
 TEST(FilterTest, negatedBytesRange) {
   auto filter = notBetween("a", "c");
 
-  EXPECT_TRUE(filter->testBytes("A", 1));
-  EXPECT_TRUE(filter->testBytes(nullptr, 0));
-  EXPECT_TRUE(filter->testBytes("ca", 2));
-  EXPECT_TRUE(filter->testBytes("z", 1));
+  EXPECT_TRUE(testBytes(*filter, "A"));
+  EXPECT_TRUE(testBytes(*filter, {}));
+  EXPECT_TRUE(testBytes(*filter, "ca"));
+  EXPECT_TRUE(testBytes(*filter, "z"));
 
-  EXPECT_FALSE(filter->testBytes("a", 1));
-  EXPECT_FALSE(filter->testBytes("apple", 5));
-  EXPECT_FALSE(filter->testBytes("c", 1));
+  EXPECT_FALSE(testBytes(*filter, "a"));
+  EXPECT_FALSE(testBytes(*filter, "apple"));
+  EXPECT_FALSE(testBytes(*filter, "c"));
   EXPECT_FALSE(filter->testNull());
 
   EXPECT_TRUE(filter->testLength(1));
@@ -974,8 +1182,8 @@ TEST(FilterTest, negatedBytesRange) {
   EXPECT_FALSE(filter->isUpperExclusive());
 
   filter = notBetweenExclusive("b", "d");
-  EXPECT_TRUE(filter->testBytes("b", 1));
-  EXPECT_TRUE(filter->testBytes("d", 1));
+  EXPECT_TRUE(testBytes(*filter, "b"));
+  EXPECT_TRUE(testBytes(*filter, "d"));
 
   EXPECT_TRUE(filter->testBytesRange("b", "c", false));
   EXPECT_TRUE(filter->testBytesRange("c", "d", false));
@@ -1565,6 +1773,16 @@ TEST(FilterTest, mergeWithBigint) {
   filters.push_back(notIn({empty - 5, empty, empty + 5}, true));
   filters.push_back(notIn({5, 498, 499, 500}, false));
 
+  const int64_t kInt64Min = std::numeric_limits<int64_t>::min();
+  const int64_t kInt64Max = std::numeric_limits<int64_t>::max();
+  filters.push_back(notIn({kInt64Min, -1}));
+  filters.push_back(notIn({kInt64Min, -1}, true));
+  filters.push_back(notIn({1, kInt64Max}));
+  filters.push_back(notIn({1, kInt64Max}, true));
+  filters.push_back(notIn({kInt64Min, kInt64Max}));
+  filters.push_back(between(kInt64Min, 0));
+  filters.push_back(between(0, kInt64Max));
+
   for (const auto& left : filters) {
     for (const auto& right : filters) {
       testMergeWithBigint(left.get(), right.get());
@@ -1897,7 +2115,8 @@ TEST(FilterTest, mergeWithBytesMultiRange) {
 }
 
 TEST(FilterTest, hugeIntRange) {
-  auto filter = equalHugeint(HugeInt::build(1, 1), false);
+  std::unique_ptr<common::Filter> filter =
+      equalHugeint(HugeInt::build(1, 1), false);
   auto max = DecimalUtil::kLongDecimalMax;
   auto min = DecimalUtil::kLongDecimalMin;
 
@@ -1987,7 +2206,8 @@ TEST(FilterTest, dateRange) {
 
 TEST(FilterTest, timestampRange) {
   // x = timestamp '1970-01-01 00:00:10.123'
-  auto filter = equal(Timestamp(10, 123000000), false);
+  std::unique_ptr<common::Filter> filter =
+      equal(Timestamp(10, 123000000), false);
   EXPECT_FALSE(filter->testNull());
 
   EXPECT_TRUE(filter->testTimestamp(Timestamp(10, 123000000)));
@@ -2039,3 +2259,6 @@ TEST(FilterTest, timestampRange) {
   EXPECT_TRUE(filter->testTimestampRange(
       Timestamp(5, 123000000), Timestamp(30, 123000000), true));
 }
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/type/tests/HugeIntTest.cpp b/velox/type/tests/HugeIntTest.cpp
index 274f5c90d0e..9648f9eeeb3 100644
--- a/velox/type/tests/HugeIntTest.cpp
+++ b/velox/type/tests/HugeIntTest.cpp
@@ -16,7 +16,6 @@
 
 #include "velox/type/HugeInt.h"
 #include <gtest/gtest.h>
-#include "velox/common/base/tests/GTestUtils.h"
 
 using namespace facebook;
 using namespace facebook::velox;
@@ -32,6 +31,19 @@ void testParse(int128_t hugeInt, const std::string& hugeString) {
   EXPECT_EQ(hugeInt, HugeInt::parse(hugeString));
   EXPECT_EQ(hugeString, std::to_string(hugeInt));
 }
+
+void testParseError(
+    const std::string& input,
+    const std::string& expectedMessage,
+    const std::string& expectedTemplate) {
+  try {
+    HugeInt::parse(input);
+    FAIL() << "Expected exception for input: " << input;
+  } catch (const VeloxRuntimeError& e) {
+    EXPECT_NE(e.message().find(expectedMessage), std::string::npos);
+    EXPECT_EQ(e.messageTemplate(), expectedTemplate);
+  }
+}
 } // namespace
 
 TEST(HugeIntTest, basic) {
@@ -83,17 +95,24 @@ TEST(HugeIntTest, parse) {
   hugeInt = HugeInt::build(0x80DEADBEEFBADFEE, 0xDDEADBEEFBADFEED);
   testParse(hugeInt, "-168984969573469355505154650711096688915");
 
-  VELOX_ASSERT_THROW(
-      HugeInt::parse("1A"), "Invalid character A in the string.");
-  VELOX_ASSERT_THROW(
-      HugeInt::parse(""), "Empty string cannot be converted to int128_t");
-  VELOX_ASSERT_THROW(
-      testParse(hugeInt, "-170141183460469231731687303715884105729"),
-      "out of range of int128_t");
-  VELOX_ASSERT_THROW(
-      testParse(hugeInt, "170141183460469231731687303715884105728"),
-      "out of range of int128_t");
-  VELOX_ASSERT_THROW(
-      testParse(hugeInt, "170141183460469231731687303715884105730"),
-      "out of range of int128_t");
+  testParseError(
+      "1A",
+      "Invalid character A in the string.",
+      "Invalid character {} in the string.");
+  testParseError(
+      "",
+      "Empty string cannot be converted to int128_t",
+      "Empty string cannot be converted to int128_t.");
+  testParseError(
+      "-170141183460469231731687303715884105729",
+      "out of range of int128_t",
+      "Value is out of range of int128_t: {}");
+  testParseError(
+      "170141183460469231731687303715884105728",
+      "out of range of int128_t",
+      "Value is out of range of int128_t: {}");
+  testParseError(
+      "170141183460469231731687303715884105730",
+      "out of range of int128_t",
+      "Value is out of range of int128_t: {}");
 }
diff --git a/velox/type/tests/NegatedBigintRangeBenchmark.cpp b/velox/type/tests/NegatedBigintRangeBenchmark.cpp
index 7da7b4073a7..34e2f24cc49 100644
--- a/velox/type/tests/NegatedBigintRangeBenchmark.cpp
+++ b/velox/type/tests/NegatedBigintRangeBenchmark.cpp
@@ -127,10 +127,12 @@ int32_t main(int32_t argc, char* argv[]) {
 
   negatedRangeNeq = std::make_unique<NegatedBigintRange>(0, 0, false);
   std::vector<std::unique_ptr<BigintRange>> zeroRanges;
-  zeroRanges.emplace_back(std::make_unique<BigintRange>(
-      std::numeric_limits<int64_t>::min(), -1, false));
-  zeroRanges.emplace_back(std::make_unique<BigintRange>(
-      1, std::numeric_limits<int64_t>::max(), false));
+  zeroRanges.emplace_back(
+      std::make_unique<BigintRange>(
+          std::numeric_limits<int64_t>::min(), -1, false));
+  zeroRanges.emplace_back(
+      std::make_unique<BigintRange>(
+          1, std::numeric_limits<int64_t>::max(), false));
   multiRangeNeq =
       std::make_unique<BigintMultiRange>(std::move(zeroRanges), false);
 
@@ -151,13 +153,18 @@ int32_t main(int32_t argc, char* argv[]) {
 
   for (int i = 0; i < rangeBounds.size(); ++i) {
     filterSizeIndices[rangeBounds[i]] = i;
-    negatedRanges.emplace_back(std::make_unique<NegatedBigintRange>(
-        -1 * rangeBounds[i], rangeBounds[i], false));
+    negatedRanges.emplace_back(
+        std::make_unique<NegatedBigintRange>(
+            -1 * rangeBounds[i], rangeBounds[i], false));
     std::vector<std::unique_ptr<BigintRange>> ranges;
-    ranges.emplace_back(std::make_unique<BigintRange>(
-        std::numeric_limits<int64_t>::min(), -1 * (rangeBounds[i] + 1), false));
-    ranges.emplace_back(std::make_unique<BigintRange>(
-        rangeBounds[i] + 1, std::numeric_limits<int64_t>::max(), false));
+    ranges.emplace_back(
+        std::make_unique<BigintRange>(
+            std::numeric_limits<int64_t>::min(),
+            -1 * (rangeBounds[i] + 1),
+            false));
+    ranges.emplace_back(
+        std::make_unique<BigintRange>(
+            rangeBounds[i] + 1, std::numeric_limits<int64_t>::max(), false));
     multiRanges.emplace_back(
         std::make_unique<BigintMultiRange>(std::move(ranges), false));
   }
diff --git a/velox/type/tests/NegatedBytesRangeBenchmark.cpp b/velox/type/tests/NegatedBytesRangeBenchmark.cpp
index 8459e6db74e..d5053f244c3 100644
--- a/velox/type/tests/NegatedBytesRangeBenchmark.cpp
+++ b/velox/type/tests/NegatedBytesRangeBenchmark.cpp
@@ -160,15 +160,18 @@ int32_t main(int32_t argc, char** argv) {
       std::string hi = string_pool[kStringPoolSize * (50 + pct / 2) / 100];
 
       // create NegatedBytesRange filter
-      negateds.emplace_back(std::make_unique<common::NegatedBytesRange>(
-          lo, false, false, hi, false, true, false));
+      negateds.emplace_back(
+          std::make_unique<common::NegatedBytesRange>(
+              lo, false, false, hi, false, true, false));
 
       // create MultiRange filter
       std::vector<std::unique_ptr<common::Filter>> rangeFilters;
-      rangeFilters.emplace_back(std::make_unique<common::BytesRange>(
-          "", true, false, lo, false, true, false));
-      rangeFilters.emplace_back(std::make_unique<common::BytesRange>(
-          hi, false, false, "", true, false, false));
+      rangeFilters.emplace_back(
+          std::make_unique<common::BytesRange>(
+              "", true, false, lo, false, true, false));
+      rangeFilters.emplace_back(
+          std::make_unique<common::BytesRange>(
+              hi, false, false, "", true, false, false));
       multiRanges.emplace_back(
           std::make_unique<common::MultiRange>(std::move(rangeFilters), false));
 
diff --git a/velox/type/tests/NegatedBytesValuesBenchmark.cpp b/velox/type/tests/NegatedBytesValuesBenchmark.cpp
index 78da7f714dc..5f917f31a66 100644
--- a/velox/type/tests/NegatedBytesValuesBenchmark.cpp
+++ b/velox/type/tests/NegatedBytesValuesBenchmark.cpp
@@ -167,18 +167,22 @@ int32_t main(int32_t argc, char* argv[]) {
       std::vector<std::unique_ptr<common::Filter>> range_filters;
       auto front = ++(reject_vector.begin());
       auto back = reject_vector.begin();
-      range_filters.emplace_back(std::make_unique<common::BytesRange>(
-          "", true, true, *back, false, true, false));
+      range_filters.emplace_back(
+          std::make_unique<common::BytesRange>(
+              "", true, true, *back, false, true, false));
       while (front != reject_vector.end()) {
-        range_filters.emplace_back(std::make_unique<common::BytesRange>(
-            *back, false, true, *front, false, true, false));
+        range_filters.emplace_back(
+            std::make_unique<common::BytesRange>(
+                *back, false, true, *front, false, true, false));
         ++front;
         ++back;
       }
-      range_filters.emplace_back(std::make_unique<common::BytesRange>(
-          *back, false, true, "", true, true, false));
-      multi_ranges.emplace_back(std::make_unique<common::MultiRange>(
-          std::move(range_filters), false));
+      range_filters.emplace_back(
+          std::make_unique<common::BytesRange>(
+              *back, false, true, "", true, true, false));
+      multi_ranges.emplace_back(
+          std::make_unique<common::MultiRange>(
+              std::move(range_filters), false));
 
       LOG(INFO) << "Generated filter for length " << len << " with size "
                 << size;
diff --git a/velox/type/tests/NegatedValuesFilterBenchmark.cpp b/velox/type/tests/NegatedValuesFilterBenchmark.cpp
index 62393b9124b..8f1e99ed402 100644
--- a/velox/type/tests/NegatedValuesFilterBenchmark.cpp
+++ b/velox/type/tests/NegatedValuesFilterBenchmark.cpp
@@ -145,14 +145,17 @@ int32_t main(int32_t argc, char* argv[]) {
     subfilters.reserve(kFilterSizes[i]);
     int64_t start = std::numeric_limits<int64_t>::min();
     for (auto j = 0; j < kFilterSizes[i]; ++j) {
-      subfilters.emplace_back(std::make_unique<common::BigintRange>(
-          start, rejectedValues[i][j] - 1, false));
+      subfilters.emplace_back(
+          std::make_unique<common::BigintRange>(
+              start, rejectedValues[i][j] - 1, false));
       start = rejectedValues[i][j] + 1;
     }
-    subfilters.emplace_back(std::make_unique<common::BigintRange>(
-        start, std::numeric_limits<int64_t>::max(), false));
-    multiRangeFilters.emplace_back(std::make_unique<common::BigintMultiRange>(
-        std::move(subfilters), false));
+    subfilters.emplace_back(
+        std::make_unique<common::BigintRange>(
+            start, std::numeric_limits<int64_t>::max(), false));
+    multiRangeFilters.emplace_back(
+        std::make_unique<common::BigintMultiRange>(
+            std::move(subfilters), false));
   }
 
   veryDenseValues.resize(kNumValues);
diff --git a/velox/type/tests/OpaqueCustomTypesTest.cpp b/velox/type/tests/OpaqueCustomTypesTest.cpp
new file mode 100644
index 00000000000..bf5268f4a90
--- /dev/null
+++ b/velox/type/tests/OpaqueCustomTypesTest.cpp
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/dynamic.h>
+#include <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/type/OpaqueCustomTypes.h"
+#include "velox/type/Variant.h"
+
+namespace facebook::velox {
+namespace {
+
+class OpaqueCustomTypeTest : public testing::Test {
+ public:
+  OpaqueCustomTypeTest()
+      : testCustomType_(TestCustomTypeRegister::VeloxType::get()) {}
+
+ protected:
+  struct TestCustomType {
+    std::string name;
+
+    bool operator==(const TestCustomType& other) const {
+      return name == other.name;
+    }
+
+    folly::dynamic serialize() const {
+      folly::dynamic obj = folly::dynamic::object();
+      obj["name"] = name;
+      return obj;
+    }
+
+    static std::shared_ptr<TestCustomType> create(const folly::dynamic& obj) {
+      return std::make_shared<TestCustomType>(obj["name"].asString());
+    }
+  };
+
+  static constexpr char testCustomTypeName[] = "my_test_custom_type";
+  using TestCustomTypeRegister =
+      OpaqueCustomTypeRegister<TestCustomType, testCustomTypeName>;
+
+  TestCustomTypeRegister::VeloxTypePtr testCustomType_;
+
+  void testUnregisterType() {
+    TestCustomTypeRegister::unregisterType();
+    ASSERT_EQ(getCustomType(testCustomTypeName, {}), nullptr);
+    VELOX_ASSERT_THROW(
+        testCustomType_->getSerializeFunc(),
+        "No serialization function registered for my_test_custom_type");
+    VELOX_ASSERT_THROW(
+        testCustomType_->getDeserializeFunc(),
+        "No deserialization function registered for my_test_custom_type");
+  }
+
+  void testTypeSerde() {
+    auto serializedCustomType = testCustomType_->serialize();
+    EXPECT_EQ(testCustomType_->name(), serializedCustomType["type"]);
+    auto deserializedType = Type::create(serializedCustomType);
+    EXPECT_EQ(testCustomType_, deserializedType);
+  }
+};
+
+TEST_F(OpaqueCustomTypeTest, registerWithoutSerde) {
+  // Register type without serialization/deserialization and build a TypePtr.
+  TestCustomTypeRegister::registerType();
+  testTypeSerde();
+  testUnregisterType();
+}
+
+TEST_F(OpaqueCustomTypeTest, registerWithSerde) {
+  // Register type with serialization/deserialization and build a TypePtr.
+  TestCustomTypeRegister::registerType(
+      /*serializeValueFunc=*/
+      [](const auto& obj) { return folly::toJson(obj->serialize()); },
+      /*deserializeValueFunc=*/
+      [](const auto& str) {
+        return TestCustomType::create(folly::parseJson(str));
+      });
+
+  // Test value serialization/deserialization, with serde functions provided in
+  // TestCustomTypeRegister::registerType() method.
+  auto original = std::make_shared<TestCustomType>("test");
+  auto opaque = Variant::create(Variant::opaque(original).serialize())
+                    .value<TypeKind::OPAQUE>()
+                    .obj;
+  auto copy = std::static_pointer_cast<TestCustomType>(opaque);
+  EXPECT_EQ(*original, *copy);
+
+  testTypeSerde();
+  testUnregisterType();
+}
+
+TEST_F(OpaqueCustomTypeTest, registerWithIncompleteSerde) {
+  VELOX_ASSERT_THROW(
+      TestCustomTypeRegister::registerType(
+          /*serializeValueFunc=*/nullptr,
+          /*deserializeValueFunc=*/
+          [](const auto& str) {
+            return TestCustomType::create(folly::parseJson(str));
+          }),
+      "Both serialization and deserialization functions need to be registered for custom type my_test_custom_type");
+
+  VELOX_ASSERT_THROW(
+      TestCustomTypeRegister::registerType(
+          /*serializeValueFunc=*/
+          [](const auto& obj) { return folly::toJson(obj->serialize()); },
+          /*deserializeValueFunc=*/nullptr),
+      "Both serialization and deserialization functions need to be registered for custom type my_test_custom_type");
+
+  testUnregisterType();
+}
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/type/tests/StringViewTest.cpp b/velox/type/tests/StringViewTest.cpp
index ff22f35c84a..619207b5b3c 100644
--- a/velox/type/tests/StringViewTest.cpp
+++ b/velox/type/tests/StringViewTest.cpp
@@ -13,15 +13,19 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <sstream>
+
 #include "velox/common/base/SimdUtil.h"
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/memory/RawVector.h"
 #include "velox/common/time/Timer.h"
 #include "velox/type/Type.h"
 
-using namespace facebook::velox;
+namespace facebook::velox {
+namespace {
 
 TEST(StringView, basic) {
   std::string text = "We are stardust, we are golden...";
@@ -181,6 +185,27 @@ int32_t linearSearchSimple(
   return -1;
 }
 
+TEST(StringView, makeInline) {
+  const std::string_view shortString = "hola";
+
+  // Test makeInline using std::string and std::string_view.
+  auto sv1 = StringView::makeInline(shortString);
+  EXPECT_TRUE(sv1.isInline());
+  EXPECT_EQ(sv1, StringView{shortString});
+
+  auto sv2 = StringView::makeInline(std::string(shortString));
+  EXPECT_TRUE(sv2.isInline());
+  EXPECT_EQ(sv2, StringView{shortString});
+
+// Only checks and throws in debug mode.
+#ifndef NDEBUG
+  VELOX_ASSERT_THROW(
+      StringView::makeInline(
+          std::string_view("slightly longer non-inlinable string")),
+      "StringView::makeInline() requires an input string that fits inline");
+#endif
+}
+
 TEST(StringView, linearSearch) {
   constexpr int32_t kSize = 1003;
   std::vector<raw_vector<char>> data(kSize);
@@ -285,3 +310,6 @@ TEST(StringView, linearSearch) {
             << simdIndicesUsec << " scalar: " << loopUsec << " / "
             << loopIndicesUsec;
 }
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/type/tests/SubfieldTest.cpp b/velox/type/tests/SubfieldTest.cpp
index a2004ba0fae..ac02077232c 100644
--- a/velox/type/tests/SubfieldTest.cpp
+++ b/velox/type/tests/SubfieldTest.cpp
@@ -15,6 +15,7 @@
  */
 #include "velox/type/Subfield.h"
 #include <gtest/gtest.h>
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/type/Tokenizer.h"
 
 using namespace facebook::velox::common;
@@ -42,7 +43,7 @@ void assertInvalidSubfield(
 }
 
 TEST(SubfieldTest, invalidPaths) {
-  assertInvalidSubfield("a[b]", "Invalid index b]");
+  assertInvalidSubfield("a[b]", "Invalid index b");
   assertInvalidSubfield("a[2", "Invalid subfield path: a[2^");
   assertInvalidSubfield("a.*", "Invalid subfield path: a.^*");
   assertInvalidSubfield("a[2].[3].", "Invalid subfield path: a[2].^[3].");
@@ -157,3 +158,124 @@ TEST(SubfieldTest, longSubscript) {
   ASSERT_TRUE(longSubscript);
   ASSERT_EQ(longSubscript->index(), 3309189884973035076);
 }
+
+TEST(SubfieldTest, asCheckedNestedField) {
+  const Subfield subfield("a.b.c");
+  ASSERT_EQ(subfield.path().size(), 3);
+
+  // Successful cast to NestedField.
+  const std::vector<std::string> expectedNames = {"a", "b", "c"};
+  for (int i = 0; i < 3; ++i) {
+    const auto* nestedField =
+        subfield.path()[i]->asChecked<Subfield::NestedField>();
+    EXPECT_EQ(nestedField->name(), expectedNames[i]);
+
+    // Failed cast should throw.
+    VELOX_ASSERT_THROW(
+        subfield.path()[i]->asChecked<Subfield::LongSubscript>(),
+        "PathElement is not of expected type");
+    VELOX_ASSERT_THROW(
+        subfield.path()[i]->asChecked<Subfield::StringSubscript>(),
+        "PathElement is not of expected type");
+    VELOX_ASSERT_THROW(
+        subfield.path()[i]->asChecked<Subfield::AllSubscripts>(),
+        "PathElement is not of expected type");
+  }
+}
+
+TEST(SubfieldTest, asCheckedLongSubscript) {
+  Subfield subfield("a[42]");
+  ASSERT_EQ(subfield.path().size(), 2);
+
+  // Element 0 is NestedField.
+  const auto* nestedField =
+      subfield.path()[0]->asChecked<Subfield::NestedField>();
+  EXPECT_EQ(nestedField->name(), "a");
+  VELOX_ASSERT_THROW(
+      subfield.path()[0]->asChecked<Subfield::LongSubscript>(),
+      "PathElement is not of expected type");
+  VELOX_ASSERT_THROW(
+      subfield.path()[0]->asChecked<Subfield::StringSubscript>(),
+      "PathElement is not of expected type");
+  VELOX_ASSERT_THROW(
+      subfield.path()[0]->asChecked<Subfield::AllSubscripts>(),
+      "PathElement is not of expected type");
+
+  // Element 1 is LongSubscript.
+  const auto* longSubscript =
+      subfield.path()[1]->asChecked<Subfield::LongSubscript>();
+  EXPECT_EQ(longSubscript->index(), 42);
+  VELOX_ASSERT_THROW(
+      subfield.path()[1]->asChecked<Subfield::NestedField>(),
+      "PathElement is not of expected type");
+  VELOX_ASSERT_THROW(
+      subfield.path()[1]->asChecked<Subfield::StringSubscript>(),
+      "PathElement is not of expected type");
+  VELOX_ASSERT_THROW(
+      subfield.path()[1]->asChecked<Subfield::AllSubscripts>(),
+      "PathElement is not of expected type");
+}
+
+TEST(SubfieldTest, asCheckedStringSubscript) {
+  Subfield subfield("a[\"key\"]");
+  ASSERT_EQ(subfield.path().size(), 2);
+
+  // Element 0 is NestedField.
+  const auto* nestedField =
+      subfield.path()[0]->asChecked<Subfield::NestedField>();
+  EXPECT_EQ(nestedField->name(), "a");
+  VELOX_ASSERT_THROW(
+      subfield.path()[0]->asChecked<Subfield::LongSubscript>(),
+      "PathElement is not of expected type");
+  VELOX_ASSERT_THROW(
+      subfield.path()[0]->asChecked<Subfield::StringSubscript>(),
+      "PathElement is not of expected type");
+  VELOX_ASSERT_THROW(
+      subfield.path()[0]->asChecked<Subfield::AllSubscripts>(),
+      "PathElement is not of expected type");
+
+  // Element 1 is StringSubscript.
+  const auto* stringSubscript =
+      subfield.path()[1]->asChecked<Subfield::StringSubscript>();
+  EXPECT_EQ(stringSubscript->index(), "key");
+  VELOX_ASSERT_THROW(
+      subfield.path()[1]->asChecked<Subfield::NestedField>(),
+      "PathElement is not of expected type");
+  VELOX_ASSERT_THROW(
+      subfield.path()[1]->asChecked<Subfield::LongSubscript>(),
+      "PathElement is not of expected type");
+  VELOX_ASSERT_THROW(
+      subfield.path()[1]->asChecked<Subfield::AllSubscripts>(),
+      "PathElement is not of expected type");
+}
+
+TEST(SubfieldTest, asCheckedAllSubscripts) {
+  Subfield subfield("a[*]");
+  ASSERT_EQ(subfield.path().size(), 2);
+
+  // Element 0 is NestedField.
+  const auto* nestedField =
+      subfield.path()[0]->asChecked<Subfield::NestedField>();
+  EXPECT_EQ(nestedField->name(), "a");
+  VELOX_ASSERT_THROW(
+      subfield.path()[0]->asChecked<Subfield::LongSubscript>(),
+      "PathElement is not of expected type");
+  VELOX_ASSERT_THROW(
+      subfield.path()[0]->asChecked<Subfield::StringSubscript>(),
+      "PathElement is not of expected type");
+  VELOX_ASSERT_THROW(
+      subfield.path()[0]->asChecked<Subfield::AllSubscripts>(),
+      "PathElement is not of expected type");
+
+  // Element 1 is AllSubscripts.
+  EXPECT_NE(subfield.path()[1]->asChecked<Subfield::AllSubscripts>(), nullptr);
+  VELOX_ASSERT_THROW(
+      subfield.path()[1]->asChecked<Subfield::NestedField>(),
+      "PathElement is not of expected type");
+  VELOX_ASSERT_THROW(
+      subfield.path()[1]->asChecked<Subfield::LongSubscript>(),
+      "PathElement is not of expected type");
+  VELOX_ASSERT_THROW(
+      subfield.path()[1]->asChecked<Subfield::StringSubscript>(),
+      "PathElement is not of expected type");
+}
diff --git a/velox/type/tests/TimestampTest.cpp b/velox/type/tests/TimestampTest.cpp
index 44f1ffc9e42..290bc79a0b2 100644
--- a/velox/type/tests/TimestampTest.cpp
+++ b/velox/type/tests/TimestampTest.cpp
@@ -15,7 +15,9 @@
  */
 
 #include <gtest/gtest.h>
+#include <iomanip>
 #include <random>
+#include <sstream>
 
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/testutil/RandomSeed.h"
@@ -279,8 +281,9 @@ std::string toStringAlt(
 }
 
 bool checkUtcToEpoch(int year, int mon, int mday, int hour, int min, int sec) {
-  SCOPED_TRACE(fmt::format(
-      "{}-{:02}-{:02} {:02}:{:02}:{:02}", year, mon, mday, hour, min, sec));
+  SCOPED_TRACE(
+      fmt::format(
+          "{}-{:02}-{:02} {:02}:{:02}:{:02}", year, mon, mday, hour, min, sec));
   std::tm tm{};
   tm.tm_sec = sec;
   tm.tm_min = min;
@@ -479,12 +482,13 @@ void testTmToString(
     for (int i = 0; i < 10'000; ++i) {
       auto epoch = dist(gen);
       auto nanos = nanosDist(gen);
-      SCOPED_TRACE(fmt::format(
-          "epoch={}, nanos={}, mode={}, precision={}",
-          epoch,
-          nanos,
-          mode,
-          precision));
+      SCOPED_TRACE(
+          fmt::format(
+              "epoch={}, nanos={}, mode={}, precision={}",
+              epoch,
+              nanos,
+              mode,
+              precision));
       if (gmtime_r(&epoch, &expected)) {
         ASSERT_TRUE(Timestamp::epochToCalendarUtc(epoch, actual));
         checkTm(actual, expected);
diff --git a/velox/type/tests/TokenizerTest.cpp b/velox/type/tests/TokenizerTest.cpp
new file mode 100644
index 00000000000..fdb1abf34ae
--- /dev/null
+++ b/velox/type/tests/TokenizerTest.cpp
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/type/Tokenizer.h"
+#include <gtest/gtest.h>
+#include "velox/common/base/tests/GTestUtils.h"
+
+using namespace facebook::velox::common;
+
+namespace {
+
+std::vector<std::unique_ptr<Subfield::PathElement>> tokenize(
+    const std::string& path) {
+  std::vector<std::unique_ptr<Subfield::PathElement>> elements;
+  Tokenizer tokenizer(path, Separators::get());
+  while (tokenizer.hasNext()) {
+    elements.push_back(tokenizer.next());
+  }
+  return elements;
+}
+
+} // namespace
+
+TEST(TokenizerTest, simpleSubscript) {
+  auto elements = tokenize("a[1]");
+  ASSERT_EQ(elements.size(), 2);
+  EXPECT_EQ(*elements[0], Subfield::NestedField("a"));
+  EXPECT_EQ(*elements[1], Subfield::LongSubscript(1));
+}
+
+TEST(TokenizerTest, subscriptAfterLongPath) {
+  auto elements = tokenize("some.long.path[42]");
+  ASSERT_EQ(elements.size(), 4);
+  EXPECT_EQ(*elements[0], Subfield::NestedField("some"));
+  EXPECT_EQ(*elements[1], Subfield::NestedField("long"));
+  EXPECT_EQ(*elements[2], Subfield::NestedField("path"));
+  EXPECT_EQ(*elements[3], Subfield::LongSubscript(42));
+}
+
+TEST(TokenizerTest, multipleSubscripts) {
+  auto elements = tokenize("a[1][2][3]");
+  ASSERT_EQ(elements.size(), 4);
+  EXPECT_EQ(*elements[0], Subfield::NestedField("a"));
+  EXPECT_EQ(*elements[1], Subfield::LongSubscript(1));
+  EXPECT_EQ(*elements[2], Subfield::LongSubscript(2));
+  EXPECT_EQ(*elements[3], Subfield::LongSubscript(3));
+}
+
+TEST(TokenizerTest, negativeSubscript) {
+  auto elements = tokenize("a[-1]");
+  ASSERT_EQ(elements.size(), 2);
+  EXPECT_EQ(*elements[0], Subfield::NestedField("a"));
+  EXPECT_EQ(*elements[1], Subfield::LongSubscript(-1));
+}
+
+TEST(TokenizerTest, invalidSubscriptErrorMessage) {
+  VELOX_ASSERT_THROW(tokenize("a[b]"), "Invalid index b");
+  VELOX_ASSERT_THROW(tokenize("some.long.path[xyz]"), "Invalid index xyz");
+}
+
+TEST(TokenizerTest, pathSegment) {
+  auto elements = tokenize("a.b.c");
+  ASSERT_EQ(elements.size(), 3);
+  EXPECT_EQ(*elements[0], Subfield::NestedField("a"));
+  EXPECT_EQ(*elements[1], Subfield::NestedField("b"));
+  EXPECT_EQ(*elements[2], Subfield::NestedField("c"));
+}
+
+TEST(TokenizerTest, quotedSubscript) {
+  auto elements = tokenize("a[\"key\"]");
+  ASSERT_EQ(elements.size(), 2);
+  EXPECT_EQ(*elements[0], Subfield::NestedField("a"));
+  EXPECT_EQ(*elements[1], Subfield::StringSubscript("key"));
+}
+
+TEST(TokenizerTest, wildcardSubscript) {
+  auto elements = tokenize("a[*]");
+  ASSERT_EQ(elements.size(), 2);
+  EXPECT_EQ(*elements[0], Subfield::NestedField("a"));
+  EXPECT_EQ(*elements[1], Subfield::AllSubscripts());
+}
diff --git a/velox/type/tests/TypeCoercerTest.cpp b/velox/type/tests/TypeCoercerTest.cpp
index 665f5fba5c0..28645b18618 100644
--- a/velox/type/tests/TypeCoercerTest.cpp
+++ b/velox/type/tests/TypeCoercerTest.cpp
@@ -17,24 +17,28 @@
 #include "velox/type/TypeCoercer.h"
 #include <gtest/gtest.h>
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/type/CastRegistry.h"
 
 namespace facebook::velox {
 namespace {
 
 void testCoercion(const TypePtr& fromType, const TypePtr& toType) {
-  auto coercion = TypeCoercer::coerceTypeBase(fromType, toType->name());
+  auto coercion =
+      TypeCoercer::defaults().coerceTypeBase(fromType, toType->name());
   ASSERT_TRUE(coercion.has_value());
   VELOX_EXPECT_EQ_TYPES(coercion->type, toType);
 }
 
 void testBaseCoercion(const TypePtr& fromType) {
-  auto coercion = TypeCoercer::coerceTypeBase(fromType, fromType->kindName());
+  auto coercion =
+      TypeCoercer::defaults().coerceTypeBase(fromType, fromType->kindName());
   ASSERT_TRUE(coercion.has_value());
   VELOX_EXPECT_EQ_TYPES(coercion->type, fromType);
 }
 
 void testNoCoercion(const TypePtr& fromType, const TypePtr& toType) {
-  auto coercion = TypeCoercer::coerceTypeBase(fromType, toType->name());
+  auto coercion =
+      TypeCoercer::defaults().coerceTypeBase(fromType, toType->name());
   ASSERT_FALSE(coercion.has_value());
 }
 
@@ -50,5 +54,345 @@ TEST(TypeCoercerTest, basic) {
   testNoCoercion(ARRAY(TINYINT()), MAP(INTEGER(), REAL()));
 }
 
+TEST(TypeCoercerTest, decimal) {
+  testCoercion(DECIMAL(10, 2), REAL());
+  testCoercion(DECIMAL(10, 2), DOUBLE());
+  testCoercion(DECIMAL(38, 6), REAL());
+  testCoercion(DECIMAL(38, 6), DOUBLE());
+
+  testNoCoercion(DECIMAL(10, 2), VARCHAR());
+  testNoCoercion(DECIMAL(10, 2), BIGINT());
+
+  ASSERT_TRUE(TypeCoercer::defaults().coercible(DECIMAL(10, 2), DOUBLE()));
+  ASSERT_TRUE(TypeCoercer::defaults().coercible(DECIMAL(10, 2), REAL()));
+  ASSERT_FALSE(TypeCoercer::defaults().coercible(DOUBLE(), DECIMAL(10, 2)));
+}
+
+TEST(TypeCoercerTest, integerToDecimal) {
+  testCoercion(TINYINT(), DECIMAL(3, 0));
+  testCoercion(SMALLINT(), DECIMAL(5, 0));
+  testCoercion(INTEGER(), DECIMAL(10, 0));
+  testCoercion(BIGINT(), DECIMAL(19, 0));
+
+  ASSERT_TRUE(TypeCoercer::defaults().coercible(TINYINT(), DECIMAL(10, 2)));
+  ASSERT_TRUE(TypeCoercer::defaults().coercible(SMALLINT(), DECIMAL(10, 2)));
+  ASSERT_TRUE(TypeCoercer::defaults().coercible(INTEGER(), DECIMAL(38, 4)));
+  ASSERT_TRUE(TypeCoercer::defaults().coercible(BIGINT(), DECIMAL(38, 4)));
+
+  ASSERT_TRUE(TypeCoercer::defaults().coercible(TINYINT(), DECIMAL(3, 0)));
+  ASSERT_TRUE(TypeCoercer::defaults().coercible(SMALLINT(), DECIMAL(5, 0)));
+  ASSERT_TRUE(TypeCoercer::defaults().coercible(INTEGER(), DECIMAL(10, 0)));
+  ASSERT_TRUE(TypeCoercer::defaults().coercible(BIGINT(), DECIMAL(19, 0)));
+
+  ASSERT_FALSE(TypeCoercer::defaults().coercible(TINYINT(), DECIMAL(2, 0)));
+  ASSERT_FALSE(TypeCoercer::defaults().coercible(SMALLINT(), DECIMAL(4, 0)));
+  ASSERT_FALSE(TypeCoercer::defaults().coercible(INTEGER(), DECIMAL(9, 0)));
+  ASSERT_FALSE(TypeCoercer::defaults().coercible(BIGINT(), DECIMAL(18, 0)));
+  ASSERT_FALSE(TypeCoercer::defaults().coercible(INTEGER(), DECIMAL(4, 2)));
+  ASSERT_FALSE(TypeCoercer::defaults().coercible(BIGINT(), DECIMAL(10, 2)));
+
+  ASSERT_FALSE(TypeCoercer::defaults().coercible(DECIMAL(10, 2), INTEGER()));
+  ASSERT_FALSE(TypeCoercer::defaults().coercible(DECIMAL(10, 2), BIGINT()));
+}
+
+TEST(TypeCoercerTest, integerToDecimalLeastCommonSuperType) {
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(INTEGER(), DECIMAL(38, 4)),
+      DECIMAL(38, 4));
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(DECIMAL(38, 4), INTEGER()),
+      DECIMAL(38, 4));
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(BIGINT(), DECIMAL(10, 2)),
+      DECIMAL(21, 2));
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(DECIMAL(10, 2), BIGINT()),
+      DECIMAL(21, 2));
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(INTEGER(), DECIMAL(4, 2)),
+      DECIMAL(12, 2));
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(SMALLINT(), DECIMAL(4, 2)),
+      DECIMAL(7, 2));
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(TINYINT(), DECIMAL(10, 4)),
+      DECIMAL(10, 4));
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(BIGINT(), DECIMAL(19, 0)),
+      DECIMAL(19, 0));
+
+  ASSERT_EQ(
+      TypeCoercer::defaults().leastCommonSuperType(BIGINT(), DECIMAL(38, 20)),
+      nullptr);
+}
+
+TEST(TypeCoercerTest, decimalDecimalLeastCommonSuperType) {
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(
+          DECIMAL(10, 2), DECIMAL(20, 4)),
+      DECIMAL(20, 4));
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(
+          DECIMAL(20, 2), DECIMAL(10, 4)),
+      DECIMAL(22, 4));
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(
+          DECIMAL(38, 4), DECIMAL(38, 4)),
+      DECIMAL(38, 4));
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(
+          DECIMAL(10, 2), DECIMAL(10, 2)),
+      DECIMAL(10, 2));
+}
+
+TEST(TypeCoercerTest, decimalLeastCommonSuperType) {
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(DECIMAL(10, 2), DOUBLE()),
+      DOUBLE());
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(DOUBLE(), DECIMAL(10, 2)),
+      DOUBLE());
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(DECIMAL(10, 2), REAL()),
+      REAL());
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(REAL(), DECIMAL(10, 2)),
+      REAL());
+}
+
+TEST(TypeCoercerTest, date) {
+  testCoercion(DATE(), DATE());
+  testCoercion(DATE(), TIMESTAMP());
+
+  testNoCoercion(DATE(), BIGINT());
+}
+
+TEST(TypeCoercerTest, unknown) {
+  ASSERT_TRUE(TypeCoercer::defaults().coercible(UNKNOWN(), BOOLEAN()));
+  ASSERT_TRUE(TypeCoercer::defaults().coercible(UNKNOWN(), BIGINT()));
+  ASSERT_TRUE(TypeCoercer::defaults().coercible(UNKNOWN(), VARCHAR()));
+  ASSERT_TRUE(TypeCoercer::defaults().coercible(UNKNOWN(), ARRAY(INTEGER())));
+}
+
+TEST(TypeCoercerTest, coerceTypeBaseFromUnknown) {
+  // Test coercion from UNKNOWN to various types.
+  testCoercion(UNKNOWN(), TINYINT());
+  testCoercion(UNKNOWN(), BOOLEAN());
+  testCoercion(UNKNOWN(), SMALLINT());
+  testCoercion(UNKNOWN(), INTEGER());
+  testCoercion(UNKNOWN(), BIGINT());
+  testCoercion(UNKNOWN(), REAL());
+  testCoercion(UNKNOWN(), DOUBLE());
+  testCoercion(UNKNOWN(), VARCHAR());
+  testCoercion(UNKNOWN(), VARBINARY());
+}
+
+TEST(TypeCoercerTest, noCost) {
+  auto assertNoCost = [](const TypePtr& type) {
+    SCOPED_TRACE(type->toString());
+    auto cost = TypeCoercer::defaults().coercible(type, type);
+    ASSERT_TRUE(cost.has_value());
+    EXPECT_EQ(cost.value(), 0);
+  };
+
+  assertNoCost(UNKNOWN());
+  assertNoCost(BOOLEAN());
+  assertNoCost(TINYINT());
+  assertNoCost(SMALLINT());
+  assertNoCost(INTEGER());
+  assertNoCost(BIGINT());
+  assertNoCost(REAL());
+  assertNoCost(DOUBLE());
+  assertNoCost(VARCHAR());
+  assertNoCost(VARBINARY());
+  assertNoCost(TIMESTAMP());
+  assertNoCost(DATE());
+
+  assertNoCost(ARRAY(INTEGER()));
+  assertNoCost(ARRAY(UNKNOWN()));
+  assertNoCost(MAP(INTEGER(), REAL()));
+  assertNoCost(MAP(UNKNOWN(), UNKNOWN()));
+  assertNoCost(ROW({INTEGER(), REAL()}));
+  assertNoCost(ROW({UNKNOWN(), UNKNOWN()}));
+}
+
+TEST(TypeCoercerTest, array) {
+  ASSERT_TRUE(
+      TypeCoercer::defaults().coercible(ARRAY(UNKNOWN()), ARRAY(INTEGER())));
+  ASSERT_TRUE(
+      TypeCoercer::defaults().coercible(
+          ARRAY(UNKNOWN()), ARRAY(ARRAY(VARCHAR()))));
+
+  ASSERT_FALSE(
+      TypeCoercer::defaults().coercible(ARRAY(BIGINT()), ARRAY(REAL())));
+  ASSERT_FALSE(
+      TypeCoercer::defaults().coercible(
+          ARRAY(UNKNOWN()), MAP(INTEGER(), REAL())));
+  ASSERT_FALSE(
+      TypeCoercer::defaults().coercible(ARRAY(UNKNOWN()), ROW({UNKNOWN()})));
+  ASSERT_FALSE(TypeCoercer::defaults().coercible(ARRAY(VARCHAR()), VARCHAR()));
+}
+
+TEST(TypeCoercerTest, map) {
+  ASSERT_TRUE(
+      TypeCoercer::defaults().coercible(
+          MAP(UNKNOWN(), UNKNOWN()), MAP(INTEGER(), REAL())));
+  ASSERT_TRUE(
+      TypeCoercer::defaults().coercible(
+          MAP(VARCHAR(), REAL()), MAP(VARCHAR(), DOUBLE())));
+  ASSERT_TRUE(
+      TypeCoercer::defaults().coercible(
+          MAP(INTEGER(), REAL()), MAP(BIGINT(), DOUBLE())));
+
+  ASSERT_FALSE(
+      TypeCoercer::defaults().coercible(
+          MAP(INTEGER(), REAL()), MAP(BIGINT(), INTEGER())));
+  ASSERT_FALSE(
+      TypeCoercer::defaults().coercible(
+          MAP(UNKNOWN(), UNKNOWN()), ARRAY(BIGINT())));
+  ASSERT_FALSE(
+      TypeCoercer::defaults().coercible(
+          MAP(UNKNOWN(), UNKNOWN()), ROW({INTEGER(), BIGINT()})));
+}
+
+TEST(TypeCoercerTest, row) {
+  ASSERT_TRUE(
+      TypeCoercer::defaults().coercible(
+          ROW({UNKNOWN(), INTEGER(), REAL()}),
+          ROW({SMALLINT(), BIGINT(), DOUBLE()})));
+
+  ASSERT_FALSE(
+      TypeCoercer::defaults().coercible(
+          ROW({UNKNOWN(), INTEGER(), REAL()}),
+          ROW({SMALLINT(), VARCHAR(), DOUBLE()})));
+
+  ASSERT_FALSE(
+      TypeCoercer::defaults().coercible(
+          ROW({UNKNOWN(), INTEGER(), REAL()}), ARRAY(INTEGER())));
+  ASSERT_FALSE(
+      TypeCoercer::defaults().coercible(
+          ROW({UNKNOWN(), INTEGER(), REAL()}), MAP(INTEGER(), REAL())));
+  ASSERT_FALSE(
+      TypeCoercer::defaults().coercible(
+          ROW({UNKNOWN(), INTEGER(), REAL()}), ROW({UNKNOWN(), INTEGER()})));
+  ASSERT_FALSE(
+      TypeCoercer::defaults().coercible(
+          ROW({UNKNOWN(), INTEGER(), REAL()}), BIGINT()));
+}
+
+TEST(TypeCoercerTest, leastCommonSuperType) {
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(INTEGER(), BIGINT()),
+      BIGINT());
+
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(
+          ARRAY(INTEGER()), ARRAY(TINYINT())),
+      ARRAY(INTEGER()));
+
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(
+          MAP(TINYINT(), DOUBLE()), MAP(INTEGER(), REAL())),
+      MAP(INTEGER(), DOUBLE()));
+
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(
+          ROW({TINYINT(), DOUBLE()}), ROW({INTEGER(), REAL()})),
+      ROW({INTEGER(), DOUBLE()}));
+
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(
+          ROW({"", "", ""}, INTEGER()), ROW({"", "", ""}, SMALLINT())),
+      ROW({"", "", ""}, INTEGER()));
+
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(
+          ROW({"a", "b", "c"}, INTEGER()), ROW({"a", "b", "c"}, SMALLINT())),
+      ROW({"a", "b", "c"}, INTEGER()));
+
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(
+          ROW({"", "", ""}, INTEGER()), ROW({"a", "b", "c"}, SMALLINT())),
+      ROW({"", "", ""}, INTEGER()));
+
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::defaults().leastCommonSuperType(
+          ROW({"a", "bb", ""}, INTEGER()), ROW({"a", "b", "c"}, SMALLINT())),
+      ROW({"a", "", ""}, INTEGER()));
+
+  ASSERT_TRUE(
+      TypeCoercer::defaults().leastCommonSuperType(VARCHAR(), TINYINT()) ==
+      nullptr);
+
+  ASSERT_TRUE(
+      TypeCoercer::defaults().leastCommonSuperType(
+          ARRAY(TINYINT()), TINYINT()) == nullptr);
+
+  ASSERT_TRUE(
+      TypeCoercer::defaults().leastCommonSuperType(
+          ARRAY(TINYINT()), ARRAY(VARCHAR())) == nullptr);
+
+  ASSERT_TRUE(
+      TypeCoercer::defaults().leastCommonSuperType(
+          ROW({""}, TINYINT()), ROW({"", ""}, TINYINT())) == nullptr);
+
+  ASSERT_TRUE(
+      TypeCoercer::defaults().leastCommonSuperType(
+          MAP(INTEGER(), REAL()), ROW({INTEGER(), REAL()})) == nullptr);
+}
+
+TEST(TypeCoercerTest, parametricBuiltinTargetDoesNotThrow) {
+  // Parametric built-in factories throw on empty params. Verify graceful
+  // handling.
+  EXPECT_EQ(
+      TypeCoercer::defaults().coerceTypeBase(BIGINT(), "ARRAY"), std::nullopt);
+}
+
+TEST(TypeCoercerTest, ctorRejectsDuplicateCostForSameSource) {
+  VELOX_ASSERT_THROW(
+      TypeCoercer({{INTEGER(), BIGINT(), 1}, {INTEGER(), DOUBLE(), 1}}),
+      "Duplicate cost 1 for source type INTEGER");
+}
+
+TEST(TypeCoercerTest, ctorRejectsNullEntries) {
+  VELOX_ASSERT_THROW(
+      TypeCoercer({{nullptr, BIGINT(), 1}}),
+      "CoercionEntry.from must not be null");
+  VELOX_ASSERT_THROW(
+      TypeCoercer({{INTEGER(), nullptr, 1}}),
+      "CoercionEntry.to must not be null");
+}
+
+TEST(TypeCoercerTest, ctorRejectsDecimalToDecimal) {
+  // DECIMAL -> DECIMAL is hardcoded in the type system; rule entries
+  // wouldn't be honored, so reject them at construction.
+  VELOX_ASSERT_THROW(
+      TypeCoercer({{DECIMAL(1, 0), DECIMAL(20, 4), 1}}),
+      "DECIMAL -> DECIMAL coercion is not customizable");
+}
+
+TEST(TypeCoercerTest, ctorRejectsNonCanonicalSourceDecimal) {
+  // Source DECIMAL must be the canonical placeholder DECIMAL(1, 0).
+  VELOX_ASSERT_THROW(
+      TypeCoercer({{DECIMAL(10, 2), DOUBLE(), 1}}),
+      "Source DECIMAL in CoercionEntry must be DECIMAL(1, 0)");
+
+  // The canonical placeholder is accepted.
+  EXPECT_NO_THROW(TypeCoercer({{DECIMAL(1, 0), DOUBLE(), 1}}));
+}
+
+TEST(TypeCoercerTest, ctorRejectsDuplicateRule) {
+  // Plain duplicate (same source -> same target name).
+  VELOX_ASSERT_THROW(
+      TypeCoercer({{INTEGER(), BIGINT(), 1}, {INTEGER(), BIGINT(), 2}}),
+      "Duplicate coercion rule INTEGER -> BIGINT");
+
+  // DECIMAL footgun: both rules collide on map key (TINYINT, DECIMAL).
+  VELOX_ASSERT_THROW(
+      TypeCoercer(
+          {{TINYINT(), DECIMAL(3, 0), 1}, {TINYINT(), DECIMAL(10, 2), 2}}),
+      "Duplicate coercion rule TINYINT -> DECIMAL");
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/type/tests/TypeTest.cpp b/velox/type/tests/TypeTest.cpp
index 21566ac63e8..cf4513aa4e4 100644
--- a/velox/type/tests/TypeTest.cpp
+++ b/velox/type/tests/TypeTest.cpp
@@ -18,7 +18,9 @@
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/type/CppToType.h"
 #include "velox/type/SimpleFunctionApi.h"
+#include "velox/type/TimestampConversion.h"
 #include "velox/type/TypeEncodingUtil.h"
+#include "velox/type/TypeSerde.h"
 #include "velox/type/tests/utils/CustomTypesForTesting.h"
 
 using namespace facebook;
@@ -107,6 +109,7 @@ TEST(TypeTest, timestamp) {
   EXPECT_STREQ(t0->kindName(), "TIMESTAMP");
   ASSERT_EQ(t0->begin(), t0->end());
   ASSERT_EQ(approximateTypeEncodingwidth(t0), 1);
+  EXPECT_TRUE(t0->equivalent(*createType(TypeKind::TIMESTAMP, {})));
 
   testTypeSerde(t0);
 }
@@ -156,6 +159,25 @@ TEST(TypeTest, timestampComparison) {
   EXPECT_GE(t1, t1lessSeconds);
 }
 
+TEST(TypeTest, timestampUtc) {
+  const auto t = TIMESTAMP_UTC();
+  ASSERT_EQ(t->toString(), "TIMESTAMP UTC");
+  ASSERT_EQ(t->size(), 0);
+  VELOX_ASSERT_THROW(t->childAt(0), "scalar type has no children");
+  ASSERT_EQ(t->kind(), TypeKind::TIMESTAMP);
+  EXPECT_STREQ(t->kindName(), "TIMESTAMP");
+  ASSERT_EQ(t->begin(), t->end());
+  ASSERT_EQ(approximateTypeEncodingwidth(t), 1);
+
+  testTypeSerde(t);
+
+  EXPECT_TRUE(t->isTimestamp());
+  EXPECT_TRUE(t->equivalent(*TIMESTAMP_UTC()));
+  EXPECT_TRUE(TIMESTAMP_UTC()->equivalent(*TimestampUtcType::get()));
+  EXPECT_FALSE(t->equivalent(*TIMESTAMP()));
+  EXPECT_FALSE(TIMESTAMP()->equivalent(*t));
+}
+
 TEST(TypeTest, date) {
   const auto date = DATE();
   ASSERT_EQ(date->toString(), "DATE");
@@ -335,6 +357,115 @@ TEST(TypeTest, dateToString) {
   EXPECT_EQ(DATE()->toString(-1855961014), "-5079479-05-03");
 }
 
+// Tests the generic Type::valueToString<T> template which routes to
+// type-specific formatting based on the type. Tests are grouped by physical
+// type and use the same raw values to illustrate the difference in output.
+TEST(TypeTest, genericValueToString) {
+  // int32_t types: INTEGER, DATE, INTERVAL YEAR TO MONTH.
+  // Same value 25 is formatted differently depending on the logical type.
+  {
+    const int32_t value = 25;
+
+    {
+      TypePtr type = INTEGER();
+      EXPECT_EQ(type->valueToString(value), "25");
+    }
+    {
+      TypePtr type = DATE();
+      EXPECT_EQ(type->valueToString(value), "1970-01-26");
+    }
+    {
+      TypePtr type = INTERVAL_YEAR_MONTH();
+      EXPECT_EQ(type->valueToString(value), "2-1");
+    }
+  }
+
+  // int64_t types: BIGINT, DECIMAL, TIME, TIME_MICRO_UTC, INTERVAL DAY TO
+  // SECOND. Same value 45'123 is formatted differently depending on the logical
+  // type.
+  {
+    const int64_t value = 45'123;
+
+    {
+      TypePtr type = BIGINT();
+      EXPECT_EQ(type->valueToString(value), "45123");
+    }
+    {
+      TypePtr type = DECIMAL(10, 2);
+      EXPECT_EQ(type->valueToString(value), "451.23");
+    }
+    {
+      // Milliseconds since midnight: 45.123 seconds.
+      TypePtr type = TIME();
+      EXPECT_EQ(type->valueToString(value), "00:00:45.123");
+    }
+    {
+      // Microseconds since midnight: 0.045123 seconds.
+      TypePtr type = TIME_MICRO_UTC();
+      EXPECT_EQ(type->valueToString(value), "00:00:00.045123");
+    }
+    {
+      TypePtr type = INTERVAL_DAY_TIME();
+      EXPECT_EQ(type->valueToString(value), "0 00:00:45.123");
+    }
+  }
+
+  // int128_t types: HUGEINT, DECIMAL.
+  {
+    const int128_t value = 45'123;
+
+    {
+      TypePtr type = HUGEINT();
+      EXPECT_EQ(type->valueToString(value), "45123");
+    }
+    {
+      TypePtr type = DECIMAL(38, 2);
+      EXPECT_EQ(type->valueToString(value), "451.23");
+    }
+  }
+
+  // StringView types: VARCHAR, VARBINARY.
+  {
+    StringView value("hello");
+
+    {
+      TypePtr type = VARCHAR();
+      EXPECT_EQ(type->valueToString(value), "hello");
+    }
+    {
+      TypePtr type = VARBINARY();
+      EXPECT_EQ(type->valueToString(value), "hello");
+    }
+  }
+
+  // Other scalar types.
+  {
+    EXPECT_EQ(BOOLEAN()->valueToString(true), "true");
+    EXPECT_EQ(BOOLEAN()->valueToString(false), "false");
+  }
+  {
+    TypePtr type = TINYINT();
+    EXPECT_EQ(type->valueToString(static_cast<int8_t>(42)), "42");
+  }
+  {
+    TypePtr type = SMALLINT();
+    EXPECT_EQ(type->valueToString(static_cast<int16_t>(42)), "42");
+  }
+  {
+    TypePtr type = REAL();
+    EXPECT_EQ(type->valueToString(1.5f), "1.5");
+  }
+  {
+    TypePtr type = DOUBLE();
+    EXPECT_EQ(type->valueToString(1.5), "1.5");
+  }
+  {
+    TypePtr type = TIMESTAMP();
+    EXPECT_EQ(
+        type->valueToString(Timestamp(0, 0)), "1970-01-01T00:00:00.000000000");
+  }
+}
+
 TEST(TypeTest, parseStringToDate) {
   auto parseDate = [](const std::string& dateStr) {
     return DATE()->toDays(dateStr);
@@ -498,9 +629,27 @@ TEST(TypeTest, wideRow) {
   auto rowType = ROW(std::move(names), BIGINT());
 
   ASSERT_EQ(rowType->findChild("c17")->toString(), "BIGINT");
-  VELOX_ASSERT_THROW(
-      rowType->findChild("blah"),
-      "Field not found: blah. Available fields are: c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, c45, c46, c47, c48, c49, ...950 more");
+  // Verify findChild error message and messageTemplate().
+  try {
+    rowType->findChild("blah");
+    FAIL() << "Expected exception";
+  } catch (const VeloxUserError& e) {
+    EXPECT_NE(
+        e.message().find(
+            "Field not found: blah. Available fields are: c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, c45, c46, c47, c48, c49, ...950 more"),
+        std::string::npos);
+    EXPECT_EQ(
+        e.messageTemplate(), "Field not found: {}. Available fields are: {}.");
+  }
+
+  // Verify getChildIdx produces the same template.
+  try {
+    rowType->getChildIdx("blah");
+    FAIL() << "Expected exception";
+  } catch (const VeloxUserError& e) {
+    EXPECT_EQ(
+        e.messageTemplate(), "Field not found: {}. Available fields are: {}.");
+  }
 }
 
 TEST(TypeTest, serdeCache) {
@@ -577,20 +726,21 @@ TEST(TypeTest, rowParametersMultiThreaded) {
   }
   auto type = ROW(std::move(names), std::move(types));
   constexpr int kNumThreads = 72;
-  const std::vector<TypeParameter>* parameters[kNumThreads];
+  std::span<const TypeParameter> parameters[kNumThreads];
   std::vector<std::thread> threads;
   for (int i = 0; i < kNumThreads; ++i) {
-    threads.emplace_back([&, i] { parameters[i] = &type->parameters(); });
+    threads.emplace_back([&, i] { parameters[i] = type->parameters(); });
   }
   for (auto& thread : threads) {
     thread.join();
   }
   for (int i = 1; i < kNumThreads; ++i) {
-    ASSERT_TRUE(parameters[i] == parameters[0]);
+    ASSERT_TRUE(parameters[i].data() == parameters[0].data());
+    ASSERT_TRUE(parameters[i].size() == parameters[0].size());
   }
-  ASSERT_EQ(parameters[0]->size(), type->size());
-  for (int i = 0; i < parameters[0]->size(); ++i) {
-    ASSERT_TRUE((*parameters[0])[i].type.get() == type->childAt(i).get());
+  ASSERT_EQ(parameters[0].size(), type->size());
+  for (int i = 0; i < parameters[0].size(); ++i) {
+    ASSERT_TRUE(parameters[0][i].type.get() == type->childAt(i).get());
   }
 }
 
@@ -660,12 +810,24 @@ TEST(TypeTest, opaque) {
   auto foo3 = Type::create(foo->serialize());
   ASSERT_EQ(*foo, *foo3);
 
+  // Clearing the serialization registry when no serialization/deserialization
+  // functions have been provided, should return true, since the registry
+  // contained nullptr as serialization/deserialization functions.
+  EXPECT_TRUE(OpaqueType::unregisterSerialization(foo2, "id_of_foo"));
+  // Clearing the serialization registry a second time should return false.
+  EXPECT_FALSE(OpaqueType::unregisterSerialization(foo2, "id_of_foo"));
+
   OpaqueType::registerSerialization<Bar>(
       "id_of_bar",
       [](const std::shared_ptr<Bar>&) -> std::string { return ""; },
       [](const std::string&) -> std::shared_ptr<Bar> { return nullptr; });
   bar->getSerializeFunc();
   bar->getDeserializeFunc();
+
+  // Clearing the serialization registry should return true.
+  EXPECT_TRUE(
+      OpaqueType::unregisterSerialization(
+          OpaqueType::create<Bar>(), "id_of_bar"));
 }
 
 // Example of an opaque type that keeps some additional type-level metadata.
@@ -885,6 +1047,81 @@ TEST(TypeTest, kindHash) {
   EXPECT_NE(ARRAY(BIGINT())->hashKind(), ROW({{"a", BIGINT()}})->hashKind());
 }
 
+TEST(TypeTest, hashType) {
+  std::hash<Type> hasher;
+
+  // Same primitive types are equal.
+  EXPECT_EQ(hasher(*BIGINT()), hasher(*BIGINT()));
+  EXPECT_EQ(hasher(*VARCHAR()), hasher(*VARCHAR()));
+  EXPECT_NE(hasher(*BIGINT()), hasher(*INTEGER()));
+
+  // ROW field names and types are included.
+  EXPECT_NE(hasher(*ROW({"a"}, {INTEGER()})), hasher(*ROW({"b"}, {INTEGER()})));
+  EXPECT_NE(hasher(*ROW({"a"}, {INTEGER()})), hasher(*ROW({"a"}, {BIGINT()})));
+  EXPECT_NE(
+      hasher(*ROW({"a"}, {INTEGER()})),
+      hasher(*ROW({"a", "b"}, {INTEGER(), INTEGER()})));
+  EXPECT_EQ(hasher(*ROW({"a"}, {INTEGER()})), hasher(*ROW({"a"}, {INTEGER()})));
+
+  // ARRAY element type is included.
+  EXPECT_NE(hasher(*ARRAY(BIGINT())), hasher(*ARRAY(VARCHAR())));
+  EXPECT_EQ(hasher(*ARRAY(BIGINT())), hasher(*ARRAY(BIGINT())));
+
+  // MAP key and value types are included.
+  EXPECT_NE(hasher(*MAP(BIGINT(), REAL())), hasher(*MAP(VARCHAR(), REAL())));
+  EXPECT_NE(hasher(*MAP(BIGINT(), REAL())), hasher(*MAP(BIGINT(), VARCHAR())));
+  EXPECT_EQ(hasher(*MAP(BIGINT(), REAL())), hasher(*MAP(BIGINT(), REAL())));
+
+  // FUNCTION argument and return types are included.
+  EXPECT_NE(
+      hasher(*FUNCTION({BIGINT()}, REAL())),
+      hasher(*FUNCTION({VARCHAR()}, REAL())));
+  EXPECT_NE(
+      hasher(*FUNCTION({BIGINT()}, REAL())),
+      hasher(*FUNCTION({BIGINT()}, VARCHAR())));
+  EXPECT_EQ(
+      hasher(*FUNCTION({BIGINT()}, REAL())),
+      hasher(*FUNCTION({BIGINT()}, REAL())));
+
+  // DECIMAL precision and scale are included.
+  EXPECT_NE(hasher(*DECIMAL(10, 2)), hasher(*DECIMAL(10, 3)));
+  EXPECT_NE(hasher(*DECIMAL(10, 2)), hasher(*DECIMAL(11, 2)));
+  EXPECT_EQ(hasher(*DECIMAL(10, 2)), hasher(*DECIMAL(10, 2)));
+  // LongDecimalType (precision > 18, TypeKind::HUGEINT) is also covered.
+  EXPECT_NE(hasher(*DECIMAL(38, 10)), hasher(*DECIMAL(38, 11)));
+  EXPECT_NE(hasher(*DECIMAL(38, 10)), hasher(*DECIMAL(19, 10)));
+  EXPECT_EQ(hasher(*DECIMAL(38, 10)), hasher(*DECIMAL(38, 10)));
+  // HUGEINT and a LongDecimalType share TypeKind::HUGEINT but must hash
+  // differently (HUGEINT goes through the leaf-scalar typeid branch; the
+  // LongDecimalType goes through the decimal branch).
+  EXPECT_NE(hasher(*HUGEINT()), hasher(*DECIMAL(38, 10)));
+
+  // OpaqueType differentiates by C++ type identity.
+  auto opaque1 = OpaqueType::create<int>();
+  auto opaque2 = OpaqueType::create<double>();
+  EXPECT_NE(hasher(*opaque1), hasher(*opaque2));
+  EXPECT_EQ(hasher(*opaque1), hasher(*OpaqueType::create<int>()));
+
+  // Singleton overlay types that share a TypeKind with their base scalar
+  // must hash distinctly (they are distinguished by operator== via RTTI).
+  EXPECT_NE(hasher(*BIGINT()), hasher(*INTERVAL_DAY_TIME()));
+  EXPECT_NE(hasher(*BIGINT()), hasher(*TIME()));
+  EXPECT_NE(hasher(*BIGINT()), hasher(*TIME_MICRO_UTC()));
+  EXPECT_NE(hasher(*INTERVAL_DAY_TIME()), hasher(*TIME()));
+  EXPECT_NE(hasher(*INTERVAL_DAY_TIME()), hasher(*TIME_MICRO_UTC()));
+  EXPECT_NE(hasher(*TIME()), hasher(*TIME_MICRO_UTC()));
+  EXPECT_NE(hasher(*INTEGER()), hasher(*DATE()));
+  EXPECT_NE(hasher(*INTEGER()), hasher(*INTERVAL_YEAR_MONTH()));
+  EXPECT_NE(hasher(*DATE()), hasher(*INTERVAL_YEAR_MONTH()));
+
+  // Self-consistency for singleton overlay types.
+  EXPECT_EQ(hasher(*INTERVAL_DAY_TIME()), hasher(*INTERVAL_DAY_TIME()));
+  EXPECT_EQ(hasher(*DATE()), hasher(*DATE()));
+  EXPECT_EQ(hasher(*INTERVAL_YEAR_MONTH()), hasher(*INTERVAL_YEAR_MONTH()));
+  EXPECT_EQ(hasher(*TIME()), hasher(*TIME()));
+  EXPECT_EQ(hasher(*TIME_MICRO_UTC()), hasher(*TIME_MICRO_UTC()));
+}
+
 template <TypeKind KIND>
 int32_t returnKindIntPlus(int32_t val) {
   return (int32_t)KIND + val;
@@ -1155,8 +1392,9 @@ TEST(TypeTest, providesCustomComparison) {
 
   // This type claims it providesCustomComparison but does not implement the
   // compare and hash functions so invoking them should still fail.
-  EXPECT_TRUE(test::BIGINT_TYPE_WITH_INVALID_CUSTOM_COMPARISON()
-                  ->providesCustomComparison());
+  EXPECT_TRUE(
+      test::BIGINT_TYPE_WITH_INVALID_CUSTOM_COMPARISON()
+          ->providesCustomComparison());
   EXPECT_THROW(
       test::BIGINT_TYPE_WITH_INVALID_CUSTOM_COMPARISON()->compare(0, 0),
       VeloxRuntimeError);
@@ -1201,3 +1439,84 @@ TEST(TypeTest, toSummaryString) {
       "ROW(BOOLEAN, INTEGER, VARCHAR, ARRAY, MAP, ROW)",
       rowType->toSummaryString({.maxChildren = 10}));
 }
+
+TEST(TypeTest, time) {
+  const auto timeType = TIME();
+
+  ASSERT_EQ(timeType->size(), 0);
+  VELOX_ASSERT_THROW(timeType->childAt(0), "scalar type has no children");
+  ASSERT_EQ(timeType->kind(), TypeKind::BIGINT); // Physical type
+  EXPECT_STREQ(timeType->kindName(), "BIGINT"); // Physical kind name
+  ASSERT_EQ(timeType->begin(), timeType->end());
+  ASSERT_EQ(approximateTypeEncodingwidth(timeType), 1);
+
+  // Test logical vs physical type behavior (similar to DATE test)
+  ASSERT_TRUE(timeType->kindEquals(BIGINT())); // Same physical kind
+  ASSERT_NE(*timeType, *BIGINT()); // Different logical types
+  ASSERT_FALSE(timeType->equivalent(*BIGINT())); // Not equivalent
+  ASSERT_FALSE(BIGINT()->equivalent(*timeType)); // Not equivalent reverse
+
+  // Test orderability and comparability
+  ASSERT_TRUE(timeType->isOrderable());
+  ASSERT_TRUE(timeType->isComparable());
+
+  testTypeSerde(timeType);
+
+  ASSERT_EQ(timeType->toString(), "TIME");
+  ASSERT_EQ(timeType->getMin(), 0);
+  ASSERT_EQ(timeType->getMax(), 86'399'999);
+}
+
+TEST(TypeTest, timeMicroUtc) {
+  const auto timeType = TIME_MICRO_UTC();
+  ASSERT_EQ(timeType->size(), 0);
+  VELOX_ASSERT_THROW(timeType->childAt(0), "scalar type has no children");
+  ASSERT_EQ(timeType->kind(), TypeKind::BIGINT); // Physical type
+  EXPECT_STREQ(timeType->kindName(), "BIGINT"); // Physical kind name
+  ASSERT_EQ(timeType->begin(), timeType->end());
+  ASSERT_EQ(approximateTypeEncodingwidth(timeType), 1);
+
+  // Test logical vs physical type behavior (similar to DATE test)
+  ASSERT_TRUE(timeType->kindEquals(BIGINT())); // Same physical kind
+  ASSERT_NE(*timeType, *BIGINT()); // Different logical types
+  ASSERT_FALSE(timeType->equivalent(*BIGINT())); // Not equivalent
+  ASSERT_FALSE(BIGINT()->equivalent(*timeType)); // Not equivalent reverse
+
+  // Test orderability and comparability
+  ASSERT_TRUE(timeType->isOrderable());
+  ASSERT_TRUE(timeType->isComparable());
+
+  testTypeSerde(timeType);
+  ASSERT_EQ(timeType->toString(), "TIME MICRO UTC");
+  ASSERT_EQ(timeType->getMin(), 0);
+  ASSERT_EQ(timeType->getMax(), 86'399'999'999);
+}
+
+TEST(TypeTest, timeTypeComparison) {
+  EXPECT_TRUE(TIME()->equivalent(*TIME()));
+  EXPECT_TRUE(TIME_MICRO_UTC()->equivalent(*TIME_MICRO_UTC()));
+
+  EXPECT_FALSE(TIME()->equivalent(*TIME_MICRO_UTC()));
+  EXPECT_FALSE(TIME_MICRO_UTC()->equivalent(*TIME()));
+}
+
+TEST(TypeTest, timeToIso8601) {
+  const auto toIso8601 =
+      [](int64_t hours, int64_t minutes, int64_t seconds, int64_t micros) {
+        return TimeMicroPrecisionUtcType::toCompactIso8601(
+            hours * util::kMicrosPerHour + minutes * util::kMicrosPerMinute +
+            seconds * util::kMicrosPerSec + micros);
+      };
+
+  EXPECT_EQ("00:00", toIso8601(0, 0, 0, 0));
+  EXPECT_EQ("00:00:00.000001", toIso8601(0, 0, 0, 1));
+  EXPECT_EQ("00:00:00.100", toIso8601(0, 0, 0, 100'000));
+  EXPECT_EQ("00:00:01", toIso8601(0, 0, 1, 0));
+  EXPECT_EQ("00:00:00.001", toIso8601(0, 0, 0, 1'000));
+  EXPECT_EQ("00:00:00.038", toIso8601(0, 0, 0, 38'000));
+  EXPECT_EQ("00:00:00.038001", toIso8601(0, 0, 0, 38'001));
+  EXPECT_EQ("00:00:00.038100", toIso8601(0, 0, 0, 38'100));
+  EXPECT_EQ("08:08:08", toIso8601(8, 8, 8, 0));
+  EXPECT_EQ("10:12:55.038", toIso8601(10, 12, 55, 38'000));
+  EXPECT_EQ("23:59:59.999999", toIso8601(23, 59, 59, 999'999));
+}
diff --git a/velox/type/tests/TypeUtilTest.cpp b/velox/type/tests/TypeUtilTest.cpp
index 321d702fade..2476dc7f4cb 100644
--- a/velox/type/tests/TypeUtilTest.cpp
+++ b/velox/type/tests/TypeUtilTest.cpp
@@ -21,19 +21,30 @@
 namespace facebook::velox::type {
 namespace {
 
-TEST(TypeUtilTest, ConcatRowTypes) {
-  auto keyType = velox::ROW({"k0", "k1"}, {velox::BIGINT(), velox::INTEGER()});
-  auto valueType = velox::ROW(
-      {"v0", "v1"}, {velox::VARBINARY(), velox::ARRAY(velox::BIGINT())});
+TEST(TypeUtilTest, concatRowTypes) {
+  auto keyType = ROW({"k0", "k1"}, {BIGINT(), INTEGER()});
+  auto valueType = ROW({"v0", "v1"}, {VARBINARY(), ARRAY(BIGINT())});
   auto type = concatRowTypes({keyType, valueType});
-  auto expected = velox::ROW(
-      {"k0", "k1", "v0", "v1"},
-      {velox::BIGINT(),
-       velox::INTEGER(),
-       velox::VARBINARY(),
-       velox::ARRAY(velox::BIGINT())});
+  auto expected =
+      ROW({"k0", "k1", "v0", "v1"},
+          {BIGINT(), INTEGER(), VARBINARY(), ARRAY(BIGINT())});
   EXPECT_EQ(type->toString(), expected->toString());
 }
 
+TEST(TypeUtilTest, tryGetHomogeneousRowChild) {
+  {
+    auto child = tryGetHomogeneousRowChild(ROW({"c1", "c2", "c3"}, BIGINT()));
+    ASSERT_NE(child, nullptr);
+    ASSERT_EQ(*child, *BIGINT());
+  }
+
+  ASSERT_EQ(tryGetHomogeneousRowChild(INTEGER()), nullptr);
+  ASSERT_EQ(tryGetHomogeneousRowChild(ROW({})), nullptr);
+  ASSERT_EQ(tryGetHomogeneousRowChild(ROW({BIGINT(), VARCHAR()})), nullptr);
+  ASSERT_EQ(
+      tryGetHomogeneousRowChild(ROW({"c1", "c2"}, {BIGINT(), VARCHAR()})),
+      nullptr);
+}
+
 } // namespace
 } // namespace facebook::velox::type
diff --git a/velox/type/tests/VariantTest.cpp b/velox/type/tests/VariantTest.cpp
index ea47af4dab9..bf297f340ef 100644
--- a/velox/type/tests/VariantTest.cpp
+++ b/velox/type/tests/VariantTest.cpp
@@ -20,14 +20,547 @@
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/type/tests/utils/CustomTypesForTesting.h"
 
-namespace facebook::velox {
-
+namespace facebook::velox::test {
 namespace {
-void testSerDe(const Variant& value) {
-  auto serialized = value.serialize();
-  auto copy = Variant::create(serialized);
 
-  ASSERT_EQ(value, copy);
+// Comprehensive tests for Variant::create() method.
+
+template <TypeKind KIND, typename T>
+void testCreate(T value) {
+  T maxVal = std::numeric_limits<T>::max();
+  T minVal = std::numeric_limits<T>::lowest(); // since we also test floats.
+
+  auto maxVariant = Variant::template create<KIND>(maxVal);
+  EXPECT_FALSE(maxVariant.isNull());
+  EXPECT_EQ(maxVariant.kind(), KIND);
+  EXPECT_EQ(maxVariant.template value<KIND>(), maxVal);
+
+  auto minVariant = Variant::template create<KIND>(minVal);
+  EXPECT_EQ(minVariant.template value<KIND>(), minVal);
+  EXPECT_EQ(minVariant.template value<KIND>(), minVal);
+
+  auto testVariant = Variant::template create<KIND>(value);
+  EXPECT_EQ(testVariant.template value<KIND>(), value);
+};
+
+TEST(VariantCreateTest, primitiveTypes) {
+  // Different integer precisions.
+  testCreate<TypeKind::TINYINT>((int8_t)-5);
+  testCreate<TypeKind::SMALLINT>((int16_t)12345);
+  testCreate<TypeKind::INTEGER>((int32_t)123456789);
+  testCreate<TypeKind::BIGINT>((int64_t)9876543210LL);
+  testCreate<TypeKind::HUGEINT>((int128_t)1234567890123456789LL);
+  testCreate<TypeKind::HUGEINT>((int128_t)0);
+
+  // Boolean.
+  testCreate<TypeKind::BOOLEAN>(true);
+  testCreate<TypeKind::BOOLEAN>(false);
+
+  // Float/double values.
+  testCreate<TypeKind::REAL>((float)0.0);
+  testCreate<TypeKind::REAL>((float)3.14159f);
+  testCreate<TypeKind::REAL>((float)-123.456f);
+
+  testCreate<TypeKind::DOUBLE>((double)0.0);
+  testCreate<TypeKind::DOUBLE>((double)3.141592653589793);
+  testCreate<TypeKind::DOUBLE>((double)-987654.321);
+
+  // Test special float values.
+  auto infVariant =
+      Variant::create<TypeKind::REAL>(std::numeric_limits<float>::infinity());
+  EXPECT_TRUE(std::isinf(infVariant.value<TypeKind::REAL>()));
+
+  auto nanVariant =
+      Variant::create<TypeKind::REAL>(std::numeric_limits<float>::quiet_NaN());
+  EXPECT_TRUE(std::isnan(nanVariant.value<TypeKind::REAL>()));
+
+  infVariant = Variant::create<TypeKind::DOUBLE>(
+      std::numeric_limits<double>::infinity());
+  EXPECT_TRUE(std::isinf(infVariant.value<TypeKind::DOUBLE>()));
+
+  nanVariant = Variant::create<TypeKind::DOUBLE>(
+      std::numeric_limits<double>::quiet_NaN());
+  EXPECT_TRUE(std::isnan(nanVariant.value<TypeKind::DOUBLE>()));
+
+  // Timestamps.
+  testCreate<TypeKind::TIMESTAMP>(Timestamp(0, 0));
+  testCreate<TypeKind::TIMESTAMP>(Timestamp(1234567890, 123456789));
+  testCreate<TypeKind::TIMESTAMP>(Timestamp(999999, 888888));
+}
+
+TEST(VariantCreateTest, varcharType) {
+  // Test VARCHAR type.
+  std::string emptyStr = "";
+  std::string simpleStr = "Hello, Velox!";
+  std::string longStr(10000, 'a');
+  std::string specialChars = "Special chars: \n\t\r !@#$%^&*()";
+  std::string unicodeStr = "Unicode: 你好世界 🌍";
+
+  auto emptyVariant = Variant::create<TypeKind::VARCHAR>(emptyStr);
+  EXPECT_FALSE(emptyVariant.isNull());
+  EXPECT_EQ(emptyVariant.kind(), TypeKind::VARCHAR);
+  EXPECT_EQ(emptyVariant.value<TypeKind::VARCHAR>(), emptyStr);
+
+  auto simpleVariant = Variant::create<TypeKind::VARCHAR>(simpleStr);
+  EXPECT_EQ(simpleVariant.value<TypeKind::VARCHAR>(), simpleStr);
+
+  auto longVariant = Variant::create<TypeKind::VARCHAR>(longStr);
+  EXPECT_EQ(longVariant.value<TypeKind::VARCHAR>(), longStr);
+
+  auto specialVariant = Variant::create<TypeKind::VARCHAR>(specialChars);
+  EXPECT_EQ(specialVariant.value<TypeKind::VARCHAR>(), specialChars);
+
+  auto unicodeVariant = Variant::create<TypeKind::VARCHAR>(unicodeStr);
+  EXPECT_EQ(unicodeVariant.value<TypeKind::VARCHAR>(), unicodeStr);
+
+  // Other string types.
+  auto stdStringViewVariant =
+      Variant::create<TypeKind::VARCHAR>(std::string_view(longStr));
+  EXPECT_EQ(stdStringViewVariant.value<TypeKind::VARCHAR>(), longStr);
+
+  auto stringViewVariant =
+      Variant::create<TypeKind::VARCHAR>(StringView(longStr));
+  EXPECT_EQ(stringViewVariant.value<TypeKind::VARCHAR>(), longStr);
+
+  // Test move semantics
+  std::string moveStr = "Move me!";
+  auto moveVariant = Variant::create<TypeKind::VARCHAR>(std::move(moveStr));
+  EXPECT_EQ(moveVariant.value<TypeKind::VARCHAR>(), "Move me!");
+}
+
+TEST(VariantCreateTest, varbinaryType) {
+  // Test VARBINARY type.
+  std::string emptyBinary = "";
+  std::string simpleBinary = "Binary data \0 with nulls \x00\x01\x02";
+  std::string largeBinary(5000, '\xFF');
+
+  auto emptyVariant = Variant::create<TypeKind::VARBINARY>(emptyBinary);
+  EXPECT_FALSE(emptyVariant.isNull());
+  EXPECT_EQ(emptyVariant.kind(), TypeKind::VARBINARY);
+  EXPECT_EQ(emptyVariant.value<TypeKind::VARBINARY>(), emptyBinary);
+
+  auto simpleVariant = Variant::create<TypeKind::VARBINARY>(simpleBinary);
+  EXPECT_EQ(simpleVariant.value<TypeKind::VARBINARY>(), simpleBinary);
+
+  auto largeVariant = Variant::create<TypeKind::VARBINARY>(largeBinary);
+  EXPECT_EQ(largeVariant.value<TypeKind::VARBINARY>(), largeBinary);
+
+  // Other string types.
+  auto stdStringViewVariant =
+      Variant::create<TypeKind::VARBINARY>(std::string_view(simpleBinary));
+  EXPECT_EQ(stdStringViewVariant.value<TypeKind::VARBINARY>(), simpleBinary);
+
+  auto stringViewVariant =
+      Variant::create<TypeKind::VARBINARY>(StringView(simpleBinary));
+  EXPECT_EQ(stringViewVariant.value<TypeKind::VARBINARY>(), simpleBinary);
+
+  // Test move semantics.
+  std::string moveBinary = "Move binary!";
+  auto moveVariant =
+      Variant::create<TypeKind::VARBINARY>(std::move(moveBinary));
+  EXPECT_EQ(moveVariant.value<TypeKind::VARBINARY>(), "Move binary!");
+}
+
+TEST(VariantCreateTest, arrayType) {
+  // Empty array.
+  std::vector<Variant> emptyArray;
+  auto emptyVariant = Variant::create<TypeKind::ARRAY>(emptyArray);
+  EXPECT_FALSE(emptyVariant.isNull());
+  EXPECT_EQ(emptyVariant.kind(), TypeKind::ARRAY);
+  EXPECT_TRUE(emptyVariant.value<TypeKind::ARRAY>().empty());
+
+  // Array of integers.
+  std::vector<Variant> intArray = {
+      Variant(1), Variant(2), Variant(3), Variant(4)};
+  auto intVariant = Variant::create<TypeKind::ARRAY>(intArray);
+  const auto& resultIntArray = intVariant.value<TypeKind::ARRAY>();
+  EXPECT_EQ(resultIntArray.size(), 4);
+  EXPECT_EQ(resultIntArray[0].value<TypeKind::INTEGER>(), 1);
+  EXPECT_EQ(resultIntArray[3].value<TypeKind::INTEGER>(), 4);
+
+  // Array of strings.
+  std::vector<Variant> strArray = {
+      Variant("apple"), Variant("banana"), Variant("cherry")};
+  auto strVariant = Variant::create<TypeKind::ARRAY>(strArray);
+  const auto& resultStrArray = strVariant.value<TypeKind::ARRAY>();
+  EXPECT_EQ(resultStrArray.size(), 3);
+  EXPECT_EQ(resultStrArray[0].value<TypeKind::VARCHAR>(), "apple");
+
+  // Array with null elements.
+  std::vector<Variant> nullArray = {
+      Variant(1), Variant::null(TypeKind::INTEGER), Variant(3)};
+  auto nullVariant = Variant::create<TypeKind::ARRAY>(nullArray);
+  const auto& resultNullArray = nullVariant.value<TypeKind::ARRAY>();
+  EXPECT_EQ(resultNullArray.size(), 3);
+  EXPECT_FALSE(resultNullArray[0].isNull());
+  EXPECT_TRUE(resultNullArray[1].isNull());
+  EXPECT_FALSE(resultNullArray[2].isNull());
+
+  // Nested arrays.
+  std::vector<Variant> nestedArray = {
+      Variant::array({Variant(1), Variant(2)}),
+      Variant::array({Variant(3), Variant(4), Variant(5)})};
+  auto nestedVariant = Variant::create<TypeKind::ARRAY>(nestedArray);
+  const auto& resultNestedArray = nestedVariant.value<TypeKind::ARRAY>();
+  EXPECT_EQ(resultNestedArray.size(), 2);
+  EXPECT_EQ(resultNestedArray[0].value<TypeKind::ARRAY>().size(), 2);
+  EXPECT_EQ(resultNestedArray[1].value<TypeKind::ARRAY>().size(), 3);
+
+  // Test move semantics.
+  std::vector<Variant> moveArray = {Variant(100), Variant(200)};
+  auto moveVariant = Variant::create<TypeKind::ARRAY>(std::move(moveArray));
+  EXPECT_EQ(moveVariant.value<TypeKind::ARRAY>().size(), 2);
+}
+
+TEST(VariantCreateTest, mapType) {
+  // Empty map.
+  std::map<Variant, Variant> emptyMap;
+  auto emptyVariant = Variant::create<TypeKind::MAP>(emptyMap);
+  EXPECT_FALSE(emptyVariant.isNull());
+  EXPECT_EQ(emptyVariant.kind(), TypeKind::MAP);
+  EXPECT_TRUE(emptyVariant.value<TypeKind::MAP>().empty());
+
+  // Simple map.
+  std::map<Variant, Variant> simpleMap = {
+      {Variant(1), Variant("one")},
+      {Variant(2), Variant("two")},
+      {Variant(3), Variant("three")}};
+  auto simpleVariant = Variant::create<TypeKind::MAP>(simpleMap);
+  const auto& resultMap = simpleVariant.value<TypeKind::MAP>();
+  EXPECT_EQ(resultMap.size(), 3);
+  EXPECT_EQ(
+      resultMap.at(Variant(1)).value<TypeKind::VARCHAR>(), std::string("one"));
+  EXPECT_EQ(
+      resultMap.at(Variant(2)).value<TypeKind::VARCHAR>(), std::string("two"));
+
+  // Map with various key types.
+  std::map<Variant, Variant> stringKeyMap = {
+      {Variant("key1"), Variant(100)}, {Variant("key2"), Variant(200)}};
+  auto stringKeyVariant = Variant::create<TypeKind::MAP>(stringKeyMap);
+  const auto& resultStringKeyMap = stringKeyVariant.value<TypeKind::MAP>();
+  EXPECT_EQ(resultStringKeyMap.size(), 2);
+
+  // Map with null values.
+  std::map<Variant, Variant> nullValueMap = {
+      {Variant(1), Variant(10)},
+      {Variant(2), Variant::null(TypeKind::INTEGER)},
+      {Variant(3), Variant(30)}};
+  auto nullValueVariant = Variant::create<TypeKind::MAP>(nullValueMap);
+  const auto& resultNullValueMap = nullValueVariant.value<TypeKind::MAP>();
+  EXPECT_EQ(resultNullValueMap.size(), 3);
+  EXPECT_FALSE(resultNullValueMap.at(Variant(1)).isNull());
+  EXPECT_TRUE(resultNullValueMap.at(Variant(2)).isNull());
+
+  // Nested map.
+  std::map<Variant, Variant> nestedMap = {
+      {Variant(1), Variant::map({{Variant("a"), Variant(1)}})},
+      {Variant(2), Variant::map({{Variant("b"), Variant(2)}})}};
+  auto nestedVariant = Variant::create<TypeKind::MAP>(nestedMap);
+  const auto& resultNestedMap = nestedVariant.value<TypeKind::MAP>();
+  EXPECT_EQ(resultNestedMap.size(), 2);
+
+  // Test move semantics.
+  std::map<Variant, Variant> moveMap = {{Variant(99), Variant("ninety-nine")}};
+  auto moveVariant = Variant::create<TypeKind::MAP>(std::move(moveMap));
+  EXPECT_EQ(moveVariant.value<TypeKind::MAP>().size(), 1);
+}
+
+TEST(VariantCreateTest, rowType) {
+  // Empty row.
+  std::vector<Variant> emptyRow;
+  auto emptyVariant = Variant::create<TypeKind::ROW>(emptyRow);
+  EXPECT_FALSE(emptyVariant.isNull());
+  EXPECT_EQ(emptyVariant.kind(), TypeKind::ROW);
+  EXPECT_TRUE(emptyVariant.value<TypeKind::ROW>().empty());
+
+  // Simple row.
+  std::vector<Variant> simpleRow = {Variant(1), Variant("test"), Variant(3.14)};
+  auto simpleVariant = Variant::create<TypeKind::ROW>(simpleRow);
+  const auto& resultRow = simpleVariant.value<TypeKind::ROW>();
+  EXPECT_EQ(resultRow.size(), 3);
+  EXPECT_EQ(resultRow[0].value<TypeKind::INTEGER>(), 1);
+  EXPECT_EQ(resultRow[1].value<TypeKind::VARCHAR>(), "test");
+  EXPECT_DOUBLE_EQ(resultRow[2].value<TypeKind::DOUBLE>(), 3.14);
+
+  // Row with null fields
+  std::vector<Variant> nullRow = {
+      Variant(100),
+      Variant::null(TypeKind::VARCHAR),
+      Variant(200),
+      Variant::null(TypeKind::DOUBLE)};
+  auto nullVariant = Variant::create<TypeKind::ROW>(nullRow);
+  const auto& resultNullRow = nullVariant.value<TypeKind::ROW>();
+  EXPECT_EQ(resultNullRow.size(), 4);
+  EXPECT_FALSE(resultNullRow[0].isNull());
+  EXPECT_TRUE(resultNullRow[1].isNull());
+  EXPECT_FALSE(resultNullRow[2].isNull());
+  EXPECT_TRUE(resultNullRow[3].isNull());
+
+  // Nested row.
+  std::vector<Variant> nestedRow = {
+      Variant(1),
+      Variant::row({Variant("nested"), Variant(42)}),
+      Variant(true)};
+  auto nestedVariant = Variant::create<TypeKind::ROW>(nestedRow);
+  const auto& resultNestedRow = nestedVariant.value<TypeKind::ROW>();
+  EXPECT_EQ(resultNestedRow.size(), 3);
+  EXPECT_EQ(resultNestedRow[1].value<TypeKind::ROW>().size(), 2);
+
+  // Complex row with mixed types.
+  std::vector<Variant> complexRow = {
+      Variant(static_cast<int8_t>(127)),
+      Variant(static_cast<int16_t>(32000)),
+      Variant(static_cast<int32_t>(2000000)),
+      Variant(static_cast<int64_t>(9000000000LL)),
+      Variant(static_cast<int128_t>(12345)),
+      Variant(1.23f),
+      Variant(4.56789),
+      Variant("complex string"),
+      Variant(Timestamp(1000, 2000)),
+      Variant::array({Variant(1), Variant(2), Variant(3)}),
+      Variant::map({{Variant("key"), Variant("value")}})};
+  auto complexVariant = Variant::create<TypeKind::ROW>(complexRow);
+  const auto& resultComplexRow = complexVariant.value<TypeKind::ROW>();
+  EXPECT_EQ(resultComplexRow.size(), 11);
+
+  // Test move semantics.
+  std::vector<Variant> moveRow = {Variant(999), Variant("move")};
+  auto moveVariant = Variant::create<TypeKind::ROW>(std::move(moveRow));
+  EXPECT_EQ(moveVariant.value<TypeKind::ROW>().size(), 2);
+}
+
+// Test the template <typename T> create() version. This version uses
+// CppToType<T>::typeKind to deduce the TypeKind.
+TEST(VariantCreateTest, templateTypeVersion) {
+  // Test with bool.
+  bool boolVal = true;
+  auto boolVariant = Variant::create<bool>(boolVal);
+  EXPECT_EQ(boolVariant.kind(), TypeKind::BOOLEAN);
+  EXPECT_TRUE(boolVariant.value<TypeKind::BOOLEAN>());
+
+  // Test with int32_t.
+  int32_t intVal = 42;
+  auto intVariant = Variant::create<int32_t>(intVal);
+  EXPECT_EQ(intVariant.kind(), TypeKind::INTEGER);
+  EXPECT_EQ(intVariant.value<TypeKind::INTEGER>(), 42);
+
+  // Test with int64_t.
+  int64_t bigintVal = 9876543210LL;
+  auto bigintVariant = Variant::create<int64_t>(bigintVal);
+  EXPECT_EQ(bigintVariant.kind(), TypeKind::BIGINT);
+  EXPECT_EQ(bigintVariant.value<TypeKind::BIGINT>(), 9876543210LL);
+
+  // Test with float.
+  float floatVal = 3.14f;
+  auto floatVariant = Variant::create<float>(floatVal);
+  EXPECT_EQ(floatVariant.kind(), TypeKind::REAL);
+  EXPECT_FLOAT_EQ(floatVariant.value<TypeKind::REAL>(), 3.14f);
+
+  // Test with double.
+  double doubleVal = 2.71828;
+  auto doubleVariant = Variant::create<double>(doubleVal);
+  EXPECT_EQ(doubleVariant.kind(), TypeKind::DOUBLE);
+  EXPECT_DOUBLE_EQ(doubleVariant.value<TypeKind::DOUBLE>(), 2.71828);
+
+  // Test with std::string (VARCHAR).
+  std::string strVal = "test string";
+  auto strVariant = Variant::create<std::string>(strVal);
+  EXPECT_EQ(strVariant.kind(), TypeKind::VARCHAR);
+  EXPECT_EQ(strVariant.value<TypeKind::VARCHAR>(), "test string");
+}
+
+TEST(VariantCreateTest, moveSemantics) {
+  // Test move semantics explicitly for large objects
+
+  // Large string.
+  std::string largeString(10000, 'x');
+  auto moveStringVariant =
+      Variant::create<TypeKind::VARCHAR>(std::move(largeString));
+  EXPECT_EQ(moveStringVariant.value<TypeKind::VARCHAR>().size(), 10000);
+  // Original string should be moved-from (typically empty, but not guaranteed)
+
+  // Large array.
+  std::vector<Variant> largeArray;
+  for (int i = 0; i < 1000; ++i) {
+    largeArray.push_back(Variant(i));
+  }
+  auto moveArrayVariant =
+      Variant::create<TypeKind::ARRAY>(std::move(largeArray));
+  EXPECT_EQ(moveArrayVariant.value<TypeKind::ARRAY>().size(), 1000);
+
+  // Large map.
+  std::map<Variant, Variant> largeMap;
+  for (int i = 0; i < 1000; ++i) {
+    largeMap.emplace(Variant(i), Variant(i * 2));
+  }
+  auto moveMapVariant = Variant::create<TypeKind::MAP>(std::move(largeMap));
+  EXPECT_EQ(moveMapVariant.value<TypeKind::MAP>().size(), 1000);
+
+  // Large row.
+  std::vector<Variant> largeRow;
+  for (int i = 0; i < 5000; ++i) {
+    largeRow.push_back(Variant(static_cast<int64_t>(i)));
+  }
+  auto moveRowVariant = Variant::create<TypeKind::ROW>(std::move(largeRow));
+  EXPECT_EQ(moveRowVariant.value<TypeKind::ROW>().size(), 5000);
+}
+
+TEST(VariantCreateTest, copySemantics) {
+  // Test copy semantics to ensure values are properly copied
+
+  // Test with string
+  std::string originalString = "original";
+  auto copiedStringVariant = Variant::create<TypeKind::VARCHAR>(originalString);
+  EXPECT_EQ(copiedStringVariant.value<TypeKind::VARCHAR>(), "original");
+  EXPECT_EQ(originalString, "original"); // Original should be unchanged
+
+  // Test with array
+  std::vector<Variant> originalArray = {Variant(1), Variant(2), Variant(3)};
+  auto copiedArrayVariant = Variant::create<TypeKind::ARRAY>(originalArray);
+  EXPECT_EQ(copiedArrayVariant.value<TypeKind::ARRAY>().size(), 3);
+  EXPECT_EQ(originalArray.size(), 3); // Original should be unchanged
+
+  // Test with map
+  std::map<Variant, Variant> originalMap = {
+      {Variant(1), Variant("one")}, {Variant(2), Variant("two")}};
+  auto copiedMapVariant = Variant::create<TypeKind::MAP>(originalMap);
+  EXPECT_EQ(copiedMapVariant.value<TypeKind::MAP>().size(), 2);
+  EXPECT_EQ(originalMap.size(), 2); // Original should be unchanged
+
+  // Test with row
+  std::vector<Variant> originalRow = {
+      Variant(100), Variant("test"), Variant(3.14)};
+  auto copiedRowVariant = Variant::create<TypeKind::ROW>(originalRow);
+  EXPECT_EQ(copiedRowVariant.value<TypeKind::ROW>().size(), 3);
+  EXPECT_EQ(originalRow.size(), 3); // Original should be unchanged
+}
+
+TEST(VariantCreateTest, equalityAfterCreate) {
+  // Test that variants created via create() are equal to those created via
+  // constructors/factory methods
+
+  // BOOLEAN
+  auto boolCreate = Variant::create<TypeKind::BOOLEAN>(true);
+  auto boolConstructor = Variant(true);
+  EXPECT_EQ(boolCreate, boolConstructor);
+
+  // INTEGER
+  auto intCreate = Variant::create<TypeKind::INTEGER>(42);
+  auto intConstructor = Variant(42);
+  EXPECT_EQ(intCreate, intConstructor);
+
+  // BIGINT
+  auto bigintCreate = Variant::create<TypeKind::BIGINT>(9876543210LL);
+  auto bigintConstructor = Variant(9876543210LL);
+  EXPECT_EQ(bigintCreate, bigintConstructor);
+
+  // REAL
+  auto realCreate = Variant::create<TypeKind::REAL>(3.14f);
+  auto realConstructor = Variant(3.14f);
+  EXPECT_TRUE(realCreate.equalsWithEpsilon(realConstructor));
+
+  // DOUBLE
+  auto doubleCreate = Variant::create<TypeKind::DOUBLE>(2.71828);
+  auto doubleConstructor = Variant(2.71828);
+  EXPECT_TRUE(doubleCreate.equalsWithEpsilon(doubleConstructor));
+
+  // VARCHAR
+  auto varcharCreate = Variant::create<TypeKind::VARCHAR>(std::string("test"));
+  auto varcharConstructor = Variant("test");
+  EXPECT_EQ(varcharCreate, varcharConstructor);
+
+  // TIMESTAMP
+  Timestamp ts(12345, 67890);
+  auto timestampCreate = Variant::create<TypeKind::TIMESTAMP>(ts);
+  auto timestampFactory = Variant::timestamp(ts);
+  EXPECT_EQ(timestampCreate, timestampFactory);
+
+  // ARRAY
+  std::vector<Variant> arr = {Variant(1), Variant(2), Variant(3)};
+  auto arrayCreate = Variant::create<TypeKind::ARRAY>(arr);
+  auto arrayFactory = Variant::array(arr);
+  EXPECT_EQ(arrayCreate, arrayFactory);
+
+  // MAP
+  std::map<Variant, Variant> mp = {
+      {Variant(1), Variant("one")}, {Variant(2), Variant("two")}};
+  auto mapCreate = Variant::create<TypeKind::MAP>(mp);
+  auto mapFactory = Variant::map(mp);
+  EXPECT_EQ(mapCreate, mapFactory);
+
+  // ROW
+  std::vector<Variant> r = {Variant(1), Variant("test"), Variant(3.14)};
+  auto rowCreate = Variant::create<TypeKind::ROW>(r);
+  auto rowFactory = Variant::row(r);
+  EXPECT_EQ(rowCreate, rowFactory);
+}
+
+TEST(VariantCreateTest, hashConsistency) {
+  // Test that variants created via create() have consistent hashes
+
+  // Same values should have same hash
+  auto v1 = Variant::create<TypeKind::INTEGER>(42);
+  auto v2 = Variant::create<TypeKind::INTEGER>(42);
+  EXPECT_EQ(v1.hash(), v2.hash());
+
+  // Different values should (usually) have different hashes
+  auto v3 = Variant::create<TypeKind::INTEGER>(43);
+  EXPECT_NE(v1.hash(), v3.hash());
+
+  // Test with strings
+  auto s1 = Variant::create<TypeKind::VARCHAR>(std::string("hello"));
+  auto s2 = Variant::create<TypeKind::VARCHAR>(std::string("hello"));
+  auto s3 = Variant::create<TypeKind::VARCHAR>(std::string("world"));
+  EXPECT_EQ(s1.hash(), s2.hash());
+  EXPECT_NE(s1.hash(), s3.hash());
+
+  // Test with arrays
+  std::vector<Variant> arr1 = {Variant(1), Variant(2)};
+  std::vector<Variant> arr2 = {Variant(1), Variant(2)};
+  std::vector<Variant> arr3 = {Variant(1), Variant(3)};
+  auto a1 = Variant::create<TypeKind::ARRAY>(arr1);
+  auto a2 = Variant::create<TypeKind::ARRAY>(arr2);
+  auto a3 = Variant::create<TypeKind::ARRAY>(arr3);
+  EXPECT_EQ(a1.hash(), a2.hash());
+  EXPECT_NE(a1.hash(), a3.hash());
+}
+
+TEST(VariantCreateTest, typeInference) {
+  // Test that variants created via create() correctly infer their types
+
+  auto boolVar = Variant::create<TypeKind::BOOLEAN>(true);
+  EXPECT_EQ(*boolVar.inferType(), *BOOLEAN());
+
+  auto intVar = Variant::create<TypeKind::INTEGER>(42);
+  EXPECT_EQ(*intVar.inferType(), *INTEGER());
+
+  auto bigintVar = Variant::create<TypeKind::BIGINT>(9876543210LL);
+  EXPECT_EQ(*bigintVar.inferType(), *BIGINT());
+
+  auto realVar = Variant::create<TypeKind::REAL>(3.14f);
+  EXPECT_EQ(*realVar.inferType(), *REAL());
+
+  auto doubleVar = Variant::create<TypeKind::DOUBLE>(2.71828);
+  EXPECT_EQ(*doubleVar.inferType(), *DOUBLE());
+
+  auto varcharVar = Variant::create<TypeKind::VARCHAR>(std::string("test"));
+  EXPECT_EQ(*varcharVar.inferType(), *VARCHAR());
+
+  auto timestampVar =
+      Variant::create<TypeKind::TIMESTAMP>(Timestamp(12345, 67890));
+  EXPECT_EQ(*timestampVar.inferType(), *TIMESTAMP());
+
+  auto arrayVar =
+      Variant::create<TypeKind::ARRAY>(std::vector<Variant>{Variant(1)});
+  EXPECT_EQ(*arrayVar.inferType(), *ARRAY(INTEGER()));
+
+  auto mapVar = Variant::create<TypeKind::MAP>(
+      std::map<Variant, Variant>{{Variant(1), Variant("one")}});
+  EXPECT_EQ(*mapVar.inferType(), *MAP(INTEGER(), VARCHAR()));
+
+  auto rowVar = Variant::create<TypeKind::ROW>(
+      std::vector<Variant>{Variant(1), Variant("test")});
+  EXPECT_EQ(*rowVar.inferType(), *ROW({INTEGER(), VARCHAR()}));
 }
 
 TEST(VariantTest, arrayInferType) {
@@ -158,81 +691,19 @@ TEST(VariantTest, rowTypeCompatibility) {
   EXPECT_FALSE(row.isTypeCompatible(BIGINT()));
 }
 
-struct Foo {};
-
-struct Bar {};
-
-TEST(VariantTest, opaque) {
-  auto foo = std::make_shared<Foo>();
-  auto foo2 = std::make_shared<Foo>();
-  auto bar = std::make_shared<Bar>();
-  {
-    Variant v = Variant::opaque(foo);
-    EXPECT_TRUE(v.hasValue());
-    EXPECT_EQ(TypeKind::OPAQUE, v.kind());
-    EXPECT_EQ(foo, v.opaque<Foo>());
-    EXPECT_THROW(v.opaque<Bar>(), std::exception);
-    EXPECT_EQ(*v.inferType(), *OPAQUE<Foo>());
-  }
-
-  // Check that the expected shared ptrs are acquired.
-  {
-    EXPECT_EQ(1, foo.use_count());
-    Variant v = Variant::opaque(foo);
-    EXPECT_EQ(2, foo.use_count());
-    Variant vv = v;
-    EXPECT_EQ(3, foo.use_count());
-    { Variant tmp = std::move(vv); }
-    EXPECT_EQ(2, foo.use_count());
-    v = 0;
-    EXPECT_EQ(1, foo.use_count());
-  }
-
-  // Test opaque equality.
-  {
-    Variant v1 = Variant::opaque(foo);
-    Variant vv1 = Variant::opaque(foo);
-    Variant v2 = Variant::opaque(foo2);
-    Variant v3 = Variant::opaque(bar);
-    Variant vint = 123;
-    EXPECT_EQ(v1, vv1);
-    EXPECT_NE(v1, v2);
-    EXPECT_NE(v1, v3);
-    EXPECT_NE(v1, vint);
-  }
-
-  // Test hashes. The semantic of the hash follows the object it points to
-  // (it hashes the pointer).
-  {
-    Variant v1 = Variant::opaque(foo);
-    Variant vv1 = Variant::opaque(foo);
-
-    Variant v2 = Variant::opaque(foo2);
-    Variant v3 = Variant::opaque(bar);
-
-    EXPECT_EQ(v1.hash(), vv1.hash());
-    EXPECT_NE(v1.hash(), v2.hash());
-    EXPECT_NE(vv1.hash(), v2.hash());
-
-    EXPECT_NE(v1.hash(), v3.hash());
-    EXPECT_NE(v2.hash(), v3.hash());
-  }
-
-  // Test opaque casting.
-  {
-    Variant fooOpaque = Variant::opaque(foo);
-    Variant barOpaque = Variant::opaque(bar);
-    Variant int1 = Variant((int64_t)123);
-
-    auto castFoo1 = fooOpaque.tryOpaque<Foo>();
-    auto castBar1 = fooOpaque.tryOpaque<Bar>();
-    auto castBar2 = barOpaque.tryOpaque<Bar>();
-
-    EXPECT_EQ(castFoo1, foo);
-    EXPECT_EQ(castBar1, nullptr);
-    EXPECT_EQ(castBar2, bar);
-    EXPECT_THROW(int1.tryOpaque<Foo>(), std::invalid_argument);
-  }
+TEST(VariantTest, nullVariant) {
+  // Type of null variant is UNKNOWN and should be compatible with all types.
+  auto nullVariant = Variant{};
+  ASSERT_TRUE(nullVariant.isTypeCompatible(VARCHAR()));
+  ASSERT_TRUE(nullVariant.isTypeCompatible(INTEGER()));
+  ASSERT_TRUE(nullVariant.isTypeCompatible(BIGINT()));
+  ASSERT_TRUE(nullVariant.isTypeCompatible(DOUBLE()));
+  ASSERT_TRUE(nullVariant.isTypeCompatible(DATE()));
+  ASSERT_TRUE(nullVariant.isTypeCompatible(TIMESTAMP()));
+  ASSERT_TRUE(nullVariant.isTypeCompatible(MAP(BIGINT(), DOUBLE())));
+  ASSERT_TRUE(nullVariant.isTypeCompatible(ARRAY(DATE())));
+  ASSERT_TRUE(
+      nullVariant.isTypeCompatible(ROW({DATE(), BIGINT(), TIMESTAMP()})));
 }
 
 /// Test Variant::equalsWithEpsilon by summing up large 64-bit integers (> 15
@@ -328,6 +799,152 @@ TEST(VariantTest, equalsWithEpsilonFloat) {
   ASSERT_FALSE(Variant(sum1).equalsWithEpsilon(Variant(sum3)));
 }
 
+TEST(VariantTest, nullEqualsNullPrimitiveTypes) {
+  auto testNullEquality = [](const TypeKind& kind) {
+    const auto null = Variant::null(kind);
+    ASSERT_EQ(
+        null.equals(null, CompareFlags::NullHandlingMode::kNullAsIndeterminate),
+        std::nullopt);
+    auto compareResult =
+        null.equals(null, CompareFlags::NullHandlingMode::kNullAsValue);
+    ASSERT_TRUE(compareResult.has_value());
+    ASSERT_TRUE(compareResult.value());
+  };
+
+  // null = null is
+  //  - indeterminate with kNullAsIndeterminate nullHandlingMode.
+  //  - true with kNullAsValue nullHandlingMode.
+  testNullEquality(TypeKind::SMALLINT);
+  testNullEquality(TypeKind::INTEGER);
+  testNullEquality(TypeKind::BIGINT);
+  testNullEquality(TypeKind::VARCHAR);
+  testNullEquality(TypeKind::VARBINARY);
+  testNullEquality(TypeKind::DOUBLE);
+  testNullEquality(TypeKind::TIMESTAMP);
+  testNullEquality(TypeKind::ARRAY);
+  testNullEquality(TypeKind::MAP);
+  testNullEquality(TypeKind::ROW);
+}
+
+TEST(VariantTest, arrayComparisonWithNullElements) {
+  auto makeArray = [](const std::vector<std::optional<int32_t>>& elements) {
+    std::vector<Variant> arrayElements;
+    for (const auto& element : elements) {
+      if (element.has_value()) {
+        arrayElements.emplace_back(element.value());
+      } else {
+        arrayElements.push_back(Variant::null(TypeKind::INTEGER));
+      }
+    }
+    return Variant::array(arrayElements);
+  };
+
+  auto a = makeArray({5, std::nullopt, 1});
+  auto b = makeArray({5, std::nullopt, 1});
+  auto c = makeArray({5, std::nullopt, 2});
+
+  // Both are non-null arrays with null elements inside.
+  // With kNullAsValue, they should be equal if all elements match.
+  auto result = a.equals(b, CompareFlags::NullHandlingMode::kNullAsValue);
+  ASSERT_TRUE(result.has_value());
+  ASSERT_TRUE(result.value());
+
+  // With kNullAsIndeterminate, null elements make the comparison indeterminate.
+  result = a.equals(b, CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+  ASSERT_FALSE(result.has_value());
+
+  // Comparison of arrays with different elements and null inside fails both
+  // with kNullAsValue and kNullAsIndeterminate modes.
+  result = a.equals(c, CompareFlags::NullHandlingMode::kNullAsValue);
+  ASSERT_TRUE(result.has_value());
+  ASSERT_FALSE(result.value());
+
+  result = a.equals(c, CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+  ASSERT_TRUE(result.has_value());
+  ASSERT_FALSE(result.value());
+}
+
+TEST(VariantTest, rowComparisonWithNullElements) {
+  auto makeRow = [](int32_t before,
+                    const std::optional<std::string>& middle,
+                    double after) {
+    std::vector<Variant> rowElements;
+    rowElements.emplace_back(before);
+    if (middle.has_value()) {
+      rowElements.emplace_back(middle.value());
+    } else {
+      rowElements.push_back(Variant::null(TypeKind::VARCHAR));
+    }
+    rowElements.emplace_back(after);
+    return Variant::row(rowElements);
+  };
+
+  auto a = makeRow(5, std::nullopt, 1.0);
+  auto b = makeRow(5, std::nullopt, 1.0);
+  auto c = makeRow(5, std::nullopt, 2.0);
+
+  // Rows with null elements inside and kNullAsValue should match if nulls
+  // match.
+  auto result = a.equals(b, CompareFlags::NullHandlingMode::kNullAsValue);
+  ASSERT_TRUE(result.has_value());
+  ASSERT_TRUE(result.value());
+
+  // With kNullAsIndeterminate, null elements make the comparison indeterminate.
+  result = a.equals(b, CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+  ASSERT_FALSE(result.has_value());
+
+  // Comparison of rows with different elements and null inside fails both
+  // with kNullAsValue and kNullAsIndeterminate modes.
+  result = a.equals(b, CompareFlags::NullHandlingMode::kNullAsValue);
+  ASSERT_TRUE(result.has_value());
+  ASSERT_TRUE(result.value());
+
+  result = a.equals(c, CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+  ASSERT_TRUE(result.has_value());
+  ASSERT_FALSE(result.value());
+}
+
+TEST(VariantTest, mapComparisonWithNullElements) {
+  auto makeMap =
+      [](const std::vector<std::pair<int32_t, std::optional<int32_t>>>&
+             entries) {
+        std::map<Variant, Variant> m;
+        for (const auto& e : entries) {
+          if (e.second.has_value()) {
+            m.emplace(Variant(e.first), Variant(e.second.value()));
+          } else {
+            m.emplace(Variant(e.first), Variant::null(TypeKind::INTEGER));
+          }
+        }
+        return Variant::map(m);
+      };
+
+  auto a = makeMap({{0, 9}, {1, std::nullopt}, {2, 3}});
+  auto b = makeMap({{0, 9}, {1, std::nullopt}, {2, 3}});
+  auto c = makeMap({{0, 9}, {1, std::nullopt}, {2, 4}});
+
+  // Both are non-null maps with null values inside.
+  // With kNullAsValue, they should be equal if all keys and values match.
+  auto result = a.equals(b, CompareFlags::NullHandlingMode::kNullAsValue);
+  ASSERT_TRUE(result.has_value());
+  ASSERT_TRUE(result.value());
+
+  // With kNullAsIndeterminate, null elements make the comparison
+  // indeterminate when keys/values are otherwise identical.
+  result = a.equals(b, CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+  ASSERT_FALSE(result.has_value());
+
+  // Maps with different values for a given key (after a null) should be a
+  // definitive mismatch under both null handling modes.
+  result = a.equals(c, CompareFlags::NullHandlingMode::kNullAsValue);
+  ASSERT_TRUE(result.has_value());
+  ASSERT_FALSE(result.value());
+
+  result = a.equals(c, CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+  ASSERT_TRUE(result.has_value());
+  ASSERT_FALSE(result.value());
+}
+
 TEST(VariantTest, mapWithNaNKey) {
   // Verify that map variants treat all NaN keys as equivalent and comparable
   // (consider them the largest) with other values.
@@ -356,7 +973,96 @@ TEST(VariantTest, mapWithNaNKey) {
   }
 }
 
-TEST(VariantTest, serialize) {
+struct Foo {};
+struct Bar {};
+
+TEST(VariantOpaqueTest, opaque) {
+  auto foo = std::make_shared<Foo>();
+  auto foo2 = std::make_shared<Foo>();
+  auto bar = std::make_shared<Bar>();
+  {
+    Variant v = Variant::opaque(foo);
+    EXPECT_TRUE(v.hasValue());
+    EXPECT_EQ(TypeKind::OPAQUE, v.kind());
+    EXPECT_EQ(foo, v.opaque<Foo>());
+    VELOX_ASSERT_THROW(
+        v.opaque<Bar>(),
+        "Requested OPAQUE<facebook::velox::test::(anonymous namespace)::Bar> but contains OPAQUE<facebook::velox::test::(anonymous namespace)::Foo>");
+    EXPECT_EQ(*v.inferType(), *OPAQUE<Foo>());
+  }
+
+  // Check that the expected shared ptrs are acquired.
+  {
+    EXPECT_EQ(1, foo.use_count());
+    Variant v = Variant::opaque(foo);
+    EXPECT_EQ(2, foo.use_count());
+    Variant vv = v;
+    EXPECT_EQ(3, foo.use_count());
+    {
+      Variant tmp = std::move(vv);
+    }
+    EXPECT_EQ(2, foo.use_count());
+    v = 0;
+    EXPECT_EQ(1, foo.use_count());
+  }
+
+  // Test opaque equality.
+  {
+    Variant v1 = Variant::opaque(foo);
+    Variant vv1 = Variant::opaque(foo);
+    Variant v2 = Variant::opaque(foo2);
+    Variant v3 = Variant::opaque(bar);
+    Variant vint = 123;
+    EXPECT_EQ(v1, vv1);
+    EXPECT_NE(v1, v2);
+    EXPECT_NE(v1, v3);
+    EXPECT_NE(v1, vint);
+  }
+
+  // Test hashes. The semantic of the hash follows the object it points to
+  // (it hashes the pointer).
+  {
+    Variant v1 = Variant::opaque(foo);
+    Variant vv1 = Variant::opaque(foo);
+
+    Variant v2 = Variant::opaque(foo2);
+    Variant v3 = Variant::opaque(bar);
+
+    EXPECT_EQ(v1.hash(), vv1.hash());
+    EXPECT_NE(v1.hash(), v2.hash());
+    EXPECT_NE(vv1.hash(), v2.hash());
+
+    EXPECT_NE(v1.hash(), v3.hash());
+    EXPECT_NE(v2.hash(), v3.hash());
+  }
+
+  // Test opaque casting.
+  {
+    Variant fooOpaque = Variant::opaque(foo);
+    Variant barOpaque = Variant::opaque(bar);
+    Variant int1 = Variant((int64_t)123);
+
+    auto castFoo1 = fooOpaque.tryOpaque<Foo>();
+    auto castBar1 = fooOpaque.tryOpaque<Bar>();
+    auto castBar2 = barOpaque.tryOpaque<Bar>();
+
+    EXPECT_EQ(castFoo1, foo);
+    EXPECT_EQ(castBar1, nullptr);
+    EXPECT_EQ(castBar2, bar);
+    VELOX_ASSERT_THROW(int1.tryOpaque<Foo>(), "wrong kind! BIGINT != OPAQUE");
+  }
+}
+
+void testSerDe(const Variant& value) {
+  auto dynamic = value.serialize();
+  auto copy = Variant::create(dynamic);
+  ASSERT_EQ(value, copy);
+  auto json = folly::toJson(value.serialize());
+  copy = Variant::create(folly::parseJson(json));
+  ASSERT_EQ(value, copy);
+}
+
+TEST(VariantSerializationTest, serialize) {
   // Null values.
   testSerDe(Variant(TypeKind::BOOLEAN));
   testSerDe(Variant(TypeKind::TINYINT));
@@ -381,11 +1087,361 @@ TEST(VariantTest, serialize) {
   testSerDe(Variant(static_cast<int64_t>(1234567)));
   testSerDe(Variant(static_cast<float>(1.2f)));
   testSerDe(Variant(static_cast<double>(1.234)));
+  testSerDe(
+      Variant(static_cast<float>(std::numeric_limits<float>::quiet_NaN())));
+  testSerDe(
+      Variant(static_cast<double>(std::numeric_limits<double>::quiet_NaN())));
+  testSerDe(
+      Variant(static_cast<float>(std::numeric_limits<float>::signaling_NaN())));
+  testSerDe(Variant(
+      static_cast<double>(std::numeric_limits<double>::signaling_NaN())));
+  testSerDe(
+      Variant(static_cast<float>(std::numeric_limits<float>::infinity())));
+  testSerDe(
+      Variant(static_cast<double>(std::numeric_limits<double>::infinity())));
   testSerDe(Variant("This is a test."));
   testSerDe(Variant::binary("This is a test."));
   testSerDe(Variant(Timestamp(1, 2)));
 }
 
+TEST(VariantSerializationTest, serializeArrayTypes) {
+  // Empty array.
+  testSerDe(Variant::array({}));
+
+  // Simple array with primitive elements.
+  testSerDe(Variant::array({Variant(1), Variant(2), Variant(3)}));
+
+  // Array with integers of same type.
+  testSerDe(
+      Variant::array({
+          Variant(static_cast<int32_t>(1)),
+          Variant(static_cast<int32_t>(100)),
+          Variant(static_cast<int32_t>(10000)),
+      }));
+
+  // Array with strings.
+  testSerDe(
+      Variant::array({
+          Variant("hello"),
+          Variant("world"),
+          Variant("test"),
+      }));
+
+  // Array with mixed null and non-null elements.
+  testSerDe(
+      Variant::array({
+          Variant(1),
+          Variant::null(TypeKind::INTEGER),
+          Variant(3),
+          Variant::null(TypeKind::INTEGER),
+      }));
+
+  // Array with floating point values.
+  testSerDe(
+      Variant::array({
+          Variant(1.5),
+          Variant(2.7),
+          Variant(-3.14),
+          Variant(std::numeric_limits<double>::quiet_NaN()),
+          Variant(std::numeric_limits<double>::signaling_NaN()),
+          Variant(std::numeric_limits<double>::infinity()),
+      }));
+
+  // Array with boolean values.
+  testSerDe(
+      Variant::array({
+          Variant(true),
+          Variant(false),
+          Variant(true),
+      }));
+
+  // Array with timestamps.
+  testSerDe(
+      Variant::array({
+          Variant(Timestamp(1000, 500)),
+          Variant(Timestamp(2000, 1000)),
+      }));
+
+  // Nested array (array of arrays).
+  testSerDe(
+      Variant::array({
+          Variant::array({Variant(1), Variant(2)}),
+          Variant::array({Variant(3), Variant(4), Variant(5)}),
+          Variant::array({}),
+      }));
+
+  // Deeply nested arrays.
+  testSerDe(
+      Variant::array({Variant::array(
+          {Variant::array({Variant(1), Variant(2)}),
+           Variant::array({Variant(3)})})}));
+
+  // Array with null array elements.
+  testSerDe(
+      Variant::array({
+          Variant::array({Variant(1)}),
+          Variant::null(TypeKind::ARRAY),
+          Variant::array({Variant(2)}),
+      }));
+
+  // Large array.
+  std::vector<Variant> largeArray;
+  for (int i = 0; i < 100; ++i) {
+    largeArray.push_back(Variant(i));
+  }
+  testSerDe(Variant::array(largeArray));
+}
+
+TEST(VariantSerializationTest, serializeMapTypes) {
+  // Empty map.
+  testSerDe(Variant::map({}));
+
+  // Simple map with integer keys and string values.
+  testSerDe(
+      Variant::map({
+          {Variant(1), Variant("one")},
+          {Variant(2), Variant("two")},
+          {Variant(3), Variant("three")},
+      }));
+
+  // Map with string keys and integer values.
+  testSerDe(
+      Variant::map({
+          {Variant("a"), Variant(1)},
+          {Variant("b"), Variant(2)},
+          {Variant("c"), Variant(3)},
+      }));
+
+  // Map with null values.
+  testSerDe(
+      Variant::map({
+          {Variant(1), Variant(100)},
+          {Variant(2), Variant::null(TypeKind::INTEGER)},
+          {Variant(3), Variant(300)},
+      }));
+
+  // Map with floating point keys and values.
+  testSerDe(
+      Variant::map({
+          {Variant(1.5), Variant(10.5)},
+          {Variant(2.5), Variant(20.5)},
+      }));
+
+  // Map with boolean keys.
+  testSerDe(
+      Variant::map({
+          {Variant(true), Variant("yes")},
+          {Variant(false), Variant("no")},
+      }));
+
+  // Nested map (map of maps).
+  testSerDe(
+      Variant::map({
+          {Variant(1),
+           Variant::map({
+               {Variant("a"), Variant(10)},
+               {Variant("b"), Variant(20)},
+           })},
+          {Variant(2),
+           Variant::map({
+               {Variant("c"), Variant(30)},
+           })},
+      }));
+
+  // Map with array values.
+  testSerDe(
+      Variant::map({
+          {Variant(1), Variant::array({Variant(10), Variant(20)})},
+          {Variant(2), Variant::array({Variant(30), Variant(40), Variant(50)})},
+      }));
+
+  // Map with complex mixed types.
+  testSerDe(
+      Variant::map({
+          {Variant(1), Variant("string")},
+          {Variant(2), Variant(42)},
+          {Variant(3), Variant(3.14)},
+          {Variant(4), Variant(true)},
+      }));
+
+  // Map with timestamp keys and values.
+  testSerDe(
+      Variant::map({
+          {Variant(Timestamp(1000, 0)), Variant(Timestamp(2000, 0))},
+          {Variant(Timestamp(3000, 500)), Variant(Timestamp(4000, 1000))},
+      }));
+
+  // Large map.
+  std::map<Variant, Variant> largeMap;
+  for (int i = 0; i < 100; ++i) {
+    largeMap.emplace(Variant(i), Variant(i * 10));
+  }
+  testSerDe(Variant::map(largeMap));
+}
+
+TEST(VariantSerializationTest, serializeRowTypes) {
+  // Empty row.
+  testSerDe(Variant::row({}));
+
+  // Simple row with primitive fields.
+  testSerDe(Variant::row({Variant(1), Variant("test"), Variant(3.14)}));
+
+  // Row with different integer types.
+  testSerDe(
+      Variant::row({
+          Variant(static_cast<int8_t>(1)),
+          Variant(static_cast<int16_t>(100)),
+          Variant(static_cast<int32_t>(10000)),
+          Variant(static_cast<int64_t>(1000000LL)),
+      }));
+
+  // Row with null fields.
+  testSerDe(
+      Variant::row({
+          Variant(1),
+          Variant::null(TypeKind::VARCHAR),
+          Variant(3.14),
+          Variant::null(TypeKind::INTEGER),
+      }));
+
+  // Row with all null fields.
+  testSerDe(
+      Variant::row({
+          Variant::null(TypeKind::INTEGER),
+          Variant::null(TypeKind::VARCHAR),
+          Variant::null(TypeKind::DOUBLE),
+      }));
+
+  // Row with boolean fields.
+  testSerDe(Variant::row({Variant(true), Variant(false), Variant(true)}));
+
+  // Row with floating point fields.
+  testSerDe(
+      Variant::row({Variant(1.5f), Variant(2.7), Variant(-3.14159265358979)}));
+
+  // Row with timestamp fields.
+  testSerDe(
+      Variant::row({
+          Variant(Timestamp(1000, 500)),
+          Variant(Timestamp(2000, 1000)),
+          Variant(Timestamp(3000, 1500)),
+      }));
+
+  // Nested row (row containing rows).
+  testSerDe(
+      Variant::row({
+          Variant(1),
+          Variant::row({Variant("inner"), Variant(42)}),
+          Variant(3.14),
+      }));
+
+  // Row with array fields.
+  testSerDe(
+      Variant::row({
+          Variant::array({Variant(1), Variant(2), Variant(3)}),
+          Variant::array({Variant("a"), Variant("b")}),
+      }));
+
+  // Row with map fields.
+  testSerDe(
+      Variant::row({
+          Variant::map({
+              {Variant(1), Variant("one")},
+              {Variant(2), Variant("two")},
+          }),
+          Variant::map({
+              {Variant("x"), Variant(10)},
+              {Variant("y"), Variant(20)},
+          }),
+      }));
+
+  // Complex nested row with mixed types.
+  testSerDe(
+      Variant::row({
+          Variant(1),
+          Variant::array({Variant(10), Variant(20)}),
+          Variant::map({
+              {Variant("key"), Variant("value")},
+          }),
+          Variant::row({Variant(true), Variant(false)}),
+          Variant("string field"),
+      }));
+
+  // Deeply nested row structure.
+  testSerDe(
+      Variant::row({
+          Variant::row({
+              Variant::row({Variant(1), Variant(2)}),
+              Variant::row({Variant(3), Variant(4)}),
+          }),
+          Variant(100),
+      }));
+
+  // Large row.
+  std::vector<Variant> largeRow;
+  for (int i = 0; i < 100; ++i) {
+    largeRow.push_back(Variant(i));
+  }
+  testSerDe(Variant::row(largeRow));
+}
+
+TEST(VariantSerializationTest, serializeComplexNestedStructures) {
+  // Array of maps (all elements must be MAP type).
+  testSerDe(
+      Variant::array({
+          Variant::map({
+              {Variant(1), Variant("a")},
+              {Variant(2), Variant("b")},
+          }),
+          Variant::map({
+              {Variant(3), Variant("c")},
+          }),
+      }));
+
+  // Map with row values.
+  testSerDe(
+      Variant::map({
+          {Variant(1), Variant::row({Variant(10), Variant("ten")})},
+          {Variant(2), Variant::row({Variant(20), Variant("twenty")})},
+      }));
+
+  // Row of arrays of maps.
+  testSerDe(
+      Variant::row({
+          Variant::array({
+              Variant::map({{Variant(1), Variant(100)}}),
+              Variant::map({{Variant(2), Variant(200)}}),
+          }),
+          Variant::array({
+              Variant::map({{Variant(3), Variant(300)}}),
+          }),
+      }));
+
+  // Map with array keys and row values (complex structure).
+  testSerDe(
+      Variant::map({
+          {Variant::array({Variant(1), Variant(2)}),
+           Variant::row({Variant("a"), Variant(true)})},
+          {Variant::array({Variant(3)}),
+           Variant::row({Variant("b"), Variant(false)})},
+      }));
+
+  // Array of arrays (homogeneous).
+  testSerDe(
+      Variant::array({
+          Variant::array({Variant(1), Variant(2)}),
+          Variant::array({Variant(3), Variant(4)}),
+          Variant::null(TypeKind::ARRAY),
+      }));
+
+  // Array of rows (homogeneous).
+  testSerDe(
+      Variant::array({
+          Variant::row({Variant(true), Variant(3.14)}),
+          Variant::row({Variant(false), Variant(2.71)}),
+      }));
+}
+
 struct SerializableClass {
   const std::string name;
   const bool value;
@@ -393,7 +1449,7 @@ struct SerializableClass {
       : name(std::move(name)), value(value) {}
 };
 
-class VariantSerializationTest : public ::testing::Test {
+class VariantOpaqueSerializationTest : public ::testing::Test {
  protected:
   void SetUp() override {
     static folly::once_flag once;
@@ -419,7 +1475,7 @@ class VariantSerializationTest : public ::testing::Test {
   Variant value_;
 };
 
-TEST_F(VariantSerializationTest, serializeOpaque) {
+TEST_F(VariantOpaqueSerializationTest, serializeOpaque) {
   auto serialized = value_.serialize();
   auto deserialized = Variant::create(serialized);
   auto opaque = deserialized.value<TypeKind::OPAQUE>().obj;
@@ -428,11 +1484,11 @@ TEST_F(VariantSerializationTest, serializeOpaque) {
   EXPECT_EQ(original->value, false);
 }
 
-TEST_F(VariantSerializationTest, opaqueToJson) {
+TEST_F(VariantOpaqueSerializationTest, opaqueToJson) {
   const auto type = value_.inferType();
 
   const auto expected =
-      R"(Opaque<type:OPAQUE<facebook::velox::(anonymous namespace)::SerializableClass>,value:"{"name":"test_class","value":false}">)";
+      R"(Opaque<type:OPAQUE<facebook::velox::test::(anonymous namespace)::SerializableClass>,value:"{"name":"test_class","value":false}">)";
   EXPECT_EQ(value_.toJson(type), expected);
   EXPECT_EQ(value_.toString(type), expected);
 }
@@ -649,6 +1705,30 @@ TEST(VariantTest, toString) {
   EXPECT_EQ(
       Variant::row({1, 2, 3}).toString(ROW({INTEGER(), INTEGER(), INTEGER()})),
       "[1,2,3]");
+
+  // Non-decimal HUGEINT types (e.g., IPADDRESS, UUID).
+  auto hugeintType = HugeintType::create();
+  EXPECT_EQ(
+      Variant::create<TypeKind::HUGEINT>(int128_t(42)).toString(hugeintType),
+      "42");
+  EXPECT_EQ(
+      Variant::create<TypeKind::HUGEINT>(
+          HugeInt::build(0x0123456789ABCDEF, 0xFEDCBA9876543210))
+          .toString(hugeintType),
+      "1512366075204170947332355369683137040");
+}
+
+TEST(VariantTest, toJsonHugeint) {
+  auto hugeintType = HugeintType::create();
+  auto small = Variant::create<TypeKind::HUGEINT>(int128_t(42));
+  auto large = Variant::create<TypeKind::HUGEINT>(
+      HugeInt::build(0x0123456789ABCDEF, 0xFEDCBA9876543210));
+
+  EXPECT_EQ(small.toJson(hugeintType), "42");
+  EXPECT_EQ(large.toJson(hugeintType), "1512366075204170947332355369683137040");
+
+  EXPECT_EQ(small.toJsonUnsafe(), "42");
+  EXPECT_EQ(large.toJsonUnsafe(), "1512366075204170947332355369683137040");
 }
 
 template <typename T>
@@ -944,5 +2024,17 @@ TEST(VariantTest, nullableMapOfArraysGetter) {
        {"c", std::vector<std::optional<int64_t>>{3}}});
 }
 
+TEST(VariantTest, accessNullVariantValue) {
+  Variant nullVar = Variant::null(TypeKind::INTEGER);
+  VELOX_ASSERT_THROW(
+      nullVar.value<TypeKind::INTEGER>(), "missing Variant value");
+}
+
+TEST(VariantTest, accessWrongTypeVariantValue) {
+  Variant intVar = Variant::create<int32_t>(1);
+  VELOX_ASSERT_THROW(
+      intVar.value<TypeKind::VARCHAR>(), "wrong kind! INTEGER != VARCHAR");
+}
+
 } // namespace
-} // namespace facebook::velox
+} // namespace facebook::velox::test
diff --git a/velox/type/tests/utils/CMakeLists.txt b/velox/type/tests/utils/CMakeLists.txt
index 8ed4f644bb1..88edc0a0b6d 100644
--- a/velox/type/tests/utils/CMakeLists.txt
+++ b/velox/type/tests/utils/CMakeLists.txt
@@ -14,3 +14,5 @@
 add_library(velox_type_test_lib INTERFACE)
 
 target_link_libraries(velox_type_test_lib INTERFACE velox_type)
+
+velox_add_library(velox_custom_types_for_testing INTERFACE HEADERS CustomTypesForTesting.h)
diff --git a/velox/type/tests/utils/CustomTypesForTesting.h b/velox/type/tests/utils/CustomTypesForTesting.h
index dfde0d48f56..baa0c3e188c 100644
--- a/velox/type/tests/utils/CustomTypesForTesting.h
+++ b/velox/type/tests/utils/CustomTypesForTesting.h
@@ -54,11 +54,6 @@ class BigintTypeWithCustomComparison final : public BigintType {
     return "BIGINT TYPE WITH CUSTOM COMPARISON";
   }
 
-  const std::vector<TypeParameter>& parameters() const override {
-    static const std::vector<TypeParameter> kEmpty = {};
-    return kEmpty;
-  }
-
   std::string toString() const override {
     return name();
   }
@@ -99,11 +94,6 @@ class BigintTypeWithInvalidCustomComparison final : public BigintType {
     return "BIGINT TYPE WITH INVALID CUSTOM COMPARISON";
   }
 
-  const std::vector<TypeParameter>& parameters() const override {
-    static const std::vector<TypeParameter> kEmpty = {};
-    return kEmpty;
-  }
-
   std::string toString() const override {
     return name();
   }
diff --git a/velox/type/tz/CMakeLists.txt b/velox/type/tz/CMakeLists.txt
index 10307187c03..b1d16071aab 100644
--- a/velox/type/tz/CMakeLists.txt
+++ b/velox/type/tz/CMakeLists.txt
@@ -24,11 +24,4 @@ velox_add_library(
   TimeZoneNames.cpp
 )
 
-velox_link_libraries(
-  velox_type_tz
-  velox_exception
-  velox_external_tzdb
-  Boost::regex
-  fmt::fmt
-  Folly::folly
-)
+velox_link_libraries(velox_type_tz velox_exception velox_external_tzdb fmt::fmt Folly::folly)
diff --git a/velox/type/tz/TimeZoneMap.cpp b/velox/type/tz/TimeZoneMap.cpp
index 2240f9aea8f..88528f9a012 100644
--- a/velox/type/tz/TimeZoneMap.cpp
+++ b/velox/type/tz/TimeZoneMap.cpp
@@ -38,7 +38,6 @@ using TTimeZoneIndex = folly::F14FastMap<std::string, const TimeZone*>;
 extern const std::vector<std::pair<int16_t, std::string>>& getTimeZoneEntries();
 
 namespace {
-
 // Returns the offset in minutes for a specific time zone offset in the
 // database. Do not call for tzID 0 (UTC / "+00:00").
 inline std::chrono::minutes getTimeZoneOffset(int16_t tzID) {
diff --git a/velox/type/tz/TimeZoneMap.h b/velox/type/tz/TimeZoneMap.h
index ba9eccc0c46..957031d64a6 100644
--- a/velox/type/tz/TimeZoneMap.h
+++ b/velox/type/tz/TimeZoneMap.h
@@ -17,6 +17,7 @@
 #pragma once
 
 #include <chrono>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -167,6 +168,15 @@ class TimeZone {
     return tz_;
   }
 
+  /// Returns the fixed offset for offset-based time zones (e.g., "+05:30").
+  /// Returns std::nullopt for time zones with a tzdb::time_zone pointer.
+  std::optional<std::chrono::minutes> offset() const {
+    if (tz_ == nullptr) {
+      return offset_;
+    }
+    return std::nullopt;
+  }
+
   /// Returns the short name (abbreviation) of the time zone for the given
   /// timestamp. Note that the timestamp is needed for time zones that support
   /// daylight savings time as the short name will change depending on the date
diff --git a/velox/type/tz/tests/TimeZoneMapTest.cpp b/velox/type/tz/tests/TimeZoneMapTest.cpp
index e45fca96bae..52bdbf44f27 100644
--- a/velox/type/tz/tests/TimeZoneMapTest.cpp
+++ b/velox/type/tz/tests/TimeZoneMapTest.cpp
@@ -254,6 +254,57 @@ TEST(TimeZoneMapTest, getTimeZoneIDFromOffset) {
   VELOX_ASSERT_THROW(getTimeZoneID(-15'000), "Invalid timezone offset");
 }
 
+TEST(TimeZoneMapTest, offset) {
+  // Test offset-based timezones - should return the offset value.
+  {
+    const auto* tz = locateZone("+05:30");
+    ASSERT_NE(tz, nullptr);
+    auto offset = tz->offset();
+    ASSERT_TRUE(offset.has_value());
+    EXPECT_EQ(offset->count(), 330); // 5*60 + 30 = 330 minutes
+  }
+
+  {
+    const auto* tz = locateZone("-08:00");
+    ASSERT_NE(tz, nullptr);
+    auto offset = tz->offset();
+    ASSERT_TRUE(offset.has_value());
+    EXPECT_EQ(offset->count(), -480); // -8*60 = -480 minutes
+  }
+
+  {
+    const auto* tz = locateZone("+00:01");
+    ASSERT_NE(tz, nullptr);
+    auto offset = tz->offset();
+    ASSERT_TRUE(offset.has_value());
+    EXPECT_EQ(offset->count(), 1); // 1 minute
+  }
+
+  // Test named timezones - should return std::nullopt.
+  // Note: UTC is a named timezone with tzdb::time_zone pointer, not
+  // offset-based
+  {
+    const auto* tz = locateZone("UTC");
+    ASSERT_NE(tz, nullptr);
+    auto offset = tz->offset();
+    EXPECT_FALSE(offset.has_value());
+  }
+
+  {
+    const auto* tz = locateZone("America/Los_Angeles");
+    ASSERT_NE(tz, nullptr);
+    auto offset = tz->offset();
+    EXPECT_FALSE(offset.has_value());
+  }
+
+  {
+    const auto* tz = locateZone("Europe/London");
+    ASSERT_NE(tz, nullptr);
+    auto offset = tz->offset();
+    EXPECT_FALSE(offset.has_value());
+  }
+}
+
 TEST(TimeZoneMapTest, invalid) {
   VELOX_ASSERT_THROW(getTimeZoneName(99999999), "Unable to resolve timeZoneID");
   VELOX_ASSERT_THROW(getTimeZoneID("This is a test"), "Unknown time zone");
diff --git a/velox/exec/AggregationHook.h b/velox/vector/AggregationHook.h
similarity index 100%
rename from velox/exec/AggregationHook.h
rename to velox/vector/AggregationHook.h
diff --git a/velox/vector/BaseVector.cpp b/velox/vector/BaseVector.cpp
index 3b2db7e7743..454e72bf2aa 100644
--- a/velox/vector/BaseVector.cpp
+++ b/velox/vector/BaseVector.cpp
@@ -23,6 +23,7 @@
 #include "velox/vector/ComplexVector.h"
 #include "velox/vector/DecodedVector.h"
 #include "velox/vector/DictionaryVector.h"
+#include "velox/vector/FlatMapVector.h"
 #include "velox/vector/FlatVector.h"
 #include "velox/vector/LazyVector.h"
 #include "velox/vector/SequenceVector.h"
@@ -32,7 +33,6 @@
 #include "velox/vector/VectorTypeUtils.h"
 
 namespace facebook::velox {
-
 namespace {
 
 Variant nullVariant(const TypePtr& type) {
@@ -56,7 +56,8 @@ template <>
 Variant variantAtTyped<TypeKind::VARBINARY>(
     const BaseVector* vector,
     vector_size_t row) {
-  return Variant::binary(vector->as<SimpleVector<StringView>>()->valueAt(row));
+  return Variant::binary(
+      std::string(vector->as<SimpleVector<StringView>>()->valueAt(row)));
 }
 
 Variant variantAtImpl(const BaseVector* vector, vector_size_t row);
@@ -142,6 +143,15 @@ Variant BaseVector::variantAt(vector_size_t index) const {
   return variantAtImpl(this, index);
 }
 
+std::vector<Variant> BaseVector::toVariants() const {
+  std::vector<Variant> result;
+  result.reserve(size());
+  for (auto i = 0; i < size(); ++i) {
+    result.push_back(variantAt(i));
+  }
+  return result;
+}
+
 BaseVector::BaseVector(
     velox::memory::MemoryPool* pool,
     std::shared_ptr<const Type> type,
@@ -180,7 +190,6 @@ BaseVector::BaseVector(
       // second reference to an immutable 'nulls_'.
       nulls_->setSize(bytes);
     }
-    inMemoryBytes_ += nulls_->size();
   }
 }
 
@@ -412,8 +421,9 @@ VectorPtr BaseVector::createInternal(
   auto kind = type->kind();
   switch (kind) {
     case TypeKind::ROW: {
-      std::vector<VectorPtr> children;
       auto& rowType = type->as<TypeKind::ROW>();
+      std::vector<VectorPtr> children;
+      children.reserve(rowType.size());
       // Children are reserved the parent size and accessible for those rows.
       for (int32_t i = 0; i < rowType.size(); ++i) {
         children.push_back(create(rowType.childAt(i), size, pool));
@@ -468,6 +478,78 @@ VectorPtr BaseVector::createInternal(
   }
 }
 
+// static
+VectorPtr BaseVector::createEmptyLikeInternal(
+    const BaseVector* source,
+    vector_size_t size,
+    memory::MemoryPool* pool) {
+  VELOX_CHECK_NOT_NULL(source);
+  auto* wrapped = source->wrappedVector();
+  const auto& type = source->type();
+
+  switch (type->kind()) {
+    case TypeKind::ROW: {
+      auto& rowType = type->as<TypeKind::ROW>();
+      auto* sourceRow = wrapped->as<RowVector>();
+      std::vector<VectorPtr> children;
+      children.reserve(rowType.size());
+      for (size_t i = 0; i < rowType.size(); ++i) {
+        children.push_back(
+            createEmptyLikeInternal(sourceRow->childAt(i).get(), size, pool));
+      }
+      return std::make_shared<RowVector>(
+          pool, type, nullptr, size, std::move(children));
+    }
+    case TypeKind::ARRAY: {
+      auto offsets = allocateOffsets(size, pool);
+      auto sizes = allocateSizes(size, pool);
+      auto* sourceArray = wrapped->as<ArrayVector>();
+      auto elements =
+          createEmptyLikeInternal(sourceArray->elements().get(), 0, pool);
+      return std::make_shared<ArrayVector>(
+          pool,
+          type,
+          nullptr,
+          size,
+          std::move(offsets),
+          std::move(sizes),
+          std::move(elements));
+    }
+    case TypeKind::MAP: {
+      // If source is FLAT_MAP, directly create FlatMapVector.
+      if (wrapped->encoding() == VectorEncoding::Simple::FLAT_MAP) {
+        return std::make_shared<FlatMapVector>(
+            pool,
+            type,
+            nullptr, // nulls
+            size,
+            nullptr, // distinctKeys
+            std::vector<VectorPtr>{}, // mapValues
+            std::vector<BufferPtr>{}); // inMaps
+      }
+
+      // Otherwise create standard MapVector.
+      auto offsets = allocateOffsets(size, pool);
+      auto sizes = allocateSizes(size, pool);
+      auto* sourceMap = wrapped->as<MapVector>();
+      auto keys = createEmptyLikeInternal(sourceMap->mapKeys().get(), 0, pool);
+      auto values =
+          createEmptyLikeInternal(sourceMap->mapValues().get(), 0, pool);
+      return std::make_shared<MapVector>(
+          pool,
+          type,
+          nullptr,
+          size,
+          std::move(offsets),
+          std::move(sizes),
+          std::move(keys),
+          std::move(values));
+    }
+    default:
+      return BaseVector::create(type, size, pool);
+  }
+}
+
 // static
 void BaseVector::setNulls(
     uint64_t* rawNulls,
@@ -791,6 +873,221 @@ VectorPtr newConstant<TypeKind::OPAQUE>(
       pool, size, value.isNull(), type, std::shared_ptr<void>(capsule.obj));
 }
 
+namespace {
+
+VectorPtr callMakeVector(
+    TypePtr type,
+    const std::vector<Variant>& data,
+    memory::MemoryPool* pool);
+
+template <TypeKind KIND, typename = void>
+struct VariantToVector {
+  static VectorPtr makeVector(
+      TypePtr type,
+      const std::vector<Variant>& /*data*/,
+      memory::MemoryPool* /*pool*/) {
+    VELOX_NYI("Type not supported: {}", type->toString());
+  }
+};
+
+template <TypeKind KIND>
+struct VariantToVector<
+    KIND,
+    std::enable_if_t<
+        TypeTraits<KIND>::isFixedWidth || KIND == TypeKind::VARCHAR ||
+            KIND == TypeKind::VARBINARY || KIND == TypeKind::OPAQUE,
+        void>> {
+  static constexpr bool kIsOpaque = (KIND == TypeKind::OPAQUE);
+  static VectorPtr makeVector(
+      TypePtr type,
+      const std::vector<Variant>& data,
+      memory::MemoryPool* pool) {
+    using T = typename TypeTraits<KIND>::NativeType;
+
+    const vector_size_t dataSize = data.size();
+    BufferPtr valuesBuffer;
+    if constexpr (std::is_same_v<T, StringView>) {
+      // Make sure to initialize StringView values so they can be safely
+      // accessed.
+      valuesBuffer = AlignedBuffer::allocate<T>(dataSize, pool, T());
+    } else {
+      valuesBuffer = AlignedBuffer::allocate<T>(dataSize, pool);
+    }
+    BufferPtr nulls = allocateNulls(dataSize, pool, bits::kNull);
+
+    auto values = std::make_shared<FlatVector<T>>(
+        pool,
+        type,
+        nulls,
+        dataSize,
+        std::move(valuesBuffer),
+        std::vector<BufferPtr>());
+
+    for (size_t i = 0; i < dataSize; i++) {
+      if (!data[i].isNull()) {
+        if constexpr (kIsOpaque) {
+          values->set(i, T(data[i].value<KIND>().obj));
+        } else {
+          values->set(i, T(data[i].value<KIND>()));
+        }
+      }
+    }
+    return values;
+  }
+};
+
+template <>
+struct VariantToVector<TypeKind::ARRAY> {
+  static VectorPtr makeVector(
+      TypePtr type,
+      const std::vector<Variant>& data,
+      memory::MemoryPool* pool) {
+    vector_size_t size = data.size();
+    BufferPtr offsets = allocateOffsets(size, pool);
+    BufferPtr sizes = allocateSizes(size, pool);
+    BufferPtr nulls = allocateNulls(size, pool);
+    auto rawOffsets = offsets->asMutable<vector_size_t>();
+    auto rawSizes = sizes->asMutable<vector_size_t>();
+    auto rawNulls = nulls->asMutable<uint64_t>();
+
+    std::vector<Variant> elements;
+    vector_size_t index = 0;
+    vector_size_t nullCount = 0;
+    for (size_t i = 0; i < data.size(); ++i) {
+      auto isNull = data[i].isNull();
+      *rawOffsets++ = index;
+      *rawSizes++ = !isNull ? data[i].array().size() : 0;
+      if (isNull) {
+        ++nullCount;
+        bits::setNull(rawNulls, i, true);
+        continue;
+      }
+      for (const auto& arrayElement : data[i].array()) {
+        elements.push_back(arrayElement);
+        ++index;
+      }
+    }
+
+    auto elementsVector = callMakeVector(type->childAt(0), elements, pool);
+
+    return std::make_shared<ArrayVector>(
+        pool,
+        type,
+        nulls,
+        size,
+        offsets,
+        sizes,
+        std::move(elementsVector),
+        nullCount);
+  }
+};
+
+template <>
+struct VariantToVector<TypeKind::MAP> {
+  static VectorPtr makeVector(
+      TypePtr type,
+      const std::vector<Variant>& data,
+      memory::MemoryPool* pool) {
+    vector_size_t size = data.size();
+    BufferPtr offsets = allocateOffsets(size, pool);
+    BufferPtr sizes = allocateSizes(size, pool);
+    BufferPtr nulls = allocateNulls(size, pool);
+    auto rawOffsets = offsets->asMutable<vector_size_t>();
+    auto rawSizes = sizes->asMutable<vector_size_t>();
+    auto rawNulls = nulls->asMutable<uint64_t>();
+
+    std::vector<Variant> keys;
+    std::vector<Variant> values;
+    vector_size_t index = 0;
+    vector_size_t nullCount = 0;
+    for (size_t i = 0; i < data.size(); ++i) {
+      auto isNull = data[i].isNull();
+      *rawOffsets++ = index;
+      *rawSizes++ = !isNull ? data[i].map().size() : 0;
+      if (isNull) {
+        ++nullCount;
+        bits::setNull(rawNulls, i, true);
+        continue;
+      }
+      for (const auto& pair : data[i].map()) {
+        keys.push_back(pair.first);
+        values.push_back(pair.second);
+        ++index;
+      }
+    }
+
+    auto keysVector = callMakeVector(type->childAt(0), keys, pool);
+    auto valuesVector = callMakeVector(type->childAt(1), values, pool);
+
+    return std::make_shared<MapVector>(
+        pool,
+        type,
+        nulls,
+        size,
+        offsets,
+        sizes,
+        std::move(keysVector),
+        std::move(valuesVector),
+        nullCount);
+  }
+};
+
+template <>
+struct VariantToVector<TypeKind::ROW> {
+  static VectorPtr makeVector(
+      TypePtr type,
+      const std::vector<Variant>& data,
+      memory::MemoryPool* pool) {
+    vector_size_t size = data.size();
+    BufferPtr nulls = allocateNulls(size, pool);
+    auto rawNulls = nulls->asMutable<uint64_t>();
+
+    auto childCount = type->size();
+    std::vector<std::vector<Variant>> children;
+    children.reserve(childCount);
+    for (size_t i = 0; i < childCount; ++i) {
+      std::vector<Variant> child;
+      child.reserve(size);
+      children.push_back(child);
+    }
+
+    for (size_t i = 0; i < data.size(); ++i) {
+      if (data[i].isNull()) {
+        bits::setNull(rawNulls, i, true);
+        for (auto j{0u}; j < childCount; ++j) {
+          children[j].push_back(Variant::null(type->childAt(j)->kind()));
+        }
+        continue;
+      }
+      const auto& row = data[i].row();
+      VELOX_CHECK_EQ(row.size(), children.size());
+      for (size_t j = 0; j < row.size(); ++j) {
+        children[j].push_back(row[j]);
+      }
+    }
+
+    std::vector<VectorPtr> childVectors;
+    childVectors.reserve(childCount);
+    for (size_t i = 0; i < childCount; ++i) {
+      childVectors.push_back(
+          callMakeVector(type->childAt(i), children[i], pool));
+    }
+
+    return std::make_shared<RowVector>(
+        pool, type, nulls, size, std::move(childVectors));
+  }
+};
+
+VectorPtr callMakeVector(
+    TypePtr type,
+    const std::vector<Variant>& data,
+    memory::MemoryPool* pool) {
+  return VELOX_DYNAMIC_TYPE_DISPATCH_METHOD_ALL(
+      VariantToVector, makeVector, type->kind(), type, data, pool);
+}
+
+} // namespace
+
 // static
 VectorPtr BaseVector::createConstant(
     const TypePtr& type,
@@ -798,8 +1095,25 @@ VectorPtr BaseVector::createConstant(
     vector_size_t size,
     velox::memory::MemoryPool* pool) {
   VELOX_CHECK_EQ(type->kind(), value.kind());
-  return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
-      newConstant, value.kind(), type, value, size, pool);
+  if (type->isPrimitiveType()) {
+    return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
+        newConstant, value.kind(), type, value, size, pool);
+  }
+
+  if (value.isNull()) {
+    return BaseVector::createNullConstant(type, size, pool);
+  }
+
+  auto variantVector = callMakeVector(type, {value}, pool);
+  return BaseVector::wrapInConstant(size, 0, std::move(variantVector));
+}
+
+// static
+VectorPtr BaseVector::createFromVariants(
+    const TypePtr& type,
+    const std::vector<Variant>& values,
+    velox::memory::MemoryPool* pool) {
+  return callMakeVector(type, values, pool);
 }
 
 // static
@@ -850,6 +1164,18 @@ void BaseVector::copy(
   copyRanges(source, ranges);
 }
 
+void BaseVector::transferOrCopyTo(velox::memory::MemoryPool* pool) {
+  if (pool == pool_) {
+    return;
+  }
+
+  if (nulls_ && !nulls_->transferTo(pool)) {
+    nulls_ = AlignedBuffer::copy<bool>(nulls_, pool);
+    rawNulls_ = nulls_->as<uint64_t>();
+  }
+  pool_ = pool;
+}
+
 namespace {
 
 template <TypeKind kind>
@@ -945,7 +1271,7 @@ uint64_t BaseVector::estimateFlatSize() const {
     const auto& leafType = leaf->type();
     return length_ *
         (leafType->isFixedWidth() ? leafType->cppSizeInBytes() : 0) +
-        BaseVector::retainedSize();
+        BaseVector::retainedSizeImpl();
   }
 
   auto avgRowSize = 1.0 * leaf->retainedSize() / leaf->size();
@@ -953,7 +1279,8 @@ uint64_t BaseVector::estimateFlatSize() const {
 }
 
 namespace {
-bool isReusableEncoding(VectorEncoding::Simple encoding) {
+// TODO: enable flatmap encoding type and allow reuse in recursivelyReusable.
+bool reusableEncoding(VectorEncoding::Simple encoding) {
   return encoding == VectorEncoding::Simple::FLAT ||
       encoding == VectorEncoding::Simple::ARRAY ||
       encoding == VectorEncoding::Simple::MAP ||
@@ -961,6 +1288,50 @@ bool isReusableEncoding(VectorEncoding::Simple encoding) {
 }
 } // namespace
 
+// static
+bool BaseVector::recursivelyReusable(const VectorPtr& vector) {
+  if (!vector) {
+    return true;
+  }
+  if (vector.use_count() != 1) {
+    return false;
+  }
+  const auto encoding = vector->encoding();
+  if (!reusableEncoding(encoding)) {
+    return false;
+  }
+
+  switch (vector->encoding()) {
+    case VectorEncoding::Simple::ROW: {
+      auto* rowVector = vector->asUnchecked<RowVector>();
+      const auto& children = rowVector->children();
+      for (size_t i = 0; i < children.size(); ++i) {
+        const auto& child = children[i];
+        if (child && !recursivelyReusable(child)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    case VectorEncoding::Simple::ARRAY: {
+      auto* arrayVector = vector->asUnchecked<ArrayVector>();
+      const auto& elems = arrayVector->elements();
+      return !elems || recursivelyReusable(elems);
+    }
+    case VectorEncoding::Simple::MAP: {
+      auto* mapVector = vector->asUnchecked<MapVector>();
+      const auto& keys = mapVector->mapKeys();
+      const auto& vals = mapVector->mapValues();
+      return (!keys || recursivelyReusable(keys)) &&
+          (!vals || recursivelyReusable(vals));
+    }
+    case VectorEncoding::Simple::FLAT:
+      return true;
+    default:
+      return false;
+  }
+}
+
 // static
 void BaseVector::flattenVector(VectorPtr& vector) {
   if (!vector) {
@@ -988,9 +1359,8 @@ void BaseVector::flattenVector(VectorPtr& vector) {
       return;
     }
     case VectorEncoding::Simple::LAZY: {
-      auto& loadedVector =
-          vector->asUnchecked<LazyVector>()->loadedVectorShared();
-      BaseVector::flattenVector(loadedVector);
+      vector = vector->asUnchecked<LazyVector>()->loadedVectorShared();
+      BaseVector::flattenVector(vector);
       return;
     }
     default:
@@ -1000,7 +1370,7 @@ void BaseVector::flattenVector(VectorPtr& vector) {
 }
 
 void BaseVector::prepareForReuse(VectorPtr& vector, vector_size_t size) {
-  if (vector.use_count() != 1 || !isReusableEncoding(vector->encoding())) {
+  if (vector.use_count() != 1 || !reusableEncoding(vector->encoding())) {
     vector = BaseVector::create(vector->type(), size, vector->pool());
     return;
   }
diff --git a/velox/vector/BaseVector.h b/velox/vector/BaseVector.h
index 2af178a9ae4..16fb99fc09d 100644
--- a/velox/vector/BaseVector.h
+++ b/velox/vector/BaseVector.h
@@ -294,11 +294,6 @@ class BaseVector {
     return representedByteCount_;
   }
 
-  /// @return the number of bytes required to hold this vector in memory
-  ByteCount inMemoryBytes() const {
-    return inMemoryBytes_;
-  }
-
   /// @return true if this vector has the same value at the given index as the
   /// other vector at the other vector's index (including if both are null),
   /// false otherwise
@@ -547,6 +542,13 @@ class BaseVector {
   virtual VectorPtr testingCopyPreserveEncodings(
       velox::memory::MemoryPool* pool = nullptr) const = 0;
 
+  /// Transfer or copy this vector and all its buffers recursively to 'pool'.
+  /// The transfer of a buffer is allowed if its original pool and 'pool' are
+  /// from the same MemoryAllocator and the buffer is not a BufferView. If a
+  /// buffer is not allowed to be transferred, it is copied to pool. After this
+  /// call, this vector and all its buffers are owned by 'pool'.
+  virtual void transferOrCopyTo(velox::memory::MemoryPool* pool);
+
   /// Construct a zero-copy slice of the vector with the indicated offset and
   /// length.
   virtual VectorPtr slice(vector_size_t offset, vector_size_t length) const = 0;
@@ -744,6 +746,21 @@ class BaseVector {
     return vector ? vector : create(type, 0, pool);
   }
 
+  /// Creates a vector matching the structure of a source vector, preserving
+  /// FLAT_MAP encoding where the source uses it. For nested types (ROW, ARRAY,
+  /// MAP), it recursively handles children to preserve encoding at each level.
+  /// BaseVector::create builds from type, without reference to encodings. This
+  /// will still flatten other encodings (e.g. dictionary, constant and lazy),
+  /// only preserving flat map as FlatMapVector.
+  template <typename T = BaseVector>
+  static std::shared_ptr<T> createEmptyLike(
+      const BaseVector* source,
+      vector_size_t size,
+      memory::MemoryPool* pool) {
+    return std::static_pointer_cast<T>(
+        createEmptyLikeInternal(source, size, pool));
+  }
+
   /// Set 'nulls' to be the nulls buffer of this vector. This API should not be
   /// used on ConstantVector.
   void setNulls(const BufferPtr& nulls);
@@ -796,8 +813,17 @@ class BaseVector {
   }
 
   /// Returns the byte size of memory that is kept live through 'this'.
-  virtual uint64_t retainedSize() const {
-    return nulls_ ? nulls_->capacity() : 0;
+  uint64_t retainedSize() const {
+    uint64_t totalStringBufferSize{0};
+    return retainedSizeImpl(totalStringBufferSize);
+  }
+
+  /// Returns the byte size of memory that is kept live through 'this'. Also add
+  /// the total size of all string buffers recursively carried by 'this' to
+  /// totalStringBufferSize. To get the total size of all string buffers, set
+  /// the initial value of totalStringBufferSize to 0 when calling this method.
+  uint64_t retainedSize(uint64_t& totalStringBufferSize) const {
+    return retainedSizeImpl(totalStringBufferSize);
   }
 
   /// Returns an estimate of the 'retainedSize' of a flat representation of the
@@ -805,6 +831,16 @@ class BaseVector {
   /// hasn't been loaded yet.
   virtual uint64_t estimateFlatSize() const;
 
+  /// Recursively checks if a vector and all its children are reusable.
+  /// A vector is reusable only if:
+  /// 1. It has use_count == 1 (singly-referenced)
+  /// 2. It has a reusable encoding (FLAT, ARRAY, MAP, ROW)
+  /// 3. All its children are also reusable (recursively)
+  ///
+  /// This prevents bugs where reusing a vector with shared nested children
+  /// would cause corruption when prepareForReuse resets those shared children.
+  static bool recursivelyReusable(const VectorPtr& vector);
+
   /// To safely reuse a vector one needs to (1) ensure that the vector as well
   /// as all its buffers and child vectors are singly-referenced and mutable
   /// (for buffers); (2) clear append-only string buffers and child vectors
@@ -851,6 +887,16 @@ class BaseVector {
   /// Returns the value at specified index as a Variant.
   Variant variantAt(vector_size_t index) const;
 
+  /// Returns values for all rows as Variants.
+  std::vector<Variant> toVariants() const;
+
+  /// Creates a vector from a list of Variant values. The result is a flat
+  /// vector with one element per value.
+  static VectorPtr createFromVariants(
+      const TypePtr& type,
+      const std::vector<Variant>& values,
+      velox::memory::MemoryPool* pool);
+
   /// Returns string representation of the value in the specified row.
   virtual std::string toString(vector_size_t index) const;
 
@@ -970,6 +1016,13 @@ class BaseVector {
     return nulls_ ? Buffer::slice<bool>(nulls_, offset, length, pool_) : nulls_;
   }
 
+  virtual uint64_t retainedSizeImpl(
+      uint64_t& /*totalStringBufferSize*/) const = 0;
+
+  uint64_t retainedSizeImpl() const {
+    return nulls_ ? nulls_->capacity() : 0;
+  }
+
   TypePtr type_;
   const TypeKind typeKind_;
   // Whether `type_` is a type that provides custom comparison operations.
@@ -993,7 +1046,6 @@ class BaseVector {
   std::optional<vector_size_t> distinctValueCount_;
   std::optional<ByteCount> representedByteCount_;
   std::optional<ByteCount> storageByteCount_;
-  ByteCount inMemoryBytes_ = 0;
 
  private:
   static VectorPtr createInternal(
@@ -1001,6 +1053,11 @@ class BaseVector {
       vector_size_t size,
       velox::memory::MemoryPool* pool);
 
+  static VectorPtr createEmptyLikeInternal(
+      const BaseVector* source,
+      vector_size_t size,
+      memory::MemoryPool* pool);
+
   friend class LazyVector;
 
   // Is true if this vector is a lazy vector or contains one and is being
diff --git a/velox/vector/BiasVector-inl.h b/velox/vector/BiasVector-inl.h
index 88f466023d4..2fd2b48994a 100644
--- a/velox/vector/BiasVector-inl.h
+++ b/velox/vector/BiasVector-inl.h
@@ -63,9 +63,10 @@ BiasVector<T>::BiasVector(
           valueType_ == TypeKind::TINYINT,
       "Invalid array type for biased values");
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   biasBuffer_ = simd::setAll(bias_);
+#endif
   rawValues_ = values_->as<uint8_t>();
-  BaseVector::inMemoryBytes_ += values_->size();
 }
 
 template <typename T>
@@ -97,7 +98,8 @@ std::unique_ptr<SimpleVector<uint64_t>> BiasVector<T>::hashAll() const {
 }
 
 template <typename T>
-const T BiasVector<T>::valueAtFast(vector_size_t idx) const {
+typename SimpleVector<T>::TValueAt BiasVector<T>::valueAtFast(
+    vector_size_t idx) const {
   switch (valueType_) {
     case TypeKind::INTEGER:
       return bias_ + reinterpret_cast<const int32_t*>(rawValues_)[idx];
@@ -110,6 +112,7 @@ const T BiasVector<T>::valueAtFast(vector_size_t idx) const {
   }
 }
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
 template <typename T>
 xsimd::batch<T> BiasVector<T>::loadSIMDValueBufferAt(size_t index) const {
   if constexpr (std::is_same_v<T, int64_t>) {
@@ -143,5 +146,6 @@ xsimd::batch<T> BiasVector<T>::loadSIMDValueBufferAt(size_t index) const {
     VELOX_UNSUPPORTED("Unsupported type for biased vector");
   }
 }
+#endif
 
 } // namespace facebook::velox
diff --git a/velox/vector/BiasVector.h b/velox/vector/BiasVector.h
index 5b522d4bcc4..157d97d7613 100644
--- a/velox/vector/BiasVector.h
+++ b/velox/vector/BiasVector.h
@@ -92,9 +92,11 @@ class BiasVector : public SimpleVector<T> {
   //    bias");
 
  public:
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   static constexpr bool can_simd =
       (std::is_same_v<T, int64_t> || std::is_same_v<T, int32_t> ||
        std::is_same_v<T, int16_t>);
+#endif
 
   BiasVector(
       velox::memory::MemoryPool* pool,
@@ -116,13 +118,14 @@ class BiasVector : public SimpleVector<T> {
     return BaseVector::isNullAt(idx);
   }
 
-  const T valueAtFast(vector_size_t idx) const;
+  typename SimpleVector<T>::TValueAt valueAtFast(vector_size_t idx) const;
 
-  const T valueAt(vector_size_t idx) const override {
+  typename SimpleVector<T>::TValueAt valueAt(vector_size_t idx) const override {
     SimpleVector<T>::checkElementSize();
     return valueAtFast(idx);
   }
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   /**
    * Loads a SIMD vector of data at the virtual byteOffset given
    * Note this method is implemented on each vector type, but is intentionally
@@ -131,6 +134,7 @@ class BiasVector : public SimpleVector<T> {
    * @param byteOffset - the byte offset to laod from
    */
   xsimd::batch<T> loadSIMDValueBufferAt(size_t index) const;
+#endif
 
   std::unique_ptr<SimpleVector<uint64_t>> hashAll() const override;
 
@@ -142,10 +146,6 @@ class BiasVector : public SimpleVector<T> {
     return valueType_;
   }
 
-  uint64_t retainedSize() const override {
-    return BaseVector::retainedSize() + values_->capacity();
-  }
-
   /**
    * Returns a shared_ptr to the underlying arrow array holding the values for
    * this vector. This is used during execution to process over the subset of
@@ -181,13 +181,24 @@ class BiasVector : public SimpleVector<T> {
         BaseVector::storageByteCount_);
   }
 
+  void transferOrCopyTo(velox::memory::MemoryPool* /*pool*/) override {
+    VELOX_UNSUPPORTED("transferTo not defined for BiasVector");
+  }
+
  private:
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   template <typename U>
   inline xsimd::batch<T> loadSIMDInternal(size_t byteOffset) const {
     auto mem = reinterpret_cast<const U*>(
         rawValues_ + byteOffset / sizeof(T) * sizeof(U));
     return xsimd::batch<T>::load_unaligned(mem);
   }
+#endif
+
+  uint64_t retainedSizeImpl(
+      uint64_t& /*totalStringBufferSize*/) const override {
+    return BaseVector::retainedSizeImpl() + values_->capacity();
+  }
 
   TypeKind valueType_;
   BufferPtr values_;
@@ -197,8 +208,10 @@ class BiasVector : public SimpleVector<T> {
   // support is 64 bit and all biasing requires a smaller internal type.
   T bias_;
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   // Used to debias several values at a time.
   std::conditional_t<can_simd, xsimd::batch<T>, char> biasBuffer_;
+#endif
 };
 
 template <typename T>
diff --git a/velox/vector/CMakeLists.txt b/velox/vector/CMakeLists.txt
index 10769cc214d..9fd4f2ca9ea 100644
--- a/velox/vector/CMakeLists.txt
+++ b/velox/vector/CMakeLists.txt
@@ -21,6 +21,7 @@ velox_add_library(
   FlatMapVector.cpp
   FlatVector.cpp
   LazyVector.cpp
+  MapConcat.cpp
   SelectivityVector.cpp
   SequenceVector.cpp
   SimpleVector.cpp
@@ -32,6 +33,40 @@ velox_add_library(
   VectorPrinter.cpp
   VectorSaver.cpp
   VectorStream.cpp
+  HEADERS
+  AggregationHook.h
+  BaseVector.h
+  BiasVector-inl.h
+  BiasVector.h
+  BuilderTypeUtils.h
+  ComplexVector.h
+  ConstantVector-inl.h
+  ConstantVector.h
+  DecodedVector.h
+  DictionaryVector-inl.h
+  DictionaryVector.h
+  EncodedVectorCopy.h
+  FlatMapVector.h
+  FlatVector-inl.h
+  FlatVector.h
+  FunctionVector.h
+  LazyVector.h
+  MapConcat.h
+  NullsBuilder.h
+  SelectivityVector.h
+  SequenceVector-inl.h
+  SequenceVector.h
+  SimpleVector.h
+  StringVectorBuffer.h
+  VariantToVector.h
+  VectorEncoding.h
+  VectorMap.h
+  VectorPool.h
+  VectorPrinter.h
+  VectorSaver.h
+  VectorStream.h
+  VectorTypeUtils.h
+  VectorUtil.h
 )
 
 velox_link_libraries(
@@ -56,3 +91,5 @@ endif()
 if(${VELOX_ENABLE_BENCHMARKS})
   add_subdirectory(benchmarks)
 endif()
+
+velox_add_library(velox_type_aliases INTERFACE HEADERS TypeAliases.h)
diff --git a/velox/vector/ComplexVector.cpp b/velox/vector/ComplexVector.cpp
index c5765988b9f..ade1356f18d 100644
--- a/velox/vector/ComplexVector.cpp
+++ b/velox/vector/ComplexVector.cpp
@@ -24,6 +24,7 @@
 #include "velox/vector/DecodedVector.h"
 #include "velox/vector/FlatMapVector.h"
 #include "velox/vector/LazyVector.h"
+#include "velox/vector/MapConcat.h"
 #include "velox/vector/SimpleVector.h"
 
 namespace facebook::velox {
@@ -417,8 +418,18 @@ bool RowVector::isWritable() const {
   return isNullsWritable();
 }
 
+void RowVector::transferOrCopyTo(velox::memory::MemoryPool* pool) {
+  BaseVector::transferOrCopyTo(pool);
+  for (auto& child : children_) {
+    child->transferOrCopyTo(pool);
+  }
+  if (rawVectorForBatchReader_) {
+    rawVectorForBatchReader_->transferOrCopyTo(pool);
+  }
+}
+
 uint64_t RowVector::estimateFlatSize() const {
-  uint64_t total = BaseVector::retainedSize();
+  uint64_t total = BaseVector::retainedSizeImpl();
   for (const auto& child : children_) {
     if (child) {
       total += child->estimateFlatSize();
@@ -623,7 +634,9 @@ void RowVector::validate(const VectorValidateOptions& options) const {
       if (child->size() < size()) {
         VELOX_CHECK_NOT_NULL(
             nulls_,
-            "Child vector has size less than parent and parent has no nulls.");
+            "Child vector has size {} less than parent and parent has no nulls {}.",
+            child->size(),
+            size());
 
         VELOX_CHECK_GT(
             child->size(),
@@ -921,6 +934,18 @@ bool ArrayVectorBase::hasOverlappingRanges(
   return false;
 }
 
+void ArrayVectorBase::transferOrCopyTo(velox::memory::MemoryPool* pool) {
+  BaseVector::transferOrCopyTo(pool);
+  if (!offsets_->transferTo(pool)) {
+    offsets_ = AlignedBuffer::copy<vector_size_t>(offsets_, pool);
+    rawOffsets_ = offsets_->as<vector_size_t>();
+  }
+  if (!sizes_->transferTo(pool)) {
+    sizes_ = AlignedBuffer::copy<vector_size_t>(sizes_, pool);
+    rawSizes_ = sizes_->as<vector_size_t>();
+  }
+}
+
 void ArrayVectorBase::ensureNullRowsEmpty() {
   if (!rawNulls_) {
     return;
@@ -1193,8 +1218,13 @@ bool ArrayVector::isWritable() const {
   return isNullsWritable() && BaseVector::isVectorWritable(elements_);
 }
 
+void ArrayVector::transferOrCopyTo(velox::memory::MemoryPool* pool) {
+  ArrayVectorBase::transferOrCopyTo(pool);
+  elements_->transferOrCopyTo(pool);
+}
+
 uint64_t ArrayVector::estimateFlatSize() const {
-  return BaseVector::retainedSize() + offsets_->capacity() +
+  return BaseVector::retainedSizeImpl() + offsets_->capacity() +
       sizes_->capacity() + elements_->estimateFlatSize();
 }
 
@@ -1513,8 +1543,14 @@ bool MapVector::isWritable() const {
       BaseVector::isVectorWritable(values_);
 }
 
+void MapVector::transferOrCopyTo(velox::memory::MemoryPool* pool) {
+  ArrayVectorBase::transferOrCopyTo(pool);
+  keys_->transferOrCopyTo(pool);
+  values_->transferOrCopyTo(pool);
+}
+
 uint64_t MapVector::estimateFlatSize() const {
-  return BaseVector::retainedSize() + offsets_->capacity() +
+  return BaseVector::retainedSizeImpl() + offsets_->capacity() +
       sizes_->capacity() + keys_->estimateFlatSize() +
       values_->estimateFlatSize();
 }
@@ -1565,203 +1601,20 @@ void MapVector::copyRanges(
   copyRangesImpl(source, ranges, &values_, &keys_);
 }
 
-namespace {
-
-struct UpdateSource {
-  vector_size_t entryIndex;
-  int8_t sourceIndex;
-};
-
-template <typename T>
-class UpdateMapRow {
- public:
-  void insert(
-      const DecodedVector* decoded,
-      vector_size_t entryIndex,
-      int8_t sourceIndex) {
-    values_[decoded->valueAt<T>(entryIndex)] = {entryIndex, sourceIndex};
-  }
-
-  template <typename F>
-  void forEachEntry(F&& func) {
-    for (auto& [_, source] : values_) {
-      func(source);
-    }
-  }
-
-  void clear() {
-    values_.clear();
-  }
-
- private:
-  folly::F14FastMap<T, UpdateSource> values_;
-};
-
-template <>
-class UpdateMapRow<void> {
- public:
-  void insert(
-      const DecodedVector* decoded,
-      vector_size_t entryIndex,
-      int8_t sourceIndex) {
-    references_[{decoded->base(), decoded->index(entryIndex)}] = {
-        entryIndex, sourceIndex};
-  }
-
-  template <typename F>
-  void forEachEntry(F&& func) {
-    for (auto& [_, source] : references_) {
-      func(source);
-    }
-  }
-
-  void clear() {
-    references_.clear();
-  }
-
- private:
-  struct Reference {
-    const BaseVector* base;
-    vector_size_t index;
-
-    bool operator==(const Reference& other) const {
-      return base->equalValueAt(other.base, index, other.index);
-    }
-  };
-
-  struct ReferenceHasher {
-    uint64_t operator()(const Reference& key) const {
-      return key.base->hashValueAt(key.index);
-    }
-  };
-
-  folly::F14FastMap<Reference, UpdateSource, ReferenceHasher> references_;
-};
-
-} // namespace
-
-template <TypeKind kKeyTypeKind>
-MapVectorPtr MapVector::updateImpl(
-    const folly::Range<DecodedVector*>& others) const {
-  auto newNulls = nulls();
-  for (auto& other : others) {
-    if (!other.nulls()) {
-      continue;
-    }
-    if (newNulls.get() == nulls().get()) {
-      newNulls = allocateNulls(size(), pool());
-      if (!rawNulls()) {
-        bits::copyBits(
-            other.nulls(), 0, newNulls->asMutable<uint64_t>(), 0, size());
-      } else {
-        bits::andBits(
-            newNulls->asMutable<uint64_t>(),
-            rawNulls(),
-            other.nulls(),
-            0,
-            size());
-      }
-    } else {
-      bits::andBits(newNulls->asMutable<uint64_t>(), other.nulls(), 0, size());
-    }
-  }
-
-  auto newOffsets = allocateIndices(size(), pool());
-  auto* rawNewOffsets = newOffsets->asMutable<vector_size_t>();
-  auto newSizes = allocateIndices(size(), pool());
-  auto* rawNewSizes = newSizes->asMutable<vector_size_t>();
-
-  std::vector<DecodedVector> keys;
-  keys.reserve(1 + others.size());
-  keys.emplace_back(*keys_);
-  for (auto& other : others) {
-    auto& otherKeys = other.base()->asChecked<MapVector>()->keys_;
-    VELOX_CHECK(*keys_->type() == *otherKeys->type());
-    keys.emplace_back(*otherKeys);
-  }
-  std::vector<std::vector<BaseVector::CopyRange>> ranges(1 + others.size());
-
-  // Subscript symbols in this function:
-  //
-  // i, ii : Top level row index.  `ii' is the index into other base at i.
-  // j, jj : Key/value vector index.  `jj' is the offset version of `j'.
-  // k : Index into `others' and `ranges' for choosing a map vector.
-  UpdateMapRow<typename TypeTraits<kKeyTypeKind>::NativeType> mapRow;
-  vector_size_t numEntries = 0;
-  for (vector_size_t i = 0; i < size(); ++i) {
-    rawNewOffsets[i] = numEntries;
-    if (newNulls && bits::isBitNull(newNulls->as<uint64_t>(), i)) {
-      rawNewSizes[i] = 0;
-      continue;
-    }
-    bool needUpdate = false;
-    for (auto& other : others) {
-      auto ii = other.index(i);
-      if (other.base()->asUnchecked<MapVector>()->sizeAt(ii) > 0) {
-        needUpdate = true;
-        break;
-      }
-    }
-    if (!needUpdate) {
-      // Fast path for no update on current row.
-      rawNewSizes[i] = sizeAt(i);
-      if (sizeAt(i) > 0) {
-        ranges[0].push_back({offsetAt(i), numEntries, sizeAt(i)});
-        numEntries += sizeAt(i);
-      }
-      continue;
-    }
-    for (int k = 0; k < keys.size(); ++k) {
-      auto* vector =
-          k == 0 ? this : others[k - 1].base()->asUnchecked<MapVector>();
-      auto ii = k == 0 ? i : others[k - 1].index(i);
-      auto offset = vector->offsetAt(ii);
-      auto size = vector->sizeAt(ii);
-      for (vector_size_t j = 0; j < size; ++j) {
-        auto jj = offset + j;
-        VELOX_CHECK(!keys[k].isNullAt(jj), "Map key cannot be null");
-        mapRow.insert(&keys[k], jj, k);
-      }
-    }
-    vector_size_t newSize = 0;
-    mapRow.forEachEntry([&](UpdateSource source) {
-      ranges[source.sourceIndex].push_back(
-          {source.entryIndex, numEntries + newSize, 1});
-      ++newSize;
-    });
-    mapRow.clear();
-    rawNewSizes[i] = newSize;
-    numEntries += newSize;
-  }
-
-  auto newKeys = BaseVector::create(mapKeys()->type(), numEntries, pool());
-  auto newValues = BaseVector::create(mapValues()->type(), numEntries, pool());
-  for (int k = 0; k < ranges.size(); ++k) {
-    auto* vector =
-        k == 0 ? this : others[k - 1].base()->asUnchecked<MapVector>();
-    newKeys->copyRanges(vector->mapKeys().get(), ranges[k]);
-    newValues->copyRanges(vector->mapValues().get(), ranges[k]);
-  }
-
-  return std::make_shared<MapVector>(
-      pool(),
-      type(),
-      std::move(newNulls),
-      size(),
-      std::move(newOffsets),
-      std::move(newSizes),
-      std::move(newKeys),
-      std::move(newValues));
-}
-
 MapVectorPtr MapVector::update(
     const folly::Range<DecodedVector*>& others) const {
-  VELOX_CHECK(!others.empty());
-  VELOX_CHECK_LT(others.size(), std::numeric_limits<int8_t>::max());
   for (auto& other : others) {
     VELOX_CHECK_EQ(size(), other.size());
   }
-  return VELOX_DYNAMIC_TYPE_DISPATCH(updateImpl, keys_->typeKind(), others);
+  DecodedVector decodedSelf(static_cast<const BaseVector&>(*this));
+  std::vector<DecodedVector*> inputs;
+  inputs.reserve(1 + others.size());
+  inputs.push_back(&decodedSelf);
+  for (auto& other : others) {
+    inputs.push_back(&other);
+  }
+  SelectivityVector allRows(size(), true);
+  return mapConcat(pool(), type(), inputs, allRows, {});
 }
 
 MapVectorPtr MapVector::update(const std::vector<MapVectorPtr>& others) const {
diff --git a/velox/vector/ComplexVector.h b/velox/vector/ComplexVector.h
index 2c8a17c264e..eefe7d93510 100644
--- a/velox/vector/ComplexVector.h
+++ b/velox/vector/ComplexVector.h
@@ -66,7 +66,6 @@ class RowVector : public BaseVector {
             rowType->nameOf(i),
             i,
             type->childAt(i)->toString());
-        BaseVector::inMemoryBytes_ += child->inMemoryBytes();
       }
     }
     updateContainsLazyNotLoaded();
@@ -184,15 +183,7 @@ class RowVector : public BaseVector {
         nullCount_);
   }
 
-  uint64_t retainedSize() const override {
-    auto size = BaseVector::retainedSize();
-    for (auto& child : children_) {
-      if (child) {
-        size += child->retainedSize();
-      }
-    }
-    return size;
-  }
+  void transferOrCopyTo(velox::memory::MemoryPool* pool) override;
 
   uint64_t estimateFlatSize() const override;
 
@@ -293,6 +284,16 @@ class RowVector : public BaseVector {
       vector_size_t count,
       vector_size_t childSize);
 
+  uint64_t retainedSizeImpl(uint64_t& totalStringBufferSize) const override {
+    auto size = BaseVector::retainedSizeImpl();
+    for (auto& child : children_) {
+      if (child) {
+        size += child->retainedSize(totalStringBufferSize);
+      }
+    }
+    return size;
+  }
+
   const size_t childrenSize_;
   mutable std::vector<VectorPtr> children_;
 
@@ -372,6 +373,8 @@ struct ArrayVectorBase : BaseVector {
     sizes_->asMutable<vector_size_t>()[i] = size;
   }
 
+  void transferOrCopyTo(velox::memory::MemoryPool* pool) override;
+
   /// Check if there is any overlapping [offset, size] ranges.
   bool hasOverlappingRanges() const {
     std::vector<vector_size_t> indices;
@@ -464,10 +467,11 @@ class ArrayVector : public ArrayVectorBase {
             nullCount,
             std::move(offsets),
             std::move(lengths)),
-        elements_(BaseVector::getOrCreateEmpty(
-            std::move(elements),
-            type->childAt(0),
-            pool)) {
+        elements_(
+            BaseVector::getOrCreateEmpty(
+                std::move(elements),
+                type->childAt(0),
+                pool)) {
     VELOX_CHECK_EQ(type->kind(), TypeKind::ARRAY);
     VELOX_CHECK(
         elements_->type()->kindEquals(type->childAt(0)),
@@ -521,10 +525,7 @@ class ArrayVector : public ArrayVectorBase {
         nullCount_);
   }
 
-  uint64_t retainedSize() const override {
-    return BaseVector::retainedSize() + offsets_->capacity() +
-        sizes_->capacity() + elements_->retainedSize();
-  }
+  void transferOrCopyTo(velox::memory::MemoryPool* pool) override;
 
   uint64_t estimateFlatSize() const override;
 
@@ -552,6 +553,11 @@ class ArrayVector : public ArrayVectorBase {
   void validate(const VectorValidateOptions& options) const override;
 
  private:
+  uint64_t retainedSizeImpl(uint64_t& totalStringBufferSize) const override {
+    return BaseVector::retainedSizeImpl() + offsets_->capacity() +
+        sizes_->capacity() + elements_->retainedSize(totalStringBufferSize);
+  }
+
   VectorPtr elements_;
 };
 
@@ -580,14 +586,16 @@ class MapVector : public ArrayVectorBase {
             nullCount,
             std::move(offsets),
             std::move(sizes)),
-        keys_(BaseVector::getOrCreateEmpty(
-            std::move(keys),
-            type->childAt(0),
-            pool)),
-        values_(BaseVector::getOrCreateEmpty(
-            std::move(values),
-            type->childAt(1),
-            pool)),
+        keys_(
+            BaseVector::getOrCreateEmpty(
+                std::move(keys),
+                type->childAt(0),
+                pool)),
+        values_(
+            BaseVector::getOrCreateEmpty(
+                std::move(values),
+                type->childAt(1),
+                pool)),
         sortedKeys_{sortedKeys} {
     VELOX_CHECK_EQ(type->kind(), TypeKind::MAP);
 
@@ -666,10 +674,7 @@ class MapVector : public ArrayVectorBase {
         sortedKeys_);
   }
 
-  uint64_t retainedSize() const override {
-    return BaseVector::retainedSize() + offsets_->capacity() +
-        sizes_->capacity() + keys_->retainedSize() + values_->retainedSize();
-  }
+  void transferOrCopyTo(velox::memory::MemoryPool* pool) override;
 
   uint64_t estimateFlatSize() const override;
 
@@ -741,6 +746,12 @@ class MapVector : public ArrayVectorBase {
   std::shared_ptr<MapVector> updateImpl(
       const folly::Range<DecodedVector*>& others) const;
 
+  uint64_t retainedSizeImpl(uint64_t& totalStringBufferSize) const override {
+    return BaseVector::retainedSizeImpl() + offsets_->capacity() +
+        sizes_->capacity() + keys_->retainedSize(totalStringBufferSize) +
+        values_->retainedSize(totalStringBufferSize);
+  }
+
   VectorPtr keys_;
   VectorPtr values_;
   bool sortedKeys_;
diff --git a/velox/vector/ConstantVector.h b/velox/vector/ConstantVector.h
index c63b06add92..01f7437e3ea 100644
--- a/velox/vector/ConstantVector.h
+++ b/velox/vector/ConstantVector.h
@@ -39,10 +39,12 @@ class ConstantVector final : public SimpleVector<T> {
   ConstantVector(const ConstantVector&) = delete;
   ConstantVector& operator=(const ConstantVector&) = delete;
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   static constexpr bool can_simd =
       (std::is_same_v<T, int64_t> || std::is_same_v<T, int32_t> ||
        std::is_same_v<T, int16_t> || std::is_same_v<T, int8_t> ||
        std::is_same_v<T, bool> || std::is_same_v<T, size_t>);
+#endif
 
   ConstantVector(
       velox::memory::MemoryPool* pool,
@@ -70,7 +72,7 @@ class ConstantVector final : public SimpleVector<T> {
         initialized_(true) {
     makeNullsBuffer();
     // Special handling for complex types
-    if (type->size() > 0) {
+    if (type->size() > 0 || type->kind() == TypeKind::ROW) {
       // Only allow null constants to be created through this interface.
       VELOX_CHECK(isNull_);
       valueVector_ = BaseVector::create(type, 1, pool);
@@ -82,10 +84,12 @@ class ConstantVector final : public SimpleVector<T> {
         setValue(value_.str());
       }
     }
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
     // If this is not encoded integer, or string, set value buffer
     if constexpr (can_simd) {
       valueBuffer_ = simd::setAll(value_);
     }
+#endif
   }
 
   /// Creates constant vector with value coming from 'index' element of the
@@ -157,16 +161,17 @@ class ConstantVector final : public SimpleVector<T> {
     VELOX_FAIL("setNull not supported on ConstantVector");
   }
 
-  const T value() const {
+  typename SimpleVector<T>::TValueAt value() const {
     VELOX_DCHECK(initialized_);
     return value_;
   }
 
-  const T valueAtFast(vector_size_t /*idx*/) const {
+  typename SimpleVector<T>::TValueAt valueAtFast(vector_size_t /*idx*/) const {
     return value();
   }
 
-  virtual const T valueAt(vector_size_t /*idx*/) const override {
+  typename SimpleVector<T>::TValueAt valueAt(
+      vector_size_t /*idx*/) const override {
     VELOX_DCHECK(initialized_);
     SimpleVector<T>::checkElementSize();
     return value();
@@ -187,6 +192,7 @@ class ConstantVector final : public SimpleVector<T> {
     return &value_;
   }
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   /// Loads a 256bit vector of data at the virtual byteOffset given
   /// Note this method is implemented on each vector type, but is intentionally
   /// not virtual for performance reasons
@@ -194,20 +200,10 @@ class ConstantVector final : public SimpleVector<T> {
     VELOX_DCHECK(initialized_);
     return valueBuffer_;
   }
+#endif
 
   std::unique_ptr<SimpleVector<uint64_t>> hashAll() const override;
 
-  uint64_t retainedSize() const override {
-    VELOX_DCHECK(initialized_);
-    if (valueVector_) {
-      return valueVector_->retainedSize();
-    }
-    if (stringBuffer_) {
-      return stringBuffer_->capacity();
-    }
-    return sizeof(T);
-  }
-
   BaseVector* loadedVector() override {
     if (!valueVector_) {
       return this;
@@ -242,10 +238,11 @@ class ConstantVector final : public SimpleVector<T> {
     static const DummyReleaser kDummy;
     auto* wrapInfo = wrapInfo_.load();
     if (FOLLY_UNLIKELY(!wrapInfo)) {
-      wrapInfo = new BufferPtr(BufferView<DummyReleaser>::create(
-          reinterpret_cast<const uint8_t*>(&index_),
-          sizeof(vector_size_t),
-          kDummy));
+      wrapInfo = new BufferPtr(
+          BufferView<DummyReleaser>::create(
+              reinterpret_cast<const uint8_t*>(&index_),
+              sizeof(vector_size_t),
+              kDummy));
       BufferPtr* oldWrapInfo = nullptr;
       if (!wrapInfo_.compare_exchange_strong(oldWrapInfo, wrapInfo)) {
         delete wrapInfo;
@@ -396,6 +393,22 @@ class ConstantVector final : public SimpleVector<T> {
         BaseVector::storageByteCount_);
   }
 
+  void transferOrCopyTo(velox::memory::MemoryPool* pool) override {
+    BaseVector::transferOrCopyTo(pool);
+    if (valueVector_) {
+      valueVector_->transferOrCopyTo(pool);
+    }
+    if constexpr (std::is_same_v<T, StringView>) {
+      if (stringBuffer_ && !stringBuffer_->transferTo(pool)) {
+        auto newBuffer = AlignedBuffer::copy<char>(stringBuffer_, pool);
+        auto offset = value_.data() - stringBuffer_->template as<char>();
+        value_ =
+            StringView(newBuffer->template as<char>() + offset, value_.size());
+        stringBuffer_ = std::move(newBuffer);
+      }
+    }
+  }
+
  protected:
   std::string toSummaryString() const override {
     std::stringstream out;
@@ -447,11 +460,12 @@ class ConstantVector final : public SimpleVector<T> {
   }
 
   void setValue(const std::string& string) {
-    BaseVector::inMemoryBytes_ += string.size();
     value_ = velox::to<decltype(value_)>(string);
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
     if constexpr (can_simd) {
       valueBuffer_ = simd::setAll(value_);
     }
+#endif
   }
 
   void makeNullsBuffer() {
@@ -465,6 +479,18 @@ class ConstantVector final : public SimpleVector<T> {
     *BaseVector::nulls_->asMutable<uint64_t>() = bits::kNull64;
   }
 
+  uint64_t retainedSizeImpl(uint64_t& totalStringBufferSize) const override {
+    VELOX_DCHECK(initialized_);
+    if (valueVector_) {
+      return valueVector_->retainedSize(totalStringBufferSize);
+    }
+    if (stringBuffer_) {
+      totalStringBufferSize += stringBuffer_->capacity();
+      return stringBuffer_->capacity();
+    }
+    return sizeof(T);
+  }
+
   // 'valueVector_' element 'index_' represents a complex constant
   // value. 'valueVector_' is nullptr if the constant is scalar.
   VectorPtr valueVector_;
@@ -477,8 +503,10 @@ class ConstantVector final : public SimpleVector<T> {
   bool initialized_{false};
   mutable std::atomic<BufferPtr*> wrapInfo_{nullptr};
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   // This must be at end to avoid memory corruption.
   std::conditional_t<can_simd, xsimd::batch<T>, char> valueBuffer_;
+#endif
 };
 
 template <>
diff --git a/velox/vector/DecodedVector.h b/velox/vector/DecodedVector.h
index fd829293e2b..3302913ba8c 100644
--- a/velox/vector/DecodedVector.h
+++ b/velox/vector/DecodedVector.h
@@ -152,6 +152,9 @@ class DecodedVector {
 
   /// Returns the mapping from top-level rows to rows in the base vector or
   /// data() buffer.
+  ///
+  /// NOTE: This method allocates non-trivial amount of memory and should not
+  /// be called if encoding is constant or flat.
   const vector_size_t* indices() const {
     if (!indices_) {
       fillInIndices();
diff --git a/velox/vector/DictionaryVector-inl.h b/velox/vector/DictionaryVector-inl.h
index 0eb8a8481fd..fa87e504a46 100644
--- a/velox/vector/DictionaryVector-inl.h
+++ b/velox/vector/DictionaryVector-inl.h
@@ -53,11 +53,6 @@ void DictionaryVector<T>::setInternalState() {
     }
   }
   initialized_ = true;
-
-  BaseVector::inMemoryBytes_ =
-      BaseVector::nulls_ ? BaseVector::nulls_->capacity() : 0;
-  BaseVector::inMemoryBytes_ += indices_->capacity();
-  BaseVector::inMemoryBytes_ += dictionaryValues_->inMemoryBytes();
 }
 
 template <typename T>
@@ -108,7 +103,8 @@ bool DictionaryVector<T>::isNullAt(vector_size_t idx) const {
 }
 
 template <typename T>
-const T DictionaryVector<T>::valueAtFast(vector_size_t idx) const {
+typename SimpleVector<T>::TValueAt DictionaryVector<T>::valueAtFast(
+    vector_size_t idx) const {
   VELOX_DCHECK(initialized_);
   if (rawDictionaryValues_) {
     return rawDictionaryValues_[getDictionaryIndex(idx)];
@@ -117,7 +113,8 @@ const T DictionaryVector<T>::valueAtFast(vector_size_t idx) const {
 }
 
 template <>
-inline const bool DictionaryVector<bool>::valueAtFast(vector_size_t idx) const {
+inline SimpleVector<bool>::TValueAt DictionaryVector<bool>::valueAtFast(
+    vector_size_t idx) const {
   VELOX_DCHECK(initialized_);
   auto innerIndex = getDictionaryIndex(idx);
   return scalarDictionaryValues_->valueAt(innerIndex);
@@ -159,6 +156,7 @@ std::unique_ptr<SimpleVector<uint64_t>> DictionaryVector<T>::hashAll() const {
       sizeof(uint64_t) * BaseVector::length_ /* representedBytes */);
 }
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
 template <typename T>
 xsimd::batch<T> DictionaryVector<T>::loadSIMDValueBufferAt(
     size_t byteOffset) const {
@@ -174,6 +172,7 @@ xsimd::batch<T> DictionaryVector<T>::loadSIMDValueBufferAt(
     VELOX_UNREACHABLE();
   }
 }
+#endif
 
 template <typename T>
 VectorPtr DictionaryVector<T>::slice(vector_size_t offset, vector_size_t length)
diff --git a/velox/vector/DictionaryVector.h b/velox/vector/DictionaryVector.h
index ed0bf38217e..cce064b7264 100644
--- a/velox/vector/DictionaryVector.h
+++ b/velox/vector/DictionaryVector.h
@@ -32,7 +32,9 @@ class DictionaryVector : public SimpleVector<T> {
   DictionaryVector(const DictionaryVector&) = delete;
   DictionaryVector& operator=(const DictionaryVector&) = delete;
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   static constexpr bool can_simd = std::is_same_v<T, int64_t>;
+#endif
 
   // Creates dictionary vector using base vector (dictionaryValues) and a set
   // of indices (dictionaryIndexArray).
@@ -93,13 +95,13 @@ class DictionaryVector : public SimpleVector<T> {
     }
   }
 
-  const T valueAtFast(vector_size_t idx) const;
+  typename SimpleVector<T>::TValueAt valueAtFast(vector_size_t idx) const;
 
   /**
    * @return the value at the given index value for a dictionary entry, i.e.
    * gets the dictionary value by its indexed value.
    */
-  const T valueAt(vector_size_t idx) const override {
+  typename SimpleVector<T>::TValueAt valueAt(vector_size_t idx) const override {
     VELOX_DCHECK(initialized_);
     VELOX_DCHECK(!isNullAt(idx), "found null value at: {}", idx);
     auto innerIndex = getDictionaryIndex(idx);
@@ -108,6 +110,7 @@ class DictionaryVector : public SimpleVector<T> {
 
   std::unique_ptr<SimpleVector<uint64_t>> hashAll() const override;
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   /**
    * Loads a SIMD vector of data at the virtual byteOffset given
    * Note this method is implemented on each vector type, but is intentionally
@@ -117,6 +120,7 @@ class DictionaryVector : public SimpleVector<T> {
    * @return the vector of values starting at the given index
    */
   xsimd::batch<T> loadSIMDValueBufferAt(size_t index) const;
+#endif
 
   inline const BufferPtr& indices() const {
     return indices_;
@@ -148,11 +152,6 @@ class DictionaryVector : public SimpleVector<T> {
     return indices_;
   }
 
-  uint64_t retainedSize() const override {
-    return BaseVector::retainedSize() + dictionaryValues_->retainedSize() +
-        indices_->capacity();
-  }
-
   bool isScalar() const override {
     return dictionaryValues_->isScalar();
   }
@@ -250,6 +249,15 @@ class DictionaryVector : public SimpleVector<T> {
         BaseVector::storageByteCount_);
   }
 
+  void transferOrCopyTo(velox::memory::MemoryPool* pool) override {
+    BaseVector::transferOrCopyTo(pool);
+    dictionaryValues_->transferOrCopyTo(pool);
+    if (!indices_->transferTo(pool)) {
+      indices_ = AlignedBuffer::copy<vector_size_t>(indices_, pool);
+      rawIndices_ = indices_->as<vector_size_t>();
+    }
+  }
+
  private:
   // return the dictionary index for the specified vector index.
   inline vector_size_t getDictionaryIndex(vector_size_t idx) const {
@@ -258,6 +266,12 @@ class DictionaryVector : public SimpleVector<T> {
 
   void setInternalState();
 
+  uint64_t retainedSizeImpl(uint64_t& totalStringBufferSize) const override {
+    return BaseVector::retainedSizeImpl() +
+        dictionaryValues_->retainedSize(totalStringBufferSize) +
+        indices_->capacity();
+  }
+
   BufferPtr indices_;
   const vector_size_t* rawIndices_ = nullptr;
 
diff --git a/velox/vector/EncodedVectorCopy.cpp b/velox/vector/EncodedVectorCopy.cpp
index a6efd25ce3f..f54baab87b4 100644
--- a/velox/vector/EncodedVectorCopy.cpp
+++ b/velox/vector/EncodedVectorCopy.cpp
@@ -18,6 +18,7 @@
 
 #include "velox/vector/ConstantVector.h"
 #include "velox/vector/DecodedVector.h"
+#include "velox/vector/FlatMapVector.h"
 #include "velox/vector/LazyVector.h"
 #include "velox/vector/VectorTypeUtils.h"
 
@@ -515,6 +516,56 @@ VectorPtr newArray(
       std::move(elements));
 }
 
+VectorPtr newFlatMap(
+    const EncodedVectorCopyOptions& options,
+    const FlatMapVector& source,
+    const folly::Range<const BaseVector::CopyRange*>& ranges) {
+  auto size = newTargetSize(ranges);
+  auto nulls = newNulls(size, options.pool, source.rawNulls(), ranges);
+
+  VectorPtr distinctKeys = BaseVector::create(
+      source.keyType(), source.numDistinctKeys(), options.pool);
+  BaseVector::CopyRange keyRange{0, 0, source.numDistinctKeys()};
+  distinctKeys->copyRanges(source.distinctKeys().get(), {&keyRange, 1});
+
+  std::vector<VectorPtr> mapValues;
+  mapValues.reserve(distinctKeys->size());
+  for (column_index_t i = 0; i < distinctKeys->size(); ++i) {
+    VectorPtr value;
+    // Vector is not empty or non-null
+    if (source.mapValuesAt(i)) {
+      copyImpl(options, source.mapValuesAt(i), ranges, value, false);
+    } else {
+      value = BaseVector::create(source.valueType(), size, options.pool);
+    }
+    mapValues.push_back(std::move(value));
+  }
+
+  std::vector<BufferPtr> inMaps;
+  inMaps.reserve(distinctKeys->size());
+  for (const auto& inMap : source.inMaps()) {
+    if (inMap) {
+      auto newInMap = allocateNulls(size, options.pool);
+      BaseVector::copyNulls(
+          newInMap->asMutable<uint64_t>(), inMap->as<uint64_t>(), ranges);
+      inMaps.push_back(std::move(newInMap));
+    } else {
+      inMaps.push_back(nullptr);
+    }
+  }
+
+  return std::make_shared<FlatMapVector>(
+      options.pool,
+      source.type(),
+      std::move(nulls),
+      size,
+      std::move(distinctKeys),
+      std::move(mapValues),
+      std::move(inMaps),
+      std::nullopt,
+      source.hasSortedKeys());
+}
+
 void copyIntoFlat(
     const EncodedVectorCopyOptions& options,
     const VectorPtr& source,
@@ -571,13 +622,15 @@ void copyIntoConstant(
   VectorPtr alphabet;
   if (decodedSource.isConstantMapping()) {
     fillIndices(1, ranges, rawIndices);
-    alphabet = BaseVector::create(target->type(), 2, options.pool);
+    alphabet =
+        BaseVector::createEmptyLike(decodedTarget.base(), 2, options.pool);
     alphabet->copy(decodedTarget.base(), 0, decodedTarget.index(0), 1);
     alphabet->copy(decodedSource.base(), 1, decodedSource.index(0), 1);
   } else {
     nulls = newNulls(size, options.pool, decodedSource.nulls(), ranges);
     auto baseRanges = toBaseRanges(decodedSource, ranges, 1, rawIndices);
-    alphabet = BaseVector::create(target->type(), 1, options.pool);
+    alphabet =
+        BaseVector::createEmptyLike(decodedTarget.base(), 1, options.pool);
     alphabet->copy(decodedTarget.base(), 0, decodedTarget.index(0), 1);
     copyImpl(options, sourceBase, baseRanges, alphabet, true);
   }
@@ -853,6 +906,148 @@ void copyIntoArray(
   }
 }
 
+void copyIntoFlatMapMutable(
+    const EncodedVectorCopyOptions& options,
+    const FlatMapVector& source,
+    const folly::Range<const BaseVector::CopyRange*>& ranges,
+    VectorPtr& target) {
+  const auto size = targetSize(target->size(), ranges);
+  target->resize(size);
+  target->resetDataDependentFlags(nullptr);
+  setSourceNulls(source.rawNulls(), *target, ranges);
+
+  auto* targetFlatMap = target->asUnchecked<FlatMapVector>();
+  auto startingNumDistinctKeys = targetFlatMap->numDistinctKeys();
+
+  for (column_index_t i = 0; i < source.numDistinctKeys(); ++i) {
+    const auto channel = targetFlatMap->getKeyChannel(source.distinctKeys(), i)
+                             .value_or(targetFlatMap->numDistinctKeys());
+
+    if (channel == targetFlatMap->numDistinctKeys()) {
+      targetFlatMap->appendDistinctKey(source.distinctKeys(), i);
+      targetFlatMap->inMapsAt(channel, true) =
+          AlignedBuffer::allocate<bool>(size, options.pool, false);
+      targetFlatMap->mapValuesAt(channel) = BaseVector::createEmptyLike(
+          source.mapValuesAt(i).get(), size, options.pool);
+    }
+
+    auto& mapValue = targetFlatMap->mapValuesAt(channel);
+    bool childMutable = mapValue.use_count() == 1;
+    copyImpl(options, source.mapValuesAt(i), ranges, mapValue, childMutable);
+    targetFlatMap->copyInMapRanges(channel, source.rawInMapsAt(i), ranges);
+  }
+
+  for (column_index_t i = 0; i < startingNumDistinctKeys; ++i) {
+    if (source.getKeyChannel(targetFlatMap->distinctKeys(), i) ==
+        std::nullopt) {
+      auto& targetInMapsBuffer = targetFlatMap->inMapsAt(i, true);
+      if (targetInMapsBuffer == nullptr) {
+        targetInMapsBuffer =
+            AlignedBuffer::allocate<bool>(size, options.pool, false);
+      }
+      auto* targetInMaps = targetInMapsBuffer->asMutable<uint64_t>();
+
+      applyToEachRange(
+          ranges, [targetInMaps](auto targetIndex, auto, auto count) {
+            bits::fillBits(
+                targetInMaps, targetIndex, targetIndex + count, false);
+          });
+    }
+  }
+}
+
+void copyIntoFlatMapImmutable(
+    const EncodedVectorCopyOptions& options,
+    const FlatMapVector& source,
+    const folly::Range<const BaseVector::CopyRange*>& ranges,
+    VectorPtr& target) {
+  const auto size = targetSize(target->size(), ranges);
+  auto* targetFlatMap = target->asUnchecked<FlatMapVector>();
+
+  auto mapValues = targetFlatMap->mapValues();
+  for (auto& mv : mapValues) {
+    if (mv && mv->size() < size) {
+      auto resized = BaseVector::createEmptyLike(mv.get(), size, options.pool);
+      BaseVector::CopyRange copyRange{0, 0, mv->size()};
+      copyImpl(options, mv, {&copyRange, 1}, resized, true);
+      mv = std::move(resized);
+    }
+  }
+  std::vector<BufferPtr> inMaps(targetFlatMap->inMaps().size());
+  for (size_t i = 0; i < targetFlatMap->inMaps().size(); ++i) {
+    if (targetFlatMap->inMaps()[i]) {
+      inMaps[i] = AlignedBuffer::copy(options.pool, targetFlatMap->inMaps()[i]);
+      if (bits::nbytes(size) > inMaps[i]->size()) {
+        AlignedBuffer::reallocate<bool>(&inMaps[i], size, false);
+      }
+    }
+  }
+  auto distinctKeys =
+      BaseVector::copy(*targetFlatMap->distinctKeys(), options.pool);
+
+  BufferPtr nulls;
+  if (target->rawNulls() || source.rawNulls()) {
+    nulls = combineNulls(
+        size,
+        options.pool,
+        target->rawNulls(),
+        target->size(),
+        source.rawNulls(),
+        ranges);
+  }
+
+  target = std::make_shared<FlatMapVector>(
+      options.pool,
+      target->type(),
+      std::move(nulls),
+      size,
+      std::move(distinctKeys),
+      std::move(mapValues),
+      std::move(inMaps));
+  target->resetDataDependentFlags(nullptr);
+  copyIntoFlatMapMutable(options, source, ranges, target);
+}
+
+void copyIntoFlatMap(
+    const EncodedVectorCopyOptions& options,
+    const VectorPtr& source,
+    const folly::Range<const BaseVector::CopyRange*>& ranges,
+    DecodedVector& decodedSource,
+    const VectorPtr& sourceBase,
+    VectorPtr& target,
+    bool targetMutable) {
+  if (decodedSource.isIdentityMapping()) {
+    auto& flatMapSource = *source->asUnchecked<FlatMapVector>();
+    if (targetMutable) {
+      copyIntoFlatMapMutable(options, flatMapSource, ranges, target);
+    } else {
+      copyIntoFlatMapImmutable(options, flatMapSource, ranges, target);
+    }
+    return;
+  }
+  const auto size = targetSize(target->size(), ranges);
+  BufferPtr nulls;
+  auto indices = allocateIndices(size, options.pool);
+  auto* rawIndices = indices->asMutable<vector_size_t>();
+  std::iota(rawIndices, rawIndices + target->size(), 0);
+  BaseVector::CopyRange baseRange;
+  baseRange.targetIndex = target->size();
+  if (decodedSource.isConstantMapping()) {
+    fillIndices(target->size(), ranges, rawIndices);
+    baseRange.sourceIndex = decodedSource.index(0);
+    baseRange.count = 1;
+  } else {
+    nulls = newNulls(size, options.pool, decodedSource.nulls(), ranges);
+    copyIndices(decodedSource.indices(), ranges, target->size(), rawIndices);
+    baseRange.sourceIndex = 0;
+    baseRange.count = sourceBase->size();
+  }
+  copyImpl(
+      options, sourceBase, folly::Range(&baseRange, 1), target, targetMutable);
+  target = BaseVector::wrapInDictionary(
+      std::move(nulls), std::move(indices), size, target);
+}
+
 void copyIntoComplex(
     const EncodedVectorCopyOptions& options,
     DecodedVector& decodedSource,
@@ -980,12 +1175,27 @@ void copyIntoExisting(
     case VectorEncoding::Simple::FLAT:
       copyIntoFlat(options, source, ranges, target, targetMutable);
       break;
-    case VectorEncoding::Simple::ROW:
     case VectorEncoding::Simple::MAP:
+      VELOX_CHECK_NE(
+          sourceBase->encoding(),
+          VectorEncoding::Simple::FLAT_MAP,
+          "Cannot copy FlatMapVector into MapVector.");
+      [[fallthrough]];
+    case VectorEncoding::Simple::ROW:
     case VectorEncoding::Simple::ARRAY:
       copyIntoComplex(
           options, decodedSource, sourceBase, ranges, target, targetMutable);
       break;
+    case VectorEncoding::Simple::FLAT_MAP:
+      copyIntoFlatMap(
+          options,
+          source,
+          ranges,
+          decodedSource,
+          sourceBase,
+          target,
+          targetMutable);
+      break;
     case VectorEncoding::Simple::LAZY:
       copyIntoLazy(options, source, ranges, target, targetMutable);
       break;
@@ -1003,7 +1213,7 @@ void copyImpl(
     bool targetMutable) {
   if (ranges.empty()) {
     if (!target) {
-      target = BaseVector::create(source->type(), 0, options.pool);
+      target = BaseVector::createEmptyLike(source.get(), 0, options.pool);
     }
     return;
   }
@@ -1046,6 +1256,10 @@ void copyImpl(
     case VectorEncoding::Simple::ARRAY:
       target = newArray(options, *source->asUnchecked<ArrayVector>(), ranges);
       break;
+    case VectorEncoding::Simple::FLAT_MAP:
+      target =
+          newFlatMap(options, *source->asUnchecked<FlatMapVector>(), ranges);
+      break;
     case VectorEncoding::Simple::LAZY:
       VELOX_CHECK(!sourceBase->isLazy());
       copyImpl(options, sourceBase, ranges, target, targetMutable);
@@ -1067,7 +1281,7 @@ void encodedVectorCopy(
     VELOX_CHECK(source->pool() == options.pool);
   }
   if (target) {
-    VELOX_CHECK(*target->type() == *source->type());
+    VELOX_CHECK(target->type()->equivalent(*source->type()));
     VELOX_CHECK(target->pool() == options.pool);
   }
   VELOX_CHECK(
diff --git a/velox/vector/EncodedVectorCopy.h b/velox/vector/EncodedVectorCopy.h
index d78cb88a4d1..873a1a75dfd 100644
--- a/velox/vector/EncodedVectorCopy.h
+++ b/velox/vector/EncodedVectorCopy.h
@@ -61,4 +61,42 @@ void encodedVectorCopy(
     const folly::Range<const BaseVector::CopyRange*>& ranges,
     VectorPtr& target);
 
+/// Overload that copies the entire source vector (full range).
+/// Equivalent to calling encodedVectorCopy with a single range
+/// {0, 0, source->size()}.
+inline void encodedVectorCopy(
+    const EncodedVectorCopyOptions& options,
+    const VectorPtr& source,
+    VectorPtr& target) {
+  BaseVector::CopyRange range{0, 0, source->size()};
+  encodedVectorCopy(options, source, {&range, 1}, target);
+}
+
+/// Non-void call to allow user's who don't want to define their own
+/// vectors to define them inline. Adds several different overloads to add
+/// various levels of convenience.
+inline VectorPtr encodedVectorCopy(
+    const EncodedVectorCopyOptions& options,
+    const VectorPtr& source,
+    const folly::Range<const BaseVector::CopyRange*>& ranges) {
+  VectorPtr target;
+  encodedVectorCopy(options, source, ranges, target);
+  return target;
+}
+
+inline VectorPtr encodedVectorCopy(
+    const EncodedVectorCopyOptions& options,
+    const VectorPtr& source) {
+  VectorPtr target;
+  BaseVector::CopyRange range{0, 0, source->size()};
+  encodedVectorCopy(options, source, {&range, 1}, target);
+  return target;
+}
+
+inline VectorPtr encodedVectorCopy(const VectorPtr& source) {
+  BaseVector::CopyRange range{0, 0, source->size()};
+  return encodedVectorCopy(
+      {.pool = source->pool(), .reuseSource = false}, source, {&range, 1});
+}
+
 } // namespace facebook::velox
diff --git a/velox/vector/FlatMapVector.cpp b/velox/vector/FlatMapVector.cpp
index c5bd8fcffb0..84a330cbea7 100644
--- a/velox/vector/FlatMapVector.cpp
+++ b/velox/vector/FlatMapVector.cpp
@@ -14,9 +14,10 @@
  * limitations under the License.
  */
 
-#include "velox/vector/FlatMapVector.h"
 #include <folly/hash/Hash.h>
-#include "velox/vector/FlatVector.h"
+
+#include "velox/vector/FlatMapVector.h"
+#include "velox/vector/SimpleVector.h"
 
 namespace facebook::velox {
 namespace {
@@ -34,9 +35,9 @@ std::optional<column_index_t> getKeyChannelImpl(
     return std::nullopt;
   }
 
-  auto distinctFlatKeys = distinctKeys->as<FlatVector<T>>();
+  auto simpleKeys = distinctKeys->as<SimpleVector<T>>();
   VELOX_CHECK(
-      distinctFlatKeys != nullptr,
+      simpleKeys != nullptr,
       "Incompatible vector type for flat map vector keys: {}",
       distinctKeys->toString());
 
@@ -51,7 +52,7 @@ std::optional<column_index_t> getKeyChannelImpl(
   // Here there was at least one hash match. Need to compare to the keys vector
   // to ensure it's an actual match and not a hash collision.
   for (auto it = range.first; it != range.second; ++it) {
-    if (distinctFlatKeys->valueAtFast(it->second) == keyValue) {
+    if (simpleKeys->valueAt(it->second) == keyValue) {
       return it->second;
     }
   }
@@ -100,7 +101,7 @@ vector_size_t FlatMapVector::sizeAt(vector_size_t index) const {
 
   for (vector_size_t i = 0; i < numDistinctKeys(); i++) {
     if (i < inMaps_.size() && inMaps_[i] != nullptr) {
-      size += bits::isBitSet(inMaps_[i]->asMutable<uint64_t>(), index);
+      size += bits::isBitSet(inMaps_[i]->as<uint64_t>(), index);
     } else {
       // By default assume the key exists.
       ++size;
@@ -129,7 +130,17 @@ void FlatMapVector::resize(vector_size_t newSize, bool setNotNull) {
 
         if (i < inMaps_.size() && inMaps_[i] != nullptr) {
           VELOX_CHECK(inMaps_[i]->unique(), "Resizing shared in map vector");
-          AlignedBuffer::reallocate<bool>(&inMaps_[i], newSize, 0);
+          if (!inMaps_[i]->isMutable()) {
+            // Can't reallocate an immutable buffer, must create new buffer.
+            auto newInMap = AlignedBuffer::allocate<bool>(newSize, pool_, 0);
+            memcpy(
+                newInMap->asMutable<uint64_t>(),
+                inMaps_[i]->as<uint64_t>(),
+                bits::nbytes(oldSize));
+            inMaps_[i] = std::move(newInMap);
+          } else {
+            AlignedBuffer::reallocate<bool>(&inMaps_[i], newSize, 0);
+          }
         }
       }
     }
@@ -545,7 +556,8 @@ void FlatMapVector::copyRanges(
       // Then we allocate a new key values vector and in map buffer.
       inMapsAt(channel, true) =
           AlignedBuffer::allocate<bool>(size(), pool(), false);
-      mapValues_.back() = BaseVector::create(valueType(), size(), pool());
+      mapValues_.back() = BaseVector::createEmptyLike(
+          sourceFlatMap->mapValues_[i].get(), size(), pool());
     }
 
     // Finally, copy the map values and update the in map buffers.
diff --git a/velox/vector/FlatMapVector.h b/velox/vector/FlatMapVector.h
index 00ca381c4ab..2e9c4c820af 100644
--- a/velox/vector/FlatMapVector.h
+++ b/velox/vector/FlatMapVector.h
@@ -204,6 +204,15 @@ class FlatMapVector : public BaseVector {
     return nullptr;
   }
 
+  /// Same as above but allows for `keysVector` at index `index` (similar
+  /// distinction between getKeyChannel we see above).
+  VectorPtr projectKey(const VectorPtr& keysVector, vector_size_t index) const {
+    if (auto channel = getKeyChannel(keysVector, index)) {
+      return mapValues_[channel.value()];
+    }
+    return nullptr;
+  }
+
   /// Returns the size for the map at position `index`. Size means the number of
   /// logical key value pairs in the map. Note that this is not a particularly
   /// efficient operation in flat maps as it requires accessing the inMap bitmap
@@ -267,12 +276,17 @@ class FlatMapVector : public BaseVector {
   }
 
   const uint64_t* rawInMapsAt(column_index_t index) const {
-    return inMaps_.size() > index ? inMaps_[index]->as<uint64_t>() : nullptr;
+    if (inMaps_.size() > index && inMaps_[index]) {
+      return inMaps_[index]->as<uint64_t>();
+    }
+    return nullptr;
   }
 
   uint64_t* mutableRawInMapsAt(column_index_t index) {
-    return inMaps_.size() > index ? inMaps_[index]->asMutable<uint64_t>()
-                                  : nullptr;
+    if (inMaps_.size() > index && inMaps_[index]) {
+      return inMaps_[index]->asMutable<uint64_t>();
+    }
+    return nullptr;
   }
 
   using BaseVector::toString;
@@ -328,22 +342,14 @@ class FlatMapVector : public BaseVector {
   /// testing/validation purposes, and not for performance critical paths.
   MapVectorPtr toMapVector() const;
 
- private:
-  void setDistinctKeysImpl(VectorPtr distinctKeys) {
-    VELOX_CHECK(distinctKeys != nullptr);
-    VELOX_CHECK(
-        *distinctKeys->type() == *keyType(),
-        "Unexpected key type: {}",
-        distinctKeys->type()->toString());
-
-    distinctKeys_ = std::move(distinctKeys);
-    keyToChannel_.clear();
-
-    for (vector_size_t i = 0; i < numDistinctKeys(); i++) {
-      keyToChannel_.insert({distinctKeys_->hashValueAt(i), i});
-    }
+  void transferOrCopyTo(velox::memory::MemoryPool* /*pool*/) override {
+    // TODO: enable this after
+    // https://github.com/facebookincubator/velox/issues/15485 is resolved to
+    // allow proper testing.
+    VELOX_NYI("{} unsupported", __FUNCTION__);
   }
 
+ public:
   /// Appends a new distinct key to the flat map specified by `sourceChannel` on
   /// `sourceDistinctKeys`.
   void appendDistinctKey(
@@ -373,6 +379,22 @@ class FlatMapVector : public BaseVector {
       const uint64_t* sourceInMaps,
       const folly::Range<const BaseVector::CopyRange*>& ranges);
 
+ private:
+  void setDistinctKeysImpl(VectorPtr distinctKeys) {
+    VELOX_CHECK(distinctKeys != nullptr);
+    VELOX_CHECK(
+        *distinctKeys->type() == *keyType(),
+        "Unexpected key type: {}",
+        distinctKeys->type()->toString());
+
+    distinctKeys_ = std::move(distinctKeys);
+    keyToChannel_.clear();
+
+    for (vector_size_t i = 0; i < numDistinctKeys(); i++) {
+      keyToChannel_.insert({distinctKeys_->hashValueAt(i), i});
+    }
+  }
+
   /// Compares a map in this Vector with a map in a MapVector.
   std::optional<int32_t> compareToMap(
       const MapVector* other,
@@ -391,6 +413,15 @@ class FlatMapVector : public BaseVector {
       vector_size_t wrappedOtherIndex,
       CompareFlags flags) const;
 
+  uint64_t retainedSizeImpl(
+      uint64_t& /*totalStringBufferSize*/) const override {
+    // TODO: since FlatMapVector didn't override BaseVector::retainedSize(),
+    // this override of retainedSizeImpl keeps the original behavior of
+    // FlatMapVector::retainedSize(). We should update this method to reflect
+    // the actual memory usage of FlatMapVector.
+    return BaseVector::retainedSizeImpl();
+  }
+
   // Vector containing the distinct map keys.
   VectorPtr distinctKeys_;
 
diff --git a/velox/vector/FlatVector-inl.h b/velox/vector/FlatVector-inl.h
index 2b761b12737..5dd79429543 100644
--- a/velox/vector/FlatVector-inl.h
+++ b/velox/vector/FlatVector-inl.h
@@ -18,6 +18,7 @@
 #include "velox/common/base/BitUtil.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/SimdUtil.h"
+#include "velox/common/testutil/TestValue.h"
 #include "velox/vector/BuilderTypeUtils.h"
 #include "velox/vector/ConstantVector.h"
 #include "velox/vector/DecodedVector.h"
@@ -25,6 +26,7 @@
 
 namespace facebook::velox {
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
 // Here are some common intel intrsic operations. Please refer to
 // https://software.intel.com/sites/landingpage/IntrinsicsGuide for examples.
 
@@ -48,8 +50,9 @@ namespace facebook::velox {
 
 // cost factors for individual operations on different filter paths - these are
 // experimentally derived from micro-bench perf testing.
-const double SIMD_CMP_COST = 0.00000051;
-const double SET_CMP_COST = 0.000023;
+static constexpr double SIMD_CMP_COST = 0.00000051;
+static constexpr double SET_CMP_COST = 0.000023;
+#endif
 
 template <typename T>
 const T* FlatVector<T>::rawValues() const {
@@ -57,7 +60,8 @@ const T* FlatVector<T>::rawValues() const {
 }
 
 template <typename T>
-T FlatVector<T>::valueAtFast(vector_size_t idx) const {
+typename SimpleVector<T>::TValueAt FlatVector<T>::valueAtFast(
+    vector_size_t idx) const {
   VELOX_DCHECK_LT(idx, BaseVector::length_, "Index out of range");
   return rawValues_[idx];
 }
@@ -67,6 +71,7 @@ Range<T> FlatVector<T>::asRange() const {
   return Range<T>(rawValues(), 0, BaseVector::length_);
 }
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
 template <typename T>
 xsimd::batch<T> FlatVector<T>::loadSIMDValueBufferAt(size_t byteOffset) const {
   auto mem = reinterpret_cast<uint8_t*>(rawValues_) + byteOffset;
@@ -76,6 +81,7 @@ xsimd::batch<T> FlatVector<T>::loadSIMDValueBufferAt(size_t byteOffset) const {
     return xsimd::load_unaligned(reinterpret_cast<T*>(mem));
   }
 }
+#endif
 
 template <typename T>
 std::unique_ptr<SimpleVector<uint64_t>> FlatVector<T>::hashAll() const {
@@ -113,6 +119,7 @@ std::unique_ptr<SimpleVector<uint64_t>> FlatVector<T>::hashAll() const {
       sizeof(uint64_t) * BaseVector::length_ /*representedBytes*/);
 }
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
 template <typename T>
 bool FlatVector<T>::useSimdEquality(size_t numCmpVals) const {
   if constexpr (!std::is_integral_v<T>) {
@@ -127,6 +134,7 @@ bool FlatVector<T>::useSimdEquality(size_t numCmpVals) const {
     return simdCost <= fallbackCost;
   }
 }
+#endif
 
 template <typename T>
 void FlatVector<T>::copyValuesAndNulls(
@@ -444,40 +452,42 @@ void FlatVector<T>::resize(vector_size_t newSize, bool setNotNull) {
   if (newSize == previousSize) {
     return;
   }
-  BaseVector::resize(newSize, setNotNull);
-  if (!values_) {
-    return;
-  }
 
-  if constexpr (std::is_same_v<T, StringView>) {
-    resizeValues(newSize, StringView());
-    if (newSize < previousSize) {
-      // If we downsize, just invalidate ascii, because we might have become
-      // 'all ascii' from 'not all ascii'.
-      SimpleVector<StringView>::invalidateIsAscii();
-    } else {
-      // Properly init stringView objects. This is useful when vectors are
-      // re-used where the size changes but not the capacity.
-      // TODO: remove this when resizeValues() checks against size() instead of
-      // capacity() when deciding to init values.
-      auto stringViews = reinterpret_cast<StringView*>(rawValues_);
-      for (auto index = previousSize; index < newSize; ++index) {
-        new (&stringViews[index]) StringView();
+  if (values_) {
+    if constexpr (std::is_same_v<T, StringView>) {
+      resizeValues(newSize, previousSize, StringView());
+      if (newSize < previousSize) {
+        // If we downsize, just invalidate ascii, because we might have become
+        // 'all ascii' from 'not all ascii'.
+        SimpleVector<StringView>::invalidateIsAscii();
+      } else {
+        // Properly init stringView objects. This is useful when vectors are
+        // re-used where the size changes but not the capacity.
+        // TODO: remove this when resizeValues() checks against size() instead
+        // of capacity() when deciding to init values.
+        auto stringViews = reinterpret_cast<StringView*>(rawValues_);
+        for (auto index = previousSize; index < newSize; ++index) {
+          new (&stringViews[index]) StringView();
+        }
+        SimpleVector<StringView>::resizeIsAsciiIfNotEmpty(newSize, false);
       }
-      SimpleVector<StringView>::resizeIsAsciiIfNotEmpty(newSize, false);
-    }
-    if (newSize == 0) {
-      keepAtMostOneStringBuffer();
+      if (newSize == 0) {
+        keepAtMostOneStringBuffer();
+      }
+    } else {
+      resizeValues(newSize, previousSize, std::nullopt);
     }
-  } else {
-    resizeValues(newSize, std::nullopt);
   }
+
+  // Call resize on the BaseVector at the end, so we only update length_ if we
+  // successfully resized the values Buffer.
+  BaseVector::resize(newSize, setNotNull);
 }
 
 template <typename T>
 void FlatVector<T>::ensureWritable(const SelectivityVector& rows) {
-  auto newSize = std::max<vector_size_t>(rows.end(), BaseVector::length_);
   if (values_ && !values_->isMutable()) {
+    auto newSize = std::max<vector_size_t>(rows.end(), BaseVector::length_);
     BufferPtr newValues;
     if constexpr (std::is_same_v<T, StringView>) {
       // Make sure to initialize StringView values so they can be safely
@@ -531,7 +541,10 @@ void FlatVector<T>::prepareForReuse() {
 template <typename T>
 void FlatVector<T>::resizeValues(
     vector_size_t newSize,
+    vector_size_t previousSize,
     const std::optional<T>& initialValue) {
+  common::testutil::TestValue::adjust(
+      "facebook::velox::FlatVector::resizeValues", this);
   // TODO: change this to isMutable(). See
   // https://github.com/facebookincubator/velox/issues/6562.
   if (values_ && !values_->isView()) {
@@ -548,16 +561,16 @@ void FlatVector<T>::resizeValues(
       AlignedBuffer::allocate<T>(newSize, BaseVector::pool_, initialValue);
 
   if (values_) {
+    auto len = std::min(newSize, previousSize);
+
     if constexpr (Buffer::is_pod_like_v<T>) {
       auto dst = newValues->asMutable<T>();
       auto src = values_->as<T>();
-      auto len = std::min(values_->size(), newValues->size());
-      memcpy(dst, src, len);
+      auto byteLen = BaseVector::byteSize<T>(len);
+      memcpy(dst, src, byteLen);
     } else {
-      const vector_size_t previousSize = BaseVector::length_;
-      auto* rawOldValues = newValues->asMutable<T>();
+      const auto* rawOldValues = values_->as<T>();
       auto* rawNewValues = newValues->asMutable<T>();
-      const auto len = std::min<vector_size_t>(newSize, previousSize);
       for (vector_size_t row = 0; row < len; ++row) {
         rawNewValues[row] = rawOldValues[row];
       }
@@ -570,7 +583,10 @@ void FlatVector<T>::resizeValues(
 template <>
 inline void FlatVector<bool>::resizeValues(
     vector_size_t newSize,
+    vector_size_t previousSize,
     const std::optional<bool>& initialValue) {
+  common::testutil::TestValue::adjust(
+      "facebook::velox::FlatVector::resizeValues", this);
   // TODO: change this to isMutable(). See
   // https://github.com/facebookincubator/velox/issues/6562.
   if (values_ && !values_->isView()) {
@@ -580,13 +596,6 @@ inline void FlatVector<bool>::resizeValues(
     } else {
       values_->setSize(newByteSize);
     }
-    // ensure that the newly added positions have the right initial value for
-    // the case where changes in size don't result in change in the size of
-    // the underlying buffer.
-    if (initialValue.has_value() && length_ < newSize) {
-      auto rawData = values_->asMutable<uint64_t>();
-      bits::fillBits(rawData, length_, newSize, initialValue.value());
-    }
     rawValues_ = values_->asMutable<bool>();
     return;
   }
@@ -596,11 +605,92 @@ inline void FlatVector<bool>::resizeValues(
   if (values_) {
     auto dst = newValues->asMutable<char>();
     auto src = values_->as<char>();
-    auto len = std::min(values_->size(), newValues->size());
+    auto len = BaseVector::byteSize<bool>(std::min(newSize, previousSize));
     memcpy(dst, src, len);
   }
   values_ = std::move(newValues);
   rawValues_ = values_->asMutable<bool>();
 }
 
+template <typename T>
+void FlatVector<T>::transferAndUpdateStringBuffers(
+    velox::memory::MemoryPool* /*pool*/) {
+  VELOX_CHECK(stringBuffers_.empty());
+}
+
+template <>
+inline void FlatVector<StringView>::transferAndUpdateStringBuffers(
+    velox::memory::MemoryPool* pool) {
+  struct StringBufferRemapping {
+    const char* oldStart;
+    const char* newStart;
+    size_t size;
+  };
+  std::vector<StringBufferRemapping> stringBufferRemapping;
+  for (auto& buffer : stringBuffers_) {
+    if (!buffer->transferTo(pool)) {
+      VELOX_CHECK_NE(
+          stringBufferSet_.erase(buffer.get()),
+          0,
+          "Easure of existing string buffer should always succeed.");
+      auto newBuffer = AlignedBuffer::copy<char>(buffer, pool);
+      stringBufferRemapping.push_back(
+          {buffer->as<char>(), newBuffer->as<char>(), buffer->size()});
+      buffer = std::move(newBuffer);
+      VELOX_CHECK(stringBufferSet_.insert(buffer.get()).second);
+    }
+  }
+  if (stringBufferRemapping.empty()) {
+    return;
+  }
+
+  std::sort(
+      stringBufferRemapping.begin(),
+      stringBufferRemapping.end(),
+      [](const StringBufferRemapping& lhs, const StringBufferRemapping& rhs) {
+        return lhs.oldStart < rhs.oldStart;
+      });
+  auto rawValues = values_->asMutable<StringView>();
+  for (auto i = 0; i < BaseVector::length_; ++i) {
+    if (BaseVector::isNullAt(i)) {
+      continue;
+    }
+    auto& stringView = rawValues[i];
+    if (stringView.isInline()) {
+      continue;
+    }
+    // Find the first remapping whose oldStart is strictly greater than
+    // stringView.data(). The remapping before it is the candidate that
+    // contains stringView.data().
+    auto remapping = std::upper_bound(
+        stringBufferRemapping.cbegin(),
+        stringBufferRemapping.cend(),
+        stringView.data(),
+        [](const char* lhs, const StringBufferRemapping& rhs) {
+          return lhs < rhs.oldStart;
+        });
+    // There is no remapping whose oldStart is smaller than or equal to
+    // stringView.data().
+    if (remapping == stringBufferRemapping.begin()) {
+      continue;
+    }
+    remapping--;
+    if (stringView.data() >= remapping->oldStart &&
+        stringView.data() < remapping->oldStart + remapping->size) {
+      auto offset = stringView.data() - remapping->oldStart;
+      stringView = StringView(remapping->newStart + offset, stringView.size());
+    }
+  }
+}
+
+template <typename T>
+void FlatVector<T>::transferOrCopyTo(velox::memory::MemoryPool* pool) {
+  BaseVector::transferOrCopyTo(pool);
+  if (values_ && !values_->transferTo(pool)) {
+    values_ = AlignedBuffer::copy<T>(values_, pool);
+    rawValues_ = const_cast<T*>(values_->as<T>());
+  }
+  transferAndUpdateStringBuffers(pool);
+}
+
 } // namespace facebook::velox
diff --git a/velox/vector/FlatVector.cpp b/velox/vector/FlatVector.cpp
index 0bf60868f05..ac37af5fb02 100644
--- a/velox/vector/FlatVector.cpp
+++ b/velox/vector/FlatVector.cpp
@@ -28,7 +28,8 @@ const bool* FlatVector<bool>::rawValues() const {
 }
 
 template <>
-bool FlatVector<bool>::valueAtFast(vector_size_t idx) const {
+SimpleVector<bool>::TValueAt FlatVector<bool>::valueAtFast(
+    vector_size_t idx) const {
   return bits::isBitSet(reinterpret_cast<const uint64_t*>(rawValues_), idx);
 }
 
diff --git a/velox/vector/FlatVector.h b/velox/vector/FlatVector.h
index aab6c38587d..cedacc7a342 100644
--- a/velox/vector/FlatVector.h
+++ b/velox/vector/FlatVector.h
@@ -37,10 +37,12 @@ class FlatVector final : public SimpleVector<T> {
   FlatVector(const FlatVector&) = delete;
   FlatVector& operator=(const FlatVector&) = delete;
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   static constexpr bool can_simd =
       (std::is_same_v<T, int64_t> || std::is_same_v<T, int32_t> ||
        std::is_same_v<T, int16_t> || std::is_same_v<T, int8_t> ||
        std::is_same_v<T, bool> || std::is_same_v<T, size_t>);
+#endif
 
   /// Minimum size of a string buffer. 32 KB value is chosen to ensure that a
   /// single buffer is sufficient for a "typical" vector: 1K rows, medium size
@@ -103,28 +105,25 @@ class FlatVector final : public SimpleVector<T> {
       // immutable Buffer.
       values_->setSize(byteSize);
     }
-
-    BaseVector::inMemoryBytes_ += values_->capacity();
-    for (const auto& stringBuffer : stringBuffers_) {
-      BaseVector::inMemoryBytes_ += stringBuffer->capacity();
-    }
   }
 
   virtual ~FlatVector() override = default;
 
-  T valueAtFast(vector_size_t idx) const;
+  typename SimpleVector<T>::TValueAt valueAtFast(vector_size_t idx) const;
 
-  const T valueAt(vector_size_t idx) const override {
+  typename SimpleVector<T>::TValueAt valueAt(vector_size_t idx) const override {
     return valueAtFast(idx);
   }
 
   std::unique_ptr<SimpleVector<uint64_t>> hashAll() const override;
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   /// Loads a SIMD vector of data at the virtual byteOffset given
   /// Note this method is implemented on each vector type, but is intentionally
   /// not virtual for performance reasons.
   /// 'index' indicates the byte offset to load from
   xsimd::batch<T> loadSIMDValueBufferAt(size_t index) const;
+#endif
 
   /// dictionary vector makes internal usehere for SIMD functions
   template <typename X>
@@ -182,10 +181,12 @@ class FlatVector final : public SimpleVector<T> {
     return values_;
   }
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   /// Returns true if this number of comparison values on this vector should use
   /// simd for equality constraint filtering, false to use standard set
   /// examination filtering.
   bool useSimdEquality(size_t numCmpVals) const;
+#endif
 
   /// Returns the raw values of this vector as a continuous array.
   const T* rawValues() const;
@@ -289,6 +290,8 @@ class FlatVector final : public SimpleVector<T> {
         BaseVector::storageByteCount_);
   }
 
+  void transferOrCopyTo(velox::memory::MemoryPool* pool) override;
+
   void resize(vector_size_t newSize, bool setNotNull = true) override;
 
   VectorPtr slice(vector_size_t offset, vector_size_t length) const override;
@@ -414,15 +417,6 @@ class FlatVector final : public SimpleVector<T> {
     return this->typeKind() != TypeKind::UNKNOWN;
   }
 
-  uint64_t retainedSize() const override {
-    auto size =
-        BaseVector::retainedSize() + (values_ ? values_->capacity() : 0);
-    for (auto& buffer : stringBuffers_) {
-      size += buffer->capacity();
-    }
-    return size;
-  }
-
   /// Used for vectors of type VARCHAR and VARBINARY to hold data referenced
   /// by StringView's. It is safe to share these among multiple vectors. These
   /// buffers are append only. It is allowed to append data, but it is
@@ -431,6 +425,16 @@ class FlatVector final : public SimpleVector<T> {
     return stringBuffers_;
   }
 
+  /// Used for vectors of type VARCHAR and VARBINARY. Returns the total size in
+  /// bytes of string buffers held by this vector.
+  uint64_t stringBufferSize() const {
+    uint64_t size = 0;
+    for (const auto& buffer : stringBuffers_) {
+      size += buffer->capacity();
+    }
+    return size;
+  }
+
   /// Used for vectors of type VARCHAR and VARBINARY to replace the old data
   /// buffers with 'buffers' which are referenced by StringView's.
   void setStringBuffers(std::vector<BufferPtr> buffers) {
@@ -555,10 +559,11 @@ class FlatVector final : public SimpleVector<T> {
       const vector_size_t* toSourceRow);
 
   // Ensures that the values buffer has space for 'newSize' elements and is
-  // mutable. Sets elements between the old and new sizes to 'initialValue' if
-  // the new size > old size.
+  // mutable. Sets elements between the previous and new sizes to 'initialValue'
+  // if the new size > previous size.
   void resizeValues(
       vector_size_t newSize,
+      vector_size_t previousSize,
       const std::optional<T>& initialValue);
 
   // Check string buffers. Keep at most one singly-referenced buffer if it is
@@ -578,6 +583,21 @@ class FlatVector final : public SimpleVector<T> {
     }
   }
 
+  // Transfer or copy string buffers to 'pool'. Update StringViews in values_ to
+  // reference addresses in the new buffers. Non-StringView-typed FlatVector
+  // should not have string buffers.
+  void transferAndUpdateStringBuffers(velox::memory::MemoryPool* pool);
+
+  uint64_t retainedSizeImpl(uint64_t& totalStringBufferSize) const override {
+    auto size =
+        BaseVector::retainedSizeImpl() + (values_ ? values_->capacity() : 0);
+    for (auto& buffer : stringBuffers_) {
+      size += buffer->capacity();
+      totalStringBufferSize += buffer->capacity();
+    }
+    return size;
+  }
+
   // Contiguous values.
   // If strings, these are velox::StringViews into memory held by
   // 'stringBuffers_'
@@ -599,7 +619,8 @@ class FlatVector final : public SimpleVector<T> {
 };
 
 template <>
-bool FlatVector<bool>::valueAtFast(vector_size_t idx) const;
+SimpleVector<bool>::TValueAt FlatVector<bool>::valueAtFast(
+    vector_size_t idx) const;
 
 template <>
 const bool* FlatVector<bool>::rawValues() const;
diff --git a/velox/vector/FunctionVector.h b/velox/vector/FunctionVector.h
index 5986945492b..8d51ec58985 100644
--- a/velox/vector/FunctionVector.h
+++ b/velox/vector/FunctionVector.h
@@ -202,7 +202,16 @@ class FunctionVector : public BaseVector {
         "testingCopyPreserveEncodings not defined for FunctionVector");
   }
 
+  void transferOrCopyTo(velox::memory::MemoryPool* /*pool*/) override {
+    VELOX_UNSUPPORTED("transferTo not defined for FunctionVector");
+  }
+
  private:
+  uint64_t retainedSizeImpl(
+      uint64_t& /*totalStringBufferSize*/) const override {
+    VELOX_UNREACHABLE("retainedSize should not be called on FunctionVector");
+  }
+
   std::vector<std::shared_ptr<Callable>> functions_;
   std::vector<SelectivityVector> rowSets_;
 };
diff --git a/velox/vector/LazyVector.cpp b/velox/vector/LazyVector.cpp
index 8e2d379afea..f0c46bef8af 100644
--- a/velox/vector/LazyVector.cpp
+++ b/velox/vector/LazyVector.cpp
@@ -203,15 +203,17 @@ void LazyVector::ensureLoadedRowsImpl(
         rowSet = RowSet(iota, rows.end());
       } else {
         rowNumbers.resize(rows.end());
-        rowNumbers.resize(simd::indicesOfSetBits(
-            rows.asRange().bits(), 0, rows.end(), rowNumbers.data()));
+        rowNumbers.resize(
+            simd::indicesOfSetBits(
+                rows.asRange().bits(), 0, rows.end(), rowNumbers.data()));
         rowSet = RowSet(rowNumbers);
       }
     } else {
       selectBaseRowsToLoad(decoded, baseRows, rows);
       rowNumbers.resize(baseRows.end());
-      rowNumbers.resize(simd::indicesOfSetBits(
-          baseRows.asRange().bits(), 0, baseRows.end(), rowNumbers.data()));
+      rowNumbers.resize(
+          simd::indicesOfSetBits(
+              baseRows.asRange().bits(), 0, baseRows.end(), rowNumbers.data()));
 
       rowSet = RowSet(rowNumbers);
     }
diff --git a/velox/vector/LazyVector.h b/velox/vector/LazyVector.h
index 0c711a5f704..b50b60901c9 100644
--- a/velox/vector/LazyVector.h
+++ b/velox/vector/LazyVector.h
@@ -78,7 +78,7 @@ class ValueHook {
     VELOX_UNSUPPORTED();
   }
 
-  virtual void addValue(vector_size_t /*row*/, folly::StringPiece /*value*/) {
+  virtual void addValue(vector_size_t /*row*/, std::string_view /*value*/) {
     VELOX_UNSUPPORTED();
   }
 
@@ -159,7 +159,8 @@ class ValueHook {
       const StringView* values,
       vector_size_t size) {
     for (auto i = 0; i < size; ++i) {
-      addValue(rows[i], values[i]);
+      // TODO: Remove explicit std::string_view cast.
+      addValue(rows[i], std::string_view(values[i]));
     }
   }
 
@@ -167,12 +168,17 @@ class ValueHook {
   void addValueTyped(vector_size_t row, T value) {
     if constexpr (std::is_integral_v<T> && sizeof(T) < sizeof(int64_t)) {
       addValue(row, static_cast<int64_t>(value));
+    } else if constexpr (std::is_same_v<T, StringView>) {
+      // TODO: Remove explicit std::string_view cast.
+      addValue(row, std::string_view(value));
     } else {
       addValue(row, value);
     }
   }
 };
 
+class ChainedVectorLoader;
+
 // Produces values for a LazyVector for a set of positions.
 class VectorLoader {
  public:
@@ -207,6 +213,8 @@ class VectorLoader {
   }
 
  protected:
+  friend class ChainedVectorLoader;
+
   virtual void loadInternal(
       RowSet rows,
       ValueHook* hook,
@@ -214,6 +222,29 @@ class VectorLoader {
       VectorPtr* result) = 0;
 };
 
+class ChainedVectorLoader : public VectorLoader {
+ public:
+  using PostVectorLoadProcessor = std::function<void(VectorPtr&)>;
+
+  ChainedVectorLoader(
+      std::unique_ptr<VectorLoader> loader,
+      PostVectorLoadProcessor postLoadProc)
+      : loader_(std::move(loader)), postLoadProc_(std::move(postLoadProc)) {}
+
+ private:
+  void loadInternal(
+      RowSet rows,
+      ValueHook* hook,
+      vector_size_t resultSize,
+      VectorPtr* result) override {
+    loader_->loadInternal(rows, hook, resultSize, result);
+    postLoadProc_(*result);
+  }
+
+  std::unique_ptr<VectorLoader> loader_;
+  PostVectorLoadProcessor postLoadProc_;
+};
+
 // Vector class which produces values on first use. This is used for
 // loading columns on demand. This allows eliding load of
 // columns which have all values filtered out by e.g. joins or which
@@ -335,11 +366,6 @@ class LazyVector : public BaseVector {
     return loadedVector()->containsNullAt(index);
   }
 
-  uint64_t retainedSize() const override {
-    return isLoaded() ? loadedVector()->retainedSize()
-                      : BaseVector::retainedSize();
-  }
-
   /// Returns zero if vector has not been loaded yet.
   uint64_t estimateFlatSize() const override {
     return isLoaded() ? loadedVector()->estimateFlatSize() : 0;
@@ -355,6 +381,12 @@ class LazyVector : public BaseVector {
     return loader_->supportsHook();
   }
 
+  void chain(ChainedVectorLoader::PostVectorLoadProcessor postLoadProc) {
+    VELOX_CHECK(!allLoaded_);
+    loader_ = std::make_unique<ChainedVectorLoader>(
+        std::move(loader_), std::move(postLoadProc));
+  }
+
   // Loads 'rows' of 'vector'. 'vector' may be an arbitrary wrapping
   // of a LazyVector. 'rows' are translated through the wrappers. If
   // there is no LazyVector inside 'vector', this has no
@@ -379,6 +411,13 @@ class LazyVector : public BaseVector {
     return loadedVector()->testingCopyPreserveEncodings(pool);
   }
 
+  void transferOrCopyTo(velox::memory::MemoryPool* pool) override {
+    BaseVector::transferOrCopyTo(pool);
+    if (vector_) {
+      vector_->transferOrCopyTo(pool);
+    }
+  }
+
  private:
   static void ensureLoadedRowsImpl(
       const VectorPtr& vector,
@@ -388,6 +427,11 @@ class LazyVector : public BaseVector {
 
   void loadVectorInternal() const;
 
+  uint64_t retainedSizeImpl(uint64_t& totalStringBufferSize) const override {
+    return isLoaded() ? loadedVector()->retainedSize(totalStringBufferSize)
+                      : BaseVector::retainedSizeImpl();
+  }
+
   std::unique_ptr<VectorLoader> loader_;
 
   // True if all values are loaded.
diff --git a/velox/vector/MapConcat.cpp b/velox/vector/MapConcat.cpp
new file mode 100644
index 00000000000..2a29c4143c3
--- /dev/null
+++ b/velox/vector/MapConcat.cpp
@@ -0,0 +1,322 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/vector/MapConcat.h"
+
+#include <folly/container/F14Map.h>
+
+#include "velox/vector/DecodedVector.h"
+
+namespace facebook::velox {
+namespace {
+
+struct UpdateSource {
+  vector_size_t entryIndex;
+  int8_t sourceIndex;
+};
+
+template <typename T>
+class UpdateMapRow {
+ public:
+  // Returns true if the key was newly inserted, false if it overwrote an
+  // existing entry.
+  bool insert(
+      const DecodedVector* decoded,
+      vector_size_t entryIndex,
+      int8_t sourceIndex) {
+    auto [iter, inserted] = values_.insert_or_assign(
+        decoded->valueAt<T>(entryIndex), UpdateSource{entryIndex, sourceIndex});
+    return inserted;
+  }
+
+  template <typename F>
+  void forEachEntry(F&& func) {
+    for (auto& [_, source] : values_) {
+      func(source);
+    }
+  }
+
+  size_t size() const {
+    return values_.size();
+  }
+
+  void reserve(size_t capacity) {
+    values_.reserve(capacity);
+  }
+
+  void clear() {
+    values_.clear();
+  }
+
+ private:
+  folly::F14FastMap<T, UpdateSource> values_;
+};
+
+template <>
+class UpdateMapRow<void> {
+ public:
+  bool insert(
+      const DecodedVector* decoded,
+      vector_size_t entryIndex,
+      int8_t sourceIndex) {
+    auto [iter, inserted] = references_.insert_or_assign(
+        Reference{decoded->base(), decoded->index(entryIndex)},
+        UpdateSource{entryIndex, sourceIndex});
+    return inserted;
+  }
+
+  template <typename F>
+  void forEachEntry(F&& func) {
+    for (auto& [_, source] : references_) {
+      func(source);
+    }
+  }
+
+  size_t size() const {
+    return references_.size();
+  }
+
+  void reserve(size_t capacity) {
+    references_.reserve(capacity);
+  }
+
+  void clear() {
+    references_.clear();
+  }
+
+ private:
+  struct Reference {
+    const BaseVector* base;
+    vector_size_t index;
+
+    bool operator==(const Reference& other) const {
+      return base->equalValueAt(other.base, index, other.index);
+    }
+  };
+
+  struct ReferenceHasher {
+    uint64_t operator()(const Reference& key) const {
+      return key.base->hashValueAt(key.index);
+    }
+  };
+
+  folly::F14FastMap<Reference, UpdateSource, ReferenceHasher> references_;
+};
+
+// Returns the error message string for a duplicate key.
+std::string duplicateKeyMessage(
+    const DecodedVector& keys,
+    vector_size_t entryIndex) {
+  return keys.base()->toString(keys.index(entryIndex));
+}
+
+template <TypeKind kKeyTypeKind>
+MapVectorPtr mapConcatImpl(
+    memory::MemoryPool* pool,
+    const TypePtr& outputType,
+    std::span<DecodedVector* const> inputs,
+    const SelectivityVector& rows,
+    const MapConcatConfig& config) {
+  const auto numInputs = inputs.size();
+  const auto numRows = rows.end();
+
+  // Step 1: Compute output nulls.
+  BufferPtr newNulls;
+  if (!config.emptyForNull) {
+    for (size_t inputIdx = 0; inputIdx < numInputs; ++inputIdx) {
+      auto* nulls = inputs[inputIdx]->nulls(&rows);
+      if (!nulls) {
+        continue;
+      }
+      if (!newNulls) {
+        newNulls = allocateNulls(numRows, pool);
+        auto* raw = newNulls->asMutable<uint64_t>();
+        bits::copyBits(nulls, 0, raw, 0, numRows);
+      } else {
+        bits::andBits(newNulls->asMutable<uint64_t>(), nulls, 0, numRows);
+      }
+    }
+  }
+
+  // Step 2: Decode keys for all inputs.
+  const auto& expectedKeyType = outputType->asMap().keyType();
+  std::vector<DecodedVector> keys;
+  keys.reserve(numInputs);
+  for (size_t inputIdx = 0; inputIdx < numInputs; ++inputIdx) {
+    auto* mapVector = inputs[inputIdx]->base()->asChecked<MapVector>();
+    auto& mapKeys = mapVector->mapKeys();
+    VELOX_CHECK(
+        *expectedKeyType == *mapKeys->type(),
+        "Map key type mismatch: {} vs {}",
+        expectedKeyType->toString(),
+        mapKeys->type()->toString());
+    keys.emplace_back(*mapKeys);
+  }
+
+  // Step 3: Allocate output metadata.
+  auto newOffsets = allocateOffsets(numRows, pool);
+  auto* rawNewOffsets = newOffsets->asMutable<vector_size_t>();
+  auto newSizes = allocateSizes(numRows, pool);
+  auto* rawNewSizes = newSizes->asMutable<vector_size_t>();
+
+  // Step 4: Per-row merge.
+  std::vector<std::vector<BaseVector::CopyRange>> ranges(numInputs);
+  UpdateMapRow<typename TypeTraits<kKeyTypeKind>::NativeType> mapRow;
+  vector_size_t numEntries = 0;
+
+  rows.applyToSelected([&](vector_size_t row) {
+    rawNewOffsets[row] = numEntries;
+
+    // Check null propagation.
+    if (newNulls && bits::isBitNull(newNulls->as<uint64_t>(), row)) {
+      rawNewSizes[row] = 0;
+      return;
+    }
+
+    // Count total entries and non-empty inputs for this row.
+    vector_size_t totalEntries{0};
+    int nonEmptyCount{0};
+    int nonEmptyIdx{-1};
+    for (size_t inputIdx = 0; inputIdx < numInputs; ++inputIdx) {
+      if (config.emptyForNull && inputs[inputIdx]->isNullAt(row)) {
+        continue;
+      }
+      auto decodedIndex = inputs[inputIdx]->index(row);
+      auto* mapVector = inputs[inputIdx]->base()->asUnchecked<MapVector>();
+      auto size = mapVector->sizeAt(decodedIndex);
+      if (size > 0) {
+        ++nonEmptyCount;
+        nonEmptyIdx = inputIdx;
+      }
+      totalEntries += size;
+    }
+
+    if (totalEntries == 0) {
+      rawNewSizes[row] = 0;
+      return;
+    }
+
+    // Fast path: only one input has entries for this row.  No dedup possible.
+    if (nonEmptyCount == 1) {
+      auto decodedIndex = inputs[nonEmptyIdx]->index(row);
+      auto* mapVector = inputs[nonEmptyIdx]->base()->asUnchecked<MapVector>();
+      auto offset = mapVector->offsetAt(decodedIndex);
+      ranges[nonEmptyIdx].push_back({offset, numEntries, totalEntries});
+      rawNewSizes[row] = totalEntries;
+      numEntries += totalEntries;
+      return;
+    }
+
+    // Build hash map for this row.
+    mapRow.reserve(totalEntries);
+    for (size_t inputIdx = 0; inputIdx < numInputs; ++inputIdx) {
+      if (config.emptyForNull && inputs[inputIdx]->isNullAt(row)) {
+        continue;
+      }
+      auto decodedIndex = inputs[inputIdx]->index(row);
+      auto* mapVector = inputs[inputIdx]->base()->asUnchecked<MapVector>();
+      auto offset = mapVector->offsetAt(decodedIndex);
+      auto size = mapVector->sizeAt(decodedIndex);
+      for (vector_size_t entryIdx = 0; entryIdx < size; ++entryIdx) {
+        auto entryOffset = offset + entryIdx;
+        VELOX_CHECK(
+            !keys[inputIdx].isNullAt(entryOffset), "Map key cannot be null");
+        bool inserted = mapRow.insert(&keys[inputIdx], entryOffset, inputIdx);
+        if (config.throwOnDuplicateKeys && !inserted) {
+          VELOX_USER_FAIL(
+              "Duplicate map key {} was found.",
+              duplicateKeyMessage(keys[inputIdx], entryOffset));
+        }
+      }
+    }
+
+    // If no dedup happened, use bulk copy ranges (much faster than
+    // per-entry ranges).
+    if (mapRow.size() == totalEntries) {
+      mapRow.clear();
+      for (size_t inputIdx = 0; inputIdx < numInputs; ++inputIdx) {
+        if (config.emptyForNull && inputs[inputIdx]->isNullAt(row)) {
+          continue;
+        }
+        auto decodedIndex = inputs[inputIdx]->index(row);
+        auto* mapVector = inputs[inputIdx]->base()->asUnchecked<MapVector>();
+        auto offset = mapVector->offsetAt(decodedIndex);
+        auto size = mapVector->sizeAt(decodedIndex);
+        if (size > 0) {
+          ranges[inputIdx].push_back({offset, numEntries, size});
+          numEntries += size;
+        }
+      }
+      rawNewSizes[row] = totalEntries;
+      return;
+    }
+
+    // Dedup happened — collect deduplicated entries into per-entry copy
+    // ranges.
+    vector_size_t newSize{0};
+    mapRow.forEachEntry([&](UpdateSource source) {
+      ranges[source.sourceIndex].push_back(
+          {source.entryIndex, numEntries + newSize, 1});
+      ++newSize;
+    });
+    mapRow.clear();
+    rawNewSizes[row] = newSize;
+    numEntries += newSize;
+  });
+
+  // Step 5: Build result vectors.
+  auto newKeys =
+      BaseVector::create(outputType->asMap().keyType(), numEntries, pool);
+  auto newValues =
+      BaseVector::create(outputType->asMap().valueType(), numEntries, pool);
+  for (size_t inputIdx = 0; inputIdx < numInputs; ++inputIdx) {
+    auto* mapVector = inputs[inputIdx]->base()->asUnchecked<MapVector>();
+    newKeys->copyRanges(mapVector->mapKeys().get(), ranges[inputIdx]);
+    newValues->copyRanges(mapVector->mapValues().get(), ranges[inputIdx]);
+  }
+
+  return std::make_shared<MapVector>(
+      pool,
+      outputType,
+      std::move(newNulls),
+      numRows,
+      std::move(newOffsets),
+      std::move(newSizes),
+      std::move(newKeys),
+      std::move(newValues));
+}
+
+} // namespace
+
+MapVectorPtr mapConcat(
+    memory::MemoryPool* pool,
+    const TypePtr& outputType,
+    std::span<DecodedVector* const> inputs,
+    const SelectivityVector& rows,
+    const MapConcatConfig& config) {
+  VELOX_CHECK_GT(inputs.size(), 0);
+  VELOX_CHECK_LT(inputs.size(), std::numeric_limits<int8_t>::max());
+  const auto& keyType = outputType->asMap().keyType();
+  // Route to UpdateMapRow<void> (BaseVector::equalValueAt/hashValueAt) when the
+  // key type provides custom comparison, so that custom hash and equality are
+  // respected for dedup.
+  if (keyType->providesCustomComparison()) {
+    return mapConcatImpl<TypeKind::ROW>(pool, outputType, inputs, rows, config);
+  }
+  return VELOX_DYNAMIC_TYPE_DISPATCH(
+      mapConcatImpl, keyType->kind(), pool, outputType, inputs, rows, config);
+}
+
+} // namespace facebook::velox
diff --git a/velox/vector/MapConcat.h b/velox/vector/MapConcat.h
new file mode 100644
index 00000000000..752f599e064
--- /dev/null
+++ b/velox/vector/MapConcat.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <span>
+
+#include "velox/vector/ComplexVector.h"
+
+namespace facebook::velox {
+
+/// Configuration for mapConcat().
+struct MapConcatConfig {
+  /// Treat null map inputs as empty maps instead of propagating null to the
+  /// output row.
+  bool emptyForNull{false};
+
+  /// Throw an exception when duplicate keys are found across inputs.
+  bool throwOnDuplicateKeys{false};
+};
+
+/// Merge multiple map vectors into a single MapVector.  All inputs are provided
+/// as DecodedVectors.  For each selected row, entries from all inputs are
+/// merged.  When duplicate keys exist across inputs, the entry from the last
+/// input wins.  Only rows selected in 'rows' are processed; unselected rows
+/// get size 0 in the output.
+MapVectorPtr mapConcat(
+    memory::MemoryPool* pool,
+    const TypePtr& outputType,
+    std::span<DecodedVector* const> inputs,
+    const SelectivityVector& rows,
+    const MapConcatConfig& config);
+
+} // namespace facebook::velox
diff --git a/velox/vector/SelectivityVector.h b/velox/vector/SelectivityVector.h
index 4aa547f42d5..7c8779d3351 100644
--- a/velox/vector/SelectivityVector.h
+++ b/velox/vector/SelectivityVector.h
@@ -438,6 +438,8 @@ class SelectivityIterator {
 template <typename Callable>
 inline void SelectivityVector::applyToSelected(Callable func) const {
   if (isAllSelected()) {
+    // IMPORTANT: Do not remove this line.  Without it the compiler would not be
+    // able to vectorize or unroll the loop.
     const auto end = end_;
     for (vector_size_t row = begin_; row < end; ++row) {
       func(row);
diff --git a/velox/vector/SequenceVector-inl.h b/velox/vector/SequenceVector-inl.h
index 914e1d9cf27..ba23b4795e9 100644
--- a/velox/vector/SequenceVector-inl.h
+++ b/velox/vector/SequenceVector-inl.h
@@ -62,8 +62,6 @@ void SequenceVector<T>::setInternalState() {
   }
   lengths_ = sequenceLengths_->as<vector_size_t>();
   lastIndexRangeEnd_ = lengths_[0];
-  BaseVector::inMemoryBytes_ += sequenceValues_->inMemoryBytes();
-  BaseVector::inMemoryBytes_ += sequenceLengths_->capacity();
 }
 
 template <typename T>
@@ -73,7 +71,8 @@ bool SequenceVector<T>::isNullAtFast(vector_size_t idx) const {
 }
 
 template <typename T>
-const T SequenceVector<T>::valueAtFast(vector_size_t idx) const {
+typename SimpleVector<T>::TValueAt SequenceVector<T>::valueAtFast(
+    vector_size_t idx) const {
   size_t offset = offsetOfIndex(idx);
   return scalarSequenceValues_->valueAt(offset);
 }
@@ -119,6 +118,7 @@ std::unique_ptr<SimpleVector<uint64_t>> SequenceVector<T>::hashAll() const {
       0 /* nullSequenceCount */);
 }
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
 template <typename T>
 xsimd::batch<T> SequenceVector<T>::loadSIMDValueBufferAt(
     size_t byteOffset) const {
@@ -138,6 +138,7 @@ xsimd::batch<T> SequenceVector<T>::loadSIMDValueBufferAt(
     return xsimd::load_aligned(tmp);
   }
 }
+#endif
 
 template <typename T>
 bool SequenceVector<T>::checkLoadRange(size_t index, size_t count) const {
diff --git a/velox/vector/SequenceVector.h b/velox/vector/SequenceVector.h
index a3a8b0c4252..63ed5b9774a 100644
--- a/velox/vector/SequenceVector.h
+++ b/velox/vector/SequenceVector.h
@@ -34,10 +34,12 @@ namespace facebook::velox {
 template <typename T>
 class SequenceVector : public SimpleVector<T> {
  public:
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   static constexpr bool can_simd =
       (std::is_same_v<T, int64_t> || std::is_same_v<T, int32_t> ||
        std::is_same_v<T, int16_t> || std::is_same_v<T, int8_t> ||
        std::is_same_v<T, size_t>);
+#endif
 
   SequenceVector(
       velox::memory::MemoryPool* pool,
@@ -81,14 +83,15 @@ class SequenceVector : public SimpleVector<T> {
     }
   }
 
-  const T valueAtFast(vector_size_t idx) const;
+  typename SimpleVector<T>::TValueAt valueAtFast(vector_size_t idx) const;
 
-  const T valueAt(vector_size_t idx) const override {
+  typename SimpleVector<T>::TValueAt valueAt(vector_size_t idx) const override {
     return valueAtFast(idx);
   }
 
   std::unique_ptr<SimpleVector<uint64_t>> hashAll() const override;
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   /**
    * Loads a 256bit vector of data at the virtual byteOffset given
    * Note this method is implemented on each vector type, but is intentionally
@@ -97,6 +100,7 @@ class SequenceVector : public SimpleVector<T> {
    * @param byteOffset - the byte offset to laod from
    */
   xsimd::batch<T> loadSIMDValueBufferAt(size_t index) const;
+#endif
 
   /**
    * Returns a shared_ptr to the underlying byte buffer holding the values for
@@ -144,10 +148,6 @@ class SequenceVector : public SimpleVector<T> {
     return sequenceLengths_;
   }
 
-  uint64_t retainedSize() const override {
-    return sequenceValues_->retainedSize() + sequenceLengths_->capacity();
-  }
-
   bool isScalar() const override {
     return sequenceValues_->isScalar();
   }
@@ -210,12 +210,21 @@ class SequenceVector : public SimpleVector<T> {
         BaseVector::storageByteCount_);
   }
 
+  void transferOrCopyTo(velox::memory::MemoryPool* /*pool*/) override {
+    VELOX_NYI("{} unsupported", __FUNCTION__);
+  }
+
  private:
   // Prepares for use after construction.
   void setInternalState();
 
   bool checkLoadRange(size_t idx, size_t count) const;
 
+  uint64_t retainedSizeImpl(uint64_t& totalStringBufferSize) const override {
+    return sequenceValues_->retainedSize(totalStringBufferSize) +
+        sequenceLengths_->capacity();
+  }
+
   VectorPtr sequenceValues_;
   SimpleVector<T>* scalarSequenceValues_ = nullptr;
   BufferPtr sequenceLengths_;
diff --git a/velox/vector/SimpleVector.cpp b/velox/vector/SimpleVector.cpp
index b616c743de2..73155159437 100644
--- a/velox/vector/SimpleVector.cpp
+++ b/velox/vector/SimpleVector.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/vector/SimpleVector.h"
+#include "velox/functions/lib/string/StringCore.h"
 
 namespace facebook::velox {
 
@@ -30,4 +31,34 @@ void SimpleVector<StringView>::validate(
   }
 }
 
+template <>
+template <>
+bool SimpleVector<StringView>::computeAndSetIsAscii<StringView>(
+    const SelectivityVector& rows) {
+  if (rows.isSubset(*asciiInfo.readLockedAsciiComputedRows())) {
+    return asciiInfo.isAllAscii();
+  }
+  ensureIsAsciiCapacity();
+  bool isAllAscii = true;
+  rows.applyToSelected([&](auto row) {
+    if (!isNullAt(row)) {
+      auto string = valueAt(row);
+      isAllAscii &=
+          functions::stringCore::isAscii(string.data(), string.size());
+    }
+  });
+
+  auto wlockedAsciiComputedRows = asciiInfo.writeLockedAsciiComputedRows();
+  if (!wlockedAsciiComputedRows->hasSelections()) {
+    asciiInfo.setIsAllAscii(isAllAscii);
+  } else {
+    asciiInfo.setIsAllAscii(asciiInfo.isAllAscii() & isAllAscii);
+  }
+
+  wlockedAsciiComputedRows->select(rows);
+  asciiInfo.setAsciiComputedRowsEmpty(
+      !wlockedAsciiComputedRows->hasSelections());
+  return asciiInfo.isAllAscii();
+}
+
 } // namespace facebook::velox
diff --git a/velox/vector/SimpleVector.h b/velox/vector/SimpleVector.h
index 42abccb761e..dd522c8210d 100644
--- a/velox/vector/SimpleVector.h
+++ b/velox/vector/SimpleVector.h
@@ -27,7 +27,6 @@
 #include <folly/hash/Hash.h>
 #include <glog/logging.h>
 
-#include "velox/functions/lib/string/StringCore.h"
 #include "velox/type/DecimalUtil.h"
 #include "velox/type/FloatingPointUtil.h"
 #include "velox/type/Type.h"
@@ -144,10 +143,15 @@ class SimpleVector : public BaseVector {
     stats_ = std::move(stats);
   }
 
+  // Type of value returned depends on size of T. If T can fit in a machine
+  // word, return by value, otherwise return by const reference. This is an
+  // optimization to avoid copying large types.
+  using TValueAt = std::conditional_t<sizeof(T) <= sizeof(void*), T, const T&>;
+
   // Concrete Vector types need to implement this themselves.
   // This method does not do bounds checking. When the value is null the return
   // value is technically undefined (currently implemented as default of T)
-  virtual const T valueAt(vector_size_t idx) const = 0;
+  virtual TValueAt valueAt(vector_size_t idx) const = 0;
 
   std::optional<int32_t> compare(
       const BaseVector* other,
@@ -305,33 +309,7 @@ class SimpleVector : public BaseVector {
   /// present. Returns computed value.
   template <typename U = T>
   typename std::enable_if_t<std::is_same_v<U, StringView>, bool>
-  computeAndSetIsAscii(const SelectivityVector& rows) {
-    if (rows.isSubset(*asciiInfo.readLockedAsciiComputedRows())) {
-      return asciiInfo.isAllAscii();
-    }
-    ensureIsAsciiCapacity();
-    bool isAllAscii = true;
-    rows.applyToSelected([&](auto row) {
-      if (!isNullAt(row)) {
-        auto string = valueAt(row);
-        isAllAscii &=
-            functions::stringCore::isAscii(string.data(), string.size());
-      }
-    });
-
-    // Set isAllAscii flag, it will unset if we encounter any utf.
-    auto wlockedAsciiComputedRows = asciiInfo.writeLockedAsciiComputedRows();
-    if (!wlockedAsciiComputedRows->hasSelections()) {
-      asciiInfo.setIsAllAscii(isAllAscii);
-    } else {
-      asciiInfo.setIsAllAscii(asciiInfo.isAllAscii() & isAllAscii);
-    }
-
-    wlockedAsciiComputedRows->select(rows);
-    asciiInfo.setAsciiComputedRowsEmpty(
-        !wlockedAsciiComputedRows->hasSelections());
-    return asciiInfo.isAllAscii();
-  }
+  computeAndSetIsAscii(const SelectivityVector& rows);
 
   /// Clears asciiness state.
   template <typename U = T>
diff --git a/velox/vector/VariantToVector.cpp b/velox/vector/VariantToVector.cpp
index bd3d7c4f6ce..9bb85e7b9a1 100644
--- a/velox/vector/VariantToVector.cpp
+++ b/velox/vector/VariantToVector.cpp
@@ -18,249 +18,126 @@
 #include "velox/vector/ComplexVector.h"
 #include "velox/vector/FlatVector.h"
 
+#include <map>
+
 namespace facebook::velox {
+
+VectorPtr variantToVector(
+    const TypePtr& type,
+    const Variant& value,
+    memory::MemoryPool* pool) {
+  return BaseVector::createConstant(type, value, 1, pool);
+}
+
 namespace {
 
-VectorPtr callMakeVector(
-    TypePtr type,
-    const std::vector<Variant>& data,
-    memory::MemoryPool* pool);
+Variant nullVariant(const TypePtr& type) {
+  return Variant(type->kind());
+}
+
+template <TypeKind kind>
+Variant variantAt(const VectorPtr& vector, int32_t row) {
+  using T = typename TypeTraits<kind>::NativeType;
 
-template <TypeKind KIND, typename = void>
-struct VariantToVector {
-  static VectorPtr makeVector(
-      TypePtr type,
-      const std::vector<Variant>& /*data*/,
-      memory::MemoryPool* /*pool*/) {
-    VELOX_NYI("Type not supported: {}", type->toString());
+  const T value = vector->as<SimpleVector<T>>()->valueAt(row);
+
+  if (vector->type()->providesCustomComparison()) {
+    return Variant::typeWithCustomComparison<kind>(value, vector->type());
   }
-};
+
+  return Variant(value);
+}
 
 template <>
-struct VariantToVector<TypeKind::HUGEINT> {
-  static VectorPtr makeVector(
-      TypePtr type,
-      const std::vector<Variant>& /*data*/,
-      memory::MemoryPool* /*pool*/) {
-    VELOX_NYI("Type not supported: {}", type->toString());
-  }
-};
+Variant variantAt<TypeKind::VARBINARY>(const VectorPtr& vector, int32_t row) {
+  return Variant::binary(
+      std::string(vector->as<SimpleVector<StringView>>()->valueAt(row)));
+}
 
-template <TypeKind KIND>
-struct VariantToVector<
-    KIND,
-    std::enable_if_t<
-        TypeTraits<KIND>::isFixedWidth || KIND == TypeKind::VARCHAR ||
-            KIND == TypeKind::VARBINARY || KIND == TypeKind::OPAQUE,
-        void>> {
-  static constexpr bool kIsOpaque = (KIND == TypeKind::OPAQUE);
-  static VectorPtr makeVector(
-      TypePtr type,
-      const std::vector<Variant>& data,
-      memory::MemoryPool* pool) {
-    using T = typename TypeTraits<KIND>::NativeType;
+Variant variantAt(const VectorPtr& vector, vector_size_t row);
 
-    // Allocate nulls and data buffers and set all values to null by default.
-    const vector_size_t dataSize = data.size();
-    BufferPtr valuesBuffer = AlignedBuffer::allocate<T>(dataSize, pool);
-    BufferPtr nulls = allocateNulls(dataSize, pool, bits::kNull);
+Variant arrayVariantAt(const VectorPtr& vector, vector_size_t row) {
+  auto arrayVector = vector->wrappedVector()->as<ArrayVector>();
+  auto& elements = arrayVector->elements();
 
-    // Create flat vector to store all the values.
-    auto values = std::make_shared<FlatVector<T>>(
-        pool,
-        type,
-        nulls,
-        dataSize,
-        std::move(valuesBuffer),
-        std::vector<BufferPtr>());
+  auto wrappedRow = vector->wrappedIndex(row);
+  auto offset = arrayVector->offsetAt(wrappedRow);
+  auto size = arrayVector->sizeAt(wrappedRow);
 
-    // Populate data into flat vector.
-    for (size_t i = 0; i < dataSize; i++) {
-      if (!data[i].isNull()) {
-        if constexpr (kIsOpaque) {
-          values->set(i, T(data[i].value<KIND>().obj));
-        } else {
-          values->set(i, T(data[i].value<KIND>()));
-        }
-      }
-    }
-    return values;
+  std::vector<Variant> array;
+  array.reserve(size);
+  for (vector_size_t i = 0; i < size; ++i) {
+    array.push_back(variantAt(elements, offset + i));
   }
-};
 
-template <>
-struct VariantToVector<TypeKind::ARRAY> {
-  static VectorPtr makeVector(
-      TypePtr type,
-      const std::vector<Variant>& data,
-      memory::MemoryPool* pool) {
-    // Create offsets, sizes and nulls buffers.
-    vector_size_t size = data.size();
-    BufferPtr offsets = allocateOffsets(size, pool);
-    BufferPtr sizes = allocateSizes(size, pool);
-    BufferPtr nulls = allocateNulls(size, pool);
-    auto rawOffsets = offsets->asMutable<vector_size_t>();
-    auto rawSizes = sizes->asMutable<vector_size_t>();
-    auto rawNulls = nulls->asMutable<uint64_t>();
+  return Variant::array(array);
+}
 
-    // Iterate through array values and set values in offsets and sizes buffers.
-    // Create container for underlying array elements to create an elements
-    // vector.
-    std::vector<Variant> elements;
-    vector_size_t index = 0;
-    vector_size_t nullCount = 0;
-    for (size_t i = 0; i < data.size(); ++i) {
-      auto isNull = data[i].isNull();
-      *rawOffsets++ = index;
-      *rawSizes++ = !isNull ? data[i].array().size() : 0;
-      if (isNull) {
-        ++nullCount;
-        bits::setNull(rawNulls, i, true);
-        continue;
-      }
-      for (const auto& arrayElement : data[i].array()) {
-        elements.push_back(arrayElement);
-        ++index;
-      }
-    }
+Variant mapVariantAt(const VectorPtr& vector, vector_size_t row) {
+  auto mapVector = vector->wrappedVector()->as<MapVector>();
+  auto& keys = mapVector->mapKeys();
+  auto& values = mapVector->mapValues();
 
-    // Create child elements vector with all the array values.
-    TypePtr elementType = type->childAt(0);
-    auto elementsVector = callMakeVector(elementType, elements, pool);
+  auto wrappedRow = vector->wrappedIndex(row);
+  auto offset = mapVector->offsetAt(wrappedRow);
+  auto size = mapVector->sizeAt(wrappedRow);
 
-    return std::make_shared<ArrayVector>(
-        pool,
-        type,
-        nulls,
-        size,
-        offsets,
-        sizes,
-        std::move(elementsVector),
-        nullCount);
+  std::map<Variant, Variant> map;
+  for (vector_size_t i = 0; i < size; ++i) {
+    map.emplace(variantAt(keys, offset + i), variantAt(values, offset + i));
   }
-};
 
-template <>
-struct VariantToVector<TypeKind::MAP> {
-  static VectorPtr makeVector(
-      TypePtr type,
-      const std::vector<Variant>& data,
-      memory::MemoryPool* pool) {
-    // Create offsets, sizes and nulls buffers.
-    vector_size_t size = data.size();
-    BufferPtr offsets = allocateOffsets(size, pool);
-    BufferPtr sizes = allocateSizes(size, pool);
-    BufferPtr nulls = allocateNulls(size, pool);
-    auto rawOffsets = offsets->asMutable<vector_size_t>();
-    auto rawSizes = sizes->asMutable<vector_size_t>();
-    auto rawNulls = nulls->asMutable<uint64_t>();
-
-    // Iterate through map (key,value) pairs and set offsets, sizes and nulls
-    // buffers. Create container for underlying key and value elements to create
-    // child vectors.
-    std::vector<Variant> keys;
-    std::vector<Variant> values;
-    vector_size_t index = 0;
-    vector_size_t nullCount = 0;
-    for (size_t i = 0; i < data.size(); ++i) {
-      auto isNull = data[i].isNull();
-      *rawOffsets++ = index;
-      *rawSizes++ = !isNull ? data[i].map().size() : 0;
-      if (isNull) {
-        ++nullCount;
-        bits::setNull(rawNulls, i, true);
-        continue;
-      }
-      for (const auto& [key, value] : data[i].map()) {
-        keys.push_back(key);
-        values.push_back(value);
-        ++index;
-      }
-    }
+  return Variant::map(std::move(map));
+}
 
-    // Create keys and values vector with corresponding values.
-    auto keysVector = callMakeVector(type->childAt(0), keys, pool);
-    auto valuesVector = callMakeVector(type->childAt(1), values, pool);
+Variant rowVariantAt(const VectorPtr& vector, vector_size_t row) {
+  auto rowVector = vector->wrappedVector()->as<RowVector>();
+  auto wrappedRow = vector->wrappedIndex(row);
 
-    return std::make_shared<MapVector>(
-        pool,
-        type,
-        nulls,
-        size,
-        offsets,
-        sizes,
-        std::move(keysVector),
-        std::move(valuesVector),
-        nullCount);
+  std::vector<Variant> rowValues;
+  rowValues.reserve(rowVector->childrenSize());
+  for (vector_size_t i = 0; i < rowVector->childrenSize(); ++i) {
+    rowValues.push_back(variantAt(rowVector->childAt(i), wrappedRow));
   }
-};
 
-template <>
-struct VariantToVector<TypeKind::ROW> {
-  static VectorPtr makeVector(
-      TypePtr type,
-      const std::vector<Variant>& data,
-      memory::MemoryPool* pool) {
-    vector_size_t size = data.size();
-    BufferPtr nulls = allocateNulls(size, pool);
-    auto rawNulls = nulls->asMutable<uint64_t>();
+  return Variant::row(rowValues);
+}
 
-    auto childCount = type->size();
-    std::vector<std::vector<Variant>> children;
-    children.reserve(childCount);
-    for (size_t i = 0; i < childCount; ++i) {
-      std::vector<Variant> child;
-      child.reserve(size);
-      children.push_back(child);
-    }
+Variant variantAt(const VectorPtr& vector, vector_size_t row) {
+  if (vector->isNullAt(row)) {
+    return nullVariant(vector->type());
+  }
 
-    // Populate data for each of the columns.
-    for (size_t i = 0; i < data.size(); ++i) {
-      if (data[i].isNull()) {
-        bits::setNull(rawNulls, i, true);
-        continue;
-      }
-      const auto& row = data[i].row();
-      VELOX_CHECK_EQ(row.size(), children.size());
-      for (size_t j = 0; j < row.size(); ++j) {
-        children[j].push_back(row[j]);
-      }
-    }
+  auto typeKind = vector->typeKind();
 
-    std::vector<VectorPtr> childVectors;
-    childVectors.reserve(childCount);
-    for (size_t i = 0; i < childCount; ++i) {
-      // @lint-ignore CLANGTIDY facebook-hte-LocalUncheckedArrayBounds
-      childVectors.push_back(
-          callMakeVector(type->childAt(i), children[i], pool));
+  if (vector->isConstantEncoding()) {
+    if (vector->valueVector()) {
+      return variantAt(vector->valueVector(), vector->wrappedIndex(row));
     }
-
-    return std::make_shared<RowVector>(pool, type, nulls, size, childVectors);
+    return variantAt(BaseVector::wrappedVectorShared(vector), 0);
   }
-};
 
-VectorPtr callMakeVector(
-    TypePtr type,
-    const std::vector<Variant>& data,
-    memory::MemoryPool* pool) {
-  return VELOX_DYNAMIC_TYPE_DISPATCH_METHOD_ALL(
-      VariantToVector, makeVector, type->kind(), type, data, pool);
+  switch (typeKind) {
+    case TypeKind::ARRAY:
+      return arrayVariantAt(vector, row);
+    case TypeKind::MAP:
+      return mapVariantAt(vector, row);
+    case TypeKind::ROW:
+      return rowVariantAt(vector, row);
+    case TypeKind::OPAQUE:
+      return Variant::opaque(
+          vector->as<SimpleVector<std::shared_ptr<void>>>()->valueAt(row),
+          std::dynamic_pointer_cast<const OpaqueType>(vector->type()));
+    default:
+      return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+          variantAt, typeKind, vector, row);
+  }
 }
 
 } // namespace
 
-VectorPtr variantToVector(
-    const TypePtr& type,
-    const Variant& value,
-    memory::MemoryPool* pool) {
-  if (value.isNull()) {
-    return BaseVector::createNullConstant(type, 1, pool);
-  } else if (type->isPrimitiveType()) {
-    return BaseVector::createConstant(type, value, 1, pool);
-  }
-
-  auto variantVector = callMakeVector(type, {value}, pool);
-  return BaseVector::wrapInConstant(1, 0, std::move(variantVector));
+Variant vectorToVariant(const VectorPtr& vector, vector_size_t index) {
+  return variantAt(vector, index);
 }
 
 } // namespace facebook::velox
diff --git a/velox/vector/VariantToVector.h b/velox/vector/VariantToVector.h
index f74225cfd67..0ec557e284c 100644
--- a/velox/vector/VariantToVector.h
+++ b/velox/vector/VariantToVector.h
@@ -21,12 +21,12 @@ namespace facebook::velox {
 
 // Converts Variant `value` into a Velox vector using specified type.
 //
-// Supports all primitive types and complex types that do not contain DECIMAL
-// types.
+// Supports all primitive types and complex types.
 //
 // @returns ConstantVector of size 1.
 //
-// TODO Fold into BaseVector::createConstant API.
+// Deprecated: use BaseVector::createConstant instead.
+[[deprecated("Use BaseVector::createConstant")]]
 VectorPtr variantToVector(
     const TypePtr& type,
     const Variant& value,
diff --git a/velox/vector/VectorSaver.cpp b/velox/vector/VectorSaver.cpp
index 7845000b1c1..116d1b6d8af 100644
--- a/velox/vector/VectorSaver.cpp
+++ b/velox/vector/VectorSaver.cpp
@@ -69,6 +69,7 @@ bool read<bool>(std::istream& in) {
 template <>
 std::string read<std::string>(std::istream& in) {
   auto size = read<int32_t>(in);
+  VELOX_CHECK_GE(size, 0, "Invalid serialized string size: {}", size);
   std::string data;
   data.resize(size);
   in.read(data.data(), size);
@@ -248,10 +249,11 @@ void writeStringViews(
   std::vector<BufferMetadata> sortedStringBuffers;
   sortedStringBuffers.reserve(stringBuffers.size());
   for (int64_t i = 0; i < stringBuffers.size(); ++i) {
-    sortedStringBuffers.push_back(BufferMetadata{
-        stringBuffers[i]->as<char>(),
-        stringBuffers[i]->as<char>() + stringBuffers[i]->size(),
-        i});
+    sortedStringBuffers.push_back(
+        BufferMetadata{
+            stringBuffers[i]->as<char>(),
+            stringBuffers[i]->as<char>() + stringBuffers[i]->size(),
+            i});
   }
 
   std::sort(
diff --git a/velox/vector/VectorStream.cpp b/velox/vector/VectorStream.cpp
index 32d5886ca45..b257436dfd5 100644
--- a/velox/vector/VectorStream.cpp
+++ b/velox/vector/VectorStream.cpp
@@ -66,9 +66,9 @@ std::unique_ptr<VectorSerde>& getVectorSerdeImpl() {
   return serde;
 }
 
-std::unordered_map<VectorSerde::Kind, std::unique_ptr<VectorSerde>>&
+std::unordered_map<std::string, std::unique_ptr<VectorSerde>>&
 getNamedVectorSerdeImpl() {
-  static std::unordered_map<VectorSerde::Kind, std::unique_ptr<VectorSerde>>
+  static std::unordered_map<std::string, std::unique_ptr<VectorSerde>>
       namedSerdes;
   return namedSerdes;
 }
@@ -147,7 +147,7 @@ bool isRegisteredVectorSerde() {
 
 /// Named serde helper functions.
 void registerNamedVectorSerde(
-    VectorSerde::Kind kind,
+    const std::string& kind,
     std::unique_ptr<VectorSerde> serdeToRegister) {
   auto& namedSerdeMap = getNamedVectorSerdeImpl();
   VELOX_CHECK(
@@ -157,17 +157,17 @@ void registerNamedVectorSerde(
   namedSerdeMap[kind] = std::move(serdeToRegister);
 }
 
-void deregisterNamedVectorSerde(VectorSerde::Kind kind) {
+void deregisterNamedVectorSerde(const std::string& kind) {
   auto& namedSerdeMap = getNamedVectorSerdeImpl();
   namedSerdeMap.erase(kind);
 }
 
-bool isRegisteredNamedVectorSerde(VectorSerde::Kind kind) {
+bool isRegisteredNamedVectorSerde(const std::string& kind) {
   auto& namedSerdeMap = getNamedVectorSerdeImpl();
   return namedSerdeMap.find(kind) != namedSerdeMap.end();
 }
 
-VectorSerde* getNamedVectorSerde(VectorSerde::Kind kind) {
+VectorSerde* getNamedVectorSerde(const std::string& kind) {
   auto& namedSerdeMap = getNamedVectorSerdeImpl();
   auto it = namedSerdeMap.find(kind);
   VELOX_CHECK(
@@ -322,10 +322,11 @@ RowVectorPtr IOBufToRowVector(
   ranges.reserve(4);
 
   for (const auto& range : ioBuf) {
-    ranges.emplace_back(ByteRange{
-        const_cast<uint8_t*>(range.data()),
-        static_cast<int32_t>(range.size()),
-        0});
+    ranges.emplace_back(
+        ByteRange{
+            const_cast<uint8_t*>(range.data()),
+            static_cast<int32_t>(range.size()),
+            0});
   }
 
   auto byteStream = std::make_unique<BufferInputStream>(std::move(ranges));
@@ -340,4 +341,31 @@ RowVectorPtr IOBufToRowVector(
   return outputVector;
 }
 
+folly::IOBuf rowVectorToIOBufBatch(
+    const RowVectorPtr& rowVector,
+    memory::MemoryPool& pool,
+    VectorSerde* serde,
+    const VectorSerde::Options* options) {
+  return rowVectorToIOBufBatch(
+      rowVector, rowVector->size(), pool, serde, options);
+}
+
+folly::IOBuf rowVectorToIOBufBatch(
+    const RowVectorPtr& rowVector,
+    vector_size_t rangeEnd,
+    memory::MemoryPool& pool,
+    VectorSerde* serde,
+    const VectorSerde::Options* options) {
+  if (serde == nullptr) {
+    serde = getVectorSerde();
+  }
+
+  auto serializer = serde->createBatchSerializer(&pool, options);
+  IOBufOutputStream stream(pool);
+  IndexRange range{0, rangeEnd};
+  Scratch scratch;
+  serializer->serialize(rowVector, folly::Range(&range, 1), scratch, &stream);
+  return std::move(*stream.getIOBuf());
+}
+
 } // namespace facebook::velox
diff --git a/velox/vector/VectorStream.h b/velox/vector/VectorStream.h
index a11733c803b..ebab1146a49 100644
--- a/velox/vector/VectorStream.h
+++ b/velox/vector/VectorStream.h
@@ -128,12 +128,12 @@ class IterativeVectorSerializer {
 
   /// Defines the exported runtime stats.
   /// The number of bytes before compression.
-  static inline const std::string kCompressionInputBytes{
+  static constexpr std::string_view kCompressionInputBytes{
       "compressionInputBytes"};
   /// The number of bytes after compression.
-  static inline const std::string kCompressedBytes{"compressedBytes"};
+  static constexpr std::string_view kCompressedBytes{"compressedBytes"};
   /// The number of bytes that skip in-efficient compression.
-  static inline const std::string kCompressionSkippedBytes{
+  static constexpr std::string_view kCompressionSkippedBytes{
       "compressionSkippedBytes"};
 
   /// Returns serializer-dependent counters, e.g. about compression, data
@@ -190,7 +190,13 @@ class RowIterator {
 
   virtual bool hasNext() const = 0;
 
-  virtual std::unique_ptr<std::string> next() = 0;
+  virtual std::unique_ptr<std::string> nextRow() = 0;
+
+  /// Returns a batch of serialized rows as string views. Reads up to maxRows
+  /// from the source stream. The returned views are valid until the next call
+  /// to nextBatch or object destruction. This method provides better
+  /// performance for bulk operations compared to repeated nextRow() calls.
+  virtual std::vector<std::string_view> nextBatch(size_t maxRows) = 0;
 
  protected:
   ByteInputStream* const source_;
@@ -231,9 +237,12 @@ class VectorSerde {
     /// than this causes subsequent compression attempts to be skipped. The more
     /// times compression misses the target the less frequently it is tried.
     float minCompressionRatio{0.8};
+
+    /// Minimum page size to attempt compression.
+    int32_t minCompressionPageSizeBytes{0};
   };
 
-  Kind kind() const {
+  const std::string& kind() const {
     return kind_;
   }
 
@@ -346,9 +355,9 @@ class VectorSerde {
   }
 
  protected:
-  explicit VectorSerde(Kind kind) : kind_(kind) {}
+  explicit VectorSerde(std::string kind) : kind_(std::move(kind)) {}
 
-  const Kind kind_;
+  const std::string kind_;
 };
 
 std::ostream& operator<<(std::ostream& out, VectorSerde::Kind kind);
@@ -366,16 +375,16 @@ VectorSerde* getVectorSerde();
 /// Register/deregister a named vector serde. `serdeName` is a handle that
 /// allows users to register multiple serde formats.
 void registerNamedVectorSerde(
-    VectorSerde::Kind kind,
+    const std::string& kind,
     std::unique_ptr<VectorSerde> serdeToRegister);
-void deregisterNamedVectorSerde(VectorSerde::Kind kind);
+void deregisterNamedVectorSerde(const std::string& kind);
 
 /// Check if a named vector serde has been registered with `serdeName` as a
 /// handle.
-bool isRegisteredNamedVectorSerde(VectorSerde::Kind kind);
+bool isRegisteredNamedVectorSerde(const std::string& kind);
 
 /// Get the vector serde identified by `serdeName`. Throws if not found.
-VectorSerde* getNamedVectorSerde(VectorSerde::Kind kind);
+VectorSerde* getNamedVectorSerde(const std::string& kind);
 
 class VectorStreamGroup : public StreamArena {
  public:
@@ -501,6 +510,22 @@ folly::IOBuf rowVectorToIOBuf(
     memory::MemoryPool& pool,
     VectorSerde* serde = nullptr);
 
+/// Convenience function to serialize a single rowVector into an IOBuf using
+/// BatchVectorSerializer, which preserves encodings of input vectors.
+folly::IOBuf rowVectorToIOBufBatch(
+    const RowVectorPtr& rowVector,
+    memory::MemoryPool& pool,
+    VectorSerde* serde = nullptr,
+    const VectorSerde::Options* options = nullptr);
+
+/// Same as above but serializes up until row `rangeEnd`.
+folly::IOBuf rowVectorToIOBufBatch(
+    const RowVectorPtr& rowVector,
+    vector_size_t rangeEnd,
+    memory::MemoryPool& pool,
+    VectorSerde* serde = nullptr,
+    const VectorSerde::Options* options = nullptr);
+
 /// Convenience function to deserialize an IOBuf into a rowVector. If `serde` is
 /// nullptr, use the default installed serializer.
 RowVectorPtr IOBufToRowVector(
diff --git a/velox/vector/arrow/Bridge.cpp b/velox/vector/arrow/Bridge.cpp
index a49d68995e6..785dfbf9d05 100644
--- a/velox/vector/arrow/Bridge.cpp
+++ b/velox/vector/arrow/Bridge.cpp
@@ -263,9 +263,16 @@ const char* exportArrowFormatStr(
     const ArrowOptions& options,
     std::string& formatBuffer) {
   if (type->isDecimal()) {
-    // Decimal types encode the precision, scale values.
+    // Decimal types encode the precision and scale values.
     const auto& [precision, scale] = getDecimalPrecisionScale(*type);
-    formatBuffer = fmt::format("d:{},{}", precision, scale);
+    if (options.useDecimalTypeWidth) {
+      // Add the (optional) bit-width suffix.
+      const int bitWidth = type->isShortDecimal() ? 64 : 128;
+      formatBuffer = fmt::format("d:{},{},{}", precision, scale, bitWidth);
+    } else {
+      // Assume default 128.
+      formatBuffer = fmt::format("d:{},{}", precision, scale);
+    }
     return formatBuffer.c_str();
   }
 
@@ -286,6 +293,17 @@ const char* exportArrowFormatStr(
       }
       return "i"; // int32
     case TypeKind::BIGINT:
+      if (type->isTime()) {
+        if (type->equivalent(*TIME())) {
+          // TIME is stored as milliseconds since midnight in Velox.
+          // Export as Arrow time32 with milliseconds unit.
+          return "ttm";
+        }
+        VELOX_DCHECK(type->equivalent(*TIME_MICRO_UTC()));
+        // TIME MICRO UTC is stored as microseconds since midnight in Velox.
+        // Export as Arrow time64 with microseconds unit.
+        return "ttu";
+      }
       return "l"; // int64
     case TypeKind::REAL:
       return "f"; // float32
@@ -299,6 +317,9 @@ const char* exportArrowFormatStr(
       }
       return "u"; // utf-8 string
     case TypeKind::VARBINARY:
+      if (options.exportVarbinaryAsString) {
+        return "u"; // utf-8 string (binary payload)
+      }
       if (options.exportToStringView) {
         return "vz";
       }
@@ -385,6 +406,30 @@ struct Selection {
   vector_size_t total_;
 };
 
+// Gather values from time buffer. Nulls are skipped.
+// TIME is stored as int64_t milliseconds in Velox, converted to int32_t
+// milliseconds for Arrow time32.
+void gatherFromTimeBuffer(
+    const BaseVector& vec,
+    const Selection& rows,
+    Buffer& out) {
+  auto src = (*vec.values()).as<int64_t>();
+  auto dst = out.asMutable<int32_t>();
+  vector_size_t j = 0;
+  if (!vec.mayHaveNulls() || vec.getNullCount() == 0) {
+    // Convert int64 milliseconds to int32 milliseconds.
+    rows.apply(
+        [&](vector_size_t i) { dst[j++] = static_cast<int32_t>(src[i]); });
+    return;
+  }
+  rows.apply([&](vector_size_t i) {
+    if (!vec.isNullAt(i)) {
+      dst[j] = static_cast<int32_t>(src[i]); // int64 to int32 milliseconds.
+    }
+    j++;
+  });
+}
+
 // Gather values from timestamp buffer. Nulls are skipped.
 void gatherFromTimestampBuffer(
     const BaseVector& vec,
@@ -465,7 +510,7 @@ void gatherFromBuffer(
     rows.apply([&](vector_size_t i) {
       bits::setBit(dst, j++, bits::isBitSet(src, i));
     });
-  } else if (type.isShortDecimal()) {
+  } else if (type.isShortDecimal() && !options.useDecimalTypeWidth) {
     rows.apply([&](vector_size_t i) {
       int128_t value = buf.as<int64_t>()[i];
       memcpy(dst + (j++) * sizeof(int128_t), &value, sizeof(int128_t));
@@ -586,12 +631,19 @@ VectorPtr createStringFlatVectorFromUtf8View(
     auto* view = reinterpret_cast<const uint32_t*>(&(
         reinterpret_cast<const uint64_t*>(arrowArray.buffers[1]))[2 * idx_64]);
     rawStringViews[2 * idx_64] = *reinterpret_cast<const uint64_t*>(view);
-    if (view[0] > 12)
+    if (view[0] > 12) {
+      const auto bufferIndex = view[2];
+      VELOX_CHECK_LT(
+          bufferIndex,
+          num_buffers - 3,
+          "Arrow Utf8View buffer index out of range");
       rawStringViews[2 * idx_64 + 1] =
-          reinterpret_cast<uint64_t>(arrowArray.buffers[2 + view[2]]) + view[3];
-    else
+          reinterpret_cast<uint64_t>(arrowArray.buffers[2 + bufferIndex]) +
+          view[3];
+    } else {
       rawStringViews[2 * idx_64 + 1] =
           *reinterpret_cast<const uint64_t*>(&view[2]);
+    }
   }
 
   return std::make_shared<FlatVector<StringView>>(
@@ -621,8 +673,16 @@ VectorPtr createStringFlatVector(
   bool shouldAcquireStringBuffer = false;
 
   for (size_t i = 0; i < length; ++i) {
-    rawStringViews[i] =
-        StringView(values + offsets[i], offsets[i + 1] - offsets[i]);
+    const auto rowBytes = offsets[i + 1] - offsets[i];
+    if constexpr (!std::is_same_v<TOffset, int32_t>) {
+      VELOX_CHECK(
+          rowBytes >= 0 && rowBytes <= std::numeric_limits<int32_t>::max(),
+          "Offset difference (rowBytes = {}) is negative or out of int32_t range at index {}",
+          rowBytes,
+          i);
+    }
+
+    rawStringViews[i] = StringView(values + offsets[i], rowBytes);
     shouldAcquireStringBuffer |= !rawStringViews[i].isInline();
   }
 
@@ -677,24 +737,39 @@ void exportValidityBitmap(
   }
 }
 
-bool isFlatScalarZeroCopy(const TypePtr& type) {
-  // - Short decimals need to be converted to 128 bit values as they are
-  // mapped to Arrow Decimal128.
+bool isFlatScalarZeroCopy(const TypePtr& type, const ArrowOptions& options) {
   // - Velox's Timestamp representation (2x 64bit values) does not have an
   // equivalent in Arrow.
-  return !type->isShortDecimal() && !type->isTimestamp();
+  // - Velox's TIME (millisecond precision) is exported as Arrow time32, which
+  // is narrower than the underlying BIGINT and therefore requires conversion.
+  // TIME_MICRO_UTC matches Arrow time64 in width and is zero-copy.
+  const bool needsTimeConversion = type->isTime() && type->equivalent(*TIME());
+  if (options.useDecimalTypeWidth) {
+    // Short decimal is zero-copy.
+    return !type->isTimestamp() && !needsTimeConversion;
+  }
+  // Short decimal requires conversion.
+  return !type->isShortDecimal() && !type->isTimestamp() &&
+      !needsTimeConversion;
 }
 
 // Returns the size of a single element of a given `type` in the target arrow
 // buffer.
-size_t getArrowElementSize(const TypePtr& type) {
-  if (type->isShortDecimal()) {
+size_t getArrowElementSize(const TypePtr& type, const ArrowOptions& options) {
+  if (type->isShortDecimal() && !options.useDecimalTypeWidth) {
     return sizeof(int128_t);
   } else if (type->isTimestamp()) {
     return sizeof(int64_t);
-  } else {
-    return type->cppSizeInBytes();
+  } else if (type->isTime()) {
+    if (type->equivalent(*TIME())) {
+      // TIME is exported as Arrow time32 (int32_t).
+      return sizeof(int32_t);
+    }
+    VELOX_DCHECK(type->equivalent(*TIME_MICRO_UTC()));
+    // TIME MICRO UTC is exported as Arrow time64 (int64_t).
+    return sizeof(int64_t);
   }
+  return type->cppSizeInBytes();
 }
 
 void exportValues(
@@ -707,19 +782,27 @@ void exportValues(
   const auto& type = vec.type();
   out.n_buffers = 2;
 
-  if (!rows.changed() && isFlatScalarZeroCopy(type)) {
-    holder.setBuffer(1, vec.values());
+  if (!rows.changed() && isFlatScalarZeroCopy(type, options)) {
+    // Arrow does not allow a nullptr for the values buffer. If the input vector
+    // has no values buffer (all-null case), allocate an empty buffer of size 0.
+    auto values =
+        vec.values() ? vec.values() : AlignedBuffer::allocate<uint8_t>(0, pool);
+    holder.setBuffer(1, values);
     return;
   }
 
   // Otherwise we will need a new buffer and copy the data.
-  auto size = getArrowElementSize(type);
+  auto size = getArrowElementSize(type, options);
   auto values = type->isBoolean()
       ? AlignedBuffer::allocate<bool>(out.length, pool)
       : AlignedBuffer::allocate<uint8_t>(
             checkedMultiply<size_t>(out.length, size), pool);
   if (type->kind() == TypeKind::TIMESTAMP) {
     gatherFromTimestampBuffer(vec, rows, options.timestampUnit, *values);
+  } else if (
+      type->kind() == TypeKind::BIGINT && type->isTime() &&
+      type->equivalent(*TIME())) {
+    gatherFromTimeBuffer(vec, rows, *values);
   } else {
     gatherFromBuffer(*type, *vec.values(), rows, options, *values);
   }
@@ -799,13 +882,15 @@ void exportViews(
       if (i == 0 ||
           (currAddr - bufferAddrCache) >
               rawVariadicBufferSizes[bufferIdxCache]) {
-        auto it = std::prev(std::upper_bound(
-            stringBufferVec.begin(),
-            stringBufferVec.end(),
-            currAddr,
-            [&out](const auto& lhs, const auto& rhs) {
-              return lhs < (reinterpret_cast<uint64_t*>(&out.buffers[2]))[rhs];
-            }));
+        auto it = std::prev(
+            std::upper_bound(
+                stringBufferVec.begin(),
+                stringBufferVec.end(),
+                currAddr,
+                [&out](const auto& lhs, const auto& rhs) {
+                  return lhs <
+                      (reinterpret_cast<uint64_t*>(&out.buffers[2]))[rhs];
+                }));
         bufferAddrCache = (reinterpret_cast<uint64_t*>(&out.buffers[2]))[*it];
         bufferIdxCache = *it;
       }
@@ -867,9 +952,11 @@ void exportFlat(
     case TypeKind::REAL:
     case TypeKind::DOUBLE:
     case TypeKind::TIMESTAMP:
-    case TypeKind::UNKNOWN:
       exportValues(vec, rows, options, out, pool, holder);
       break;
+    case TypeKind::UNKNOWN:
+      // Keep out.n_children = 0 for UNKNOWN type.
+      break;
     case TypeKind::VARCHAR:
     case TypeKind::VARBINARY:
       if (options.exportToStringView) {
@@ -1108,19 +1195,23 @@ void exportConstantValue(
     // If this is a scalar type, then ConstantVector does not have a vector
     // inside. Wrap the single value in a flat vector with a single element to
     // export it to an ArrowArray.
-    size_t bufferSize = (vec.type()->isVarchar() || vec.type()->isVarbinary())
-        ? sizeof(StringView)
-        : vec.type()->cppSizeInBytes();
+    if (vec.typeKind() == TypeKind::UNKNOWN) {
+      valuesVector = BaseVector::create(vec.type(), 1, pool);
+    } else {
+      size_t bufferSize = (vec.type()->isVarchar() || vec.type()->isVarbinary())
+          ? sizeof(StringView)
+          : vec.type()->cppSizeInBytes();
 
-    valuesVector = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
-        createFlatVector,
-        vec.typeKind(),
-        pool,
-        vec.type(),
-        vec.nulls(),
-        1,
-        wrapInBufferViewAsViewer(vec.valuesAsVoid(), bufferSize),
-        vec.mayHaveNulls() ? 1 : 0);
+      valuesVector = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+          createFlatVector,
+          vec.typeKind(),
+          pool,
+          vec.type(),
+          vec.nulls(),
+          1,
+          wrapInBufferViewAsViewer(vec.valuesAsVoid(), bufferSize),
+          vec.mayHaveNulls() ? 1 : 0);
+    }
   }
   exportToArrowImpl(*valuesVector, selection, options, out, pool);
 }
@@ -1214,39 +1305,59 @@ void exportToArrowImpl(
 
 // Parses the velox decimal format from the given arrow format.
 // The input format string should be in the form "d:precision,scale<,bitWidth>".
-// bitWidth is not required and must be 128 if provided.
-TypePtr parseDecimalFormat(const char* format) {
-  std::string invalidFormatMsg =
-      "Unable to convert '{}' ArrowSchema decimal format to Velox decimal";
+// bitWidth is optional and may be 64 or 128 if provided.
+
+int32_t parseDecimalBitWidthOrDefault(const std::string_view format) {
+  auto firstCommaIdx = format.find(',', 2);
+  auto secondCommaIdx = format.find(',', firstCommaIdx + 1);
+  if (secondCommaIdx == std::string_view::npos) {
+    // Default per Arrow C data interface conventions.
+    return 128;
+  }
+  // Parse the bitWidth.
+  std::string::size_type sz{};
+  int32_t bitWidth = std::stoi(&format[secondCommaIdx + 1], &sz);
+  return bitWidth;
+}
+
+TypePtr parseDecimalFormat(const std::string_view format) {
   try {
-    std::string::size_type sz;
-    std::string formatStr(format);
+    std::string_view::size_type sz;
 
-    auto firstCommaIdx = formatStr.find(',', 2);
-    auto secondCommaIdx = formatStr.find(',', firstCommaIdx + 1);
+    auto firstCommaIdx = format.find(',', 2);
+    auto secondCommaIdx = format.find(',', firstCommaIdx + 1);
 
-    if (firstCommaIdx == std::string::npos ||
-        formatStr.size() == firstCommaIdx + 1 ||
-        (secondCommaIdx != std::string::npos &&
-         formatStr.size() == secondCommaIdx + 1)) {
-      VELOX_USER_FAIL(invalidFormatMsg, format);
+    if (firstCommaIdx == std::string_view::npos ||
+        format.size() == firstCommaIdx + 1 ||
+        (secondCommaIdx != std::string_view::npos &&
+         format.size() == secondCommaIdx + 1)) {
+      VELOX_USER_FAIL(
+          "Unable to convert '{}' ArrowSchema decimal format to Velox decimal",
+          format);
     }
 
     // Parse "d:".
     int precision = std::stoi(&format[2], &sz);
     int scale = std::stoi(&format[firstCommaIdx + 1], &sz);
-    // If bitwidth is provided, check if it is equal to 128.
-    if (secondCommaIdx != std::string::npos) {
+    if (secondCommaIdx != std::string_view::npos) {
+      // BitWidth is provided. We only support 64 or 128.
       int bitWidth = std::stoi(&format[secondCommaIdx + 1], &sz);
-      VELOX_USER_CHECK_EQ(
-          bitWidth,
-          128,
-          "Conversion failed for '{}'. Velox decimal does not support custom bitwidth.",
+      // Return type depends on bitWidth.
+      if (bitWidth == 64) {
+        return std::make_shared<ShortDecimalType>(precision, scale);
+      } else if (bitWidth == 128) {
+        return std::make_shared<LongDecimalType>(precision, scale);
+      }
+      VELOX_USER_FAIL(
+          "Conversion failed for '{}'. Only 64-bit and 128-bit decimal types are supported.",
           format);
     }
+    // Otherwise return type depends on precision.
     return DECIMAL(precision, scale);
   } catch (std::invalid_argument&) {
-    VELOX_USER_FAIL(invalidFormatMsg, format);
+    VELOX_USER_FAIL(
+        "Unable to convert '{}' ArrowSchema decimal format to Velox decimal",
+        format);
   }
 }
 
@@ -1299,6 +1410,9 @@ TypePtr importFromArrowImpl(
       if (format[1] == 'd' && format[2] == 'D') {
         return DATE();
       }
+      if (format[1] == 't') {
+        return TIME();
+      }
       if (format[1] == 'i' && format[2] == 'M') {
         return INTERVAL_YEAR_MONTH();
       }
@@ -1540,6 +1654,32 @@ TypePtr importFromArrow(const ArrowSchema& arrowSchema) {
 
 namespace {
 
+enum class TimeUnit { kSecond, kMilli, kMicro, kNano };
+
+TimeUnit getTimeUnit(const ArrowSchema& arrowSchema) {
+  const char* format = arrowSchema.dictionary ? arrowSchema.dictionary->format
+                                              : arrowSchema.format;
+  VELOX_USER_CHECK_NOT_NULL(format);
+  VELOX_USER_CHECK_GE(
+      strlen(format),
+      3,
+      "The arrow format string of time should contain 'tt' and unit char.");
+  VELOX_USER_CHECK_EQ(format[0], 't', "The first character should be 't'.");
+  VELOX_USER_CHECK_EQ(format[1], 't', "The second character should be 't'.");
+  switch (format[2]) {
+    case 's':
+      return TimeUnit::kSecond;
+    case 'm':
+      return TimeUnit::kMilli;
+    case 'u':
+      return TimeUnit::kMicro;
+    case 'n':
+      return TimeUnit::kNano;
+    default:
+      VELOX_UNREACHABLE();
+  }
+}
+
 TimestampUnit getTimestampUnit(const ArrowSchema& arrowSchema) {
   const char* format = arrowSchema.dictionary ? arrowSchema.dictionary->format
                                               : arrowSchema.format;
@@ -1831,6 +1971,126 @@ void setTimestamps(
   }
 }
 
+// Create TIME vector from Arrow time32 or time64 data.
+template <typename TArrowTime>
+VectorPtr createTimeVectorFromArrow(
+    memory::MemoryPool* pool,
+    const TypePtr& type,
+    TimeUnit unit,
+    BufferPtr nulls,
+    const TArrowTime* input,
+    vector_size_t length,
+    int64_t nullCount) {
+  BufferPtr times = AlignedBuffer::allocate<int64_t>(length, pool);
+  auto* rawTimes = times->asMutable<int64_t>();
+
+  // Convert from Arrow time unit to Velox TIME (int64_t milliseconds).
+  if (nulls == nullptr) {
+    switch (unit) {
+      case TimeUnit::kSecond:
+        for (auto i = 0; i < length; ++i) {
+          rawTimes[i] = static_cast<int64_t>(input[i]) *
+              1'000; // seconds to milliseconds.
+        }
+        break;
+      case TimeUnit::kMilli:
+        for (auto i = 0; i < length; ++i) {
+          rawTimes[i] =
+              static_cast<int64_t>(input[i]); // already in milliseconds.
+        }
+        break;
+      case TimeUnit::kMicro:
+        for (auto i = 0; i < length; ++i) {
+          rawTimes[i] = static_cast<int64_t>(input[i]) /
+              1'000; // microseconds to milliseconds.
+        }
+        break;
+      case TimeUnit::kNano:
+        for (auto i = 0; i < length; ++i) {
+          rawTimes[i] = static_cast<int64_t>(input[i]) /
+              1'000'000; // nanoseconds to milliseconds.
+        }
+        break;
+      default:
+        VELOX_UNREACHABLE();
+    }
+  } else if (length > nullCount) {
+    const auto* rawNulls = nulls->as<const uint64_t>();
+    switch (unit) {
+      case TimeUnit::kSecond:
+        for (auto i = 0; i < length; ++i) {
+          if (!bits::isBitNull(rawNulls, i)) {
+            rawTimes[i] = static_cast<int64_t>(input[i]) * 1'000;
+          }
+        }
+        break;
+      case TimeUnit::kMilli:
+        for (auto i = 0; i < length; ++i) {
+          if (!bits::isBitNull(rawNulls, i)) {
+            rawTimes[i] = static_cast<int64_t>(input[i]);
+          }
+        }
+        break;
+      case TimeUnit::kMicro:
+        for (auto i = 0; i < length; ++i) {
+          if (!bits::isBitNull(rawNulls, i)) {
+            rawTimes[i] = static_cast<int64_t>(input[i]) / 1'000;
+          }
+        }
+        break;
+      case TimeUnit::kNano:
+        for (auto i = 0; i < length; ++i) {
+          if (!bits::isBitNull(rawNulls, i)) {
+            rawTimes[i] = static_cast<int64_t>(input[i]) / 1'000'000;
+          }
+        }
+        break;
+      default:
+        VELOX_UNREACHABLE();
+    }
+  }
+
+  return std::make_shared<FlatVector<int64_t>>(
+      pool,
+      type,
+      std::move(nulls),
+      length,
+      times,
+      std::vector<BufferPtr>(),
+      SimpleVectorStats<int64_t>{},
+      std::nullopt,
+      optionalNullCount(nullCount));
+}
+
+VectorPtr createTimeVector(
+    memory::MemoryPool* pool,
+    const TypePtr& type,
+    TimeUnit unit,
+    BufferPtr nulls,
+    const void* input,
+    vector_size_t length,
+    int64_t nullCount,
+    bool isTime32) {
+  if (isTime32) {
+    return createTimeVectorFromArrow<int32_t>(
+        pool,
+        type,
+        unit,
+        nulls,
+        static_cast<const int32_t*>(input),
+        length,
+        nullCount);
+  }
+  return createTimeVectorFromArrow<int64_t>(
+      pool,
+      type,
+      unit,
+      nulls,
+      static_cast<const int64_t*>(input),
+      length,
+      nullCount);
+}
+
 VectorPtr createTimestampVector(
     memory::MemoryPool* pool,
     const TypePtr& type,
@@ -1859,6 +2119,23 @@ VectorPtr createTimestampVector(
 }
 
 VectorPtr createShortDecimalVector(
+    memory::MemoryPool* pool,
+    const TypePtr& type,
+    BufferPtr nulls,
+    const int64_t* input,
+    vector_size_t length,
+    int64_t nullCount,
+    WrapInBufferViewFunc wrapInBufferView) {
+  return createFlatVector<TypeKind::BIGINT>(
+      pool,
+      type,
+      std::move(nulls),
+      length,
+      wrapInBufferView(input, length * type->cppSizeInBytes()),
+      nullCount);
+}
+
+VectorPtr createShortDecimalVectorFromLongDecimals(
     memory::MemoryPool* pool,
     const TypePtr& type,
     BufferPtr nulls,
@@ -2002,8 +2279,41 @@ VectorPtr importFromArrowImpl(
         static_cast<const int64_t*>(arrowArray.buffers[1]),
         arrowArray.length,
         arrowArray.null_count);
+  } else if (type->isTime()) {
+    VELOX_DCHECK(type->equivalent(*TIME()));
+    auto timeUnit = getTimeUnit(arrowSchema);
+    bool isTime32 =
+        (timeUnit == TimeUnit::kSecond || timeUnit == TimeUnit::kMilli);
+    return createTimeVector(
+        pool,
+        type,
+        timeUnit,
+        nulls,
+        arrowArray.buffers[1],
+        arrowArray.length,
+        arrowArray.null_count,
+        isTime32);
   } else if (type->isShortDecimal()) {
-    return createShortDecimalVector(
+    // Validate the format bitWidth.
+    const auto bitWidth = parseDecimalBitWidthOrDefault(arrowSchema.format);
+    if (bitWidth == 64) {
+      return createShortDecimalVector(
+          pool,
+          type,
+          nulls,
+          static_cast<const int64_t*>(arrowArray.buffers[1]),
+          arrowArray.length,
+          arrowArray.null_count,
+          wrapInBufferView);
+    }
+    // Otherwise convert to 128.
+    VELOX_USER_CHECK_EQ(
+        bitWidth,
+        128,
+        "Unsupported decimal bitWidth {} for '{}'",
+        bitWidth,
+        arrowSchema.format);
+    return createShortDecimalVectorFromLongDecimals(
         pool,
         type,
         nulls,
@@ -2011,6 +2321,14 @@ VectorPtr importFromArrowImpl(
         arrowArray.length,
         arrowArray.null_count);
   } else if (type->isLongDecimal()) {
+    // Validate that the format is actually 128.
+    const int32_t bitWidth = parseDecimalBitWidthOrDefault(arrowSchema.format);
+    VELOX_USER_CHECK_EQ(
+        bitWidth,
+        128,
+        "Unsupported decimal bitWidth {} for '{}'",
+        bitWidth,
+        arrowSchema.format);
     return createLongDecimalVector(
         pool,
         type,
diff --git a/velox/vector/arrow/Bridge.h b/velox/vector/arrow/Bridge.h
index eff8b8ee586..278d82d0122 100644
--- a/velox/vector/arrow/Bridge.h
+++ b/velox/vector/arrow/Bridge.h
@@ -40,6 +40,13 @@ struct ArrowOptions {
   std::optional<std::string> timestampTimeZone{std::nullopt};
   // Export VARCHAR and VARBINARY to Arrow 15 StringView format
   bool exportToStringView = false;
+  // Export VARBINARY as UTF-8 string (for consumers that lack binary support).
+  bool exportVarbinaryAsString = false;
+  /// Respect the width component of decimal type format string on export.
+  /// Default to false for now until Arrow 18 upgrade is completed and Parquet
+  /// reader/writer code is adapted to support Decimal64. CUDF I/O sets this to
+  /// true as it uses NanoArrow 0.7.0 which already supports Decimal64.
+  bool useDecimalTypeWidth = false;
 };
 
 namespace facebook::velox {
diff --git a/velox/vector/arrow/CMakeLists.txt b/velox/vector/arrow/CMakeLists.txt
index e479a28fe2d..40162a0535a 100644
--- a/velox/vector/arrow/CMakeLists.txt
+++ b/velox/vector/arrow/CMakeLists.txt
@@ -11,7 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-velox_add_library(velox_arrow_bridge Bridge.cpp)
+velox_add_library(velox_arrow_bridge Bridge.cpp HEADERS Abi.h Bridge.h)
 
 velox_link_libraries(velox_arrow_bridge velox_memory velox_type velox_buffer velox_exception)
 
diff --git a/velox/vector/arrow/tests/ArrowBridgeArrayTest.cpp b/velox/vector/arrow/tests/ArrowBridgeArrayTest.cpp
index 7f3b975fd28..a469a163861 100644
--- a/velox/vector/arrow/tests/ArrowBridgeArrayTest.cpp
+++ b/velox/vector/arrow/tests/ArrowBridgeArrayTest.cpp
@@ -21,6 +21,7 @@
 #include <gtest/gtest.h>
 
 #include "velox/common/base/Nulls.h"
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/core/QueryCtx.h"
 #include "velox/vector/arrow/Bridge.h"
 #include "velox/vector/tests/utils/VectorMaker.h"
@@ -113,6 +114,7 @@ class ArrowBridgeArrayExportTest : public testing::Test {
       const ArrowArray& arrowArray) {
     const bool isString =
         std::is_same_v<T, StringView> or std::is_same_v<T, std::string>;
+    const bool isUnknownType = std::is_same_v<T, UnknownValue>;
 
     EXPECT_EQ(inputData.size(), arrowArray.length);
     EXPECT_EQ(0, arrowArray.offset);
@@ -127,11 +129,17 @@ class ArrowBridgeArrayExportTest : public testing::Test {
     // Validate array contents.
     if constexpr (isString) {
       validateStringArray(inputData, arrowArray);
+    } else if constexpr (isUnknownType) {
+      validateNullArray(arrowArray);
     } else {
       validateNumericalArray(inputData, arrowArray);
     }
   }
 
+  void validateNullArray(const ArrowArray& arrowArray) {
+    ASSERT_EQ(0, arrowArray.n_buffers);
+  }
+
   template <typename T>
   void validateNumericalArray(
       const std::vector<std::optional<T>>& inputData,
@@ -231,6 +239,7 @@ class ArrowBridgeArrayExportTest : public testing::Test {
       const ArrowArray& arrowArray) {
     const bool isString =
         std::is_same_v<T, StringView> or std::is_same_v<T, std::string>;
+    const bool isUnknownType = std::is_same_v<T, UnknownValue>;
 
     EXPECT_EQ(inputData.size(), arrowArray.length);
     EXPECT_EQ(0, arrowArray.offset);
@@ -266,6 +275,8 @@ class ArrowBridgeArrayExportTest : public testing::Test {
 
     if constexpr (isString) {
       validateStringArray(flattenedData, *childArray);
+    } else if constexpr (isUnknownType) {
+      validateNullArray(*childArray);
     } else {
       validateNumericalArray(flattenedData, *childArray);
     }
@@ -547,6 +558,48 @@ TEST_F(ArrowBridgeArrayExportTest, flatTimestamp) {
       VeloxUserError);
 }
 
+TEST_F(ArrowBridgeArrayExportTest, flatTime) {
+  std::vector<std::optional<int64_t>> inputData = {
+      0L,
+      std::nullopt,
+      1'000L,
+      60'000L,
+      3'600'000L,
+      std::nullopt,
+      50'402'000L,
+      86'399'999L,
+      std::nullopt};
+
+  auto flatVector = vectorMaker_.flatVectorNullable(inputData, TIME());
+  ArrowArray arrowArray;
+  ArrowSchema arrowSchema;
+  velox::exportToArrow(flatVector, arrowArray, pool_.get(), options_);
+  velox::exportToArrow(flatVector, arrowSchema, options_);
+
+  EXPECT_STREQ(arrowSchema.format, "ttm"); // time32 milliseconds.
+  EXPECT_EQ(arrowArray.length, inputData.size());
+  EXPECT_EQ(arrowArray.n_buffers, 2);
+
+  const uint64_t* nulls = static_cast<const uint64_t*>(arrowArray.buffers[0]);
+  const int32_t* values = static_cast<const int32_t*>(arrowArray.buffers[1]);
+
+  ASSERT_NE(nulls, nullptr);
+
+  for (auto i = 0; i < inputData.size(); ++i) {
+    if (inputData[i] == std::nullopt) {
+      EXPECT_TRUE(bits::isBitNull(nulls, i));
+    } else {
+      EXPECT_FALSE(bits::isBitNull(nulls, i));
+      // Velox milliseconds exported as Arrow time32 milliseconds (int32).
+      EXPECT_EQ(static_cast<int32_t>(inputData[i].value()), values[i])
+          << "mismatch at index " << i;
+    }
+  }
+
+  arrowArray.release(&arrowArray);
+  arrowSchema.release(&arrowSchema);
+}
+
 TEST_F(ArrowBridgeArrayExportTest, flatString) {
   testFlatVector<std::string>({
       "my string",
@@ -1007,6 +1060,13 @@ TEST_F(ArrowBridgeArrayExportTest, dictionaryNested) {
   EXPECT_EQ(values.Value(2), 3);
 }
 
+TEST_F(ArrowBridgeArrayExportTest, unknownType) {
+  VectorPtr vector =
+      BaseVector::createNullConstant(UNKNOWN(), 2048, pool_.get());
+  testConstantVector<true, UnknownValue>(
+      vector, std::vector<std::optional<UnknownValue>>{std::nullopt});
+}
+
 TEST_F(ArrowBridgeArrayExportTest, constants) {
   testConstant((int64_t)987654321);
   testConstant((int32_t)1234);
@@ -1203,6 +1263,18 @@ class ArrowBridgeArrayImportTest : public ArrowBridgeArrayExportTest {
         std::is_same_v<TInput, int128_t> && std::is_same_v<TOutput, int64_t>) {
       assertShortDecimalVectorContent(
           inputValues, output, arrowArray.null_count);
+    } else if constexpr (
+        std::is_same_v<TOutput, int64_t> &&
+        (std::is_same_v<TInput, int32_t> || std::is_same_v<TInput, int64_t>)) {
+      // TIME: Arrow time32 (int32) or time64 (int64) to Velox TIME (int64
+      // millis) Check if format starts with "tt" to distinguish from regular
+      // int32/int64.
+      if (format[0] == 't' && format[1] == 't') {
+        assertTimeVectorContent(
+            inputValues, output, arrowArray.null_count, format);
+      } else {
+        assertVectorContent(inputValues, output, arrowArray.null_count);
+      }
     } else {
       assertVectorContent(inputValues, output, arrowArray.null_count);
     }
@@ -1287,6 +1359,29 @@ class ArrowBridgeArrayImportTest : public ArrowBridgeArrayExportTest {
           tsString, {0, std::nullopt, Timestamp::kMaxSeconds});
     }
 
+    testArrowImport<int64_t, int32_t>(
+        "tts", {0, std::nullopt, 1, 60, 3600, 50402, 86399});
+    testArrowImport<int64_t, int32_t>(
+        "ttm", {0, std::nullopt, 1000, 60000, 3600000, 50402000, 86399999});
+    testArrowImport<int64_t, int64_t>(
+        "ttu",
+        {0,
+         std::nullopt,
+         1'000'000,
+         60'000'000,
+         3'600'000'000,
+         50'402'000'000,
+         86'399'999'000});
+    testArrowImport<int64_t, int64_t>(
+        "ttn",
+        {0,
+         std::nullopt,
+         1'000'000'000,
+         60'000'000'000,
+         3'600'000'000'000,
+         50'402'000'000'000,
+         86'399'999'000'000});
+
     testArrowImport<int64_t, int128_t>(
         "d:5,2", {1, -1, 0, 12345, -12345, std::nullopt});
     testArrowImport<int128_t, int128_t>(
@@ -1323,6 +1418,17 @@ class ArrowBridgeArrayImportTest : public ArrowBridgeArrayExportTest {
         std::is_same_v<TInput, int64_t> && std::is_same_v<TOutput, Timestamp>) {
       assertTimestampVectorContent(
           inputValues, output, arrowArray1.null_count, format);
+    } else if constexpr (
+        std::is_same_v<TOutput, int64_t> &&
+        (std::is_same_v<TInput, int32_t> || std::is_same_v<TInput, int64_t>)) {
+      // TIME: Arrow time32 (int32) or time64 (int64) to Velox TIME (int64
+      // millis).
+      if (format[0] == 't' && format[1] == 't') {
+        assertTimeVectorContent(
+            inputValues, output, arrowArray1.null_count, format);
+      } else {
+        assertVectorContent(inputValues, output, arrowArray1.null_count);
+      }
     } else {
       assertVectorContent(inputValues, output, arrowArray1.null_count);
     }
@@ -1426,6 +1532,47 @@ class ArrowBridgeArrayImportTest : public ArrowBridgeArrayExportTest {
     assertVectorContent(decValues, actual, nullCount);
   }
 
+  // Creates TIME from int32/int64 and asserts the content of actual vector with
+  // the expected TIME values (in milliseconds).
+  template <typename TInput>
+  void assertTimeVectorContent(
+      const std::vector<std::optional<TInput>>& expectedValues,
+      const VectorPtr& actual,
+      size_t nullCount,
+      const char* format) {
+    VELOX_USER_CHECK_GE(
+        strlen(format), 3, "At least three characters are expected.");
+    std::vector<std::optional<int64_t>> timeValues;
+    timeValues.reserve(expectedValues.size());
+    for (const auto& value : expectedValues) {
+      if (!value.has_value()) {
+        timeValues.emplace_back(std::nullopt);
+      } else {
+        int64_t millis;
+        // Convert from Arrow time unit to Velox TIME (milliseconds).
+        switch (format[2]) {
+          case 's':
+            millis = static_cast<int64_t>(value.value()) * 1'000;
+            break;
+          case 'm':
+            millis = static_cast<int64_t>(value.value());
+            break;
+          case 'u':
+            millis = static_cast<int64_t>(value.value()) / 1'000;
+            break;
+          case 'n':
+            millis = static_cast<int64_t>(value.value()) / 1'000'000;
+            break;
+          default:
+            VELOX_UNREACHABLE();
+        }
+        timeValues.emplace_back(millis);
+      }
+    }
+    auto expected = vectorMaker_.flatVectorNullable(timeValues, TIME());
+    assertVectorContent(timeValues, actual, nullCount);
+  }
+
   // Creates timestamp from bigint and asserts the content of actual vector with
   // the expected timestamp values.
   void assertTimestampVectorContent(
@@ -1919,6 +2066,51 @@ TEST_F(ArrowBridgeArrayImportAsViewerTest, failures) {
   testImportFailures();
 }
 
+// Verify that importing a Utf8View array with an out-of-bounds buffer index
+// in a non-inline string view throws instead of reading past the buffers
+// array.
+TEST_F(ArrowBridgeArrayImportAsViewerTest, utf8ViewOobBufferIndex) {
+  // Arrow Utf8View layout (format "vu"):
+  //   buffer[0] = nulls
+  //   buffer[1] = views (16 bytes each)
+  //   buffer[2 .. n_buffers-2] = data buffers
+  //   buffer[n_buffers-1] = buffer sizes (uint64_t per data buffer)
+  //
+  // We set up one data buffer (index 2) and one sizes buffer (index 3), so
+  // n_buffers = 4 and the only valid data-buffer index is 0.  The crafted
+  // view references buffer index 99 — well out of range.
+
+  const char dataBuffer[] = "some data string";
+  const uint64_t bufferSizesArr[] = {sizeof(dataBuffer)};
+
+  // Arrow Utf8View: [4B length][4B prefix][4B buffer_index][4B buffer_offset]
+  struct Utf8ViewEntry {
+    uint32_t length;
+    char prefix[4];
+    uint32_t bufferIndex;
+    uint32_t bufferOffset;
+  };
+  Utf8ViewEntry malformedView{};
+  malformedView.length = 16; // > 12, so non-inline.
+  std::memcpy(malformedView.prefix, "some", 4);
+  malformedView.bufferIndex = 99; // Out of bounds.
+  malformedView.bufferOffset = 0;
+
+  const void* buffers[] = {
+      nullptr, // nulls
+      &malformedView, // views
+      dataBuffer, // data buffer 0
+      bufferSizesArr, // buffer sizes
+  };
+
+  auto arrowSchema = makeArrowSchema("vu");
+  auto arrowArray = makeArrowArray(buffers, 4, 1, 0);
+
+  VELOX_ASSERT_THROW(
+      importFromArrowAsViewer(arrowSchema, arrowArray, pool_.get()),
+      "Arrow Utf8View buffer index out of range");
+}
+
 class ArrowBridgeArrayImportAsOwnerTest
     : public ArrowBridgeArrayImportAsViewerTest {
   bool isViewer() const override {
@@ -2020,7 +2212,9 @@ TEST_F(ArrowBridgeArrayImportAsOwnerTest, releaseCalled) {
 
   // Create a Velox Vector from Arrow and then destruct it to trigger the
   // release callback calling
-  { auto _ = importFromArrowAsOwner(arrowSchema, arrowArray, pool_.get()); }
+  {
+    auto _ = importFromArrowAsOwner(arrowSchema, arrowArray, pool_.get());
+  }
 
   EXPECT_TRUE(TestReleaseCalled::schemaReleaseCalled);
   EXPECT_TRUE(TestReleaseCalled::arrayReleaseCalled);
diff --git a/velox/vector/arrow/tests/ArrowBridgeSchemaTest.cpp b/velox/vector/arrow/tests/ArrowBridgeSchemaTest.cpp
index 1b37010b829..5662a9d65c6 100644
--- a/velox/vector/arrow/tests/ArrowBridgeSchemaTest.cpp
+++ b/velox/vector/arrow/tests/ArrowBridgeSchemaTest.cpp
@@ -240,6 +240,13 @@ TEST_F(ArrowBridgeSchemaExportTest, scalar) {
   testScalarType(DECIMAL(10, 4), "d:10,4");
   testScalarType(DECIMAL(20, 15), "d:20,15");
 
+#if ARROW_VERSION_MAJOR >= 18
+  testScalarType(DECIMAL(10, 4), "d:10,4,64", {.useDecimalTypeWidth = true});
+#else
+  testScalarType(DECIMAL(10, 4), "d:10,4,128", {.useDecimalTypeWidth = true});
+#endif
+  testScalarType(DECIMAL(20, 15), "d:20,15,128", {.useDecimalTypeWidth = true});
+
   testScalarType(UNKNOWN(), "n");
 }
 
@@ -427,10 +434,11 @@ TEST_F(ArrowBridgeSchemaImportTest, scalar) {
   VELOX_ASSERT_THROW(
       *testSchemaImport("d2,15"),
       "Unable to convert 'd2,15' ArrowSchema decimal format to Velox decimal");
-  EXPECT_EQ(*DECIMAL(10, 4), *testSchemaImport("d:10,4,128"));
+  EXPECT_EQ(*DECIMAL(10, 4), *testSchemaImport("d:10,4,64"));
+  EXPECT_EQ(*DECIMAL(20, 15), *testSchemaImport("d:20,15,128"));
   VELOX_ASSERT_THROW(
       *testSchemaImport("d:10,4,256"),
-      "Conversion failed for 'd:10,4,256'. Velox decimal does not support custom bitwidth.");
+      "Conversion failed for 'd:10,4,256'. Only 64-bit and 128-bit decimal types are supported.");
   VELOX_ASSERT_THROW(
       *testSchemaImport("d:10,4,"),
       "Unable to convert 'd:10,4,' ArrowSchema decimal format to Velox decimal");
@@ -487,8 +495,6 @@ TEST_F(ArrowBridgeSchemaImportTest, unsupported) {
   EXPECT_THROW(testSchemaImport("w:42"), VeloxUserError);
 
   EXPECT_THROW(testSchemaImport("tdm"), VeloxUserError);
-  EXPECT_THROW(testSchemaImport("tts"), VeloxUserError);
-  EXPECT_THROW(testSchemaImport("ttm"), VeloxUserError);
   EXPECT_THROW(testSchemaImport("tDs"), VeloxUserError);
 
   EXPECT_THROW(testSchemaImport("+"), VeloxUserError);
@@ -553,6 +559,7 @@ TEST_F(ArrowBridgeSchemaTest, validateInArrow) {
       {VARCHAR(), arrow::utf8()},
       {VARCHAR(), arrow::utf8_view()},
 #if ARROW_VERSION_MAJOR >= 18
+      // Type arrow::decimal is deprecated, use arrow::decimal128.
       {DECIMAL(10, 4), arrow::decimal128(10, 4)},
       {DECIMAL(20, 15), arrow::decimal128(20, 15)},
 #else
diff --git a/velox/vector/fuzzer/CMakeLists.txt b/velox/vector/fuzzer/CMakeLists.txt
index 4fd8c4afcab..f581e34b9e3 100644
--- a/velox/vector/fuzzer/CMakeLists.txt
+++ b/velox/vector/fuzzer/CMakeLists.txt
@@ -13,10 +13,12 @@
 # limitations under the License.
 
 add_library(velox_vector_fuzzer_util Utils.cpp)
+velox_add_test_headers(velox_vector_fuzzer_util Utils.h)
 
 target_link_libraries(velox_vector_fuzzer_util velox_vector velox_common_fuzzer_util)
 
 add_library(velox_vector_fuzzer GeneratorSpec.cpp VectorFuzzer.cpp)
+velox_add_test_headers(velox_vector_fuzzer GeneratorSpec.h VectorFuzzer.h)
 
 target_link_libraries(
   velox_vector_fuzzer
@@ -33,6 +35,7 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
 endif()
 
 add_library(velox_constrained_vector_generator ConstrainedVectorGenerator.cpp)
+velox_add_test_headers(velox_constrained_vector_generator ConstrainedVectorGenerator.h)
 
 target_link_libraries(
   velox_constrained_vector_generator
@@ -43,5 +46,6 @@ target_link_libraries(
 )
 
 if(${VELOX_BUILD_TESTING})
+  add_subdirectory(examples)
   add_subdirectory(tests)
 endif()
diff --git a/velox/vector/fuzzer/VectorFuzzer.cpp b/velox/vector/fuzzer/VectorFuzzer.cpp
index 321cd82064e..fcbc51a8210 100644
--- a/velox/vector/fuzzer/VectorFuzzer.cpp
+++ b/velox/vector/fuzzer/VectorFuzzer.cpp
@@ -39,6 +39,7 @@ namespace {
 
 using fuzzer::rand;
 using fuzzer::randDate;
+using fuzzer::randTime;
 
 // Structure to help temporary changes to Options. This objects saves the
 // current state of the Options object, and restores it when it's destructed.
@@ -139,6 +140,10 @@ VectorPtr fuzzConstantPrimitiveImpl(
   } else if (type->isLongDecimal()) {
     return std::make_shared<ConstantVector<int128_t>>(
         pool, size, false, type, randLongDecimal(type, rng));
+  } else if (type->isTime()) {
+    VELOX_DCHECK(type->equivalent(*TIME()));
+    return std::make_shared<ConstantVector<int64_t>>(
+        pool, size, false, type, randTime(rng));
   } else {
     return std::make_shared<ConstantVector<TCpp>>(
         pool, size, false, type, rand<TCpp>(rng, opts.dataSpec));
@@ -172,6 +177,9 @@ void fuzzFlatPrimitiveImpl(
                 VectorFuzzer::kMaxAllowedIntervalDayTime));
       } else if (vector->type()->isShortDecimal()) {
         flatVector->set(i, randShortDecimal(vector->type(), rng));
+      } else if (vector->type()->isTime()) {
+        VELOX_DCHECK(vector->type()->equivalent(*TIME()));
+        flatVector->set(i, randTime(rng));
       } else {
         flatVector->set(i, rand<TCpp>(rng, opts.dataSpec));
       }
@@ -202,6 +210,51 @@ void fuzzFlatPrimitiveImpl(
   }
 }
 
+bool containsFlatMapVector(const BaseVector* vector) {
+  if (!vector) {
+    return false;
+  }
+
+  // Unwrap any dictionary/constant encoding to get to the base.
+  while (VectorEncoding::isDictionary(vector->encoding()) ||
+         vector->encoding() == VectorEncoding::Simple::CONSTANT) {
+    vector = vector->valueVector().get();
+    if (!vector) {
+      return false;
+    }
+  }
+
+  if (vector->encoding() == VectorEncoding::Simple::FLAT_MAP) {
+    return true;
+  }
+
+  // Check children for complex types.
+  switch (vector->encoding()) {
+    case VectorEncoding::Simple::ROW: {
+      auto* row = vector->asUnchecked<RowVector>();
+      for (const auto& child : row->children()) {
+        if (containsFlatMapVector(child.get())) {
+          return true;
+        }
+      }
+      break;
+    }
+    case VectorEncoding::Simple::ARRAY: {
+      auto* array = vector->asUnchecked<ArrayVector>();
+      return containsFlatMapVector(array->elements().get());
+    }
+    case VectorEncoding::Simple::MAP: {
+      auto* map = vector->asUnchecked<MapVector>();
+      return containsFlatMapVector(map->mapKeys().get()) ||
+          containsFlatMapVector(map->mapValues().get());
+    }
+    default:
+      break;
+  }
+
+  return false;
+}
+
 // Servers as a wrapper around a vector that will be used to load a lazyVector.
 // Ensures that the loaded vector will only contain valid rows for the row set
 // that it was loaded for. NOTE: If the vector is a multi-level dictionary, the
@@ -388,7 +441,7 @@ VectorPtr VectorFuzzer::fuzzConstant(
     if (coinToss(opts_.nullRatio)) {
       return BaseVector::createNullConstant(type, size, pool_);
     }
-    if (type->isUnKnown()) {
+    if (type->isUnknown()) {
       return BaseVector::createNullConstant(type, size, pool_);
     } else {
       return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
@@ -527,7 +580,7 @@ VectorPtr VectorFuzzer::fuzzFlatPrimitive(
   VELOX_CHECK(type->isPrimitiveType());
   auto vector = BaseVector::create(type, size, pool_);
 
-  if (type->isUnKnown()) {
+  if (type->isUnknown()) {
     auto* rawNulls = vector->mutableRawNulls();
     bits::fillBits(rawNulls, 0, size, bits::kNull);
   } else {
@@ -537,11 +590,10 @@ VectorPtr VectorFuzzer::fuzzFlatPrimitive(
     VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
         fuzzFlatPrimitiveImpl, kind, vector, rng_, opts_);
 
-    // Second, generate a random null vector.
-    for (size_t i = 0; i < vector->size(); ++i) {
-      if (coinToss(opts_.nullRatio)) {
-        vector->setNull(i, true);
-      }
+    // Second, generate nulls using the configured null pattern.
+    auto nulls = fuzzNulls(size);
+    if (nulls) {
+      vector->setNulls(nulls);
     }
   }
   return vector;
@@ -870,11 +922,71 @@ RowVectorPtr VectorFuzzer::fuzzRow(
 
 BufferPtr VectorFuzzer::fuzzNulls(vector_size_t size) {
   NullsBuilder builder{size, pool_};
-  for (size_t i = 0; i < size; ++i) {
-    if (coinToss(opts_.nullRatio)) {
-      builder.setNull(i);
+
+  // Randomly select a pattern with weighted distribution:
+  // 70% kRandom, 30% split equally among kHeadOnly, kTailOnly, kHeadAndTail
+  // (each gets 10%)
+
+  // default to kRandom pattern
+  int patternChoice = 0;
+
+  if (opts_.useRandomNullPattern) {
+    auto randValue = fuzzer::rand<uint32_t>(rng_) % 100;
+    if (randValue < 70) {
+      patternChoice = 0; // kRandom - 70%
+    } else if (randValue < 80) {
+      patternChoice = 1; // kHeadOnly - 10%
+    } else if (randValue < 90) {
+      patternChoice = 2; // kTailOnly - 10%
+    } else {
+      patternChoice = 3; // kHeadAndTail - 10%
     }
   }
+
+  switch (patternChoice) {
+    case 0: // kRandom pattern
+      for (size_t i = 0; i < size; ++i) {
+        if (coinToss(opts_.nullRatio)) {
+          builder.setNull(i);
+        }
+      }
+      break;
+
+    case 1: { // kHeadOnly pattern
+      auto headNulls =
+          std::min<size_t>(static_cast<size_t>(size * opts_.nullRatio), size);
+      for (size_t i = 0; i < headNulls; ++i) {
+        builder.setNull(i);
+      }
+      break;
+    }
+
+    case 2: { // kTailOnly pattern
+      auto tailNulls =
+          std::min<size_t>(static_cast<size_t>(size * opts_.nullRatio), size);
+      auto startIdx = size > tailNulls ? size - tailNulls : 0;
+      for (size_t i = startIdx; i < size; ++i) {
+        builder.setNull(i);
+      }
+      break;
+    }
+
+    case 3: { // kHeadAndTail pattern
+      // Split nullRatio between head and tail to match total nulls of other
+      // patterns
+      auto edgeNulls = std::min<size_t>(
+          static_cast<size_t>(size * opts_.nullRatio / 2.0), size / 2);
+      for (size_t i = 0; i < edgeNulls; ++i) {
+        builder.setNull(i);
+      }
+      auto tailStart = size > edgeNulls ? size - edgeNulls : 0;
+      for (size_t i = tailStart; i < size; ++i) {
+        builder.setNull(i);
+      }
+      break;
+    }
+  }
+
   return builder.build();
 }
 
@@ -1098,6 +1210,12 @@ VectorPtr VectorLoaderWrap::makeEncodingPreservedCopy(
   DecodedVector decoded;
   decoded.decode(*vector_, rows, false);
 
+  // FlatMapVector copy into MapVector vector is not supported. Let's preserve
+  // encodings to avoid runtime checks.
+  if (containsFlatMapVector(decoded.base())) {
+    return vector_->testingCopyPreserveEncodings(vector_->pool());
+  }
+
   if (decoded.isConstantMapping() || decoded.isIdentityMapping()) {
     VectorPtr result;
     BaseVector::ensureWritable(rows, vector_->type(), vector_->pool(), result);
@@ -1165,6 +1283,7 @@ const std::vector<TypePtr>& defaultScalarTypes() {
       VARBINARY(),
       TIMESTAMP(),
       DATE(),
+      TIME(),
       INTERVAL_DAY_TIME(),
   };
   return kScalarTypes;
diff --git a/velox/vector/fuzzer/VectorFuzzer.h b/velox/vector/fuzzer/VectorFuzzer.h
index ed13edb6a20..c1557fe0017 100644
--- a/velox/vector/fuzzer/VectorFuzzer.h
+++ b/velox/vector/fuzzer/VectorFuzzer.h
@@ -79,10 +79,22 @@ class VectorFuzzer {
   struct Options {
     size_t vectorSize{100};
 
-    /// Chance of generating a null value in the output vector (`nullRatio` is a
-    /// double between 0 and 1).
+    /// Controls NULL generation in vectors. This is a probability (0.0-1.0)
+    /// or fraction used by NULL patterns:
+    /// - When useRandomNullPattern=false (default): Uses kRandom pattern only
+    ///   - nullRatio is the probability that each element is NULL
+    /// - When useRandomNullPattern=true: Randomly selects pattern, then:
+    ///   - Random (70%): Probability that each element is NULL
+    ///   - HeadOnly (10%): Fraction of vector that's NULL at beginning
+    ///   - TailOnly (10%): Fraction of vector that's NULL at end
+    ///   - HeadAndTail (10%): Half the fraction at head, half at tail
     double nullRatio{0};
 
+    /// If true, randomly selects NULL patterns (kRandom 70%, kHeadOnly 10%,
+    /// kTailOnly 10%, kHeadAndTail 10%). If false, uses only kRandom pattern.
+    /// Default is false to preserve backward compatibility.
+    bool useRandomNullPattern{false};
+
     /// If false, fuzzer will not generate nulls for elements within containers
     /// (arrays/maps/rows). It might still generate null for the container
     /// itself.
@@ -171,15 +183,13 @@ class VectorFuzzer {
       const VectorFuzzer::Options& options,
       memory::MemoryPool* pool,
       size_t seed = 123456)
-      : opts_(options),
-        pool_(pool),
-        rng_(seed){}
+      : opts_(options), pool_(pool), rng_(seed) {}
 #if defined(__GNUC__) && \
     ((__GNUC__ > 12) || (__GNUC__ == 12 && __GNUC_MINOR__ >= 4))
-        VELOX_UNSUPPRESS_STRINGOP_OVERFLOW_WARNING
+  VELOX_UNSUPPRESS_STRINGOP_OVERFLOW_WARNING
 #endif
 
-        void setOptions(const VectorFuzzer::Options& options) {
+  void setOptions(const VectorFuzzer::Options& options) {
     opts_ = options;
   }
 
diff --git a/velox/vector/fuzzer/examples/CMakeLists.txt b/velox/vector/fuzzer/examples/CMakeLists.txt
new file mode 100644
index 00000000000..816a57f1e48
--- /dev/null
+++ b/velox/vector/fuzzer/examples/CMakeLists.txt
@@ -0,0 +1,15 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+velox_add_library(velox_vector_fuzzer_examples_utils INTERFACE HEADERS Utils.h)
diff --git a/velox/vector/fuzzer/tests/VectorFuzzerTest.cpp b/velox/vector/fuzzer/tests/VectorFuzzerTest.cpp
index 7bf44a306ae..40746ca064e 100644
--- a/velox/vector/fuzzer/tests/VectorFuzzerTest.cpp
+++ b/velox/vector/fuzzer/tests/VectorFuzzerTest.cpp
@@ -94,6 +94,16 @@ class VectorFuzzerTest : public testing::Test {
 
   void validateMaxSizes(VectorPtr vector, size_t maxSize);
 
+  void assertTimeValuesInRange(const SimpleVector<int64_t>* timeVector) {
+    for (size_t i = 0; i < timeVector->size(); ++i) {
+      if (!timeVector->isNullAt(i)) {
+        auto timeValue = timeVector->valueAt(i);
+        ASSERT_GE(timeValue, TIME()->getMin());
+        ASSERT_LE(timeValue, TIME()->getMax());
+      }
+    }
+  }
+
  private:
   std::shared_ptr<memory::MemoryPool> pool_{
       memory::memoryManager()->addLeafPool()};
@@ -113,6 +123,7 @@ TEST_F(VectorFuzzerTest, flatPrimitive) {
       VARCHAR(),
       VARBINARY(),
       DATE(),
+      TIME(),
       TIMESTAMP(),
       INTERVAL_DAY_TIME(),
       UNKNOWN(),
@@ -675,6 +686,47 @@ TEST_F(VectorFuzzerTest, timestamp) {
   ASSERT_TRUE(nanosFound);
 }
 
+TEST_F(VectorFuzzerTest, time) {
+  constexpr size_t vectorSize = 1'000;
+  VectorFuzzer::Options opts;
+  opts.vectorSize = vectorSize;
+  VectorFuzzer fuzzer(opts, pool());
+
+  // Test flat TIME vector.
+  auto timeVector = fuzzer.fuzzFlat(TIME());
+  ASSERT_EQ(VectorEncoding::Simple::FLAT, timeVector->encoding());
+  ASSERT_TRUE(timeVector->type()->equivalent(*TIME()));
+  ASSERT_EQ(vectorSize, timeVector->size());
+
+  auto flatTimeVector = timeVector->as<FlatVector<int64_t>>();
+  assertTimeValuesInRange(flatTimeVector);
+
+  // Test constant TIME vector.
+  auto constTimeVector = fuzzer.fuzzConstant(TIME(), vectorSize);
+  ASSERT_EQ(VectorEncoding::Simple::CONSTANT, constTimeVector->encoding());
+  ASSERT_TRUE(constTimeVector->type()->equivalent(*TIME()));
+  ASSERT_EQ(vectorSize, constTimeVector->size());
+
+  // Verify constant TIME value is in valid range.
+  auto constVector = constTimeVector->as<ConstantVector<int64_t>>();
+  if (!constVector->isNullAt(0)) {
+    auto timeValue = constVector->valueAt(0);
+    ASSERT_GE(timeValue, TIME()->getMin());
+    ASSERT_LE(timeValue, TIME()->getMax());
+  }
+
+  // Test dictionary TIME vector.
+  auto dictTimeVector =
+      fuzzer.fuzzDictionary(fuzzer.fuzzFlat(TIME(), 100), 500);
+  ASSERT_EQ(VectorEncoding::Simple::DICTIONARY, dictTimeVector->encoding());
+  ASSERT_TRUE(dictTimeVector->type()->equivalent(*TIME()));
+
+  // Verify all TIME values in dictionary are in valid range.
+  auto dictVector = dictTimeVector->as<DictionaryVector<int64_t>>();
+  auto baseVector = dictVector->valueVector()->as<FlatVector<int64_t>>();
+  assertTimeValuesInRange(baseVector);
+}
+
 TEST_F(VectorFuzzerTest, assorted) {
   VectorFuzzer::Options opts;
   VectorFuzzer fuzzer(opts, pool());
@@ -1036,9 +1088,9 @@ TEST_F(VectorFuzzerTest, customTypeGenerator) {
       if (decoded.isNullAt(j)) {
         continue;
       }
-      std::string value = decoded.valueAt<StringView>(j);
       try {
-        json = folly::parseJson(value, opts);
+        auto stringView = decoded.valueAt<StringView>(j);
+        json = folly::parseJson(std::string_view(stringView), opts);
       } catch (...) {
         EXPECT_TRUE(false);
       }
@@ -1078,9 +1130,10 @@ TEST_F(VectorFuzzerTest, jsonConstrained) {
       if (decoded.isNullAt(j)) {
         continue;
       }
-      std::string value = decoded.valueAt<StringView>(j);
       folly::dynamic json;
-      EXPECT_NO_THROW(json = folly::parseJson(value, jsonOpts));
+      auto stringView = decoded.valueAt<StringView>(j);
+      EXPECT_NO_THROW(
+          json = folly::parseJson(std::string_view(stringView), jsonOpts));
       EXPECT_TRUE(json.isNull() || json.isArray());
     }
   }
@@ -1098,7 +1151,7 @@ TEST_F(VectorFuzzerTest, setConstrained) {
 
   DecodedVector decoded(*vector, SelectivityVector(kSize));
   for (auto i = 0; i < kSize; ++i) {
-    std::string value = decoded.valueAt<StringView>(i);
+    auto value = decoded.valueAt<StringView>(i);
     EXPECT_TRUE(value == "a" || value == "b");
   }
 }
@@ -1137,4 +1190,66 @@ TEST_F(VectorFuzzerTest, qdigestTypeGeneration) {
     EXPECT_EQ(vector->size(), opts.vectorSize);
   }
 }
+
+TEST_F(VectorFuzzerTest, nullRatioPatternVariety) {
+  // Test that we get variety in NULL patterns when feature is enabled
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.2;
+  opts.useRandomNullPattern = true; // Enable random NULL pattern selection
+
+  VectorFuzzer fuzzer(opts, pool());
+
+  // Track different null patterns we see
+  bool seenAllAtStart = false;
+  bool seenAllAtEnd = false;
+  bool seenScattered = false;
+
+  for (size_t iter = 0; iter < 200; ++iter) {
+    auto vector = fuzzer.fuzzFlat(INTEGER());
+    ASSERT_EQ(vector->size(), 100);
+
+    size_t nullCount = 0;
+    size_t firstNull = 0;
+    size_t lastNull = 0;
+    bool foundFirst = false;
+
+    for (size_t i = 0; i < vector->size(); ++i) {
+      if (vector->isNullAt(i)) {
+        nullCount++;
+        if (!foundFirst) {
+          firstNull = i;
+          foundFirst = true;
+        }
+        lastNull = i;
+      }
+    }
+
+    if (nullCount == 0) {
+      continue; // Skip empty vectors
+    }
+
+    // Detect patterns:
+    // HeadOnly: all nulls at start (firstNull < 5)
+    if (firstNull < 5 && lastNull < nullCount + 5) {
+      seenAllAtStart = true;
+    }
+    // TailOnly: all nulls at end (firstNull > 100 - nullCount - 5)
+    if (firstNull > 100 - nullCount - 5 && lastNull > 95) {
+      seenAllAtEnd = true;
+    }
+    // Scattered (Random or HeadAndTail with gaps)
+    size_t gapSize = lastNull - firstNull - nullCount + 1;
+    if (gapSize > 10) {
+      seenScattered = true;
+    }
+  }
+
+  // We should see all different patterns across 200 iterations
+  int patternsObserved = (seenAllAtStart ? 1 : 0) + (seenAllAtEnd ? 1 : 0) +
+      (seenScattered ? 1 : 0);
+  EXPECT_EQ(patternsObserved, 3)
+      << "Expected to observe multiple NULL patterns, but only saw "
+      << patternsObserved;
+}
 } // namespace
diff --git a/velox/vector/tests/CMakeLists.txt b/velox/vector/tests/CMakeLists.txt
index 248e8be2ea0..24478b9c8e5 100644
--- a/velox/vector/tests/CMakeLists.txt
+++ b/velox/vector/tests/CMakeLists.txt
@@ -23,6 +23,7 @@ add_executable(
   FlatMapVectorTest.cpp
   IsWritableVectorTest.cpp
   LazyVectorTest.cpp
+  MapConcatTest.cpp
   MayHaveNullsRecursiveTest.cpp
   SelectivityVectorTest.cpp
   StringVectorBufferTest.cpp
@@ -33,6 +34,7 @@ add_executable(
   VectorPoolTest.cpp
   VectorPrepareForReuseTest.cpp
   VectorPrinterTest.cpp
+  VectorRetainedSizeTest.cpp
   VectorSaverTest.cpp
   VectorStreamTest.cpp
   VectorStreamGroupTest.cpp
@@ -40,6 +42,15 @@ add_executable(
   VectorTestUtils.cpp
   VectorToStringTest.cpp
 )
+velox_add_test_headers(
+  velox_vector_test
+  SimpleVectorTestHelper.h
+  TestingAlwaysThrowsFunction.h
+  TestingDictionaryArrayElementsFunction.h
+  TestingDictionaryFunction.h
+  VectorTestUtils.h
+  VectorValueGenerator.h
+)
 
 add_test(velox_vector_test velox_vector_test)
 
@@ -52,14 +63,14 @@ target_link_libraries(
   velox_serialization
   velox_presto_serializer
   velox_presto_types
-  velox_temp_path
+  velox_test_util
   velox_type_test_lib
+  velox_common_fuzzer_util
   Boost::atomic
   Boost::context
   Boost::date_time
   Boost::filesystem
   Boost::program_options
-  Boost::regex
   Boost::thread
   Boost::system
   GTest::gtest
diff --git a/velox/vector/tests/DecodedVectorTest.cpp b/velox/vector/tests/DecodedVectorTest.cpp
index 97b68c10ac2..f777de427aa 100644
--- a/velox/vector/tests/DecodedVectorTest.cpp
+++ b/velox/vector/tests/DecodedVectorTest.cpp
@@ -477,16 +477,15 @@ class DecodedVectorTest : public testing::Test, public VectorTestBase {
 
 template <>
 void DecodedVectorTest::testConstant<StringView>(const StringView& value) {
-  auto val = value.getString();
-  auto constantVector = BaseVector::createConstant(
-      VARCHAR(), folly::StringPiece{val}, 100, pool_.get());
+  auto constantVector =
+      BaseVector::createConstant(VARCHAR(), value, 100, pool_.get());
 
   auto check = [&](auto& decoded) {
     EXPECT_TRUE(decoded.isConstantMapping());
     EXPECT_FALSE(decoded.isIdentityMapping());
     for (int32_t i = 0; i < 100; i++) {
       EXPECT_FALSE(decoded.isNullAt(i));
-      EXPECT_EQ(decoded.template valueAt<StringView>(i).getString(), val);
+      EXPECT_EQ(decoded.template valueAt<StringView>(i).getString(), value);
     }
   };
 
@@ -573,6 +572,7 @@ TEST_F(DecodedVectorTest, constantNull) {
   testConstantNull(ARRAY(INTEGER()));
   testConstantNull(MAP(INTEGER(), INTEGER()));
   testConstantNull(ROW({INTEGER()}));
+  testConstantNull(ROW({}));
 }
 
 TEST_F(DecodedVectorTest, constantComplexType) {
@@ -1625,4 +1625,13 @@ TEST_F(DecodedVectorTest, toString) {
   }
 }
 
+TEST_F(DecodedVectorTest, emptyStruct) {
+  auto vector = makeRowVector(ROW({}), 1);
+  DecodedVector decoded;
+  decoded.decode(*vector);
+  EXPECT_EQ(decoded.base(), vector.get());
+  EXPECT_EQ(decoded.size(), 1);
+  EXPECT_FALSE(decoded.isNullAt(0));
+}
+
 } // namespace facebook::velox::test
diff --git a/velox/vector/tests/EncodedVectorCopyTest.cpp b/velox/vector/tests/EncodedVectorCopyTest.cpp
index f1ac7c8a4de..97edb313828 100644
--- a/velox/vector/tests/EncodedVectorCopyTest.cpp
+++ b/velox/vector/tests/EncodedVectorCopyTest.cpp
@@ -17,6 +17,7 @@
 #include "velox/vector/EncodedVectorCopy.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/testutil/RandomSeed.h"
+#include "velox/vector/FlatMapVector.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
@@ -54,8 +55,9 @@ void compareVectors(const VectorPtr& actual, const VectorPtr& expected) {
   }
   switch (actual->encoding()) {
     case VectorEncoding::Simple::DICTIONARY:
-      ASSERT_TRUE(bufferEqual<vector_size_t>(
-          *actual->wrapInfo(), *expected->wrapInfo(), actual->size()));
+      ASSERT_TRUE(
+          bufferEqual<vector_size_t>(
+              *actual->wrapInfo(), *expected->wrapInfo(), actual->size()));
       compareVectors(actual->valueVector(), expected->valueVector());
       break;
     case VectorEncoding::Simple::ROW: {
@@ -69,10 +71,14 @@ void compareVectors(const VectorPtr& actual, const VectorPtr& expected) {
     case VectorEncoding::Simple::MAP: {
       auto* actualMap = actual->asChecked<MapVector>();
       auto* expectedMap = expected->asChecked<MapVector>();
-      ASSERT_TRUE(bufferEqual<vector_size_t>(
-          *actualMap->offsets(), *expectedMap->offsets(), actualMap->size()));
-      ASSERT_TRUE(bufferEqual<vector_size_t>(
-          *actualMap->sizes(), *expectedMap->sizes(), actualMap->size()));
+      ASSERT_TRUE(
+          bufferEqual<vector_size_t>(
+              *actualMap->offsets(),
+              *expectedMap->offsets(),
+              actualMap->size()));
+      ASSERT_TRUE(
+          bufferEqual<vector_size_t>(
+              *actualMap->sizes(), *expectedMap->sizes(), actualMap->size()));
       compareVectors(actualMap->mapKeys(), expectedMap->mapKeys());
       compareVectors(actualMap->mapValues(), expectedMap->mapValues());
       break;
@@ -80,12 +86,16 @@ void compareVectors(const VectorPtr& actual, const VectorPtr& expected) {
     case VectorEncoding::Simple::ARRAY: {
       auto* actualArray = actual->asChecked<ArrayVector>();
       auto* expectedArray = expected->asChecked<ArrayVector>();
-      ASSERT_TRUE(bufferEqual<vector_size_t>(
-          *actualArray->offsets(),
-          *expectedArray->offsets(),
-          actualArray->size()));
-      ASSERT_TRUE(bufferEqual<vector_size_t>(
-          *actualArray->sizes(), *expectedArray->sizes(), actualArray->size()));
+      ASSERT_TRUE(
+          bufferEqual<vector_size_t>(
+              *actualArray->offsets(),
+              *expectedArray->offsets(),
+              actualArray->size()));
+      ASSERT_TRUE(
+          bufferEqual<vector_size_t>(
+              *actualArray->sizes(),
+              *expectedArray->sizes(),
+              actualArray->size()));
       compareVectors(actualArray->elements(), expectedArray->elements());
       break;
     }
@@ -553,10 +563,412 @@ TEST_P(EncodedVectorCopyTest, allNullsMap) {
   VectorPtr target = makeAllNullMapVector(3, BIGINT(), BIGINT());
   BaseVector::CopyRange range = {1, 2, 2};
   auto expected = makeAllNullMapVector(4, BIGINT(), BIGINT());
-  ;
   runTests(source, folly::Range(&range, 1), target, expected);
 }
 
+TEST_P(EncodedVectorCopyTest, flatMapVector) {
+  // Simple case
+  auto source = vectorMaker_.flatMapVector<int64_t, int64_t>({
+      {{1, 10}, {2, 20}},
+      {{1, 30}},
+      {{1, 40}, {3, 50}},
+  });
+
+  {
+    SCOPED_TRACE("New full copy");
+    BaseVector::CopyRange range = {0, 0, source->size()};
+    VectorPtr actual;
+    copy(source, folly::Range(&range, 1), actual);
+    ASSERT_EQ(actual->encoding(), VectorEncoding::Simple::FLAT_MAP);
+    test::assertEqualVectors(source, actual);
+  }
+  {
+    SCOPED_TRACE("New slice copy");
+    BaseVector::CopyRange range = {1, 0, 2};
+    VectorPtr actual;
+    copy(source, folly::Range(&range, 1), actual);
+    ASSERT_EQ(actual->encoding(), VectorEncoding::Simple::FLAT_MAP);
+    test::assertEqualVectors(
+        source->slice(range.sourceIndex, range.count), actual);
+  }
+
+  // Null case.
+  source = vectorMaker_.flatMapVectorNullable<int64_t, int64_t>({
+      std::nullopt,
+      {{{1, 10}, {2, 20}}},
+      {{{3, std::nullopt}}},
+  });
+
+  {
+    SCOPED_TRACE("New full copy with nulls");
+    BaseVector::CopyRange range = {0, 0, source->size()};
+    VectorPtr actual;
+    copy(source, folly::Range(&range, 1), actual);
+    ASSERT_EQ(actual->encoding(), VectorEncoding::Simple::FLAT_MAP);
+    test::assertEqualVectors(source, actual);
+  }
+  {
+    SCOPED_TRACE("Copy non-null slice");
+    BaseVector::CopyRange range = {1, 0, 2};
+    VectorPtr actual;
+    copy(source, folly::Range(&range, 1), actual);
+    ASSERT_EQ(actual->encoding(), VectorEncoding::Simple::FLAT_MAP);
+    test::assertEqualVectors(
+        source->slice(range.sourceIndex, range.count), actual);
+  }
+
+  // Empty maps
+  source = vectorMaker_.flatMapVectorNullable<int64_t, int64_t>({
+      std::vector<std::pair<int64_t, std::optional<int64_t>>>{},
+      {{{1, 10}}},
+      std::vector<std::pair<int64_t, std::optional<int64_t>>>{},
+  });
+
+  {
+    SCOPED_TRACE("Empty maps");
+    BaseVector::CopyRange range = {0, 0, source->size()};
+    VectorPtr actual;
+    copy(source, folly::Range(&range, 1), actual);
+    ASSERT_EQ(actual->encoding(), VectorEncoding::Simple::FLAT_MAP);
+    test::assertEqualVectors(source, actual);
+  }
+
+  // Copy non-contiguous ranges.
+  source = vectorMaker_.flatMapVector<int64_t, int64_t>({
+      {{1, 10}},
+      {{2, 20}},
+      {{3, 30}},
+      {{4, 40}},
+  });
+  {
+    SCOPED_TRACE("Non-contiguous ranges");
+    BaseVector::CopyRange ranges[] = {{0, 0, 1}, {2, 1, 2}};
+    VectorPtr actual;
+    copy(source, folly::Range(ranges, 2), actual);
+    ASSERT_EQ(actual->encoding(), VectorEncoding::Simple::FLAT_MAP);
+    test::assertEqualVectors(
+        vectorMaker_.flatMapVector<int64_t, int64_t>({
+            {{1, 10}},
+            {{3, 30}},
+            {{4, 40}},
+        }),
+        actual);
+  }
+
+  // Complex values
+  auto valueType = ROW({{"a", BIGINT()}});
+  auto mapType = MAP(INTEGER(), valueType);
+  auto distinctKeys = makeFlatVector<int32_t>({1, 2});
+  std::vector<VectorPtr> mapValues;
+  mapValues.push_back(makeRowVector({makeFlatVector<int64_t>({10, 20, 30})}));
+  mapValues.push_back(makeRowVector({makeFlatVector<int64_t>({40, 50, 60})}));
+  source = std::make_shared<FlatMapVector>(
+      pool(),
+      mapType,
+      nullptr,
+      3,
+      distinctKeys,
+      std::move(mapValues),
+      std::vector<BufferPtr>{nullptr, nullptr});
+
+  {
+    SCOPED_TRACE("Complex values");
+    BaseVector::CopyRange range = {0, 0, source->size()};
+    VectorPtr actual;
+    copy(source, folly::Range(&range, 1), actual);
+    ASSERT_EQ(actual->encoding(), VectorEncoding::Simple::FLAT_MAP);
+    test::assertEqualVectors(source, actual);
+  }
+}
+
+/// Tests copying into an existing FlatMapVector target.
+TEST_P(EncodedVectorCopyTest, flatMapVectorCopyInto) {
+  {
+    SCOPED_TRACE("Copy into same keys");
+    auto source = vectorMaker_.flatMapVector<int64_t, int64_t>({
+        {{1, 100}, {2, 200}},
+        {{1, 300}, {2, 400}},
+    });
+
+    VectorPtr target = vectorMaker_.flatMapVector<int64_t, int64_t>({
+        {{1, 10}, {2, 20}},
+        {{1, 30}, {2, 40}},
+        {{1, 50}, {2, 60}},
+    });
+
+    // Copy source rows 0-1 to target rows 1-2.
+    BaseVector::CopyRange range = {0, 1, 2};
+    copy(source, folly::Range(&range, 1), target);
+    ASSERT_EQ(target->encoding(), VectorEncoding::Simple::FLAT_MAP);
+
+    // Row 0 should be unchanged: {1: 10, 2: 20}
+    // Row 1 should be from source row 0: {1: 100, 2: 200}
+    // Row 2 should be from source row 1: {1: 300, 2: 400}
+    auto expected = vectorMaker_.flatMapVector<int64_t, int64_t>({
+        {{1, 10}, {2, 20}},
+        {{1, 100}, {2, 200}},
+        {{1, 300}, {2, 400}},
+    });
+    test::assertEqualVectors(expected, target);
+  }
+
+  {
+    SCOPED_TRACE("Copy into same keys with non-mutable target");
+    auto source = vectorMaker_.flatMapVector<int64_t, int64_t>({
+        {{1, 100}, {2, 200}},
+        {{1, 300}, {2, 400}},
+    });
+
+    VectorPtr target = vectorMaker_.flatMapVector<int64_t, int64_t>({
+        {{1, 10}, {2, 20}},
+        {{1, 100}, {2, 200}},
+        {{1, 300}, {2, 400}},
+    });
+    auto immutableTarget = target;
+
+    // Copy source rows 0-1 to target rows 1-2.
+    BaseVector::CopyRange range = {0, 1, 2};
+    copy(source, folly::Range(&range, 1), immutableTarget);
+    ASSERT_EQ(immutableTarget->encoding(), VectorEncoding::Simple::FLAT_MAP);
+
+    auto expected = makeMapVector<int64_t, int64_t>({
+        {{1, 10}, {2, 20}},
+        {{1, 100}, {2, 200}},
+        {{1, 300}, {2, 400}},
+    });
+    test::assertEqualVectors(expected, immutableTarget);
+  }
+
+  {
+    SCOPED_TRACE("Copy into different keys");
+    auto source = vectorMaker_.flatMapVector<int64_t, int64_t>({
+        {{3, 300}, {4, 400}},
+        {{3, 500}},
+    });
+
+    VectorPtr target = vectorMaker_.flatMapVector<int64_t, int64_t>({
+        {{1, 10}, {2, 20}},
+        {{1, 30}},
+    });
+
+    // Copy source to target rows 2-3.
+    BaseVector::CopyRange range = {0, 2, 2};
+    copy(source, folly::Range(&range, 1), target);
+
+    auto expected = makeMapVector<int64_t, int64_t>({
+        {{1, 10}, {2, 20}},
+        {{1, 30}},
+        {{3, 300}, {4, 400}},
+        {{3, 500}},
+    });
+    test::assertEqualVectors(expected, target);
+  }
+
+  {
+    SCOPED_TRACE("Copy into different keys with non-mutable target");
+    auto source = vectorMaker_.flatMapVector<int64_t, int64_t>({
+        {{3, 300}, {4, 400}},
+        {{3, 500}},
+    });
+
+    VectorPtr target = vectorMaker_.flatMapVector<int64_t, int64_t>({
+        {{1, 10}, {2, 20}},
+        {{1, 30}},
+    });
+    auto immutableTarget = target;
+
+    BaseVector::CopyRange range = {0, 2, 2};
+    copy(source, folly::Range(&range, 1), immutableTarget);
+
+    auto expected = makeMapVector<int64_t, int64_t>({
+        {{1, 10}, {2, 20}},
+        {{1, 30}},
+        {{3, 300}, {4, 400}},
+        {{3, 500}},
+    });
+    test::assertEqualVectors(expected, immutableTarget);
+  }
+
+  {
+    SCOPED_TRACE("Overlapping keys");
+
+    auto source = vectorMaker_.flatMapVector<int64_t, int64_t>({
+        {{2, 200}, {3, 300}},
+    });
+
+    VectorPtr target = vectorMaker_.flatMapVector<int64_t, int64_t>({
+        {{1, 10}, {2, 20}},
+        {{1, 30}, {2, 40}},
+    });
+
+    // Copy source to target row 1.
+    BaseVector::CopyRange range = {0, 1, 1};
+    copy(source, folly::Range(&range, 1), target);
+
+    auto expected = makeMapVector<int64_t, int64_t>({
+        {{1, 10}, {2, 20}},
+        {{2, 200}, {3, 300}},
+    });
+    test::assertEqualVectors(expected, target);
+  }
+
+  {
+    SCOPED_TRACE("Overlapping keys with non-mutable target");
+
+    auto source = vectorMaker_.flatMapVector<int64_t, int64_t>({
+        {{2, 200}, {3, 300}},
+    });
+
+    VectorPtr target = vectorMaker_.flatMapVector<int64_t, int64_t>({
+        {{1, 10}, {2, 20}},
+        {{1, 30}, {2, 40}},
+    });
+    auto immutableTarget = target;
+
+    BaseVector::CopyRange range = {0, 1, 1};
+    copy(source, folly::Range(&range, 1), target);
+
+    EXPECT_EQ(target->encoding(), VectorEncoding::Simple::FLAT_MAP);
+    ASSERT_EQ(target->size(), 2);
+    ASSERT_NE(target.get(), immutableTarget.get());
+
+    auto expected = makeMapVector<int64_t, int64_t>({
+        {{1, 10}, {2, 20}},
+        {{2, 200}, {3, 300}},
+    });
+    test::assertEqualVectors(expected, target);
+  }
+}
+
+TEST_P(EncodedVectorCopyTest, flatMapVectorEncoded) {
+  auto source = BaseVector::wrapInConstant(
+      3,
+      1,
+      vectorMaker_.flatMapVector<int64_t, int64_t>(
+          {{{1, 10}, {2, 20}}, {{1, 100}, {2, 200}}}));
+  BaseVector::CopyRange range = {0, 0, 3};
+  auto expected = makeMapVector<int64_t, int64_t>(
+      {{{1, 100}, {2, 200}}, {{1, 100}, {2, 200}}, {{1, 100}, {2, 200}}});
+  {
+    SCOPED_TRACE("Constant wrapped FlatMapVector copy - NULL case");
+
+    VectorPtr target;
+    copy(source, folly::Range(&range, 1), target);
+    ASSERT_EQ(
+        target->wrappedVector()->encoding(), VectorEncoding::Simple::FLAT_MAP);
+    ASSERT_EQ(target->encoding(), VectorEncoding::Simple::CONSTANT);
+    test::assertEqualVectors(expected, target);
+  }
+  {
+    SCOPED_TRACE(
+        "Constant wrapped FlatMapVector copy - non-NULL mutable encoded source case");
+
+    VectorPtr target = vectorMaker_.flatMapVector<int64_t, int64_t>(
+        {{{0, 0}, {1, 10}}, {{2, 200}, {3, 300}}});
+    copy(source, folly::Range(&range, 1), target);
+    ASSERT_EQ(
+        target->wrappedVector()->encoding(), VectorEncoding::Simple::FLAT_MAP);
+    ASSERT_EQ(target->encoding(), VectorEncoding::Simple::DICTIONARY);
+    test::assertEqualVectors(expected, target);
+  }
+  {
+    SCOPED_TRACE(
+        "Constant wrapped FlatMapVector copy - non-NULL mutable encoded target case");
+
+    VectorPtr target = BaseVector::wrapInConstant(
+        3,
+        1,
+        vectorMaker_.flatMapVector<int64_t, int64_t>(
+            {{{0, 0}, {1, 10}}, {{2, 200}, {3, 300}}}));
+    copy(source, folly::Range(&range, 1), target);
+    ASSERT_EQ(
+        target->wrappedVector()->encoding(), VectorEncoding::Simple::FLAT_MAP);
+    ASSERT_EQ(target->encoding(), VectorEncoding::Simple::DICTIONARY);
+    test::assertEqualVectors(expected, target);
+  }
+  {
+    SCOPED_TRACE(
+        "Constant wrapped FlatMapVector copy - non-NULL immutable case");
+
+    VectorPtr target = vectorMaker_.flatMapVector<int64_t, int64_t>(
+        {{{0, 0}, {1, 10}}, {{2, 200}, {3, 300}}});
+    auto immutableTarget = target;
+    copy(source, folly::Range(&range, 1), immutableTarget);
+    test::assertEqualVectors(expected, immutableTarget);
+  }
+
+  source = wrapInDictionary(
+      makeIndices({1, 0, 1, 0}),
+      vectorMaker_.flatMapVector<int64_t, int64_t>({
+          {{1, 10}, {2, 20}},
+          {{1, 100}, {2, 200}},
+      }));
+  {
+    SCOPED_TRACE("Dictionary wrapped FlatMapVector copy - NULL case");
+
+    VectorPtr target;
+    BaseVector::CopyRange range = {0, 0, 4};
+    copy(source, folly::Range(&range, 1), target);
+    ASSERT_EQ(
+        target->wrappedVector()->encoding(), VectorEncoding::Simple::FLAT_MAP);
+    ASSERT_EQ(target->encoding(), VectorEncoding::Simple::DICTIONARY);
+
+    auto expected = makeMapVector<int64_t, int64_t>({
+        {{1, 100}, {2, 200}},
+        {{1, 10}, {2, 20}},
+        {{1, 100}, {2, 200}},
+        {{1, 10}, {2, 20}},
+    });
+    test::assertEqualVectors(expected, target);
+  }
+  {
+    SCOPED_TRACE(
+        "Dictionary wrapped FlatMapVector copy - non-NULL mutable case");
+
+    VectorPtr target = wrapInDictionary(
+        makeIndices({1, 0, 1, 0}),
+        vectorMaker_.flatMapVector<int64_t, int64_t>({
+            {{0, 0}, {1, 10}},
+            {{2, 200}, {3, 300}},
+        }));
+    BaseVector::CopyRange range = {0, 0, 4};
+    copy(source, folly::Range(&range, 1), target);
+    ASSERT_EQ(
+        target->wrappedVector()->encoding(), VectorEncoding::Simple::FLAT_MAP);
+    ASSERT_EQ(target->encoding(), VectorEncoding::Simple::DICTIONARY);
+
+    auto expected = makeMapVector<int64_t, int64_t>({
+        {{1, 100}, {2, 200}},
+        {{1, 10}, {2, 20}},
+        {{1, 100}, {2, 200}},
+        {{1, 10}, {2, 20}},
+    });
+    test::assertEqualVectors(expected, target);
+  }
+  {
+    SCOPED_TRACE(
+        "Dictionary wrapped FlatMapVector copy - non-NULL mutable case");
+
+    VectorPtr target = wrapInDictionary(
+        makeIndices({1, 0, 1, 0}),
+        vectorMaker_.flatMapVector<int64_t, int64_t>({
+            {{0, 0}, {1, 10}},
+            {{2, 200}, {3, 300}},
+        }));
+    BaseVector::CopyRange range = {0, 0, 4};
+    auto immutableTarget = target;
+    copy(source, folly::Range(&range, 1), immutableTarget);
+
+    auto expected = makeMapVector<int64_t, int64_t>({
+        {{1, 100}, {2, 200}},
+        {{1, 10}, {2, 20}},
+        {{1, 100}, {2, 200}},
+        {{1, 10}, {2, 20}},
+    });
+    test::assertEqualVectors(expected, immutableTarget);
+  }
+}
+
 TEST_P(EncodedVectorCopyTest, flatArray) {
   auto sourceElements = makeFlatVector<int64_t>({1, 2, 3});
   auto targetElements = makeFlatVector<int64_t>({4, 5, 6});
@@ -641,8 +1053,10 @@ TEST_P(EncodedVectorCopyTest, fuzzer) {
       test::assertEqualVectors(
           source->slice(range.sourceIndex, range.count), target);
     }
+
     auto target = fuzzer.fuzz(type);
     range.targetIndex = folly::Random::rand32(0, target->size() - 1, rng);
+
     auto makeExpected = [&](auto& expected) {
       if (expected->size() < range.targetIndex + range.count) {
         expected->resize(range.targetIndex + range.count);
@@ -667,5 +1081,104 @@ TEST_P(EncodedVectorCopyTest, fuzzer) {
   }
 }
 
+TEST_P(EncodedVectorCopyTest, flatMapImmutableTargetGrow) {
+  auto source = vectorMaker_.flatMapVector<int64_t, int64_t>({
+      {{3, 300}, {4, 400}},
+      {{3, 500}},
+  });
+
+  VectorPtr target = vectorMaker_.flatMapVector<int64_t, int64_t>({
+      {{1, 10}, {2, 20}},
+      {{1, 30}},
+  });
+  auto immutableTarget = target;
+
+  BaseVector::CopyRange range = {0, 2, 2};
+  copy(source, folly::Range(&range, 1), immutableTarget);
+
+  ASSERT_EQ(immutableTarget->size(), 4);
+  auto* resultFlatMap = immutableTarget->asUnchecked<FlatMapVector>();
+  for (column_index_t i = 0; i < resultFlatMap->numDistinctKeys(); ++i) {
+    ASSERT_GE(resultFlatMap->mapValuesAt(i)->size(), resultFlatMap->size())
+        << "Map value vector at channel " << i
+        << " is shorter than FlatMapVector length";
+  }
+
+  auto sliced = immutableTarget->slice(0, 4);
+  auto expected = makeMapVector<int64_t, int64_t>({
+      {{1, 10}, {2, 20}},
+      {{1, 30}},
+      {{3, 300}, {4, 400}},
+      {{3, 500}},
+  });
+  test::assertEqualVectors(expected, sliced);
+}
+
+TEST_P(EncodedVectorCopyTest, fuzzerFlatMapEncoded) {
+  VectorFuzzer::Options fuzzerOptions;
+  fuzzerOptions.allowLazyVector = reuseSource();
+  // Requires FlatMapVector to support encoded sources in copyRanges.
+  fuzzerOptions.allowConstantVector = false;
+  fuzzerOptions.allowDictionaryVector = false;
+  fuzzerOptions.allowFlatMapVector = true;
+  fuzzerOptions.allowLazyVector = false;
+  fuzzerOptions.flatMapRatio = 1.0;
+  fuzzerOptions.normalizeMapKeys = false;
+  fuzzerOptions.nullRatio = 0.05;
+  auto seed = common::testutil::getRandomSeed(42);
+  VectorFuzzer fuzzer(fuzzerOptions, pool(), seed);
+  fuzzer::FuzzerGenerator rng(seed);
+  constexpr int kNumIterations = 10;
+  for (int i = 0; i < kNumIterations; ++i) {
+    auto type = fuzzer.randType();
+    SCOPED_TRACE(fmt::format("i={} type={}", i, type->toString()));
+    auto source = fuzzer.fuzz(type);
+    BaseVector::CopyRange range;
+    range.sourceIndex = folly::Random::rand32(source->size() - 1, rng);
+    range.count =
+        folly::Random::rand32(1, source->size() - range.sourceIndex, rng);
+    {
+      SCOPED_TRACE("Null target");
+      VectorPtr target;
+      range.targetIndex = 0;
+      copy(source, folly::Range(&range, 1), target);
+      test::assertEqualVectors(
+          source->slice(range.sourceIndex, range.count), target);
+    }
+
+    {
+      SCOPED_TRACE("Immutable target");
+      auto source = fuzzer.fuzz(type);
+      auto target = fuzzer.fuzz(type);
+      auto actual = target;
+      BaseVector::CopyRange range;
+      range.sourceIndex = folly::Random::rand32(source->size() - 1, rng);
+      range.count =
+          folly::Random::rand32(1, source->size() - range.sourceIndex, rng);
+      range.targetIndex = folly::Random::rand32(0, target->size() - 1, rng);
+      copy(source, folly::Range(&range, 1), actual);
+      test::assertEqualVectors(
+          source->slice(range.sourceIndex, range.count),
+          actual->slice(range.targetIndex, range.count));
+    }
+
+    {
+      SCOPED_TRACE("Mutable target");
+      auto source = fuzzer.fuzz(type);
+      auto target = fuzzer.fuzz(type);
+      BaseVector::CopyRange mutableRange;
+      mutableRange.sourceIndex = folly::Random::rand32(source->size() - 1, rng);
+      mutableRange.count = folly::Random::rand32(
+          1, source->size() - mutableRange.sourceIndex, rng);
+      mutableRange.targetIndex =
+          folly::Random::rand32(0, target->size() - 1, rng);
+      copy(source, folly::Range(&mutableRange, 1), target);
+      test::assertEqualVectors(
+          source->slice(mutableRange.sourceIndex, mutableRange.count),
+          target->slice(mutableRange.targetIndex, mutableRange.count));
+    }
+  }
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/vector/tests/FlatMapVectorTest.cpp b/velox/vector/tests/FlatMapVectorTest.cpp
index 651834074d3..6ea77e58628 100644
--- a/velox/vector/tests/FlatMapVectorTest.cpp
+++ b/velox/vector/tests/FlatMapVectorTest.cpp
@@ -17,9 +17,9 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-#include "velox/common/base/VeloxException.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/memory/Memory.h"
+#include "velox/common/testutil/OptionalEmpty.h"
 #include "velox/vector/tests/utils/VectorMaker.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
@@ -74,6 +74,124 @@ class FlatMapVectorTest : public testing::Test, public VectorTestBase {
   VectorMaker maker_{pool_.get()};
 };
 
+TEST_F(FlatMapVectorTest, encodedKeys) {
+  const auto constructFlatMap = [&](VectorPtr keys) {
+    return std::make_shared<FlatMapVector>(
+        pool_.get(),
+        MAP(INTEGER(), INTEGER()),
+        nullptr,
+        3,
+        keys,
+        std::vector<VectorPtr>{
+            makeFlatVector<int32_t>({1, 2, 3}),
+            makeFlatVector<int32_t>({4, 5, 6}),
+            makeFlatVector<int32_t>({7, 8, 9})},
+        std::vector<BufferPtr>{nullptr, nullptr, nullptr});
+  };
+
+  // Dictionary wrapped keys
+  {
+    // Simple case
+    auto flatMap = constructFlatMap(
+        BaseVector::wrapInDictionary(
+            nullptr,
+            makeIndices({0, 1, 2}),
+            3,
+            makeFlatVector<int32_t>({1, 2, 3})));
+
+    auto mapValues = flatMap->projectKey(1)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->valueAt(0), 1);
+    EXPECT_EQ(mapValues->valueAt(1), 2);
+    EXPECT_EQ(mapValues->valueAt(2), 3);
+    mapValues = flatMap->projectKey(2)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->valueAt(0), 4);
+    EXPECT_EQ(mapValues->valueAt(1), 5);
+    EXPECT_EQ(mapValues->valueAt(2), 6);
+    mapValues = flatMap->projectKey(3)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->valueAt(0), 7);
+    EXPECT_EQ(mapValues->valueAt(1), 8);
+    EXPECT_EQ(mapValues->valueAt(2), 9);
+
+    // Random indices
+    flatMap = constructFlatMap(
+        BaseVector::wrapInDictionary(
+            nullptr,
+            makeIndices({2, 0, 1}),
+            3,
+            makeFlatVector<int32_t>({1, 2, 3})));
+
+    mapValues = flatMap->projectKey(1)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->valueAt(0), 4);
+    EXPECT_EQ(mapValues->valueAt(1), 5);
+    EXPECT_EQ(mapValues->valueAt(2), 6);
+    mapValues = flatMap->projectKey(2)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->valueAt(0), 7);
+    EXPECT_EQ(mapValues->valueAt(1), 8);
+    EXPECT_EQ(mapValues->valueAt(2), 9);
+    mapValues = flatMap->projectKey(3)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->valueAt(0), 1);
+    EXPECT_EQ(mapValues->valueAt(1), 2);
+    EXPECT_EQ(mapValues->valueAt(2), 3);
+
+    // Cardinality change
+    flatMap = constructFlatMap(
+        BaseVector::wrapInDictionary(
+            nullptr,
+            makeIndices({1, 3, 5}),
+            3,
+            makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6})));
+
+    mapValues = flatMap->projectKey(2)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->valueAt(0), 1);
+    EXPECT_EQ(mapValues->valueAt(1), 2);
+    EXPECT_EQ(mapValues->valueAt(2), 3);
+    mapValues = flatMap->projectKey(4)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->valueAt(0), 4);
+    EXPECT_EQ(mapValues->valueAt(1), 5);
+    EXPECT_EQ(mapValues->valueAt(2), 6);
+    mapValues = flatMap->projectKey(6)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->valueAt(0), 7);
+    EXPECT_EQ(mapValues->valueAt(1), 8);
+    EXPECT_EQ(mapValues->valueAt(2), 9);
+    EXPECT_EQ(flatMap->projectKey(1), nullptr);
+    EXPECT_EQ(flatMap->projectKey(3), nullptr);
+    EXPECT_EQ(flatMap->projectKey(5), nullptr);
+
+    // Repeated keys
+    flatMap = constructFlatMap(
+        BaseVector::wrapInDictionary(
+            nullptr,
+            makeIndices({2, 1, 1}),
+            3,
+            makeFlatVector<int32_t>({1, 2, 3})));
+
+    EXPECT_EQ(flatMap->projectKey(1), nullptr);
+    mapValues = flatMap->projectKey(2)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->size(), 3);
+    EXPECT_EQ(mapValues->valueAt(0), 7); // Becomes last set vector
+    EXPECT_EQ(mapValues->valueAt(1), 8);
+    EXPECT_EQ(mapValues->valueAt(2), 9);
+    mapValues = flatMap->projectKey(3)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->valueAt(0), 1);
+    EXPECT_EQ(mapValues->valueAt(1), 2);
+    EXPECT_EQ(mapValues->valueAt(2), 3);
+  }
+
+  // Constant wrapped keys
+  {
+    auto flatMap = constructFlatMap(
+        BaseVector::wrapInConstant(3, 0, makeFlatVector<int32_t>({1, 2, 3})));
+
+    auto mapValues = flatMap->projectKey(1)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->size(), 3);
+    EXPECT_EQ(mapValues->valueAt(0), 7); // Becomes last set vector
+    EXPECT_EQ(mapValues->valueAt(1), 8);
+    EXPECT_EQ(mapValues->valueAt(2), 9);
+    EXPECT_EQ(flatMap->projectKey(2), nullptr);
+    EXPECT_EQ(flatMap->projectKey(3), nullptr);
+  }
+}
+
 TEST_F(FlatMapVectorTest, fail) {
   auto buildVector = [&](const TypePtr& type,
                          const VectorPtr& keys = nullptr,
@@ -275,6 +393,95 @@ TEST_F(FlatMapVectorTest, nullInMaps) {
   EXPECT_TRUE(flatMap->isInMap(2, 0));
 }
 
+TEST_F(FlatMapVectorTest, copyRangesWithNullInMaps) {
+  auto vectorSize = 2;
+  auto distinctKeys = maker_.flatVector<int32_t>({1, 2, 3});
+
+  std::vector<VectorPtr> sourceMapValues{
+      makeFlatVector<int32_t>({10, 20}),
+      makeFlatVector<int32_t>({30, 40}),
+      makeFlatVector<int32_t>({50, 60}),
+  };
+
+  std::vector<BufferPtr> sourceInMaps(distinctKeys->size());
+  sourceInMaps[1] = AlignedBuffer::allocate<bool>(vectorSize, pool_.get(), 0);
+
+  auto source = std::make_shared<FlatMapVector>(
+      pool_.get(),
+      MAP(INTEGER(), INTEGER()),
+      nullptr,
+      vectorSize,
+      distinctKeys,
+      sourceMapValues,
+      sourceInMaps);
+
+  auto target = std::make_shared<FlatMapVector>(
+      pool_.get(),
+      MAP(INTEGER(), INTEGER()),
+      nullptr,
+      vectorSize,
+      makeFlatVector<int32_t>({4}),
+      std::vector<VectorPtr>{makeFlatVector<int32_t>({0, 0})},
+      std::vector<BufferPtr>{nullptr});
+
+  std::vector<BaseVector::CopyRange> ranges = {BaseVector::CopyRange{0, 0, 2}};
+  target->copyRanges(
+      source.get(), folly::Range<const BaseVector::CopyRange*>{ranges});
+
+  assertEqualVectors(source, target);
+}
+
+struct MockBufferViewReleaser {
+  void addRef() {}
+  void release() {}
+};
+
+TEST_F(FlatMapVectorTest, resizeWithViewInMaps) {
+  using MockBufferView = BufferView<MockBufferViewReleaser&>;
+  static MockBufferViewReleaser releaser;
+
+  auto vectorSize = 2;
+  auto distinctKeys = maker_.flatVector<int32_t>({1, 2});
+
+  std::vector<VectorPtr> mapValues{
+      BaseVector::create(INTEGER(), vectorSize, pool_.get()),
+      BaseVector::create(INTEGER(), vectorSize, pool_.get()),
+  };
+  mapValues[0]->asFlatVector<int32_t>()->set(0, 10);
+  mapValues[0]->asFlatVector<int32_t>()->set(1, 20);
+  mapValues[1]->asFlatVector<int32_t>()->set(0, 30);
+  mapValues[1]->asFlatVector<int32_t>()->set(1, 40);
+
+  auto inMapBuffer = AlignedBuffer::allocate<bool>(vectorSize, pool_.get());
+  auto rawInMapBuffer = inMapBuffer->asMutable<uint64_t>();
+  bits::setBit(rawInMapBuffer, 0, true);
+  bits::setBit(rawInMapBuffer, 1, true);
+
+  std::vector<BufferPtr> inMaps{
+      MockBufferView::create(inMapBuffer, releaser),
+      nullptr,
+  };
+
+  auto flatMap = std::make_shared<FlatMapVector>(
+      pool_.get(),
+      MAP(INTEGER(), INTEGER()),
+      nullptr,
+      vectorSize,
+      distinctKeys,
+      std::move(mapValues),
+      std::move(inMaps));
+
+  flatMap->resize(4);
+
+  EXPECT_EQ(flatMap->size(), 4);
+  EXPECT_TRUE(flatMap->isInMap(0, 0));
+  EXPECT_TRUE(flatMap->isInMap(0, 1));
+
+  // Verify sizeAt() works after resize.
+  EXPECT_EQ(flatMap->sizeAt(0), 2);
+  EXPECT_EQ(flatMap->sizeAt(1), 2);
+}
+
 TEST_F(FlatMapVectorTest, primitiveKeys) {
   // bigint key.
   auto flatMapVector = maker_.flatMapVector<int64_t, double>({
@@ -443,17 +650,14 @@ TEST_F(FlatMapVectorTest, sortedKeyIndices) {
 }
 
 TEST_F(FlatMapVectorTest, toString) {
-  auto vector = maker_.flatMapVectorNullable<int64_t, int64_t>({
-      std::optional{std::vector<std::pair<int64_t, std::optional<int64_t>>>{}},
-      std::optional<std::vector<std::pair<int64_t, std::optional<int64_t>>>>{
-          std::nullopt},
-      std::optional<std::vector<std::pair<int64_t, std::optional<int64_t>>>>{
-          {{1, {0}}}},
-      std::optional<std::vector<std::pair<int64_t, std::optional<int64_t>>>>{
-          {{1, {1}}, {2, {std::nullopt}}}},
-      std::optional<std::vector<std::pair<int64_t, std::optional<int64_t>>>>{
-          {{0, {0}}, {1, {1}}, {2, {2}}, {3, {3}}, {4, {4}}, {5, {5}}}},
-  });
+  auto vector = maker_.flatMapVectorNullable<int64_t, int64_t>(
+      {common::testutil::optionalEmpty,
+       std::nullopt,
+       std::vector<std::pair<int64_t, std::optional<int64_t>>>{{1, 0}},
+       std::vector<std::pair<int64_t, std::optional<int64_t>>>{
+           {1, 1}, {2, std::nullopt}},
+       std::vector<std::pair<int64_t, std::optional<int64_t>>>{
+           {0, 0}, {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}}});
 
   EXPECT_EQ(
       vector->toString(), "[FLAT_MAP MAP<BIGINT,BIGINT>: 5 elements, 1 nulls]");
@@ -748,5 +952,54 @@ TEST_F(FlatMapVectorTest, copyRanges) {
       {BaseVector::CopyRange{0, 1, 2}, BaseVector::CopyRange{3, 3, 1}});
 }
 
+TEST_F(FlatMapVectorTest, copyAndPreserveNestedFlatMap) {
+  // Create a nested map type: MAP<INT, MAP<INT, INT>>.
+  auto source = std::make_shared<FlatMapVector>(
+      pool_.get(),
+      MAP(INTEGER(), MAP(INTEGER(), INTEGER())),
+      nullptr,
+      2,
+      makeFlatVector<int32_t>({1}),
+      std::vector<VectorPtr>{std::make_shared<FlatMapVector>(
+          pool_.get(),
+          MAP(INTEGER(), INTEGER()),
+          nullptr,
+          2,
+          makeFlatVector<int32_t>({10, 20}),
+          std::vector<VectorPtr>{
+              makeFlatVector<int32_t>({100, 0}),
+              makeFlatVector<int32_t>({200, 0})},
+          std::vector<BufferPtr>{
+              AlignedBuffer::allocate<bool>(2, pool_.get(), true),
+              AlignedBuffer::allocate<bool>(2, pool_.get(), true)})},
+      std::vector<BufferPtr>{
+          AlignedBuffer::allocate<bool>(2, pool_.get(), true)});
+
+  auto target = std::make_shared<FlatMapVector>(
+      pool_.get(),
+      MAP(INTEGER(), MAP(INTEGER(), INTEGER())),
+      nullptr,
+      2,
+      makeFlatVector<int32_t>({2}),
+      std::vector<VectorPtr>{std::make_shared<FlatMapVector>(
+          pool_.get(),
+          MAP(INTEGER(), INTEGER()),
+          nullptr,
+          2,
+          makeFlatVector<int32_t>({30}),
+          std::vector<VectorPtr>{makeFlatVector<int32_t>({300, 0})},
+          std::vector<BufferPtr>{
+              AlignedBuffer::allocate<bool>(2, pool_.get(), true)})},
+      std::vector<BufferPtr>{
+          AlignedBuffer::allocate<bool>(2, pool_.get(), true)});
+
+  std::vector<BaseVector::CopyRange> ranges = {BaseVector::CopyRange{0, 0, 2}};
+  target->copyRanges(
+      source.get(), folly::Range<const BaseVector::CopyRange*>{ranges});
+
+  ASSERT_EQ(target->encoding(), VectorEncoding::Simple::FLAT_MAP);
+  assertEqualVectors(source, target);
+}
+
 } // namespace
 } // namespace facebook::velox::test
diff --git a/velox/vector/tests/LazyVectorTest.cpp b/velox/vector/tests/LazyVectorTest.cpp
index 2d522330210..b231c5e4bdf 100644
--- a/velox/vector/tests/LazyVectorTest.cpp
+++ b/velox/vector/tests/LazyVectorTest.cpp
@@ -19,7 +19,9 @@
 #include "velox/common/memory/RawVector.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
-using namespace facebook::velox;
+namespace facebook::velox {
+namespace {
+
 using namespace facebook::velox::test;
 
 class LazyVectorTest : public testing::Test, public VectorTestBase {
@@ -696,3 +698,25 @@ TEST_F(LazyVectorTest, runtimeStats) {
   ASSERT_EQ(stats[2].first, LazyVector::kWallNanos);
   ASSERT_GE(stats[2].second.value, 0);
 }
+
+TEST_F(LazyVectorTest, chain) {
+  auto lazy = std::make_shared<LazyVector>(
+      pool_.get(),
+      INTEGER(),
+      10,
+      std::make_unique<test::SimpleVectorLoader>([&](auto rows) {
+        return makeFlatVector<int32_t>(rows.back() + 1, folly::identity);
+      }));
+  lazy->chain([](auto& vector) {
+    auto* values =
+        vector->template asChecked<FlatVector<int32_t>>()->mutableRawValues();
+    for (vector_size_t i = 0; i < vector->size(); ++i) {
+      values[i] *= 2;
+    }
+  });
+  auto expected = makeFlatVector<int32_t>(10, [](auto i) { return i * 2; });
+  assertEqualVectors(expected, lazy);
+}
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/vector/tests/MapConcatTest.cpp b/velox/vector/tests/MapConcatTest.cpp
new file mode 100644
index 00000000000..91b08df73da
--- /dev/null
+++ b/velox/vector/tests/MapConcatTest.cpp
@@ -0,0 +1,446 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/vector/MapConcat.h"
+
+#include <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+namespace facebook::velox {
+namespace {
+
+class MapConcatTest : public testing::Test, public velox::test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  // Decode a vector and return the DecodedVector.  Caller must keep the
+  // returned object alive while using the pointer.
+  std::unique_ptr<DecodedVector> decode(const VectorPtr& vector) {
+    auto decoded = std::make_unique<DecodedVector>(*vector);
+    return decoded;
+  }
+
+  // Helper to call mapConcat with VectorPtrs (decodes internally).
+  MapVectorPtr concat(
+      const std::vector<VectorPtr>& inputs,
+      const SelectivityVector& rows,
+      const MapConcatConfig& config = {}) {
+    std::vector<std::unique_ptr<DecodedVector>> decodedOwners;
+    std::vector<DecodedVector*> decodedPtrs;
+    decodedOwners.reserve(inputs.size());
+    decodedPtrs.reserve(inputs.size());
+    for (const auto& input : inputs) {
+      decodedOwners.push_back(decode(input));
+      decodedPtrs.push_back(decodedOwners.back().get());
+    }
+    return mapConcat(pool(), inputs[0]->type(), decodedPtrs, rows, config);
+  }
+};
+
+TEST_F(MapConcatTest, basic) {
+  // Two maps with no overlapping keys.
+  auto map1 = makeMapVector<int64_t, int64_t>({
+      {{1, 10}, {2, 20}},
+      {{3, 30}},
+      {{4, 40}, {5, 50}, {6, 60}},
+  });
+  auto map2 = makeMapVector<int64_t, int64_t>({
+      {{7, 70}},
+      {{8, 80}, {9, 90}},
+      {{10, 100}},
+  });
+
+  SelectivityVector rows(3);
+  auto result = concat({map1, map2}, rows);
+
+  // Row 0: {1->10, 2->20, 7->70}
+  ASSERT_EQ(result->sizeAt(0), 3);
+  // Row 1: {3->30, 8->80, 9->90}
+  ASSERT_EQ(result->sizeAt(1), 3);
+  // Row 2: {4->40, 5->50, 6->60, 10->100}
+  ASSERT_EQ(result->sizeAt(2), 4);
+
+  // Verify by comparing with expected.
+  auto expected = makeMapVector<int64_t, int64_t>({
+      {{1, 10}, {2, 20}, {7, 70}},
+      {{3, 30}, {8, 80}, {9, 90}},
+      {{4, 40}, {5, 50}, {6, 60}, {10, 100}},
+  });
+  for (int i = 0; i < 3; ++i) {
+    ASSERT_TRUE(expected->equalValueAt(result.get(), i, i))
+        << "at " << i << ": expected " << expected->toString(i) << ", got "
+        << result->toString(i);
+  }
+}
+
+TEST_F(MapConcatTest, duplicateKeys) {
+  // Keys 2 and 3 overlap.  Last input wins.
+  auto map1 = makeMapVector<int64_t, int64_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+  auto map2 = makeMapVector<int64_t, int64_t>({
+      {{2, 200}, {3, 300}, {4, 400}},
+  });
+
+  SelectivityVector rows(1);
+  auto result = concat({map1, map2}, rows);
+
+  // Key 2 -> 200 (from map2), key 3 -> 300 (from map2).
+  auto expected = makeMapVector<int64_t, int64_t>({
+      {{1, 10}, {2, 200}, {3, 300}, {4, 400}},
+  });
+  ASSERT_TRUE(expected->equalValueAt(result.get(), 0, 0))
+      << "expected " << expected->toString(0) << ", got "
+      << result->toString(0);
+}
+
+TEST_F(MapConcatTest, throwOnDuplicateKeys) {
+  auto map1 = makeMapVector<int64_t, int64_t>({
+      {{1, 10}, {2, 20}},
+  });
+  auto map2 = makeMapVector<int64_t, int64_t>({
+      {{2, 200}, {3, 300}},
+  });
+
+  SelectivityVector rows(1);
+  MapConcatConfig config;
+  config.throwOnDuplicateKeys = true;
+  VELOX_ASSERT_USER_THROW(
+      concat({map1, map2}, rows, config), "Duplicate map key");
+}
+
+TEST_F(MapConcatTest, emptyForNull) {
+  // When emptyForNull is true, null inputs are treated as empty maps.
+  auto map1 = makeNullableMapVector<int64_t, int64_t>({
+      {{{1, 10}, {2, 20}}},
+      std::nullopt,
+      {{{3, 30}}},
+  });
+  auto map2 = makeNullableMapVector<int64_t, int64_t>({
+      std::nullopt,
+      {{{4, 40}}},
+      {{{5, 50}}},
+  });
+
+  SelectivityVector rows(3);
+  MapConcatConfig config;
+  config.emptyForNull = true;
+  auto result = concat({map1, map2}, rows, config);
+
+  // Row 0: map1 has {1->10, 2->20}, map2 is null (empty).  Result: {1->10,
+  // 2->20}.
+  ASSERT_FALSE(result->isNullAt(0));
+  ASSERT_EQ(result->sizeAt(0), 2);
+  // Row 1: map1 is null (empty), map2 has {4->40}.  Result: {4->40}.
+  ASSERT_FALSE(result->isNullAt(1));
+  ASSERT_EQ(result->sizeAt(1), 1);
+  // Row 2: both non-null.  Result: {3->30, 5->50}.
+  ASSERT_FALSE(result->isNullAt(2));
+  ASSERT_EQ(result->sizeAt(2), 2);
+}
+
+TEST_F(MapConcatTest, nullPropagation) {
+  // Default behavior: null in any input => null row.
+  auto map1 = makeNullableMapVector<int64_t, int64_t>({
+      {{{1, 10}}},
+      std::nullopt,
+      {{{3, 30}}},
+  });
+  auto map2 = makeNullableMapVector<int64_t, int64_t>({
+      std::nullopt,
+      {{{4, 40}}},
+      {{{5, 50}}},
+  });
+
+  SelectivityVector rows(3);
+  auto result = concat({map1, map2}, rows);
+
+  // Row 0: map2 is null -> null.
+  ASSERT_TRUE(result->isNullAt(0));
+  // Row 1: map1 is null -> null.
+  ASSERT_TRUE(result->isNullAt(1));
+  // Row 2: both non-null.
+  ASSERT_FALSE(result->isNullAt(2));
+  ASSERT_EQ(result->sizeAt(2), 2);
+}
+
+TEST_F(MapConcatTest, partialRows) {
+  auto map1 = makeMapVector<int64_t, int64_t>({
+      {{1, 10}},
+      {{2, 20}},
+      {{3, 30}},
+      {{4, 40}},
+  });
+  auto map2 = makeMapVector<int64_t, int64_t>({
+      {{5, 50}},
+      {{6, 60}},
+      {{7, 70}},
+      {{8, 80}},
+  });
+
+  // Only process rows 1 and 3.
+  SelectivityVector rows(4, false);
+  rows.setValid(1, true);
+  rows.setValid(3, true);
+  rows.updateBounds();
+
+  auto result = concat({map1, map2}, rows);
+
+  // Unselected rows get size 0.
+  ASSERT_EQ(result->sizeAt(0), 0);
+  ASSERT_EQ(result->sizeAt(2), 0);
+  // Selected rows are merged.
+  ASSERT_EQ(result->sizeAt(1), 2);
+  ASSERT_EQ(result->sizeAt(3), 2);
+}
+
+TEST_F(MapConcatTest, multipleInputs) {
+  auto map1 = makeMapVector<int64_t, int64_t>({
+      {{1, 10}},
+  });
+  auto map2 = makeMapVector<int64_t, int64_t>({
+      {{2, 20}},
+  });
+  auto map3 = makeMapVector<int64_t, int64_t>({
+      {{3, 30}},
+  });
+
+  SelectivityVector rows(1);
+  auto result = concat({map1, map2, map3}, rows);
+
+  auto expected = makeMapVector<int64_t, int64_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+  ASSERT_TRUE(expected->equalValueAt(result.get(), 0, 0))
+      << "expected " << expected->toString(0) << ", got "
+      << result->toString(0);
+}
+
+TEST_F(MapConcatTest, multipleInputsDuplicateKeys) {
+  // Key 1 appears in all three.  Last input wins.
+  auto map1 = makeMapVector<int64_t, int64_t>({
+      {{1, 10}, {2, 20}},
+  });
+  auto map2 = makeMapVector<int64_t, int64_t>({
+      {{1, 100}, {3, 30}},
+  });
+  auto map3 = makeMapVector<int64_t, int64_t>({
+      {{1, 1000}, {4, 40}},
+  });
+
+  SelectivityVector rows(1);
+  auto result = concat({map1, map2, map3}, rows);
+
+  auto expected = makeMapVector<int64_t, int64_t>({
+      {{1, 1000}, {2, 20}, {3, 30}, {4, 40}},
+  });
+  ASSERT_TRUE(expected->equalValueAt(result.get(), 0, 0))
+      << "expected " << expected->toString(0) << ", got "
+      << result->toString(0);
+}
+
+TEST_F(MapConcatTest, varcharKeys) {
+  auto map1 = makeMapVector<StringView, int64_t>({
+      {{StringView("a"), 1}, {StringView("b"), 2}},
+  });
+  auto map2 = makeMapVector<StringView, int64_t>({
+      {{StringView("b"), 20}, {StringView("c"), 3}},
+  });
+
+  SelectivityVector rows(1);
+  auto result = concat({map1, map2}, rows);
+
+  auto expected = makeMapVector<StringView, int64_t>({
+      {{StringView("a"), 1}, {StringView("b"), 20}, {StringView("c"), 3}},
+  });
+  ASSERT_TRUE(expected->equalValueAt(result.get(), 0, 0))
+      << "expected " << expected->toString(0) << ", got "
+      << result->toString(0);
+}
+
+TEST_F(MapConcatTest, emptyMaps) {
+  auto map1 = makeMapVector<int64_t, int64_t>({
+      {},
+      {{1, 10}},
+      {},
+  });
+  auto map2 = makeMapVector<int64_t, int64_t>({
+      {{2, 20}},
+      {},
+      {},
+  });
+
+  SelectivityVector rows(3);
+  auto result = concat({map1, map2}, rows);
+
+  auto expected = makeMapVector<int64_t, int64_t>({
+      {{2, 20}},
+      {{1, 10}},
+      {},
+  });
+  for (int i = 0; i < 3; ++i) {
+    ASSERT_TRUE(expected->equalValueAt(result.get(), i, i))
+        << "at " << i << ": expected " << expected->toString(i) << ", got "
+        << result->toString(i);
+  }
+}
+
+TEST_F(MapConcatTest, dictionaryEncoded) {
+  auto base = makeMapVector<int64_t, int64_t>({
+      {{1, 10}, {2, 20}},
+      {{3, 30}},
+      {{4, 40}, {5, 50}},
+  });
+
+  // Dictionary that reverses the order: [2, 1, 0].
+  auto indices = makeIndices({2, 1, 0});
+  auto dict = wrapInDictionary(indices, 3, base);
+
+  auto map2 = makeMapVector<int64_t, int64_t>({
+      {{6, 60}},
+      {{7, 70}},
+      {{8, 80}},
+  });
+
+  SelectivityVector rows(3);
+  auto result = concat({dict, map2}, rows);
+
+  // Row 0: dict[0] = base[2] = {4->40, 5->50} + {6->60}.
+  ASSERT_EQ(result->sizeAt(0), 3);
+  // Row 1: dict[1] = base[1] = {3->30} + {7->70}.
+  ASSERT_EQ(result->sizeAt(1), 2);
+  // Row 2: dict[2] = base[0] = {1->10, 2->20} + {8->80}.
+  ASSERT_EQ(result->sizeAt(2), 3);
+}
+
+TEST_F(MapConcatTest, constantEncoded) {
+  auto base = makeMapVector<int64_t, int64_t>({
+      {{1, 10}, {2, 20}},
+  });
+
+  // Constant vector repeating base[0] for 3 rows.
+  auto constant = BaseVector::wrapInConstant(3, 0, base);
+
+  auto map2 = makeMapVector<int64_t, int64_t>({
+      {{3, 30}},
+      {{4, 40}},
+      {{5, 50}},
+  });
+
+  SelectivityVector rows(3);
+  auto result = concat({constant, map2}, rows);
+
+  // Each row: {1->10, 2->20} + one new entry.
+  ASSERT_EQ(result->sizeAt(0), 3);
+  ASSERT_EQ(result->sizeAt(1), 3);
+  ASSERT_EQ(result->sizeAt(2), 3);
+}
+
+TEST_F(MapConcatTest, emptyForNullAllNull) {
+  // When all inputs are null for a row and emptyForNull is true, result is
+  // an empty map (not null).
+  auto map1 = makeNullableMapVector<int64_t, int64_t>({
+      std::nullopt,
+  });
+  auto map2 = makeNullableMapVector<int64_t, int64_t>({
+      std::nullopt,
+  });
+
+  SelectivityVector rows(1);
+  MapConcatConfig config;
+  config.emptyForNull = true;
+  auto result = concat({map1, map2}, rows, config);
+
+  ASSERT_FALSE(result->isNullAt(0));
+  ASSERT_EQ(result->sizeAt(0), 0);
+}
+
+// Custom type where keys are compared modulo 100.  So 1 and 101 are considered
+// equal, but native int64_t == treats them as different.
+class Mod100Type : public BigintType {
+ public:
+  constexpr Mod100Type() : BigintType{ProvideCustomComparison{}} {}
+
+  int32_t compare(const int64_t& left, const int64_t& right) const override {
+    return static_cast<int32_t>((left % 100) - (right % 100));
+  }
+
+  uint64_t hash(const int64_t& value) const override {
+    return folly::hasher<int64_t>()(value % 100);
+  }
+
+  bool equivalent(const Type& other) const override {
+    return this == &other;
+  }
+
+  const char* name() const override {
+    return "MOD100";
+  }
+
+  std::string toString() const override {
+    return name();
+  }
+};
+
+TEST_F(MapConcatTest, customComparisonType) {
+  // Keys 1 and 101 are different by native ==, but equal by Mod100Type
+  // comparison (both are 1 mod 100).  Dedup should treat them as the same key.
+  static const Mod100Type kMod100Type;
+  auto mod100TypePtr =
+      std::shared_ptr<const Type>(std::shared_ptr<const Type>{}, &kMod100Type);
+  auto mapType = MAP(mod100TypePtr, BIGINT());
+
+  // Build map1 with key 1, map2 with key 101.
+  auto map1Keys = makeFlatVector<int64_t>({1}, mod100TypePtr);
+  auto map1Values = makeFlatVector<int64_t>({10});
+  auto map1 = std::make_shared<MapVector>(
+      pool(),
+      mapType,
+      BufferPtr(nullptr),
+      1,
+      allocateOffsets(1, pool()),
+      allocateSizes(1, pool()),
+      map1Keys,
+      map1Values);
+  // Set offset=0, size=1 for row 0.
+  map1->setOffsetAndSize(0, 0, 1);
+
+  auto map2Keys = makeFlatVector<int64_t>({101}, mod100TypePtr);
+  auto map2Values = makeFlatVector<int64_t>({20});
+  auto map2 = std::make_shared<MapVector>(
+      pool(),
+      mapType,
+      BufferPtr(nullptr),
+      1,
+      allocateOffsets(1, pool()),
+      allocateSizes(1, pool()),
+      map2Keys,
+      map2Values);
+  map2->setOffsetAndSize(0, 0, 1);
+
+  SelectivityVector rows(1);
+  auto result = concat({map1, map2}, rows);
+
+  // With custom comparison, 1 and 101 are the same key.  Last input wins,
+  // so the result should have 1 entry with value 20 (from map2).
+  ASSERT_EQ(result->sizeAt(0), 1);
+}
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/vector/tests/SimpleVectorTest.cpp b/velox/vector/tests/SimpleVectorTest.cpp
index 9f2e30af95d..8b38b8c183a 100644
--- a/velox/vector/tests/SimpleVectorTest.cpp
+++ b/velox/vector/tests/SimpleVectorTest.cpp
@@ -747,6 +747,7 @@ TYPED_TEST(SimpleVectorCompareTest, compareDescNullsLast) {
   this->runTest({/*nullsFirst=*/false, /*ascending=*/false});
 }
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
 template <typename T, int32_t offset>
 inline T simd256_extract_value(xsimd::batch<T> simdValue) {
   if constexpr (std::is_same_v<T, bool>) {
@@ -925,6 +926,7 @@ TYPED_TEST(SimpleVectorSimdTypedTest, flatVectorTest) {
 TYPED_TEST(SimpleVectorSimdTypedTest, sequenceVectorTest) {
   this->template runTest<VectorEncoding::Simple::SEQUENCE>();
 }
+#endif
 
 // See instructions in SimpleVectorTestHelper.h. By implementing this, a bunch
 // of SimpleVector test cases will be run.
diff --git a/velox/vector/tests/VariantToVectorTest.cpp b/velox/vector/tests/VariantToVectorTest.cpp
index 1c31b2c4fa5..7ee954ed087 100644
--- a/velox/vector/tests/VariantToVectorTest.cpp
+++ b/velox/vector/tests/VariantToVectorTest.cpp
@@ -18,6 +18,8 @@
 #include <gtest/gtest.h>
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/type/Variant.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/VectorSaver.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
 namespace facebook::velox {
@@ -30,10 +32,11 @@ class VariantToVectorTest : public testing::Test, public test::VectorTestBase {
   }
 
   void testNull(const TypePtr& type) const {
-    auto vector = variantToVector(type, Variant::null(type->kind()), pool());
+    auto vector = BaseVector::createConstant(
+        type, Variant::null(type->kind()), 1, pool());
 
     EXPECT_TRUE(vector->isConstantEncoding());
-    EXPECT_EQ(vector->type()->toString(), type->toString());
+    VELOX_EXPECT_EQ_TYPES(vector->type(), type);
     EXPECT_TRUE(vector->isNullAt(0));
 
     auto copy = vector->variantAt(0);
@@ -45,10 +48,10 @@ class VariantToVectorTest : public testing::Test, public test::VectorTestBase {
       const TypePtr& type,
       const Variant& value,
       const VectorPtr& expected) {
-    auto vector = variantToVector(type, value, pool());
+    auto vector = BaseVector::createConstant(type, value, 1, pool());
 
     EXPECT_TRUE(vector->isConstantEncoding());
-    EXPECT_EQ(vector->type()->toString(), type->toString());
+    VELOX_EXPECT_EQ_TYPES(vector->type(), type);
     EXPECT_TRUE(expected->equalValueAt(vector.get(), 0, 0))
         << "Expected: " << expected->toString(0)
         << ", but got: " << vector->toString(0);
@@ -58,6 +61,23 @@ class VariantToVectorTest : public testing::Test, public test::VectorTestBase {
     EXPECT_TRUE(copy.isTypeCompatible(type));
     EXPECT_EQ(copy, value);
   }
+
+  void testFromVariants(
+      const TypePtr& type,
+      const std::vector<Variant>& values) {
+    auto vector = BaseVector::createFromVariants(type, values, pool());
+
+    EXPECT_FALSE(vector->isConstantEncoding());
+    VELOX_EXPECT_EQ_TYPES(vector->type(), type);
+    EXPECT_EQ(vector->size(), values.size());
+
+    vector->validate();
+
+    for (auto i = 0; i < values.size(); ++i) {
+      EXPECT_EQ(values[i], vector->variantAt(i));
+      EXPECT_TRUE(vector->variantAt(i).isTypeCompatible(type));
+    }
+  }
 };
 
 TEST_F(VariantToVectorTest, integer) {
@@ -82,9 +102,8 @@ TEST_F(VariantToVectorTest, decimal) {
       Variant(arrayData[0]), Variant(arrayData[1]), Variant(arrayData[2])};
   Variant arrayInput = Variant::array(arrayInputData);
 
-  VELOX_ASSERT_THROW(
-      variantToVector(ARRAY(type), arrayInput, pool()),
-      "Type not supported: DECIMAL(20, 3)");
+  auto expectedVector = makeArrayVector<int128_t>({arrayData}, type);
+  testValue(ARRAY(type), arrayInput, expectedVector);
 }
 
 TEST_F(VariantToVectorTest, timestamp) {
@@ -126,6 +145,19 @@ TEST_F(VariantToVectorTest, array) {
       makeArrayVectorFromJson<int32_t>({"[1, 2, null, 4]"}));
 }
 
+TEST_F(VariantToVectorTest, saveVarcharArrayVector) {
+  auto type = ARRAY(VARCHAR());
+  auto variant =
+      Variant::array({"a", "b", Variant::null(TypeKind::VARCHAR), "d"});
+  auto vectorWithNulls = BaseVector::createConstant(type, variant, 1, pool());
+  std::ostringstream out;
+  saveVector(*vectorWithNulls, out);
+  std::istringstream in(out.str());
+  auto vectorCopy = restoreVector(in, pool());
+  auto variantCopy = vectorCopy->variantAt(0);
+  EXPECT_EQ(variantCopy, variant);
+}
+
 TEST_F(VariantToVectorTest, nestedContainers) {
   auto type = MAP(DOUBLE(), ARRAY(INTEGER()));
   testNull(type);
@@ -202,5 +234,84 @@ TEST_F(VariantToVectorTest, opaque) {
   testValue(type, Variant::opaque(data), expected);
 }
 
+TEST_F(VariantToVectorTest, createFromVariantsInteger) {
+  testFromVariants(
+      INTEGER(),
+      {
+          Variant::create<int32_t>(1),
+          Variant::create<int32_t>(2),
+          Variant::create<int32_t>(3),
+      });
+}
+
+TEST_F(VariantToVectorTest, createFromVariantsWithNulls) {
+  testFromVariants(
+      INTEGER(),
+      {
+          Variant::create<int32_t>(1),
+          Variant::null(TypeKind::INTEGER),
+          Variant::create<int32_t>(3),
+      });
+}
+
+TEST_F(VariantToVectorTest, createFromVariantsVarchar) {
+  testFromVariants(
+      VARCHAR(), {Variant("hello"), Variant("world"), Variant("test")});
+}
+
+TEST_F(VariantToVectorTest, createFromVariantsArray) {
+  testFromVariants(
+      ARRAY(INTEGER()),
+      {Variant::array({1, 2, 3}), Variant::array({4, 5}), Variant::array({})});
+}
+
+TEST_F(VariantToVectorTest, createFromVariantsMap) {
+  testFromVariants(
+      MAP(INTEGER(), DOUBLE()),
+      {Variant::map({{1, 1.0}, {2, 2.0}}), Variant::map({{3, 3.0}})});
+}
+
+TEST_F(VariantToVectorTest, createFromVariantsRow) {
+  testFromVariants(
+      ROW({"a", "b"}, {INTEGER(), DOUBLE()}),
+      {Variant::row({1, 1.0}), Variant::row({2, 2.0})});
+
+  // All nulls.
+  testFromVariants(
+      ROW({"a", "b"}, {INTEGER(), DOUBLE()}),
+      {Variant::null(TypeKind::ROW), Variant::null(TypeKind::ROW)});
+
+  // Mixed nulls and values.
+  testFromVariants(
+      ROW({"a", "b"}, {INTEGER(), DOUBLE()}),
+      {Variant::row({1, 1.0}),
+       Variant::null(TypeKind::ROW),
+       Variant::row({2, 2.0}),
+       Variant::null(TypeKind::ROW)});
+}
+
+TEST_F(VariantToVectorTest, createFromVariantsEmpty) {
+  auto vector = BaseVector::createFromVariants(INTEGER(), {}, pool());
+  EXPECT_EQ(vector->size(), 0);
+}
+
+TEST_F(VariantToVectorTest, createFromVariantsMismatchedType) {
+  {
+    std::vector<Variant> values = {
+        Variant::create<int32_t>(1),
+        Variant::create<int32_t>(2),
+    };
+    VELOX_ASSERT_THROW(
+        BaseVector::createFromVariants(VARCHAR(), values, pool()),
+        "wrong kind! INTEGER != VARCHAR");
+  }
+  {
+    std::vector<Variant> values = {Variant::create<int32_t>(1), Variant("one")};
+    VELOX_ASSERT_THROW(
+        BaseVector::createFromVariants(INTEGER(), values, pool()),
+        "wrong kind! VARCHAR != INTEGER");
+  }
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/vector/tests/VectorMakerTest.cpp b/velox/vector/tests/VectorMakerTest.cpp
index f2b2061f54b..4b01116bfba 100644
--- a/velox/vector/tests/VectorMakerTest.cpp
+++ b/velox/vector/tests/VectorMakerTest.cpp
@@ -139,16 +139,17 @@ TEST_F(VectorMakerTest, flatVectorStringNullableTypes) {
       maker_.flatVectorNullable<const char*>({"hello", std::nullopt, "world"}));
 
   // std::string
-  validate(maker_.flatVectorNullable(std::vector<std::optional<std::string>>(
-      {"hello", std::nullopt, "world"})));
+  validate(maker_.flatVectorNullable(
+      std::vector<std::optional<std::string>>(
+          {"hello", std::nullopt, "world"})));
 
   // StringView
   validate(
       maker_.flatVectorNullable<StringView>({"hello", std::nullopt, "world"}));
 
   // std::string_view
-  validate(
-      maker_.flatVectorNullable(std::vector<std::optional<std::string_view>>(
+  validate(maker_.flatVectorNullable(
+      std::vector<std::optional<std::string_view>>(
           {"hello", std::nullopt, "world"})));
 }
 
@@ -693,6 +694,76 @@ TEST_F(VectorMakerTest, mapVectorUsingKeyValueVectorsUnevenKeysValues) {
   EXPECT_THROW(maker_.mapVector({0, 2, 4}, keys, values), VeloxRuntimeError);
 }
 
+TEST_F(VectorMakerTest, mapVectorWithExplicitSizesNoNulls) {
+  // Keys/values laid out non-contiguously:
+  //   index: 0  1  2  3  4
+  //   key:   1  2  3  4  5
+  //   val:   10 20 30 40 50
+  //
+  // Row 0 -> offset=2, size=3 (indices 2,3,4)
+  // Row 1 -> offset=0, size=2 (indices 0,1)
+  auto keys = maker_.flatVector<int32_t>({1, 2, 3, 4, 5});
+  auto values = maker_.flatVector<int64_t>({10, 20, 30, 40, 50});
+
+  auto mapVector = maker_.mapVector({2, 0}, {3, 2}, keys, values);
+
+  EXPECT_EQ(mapVector->size(), 2);
+  EXPECT_EQ(mapVector->offsetAt(0), 2);
+  EXPECT_EQ(mapVector->sizeAt(0), 3);
+  EXPECT_EQ(mapVector->offsetAt(1), 0);
+  EXPECT_EQ(mapVector->sizeAt(1), 2);
+  EXPECT_FALSE(mapVector->isNullAt(0));
+  EXPECT_FALSE(mapVector->isNullAt(1));
+}
+
+TEST_F(VectorMakerTest, mapVectorWithExplicitSizesWithGaps) {
+  // Rows reference non-adjacent regions, leaving a gap at indices 2-3.
+  //   index: 0  1  2  3  4  5
+  //   key:   1  2  9  9  3  4
+  //   val:   10 20 0  0  30 40
+  //
+  // Row 0 -> offset=0, size=2
+  // Row 1 -> offset=4, size=2
+  auto keys = maker_.flatVector<int32_t>({1, 2, 9, 9, 3, 4});
+  auto values = maker_.flatVector<int64_t>({10, 20, 0, 0, 30, 40});
+
+  auto mapVector = maker_.mapVector({0, 4}, {2, 2}, keys, values);
+
+  EXPECT_EQ(mapVector->size(), 2);
+  EXPECT_EQ(mapVector->offsetAt(0), 0);
+  EXPECT_EQ(mapVector->sizeAt(0), 2);
+  EXPECT_EQ(mapVector->offsetAt(1), 4);
+  EXPECT_EQ(mapVector->sizeAt(1), 2);
+}
+
+TEST_F(VectorMakerTest, mapVectorWithExplicitSizesWithNulls) {
+  auto keys = maker_.flatVector<int32_t>({1, 2, 3, 4});
+  auto values = maker_.flatVector<int64_t>({10, 20, 30, 40});
+
+  // Row 0 -> offset=2, size=2, not null
+  // Row 1 -> null
+  // Row 2 -> offset=0, size=2, not null
+  auto mapVector = maker_.mapVector({2, 0, 0}, {2, 0, 2}, keys, values, {1});
+
+  EXPECT_EQ(mapVector->size(), 3);
+  EXPECT_FALSE(mapVector->isNullAt(0));
+  EXPECT_TRUE(mapVector->isNullAt(1));
+  EXPECT_FALSE(mapVector->isNullAt(2));
+  EXPECT_EQ(mapVector->offsetAt(0), 2);
+  EXPECT_EQ(mapVector->sizeAt(0), 2);
+  EXPECT_EQ(mapVector->sizeAt(1), 0);
+  EXPECT_EQ(mapVector->offsetAt(2), 0);
+  EXPECT_EQ(mapVector->sizeAt(2), 2);
+}
+
+TEST_F(VectorMakerTest, mapVectorWithExplicitSizesMismatch) {
+  auto keys = maker_.flatVector<int32_t>({1, 2});
+  auto values = maker_.flatVector<int64_t>({10, 20});
+
+  // offsets and sizes must have the same length.
+  EXPECT_THROW(maker_.mapVector({0}, {1, 1}, keys, values), VeloxRuntimeError);
+}
+
 TEST_F(VectorMakerTest, mapVectorStringString) {
   auto mapVector = maker_.mapVector<std::string, std::string>({
       {{"a", "1"}, {"b", "2"}},
diff --git a/velox/vector/tests/VectorPoolTest.cpp b/velox/vector/tests/VectorPoolTest.cpp
index 4f5d4691fc9..acb018cc5f3 100644
--- a/velox/vector/tests/VectorPoolTest.cpp
+++ b/velox/vector/tests/VectorPoolTest.cpp
@@ -110,7 +110,9 @@ TEST_F(VectorPoolTest, vectorRecycler) {
 
   // Empty scoped vector does nothing.
   VectorPtr vectorPtr;
-  { VectorRecycler vectorRecycler(vectorPtr, &vectorPool); }
+  {
+    VectorRecycler vectorRecycler(vectorPtr, &vectorPool);
+  }
 
   // Get new vector from the pool and release it back.
   BaseVector* rawPtr;
diff --git a/velox/vector/tests/VectorPrepareForReuseTest.cpp b/velox/vector/tests/VectorPrepareForReuseTest.cpp
index 44ff7d4cf6c..9bf02208008 100644
--- a/velox/vector/tests/VectorPrepareForReuseTest.cpp
+++ b/velox/vector/tests/VectorPrepareForReuseTest.cpp
@@ -323,3 +323,147 @@ TEST_F(VectorPrepareForReuseTest, dataDependentFlags) {
         createVector, prepareForReuseStatic, SelectivityVector{size});
   }
 }
+
+TEST_F(VectorPrepareForReuseTest, recursivelyReusableFlatVector) {
+  // Single reference flat vector should be reusable.
+  VectorPtr vector = makeFlatVector<int32_t>(100, [](auto row) { return row; });
+  ASSERT_TRUE(BaseVector::recursivelyReusable(vector));
+
+  // Multiple references make it non-reusable.
+  VectorPtr copy = vector;
+  ASSERT_FALSE(BaseVector::recursivelyReusable(vector));
+  ASSERT_FALSE(BaseVector::recursivelyReusable(copy));
+
+  // Release the extra reference.
+  copy.reset();
+  ASSERT_TRUE(BaseVector::recursivelyReusable(vector));
+}
+
+TEST_F(VectorPrepareForReuseTest, recursivelyReusableNullVector) {
+  // Null vector should return false (not reusable because there's nothing to
+  // reuse).
+  VectorPtr nullVector = nullptr;
+  ASSERT_TRUE(BaseVector::recursivelyReusable(nullVector));
+}
+
+TEST_F(VectorPrepareForReuseTest, recursivelyReusableArrayVector) {
+  // Single reference array vector with single reference elements.
+  VectorPtr vector = makeArrayVector<int32_t>(
+      100,
+      [](auto row) { return 1; },
+      [](auto row, auto index) { return row + index; });
+  ASSERT_TRUE(BaseVector::recursivelyReusable(vector));
+
+  // Share the elements - should make it non-reusable.
+  auto* arrayVector = vector->as<ArrayVector>();
+  VectorPtr elementsCopy = arrayVector->elements();
+  ASSERT_FALSE(BaseVector::recursivelyReusable(vector));
+
+  // Release the elements copy.
+  elementsCopy.reset();
+  ASSERT_TRUE(BaseVector::recursivelyReusable(vector));
+}
+
+TEST_F(VectorPrepareForReuseTest, recursivelyReusableRowVector) {
+  // Create children vectors first
+  auto child0 = makeFlatVector<int32_t>(100, [](auto row) { return row; });
+  auto child1 = makeFlatVector<int64_t>(100, [](auto row) { return row * 2; });
+
+  // Create row vector - children are moved in, so row vector owns them
+  VectorPtr vector = std::make_shared<RowVector>(
+      pool(),
+      ROW({{"a", INTEGER()}, {"b", BIGINT()}}),
+      nullptr,
+      100,
+      std::vector<VectorPtr>{child0, child1});
+
+  // At this point, child0 and child1 still hold references
+  // so the row vector is NOT reusable
+  ASSERT_FALSE(BaseVector::recursivelyReusable(vector));
+
+  // Release the external references to children
+  child0.reset();
+  child1.reset();
+  ASSERT_TRUE(BaseVector::recursivelyReusable(vector));
+
+  // Share a child - should make it non-reusable.
+  VectorPtr childCopy = vector->as<RowVector>()->childAt(0);
+  ASSERT_FALSE(BaseVector::recursivelyReusable(vector));
+
+  // Release the child copy.
+  childCopy.reset();
+  ASSERT_TRUE(BaseVector::recursivelyReusable(vector));
+}
+
+TEST_F(VectorPrepareForReuseTest, recursivelyReusableMapVector) {
+  // Use makeMapVector helper which creates a fully owned structure
+  VectorPtr vector =
+      makeMapVector<int32_t, int32_t>({{{{1, 10}, {2, 20}}}, {{{3, 30}}}});
+  ASSERT_TRUE(BaseVector::recursivelyReusable(vector));
+
+  // Share the keys - should make it non-reusable.
+  auto* mapVector = vector->as<MapVector>();
+  VectorPtr keysCopy = mapVector->mapKeys();
+  ASSERT_FALSE(BaseVector::recursivelyReusable(vector));
+
+  // Release the keys copy.
+  keysCopy.reset();
+  ASSERT_TRUE(BaseVector::recursivelyReusable(vector));
+
+  // Share values instead.
+  VectorPtr valuesCopy = mapVector->mapValues();
+  ASSERT_FALSE(BaseVector::recursivelyReusable(vector));
+
+  valuesCopy.reset();
+  ASSERT_TRUE(BaseVector::recursivelyReusable(vector));
+}
+
+TEST_F(VectorPrepareForReuseTest, recursivelyReusableNestedArrayOfRow) {
+  // Test nested structure: Array<Row<int32, int64>>
+  // Sharing deeply nested children makes the whole structure non-reusable.
+  const auto rowType = ROW({{"a", INTEGER()}, {"b", BIGINT()}});
+  constexpr int kNumArrays = 10;
+  constexpr int kElementsPerArray = 5;
+  constexpr int kTotalElements = kNumArrays * kElementsPerArray;
+
+  // Create the rows RowVector as elements for the ArrayVector.
+  auto child0 = makeFlatVector<int32_t>(kTotalElements, [](auto idx) {
+    return (idx / kElementsPerArray) * 10 + (idx % kElementsPerArray);
+  });
+  auto child1 = makeFlatVector<int64_t>(kTotalElements, [](auto idx) {
+    return (idx / kElementsPerArray) * 100 + (idx % kElementsPerArray);
+  });
+  auto rows =
+      makeRowVector(rowType->names(), {std::move(child0), std::move(child1)});
+
+  // Build the ArrayVector on top of rows.
+  VectorPtr vector =
+      makeArrayVector({0, 5, 10, 15, 20, 25, 30, 35, 40, 45}, rows);
+  ASSERT_FALSE(BaseVector::recursivelyReusable(vector));
+
+  rows.reset();
+  ASSERT_TRUE(BaseVector::recursivelyReusable(vector));
+
+  // Share the nested row's child - should make the whole array non-reusable.
+  auto* arrayVector = vector->as<ArrayVector>();
+  auto* rowElements = arrayVector->elements()->as<RowVector>();
+  VectorPtr nestedChildCopy = rowElements->childAt(0);
+  ASSERT_FALSE(BaseVector::recursivelyReusable(vector));
+
+  nestedChildCopy.reset();
+  ASSERT_TRUE(BaseVector::recursivelyReusable(vector));
+}
+
+TEST_F(VectorPrepareForReuseTest, recursivelyReusableDictionaryVector) {
+  // Dictionary vectors are not considered reusable encoding.
+  auto flat = makeFlatVector<int32_t>(100, [](auto row) { return row; });
+  auto indices = makeIndices(100, [](auto row) { return row; });
+  auto dictionary = BaseVector::wrapInDictionary(nullptr, indices, 100, flat);
+
+  ASSERT_FALSE(BaseVector::recursivelyReusable(dictionary));
+
+  flat.reset();
+  ASSERT_FALSE(BaseVector::recursivelyReusable(dictionary));
+  indices.reset();
+  ASSERT_FALSE(BaseVector::recursivelyReusable(dictionary));
+}
diff --git a/velox/vector/tests/VectorRetainedSizeTest.cpp b/velox/vector/tests/VectorRetainedSizeTest.cpp
new file mode 100644
index 00000000000..5a45d1ffc3b
--- /dev/null
+++ b/velox/vector/tests/VectorRetainedSizeTest.cpp
@@ -0,0 +1,287 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+namespace facebook::velox::test {
+namespace {
+
+class VectorRetainedSizeTest : public testing::Test,
+                               public velox::test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  uint64_t getTotalStringBufferSize(const VectorPtr& vector) {
+    auto* flatVector = vector->asFlatVector<StringView>();
+    VELOX_CHECK_NOT_NULL(flatVector, nullptr);
+    return flatVector->stringBufferSize();
+  }
+};
+
+} // namespace
+
+TEST_F(VectorRetainedSizeTest, flatNoStrings) {
+  auto vector = makeFlatVector<int32_t>(1'000, folly::identity);
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = vector->retainedSize(totalStringBufferSize);
+
+  EXPECT_EQ(totalStringBufferSize, 0);
+  EXPECT_EQ(retainedSize, vector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, flatInlinedStrings) {
+  auto vector = makeFlatVector<std::string>(
+      1'000, [](auto row) { return std::string(row % 3, '.'); });
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = vector->retainedSize(totalStringBufferSize);
+
+  EXPECT_EQ(totalStringBufferSize, 0);
+  EXPECT_EQ(retainedSize, vector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, flatMultipleStringBuffers) {
+  auto vector = makeFlatVector<StringView>({});
+  vector->resize(3);
+
+  std::vector<BufferPtr> buffers;
+  for (auto i = 1; i <= 3; ++i) {
+    vector->getBufferWithSpace(i * 100);
+    // Update buffers to hold a shared pointer to every existing string buffer,
+    // so that the next getBufferWithSpace call will create a new buffer.
+    buffers = vector->stringBuffers();
+  }
+  EXPECT_EQ(vector->stringBuffers().size(), 3);
+
+  for (auto& buffer : buffers) {
+    std::string str(100, 'a');
+    memcpy(buffer->asMutable<char>(), str.data(), str.size());
+    vector->setNoCopy(0, StringView(buffer->as<char>(), str.size()));
+  }
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = vector->retainedSize(totalStringBufferSize);
+  uint64_t expectedBufferSize = getTotalStringBufferSize(vector);
+
+  EXPECT_EQ(totalStringBufferSize, expectedBufferSize);
+  EXPECT_EQ(retainedSize, vector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, constantWithStringBuffer) {
+  auto vector = makeConstant(std::string(100, 'a'), 50);
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = vector->retainedSize(totalStringBufferSize);
+
+  EXPECT_EQ(
+      totalStringBufferSize,
+      vector->as<ConstantVector<StringView>>()->getStringBuffer()->capacity());
+  EXPECT_EQ(retainedSize, vector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, constantWithInlinedString) {
+  auto vector = makeConstant("short", 100);
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = vector->retainedSize(totalStringBufferSize);
+
+  EXPECT_EQ(totalStringBufferSize, 0);
+  EXPECT_EQ(retainedSize, vector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, constantWithValueVector) {
+  auto valueVector = makeFlatVector<std::string>(
+      10, [&](auto /*row*/) { return std::string(100, 'a'); });
+  auto vector =
+      std::make_shared<ConstantVector<StringView>>(pool(), 100, 5, valueVector);
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = vector->retainedSize(totalStringBufferSize);
+
+  auto stringBuffer =
+      vector->as<ConstantVector<StringView>>()->getStringBuffer();
+  EXPECT_TRUE(stringBuffer != nullptr);
+  EXPECT_EQ(totalStringBufferSize, stringBuffer->capacity());
+  EXPECT_EQ(retainedSize, vector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, dictionaryWithStrings) {
+  auto baseVector = makeFlatVector<std::string>(
+      1'000, [&](auto /*row*/) { return std::string(100, 'a'); });
+  auto indices = makeIndices(100, folly::identity);
+  auto dictVector = wrapInDictionary(indices, 100, baseVector);
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = dictVector->retainedSize(totalStringBufferSize);
+
+  uint64_t expectedBufferSize = getTotalStringBufferSize(baseVector);
+
+  EXPECT_EQ(totalStringBufferSize, expectedBufferSize);
+  EXPECT_EQ(retainedSize, dictVector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, dictionaryNoStrings) {
+  auto baseVector = makeFlatVector<int32_t>(1'000, folly::identity);
+  auto indices = makeIndices(100, folly::identity);
+  auto dictVector = wrapInDictionary(indices, 100, baseVector);
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = dictVector->retainedSize(totalStringBufferSize);
+
+  EXPECT_EQ(totalStringBufferSize, 0);
+  EXPECT_EQ(retainedSize, dictVector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, rowVectorMultipleStringChildren) {
+  auto longStringAt = [&](auto /*row*/) { return std::string(100, 'a'); };
+
+  auto rowVector = makeRowVector({
+      makeFlatVector<std::string>(1'000, longStringAt),
+      makeFlatVector<int32_t>(1'000, folly::identity),
+      makeFlatVector<std::string>(1'000, longStringAt),
+  });
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = rowVector->retainedSize(totalStringBufferSize);
+  uint64_t expectedBufferSize =
+      getTotalStringBufferSize(rowVector->childAt(0)) +
+      getTotalStringBufferSize(rowVector->childAt(2));
+
+  EXPECT_EQ(totalStringBufferSize, expectedBufferSize);
+  EXPECT_EQ(retainedSize, rowVector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, arrayWithStringElements) {
+  auto arrayVector = makeArrayVector<std::string>(
+      1'000,
+      [](auto /*row*/) { return 3; },
+      [&](auto /*row*/) { return std::string(100, 'a'); });
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = arrayVector->retainedSize(totalStringBufferSize);
+  uint64_t expectedBufferSize =
+      getTotalStringBufferSize(arrayVector->elements());
+
+  EXPECT_EQ(totalStringBufferSize, expectedBufferSize);
+  EXPECT_EQ(retainedSize, arrayVector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, arrayNoStrings) {
+  auto arrayVector = makeArrayVector<int32_t>(
+      1'000,
+      [](auto /*row*/) { return 3; },
+      [](auto row, auto index) { return row + index; });
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = arrayVector->retainedSize(totalStringBufferSize);
+
+  EXPECT_EQ(totalStringBufferSize, 0);
+  EXPECT_EQ(retainedSize, arrayVector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, mapWithStringKeysAndValues) {
+  auto longStringAt = [&](auto /*row*/) { return std::string(100, 'a'); };
+
+  auto mapVector = makeMapVector<std::string, std::string>(
+      1'000, [](auto /*row*/) { return 2; }, longStringAt, longStringAt);
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = mapVector->retainedSize(totalStringBufferSize);
+  uint64_t expectedBufferSize = getTotalStringBufferSize(mapVector->mapKeys()) +
+      getTotalStringBufferSize(mapVector->mapValues());
+
+  EXPECT_EQ(totalStringBufferSize, expectedBufferSize);
+  EXPECT_EQ(retainedSize, mapVector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, nestedComplexWithStrings) {
+  auto innerArray = makeArrayVector<std::string>(
+      1'000,
+      [](auto /*row*/) { return 2; },
+      [&](auto /*row*/) { return std::string(100, 'a'); });
+
+  auto outerArray = makeArrayVector({0, 10, 20}, innerArray);
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = outerArray->retainedSize(totalStringBufferSize);
+  uint64_t expectedBufferSize = getTotalStringBufferSize(
+      outerArray->elements()->as<ArrayVector>()->elements());
+
+  EXPECT_EQ(totalStringBufferSize, expectedBufferSize);
+  EXPECT_EQ(retainedSize, outerArray->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, lazyNotLoaded) {
+  auto lazyVector = std::make_shared<LazyVector>(
+      pool(),
+      VARCHAR(),
+      100,
+      std::make_unique<test::SimpleVectorLoader>([&](auto /*rows*/) {
+        return makeFlatVector<std::string>(
+            100, [&](auto /*row*/) { return std::string(100, 'a'); });
+      }));
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = lazyVector->retainedSize(totalStringBufferSize);
+
+  EXPECT_EQ(totalStringBufferSize, 0);
+  EXPECT_EQ(retainedSize, lazyVector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, lazyLoaded) {
+  auto lazyVector = std::make_shared<LazyVector>(
+      pool(),
+      VARCHAR(),
+      100,
+      std::make_unique<test::SimpleVectorLoader>([&](auto /*rows*/) {
+        return makeFlatVector<std::string>(
+            100, [&](auto /*row*/) { return std::string(100, 'a'); });
+      }));
+
+  SelectivityVector rows(100);
+  LazyVector::ensureLoadedRows(lazyVector, rows);
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = lazyVector->retainedSize(totalStringBufferSize);
+  uint64_t expectedBufferSize =
+      getTotalStringBufferSize(lazyVector->loadedVectorShared());
+
+  EXPECT_EQ(totalStringBufferSize, expectedBufferSize);
+  EXPECT_EQ(retainedSize, lazyVector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, sharedStringBuffers) {
+  auto baseVector = makeFlatVector<std::string>(
+      1'000, [&](auto /*row*/) { return std::string(100, 'a'); });
+
+  auto indices = makeIndices(100, folly::identity);
+  std::vector<VectorPtr> dictionaries;
+  dictionaries.emplace_back(wrapInDictionary(indices, 100, baseVector));
+  dictionaries.emplace_back(wrapInDictionary(indices, 100, baseVector));
+
+  auto expectedBufferSize = getTotalStringBufferSize(baseVector);
+  for (auto& dictVector : dictionaries) {
+    uint64_t totalStringBufferSize = 0;
+    auto retainedSize = dictVector->retainedSize(totalStringBufferSize);
+
+    EXPECT_EQ(totalStringBufferSize, expectedBufferSize);
+    EXPECT_EQ(retainedSize, dictVector->retainedSize());
+  }
+}
+
+} // namespace facebook::velox::test
diff --git a/velox/vector/tests/VectorSaverTest.cpp b/velox/vector/tests/VectorSaverTest.cpp
index 11cdd8fac40..ef010f55d84 100644
--- a/velox/vector/tests/VectorSaverTest.cpp
+++ b/velox/vector/tests/VectorSaverTest.cpp
@@ -17,8 +17,8 @@
 #include <fstream>
 #include "velox/common/base/Fs.h"
 #include "velox/common/base/tests/GTestUtils.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
-#include "velox/exec/tests/utils/TempFilePath.h"
+#include "velox/common/testutil/TempDirectoryPath.h"
+#include "velox/common/testutil/TempFilePath.h"
 #include "velox/functions/prestosql/types/HyperLogLogRegistration.h"
 #include "velox/functions/prestosql/types/HyperLogLogType.h"
 #include "velox/functions/prestosql/types/JsonRegistration.h"
@@ -30,6 +30,8 @@
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
+using namespace facebook::velox::common::testutil;
+
 namespace facebook::velox::test {
 
 class VectorSaverTest : public testing::Test, public VectorTestBase {
@@ -124,7 +126,7 @@ class VectorSaverTest : public testing::Test, public VectorTestBase {
   // Writes the passed vector to file and reads it back, returns the read
   // vector.
   VectorPtr takeRoundTrip(const VectorPtr& vector) {
-    auto path = exec::test::TempFilePath::create();
+    auto path = TempFilePath::create();
 
     std::ofstream outputFile(path->getPath(), std::ofstream::binary);
     saveVector(*vector, outputFile);
@@ -143,7 +145,7 @@ class VectorSaverTest : public testing::Test, public VectorTestBase {
   }
 
   void testTypeRoundTrip(const TypePtr& type) {
-    auto path = exec::test::TempFilePath::create();
+    auto path = TempFilePath::create();
 
     std::ofstream outputFile(path->getPath(), std::ofstream::binary);
     saveType(type, outputFile);
@@ -352,8 +354,9 @@ TEST_F(VectorSaverTest, flatBoolean) {
   testRoundTrip(makeFlatVector<bool>({true, false, true, true, false}));
 
   // Some nulls.
-  testRoundTrip(makeNullableFlatVector<bool>(
-      {true, std::nullopt, true, std::nullopt, false}));
+  testRoundTrip(
+      makeNullableFlatVector<bool>(
+          {true, std::nullopt, true, std::nullopt, false}));
 
   // Empty vector.
   testRoundTrip(BaseVector::create(BOOLEAN(), 0, pool()));
@@ -363,8 +366,9 @@ TEST_F(VectorSaverTest, flatBoolean) {
       makeFlatVector<bool>(10'000, [](auto row) { return row % 7 == 2; }));
 
   // Long vector with nulls.
-  testRoundTrip(makeFlatVector<bool>(
-      10'000, [](auto row) { return row % 2 == 1; }, nullEvery(17)));
+  testRoundTrip(
+      makeFlatVector<bool>(
+          10'000, [](auto row) { return row % 2 == 1; }, nullEvery(17)));
 }
 
 TEST_F(VectorSaverTest, flatVarchar) {
@@ -566,14 +570,15 @@ TEST_F(VectorSaverTest, dictionaryArray) {
   auto offsets = makeEvenIndices(64);
   auto sizes = makeIndices(64, [](auto /* row */) { return 2; });
 
-  testRoundTrip(std::make_shared<ArrayVector>(
-      pool(),
-      ARRAY(INTEGER()),
-      makeNulls(64, nullEvery(7)),
-      64,
-      offsets,
-      sizes,
-      elementsVector));
+  testRoundTrip(
+      std::make_shared<ArrayVector>(
+          pool(),
+          ARRAY(INTEGER()),
+          makeNulls(64, nullEvery(7)),
+          64,
+          offsets,
+          sizes,
+          elementsVector));
 }
 
 TEST_F(VectorSaverTest, dictionaryMap) {
@@ -643,7 +648,7 @@ struct VectorSaverInfo {
 /// A demonstration of using VectorSaver to save 'current' vector being
 /// processed to disk in case of an exception.
 TEST_F(VectorSaverTest, exceptionContext) {
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  auto tempDirectory = TempDirectoryPath::create();
 
   auto messageFunction = [](VeloxException::Type /*exceptionType*/,
                             auto* arg) -> std::string {
@@ -709,4 +714,13 @@ TEST_F(VectorSaverTest, multipleVectors) {
 
   ASSERT_EQ(out.str().size(), in.tellg());
 }
+TEST_F(VectorSaverTest, corruptStringSize) {
+  // The read<std::string> function reads int32_t size then resizes a string.
+  // A negative size must throw instead of crashing via std::terminate.
+  int32_t badSize = -1;
+  std::string data(reinterpret_cast<const char*>(&badSize), sizeof(badSize));
+  std::istringstream in(data);
+  VELOX_ASSERT_THROW(restoreVector(in, pool()), "");
+}
+
 } // namespace facebook::velox::test
diff --git a/velox/vector/tests/VectorStreamGroupTest.cpp b/velox/vector/tests/VectorStreamGroupTest.cpp
index 55e0009d524..39e75d79d62 100644
--- a/velox/vector/tests/VectorStreamGroupTest.cpp
+++ b/velox/vector/tests/VectorStreamGroupTest.cpp
@@ -27,28 +27,27 @@
 
 namespace facebook::velox {
 namespace {
-class VectorStreamGroupTest
-    : public testing::Test,
-      public velox::test::VectorTestBase,
-      public testing::WithParamInterface<VectorSerde::Kind> {
+class VectorStreamGroupTest : public testing::Test,
+                              public velox::test::VectorTestBase,
+                              public testing::WithParamInterface<std::string> {
  protected:
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   }
 
   void SetUp() override {
-    if (isRegisteredNamedVectorSerde(VectorSerde::Kind::kPresto)) {
-      deregisterNamedVectorSerde(VectorSerde::Kind::kPresto);
+    if (isRegisteredNamedVectorSerde("Presto")) {
+      deregisterNamedVectorSerde("Presto");
     }
     serializer::presto::PrestoVectorSerde::registerNamedVectorSerde();
 
-    if (isRegisteredNamedVectorSerde(VectorSerde::Kind::kCompactRow)) {
-      deregisterNamedVectorSerde(VectorSerde::Kind::kCompactRow);
+    if (isRegisteredNamedVectorSerde("CompactRow")) {
+      deregisterNamedVectorSerde("CompactRow");
     }
     serializer::CompactRowVectorSerde::registerNamedVectorSerde();
 
-    if (isRegisteredNamedVectorSerde(VectorSerde::Kind::kUnsafeRow)) {
-      deregisterNamedVectorSerde(VectorSerde::Kind::kUnsafeRow);
+    if (isRegisteredNamedVectorSerde("UnsafeRow")) {
+      deregisterNamedVectorSerde("UnsafeRow");
     }
     serializer::spark::UnsafeRowVectorSerde::registerNamedVectorSerde();
   }
@@ -89,7 +88,7 @@ TEST_P(VectorStreamGroupTest, clear) {
   OStreamOutputStream outputStream(&output);
   vectorGroup.flush(&outputStream);
   vectorGroup.clear();
-  if (GetParam() == VectorSerde::Kind::kPresto) {
+  if (GetParam() == "Presto") {
     // We expect two pages for header after clear.
     ASSERT_EQ(
         vectorGroup.size(),
@@ -114,9 +113,9 @@ TEST_P(VectorStreamGroupTest, clear) {
 VELOX_INSTANTIATE_TEST_SUITE_P(
     VectorStreamGroupTest,
     VectorStreamGroupTest,
-    testing::ValuesIn(
-        {VectorSerde::Kind::kPresto,
-         VectorSerde::Kind::kCompactRow,
-         VectorSerde::Kind::kUnsafeRow}));
+    testing::Values(
+        std::string("Presto"),
+        std::string("CompactRow"),
+        std::string("UnsafeRow")));
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/vector/tests/VectorStreamTest.cpp b/velox/vector/tests/VectorStreamTest.cpp
index d80fcf8d1e0..5c8043b6b08 100644
--- a/velox/vector/tests/VectorStreamTest.cpp
+++ b/velox/vector/tests/VectorStreamTest.cpp
@@ -23,7 +23,7 @@ namespace facebook::velox::test {
 
 class MockVectorSerde : public VectorSerde {
  public:
-  MockVectorSerde() : VectorSerde(VectorSerde::Kind::kPresto) {}
+  MockVectorSerde() : VectorSerde("Presto") {}
 
   void estimateSerializedSize(
       const BaseVector* /*vector*/,
@@ -71,7 +71,7 @@ TEST(VectorStreamTest, serdeRegistration) {
 }
 
 TEST(VectorStreamTest, namedSerdeRegistration) {
-  const VectorSerde::Kind kind = VectorSerde::Kind::kPresto;
+  const std::string kind = "Presto";
 
   // Nothing registered yet.
   deregisterNamedVectorSerde(kind);
@@ -87,7 +87,7 @@ TEST(VectorStreamTest, namedSerdeRegistration) {
   EXPECT_NE(serde, nullptr);
   EXPECT_NE(dynamic_cast<MockVectorSerde*>(serde), nullptr);
 
-  const VectorSerde::Kind otherKind = VectorSerde::Kind::kUnsafeRow;
+  const std::string otherKind = "UnsafeRow";
   EXPECT_FALSE(isRegisteredNamedVectorSerde(otherKind));
   VELOX_ASSERT_THROW(
       getNamedVectorSerde(otherKind),
diff --git a/velox/vector/tests/VectorTest.cpp b/velox/vector/tests/VectorTest.cpp
index 64f088e5a8f..8ebca2d10cd 100644
--- a/velox/vector/tests/VectorTest.cpp
+++ b/velox/vector/tests/VectorTest.cpp
@@ -22,8 +22,10 @@
 #include <optional>
 
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/fuzzer/Utils.h"
 #include "velox/common/memory/ByteStream.h"
 #include "velox/common/testutil/OptionalEmpty.h"
+#include "velox/common/testutil/TestValue.h"
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/vector/BaseVector.h"
 #include "velox/vector/ComplexVector.h"
@@ -117,6 +119,7 @@ class VectorTest : public testing::Test, public velox::test::VectorTestBase {
  protected:
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+    common::testutil::TestValue::enable();
   }
 
   void SetUp() override {
@@ -296,6 +299,24 @@ class VectorTest : public testing::Test, public velox::test::VectorTestBase {
       EXPECT_EQ(flat->valueAt(size * 2 - 1).size(), 0);
     }
 
+// This part of the test relies on TestValues to inject a failure, these are
+// only enabled in debug builds.
+#ifndef NDEBUG
+    {
+      // Make a copy so we don't modify the original Vector.
+      const auto slice = flat->slice(0, flat->size());
+
+      const std::string errorMessage = "Simulated failure in memory allocation";
+      SCOPED_TESTVALUE_SET(
+          "facebook::velox::FlatVector::resizeValues",
+          std::function<void(FlatVector<T>*)>(
+              [&](FlatVector<T>*) { VELOX_FAIL(errorMessage); }));
+
+      VELOX_ASSERT_THROW(slice->resize(slice->size() * 2), errorMessage);
+      slice->validate();
+    }
+#endif
+
     // Fill, the values at size * 2 - 1 gets assigned a second time.
     for (int32_t i = 0; i < flat->size(); ++i) {
       if (withNulls && i % 3 == 0) {
@@ -668,11 +689,12 @@ class VectorTest : public testing::Test, public velox::test::VectorTestBase {
       int level,
       vector_size_t offset,
       vector_size_t length) {
-    SCOPED_TRACE(fmt::format(
-        "testSlice encoding={} offset={} length={}",
-        vec->encoding(),
-        offset,
-        length));
+    SCOPED_TRACE(
+        fmt::format(
+            "testSlice encoding={} offset={} length={}",
+            vec->encoding(),
+            offset,
+            length));
     ASSERT_GE(vec->size(), offset + length);
     auto slice = vec->loadedVector()->slice(offset, length);
     ASSERT_EQ(slice->size(), length);
@@ -748,14 +770,17 @@ class VectorTest : public testing::Test, public velox::test::VectorTestBase {
       // immutable. This is true for a slice since it creates buffer views over
       // the buffers of the original vector that it sliced.
       auto newSize = slice->size() * 2;
+      auto sliceCopy = BaseVector::copy(*slice);
       slice->resize(newSize);
       EXPECT_EQ(slice->size(), newSize);
+      slice->resize(sliceCopy->size());
+      test::assertEqualVectors(slice, sliceCopy);
     }
   }
 
   static void testSlices(const VectorPtr& slice, int level = 2) {
     for (vector_size_t offset : {0, 16, 17}) {
-      for (vector_size_t length : {0, 1, 83}) {
+      for (vector_size_t length : {0, 1, 83, 100}) {
         if (offset + length <= slice->size()) {
           testSlice(slice, level, offset, length);
         }
@@ -1950,6 +1975,8 @@ TEST_F(VectorCreateConstantTest, complex) {
   testComplexConstant<TypeKind::ROW>(
       ROW({{"c0", INTEGER()}}),
       makeRowVector({makeFlatVector<int32_t>(1, [](auto i) { return i; })}));
+
+  testComplexConstant<TypeKind::ROW>(ROW({}), makeRowVector(ROW({}), 1));
 }
 
 TEST_F(VectorCreateConstantTest, null) {
@@ -1973,6 +2000,7 @@ TEST_F(VectorCreateConstantTest, null) {
   testNullConstant<TypeKind::VARBINARY>(VARBINARY());
 
   testNullConstant<TypeKind::ROW>(ROW({BIGINT(), REAL()}));
+  testNullConstant<TypeKind::ROW>(ROW({}));
   testNullConstant<TypeKind::ARRAY>(ARRAY(DOUBLE()));
   testNullConstant<TypeKind::MAP>(MAP(INTEGER(), DOUBLE()));
 }
@@ -2228,8 +2256,9 @@ TEST_F(VectorTest, nestedLazy) {
 
   // Verify that the unloaded dictionary can be nested as long as it has one top
   // level vector.
-  EXPECT_NO_THROW(BaseVector::wrapInDictionary(
-      nullptr, makeIndices(size, indexAt), size, dict));
+  EXPECT_NO_THROW(
+      BaseVector::wrapInDictionary(
+          nullptr, makeIndices(size, indexAt), size, dict));
 
   // Limitation: Current checks cannot prevent existing references of the lazy
   // vector to load rows. For example, the following would succeed even though
@@ -2678,14 +2707,16 @@ TEST_F(VectorTest, testCopyWithZeroCount) {
   runTest(makeFlatVector<int32_t>({1, 2}));
 
   // Complex types.
-  runTest(makeArrayVector<int32_t>(
-      1, [](auto) { return 10; }, [](auto i) { return i; }));
+  runTest(
+      makeArrayVector<int32_t>(
+          1, [](auto) { return 10; }, [](auto i) { return i; }));
 
-  runTest(makeMapVector<int32_t, float>(
-      1,
-      [](auto) { return 10; },
-      [](auto i) { return i; },
-      [](auto i) { return i; }));
+  runTest(
+      makeMapVector<int32_t, float>(
+          1,
+          [](auto) { return 10; },
+          [](auto i) { return i; },
+          [](auto i) { return i; }));
 
   runTest(
       makeRowVector({makeFlatVector<int32_t>(1, [](auto i) { return i; })}));
@@ -2719,24 +2750,43 @@ TEST_F(VectorTest, flattenVector) {
 
   VectorPtr lazy = std::make_shared<LazyVector>(
       pool(), INTEGER(), flat->size(), std::make_unique<TestingLoader>(flat));
-  test(lazy, true);
+  test(lazy, false);
 
-  // Constant
+  // Constant.
   VectorPtr constant = BaseVector::wrapInConstant(100, 1, flat);
   test(constant, false);
   EXPECT_TRUE(constant->isFlatEncoding());
 
-  // Dictionary
+  // Dictionary.
   VectorPtr dictionary = BaseVector::wrapInDictionary(
       nullptr, makeIndices(100, [](auto row) { return row % 2; }), 100, flat);
   test(dictionary, false);
   EXPECT_TRUE(dictionary->isFlatEncoding());
 
+  // Lazy dictionary.
   VectorPtr lazyDictionary =
       wrapInLazyDictionary(makeFlatVector<int32_t>({1, 2, 3}));
-  test(lazyDictionary, true);
-  EXPECT_TRUE(lazyDictionary->isLazy());
-  EXPECT_TRUE(lazyDictionary->loadedVector()->isFlatEncoding());
+  test(lazyDictionary, false);
+  EXPECT_TRUE(lazyDictionary->isFlatEncoding());
+
+  // Lazy dictionary row, where children are also lazy dictionaries.
+  VectorPtr rowWithLazyDictionaryChildren = wrapInLazyDictionary(makeRowVector(
+      {wrapInLazyDictionary(makeFlatVector<int32_t>({1, 2, 3})),
+       wrapInLazyDictionary(array),
+       wrapInLazyDictionary(map)}));
+  test(rowWithLazyDictionaryChildren, false);
+  EXPECT_EQ(
+      rowWithLazyDictionaryChildren->encoding(), VectorEncoding::Simple::ROW);
+  RowVector* rowWithLazyDictionaryChildrenRowVector =
+      rowWithLazyDictionaryChildren->as<RowVector>();
+  EXPECT_TRUE(
+      rowWithLazyDictionaryChildrenRowVector->childAt(0)->isFlatEncoding());
+  EXPECT_EQ(
+      rowWithLazyDictionaryChildrenRowVector->childAt(1)->encoding(),
+      VectorEncoding::Simple::ARRAY);
+  EXPECT_EQ(
+      rowWithLazyDictionaryChildrenRowVector->childAt(2)->encoding(),
+      VectorEncoding::Simple::MAP);
 
   // Array with constant elements.
   auto* arrayVector = array->as<ArrayVector>();
@@ -4268,5 +4318,335 @@ TEST_F(VectorTest, estimateFlatSize) {
   // Test that the second call to prepareForReuse will not cause crash
   arrayVector->prepareForReuse();
 }
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+TEST_F(VectorTest, transferOrCopyTo) {
+  auto rootPool = memory::memoryManager()->addRootPool("long-living");
+  auto pool = rootPool->addLeafChild("long-living leaf");
+  memory::MemoryManager anotherManager{memory::MemoryManager::Options{}};
+
+  VectorPtr vector;
+  VectorPtr expected;
+
+  // Test primitive type.
+  auto testPrimitive = [&](memory::MemoryManager* memoryManager) {
+    std::vector<int64_t> c0;
+    std::vector<std::string> c1;
+    {
+      auto localRootPool = memoryManager->addRootPool("short-living");
+      auto localPool = localRootPool->addLeafChild("short-living leaf");
+      FuzzerGenerator rng{123};
+      std::wstring_convert<std::codecvt_utf8<char16_t>, char16_t> converter;
+      for (auto i = 0; i < 1000; ++i) {
+        c0.push_back(fuzzer::rand<int64_t>(rng, fuzzer::DataSpec{}));
+        std::string buf;
+        fuzzer::randString(
+            rng,
+            fuzzer::rand<uint64_t>(rng, 0, 100),
+            {fuzzer::UTF8CharList::ASCII,
+             fuzzer::UTF8CharList::UNICODE_CASE_SENSITIVE,
+             fuzzer::UTF8CharList::EXTENDED_UNICODE},
+            buf,
+            converter);
+        c1.push_back(buf);
+      }
+      test::VectorMaker maker{localPool.get()};
+      vector = maker.rowVector(
+          {maker.flatVector<int64_t>(c0), maker.flatVector<std::string>(c1)});
+      vector->transferOrCopyTo(pool.get());
+    }
+    ASSERT_EQ(vector->pool(), pool.get());
+    test::VectorMaker maker{pool.get()};
+    expected = maker.rowVector(
+        {maker.flatVector<int64_t>(c0), maker.flatVector<std::string>(c1)});
+    test::assertEqualVectors(expected, vector);
+  };
+  testPrimitive(memory::memoryManager());
+  testPrimitive(&anotherManager);
+
+  // Test complex type.
+  auto testComplex = [&](memory::MemoryManager* memoryManager) {
+    {
+      auto localRootPool = memoryManager->addRootPool("short-living");
+      auto localPool = localRootPool->addLeafChild("short-living leaf");
+      test::VectorMaker maker{localPool.get()};
+      vector = maker.rowVector(
+          {maker.flatVector<double>(
+               3,
+               [](auto row) { return row; },
+               [](auto row) { return row == 2; }),
+           maker.constantVector<bool>({true, true, true}),
+           maker.dictionaryVector<int64_t>({1, std::nullopt, 1}),
+           maker.arrayVector<int64_t>(
+               3,
+               [](auto row) { return row; },
+               [](auto row) { return row; },
+               [](auto row) { return row == 0; },
+               [](auto row) { return row == 1; }),
+           maker.mapVector<int64_t, int64_t>(
+               3,
+               [](auto row) { return row; },
+               [](auto row) { return row; },
+               [](auto row) { return row + 1; },
+               [](auto row) { return row == 1; },
+               [](auto row) { return row == 2; })});
+      expected = BaseVector::copy(*vector, pool.get());
+      vector->transferOrCopyTo(pool.get());
+    }
+    ASSERT_EQ(vector->pool(), pool.get());
+    test::assertEqualVectors(expected, vector);
+  };
+  testComplex(memory::memoryManager());
+  testComplex(&anotherManager);
+
+  // Test with fuzzing.
+  // TODO: FlatMapVector doesn't support copy() yet. Add it later when it
+  // supports.
+  VectorFuzzer::Options options{
+      .nullRatio = 0.2,
+      .stringVariableLength = true,
+      .allowLazyVector = true,
+      .allowFlatMapVector = false};
+  const int kNumIterations = 500;
+  auto testFuzz = [&](memory::MemoryManager* memoryManager) {
+    for (auto i = 0; i < kNumIterations; ++i) {
+      {
+        auto localRootPool = memoryManager->addRootPool("short-living");
+        auto localPool = localRootPool->addLeafChild("short-living leaf");
+
+        VectorFuzzer fuzzer{options, localPool.get(), 123};
+        auto type = fuzzer.randType();
+        vector = fuzzer.fuzz(type);
+        expected = BaseVector::copy(*vector, pool.get());
+        vector->transferOrCopyTo(pool.get());
+      }
+      ASSERT_EQ(vector->pool(), pool.get());
+      test::assertEqualVectors(expected, vector);
+    }
+  };
+  testFuzz(memory::memoryManager());
+  testFuzz(&anotherManager);
+
+  // Test complex-typed vectors with buffers from different pools.
+  auto testBufferFromDifferentPools =
+      [&](memory::MemoryManager* memoryManager) {
+        VectorFuzzer fuzzer{options, pool.get(), 123};
+        for (auto i = 0; i < kNumIterations; ++i) {
+          {
+            auto localRootPool = memoryManager->addRootPool("short-living");
+            auto localPool = localRootPool->addLeafChild("short-living leaf");
+            VectorFuzzer localFuzzer{options, localPool.get(), 123};
+
+            auto type = fuzzer.randType();
+            auto elements = localFuzzer.fuzz(type);
+            auto arrays = fuzzer.fuzzArray(elements, 70);
+            fuzzer.setOptions({});
+            auto keys = fuzzer.fuzz(BIGINT());
+            fuzzer.setOptions(options);
+            auto maps = localFuzzer.fuzzMap(keys, arrays, 50);
+            vector = localFuzzer.fuzzRow({maps}, 50);
+
+            expected = BaseVector::copy(*vector, pool.get());
+            vector->transferOrCopyTo(pool.get());
+          }
+          ASSERT_EQ(vector->pool(), pool.get());
+          test::assertEqualVectors(expected, vector);
+        }
+      };
+  testBufferFromDifferentPools(memory::memoryManager());
+  testBufferFromDifferentPools(&anotherManager);
+
+  // Test opaque vector.
+  auto testOpaque = [&](memory::MemoryManager* memoryManager) {
+    {
+      auto localRootPool = memoryManager->addRootPool("short-living");
+      auto localPool = localRootPool->addLeafChild("short-living leaf");
+
+      auto type = OPAQUE<NonPOD>();
+      auto size = 100;
+      vector = BaseVector::create(type, size, localPool.get());
+      auto opaqueObj = std::make_shared<NonPOD>();
+      for (auto i = 0; i < size; ++i) {
+        vector->as<FlatVector<std::shared_ptr<void>>>()->set(i, opaqueObj);
+      }
+      expected = BaseVector::copy(*vector, pool.get());
+      vector->transferOrCopyTo(pool.get());
+    }
+    ASSERT_EQ(vector->pool(), pool.get());
+    test::assertEqualVectors(expected, vector);
+  };
+  testOpaque(memory::memoryManager());
+  testOpaque(&anotherManager);
+
+  auto testMemoryStats = [&options](size_t seed) {
+    auto localRoot1 = memory::memoryManager()->addRootPool("local root 1");
+    auto localLeaf1 = localRoot1->addLeafChild("local leaf 1");
+    auto localRoot2 = memory::memoryManager()->addRootPool("local root 2");
+    auto localLeaf2 = localRoot2->addLeafChild("local leaf 2");
+
+    EXPECT_EQ(localLeaf1->usedBytes(), 0);
+    EXPECT_EQ(localLeaf1->peakBytes(), 0);
+    EXPECT_EQ(localLeaf2->usedBytes(), 0);
+    EXPECT_EQ(localLeaf2->peakBytes(), 0);
+
+    VectorFuzzer fuzzer{options, localLeaf1.get(), seed};
+    auto size = fuzzer.randInRange(0, 10000);
+    auto type = fuzzer.randType();
+    auto vector = fuzzer.fuzz(type, size);
+    auto usedBytes = localLeaf1->usedBytes();
+    auto peakBytes = localLeaf1->peakBytes();
+
+    vector->transferOrCopyTo(localLeaf2.get());
+    EXPECT_LE(localLeaf2->usedBytes(), usedBytes);
+    EXPECT_LE(localLeaf2->peakBytes(), peakBytes);
+    if (localLeaf2->usedBytes() == 0) {
+      auto tmp = facebook::velox::isLazyNotLoaded(*vector) ||
+          vector->isConstantEncoding();
+      EXPECT_TRUE(tmp);
+    }
+    vector = nullptr;
+  };
+
+  for (auto i = 0; i < kNumIterations; ++i) {
+    testMemoryStats(kNumIterations * i + i);
+  }
+}
+#pragma GCC diagnostic pop
+
+TEST_F(VectorTest, createEmptyLikePrimitives) {
+  auto intVector = makeFlatVector<int32_t>({1, 2, 3});
+  auto emptyInt = BaseVector::createEmptyLike(intVector.get(), 10, pool());
+  EXPECT_EQ(emptyInt->size(), 10);
+  EXPECT_EQ(emptyInt->type()->kind(), TypeKind::INTEGER);
+  EXPECT_EQ(emptyInt->encoding(), VectorEncoding::Simple::FLAT);
+
+  auto stringVector = makeFlatVector<StringView>({"a"_sv, "b"_sv});
+  auto emptyString = BaseVector::createEmptyLike(stringVector.get(), 5, pool());
+  EXPECT_EQ(emptyString->size(), 5);
+  EXPECT_EQ(emptyString->type()->kind(), TypeKind::VARCHAR);
+  EXPECT_EQ(emptyString->encoding(), VectorEncoding::Simple::FLAT);
+}
+
+TEST_F(VectorTest, createEmptyLikeComplexTypes) {
+  auto rowVector = makeRowVector({
+      makeFlatVector<int64_t>({1, 2}),
+      makeFlatVector<StringView>({"a"_sv, "b"_sv}),
+  });
+  auto emptyRow =
+      BaseVector::createEmptyLike<RowVector>(rowVector.get(), 5, pool());
+  EXPECT_EQ(emptyRow->size(), 5);
+  EXPECT_EQ(emptyRow->type()->kind(), TypeKind::ROW);
+  EXPECT_EQ(emptyRow->childrenSize(), 2);
+  EXPECT_EQ(emptyRow->childAt(0)->size(), 5);
+  EXPECT_EQ(emptyRow->childAt(1)->size(), 5);
+
+  auto arrayVector = makeArrayVector<int32_t>({{1, 2}, {3}});
+  auto emptyArray =
+      BaseVector::createEmptyLike<ArrayVector>(arrayVector.get(), 3, pool());
+  EXPECT_EQ(emptyArray->size(), 3);
+  EXPECT_EQ(emptyArray->type()->kind(), TypeKind::ARRAY);
+  EXPECT_EQ(emptyArray->elements()->size(), 0);
+
+  auto mapVector = makeMapVector<int32_t, StringView>({{{1, "a"_sv}}});
+  auto emptyMap =
+      BaseVector::createEmptyLike<MapVector>(mapVector.get(), 4, pool());
+  EXPECT_EQ(emptyMap->size(), 4);
+  EXPECT_EQ(emptyMap->type()->kind(), TypeKind::MAP);
+  EXPECT_EQ(emptyMap->encoding(), VectorEncoding::Simple::MAP);
+  EXPECT_EQ(emptyMap->mapKeys()->size(), 0);
+  EXPECT_EQ(emptyMap->mapValues()->size(), 0);
+}
+
+TEST_F(VectorTest, createEmptyLikeFlatMap) {
+  auto flatMapVector = makeFlatMapVector<int64_t, int64_t>({
+      {{1, 10}, {2, 20}},
+      {{1, 30}},
+  });
+  EXPECT_EQ(flatMapVector->encoding(), VectorEncoding::Simple::FLAT_MAP);
+
+  auto emptyFlatMap =
+      BaseVector::createEmptyLike(flatMapVector.get(), 5, pool());
+  EXPECT_EQ(emptyFlatMap->size(), 5);
+  EXPECT_EQ(emptyFlatMap->type()->kind(), TypeKind::MAP);
+  EXPECT_EQ(emptyFlatMap->encoding(), VectorEncoding::Simple::FLAT_MAP);
+}
+
+TEST_F(VectorTest, createEmptyLikeNestedFlatMap) {
+  // ROW containing a FlatMapVector.
+  auto flatMapVector = makeFlatMapVector<int64_t, int64_t>({
+      {{1, 10}, {2, 20}},
+      {{3, 30}},
+  });
+  auto rowWithFlatMap = makeRowVector({
+      makeFlatVector<int64_t>({100, 200}),
+      flatMapVector,
+  });
+
+  auto emptyRow =
+      BaseVector::createEmptyLike<RowVector>(rowWithFlatMap.get(), 3, pool());
+  EXPECT_EQ(emptyRow->size(), 3);
+  EXPECT_EQ(emptyRow->childrenSize(), 2);
+  EXPECT_EQ(emptyRow->childAt(0)->encoding(), VectorEncoding::Simple::FLAT);
+  EXPECT_EQ(emptyRow->childAt(1)->encoding(), VectorEncoding::Simple::FLAT_MAP);
+
+  // ARRAY of FlatMapVector.
+  auto arrayType = ARRAY(MAP(BIGINT(), BIGINT()));
+  auto arrayOfFlatMaps = std::make_shared<ArrayVector>(
+      pool(),
+      arrayType,
+      nullptr,
+      2,
+      allocateOffsets(2, pool()),
+      allocateSizes(2, pool()),
+      flatMapVector);
+
+  auto emptyArray = BaseVector::createEmptyLike<ArrayVector>(
+      arrayOfFlatMaps.get(), 4, pool());
+  EXPECT_EQ(emptyArray->size(), 4);
+  EXPECT_EQ(
+      emptyArray->elements()->encoding(), VectorEncoding::Simple::FLAT_MAP);
+}
+
+TEST_F(VectorTest, createMapOfArraysVectorWithNullRows) {
+  // Row 0: {1 → [10, 20]}
+  // Row 1: null
+  // Row 2: {2 → [30]}
+  auto vector = createMapOfArraysVector<int64_t, int64_t>(
+      {{{1, {{10, 20}}}}, {}, {{2, {{30}}}}}, {1});
+
+  ASSERT_EQ(vector->size(), 3);
+  auto* map = vector->as<MapVector>();
+  ASSERT_NE(map, nullptr);
+
+  // Row 0: non-null, size 1.
+  EXPECT_FALSE(map->isNullAt(0));
+  EXPECT_EQ(map->sizeAt(0), 1);
+
+  // Row 1: null.
+  EXPECT_TRUE(map->isNullAt(1));
+
+  // Row 2: non-null, size 1.
+  EXPECT_FALSE(map->isNullAt(2));
+  EXPECT_EQ(map->sizeAt(2), 1);
+
+  // Verify keys and values.
+  auto* keys = map->mapKeys()->as<FlatVector<int64_t>>();
+  EXPECT_EQ(keys->valueAt(0), 1);
+  EXPECT_EQ(keys->valueAt(1), 2);
+
+  auto* arrays = map->mapValues()->as<ArrayVector>();
+  auto* elements = arrays->elements()->as<FlatVector<int64_t>>();
+
+  // Row 0, key 1 → [10, 20].
+  EXPECT_EQ(arrays->sizeAt(0), 2);
+  EXPECT_EQ(elements->valueAt(arrays->offsetAt(0)), 10);
+  EXPECT_EQ(elements->valueAt(arrays->offsetAt(0) + 1), 20);
+
+  // Row 2, key 2 → [30].
+  EXPECT_EQ(arrays->sizeAt(1), 1);
+  EXPECT_EQ(elements->valueAt(arrays->offsetAt(1)), 30);
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/vector/tests/VectorTestUtils.h b/velox/vector/tests/VectorTestUtils.h
index be04bb31010..d9e50583c7f 100644
--- a/velox/vector/tests/VectorTestUtils.h
+++ b/velox/vector/tests/VectorTestUtils.h
@@ -136,12 +136,13 @@ VectorGeneratedData<T> genTestData(
   testData.reserve(cardinality);
 
   for (int64_t m = 0; m < cardinality; m++) {
-    testData.push_back(VectorValueGenerator::cardValueOf<T>(
-        useFullTypeRange,
-        rng,
-        testData.stringViewBufferHolder(),
-        fixedWidthStringSize,
-        type));
+    testData.push_back(
+        VectorValueGenerator::cardValueOf<T>(
+            useFullTypeRange,
+            rng,
+            testData.stringViewBufferHolder(),
+            fixedWidthStringSize,
+            type));
   }
 
   if (includeNulls) {
diff --git a/velox/vector/tests/utils/CMakeLists.txt b/velox/vector/tests/utils/CMakeLists.txt
index 4d61ce356e6..9e7fbae65b6 100644
--- a/velox/vector/tests/utils/CMakeLists.txt
+++ b/velox/vector/tests/utils/CMakeLists.txt
@@ -12,6 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 add_library(velox_vector_test_lib VectorMaker.cpp VectorTestBase.cpp)
+velox_add_test_headers(
+  velox_vector_test_lib
+  VectorMaker-inl.h
+  VectorMaker.h
+  VectorMakerStats.h
+  VectorTestBase.h
+)
 
 target_link_libraries(
   velox_vector_test_lib
diff --git a/velox/vector/tests/utils/VectorMaker.cpp b/velox/vector/tests/utils/VectorMaker.cpp
index bdd175baa1a..cfc5ffbbba9 100644
--- a/velox/vector/tests/utils/VectorMaker.cpp
+++ b/velox/vector/tests/utils/VectorMaker.cpp
@@ -247,26 +247,45 @@ MapVectorPtr VectorMaker::mapVector(
     const std::vector<vector_size_t>& nulls) {
   VELOX_CHECK_EQ(keys->size(), values->size());
 
+  // Derive sizes from consecutive offsets.
   const auto size = offsets.size();
-  BufferPtr offsetsBuffer = allocateOffsets(size, pool_);
-  BufferPtr sizesBuffer = allocateSizes(size, pool_);
-  BufferPtr nullsBuffer = nullptr;
-  auto rawOffsets = offsetsBuffer->asMutable<vector_size_t>();
-  auto rawSizes = sizesBuffer->asMutable<vector_size_t>();
-
-  for (int i = 0; i < size - 1; i++) {
-    rawSizes[i] = offsets[i + 1] - offsets[i];
+  std::vector<vector_size_t> sizes(size);
+  for (size_t i = 0; i + 1 < size; ++i) {
+    sizes[i] = offsets[i + 1] - offsets[i];
+  }
+  if (size > 0) {
+    sizes.back() = keys->size() - offsets.back();
   }
-  rawSizes[size - 1] = keys->size() - offsets.back();
 
-  memcpy(rawOffsets, offsets.data(), size * sizeof(vector_size_t));
+  return mapVector(offsets, sizes, keys, values, nulls);
+}
 
+MapVectorPtr VectorMaker::mapVector(
+    const std::vector<vector_size_t>& offsets,
+    const std::vector<vector_size_t>& sizes,
+    const VectorPtr& keys,
+    const VectorPtr& values,
+    const std::vector<vector_size_t>& nulls) {
+  VELOX_CHECK_EQ(offsets.size(), sizes.size());
+
+  const auto numRows = offsets.size();
+  BufferPtr offsetsBuffer = allocateOffsets(numRows, pool_);
+  BufferPtr sizesBuffer = allocateSizes(numRows, pool_);
+  memcpy(
+      offsetsBuffer->asMutable<vector_size_t>(),
+      offsets.data(),
+      numRows * sizeof(vector_size_t));
+  memcpy(
+      sizesBuffer->asMutable<vector_size_t>(),
+      sizes.data(),
+      numRows * sizeof(vector_size_t));
+
+  BufferPtr nullsBuffer = nullptr;
   if (!nulls.empty()) {
-    nullsBuffer = AlignedBuffer::allocate<bool>(size, pool_, bits::kNotNull);
+    nullsBuffer = allocateNulls(numRows, pool_);
     auto rawNulls = nullsBuffer->asMutable<uint64_t>();
-
-    for (int i = 0; i < nulls.size(); i++) {
-      bits::setNull(rawNulls, nulls[i]);
+    for (const auto idx : nulls) {
+      bits::setNull(rawNulls, idx);
     }
   }
 
@@ -274,7 +293,7 @@ MapVectorPtr VectorMaker::mapVector(
       pool_,
       MAP(keys->type(), values->type()),
       nullsBuffer,
-      size,
+      numRows,
       offsetsBuffer,
       sizesBuffer,
       keys,
diff --git a/velox/vector/tests/utils/VectorMaker.h b/velox/vector/tests/utils/VectorMaker.h
index ffe35bd9332..c6df651e329 100644
--- a/velox/vector/tests/utils/VectorMaker.h
+++ b/velox/vector/tests/utils/VectorMaker.h
@@ -945,8 +945,9 @@ class VectorMaker {
           if (it == keysMap.end()) {
             keysMap.insert({key, keyChannel++});
             flatKeys.push_back(key);
-            values.push_back(BaseVector::create(
-                mapVector->type()->childAt(1), mapVector->size(), pool_));
+            values.push_back(
+                BaseVector::create(
+                    mapVector->type()->childAt(1), mapVector->size(), pool_));
 
             // We allocate a new inMaps buffer, setting "not in map" by default.
             // Then set the current key to in map.
@@ -1049,6 +1050,17 @@ class VectorMaker {
       const VectorPtr& values,
       const std::vector<vector_size_t>& nulls = {});
 
+  /// Create a MapVector from explicit offsets, sizes, and key/value vectors.
+  /// Unlike the offsets-only overload above, this allows non-consecutive or
+  /// out-of-order offsets (e.g. for testing vectors produced by filters or
+  /// slices). An optional nulls vector specifies which row indices are null.
+  MapVectorPtr mapVector(
+      const std::vector<vector_size_t>& offsets,
+      const std::vector<vector_size_t>& sizes,
+      const VectorPtr& keys,
+      const VectorPtr& values,
+      const std::vector<vector_size_t>& nulls = {});
+
  private:
   vector_size_t createOffsetsAndSizes(
       vector_size_t size,
diff --git a/velox/vector/tests/utils/VectorTestBase.cpp b/velox/vector/tests/utils/VectorTestBase.cpp
index d0a172f2023..f47383bcada 100644
--- a/velox/vector/tests/utils/VectorTestBase.cpp
+++ b/velox/vector/tests/utils/VectorTestBase.cpp
@@ -121,13 +121,15 @@ std::vector<RowVectorPtr> VectorTestBase::split(
 
   vector_size_t offset = 0;
   for (auto i = 0; i < n - 1; ++i) {
-    vectors.push_back(std::dynamic_pointer_cast<RowVector>(
-        vector->slice(offset, numRowsPerVector)));
+    vectors.push_back(
+        std::dynamic_pointer_cast<RowVector>(
+            vector->slice(offset, numRowsPerVector)));
     offset += numRowsPerVector;
   }
 
-  vectors.push_back(std::dynamic_pointer_cast<RowVector>(
-      vector->slice(offset, numRows - offset)));
+  vectors.push_back(
+      std::dynamic_pointer_cast<RowVector>(
+          vector->slice(offset, numRows - offset)));
   return vectors;
 }
 
diff --git a/velox/vector/tests/utils/VectorTestBase.h b/velox/vector/tests/utils/VectorTestBase.h
index 5f75a32e9c6..5c22905634b 100644
--- a/velox/vector/tests/utils/VectorTestBase.h
+++ b/velox/vector/tests/utils/VectorTestBase.h
@@ -17,6 +17,7 @@
 
 #include <folly/Executor.h>
 #include <folly/executors/CPUThreadPoolExecutor.h>
+#include <folly/system/HardwareConcurrency.h>
 
 #include "velox/common/base/RuntimeMetrics.h"
 #include "velox/vector/FlatVector.h"
@@ -24,6 +25,7 @@
 
 #include <gtest/gtest.h>
 #include <optional>
+#include <unordered_set>
 #include "velox/type/CppToType.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
@@ -662,6 +664,18 @@ class VectorTestBase {
     return vectorMaker_.mapVector(offsets, keyVector, valueVector, nulls);
   }
 
+  // Creates a MapVector with explicit offsets and sizes, allowing
+  // non-consecutive or out-of-order layouts in the underlying key/value arrays.
+  MapVectorPtr makeMapVector(
+      const std::vector<vector_size_t>& offsets,
+      const std::vector<vector_size_t>& sizes,
+      const VectorPtr& keyVector,
+      const VectorPtr& valueVector,
+      const std::vector<vector_size_t>& nulls = {}) {
+    return vectorMaker_.mapVector(
+        offsets, sizes, keyVector, valueVector, nulls);
+  }
+
   MapVectorPtr makeAllNullMapVector(
       vector_size_t size,
       const TypePtr& keyType,
@@ -679,7 +693,7 @@ class VectorTestBase {
       vector_size_t size,
       const TypePtr& type = CppToType<EvalType<T>>::create()) {
     return std::make_shared<ConstantVector<EvalType<T>>>(
-        pool(), size, false, type, std::move(value));
+        pool(), size, false, type, EvalType<T>(value));
   }
 
   template <typename T>
@@ -755,15 +769,24 @@ class VectorTestBase {
   //      {{{1, std::nullopt}},
   //       {{2, {{4, 5, std::nullopt}}}},
   //       {{std::nullopt, {{7, 8, 9}}}}});
+  //
+  // Null map rows are supported via the nullRows parameter:
+  //    createMapOfArraysVector<int64_t, int64_t>(
+  //      {{{1, {{1, 2}}}}, {}, {{3, {{7, 8, 9}}}}},
+  //      {1}); // row 1 is null
   template <typename K, typename V>
   VectorPtr createMapOfArraysVector(
       std::vector<std::map<
           std::optional<K>,
-          std::optional<std::vector<std::optional<V>>>>> maps) {
+          std::optional<std::vector<std::optional<V>>>>> maps,
+      std::unordered_set<vector_size_t> nullRows = {}) {
     std::vector<std::optional<K>> keys;
     std::vector<std::optional<std::vector<std::optional<V>>>> values;
-    for (auto& map : maps) {
-      for (const auto& [key, value] : map) {
+    for (vector_size_t i = 0; i < maps.size(); i++) {
+      if (nullRows.count(i)) {
+        continue;
+      }
+      for (const auto& [key, value] : maps[i]) {
         keys.push_back(key);
         values.push_back(value);
       }
@@ -779,17 +802,30 @@ class VectorTestBase {
     auto rawOffsets = offsets->template asMutable<vector_size_t>();
     auto rawSizes = sizes->template asMutable<vector_size_t>();
 
+    BufferPtr nulls = nullptr;
+    uint64_t* rawNulls = nullptr;
     vector_size_t offset = 0;
+
+    if (nullRows.size() > 0) {
+      nulls = allocateNulls(size, pool_.get());
+      rawNulls = nulls->asMutable<uint64_t>();
+    }
+
     for (vector_size_t i = 0; i < size; i++) {
-      rawSizes[i] = maps[i].size();
+      if (nullRows.count(i)) {
+        rawSizes[i] = 0;
+        bits::setNull(rawNulls, i, true);
+      } else {
+        rawSizes[i] = maps[i].size();
+      }
       rawOffsets[i] = offset;
-      offset += maps[i].size();
+      offset += rawSizes[i];
     }
 
     return std::make_shared<MapVector>(
         pool_.get(),
         MAP(CppToType<K>::create(), ARRAY(CppToType<V>::create())),
-        nullptr,
+        nulls,
         size,
         offsets,
         sizes,
@@ -846,19 +882,19 @@ class VectorTestBase {
       memory::memoryManager()->addRootPool()};
   std::shared_ptr<memory::MemoryPool> pool_{rootPool_->addLeafChild("leaf")};
   velox::test::VectorMaker vectorMaker_{pool_.get()};
-  std::shared_ptr<folly::Executor> executor_{
-      std::make_shared<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency())};
+  std::unique_ptr<folly::Executor> executor_{
+      std::make_unique<folly::CPUThreadPoolExecutor>(
+          folly::available_concurrency())};
   std::shared_ptr<folly::Executor> spillExecutor_{
       std::make_shared<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency())};
+          folly::available_concurrency())};
 };
 
 class TestRuntimeStatWriter : public BaseRuntimeStatWriter {
  public:
-  void addRuntimeStat(const std::string& name, const RuntimeCounter& value)
+  void addRuntimeStat(std::string_view name, const RuntimeCounter& value)
       override {
-    stats_.emplace_back(name, value);
+    stats_.emplace_back(std::string(name), value);
   }
 
   const std::vector<std::pair<std::string, RuntimeCounter>>& stats() const {
diff --git a/website/blog/2022-07-01-june-2022-updates.mdx b/website/blog/2022-07-01-june-2022-updates.mdx
index a3f528534ff..fd2c042cd85 100644
--- a/website/blog/2022-07-01-june-2022-updates.mdx
+++ b/website/blog/2022-07-01-june-2022-updates.mdx
@@ -10,6 +10,8 @@ tags: [monthly-updates]
 
 * Add documentation for :ref:`complex types writers<outputs-write>`.
 
+<!-- truncate -->
+
 ## Core Library
 
 * Add support for INTERVAL DAY TO SECOND Presto type.
diff --git a/website/blog/2022-07-31-public-announcement.mdx b/website/blog/2022-07-31-public-announcement.mdx
index 340c50bac89..d1c23f99284 100644
--- a/website/blog/2022-07-31-public-announcement.mdx
+++ b/website/blog/2022-07-31-public-announcement.mdx
@@ -7,6 +7,8 @@ tags: [public-announcement]
 
 We are extremely excited to introduce Velox as an [open-source project](https://engineering.fb.com/2022/08/31/open-source/velox/), with a mission to define common standards for modular data processing systems. Velox provides reusable, extensible, high-performance, and dialect-agnostic data processing components for building execution engines, and enhancing data management systems. We envision Velox to be the defacto execution engine for [Arrow-compatible](https://www.globenewswire.com/en/news-release/2022/06/23/2468271/0/en/Voltron-Data-Announces-Commitment-to-Improve-Interoperability-Between-Apache-Arrow-and-the-Velox-Open-Source-Project-Created-by-Meta.html) data format powering ML and Analytical workloads.
 
+<!-- truncate -->
+
 The Velox team has been partnering with companies such as [Ahana, Intel, and Voltron Data](https://www.techtarget.com/searchdatamanagement/news/252524446/Meta-and-partners-build-Velox-open-source-execution-engine?amp=1) as well as various academic institutions to accelerate innovation and development in the data management industry.
 
 Looking at the future, we believe Velox’s unified and modular nature has the potential to disrupt the data management industry. It will allow us to deepen our partnership with hardware vendors and proactively adapt our unified software stack as hardware advances. We believe that modularity and reusability are the future of database system development and hope a vibrant open source community will help us in this journey.
diff --git a/website/blog/2022-10-31-simple-1.mdx b/website/blog/2022-10-31-simple-1.mdx
index 88109d8c36a..363d38d9f99 100644
--- a/website/blog/2022-10-31-simple-1.mdx
+++ b/website/blog/2022-10-31-simple-1.mdx
@@ -16,6 +16,8 @@ Scalar functions are one of the most used extension points in Velox. Since Velox
 <img src="/img/simple1_1.png"/>
 </figure>
 
+<!-- truncate -->
+
 Writing functions as vector functions directly gives the user `complete` control over the function implementations and optimizations, however it comes with some cost that can be summarized in three points:
 
 - **Complexity** : Requires an understanding of Velox vectorized data representation and encodings, which requires additional work for our customers, specially those without DB background. Moreover, Writing optimized vector functions requires even deeper understanding.
diff --git a/website/blog/2023-03-15-build-experience.mdx b/website/blog/2023-03-15-build-experience.mdx
index d5ab05290cd..a79bd9f2833 100644
--- a/website/blog/2023-03-15-build-experience.mdx
+++ b/website/blog/2023-03-15-build-experience.mdx
@@ -10,6 +10,8 @@ When Velox was open sourced in August 2021, it was not nearly as easily usable a
 
 To improve the Velox experience for users and community developers, Velox has partnered with Voltron Data to help make Velox more accessible and user-friendly. In this blog post, we will examine the challenges we faced, the improvements that have already been made, and the ones yet to come.
 
+<!-- truncate -->
+
 ## Enhancements & Improvements
 
 Velox was a product of the mono repo and required installation of dependencies on the system via a script. Any change in the state of the host system could cause a build failure and introduce version conflicts of dependencies. Fixing these challenges was a big focus to help the Velox Community and we worked in collaboration with the Voltron Data Team. We wanted to improve the overall Velox user experience by making Velox easy to consume across a wide range of platforms to accelerate its adoption.
diff --git a/website/blog/2023-05-01-simple-2.mdx b/website/blog/2023-05-01-simple-2.mdx
index 7d0753a15f5..84376014b3c 100644
--- a/website/blog/2023-05-01-simple-2.mdx
+++ b/website/blog/2023-05-01-simple-2.mdx
@@ -19,6 +19,8 @@ Note that the vector function implementation is minimal without any special opti
 </figure>
 
 
+<!-- truncate -->
+
 ### View types for inputs
 The previous representations of input complex types in the simple function interface were computationally expensive. Data from vectors used to be copied into std containers and passed to simple functions to process it. Arrays, Maps and Structs used to be materialized into std::vectors, folly::F14FastMap and std::tuples.
  The graph below illustrates the previous approach.
diff --git a/website/blog/2023-07-19-array-sort.mdx b/website/blog/2023-07-19-array-sort.mdx
index 279179f39b1..6d59122c174 100644
--- a/website/blog/2023-07-19-array-sort.mdx
+++ b/website/blog/2023-07-19-array-sort.mdx
@@ -27,6 +27,8 @@ presto> select array_sort_desc(array[2, 5, null, 1, -1]);
 
 Both array_sort and array_sort_desc place nulls at the end of the array.
 
+<!-- truncate -->
+
 There is also a version of <a href="https://prestodb.io/docs/current/functions/array.html#id2">array_sort</a>
 function that takes a comparator lambda function and uses it to sort the array.
 
diff --git a/website/blog/2023-09-06-optimize-try-cast.mdx b/website/blog/2023-09-06-optimize-try-cast.mdx
index 8a823e7467c..5bf1d1f0a17 100644
--- a/website/blog/2023-09-06-optimize-try-cast.mdx
+++ b/website/blog/2023-09-06-optimize-try-cast.mdx
@@ -9,6 +9,8 @@ One of the queries shadowed internally at Meta was much slower in Velox compared
 
 In this blogpost I summarize my learnings from investigating and optimizing try_cast.
 
+<!-- truncate -->
+
 --------------------------------------------------------------------------------------------
 
 ### Start and end results
diff --git a/website/blog/2023-10-02-reduce-agg.mdx b/website/blog/2023-10-02-reduce-agg.mdx
index 1e7d2dda745..12dfeaf2a53 100644
--- a/website/blog/2023-10-02-reduce-agg.mdx
+++ b/website/blog/2023-10-02-reduce-agg.mdx
@@ -22,6 +22,8 @@ state is returned. Throws an error if initialState is NULL or inputFunction or c
 returns a NULL.
 ```
 
+<!-- truncate -->
+
 Once can think of reduce_agg as using inputFunction to implement partial aggregation and
 combineFunction to implement final aggregation. Partial aggregation processes a list of
 input values and produces an intermediate state:
diff --git a/website/blog/2024-01-27-like-optimization.mdx b/website/blog/2024-01-27-like-optimization.mdx
index 57ba15f647c..45463f33372 100644
--- a/website/blog/2024-01-27-like-optimization.mdx
+++ b/website/blog/2024-01-27-like-optimization.mdx
@@ -24,6 +24,8 @@ WHERE name LIKE '%#_%' ESCAPE '#'
 --returns 'a_c' and  '_cd'
 ```
 
+<!-- truncate -->
+
 These examples show the basic usage of LIKE:
 
 - Use `%` to match zero or more characters.
diff --git a/website/blog/2024-05-31-optimize-try-more.mdx b/website/blog/2024-05-31-optimize-try-more.mdx
index d72f6aadb29..de7e9dad390 100644
--- a/website/blog/2024-05-31-optimize-try-more.mdx
+++ b/website/blog/2024-05-31-optimize-try-more.mdx
@@ -13,6 +13,8 @@ failure without throwing and introduced a mechanism for scalar functions to do
 the same. Microbenchmark measuring worst case performance of CAST improved
 100x. Samples of production queries show 30x cpu time improvement.
 
+<!-- truncate -->
+
 ## TRY and TRY(CAST)
 
 TRY construct can be applied to any expression to suppress errors and turn them
diff --git a/website/blog/2024-08-23-ci-migration.mdx b/website/blog/2024-08-23-ci-migration.mdx
index f93a0d335da..df6689427c5 100644
--- a/website/blog/2024-08-23-ci-migration.mdx
+++ b/website/blog/2024-08-23-ci-migration.mdx
@@ -13,6 +13,8 @@ tags: [tech-blog, packaging]
 
 In late 2023, the Meta OSS (Open Source Software) Team requested all Meta teams to move the CI deployments from CircleCI to Github Actions. [Voltron Data](http://voltrondata.com) and Meta in collaboration migrated all the deployed Velox CI jobs. For the year 2024, Velox CI spend was on track to overshoot the allocated resources by a considerable amount of money. As part of this migration effort, the CI workloads were consolidated and optimized by Q2 2024, bringing down the projected 2024 CI spend by 51%.
 
+<!-- truncate -->
+
 ## Velox’s Continuous Integration Workload
 
 Continuous Integration (CI) is crucial for Velox’s success as an open source project as it helps protect from bugs and errors, reduces likelihood of conflicts and leads to increased community trust in the project. This is to ensure the Velox builds works well on a myriad of system architectures, operating systems and compilers - along with the ones used internally at Meta. The OSS build version of Velox also supports additional features that aren't used internally in Meta (for example, support for Cloud blob stores, etc.).
diff --git a/website/blog/2024-12-15-tracing-query-tracing.mdx b/website/blog/2024-12-15-tracing-query-tracing.mdx
index aca5aeb772e..8baef527671 100644
--- a/website/blog/2024-12-15-tracing-query-tracing.mdx
+++ b/website/blog/2024-12-15-tracing-query-tracing.mdx
@@ -13,6 +13,8 @@ replay of a part of the query plan and dataset in an isolated environment, such
 This is much more efficient for query performance analysis and issue debugging, as it eliminates the need
 to replay the whole query in a production environment.
 
+<!-- truncate -->
+
 ## How Tracing Works
 
 The tracing process consists of two distinct phases: the tracing phase and the replaying phase. The
diff --git a/website/blog/2025-02-17-velox-primer-part-1.mdx b/website/blog/2025-02-17-velox-primer-part-1.mdx
index 4066f96b8da..6dd26ae7c80 100644
--- a/website/blog/2025-02-17-velox-primer-part-1.mdx
+++ b/website/blog/2025-02-17-velox-primer-part-1.mdx
@@ -11,6 +11,8 @@ how distributed queries are executed, how data is shuffled among different
 stages, and present Velox concepts such as Tasks, Splits, Pipelines, Drivers,
 and Operators that enable such functionality.
 
+<!-- truncate -->
+
 ## Distributed Query Execution
 
 Velox is a library that provides the functions that go into a *query fragment* in
diff --git a/website/blog/2025-03-25-velox-primer-part-2.mdx b/website/blog/2025-03-25-velox-primer-part-2.mdx
index 27407953695..84229400efd 100644
--- a/website/blog/2025-03-25-velox-primer-part-2.mdx
+++ b/website/blog/2025-03-25-velox-primer-part-2.mdx
@@ -23,6 +23,8 @@ fragments within a single worker node. Throughout this article, we will present
 which functions are performed by Velox and which by the distributed engine -
 Prestissimo, in this example.
 
+<!-- truncate -->
+
 ## Query Setup
 
 Prestissimo first receives the query through a *coordinator* node, which is
diff --git a/website/blog/2025-05-12-velox-primer-part-3.mdx b/website/blog/2025-05-12-velox-primer-part-3.mdx
index 424c6736cc9..f8fba8fb35b 100644
--- a/website/blog/2025-05-12-velox-primer-part-3.mdx
+++ b/website/blog/2025-05-12-velox-primer-part-3.mdx
@@ -21,6 +21,8 @@ producer side of the shuffle.  
 In this article, we will discuss the second query stage, or the consumer side
 of the shuffle.
 
+<!-- truncate -->
+
 ## Shuffle Consumer
 
 As presented in the previous post, on the first query stage each worker reads
diff --git a/website/blog/2025-07-07-segfault-dependency-update.mdx b/website/blog/2025-07-07-segfault-dependency-update.mdx
index fb02f44d066..c668edf7311 100644
--- a/website/blog/2025-07-07-segfault-dependency-update.mdx
+++ b/website/blog/2025-07-07-segfault-dependency-update.mdx
@@ -14,6 +14,8 @@ Updating these dependencies typically involves modifying the Velox code to align
 However, a recent upgrade of Folly and Facebook Thrift to version *v2025.04.28.00* caused a *SEGFAULT* only in one unit test in Velox
 named *velox_functions_remote_client_test*.
 
+<!-- truncate -->
+
 ## Investigation
 We immediately put on our [gdb](https://en.wikipedia.org/wiki/GNU_Debugger) gloves and looked at the stack traces. This issue was also reproducible in a debug build.
 The SEGFAULT occurred in Facebook Thrift's *ThriftServer* Class during it's initialization but the offending call was invoking a destructor of a certain handler.
diff --git a/website/blog/2025-07-11-extending-velox-with-cudf.mdx b/website/blog/2025-07-11-extending-velox-with-cudf.mdx
index 80e61b30b2d..652f81bd4c3 100644
--- a/website/blog/2025-07-11-extending-velox-with-cudf.mdx
+++ b/website/blog/2025-07-11-extending-velox-with-cudf.mdx
@@ -9,6 +9,8 @@ tags: [tech-blog]
 
 This post describes the design principles and software components for extending Velox with hardware acceleration libraries like NVIDIA's [cuDF](https://github.com/rapidsai/cudf). Velox provides a flexible execution model for hardware accelerators, and cuDF's data structures and algorithms align well with core components in Velox.
 
+<!-- truncate -->
+
 ## How Velox and cuDF Fit Together
 
 Extensibility is a key feature in Velox. The cuDF library integrates with Velox using the [DriverAdapter](https://github.com/facebookincubator/velox/blob/2a9c9043264a60c9a1b01324f8371c64bd095af9/velox/experimental/cudf/exec/ToCudf.cpp#L293) interface to rewrite query plans for GPU execution. The rewriting process allows for operator replacement, operator fusion and operator addition, giving cuDF a lot of freedom when preparing a query plan with GPU operators. Once Velox converts a query plan into executable pipelines, the cuDF DriverAdapter rewrites the plan to use GPU operators:
diff --git a/website/blog/2025-08-30-cpp20-standard.mdx b/website/blog/2025-08-30-cpp20-standard.mdx
new file mode 100644
index 00000000000..7c90a7b7a80
--- /dev/null
+++ b/website/blog/2025-08-30-cpp20-standard.mdx
@@ -0,0 +1,60 @@
+---
+slug: cpp20-standard
+title: "Velox switches to C++20 standard"
+authors: [czentgr]
+tags: [build]
+---
+
+## Background
+The C++ standard used in a project determines what built-in functionality developers can use to ease development and extended capabilities.
+
+Since its inception in August of 2021 Velox used the C++17 standard.
+
+<!-- truncate -->
+
+## Benefits
+
+Switching to C++20 contributes to having a modern ecosystem that is attractive in use, to develop in, and to maintain.
+Going forward Velox is looking to enhance the codebase by making use of newer compiler functionalities, such as sanitization checks, by also moving to support newer compiler versions for both GCC and Clang.
+
+## Changes
+
+### New minimum compiler versions
+This change also changes the minimum required compiler versions for GCC and CLang.
+The following minimum versions are now required:
+
+- GCC11 and later
+- CLang 15 and later
+
+### C++20 major new features relevant to Velox
+- coroutines language feature
+- modules language feature
+- Calendar and Timezone library `<chrono>`
+- constraints and concepts language feature
+- 3-way operator language feature
+- Ranges library feature
+
+Please refer to the C++20 standard for a complete list of new features.
+
+The minimum targeted compiler versions support
+- coroutines
+- Calendar and Timezone library `<chrono>`
+
+Newer versions of compilers implement more and more and C++20 features and library support.
+Supporting Velox on newer compiler versions is a continuous effort.
+
+## Lessons
+
+There was some interesting behavior by the compilers. Changing the C++20 standard caused some compile errors in the existing code.
+One of these errors was caused by a compiler issue itself.
+
+In GCC 12.2.1, which is used in the CI, the std::string `+` operator implementation ran into a known issue causing a warning.
+Because all warnings are errors we had to explictly add an exemption for this particlar compiler version.
+
+In general, however, the found compile errors were reasonably easy to fix.
+Most of the changes were compatible with C++17 as well which means the code is bit more clean.
+However, one change caused slight trouble because it emitted warnings in C++17 causing build failures due to turning all warnigns into errors.
+This was the change to require `this` in the lambda capture where applicable.
+On the other hand, not addressing the changes to the lamda capture caused errors in C++20.
+
+Overall, the switch to C++20 took some time but was not overly complicated. No changes to the CI pipelines used in the project were needed. It was limited to CMake and code changes.
diff --git a/website/blog/2025-11-01-shared-build.mdx b/website/blog/2025-11-01-shared-build.mdx
new file mode 100644
index 00000000000..5261aaf6b50
--- /dev/null
+++ b/website/blog/2025-11-01-shared-build.mdx
@@ -0,0 +1,105 @@
+---
+slug: shared-build
+title: "Enabling Shared Library Builds in Velox"
+authors: [jwujciak]
+tags: [tech-blog, packaging]
+---
+
+# Enabling Shared Library Builds in Velox
+
+In this post, I’ll share how we unblocked shared library builds in Velox, the challenges we encountered with our large CMake build system, and the creative solution that let us move forward without disrupting contributors or downstream users.
+
+<!-- truncate -->
+
+## The State of the Velox Build System
+
+Velox’s codebase was started in Meta’s internal monorepo, which still serves as a source of truth. Changes from pull requests in the Github repository are not merged directly via the web UI. Instead, the changes are imported into the internal review and CI tool [Phabricator](https://developers.facebook.com/blog/post/2022/11/15/meta-developers-workflow-exploring-tools-used-to-code/), as a ‘diff’. There, it has to pass an additional set of CI checks before being merged into the monorepo and in turn, exported to Github as a commit on the ‘main’ branch.
+
+Internally, Meta uses the Buck2 build system which, like its predecessor Buck, promotes   small, [granular build targets](https://buck.build/concept/what_makes_buck_so_fast.html) to improve caching and distributed compilation. Externally, however, the open-source community relies on CMake as a build system. When the CMake build system was first added, its structure mirrored the granular nature of the internal build targets.
+
+The result was hundreds of targets: over one hundred library targets, built as static libraries, and more than two hundred executables for tests and examples. While Buck(2) is optimized  for managing such  granular targets, the same can not be said for CMake. Each subdirectory maintained its own `CMakeLists.txt`, and header includes were managed through global `include_directories()`, with no direct link between targets and their associated header files. This approach encouraged tight coupling across module boundaries. Over the years, dependencies accumulated organically, resulting in a highly interconnected, and in parts cyclic, dependency graph.
+
+## Static Linking vs. Shared Linking
+
+The combination of 300+ targets and static linking resulted in a massive build tree, dozens of GiB when building in release mode and several times larger when built with debug information. This grew to the point where we had to provision larger CI runners just to accommodate the build tree in debug mode\!
+
+Individual test executables could reach several GiB, making it impractical to transfer the executables between runners to parallelize the execution of the tests across different CI runners. Significantly delaying CI feedback for developers when pushing changes to a PR.
+
+This size is the result of each static library containing a full copy of all of its dependencies' object files. With over 100+ strongly connected libraries, we end up with countless redundant copies of the same objects scattered throughout the build tree, blowing up the total size.
+
+CMake usually [requires](https://cmake.org/cmake/help/latest/command/target_link_libraries.html?utm_source=chatgpt.com#id12) the library dependency graph to be acyclic (a DAG). However it allows circular dependencies between static libraries, because it’s possible to adjust the linker invocation to work around possible issues with missing symbols.
+
+For example, say library `A` depends on `foo()` from library `B`, and `B` in turn depends on `bar()` defined in `A`. If we link them in order `A B`, the linker will find `foo()` in `B` for use in `A` but will fail to find `bar()` for use in `B`. This happens because the linker processes the libraries from left to right and symbols that are not (yet) required are effectively ignored.
+
+The trick is now simply to repeat the entire circular group in the linker arguments `A B A B`. Previously ignored symbols are now in the list of required symbols and can be resolved when the linker processes the repeated libraries.
+
+However, there is no workaround for shared libraries. So the moment we attempted to build Velox as a set of shared libraries, CMake failed to configure. The textbook solution would involve refactoring dependencies between targets, explicitly marking dependencies \- as `PUBLIC`( meaning forwarded to both direct and transitive dependents) or `PRIVATE`, ( required only for this target at build time), and manually breaking cycles. But with hundreds of targets and years of organic growth, this became an unmanageable task.
+
+## ~~Solution~~ Attempt 1: Automate
+
+Manually addressing this was unmanageable so, our first instinct as Software Engineers was, of course, to automate the process. I wrote a [python package](https://github.com/assignUser/cmake-refactor) that parses all `CMakelists.txt` files in the repository using [Antlr4](https://github.com/antlr/antlr4/), tracks which source files and headers belong to which target and reconstructs the library dependency graph. Based on the graph and whether headers are included from a source or a header file, the tool grouped the linked targets as either PRIVATE or PUBLIC.
+
+While this worked locally and made it easier to resolve the circular dependencies, it proved far too brittle and disruptive to implement at scale. Velox's high development velocity meant many parts of the code base changed daily, making it impossible to land modifications  across over 250+ CMake files in a timely manner while also allowing for thorough review and testing. Maintaining this carefully constructed DAG of dependencies would also have required an unsustainable amount of specialized reviewer attention, time that could be spent much more productively elsewhere.
+
+## Solution: Monolithic Library via CMake Wrappers
+
+Given the practical constraints we needed a solution that would unblock shared builds without disrupting the ongoing development. To achieve this we used a common pattern of larger CMake code bases, project specific wrapper functions. A special thanks to [Marcus Hanwell](https://github.com/cryos) for introducing me to the pattern he successfully used in [VTK](https://www.kitware.com/vtk-modularization-and-modernization/).
+
+We created wrapper functions for a selection of the CMake commands that create and manage build targets: `add_library` became `velox_add_library`, `target_link_libraries` turned into `velox_link_libraries` etc. These functions just forward the arguments to the wrapped core command, unless the option to build Velox as a monolithic library is set. In the latter case instead of ~100 only a single library target is created.
+
+Each call to `velox_add_library` just adds the relevant source files to the main `velox` target. To ensure drop-in compatibility, for every original library target, the wrapper creates an `ALIAS` target referring to `velox`. This way, all existing code, downstream consumers, old and new test targets, can continue to link to their accustomed `velox_xyz` targets, which effectively point to the same monolithic library. There is no need to adjust CMake files throughout the codebase, keeping the migration quick and entirely transparent to developers and users.
+
+Some special-case libraries, such as those involving the CUDA driver, still needed to be built separately for runtime or integration reasons. The wrapper logic allows exemptions for these, letting them be built as standalone libraries even in monolithic mode.
+
+Here's a simplified version of the relevant logic:
+```cmake
+function(velox_add_library TARGET)
+  if(VELOX_MONO_LIBRARY)
+      if(TARGET velox)
+        # Target already exists, append sources to it.
+        target_sources(velox PRIVATE ${ARGN})
+      else()
+        add_library(velox ${ARGN})
+      endif()
+      # create alias for compatibility
+      add_library(${TARGET} ALIAS velox)
+  else()
+    # Just call add_library as normal
+    add_library(${TARGET} ${ARGN})
+  endif()
+endfunction()
+```
+
+This new, monolithic library obviously doesn’t suffer from cyclic dependencies, as it only has external dependencies. So after implementing the wrapper functions, building Velox as a shared library only required some minor adjustments\!
+
+We have now switched the default configuration to build the monolithic library and transitioned to build the shared library in our main [PR CI](https://github.com/facebookincubator/velox/actions/workflows/linux-build.yml) and [macOS builds](https://github.com/facebookincubator/velox/actions/workflows/macos.yml).
+
+## Result
+
+The results of our efforts can be clearly seen in our [Build Metrics Report](https://facebookincubator.github.io/velox/bm-report) with the size of the resulting binaries being the biggest win as seen in Table 1\. The workflow that collects these metrics uses our regular CI image with GCC 12.2 and ld 2.38.
+
+![Velox Build Metrics Report](/img/bm-report.png)
+
+The new executables built against the shared [`libvelox.so`](http://libvelox.so) are a mere \~4% of their previous size\! This unlocks improvements across the board both for the local developer experience, packaging/deployments for downstream users as well as CI.
+
+| Size of executables | Static | Shared |
+| :---- | :---- | :---- |
+| Release | 18.31G | 0.76G |
+| Debug | 244G | 8.8G |
+
+Table 1: Total size of test, fuzzer and benchmark executables
+
+Less impressive but still notable is the reduction of the debug build time by almost two hours[^1]. The improvement is entirely explained by the much faster link time for the shared build of \~30 minutes compared to the 2 hours and 20 minutes it takes to link the static library.
+
+[^1]: This is of course much less in terms of wall time the user experiences (~ `CPU time/n` where n is the number of cores used for the build)
+
+| Total CPU Time | Static | Shared |
+| :---- | :---- | :---- |
+| Release | 13:21h | 13:23h |
+| Debug | 12:50h | 11:07h |
+
+Table 2: Total time spent on compilation and linking across all cores
+
+In addition to unblocking shared builds, the wrapper function pattern offers further benefits for future feature additions or build-system wide adjustments with minimal disruption. We already use them to automate installation of header files along the Velox libraries, with no changes to the targets themselves.
+
+The wrapper functions will also help with defining and enforcing the public Velox API by allowing us to manage header visibility, component libraries like GPU and Cloud extensions and versioning in a consistent and centralized manner.
diff --git a/website/blog/2025-11-09-multiround-local-merge.mdx b/website/blog/2025-11-09-multiround-local-merge.mdx
new file mode 100644
index 00000000000..761bb824161
--- /dev/null
+++ b/website/blog/2025-11-09-multiround-local-merge.mdx
@@ -0,0 +1,120 @@
+---
+slug: multi-round-local-merge
+title: "Multi-Round Lazy Start Merge"
+authors: [duanmeng, xiaoxmeng, pedroerp]
+tags: [tech-blog, spill, operator]
+---
+
+## Background
+
+Efficiently merging sorted data partitions at scale is crucial for a variety of training data preparation
+workloads, especially for Generative Recommenders (GRs) a new paradigm introduced in the paper
+*[Actions Speak Louder than Words: Trillion-Parameter Sequential Transducers for Generative Recommendations](https://arxiv.org/pdf/2402.17152)*.
+A key requirement is to merge training data across partitions—for example, merging hourly partitions into
+daily ones—while ensuring that all rows sharing the same primary key are stored consecutively. Training data is
+typically partitioned and bucketed by primary key, with rows sharing the same key
+stored consecutively, so merging across partitions essentially becomes a [multi-way merge problem](https://en.wikipedia.org/wiki/K-way_merge_algorithm#).
+
+Normally, [Apache Spark](https://spark.apache.org/) can be used for this sort-merge requirement — for example, via `CLUSTER BY`.
+However, training datasets for a single job can often reach the PB scale, which in turn generates shuffle data at PB scale.
+Although we typically apply bucketing and ordering by key when preparing training data in production,
+Spark can eliminate the shuffle when merging training data from multiple hourly partitions.
+However, each Spark task can only read the files planned from various partitions within a split
+sequentially, placing them into the sorter and spilling as needed. Only after all files have been read
+does Spark perform a sort-merge of the spilled files. This process produces a large number of small
+spill files, which further degrades efficiency.
+
+<!-- truncate -->
+
+Moreover, Spark’s spill is row-based with a low compression ratio, resulting in approximately 4 times
+amplification compared to the original columnar training data in the data lake. These factors
+significantly degrade task stability and performance. Velox has a `LocalMerge` operator that can be
+introduced into Apache Spark via [Gluten](https://gluten.apache.org/) or [PySpark on Velox](https://www.youtube.com/watch?v=oq5M2861WaQ).
+
+*Note: To keep the focus on merging, the remainder of this article also assumes that each partition’s
+training data is already sorted by primary key—a common setup in training data pipelines.*
+
+
+## LocalMerge Operator
+
+The `LocalMerge` operator consolidates its sources’ outputs into a single, sorted stream of rows.
+It runs single-threaded, while its upstream sources may run multi-threaded within the same task,
+producing multiple sorted inputs concurrently. For example, when merging 24 hourly partitions into
+a single daily partition (as shown in the figure below), the merge plan fragment is split into two pipelines:
+
+- Pipeline 0: contains two operators, `TableScan` and `CallbackSink`. 24 drivers are instantiated to scan the 24 hourly partitions.
+- Pipeline 1: contains only a single operator, `LocalMerge`, with one driver responsible for performing the sort merge.
+
+A `CallbackSink` operator is installed at the end of each driver in Pipeline 0. It pushes the `TableScan`
+operator’s output vectors into the queues backing the merge streams. Inside `LocalMerge`, a `TreeOfLosers`
+performs a k-way merge over the 24 merge streams supplied by the Pipeline 0 drivers, producing a single,
+globally sorted output stream.
+
+
+<figure>
+    <img src="/img/merge.png" height= "100%" width="100%"/>
+</figure>
+
+## Multi-Round Spill Merge
+
+Although `LocalMerge` minimizes comparisons during merging, preserves row-ordering guarantees, and cleanly
+isolates the single-threaded merge from the multi-threaded scan phase for predictable performance, it can
+cause substantial memory pressure—particularly in training-data pipelines. In these workloads, extremely
+wide tables are common, and even after column pruning, thousands of columns may remain.
+
+Moreover, training data is typically stored in [PAX-style formats such as Parquet, ORC, or DRWF](https://www.vldb.org/pvldb/vol17/p148-zeng.pdf).
+Using Parquet as an example, the reader often needs to keep at least one page per column in memory. As a result,
+simply opening a Parquet file with thousands of columns can consume significant memory even before any
+merging occurs. Wide schemas further amplify per-column metadata, dictionary pages, and decompression buffers,
+inflating the overall footprint. In addition, the k-way merge must hold input vectors from multiple sources
+concurrently, which drives peak memory usage even higher.
+
+To cap memory usage and avoid OOM when merging a large number of partitions, we extend `LocalMerge` to
+process fewer local sources at a time, leverage existing spill facilities to persist intermediate
+results, and introduce lazy-start activation for merge inputs. Using the case of merging 24 hourly
+partitions into a single daily partition, the process is organized into two phases:
+
+**Phase 1**
+
+1. Break the scan-and-merge into multiple rounds (e.g., 3 rounds).
+2. In each round, lazily start a limited number of drivers (e.g., drivers 0–7, eight at a time).
+3. The started drivers scan data and push it into the queues backing their respective merge streams.
+4. Perform an in-memory k-way merge and spill the results, producing a spill-file group (one or more spill files per group).
+5. After all inputs from drivers 0–7 are consumed and spilled, the drivers will be closed, and close the file streams opened by their `TableScan` operators, and release associated memory.
+6. Repeat the above steps for the remaining rounds (drivers 8–15, then drivers 16–23), ensuring peak memory stays within budget.
+
+**Phase 2**
+
+1. Create a concatenated file stream for each spill-file group produced in Phase 1.
+2. Schedule one async callback for each concatenated stream to prefetch and push data into a merge stream.
+3. Merge the outputs of the three merge streams using a k-way merge (e.g., a loser-tree), and begin streaming the final, globally sorted results to downstream operators.
+4. The output batch rows is limited adaptively by estimating row size from the merge streams which use the averaged row size from the first batch.
+
+<figure>
+    <img src="/img/spill.merge.png" height= "100%" width="100%"/>
+</figure>
+
+## How To Use
+
+Set `local_merge_spill_enabled` to `true` to enable spilling for the `LocalMerge`
+operator (it is `false` by default). Then, set `local_merge_max_num_merge_sources` to
+control the number of merge sources per round according to your memory management strategy.
+
+*Note: An executor must be configured for spilling, as it would schedule an asynchronous
+callback for each concatenated stream to prefetch data and push it into the merge stream.*
+
+## Future Work
+
+The number of merge sources is adjusted dynamically based on available memory, rather than being
+determined by the `local_merge_max_num_merge_sources` parameter. The process starts with a small
+number of sources, such as 2, and incrementally increases this number for subsequent
+rounds (e.g., to 4) as long as sufficient memory is available. The number of sources stops increasing
+once it reaches a memory-constrained limit.
+
+## Acknowledgements
+
+Thanks to [Xiaoxuan Meng](https://www.linkedin.com/in/xiaoxuanmeng/) and [Pedro Pederia](https://www.linkedin.com/in/pedro-pedreira/) for their guidance, review, and brainstorming.
+I also appreciate the excellent collaboration and work from my colleagues,
+[Xiang Yao](https://www.linkedin.com/in/%E7%BF%94-%E5%A7%9A-1b513a359/),
+[Gang Wang](https://github.com/zjuwangg),
+and [Weixin Xu](https://www.linkedin.com/in/xu-weixin-75b06786/).
diff --git a/website/blog/2025-12-24-why-row-based-sort.mdx b/website/blog/2025-12-24-why-row-based-sort.mdx
new file mode 100644
index 00000000000..07bd968862e
--- /dev/null
+++ b/website/blog/2025-12-24-why-row-based-sort.mdx
@@ -0,0 +1,174 @@
+---
+slug: why-row-based-sort
+title: "Why Sort is row-based in Velox — A Quantitative Assessment"
+authors: [duanmeng, xiaoxmeng]
+tags: [tech-blog, sort, operator]
+---
+
+## TL;DR
+
+Velox is a fully vectorized execution engine[1]. Its internal columnar memory layout enhances cache
+locality, exposes more inter-instruction parallelism to CPUs, and enables the use of SIMD instructions,
+significantly accelerating large-scale query processing.
+
+However, some operators in Velox utilize a hybrid layout, where datasets can be temporarily converted
+to a row-oriented format. The `OrderBy` operator is one example, where our implementation first
+materializes the input vectors into rows, containing both sort keys and payload columns, sorts them, and
+converts the rows back to vectors.
+
+In this article, we explain the rationale behind this design decision and provide experimental evidence
+for its implementation. We show a prototype of a hybrid sorting strategy that materializes only the
+sort-key columns, reducing the overhead of materializing payload columns. Contrary to expectations, the
+end-to-end performance did not improve—in fact, it was even up to **3×** slower. We present the two
+variants and discuss why one is counter-intuitively faster than the other.
+
+<!-- truncate -->
+
+## Row-based vs. Non-Materialized
+
+### Row-based Sort
+
+The `OrderBy` operator in Velox’s current implementation uses a utility called `SortBuffer` to perform
+the sorting, which consists of three stages:
+
+1. Input Stage: Serializes input Columnar Vectors into a row format, stored in a RowContainer.
+2. Sort Stage: Sorts based on keys within the RowContainer.
+3. Output Stage: Extract output vectors column by column from the RowContainer in sorted order.
+
+<figure>
+    <img src="/img/row-sort.png" height= "100%" width="100%"/>
+</figure>
+
+While row-based sorting is more efficient than column-based sorting[2,3], what if we only
+materialize the sort key columns? We could then use the resulting sort indices to gather
+the payload data into the output vectors directly. This would save the cost of converting
+the payload columns to rows and back again. More importantly, it would allow us to spill
+the original vectors directly to disk rather than first converting rows back into vectors
+for spilling.
+
+### Non-Materialized Sort
+We have implemented a [non-materializing sort strategy](https://github.com/facebookincubator/velox/pull/15157) designed
+to improve sorting performance. The approach materializes only the sort key columns and their original vector indices,
+which are then used to gather the corresponding rows from the original input vectors into the output vector after the
+sort completes. It changes the `SortBuffer` to `NonMaterizedSortBuffer`, which consists of three stages:
+
+1. Input Stage: Holds the input vector (its shared pointer) in a list, serializes key columns
+and additional index columns (VectorIndex and RowIndex) into rows, stored in a RowContainer.
+2. Sort Stage: Sorts based on keys within the RowContainer.
+3. Output Stage: Extracts the VectorIndex and RowIndex columns, uses them together to gather
+the corresponding rows from the original input vectors into the output vector.
+
+<figure>
+    <img src="/img/column-sort.png" height= "100%" width="100%"/>
+</figure>
+
+In theory, this should have significantly reduced the overhead of materializing payload columns,
+especially for wide tables, since only sorting keys are materialized. However, the benchmark results
+were the exact opposite of our expectations. Despite successfully eliminating expensive serialization
+overhead and reducing the total instruction the end-to-end performance was **3x times slower**.
+
+## Benchmark Result
+
+To validate the effectiveness of our new strategy, we designed a benchmark with a varying number of
+payload columns:
+
+- Inputs: 1000 Input Vectors, 4096 rows per vector.
+- Number of payload columns: 64, 128, 256.
+- L2 cache: 80 MiB, L3 cache: 108 MiB.
+
+| numPayloadColumns | Mode | Input Time  | Sorting Time | Output Time  | Total Time  | Desc  |
+| --- | --- | --- | --- | --- | --- | --- |
+| 64 | Row-based | 4.27s | 0.79s | 4.23s | 11.64s | Row-based is 3.9x faster |
+|  | Columnar | 0.28s | 0.84s | 42.30s  | 45.90s | |
+| 128 | Row-based | 20.25s | 1.11s | 5.49s | 31.43s | Row-based is 2.0x faster |
+|  | Columnar | 0.27s | 0.51s | 59.15s | 64.20s |  |
+| 256 | Rows-based | 29.34s | 1.02s | 12.85s | 51.48s | Row-based is 3.0x faster |
+|  | Columnar | 0.87s | 1.10s | 144.00s | 154.80s |  |
+
+The benchmark results confirm that Row-based Sort is the superior strategy,
+delivering a 1.9x to 3.9x overall speedup compared to Columnar Sort. While Row-based Sort
+incurs a significantly higher upfront cost during the Input phase (peaking at 104s), it
+maintains a highly stable and efficient Output phase (maximum 32s). In contrast, Columnar
+Sort suffers from severe performance degradation in the Output phase as the payload increases,
+with execution times surging from 42s to 283s, resulting in a much slower total execution time
+despite its negligible input overhead.
+
+To identify the root cause of the performance divergence, we utilized `perf stat` to analyze
+micro-architectural efficiency and `perf mem` to profile memory access patterns during the critical
+Output phase.
+
+| Metrics | Row-based | Columnar | Desc |
+| --- | --- | --- | --- |
+| Total Instructions | 555.6 Billion | 475.6 Billion | Row +17% |
+| IPC (Instructions Per Cycle) | 2.4 | 0.82 | Row 2.9x Higher |
+| LLC Load Misses (Last Level Cache) | 0.14 Billion | 5.01 Billion | Columnar 35x Higher |
+
+| Memory Level | Row-based Output | Columnar Outputs |
+| --- | --- | --- |
+| RAM Hit | 5.8% | 38.1% |
+| LFB Hit | 1.7% | 18.9% |
+| RAM Hit | 5.8% | 38.1% |
+
+The results reveal a stark contrast in CPU utilization. Although the Row-based approach
+executes 17% more instructions (due to serialization overhead), it maintains a high IPC of 2.4,
+indicating a fully utilized pipeline. In contrast, the Columnar approach suffers from a low IPC
+of 0.82, meaning the CPU is stalled for the majority of cycles. This is directly driven by the
+35x difference in LLC Load Misses, which forces the Columnar implementation to fetch data from
+main memory repeatedly. The memory profile further confirms this bottleneck: Columnar mode is
+severely latency-bound, spending 38.1% of its execution time waiting for DRAM (RAM Hit) and
+experiencing significant congestion in the Line Fill Buffer (18.9% LFB Hit), while Row-based
+mode effectively utilizes the cache hierarchy.
+
+## The Memory Access Pattern
+
+Why does the non-materializing sort, specifically its gather method, cause so many cache misses?
+The answer lies in its memory access pattern. Since Velox is a columnar engine, the output is
+constructed column by column. For each column in an output vector, the gather process does the following:
+1. It iterates through all rows of the current output vector.
+2. For each row, locate the corresponding input vector via the sorted vector index.
+3. Locates the source row in the corresponding input vector.
+4. Copies the data from that single source cell to the target cell.
+
+The sorted indices, by nature, offer low predictability. This forces the gather operation for a single
+output column to jump unpredictably across as many as different input vectors, fetching just one
+value from each. This random access pattern has two devastating consequences for performance.
+
+First, at the micro-level, every single data read becomes a "long-distance" memory jump.
+The CPU's hardware prefetcher is rendered completely ineffective by this chaotic access pattern,
+resulting in almost every lookup yielding a cache miss.
+
+Second, at the macro-level, the problem compounds with each column processed. The sheer
+volume of data touched potentially exceeds the size of the L3 cache. This ensures
+that by the time we start processing the next payload column, the necessary vectors have already
+been evicted from the cache. Consequently, the gather process must re-fetch the same vector
+metadata and data from main memory over and over again for each of the 256 payload columns.
+This results in 256 passes of cache-thrashing, random memory access, leading to a catastrophic
+number of cache misses and explaining the severe performance degradation.
+
+<figure>
+    <img src="/img/columnar-mem.png" height= "100%" width="100%"/>
+</figure>
+
+In contrast, Velox’s current row-based approach serializes all input vectors into rows, with
+each allocation producing a contiguous buffer that holds a subset of those rows. Despite the
+serialization, the row layout preserves strong locality when materializing output
+vectors: once rows are in the cache, they can be used to extract multiple output columns.
+This leads to much better cache-line utilization and fewer cache misses than a columnar layout,
+where each fetched line often yields only a single value per column. Moreover, the largely
+sequential scans over contiguous buffers let the hardware prefetcher operate effectively,
+boosting throughput even in the presence of serialization overhead.
+
+<figure>
+    <img src="/img/row-mem.png" height= "100%" width="100%"/>
+</figure>
+
+## Conclusion
+This study reinforces the core principle of performance engineering: Hardware Sympathy.
+Without understanding the characteristics of the memory hierarchy and optimizing for it,
+simply reducing the instruction count usually does not guarantee better performance.
+
+## Reference
+
+- [1] https://velox-lib.io/blog/velox-primer-part-1/
+- [2] https://duckdb.org/pdf/ICDE2023-kuiper-muehleisen-sorting.pdf
+- [3] https://duckdb.org/2021/08/27/external-sorting
diff --git a/website/blog/2026-01-06-task-barrier.mdx b/website/blog/2026-01-06-task-barrier.mdx
new file mode 100644
index 00000000000..7c8de02a9a7
--- /dev/null
+++ b/website/blog/2026-01-06-task-barrier.mdx
@@ -0,0 +1,132 @@
+---
+slug: task-barrier
+title: "Task Barrier: Efficient Task Reuse and Streaming Checkpoints in Velox"
+authors: [xiaoxmeng, yuhta, mbasmanova, pedroerp]
+tags: [tech-blog, task, execution]
+---
+
+## TL;DR
+
+Velox Task Barriers provide a synchronization mechanism that not only enables efficient task reuse,
+important for workloads such as [AI training data loading](https://engineering.fb.com/2022/09/19/ml-applications/data-ingestion-machine-learning-training-meta/),
+but also delivers the strict sequencing and checkpointing semantics required for streaming workloads.
+
+By injecting a barrier split, users guarantee that no subsequent data is processed until the entire
+DAG is flushed and the synchronization signal is unblocked. This capability serves two critical
+patterns:
+
+1. **Task Reuse**: Eliminates the overhead of repeated task initialization and teardown by safely
+   reconfiguring warm tasks for new queries. This is a recurring pattern in AI training data
+   loading workloads.
+
+2. **Streaming Processing**: Enables continuous data handling with consistent checkpoints, allowing
+   stateful operators to maintain context across batches without service interruption.
+
+See the [Task Barrier Developer Guide](https://facebookincubator.github.io/velox/develop/task-barrier.html) for implementation details.
+
+<!-- truncate -->
+
+## The Problem
+
+Creating a new Velox task for every data request introduces overhead:
+
+- Memory pool initialization and configuration
+- Pipeline and operator construction
+- Connector and data source setup
+- Thread pool registration
+
+For high-throughput workloads that process thousands of requests, this overhead may accumulate
+and impact overall system performance.
+
+## The Solution: Task Barrier
+
+Task Barrier introduces a lightweight synchronization mechanism that:
+
+1. **Drains all in-flight data** - Ensures all buffered data flows through the pipeline to completion.
+
+2. **Resets stateful operators** - Clears internal state in operators like aggregations, joins, and sorts.
+
+3. **Preserves task infrastructure** - Keeps memory pools, thread registrations, and connector sessions intact.
+
+### How It Works
+
+The barrier is triggered by a special `BarrierSplit` injected into the task's source operators via
+`requestBarrier()`. When received:
+
+1. Source operators propagate the barrier signal downstream.
+2. Each operator calls `finishDriverBarrier()` to flush and reset its state.
+3. Once all drivers complete barrier processing, the task is ready for a new split.
+
+### Workflow Example (Pseudo-code)
+
+The following example demonstrates the usage pattern: the user adds splits, requests a barrier,
+and then must continue to drain results until the barrier is reached. This ensures all in-flight
+data leaves the pipeline, allowing the barrier to complete.
+
+```cpp
+// 1. Initialize the task infrastructure once
+auto task = Task::create(config, memoryPool);
+
+// 2. Loop to process multiple batches using the same task
+while (scheduler.hasMoreRequests()) {
+
+  // A. Get new data splits (e.g., from a file or query)
+  auto splits = scheduler.getNextSplits();
+
+  // B. Add splits to the running task
+  task->addSplits(sourcePlanNodeId, splits);
+
+  // C. Request a barrier to mark the end of this batch.
+  // This injects a BarrierSplit that flows behind the data.
+  // Note: Any splits added to the task AFTER this call will be blocked
+  // and will not be processed until this barrier is fully cleared.
+  auto barrierFuture = task->requestBarrier();
+
+  // D. Drain the pipeline until the barrier is passed.
+  // Critical: We must keep pulling results so the task can flush
+  // its buffers and reach the barrier.
+  while (!barrierFuture.isReady()) {
+    auto result = task->next(); // Get next result batch
+    if (result != nullptr) {
+      userOutput.consume(result);
+    }
+  }
+
+  // E. Barrier reached.
+  // The task has been reset (operators cleared, buffers flushed).
+  // It is now ready for the next iteration immediately.
+}
+```
+
+### Operator Support
+
+Task Barrier requires operators to implement `finishDriverBarrier()` to properly reset their state:
+
+- **TableScan**: Clears current split and reader state.
+- **HashBuild/HashProbe**: Resets hash tables and probe state.
+- **Aggregation**: Flushes partial aggregates and clears accumulators.
+- **OrderBy**: Outputs sorted data and resets sort buffer.
+- **Exchange**: Drains exchange queues.
+
+## Performance Impact
+
+By eliminating repeated task creation overhead, Task Barrier provides significant performance
+improvements for workloads with:
+
+- **Short-lived Queries**: Specifically those that recur frequently with the exact same plan DAG,
+  avoiding the need for repeated reconstruction.
+- **AI/ML Pipelines**: High-frequency data loading requests where task initialization would
+  otherwise dominate execution time.
+- **Iterative Processing**: Queries that can benefit from "warm" caches and pre-allocated memory pools.
+
+## Learn More
+
+For detailed implementation information, API reference, and operator-specific behavior, see the
+[Task Barrier](https://facebookincubator.github.io/velox/develop/task-barrier.html) documentation.
+
+## References
+
+- [Data Ingestion for Machine Learning Training at Meta](https://engineering.fb.com/2022/09/19/ml-applications/data-ingestion-machine-learning-training-meta/)
+- [Flink Stateful Streaming Processing](https://nightlies.apache.org/flink/flink-docs-release-1.20/docs/concepts/stateful-stream-processing/)
+- [Velox Task Model](https://facebookincubator.github.io/velox/develop/task.html)
+- [Velox Task Barrier](https://facebookincubator.github.io/velox/develop/task-barrier.html)
diff --git a/website/blog/2026-02-10-stringview-api-changes.mdx b/website/blog/2026-02-10-stringview-api-changes.mdx
new file mode 100644
index 00000000000..2828b6a58ae
--- /dev/null
+++ b/website/blog/2026-02-10-stringview-api-changes.mdx
@@ -0,0 +1,145 @@
+---
+slug: stringview-api-changes
+title: "velox::StringView API Changes and Best Practices"
+authors: [pedroerp]
+tags: [tech-blog, strings, api]
+---
+
+## Context
+
+Strings are ubiquitously used in large-scale analytic query processing. From storing identifiers,
+names, labels, or structured data (like json/xml), to simply descriptive text, like a product
+description or the contents of this very blog post, there is hardly a SQL query that does not require
+the manipulation of string data.
+
+This post describes in more detail how Velox handles columns of strings, the low-level C++ APIs
+involved and some recent changes made to them, and presents best practices for string usage
+throughout Velox's codebase.
+
+<!-- truncate -->
+
+## StringView
+
+To efficiently enable string operations, Velox provides a specialized physical C++ type, called
+`velox::StringView`. The main purpose of this layout, also called a *German String Layout*, is to
+optimize common string operations over small strings, or operations that can be performed by only
+accessing a string's prefix.
+
+StringViews are 16-byte objects that provide a non-owning string-like API that refers to data stored
+elsewhere in a columnar Velox Vector buffer. The lifetime of a `velox::StringView` is always tied to
+the lifetime of the underlying Velox Vector buffer, in the sense that it only provides a pointer
+(*view*) into the external buffer. It provides a similar abstraction to `std::string_view`, with
+the following additional optimizations:
+
+- **Small String Optimization (SSO):** strings up to 12 characters are always stored inline, within
+  the object itself. With the assumption that strings are in many cases small, it removes the need
+  for dereferencing the larger data buffer, hopefully reducing cache misses and memory bus traffic.
+
+- **Prefix optimization:** a 4 character prefix is always stored inline within the StringView object
+  to enable failed comparison to be short circuited, also skipping accesses to the external buffer.
+
+To enable better interoperability with other engines, a few years ago
+[we collaborated with the Arrow community](https://engineering.fb.com/2024/02/20/developer-tools/velox-apache-arrow-15-composable-data-management/)
+in what resulted to be the
+[BinaryView Arrow format](https://arrow.apache.org/docs/format/Columnar.html#variable-size-binary-view-layout)
+for string data. Ever since, we have seen increased adoption of this format in a series of
+[other systems and libraries](https://datafusion.apache.org/blog/2024/09/13/string-view-german-style-strings-part-1/).
+
+## The Old Unsafe API
+
+For convenience, in Velox we used to allow developers to implicitly convert `velox::StringView` into
+`std::string`, since many APIs are built based on `std::string`. For example, one could naively do:
+
+```cpp
+// Given this signature.
+void myFunction(const std::string& input) {
+  // ...
+}
+
+// All would silently result in a string copy
+// (valueAt() returns a velox::StringView):
+
+myFunction(stringVector->valueAt(0));
+
+std::string myStr = stringVector->valueAt(0);
+
+std::unordered_map<std::string, size_t> myMap;
+myMap[stringVector->valueAt(0)] = 1;
+```
+
+While these usages seem harmless, they would all result in a full string copy, and potentially a
+memory allocation, depending on the string size. We have found this anti-pattern to be commonly
+used; in most cases, the developer did not intend for a copy to be performed, and this behavior
+silently added unnecessary overhead.
+
+## What Changed
+
+To prevent such inadvertent string copies, in
+[#15946](https://github.com/facebookincubator/velox/pull/15946) we removed implicit conversion from
+`velox::StringView` to `std::string`. You can still do so if needed, but you now have to explicitly
+state it, for clarity:
+
+```cpp
+// Compilation failure from now on:
+myFunction(stringVector->valueAt(0));
+
+// Ok:
+myFunction(std::string(stringVector->valueAt(0)));
+```
+
+Instead, we are now making conversion from `velox::StringView` to `std::string_view` available
+implicitly. `std::string_view`'s are non-owning, so constructing them based on a pointer and size
+is essentially free.
+
+A series of PR were landed before this change to clean up any dependencies on the old behavior
+throughout Velox's codebase, making them explicitly defined when needed.
+
+## folly::StringPiece
+
+`folly::StringPiece`'s are now superseded by `std::string_view`. As part of this work, we have also
+cleaned up and removed every usage of `folly::StringPiece` in Velox; **do not** use
+`folly::StringPiece` in future code in Velox. Use `std::string_view` or `velox::StringView` instead.
+
+If you need to use a library that takes a `folly::StringPiece`, for example, `folly::parseJson()`,
+you can pass a `std::string_view` instead, since the `std::string_view` => `folly::StringPiece`
+conversion can be done implicitly.
+
+## The RValue Gotcha
+
+A slightly unintuitive gotcha of `velox::StringView` is the handling of rvalues and temporary
+values. Since `velox::StringView` may contain inlined strings, if you take a pointer to the string
+contents, the string happened to be small and inlined, and the `velox::StringView` object is
+destroyed, you would end up with a dangling pointer. For example:
+
+```cpp
+// Unsafe: would result in a std::string_view pointing to
+// the temporary object that gets destroyed right away.
+std::string_view sv = stringVector->valueAt(0);
+LOG(INFO) << "Happily would have crashed: " << sv;
+```
+
+To prevent these unsafe usages, the rvalue-based version of these conversions, both explicit and
+implicit, and for both `std::string` and `std::string_view`, are disabled. This means that the
+snippets above will give you a compilation error.
+
+The safe behavior would be to create a non-temporary object in the stack:
+
+```cpp
+velox::StringView sv1 = stringVector->valueAt(0);
+std::string_view sv2 = sv1; // all good, as long as sv2 is not used after
+                             // sv1 is destroyed.
+```
+
+## Best Practices
+
+To summarize, from now on, the conversions:
+
+- `velox::StringView` => `std::string`: won't be done implicitly anymore. This now needs to be
+  explicitly stated, for clarity.
+- `velox::StringView` => `std::string_view`: can be done implicitly.
+- `velox::StringView` => `folly::StringPiece`: do not use. If needed for legacy external libraries,
+  pass a `std::string_view` instead.
+- rvalue `velox::StringView&&` => any other type: compilation error to minimize risk of dangling
+  pointer.
+
+Please reach out on [Slack](https://velox-oss.slack.com) if you have any questions.
diff --git a/website/blog/2026-03-07-regex-hidden-traps.mdx b/website/blog/2026-03-07-regex-hidden-traps.mdx
new file mode 100644
index 00000000000..dd256f5c189
--- /dev/null
+++ b/website/blog/2026-03-07-regex-hidden-traps.mdx
@@ -0,0 +1,185 @@
+---
+slug: regex-hidden-traps
+title: "The hidden traps of regex in LIKE and split"
+authors: [mbasmanova]
+tags: [tech-blog,functions]
+---
+
+SQL functions sometimes use regular expressions under the hood in ways that
+surprise users. Two common examples are the
+<a href="https://facebookincubator.github.io/velox/functions/presto/regexp.html#like">LIKE</a>
+operator and Spark's
+<a href="https://facebookincubator.github.io/velox/functions/spark/string.html#split">split</a>
+function.
+
+In Presto,
+<a href="https://facebookincubator.github.io/velox/functions/presto/string.html#split">split</a>
+takes a literal string delimiter and
+<a href="https://facebookincubator.github.io/velox/functions/presto/regexp.html#regexp_split">regexp_split</a>
+is a separate function for regex-based splitting. Spark's `split`, however,
+always treats the delimiter as a regular expression.
+
+Both LIKE and Spark's split can silently produce wrong results and waste CPU
+when used with column values instead of constants. Understanding why this
+happens helps write faster, more correct queries — and helps engine developers
+make better design choices.
+
+<!-- truncate -->
+
+## LIKE is not contains
+
+A very common query pattern is to check whether one string contains another:
+
+```sql
+SELECT * FROM t WHERE name LIKE '%' || search_term || '%'
+```
+
+This looks intuitive: wrap `search_term` in `%` wildcards and you get a
+"contains" check. But LIKE is **not** the same as substring matching.
+LIKE treats `_` as a single-character wildcard and `%` as a multi-character
+wildcard. If `search_term` comes from a column and contains these characters,
+the results are silently wrong:
+
+```
+SELECT url,
+       url LIKE '%' || search_term || '%' AS like_result,
+       strpos(url, search_term) > 0 AS contains_result
+FROM (VALUES
+    ('https://site.com/home'),
+    ('https://site.com/user_profile'),
+    ('https://site.com/username')
+) AS t(url)
+CROSS JOIN (VALUES ('user_')) AS s(search_term);
+
+              url              | like_result | contains_result
+-------------------------------+-------------+----------------
+https://site.com/home          |    false    |     false
+https://site.com/user_profile  |    true     |     true
+https://site.com/username      |    true     |     false
+```
+
+`LIKE '%user_%'` matches `'https://site.com/username'` because `_` is a
+wildcard that matches any single character — in this case, `n`. But
+`strpos(url, 'user_') > 0` treats `_` as a literal underscore and correctly
+reports that `'https://site.com/username'` does not contain the substring
+`'user_'`.
+
+When the pattern is a constant, this distinction is visible and intentional.
+But when users write `x LIKE '%' || y || '%'` where `y` is a column, the
+values of `y` may contain `_` or `%` characters — and they will be silently
+interpreted as wildcards, producing wrong results.
+
+## Spark's split treats delimiters as regex
+
+In Presto, the <a href="https://facebookincubator.github.io/velox/functions/presto/string.html#split">split</a>
+function takes a literal string delimiter, while
+<a href="https://facebookincubator.github.io/velox/functions/presto/regexp.html#regexp_split">regexp_split</a>
+is a separate function for regex-based splitting. This distinction makes the intent clear.
+
+Spark's <a href="https://facebookincubator.github.io/velox/functions/spark/string.html#split">split</a>
+function, however, always treats the delimiter as a regular expression.
+Users rarely realize this, and a common pattern is to split a string using a
+value from another column:
+
+```sql
+select split(dir_path, location_path)[1] as partition_name from t
+```
+
+Here, a table stores Hive partition metadata: `dir_path` is the full partition
+path (e.g., `/data/warehouse/db.name/table/ds=2024-01-01`) and `location_path`
+is the table path (e.g., `/data/warehouse/db.name/table`). The user wants to
+strip the table path prefix to get the partition name.
+
+This works for simple paths. But `location_path` is interpreted as a regular
+expression, not a literal string. If it contains `.` — as in `db.name` — the
+`.` matches **any character**, not a literal dot. Characters like `(`, `)`,
+`[`, `+`, `*`, `?`, and `$` would also cause wrong results or errors.
+
+A correct alternative that also executes faster uses simple string operations:
+
+```sql
+IF(starts_with(dir_path, location_path),
+   substr(dir_path, length(location_path) + 2)) as partition_name
+```
+
+This is a bit more verbose than `split(dir_path, location_path)[1]`, but it is
+correct for all inputs and avoids regex compilation entirely.
+
+## Performance trap
+
+Beyond correctness, there is a performance problem. Both LIKE and Spark's
+split use <a href="https://github.com/google/re2">RE2</a> as the regex
+engine. RE2 is fast and safe, but compiling a regular expression can take up
+to 200x more CPU time than evaluating it.
+
+When the pattern or delimiter is a constant, the regex is compiled once and
+reused for every row. The cost is negligible. But when the pattern comes from
+a column, a new regex may need to be compiled for every distinct value. A table
+with thousands of distinct `location_path` values means thousands of regex
+compilations — each one expensive and none of them necessary.
+
+Velox limits the number of compiled regular expressions per function instance
+per thread of execution via the
+<a href="https://facebookincubator.github.io/velox/configs.html#expression-evaluation-configuration">expression.max_compiled_regexes</a>
+configuration property (default: 100). When this limit is reached, the query fails with an
+error.
+
+## Tempting but wrong fix
+
+When users hit this limit, the natural reaction is to ask the engine developers
+to raise or eliminate the cap. A recent
+<a href="https://github.com/facebookincubator/velox/pull/15953">pull request</a>
+proposed replacing the fixed-size cache with an evicting cache: when the limit
+is reached, the oldest compiled regex is evicted to make room for the new one.
+
+This sounds reasonable, and the motivation is understandable — users migrating
+from Spark don't want to rewrite working queries. But it makes things worse:
+
+- **It hides the correctness bug.** The query no longer fails, so users never
+  discover that their LIKE pattern or split delimiter is being interpreted as
+  a regex and producing wrong results for inputs with special characters.
+- **It makes the performance problem worse.** With thousands of distinct
+  patterns, the cache churns constantly — evicting one compiled regex only to
+  compile another. The query runs, but dramatically slower than necessary, and
+  the user has no indication why. In shared multi-tenant clusters, a single
+  slow query like this can consume excessive CPU and affect other users'
+  workloads.
+
+The error is a feature, not a bug. It is an early warning that catches misuse
+before it leads to silently wrong results in production and prevents a single
+query from wasting shared cluster resources.
+
+## Right fix
+
+**For users:** replace LIKE with literal string operations when checking for
+substrings. Use `strpos(x, y) > 0` or `contains(x, y)` instead of
+`x LIKE '%' || y || '%'`. For Spark's split with literal delimiters, use
+`substr` or other <a href="https://facebookincubator.github.io/velox/functions/spark/string.html">string functions</a> that don't involve regex.
+
+**For engine developers:** optimize the functions to avoid regex when it isn't
+needed. Velox's LIKE implementation already does this. As described in
+<a href="https://github.com/xumingming">James Xu</a>'s
+<a href="/blog/like">earlier blog post</a>, the engine analyzes each pattern
+and uses fast paths — prefix match, suffix match, substring search — whenever
+the pattern contains only regular characters and `_` wildcards. For simple patterns, this gives up to 750x speedup over regex.
+Regex is compiled only for patterns that truly require it, and these optimized
+patterns are not counted toward the compiled regex limit.
+
+The same approach should be applied to Spark's split function. The engine can
+check whether the delimiter contains any regex metacharacters. If it doesn't,
+a simple string search can be used instead of compiling a regex. This would
+make queries like `split(dir_path, location_path)` both fast and correct —
+without users needing to change anything and without removing the safety net
+for cases that genuinely require regex.
+
+## Takeaways
+
+- `LIKE` is not `contains`. The `_` and `%` wildcards can silently corrupt
+  results when the pattern comes from a column.
+- Spark's `split` treats delimiters as regex. Characters like `.` in column
+  values are interpreted as regex metacharacters, not literal characters.
+  Presto avoids this by separating `split` (literal) and `regexp_split` (regex).
+- When a query hits the compiled regex limit, the right response is to fix the
+  query, not to raise the limit.
+- Engine developers should optimize functions to avoid regex when the input
+  is a plain string, rather than making it easier to misuse regex at scale.
diff --git a/website/blog/2026-03-13-simd-capped-unicode-length.mdx b/website/blog/2026-03-13-simd-capped-unicode-length.mdx
new file mode 100644
index 00000000000..bfb75bb464b
--- /dev/null
+++ b/website/blog/2026-03-13-simd-capped-unicode-length.mdx
@@ -0,0 +1,220 @@
+---
+slug: simd-capped-unicode-length
+title: "Accelerating Unicode string processing with SIMD in Velox"
+authors: [PingLiuPing, yuhta, mbasmanova]
+tags: [tech-blog, performance]
+---
+
+## TL;DR
+
+We optimized two Unicode string helpers — `cappedLengthUnicode` and
+`cappedByteLengthUnicode` — by replacing byte-by-byte `utf8proc_char_length`
+calls with a SIMD-based scanning loop. The new implementation processes
+register-width blocks at a time: pure-ASCII blocks skip in one step, while
+mixed blocks use bitmask arithmetic to count character starts. Both helpers now
+share a single parameterized template, eliminating code duplication.
+
+On a comprehensive benchmark matrix covering string lengths from 4 to 1024
+bytes and ASCII ratios from 0% to 100%, we measured **2–15× speedups** across
+most configurations, with no regressions on Unicode-heavy inputs. The
+optimization benefits all callers of these helpers, including the Iceberg
+truncate transform and various string functions.
+
+<!-- truncate -->
+
+## Why SIMD, why here
+
+Velox is a high-performance execution engine, and SIMD is one of the primary
+ways we deliver that performance across compute-heavy paths. This is not a
+one-off micro-optimization; it is a principle we apply consistently when the
+data and algorithms make SIMD a natural fit. String processing is one of those
+places: it is ubiquitous in query execution and often dominated by byte-wise
+work that maps well to vectorized scanning.
+
+In this post, we describe how we applied this principle to two Unicode helpers
+that sit on many string processing paths, and how we balanced speed,
+correctness, and maintainability.
+
+The old implementation calls utf8proc_char_length on every UTF character.
+That is robust, but it is inefficient for long ASCII segments where every character has only 1 byte.
+## What these helpers do
+
+- **`cappedLengthUnicode`** returns the number of UTF-8 characters in a
+  string, stopping early once `maxChars` is reached.
+- **`cappedByteLengthUnicode`** returns the *byte position* of the Nth
+  character, also capped by `maxChars`. This is the key primitive for
+  truncating strings by character count without re-parsing the entire string.
+
+Consider a UTF-8 string that mixes multi-byte characters and ASCII:
+
+```
+input = "你好abc世界"  // 15 bytes, 7 characters
+```
+
+With `maxChars = 3`:
+- `cappedLengthUnicode` returns `3`.
+- `cappedByteLengthUnicode` returns `7` (the byte position after the third
+  character, `"好"`).
+
+Both need to handle mixed ASCII and multi-byte UTF-8 inputs, invalid bytes,
+and early-exit behavior. These helpers are called on the Unicode code path —
+the path used when the input is *not* known to be pure ASCII at the call
+site. They are hot in several places, most notably the
+<a href="https://iceberg.apache.org/spec/#truncate-transform-details">Iceberg truncate transform</a>,
+which must find the byte position of the Nth character to truncate partition
+keys. When we profiled the Iceberg write benchmark, `cappedByteLengthUnicode`
+stood out as a clear hot spot.
+
+Byte-by-byte UTF-8 scanning becomes a bottleneck on large, ASCII-heavy
+strings, but we cannot assume pure ASCII because inputs may mix ASCII and
+multi-byte characters.
+
+## The SIMD design
+
+We introduced a shared helper, `detail::cappedUnicodeImpl`, and parameterized
+it by whether it should return characters or bytes. The key idea is to process
+the string in SIMD-width blocks using
+<a href="https://github.com/xtensor-stack/xsimd">xsimd</a>:
+
+1. **ASCII fast path.** Load a register-width block and check whether any
+   byte has its high bit set. If not, the whole block is ASCII. We can skip the
+   entire block and advance the counters in one step.
+2. **Mixed UTF-8 blocks.** For a block containing non-ASCII bytes, we count
+   character starts using `(byte & 0xC0) != 0x80`, convert the predicate into a
+   bitmask, and use `popcount` to get the number of UTF-8 characters in the
+   block.
+3. **Finding the Nth character.** For `cappedByteLengthUnicode`, if the
+   `maxChars` target falls inside a mixed block, we use `ctz` on the bitmask to
+   locate the Nth character start and add a small inline helper
+   (`getUtf8CharLength`) to compute the byte length of that UTF-8 character.
+4. **Remainder handling.** For the tail, we keep two loops:
+   - A non-ASCII remainder loop that avoids ASCII fast-path mispredicts.
+   - A branching ASCII loop that is cheaper than the branchless version for
+     short strings.
+
+## The journey: what we tried and learned
+
+The final implementation emerged through several rounds of iteration and
+experimentation. Here are the key insights from that process.
+
+### Optimize at the core, not the call site
+
+The initial version added the SIMD fast path directly in the Iceberg truncate
+function. But the real bottleneck was in `cappedByteLengthUnicode` itself.
+Moving the optimization into the shared helper meant every call site benefits
+— not just Iceberg.
+
+### Avoid switching between code paths
+
+The first SIMD version only accelerated the leading ASCII prefix: it scanned
+SIMD blocks until it hit the first non-ASCII byte, then fell back to scalar
+for the rest of the string. This is useless if the first character is
+non-ASCII but the rest are ASCII. The obvious fix — re-entering the SIMD path
+after each non-ASCII block — caused a ~20% regression on mixed and
+Unicode-heavy inputs due to the overhead of switching between SIMD and scalar
+modes. The solution was a single SIMD loop that handles *both* ASCII and mixed
+blocks, avoiding frequent code-path switches and extra branching.
+
+### Unify the two helpers
+
+`cappedLengthUnicode` and `cappedByteLengthUnicode` have nearly identical
+logic — the only difference is what they return. Factoring them into a shared
+`detail::cappedUnicodeImpl<returnByteLength>` template eliminated the code
+duplication and ensures both helpers stay in sync.
+
+### Short strings need special care
+
+After the SIMD path was generalized, the expanded benchmark matrix revealed
+regressions on very short strings (4 bytes). The fix was simple: skip the
+SIMD loop entirely when the string is shorter than one register width. Short
+strings go straight to the scalar path, which avoids the overhead of loading
+and testing a partial SIMD register.
+
+### A branchless `getUtf8CharLength`
+
+The scalar remainder loop originally called `utf8proc_char_length`, which
+involves several branches. A branchless alternative using `std::countl_zero`
+compiles to a handful of instructions:
+
+```cpp
+auto n = std::countl_zero((~static_cast<uint32_t>(c) << 24) | 1);
+return (n == 0 || n > 4) ? 1 : n;
+```
+
+This improved performance on the short-string and remainder paths.
+
+### Confidence through comprehensive testing
+
+Since `cappedLengthUnicode` is widely used across Velox (unlike
+`cappedByteLengthUnicode` which is limited to Iceberg and Spark), the change
+needed high confidence. The PR added tests for multi-byte UTF-8 sequences that
+straddle SIMD boundaries, continuation bytes in the scalar tail, and strings
+that are exactly one register width.
+
+## Benchmark results
+
+We added `StringCoreBenchmark.cpp` to measure both helpers across a matrix of
+string lengths (4, 16, 64, 256, 1024 bytes) and ASCII ratios (0%, 1%, 25%,
+50%, 75%, 99%, 100%). Each benchmark processes 10,000 strings with
+`maxChars = 128`.
+
+ASCII ratio indicates the percentage of characters in each string that are
+single-byte ASCII; the remaining characters are multi-byte UTF-8. The
+following table highlights representative speedups from the full matrix
+(measured on an Apple M3):
+
+| String Length | ASCII Ratio | `cappedByteLengthUnicode` | `cappedLengthUnicode` |
+| --- | --- | --- | --- |
+| 16 | 50% | **+9.7×** | **+7.7×** |
+| 64 | 50% | **+15.3×** | **+11.3×** |
+| 64 | 100% | **+6.3×** | **+7.3×** |
+| 256 | 25% | **+9.2×** | **+6.3×** |
+| 256 | 100% | **+9.0×** | **+7.2×** |
+| 1024 | 50% | **+6.1×** | **+7.4×** |
+| 1024 | 99% | **+2.3×** | **+2.4×** |
+| 1024 | 100% | **+4.9×** | **+7.6×** |
+| 4 | 0% (Unicode-only) | −1.25× | −1.08× |
+| 4 | 100% (short ASCII) | −1.07× | −1.02× |
+
+The small regressions on 4-byte strings are within noise for such tiny
+inputs. For strings ≥ 16 bytes — which dominate real workloads — speedups
+range from 2× to over 15×, with the largest gains on mixed-content strings
+where the SIMD loop handles both ASCII and non-ASCII blocks without falling
+back to scalar.
+
+We also validated the results on an x86_64 server (Intel Xeon Skylake with
+AVX-512) and observed similar improvement patterns. A full set of raw numbers
+is available in the
+<a href="https://gist.github.com/PingLiuPing/889ec7d8cdffbf9081cb1af75e7f102f">perf data gist</a>
+and summarized in the
+<a href="https://github.com/facebookincubator/velox/pull/16428">PR</a>.
+
+## Takeaways
+
+- **Measure first, optimize second.** The optimization started from a real
+  hot spot found in the Iceberg write benchmark — not from speculation.
+- **Optimize the core, not the symptom.** Rather than patching the call site,
+  we pushed the improvement into the shared helper so that all callers benefit.
+- **SIMD is a first-class tool** in Velox for performance-critical paths.
+  String processing — ubiquitous in query execution and dominated by
+  byte-wise work — is a natural fit for vectorized scanning.
+- **Avoid switching between code paths.** Re-entering the SIMD path after every
+  non-ASCII block introduced extra branching and switching overhead; a unified
+  loop that handles both ASCII and mixed blocks was consistently faster.
+- **Branchless is not always faster.** A single branchless remainder loop was
+  slower than two tailored loops on short strings.
+- **Avoid duplication.** The two helpers share a single parameterized
+  implementation, keeping behavior consistent and reducing maintenance burden.
+- **Data-driven iteration.** We tried multiple strategies and compared them
+  against a realistic benchmark matrix. We kept the version that improved the
+  common case without regressing Unicode-heavy workloads.
+- **Comprehensive benchmarks** across different string lengths and ASCII
+  mixing ratios are essential for validating correctness-sensitive
+  optimizations.
+
+## Acknowledgements
+
+Special thanks to <a href="https://github.com/mbasmanova">Masha Basmanova</a> and
+<a href="https://github.com/Yuhta">Yuhta</a> for their guidance and detailed
+code reviews that shaped the SIMD design and pushed for comprehensive
+benchmarking.
diff --git a/website/blog/2026-03-26-velox-adaptive-cpu-sampling.mdx b/website/blog/2026-03-26-velox-adaptive-cpu-sampling.mdx
new file mode 100644
index 00000000000..78969cbc115
--- /dev/null
+++ b/website/blog/2026-03-26-velox-adaptive-cpu-sampling.mdx
@@ -0,0 +1,156 @@
+---
+slug: velox-adaptive-cpu-sampling
+title: "Adaptive Per-Function CPU Time Tracking"
+authors: [Rajeev975, pedroerp]
+tags: [tech-blog, expressions]
+---
+
+## Context
+
+Velox evaluates SQL expressions as trees of functions. A query like
+`if(array_gte(a, b), multiply(x, y), 0)` compiles into a tree where each node
+processes an entire vector of rows at a time. When a query runs slowly, the
+first question usually is: which function is consuming the most CPU? Is it the
+expensive array comparison, or the cheap arithmetic called millions of times?
+This problem is even more prominent in use cases like training data loading,
+when very long and deeply nested expression trees are common, and jobs may run
+for many hours, or days; in such cases, the CPU usage of even seemingly
+short-lived functions may add up to substantial overhead. Without a detailed
+per-function CPU usage breakdown, you may be left guessing — or worse,
+optimizing the wrong thing.
+
+<!-- truncate -->
+
+Velox supports CPU usage tracking through the `expression.track_cpu_usage` query
+config. When enabled, every function invocation is wrapped in a `CpuWallTimer`
+— an RAII guard that makes the `clock_gettime()` system call at entry and exit,
+recording the CPU and wall time spent in each function. This gives precise,
+per-function cost attribution across the entire expression tree.
+
+## The Overhead Problem
+
+That precision comes at a price. Each `CpuWallTimer` invocation performs a heap
+allocation, two `clock_gettime()` syscalls, and a heap deallocation — roughly
+~5μs of fixed overhead, depending on the platform. For a function like
+`array_gte()`, which spends milliseconds per vector iterating over array
+elements, 5μs is a negligible noise. But for a function like `multiply` that
+incurs a single instruction, the timer takes longer than the work itself:
+
+| Vector Size | No Tracking | Full Tracking | Overhead |
+|-------------|-------------|---------------|----------|
+| 100 rows    | 2.13ms      | 5.89ms        | **2.8x** |
+| 1,000 rows  | 300μs       | 668μs         | **2.2x** |
+| 10,000 rows | 193μs       | 233μs         | 1.2x     |
+
+*Benchmark for `multiply(a, b)` on double columns. Times are per 10K
+iterations.*
+
+This overhead forced production systems to disable per-function CPU tracking
+entirely, losing visibility into more granular CPU consumption. Selective
+per-function tracking (`expression.track_cpu_usage_for_functions`) was added to
+Velox in the past to let operators opt in specific functions, but even for
+tracked functions the overhead remained — you just chose which functions to pay
+the cost for.
+
+## Why Uniform Sampling Falls Short
+
+The obvious next step is to sample: measure every Nth vector instead of every
+one, and extrapolate. A uniform rate applied to all functions would be simple —
+one counter, one config key. But a single rate cannot serve both cheap and
+expensive functions.
+
+Consider `array_gte`, where the timer overhead is less than 0.1% of execution
+time. Sampling in this case throws away measurement precision for no benefit —
+the function can afford full tracking. Now consider `multiply` on small vectors,
+where the timer is 2500% of the function cost. Even a 1/1000 rate may not be
+aggressive enough. A rate that works for one function is either inaccurate or
+insufficient for another.
+
+## Adaptive Per-Function Sampling
+
+When a query starts running, adaptive sampling does not yet know which functions
+are cheap and which are expensive. So it watches.
+
+The first vector through each function is a warmup — caches and branch
+predictors settle, and the system measures the cost of the `CpuWallTimer` itself
+by creating and destroying a dummy one. Over the next 5 vectors, each function
+runs with a lightweight stopwatch instead, quietly accumulating how long it
+actually takes without any timer overhead.
+
+By the sixth vector, the system has what it needs: the ratio of timer overhead
+to function cost. If the ratio is within a configurable threshold (default 1%),
+the function switches to full tracking: every future vector gets a
+`CpuWallTimer`, with zero information loss. If the timer dominates, the function
+switches to sampling at a rate that bounds overhead to the threshold:
+
+| Function | Per-Vector Cost | Timer Overhead | Overhead Ratio | Decision |
+|----------|-----------------|----------------|----------------|----------|
+| `multiply(a,b)` 100 rows | ~0.2μs | ~5μs | 2500% | Sample 1/2500 |
+| `multiply(a,b)` 10K rows | ~20μs | ~5μs | 25% | Sample 1/25 |
+| `array_gte(a,b)` 100 rows | ~3ms | ~5μs | 0.17% | Always track |
+| `array_gte(a,b)` 10K rows | ~12ms | ~5μs | 0.04% | Always track |
+
+Expensive functions get exact tracking. Cheap functions sample aggressively. No
+per-function configuration needed — just a single "max acceptable overhead"
+knob.
+
+When stats are read, sampled functions have their CPU and wall time scaled up by
+the ratio of total vectors to timed vectors. To handle short queries where the
+sampling counter might never fire, the first post-calibration vector is always
+timed, guaranteeing at least one measurement to extrapolate from.
+
+## Results
+
+So does it work? We benchmarked adaptive sampling against both no tracking and
+full tracking, across cheap and expensive functions, at different vector sizes,
+and with different adaptive rates (1% and 0.5%). Results are presented below:
+
+| Benchmark | No Tracking | Full Tracking | Adaptive 1% | Adaptive 0.5% |
+|-----------|-------------|---------------|-------------|---------------|
+| multiply 100 rows | 2.13ms | 5.86ms (**36%**) | 2.19ms (**97%**) | 2.16ms (**98%**) |
+| multiply 1K rows | 299μs | 671μs (**44%**) | 304μs (**98%**) | 302μs (**99%**) |
+| multiply 10K rows | 193μs | 224μs (**86%**) | 165μs (**117%**) | 193μs (**100%**) |
+| array_gte 100 rows | 188ms | 193ms (**98%**) | 189ms (**100%**) | 187ms (**100%**) |
+| array_gte 1K rows | 32ms | 32ms (**100%**) | 32ms (**100%**) | 32ms (**100%**) |
+| array_gte 10K rows | 11ms | 11ms (**100%**) | 11ms (**100%**) | 11ms (**100%**) |
+
+*(Percentages are relative to "No Tracking" — higher is better)*
+
+For `multiply` on 100-row vectors, overhead drops from 64% to under 3%. For
+`array_gte`, overhead was already negligible and remains so — the function is
+fully tracked with near zero sampling.
+
+The natural concern with sampling is accuracy. We ran a correctness benchmark
+comparing the extrapolated CPU time from adaptive sampling against the true
+value from full tracking over 1,000 vectors:
+
+| Function | 100 rows | 1,000 rows | 10,000 rows |
+|----------|----------|------------|-------------|
+| multiply | 108.8% | 102.4% | 103.7% |
+| array_gte | 99.8% | 100.3% | 99.6% |
+
+Estimates land within 1–9% of the true value. For expensive functions that end
+up in *always track* mode, accuracy is exact — every vector is timed.
+
+## Configuration
+
+Two config properties control adaptive sampling:
+
+| Config | Type | Default | Description |
+|--------|------|---------|-------------|
+| `expression.adaptive_cpu_sampling` | bool | false | Enable adaptive per-function sampling |
+| `expression.adaptive_cpu_sampling_max_overhead_pct` | double | 1.0 | Target max overhead percentage |
+
+Adaptive sampling interacts cleanly with existing tracking modes.
+`expression.track_cpu_usage` (global tracking for all functions) takes highest
+priority and always wins. `expression.track_cpu_usage_for_functions` (selective
+per-function tracking) overrides adaptive for named functions. Adaptive sampling
+applies to everything else.
+
+## Takeaway
+
+Adaptive per-function CPU time tracking eliminates the tradeoff between
+observability and performance. Every function gets the best tracking mode for
+its cost profile — cheap functions run at near-native speed with minimal
+overhead, expensive functions get exact tracking at zero additional cost. The
+system is self-tuning and requires no per-function configuration.
diff --git a/website/blog/2026-03-29-debugging-flaky-ci.mdx b/website/blog/2026-03-29-debugging-flaky-ci.mdx
new file mode 100644
index 00000000000..34be726c849
--- /dev/null
+++ b/website/blog/2026-03-29-debugging-flaky-ci.mdx
@@ -0,0 +1,221 @@
+---
+slug: debugging-flaky-ci-across-repos
+title: "From flaky Axiom CI to a Velox bug fix: a cross-repo debugging story"
+authors: [mbasmanova]
+tags: [tech-blog, debugging]
+---
+
+## TL;DR
+
+When adding macOS CI to [Axiom](https://github.com/facebookincubator/axiom),
+set operation tests kept failing intermittently — but only in macOS debug CI.
+Linux CI (debug and release) passed consistently. Local runs always passed.
+The root cause turned out to be a bug in
+[Velox](https://github.com/facebookincubator/velox) — a dependency managed as
+a Git submodule. This post describes the process of debugging a CI-only failure
+when the bug lives in a different repository.
+
+<!-- truncate -->
+
+## The problem
+
+[Axiom](https://github.com/facebookincubator/axiom) is a set of open-source
+composable libraries for building SQL and dataframe processing front ends on
+top of [Velox](https://github.com/facebookincubator/velox). It integrates
+Velox as a Git submodule.
+
+After adding macOS CI builds ([#1168](https://github.com/facebookincubator/axiom/pull/1168)),
+we couldn't get the test suite to pass reliably.
+Various set operation tests (`SqlTest.set_*`) failed intermittently in macOS
+debug CI — different tests on different runs, all involving EXCEPT ALL or
+INTERSECT ALL. Linux debug and release CI passed consistently. Running the same
+tests locally — same build type, same data, same configuration — always passed.
+
+## Why CI-only failures are hard to debug
+
+The obvious approach — reproduce locally, attach a debugger, step through the
+code — doesn't work. You are limited to CI runs, and each run takes about 10
+minutes end-to-end: push the change, wait for CI to pick it up, build
+(~8 minutes even with ccache), run tests, check results. That's 3-4 iterations
+per hour at best. Every CI run has to be designed to extract maximum signal.
+
+## Step 1: Make CI runs count
+
+The first change was to restructure CI to focus on the problem:
+
+- **Disable unrelated builds.** Linux debug, Linux release, and macOS release
+  were all passing. Disabling them reduced the CI cycle time.
+- **Run only `SqlTest.set_*` tests 5 times.** The tests were flaky — sometimes
+  passing, sometimes failing. Running just the set operation tests (not the
+  full suite) 5 times increased the chances of triggering the failure together
+  with the debug logging while keeping the run fast. Without this, a CI run
+  could pass by luck, wasting 10 minutes with no useful signal.
+- **Run the full test suite after.** The 5x set-test loop ran first. If it
+  passed, the full suite ran to check for regressions.
+
+## Step 2: Iterate on Velox changes using Axiom CI
+
+The failing tests all involved EXCEPT ALL and INTERSECT ALL queries. Axiom's
+SQL parser and optimizer translate these into Velox execution plans using
+*counting joins* — a Velox-specific join type that, unlike regular semi/anti
+joins that check whether a key exists, tracks how many times each key appears
+on the build side. Since the implementation lives in Velox, the bug had to be
+there too.
+
+But the tests were in Axiom. Axiom uses Velox as a Git submodule pointing to a
+specific commit on `facebookincubator/velox`. To add debug logging to Velox and
+test it in Axiom CI, we needed Axiom to build from a modified Velox.
+
+The key insight is that you don't have to land changes to Velox first. You can
+point Axiom's submodule at a fork branch and let CI validate end-to-end.
+
+The workflow:
+
+1. **Fork Velox and push changes to a branch.** Create a branch on your fork
+   (e.g., `mbasmanova/velox`) with the debug logging or fix.
+2. **Point Axiom's submodule at the fork.** Two changes are needed:
+   - Update `.gitmodules` to use the fork URL:
+     ```
+     [submodule "velox"]
+         path = velox
+         url = https://github.com/mbasmanova/velox.git
+     ```
+   - Update the submodule to the desired commit:
+     ```bash
+     git -C velox checkout <commit>
+     git add velox .gitmodules
+     ```
+3. **Push and let CI build.** Axiom CI checks out submodules recursively, so
+   it picks up the modified Velox automatically.
+
+One subtlety: the Velox PR and the Axiom submodule both pushed to branches on
+the same fork (`mbasmanova/velox`). Initially we used the same branch name for
+both, which caused force-pushes from one repo to overwrite the other. The fix
+was to use separate branches — `fix-counting-join-merge` for the Velox PR and
+`fix-counting-join-merge-axiom` for the Axiom submodule.
+
+## Step 3: Form a hypothesis, then add targeted logging
+
+With limited CI iterations, random logging is wasteful. Each round of logging
+must be designed to prove or disprove one or more hypotheses.
+
+The hypothesis was:
+
+> When multiple build drivers process overlapping keys, each driver builds its
+> own hash table with per-key counts. When these tables are merged, duplicate
+> keys are dropped without summing their counts.
+
+To test this, we added logging at three points in the counting join lifecycle,
+logging full input/output data per driver including the driver ID:
+
+1. **Build input** — log each batch of rows received by each build driver.
+2. **Probe input** — log each batch of probe rows.
+3. **Probe output** — log the rows emitted by each probe driver.
+
+By comparing build inputs across drivers (to see which keys each driver
+processed) with probe outputs (to see the final results), we could determine
+whether the merged hash table had correct per-key counts.
+
+Before pushing to CI, we ran the tests locally. The bug didn't reproduce
+locally, but the logging code paths still executed. This validated that the log
+output was readable, the format was correct, and the information needed to
+confirm or reject the hypothesis would be present.
+
+One CI run with this logging confirmed the hypothesis: multiple build drivers
+processed overlapping keys, but the probe output showed counts as if only one
+driver's keys were present — the merge had dropped duplicate key counts.
+
+## Step 4: The fix
+
+The actual bug was straightforward once identified. Velox's `HashTable` has
+three code paths for inserting rows during hash table merge:
+
+- `arrayPushRow` for array-based hash mode (small key domains)
+- `buildFullProbe` with normalized-key comparison (medium key domains)
+- `buildFullProbe` with full key comparison (complex types)
+
+All three paths handled duplicate keys correctly for regular joins (linking
+rows via a "next" pointer), but for counting joins (which use a count instead
+of a next pointer), duplicates were silently dropped.
+
+The fix adds an `addCount` method to sum counts when a duplicate key is found
+during merge. Since Axiom's build does not compile Velox tests, we built Velox
+standalone to develop and run the test.
+
+Designing a test that exercises all three code paths was non-trivial. The hash
+table mode is chosen automatically based on key types, number of distinct
+values, and value ranges. Our first test attempts only hit array mode because
+the key domain was small. We had to study the mode selection logic in
+`decideHashMode()` to find key configurations that force each mode. This
+analysis was time-consuming enough that we
+[documented the hash modes](https://facebookincubator.github.io/velox/develop/hash-table.html)
+([#16953](https://github.com/facebookincubator/velox/pull/16953)) to spare
+other developers the same exercise. The key configurations we found:
+
+- Small integers `{1, 2}` → array mode
+- Two integer columns with 1500 distinct values each (combined cardinality
+  exceeds the 2M array threshold) → normalized-key mode
+- `ARRAY(INTEGER)` keys (complex types don't support value IDs) → hash mode
+
+We verified each variant independently by reverting the fix for one code path
+at a time and confirming the test failed.
+
+## Step 5: Landing the fix
+
+With the fix validated in Axiom CI, we created two PRs:
+
+- **Velox PR** ([#16949](https://github.com/facebookincubator/velox/pull/16949)):
+  The fix, test, documentation updates, and a new `hashtable.hashMode` runtime
+  stat.
+- **Axiom PR** ([#1175](https://github.com/facebookincubator/axiom/pull/1175)):
+  Update the Velox submodule and stop skipping set operation tests in macOS
+  debug CI (they were excluded via `GTEST_FILTER="-SqlTest.set_*"` as a
+  workaround).
+
+After the Velox PR merges, the Axiom submodule will be updated to point back to
+`facebookincubator/velox`.
+
+## Why only macOS debug?
+
+Honestly, we don't fully know.
+
+The bug requires splits with overlapping keys to land on different build
+drivers. The test uses 4 drivers and 3 data splits (one per input vector).
+Velox assigns splits to drivers on demand — whichever driver is ready first
+grabs the next split. If all splits happen to be processed by the same driver,
+there is no merge and no bug.
+
+Note that this is not a race condition. Given the same split-to-driver
+assignment, the result is deterministic and reproducibly wrong. The
+non-determinism is purely in which driver grabs which split, which depends on
+thread scheduling.
+
+What we can't explain is why macOS debug CI triggers this while the same macOS
+debug build locally does not. Same OS, same build type, same compiler, same
+test data, same number of drivers. Yet the thread scheduling differs enough
+to change split distribution. Differences in CPU, load, or runtime environment
+on the CI runner may play a role.
+
+If you have insights into what could cause such a difference in thread
+scheduling between local and CI macOS environments, please comment on
+[axiom#1170](https://github.com/facebookincubator/axiom/issues/1170).
+
+## Takeaways
+
+- **Don't dismiss "flaky" tests.** A test that sometimes passes and sometimes
+  fails is not necessarily a bad test. In this case, the test was correct — the
+  production code was buggy. The flakiness was the only signal that something
+  was wrong. We initially excluded the set tests via `GTEST_FILTER` to land the
+  macOS CI work, but came back to investigate right away. Leaving them disabled
+  would have hidden a real bug in Velox affecting all users of EXCEPT ALL and
+  INTERSECT ALL.
+- **Design each CI run for maximum signal.** When you get 3-4 iterations per
+  hour, you can't afford exploratory logging. Form a hypothesis first, design
+  logging to confirm or reject it, validate the logging locally, then push.
+- **Run flaky tests multiple times.** Not to distinguish flaky from broken, but
+  to ensure you reliably trigger the failure together with your debug logging
+  in a single CI run.
+- **Use downstream CI to iterate on dependency fixes.** When a bug lives in a
+  dependency, you can debug and validate fixes without landing anything. Point
+  the submodule at a fork branch and let downstream CI run end-to-end. See
+  Step 2 above for details.
diff --git a/website/blog/2026-04-10-nullif-special-form.mdx b/website/blog/2026-04-10-nullif-special-form.mdx
new file mode 100644
index 00000000000..38f983e52ed
--- /dev/null
+++ b/website/blog/2026-04-10-nullif-special-form.mdx
@@ -0,0 +1,78 @@
+---
+slug: nullif-special-form
+title: Why NULLIF Must Be a Special Form
+authors: [mbasmanova, peterenescu, bikramSingh91]
+tags: [tech-blog, expressions]
+---
+
+## What is NULLIF?
+
+`NULLIF(a, b)` is a SQL standard function that returns NULL if `a` equals `b`, otherwise returns `a`. It's commonly used to avoid division by zero (`x / NULLIF(y, 0)`) or to convert sentinel values to NULLs.
+
+<!-- truncate -->
+
+## The Naive Implementation
+
+The textbook rewrite is simple:
+
+```
+NULLIF(a, b) → IF(a = b, NULL, a)
+```
+
+This is exactly what Presto's SQL-to-plan translator does when running on Velox (Prestissimo). It works correctly for deterministic expressions. But there's a subtle, critical bug.
+
+## The Bug
+
+Consider this query:
+
+```sql
+SELECT nullif(rand() < 0.5, true), count(*)
+FROM unnest(sequence(1, 10))
+GROUP BY 1;
+```
+
+`nullif(x, true)` should return NULL when x is true and FALSE when x is false. TRUE should never appear in the output.
+
+But with the `IF` rewrite:
+
+```
+IF(rand() < 0.5 = true, NULL, rand() < 0.5)
+```
+
+The expression `rand() < 0.5` appears **twice** in the expression tree. Velox evaluates each occurrence independently. When `rand()` returns different values for the two evaluations, you get impossible results. For example: the first `rand()` returns 0.7, so the condition `0.7 < 0.5 = true` is FALSE — we take the else branch. But the second `rand()` returns 0.3, so the else value `0.3 < 0.5` is TRUE. The result is TRUE, which `nullif(x, true)` should never produce.
+
+Actual results from Prestissimo:
+
+```
+ _col0 | _col1
+-------+-------
+ NULL  |     4
+ true  |     4    ← should never happen
+ false |     2
+```
+
+## Why This Happens in Prestissimo
+
+Velox has a common subexpression elimination (CSE) mechanism that can detect when the same expression appears multiple times and evaluate it only once. However, CSE correctly skips non-deterministic expressions — evaluating `rand()` once and reusing the result would change the semantics of queries that intentionally use multiple independent random values. So when Presto's planner duplicates `rand() < 0.5` into both the condition and the else branch of `IF`, Velox evaluates each occurrence independently, producing different random values.
+
+The root cause is that Velox doesn't have a native `NULLIF` implementation, forcing Prestissimo to use the `IF` rewrite. Adding `NULLIF` to Velox would eliminate the need for the rewrite entirely.
+
+## Why Not a Simple Rewrite or a Regular Function?
+
+The `IF` rewrite is broken for non-deterministic expressions, as shown above. What about making `NULLIF` a regular function instead? A regular function receives pre-evaluated arguments, so there's no duplication problem.
+
+But `NULLIF` has a type complication: the types of `a` and `b` may differ. Per the SQL spec, the comparison uses the common supertype (`equal(cast(a as common_type), cast(b as common_type))`), but `NULLIF` must return `a`'s **original value in its original type**, not a cast-back version. For example, `NULLIF(tinyint_col, bigint_col)` casts both to BIGINT for comparison, but returns the original TINYINT value — not the BIGINT value cast back to TINYINT. A regular function would receive arguments already cast to a common type, losing `a`'s original value.
+
+One possible workaround: rewrite `NULLIF(a, b)` as `cast(nullif_function(cast(a as common_type), cast(b as common_type)) as typeof(a))`, where `nullif_function` is a regular same-typed function. The cast back to `typeof(a)` is lossless for integer, decimal, and varchar coercions since the value originated from the narrower type. However, when the common type is `real` or `double` (e.g., `NULLIF(bigint_col, 1.5)`), the round-trip can lose precision. In practice, comparing floating point values for equality is unreliable anyway, so rejecting `NULLIF` with a float/double common type at planning time may be acceptable.
+
+If exact value preservation is required in all cases, a **special form** is needed — a built-in expression type (like `IF`, `COALESCE`, `TRY`) that controls its own evaluation and type handling. Velox already has several special forms for similar reasons, where a construct's semantics cannot be expressed through simple function calls or rewrites.
+
+See [#17110](https://github.com/facebookincubator/velox/issues/17110) for more details and discussion.
+
+## The General Lesson
+
+Any time a SQL construct needs to use the same expression value in multiple places, it cannot be safely rewritten into a tree that duplicates that expression. This applies whenever the expression is non-deterministic (`rand()`, `uuid()`) or has side effects.
+
+`NULLIF` is not the only construct with this problem. The same class of bug affects `CASE` expressions with non-deterministic operands (see [#17115](https://github.com/facebookincubator/velox/issues/17115)).
+
+The SQL standard defines NULLIF, COALESCE, and CASE with single-evaluation semantics. When implementing a SQL engine, these semantics must be preserved through special forms that control evaluation order and multiplicity.
diff --git a/website/blog/2026-04-23-axiom-composable-query-engines.mdx b/website/blog/2026-04-23-axiom-composable-query-engines.mdx
new file mode 100644
index 00000000000..21434d2f817
--- /dev/null
+++ b/website/blog/2026-04-23-axiom-composable-query-engines.mdx
@@ -0,0 +1,183 @@
+---
+slug: axiom-composable-query-engines
+title: "Axiom: Composable Query Engines Built on Velox"
+authors: [mbasmanova, amitkdutta]
+tags: [tech-blog, axiom]
+---
+
+## Introduction
+
+[Axiom](https://github.com/facebookincubator/axiom) is a C++ library for
+building fully composable, high-performance query engines, built on top of
+Velox. Think of it as Lego for query processing — the pieces are compatible,
+but don't restrict how you put them together. Configure each layer, swap in
+your own components.
+
+Today, users face significant friction moving between interactive queries,
+batch processing, streaming, and AI training data preparation — different
+engines, different semantics, different quirks. With Axiom, we can build all
+of these on a shared foundation, delivering consistent semantics across
+deployment modes.
+
+<!-- truncate -->
+
+## The Current Landscape
+
+Velox made execution composable — plugged into Presto via Prestissimo, into
+Spark via Gluten, into streaming and AI training workloads — and delivered 2-3x
+efficiency gains across the board. Velox also opened the door to
+[GPU-accelerated query processing](https://developer.nvidia.com/blog/accelerating-large-scale-data-analytics-with-gpu-native-velox-and-nvidia-cudf/),
+with IBM and NVIDIA collaborating on GPU-native implementations of Velox
+operators for Prestissimo. But everything
+above execution remains monolithic and engine-specific.
+
+Presto excels at interactive queries with streaming shuffle — optimized for
+latency. Spark excels at batch with durable shuffle — optimized for throughput.
+DuckDB provides a great single-node experience. But they all have different
+semantics. When a Presto query organically grows beyond Presto's limits, it
+must be rewritten in Spark SQL and migrated to Spark — a non-trivial,
+error-prone effort. Sapphire (Presto-on-Spark) exists specifically to work
+around this, running Presto SQL on Spark's durable execution, but it's
+inherently awkward — bolting one engine onto another.
+
+Neither Presto nor Spark offers a practical local execution mode. Even basic
+SQL linting or running a query over in-memory VALUES requires going through the
+cluster — network calls, queuing, distributed execution. When iterating on
+analysis over the same data, trying to figure out the right way to slice and
+dice, every run goes through the cluster. Velox's AsyncDataCache can cache warm
+data in memory and SSD on Prestissimo workers, but that still requires
+distributed execution and depends on all cluster users working on the same warm
+data. There's no way to download your dataset locally, keep it in memory, and
+iterate fast on your own machine — DuckDB-style. Not possible with a monolithic
+distributed-only architecture.
+
+Under the hood, the architectures are split along language boundaries. In
+Prestissimo, Java coordinator handles SQL parsing, optimization, and
+orchestrates distributed execution; C++ worker handles local execution. They
+connect via RPC — relatively clean, but connectors are split: metadata in Java,
+data reading in C++. Constant folding is another pain point — it happens in the
+coordinator (Java) but must produce results compatible with Velox execution,
+currently solved via a C++ sidecar, but clunky. In Gluten, Spark's Catalyst
+handles SQL parsing, DataFrame API, optimization, and orchestrates distributed
+execution; Velox handles local execution. They connect via JNI — more complex,
+harder to debug.
+
+<figure style={{textAlign: 'center'}}>
+  <img src="/img/axiom-split-architectures.png" width="80%" />
+  <figcaption><em>Today's split architectures: Java/Scala coordinators connected to C++ Velox workers via RPC or JNI.</em></figcaption>
+</figure>
+
+Both coordinators are monolithic — you can't add a DataFrame API to Presto, run
+Spark SQL on Presto's coordinator, or run Presto SQL on Spark.
+
+Why hasn't anyone built a unified C++ stack before? We believe the major
+blocker has been the lack of a reusable C++ query optimizer. Optimizers are
+extremely hard to build, even with the use of AI. Catalyst is the closest thing
+to a reusable optimizer and has been widely adopted, but it's Java. So when
+Velox came along, the natural path was to plug it into existing JVM
+coordinators — building a C++ optimizer from scratch wasn't a realistic
+alternative. Until now.
+
+Velox solved composability for execution. The layers above execution need the
+same treatment. That's the gap Axiom aims to fill.
+
+## How Axiom Solves This
+
+Axiom decomposes the query engine into a set of independent, reusable
+components — frontends, optimizer, runtime, connectors, execution — connected
+by stable, engine-agnostic APIs. Each component can be swapped, extended, or
+composed independently. The key APIs are the logical plan (between frontends
+and the optimizer) and the physical plan (between the optimizer and the
+runtime). Axiom builds on Velox's extensible type system and function
+registry — the same types and function implementations are used by the
+optimizer and by execution, so semantics are consistent by construction. This
+is what makes it possible for different engines to plug in their own frontends
+or target different deployment modes — without forking or rebuilding the rest.
+
+Composability requires crisp, clear contracts between components. Monolithic
+engines tend to treat these boundaries more fluidly, with code that sometimes
+crosses layer boundaries. This makes composability harder to build, but the
+resulting clarity pays off in extensibility and reuse.
+
+<figure style={{textAlign: 'center'}}>
+  <img src="/img/axiom-architecture.png" width="90%" />
+  <figcaption><em>Axiom's composable architecture: independent components connected by stable APIs.</em></figcaption>
+</figure>
+
+The logical plan is a fully resolved, typed, dialect-agnostic representation of
+the query — the contract between frontends and the optimizer. It describes
+*what* the query does, not *how* to execute it. The logical plan has 13 node
+types; Velox has 32. For example, there is a single logical JoinNode that
+specifies what to join, but the optimizer decides *how* — whether it becomes a
+HashJoinNode, MergeJoinNode, or NestedLoopJoinNode in Velox. Any frontend that
+produces a valid logical plan can use the same optimizer and execution stack.
+This is what makes it practical to add a Spark SQL parser or a PySpark
+DataFrame API without touching the rest of the system.
+
+The optimizer directly uses Velox's function registry and expression
+evaluator — constant folding uses the same code path as query execution, with
+no integration overhead. The optimizer can also fold constant scalar subqueries
+by executing them in-process. It knows which Velox operators exist and can
+target them directly — for example, using counting joins for EXCEPT ALL. No
+need for a 2700-line conversion layer to translate between plan representations
+that don't map one-to-one.
+
+The optimizer produces a physical plan (MultiFragmentPlan) — a set of Velox
+plan fragments connected by shuffle boundaries. The deployment topology is an
+input to the optimizer — shuffle costs affect join ordering and other plan
+decisions.
+
+The runtime is the component that enables different deployment modes — it takes
+the physical plan and executes it locally in a single process, distributes with
+streaming shuffle for interactive latency, or distributes with durable shuffle
+for batch throughput. Axiom ships with a local execution runtime (LocalRunner)
+and a CLI that serves as a reference implementation illustrating how the
+components fit together. Axel, a separate initiative, is building a Presto-like
+distributed runtime on top of Axiom.
+
+Connectors are also unified. Planning-time logic (metadata, statistics,
+partition pruning) and execution-time logic (data reading) live in the same
+language, unlike Prestissimo and Gluten where they are split across Java and
+C++.
+
+## Where We Are
+
+Building a composable query processing stack is a long journey. Velox was a big
+step forward, but there are still many steps to take. We are still early, but
+the foundation is in place and the results so far are encouraging.
+
+All TPC-H queries work end-to-end, producing optimal plans. We are actively
+migrating production workloads at Meta — the optimizer and execution stack are
+handling real queries at scale, not just benchmarks.
+
+Axiom includes an [interactive CLI](https://github.com/facebookincubator/axiom/blob/main/axiom/cli/README.md) that lets developers and users run SQL
+locally against TPC-H, Hive, or in-memory data. This has become a popular tool
+for rapid prototyping and testing — users love sub-second SQL linting and
+validation without waiting for a cluster round-trip.
+
+We are also extending Presto SQL with user-friendly features inspired by
+DuckDB: FROM-first syntax, trailing commas, SELECT * EXCLUDE/REPLACE, and more
+(see [Presto SQL Extensions](https://github.com/facebookincubator/axiom/blob/main/axiom/sql/presto/docs/PrestoSqlExtensions.md)).
+
+The composable architecture is proving itself beyond the original use case. The
+graph query team built a Cypher frontend that produces Axiom's logical plan and
+leverages the optimizer's cost-based join reordering for graph pattern
+matching — demonstrating that the logical plan and optimizer work for non-SQL
+languages. Both the streaming and AI training data processing teams adopted
+Axiom's Presto SQL parser to offer a SQL interface alongside their existing
+Python APIs.
+
+## Get Involved
+
+Velox made execution composable and delivered massive efficiency gains. Axiom
+extends that same vision to the full query processing stack. The pieces are
+there — come help us put them together.
+
+We want to partner with the community to tackle what's next. A Spark SQL parser
+and PySpark DataFrame API would close the gap between Presto and Spark users.
+There is room for more Friendly SQL features. The optimizer can become more
+extensible and add support for index and merge joins. Axel will benefit from
+durable shuffle to enable batch workloads with the fault tolerance that Spark
+users expect. And the connector ecosystem is ready to grow.
+
+- GitHub: [facebookincubator/axiom](https://github.com/facebookincubator/axiom#getting-started)
diff --git a/website/blog/2026-04-27-nimble-cluster-index.mdx b/website/blog/2026-04-27-nimble-cluster-index.mdx
new file mode 100644
index 00000000000..240accbb113
--- /dev/null
+++ b/website/blog/2026-04-27-nimble-cluster-index.mdx
@@ -0,0 +1,159 @@
+---
+slug: nimble-cluster-index
+title: "Nimble Cluster Index: Efficient Indexed Lookups on Columnar Data"
+authors: [xiaoxmeng, tanjialiang, zacw, zzhao, pedroerp, mbasmanova]
+tags: [tech-blog, nimble, performance]
+---
+
+## Introduction
+
+Analytical data lakes excel at full-table scans but struggle with point lookups. Key-value stores handle point lookups efficiently but cannot serve analytical queries. What if a single file format could serve both workloads?
+
+Nimble's **Cluster Index** bridges this gap. It is a lightweight, hierarchical index structure embedded directly inside Nimble columnar files. It enables O(log n) point lookups and range scans on sorted data — without a separate index file, without an external service, and without sacrificing Nimble's columnar scan performance.
+
+We have integrated the cluster index with **Presto** for analytical index joins and are actively integrating with **ZippyDB** for prefix key scans — both powered by the same underlying index structure, served through Velox.
+
+## Motivation
+
+Consider a common pattern in data warehousing: a large fact table needs to be joined with a dimension table on a key column. Traditional hash joins materialize both sides into memory. For selective lookups — where the probe side touches only a fraction of the build side — this is wasteful.
+
+Index joins solve this: for each probe key, look up only the matching rows in the build table, skipping everything else. But this requires an efficient index on the build-side file.
+
+Similarly, in ML training data serving, workloads need prefix key scans with column projection — e.g., fetching a user's event history while reading only the features a model needs. Without an index, this requires scanning entire stripes — unacceptable at serving latency.
+
+The cluster index addresses both use cases with a single, unified design.
+
+## File Layout
+
+The cluster index is stored as a FlatBuffer-serialized optional section in the Nimble file footer. No separate index file is needed — the index lives alongside the data it references.
+
+<figure style={{textAlign: 'center'}}>
+  <img src="/img/nimble-cluster-index-file-layout.png" width="95%" />
+  <figcaption><em>Nimble file layout showing the cluster index as an optional section in the footer, with its internal hierarchical structure of partitions and key stream chunks.</em></figcaption>
+</figure>
+
+### Hierarchical Structure
+
+The index is organized as a three-level hierarchy designed to minimize I/O:
+
+**Level 1: Root ClusterIndex.** The root is a FlatBuffer table embedded in the file footer's optional sections. It contains the index column names, sort orders, and an array of `partition_keys` — the boundary keys for each index group. Since this metadata is loaded when the file is opened, the first level of binary search requires **zero additional I/O**.
+
+**Level 2: Index Groups.** Each index group corresponds 1:1 to a stripe group and contains metadata for the chunks within it: `chunk_keys` (boundary keys per chunk), `chunk_offsets`, and `chunk_rows` (accumulated row counts). Index groups are written inline after each stripe group and loaded on demand — only the group(s) that could contain the lookup key are read from disk.
+
+**Level 3: Key Stream Chunks.** The actual encoded keys live in the key stream, divided into fixed-size chunks. Each chunk stores keys using prefix encoding (with a configurable restart interval) for compact representation. Only the specific chunk(s) identified by the group-level binary search are read and decoded.
+
+### Key Encoding
+
+Multi-column index keys are serialized into a single byte-comparable binary string using Velox's `KeyEncoder`. The sort order (ascending or descending) for each column is baked into the encoding, so a simple byte comparison on the encoded key correctly handles multi-column composite keys with mixed sort orders.
+
+### Lookup Flow
+
+A lookup proceeds through the hierarchy:
+
+1. **Binary search on `partition_keys`** — identifies which index group(s) could contain the target key. This is pure in-memory computation — no I/O.
+2. **Load index group metadata** — reads the matching group's FlatBuffer from disk (cached for repeated lookups).
+3. **Binary search on `chunk_keys`** — narrows down to specific chunk(s) within the group. Again, in-memory only.
+4. **Seek within chunk** — reads and decodes the key stream chunk, then binary searches the materialized keys to find the exact row range.
+
+The result is a set of file-level row ranges — contiguous for both point lookups and range scans since the data is sorted by the index key.
+
+The key design insight is that **the common case — eliminating entire index groups — requires no disk I/O at all**. Only when a group is a candidate does the system incur reads, and even then, only the specific chunk within that group is loaded.
+
+## Beyond ClusterIndex: Hash and Sorted Indices
+
+While the cluster index is optimized for sorted data, Nimble also supports two additional index types for unsorted data:
+
+**HashIndex** — O(1) amortized point lookups using a hash table with optional Bloom filter. The Bloom filter follows the Parquet split-block design (256-bit blocks, 8 hash probes per block, xxHash64) for cache-friendly probabilistic filtering before accessing the hash buckets.
+
+**SortedIndex** — A secondary index that maintains a separately sorted copy of the keys alongside their original row IDs. Each entry in the sorted key stream is a composite `encoded_key || fixed_width_row_id`, enabling binary search while carrying the row ID inline. This supports both point lookups and range scans on unsorted data.
+
+All three index types implement a unified `IndexLookup` interface with `PointLookup` and `RangeScan` modes, and are discovered through the `DenseIndexRegistry` which transparently selects the best available index for a given set of columns.
+
+## Integration with Presto
+
+We integrated the Nimble cluster index with Presto's native execution engine (Prestissimo) through Velox's `IndexLookupJoin` operator.
+
+<figure style={{textAlign: 'center'}}>
+  <img src="/img/nimble-cluster-index-architecture.png" width="95%" />
+  <figcaption><em>Integration architecture showing the Presto path (left) and ZippyDB path (right), both sharing the same ClusterIndex core.</em></figcaption>
+</figure>
+
+### The Execution Path
+
+The Presto integration flows through several layers:
+
+**Presto Coordinator (Java)** — The query optimizer recognizes index join opportunities and generates an `IndexJoinNode` in the query plan, with planner rules for lookup variable extraction, non-equal join condition support, and index join session properties.
+
+**Velox IndexLookupJoin** — The execution operator receives probe-side input batches and performs index lookups against the cluster indexed table. It projects lookup columns from each probe batch, detects and excludes null keys, and calls into the connector's `IndexSource` for the actual lookup. For left joins, unmatched probe rows are emitted with null values for the lookup columns. The operator pipelines multiple probe batches to overlap lookup I/O with processing.
+
+**HiveIndexSource** — Implements Velox's `connector::IndexSource` interface for Hive tables. The coordinator retrieves index metadata from the Hive metastore (declared via the `indexed_by` DDL table property) and passes it to the worker through the table handle.
+
+**SelectiveNimbleIndexReader** — The Nimble-specific implementation of Velox's `IndexReader` interface. It converts index bounds into encoded key bounds, calls `ClusterIndex::lookup()` to resolve file-level row ranges, then maps those ranges to stripes and iterates through them using the selective column reader with precise `seekTo()` operations.
+
+A notable design detail in the reader is how it handles overlapping row ranges from multiple lookup requests. When no additional filter is present, it merges overlapping ranges for efficient bulk reads. When a filter is present, it splits ranges into non-overlapping segments so that filtered output can be correctly attributed back to the originating request.
+
+### Usage
+
+With the integration in place, users can create Nimble tables with a cluster index and query them with index joins:
+
+```sql
+-- Create a table with cluster index on the key column
+CREATE TABLE dimension_table (
+    key_col BIGINT,
+    value_col VARCHAR,
+    ...
+) WITH (
+    format = 'NIMBLE',
+    indexed_by = '["key_col"]'
+);
+
+-- The optimizer automatically chooses index join when beneficial
+SELECT f.*, d.value_col
+FROM fact_table f
+JOIN dimension_table d ON f.key_col = d.key_col
+WHERE f.date = '2026-04-27';
+```
+
+## Integration with ZippyDB
+
+We are actively integrating the cluster index with ZippyDB to serve point lookup workloads. The integration uses a fundamentally different strategy than the Presto path, optimized for serving latency rather than analytical throughput.
+
+### Server-Side Zero-Decode Projection
+
+The key innovation in the ZippyDB path is the `NimbleIndexProjector`, which implements a **zero-decode passthrough** strategy. Instead of decoding Nimble-encoded data into Velox vectors on the server (as the Presto path does), it extracts the raw encoded stream bytes and sends them directly to clients via the [Nimble serializer](https://github.com/facebookincubator/nimble/tree/main/dwio/nimble/serializer) — without decoding or re-encoding. The client deserializes and decodes locally. This design shifts the CPU cost of decoding from the centralized lookup service to the distributed clients — critical for a serving system where the server is the bottleneck.
+
+The projector uses the same `ClusterIndex::lookup()` for key-to-row-range resolution, but then takes a completely different serialization path. It builds per-stripe results by copying raw stream bytes directly from the tablet's encoded streams, with no intermediate decode/re-encode step.
+
+### Design Tradeoffs
+
+| Aspect | Presto Path | ZippyDB Path |
+|--------|-------------|--------------|
+| **Decode location** | Server (Velox vectors) | Client (raw bytes) |
+| **Output format** | `RowVector` | Nimble serializer |
+| **Filter support** | Full pushdown | Key-only |
+| **Optimized for** | Throughput | Latency |
+| **CPU bottleneck** | Distributed workers | Centralized server |
+
+## Performance Characteristics
+
+The hierarchical design provides several performance properties:
+
+**Minimal I/O amplification.** A point lookup on a file with millions of rows typically requires 2 disk reads: one for the index group metadata and one for the target key stream chunk. The root-level group search is free — it's already in memory from the file open.
+
+**Bounded memory overhead.** Only the root FlatBuffer is kept in memory permanently. Index group metadata and key stream chunks are loaded on demand and can be cached or evicted independently.
+
+**Write-time cost is low.** The index is built incrementally during writes — keys are encoded as a byte stream and chunked as rows are flushed. The root-level partition metadata is assembled at file close. There is no post-write index building step.
+
+**Composability with columnar scans.** The cluster index produces row ranges, not decoded values. These row ranges feed directly into the selective column reader's `seekTo()` mechanism, which uses the separate `ChunkIndex` (a position-to-offset mapping per stream) to skip efficiently within stripes. The index lookup and the columnar read are cleanly separated — the index narrows the search space, and the columnar reader handles the actual data extraction.
+
+## What's Next
+
+We are continuing to expand the cluster index ecosystem:
+
+- **ZippyDB production integration** — completing the end-to-end integration with ZippyDB's serving layer.
+- **Adaptive index selection** — automatically choosing between cluster, hash, and sorted indices based on query patterns and data characteristics.
+- **Vector search index** — exploring embedding FAISS-based approximate nearest neighbor indices inside Nimble files, co-locating vector search with columnar data so one indexed file serves analytical queries, training pipelines, and retrieval workloads.
+
+## Acknowledgements
+
+Thanks to the Velox, Nimble, and Presto teams at Meta for the foundational infrastructure and integration work that makes this possible.
diff --git a/website/blog/2026-05-01-flatmapvector.mdx b/website/blog/2026-05-01-flatmapvector.mdx
new file mode 100644
index 00000000000..ce49a73e08f
--- /dev/null
+++ b/website/blog/2026-05-01-flatmapvector.mdx
@@ -0,0 +1,112 @@
+---
+slug: flatmapvector
+title: "FlatMapVector Adoption for Scaling High-Performance AI/ML Data Pre-Processing"
+authors: [peterenescu, pedroerp, kkpulla, yuhta, kevinwilfong]
+tags: [tech-blog, performance, vectors]
+---
+
+## Context
+
+At Meta, features used for AI use cases are largely combined and stored within warehouse tables as *map* columns because frequent access to and manipulation of these features can scale poorly if modelled as top-level columns, which would result in extremely wide tables and frequent schema changes. Thus, to provide maximum flexibility, features are modeled as maps.
+
+In a traditional columnar layout, map columns are typically represented in-memory by a few data streams. The diagram below illustrates an example dataset. Two main buffers or streams are allocated for map keys and values. Additional buffers are used for null flags and map offsets or lengths (note that map keys are non-nullable):
+
+<!-- truncate -->
+
+<figure style={{textAlign: 'center'}}>
+  <img src="/img/flatmapvector-tradtional-map-layout.png" width="80%" />
+  <figcaption><em>Traditional columnar map layout: shared key and value buffers with offset-based indexing.</em></figcaption>
+</figure>
+
+While simple, fast, and efficient, common map operations, like feature projection, cannot be trivially executed without materializing the entire map. For extremely wide tables where only a subset of map keys are read, like in many AI workloads, reading and decoding the entire map makes these operations impractical at scale.
+
+## Flat Maps
+
+To enable efficient map transformations that operate over particular map keys, Meta uses the "flat map" map encoding. The term "flat maps" refers to a logical encoding that stores map data using value streams grouped by key. The diagram below reuses the same example above, but illustrates the "flat map" encoding. Notice the individualized value streams, identified by their unique key value.
+
+<figure style={{textAlign: 'center'}}>
+  <img src="/img/flatmapvector-flatmap-map-layout.png" width="80%" />
+  <figcaption><em>Flat map encoding: value streams grouped by key, with per-key "in map" and null bitmaps.</em></figcaption>
+</figure>
+
+Flat maps provide several fields: a unique set of keys, and a list of value streams and "in map" and "null" buffers. Value streams and buffers are sized to match the rows in the table.
+
+Flat maps also use a "null" bitmap buffer, like traditional maps; however, unlike traditional maps, flat maps also provide an "in map" buffer. This additional bitmap is used to identify whether or not a particular key-value pair exists in a particular row.
+
+Since streams and buffers are grouped by key, certain map operations like key filtering and projection do not require full vector materialization. The drawback, however, is worse storage efficiency due to fragmented, full-length data streams.
+
+## Flat Maps at Meta
+
+"Flat map" encoding is not a novel concept and is already used extensively at the storage layer in many training tables at Meta, but prior to a recent effort, no equivalent in-memory layout existed in Velox's compute framework.
+
+To avoid flat map to map conversion overhead, certain engines like DPP and Spark awkwardly cast flat maps as row types, which solves the problem, but severely limits training data context and ability to leverage map functions. Moreover, other compute engines like Presto are unable to leverage this workaround since the implicit conversion from MAP to ROW results in irreconcilable semantic differences.
+
+To improve the efficiency of our AI training workloads, we have designed and implemented a new Velox vector type to our data processing framework that provides a native in-memory flat map encoding for Velox map types: [**FlatMapVectors**](https://github.com/facebookincubator/velox/blob/main/velox/vector/FlatMapVector.h).
+
+## Pilot Use Cases
+
+To pilot our first internal FlatMapVector use cases, we targeted two Spark use cases: feature injection and feature reaping. Feature injection refers to the process of adding new features to map columns, while feature reaping does the opposite, removing features.
+
+To support these use cases, full-stack support would be required to support our new vector type. Some of this work included adding new readers and writers to our DWRF and Nimble IO suite and adding FlatMapVector support to our map UDFs. In theory, the former should provide immediate wins by eliminating conversion overhead, but how do end-to-end performance numbers look in practice? Let's start by examining two production tables onboarded to our feature reaping and injection pipelines. These two tables provide a good sample of our workloads:
+
+**Table 1 (1,000 rows)**
+
+| Metric | MapVector | FlatMapVector | Improvement |
+|--------|-----------|---------------|-------------|
+| TableScan Input | 26.22 GB | 34.96 MB | 768x more compact |
+| TableScan CPU Time | 9.52s | 1.85s | 5.1x faster |
+| TableScan Wall Time | 11.30s | 3.75s | 3.0x faster |
+| TableScan Allocs | 1,254,358 | 213,629 | 5.9x fewer |
+| TableWrite CPU Time | 19.82s | 14.03s | 1.4x faster |
+| TableWrite Wall Time | 23.07s | 17.37s | 1.3x faster |
+| TableWrite Output | 212.01 MB | 212.02 MB | same |
+
+**Table 2 (100K rows)**
+
+| Metric | MapVector | FlatMapVector | Improvement |
+|--------|-----------|---------------|-------------|
+| TableScan Input | 19.87 TB | 15.20 GB | 1,338x more compact |
+| TableScan CPU Time | 6h 52m | 23m 50s | 17.3x faster |
+| TableScan Wall Time | 7h 3m | 28m 49s | 14.7x faster |
+| TableScan Allocs | 4,207,241,070 | 196,178,311 | 21.4x fewer |
+| TableWrite CPU Time | 2h 59m | 1h 46m | 1.7x faster |
+| TableWrite Wall Time | 3h 9m | 1h 54m | 1.7x faster |
+| TableWrite Output | 66.27 GB | 65.44 GB | ~same |
+
+As expected, without high conversion overhead, reading and writing is significantly improved, producing 5x and 17x read latency improvements for both of our tables, respectively. We also see astronomical memory savings, quite literally reducing magnitudes of consumed resources in either case.
+
+Moreover, it seems that the larger consumed data becomes, the wider the performance gaps grow between the vector types, demonstrating the serious consequences of map conversion at scale. Are these performance wins enough to see end-to-end results? Let's now examine how our vectors behave in-memory, starting with feature projection used heavily in feature injection. The below benchmarks feature projection over various mixed feature counts:
+
+| Scenario (<u>D</u>istinct Keys, average <u>K</u>eys per row) | MapVector | FlatMapVector | Speedup |
+|--------------------------------------------------------------|-----------|---------------|---------|
+| D=10, K=5 | 129ms | 0.6ms | 215x |
+| D=50, K=10 | 190ms | 0.6ms | 327x |
+| D=50, K=10 | 269ms | 0.6ms | 453x |
+| D=200, K=20 | 488ms | 0.6ms | 820x |
+
+As expected, FlatMapVector provides constant lookup due to grouped value streams. Meanwhile, MapVector grows with volume size due to hash-lookup. Feature projection is a clear win.
+
+Filtering, on the other hand, is a little more nuanced. FlatMapVectors suffer from value filtering due to fragmented value streams; however, because feature reaping uses feature (key-only) predicates, we still see some improvement:
+
+| Scenario (<u>D</u>istinct Keys, average <u>K</u>eys per row) | Filter (% of keys filtered out) | MapVector | FlatMapVector | Speedup |
+|--------------------------------------------------------------|----------------------------------|-----------|---------------|---------|
+| D=10, K=5 | large (90%) | 58ms | 22ms | 2.6x faster |
+| | half (50%) | 51ms | 13ms | 4.0x faster |
+| | narrow (10%) | 52ms | 5.5ms | 9.4x faster |
+| D=50, K=10 | large (90%) | 104ms | 104ms | 1.0x (tie) |
+| | half (50%) | 92ms | 66ms | 1.4x faster |
+| | narrow (10%) | 79ms | 24ms | 3.3x faster |
+| D=200, K=20 | large (90%) | 211ms | 533ms | 2.6x slower |
+| | half (50%) | 190ms | 302ms | 1.6x slower |
+| | narrow (10%) | 178ms | 131ms | 1.4x faster |
+| D=500, K=50 | large (90%) | 531ms | 1.48s | 2.8x slower |
+| | half (50%) | 478ms | 863ms | 1.8x slower |
+| | narrow (10%) | 369ms | 260ms | 1.4x faster |
+
+The more selective the key filter, the better FlatMapVector performs. The cost scales with the number of matching channels. For large filters (90%), copying the majority of value streams and buffers can be quite expensive. This is a known issue exposed by our in-progress support for partition merge; however, narrow filters more closely represent our production feature reaping workloads, where FlatMapVector consistently wins.
+
+## So What?
+
+Although only first targeting specified use cases, the introduction of FlatMapVectors into Velox's compute framework represents a demonstrable step forward in scaling high-performance AI data pre-processing. Quite literally, both feature reaping and feature injection see magnitudes of performance increases by avoiding map conversion overhead and significant in-memory feature projection and filtering speedup. Leveraging FlatMapVectors for scaling AI workloads appears to no longer be negotiable.
+
+We already have several workstreams to continue to support FlatMapVectors across multiple warehouse use cases. For one, we want to continue onboarding new Spark workloads, which as demonstrated above provides tangible wins for our internal Spark users. Additionally, we want to completely descope the ROW type workaround for flat maps in engines like DPP. Both this and support in Presto necessitate flat map encoding implementations in map UDFs, which is a non-trivial task. Eventually, we'd like FlatMapVectors to be the default way to access data written to storage as flat maps, across all Velox-supported engines.
diff --git a/website/blog/authors.yml b/website/blog/authors.yml
index d616967290c..275fa05abed 100644
--- a/website/blog/authors.yml
+++ b/website/blog/authors.yml
@@ -95,3 +95,63 @@ GregoryKimball:
   title: Software Engineer @ NVIDIA
   url: https://github.com/GregoryKimball
   image_url: https://github.com/GregoryKimball.png
+
+yuhta:
+  name: Yuhta
+  title: Software Engineer @ Meta
+  url: https://github.com/Yuhta
+  image_url: https://github.com/Yuhta.png
+
+PingLiuPing:
+  name: Ping Liu
+  title: Software Engineer
+  url: https://github.com/PingLiuPing
+  image_url: https://github.com/PingLiuPing.png
+
+Rajeev975:
+  name: Rajeev Singh
+  title: Software Engineer @ Meta
+  url: https://github.com/Rajeev975
+  image_url: https://github.com/Rajeev975.png
+
+bikramSingh91:
+  name: Bikram Singh
+  title: Software Engineer @ Meta
+  url: https://github.com/bikramSingh91
+  image_url: https://github.com/bikramSingh91.png
+
+peterenescu:
+  name: Peter Enescu
+  title: Software Engineer @ Meta
+  url: https://github.com/peterenescu
+  image_url: https://github.com/peterenescu.png
+
+zacw:
+  name: Zac Wen
+  title: Software Engineer @ Meta
+  url: https://github.com/zacw7
+  image_url: https://github.com/zacw7.png
+
+zzhao:
+  name: Zhenyuan Zhao
+  title: Software Engineer @ Meta
+  url: https://github.com/zzhao0
+  image_url: https://github.com/zzhao0.png
+
+kevinwilfong:
+  name: Kevin Wilfong
+  title: Software Engineer @ Meta
+  url: https://github.com/kevinwilfong
+  image_url: https://github.com/kevinwilfong.png
+
+kkpulla:
+  name: Kk Pulla
+  title: Software Engineer @ Meta
+  url: https://github.com/kkpulla
+  image_url: https://github.com/kkpulla.png
+
+amitkdutta:
+  name: Amit Dutta
+  title: Software Engineer @ Meta
+  url: https://github.com/amitkdutta
+  image_url: https://github.com/amitkdutta.png
diff --git a/website/docs/community/03-components-and-maintainers.md b/website/docs/community/03-components-and-maintainers.md
index e23c9ac83ec..2e68df2f43d 100644
--- a/website/docs/community/03-components-and-maintainers.md
+++ b/website/docs/community/03-components-and-maintainers.md
@@ -52,6 +52,7 @@ maintainers of that component.
 * Jimmy Lu - [Yuhta](https://github.com/Yuhta) / jimmylu@meta.com
 * Masha Basmanova - [mbasmanova](https://github.com/mbasmanova) / mbasmanova@meta.com
 * Xiaoxuan Meng - [xiaoxmeng](https://github.com/xiaoxmeng) / xiaoxmeng@meta.com
+* Meng Duan - [duanmeng](https://github.com/duanmeng) / meng.duan@bytedance.com
 
 ### Presto Functions
 
@@ -67,6 +68,7 @@ maintainers of that component.
 ### Memory Management
 
 * Xiaoxuan Meng - [xiaoxmeng](https://github.com/xiaoxmeng) / xiaoxmeng@meta.com
+* Meng Duan - [duanmeng](https://github.com/duanmeng) / meng.duan@bytedance.com
 
 ### IO, Cache, Hive connector, and File reader/writers
 
@@ -84,6 +86,11 @@ maintainers of that component.
 ### Storage Adapters (S3/HDFS/GCS/ABFS)
 
 * Deepak Majeti - [majetideepak](https://github.com/majetideepak) / deepak.majeti@ibm.com
+* Ke Jia - [JkSelf](https://github.com/jkself) / ke.a.jia@intel.com
+
+### LibcuDF Bindings
+
+* Karthikeyan Natarajan - [karthikeyann](https://github.com/karthikeyann) / knataraj@nvidia.com
 
 ### Builds and CI
 
@@ -96,3 +103,4 @@ maintainers of that component.
 
 * Masha Basmanova - [mbasmanova](https://github.com/mbasmanova) / mbasmanova@meta.com
 * Pedro Pedreira - [pedroerp](https://github.com/pedroerp) / pedroerp@meta.com
+* Meng Duan - [duanmeng](https://github.com/duanmeng) / meng.duan@bytedance.com
diff --git a/website/docusaurus.config.js b/website/docusaurus.config.js
index 466f42a9e45..928faf5b179 100644
--- a/website/docusaurus.config.js
+++ b/website/docusaurus.config.js
@@ -38,6 +38,7 @@ const config = {
         blog: {
           showReadingTime: true,
           onUntruncatedBlogPosts: 'ignore',
+          blogSidebarCount: 24,
         },
         theme: {
           customCss: require.resolve('./src/css/custom.css'),
diff --git a/website/package-lock.json b/website/package-lock.json
index d7c941a65d0..35bd330e89f 100644
--- a/website/package-lock.json
+++ b/website/package-lock.json
@@ -1,16 +1,16 @@
 {
   "name": "website",
   "version": "0.0.0",
-  "lockfileVersion": 3,
+  "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "website",
       "version": "0.0.0",
       "dependencies": {
-        "@docusaurus/core": "3.6.3",
-        "@docusaurus/plugin-google-gtag": "^3.6.3",
-        "@docusaurus/preset-classic": "3.6.3",
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/plugin-google-gtag": "3.10.0",
+        "@docusaurus/preset-classic": "3.10.0",
         "@mdx-js/react": "^3.1.0",
         "axios": "^1.7.9",
         "clsx": "^2.1.1",
@@ -19,231 +19,173 @@
         "react-dom": "^18.3.1"
       },
       "devDependencies": {
-        "@docusaurus/module-type-aliases": "3.6.3"
+        "@docusaurus/module-type-aliases": "3.10.0"
       },
       "engines": {
         "node": ">=18.0"
       }
     },
+    "node_modules/@algolia/abtesting": {
+      "version": "1.17.0",
+      "resolved": "https://registry.facebook.net/@algolia/abtesting/-/abtesting-1.17.0.tgz",
+      "integrity": "sha512-nuhHZdTiCtRzJEe9VSNzyqE9cOQMt01UWBzymFnjbgwrxxZpbGHQde6Oa/y9zyspTCjbUtb7Q5HQek1CLiLyeg==",
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.51.0",
+        "@algolia/requester-browser-xhr": "5.51.0",
+        "@algolia/requester-fetch": "5.51.0",
+        "@algolia/requester-node-http": "5.51.0"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
     "node_modules/@algolia/autocomplete-core": {
-      "version": "1.17.7",
-      "resolved": "https://registry.npmjs.org/@algolia/autocomplete-core/-/autocomplete-core-1.17.7.tgz",
-      "integrity": "sha512-BjiPOW6ks90UKl7TwMv7oNQMnzU+t/wk9mgIDi6b1tXpUek7MW0lbNOUHpvam9pe3lVCf4xPFT+lK7s+e+fs7Q==",
+      "version": "1.19.8",
+      "resolved": "https://registry.facebook.net/@algolia/autocomplete-core/-/autocomplete-core-1.19.8.tgz",
+      "integrity": "sha512-3YEorYg44niXcm7gkft3nXYItHd44e8tmh4D33CTszPgP0QWkaLEaFywiNyJBo7UL/mqObA/G9RYuU7R8tN1IA==",
       "license": "MIT",
       "dependencies": {
-        "@algolia/autocomplete-plugin-algolia-insights": "1.17.7",
-        "@algolia/autocomplete-shared": "1.17.7"
+        "@algolia/autocomplete-plugin-algolia-insights": "1.19.8",
+        "@algolia/autocomplete-shared": "1.19.8"
+      }
+    },
+    "node_modules/@algolia/autocomplete-core/node_modules/@algolia/autocomplete-shared": {
+      "version": "1.19.8",
+      "resolved": "https://registry.facebook.net/@algolia/autocomplete-shared/-/autocomplete-shared-1.19.8.tgz",
+      "integrity": "sha512-h5hf2t8ejF6vlOgvLaZzQbWs5SyH2z4PAWygNAvvD/2RI29hdQ54ldUGwqVuj9Srs+n8XUKTPUqb7fvhBhQrnQ==",
+      "license": "MIT",
+      "peerDependencies": {
+        "@algolia/client-search": ">= 4.9.1 < 6",
+        "algoliasearch": ">= 4.9.1 < 6"
       }
     },
     "node_modules/@algolia/autocomplete-plugin-algolia-insights": {
-      "version": "1.17.7",
-      "resolved": "https://registry.npmjs.org/@algolia/autocomplete-plugin-algolia-insights/-/autocomplete-plugin-algolia-insights-1.17.7.tgz",
-      "integrity": "sha512-Jca5Ude6yUOuyzjnz57og7Et3aXjbwCSDf/8onLHSQgw1qW3ALl9mrMWaXb5FmPVkV3EtkD2F/+NkT6VHyPu9A==",
+      "version": "1.19.8",
+      "resolved": "https://registry.facebook.net/@algolia/autocomplete-plugin-algolia-insights/-/autocomplete-plugin-algolia-insights-1.19.8.tgz",
+      "integrity": "sha512-ZvJWO8ZZJDpc1LNM2TTBdmQsZBLMR4rU5iNR2OYvEeFBiaf/0ESnRSSLQbryarJY4SVxtoz6A2ZtDMNM+iQEAA==",
       "license": "MIT",
       "dependencies": {
-        "@algolia/autocomplete-shared": "1.17.7"
+        "@algolia/autocomplete-shared": "1.19.8"
       },
       "peerDependencies": {
         "search-insights": ">= 1 < 3"
       }
     },
-    "node_modules/@algolia/autocomplete-preset-algolia": {
-      "version": "1.17.7",
-      "resolved": "https://registry.npmjs.org/@algolia/autocomplete-preset-algolia/-/autocomplete-preset-algolia-1.17.7.tgz",
-      "integrity": "sha512-ggOQ950+nwbWROq2MOCIL71RE0DdQZsceqrg32UqnhDz8FlO9rL8ONHNsI2R1MH0tkgVIDKI/D0sMiUchsFdWA==",
+    "node_modules/@algolia/autocomplete-plugin-algolia-insights/node_modules/@algolia/autocomplete-shared": {
+      "version": "1.19.8",
+      "resolved": "https://registry.facebook.net/@algolia/autocomplete-shared/-/autocomplete-shared-1.19.8.tgz",
+      "integrity": "sha512-h5hf2t8ejF6vlOgvLaZzQbWs5SyH2z4PAWygNAvvD/2RI29hdQ54ldUGwqVuj9Srs+n8XUKTPUqb7fvhBhQrnQ==",
       "license": "MIT",
-      "dependencies": {
-        "@algolia/autocomplete-shared": "1.17.7"
-      },
       "peerDependencies": {
         "@algolia/client-search": ">= 4.9.1 < 6",
         "algoliasearch": ">= 4.9.1 < 6"
       }
     },
     "node_modules/@algolia/autocomplete-shared": {
-      "version": "1.17.7",
-      "resolved": "https://registry.npmjs.org/@algolia/autocomplete-shared/-/autocomplete-shared-1.17.7.tgz",
-      "integrity": "sha512-o/1Vurr42U/qskRSuhBH+VKxMvkkUVTLU6WZQr+L5lGZZLYWyhdzWjW0iGXY7EkwRTjBqvN2EsR81yCTGV/kmg==",
+      "version": "1.19.2",
+      "resolved": "https://registry.facebook.net/@algolia/autocomplete-shared/-/autocomplete-shared-1.19.2.tgz",
+      "integrity": "sha512-jEazxZTVD2nLrC+wYlVHQgpBoBB5KPStrJxLzsIFl6Kqd1AlG9sIAGl39V5tECLpIQzB3Qa2T6ZPJ1ChkwMK/w==",
       "license": "MIT",
       "peerDependencies": {
         "@algolia/client-search": ">= 4.9.1 < 6",
         "algoliasearch": ">= 4.9.1 < 6"
       }
     },
-    "node_modules/@algolia/cache-browser-local-storage": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/cache-browser-local-storage/-/cache-browser-local-storage-4.24.0.tgz",
-      "integrity": "sha512-t63W9BnoXVrGy9iYHBgObNXqYXM3tYXCjDSHeNwnsc324r4o5UiVKUiAB4THQ5z9U5hTj6qUvwg/Ez43ZD85ww==",
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/cache-common": "4.24.0"
-      }
-    },
-    "node_modules/@algolia/cache-common": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/cache-common/-/cache-common-4.24.0.tgz",
-      "integrity": "sha512-emi+v+DmVLpMGhp0V9q9h5CdkURsNmFC+cOS6uK9ndeJm9J4TiqSvPYVu+THUP8P/S08rxf5x2P+p3CfID0Y4g==",
-      "license": "MIT"
-    },
-    "node_modules/@algolia/cache-in-memory": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/cache-in-memory/-/cache-in-memory-4.24.0.tgz",
-      "integrity": "sha512-gDrt2so19jW26jY3/MkFg5mEypFIPbPoXsQGQWAi6TrCPsNOSEYepBMPlucqWigsmEy/prp5ug2jy/N3PVG/8w==",
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/cache-common": "4.24.0"
-      }
-    },
     "node_modules/@algolia/client-abtesting": {
-      "version": "5.18.0",
-      "resolved": "https://registry.npmjs.org/@algolia/client-abtesting/-/client-abtesting-5.18.0.tgz",
-      "integrity": "sha512-DLIrAukjsSrdMNNDx1ZTks72o4RH/1kOn8Wx5zZm8nnqFexG+JzY4SANnCNEjnFQPJTTvC+KpgiNW/CP2lumng==",
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/client-abtesting/-/client-abtesting-5.51.0.tgz",
+      "integrity": "sha512-PKrKlIla1U2J7mFcIQn6N3pWP4oySmkxShnbbDsj/H7818gKbET5KsUwsVoNjWIxHKTJMCTcQ7ekAJ8Ea23NMg==",
       "license": "MIT",
       "dependencies": {
-        "@algolia/client-common": "5.18.0",
-        "@algolia/requester-browser-xhr": "5.18.0",
-        "@algolia/requester-fetch": "5.18.0",
-        "@algolia/requester-node-http": "5.18.0"
+        "@algolia/client-common": "5.51.0",
+        "@algolia/requester-browser-xhr": "5.51.0",
+        "@algolia/requester-fetch": "5.51.0",
+        "@algolia/requester-node-http": "5.51.0"
       },
       "engines": {
         "node": ">= 14.0.0"
       }
     },
-    "node_modules/@algolia/client-account": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/client-account/-/client-account-4.24.0.tgz",
-      "integrity": "sha512-adcvyJ3KjPZFDybxlqnf+5KgxJtBjwTPTeyG2aOyoJvx0Y8dUQAEOEVOJ/GBxX0WWNbmaSrhDURMhc+QeevDsA==",
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/client-common": "4.24.0",
-        "@algolia/client-search": "4.24.0",
-        "@algolia/transporter": "4.24.0"
-      }
-    },
-    "node_modules/@algolia/client-account/node_modules/@algolia/client-common": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/client-common/-/client-common-4.24.0.tgz",
-      "integrity": "sha512-bc2ROsNL6w6rqpl5jj/UywlIYC21TwSSoFHKl01lYirGMW+9Eek6r02Tocg4gZ8HAw3iBvu6XQiM3BEbmEMoiA==",
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/requester-common": "4.24.0",
-        "@algolia/transporter": "4.24.0"
-      }
-    },
-    "node_modules/@algolia/client-account/node_modules/@algolia/client-search": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/client-search/-/client-search-4.24.0.tgz",
-      "integrity": "sha512-uRW6EpNapmLAD0mW47OXqTP8eiIx5F6qN9/x/7HHO6owL3N1IXqydGwW5nhDFBrV+ldouro2W1VX3XlcUXEFCA==",
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/client-common": "4.24.0",
-        "@algolia/requester-common": "4.24.0",
-        "@algolia/transporter": "4.24.0"
-      }
-    },
     "node_modules/@algolia/client-analytics": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/client-analytics/-/client-analytics-4.24.0.tgz",
-      "integrity": "sha512-y8jOZt1OjwWU4N2qr8G4AxXAzaa8DBvyHTWlHzX/7Me1LX8OayfgHexqrsL4vSBcoMmVw2XnVW9MhL+Y2ZDJXg==",
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/client-common": "4.24.0",
-        "@algolia/client-search": "4.24.0",
-        "@algolia/requester-common": "4.24.0",
-        "@algolia/transporter": "4.24.0"
-      }
-    },
-    "node_modules/@algolia/client-analytics/node_modules/@algolia/client-common": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/client-common/-/client-common-4.24.0.tgz",
-      "integrity": "sha512-bc2ROsNL6w6rqpl5jj/UywlIYC21TwSSoFHKl01lYirGMW+9Eek6r02Tocg4gZ8HAw3iBvu6XQiM3BEbmEMoiA==",
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/requester-common": "4.24.0",
-        "@algolia/transporter": "4.24.0"
-      }
-    },
-    "node_modules/@algolia/client-analytics/node_modules/@algolia/client-search": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/client-search/-/client-search-4.24.0.tgz",
-      "integrity": "sha512-uRW6EpNapmLAD0mW47OXqTP8eiIx5F6qN9/x/7HHO6owL3N1IXqydGwW5nhDFBrV+ldouro2W1VX3XlcUXEFCA==",
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/client-analytics/-/client-analytics-5.51.0.tgz",
+      "integrity": "sha512-U+HCY1K16Km91pIRL1kN6bW6BbGFAF/WhkRSCx4wyl1aFpbrlhSFQs/dAwWbmyBiHWwVWhl7stWHQ1pum5EfMw==",
       "license": "MIT",
       "dependencies": {
-        "@algolia/client-common": "4.24.0",
-        "@algolia/requester-common": "4.24.0",
-        "@algolia/transporter": "4.24.0"
+        "@algolia/client-common": "5.51.0",
+        "@algolia/requester-browser-xhr": "5.51.0",
+        "@algolia/requester-fetch": "5.51.0",
+        "@algolia/requester-node-http": "5.51.0"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
       }
     },
     "node_modules/@algolia/client-common": {
-      "version": "5.18.0",
-      "resolved": "https://registry.npmjs.org/@algolia/client-common/-/client-common-5.18.0.tgz",
-      "integrity": "sha512-X1WMSC+1ve2qlMsemyTF5bIjwipOT+m99Ng1Tyl36ZjQKTa54oajBKE0BrmM8LD8jGdtukAgkUhFoYOaRbMcmQ==",
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/client-common/-/client-common-5.51.0.tgz",
+      "integrity": "sha512-YPJ3dEuZLCRp846Az94t6Z2gwSNRazP+SmBco7p6SCa4fYrtIE820PDXYZshbNrj2Z8Qfbmv7BQ1Lecl5L3G/w==",
       "license": "MIT",
       "engines": {
         "node": ">= 14.0.0"
       }
     },
     "node_modules/@algolia/client-insights": {
-      "version": "5.18.0",
-      "resolved": "https://registry.npmjs.org/@algolia/client-insights/-/client-insights-5.18.0.tgz",
-      "integrity": "sha512-FAJRNANUOSs/FgYOJ/Njqp+YTe4TMz2GkeZtfsw1TMiA5mVNRS/nnMpxas9771aJz7KTEWvK9GwqPs0K6RMYWg==",
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/client-insights/-/client-insights-5.51.0.tgz",
+      "integrity": "sha512-/gEwLlR7fQ7YjOW+ADRZ0NxLDtpTC61FSzlZ01Gdl1kTJfU0Rq3Y/TYqwxGxlQGcUiXtGzrpjxXWh3Y0TZD6NA==",
       "license": "MIT",
       "dependencies": {
-        "@algolia/client-common": "5.18.0",
-        "@algolia/requester-browser-xhr": "5.18.0",
-        "@algolia/requester-fetch": "5.18.0",
-        "@algolia/requester-node-http": "5.18.0"
+        "@algolia/client-common": "5.51.0",
+        "@algolia/requester-browser-xhr": "5.51.0",
+        "@algolia/requester-fetch": "5.51.0",
+        "@algolia/requester-node-http": "5.51.0"
       },
       "engines": {
         "node": ">= 14.0.0"
       }
     },
     "node_modules/@algolia/client-personalization": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/client-personalization/-/client-personalization-4.24.0.tgz",
-      "integrity": "sha512-l5FRFm/yngztweU0HdUzz1rC4yoWCFo3IF+dVIVTfEPg906eZg5BOd1k0K6rZx5JzyyoP4LdmOikfkfGsKVE9w==",
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/client-personalization/-/client-personalization-5.51.0.tgz",
+      "integrity": "sha512-nRwUN1Y2cKyOAFZyIBagkEfZSIhP05nWhT4Rjwl84lcjECssYggftrAODrZ4leakXxSGjhxs/AdaAFEIBqwVFA==",
       "license": "MIT",
       "dependencies": {
-        "@algolia/client-common": "4.24.0",
-        "@algolia/requester-common": "4.24.0",
-        "@algolia/transporter": "4.24.0"
-      }
-    },
-    "node_modules/@algolia/client-personalization/node_modules/@algolia/client-common": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/client-common/-/client-common-4.24.0.tgz",
-      "integrity": "sha512-bc2ROsNL6w6rqpl5jj/UywlIYC21TwSSoFHKl01lYirGMW+9Eek6r02Tocg4gZ8HAw3iBvu6XQiM3BEbmEMoiA==",
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/requester-common": "4.24.0",
-        "@algolia/transporter": "4.24.0"
+        "@algolia/client-common": "5.51.0",
+        "@algolia/requester-browser-xhr": "5.51.0",
+        "@algolia/requester-fetch": "5.51.0",
+        "@algolia/requester-node-http": "5.51.0"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
       }
     },
     "node_modules/@algolia/client-query-suggestions": {
-      "version": "5.18.0",
-      "resolved": "https://registry.npmjs.org/@algolia/client-query-suggestions/-/client-query-suggestions-5.18.0.tgz",
-      "integrity": "sha512-x6XKIQgKFTgK/bMasXhghoEjHhmgoP61pFPb9+TaUJ32aKOGc65b12usiGJ9A84yS73UDkXS452NjyP50Knh/g==",
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/client-query-suggestions/-/client-query-suggestions-5.51.0.tgz",
+      "integrity": "sha512-pybzYCG7VoQKppo+z5iZOKpW8XqtFxhsAIRgEaNboCnfypKukiBHJAwB+pmr7vMZXBsOHwklGYWwCG82e8qshA==",
       "license": "MIT",
       "dependencies": {
-        "@algolia/client-common": "5.18.0",
-        "@algolia/requester-browser-xhr": "5.18.0",
-        "@algolia/requester-fetch": "5.18.0",
-        "@algolia/requester-node-http": "5.18.0"
+        "@algolia/client-common": "5.51.0",
+        "@algolia/requester-browser-xhr": "5.51.0",
+        "@algolia/requester-fetch": "5.51.0",
+        "@algolia/requester-node-http": "5.51.0"
       },
       "engines": {
         "node": ">= 14.0.0"
       }
     },
     "node_modules/@algolia/client-search": {
-      "version": "5.18.0",
-      "resolved": "https://registry.npmjs.org/@algolia/client-search/-/client-search-5.18.0.tgz",
-      "integrity": "sha512-qI3LcFsVgtvpsBGR7aNSJYxhsR+Zl46+958ODzg8aCxIcdxiK7QEVLMJMZAR57jGqW0Lg/vrjtuLFDMfSE53qA==",
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/client-search/-/client-search-5.51.0.tgz",
+      "integrity": "sha512-DWVIlj6RqcvdhwP0gBU9OpOQPnHdcAk9jlT+z8rsNb2+liWv4eUlfQZ7saGBraFsnygEHD3PtdppIHvqwBAb5w==",
       "license": "MIT",
       "dependencies": {
-        "@algolia/client-common": "5.18.0",
-        "@algolia/requester-browser-xhr": "5.18.0",
-        "@algolia/requester-fetch": "5.18.0",
-        "@algolia/requester-node-http": "5.18.0"
+        "@algolia/client-common": "5.51.0",
+        "@algolia/requester-browser-xhr": "5.51.0",
+        "@algolia/requester-fetch": "5.51.0",
+        "@algolia/requester-node-http": "5.51.0"
       },
       "engines": {
         "node": ">= 14.0.0"
@@ -251,218 +193,130 @@
     },
     "node_modules/@algolia/events": {
       "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/@algolia/events/-/events-4.0.1.tgz",
+      "resolved": "https://registry.facebook.net/@algolia/events/-/events-4.0.1.tgz",
       "integrity": "sha512-FQzvOCgoFXAbf5Y6mYozw2aj5KCJoA3m4heImceldzPSMbdyS4atVjJzXKMsfX3wnZTFYwkkt8/z8UesLHlSBQ==",
       "license": "MIT"
     },
     "node_modules/@algolia/ingestion": {
-      "version": "1.18.0",
-      "resolved": "https://registry.npmjs.org/@algolia/ingestion/-/ingestion-1.18.0.tgz",
-      "integrity": "sha512-bGvJg7HnGGm+XWYMDruZXWgMDPVt4yCbBqq8DM6EoaMBK71SYC4WMfIdJaw+ABqttjBhe6aKNRkWf/bbvYOGyw==",
+      "version": "1.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/ingestion/-/ingestion-1.51.0.tgz",
+      "integrity": "sha512-bA25s12iUDJi/X8M7tWlPRT8GeOhls/yDbdoUqinz27lNqsOlcM1UrAxIKdIZ6lm3sXit+ewPIz1pS2x6rXu8g==",
       "license": "MIT",
       "dependencies": {
-        "@algolia/client-common": "5.18.0",
-        "@algolia/requester-browser-xhr": "5.18.0",
-        "@algolia/requester-fetch": "5.18.0",
-        "@algolia/requester-node-http": "5.18.0"
+        "@algolia/client-common": "5.51.0",
+        "@algolia/requester-browser-xhr": "5.51.0",
+        "@algolia/requester-fetch": "5.51.0",
+        "@algolia/requester-node-http": "5.51.0"
       },
       "engines": {
         "node": ">= 14.0.0"
       }
     },
-    "node_modules/@algolia/logger-common": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/logger-common/-/logger-common-4.24.0.tgz",
-      "integrity": "sha512-LLUNjkahj9KtKYrQhFKCzMx0BY3RnNP4FEtO+sBybCjJ73E8jNdaKJ/Dd8A/VA4imVHP5tADZ8pn5B8Ga/wTMA==",
-      "license": "MIT"
-    },
-    "node_modules/@algolia/logger-console": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/logger-console/-/logger-console-4.24.0.tgz",
-      "integrity": "sha512-X4C8IoHgHfiUROfoRCV+lzSy+LHMgkoEEU1BbKcsfnV0i0S20zyy0NLww9dwVHUWNfPPxdMU+/wKmLGYf96yTg==",
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/logger-common": "4.24.0"
-      }
-    },
     "node_modules/@algolia/monitoring": {
-      "version": "1.18.0",
-      "resolved": "https://registry.npmjs.org/@algolia/monitoring/-/monitoring-1.18.0.tgz",
-      "integrity": "sha512-lBssglINIeGIR+8KyzH05NAgAmn1BCrm5D2T6pMtr/8kbTHvvrm1Zvcltc5dKUQEFyyx3J5+MhNc7kfi8LdjVw==",
+      "version": "1.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/monitoring/-/monitoring-1.51.0.tgz",
+      "integrity": "sha512-zj+RcE5e0NE0/ew6oEOTgOplPHry+w2oi7h0Y87lhdq4E0d7xLS31KVB8kKfCGkrG7AYtZvrcyvLOKS5d0no4Q==",
       "license": "MIT",
       "dependencies": {
-        "@algolia/client-common": "5.18.0",
-        "@algolia/requester-browser-xhr": "5.18.0",
-        "@algolia/requester-fetch": "5.18.0",
-        "@algolia/requester-node-http": "5.18.0"
+        "@algolia/client-common": "5.51.0",
+        "@algolia/requester-browser-xhr": "5.51.0",
+        "@algolia/requester-fetch": "5.51.0",
+        "@algolia/requester-node-http": "5.51.0"
       },
       "engines": {
         "node": ">= 14.0.0"
       }
     },
     "node_modules/@algolia/recommend": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/recommend/-/recommend-4.24.0.tgz",
-      "integrity": "sha512-P9kcgerfVBpfYHDfVZDvvdJv0lEoCvzNlOy2nykyt5bK8TyieYyiD0lguIJdRZZYGre03WIAFf14pgE+V+IBlw==",
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/cache-browser-local-storage": "4.24.0",
-        "@algolia/cache-common": "4.24.0",
-        "@algolia/cache-in-memory": "4.24.0",
-        "@algolia/client-common": "4.24.0",
-        "@algolia/client-search": "4.24.0",
-        "@algolia/logger-common": "4.24.0",
-        "@algolia/logger-console": "4.24.0",
-        "@algolia/requester-browser-xhr": "4.24.0",
-        "@algolia/requester-common": "4.24.0",
-        "@algolia/requester-node-http": "4.24.0",
-        "@algolia/transporter": "4.24.0"
-      }
-    },
-    "node_modules/@algolia/recommend/node_modules/@algolia/client-common": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/client-common/-/client-common-4.24.0.tgz",
-      "integrity": "sha512-bc2ROsNL6w6rqpl5jj/UywlIYC21TwSSoFHKl01lYirGMW+9Eek6r02Tocg4gZ8HAw3iBvu6XQiM3BEbmEMoiA==",
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/requester-common": "4.24.0",
-        "@algolia/transporter": "4.24.0"
-      }
-    },
-    "node_modules/@algolia/recommend/node_modules/@algolia/client-search": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/client-search/-/client-search-4.24.0.tgz",
-      "integrity": "sha512-uRW6EpNapmLAD0mW47OXqTP8eiIx5F6qN9/x/7HHO6owL3N1IXqydGwW5nhDFBrV+ldouro2W1VX3XlcUXEFCA==",
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/client-common": "4.24.0",
-        "@algolia/requester-common": "4.24.0",
-        "@algolia/transporter": "4.24.0"
-      }
-    },
-    "node_modules/@algolia/recommend/node_modules/@algolia/requester-browser-xhr": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/requester-browser-xhr/-/requester-browser-xhr-4.24.0.tgz",
-      "integrity": "sha512-Z2NxZMb6+nVXSjF13YpjYTdvV3032YTBSGm2vnYvYPA6mMxzM3v5rsCiSspndn9rzIW4Qp1lPHBvuoKJV6jnAA==",
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/requester-common": "4.24.0"
-      }
-    },
-    "node_modules/@algolia/recommend/node_modules/@algolia/requester-node-http": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/requester-node-http/-/requester-node-http-4.24.0.tgz",
-      "integrity": "sha512-JF18yTjNOVYvU/L3UosRcvbPMGT9B+/GQWNWnenIImglzNVGpyzChkXLnrSf6uxwVNO6ESGu6oN8MqcGQcjQJw==",
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/recommend/-/recommend-5.51.0.tgz",
+      "integrity": "sha512-/HDgccfye1Rq3bPxaSCsvSEBHzSMmtpM9ZRGRtAuC62Cv+ql/76IWnxjGTDXtqIJ+/j7ZlFYAzq9fkp95wF2SQ==",
       "license": "MIT",
       "dependencies": {
-        "@algolia/requester-common": "4.24.0"
+        "@algolia/client-common": "5.51.0",
+        "@algolia/requester-browser-xhr": "5.51.0",
+        "@algolia/requester-fetch": "5.51.0",
+        "@algolia/requester-node-http": "5.51.0"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
       }
     },
     "node_modules/@algolia/requester-browser-xhr": {
-      "version": "5.18.0",
-      "resolved": "https://registry.npmjs.org/@algolia/requester-browser-xhr/-/requester-browser-xhr-5.18.0.tgz",
-      "integrity": "sha512-1XFjW0C3pV0dS/9zXbV44cKI+QM4ZIz9cpatXpsjRlq6SUCpLID3DZHsXyE6sTb8IhyPaUjk78GEJT8/3hviqg==",
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/requester-browser-xhr/-/requester-browser-xhr-5.51.0.tgz",
+      "integrity": "sha512-nJdW+WBwGlXWMJbxxB7/AJPvNq0lLJSudXmIQCJbmH8jsOXQhRpAtoCD4ceLyJKv3ze9JbQu4Gqu5JDLckuFcw==",
       "license": "MIT",
       "dependencies": {
-        "@algolia/client-common": "5.18.0"
+        "@algolia/client-common": "5.51.0"
       },
       "engines": {
         "node": ">= 14.0.0"
       }
     },
-    "node_modules/@algolia/requester-common": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/requester-common/-/requester-common-4.24.0.tgz",
-      "integrity": "sha512-k3CXJ2OVnvgE3HMwcojpvY6d9kgKMPRxs/kVohrwF5WMr2fnqojnycZkxPoEg+bXm8fi5BBfFmOqgYztRtHsQA==",
-      "license": "MIT"
-    },
     "node_modules/@algolia/requester-fetch": {
-      "version": "5.18.0",
-      "resolved": "https://registry.npmjs.org/@algolia/requester-fetch/-/requester-fetch-5.18.0.tgz",
-      "integrity": "sha512-0uodeNdAHz1YbzJh6C5xeQ4T6x5WGiUxUq3GOaT/R4njh5t78dq+Rb187elr7KtnjUmETVVuCvmEYaThfTHzNg==",
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/requester-fetch/-/requester-fetch-5.51.0.tgz",
+      "integrity": "sha512-bsBgRI/1h1mjS3eCyfGau78yGZVmiDLmT1aU6dMnk75/T0SgKqnSKNpQ53xKoDYVChGDcNnpHXWpoUSo8MH1+w==",
       "license": "MIT",
       "dependencies": {
-        "@algolia/client-common": "5.18.0"
+        "@algolia/client-common": "5.51.0"
       },
       "engines": {
         "node": ">= 14.0.0"
       }
     },
     "node_modules/@algolia/requester-node-http": {
-      "version": "5.18.0",
-      "resolved": "https://registry.npmjs.org/@algolia/requester-node-http/-/requester-node-http-5.18.0.tgz",
-      "integrity": "sha512-tZCqDrqJ2YE2I5ukCQrYN8oiF6u3JIdCxrtKq+eniuLkjkO78TKRnXrVcKZTmfFJyyDK8q47SfDcHzAA3nHi6w==",
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/requester-node-http/-/requester-node-http-5.51.0.tgz",
+      "integrity": "sha512-zPrIDVPpmKWgrjmWOqpqrhqAhNjvVkjoj+mqw2NBPxEOuKNzP0H+Qz5NJLLTOepBVj1UFedFaF3AUgxLsB9ukQ==",
       "license": "MIT",
       "dependencies": {
-        "@algolia/client-common": "5.18.0"
+        "@algolia/client-common": "5.51.0"
       },
       "engines": {
         "node": ">= 14.0.0"
       }
     },
-    "node_modules/@algolia/transporter": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/transporter/-/transporter-4.24.0.tgz",
-      "integrity": "sha512-86nI7w6NzWxd1Zp9q3413dRshDqAzSbsQjhcDhPIatEFiZrL1/TjnHL8S7jVKFePlIMzDsZWXAXwXzcok9c5oA==",
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/cache-common": "4.24.0",
-        "@algolia/logger-common": "4.24.0",
-        "@algolia/requester-common": "4.24.0"
-      }
-    },
-    "node_modules/@ampproject/remapping": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.3.0.tgz",
-      "integrity": "sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@jridgewell/gen-mapping": "^0.3.5",
-        "@jridgewell/trace-mapping": "^0.3.24"
-      },
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
     "node_modules/@babel/code-frame": {
-      "version": "7.26.2",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.26.2.tgz",
-      "integrity": "sha512-RJlIHRueQgwWitWgF8OdFYGZX328Ax5BCemNGlqHfplnRT9ESi8JkFlvaVYbS+UubVY6dpv87Fs2u5M29iNFVQ==",
+      "version": "7.29.0",
+      "resolved": "https://registry.facebook.net/@babel/code-frame/-/code-frame-7.29.0.tgz",
+      "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-validator-identifier": "^7.25.9",
+        "@babel/helper-validator-identifier": "^7.28.5",
         "js-tokens": "^4.0.0",
-        "picocolors": "^1.0.0"
+        "picocolors": "^1.1.1"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/compat-data": {
-      "version": "7.26.3",
-      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.26.3.tgz",
-      "integrity": "sha512-nHIxvKPniQXpmQLb0vhY3VaFb3S0YrTAwpOWJZh1wn3oJPjJk9Asva204PsBdmAE8vpzfHudT8DB0scYvy9q0g==",
+      "version": "7.29.0",
+      "resolved": "https://registry.facebook.net/@babel/compat-data/-/compat-data-7.29.0.tgz",
+      "integrity": "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==",
       "license": "MIT",
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/core": {
-      "version": "7.26.0",
-      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.26.0.tgz",
-      "integrity": "sha512-i1SLeK+DzNnQ3LL/CswPCa/E5u4lh1k6IAEphON8F+cXt0t9euTshDru0q7/IqMa1PMPz5RnHuHscF8/ZJsStg==",
-      "license": "MIT",
-      "dependencies": {
-        "@ampproject/remapping": "^2.2.0",
-        "@babel/code-frame": "^7.26.0",
-        "@babel/generator": "^7.26.0",
-        "@babel/helper-compilation-targets": "^7.25.9",
-        "@babel/helper-module-transforms": "^7.26.0",
-        "@babel/helpers": "^7.26.0",
-        "@babel/parser": "^7.26.0",
-        "@babel/template": "^7.25.9",
-        "@babel/traverse": "^7.25.9",
-        "@babel/types": "^7.26.0",
+      "version": "7.29.0",
+      "resolved": "https://registry.facebook.net/@babel/core/-/core-7.29.0.tgz",
+      "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.0",
+        "@babel/generator": "^7.29.0",
+        "@babel/helper-compilation-targets": "^7.28.6",
+        "@babel/helper-module-transforms": "^7.28.6",
+        "@babel/helpers": "^7.28.6",
+        "@babel/parser": "^7.29.0",
+        "@babel/template": "^7.28.6",
+        "@babel/traverse": "^7.29.0",
+        "@babel/types": "^7.29.0",
+        "@jridgewell/remapping": "^2.3.5",
         "convert-source-map": "^2.0.0",
         "debug": "^4.1.0",
         "gensync": "^1.0.0-beta.2",
@@ -477,25 +331,16 @@
         "url": "https://opencollective.com/babel"
       }
     },
-    "node_modules/@babel/core/node_modules/semver": {
-      "version": "6.3.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
-      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      }
-    },
     "node_modules/@babel/generator": {
-      "version": "7.26.3",
-      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.26.3.tgz",
-      "integrity": "sha512-6FF/urZvD0sTeO7k6/B15pMLC4CHUv1426lzr3N01aHJTl046uCAh9LXW/fzeXXjPNCJ6iABW5XaWOsIZB93aQ==",
+      "version": "7.29.1",
+      "resolved": "https://registry.facebook.net/@babel/generator/-/generator-7.29.1.tgz",
+      "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/parser": "^7.26.3",
-        "@babel/types": "^7.26.3",
-        "@jridgewell/gen-mapping": "^0.3.5",
-        "@jridgewell/trace-mapping": "^0.3.25",
+        "@babel/parser": "^7.29.0",
+        "@babel/types": "^7.29.0",
+        "@jridgewell/gen-mapping": "^0.3.12",
+        "@jridgewell/trace-mapping": "^0.3.28",
         "jsesc": "^3.0.2"
       },
       "engines": {
@@ -503,25 +348,25 @@
       }
     },
     "node_modules/@babel/helper-annotate-as-pure": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.25.9.tgz",
-      "integrity": "sha512-gv7320KBUFJz1RnylIg5WWYPRXKZ884AGkYpgpWW02TH66Dl+HaC1t1CKd0z3R4b6hdYEcmrNZHUmfCP+1u3/g==",
+      "version": "7.27.3",
+      "resolved": "https://registry.facebook.net/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.27.3.tgz",
+      "integrity": "sha512-fXSwMQqitTGeHLBC08Eq5yXz2m37E4pJX1qAU1+2cNedz/ifv/bVXft90VeSav5nFO61EcNgwr0aJxbyPaWBPg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/types": "^7.25.9"
+        "@babel/types": "^7.27.3"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-compilation-targets": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.25.9.tgz",
-      "integrity": "sha512-j9Db8Suy6yV/VHa4qzrj9yZfZxhLWQdVnRlXxmKLYlhWUVB1sB2G5sxuWYXk/whHD9iW76PmNzxZ4UCnTQTVEQ==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz",
+      "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/compat-data": "^7.25.9",
-        "@babel/helper-validator-option": "^7.25.9",
+        "@babel/compat-data": "^7.28.6",
+        "@babel/helper-validator-option": "^7.27.1",
         "browserslist": "^4.24.0",
         "lru-cache": "^5.1.1",
         "semver": "^6.3.1"
@@ -530,27 +375,18 @@
         "node": ">=6.9.0"
       }
     },
-    "node_modules/@babel/helper-compilation-targets/node_modules/semver": {
-      "version": "6.3.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
-      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      }
-    },
     "node_modules/@babel/helper-create-class-features-plugin": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.25.9.tgz",
-      "integrity": "sha512-UTZQMvt0d/rSz6KI+qdu7GQze5TIajwTS++GUozlw8VBJDEOAqSXwm1WvmYEZwqdqSGQshRocPDqrt4HBZB3fQ==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.28.6.tgz",
+      "integrity": "sha512-dTOdvsjnG3xNT9Y0AUg1wAl38y+4Rl4sf9caSQZOXdNqVn+H+HbbJ4IyyHaIqNR6SW9oJpA/RuRjsjCw2IdIow==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-annotate-as-pure": "^7.25.9",
-        "@babel/helper-member-expression-to-functions": "^7.25.9",
-        "@babel/helper-optimise-call-expression": "^7.25.9",
-        "@babel/helper-replace-supers": "^7.25.9",
-        "@babel/helper-skip-transparent-expression-wrappers": "^7.25.9",
-        "@babel/traverse": "^7.25.9",
+        "@babel/helper-annotate-as-pure": "^7.27.3",
+        "@babel/helper-member-expression-to-functions": "^7.28.5",
+        "@babel/helper-optimise-call-expression": "^7.27.1",
+        "@babel/helper-replace-supers": "^7.28.6",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1",
+        "@babel/traverse": "^7.28.6",
         "semver": "^6.3.1"
       },
       "engines": {
@@ -560,23 +396,14 @@
         "@babel/core": "^7.0.0"
       }
     },
-    "node_modules/@babel/helper-create-class-features-plugin/node_modules/semver": {
-      "version": "6.3.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
-      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      }
-    },
     "node_modules/@babel/helper-create-regexp-features-plugin": {
-      "version": "7.26.3",
-      "resolved": "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.26.3.tgz",
-      "integrity": "sha512-G7ZRb40uUgdKOQqPLjfD12ZmGA54PzqDFUv2BKImnC9QIfGhIHKvVML0oN8IUiDq4iRqpq74ABpvOaerfWdong==",
+      "version": "7.28.5",
+      "resolved": "https://registry.facebook.net/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.28.5.tgz",
+      "integrity": "sha512-N1EhvLtHzOvj7QQOUCCS3NrPJP8c5W6ZXCHDn7Yialuy1iu4r5EmIYkXlKNqT99Ciw+W0mDqWoR6HWMZlFP3hw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-annotate-as-pure": "^7.25.9",
-        "regexpu-core": "^6.2.0",
+        "@babel/helper-annotate-as-pure": "^7.27.3",
+        "regexpu-core": "^6.3.1",
         "semver": "^6.3.1"
       },
       "engines": {
@@ -586,66 +413,66 @@
         "@babel/core": "^7.0.0"
       }
     },
-    "node_modules/@babel/helper-create-regexp-features-plugin/node_modules/semver": {
-      "version": "6.3.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
-      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      }
-    },
     "node_modules/@babel/helper-define-polyfill-provider": {
-      "version": "0.6.3",
-      "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.6.3.tgz",
-      "integrity": "sha512-HK7Bi+Hj6H+VTHA3ZvBis7V/6hu9QuTrnMXNybfUf2iiuU/N97I8VjB+KbhFF8Rld/Lx5MzoCwPCpPjfK+n8Cg==",
+      "version": "0.6.8",
+      "resolved": "https://registry.facebook.net/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.6.8.tgz",
+      "integrity": "sha512-47UwBLPpQi1NoWzLuHNjRoHlYXMwIJoBf7MFou6viC/sIHWYygpvr0B6IAyh5sBdA2nr2LPIRww8lfaUVQINBA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-compilation-targets": "^7.22.6",
-        "@babel/helper-plugin-utils": "^7.22.5",
-        "debug": "^4.1.1",
+        "@babel/helper-compilation-targets": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "debug": "^4.4.3",
         "lodash.debounce": "^4.0.8",
-        "resolve": "^1.14.2"
+        "resolve": "^1.22.11"
       },
       "peerDependencies": {
         "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
       }
     },
+    "node_modules/@babel/helper-globals": {
+      "version": "7.28.0",
+      "resolved": "https://registry.facebook.net/@babel/helper-globals/-/helper-globals-7.28.0.tgz",
+      "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
     "node_modules/@babel/helper-member-expression-to-functions": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.25.9.tgz",
-      "integrity": "sha512-wbfdZ9w5vk0C0oyHqAJbc62+vet5prjj01jjJ8sKn3j9h3MQQlflEdXYvuqRWjHnM12coDEqiC1IRCi0U/EKwQ==",
+      "version": "7.28.5",
+      "resolved": "https://registry.facebook.net/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.28.5.tgz",
+      "integrity": "sha512-cwM7SBRZcPCLgl8a7cY0soT1SptSzAlMH39vwiRpOQkJlh53r5hdHwLSCZpQdVLT39sZt+CRpNwYG4Y2v77atg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/traverse": "^7.25.9",
-        "@babel/types": "^7.25.9"
+        "@babel/traverse": "^7.28.5",
+        "@babel/types": "^7.28.5"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-module-imports": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.25.9.tgz",
-      "integrity": "sha512-tnUA4RsrmflIM6W6RFTLFSXITtl0wKjgpnLgXyowocVPrbYrLUXSBXDgTs8BlbmIzIdlBySRQjINYs2BAkiLtw==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz",
+      "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/traverse": "^7.25.9",
-        "@babel/types": "^7.25.9"
+        "@babel/traverse": "^7.28.6",
+        "@babel/types": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-module-transforms": {
-      "version": "7.26.0",
-      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.26.0.tgz",
-      "integrity": "sha512-xO+xu6B5K2czEnQye6BHA7DolFFmS3LB7stHZFaOLb1pAwO1HWLS8fXA+eh0A2yIvltPVmx3eNNDBJA2SLHXFw==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz",
+      "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-module-imports": "^7.25.9",
-        "@babel/helper-validator-identifier": "^7.25.9",
-        "@babel/traverse": "^7.25.9"
+        "@babel/helper-module-imports": "^7.28.6",
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "@babel/traverse": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -655,35 +482,35 @@
       }
     },
     "node_modules/@babel/helper-optimise-call-expression": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.25.9.tgz",
-      "integrity": "sha512-FIpuNaz5ow8VyrYcnXQTDRGvV6tTjkNtCK/RYNDXGSLlUD6cBuQTSw43CShGxjvfBTfcUA/r6UhUCbtYqkhcuQ==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.27.1.tgz",
+      "integrity": "sha512-URMGH08NzYFhubNSGJrpUEphGKQwMQYBySzat5cAByY1/YgIRkULnIy3tAMeszlL/so2HbeilYloUmSpd7GdVw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/types": "^7.25.9"
+        "@babel/types": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-plugin-utils": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.25.9.tgz",
-      "integrity": "sha512-kSMlyUVdWe25rEsRGviIgOWnoT/nfABVWlqt9N19/dIPWViAOW2s9wznP5tURbs/IDuNk4gPy3YdYRgH3uxhBw==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz",
+      "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==",
       "license": "MIT",
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-remap-async-to-generator": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.25.9.tgz",
-      "integrity": "sha512-IZtukuUeBbhgOcaW2s06OXTzVNJR0ybm4W5xC1opWFFJMZbwRj5LCk+ByYH7WdZPZTt8KnFwA8pvjN2yqcPlgw==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.27.1.tgz",
+      "integrity": "sha512-7fiA521aVw8lSPeI4ZOD3vRFkoqkJcS+z4hFo82bFSH/2tNd6eJ5qCVMS5OzDmZh/kaHQeBaeyxK6wljcPtveA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-annotate-as-pure": "^7.25.9",
-        "@babel/helper-wrap-function": "^7.25.9",
-        "@babel/traverse": "^7.25.9"
+        "@babel/helper-annotate-as-pure": "^7.27.1",
+        "@babel/helper-wrap-function": "^7.27.1",
+        "@babel/traverse": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -693,14 +520,14 @@
       }
     },
     "node_modules/@babel/helper-replace-supers": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.25.9.tgz",
-      "integrity": "sha512-IiDqTOTBQy0sWyeXyGSC5TBJpGFXBkRynjBeXsvbhQFKj2viwJC76Epz35YLU1fpe/Am6Vppb7W7zM4fPQzLsQ==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/helper-replace-supers/-/helper-replace-supers-7.28.6.tgz",
+      "integrity": "sha512-mq8e+laIk94/yFec3DxSjCRD2Z0TAjhVbEJY3UQrlwVo15Lmt7C2wAUbK4bjnTs4APkwsYLTahXRraQXhb1WCg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-member-expression-to-functions": "^7.25.9",
-        "@babel/helper-optimise-call-expression": "^7.25.9",
-        "@babel/traverse": "^7.25.9"
+        "@babel/helper-member-expression-to-functions": "^7.28.5",
+        "@babel/helper-optimise-call-expression": "^7.27.1",
+        "@babel/traverse": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -710,79 +537,79 @@
       }
     },
     "node_modules/@babel/helper-skip-transparent-expression-wrappers": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.25.9.tgz",
-      "integrity": "sha512-K4Du3BFa3gvyhzgPcntrkDgZzQaq6uozzcpGbOO1OEJaI+EJdqWIMTLgFgQf6lrfiDFo5FU+BxKepI9RmZqahA==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.27.1.tgz",
+      "integrity": "sha512-Tub4ZKEXqbPjXgWLl2+3JpQAYBJ8+ikpQ2Ocj/q/r0LwE3UhENh7EUabyHjz2kCEsrRY83ew2DQdHluuiDQFzg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/traverse": "^7.25.9",
-        "@babel/types": "^7.25.9"
+        "@babel/traverse": "^7.27.1",
+        "@babel/types": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-string-parser": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.25.9.tgz",
-      "integrity": "sha512-4A/SCr/2KLd5jrtOMFzaKjVtAei3+2r/NChoBNoZ3EyP/+GlhoaEGoWOZUmFmoITP7zOJyHIMm+DYRd8o3PvHA==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
       "license": "MIT",
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-validator-identifier": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.25.9.tgz",
-      "integrity": "sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ==",
+      "version": "7.28.5",
+      "resolved": "https://registry.facebook.net/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
+      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
       "license": "MIT",
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-validator-option": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.25.9.tgz",
-      "integrity": "sha512-e/zv1co8pp55dNdEcCynfj9X7nyUKUXoUEwfXqaZt0omVOmDe9oOTdKStH4GmAw6zxMFs50ZayuMfHDKlO7Tfw==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
+      "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==",
       "license": "MIT",
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-wrap-function": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.25.9.tgz",
-      "integrity": "sha512-ETzz9UTjQSTmw39GboatdymDq4XIQbR8ySgVrylRhPOFpsd+JrKHIuF0de7GCWmem+T4uC5z7EZguod7Wj4A4g==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/helper-wrap-function/-/helper-wrap-function-7.28.6.tgz",
+      "integrity": "sha512-z+PwLziMNBeSQJonizz2AGnndLsP2DeGHIxDAn+wdHOGuo4Fo1x1HBPPXeE9TAOPHNNWQKCSlA2VZyYyyibDnQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/template": "^7.25.9",
-        "@babel/traverse": "^7.25.9",
-        "@babel/types": "^7.25.9"
+        "@babel/template": "^7.28.6",
+        "@babel/traverse": "^7.28.6",
+        "@babel/types": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helpers": {
-      "version": "7.26.0",
-      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.26.0.tgz",
-      "integrity": "sha512-tbhNuIxNcVb21pInl3ZSjksLCvgdZy9KwJ8brv993QtIVKJBBkYXz4q4ZbAv31GdnC+R90np23L5FbEBlthAEw==",
+      "version": "7.29.2",
+      "resolved": "https://registry.facebook.net/@babel/helpers/-/helpers-7.29.2.tgz",
+      "integrity": "sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/template": "^7.25.9",
-        "@babel/types": "^7.26.0"
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.29.0"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/parser": {
-      "version": "7.26.3",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.26.3.tgz",
-      "integrity": "sha512-WJ/CvmY8Mea8iDXo6a7RK2wbmJITT5fN3BEkRuFlxVyNx8jOKIIhmC4fSkTcPcf8JyavbBwIe6OpiCOBXt/IcA==",
+      "version": "7.29.2",
+      "resolved": "https://registry.facebook.net/@babel/parser/-/parser-7.29.2.tgz",
+      "integrity": "sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/types": "^7.26.3"
+        "@babel/types": "^7.29.0"
       },
       "bin": {
         "parser": "bin/babel-parser.js"
@@ -792,13 +619,13 @@
       }
     },
     "node_modules/@babel/plugin-bugfix-firefox-class-in-computed-class-key": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-firefox-class-in-computed-class-key/-/plugin-bugfix-firefox-class-in-computed-class-key-7.25.9.tgz",
-      "integrity": "sha512-ZkRyVkThtxQ/J6nv3JFYv1RYY+JT5BvU0y3k5bWrmuG4woXypRa4PXmm9RhOwodRkYFWqC0C0cqcJ4OqR7kW+g==",
+      "version": "7.28.5",
+      "resolved": "https://registry.facebook.net/@babel/plugin-bugfix-firefox-class-in-computed-class-key/-/plugin-bugfix-firefox-class-in-computed-class-key-7.28.5.tgz",
+      "integrity": "sha512-87GDMS3tsmMSi/3bWOte1UblL+YUTFMV8SZPZ2eSEL17s74Cw/l63rR6NmGVKMYW2GYi85nE+/d6Hw5N0bEk2Q==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9",
-        "@babel/traverse": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1",
+        "@babel/traverse": "^7.28.5"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -808,12 +635,12 @@
       }
     },
     "node_modules/@babel/plugin-bugfix-safari-class-field-initializer-scope": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-class-field-initializer-scope/-/plugin-bugfix-safari-class-field-initializer-scope-7.25.9.tgz",
-      "integrity": "sha512-MrGRLZxLD/Zjj0gdU15dfs+HH/OXvnw/U4jJD8vpcP2CJQapPEv1IWwjc/qMg7ItBlPwSv1hRBbb7LeuANdcnw==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-bugfix-safari-class-field-initializer-scope/-/plugin-bugfix-safari-class-field-initializer-scope-7.27.1.tgz",
+      "integrity": "sha512-qNeq3bCKnGgLkEXUuFry6dPlGfCdQNZbn7yUAPCInwAJHMU7THJfrBSozkcWq5sNM6RcF3S8XyQL2A52KNR9IA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -823,12 +650,12 @@
       }
     },
     "node_modules/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.25.9.tgz",
-      "integrity": "sha512-2qUwwfAFpJLZqxd02YW9btUCZHl+RFvdDkNfZwaIJrvB8Tesjsk8pEQkTvGwZXLqXUx/2oyY3ySRhm6HOXuCug==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.27.1.tgz",
+      "integrity": "sha512-g4L7OYun04N1WyqMNjldFwlfPCLVkgB54A/YCXICZYBsvJJE3kByKv9c9+R/nAfmIfjl2rKYLNyMHboYbZaWaA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -838,14 +665,14 @@
       }
     },
     "node_modules/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.25.9.tgz",
-      "integrity": "sha512-6xWgLZTJXwilVjlnV7ospI3xi+sl8lN8rXXbBD6vYn3UYDlGsag8wrZkKcSI8G6KgqKP7vNFaDgeDnfAABq61g==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.27.1.tgz",
+      "integrity": "sha512-oO02gcONcD5O1iTLi/6frMJBIwWEHceWGSGqrpCmEL8nogiS6J9PBlE48CaK20/Jx1LuRml9aDftLgdjXT8+Cw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9",
-        "@babel/helper-skip-transparent-expression-wrappers": "^7.25.9",
-        "@babel/plugin-transform-optional-chaining": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1",
+        "@babel/plugin-transform-optional-chaining": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -855,13 +682,13 @@
       }
     },
     "node_modules/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.25.9.tgz",
-      "integrity": "sha512-aLnMXYPnzwwqhYSCyXfKkIkYgJ8zv9RK+roo9DkTXz38ynIhd9XCbN08s3MGvqL2MYGVUGdRQLL/JqBIeJhJBg==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.28.6.tgz",
+      "integrity": "sha512-a0aBScVTlNaiUe35UtfxAN7A/tehvvG4/ByO6+46VPKTRSlfnAFsgKy0FUh+qAkQrDTmhDkT+IBOKlOoMUxQ0g==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9",
-        "@babel/traverse": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/traverse": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -872,7 +699,7 @@
     },
     "node_modules/@babel/plugin-proposal-private-property-in-object": {
       "version": "7.21.0-placeholder-for-preset-env.2",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.21.0-placeholder-for-preset-env.2.tgz",
+      "resolved": "https://registry.facebook.net/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.21.0-placeholder-for-preset-env.2.tgz",
       "integrity": "sha512-SOSkfJDddaM7mak6cPEpswyTRnuRltl429hMraQEglW+OkovnCzsiszTmsrlY//qLFjCpQDFRvjdm2wA5pPm9w==",
       "license": "MIT",
       "engines": {
@@ -884,7 +711,7 @@
     },
     "node_modules/@babel/plugin-syntax-dynamic-import": {
       "version": "7.8.3",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-dynamic-import/-/plugin-syntax-dynamic-import-7.8.3.tgz",
+      "resolved": "https://registry.facebook.net/@babel/plugin-syntax-dynamic-import/-/plugin-syntax-dynamic-import-7.8.3.tgz",
       "integrity": "sha512-5gdGbFon+PszYzqs83S3E5mpi7/y/8M9eC90MRTZfduQOYW76ig6SOSPNe41IG5LoP3FGBn2N0RjVDSQiS94kQ==",
       "license": "MIT",
       "dependencies": {
@@ -895,12 +722,12 @@
       }
     },
     "node_modules/@babel/plugin-syntax-import-assertions": {
-      "version": "7.26.0",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.26.0.tgz",
-      "integrity": "sha512-QCWT5Hh830hK5EQa7XzuqIkQU9tT/whqbDz7kuaZMHFl1inRRg7JnuAEOQ0Ur0QUl0NufCk1msK2BeY79Aj/eg==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.28.6.tgz",
+      "integrity": "sha512-pSJUpFHdx9z5nqTSirOCMtYVP2wFgoWhP0p3g8ONK/4IHhLIBd0B9NYqAvIUAhq+OkhO4VM1tENCt0cjlsNShw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -910,12 +737,12 @@
       }
     },
     "node_modules/@babel/plugin-syntax-import-attributes": {
-      "version": "7.26.0",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.26.0.tgz",
-      "integrity": "sha512-e2dttdsJ1ZTpi3B9UYGLw41hifAubg19AtCu/2I/F1QNVclOBr1dYpTdmdyZ84Xiz43BS/tCUkMAZNLv12Pi+A==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.28.6.tgz",
+      "integrity": "sha512-jiLC0ma9XkQT3TKJ9uYvlakm66Pamywo+qwL+oL8HJOvc6TWdZXVfhqJr8CCzbSGUAbDOzlGHJC1U+vRfLQDvw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -925,12 +752,12 @@
       }
     },
     "node_modules/@babel/plugin-syntax-jsx": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.25.9.tgz",
-      "integrity": "sha512-ld6oezHQMZsZfp6pWtbjaNDF2tiiCYYDqQszHt5VV437lewP9aSi2Of99CK0D0XB21k7FLgnLcmQKyKzynfeAA==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.28.6.tgz",
+      "integrity": "sha512-wgEmr06G6sIpqr8YDwA2dSRTE3bJ+V0IfpzfSY3Lfgd7YWOaAdlykvJi13ZKBt8cZHfgH1IXN+CL656W3uUa4w==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -940,12 +767,12 @@
       }
     },
     "node_modules/@babel/plugin-syntax-typescript": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.25.9.tgz",
-      "integrity": "sha512-hjMgRy5hb8uJJjUcdWunWVcoi9bGpJp8p5Ol1229PoN6aytsLwNMgmdftO23wnCLMfVmTwZDWMPNq/D1SY60JQ==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.28.6.tgz",
+      "integrity": "sha512-+nDNmQye7nlnuuHDboPbGm00Vqg3oO8niRRL27/4LYHUsHYh0zJ1xWOz0uRwNFmM1Avzk8wZbc6rdiYhomzv/A==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -956,7 +783,7 @@
     },
     "node_modules/@babel/plugin-syntax-unicode-sets-regex": {
       "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-unicode-sets-regex/-/plugin-syntax-unicode-sets-regex-7.18.6.tgz",
+      "resolved": "https://registry.facebook.net/@babel/plugin-syntax-unicode-sets-regex/-/plugin-syntax-unicode-sets-regex-7.18.6.tgz",
       "integrity": "sha512-727YkEAPwSIQTv5im8QHz3upqp92JTWhidIC81Tdx4VJYIte/VndKf1qKrfnnhPLiPghStWfvC/iFaMCQu7Nqg==",
       "license": "MIT",
       "dependencies": {
@@ -971,12 +798,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-arrow-functions": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.25.9.tgz",
-      "integrity": "sha512-6jmooXYIwn9ca5/RylZADJ+EnSxVUS5sjeJ9UPk6RWRzXCmOJCy6dqItPJFpw2cuCangPK4OYr5uhGKcmrm5Qg==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.27.1.tgz",
+      "integrity": "sha512-8Z4TGic6xW70FKThA5HYEKKyBpOOsucTOD1DjU3fZxDg+K3zBJcXMFnt/4yQiZnf5+MiOMSXQ9PaEK/Ilh1DeA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -986,14 +813,14 @@
       }
     },
     "node_modules/@babel/plugin-transform-async-generator-functions": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.25.9.tgz",
-      "integrity": "sha512-RXV6QAzTBbhDMO9fWwOmwwTuYaiPbggWQ9INdZqAYeSHyG7FzQ+nOZaUUjNwKv9pV3aE4WFqFm1Hnbci5tBCAw==",
+      "version": "7.29.0",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.29.0.tgz",
+      "integrity": "sha512-va0VdWro4zlBr2JsXC+ofCPB2iG12wPtVGTWFx2WLDOM3nYQZZIGP82qku2eW/JR83sD+k2k+CsNtyEbUqhU6w==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9",
-        "@babel/helper-remap-async-to-generator": "^7.25.9",
-        "@babel/traverse": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/helper-remap-async-to-generator": "^7.27.1",
+        "@babel/traverse": "^7.29.0"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1003,14 +830,14 @@
       }
     },
     "node_modules/@babel/plugin-transform-async-to-generator": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.25.9.tgz",
-      "integrity": "sha512-NT7Ejn7Z/LjUH0Gv5KsBCxh7BH3fbLTV0ptHvpeMvrt3cPThHfJfst9Wrb7S8EvJ7vRTFI7z+VAvFVEQn/m5zQ==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.28.6.tgz",
+      "integrity": "sha512-ilTRcmbuXjsMmcZ3HASTe4caH5Tpo93PkTxF9oG2VZsSWsahydmcEHhix9Ik122RcTnZnUzPbmux4wh1swfv7g==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-module-imports": "^7.25.9",
-        "@babel/helper-plugin-utils": "^7.25.9",
-        "@babel/helper-remap-async-to-generator": "^7.25.9"
+        "@babel/helper-module-imports": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/helper-remap-async-to-generator": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1020,12 +847,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-block-scoped-functions": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.25.9.tgz",
-      "integrity": "sha512-toHc9fzab0ZfenFpsyYinOX0J/5dgJVA2fm64xPewu7CoYHWEivIWKxkK2rMi4r3yQqLnVmheMXRdG+k239CgA==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.27.1.tgz",
+      "integrity": "sha512-cnqkuOtZLapWYZUYM5rVIdv1nXYuFVIltZ6ZJ7nIj585QsjKM5dhL2Fu/lICXZ1OyIAFc7Qy+bvDAtTXqGrlhg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1035,12 +862,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-block-scoping": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.25.9.tgz",
-      "integrity": "sha512-1F05O7AYjymAtqbsFETboN1NvBdcnzMerO+zlMyJBEz6WkMdejvGWw9p05iTSjC85RLlBseHHQpYaM4gzJkBGg==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.28.6.tgz",
+      "integrity": "sha512-tt/7wOtBmwHPNMPu7ax4pdPz6shjFrmHDghvNC+FG9Qvj7D6mJcoRQIF5dy4njmxR941l6rgtvfSB2zX3VlUIw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1050,13 +877,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-class-properties": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.25.9.tgz",
-      "integrity": "sha512-bbMAII8GRSkcd0h0b4X+36GksxuheLFjP65ul9w6C3KgAamI3JqErNgSrosX6ZPj+Mpim5VvEbawXxJCyEUV3Q==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.28.6.tgz",
+      "integrity": "sha512-dY2wS3I2G7D697VHndN91TJr8/AAfXQNt5ynCTI/MpxMsSzHp+52uNivYT5wCPax3whc47DR8Ba7cmlQMg24bw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-create-class-features-plugin": "^7.25.9",
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-create-class-features-plugin": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1066,13 +893,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-class-static-block": {
-      "version": "7.26.0",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.26.0.tgz",
-      "integrity": "sha512-6J2APTs7BDDm+UMqP1useWqhcRAXo0WIoVj26N7kPFB6S73Lgvyka4KTZYIxtgYXiN5HTyRObA72N2iu628iTQ==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.28.6.tgz",
+      "integrity": "sha512-rfQ++ghVwTWTqQ7w8qyDxL1XGihjBss4CmTgGRCTAC9RIbhVpyp4fOeZtta0Lbf+dTNIVJer6ych2ibHwkZqsQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-create-class-features-plugin": "^7.25.9",
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-create-class-features-plugin": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1082,17 +909,17 @@
       }
     },
     "node_modules/@babel/plugin-transform-classes": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.25.9.tgz",
-      "integrity": "sha512-mD8APIXmseE7oZvZgGABDyM34GUmK45Um2TXiBUt7PnuAxrgoSVf123qUzPxEr/+/BHrRn5NMZCdE2m/1F8DGg==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-classes/-/plugin-transform-classes-7.28.6.tgz",
+      "integrity": "sha512-EF5KONAqC5zAqT783iMGuM2ZtmEBy+mJMOKl2BCvPZ2lVrwvXnB6o+OBWCS+CoeCCpVRF2sA2RBKUxvT8tQT5Q==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-annotate-as-pure": "^7.25.9",
-        "@babel/helper-compilation-targets": "^7.25.9",
-        "@babel/helper-plugin-utils": "^7.25.9",
-        "@babel/helper-replace-supers": "^7.25.9",
-        "@babel/traverse": "^7.25.9",
-        "globals": "^11.1.0"
+        "@babel/helper-annotate-as-pure": "^7.27.3",
+        "@babel/helper-compilation-targets": "^7.28.6",
+        "@babel/helper-globals": "^7.28.0",
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/helper-replace-supers": "^7.28.6",
+        "@babel/traverse": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1102,13 +929,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-computed-properties": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.25.9.tgz",
-      "integrity": "sha512-HnBegGqXZR12xbcTHlJ9HGxw1OniltT26J5YpfruGqtUHlz/xKf/G2ak9e+t0rVqrjXa9WOhvYPz1ERfMj23AA==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.28.6.tgz",
+      "integrity": "sha512-bcc3k0ijhHbc2lEfpFHgx7eYw9KNXqOerKWfzbxEHUGKnS3sz9C4CNL9OiFN1297bDNfUiSO7DaLzbvHQQQ1BQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9",
-        "@babel/template": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/template": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1118,12 +945,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-destructuring": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.25.9.tgz",
-      "integrity": "sha512-WkCGb/3ZxXepmMiX101nnGiU+1CAdut8oHyEOHxkKuS1qKpU2SMXE2uSvfz8PBuLd49V6LEsbtyPhWC7fnkgvQ==",
+      "version": "7.28.5",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.28.5.tgz",
+      "integrity": "sha512-Kl9Bc6D0zTUcFUvkNuQh4eGXPKKNDOJQXVyyM4ZAQPMveniJdxi8XMJwLo+xSoW3MIq81bD33lcUe9kZpl0MCw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1",
+        "@babel/traverse": "^7.28.5"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1133,13 +961,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-dotall-regex": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.25.9.tgz",
-      "integrity": "sha512-t7ZQ7g5trIgSRYhI9pIJtRl64KHotutUJsh4Eze5l7olJv+mRSg4/MmbZ0tv1eeqRbdvo/+trvJD/Oc5DmW2cA==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.28.6.tgz",
+      "integrity": "sha512-SljjowuNKB7q5Oayv4FoPzeB74g3QgLt8IVJw9ADvWy3QnUb/01aw8I4AVv8wYnPvQz2GDDZ/g3GhcNyDBI4Bg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-create-regexp-features-plugin": "^7.25.9",
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-create-regexp-features-plugin": "^7.28.5",
+        "@babel/helper-plugin-utils": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1149,12 +977,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-duplicate-keys": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.25.9.tgz",
-      "integrity": "sha512-LZxhJ6dvBb/f3x8xwWIuyiAHy56nrRG3PeYTpBkkzkYRRQ6tJLu68lEF5VIqMUZiAV7a8+Tb78nEoMCMcqjXBw==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.27.1.tgz",
+      "integrity": "sha512-MTyJk98sHvSs+cvZ4nOauwTTG1JeonDjSGvGGUNHreGQns+Mpt6WX/dVzWBHgg+dYZhkC4X+zTDfkTU+Vy9y7Q==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1164,13 +992,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-duplicate-named-capturing-groups-regex": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-named-capturing-groups-regex/-/plugin-transform-duplicate-named-capturing-groups-regex-7.25.9.tgz",
-      "integrity": "sha512-0UfuJS0EsXbRvKnwcLjFtJy/Sxc5J5jhLHnFhy7u4zih97Hz6tJkLU+O+FMMrNZrosUPxDi6sYxJ/EA8jDiAog==",
+      "version": "7.29.0",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-duplicate-named-capturing-groups-regex/-/plugin-transform-duplicate-named-capturing-groups-regex-7.29.0.tgz",
+      "integrity": "sha512-zBPcW2lFGxdiD8PUnPwJjag2J9otbcLQzvbiOzDxpYXyCuYX9agOwMPGn1prVH0a4qzhCKu24rlH4c1f7yA8rw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-create-regexp-features-plugin": "^7.25.9",
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-create-regexp-features-plugin": "^7.28.5",
+        "@babel/helper-plugin-utils": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1180,12 +1008,28 @@
       }
     },
     "node_modules/@babel/plugin-transform-dynamic-import": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dynamic-import/-/plugin-transform-dynamic-import-7.25.9.tgz",
-      "integrity": "sha512-GCggjexbmSLaFhqsojeugBpeaRIgWNTcgKVq/0qIteFEqY2A+b9QidYadrWlnbWQUrW5fn+mCvf3tr7OeBFTyg==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-dynamic-import/-/plugin-transform-dynamic-import-7.27.1.tgz",
+      "integrity": "sha512-MHzkWQcEmjzzVW9j2q8LGjwGWpG2mjwaaB0BNQwst3FIjqsg8Ct/mIZlvSPJvfi9y2AC8mi/ktxbFVL9pZ1I4A==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-explicit-resource-management": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-explicit-resource-management/-/plugin-transform-explicit-resource-management-7.28.6.tgz",
+      "integrity": "sha512-Iao5Konzx2b6g7EPqTy40UZbcdXE126tTxVFr/nAIj+WItNxjKSYTEw3RC+A2/ZetmdJsgueL1KhaMCQHkLPIg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/plugin-transform-destructuring": "^7.28.5"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1195,12 +1039,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-exponentiation-operator": {
-      "version": "7.26.3",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.26.3.tgz",
-      "integrity": "sha512-7CAHcQ58z2chuXPWblnn1K6rLDnDWieghSOEmqQsrBenH0P9InCUtOJYD89pvngljmZlJcz3fcmgYsXFNGa1ZQ==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.28.6.tgz",
+      "integrity": "sha512-WitabqiGjV/vJ0aPOLSFfNY1u9U3R7W36B03r5I2KoNix+a3sOhJ3pKFB3R5It9/UiK78NiO0KE9P21cMhlPkw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1210,12 +1054,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-export-namespace-from": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-export-namespace-from/-/plugin-transform-export-namespace-from-7.25.9.tgz",
-      "integrity": "sha512-2NsEz+CxzJIVOPx2o9UsW1rXLqtChtLoVnwYHHiB04wS5sgn7mrV45fWMBX0Kk+ub9uXytVYfNP2HjbVbCB3Ww==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-export-namespace-from/-/plugin-transform-export-namespace-from-7.27.1.tgz",
+      "integrity": "sha512-tQvHWSZ3/jH2xuq/vZDy0jNn+ZdXJeM8gHvX4lnJmsc3+50yPlWdZXIc5ay+umX+2/tJIqHqiEqcJvxlmIvRvQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1225,13 +1069,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-for-of": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.25.9.tgz",
-      "integrity": "sha512-LqHxduHoaGELJl2uhImHwRQudhCM50pT46rIBNvtT/Oql3nqiS3wOwP+5ten7NpYSXrrVLgtZU3DZmPtWZo16A==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.27.1.tgz",
+      "integrity": "sha512-BfbWFFEJFQzLCQ5N8VocnCtA8J1CLkNTe2Ms2wocj75dd6VpiqS5Z5quTYcUoo4Yq+DN0rtikODccuv7RU81sw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9",
-        "@babel/helper-skip-transparent-expression-wrappers": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1241,14 +1085,14 @@
       }
     },
     "node_modules/@babel/plugin-transform-function-name": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.25.9.tgz",
-      "integrity": "sha512-8lP+Yxjv14Vc5MuWBpJsoUCd3hD6V9DgBon2FVYL4jJgbnVQ9fTgYmonchzZJOVNgzEgbxp4OwAf6xz6M/14XA==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.27.1.tgz",
+      "integrity": "sha512-1bQeydJF9Nr1eBCMMbC+hdwmRlsv5XYOMu03YSWFwNs0HsAmtSxxF1fyuYPqemVldVyFmlCU7w8UE14LupUSZQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-compilation-targets": "^7.25.9",
-        "@babel/helper-plugin-utils": "^7.25.9",
-        "@babel/traverse": "^7.25.9"
+        "@babel/helper-compilation-targets": "^7.27.1",
+        "@babel/helper-plugin-utils": "^7.27.1",
+        "@babel/traverse": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1258,12 +1102,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-json-strings": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.25.9.tgz",
-      "integrity": "sha512-xoTMk0WXceiiIvsaquQQUaLLXSW1KJ159KP87VilruQm0LNNGxWzahxSS6T6i4Zg3ezp4vA4zuwiNUR53qmQAw==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.28.6.tgz",
+      "integrity": "sha512-Nr+hEN+0geQkzhbdgQVPoqr47lZbm+5fCUmO70722xJZd0Mvb59+33QLImGj6F+DkK3xgDi1YVysP8whD6FQAw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1273,12 +1117,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-literals": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.25.9.tgz",
-      "integrity": "sha512-9N7+2lFziW8W9pBl2TzaNht3+pgMIRP74zizeCSrtnSKVdUl8mAjjOP2OOVQAfZ881P2cNjDj1uAMEdeD50nuQ==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-literals/-/plugin-transform-literals-7.27.1.tgz",
+      "integrity": "sha512-0HCFSepIpLTkLcsi86GG3mTUzxV5jpmbv97hTETW3yzrAij8aqlD36toB1D0daVFJM8NK6GvKO0gslVQmm+zZA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1288,12 +1132,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-logical-assignment-operators": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.25.9.tgz",
-      "integrity": "sha512-wI4wRAzGko551Y8eVf6iOY9EouIDTtPb0ByZx+ktDGHwv6bHFimrgJM/2T021txPZ2s4c7bqvHbd+vXG6K948Q==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.28.6.tgz",
+      "integrity": "sha512-+anKKair6gpi8VsM/95kmomGNMD0eLz1NQ8+Pfw5sAwWH9fGYXT50E55ZpV0pHUHWf6IUTWPM+f/7AAff+wr9A==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1303,12 +1147,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-member-expression-literals": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.25.9.tgz",
-      "integrity": "sha512-PYazBVfofCQkkMzh2P6IdIUaCEWni3iYEerAsRWuVd8+jlM1S9S9cz1dF9hIzyoZ8IA3+OwVYIp9v9e+GbgZhA==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.27.1.tgz",
+      "integrity": "sha512-hqoBX4dcZ1I33jCSWcXrP+1Ku7kdqXf1oeah7ooKOIiAdKQ+uqftgCFNOSzA5AMS2XIHEYeGFg4cKRCdpxzVOQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1318,13 +1162,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-modules-amd": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.25.9.tgz",
-      "integrity": "sha512-g5T11tnI36jVClQlMlt4qKDLlWnG5pP9CSM4GhdRciTNMRgkfpo5cR6b4rGIOYPgRRuFAvwjPQ/Yk+ql4dyhbw==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.27.1.tgz",
+      "integrity": "sha512-iCsytMg/N9/oFq6n+gFTvUYDZQOMK5kEdeYxmxt91fcJGycfxVP9CnrxoliM0oumFERba2i8ZtwRUCMhvP1LnA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-module-transforms": "^7.25.9",
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-module-transforms": "^7.27.1",
+        "@babel/helper-plugin-utils": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1334,13 +1178,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-modules-commonjs": {
-      "version": "7.26.3",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.26.3.tgz",
-      "integrity": "sha512-MgR55l4q9KddUDITEzEFYn5ZsGDXMSsU9E+kh7fjRXTIC3RHqfCo8RPRbyReYJh44HQ/yomFkqbOFohXvDCiIQ==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.28.6.tgz",
+      "integrity": "sha512-jppVbf8IV9iWWwWTQIxJMAJCWBuuKx71475wHwYytrRGQ2CWiDvYlADQno3tcYpS/T2UUWFQp3nVtYfK/YBQrA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-module-transforms": "^7.26.0",
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-module-transforms": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1350,15 +1194,15 @@
       }
     },
     "node_modules/@babel/plugin-transform-modules-systemjs": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.25.9.tgz",
-      "integrity": "sha512-hyss7iIlH/zLHaehT+xwiymtPOpsiwIIRlCAOwBB04ta5Tt+lNItADdlXw3jAWZ96VJ2jlhl/c+PNIQPKNfvcA==",
+      "version": "7.29.0",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.29.0.tgz",
+      "integrity": "sha512-PrujnVFbOdUpw4UHiVwKvKRLMMic8+eC0CuNlxjsyZUiBjhFdPsewdXCkveh2KqBA9/waD0W1b4hXSOBQJezpQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-module-transforms": "^7.25.9",
-        "@babel/helper-plugin-utils": "^7.25.9",
-        "@babel/helper-validator-identifier": "^7.25.9",
-        "@babel/traverse": "^7.25.9"
+        "@babel/helper-module-transforms": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "@babel/traverse": "^7.29.0"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1368,13 +1212,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-modules-umd": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.25.9.tgz",
-      "integrity": "sha512-bS9MVObUgE7ww36HEfwe6g9WakQ0KF07mQF74uuXdkoziUPfKyu/nIm663kz//e5O1nPInPFx36z7WJmJ4yNEw==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.27.1.tgz",
+      "integrity": "sha512-iQBE/xC5BV1OxJbp6WG7jq9IWiD+xxlZhLrdwpPkTX3ydmXdvoCpyfJN7acaIBZaOqTfr76pgzqBJflNbeRK+w==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-module-transforms": "^7.25.9",
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-module-transforms": "^7.27.1",
+        "@babel/helper-plugin-utils": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1384,13 +1228,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-named-capturing-groups-regex": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.25.9.tgz",
-      "integrity": "sha512-oqB6WHdKTGl3q/ItQhpLSnWWOpjUJLsOCLVyeFgeTktkBSCiurvPOsyt93gibI9CmuKvTUEtWmG5VhZD+5T/KA==",
+      "version": "7.29.0",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.29.0.tgz",
+      "integrity": "sha512-1CZQA5KNAD6ZYQLPw7oi5ewtDNxH/2vuCh+6SmvgDfhumForvs8a1o9n0UrEoBD8HU4djO2yWngTQlXl1NDVEQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-create-regexp-features-plugin": "^7.25.9",
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-create-regexp-features-plugin": "^7.28.5",
+        "@babel/helper-plugin-utils": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1400,12 +1244,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-new-target": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.25.9.tgz",
-      "integrity": "sha512-U/3p8X1yCSoKyUj2eOBIx3FOn6pElFOKvAAGf8HTtItuPyB+ZeOqfn+mvTtg9ZlOAjsPdK3ayQEjqHjU/yLeVQ==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.27.1.tgz",
+      "integrity": "sha512-f6PiYeqXQ05lYq3TIfIDu/MtliKUbNwkGApPUvyo6+tc7uaR4cPjPe7DFPr15Uyycg2lZU6btZ575CuQoYh7MQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1415,12 +1259,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-nullish-coalescing-operator": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.25.9.tgz",
-      "integrity": "sha512-ENfftpLZw5EItALAD4WsY/KUWvhUlZndm5GC7G3evUsVeSJB6p0pBeLQUnRnBCBx7zV0RKQjR9kCuwrsIrjWog==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.28.6.tgz",
+      "integrity": "sha512-3wKbRgmzYbw24mDJXT7N+ADXw8BC/imU9yo9c9X9NKaLF1fW+e5H1U5QjMUBe4Qo4Ox/o++IyUkl1sVCLgevKg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1430,12 +1274,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-numeric-separator": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.25.9.tgz",
-      "integrity": "sha512-TlprrJ1GBZ3r6s96Yq8gEQv82s8/5HnCVHtEJScUj90thHQbwe+E5MLhi2bbNHBEJuzrvltXSru+BUxHDoog7Q==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.28.6.tgz",
+      "integrity": "sha512-SJR8hPynj8outz+SlStQSwvziMN4+Bq99it4tMIf5/Caq+3iOc0JtKyse8puvyXkk3eFRIA5ID/XfunGgO5i6w==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1445,14 +1289,16 @@
       }
     },
     "node_modules/@babel/plugin-transform-object-rest-spread": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.25.9.tgz",
-      "integrity": "sha512-fSaXafEE9CVHPweLYw4J0emp1t8zYTXyzN3UuG+lylqkvYd7RMrsOQ8TYx5RF231be0vqtFC6jnx3UmpJmKBYg==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.28.6.tgz",
+      "integrity": "sha512-5rh+JR4JBC4pGkXLAcYdLHZjXudVxWMXbB6u6+E9lRL5TrGVbHt1TjxGbZ8CkmYw9zjkB7jutzOROArsqtncEA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-compilation-targets": "^7.25.9",
-        "@babel/helper-plugin-utils": "^7.25.9",
-        "@babel/plugin-transform-parameters": "^7.25.9"
+        "@babel/helper-compilation-targets": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/plugin-transform-destructuring": "^7.28.5",
+        "@babel/plugin-transform-parameters": "^7.27.7",
+        "@babel/traverse": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1462,13 +1308,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-object-super": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.25.9.tgz",
-      "integrity": "sha512-Kj/Gh+Rw2RNLbCK1VAWj2U48yxxqL2x0k10nPtSdRa0O2xnHXalD0s+o1A6a0W43gJ00ANo38jxkQreckOzv5A==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.27.1.tgz",
+      "integrity": "sha512-SFy8S9plRPbIcxlJ8A6mT/CxFdJx/c04JEctz4jf8YZaVS2px34j7NXRrlGlHkN/M2gnpL37ZpGRGVFLd3l8Ng==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9",
-        "@babel/helper-replace-supers": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1",
+        "@babel/helper-replace-supers": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1478,12 +1324,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-optional-catch-binding": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.25.9.tgz",
-      "integrity": "sha512-qM/6m6hQZzDcZF3onzIhZeDHDO43bkNNlOX0i8n3lR6zLbu0GN2d8qfM/IERJZYauhAHSLHy39NF0Ctdvcid7g==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.28.6.tgz",
+      "integrity": "sha512-R8ja/Pyrv0OGAvAXQhSTmWyPJPml+0TMqXlO5w+AsMEiwb2fg3WkOvob7UxFSL3OIttFSGSRFKQsOhJ/X6HQdQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1493,13 +1339,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-optional-chaining": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.25.9.tgz",
-      "integrity": "sha512-6AvV0FsLULbpnXeBjrY4dmWF8F7gf8QnvTEoO/wX/5xm/xE1Xo8oPuD3MPS+KS9f9XBEAWN7X1aWr4z9HdOr7A==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.28.6.tgz",
+      "integrity": "sha512-A4zobikRGJTsX9uqVFdafzGkqD30t26ck2LmOzAuLL8b2x6k3TIqRiT2xVvA9fNmFeTX484VpsdgmKNA0bS23w==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9",
-        "@babel/helper-skip-transparent-expression-wrappers": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1509,12 +1355,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-parameters": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.25.9.tgz",
-      "integrity": "sha512-wzz6MKwpnshBAiRmn4jR8LYz/g8Ksg0o80XmwZDlordjwEk9SxBzTWC7F5ef1jhbrbOW2DJ5J6ayRukrJmnr0g==",
+      "version": "7.27.7",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.27.7.tgz",
+      "integrity": "sha512-qBkYTYCb76RRxUM6CcZA5KRu8K4SM8ajzVeUgVdMVO9NN9uI/GaVmBg/WKJJGnNokV9SY8FxNOVWGXzqzUidBg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1524,13 +1370,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-private-methods": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.25.9.tgz",
-      "integrity": "sha512-D/JUozNpQLAPUVusvqMxyvjzllRaF8/nSrP1s2YGQT/W4LHK4xxsMcHjhOGTS01mp9Hda8nswb+FblLdJornQw==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.28.6.tgz",
+      "integrity": "sha512-piiuapX9CRv7+0st8lmuUlRSmX6mBcVeNQ1b4AYzJxfCMuBfB0vBXDiGSmm03pKJw1v6cZ8KSeM+oUnM6yAExg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-create-class-features-plugin": "^7.25.9",
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-create-class-features-plugin": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1540,14 +1386,14 @@
       }
     },
     "node_modules/@babel/plugin-transform-private-property-in-object": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.25.9.tgz",
-      "integrity": "sha512-Evf3kcMqzXA3xfYJmZ9Pg1OvKdtqsDMSWBDzZOPLvHiTt36E75jLDQo5w1gtRU95Q4E5PDttrTf25Fw8d/uWLw==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.28.6.tgz",
+      "integrity": "sha512-b97jvNSOb5+ehyQmBpmhOCiUC5oVK4PMnpRvO7+ymFBoqYjeDHIU9jnrNUuwHOiL9RpGDoKBpSViarV+BU+eVA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-annotate-as-pure": "^7.25.9",
-        "@babel/helper-create-class-features-plugin": "^7.25.9",
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-annotate-as-pure": "^7.27.3",
+        "@babel/helper-create-class-features-plugin": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1557,12 +1403,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-property-literals": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.25.9.tgz",
-      "integrity": "sha512-IvIUeV5KrS/VPavfSM/Iu+RE6llrHrYIKY1yfCzyO/lMXHQ+p7uGhonmGVisv6tSBSVgWzMBohTcvkC9vQcQFA==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.27.1.tgz",
+      "integrity": "sha512-oThy3BCuCha8kDZ8ZkgOg2exvPYUlprMukKQXI1r1pJ47NCvxfkEy8vK+r/hT9nF0Aa4H1WUPZZjHTFtAhGfmQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1572,12 +1418,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-react-constant-elements": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-constant-elements/-/plugin-transform-react-constant-elements-7.25.9.tgz",
-      "integrity": "sha512-Ncw2JFsJVuvfRsa2lSHiC55kETQVLSnsYGQ1JDDwkUeWGTL/8Tom8aLTnlqgoeuopWrbbGndrc9AlLYrIosrow==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-react-constant-elements/-/plugin-transform-react-constant-elements-7.27.1.tgz",
+      "integrity": "sha512-edoidOjl/ZxvYo4lSBOQGDSyToYVkTAwyVoa2tkuYTSmjrB1+uAedoL5iROVLXkxH+vRgA7uP4tMg2pUJpZ3Ug==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1587,12 +1433,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-react-display-name": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-display-name/-/plugin-transform-react-display-name-7.25.9.tgz",
-      "integrity": "sha512-KJfMlYIUxQB1CJfO3e0+h0ZHWOTLCPP115Awhaz8U0Zpq36Gl/cXlpoyMRnUWlhNUBAzldnCiAZNvCDj7CrKxQ==",
+      "version": "7.28.0",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-react-display-name/-/plugin-transform-react-display-name-7.28.0.tgz",
+      "integrity": "sha512-D6Eujc2zMxKjfa4Zxl4GHMsmhKKZ9VpcqIchJLvwTxad9zWIYulwYItBovpDOoNLISpcZSXoDJ5gaGbQUDqViA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1602,16 +1448,16 @@
       }
     },
     "node_modules/@babel/plugin-transform-react-jsx": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.25.9.tgz",
-      "integrity": "sha512-s5XwpQYCqGerXl+Pu6VDL3x0j2d82eiV77UJ8a2mDHAW7j9SWRqQ2y1fNo1Z74CdcYipl5Z41zvjj4Nfzq36rw==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.28.6.tgz",
+      "integrity": "sha512-61bxqhiRfAACulXSLd/GxqmAedUSrRZIu/cbaT18T1CetkTmtDN15it7i80ru4DVqRK1WMxQhXs+Lf9kajm5Ow==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-annotate-as-pure": "^7.25.9",
-        "@babel/helper-module-imports": "^7.25.9",
-        "@babel/helper-plugin-utils": "^7.25.9",
-        "@babel/plugin-syntax-jsx": "^7.25.9",
-        "@babel/types": "^7.25.9"
+        "@babel/helper-annotate-as-pure": "^7.27.3",
+        "@babel/helper-module-imports": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/plugin-syntax-jsx": "^7.28.6",
+        "@babel/types": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1621,12 +1467,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-react-jsx-development": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-development/-/plugin-transform-react-jsx-development-7.25.9.tgz",
-      "integrity": "sha512-9mj6rm7XVYs4mdLIpbZnHOYdpW42uoiBCTVowg7sP1thUOiANgMb4UtpRivR0pp5iL+ocvUv7X4mZgFRpJEzGw==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-react-jsx-development/-/plugin-transform-react-jsx-development-7.27.1.tgz",
+      "integrity": "sha512-ykDdF5yI4f1WrAolLqeF3hmYU12j9ntLQl/AOG1HAS21jxyg1Q0/J/tpREuYLfatGdGmXp/3yS0ZA76kOlVq9Q==",
       "license": "MIT",
       "dependencies": {
-        "@babel/plugin-transform-react-jsx": "^7.25.9"
+        "@babel/plugin-transform-react-jsx": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1636,13 +1482,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-react-pure-annotations": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-pure-annotations/-/plugin-transform-react-pure-annotations-7.25.9.tgz",
-      "integrity": "sha512-KQ/Takk3T8Qzj5TppkS1be588lkbTp5uj7w6a0LeQaTMSckU/wK0oJ/pih+T690tkgI5jfmg2TqDJvd41Sj1Cg==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-react-pure-annotations/-/plugin-transform-react-pure-annotations-7.27.1.tgz",
+      "integrity": "sha512-JfuinvDOsD9FVMTHpzA/pBLisxpv1aSf+OIV8lgH3MuWrks19R27e6a6DipIg4aX1Zm9Wpb04p8wljfKrVSnPA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-annotate-as-pure": "^7.25.9",
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-annotate-as-pure": "^7.27.1",
+        "@babel/helper-plugin-utils": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1652,13 +1498,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-regenerator": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.25.9.tgz",
-      "integrity": "sha512-vwDcDNsgMPDGP0nMqzahDWE5/MLcX8sv96+wfX7as7LoF/kr97Bo/7fI00lXY4wUXYfVmwIIyG80fGZ1uvt2qg==",
+      "version": "7.29.0",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.29.0.tgz",
+      "integrity": "sha512-FijqlqMA7DmRdg/aINBSs04y8XNTYw/lr1gJ2WsmBnnaNw1iS43EPkJW+zK7z65auG3AWRFXWj+NcTQwYptUog==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9",
-        "regenerator-transform": "^0.15.2"
+        "@babel/helper-plugin-utils": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1668,13 +1513,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-regexp-modifiers": {
-      "version": "7.26.0",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regexp-modifiers/-/plugin-transform-regexp-modifiers-7.26.0.tgz",
-      "integrity": "sha512-vN6saax7lrA2yA/Pak3sCxuD6F5InBjn9IcrIKQPjpsLvuHYLVroTxjdlVRHjjBWxKOqIwpTXDkOssYT4BFdRw==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-regexp-modifiers/-/plugin-transform-regexp-modifiers-7.28.6.tgz",
+      "integrity": "sha512-QGWAepm9qxpaIs7UM9FvUSnCGlb8Ua1RhyM4/veAxLwt3gMat/LSGrZixyuj4I6+Kn9iwvqCyPTtbdxanYoWYg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-create-regexp-features-plugin": "^7.25.9",
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-create-regexp-features-plugin": "^7.28.5",
+        "@babel/helper-plugin-utils": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1684,12 +1529,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-reserved-words": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.25.9.tgz",
-      "integrity": "sha512-7DL7DKYjn5Su++4RXu8puKZm2XBPHyjWLUidaPEkCUBbE7IPcsrkRHggAOOKydH1dASWdcUBxrkOGNxUv5P3Jg==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.27.1.tgz",
+      "integrity": "sha512-V2ABPHIJX4kC7HegLkYoDpfg9PVmuWy/i6vUM5eGK22bx4YVFD3M5F0QQnWQoDs6AGsUWTVOopBiMFQgHaSkVw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1699,16 +1544,16 @@
       }
     },
     "node_modules/@babel/plugin-transform-runtime": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-runtime/-/plugin-transform-runtime-7.25.9.tgz",
-      "integrity": "sha512-nZp7GlEl+yULJrClz0SwHPqir3lc0zsPrDHQUcxGspSL7AKrexNSEfTbfqnDNJUO13bgKyfuOLMF8Xqtu8j3YQ==",
+      "version": "7.29.0",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-runtime/-/plugin-transform-runtime-7.29.0.tgz",
+      "integrity": "sha512-jlaRT5dJtMaMCV6fAuLbsQMSwz/QkvaHOHOSXRitGGwSpR1blCY4KUKoyP2tYO8vJcqYe8cEj96cqSztv3uF9w==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-module-imports": "^7.25.9",
-        "@babel/helper-plugin-utils": "^7.25.9",
-        "babel-plugin-polyfill-corejs2": "^0.4.10",
-        "babel-plugin-polyfill-corejs3": "^0.10.6",
-        "babel-plugin-polyfill-regenerator": "^0.6.1",
+        "@babel/helper-module-imports": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "babel-plugin-polyfill-corejs2": "^0.4.14",
+        "babel-plugin-polyfill-corejs3": "^0.13.0",
+        "babel-plugin-polyfill-regenerator": "^0.6.5",
         "semver": "^6.3.1"
       },
       "engines": {
@@ -1718,22 +1563,13 @@
         "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@babel/plugin-transform-runtime/node_modules/semver": {
-      "version": "6.3.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
-      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      }
-    },
     "node_modules/@babel/plugin-transform-shorthand-properties": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.25.9.tgz",
-      "integrity": "sha512-MUv6t0FhO5qHnS/W8XCbHmiRWOphNufpE1IVxhK5kuN3Td9FT1x4rx4K42s3RYdMXCXpfWkGSbCSd0Z64xA7Ng==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.27.1.tgz",
+      "integrity": "sha512-N/wH1vcn4oYawbJ13Y/FxcQrWk63jhfNa7jef0ih7PHSIHX2LB7GWE1rkPrOnka9kwMxb6hMl19p7lidA+EHmQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1743,13 +1579,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-spread": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.25.9.tgz",
-      "integrity": "sha512-oNknIB0TbURU5pqJFVbOOFspVlrpVwo2H1+HUIsVDvp5VauGGDP1ZEvO8Nn5xyMEs3dakajOxlmkNW7kNgSm6A==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-spread/-/plugin-transform-spread-7.28.6.tgz",
+      "integrity": "sha512-9U4QObUC0FtJl05AsUcodau/RWDytrU6uKgkxu09mLR9HLDAtUMoPuuskm5huQsoktmsYpI+bGmq+iapDcriKA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9",
-        "@babel/helper-skip-transparent-expression-wrappers": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1759,12 +1595,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-sticky-regex": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.25.9.tgz",
-      "integrity": "sha512-WqBUSgeVwucYDP9U/xNRQam7xV8W5Zf+6Eo7T2SRVUFlhRiMNFdFz58u0KZmCVVqs2i7SHgpRnAhzRNmKfi2uA==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.27.1.tgz",
+      "integrity": "sha512-lhInBO5bi/Kowe2/aLdBAawijx+q1pQzicSgnkB6dUPc1+RC8QmJHKf2OjvU+NZWitguJHEaEmbV6VWEouT58g==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1774,12 +1610,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-template-literals": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.25.9.tgz",
-      "integrity": "sha512-o97AE4syN71M/lxrCtQByzphAdlYluKPDBzDVzMmfCobUjjhAryZV0AIpRPrxN0eAkxXO6ZLEScmt+PNhj2OTw==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.27.1.tgz",
+      "integrity": "sha512-fBJKiV7F2DxZUkg5EtHKXQdbsbURW3DZKQUWphDum0uRP6eHGGa/He9mc0mypL680pb+e/lDIthRohlv8NCHkg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1789,12 +1625,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-typeof-symbol": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.25.9.tgz",
-      "integrity": "sha512-v61XqUMiueJROUv66BVIOi0Fv/CUuZuZMl5NkRoCVxLAnMexZ0A3kMe7vvZ0nulxMuMp0Mk6S5hNh48yki08ZA==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.27.1.tgz",
+      "integrity": "sha512-RiSILC+nRJM7FY5srIyc4/fGIwUhyDuuBSdWn4y6yT6gm652DpCHZjIipgn6B7MQ1ITOUnAKWixEUjQRIBIcLw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1804,16 +1640,16 @@
       }
     },
     "node_modules/@babel/plugin-transform-typescript": {
-      "version": "7.26.3",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.26.3.tgz",
-      "integrity": "sha512-6+5hpdr6mETwSKjmJUdYw0EIkATiQhnELWlE3kJFBwSg/BGIVwVaVbX+gOXBCdc7Ln1RXZxyWGecIXhUfnl7oA==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.28.6.tgz",
+      "integrity": "sha512-0YWL2RFxOqEm9Efk5PvreamxPME8OyY0wM5wh5lHjF+VtVhdneCWGzZeSqzOfiobVqQaNCd2z0tQvnI9DaPWPw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-annotate-as-pure": "^7.25.9",
-        "@babel/helper-create-class-features-plugin": "^7.25.9",
-        "@babel/helper-plugin-utils": "^7.25.9",
-        "@babel/helper-skip-transparent-expression-wrappers": "^7.25.9",
-        "@babel/plugin-syntax-typescript": "^7.25.9"
+        "@babel/helper-annotate-as-pure": "^7.27.3",
+        "@babel/helper-create-class-features-plugin": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1",
+        "@babel/plugin-syntax-typescript": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1823,12 +1659,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-unicode-escapes": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.25.9.tgz",
-      "integrity": "sha512-s5EDrE6bW97LtxOcGj1Khcx5AaXwiMmi4toFWRDP9/y0Woo6pXC+iyPu/KuhKtfSrNFd7jJB+/fkOtZy6aIC6Q==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.27.1.tgz",
+      "integrity": "sha512-Ysg4v6AmF26k9vpfFuTZg8HRfVWzsh1kVfowA23y9j/Gu6dOuahdUVhkLqpObp3JIv27MLSii6noRnuKN8H0Mg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1838,13 +1674,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-unicode-property-regex": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.25.9.tgz",
-      "integrity": "sha512-Jt2d8Ga+QwRluxRQ307Vlxa6dMrYEMZCgGxoPR8V52rxPyldHu3hdlHspxaqYmE7oID5+kB+UKUB/eWS+DkkWg==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.28.6.tgz",
+      "integrity": "sha512-4Wlbdl/sIZjzi/8St0evF0gEZrgOswVO6aOzqxh1kDZOl9WmLrHq2HtGhnOJZmHZYKP8WZ1MDLCt5DAWwRo57A==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-create-regexp-features-plugin": "^7.25.9",
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-create-regexp-features-plugin": "^7.28.5",
+        "@babel/helper-plugin-utils": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1854,13 +1690,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-unicode-regex": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.25.9.tgz",
-      "integrity": "sha512-yoxstj7Rg9dlNn9UQxzk4fcNivwv4nUYz7fYXBaKxvw/lnmPuOm/ikoELygbYq68Bls3D/D+NBPHiLwZdZZ4HA==",
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.27.1.tgz",
+      "integrity": "sha512-xvINq24TRojDuyt6JGtHmkVkrfVV3FPT16uytxImLeBZqW3/H52yN+kM1MGuyPkIQxrzKwPHs5U/MP3qKyzkGw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-create-regexp-features-plugin": "^7.25.9",
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-create-regexp-features-plugin": "^7.27.1",
+        "@babel/helper-plugin-utils": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1870,13 +1706,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-unicode-sets-regex": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.25.9.tgz",
-      "integrity": "sha512-8BYqO3GeVNHtx69fdPshN3fnzUNLrWdHhk/icSwigksJGczKSizZ+Z6SBCxTs723Fr5VSNorTIK7a+R2tISvwQ==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.28.6.tgz",
+      "integrity": "sha512-/wHc/paTUmsDYN7SZkpWxogTOBNnlx7nBQYfy6JJlCT7G3mVhltk3e++N7zV0XfgGsrqBxd4rJQt9H16I21Y1Q==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-create-regexp-features-plugin": "^7.25.9",
-        "@babel/helper-plugin-utils": "^7.25.9"
+        "@babel/helper-create-regexp-features-plugin": "^7.28.5",
+        "@babel/helper-plugin-utils": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1886,79 +1722,80 @@
       }
     },
     "node_modules/@babel/preset-env": {
-      "version": "7.26.0",
-      "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.26.0.tgz",
-      "integrity": "sha512-H84Fxq0CQJNdPFT2DrfnylZ3cf5K43rGfWK4LJGPpjKHiZlk0/RzwEus3PDDZZg+/Er7lCA03MVacueUuXdzfw==",
-      "license": "MIT",
-      "dependencies": {
-        "@babel/compat-data": "^7.26.0",
-        "@babel/helper-compilation-targets": "^7.25.9",
-        "@babel/helper-plugin-utils": "^7.25.9",
-        "@babel/helper-validator-option": "^7.25.9",
-        "@babel/plugin-bugfix-firefox-class-in-computed-class-key": "^7.25.9",
-        "@babel/plugin-bugfix-safari-class-field-initializer-scope": "^7.25.9",
-        "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": "^7.25.9",
-        "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.25.9",
-        "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": "^7.25.9",
+      "version": "7.29.2",
+      "resolved": "https://registry.facebook.net/@babel/preset-env/-/preset-env-7.29.2.tgz",
+      "integrity": "sha512-DYD23veRYGvBFhcTY1iUvJnDNpuqNd/BzBwCvzOTKUnJjKg5kpUBh3/u9585Agdkgj+QuygG7jLfOPWMa2KVNw==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/compat-data": "^7.29.0",
+        "@babel/helper-compilation-targets": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/helper-validator-option": "^7.27.1",
+        "@babel/plugin-bugfix-firefox-class-in-computed-class-key": "^7.28.5",
+        "@babel/plugin-bugfix-safari-class-field-initializer-scope": "^7.27.1",
+        "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": "^7.27.1",
+        "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.27.1",
+        "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": "^7.28.6",
         "@babel/plugin-proposal-private-property-in-object": "7.21.0-placeholder-for-preset-env.2",
-        "@babel/plugin-syntax-import-assertions": "^7.26.0",
-        "@babel/plugin-syntax-import-attributes": "^7.26.0",
+        "@babel/plugin-syntax-import-assertions": "^7.28.6",
+        "@babel/plugin-syntax-import-attributes": "^7.28.6",
         "@babel/plugin-syntax-unicode-sets-regex": "^7.18.6",
-        "@babel/plugin-transform-arrow-functions": "^7.25.9",
-        "@babel/plugin-transform-async-generator-functions": "^7.25.9",
-        "@babel/plugin-transform-async-to-generator": "^7.25.9",
-        "@babel/plugin-transform-block-scoped-functions": "^7.25.9",
-        "@babel/plugin-transform-block-scoping": "^7.25.9",
-        "@babel/plugin-transform-class-properties": "^7.25.9",
-        "@babel/plugin-transform-class-static-block": "^7.26.0",
-        "@babel/plugin-transform-classes": "^7.25.9",
-        "@babel/plugin-transform-computed-properties": "^7.25.9",
-        "@babel/plugin-transform-destructuring": "^7.25.9",
-        "@babel/plugin-transform-dotall-regex": "^7.25.9",
-        "@babel/plugin-transform-duplicate-keys": "^7.25.9",
-        "@babel/plugin-transform-duplicate-named-capturing-groups-regex": "^7.25.9",
-        "@babel/plugin-transform-dynamic-import": "^7.25.9",
-        "@babel/plugin-transform-exponentiation-operator": "^7.25.9",
-        "@babel/plugin-transform-export-namespace-from": "^7.25.9",
-        "@babel/plugin-transform-for-of": "^7.25.9",
-        "@babel/plugin-transform-function-name": "^7.25.9",
-        "@babel/plugin-transform-json-strings": "^7.25.9",
-        "@babel/plugin-transform-literals": "^7.25.9",
-        "@babel/plugin-transform-logical-assignment-operators": "^7.25.9",
-        "@babel/plugin-transform-member-expression-literals": "^7.25.9",
-        "@babel/plugin-transform-modules-amd": "^7.25.9",
-        "@babel/plugin-transform-modules-commonjs": "^7.25.9",
-        "@babel/plugin-transform-modules-systemjs": "^7.25.9",
-        "@babel/plugin-transform-modules-umd": "^7.25.9",
-        "@babel/plugin-transform-named-capturing-groups-regex": "^7.25.9",
-        "@babel/plugin-transform-new-target": "^7.25.9",
-        "@babel/plugin-transform-nullish-coalescing-operator": "^7.25.9",
-        "@babel/plugin-transform-numeric-separator": "^7.25.9",
-        "@babel/plugin-transform-object-rest-spread": "^7.25.9",
-        "@babel/plugin-transform-object-super": "^7.25.9",
-        "@babel/plugin-transform-optional-catch-binding": "^7.25.9",
-        "@babel/plugin-transform-optional-chaining": "^7.25.9",
-        "@babel/plugin-transform-parameters": "^7.25.9",
-        "@babel/plugin-transform-private-methods": "^7.25.9",
-        "@babel/plugin-transform-private-property-in-object": "^7.25.9",
-        "@babel/plugin-transform-property-literals": "^7.25.9",
-        "@babel/plugin-transform-regenerator": "^7.25.9",
-        "@babel/plugin-transform-regexp-modifiers": "^7.26.0",
-        "@babel/plugin-transform-reserved-words": "^7.25.9",
-        "@babel/plugin-transform-shorthand-properties": "^7.25.9",
-        "@babel/plugin-transform-spread": "^7.25.9",
-        "@babel/plugin-transform-sticky-regex": "^7.25.9",
-        "@babel/plugin-transform-template-literals": "^7.25.9",
-        "@babel/plugin-transform-typeof-symbol": "^7.25.9",
-        "@babel/plugin-transform-unicode-escapes": "^7.25.9",
-        "@babel/plugin-transform-unicode-property-regex": "^7.25.9",
-        "@babel/plugin-transform-unicode-regex": "^7.25.9",
-        "@babel/plugin-transform-unicode-sets-regex": "^7.25.9",
+        "@babel/plugin-transform-arrow-functions": "^7.27.1",
+        "@babel/plugin-transform-async-generator-functions": "^7.29.0",
+        "@babel/plugin-transform-async-to-generator": "^7.28.6",
+        "@babel/plugin-transform-block-scoped-functions": "^7.27.1",
+        "@babel/plugin-transform-block-scoping": "^7.28.6",
+        "@babel/plugin-transform-class-properties": "^7.28.6",
+        "@babel/plugin-transform-class-static-block": "^7.28.6",
+        "@babel/plugin-transform-classes": "^7.28.6",
+        "@babel/plugin-transform-computed-properties": "^7.28.6",
+        "@babel/plugin-transform-destructuring": "^7.28.5",
+        "@babel/plugin-transform-dotall-regex": "^7.28.6",
+        "@babel/plugin-transform-duplicate-keys": "^7.27.1",
+        "@babel/plugin-transform-duplicate-named-capturing-groups-regex": "^7.29.0",
+        "@babel/plugin-transform-dynamic-import": "^7.27.1",
+        "@babel/plugin-transform-explicit-resource-management": "^7.28.6",
+        "@babel/plugin-transform-exponentiation-operator": "^7.28.6",
+        "@babel/plugin-transform-export-namespace-from": "^7.27.1",
+        "@babel/plugin-transform-for-of": "^7.27.1",
+        "@babel/plugin-transform-function-name": "^7.27.1",
+        "@babel/plugin-transform-json-strings": "^7.28.6",
+        "@babel/plugin-transform-literals": "^7.27.1",
+        "@babel/plugin-transform-logical-assignment-operators": "^7.28.6",
+        "@babel/plugin-transform-member-expression-literals": "^7.27.1",
+        "@babel/plugin-transform-modules-amd": "^7.27.1",
+        "@babel/plugin-transform-modules-commonjs": "^7.28.6",
+        "@babel/plugin-transform-modules-systemjs": "^7.29.0",
+        "@babel/plugin-transform-modules-umd": "^7.27.1",
+        "@babel/plugin-transform-named-capturing-groups-regex": "^7.29.0",
+        "@babel/plugin-transform-new-target": "^7.27.1",
+        "@babel/plugin-transform-nullish-coalescing-operator": "^7.28.6",
+        "@babel/plugin-transform-numeric-separator": "^7.28.6",
+        "@babel/plugin-transform-object-rest-spread": "^7.28.6",
+        "@babel/plugin-transform-object-super": "^7.27.1",
+        "@babel/plugin-transform-optional-catch-binding": "^7.28.6",
+        "@babel/plugin-transform-optional-chaining": "^7.28.6",
+        "@babel/plugin-transform-parameters": "^7.27.7",
+        "@babel/plugin-transform-private-methods": "^7.28.6",
+        "@babel/plugin-transform-private-property-in-object": "^7.28.6",
+        "@babel/plugin-transform-property-literals": "^7.27.1",
+        "@babel/plugin-transform-regenerator": "^7.29.0",
+        "@babel/plugin-transform-regexp-modifiers": "^7.28.6",
+        "@babel/plugin-transform-reserved-words": "^7.27.1",
+        "@babel/plugin-transform-shorthand-properties": "^7.27.1",
+        "@babel/plugin-transform-spread": "^7.28.6",
+        "@babel/plugin-transform-sticky-regex": "^7.27.1",
+        "@babel/plugin-transform-template-literals": "^7.27.1",
+        "@babel/plugin-transform-typeof-symbol": "^7.27.1",
+        "@babel/plugin-transform-unicode-escapes": "^7.27.1",
+        "@babel/plugin-transform-unicode-property-regex": "^7.28.6",
+        "@babel/plugin-transform-unicode-regex": "^7.27.1",
+        "@babel/plugin-transform-unicode-sets-regex": "^7.28.6",
         "@babel/preset-modules": "0.1.6-no-external-plugins",
-        "babel-plugin-polyfill-corejs2": "^0.4.10",
-        "babel-plugin-polyfill-corejs3": "^0.10.6",
-        "babel-plugin-polyfill-regenerator": "^0.6.1",
-        "core-js-compat": "^3.38.1",
+        "babel-plugin-polyfill-corejs2": "^0.4.15",
+        "babel-plugin-polyfill-corejs3": "^0.14.0",
+        "babel-plugin-polyfill-regenerator": "^0.6.6",
+        "core-js-compat": "^3.48.0",
         "semver": "^6.3.1"
       },
       "engines": {
@@ -1968,18 +1805,22 @@
         "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@babel/preset-env/node_modules/semver": {
-      "version": "6.3.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
-      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
+    "node_modules/@babel/preset-env/node_modules/babel-plugin-polyfill-corejs3": {
+      "version": "0.14.2",
+      "resolved": "https://registry.facebook.net/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.14.2.tgz",
+      "integrity": "sha512-coWpDLJ410R781Npmn/SIBZEsAetR4xVi0SxLMXPaMO4lSf1MwnkGYMtkFxew0Dn8B3/CpbpYxN0JCgg8mn67g==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-define-polyfill-provider": "^0.6.8",
+        "core-js-compat": "^3.48.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
       }
     },
     "node_modules/@babel/preset-modules": {
       "version": "0.1.6-no-external-plugins",
-      "resolved": "https://registry.npmjs.org/@babel/preset-modules/-/preset-modules-0.1.6-no-external-plugins.tgz",
+      "resolved": "https://registry.facebook.net/@babel/preset-modules/-/preset-modules-0.1.6-no-external-plugins.tgz",
       "integrity": "sha512-HrcgcIESLm9aIR842yhJ5RWan/gebQUJ6E/E5+rf0y9o6oj7w0Br+sWuL6kEQ/o/AdfvR1Je9jG18/gnpwjEyA==",
       "license": "MIT",
       "dependencies": {
@@ -1992,17 +1833,17 @@
       }
     },
     "node_modules/@babel/preset-react": {
-      "version": "7.26.3",
-      "resolved": "https://registry.npmjs.org/@babel/preset-react/-/preset-react-7.26.3.tgz",
-      "integrity": "sha512-Nl03d6T9ky516DGK2YMxrTqvnpUW63TnJMOMonj+Zae0JiPC5BC9xPMSL6L8fiSpA5vP88qfygavVQvnLp+6Cw==",
+      "version": "7.28.5",
+      "resolved": "https://registry.facebook.net/@babel/preset-react/-/preset-react-7.28.5.tgz",
+      "integrity": "sha512-Z3J8vhRq7CeLjdC58jLv4lnZ5RKFUJWqH5emvxmv9Hv3BD1T9R/Im713R4MTKwvFaV74ejZ3sM01LyEKk4ugNQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9",
-        "@babel/helper-validator-option": "^7.25.9",
-        "@babel/plugin-transform-react-display-name": "^7.25.9",
-        "@babel/plugin-transform-react-jsx": "^7.25.9",
-        "@babel/plugin-transform-react-jsx-development": "^7.25.9",
-        "@babel/plugin-transform-react-pure-annotations": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1",
+        "@babel/helper-validator-option": "^7.27.1",
+        "@babel/plugin-transform-react-display-name": "^7.28.0",
+        "@babel/plugin-transform-react-jsx": "^7.27.1",
+        "@babel/plugin-transform-react-jsx-development": "^7.27.1",
+        "@babel/plugin-transform-react-pure-annotations": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -2012,16 +1853,16 @@
       }
     },
     "node_modules/@babel/preset-typescript": {
-      "version": "7.26.0",
-      "resolved": "https://registry.npmjs.org/@babel/preset-typescript/-/preset-typescript-7.26.0.tgz",
-      "integrity": "sha512-NMk1IGZ5I/oHhoXEElcm+xUnL/szL6xflkFZmoEU9xj1qSJXpiS7rsspYo92B4DRCDvZn2erT5LdsCeXAKNCkg==",
+      "version": "7.28.5",
+      "resolved": "https://registry.facebook.net/@babel/preset-typescript/-/preset-typescript-7.28.5.tgz",
+      "integrity": "sha512-+bQy5WOI2V6LJZpPVxY+yp66XdZ2yifu0Mc1aP5CQKgjn4QM5IN2i5fAZ4xKop47pr8rpVhiAeu+nDQa12C8+g==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.25.9",
-        "@babel/helper-validator-option": "^7.25.9",
-        "@babel/plugin-syntax-jsx": "^7.25.9",
-        "@babel/plugin-transform-modules-commonjs": "^7.25.9",
-        "@babel/plugin-transform-typescript": "^7.25.9"
+        "@babel/helper-plugin-utils": "^7.27.1",
+        "@babel/helper-validator-option": "^7.27.1",
+        "@babel/plugin-syntax-jsx": "^7.27.1",
+        "@babel/plugin-transform-modules-commonjs": "^7.27.1",
+        "@babel/plugin-transform-typescript": "^7.28.5"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -2031,70 +1872,54 @@
       }
     },
     "node_modules/@babel/runtime": {
-      "version": "7.26.0",
-      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.26.0.tgz",
-      "integrity": "sha512-FDSOghenHTiToteC/QRlv2q3DhPZ/oOXTBoirfWNx1Cx3TMVcGWQtMMmQcSvb/JjpNeGzx8Pq/b4fKEJuWm1sw==",
-      "license": "MIT",
-      "dependencies": {
-        "regenerator-runtime": "^0.14.0"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/runtime-corejs3": {
-      "version": "7.26.0",
-      "resolved": "https://registry.npmjs.org/@babel/runtime-corejs3/-/runtime-corejs3-7.26.0.tgz",
-      "integrity": "sha512-YXHu5lN8kJCb1LOb9PgV6pvak43X2h4HvRApcN5SdWeaItQOzfn1hgP6jasD6KWQyJDBxrVmA9o9OivlnNJK/w==",
+      "version": "7.29.2",
+      "resolved": "https://registry.facebook.net/@babel/runtime/-/runtime-7.29.2.tgz",
+      "integrity": "sha512-JiDShH45zKHWyGe4ZNVRrCjBz8Nh9TMmZG1kh4QTK8hCBTWBi8Da+i7s1fJw7/lYpM4ccepSNfqzZ/QvABBi5g==",
       "license": "MIT",
-      "dependencies": {
-        "core-js-pure": "^3.30.2",
-        "regenerator-runtime": "^0.14.0"
-      },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/template": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.25.9.tgz",
-      "integrity": "sha512-9DGttpmPvIxBb/2uwpVo3dqJ+O6RooAFOS+lB+xDqoE2PVCE8nfoHMdZLpfCQRLwvohzXISPZcgxt80xLfsuwg==",
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/template/-/template-7.28.6.tgz",
+      "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/code-frame": "^7.25.9",
-        "@babel/parser": "^7.25.9",
-        "@babel/types": "^7.25.9"
+        "@babel/code-frame": "^7.28.6",
+        "@babel/parser": "^7.28.6",
+        "@babel/types": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/traverse": {
-      "version": "7.26.4",
-      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.26.4.tgz",
-      "integrity": "sha512-fH+b7Y4p3yqvApJALCPJcwb0/XaOSgtK4pzV6WVjPR5GLFQBRI7pfoX2V2iM48NXvX07NUxxm1Vw98YjqTcU5w==",
+      "version": "7.29.0",
+      "resolved": "https://registry.facebook.net/@babel/traverse/-/traverse-7.29.0.tgz",
+      "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/code-frame": "^7.26.2",
-        "@babel/generator": "^7.26.3",
-        "@babel/parser": "^7.26.3",
-        "@babel/template": "^7.25.9",
-        "@babel/types": "^7.26.3",
-        "debug": "^4.3.1",
-        "globals": "^11.1.0"
+        "@babel/code-frame": "^7.29.0",
+        "@babel/generator": "^7.29.0",
+        "@babel/helper-globals": "^7.28.0",
+        "@babel/parser": "^7.29.0",
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.29.0",
+        "debug": "^4.3.1"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/types": {
-      "version": "7.26.3",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.26.3.tgz",
-      "integrity": "sha512-vN5p+1kl59GVKMvTHt55NzzmYVxprfJD+ql7U9NFIfKCBkYE55LYtS+WtPlaYOyzydrKI8Nezd+aZextrd+FMA==",
+      "version": "7.29.0",
+      "resolved": "https://registry.facebook.net/@babel/types/-/types-7.29.0.tgz",
+      "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-string-parser": "^7.25.9",
-        "@babel/helper-validator-identifier": "^7.25.9"
+        "@babel/helper-string-parser": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.28.5"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -2102,7 +1927,7 @@
     },
     "node_modules/@colors/colors": {
       "version": "1.5.0",
-      "resolved": "https://registry.npmjs.org/@colors/colors/-/colors-1.5.0.tgz",
+      "resolved": "https://registry.facebook.net/@colors/colors/-/colors-1.5.0.tgz",
       "integrity": "sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==",
       "license": "MIT",
       "optional": true,
@@ -2111,9 +1936,9 @@
       }
     },
     "node_modules/@csstools/cascade-layer-name-parser": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/@csstools/cascade-layer-name-parser/-/cascade-layer-name-parser-2.0.4.tgz",
-      "integrity": "sha512-7DFHlPuIxviKYZrOiwVU/PiHLm3lLUR23OMuEEtfEOQTOp9hzQ2JjdY6X5H18RVuUPJqSCI+qNnD5iOLMVE0bA==",
+      "version": "2.0.5",
+      "resolved": "https://registry.facebook.net/@csstools/cascade-layer-name-parser/-/cascade-layer-name-parser-2.0.5.tgz",
+      "integrity": "sha512-p1ko5eHgV+MgXFVa4STPKpvPxr6ReS8oS2jzTukjR74i5zJNyWO1ZM1m8YKBXnzDKWfBN1ztLYlHxbVemDD88A==",
       "funding": [
         {
           "type": "github",
@@ -2129,14 +1954,14 @@
         "node": ">=18"
       },
       "peerDependencies": {
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3"
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
       }
     },
     "node_modules/@csstools/color-helpers": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-5.0.1.tgz",
-      "integrity": "sha512-MKtmkA0BX87PKaO1NFRTFH+UnkgnmySQOvNxJubsadusqPEC2aJ9MOQiMceZJJ6oitUl/i0L6u0M1IrmAOmgBA==",
+      "version": "5.1.0",
+      "resolved": "https://registry.facebook.net/@csstools/color-helpers/-/color-helpers-5.1.0.tgz",
+      "integrity": "sha512-S11EXWJyy0Mz5SYvRmY8nJYTFFd1LCNV+7cXyAgQtOOuzb4EsgfqDufL+9esx72/eLhsRdGZwaldu/h+E4t4BA==",
       "funding": [
         {
           "type": "github",
@@ -2153,9 +1978,9 @@
       }
     },
     "node_modules/@csstools/css-calc": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-2.1.1.tgz",
-      "integrity": "sha512-rL7kaUnTkL9K+Cvo2pnCieqNpTKgQzy5f+N+5Iuko9HAoasP+xgprVh7KN/MaJVvVL1l0EzQq2MoqBHKSrDrag==",
+      "version": "2.1.4",
+      "resolved": "https://registry.facebook.net/@csstools/css-calc/-/css-calc-2.1.4.tgz",
+      "integrity": "sha512-3N8oaj+0juUw/1H3YwmDDJXCgTB1gKU6Hc/bB502u9zR0q2vd786XJH9QfrKIEgFlZmhZiq6epXl4rHqhzsIgQ==",
       "funding": [
         {
           "type": "github",
@@ -2171,14 +1996,14 @@
         "node": ">=18"
       },
       "peerDependencies": {
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3"
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
       }
     },
     "node_modules/@csstools/css-color-parser": {
-      "version": "3.0.7",
-      "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-3.0.7.tgz",
-      "integrity": "sha512-nkMp2mTICw32uE5NN+EsJ4f5N+IGFeCFu4bGpiKgb2Pq/7J/MpyLBeQ5ry4KKtRFZaYs6sTmcMYrSRIyj5DFKA==",
+      "version": "3.1.0",
+      "resolved": "https://registry.facebook.net/@csstools/css-color-parser/-/css-color-parser-3.1.0.tgz",
+      "integrity": "sha512-nbtKwh3a6xNVIp/VRuXV64yTKnb1IjTAEEh3irzS+HkKjAOYLTGNb9pmVNntZ8iVBHcWDA2Dof0QtPgFI1BaTA==",
       "funding": [
         {
           "type": "github",
@@ -2191,21 +2016,21 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "@csstools/color-helpers": "^5.0.1",
-        "@csstools/css-calc": "^2.1.1"
+        "@csstools/color-helpers": "^5.1.0",
+        "@csstools/css-calc": "^2.1.4"
       },
       "engines": {
         "node": ">=18"
       },
       "peerDependencies": {
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3"
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
       }
     },
     "node_modules/@csstools/css-parser-algorithms": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-3.0.4.tgz",
-      "integrity": "sha512-Up7rBoV77rv29d3uKHUIVubz1BTcgyUK72IvCQAbfbMv584xHcGKCKbWh7i8hPrRJ7qU4Y8IO3IY9m+iTB7P3A==",
+      "version": "3.0.5",
+      "resolved": "https://registry.facebook.net/@csstools/css-parser-algorithms/-/css-parser-algorithms-3.0.5.tgz",
+      "integrity": "sha512-DaDeUkXZKjdGhgYaHNJTV9pV7Y9B3b644jCLs9Upc3VeNGg6LWARAT6O+Q+/COo+2gg/bM5rhpMAtf70WqfBdQ==",
       "funding": [
         {
           "type": "github",
@@ -2221,13 +2046,13 @@
         "node": ">=18"
       },
       "peerDependencies": {
-        "@csstools/css-tokenizer": "^3.0.3"
+        "@csstools/css-tokenizer": "^3.0.4"
       }
     },
     "node_modules/@csstools/css-tokenizer": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/@csstools/css-tokenizer/-/css-tokenizer-3.0.3.tgz",
-      "integrity": "sha512-UJnjoFsmxfKUdNYdWgOB0mWUypuLvAfQPH1+pyvRJs6euowbFkFC6P13w1l8mJyi3vxYMxc9kld5jZEGRQs6bw==",
+      "version": "3.0.4",
+      "resolved": "https://registry.facebook.net/@csstools/css-tokenizer/-/css-tokenizer-3.0.4.tgz",
+      "integrity": "sha512-Vd/9EVDiu6PPJt9yAh6roZP6El1xHrdvIVGjyBsHR0RYwNHgL7FJPyIIW4fANJNG6FtyZfvlRPpFI4ZM/lubvw==",
       "funding": [
         {
           "type": "github",
@@ -2244,9 +2069,9 @@
       }
     },
     "node_modules/@csstools/media-query-list-parser": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/@csstools/media-query-list-parser/-/media-query-list-parser-4.0.2.tgz",
-      "integrity": "sha512-EUos465uvVvMJehckATTlNqGj4UJWkTmdWuDMjqvSUkjGpmOyFZBVwb4knxCm/k2GMTXY+c/5RkdndzFYWeX5A==",
+      "version": "4.0.3",
+      "resolved": "https://registry.facebook.net/@csstools/media-query-list-parser/-/media-query-list-parser-4.0.3.tgz",
+      "integrity": "sha512-HAYH7d3TLRHDOUQK4mZKf9k9Ph/m8Akstg66ywKR4SFAigjs3yBiUeZtFxywiTm5moZMAp/5W/ZuFnNXXYLuuQ==",
       "funding": [
         {
           "type": "github",
@@ -2262,14 +2087,14 @@
         "node": ">=18"
       },
       "peerDependencies": {
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3"
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
       }
     },
-    "node_modules/@csstools/postcss-cascade-layers": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-cascade-layers/-/postcss-cascade-layers-5.0.1.tgz",
-      "integrity": "sha512-XOfhI7GShVcKiKwmPAnWSqd2tBR0uxt+runAxttbSp/LY2U16yAVPmAf7e9q4JJ0d+xMNmpwNDLBXnmRCl3HMQ==",
+    "node_modules/@csstools/postcss-alpha-function": {
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-alpha-function/-/postcss-alpha-function-1.0.1.tgz",
+      "integrity": "sha512-isfLLwksH3yHkFXfCI2Gcaqg7wGGHZZwunoJzEZk0yKYIokgre6hYVFibKL3SYAoR1kBXova8LB+JoO5vZzi9w==",
       "funding": [
         {
           "type": "github",
@@ -2282,8 +2107,11 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/selector-specificity": "^5.0.0",
-        "postcss-selector-parser": "^7.0.0"
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/utilities": "^2.0.0"
       },
       "engines": {
         "node": ">=18"
@@ -2292,10 +2120,10 @@
         "postcss": "^8.4"
       }
     },
-    "node_modules/@csstools/postcss-cascade-layers/node_modules/@csstools/selector-specificity": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/@csstools/selector-specificity/-/selector-specificity-5.0.0.tgz",
-      "integrity": "sha512-PCqQV3c4CoVm3kdPhyeZ07VmBRdH2EpMFA/pd9OASpOEC3aXNGoqPDAZ80D0cLpMBxnmk0+yNhGsEx31hq7Gtw==",
+    "node_modules/@csstools/postcss-cascade-layers": {
+      "version": "5.0.2",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-cascade-layers/-/postcss-cascade-layers-5.0.2.tgz",
+      "integrity": "sha512-nWBE08nhO8uWl6kSAeCx4im7QfVko3zLrtgWZY4/bP87zrSPpSyN/3W3TDqz1jJuH+kbKOHXg5rJnK+ZVYcFFg==",
       "funding": [
         {
           "type": "github",
@@ -2307,30 +2135,21 @@
         }
       ],
       "license": "MIT-0",
+      "dependencies": {
+        "@csstools/selector-specificity": "^5.0.0",
+        "postcss-selector-parser": "^7.0.0"
+      },
       "engines": {
         "node": ">=18"
       },
       "peerDependencies": {
-        "postcss-selector-parser": "^7.0.0"
-      }
-    },
-    "node_modules/@csstools/postcss-cascade-layers/node_modules/postcss-selector-parser": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.0.0.tgz",
-      "integrity": "sha512-9RbEr1Y7FFfptd/1eEdntyjMwLeghW1bHX9GWjXo19vx4ytPQhANltvVxDggzJl7mnWM+dX28kb6cyS/4iQjlQ==",
-      "license": "MIT",
-      "dependencies": {
-        "cssesc": "^3.0.0",
-        "util-deprecate": "^1.0.2"
-      },
-      "engines": {
-        "node": ">=4"
+        "postcss": "^8.4"
       }
     },
     "node_modules/@csstools/postcss-color-function": {
-      "version": "4.0.7",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-color-function/-/postcss-color-function-4.0.7.tgz",
-      "integrity": "sha512-aDHYmhNIHR6iLw4ElWhf+tRqqaXwKnMl0YsQ/X105Zc4dQwe6yJpMrTN6BwOoESrkDjOYMOfORviSSLeDTJkdQ==",
+      "version": "4.0.12",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-color-function/-/postcss-color-function-4.0.12.tgz",
+      "integrity": "sha512-yx3cljQKRaSBc2hfh8rMZFZzChaFgwmO2JfFgFr1vMcF3C/uyy5I4RFIBOIWGq1D+XbKCG789CGkG6zzkLpagA==",
       "funding": [
         {
           "type": "github",
@@ -2343,10 +2162,10 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/css-color-parser": "^3.0.7",
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3",
-        "@csstools/postcss-progressive-custom-properties": "^4.0.0",
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
         "@csstools/utilities": "^2.0.0"
       },
       "engines": {
@@ -2356,10 +2175,10 @@
         "postcss": "^8.4"
       }
     },
-    "node_modules/@csstools/postcss-color-mix-function": {
-      "version": "3.0.7",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-color-mix-function/-/postcss-color-mix-function-3.0.7.tgz",
-      "integrity": "sha512-e68Nev4CxZYCLcrfWhHH4u/N1YocOfTmw67/kVX5Rb7rnguqqLyxPjhHWjSBX8o4bmyuukmNf3wrUSU3//kT7g==",
+    "node_modules/@csstools/postcss-color-function-display-p3-linear": {
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-color-function-display-p3-linear/-/postcss-color-function-display-p3-linear-1.0.1.tgz",
+      "integrity": "sha512-E5qusdzhlmO1TztYzDIi8XPdPoYOjoTY6HBYBCYSj+Gn4gQRBlvjgPQXzfzuPQqt8EhkC/SzPKObg4Mbn8/xMg==",
       "funding": [
         {
           "type": "github",
@@ -2372,10 +2191,10 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/css-color-parser": "^3.0.7",
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3",
-        "@csstools/postcss-progressive-custom-properties": "^4.0.0",
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
         "@csstools/utilities": "^2.0.0"
       },
       "engines": {
@@ -2385,10 +2204,10 @@
         "postcss": "^8.4"
       }
     },
-    "node_modules/@csstools/postcss-content-alt-text": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-content-alt-text/-/postcss-content-alt-text-2.0.4.tgz",
-      "integrity": "sha512-YItlZUOuZJCBlRaCf8Aucc1lgN41qYGALMly0qQllrxYJhiyzlI6RxOTMUvtWk+KhS8GphMDsDhKQ7KTPfEMSw==",
+    "node_modules/@csstools/postcss-color-mix-function": {
+      "version": "3.0.12",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-color-mix-function/-/postcss-color-mix-function-3.0.12.tgz",
+      "integrity": "sha512-4STERZfCP5Jcs13P1U5pTvI9SkgLgfMUMhdXW8IlJWkzOOOqhZIjcNhWtNJZes2nkBDsIKJ0CJtFtuaZ00moag==",
       "funding": [
         {
           "type": "github",
@@ -2401,9 +2220,10 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3",
-        "@csstools/postcss-progressive-custom-properties": "^4.0.0",
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
         "@csstools/utilities": "^2.0.0"
       },
       "engines": {
@@ -2413,10 +2233,10 @@
         "postcss": "^8.4"
       }
     },
-    "node_modules/@csstools/postcss-exponential-functions": {
-      "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-exponential-functions/-/postcss-exponential-functions-2.0.6.tgz",
-      "integrity": "sha512-IgJA5DQsQLu/upA3HcdvC6xEMR051ufebBTIXZ5E9/9iiaA7juXWz1ceYj814lnDYP/7eWjZnw0grRJlX4eI6g==",
+    "node_modules/@csstools/postcss-color-mix-variadic-function-arguments": {
+      "version": "1.0.2",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-color-mix-variadic-function-arguments/-/postcss-color-mix-variadic-function-arguments-1.0.2.tgz",
+      "integrity": "sha512-rM67Gp9lRAkTo+X31DUqMEq+iK+EFqsidfecmhrteErxJZb6tUoJBVQca1Vn1GpDql1s1rD1pKcuYzMsg7Z1KQ==",
       "funding": [
         {
           "type": "github",
@@ -2429,9 +2249,11 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/css-calc": "^2.1.1",
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3"
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/utilities": "^2.0.0"
       },
       "engines": {
         "node": ">=18"
@@ -2440,10 +2262,10 @@
         "postcss": "^8.4"
       }
     },
-    "node_modules/@csstools/postcss-font-format-keywords": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-font-format-keywords/-/postcss-font-format-keywords-4.0.0.tgz",
-      "integrity": "sha512-usBzw9aCRDvchpok6C+4TXC57btc4bJtmKQWOHQxOVKen1ZfVqBUuCZ/wuqdX5GHsD0NRSr9XTP+5ID1ZZQBXw==",
+    "node_modules/@csstools/postcss-content-alt-text": {
+      "version": "2.0.8",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-content-alt-text/-/postcss-content-alt-text-2.0.8.tgz",
+      "integrity": "sha512-9SfEW9QCxEpTlNMnpSqFaHyzsiRpZ5J5+KqCu1u5/eEJAWsMhzT40qf0FIbeeglEvrGRMdDzAxMIz3wqoGSb+Q==",
       "funding": [
         {
           "type": "github",
@@ -2456,8 +2278,10 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/utilities": "^2.0.0",
-        "postcss-value-parser": "^4.2.0"
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/utilities": "^2.0.0"
       },
       "engines": {
         "node": ">=18"
@@ -2466,10 +2290,10 @@
         "postcss": "^8.4"
       }
     },
-    "node_modules/@csstools/postcss-gamut-mapping": {
-      "version": "2.0.7",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-gamut-mapping/-/postcss-gamut-mapping-2.0.7.tgz",
-      "integrity": "sha512-gzFEZPoOkY0HqGdyeBXR3JP218Owr683u7KOZazTK7tQZBE8s2yhg06W1tshOqk7R7SWvw9gkw2TQogKpIW8Xw==",
+    "node_modules/@csstools/postcss-contrast-color-function": {
+      "version": "2.0.12",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-contrast-color-function/-/postcss-contrast-color-function-2.0.12.tgz",
+      "integrity": "sha512-YbwWckjK3qwKjeYz/CijgcS7WDUCtKTd8ShLztm3/i5dhh4NaqzsbYnhm4bjrpFpnLZ31jVcbK8YL77z3GBPzA==",
       "funding": [
         {
           "type": "github",
@@ -2482,9 +2306,11 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/css-color-parser": "^3.0.7",
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3"
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/utilities": "^2.0.0"
       },
       "engines": {
         "node": ">=18"
@@ -2493,10 +2319,10 @@
         "postcss": "^8.4"
       }
     },
-    "node_modules/@csstools/postcss-gradients-interpolation-method": {
-      "version": "5.0.7",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-gradients-interpolation-method/-/postcss-gradients-interpolation-method-5.0.7.tgz",
-      "integrity": "sha512-WgEyBeg6glUeTdS2XT7qeTFBthTJuXlS9GFro/DVomj7W7WMTamAwpoP4oQCq/0Ki2gvfRYFi/uZtmRE14/DFA==",
+    "node_modules/@csstools/postcss-exponential-functions": {
+      "version": "2.0.9",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-exponential-functions/-/postcss-exponential-functions-2.0.9.tgz",
+      "integrity": "sha512-abg2W/PI3HXwS/CZshSa79kNWNZHdJPMBXeZNyPQFbbj8sKO3jXxOt/wF7juJVjyDTc6JrvaUZYFcSBZBhaxjw==",
       "funding": [
         {
           "type": "github",
@@ -2509,11 +2335,9 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/css-color-parser": "^3.0.7",
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3",
-        "@csstools/postcss-progressive-custom-properties": "^4.0.0",
-        "@csstools/utilities": "^2.0.0"
+        "@csstools/css-calc": "^2.1.4",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
       },
       "engines": {
         "node": ">=18"
@@ -2522,10 +2346,10 @@
         "postcss": "^8.4"
       }
     },
-    "node_modules/@csstools/postcss-hwb-function": {
-      "version": "4.0.7",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-hwb-function/-/postcss-hwb-function-4.0.7.tgz",
-      "integrity": "sha512-LKYqjO+wGwDCfNIEllessCBWfR4MS/sS1WXO+j00KKyOjm7jDW2L6jzUmqASEiv/kkJO39GcoIOvTTfB3yeBUA==",
+    "node_modules/@csstools/postcss-font-format-keywords": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-font-format-keywords/-/postcss-font-format-keywords-4.0.0.tgz",
+      "integrity": "sha512-usBzw9aCRDvchpok6C+4TXC57btc4bJtmKQWOHQxOVKen1ZfVqBUuCZ/wuqdX5GHsD0NRSr9XTP+5ID1ZZQBXw==",
       "funding": [
         {
           "type": "github",
@@ -2538,11 +2362,8 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/css-color-parser": "^3.0.7",
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3",
-        "@csstools/postcss-progressive-custom-properties": "^4.0.0",
-        "@csstools/utilities": "^2.0.0"
+        "@csstools/utilities": "^2.0.0",
+        "postcss-value-parser": "^4.2.0"
       },
       "engines": {
         "node": ">=18"
@@ -2551,10 +2372,10 @@
         "postcss": "^8.4"
       }
     },
-    "node_modules/@csstools/postcss-ic-unit": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-ic-unit/-/postcss-ic-unit-4.0.0.tgz",
-      "integrity": "sha512-9QT5TDGgx7wD3EEMN3BSUG6ckb6Eh5gSPT5kZoVtUuAonfPmLDJyPhqR4ntPpMYhUKAMVKAg3I/AgzqHMSeLhA==",
+    "node_modules/@csstools/postcss-gamut-mapping": {
+      "version": "2.0.11",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-gamut-mapping/-/postcss-gamut-mapping-2.0.11.tgz",
+      "integrity": "sha512-fCpCUgZNE2piVJKC76zFsgVW1apF6dpYsqGyH8SIeCcM4pTEsRTWTLCaJIMKFEundsCKwY1rwfhtrio04RJ4Dw==",
       "funding": [
         {
           "type": "github",
@@ -2567,9 +2388,9 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/postcss-progressive-custom-properties": "^4.0.0",
-        "@csstools/utilities": "^2.0.0",
-        "postcss-value-parser": "^4.2.0"
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
       },
       "engines": {
         "node": ">=18"
@@ -2578,10 +2399,10 @@
         "postcss": "^8.4"
       }
     },
-    "node_modules/@csstools/postcss-initial": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-initial/-/postcss-initial-2.0.0.tgz",
-      "integrity": "sha512-dv2lNUKR+JV+OOhZm9paWzYBXOCi+rJPqJ2cJuhh9xd8USVrd0cBEPczla81HNOyThMQWeCcdln3gZkQV2kYxA==",
+    "node_modules/@csstools/postcss-gradients-interpolation-method": {
+      "version": "5.0.12",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-gradients-interpolation-method/-/postcss-gradients-interpolation-method-5.0.12.tgz",
+      "integrity": "sha512-jugzjwkUY0wtNrZlFeyXzimUL3hN4xMvoPnIXxoZqxDvjZRiSh+itgHcVUWzJ2VwD/VAMEgCLvtaJHX+4Vj3Ow==",
       "funding": [
         {
           "type": "github",
@@ -2593,6 +2414,13 @@
         }
       ],
       "license": "MIT-0",
+      "dependencies": {
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/utilities": "^2.0.0"
+      },
       "engines": {
         "node": ">=18"
       },
@@ -2600,10 +2428,10 @@
         "postcss": "^8.4"
       }
     },
-    "node_modules/@csstools/postcss-is-pseudo-class": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-is-pseudo-class/-/postcss-is-pseudo-class-5.0.1.tgz",
-      "integrity": "sha512-JLp3POui4S1auhDR0n8wHd/zTOWmMsmK3nQd3hhL6FhWPaox5W7j1se6zXOG/aP07wV2ww0lxbKYGwbBszOtfQ==",
+    "node_modules/@csstools/postcss-hwb-function": {
+      "version": "4.0.12",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-hwb-function/-/postcss-hwb-function-4.0.12.tgz",
+      "integrity": "sha512-mL/+88Z53KrE4JdePYFJAQWFrcADEqsLprExCM04GDNgHIztwFzj0Mbhd/yxMBngq0NIlz58VVxjt5abNs1VhA==",
       "funding": [
         {
           "type": "github",
@@ -2616,8 +2444,11 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/selector-specificity": "^5.0.0",
-        "postcss-selector-parser": "^7.0.0"
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/utilities": "^2.0.0"
       },
       "engines": {
         "node": ">=18"
@@ -2626,10 +2457,10 @@
         "postcss": "^8.4"
       }
     },
-    "node_modules/@csstools/postcss-is-pseudo-class/node_modules/@csstools/selector-specificity": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/@csstools/selector-specificity/-/selector-specificity-5.0.0.tgz",
-      "integrity": "sha512-PCqQV3c4CoVm3kdPhyeZ07VmBRdH2EpMFA/pd9OASpOEC3aXNGoqPDAZ80D0cLpMBxnmk0+yNhGsEx31hq7Gtw==",
+    "node_modules/@csstools/postcss-ic-unit": {
+      "version": "4.0.4",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-ic-unit/-/postcss-ic-unit-4.0.4.tgz",
+      "integrity": "sha512-yQ4VmossuOAql65sCPppVO1yfb7hDscf4GseF0VCA/DTDaBc0Wtf8MTqVPfjGYlT5+2buokG0Gp7y0atYZpwjg==",
       "funding": [
         {
           "type": "github",
@@ -2641,30 +2472,70 @@
         }
       ],
       "license": "MIT-0",
+      "dependencies": {
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/utilities": "^2.0.0",
+        "postcss-value-parser": "^4.2.0"
+      },
       "engines": {
         "node": ">=18"
       },
       "peerDependencies": {
-        "postcss-selector-parser": "^7.0.0"
+        "postcss": "^8.4"
       }
     },
-    "node_modules/@csstools/postcss-is-pseudo-class/node_modules/postcss-selector-parser": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.0.0.tgz",
-      "integrity": "sha512-9RbEr1Y7FFfptd/1eEdntyjMwLeghW1bHX9GWjXo19vx4ytPQhANltvVxDggzJl7mnWM+dX28kb6cyS/4iQjlQ==",
-      "license": "MIT",
+    "node_modules/@csstools/postcss-initial": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-initial/-/postcss-initial-2.0.1.tgz",
+      "integrity": "sha512-L1wLVMSAZ4wovznquK0xmC7QSctzO4D0Is590bxpGqhqjboLXYA16dWZpfwImkdOgACdQ9PqXsuRroW6qPlEsg==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "postcss": "^8.4"
+      }
+    },
+    "node_modules/@csstools/postcss-is-pseudo-class": {
+      "version": "5.0.3",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-is-pseudo-class/-/postcss-is-pseudo-class-5.0.3.tgz",
+      "integrity": "sha512-jS/TY4SpG4gszAtIg7Qnf3AS2pjcUM5SzxpApOrlndMeGhIbaTzWBzzP/IApXoNWEW7OhcjkRT48jnAUIFXhAQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
       "dependencies": {
-        "cssesc": "^3.0.0",
-        "util-deprecate": "^1.0.2"
+        "@csstools/selector-specificity": "^5.0.0",
+        "postcss-selector-parser": "^7.0.0"
       },
       "engines": {
-        "node": ">=4"
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "postcss": "^8.4"
       }
     },
     "node_modules/@csstools/postcss-light-dark-function": {
-      "version": "2.0.7",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-light-dark-function/-/postcss-light-dark-function-2.0.7.tgz",
-      "integrity": "sha512-ZZ0rwlanYKOHekyIPaU+sVm3BEHCe+Ha0/px+bmHe62n0Uc1lL34vbwrLYn6ote8PHlsqzKeTQdIejQCJ05tfw==",
+      "version": "2.0.11",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-light-dark-function/-/postcss-light-dark-function-2.0.11.tgz",
+      "integrity": "sha512-fNJcKXJdPM3Lyrbmgw2OBbaioU7yuKZtiXClf4sGdQttitijYlZMD5K7HrC/eF83VRWRrYq6OZ0Lx92leV2LFA==",
       "funding": [
         {
           "type": "github",
@@ -2677,9 +2548,9 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3",
-        "@csstools/postcss-progressive-custom-properties": "^4.0.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
         "@csstools/utilities": "^2.0.0"
       },
       "engines": {
@@ -2691,7 +2562,7 @@
     },
     "node_modules/@csstools/postcss-logical-float-and-clear": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-logical-float-and-clear/-/postcss-logical-float-and-clear-3.0.0.tgz",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-logical-float-and-clear/-/postcss-logical-float-and-clear-3.0.0.tgz",
       "integrity": "sha512-SEmaHMszwakI2rqKRJgE+8rpotFfne1ZS6bZqBoQIicFyV+xT1UF42eORPxJkVJVrH9C0ctUgwMSn3BLOIZldQ==",
       "funding": [
         {
@@ -2713,7 +2584,7 @@
     },
     "node_modules/@csstools/postcss-logical-overflow": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-logical-overflow/-/postcss-logical-overflow-2.0.0.tgz",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-logical-overflow/-/postcss-logical-overflow-2.0.0.tgz",
       "integrity": "sha512-spzR1MInxPuXKEX2csMamshR4LRaSZ3UXVaRGjeQxl70ySxOhMpP2252RAFsg8QyyBXBzuVOOdx1+bVO5bPIzA==",
       "funding": [
         {
@@ -2735,7 +2606,7 @@
     },
     "node_modules/@csstools/postcss-logical-overscroll-behavior": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-logical-overscroll-behavior/-/postcss-logical-overscroll-behavior-2.0.0.tgz",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-logical-overscroll-behavior/-/postcss-logical-overscroll-behavior-2.0.0.tgz",
       "integrity": "sha512-e/webMjoGOSYfqLunyzByZj5KKe5oyVg/YSbie99VEaSDE2kimFm0q1f6t/6Jo+VVCQ/jbe2Xy+uX+C4xzWs4w==",
       "funding": [
         {
@@ -2757,7 +2628,7 @@
     },
     "node_modules/@csstools/postcss-logical-resize": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-logical-resize/-/postcss-logical-resize-3.0.0.tgz",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-logical-resize/-/postcss-logical-resize-3.0.0.tgz",
       "integrity": "sha512-DFbHQOFW/+I+MY4Ycd/QN6Dg4Hcbb50elIJCfnwkRTCX05G11SwViI5BbBlg9iHRl4ytB7pmY5ieAFk3ws7yyg==",
       "funding": [
         {
@@ -2781,9 +2652,9 @@
       }
     },
     "node_modules/@csstools/postcss-logical-viewport-units": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-logical-viewport-units/-/postcss-logical-viewport-units-3.0.3.tgz",
-      "integrity": "sha512-OC1IlG/yoGJdi0Y+7duz/kU/beCwO+Gua01sD6GtOtLi7ByQUpcIqs7UE/xuRPay4cHgOMatWdnDdsIDjnWpPw==",
+      "version": "3.0.4",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-logical-viewport-units/-/postcss-logical-viewport-units-3.0.4.tgz",
+      "integrity": "sha512-q+eHV1haXA4w9xBwZLKjVKAWn3W2CMqmpNpZUk5kRprvSiBEGMgrNH3/sJZ8UA3JgyHaOt3jwT9uFa4wLX4EqQ==",
       "funding": [
         {
           "type": "github",
@@ -2796,7 +2667,7 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/css-tokenizer": "^3.0.3",
+        "@csstools/css-tokenizer": "^3.0.4",
         "@csstools/utilities": "^2.0.0"
       },
       "engines": {
@@ -2807,9 +2678,9 @@
       }
     },
     "node_modules/@csstools/postcss-media-minmax": {
-      "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-media-minmax/-/postcss-media-minmax-2.0.6.tgz",
-      "integrity": "sha512-J1+4Fr2W3pLZsfxkFazK+9kr96LhEYqoeBszLmFjb6AjYs+g9oDAw3J5oQignLKk3rC9XHW+ebPTZ9FaW5u5pg==",
+      "version": "2.0.9",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-media-minmax/-/postcss-media-minmax-2.0.9.tgz",
+      "integrity": "sha512-af9Qw3uS3JhYLnCbqtZ9crTvvkR+0Se+bBqSr7ykAnl9yKhk6895z9rf+2F4dClIDJWxgn0iZZ1PSdkhrbs2ig==",
       "funding": [
         {
           "type": "github",
@@ -2822,10 +2693,10 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "@csstools/css-calc": "^2.1.1",
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3",
-        "@csstools/media-query-list-parser": "^4.0.2"
+        "@csstools/css-calc": "^2.1.4",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/media-query-list-parser": "^4.0.3"
       },
       "engines": {
         "node": ">=18"
@@ -2835,9 +2706,9 @@
       }
     },
     "node_modules/@csstools/postcss-media-queries-aspect-ratio-number-values": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-media-queries-aspect-ratio-number-values/-/postcss-media-queries-aspect-ratio-number-values-3.0.4.tgz",
-      "integrity": "sha512-AnGjVslHMm5xw9keusQYvjVWvuS7KWK+OJagaG0+m9QnIjZsrysD2kJP/tr/UJIyYtMCtu8OkUd+Rajb4DqtIQ==",
+      "version": "3.0.5",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-media-queries-aspect-ratio-number-values/-/postcss-media-queries-aspect-ratio-number-values-3.0.5.tgz",
+      "integrity": "sha512-zhAe31xaaXOY2Px8IYfoVTB3wglbJUVigGphFLj6exb7cjZRH9A6adyE22XfFK3P2PzwRk0VDeTJmaxpluyrDg==",
       "funding": [
         {
           "type": "github",
@@ -2850,9 +2721,9 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3",
-        "@csstools/media-query-list-parser": "^4.0.2"
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/media-query-list-parser": "^4.0.3"
       },
       "engines": {
         "node": ">=18"
@@ -2863,7 +2734,7 @@
     },
     "node_modules/@csstools/postcss-nested-calc": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-nested-calc/-/postcss-nested-calc-4.0.0.tgz",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-nested-calc/-/postcss-nested-calc-4.0.0.tgz",
       "integrity": "sha512-jMYDdqrQQxE7k9+KjstC3NbsmC063n1FTPLCgCRS2/qHUbHM0mNy9pIn4QIiQGs9I/Bg98vMqw7mJXBxa0N88A==",
       "funding": [
         {
@@ -2888,9 +2759,9 @@
       }
     },
     "node_modules/@csstools/postcss-normalize-display-values": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-normalize-display-values/-/postcss-normalize-display-values-4.0.0.tgz",
-      "integrity": "sha512-HlEoG0IDRoHXzXnkV4in47dzsxdsjdz6+j7MLjaACABX2NfvjFS6XVAnpaDyGesz9gK2SC7MbNwdCHusObKJ9Q==",
+      "version": "4.0.1",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-normalize-display-values/-/postcss-normalize-display-values-4.0.1.tgz",
+      "integrity": "sha512-TQUGBuRvxdc7TgNSTevYqrL8oItxiwPDixk20qCB5me/W8uF7BPbhRrAvFuhEoywQp/woRsUZ6SJ+sU5idZAIA==",
       "funding": [
         {
           "type": "github",
@@ -2913,9 +2784,9 @@
       }
     },
     "node_modules/@csstools/postcss-oklab-function": {
-      "version": "4.0.7",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-oklab-function/-/postcss-oklab-function-4.0.7.tgz",
-      "integrity": "sha512-I6WFQIbEKG2IO3vhaMGZDkucbCaUSXMxvHNzDdnfsTCF5tc0UlV3Oe2AhamatQoKFjBi75dSEMrgWq3+RegsOQ==",
+      "version": "4.0.12",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-oklab-function/-/postcss-oklab-function-4.0.12.tgz",
+      "integrity": "sha512-HhlSmnE1NKBhXsTnNGjxvhryKtO7tJd1w42DKOGFD6jSHtYOrsJTQDKPMwvOfrzUAk8t7GcpIfRyM7ssqHpFjg==",
       "funding": [
         {
           "type": "github",
@@ -2928,10 +2799,10 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/css-color-parser": "^3.0.7",
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3",
-        "@csstools/postcss-progressive-custom-properties": "^4.0.0",
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
         "@csstools/utilities": "^2.0.0"
       },
       "engines": {
@@ -2941,10 +2812,32 @@
         "postcss": "^8.4"
       }
     },
+    "node_modules/@csstools/postcss-position-area-property": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-position-area-property/-/postcss-position-area-property-1.0.0.tgz",
+      "integrity": "sha512-fUP6KR8qV2NuUZV3Cw8itx0Ep90aRjAZxAEzC3vrl6yjFv+pFsQbR18UuQctEKmA72K9O27CoYiKEgXxkqjg8Q==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "postcss": "^8.4"
+      }
+    },
     "node_modules/@csstools/postcss-progressive-custom-properties": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-progressive-custom-properties/-/postcss-progressive-custom-properties-4.0.0.tgz",
-      "integrity": "sha512-XQPtROaQjomnvLUSy/bALTR5VCtTVUFwYs1SblvYgLSeTo2a/bMNwUwo2piXw5rTv/FEYiy5yPSXBqg9OKUx7Q==",
+      "version": "4.2.1",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-progressive-custom-properties/-/postcss-progressive-custom-properties-4.2.1.tgz",
+      "integrity": "sha512-uPiiXf7IEKtUQXsxu6uWtOlRMXd2QWWy5fhxHDnPdXKCQckPP3E34ZgDoZ62r2iT+UOgWsSbM4NvHE5m3mAEdw==",
       "funding": [
         {
           "type": "github",
@@ -2966,10 +2859,36 @@
         "postcss": "^8.4"
       }
     },
+    "node_modules/@csstools/postcss-property-rule-prelude-list": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-property-rule-prelude-list/-/postcss-property-rule-prelude-list-1.0.0.tgz",
+      "integrity": "sha512-IxuQjUXq19fobgmSSvUDO7fVwijDJaZMvWQugxfEUxmjBeDCVaDuMpsZ31MsTm5xbnhA+ElDi0+rQ7sQQGisFA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "dependencies": {
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "postcss": "^8.4"
+      }
+    },
     "node_modules/@csstools/postcss-random-function": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-random-function/-/postcss-random-function-1.0.2.tgz",
-      "integrity": "sha512-vBCT6JvgdEkvRc91NFoNrLjgGtkLWt47GKT6E2UDn3nd8ZkMBiziQ1Md1OiKoSsgzxsSnGKG3RVdhlbdZEkHjA==",
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-random-function/-/postcss-random-function-2.0.1.tgz",
+      "integrity": "sha512-q+FQaNiRBhnoSNo+GzqGOIBKoHQ43lYz0ICrV+UudfWnEF6ksS6DsBIJSISKQT2Bvu3g4k6r7t0zYrk5pDlo8w==",
       "funding": [
         {
           "type": "github",
@@ -2982,9 +2901,9 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/css-calc": "^2.1.1",
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3"
+        "@csstools/css-calc": "^2.1.4",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
       },
       "engines": {
         "node": ">=18"
@@ -2994,9 +2913,9 @@
       }
     },
     "node_modules/@csstools/postcss-relative-color-syntax": {
-      "version": "3.0.7",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-relative-color-syntax/-/postcss-relative-color-syntax-3.0.7.tgz",
-      "integrity": "sha512-apbT31vsJVd18MabfPOnE977xgct5B1I+Jpf+Munw3n6kKb1MMuUmGGH+PT9Hm/fFs6fe61Q/EWnkrb4bNoNQw==",
+      "version": "3.0.12",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-relative-color-syntax/-/postcss-relative-color-syntax-3.0.12.tgz",
+      "integrity": "sha512-0RLIeONxu/mtxRtf3o41Lq2ghLimw0w9ByLWnnEVuy89exmEEq8bynveBxNW3nyHqLAFEeNtVEmC1QK9MZ8Huw==",
       "funding": [
         {
           "type": "github",
@@ -3009,10 +2928,10 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/css-color-parser": "^3.0.7",
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3",
-        "@csstools/postcss-progressive-custom-properties": "^4.0.0",
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
         "@csstools/utilities": "^2.0.0"
       },
       "engines": {
@@ -3024,7 +2943,7 @@
     },
     "node_modules/@csstools/postcss-scope-pseudo-class": {
       "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-scope-pseudo-class/-/postcss-scope-pseudo-class-4.0.1.tgz",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-scope-pseudo-class/-/postcss-scope-pseudo-class-4.0.1.tgz",
       "integrity": "sha512-IMi9FwtH6LMNuLea1bjVMQAsUhFxJnyLSgOp/cpv5hrzWmrUYU5fm0EguNDIIOHUqzXode8F/1qkC/tEo/qN8Q==",
       "funding": [
         {
@@ -3047,23 +2966,37 @@
         "postcss": "^8.4"
       }
     },
-    "node_modules/@csstools/postcss-scope-pseudo-class/node_modules/postcss-selector-parser": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.0.0.tgz",
-      "integrity": "sha512-9RbEr1Y7FFfptd/1eEdntyjMwLeghW1bHX9GWjXo19vx4ytPQhANltvVxDggzJl7mnWM+dX28kb6cyS/4iQjlQ==",
-      "license": "MIT",
+    "node_modules/@csstools/postcss-sign-functions": {
+      "version": "1.1.4",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-sign-functions/-/postcss-sign-functions-1.1.4.tgz",
+      "integrity": "sha512-P97h1XqRPcfcJndFdG95Gv/6ZzxUBBISem0IDqPZ7WMvc/wlO+yU0c5D/OCpZ5TJoTt63Ok3knGk64N+o6L2Pg==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
       "dependencies": {
-        "cssesc": "^3.0.0",
-        "util-deprecate": "^1.0.2"
+        "@csstools/css-calc": "^2.1.4",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
       },
       "engines": {
-        "node": ">=4"
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "postcss": "^8.4"
       }
     },
-    "node_modules/@csstools/postcss-sign-functions": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-sign-functions/-/postcss-sign-functions-1.1.1.tgz",
-      "integrity": "sha512-MslYkZCeMQDxetNkfmmQYgKCy4c+w9pPDfgOBCJOo/RI1RveEUdZQYtOfrC6cIZB7sD7/PHr2VGOcMXlZawrnA==",
+    "node_modules/@csstools/postcss-stepped-value-functions": {
+      "version": "4.0.9",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-stepped-value-functions/-/postcss-stepped-value-functions-4.0.9.tgz",
+      "integrity": "sha512-h9btycWrsex4dNLeQfyU3y3w40LMQooJWFMm/SK9lrKguHDcFl4VMkncKKoXi2z5rM9YGWbUQABI8BT2UydIcA==",
       "funding": [
         {
           "type": "github",
@@ -3076,9 +3009,9 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/css-calc": "^2.1.1",
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3"
+        "@csstools/css-calc": "^2.1.4",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
       },
       "engines": {
         "node": ">=18"
@@ -3087,10 +3020,35 @@
         "postcss": "^8.4"
       }
     },
-    "node_modules/@csstools/postcss-stepped-value-functions": {
-      "version": "4.0.6",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-stepped-value-functions/-/postcss-stepped-value-functions-4.0.6.tgz",
-      "integrity": "sha512-/dwlO9w8vfKgiADxpxUbZOWlL5zKoRIsCymYoh1IPuBsXODKanKnfuZRr32DEqT0//3Av1VjfNZU9yhxtEfIeA==",
+    "node_modules/@csstools/postcss-syntax-descriptor-syntax-production": {
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-syntax-descriptor-syntax-production/-/postcss-syntax-descriptor-syntax-production-1.0.1.tgz",
+      "integrity": "sha512-GneqQWefjM//f4hJ/Kbox0C6f2T7+pi4/fqTqOFGTL3EjnvOReTqO1qUQ30CaUjkwjYq9qZ41hzarrAxCc4gow==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "dependencies": {
+        "@csstools/css-tokenizer": "^3.0.4"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "postcss": "^8.4"
+      }
+    },
+    "node_modules/@csstools/postcss-system-ui-font-family": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-system-ui-font-family/-/postcss-system-ui-font-family-1.0.0.tgz",
+      "integrity": "sha512-s3xdBvfWYfoPSBsikDXbuorcMG1nN1M6GdU0qBsGfcmNR0A/qhloQZpTxjA3Xsyrk1VJvwb2pOfiOT3at/DuIQ==",
       "funding": [
         {
           "type": "github",
@@ -3103,9 +3061,8 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/css-calc": "^2.1.1",
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3"
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
       },
       "engines": {
         "node": ">=18"
@@ -3115,9 +3072,9 @@
       }
     },
     "node_modules/@csstools/postcss-text-decoration-shorthand": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-text-decoration-shorthand/-/postcss-text-decoration-shorthand-4.0.1.tgz",
-      "integrity": "sha512-xPZIikbx6jyzWvhms27uugIc0I4ykH4keRvoa3rxX5K7lEhkbd54rjj/dv60qOCTisoS+3bmwJTeyV1VNBrXaw==",
+      "version": "4.0.3",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-text-decoration-shorthand/-/postcss-text-decoration-shorthand-4.0.3.tgz",
+      "integrity": "sha512-KSkGgZfx0kQjRIYnpsD7X2Om9BUXX/Kii77VBifQW9Ih929hK0KNjVngHDH0bFB9GmfWcR9vJYJJRvw/NQjkrA==",
       "funding": [
         {
           "type": "github",
@@ -3130,7 +3087,7 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/color-helpers": "^5.0.1",
+        "@csstools/color-helpers": "^5.1.0",
         "postcss-value-parser": "^4.2.0"
       },
       "engines": {
@@ -3141,9 +3098,9 @@
       }
     },
     "node_modules/@csstools/postcss-trigonometric-functions": {
-      "version": "4.0.6",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-trigonometric-functions/-/postcss-trigonometric-functions-4.0.6.tgz",
-      "integrity": "sha512-c4Y1D2Why/PeccaSouXnTt6WcNHJkoJRidV2VW9s5gJ97cNxnLgQ4Qj8qOqkIR9VmTQKJyNcbF4hy79ZQnWD7A==",
+      "version": "4.0.9",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-trigonometric-functions/-/postcss-trigonometric-functions-4.0.9.tgz",
+      "integrity": "sha512-Hnh5zJUdpNrJqK9v1/E3BbrQhaDTj5YiX7P61TOvUhoDHnUmsNNxcDAgkQ32RrcWx9GVUvfUNPcUkn8R3vIX6A==",
       "funding": [
         {
           "type": "github",
@@ -3156,9 +3113,9 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/css-calc": "^2.1.1",
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3"
+        "@csstools/css-calc": "^2.1.4",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
       },
       "engines": {
         "node": ">=18"
@@ -3169,7 +3126,7 @@
     },
     "node_modules/@csstools/postcss-unset-value": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/@csstools/postcss-unset-value/-/postcss-unset-value-4.0.0.tgz",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-unset-value/-/postcss-unset-value-4.0.0.tgz",
       "integrity": "sha512-cBz3tOCI5Fw6NIFEwU3RiwK6mn3nKegjpJuzCndoGq3BZPkUjnsq7uQmIeMNeMbMk7YD2MfKcgCpZwX5jyXqCA==",
       "funding": [
         {
@@ -3189,9 +3146,53 @@
         "postcss": "^8.4"
       }
     },
+    "node_modules/@csstools/selector-resolve-nested": {
+      "version": "3.1.0",
+      "resolved": "https://registry.facebook.net/@csstools/selector-resolve-nested/-/selector-resolve-nested-3.1.0.tgz",
+      "integrity": "sha512-mf1LEW0tJLKfWyvn5KdDrhpxHyuxpbNwTIwOYLIvsTffeyOf85j5oIzfG0yosxDgx/sswlqBnESYUcQH0vgZ0g==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "postcss-selector-parser": "^7.0.0"
+      }
+    },
+    "node_modules/@csstools/selector-specificity": {
+      "version": "5.0.0",
+      "resolved": "https://registry.facebook.net/@csstools/selector-specificity/-/selector-specificity-5.0.0.tgz",
+      "integrity": "sha512-PCqQV3c4CoVm3kdPhyeZ07VmBRdH2EpMFA/pd9OASpOEC3aXNGoqPDAZ80D0cLpMBxnmk0+yNhGsEx31hq7Gtw==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "postcss-selector-parser": "^7.0.0"
+      }
+    },
     "node_modules/@csstools/utilities": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/@csstools/utilities/-/utilities-2.0.0.tgz",
+      "resolved": "https://registry.facebook.net/@csstools/utilities/-/utilities-2.0.0.tgz",
       "integrity": "sha512-5VdOr0Z71u+Yp3ozOx8T11N703wIFGVRgOWbOZMKgglPJsWA54MRIoMNVMa7shUToIhx5J8vX4sOZgD2XiihiQ==",
       "funding": [
         {
@@ -3213,34 +3214,55 @@
     },
     "node_modules/@discoveryjs/json-ext": {
       "version": "0.5.7",
-      "resolved": "https://registry.npmjs.org/@discoveryjs/json-ext/-/json-ext-0.5.7.tgz",
+      "resolved": "https://registry.facebook.net/@discoveryjs/json-ext/-/json-ext-0.5.7.tgz",
       "integrity": "sha512-dBVuXR082gk3jsFp7Rd/JI4kytwGHecnCoTtXFb7DB6CNHp4rg5k1bhg0nWdLGLnOV71lmDzGQaLMy8iPLY0pw==",
       "license": "MIT",
       "engines": {
         "node": ">=10.0.0"
       }
     },
+    "node_modules/@docsearch/core": {
+      "version": "4.6.3",
+      "resolved": "https://registry.facebook.net/@docsearch/core/-/core-4.6.3.tgz",
+      "integrity": "sha512-rUOujwIpxJRgD7+kicVsI3D5sqBvdiRTquzWBpTEXZs8ZXfGbfzpus5HqumaNYTppN2HvH8E2yNuRwYdHJeOlA==",
+      "license": "MIT",
+      "peerDependencies": {
+        "@types/react": ">= 16.8.0 < 20.0.0",
+        "react": ">= 16.8.0 < 20.0.0",
+        "react-dom": ">= 16.8.0 < 20.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "react": {
+          "optional": true
+        },
+        "react-dom": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/@docsearch/css": {
-      "version": "3.8.2",
-      "resolved": "https://registry.npmjs.org/@docsearch/css/-/css-3.8.2.tgz",
-      "integrity": "sha512-y05ayQFyUmCXze79+56v/4HpycYF3uFqB78pLPrSV5ZKAlDuIAAJNhaRi8tTdRNXh05yxX/TyNnzD6LwSM89vQ==",
+      "version": "4.6.3",
+      "resolved": "https://registry.facebook.net/@docsearch/css/-/css-4.6.3.tgz",
+      "integrity": "sha512-nlOwcXcsNAptQl4vlL4MA78qNJKO0Qlds5GuBjCoePgkebTXLSf8Qt1oyZ3YBshYupKXG9VRGEsk1zr23d+bzQ==",
       "license": "MIT"
     },
     "node_modules/@docsearch/react": {
-      "version": "3.8.2",
-      "resolved": "https://registry.npmjs.org/@docsearch/react/-/react-3.8.2.tgz",
-      "integrity": "sha512-xCRrJQlTt8N9GU0DG4ptwHRkfnSnD/YpdeaXe02iKfqs97TkZJv60yE+1eq/tjPcVnTW8dP5qLP7itifFVV5eg==",
+      "version": "4.6.3",
+      "resolved": "https://registry.facebook.net/@docsearch/react/-/react-4.6.3.tgz",
+      "integrity": "sha512-Bg2wdDsoQVlNCcEKuEJAU04tvHCqgx8rIu+uIoM4pRtcx3TBKJuXutJik3LTA8LRc9YEyHkrYUrmcC0D7BYf+g==",
       "license": "MIT",
       "dependencies": {
-        "@algolia/autocomplete-core": "1.17.7",
-        "@algolia/autocomplete-preset-algolia": "1.17.7",
-        "@docsearch/css": "3.8.2",
-        "algoliasearch": "^5.14.2"
+        "@algolia/autocomplete-core": "1.19.2",
+        "@docsearch/core": "4.6.3",
+        "@docsearch/css": "4.6.3"
       },
       "peerDependencies": {
-        "@types/react": ">= 16.8.0 < 19.0.0",
-        "react": ">= 16.8.0 < 19.0.0",
-        "react-dom": ">= 16.8.0 < 19.0.0",
+        "@types/react": ">= 16.8.0 < 20.0.0",
+        "react": ">= 16.8.0 < 20.0.0",
+        "react-dom": ">= 16.8.0 < 20.0.0",
         "search-insights": ">= 1 < 3"
       },
       "peerDependenciesMeta": {
@@ -3258,79 +3280,32 @@
         }
       }
     },
-    "node_modules/@docsearch/react/node_modules/@algolia/client-analytics": {
-      "version": "5.18.0",
-      "resolved": "https://registry.npmjs.org/@algolia/client-analytics/-/client-analytics-5.18.0.tgz",
-      "integrity": "sha512-0VpGG2uQW+h2aejxbG8VbnMCQ9ary9/ot7OASXi6OjE0SRkYQ/+pkW+q09+IScif3pmsVVYggmlMPtAsmYWHng==",
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/client-common": "5.18.0",
-        "@algolia/requester-browser-xhr": "5.18.0",
-        "@algolia/requester-fetch": "5.18.0",
-        "@algolia/requester-node-http": "5.18.0"
-      },
-      "engines": {
-        "node": ">= 14.0.0"
-      }
-    },
-    "node_modules/@docsearch/react/node_modules/@algolia/client-personalization": {
-      "version": "5.18.0",
-      "resolved": "https://registry.npmjs.org/@algolia/client-personalization/-/client-personalization-5.18.0.tgz",
-      "integrity": "sha512-I2dc94Oiwic3SEbrRp8kvTZtYpJjGtg5y5XnqubgnA15AgX59YIY8frKsFG8SOH1n2rIhUClcuDkxYQNXJLg+w==",
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/client-common": "5.18.0",
-        "@algolia/requester-browser-xhr": "5.18.0",
-        "@algolia/requester-fetch": "5.18.0",
-        "@algolia/requester-node-http": "5.18.0"
-      },
-      "engines": {
-        "node": ">= 14.0.0"
-      }
-    },
-    "node_modules/@docsearch/react/node_modules/@algolia/recommend": {
-      "version": "5.18.0",
-      "resolved": "https://registry.npmjs.org/@algolia/recommend/-/recommend-5.18.0.tgz",
-      "integrity": "sha512-uSnkm0cdAuFwdMp4pGT5vHVQ84T6AYpTZ3I0b3k/M3wg4zXDhl3aCiY8NzokEyRLezz/kHLEEcgb/tTTobOYVw==",
+    "node_modules/@docsearch/react/node_modules/@algolia/autocomplete-core": {
+      "version": "1.19.2",
+      "resolved": "https://registry.facebook.net/@algolia/autocomplete-core/-/autocomplete-core-1.19.2.tgz",
+      "integrity": "sha512-mKv7RyuAzXvwmq+0XRK8HqZXt9iZ5Kkm2huLjgn5JoCPtDy+oh9yxUMfDDaVCw0oyzZ1isdJBc7l9nuCyyR7Nw==",
       "license": "MIT",
       "dependencies": {
-        "@algolia/client-common": "5.18.0",
-        "@algolia/requester-browser-xhr": "5.18.0",
-        "@algolia/requester-fetch": "5.18.0",
-        "@algolia/requester-node-http": "5.18.0"
-      },
-      "engines": {
-        "node": ">= 14.0.0"
+        "@algolia/autocomplete-plugin-algolia-insights": "1.19.2",
+        "@algolia/autocomplete-shared": "1.19.2"
       }
     },
-    "node_modules/@docsearch/react/node_modules/algoliasearch": {
-      "version": "5.18.0",
-      "resolved": "https://registry.npmjs.org/algoliasearch/-/algoliasearch-5.18.0.tgz",
-      "integrity": "sha512-/tfpK2A4FpS0o+S78o3YSdlqXr0MavJIDlFK3XZrlXLy7vaRXJvW5jYg3v5e/wCaF8y0IpMjkYLhoV6QqfpOgw==",
+    "node_modules/@docsearch/react/node_modules/@algolia/autocomplete-plugin-algolia-insights": {
+      "version": "1.19.2",
+      "resolved": "https://registry.facebook.net/@algolia/autocomplete-plugin-algolia-insights/-/autocomplete-plugin-algolia-insights-1.19.2.tgz",
+      "integrity": "sha512-TjxbcC/r4vwmnZaPwrHtkXNeqvlpdyR+oR9Wi2XyfORkiGkLTVhX2j+O9SaCCINbKoDfc+c2PB8NjfOnz7+oKg==",
       "license": "MIT",
       "dependencies": {
-        "@algolia/client-abtesting": "5.18.0",
-        "@algolia/client-analytics": "5.18.0",
-        "@algolia/client-common": "5.18.0",
-        "@algolia/client-insights": "5.18.0",
-        "@algolia/client-personalization": "5.18.0",
-        "@algolia/client-query-suggestions": "5.18.0",
-        "@algolia/client-search": "5.18.0",
-        "@algolia/ingestion": "1.18.0",
-        "@algolia/monitoring": "1.18.0",
-        "@algolia/recommend": "5.18.0",
-        "@algolia/requester-browser-xhr": "5.18.0",
-        "@algolia/requester-fetch": "5.18.0",
-        "@algolia/requester-node-http": "5.18.0"
+        "@algolia/autocomplete-shared": "1.19.2"
       },
-      "engines": {
-        "node": ">= 14.0.0"
+      "peerDependencies": {
+        "search-insights": ">= 1 < 3"
       }
     },
     "node_modules/@docusaurus/babel": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/babel/-/babel-3.6.3.tgz",
-      "integrity": "sha512-7dW9Hat9EHYCVicFXYA4hjxBY38+hPuCURL8oRF9fySRm7vzNWuEOghA1TXcykuXZp0HLG2td4RhDxCvGG7tNw==",
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/babel/-/babel-3.10.0.tgz",
+      "integrity": "sha512-mqCJhCZNZUDg0zgDEaPTM4DnRsisa24HdqTy/qn/MQlbwhTb4WVaZg6ZyX6yIVKqTz8fS1hBMgM+98z+BeJJDg==",
       "license": "MIT",
       "dependencies": {
         "@babel/core": "^7.25.9",
@@ -3341,44 +3316,42 @@
         "@babel/preset-react": "^7.25.9",
         "@babel/preset-typescript": "^7.25.9",
         "@babel/runtime": "^7.25.9",
-        "@babel/runtime-corejs3": "^7.25.9",
         "@babel/traverse": "^7.25.9",
-        "@docusaurus/logger": "3.6.3",
-        "@docusaurus/utils": "3.6.3",
+        "@docusaurus/logger": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
         "babel-plugin-dynamic-import-node": "^2.3.3",
         "fs-extra": "^11.1.1",
         "tslib": "^2.6.0"
       },
       "engines": {
-        "node": ">=18.0"
+        "node": ">=20.0"
       }
     },
     "node_modules/@docusaurus/bundler": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/bundler/-/bundler-3.6.3.tgz",
-      "integrity": "sha512-47JLuc8D4wA+6VOvmMd5fUC9rFppBQpQOnxDYiVXffm/DeV/wmm3sbpNd5Y+O+G2+nevLTRnvCm/qyancv0Y3A==",
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/bundler/-/bundler-3.10.0.tgz",
+      "integrity": "sha512-iONUGZGgp+lAkw/cJZH6irONcF4p8+278IsdRlq8lYhxGjkoNUs0w7F4gVXBYSNChq5KG5/JleTSsdJySShxow==",
       "license": "MIT",
       "dependencies": {
         "@babel/core": "^7.25.9",
-        "@docusaurus/babel": "3.6.3",
-        "@docusaurus/cssnano-preset": "3.6.3",
-        "@docusaurus/logger": "3.6.3",
-        "@docusaurus/types": "3.6.3",
-        "@docusaurus/utils": "3.6.3",
+        "@docusaurus/babel": "3.10.0",
+        "@docusaurus/cssnano-preset": "3.10.0",
+        "@docusaurus/logger": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
         "babel-loader": "^9.2.1",
-        "clean-css": "^5.3.2",
+        "clean-css": "^5.3.3",
         "copy-webpack-plugin": "^11.0.0",
-        "css-loader": "^6.8.1",
+        "css-loader": "^6.11.0",
         "css-minimizer-webpack-plugin": "^5.0.1",
         "cssnano": "^6.1.2",
         "file-loader": "^6.2.0",
         "html-minifier-terser": "^7.2.0",
-        "mini-css-extract-plugin": "^2.9.1",
+        "mini-css-extract-plugin": "^2.9.2",
         "null-loader": "^4.0.1",
-        "postcss": "^8.4.26",
-        "postcss-loader": "^7.3.3",
-        "postcss-preset-env": "^10.1.0",
-        "react-dev-utils": "^12.0.1",
+        "postcss": "^8.5.4",
+        "postcss-loader": "^7.3.4",
+        "postcss-preset-env": "^10.2.1",
         "terser-webpack-plugin": "^5.3.9",
         "tslib": "^2.6.0",
         "url-loader": "^4.1.1",
@@ -3386,7 +3359,7 @@
         "webpackbar": "^6.0.1"
       },
       "engines": {
-        "node": ">=18.0"
+        "node": ">=20.0"
       },
       "peerDependencies": {
         "@docusaurus/faster": "*"
@@ -3397,112 +3370,226 @@
         }
       }
     },
-    "node_modules/@docusaurus/core": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/core/-/core-3.6.3.tgz",
-      "integrity": "sha512-xL7FRY9Jr5DWqB6pEnqgKqcMPJOX5V0pgWXi5lCiih11sUBmcFKM7c3+GyxcVeeWFxyYSDP3grLTWqJoP4P9Vw==",
-      "license": "MIT",
-      "dependencies": {
-        "@docusaurus/babel": "3.6.3",
-        "@docusaurus/bundler": "3.6.3",
-        "@docusaurus/logger": "3.6.3",
-        "@docusaurus/mdx-loader": "3.6.3",
-        "@docusaurus/utils": "3.6.3",
-        "@docusaurus/utils-common": "3.6.3",
-        "@docusaurus/utils-validation": "3.6.3",
-        "boxen": "^6.2.1",
-        "chalk": "^4.1.2",
-        "chokidar": "^3.5.3",
-        "cli-table3": "^0.6.3",
-        "combine-promises": "^1.1.0",
-        "commander": "^5.1.0",
-        "core-js": "^3.31.1",
-        "del": "^6.1.1",
-        "detect-port": "^1.5.1",
-        "escape-html": "^1.0.3",
-        "eta": "^2.2.0",
-        "eval": "^0.1.8",
+    "node_modules/@docusaurus/bundler/node_modules/commander": {
+      "version": "10.0.1",
+      "resolved": "https://registry.facebook.net/commander/-/commander-10.0.1.tgz",
+      "integrity": "sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@docusaurus/bundler/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="
+    },
+    "node_modules/@docusaurus/bundler/node_modules/html-minifier-terser": {
+      "version": "7.2.0",
+      "resolved": "https://registry.facebook.net/html-minifier-terser/-/html-minifier-terser-7.2.0.tgz",
+      "integrity": "sha512-tXgn3QfqPIpGl9o+K5tpcj3/MN4SfLtsx2GWwBC3SSd0tXQGyF3gsSqad8loJgKZGM3ZxbYDd5yhiBIdWpmvLA==",
+      "license": "MIT",
+      "dependencies": {
+        "camel-case": "^4.1.2",
+        "clean-css": "~5.3.2",
+        "commander": "^10.0.0",
+        "entities": "^4.4.0",
+        "param-case": "^3.0.4",
+        "relateurl": "^0.2.7",
+        "terser": "^5.15.1"
+      },
+      "bin": {
+        "html-minifier-terser": "cli.js"
+      },
+      "engines": {
+        "node": "^14.13.1 || >=16.0.0"
+      }
+    },
+    "node_modules/@docusaurus/bundler/node_modules/markdown-table": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-2.0.0.tgz",
+      "integrity": "sha512-Ezda85ToJUBhM6WGaG6veasyym+Tbs3cMAw/ZhOPqXiYsr0jgocBV3j3nx+4lk47plLlIqjwuTm/ywVI+zjJ/A==",
+      "dependencies": {
+        "repeat-string": "^1.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/@docusaurus/bundler/node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/@docusaurus/bundler/node_modules/webpackbar": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/webpackbar/-/webpackbar-6.0.1.tgz",
+      "integrity": "sha512-TnErZpmuKdwWBdMoexjio3KKX6ZtoKHRVvLIU0A47R0VVBDtx3ZyOJDktgYixhoJokZTYTt1Z37OkO9pnGJa9Q==",
+      "dependencies": {
+        "ansi-escapes": "^4.3.2",
+        "chalk": "^4.1.2",
+        "consola": "^3.2.3",
+        "figures": "^3.2.0",
+        "markdown-table": "^2.0.0",
+        "pretty-time": "^1.1.0",
+        "std-env": "^3.7.0",
+        "wrap-ansi": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=14.21.3"
+      },
+      "peerDependencies": {
+        "webpack": "3 || 4 || 5"
+      }
+    },
+    "node_modules/@docusaurus/bundler/node_modules/wrap-ansi": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/@docusaurus/core": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/core/-/core-3.10.0.tgz",
+      "integrity": "sha512-mgLdQsO8xppnQZc3LPi+Mf+PkPeyxJeIx11AXAq/14fsaMefInQiMEZUUmrc7J+956G/f7MwE7tn8KZgi3iRcA==",
+      "license": "MIT",
+      "dependencies": {
+        "@docusaurus/babel": "3.10.0",
+        "@docusaurus/bundler": "3.10.0",
+        "@docusaurus/logger": "3.10.0",
+        "@docusaurus/mdx-loader": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-common": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
+        "boxen": "^6.2.1",
+        "chalk": "^4.1.2",
+        "chokidar": "^3.5.3",
+        "cli-table3": "^0.6.3",
+        "combine-promises": "^1.1.0",
+        "commander": "^5.1.0",
+        "core-js": "^3.31.1",
+        "detect-port": "^1.5.1",
+        "escape-html": "^1.0.3",
+        "eta": "^2.2.0",
+        "eval": "^0.1.8",
+        "execa": "^5.1.1",
         "fs-extra": "^11.1.1",
         "html-tags": "^3.3.1",
         "html-webpack-plugin": "^5.6.0",
         "leven": "^3.1.0",
         "lodash": "^4.17.21",
+        "open": "^8.4.0",
         "p-map": "^4.0.0",
         "prompts": "^2.4.2",
-        "react-dev-utils": "^12.0.1",
-        "react-helmet-async": "^1.3.0",
+        "react-helmet-async": "npm:@slorber/react-helmet-async@1.3.0",
         "react-loadable": "npm:@docusaurus/react-loadable@6.0.0",
-        "react-loadable-ssr-addon-v5-slorber": "^1.0.1",
+        "react-loadable-ssr-addon-v5-slorber": "^1.0.3",
         "react-router": "^5.3.4",
         "react-router-config": "^5.1.1",
         "react-router-dom": "^5.3.4",
-        "rtl-detect": "^1.0.4",
         "semver": "^7.5.4",
-        "serve-handler": "^6.1.6",
-        "shelljs": "^0.8.5",
+        "serve-handler": "^6.1.7",
+        "tinypool": "^1.0.2",
         "tslib": "^2.6.0",
         "update-notifier": "^6.0.2",
         "webpack": "^5.95.0",
         "webpack-bundle-analyzer": "^4.10.2",
-        "webpack-dev-server": "^4.15.2",
+        "webpack-dev-server": "^5.2.2",
         "webpack-merge": "^6.0.1"
       },
       "bin": {
         "docusaurus": "bin/docusaurus.mjs"
       },
       "engines": {
-        "node": ">=18.0"
+        "node": ">=20.0"
       },
       "peerDependencies": {
+        "@docusaurus/faster": "*",
         "@mdx-js/react": "^3.0.0",
-        "react": "^18.0.0",
-        "react-dom": "^18.0.0"
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@docusaurus/faster": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@docusaurus/core/node_modules/semver": {
+      "version": "7.7.4",
+      "resolved": "https://registry.facebook.net/semver/-/semver-7.7.4.tgz",
+      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
       }
     },
     "node_modules/@docusaurus/cssnano-preset": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/cssnano-preset/-/cssnano-preset-3.6.3.tgz",
-      "integrity": "sha512-qP7SXrwZ+23GFJdPN4aIHQrZW+oH/7tzwEuc/RNL0+BdZdmIjYQqUxdXsjE4lFxLNZjj0eUrSNYIS6xwfij+5Q==",
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/cssnano-preset/-/cssnano-preset-3.10.0.tgz",
+      "integrity": "sha512-qzSshTO1DB3TYW+dPUal5KHM7XPc5YQfzF3Kdb2NDACJUyGbNcFtw3tGkCJlYwhNCRKbZcmwraKUS1i5dcHdGg==",
       "license": "MIT",
       "dependencies": {
         "cssnano-preset-advanced": "^6.1.2",
-        "postcss": "^8.4.38",
+        "postcss": "^8.5.4",
         "postcss-sort-media-queries": "^5.2.0",
         "tslib": "^2.6.0"
       },
       "engines": {
-        "node": ">=18.0"
+        "node": ">=20.0"
       }
     },
     "node_modules/@docusaurus/logger": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/logger/-/logger-3.6.3.tgz",
-      "integrity": "sha512-xSubJixcNyMV9wMV4q0s47CBz3Rlc5jbcCCuij8pfQP8qn/DIpt0ks8W6hQWzHAedg/J/EwxxUOUrnEoKzJo8g==",
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/logger/-/logger-3.10.0.tgz",
+      "integrity": "sha512-9jrZzFuBH1LDRlZ7cznAhCLmAZ3HSDqgwdrSSZdGHq9SPUOQgXXu8mnxe2ZRB9NS1PCpMTIOVUqDtZPIhMafZg==",
       "license": "MIT",
       "dependencies": {
         "chalk": "^4.1.2",
         "tslib": "^2.6.0"
       },
       "engines": {
-        "node": ">=18.0"
+        "node": ">=20.0"
       }
     },
     "node_modules/@docusaurus/mdx-loader": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/mdx-loader/-/mdx-loader-3.6.3.tgz",
-      "integrity": "sha512-3iJdiDz9540ppBseeI93tWTDtUGVkxzh59nMq4ignylxMuXBLK8dFqVeaEor23v1vx6TrGKZ2FuLaTB+U7C0QQ==",
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/mdx-loader/-/mdx-loader-3.10.0.tgz",
+      "integrity": "sha512-mQQV97080AH4PYNs087l202NMDqRopZA4mg5W76ZZyTFrmWhJ3mHg+8A+drJVENxw5/Q+wHMHLgsx+9z1nEs0A==",
       "license": "MIT",
       "dependencies": {
-        "@docusaurus/logger": "3.6.3",
-        "@docusaurus/utils": "3.6.3",
-        "@docusaurus/utils-validation": "3.6.3",
+        "@docusaurus/logger": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
         "@mdx-js/mdx": "^3.0.0",
         "@slorber/remark-comment": "^1.0.0",
         "escape-html": "^1.0.3",
         "estree-util-value-to-estree": "^3.0.1",
         "file-loader": "^6.2.0",
         "fs-extra": "^11.1.1",
-        "image-size": "^1.0.2",
+        "image-size": "^2.0.2",
         "mdast-util-mdx": "^3.0.0",
         "mdast-util-to-string": "^4.0.0",
         "rehype-raw": "^7.0.0",
@@ -3519,25 +3606,25 @@
         "webpack": "^5.88.1"
       },
       "engines": {
-        "node": ">=18.0"
+        "node": ">=20.0"
       },
       "peerDependencies": {
-        "react": "^18.0.0",
-        "react-dom": "^18.0.0"
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
       }
     },
     "node_modules/@docusaurus/module-type-aliases": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/module-type-aliases/-/module-type-aliases-3.6.3.tgz",
-      "integrity": "sha512-MjaXX9PN/k5ugNvfRZdWyKWq4FsrhN4LEXaj0pEmMebJuBNlFeGyKQUa9DRhJHpadNaiMLrbo9m3U7Ig5YlsZg==",
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/module-type-aliases/-/module-type-aliases-3.10.0.tgz",
+      "integrity": "sha512-/1O0Zg8w3DFrYX/I6Fbss7OJrtZw1QoyjDhegiFNHVi9A9Y0gQ3jUAytVxF6ywpAWpLyLxch8nN8H/V3XfzdJQ==",
       "license": "MIT",
       "dependencies": {
-        "@docusaurus/types": "3.6.3",
+        "@docusaurus/types": "3.10.0",
         "@types/history": "^4.7.11",
         "@types/react": "*",
         "@types/react-router-config": "*",
         "@types/react-router-dom": "*",
-        "react-helmet-async": "*",
+        "react-helmet-async": "npm:@slorber/react-helmet-async@1.3.0",
         "react-loadable": "npm:@docusaurus/react-loadable@6.0.0"
       },
       "peerDependencies": {
@@ -3546,24 +3633,25 @@
       }
     },
     "node_modules/@docusaurus/plugin-content-blog": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-blog/-/plugin-content-blog-3.6.3.tgz",
-      "integrity": "sha512-k0ogWwwJU3pFRFfvW1kRVHxzf2DutLGaaLjAnHVEU6ju+aRP0Z5ap/13DHyPOfHeE4WKpn/M0TqjdwZAcY3kAw==",
-      "license": "MIT",
-      "dependencies": {
-        "@docusaurus/core": "3.6.3",
-        "@docusaurus/logger": "3.6.3",
-        "@docusaurus/mdx-loader": "3.6.3",
-        "@docusaurus/theme-common": "3.6.3",
-        "@docusaurus/types": "3.6.3",
-        "@docusaurus/utils": "3.6.3",
-        "@docusaurus/utils-common": "3.6.3",
-        "@docusaurus/utils-validation": "3.6.3",
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/plugin-content-blog/-/plugin-content-blog-3.10.0.tgz",
+      "integrity": "sha512-RuTz68DhB7CL96QO5UsFbciD7GPYq6QV+YMfF9V0+N4ZgLhJIBgpVAr8GobrKF6NRe5cyWWETU5z5T834piG9g==",
+      "license": "MIT",
+      "dependencies": {
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/logger": "3.10.0",
+        "@docusaurus/mdx-loader": "3.10.0",
+        "@docusaurus/theme-common": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-common": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
         "cheerio": "1.0.0-rc.12",
+        "combine-promises": "^1.1.0",
         "feed": "^4.2.2",
         "fs-extra": "^11.1.1",
         "lodash": "^4.17.21",
-        "reading-time": "^1.5.0",
+        "schema-dts": "^1.1.2",
         "srcset": "^4.0.0",
         "tslib": "^2.6.0",
         "unist-util-visit": "^5.0.0",
@@ -3571,226 +3659,268 @@
         "webpack": "^5.88.1"
       },
       "engines": {
-        "node": ">=18.0"
+        "node": ">=20.0"
       },
       "peerDependencies": {
         "@docusaurus/plugin-content-docs": "*",
-        "react": "^18.0.0",
-        "react-dom": "^18.0.0"
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
       }
     },
     "node_modules/@docusaurus/plugin-content-docs": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-docs/-/plugin-content-docs-3.6.3.tgz",
-      "integrity": "sha512-r2wS8y/fsaDcxkm20W5bbYJFPzdWdEaTWVYjNxlHlcmX086eqQR1Fomlg9BHTJ0dLXPzAlbC8EN4XqMr3QzNCQ==",
-      "license": "MIT",
-      "dependencies": {
-        "@docusaurus/core": "3.6.3",
-        "@docusaurus/logger": "3.6.3",
-        "@docusaurus/mdx-loader": "3.6.3",
-        "@docusaurus/module-type-aliases": "3.6.3",
-        "@docusaurus/theme-common": "3.6.3",
-        "@docusaurus/types": "3.6.3",
-        "@docusaurus/utils": "3.6.3",
-        "@docusaurus/utils-common": "3.6.3",
-        "@docusaurus/utils-validation": "3.6.3",
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/plugin-content-docs/-/plugin-content-docs-3.10.0.tgz",
+      "integrity": "sha512-9BjHhf15ct8Z7TThTC0xRndKDVvMKmVsAGAN7W9FpNRzfMdScOGcXtLmcCWtJGvAezjOJIm6CxOYCy3Io5+RnQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/logger": "3.10.0",
+        "@docusaurus/mdx-loader": "3.10.0",
+        "@docusaurus/module-type-aliases": "3.10.0",
+        "@docusaurus/theme-common": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-common": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
         "@types/react-router-config": "^5.0.7",
         "combine-promises": "^1.1.0",
         "fs-extra": "^11.1.1",
         "js-yaml": "^4.1.0",
         "lodash": "^4.17.21",
+        "schema-dts": "^1.1.2",
         "tslib": "^2.6.0",
         "utility-types": "^3.10.0",
         "webpack": "^5.88.1"
       },
       "engines": {
-        "node": ">=18.0"
+        "node": ">=20.0"
       },
       "peerDependencies": {
-        "react": "^18.0.0",
-        "react-dom": "^18.0.0"
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
       }
     },
     "node_modules/@docusaurus/plugin-content-pages": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-pages/-/plugin-content-pages-3.6.3.tgz",
-      "integrity": "sha512-eHrmTgjgLZsuqfsYr5X2xEwyIcck0wseSofWrjTwT9FLOWp+KDmMAuVK+wRo7sFImWXZk3oV/xX/g9aZrhD7OA==",
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/plugin-content-pages/-/plugin-content-pages-3.10.0.tgz",
+      "integrity": "sha512-5amX8kEJI+nIGtuLVjYk59Y5utEJ3CHETFOPEE4cooIRLA4xM4iBsA6zFgu4ljcopeYwvBzFEWf5g2I6Yb9SkA==",
       "license": "MIT",
       "dependencies": {
-        "@docusaurus/core": "3.6.3",
-        "@docusaurus/mdx-loader": "3.6.3",
-        "@docusaurus/types": "3.6.3",
-        "@docusaurus/utils": "3.6.3",
-        "@docusaurus/utils-validation": "3.6.3",
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/mdx-loader": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
         "fs-extra": "^11.1.1",
         "tslib": "^2.6.0",
         "webpack": "^5.88.1"
       },
       "engines": {
-        "node": ">=18.0"
+        "node": ">=20.0"
       },
       "peerDependencies": {
-        "react": "^18.0.0",
-        "react-dom": "^18.0.0"
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
+      }
+    },
+    "node_modules/@docusaurus/plugin-css-cascade-layers": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/plugin-css-cascade-layers/-/plugin-css-cascade-layers-3.10.0.tgz",
+      "integrity": "sha512-6q1vtt5FJcg5osgkHeM1euErECNqEZ5Z1j69yiNx2luEBIso+nxCkS9nqj8w+MK5X7rvKEToGhFfOFWncs51pQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
+        "tslib": "^2.6.0"
+      },
+      "engines": {
+        "node": ">=20.0"
       }
     },
     "node_modules/@docusaurus/plugin-debug": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/plugin-debug/-/plugin-debug-3.6.3.tgz",
-      "integrity": "sha512-zB9GXfIZNPRfzKnNjU6xGVrqn9bPXuGhpjgsuc/YtcTDjnjhasg38NdYd5LEqXex5G/zIorQgWB3n6x/Ut62vQ==",
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/plugin-debug/-/plugin-debug-3.10.0.tgz",
+      "integrity": "sha512-XcljKN+G+nmmK69uQA1d9BlYU3ZftG3T3zpK8/7Hf/wrOlV7TA4Ampdrdwkg0jElKdKAoSnPhCO0/U3bQGsVQQ==",
       "license": "MIT",
       "dependencies": {
-        "@docusaurus/core": "3.6.3",
-        "@docusaurus/types": "3.6.3",
-        "@docusaurus/utils": "3.6.3",
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
         "fs-extra": "^11.1.1",
-        "react-json-view-lite": "^1.2.0",
+        "react-json-view-lite": "^2.3.0",
         "tslib": "^2.6.0"
       },
       "engines": {
-        "node": ">=18.0"
+        "node": ">=20.0"
       },
       "peerDependencies": {
-        "react": "^18.0.0",
-        "react-dom": "^18.0.0"
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
       }
     },
     "node_modules/@docusaurus/plugin-google-analytics": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/plugin-google-analytics/-/plugin-google-analytics-3.6.3.tgz",
-      "integrity": "sha512-rCDNy1QW8Dag7nZq67pcum0bpFLrwvxJhYuVprhFh8BMBDxV0bY+bAkGHbSf68P3Bk9C3hNOAXX1srGLIDvcTA==",
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/plugin-google-analytics/-/plugin-google-analytics-3.10.0.tgz",
+      "integrity": "sha512-hTEoodatpBZnUat5nFExbuTGA1lhWGy7vZGuTew5Q3QDtGKFpSJLYmZJhdTjvCFwv1+qQ67hgAVlKdJOB8TXow==",
       "license": "MIT",
       "dependencies": {
-        "@docusaurus/core": "3.6.3",
-        "@docusaurus/types": "3.6.3",
-        "@docusaurus/utils-validation": "3.6.3",
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
         "tslib": "^2.6.0"
       },
       "engines": {
-        "node": ">=18.0"
+        "node": ">=20.0"
       },
       "peerDependencies": {
-        "react": "^18.0.0",
-        "react-dom": "^18.0.0"
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
       }
     },
     "node_modules/@docusaurus/plugin-google-gtag": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/plugin-google-gtag/-/plugin-google-gtag-3.6.3.tgz",
-      "integrity": "sha512-+OyDvhM6rqVkQOmLVkQWVJAizEEfkPzVWtIHXlWPOCFGK9X4/AWeBSrU0WG4iMg9Z4zD4YDRrU+lvI4s6DSC+w==",
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/plugin-google-gtag/-/plugin-google-gtag-3.10.0.tgz",
+      "integrity": "sha512-iB/Zzjv/eelJRbdULZqzWCbgMgJ7ht4ONVjXtN3+BI/muil6S87gQ1OJyPwlXD+ELdKkitC7bWv5eJdYOZLhrQ==",
       "license": "MIT",
       "dependencies": {
-        "@docusaurus/core": "3.6.3",
-        "@docusaurus/types": "3.6.3",
-        "@docusaurus/utils-validation": "3.6.3",
-        "@types/gtag.js": "^0.0.12",
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
+        "@types/gtag.js": "^0.0.20",
         "tslib": "^2.6.0"
       },
       "engines": {
-        "node": ">=18.0"
+        "node": ">=20.0"
       },
       "peerDependencies": {
-        "react": "^18.0.0",
-        "react-dom": "^18.0.0"
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
       }
     },
     "node_modules/@docusaurus/plugin-google-tag-manager": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/plugin-google-tag-manager/-/plugin-google-tag-manager-3.6.3.tgz",
-      "integrity": "sha512-1M6UPB13gWUtN2UHX083/beTn85PlRI9ABItTl/JL1FJ5dJTWWFXXsHf9WW/6hrVwthwTeV/AGbGKvLKV+IlCA==",
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/plugin-google-tag-manager/-/plugin-google-tag-manager-3.10.0.tgz",
+      "integrity": "sha512-FEjZxqKgLHa+Wez/EgKxRwvArNCWIScfyEQD95rot7jkxp6nonjI5XIbGfO/iYhM5Qinwe8aIEQHP2KZtpqVuA==",
       "license": "MIT",
       "dependencies": {
-        "@docusaurus/core": "3.6.3",
-        "@docusaurus/types": "3.6.3",
-        "@docusaurus/utils-validation": "3.6.3",
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
         "tslib": "^2.6.0"
       },
       "engines": {
-        "node": ">=18.0"
+        "node": ">=20.0"
       },
       "peerDependencies": {
-        "react": "^18.0.0",
-        "react-dom": "^18.0.0"
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
       }
     },
     "node_modules/@docusaurus/plugin-sitemap": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/plugin-sitemap/-/plugin-sitemap-3.6.3.tgz",
-      "integrity": "sha512-94qOO4M9Fwv9KfVQJsgbe91k+fPJ4byf1L3Ez8TUa6TAFPo/BrLwQ80zclHkENlL1824TuxkcMKv33u6eydQCg==",
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/plugin-sitemap/-/plugin-sitemap-3.10.0.tgz",
+      "integrity": "sha512-DVTSLjB97hIjmayGnGcBfognCeI7ZuUKgEnU7Oz81JYqXtVg94mVTthDjq3QHTylYNeCUbkaW8VF0FDLcc8pPw==",
       "license": "MIT",
       "dependencies": {
-        "@docusaurus/core": "3.6.3",
-        "@docusaurus/logger": "3.6.3",
-        "@docusaurus/types": "3.6.3",
-        "@docusaurus/utils": "3.6.3",
-        "@docusaurus/utils-common": "3.6.3",
-        "@docusaurus/utils-validation": "3.6.3",
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/logger": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-common": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
         "fs-extra": "^11.1.1",
         "sitemap": "^7.1.1",
         "tslib": "^2.6.0"
       },
       "engines": {
-        "node": ">=18.0"
+        "node": ">=20.0"
+      },
+      "peerDependencies": {
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
+      }
+    },
+    "node_modules/@docusaurus/plugin-svgr": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/plugin-svgr/-/plugin-svgr-3.10.0.tgz",
+      "integrity": "sha512-lNljBESaETZqVBMPqkrGchr+UPT1eZzEPLmJhz8I76BxbjqgsUnRvrq6lQJ9sYjgmgX52KB7kkgczqd2yzoswQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
+        "@svgr/core": "8.1.0",
+        "@svgr/webpack": "^8.1.0",
+        "tslib": "^2.6.0",
+        "webpack": "^5.88.1"
+      },
+      "engines": {
+        "node": ">=20.0"
       },
       "peerDependencies": {
-        "react": "^18.0.0",
-        "react-dom": "^18.0.0"
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
       }
     },
     "node_modules/@docusaurus/preset-classic": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/preset-classic/-/preset-classic-3.6.3.tgz",
-      "integrity": "sha512-VHSYWROT3flvNNI1SrnMOtW1EsjeHNK9dhU6s9eY5hryZe79lUqnZJyze/ymDe2LXAqzyj6y5oYvyBoZZk6ErA==",
-      "license": "MIT",
-      "dependencies": {
-        "@docusaurus/core": "3.6.3",
-        "@docusaurus/plugin-content-blog": "3.6.3",
-        "@docusaurus/plugin-content-docs": "3.6.3",
-        "@docusaurus/plugin-content-pages": "3.6.3",
-        "@docusaurus/plugin-debug": "3.6.3",
-        "@docusaurus/plugin-google-analytics": "3.6.3",
-        "@docusaurus/plugin-google-gtag": "3.6.3",
-        "@docusaurus/plugin-google-tag-manager": "3.6.3",
-        "@docusaurus/plugin-sitemap": "3.6.3",
-        "@docusaurus/theme-classic": "3.6.3",
-        "@docusaurus/theme-common": "3.6.3",
-        "@docusaurus/theme-search-algolia": "3.6.3",
-        "@docusaurus/types": "3.6.3"
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/preset-classic/-/preset-classic-3.10.0.tgz",
+      "integrity": "sha512-kw/Ye02Hc6xP1OdTswy8yxQEHg0fdPpyWAQRxr5b2x3h7LlG2Zgbb5BDFROnXDDMpUxB7YejlocJIE5HIEfpNA==",
+      "license": "MIT",
+      "dependencies": {
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/plugin-content-blog": "3.10.0",
+        "@docusaurus/plugin-content-docs": "3.10.0",
+        "@docusaurus/plugin-content-pages": "3.10.0",
+        "@docusaurus/plugin-css-cascade-layers": "3.10.0",
+        "@docusaurus/plugin-debug": "3.10.0",
+        "@docusaurus/plugin-google-analytics": "3.10.0",
+        "@docusaurus/plugin-google-gtag": "3.10.0",
+        "@docusaurus/plugin-google-tag-manager": "3.10.0",
+        "@docusaurus/plugin-sitemap": "3.10.0",
+        "@docusaurus/plugin-svgr": "3.10.0",
+        "@docusaurus/theme-classic": "3.10.0",
+        "@docusaurus/theme-common": "3.10.0",
+        "@docusaurus/theme-search-algolia": "3.10.0",
+        "@docusaurus/types": "3.10.0"
       },
       "engines": {
-        "node": ">=18.0"
+        "node": ">=20.0"
       },
       "peerDependencies": {
-        "react": "^18.0.0",
-        "react-dom": "^18.0.0"
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
       }
     },
     "node_modules/@docusaurus/theme-classic": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/theme-classic/-/theme-classic-3.6.3.tgz",
-      "integrity": "sha512-1RRLK1tSArI2c00qugWYO3jRocjOZwGF1mBzPPylDVRwWCS/rnWWR91ChdbbaxIupRJ+hX8ZBYrwr5bbU0oztQ==",
-      "license": "MIT",
-      "dependencies": {
-        "@docusaurus/core": "3.6.3",
-        "@docusaurus/logger": "3.6.3",
-        "@docusaurus/mdx-loader": "3.6.3",
-        "@docusaurus/module-type-aliases": "3.6.3",
-        "@docusaurus/plugin-content-blog": "3.6.3",
-        "@docusaurus/plugin-content-docs": "3.6.3",
-        "@docusaurus/plugin-content-pages": "3.6.3",
-        "@docusaurus/theme-common": "3.6.3",
-        "@docusaurus/theme-translations": "3.6.3",
-        "@docusaurus/types": "3.6.3",
-        "@docusaurus/utils": "3.6.3",
-        "@docusaurus/utils-common": "3.6.3",
-        "@docusaurus/utils-validation": "3.6.3",
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/theme-classic/-/theme-classic-3.10.0.tgz",
+      "integrity": "sha512-9msCAsRdN+UG+RwPwCFb0uKy4tGoPh5YfBozXeGUtIeAgsMdn6f3G/oY861luZ3t8S2ET8S9Y/1GnpJAGWytww==",
+      "license": "MIT",
+      "dependencies": {
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/logger": "3.10.0",
+        "@docusaurus/mdx-loader": "3.10.0",
+        "@docusaurus/module-type-aliases": "3.10.0",
+        "@docusaurus/plugin-content-blog": "3.10.0",
+        "@docusaurus/plugin-content-docs": "3.10.0",
+        "@docusaurus/plugin-content-pages": "3.10.0",
+        "@docusaurus/theme-common": "3.10.0",
+        "@docusaurus/theme-translations": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-common": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
         "@mdx-js/react": "^3.0.0",
         "clsx": "^2.0.0",
         "copy-text-to-clipboard": "^3.2.0",
         "infima": "0.2.0-alpha.45",
         "lodash": "^4.17.21",
         "nprogress": "^0.2.0",
-        "postcss": "^8.4.26",
+        "postcss": "^8.5.4",
         "prism-react-renderer": "^2.3.0",
         "prismjs": "^1.29.0",
         "react-router-dom": "^5.3.4",
@@ -3799,23 +3929,23 @@
         "utility-types": "^3.10.0"
       },
       "engines": {
-        "node": ">=18.0"
+        "node": ">=20.0"
       },
       "peerDependencies": {
-        "react": "^18.0.0",
-        "react-dom": "^18.0.0"
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
       }
     },
     "node_modules/@docusaurus/theme-common": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/theme-common/-/theme-common-3.6.3.tgz",
-      "integrity": "sha512-b8ZkhczXHDxWWyvz+YJy4t/PlPbEogTTbgnHoflYnH7rmRtyoodTsu8WVM12la5LmlMJBclBXFl29OH8kPE7gg==",
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/theme-common/-/theme-common-3.10.0.tgz",
+      "integrity": "sha512-Dkp1YXKn16ByCJAdIjbDIOpVb4Z66MsVD694/ilX1vAAHaVEMrVsf/NPd9VgreyFx08rJ9GqV1MtzsbTcU73Kg==",
       "license": "MIT",
       "dependencies": {
-        "@docusaurus/mdx-loader": "3.6.3",
-        "@docusaurus/module-type-aliases": "3.6.3",
-        "@docusaurus/utils": "3.6.3",
-        "@docusaurus/utils-common": "3.6.3",
+        "@docusaurus/mdx-loader": "3.10.0",
+        "@docusaurus/module-type-aliases": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-common": "3.10.0",
         "@types/history": "^4.7.11",
         "@types/react": "*",
         "@types/react-router-config": "*",
@@ -3826,30 +3956,31 @@
         "utility-types": "^3.10.0"
       },
       "engines": {
-        "node": ">=18.0"
+        "node": ">=20.0"
       },
       "peerDependencies": {
         "@docusaurus/plugin-content-docs": "*",
-        "react": "^18.0.0",
-        "react-dom": "^18.0.0"
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
       }
     },
     "node_modules/@docusaurus/theme-search-algolia": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/theme-search-algolia/-/theme-search-algolia-3.6.3.tgz",
-      "integrity": "sha512-rt+MGCCpYgPyWCGXtbxlwFbTSobu15jWBTPI2LHsHNa5B0zSmOISX6FWYAPt5X1rNDOqMGM0FATnh7TBHRohVA==",
-      "license": "MIT",
-      "dependencies": {
-        "@docsearch/react": "^3.5.2",
-        "@docusaurus/core": "3.6.3",
-        "@docusaurus/logger": "3.6.3",
-        "@docusaurus/plugin-content-docs": "3.6.3",
-        "@docusaurus/theme-common": "3.6.3",
-        "@docusaurus/theme-translations": "3.6.3",
-        "@docusaurus/utils": "3.6.3",
-        "@docusaurus/utils-validation": "3.6.3",
-        "algoliasearch": "^4.18.0",
-        "algoliasearch-helper": "^3.13.3",
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/theme-search-algolia/-/theme-search-algolia-3.10.0.tgz",
+      "integrity": "sha512-f5FPKI08e3JRG63vR/o4qeuUVHUHzFzM0nnF+AkB67soAZgNsKJRf2qmUZvlQkGwlV+QFkKe4D0ANMh1jToU3g==",
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/autocomplete-core": "^1.19.2",
+        "@docsearch/react": "^3.9.0 || ^4.3.2",
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/logger": "3.10.0",
+        "@docusaurus/plugin-content-docs": "3.10.0",
+        "@docusaurus/theme-common": "3.10.0",
+        "@docusaurus/theme-translations": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
+        "algoliasearch": "^5.37.0",
+        "algoliasearch-helper": "^3.26.0",
         "clsx": "^2.0.0",
         "eta": "^2.2.0",
         "fs-extra": "^11.1.1",
@@ -3858,50 +3989,51 @@
         "utility-types": "^3.10.0"
       },
       "engines": {
-        "node": ">=18.0"
+        "node": ">=20.0"
       },
       "peerDependencies": {
-        "react": "^18.0.0",
-        "react-dom": "^18.0.0"
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
       }
     },
     "node_modules/@docusaurus/theme-translations": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/theme-translations/-/theme-translations-3.6.3.tgz",
-      "integrity": "sha512-Gb0regclToVlngSIIwUCtBMQBq48qVUaN1XQNKW4XwlsgUyk0vP01LULdqbem7czSwIeBAFXFoORJ0RPX7ht/w==",
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/theme-translations/-/theme-translations-3.10.0.tgz",
+      "integrity": "sha512-L9IbFLwTc5+XdgH45iQYufLn0SVZd6BUNelDbKIFlH+E4hhjuj/XHWAFMX/w2K59rfy8wak9McOaei7BSUfRPA==",
       "license": "MIT",
       "dependencies": {
         "fs-extra": "^11.1.1",
         "tslib": "^2.6.0"
       },
       "engines": {
-        "node": ">=18.0"
+        "node": ">=20.0"
       }
     },
     "node_modules/@docusaurus/types": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/types/-/types-3.6.3.tgz",
-      "integrity": "sha512-xD9oTGDrouWzefkhe9ogB2fDV96/82cRpNGx2HIvI5L87JHNhQVIWimQ/3JIiiX/TEd5S9s+VO6FFguwKNRVow==",
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/types/-/types-3.10.0.tgz",
+      "integrity": "sha512-F0dOt3FOoO20rRaFK7whGFQZ3ggyrWEdQc/c8/UiRuzhtg4y1w9FspXH5zpCT07uMnJKBPGh+qNazbNlCQqvSw==",
       "license": "MIT",
       "dependencies": {
         "@mdx-js/mdx": "^3.0.0",
         "@types/history": "^4.7.11",
+        "@types/mdast": "^4.0.2",
         "@types/react": "*",
         "commander": "^5.1.0",
         "joi": "^17.9.2",
-        "react-helmet-async": "^1.3.0",
+        "react-helmet-async": "npm:@slorber/react-helmet-async@1.3.0",
         "utility-types": "^3.10.0",
         "webpack": "^5.95.0",
         "webpack-merge": "^5.9.0"
       },
       "peerDependencies": {
-        "react": "^18.0.0",
-        "react-dom": "^18.0.0"
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
       }
     },
     "node_modules/@docusaurus/types/node_modules/webpack-merge": {
       "version": "5.10.0",
-      "resolved": "https://registry.npmjs.org/webpack-merge/-/webpack-merge-5.10.0.tgz",
+      "resolved": "https://registry.facebook.net/webpack-merge/-/webpack-merge-5.10.0.tgz",
       "integrity": "sha512-+4zXKdx7UnO+1jaN4l2lHVD+mFvnlZQP/6ljaJVb4SZiwIKeUnrT5l0gkT8z+n4hKpC+jpOv6O9R+gLtag7pSA==",
       "license": "MIT",
       "dependencies": {
@@ -3914,16 +4046,16 @@
       }
     },
     "node_modules/@docusaurus/utils": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/utils/-/utils-3.6.3.tgz",
-      "integrity": "sha512-0R/FR3bKVl4yl8QwbL4TYFfR+OXBRpVUaTJdENapBGR3YMwfM6/JnhGilWQO8AOwPJGtGoDK7ib8+8UF9f3OZQ==",
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/utils/-/utils-3.10.0.tgz",
+      "integrity": "sha512-T3B0WTigsIthe0D4LQa2k+7bJY+c3WS+Wq2JhcznOSpn1lSN64yNtHQXboCj3QnUs1EuAZszQG1SHKu5w5ZrlA==",
       "license": "MIT",
       "dependencies": {
-        "@docusaurus/logger": "3.6.3",
-        "@docusaurus/types": "3.6.3",
-        "@docusaurus/utils-common": "3.6.3",
-        "@svgr/webpack": "^8.1.0",
+        "@docusaurus/logger": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils-common": "3.10.0",
         "escape-string-regexp": "^4.0.0",
+        "execa": "^5.1.1",
         "file-loader": "^6.2.0",
         "fs-extra": "^11.1.1",
         "github-slugger": "^1.5.0",
@@ -3933,40 +4065,40 @@
         "js-yaml": "^4.1.0",
         "lodash": "^4.17.21",
         "micromatch": "^4.0.5",
+        "p-queue": "^6.6.2",
         "prompts": "^2.4.2",
         "resolve-pathname": "^3.0.0",
-        "shelljs": "^0.8.5",
         "tslib": "^2.6.0",
         "url-loader": "^4.1.1",
         "utility-types": "^3.10.0",
         "webpack": "^5.88.1"
       },
       "engines": {
-        "node": ">=18.0"
+        "node": ">=20.0"
       }
     },
     "node_modules/@docusaurus/utils-common": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/utils-common/-/utils-common-3.6.3.tgz",
-      "integrity": "sha512-v4nKDaANLgT3pMBewHYEMAl/ufY0LkXao1QkFWzI5huWFOmNQ2UFzv2BiKeHX5Ownis0/w6cAyoxPhVdDonlSQ==",
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/utils-common/-/utils-common-3.10.0.tgz",
+      "integrity": "sha512-JyL7sb9QVDgYvudIS81Dv0lsWm7le0vGZSDwsztxWam1SPBqrnkvBy9UYL/amh6pbybkyYTd3CMTkO24oMlCSw==",
       "license": "MIT",
       "dependencies": {
-        "@docusaurus/types": "3.6.3",
+        "@docusaurus/types": "3.10.0",
         "tslib": "^2.6.0"
       },
       "engines": {
-        "node": ">=18.0"
+        "node": ">=20.0"
       }
     },
     "node_modules/@docusaurus/utils-validation": {
-      "version": "3.6.3",
-      "resolved": "https://registry.npmjs.org/@docusaurus/utils-validation/-/utils-validation-3.6.3.tgz",
-      "integrity": "sha512-bhEGGiN5BE38h21vjqD70Gxg++j+PfYVddDUE5UFvLDup68QOcpD33CLr+2knPorlxRbEaNfz6HQDUMQ3HuqKw==",
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/utils-validation/-/utils-validation-3.10.0.tgz",
+      "integrity": "sha512-c+6n2+ZPOJtWWc8Bb/EYdpSDfjYEScdCu9fB/SNjOmSCf1IdVnGf2T53o0tsz0gDRtCL90tifTL0JE/oMuP1Mw==",
       "license": "MIT",
       "dependencies": {
-        "@docusaurus/logger": "3.6.3",
-        "@docusaurus/utils": "3.6.3",
-        "@docusaurus/utils-common": "3.6.3",
+        "@docusaurus/logger": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-common": "3.10.0",
         "fs-extra": "^11.2.0",
         "joi": "^17.9.2",
         "js-yaml": "^4.1.0",
@@ -3974,18 +4106,18 @@
         "tslib": "^2.6.0"
       },
       "engines": {
-        "node": ">=18.0"
+        "node": ">=20.0"
       }
     },
     "node_modules/@hapi/hoek": {
       "version": "9.3.0",
-      "resolved": "https://registry.npmjs.org/@hapi/hoek/-/hoek-9.3.0.tgz",
+      "resolved": "https://registry.facebook.net/@hapi/hoek/-/hoek-9.3.0.tgz",
       "integrity": "sha512-/c6rf4UJlmHlC9b5BaNvzAcFv7HZ2QHaV0D4/HNlBdvFnvQq8RI4kYdhyPCl7Xj+oWvTWQ8ujhqS53LIgAe6KQ==",
       "license": "BSD-3-Clause"
     },
     "node_modules/@hapi/topo": {
       "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/@hapi/topo/-/topo-5.1.0.tgz",
+      "resolved": "https://registry.facebook.net/@hapi/topo/-/topo-5.1.0.tgz",
       "integrity": "sha512-foQZKJig7Ob0BMAYBfcJk8d77QtOe7Wo4ox7ff1lQYoNNAb6jwcY1ncdoy2e9wQZzvNy7ODZCYJkK8kzmcAnAg==",
       "license": "BSD-3-Clause",
       "dependencies": {
@@ -3994,7 +4126,7 @@
     },
     "node_modules/@jest/schemas": {
       "version": "29.6.3",
-      "resolved": "https://registry.npmjs.org/@jest/schemas/-/schemas-29.6.3.tgz",
+      "resolved": "https://registry.facebook.net/@jest/schemas/-/schemas-29.6.3.tgz",
       "integrity": "sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==",
       "license": "MIT",
       "dependencies": {
@@ -4006,7 +4138,7 @@
     },
     "node_modules/@jest/types": {
       "version": "29.6.3",
-      "resolved": "https://registry.npmjs.org/@jest/types/-/types-29.6.3.tgz",
+      "resolved": "https://registry.facebook.net/@jest/types/-/types-29.6.3.tgz",
       "integrity": "sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw==",
       "license": "MIT",
       "dependencies": {
@@ -4022,41 +4154,38 @@
       }
     },
     "node_modules/@jridgewell/gen-mapping": {
-      "version": "0.3.8",
-      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.8.tgz",
-      "integrity": "sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA==",
+      "version": "0.3.13",
+      "resolved": "https://registry.facebook.net/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
       "license": "MIT",
       "dependencies": {
-        "@jridgewell/set-array": "^1.2.1",
-        "@jridgewell/sourcemap-codec": "^1.4.10",
+        "@jridgewell/sourcemap-codec": "^1.5.0",
         "@jridgewell/trace-mapping": "^0.3.24"
-      },
-      "engines": {
-        "node": ">=6.0.0"
       }
     },
-    "node_modules/@jridgewell/resolve-uri": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
-      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.facebook.net/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
       "license": "MIT",
-      "engines": {
-        "node": ">=6.0.0"
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
       }
     },
-    "node_modules/@jridgewell/set-array": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.2.1.tgz",
-      "integrity": "sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==",
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.facebook.net/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
       "license": "MIT",
       "engines": {
         "node": ">=6.0.0"
       }
     },
     "node_modules/@jridgewell/source-map": {
-      "version": "0.3.6",
-      "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.6.tgz",
-      "integrity": "sha512-1ZJTZebgqllO79ue2bm3rIGud/bOe0pP5BjSRCRxxYkEZS8STV7zN84UBbiYu7jy+eCKSnVIUgoWWE/tt+shMQ==",
+      "version": "0.3.11",
+      "resolved": "https://registry.facebook.net/@jridgewell/source-map/-/source-map-0.3.11.tgz",
+      "integrity": "sha512-ZMp1V8ZFcPG5dIWnQLr3NSI1MiCU7UETdS/A0G8V/XWHvJv3ZsFqutJn1Y5RPmAPX6F3BiE397OqveU/9NCuIA==",
       "license": "MIT",
       "dependencies": {
         "@jridgewell/gen-mapping": "^0.3.5",
@@ -4064,1830 +4193,1931 @@
       }
     },
     "node_modules/@jridgewell/sourcemap-codec": {
-      "version": "1.5.0",
-      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz",
-      "integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==",
+      "version": "1.5.5",
+      "resolved": "https://registry.facebook.net/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
       "license": "MIT"
     },
     "node_modules/@jridgewell/trace-mapping": {
-      "version": "0.3.25",
-      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz",
-      "integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==",
+      "version": "0.3.31",
+      "resolved": "https://registry.facebook.net/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
       "license": "MIT",
       "dependencies": {
         "@jridgewell/resolve-uri": "^3.1.0",
         "@jridgewell/sourcemap-codec": "^1.4.14"
       }
     },
-    "node_modules/@leichtgewicht/ip-codec": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/@leichtgewicht/ip-codec/-/ip-codec-2.0.5.tgz",
-      "integrity": "sha512-Vo+PSpZG2/fmgmiNzYK9qWRh8h/CHrwD0mo1h1DzL4yzHNSfWYujGTYsWGreD000gcgmZ7K4Ys6Tx9TxtsKdDw==",
-      "license": "MIT"
+    "node_modules/@jsonjoy.com/base64": {
+      "version": "1.1.2",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/base64/-/base64-1.1.2.tgz",
+      "integrity": "sha512-q6XAnWQDIMA3+FTiOYajoYqySkO+JSat0ytXGSuRdq9uXE7o92gzuQwQM14xaCRlBLGq3v5miDGC4vkVTn54xA==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=10.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/streamich"
+      },
+      "peerDependencies": {
+        "tslib": "2"
+      }
     },
-    "node_modules/@mdx-js/mdx": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/@mdx-js/mdx/-/mdx-3.1.0.tgz",
-      "integrity": "sha512-/QxEhPAvGwbQmy1Px8F899L5Uc2KZ6JtXwlCgJmjSTBedwOZkByYcBG4GceIGPXRDsmfxhHazuS+hlOShRLeDw==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/estree": "^1.0.0",
-        "@types/estree-jsx": "^1.0.0",
-        "@types/hast": "^3.0.0",
-        "@types/mdx": "^2.0.0",
-        "collapse-white-space": "^2.0.0",
-        "devlop": "^1.0.0",
-        "estree-util-is-identifier-name": "^3.0.0",
-        "estree-util-scope": "^1.0.0",
-        "estree-walker": "^3.0.0",
-        "hast-util-to-jsx-runtime": "^2.0.0",
-        "markdown-extensions": "^2.0.0",
-        "recma-build-jsx": "^1.0.0",
-        "recma-jsx": "^1.0.0",
-        "recma-stringify": "^1.0.0",
-        "rehype-recma": "^1.0.0",
-        "remark-mdx": "^3.0.0",
-        "remark-parse": "^11.0.0",
-        "remark-rehype": "^11.0.0",
-        "source-map": "^0.7.0",
-        "unified": "^11.0.0",
-        "unist-util-position-from-estree": "^2.0.0",
-        "unist-util-stringify-position": "^4.0.0",
-        "unist-util-visit": "^5.0.0",
-        "vfile": "^6.0.0"
+    "node_modules/@jsonjoy.com/buffers": {
+      "version": "17.67.0",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/buffers/-/buffers-17.67.0.tgz",
+      "integrity": "sha512-tfExRpYxBvi32vPs9ZHaTjSP4fHAfzSmcahOfNxtvGHcyJel+aibkPlGeBB+7AoC6hL7lXIE++8okecBxx7lcw==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=10.0"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "type": "github",
+        "url": "https://github.com/sponsors/streamich"
+      },
+      "peerDependencies": {
+        "tslib": "2"
       }
     },
-    "node_modules/@mdx-js/react": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/@mdx-js/react/-/react-3.1.0.tgz",
-      "integrity": "sha512-QjHtSaoameoalGnKDT3FoIl4+9RwyTmo9ZJGBdLOks/YOiWHoRDI3PUwEzOE7kEmGcV3AFcp9K6dYu9rEuKLAQ==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/mdx": "^2.0.0"
+    "node_modules/@jsonjoy.com/codegen": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/codegen/-/codegen-1.0.0.tgz",
+      "integrity": "sha512-E8Oy+08cmCf0EK/NMxpaJZmOxPqM+6iSe2S4nlSBrPZOORoDJILxtbSUEDKQyTamm/BVAhIGllOBNU79/dwf0g==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=10.0"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "type": "github",
+        "url": "https://github.com/sponsors/streamich"
       },
       "peerDependencies": {
-        "@types/react": ">=16",
-        "react": ">=16"
+        "tslib": "2"
       }
     },
-    "node_modules/@nodelib/fs.scandir": {
-      "version": "2.1.5",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
-      "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
-      "license": "MIT",
+    "node_modules/@jsonjoy.com/fs-core": {
+      "version": "4.57.2",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/fs-core/-/fs-core-4.57.2.tgz",
+      "integrity": "sha512-SVjwklkpIV5wrynpYtuYnfYH1QF4/nDuLBX7VXdb+3miglcAgBVZb/5y0cOsehRV/9Vb+3UqhkMq3/NR3ztdkQ==",
+      "license": "Apache-2.0",
       "dependencies": {
-        "@nodelib/fs.stat": "2.0.5",
-        "run-parallel": "^1.1.9"
+        "@jsonjoy.com/fs-node-builtins": "4.57.2",
+        "@jsonjoy.com/fs-node-utils": "4.57.2",
+        "thingies": "^2.5.0"
       },
       "engines": {
-        "node": ">= 8"
+        "node": ">=10.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/streamich"
+      },
+      "peerDependencies": {
+        "tslib": "2"
       }
     },
-    "node_modules/@nodelib/fs.stat": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
-      "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
-      "license": "MIT",
+    "node_modules/@jsonjoy.com/fs-fsa": {
+      "version": "4.57.2",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/fs-fsa/-/fs-fsa-4.57.2.tgz",
+      "integrity": "sha512-fhO8+iR2I+OCw668ISDJdn1aArc9zx033sWejIyzQ8RBeXa9bDSaUeA3ix0poYOfrj1KdOzytmYNv2/uLDfV6g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@jsonjoy.com/fs-core": "4.57.2",
+        "@jsonjoy.com/fs-node-builtins": "4.57.2",
+        "@jsonjoy.com/fs-node-utils": "4.57.2",
+        "thingies": "^2.5.0"
+      },
       "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/@nodelib/fs.walk": {
-      "version": "1.2.8",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
-      "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
-      "license": "MIT",
-      "dependencies": {
-        "@nodelib/fs.scandir": "2.1.5",
-        "fastq": "^1.6.0"
+        "node": ">=10.0"
       },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/@pnpm/config.env-replace": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@pnpm/config.env-replace/-/config.env-replace-1.1.0.tgz",
-      "integrity": "sha512-htyl8TWnKL7K/ESFa1oW2UB5lVDxuF5DpM7tBi6Hu2LNL3mWkIzNLG6N4zoCUP1lCKNxWy/3iu8mS8MvToGd6w==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=12.22.0"
-      }
-    },
-    "node_modules/@pnpm/network.ca-file": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/@pnpm/network.ca-file/-/network.ca-file-1.0.2.tgz",
-      "integrity": "sha512-YcPQ8a0jwYU9bTdJDpXjMi7Brhkr1mXsXrUJvjqM2mQDgkRiz8jFaQGOdaLxgjtUfQgZhKy/O3cG/YwmgKaxLA==",
-      "license": "MIT",
-      "dependencies": {
-        "graceful-fs": "4.2.10"
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/streamich"
       },
-      "engines": {
-        "node": ">=12.22.0"
+      "peerDependencies": {
+        "tslib": "2"
       }
     },
-    "node_modules/@pnpm/network.ca-file/node_modules/graceful-fs": {
-      "version": "4.2.10",
-      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz",
-      "integrity": "sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==",
-      "license": "ISC"
-    },
-    "node_modules/@pnpm/npm-conf": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/@pnpm/npm-conf/-/npm-conf-2.3.1.tgz",
-      "integrity": "sha512-c83qWb22rNRuB0UaVCI0uRPNRr8Z0FWnEIvT47jiHAmOIUHbBOg5XvV7pM5x+rKn9HRpjxquDbXYSXr3fAKFcw==",
-      "license": "MIT",
+    "node_modules/@jsonjoy.com/fs-node": {
+      "version": "4.57.2",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/fs-node/-/fs-node-4.57.2.tgz",
+      "integrity": "sha512-nX2AdL6cOFwLdju9G4/nbRnYevmCJbh7N7hvR3gGm97Cs60uEjyd0rpR+YBS7cTg175zzl22pGKXR5USaQMvKg==",
+      "license": "Apache-2.0",
       "dependencies": {
-        "@pnpm/config.env-replace": "^1.1.0",
-        "@pnpm/network.ca-file": "^1.0.1",
-        "config-chain": "^1.1.11"
+        "@jsonjoy.com/fs-core": "4.57.2",
+        "@jsonjoy.com/fs-node-builtins": "4.57.2",
+        "@jsonjoy.com/fs-node-utils": "4.57.2",
+        "@jsonjoy.com/fs-print": "4.57.2",
+        "@jsonjoy.com/fs-snapshot": "4.57.2",
+        "glob-to-regex.js": "^1.0.0",
+        "thingies": "^2.5.0"
       },
       "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@polka/url": {
-      "version": "1.0.0-next.28",
-      "resolved": "https://registry.npmjs.org/@polka/url/-/url-1.0.0-next.28.tgz",
-      "integrity": "sha512-8LduaNlMZGwdZ6qWrKlfa+2M4gahzFkprZiAt2TF8uS0qQgBizKXpXURqvTJ4WtmupWxaLqjRb2UCTe72mu+Aw==",
-      "license": "MIT"
-    },
-    "node_modules/@sideway/address": {
-      "version": "4.1.5",
-      "resolved": "https://registry.npmjs.org/@sideway/address/-/address-4.1.5.tgz",
-      "integrity": "sha512-IqO/DUQHUkPeixNQ8n0JA6102hT9CmaljNTPmQ1u8MEhBo/R4Q8eKLN/vGZxuebwOroDB4cbpjheD4+/sKFK4Q==",
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "@hapi/hoek": "^9.0.0"
+        "node": ">=10.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/streamich"
+      },
+      "peerDependencies": {
+        "tslib": "2"
       }
     },
-    "node_modules/@sideway/formula": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/@sideway/formula/-/formula-3.0.1.tgz",
-      "integrity": "sha512-/poHZJJVjx3L+zVD6g9KgHfYnb443oi7wLu/XKojDviHy6HOEOA6z1Trk5aR1dGcmPenJEgb2sK2I80LeS3MIg==",
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/@sideway/pinpoint": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/@sideway/pinpoint/-/pinpoint-2.0.0.tgz",
-      "integrity": "sha512-RNiOoTPkptFtSVzQevY/yWtZwf/RxyVnPy/OcA9HBM3MlGDnBEYL5B41H0MTn0Uec8Hi+2qUtTfG2WWZBmMejQ==",
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/@sinclair/typebox": {
-      "version": "0.27.8",
-      "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.8.tgz",
-      "integrity": "sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==",
-      "license": "MIT"
-    },
-    "node_modules/@sindresorhus/is": {
-      "version": "4.6.0",
-      "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.6.0.tgz",
-      "integrity": "sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==",
-      "license": "MIT",
+    "node_modules/@jsonjoy.com/fs-node-builtins": {
+      "version": "4.57.2",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/fs-node-builtins/-/fs-node-builtins-4.57.2.tgz",
+      "integrity": "sha512-xhiegylRmhw43Ki2HO1ZBL7DQ5ja/qpRsL29VtQ2xuUHiuDGbgf2uD4p9Qd8hJI5P6RCtGYD50IXHXVq/Ocjcg==",
+      "license": "Apache-2.0",
       "engines": {
-        "node": ">=10"
+        "node": ">=10.0"
       },
       "funding": {
-        "url": "https://github.com/sindresorhus/is?sponsor=1"
+        "type": "github",
+        "url": "https://github.com/sponsors/streamich"
+      },
+      "peerDependencies": {
+        "tslib": "2"
       }
     },
-    "node_modules/@slorber/remark-comment": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/@slorber/remark-comment/-/remark-comment-1.0.0.tgz",
-      "integrity": "sha512-RCE24n7jsOj1M0UPvIQCHTe7fI0sFL4S2nwKVWwHyVr/wI/H8GosgsJGyhnsZoGFnD/P2hLf1mSbrrgSLN93NA==",
-      "license": "MIT",
+    "node_modules/@jsonjoy.com/fs-node-to-fsa": {
+      "version": "4.57.2",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/fs-node-to-fsa/-/fs-node-to-fsa-4.57.2.tgz",
+      "integrity": "sha512-18LmWTSONhoAPW+IWRuf8w/+zRolPFGPeGwMxlAhhfY11EKzX+5XHDBPAw67dBF5dxDErHJbl40U+3IXSDRXSQ==",
+      "license": "Apache-2.0",
       "dependencies": {
-        "micromark-factory-space": "^1.0.0",
-        "micromark-util-character": "^1.1.0",
-        "micromark-util-symbol": "^1.0.1"
-      }
-    },
-    "node_modules/@svgr/babel-plugin-add-jsx-attribute": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-add-jsx-attribute/-/babel-plugin-add-jsx-attribute-8.0.0.tgz",
-      "integrity": "sha512-b9MIk7yhdS1pMCZM8VeNfUlSKVRhsHZNMl5O9SfaX0l0t5wjdgu4IDzGB8bpnGBBOjGST3rRFVsaaEtI4W6f7g==",
-      "license": "MIT",
+        "@jsonjoy.com/fs-fsa": "4.57.2",
+        "@jsonjoy.com/fs-node-builtins": "4.57.2",
+        "@jsonjoy.com/fs-node-utils": "4.57.2"
+      },
       "engines": {
-        "node": ">=14"
+        "node": ">=10.0"
       },
       "funding": {
         "type": "github",
-        "url": "https://github.com/sponsors/gregberge"
+        "url": "https://github.com/sponsors/streamich"
       },
       "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
+        "tslib": "2"
       }
     },
-    "node_modules/@svgr/babel-plugin-remove-jsx-attribute": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-remove-jsx-attribute/-/babel-plugin-remove-jsx-attribute-8.0.0.tgz",
-      "integrity": "sha512-BcCkm/STipKvbCl6b7QFrMh/vx00vIP63k2eM66MfHJzPr6O2U0jYEViXkHJWqXqQYjdeA9cuCl5KWmlwjDvbA==",
-      "license": "MIT",
+    "node_modules/@jsonjoy.com/fs-node-utils": {
+      "version": "4.57.2",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/fs-node-utils/-/fs-node-utils-4.57.2.tgz",
+      "integrity": "sha512-rsPSJgekz43IlNbLyAM/Ab+ouYLWGp5DDBfYBNNEqDaSpsbXfthBn29Q4muFA9L0F+Z3mKo+CWlgSCXrf+mOyQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@jsonjoy.com/fs-node-builtins": "4.57.2"
+      },
       "engines": {
-        "node": ">=14"
+        "node": ">=10.0"
       },
       "funding": {
         "type": "github",
-        "url": "https://github.com/sponsors/gregberge"
+        "url": "https://github.com/sponsors/streamich"
       },
       "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
+        "tslib": "2"
       }
     },
-    "node_modules/@svgr/babel-plugin-remove-jsx-empty-expression": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-remove-jsx-empty-expression/-/babel-plugin-remove-jsx-empty-expression-8.0.0.tgz",
-      "integrity": "sha512-5BcGCBfBxB5+XSDSWnhTThfI9jcO5f0Ai2V24gZpG+wXF14BzwxxdDb4g6trdOux0rhibGs385BeFMSmxtS3uA==",
-      "license": "MIT",
+    "node_modules/@jsonjoy.com/fs-print": {
+      "version": "4.57.2",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/fs-print/-/fs-print-4.57.2.tgz",
+      "integrity": "sha512-wK9NSow48i4DbDl9F1CQE5TqnyZOJ04elU3WFG5aJ76p+YxO/ulyBBQvKsessPxdo381Bc2pcEoyPujMOhcRqQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@jsonjoy.com/fs-node-utils": "4.57.2",
+        "tree-dump": "^1.1.0"
+      },
       "engines": {
-        "node": ">=14"
+        "node": ">=10.0"
       },
       "funding": {
         "type": "github",
-        "url": "https://github.com/sponsors/gregberge"
+        "url": "https://github.com/sponsors/streamich"
       },
       "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
+        "tslib": "2"
       }
     },
-    "node_modules/@svgr/babel-plugin-replace-jsx-attribute-value": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-replace-jsx-attribute-value/-/babel-plugin-replace-jsx-attribute-value-8.0.0.tgz",
-      "integrity": "sha512-KVQ+PtIjb1BuYT3ht8M5KbzWBhdAjjUPdlMtpuw/VjT8coTrItWX6Qafl9+ji831JaJcu6PJNKCV0bp01lBNzQ==",
-      "license": "MIT",
+    "node_modules/@jsonjoy.com/fs-snapshot": {
+      "version": "4.57.2",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/fs-snapshot/-/fs-snapshot-4.57.2.tgz",
+      "integrity": "sha512-GdduDZuoP5V/QCgJkx9+BZ6SC0EZ/smXAdTS7PfMqgMTGXLlt/bH/FqMYaqB9JmLf05sJPtO0XRbAwwkEEPbVw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@jsonjoy.com/buffers": "^17.65.0",
+        "@jsonjoy.com/fs-node-utils": "4.57.2",
+        "@jsonjoy.com/json-pack": "^17.65.0",
+        "@jsonjoy.com/util": "^17.65.0"
+      },
       "engines": {
-        "node": ">=14"
+        "node": ">=10.0"
       },
       "funding": {
         "type": "github",
-        "url": "https://github.com/sponsors/gregberge"
+        "url": "https://github.com/sponsors/streamich"
       },
       "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
+        "tslib": "2"
       }
     },
-    "node_modules/@svgr/babel-plugin-svg-dynamic-title": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-svg-dynamic-title/-/babel-plugin-svg-dynamic-title-8.0.0.tgz",
-      "integrity": "sha512-omNiKqwjNmOQJ2v6ge4SErBbkooV2aAWwaPFs2vUY7p7GhVkzRkJ00kILXQvRhA6miHnNpXv7MRnnSjdRjK8og==",
-      "license": "MIT",
+    "node_modules/@jsonjoy.com/fs-snapshot/node_modules/@jsonjoy.com/base64": {
+      "version": "17.67.0",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/base64/-/base64-17.67.0.tgz",
+      "integrity": "sha512-5SEsJGsm15aP8TQGkDfJvz9axgPwAEm98S5DxOuYe8e1EbfajcDmgeXXzccEjh+mLnjqEKrkBdjHWS5vFNwDdw==",
+      "license": "Apache-2.0",
       "engines": {
-        "node": ">=14"
+        "node": ">=10.0"
       },
       "funding": {
         "type": "github",
-        "url": "https://github.com/sponsors/gregberge"
+        "url": "https://github.com/sponsors/streamich"
       },
       "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
+        "tslib": "2"
       }
     },
-    "node_modules/@svgr/babel-plugin-svg-em-dimensions": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-svg-em-dimensions/-/babel-plugin-svg-em-dimensions-8.0.0.tgz",
-      "integrity": "sha512-mURHYnu6Iw3UBTbhGwE/vsngtCIbHE43xCRK7kCw4t01xyGqb2Pd+WXekRRoFOBIY29ZoOhUCTEweDMdrjfi9g==",
-      "license": "MIT",
+    "node_modules/@jsonjoy.com/fs-snapshot/node_modules/@jsonjoy.com/codegen": {
+      "version": "17.67.0",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/codegen/-/codegen-17.67.0.tgz",
+      "integrity": "sha512-idnkUplROpdBOV0HMcwhsCUS5TRUi9poagdGs70A6S4ux9+/aPuKbh8+UYRTLYQHtXvAdNfQWXDqZEx5k4Dj2Q==",
+      "license": "Apache-2.0",
       "engines": {
-        "node": ">=14"
+        "node": ">=10.0"
       },
       "funding": {
         "type": "github",
-        "url": "https://github.com/sponsors/gregberge"
+        "url": "https://github.com/sponsors/streamich"
       },
       "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
+        "tslib": "2"
       }
     },
-    "node_modules/@svgr/babel-plugin-transform-react-native-svg": {
-      "version": "8.1.0",
-      "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-transform-react-native-svg/-/babel-plugin-transform-react-native-svg-8.1.0.tgz",
-      "integrity": "sha512-Tx8T58CHo+7nwJ+EhUwx3LfdNSG9R2OKfaIXXs5soiy5HtgoAEkDay9LIimLOcG8dJQH1wPZp/cnAv6S9CrR1Q==",
-      "license": "MIT",
+    "node_modules/@jsonjoy.com/fs-snapshot/node_modules/@jsonjoy.com/json-pack": {
+      "version": "17.67.0",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/json-pack/-/json-pack-17.67.0.tgz",
+      "integrity": "sha512-t0ejURcGaZsn1ClbJ/3kFqSOjlryd92eQY465IYrezsXmPcfHPE/av4twRSxf6WE+TkZgLY+71vCZbiIiFKA/w==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@jsonjoy.com/base64": "17.67.0",
+        "@jsonjoy.com/buffers": "17.67.0",
+        "@jsonjoy.com/codegen": "17.67.0",
+        "@jsonjoy.com/json-pointer": "17.67.0",
+        "@jsonjoy.com/util": "17.67.0",
+        "hyperdyperid": "^1.2.0",
+        "thingies": "^2.5.0",
+        "tree-dump": "^1.1.0"
+      },
       "engines": {
-        "node": ">=14"
+        "node": ">=10.0"
       },
       "funding": {
         "type": "github",
-        "url": "https://github.com/sponsors/gregberge"
+        "url": "https://github.com/sponsors/streamich"
       },
       "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
+        "tslib": "2"
       }
     },
-    "node_modules/@svgr/babel-plugin-transform-svg-component": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-transform-svg-component/-/babel-plugin-transform-svg-component-8.0.0.tgz",
-      "integrity": "sha512-DFx8xa3cZXTdb/k3kfPeaixecQLgKh5NVBMwD0AQxOzcZawK4oo1Jh9LbrcACUivsCA7TLG8eeWgrDXjTMhRmw==",
-      "license": "MIT",
+    "node_modules/@jsonjoy.com/fs-snapshot/node_modules/@jsonjoy.com/json-pointer": {
+      "version": "17.67.0",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/json-pointer/-/json-pointer-17.67.0.tgz",
+      "integrity": "sha512-+iqOFInH+QZGmSuaybBUNdh7yvNrXvqR+h3wjXm0N/3JK1EyyFAeGJvqnmQL61d1ARLlk/wJdFKSL+LHJ1eaUA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@jsonjoy.com/util": "17.67.0"
+      },
       "engines": {
-        "node": ">=12"
+        "node": ">=10.0"
       },
       "funding": {
         "type": "github",
-        "url": "https://github.com/sponsors/gregberge"
+        "url": "https://github.com/sponsors/streamich"
       },
       "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
+        "tslib": "2"
       }
     },
-    "node_modules/@svgr/babel-preset": {
-      "version": "8.1.0",
-      "resolved": "https://registry.npmjs.org/@svgr/babel-preset/-/babel-preset-8.1.0.tgz",
-      "integrity": "sha512-7EYDbHE7MxHpv4sxvnVPngw5fuR6pw79SkcrILHJ/iMpuKySNCl5W1qcwPEpU+LgyRXOaAFgH0KhwD18wwg6ug==",
-      "license": "MIT",
+    "node_modules/@jsonjoy.com/fs-snapshot/node_modules/@jsonjoy.com/util": {
+      "version": "17.67.0",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/util/-/util-17.67.0.tgz",
+      "integrity": "sha512-6+8xBaz1rLSohlGh68D1pdw3AwDi9xydm8QNlAFkvnavCJYSze+pxoW2VKP8p308jtlMRLs5NTHfPlZLd4w7ew==",
+      "license": "Apache-2.0",
       "dependencies": {
-        "@svgr/babel-plugin-add-jsx-attribute": "8.0.0",
-        "@svgr/babel-plugin-remove-jsx-attribute": "8.0.0",
-        "@svgr/babel-plugin-remove-jsx-empty-expression": "8.0.0",
-        "@svgr/babel-plugin-replace-jsx-attribute-value": "8.0.0",
-        "@svgr/babel-plugin-svg-dynamic-title": "8.0.0",
-        "@svgr/babel-plugin-svg-em-dimensions": "8.0.0",
-        "@svgr/babel-plugin-transform-react-native-svg": "8.1.0",
-        "@svgr/babel-plugin-transform-svg-component": "8.0.0"
+        "@jsonjoy.com/buffers": "17.67.0",
+        "@jsonjoy.com/codegen": "17.67.0"
       },
       "engines": {
-        "node": ">=14"
+        "node": ">=10.0"
       },
       "funding": {
         "type": "github",
-        "url": "https://github.com/sponsors/gregberge"
+        "url": "https://github.com/sponsors/streamich"
       },
       "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
+        "tslib": "2"
       }
     },
-    "node_modules/@svgr/core": {
-      "version": "8.1.0",
-      "resolved": "https://registry.npmjs.org/@svgr/core/-/core-8.1.0.tgz",
-      "integrity": "sha512-8QqtOQT5ACVlmsvKOJNEaWmRPmcojMOzCz4Hs2BGG/toAp/K38LcsMRyLp349glq5AzJbCEeimEoxaX6v/fLrA==",
-      "license": "MIT",
+    "node_modules/@jsonjoy.com/json-pack": {
+      "version": "1.21.0",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/json-pack/-/json-pack-1.21.0.tgz",
+      "integrity": "sha512-+AKG+R2cfZMShzrF2uQw34v3zbeDYUqnQ+jg7ORic3BGtfw9p/+N6RJbq/kkV8JmYZaINknaEQ2m0/f693ZPpg==",
+      "license": "Apache-2.0",
       "dependencies": {
-        "@babel/core": "^7.21.3",
-        "@svgr/babel-preset": "8.1.0",
-        "camelcase": "^6.2.0",
-        "cosmiconfig": "^8.1.3",
-        "snake-case": "^3.0.4"
+        "@jsonjoy.com/base64": "^1.1.2",
+        "@jsonjoy.com/buffers": "^1.2.0",
+        "@jsonjoy.com/codegen": "^1.0.0",
+        "@jsonjoy.com/json-pointer": "^1.0.2",
+        "@jsonjoy.com/util": "^1.9.0",
+        "hyperdyperid": "^1.2.0",
+        "thingies": "^2.5.0",
+        "tree-dump": "^1.1.0"
       },
       "engines": {
-        "node": ">=14"
+        "node": ">=10.0"
       },
       "funding": {
         "type": "github",
-        "url": "https://github.com/sponsors/gregberge"
+        "url": "https://github.com/sponsors/streamich"
+      },
+      "peerDependencies": {
+        "tslib": "2"
       }
     },
-    "node_modules/@svgr/hast-util-to-babel-ast": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/@svgr/hast-util-to-babel-ast/-/hast-util-to-babel-ast-8.0.0.tgz",
-      "integrity": "sha512-EbDKwO9GpfWP4jN9sGdYwPBU0kdomaPIL2Eu4YwmgP+sJeXT+L7bMwJUBnhzfH8Q2qMBqZ4fJwpCyYsAN3mt2Q==",
-      "license": "MIT",
-      "dependencies": {
-        "@babel/types": "^7.21.3",
-        "entities": "^4.4.0"
-      },
+    "node_modules/@jsonjoy.com/json-pack/node_modules/@jsonjoy.com/buffers": {
+      "version": "1.2.1",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/buffers/-/buffers-1.2.1.tgz",
+      "integrity": "sha512-12cdlDwX4RUM3QxmUbVJWqZ/mrK6dFQH4Zxq6+r1YXKXYBNgZXndx2qbCJwh3+WWkCSn67IjnlG3XYTvmvYtgA==",
+      "license": "Apache-2.0",
       "engines": {
-        "node": ">=14"
+        "node": ">=10.0"
       },
       "funding": {
         "type": "github",
-        "url": "https://github.com/sponsors/gregberge"
+        "url": "https://github.com/sponsors/streamich"
+      },
+      "peerDependencies": {
+        "tslib": "2"
       }
     },
-    "node_modules/@svgr/plugin-jsx": {
-      "version": "8.1.0",
-      "resolved": "https://registry.npmjs.org/@svgr/plugin-jsx/-/plugin-jsx-8.1.0.tgz",
-      "integrity": "sha512-0xiIyBsLlr8quN+WyuxooNW9RJ0Dpr8uOnH/xrCVO8GLUcwHISwj1AG0k+LFzteTkAA0GbX0kj9q6Dk70PTiPA==",
-      "license": "MIT",
+    "node_modules/@jsonjoy.com/json-pointer": {
+      "version": "1.0.2",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/json-pointer/-/json-pointer-1.0.2.tgz",
+      "integrity": "sha512-Fsn6wM2zlDzY1U+v4Nc8bo3bVqgfNTGcn6dMgs6FjrEnt4ZCe60o6ByKRjOGlI2gow0aE/Q41QOigdTqkyK5fg==",
+      "license": "Apache-2.0",
       "dependencies": {
-        "@babel/core": "^7.21.3",
-        "@svgr/babel-preset": "8.1.0",
-        "@svgr/hast-util-to-babel-ast": "8.0.0",
-        "svg-parser": "^2.0.4"
+        "@jsonjoy.com/codegen": "^1.0.0",
+        "@jsonjoy.com/util": "^1.9.0"
       },
       "engines": {
-        "node": ">=14"
+        "node": ">=10.0"
       },
       "funding": {
         "type": "github",
-        "url": "https://github.com/sponsors/gregberge"
+        "url": "https://github.com/sponsors/streamich"
       },
       "peerDependencies": {
-        "@svgr/core": "*"
+        "tslib": "2"
       }
     },
-    "node_modules/@svgr/plugin-svgo": {
-      "version": "8.1.0",
-      "resolved": "https://registry.npmjs.org/@svgr/plugin-svgo/-/plugin-svgo-8.1.0.tgz",
-      "integrity": "sha512-Ywtl837OGO9pTLIN/onoWLmDQ4zFUycI1g76vuKGEz6evR/ZTJlJuz3G/fIkb6OVBJ2g0o6CGJzaEjfmEo3AHA==",
-      "license": "MIT",
+    "node_modules/@jsonjoy.com/util": {
+      "version": "1.9.0",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/util/-/util-1.9.0.tgz",
+      "integrity": "sha512-pLuQo+VPRnN8hfPqUTLTHk126wuYdXVxE6aDmjSeV4NCAgyxWbiOIeNJVtID3h1Vzpoi9m4jXezf73I6LgabgQ==",
+      "license": "Apache-2.0",
       "dependencies": {
-        "cosmiconfig": "^8.1.3",
-        "deepmerge": "^4.3.1",
-        "svgo": "^3.0.2"
+        "@jsonjoy.com/buffers": "^1.0.0",
+        "@jsonjoy.com/codegen": "^1.0.0"
       },
       "engines": {
-        "node": ">=14"
+        "node": ">=10.0"
       },
       "funding": {
         "type": "github",
-        "url": "https://github.com/sponsors/gregberge"
+        "url": "https://github.com/sponsors/streamich"
       },
       "peerDependencies": {
-        "@svgr/core": "*"
+        "tslib": "2"
       }
     },
-    "node_modules/@svgr/webpack": {
-      "version": "8.1.0",
-      "resolved": "https://registry.npmjs.org/@svgr/webpack/-/webpack-8.1.0.tgz",
-      "integrity": "sha512-LnhVjMWyMQV9ZmeEy26maJk+8HTIbd59cH4F2MJ439k9DqejRisfFNGAPvRYlKETuh9LrImlS8aKsBgKjMA8WA==",
-      "license": "MIT",
-      "dependencies": {
-        "@babel/core": "^7.21.3",
-        "@babel/plugin-transform-react-constant-elements": "^7.21.3",
-        "@babel/preset-env": "^7.20.2",
-        "@babel/preset-react": "^7.18.6",
-        "@babel/preset-typescript": "^7.21.0",
-        "@svgr/core": "8.1.0",
-        "@svgr/plugin-jsx": "8.1.0",
-        "@svgr/plugin-svgo": "8.1.0"
-      },
+    "node_modules/@jsonjoy.com/util/node_modules/@jsonjoy.com/buffers": {
+      "version": "1.2.1",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/buffers/-/buffers-1.2.1.tgz",
+      "integrity": "sha512-12cdlDwX4RUM3QxmUbVJWqZ/mrK6dFQH4Zxq6+r1YXKXYBNgZXndx2qbCJwh3+WWkCSn67IjnlG3XYTvmvYtgA==",
+      "license": "Apache-2.0",
       "engines": {
-        "node": ">=14"
+        "node": ">=10.0"
       },
       "funding": {
         "type": "github",
-        "url": "https://github.com/sponsors/gregberge"
+        "url": "https://github.com/sponsors/streamich"
+      },
+      "peerDependencies": {
+        "tslib": "2"
       }
     },
-    "node_modules/@szmarczak/http-timer": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-5.0.1.tgz",
-      "integrity": "sha512-+PmQX0PiAYPMeVYe237LJAYvOMYW1j2rH5YROyS3b4CTVJum34HfRvKvAzozHAQG0TnHNdUfY9nCeUyRAs//cw==",
+    "node_modules/@leichtgewicht/ip-codec": {
+      "version": "2.0.5",
+      "resolved": "https://registry.facebook.net/@leichtgewicht/ip-codec/-/ip-codec-2.0.5.tgz",
+      "integrity": "sha512-Vo+PSpZG2/fmgmiNzYK9qWRh8h/CHrwD0mo1h1DzL4yzHNSfWYujGTYsWGreD000gcgmZ7K4Ys6Tx9TxtsKdDw==",
+      "license": "MIT"
+    },
+    "node_modules/@mdx-js/mdx": {
+      "version": "3.1.1",
+      "resolved": "https://registry.facebook.net/@mdx-js/mdx/-/mdx-3.1.1.tgz",
+      "integrity": "sha512-f6ZO2ifpwAQIpzGWaBQT2TXxPv6z3RBzQKpVftEWN78Vl/YweF1uwussDx8ECAXVtr3Rs89fKyG9YlzUs9DyGQ==",
       "license": "MIT",
       "dependencies": {
-        "defer-to-connect": "^2.0.1"
+        "@types/estree": "^1.0.0",
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/mdx": "^2.0.0",
+        "acorn": "^8.0.0",
+        "collapse-white-space": "^2.0.0",
+        "devlop": "^1.0.0",
+        "estree-util-is-identifier-name": "^3.0.0",
+        "estree-util-scope": "^1.0.0",
+        "estree-walker": "^3.0.0",
+        "hast-util-to-jsx-runtime": "^2.0.0",
+        "markdown-extensions": "^2.0.0",
+        "recma-build-jsx": "^1.0.0",
+        "recma-jsx": "^1.0.0",
+        "recma-stringify": "^1.0.0",
+        "rehype-recma": "^1.0.0",
+        "remark-mdx": "^3.0.0",
+        "remark-parse": "^11.0.0",
+        "remark-rehype": "^11.0.0",
+        "source-map": "^0.7.0",
+        "unified": "^11.0.0",
+        "unist-util-position-from-estree": "^2.0.0",
+        "unist-util-stringify-position": "^4.0.0",
+        "unist-util-visit": "^5.0.0",
+        "vfile": "^6.0.0"
       },
-      "engines": {
-        "node": ">=14.16"
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/@trysound/sax": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/@trysound/sax/-/sax-0.2.0.tgz",
-      "integrity": "sha512-L7z9BgrNEcYyUYtF+HaEfiS5ebkh9jXqbszz7pC0hRBPaatV0XjSD3+eHrpqFemQfgwiFF0QPIarnIihIDn7OA==",
-      "license": "ISC",
+    "node_modules/@mdx-js/mdx/node_modules/source-map": {
+      "version": "0.7.6",
+      "resolved": "https://registry.facebook.net/source-map/-/source-map-0.7.6.tgz",
+      "integrity": "sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ==",
+      "license": "BSD-3-Clause",
       "engines": {
-        "node": ">=10.13.0"
+        "node": ">= 12"
       }
     },
-    "node_modules/@types/acorn": {
-      "version": "4.0.6",
-      "resolved": "https://registry.npmjs.org/@types/acorn/-/acorn-4.0.6.tgz",
-      "integrity": "sha512-veQTnWP+1D/xbxVrPC3zHnCZRjSrKfhbMUlEA43iMZLu7EsnTtkJklIuwrCPbOi8YkvDQAiW05VQQFvvz9oieQ==",
+    "node_modules/@mdx-js/react": {
+      "version": "3.1.1",
+      "resolved": "https://registry.facebook.net/@mdx-js/react/-/react-3.1.1.tgz",
+      "integrity": "sha512-f++rKLQgUVYDAtECQ6fn/is15GkEH9+nZPM3MS0RcxVqoTfawHvDlSCH7JbMhAM6uJ32v3eXLvLmLvjGu7PTQw==",
       "license": "MIT",
       "dependencies": {
-        "@types/estree": "*"
+        "@types/mdx": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      },
+      "peerDependencies": {
+        "@types/react": ">=16",
+        "react": ">=16"
       }
     },
-    "node_modules/@types/body-parser": {
-      "version": "1.19.5",
-      "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.5.tgz",
-      "integrity": "sha512-fB3Zu92ucau0iQ0JMCFQE7b/dv8Ot07NI3KaZIkIUNXq82k4eBAqUaneXfleGY9JWskeS9y+u0nXMyspcuQrCg==",
+    "node_modules/@noble/hashes": {
+      "version": "1.4.0",
+      "resolved": "https://registry.facebook.net/@noble/hashes/-/hashes-1.4.0.tgz",
+      "integrity": "sha512-V1JJ1WTRUqHHrOSh597hURcMqVKVGL/ea3kv0gSnEdsEZ0/+VyPghM1lMNGc00z7CIQorSvbKpuJkxvuHbvdbg==",
       "license": "MIT",
-      "dependencies": {
-        "@types/connect": "*",
-        "@types/node": "*"
+      "engines": {
+        "node": ">= 16"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
       }
     },
-    "node_modules/@types/bonjour": {
-      "version": "3.5.13",
-      "resolved": "https://registry.npmjs.org/@types/bonjour/-/bonjour-3.5.13.tgz",
-      "integrity": "sha512-z9fJ5Im06zvUL548KvYNecEVlA7cVDkGUi6kZusb04mpyEFKCIZJvloCcmpmLaIahDpOQGHaHmG6imtPMmPXGQ==",
+    "node_modules/@nodelib/fs.scandir": {
+      "version": "2.1.5",
+      "resolved": "https://registry.facebook.net/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
+      "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
       "license": "MIT",
       "dependencies": {
-        "@types/node": "*"
+        "@nodelib/fs.stat": "2.0.5",
+        "run-parallel": "^1.1.9"
+      },
+      "engines": {
+        "node": ">= 8"
       }
     },
-    "node_modules/@types/connect": {
-      "version": "3.4.38",
-      "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.38.tgz",
-      "integrity": "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==",
+    "node_modules/@nodelib/fs.stat": {
+      "version": "2.0.5",
+      "resolved": "https://registry.facebook.net/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
+      "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
       "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
+      "engines": {
+        "node": ">= 8"
       }
     },
-    "node_modules/@types/connect-history-api-fallback": {
-      "version": "1.5.4",
-      "resolved": "https://registry.npmjs.org/@types/connect-history-api-fallback/-/connect-history-api-fallback-1.5.4.tgz",
-      "integrity": "sha512-n6Cr2xS1h4uAulPRdlw6Jl6s1oG8KrVilPN2yUITEs+K48EzMJJ3W1xy8K5eWuFvjp3R74AOIGSmp2UfBJ8HFw==",
+    "node_modules/@nodelib/fs.walk": {
+      "version": "1.2.8",
+      "resolved": "https://registry.facebook.net/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
+      "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
       "license": "MIT",
       "dependencies": {
-        "@types/express-serve-static-core": "*",
-        "@types/node": "*"
+        "@nodelib/fs.scandir": "2.1.5",
+        "fastq": "^1.6.0"
+      },
+      "engines": {
+        "node": ">= 8"
       }
     },
-    "node_modules/@types/debug": {
-      "version": "4.1.12",
-      "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.12.tgz",
-      "integrity": "sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ==",
+    "node_modules/@peculiar/asn1-cms": {
+      "version": "2.6.1",
+      "resolved": "https://registry.facebook.net/@peculiar/asn1-cms/-/asn1-cms-2.6.1.tgz",
+      "integrity": "sha512-vdG4fBF6Lkirkcl53q6eOdn3XYKt+kJTG59edgRZORlg/3atWWEReRCx5rYE1ZzTTX6vLK5zDMjHh7vbrcXGtw==",
       "license": "MIT",
       "dependencies": {
-        "@types/ms": "*"
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.1",
+        "@peculiar/asn1-x509-attr": "^2.6.1",
+        "asn1js": "^3.0.6",
+        "tslib": "^2.8.1"
       }
     },
-    "node_modules/@types/eslint": {
-      "version": "9.6.1",
-      "resolved": "https://registry.npmjs.org/@types/eslint/-/eslint-9.6.1.tgz",
-      "integrity": "sha512-FXx2pKgId/WyYo2jXw63kk7/+TY7u7AziEJxJAnSFzHlqTAS3Ync6SvgYAN/k4/PQpnnVuzoMuVnByKK2qp0ag==",
+    "node_modules/@peculiar/asn1-csr": {
+      "version": "2.6.1",
+      "resolved": "https://registry.facebook.net/@peculiar/asn1-csr/-/asn1-csr-2.6.1.tgz",
+      "integrity": "sha512-WRWnKfIocHyzFYQTka8O/tXCiBquAPSrRjXbOkHbO4qdmS6loffCEGs+rby6WxxGdJCuunnhS2duHURhjyio6w==",
       "license": "MIT",
       "dependencies": {
-        "@types/estree": "*",
-        "@types/json-schema": "*"
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.1",
+        "asn1js": "^3.0.6",
+        "tslib": "^2.8.1"
       }
     },
-    "node_modules/@types/eslint-scope": {
-      "version": "3.7.7",
-      "resolved": "https://registry.npmjs.org/@types/eslint-scope/-/eslint-scope-3.7.7.tgz",
-      "integrity": "sha512-MzMFlSLBqNF2gcHWO0G1vP/YQyfvrxZ0bF+u7mzUdZ1/xK4A4sru+nraZz5i3iEIk1l1uyicaDVTB4QbbEkAYg==",
+    "node_modules/@peculiar/asn1-ecc": {
+      "version": "2.6.1",
+      "resolved": "https://registry.facebook.net/@peculiar/asn1-ecc/-/asn1-ecc-2.6.1.tgz",
+      "integrity": "sha512-+Vqw8WFxrtDIN5ehUdvlN2m73exS2JVG0UAyfVB31gIfor3zWEAQPD+K9ydCxaj3MLen9k0JhKpu9LqviuCE1g==",
       "license": "MIT",
       "dependencies": {
-        "@types/eslint": "*",
-        "@types/estree": "*"
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.1",
+        "asn1js": "^3.0.6",
+        "tslib": "^2.8.1"
       }
     },
-    "node_modules/@types/estree": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.6.tgz",
-      "integrity": "sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==",
-      "license": "MIT"
-    },
-    "node_modules/@types/estree-jsx": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/@types/estree-jsx/-/estree-jsx-1.0.5.tgz",
-      "integrity": "sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg==",
+    "node_modules/@peculiar/asn1-pfx": {
+      "version": "2.6.1",
+      "resolved": "https://registry.facebook.net/@peculiar/asn1-pfx/-/asn1-pfx-2.6.1.tgz",
+      "integrity": "sha512-nB5jVQy3MAAWvq0KY0R2JUZG8bO/bTLpnwyOzXyEh/e54ynGTatAR+csOnXkkVD9AFZ2uL8Z7EV918+qB1qDvw==",
       "license": "MIT",
       "dependencies": {
-        "@types/estree": "*"
+        "@peculiar/asn1-cms": "^2.6.1",
+        "@peculiar/asn1-pkcs8": "^2.6.1",
+        "@peculiar/asn1-rsa": "^2.6.1",
+        "@peculiar/asn1-schema": "^2.6.0",
+        "asn1js": "^3.0.6",
+        "tslib": "^2.8.1"
       }
     },
-    "node_modules/@types/express": {
-      "version": "4.17.21",
-      "resolved": "https://registry.npmjs.org/@types/express/-/express-4.17.21.tgz",
-      "integrity": "sha512-ejlPM315qwLpaQlQDTjPdsUFSc6ZsP4AN6AlWnogPjQ7CVi7PYF3YVz+CY3jE2pwYf7E/7HlDAN0rV2GxTG0HQ==",
+    "node_modules/@peculiar/asn1-pkcs8": {
+      "version": "2.6.1",
+      "resolved": "https://registry.facebook.net/@peculiar/asn1-pkcs8/-/asn1-pkcs8-2.6.1.tgz",
+      "integrity": "sha512-JB5iQ9Izn5yGMw3ZG4Nw3Xn/hb/G38GYF3lf7WmJb8JZUydhVGEjK/ZlFSWhnlB7K/4oqEs8HnfFIKklhR58Tw==",
       "license": "MIT",
       "dependencies": {
-        "@types/body-parser": "*",
-        "@types/express-serve-static-core": "^4.17.33",
-        "@types/qs": "*",
-        "@types/serve-static": "*"
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.1",
+        "asn1js": "^3.0.6",
+        "tslib": "^2.8.1"
       }
     },
-    "node_modules/@types/express-serve-static-core": {
-      "version": "5.0.3",
-      "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-5.0.3.tgz",
-      "integrity": "sha512-JEhMNwUJt7bw728CydvYzntD0XJeTmDnvwLlbfbAhE7Tbslm/ax6bdIiUwTgeVlZTsJQPwZwKpAkyDtIjsvx3g==",
+    "node_modules/@peculiar/asn1-pkcs9": {
+      "version": "2.6.1",
+      "resolved": "https://registry.facebook.net/@peculiar/asn1-pkcs9/-/asn1-pkcs9-2.6.1.tgz",
+      "integrity": "sha512-5EV8nZoMSxeWmcxWmmcolg22ojZRgJg+Y9MX2fnE2bGRo5KQLqV5IL9kdSQDZxlHz95tHvIq9F//bvL1OeNILw==",
       "license": "MIT",
       "dependencies": {
-        "@types/node": "*",
-        "@types/qs": "*",
-        "@types/range-parser": "*",
-        "@types/send": "*"
+        "@peculiar/asn1-cms": "^2.6.1",
+        "@peculiar/asn1-pfx": "^2.6.1",
+        "@peculiar/asn1-pkcs8": "^2.6.1",
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.1",
+        "@peculiar/asn1-x509-attr": "^2.6.1",
+        "asn1js": "^3.0.6",
+        "tslib": "^2.8.1"
       }
     },
-    "node_modules/@types/express/node_modules/@types/express-serve-static-core": {
-      "version": "4.19.6",
-      "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-4.19.6.tgz",
-      "integrity": "sha512-N4LZ2xG7DatVqhCZzOGb1Yi5lMbXSZcmdLDe9EzSndPV2HpWYWzRbaerl2n27irrm94EPpprqa8KpskPT085+A==",
+    "node_modules/@peculiar/asn1-rsa": {
+      "version": "2.6.1",
+      "resolved": "https://registry.facebook.net/@peculiar/asn1-rsa/-/asn1-rsa-2.6.1.tgz",
+      "integrity": "sha512-1nVMEh46SElUt5CB3RUTV4EG/z7iYc7EoaDY5ECwganibQPkZ/Y2eMsTKB/LeyrUJ+W/tKoD9WUqIy8vB+CEdA==",
       "license": "MIT",
       "dependencies": {
-        "@types/node": "*",
-        "@types/qs": "*",
-        "@types/range-parser": "*",
-        "@types/send": "*"
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.1",
+        "asn1js": "^3.0.6",
+        "tslib": "^2.8.1"
       }
     },
-    "node_modules/@types/gtag.js": {
-      "version": "0.0.12",
-      "resolved": "https://registry.npmjs.org/@types/gtag.js/-/gtag.js-0.0.12.tgz",
-      "integrity": "sha512-YQV9bUsemkzG81Ea295/nF/5GijnD2Af7QhEofh7xu+kvCN6RdodgNwwGWXB5GMI3NoyvQo0odNctoH/qLMIpg==",
-      "license": "MIT"
-    },
-    "node_modules/@types/hast": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/@types/hast/-/hast-3.0.4.tgz",
-      "integrity": "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==",
+    "node_modules/@peculiar/asn1-schema": {
+      "version": "2.6.0",
+      "resolved": "https://registry.facebook.net/@peculiar/asn1-schema/-/asn1-schema-2.6.0.tgz",
+      "integrity": "sha512-xNLYLBFTBKkCzEZIw842BxytQQATQv+lDTCEMZ8C196iJcJJMBUZxrhSTxLaohMyKK8QlzRNTRkUmanucnDSqg==",
       "license": "MIT",
       "dependencies": {
-        "@types/unist": "*"
+        "asn1js": "^3.0.6",
+        "pvtsutils": "^1.3.6",
+        "tslib": "^2.8.1"
       }
     },
-    "node_modules/@types/history": {
-      "version": "4.7.11",
-      "resolved": "https://registry.npmjs.org/@types/history/-/history-4.7.11.tgz",
-      "integrity": "sha512-qjDJRrmvBMiTx+jyLxvLfJU7UznFuokDv4f3WRuriHKERccVpFU+8XMQUAbDzoiJCsmexxRExQeMwwCdamSKDA==",
-      "license": "MIT"
-    },
-    "node_modules/@types/html-minifier-terser": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/@types/html-minifier-terser/-/html-minifier-terser-6.1.0.tgz",
-      "integrity": "sha512-oh/6byDPnL1zeNXFrDXFLyZjkr1MsBG667IM792caf1L2UPOOMf65NFzjUH/ltyfwjAGfs1rsX1eftK0jC/KIg==",
-      "license": "MIT"
-    },
-    "node_modules/@types/http-cache-semantics": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.0.4.tgz",
-      "integrity": "sha512-1m0bIFVc7eJWyve9S0RnuRgcQqF/Xd5QsUZAZeQFr1Q3/p9JWoQQEqmVy+DPTNpGXwhgIetAoYF8JSc33q29QA==",
-      "license": "MIT"
+    "node_modules/@peculiar/asn1-x509": {
+      "version": "2.6.1",
+      "resolved": "https://registry.facebook.net/@peculiar/asn1-x509/-/asn1-x509-2.6.1.tgz",
+      "integrity": "sha512-O9jT5F1A2+t3r7C4VT7LYGXqkGLK7Kj1xFpz7U0isPrubwU5PbDoyYtx6MiGst29yq7pXN5vZbQFKRCP+lLZlA==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.6.0",
+        "asn1js": "^3.0.6",
+        "pvtsutils": "^1.3.6",
+        "tslib": "^2.8.1"
+      }
     },
-    "node_modules/@types/http-errors": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.4.tgz",
-      "integrity": "sha512-D0CFMMtydbJAegzOyHjtiKPLlvnm3iTZyZRSZoLq2mRhDdmLfIWOCYPfQJ4cu2erKghU++QvjcUjp/5h7hESpA==",
-      "license": "MIT"
+    "node_modules/@peculiar/asn1-x509-attr": {
+      "version": "2.6.1",
+      "resolved": "https://registry.facebook.net/@peculiar/asn1-x509-attr/-/asn1-x509-attr-2.6.1.tgz",
+      "integrity": "sha512-tlW6cxoHwgcQghnJwv3YS+9OO1737zgPogZ+CgWRUK4roEwIPzRH4JEiG770xe5HX2ATfCpmX60gurfWIF9dcQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.1",
+        "asn1js": "^3.0.6",
+        "tslib": "^2.8.1"
+      }
     },
-    "node_modules/@types/http-proxy": {
-      "version": "1.17.15",
-      "resolved": "https://registry.npmjs.org/@types/http-proxy/-/http-proxy-1.17.15.tgz",
-      "integrity": "sha512-25g5atgiVNTIv0LBDTg1H74Hvayx0ajtJPLLcYE3whFv75J0pWNtOBzaXJQgDTmrX1bx5U9YC2w/n65BN1HwRQ==",
+    "node_modules/@peculiar/x509": {
+      "version": "1.14.3",
+      "resolved": "https://registry.facebook.net/@peculiar/x509/-/x509-1.14.3.tgz",
+      "integrity": "sha512-C2Xj8FZ0uHWeCXXqX5B4/gVFQmtSkiuOolzAgutjTfseNOHT3pUjljDZsTSxXFGgio54bCzVFqmEOUrIVk8RDA==",
       "license": "MIT",
       "dependencies": {
-        "@types/node": "*"
+        "@peculiar/asn1-cms": "^2.6.0",
+        "@peculiar/asn1-csr": "^2.6.0",
+        "@peculiar/asn1-ecc": "^2.6.0",
+        "@peculiar/asn1-pkcs9": "^2.6.0",
+        "@peculiar/asn1-rsa": "^2.6.0",
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.0",
+        "pvtsutils": "^1.3.6",
+        "reflect-metadata": "^0.2.2",
+        "tslib": "^2.8.1",
+        "tsyringe": "^4.10.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
       }
     },
-    "node_modules/@types/istanbul-lib-coverage": {
-      "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz",
-      "integrity": "sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==",
-      "license": "MIT"
+    "node_modules/@pnpm/config.env-replace": {
+      "version": "1.1.0",
+      "resolved": "https://registry.facebook.net/@pnpm/config.env-replace/-/config.env-replace-1.1.0.tgz",
+      "integrity": "sha512-htyl8TWnKL7K/ESFa1oW2UB5lVDxuF5DpM7tBi6Hu2LNL3mWkIzNLG6N4zoCUP1lCKNxWy/3iu8mS8MvToGd6w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.22.0"
+      }
     },
-    "node_modules/@types/istanbul-lib-report": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.3.tgz",
-      "integrity": "sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA==",
+    "node_modules/@pnpm/network.ca-file": {
+      "version": "1.0.2",
+      "resolved": "https://registry.facebook.net/@pnpm/network.ca-file/-/network.ca-file-1.0.2.tgz",
+      "integrity": "sha512-YcPQ8a0jwYU9bTdJDpXjMi7Brhkr1mXsXrUJvjqM2mQDgkRiz8jFaQGOdaLxgjtUfQgZhKy/O3cG/YwmgKaxLA==",
       "license": "MIT",
       "dependencies": {
-        "@types/istanbul-lib-coverage": "*"
+        "graceful-fs": "4.2.10"
+      },
+      "engines": {
+        "node": ">=12.22.0"
       }
     },
-    "node_modules/@types/istanbul-reports": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/@types/istanbul-reports/-/istanbul-reports-3.0.4.tgz",
-      "integrity": "sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==",
+    "node_modules/@pnpm/network.ca-file/node_modules/graceful-fs": {
+      "version": "4.2.10",
+      "resolved": "https://registry.facebook.net/graceful-fs/-/graceful-fs-4.2.10.tgz",
+      "integrity": "sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==",
+      "license": "ISC"
+    },
+    "node_modules/@pnpm/npm-conf": {
+      "version": "3.0.2",
+      "resolved": "https://registry.facebook.net/@pnpm/npm-conf/-/npm-conf-3.0.2.tgz",
+      "integrity": "sha512-h104Kh26rR8tm+a3Qkc5S4VLYint3FE48as7+/5oCEcKR2idC/pF1G6AhIXKI+eHPJa/3J9i5z0Al47IeGHPkA==",
       "license": "MIT",
       "dependencies": {
-        "@types/istanbul-lib-report": "*"
+        "@pnpm/config.env-replace": "^1.1.0",
+        "@pnpm/network.ca-file": "^1.0.1",
+        "config-chain": "^1.1.11"
+      },
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/@types/json-schema": {
-      "version": "7.0.15",
-      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
-      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+    "node_modules/@polka/url": {
+      "version": "1.0.0-next.29",
+      "resolved": "https://registry.facebook.net/@polka/url/-/url-1.0.0-next.29.tgz",
+      "integrity": "sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww==",
       "license": "MIT"
     },
-    "node_modules/@types/mdast": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.4.tgz",
-      "integrity": "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==",
-      "license": "MIT",
+    "node_modules/@sideway/address": {
+      "version": "4.1.5",
+      "resolved": "https://registry.facebook.net/@sideway/address/-/address-4.1.5.tgz",
+      "integrity": "sha512-IqO/DUQHUkPeixNQ8n0JA6102hT9CmaljNTPmQ1u8MEhBo/R4Q8eKLN/vGZxuebwOroDB4cbpjheD4+/sKFK4Q==",
+      "license": "BSD-3-Clause",
       "dependencies": {
-        "@types/unist": "*"
+        "@hapi/hoek": "^9.0.0"
       }
     },
-    "node_modules/@types/mdx": {
-      "version": "2.0.13",
-      "resolved": "https://registry.npmjs.org/@types/mdx/-/mdx-2.0.13.tgz",
-      "integrity": "sha512-+OWZQfAYyio6YkJb3HLxDrvnx6SWWDbC0zVPfBRzUk0/nqoDyf6dNxQi3eArPe8rJ473nobTMQ/8Zk+LxJ+Yuw==",
-      "license": "MIT"
+    "node_modules/@sideway/formula": {
+      "version": "3.0.1",
+      "resolved": "https://registry.facebook.net/@sideway/formula/-/formula-3.0.1.tgz",
+      "integrity": "sha512-/poHZJJVjx3L+zVD6g9KgHfYnb443oi7wLu/XKojDviHy6HOEOA6z1Trk5aR1dGcmPenJEgb2sK2I80LeS3MIg==",
+      "license": "BSD-3-Clause"
     },
-    "node_modules/@types/mime": {
-      "version": "1.3.5",
-      "resolved": "https://registry.npmjs.org/@types/mime/-/mime-1.3.5.tgz",
-      "integrity": "sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==",
-      "license": "MIT"
+    "node_modules/@sideway/pinpoint": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/@sideway/pinpoint/-/pinpoint-2.0.0.tgz",
+      "integrity": "sha512-RNiOoTPkptFtSVzQevY/yWtZwf/RxyVnPy/OcA9HBM3MlGDnBEYL5B41H0MTn0Uec8Hi+2qUtTfG2WWZBmMejQ==",
+      "license": "BSD-3-Clause"
     },
-    "node_modules/@types/ms": {
-      "version": "0.7.34",
-      "resolved": "https://registry.npmjs.org/@types/ms/-/ms-0.7.34.tgz",
-      "integrity": "sha512-nG96G3Wp6acyAgJqGasjODb+acrI7KltPiRxzHPXnP3NgI28bpQDRv53olbqGXbfcgF5aiiHmO3xpwEpS5Ld9g==",
+    "node_modules/@sinclair/typebox": {
+      "version": "0.27.10",
+      "resolved": "https://registry.facebook.net/@sinclair/typebox/-/typebox-0.27.10.tgz",
+      "integrity": "sha512-MTBk/3jGLNB2tVxv6uLlFh1iu64iYOQ2PbdOSK3NW8JZsmlaOh2q6sdtKowBhfw8QFLmYNzTW4/oK4uATIi6ZA==",
       "license": "MIT"
     },
-    "node_modules/@types/node": {
-      "version": "22.10.4",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.10.4.tgz",
-      "integrity": "sha512-99l6wv4HEzBQhvaU/UGoeBoCK61SCROQaCCGyQSgX2tEQ3rKkNZ2S7CEWnS/4s1LV+8ODdK21UeyR1fHP2mXug==",
+    "node_modules/@sindresorhus/is": {
+      "version": "4.6.0",
+      "resolved": "https://registry.facebook.net/@sindresorhus/is/-/is-4.6.0.tgz",
+      "integrity": "sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==",
       "license": "MIT",
-      "dependencies": {
-        "undici-types": "~6.20.0"
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sindresorhus/is?sponsor=1"
       }
     },
-    "node_modules/@types/node-forge": {
-      "version": "1.3.11",
-      "resolved": "https://registry.npmjs.org/@types/node-forge/-/node-forge-1.3.11.tgz",
-      "integrity": "sha512-FQx220y22OKNTqaByeBGqHWYz4cl94tpcxeFdvBo3wjG6XPBuZ0BNgNZRV5J5TFmmcsJ4IzsLkmGRiQbnYsBEQ==",
+    "node_modules/@slorber/remark-comment": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/@slorber/remark-comment/-/remark-comment-1.0.0.tgz",
+      "integrity": "sha512-RCE24n7jsOj1M0UPvIQCHTe7fI0sFL4S2nwKVWwHyVr/wI/H8GosgsJGyhnsZoGFnD/P2hLf1mSbrrgSLN93NA==",
       "license": "MIT",
       "dependencies": {
-        "@types/node": "*"
+        "micromark-factory-space": "^1.0.0",
+        "micromark-util-character": "^1.1.0",
+        "micromark-util-symbol": "^1.0.1"
       }
     },
-    "node_modules/@types/parse-json": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/@types/parse-json/-/parse-json-4.0.2.tgz",
-      "integrity": "sha512-dISoDXWWQwUquiKsyZ4Ng+HX2KsPL7LyHKHQwgGFEA3IaKac4Obd+h2a/a6waisAoepJlBcx9paWqjA8/HVjCw==",
-      "license": "MIT"
-    },
-    "node_modules/@types/prismjs": {
-      "version": "1.26.5",
-      "resolved": "https://registry.npmjs.org/@types/prismjs/-/prismjs-1.26.5.tgz",
-      "integrity": "sha512-AUZTa7hQ2KY5L7AmtSiqxlhWxb4ina0yd8hNbl4TWuqnv/pFP0nDMb3YrfSBf4hJVGLh2YEIBfKaBW/9UEl6IQ==",
-      "license": "MIT"
+    "node_modules/@slorber/remark-comment/node_modules/micromark-factory-space": {
+      "version": "1.1.0",
+      "resolved": "https://registry.facebook.net/micromark-factory-space/-/micromark-factory-space-1.1.0.tgz",
+      "integrity": "sha512-cRzEj7c0OL4Mw2v6nwzttyOZe8XY/Z8G0rzmWQZTBi/jjwyw/U4uqKtUORXQrR5bAZZnbTI/feRV/R7hc4jQYQ==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
     },
-    "node_modules/@types/prop-types": {
-      "version": "15.7.14",
-      "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.14.tgz",
-      "integrity": "sha512-gNMvNH49DJ7OJYv+KAKn0Xp45p8PLl6zo2YnvDIbTd4J6MER2BmWN49TG7n9LvkyihINxeKW8+3bfS2yDC9dzQ==",
-      "license": "MIT"
+    "node_modules/@slorber/remark-comment/node_modules/micromark-util-character": {
+      "version": "1.2.0",
+      "resolved": "https://registry.facebook.net/micromark-util-character/-/micromark-util-character-1.2.0.tgz",
+      "integrity": "sha512-lXraTwcX3yH/vMDaFWCQJP1uIszLVebzUa3ZHdrgxr7KEU/9mL4mVgCpGbyhvNLNlauROiNUq7WN5u7ndbY6xg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
     },
-    "node_modules/@types/qs": {
-      "version": "6.9.17",
-      "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.9.17.tgz",
-      "integrity": "sha512-rX4/bPcfmvxHDv0XjfJELTTr+iB+tn032nPILqHm5wbthUUUuVtNGGqzhya9XUxjTP8Fpr0qYgSZZKxGY++svQ==",
+    "node_modules/@slorber/remark-comment/node_modules/micromark-util-symbol": {
+      "version": "1.1.0",
+      "resolved": "https://registry.facebook.net/micromark-util-symbol/-/micromark-util-symbol-1.1.0.tgz",
+      "integrity": "sha512-uEjpEYY6KMs1g7QfJ2eX1SQEV+ZT4rUD3UcF6l57acZvLNK7PBZL+ty82Z1qhK1/yXIY4bdx04FKMgR0g4IAag==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
       "license": "MIT"
     },
-    "node_modules/@types/range-parser": {
-      "version": "1.2.7",
-      "resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.7.tgz",
-      "integrity": "sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==",
+    "node_modules/@slorber/remark-comment/node_modules/micromark-util-types": {
+      "version": "1.1.0",
+      "resolved": "https://registry.facebook.net/micromark-util-types/-/micromark-util-types-1.1.0.tgz",
+      "integrity": "sha512-ukRBgie8TIAcacscVHSiddHjO4k/q3pnedmzMQ4iwDcK0FtFCohKOlFbaOL/mPgfnPsL3C1ZyxJa4sbWrBl3jg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
       "license": "MIT"
     },
-    "node_modules/@types/react": {
-      "version": "18.3.18",
-      "resolved": "https://registry.npmjs.org/@types/react/-/react-18.3.18.tgz",
-      "integrity": "sha512-t4yC+vtgnkYjNSKlFx1jkAhH8LgTo2N/7Qvi83kdEaUtMDiwpbLAktKDaAMlRcJ5eSxZkH74eEGt1ky31d7kfQ==",
+    "node_modules/@svgr/babel-plugin-add-jsx-attribute": {
+      "version": "8.0.0",
+      "resolved": "https://registry.facebook.net/@svgr/babel-plugin-add-jsx-attribute/-/babel-plugin-add-jsx-attribute-8.0.0.tgz",
+      "integrity": "sha512-b9MIk7yhdS1pMCZM8VeNfUlSKVRhsHZNMl5O9SfaX0l0t5wjdgu4IDzGB8bpnGBBOjGST3rRFVsaaEtI4W6f7g==",
       "license": "MIT",
-      "dependencies": {
-        "@types/prop-types": "*",
-        "csstype": "^3.0.2"
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/gregberge"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@types/react-router": {
-      "version": "5.1.20",
-      "resolved": "https://registry.npmjs.org/@types/react-router/-/react-router-5.1.20.tgz",
-      "integrity": "sha512-jGjmu/ZqS7FjSH6owMcD5qpq19+1RS9DeVRqfl1FeBMxTDQAGwlMWOcs52NDoXaNKyG3d1cYQFMs9rCrb88o9Q==",
+    "node_modules/@svgr/babel-plugin-remove-jsx-attribute": {
+      "version": "8.0.0",
+      "resolved": "https://registry.facebook.net/@svgr/babel-plugin-remove-jsx-attribute/-/babel-plugin-remove-jsx-attribute-8.0.0.tgz",
+      "integrity": "sha512-BcCkm/STipKvbCl6b7QFrMh/vx00vIP63k2eM66MfHJzPr6O2U0jYEViXkHJWqXqQYjdeA9cuCl5KWmlwjDvbA==",
       "license": "MIT",
-      "dependencies": {
-        "@types/history": "^4.7.11",
-        "@types/react": "*"
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/gregberge"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@types/react-router-config": {
-      "version": "5.0.11",
-      "resolved": "https://registry.npmjs.org/@types/react-router-config/-/react-router-config-5.0.11.tgz",
-      "integrity": "sha512-WmSAg7WgqW7m4x8Mt4N6ZyKz0BubSj/2tVUMsAHp+Yd2AMwcSbeFq9WympT19p5heCFmF97R9eD5uUR/t4HEqw==",
+    "node_modules/@svgr/babel-plugin-remove-jsx-empty-expression": {
+      "version": "8.0.0",
+      "resolved": "https://registry.facebook.net/@svgr/babel-plugin-remove-jsx-empty-expression/-/babel-plugin-remove-jsx-empty-expression-8.0.0.tgz",
+      "integrity": "sha512-5BcGCBfBxB5+XSDSWnhTThfI9jcO5f0Ai2V24gZpG+wXF14BzwxxdDb4g6trdOux0rhibGs385BeFMSmxtS3uA==",
       "license": "MIT",
-      "dependencies": {
-        "@types/history": "^4.7.11",
-        "@types/react": "*",
-        "@types/react-router": "^5.1.0"
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/gregberge"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@types/react-router-dom": {
-      "version": "5.3.3",
-      "resolved": "https://registry.npmjs.org/@types/react-router-dom/-/react-router-dom-5.3.3.tgz",
-      "integrity": "sha512-kpqnYK4wcdm5UaWI3fLcELopqLrHgLqNsdpHauzlQktfkHL3npOSwtj1Uz9oKBAzs7lFtVkV8j83voAz2D8fhw==",
+    "node_modules/@svgr/babel-plugin-replace-jsx-attribute-value": {
+      "version": "8.0.0",
+      "resolved": "https://registry.facebook.net/@svgr/babel-plugin-replace-jsx-attribute-value/-/babel-plugin-replace-jsx-attribute-value-8.0.0.tgz",
+      "integrity": "sha512-KVQ+PtIjb1BuYT3ht8M5KbzWBhdAjjUPdlMtpuw/VjT8coTrItWX6Qafl9+ji831JaJcu6PJNKCV0bp01lBNzQ==",
       "license": "MIT",
-      "dependencies": {
-        "@types/history": "^4.7.11",
-        "@types/react": "*",
-        "@types/react-router": "*"
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/gregberge"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@types/retry": {
-      "version": "0.12.0",
-      "resolved": "https://registry.npmjs.org/@types/retry/-/retry-0.12.0.tgz",
-      "integrity": "sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA==",
-      "license": "MIT"
-    },
-    "node_modules/@types/sax": {
-      "version": "1.2.7",
-      "resolved": "https://registry.npmjs.org/@types/sax/-/sax-1.2.7.tgz",
-      "integrity": "sha512-rO73L89PJxeYM3s3pPPjiPgVVcymqU490g0YO5n5By0k2Erzj6tay/4lr1CHAAU4JyOWd1rpQ8bCf6cZfHU96A==",
+    "node_modules/@svgr/babel-plugin-svg-dynamic-title": {
+      "version": "8.0.0",
+      "resolved": "https://registry.facebook.net/@svgr/babel-plugin-svg-dynamic-title/-/babel-plugin-svg-dynamic-title-8.0.0.tgz",
+      "integrity": "sha512-omNiKqwjNmOQJ2v6ge4SErBbkooV2aAWwaPFs2vUY7p7GhVkzRkJ00kILXQvRhA6miHnNpXv7MRnnSjdRjK8og==",
       "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/gregberge"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@types/send": {
-      "version": "0.17.4",
-      "resolved": "https://registry.npmjs.org/@types/send/-/send-0.17.4.tgz",
-      "integrity": "sha512-x2EM6TJOybec7c52BX0ZspPodMsQUd5L6PRwOunVyVUhXiBSKf3AezDL8Dgvgt5o0UfKNfuA0eMLr2wLT4AiBA==",
+    "node_modules/@svgr/babel-plugin-svg-em-dimensions": {
+      "version": "8.0.0",
+      "resolved": "https://registry.facebook.net/@svgr/babel-plugin-svg-em-dimensions/-/babel-plugin-svg-em-dimensions-8.0.0.tgz",
+      "integrity": "sha512-mURHYnu6Iw3UBTbhGwE/vsngtCIbHE43xCRK7kCw4t01xyGqb2Pd+WXekRRoFOBIY29ZoOhUCTEweDMdrjfi9g==",
       "license": "MIT",
-      "dependencies": {
-        "@types/mime": "^1",
-        "@types/node": "*"
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/gregberge"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@types/serve-index": {
-      "version": "1.9.4",
-      "resolved": "https://registry.npmjs.org/@types/serve-index/-/serve-index-1.9.4.tgz",
-      "integrity": "sha512-qLpGZ/c2fhSs5gnYsQxtDEq3Oy8SXPClIXkW5ghvAvsNuVSA8k+gCONcUCS/UjLEYvYps+e8uBtfgXgvhwfNug==",
+    "node_modules/@svgr/babel-plugin-transform-react-native-svg": {
+      "version": "8.1.0",
+      "resolved": "https://registry.facebook.net/@svgr/babel-plugin-transform-react-native-svg/-/babel-plugin-transform-react-native-svg-8.1.0.tgz",
+      "integrity": "sha512-Tx8T58CHo+7nwJ+EhUwx3LfdNSG9R2OKfaIXXs5soiy5HtgoAEkDay9LIimLOcG8dJQH1wPZp/cnAv6S9CrR1Q==",
       "license": "MIT",
-      "dependencies": {
-        "@types/express": "*"
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/gregberge"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@types/serve-static": {
-      "version": "1.15.7",
-      "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-1.15.7.tgz",
-      "integrity": "sha512-W8Ym+h8nhuRwaKPaDw34QUkwsGi6Rc4yYqvKFo5rm2FUEhCFbzVWrxXUxuKK8TASjWsysJY0nsmNCGhCOIsrOw==",
+    "node_modules/@svgr/babel-plugin-transform-svg-component": {
+      "version": "8.0.0",
+      "resolved": "https://registry.facebook.net/@svgr/babel-plugin-transform-svg-component/-/babel-plugin-transform-svg-component-8.0.0.tgz",
+      "integrity": "sha512-DFx8xa3cZXTdb/k3kfPeaixecQLgKh5NVBMwD0AQxOzcZawK4oo1Jh9LbrcACUivsCA7TLG8eeWgrDXjTMhRmw==",
       "license": "MIT",
-      "dependencies": {
-        "@types/http-errors": "*",
-        "@types/node": "*",
-        "@types/send": "*"
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/gregberge"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@types/sockjs": {
-      "version": "0.3.36",
-      "resolved": "https://registry.npmjs.org/@types/sockjs/-/sockjs-0.3.36.tgz",
-      "integrity": "sha512-MK9V6NzAS1+Ud7JV9lJLFqW85VbC9dq3LmwZCuBe4wBDgKC0Kj/jd8Xl+nSviU+Qc3+m7umHHyHg//2KSa0a0Q==",
+    "node_modules/@svgr/babel-preset": {
+      "version": "8.1.0",
+      "resolved": "https://registry.facebook.net/@svgr/babel-preset/-/babel-preset-8.1.0.tgz",
+      "integrity": "sha512-7EYDbHE7MxHpv4sxvnVPngw5fuR6pw79SkcrILHJ/iMpuKySNCl5W1qcwPEpU+LgyRXOaAFgH0KhwD18wwg6ug==",
       "license": "MIT",
       "dependencies": {
-        "@types/node": "*"
+        "@svgr/babel-plugin-add-jsx-attribute": "8.0.0",
+        "@svgr/babel-plugin-remove-jsx-attribute": "8.0.0",
+        "@svgr/babel-plugin-remove-jsx-empty-expression": "8.0.0",
+        "@svgr/babel-plugin-replace-jsx-attribute-value": "8.0.0",
+        "@svgr/babel-plugin-svg-dynamic-title": "8.0.0",
+        "@svgr/babel-plugin-svg-em-dimensions": "8.0.0",
+        "@svgr/babel-plugin-transform-react-native-svg": "8.1.0",
+        "@svgr/babel-plugin-transform-svg-component": "8.0.0"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/gregberge"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@types/unist": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz",
-      "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==",
-      "license": "MIT"
-    },
-    "node_modules/@types/ws": {
-      "version": "8.5.13",
-      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.5.13.tgz",
-      "integrity": "sha512-osM/gWBTPKgHV8XkTunnegTRIsvF6owmf5w+JtAfOw472dptdm0dlGv4xCt6GwQRcC2XVOvvRE/0bAoQcL2QkA==",
+    "node_modules/@svgr/core": {
+      "version": "8.1.0",
+      "resolved": "https://registry.facebook.net/@svgr/core/-/core-8.1.0.tgz",
+      "integrity": "sha512-8QqtOQT5ACVlmsvKOJNEaWmRPmcojMOzCz4Hs2BGG/toAp/K38LcsMRyLp349glq5AzJbCEeimEoxaX6v/fLrA==",
       "license": "MIT",
       "dependencies": {
-        "@types/node": "*"
+        "@babel/core": "^7.21.3",
+        "@svgr/babel-preset": "8.1.0",
+        "camelcase": "^6.2.0",
+        "cosmiconfig": "^8.1.3",
+        "snake-case": "^3.0.4"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/gregberge"
       }
     },
-    "node_modules/@types/yargs": {
-      "version": "17.0.33",
-      "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.33.tgz",
-      "integrity": "sha512-WpxBCKWPLr4xSsHgz511rFJAM+wS28w2zEO1QDNY5zM/S8ok70NNfztH0xwhqKyaK0OHCbN98LDAZuy1ctxDkA==",
+    "node_modules/@svgr/hast-util-to-babel-ast": {
+      "version": "8.0.0",
+      "resolved": "https://registry.facebook.net/@svgr/hast-util-to-babel-ast/-/hast-util-to-babel-ast-8.0.0.tgz",
+      "integrity": "sha512-EbDKwO9GpfWP4jN9sGdYwPBU0kdomaPIL2Eu4YwmgP+sJeXT+L7bMwJUBnhzfH8Q2qMBqZ4fJwpCyYsAN3mt2Q==",
       "license": "MIT",
       "dependencies": {
-        "@types/yargs-parser": "*"
+        "@babel/types": "^7.21.3",
+        "entities": "^4.4.0"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/gregberge"
       }
     },
-    "node_modules/@types/yargs-parser": {
-      "version": "21.0.3",
-      "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-21.0.3.tgz",
-      "integrity": "sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==",
-      "license": "MIT"
-    },
-    "node_modules/@ungap/structured-clone": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.2.1.tgz",
-      "integrity": "sha512-fEzPV3hSkSMltkw152tJKNARhOupqbH96MZWyRjNaYZOMIzbrTeQDG+MTc6Mr2pgzFQzFxAfmhGDNP5QK++2ZA==",
-      "license": "ISC"
-    },
-    "node_modules/@webassemblyjs/ast": {
-      "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.14.1.tgz",
-      "integrity": "sha512-nuBEDgQfm1ccRp/8bCQrx1frohyufl4JlbMMZ4P1wpeOfDhF6FQkxZJ1b/e+PLwr6X1Nhw6OLme5usuBWYBvuQ==",
+    "node_modules/@svgr/plugin-jsx": {
+      "version": "8.1.0",
+      "resolved": "https://registry.facebook.net/@svgr/plugin-jsx/-/plugin-jsx-8.1.0.tgz",
+      "integrity": "sha512-0xiIyBsLlr8quN+WyuxooNW9RJ0Dpr8uOnH/xrCVO8GLUcwHISwj1AG0k+LFzteTkAA0GbX0kj9q6Dk70PTiPA==",
       "license": "MIT",
       "dependencies": {
-        "@webassemblyjs/helper-numbers": "1.13.2",
-        "@webassemblyjs/helper-wasm-bytecode": "1.13.2"
+        "@babel/core": "^7.21.3",
+        "@svgr/babel-preset": "8.1.0",
+        "@svgr/hast-util-to-babel-ast": "8.0.0",
+        "svg-parser": "^2.0.4"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/gregberge"
+      },
+      "peerDependencies": {
+        "@svgr/core": "*"
       }
     },
-    "node_modules/@webassemblyjs/floating-point-hex-parser": {
-      "version": "1.13.2",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.13.2.tgz",
-      "integrity": "sha512-6oXyTOzbKxGH4steLbLNOu71Oj+C8Lg34n6CqRvqfS2O71BxY6ByfMDRhBytzknj9yGUPVJ1qIKhRlAwO1AovA==",
-      "license": "MIT"
-    },
-    "node_modules/@webassemblyjs/helper-api-error": {
-      "version": "1.13.2",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.13.2.tgz",
-      "integrity": "sha512-U56GMYxy4ZQCbDZd6JuvvNV/WFildOjsaWD3Tzzvmw/mas3cXzRJPMjP83JqEsgSbyrmaGjBfDtV7KDXV9UzFQ==",
-      "license": "MIT"
-    },
-    "node_modules/@webassemblyjs/helper-buffer": {
-      "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.14.1.tgz",
-      "integrity": "sha512-jyH7wtcHiKssDtFPRB+iQdxlDf96m0E39yb0k5uJVhFGleZFoNw1c4aeIcVUPPbXUVJ94wwnMOAqUHyzoEPVMA==",
-      "license": "MIT"
-    },
-    "node_modules/@webassemblyjs/helper-numbers": {
-      "version": "1.13.2",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.13.2.tgz",
-      "integrity": "sha512-FE8aCmS5Q6eQYcV3gI35O4J789wlQA+7JrqTTpJqn5emA4U2hvwJmvFRC0HODS+3Ye6WioDklgd6scJ3+PLnEA==",
+    "node_modules/@svgr/plugin-svgo": {
+      "version": "8.1.0",
+      "resolved": "https://registry.facebook.net/@svgr/plugin-svgo/-/plugin-svgo-8.1.0.tgz",
+      "integrity": "sha512-Ywtl837OGO9pTLIN/onoWLmDQ4zFUycI1g76vuKGEz6evR/ZTJlJuz3G/fIkb6OVBJ2g0o6CGJzaEjfmEo3AHA==",
       "license": "MIT",
       "dependencies": {
-        "@webassemblyjs/floating-point-hex-parser": "1.13.2",
-        "@webassemblyjs/helper-api-error": "1.13.2",
-        "@xtuc/long": "4.2.2"
+        "cosmiconfig": "^8.1.3",
+        "deepmerge": "^4.3.1",
+        "svgo": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/gregberge"
+      },
+      "peerDependencies": {
+        "@svgr/core": "*"
       }
     },
-    "node_modules/@webassemblyjs/helper-wasm-bytecode": {
-      "version": "1.13.2",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.13.2.tgz",
-      "integrity": "sha512-3QbLKy93F0EAIXLh0ogEVR6rOubA9AoZ+WRYhNbFyuB70j3dRdwH9g+qXhLAO0kiYGlg3TxDV+I4rQTr/YNXkA==",
-      "license": "MIT"
-    },
-    "node_modules/@webassemblyjs/helper-wasm-section": {
-      "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.14.1.tgz",
-      "integrity": "sha512-ds5mXEqTJ6oxRoqjhWDU83OgzAYjwsCV8Lo/N+oRsNDmx/ZDpqalmrtgOMkHwxsG0iI//3BwWAErYRHtgn0dZw==",
+    "node_modules/@svgr/webpack": {
+      "version": "8.1.0",
+      "resolved": "https://registry.facebook.net/@svgr/webpack/-/webpack-8.1.0.tgz",
+      "integrity": "sha512-LnhVjMWyMQV9ZmeEy26maJk+8HTIbd59cH4F2MJ439k9DqejRisfFNGAPvRYlKETuh9LrImlS8aKsBgKjMA8WA==",
       "license": "MIT",
       "dependencies": {
-        "@webassemblyjs/ast": "1.14.1",
-        "@webassemblyjs/helper-buffer": "1.14.1",
-        "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
-        "@webassemblyjs/wasm-gen": "1.14.1"
+        "@babel/core": "^7.21.3",
+        "@babel/plugin-transform-react-constant-elements": "^7.21.3",
+        "@babel/preset-env": "^7.20.2",
+        "@babel/preset-react": "^7.18.6",
+        "@babel/preset-typescript": "^7.21.0",
+        "@svgr/core": "8.1.0",
+        "@svgr/plugin-jsx": "8.1.0",
+        "@svgr/plugin-svgo": "8.1.0"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/gregberge"
       }
     },
-    "node_modules/@webassemblyjs/ieee754": {
-      "version": "1.13.2",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.13.2.tgz",
-      "integrity": "sha512-4LtOzh58S/5lX4ITKxnAK2USuNEvpdVV9AlgGQb8rJDHaLeHciwG4zlGr0j/SNWlr7x3vO1lDEsuePvtcDNCkw==",
+    "node_modules/@szmarczak/http-timer": {
+      "version": "5.0.1",
+      "resolved": "https://registry.facebook.net/@szmarczak/http-timer/-/http-timer-5.0.1.tgz",
+      "integrity": "sha512-+PmQX0PiAYPMeVYe237LJAYvOMYW1j2rH5YROyS3b4CTVJum34HfRvKvAzozHAQG0TnHNdUfY9nCeUyRAs//cw==",
       "license": "MIT",
       "dependencies": {
-        "@xtuc/ieee754": "^1.2.0"
+        "defer-to-connect": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=14.16"
       }
     },
-    "node_modules/@webassemblyjs/leb128": {
-      "version": "1.13.2",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.13.2.tgz",
-      "integrity": "sha512-Lde1oNoIdzVzdkNEAWZ1dZ5orIbff80YPdHx20mrHwHrVNNTjNr8E3xz9BdpcGqRQbAEa+fkrCb+fRFTl/6sQw==",
-      "license": "Apache-2.0",
+    "node_modules/@types/body-parser": {
+      "version": "1.19.6",
+      "resolved": "https://registry.facebook.net/@types/body-parser/-/body-parser-1.19.6.tgz",
+      "integrity": "sha512-HLFeCYgz89uk22N5Qg3dvGvsv46B8GLvKKo1zKG4NybA8U2DiEO3w9lqGg29t/tfLRJpJ6iQxnVw4OnB7MoM9g==",
+      "license": "MIT",
       "dependencies": {
-        "@xtuc/long": "4.2.2"
+        "@types/connect": "*",
+        "@types/node": "*"
       }
     },
-    "node_modules/@webassemblyjs/utf8": {
-      "version": "1.13.2",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.13.2.tgz",
-      "integrity": "sha512-3NQWGjKTASY1xV5m7Hr0iPeXD9+RDobLll3T9d2AO+g3my8xy5peVyjSag4I50mR1bBSN/Ct12lo+R9tJk0NZQ==",
-      "license": "MIT"
-    },
-    "node_modules/@webassemblyjs/wasm-edit": {
-      "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.14.1.tgz",
-      "integrity": "sha512-RNJUIQH/J8iA/1NzlE4N7KtyZNHi3w7at7hDjvRNm5rcUXa00z1vRz3glZoULfJ5mpvYhLybmVcwcjGrC1pRrQ==",
+    "node_modules/@types/bonjour": {
+      "version": "3.5.13",
+      "resolved": "https://registry.facebook.net/@types/bonjour/-/bonjour-3.5.13.tgz",
+      "integrity": "sha512-z9fJ5Im06zvUL548KvYNecEVlA7cVDkGUi6kZusb04mpyEFKCIZJvloCcmpmLaIahDpOQGHaHmG6imtPMmPXGQ==",
       "license": "MIT",
       "dependencies": {
-        "@webassemblyjs/ast": "1.14.1",
-        "@webassemblyjs/helper-buffer": "1.14.1",
-        "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
-        "@webassemblyjs/helper-wasm-section": "1.14.1",
-        "@webassemblyjs/wasm-gen": "1.14.1",
-        "@webassemblyjs/wasm-opt": "1.14.1",
-        "@webassemblyjs/wasm-parser": "1.14.1",
-        "@webassemblyjs/wast-printer": "1.14.1"
+        "@types/node": "*"
       }
     },
-    "node_modules/@webassemblyjs/wasm-gen": {
-      "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.14.1.tgz",
-      "integrity": "sha512-AmomSIjP8ZbfGQhumkNvgC33AY7qtMCXnN6bL2u2Js4gVCg8fp735aEiMSBbDR7UQIj90n4wKAFUSEd0QN2Ukg==",
+    "node_modules/@types/connect": {
+      "version": "3.4.38",
+      "resolved": "https://registry.facebook.net/@types/connect/-/connect-3.4.38.tgz",
+      "integrity": "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==",
       "license": "MIT",
       "dependencies": {
-        "@webassemblyjs/ast": "1.14.1",
-        "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
-        "@webassemblyjs/ieee754": "1.13.2",
-        "@webassemblyjs/leb128": "1.13.2",
-        "@webassemblyjs/utf8": "1.13.2"
+        "@types/node": "*"
       }
     },
-    "node_modules/@webassemblyjs/wasm-opt": {
-      "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.14.1.tgz",
-      "integrity": "sha512-PTcKLUNvBqnY2U6E5bdOQcSM+oVP/PmrDY9NzowJjislEjwP/C4an2303MCVS2Mg9d3AJpIGdUFIQQWbPds0Sw==",
+    "node_modules/@types/connect-history-api-fallback": {
+      "version": "1.5.4",
+      "resolved": "https://registry.facebook.net/@types/connect-history-api-fallback/-/connect-history-api-fallback-1.5.4.tgz",
+      "integrity": "sha512-n6Cr2xS1h4uAulPRdlw6Jl6s1oG8KrVilPN2yUITEs+K48EzMJJ3W1xy8K5eWuFvjp3R74AOIGSmp2UfBJ8HFw==",
       "license": "MIT",
       "dependencies": {
-        "@webassemblyjs/ast": "1.14.1",
-        "@webassemblyjs/helper-buffer": "1.14.1",
-        "@webassemblyjs/wasm-gen": "1.14.1",
-        "@webassemblyjs/wasm-parser": "1.14.1"
+        "@types/express-serve-static-core": "*",
+        "@types/node": "*"
       }
     },
-    "node_modules/@webassemblyjs/wasm-parser": {
-      "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.14.1.tgz",
-      "integrity": "sha512-JLBl+KZ0R5qB7mCnud/yyX08jWFw5MsoalJ1pQ4EdFlgj9VdXKGuENGsiCIjegI1W7p91rUlcB/LB5yRJKNTcQ==",
+    "node_modules/@types/connect-history-api-fallback/node_modules/@types/express-serve-static-core": {
+      "version": "5.1.1",
+      "resolved": "https://registry.facebook.net/@types/express-serve-static-core/-/express-serve-static-core-5.1.1.tgz",
+      "integrity": "sha512-v4zIMr/cX7/d2BpAEX3KNKL/JrT1s43s96lLvvdTmza1oEvDudCqK9aF/djc/SWgy8Yh0h30TZx5VpzqFCxk5A==",
       "license": "MIT",
       "dependencies": {
-        "@webassemblyjs/ast": "1.14.1",
-        "@webassemblyjs/helper-api-error": "1.13.2",
-        "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
-        "@webassemblyjs/ieee754": "1.13.2",
-        "@webassemblyjs/leb128": "1.13.2",
-        "@webassemblyjs/utf8": "1.13.2"
+        "@types/node": "*",
+        "@types/qs": "*",
+        "@types/range-parser": "*",
+        "@types/send": "*"
       }
     },
-    "node_modules/@webassemblyjs/wast-printer": {
-      "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.14.1.tgz",
-      "integrity": "sha512-kPSSXE6De1XOR820C90RIo2ogvZG+c3KiHzqUoO/F34Y2shGzesfqv7o57xrxovZJH/MetF5UjroJ/R/3isoiw==",
+    "node_modules/@types/debug": {
+      "version": "4.1.13",
+      "resolved": "https://registry.facebook.net/@types/debug/-/debug-4.1.13.tgz",
+      "integrity": "sha512-KSVgmQmzMwPlmtljOomayoR89W4FynCAi3E8PPs7vmDVPe84hT+vGPKkJfThkmXs0x0jAaa9U8uW8bbfyS2fWw==",
       "license": "MIT",
       "dependencies": {
-        "@webassemblyjs/ast": "1.14.1",
-        "@xtuc/long": "4.2.2"
+        "@types/ms": "*"
       }
     },
-    "node_modules/@xtuc/ieee754": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/@xtuc/ieee754/-/ieee754-1.2.0.tgz",
-      "integrity": "sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA==",
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/@xtuc/long": {
-      "version": "4.2.2",
-      "resolved": "https://registry.npmjs.org/@xtuc/long/-/long-4.2.2.tgz",
-      "integrity": "sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==",
-      "license": "Apache-2.0"
-    },
-    "node_modules/accepts": {
-      "version": "1.3.8",
-      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
-      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
+    "node_modules/@types/eslint": {
+      "version": "9.6.1",
+      "resolved": "https://registry.facebook.net/@types/eslint/-/eslint-9.6.1.tgz",
+      "integrity": "sha512-FXx2pKgId/WyYo2jXw63kk7/+TY7u7AziEJxJAnSFzHlqTAS3Ync6SvgYAN/k4/PQpnnVuzoMuVnByKK2qp0ag==",
       "license": "MIT",
       "dependencies": {
-        "mime-types": "~2.1.34",
-        "negotiator": "0.6.3"
-      },
-      "engines": {
-        "node": ">= 0.6"
+        "@types/estree": "*",
+        "@types/json-schema": "*"
       }
     },
-    "node_modules/accepts/node_modules/negotiator": {
-      "version": "0.6.3",
-      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
-      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
+    "node_modules/@types/eslint-scope": {
+      "version": "3.7.7",
+      "resolved": "https://registry.facebook.net/@types/eslint-scope/-/eslint-scope-3.7.7.tgz",
+      "integrity": "sha512-MzMFlSLBqNF2gcHWO0G1vP/YQyfvrxZ0bF+u7mzUdZ1/xK4A4sru+nraZz5i3iEIk1l1uyicaDVTB4QbbEkAYg==",
       "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
+      "dependencies": {
+        "@types/eslint": "*",
+        "@types/estree": "*"
       }
     },
-    "node_modules/acorn": {
-      "version": "8.14.0",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.0.tgz",
-      "integrity": "sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==",
-      "license": "MIT",
-      "bin": {
-        "acorn": "bin/acorn"
-      },
-      "engines": {
-        "node": ">=0.4.0"
-      }
+    "node_modules/@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.facebook.net/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "license": "MIT"
     },
-    "node_modules/acorn-jsx": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
-      "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
+    "node_modules/@types/estree-jsx": {
+      "version": "1.0.5",
+      "resolved": "https://registry.facebook.net/@types/estree-jsx/-/estree-jsx-1.0.5.tgz",
+      "integrity": "sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg==",
       "license": "MIT",
-      "peerDependencies": {
-        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      "dependencies": {
+        "@types/estree": "*"
       }
     },
-    "node_modules/acorn-walk": {
-      "version": "8.3.4",
-      "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.4.tgz",
-      "integrity": "sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==",
+    "node_modules/@types/express": {
+      "version": "4.17.25",
+      "resolved": "https://registry.facebook.net/@types/express/-/express-4.17.25.tgz",
+      "integrity": "sha512-dVd04UKsfpINUnK0yBoYHDF3xu7xVH4BuDotC/xGuycx4CgbP48X/KF/586bcObxT0HENHXEU8Nqtu6NR+eKhw==",
       "license": "MIT",
       "dependencies": {
-        "acorn": "^8.11.0"
-      },
-      "engines": {
-        "node": ">=0.4.0"
+        "@types/body-parser": "*",
+        "@types/express-serve-static-core": "^4.17.33",
+        "@types/qs": "*",
+        "@types/serve-static": "^1"
       }
     },
-    "node_modules/address": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/address/-/address-1.2.2.tgz",
-      "integrity": "sha512-4B/qKCfeE/ODUaAUpSwfzazo5x29WD4r3vXiWsB7I2mSDAihwEqKO+g8GELZUQSSAo5e1XTYh3ZVfLyxBc12nA==",
+    "node_modules/@types/express-serve-static-core": {
+      "version": "4.19.8",
+      "resolved": "https://registry.facebook.net/@types/express-serve-static-core/-/express-serve-static-core-4.19.8.tgz",
+      "integrity": "sha512-02S5fmqeoKzVZCHPZid4b8JH2eM5HzQLZWN2FohQEy/0eXTq8VXZfSN6Pcr3F6N9R/vNrj7cpgbhjie6m/1tCA==",
       "license": "MIT",
-      "engines": {
-        "node": ">= 10.0.0"
+      "dependencies": {
+        "@types/node": "*",
+        "@types/qs": "*",
+        "@types/range-parser": "*",
+        "@types/send": "*"
       }
     },
-    "node_modules/aggregate-error": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-3.1.0.tgz",
-      "integrity": "sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==",
+    "node_modules/@types/gtag.js": {
+      "version": "0.0.20",
+      "resolved": "https://registry.facebook.net/@types/gtag.js/-/gtag.js-0.0.20.tgz",
+      "integrity": "sha512-wwAbk3SA2QeU67unN7zPxjEHmPmlXwZXZvQEpbEUQuMCRGgKyE1m6XDuTUA9b6pCGb/GqJmdfMOY5LuDjJSbbg==",
+      "license": "MIT"
+    },
+    "node_modules/@types/hast": {
+      "version": "3.0.4",
+      "resolved": "https://registry.facebook.net/@types/hast/-/hast-3.0.4.tgz",
+      "integrity": "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==",
       "license": "MIT",
       "dependencies": {
-        "clean-stack": "^2.0.0",
-        "indent-string": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=8"
+        "@types/unist": "*"
       }
     },
-    "node_modules/ajv": {
-      "version": "8.17.1",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
-      "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
+    "node_modules/@types/history": {
+      "version": "4.7.11",
+      "resolved": "https://registry.facebook.net/@types/history/-/history-4.7.11.tgz",
+      "integrity": "sha512-qjDJRrmvBMiTx+jyLxvLfJU7UznFuokDv4f3WRuriHKERccVpFU+8XMQUAbDzoiJCsmexxRExQeMwwCdamSKDA==",
+      "license": "MIT"
+    },
+    "node_modules/@types/html-minifier-terser": {
+      "version": "6.1.0",
+      "resolved": "https://registry.facebook.net/@types/html-minifier-terser/-/html-minifier-terser-6.1.0.tgz",
+      "integrity": "sha512-oh/6byDPnL1zeNXFrDXFLyZjkr1MsBG667IM792caf1L2UPOOMf65NFzjUH/ltyfwjAGfs1rsX1eftK0jC/KIg==",
+      "license": "MIT"
+    },
+    "node_modules/@types/http-cache-semantics": {
+      "version": "4.2.0",
+      "resolved": "https://registry.facebook.net/@types/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz",
+      "integrity": "sha512-L3LgimLHXtGkWikKnsPg0/VFx9OGZaC+eN1u4r+OB1XRqH3meBIAVC2zr1WdMH+RHmnRkqliQAOHNJ/E0j/e0Q==",
+      "license": "MIT"
+    },
+    "node_modules/@types/http-errors": {
+      "version": "2.0.5",
+      "resolved": "https://registry.facebook.net/@types/http-errors/-/http-errors-2.0.5.tgz",
+      "integrity": "sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg==",
+      "license": "MIT"
+    },
+    "node_modules/@types/http-proxy": {
+      "version": "1.17.17",
+      "resolved": "https://registry.facebook.net/@types/http-proxy/-/http-proxy-1.17.17.tgz",
+      "integrity": "sha512-ED6LB+Z1AVylNTu7hdzuBqOgMnvG/ld6wGCG8wFnAzKX5uyW2K3WD52v0gnLCTK/VLpXtKckgWuyScYK6cSPaw==",
       "license": "MIT",
       "dependencies": {
-        "fast-deep-equal": "^3.1.3",
-        "fast-uri": "^3.0.1",
-        "json-schema-traverse": "^1.0.0",
-        "require-from-string": "^2.0.2"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/epoberezkin"
+        "@types/node": "*"
       }
     },
-    "node_modules/ajv-formats": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-2.1.1.tgz",
-      "integrity": "sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA==",
+    "node_modules/@types/istanbul-lib-coverage": {
+      "version": "2.0.6",
+      "resolved": "https://registry.facebook.net/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz",
+      "integrity": "sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==",
+      "license": "MIT"
+    },
+    "node_modules/@types/istanbul-lib-report": {
+      "version": "3.0.3",
+      "resolved": "https://registry.facebook.net/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.3.tgz",
+      "integrity": "sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA==",
       "license": "MIT",
       "dependencies": {
-        "ajv": "^8.0.0"
-      },
-      "peerDependencies": {
-        "ajv": "^8.0.0"
-      },
-      "peerDependenciesMeta": {
-        "ajv": {
-          "optional": true
-        }
+        "@types/istanbul-lib-coverage": "*"
       }
     },
-    "node_modules/ajv-keywords": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz",
-      "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==",
+    "node_modules/@types/istanbul-reports": {
+      "version": "3.0.4",
+      "resolved": "https://registry.facebook.net/@types/istanbul-reports/-/istanbul-reports-3.0.4.tgz",
+      "integrity": "sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==",
       "license": "MIT",
       "dependencies": {
-        "fast-deep-equal": "^3.1.3"
-      },
-      "peerDependencies": {
-        "ajv": "^8.8.2"
+        "@types/istanbul-lib-report": "*"
       }
     },
-    "node_modules/algoliasearch": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/algoliasearch/-/algoliasearch-4.24.0.tgz",
-      "integrity": "sha512-bf0QV/9jVejssFBmz2HQLxUadxk574t4iwjCKp5E7NBzwKkrDEhKPISIIjAU/p6K5qDx3qoeh4+26zWN1jmw3g==",
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/cache-browser-local-storage": "4.24.0",
-        "@algolia/cache-common": "4.24.0",
-        "@algolia/cache-in-memory": "4.24.0",
-        "@algolia/client-account": "4.24.0",
-        "@algolia/client-analytics": "4.24.0",
-        "@algolia/client-common": "4.24.0",
-        "@algolia/client-personalization": "4.24.0",
-        "@algolia/client-search": "4.24.0",
-        "@algolia/logger-common": "4.24.0",
-        "@algolia/logger-console": "4.24.0",
-        "@algolia/recommend": "4.24.0",
-        "@algolia/requester-browser-xhr": "4.24.0",
-        "@algolia/requester-common": "4.24.0",
-        "@algolia/requester-node-http": "4.24.0",
-        "@algolia/transporter": "4.24.0"
-      }
+    "node_modules/@types/json-schema": {
+      "version": "7.0.15",
+      "resolved": "https://registry.facebook.net/@types/json-schema/-/json-schema-7.0.15.tgz",
+      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+      "license": "MIT"
     },
-    "node_modules/algoliasearch-helper": {
-      "version": "3.22.6",
-      "resolved": "https://registry.npmjs.org/algoliasearch-helper/-/algoliasearch-helper-3.22.6.tgz",
-      "integrity": "sha512-F2gSb43QHyvZmvH/2hxIjbk/uFdO2MguQYTFP7J+RowMW1csjIODMobEnpLI8nbLQuzZnGZdIxl5Bpy1k9+CFQ==",
+    "node_modules/@types/mdast": {
+      "version": "4.0.4",
+      "resolved": "https://registry.facebook.net/@types/mdast/-/mdast-4.0.4.tgz",
+      "integrity": "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==",
       "license": "MIT",
       "dependencies": {
-        "@algolia/events": "^4.0.1"
-      },
-      "peerDependencies": {
-        "algoliasearch": ">= 3.1 < 6"
+        "@types/unist": "*"
       }
     },
-    "node_modules/algoliasearch/node_modules/@algolia/client-common": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/client-common/-/client-common-4.24.0.tgz",
-      "integrity": "sha512-bc2ROsNL6w6rqpl5jj/UywlIYC21TwSSoFHKl01lYirGMW+9Eek6r02Tocg4gZ8HAw3iBvu6XQiM3BEbmEMoiA==",
+    "node_modules/@types/mdx": {
+      "version": "2.0.13",
+      "resolved": "https://registry.facebook.net/@types/mdx/-/mdx-2.0.13.tgz",
+      "integrity": "sha512-+OWZQfAYyio6YkJb3HLxDrvnx6SWWDbC0zVPfBRzUk0/nqoDyf6dNxQi3eArPe8rJ473nobTMQ/8Zk+LxJ+Yuw==",
+      "license": "MIT"
+    },
+    "node_modules/@types/mime": {
+      "version": "1.3.5",
+      "resolved": "https://registry.facebook.net/@types/mime/-/mime-1.3.5.tgz",
+      "integrity": "sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==",
+      "license": "MIT"
+    },
+    "node_modules/@types/ms": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/@types/ms/-/ms-2.1.0.tgz",
+      "integrity": "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==",
+      "license": "MIT"
+    },
+    "node_modules/@types/node": {
+      "version": "25.6.0",
+      "resolved": "https://registry.facebook.net/@types/node/-/node-25.6.0.tgz",
+      "integrity": "sha512-+qIYRKdNYJwY3vRCZMdJbPLJAtGjQBudzZzdzwQYkEPQd+PJGixUL5QfvCLDaULoLv+RhT3LDkwEfKaAkgSmNQ==",
       "license": "MIT",
       "dependencies": {
-        "@algolia/requester-common": "4.24.0",
-        "@algolia/transporter": "4.24.0"
+        "undici-types": "~7.19.0"
       }
     },
-    "node_modules/algoliasearch/node_modules/@algolia/client-search": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/client-search/-/client-search-4.24.0.tgz",
-      "integrity": "sha512-uRW6EpNapmLAD0mW47OXqTP8eiIx5F6qN9/x/7HHO6owL3N1IXqydGwW5nhDFBrV+ldouro2W1VX3XlcUXEFCA==",
+    "node_modules/@types/prismjs": {
+      "version": "1.26.6",
+      "resolved": "https://registry.facebook.net/@types/prismjs/-/prismjs-1.26.6.tgz",
+      "integrity": "sha512-vqlvI7qlMvcCBbVe0AKAb4f97//Hy0EBTaiW8AalRnG/xAN5zOiWWyrNqNXeq8+KAuvRewjCVY1+IPxk4RdNYw==",
+      "license": "MIT"
+    },
+    "node_modules/@types/qs": {
+      "version": "6.15.0",
+      "resolved": "https://registry.facebook.net/@types/qs/-/qs-6.15.0.tgz",
+      "integrity": "sha512-JawvT8iBVWpzTrz3EGw9BTQFg3BQNmwERdKE22vlTxawwtbyUSlMppvZYKLZzB5zgACXdXxbD3m1bXaMqP/9ow==",
+      "license": "MIT"
+    },
+    "node_modules/@types/range-parser": {
+      "version": "1.2.7",
+      "resolved": "https://registry.facebook.net/@types/range-parser/-/range-parser-1.2.7.tgz",
+      "integrity": "sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==",
+      "license": "MIT"
+    },
+    "node_modules/@types/react": {
+      "version": "19.2.14",
+      "resolved": "https://registry.facebook.net/@types/react/-/react-19.2.14.tgz",
+      "integrity": "sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==",
       "license": "MIT",
       "dependencies": {
-        "@algolia/client-common": "4.24.0",
-        "@algolia/requester-common": "4.24.0",
-        "@algolia/transporter": "4.24.0"
+        "csstype": "^3.2.2"
       }
     },
-    "node_modules/algoliasearch/node_modules/@algolia/requester-browser-xhr": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/requester-browser-xhr/-/requester-browser-xhr-4.24.0.tgz",
-      "integrity": "sha512-Z2NxZMb6+nVXSjF13YpjYTdvV3032YTBSGm2vnYvYPA6mMxzM3v5rsCiSspndn9rzIW4Qp1lPHBvuoKJV6jnAA==",
+    "node_modules/@types/react-router": {
+      "version": "5.1.20",
+      "resolved": "https://registry.facebook.net/@types/react-router/-/react-router-5.1.20.tgz",
+      "integrity": "sha512-jGjmu/ZqS7FjSH6owMcD5qpq19+1RS9DeVRqfl1FeBMxTDQAGwlMWOcs52NDoXaNKyG3d1cYQFMs9rCrb88o9Q==",
       "license": "MIT",
       "dependencies": {
-        "@algolia/requester-common": "4.24.0"
+        "@types/history": "^4.7.11",
+        "@types/react": "*"
       }
     },
-    "node_modules/algoliasearch/node_modules/@algolia/requester-node-http": {
-      "version": "4.24.0",
-      "resolved": "https://registry.npmjs.org/@algolia/requester-node-http/-/requester-node-http-4.24.0.tgz",
-      "integrity": "sha512-JF18yTjNOVYvU/L3UosRcvbPMGT9B+/GQWNWnenIImglzNVGpyzChkXLnrSf6uxwVNO6ESGu6oN8MqcGQcjQJw==",
+    "node_modules/@types/react-router-config": {
+      "version": "5.0.11",
+      "resolved": "https://registry.facebook.net/@types/react-router-config/-/react-router-config-5.0.11.tgz",
+      "integrity": "sha512-WmSAg7WgqW7m4x8Mt4N6ZyKz0BubSj/2tVUMsAHp+Yd2AMwcSbeFq9WympT19p5heCFmF97R9eD5uUR/t4HEqw==",
       "license": "MIT",
       "dependencies": {
-        "@algolia/requester-common": "4.24.0"
+        "@types/history": "^4.7.11",
+        "@types/react": "*",
+        "@types/react-router": "^5.1.0"
       }
     },
-    "node_modules/ansi-align": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-align/-/ansi-align-3.0.1.tgz",
-      "integrity": "sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==",
-      "license": "ISC",
+    "node_modules/@types/react-router-dom": {
+      "version": "5.3.3",
+      "resolved": "https://registry.facebook.net/@types/react-router-dom/-/react-router-dom-5.3.3.tgz",
+      "integrity": "sha512-kpqnYK4wcdm5UaWI3fLcELopqLrHgLqNsdpHauzlQktfkHL3npOSwtj1Uz9oKBAzs7lFtVkV8j83voAz2D8fhw==",
+      "license": "MIT",
       "dependencies": {
-        "string-width": "^4.1.0"
+        "@types/history": "^4.7.11",
+        "@types/react": "*",
+        "@types/react-router": "*"
       }
     },
-    "node_modules/ansi-align/node_modules/emoji-regex": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+    "node_modules/@types/retry": {
+      "version": "0.12.2",
+      "resolved": "https://registry.facebook.net/@types/retry/-/retry-0.12.2.tgz",
+      "integrity": "sha512-XISRgDJ2Tc5q4TRqvgJtzsRkFYNJzZrhTdtMoGVBttwzzQJkPnS3WWTFc7kuDRoPtPakl+T+OfdEUjYJj7Jbow==",
       "license": "MIT"
     },
-    "node_modules/ansi-align/node_modules/string-width": {
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+    "node_modules/@types/sax": {
+      "version": "1.2.7",
+      "resolved": "https://registry.facebook.net/@types/sax/-/sax-1.2.7.tgz",
+      "integrity": "sha512-rO73L89PJxeYM3s3pPPjiPgVVcymqU490g0YO5n5By0k2Erzj6tay/4lr1CHAAU4JyOWd1rpQ8bCf6cZfHU96A==",
       "license": "MIT",
       "dependencies": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=8"
+        "@types/node": "*"
       }
     },
-    "node_modules/ansi-escapes": {
-      "version": "4.3.2",
-      "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz",
-      "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==",
+    "node_modules/@types/send": {
+      "version": "1.2.1",
+      "resolved": "https://registry.facebook.net/@types/send/-/send-1.2.1.tgz",
+      "integrity": "sha512-arsCikDvlU99zl1g69TcAB3mzZPpxgw0UQnaHeC1Nwb015xp8bknZv5rIfri9xTOcMuaVgvabfIRA7PSZVuZIQ==",
       "license": "MIT",
       "dependencies": {
-        "type-fest": "^0.21.3"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "@types/node": "*"
       }
     },
-    "node_modules/ansi-escapes/node_modules/type-fest": {
-      "version": "0.21.3",
-      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz",
-      "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==",
-      "license": "(MIT OR CC0-1.0)",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+    "node_modules/@types/serve-index": {
+      "version": "1.9.4",
+      "resolved": "https://registry.facebook.net/@types/serve-index/-/serve-index-1.9.4.tgz",
+      "integrity": "sha512-qLpGZ/c2fhSs5gnYsQxtDEq3Oy8SXPClIXkW5ghvAvsNuVSA8k+gCONcUCS/UjLEYvYps+e8uBtfgXgvhwfNug==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/express": "*"
       }
     },
-    "node_modules/ansi-html-community": {
-      "version": "0.0.8",
-      "resolved": "https://registry.npmjs.org/ansi-html-community/-/ansi-html-community-0.0.8.tgz",
-      "integrity": "sha512-1APHAyr3+PCamwNw3bXCPp4HFLONZt/yIH0sZp0/469KWNTEy+qN5jQ3GVX6DMZ1UXAi34yVwtTeaG/HpBuuzw==",
-      "engines": [
-        "node >= 0.8.0"
-      ],
-      "license": "Apache-2.0",
-      "bin": {
-        "ansi-html": "bin/ansi-html"
+    "node_modules/@types/serve-index/node_modules/@types/express": {
+      "version": "5.0.6",
+      "resolved": "https://registry.facebook.net/@types/express/-/express-5.0.6.tgz",
+      "integrity": "sha512-sKYVuV7Sv9fbPIt/442koC7+IIwK5olP1KWeD88e/idgoJqDm3JV/YUiPwkoKK92ylff2MGxSz1CSjsXelx0YA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/body-parser": "*",
+        "@types/express-serve-static-core": "^5.0.0",
+        "@types/serve-static": "^2"
       }
     },
-    "node_modules/ansi-regex": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
-      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+    "node_modules/@types/serve-index/node_modules/@types/express-serve-static-core": {
+      "version": "5.1.1",
+      "resolved": "https://registry.facebook.net/@types/express-serve-static-core/-/express-serve-static-core-5.1.1.tgz",
+      "integrity": "sha512-v4zIMr/cX7/d2BpAEX3KNKL/JrT1s43s96lLvvdTmza1oEvDudCqK9aF/djc/SWgy8Yh0h30TZx5VpzqFCxk5A==",
       "license": "MIT",
-      "engines": {
-        "node": ">=8"
+      "dependencies": {
+        "@types/node": "*",
+        "@types/qs": "*",
+        "@types/range-parser": "*",
+        "@types/send": "*"
       }
     },
-    "node_modules/ansi-styles": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+    "node_modules/@types/serve-index/node_modules/@types/serve-static": {
+      "version": "2.2.0",
+      "resolved": "https://registry.facebook.net/@types/serve-static/-/serve-static-2.2.0.tgz",
+      "integrity": "sha512-8mam4H1NHLtu7nmtalF7eyBH14QyOASmcxHhSfEoRyr0nP/YdoesEtU+uSRvMe96TW/HPTtkoKqQLl53N7UXMQ==",
       "license": "MIT",
       "dependencies": {
-        "color-convert": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+        "@types/http-errors": "*",
+        "@types/node": "*"
       }
     },
-    "node_modules/anymatch": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
-      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
-      "license": "ISC",
+    "node_modules/@types/serve-static": {
+      "version": "1.15.10",
+      "resolved": "https://registry.facebook.net/@types/serve-static/-/serve-static-1.15.10.tgz",
+      "integrity": "sha512-tRs1dB+g8Itk72rlSI2ZrW6vZg0YrLI81iQSTkMmOqnqCaNr/8Ek4VwWcN5vZgCYWbg/JJSGBlUaYGAOP73qBw==",
+      "license": "MIT",
       "dependencies": {
-        "normalize-path": "^3.0.0",
-        "picomatch": "^2.0.4"
-      },
-      "engines": {
-        "node": ">= 8"
+        "@types/http-errors": "*",
+        "@types/node": "*",
+        "@types/send": "<1"
       }
     },
-    "node_modules/arg": {
-      "version": "5.0.2",
-      "resolved": "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz",
-      "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==",
-      "license": "MIT"
+    "node_modules/@types/serve-static/node_modules/@types/send": {
+      "version": "0.17.6",
+      "resolved": "https://registry.facebook.net/@types/send/-/send-0.17.6.tgz",
+      "integrity": "sha512-Uqt8rPBE8SY0RK8JB1EzVOIZ32uqy8HwdxCnoCOsYrvnswqmFZ/k+9Ikidlk/ImhsdvBsloHbAlewb2IEBV/Og==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mime": "^1",
+        "@types/node": "*"
+      }
     },
-    "node_modules/argparse": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
-      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
-      "license": "Python-2.0"
+    "node_modules/@types/sockjs": {
+      "version": "0.3.36",
+      "resolved": "https://registry.facebook.net/@types/sockjs/-/sockjs-0.3.36.tgz",
+      "integrity": "sha512-MK9V6NzAS1+Ud7JV9lJLFqW85VbC9dq3LmwZCuBe4wBDgKC0Kj/jd8Xl+nSviU+Qc3+m7umHHyHg//2KSa0a0Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
     },
-    "node_modules/array-flatten": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
-      "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==",
+    "node_modules/@types/unist": {
+      "version": "3.0.3",
+      "resolved": "https://registry.facebook.net/@types/unist/-/unist-3.0.3.tgz",
+      "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==",
       "license": "MIT"
     },
-    "node_modules/array-union": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz",
-      "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==",
+    "node_modules/@types/ws": {
+      "version": "8.18.1",
+      "resolved": "https://registry.facebook.net/@types/ws/-/ws-8.18.1.tgz",
+      "integrity": "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==",
       "license": "MIT",
-      "engines": {
-        "node": ">=8"
+      "dependencies": {
+        "@types/node": "*"
       }
     },
-    "node_modules/astring": {
-      "version": "1.9.0",
-      "resolved": "https://registry.npmjs.org/astring/-/astring-1.9.0.tgz",
-      "integrity": "sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg==",
+    "node_modules/@types/yargs": {
+      "version": "17.0.35",
+      "resolved": "https://registry.facebook.net/@types/yargs/-/yargs-17.0.35.tgz",
+      "integrity": "sha512-qUHkeCyQFxMXg79wQfTtfndEC+N9ZZg76HJftDJp+qH2tV7Gj4OJi7l+PiWwJ+pWtW8GwSmqsDj/oymhrTWXjg==",
       "license": "MIT",
-      "bin": {
-        "astring": "bin/astring"
+      "dependencies": {
+        "@types/yargs-parser": "*"
       }
     },
-    "node_modules/asynckit": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
-      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+    "node_modules/@types/yargs-parser": {
+      "version": "21.0.3",
+      "resolved": "https://registry.facebook.net/@types/yargs-parser/-/yargs-parser-21.0.3.tgz",
+      "integrity": "sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==",
       "license": "MIT"
     },
-    "node_modules/at-least-node": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz",
-      "integrity": "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==",
-      "license": "ISC",
-      "engines": {
-        "node": ">= 4.0.0"
-      }
+    "node_modules/@ungap/structured-clone": {
+      "version": "1.3.0",
+      "resolved": "https://registry.facebook.net/@ungap/structured-clone/-/structured-clone-1.3.0.tgz",
+      "integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==",
+      "license": "ISC"
     },
-    "node_modules/autoprefixer": {
-      "version": "10.4.20",
-      "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.20.tgz",
-      "integrity": "sha512-XY25y5xSv/wEoqzDyXXME4AFfkZI0P23z6Fs3YgymDnKJkCGOnkL0iTxCa85UTqaSgfcqyf3UA6+c7wUvx/16g==",
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/postcss/"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/autoprefixer"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
+    "node_modules/@webassemblyjs/ast": {
+      "version": "1.14.1",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/ast/-/ast-1.14.1.tgz",
+      "integrity": "sha512-nuBEDgQfm1ccRp/8bCQrx1frohyufl4JlbMMZ4P1wpeOfDhF6FQkxZJ1b/e+PLwr6X1Nhw6OLme5usuBWYBvuQ==",
       "license": "MIT",
       "dependencies": {
-        "browserslist": "^4.23.3",
-        "caniuse-lite": "^1.0.30001646",
-        "fraction.js": "^4.3.7",
-        "normalize-range": "^0.1.2",
-        "picocolors": "^1.0.1",
-        "postcss-value-parser": "^4.2.0"
-      },
-      "bin": {
-        "autoprefixer": "bin/autoprefixer"
-      },
-      "engines": {
-        "node": "^10 || ^12 || >=14"
-      },
-      "peerDependencies": {
-        "postcss": "^8.1.0"
+        "@webassemblyjs/helper-numbers": "1.13.2",
+        "@webassemblyjs/helper-wasm-bytecode": "1.13.2"
       }
     },
-    "node_modules/axios": {
-      "version": "1.7.9",
-      "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.9.tgz",
-      "integrity": "sha512-LhLcE7Hbiryz8oMDdDptSrWowmB4Bl6RCt6sIJKpRB4XtVf0iEgewX3au/pJqm+Py1kCASkb/FFKjxQaLtxJvw==",
+    "node_modules/@webassemblyjs/floating-point-hex-parser": {
+      "version": "1.13.2",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.13.2.tgz",
+      "integrity": "sha512-6oXyTOzbKxGH4steLbLNOu71Oj+C8Lg34n6CqRvqfS2O71BxY6ByfMDRhBytzknj9yGUPVJ1qIKhRlAwO1AovA==",
+      "license": "MIT"
+    },
+    "node_modules/@webassemblyjs/helper-api-error": {
+      "version": "1.13.2",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/helper-api-error/-/helper-api-error-1.13.2.tgz",
+      "integrity": "sha512-U56GMYxy4ZQCbDZd6JuvvNV/WFildOjsaWD3Tzzvmw/mas3cXzRJPMjP83JqEsgSbyrmaGjBfDtV7KDXV9UzFQ==",
+      "license": "MIT"
+    },
+    "node_modules/@webassemblyjs/helper-buffer": {
+      "version": "1.14.1",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/helper-buffer/-/helper-buffer-1.14.1.tgz",
+      "integrity": "sha512-jyH7wtcHiKssDtFPRB+iQdxlDf96m0E39yb0k5uJVhFGleZFoNw1c4aeIcVUPPbXUVJ94wwnMOAqUHyzoEPVMA==",
+      "license": "MIT"
+    },
+    "node_modules/@webassemblyjs/helper-numbers": {
+      "version": "1.13.2",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/helper-numbers/-/helper-numbers-1.13.2.tgz",
+      "integrity": "sha512-FE8aCmS5Q6eQYcV3gI35O4J789wlQA+7JrqTTpJqn5emA4U2hvwJmvFRC0HODS+3Ye6WioDklgd6scJ3+PLnEA==",
       "license": "MIT",
       "dependencies": {
-        "follow-redirects": "^1.15.6",
-        "form-data": "^4.0.0",
-        "proxy-from-env": "^1.1.0"
+        "@webassemblyjs/floating-point-hex-parser": "1.13.2",
+        "@webassemblyjs/helper-api-error": "1.13.2",
+        "@xtuc/long": "4.2.2"
       }
     },
-    "node_modules/babel-loader": {
-      "version": "9.2.1",
-      "resolved": "https://registry.npmjs.org/babel-loader/-/babel-loader-9.2.1.tgz",
-      "integrity": "sha512-fqe8naHt46e0yIdkjUZYqddSXfej3AHajX+CSO5X7oy0EmPc6o5Xh+RClNoHjnieWz9AW4kZxW9yyFMhVB1QLA==",
+    "node_modules/@webassemblyjs/helper-wasm-bytecode": {
+      "version": "1.13.2",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.13.2.tgz",
+      "integrity": "sha512-3QbLKy93F0EAIXLh0ogEVR6rOubA9AoZ+WRYhNbFyuB70j3dRdwH9g+qXhLAO0kiYGlg3TxDV+I4rQTr/YNXkA==",
+      "license": "MIT"
+    },
+    "node_modules/@webassemblyjs/helper-wasm-section": {
+      "version": "1.14.1",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.14.1.tgz",
+      "integrity": "sha512-ds5mXEqTJ6oxRoqjhWDU83OgzAYjwsCV8Lo/N+oRsNDmx/ZDpqalmrtgOMkHwxsG0iI//3BwWAErYRHtgn0dZw==",
       "license": "MIT",
       "dependencies": {
-        "find-cache-dir": "^4.0.0",
-        "schema-utils": "^4.0.0"
-      },
-      "engines": {
-        "node": ">= 14.15.0"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.12.0",
-        "webpack": ">=5"
+        "@webassemblyjs/ast": "1.14.1",
+        "@webassemblyjs/helper-buffer": "1.14.1",
+        "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+        "@webassemblyjs/wasm-gen": "1.14.1"
       }
     },
-    "node_modules/babel-plugin-dynamic-import-node": {
-      "version": "2.3.3",
-      "resolved": "https://registry.npmjs.org/babel-plugin-dynamic-import-node/-/babel-plugin-dynamic-import-node-2.3.3.tgz",
-      "integrity": "sha512-jZVI+s9Zg3IqA/kdi0i6UDCybUI3aSBLnglhYbSSjKlV7yF1F/5LWv8MakQmvYpnbJDS6fcBL2KzHSxNCMtWSQ==",
+    "node_modules/@webassemblyjs/ieee754": {
+      "version": "1.13.2",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/ieee754/-/ieee754-1.13.2.tgz",
+      "integrity": "sha512-4LtOzh58S/5lX4ITKxnAK2USuNEvpdVV9AlgGQb8rJDHaLeHciwG4zlGr0j/SNWlr7x3vO1lDEsuePvtcDNCkw==",
       "license": "MIT",
       "dependencies": {
-        "object.assign": "^4.1.0"
+        "@xtuc/ieee754": "^1.2.0"
       }
     },
-    "node_modules/babel-plugin-polyfill-corejs2": {
-      "version": "0.4.12",
-      "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.12.tgz",
-      "integrity": "sha512-CPWT6BwvhrTO2d8QVorhTCQw9Y43zOu7G9HigcfxvepOU6b8o3tcWad6oVgZIsZCTt42FFv97aA7ZJsbM4+8og==",
+    "node_modules/@webassemblyjs/leb128": {
+      "version": "1.13.2",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/leb128/-/leb128-1.13.2.tgz",
+      "integrity": "sha512-Lde1oNoIdzVzdkNEAWZ1dZ5orIbff80YPdHx20mrHwHrVNNTjNr8E3xz9BdpcGqRQbAEa+fkrCb+fRFTl/6sQw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@xtuc/long": "4.2.2"
+      }
+    },
+    "node_modules/@webassemblyjs/utf8": {
+      "version": "1.13.2",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/utf8/-/utf8-1.13.2.tgz",
+      "integrity": "sha512-3NQWGjKTASY1xV5m7Hr0iPeXD9+RDobLll3T9d2AO+g3my8xy5peVyjSag4I50mR1bBSN/Ct12lo+R9tJk0NZQ==",
+      "license": "MIT"
+    },
+    "node_modules/@webassemblyjs/wasm-edit": {
+      "version": "1.14.1",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/wasm-edit/-/wasm-edit-1.14.1.tgz",
+      "integrity": "sha512-RNJUIQH/J8iA/1NzlE4N7KtyZNHi3w7at7hDjvRNm5rcUXa00z1vRz3glZoULfJ5mpvYhLybmVcwcjGrC1pRrQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/compat-data": "^7.22.6",
-        "@babel/helper-define-polyfill-provider": "^0.6.3",
-        "semver": "^6.3.1"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
+        "@webassemblyjs/ast": "1.14.1",
+        "@webassemblyjs/helper-buffer": "1.14.1",
+        "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+        "@webassemblyjs/helper-wasm-section": "1.14.1",
+        "@webassemblyjs/wasm-gen": "1.14.1",
+        "@webassemblyjs/wasm-opt": "1.14.1",
+        "@webassemblyjs/wasm-parser": "1.14.1",
+        "@webassemblyjs/wast-printer": "1.14.1"
       }
     },
-    "node_modules/babel-plugin-polyfill-corejs2/node_modules/semver": {
-      "version": "6.3.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
-      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
+    "node_modules/@webassemblyjs/wasm-gen": {
+      "version": "1.14.1",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/wasm-gen/-/wasm-gen-1.14.1.tgz",
+      "integrity": "sha512-AmomSIjP8ZbfGQhumkNvgC33AY7qtMCXnN6bL2u2Js4gVCg8fp735aEiMSBbDR7UQIj90n4wKAFUSEd0QN2Ukg==",
+      "license": "MIT",
+      "dependencies": {
+        "@webassemblyjs/ast": "1.14.1",
+        "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+        "@webassemblyjs/ieee754": "1.13.2",
+        "@webassemblyjs/leb128": "1.13.2",
+        "@webassemblyjs/utf8": "1.13.2"
       }
     },
-    "node_modules/babel-plugin-polyfill-corejs3": {
-      "version": "0.10.6",
-      "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.10.6.tgz",
-      "integrity": "sha512-b37+KR2i/khY5sKmWNVQAnitvquQbNdWy6lJdsr0kmquCKEEUgMKK4SboVM3HtfnZilfjr4MMQ7vY58FVWDtIA==",
+    "node_modules/@webassemblyjs/wasm-opt": {
+      "version": "1.14.1",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/wasm-opt/-/wasm-opt-1.14.1.tgz",
+      "integrity": "sha512-PTcKLUNvBqnY2U6E5bdOQcSM+oVP/PmrDY9NzowJjislEjwP/C4an2303MCVS2Mg9d3AJpIGdUFIQQWbPds0Sw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-define-polyfill-provider": "^0.6.2",
-        "core-js-compat": "^3.38.0"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
+        "@webassemblyjs/ast": "1.14.1",
+        "@webassemblyjs/helper-buffer": "1.14.1",
+        "@webassemblyjs/wasm-gen": "1.14.1",
+        "@webassemblyjs/wasm-parser": "1.14.1"
       }
     },
-    "node_modules/babel-plugin-polyfill-regenerator": {
-      "version": "0.6.3",
-      "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.6.3.tgz",
-      "integrity": "sha512-LiWSbl4CRSIa5x/JAU6jZiG9eit9w6mz+yVMFwDE83LAWvt0AfGBoZ7HS/mkhrKuh2ZlzfVZYKoLjXdqw6Yt7Q==",
+    "node_modules/@webassemblyjs/wasm-parser": {
+      "version": "1.14.1",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/wasm-parser/-/wasm-parser-1.14.1.tgz",
+      "integrity": "sha512-JLBl+KZ0R5qB7mCnud/yyX08jWFw5MsoalJ1pQ4EdFlgj9VdXKGuENGsiCIjegI1W7p91rUlcB/LB5yRJKNTcQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-define-polyfill-provider": "^0.6.3"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
+        "@webassemblyjs/ast": "1.14.1",
+        "@webassemblyjs/helper-api-error": "1.13.2",
+        "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+        "@webassemblyjs/ieee754": "1.13.2",
+        "@webassemblyjs/leb128": "1.13.2",
+        "@webassemblyjs/utf8": "1.13.2"
       }
     },
-    "node_modules/bail": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/bail/-/bail-2.0.2.tgz",
-      "integrity": "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==",
+    "node_modules/@webassemblyjs/wast-printer": {
+      "version": "1.14.1",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/wast-printer/-/wast-printer-1.14.1.tgz",
+      "integrity": "sha512-kPSSXE6De1XOR820C90RIo2ogvZG+c3KiHzqUoO/F34Y2shGzesfqv7o57xrxovZJH/MetF5UjroJ/R/3isoiw==",
       "license": "MIT",
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/wooorm"
+      "dependencies": {
+        "@webassemblyjs/ast": "1.14.1",
+        "@xtuc/long": "4.2.2"
       }
     },
-    "node_modules/balanced-match": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
-      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
-      "license": "MIT"
+    "node_modules/@xtuc/ieee754": {
+      "version": "1.2.0",
+      "resolved": "https://registry.facebook.net/@xtuc/ieee754/-/ieee754-1.2.0.tgz",
+      "integrity": "sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA==",
+      "license": "BSD-3-Clause"
     },
-    "node_modules/batch": {
-      "version": "0.6.1",
-      "resolved": "https://registry.npmjs.org/batch/-/batch-0.6.1.tgz",
-      "integrity": "sha512-x+VAiMRL6UPkx+kudNvxTl6hB2XNNCG2r+7wixVfIYwu/2HKRXimwQyaumLjMveWvT2Hkd/cAJw+QBMfJ/EKVw==",
-      "license": "MIT"
+    "node_modules/@xtuc/long": {
+      "version": "4.2.2",
+      "resolved": "https://registry.facebook.net/@xtuc/long/-/long-4.2.2.tgz",
+      "integrity": "sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==",
+      "license": "Apache-2.0"
     },
-    "node_modules/big.js": {
-      "version": "5.2.2",
-      "resolved": "https://registry.npmjs.org/big.js/-/big.js-5.2.2.tgz",
-      "integrity": "sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==",
+    "node_modules/accepts": {
+      "version": "1.3.8",
+      "resolved": "https://registry.facebook.net/accepts/-/accepts-1.3.8.tgz",
+      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
       "license": "MIT",
+      "dependencies": {
+        "mime-types": "~2.1.34",
+        "negotiator": "0.6.3"
+      },
       "engines": {
-        "node": "*"
+        "node": ">= 0.6"
       }
     },
-    "node_modules/binary-extensions": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
-      "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
+    "node_modules/accepts/node_modules/negotiator": {
+      "version": "0.6.3",
+      "resolved": "https://registry.facebook.net/negotiator/-/negotiator-0.6.3.tgz",
+      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
       "license": "MIT",
       "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "node": ">= 0.6"
       }
     },
-    "node_modules/body-parser": {
-      "version": "1.20.3",
-      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.3.tgz",
-      "integrity": "sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==",
+    "node_modules/acorn": {
+      "version": "8.16.0",
+      "resolved": "https://registry.facebook.net/acorn/-/acorn-8.16.0.tgz",
+      "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==",
       "license": "MIT",
-      "dependencies": {
-        "bytes": "3.1.2",
-        "content-type": "~1.0.5",
-        "debug": "2.6.9",
-        "depd": "2.0.0",
-        "destroy": "1.2.0",
-        "http-errors": "2.0.0",
-        "iconv-lite": "0.4.24",
-        "on-finished": "2.4.1",
-        "qs": "6.13.0",
-        "raw-body": "2.5.2",
-        "type-is": "~1.6.18",
-        "unpipe": "1.0.0"
+      "bin": {
+        "acorn": "bin/acorn"
       },
       "engines": {
-        "node": ">= 0.8",
-        "npm": "1.2.8000 || >= 1.4.16"
+        "node": ">=0.4.0"
       }
     },
-    "node_modules/body-parser/node_modules/bytes": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
-      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+    "node_modules/acorn-import-phases": {
+      "version": "1.0.4",
+      "resolved": "https://registry.facebook.net/acorn-import-phases/-/acorn-import-phases-1.0.4.tgz",
+      "integrity": "sha512-wKmbr/DDiIXzEOiWrTTUcDm24kQ2vGfZQvM2fwg2vXqR5uW6aapr7ObPtj1th32b9u90/Pf4AItvdTh42fBmVQ==",
       "license": "MIT",
       "engines": {
-        "node": ">= 0.8"
+        "node": ">=10.13.0"
+      },
+      "peerDependencies": {
+        "acorn": "^8.14.0"
       }
     },
-    "node_modules/body-parser/node_modules/debug": {
-      "version": "2.6.9",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
-      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+    "node_modules/acorn-jsx": {
+      "version": "5.3.2",
+      "resolved": "https://registry.facebook.net/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
+      "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
       "license": "MIT",
-      "dependencies": {
-        "ms": "2.0.0"
+      "peerDependencies": {
+        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
       }
     },
-    "node_modules/body-parser/node_modules/ms": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
-      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
-      "license": "MIT"
-    },
-    "node_modules/bonjour-service": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/bonjour-service/-/bonjour-service-1.3.0.tgz",
-      "integrity": "sha512-3YuAUiSkWykd+2Azjgyxei8OWf8thdn8AITIog2M4UICzoqfjlqr64WIjEXZllf/W6vK1goqleSR6brGomxQqA==",
+    "node_modules/acorn-walk": {
+      "version": "8.3.5",
+      "resolved": "https://registry.facebook.net/acorn-walk/-/acorn-walk-8.3.5.tgz",
+      "integrity": "sha512-HEHNfbars9v4pgpW6SO1KSPkfoS0xVOM/9UzkJltjlsHZmJasxg8aXkuZa7SMf8vKGIBhpUsPluQSqhJFCqebw==",
       "license": "MIT",
       "dependencies": {
-        "fast-deep-equal": "^3.1.3",
-        "multicast-dns": "^7.2.5"
+        "acorn": "^8.11.0"
+      },
+      "engines": {
+        "node": ">=0.4.0"
       }
     },
-    "node_modules/boolbase": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz",
-      "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==",
-      "license": "ISC"
-    },
-    "node_modules/boxen": {
-      "version": "6.2.1",
-      "resolved": "https://registry.npmjs.org/boxen/-/boxen-6.2.1.tgz",
-      "integrity": "sha512-H4PEsJXfFI/Pt8sjDWbHlQPx4zL/bvSQjcilJmaulGt5mLDorHOHpmdXAJcBcmru7PhYSp/cDMWRko4ZUMFkSw==",
+    "node_modules/address": {
+      "version": "1.2.2",
+      "resolved": "https://registry.facebook.net/address/-/address-1.2.2.tgz",
+      "integrity": "sha512-4B/qKCfeE/ODUaAUpSwfzazo5x29WD4r3vXiWsB7I2mSDAihwEqKO+g8GELZUQSSAo5e1XTYh3ZVfLyxBc12nA==",
       "license": "MIT",
-      "dependencies": {
-        "ansi-align": "^3.0.1",
-        "camelcase": "^6.2.0",
-        "chalk": "^4.1.2",
-        "cli-boxes": "^3.0.0",
-        "string-width": "^5.0.1",
-        "type-fest": "^2.5.0",
-        "widest-line": "^4.0.1",
-        "wrap-ansi": "^8.0.1"
-      },
       "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "node": ">= 10.0.0"
       }
     },
-    "node_modules/brace-expansion": {
-      "version": "1.1.12",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+    "node_modules/aggregate-error": {
+      "version": "3.1.0",
+      "resolved": "https://registry.facebook.net/aggregate-error/-/aggregate-error-3.1.0.tgz",
+      "integrity": "sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==",
       "license": "MIT",
       "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
+        "clean-stack": "^2.0.0",
+        "indent-string": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
       }
     },
-    "node_modules/braces": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
-      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+    "node_modules/ajv": {
+      "version": "8.20.0",
+      "resolved": "https://registry.facebook.net/ajv/-/ajv-8.20.0.tgz",
+      "integrity": "sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==",
       "license": "MIT",
       "dependencies": {
-        "fill-range": "^7.1.1"
+        "fast-deep-equal": "^3.1.3",
+        "fast-uri": "^3.0.1",
+        "json-schema-traverse": "^1.0.0",
+        "require-from-string": "^2.0.2"
       },
-      "engines": {
-        "node": ">=8"
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
       }
     },
-    "node_modules/browserslist": {
-      "version": "4.24.3",
-      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.3.tgz",
-      "integrity": "sha512-1CPmv8iobE2fyRMV97dAcMVegvvWKxmq94hkLiAkUGwKVTyDLw33K+ZxiFrREKmmps4rIw6grcCFCnTMSZ/YiA==",
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/browserslist"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/browserslist"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
+    "node_modules/ajv-formats": {
+      "version": "2.1.1",
+      "resolved": "https://registry.facebook.net/ajv-formats/-/ajv-formats-2.1.1.tgz",
+      "integrity": "sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA==",
       "license": "MIT",
       "dependencies": {
-        "caniuse-lite": "^1.0.30001688",
-        "electron-to-chromium": "^1.5.73",
-        "node-releases": "^2.0.19",
-        "update-browserslist-db": "^1.1.1"
+        "ajv": "^8.0.0"
       },
-      "bin": {
-        "browserslist": "cli.js"
+      "peerDependencies": {
+        "ajv": "^8.0.0"
       },
-      "engines": {
-        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      "peerDependenciesMeta": {
+        "ajv": {
+          "optional": true
+        }
       }
     },
-    "node_modules/buffer-from": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
-      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
-      "license": "MIT"
-    },
-    "node_modules/bytes": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.0.0.tgz",
-      "integrity": "sha512-pMhOfFDPiv9t5jjIXkHosWmkSyQbvsgEVNkz0ERHbuLh2T/7j4Mqqpz523Fe8MVY89KC6Sh/QfS2sM+SjgFDcw==",
+    "node_modules/ajv-keywords": {
+      "version": "5.1.0",
+      "resolved": "https://registry.facebook.net/ajv-keywords/-/ajv-keywords-5.1.0.tgz",
+      "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==",
       "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
+      "dependencies": {
+        "fast-deep-equal": "^3.1.3"
+      },
+      "peerDependencies": {
+        "ajv": "^8.8.2"
       }
     },
-    "node_modules/cacheable-lookup": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/cacheable-lookup/-/cacheable-lookup-7.0.0.tgz",
-      "integrity": "sha512-+qJyx4xiKra8mZrcwhjMRMUhD5NR1R8esPkzIYxX96JiecFoxAXFuz/GpR3+ev4PE1WamHip78wV0vcmPQtp8w==",
-      "license": "MIT",
+    "node_modules/algoliasearch": {
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/algoliasearch/-/algoliasearch-5.51.0.tgz",
+      "integrity": "sha512-u3XS8HaTzt5YN90KPsOXMRjYJUMVD1dtr6yi4NXQluMbZ5IjQNBu1MEabdAxFhYtEuexqomPMSmRIhQJUd3QSg==",
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/abtesting": "1.17.0",
+        "@algolia/client-abtesting": "5.51.0",
+        "@algolia/client-analytics": "5.51.0",
+        "@algolia/client-common": "5.51.0",
+        "@algolia/client-insights": "5.51.0",
+        "@algolia/client-personalization": "5.51.0",
+        "@algolia/client-query-suggestions": "5.51.0",
+        "@algolia/client-search": "5.51.0",
+        "@algolia/ingestion": "1.51.0",
+        "@algolia/monitoring": "1.51.0",
+        "@algolia/recommend": "5.51.0",
+        "@algolia/requester-browser-xhr": "5.51.0",
+        "@algolia/requester-fetch": "5.51.0",
+        "@algolia/requester-node-http": "5.51.0"
+      },
       "engines": {
-        "node": ">=14.16"
+        "node": ">= 14.0.0"
       }
     },
-    "node_modules/cacheable-request": {
-      "version": "10.2.14",
-      "resolved": "https://registry.npmjs.org/cacheable-request/-/cacheable-request-10.2.14.tgz",
-      "integrity": "sha512-zkDT5WAF4hSSoUgyfg5tFIxz8XQK+25W/TLVojJTMKBaxevLBBtLxgqguAuVQB8PVW79FVjHcU+GJ9tVbDZ9mQ==",
+    "node_modules/algoliasearch-helper": {
+      "version": "3.28.2",
+      "resolved": "https://registry.facebook.net/algoliasearch-helper/-/algoliasearch-helper-3.28.2.tgz",
+      "integrity": "sha512-sexVcXLHrJN54+S0wXD52xV3ySeGZA5T6HMDkb84wT+3UcXCd8af/k2vU5qJTbHv7DoBb4mISJHdyQ2JOo3Aig==",
       "license": "MIT",
       "dependencies": {
-        "@types/http-cache-semantics": "^4.0.2",
-        "get-stream": "^6.0.1",
-        "http-cache-semantics": "^4.1.1",
-        "keyv": "^4.5.3",
-        "mimic-response": "^4.0.0",
-        "normalize-url": "^8.0.0",
-        "responselike": "^3.0.0"
+        "@algolia/events": "^4.0.1"
       },
-      "engines": {
-        "node": ">=14.16"
+      "peerDependencies": {
+        "algoliasearch": ">= 3.1 < 6"
       }
     },
-    "node_modules/call-bind": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz",
-      "integrity": "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==",
-      "license": "MIT",
+    "node_modules/ansi-align": {
+      "version": "3.0.1",
+      "resolved": "https://registry.facebook.net/ansi-align/-/ansi-align-3.0.1.tgz",
+      "integrity": "sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==",
+      "license": "ISC",
       "dependencies": {
-        "call-bind-apply-helpers": "^1.0.0",
-        "es-define-property": "^1.0.0",
-        "get-intrinsic": "^1.2.4",
-        "set-function-length": "^1.2.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "string-width": "^4.1.0"
       }
     },
-    "node_modules/call-bind-apply-helpers": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.1.tgz",
-      "integrity": "sha512-BhYE+WDaywFg2TBWYNXAE+8B1ATnThNBqXHP5nQu0jWJdVvY2hvkpyB3qOmtmDePiS5/BDQ8wASEWGMWRG148g==",
+    "node_modules/ansi-align/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.facebook.net/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "license": "MIT"
+    },
+    "node_modules/ansi-align/node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.facebook.net/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
       "license": "MIT",
       "dependencies": {
-        "es-errors": "^1.3.0",
-        "function-bind": "^1.1.2"
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
       },
       "engines": {
-        "node": ">= 0.4"
+        "node": ">=8"
       }
     },
-    "node_modules/call-bound": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.3.tgz",
-      "integrity": "sha512-YTd+6wGlNlPxSuri7Y6X8tY2dmm12UMH66RpKMhiX6rsk5wXXnYgbUcOt8kiS31/AjfoTOvCsE+w8nZQLQnzHA==",
-      "license": "MIT",
+    "node_modules/ansi-escapes": {
+      "version": "4.3.2",
+      "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz",
+      "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==",
       "dependencies": {
-        "call-bind-apply-helpers": "^1.0.1",
-        "get-intrinsic": "^1.2.6"
+        "type-fest": "^0.21.3"
       },
       "engines": {
-        "node": ">= 0.4"
+        "node": ">=8"
       },
       "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/callsites": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
-      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/camel-case": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/camel-case/-/camel-case-4.1.2.tgz",
-      "integrity": "sha512-gxGWBrTT1JuMx6R+o5PTXMmUnhnVzLQ9SNutD4YqKtI6ap897t3tKECYla6gCWEkplXnlNybEkZg9GEGxKFCgw==",
-      "license": "MIT",
-      "dependencies": {
-        "pascal-case": "^3.1.2",
-        "tslib": "^2.0.3"
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/camelcase": {
-      "version": "6.3.0",
-      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz",
-      "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==",
-      "license": "MIT",
+    "node_modules/ansi-escapes/node_modules/type-fest": {
+      "version": "0.21.3",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz",
+      "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==",
       "engines": {
         "node": ">=10"
       },
@@ -5895,1296 +6125,1269 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/caniuse-api": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/caniuse-api/-/caniuse-api-3.0.0.tgz",
-      "integrity": "sha512-bsTwuIg/BZZK/vreVTYYbSWoe2F+71P7K5QGEX+pT250DZbfU1MQ5prOKpPR+LL6uWKK3KMwMCAS74QB3Um1uw==",
-      "license": "MIT",
-      "dependencies": {
-        "browserslist": "^4.0.0",
-        "caniuse-lite": "^1.0.0",
-        "lodash.memoize": "^4.1.2",
-        "lodash.uniq": "^4.5.0"
-      }
-    },
-    "node_modules/caniuse-lite": {
-      "version": "1.0.30001690",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001690.tgz",
-      "integrity": "sha512-5ExiE3qQN6oF8Clf8ifIDcMRCRE/dMGcETG/XGMD8/XiXm6HXQgQTh1yZYLXXpSOsEUlJm1Xr7kGULZTuGtP/w==",
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/browserslist"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
+    "node_modules/ansi-html-community": {
+      "version": "0.0.8",
+      "resolved": "https://registry.facebook.net/ansi-html-community/-/ansi-html-community-0.0.8.tgz",
+      "integrity": "sha512-1APHAyr3+PCamwNw3bXCPp4HFLONZt/yIH0sZp0/469KWNTEy+qN5jQ3GVX6DMZ1UXAi34yVwtTeaG/HpBuuzw==",
+      "engines": [
+        "node >= 0.8.0"
       ],
-      "license": "CC-BY-4.0"
+      "license": "Apache-2.0",
+      "bin": {
+        "ansi-html": "bin/ansi-html"
+      }
     },
-    "node_modules/ccount": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/ccount/-/ccount-2.0.1.tgz",
-      "integrity": "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==",
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.facebook.net/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
       "license": "MIT",
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/wooorm"
+      "engines": {
+        "node": ">=8"
       }
     },
-    "node_modules/chalk": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
-      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.facebook.net/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
       "license": "MIT",
       "dependencies": {
-        "ansi-styles": "^4.1.0",
-        "supports-color": "^7.1.0"
+        "color-convert": "^2.0.1"
       },
       "engines": {
-        "node": ">=10"
+        "node": ">=8"
       },
       "funding": {
-        "url": "https://github.com/chalk/chalk?sponsor=1"
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
       }
     },
-    "node_modules/char-regex": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/char-regex/-/char-regex-1.0.2.tgz",
-      "integrity": "sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==",
-      "license": "MIT",
+    "node_modules/anymatch": {
+      "version": "3.1.3",
+      "resolved": "https://registry.facebook.net/anymatch/-/anymatch-3.1.3.tgz",
+      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+      "license": "ISC",
+      "dependencies": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      },
       "engines": {
-        "node": ">=10"
+        "node": ">= 8"
       }
     },
-    "node_modules/character-entities": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/character-entities/-/character-entities-2.0.2.tgz",
-      "integrity": "sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ==",
-      "license": "MIT",
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/wooorm"
-      }
+    "node_modules/arg": {
+      "version": "5.0.2",
+      "resolved": "https://registry.facebook.net/arg/-/arg-5.0.2.tgz",
+      "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==",
+      "license": "MIT"
     },
-    "node_modules/character-entities-html4": {
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "license": "Python-2.0"
+    },
+    "node_modules/array-flatten": {
+      "version": "1.1.1",
+      "resolved": "https://registry.facebook.net/array-flatten/-/array-flatten-1.1.1.tgz",
+      "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==",
+      "license": "MIT"
+    },
+    "node_modules/array-union": {
       "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-2.1.0.tgz",
-      "integrity": "sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==",
+      "resolved": "https://registry.facebook.net/array-union/-/array-union-2.1.0.tgz",
+      "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==",
       "license": "MIT",
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/wooorm"
+      "engines": {
+        "node": ">=8"
       }
     },
-    "node_modules/character-entities-legacy": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz",
-      "integrity": "sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==",
-      "license": "MIT",
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/wooorm"
+    "node_modules/asn1js": {
+      "version": "3.0.10",
+      "resolved": "https://registry.facebook.net/asn1js/-/asn1js-3.0.10.tgz",
+      "integrity": "sha512-S2s3aOytiKdFRdulw2qPE51MzjzVOisppcVv7jVFR+Kw0kxwvFrDcYA0h7Ndqbmj0HkMIXYWaoj7fli8kgx1eg==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "pvtsutils": "^1.3.6",
+        "pvutils": "^1.1.5",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=12.0.0"
       }
     },
-    "node_modules/character-reference-invalid": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/character-reference-invalid/-/character-reference-invalid-2.0.1.tgz",
-      "integrity": "sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw==",
+    "node_modules/astring": {
+      "version": "1.9.0",
+      "resolved": "https://registry.facebook.net/astring/-/astring-1.9.0.tgz",
+      "integrity": "sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg==",
       "license": "MIT",
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/wooorm"
+      "bin": {
+        "astring": "bin/astring"
       }
     },
-    "node_modules/cheerio": {
-      "version": "1.0.0-rc.12",
-      "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-1.0.0-rc.12.tgz",
-      "integrity": "sha512-VqR8m68vM46BNnuZ5NtnGBKIE/DfN0cRIzg9n40EIq9NOv90ayxLBXA8fXC5gquFRGJSTRqBq25Jt2ECLR431Q==",
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.facebook.net/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+      "license": "MIT"
+    },
+    "node_modules/autoprefixer": {
+      "version": "10.5.0",
+      "resolved": "https://registry.facebook.net/autoprefixer/-/autoprefixer-10.5.0.tgz",
+      "integrity": "sha512-FMhOoZV4+qR6aTUALKX2rEqGG+oyATvwBt9IIzVR5rMa2HRWPkxf+P+PAJLD1I/H5/II+HuZcBJYEFBpq39ong==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/autoprefixer"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
       "license": "MIT",
       "dependencies": {
-        "cheerio-select": "^2.1.0",
-        "dom-serializer": "^2.0.0",
-        "domhandler": "^5.0.3",
-        "domutils": "^3.0.1",
-        "htmlparser2": "^8.0.1",
-        "parse5": "^7.0.0",
-        "parse5-htmlparser2-tree-adapter": "^7.0.0"
+        "browserslist": "^4.28.2",
+        "caniuse-lite": "^1.0.30001787",
+        "fraction.js": "^5.3.4",
+        "picocolors": "^1.1.1",
+        "postcss-value-parser": "^4.2.0"
+      },
+      "bin": {
+        "autoprefixer": "bin/autoprefixer"
       },
       "engines": {
-        "node": ">= 6"
+        "node": "^10 || ^12 || >=14"
       },
-      "funding": {
-        "url": "https://github.com/cheeriojs/cheerio?sponsor=1"
+      "peerDependencies": {
+        "postcss": "^8.1.0"
       }
     },
-    "node_modules/cheerio-select": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/cheerio-select/-/cheerio-select-2.1.0.tgz",
-      "integrity": "sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==",
-      "license": "BSD-2-Clause",
+    "node_modules/axios": {
+      "version": "1.15.2",
+      "resolved": "https://registry.facebook.net/axios/-/axios-1.15.2.tgz",
+      "integrity": "sha512-wLrXxPtcrPTsNlJmKjkPnNPK2Ihe0hn0wGSaTEiHRPxwjvJwT3hKmXF4dpqxmPO9SoNb2FsYXj/xEo0gHN+D5A==",
+      "license": "MIT",
       "dependencies": {
-        "boolbase": "^1.0.0",
-        "css-select": "^5.1.0",
-        "css-what": "^6.1.0",
-        "domelementtype": "^2.3.0",
-        "domhandler": "^5.0.3",
-        "domutils": "^3.0.1"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/fb55"
+        "follow-redirects": "^1.15.11",
+        "form-data": "^4.0.5",
+        "proxy-from-env": "^2.1.0"
       }
     },
-    "node_modules/chokidar": {
-      "version": "3.6.0",
-      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
-      "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
+    "node_modules/babel-loader": {
+      "version": "9.2.1",
+      "resolved": "https://registry.facebook.net/babel-loader/-/babel-loader-9.2.1.tgz",
+      "integrity": "sha512-fqe8naHt46e0yIdkjUZYqddSXfej3AHajX+CSO5X7oy0EmPc6o5Xh+RClNoHjnieWz9AW4kZxW9yyFMhVB1QLA==",
       "license": "MIT",
       "dependencies": {
-        "anymatch": "~3.1.2",
-        "braces": "~3.0.2",
-        "glob-parent": "~5.1.2",
-        "is-binary-path": "~2.1.0",
-        "is-glob": "~4.0.1",
-        "normalize-path": "~3.0.0",
-        "readdirp": "~3.6.0"
+        "find-cache-dir": "^4.0.0",
+        "schema-utils": "^4.0.0"
       },
       "engines": {
-        "node": ">= 8.10.0"
-      },
-      "funding": {
-        "url": "https://paulmillr.com/funding/"
+        "node": ">= 14.15.0"
       },
-      "optionalDependencies": {
-        "fsevents": "~2.3.2"
+      "peerDependencies": {
+        "@babel/core": "^7.12.0",
+        "webpack": ">=5"
       }
     },
-    "node_modules/chrome-trace-event": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/chrome-trace-event/-/chrome-trace-event-1.0.4.tgz",
-      "integrity": "sha512-rNjApaLzuwaOTjCiT8lSDdGN1APCiqkChLMJxJPWLunPAt5fy8xgU9/jNOchV84wfIxrA0lRQB7oCT8jrn/wrQ==",
+    "node_modules/babel-plugin-dynamic-import-node": {
+      "version": "2.3.3",
+      "resolved": "https://registry.facebook.net/babel-plugin-dynamic-import-node/-/babel-plugin-dynamic-import-node-2.3.3.tgz",
+      "integrity": "sha512-jZVI+s9Zg3IqA/kdi0i6UDCybUI3aSBLnglhYbSSjKlV7yF1F/5LWv8MakQmvYpnbJDS6fcBL2KzHSxNCMtWSQ==",
       "license": "MIT",
-      "engines": {
-        "node": ">=6.0"
+      "dependencies": {
+        "object.assign": "^4.1.0"
       }
     },
-    "node_modules/ci-info": {
-      "version": "3.9.0",
-      "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-3.9.0.tgz",
-      "integrity": "sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/sibiraj-s"
-        }
-      ],
+    "node_modules/babel-plugin-polyfill-corejs2": {
+      "version": "0.4.17",
+      "resolved": "https://registry.facebook.net/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.17.tgz",
+      "integrity": "sha512-aTyf30K/rqAsNwN76zYrdtx8obu0E4KoUME29B1xj+B3WxgvWkp943vYQ+z8Mv3lw9xHXMHpvSPOBxzAkIa94w==",
       "license": "MIT",
-      "engines": {
-        "node": ">=8"
+      "dependencies": {
+        "@babel/compat-data": "^7.28.6",
+        "@babel/helper-define-polyfill-provider": "^0.6.8",
+        "semver": "^6.3.1"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
       }
     },
-    "node_modules/clean-css": {
-      "version": "5.3.3",
-      "resolved": "https://registry.npmjs.org/clean-css/-/clean-css-5.3.3.tgz",
-      "integrity": "sha512-D5J+kHaVb/wKSFcyyV75uCn8fiY4sV38XJoe4CUyGQ+mOU/fMVYUdH1hJC+CJQ5uY3EnW27SbJYS4X8BiLrAFg==",
+    "node_modules/babel-plugin-polyfill-corejs3": {
+      "version": "0.13.0",
+      "resolved": "https://registry.facebook.net/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.13.0.tgz",
+      "integrity": "sha512-U+GNwMdSFgzVmfhNm8GJUX88AadB3uo9KpJqS3FaqNIPKgySuvMb+bHPsOmmuWyIcuqZj/pzt1RUIUZns4y2+A==",
       "license": "MIT",
       "dependencies": {
-        "source-map": "~0.6.0"
+        "@babel/helper-define-polyfill-provider": "^0.6.5",
+        "core-js-compat": "^3.43.0"
       },
-      "engines": {
-        "node": ">= 10.0"
-      }
-    },
-    "node_modules/clean-css/node_modules/source-map": {
-      "version": "0.6.1",
-      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
-      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
-      "license": "BSD-3-Clause",
-      "engines": {
-        "node": ">=0.10.0"
+      "peerDependencies": {
+        "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
       }
     },
-    "node_modules/clean-stack": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/clean-stack/-/clean-stack-2.2.0.tgz",
-      "integrity": "sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==",
+    "node_modules/babel-plugin-polyfill-regenerator": {
+      "version": "0.6.8",
+      "resolved": "https://registry.facebook.net/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.6.8.tgz",
+      "integrity": "sha512-M762rNHfSF1EV3SLtnCJXFoQbbIIz0OyRwnCmV0KPC7qosSfCO0QLTSuJX3ayAebubhE6oYBAYPrBA5ljowaZg==",
       "license": "MIT",
-      "engines": {
-        "node": ">=6"
+      "dependencies": {
+        "@babel/helper-define-polyfill-provider": "^0.6.8"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
       }
     },
-    "node_modules/cli-boxes": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/cli-boxes/-/cli-boxes-3.0.0.tgz",
-      "integrity": "sha512-/lzGpEWL/8PfI0BmBOPRwp0c/wFNX1RdUML3jK/RcSBA9T8mZDdQpqYBKtCFTOfQbwPqWEOpjqW+Fnayc0969g==",
+    "node_modules/bail": {
+      "version": "2.0.2",
+      "resolved": "https://registry.facebook.net/bail/-/bail-2.0.2.tgz",
+      "integrity": "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==",
       "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
       }
     },
-    "node_modules/cli-table3": {
-      "version": "0.6.5",
-      "resolved": "https://registry.npmjs.org/cli-table3/-/cli-table3-0.6.5.tgz",
-      "integrity": "sha512-+W/5efTR7y5HRD7gACw9yQjqMVvEMLBHmboM/kPWam+H+Hmyrgjh6YncVKK122YZkXrLudzTuAukUw9FnMf7IQ==",
-      "license": "MIT",
-      "dependencies": {
-        "string-width": "^4.2.0"
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.facebook.net/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "license": "MIT"
+    },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.10.24",
+      "resolved": "https://registry.facebook.net/baseline-browser-mapping/-/baseline-browser-mapping-2.10.24.tgz",
+      "integrity": "sha512-I2NkZOOrj2XuguvWCK6OVh9GavsNjZjK908Rq3mIBK25+GD8vPX5w2WdxVqnQ7xx3SrZJiCiZFu+/Oz50oSYSA==",
+      "license": "Apache-2.0",
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.cjs"
       },
       "engines": {
-        "node": "10.* || >= 12.*"
-      },
-      "optionalDependencies": {
-        "@colors/colors": "1.5.0"
+        "node": ">=6.0.0"
       }
     },
-    "node_modules/cli-table3/node_modules/emoji-regex": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+    "node_modules/batch": {
+      "version": "0.6.1",
+      "resolved": "https://registry.facebook.net/batch/-/batch-0.6.1.tgz",
+      "integrity": "sha512-x+VAiMRL6UPkx+kudNvxTl6hB2XNNCG2r+7wixVfIYwu/2HKRXimwQyaumLjMveWvT2Hkd/cAJw+QBMfJ/EKVw==",
       "license": "MIT"
     },
-    "node_modules/cli-table3/node_modules/string-width": {
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+    "node_modules/big.js": {
+      "version": "5.2.2",
+      "resolved": "https://registry.facebook.net/big.js/-/big.js-5.2.2.tgz",
+      "integrity": "sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==",
       "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
-      },
       "engines": {
-        "node": ">=8"
+        "node": "*"
       }
     },
-    "node_modules/clone-deep": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/clone-deep/-/clone-deep-4.0.1.tgz",
-      "integrity": "sha512-neHB9xuzh/wk0dIHweyAXv2aPGZIVk3pLMe+/RNzINf17fe0OG96QroktYAUm7SM1PBnzTabaLboqqxDyMU+SQ==",
+    "node_modules/binary-extensions": {
+      "version": "2.3.0",
+      "resolved": "https://registry.facebook.net/binary-extensions/-/binary-extensions-2.3.0.tgz",
+      "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
       "license": "MIT",
-      "dependencies": {
-        "is-plain-object": "^2.0.4",
-        "kind-of": "^6.0.2",
-        "shallow-clone": "^3.0.0"
-      },
       "engines": {
-        "node": ">=6"
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/clsx": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",
-      "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==",
+    "node_modules/body-parser": {
+      "version": "1.20.5",
+      "resolved": "https://registry.facebook.net/body-parser/-/body-parser-1.20.5.tgz",
+      "integrity": "sha512-3grm+/2tUOvu2cjJkvsIxrv/wVpfXQW4PsQHYm7yk4vfpu7Ekl6nEsYBoJUL6qDwZUx8wUhQ8tR2qz+ad9c9OA==",
       "license": "MIT",
+      "dependencies": {
+        "bytes": "~3.1.2",
+        "content-type": "~1.0.5",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "~1.2.0",
+        "http-errors": "~2.0.1",
+        "iconv-lite": "~0.4.24",
+        "on-finished": "~2.4.1",
+        "qs": "~6.15.1",
+        "raw-body": "~2.5.3",
+        "type-is": "~1.6.18",
+        "unpipe": "~1.0.0"
+      },
       "engines": {
-        "node": ">=6"
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
       }
     },
-    "node_modules/collapse-white-space": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/collapse-white-space/-/collapse-white-space-2.1.0.tgz",
-      "integrity": "sha512-loKTxY1zCOuG4j9f6EPnuyyYkf58RnhhWTvRoZEokgB+WbdXehfjFviyOVYkqzEWz1Q5kRiZdBYS5SwxbQYwzw==",
+    "node_modules/body-parser/node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.facebook.net/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
       "license": "MIT",
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/wooorm"
+      "dependencies": {
+        "ms": "2.0.0"
       }
     },
-    "node_modules/color-convert": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-      "license": "MIT",
+    "node_modules/body-parser/node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "license": "MIT"
+    },
+    "node_modules/body-parser/node_modules/qs": {
+      "version": "6.15.1",
+      "resolved": "https://registry.facebook.net/qs/-/qs-6.15.1.tgz",
+      "integrity": "sha512-6YHEFRL9mfgcAvql/XhwTvf5jKcOiiupt2FiJxHkiX1z4j7WL8J/jRHYLluORvc1XxB5rV20KoeK00gVJamspg==",
+      "license": "BSD-3-Clause",
       "dependencies": {
-        "color-name": "~1.1.4"
+        "side-channel": "^1.1.0"
       },
       "engines": {
-        "node": ">=7.0.0"
+        "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/color-name": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
-      "license": "MIT"
-    },
-    "node_modules/colord": {
-      "version": "2.9.3",
-      "resolved": "https://registry.npmjs.org/colord/-/colord-2.9.3.tgz",
-      "integrity": "sha512-jeC1axXpnb0/2nn/Y1LPuLdgXBLH7aDcHu4KEKfqw3CUhX7ZpfBSlPKyqXE6btIgEzfWtrX3/tyBCaCvXvMkOw==",
-      "license": "MIT"
-    },
-    "node_modules/colorette": {
-      "version": "2.0.20",
-      "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.20.tgz",
-      "integrity": "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==",
-      "license": "MIT"
-    },
-    "node_modules/combine-promises": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/combine-promises/-/combine-promises-1.2.0.tgz",
-      "integrity": "sha512-VcQB1ziGD0NXrhKxiwyNbCDmRzs/OShMs2GqW2DlU2A/Sd0nQxE1oWDAE5O0ygSx5mgQOn9eIFh7yKPgFRVkPQ==",
+    "node_modules/bonjour-service": {
+      "version": "1.3.0",
+      "resolved": "https://registry.facebook.net/bonjour-service/-/bonjour-service-1.3.0.tgz",
+      "integrity": "sha512-3YuAUiSkWykd+2Azjgyxei8OWf8thdn8AITIog2M4UICzoqfjlqr64WIjEXZllf/W6vK1goqleSR6brGomxQqA==",
       "license": "MIT",
-      "engines": {
-        "node": ">=10"
+      "dependencies": {
+        "fast-deep-equal": "^3.1.3",
+        "multicast-dns": "^7.2.5"
       }
     },
-    "node_modules/combined-stream": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
-      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+    "node_modules/boolbase": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/boolbase/-/boolbase-1.0.0.tgz",
+      "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==",
+      "license": "ISC"
+    },
+    "node_modules/boxen": {
+      "version": "6.2.1",
+      "resolved": "https://registry.facebook.net/boxen/-/boxen-6.2.1.tgz",
+      "integrity": "sha512-H4PEsJXfFI/Pt8sjDWbHlQPx4zL/bvSQjcilJmaulGt5mLDorHOHpmdXAJcBcmru7PhYSp/cDMWRko4ZUMFkSw==",
       "license": "MIT",
       "dependencies": {
-        "delayed-stream": "~1.0.0"
+        "ansi-align": "^3.0.1",
+        "camelcase": "^6.2.0",
+        "chalk": "^4.1.2",
+        "cli-boxes": "^3.0.0",
+        "string-width": "^5.0.1",
+        "type-fest": "^2.5.0",
+        "widest-line": "^4.0.1",
+        "wrap-ansi": "^8.0.1"
       },
       "engines": {
-        "node": ">= 0.8"
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/comma-separated-tokens": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz",
-      "integrity": "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==",
+    "node_modules/brace-expansion": {
+      "version": "1.1.14",
+      "resolved": "https://registry.facebook.net/brace-expansion/-/brace-expansion-1.1.14.tgz",
+      "integrity": "sha512-MWPGfDxnyzKU7rNOW9SP/c50vi3xrmrua/+6hfPbCS2ABNWfx24vPidzvC7krjU/RTo235sV776ymlsMtGKj8g==",
       "license": "MIT",
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/wooorm"
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
       }
     },
-    "node_modules/commander": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/commander/-/commander-5.1.0.tgz",
-      "integrity": "sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg==",
+    "node_modules/braces": {
+      "version": "3.0.3",
+      "resolved": "https://registry.facebook.net/braces/-/braces-3.0.3.tgz",
+      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
       "license": "MIT",
+      "dependencies": {
+        "fill-range": "^7.1.1"
+      },
       "engines": {
-        "node": ">= 6"
+        "node": ">=8"
       }
     },
-    "node_modules/common-path-prefix": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/common-path-prefix/-/common-path-prefix-3.0.0.tgz",
-      "integrity": "sha512-QE33hToZseCH3jS0qN96O/bSh3kaw/h+Tq7ngyY9eWDUnTlTNUyqfqvCXioLe5Na5jFsL78ra/wuBU4iuEgd4w==",
-      "license": "ISC"
-    },
-    "node_modules/compressible": {
-      "version": "2.0.18",
-      "resolved": "https://registry.npmjs.org/compressible/-/compressible-2.0.18.tgz",
-      "integrity": "sha512-AF3r7P5dWxL8MxyITRMlORQNaOA2IkAFaTr4k7BUumjPtRpGDTZpl0Pb1XCO6JeDCBdp126Cgs9sMxqSjgYyRg==",
+    "node_modules/browserslist": {
+      "version": "4.28.2",
+      "resolved": "https://registry.facebook.net/browserslist/-/browserslist-4.28.2.tgz",
+      "integrity": "sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
       "license": "MIT",
       "dependencies": {
-        "mime-db": ">= 1.43.0 < 2"
+        "baseline-browser-mapping": "^2.10.12",
+        "caniuse-lite": "^1.0.30001782",
+        "electron-to-chromium": "^1.5.328",
+        "node-releases": "^2.0.36",
+        "update-browserslist-db": "^1.2.3"
+      },
+      "bin": {
+        "browserslist": "cli.js"
       },
       "engines": {
-        "node": ">= 0.6"
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
       }
     },
-    "node_modules/compression": {
-      "version": "1.8.1",
-      "resolved": "https://registry.npmjs.org/compression/-/compression-1.8.1.tgz",
-      "integrity": "sha512-9mAqGPHLakhCLeNyxPkK4xVo746zQ/czLH1Ky+vkitMnWfWZps8r0qXuwhwizagCRttsL4lfG4pIOvaWLpAP0w==",
+    "node_modules/buffer-from": {
+      "version": "1.1.2",
+      "resolved": "https://registry.facebook.net/buffer-from/-/buffer-from-1.1.2.tgz",
+      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
+      "license": "MIT"
+    },
+    "node_modules/bundle-name": {
+      "version": "4.1.0",
+      "resolved": "https://registry.facebook.net/bundle-name/-/bundle-name-4.1.0.tgz",
+      "integrity": "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==",
       "license": "MIT",
       "dependencies": {
-        "bytes": "3.1.2",
-        "compressible": "~2.0.18",
-        "debug": "2.6.9",
-        "negotiator": "~0.6.4",
-        "on-headers": "~1.1.0",
-        "safe-buffer": "5.2.1",
-        "vary": "~1.1.2"
+        "run-applescript": "^7.0.0"
       },
       "engines": {
-        "node": ">= 0.8.0"
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/compression/node_modules/bytes": {
+    "node_modules/bytes": {
       "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "resolved": "https://registry.facebook.net/bytes/-/bytes-3.1.2.tgz",
       "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
       "license": "MIT",
       "engines": {
         "node": ">= 0.8"
       }
     },
-    "node_modules/compression/node_modules/debug": {
-      "version": "2.6.9",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
-      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
-      "license": "MIT",
-      "dependencies": {
-        "ms": "2.0.0"
+    "node_modules/bytestreamjs": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/bytestreamjs/-/bytestreamjs-2.0.1.tgz",
+      "integrity": "sha512-U1Z/ob71V/bXfVABvNr/Kumf5VyeQRBEm6Txb0PQ6S7V5GpBM3w4Cbqz/xPDicR5tN0uvDifng8C+5qECeGwyQ==",
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=6.0.0"
       }
     },
-    "node_modules/compression/node_modules/ms": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
-      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
-      "license": "MIT"
-    },
-    "node_modules/concat-map": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
-      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
-      "license": "MIT"
-    },
-    "node_modules/config-chain": {
-      "version": "1.1.13",
-      "resolved": "https://registry.npmjs.org/config-chain/-/config-chain-1.1.13.tgz",
-      "integrity": "sha512-qj+f8APARXHrM0hraqXYb2/bOVSV4PvJQlNZ/DVj0QrmNM2q2euizkeuVckQ57J+W0mRH6Hvi+k50M4Jul2VRQ==",
+    "node_modules/cacheable-lookup": {
+      "version": "7.0.0",
+      "resolved": "https://registry.facebook.net/cacheable-lookup/-/cacheable-lookup-7.0.0.tgz",
+      "integrity": "sha512-+qJyx4xiKra8mZrcwhjMRMUhD5NR1R8esPkzIYxX96JiecFoxAXFuz/GpR3+ev4PE1WamHip78wV0vcmPQtp8w==",
       "license": "MIT",
-      "dependencies": {
-        "ini": "^1.3.4",
-        "proto-list": "~1.2.1"
+      "engines": {
+        "node": ">=14.16"
       }
     },
-    "node_modules/configstore": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/configstore/-/configstore-6.0.0.tgz",
-      "integrity": "sha512-cD31W1v3GqUlQvbBCGcXmd2Nj9SvLDOP1oQ0YFuLETufzSPaKp11rYBsSOm7rCsW3OnIRAFM3OxRhceaXNYHkA==",
-      "license": "BSD-2-Clause",
+    "node_modules/cacheable-request": {
+      "version": "10.2.14",
+      "resolved": "https://registry.facebook.net/cacheable-request/-/cacheable-request-10.2.14.tgz",
+      "integrity": "sha512-zkDT5WAF4hSSoUgyfg5tFIxz8XQK+25W/TLVojJTMKBaxevLBBtLxgqguAuVQB8PVW79FVjHcU+GJ9tVbDZ9mQ==",
+      "license": "MIT",
       "dependencies": {
-        "dot-prop": "^6.0.1",
-        "graceful-fs": "^4.2.6",
-        "unique-string": "^3.0.0",
-        "write-file-atomic": "^3.0.3",
-        "xdg-basedir": "^5.0.1"
+        "@types/http-cache-semantics": "^4.0.2",
+        "get-stream": "^6.0.1",
+        "http-cache-semantics": "^4.1.1",
+        "keyv": "^4.5.3",
+        "mimic-response": "^4.0.0",
+        "normalize-url": "^8.0.0",
+        "responselike": "^3.0.0"
       },
       "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/yeoman/configstore?sponsor=1"
+        "node": ">=14.16"
       }
     },
-    "node_modules/connect-history-api-fallback": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/connect-history-api-fallback/-/connect-history-api-fallback-2.0.0.tgz",
-      "integrity": "sha512-U73+6lQFmfiNPrYbXqr6kZ1i1wiRqXnp2nhMsINseWXO8lDau0LGEffJ8kQi4EjLZympVgRdvqjAgiZ1tgzDDA==",
+    "node_modules/cacheable-request/node_modules/mimic-response": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/mimic-response/-/mimic-response-4.0.0.tgz",
+      "integrity": "sha512-e5ISH9xMYU0DzrT+jl8q2ze9D6eWBto+I8CNpe+VI+K2J/F/k3PdkdTdz4wvGVH4NTpo+NRYTVIuMQEMMcsLqg==",
       "license": "MIT",
       "engines": {
-        "node": ">=0.8"
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/consola": {
-      "version": "3.3.3",
-      "resolved": "https://registry.npmjs.org/consola/-/consola-3.3.3.tgz",
-      "integrity": "sha512-Qil5KwghMzlqd51UXM0b6fyaGHtOC22scxrwrz4A2882LyUMwQjnvaedN1HAeXzphspQ6CpHkzMAWxBTUruDLg==",
+    "node_modules/call-bind": {
+      "version": "1.0.9",
+      "resolved": "https://registry.facebook.net/call-bind/-/call-bind-1.0.9.tgz",
+      "integrity": "sha512-a/hy+pNsFUTR+Iz8TCJvXudKVLAnz/DyeSUo10I5yvFDQJBFU2s9uqQpoSrJlroHUKoKqzg+epxyP9lqFdzfBQ==",
       "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "get-intrinsic": "^1.3.0",
+        "set-function-length": "^1.2.2"
+      },
       "engines": {
-        "node": "^14.18.0 || >=16.10.0"
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/content-disposition": {
-      "version": "0.5.2",
-      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.2.tgz",
-      "integrity": "sha512-kRGRZw3bLlFISDBgwTSA1TMBFN6J6GWDeubmDE3AF+3+yXL8hTWv8r5rkLbqYXY4RjPk/EzHnClI3zQf1cFmHA==",
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.facebook.net/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
       "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
       "engines": {
-        "node": ">= 0.6"
+        "node": ">= 0.4"
       }
     },
-    "node_modules/content-type": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
-      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+    "node_modules/call-bound": {
+      "version": "1.0.4",
+      "resolved": "https://registry.facebook.net/call-bound/-/call-bound-1.0.4.tgz",
+      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
       "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "get-intrinsic": "^1.3.0"
+      },
       "engines": {
-        "node": ">= 0.6"
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/convert-source-map": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
-      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
-      "license": "MIT"
-    },
-    "node_modules/cookie": {
-      "version": "0.7.1",
-      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.1.tgz",
-      "integrity": "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==",
+    "node_modules/callsites": {
+      "version": "3.1.0",
+      "resolved": "https://registry.facebook.net/callsites/-/callsites-3.1.0.tgz",
+      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
       "license": "MIT",
       "engines": {
-        "node": ">= 0.6"
+        "node": ">=6"
       }
     },
-    "node_modules/cookie-signature": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz",
-      "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==",
-      "license": "MIT"
+    "node_modules/camel-case": {
+      "version": "4.1.2",
+      "resolved": "https://registry.facebook.net/camel-case/-/camel-case-4.1.2.tgz",
+      "integrity": "sha512-gxGWBrTT1JuMx6R+o5PTXMmUnhnVzLQ9SNutD4YqKtI6ap897t3tKECYla6gCWEkplXnlNybEkZg9GEGxKFCgw==",
+      "license": "MIT",
+      "dependencies": {
+        "pascal-case": "^3.1.2",
+        "tslib": "^2.0.3"
+      }
     },
-    "node_modules/copy-text-to-clipboard": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/copy-text-to-clipboard/-/copy-text-to-clipboard-3.2.0.tgz",
-      "integrity": "sha512-RnJFp1XR/LOBDckxTib5Qjr/PMfkatD0MUCQgdpqS8MdKiNUzBjAQBEN6oUy+jW7LI93BBG3DtMB2KOOKpGs2Q==",
+    "node_modules/camelcase": {
+      "version": "6.3.0",
+      "resolved": "https://registry.facebook.net/camelcase/-/camelcase-6.3.0.tgz",
+      "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==",
       "license": "MIT",
       "engines": {
-        "node": ">=12"
+        "node": ">=10"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/copy-webpack-plugin": {
-      "version": "11.0.0",
-      "resolved": "https://registry.npmjs.org/copy-webpack-plugin/-/copy-webpack-plugin-11.0.0.tgz",
-      "integrity": "sha512-fX2MWpamkW0hZxMEg0+mYnA40LTosOSa5TqZ9GYIBzyJa9C3QUaMPSE2xAi/buNr8u89SfD9wHSQVBzrRa/SOQ==",
+    "node_modules/caniuse-api": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/caniuse-api/-/caniuse-api-3.0.0.tgz",
+      "integrity": "sha512-bsTwuIg/BZZK/vreVTYYbSWoe2F+71P7K5QGEX+pT250DZbfU1MQ5prOKpPR+LL6uWKK3KMwMCAS74QB3Um1uw==",
       "license": "MIT",
       "dependencies": {
-        "fast-glob": "^3.2.11",
-        "glob-parent": "^6.0.1",
-        "globby": "^13.1.1",
-        "normalize-path": "^3.0.0",
-        "schema-utils": "^4.0.0",
-        "serialize-javascript": "^6.0.0"
-      },
-      "engines": {
-        "node": ">= 14.15.0"
-      },
+        "browserslist": "^4.0.0",
+        "caniuse-lite": "^1.0.0",
+        "lodash.memoize": "^4.1.2",
+        "lodash.uniq": "^4.5.0"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001791",
+      "resolved": "https://registry.facebook.net/caniuse-lite/-/caniuse-lite-1.0.30001791.tgz",
+      "integrity": "sha512-yk0l/YSrOnFZk3UROpDLQD9+kC1l4meK/wed583AXrzoarMGJcbRi2Q4RaUYbKxYAsZ8sWmaSa/DsLmdBeI1vQ==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "CC-BY-4.0"
+    },
+    "node_modules/ccount": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/ccount/-/ccount-2.0.1.tgz",
+      "integrity": "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==",
+      "license": "MIT",
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/webpack"
-      },
-      "peerDependencies": {
-        "webpack": "^5.1.0"
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
       }
     },
-    "node_modules/copy-webpack-plugin/node_modules/glob-parent": {
-      "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
-      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
-      "license": "ISC",
+    "node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.facebook.net/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "license": "MIT",
       "dependencies": {
-        "is-glob": "^4.0.3"
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
       },
       "engines": {
-        "node": ">=10.13.0"
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
       }
     },
-    "node_modules/copy-webpack-plugin/node_modules/globby": {
-      "version": "13.2.2",
-      "resolved": "https://registry.npmjs.org/globby/-/globby-13.2.2.tgz",
-      "integrity": "sha512-Y1zNGV+pzQdh7H39l9zgB4PJqjRNqydvdYCDG4HFXM4XuvSaQQlEc91IU1yALL8gUTDomgBAfz3XJdmUS+oo0w==",
+    "node_modules/chalk/node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.facebook.net/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
       "license": "MIT",
       "dependencies": {
-        "dir-glob": "^3.0.1",
-        "fast-glob": "^3.3.0",
-        "ignore": "^5.2.4",
-        "merge2": "^1.4.1",
-        "slash": "^4.0.0"
+        "has-flag": "^4.0.0"
       },
       "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "node": ">=8"
       }
     },
-    "node_modules/copy-webpack-plugin/node_modules/slash": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/slash/-/slash-4.0.0.tgz",
-      "integrity": "sha512-3dOsAHXXUkQTpOYcoAxLIorMTp4gIQr5IW3iVb7A7lFIp0VHhnynm9izx6TssdrIcVIESAlVjtnO2K8bg+Coew==",
+    "node_modules/char-regex": {
+      "version": "1.0.2",
+      "resolved": "https://registry.facebook.net/char-regex/-/char-regex-1.0.2.tgz",
+      "integrity": "sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==",
       "license": "MIT",
       "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "node": ">=10"
       }
     },
-    "node_modules/core-js": {
-      "version": "3.39.0",
-      "resolved": "https://registry.npmjs.org/core-js/-/core-js-3.39.0.tgz",
-      "integrity": "sha512-raM0ew0/jJUqkJ0E6e8UDtl+y/7ktFivgWvqw8dNSQeNWoSDLvQ1H/RN3aPXB9tBd4/FhyR4RDPGhsNIMsAn7g==",
-      "hasInstallScript": true,
+    "node_modules/character-entities": {
+      "version": "2.0.2",
+      "resolved": "https://registry.facebook.net/character-entities/-/character-entities-2.0.2.tgz",
+      "integrity": "sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ==",
       "license": "MIT",
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/core-js"
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
       }
     },
-    "node_modules/core-js-compat": {
-      "version": "3.39.0",
-      "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.39.0.tgz",
-      "integrity": "sha512-VgEUx3VwlExr5no0tXlBt+silBvhTryPwCXRI2Id1PN8WTKu7MreethvddqOubrYxkFdv/RnYrqlv1sFNAUelw==",
+    "node_modules/character-entities-html4": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/character-entities-html4/-/character-entities-html4-2.1.0.tgz",
+      "integrity": "sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==",
       "license": "MIT",
-      "dependencies": {
-        "browserslist": "^4.24.2"
-      },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/core-js"
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
       }
     },
-    "node_modules/core-js-pure": {
-      "version": "3.39.0",
-      "resolved": "https://registry.npmjs.org/core-js-pure/-/core-js-pure-3.39.0.tgz",
-      "integrity": "sha512-7fEcWwKI4rJinnK+wLTezeg2smbFFdSBP6E2kQZNbnzM2s1rpKQ6aaRteZSSg7FLU3P0HGGVo/gbpfanU36urg==",
-      "hasInstallScript": true,
+    "node_modules/character-entities-legacy": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz",
+      "integrity": "sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==",
       "license": "MIT",
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/core-js"
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
       }
     },
-    "node_modules/core-util-is": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz",
-      "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==",
-      "license": "MIT"
+    "node_modules/character-reference-invalid": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/character-reference-invalid/-/character-reference-invalid-2.0.1.tgz",
+      "integrity": "sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
     },
-    "node_modules/cosmiconfig": {
-      "version": "8.3.6",
-      "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-8.3.6.tgz",
-      "integrity": "sha512-kcZ6+W5QzcJ3P1Mt+83OUv/oHFqZHIx8DuxG6eZ5RGMERoLqp4BuGjhHLYGK+Kf5XVkQvqBSmAy/nGWN3qDgEA==",
+    "node_modules/cheerio": {
+      "version": "1.0.0-rc.12",
+      "resolved": "https://registry.facebook.net/cheerio/-/cheerio-1.0.0-rc.12.tgz",
+      "integrity": "sha512-VqR8m68vM46BNnuZ5NtnGBKIE/DfN0cRIzg9n40EIq9NOv90ayxLBXA8fXC5gquFRGJSTRqBq25Jt2ECLR431Q==",
       "license": "MIT",
       "dependencies": {
-        "import-fresh": "^3.3.0",
-        "js-yaml": "^4.1.0",
-        "parse-json": "^5.2.0",
-        "path-type": "^4.0.0"
+        "cheerio-select": "^2.1.0",
+        "dom-serializer": "^2.0.0",
+        "domhandler": "^5.0.3",
+        "domutils": "^3.0.1",
+        "htmlparser2": "^8.0.1",
+        "parse5": "^7.0.0",
+        "parse5-htmlparser2-tree-adapter": "^7.0.0"
       },
       "engines": {
-        "node": ">=14"
+        "node": ">= 6"
       },
       "funding": {
-        "url": "https://github.com/sponsors/d-fischer"
-      },
-      "peerDependencies": {
-        "typescript": ">=4.9.5"
-      },
-      "peerDependenciesMeta": {
-        "typescript": {
-          "optional": true
-        }
+        "url": "https://github.com/cheeriojs/cheerio?sponsor=1"
       }
     },
-    "node_modules/cross-spawn": {
-      "version": "7.0.6",
-      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
-      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
-      "license": "MIT",
+    "node_modules/cheerio-select": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/cheerio-select/-/cheerio-select-2.1.0.tgz",
+      "integrity": "sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==",
+      "license": "BSD-2-Clause",
       "dependencies": {
-        "path-key": "^3.1.0",
-        "shebang-command": "^2.0.0",
-        "which": "^2.0.1"
+        "boolbase": "^1.0.0",
+        "css-select": "^5.1.0",
+        "css-what": "^6.1.0",
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.3",
+        "domutils": "^3.0.1"
       },
-      "engines": {
-        "node": ">= 8"
+      "funding": {
+        "url": "https://github.com/sponsors/fb55"
       }
     },
-    "node_modules/crypto-random-string": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/crypto-random-string/-/crypto-random-string-4.0.0.tgz",
-      "integrity": "sha512-x8dy3RnvYdlUcPOjkEHqozhiwzKNSq7GcPuXFbnyMOCHxX8V3OgIg/pYuabl2sbUPfIJaeAQB7PMOK8DFIdoRA==",
+    "node_modules/chokidar": {
+      "version": "3.6.0",
+      "resolved": "https://registry.facebook.net/chokidar/-/chokidar-3.6.0.tgz",
+      "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
       "license": "MIT",
       "dependencies": {
-        "type-fest": "^1.0.1"
+        "anymatch": "~3.1.2",
+        "braces": "~3.0.2",
+        "glob-parent": "~5.1.2",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.6.0"
       },
       "engines": {
-        "node": ">=12"
+        "node": ">= 8.10.0"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "url": "https://paulmillr.com/funding/"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.2"
       }
     },
-    "node_modules/crypto-random-string/node_modules/type-fest": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-1.4.0.tgz",
-      "integrity": "sha512-yGSza74xk0UG8k+pLh5oeoYirvIiWo5t0/o3zHHAO2tRDiZcxWP7fywNlXhqb6/r6sWvwi+RsyQMWhVLe4BVuA==",
-      "license": "(MIT OR CC0-1.0)",
+    "node_modules/chrome-trace-event": {
+      "version": "1.0.4",
+      "resolved": "https://registry.facebook.net/chrome-trace-event/-/chrome-trace-event-1.0.4.tgz",
+      "integrity": "sha512-rNjApaLzuwaOTjCiT8lSDdGN1APCiqkChLMJxJPWLunPAt5fy8xgU9/jNOchV84wfIxrA0lRQB7oCT8jrn/wrQ==",
+      "license": "MIT",
       "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "node": ">=6.0"
       }
     },
-    "node_modules/css-blank-pseudo": {
-      "version": "7.0.1",
-      "resolved": "https://registry.npmjs.org/css-blank-pseudo/-/css-blank-pseudo-7.0.1.tgz",
-      "integrity": "sha512-jf+twWGDf6LDoXDUode+nc7ZlrqfaNphrBIBrcmeP3D8yw1uPaix1gCC8LUQUGQ6CycuK2opkbFFWFuq/a94ag==",
+    "node_modules/ci-info": {
+      "version": "3.9.0",
+      "resolved": "https://registry.facebook.net/ci-info/-/ci-info-3.9.0.tgz",
+      "integrity": "sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==",
       "funding": [
         {
           "type": "github",
-          "url": "https://github.com/sponsors/csstools"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/csstools"
+          "url": "https://github.com/sponsors/sibiraj-s"
         }
       ],
-      "license": "MIT-0",
-      "dependencies": {
-        "postcss-selector-parser": "^7.0.0"
-      },
+      "license": "MIT",
       "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "postcss": "^8.4"
+        "node": ">=8"
       }
     },
-    "node_modules/css-blank-pseudo/node_modules/postcss-selector-parser": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.0.0.tgz",
-      "integrity": "sha512-9RbEr1Y7FFfptd/1eEdntyjMwLeghW1bHX9GWjXo19vx4ytPQhANltvVxDggzJl7mnWM+dX28kb6cyS/4iQjlQ==",
+    "node_modules/clean-css": {
+      "version": "5.3.3",
+      "resolved": "https://registry.facebook.net/clean-css/-/clean-css-5.3.3.tgz",
+      "integrity": "sha512-D5J+kHaVb/wKSFcyyV75uCn8fiY4sV38XJoe4CUyGQ+mOU/fMVYUdH1hJC+CJQ5uY3EnW27SbJYS4X8BiLrAFg==",
       "license": "MIT",
       "dependencies": {
-        "cssesc": "^3.0.0",
-        "util-deprecate": "^1.0.2"
+        "source-map": "~0.6.0"
       },
       "engines": {
-        "node": ">=4"
+        "node": ">= 10.0"
       }
     },
-    "node_modules/css-declaration-sorter": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/css-declaration-sorter/-/css-declaration-sorter-7.2.0.tgz",
-      "integrity": "sha512-h70rUM+3PNFuaBDTLe8wF/cdWu+dOZmb7pJt8Z2sedYbAcQVQV/tEchueg3GWxwqS0cxtbxmaHEdkNACqcvsow==",
-      "license": "ISC",
+    "node_modules/clean-stack": {
+      "version": "2.2.0",
+      "resolved": "https://registry.facebook.net/clean-stack/-/clean-stack-2.2.0.tgz",
+      "integrity": "sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==",
+      "license": "MIT",
       "engines": {
-        "node": "^14 || ^16 || >=18"
-      },
-      "peerDependencies": {
-        "postcss": "^8.0.9"
+        "node": ">=6"
       }
     },
-    "node_modules/css-has-pseudo": {
-      "version": "7.0.2",
-      "resolved": "https://registry.npmjs.org/css-has-pseudo/-/css-has-pseudo-7.0.2.tgz",
-      "integrity": "sha512-nzol/h+E0bId46Kn2dQH5VElaknX2Sr0hFuB/1EomdC7j+OISt2ZzK7EHX9DZDY53WbIVAR7FYKSO2XnSf07MQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/csstools"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/csstools"
-        }
-      ],
-      "license": "MIT-0",
-      "dependencies": {
-        "@csstools/selector-specificity": "^5.0.0",
-        "postcss-selector-parser": "^7.0.0",
-        "postcss-value-parser": "^4.2.0"
-      },
+    "node_modules/cli-boxes": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/cli-boxes/-/cli-boxes-3.0.0.tgz",
+      "integrity": "sha512-/lzGpEWL/8PfI0BmBOPRwp0c/wFNX1RdUML3jK/RcSBA9T8mZDdQpqYBKtCFTOfQbwPqWEOpjqW+Fnayc0969g==",
+      "license": "MIT",
       "engines": {
-        "node": ">=18"
+        "node": ">=10"
       },
-      "peerDependencies": {
-        "postcss": "^8.4"
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/css-has-pseudo/node_modules/@csstools/selector-specificity": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/@csstools/selector-specificity/-/selector-specificity-5.0.0.tgz",
-      "integrity": "sha512-PCqQV3c4CoVm3kdPhyeZ07VmBRdH2EpMFA/pd9OASpOEC3aXNGoqPDAZ80D0cLpMBxnmk0+yNhGsEx31hq7Gtw==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/csstools"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/csstools"
-        }
-      ],
-      "license": "MIT-0",
+    "node_modules/cli-table3": {
+      "version": "0.6.5",
+      "resolved": "https://registry.facebook.net/cli-table3/-/cli-table3-0.6.5.tgz",
+      "integrity": "sha512-+W/5efTR7y5HRD7gACw9yQjqMVvEMLBHmboM/kPWam+H+Hmyrgjh6YncVKK122YZkXrLudzTuAukUw9FnMf7IQ==",
+      "license": "MIT",
+      "dependencies": {
+        "string-width": "^4.2.0"
+      },
       "engines": {
-        "node": ">=18"
+        "node": "10.* || >= 12.*"
       },
-      "peerDependencies": {
-        "postcss-selector-parser": "^7.0.0"
+      "optionalDependencies": {
+        "@colors/colors": "1.5.0"
       }
     },
-    "node_modules/css-has-pseudo/node_modules/postcss-selector-parser": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.0.0.tgz",
-      "integrity": "sha512-9RbEr1Y7FFfptd/1eEdntyjMwLeghW1bHX9GWjXo19vx4ytPQhANltvVxDggzJl7mnWM+dX28kb6cyS/4iQjlQ==",
+    "node_modules/cli-table3/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.facebook.net/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "license": "MIT"
+    },
+    "node_modules/cli-table3/node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.facebook.net/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
       "license": "MIT",
       "dependencies": {
-        "cssesc": "^3.0.0",
-        "util-deprecate": "^1.0.2"
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
       },
       "engines": {
-        "node": ">=4"
+        "node": ">=8"
       }
     },
-    "node_modules/css-loader": {
-      "version": "6.11.0",
-      "resolved": "https://registry.npmjs.org/css-loader/-/css-loader-6.11.0.tgz",
-      "integrity": "sha512-CTJ+AEQJjq5NzLga5pE39qdiSV56F8ywCIsqNIRF0r7BDgWsN25aazToqAFg7ZrtA/U016xudB3ffgweORxX7g==",
+    "node_modules/clone-deep": {
+      "version": "4.0.1",
+      "resolved": "https://registry.facebook.net/clone-deep/-/clone-deep-4.0.1.tgz",
+      "integrity": "sha512-neHB9xuzh/wk0dIHweyAXv2aPGZIVk3pLMe+/RNzINf17fe0OG96QroktYAUm7SM1PBnzTabaLboqqxDyMU+SQ==",
       "license": "MIT",
       "dependencies": {
-        "icss-utils": "^5.1.0",
-        "postcss": "^8.4.33",
-        "postcss-modules-extract-imports": "^3.1.0",
-        "postcss-modules-local-by-default": "^4.0.5",
-        "postcss-modules-scope": "^3.2.0",
-        "postcss-modules-values": "^4.0.0",
-        "postcss-value-parser": "^4.2.0",
-        "semver": "^7.5.4"
+        "is-plain-object": "^2.0.4",
+        "kind-of": "^6.0.2",
+        "shallow-clone": "^3.0.0"
       },
       "engines": {
-        "node": ">= 12.13.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/webpack"
-      },
-      "peerDependencies": {
-        "@rspack/core": "0.x || 1.x",
-        "webpack": "^5.0.0"
-      },
-      "peerDependenciesMeta": {
-        "@rspack/core": {
-          "optional": true
-        },
-        "webpack": {
-          "optional": true
-        }
+        "node": ">=6"
       }
     },
-    "node_modules/css-minimizer-webpack-plugin": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/css-minimizer-webpack-plugin/-/css-minimizer-webpack-plugin-5.0.1.tgz",
-      "integrity": "sha512-3caImjKFQkS+ws1TGcFn0V1HyDJFq1Euy589JlD6/3rV2kj+w7r5G9WDMgSHvpvXHNZ2calVypZWuEDQd9wfLg==",
+    "node_modules/clsx": {
+      "version": "2.1.1",
+      "resolved": "https://registry.facebook.net/clsx/-/clsx-2.1.1.tgz",
+      "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==",
       "license": "MIT",
-      "dependencies": {
-        "@jridgewell/trace-mapping": "^0.3.18",
-        "cssnano": "^6.0.1",
-        "jest-worker": "^29.4.3",
-        "postcss": "^8.4.24",
-        "schema-utils": "^4.0.1",
-        "serialize-javascript": "^6.0.1"
-      },
       "engines": {
-        "node": ">= 14.15.0"
-      },
+        "node": ">=6"
+      }
+    },
+    "node_modules/collapse-white-space": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/collapse-white-space/-/collapse-white-space-2.1.0.tgz",
+      "integrity": "sha512-loKTxY1zCOuG4j9f6EPnuyyYkf58RnhhWTvRoZEokgB+WbdXehfjFviyOVYkqzEWz1Q5kRiZdBYS5SwxbQYwzw==",
+      "license": "MIT",
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/webpack"
-      },
-      "peerDependencies": {
-        "webpack": "^5.0.0"
-      },
-      "peerDependenciesMeta": {
-        "@parcel/css": {
-          "optional": true
-        },
-        "@swc/css": {
-          "optional": true
-        },
-        "clean-css": {
-          "optional": true
-        },
-        "csso": {
-          "optional": true
-        },
-        "esbuild": {
-          "optional": true
-        },
-        "lightningcss": {
-          "optional": true
-        }
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
       }
     },
-    "node_modules/css-prefers-color-scheme": {
-      "version": "10.0.0",
-      "resolved": "https://registry.npmjs.org/css-prefers-color-scheme/-/css-prefers-color-scheme-10.0.0.tgz",
-      "integrity": "sha512-VCtXZAWivRglTZditUfB4StnsWr6YVZ2PRtuxQLKTNRdtAf8tpzaVPE9zXIF3VaSc7O70iK/j1+NXxyQCqdPjQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/csstools"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/csstools"
-        }
-      ],
-      "license": "MIT-0",
-      "engines": {
-        "node": ">=18"
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
       },
-      "peerDependencies": {
-        "postcss": "^8.4"
+      "engines": {
+        "node": ">=7.0.0"
       }
     },
-    "node_modules/css-select": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/css-select/-/css-select-5.1.0.tgz",
-      "integrity": "sha512-nwoRF1rvRRnnCqqY7updORDsuqKzqYJ28+oSMaJMMgOauh3fvwHqMS7EZpIPqK8GL+g9mKxF1vP/ZjSeNjEVHg==",
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "boolbase": "^1.0.0",
-        "css-what": "^6.1.0",
-        "domhandler": "^5.0.2",
-        "domutils": "^3.0.1",
-        "nth-check": "^2.0.1"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/fb55"
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.facebook.net/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "license": "MIT"
+    },
+    "node_modules/colord": {
+      "version": "2.9.3",
+      "resolved": "https://registry.facebook.net/colord/-/colord-2.9.3.tgz",
+      "integrity": "sha512-jeC1axXpnb0/2nn/Y1LPuLdgXBLH7aDcHu4KEKfqw3CUhX7ZpfBSlPKyqXE6btIgEzfWtrX3/tyBCaCvXvMkOw==",
+      "license": "MIT"
+    },
+    "node_modules/colorette": {
+      "version": "2.0.20",
+      "resolved": "https://registry.facebook.net/colorette/-/colorette-2.0.20.tgz",
+      "integrity": "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==",
+      "license": "MIT"
+    },
+    "node_modules/combine-promises": {
+      "version": "1.2.0",
+      "resolved": "https://registry.facebook.net/combine-promises/-/combine-promises-1.2.0.tgz",
+      "integrity": "sha512-VcQB1ziGD0NXrhKxiwyNbCDmRzs/OShMs2GqW2DlU2A/Sd0nQxE1oWDAE5O0ygSx5mgQOn9eIFh7yKPgFRVkPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
       }
     },
-    "node_modules/css-tree": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-2.3.1.tgz",
-      "integrity": "sha512-6Fv1DV/TYw//QF5IzQdqsNDjx/wc8TrMBZsqjL9eW01tWb7R7k/mq+/VXfJCl7SoD5emsJop9cOByJZfs8hYIw==",
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.facebook.net/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
       "license": "MIT",
       "dependencies": {
-        "mdn-data": "2.0.30",
-        "source-map-js": "^1.0.1"
+        "delayed-stream": "~1.0.0"
       },
       "engines": {
-        "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0"
+        "node": ">= 0.8"
       }
     },
-    "node_modules/css-what": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/css-what/-/css-what-6.1.0.tgz",
-      "integrity": "sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==",
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">= 6"
-      },
+    "node_modules/comma-separated-tokens": {
+      "version": "2.0.3",
+      "resolved": "https://registry.facebook.net/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz",
+      "integrity": "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==",
+      "license": "MIT",
       "funding": {
-        "url": "https://github.com/sponsors/fb55"
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
       }
     },
-    "node_modules/cssdb": {
-      "version": "8.2.3",
-      "resolved": "https://registry.npmjs.org/cssdb/-/cssdb-8.2.3.tgz",
-      "integrity": "sha512-9BDG5XmJrJQQnJ51VFxXCAtpZ5ebDlAREmO8sxMOVU0aSxN/gocbctjIG5LMh3WBUq+xTlb/jw2LoljBEqraTA==",
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/csstools"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/csstools"
-        }
-      ],
-      "license": "MIT-0"
+    "node_modules/commander": {
+      "version": "5.1.0",
+      "resolved": "https://registry.facebook.net/commander/-/commander-5.1.0.tgz",
+      "integrity": "sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 6"
+      }
     },
-    "node_modules/cssesc": {
+    "node_modules/common-path-prefix": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz",
-      "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==",
+      "resolved": "https://registry.facebook.net/common-path-prefix/-/common-path-prefix-3.0.0.tgz",
+      "integrity": "sha512-QE33hToZseCH3jS0qN96O/bSh3kaw/h+Tq7ngyY9eWDUnTlTNUyqfqvCXioLe5Na5jFsL78ra/wuBU4iuEgd4w==",
+      "license": "ISC"
+    },
+    "node_modules/compressible": {
+      "version": "2.0.18",
+      "resolved": "https://registry.facebook.net/compressible/-/compressible-2.0.18.tgz",
+      "integrity": "sha512-AF3r7P5dWxL8MxyITRMlORQNaOA2IkAFaTr4k7BUumjPtRpGDTZpl0Pb1XCO6JeDCBdp126Cgs9sMxqSjgYyRg==",
       "license": "MIT",
-      "bin": {
-        "cssesc": "bin/cssesc"
+      "dependencies": {
+        "mime-db": ">= 1.43.0 < 2"
       },
       "engines": {
-        "node": ">=4"
+        "node": ">= 0.6"
       }
     },
-    "node_modules/cssnano": {
-      "version": "6.1.2",
-      "resolved": "https://registry.npmjs.org/cssnano/-/cssnano-6.1.2.tgz",
-      "integrity": "sha512-rYk5UeX7VAM/u0lNqewCdasdtPK81CgX8wJFLEIXHbV2oldWRgJAsZrdhRXkV1NJzA2g850KiFm9mMU2HxNxMA==",
+    "node_modules/compression": {
+      "version": "1.8.1",
+      "resolved": "https://registry.facebook.net/compression/-/compression-1.8.1.tgz",
+      "integrity": "sha512-9mAqGPHLakhCLeNyxPkK4xVo746zQ/czLH1Ky+vkitMnWfWZps8r0qXuwhwizagCRttsL4lfG4pIOvaWLpAP0w==",
       "license": "MIT",
       "dependencies": {
-        "cssnano-preset-default": "^6.1.2",
-        "lilconfig": "^3.1.1"
+        "bytes": "3.1.2",
+        "compressible": "~2.0.18",
+        "debug": "2.6.9",
+        "negotiator": "~0.6.4",
+        "on-headers": "~1.1.0",
+        "safe-buffer": "5.2.1",
+        "vary": "~1.1.2"
       },
       "engines": {
-        "node": "^14 || ^16 || >=18.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/cssnano"
-      },
-      "peerDependencies": {
-        "postcss": "^8.4.31"
+        "node": ">= 0.8.0"
       }
     },
-    "node_modules/cssnano-preset-advanced": {
-      "version": "6.1.2",
-      "resolved": "https://registry.npmjs.org/cssnano-preset-advanced/-/cssnano-preset-advanced-6.1.2.tgz",
-      "integrity": "sha512-Nhao7eD8ph2DoHolEzQs5CfRpiEP0xa1HBdnFZ82kvqdmbwVBUr2r1QuQ4t1pi+D1ZpqpcO4T+wy/7RxzJ/WPQ==",
+    "node_modules/compression/node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.facebook.net/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
       "license": "MIT",
       "dependencies": {
-        "autoprefixer": "^10.4.19",
-        "browserslist": "^4.23.0",
-        "cssnano-preset-default": "^6.1.2",
-        "postcss-discard-unused": "^6.0.5",
-        "postcss-merge-idents": "^6.0.3",
-        "postcss-reduce-idents": "^6.0.3",
-        "postcss-zindex": "^6.0.2"
-      },
-      "engines": {
-        "node": "^14 || ^16 || >=18.0"
-      },
-      "peerDependencies": {
-        "postcss": "^8.4.31"
+        "ms": "2.0.0"
       }
     },
-    "node_modules/cssnano-preset-default": {
-      "version": "6.1.2",
-      "resolved": "https://registry.npmjs.org/cssnano-preset-default/-/cssnano-preset-default-6.1.2.tgz",
-      "integrity": "sha512-1C0C+eNaeN8OcHQa193aRgYexyJtU8XwbdieEjClw+J9d94E41LwT6ivKH0WT+fYwYWB0Zp3I3IZ7tI/BbUbrg==",
+    "node_modules/compression/node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "license": "MIT"
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.facebook.net/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+      "license": "MIT"
+    },
+    "node_modules/config-chain": {
+      "version": "1.1.13",
+      "resolved": "https://registry.facebook.net/config-chain/-/config-chain-1.1.13.tgz",
+      "integrity": "sha512-qj+f8APARXHrM0hraqXYb2/bOVSV4PvJQlNZ/DVj0QrmNM2q2euizkeuVckQ57J+W0mRH6Hvi+k50M4Jul2VRQ==",
       "license": "MIT",
       "dependencies": {
-        "browserslist": "^4.23.0",
-        "css-declaration-sorter": "^7.2.0",
-        "cssnano-utils": "^4.0.2",
-        "postcss-calc": "^9.0.1",
-        "postcss-colormin": "^6.1.0",
-        "postcss-convert-values": "^6.1.0",
-        "postcss-discard-comments": "^6.0.2",
-        "postcss-discard-duplicates": "^6.0.3",
-        "postcss-discard-empty": "^6.0.3",
-        "postcss-discard-overridden": "^6.0.2",
-        "postcss-merge-longhand": "^6.0.5",
-        "postcss-merge-rules": "^6.1.1",
-        "postcss-minify-font-values": "^6.1.0",
-        "postcss-minify-gradients": "^6.0.3",
-        "postcss-minify-params": "^6.1.0",
-        "postcss-minify-selectors": "^6.0.4",
-        "postcss-normalize-charset": "^6.0.2",
-        "postcss-normalize-display-values": "^6.0.2",
-        "postcss-normalize-positions": "^6.0.2",
-        "postcss-normalize-repeat-style": "^6.0.2",
-        "postcss-normalize-string": "^6.0.2",
-        "postcss-normalize-timing-functions": "^6.0.2",
-        "postcss-normalize-unicode": "^6.1.0",
-        "postcss-normalize-url": "^6.0.2",
-        "postcss-normalize-whitespace": "^6.0.2",
-        "postcss-ordered-values": "^6.0.2",
-        "postcss-reduce-initial": "^6.1.0",
-        "postcss-reduce-transforms": "^6.0.2",
-        "postcss-svgo": "^6.0.3",
-        "postcss-unique-selectors": "^6.0.4"
+        "ini": "^1.3.4",
+        "proto-list": "~1.2.1"
+      }
+    },
+    "node_modules/configstore": {
+      "version": "6.0.0",
+      "resolved": "https://registry.facebook.net/configstore/-/configstore-6.0.0.tgz",
+      "integrity": "sha512-cD31W1v3GqUlQvbBCGcXmd2Nj9SvLDOP1oQ0YFuLETufzSPaKp11rYBsSOm7rCsW3OnIRAFM3OxRhceaXNYHkA==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "dot-prop": "^6.0.1",
+        "graceful-fs": "^4.2.6",
+        "unique-string": "^3.0.0",
+        "write-file-atomic": "^3.0.3",
+        "xdg-basedir": "^5.0.1"
       },
       "engines": {
-        "node": "^14 || ^16 || >=18.0"
+        "node": ">=12"
       },
-      "peerDependencies": {
-        "postcss": "^8.4.31"
+      "funding": {
+        "url": "https://github.com/yeoman/configstore?sponsor=1"
       }
     },
-    "node_modules/cssnano-utils": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/cssnano-utils/-/cssnano-utils-4.0.2.tgz",
-      "integrity": "sha512-ZR1jHg+wZ8o4c3zqf1SIUSTIvm/9mU343FMR6Obe/unskbvpGhZOo1J6d/r8D1pzkRQYuwbcH3hToOuoA2G7oQ==",
+    "node_modules/connect-history-api-fallback": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/connect-history-api-fallback/-/connect-history-api-fallback-2.0.0.tgz",
+      "integrity": "sha512-U73+6lQFmfiNPrYbXqr6kZ1i1wiRqXnp2nhMsINseWXO8lDau0LGEffJ8kQi4EjLZympVgRdvqjAgiZ1tgzDDA==",
       "license": "MIT",
       "engines": {
-        "node": "^14 || ^16 || >=18.0"
-      },
-      "peerDependencies": {
-        "postcss": "^8.4.31"
+        "node": ">=0.8"
       }
     },
-    "node_modules/csso": {
-      "version": "5.0.5",
-      "resolved": "https://registry.npmjs.org/csso/-/csso-5.0.5.tgz",
-      "integrity": "sha512-0LrrStPOdJj+SPCCrGhzryycLjwcgUSHBtxNA8aIDxf0GLsRh1cKYhB00Gd1lDOS4yGH69+SNn13+TWbVHETFQ==",
+    "node_modules/consola": {
+      "version": "3.4.2",
+      "resolved": "https://registry.facebook.net/consola/-/consola-3.4.2.tgz",
+      "integrity": "sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA==",
       "license": "MIT",
-      "dependencies": {
-        "css-tree": "~2.2.0"
-      },
       "engines": {
-        "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0",
-        "npm": ">=7.0.0"
+        "node": "^14.18.0 || >=16.10.0"
       }
     },
-    "node_modules/csso/node_modules/css-tree": {
-      "version": "2.2.1",
-      "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-2.2.1.tgz",
-      "integrity": "sha512-OA0mILzGc1kCOCSJerOeqDxDQ4HOh+G8NbOJFOTgOCzpw7fCBubk0fEyxp8AgOL/jvLgYA/uV0cMbe43ElF1JA==",
+    "node_modules/content-disposition": {
+      "version": "0.5.2",
+      "resolved": "https://registry.facebook.net/content-disposition/-/content-disposition-0.5.2.tgz",
+      "integrity": "sha512-kRGRZw3bLlFISDBgwTSA1TMBFN6J6GWDeubmDE3AF+3+yXL8hTWv8r5rkLbqYXY4RjPk/EzHnClI3zQf1cFmHA==",
       "license": "MIT",
-      "dependencies": {
-        "mdn-data": "2.0.28",
-        "source-map-js": "^1.0.1"
-      },
       "engines": {
-        "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0",
-        "npm": ">=7.0.0"
+        "node": ">= 0.6"
       }
     },
-    "node_modules/csso/node_modules/mdn-data": {
-      "version": "2.0.28",
-      "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.0.28.tgz",
-      "integrity": "sha512-aylIc7Z9y4yzHYAJNuESG3hfhC+0Ibp/MAMiaOZgNv4pmEdFyfZhhhny4MNiAfWdBQ1RQ2mfDWmM1x8SvGyp8g==",
-      "license": "CC0-1.0"
+    "node_modules/content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.facebook.net/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
     },
-    "node_modules/csstype": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz",
-      "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==",
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
       "license": "MIT"
     },
-    "node_modules/debounce": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/debounce/-/debounce-1.2.1.tgz",
-      "integrity": "sha512-XRRe6Glud4rd/ZGQfiV1ruXSfbvfJedlV9Y6zOlP+2K04vBYiJEte6stfFkCP03aMnY5tsipamumUjL14fofug==",
+    "node_modules/cookie": {
+      "version": "0.7.2",
+      "resolved": "https://registry.facebook.net/cookie/-/cookie-0.7.2.tgz",
+      "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie-signature": {
+      "version": "1.0.7",
+      "resolved": "https://registry.facebook.net/cookie-signature/-/cookie-signature-1.0.7.tgz",
+      "integrity": "sha512-NXdYc3dLr47pBkpUCHtKSwIOQXLVn8dZEuywboCOJY/osA0wFSLlSawr3KN8qXJEyX66FcONTH8EIlVuK0yyFA==",
       "license": "MIT"
     },
-    "node_modules/debug": {
-      "version": "4.4.0",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz",
-      "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==",
+    "node_modules/copy-text-to-clipboard": {
+      "version": "3.2.2",
+      "resolved": "https://registry.facebook.net/copy-text-to-clipboard/-/copy-text-to-clipboard-3.2.2.tgz",
+      "integrity": "sha512-T6SqyLd1iLuqPA90J5N4cTalrtovCySh58iiZDGJ6FGznbclKh4UI+FGacQSgFzwKG77W7XT5gwbVEbd9cIH1A==",
       "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
       "engines": {
-        "node": ">=6.0"
+        "node": ">=12"
       },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/decode-named-character-reference": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/decode-named-character-reference/-/decode-named-character-reference-1.0.2.tgz",
-      "integrity": "sha512-O8x12RzrUF8xyVcY0KJowWsmaJxQbmy0/EtnNtHRpsOcT7dFk5W598coHqBVpmWo1oQQfsCqfCmkZN5DJrZVdg==",
+    "node_modules/copy-webpack-plugin": {
+      "version": "11.0.0",
+      "resolved": "https://registry.facebook.net/copy-webpack-plugin/-/copy-webpack-plugin-11.0.0.tgz",
+      "integrity": "sha512-fX2MWpamkW0hZxMEg0+mYnA40LTosOSa5TqZ9GYIBzyJa9C3QUaMPSE2xAi/buNr8u89SfD9wHSQVBzrRa/SOQ==",
       "license": "MIT",
       "dependencies": {
-        "character-entities": "^2.0.0"
+        "fast-glob": "^3.2.11",
+        "glob-parent": "^6.0.1",
+        "globby": "^13.1.1",
+        "normalize-path": "^3.0.0",
+        "schema-utils": "^4.0.0",
+        "serialize-javascript": "^6.0.0"
+      },
+      "engines": {
+        "node": ">= 14.15.0"
       },
       "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/wooorm"
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
+      },
+      "peerDependencies": {
+        "webpack": "^5.1.0"
       }
     },
-    "node_modules/decompress-response": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz",
-      "integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==",
+    "node_modules/copy-webpack-plugin/node_modules/glob-parent": {
+      "version": "6.0.2",
+      "resolved": "https://registry.facebook.net/glob-parent/-/glob-parent-6.0.2.tgz",
+      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/copy-webpack-plugin/node_modules/globby": {
+      "version": "13.2.2",
+      "resolved": "https://registry.facebook.net/globby/-/globby-13.2.2.tgz",
+      "integrity": "sha512-Y1zNGV+pzQdh7H39l9zgB4PJqjRNqydvdYCDG4HFXM4XuvSaQQlEc91IU1yALL8gUTDomgBAfz3XJdmUS+oo0w==",
       "license": "MIT",
       "dependencies": {
-        "mimic-response": "^3.1.0"
+        "dir-glob": "^3.0.1",
+        "fast-glob": "^3.3.0",
+        "ignore": "^5.2.4",
+        "merge2": "^1.4.1",
+        "slash": "^4.0.0"
       },
       "engines": {
-        "node": ">=10"
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/decompress-response/node_modules/mimic-response": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-3.1.0.tgz",
-      "integrity": "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==",
+    "node_modules/copy-webpack-plugin/node_modules/slash": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/slash/-/slash-4.0.0.tgz",
+      "integrity": "sha512-3dOsAHXXUkQTpOYcoAxLIorMTp4gIQr5IW3iVb7A7lFIp0VHhnynm9izx6TssdrIcVIESAlVjtnO2K8bg+Coew==",
       "license": "MIT",
       "engines": {
-        "node": ">=10"
+        "node": ">=12"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/deep-extend": {
-      "version": "0.6.0",
-      "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz",
-      "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==",
+    "node_modules/core-js": {
+      "version": "3.49.0",
+      "resolved": "https://registry.facebook.net/core-js/-/core-js-3.49.0.tgz",
+      "integrity": "sha512-es1U2+YTtzpwkxVLwAFdSpaIMyQaq0PBgm3YD1W3Qpsn1NAmO3KSgZfu+oGSWVu6NvLHoHCV/aYcsE5wiB7ALg==",
+      "hasInstallScript": true,
       "license": "MIT",
-      "engines": {
-        "node": ">=4.0.0"
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/core-js"
       }
     },
-    "node_modules/deepmerge": {
-      "version": "4.3.1",
-      "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz",
-      "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==",
+    "node_modules/core-js-compat": {
+      "version": "3.49.0",
+      "resolved": "https://registry.facebook.net/core-js-compat/-/core-js-compat-3.49.0.tgz",
+      "integrity": "sha512-VQXt1jr9cBz03b331DFDCCP90b3fanciLkgiOoy8SBHy06gNf+vQ1A3WFLqG7I8TipYIKeYK9wxd0tUrvHcOZA==",
       "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/default-gateway": {
-      "version": "6.0.3",
-      "resolved": "https://registry.npmjs.org/default-gateway/-/default-gateway-6.0.3.tgz",
-      "integrity": "sha512-fwSOJsbbNzZ/CUFpqFBqYfYNLj1NbMPm8MMCIzHjC83iSJRBEGmDUxU+WP661BaBQImeC2yHwXtz+P/O9o+XEg==",
-      "license": "BSD-2-Clause",
       "dependencies": {
-        "execa": "^5.0.0"
+        "browserslist": "^4.28.1"
       },
-      "engines": {
-        "node": ">= 10"
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/core-js"
       }
     },
-    "node_modules/defer-to-connect": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-2.0.1.tgz",
-      "integrity": "sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      }
+    "node_modules/core-util-is": {
+      "version": "1.0.3",
+      "resolved": "https://registry.facebook.net/core-util-is/-/core-util-is-1.0.3.tgz",
+      "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==",
+      "license": "MIT"
     },
-    "node_modules/define-data-property": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",
-      "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
+    "node_modules/cosmiconfig": {
+      "version": "8.3.6",
+      "resolved": "https://registry.facebook.net/cosmiconfig/-/cosmiconfig-8.3.6.tgz",
+      "integrity": "sha512-kcZ6+W5QzcJ3P1Mt+83OUv/oHFqZHIx8DuxG6eZ5RGMERoLqp4BuGjhHLYGK+Kf5XVkQvqBSmAy/nGWN3qDgEA==",
       "license": "MIT",
       "dependencies": {
-        "es-define-property": "^1.0.0",
-        "es-errors": "^1.3.0",
-        "gopd": "^1.0.1"
+        "import-fresh": "^3.3.0",
+        "js-yaml": "^4.1.0",
+        "parse-json": "^5.2.0",
+        "path-type": "^4.0.0"
       },
       "engines": {
-        "node": ">= 0.4"
+        "node": ">=14"
       },
       "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "url": "https://github.com/sponsors/d-fischer"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.9.5"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
       }
     },
-    "node_modules/define-lazy-prop": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-2.0.0.tgz",
-      "integrity": "sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==",
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.facebook.net/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
       "license": "MIT",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
       "engines": {
-        "node": ">=8"
+        "node": ">= 8"
       }
     },
-    "node_modules/define-properties": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz",
-      "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==",
+    "node_modules/crypto-random-string": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/crypto-random-string/-/crypto-random-string-4.0.0.tgz",
+      "integrity": "sha512-x8dy3RnvYdlUcPOjkEHqozhiwzKNSq7GcPuXFbnyMOCHxX8V3OgIg/pYuabl2sbUPfIJaeAQB7PMOK8DFIdoRA==",
       "license": "MIT",
       "dependencies": {
-        "define-data-property": "^1.0.1",
-        "has-property-descriptors": "^1.0.0",
-        "object-keys": "^1.1.1"
+        "type-fest": "^1.0.1"
       },
       "engines": {
-        "node": ">= 0.4"
+        "node": ">=12"
       },
       "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/del": {
-      "version": "6.1.1",
-      "resolved": "https://registry.npmjs.org/del/-/del-6.1.1.tgz",
-      "integrity": "sha512-ua8BhapfP0JUJKC/zV9yHHDW/rDoDxP4Zhn3AkA6/xT6gY7jYXJiaeyBZznYVujhZZET+UgcbZiQ7sN3WqcImg==",
-      "license": "MIT",
-      "dependencies": {
-        "globby": "^11.0.1",
-        "graceful-fs": "^4.2.4",
-        "is-glob": "^4.0.1",
-        "is-path-cwd": "^2.2.0",
-        "is-path-inside": "^3.0.2",
-        "p-map": "^4.0.0",
-        "rimraf": "^3.0.2",
-        "slash": "^3.0.0"
-      },
+    "node_modules/crypto-random-string/node_modules/type-fest": {
+      "version": "1.4.0",
+      "resolved": "https://registry.facebook.net/type-fest/-/type-fest-1.4.0.tgz",
+      "integrity": "sha512-yGSza74xk0UG8k+pLh5oeoYirvIiWo5t0/o3zHHAO2tRDiZcxWP7fywNlXhqb6/r6sWvwi+RsyQMWhVLe4BVuA==",
+      "license": "(MIT OR CC0-1.0)",
       "engines": {
         "node": ">=10"
       },
@@ -7192,3005 +7395,2793 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/delayed-stream": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
-      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
-      "license": "MIT",
+    "node_modules/css-blank-pseudo": {
+      "version": "7.0.1",
+      "resolved": "https://registry.facebook.net/css-blank-pseudo/-/css-blank-pseudo-7.0.1.tgz",
+      "integrity": "sha512-jf+twWGDf6LDoXDUode+nc7ZlrqfaNphrBIBrcmeP3D8yw1uPaix1gCC8LUQUGQ6CycuK2opkbFFWFuq/a94ag==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "dependencies": {
+        "postcss-selector-parser": "^7.0.0"
+      },
       "engines": {
-        "node": ">=0.4.0"
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "postcss": "^8.4"
       }
     },
-    "node_modules/depd": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
-      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
-      "license": "MIT",
+    "node_modules/css-declaration-sorter": {
+      "version": "7.4.0",
+      "resolved": "https://registry.facebook.net/css-declaration-sorter/-/css-declaration-sorter-7.4.0.tgz",
+      "integrity": "sha512-LTuzjPoyA2vMGKKcaOqKSp7Ub2eGrNfKiZH4LpezxpNrsICGCSFvsQOI29psISxNZtaXibkC2CXzrQ5enMeGGw==",
+      "license": "ISC",
       "engines": {
-        "node": ">= 0.8"
+        "node": "^14 || ^16 || >=18"
+      },
+      "peerDependencies": {
+        "postcss": "^8.0.9"
       }
     },
-    "node_modules/dequal": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
-      "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
-      "license": "MIT",
+    "node_modules/css-has-pseudo": {
+      "version": "7.0.3",
+      "resolved": "https://registry.facebook.net/css-has-pseudo/-/css-has-pseudo-7.0.3.tgz",
+      "integrity": "sha512-oG+vKuGyqe/xvEMoxAQrhi7uY16deJR3i7wwhBerVrGQKSqUC5GiOVxTpM9F9B9hw0J+eKeOWLH7E9gZ1Dr5rA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "dependencies": {
+        "@csstools/selector-specificity": "^5.0.0",
+        "postcss-selector-parser": "^7.0.0",
+        "postcss-value-parser": "^4.2.0"
+      },
       "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/destroy": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
-      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8",
-        "npm": "1.2.8000 || >= 1.4.16"
-      }
-    },
-    "node_modules/detect-node": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/detect-node/-/detect-node-2.1.0.tgz",
-      "integrity": "sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==",
-      "license": "MIT"
-    },
-    "node_modules/detect-port": {
-      "version": "1.6.1",
-      "resolved": "https://registry.npmjs.org/detect-port/-/detect-port-1.6.1.tgz",
-      "integrity": "sha512-CmnVc+Hek2egPx1PeTFVta2W78xy2K/9Rkf6cC4T59S50tVnzKj+tnx5mmx5lwvCkujZ4uRrpRSuV+IVs3f90Q==",
-      "license": "MIT",
-      "dependencies": {
-        "address": "^1.0.1",
-        "debug": "4"
-      },
-      "bin": {
-        "detect": "bin/detect-port.js",
-        "detect-port": "bin/detect-port.js"
+        "node": ">=18"
       },
-      "engines": {
-        "node": ">= 4.0.0"
+      "peerDependencies": {
+        "postcss": "^8.4"
       }
     },
-    "node_modules/detect-port-alt": {
-      "version": "1.1.6",
-      "resolved": "https://registry.npmjs.org/detect-port-alt/-/detect-port-alt-1.1.6.tgz",
-      "integrity": "sha512-5tQykt+LqfJFBEYaDITx7S7cR7mJ/zQmLXZ2qt5w04ainYZw6tBf9dBunMjVeVOdYVRUzUOE4HkY5J7+uttb5Q==",
+    "node_modules/css-loader": {
+      "version": "6.11.0",
+      "resolved": "https://registry.facebook.net/css-loader/-/css-loader-6.11.0.tgz",
+      "integrity": "sha512-CTJ+AEQJjq5NzLga5pE39qdiSV56F8ywCIsqNIRF0r7BDgWsN25aazToqAFg7ZrtA/U016xudB3ffgweORxX7g==",
       "license": "MIT",
       "dependencies": {
-        "address": "^1.0.1",
-        "debug": "^2.6.0"
-      },
-      "bin": {
-        "detect": "bin/detect-port",
-        "detect-port": "bin/detect-port"
+        "icss-utils": "^5.1.0",
+        "postcss": "^8.4.33",
+        "postcss-modules-extract-imports": "^3.1.0",
+        "postcss-modules-local-by-default": "^4.0.5",
+        "postcss-modules-scope": "^3.2.0",
+        "postcss-modules-values": "^4.0.0",
+        "postcss-value-parser": "^4.2.0",
+        "semver": "^7.5.4"
       },
       "engines": {
-        "node": ">= 4.2.1"
-      }
-    },
-    "node_modules/detect-port-alt/node_modules/debug": {
-      "version": "2.6.9",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
-      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
-      "license": "MIT",
-      "dependencies": {
-        "ms": "2.0.0"
-      }
-    },
-    "node_modules/detect-port-alt/node_modules/ms": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
-      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
-      "license": "MIT"
-    },
-    "node_modules/devlop": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/devlop/-/devlop-1.1.0.tgz",
-      "integrity": "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==",
-      "license": "MIT",
-      "dependencies": {
-        "dequal": "^2.0.0"
+        "node": ">= 12.13.0"
       },
       "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/wooorm"
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
+      },
+      "peerDependencies": {
+        "@rspack/core": "0.x || 1.x",
+        "webpack": "^5.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@rspack/core": {
+          "optional": true
+        },
+        "webpack": {
+          "optional": true
+        }
       }
     },
-    "node_modules/dir-glob": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz",
-      "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==",
-      "license": "MIT",
-      "dependencies": {
-        "path-type": "^4.0.0"
+    "node_modules/css-loader/node_modules/semver": {
+      "version": "7.7.4",
+      "resolved": "https://registry.facebook.net/semver/-/semver-7.7.4.tgz",
+      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
       },
       "engines": {
-        "node": ">=8"
+        "node": ">=10"
       }
     },
-    "node_modules/dns-packet": {
-      "version": "5.6.1",
-      "resolved": "https://registry.npmjs.org/dns-packet/-/dns-packet-5.6.1.tgz",
-      "integrity": "sha512-l4gcSouhcgIKRvyy99RNVOgxXiicE+2jZoNmaNmZ6JXiGajBOJAesk1OBlJuM5k2c+eudGdLxDqXuPCKIj6kpw==",
+    "node_modules/css-minimizer-webpack-plugin": {
+      "version": "5.0.1",
+      "resolved": "https://registry.facebook.net/css-minimizer-webpack-plugin/-/css-minimizer-webpack-plugin-5.0.1.tgz",
+      "integrity": "sha512-3caImjKFQkS+ws1TGcFn0V1HyDJFq1Euy589JlD6/3rV2kj+w7r5G9WDMgSHvpvXHNZ2calVypZWuEDQd9wfLg==",
       "license": "MIT",
       "dependencies": {
-        "@leichtgewicht/ip-codec": "^2.0.1"
+        "@jridgewell/trace-mapping": "^0.3.18",
+        "cssnano": "^6.0.1",
+        "jest-worker": "^29.4.3",
+        "postcss": "^8.4.24",
+        "schema-utils": "^4.0.1",
+        "serialize-javascript": "^6.0.1"
       },
       "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/dom-converter": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/dom-converter/-/dom-converter-0.2.0.tgz",
-      "integrity": "sha512-gd3ypIPfOMr9h5jIKq8E3sHOTCjeirnl0WK5ZdS1AW0Odt0b1PaWaHdJ4Qk4klv+YB9aJBS7mESXjFoDQPu6DA==",
-      "license": "MIT",
-      "dependencies": {
-        "utila": "~0.4"
+        "node": ">= 14.15.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
+      },
+      "peerDependencies": {
+        "webpack": "^5.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@parcel/css": {
+          "optional": true
+        },
+        "@swc/css": {
+          "optional": true
+        },
+        "clean-css": {
+          "optional": true
+        },
+        "csso": {
+          "optional": true
+        },
+        "esbuild": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        }
       }
     },
-    "node_modules/dom-serializer": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz",
-      "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==",
+    "node_modules/css-minimizer-webpack-plugin/node_modules/jest-worker": {
+      "version": "29.7.0",
+      "resolved": "https://registry.facebook.net/jest-worker/-/jest-worker-29.7.0.tgz",
+      "integrity": "sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw==",
       "license": "MIT",
       "dependencies": {
-        "domelementtype": "^2.3.0",
-        "domhandler": "^5.0.2",
-        "entities": "^4.2.0"
+        "@types/node": "*",
+        "jest-util": "^29.7.0",
+        "merge-stream": "^2.0.0",
+        "supports-color": "^8.0.0"
       },
-      "funding": {
-        "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1"
+      "engines": {
+        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
       }
     },
-    "node_modules/domelementtype": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz",
-      "integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==",
+    "node_modules/css-prefers-color-scheme": {
+      "version": "10.0.0",
+      "resolved": "https://registry.facebook.net/css-prefers-color-scheme/-/css-prefers-color-scheme-10.0.0.tgz",
+      "integrity": "sha512-VCtXZAWivRglTZditUfB4StnsWr6YVZ2PRtuxQLKTNRdtAf8tpzaVPE9zXIF3VaSc7O70iK/j1+NXxyQCqdPjQ==",
       "funding": [
         {
           "type": "github",
-          "url": "https://github.com/sponsors/fb55"
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
         }
       ],
-      "license": "BSD-2-Clause"
-    },
-    "node_modules/domhandler": {
-      "version": "5.0.3",
-      "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz",
-      "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==",
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "domelementtype": "^2.3.0"
-      },
+      "license": "MIT-0",
       "engines": {
-        "node": ">= 4"
+        "node": ">=18"
       },
-      "funding": {
-        "url": "https://github.com/fb55/domhandler?sponsor=1"
+      "peerDependencies": {
+        "postcss": "^8.4"
       }
     },
-    "node_modules/domutils": {
-      "version": "3.2.1",
-      "resolved": "https://registry.npmjs.org/domutils/-/domutils-3.2.1.tgz",
-      "integrity": "sha512-xWXmuRnN9OMP6ptPd2+H0cCbcYBULa5YDTbMm/2lvkWvNA3O4wcW+GvzooqBuNM8yy6pl3VIAeJTUUWUbfI5Fw==",
+    "node_modules/css-select": {
+      "version": "5.2.2",
+      "resolved": "https://registry.facebook.net/css-select/-/css-select-5.2.2.tgz",
+      "integrity": "sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw==",
       "license": "BSD-2-Clause",
       "dependencies": {
-        "dom-serializer": "^2.0.0",
-        "domelementtype": "^2.3.0",
-        "domhandler": "^5.0.3"
+        "boolbase": "^1.0.0",
+        "css-what": "^6.1.0",
+        "domhandler": "^5.0.2",
+        "domutils": "^3.0.1",
+        "nth-check": "^2.0.1"
       },
       "funding": {
-        "url": "https://github.com/fb55/domutils?sponsor=1"
+        "url": "https://github.com/sponsors/fb55"
       }
     },
-    "node_modules/dot-case": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/dot-case/-/dot-case-3.0.4.tgz",
-      "integrity": "sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w==",
+    "node_modules/css-tree": {
+      "version": "2.3.1",
+      "resolved": "https://registry.facebook.net/css-tree/-/css-tree-2.3.1.tgz",
+      "integrity": "sha512-6Fv1DV/TYw//QF5IzQdqsNDjx/wc8TrMBZsqjL9eW01tWb7R7k/mq+/VXfJCl7SoD5emsJop9cOByJZfs8hYIw==",
       "license": "MIT",
       "dependencies": {
-        "no-case": "^3.0.4",
-        "tslib": "^2.0.3"
+        "mdn-data": "2.0.30",
+        "source-map-js": "^1.0.1"
+      },
+      "engines": {
+        "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0"
       }
     },
-    "node_modules/dot-prop": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/dot-prop/-/dot-prop-6.0.1.tgz",
-      "integrity": "sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA==",
-      "license": "MIT",
-      "dependencies": {
-        "is-obj": "^2.0.0"
-      },
+    "node_modules/css-what": {
+      "version": "6.2.2",
+      "resolved": "https://registry.facebook.net/css-what/-/css-what-6.2.2.tgz",
+      "integrity": "sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==",
+      "license": "BSD-2-Clause",
       "engines": {
-        "node": ">=10"
+        "node": ">= 6"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "url": "https://github.com/sponsors/fb55"
       }
     },
-    "node_modules/dot-prop/node_modules/is-obj": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-2.0.0.tgz",
-      "integrity": "sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==",
+    "node_modules/cssdb": {
+      "version": "8.8.0",
+      "resolved": "https://registry.facebook.net/cssdb/-/cssdb-8.8.0.tgz",
+      "integrity": "sha512-QbLeyz2Bgso1iRlh7IpWk6OKa3lLNGXsujVjDMPl9rOZpxKeiG69icLpbLCFxeURwmcdIfZqQyhlooKJYM4f8Q==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        }
+      ],
+      "license": "MIT-0"
+    },
+    "node_modules/cssesc": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/cssesc/-/cssesc-3.0.0.tgz",
+      "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==",
       "license": "MIT",
+      "bin": {
+        "cssesc": "bin/cssesc"
+      },
       "engines": {
-        "node": ">=8"
+        "node": ">=4"
       }
     },
-    "node_modules/dunder-proto": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
-      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+    "node_modules/cssnano": {
+      "version": "6.1.2",
+      "resolved": "https://registry.facebook.net/cssnano/-/cssnano-6.1.2.tgz",
+      "integrity": "sha512-rYk5UeX7VAM/u0lNqewCdasdtPK81CgX8wJFLEIXHbV2oldWRgJAsZrdhRXkV1NJzA2g850KiFm9mMU2HxNxMA==",
       "license": "MIT",
       "dependencies": {
-        "call-bind-apply-helpers": "^1.0.1",
-        "es-errors": "^1.3.0",
-        "gopd": "^1.2.0"
+        "cssnano-preset-default": "^6.1.2",
+        "lilconfig": "^3.1.1"
       },
       "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/duplexer": {
-      "version": "0.1.2",
-      "resolved": "https://registry.npmjs.org/duplexer/-/duplexer-0.1.2.tgz",
-      "integrity": "sha512-jtD6YG370ZCIi/9GTaJKQxWTZD045+4R4hTk/x1UyoqadyJ9x9CgSi1RlVDQF8U2sxLLSnFkCaMihqljHIWgMg==",
-      "license": "MIT"
-    },
-    "node_modules/eastasianwidth": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
-      "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==",
-      "license": "MIT"
-    },
-    "node_modules/ee-first": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
-      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
-      "license": "MIT"
-    },
-    "node_modules/electron-to-chromium": {
-      "version": "1.5.76",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.76.tgz",
-      "integrity": "sha512-CjVQyG7n7Sr+eBXE86HIulnL5N8xZY1sgmOPGuq/F0Rr0FJq63lg0kEtOIDfZBk44FnDLf6FUJ+dsJcuiUDdDQ==",
-      "license": "ISC"
-    },
-    "node_modules/emoji-regex": {
-      "version": "9.2.2",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
-      "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==",
-      "license": "MIT"
-    },
-    "node_modules/emojilib": {
-      "version": "2.4.0",
-      "resolved": "https://registry.npmjs.org/emojilib/-/emojilib-2.4.0.tgz",
-      "integrity": "sha512-5U0rVMU5Y2n2+ykNLQqMoqklN9ICBT/KsvC1Gz6vqHbz2AXXGkG+Pm5rMWk/8Vjrr/mY9985Hi8DYzn1F09Nyw==",
-      "license": "MIT"
-    },
-    "node_modules/emojis-list": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/emojis-list/-/emojis-list-3.0.0.tgz",
-      "integrity": "sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 4"
-      }
-    },
-    "node_modules/emoticon": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/emoticon/-/emoticon-4.1.0.tgz",
-      "integrity": "sha512-VWZfnxqwNcc51hIy/sbOdEem6D+cVtpPzEEtVAFdaas30+1dgkyaOQ4sQ6Bp0tOMqWO1v+HQfYaoodOkdhK6SQ==",
-      "license": "MIT",
+        "node": "^14 || ^16 || >=18.0"
+      },
       "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/wooorm"
+        "type": "opencollective",
+        "url": "https://opencollective.com/cssnano"
+      },
+      "peerDependencies": {
+        "postcss": "^8.4.31"
       }
     },
-    "node_modules/encodeurl": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
-      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
+    "node_modules/cssnano-preset-advanced": {
+      "version": "6.1.2",
+      "resolved": "https://registry.facebook.net/cssnano-preset-advanced/-/cssnano-preset-advanced-6.1.2.tgz",
+      "integrity": "sha512-Nhao7eD8ph2DoHolEzQs5CfRpiEP0xa1HBdnFZ82kvqdmbwVBUr2r1QuQ4t1pi+D1ZpqpcO4T+wy/7RxzJ/WPQ==",
       "license": "MIT",
+      "dependencies": {
+        "autoprefixer": "^10.4.19",
+        "browserslist": "^4.23.0",
+        "cssnano-preset-default": "^6.1.2",
+        "postcss-discard-unused": "^6.0.5",
+        "postcss-merge-idents": "^6.0.3",
+        "postcss-reduce-idents": "^6.0.3",
+        "postcss-zindex": "^6.0.2"
+      },
       "engines": {
-        "node": ">= 0.8"
+        "node": "^14 || ^16 || >=18.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.4.31"
       }
     },
-    "node_modules/enhanced-resolve": {
-      "version": "5.18.0",
-      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.18.0.tgz",
-      "integrity": "sha512-0/r0MySGYG8YqlayBZ6MuCfECmHFdJ5qyPh8s8wa5Hnm6SaFLSK1VYCbj+NKp090Nm1caZhD+QTnmxO7esYGyQ==",
+    "node_modules/cssnano-preset-default": {
+      "version": "6.1.2",
+      "resolved": "https://registry.facebook.net/cssnano-preset-default/-/cssnano-preset-default-6.1.2.tgz",
+      "integrity": "sha512-1C0C+eNaeN8OcHQa193aRgYexyJtU8XwbdieEjClw+J9d94E41LwT6ivKH0WT+fYwYWB0Zp3I3IZ7tI/BbUbrg==",
       "license": "MIT",
       "dependencies": {
-        "graceful-fs": "^4.2.4",
-        "tapable": "^2.2.0"
+        "browserslist": "^4.23.0",
+        "css-declaration-sorter": "^7.2.0",
+        "cssnano-utils": "^4.0.2",
+        "postcss-calc": "^9.0.1",
+        "postcss-colormin": "^6.1.0",
+        "postcss-convert-values": "^6.1.0",
+        "postcss-discard-comments": "^6.0.2",
+        "postcss-discard-duplicates": "^6.0.3",
+        "postcss-discard-empty": "^6.0.3",
+        "postcss-discard-overridden": "^6.0.2",
+        "postcss-merge-longhand": "^6.0.5",
+        "postcss-merge-rules": "^6.1.1",
+        "postcss-minify-font-values": "^6.1.0",
+        "postcss-minify-gradients": "^6.0.3",
+        "postcss-minify-params": "^6.1.0",
+        "postcss-minify-selectors": "^6.0.4",
+        "postcss-normalize-charset": "^6.0.2",
+        "postcss-normalize-display-values": "^6.0.2",
+        "postcss-normalize-positions": "^6.0.2",
+        "postcss-normalize-repeat-style": "^6.0.2",
+        "postcss-normalize-string": "^6.0.2",
+        "postcss-normalize-timing-functions": "^6.0.2",
+        "postcss-normalize-unicode": "^6.1.0",
+        "postcss-normalize-url": "^6.0.2",
+        "postcss-normalize-whitespace": "^6.0.2",
+        "postcss-ordered-values": "^6.0.2",
+        "postcss-reduce-initial": "^6.1.0",
+        "postcss-reduce-transforms": "^6.0.2",
+        "postcss-svgo": "^6.0.3",
+        "postcss-unique-selectors": "^6.0.4"
       },
       "engines": {
-        "node": ">=10.13.0"
+        "node": "^14 || ^16 || >=18.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.4.31"
       }
     },
-    "node_modules/entities": {
-      "version": "4.5.0",
-      "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz",
-      "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
-      "license": "BSD-2-Clause",
+    "node_modules/cssnano-utils": {
+      "version": "4.0.2",
+      "resolved": "https://registry.facebook.net/cssnano-utils/-/cssnano-utils-4.0.2.tgz",
+      "integrity": "sha512-ZR1jHg+wZ8o4c3zqf1SIUSTIvm/9mU343FMR6Obe/unskbvpGhZOo1J6d/r8D1pzkRQYuwbcH3hToOuoA2G7oQ==",
+      "license": "MIT",
       "engines": {
-        "node": ">=0.12"
+        "node": "^14 || ^16 || >=18.0"
       },
-      "funding": {
-        "url": "https://github.com/fb55/entities?sponsor=1"
+      "peerDependencies": {
+        "postcss": "^8.4.31"
       }
     },
-    "node_modules/error-ex": {
-      "version": "1.3.2",
-      "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz",
-      "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==",
+    "node_modules/csso": {
+      "version": "5.0.5",
+      "resolved": "https://registry.facebook.net/csso/-/csso-5.0.5.tgz",
+      "integrity": "sha512-0LrrStPOdJj+SPCCrGhzryycLjwcgUSHBtxNA8aIDxf0GLsRh1cKYhB00Gd1lDOS4yGH69+SNn13+TWbVHETFQ==",
       "license": "MIT",
       "dependencies": {
-        "is-arrayish": "^0.2.1"
-      }
-    },
-    "node_modules/es-define-property": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
-      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
-      "license": "MIT",
+        "css-tree": "~2.2.0"
+      },
       "engines": {
-        "node": ">= 0.4"
+        "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0",
+        "npm": ">=7.0.0"
       }
     },
-    "node_modules/es-errors": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
-      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+    "node_modules/csso/node_modules/css-tree": {
+      "version": "2.2.1",
+      "resolved": "https://registry.facebook.net/css-tree/-/css-tree-2.2.1.tgz",
+      "integrity": "sha512-OA0mILzGc1kCOCSJerOeqDxDQ4HOh+G8NbOJFOTgOCzpw7fCBubk0fEyxp8AgOL/jvLgYA/uV0cMbe43ElF1JA==",
       "license": "MIT",
+      "dependencies": {
+        "mdn-data": "2.0.28",
+        "source-map-js": "^1.0.1"
+      },
       "engines": {
-        "node": ">= 0.4"
+        "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0",
+        "npm": ">=7.0.0"
       }
     },
-    "node_modules/es-module-lexer": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.6.0.tgz",
-      "integrity": "sha512-qqnD1yMU6tk/jnaMosogGySTZP8YtUgAffA9nMN+E/rjxcfRQ6IEk7IiozUjgxKoFHBGjTLnrHB/YC45r/59EQ==",
+    "node_modules/csso/node_modules/mdn-data": {
+      "version": "2.0.28",
+      "resolved": "https://registry.facebook.net/mdn-data/-/mdn-data-2.0.28.tgz",
+      "integrity": "sha512-aylIc7Z9y4yzHYAJNuESG3hfhC+0Ibp/MAMiaOZgNv4pmEdFyfZhhhny4MNiAfWdBQ1RQ2mfDWmM1x8SvGyp8g==",
+      "license": "CC0-1.0"
+    },
+    "node_modules/csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.facebook.net/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
       "license": "MIT"
     },
-    "node_modules/es-object-atoms": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.0.0.tgz",
-      "integrity": "sha512-MZ4iQ6JwHOBQjahnjwaC1ZtIBH+2ohjamzAO3oaHcXYup7qxjF2fixyH+Q71voWHeOkI2q/TnJao/KfXYIZWbw==",
+    "node_modules/debounce": {
+      "version": "1.2.1",
+      "resolved": "https://registry.facebook.net/debounce/-/debounce-1.2.1.tgz",
+      "integrity": "sha512-XRRe6Glud4rd/ZGQfiV1ruXSfbvfJedlV9Y6zOlP+2K04vBYiJEte6stfFkCP03aMnY5tsipamumUjL14fofug==",
+      "license": "MIT"
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.facebook.net/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
       "license": "MIT",
       "dependencies": {
-        "es-errors": "^1.3.0"
+        "ms": "^2.1.3"
       },
       "engines": {
-        "node": ">= 0.4"
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
       }
     },
-    "node_modules/esast-util-from-estree": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/esast-util-from-estree/-/esast-util-from-estree-2.0.0.tgz",
-      "integrity": "sha512-4CyanoAudUSBAn5K13H4JhsMH6L9ZP7XbLVe/dKybkxMO7eDyLsT8UHl9TRNrU2Gr9nz+FovfSIjuXWJ81uVwQ==",
+    "node_modules/decode-named-character-reference": {
+      "version": "1.3.0",
+      "resolved": "https://registry.facebook.net/decode-named-character-reference/-/decode-named-character-reference-1.3.0.tgz",
+      "integrity": "sha512-GtpQYB283KrPp6nRw50q3U9/VfOutZOe103qlN7BPP6Ad27xYnOIWv4lPzo8HCAL+mMZofJ9KEy30fq6MfaK6Q==",
       "license": "MIT",
       "dependencies": {
-        "@types/estree-jsx": "^1.0.0",
-        "devlop": "^1.0.0",
-        "estree-util-visit": "^2.0.0",
-        "unist-util-position-from-estree": "^2.0.0"
+        "character-entities": "^2.0.0"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
       }
     },
-    "node_modules/esast-util-from-js": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/esast-util-from-js/-/esast-util-from-js-2.0.1.tgz",
-      "integrity": "sha512-8Ja+rNJ0Lt56Pcf3TAmpBZjmx8ZcK5Ts4cAzIOjsjevg9oSXJnl6SUQ2EevU8tv3h6ZLWmoKL5H4fgWvdvfETw==",
+    "node_modules/decompress-response": {
+      "version": "6.0.0",
+      "resolved": "https://registry.facebook.net/decompress-response/-/decompress-response-6.0.0.tgz",
+      "integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==",
       "license": "MIT",
       "dependencies": {
-        "@types/estree-jsx": "^1.0.0",
-        "acorn": "^8.0.0",
-        "esast-util-from-estree": "^2.0.0",
-        "vfile-message": "^4.0.0"
+        "mimic-response": "^3.1.0"
+      },
+      "engines": {
+        "node": ">=10"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/escalade": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
-      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+    "node_modules/deep-extend": {
+      "version": "0.6.0",
+      "resolved": "https://registry.facebook.net/deep-extend/-/deep-extend-0.6.0.tgz",
+      "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==",
       "license": "MIT",
       "engines": {
-        "node": ">=6"
+        "node": ">=4.0.0"
       }
     },
-    "node_modules/escape-goat": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/escape-goat/-/escape-goat-4.0.0.tgz",
-      "integrity": "sha512-2Sd4ShcWxbx6OY1IHyla/CVNwvg7XwZVoXZHcSu9w9SReNP1EzzD5T8NWKIR38fIqEns9kDWKUQTXXAmlDrdPg==",
+    "node_modules/deepmerge": {
+      "version": "4.3.1",
+      "resolved": "https://registry.facebook.net/deepmerge/-/deepmerge-4.3.1.tgz",
+      "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==",
       "license": "MIT",
       "engines": {
-        "node": ">=12"
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/default-browser": {
+      "version": "5.5.0",
+      "resolved": "https://registry.facebook.net/default-browser/-/default-browser-5.5.0.tgz",
+      "integrity": "sha512-H9LMLr5zwIbSxrmvikGuI/5KGhZ8E2zH3stkMgM5LpOWDutGM2JZaj460Udnf1a+946zc7YBgrqEWwbk7zHvGw==",
+      "license": "MIT",
+      "dependencies": {
+        "bundle-name": "^4.1.0",
+        "default-browser-id": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/escape-html": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
-      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
-      "license": "MIT"
-    },
-    "node_modules/escape-string-regexp": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
-      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+    "node_modules/default-browser-id": {
+      "version": "5.0.1",
+      "resolved": "https://registry.facebook.net/default-browser-id/-/default-browser-id-5.0.1.tgz",
+      "integrity": "sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q==",
       "license": "MIT",
       "engines": {
-        "node": ">=10"
+        "node": ">=18"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/eslint-scope": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz",
-      "integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==",
-      "license": "BSD-2-Clause",
+    "node_modules/defer-to-connect": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/defer-to-connect/-/defer-to-connect-2.0.1.tgz",
+      "integrity": "sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/define-data-property": {
+      "version": "1.1.4",
+      "resolved": "https://registry.facebook.net/define-data-property/-/define-data-property-1.1.4.tgz",
+      "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
+      "license": "MIT",
       "dependencies": {
-        "esrecurse": "^4.3.0",
-        "estraverse": "^4.1.1"
+        "es-define-property": "^1.0.0",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.0.1"
       },
       "engines": {
-        "node": ">=8.0.0"
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/esprima": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
-      "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
-      "license": "BSD-2-Clause",
-      "bin": {
-        "esparse": "bin/esparse.js",
-        "esvalidate": "bin/esvalidate.js"
-      },
+    "node_modules/define-lazy-prop": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/define-lazy-prop/-/define-lazy-prop-2.0.0.tgz",
+      "integrity": "sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==",
+      "license": "MIT",
       "engines": {
-        "node": ">=4"
+        "node": ">=8"
       }
     },
-    "node_modules/esrecurse": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
-      "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
-      "license": "BSD-2-Clause",
+    "node_modules/define-properties": {
+      "version": "1.2.1",
+      "resolved": "https://registry.facebook.net/define-properties/-/define-properties-1.2.1.tgz",
+      "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==",
+      "license": "MIT",
       "dependencies": {
-        "estraverse": "^5.2.0"
+        "define-data-property": "^1.0.1",
+        "has-property-descriptors": "^1.0.0",
+        "object-keys": "^1.1.1"
       },
       "engines": {
-        "node": ">=4.0"
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/esrecurse/node_modules/estraverse": {
-      "version": "5.3.0",
-      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
-      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
-      "license": "BSD-2-Clause",
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "license": "MIT",
       "engines": {
-        "node": ">=4.0"
+        "node": ">=0.4.0"
       }
     },
-    "node_modules/estraverse": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz",
-      "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==",
-      "license": "BSD-2-Clause",
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+      "license": "MIT",
       "engines": {
-        "node": ">=4.0"
+        "node": ">= 0.8"
       }
     },
-    "node_modules/estree-util-attach-comments": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/estree-util-attach-comments/-/estree-util-attach-comments-3.0.0.tgz",
-      "integrity": "sha512-cKUwm/HUcTDsYh/9FgnuFqpfquUbwIqwKM26BVCGDPVgvaCl/nDCCjUfiLlx6lsEZ3Z4RFxNbOQ60pkaEwFxGw==",
+    "node_modules/dequal": {
+      "version": "2.0.3",
+      "resolved": "https://registry.facebook.net/dequal/-/dequal-2.0.3.tgz",
+      "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/destroy": {
+      "version": "1.2.0",
+      "resolved": "https://registry.facebook.net/destroy/-/destroy-1.2.0.tgz",
+      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/detect-node": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/detect-node/-/detect-node-2.1.0.tgz",
+      "integrity": "sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==",
+      "license": "MIT"
+    },
+    "node_modules/detect-port": {
+      "version": "1.6.1",
+      "resolved": "https://registry.facebook.net/detect-port/-/detect-port-1.6.1.tgz",
+      "integrity": "sha512-CmnVc+Hek2egPx1PeTFVta2W78xy2K/9Rkf6cC4T59S50tVnzKj+tnx5mmx5lwvCkujZ4uRrpRSuV+IVs3f90Q==",
       "license": "MIT",
       "dependencies": {
-        "@types/estree": "^1.0.0"
+        "address": "^1.0.1",
+        "debug": "4"
       },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+      "bin": {
+        "detect": "bin/detect-port.js",
+        "detect-port": "bin/detect-port.js"
+      },
+      "engines": {
+        "node": ">= 4.0.0"
       }
     },
-    "node_modules/estree-util-build-jsx": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/estree-util-build-jsx/-/estree-util-build-jsx-3.0.1.tgz",
-      "integrity": "sha512-8U5eiL6BTrPxp/CHbs2yMgP8ftMhR5ww1eIKoWRMlqvltHF8fZn5LRDvTKuxD3DUn+shRbLGqXemcP51oFCsGQ==",
+    "node_modules/devlop": {
+      "version": "1.1.0",
+      "resolved": "https://registry.facebook.net/devlop/-/devlop-1.1.0.tgz",
+      "integrity": "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==",
       "license": "MIT",
       "dependencies": {
-        "@types/estree-jsx": "^1.0.0",
-        "devlop": "^1.0.0",
-        "estree-util-is-identifier-name": "^3.0.0",
-        "estree-walker": "^3.0.0"
+        "dequal": "^2.0.0"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
       }
     },
-    "node_modules/estree-util-is-identifier-name": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/estree-util-is-identifier-name/-/estree-util-is-identifier-name-3.0.0.tgz",
-      "integrity": "sha512-hFtqIDZTIUZ9BXLb8y4pYGyk6+wekIivNVTcmvk8NoOh+VeRn5y6cEHzbURrWbfp1fIqdVipilzj+lfaadNZmg==",
+    "node_modules/dir-glob": {
+      "version": "3.0.1",
+      "resolved": "https://registry.facebook.net/dir-glob/-/dir-glob-3.0.1.tgz",
+      "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==",
       "license": "MIT",
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+      "dependencies": {
+        "path-type": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
       }
     },
-    "node_modules/estree-util-scope": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/estree-util-scope/-/estree-util-scope-1.0.0.tgz",
-      "integrity": "sha512-2CAASclonf+JFWBNJPndcOpA8EMJwa0Q8LUFJEKqXLW6+qBvbFZuF5gItbQOs/umBUkjviCSDCbBwU2cXbmrhQ==",
+    "node_modules/dns-packet": {
+      "version": "5.6.1",
+      "resolved": "https://registry.facebook.net/dns-packet/-/dns-packet-5.6.1.tgz",
+      "integrity": "sha512-l4gcSouhcgIKRvyy99RNVOgxXiicE+2jZoNmaNmZ6JXiGajBOJAesk1OBlJuM5k2c+eudGdLxDqXuPCKIj6kpw==",
       "license": "MIT",
       "dependencies": {
-        "@types/estree": "^1.0.0",
-        "devlop": "^1.0.0"
+        "@leichtgewicht/ip-codec": "^2.0.1"
       },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+      "engines": {
+        "node": ">=6"
       }
     },
-    "node_modules/estree-util-to-js": {
+    "node_modules/dom-converter": {
+      "version": "0.2.0",
+      "resolved": "https://registry.facebook.net/dom-converter/-/dom-converter-0.2.0.tgz",
+      "integrity": "sha512-gd3ypIPfOMr9h5jIKq8E3sHOTCjeirnl0WK5ZdS1AW0Odt0b1PaWaHdJ4Qk4klv+YB9aJBS7mESXjFoDQPu6DA==",
+      "license": "MIT",
+      "dependencies": {
+        "utila": "~0.4"
+      }
+    },
+    "node_modules/dom-serializer": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/estree-util-to-js/-/estree-util-to-js-2.0.0.tgz",
-      "integrity": "sha512-WDF+xj5rRWmD5tj6bIqRi6CkLIXbbNQUcxQHzGysQzvHmdYG2G7p/Tf0J0gpxGgkeMZNTIjT/AoSvC9Xehcgdg==",
+      "resolved": "https://registry.facebook.net/dom-serializer/-/dom-serializer-2.0.0.tgz",
+      "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==",
       "license": "MIT",
       "dependencies": {
-        "@types/estree-jsx": "^1.0.0",
-        "astring": "^1.8.0",
-        "source-map": "^0.7.0"
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.2",
+        "entities": "^4.2.0"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1"
       }
     },
-    "node_modules/estree-util-value-to-estree": {
-      "version": "3.2.1",
-      "resolved": "https://registry.npmjs.org/estree-util-value-to-estree/-/estree-util-value-to-estree-3.2.1.tgz",
-      "integrity": "sha512-Vt2UOjyPbNQQgT5eJh+K5aATti0OjCIAGc9SgMdOFYbohuifsWclR74l0iZTJwePMgWYdX1hlVS+dedH9XV8kw==",
-      "license": "MIT",
+    "node_modules/domelementtype": {
+      "version": "2.3.0",
+      "resolved": "https://registry.facebook.net/domelementtype/-/domelementtype-2.3.0.tgz",
+      "integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fb55"
+        }
+      ],
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/domhandler": {
+      "version": "5.0.3",
+      "resolved": "https://registry.facebook.net/domhandler/-/domhandler-5.0.3.tgz",
+      "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==",
+      "license": "BSD-2-Clause",
       "dependencies": {
-        "@types/estree": "^1.0.0"
+        "domelementtype": "^2.3.0"
+      },
+      "engines": {
+        "node": ">= 4"
       },
       "funding": {
-        "url": "https://github.com/sponsors/remcohaszing"
+        "url": "https://github.com/fb55/domhandler?sponsor=1"
       }
     },
-    "node_modules/estree-util-visit": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/estree-util-visit/-/estree-util-visit-2.0.0.tgz",
-      "integrity": "sha512-m5KgiH85xAhhW8Wta0vShLcUvOsh3LLPI2YVwcbio1l7E09NTLL1EyMZFM1OyWowoH0skScNbhOPl4kcBgzTww==",
-      "license": "MIT",
+    "node_modules/domutils": {
+      "version": "3.2.2",
+      "resolved": "https://registry.facebook.net/domutils/-/domutils-3.2.2.tgz",
+      "integrity": "sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==",
+      "license": "BSD-2-Clause",
       "dependencies": {
-        "@types/estree-jsx": "^1.0.0",
-        "@types/unist": "^3.0.0"
+        "dom-serializer": "^2.0.0",
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.3"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "url": "https://github.com/fb55/domutils?sponsor=1"
       }
     },
-    "node_modules/estree-walker": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
-      "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
+    "node_modules/dot-case": {
+      "version": "3.0.4",
+      "resolved": "https://registry.facebook.net/dot-case/-/dot-case-3.0.4.tgz",
+      "integrity": "sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w==",
       "license": "MIT",
       "dependencies": {
-        "@types/estree": "^1.0.0"
-      }
-    },
-    "node_modules/esutils": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
-      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=0.10.0"
+        "no-case": "^3.0.4",
+        "tslib": "^2.0.3"
       }
     },
-    "node_modules/eta": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/eta/-/eta-2.2.0.tgz",
-      "integrity": "sha512-UVQ72Rqjy/ZKQalzV5dCCJP80GrmPrMxh6NlNf+erV6ObL0ZFkhCstWRawS85z3smdr3d2wXPsZEY7rDPfGd2g==",
+    "node_modules/dot-prop": {
+      "version": "6.0.1",
+      "resolved": "https://registry.facebook.net/dot-prop/-/dot-prop-6.0.1.tgz",
+      "integrity": "sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA==",
       "license": "MIT",
+      "dependencies": {
+        "is-obj": "^2.0.0"
+      },
       "engines": {
-        "node": ">=6.0.0"
+        "node": ">=10"
       },
       "funding": {
-        "url": "https://github.com/eta-dev/eta?sponsor=1"
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/etag": {
-      "version": "1.8.1",
-      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
-      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+    "node_modules/dot-prop/node_modules/is-obj": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/is-obj/-/is-obj-2.0.0.tgz",
+      "integrity": "sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==",
       "license": "MIT",
       "engines": {
-        "node": ">= 0.6"
+        "node": ">=8"
       }
     },
-    "node_modules/eval": {
-      "version": "0.1.8",
-      "resolved": "https://registry.npmjs.org/eval/-/eval-0.1.8.tgz",
-      "integrity": "sha512-EzV94NYKoO09GLXGjXj9JIlXijVck4ONSr5wiCWDvhsvj5jxSrzTmRU/9C1DyB6uToszLs8aifA6NQ7lEQdvFw==",
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "license": "MIT",
       "dependencies": {
-        "@types/node": "*",
-        "require-like": ">= 0.1.1"
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
       },
       "engines": {
-        "node": ">= 0.8"
+        "node": ">= 0.4"
       }
     },
-    "node_modules/eventemitter3": {
-      "version": "4.0.7",
-      "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz",
-      "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==",
+    "node_modules/duplexer": {
+      "version": "0.1.2",
+      "resolved": "https://registry.facebook.net/duplexer/-/duplexer-0.1.2.tgz",
+      "integrity": "sha512-jtD6YG370ZCIi/9GTaJKQxWTZD045+4R4hTk/x1UyoqadyJ9x9CgSi1RlVDQF8U2sxLLSnFkCaMihqljHIWgMg==",
       "license": "MIT"
     },
-    "node_modules/events": {
-      "version": "3.3.0",
-      "resolved": "https://registry.npmjs.org/events/-/events-3.3.0.tgz",
-      "integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==",
+    "node_modules/eastasianwidth": {
+      "version": "0.2.0",
+      "resolved": "https://registry.facebook.net/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
+      "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==",
+      "license": "MIT"
+    },
+    "node_modules/ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.facebook.net/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
+      "license": "MIT"
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.344",
+      "resolved": "https://registry.facebook.net/electron-to-chromium/-/electron-to-chromium-1.5.344.tgz",
+      "integrity": "sha512-4MxfbmNDm+KPh066EZy+eUnkcDPcZ35wNmOWzFuh/ijvHsve6kbLTLURy88uCNK5FbpN+yk2nQY6BYh1GEt+wg==",
+      "license": "ISC"
+    },
+    "node_modules/emoji-regex": {
+      "version": "9.2.2",
+      "resolved": "https://registry.facebook.net/emoji-regex/-/emoji-regex-9.2.2.tgz",
+      "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==",
+      "license": "MIT"
+    },
+    "node_modules/emojilib": {
+      "version": "2.4.0",
+      "resolved": "https://registry.facebook.net/emojilib/-/emojilib-2.4.0.tgz",
+      "integrity": "sha512-5U0rVMU5Y2n2+ykNLQqMoqklN9ICBT/KsvC1Gz6vqHbz2AXXGkG+Pm5rMWk/8Vjrr/mY9985Hi8DYzn1F09Nyw==",
+      "license": "MIT"
+    },
+    "node_modules/emojis-list": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/emojis-list/-/emojis-list-3.0.0.tgz",
+      "integrity": "sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q==",
       "license": "MIT",
       "engines": {
-        "node": ">=0.8.x"
+        "node": ">= 4"
       }
     },
-    "node_modules/execa": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz",
-      "integrity": "sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==",
+    "node_modules/emoticon": {
+      "version": "4.1.0",
+      "resolved": "https://registry.facebook.net/emoticon/-/emoticon-4.1.0.tgz",
+      "integrity": "sha512-VWZfnxqwNcc51hIy/sbOdEem6D+cVtpPzEEtVAFdaas30+1dgkyaOQ4sQ6Bp0tOMqWO1v+HQfYaoodOkdhK6SQ==",
       "license": "MIT",
-      "dependencies": {
-        "cross-spawn": "^7.0.3",
-        "get-stream": "^6.0.0",
-        "human-signals": "^2.1.0",
-        "is-stream": "^2.0.0",
-        "merge-stream": "^2.0.0",
-        "npm-run-path": "^4.0.1",
-        "onetime": "^5.1.2",
-        "signal-exit": "^3.0.3",
-        "strip-final-newline": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
       "funding": {
-        "url": "https://github.com/sindresorhus/execa?sponsor=1"
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
       }
     },
-    "node_modules/express": {
-      "version": "4.21.2",
-      "resolved": "https://registry.npmjs.org/express/-/express-4.21.2.tgz",
-      "integrity": "sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA==",
+    "node_modules/encodeurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/encodeurl/-/encodeurl-2.0.0.tgz",
+      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
       "license": "MIT",
-      "dependencies": {
-        "accepts": "~1.3.8",
-        "array-flatten": "1.1.1",
-        "body-parser": "1.20.3",
-        "content-disposition": "0.5.4",
-        "content-type": "~1.0.4",
-        "cookie": "0.7.1",
-        "cookie-signature": "1.0.6",
-        "debug": "2.6.9",
-        "depd": "2.0.0",
-        "encodeurl": "~2.0.0",
-        "escape-html": "~1.0.3",
-        "etag": "~1.8.1",
-        "finalhandler": "1.3.1",
-        "fresh": "0.5.2",
-        "http-errors": "2.0.0",
-        "merge-descriptors": "1.0.3",
-        "methods": "~1.1.2",
-        "on-finished": "2.4.1",
-        "parseurl": "~1.3.3",
-        "path-to-regexp": "0.1.12",
-        "proxy-addr": "~2.0.7",
-        "qs": "6.13.0",
-        "range-parser": "~1.2.1",
-        "safe-buffer": "5.2.1",
-        "send": "0.19.0",
-        "serve-static": "1.16.2",
-        "setprototypeof": "1.2.0",
-        "statuses": "2.0.1",
-        "type-is": "~1.6.18",
-        "utils-merge": "1.0.1",
-        "vary": "~1.1.2"
-      },
       "engines": {
-        "node": ">= 0.10.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
+        "node": ">= 0.8"
       }
     },
-    "node_modules/express/node_modules/content-disposition": {
-      "version": "0.5.4",
-      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
-      "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
+    "node_modules/enhanced-resolve": {
+      "version": "5.21.0",
+      "resolved": "https://registry.facebook.net/enhanced-resolve/-/enhanced-resolve-5.21.0.tgz",
+      "integrity": "sha512-otxSQPw4lkOZWkHpB3zaEQs6gWYEsmX4xQF68ElXC/TWvGxGMSGOvoNbaLXm6/cS/fSfHtsEdw90y20PCd+sCA==",
       "license": "MIT",
       "dependencies": {
-        "safe-buffer": "5.2.1"
+        "graceful-fs": "^4.2.4",
+        "tapable": "^2.3.3"
       },
       "engines": {
-        "node": ">= 0.6"
+        "node": ">=10.13.0"
       }
     },
-    "node_modules/express/node_modules/debug": {
-      "version": "2.6.9",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
-      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+    "node_modules/entities": {
+      "version": "4.5.0",
+      "resolved": "https://registry.facebook.net/entities/-/entities-4.5.0.tgz",
+      "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/error-ex": {
+      "version": "1.3.4",
+      "resolved": "https://registry.facebook.net/error-ex/-/error-ex-1.3.4.tgz",
+      "integrity": "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ==",
       "license": "MIT",
       "dependencies": {
-        "ms": "2.0.0"
+        "is-arrayish": "^0.2.1"
       }
     },
-    "node_modules/express/node_modules/ms": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
-      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
-      "license": "MIT"
-    },
-    "node_modules/express/node_modules/path-to-regexp": {
-      "version": "0.1.12",
-      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz",
-      "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==",
-      "license": "MIT"
-    },
-    "node_modules/express/node_modules/range-parser": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
-      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
       "license": "MIT",
       "engines": {
-        "node": ">= 0.6"
+        "node": ">= 0.4"
       }
     },
-    "node_modules/extend": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz",
-      "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==",
-      "license": "MIT"
-    },
-    "node_modules/extend-shallow": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
-      "integrity": "sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==",
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.facebook.net/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
       "license": "MIT",
-      "dependencies": {
-        "is-extendable": "^0.1.0"
-      },
       "engines": {
-        "node": ">=0.10.0"
+        "node": ">= 0.4"
       }
     },
-    "node_modules/fast-deep-equal": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
-      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+    "node_modules/es-module-lexer": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/es-module-lexer/-/es-module-lexer-2.1.0.tgz",
+      "integrity": "sha512-n27zTYMjYu1aj4MjCWzSP7G9r75utsaoc8m61weK+W8JMBGGQybd43GstCXZ3WNmSFtGT9wi59qQTW6mhTR5LQ==",
       "license": "MIT"
     },
-    "node_modules/fast-glob": {
-      "version": "3.3.2",
-      "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.2.tgz",
-      "integrity": "sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow==",
+    "node_modules/es-object-atoms": {
+      "version": "1.1.1",
+      "resolved": "https://registry.facebook.net/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
       "license": "MIT",
       "dependencies": {
-        "@nodelib/fs.stat": "^2.0.2",
-        "@nodelib/fs.walk": "^1.2.3",
-        "glob-parent": "^5.1.2",
-        "merge2": "^1.3.0",
-        "micromatch": "^4.0.4"
+        "es-errors": "^1.3.0"
       },
       "engines": {
-        "node": ">=8.6.0"
+        "node": ">= 0.4"
       }
     },
-    "node_modules/fast-json-stable-stringify": {
+    "node_modules/es-set-tostringtag": {
       "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
-      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
-      "license": "MIT"
-    },
-    "node_modules/fast-uri": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.0.3.tgz",
-      "integrity": "sha512-aLrHthzCjH5He4Z2H9YZ+v6Ujb9ocRuW6ZzkJQOrTxleEijANq4v1TsaPaVG1PZcuurEzrLcWRyYBYXD5cEiaw==",
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/fastq": {
-      "version": "1.18.0",
-      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.18.0.tgz",
-      "integrity": "sha512-QKHXPW0hD8g4UET03SdOdunzSouc9N4AuHdsX8XNcTsuz+yYFILVNIX4l9yHABMhiEI9Db0JTTIpu0wB+Y1QQw==",
-      "license": "ISC",
+      "resolved": "https://registry.facebook.net/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+      "license": "MIT",
       "dependencies": {
-        "reusify": "^1.0.4"
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6",
+        "has-tostringtag": "^1.0.2",
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
       }
     },
-    "node_modules/fault": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/fault/-/fault-2.0.1.tgz",
-      "integrity": "sha512-WtySTkS4OKev5JtpHXnib4Gxiurzh5NCGvWrFaZ34m6JehfTUhKZvn9njTfw48t6JumVQOmrKqpmGcdwxnhqBQ==",
+    "node_modules/esast-util-from-estree": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/esast-util-from-estree/-/esast-util-from-estree-2.0.0.tgz",
+      "integrity": "sha512-4CyanoAudUSBAn5K13H4JhsMH6L9ZP7XbLVe/dKybkxMO7eDyLsT8UHl9TRNrU2Gr9nz+FovfSIjuXWJ81uVwQ==",
       "license": "MIT",
       "dependencies": {
-        "format": "^0.2.0"
+        "@types/estree-jsx": "^1.0.0",
+        "devlop": "^1.0.0",
+        "estree-util-visit": "^2.0.0",
+        "unist-util-position-from-estree": "^2.0.0"
       },
       "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/wooorm"
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/faye-websocket": {
-      "version": "0.11.4",
-      "resolved": "https://registry.npmjs.org/faye-websocket/-/faye-websocket-0.11.4.tgz",
-      "integrity": "sha512-CzbClwlXAuiRQAlUyfqPgvPoNKTckTPGfwZV4ZdAhVcP2lh9KUxJg2b5GkE7XbjKQ3YJnQ9z6D9ntLAlB+tP8g==",
-      "license": "Apache-2.0",
+    "node_modules/esast-util-from-js": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/esast-util-from-js/-/esast-util-from-js-2.0.1.tgz",
+      "integrity": "sha512-8Ja+rNJ0Lt56Pcf3TAmpBZjmx8ZcK5Ts4cAzIOjsjevg9oSXJnl6SUQ2EevU8tv3h6ZLWmoKL5H4fgWvdvfETw==",
+      "license": "MIT",
       "dependencies": {
-        "websocket-driver": ">=0.5.1"
+        "@types/estree-jsx": "^1.0.0",
+        "acorn": "^8.0.0",
+        "esast-util-from-estree": "^2.0.0",
+        "vfile-message": "^4.0.0"
       },
-      "engines": {
-        "node": ">=0.8.0"
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/feed": {
-      "version": "4.2.2",
-      "resolved": "https://registry.npmjs.org/feed/-/feed-4.2.2.tgz",
-      "integrity": "sha512-u5/sxGfiMfZNtJ3OvQpXcvotFpYkL0n9u9mM2vkui2nGo8b4wvDkJ8gAkYqbA8QpGyFCv3RK0Z+Iv+9veCS9bQ==",
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.facebook.net/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
       "license": "MIT",
-      "dependencies": {
-        "xml-js": "^1.6.11"
-      },
       "engines": {
-        "node": ">=0.4.0"
+        "node": ">=6"
       }
     },
-    "node_modules/figures": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/figures/-/figures-3.2.0.tgz",
-      "integrity": "sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg==",
+    "node_modules/escape-goat": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/escape-goat/-/escape-goat-4.0.0.tgz",
+      "integrity": "sha512-2Sd4ShcWxbx6OY1IHyla/CVNwvg7XwZVoXZHcSu9w9SReNP1EzzD5T8NWKIR38fIqEns9kDWKUQTXXAmlDrdPg==",
       "license": "MIT",
-      "dependencies": {
-        "escape-string-regexp": "^1.0.5"
-      },
       "engines": {
-        "node": ">=8"
+        "node": ">=12"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/figures/node_modules/escape-string-regexp": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
-      "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.8.0"
-      }
+    "node_modules/escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.facebook.net/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
+      "license": "MIT"
     },
-    "node_modules/file-loader": {
-      "version": "6.2.0",
-      "resolved": "https://registry.npmjs.org/file-loader/-/file-loader-6.2.0.tgz",
-      "integrity": "sha512-qo3glqyTa61Ytg4u73GultjHGjdRyig3tG6lPtyX/jOEJvHif9uB0/OCI2Kif6ctF3caQTW2G5gym21oAsI4pw==",
+    "node_modules/escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
       "license": "MIT",
-      "dependencies": {
-        "loader-utils": "^2.0.0",
-        "schema-utils": "^3.0.0"
-      },
       "engines": {
-        "node": ">= 10.13.0"
+        "node": ">=10"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/webpack"
-      },
-      "peerDependencies": {
-        "webpack": "^4.0.0 || ^5.0.0"
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/file-loader/node_modules/ajv": {
-      "version": "6.12.6",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
-      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
-      "license": "MIT",
+    "node_modules/eslint-scope": {
+      "version": "5.1.1",
+      "resolved": "https://registry.facebook.net/eslint-scope/-/eslint-scope-5.1.1.tgz",
+      "integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==",
+      "license": "BSD-2-Clause",
       "dependencies": {
-        "fast-deep-equal": "^3.1.1",
-        "fast-json-stable-stringify": "^2.0.0",
-        "json-schema-traverse": "^0.4.1",
-        "uri-js": "^4.2.2"
+        "esrecurse": "^4.3.0",
+        "estraverse": "^4.1.1"
       },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/epoberezkin"
+      "engines": {
+        "node": ">=8.0.0"
       }
     },
-    "node_modules/file-loader/node_modules/ajv-keywords": {
-      "version": "3.5.2",
-      "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz",
-      "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==",
-      "license": "MIT",
-      "peerDependencies": {
-        "ajv": "^6.9.1"
+    "node_modules/esprima": {
+      "version": "4.0.1",
+      "resolved": "https://registry.facebook.net/esprima/-/esprima-4.0.1.tgz",
+      "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
+      "license": "BSD-2-Clause",
+      "bin": {
+        "esparse": "bin/esparse.js",
+        "esvalidate": "bin/esvalidate.js"
+      },
+      "engines": {
+        "node": ">=4"
       }
     },
-    "node_modules/file-loader/node_modules/json-schema-traverse": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
-      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
-      "license": "MIT"
-    },
-    "node_modules/file-loader/node_modules/schema-utils": {
-      "version": "3.3.0",
-      "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.3.0.tgz",
-      "integrity": "sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==",
-      "license": "MIT",
+    "node_modules/esrecurse": {
+      "version": "4.3.0",
+      "resolved": "https://registry.facebook.net/esrecurse/-/esrecurse-4.3.0.tgz",
+      "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
+      "license": "BSD-2-Clause",
       "dependencies": {
-        "@types/json-schema": "^7.0.8",
-        "ajv": "^6.12.5",
-        "ajv-keywords": "^3.5.2"
+        "estraverse": "^5.2.0"
       },
       "engines": {
-        "node": ">= 10.13.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/webpack"
+        "node": ">=4.0"
       }
     },
-    "node_modules/filesize": {
-      "version": "8.0.7",
-      "resolved": "https://registry.npmjs.org/filesize/-/filesize-8.0.7.tgz",
-      "integrity": "sha512-pjmC+bkIF8XI7fWaH8KxHcZL3DPybs1roSKP4rKDvy20tAWwIObE4+JIseG2byfGKhud5ZnM4YSGKBz7Sh0ndQ==",
-      "license": "BSD-3-Clause",
+    "node_modules/esrecurse/node_modules/estraverse": {
+      "version": "5.3.0",
+      "resolved": "https://registry.facebook.net/estraverse/-/estraverse-5.3.0.tgz",
+      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
+      "license": "BSD-2-Clause",
       "engines": {
-        "node": ">= 0.4.0"
+        "node": ">=4.0"
       }
     },
-    "node_modules/fill-range": {
-      "version": "7.1.1",
-      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
-      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
-      "license": "MIT",
-      "dependencies": {
-        "to-regex-range": "^5.0.1"
-      },
+    "node_modules/estraverse": {
+      "version": "4.3.0",
+      "resolved": "https://registry.facebook.net/estraverse/-/estraverse-4.3.0.tgz",
+      "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==",
+      "license": "BSD-2-Clause",
       "engines": {
-        "node": ">=8"
+        "node": ">=4.0"
       }
     },
-    "node_modules/finalhandler": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.1.tgz",
-      "integrity": "sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==",
+    "node_modules/estree-util-attach-comments": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/estree-util-attach-comments/-/estree-util-attach-comments-3.0.0.tgz",
+      "integrity": "sha512-cKUwm/HUcTDsYh/9FgnuFqpfquUbwIqwKM26BVCGDPVgvaCl/nDCCjUfiLlx6lsEZ3Z4RFxNbOQ60pkaEwFxGw==",
       "license": "MIT",
       "dependencies": {
-        "debug": "2.6.9",
-        "encodeurl": "~2.0.0",
-        "escape-html": "~1.0.3",
-        "on-finished": "2.4.1",
-        "parseurl": "~1.3.3",
-        "statuses": "2.0.1",
-        "unpipe": "~1.0.0"
+        "@types/estree": "^1.0.0"
       },
-      "engines": {
-        "node": ">= 0.8"
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/finalhandler/node_modules/debug": {
-      "version": "2.6.9",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
-      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+    "node_modules/estree-util-build-jsx": {
+      "version": "3.0.1",
+      "resolved": "https://registry.facebook.net/estree-util-build-jsx/-/estree-util-build-jsx-3.0.1.tgz",
+      "integrity": "sha512-8U5eiL6BTrPxp/CHbs2yMgP8ftMhR5ww1eIKoWRMlqvltHF8fZn5LRDvTKuxD3DUn+shRbLGqXemcP51oFCsGQ==",
       "license": "MIT",
       "dependencies": {
-        "ms": "2.0.0"
+        "@types/estree-jsx": "^1.0.0",
+        "devlop": "^1.0.0",
+        "estree-util-is-identifier-name": "^3.0.0",
+        "estree-walker": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/finalhandler/node_modules/ms": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
-      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
-      "license": "MIT"
+    "node_modules/estree-util-is-identifier-name": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/estree-util-is-identifier-name/-/estree-util-is-identifier-name-3.0.0.tgz",
+      "integrity": "sha512-hFtqIDZTIUZ9BXLb8y4pYGyk6+wekIivNVTcmvk8NoOh+VeRn5y6cEHzbURrWbfp1fIqdVipilzj+lfaadNZmg==",
+      "license": "MIT",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
     },
-    "node_modules/find-cache-dir": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/find-cache-dir/-/find-cache-dir-4.0.0.tgz",
-      "integrity": "sha512-9ZonPT4ZAK4a+1pUPVPZJapbi7O5qbbJPdYw/NOQWZZbVLdDTYM3A4R9z/DpAM08IDaFGsvPgiGZ82WEwUDWjg==",
+    "node_modules/estree-util-scope": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/estree-util-scope/-/estree-util-scope-1.0.0.tgz",
+      "integrity": "sha512-2CAASclonf+JFWBNJPndcOpA8EMJwa0Q8LUFJEKqXLW6+qBvbFZuF5gItbQOs/umBUkjviCSDCbBwU2cXbmrhQ==",
       "license": "MIT",
       "dependencies": {
-        "common-path-prefix": "^3.0.0",
-        "pkg-dir": "^7.0.0"
-      },
-      "engines": {
-        "node": ">=14.16"
+        "@types/estree": "^1.0.0",
+        "devlop": "^1.0.0"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/find-up": {
-      "version": "6.3.0",
-      "resolved": "https://registry.npmjs.org/find-up/-/find-up-6.3.0.tgz",
-      "integrity": "sha512-v2ZsoEuVHYy8ZIlYqwPe/39Cy+cFDzp4dXPaxNvkEuouymu+2Jbz0PxpKarJHYJTmv2HWT3O382qY8l4jMWthw==",
+    "node_modules/estree-util-to-js": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/estree-util-to-js/-/estree-util-to-js-2.0.0.tgz",
+      "integrity": "sha512-WDF+xj5rRWmD5tj6bIqRi6CkLIXbbNQUcxQHzGysQzvHmdYG2G7p/Tf0J0gpxGgkeMZNTIjT/AoSvC9Xehcgdg==",
       "license": "MIT",
       "dependencies": {
-        "locate-path": "^7.1.0",
-        "path-exists": "^5.0.0"
-      },
-      "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+        "@types/estree-jsx": "^1.0.0",
+        "astring": "^1.8.0",
+        "source-map": "^0.7.0"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/flat": {
-      "version": "5.0.2",
-      "resolved": "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz",
-      "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==",
+    "node_modules/estree-util-to-js/node_modules/source-map": {
+      "version": "0.7.6",
+      "resolved": "https://registry.facebook.net/source-map/-/source-map-0.7.6.tgz",
+      "integrity": "sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ==",
       "license": "BSD-3-Clause",
-      "bin": {
-        "flat": "cli.js"
-      }
-    },
-    "node_modules/follow-redirects": {
-      "version": "1.15.9",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.9.tgz",
-      "integrity": "sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==",
-      "funding": [
-        {
-          "type": "individual",
-          "url": "https://github.com/sponsors/RubenVerborgh"
-        }
-      ],
-      "license": "MIT",
       "engines": {
-        "node": ">=4.0"
-      },
-      "peerDependenciesMeta": {
-        "debug": {
-          "optional": true
-        }
+        "node": ">= 12"
       }
     },
-    "node_modules/fork-ts-checker-webpack-plugin": {
-      "version": "6.5.3",
-      "resolved": "https://registry.npmjs.org/fork-ts-checker-webpack-plugin/-/fork-ts-checker-webpack-plugin-6.5.3.tgz",
-      "integrity": "sha512-SbH/l9ikmMWycd5puHJKTkZJKddF4iRLyW3DeZ08HTI7NGyLS38MXd/KGgeWumQO7YNQbW2u/NtPT2YowbPaGQ==",
+    "node_modules/estree-util-value-to-estree": {
+      "version": "3.5.0",
+      "resolved": "https://registry.facebook.net/estree-util-value-to-estree/-/estree-util-value-to-estree-3.5.0.tgz",
+      "integrity": "sha512-aMV56R27Gv3QmfmF1MY12GWkGzzeAezAX+UplqHVASfjc9wNzI/X6hC0S9oxq61WT4aQesLGslWP9tKk6ghRZQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/code-frame": "^7.8.3",
-        "@types/json-schema": "^7.0.5",
-        "chalk": "^4.1.0",
-        "chokidar": "^3.4.2",
-        "cosmiconfig": "^6.0.0",
-        "deepmerge": "^4.2.2",
-        "fs-extra": "^9.0.0",
-        "glob": "^7.1.6",
-        "memfs": "^3.1.2",
-        "minimatch": "^3.0.4",
-        "schema-utils": "2.7.0",
-        "semver": "^7.3.2",
-        "tapable": "^1.0.0"
-      },
-      "engines": {
-        "node": ">=10",
-        "yarn": ">=1.0.0"
-      },
-      "peerDependencies": {
-        "eslint": ">= 6",
-        "typescript": ">= 2.7",
-        "vue-template-compiler": "*",
-        "webpack": ">= 4"
+        "@types/estree": "^1.0.0"
       },
-      "peerDependenciesMeta": {
-        "eslint": {
-          "optional": true
-        },
-        "vue-template-compiler": {
-          "optional": true
-        }
+      "funding": {
+        "url": "https://github.com/sponsors/remcohaszing"
       }
     },
-    "node_modules/fork-ts-checker-webpack-plugin/node_modules/ajv": {
-      "version": "6.12.6",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
-      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+    "node_modules/estree-util-visit": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/estree-util-visit/-/estree-util-visit-2.0.0.tgz",
+      "integrity": "sha512-m5KgiH85xAhhW8Wta0vShLcUvOsh3LLPI2YVwcbio1l7E09NTLL1EyMZFM1OyWowoH0skScNbhOPl4kcBgzTww==",
       "license": "MIT",
       "dependencies": {
-        "fast-deep-equal": "^3.1.1",
-        "fast-json-stable-stringify": "^2.0.0",
-        "json-schema-traverse": "^0.4.1",
-        "uri-js": "^4.2.2"
+        "@types/estree-jsx": "^1.0.0",
+        "@types/unist": "^3.0.0"
       },
       "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/epoberezkin"
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/fork-ts-checker-webpack-plugin/node_modules/ajv-keywords": {
-      "version": "3.5.2",
-      "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz",
-      "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==",
+    "node_modules/estree-walker": {
+      "version": "3.0.3",
+      "resolved": "https://registry.facebook.net/estree-walker/-/estree-walker-3.0.3.tgz",
+      "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
       "license": "MIT",
-      "peerDependencies": {
-        "ajv": "^6.9.1"
+      "dependencies": {
+        "@types/estree": "^1.0.0"
       }
     },
-    "node_modules/fork-ts-checker-webpack-plugin/node_modules/cosmiconfig": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-6.0.0.tgz",
-      "integrity": "sha512-xb3ZL6+L8b9JLLCx3ZdoZy4+2ECphCMo2PwqgP1tlfVq6M6YReyzBJtvWWtbDSpNr9hn96pkCiZqUcFEc+54Qg==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/parse-json": "^4.0.0",
-        "import-fresh": "^3.1.0",
-        "parse-json": "^5.0.0",
-        "path-type": "^4.0.0",
-        "yaml": "^1.7.2"
-      },
+    "node_modules/esutils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.facebook.net/esutils/-/esutils-2.0.3.tgz",
+      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+      "license": "BSD-2-Clause",
       "engines": {
-        "node": ">=8"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/fork-ts-checker-webpack-plugin/node_modules/fs-extra": {
-      "version": "9.1.0",
-      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz",
-      "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==",
+    "node_modules/eta": {
+      "version": "2.2.0",
+      "resolved": "https://registry.facebook.net/eta/-/eta-2.2.0.tgz",
+      "integrity": "sha512-UVQ72Rqjy/ZKQalzV5dCCJP80GrmPrMxh6NlNf+erV6ObL0ZFkhCstWRawS85z3smdr3d2wXPsZEY7rDPfGd2g==",
       "license": "MIT",
-      "dependencies": {
-        "at-least-node": "^1.0.0",
-        "graceful-fs": "^4.2.0",
-        "jsonfile": "^6.0.1",
-        "universalify": "^2.0.0"
-      },
       "engines": {
-        "node": ">=10"
+        "node": ">=6.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/eta-dev/eta?sponsor=1"
       }
     },
-    "node_modules/fork-ts-checker-webpack-plugin/node_modules/json-schema-traverse": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
-      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
-      "license": "MIT"
-    },
-    "node_modules/fork-ts-checker-webpack-plugin/node_modules/schema-utils": {
-      "version": "2.7.0",
-      "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-2.7.0.tgz",
-      "integrity": "sha512-0ilKFI6QQF5nxDZLFn2dMjvc4hjg/Wkg7rHd3jK6/A4a1Hl9VFdQWvgB1UMGoU94pad1P/8N7fMcEnLnSiju8A==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/json-schema": "^7.0.4",
-        "ajv": "^6.12.2",
-        "ajv-keywords": "^3.4.1"
-      },
-      "engines": {
-        "node": ">= 8.9.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/webpack"
-      }
-    },
-    "node_modules/fork-ts-checker-webpack-plugin/node_modules/tapable": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/tapable/-/tapable-1.1.3.tgz",
-      "integrity": "sha512-4WK/bYZmj8xLr+HUCODHGF1ZFzsYffasLUgEiMBY4fgtltdO6B4WJtlSbPaDTLpYTcGVwM2qLnFTICEcNxs3kA==",
+    "node_modules/etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.facebook.net/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
       "license": "MIT",
       "engines": {
-        "node": ">=6"
+        "node": ">= 0.6"
       }
     },
-    "node_modules/form-data": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.1.tgz",
-      "integrity": "sha512-tzN8e4TX8+kkxGPK8D5u0FNmjPUjw3lwC9lSLxxoB/+GtsJG91CO8bSWy73APlgAZzZbXEYZJuxjkHH2w+Ezhw==",
-      "license": "MIT",
+    "node_modules/eval": {
+      "version": "0.1.8",
+      "resolved": "https://registry.facebook.net/eval/-/eval-0.1.8.tgz",
+      "integrity": "sha512-EzV94NYKoO09GLXGjXj9JIlXijVck4ONSr5wiCWDvhsvj5jxSrzTmRU/9C1DyB6uToszLs8aifA6NQ7lEQdvFw==",
       "dependencies": {
-        "asynckit": "^0.4.0",
-        "combined-stream": "^1.0.8",
-        "mime-types": "^2.1.12"
+        "@types/node": "*",
+        "require-like": ">= 0.1.1"
       },
       "engines": {
-        "node": ">= 6"
+        "node": ">= 0.8"
       }
     },
-    "node_modules/form-data-encoder": {
-      "version": "2.1.4",
-      "resolved": "https://registry.npmjs.org/form-data-encoder/-/form-data-encoder-2.1.4.tgz",
-      "integrity": "sha512-yDYSgNMraqvnxiEXO4hi88+YZxaHC6QKzb5N84iRCTDeRO7ZALpir/lVmf/uXUhnwUr2O4HU8s/n6x+yNjQkHw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 14.17"
-      }
+    "node_modules/eventemitter3": {
+      "version": "4.0.7",
+      "resolved": "https://registry.facebook.net/eventemitter3/-/eventemitter3-4.0.7.tgz",
+      "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==",
+      "license": "MIT"
     },
-    "node_modules/format": {
-      "version": "0.2.2",
-      "resolved": "https://registry.npmjs.org/format/-/format-0.2.2.tgz",
-      "integrity": "sha512-wzsgA6WOq+09wrU1tsJ09udeR/YZRaeArL9e1wPbFg3GG2yDnC2ldKpxs4xunpFF9DgqCqOIra3bc1HWrJ37Ww==",
+    "node_modules/events": {
+      "version": "3.3.0",
+      "resolved": "https://registry.facebook.net/events/-/events-3.3.0.tgz",
+      "integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==",
+      "license": "MIT",
       "engines": {
-        "node": ">=0.4.x"
+        "node": ">=0.8.x"
       }
     },
-    "node_modules/forwarded": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
-      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+    "node_modules/execa": {
+      "version": "5.1.1",
+      "resolved": "https://registry.facebook.net/execa/-/execa-5.1.1.tgz",
+      "integrity": "sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==",
       "license": "MIT",
+      "dependencies": {
+        "cross-spawn": "^7.0.3",
+        "get-stream": "^6.0.0",
+        "human-signals": "^2.1.0",
+        "is-stream": "^2.0.0",
+        "merge-stream": "^2.0.0",
+        "npm-run-path": "^4.0.1",
+        "onetime": "^5.1.2",
+        "signal-exit": "^3.0.3",
+        "strip-final-newline": "^2.0.0"
+      },
       "engines": {
-        "node": ">= 0.6"
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sindresorhus/execa?sponsor=1"
       }
     },
-    "node_modules/fraction.js": {
-      "version": "4.3.7",
-      "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-4.3.7.tgz",
-      "integrity": "sha512-ZsDfxO51wGAXREY55a7la9LScWpwv9RxIrYABrlvOFBlH/ShPnrtsXeuUIfXKKOVicNxQ+o8JTbJvjS4M89yew==",
+    "node_modules/express": {
+      "version": "4.22.1",
+      "resolved": "https://registry.facebook.net/express/-/express-4.22.1.tgz",
+      "integrity": "sha512-F2X8g9P1X7uCPZMA3MVf9wcTqlyNp7IhH5qPCI0izhaOIYXaW9L535tGA3qmjRzpH+bZczqq7hVKxTR4NWnu+g==",
       "license": "MIT",
+      "dependencies": {
+        "accepts": "~1.3.8",
+        "array-flatten": "1.1.1",
+        "body-parser": "~1.20.3",
+        "content-disposition": "~0.5.4",
+        "content-type": "~1.0.4",
+        "cookie": "~0.7.1",
+        "cookie-signature": "~1.0.6",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "finalhandler": "~1.3.1",
+        "fresh": "~0.5.2",
+        "http-errors": "~2.0.0",
+        "merge-descriptors": "1.0.3",
+        "methods": "~1.1.2",
+        "on-finished": "~2.4.1",
+        "parseurl": "~1.3.3",
+        "path-to-regexp": "~0.1.12",
+        "proxy-addr": "~2.0.7",
+        "qs": "~6.14.0",
+        "range-parser": "~1.2.1",
+        "safe-buffer": "5.2.1",
+        "send": "~0.19.0",
+        "serve-static": "~1.16.2",
+        "setprototypeof": "1.2.0",
+        "statuses": "~2.0.1",
+        "type-is": "~1.6.18",
+        "utils-merge": "1.0.1",
+        "vary": "~1.1.2"
+      },
       "engines": {
-        "node": "*"
+        "node": ">= 0.10.0"
       },
       "funding": {
-        "type": "patreon",
-        "url": "https://github.com/sponsors/rawify"
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
       }
     },
-    "node_modules/fresh": {
-      "version": "0.5.2",
-      "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
-      "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==",
+    "node_modules/express/node_modules/content-disposition": {
+      "version": "0.5.4",
+      "resolved": "https://registry.facebook.net/content-disposition/-/content-disposition-0.5.4.tgz",
+      "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
       "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "5.2.1"
+      },
       "engines": {
         "node": ">= 0.6"
       }
     },
-    "node_modules/fs-extra": {
-      "version": "11.2.0",
-      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.2.0.tgz",
-      "integrity": "sha512-PmDi3uwK5nFuXh7XDTlVnS17xJS7vW36is2+w3xcv8SVxiB4NyATf4ctkVY5bkSjX0Y4nbvZCq1/EjtEyr9ktw==",
+    "node_modules/express/node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.facebook.net/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
       "license": "MIT",
       "dependencies": {
-        "graceful-fs": "^4.2.0",
-        "jsonfile": "^6.0.1",
-        "universalify": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=14.14"
+        "ms": "2.0.0"
       }
     },
-    "node_modules/fs-monkey": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/fs-monkey/-/fs-monkey-1.0.6.tgz",
-      "integrity": "sha512-b1FMfwetIKymC0eioW7mTywihSQE4oLzQn1dB6rZB5fx/3NpNEdAWeCSMB+60/AeT0TCXsxzAlcYVEFCTAksWg==",
-      "license": "Unlicense"
-    },
-    "node_modules/fs.realpath": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
-      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
-      "license": "ISC"
+    "node_modules/express/node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "license": "MIT"
     },
-    "node_modules/fsevents": {
-      "version": "2.3.3",
-      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
-      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
-      "hasInstallScript": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
-      }
+    "node_modules/express/node_modules/path-to-regexp": {
+      "version": "0.1.13",
+      "resolved": "https://registry.facebook.net/path-to-regexp/-/path-to-regexp-0.1.13.tgz",
+      "integrity": "sha512-A/AGNMFN3c8bOlvV9RreMdrv7jsmF9XIfDeCd87+I8RNg6s78BhJxMu69NEMHBSJFxKidViTEdruRwEk/WIKqA==",
+      "license": "MIT"
     },
-    "node_modules/function-bind": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
-      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
+    "node_modules/extend": {
+      "version": "3.0.2",
+      "resolved": "https://registry.facebook.net/extend/-/extend-3.0.2.tgz",
+      "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==",
+      "license": "MIT"
     },
-    "node_modules/gensync": {
-      "version": "1.0.0-beta.2",
-      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
-      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+    "node_modules/extend-shallow": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/extend-shallow/-/extend-shallow-2.0.1.tgz",
+      "integrity": "sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==",
       "license": "MIT",
+      "dependencies": {
+        "is-extendable": "^0.1.0"
+      },
       "engines": {
-        "node": ">=6.9.0"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/get-intrinsic": {
-      "version": "1.2.7",
-      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.7.tgz",
-      "integrity": "sha512-VW6Pxhsrk0KAOqs3WEd0klDiF/+V7gQOpAvY1jVU/LHmaD/kQO4523aiJuikX/QAKYiW6x8Jh+RJej1almdtCA==",
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.facebook.net/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+      "license": "MIT"
+    },
+    "node_modules/fast-glob": {
+      "version": "3.3.3",
+      "resolved": "https://registry.facebook.net/fast-glob/-/fast-glob-3.3.3.tgz",
+      "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==",
       "license": "MIT",
       "dependencies": {
-        "call-bind-apply-helpers": "^1.0.1",
-        "es-define-property": "^1.0.1",
-        "es-errors": "^1.3.0",
-        "es-object-atoms": "^1.0.0",
-        "function-bind": "^1.1.2",
-        "get-proto": "^1.0.0",
-        "gopd": "^1.2.0",
-        "has-symbols": "^1.1.0",
-        "hasown": "^2.0.2",
-        "math-intrinsics": "^1.1.0"
+        "@nodelib/fs.stat": "^2.0.2",
+        "@nodelib/fs.walk": "^1.2.3",
+        "glob-parent": "^5.1.2",
+        "merge2": "^1.3.0",
+        "micromatch": "^4.0.8"
       },
       "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "node": ">=8.6.0"
       }
     },
-    "node_modules/get-own-enumerable-property-symbols": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/get-own-enumerable-property-symbols/-/get-own-enumerable-property-symbols-3.0.2.tgz",
-      "integrity": "sha512-I0UBV/XOz1XkIJHEUDMZAbzCThU/H8DxmSfmdGcKPnVhu2VfFqr34jr9777IyaTYvxjedWhqVIilEDsCdP5G6g==",
-      "license": "ISC"
+    "node_modules/fast-json-stable-stringify": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+      "license": "MIT"
     },
-    "node_modules/get-proto": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.0.tgz",
-      "integrity": "sha512-TtLgOcKaF1nMP2ijJnITkE4nRhbpshHhmzKiuhmSniiwWzovoqwqQ8rNuhf0mXJOqIY5iU+QkUe0CkJYrLsG9w==",
-      "license": "MIT",
+    "node_modules/fast-uri": {
+      "version": "3.1.0",
+      "resolved": "https://registry.facebook.net/fast-uri/-/fast-uri-3.1.0.tgz",
+      "integrity": "sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fastify"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fastify"
+        }
+      ],
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/fastq": {
+      "version": "1.20.1",
+      "resolved": "https://registry.facebook.net/fastq/-/fastq-1.20.1.tgz",
+      "integrity": "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==",
+      "license": "ISC",
       "dependencies": {
-        "dunder-proto": "^1.0.1",
-        "es-object-atoms": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
+        "reusify": "^1.0.4"
       }
     },
-    "node_modules/get-stream": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz",
-      "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==",
+    "node_modules/fault": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/fault/-/fault-2.0.1.tgz",
+      "integrity": "sha512-WtySTkS4OKev5JtpHXnib4Gxiurzh5NCGvWrFaZ34m6JehfTUhKZvn9njTfw48t6JumVQOmrKqpmGcdwxnhqBQ==",
       "license": "MIT",
-      "engines": {
-        "node": ">=10"
+      "dependencies": {
+        "format": "^0.2.0"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
       }
     },
-    "node_modules/github-slugger": {
-      "version": "1.5.0",
-      "resolved": "https://registry.npmjs.org/github-slugger/-/github-slugger-1.5.0.tgz",
-      "integrity": "sha512-wIh+gKBI9Nshz2o46B0B3f5k/W+WI9ZAv6y5Dn5WJ5SK1t0TnDimB4WE5rmTD05ZAIn8HALCZVmCsvj0w0v0lw==",
-      "license": "ISC"
-    },
-    "node_modules/glob": {
-      "version": "7.2.3",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
-      "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
-      "deprecated": "Glob versions prior to v9 are no longer supported",
-      "license": "ISC",
+    "node_modules/faye-websocket": {
+      "version": "0.11.4",
+      "resolved": "https://registry.facebook.net/faye-websocket/-/faye-websocket-0.11.4.tgz",
+      "integrity": "sha512-CzbClwlXAuiRQAlUyfqPgvPoNKTckTPGfwZV4ZdAhVcP2lh9KUxJg2b5GkE7XbjKQ3YJnQ9z6D9ntLAlB+tP8g==",
+      "license": "Apache-2.0",
       "dependencies": {
-        "fs.realpath": "^1.0.0",
-        "inflight": "^1.0.4",
-        "inherits": "2",
-        "minimatch": "^3.1.1",
-        "once": "^1.3.0",
-        "path-is-absolute": "^1.0.0"
+        "websocket-driver": ">=0.5.1"
       },
       "engines": {
-        "node": "*"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
+        "node": ">=0.8.0"
       }
     },
-    "node_modules/glob-parent": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
-      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
-      "license": "ISC",
+    "node_modules/feed": {
+      "version": "4.2.2",
+      "resolved": "https://registry.facebook.net/feed/-/feed-4.2.2.tgz",
+      "integrity": "sha512-u5/sxGfiMfZNtJ3OvQpXcvotFpYkL0n9u9mM2vkui2nGo8b4wvDkJ8gAkYqbA8QpGyFCv3RK0Z+Iv+9veCS9bQ==",
+      "license": "MIT",
       "dependencies": {
-        "is-glob": "^4.0.1"
+        "xml-js": "^1.6.11"
       },
       "engines": {
-        "node": ">= 6"
+        "node": ">=0.4.0"
       }
     },
-    "node_modules/glob-to-regexp": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz",
-      "integrity": "sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==",
-      "license": "BSD-2-Clause"
-    },
-    "node_modules/global-dirs": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/global-dirs/-/global-dirs-3.0.1.tgz",
-      "integrity": "sha512-NBcGGFbBA9s1VzD41QXDG+3++t9Mn5t1FpLdhESY6oKY4gYTFpX4wO3sqGUa0Srjtbfj3szX0RnemmrVRUdULA==",
-      "license": "MIT",
+    "node_modules/figures": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/figures/-/figures-3.2.0.tgz",
+      "integrity": "sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg==",
       "dependencies": {
-        "ini": "2.0.0"
+        "escape-string-regexp": "^1.0.5"
       },
       "engines": {
-        "node": ">=10"
+        "node": ">=8"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/global-dirs/node_modules/ini": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/ini/-/ini-2.0.0.tgz",
-      "integrity": "sha512-7PnF4oN3CvZF23ADhA5wRaYEQpJ8qygSkbtTXWBeXWXmEVRXK+1ITciHWwHhsjv1TmW0MgacIv6hEi5pX5NQdA==",
-      "license": "ISC",
+    "node_modules/figures/node_modules/escape-string-regexp": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
+      "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
       "engines": {
-        "node": ">=10"
+        "node": ">=0.8.0"
       }
     },
-    "node_modules/global-modules": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/global-modules/-/global-modules-2.0.0.tgz",
-      "integrity": "sha512-NGbfmJBp9x8IxyJSd1P+otYK8vonoJactOogrVfFRIAEY1ukil8RSKDz2Yo7wh1oihl51l/r6W4epkeKJHqL8A==",
+    "node_modules/file-loader": {
+      "version": "6.2.0",
+      "resolved": "https://registry.facebook.net/file-loader/-/file-loader-6.2.0.tgz",
+      "integrity": "sha512-qo3glqyTa61Ytg4u73GultjHGjdRyig3tG6lPtyX/jOEJvHif9uB0/OCI2Kif6ctF3caQTW2G5gym21oAsI4pw==",
       "license": "MIT",
       "dependencies": {
-        "global-prefix": "^3.0.0"
+        "loader-utils": "^2.0.0",
+        "schema-utils": "^3.0.0"
       },
       "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/global-prefix": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/global-prefix/-/global-prefix-3.0.0.tgz",
-      "integrity": "sha512-awConJSVCHVGND6x3tmMaKcQvwXLhjdkmomy2W+Goaui8YPgYgXJZewhg3fWC+DlfqqQuWg8AwqjGTD2nAPVWg==",
-      "license": "MIT",
-      "dependencies": {
-        "ini": "^1.3.5",
-        "kind-of": "^6.0.2",
-        "which": "^1.3.1"
+        "node": ">= 10.13.0"
       },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/global-prefix/node_modules/which": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz",
-      "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==",
-      "license": "ISC",
-      "dependencies": {
-        "isexe": "^2.0.0"
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
       },
-      "bin": {
-        "which": "bin/which"
-      }
-    },
-    "node_modules/globals": {
-      "version": "11.12.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz",
-      "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
+      "peerDependencies": {
+        "webpack": "^4.0.0 || ^5.0.0"
       }
     },
-    "node_modules/globby": {
-      "version": "11.1.0",
-      "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz",
-      "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==",
+    "node_modules/file-loader/node_modules/ajv": {
+      "version": "6.15.0",
+      "resolved": "https://registry.facebook.net/ajv/-/ajv-6.15.0.tgz",
+      "integrity": "sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==",
       "license": "MIT",
       "dependencies": {
-        "array-union": "^2.1.0",
-        "dir-glob": "^3.0.1",
-        "fast-glob": "^3.2.9",
-        "ignore": "^5.2.0",
-        "merge2": "^1.4.1",
-        "slash": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=10"
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
       }
     },
-    "node_modules/gopd": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
-      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+    "node_modules/file-loader/node_modules/ajv-keywords": {
+      "version": "3.5.2",
+      "resolved": "https://registry.facebook.net/ajv-keywords/-/ajv-keywords-3.5.2.tgz",
+      "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==",
       "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+      "peerDependencies": {
+        "ajv": "^6.9.1"
       }
     },
-    "node_modules/got": {
-      "version": "12.6.1",
-      "resolved": "https://registry.npmjs.org/got/-/got-12.6.1.tgz",
-      "integrity": "sha512-mThBblvlAF1d4O5oqyvN+ZxLAYwIJK7bpMxgYqPD9okW0C3qm5FFn7k811QrcuEBwaogR3ngOFoCfs6mRv7teQ==",
+    "node_modules/file-loader/node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.facebook.net/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+      "license": "MIT"
+    },
+    "node_modules/file-loader/node_modules/schema-utils": {
+      "version": "3.3.0",
+      "resolved": "https://registry.facebook.net/schema-utils/-/schema-utils-3.3.0.tgz",
+      "integrity": "sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==",
       "license": "MIT",
       "dependencies": {
-        "@sindresorhus/is": "^5.2.0",
-        "@szmarczak/http-timer": "^5.0.1",
-        "cacheable-lookup": "^7.0.0",
-        "cacheable-request": "^10.2.8",
-        "decompress-response": "^6.0.0",
-        "form-data-encoder": "^2.1.2",
-        "get-stream": "^6.0.1",
-        "http2-wrapper": "^2.1.10",
-        "lowercase-keys": "^3.0.0",
-        "p-cancelable": "^3.0.0",
-        "responselike": "^3.0.0"
+        "@types/json-schema": "^7.0.8",
+        "ajv": "^6.12.5",
+        "ajv-keywords": "^3.5.2"
       },
       "engines": {
-        "node": ">=14.16"
+        "node": ">= 10.13.0"
       },
       "funding": {
-        "url": "https://github.com/sindresorhus/got?sponsor=1"
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
       }
     },
-    "node_modules/got/node_modules/@sindresorhus/is": {
-      "version": "5.6.0",
-      "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-5.6.0.tgz",
-      "integrity": "sha512-TV7t8GKYaJWsn00tFDqBw8+Uqmr8A0fRU1tvTQhyZzGv0sJCGRQL3JGMI3ucuKo3XIZdUP+Lx7/gh2t3lewy7g==",
+    "node_modules/fill-range": {
+      "version": "7.1.1",
+      "resolved": "https://registry.facebook.net/fill-range/-/fill-range-7.1.1.tgz",
+      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
       "license": "MIT",
-      "engines": {
-        "node": ">=14.16"
+      "dependencies": {
+        "to-regex-range": "^5.0.1"
       },
-      "funding": {
-        "url": "https://github.com/sindresorhus/is?sponsor=1"
+      "engines": {
+        "node": ">=8"
       }
     },
-    "node_modules/graceful-fs": {
-      "version": "4.2.11",
-      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
-      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
-      "license": "ISC"
-    },
-    "node_modules/gray-matter": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/gray-matter/-/gray-matter-4.0.3.tgz",
-      "integrity": "sha512-5v6yZd4JK3eMI3FqqCouswVqwugaA9r4dNZB1wwcmrD02QkV5H0y7XBQW8QwQqEaZY1pM9aqORSORhJRdNK44Q==",
+    "node_modules/finalhandler": {
+      "version": "1.3.2",
+      "resolved": "https://registry.facebook.net/finalhandler/-/finalhandler-1.3.2.tgz",
+      "integrity": "sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg==",
       "license": "MIT",
       "dependencies": {
-        "js-yaml": "^3.13.1",
-        "kind-of": "^6.0.2",
-        "section-matter": "^1.0.0",
-        "strip-bom-string": "^1.0.0"
+        "debug": "2.6.9",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "on-finished": "~2.4.1",
+        "parseurl": "~1.3.3",
+        "statuses": "~2.0.2",
+        "unpipe": "~1.0.0"
       },
       "engines": {
-        "node": ">=6.0"
+        "node": ">= 0.8"
       }
     },
-    "node_modules/gray-matter/node_modules/argparse": {
-      "version": "1.0.10",
-      "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
-      "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
+    "node_modules/finalhandler/node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.facebook.net/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
       "license": "MIT",
       "dependencies": {
-        "sprintf-js": "~1.0.2"
+        "ms": "2.0.0"
       }
     },
-    "node_modules/gray-matter/node_modules/js-yaml": {
-      "version": "3.14.1",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz",
-      "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==",
+    "node_modules/finalhandler/node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "license": "MIT"
+    },
+    "node_modules/find-cache-dir": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/find-cache-dir/-/find-cache-dir-4.0.0.tgz",
+      "integrity": "sha512-9ZonPT4ZAK4a+1pUPVPZJapbi7O5qbbJPdYw/NOQWZZbVLdDTYM3A4R9z/DpAM08IDaFGsvPgiGZ82WEwUDWjg==",
       "license": "MIT",
       "dependencies": {
-        "argparse": "^1.0.7",
-        "esprima": "^4.0.0"
+        "common-path-prefix": "^3.0.0",
+        "pkg-dir": "^7.0.0"
       },
-      "bin": {
-        "js-yaml": "bin/js-yaml.js"
+      "engines": {
+        "node": ">=14.16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/gzip-size": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/gzip-size/-/gzip-size-6.0.0.tgz",
-      "integrity": "sha512-ax7ZYomf6jqPTQ4+XCpUGyXKHk5WweS+e05MBO4/y3WJ5RkmPXNKvX+bx1behVILVwr6JSQvZAku021CHPXG3Q==",
+    "node_modules/find-up": {
+      "version": "6.3.0",
+      "resolved": "https://registry.facebook.net/find-up/-/find-up-6.3.0.tgz",
+      "integrity": "sha512-v2ZsoEuVHYy8ZIlYqwPe/39Cy+cFDzp4dXPaxNvkEuouymu+2Jbz0PxpKarJHYJTmv2HWT3O382qY8l4jMWthw==",
       "license": "MIT",
       "dependencies": {
-        "duplexer": "^0.1.2"
+        "locate-path": "^7.1.0",
+        "path-exists": "^5.0.0"
       },
       "engines": {
-        "node": ">=10"
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/handle-thing": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/handle-thing/-/handle-thing-2.0.1.tgz",
-      "integrity": "sha512-9Qn4yBxelxoh2Ow62nP+Ka/kMnOXRi8BXnRaUwezLNhqelnN49xKz4F/dPP8OYLxLxq6JDtZb2i9XznUQbNPTg==",
-      "license": "MIT"
+    "node_modules/flat": {
+      "version": "5.0.2",
+      "resolved": "https://registry.facebook.net/flat/-/flat-5.0.2.tgz",
+      "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==",
+      "license": "BSD-3-Clause",
+      "bin": {
+        "flat": "cli.js"
+      }
     },
-    "node_modules/has-flag": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
-      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+    "node_modules/follow-redirects": {
+      "version": "1.16.0",
+      "resolved": "https://registry.facebook.net/follow-redirects/-/follow-redirects-1.16.0.tgz",
+      "integrity": "sha512-y5rN/uOsadFT/JfYwhxRS5R7Qce+g3zG97+JrtFZlC9klX/W5hD7iiLzScI4nZqUS7DNUdhPgw4xI8W2LuXlUw==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/RubenVerborgh"
+        }
+      ],
       "license": "MIT",
       "engines": {
-        "node": ">=8"
+        "node": ">=4.0"
+      },
+      "peerDependenciesMeta": {
+        "debug": {
+          "optional": true
+        }
       }
     },
-    "node_modules/has-property-descriptors": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
-      "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
+    "node_modules/form-data": {
+      "version": "4.0.5",
+      "resolved": "https://registry.facebook.net/form-data/-/form-data-4.0.5.tgz",
+      "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
       "license": "MIT",
       "dependencies": {
-        "es-define-property": "^1.0.0"
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "es-set-tostringtag": "^2.1.0",
+        "hasown": "^2.0.2",
+        "mime-types": "^2.1.12"
       },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+      "engines": {
+        "node": ">= 6"
       }
     },
-    "node_modules/has-symbols": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
-      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+    "node_modules/form-data-encoder": {
+      "version": "2.1.4",
+      "resolved": "https://registry.facebook.net/form-data-encoder/-/form-data-encoder-2.1.4.tgz",
+      "integrity": "sha512-yDYSgNMraqvnxiEXO4hi88+YZxaHC6QKzb5N84iRCTDeRO7ZALpir/lVmf/uXUhnwUr2O4HU8s/n6x+yNjQkHw==",
       "license": "MIT",
       "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "node": ">= 14.17"
       }
     },
-    "node_modules/has-yarn": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/has-yarn/-/has-yarn-3.0.0.tgz",
-      "integrity": "sha512-IrsVwUHhEULx3R8f/aA8AHuEzAorplsab/v8HBzEiIukwq5i/EC+xmOW+HfP1OaDP+2JkgT1yILHN2O3UFIbcA==",
-      "license": "MIT",
+    "node_modules/format": {
+      "version": "0.2.2",
+      "resolved": "https://registry.facebook.net/format/-/format-0.2.2.tgz",
+      "integrity": "sha512-wzsgA6WOq+09wrU1tsJ09udeR/YZRaeArL9e1wPbFg3GG2yDnC2ldKpxs4xunpFF9DgqCqOIra3bc1HWrJ37Ww==",
       "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "node": ">=0.4.x"
       }
     },
-    "node_modules/hasown": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
-      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+    "node_modules/forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.facebook.net/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
       "license": "MIT",
-      "dependencies": {
-        "function-bind": "^1.1.2"
-      },
       "engines": {
-        "node": ">= 0.4"
+        "node": ">= 0.6"
       }
     },
-    "node_modules/hast-util-from-parse5": {
-      "version": "8.0.2",
-      "resolved": "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-8.0.2.tgz",
-      "integrity": "sha512-SfMzfdAi/zAoZ1KkFEyyeXBn7u/ShQrfd675ZEE9M3qj+PMFX05xubzRyF76CCSJu8au9jgVxDV1+okFvgZU4A==",
+    "node_modules/fraction.js": {
+      "version": "5.3.4",
+      "resolved": "https://registry.facebook.net/fraction.js/-/fraction.js-5.3.4.tgz",
+      "integrity": "sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ==",
       "license": "MIT",
-      "dependencies": {
-        "@types/hast": "^3.0.0",
-        "@types/unist": "^3.0.0",
-        "devlop": "^1.0.0",
-        "hastscript": "^9.0.0",
-        "property-information": "^6.0.0",
-        "vfile": "^6.0.0",
-        "vfile-location": "^5.0.0",
-        "web-namespaces": "^2.0.0"
+      "engines": {
+        "node": "*"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "type": "github",
+        "url": "https://github.com/sponsors/rawify"
       }
     },
-    "node_modules/hast-util-parse-selector": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-4.0.0.tgz",
-      "integrity": "sha512-wkQCkSYoOGCRKERFWcxMVMOcYE2K1AaNLU8DXS9arxnLOUEWbOXKXiJUNzEpqZ3JOKpnha3jkFrumEjVliDe7A==",
+    "node_modules/fresh": {
+      "version": "0.5.2",
+      "resolved": "https://registry.facebook.net/fresh/-/fresh-0.5.2.tgz",
+      "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==",
       "license": "MIT",
-      "dependencies": {
-        "@types/hast": "^3.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+      "engines": {
+        "node": ">= 0.6"
       }
     },
-    "node_modules/hast-util-raw": {
-      "version": "9.1.0",
-      "resolved": "https://registry.npmjs.org/hast-util-raw/-/hast-util-raw-9.1.0.tgz",
-      "integrity": "sha512-Y8/SBAHkZGoNkpzqqfCldijcuUKh7/su31kEBp67cFY09Wy0mTRgtsLYsiIxMJxlu0f6AA5SUTbDR8K0rxnbUw==",
+    "node_modules/fs-extra": {
+      "version": "11.3.4",
+      "resolved": "https://registry.facebook.net/fs-extra/-/fs-extra-11.3.4.tgz",
+      "integrity": "sha512-CTXd6rk/M3/ULNQj8FBqBWHYBVYybQ3VPBw0xGKFe3tuH7ytT6ACnvzpIQ3UZtB8yvUKC2cXn1a+x+5EVQLovA==",
       "license": "MIT",
       "dependencies": {
-        "@types/hast": "^3.0.0",
-        "@types/unist": "^3.0.0",
-        "@ungap/structured-clone": "^1.0.0",
-        "hast-util-from-parse5": "^8.0.0",
-        "hast-util-to-parse5": "^8.0.0",
-        "html-void-elements": "^3.0.0",
-        "mdast-util-to-hast": "^13.0.0",
-        "parse5": "^7.0.0",
-        "unist-util-position": "^5.0.0",
-        "unist-util-visit": "^5.0.0",
-        "vfile": "^6.0.0",
-        "web-namespaces": "^2.0.0",
-        "zwitch": "^2.0.0"
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
       },
+      "engines": {
+        "node": ">=14.14"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.facebook.net/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "license": "MIT",
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/hast-util-to-estree": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/hast-util-to-estree/-/hast-util-to-estree-3.1.0.tgz",
-      "integrity": "sha512-lfX5g6hqVh9kjS/B9E2gSkvHH4SZNiQFiqWS0x9fENzEl+8W12RqdRxX6d/Cwxi30tPQs3bIO+aolQJNp1bIyw==",
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.facebook.net/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.facebook.net/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
       "license": "MIT",
       "dependencies": {
-        "@types/estree": "^1.0.0",
-        "@types/estree-jsx": "^1.0.0",
-        "@types/hast": "^3.0.0",
-        "comma-separated-tokens": "^2.0.0",
-        "devlop": "^1.0.0",
-        "estree-util-attach-comments": "^3.0.0",
-        "estree-util-is-identifier-name": "^3.0.0",
-        "hast-util-whitespace": "^3.0.0",
-        "mdast-util-mdx-expression": "^2.0.0",
-        "mdast-util-mdx-jsx": "^3.0.0",
-        "mdast-util-mdxjs-esm": "^2.0.0",
-        "property-information": "^6.0.0",
-        "space-separated-tokens": "^2.0.0",
-        "style-to-object": "^0.4.0",
-        "unist-util-position": "^5.0.0",
-        "zwitch": "^2.0.0"
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/hast-util-to-estree/node_modules/inline-style-parser": {
-      "version": "0.1.1",
-      "resolved": "https://registry.npmjs.org/inline-style-parser/-/inline-style-parser-0.1.1.tgz",
-      "integrity": "sha512-7NXolsK4CAS5+xvdj5OMMbI962hU/wvwoxk+LWR9Ek9bVtyuuYScDN6eS0rUm6TxApFpw7CX1o4uJzcd4AyD3Q==",
-      "license": "MIT"
+    "node_modules/get-own-enumerable-property-symbols": {
+      "version": "3.0.2",
+      "resolved": "https://registry.facebook.net/get-own-enumerable-property-symbols/-/get-own-enumerable-property-symbols-3.0.2.tgz",
+      "integrity": "sha512-I0UBV/XOz1XkIJHEUDMZAbzCThU/H8DxmSfmdGcKPnVhu2VfFqr34jr9777IyaTYvxjedWhqVIilEDsCdP5G6g==",
+      "license": "ISC"
     },
-    "node_modules/hast-util-to-estree/node_modules/style-to-object": {
-      "version": "0.4.4",
-      "resolved": "https://registry.npmjs.org/style-to-object/-/style-to-object-0.4.4.tgz",
-      "integrity": "sha512-HYNoHZa2GorYNyqiCaBgsxvcJIn7OHq6inEga+E6Ke3m5JkoqpQbnFssk4jwe+K7AhGa2fcha4wSOf1Kn01dMg==",
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
       "license": "MIT",
       "dependencies": {
-        "inline-style-parser": "0.1.1"
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
       }
     },
-    "node_modules/hast-util-to-jsx-runtime": {
-      "version": "2.3.2",
-      "resolved": "https://registry.npmjs.org/hast-util-to-jsx-runtime/-/hast-util-to-jsx-runtime-2.3.2.tgz",
-      "integrity": "sha512-1ngXYb+V9UT5h+PxNRa1O1FYguZK/XL+gkeqvp7EdHlB9oHUG0eYRo/vY5inBdcqo3RkPMC58/H94HvkbfGdyg==",
+    "node_modules/get-stream": {
+      "version": "6.0.1",
+      "resolved": "https://registry.facebook.net/get-stream/-/get-stream-6.0.1.tgz",
+      "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==",
       "license": "MIT",
-      "dependencies": {
-        "@types/estree": "^1.0.0",
-        "@types/hast": "^3.0.0",
-        "@types/unist": "^3.0.0",
-        "comma-separated-tokens": "^2.0.0",
-        "devlop": "^1.0.0",
-        "estree-util-is-identifier-name": "^3.0.0",
-        "hast-util-whitespace": "^3.0.0",
-        "mdast-util-mdx-expression": "^2.0.0",
-        "mdast-util-mdx-jsx": "^3.0.0",
-        "mdast-util-mdxjs-esm": "^2.0.0",
-        "property-information": "^6.0.0",
-        "space-separated-tokens": "^2.0.0",
-        "style-to-object": "^1.0.0",
-        "unist-util-position": "^5.0.0",
-        "vfile-message": "^4.0.0"
+      "engines": {
+        "node": ">=10"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/hast-util-to-parse5": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/hast-util-to-parse5/-/hast-util-to-parse5-8.0.0.tgz",
-      "integrity": "sha512-3KKrV5ZVI8if87DVSi1vDeByYrkGzg4mEfeu4alwgmmIeARiBLKCZS2uw5Gb6nU9x9Yufyj3iudm6i7nl52PFw==",
-      "license": "MIT",
+    "node_modules/github-slugger": {
+      "version": "1.5.0",
+      "resolved": "https://registry.facebook.net/github-slugger/-/github-slugger-1.5.0.tgz",
+      "integrity": "sha512-wIh+gKBI9Nshz2o46B0B3f5k/W+WI9ZAv6y5Dn5WJ5SK1t0TnDimB4WE5rmTD05ZAIn8HALCZVmCsvj0w0v0lw==",
+      "license": "ISC"
+    },
+    "node_modules/glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://registry.facebook.net/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "license": "ISC",
       "dependencies": {
-        "@types/hast": "^3.0.0",
-        "comma-separated-tokens": "^2.0.0",
-        "devlop": "^1.0.0",
-        "property-information": "^6.0.0",
-        "space-separated-tokens": "^2.0.0",
-        "web-namespaces": "^2.0.0",
-        "zwitch": "^2.0.0"
+        "is-glob": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/glob-to-regex.js": {
+      "version": "1.2.0",
+      "resolved": "https://registry.facebook.net/glob-to-regex.js/-/glob-to-regex.js-1.2.0.tgz",
+      "integrity": "sha512-QMwlOQKU/IzqMUOAZWubUOT8Qft+Y0KQWnX9nK3ch0CJg0tTp4TvGZsTfudYKv2NzoQSyPcnA6TYeIQ3jGichQ==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=10.0"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "type": "github",
+        "url": "https://github.com/sponsors/streamich"
+      },
+      "peerDependencies": {
+        "tslib": "2"
       }
     },
-    "node_modules/hast-util-whitespace": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz",
-      "integrity": "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==",
+    "node_modules/glob-to-regexp": {
+      "version": "0.4.1",
+      "resolved": "https://registry.facebook.net/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz",
+      "integrity": "sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==",
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/global-dirs": {
+      "version": "3.0.1",
+      "resolved": "https://registry.facebook.net/global-dirs/-/global-dirs-3.0.1.tgz",
+      "integrity": "sha512-NBcGGFbBA9s1VzD41QXDG+3++t9Mn5t1FpLdhESY6oKY4gYTFpX4wO3sqGUa0Srjtbfj3szX0RnemmrVRUdULA==",
       "license": "MIT",
       "dependencies": {
-        "@types/hast": "^3.0.0"
+        "ini": "2.0.0"
+      },
+      "engines": {
+        "node": ">=10"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/hastscript": {
-      "version": "9.0.0",
-      "resolved": "https://registry.npmjs.org/hastscript/-/hastscript-9.0.0.tgz",
-      "integrity": "sha512-jzaLBGavEDKHrc5EfFImKN7nZKKBdSLIdGvCwDZ9TfzbF2ffXiov8CKE445L2Z1Ek2t/m4SKQ2j6Ipv7NyUolw==",
+    "node_modules/global-dirs/node_modules/ini": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/ini/-/ini-2.0.0.tgz",
+      "integrity": "sha512-7PnF4oN3CvZF23ADhA5wRaYEQpJ8qygSkbtTXWBeXWXmEVRXK+1ITciHWwHhsjv1TmW0MgacIv6hEi5pX5NQdA==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/globby": {
+      "version": "11.1.0",
+      "resolved": "https://registry.facebook.net/globby/-/globby-11.1.0.tgz",
+      "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==",
       "license": "MIT",
       "dependencies": {
-        "@types/hast": "^3.0.0",
-        "comma-separated-tokens": "^2.0.0",
-        "hast-util-parse-selector": "^4.0.0",
-        "property-information": "^6.0.0",
-        "space-separated-tokens": "^2.0.0"
+        "array-union": "^2.1.0",
+        "dir-glob": "^3.0.1",
+        "fast-glob": "^3.2.9",
+        "ignore": "^5.2.0",
+        "merge2": "^1.4.1",
+        "slash": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=10"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/he": {
+    "node_modules/gopd": {
       "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz",
-      "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==",
+      "resolved": "https://registry.facebook.net/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
       "license": "MIT",
-      "bin": {
-        "he": "bin/he"
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/history": {
-      "version": "4.10.1",
-      "resolved": "https://registry.npmjs.org/history/-/history-4.10.1.tgz",
-      "integrity": "sha512-36nwAD620w12kuzPAsyINPWJqlNbij+hpK1k9XRloDtym8mxzGYl2c17LnV6IAGB2Dmg4tEa7G7DlawS0+qjew==",
+    "node_modules/got": {
+      "version": "12.6.1",
+      "resolved": "https://registry.facebook.net/got/-/got-12.6.1.tgz",
+      "integrity": "sha512-mThBblvlAF1d4O5oqyvN+ZxLAYwIJK7bpMxgYqPD9okW0C3qm5FFn7k811QrcuEBwaogR3ngOFoCfs6mRv7teQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/runtime": "^7.1.2",
-        "loose-envify": "^1.2.0",
-        "resolve-pathname": "^3.0.0",
-        "tiny-invariant": "^1.0.2",
-        "tiny-warning": "^1.0.0",
-        "value-equal": "^1.0.1"
-      }
-    },
-    "node_modules/hoist-non-react-statics": {
-      "version": "3.3.2",
-      "resolved": "https://registry.npmjs.org/hoist-non-react-statics/-/hoist-non-react-statics-3.3.2.tgz",
-      "integrity": "sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==",
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "react-is": "^16.7.0"
+        "@sindresorhus/is": "^5.2.0",
+        "@szmarczak/http-timer": "^5.0.1",
+        "cacheable-lookup": "^7.0.0",
+        "cacheable-request": "^10.2.8",
+        "decompress-response": "^6.0.0",
+        "form-data-encoder": "^2.1.2",
+        "get-stream": "^6.0.1",
+        "http2-wrapper": "^2.1.10",
+        "lowercase-keys": "^3.0.0",
+        "p-cancelable": "^3.0.0",
+        "responselike": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=14.16"
+      },
+      "funding": {
+        "url": "https://github.com/sindresorhus/got?sponsor=1"
       }
     },
-    "node_modules/hpack.js": {
-      "version": "2.1.6",
-      "resolved": "https://registry.npmjs.org/hpack.js/-/hpack.js-2.1.6.tgz",
-      "integrity": "sha512-zJxVehUdMGIKsRaNt7apO2Gqp0BdqW5yaiGHXXmbpvxgBYVZnAql+BJb4RO5ad2MgpbZKn5G6nMnegrH1FcNYQ==",
+    "node_modules/got/node_modules/@sindresorhus/is": {
+      "version": "5.6.0",
+      "resolved": "https://registry.facebook.net/@sindresorhus/is/-/is-5.6.0.tgz",
+      "integrity": "sha512-TV7t8GKYaJWsn00tFDqBw8+Uqmr8A0fRU1tvTQhyZzGv0sJCGRQL3JGMI3ucuKo3XIZdUP+Lx7/gh2t3lewy7g==",
       "license": "MIT",
-      "dependencies": {
-        "inherits": "^2.0.1",
-        "obuf": "^1.0.0",
-        "readable-stream": "^2.0.1",
-        "wbuf": "^1.1.0"
+      "engines": {
+        "node": ">=14.16"
+      },
+      "funding": {
+        "url": "https://github.com/sindresorhus/is?sponsor=1"
       }
     },
-    "node_modules/hpack.js/node_modules/isarray": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
-      "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
-      "license": "MIT"
+    "node_modules/graceful-fs": {
+      "version": "4.2.11",
+      "resolved": "https://registry.facebook.net/graceful-fs/-/graceful-fs-4.2.11.tgz",
+      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+      "license": "ISC"
     },
-    "node_modules/hpack.js/node_modules/readable-stream": {
-      "version": "2.3.8",
-      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
-      "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
+    "node_modules/gray-matter": {
+      "version": "4.0.3",
+      "resolved": "https://registry.facebook.net/gray-matter/-/gray-matter-4.0.3.tgz",
+      "integrity": "sha512-5v6yZd4JK3eMI3FqqCouswVqwugaA9r4dNZB1wwcmrD02QkV5H0y7XBQW8QwQqEaZY1pM9aqORSORhJRdNK44Q==",
       "license": "MIT",
       "dependencies": {
-        "core-util-is": "~1.0.0",
-        "inherits": "~2.0.3",
-        "isarray": "~1.0.0",
-        "process-nextick-args": "~2.0.0",
-        "safe-buffer": "~5.1.1",
-        "string_decoder": "~1.1.1",
-        "util-deprecate": "~1.0.1"
+        "js-yaml": "^3.13.1",
+        "kind-of": "^6.0.2",
+        "section-matter": "^1.0.0",
+        "strip-bom-string": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=6.0"
       }
     },
-    "node_modules/hpack.js/node_modules/safe-buffer": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
-      "license": "MIT"
-    },
-    "node_modules/hpack.js/node_modules/string_decoder": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
-      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+    "node_modules/gray-matter/node_modules/argparse": {
+      "version": "1.0.10",
+      "resolved": "https://registry.facebook.net/argparse/-/argparse-1.0.10.tgz",
+      "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
       "license": "MIT",
       "dependencies": {
-        "safe-buffer": "~5.1.0"
+        "sprintf-js": "~1.0.2"
       }
     },
-    "node_modules/html-entities": {
-      "version": "2.5.2",
-      "resolved": "https://registry.npmjs.org/html-entities/-/html-entities-2.5.2.tgz",
-      "integrity": "sha512-K//PSRMQk4FZ78Kyau+mZurHn3FH0Vwr+H36eE0rPbeYkRRi9YxceYPhuN60UwWorxyKHhqoAJl2OFKa4BVtaA==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/mdevils"
-        },
-        {
-          "type": "patreon",
-          "url": "https://patreon.com/mdevils"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/html-escaper": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz",
-      "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==",
-      "license": "MIT"
-    },
-    "node_modules/html-minifier-terser": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/html-minifier-terser/-/html-minifier-terser-7.2.0.tgz",
-      "integrity": "sha512-tXgn3QfqPIpGl9o+K5tpcj3/MN4SfLtsx2GWwBC3SSd0tXQGyF3gsSqad8loJgKZGM3ZxbYDd5yhiBIdWpmvLA==",
+    "node_modules/gray-matter/node_modules/js-yaml": {
+      "version": "3.14.2",
+      "resolved": "https://registry.facebook.net/js-yaml/-/js-yaml-3.14.2.tgz",
+      "integrity": "sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==",
       "license": "MIT",
       "dependencies": {
-        "camel-case": "^4.1.2",
-        "clean-css": "~5.3.2",
-        "commander": "^10.0.0",
-        "entities": "^4.4.0",
-        "param-case": "^3.0.4",
-        "relateurl": "^0.2.7",
-        "terser": "^5.15.1"
+        "argparse": "^1.0.7",
+        "esprima": "^4.0.0"
       },
       "bin": {
-        "html-minifier-terser": "cli.js"
-      },
-      "engines": {
-        "node": "^14.13.1 || >=16.0.0"
+        "js-yaml": "bin/js-yaml.js"
       }
     },
-    "node_modules/html-minifier-terser/node_modules/commander": {
-      "version": "10.0.1",
-      "resolved": "https://registry.npmjs.org/commander/-/commander-10.0.1.tgz",
-      "integrity": "sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==",
+    "node_modules/gzip-size": {
+      "version": "6.0.0",
+      "resolved": "https://registry.facebook.net/gzip-size/-/gzip-size-6.0.0.tgz",
+      "integrity": "sha512-ax7ZYomf6jqPTQ4+XCpUGyXKHk5WweS+e05MBO4/y3WJ5RkmPXNKvX+bx1behVILVwr6JSQvZAku021CHPXG3Q==",
       "license": "MIT",
+      "dependencies": {
+        "duplexer": "^0.1.2"
+      },
       "engines": {
-        "node": ">=14"
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/html-tags": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/html-tags/-/html-tags-3.3.1.tgz",
-      "integrity": "sha512-ztqyC3kLto0e9WbNp0aeP+M3kTt+nbaIveGmUxAtZa+8iFgKLUOD4YKM5j+f3QD89bra7UeumolZHKuOXnTmeQ==",
+    "node_modules/handle-thing": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/handle-thing/-/handle-thing-2.0.1.tgz",
+      "integrity": "sha512-9Qn4yBxelxoh2Ow62nP+Ka/kMnOXRi8BXnRaUwezLNhqelnN49xKz4F/dPP8OYLxLxq6JDtZb2i9XznUQbNPTg==",
+      "license": "MIT"
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
       "license": "MIT",
       "engines": {
         "node": ">=8"
+      }
+    },
+    "node_modules/has-property-descriptors": {
+      "version": "1.0.2",
+      "resolved": "https://registry.facebook.net/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
+      "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
+      "license": "MIT",
+      "dependencies": {
+        "es-define-property": "^1.0.0"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/html-void-elements": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/html-void-elements/-/html-void-elements-3.0.0.tgz",
-      "integrity": "sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==",
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.facebook.net/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
       "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
       "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/wooorm"
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/html-webpack-plugin": {
-      "version": "5.6.3",
-      "resolved": "https://registry.npmjs.org/html-webpack-plugin/-/html-webpack-plugin-5.6.3.tgz",
-      "integrity": "sha512-QSf1yjtSAsmf7rYBV7XX86uua4W/vkhIt0xNXKbsi2foEeW7vjJQz4bhnpL3xH+l1ryl1680uNv968Z+X6jSYg==",
+    "node_modules/has-tostringtag": {
+      "version": "1.0.2",
+      "resolved": "https://registry.facebook.net/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
       "license": "MIT",
       "dependencies": {
-        "@types/html-minifier-terser": "^6.0.0",
-        "html-minifier-terser": "^6.0.2",
-        "lodash": "^4.17.21",
-        "pretty-error": "^4.0.0",
-        "tapable": "^2.0.0"
+        "has-symbols": "^1.0.3"
       },
       "engines": {
-        "node": ">=10.13.0"
+        "node": ">= 0.4"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/html-webpack-plugin"
-      },
-      "peerDependencies": {
-        "@rspack/core": "0.x || 1.x",
-        "webpack": "^5.20.0"
-      },
-      "peerDependenciesMeta": {
-        "@rspack/core": {
-          "optional": true
-        },
-        "webpack": {
-          "optional": true
-        }
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/html-webpack-plugin/node_modules/commander": {
-      "version": "8.3.0",
-      "resolved": "https://registry.npmjs.org/commander/-/commander-8.3.0.tgz",
-      "integrity": "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==",
+    "node_modules/has-yarn": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/has-yarn/-/has-yarn-3.0.0.tgz",
+      "integrity": "sha512-IrsVwUHhEULx3R8f/aA8AHuEzAorplsab/v8HBzEiIukwq5i/EC+xmOW+HfP1OaDP+2JkgT1yILHN2O3UFIbcA==",
       "license": "MIT",
       "engines": {
-        "node": ">= 12"
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/html-webpack-plugin/node_modules/html-minifier-terser": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/html-minifier-terser/-/html-minifier-terser-6.1.0.tgz",
-      "integrity": "sha512-YXxSlJBZTP7RS3tWnQw74ooKa6L9b9i9QYXY21eUEvhZ3u9XLfv6OnFsQq6RxkhHygsaUMvYsZRV5rU/OVNZxw==",
+    "node_modules/hasown": {
+      "version": "2.0.3",
+      "resolved": "https://registry.facebook.net/hasown/-/hasown-2.0.3.tgz",
+      "integrity": "sha512-ej4AhfhfL2Q2zpMmLo7U1Uv9+PyhIZpgQLGT1F9miIGmiCJIoCgSmczFdrc97mWT4kVY72KA+WnnhJ5pghSvSg==",
       "license": "MIT",
       "dependencies": {
-        "camel-case": "^4.1.2",
-        "clean-css": "^5.2.2",
-        "commander": "^8.3.0",
-        "he": "^1.2.0",
-        "param-case": "^3.0.4",
-        "relateurl": "^0.2.7",
-        "terser": "^5.10.0"
-      },
-      "bin": {
-        "html-minifier-terser": "cli.js"
+        "function-bind": "^1.1.2"
       },
       "engines": {
-        "node": ">=12"
+        "node": ">= 0.4"
       }
     },
-    "node_modules/htmlparser2": {
-      "version": "8.0.2",
-      "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-8.0.2.tgz",
-      "integrity": "sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA==",
-      "funding": [
-        "https://github.com/fb55/htmlparser2?sponsor=1",
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fb55"
-        }
-      ],
+    "node_modules/hast-util-from-parse5": {
+      "version": "8.0.3",
+      "resolved": "https://registry.facebook.net/hast-util-from-parse5/-/hast-util-from-parse5-8.0.3.tgz",
+      "integrity": "sha512-3kxEVkEKt0zvcZ3hCRYI8rqrgwtlIOFMWkbclACvjlDw8Li9S2hk/d51OI0nr/gIpdMHNepwgOKqZ/sy0Clpyg==",
       "license": "MIT",
       "dependencies": {
-        "domelementtype": "^2.3.0",
-        "domhandler": "^5.0.3",
-        "domutils": "^3.0.1",
-        "entities": "^4.4.0"
+        "@types/hast": "^3.0.0",
+        "@types/unist": "^3.0.0",
+        "devlop": "^1.0.0",
+        "hastscript": "^9.0.0",
+        "property-information": "^7.0.0",
+        "vfile": "^6.0.0",
+        "vfile-location": "^5.0.0",
+        "web-namespaces": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/http-cache-semantics": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.1.1.tgz",
-      "integrity": "sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ==",
-      "license": "BSD-2-Clause"
-    },
-    "node_modules/http-deceiver": {
-      "version": "1.2.7",
-      "resolved": "https://registry.npmjs.org/http-deceiver/-/http-deceiver-1.2.7.tgz",
-      "integrity": "sha512-LmpOGxTfbpgtGVxJrj5k7asXHCgNZp5nLfp+hWc8QQRqtb7fUy6kRY3BO1h9ddF6yIPYUARgxGOwB42DnxIaNw==",
-      "license": "MIT"
-    },
-    "node_modules/http-errors": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
-      "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
+    "node_modules/hast-util-parse-selector": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/hast-util-parse-selector/-/hast-util-parse-selector-4.0.0.tgz",
+      "integrity": "sha512-wkQCkSYoOGCRKERFWcxMVMOcYE2K1AaNLU8DXS9arxnLOUEWbOXKXiJUNzEpqZ3JOKpnha3jkFrumEjVliDe7A==",
       "license": "MIT",
       "dependencies": {
-        "depd": "2.0.0",
-        "inherits": "2.0.4",
-        "setprototypeof": "1.2.0",
-        "statuses": "2.0.1",
-        "toidentifier": "1.0.1"
+        "@types/hast": "^3.0.0"
       },
-      "engines": {
-        "node": ">= 0.8"
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/http-parser-js": {
-      "version": "0.5.8",
-      "resolved": "https://registry.npmjs.org/http-parser-js/-/http-parser-js-0.5.8.tgz",
-      "integrity": "sha512-SGeBX54F94Wgu5RH3X5jsDtf4eHyRogWX1XGT3b4HuW3tQPM4AaBzoUji/4AAJNXCEOWZ5O0DgZmJw1947gD5Q==",
-      "license": "MIT"
-    },
-    "node_modules/http-proxy": {
-      "version": "1.18.1",
-      "resolved": "https://registry.npmjs.org/http-proxy/-/http-proxy-1.18.1.tgz",
-      "integrity": "sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==",
+    "node_modules/hast-util-raw": {
+      "version": "9.1.0",
+      "resolved": "https://registry.facebook.net/hast-util-raw/-/hast-util-raw-9.1.0.tgz",
+      "integrity": "sha512-Y8/SBAHkZGoNkpzqqfCldijcuUKh7/su31kEBp67cFY09Wy0mTRgtsLYsiIxMJxlu0f6AA5SUTbDR8K0rxnbUw==",
       "license": "MIT",
       "dependencies": {
-        "eventemitter3": "^4.0.0",
-        "follow-redirects": "^1.0.0",
-        "requires-port": "^1.0.0"
+        "@types/hast": "^3.0.0",
+        "@types/unist": "^3.0.0",
+        "@ungap/structured-clone": "^1.0.0",
+        "hast-util-from-parse5": "^8.0.0",
+        "hast-util-to-parse5": "^8.0.0",
+        "html-void-elements": "^3.0.0",
+        "mdast-util-to-hast": "^13.0.0",
+        "parse5": "^7.0.0",
+        "unist-util-position": "^5.0.0",
+        "unist-util-visit": "^5.0.0",
+        "vfile": "^6.0.0",
+        "web-namespaces": "^2.0.0",
+        "zwitch": "^2.0.0"
       },
-      "engines": {
-        "node": ">=8.0.0"
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/http-proxy-middleware": {
-      "version": "2.0.9",
-      "resolved": "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-2.0.9.tgz",
-      "integrity": "sha512-c1IyJYLYppU574+YI7R4QyX2ystMtVXZwIdzazUIPIJsHuWNd+mho2j+bKoHftndicGj9yh+xjd+l0yj7VeT1Q==",
+    "node_modules/hast-util-to-estree": {
+      "version": "3.1.3",
+      "resolved": "https://registry.facebook.net/hast-util-to-estree/-/hast-util-to-estree-3.1.3.tgz",
+      "integrity": "sha512-48+B/rJWAp0jamNbAAf9M7Uf//UVqAoMmgXhBdxTDJLGKY+LRnZ99qcG+Qjl5HfMpYNzS5v4EAwVEF34LeAj7w==",
       "license": "MIT",
       "dependencies": {
-        "@types/http-proxy": "^1.17.8",
-        "http-proxy": "^1.18.1",
-        "is-glob": "^4.0.1",
-        "is-plain-obj": "^3.0.0",
-        "micromatch": "^4.0.2"
-      },
-      "engines": {
-        "node": ">=12.0.0"
-      },
-      "peerDependencies": {
-        "@types/express": "^4.17.13"
-      },
-      "peerDependenciesMeta": {
-        "@types/express": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/http-proxy-middleware/node_modules/is-plain-obj": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-3.0.0.tgz",
-      "integrity": "sha512-gwsOE28k+23GP1B6vFl1oVh/WOzmawBrKwo5Ev6wMKzPkaXaCDIQKzLnvsA42DRlbVTWorkgTKIviAKCWkfUwA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
+        "@types/estree": "^1.0.0",
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "comma-separated-tokens": "^2.0.0",
+        "devlop": "^1.0.0",
+        "estree-util-attach-comments": "^3.0.0",
+        "estree-util-is-identifier-name": "^3.0.0",
+        "hast-util-whitespace": "^3.0.0",
+        "mdast-util-mdx-expression": "^2.0.0",
+        "mdast-util-mdx-jsx": "^3.0.0",
+        "mdast-util-mdxjs-esm": "^2.0.0",
+        "property-information": "^7.0.0",
+        "space-separated-tokens": "^2.0.0",
+        "style-to-js": "^1.0.0",
+        "unist-util-position": "^5.0.0",
+        "zwitch": "^2.0.0"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/http2-wrapper": {
-      "version": "2.2.1",
-      "resolved": "https://registry.npmjs.org/http2-wrapper/-/http2-wrapper-2.2.1.tgz",
-      "integrity": "sha512-V5nVw1PAOgfI3Lmeaj2Exmeg7fenjhRUgz1lPSezy1CuhPYbgQtbQj4jZfEAEMlaL+vupsvhjqCyjzob0yxsmQ==",
+    "node_modules/hast-util-to-jsx-runtime": {
+      "version": "2.3.6",
+      "resolved": "https://registry.facebook.net/hast-util-to-jsx-runtime/-/hast-util-to-jsx-runtime-2.3.6.tgz",
+      "integrity": "sha512-zl6s8LwNyo1P9uw+XJGvZtdFF1GdAkOg8ujOw+4Pyb76874fLps4ueHXDhXWdk6YHQ6OgUtinliG7RsYvCbbBg==",
       "license": "MIT",
       "dependencies": {
-        "quick-lru": "^5.1.1",
-        "resolve-alpn": "^1.2.0"
+        "@types/estree": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/unist": "^3.0.0",
+        "comma-separated-tokens": "^2.0.0",
+        "devlop": "^1.0.0",
+        "estree-util-is-identifier-name": "^3.0.0",
+        "hast-util-whitespace": "^3.0.0",
+        "mdast-util-mdx-expression": "^2.0.0",
+        "mdast-util-mdx-jsx": "^3.0.0",
+        "mdast-util-mdxjs-esm": "^2.0.0",
+        "property-information": "^7.0.0",
+        "space-separated-tokens": "^2.0.0",
+        "style-to-js": "^1.0.0",
+        "unist-util-position": "^5.0.0",
+        "vfile-message": "^4.0.0"
       },
-      "engines": {
-        "node": ">=10.19.0"
-      }
-    },
-    "node_modules/human-signals": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz",
-      "integrity": "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==",
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=10.17.0"
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/iconv-lite": {
-      "version": "0.4.24",
-      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
-      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+    "node_modules/hast-util-to-parse5": {
+      "version": "8.0.1",
+      "resolved": "https://registry.facebook.net/hast-util-to-parse5/-/hast-util-to-parse5-8.0.1.tgz",
+      "integrity": "sha512-MlWT6Pjt4CG9lFCjiz4BH7l9wmrMkfkJYCxFwKQic8+RTZgWPuWxwAfjJElsXkex7DJjfSJsQIt931ilUgmwdA==",
       "license": "MIT",
       "dependencies": {
-        "safer-buffer": ">= 2.1.2 < 3"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/icss-utils": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/icss-utils/-/icss-utils-5.1.0.tgz",
-      "integrity": "sha512-soFhflCVWLfRNOPU3iv5Z9VUdT44xFRbzjLsEzSr5AQmgqPMTHdU3PMT1Cf1ssx8fLNJDA1juftYl+PUcv3MqA==",
-      "license": "ISC",
-      "engines": {
-        "node": "^10 || ^12 || >= 14"
+        "@types/hast": "^3.0.0",
+        "comma-separated-tokens": "^2.0.0",
+        "devlop": "^1.0.0",
+        "property-information": "^7.0.0",
+        "space-separated-tokens": "^2.0.0",
+        "web-namespaces": "^2.0.0",
+        "zwitch": "^2.0.0"
       },
-      "peerDependencies": {
-        "postcss": "^8.1.0"
-      }
-    },
-    "node_modules/ignore": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
-      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 4"
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/image-size": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/image-size/-/image-size-1.2.0.tgz",
-      "integrity": "sha512-4S8fwbO6w3GeCVN6OPtA9I5IGKkcDMPcKndtUlpJuCwu7JLjtj7JZpwqLuyY2nrmQT3AWsCJLSKPsc2mPBSl3w==",
+    "node_modules/hast-util-whitespace": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz",
+      "integrity": "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==",
       "license": "MIT",
       "dependencies": {
-        "queue": "6.0.2"
-      },
-      "bin": {
-        "image-size": "bin/image-size.js"
+        "@types/hast": "^3.0.0"
       },
-      "engines": {
-        "node": ">=16.x"
-      }
-    },
-    "node_modules/immer": {
-      "version": "9.0.21",
-      "resolved": "https://registry.npmjs.org/immer/-/immer-9.0.21.tgz",
-      "integrity": "sha512-bc4NBHqOqSfRW7POMkHd51LvClaeMXpm8dx0e8oE2GORbq5aRK7Bxl4FyzVLdGtLmvLKL7BTDBG5ACQm4HWjTA==",
-      "license": "MIT",
       "funding": {
         "type": "opencollective",
-        "url": "https://opencollective.com/immer"
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/import-fresh": {
-      "version": "3.3.0",
-      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz",
-      "integrity": "sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==",
+    "node_modules/hastscript": {
+      "version": "9.0.1",
+      "resolved": "https://registry.facebook.net/hastscript/-/hastscript-9.0.1.tgz",
+      "integrity": "sha512-g7df9rMFX/SPi34tyGCyUBREQoKkapwdY/T04Qn9TDWfHhAYt4/I0gMVirzK5wEzeUqIjEB+LXC/ypb7Aqno5w==",
       "license": "MIT",
       "dependencies": {
-        "parent-module": "^1.0.0",
-        "resolve-from": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=6"
+        "@types/hast": "^3.0.0",
+        "comma-separated-tokens": "^2.0.0",
+        "hast-util-parse-selector": "^4.0.0",
+        "property-information": "^7.0.0",
+        "space-separated-tokens": "^2.0.0"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/import-lazy": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/import-lazy/-/import-lazy-4.0.0.tgz",
-      "integrity": "sha512-rKtvo6a868b5Hu3heneU+L4yEQ4jYKLtjpnPeUdK7h0yzXGmyBTypknlkCvHFBqfX9YlorEiMM6Dnq/5atfHkw==",
+    "node_modules/he": {
+      "version": "1.2.0",
+      "resolved": "https://registry.facebook.net/he/-/he-1.2.0.tgz",
+      "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==",
       "license": "MIT",
-      "engines": {
-        "node": ">=8"
+      "bin": {
+        "he": "bin/he"
       }
     },
-    "node_modules/imurmurhash": {
-      "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
-      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
+    "node_modules/history": {
+      "version": "4.10.1",
+      "resolved": "https://registry.facebook.net/history/-/history-4.10.1.tgz",
+      "integrity": "sha512-36nwAD620w12kuzPAsyINPWJqlNbij+hpK1k9XRloDtym8mxzGYl2c17LnV6IAGB2Dmg4tEa7G7DlawS0+qjew==",
       "license": "MIT",
-      "engines": {
-        "node": ">=0.8.19"
+      "dependencies": {
+        "@babel/runtime": "^7.1.2",
+        "loose-envify": "^1.2.0",
+        "resolve-pathname": "^3.0.0",
+        "tiny-invariant": "^1.0.2",
+        "tiny-warning": "^1.0.0",
+        "value-equal": "^1.0.1"
       }
     },
-    "node_modules/indent-string": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz",
-      "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
+    "node_modules/hoist-non-react-statics": {
+      "version": "3.3.2",
+      "resolved": "https://registry.facebook.net/hoist-non-react-statics/-/hoist-non-react-statics-3.3.2.tgz",
+      "integrity": "sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "react-is": "^16.7.0"
       }
     },
-    "node_modules/infima": {
-      "version": "0.2.0-alpha.45",
-      "resolved": "https://registry.npmjs.org/infima/-/infima-0.2.0-alpha.45.tgz",
-      "integrity": "sha512-uyH0zfr1erU1OohLk0fT4Rrb94AOhguWNOcD9uGrSpRvNB+6gZXUoJX5J0NtvzBO10YZ9PgvA4NFgt+fYg8ojw==",
+    "node_modules/hpack.js": {
+      "version": "2.1.6",
+      "resolved": "https://registry.facebook.net/hpack.js/-/hpack.js-2.1.6.tgz",
+      "integrity": "sha512-zJxVehUdMGIKsRaNt7apO2Gqp0BdqW5yaiGHXXmbpvxgBYVZnAql+BJb4RO5ad2MgpbZKn5G6nMnegrH1FcNYQ==",
       "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/inflight": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
-      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
-      "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
-      "license": "ISC",
       "dependencies": {
-        "once": "^1.3.0",
-        "wrappy": "1"
+        "inherits": "^2.0.1",
+        "obuf": "^1.0.0",
+        "readable-stream": "^2.0.1",
+        "wbuf": "^1.1.0"
       }
     },
-    "node_modules/inherits": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
-      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
-      "license": "ISC"
-    },
-    "node_modules/ini": {
-      "version": "1.3.8",
-      "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz",
-      "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==",
-      "license": "ISC"
-    },
-    "node_modules/inline-style-parser": {
-      "version": "0.2.4",
-      "resolved": "https://registry.npmjs.org/inline-style-parser/-/inline-style-parser-0.2.4.tgz",
-      "integrity": "sha512-0aO8FkhNZlj/ZIbNi7Lxxr12obT7cL1moPfE4tg1LkX7LlLfC6DeX4l2ZEud1ukP9jNQyNnfzQVqwbwmAATY4Q==",
+    "node_modules/hpack.js/node_modules/isarray": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/isarray/-/isarray-1.0.0.tgz",
+      "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
       "license": "MIT"
     },
-    "node_modules/interpret": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/interpret/-/interpret-1.4.0.tgz",
-      "integrity": "sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.10"
-      }
-    },
-    "node_modules/invariant": {
-      "version": "2.2.4",
-      "resolved": "https://registry.npmjs.org/invariant/-/invariant-2.2.4.tgz",
-      "integrity": "sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==",
+    "node_modules/hpack.js/node_modules/readable-stream": {
+      "version": "2.3.8",
+      "resolved": "https://registry.facebook.net/readable-stream/-/readable-stream-2.3.8.tgz",
+      "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
       "license": "MIT",
       "dependencies": {
-        "loose-envify": "^1.0.0"
-      }
-    },
-    "node_modules/ipaddr.js": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-2.2.0.tgz",
-      "integrity": "sha512-Ag3wB2o37wslZS19hZqorUnrnzSkpOVy+IiiDEiTqNubEYpYuHWIf6K4psgN2ZWKExS4xhVCrRVfb/wfW8fWJA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 10"
+        "core-util-is": "~1.0.0",
+        "inherits": "~2.0.3",
+        "isarray": "~1.0.0",
+        "process-nextick-args": "~2.0.0",
+        "safe-buffer": "~5.1.1",
+        "string_decoder": "~1.1.1",
+        "util-deprecate": "~1.0.1"
       }
     },
-    "node_modules/is-alphabetical": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/is-alphabetical/-/is-alphabetical-2.0.1.tgz",
-      "integrity": "sha512-FWyyY60MeTNyeSRpkM2Iry0G9hpr7/9kD40mD/cGQEuilcZYS4okz8SN2Q6rLCJ8gbCt6fN+rC+6tMGS99LaxQ==",
-      "license": "MIT",
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/wooorm"
-      }
+    "node_modules/hpack.js/node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.facebook.net/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "license": "MIT"
     },
-    "node_modules/is-alphanumerical": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/is-alphanumerical/-/is-alphanumerical-2.0.1.tgz",
-      "integrity": "sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw==",
+    "node_modules/hpack.js/node_modules/string_decoder": {
+      "version": "1.1.1",
+      "resolved": "https://registry.facebook.net/string_decoder/-/string_decoder-1.1.1.tgz",
+      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
       "license": "MIT",
       "dependencies": {
-        "is-alphabetical": "^2.0.0",
-        "is-decimal": "^2.0.0"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/wooorm"
+        "safe-buffer": "~5.1.0"
       }
     },
-    "node_modules/is-arrayish": {
-      "version": "0.2.1",
-      "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz",
-      "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==",
+    "node_modules/html-escaper": {
+      "version": "2.0.2",
+      "resolved": "https://registry.facebook.net/html-escaper/-/html-escaper-2.0.2.tgz",
+      "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==",
       "license": "MIT"
     },
-    "node_modules/is-binary-path": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
-      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+    "node_modules/html-minifier-terser": {
+      "version": "6.1.0",
+      "resolved": "https://registry.facebook.net/html-minifier-terser/-/html-minifier-terser-6.1.0.tgz",
+      "integrity": "sha512-YXxSlJBZTP7RS3tWnQw74ooKa6L9b9i9QYXY21eUEvhZ3u9XLfv6OnFsQq6RxkhHygsaUMvYsZRV5rU/OVNZxw==",
       "license": "MIT",
       "dependencies": {
-        "binary-extensions": "^2.0.0"
+        "camel-case": "^4.1.2",
+        "clean-css": "^5.2.2",
+        "commander": "^8.3.0",
+        "he": "^1.2.0",
+        "param-case": "^3.0.4",
+        "relateurl": "^0.2.7",
+        "terser": "^5.10.0"
+      },
+      "bin": {
+        "html-minifier-terser": "cli.js"
       },
       "engines": {
-        "node": ">=8"
+        "node": ">=12"
       }
     },
-    "node_modules/is-ci": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/is-ci/-/is-ci-3.0.1.tgz",
-      "integrity": "sha512-ZYvCgrefwqoQ6yTyYUbQu64HsITZ3NfKX1lzaEYdkTDcfKzzCI/wthRRYKkdjHKFVgNiXKAKm65Zo1pk2as/QQ==",
+    "node_modules/html-minifier-terser/node_modules/commander": {
+      "version": "8.3.0",
+      "resolved": "https://registry.facebook.net/commander/-/commander-8.3.0.tgz",
+      "integrity": "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==",
       "license": "MIT",
-      "dependencies": {
-        "ci-info": "^3.2.0"
-      },
-      "bin": {
-        "is-ci": "bin.js"
+      "engines": {
+        "node": ">= 12"
       }
     },
-    "node_modules/is-core-module": {
-      "version": "2.16.1",
-      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz",
-      "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==",
+    "node_modules/html-tags": {
+      "version": "3.3.1",
+      "resolved": "https://registry.facebook.net/html-tags/-/html-tags-3.3.1.tgz",
+      "integrity": "sha512-ztqyC3kLto0e9WbNp0aeP+M3kTt+nbaIveGmUxAtZa+8iFgKLUOD4YKM5j+f3QD89bra7UeumolZHKuOXnTmeQ==",
       "license": "MIT",
-      "dependencies": {
-        "hasown": "^2.0.2"
-      },
       "engines": {
-        "node": ">= 0.4"
+        "node": ">=8"
       },
       "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/is-decimal": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/is-decimal/-/is-decimal-2.0.1.tgz",
-      "integrity": "sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A==",
+    "node_modules/html-void-elements": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/html-void-elements/-/html-void-elements-3.0.0.tgz",
+      "integrity": "sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==",
       "license": "MIT",
       "funding": {
         "type": "github",
         "url": "https://github.com/sponsors/wooorm"
       }
     },
-    "node_modules/is-docker": {
-      "version": "2.2.1",
-      "resolved": "https://registry.npmjs.org/is-docker/-/is-docker-2.2.1.tgz",
-      "integrity": "sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==",
+    "node_modules/html-webpack-plugin": {
+      "version": "5.6.7",
+      "resolved": "https://registry.facebook.net/html-webpack-plugin/-/html-webpack-plugin-5.6.7.tgz",
+      "integrity": "sha512-md+vXtdCAe60s1k6AU3dUyMJnDxUyQAwfwPKoLisvgUF1IXjtlLsk2se54+qfL9Mdm26bbwvjJybpNx48NKRLw==",
       "license": "MIT",
-      "bin": {
-        "is-docker": "cli.js"
+      "dependencies": {
+        "@types/html-minifier-terser": "^6.0.0",
+        "html-minifier-terser": "^6.0.2",
+        "lodash": "^4.17.21",
+        "pretty-error": "^4.0.0",
+        "tapable": "^2.0.0"
       },
       "engines": {
-        "node": ">=8"
+        "node": ">=10.13.0"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "type": "opencollective",
+        "url": "https://opencollective.com/html-webpack-plugin"
+      },
+      "peerDependencies": {
+        "@rspack/core": "0.x || 1.x",
+        "webpack": "^5.20.0"
+      },
+      "peerDependenciesMeta": {
+        "@rspack/core": {
+          "optional": true
+        },
+        "webpack": {
+          "optional": true
+        }
       }
     },
-    "node_modules/is-extendable": {
-      "version": "0.1.1",
-      "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz",
-      "integrity": "sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==",
+    "node_modules/htmlparser2": {
+      "version": "8.0.2",
+      "resolved": "https://registry.facebook.net/htmlparser2/-/htmlparser2-8.0.2.tgz",
+      "integrity": "sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA==",
+      "funding": [
+        "https://github.com/fb55/htmlparser2?sponsor=1",
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fb55"
+        }
+      ],
       "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
+      "dependencies": {
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.3",
+        "domutils": "^3.0.1",
+        "entities": "^4.4.0"
       }
     },
-    "node_modules/is-extglob": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
-      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
+    "node_modules/http-cache-semantics": {
+      "version": "4.2.0",
+      "resolved": "https://registry.facebook.net/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz",
+      "integrity": "sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==",
+      "license": "BSD-2-Clause"
     },
-    "node_modules/is-fullwidth-code-point": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
-      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
+    "node_modules/http-deceiver": {
+      "version": "1.2.7",
+      "resolved": "https://registry.facebook.net/http-deceiver/-/http-deceiver-1.2.7.tgz",
+      "integrity": "sha512-LmpOGxTfbpgtGVxJrj5k7asXHCgNZp5nLfp+hWc8QQRqtb7fUy6kRY3BO1h9ddF6yIPYUARgxGOwB42DnxIaNw==",
+      "license": "MIT"
     },
-    "node_modules/is-glob": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
-      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+    "node_modules/http-errors": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/http-errors/-/http-errors-2.0.1.tgz",
+      "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==",
       "license": "MIT",
       "dependencies": {
-        "is-extglob": "^2.1.1"
+        "depd": "~2.0.0",
+        "inherits": "~2.0.4",
+        "setprototypeof": "~1.2.0",
+        "statuses": "~2.0.2",
+        "toidentifier": "~1.0.1"
       },
       "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-hexadecimal": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/is-hexadecimal/-/is-hexadecimal-2.0.1.tgz",
-      "integrity": "sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg==",
-      "license": "MIT",
+        "node": ">= 0.8"
+      },
       "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/wooorm"
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
       }
     },
-    "node_modules/is-installed-globally": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/is-installed-globally/-/is-installed-globally-0.4.0.tgz",
-      "integrity": "sha512-iwGqO3J21aaSkC7jWnHP/difazwS7SFeIqxv6wEtLU8Y5KlzFTjyqcSIT0d8s4+dDhKytsk9PJZ2BkS5eZwQRQ==",
+    "node_modules/http-parser-js": {
+      "version": "0.5.10",
+      "resolved": "https://registry.facebook.net/http-parser-js/-/http-parser-js-0.5.10.tgz",
+      "integrity": "sha512-Pysuw9XpUq5dVc/2SMHpuTY01RFl8fttgcyunjL7eEMhGM3cI4eOmiCycJDVCo/7O7ClfQD3SaI6ftDzqOXYMA==",
+      "license": "MIT"
+    },
+    "node_modules/http-proxy": {
+      "version": "1.18.1",
+      "resolved": "https://registry.facebook.net/http-proxy/-/http-proxy-1.18.1.tgz",
+      "integrity": "sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==",
       "license": "MIT",
       "dependencies": {
-        "global-dirs": "^3.0.0",
-        "is-path-inside": "^3.0.2"
+        "eventemitter3": "^4.0.0",
+        "follow-redirects": "^1.0.0",
+        "requires-port": "^1.0.0"
       },
       "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "node": ">=8.0.0"
       }
     },
-    "node_modules/is-npm": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/is-npm/-/is-npm-6.0.0.tgz",
-      "integrity": "sha512-JEjxbSmtPSt1c8XTkVrlujcXdKV1/tvuQ7GwKcAlyiVLeYFQ2VHat8xfrDJsIkhCdF/tZ7CiIR3sy141c6+gPQ==",
+    "node_modules/http-proxy-middleware": {
+      "version": "2.0.9",
+      "resolved": "https://registry.facebook.net/http-proxy-middleware/-/http-proxy-middleware-2.0.9.tgz",
+      "integrity": "sha512-c1IyJYLYppU574+YI7R4QyX2ystMtVXZwIdzazUIPIJsHuWNd+mho2j+bKoHftndicGj9yh+xjd+l0yj7VeT1Q==",
       "license": "MIT",
+      "dependencies": {
+        "@types/http-proxy": "^1.17.8",
+        "http-proxy": "^1.18.1",
+        "is-glob": "^4.0.1",
+        "is-plain-obj": "^3.0.0",
+        "micromatch": "^4.0.2"
+      },
       "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+        "node": ">=12.0.0"
       },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+      "peerDependencies": {
+        "@types/express": "^4.17.13"
+      },
+      "peerDependenciesMeta": {
+        "@types/express": {
+          "optional": true
+        }
       }
     },
-    "node_modules/is-number": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
-      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+    "node_modules/http2-wrapper": {
+      "version": "2.2.1",
+      "resolved": "https://registry.facebook.net/http2-wrapper/-/http2-wrapper-2.2.1.tgz",
+      "integrity": "sha512-V5nVw1PAOgfI3Lmeaj2Exmeg7fenjhRUgz1lPSezy1CuhPYbgQtbQj4jZfEAEMlaL+vupsvhjqCyjzob0yxsmQ==",
       "license": "MIT",
+      "dependencies": {
+        "quick-lru": "^5.1.1",
+        "resolve-alpn": "^1.2.0"
+      },
       "engines": {
-        "node": ">=0.12.0"
+        "node": ">=10.19.0"
       }
     },
-    "node_modules/is-obj": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-1.0.1.tgz",
-      "integrity": "sha512-l4RyHgRqGN4Y3+9JHVrNqO+tN0rV5My76uW5/nuO4K1b6vw5G8d/cmFjP9tRfEsdhZNt0IFdZuK/c2Vr4Nb+Qg==",
-      "license": "MIT",
+    "node_modules/human-signals": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/human-signals/-/human-signals-2.1.0.tgz",
+      "integrity": "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==",
+      "license": "Apache-2.0",
       "engines": {
-        "node": ">=0.10.0"
+        "node": ">=10.17.0"
       }
     },
-    "node_modules/is-path-cwd": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/is-path-cwd/-/is-path-cwd-2.2.0.tgz",
-      "integrity": "sha512-w942bTcih8fdJPJmQHFzkS76NEP8Kzzvmw92cXsazb8intwLqPibPPdXf4ANdKV3rYMuuQYGIWtvz9JilB3NFQ==",
+    "node_modules/hyperdyperid": {
+      "version": "1.2.0",
+      "resolved": "https://registry.facebook.net/hyperdyperid/-/hyperdyperid-1.2.0.tgz",
+      "integrity": "sha512-Y93lCzHYgGWdrJ66yIktxiaGULYc6oGiABxhcO5AufBeOyoIdZF7bIfLaOrbM0iGIOXQQgxxRrFEnb+Y6w1n4A==",
       "license": "MIT",
       "engines": {
-        "node": ">=6"
+        "node": ">=10.18"
       }
     },
-    "node_modules/is-path-inside": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz",
-      "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==",
+    "node_modules/iconv-lite": {
+      "version": "0.4.24",
+      "resolved": "https://registry.facebook.net/iconv-lite/-/iconv-lite-0.4.24.tgz",
+      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
       "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3"
+      },
       "engines": {
-        "node": ">=8"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/is-plain-obj": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.1.0.tgz",
-      "integrity": "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==",
-      "license": "MIT",
+    "node_modules/icss-utils": {
+      "version": "5.1.0",
+      "resolved": "https://registry.facebook.net/icss-utils/-/icss-utils-5.1.0.tgz",
+      "integrity": "sha512-soFhflCVWLfRNOPU3iv5Z9VUdT44xFRbzjLsEzSr5AQmgqPMTHdU3PMT1Cf1ssx8fLNJDA1juftYl+PUcv3MqA==",
+      "license": "ISC",
       "engines": {
-        "node": ">=12"
+        "node": "^10 || ^12 || >= 14"
       },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+      "peerDependencies": {
+        "postcss": "^8.1.0"
       }
     },
-    "node_modules/is-plain-object": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz",
-      "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==",
+    "node_modules/ignore": {
+      "version": "5.3.2",
+      "resolved": "https://registry.facebook.net/ignore/-/ignore-5.3.2.tgz",
+      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
       "license": "MIT",
-      "dependencies": {
-        "isobject": "^3.0.1"
-      },
       "engines": {
-        "node": ">=0.10.0"
+        "node": ">= 4"
       }
     },
-    "node_modules/is-regexp": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/is-regexp/-/is-regexp-1.0.0.tgz",
-      "integrity": "sha512-7zjFAPO4/gwyQAAgRRmqeEeyIICSdmCqa3tsVHMdBzaXXRiqopZL4Cyghg/XulGWrtABTpbnYYzzIRffLkP4oA==",
+    "node_modules/image-size": {
+      "version": "2.0.2",
+      "resolved": "https://registry.facebook.net/image-size/-/image-size-2.0.2.tgz",
+      "integrity": "sha512-IRqXKlaXwgSMAMtpNzZa1ZAe8m+Sa1770Dhk8VkSsP9LS+iHD62Zd8FQKs8fbPiagBE7BzoFX23cxFnwshpV6w==",
       "license": "MIT",
+      "bin": {
+        "image-size": "bin/image-size.js"
+      },
       "engines": {
-        "node": ">=0.10.0"
+        "node": ">=16.x"
       }
     },
-    "node_modules/is-root": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/is-root/-/is-root-2.1.0.tgz",
-      "integrity": "sha512-AGOriNp96vNBd3HtU+RzFEc75FfR5ymiYv8E553I71SCeXBiMsVDUtdio1OEFvrPyLIQ9tVR5RxXIFe5PUFjMg==",
+    "node_modules/import-fresh": {
+      "version": "3.3.1",
+      "resolved": "https://registry.facebook.net/import-fresh/-/import-fresh-3.3.1.tgz",
+      "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
       "license": "MIT",
+      "dependencies": {
+        "parent-module": "^1.0.0",
+        "resolve-from": "^4.0.0"
+      },
       "engines": {
         "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/is-stream": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz",
-      "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==",
+    "node_modules/import-lazy": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/import-lazy/-/import-lazy-4.0.0.tgz",
+      "integrity": "sha512-rKtvo6a868b5Hu3heneU+L4yEQ4jYKLtjpnPeUdK7h0yzXGmyBTypknlkCvHFBqfX9YlorEiMM6Dnq/5atfHkw==",
       "license": "MIT",
       "engines": {
         "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/is-typedarray": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz",
-      "integrity": "sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==",
-      "license": "MIT"
+    "node_modules/imurmurhash": {
+      "version": "0.1.4",
+      "resolved": "https://registry.facebook.net/imurmurhash/-/imurmurhash-0.1.4.tgz",
+      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8.19"
+      }
     },
-    "node_modules/is-wsl": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-2.2.0.tgz",
-      "integrity": "sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==",
+    "node_modules/indent-string": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/indent-string/-/indent-string-4.0.0.tgz",
+      "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==",
       "license": "MIT",
-      "dependencies": {
-        "is-docker": "^2.0.0"
-      },
       "engines": {
         "node": ">=8"
       }
     },
-    "node_modules/is-yarn-global": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/is-yarn-global/-/is-yarn-global-0.4.1.tgz",
-      "integrity": "sha512-/kppl+R+LO5VmhYSEWARUFjodS25D68gvj8W7z0I7OWhUla5xWu8KL6CtB2V0R6yqhnRgbcaREMr4EEM6htLPQ==",
+    "node_modules/infima": {
+      "version": "0.2.0-alpha.45",
+      "resolved": "https://registry.facebook.net/infima/-/infima-0.2.0-alpha.45.tgz",
+      "integrity": "sha512-uyH0zfr1erU1OohLk0fT4Rrb94AOhguWNOcD9uGrSpRvNB+6gZXUoJX5J0NtvzBO10YZ9PgvA4NFgt+fYg8ojw==",
       "license": "MIT",
       "engines": {
         "node": ">=12"
       }
     },
-    "node_modules/isarray": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz",
-      "integrity": "sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==",
-      "license": "MIT"
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.facebook.net/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC"
     },
-    "node_modules/isexe": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
-      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+    "node_modules/ini": {
+      "version": "1.3.8",
+      "resolved": "https://registry.facebook.net/ini/-/ini-1.3.8.tgz",
+      "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==",
       "license": "ISC"
     },
-    "node_modules/isobject": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz",
-      "integrity": "sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
+    "node_modules/inline-style-parser": {
+      "version": "0.2.7",
+      "resolved": "https://registry.facebook.net/inline-style-parser/-/inline-style-parser-0.2.7.tgz",
+      "integrity": "sha512-Nb2ctOyNR8DqQoR0OwRG95uNWIC0C1lCgf5Naz5H6Ji72KZ8OcFZLz2P5sNgwlyoJ8Yif11oMuYs5pBQa86csA==",
+      "license": "MIT"
     },
-    "node_modules/jest-util": {
-      "version": "29.7.0",
-      "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-29.7.0.tgz",
-      "integrity": "sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA==",
+    "node_modules/invariant": {
+      "version": "2.2.4",
+      "resolved": "https://registry.facebook.net/invariant/-/invariant-2.2.4.tgz",
+      "integrity": "sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==",
       "license": "MIT",
       "dependencies": {
-        "@jest/types": "^29.6.3",
-        "@types/node": "*",
-        "chalk": "^4.0.0",
-        "ci-info": "^3.2.0",
-        "graceful-fs": "^4.2.9",
-        "picomatch": "^2.2.3"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+        "loose-envify": "^1.0.0"
       }
     },
-    "node_modules/jest-worker": {
-      "version": "29.7.0",
-      "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-29.7.0.tgz",
-      "integrity": "sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw==",
+    "node_modules/ipaddr.js": {
+      "version": "2.3.0",
+      "resolved": "https://registry.facebook.net/ipaddr.js/-/ipaddr.js-2.3.0.tgz",
+      "integrity": "sha512-Zv/pA+ciVFbCSBBjGfaKUya/CcGmUHzTydLMaTwrUUEM2DIEO3iZvueGxmacvmN50fGpGVKeTXpb2LcYQxeVdg==",
       "license": "MIT",
-      "dependencies": {
-        "@types/node": "*",
-        "jest-util": "^29.7.0",
-        "merge-stream": "^2.0.0",
-        "supports-color": "^8.0.0"
-      },
       "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+        "node": ">= 10"
       }
     },
-    "node_modules/jest-worker/node_modules/supports-color": {
-      "version": "8.1.1",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz",
-      "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==",
+    "node_modules/is-alphabetical": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/is-alphabetical/-/is-alphabetical-2.0.1.tgz",
+      "integrity": "sha512-FWyyY60MeTNyeSRpkM2Iry0G9hpr7/9kD40mD/cGQEuilcZYS4okz8SN2Q6rLCJ8gbCt6fN+rC+6tMGS99LaxQ==",
       "license": "MIT",
-      "dependencies": {
-        "has-flag": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
       "funding": {
-        "url": "https://github.com/chalk/supports-color?sponsor=1"
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
       }
     },
-    "node_modules/jiti": {
-      "version": "1.21.7",
-      "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz",
-      "integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==",
+    "node_modules/is-alphanumerical": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/is-alphanumerical/-/is-alphanumerical-2.0.1.tgz",
+      "integrity": "sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw==",
       "license": "MIT",
-      "bin": {
-        "jiti": "bin/jiti.js"
-      }
-    },
-    "node_modules/joi": {
-      "version": "17.13.3",
-      "resolved": "https://registry.npmjs.org/joi/-/joi-17.13.3.tgz",
-      "integrity": "sha512-otDA4ldcIx+ZXsKHWmp0YizCweVRZG96J10b0FevjfuncLO1oX59THoAmHkNubYJ+9gWsYsp5k8v4ib6oDv1fA==",
-      "license": "BSD-3-Clause",
       "dependencies": {
-        "@hapi/hoek": "^9.3.0",
-        "@hapi/topo": "^5.1.0",
-        "@sideway/address": "^4.1.5",
-        "@sideway/formula": "^3.0.1",
-        "@sideway/pinpoint": "^2.0.0"
+        "is-alphabetical": "^2.0.0",
+        "is-decimal": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
       }
     },
-    "node_modules/js-tokens": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
-      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+    "node_modules/is-arrayish": {
+      "version": "0.2.1",
+      "resolved": "https://registry.facebook.net/is-arrayish/-/is-arrayish-0.2.1.tgz",
+      "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==",
       "license": "MIT"
     },
-    "node_modules/js-yaml": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
-      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+    "node_modules/is-binary-path": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/is-binary-path/-/is-binary-path-2.1.0.tgz",
+      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
       "license": "MIT",
       "dependencies": {
-        "argparse": "^2.0.1"
-      },
-      "bin": {
-        "js-yaml": "bin/js-yaml.js"
-      }
-    },
-    "node_modules/jsesc": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
-      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
-      "license": "MIT",
-      "bin": {
-        "jsesc": "bin/jsesc"
+        "binary-extensions": "^2.0.0"
       },
       "engines": {
-        "node": ">=6"
+        "node": ">=8"
       }
     },
-    "node_modules/json-buffer": {
+    "node_modules/is-ci": {
       "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
-      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
-      "license": "MIT"
-    },
-    "node_modules/json-parse-even-better-errors": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
-      "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==",
-      "license": "MIT"
-    },
-    "node_modules/json-schema-traverse": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
-      "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
-      "license": "MIT"
-    },
-    "node_modules/json5": {
-      "version": "2.2.3",
-      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
-      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "resolved": "https://registry.facebook.net/is-ci/-/is-ci-3.0.1.tgz",
+      "integrity": "sha512-ZYvCgrefwqoQ6yTyYUbQu64HsITZ3NfKX1lzaEYdkTDcfKzzCI/wthRRYKkdjHKFVgNiXKAKm65Zo1pk2as/QQ==",
       "license": "MIT",
-      "bin": {
-        "json5": "lib/cli.js"
+      "dependencies": {
+        "ci-info": "^3.2.0"
       },
-      "engines": {
-        "node": ">=6"
+      "bin": {
+        "is-ci": "bin.js"
       }
     },
-    "node_modules/jsonfile": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz",
-      "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==",
+    "node_modules/is-core-module": {
+      "version": "2.16.1",
+      "resolved": "https://registry.facebook.net/is-core-module/-/is-core-module-2.16.1.tgz",
+      "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==",
       "license": "MIT",
       "dependencies": {
-        "universalify": "^2.0.0"
+        "hasown": "^2.0.2"
       },
-      "optionalDependencies": {
-        "graceful-fs": "^4.1.6"
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/keyv": {
-      "version": "4.5.4",
-      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
-      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
+    "node_modules/is-decimal": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/is-decimal/-/is-decimal-2.0.1.tgz",
+      "integrity": "sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A==",
       "license": "MIT",
-      "dependencies": {
-        "json-buffer": "3.0.1"
-      }
-    },
-    "node_modules/kind-of": {
-      "version": "6.0.3",
-      "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz",
-      "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/kleur": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/kleur/-/kleur-3.0.3.tgz",
-      "integrity": "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
       }
     },
-    "node_modules/latest-version": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/latest-version/-/latest-version-7.0.0.tgz",
-      "integrity": "sha512-KvNT4XqAMzdcL6ka6Tl3i2lYeFDgXNCuIX+xNx6ZMVR1dFq+idXd9FLKNMOIx0t9mJ9/HudyX4oZWXZQ0UJHeg==",
+    "node_modules/is-docker": {
+      "version": "2.2.1",
+      "resolved": "https://registry.facebook.net/is-docker/-/is-docker-2.2.1.tgz",
+      "integrity": "sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==",
       "license": "MIT",
-      "dependencies": {
-        "package-json": "^8.1.0"
+      "bin": {
+        "is-docker": "cli.js"
       },
       "engines": {
-        "node": ">=14.16"
+        "node": ">=8"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/launch-editor": {
-      "version": "2.9.1",
-      "resolved": "https://registry.npmjs.org/launch-editor/-/launch-editor-2.9.1.tgz",
-      "integrity": "sha512-Gcnl4Bd+hRO9P9icCP/RVVT2o8SFlPXofuCxvA2SaZuH45whSvf5p8x5oih5ftLiVhEI4sp5xDY+R+b3zJBh5w==",
-      "license": "MIT",
-      "dependencies": {
-        "picocolors": "^1.0.0",
-        "shell-quote": "^1.8.1"
-      }
-    },
-    "node_modules/leven": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz",
-      "integrity": "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/lilconfig": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz",
-      "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==",
+    "node_modules/is-extendable": {
+      "version": "0.1.1",
+      "resolved": "https://registry.facebook.net/is-extendable/-/is-extendable-0.1.1.tgz",
+      "integrity": "sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==",
       "license": "MIT",
       "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/antonk52"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/lines-and-columns": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
-      "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==",
-      "license": "MIT"
-    },
-    "node_modules/loader-runner": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/loader-runner/-/loader-runner-4.3.0.tgz",
-      "integrity": "sha512-3R/1M+yS3j5ou80Me59j7F9IMs4PXs3VqRrm0TU3AbKPxlmpoY1TNscJV/oGJXo8qCatFGTfDbY6W6ipGOYXfg==",
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.facebook.net/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
       "license": "MIT",
       "engines": {
-        "node": ">=6.11.5"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/loader-utils": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/loader-utils/-/loader-utils-2.0.4.tgz",
-      "integrity": "sha512-xXqpXoINfFhgua9xiqD8fPFHgkoq1mmmpE92WlDbm9rNRd/EbRb+Gqf908T2DMfuHjjJlksiK2RbHVOdD/MqSw==",
+    "node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
       "license": "MIT",
-      "dependencies": {
-        "big.js": "^5.2.2",
-        "emojis-list": "^3.0.0",
-        "json5": "^2.1.2"
-      },
       "engines": {
-        "node": ">=8.9.0"
+        "node": ">=8"
       }
     },
-    "node_modules/locate-path": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-7.2.0.tgz",
-      "integrity": "sha512-gvVijfZvn7R+2qyPX8mAuKcFGDf6Nc61GdvGafQsHL0sBIxfKzA+usWn4GFC/bk+QdwPUD4kWFJLhElipq+0VA==",
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.facebook.net/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
       "license": "MIT",
       "dependencies": {
-        "p-locate": "^6.0.0"
+        "is-extglob": "^2.1.1"
       },
       "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/lodash": {
-      "version": "4.17.21",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
-      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
-      "license": "MIT"
-    },
-    "node_modules/lodash.debounce": {
-      "version": "4.0.8",
-      "resolved": "https://registry.npmjs.org/lodash.debounce/-/lodash.debounce-4.0.8.tgz",
-      "integrity": "sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==",
-      "license": "MIT"
-    },
-    "node_modules/lodash.memoize": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz",
-      "integrity": "sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==",
-      "license": "MIT"
-    },
-    "node_modules/lodash.uniq": {
-      "version": "4.5.0",
-      "resolved": "https://registry.npmjs.org/lodash.uniq/-/lodash.uniq-4.5.0.tgz",
-      "integrity": "sha512-xfBaXQd9ryd9dlSDvnvI0lvxfLJlYAZzXomUYzLKtUeOQvOP5piqAWuGtrhWeqaXK9hhoM/iyJc5AV+XfsX3HQ==",
-      "license": "MIT"
-    },
-    "node_modules/longest-streak": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/longest-streak/-/longest-streak-3.1.0.tgz",
-      "integrity": "sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==",
+    "node_modules/is-hexadecimal": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/is-hexadecimal/-/is-hexadecimal-2.0.1.tgz",
+      "integrity": "sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg==",
       "license": "MIT",
       "funding": {
         "type": "github",
         "url": "https://github.com/sponsors/wooorm"
       }
     },
-    "node_modules/loose-envify": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
-      "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
+    "node_modules/is-inside-container": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/is-inside-container/-/is-inside-container-1.0.0.tgz",
+      "integrity": "sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA==",
       "license": "MIT",
       "dependencies": {
-        "js-tokens": "^3.0.0 || ^4.0.0"
+        "is-docker": "^3.0.0"
       },
       "bin": {
-        "loose-envify": "cli.js"
-      }
-    },
-    "node_modules/lower-case": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/lower-case/-/lower-case-2.0.2.tgz",
-      "integrity": "sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==",
-      "license": "MIT",
-      "dependencies": {
-        "tslib": "^2.0.3"
+        "is-inside-container": "cli.js"
+      },
+      "engines": {
+        "node": ">=14.16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/lowercase-keys": {
+    "node_modules/is-inside-container/node_modules/is-docker": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-3.0.0.tgz",
-      "integrity": "sha512-ozCC6gdQ+glXOQsveKD0YsDy8DSQFjDTz4zyzEHNV5+JP5D62LmfDZ6o1cycFx9ouG940M5dE8C8CTewdj2YWQ==",
+      "resolved": "https://registry.facebook.net/is-docker/-/is-docker-3.0.0.tgz",
+      "integrity": "sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ==",
       "license": "MIT",
+      "bin": {
+        "is-docker": "cli.js"
+      },
       "engines": {
         "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
       },
@@ -10198,19 +10189,26 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/lru-cache": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
-      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
-      "license": "ISC",
+    "node_modules/is-installed-globally": {
+      "version": "0.4.0",
+      "resolved": "https://registry.facebook.net/is-installed-globally/-/is-installed-globally-0.4.0.tgz",
+      "integrity": "sha512-iwGqO3J21aaSkC7jWnHP/difazwS7SFeIqxv6wEtLU8Y5KlzFTjyqcSIT0d8s4+dDhKytsk9PJZ2BkS5eZwQRQ==",
+      "license": "MIT",
       "dependencies": {
-        "yallist": "^3.0.2"
+        "global-dirs": "^3.0.0",
+        "is-path-inside": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/markdown-extensions": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/markdown-extensions/-/markdown-extensions-2.0.0.tgz",
-      "integrity": "sha512-o5vL7aDWatOTX8LzaS1WMoaoxIiLRQJuIKKe2wAw6IeULDHaqbiqiggmx+pKvZDb1Sj+pE46Sn1T7lCqfFtg1Q==",
+    "node_modules/is-network-error": {
+      "version": "1.3.1",
+      "resolved": "https://registry.facebook.net/is-network-error/-/is-network-error-1.3.1.tgz",
+      "integrity": "sha512-6QCxa49rQbmUWLfk0nuGqzql9U8uaV2H6279bRErPBHe/109hCzsLUBUHfbEtvLIHBd6hyXbgedBSHevm43Edw==",
       "license": "MIT",
       "engines": {
         "node": ">=16"
@@ -10219,1083 +10217,922 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/markdown-table": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-3.0.4.tgz",
-      "integrity": "sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw==",
+    "node_modules/is-npm": {
+      "version": "6.1.0",
+      "resolved": "https://registry.facebook.net/is-npm/-/is-npm-6.1.0.tgz",
+      "integrity": "sha512-O2z4/kNgyjhQwVR1Wpkbfc19JIhggF97NZNCpWTnjH7kVcZMUrnut9XSN7txI7VdyIYk5ZatOq3zvSuWpU8hoA==",
       "license": "MIT",
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
       "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/wooorm"
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/math-intrinsics": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
-      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+    "node_modules/is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.facebook.net/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
       "license": "MIT",
       "engines": {
-        "node": ">= 0.4"
+        "node": ">=0.12.0"
       }
     },
-    "node_modules/mdast-util-directive": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/mdast-util-directive/-/mdast-util-directive-3.0.0.tgz",
-      "integrity": "sha512-JUpYOqKI4mM3sZcNxmF/ox04XYFFkNwr0CFlrQIkCwbvH0xzMCqkMqAde9wRd80VAhaUrwFwKm2nxretdT1h7Q==",
+    "node_modules/is-obj": {
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/is-obj/-/is-obj-1.0.1.tgz",
+      "integrity": "sha512-l4RyHgRqGN4Y3+9JHVrNqO+tN0rV5My76uW5/nuO4K1b6vw5G8d/cmFjP9tRfEsdhZNt0IFdZuK/c2Vr4Nb+Qg==",
       "license": "MIT",
-      "dependencies": {
-        "@types/mdast": "^4.0.0",
-        "@types/unist": "^3.0.0",
-        "devlop": "^1.0.0",
-        "mdast-util-from-markdown": "^2.0.0",
-        "mdast-util-to-markdown": "^2.0.0",
-        "parse-entities": "^4.0.0",
-        "stringify-entities": "^4.0.0",
-        "unist-util-visit-parents": "^6.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+      "engines": {
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/mdast-util-find-and-replace": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/mdast-util-find-and-replace/-/mdast-util-find-and-replace-3.0.1.tgz",
-      "integrity": "sha512-SG21kZHGC3XRTSUhtofZkBzZTJNM5ecCi0SK2IMKmSXR8vO3peL+kb1O0z7Zl83jKtutG4k5Wv/W7V3/YHvzPA==",
+    "node_modules/is-path-inside": {
+      "version": "3.0.3",
+      "resolved": "https://registry.facebook.net/is-path-inside/-/is-path-inside-3.0.3.tgz",
+      "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==",
       "license": "MIT",
-      "dependencies": {
-        "@types/mdast": "^4.0.0",
-        "escape-string-regexp": "^5.0.0",
-        "unist-util-is": "^6.0.0",
-        "unist-util-visit-parents": "^6.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+      "engines": {
+        "node": ">=8"
       }
     },
-    "node_modules/mdast-util-find-and-replace/node_modules/escape-string-regexp": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz",
-      "integrity": "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==",
+    "node_modules/is-plain-obj": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/is-plain-obj/-/is-plain-obj-3.0.0.tgz",
+      "integrity": "sha512-gwsOE28k+23GP1B6vFl1oVh/WOzmawBrKwo5Ev6wMKzPkaXaCDIQKzLnvsA42DRlbVTWorkgTKIviAKCWkfUwA==",
       "license": "MIT",
       "engines": {
-        "node": ">=12"
+        "node": ">=10"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/mdast-util-from-markdown": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-2.0.2.tgz",
-      "integrity": "sha512-uZhTV/8NBuw0WHkPTrCqDOl0zVe1BIng5ZtHoDk49ME1qqcjYmmLmOf0gELgcRMxN4w2iuIeVso5/6QymSrgmA==",
+    "node_modules/is-plain-object": {
+      "version": "2.0.4",
+      "resolved": "https://registry.facebook.net/is-plain-object/-/is-plain-object-2.0.4.tgz",
+      "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==",
       "license": "MIT",
       "dependencies": {
-        "@types/mdast": "^4.0.0",
-        "@types/unist": "^3.0.0",
-        "decode-named-character-reference": "^1.0.0",
-        "devlop": "^1.0.0",
-        "mdast-util-to-string": "^4.0.0",
-        "micromark": "^4.0.0",
-        "micromark-util-decode-numeric-character-reference": "^2.0.0",
-        "micromark-util-decode-string": "^2.0.0",
-        "micromark-util-normalize-identifier": "^2.0.0",
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0",
-        "unist-util-stringify-position": "^4.0.0"
+        "isobject": "^3.0.1"
       },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+      "engines": {
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/mdast-util-from-markdown/node_modules/micromark-util-symbol": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/mdast-util-frontmatter": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/mdast-util-frontmatter/-/mdast-util-frontmatter-2.0.1.tgz",
-      "integrity": "sha512-LRqI9+wdgC25P0URIJY9vwocIzCcksduHQ9OF2joxQoyTNVduwLAFUzjoopuRJbJAReaKrNQKAZKL3uCMugWJA==",
+    "node_modules/is-regexp": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/is-regexp/-/is-regexp-1.0.0.tgz",
+      "integrity": "sha512-7zjFAPO4/gwyQAAgRRmqeEeyIICSdmCqa3tsVHMdBzaXXRiqopZL4Cyghg/XulGWrtABTpbnYYzzIRffLkP4oA==",
       "license": "MIT",
-      "dependencies": {
-        "@types/mdast": "^4.0.0",
-        "devlop": "^1.0.0",
-        "escape-string-regexp": "^5.0.0",
-        "mdast-util-from-markdown": "^2.0.0",
-        "mdast-util-to-markdown": "^2.0.0",
-        "micromark-extension-frontmatter": "^2.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+      "engines": {
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/mdast-util-frontmatter/node_modules/escape-string-regexp": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz",
-      "integrity": "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==",
+    "node_modules/is-stream": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/is-stream/-/is-stream-2.0.1.tgz",
+      "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==",
       "license": "MIT",
       "engines": {
-        "node": ">=12"
+        "node": ">=8"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/mdast-util-gfm": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/mdast-util-gfm/-/mdast-util-gfm-3.0.0.tgz",
-      "integrity": "sha512-dgQEX5Amaq+DuUqf26jJqSK9qgixgd6rYDHAv4aTBuA92cTknZlKpPfa86Z/s8Dj8xsAQpFfBmPUHWJBWqS4Bw==",
-      "license": "MIT",
-      "dependencies": {
-        "mdast-util-from-markdown": "^2.0.0",
-        "mdast-util-gfm-autolink-literal": "^2.0.0",
-        "mdast-util-gfm-footnote": "^2.0.0",
-        "mdast-util-gfm-strikethrough": "^2.0.0",
-        "mdast-util-gfm-table": "^2.0.0",
-        "mdast-util-gfm-task-list-item": "^2.0.0",
-        "mdast-util-to-markdown": "^2.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
-      }
+    "node_modules/is-typedarray": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/is-typedarray/-/is-typedarray-1.0.0.tgz",
+      "integrity": "sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==",
+      "license": "MIT"
     },
-    "node_modules/mdast-util-gfm-autolink-literal": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/mdast-util-gfm-autolink-literal/-/mdast-util-gfm-autolink-literal-2.0.1.tgz",
-      "integrity": "sha512-5HVP2MKaP6L+G6YaxPNjuL0BPrq9orG3TsrZ9YXbA3vDw/ACI4MEsnoDpn6ZNm7GnZgtAcONJyPhOP8tNJQavQ==",
+    "node_modules/is-wsl": {
+      "version": "2.2.0",
+      "resolved": "https://registry.facebook.net/is-wsl/-/is-wsl-2.2.0.tgz",
+      "integrity": "sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==",
       "license": "MIT",
       "dependencies": {
-        "@types/mdast": "^4.0.0",
-        "ccount": "^2.0.0",
-        "devlop": "^1.0.0",
-        "mdast-util-find-and-replace": "^3.0.0",
-        "micromark-util-character": "^2.0.0"
+        "is-docker": "^2.0.0"
       },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+      "engines": {
+        "node": ">=8"
       }
     },
-    "node_modules/mdast-util-gfm-autolink-literal/node_modules/micromark-util-character": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
-      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/is-yarn-global": {
+      "version": "0.4.1",
+      "resolved": "https://registry.facebook.net/is-yarn-global/-/is-yarn-global-0.4.1.tgz",
+      "integrity": "sha512-/kppl+R+LO5VmhYSEWARUFjodS25D68gvj8W7z0I7OWhUla5xWu8KL6CtB2V0R6yqhnRgbcaREMr4EEM6htLPQ==",
       "license": "MIT",
-      "dependencies": {
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/mdast-util-gfm-autolink-literal/node_modules/micromark-util-symbol": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/isarray": {
+      "version": "0.0.1",
+      "resolved": "https://registry.facebook.net/isarray/-/isarray-0.0.1.tgz",
+      "integrity": "sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==",
       "license": "MIT"
     },
-    "node_modules/mdast-util-gfm-footnote": {
+    "node_modules/isexe": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/mdast-util-gfm-footnote/-/mdast-util-gfm-footnote-2.0.0.tgz",
-      "integrity": "sha512-5jOT2boTSVkMnQ7LTrd6n/18kqwjmuYqo7JUPe+tRCY6O7dAuTFMtTPauYYrMPpox9hlN0uOx/FL8XvEfG9/mQ==",
+      "resolved": "https://registry.facebook.net/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "license": "ISC"
+    },
+    "node_modules/isobject": {
+      "version": "3.0.1",
+      "resolved": "https://registry.facebook.net/isobject/-/isobject-3.0.1.tgz",
+      "integrity": "sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==",
       "license": "MIT",
-      "dependencies": {
-        "@types/mdast": "^4.0.0",
-        "devlop": "^1.1.0",
-        "mdast-util-from-markdown": "^2.0.0",
-        "mdast-util-to-markdown": "^2.0.0",
-        "micromark-util-normalize-identifier": "^2.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+      "engines": {
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/mdast-util-gfm-strikethrough": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/mdast-util-gfm-strikethrough/-/mdast-util-gfm-strikethrough-2.0.0.tgz",
-      "integrity": "sha512-mKKb915TF+OC5ptj5bJ7WFRPdYtuHv0yTRxK2tJvi+BDqbkiG7h7u/9SI89nRAYcmap2xHQL9D+QG/6wSrTtXg==",
+    "node_modules/jest-util": {
+      "version": "29.7.0",
+      "resolved": "https://registry.facebook.net/jest-util/-/jest-util-29.7.0.tgz",
+      "integrity": "sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA==",
       "license": "MIT",
       "dependencies": {
-        "@types/mdast": "^4.0.0",
-        "mdast-util-from-markdown": "^2.0.0",
-        "mdast-util-to-markdown": "^2.0.0"
+        "@jest/types": "^29.6.3",
+        "@types/node": "*",
+        "chalk": "^4.0.0",
+        "ci-info": "^3.2.0",
+        "graceful-fs": "^4.2.9",
+        "picomatch": "^2.2.3"
       },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+      "engines": {
+        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
       }
     },
-    "node_modules/mdast-util-gfm-table": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/mdast-util-gfm-table/-/mdast-util-gfm-table-2.0.0.tgz",
-      "integrity": "sha512-78UEvebzz/rJIxLvE7ZtDd/vIQ0RHv+3Mh5DR96p7cS7HsBhYIICDBCu8csTNWNO6tBWfqXPWekRuj2FNOGOZg==",
+    "node_modules/jest-worker": {
+      "version": "27.5.1",
+      "resolved": "https://registry.facebook.net/jest-worker/-/jest-worker-27.5.1.tgz",
+      "integrity": "sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg==",
       "license": "MIT",
       "dependencies": {
-        "@types/mdast": "^4.0.0",
-        "devlop": "^1.0.0",
-        "markdown-table": "^3.0.0",
-        "mdast-util-from-markdown": "^2.0.0",
-        "mdast-util-to-markdown": "^2.0.0"
+        "@types/node": "*",
+        "merge-stream": "^2.0.0",
+        "supports-color": "^8.0.0"
       },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+      "engines": {
+        "node": ">= 10.13.0"
       }
     },
-    "node_modules/mdast-util-gfm-task-list-item": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/mdast-util-gfm-task-list-item/-/mdast-util-gfm-task-list-item-2.0.0.tgz",
-      "integrity": "sha512-IrtvNvjxC1o06taBAVJznEnkiHxLFTzgonUdy8hzFVeDun0uTjxxrRGVaNFqkU1wJR3RBPEfsxmU6jDWPofrTQ==",
+    "node_modules/jiti": {
+      "version": "1.21.7",
+      "resolved": "https://registry.facebook.net/jiti/-/jiti-1.21.7.tgz",
+      "integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==",
       "license": "MIT",
-      "dependencies": {
-        "@types/mdast": "^4.0.0",
-        "devlop": "^1.0.0",
-        "mdast-util-from-markdown": "^2.0.0",
-        "mdast-util-to-markdown": "^2.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+      "bin": {
+        "jiti": "bin/jiti.js"
       }
     },
-    "node_modules/mdast-util-mdx": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/mdast-util-mdx/-/mdast-util-mdx-3.0.0.tgz",
-      "integrity": "sha512-JfbYLAW7XnYTTbUsmpu0kdBUVe+yKVJZBItEjwyYJiDJuZ9w4eeaqks4HQO+R7objWgS2ymV60GYpI14Ug554w==",
-      "license": "MIT",
+    "node_modules/joi": {
+      "version": "17.13.3",
+      "resolved": "https://registry.facebook.net/joi/-/joi-17.13.3.tgz",
+      "integrity": "sha512-otDA4ldcIx+ZXsKHWmp0YizCweVRZG96J10b0FevjfuncLO1oX59THoAmHkNubYJ+9gWsYsp5k8v4ib6oDv1fA==",
+      "license": "BSD-3-Clause",
       "dependencies": {
-        "mdast-util-from-markdown": "^2.0.0",
-        "mdast-util-mdx-expression": "^2.0.0",
-        "mdast-util-mdx-jsx": "^3.0.0",
-        "mdast-util-mdxjs-esm": "^2.0.0",
-        "mdast-util-to-markdown": "^2.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "@hapi/hoek": "^9.3.0",
+        "@hapi/topo": "^5.1.0",
+        "@sideway/address": "^4.1.5",
+        "@sideway/formula": "^3.0.1",
+        "@sideway/pinpoint": "^2.0.0"
       }
     },
-    "node_modules/mdast-util-mdx-expression": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/mdast-util-mdx-expression/-/mdast-util-mdx-expression-2.0.1.tgz",
-      "integrity": "sha512-J6f+9hUp+ldTZqKRSg7Vw5V6MqjATc+3E4gf3CFNcuZNWD8XdyI6zQ8GqH7f8169MM6P7hMBRDVGnn7oHB9kXQ==",
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "license": "MIT"
+    },
+    "node_modules/js-yaml": {
+      "version": "4.1.1",
+      "resolved": "https://registry.facebook.net/js-yaml/-/js-yaml-4.1.1.tgz",
+      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
       "license": "MIT",
       "dependencies": {
-        "@types/estree-jsx": "^1.0.0",
-        "@types/hast": "^3.0.0",
-        "@types/mdast": "^4.0.0",
-        "devlop": "^1.0.0",
-        "mdast-util-from-markdown": "^2.0.0",
-        "mdast-util-to-markdown": "^2.0.0"
+        "argparse": "^2.0.1"
       },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
       }
     },
-    "node_modules/mdast-util-mdx-jsx": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.1.3.tgz",
-      "integrity": "sha512-bfOjvNt+1AcbPLTFMFWY149nJz0OjmewJs3LQQ5pIyVGxP4CdOqNVJL6kTaM5c68p8q82Xv3nCyFfUnuEcH3UQ==",
+    "node_modules/jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.facebook.net/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
       "license": "MIT",
-      "dependencies": {
-        "@types/estree-jsx": "^1.0.0",
-        "@types/hast": "^3.0.0",
-        "@types/mdast": "^4.0.0",
-        "@types/unist": "^3.0.0",
-        "ccount": "^2.0.0",
-        "devlop": "^1.1.0",
-        "mdast-util-from-markdown": "^2.0.0",
-        "mdast-util-to-markdown": "^2.0.0",
-        "parse-entities": "^4.0.0",
-        "stringify-entities": "^4.0.0",
-        "unist-util-stringify-position": "^4.0.0",
-        "vfile-message": "^4.0.0"
+      "bin": {
+        "jsesc": "bin/jsesc"
       },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+      "engines": {
+        "node": ">=6"
       }
     },
-    "node_modules/mdast-util-mdxjs-esm": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/mdast-util-mdxjs-esm/-/mdast-util-mdxjs-esm-2.0.1.tgz",
-      "integrity": "sha512-EcmOpxsZ96CvlP03NghtH1EsLtr0n9Tm4lPUJUBccV9RwUOneqSycg19n5HGzCf+10LozMRSObtVr3ee1WoHtg==",
+    "node_modules/json-buffer": {
+      "version": "3.0.1",
+      "resolved": "https://registry.facebook.net/json-buffer/-/json-buffer-3.0.1.tgz",
+      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
+      "license": "MIT"
+    },
+    "node_modules/json-parse-even-better-errors": {
+      "version": "2.3.1",
+      "resolved": "https://registry.facebook.net/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
+      "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==",
+      "license": "MIT"
+    },
+    "node_modules/json-schema-traverse": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+      "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+      "license": "MIT"
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.facebook.net/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
       "license": "MIT",
-      "dependencies": {
-        "@types/estree-jsx": "^1.0.0",
-        "@types/hast": "^3.0.0",
-        "@types/mdast": "^4.0.0",
-        "devlop": "^1.0.0",
-        "mdast-util-from-markdown": "^2.0.0",
-        "mdast-util-to-markdown": "^2.0.0"
+      "bin": {
+        "json5": "lib/cli.js"
       },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+      "engines": {
+        "node": ">=6"
       }
     },
-    "node_modules/mdast-util-phrasing": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/mdast-util-phrasing/-/mdast-util-phrasing-4.1.0.tgz",
-      "integrity": "sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w==",
+    "node_modules/jsonfile": {
+      "version": "6.2.1",
+      "resolved": "https://registry.facebook.net/jsonfile/-/jsonfile-6.2.1.tgz",
+      "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
       "license": "MIT",
       "dependencies": {
-        "@types/mdast": "^4.0.0",
-        "unist-util-is": "^6.0.0"
+        "universalify": "^2.0.0"
       },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+      "optionalDependencies": {
+        "graceful-fs": "^4.1.6"
       }
     },
-    "node_modules/mdast-util-to-hast": {
-      "version": "13.2.0",
-      "resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-13.2.0.tgz",
-      "integrity": "sha512-QGYKEuUsYT9ykKBCMOEDLsU5JRObWQusAolFMeko/tYPufNkRffBAQjIE+99jbA87xv6FgmjLtwjh9wBWajwAA==",
+    "node_modules/keyv": {
+      "version": "4.5.4",
+      "resolved": "https://registry.facebook.net/keyv/-/keyv-4.5.4.tgz",
+      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
       "license": "MIT",
       "dependencies": {
-        "@types/hast": "^3.0.0",
-        "@types/mdast": "^4.0.0",
-        "@ungap/structured-clone": "^1.0.0",
-        "devlop": "^1.0.0",
-        "micromark-util-sanitize-uri": "^2.0.0",
-        "trim-lines": "^3.0.0",
-        "unist-util-position": "^5.0.0",
-        "unist-util-visit": "^5.0.0",
-        "vfile": "^6.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "json-buffer": "3.0.1"
       }
     },
-    "node_modules/mdast-util-to-markdown": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/mdast-util-to-markdown/-/mdast-util-to-markdown-2.1.2.tgz",
-      "integrity": "sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA==",
+    "node_modules/kind-of": {
+      "version": "6.0.3",
+      "resolved": "https://registry.facebook.net/kind-of/-/kind-of-6.0.3.tgz",
+      "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/kleur": {
+      "version": "3.0.3",
+      "resolved": "https://registry.facebook.net/kleur/-/kleur-3.0.3.tgz",
+      "integrity": "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/latest-version": {
+      "version": "7.0.0",
+      "resolved": "https://registry.facebook.net/latest-version/-/latest-version-7.0.0.tgz",
+      "integrity": "sha512-KvNT4XqAMzdcL6ka6Tl3i2lYeFDgXNCuIX+xNx6ZMVR1dFq+idXd9FLKNMOIx0t9mJ9/HudyX4oZWXZQ0UJHeg==",
       "license": "MIT",
       "dependencies": {
-        "@types/mdast": "^4.0.0",
-        "@types/unist": "^3.0.0",
-        "longest-streak": "^3.0.0",
-        "mdast-util-phrasing": "^4.0.0",
-        "mdast-util-to-string": "^4.0.0",
-        "micromark-util-classify-character": "^2.0.0",
-        "micromark-util-decode-string": "^2.0.0",
-        "unist-util-visit": "^5.0.0",
-        "zwitch": "^2.0.0"
+        "package-json": "^8.1.0"
+      },
+      "engines": {
+        "node": ">=14.16"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/mdast-util-to-string": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-4.0.0.tgz",
-      "integrity": "sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg==",
+    "node_modules/launch-editor": {
+      "version": "2.13.2",
+      "resolved": "https://registry.facebook.net/launch-editor/-/launch-editor-2.13.2.tgz",
+      "integrity": "sha512-4VVDnbOpLXy/s8rdRCSXb+zfMeFR0WlJWpET1iA9CQdlZDfwyLjUuGQzXU4VeOoey6AicSAluWan7Etga6Kcmg==",
       "license": "MIT",
       "dependencies": {
-        "@types/mdast": "^4.0.0"
+        "picocolors": "^1.1.1",
+        "shell-quote": "^1.8.3"
+      }
+    },
+    "node_modules/leven": {
+      "version": "3.1.0",
+      "resolved": "https://registry.facebook.net/leven/-/leven-3.1.0.tgz",
+      "integrity": "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/lilconfig": {
+      "version": "3.1.3",
+      "resolved": "https://registry.facebook.net/lilconfig/-/lilconfig-3.1.3.tgz",
+      "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=14"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "url": "https://github.com/sponsors/antonk52"
       }
     },
-    "node_modules/mdn-data": {
-      "version": "2.0.30",
-      "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.0.30.tgz",
-      "integrity": "sha512-GaqWWShW4kv/G9IEucWScBx9G1/vsFZZJUO+tD26M8J8z3Kw5RDQjaoZe03YAClgeS/SWPOcb4nkFBTEi5DUEA==",
-      "license": "CC0-1.0"
+    "node_modules/lines-and-columns": {
+      "version": "1.2.4",
+      "resolved": "https://registry.facebook.net/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
+      "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==",
+      "license": "MIT"
     },
-    "node_modules/media-typer": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
-      "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==",
+    "node_modules/loader-runner": {
+      "version": "4.3.2",
+      "resolved": "https://registry.facebook.net/loader-runner/-/loader-runner-4.3.2.tgz",
+      "integrity": "sha512-DFEqQ3ihfS9blba08cLfYf1NRAIEm+dDjic073DRDc3/JspI/8wYmtDsHwd3+4hwvdxSK7PGaElfTmm0awWJ4w==",
       "license": "MIT",
       "engines": {
-        "node": ">= 0.6"
+        "node": ">=6.11.5"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
       }
     },
-    "node_modules/memfs": {
-      "version": "3.5.3",
-      "resolved": "https://registry.npmjs.org/memfs/-/memfs-3.5.3.tgz",
-      "integrity": "sha512-UERzLsxzllchadvbPs5aolHh65ISpKpM+ccLbOJ8/vvpBKmAWf+la7dXFy7Mr0ySHbdHrFv5kGFCUHHe6GFEmw==",
-      "license": "Unlicense",
+    "node_modules/loader-utils": {
+      "version": "2.0.4",
+      "resolved": "https://registry.facebook.net/loader-utils/-/loader-utils-2.0.4.tgz",
+      "integrity": "sha512-xXqpXoINfFhgua9xiqD8fPFHgkoq1mmmpE92WlDbm9rNRd/EbRb+Gqf908T2DMfuHjjJlksiK2RbHVOdD/MqSw==",
+      "license": "MIT",
       "dependencies": {
-        "fs-monkey": "^1.0.4"
+        "big.js": "^5.2.2",
+        "emojis-list": "^3.0.0",
+        "json5": "^2.1.2"
       },
       "engines": {
-        "node": ">= 4.0.0"
+        "node": ">=8.9.0"
       }
     },
-    "node_modules/merge-descriptors": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz",
-      "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==",
+    "node_modules/locate-path": {
+      "version": "7.2.0",
+      "resolved": "https://registry.facebook.net/locate-path/-/locate-path-7.2.0.tgz",
+      "integrity": "sha512-gvVijfZvn7R+2qyPX8mAuKcFGDf6Nc61GdvGafQsHL0sBIxfKzA+usWn4GFC/bk+QdwPUD4kWFJLhElipq+0VA==",
       "license": "MIT",
+      "dependencies": {
+        "p-locate": "^6.0.0"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/merge-stream": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz",
-      "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==",
+    "node_modules/lodash": {
+      "version": "4.18.1",
+      "resolved": "https://registry.facebook.net/lodash/-/lodash-4.18.1.tgz",
+      "integrity": "sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==",
       "license": "MIT"
     },
-    "node_modules/merge2": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
-      "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 8"
-      }
+    "node_modules/lodash.debounce": {
+      "version": "4.0.8",
+      "resolved": "https://registry.facebook.net/lodash.debounce/-/lodash.debounce-4.0.8.tgz",
+      "integrity": "sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==",
+      "license": "MIT"
     },
-    "node_modules/methods": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
-      "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==",
+    "node_modules/lodash.memoize": {
+      "version": "4.1.2",
+      "resolved": "https://registry.facebook.net/lodash.memoize/-/lodash.memoize-4.1.2.tgz",
+      "integrity": "sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.uniq": {
+      "version": "4.5.0",
+      "resolved": "https://registry.facebook.net/lodash.uniq/-/lodash.uniq-4.5.0.tgz",
+      "integrity": "sha512-xfBaXQd9ryd9dlSDvnvI0lvxfLJlYAZzXomUYzLKtUeOQvOP5piqAWuGtrhWeqaXK9hhoM/iyJc5AV+XfsX3HQ==",
+      "license": "MIT"
+    },
+    "node_modules/longest-streak": {
+      "version": "3.1.0",
+      "resolved": "https://registry.facebook.net/longest-streak/-/longest-streak-3.1.0.tgz",
+      "integrity": "sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==",
       "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
       }
     },
-    "node_modules/micromark": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/micromark/-/micromark-4.0.1.tgz",
-      "integrity": "sha512-eBPdkcoCNvYcxQOAKAlceo5SNdzZWfF+FcSupREAzdAh9rRmE239CEQAiTwIgblwnoM8zzj35sZ5ZwvSEOF6Kw==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/loose-envify": {
+      "version": "1.4.0",
+      "resolved": "https://registry.facebook.net/loose-envify/-/loose-envify-1.4.0.tgz",
+      "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
       "license": "MIT",
       "dependencies": {
-        "@types/debug": "^4.0.0",
-        "debug": "^4.0.0",
-        "decode-named-character-reference": "^1.0.0",
-        "devlop": "^1.0.0",
-        "micromark-core-commonmark": "^2.0.0",
-        "micromark-factory-space": "^2.0.0",
-        "micromark-util-character": "^2.0.0",
-        "micromark-util-chunked": "^2.0.0",
-        "micromark-util-combine-extensions": "^2.0.0",
-        "micromark-util-decode-numeric-character-reference": "^2.0.0",
-        "micromark-util-encode": "^2.0.0",
-        "micromark-util-normalize-identifier": "^2.0.0",
-        "micromark-util-resolve-all": "^2.0.0",
-        "micromark-util-sanitize-uri": "^2.0.0",
-        "micromark-util-subtokenize": "^2.0.0",
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "js-tokens": "^3.0.0 || ^4.0.0"
+      },
+      "bin": {
+        "loose-envify": "cli.js"
       }
     },
-    "node_modules/micromark-core-commonmark": {
+    "node_modules/lower-case": {
       "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/micromark-core-commonmark/-/micromark-core-commonmark-2.0.2.tgz",
-      "integrity": "sha512-FKjQKbxd1cibWMM1P9N+H8TwlgGgSkWZMmfuVucLCHaYqeSvJ0hFeHsIa65pA2nYbes0f8LDHPMrd9X7Ujxg9w==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+      "resolved": "https://registry.facebook.net/lower-case/-/lower-case-2.0.2.tgz",
+      "integrity": "sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==",
       "license": "MIT",
       "dependencies": {
-        "decode-named-character-reference": "^1.0.0",
-        "devlop": "^1.0.0",
-        "micromark-factory-destination": "^2.0.0",
-        "micromark-factory-label": "^2.0.0",
-        "micromark-factory-space": "^2.0.0",
-        "micromark-factory-title": "^2.0.0",
-        "micromark-factory-whitespace": "^2.0.0",
-        "micromark-util-character": "^2.0.0",
-        "micromark-util-chunked": "^2.0.0",
-        "micromark-util-classify-character": "^2.0.0",
-        "micromark-util-html-tag-name": "^2.0.0",
-        "micromark-util-normalize-identifier": "^2.0.0",
-        "micromark-util-resolve-all": "^2.0.0",
-        "micromark-util-subtokenize": "^2.0.0",
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "tslib": "^2.0.3"
       }
     },
-    "node_modules/micromark-core-commonmark/node_modules/micromark-factory-space": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz",
-      "integrity": "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/lowercase-keys": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/lowercase-keys/-/lowercase-keys-3.0.0.tgz",
+      "integrity": "sha512-ozCC6gdQ+glXOQsveKD0YsDy8DSQFjDTz4zyzEHNV5+JP5D62LmfDZ6o1cycFx9ouG940M5dE8C8CTewdj2YWQ==",
       "license": "MIT",
-      "dependencies": {
-        "micromark-util-character": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/micromark-core-commonmark/node_modules/micromark-util-character": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
-      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT",
+    "node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.facebook.net/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "license": "ISC",
       "dependencies": {
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "yallist": "^3.0.2"
       }
     },
-    "node_modules/micromark-core-commonmark/node_modules/micromark-util-symbol": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/micromark-extension-directive": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/micromark-extension-directive/-/micromark-extension-directive-3.0.2.tgz",
-      "integrity": "sha512-wjcXHgk+PPdmvR58Le9d7zQYWy+vKEU9Se44p2CrCDPiLr2FMyiT4Fyb5UFKFC66wGB3kPlgD7q3TnoqPS7SZA==",
+    "node_modules/markdown-extensions": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/markdown-extensions/-/markdown-extensions-2.0.0.tgz",
+      "integrity": "sha512-o5vL7aDWatOTX8LzaS1WMoaoxIiLRQJuIKKe2wAw6IeULDHaqbiqiggmx+pKvZDb1Sj+pE46Sn1T7lCqfFtg1Q==",
       "license": "MIT",
-      "dependencies": {
-        "devlop": "^1.0.0",
-        "micromark-factory-space": "^2.0.0",
-        "micromark-factory-whitespace": "^2.0.0",
-        "micromark-util-character": "^2.0.0",
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0",
-        "parse-entities": "^4.0.0"
+      "engines": {
+        "node": ">=16"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/micromark-extension-directive/node_modules/micromark-factory-space": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz",
-      "integrity": "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/markdown-table": {
+      "version": "3.0.4",
+      "resolved": "https://registry.facebook.net/markdown-table/-/markdown-table-3.0.4.tgz",
+      "integrity": "sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw==",
       "license": "MIT",
-      "dependencies": {
-        "micromark-util-character": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
       }
     },
-    "node_modules/micromark-extension-directive/node_modules/micromark-util-character": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
-      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.facebook.net/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
       "license": "MIT",
-      "dependencies": {
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+      "engines": {
+        "node": ">= 0.4"
       }
     },
-    "node_modules/micromark-extension-directive/node_modules/micromark-util-symbol": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/micromark-extension-frontmatter": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/micromark-extension-frontmatter/-/micromark-extension-frontmatter-2.0.0.tgz",
-      "integrity": "sha512-C4AkuM3dA58cgZha7zVnuVxBhDsbttIMiytjgsM2XbHAB2faRVaHRle40558FBN+DJcrLNCoqG5mlrpdU4cRtg==",
+    "node_modules/mdast-util-directive": {
+      "version": "3.1.0",
+      "resolved": "https://registry.facebook.net/mdast-util-directive/-/mdast-util-directive-3.1.0.tgz",
+      "integrity": "sha512-I3fNFt+DHmpWCYAT7quoM6lHf9wuqtI+oCOfvILnoicNIqjh5E3dEJWiXuYME2gNe8vl1iMQwyUHa7bgFmak6Q==",
       "license": "MIT",
       "dependencies": {
-        "fault": "^2.0.0",
-        "micromark-util-character": "^2.0.0",
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "ccount": "^2.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0",
+        "parse-entities": "^4.0.0",
+        "stringify-entities": "^4.0.0",
+        "unist-util-visit-parents": "^6.0.0"
       },
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/micromark-extension-frontmatter/node_modules/micromark-util-character": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
-      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/mdast-util-find-and-replace": {
+      "version": "3.0.2",
+      "resolved": "https://registry.facebook.net/mdast-util-find-and-replace/-/mdast-util-find-and-replace-3.0.2.tgz",
+      "integrity": "sha512-Tmd1Vg/m3Xz43afeNxDIhWRtFZgM2VLyaf4vSTYwudTyeuTneoL3qtWMA5jeLyz/O1vDJmmV4QuScFCA2tBPwg==",
       "license": "MIT",
       "dependencies": {
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "@types/mdast": "^4.0.0",
+        "escape-string-regexp": "^5.0.0",
+        "unist-util-is": "^6.0.0",
+        "unist-util-visit-parents": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/micromark-extension-frontmatter/node_modules/micromark-util-symbol": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT"
+    "node_modules/mdast-util-find-and-replace/node_modules/escape-string-regexp": {
+      "version": "5.0.0",
+      "resolved": "https://registry.facebook.net/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz",
+      "integrity": "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
     },
-    "node_modules/micromark-extension-gfm": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/micromark-extension-gfm/-/micromark-extension-gfm-3.0.0.tgz",
-      "integrity": "sha512-vsKArQsicm7t0z2GugkCKtZehqUm31oeGBV/KVSorWSy8ZlNAv7ytjFhvaryUiCUJYqs+NoE6AFhpQvBTM6Q4w==",
+    "node_modules/mdast-util-from-markdown": {
+      "version": "2.0.3",
+      "resolved": "https://registry.facebook.net/mdast-util-from-markdown/-/mdast-util-from-markdown-2.0.3.tgz",
+      "integrity": "sha512-W4mAWTvSlKvf8L6J+VN9yLSqQ9AOAAvHuoDAmPkz4dHf553m5gVj2ejadHJhoJmcmxEnOv6Pa8XJhpxE93kb8Q==",
       "license": "MIT",
       "dependencies": {
-        "micromark-extension-gfm-autolink-literal": "^2.0.0",
-        "micromark-extension-gfm-footnote": "^2.0.0",
-        "micromark-extension-gfm-strikethrough": "^2.0.0",
-        "micromark-extension-gfm-table": "^2.0.0",
-        "micromark-extension-gfm-tagfilter": "^2.0.0",
-        "micromark-extension-gfm-task-list-item": "^2.0.0",
-        "micromark-util-combine-extensions": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "decode-named-character-reference": "^1.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-to-string": "^4.0.0",
+        "micromark": "^4.0.0",
+        "micromark-util-decode-numeric-character-reference": "^2.0.0",
+        "micromark-util-decode-string": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0",
+        "unist-util-stringify-position": "^4.0.0"
       },
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/micromark-extension-gfm-autolink-literal": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-autolink-literal/-/micromark-extension-gfm-autolink-literal-2.1.0.tgz",
-      "integrity": "sha512-oOg7knzhicgQ3t4QCjCWgTmfNhvQbDDnJeVu9v81r7NltNCVmhPy1fJRX27pISafdjL+SVc4d3l48Gb6pbRypw==",
+    "node_modules/mdast-util-frontmatter": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/mdast-util-frontmatter/-/mdast-util-frontmatter-2.0.1.tgz",
+      "integrity": "sha512-LRqI9+wdgC25P0URIJY9vwocIzCcksduHQ9OF2joxQoyTNVduwLAFUzjoopuRJbJAReaKrNQKAZKL3uCMugWJA==",
       "license": "MIT",
       "dependencies": {
-        "micromark-util-character": "^2.0.0",
-        "micromark-util-sanitize-uri": "^2.0.0",
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "escape-string-regexp": "^5.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0",
+        "micromark-extension-frontmatter": "^2.0.0"
       },
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/micromark-extension-gfm-autolink-literal/node_modules/micromark-util-character": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
-      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/mdast-util-frontmatter/node_modules/escape-string-regexp": {
+      "version": "5.0.0",
+      "resolved": "https://registry.facebook.net/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz",
+      "integrity": "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==",
       "license": "MIT",
-      "dependencies": {
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/micromark-extension-gfm-autolink-literal/node_modules/micromark-util-symbol": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/micromark-extension-gfm-footnote": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-footnote/-/micromark-extension-gfm-footnote-2.1.0.tgz",
-      "integrity": "sha512-/yPhxI1ntnDNsiHtzLKYnE3vf9JZ6cAisqVDauhp4CEHxlb4uoOTxOCJ+9s51bIB8U1N1FJ1RXOKTIlD5B/gqw==",
+    "node_modules/mdast-util-gfm": {
+      "version": "3.1.0",
+      "resolved": "https://registry.facebook.net/mdast-util-gfm/-/mdast-util-gfm-3.1.0.tgz",
+      "integrity": "sha512-0ulfdQOM3ysHhCJ1p06l0b0VKlhU0wuQs3thxZQagjcjPrlFRqY215uZGHHJan9GEAXd9MbfPjFJz+qMkVR6zQ==",
       "license": "MIT",
       "dependencies": {
-        "devlop": "^1.0.0",
-        "micromark-core-commonmark": "^2.0.0",
-        "micromark-factory-space": "^2.0.0",
-        "micromark-util-character": "^2.0.0",
-        "micromark-util-normalize-identifier": "^2.0.0",
-        "micromark-util-sanitize-uri": "^2.0.0",
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-gfm-autolink-literal": "^2.0.0",
+        "mdast-util-gfm-footnote": "^2.0.0",
+        "mdast-util-gfm-strikethrough": "^2.0.0",
+        "mdast-util-gfm-table": "^2.0.0",
+        "mdast-util-gfm-task-list-item": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
       },
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/micromark-extension-gfm-footnote/node_modules/micromark-factory-space": {
+    "node_modules/mdast-util-gfm-autolink-literal": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz",
-      "integrity": "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+      "resolved": "https://registry.facebook.net/mdast-util-gfm-autolink-literal/-/mdast-util-gfm-autolink-literal-2.0.1.tgz",
+      "integrity": "sha512-5HVP2MKaP6L+G6YaxPNjuL0BPrq9orG3TsrZ9YXbA3vDw/ACI4MEsnoDpn6ZNm7GnZgtAcONJyPhOP8tNJQavQ==",
       "license": "MIT",
       "dependencies": {
-        "micromark-util-character": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "@types/mdast": "^4.0.0",
+        "ccount": "^2.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-find-and-replace": "^3.0.0",
+        "micromark-util-character": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/micromark-extension-gfm-footnote/node_modules/micromark-util-character": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
-      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/mdast-util-gfm-footnote": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/mdast-util-gfm-footnote/-/mdast-util-gfm-footnote-2.1.0.tgz",
+      "integrity": "sha512-sqpDWlsHn7Ac9GNZQMeUzPQSMzR6Wv0WKRNvQRg0KqHh02fpTz69Qc1QSseNX29bhz1ROIyNyxExfawVKTm1GQ==",
       "license": "MIT",
       "dependencies": {
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.1.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/micromark-extension-gfm-footnote/node_modules/micromark-util-symbol": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/micromark-extension-gfm-strikethrough": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-strikethrough/-/micromark-extension-gfm-strikethrough-2.1.0.tgz",
-      "integrity": "sha512-ADVjpOOkjz1hhkZLlBiYA9cR2Anf8F4HqZUO6e5eDcPQd0Txw5fxLzzxnEkSkfnD0wziSGiv7sYhk/ktvbf1uw==",
+    "node_modules/mdast-util-gfm-strikethrough": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/mdast-util-gfm-strikethrough/-/mdast-util-gfm-strikethrough-2.0.0.tgz",
+      "integrity": "sha512-mKKb915TF+OC5ptj5bJ7WFRPdYtuHv0yTRxK2tJvi+BDqbkiG7h7u/9SI89nRAYcmap2xHQL9D+QG/6wSrTtXg==",
       "license": "MIT",
       "dependencies": {
-        "devlop": "^1.0.0",
-        "micromark-util-chunked": "^2.0.0",
-        "micromark-util-classify-character": "^2.0.0",
-        "micromark-util-resolve-all": "^2.0.0",
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "@types/mdast": "^4.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
       },
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/micromark-extension-gfm-strikethrough/node_modules/micromark-util-symbol": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/micromark-extension-gfm-table": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-table/-/micromark-extension-gfm-table-2.1.0.tgz",
-      "integrity": "sha512-Ub2ncQv+fwD70/l4ou27b4YzfNaCJOvyX4HxXU15m7mpYY+rjuWzsLIPZHJL253Z643RpbcP1oeIJlQ/SKW67g==",
+    "node_modules/mdast-util-gfm-table": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/mdast-util-gfm-table/-/mdast-util-gfm-table-2.0.0.tgz",
+      "integrity": "sha512-78UEvebzz/rJIxLvE7ZtDd/vIQ0RHv+3Mh5DR96p7cS7HsBhYIICDBCu8csTNWNO6tBWfqXPWekRuj2FNOGOZg==",
       "license": "MIT",
       "dependencies": {
+        "@types/mdast": "^4.0.0",
         "devlop": "^1.0.0",
-        "micromark-factory-space": "^2.0.0",
-        "micromark-util-character": "^2.0.0",
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "markdown-table": "^3.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
       },
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/micromark-extension-gfm-table/node_modules/micromark-factory-space": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz",
-      "integrity": "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/mdast-util-gfm-task-list-item": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/mdast-util-gfm-task-list-item/-/mdast-util-gfm-task-list-item-2.0.0.tgz",
+      "integrity": "sha512-IrtvNvjxC1o06taBAVJznEnkiHxLFTzgonUdy8hzFVeDun0uTjxxrRGVaNFqkU1wJR3RBPEfsxmU6jDWPofrTQ==",
       "license": "MIT",
       "dependencies": {
-        "micromark-util-character": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/micromark-extension-gfm-table/node_modules/micromark-util-character": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
-      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/mdast-util-mdx": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/mdast-util-mdx/-/mdast-util-mdx-3.0.0.tgz",
+      "integrity": "sha512-JfbYLAW7XnYTTbUsmpu0kdBUVe+yKVJZBItEjwyYJiDJuZ9w4eeaqks4HQO+R7objWgS2ymV60GYpI14Ug554w==",
       "license": "MIT",
       "dependencies": {
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-mdx-expression": "^2.0.0",
+        "mdast-util-mdx-jsx": "^3.0.0",
+        "mdast-util-mdxjs-esm": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/micromark-extension-gfm-table/node_modules/micromark-util-symbol": {
+    "node_modules/mdast-util-mdx-expression": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/micromark-extension-gfm-tagfilter": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-tagfilter/-/micromark-extension-gfm-tagfilter-2.0.0.tgz",
-      "integrity": "sha512-xHlTOmuCSotIA8TW1mDIM6X2O1SiX5P9IuDtqGonFhEK0qgRI4yeC6vMxEV2dgyr2TiD+2PQ10o+cOhdVAcwfg==",
+      "resolved": "https://registry.facebook.net/mdast-util-mdx-expression/-/mdast-util-mdx-expression-2.0.1.tgz",
+      "integrity": "sha512-J6f+9hUp+ldTZqKRSg7Vw5V6MqjATc+3E4gf3CFNcuZNWD8XdyI6zQ8GqH7f8169MM6P7hMBRDVGnn7oHB9kXQ==",
       "license": "MIT",
       "dependencies": {
-        "micromark-util-types": "^2.0.0"
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
       },
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/micromark-extension-gfm-task-list-item": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-task-list-item/-/micromark-extension-gfm-task-list-item-2.1.0.tgz",
-      "integrity": "sha512-qIBZhqxqI6fjLDYFTBIa4eivDMnP+OZqsNwmQ3xNLE4Cxwc+zfQEfbs6tzAo2Hjq+bh6q5F+Z8/cksrLFYWQQw==",
+    "node_modules/mdast-util-mdx-jsx": {
+      "version": "3.2.0",
+      "resolved": "https://registry.facebook.net/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.2.0.tgz",
+      "integrity": "sha512-lj/z8v0r6ZtsN/cGNNtemmmfoLAFZnjMbNyLzBafjzikOM+glrjNHPlf6lQDOTccj9n5b0PPihEBbhneMyGs1Q==",
       "license": "MIT",
       "dependencies": {
-        "devlop": "^1.0.0",
-        "micromark-factory-space": "^2.0.0",
-        "micromark-util-character": "^2.0.0",
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "ccount": "^2.0.0",
+        "devlop": "^1.1.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0",
+        "parse-entities": "^4.0.0",
+        "stringify-entities": "^4.0.0",
+        "unist-util-stringify-position": "^4.0.0",
+        "vfile-message": "^4.0.0"
       },
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/micromark-extension-gfm-task-list-item/node_modules/micromark-factory-space": {
+    "node_modules/mdast-util-mdxjs-esm": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz",
-      "integrity": "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+      "resolved": "https://registry.facebook.net/mdast-util-mdxjs-esm/-/mdast-util-mdxjs-esm-2.0.1.tgz",
+      "integrity": "sha512-EcmOpxsZ96CvlP03NghtH1EsLtr0n9Tm4lPUJUBccV9RwUOneqSycg19n5HGzCf+10LozMRSObtVr3ee1WoHtg==",
       "license": "MIT",
       "dependencies": {
-        "micromark-util-character": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/micromark-extension-gfm-task-list-item/node_modules/micromark-util-character": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
-      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/mdast-util-phrasing": {
+      "version": "4.1.0",
+      "resolved": "https://registry.facebook.net/mdast-util-phrasing/-/mdast-util-phrasing-4.1.0.tgz",
+      "integrity": "sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w==",
       "license": "MIT",
       "dependencies": {
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "@types/mdast": "^4.0.0",
+        "unist-util-is": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/micromark-extension-gfm-task-list-item/node_modules/micromark-util-symbol": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/mdast-util-to-hast": {
+      "version": "13.2.1",
+      "resolved": "https://registry.facebook.net/mdast-util-to-hast/-/mdast-util-to-hast-13.2.1.tgz",
+      "integrity": "sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "@ungap/structured-clone": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "trim-lines": "^3.0.0",
+        "unist-util-position": "^5.0.0",
+        "unist-util-visit": "^5.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-to-markdown": {
+      "version": "2.1.2",
+      "resolved": "https://registry.facebook.net/mdast-util-to-markdown/-/mdast-util-to-markdown-2.1.2.tgz",
+      "integrity": "sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "longest-streak": "^3.0.0",
+        "mdast-util-phrasing": "^4.0.0",
+        "mdast-util-to-string": "^4.0.0",
+        "micromark-util-classify-character": "^2.0.0",
+        "micromark-util-decode-string": "^2.0.0",
+        "unist-util-visit": "^5.0.0",
+        "zwitch": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-to-string": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/mdast-util-to-string/-/mdast-util-to-string-4.0.0.tgz",
+      "integrity": "sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdn-data": {
+      "version": "2.0.30",
+      "resolved": "https://registry.facebook.net/mdn-data/-/mdn-data-2.0.30.tgz",
+      "integrity": "sha512-GaqWWShW4kv/G9IEucWScBx9G1/vsFZZJUO+tD26M8J8z3Kw5RDQjaoZe03YAClgeS/SWPOcb4nkFBTEi5DUEA==",
+      "license": "CC0-1.0"
+    },
+    "node_modules/media-typer": {
+      "version": "0.3.0",
+      "resolved": "https://registry.facebook.net/media-typer/-/media-typer-0.3.0.tgz",
+      "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/memfs": {
+      "version": "4.57.2",
+      "resolved": "https://registry.facebook.net/memfs/-/memfs-4.57.2.tgz",
+      "integrity": "sha512-2nWzSsJzrukurSDna4Z0WywuScK4Id3tSKejgu74u8KCdW4uNrseKRSIDg75C6Yw5ZRqBe0F0EtMNlTbUq8bAQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@jsonjoy.com/fs-core": "4.57.2",
+        "@jsonjoy.com/fs-fsa": "4.57.2",
+        "@jsonjoy.com/fs-node": "4.57.2",
+        "@jsonjoy.com/fs-node-builtins": "4.57.2",
+        "@jsonjoy.com/fs-node-to-fsa": "4.57.2",
+        "@jsonjoy.com/fs-node-utils": "4.57.2",
+        "@jsonjoy.com/fs-print": "4.57.2",
+        "@jsonjoy.com/fs-snapshot": "4.57.2",
+        "@jsonjoy.com/json-pack": "^1.11.0",
+        "@jsonjoy.com/util": "^1.9.0",
+        "glob-to-regex.js": "^1.0.1",
+        "thingies": "^2.5.0",
+        "tree-dump": "^1.0.3",
+        "tslib": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/streamich"
+      },
+      "peerDependencies": {
+        "tslib": "2"
+      }
+    },
+    "node_modules/merge-descriptors": {
+      "version": "1.0.3",
+      "resolved": "https://registry.facebook.net/merge-descriptors/-/merge-descriptors-1.0.3.tgz",
+      "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/merge-stream": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/merge-stream/-/merge-stream-2.0.0.tgz",
+      "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==",
       "license": "MIT"
     },
-    "node_modules/micromark-extension-mdx-expression": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/micromark-extension-mdx-expression/-/micromark-extension-mdx-expression-3.0.0.tgz",
-      "integrity": "sha512-sI0nwhUDz97xyzqJAbHQhp5TfaxEvZZZ2JDqUo+7NvyIYG6BZ5CPPqj2ogUoPJlmXHBnyZUzISg9+oUmU6tUjQ==",
+    "node_modules/merge2": {
+      "version": "1.4.1",
+      "resolved": "https://registry.facebook.net/merge2/-/merge2-1.4.1.tgz",
+      "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/methods": {
+      "version": "1.1.2",
+      "resolved": "https://registry.facebook.net/methods/-/methods-1.1.2.tgz",
+      "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/micromark": {
+      "version": "4.0.2",
+      "resolved": "https://registry.facebook.net/micromark/-/micromark-4.0.2.tgz",
+      "integrity": "sha512-zpe98Q6kvavpCr1NPVSCMebCKfD7CA2NqZ+rykeNhONIJBpc1tFKt9hucLGwha3jNTNI8lHpctWJWoimVF4PfA==",
       "funding": [
         {
           "type": "GitHub Sponsors",
@@ -11308,20 +11145,29 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "@types/estree": "^1.0.0",
+        "@types/debug": "^4.0.0",
+        "debug": "^4.0.0",
+        "decode-named-character-reference": "^1.0.0",
         "devlop": "^1.0.0",
-        "micromark-factory-mdx-expression": "^2.0.0",
+        "micromark-core-commonmark": "^2.0.0",
         "micromark-factory-space": "^2.0.0",
         "micromark-util-character": "^2.0.0",
-        "micromark-util-events-to-acorn": "^2.0.0",
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-combine-extensions": "^2.0.0",
+        "micromark-util-decode-numeric-character-reference": "^2.0.0",
+        "micromark-util-encode": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-resolve-all": "^2.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "micromark-util-subtokenize": "^2.0.0",
         "micromark-util-symbol": "^2.0.0",
         "micromark-util-types": "^2.0.0"
       }
     },
-    "node_modules/micromark-extension-mdx-expression/node_modules/micromark-factory-space": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz",
-      "integrity": "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==",
+    "node_modules/micromark-core-commonmark": {
+      "version": "2.0.3",
+      "resolved": "https://registry.facebook.net/micromark-core-commonmark/-/micromark-core-commonmark-2.0.3.tgz",
+      "integrity": "sha512-RDBrHEMSxVFLg6xvnXmb1Ayr2WzLAWjeSATAoxwKYJV94TeNavgoIdA0a9ytzDSVzBy2YKFK+emCPOEibLeCrg==",
       "funding": [
         {
           "type": "GitHub Sponsors",
@@ -11334,113 +11180,184 @@
       ],
       "license": "MIT",
       "dependencies": {
+        "decode-named-character-reference": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-factory-destination": "^2.0.0",
+        "micromark-factory-label": "^2.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-factory-title": "^2.0.0",
+        "micromark-factory-whitespace": "^2.0.0",
         "micromark-util-character": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
-      }
-    },
-    "node_modules/micromark-extension-mdx-expression/node_modules/micromark-util-character": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
-      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-classify-character": "^2.0.0",
+        "micromark-util-html-tag-name": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-resolve-all": "^2.0.0",
+        "micromark-util-subtokenize": "^2.0.0",
         "micromark-util-symbol": "^2.0.0",
         "micromark-util-types": "^2.0.0"
       }
     },
-    "node_modules/micromark-extension-mdx-expression/node_modules/micromark-util-symbol": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/micromark-extension-mdx-jsx": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-extension-mdx-jsx/-/micromark-extension-mdx-jsx-3.0.1.tgz",
-      "integrity": "sha512-vNuFb9czP8QCtAQcEJn0UJQJZA8Dk6DXKBqx+bg/w0WGuSxDxNr7hErW89tHUY31dUW4NqEOWwmEUNhjTFmHkg==",
+    "node_modules/micromark-extension-directive": {
+      "version": "3.0.2",
+      "resolved": "https://registry.facebook.net/micromark-extension-directive/-/micromark-extension-directive-3.0.2.tgz",
+      "integrity": "sha512-wjcXHgk+PPdmvR58Le9d7zQYWy+vKEU9Se44p2CrCDPiLr2FMyiT4Fyb5UFKFC66wGB3kPlgD7q3TnoqPS7SZA==",
       "license": "MIT",
       "dependencies": {
-        "@types/acorn": "^4.0.0",
-        "@types/estree": "^1.0.0",
         "devlop": "^1.0.0",
-        "estree-util-is-identifier-name": "^3.0.0",
-        "micromark-factory-mdx-expression": "^2.0.0",
         "micromark-factory-space": "^2.0.0",
+        "micromark-factory-whitespace": "^2.0.0",
         "micromark-util-character": "^2.0.0",
-        "micromark-util-events-to-acorn": "^2.0.0",
         "micromark-util-symbol": "^2.0.0",
         "micromark-util-types": "^2.0.0",
-        "vfile-message": "^4.0.0"
+        "parse-entities": "^4.0.0"
       },
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/micromark-extension-mdx-jsx/node_modules/micromark-factory-space": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz",
-      "integrity": "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/micromark-extension-frontmatter": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/micromark-extension-frontmatter/-/micromark-extension-frontmatter-2.0.0.tgz",
+      "integrity": "sha512-C4AkuM3dA58cgZha7zVnuVxBhDsbttIMiytjgsM2XbHAB2faRVaHRle40558FBN+DJcrLNCoqG5mlrpdU4cRtg==",
       "license": "MIT",
       "dependencies": {
+        "fault": "^2.0.0",
         "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
         "micromark-util-types": "^2.0.0"
-      }
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/micromark-extension-gfm/-/micromark-extension-gfm-3.0.0.tgz",
+      "integrity": "sha512-vsKArQsicm7t0z2GugkCKtZehqUm31oeGBV/KVSorWSy8ZlNAv7ytjFhvaryUiCUJYqs+NoE6AFhpQvBTM6Q4w==",
+      "license": "MIT",
+      "dependencies": {
+        "micromark-extension-gfm-autolink-literal": "^2.0.0",
+        "micromark-extension-gfm-footnote": "^2.0.0",
+        "micromark-extension-gfm-strikethrough": "^2.0.0",
+        "micromark-extension-gfm-table": "^2.0.0",
+        "micromark-extension-gfm-tagfilter": "^2.0.0",
+        "micromark-extension-gfm-task-list-item": "^2.0.0",
+        "micromark-util-combine-extensions": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-autolink-literal": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/micromark-extension-gfm-autolink-literal/-/micromark-extension-gfm-autolink-literal-2.1.0.tgz",
+      "integrity": "sha512-oOg7knzhicgQ3t4QCjCWgTmfNhvQbDDnJeVu9v81r7NltNCVmhPy1fJRX27pISafdjL+SVc4d3l48Gb6pbRypw==",
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-footnote": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/micromark-extension-gfm-footnote/-/micromark-extension-gfm-footnote-2.1.0.tgz",
+      "integrity": "sha512-/yPhxI1ntnDNsiHtzLKYnE3vf9JZ6cAisqVDauhp4CEHxlb4uoOTxOCJ+9s51bIB8U1N1FJ1RXOKTIlD5B/gqw==",
+      "license": "MIT",
+      "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-core-commonmark": "^2.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-strikethrough": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/micromark-extension-gfm-strikethrough/-/micromark-extension-gfm-strikethrough-2.1.0.tgz",
+      "integrity": "sha512-ADVjpOOkjz1hhkZLlBiYA9cR2Anf8F4HqZUO6e5eDcPQd0Txw5fxLzzxnEkSkfnD0wziSGiv7sYhk/ktvbf1uw==",
+      "license": "MIT",
+      "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-classify-character": "^2.0.0",
+        "micromark-util-resolve-all": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
     },
-    "node_modules/micromark-extension-mdx-jsx/node_modules/micromark-util-character": {
+    "node_modules/micromark-extension-gfm-table": {
       "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
-      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+      "resolved": "https://registry.facebook.net/micromark-extension-gfm-table/-/micromark-extension-gfm-table-2.1.1.tgz",
+      "integrity": "sha512-t2OU/dXXioARrC6yWfJ4hqB7rct14e8f7m0cbI5hUmDyyIlwv5vEtooptH8INkbLzOatzKuVbQmAYcbWoyz6Dg==",
       "license": "MIT",
       "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
         "micromark-util-symbol": "^2.0.0",
         "micromark-util-types": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/micromark-extension-mdx-jsx/node_modules/micromark-util-symbol": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
+    "node_modules/micromark-extension-gfm-tagfilter": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/micromark-extension-gfm-tagfilter/-/micromark-extension-gfm-tagfilter-2.0.0.tgz",
+      "integrity": "sha512-xHlTOmuCSotIA8TW1mDIM6X2O1SiX5P9IuDtqGonFhEK0qgRI4yeC6vMxEV2dgyr2TiD+2PQ10o+cOhdVAcwfg==",
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-types": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-task-list-item": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/micromark-extension-gfm-task-list-item/-/micromark-extension-gfm-task-list-item-2.1.0.tgz",
+      "integrity": "sha512-qIBZhqxqI6fjLDYFTBIa4eivDMnP+OZqsNwmQ3xNLE4Cxwc+zfQEfbs6tzAo2Hjq+bh6q5F+Z8/cksrLFYWQQw==",
+      "license": "MIT",
+      "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-mdx-expression": {
+      "version": "3.0.1",
+      "resolved": "https://registry.facebook.net/micromark-extension-mdx-expression/-/micromark-extension-mdx-expression-3.0.1.tgz",
+      "integrity": "sha512-dD/ADLJ1AeMvSAKBwO22zG22N4ybhe7kFIZ3LsDI0GlsNr2A3KYxb0LdC1u5rj4Nw+CHKY0RVdnHX8vj8ejm4Q==",
       "funding": [
         {
           "type": "GitHub Sponsors",
@@ -11451,11 +11368,43 @@
           "url": "https://opencollective.com/unified"
         }
       ],
-      "license": "MIT"
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-factory-mdx-expression": "^2.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-events-to-acorn": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-extension-mdx-jsx": {
+      "version": "3.0.2",
+      "resolved": "https://registry.facebook.net/micromark-extension-mdx-jsx/-/micromark-extension-mdx-jsx-3.0.2.tgz",
+      "integrity": "sha512-e5+q1DjMh62LZAJOnDraSSbDMvGJ8x3cbjygy2qFEi7HCeUT4BDKCvMozPozcD6WmOt6sVvYDNBKhFSz3kjOVQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0",
+        "devlop": "^1.0.0",
+        "estree-util-is-identifier-name": "^3.0.0",
+        "micromark-factory-mdx-expression": "^2.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-events-to-acorn": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0",
+        "vfile-message": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
     },
     "node_modules/micromark-extension-mdx-md": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/micromark-extension-mdx-md/-/micromark-extension-mdx-md-2.0.0.tgz",
+      "resolved": "https://registry.facebook.net/micromark-extension-mdx-md/-/micromark-extension-mdx-md-2.0.0.tgz",
       "integrity": "sha512-EpAiszsB3blw4Rpba7xTOUptcFeBFi+6PY8VnJ2hhimH+vCQDirWgsMpz7w1XcZE7LVrSAUGb9VJpG9ghlYvYQ==",
       "license": "MIT",
       "dependencies": {
@@ -11468,7 +11417,7 @@
     },
     "node_modules/micromark-extension-mdxjs": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/micromark-extension-mdxjs/-/micromark-extension-mdxjs-3.0.0.tgz",
+      "resolved": "https://registry.facebook.net/micromark-extension-mdxjs/-/micromark-extension-mdxjs-3.0.0.tgz",
       "integrity": "sha512-A873fJfhnJ2siZyUrJ31l34Uqwy4xIFmvPY1oj+Ean5PHcPBYzEsvqvWGaWcfEIr11O5Dlw3p2y0tZWpKHDejQ==",
       "license": "MIT",
       "dependencies": {
@@ -11488,7 +11437,7 @@
     },
     "node_modules/micromark-extension-mdxjs-esm": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/micromark-extension-mdxjs-esm/-/micromark-extension-mdxjs-esm-3.0.0.tgz",
+      "resolved": "https://registry.facebook.net/micromark-extension-mdxjs-esm/-/micromark-extension-mdxjs-esm-3.0.0.tgz",
       "integrity": "sha512-DJFl4ZqkErRpq/dAPyeWp15tGrcrrJho1hKK5uBS70BCtfrIFg81sqcTVu3Ta+KD1Tk5vAtBNElWxtAa+m8K9A==",
       "license": "MIT",
       "dependencies": {
@@ -11507,10 +11456,10 @@
         "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/micromark-extension-mdxjs-esm/node_modules/micromark-util-character": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
-      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
+    "node_modules/micromark-factory-destination": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/micromark-factory-destination/-/micromark-factory-destination-2.0.1.tgz",
+      "integrity": "sha512-Xe6rDdJlkmbFRExpTOmRj9N3MaWmbAgdpSrBQvCFqhezUn4AHqJHbaEnfbVYYiexVSs//tqOdY/DxhjdCiJnIA==",
       "funding": [
         {
           "type": "GitHub Sponsors",
@@ -11523,14 +11472,15 @@
       ],
       "license": "MIT",
       "dependencies": {
+        "micromark-util-character": "^2.0.0",
         "micromark-util-symbol": "^2.0.0",
         "micromark-util-types": "^2.0.0"
       }
     },
-    "node_modules/micromark-extension-mdxjs-esm/node_modules/micromark-util-symbol": {
+    "node_modules/micromark-factory-label": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
+      "resolved": "https://registry.facebook.net/micromark-factory-label/-/micromark-factory-label-2.0.1.tgz",
+      "integrity": "sha512-VFMekyQExqIW7xIChcXn4ok29YE3rnuyveW3wZQWWqF4Nv9Wk5rgJ99KzPvHjkmPXF93FXIbBp6YdW3t71/7Vg==",
       "funding": [
         {
           "type": "GitHub Sponsors",
@@ -11541,12 +11491,18 @@
           "url": "https://opencollective.com/unified"
         }
       ],
-      "license": "MIT"
+      "license": "MIT",
+      "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
     },
-    "node_modules/micromark-factory-destination": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-factory-destination/-/micromark-factory-destination-2.0.1.tgz",
-      "integrity": "sha512-Xe6rDdJlkmbFRExpTOmRj9N3MaWmbAgdpSrBQvCFqhezUn4AHqJHbaEnfbVYYiexVSs//tqOdY/DxhjdCiJnIA==",
+    "node_modules/micromark-factory-mdx-expression": {
+      "version": "2.0.3",
+      "resolved": "https://registry.facebook.net/micromark-factory-mdx-expression/-/micromark-factory-mdx-expression-2.0.3.tgz",
+      "integrity": "sha512-kQnEtA3vzucU2BkrIa8/VaSAsP+EJ3CKOvhMuJgOEGg9KDC6OAY6nSnNDVRiVNRqj7Y4SlSzcStaH/5jge8JdQ==",
       "funding": [
         {
           "type": "GitHub Sponsors",
@@ -11559,15 +11515,21 @@
       ],
       "license": "MIT",
       "dependencies": {
+        "@types/estree": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-factory-space": "^2.0.0",
         "micromark-util-character": "^2.0.0",
+        "micromark-util-events-to-acorn": "^2.0.0",
         "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "micromark-util-types": "^2.0.0",
+        "unist-util-position-from-estree": "^2.0.0",
+        "vfile-message": "^4.0.0"
       }
     },
-    "node_modules/micromark-factory-destination/node_modules/micromark-util-character": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
-      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
+    "node_modules/micromark-factory-space": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz",
+      "integrity": "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==",
       "funding": [
         {
           "type": "GitHub Sponsors",
@@ -11580,14 +11542,14 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
         "micromark-util-types": "^2.0.0"
       }
     },
-    "node_modules/micromark-factory-destination/node_modules/micromark-util-symbol": {
+    "node_modules/micromark-factory-title": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
+      "resolved": "https://registry.facebook.net/micromark-factory-title/-/micromark-factory-title-2.0.1.tgz",
+      "integrity": "sha512-5bZ+3CjhAd9eChYTHsjy6TGxpOFSKgKKJPJxr293jTbfry2KDoWkhBb6TcPVB4NmzaPhMs1Frm9AZH7OD4Cjzw==",
       "funding": [
         {
           "type": "GitHub Sponsors",
@@ -11598,12 +11560,18 @@
           "url": "https://opencollective.com/unified"
         }
       ],
-      "license": "MIT"
+      "license": "MIT",
+      "dependencies": {
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
     },
-    "node_modules/micromark-factory-label": {
+    "node_modules/micromark-factory-whitespace": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-factory-label/-/micromark-factory-label-2.0.1.tgz",
-      "integrity": "sha512-VFMekyQExqIW7xIChcXn4ok29YE3rnuyveW3wZQWWqF4Nv9Wk5rgJ99KzPvHjkmPXF93FXIbBp6YdW3t71/7Vg==",
+      "resolved": "https://registry.facebook.net/micromark-factory-whitespace/-/micromark-factory-whitespace-2.0.1.tgz",
+      "integrity": "sha512-Ob0nuZ3PKt/n0hORHyvoD9uZhr+Za8sFoP+OnMcnWK5lngSzALgQYKMr9RJVOWLqQYuyn6ulqGWSXdwf6F80lQ==",
       "funding": [
         {
           "type": "GitHub Sponsors",
@@ -11616,15 +11584,15 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "devlop": "^1.0.0",
+        "micromark-factory-space": "^2.0.0",
         "micromark-util-character": "^2.0.0",
         "micromark-util-symbol": "^2.0.0",
         "micromark-util-types": "^2.0.0"
       }
     },
-    "node_modules/micromark-factory-label/node_modules/micromark-util-character": {
+    "node_modules/micromark-util-character": {
       "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
+      "resolved": "https://registry.facebook.net/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
       "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
       "funding": [
         {
@@ -11642,10 +11610,10 @@
         "micromark-util-types": "^2.0.0"
       }
     },
-    "node_modules/micromark-factory-label/node_modules/micromark-util-symbol": {
+    "node_modules/micromark-util-chunked": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
+      "resolved": "https://registry.facebook.net/micromark-util-chunked/-/micromark-util-chunked-2.0.1.tgz",
+      "integrity": "sha512-QUNFEOPELfmvv+4xiNg2sRYeS/P84pTW0TCgP5zc9FpXetHY0ab7SxKyAQCNCc1eK0459uoLI1y5oO5Vc1dbhA==",
       "funding": [
         {
           "type": "GitHub Sponsors",
@@ -11656,12 +11624,15 @@
           "url": "https://opencollective.com/unified"
         }
       ],
-      "license": "MIT"
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0"
+      }
     },
-    "node_modules/micromark-factory-mdx-expression": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/micromark-factory-mdx-expression/-/micromark-factory-mdx-expression-2.0.2.tgz",
-      "integrity": "sha512-5E5I2pFzJyg2CtemqAbcyCktpHXuJbABnsb32wX2U8IQKhhVFBqkcZR5LRm1WVoFqa4kTueZK4abep7wdo9nrw==",
+    "node_modules/micromark-util-classify-character": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/micromark-util-classify-character/-/micromark-util-classify-character-2.0.1.tgz",
+      "integrity": "sha512-K0kHzM6afW/MbeWYWLjoHQv1sgg2Q9EccHEDzSkxiP/EaagNzCm7T/WMKZ3rjMbvIpvBiZgwR3dKMygtA4mG1Q==",
       "funding": [
         {
           "type": "GitHub Sponsors",
@@ -11674,21 +11645,15 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "@types/estree": "^1.0.0",
-        "devlop": "^1.0.0",
-        "micromark-factory-space": "^2.0.0",
         "micromark-util-character": "^2.0.0",
-        "micromark-util-events-to-acorn": "^2.0.0",
         "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0",
-        "unist-util-position-from-estree": "^2.0.0",
-        "vfile-message": "^4.0.0"
+        "micromark-util-types": "^2.0.0"
       }
     },
-    "node_modules/micromark-factory-mdx-expression/node_modules/micromark-factory-space": {
+    "node_modules/micromark-util-combine-extensions": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz",
-      "integrity": "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==",
+      "resolved": "https://registry.facebook.net/micromark-util-combine-extensions/-/micromark-util-combine-extensions-2.0.1.tgz",
+      "integrity": "sha512-OnAnH8Ujmy59JcyZw8JSbK9cGpdVY44NKgSM7E9Eh7DiLS2E9RNQf0dONaGDzEG9yjEl5hcqeIsj4hfRkLH/Bg==",
       "funding": [
         {
           "type": "GitHub Sponsors",
@@ -11701,14 +11666,14 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "micromark-util-character": "^2.0.0",
+        "micromark-util-chunked": "^2.0.0",
         "micromark-util-types": "^2.0.0"
       }
     },
-    "node_modules/micromark-factory-mdx-expression/node_modules/micromark-util-character": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
-      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
+    "node_modules/micromark-util-decode-numeric-character-reference": {
+      "version": "2.0.2",
+      "resolved": "https://registry.facebook.net/micromark-util-decode-numeric-character-reference/-/micromark-util-decode-numeric-character-reference-2.0.2.tgz",
+      "integrity": "sha512-ccUbYk6CwVdkmCQMyr64dXz42EfHGkPQlBj5p7YVGzq8I7CtjXZJrubAYezf7Rp+bjPseiROqe7G6foFd+lEuw==",
       "funding": [
         {
           "type": "GitHub Sponsors",
@@ -11721,30 +11686,13 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "micromark-util-symbol": "^2.0.0"
       }
     },
-    "node_modules/micromark-factory-mdx-expression/node_modules/micromark-util-symbol": {
+    "node_modules/micromark-util-decode-string": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/micromark-factory-space": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-1.1.0.tgz",
-      "integrity": "sha512-cRzEj7c0OL4Mw2v6nwzttyOZe8XY/Z8G0rzmWQZTBi/jjwyw/U4uqKtUORXQrR5bAZZnbTI/feRV/R7hc4jQYQ==",
+      "resolved": "https://registry.facebook.net/micromark-util-decode-string/-/micromark-util-decode-string-2.0.1.tgz",
+      "integrity": "sha512-nDV/77Fj6eH1ynwscYTOsbK7rR//Uj0bZXBwJZRfaLEJ1iGBR6kIfNmlNqaqJf649EP0F3NWNdeJi03elllNUQ==",
       "funding": [
         {
           "type": "GitHub Sponsors",
@@ -11757,14 +11705,16 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "micromark-util-character": "^1.0.0",
-        "micromark-util-types": "^1.0.0"
+        "decode-named-character-reference": "^1.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-decode-numeric-character-reference": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0"
       }
     },
-    "node_modules/micromark-factory-space/node_modules/micromark-util-types": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-1.1.0.tgz",
-      "integrity": "sha512-ukRBgie8TIAcacscVHSiddHjO4k/q3pnedmzMQ4iwDcK0FtFCohKOlFbaOL/mPgfnPsL3C1ZyxJa4sbWrBl3jg==",
+    "node_modules/micromark-util-encode": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/micromark-util-encode/-/micromark-util-encode-2.0.1.tgz",
+      "integrity": "sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==",
       "funding": [
         {
           "type": "GitHub Sponsors",
@@ -11777,10 +11727,10 @@
       ],
       "license": "MIT"
     },
-    "node_modules/micromark-factory-title": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-factory-title/-/micromark-factory-title-2.0.1.tgz",
-      "integrity": "sha512-5bZ+3CjhAd9eChYTHsjy6TGxpOFSKgKKJPJxr293jTbfry2KDoWkhBb6TcPVB4NmzaPhMs1Frm9AZH7OD4Cjzw==",
+    "node_modules/micromark-util-events-to-acorn": {
+      "version": "2.0.3",
+      "resolved": "https://registry.facebook.net/micromark-util-events-to-acorn/-/micromark-util-events-to-acorn-2.0.3.tgz",
+      "integrity": "sha512-jmsiEIiZ1n7X1Rr5k8wVExBQCg5jy4UXVADItHmNk1zkwEVhBuIUKRu3fqv+hs4nxLISi2DQGlqIOGiFxgbfHg==",
       "funding": [
         {
           "type": "GitHub Sponsors",
@@ -11793,16 +11743,19 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "micromark-factory-space": "^2.0.0",
-        "micromark-util-character": "^2.0.0",
+        "@types/estree": "^1.0.0",
+        "@types/unist": "^3.0.0",
+        "devlop": "^1.0.0",
+        "estree-util-visit": "^2.0.0",
         "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "micromark-util-types": "^2.0.0",
+        "vfile-message": "^4.0.0"
       }
     },
-    "node_modules/micromark-factory-title/node_modules/micromark-factory-space": {
+    "node_modules/micromark-util-html-tag-name": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz",
-      "integrity": "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==",
+      "resolved": "https://registry.facebook.net/micromark-util-html-tag-name/-/micromark-util-html-tag-name-2.0.1.tgz",
+      "integrity": "sha512-2cNEiYDhCWKI+Gs9T0Tiysk136SnR13hhO8yW6BGNyhOC4qYFnwF1nKfD3HFAIXA5c45RrIG1ub11GiXeYd1xA==",
       "funding": [
         {
           "type": "GitHub Sponsors",
@@ -11813,16 +11766,12 @@
           "url": "https://opencollective.com/unified"
         }
       ],
-      "license": "MIT",
-      "dependencies": {
-        "micromark-util-character": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
-      }
+      "license": "MIT"
     },
-    "node_modules/micromark-factory-title/node_modules/micromark-util-character": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
-      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
+    "node_modules/micromark-util-normalize-identifier": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/micromark-util-normalize-identifier/-/micromark-util-normalize-identifier-2.0.1.tgz",
+      "integrity": "sha512-sxPqmo70LyARJs0w2UclACPUUEqltCkJ6PhKdMIDuJ3gSf/Q+/GIe3WKl0Ijb/GyH9lOpUkRAO2wp0GVkLvS9Q==",
       "funding": [
         {
           "type": "GitHub Sponsors",
@@ -11835,30 +11784,13 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "micromark-util-symbol": "^2.0.0"
       }
     },
-    "node_modules/micromark-factory-title/node_modules/micromark-util-symbol": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/micromark-factory-whitespace": {
+    "node_modules/micromark-util-resolve-all": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-factory-whitespace/-/micromark-factory-whitespace-2.0.1.tgz",
-      "integrity": "sha512-Ob0nuZ3PKt/n0hORHyvoD9uZhr+Za8sFoP+OnMcnWK5lngSzALgQYKMr9RJVOWLqQYuyn6ulqGWSXdwf6F80lQ==",
+      "resolved": "https://registry.facebook.net/micromark-util-resolve-all/-/micromark-util-resolve-all-2.0.1.tgz",
+      "integrity": "sha512-VdQyxFWFT2/FGJgwQnJYbe1jjQoNTS4RjglmSjTUlpUMa95Htx9NHeYW4rGDJzbjvCsl9eLjMQwGeElsqmzcHg==",
       "funding": [
         {
           "type": "GitHub Sponsors",
@@ -11871,16 +11803,13 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "micromark-factory-space": "^2.0.0",
-        "micromark-util-character": "^2.0.0",
-        "micromark-util-symbol": "^2.0.0",
         "micromark-util-types": "^2.0.0"
       }
     },
-    "node_modules/micromark-factory-whitespace/node_modules/micromark-factory-space": {
+    "node_modules/micromark-util-sanitize-uri": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz",
-      "integrity": "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==",
+      "resolved": "https://registry.facebook.net/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.1.tgz",
+      "integrity": "sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==",
       "funding": [
         {
           "type": "GitHub Sponsors",
@@ -11894,13 +11823,14 @@
       "license": "MIT",
       "dependencies": {
         "micromark-util-character": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "micromark-util-encode": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0"
       }
     },
-    "node_modules/micromark-factory-whitespace/node_modules/micromark-util-character": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
-      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
+    "node_modules/micromark-util-subtokenize": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/micromark-util-subtokenize/-/micromark-util-subtokenize-2.1.0.tgz",
+      "integrity": "sha512-XQLu552iSctvnEcgXw6+Sx75GflAPNED1qx7eBJ+wydBb2KCbRZe+NwvIEEMM83uml1+2WSXpBAcp9IUCgCYWA==",
       "funding": [
         {
           "type": "GitHub Sponsors",
@@ -11913,13 +11843,15 @@
       ],
       "license": "MIT",
       "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-util-chunked": "^2.0.0",
         "micromark-util-symbol": "^2.0.0",
         "micromark-util-types": "^2.0.0"
       }
     },
-    "node_modules/micromark-factory-whitespace/node_modules/micromark-util-symbol": {
+    "node_modules/micromark-util-symbol": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
+      "resolved": "https://registry.facebook.net/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
       "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
       "funding": [
         {
@@ -11933,30 +11865,10 @@
       ],
       "license": "MIT"
     },
-    "node_modules/micromark-util-character": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-1.2.0.tgz",
-      "integrity": "sha512-lXraTwcX3yH/vMDaFWCQJP1uIszLVebzUa3ZHdrgxr7KEU/9mL4mVgCpGbyhvNLNlauROiNUq7WN5u7ndbY6xg==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "micromark-util-symbol": "^1.0.0",
-        "micromark-util-types": "^1.0.0"
-      }
-    },
-    "node_modules/micromark-util-character/node_modules/micromark-util-types": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-1.1.0.tgz",
-      "integrity": "sha512-ukRBgie8TIAcacscVHSiddHjO4k/q3pnedmzMQ4iwDcK0FtFCohKOlFbaOL/mPgfnPsL3C1ZyxJa4sbWrBl3jg==",
+    "node_modules/micromark-util-types": {
+      "version": "2.0.2",
+      "resolved": "https://registry.facebook.net/micromark-util-types/-/micromark-util-types-2.0.2.tgz",
+      "integrity": "sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA==",
       "funding": [
         {
           "type": "GitHub Sponsors",
@@ -11969,891 +11881,366 @@
       ],
       "license": "MIT"
     },
-    "node_modules/micromark-util-chunked": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-chunked/-/micromark-util-chunked-2.0.1.tgz",
-      "integrity": "sha512-QUNFEOPELfmvv+4xiNg2sRYeS/P84pTW0TCgP5zc9FpXetHY0ab7SxKyAQCNCc1eK0459uoLI1y5oO5Vc1dbhA==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/micromatch": {
+      "version": "4.0.8",
+      "resolved": "https://registry.facebook.net/micromatch/-/micromatch-4.0.8.tgz",
+      "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
       "license": "MIT",
       "dependencies": {
-        "micromark-util-symbol": "^2.0.0"
+        "braces": "^3.0.3",
+        "picomatch": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=8.6"
       }
     },
-    "node_modules/micromark-util-chunked/node_modules/micromark-util-symbol": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT"
+    "node_modules/mime": {
+      "version": "1.6.0",
+      "resolved": "https://registry.facebook.net/mime/-/mime-1.6.0.tgz",
+      "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
+      "license": "MIT",
+      "bin": {
+        "mime": "cli.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
     },
-    "node_modules/micromark-util-classify-character": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-classify-character/-/micromark-util-classify-character-2.0.1.tgz",
-      "integrity": "sha512-K0kHzM6afW/MbeWYWLjoHQv1sgg2Q9EccHEDzSkxiP/EaagNzCm7T/WMKZ3rjMbvIpvBiZgwR3dKMygtA4mG1Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/mime-db": {
+      "version": "1.54.0",
+      "resolved": "https://registry.facebook.net/mime-db/-/mime-db-1.54.0.tgz",
+      "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==",
       "license": "MIT",
-      "dependencies": {
-        "micromark-util-character": "^2.0.0",
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+      "engines": {
+        "node": ">= 0.6"
       }
     },
-    "node_modules/micromark-util-classify-character/node_modules/micromark-util-character": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
-      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.facebook.net/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
       "license": "MIT",
       "dependencies": {
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
       }
     },
-    "node_modules/micromark-util-classify-character/node_modules/micromark-util-symbol": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/micromark-util-combine-extensions": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-combine-extensions/-/micromark-util-combine-extensions-2.0.1.tgz",
-      "integrity": "sha512-OnAnH8Ujmy59JcyZw8JSbK9cGpdVY44NKgSM7E9Eh7DiLS2E9RNQf0dONaGDzEG9yjEl5hcqeIsj4hfRkLH/Bg==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/mime-types/node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.facebook.net/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
       "license": "MIT",
-      "dependencies": {
-        "micromark-util-chunked": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+      "engines": {
+        "node": ">= 0.6"
       }
     },
-    "node_modules/micromark-util-decode-numeric-character-reference": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/micromark-util-decode-numeric-character-reference/-/micromark-util-decode-numeric-character-reference-2.0.2.tgz",
-      "integrity": "sha512-ccUbYk6CwVdkmCQMyr64dXz42EfHGkPQlBj5p7YVGzq8I7CtjXZJrubAYezf7Rp+bjPseiROqe7G6foFd+lEuw==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/mimic-fn": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/mimic-fn/-/mimic-fn-2.1.0.tgz",
+      "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==",
       "license": "MIT",
-      "dependencies": {
-        "micromark-util-symbol": "^2.0.0"
+      "engines": {
+        "node": ">=6"
       }
     },
-    "node_modules/micromark-util-decode-numeric-character-reference/node_modules/micromark-util-symbol": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/micromark-util-decode-string": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-decode-string/-/micromark-util-decode-string-2.0.1.tgz",
-      "integrity": "sha512-nDV/77Fj6eH1ynwscYTOsbK7rR//Uj0bZXBwJZRfaLEJ1iGBR6kIfNmlNqaqJf649EP0F3NWNdeJi03elllNUQ==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/mimic-response": {
+      "version": "3.1.0",
+      "resolved": "https://registry.facebook.net/mimic-response/-/mimic-response-3.1.0.tgz",
+      "integrity": "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==",
       "license": "MIT",
-      "dependencies": {
-        "decode-named-character-reference": "^1.0.0",
-        "micromark-util-character": "^2.0.0",
-        "micromark-util-decode-numeric-character-reference": "^2.0.0",
-        "micromark-util-symbol": "^2.0.0"
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/micromark-util-decode-string/node_modules/micromark-util-character": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
-      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/mini-css-extract-plugin": {
+      "version": "2.10.2",
+      "resolved": "https://registry.facebook.net/mini-css-extract-plugin/-/mini-css-extract-plugin-2.10.2.tgz",
+      "integrity": "sha512-AOSS0IdEB95ayVkxn5oGzNQwqAi2J0Jb/kKm43t7H73s8+f5873g0yuj0PNvK4dO75mu5DHg4nlgp4k6Kga8eg==",
       "license": "MIT",
       "dependencies": {
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "schema-utils": "^4.0.0",
+        "tapable": "^2.2.1"
+      },
+      "engines": {
+        "node": ">= 12.13.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
+      },
+      "peerDependencies": {
+        "webpack": "^5.0.0"
       }
     },
-    "node_modules/micromark-util-decode-string/node_modules/micromark-util-symbol": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT"
+    "node_modules/minimalistic-assert": {
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz",
+      "integrity": "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==",
+      "license": "ISC"
     },
-    "node_modules/micromark-util-encode": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-encode/-/micromark-util-encode-2.0.1.tgz",
-      "integrity": "sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT"
+    "node_modules/minimatch": {
+      "version": "3.1.5",
+      "resolved": "https://registry.facebook.net/minimatch/-/minimatch-3.1.5.tgz",
+      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
     },
-    "node_modules/micromark-util-events-to-acorn": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/micromark-util-events-to-acorn/-/micromark-util-events-to-acorn-2.0.2.tgz",
-      "integrity": "sha512-Fk+xmBrOv9QZnEDguL9OI9/NQQp6Hz4FuQ4YmCb/5V7+9eAh1s6AYSvL20kHkD67YIg7EpE54TiSlcsf3vyZgA==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/minimist": {
+      "version": "1.2.8",
+      "resolved": "https://registry.facebook.net/minimist/-/minimist-1.2.8.tgz",
+      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
       "license": "MIT",
-      "dependencies": {
-        "@types/acorn": "^4.0.0",
-        "@types/estree": "^1.0.0",
-        "@types/unist": "^3.0.0",
-        "devlop": "^1.0.0",
-        "estree-util-visit": "^2.0.0",
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0",
-        "vfile-message": "^4.0.0"
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/micromark-util-events-to-acorn/node_modules/micromark-util-symbol": {
+    "node_modules/mrmime": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT"
+      "resolved": "https://registry.facebook.net/mrmime/-/mrmime-2.0.1.tgz",
+      "integrity": "sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      }
     },
-    "node_modules/micromark-util-html-tag-name": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-html-tag-name/-/micromark-util-html-tag-name-2.0.1.tgz",
-      "integrity": "sha512-2cNEiYDhCWKI+Gs9T0Tiysk136SnR13hhO8yW6BGNyhOC4qYFnwF1nKfD3HFAIXA5c45RrIG1ub11GiXeYd1xA==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.facebook.net/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
       "license": "MIT"
     },
-    "node_modules/micromark-util-normalize-identifier": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-normalize-identifier/-/micromark-util-normalize-identifier-2.0.1.tgz",
-      "integrity": "sha512-sxPqmo70LyARJs0w2UclACPUUEqltCkJ6PhKdMIDuJ3gSf/Q+/GIe3WKl0Ijb/GyH9lOpUkRAO2wp0GVkLvS9Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/multicast-dns": {
+      "version": "7.2.5",
+      "resolved": "https://registry.facebook.net/multicast-dns/-/multicast-dns-7.2.5.tgz",
+      "integrity": "sha512-2eznPJP8z2BFLX50tf0LuODrpINqP1RVIm/CObbTcBRITQgmC/TjcREF1NeTBzIcR5XO/ukWo+YHOjBbFwIupg==",
       "license": "MIT",
       "dependencies": {
-        "micromark-util-symbol": "^2.0.0"
+        "dns-packet": "^5.2.2",
+        "thunky": "^1.0.2"
+      },
+      "bin": {
+        "multicast-dns": "cli.js"
       }
     },
-    "node_modules/micromark-util-normalize-identifier/node_modules/micromark-util-symbol": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
+    "node_modules/nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.facebook.net/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
       "funding": [
         {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
         }
       ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/negotiator": {
+      "version": "0.6.4",
+      "resolved": "https://registry.facebook.net/negotiator/-/negotiator-0.6.4.tgz",
+      "integrity": "sha512-myRT3DiWPHqho5PrJaIRyaMv2kgYf0mUVgBNOYMuCH5Ki1yEiQaf/ZJuQ62nvpc44wL5WDbTX7yGJi1Neevw8w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/neo-async": {
+      "version": "2.6.2",
+      "resolved": "https://registry.facebook.net/neo-async/-/neo-async-2.6.2.tgz",
+      "integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==",
       "license": "MIT"
     },
-    "node_modules/micromark-util-resolve-all": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-resolve-all/-/micromark-util-resolve-all-2.0.1.tgz",
-      "integrity": "sha512-VdQyxFWFT2/FGJgwQnJYbe1jjQoNTS4RjglmSjTUlpUMa95Htx9NHeYW4rGDJzbjvCsl9eLjMQwGeElsqmzcHg==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/no-case": {
+      "version": "3.0.4",
+      "resolved": "https://registry.facebook.net/no-case/-/no-case-3.0.4.tgz",
+      "integrity": "sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==",
       "license": "MIT",
       "dependencies": {
-        "micromark-util-types": "^2.0.0"
+        "lower-case": "^2.0.2",
+        "tslib": "^2.0.3"
       }
     },
-    "node_modules/micromark-util-sanitize-uri": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.1.tgz",
-      "integrity": "sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/node-emoji": {
+      "version": "2.2.0",
+      "resolved": "https://registry.facebook.net/node-emoji/-/node-emoji-2.2.0.tgz",
+      "integrity": "sha512-Z3lTE9pLaJF47NyMhd4ww1yFTAP8YhYI8SleJiHzM46Fgpm5cnNzSl9XfzFNqbaz+VlJrIj3fXQ4DeN1Rjm6cw==",
       "license": "MIT",
       "dependencies": {
-        "micromark-util-character": "^2.0.0",
-        "micromark-util-encode": "^2.0.0",
-        "micromark-util-symbol": "^2.0.0"
+        "@sindresorhus/is": "^4.6.0",
+        "char-regex": "^1.0.2",
+        "emojilib": "^2.4.0",
+        "skin-tone": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=18"
       }
     },
-    "node_modules/micromark-util-sanitize-uri/node_modules/micromark-util-character": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
-      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
-      }
-    },
-    "node_modules/micromark-util-sanitize-uri/node_modules/micromark-util-symbol": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/node-releases": {
+      "version": "2.0.38",
+      "resolved": "https://registry.facebook.net/node-releases/-/node-releases-2.0.38.tgz",
+      "integrity": "sha512-3qT/88Y3FbH/Kx4szpQQ4HzUbVrHPKTLVpVocKiLfoYvw9XSGOX2FmD2d6DrXbVYyAQTF2HeF6My8jmzx7/CRw==",
       "license": "MIT"
     },
-    "node_modules/micromark-util-subtokenize": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/micromark-util-subtokenize/-/micromark-util-subtokenize-2.0.3.tgz",
-      "integrity": "sha512-VXJJuNxYWSoYL6AJ6OQECCFGhIU2GGHMw8tahogePBrjkG8aCCas3ibkp7RnVOSTClg2is05/R7maAhF1XyQMg==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
       "license": "MIT",
-      "dependencies": {
-        "devlop": "^1.0.0",
-        "micromark-util-chunked": "^2.0.0",
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+      "engines": {
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/micromark-util-subtokenize/node_modules/micromark-util-symbol": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/micromark-util-symbol": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-1.1.0.tgz",
-      "integrity": "sha512-uEjpEYY6KMs1g7QfJ2eX1SQEV+ZT4rUD3UcF6l57acZvLNK7PBZL+ty82Z1qhK1/yXIY4bdx04FKMgR0g4IAag==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/micromark-util-types": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-2.0.1.tgz",
-      "integrity": "sha512-534m2WhVTddrcKVepwmVEVnUAmtrx9bfIjNoQHRqfnvdaHQiFytEhJoTgpWJvDEXCO5gLTQh3wYC1PgOJA4NSQ==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/micromark/node_modules/micromark-factory-space": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz",
-      "integrity": "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/normalize-url": {
+      "version": "8.1.1",
+      "resolved": "https://registry.facebook.net/normalize-url/-/normalize-url-8.1.1.tgz",
+      "integrity": "sha512-JYc0DPlpGWB40kH5g07gGTrYuMqV653k3uBKY6uITPWds3M0ov3GaWGp9lbE3Bzngx8+XkfzgvASb9vk9JDFXQ==",
       "license": "MIT",
-      "dependencies": {
-        "micromark-util-character": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+      "engines": {
+        "node": ">=14.16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/micromark/node_modules/micromark-util-character": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
-      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/npm-run-path": {
+      "version": "4.0.1",
+      "resolved": "https://registry.facebook.net/npm-run-path/-/npm-run-path-4.0.1.tgz",
+      "integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==",
       "license": "MIT",
       "dependencies": {
-        "micromark-util-symbol": "^2.0.0",
-        "micromark-util-types": "^2.0.0"
+        "path-key": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
       }
     },
-    "node_modules/micromark/node_modules/micromark-util-symbol": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
-      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
-      "funding": [
-        {
-          "type": "GitHub Sponsors",
-          "url": "https://github.com/sponsors/unifiedjs"
-        },
-        {
-          "type": "OpenCollective",
-          "url": "https://opencollective.com/unified"
-        }
-      ],
+    "node_modules/nprogress": {
+      "version": "0.2.0",
+      "resolved": "https://registry.facebook.net/nprogress/-/nprogress-0.2.0.tgz",
+      "integrity": "sha512-I19aIingLgR1fmhftnbWWO3dXc0hSxqHQHQb3H8m+K3TnEn/iSeTZZOyvKXWqQESMwuUVnatlCnZdLBZZt2VSA==",
       "license": "MIT"
     },
-    "node_modules/micromatch": {
-      "version": "4.0.8",
-      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
-      "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
+    "node_modules/nth-check": {
+      "version": "2.1.1",
+      "resolved": "https://registry.facebook.net/nth-check/-/nth-check-2.1.1.tgz",
+      "integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "boolbase": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/nth-check?sponsor=1"
+      }
+    },
+    "node_modules/null-loader": {
+      "version": "4.0.1",
+      "resolved": "https://registry.facebook.net/null-loader/-/null-loader-4.0.1.tgz",
+      "integrity": "sha512-pxqVbi4U6N26lq+LmgIbB5XATP0VdZKOG25DhHi8btMmJJefGArFyDg1yc4U3hWCJbMqSrw0qyrz1UQX+qYXqg==",
       "license": "MIT",
       "dependencies": {
-        "braces": "^3.0.3",
-        "picomatch": "^2.3.1"
+        "loader-utils": "^2.0.0",
+        "schema-utils": "^3.0.0"
       },
       "engines": {
-        "node": ">=8.6"
+        "node": ">= 10.13.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
+      },
+      "peerDependencies": {
+        "webpack": "^4.0.0 || ^5.0.0"
       }
     },
-    "node_modules/mime": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
-      "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
+    "node_modules/null-loader/node_modules/ajv": {
+      "version": "6.15.0",
+      "resolved": "https://registry.facebook.net/ajv/-/ajv-6.15.0.tgz",
+      "integrity": "sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==",
       "license": "MIT",
-      "bin": {
-        "mime": "cli.js"
+      "dependencies": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
       },
-      "engines": {
-        "node": ">=4"
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
       }
     },
-    "node_modules/mime-db": {
-      "version": "1.52.0",
-      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
-      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+    "node_modules/null-loader/node_modules/ajv-keywords": {
+      "version": "3.5.2",
+      "resolved": "https://registry.facebook.net/ajv-keywords/-/ajv-keywords-3.5.2.tgz",
+      "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==",
       "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
+      "peerDependencies": {
+        "ajv": "^6.9.1"
       }
     },
-    "node_modules/mime-types": {
-      "version": "2.1.35",
-      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
-      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+    "node_modules/null-loader/node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.facebook.net/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+      "license": "MIT"
+    },
+    "node_modules/null-loader/node_modules/schema-utils": {
+      "version": "3.3.0",
+      "resolved": "https://registry.facebook.net/schema-utils/-/schema-utils-3.3.0.tgz",
+      "integrity": "sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==",
       "license": "MIT",
       "dependencies": {
-        "mime-db": "1.52.0"
+        "@types/json-schema": "^7.0.8",
+        "ajv": "^6.12.5",
+        "ajv-keywords": "^3.5.2"
       },
       "engines": {
-        "node": ">= 0.6"
+        "node": ">= 10.13.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
       }
     },
-    "node_modules/mimic-fn": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz",
-      "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==",
+    "node_modules/object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.facebook.net/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
       "license": "MIT",
       "engines": {
-        "node": ">=6"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/mimic-response": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-4.0.0.tgz",
-      "integrity": "sha512-e5ISH9xMYU0DzrT+jl8q2ze9D6eWBto+I8CNpe+VI+K2J/F/k3PdkdTdz4wvGVH4NTpo+NRYTVIuMQEMMcsLqg==",
+    "node_modules/object-inspect": {
+      "version": "1.13.4",
+      "resolved": "https://registry.facebook.net/object-inspect/-/object-inspect-1.13.4.tgz",
+      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
       "license": "MIT",
       "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+        "node": ">= 0.4"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/mini-css-extract-plugin": {
-      "version": "2.9.2",
-      "resolved": "https://registry.npmjs.org/mini-css-extract-plugin/-/mini-css-extract-plugin-2.9.2.tgz",
-      "integrity": "sha512-GJuACcS//jtq4kCtd5ii/M0SZf7OZRH+BxdqXZHaJfb8TJiVl+NgQRPwiYt2EuqeSkNydn/7vP+bcE27C5mb9w==",
-      "license": "MIT",
-      "dependencies": {
-        "schema-utils": "^4.0.0",
-        "tapable": "^2.2.1"
-      },
-      "engines": {
-        "node": ">= 12.13.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/webpack"
-      },
-      "peerDependencies": {
-        "webpack": "^5.0.0"
-      }
-    },
-    "node_modules/minimalistic-assert": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz",
-      "integrity": "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==",
-      "license": "ISC"
-    },
-    "node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^1.1.7"
-      },
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/minimist": {
-      "version": "1.2.8",
-      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
-      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/mrmime": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/mrmime/-/mrmime-2.0.0.tgz",
-      "integrity": "sha512-eu38+hdgojoyq63s+yTpN4XMBdt5l8HhMhc4VKLO9KM5caLIBvUm4thi7fFaxyTmCKeNnXZ5pAlBwCUnhA09uw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "license": "MIT"
-    },
-    "node_modules/multicast-dns": {
-      "version": "7.2.5",
-      "resolved": "https://registry.npmjs.org/multicast-dns/-/multicast-dns-7.2.5.tgz",
-      "integrity": "sha512-2eznPJP8z2BFLX50tf0LuODrpINqP1RVIm/CObbTcBRITQgmC/TjcREF1NeTBzIcR5XO/ukWo+YHOjBbFwIupg==",
-      "license": "MIT",
-      "dependencies": {
-        "dns-packet": "^5.2.2",
-        "thunky": "^1.0.2"
-      },
-      "bin": {
-        "multicast-dns": "cli.js"
-      }
-    },
-    "node_modules/nanoid": {
-      "version": "3.3.8",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.8.tgz",
-      "integrity": "sha512-WNLf5Sd8oZxOm+TzppcYk8gVOgP+l58xNy58D0nbUnOxOWRWvlcCV4kUF7ltmI6PsrLl/BgKEyS4mqsGChFN0w==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
-      "license": "MIT",
-      "bin": {
-        "nanoid": "bin/nanoid.cjs"
-      },
-      "engines": {
-        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
-      }
-    },
-    "node_modules/negotiator": {
-      "version": "0.6.4",
-      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.4.tgz",
-      "integrity": "sha512-myRT3DiWPHqho5PrJaIRyaMv2kgYf0mUVgBNOYMuCH5Ki1yEiQaf/ZJuQ62nvpc44wL5WDbTX7yGJi1Neevw8w==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/neo-async": {
-      "version": "2.6.2",
-      "resolved": "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz",
-      "integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==",
-      "license": "MIT"
-    },
-    "node_modules/no-case": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/no-case/-/no-case-3.0.4.tgz",
-      "integrity": "sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==",
-      "license": "MIT",
-      "dependencies": {
-        "lower-case": "^2.0.2",
-        "tslib": "^2.0.3"
-      }
-    },
-    "node_modules/node-emoji": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/node-emoji/-/node-emoji-2.2.0.tgz",
-      "integrity": "sha512-Z3lTE9pLaJF47NyMhd4ww1yFTAP8YhYI8SleJiHzM46Fgpm5cnNzSl9XfzFNqbaz+VlJrIj3fXQ4DeN1Rjm6cw==",
-      "license": "MIT",
-      "dependencies": {
-        "@sindresorhus/is": "^4.6.0",
-        "char-regex": "^1.0.2",
-        "emojilib": "^2.4.0",
-        "skin-tone": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/node-forge": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/node-forge/-/node-forge-1.3.1.tgz",
-      "integrity": "sha512-dPEtOeMvF9VMcYV/1Wb8CPoVAXtp6MKMlcbAt4ddqmGqUJ6fQZFXkNZNkNlfevtNkGtaSoXf/vNNNSvgrdXwtA==",
-      "license": "(BSD-3-Clause OR GPL-2.0)",
-      "engines": {
-        "node": ">= 6.13.0"
-      }
-    },
-    "node_modules/node-releases": {
-      "version": "2.0.19",
-      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.19.tgz",
-      "integrity": "sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==",
-      "license": "MIT"
-    },
-    "node_modules/normalize-path": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
-      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/normalize-range": {
-      "version": "0.1.2",
-      "resolved": "https://registry.npmjs.org/normalize-range/-/normalize-range-0.1.2.tgz",
-      "integrity": "sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/normalize-url": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-8.0.1.tgz",
-      "integrity": "sha512-IO9QvjUMWxPQQhs60oOu10CRkWCiZzSUkzbXGGV9pviYl1fXYcvkzQ5jV9z8Y6un8ARoVRl4EtC6v6jNqbaJ/w==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=14.16"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/npm-run-path": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz",
-      "integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==",
-      "license": "MIT",
-      "dependencies": {
-        "path-key": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/nprogress": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/nprogress/-/nprogress-0.2.0.tgz",
-      "integrity": "sha512-I19aIingLgR1fmhftnbWWO3dXc0hSxqHQHQb3H8m+K3TnEn/iSeTZZOyvKXWqQESMwuUVnatlCnZdLBZZt2VSA==",
-      "license": "MIT"
-    },
-    "node_modules/nth-check": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz",
-      "integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==",
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "boolbase": "^1.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/fb55/nth-check?sponsor=1"
-      }
-    },
-    "node_modules/null-loader": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/null-loader/-/null-loader-4.0.1.tgz",
-      "integrity": "sha512-pxqVbi4U6N26lq+LmgIbB5XATP0VdZKOG25DhHi8btMmJJefGArFyDg1yc4U3hWCJbMqSrw0qyrz1UQX+qYXqg==",
-      "license": "MIT",
-      "dependencies": {
-        "loader-utils": "^2.0.0",
-        "schema-utils": "^3.0.0"
-      },
-      "engines": {
-        "node": ">= 10.13.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/webpack"
-      },
-      "peerDependencies": {
-        "webpack": "^4.0.0 || ^5.0.0"
-      }
-    },
-    "node_modules/null-loader/node_modules/ajv": {
-      "version": "6.12.6",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
-      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
-      "license": "MIT",
-      "dependencies": {
-        "fast-deep-equal": "^3.1.1",
-        "fast-json-stable-stringify": "^2.0.0",
-        "json-schema-traverse": "^0.4.1",
-        "uri-js": "^4.2.2"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/epoberezkin"
-      }
-    },
-    "node_modules/null-loader/node_modules/ajv-keywords": {
-      "version": "3.5.2",
-      "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz",
-      "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==",
-      "license": "MIT",
-      "peerDependencies": {
-        "ajv": "^6.9.1"
-      }
-    },
-    "node_modules/null-loader/node_modules/json-schema-traverse": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
-      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
-      "license": "MIT"
-    },
-    "node_modules/null-loader/node_modules/schema-utils": {
-      "version": "3.3.0",
-      "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.3.0.tgz",
-      "integrity": "sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/json-schema": "^7.0.8",
-        "ajv": "^6.12.5",
-        "ajv-keywords": "^3.5.2"
-      },
-      "engines": {
-        "node": ">= 10.13.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/webpack"
-      }
-    },
-    "node_modules/object-assign": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
-      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/object-inspect": {
-      "version": "1.13.3",
-      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.3.tgz",
-      "integrity": "sha512-kDCGIbxkDSXE3euJZZXzc6to7fCrKHNI/hSRQnRuQ+BWjFNzZwiFF8fj/6o2t2G9/jTj8PSIYTfCLelLZEeRpA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/object-keys": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
-      "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
+    "node_modules/object-keys": {
+      "version": "1.1.1",
+      "resolved": "https://registry.facebook.net/object-keys/-/object-keys-1.1.1.tgz",
+      "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
       "license": "MIT",
       "engines": {
         "node": ">= 0.4"
@@ -12861,7 +12248,7 @@
     },
     "node_modules/object.assign": {
       "version": "4.1.7",
-      "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.7.tgz",
+      "resolved": "https://registry.facebook.net/object.assign/-/object.assign-4.1.7.tgz",
       "integrity": "sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==",
       "license": "MIT",
       "dependencies": {
@@ -12881,13 +12268,13 @@
     },
     "node_modules/obuf": {
       "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/obuf/-/obuf-1.1.2.tgz",
+      "resolved": "https://registry.facebook.net/obuf/-/obuf-1.1.2.tgz",
       "integrity": "sha512-PX1wu0AmAdPqOL1mWhqmlOd8kOIZQwGZw6rh7uby9fTc5lhaOWFLX3I6R1hrF9k3zUY40e6igsLGkDXK92LJNg==",
       "license": "MIT"
     },
     "node_modules/on-finished": {
       "version": "2.4.1",
-      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
+      "resolved": "https://registry.facebook.net/on-finished/-/on-finished-2.4.1.tgz",
       "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
       "license": "MIT",
       "dependencies": {
@@ -12899,25 +12286,16 @@
     },
     "node_modules/on-headers": {
       "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/on-headers/-/on-headers-1.1.0.tgz",
+      "resolved": "https://registry.facebook.net/on-headers/-/on-headers-1.1.0.tgz",
       "integrity": "sha512-737ZY3yNnXy37FHkQxPzt4UZ2UWPWiCZWLvFZ4fu5cueciegX0zGPnrlY6bwRg4FdQOe9YU8MkmJwGhoMybl8A==",
       "license": "MIT",
       "engines": {
         "node": ">= 0.8"
       }
     },
-    "node_modules/once": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
-      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
-      "license": "ISC",
-      "dependencies": {
-        "wrappy": "1"
-      }
-    },
     "node_modules/onetime": {
       "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz",
+      "resolved": "https://registry.facebook.net/onetime/-/onetime-5.1.2.tgz",
       "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==",
       "license": "MIT",
       "dependencies": {
@@ -12932,7 +12310,7 @@
     },
     "node_modules/open": {
       "version": "8.4.2",
-      "resolved": "https://registry.npmjs.org/open/-/open-8.4.2.tgz",
+      "resolved": "https://registry.facebook.net/open/-/open-8.4.2.tgz",
       "integrity": "sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==",
       "license": "MIT",
       "dependencies": {
@@ -12949,7 +12327,7 @@
     },
     "node_modules/opener": {
       "version": "1.5.2",
-      "resolved": "https://registry.npmjs.org/opener/-/opener-1.5.2.tgz",
+      "resolved": "https://registry.facebook.net/opener/-/opener-1.5.2.tgz",
       "integrity": "sha512-ur5UIdyw5Y7yEj9wLzhqXiy6GZ3Mwx0yGI+5sMn2r0N0v3cKJvUmFH5yPP+WXh9e0xfyzyJX95D8l088DNFj7A==",
       "license": "(WTFPL OR MIT)",
       "bin": {
@@ -12958,17 +12336,26 @@
     },
     "node_modules/p-cancelable": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-3.0.0.tgz",
+      "resolved": "https://registry.facebook.net/p-cancelable/-/p-cancelable-3.0.0.tgz",
       "integrity": "sha512-mlVgR3PGuzlo0MmTdk4cXqXWlwQDLnONTAg6sm62XkMJEiRxN3GL3SffkYvqwonbkJBcrI7Uvv5Zh9yjvn2iUw==",
       "license": "MIT",
       "engines": {
         "node": ">=12.20"
       }
     },
-    "node_modules/p-limit": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-4.0.0.tgz",
-      "integrity": "sha512-5b0R4txpzjPWVw/cXXUResoD4hb6U/x9BH08L7nw+GN1sezDzPdxeRvpc9c433fZhBan/wusjbCsqwqm4EIBIQ==",
+    "node_modules/p-finally": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/p-finally/-/p-finally-1.0.0.tgz",
+      "integrity": "sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/p-limit": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/p-limit/-/p-limit-4.0.0.tgz",
+      "integrity": "sha512-5b0R4txpzjPWVw/cXXUResoD4hb6U/x9BH08L7nw+GN1sezDzPdxeRvpc9c433fZhBan/wusjbCsqwqm4EIBIQ==",
       "license": "MIT",
       "dependencies": {
         "yocto-queue": "^1.0.0"
@@ -12982,7 +12369,7 @@
     },
     "node_modules/p-locate": {
       "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-6.0.0.tgz",
+      "resolved": "https://registry.facebook.net/p-locate/-/p-locate-6.0.0.tgz",
       "integrity": "sha512-wPrq66Llhl7/4AGC6I+cqxT07LhXvWL08LNXz1fENOw0Ap4sRZZ/gZpTTJ5jpurzzzfS2W/Ge9BY3LgLjCShcw==",
       "license": "MIT",
       "dependencies": {
@@ -12997,7 +12384,7 @@
     },
     "node_modules/p-map": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/p-map/-/p-map-4.0.0.tgz",
+      "resolved": "https://registry.facebook.net/p-map/-/p-map-4.0.0.tgz",
       "integrity": "sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==",
       "license": "MIT",
       "dependencies": {
@@ -13010,31 +12397,54 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/p-queue": {
+      "version": "6.6.2",
+      "resolved": "https://registry.facebook.net/p-queue/-/p-queue-6.6.2.tgz",
+      "integrity": "sha512-RwFpb72c/BhQLEXIZ5K2e+AhgNVmIejGlTgiB9MzZ0e93GRvqZ7uSi0dvRF7/XIXDeNkra2fNHBxTyPDGySpjQ==",
+      "license": "MIT",
+      "dependencies": {
+        "eventemitter3": "^4.0.4",
+        "p-timeout": "^3.2.0"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/p-retry": {
-      "version": "4.6.2",
-      "resolved": "https://registry.npmjs.org/p-retry/-/p-retry-4.6.2.tgz",
-      "integrity": "sha512-312Id396EbJdvRONlngUx0NydfrIQ5lsYu0znKVUzVvArzEIt08V1qhtyESbGVd1FGX7UKtiFp5uwKZdM8wIuQ==",
+      "version": "6.2.1",
+      "resolved": "https://registry.facebook.net/p-retry/-/p-retry-6.2.1.tgz",
+      "integrity": "sha512-hEt02O4hUct5wtwg4H4KcWgDdm+l1bOaEy/hWzd8xtXB9BqxTWBBhb+2ImAtH4Cv4rPjV76xN3Zumqk3k3AhhQ==",
       "license": "MIT",
       "dependencies": {
-        "@types/retry": "0.12.0",
+        "@types/retry": "0.12.2",
+        "is-network-error": "^1.0.0",
         "retry": "^0.13.1"
       },
       "engines": {
-        "node": ">=8"
+        "node": ">=16.17"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/p-try": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz",
-      "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==",
+    "node_modules/p-timeout": {
+      "version": "3.2.0",
+      "resolved": "https://registry.facebook.net/p-timeout/-/p-timeout-3.2.0.tgz",
+      "integrity": "sha512-rhIwUycgwwKcP9yTOOFK/AKsAopjjCakVqLHePO3CC6Mir1Z99xT+R63jZxAT5lFZLa2inS5h+ZS2GvR99/FBg==",
       "license": "MIT",
+      "dependencies": {
+        "p-finally": "^1.0.0"
+      },
       "engines": {
-        "node": ">=6"
+        "node": ">=8"
       }
     },
     "node_modules/package-json": {
       "version": "8.1.1",
-      "resolved": "https://registry.npmjs.org/package-json/-/package-json-8.1.1.tgz",
+      "resolved": "https://registry.facebook.net/package-json/-/package-json-8.1.1.tgz",
       "integrity": "sha512-cbH9IAIJHNj9uXi196JVsRlt7cHKak6u/e6AkL/bkRelZ7rlL3X1YKxsZwa36xipOEKAsdtmaG6aAJoM1fx2zA==",
       "license": "MIT",
       "dependencies": {
@@ -13050,9 +12460,21 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/package-json/node_modules/semver": {
+      "version": "7.7.4",
+      "resolved": "https://registry.facebook.net/semver/-/semver-7.7.4.tgz",
+      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/param-case": {
       "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/param-case/-/param-case-3.0.4.tgz",
+      "resolved": "https://registry.facebook.net/param-case/-/param-case-3.0.4.tgz",
       "integrity": "sha512-RXlj7zCYokReqWpOPH9oYivUzLYZ5vAPIfEmCTNViosC78F8F0H9y7T7gG2M39ymgutxF5gcFEsyZQSph9Bp3A==",
       "license": "MIT",
       "dependencies": {
@@ -13062,7 +12484,7 @@
     },
     "node_modules/parent-module": {
       "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+      "resolved": "https://registry.facebook.net/parent-module/-/parent-module-1.0.1.tgz",
       "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
       "license": "MIT",
       "dependencies": {
@@ -13074,7 +12496,7 @@
     },
     "node_modules/parse-entities": {
       "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/parse-entities/-/parse-entities-4.0.2.tgz",
+      "resolved": "https://registry.facebook.net/parse-entities/-/parse-entities-4.0.2.tgz",
       "integrity": "sha512-GG2AQYWoLgL877gQIKeRPGO1xF9+eG1ujIb5soS5gPvLQ1y2o8FL90w2QWNdf9I361Mpp7726c+lj3U0qK1uGw==",
       "license": "MIT",
       "dependencies": {
@@ -13093,13 +12515,13 @@
     },
     "node_modules/parse-entities/node_modules/@types/unist": {
       "version": "2.0.11",
-      "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz",
+      "resolved": "https://registry.facebook.net/@types/unist/-/unist-2.0.11.tgz",
       "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==",
       "license": "MIT"
     },
     "node_modules/parse-json": {
       "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz",
+      "resolved": "https://registry.facebook.net/parse-json/-/parse-json-5.2.0.tgz",
       "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==",
       "license": "MIT",
       "dependencies": {
@@ -13117,17 +12539,17 @@
     },
     "node_modules/parse-numeric-range": {
       "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/parse-numeric-range/-/parse-numeric-range-1.3.0.tgz",
+      "resolved": "https://registry.facebook.net/parse-numeric-range/-/parse-numeric-range-1.3.0.tgz",
       "integrity": "sha512-twN+njEipszzlMJd4ONUYgSfZPDxgHhT9Ahed5uTigpQn90FggW4SA/AIPq/6a149fTbE9qBEcSwE3FAEp6wQQ==",
       "license": "ISC"
     },
     "node_modules/parse5": {
-      "version": "7.2.1",
-      "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.2.1.tgz",
-      "integrity": "sha512-BuBYQYlv1ckiPdQi/ohiivi9Sagc9JG+Ozs0r7b/0iK3sKmrb0b9FdWdBbOdx6hBCM/F9Ir82ofnBhtZOjCRPQ==",
+      "version": "7.3.0",
+      "resolved": "https://registry.facebook.net/parse5/-/parse5-7.3.0.tgz",
+      "integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==",
       "license": "MIT",
       "dependencies": {
-        "entities": "^4.5.0"
+        "entities": "^6.0.0"
       },
       "funding": {
         "url": "https://github.com/inikulin/parse5?sponsor=1"
@@ -13135,7 +12557,7 @@
     },
     "node_modules/parse5-htmlparser2-tree-adapter": {
       "version": "7.1.0",
-      "resolved": "https://registry.npmjs.org/parse5-htmlparser2-tree-adapter/-/parse5-htmlparser2-tree-adapter-7.1.0.tgz",
+      "resolved": "https://registry.facebook.net/parse5-htmlparser2-tree-adapter/-/parse5-htmlparser2-tree-adapter-7.1.0.tgz",
       "integrity": "sha512-ruw5xyKs6lrpo9x9rCZqZZnIUntICjQAd0Wsmp396Ul9lN/h+ifgVV1x1gZHi8euej6wTfpqX8j+BFQxF0NS/g==",
       "license": "MIT",
       "dependencies": {
@@ -13146,9 +12568,21 @@
         "url": "https://github.com/inikulin/parse5?sponsor=1"
       }
     },
+    "node_modules/parse5/node_modules/entities": {
+      "version": "6.0.1",
+      "resolved": "https://registry.facebook.net/entities/-/entities-6.0.1.tgz",
+      "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
     "node_modules/parseurl": {
       "version": "1.3.3",
-      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
+      "resolved": "https://registry.facebook.net/parseurl/-/parseurl-1.3.3.tgz",
       "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
       "license": "MIT",
       "engines": {
@@ -13157,7 +12591,7 @@
     },
     "node_modules/pascal-case": {
       "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/pascal-case/-/pascal-case-3.1.2.tgz",
+      "resolved": "https://registry.facebook.net/pascal-case/-/pascal-case-3.1.2.tgz",
       "integrity": "sha512-uWlGT3YSnK9x3BQJaOdcZwrnV6hPpd8jFH1/ucpiLRPh/2zCVJKS19E4GvYHvaCcACn3foXZ0cLB9Wrx1KGe5g==",
       "license": "MIT",
       "dependencies": {
@@ -13167,31 +12601,22 @@
     },
     "node_modules/path-exists": {
       "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-5.0.0.tgz",
+      "resolved": "https://registry.facebook.net/path-exists/-/path-exists-5.0.0.tgz",
       "integrity": "sha512-RjhtfwJOxzcFmNOi6ltcbcu4Iu+FL3zEj83dk4kAS+fVpTxXLO1b38RvJgT/0QwvV/L3aY9TAnyv0EOqW4GoMQ==",
       "license": "MIT",
       "engines": {
         "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
       }
     },
-    "node_modules/path-is-absolute": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
-      "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
     "node_modules/path-is-inside": {
       "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/path-is-inside/-/path-is-inside-1.0.2.tgz",
+      "resolved": "https://registry.facebook.net/path-is-inside/-/path-is-inside-1.0.2.tgz",
       "integrity": "sha512-DUWJr3+ULp4zXmol/SZkFf3JGsS9/SIv+Y3Rt93/UjPpDpklB5f1er4O3POIbUuUJ3FXgqte2Q7SrU6zAqwk8w==",
       "license": "(WTFPL OR MIT)"
     },
     "node_modules/path-key": {
       "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "resolved": "https://registry.facebook.net/path-key/-/path-key-3.1.1.tgz",
       "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
       "license": "MIT",
       "engines": {
@@ -13200,22 +12625,19 @@
     },
     "node_modules/path-parse": {
       "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+      "resolved": "https://registry.facebook.net/path-parse/-/path-parse-1.0.7.tgz",
       "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
       "license": "MIT"
     },
     "node_modules/path-to-regexp": {
-      "version": "1.9.0",
-      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-1.9.0.tgz",
-      "integrity": "sha512-xIp7/apCFJuUHdDLWe8O1HIkb0kQrOMb/0u6FXQjemHn/ii5LrIzU6bdECnsiTF/GjZkMEKg1xdiZwNqDYlZ6g==",
-      "license": "MIT",
-      "dependencies": {
-        "isarray": "0.0.1"
-      }
+      "version": "3.3.0",
+      "resolved": "https://registry.facebook.net/path-to-regexp/-/path-to-regexp-3.3.0.tgz",
+      "integrity": "sha512-qyCH421YQPS2WFDxDjftfc1ZR5WKQzVzqsp4n9M2kQhVOo/ByahFoUNJfl58kOcEGfQ//7weFTDhm+ss8Ecxgw==",
+      "license": "MIT"
     },
     "node_modules/path-type": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz",
+      "resolved": "https://registry.facebook.net/path-type/-/path-type-4.0.0.tgz",
       "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==",
       "license": "MIT",
       "engines": {
@@ -13224,14 +12646,14 @@
     },
     "node_modules/picocolors": {
       "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "resolved": "https://registry.facebook.net/picocolors/-/picocolors-1.1.1.tgz",
       "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
       "license": "ISC"
     },
     "node_modules/picomatch": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
-      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "version": "2.3.2",
+      "resolved": "https://registry.facebook.net/picomatch/-/picomatch-2.3.2.tgz",
+      "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==",
       "license": "MIT",
       "engines": {
         "node": ">=8.6"
@@ -13242,7 +12664,7 @@
     },
     "node_modules/pkg-dir": {
       "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-7.0.0.tgz",
+      "resolved": "https://registry.facebook.net/pkg-dir/-/pkg-dir-7.0.0.tgz",
       "integrity": "sha512-Ie9z/WINcxxLp27BKOCHGde4ITq9UklYKDzVo1nhk5sqGEXU3FpkwP5GM2voTGJkGd9B3Otl+Q4uwSOeSUtOBA==",
       "license": "MIT",
       "dependencies": {
@@ -13255,83 +12677,27 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/pkg-up": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/pkg-up/-/pkg-up-3.1.0.tgz",
-      "integrity": "sha512-nDywThFk1i4BQK4twPQ6TA4RT8bDY96yeuCVBWL3ePARCiEKDRSrNGbFIgUJpLp+XeIR65v8ra7WuJOFUBtkMA==",
-      "license": "MIT",
-      "dependencies": {
-        "find-up": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/pkg-up/node_modules/find-up": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz",
-      "integrity": "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==",
-      "license": "MIT",
-      "dependencies": {
-        "locate-path": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/pkg-up/node_modules/locate-path": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz",
-      "integrity": "sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==",
-      "license": "MIT",
-      "dependencies": {
-        "p-locate": "^3.0.0",
-        "path-exists": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/pkg-up/node_modules/p-limit": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz",
-      "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==",
-      "license": "MIT",
-      "dependencies": {
-        "p-try": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/pkg-up/node_modules/p-locate": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz",
-      "integrity": "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==",
-      "license": "MIT",
+    "node_modules/pkijs": {
+      "version": "3.4.0",
+      "resolved": "https://registry.facebook.net/pkijs/-/pkijs-3.4.0.tgz",
+      "integrity": "sha512-emEcLuomt2j03vxD54giVB4SxTjnsqkU692xZOZXHDVoYyypEm+b3jpiTcc+Cf+myooc+/Ly0z01jqeNHVgJGw==",
+      "license": "BSD-3-Clause",
       "dependencies": {
-        "p-limit": "^2.0.0"
+        "@noble/hashes": "1.4.0",
+        "asn1js": "^3.0.6",
+        "bytestreamjs": "^2.0.1",
+        "pvtsutils": "^1.3.6",
+        "pvutils": "^1.1.3",
+        "tslib": "^2.8.1"
       },
       "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/pkg-up/node_modules/path-exists": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz",
-      "integrity": "sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
+        "node": ">=16.0.0"
       }
     },
     "node_modules/postcss": {
-      "version": "8.4.49",
-      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.49.tgz",
-      "integrity": "sha512-OCVPnIObs4N29kxTjzLfUryOkvZEq+pf8jTF0lg8E7uETuWHA+v7j3c/xJmiqpX450191LlmZfUKkXxkTry7nA==",
+      "version": "8.5.12",
+      "resolved": "https://registry.facebook.net/postcss/-/postcss-8.5.12.tgz",
+      "integrity": "sha512-W62t/Se6rA0Az3DfCL0AqJwXuKwBeYg6nOaIgzP+xZ7N5BFCI7DYi1qs6ygUYT6rvfi6t9k65UMLJC+PHZpDAA==",
       "funding": [
         {
           "type": "opencollective",
@@ -13348,7 +12714,7 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "nanoid": "^3.3.7",
+        "nanoid": "^3.3.11",
         "picocolors": "^1.1.1",
         "source-map-js": "^1.2.1"
       },
@@ -13358,7 +12724,7 @@
     },
     "node_modules/postcss-attribute-case-insensitive": {
       "version": "7.0.1",
-      "resolved": "https://registry.npmjs.org/postcss-attribute-case-insensitive/-/postcss-attribute-case-insensitive-7.0.1.tgz",
+      "resolved": "https://registry.facebook.net/postcss-attribute-case-insensitive/-/postcss-attribute-case-insensitive-7.0.1.tgz",
       "integrity": "sha512-Uai+SupNSqzlschRyNx3kbCTWgY/2hcwtHEI/ej2LJWc9JJ77qKgGptd8DHwY1mXtZ7Aoh4z4yxfwMBue9eNgw==",
       "funding": [
         {
@@ -13381,22 +12747,9 @@
         "postcss": "^8.4"
       }
     },
-    "node_modules/postcss-attribute-case-insensitive/node_modules/postcss-selector-parser": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.0.0.tgz",
-      "integrity": "sha512-9RbEr1Y7FFfptd/1eEdntyjMwLeghW1bHX9GWjXo19vx4ytPQhANltvVxDggzJl7mnWM+dX28kb6cyS/4iQjlQ==",
-      "license": "MIT",
-      "dependencies": {
-        "cssesc": "^3.0.0",
-        "util-deprecate": "^1.0.2"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/postcss-calc": {
       "version": "9.0.1",
-      "resolved": "https://registry.npmjs.org/postcss-calc/-/postcss-calc-9.0.1.tgz",
+      "resolved": "https://registry.facebook.net/postcss-calc/-/postcss-calc-9.0.1.tgz",
       "integrity": "sha512-TipgjGyzP5QzEhsOZUaIkeO5mKeMFpebWzRogWG/ysonUlnHcq5aJe0jOjpfzUU8PeSaBQnrE8ehR0QA5vs8PQ==",
       "license": "MIT",
       "dependencies": {
@@ -13410,9 +12763,22 @@
         "postcss": "^8.2.2"
       }
     },
+    "node_modules/postcss-calc/node_modules/postcss-selector-parser": {
+      "version": "6.1.2",
+      "resolved": "https://registry.facebook.net/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
+      "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
+      "license": "MIT",
+      "dependencies": {
+        "cssesc": "^3.0.0",
+        "util-deprecate": "^1.0.2"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/postcss-clamp": {
       "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/postcss-clamp/-/postcss-clamp-4.1.0.tgz",
+      "resolved": "https://registry.facebook.net/postcss-clamp/-/postcss-clamp-4.1.0.tgz",
       "integrity": "sha512-ry4b1Llo/9zz+PKC+030KUnPITTJAHeOwjfAyyB60eT0AorGLdzp52s31OsPRHRf8NchkgFoG2y6fCfn1IV1Ow==",
       "license": "MIT",
       "dependencies": {
@@ -13426,9 +12792,9 @@
       }
     },
     "node_modules/postcss-color-functional-notation": {
-      "version": "7.0.7",
-      "resolved": "https://registry.npmjs.org/postcss-color-functional-notation/-/postcss-color-functional-notation-7.0.7.tgz",
-      "integrity": "sha512-EZvAHsvyASX63vXnyXOIynkxhaHRSsdb7z6yiXKIovGXAolW4cMZ3qoh7k3VdTsLBS6VGdksGfIo3r6+waLoOw==",
+      "version": "7.0.12",
+      "resolved": "https://registry.facebook.net/postcss-color-functional-notation/-/postcss-color-functional-notation-7.0.12.tgz",
+      "integrity": "sha512-TLCW9fN5kvO/u38/uesdpbx3e8AkTYhMvDZYa9JpmImWuTE99bDQ7GU7hdOADIZsiI9/zuxfAJxny/khknp1Zw==",
       "funding": [
         {
           "type": "github",
@@ -13441,10 +12807,10 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/css-color-parser": "^3.0.7",
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3",
-        "@csstools/postcss-progressive-custom-properties": "^4.0.0",
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
         "@csstools/utilities": "^2.0.0"
       },
       "engines": {
@@ -13456,7 +12822,7 @@
     },
     "node_modules/postcss-color-hex-alpha": {
       "version": "10.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-color-hex-alpha/-/postcss-color-hex-alpha-10.0.0.tgz",
+      "resolved": "https://registry.facebook.net/postcss-color-hex-alpha/-/postcss-color-hex-alpha-10.0.0.tgz",
       "integrity": "sha512-1kervM2cnlgPs2a8Vt/Qbe5cQ++N7rkYo/2rz2BkqJZIHQwaVuJgQH38REHrAi4uM0b1fqxMkWYmese94iMp3w==",
       "funding": [
         {
@@ -13482,7 +12848,7 @@
     },
     "node_modules/postcss-color-rebeccapurple": {
       "version": "10.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-color-rebeccapurple/-/postcss-color-rebeccapurple-10.0.0.tgz",
+      "resolved": "https://registry.facebook.net/postcss-color-rebeccapurple/-/postcss-color-rebeccapurple-10.0.0.tgz",
       "integrity": "sha512-JFta737jSP+hdAIEhk1Vs0q0YF5P8fFcj+09pweS8ktuGuZ8pPlykHsk6mPxZ8awDl4TrcxUqJo9l1IhVr/OjQ==",
       "funding": [
         {
@@ -13508,7 +12874,7 @@
     },
     "node_modules/postcss-colormin": {
       "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/postcss-colormin/-/postcss-colormin-6.1.0.tgz",
+      "resolved": "https://registry.facebook.net/postcss-colormin/-/postcss-colormin-6.1.0.tgz",
       "integrity": "sha512-x9yX7DOxeMAR+BgGVnNSAxmAj98NX/YxEMNFP+SDCEeNLb2r3i6Hh1ksMsnW8Ub5SLCpbescQqn9YEbE9554Sw==",
       "license": "MIT",
       "dependencies": {
@@ -13526,7 +12892,7 @@
     },
     "node_modules/postcss-convert-values": {
       "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/postcss-convert-values/-/postcss-convert-values-6.1.0.tgz",
+      "resolved": "https://registry.facebook.net/postcss-convert-values/-/postcss-convert-values-6.1.0.tgz",
       "integrity": "sha512-zx8IwP/ts9WvUM6NkVSkiU902QZL1bwPhaVaLynPtCsOTqp+ZKbNi+s6XJg3rfqpKGA/oc7Oxk5t8pOQJcwl/w==",
       "license": "MIT",
       "dependencies": {
@@ -13541,9 +12907,9 @@
       }
     },
     "node_modules/postcss-custom-media": {
-      "version": "11.0.5",
-      "resolved": "https://registry.npmjs.org/postcss-custom-media/-/postcss-custom-media-11.0.5.tgz",
-      "integrity": "sha512-SQHhayVNgDvSAdX9NQ/ygcDQGEY+aSF4b/96z7QUX6mqL5yl/JgG/DywcF6fW9XbnCRE+aVYk+9/nqGuzOPWeQ==",
+      "version": "11.0.6",
+      "resolved": "https://registry.facebook.net/postcss-custom-media/-/postcss-custom-media-11.0.6.tgz",
+      "integrity": "sha512-C4lD4b7mUIw+RZhtY7qUbf4eADmb7Ey8BFA2px9jUbwg7pjTZDl4KY4bvlUV+/vXQvzQRfiGEVJyAbtOsCMInw==",
       "funding": [
         {
           "type": "github",
@@ -13556,10 +12922,10 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "@csstools/cascade-layer-name-parser": "^2.0.4",
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3",
-        "@csstools/media-query-list-parser": "^4.0.2"
+        "@csstools/cascade-layer-name-parser": "^2.0.5",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/media-query-list-parser": "^4.0.3"
       },
       "engines": {
         "node": ">=18"
@@ -13569,9 +12935,9 @@
       }
     },
     "node_modules/postcss-custom-properties": {
-      "version": "14.0.4",
-      "resolved": "https://registry.npmjs.org/postcss-custom-properties/-/postcss-custom-properties-14.0.4.tgz",
-      "integrity": "sha512-QnW8FCCK6q+4ierwjnmXF9Y9KF8q0JkbgVfvQEMa93x1GT8FvOiUevWCN2YLaOWyByeDX8S6VFbZEeWoAoXs2A==",
+      "version": "14.0.6",
+      "resolved": "https://registry.facebook.net/postcss-custom-properties/-/postcss-custom-properties-14.0.6.tgz",
+      "integrity": "sha512-fTYSp3xuk4BUeVhxCSJdIPhDLpJfNakZKoiTDx7yRGCdlZrSJR7mWKVOBS4sBF+5poPQFMj2YdXx1VHItBGihQ==",
       "funding": [
         {
           "type": "github",
@@ -13584,9 +12950,9 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "@csstools/cascade-layer-name-parser": "^2.0.4",
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3",
+        "@csstools/cascade-layer-name-parser": "^2.0.5",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
         "@csstools/utilities": "^2.0.0",
         "postcss-value-parser": "^4.2.0"
       },
@@ -13598,9 +12964,9 @@
       }
     },
     "node_modules/postcss-custom-selectors": {
-      "version": "8.0.4",
-      "resolved": "https://registry.npmjs.org/postcss-custom-selectors/-/postcss-custom-selectors-8.0.4.tgz",
-      "integrity": "sha512-ASOXqNvDCE0dAJ/5qixxPeL1aOVGHGW2JwSy7HyjWNbnWTQCl+fDc968HY1jCmZI0+BaYT5CxsOiUhavpG/7eg==",
+      "version": "8.0.5",
+      "resolved": "https://registry.facebook.net/postcss-custom-selectors/-/postcss-custom-selectors-8.0.5.tgz",
+      "integrity": "sha512-9PGmckHQswiB2usSO6XMSswO2yFWVoCAuih1yl9FVcwkscLjRKjwsjM3t+NIWpSU2Jx3eOiK2+t4vVTQaoCHHg==",
       "funding": [
         {
           "type": "github",
@@ -13613,9 +12979,9 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "@csstools/cascade-layer-name-parser": "^2.0.4",
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3",
+        "@csstools/cascade-layer-name-parser": "^2.0.5",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
         "postcss-selector-parser": "^7.0.0"
       },
       "engines": {
@@ -13625,22 +12991,9 @@
         "postcss": "^8.4"
       }
     },
-    "node_modules/postcss-custom-selectors/node_modules/postcss-selector-parser": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.0.0.tgz",
-      "integrity": "sha512-9RbEr1Y7FFfptd/1eEdntyjMwLeghW1bHX9GWjXo19vx4ytPQhANltvVxDggzJl7mnWM+dX28kb6cyS/4iQjlQ==",
-      "license": "MIT",
-      "dependencies": {
-        "cssesc": "^3.0.0",
-        "util-deprecate": "^1.0.2"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/postcss-dir-pseudo-class": {
       "version": "9.0.1",
-      "resolved": "https://registry.npmjs.org/postcss-dir-pseudo-class/-/postcss-dir-pseudo-class-9.0.1.tgz",
+      "resolved": "https://registry.facebook.net/postcss-dir-pseudo-class/-/postcss-dir-pseudo-class-9.0.1.tgz",
       "integrity": "sha512-tRBEK0MHYvcMUrAuYMEOa0zg9APqirBcgzi6P21OhxtJyJADo/SWBwY1CAwEohQ/6HDaa9jCjLRG7K3PVQYHEA==",
       "funding": [
         {
@@ -13663,22 +13016,9 @@
         "postcss": "^8.4"
       }
     },
-    "node_modules/postcss-dir-pseudo-class/node_modules/postcss-selector-parser": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.0.0.tgz",
-      "integrity": "sha512-9RbEr1Y7FFfptd/1eEdntyjMwLeghW1bHX9GWjXo19vx4ytPQhANltvVxDggzJl7mnWM+dX28kb6cyS/4iQjlQ==",
-      "license": "MIT",
-      "dependencies": {
-        "cssesc": "^3.0.0",
-        "util-deprecate": "^1.0.2"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/postcss-discard-comments": {
       "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/postcss-discard-comments/-/postcss-discard-comments-6.0.2.tgz",
+      "resolved": "https://registry.facebook.net/postcss-discard-comments/-/postcss-discard-comments-6.0.2.tgz",
       "integrity": "sha512-65w/uIqhSBBfQmYnG92FO1mWZjJ4GL5b8atm5Yw2UgrwD7HiNiSSNwJor1eCFGzUgYnN/iIknhNRVqjrrpuglw==",
       "license": "MIT",
       "engines": {
@@ -13690,7 +13030,7 @@
     },
     "node_modules/postcss-discard-duplicates": {
       "version": "6.0.3",
-      "resolved": "https://registry.npmjs.org/postcss-discard-duplicates/-/postcss-discard-duplicates-6.0.3.tgz",
+      "resolved": "https://registry.facebook.net/postcss-discard-duplicates/-/postcss-discard-duplicates-6.0.3.tgz",
       "integrity": "sha512-+JA0DCvc5XvFAxwx6f/e68gQu/7Z9ud584VLmcgto28eB8FqSFZwtrLwB5Kcp70eIoWP/HXqz4wpo8rD8gpsTw==",
       "license": "MIT",
       "engines": {
@@ -13702,7 +13042,7 @@
     },
     "node_modules/postcss-discard-empty": {
       "version": "6.0.3",
-      "resolved": "https://registry.npmjs.org/postcss-discard-empty/-/postcss-discard-empty-6.0.3.tgz",
+      "resolved": "https://registry.facebook.net/postcss-discard-empty/-/postcss-discard-empty-6.0.3.tgz",
       "integrity": "sha512-znyno9cHKQsK6PtxL5D19Fj9uwSzC2mB74cpT66fhgOadEUPyXFkbgwm5tvc3bt3NAy8ltE5MrghxovZRVnOjQ==",
       "license": "MIT",
       "engines": {
@@ -13714,7 +13054,7 @@
     },
     "node_modules/postcss-discard-overridden": {
       "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/postcss-discard-overridden/-/postcss-discard-overridden-6.0.2.tgz",
+      "resolved": "https://registry.facebook.net/postcss-discard-overridden/-/postcss-discard-overridden-6.0.2.tgz",
       "integrity": "sha512-j87xzI4LUggC5zND7KdjsI25APtyMuynXZSujByMaav2roV6OZX+8AaCUcZSWqckZpjAjRyFDdpqybgjFO0HJQ==",
       "license": "MIT",
       "engines": {
@@ -13726,7 +13066,7 @@
     },
     "node_modules/postcss-discard-unused": {
       "version": "6.0.5",
-      "resolved": "https://registry.npmjs.org/postcss-discard-unused/-/postcss-discard-unused-6.0.5.tgz",
+      "resolved": "https://registry.facebook.net/postcss-discard-unused/-/postcss-discard-unused-6.0.5.tgz",
       "integrity": "sha512-wHalBlRHkaNnNwfC8z+ppX57VhvS+HWgjW508esjdaEYr3Mx7Gnn2xA4R/CKf5+Z9S5qsqC+Uzh4ueENWwCVUA==",
       "license": "MIT",
       "dependencies": {
@@ -13739,10 +13079,23 @@
         "postcss": "^8.4.31"
       }
     },
+    "node_modules/postcss-discard-unused/node_modules/postcss-selector-parser": {
+      "version": "6.1.2",
+      "resolved": "https://registry.facebook.net/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
+      "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
+      "license": "MIT",
+      "dependencies": {
+        "cssesc": "^3.0.0",
+        "util-deprecate": "^1.0.2"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/postcss-double-position-gradients": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-double-position-gradients/-/postcss-double-position-gradients-6.0.0.tgz",
-      "integrity": "sha512-JkIGah3RVbdSEIrcobqj4Gzq0h53GG4uqDPsho88SgY84WnpkTpI0k50MFK/sX7XqVisZ6OqUfFnoUO6m1WWdg==",
+      "version": "6.0.4",
+      "resolved": "https://registry.facebook.net/postcss-double-position-gradients/-/postcss-double-position-gradients-6.0.4.tgz",
+      "integrity": "sha512-m6IKmxo7FxSP5nF2l63QbCC3r+bWpFUWmZXZf096WxG0m7Vl1Q1+ruFOhpdDRmKrRS+S3Jtk+TVk/7z0+BVK6g==",
       "funding": [
         {
           "type": "github",
@@ -13755,7 +13108,7 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/postcss-progressive-custom-properties": "^4.0.0",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
         "@csstools/utilities": "^2.0.0",
         "postcss-value-parser": "^4.2.0"
       },
@@ -13768,7 +13121,7 @@
     },
     "node_modules/postcss-focus-visible": {
       "version": "10.0.1",
-      "resolved": "https://registry.npmjs.org/postcss-focus-visible/-/postcss-focus-visible-10.0.1.tgz",
+      "resolved": "https://registry.facebook.net/postcss-focus-visible/-/postcss-focus-visible-10.0.1.tgz",
       "integrity": "sha512-U58wyjS/I1GZgjRok33aE8juW9qQgQUNwTSdxQGuShHzwuYdcklnvK/+qOWX1Q9kr7ysbraQ6ht6r+udansalA==",
       "funding": [
         {
@@ -13791,22 +13144,9 @@
         "postcss": "^8.4"
       }
     },
-    "node_modules/postcss-focus-visible/node_modules/postcss-selector-parser": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.0.0.tgz",
-      "integrity": "sha512-9RbEr1Y7FFfptd/1eEdntyjMwLeghW1bHX9GWjXo19vx4ytPQhANltvVxDggzJl7mnWM+dX28kb6cyS/4iQjlQ==",
-      "license": "MIT",
-      "dependencies": {
-        "cssesc": "^3.0.0",
-        "util-deprecate": "^1.0.2"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/postcss-focus-within": {
       "version": "9.0.1",
-      "resolved": "https://registry.npmjs.org/postcss-focus-within/-/postcss-focus-within-9.0.1.tgz",
+      "resolved": "https://registry.facebook.net/postcss-focus-within/-/postcss-focus-within-9.0.1.tgz",
       "integrity": "sha512-fzNUyS1yOYa7mOjpci/bR+u+ESvdar6hk8XNK/TRR0fiGTp2QT5N+ducP0n3rfH/m9I7H/EQU6lsa2BrgxkEjw==",
       "funding": [
         {
@@ -13829,22 +13169,9 @@
         "postcss": "^8.4"
       }
     },
-    "node_modules/postcss-focus-within/node_modules/postcss-selector-parser": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.0.0.tgz",
-      "integrity": "sha512-9RbEr1Y7FFfptd/1eEdntyjMwLeghW1bHX9GWjXo19vx4ytPQhANltvVxDggzJl7mnWM+dX28kb6cyS/4iQjlQ==",
-      "license": "MIT",
-      "dependencies": {
-        "cssesc": "^3.0.0",
-        "util-deprecate": "^1.0.2"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/postcss-font-variant": {
       "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-font-variant/-/postcss-font-variant-5.0.0.tgz",
+      "resolved": "https://registry.facebook.net/postcss-font-variant/-/postcss-font-variant-5.0.0.tgz",
       "integrity": "sha512-1fmkBaCALD72CK2a9i468mA/+tr9/1cBxRRMXOUaZqO43oWPR5imcyPjXwuv7PXbCid4ndlP5zWhidQVVa3hmA==",
       "license": "MIT",
       "peerDependencies": {
@@ -13853,7 +13180,7 @@
     },
     "node_modules/postcss-gap-properties": {
       "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-gap-properties/-/postcss-gap-properties-6.0.0.tgz",
+      "resolved": "https://registry.facebook.net/postcss-gap-properties/-/postcss-gap-properties-6.0.0.tgz",
       "integrity": "sha512-Om0WPjEwiM9Ru+VhfEDPZJAKWUd0mV1HmNXqp2C29z80aQ2uP9UVhLc7e3aYMIor/S5cVhoPgYQ7RtfeZpYTRw==",
       "funding": [
         {
@@ -13875,7 +13202,7 @@
     },
     "node_modules/postcss-image-set-function": {
       "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-image-set-function/-/postcss-image-set-function-7.0.0.tgz",
+      "resolved": "https://registry.facebook.net/postcss-image-set-function/-/postcss-image-set-function-7.0.0.tgz",
       "integrity": "sha512-QL7W7QNlZuzOwBTeXEmbVckNt1FSmhQtbMRvGGqqU4Nf4xk6KUEQhAoWuMzwbSv5jxiRiSZ5Tv7eiDB9U87znA==",
       "funding": [
         {
@@ -13900,9 +13227,9 @@
       }
     },
     "node_modules/postcss-lab-function": {
-      "version": "7.0.7",
-      "resolved": "https://registry.npmjs.org/postcss-lab-function/-/postcss-lab-function-7.0.7.tgz",
-      "integrity": "sha512-+ONj2bpOQfsCKZE2T9VGMyVVdGcGUpr7u3SVfvkJlvhTRmDCfY25k4Jc8fubB9DclAPR4+w8uVtDZmdRgdAHig==",
+      "version": "7.0.12",
+      "resolved": "https://registry.facebook.net/postcss-lab-function/-/postcss-lab-function-7.0.12.tgz",
+      "integrity": "sha512-tUcyRk1ZTPec3OuKFsqtRzW2Go5lehW29XA21lZ65XmzQkz43VY2tyWEC202F7W3mILOjw0voOiuxRGTsN+J9w==",
       "funding": [
         {
           "type": "github",
@@ -13915,10 +13242,10 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/css-color-parser": "^3.0.7",
-        "@csstools/css-parser-algorithms": "^3.0.4",
-        "@csstools/css-tokenizer": "^3.0.3",
-        "@csstools/postcss-progressive-custom-properties": "^4.0.0",
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
         "@csstools/utilities": "^2.0.0"
       },
       "engines": {
@@ -13930,7 +13257,7 @@
     },
     "node_modules/postcss-loader": {
       "version": "7.3.4",
-      "resolved": "https://registry.npmjs.org/postcss-loader/-/postcss-loader-7.3.4.tgz",
+      "resolved": "https://registry.facebook.net/postcss-loader/-/postcss-loader-7.3.4.tgz",
       "integrity": "sha512-iW5WTTBSC5BfsBJ9daFMPVrLT36MrNiC6fqOZTTaHjBNX6Pfd5p+hSBqe/fEeNd7pc13QiAyGt7VdGMw4eRC4A==",
       "license": "MIT",
       "dependencies": {
@@ -13950,10 +13277,22 @@
         "webpack": "^5.0.0"
       }
     },
+    "node_modules/postcss-loader/node_modules/semver": {
+      "version": "7.7.4",
+      "resolved": "https://registry.facebook.net/semver/-/semver-7.7.4.tgz",
+      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/postcss-logical": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-logical/-/postcss-logical-8.0.0.tgz",
-      "integrity": "sha512-HpIdsdieClTjXLOyYdUPAX/XQASNIwdKt5hoZW08ZOAiI+tbV0ta1oclkpVkW5ANU+xJvk3KkA0FejkjGLXUkg==",
+      "version": "8.1.0",
+      "resolved": "https://registry.facebook.net/postcss-logical/-/postcss-logical-8.1.0.tgz",
+      "integrity": "sha512-pL1hXFQ2fEXNKiNiAgtfA005T9FBxky5zkX6s4GZM2D8RkVgRqz3f4g1JUoq925zXv495qk8UNldDwh8uGEDoA==",
       "funding": [
         {
           "type": "github",
@@ -13977,7 +13316,7 @@
     },
     "node_modules/postcss-merge-idents": {
       "version": "6.0.3",
-      "resolved": "https://registry.npmjs.org/postcss-merge-idents/-/postcss-merge-idents-6.0.3.tgz",
+      "resolved": "https://registry.facebook.net/postcss-merge-idents/-/postcss-merge-idents-6.0.3.tgz",
       "integrity": "sha512-1oIoAsODUs6IHQZkLQGO15uGEbK3EAl5wi9SS8hs45VgsxQfMnxvt+L+zIr7ifZFIH14cfAeVe2uCTa+SPRa3g==",
       "license": "MIT",
       "dependencies": {
@@ -13993,7 +13332,7 @@
     },
     "node_modules/postcss-merge-longhand": {
       "version": "6.0.5",
-      "resolved": "https://registry.npmjs.org/postcss-merge-longhand/-/postcss-merge-longhand-6.0.5.tgz",
+      "resolved": "https://registry.facebook.net/postcss-merge-longhand/-/postcss-merge-longhand-6.0.5.tgz",
       "integrity": "sha512-5LOiordeTfi64QhICp07nzzuTDjNSO8g5Ksdibt44d+uvIIAE1oZdRn8y/W5ZtYgRH/lnLDlvi9F8btZcVzu3w==",
       "license": "MIT",
       "dependencies": {
@@ -14009,7 +13348,7 @@
     },
     "node_modules/postcss-merge-rules": {
       "version": "6.1.1",
-      "resolved": "https://registry.npmjs.org/postcss-merge-rules/-/postcss-merge-rules-6.1.1.tgz",
+      "resolved": "https://registry.facebook.net/postcss-merge-rules/-/postcss-merge-rules-6.1.1.tgz",
       "integrity": "sha512-KOdWF0gju31AQPZiD+2Ar9Qjowz1LTChSjFFbS+e2sFgc4uHOp3ZvVX4sNeTlk0w2O31ecFGgrFzhO0RSWbWwQ==",
       "license": "MIT",
       "dependencies": {
@@ -14025,9 +13364,22 @@
         "postcss": "^8.4.31"
       }
     },
+    "node_modules/postcss-merge-rules/node_modules/postcss-selector-parser": {
+      "version": "6.1.2",
+      "resolved": "https://registry.facebook.net/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
+      "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
+      "license": "MIT",
+      "dependencies": {
+        "cssesc": "^3.0.0",
+        "util-deprecate": "^1.0.2"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/postcss-minify-font-values": {
       "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/postcss-minify-font-values/-/postcss-minify-font-values-6.1.0.tgz",
+      "resolved": "https://registry.facebook.net/postcss-minify-font-values/-/postcss-minify-font-values-6.1.0.tgz",
       "integrity": "sha512-gklfI/n+9rTh8nYaSJXlCo3nOKqMNkxuGpTn/Qm0gstL3ywTr9/WRKznE+oy6fvfolH6dF+QM4nCo8yPLdvGJg==",
       "license": "MIT",
       "dependencies": {
@@ -14042,7 +13394,7 @@
     },
     "node_modules/postcss-minify-gradients": {
       "version": "6.0.3",
-      "resolved": "https://registry.npmjs.org/postcss-minify-gradients/-/postcss-minify-gradients-6.0.3.tgz",
+      "resolved": "https://registry.facebook.net/postcss-minify-gradients/-/postcss-minify-gradients-6.0.3.tgz",
       "integrity": "sha512-4KXAHrYlzF0Rr7uc4VrfwDJ2ajrtNEpNEuLxFgwkhFZ56/7gaE4Nr49nLsQDZyUe+ds+kEhf+YAUolJiYXF8+Q==",
       "license": "MIT",
       "dependencies": {
@@ -14059,7 +13411,7 @@
     },
     "node_modules/postcss-minify-params": {
       "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/postcss-minify-params/-/postcss-minify-params-6.1.0.tgz",
+      "resolved": "https://registry.facebook.net/postcss-minify-params/-/postcss-minify-params-6.1.0.tgz",
       "integrity": "sha512-bmSKnDtyyE8ujHQK0RQJDIKhQ20Jq1LYiez54WiaOoBtcSuflfK3Nm596LvbtlFcpipMjgClQGyGr7GAs+H1uA==",
       "license": "MIT",
       "dependencies": {
@@ -14076,7 +13428,7 @@
     },
     "node_modules/postcss-minify-selectors": {
       "version": "6.0.4",
-      "resolved": "https://registry.npmjs.org/postcss-minify-selectors/-/postcss-minify-selectors-6.0.4.tgz",
+      "resolved": "https://registry.facebook.net/postcss-minify-selectors/-/postcss-minify-selectors-6.0.4.tgz",
       "integrity": "sha512-L8dZSwNLgK7pjTto9PzWRoMbnLq5vsZSTu8+j1P/2GB8qdtGQfn+K1uSvFgYvgh83cbyxT5m43ZZhUMTJDSClQ==",
       "license": "MIT",
       "dependencies": {
@@ -14089,9 +13441,22 @@
         "postcss": "^8.4.31"
       }
     },
+    "node_modules/postcss-minify-selectors/node_modules/postcss-selector-parser": {
+      "version": "6.1.2",
+      "resolved": "https://registry.facebook.net/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
+      "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
+      "license": "MIT",
+      "dependencies": {
+        "cssesc": "^3.0.0",
+        "util-deprecate": "^1.0.2"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/postcss-modules-extract-imports": {
       "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/postcss-modules-extract-imports/-/postcss-modules-extract-imports-3.1.0.tgz",
+      "resolved": "https://registry.facebook.net/postcss-modules-extract-imports/-/postcss-modules-extract-imports-3.1.0.tgz",
       "integrity": "sha512-k3kNe0aNFQDAZGbin48pL2VNidTF0w4/eASDsxlyspobzU3wZQLOGj7L9gfRe0Jo9/4uud09DsjFNH7winGv8Q==",
       "license": "ISC",
       "engines": {
@@ -14103,7 +13468,7 @@
     },
     "node_modules/postcss-modules-local-by-default": {
       "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/postcss-modules-local-by-default/-/postcss-modules-local-by-default-4.2.0.tgz",
+      "resolved": "https://registry.facebook.net/postcss-modules-local-by-default/-/postcss-modules-local-by-default-4.2.0.tgz",
       "integrity": "sha512-5kcJm/zk+GJDSfw+V/42fJ5fhjL5YbFDl8nVdXkJPLLW+Vf9mTD5Xe0wqIaDnLuL2U6cDNpTr+UQ+v2HWIBhzw==",
       "license": "MIT",
       "dependencies": {
@@ -14118,22 +13483,9 @@
         "postcss": "^8.1.0"
       }
     },
-    "node_modules/postcss-modules-local-by-default/node_modules/postcss-selector-parser": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.0.0.tgz",
-      "integrity": "sha512-9RbEr1Y7FFfptd/1eEdntyjMwLeghW1bHX9GWjXo19vx4ytPQhANltvVxDggzJl7mnWM+dX28kb6cyS/4iQjlQ==",
-      "license": "MIT",
-      "dependencies": {
-        "cssesc": "^3.0.0",
-        "util-deprecate": "^1.0.2"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/postcss-modules-scope": {
       "version": "3.2.1",
-      "resolved": "https://registry.npmjs.org/postcss-modules-scope/-/postcss-modules-scope-3.2.1.tgz",
+      "resolved": "https://registry.facebook.net/postcss-modules-scope/-/postcss-modules-scope-3.2.1.tgz",
       "integrity": "sha512-m9jZstCVaqGjTAuny8MdgE88scJnCiQSlSrOWcTQgM2t32UBe+MUmFSO5t7VMSfAf/FJKImAxBav8ooCHJXCJA==",
       "license": "ISC",
       "dependencies": {
@@ -14146,22 +13498,9 @@
         "postcss": "^8.1.0"
       }
     },
-    "node_modules/postcss-modules-scope/node_modules/postcss-selector-parser": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.0.0.tgz",
-      "integrity": "sha512-9RbEr1Y7FFfptd/1eEdntyjMwLeghW1bHX9GWjXo19vx4ytPQhANltvVxDggzJl7mnWM+dX28kb6cyS/4iQjlQ==",
-      "license": "MIT",
-      "dependencies": {
-        "cssesc": "^3.0.0",
-        "util-deprecate": "^1.0.2"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/postcss-modules-values": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-modules-values/-/postcss-modules-values-4.0.0.tgz",
+      "resolved": "https://registry.facebook.net/postcss-modules-values/-/postcss-modules-values-4.0.0.tgz",
       "integrity": "sha512-RDxHkAiEGI78gS2ofyvCsu7iycRv7oqw5xMWn9iMoR0N/7mf9D50ecQqUo5BZ9Zh2vH4bCUR/ktCqbB9m8vJjQ==",
       "license": "ISC",
       "dependencies": {
@@ -14175,9 +13514,9 @@
       }
     },
     "node_modules/postcss-nesting": {
-      "version": "13.0.1",
-      "resolved": "https://registry.npmjs.org/postcss-nesting/-/postcss-nesting-13.0.1.tgz",
-      "integrity": "sha512-VbqqHkOBOt4Uu3G8Dm8n6lU5+9cJFxiuty9+4rcoyRPO9zZS1JIs6td49VIoix3qYqELHlJIn46Oih9SAKo+yQ==",
+      "version": "13.0.2",
+      "resolved": "https://registry.facebook.net/postcss-nesting/-/postcss-nesting-13.0.2.tgz",
+      "integrity": "sha512-1YCI290TX+VP0U/K/aFxzHzQWHWURL+CtHMSbex1lCdpXD1SoR2sYuxDu5aNI9lPoXpKTCggFZiDJbwylU0LEQ==",
       "funding": [
         {
           "type": "github",
@@ -14190,7 +13529,7 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/selector-resolve-nested": "^3.0.0",
+        "@csstools/selector-resolve-nested": "^3.1.0",
         "@csstools/selector-specificity": "^5.0.0",
         "postcss-selector-parser": "^7.0.0"
       },
@@ -14201,78 +13540,21 @@
         "postcss": "^8.4"
       }
     },
-    "node_modules/postcss-nesting/node_modules/@csstools/selector-resolve-nested": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/@csstools/selector-resolve-nested/-/selector-resolve-nested-3.0.0.tgz",
-      "integrity": "sha512-ZoK24Yku6VJU1gS79a5PFmC8yn3wIapiKmPgun0hZgEI5AOqgH2kiPRsPz1qkGv4HL+wuDLH83yQyk6inMYrJQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/csstools"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/csstools"
-        }
-      ],
-      "license": "MIT-0",
+    "node_modules/postcss-normalize-charset": {
+      "version": "6.0.2",
+      "resolved": "https://registry.facebook.net/postcss-normalize-charset/-/postcss-normalize-charset-6.0.2.tgz",
+      "integrity": "sha512-a8N9czmdnrjPHa3DeFlwqst5eaL5W8jYu3EBbTTkI5FHkfMhFZh1EGbku6jhHhIzTA6tquI2P42NtZ59M/H/kQ==",
+      "license": "MIT",
       "engines": {
-        "node": ">=18"
+        "node": "^14 || ^16 || >=18.0"
       },
       "peerDependencies": {
-        "postcss-selector-parser": "^7.0.0"
-      }
-    },
-    "node_modules/postcss-nesting/node_modules/@csstools/selector-specificity": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/@csstools/selector-specificity/-/selector-specificity-5.0.0.tgz",
-      "integrity": "sha512-PCqQV3c4CoVm3kdPhyeZ07VmBRdH2EpMFA/pd9OASpOEC3aXNGoqPDAZ80D0cLpMBxnmk0+yNhGsEx31hq7Gtw==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/csstools"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/csstools"
-        }
-      ],
-      "license": "MIT-0",
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "postcss-selector-parser": "^7.0.0"
-      }
-    },
-    "node_modules/postcss-nesting/node_modules/postcss-selector-parser": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.0.0.tgz",
-      "integrity": "sha512-9RbEr1Y7FFfptd/1eEdntyjMwLeghW1bHX9GWjXo19vx4ytPQhANltvVxDggzJl7mnWM+dX28kb6cyS/4iQjlQ==",
-      "license": "MIT",
-      "dependencies": {
-        "cssesc": "^3.0.0",
-        "util-deprecate": "^1.0.2"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/postcss-normalize-charset": {
-      "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/postcss-normalize-charset/-/postcss-normalize-charset-6.0.2.tgz",
-      "integrity": "sha512-a8N9czmdnrjPHa3DeFlwqst5eaL5W8jYu3EBbTTkI5FHkfMhFZh1EGbku6jhHhIzTA6tquI2P42NtZ59M/H/kQ==",
-      "license": "MIT",
-      "engines": {
-        "node": "^14 || ^16 || >=18.0"
-      },
-      "peerDependencies": {
-        "postcss": "^8.4.31"
+        "postcss": "^8.4.31"
       }
     },
     "node_modules/postcss-normalize-display-values": {
       "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/postcss-normalize-display-values/-/postcss-normalize-display-values-6.0.2.tgz",
+      "resolved": "https://registry.facebook.net/postcss-normalize-display-values/-/postcss-normalize-display-values-6.0.2.tgz",
       "integrity": "sha512-8H04Mxsb82ON/aAkPeq8kcBbAtI5Q2a64X/mnRRfPXBq7XeogoQvReqxEfc0B4WPq1KimjezNC8flUtC3Qz6jg==",
       "license": "MIT",
       "dependencies": {
@@ -14287,7 +13569,7 @@
     },
     "node_modules/postcss-normalize-positions": {
       "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/postcss-normalize-positions/-/postcss-normalize-positions-6.0.2.tgz",
+      "resolved": "https://registry.facebook.net/postcss-normalize-positions/-/postcss-normalize-positions-6.0.2.tgz",
       "integrity": "sha512-/JFzI441OAB9O7VnLA+RtSNZvQ0NCFZDOtp6QPFo1iIyawyXg0YI3CYM9HBy1WvwCRHnPep/BvI1+dGPKoXx/Q==",
       "license": "MIT",
       "dependencies": {
@@ -14302,7 +13584,7 @@
     },
     "node_modules/postcss-normalize-repeat-style": {
       "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/postcss-normalize-repeat-style/-/postcss-normalize-repeat-style-6.0.2.tgz",
+      "resolved": "https://registry.facebook.net/postcss-normalize-repeat-style/-/postcss-normalize-repeat-style-6.0.2.tgz",
       "integrity": "sha512-YdCgsfHkJ2jEXwR4RR3Tm/iOxSfdRt7jplS6XRh9Js9PyCR/aka/FCb6TuHT2U8gQubbm/mPmF6L7FY9d79VwQ==",
       "license": "MIT",
       "dependencies": {
@@ -14317,7 +13599,7 @@
     },
     "node_modules/postcss-normalize-string": {
       "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/postcss-normalize-string/-/postcss-normalize-string-6.0.2.tgz",
+      "resolved": "https://registry.facebook.net/postcss-normalize-string/-/postcss-normalize-string-6.0.2.tgz",
       "integrity": "sha512-vQZIivlxlfqqMp4L9PZsFE4YUkWniziKjQWUtsxUiVsSSPelQydwS8Wwcuw0+83ZjPWNTl02oxlIvXsmmG+CiQ==",
       "license": "MIT",
       "dependencies": {
@@ -14332,7 +13614,7 @@
     },
     "node_modules/postcss-normalize-timing-functions": {
       "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/postcss-normalize-timing-functions/-/postcss-normalize-timing-functions-6.0.2.tgz",
+      "resolved": "https://registry.facebook.net/postcss-normalize-timing-functions/-/postcss-normalize-timing-functions-6.0.2.tgz",
       "integrity": "sha512-a+YrtMox4TBtId/AEwbA03VcJgtyW4dGBizPl7e88cTFULYsprgHWTbfyjSLyHeBcK/Q9JhXkt2ZXiwaVHoMzA==",
       "license": "MIT",
       "dependencies": {
@@ -14347,7 +13629,7 @@
     },
     "node_modules/postcss-normalize-unicode": {
       "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/postcss-normalize-unicode/-/postcss-normalize-unicode-6.1.0.tgz",
+      "resolved": "https://registry.facebook.net/postcss-normalize-unicode/-/postcss-normalize-unicode-6.1.0.tgz",
       "integrity": "sha512-QVC5TQHsVj33otj8/JD869Ndr5Xcc/+fwRh4HAsFsAeygQQXm+0PySrKbr/8tkDKzW+EVT3QkqZMfFrGiossDg==",
       "license": "MIT",
       "dependencies": {
@@ -14363,7 +13645,7 @@
     },
     "node_modules/postcss-normalize-url": {
       "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/postcss-normalize-url/-/postcss-normalize-url-6.0.2.tgz",
+      "resolved": "https://registry.facebook.net/postcss-normalize-url/-/postcss-normalize-url-6.0.2.tgz",
       "integrity": "sha512-kVNcWhCeKAzZ8B4pv/DnrU1wNh458zBNp8dh4y5hhxih5RZQ12QWMuQrDgPRw3LRl8mN9vOVfHl7uhvHYMoXsQ==",
       "license": "MIT",
       "dependencies": {
@@ -14378,7 +13660,7 @@
     },
     "node_modules/postcss-normalize-whitespace": {
       "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/postcss-normalize-whitespace/-/postcss-normalize-whitespace-6.0.2.tgz",
+      "resolved": "https://registry.facebook.net/postcss-normalize-whitespace/-/postcss-normalize-whitespace-6.0.2.tgz",
       "integrity": "sha512-sXZ2Nj1icbJOKmdjXVT9pnyHQKiSAyuNQHSgRCUgThn2388Y9cGVDR+E9J9iAYbSbLHI+UUwLVl1Wzco/zgv0Q==",
       "license": "MIT",
       "dependencies": {
@@ -14393,7 +13675,7 @@
     },
     "node_modules/postcss-opacity-percentage": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-opacity-percentage/-/postcss-opacity-percentage-3.0.0.tgz",
+      "resolved": "https://registry.facebook.net/postcss-opacity-percentage/-/postcss-opacity-percentage-3.0.0.tgz",
       "integrity": "sha512-K6HGVzyxUxd/VgZdX04DCtdwWJ4NGLG212US4/LA1TLAbHgmAsTWVR86o+gGIbFtnTkfOpb9sCRBx8K7HO66qQ==",
       "funding": [
         {
@@ -14415,7 +13697,7 @@
     },
     "node_modules/postcss-ordered-values": {
       "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/postcss-ordered-values/-/postcss-ordered-values-6.0.2.tgz",
+      "resolved": "https://registry.facebook.net/postcss-ordered-values/-/postcss-ordered-values-6.0.2.tgz",
       "integrity": "sha512-VRZSOB+JU32RsEAQrO94QPkClGPKJEL/Z9PCBImXMhIeK5KAYo6slP/hBYlLgrCjFxyqvn5VC81tycFEDBLG1Q==",
       "license": "MIT",
       "dependencies": {
@@ -14431,7 +13713,7 @@
     },
     "node_modules/postcss-overflow-shorthand": {
       "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-overflow-shorthand/-/postcss-overflow-shorthand-6.0.0.tgz",
+      "resolved": "https://registry.facebook.net/postcss-overflow-shorthand/-/postcss-overflow-shorthand-6.0.0.tgz",
       "integrity": "sha512-BdDl/AbVkDjoTofzDQnwDdm/Ym6oS9KgmO7Gr+LHYjNWJ6ExORe4+3pcLQsLA9gIROMkiGVjjwZNoL/mpXHd5Q==",
       "funding": [
         {
@@ -14456,7 +13738,7 @@
     },
     "node_modules/postcss-page-break": {
       "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/postcss-page-break/-/postcss-page-break-3.0.4.tgz",
+      "resolved": "https://registry.facebook.net/postcss-page-break/-/postcss-page-break-3.0.4.tgz",
       "integrity": "sha512-1JGu8oCjVXLa9q9rFTo4MbeeA5FMe00/9C7lN4va606Rdb+HkxXtXsmEDrIraQ11fGz/WvKWa8gMuCKkrXpTsQ==",
       "license": "MIT",
       "peerDependencies": {
@@ -14465,7 +13747,7 @@
     },
     "node_modules/postcss-place": {
       "version": "10.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-place/-/postcss-place-10.0.0.tgz",
+      "resolved": "https://registry.facebook.net/postcss-place/-/postcss-place-10.0.0.tgz",
       "integrity": "sha512-5EBrMzat2pPAxQNWYavwAfoKfYcTADJ8AXGVPcUZ2UkNloUTWzJQExgrzrDkh3EKzmAx1evfTAzF9I8NGcc+qw==",
       "funding": [
         {
@@ -14489,9 +13771,9 @@
       }
     },
     "node_modules/postcss-preset-env": {
-      "version": "10.1.3",
-      "resolved": "https://registry.npmjs.org/postcss-preset-env/-/postcss-preset-env-10.1.3.tgz",
-      "integrity": "sha512-9qzVhcMFU/MnwYHyYpJz4JhGku/4+xEiPTmhn0hj3IxnUYlEF9vbh7OC1KoLAnenS6Fgg43TKNp9xcuMeAi4Zw==",
+      "version": "10.6.1",
+      "resolved": "https://registry.facebook.net/postcss-preset-env/-/postcss-preset-env-10.6.1.tgz",
+      "integrity": "sha512-yrk74d9EvY+W7+lO9Aj1QmjWY9q5NsKjK2V9drkOPZB/X6KZ0B3igKsHUYakb7oYVhnioWypQX3xGuePf89f3g==",
       "funding": [
         {
           "type": "github",
@@ -14504,62 +13786,70 @@
       ],
       "license": "MIT-0",
       "dependencies": {
-        "@csstools/postcss-cascade-layers": "^5.0.1",
-        "@csstools/postcss-color-function": "^4.0.7",
-        "@csstools/postcss-color-mix-function": "^3.0.7",
-        "@csstools/postcss-content-alt-text": "^2.0.4",
-        "@csstools/postcss-exponential-functions": "^2.0.6",
+        "@csstools/postcss-alpha-function": "^1.0.1",
+        "@csstools/postcss-cascade-layers": "^5.0.2",
+        "@csstools/postcss-color-function": "^4.0.12",
+        "@csstools/postcss-color-function-display-p3-linear": "^1.0.1",
+        "@csstools/postcss-color-mix-function": "^3.0.12",
+        "@csstools/postcss-color-mix-variadic-function-arguments": "^1.0.2",
+        "@csstools/postcss-content-alt-text": "^2.0.8",
+        "@csstools/postcss-contrast-color-function": "^2.0.12",
+        "@csstools/postcss-exponential-functions": "^2.0.9",
         "@csstools/postcss-font-format-keywords": "^4.0.0",
-        "@csstools/postcss-gamut-mapping": "^2.0.7",
-        "@csstools/postcss-gradients-interpolation-method": "^5.0.7",
-        "@csstools/postcss-hwb-function": "^4.0.7",
-        "@csstools/postcss-ic-unit": "^4.0.0",
-        "@csstools/postcss-initial": "^2.0.0",
-        "@csstools/postcss-is-pseudo-class": "^5.0.1",
-        "@csstools/postcss-light-dark-function": "^2.0.7",
+        "@csstools/postcss-gamut-mapping": "^2.0.11",
+        "@csstools/postcss-gradients-interpolation-method": "^5.0.12",
+        "@csstools/postcss-hwb-function": "^4.0.12",
+        "@csstools/postcss-ic-unit": "^4.0.4",
+        "@csstools/postcss-initial": "^2.0.1",
+        "@csstools/postcss-is-pseudo-class": "^5.0.3",
+        "@csstools/postcss-light-dark-function": "^2.0.11",
         "@csstools/postcss-logical-float-and-clear": "^3.0.0",
         "@csstools/postcss-logical-overflow": "^2.0.0",
         "@csstools/postcss-logical-overscroll-behavior": "^2.0.0",
         "@csstools/postcss-logical-resize": "^3.0.0",
-        "@csstools/postcss-logical-viewport-units": "^3.0.3",
-        "@csstools/postcss-media-minmax": "^2.0.6",
-        "@csstools/postcss-media-queries-aspect-ratio-number-values": "^3.0.4",
+        "@csstools/postcss-logical-viewport-units": "^3.0.4",
+        "@csstools/postcss-media-minmax": "^2.0.9",
+        "@csstools/postcss-media-queries-aspect-ratio-number-values": "^3.0.5",
         "@csstools/postcss-nested-calc": "^4.0.0",
-        "@csstools/postcss-normalize-display-values": "^4.0.0",
-        "@csstools/postcss-oklab-function": "^4.0.7",
-        "@csstools/postcss-progressive-custom-properties": "^4.0.0",
-        "@csstools/postcss-random-function": "^1.0.2",
-        "@csstools/postcss-relative-color-syntax": "^3.0.7",
+        "@csstools/postcss-normalize-display-values": "^4.0.1",
+        "@csstools/postcss-oklab-function": "^4.0.12",
+        "@csstools/postcss-position-area-property": "^1.0.0",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/postcss-property-rule-prelude-list": "^1.0.0",
+        "@csstools/postcss-random-function": "^2.0.1",
+        "@csstools/postcss-relative-color-syntax": "^3.0.12",
         "@csstools/postcss-scope-pseudo-class": "^4.0.1",
-        "@csstools/postcss-sign-functions": "^1.1.1",
-        "@csstools/postcss-stepped-value-functions": "^4.0.6",
-        "@csstools/postcss-text-decoration-shorthand": "^4.0.1",
-        "@csstools/postcss-trigonometric-functions": "^4.0.6",
+        "@csstools/postcss-sign-functions": "^1.1.4",
+        "@csstools/postcss-stepped-value-functions": "^4.0.9",
+        "@csstools/postcss-syntax-descriptor-syntax-production": "^1.0.1",
+        "@csstools/postcss-system-ui-font-family": "^1.0.0",
+        "@csstools/postcss-text-decoration-shorthand": "^4.0.3",
+        "@csstools/postcss-trigonometric-functions": "^4.0.9",
         "@csstools/postcss-unset-value": "^4.0.0",
-        "autoprefixer": "^10.4.19",
-        "browserslist": "^4.23.1",
+        "autoprefixer": "^10.4.23",
+        "browserslist": "^4.28.1",
         "css-blank-pseudo": "^7.0.1",
-        "css-has-pseudo": "^7.0.2",
+        "css-has-pseudo": "^7.0.3",
         "css-prefers-color-scheme": "^10.0.0",
-        "cssdb": "^8.2.3",
+        "cssdb": "^8.6.0",
         "postcss-attribute-case-insensitive": "^7.0.1",
         "postcss-clamp": "^4.1.0",
-        "postcss-color-functional-notation": "^7.0.7",
+        "postcss-color-functional-notation": "^7.0.12",
         "postcss-color-hex-alpha": "^10.0.0",
         "postcss-color-rebeccapurple": "^10.0.0",
-        "postcss-custom-media": "^11.0.5",
-        "postcss-custom-properties": "^14.0.4",
-        "postcss-custom-selectors": "^8.0.4",
+        "postcss-custom-media": "^11.0.6",
+        "postcss-custom-properties": "^14.0.6",
+        "postcss-custom-selectors": "^8.0.5",
         "postcss-dir-pseudo-class": "^9.0.1",
-        "postcss-double-position-gradients": "^6.0.0",
+        "postcss-double-position-gradients": "^6.0.4",
         "postcss-focus-visible": "^10.0.1",
         "postcss-focus-within": "^9.0.1",
         "postcss-font-variant": "^5.0.0",
         "postcss-gap-properties": "^6.0.0",
         "postcss-image-set-function": "^7.0.0",
-        "postcss-lab-function": "^7.0.7",
-        "postcss-logical": "^8.0.0",
-        "postcss-nesting": "^13.0.1",
+        "postcss-lab-function": "^7.0.12",
+        "postcss-logical": "^8.1.0",
+        "postcss-nesting": "^13.0.2",
         "postcss-opacity-percentage": "^3.0.0",
         "postcss-overflow-shorthand": "^6.0.0",
         "postcss-page-break": "^3.0.4",
@@ -14577,7 +13867,7 @@
     },
     "node_modules/postcss-pseudo-class-any-link": {
       "version": "10.0.1",
-      "resolved": "https://registry.npmjs.org/postcss-pseudo-class-any-link/-/postcss-pseudo-class-any-link-10.0.1.tgz",
+      "resolved": "https://registry.facebook.net/postcss-pseudo-class-any-link/-/postcss-pseudo-class-any-link-10.0.1.tgz",
       "integrity": "sha512-3el9rXlBOqTFaMFkWDOkHUTQekFIYnaQY55Rsp8As8QQkpiSgIYEcF/6Ond93oHiDsGb4kad8zjt+NPlOC1H0Q==",
       "funding": [
         {
@@ -14600,22 +13890,9 @@
         "postcss": "^8.4"
       }
     },
-    "node_modules/postcss-pseudo-class-any-link/node_modules/postcss-selector-parser": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.0.0.tgz",
-      "integrity": "sha512-9RbEr1Y7FFfptd/1eEdntyjMwLeghW1bHX9GWjXo19vx4ytPQhANltvVxDggzJl7mnWM+dX28kb6cyS/4iQjlQ==",
-      "license": "MIT",
-      "dependencies": {
-        "cssesc": "^3.0.0",
-        "util-deprecate": "^1.0.2"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/postcss-reduce-idents": {
       "version": "6.0.3",
-      "resolved": "https://registry.npmjs.org/postcss-reduce-idents/-/postcss-reduce-idents-6.0.3.tgz",
+      "resolved": "https://registry.facebook.net/postcss-reduce-idents/-/postcss-reduce-idents-6.0.3.tgz",
       "integrity": "sha512-G3yCqZDpsNPoQgbDUy3T0E6hqOQ5xigUtBQyrmq3tn2GxlyiL0yyl7H+T8ulQR6kOcHJ9t7/9H4/R2tv8tJbMA==",
       "license": "MIT",
       "dependencies": {
@@ -14630,7 +13907,7 @@
     },
     "node_modules/postcss-reduce-initial": {
       "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/postcss-reduce-initial/-/postcss-reduce-initial-6.1.0.tgz",
+      "resolved": "https://registry.facebook.net/postcss-reduce-initial/-/postcss-reduce-initial-6.1.0.tgz",
       "integrity": "sha512-RarLgBK/CrL1qZags04oKbVbrrVK2wcxhvta3GCxrZO4zveibqbRPmm2VI8sSgCXwoUHEliRSbOfpR0b/VIoiw==",
       "license": "MIT",
       "dependencies": {
@@ -14646,7 +13923,7 @@
     },
     "node_modules/postcss-reduce-transforms": {
       "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/postcss-reduce-transforms/-/postcss-reduce-transforms-6.0.2.tgz",
+      "resolved": "https://registry.facebook.net/postcss-reduce-transforms/-/postcss-reduce-transforms-6.0.2.tgz",
       "integrity": "sha512-sB+Ya++3Xj1WaT9+5LOOdirAxP7dJZms3GRcYheSPi1PiTMigsxHAdkrbItHxwYHr4kt1zL7mmcHstgMYT+aiA==",
       "license": "MIT",
       "dependencies": {
@@ -14661,7 +13938,7 @@
     },
     "node_modules/postcss-replace-overflow-wrap": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-replace-overflow-wrap/-/postcss-replace-overflow-wrap-4.0.0.tgz",
+      "resolved": "https://registry.facebook.net/postcss-replace-overflow-wrap/-/postcss-replace-overflow-wrap-4.0.0.tgz",
       "integrity": "sha512-KmF7SBPphT4gPPcKZc7aDkweHiKEEO8cla/GjcBK+ckKxiZslIu3C4GCRW3DNfL0o7yW7kMQu9xlZ1kXRXLXtw==",
       "license": "MIT",
       "peerDependencies": {
@@ -14670,7 +13947,7 @@
     },
     "node_modules/postcss-selector-not": {
       "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/postcss-selector-not/-/postcss-selector-not-8.0.1.tgz",
+      "resolved": "https://registry.facebook.net/postcss-selector-not/-/postcss-selector-not-8.0.1.tgz",
       "integrity": "sha512-kmVy/5PYVb2UOhy0+LqUYAhKj7DUGDpSWa5LZqlkWJaaAV+dxxsOG3+St0yNLu6vsKD7Dmqx+nWQt0iil89+WA==",
       "funding": [
         {
@@ -14693,23 +13970,10 @@
         "postcss": "^8.4"
       }
     },
-    "node_modules/postcss-selector-not/node_modules/postcss-selector-parser": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.0.0.tgz",
-      "integrity": "sha512-9RbEr1Y7FFfptd/1eEdntyjMwLeghW1bHX9GWjXo19vx4ytPQhANltvVxDggzJl7mnWM+dX28kb6cyS/4iQjlQ==",
-      "license": "MIT",
-      "dependencies": {
-        "cssesc": "^3.0.0",
-        "util-deprecate": "^1.0.2"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/postcss-selector-parser": {
-      "version": "6.1.2",
-      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
-      "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
+      "version": "7.1.1",
+      "resolved": "https://registry.facebook.net/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz",
+      "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==",
       "license": "MIT",
       "dependencies": {
         "cssesc": "^3.0.0",
@@ -14721,7 +13985,7 @@
     },
     "node_modules/postcss-sort-media-queries": {
       "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/postcss-sort-media-queries/-/postcss-sort-media-queries-5.2.0.tgz",
+      "resolved": "https://registry.facebook.net/postcss-sort-media-queries/-/postcss-sort-media-queries-5.2.0.tgz",
       "integrity": "sha512-AZ5fDMLD8SldlAYlvi8NIqo0+Z8xnXU2ia0jxmuhxAU+Lqt9K+AlmLNJ/zWEnE9x+Zx3qL3+1K20ATgNOr3fAA==",
       "license": "MIT",
       "dependencies": {
@@ -14736,7 +14000,7 @@
     },
     "node_modules/postcss-svgo": {
       "version": "6.0.3",
-      "resolved": "https://registry.npmjs.org/postcss-svgo/-/postcss-svgo-6.0.3.tgz",
+      "resolved": "https://registry.facebook.net/postcss-svgo/-/postcss-svgo-6.0.3.tgz",
       "integrity": "sha512-dlrahRmxP22bX6iKEjOM+c8/1p+81asjKT+V5lrgOH944ryx/OHpclnIbGsKVd3uWOXFLYJwCVf0eEkJGvO96g==",
       "license": "MIT",
       "dependencies": {
@@ -14752,7 +14016,7 @@
     },
     "node_modules/postcss-unique-selectors": {
       "version": "6.0.4",
-      "resolved": "https://registry.npmjs.org/postcss-unique-selectors/-/postcss-unique-selectors-6.0.4.tgz",
+      "resolved": "https://registry.facebook.net/postcss-unique-selectors/-/postcss-unique-selectors-6.0.4.tgz",
       "integrity": "sha512-K38OCaIrO8+PzpArzkLKB42dSARtC2tmG6PvD4b1o1Q2E9Os8jzfWFfSy/rixsHwohtsDdFtAWGjFVFUdwYaMg==",
       "license": "MIT",
       "dependencies": {
@@ -14765,15 +14029,28 @@
         "postcss": "^8.4.31"
       }
     },
+    "node_modules/postcss-unique-selectors/node_modules/postcss-selector-parser": {
+      "version": "6.1.2",
+      "resolved": "https://registry.facebook.net/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
+      "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
+      "license": "MIT",
+      "dependencies": {
+        "cssesc": "^3.0.0",
+        "util-deprecate": "^1.0.2"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/postcss-value-parser": {
       "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz",
+      "resolved": "https://registry.facebook.net/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz",
       "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==",
       "license": "MIT"
     },
     "node_modules/postcss-zindex": {
       "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/postcss-zindex/-/postcss-zindex-6.0.2.tgz",
+      "resolved": "https://registry.facebook.net/postcss-zindex/-/postcss-zindex-6.0.2.tgz",
       "integrity": "sha512-5BxW9l1evPB/4ZIc+2GobEBoKC+h8gPGCMi+jxsYvd2x0mjq7wazk6DrP71pStqxE9Foxh5TVnonbWpFZzXaYg==",
       "license": "MIT",
       "engines": {
@@ -14785,7 +14062,7 @@
     },
     "node_modules/pretty-error": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/pretty-error/-/pretty-error-4.0.0.tgz",
+      "resolved": "https://registry.facebook.net/pretty-error/-/pretty-error-4.0.0.tgz",
       "integrity": "sha512-AoJ5YMAcXKYxKhuJGdcvse+Voc6v1RgnsR3nWcYU7q4t6z0Q6T86sv5Zq8VIRbOWWFpvdGE83LtdSMNd+6Y0xw==",
       "license": "MIT",
       "dependencies": {
@@ -14795,7 +14072,7 @@
     },
     "node_modules/pretty-time": {
       "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/pretty-time/-/pretty-time-1.1.0.tgz",
+      "resolved": "https://registry.facebook.net/pretty-time/-/pretty-time-1.1.0.tgz",
       "integrity": "sha512-28iF6xPQrP8Oa6uxE6a1biz+lWeTOAPKggvjB8HAs6nVMKZwf5bG++632Dx614hIWgUPkgivRfG+a8uAXGTIbA==",
       "license": "MIT",
       "engines": {
@@ -14804,7 +14081,7 @@
     },
     "node_modules/prism-react-renderer": {
       "version": "2.4.1",
-      "resolved": "https://registry.npmjs.org/prism-react-renderer/-/prism-react-renderer-2.4.1.tgz",
+      "resolved": "https://registry.facebook.net/prism-react-renderer/-/prism-react-renderer-2.4.1.tgz",
       "integrity": "sha512-ey8Ls/+Di31eqzUxC46h8MksNuGx/n0AAC8uKpwFau4RPDYLuE3EXTp8N8G2vX2N7UC/+IXeNUnlWBGGcAG+Ig==",
       "license": "MIT",
       "dependencies": {
@@ -14816,9 +14093,9 @@
       }
     },
     "node_modules/prismjs": {
-      "version": "1.29.0",
-      "resolved": "https://registry.npmjs.org/prismjs/-/prismjs-1.29.0.tgz",
-      "integrity": "sha512-Kx/1w86q/epKcmte75LNrEoT+lX8pBpavuAbvJWRXar7Hz8jrtF+e3vY751p0R8H9HdArwaCTNDDzHg/ScJK1Q==",
+      "version": "1.30.0",
+      "resolved": "https://registry.facebook.net/prismjs/-/prismjs-1.30.0.tgz",
+      "integrity": "sha512-DEvV2ZF2r2/63V+tK8hQvrR2ZGn10srHbXviTlcv7Kpzw8jWiNTqbVgjO3IY8RxrrOUF8VPMQQFysYYYv0YZxw==",
       "license": "MIT",
       "engines": {
         "node": ">=6"
@@ -14826,13 +14103,13 @@
     },
     "node_modules/process-nextick-args": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
+      "resolved": "https://registry.facebook.net/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
       "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
       "license": "MIT"
     },
     "node_modules/prompts": {
       "version": "2.4.2",
-      "resolved": "https://registry.npmjs.org/prompts/-/prompts-2.4.2.tgz",
+      "resolved": "https://registry.facebook.net/prompts/-/prompts-2.4.2.tgz",
       "integrity": "sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==",
       "license": "MIT",
       "dependencies": {
@@ -14845,7 +14122,7 @@
     },
     "node_modules/prop-types": {
       "version": "15.8.1",
-      "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz",
+      "resolved": "https://registry.facebook.net/prop-types/-/prop-types-15.8.1.tgz",
       "integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==",
       "license": "MIT",
       "dependencies": {
@@ -14855,9 +14132,9 @@
       }
     },
     "node_modules/property-information": {
-      "version": "6.5.0",
-      "resolved": "https://registry.npmjs.org/property-information/-/property-information-6.5.0.tgz",
-      "integrity": "sha512-PgTgs/BlvHxOu8QuEN7wi5A0OmXaBcHpmCSTehcs6Uuu9IkDIEo13Hy7n898RHfrQ49vKCoGeWZSaAK01nwVig==",
+      "version": "7.1.0",
+      "resolved": "https://registry.facebook.net/property-information/-/property-information-7.1.0.tgz",
+      "integrity": "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ==",
       "license": "MIT",
       "funding": {
         "type": "github",
@@ -14866,13 +14143,13 @@
     },
     "node_modules/proto-list": {
       "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/proto-list/-/proto-list-1.2.4.tgz",
+      "resolved": "https://registry.facebook.net/proto-list/-/proto-list-1.2.4.tgz",
       "integrity": "sha512-vtK/94akxsTMhe0/cbfpR+syPuszcuwhqVjJq26CuNDgFGj682oRBXOP5MJpv2r7JtE8MsiepGIqvvOTBwn2vA==",
       "license": "ISC"
     },
     "node_modules/proxy-addr": {
       "version": "2.0.7",
-      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "resolved": "https://registry.facebook.net/proxy-addr/-/proxy-addr-2.0.7.tgz",
       "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
       "license": "MIT",
       "dependencies": {
@@ -14885,7 +14162,7 @@
     },
     "node_modules/proxy-addr/node_modules/ipaddr.js": {
       "version": "1.9.1",
-      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+      "resolved": "https://registry.facebook.net/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
       "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
       "license": "MIT",
       "engines": {
@@ -14893,14 +14170,17 @@
       }
     },
     "node_modules/proxy-from-env": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
-      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
-      "license": "MIT"
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/proxy-from-env/-/proxy-from-env-2.1.0.tgz",
+      "integrity": "sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      }
     },
     "node_modules/punycode": {
       "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "resolved": "https://registry.facebook.net/punycode/-/punycode-2.3.1.tgz",
       "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
       "license": "MIT",
       "engines": {
@@ -14908,9 +14188,9 @@
       }
     },
     "node_modules/pupa": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/pupa/-/pupa-3.1.0.tgz",
-      "integrity": "sha512-FLpr4flz5xZTSJxSeaheeMKN/EDzMdK7b8PTOC6a5PYFKTucWbdqjgqaEyH0shFiSJrVB1+Qqi4Tk19ccU6Aug==",
+      "version": "3.3.0",
+      "resolved": "https://registry.facebook.net/pupa/-/pupa-3.3.0.tgz",
+      "integrity": "sha512-LjgDO2zPtoXP2wJpDjZrGdojii1uqO0cnwKoIoUzkfS98HDmbeiGmYiXo3lXeFlq2xvne1QFQhwYXSUCLKtEuA==",
       "license": "MIT",
       "dependencies": {
         "escape-goat": "^4.0.0"
@@ -14922,13 +14202,31 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/pvtsutils": {
+      "version": "1.3.6",
+      "resolved": "https://registry.facebook.net/pvtsutils/-/pvtsutils-1.3.6.tgz",
+      "integrity": "sha512-PLgQXQ6H2FWCaeRak8vvk1GW462lMxB5s3Jm673N82zI4vqtVUPuZdffdZbPDFRoU8kAhItWFtPCWiPpp4/EDg==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/pvutils": {
+      "version": "1.1.5",
+      "resolved": "https://registry.facebook.net/pvutils/-/pvutils-1.1.5.tgz",
+      "integrity": "sha512-KTqnxsgGiQ6ZAzZCVlJH5eOjSnvlyEgx1m8bkRJfOhmGRqfo5KLvmAlACQkrjEtOQ4B7wF9TdSLIs9O90MX9xA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
     "node_modules/qs": {
-      "version": "6.13.0",
-      "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz",
-      "integrity": "sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==",
+      "version": "6.14.2",
+      "resolved": "https://registry.facebook.net/qs/-/qs-6.14.2.tgz",
+      "integrity": "sha512-V/yCWTTF7VJ9hIh18Ugr2zhJMP01MY7c5kh4J870L7imm6/DIzBsNLTXzMwUA3yZ5b/KBqLx8Kp3uRvd7xSe3Q==",
       "license": "BSD-3-Clause",
       "dependencies": {
-        "side-channel": "^1.0.6"
+        "side-channel": "^1.1.0"
       },
       "engines": {
         "node": ">=0.6"
@@ -14937,18 +14235,9 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/queue": {
-      "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/queue/-/queue-6.0.2.tgz",
-      "integrity": "sha512-iHZWu+q3IdFZFX36ro/lKBkSvfkztY5Y7HMiPlOUjhupPcG2JMfst2KKEpu5XndviX/3UhFbRngUPNKtgvtZiA==",
-      "license": "MIT",
-      "dependencies": {
-        "inherits": "~2.0.3"
-      }
-    },
     "node_modules/queue-microtask": {
       "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
+      "resolved": "https://registry.facebook.net/queue-microtask/-/queue-microtask-1.2.3.tgz",
       "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
       "funding": [
         {
@@ -14968,7 +14257,7 @@
     },
     "node_modules/quick-lru": {
       "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz",
+      "resolved": "https://registry.facebook.net/quick-lru/-/quick-lru-5.1.1.tgz",
       "integrity": "sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==",
       "license": "MIT",
       "engines": {
@@ -14980,7 +14269,7 @@
     },
     "node_modules/randombytes": {
       "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz",
+      "resolved": "https://registry.facebook.net/randombytes/-/randombytes-2.1.0.tgz",
       "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==",
       "license": "MIT",
       "dependencies": {
@@ -14988,41 +14277,32 @@
       }
     },
     "node_modules/range-parser": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.0.tgz",
-      "integrity": "sha512-kA5WQoNVo4t9lNx2kQNFCxKeBl5IbbSNBl1M/tLkw9WCn+hxNBAW5Qh8gdhs63CJnhjJ2zQWFoqPJP2sK1AV5A==",
+      "version": "1.2.1",
+      "resolved": "https://registry.facebook.net/range-parser/-/range-parser-1.2.1.tgz",
+      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
       "license": "MIT",
       "engines": {
         "node": ">= 0.6"
       }
     },
     "node_modules/raw-body": {
-      "version": "2.5.2",
-      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz",
-      "integrity": "sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==",
+      "version": "2.5.3",
+      "resolved": "https://registry.facebook.net/raw-body/-/raw-body-2.5.3.tgz",
+      "integrity": "sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA==",
       "license": "MIT",
       "dependencies": {
-        "bytes": "3.1.2",
-        "http-errors": "2.0.0",
-        "iconv-lite": "0.4.24",
-        "unpipe": "1.0.0"
+        "bytes": "~3.1.2",
+        "http-errors": "~2.0.1",
+        "iconv-lite": "~0.4.24",
+        "unpipe": "~1.0.0"
       },
       "engines": {
         "node": ">= 0.8"
       }
     },
-    "node_modules/raw-body/node_modules/bytes": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
-      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
     "node_modules/rc": {
       "version": "1.2.8",
-      "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz",
+      "resolved": "https://registry.facebook.net/rc/-/rc-1.2.8.tgz",
       "integrity": "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==",
       "license": "(BSD-2-Clause OR MIT OR Apache-2.0)",
       "dependencies": {
@@ -15037,7 +14317,7 @@
     },
     "node_modules/rc/node_modules/strip-json-comments": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz",
+      "resolved": "https://registry.facebook.net/strip-json-comments/-/strip-json-comments-2.0.1.tgz",
       "integrity": "sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==",
       "license": "MIT",
       "engines": {
@@ -15046,7 +14326,7 @@
     },
     "node_modules/react": {
       "version": "18.3.1",
-      "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
+      "resolved": "https://registry.facebook.net/react/-/react-18.3.1.tgz",
       "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
       "license": "MIT",
       "dependencies": {
@@ -15056,135 +14336,9 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/react-dev-utils": {
-      "version": "12.0.1",
-      "resolved": "https://registry.npmjs.org/react-dev-utils/-/react-dev-utils-12.0.1.tgz",
-      "integrity": "sha512-84Ivxmr17KjUupyqzFode6xKhjwuEJDROWKJy/BthkL7Wn6NJ8h4WE6k/exAv6ImS+0oZLRRW5j/aINMHyeGeQ==",
-      "license": "MIT",
-      "dependencies": {
-        "@babel/code-frame": "^7.16.0",
-        "address": "^1.1.2",
-        "browserslist": "^4.18.1",
-        "chalk": "^4.1.2",
-        "cross-spawn": "^7.0.3",
-        "detect-port-alt": "^1.1.6",
-        "escape-string-regexp": "^4.0.0",
-        "filesize": "^8.0.6",
-        "find-up": "^5.0.0",
-        "fork-ts-checker-webpack-plugin": "^6.5.0",
-        "global-modules": "^2.0.0",
-        "globby": "^11.0.4",
-        "gzip-size": "^6.0.0",
-        "immer": "^9.0.7",
-        "is-root": "^2.1.0",
-        "loader-utils": "^3.2.0",
-        "open": "^8.4.0",
-        "pkg-up": "^3.1.0",
-        "prompts": "^2.4.2",
-        "react-error-overlay": "^6.0.11",
-        "recursive-readdir": "^2.2.2",
-        "shell-quote": "^1.7.3",
-        "strip-ansi": "^6.0.1",
-        "text-table": "^0.2.0"
-      },
-      "engines": {
-        "node": ">=14"
-      }
-    },
-    "node_modules/react-dev-utils/node_modules/find-up": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
-      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
-      "license": "MIT",
-      "dependencies": {
-        "locate-path": "^6.0.0",
-        "path-exists": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/react-dev-utils/node_modules/loader-utils": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/loader-utils/-/loader-utils-3.3.1.tgz",
-      "integrity": "sha512-FMJTLMXfCLMLfJxcX9PFqX5qD88Z5MRGaZCVzfuqeZSPsyiBzs+pahDQjbIWz2QIzPZz0NX9Zy4FX3lmK6YHIg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 12.13.0"
-      }
-    },
-    "node_modules/react-dev-utils/node_modules/locate-path": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
-      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
-      "license": "MIT",
-      "dependencies": {
-        "p-locate": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/react-dev-utils/node_modules/p-limit": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
-      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
-      "license": "MIT",
-      "dependencies": {
-        "yocto-queue": "^0.1.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/react-dev-utils/node_modules/p-locate": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
-      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
-      "license": "MIT",
-      "dependencies": {
-        "p-limit": "^3.0.2"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/react-dev-utils/node_modules/path-exists": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
-      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/react-dev-utils/node_modules/yocto-queue": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
-      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
     "node_modules/react-dom": {
       "version": "18.3.1",
-      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
+      "resolved": "https://registry.facebook.net/react-dom/-/react-dom-18.3.1.tgz",
       "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
       "license": "MIT",
       "dependencies": {
@@ -15195,22 +14349,17 @@
         "react": "^18.3.1"
       }
     },
-    "node_modules/react-error-overlay": {
-      "version": "6.0.11",
-      "resolved": "https://registry.npmjs.org/react-error-overlay/-/react-error-overlay-6.0.11.tgz",
-      "integrity": "sha512-/6UZ2qgEyH2aqzYZgQPxEnz33NJ2gNsnHA2o5+o4wW9bLM/JYQitNP9xPhsXwC08hMMovfGe/8retsdDsczPRg==",
-      "license": "MIT"
-    },
     "node_modules/react-fast-compare": {
       "version": "3.2.2",
-      "resolved": "https://registry.npmjs.org/react-fast-compare/-/react-fast-compare-3.2.2.tgz",
+      "resolved": "https://registry.facebook.net/react-fast-compare/-/react-fast-compare-3.2.2.tgz",
       "integrity": "sha512-nsO+KSNgo1SbJqJEYRE9ERzo7YtYbou/OqjSQKxV7jcKox7+usiUVZOAC+XnDOABXggQTno0Y1CpVnuWEc1boQ==",
       "license": "MIT"
     },
     "node_modules/react-helmet-async": {
+      "name": "@slorber/react-helmet-async",
       "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/react-helmet-async/-/react-helmet-async-1.3.0.tgz",
-      "integrity": "sha512-9jZ57/dAn9t3q6hneQS0wukqC2ENOBgMNVEhb/ZG9ZSxUetzVIw4iAmEU38IaVg3QGYauQPhSeUTuIUtFglWpg==",
+      "resolved": "https://registry.facebook.net/@slorber/react-helmet-async/-/react-helmet-async-1.3.0.tgz",
+      "integrity": "sha512-e9/OK8VhwUSc67diWI8Rb3I0YgI9/SBQtnhe9aEuK6MhZm7ntZZimXgwXnd8W96YTmSOb9M4d8LwhRZyhWr/1A==",
       "license": "Apache-2.0",
       "dependencies": {
         "@babel/runtime": "^7.12.5",
@@ -15220,32 +14369,32 @@
         "shallowequal": "^1.1.0"
       },
       "peerDependencies": {
-        "react": "^16.6.0 || ^17.0.0 || ^18.0.0",
-        "react-dom": "^16.6.0 || ^17.0.0 || ^18.0.0"
+        "react": "^16.6.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "react-dom": "^16.6.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
       }
     },
     "node_modules/react-is": {
       "version": "16.13.1",
-      "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz",
+      "resolved": "https://registry.facebook.net/react-is/-/react-is-16.13.1.tgz",
       "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
       "license": "MIT"
     },
     "node_modules/react-json-view-lite": {
-      "version": "1.5.0",
-      "resolved": "https://registry.npmjs.org/react-json-view-lite/-/react-json-view-lite-1.5.0.tgz",
-      "integrity": "sha512-nWqA1E4jKPklL2jvHWs6s+7Na0qNgw9HCP6xehdQJeg6nPBTFZgGwyko9Q0oj+jQWKTTVRS30u0toM5wiuL3iw==",
+      "version": "2.5.0",
+      "resolved": "https://registry.facebook.net/react-json-view-lite/-/react-json-view-lite-2.5.0.tgz",
+      "integrity": "sha512-tk7o7QG9oYyELWHL8xiMQ8x4WzjCzbWNyig3uexmkLb54r8jO0yH3WCWx8UZS0c49eSA4QUmG5caiRJ8fAn58g==",
       "license": "MIT",
       "engines": {
-        "node": ">=14"
+        "node": ">=18"
       },
       "peerDependencies": {
-        "react": "^16.13.1 || ^17.0.0 || ^18.0.0"
+        "react": "^18.0.0 || ^19.0.0"
       }
     },
     "node_modules/react-loadable": {
       "name": "@docusaurus/react-loadable",
       "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/@docusaurus/react-loadable/-/react-loadable-6.0.0.tgz",
+      "resolved": "https://registry.facebook.net/@docusaurus/react-loadable/-/react-loadable-6.0.0.tgz",
       "integrity": "sha512-YMMxTUQV/QFSnbgrP3tjDzLHRg7vsbMn8e9HAa8o/1iXoiomo48b7sk/kkmWEuWNDPJVlKSJRB6Y2fHqdJk+SQ==",
       "license": "MIT",
       "dependencies": {
@@ -15256,9 +14405,9 @@
       }
     },
     "node_modules/react-loadable-ssr-addon-v5-slorber": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/react-loadable-ssr-addon-v5-slorber/-/react-loadable-ssr-addon-v5-slorber-1.0.1.tgz",
-      "integrity": "sha512-lq3Lyw1lGku8zUEJPDxsNm1AfYHBrO9Y1+olAYwpUJ2IGFBskM0DMKok97A6LWUpHm+o7IvQBOWu9MLenp9Z+A==",
+      "version": "1.0.3",
+      "resolved": "https://registry.facebook.net/react-loadable-ssr-addon-v5-slorber/-/react-loadable-ssr-addon-v5-slorber-1.0.3.tgz",
+      "integrity": "sha512-GXfh9VLwB5ERaCsU6RULh7tkemeX15aNh6wuMEBtfdyMa7fFG8TXrhXlx1SoEK2Ty/l6XIkzzYIQmyaWW3JgdQ==",
       "license": "MIT",
       "dependencies": {
         "@babel/runtime": "^7.10.3"
@@ -15273,7 +14422,7 @@
     },
     "node_modules/react-router": {
       "version": "5.3.4",
-      "resolved": "https://registry.npmjs.org/react-router/-/react-router-5.3.4.tgz",
+      "resolved": "https://registry.facebook.net/react-router/-/react-router-5.3.4.tgz",
       "integrity": "sha512-Ys9K+ppnJah3QuaRiLxk+jDWOR1MekYQrlytiXxC1RyfbdsZkS5pvKAzCCr031xHixZwpnsYNT5xysdFHQaYsA==",
       "license": "MIT",
       "dependencies": {
@@ -15293,7 +14442,7 @@
     },
     "node_modules/react-router-config": {
       "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/react-router-config/-/react-router-config-5.1.1.tgz",
+      "resolved": "https://registry.facebook.net/react-router-config/-/react-router-config-5.1.1.tgz",
       "integrity": "sha512-DuanZjaD8mQp1ppHjgnnUnyOlqYXZVjnov/JzFhjLEwd3Z4dYjMSnqrEzzGThH47vpCOqPPwJM2FtthLeJ8Pbg==",
       "license": "MIT",
       "dependencies": {
@@ -15306,7 +14455,7 @@
     },
     "node_modules/react-router-dom": {
       "version": "5.3.4",
-      "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-5.3.4.tgz",
+      "resolved": "https://registry.facebook.net/react-router-dom/-/react-router-dom-5.3.4.tgz",
       "integrity": "sha512-m4EqFMHv/Ih4kpcBCONHbkT68KoAeHN4p3lAGoNryfHi0dMy0kCzEZakiKRsvg5wHZ/JLrLW8o8KomWiz/qbYQ==",
       "license": "MIT",
       "dependencies": {
@@ -15322,9 +14471,18 @@
         "react": ">=15"
       }
     },
+    "node_modules/react-router/node_modules/path-to-regexp": {
+      "version": "1.9.0",
+      "resolved": "https://registry.facebook.net/path-to-regexp/-/path-to-regexp-1.9.0.tgz",
+      "integrity": "sha512-xIp7/apCFJuUHdDLWe8O1HIkb0kQrOMb/0u6FXQjemHn/ii5LrIzU6bdECnsiTF/GjZkMEKg1xdiZwNqDYlZ6g==",
+      "license": "MIT",
+      "dependencies": {
+        "isarray": "0.0.1"
+      }
+    },
     "node_modules/readable-stream": {
       "version": "3.6.2",
-      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
+      "resolved": "https://registry.facebook.net/readable-stream/-/readable-stream-3.6.2.tgz",
       "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
       "license": "MIT",
       "dependencies": {
@@ -15338,7 +14496,7 @@
     },
     "node_modules/readdirp": {
       "version": "3.6.0",
-      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
+      "resolved": "https://registry.facebook.net/readdirp/-/readdirp-3.6.0.tgz",
       "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
       "license": "MIT",
       "dependencies": {
@@ -15348,26 +14506,9 @@
         "node": ">=8.10.0"
       }
     },
-    "node_modules/reading-time": {
-      "version": "1.5.0",
-      "resolved": "https://registry.npmjs.org/reading-time/-/reading-time-1.5.0.tgz",
-      "integrity": "sha512-onYyVhBNr4CmAxFsKS7bz+uTLRakypIe4R+5A824vBSkQy/hB3fZepoVEf8OVAxzLvK+H/jm9TzpI3ETSm64Kg==",
-      "license": "MIT"
-    },
-    "node_modules/rechoir": {
-      "version": "0.6.2",
-      "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.6.2.tgz",
-      "integrity": "sha512-HFM8rkZ+i3zrV+4LQjwQ0W+ez98pApMGM3HUrN04j3CqzPOzl9nmP15Y8YXNm8QHGv/eacOVEjqhmWpkRV0NAw==",
-      "dependencies": {
-        "resolve": "^1.1.6"
-      },
-      "engines": {
-        "node": ">= 0.10"
-      }
-    },
     "node_modules/recma-build-jsx": {
       "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/recma-build-jsx/-/recma-build-jsx-1.0.0.tgz",
+      "resolved": "https://registry.facebook.net/recma-build-jsx/-/recma-build-jsx-1.0.0.tgz",
       "integrity": "sha512-8GtdyqaBcDfva+GUKDr3nev3VpKAhup1+RvkMvUxURHpW7QyIvk9F5wz7Vzo06CEMSilw6uArgRqhpiUcWp8ew==",
       "license": "MIT",
       "dependencies": {
@@ -15381,9 +14522,9 @@
       }
     },
     "node_modules/recma-jsx": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/recma-jsx/-/recma-jsx-1.0.0.tgz",
-      "integrity": "sha512-5vwkv65qWwYxg+Atz95acp8DMu1JDSqdGkA2Of1j6rCreyFUE/gp15fC8MnGEuG1W68UKjM6x6+YTWIh7hZM/Q==",
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/recma-jsx/-/recma-jsx-1.0.1.tgz",
+      "integrity": "sha512-huSIy7VU2Z5OLv6oFLosQGGDqPqdO1iq6bWNAdhzMxSJP7RAso4fCZ1cKu8j9YHCZf3TPrq4dw3okhrylgcd7w==",
       "license": "MIT",
       "dependencies": {
         "acorn-jsx": "^5.0.0",
@@ -15395,11 +14536,14 @@
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/unified"
+      },
+      "peerDependencies": {
+        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
       }
     },
     "node_modules/recma-parse": {
       "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/recma-parse/-/recma-parse-1.0.0.tgz",
+      "resolved": "https://registry.facebook.net/recma-parse/-/recma-parse-1.0.0.tgz",
       "integrity": "sha512-OYLsIGBB5Y5wjnSnQW6t3Xg7q3fQ7FWbw/vcXtORTnyaSFscOtABg+7Pnz6YZ6c27fG1/aN8CjfwoUEUIdwqWQ==",
       "license": "MIT",
       "dependencies": {
@@ -15415,7 +14559,7 @@
     },
     "node_modules/recma-stringify": {
       "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/recma-stringify/-/recma-stringify-1.0.0.tgz",
+      "resolved": "https://registry.facebook.net/recma-stringify/-/recma-stringify-1.0.0.tgz",
       "integrity": "sha512-cjwII1MdIIVloKvC9ErQ+OgAtwHBmcZ0Bg4ciz78FtbT8In39aAYbaA7zvxQ61xVMSPE8WxhLwLbhif4Js2C+g==",
       "license": "MIT",
       "dependencies": {
@@ -15429,28 +14573,22 @@
         "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/recursive-readdir": {
-      "version": "2.2.3",
-      "resolved": "https://registry.npmjs.org/recursive-readdir/-/recursive-readdir-2.2.3.tgz",
-      "integrity": "sha512-8HrF5ZsXk5FAH9dgsx3BlUer73nIhuj+9OrQwEbLTPOBzGkL1lsFCR01am+v+0m2Cmbs1nP12hLDl5FA7EszKA==",
-      "license": "MIT",
-      "dependencies": {
-        "minimatch": "^3.0.5"
-      },
-      "engines": {
-        "node": ">=6.0.0"
-      }
+    "node_modules/reflect-metadata": {
+      "version": "0.2.2",
+      "resolved": "https://registry.facebook.net/reflect-metadata/-/reflect-metadata-0.2.2.tgz",
+      "integrity": "sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==",
+      "license": "Apache-2.0"
     },
     "node_modules/regenerate": {
       "version": "1.4.2",
-      "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.4.2.tgz",
+      "resolved": "https://registry.facebook.net/regenerate/-/regenerate-1.4.2.tgz",
       "integrity": "sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==",
       "license": "MIT"
     },
     "node_modules/regenerate-unicode-properties": {
-      "version": "10.2.0",
-      "resolved": "https://registry.npmjs.org/regenerate-unicode-properties/-/regenerate-unicode-properties-10.2.0.tgz",
-      "integrity": "sha512-DqHn3DwbmmPVzeKj9woBadqmXxLvQoQIwu7nopMc72ztvxVmVk2SBhSnx67zuye5TP+lJsb/TBQsjLKhnDf3MA==",
+      "version": "10.2.2",
+      "resolved": "https://registry.facebook.net/regenerate-unicode-properties/-/regenerate-unicode-properties-10.2.2.tgz",
+      "integrity": "sha512-m03P+zhBeQd1RGnYxrGyDAPpWX/epKirLrp8e3qevZdVkKtnCrjjWczIbYc8+xd6vcTStVlqfycTx1KR4LOr0g==",
       "license": "MIT",
       "dependencies": {
         "regenerate": "^1.4.2"
@@ -15459,45 +14597,30 @@
         "node": ">=4"
       }
     },
-    "node_modules/regenerator-runtime": {
-      "version": "0.14.1",
-      "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.14.1.tgz",
-      "integrity": "sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==",
-      "license": "MIT"
-    },
-    "node_modules/regenerator-transform": {
-      "version": "0.15.2",
-      "resolved": "https://registry.npmjs.org/regenerator-transform/-/regenerator-transform-0.15.2.tgz",
-      "integrity": "sha512-hfMp2BoF0qOk3uc5V20ALGDS2ddjQaLrdl7xrGXvAIow7qeWRM2VA2HuCHkUKk9slq3VwEwLNK3DFBqDfPGYtg==",
-      "license": "MIT",
-      "dependencies": {
-        "@babel/runtime": "^7.8.4"
-      }
-    },
     "node_modules/regexpu-core": {
-      "version": "6.2.0",
-      "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-6.2.0.tgz",
-      "integrity": "sha512-H66BPQMrv+V16t8xtmq+UC0CBpiTBA60V8ibS1QVReIp8T1z8hwFxqcGzm9K6lgsN7sB5edVH8a+ze6Fqm4weA==",
+      "version": "6.4.0",
+      "resolved": "https://registry.facebook.net/regexpu-core/-/regexpu-core-6.4.0.tgz",
+      "integrity": "sha512-0ghuzq67LI9bLXpOX/ISfve/Mq33a4aFRzoQYhnnok1JOFpmE/A2TBGkNVenOGEeSBCjIiWcc6MVOG5HEQv0sA==",
       "license": "MIT",
       "dependencies": {
         "regenerate": "^1.4.2",
-        "regenerate-unicode-properties": "^10.2.0",
+        "regenerate-unicode-properties": "^10.2.2",
         "regjsgen": "^0.8.0",
-        "regjsparser": "^0.12.0",
+        "regjsparser": "^0.13.0",
         "unicode-match-property-ecmascript": "^2.0.0",
-        "unicode-match-property-value-ecmascript": "^2.1.0"
+        "unicode-match-property-value-ecmascript": "^2.2.1"
       },
       "engines": {
         "node": ">=4"
       }
     },
     "node_modules/registry-auth-token": {
-      "version": "5.0.3",
-      "resolved": "https://registry.npmjs.org/registry-auth-token/-/registry-auth-token-5.0.3.tgz",
-      "integrity": "sha512-1bpc9IyC+e+CNFRaWyn77tk4xGG4PPUyfakSmA6F6cvUDjrm58dfyJ3II+9yb10EDkHoy1LaPSmHaWLOH3m6HA==",
+      "version": "5.1.1",
+      "resolved": "https://registry.facebook.net/registry-auth-token/-/registry-auth-token-5.1.1.tgz",
+      "integrity": "sha512-P7B4+jq8DeD2nMsAcdfaqHbssgHtZ7Z5+++a5ask90fvmJ8p5je4mOa+wzu+DB4vQ5tdJV/xywY+UnVFeQLV5Q==",
       "license": "MIT",
       "dependencies": {
-        "@pnpm/npm-conf": "^2.1.0"
+        "@pnpm/npm-conf": "^3.0.2"
       },
       "engines": {
         "node": ">=14"
@@ -15505,7 +14628,7 @@
     },
     "node_modules/registry-url": {
       "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/registry-url/-/registry-url-6.0.1.tgz",
+      "resolved": "https://registry.facebook.net/registry-url/-/registry-url-6.0.1.tgz",
       "integrity": "sha512-+crtS5QjFRqFCoQmvGduwYWEBng99ZvmFvF+cUJkGYF1L1BfU8C6Zp9T7f5vPAwyLkUExpvK+ANVZmGU49qi4Q==",
       "license": "MIT",
       "dependencies": {
@@ -15520,37 +14643,25 @@
     },
     "node_modules/regjsgen": {
       "version": "0.8.0",
-      "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.8.0.tgz",
+      "resolved": "https://registry.facebook.net/regjsgen/-/regjsgen-0.8.0.tgz",
       "integrity": "sha512-RvwtGe3d7LvWiDQXeQw8p5asZUmfU1G/l6WbUXeHta7Y2PEIvBTwH6E2EfmYUK8pxcxEdEmaomqyp0vZZ7C+3Q==",
       "license": "MIT"
     },
     "node_modules/regjsparser": {
-      "version": "0.12.0",
-      "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.12.0.tgz",
-      "integrity": "sha512-cnE+y8bz4NhMjISKbgeVJtqNbtf5QpjZP+Bslo+UqkIt9QPnX9q095eiRRASJG1/tz6dlNr6Z5NsBiWYokp6EQ==",
+      "version": "0.13.1",
+      "resolved": "https://registry.facebook.net/regjsparser/-/regjsparser-0.13.1.tgz",
+      "integrity": "sha512-dLsljMd9sqwRkby8zhO1gSg3PnJIBFid8f4CQj/sXx+7cKx+E7u0PKhZ+U4wmhx7EfmtvnA318oVaIkAB1lRJw==",
       "license": "BSD-2-Clause",
       "dependencies": {
-        "jsesc": "~3.0.2"
+        "jsesc": "~3.1.0"
       },
       "bin": {
         "regjsparser": "bin/parser"
       }
     },
-    "node_modules/regjsparser/node_modules/jsesc": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.0.2.tgz",
-      "integrity": "sha512-xKqzzWXDttJuOcawBt4KnKHHIf5oQ/Cxax+0PWFG+DFDgHNAdi+TXECADI+RYiFUMmx8792xsMbbgXj4CwnP4g==",
-      "license": "MIT",
-      "bin": {
-        "jsesc": "bin/jsesc"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
     "node_modules/rehype-raw": {
       "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/rehype-raw/-/rehype-raw-7.0.0.tgz",
+      "resolved": "https://registry.facebook.net/rehype-raw/-/rehype-raw-7.0.0.tgz",
       "integrity": "sha512-/aE8hCfKlQeA8LmyeyQvQF3eBiLRGNlfBJEvWH7ivp9sBqs7TNqBL5X3v157rM4IFETqDnIOO+z5M/biZbo9Ww==",
       "license": "MIT",
       "dependencies": {
@@ -15565,7 +14676,7 @@
     },
     "node_modules/rehype-recma": {
       "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/rehype-recma/-/rehype-recma-1.0.0.tgz",
+      "resolved": "https://registry.facebook.net/rehype-recma/-/rehype-recma-1.0.0.tgz",
       "integrity": "sha512-lqA4rGUf1JmacCNWWZx0Wv1dHqMwxzsDWYMTowuplHF3xH0N/MmrZ/G3BDZnzAkRmxDadujCjaKM2hqYdCBOGw==",
       "license": "MIT",
       "dependencies": {
@@ -15580,7 +14691,7 @@
     },
     "node_modules/relateurl": {
       "version": "0.2.7",
-      "resolved": "https://registry.npmjs.org/relateurl/-/relateurl-0.2.7.tgz",
+      "resolved": "https://registry.facebook.net/relateurl/-/relateurl-0.2.7.tgz",
       "integrity": "sha512-G08Dxvm4iDN3MLM0EsP62EDV9IuhXPR6blNz6Utcp7zyV3tr4HVNINt6MpaRWbxoOHT3Q7YN2P+jaHX8vUbgog==",
       "license": "MIT",
       "engines": {
@@ -15588,9 +14699,9 @@
       }
     },
     "node_modules/remark-directive": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/remark-directive/-/remark-directive-3.0.0.tgz",
-      "integrity": "sha512-l1UyWJ6Eg1VPU7Hm/9tt0zKtReJQNOA4+iDMAxTyZNWnJnFlbS/7zhiel/rogTLQ2vMYwDzSJa4BiVNqGlqIMA==",
+      "version": "3.0.1",
+      "resolved": "https://registry.facebook.net/remark-directive/-/remark-directive-3.0.1.tgz",
+      "integrity": "sha512-gwglrEQEZcZYgVyG1tQuA+h58EZfq5CSULw7J90AFuCTyib1thgHPoqQ+h9iFvU6R+vnZ5oNFQR5QKgGpk741A==",
       "license": "MIT",
       "dependencies": {
         "@types/mdast": "^4.0.0",
@@ -15605,7 +14716,7 @@
     },
     "node_modules/remark-emoji": {
       "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/remark-emoji/-/remark-emoji-4.0.1.tgz",
+      "resolved": "https://registry.facebook.net/remark-emoji/-/remark-emoji-4.0.1.tgz",
       "integrity": "sha512-fHdvsTR1dHkWKev9eNyhTo4EFwbUvJ8ka9SgeWkMPYFX4WoI7ViVBms3PjlQYgw5TLvNQso3GUB/b/8t3yo+dg==",
       "license": "MIT",
       "dependencies": {
@@ -15621,7 +14732,7 @@
     },
     "node_modules/remark-frontmatter": {
       "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/remark-frontmatter/-/remark-frontmatter-5.0.0.tgz",
+      "resolved": "https://registry.facebook.net/remark-frontmatter/-/remark-frontmatter-5.0.0.tgz",
       "integrity": "sha512-XTFYvNASMe5iPN0719nPrdItC9aU0ssC4v14mH1BCi1u0n1gAocqcujWUrByftZTbLhRtiKRyjYTSIOcr69UVQ==",
       "license": "MIT",
       "dependencies": {
@@ -15636,9 +14747,9 @@
       }
     },
     "node_modules/remark-gfm": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/remark-gfm/-/remark-gfm-4.0.0.tgz",
-      "integrity": "sha512-U92vJgBPkbw4Zfu/IiW2oTZLSL3Zpv+uI7My2eq8JxKgqraFdU8YUGicEJCEgSbeaG+QDFqIcwwfMTOEelPxuA==",
+      "version": "4.0.1",
+      "resolved": "https://registry.facebook.net/remark-gfm/-/remark-gfm-4.0.1.tgz",
+      "integrity": "sha512-1quofZ2RQ9EWdeN34S79+KExV1764+wCUGop5CPL1WGdD0ocPpu91lzPGbwWMECpEpd42kJGQwzRfyov9j4yNg==",
       "license": "MIT",
       "dependencies": {
         "@types/mdast": "^4.0.0",
@@ -15654,9 +14765,9 @@
       }
     },
     "node_modules/remark-mdx": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/remark-mdx/-/remark-mdx-3.1.0.tgz",
-      "integrity": "sha512-Ngl/H3YXyBV9RcRNdlYsZujAmhsxwzxpDzpDEhFBVAGthS4GDgnctpDjgFl/ULx5UEDzqtW1cyBSNKqYYrqLBA==",
+      "version": "3.1.1",
+      "resolved": "https://registry.facebook.net/remark-mdx/-/remark-mdx-3.1.1.tgz",
+      "integrity": "sha512-Pjj2IYlUY3+D8x00UJsIOg5BEvfMyeI+2uLPn9VO9Wg4MEtN/VTIq2NEJQfde9PnX15KgtHyl9S0BcTnWrIuWg==",
       "license": "MIT",
       "dependencies": {
         "mdast-util-mdx": "^3.0.0",
@@ -15669,7 +14780,7 @@
     },
     "node_modules/remark-parse": {
       "version": "11.0.0",
-      "resolved": "https://registry.npmjs.org/remark-parse/-/remark-parse-11.0.0.tgz",
+      "resolved": "https://registry.facebook.net/remark-parse/-/remark-parse-11.0.0.tgz",
       "integrity": "sha512-FCxlKLNGknS5ba/1lmpYijMUzX2esxW5xQqjWxw2eHFfS2MSdaHVINFmhjo+qN1WhZhNimq0dZATN9pH0IDrpA==",
       "license": "MIT",
       "dependencies": {
@@ -15684,9 +14795,9 @@
       }
     },
     "node_modules/remark-rehype": {
-      "version": "11.1.1",
-      "resolved": "https://registry.npmjs.org/remark-rehype/-/remark-rehype-11.1.1.tgz",
-      "integrity": "sha512-g/osARvjkBXb6Wo0XvAeXQohVta8i84ACbenPpoSsxTOQH/Ae0/RGP4WZgnMH5pMLpsj4FG7OHmcIcXxpza8eQ==",
+      "version": "11.1.2",
+      "resolved": "https://registry.facebook.net/remark-rehype/-/remark-rehype-11.1.2.tgz",
+      "integrity": "sha512-Dh7l57ianaEoIpzbp0PC9UKAdCSVklD8E5Rpw7ETfbTl3FqcOOgq5q2LVDhgGCkaBv7p24JXikPdvhhmHvKMsw==",
       "license": "MIT",
       "dependencies": {
         "@types/hast": "^3.0.0",
@@ -15702,7 +14813,7 @@
     },
     "node_modules/remark-stringify": {
       "version": "11.0.0",
-      "resolved": "https://registry.npmjs.org/remark-stringify/-/remark-stringify-11.0.0.tgz",
+      "resolved": "https://registry.facebook.net/remark-stringify/-/remark-stringify-11.0.0.tgz",
       "integrity": "sha512-1OSmLd3awB/t8qdoEOMazZkNsfVTeY4fTsgzcQFdXNq8ToTN4ZGwrMnlda4K6smTFKD+GRV6O48i6Z4iKgPPpw==",
       "license": "MIT",
       "dependencies": {
@@ -15717,7 +14828,7 @@
     },
     "node_modules/renderkid": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/renderkid/-/renderkid-3.0.0.tgz",
+      "resolved": "https://registry.facebook.net/renderkid/-/renderkid-3.0.0.tgz",
       "integrity": "sha512-q/7VIQA8lmM1hF+jn+sFSPWGlMkSAeNYcPLmDQx2zzuiDfaLrOmumR8iaUKlenFgh0XRPIUeSPlH3A+AW3Z5pg==",
       "license": "MIT",
       "dependencies": {
@@ -15730,7 +14841,7 @@
     },
     "node_modules/renderkid/node_modules/css-select": {
       "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/css-select/-/css-select-4.3.0.tgz",
+      "resolved": "https://registry.facebook.net/css-select/-/css-select-4.3.0.tgz",
       "integrity": "sha512-wPpOYtnsVontu2mODhA19JrqWxNsfdatRKd64kmpRbQgh1KtItko5sTnEpPdpSaJszTOhEMlF/RPz28qj4HqhQ==",
       "license": "BSD-2-Clause",
       "dependencies": {
@@ -15746,7 +14857,7 @@
     },
     "node_modules/renderkid/node_modules/dom-serializer": {
       "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-1.4.1.tgz",
+      "resolved": "https://registry.facebook.net/dom-serializer/-/dom-serializer-1.4.1.tgz",
       "integrity": "sha512-VHwB3KfrcOOkelEG2ZOfxqLZdfkil8PtJi4P8N2MMXucZq2yLp75ClViUlOVwyoHEDjYU433Aq+5zWP61+RGag==",
       "license": "MIT",
       "dependencies": {
@@ -15760,7 +14871,7 @@
     },
     "node_modules/renderkid/node_modules/domhandler": {
       "version": "4.3.1",
-      "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-4.3.1.tgz",
+      "resolved": "https://registry.facebook.net/domhandler/-/domhandler-4.3.1.tgz",
       "integrity": "sha512-GrwoxYN+uWlzO8uhUXRl0P+kHE4GtVPfYzVLcUxPL7KNdHKj66vvlhiweIHqYYXWlw+T8iLMp42Lm67ghw4WMQ==",
       "license": "BSD-2-Clause",
       "dependencies": {
@@ -15775,7 +14886,7 @@
     },
     "node_modules/renderkid/node_modules/domutils": {
       "version": "2.8.0",
-      "resolved": "https://registry.npmjs.org/domutils/-/domutils-2.8.0.tgz",
+      "resolved": "https://registry.facebook.net/domutils/-/domutils-2.8.0.tgz",
       "integrity": "sha512-w96Cjofp72M5IIhpjgobBimYEfoPjx1Vx0BSX9P30WBdZW2WIKU0T1Bd0kz2eNZ9ikjKgHbEyKx8BB6H1L3h3A==",
       "license": "BSD-2-Clause",
       "dependencies": {
@@ -15789,7 +14900,7 @@
     },
     "node_modules/renderkid/node_modules/entities": {
       "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/entities/-/entities-2.2.0.tgz",
+      "resolved": "https://registry.facebook.net/entities/-/entities-2.2.0.tgz",
       "integrity": "sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==",
       "license": "BSD-2-Clause",
       "funding": {
@@ -15798,7 +14909,7 @@
     },
     "node_modules/renderkid/node_modules/htmlparser2": {
       "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-6.1.0.tgz",
+      "resolved": "https://registry.facebook.net/htmlparser2/-/htmlparser2-6.1.0.tgz",
       "integrity": "sha512-gyyPk6rgonLFEDGoeRgQNaEUvdJ4ktTmmUh/h2t7s+M8oPpIPxgNACWa+6ESR57kXstwqPiCut0V8NRpcwgU7A==",
       "funding": [
         "https://github.com/fb55/htmlparser2?sponsor=1",
@@ -15819,14 +14930,13 @@
       "version": "1.6.1",
       "resolved": "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz",
       "integrity": "sha512-PV0dzCYDNfRi1jCDbJzpW7jNNDRuCOG/jI5ctQcGKt/clZD+YcPS3yIlWuTJMmESC8aevCFmWJy5wjAFgNqN6w==",
-      "license": "MIT",
       "engines": {
         "node": ">=0.10"
       }
     },
     "node_modules/require-from-string": {
       "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+      "resolved": "https://registry.facebook.net/require-from-string/-/require-from-string-2.0.2.tgz",
       "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
       "license": "MIT",
       "engines": {
@@ -15835,7 +14945,7 @@
     },
     "node_modules/require-like": {
       "version": "0.1.2",
-      "resolved": "https://registry.npmjs.org/require-like/-/require-like-0.1.2.tgz",
+      "resolved": "https://registry.facebook.net/require-like/-/require-like-0.1.2.tgz",
       "integrity": "sha512-oyrU88skkMtDdauHDuKVrgR+zuItqr6/c//FXzvmxRGMexSDc6hNvJInGW3LL46n+8b50RykrvwSUIIQH2LQ5A==",
       "engines": {
         "node": "*"
@@ -15843,17 +14953,18 @@
     },
     "node_modules/requires-port": {
       "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz",
+      "resolved": "https://registry.facebook.net/requires-port/-/requires-port-1.0.0.tgz",
       "integrity": "sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==",
       "license": "MIT"
     },
     "node_modules/resolve": {
-      "version": "1.22.10",
-      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.10.tgz",
-      "integrity": "sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==",
+      "version": "1.22.12",
+      "resolved": "https://registry.facebook.net/resolve/-/resolve-1.22.12.tgz",
+      "integrity": "sha512-TyeJ1zif53BPfHootBGwPRYT1RUt6oGWsaQr8UyZW/eAm9bKoijtvruSDEmZHm92CwS9nj7/fWttqPCgzep8CA==",
       "license": "MIT",
       "dependencies": {
-        "is-core-module": "^2.16.0",
+        "es-errors": "^1.3.0",
+        "is-core-module": "^2.16.1",
         "path-parse": "^1.0.7",
         "supports-preserve-symlinks-flag": "^1.0.0"
       },
@@ -15869,13 +14980,13 @@
     },
     "node_modules/resolve-alpn": {
       "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/resolve-alpn/-/resolve-alpn-1.2.1.tgz",
+      "resolved": "https://registry.facebook.net/resolve-alpn/-/resolve-alpn-1.2.1.tgz",
       "integrity": "sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==",
       "license": "MIT"
     },
     "node_modules/resolve-from": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+      "resolved": "https://registry.facebook.net/resolve-from/-/resolve-from-4.0.0.tgz",
       "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
       "license": "MIT",
       "engines": {
@@ -15884,13 +14995,13 @@
     },
     "node_modules/resolve-pathname": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/resolve-pathname/-/resolve-pathname-3.0.0.tgz",
+      "resolved": "https://registry.facebook.net/resolve-pathname/-/resolve-pathname-3.0.0.tgz",
       "integrity": "sha512-C7rARubxI8bXFNB/hqcp/4iUeIXJhJZvFPFPiSPRnhU5UPxzMFIl+2E6yY6c4k9giDJAhtV+enfA+G89N6Csng==",
       "license": "MIT"
     },
     "node_modules/responselike": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/responselike/-/responselike-3.0.0.tgz",
+      "resolved": "https://registry.facebook.net/responselike/-/responselike-3.0.0.tgz",
       "integrity": "sha512-40yHxbNcl2+rzXvZuVkrYohathsSJlMTXKryG5y8uciHv1+xDLHQpgjG64JUO9nrEq2jGLH6IZ8BcZyw3wrweg==",
       "license": "MIT",
       "dependencies": {
@@ -15905,7 +15016,7 @@
     },
     "node_modules/retry": {
       "version": "0.13.1",
-      "resolved": "https://registry.npmjs.org/retry/-/retry-0.13.1.tgz",
+      "resolved": "https://registry.facebook.net/retry/-/retry-0.13.1.tgz",
       "integrity": "sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==",
       "license": "MIT",
       "engines": {
@@ -15913,40 +15024,18 @@
       }
     },
     "node_modules/reusify": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz",
-      "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==",
+      "version": "1.1.0",
+      "resolved": "https://registry.facebook.net/reusify/-/reusify-1.1.0.tgz",
+      "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==",
       "license": "MIT",
       "engines": {
         "iojs": ">=1.0.0",
         "node": ">=0.10.0"
       }
     },
-    "node_modules/rimraf": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
-      "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
-      "deprecated": "Rimraf versions prior to v4 are no longer supported",
-      "license": "ISC",
-      "dependencies": {
-        "glob": "^7.1.3"
-      },
-      "bin": {
-        "rimraf": "bin.js"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/rtl-detect": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/rtl-detect/-/rtl-detect-1.1.2.tgz",
-      "integrity": "sha512-PGMBq03+TTG/p/cRB7HCLKJ1MgDIi07+QU1faSjiYRfmY5UsAttV9Hs08jDAHVwcOwmVLcSJkpwyfXszVjWfIQ==",
-      "license": "BSD-3-Clause"
-    },
     "node_modules/rtlcss": {
       "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/rtlcss/-/rtlcss-4.3.0.tgz",
+      "resolved": "https://registry.facebook.net/rtlcss/-/rtlcss-4.3.0.tgz",
       "integrity": "sha512-FI+pHEn7Wc4NqKXMXFM+VAYKEj/mRIcW4h24YVwVtyjI+EqGrLc2Hx/Ny0lrZ21cBWU2goLy36eqMcNj3AQJig==",
       "license": "MIT",
       "dependencies": {
@@ -15962,9 +15051,21 @@
         "node": ">=12.0.0"
       }
     },
+    "node_modules/run-applescript": {
+      "version": "7.1.0",
+      "resolved": "https://registry.facebook.net/run-applescript/-/run-applescript-7.1.0.tgz",
+      "integrity": "sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/run-parallel": {
       "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
+      "resolved": "https://registry.facebook.net/run-parallel/-/run-parallel-1.2.0.tgz",
       "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
       "funding": [
         {
@@ -15987,7 +15088,7 @@
     },
     "node_modules/safe-buffer": {
       "version": "5.2.1",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "resolved": "https://registry.facebook.net/safe-buffer/-/safe-buffer-5.2.1.tgz",
       "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
       "funding": [
         {
@@ -16007,29 +15108,38 @@
     },
     "node_modules/safer-buffer": {
       "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "resolved": "https://registry.facebook.net/safer-buffer/-/safer-buffer-2.1.2.tgz",
       "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
       "license": "MIT"
     },
     "node_modules/sax": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/sax/-/sax-1.4.1.tgz",
-      "integrity": "sha512-+aWOz7yVScEGoKNd4PA10LZ8sk0A/z5+nXQG5giUO5rprX9jgYsTdov9qCchZiPIZezbZH+jRut8nPodFAX4Jg==",
-      "license": "ISC"
+      "version": "1.6.0",
+      "resolved": "https://registry.facebook.net/sax/-/sax-1.6.0.tgz",
+      "integrity": "sha512-6R3J5M4AcbtLUdZmRv2SygeVaM7IhrLXu9BmnOGmmACak8fiUtOsYNWUS4uK7upbmHIBbLBeFeI//477BKLBzA==",
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=11.0.0"
+      }
     },
     "node_modules/scheduler": {
       "version": "0.23.2",
-      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
+      "resolved": "https://registry.facebook.net/scheduler/-/scheduler-0.23.2.tgz",
       "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
       "license": "MIT",
       "dependencies": {
         "loose-envify": "^1.1.0"
       }
     },
+    "node_modules/schema-dts": {
+      "version": "1.1.5",
+      "resolved": "https://registry.facebook.net/schema-dts/-/schema-dts-1.1.5.tgz",
+      "integrity": "sha512-RJr9EaCmsLzBX2NDiO5Z3ux2BVosNZN5jo0gWgsyKvxKIUL5R3swNvoorulAeL9kLB0iTSX7V6aokhla2m7xbg==",
+      "license": "Apache-2.0"
+    },
     "node_modules/schema-utils": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.3.0.tgz",
-      "integrity": "sha512-Gf9qqc58SpCA/xdziiHz35F4GNIWYWZrEshUc/G/r5BnLph6xpKuLeoJoQuj5WfBIx/eQLf+hmVPYHaxJu7V2g==",
+      "version": "4.3.3",
+      "resolved": "https://registry.facebook.net/schema-utils/-/schema-utils-4.3.3.tgz",
+      "integrity": "sha512-eflK8wEtyOE6+hsaRVPxvUKYCpRgzLqDTb8krvAsRIwOGlHoSgYLgBXoubGgLd2fT41/OUYdb48v4k4WWHQurA==",
       "license": "MIT",
       "dependencies": {
         "@types/json-schema": "^7.0.9",
@@ -16049,12 +15159,11 @@
       "version": "2.17.3",
       "resolved": "https://registry.npmjs.org/search-insights/-/search-insights-2.17.3.tgz",
       "integrity": "sha512-RQPdCYTa8A68uM2jwxoY842xDhvx3E5LFL1LxvxCNMev4o5mLuokczhzjAgGwUZBAmOKZknArSxLKmXtIi2AxQ==",
-      "license": "MIT",
       "peer": true
     },
     "node_modules/section-matter": {
       "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/section-matter/-/section-matter-1.0.0.tgz",
+      "resolved": "https://registry.facebook.net/section-matter/-/section-matter-1.0.0.tgz",
       "integrity": "sha512-vfD3pmTzGpufjScBh50YHKzEu2lxBWhVEHsNGoEXmCmn2hKGfeNLYMzCJpe8cD7gqX7TJluOVpBkAequ6dgMmA==",
       "license": "MIT",
       "dependencies": {
@@ -16067,38 +15176,35 @@
     },
     "node_modules/select-hose": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/select-hose/-/select-hose-2.0.0.tgz",
+      "resolved": "https://registry.facebook.net/select-hose/-/select-hose-2.0.0.tgz",
       "integrity": "sha512-mEugaLK+YfkijB4fx0e6kImuJdCIt2LxCRcbEYPqRGCs4F2ogyfZU5IAZRdjCP8JPq2AtdNoC/Dux63d9Kiryg==",
       "license": "MIT"
     },
     "node_modules/selfsigned": {
-      "version": "2.4.1",
-      "resolved": "https://registry.npmjs.org/selfsigned/-/selfsigned-2.4.1.tgz",
-      "integrity": "sha512-th5B4L2U+eGLq1TVh7zNRGBapioSORUeymIydxgFpwww9d2qyKvtuPU2jJuHvYAwwqi2Y596QBL3eEqcPEYL8Q==",
+      "version": "5.5.0",
+      "resolved": "https://registry.facebook.net/selfsigned/-/selfsigned-5.5.0.tgz",
+      "integrity": "sha512-ftnu3TW4+3eBfLRFnDEkzGxSF/10BJBkaLJuBHZX0kiPS7bRdlpZGu6YGt4KngMkdTwJE6MbjavFpqHvqVt+Ew==",
       "license": "MIT",
       "dependencies": {
-        "@types/node-forge": "^1.3.0",
-        "node-forge": "^1"
+        "@peculiar/x509": "^1.14.2",
+        "pkijs": "^3.3.3"
       },
       "engines": {
-        "node": ">=10"
+        "node": ">=18"
       }
     },
     "node_modules/semver": {
-      "version": "7.6.3",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz",
-      "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==",
+      "version": "6.3.1",
+      "resolved": "https://registry.facebook.net/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
       "license": "ISC",
       "bin": {
         "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
       }
     },
     "node_modules/semver-diff": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/semver-diff/-/semver-diff-4.0.0.tgz",
+      "resolved": "https://registry.facebook.net/semver-diff/-/semver-diff-4.0.0.tgz",
       "integrity": "sha512-0Ju4+6A8iOnpL/Thra7dZsSlOHYAHIeMxfhWQRI1/VLcT3WDBZKKtQt/QkBOsiIN9ZpuvHE6cGZ0x4glCMmfiA==",
       "license": "MIT",
       "dependencies": {
@@ -16111,25 +15217,37 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/semver-diff/node_modules/semver": {
+      "version": "7.7.4",
+      "resolved": "https://registry.facebook.net/semver/-/semver-7.7.4.tgz",
+      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/send": {
-      "version": "0.19.0",
-      "resolved": "https://registry.npmjs.org/send/-/send-0.19.0.tgz",
-      "integrity": "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==",
+      "version": "0.19.2",
+      "resolved": "https://registry.facebook.net/send/-/send-0.19.2.tgz",
+      "integrity": "sha512-VMbMxbDeehAxpOtWJXlcUS5E8iXh6QmN+BkRX1GARS3wRaXEEgzCcB10gTQazO42tpNIya8xIyNx8fll1OFPrg==",
       "license": "MIT",
       "dependencies": {
         "debug": "2.6.9",
         "depd": "2.0.0",
         "destroy": "1.2.0",
-        "encodeurl": "~1.0.2",
+        "encodeurl": "~2.0.0",
         "escape-html": "~1.0.3",
         "etag": "~1.8.1",
-        "fresh": "0.5.2",
-        "http-errors": "2.0.0",
+        "fresh": "~0.5.2",
+        "http-errors": "~2.0.1",
         "mime": "1.6.0",
         "ms": "2.1.3",
-        "on-finished": "2.4.1",
+        "on-finished": "~2.4.1",
         "range-parser": "~1.2.1",
-        "statuses": "2.0.1"
+        "statuses": "~2.0.2"
       },
       "engines": {
         "node": ">= 0.8.0"
@@ -16137,7 +15255,7 @@
     },
     "node_modules/send/node_modules/debug": {
       "version": "2.6.9",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "resolved": "https://registry.facebook.net/debug/-/debug-2.6.9.tgz",
       "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
       "license": "MIT",
       "dependencies": {
@@ -16146,31 +15264,13 @@
     },
     "node_modules/send/node_modules/debug/node_modules/ms": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "resolved": "https://registry.facebook.net/ms/-/ms-2.0.0.tgz",
       "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
       "license": "MIT"
     },
-    "node_modules/send/node_modules/encodeurl": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
-      "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/send/node_modules/range-parser": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
-      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
     "node_modules/serialize-javascript": {
       "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.2.tgz",
+      "resolved": "https://registry.facebook.net/serialize-javascript/-/serialize-javascript-6.0.2.tgz",
       "integrity": "sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==",
       "license": "BSD-3-Clause",
       "dependencies": {
@@ -16178,23 +15278,32 @@
       }
     },
     "node_modules/serve-handler": {
-      "version": "6.1.6",
-      "resolved": "https://registry.npmjs.org/serve-handler/-/serve-handler-6.1.6.tgz",
-      "integrity": "sha512-x5RL9Y2p5+Sh3D38Fh9i/iQ5ZK+e4xuXRd/pGbM4D13tgo/MGwbttUk8emytcr1YYzBYs+apnUngBDFYfpjPuQ==",
+      "version": "6.1.7",
+      "resolved": "https://registry.facebook.net/serve-handler/-/serve-handler-6.1.7.tgz",
+      "integrity": "sha512-CinAq1xWb0vR3twAv9evEU8cNWkXCb9kd5ePAHUKJBkOsUpR1wt/CvGdeca7vqumL1U5cSaeVQ6zZMxiJ3yWsg==",
       "license": "MIT",
       "dependencies": {
         "bytes": "3.0.0",
         "content-disposition": "0.5.2",
         "mime-types": "2.1.18",
-        "minimatch": "3.1.2",
+        "minimatch": "3.1.5",
         "path-is-inside": "1.0.2",
         "path-to-regexp": "3.3.0",
         "range-parser": "1.2.0"
       }
     },
+    "node_modules/serve-handler/node_modules/bytes": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/bytes/-/bytes-3.0.0.tgz",
+      "integrity": "sha512-pMhOfFDPiv9t5jjIXkHosWmkSyQbvsgEVNkz0ERHbuLh2T/7j4Mqqpz523Fe8MVY89KC6Sh/QfS2sM+SjgFDcw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/serve-handler/node_modules/mime-db": {
       "version": "1.33.0",
-      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.33.0.tgz",
+      "resolved": "https://registry.facebook.net/mime-db/-/mime-db-1.33.0.tgz",
       "integrity": "sha512-BHJ/EKruNIqJf/QahvxwQZXKygOQ256myeN/Ew+THcAa5q+PjyTTMMeNQC4DZw5AwfvelsUrA6B67NKMqXDbzQ==",
       "license": "MIT",
       "engines": {
@@ -16203,7 +15312,7 @@
     },
     "node_modules/serve-handler/node_modules/mime-types": {
       "version": "2.1.18",
-      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.18.tgz",
+      "resolved": "https://registry.facebook.net/mime-types/-/mime-types-2.1.18.tgz",
       "integrity": "sha512-lc/aahn+t4/SWV/qcmumYjymLsWfN3ELhpmVuUFjgsORruuZPVSwAQryq+HHGvO/SI2KVX26bx+En+zhM8g8hQ==",
       "license": "MIT",
       "dependencies": {
@@ -16213,33 +15322,40 @@
         "node": ">= 0.6"
       }
     },
-    "node_modules/serve-handler/node_modules/path-to-regexp": {
-      "version": "3.3.0",
-      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-3.3.0.tgz",
-      "integrity": "sha512-qyCH421YQPS2WFDxDjftfc1ZR5WKQzVzqsp4n9M2kQhVOo/ByahFoUNJfl58kOcEGfQ//7weFTDhm+ss8Ecxgw==",
-      "license": "MIT"
+    "node_modules/serve-handler/node_modules/range-parser": {
+      "version": "1.2.0",
+      "resolved": "https://registry.facebook.net/range-parser/-/range-parser-1.2.0.tgz",
+      "integrity": "sha512-kA5WQoNVo4t9lNx2kQNFCxKeBl5IbbSNBl1M/tLkw9WCn+hxNBAW5Qh8gdhs63CJnhjJ2zQWFoqPJP2sK1AV5A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
     },
     "node_modules/serve-index": {
-      "version": "1.9.1",
-      "resolved": "https://registry.npmjs.org/serve-index/-/serve-index-1.9.1.tgz",
-      "integrity": "sha512-pXHfKNP4qujrtteMrSBb0rc8HJ9Ms/GrXwcUtUtD5s4ewDJI8bT3Cz2zTVRMKtri49pLx2e0Ya8ziP5Ya2pZZw==",
+      "version": "1.9.2",
+      "resolved": "https://registry.facebook.net/serve-index/-/serve-index-1.9.2.tgz",
+      "integrity": "sha512-KDj11HScOaLmrPxl70KYNW1PksP4Nb/CLL2yvC+Qd2kHMPEEpfc4Re2e4FOay+bC/+XQl/7zAcWON3JVo5v3KQ==",
       "license": "MIT",
       "dependencies": {
-        "accepts": "~1.3.4",
+        "accepts": "~1.3.8",
         "batch": "0.6.1",
         "debug": "2.6.9",
         "escape-html": "~1.0.3",
-        "http-errors": "~1.6.2",
-        "mime-types": "~2.1.17",
-        "parseurl": "~1.3.2"
+        "http-errors": "~1.8.0",
+        "mime-types": "~2.1.35",
+        "parseurl": "~1.3.3"
       },
       "engines": {
         "node": ">= 0.8.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
       }
     },
     "node_modules/serve-index/node_modules/debug": {
       "version": "2.6.9",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "resolved": "https://registry.facebook.net/debug/-/debug-2.6.9.tgz",
       "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
       "license": "MIT",
       "dependencies": {
@@ -16248,7 +15364,7 @@
     },
     "node_modules/serve-index/node_modules/depd": {
       "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.2.tgz",
+      "resolved": "https://registry.facebook.net/depd/-/depd-1.1.2.tgz",
       "integrity": "sha512-7emPTl6Dpo6JRXOXjLRxck+FlLRX5847cLKEn00PLAgc3g2hTZZgr+e4c2v6QpSmLeFP3n5yUo7ft6avBK/5jQ==",
       "license": "MIT",
       "engines": {
@@ -16256,41 +15372,30 @@
       }
     },
     "node_modules/serve-index/node_modules/http-errors": {
-      "version": "1.6.3",
-      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.6.3.tgz",
-      "integrity": "sha512-lks+lVC8dgGyh97jxvxeYTWQFvh4uw4yC12gVl63Cg30sjPX4wuGcdkICVXDAESr6OJGjqGA8Iz5mkeN6zlD7A==",
+      "version": "1.8.1",
+      "resolved": "https://registry.facebook.net/http-errors/-/http-errors-1.8.1.tgz",
+      "integrity": "sha512-Kpk9Sm7NmI+RHhnj6OIWDI1d6fIoFAtFt9RLaTMRlg/8w49juAStsrBgp0Dp4OdxdVbRIeKhtCUvoi/RuAhO4g==",
       "license": "MIT",
       "dependencies": {
         "depd": "~1.1.2",
-        "inherits": "2.0.3",
-        "setprototypeof": "1.1.0",
-        "statuses": ">= 1.4.0 < 2"
+        "inherits": "2.0.4",
+        "setprototypeof": "1.2.0",
+        "statuses": ">= 1.5.0 < 2",
+        "toidentifier": "1.0.1"
       },
       "engines": {
         "node": ">= 0.6"
       }
     },
-    "node_modules/serve-index/node_modules/inherits": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
-      "integrity": "sha512-x00IRNXNy63jwGkJmzPigoySHbaqpNuzKbBOmzK+g2OdZpQ9w+sxCN+VSB3ja7IAge2OP2qpfxTjeNcyjmW1uw==",
-      "license": "ISC"
-    },
     "node_modules/serve-index/node_modules/ms": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "resolved": "https://registry.facebook.net/ms/-/ms-2.0.0.tgz",
       "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
       "license": "MIT"
     },
-    "node_modules/serve-index/node_modules/setprototypeof": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.1.0.tgz",
-      "integrity": "sha512-BvE/TwpZX4FXExxOxZyRGQQv651MSwmWKZGqvmPcRIjDqWub67kTKuIMx43cZZrS/cBBzwBcNDWoFxt2XEFIpQ==",
-      "license": "ISC"
-    },
     "node_modules/serve-index/node_modules/statuses": {
       "version": "1.5.0",
-      "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.5.0.tgz",
+      "resolved": "https://registry.facebook.net/statuses/-/statuses-1.5.0.tgz",
       "integrity": "sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA==",
       "license": "MIT",
       "engines": {
@@ -16298,15 +15403,15 @@
       }
     },
     "node_modules/serve-static": {
-      "version": "1.16.2",
-      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.2.tgz",
-      "integrity": "sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==",
+      "version": "1.16.3",
+      "resolved": "https://registry.facebook.net/serve-static/-/serve-static-1.16.3.tgz",
+      "integrity": "sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==",
       "license": "MIT",
       "dependencies": {
         "encodeurl": "~2.0.0",
         "escape-html": "~1.0.3",
         "parseurl": "~1.3.3",
-        "send": "0.19.0"
+        "send": "~0.19.1"
       },
       "engines": {
         "node": ">= 0.8.0"
@@ -16314,7 +15419,7 @@
     },
     "node_modules/set-function-length": {
       "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
+      "resolved": "https://registry.facebook.net/set-function-length/-/set-function-length-1.2.2.tgz",
       "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==",
       "license": "MIT",
       "dependencies": {
@@ -16331,13 +15436,13 @@
     },
     "node_modules/setprototypeof": {
       "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "resolved": "https://registry.facebook.net/setprototypeof/-/setprototypeof-1.2.0.tgz",
       "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
       "license": "ISC"
     },
     "node_modules/shallow-clone": {
       "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/shallow-clone/-/shallow-clone-3.0.1.tgz",
+      "resolved": "https://registry.facebook.net/shallow-clone/-/shallow-clone-3.0.1.tgz",
       "integrity": "sha512-/6KqX+GVUdqPuPPd2LxDDxzX6CAbjJehAAOKlNpqqUpAqPM6HeL8f+o3a+JsyGjn2lv0WY8UsTgUJjU9Ok55NA==",
       "license": "MIT",
       "dependencies": {
@@ -16349,13 +15454,13 @@
     },
     "node_modules/shallowequal": {
       "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/shallowequal/-/shallowequal-1.1.0.tgz",
+      "resolved": "https://registry.facebook.net/shallowequal/-/shallowequal-1.1.0.tgz",
       "integrity": "sha512-y0m1JoUZSlPAjXVtPPW70aZWfIL/dSP7AFkRnniLCrK/8MDKog3TySTBmckD+RObVxH0v4Tox67+F14PdED2oQ==",
       "license": "MIT"
     },
     "node_modules/shebang-command": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "resolved": "https://registry.facebook.net/shebang-command/-/shebang-command-2.0.0.tgz",
       "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
       "license": "MIT",
       "dependencies": {
@@ -16367,7 +15472,7 @@
     },
     "node_modules/shebang-regex": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "resolved": "https://registry.facebook.net/shebang-regex/-/shebang-regex-3.0.0.tgz",
       "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
       "license": "MIT",
       "engines": {
@@ -16375,9 +15480,9 @@
       }
     },
     "node_modules/shell-quote": {
-      "version": "1.8.2",
-      "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.8.2.tgz",
-      "integrity": "sha512-AzqKpGKjrj7EM6rKVQEPpB288oCfnrEIuyoT9cyF4nmGa7V8Zk6f7RRqYisX8X9m+Q7bd632aZW4ky7EhbQztA==",
+      "version": "1.8.3",
+      "resolved": "https://registry.facebook.net/shell-quote/-/shell-quote-1.8.3.tgz",
+      "integrity": "sha512-ObmnIF4hXNg1BqhnHmgbDETF8dLPCggZWBjkQfhZpbszZnYur5DUljTcCHii5LC3J5E0yeO/1LIMyH+UvHQgyw==",
       "license": "MIT",
       "engines": {
         "node": ">= 0.4"
@@ -16386,26 +15491,9 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/shelljs": {
-      "version": "0.8.5",
-      "resolved": "https://registry.npmjs.org/shelljs/-/shelljs-0.8.5.tgz",
-      "integrity": "sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow==",
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "glob": "^7.0.0",
-        "interpret": "^1.0.0",
-        "rechoir": "^0.6.2"
-      },
-      "bin": {
-        "shjs": "bin/shjs"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/side-channel": {
       "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
+      "resolved": "https://registry.facebook.net/side-channel/-/side-channel-1.1.0.tgz",
       "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
       "license": "MIT",
       "dependencies": {
@@ -16423,13 +15511,13 @@
       }
     },
     "node_modules/side-channel-list": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
-      "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/side-channel-list/-/side-channel-list-1.0.1.tgz",
+      "integrity": "sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==",
       "license": "MIT",
       "dependencies": {
         "es-errors": "^1.3.0",
-        "object-inspect": "^1.13.3"
+        "object-inspect": "^1.13.4"
       },
       "engines": {
         "node": ">= 0.4"
@@ -16440,7 +15528,7 @@
     },
     "node_modules/side-channel-map": {
       "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+      "resolved": "https://registry.facebook.net/side-channel-map/-/side-channel-map-1.0.1.tgz",
       "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
       "license": "MIT",
       "dependencies": {
@@ -16458,7 +15546,7 @@
     },
     "node_modules/side-channel-weakmap": {
       "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+      "resolved": "https://registry.facebook.net/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
       "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
       "license": "MIT",
       "dependencies": {
@@ -16477,13 +15565,13 @@
     },
     "node_modules/signal-exit": {
       "version": "3.0.7",
-      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
+      "resolved": "https://registry.facebook.net/signal-exit/-/signal-exit-3.0.7.tgz",
       "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
       "license": "ISC"
     },
     "node_modules/sirv": {
       "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/sirv/-/sirv-2.0.4.tgz",
+      "resolved": "https://registry.facebook.net/sirv/-/sirv-2.0.4.tgz",
       "integrity": "sha512-94Bdh3cC2PKrbgSOUqTiGPWVZeSiXfKOVZNJniWoqrWrRkB1CJzBU3NEbiTsPcYy1lDsANA/THzS+9WBiy5nfQ==",
       "license": "MIT",
       "dependencies": {
@@ -16497,14 +15585,14 @@
     },
     "node_modules/sisteransi": {
       "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz",
+      "resolved": "https://registry.facebook.net/sisteransi/-/sisteransi-1.0.5.tgz",
       "integrity": "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==",
       "license": "MIT"
     },
     "node_modules/sitemap": {
-      "version": "7.1.2",
-      "resolved": "https://registry.npmjs.org/sitemap/-/sitemap-7.1.2.tgz",
-      "integrity": "sha512-ARCqzHJ0p4gWt+j7NlU5eDlIO9+Rkr/JhPFZKKQ1l5GCus7rJH4UdrlVAh0xC/gDS/Qir2UMxqYNHtsKr2rpCw==",
+      "version": "7.1.3",
+      "resolved": "https://registry.facebook.net/sitemap/-/sitemap-7.1.3.tgz",
+      "integrity": "sha512-tAjEd+wt/YwnEbfNB2ht51ybBJxbEWwe5ki/Z//Wh0rpBFTCUSj46GnxUKEWzhfuJTsee8x3lybHxFgUMig2hw==",
       "license": "MIT",
       "dependencies": {
         "@types/node": "^17.0.5",
@@ -16522,13 +15610,13 @@
     },
     "node_modules/sitemap/node_modules/@types/node": {
       "version": "17.0.45",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-17.0.45.tgz",
+      "resolved": "https://registry.facebook.net/@types/node/-/node-17.0.45.tgz",
       "integrity": "sha512-w+tIMs3rq2afQdsPJlODhoUEKzFP1ayaoyl1CcnwtIlsVe7K7bA1NGm4s3PraqTLlXnbIN84zuBlxBWo1u9BLw==",
       "license": "MIT"
     },
     "node_modules/skin-tone": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/skin-tone/-/skin-tone-2.0.0.tgz",
+      "resolved": "https://registry.facebook.net/skin-tone/-/skin-tone-2.0.0.tgz",
       "integrity": "sha512-kUMbT1oBJCpgrnKoSr0o6wPtvRWT9W9UKvGLwfJYO2WuahZRHOpEyL1ckyMGgMWh0UdpmaoFqKKD29WTomNEGA==",
       "license": "MIT",
       "dependencies": {
@@ -16540,7 +15628,7 @@
     },
     "node_modules/slash": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz",
+      "resolved": "https://registry.facebook.net/slash/-/slash-3.0.0.tgz",
       "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==",
       "license": "MIT",
       "engines": {
@@ -16549,7 +15637,7 @@
     },
     "node_modules/snake-case": {
       "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/snake-case/-/snake-case-3.0.4.tgz",
+      "resolved": "https://registry.facebook.net/snake-case/-/snake-case-3.0.4.tgz",
       "integrity": "sha512-LAOh4z89bGQvl9pFfNF8V146i7o7/CqFPbqzYgP+yYzDIDeS9HaNFtXABamRW+AQzEVODcvE79ljJ+8a9YSdMg==",
       "license": "MIT",
       "dependencies": {
@@ -16559,7 +15647,7 @@
     },
     "node_modules/sockjs": {
       "version": "0.3.24",
-      "resolved": "https://registry.npmjs.org/sockjs/-/sockjs-0.3.24.tgz",
+      "resolved": "https://registry.facebook.net/sockjs/-/sockjs-0.3.24.tgz",
       "integrity": "sha512-GJgLTZ7vYb/JtPSSZ10hsOYIvEYsjbNU+zPdIHcUaWVNUEPivzxku31865sSSud0Da0W4lEeOPlmw93zLQchuQ==",
       "license": "MIT",
       "dependencies": {
@@ -16570,7 +15658,7 @@
     },
     "node_modules/sort-css-media-queries": {
       "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/sort-css-media-queries/-/sort-css-media-queries-2.2.0.tgz",
+      "resolved": "https://registry.facebook.net/sort-css-media-queries/-/sort-css-media-queries-2.2.0.tgz",
       "integrity": "sha512-0xtkGhWCC9MGt/EzgnvbbbKhqWjl1+/rncmhTh5qCpbYguXh6S/qwePfv/JQ8jePXXmqingylxoC49pCkSPIbA==",
       "license": "MIT",
       "engines": {
@@ -16578,17 +15666,17 @@
       }
     },
     "node_modules/source-map": {
-      "version": "0.7.4",
-      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.4.tgz",
-      "integrity": "sha512-l3BikUxvPOcn5E74dZiq5BGsTb5yEwhaTSzccU6t4sDOH8NWJCstKO5QT2CvtFoK6F0saL7p9xHAqHOlCPJygA==",
+      "version": "0.6.1",
+      "resolved": "https://registry.facebook.net/source-map/-/source-map-0.6.1.tgz",
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
       "license": "BSD-3-Clause",
       "engines": {
-        "node": ">= 8"
+        "node": ">=0.10.0"
       }
     },
     "node_modules/source-map-js": {
       "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "resolved": "https://registry.facebook.net/source-map-js/-/source-map-js-1.2.1.tgz",
       "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
       "license": "BSD-3-Clause",
       "engines": {
@@ -16597,7 +15685,7 @@
     },
     "node_modules/source-map-support": {
       "version": "0.5.21",
-      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz",
+      "resolved": "https://registry.facebook.net/source-map-support/-/source-map-support-0.5.21.tgz",
       "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==",
       "license": "MIT",
       "dependencies": {
@@ -16605,18 +15693,9 @@
         "source-map": "^0.6.0"
       }
     },
-    "node_modules/source-map-support/node_modules/source-map": {
-      "version": "0.6.1",
-      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
-      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
-      "license": "BSD-3-Clause",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
     "node_modules/space-separated-tokens": {
       "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz",
+      "resolved": "https://registry.facebook.net/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz",
       "integrity": "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==",
       "license": "MIT",
       "funding": {
@@ -16626,7 +15705,7 @@
     },
     "node_modules/spdy": {
       "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/spdy/-/spdy-4.0.2.tgz",
+      "resolved": "https://registry.facebook.net/spdy/-/spdy-4.0.2.tgz",
       "integrity": "sha512-r46gZQZQV+Kl9oItvl1JZZqJKGr+oEkB08A6BzkiR7593/7IbtuncXHd2YoYeTsG4157ZssMu9KYvUHLcjcDoA==",
       "license": "MIT",
       "dependencies": {
@@ -16642,7 +15721,7 @@
     },
     "node_modules/spdy-transport": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/spdy-transport/-/spdy-transport-3.0.0.tgz",
+      "resolved": "https://registry.facebook.net/spdy-transport/-/spdy-transport-3.0.0.tgz",
       "integrity": "sha512-hsLVFE5SjA6TCisWeJXFKniGGOpBgMLmerfO2aCyCU5s7nJ/rpAepqmFifv/GCbSbueEeAJJnmSQ2rKC/g8Fcw==",
       "license": "MIT",
       "dependencies": {
@@ -16656,13 +15735,13 @@
     },
     "node_modules/sprintf-js": {
       "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
+      "resolved": "https://registry.facebook.net/sprintf-js/-/sprintf-js-1.0.3.tgz",
       "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==",
       "license": "BSD-3-Clause"
     },
     "node_modules/srcset": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/srcset/-/srcset-4.0.0.tgz",
+      "resolved": "https://registry.facebook.net/srcset/-/srcset-4.0.0.tgz",
       "integrity": "sha512-wvLeHgcVHKO8Sc/H/5lkGreJQVeYMm9rlmt8PuR1xE31rIuXhuzznUUqAt8MqLhB3MqJdFzlNAfpcWnxiFUcPw==",
       "license": "MIT",
       "engines": {
@@ -16673,23 +15752,23 @@
       }
     },
     "node_modules/statuses": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
-      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
+      "version": "2.0.2",
+      "resolved": "https://registry.facebook.net/statuses/-/statuses-2.0.2.tgz",
+      "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==",
       "license": "MIT",
       "engines": {
         "node": ">= 0.8"
       }
     },
     "node_modules/std-env": {
-      "version": "3.8.0",
-      "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.8.0.tgz",
-      "integrity": "sha512-Bc3YwwCB+OzldMxOXJIIvC6cPRWr/LxOp48CdQTOkPyk/t4JWWJbrilwBd7RJzKV8QW7tJkcgAmeuLLJugl5/w==",
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/std-env/-/std-env-3.10.0.tgz",
+      "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==",
       "license": "MIT"
     },
     "node_modules/string_decoder": {
       "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+      "resolved": "https://registry.facebook.net/string_decoder/-/string_decoder-1.3.0.tgz",
       "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
       "license": "MIT",
       "dependencies": {
@@ -16698,7 +15777,7 @@
     },
     "node_modules/string-width": {
       "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz",
+      "resolved": "https://registry.facebook.net/string-width/-/string-width-5.1.2.tgz",
       "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==",
       "license": "MIT",
       "dependencies": {
@@ -16714,9 +15793,9 @@
       }
     },
     "node_modules/string-width/node_modules/ansi-regex": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz",
-      "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==",
+      "version": "6.2.2",
+      "resolved": "https://registry.facebook.net/ansi-regex/-/ansi-regex-6.2.2.tgz",
+      "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==",
       "license": "MIT",
       "engines": {
         "node": ">=12"
@@ -16726,12 +15805,12 @@
       }
     },
     "node_modules/string-width/node_modules/strip-ansi": {
-      "version": "7.1.0",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz",
-      "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==",
+      "version": "7.2.0",
+      "resolved": "https://registry.facebook.net/strip-ansi/-/strip-ansi-7.2.0.tgz",
+      "integrity": "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==",
       "license": "MIT",
       "dependencies": {
-        "ansi-regex": "^6.0.1"
+        "ansi-regex": "^6.2.2"
       },
       "engines": {
         "node": ">=12"
@@ -16742,7 +15821,7 @@
     },
     "node_modules/stringify-entities": {
       "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.4.tgz",
+      "resolved": "https://registry.facebook.net/stringify-entities/-/stringify-entities-4.0.4.tgz",
       "integrity": "sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==",
       "license": "MIT",
       "dependencies": {
@@ -16756,7 +15835,7 @@
     },
     "node_modules/stringify-object": {
       "version": "3.3.0",
-      "resolved": "https://registry.npmjs.org/stringify-object/-/stringify-object-3.3.0.tgz",
+      "resolved": "https://registry.facebook.net/stringify-object/-/stringify-object-3.3.0.tgz",
       "integrity": "sha512-rHqiFh1elqCQ9WPLIC8I0Q/g/wj5J1eMkyoiD6eoQApWHP0FtlK7rqnhmabL5VUY9JQCcqwwvlOaSuutekgyrw==",
       "license": "BSD-2-Clause",
       "dependencies": {
@@ -16770,7 +15849,7 @@
     },
     "node_modules/strip-ansi": {
       "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "resolved": "https://registry.facebook.net/strip-ansi/-/strip-ansi-6.0.1.tgz",
       "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
       "license": "MIT",
       "dependencies": {
@@ -16782,7 +15861,7 @@
     },
     "node_modules/strip-bom-string": {
       "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/strip-bom-string/-/strip-bom-string-1.0.0.tgz",
+      "resolved": "https://registry.facebook.net/strip-bom-string/-/strip-bom-string-1.0.0.tgz",
       "integrity": "sha512-uCC2VHvQRYu+lMh4My/sFNmF2klFymLX1wHJeXnbEJERpV/ZsVuonzerjfrGpIGF7LBVa1O7i9kjiWvJiFck8g==",
       "license": "MIT",
       "engines": {
@@ -16791,7 +15870,7 @@
     },
     "node_modules/strip-final-newline": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz",
+      "resolved": "https://registry.facebook.net/strip-final-newline/-/strip-final-newline-2.0.0.tgz",
       "integrity": "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==",
       "license": "MIT",
       "engines": {
@@ -16800,7 +15879,7 @@
     },
     "node_modules/strip-json-comments": {
       "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
+      "resolved": "https://registry.facebook.net/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
       "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
       "license": "MIT",
       "engines": {
@@ -16810,18 +15889,27 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/style-to-js": {
+      "version": "1.1.21",
+      "resolved": "https://registry.facebook.net/style-to-js/-/style-to-js-1.1.21.tgz",
+      "integrity": "sha512-RjQetxJrrUJLQPHbLku6U/ocGtzyjbJMP9lCNK7Ag0CNh690nSH8woqWH9u16nMjYBAok+i7JO1NP2pOy8IsPQ==",
+      "license": "MIT",
+      "dependencies": {
+        "style-to-object": "1.0.14"
+      }
+    },
     "node_modules/style-to-object": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/style-to-object/-/style-to-object-1.0.8.tgz",
-      "integrity": "sha512-xT47I/Eo0rwJmaXC4oilDGDWLohVhR6o/xAQcPQN8q6QBuZVL8qMYL85kLmST5cPjAorwvqIA4qXTRQoYHaL6g==",
+      "version": "1.0.14",
+      "resolved": "https://registry.facebook.net/style-to-object/-/style-to-object-1.0.14.tgz",
+      "integrity": "sha512-LIN7rULI0jBscWQYaSswptyderlarFkjQ+t79nzty8tcIAceVomEVlLzH5VP4Cmsv6MtKhs7qaAiwlcp+Mgaxw==",
       "license": "MIT",
       "dependencies": {
-        "inline-style-parser": "0.2.4"
+        "inline-style-parser": "0.2.7"
       }
     },
     "node_modules/stylehacks": {
       "version": "6.1.1",
-      "resolved": "https://registry.npmjs.org/stylehacks/-/stylehacks-6.1.1.tgz",
+      "resolved": "https://registry.facebook.net/stylehacks/-/stylehacks-6.1.1.tgz",
       "integrity": "sha512-gSTTEQ670cJNoaeIp9KX6lZmm8LJ3jPB5yJmX8Zq/wQxOsAFXV3qjWzHas3YYk1qesuVIyYWWUpZ0vSE/dTSGg==",
       "license": "MIT",
       "dependencies": {
@@ -16835,21 +15923,37 @@
         "postcss": "^8.4.31"
       }
     },
+    "node_modules/stylehacks/node_modules/postcss-selector-parser": {
+      "version": "6.1.2",
+      "resolved": "https://registry.facebook.net/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
+      "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
+      "license": "MIT",
+      "dependencies": {
+        "cssesc": "^3.0.0",
+        "util-deprecate": "^1.0.2"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/supports-color": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
-      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "version": "8.1.1",
+      "resolved": "https://registry.facebook.net/supports-color/-/supports-color-8.1.1.tgz",
+      "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==",
       "license": "MIT",
       "dependencies": {
         "has-flag": "^4.0.0"
       },
       "engines": {
-        "node": ">=8"
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/supports-color?sponsor=1"
       }
     },
     "node_modules/supports-preserve-symlinks-flag": {
       "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
+      "resolved": "https://registry.facebook.net/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
       "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
       "license": "MIT",
       "engines": {
@@ -16861,23 +15965,23 @@
     },
     "node_modules/svg-parser": {
       "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/svg-parser/-/svg-parser-2.0.4.tgz",
+      "resolved": "https://registry.facebook.net/svg-parser/-/svg-parser-2.0.4.tgz",
       "integrity": "sha512-e4hG1hRwoOdRb37cIMSgzNsxyzKfayW6VOflrwvR+/bzrkyxY/31WkbgnQpgtrNp1SdpJvpUAGTa/ZoiPNDuRQ==",
       "license": "MIT"
     },
     "node_modules/svgo": {
-      "version": "3.3.2",
-      "resolved": "https://registry.npmjs.org/svgo/-/svgo-3.3.2.tgz",
-      "integrity": "sha512-OoohrmuUlBs8B8o6MB2Aevn+pRIH9zDALSR+6hhqVfa6fRwG/Qw9VUMSMW9VNg2CFc/MTIfabtdOVl9ODIJjpw==",
+      "version": "3.3.3",
+      "resolved": "https://registry.facebook.net/svgo/-/svgo-3.3.3.tgz",
+      "integrity": "sha512-+wn7I4p7YgJhHs38k2TNjy1vCfPIfLIJWR5MnCStsN8WuuTcBnRKcMHQLMM2ijxGZmDoZwNv8ipl5aTTen62ng==",
       "license": "MIT",
       "dependencies": {
-        "@trysound/sax": "0.2.0",
         "commander": "^7.2.0",
         "css-select": "^5.1.0",
         "css-tree": "^2.3.1",
         "css-what": "^6.1.0",
         "csso": "^5.0.5",
-        "picocolors": "^1.0.0"
+        "picocolors": "^1.0.0",
+        "sax": "^1.5.0"
       },
       "bin": {
         "svgo": "bin/svgo"
@@ -16892,7 +15996,7 @@
     },
     "node_modules/svgo/node_modules/commander": {
       "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/commander/-/commander-7.2.0.tgz",
+      "resolved": "https://registry.facebook.net/commander/-/commander-7.2.0.tgz",
       "integrity": "sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==",
       "license": "MIT",
       "engines": {
@@ -16900,22 +16004,26 @@
       }
     },
     "node_modules/tapable": {
-      "version": "2.2.1",
-      "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.2.1.tgz",
-      "integrity": "sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==",
+      "version": "2.3.3",
+      "resolved": "https://registry.facebook.net/tapable/-/tapable-2.3.3.tgz",
+      "integrity": "sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A==",
       "license": "MIT",
       "engines": {
         "node": ">=6"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
       }
     },
     "node_modules/terser": {
-      "version": "5.37.0",
-      "resolved": "https://registry.npmjs.org/terser/-/terser-5.37.0.tgz",
-      "integrity": "sha512-B8wRRkmre4ERucLM/uXx4MOV5cbnOlVAqUst+1+iLKPI0dOgFO28f84ptoQt9HEI537PMzfYa/d+GEPKTRXmYA==",
+      "version": "5.46.2",
+      "resolved": "https://registry.facebook.net/terser/-/terser-5.46.2.tgz",
+      "integrity": "sha512-uxfo9fPcSgLDYob/w1FuL0c99MWiJDnv+5qXSQc5+Ki5NjVNsYi66INnMFBjf6uFz6OnX12piJQPF4IpjJTNTw==",
       "license": "BSD-2-Clause",
       "dependencies": {
         "@jridgewell/source-map": "^0.3.3",
-        "acorn": "^8.8.2",
+        "acorn": "^8.15.0",
         "commander": "^2.20.0",
         "source-map-support": "~0.5.20"
       },
@@ -16927,15 +16035,14 @@
       }
     },
     "node_modules/terser-webpack-plugin": {
-      "version": "5.3.11",
-      "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.11.tgz",
-      "integrity": "sha512-RVCsMfuD0+cTt3EwX8hSl2Ks56EbFHWmhluwcqoPKtBnfjiT6olaq7PRIRfhyU8nnC2MrnDrBLfrD/RGE+cVXQ==",
+      "version": "5.5.0",
+      "resolved": "https://registry.facebook.net/terser-webpack-plugin/-/terser-webpack-plugin-5.5.0.tgz",
+      "integrity": "sha512-UYhptBwhWvfIjKd/UuFo6D8uq9xpGLDK+z8EDsj/zWhrTaH34cKEbrkMKfV5YWqGBvAYA3tlzZbs2R+qYrbQJA==",
       "license": "MIT",
       "dependencies": {
         "@jridgewell/trace-mapping": "^0.3.25",
         "jest-worker": "^27.4.5",
         "schema-utils": "^4.3.0",
-        "serialize-javascript": "^6.0.2",
         "terser": "^5.31.1"
       },
       "engines": {
@@ -16960,68 +16067,58 @@
         }
       }
     },
-    "node_modules/terser-webpack-plugin/node_modules/jest-worker": {
-      "version": "27.5.1",
-      "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-27.5.1.tgz",
-      "integrity": "sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*",
-        "merge-stream": "^2.0.0",
-        "supports-color": "^8.0.0"
-      },
-      "engines": {
-        "node": ">= 10.13.0"
-      }
+    "node_modules/terser/node_modules/commander": {
+      "version": "2.20.3",
+      "resolved": "https://registry.facebook.net/commander/-/commander-2.20.3.tgz",
+      "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==",
+      "license": "MIT"
     },
-    "node_modules/terser-webpack-plugin/node_modules/supports-color": {
-      "version": "8.1.1",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz",
-      "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==",
+    "node_modules/thingies": {
+      "version": "2.6.0",
+      "resolved": "https://registry.facebook.net/thingies/-/thingies-2.6.0.tgz",
+      "integrity": "sha512-rMHRjmlFLM1R96UYPvpmnc3LYtdFrT33JIB7L9hetGue1qAPfn1N2LJeEjxUSidu1Iku+haLZXDuEXUHNGO/lg==",
       "license": "MIT",
-      "dependencies": {
-        "has-flag": "^4.0.0"
-      },
       "engines": {
-        "node": ">=10"
+        "node": ">=10.18"
       },
       "funding": {
-        "url": "https://github.com/chalk/supports-color?sponsor=1"
+        "type": "github",
+        "url": "https://github.com/sponsors/streamich"
+      },
+      "peerDependencies": {
+        "tslib": "^2"
       }
     },
-    "node_modules/terser/node_modules/commander": {
-      "version": "2.20.3",
-      "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
-      "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==",
-      "license": "MIT"
-    },
-    "node_modules/text-table": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz",
-      "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==",
-      "license": "MIT"
-    },
     "node_modules/thunky": {
       "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/thunky/-/thunky-1.1.0.tgz",
+      "resolved": "https://registry.facebook.net/thunky/-/thunky-1.1.0.tgz",
       "integrity": "sha512-eHY7nBftgThBqOyHGVN+l8gF0BucP09fMo0oO/Lb0w1OF80dJv+lDVpXG60WMQvkcxAkNybKsrEIE3ZtKGmPrA==",
       "license": "MIT"
     },
     "node_modules/tiny-invariant": {
       "version": "1.3.3",
-      "resolved": "https://registry.npmjs.org/tiny-invariant/-/tiny-invariant-1.3.3.tgz",
+      "resolved": "https://registry.facebook.net/tiny-invariant/-/tiny-invariant-1.3.3.tgz",
       "integrity": "sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==",
       "license": "MIT"
     },
     "node_modules/tiny-warning": {
       "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/tiny-warning/-/tiny-warning-1.0.3.tgz",
+      "resolved": "https://registry.facebook.net/tiny-warning/-/tiny-warning-1.0.3.tgz",
       "integrity": "sha512-lBN9zLN/oAf68o3zNXYrdCt1kP8WsiGW8Oo2ka41b2IM5JL/S1CTyX1rW0mb/zSuJun0ZUrDxx4sqvYS2FWzPA==",
       "license": "MIT"
     },
+    "node_modules/tinypool": {
+      "version": "1.1.1",
+      "resolved": "https://registry.facebook.net/tinypool/-/tinypool-1.1.1.tgz",
+      "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==",
+      "license": "MIT",
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      }
+    },
     "node_modules/to-regex-range": {
       "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "resolved": "https://registry.facebook.net/to-regex-range/-/to-regex-range-5.0.1.tgz",
       "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
       "license": "MIT",
       "dependencies": {
@@ -17033,7 +16130,7 @@
     },
     "node_modules/toidentifier": {
       "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "resolved": "https://registry.facebook.net/toidentifier/-/toidentifier-1.0.1.tgz",
       "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
       "license": "MIT",
       "engines": {
@@ -17042,16 +16139,32 @@
     },
     "node_modules/totalist": {
       "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/totalist/-/totalist-3.0.1.tgz",
+      "resolved": "https://registry.facebook.net/totalist/-/totalist-3.0.1.tgz",
       "integrity": "sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==",
       "license": "MIT",
       "engines": {
         "node": ">=6"
       }
     },
+    "node_modules/tree-dump": {
+      "version": "1.1.0",
+      "resolved": "https://registry.facebook.net/tree-dump/-/tree-dump-1.1.0.tgz",
+      "integrity": "sha512-rMuvhU4MCDbcbnleZTFezWsaZXRFemSqAM+7jPnzUl1fo9w3YEKOxAeui0fz3OI4EU4hf23iyA7uQRVko+UaBA==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=10.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/streamich"
+      },
+      "peerDependencies": {
+        "tslib": "2"
+      }
+    },
     "node_modules/trim-lines": {
       "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz",
+      "resolved": "https://registry.facebook.net/trim-lines/-/trim-lines-3.0.1.tgz",
       "integrity": "sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==",
       "license": "MIT",
       "funding": {
@@ -17061,7 +16174,7 @@
     },
     "node_modules/trough": {
       "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/trough/-/trough-2.2.0.tgz",
+      "resolved": "https://registry.facebook.net/trough/-/trough-2.2.0.tgz",
       "integrity": "sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw==",
       "license": "MIT",
       "funding": {
@@ -17071,13 +16184,31 @@
     },
     "node_modules/tslib": {
       "version": "2.8.1",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "resolved": "https://registry.facebook.net/tslib/-/tslib-2.8.1.tgz",
       "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
       "license": "0BSD"
     },
+    "node_modules/tsyringe": {
+      "version": "4.10.0",
+      "resolved": "https://registry.facebook.net/tsyringe/-/tsyringe-4.10.0.tgz",
+      "integrity": "sha512-axr3IdNuVIxnaK5XGEUFTu3YmAQ6lllgrvqfEoR16g/HGnYY/6We4oWENtAnzK6/LpJ2ur9PAb80RBt7/U4ugw==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^1.9.3"
+      },
+      "engines": {
+        "node": ">= 6.0.0"
+      }
+    },
+    "node_modules/tsyringe/node_modules/tslib": {
+      "version": "1.14.1",
+      "resolved": "https://registry.facebook.net/tslib/-/tslib-1.14.1.tgz",
+      "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==",
+      "license": "0BSD"
+    },
     "node_modules/type-fest": {
       "version": "2.19.0",
-      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-2.19.0.tgz",
+      "resolved": "https://registry.facebook.net/type-fest/-/type-fest-2.19.0.tgz",
       "integrity": "sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA==",
       "license": "(MIT OR CC0-1.0)",
       "engines": {
@@ -17089,7 +16220,7 @@
     },
     "node_modules/type-is": {
       "version": "1.6.18",
-      "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz",
+      "resolved": "https://registry.facebook.net/type-is/-/type-is-1.6.18.tgz",
       "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==",
       "license": "MIT",
       "dependencies": {
@@ -17102,36 +16233,22 @@
     },
     "node_modules/typedarray-to-buffer": {
       "version": "3.1.5",
-      "resolved": "https://registry.npmjs.org/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz",
+      "resolved": "https://registry.facebook.net/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz",
       "integrity": "sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==",
       "license": "MIT",
       "dependencies": {
         "is-typedarray": "^1.0.0"
       }
     },
-    "node_modules/typescript": {
-      "version": "5.7.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.7.2.tgz",
-      "integrity": "sha512-i5t66RHxDvVN40HfDd1PsEThGNnlMCMT3jMUuoh9/0TaqWevNontacunWyN02LA9/fIbEWlcHZcgTKb9QoaLfg==",
-      "license": "Apache-2.0",
-      "peer": true,
-      "bin": {
-        "tsc": "bin/tsc",
-        "tsserver": "bin/tsserver"
-      },
-      "engines": {
-        "node": ">=14.17"
-      }
-    },
     "node_modules/undici-types": {
-      "version": "6.20.0",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.20.0.tgz",
-      "integrity": "sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==",
+      "version": "7.19.2",
+      "resolved": "https://registry.facebook.net/undici-types/-/undici-types-7.19.2.tgz",
+      "integrity": "sha512-qYVnV5OEm2AW8cJMCpdV20CDyaN3g0AjDlOGf1OW4iaDEx8MwdtChUp4zu4H0VP3nDRF/8RKWH+IPp9uW0YGZg==",
       "license": "MIT"
     },
     "node_modules/unicode-canonical-property-names-ecmascript": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.1.tgz",
+      "resolved": "https://registry.facebook.net/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.1.tgz",
       "integrity": "sha512-dA8WbNeb2a6oQzAQ55YlT5vQAWGV9WXOsi3SskE3bcCdM0P4SDd+24zS/OCacdRq5BkdsRj9q3Pg6YyQoxIGqg==",
       "license": "MIT",
       "engines": {
@@ -17140,7 +16257,7 @@
     },
     "node_modules/unicode-emoji-modifier-base": {
       "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/unicode-emoji-modifier-base/-/unicode-emoji-modifier-base-1.0.0.tgz",
+      "resolved": "https://registry.facebook.net/unicode-emoji-modifier-base/-/unicode-emoji-modifier-base-1.0.0.tgz",
       "integrity": "sha512-yLSH4py7oFH3oG/9K+XWrz1pSi3dfUrWEnInbxMfArOfc1+33BlGPQtLsOYwvdMy11AwUBetYuaRxSPqgkq+8g==",
       "license": "MIT",
       "engines": {
@@ -17149,7 +16266,7 @@
     },
     "node_modules/unicode-match-property-ecmascript": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-2.0.0.tgz",
+      "resolved": "https://registry.facebook.net/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-2.0.0.tgz",
       "integrity": "sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q==",
       "license": "MIT",
       "dependencies": {
@@ -17161,18 +16278,18 @@
       }
     },
     "node_modules/unicode-match-property-value-ecmascript": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.2.0.tgz",
-      "integrity": "sha512-4IehN3V/+kkr5YeSSDDQG8QLqO26XpL2XP3GQtqwlT/QYSECAwFztxVHjlbh0+gjJ3XmNLS0zDsbgs9jWKExLg==",
+      "version": "2.2.1",
+      "resolved": "https://registry.facebook.net/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.2.1.tgz",
+      "integrity": "sha512-JQ84qTuMg4nVkx8ga4A16a1epI9H6uTXAknqxkGF/aFfRLw1xC/Bp24HNLaZhHSkWd3+84t8iXnp1J0kYcZHhg==",
       "license": "MIT",
       "engines": {
         "node": ">=4"
       }
     },
     "node_modules/unicode-property-aliases-ecmascript": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.1.0.tgz",
-      "integrity": "sha512-6t3foTQI9qne+OZoVQB/8x8rk2k1eVy1gRXhV3oFQ5T6R1dqQ1xtin3XqSlx3+ATBkliTaR/hHyJBm+LVPNM8w==",
+      "version": "2.2.0",
+      "resolved": "https://registry.facebook.net/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.2.0.tgz",
+      "integrity": "sha512-hpbDzxUY9BFwX+UeBnxv3Sh1q7HFxj48DTmXchNgRa46lO8uj3/1iEn3MiNUYTg1g9ctIqXCCERn8gYZhHC5lQ==",
       "license": "MIT",
       "engines": {
         "node": ">=4"
@@ -17180,7 +16297,7 @@
     },
     "node_modules/unified": {
       "version": "11.0.5",
-      "resolved": "https://registry.npmjs.org/unified/-/unified-11.0.5.tgz",
+      "resolved": "https://registry.facebook.net/unified/-/unified-11.0.5.tgz",
       "integrity": "sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA==",
       "license": "MIT",
       "dependencies": {
@@ -17197,9 +16314,21 @@
         "url": "https://opencollective.com/unified"
       }
     },
+    "node_modules/unified/node_modules/is-plain-obj": {
+      "version": "4.1.0",
+      "resolved": "https://registry.facebook.net/is-plain-obj/-/is-plain-obj-4.1.0.tgz",
+      "integrity": "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/unique-string": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/unique-string/-/unique-string-3.0.0.tgz",
+      "resolved": "https://registry.facebook.net/unique-string/-/unique-string-3.0.0.tgz",
       "integrity": "sha512-VGXBUVwxKMBUznyffQweQABPRRW1vHZAbadFZud4pLFAqRGvv/96vafgjWFqzourzr8YonlQiPgH0YCJfawoGQ==",
       "license": "MIT",
       "dependencies": {
@@ -17213,9 +16342,9 @@
       }
     },
     "node_modules/unist-util-is": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.0.tgz",
-      "integrity": "sha512-2qCTHimwdxLfz+YzdGfkqNlH0tLi9xjTnHddPmJwtIG9MGsdbutfTc4P+haPD7l7Cjxf/WZj+we5qfVPvvxfYw==",
+      "version": "6.0.1",
+      "resolved": "https://registry.facebook.net/unist-util-is/-/unist-util-is-6.0.1.tgz",
+      "integrity": "sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==",
       "license": "MIT",
       "dependencies": {
         "@types/unist": "^3.0.0"
@@ -17227,7 +16356,7 @@
     },
     "node_modules/unist-util-position": {
       "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-5.0.0.tgz",
+      "resolved": "https://registry.facebook.net/unist-util-position/-/unist-util-position-5.0.0.tgz",
       "integrity": "sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==",
       "license": "MIT",
       "dependencies": {
@@ -17240,7 +16369,7 @@
     },
     "node_modules/unist-util-position-from-estree": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/unist-util-position-from-estree/-/unist-util-position-from-estree-2.0.0.tgz",
+      "resolved": "https://registry.facebook.net/unist-util-position-from-estree/-/unist-util-position-from-estree-2.0.0.tgz",
       "integrity": "sha512-KaFVRjoqLyF6YXCbVLNad/eS4+OfPQQn2yOd7zF/h5T/CSL2v8NpN6a5TPvtbXthAGw5nG+PuTtq+DdIZr+cRQ==",
       "license": "MIT",
       "dependencies": {
@@ -17253,7 +16382,7 @@
     },
     "node_modules/unist-util-stringify-position": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz",
+      "resolved": "https://registry.facebook.net/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz",
       "integrity": "sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==",
       "license": "MIT",
       "dependencies": {
@@ -17265,9 +16394,9 @@
       }
     },
     "node_modules/unist-util-visit": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.0.0.tgz",
-      "integrity": "sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg==",
+      "version": "5.1.0",
+      "resolved": "https://registry.facebook.net/unist-util-visit/-/unist-util-visit-5.1.0.tgz",
+      "integrity": "sha512-m+vIdyeCOpdr/QeQCu2EzxX/ohgS8KbnPDgFni4dQsfSCtpz8UqDyY5GjRru8PDKuYn7Fq19j1CQ+nJSsGKOzg==",
       "license": "MIT",
       "dependencies": {
         "@types/unist": "^3.0.0",
@@ -17280,9 +16409,9 @@
       }
     },
     "node_modules/unist-util-visit-parents": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-6.0.1.tgz",
-      "integrity": "sha512-L/PqWzfTP9lzzEa6CKs0k2nARxTdZduw3zyh8d2NVBnsyvHjSX4TWse388YrrQKbvI8w20fGjGlhgT96WwKykw==",
+      "version": "6.0.2",
+      "resolved": "https://registry.facebook.net/unist-util-visit-parents/-/unist-util-visit-parents-6.0.2.tgz",
+      "integrity": "sha512-goh1s1TBrqSqukSc8wrjwWhL0hiJxgA8m4kFxGlQ+8FYQ3C/m11FcTs4YYem7V664AhHVvgoQLk890Ssdsr2IQ==",
       "license": "MIT",
       "dependencies": {
         "@types/unist": "^3.0.0",
@@ -17295,7 +16424,7 @@
     },
     "node_modules/universalify": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+      "resolved": "https://registry.facebook.net/universalify/-/universalify-2.0.1.tgz",
       "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
       "license": "MIT",
       "engines": {
@@ -17304,7 +16433,7 @@
     },
     "node_modules/unpipe": {
       "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "resolved": "https://registry.facebook.net/unpipe/-/unpipe-1.0.0.tgz",
       "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
       "license": "MIT",
       "engines": {
@@ -17312,9 +16441,9 @@
       }
     },
     "node_modules/update-browserslist-db": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.1.tgz",
-      "integrity": "sha512-R8UzCaa9Az+38REPiJ1tXlImTJXlVfgHZsglwBD/k6nj76ctsH1E3q4doGrukiLQd3sGQYu56r5+lo5r94l29A==",
+      "version": "1.2.3",
+      "resolved": "https://registry.facebook.net/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
       "funding": [
         {
           "type": "opencollective",
@@ -17332,7 +16461,7 @@
       "license": "MIT",
       "dependencies": {
         "escalade": "^3.2.0",
-        "picocolors": "^1.1.0"
+        "picocolors": "^1.1.1"
       },
       "bin": {
         "update-browserslist-db": "cli.js"
@@ -17343,7 +16472,7 @@
     },
     "node_modules/update-notifier": {
       "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/update-notifier/-/update-notifier-6.0.2.tgz",
+      "resolved": "https://registry.facebook.net/update-notifier/-/update-notifier-6.0.2.tgz",
       "integrity": "sha512-EDxhTEVPZZRLWYcJ4ZXjGFN0oP7qYvbXWzEgRm/Yql4dHX5wDbvh89YHP6PK1lzZJYrMtXUuZZz8XGK+U6U1og==",
       "license": "BSD-2-Clause",
       "dependencies": {
@@ -17371,7 +16500,7 @@
     },
     "node_modules/update-notifier/node_modules/boxen": {
       "version": "7.1.1",
-      "resolved": "https://registry.npmjs.org/boxen/-/boxen-7.1.1.tgz",
+      "resolved": "https://registry.facebook.net/boxen/-/boxen-7.1.1.tgz",
       "integrity": "sha512-2hCgjEmP8YLWQ130n2FerGv7rYpfBmnmp9Uy2Le1vge6X3gZIfSmEzP5QTDElFxcvVcXlEn8Aq6MU/PZygIOog==",
       "license": "MIT",
       "dependencies": {
@@ -17393,7 +16522,7 @@
     },
     "node_modules/update-notifier/node_modules/camelcase": {
       "version": "7.0.1",
-      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-7.0.1.tgz",
+      "resolved": "https://registry.facebook.net/camelcase/-/camelcase-7.0.1.tgz",
       "integrity": "sha512-xlx1yCK2Oc1APsPXDL2LdlNP6+uu8OCDdhOBSVT279M/S+y75O30C2VuD8T2ogdePBBl7PfPF4504tnLgX3zfw==",
       "license": "MIT",
       "engines": {
@@ -17404,9 +16533,9 @@
       }
     },
     "node_modules/update-notifier/node_modules/chalk": {
-      "version": "5.4.1",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.4.1.tgz",
-      "integrity": "sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w==",
+      "version": "5.6.2",
+      "resolved": "https://registry.facebook.net/chalk/-/chalk-5.6.2.tgz",
+      "integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==",
       "license": "MIT",
       "engines": {
         "node": "^12.17.0 || ^14.13 || >=16.0.0"
@@ -17415,9 +16544,21 @@
         "url": "https://github.com/chalk/chalk?sponsor=1"
       }
     },
+    "node_modules/update-notifier/node_modules/semver": {
+      "version": "7.7.4",
+      "resolved": "https://registry.facebook.net/semver/-/semver-7.7.4.tgz",
+      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/uri-js": {
       "version": "4.4.1",
-      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+      "resolved": "https://registry.facebook.net/uri-js/-/uri-js-4.4.1.tgz",
       "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
       "license": "BSD-2-Clause",
       "dependencies": {
@@ -17426,7 +16567,7 @@
     },
     "node_modules/url-loader": {
       "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/url-loader/-/url-loader-4.1.1.tgz",
+      "resolved": "https://registry.facebook.net/url-loader/-/url-loader-4.1.1.tgz",
       "integrity": "sha512-3BTV812+AVHHOJQO8O5MkWgZ5aosP7GnROJwvzLS9hWDj00lZ6Z0wNak423Lp9PBZN05N+Jk/N5Si8jRAlGyWA==",
       "license": "MIT",
       "dependencies": {
@@ -17452,9 +16593,9 @@
       }
     },
     "node_modules/url-loader/node_modules/ajv": {
-      "version": "6.12.6",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
-      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+      "version": "6.15.0",
+      "resolved": "https://registry.facebook.net/ajv/-/ajv-6.15.0.tgz",
+      "integrity": "sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==",
       "license": "MIT",
       "dependencies": {
         "fast-deep-equal": "^3.1.1",
@@ -17469,7 +16610,7 @@
     },
     "node_modules/url-loader/node_modules/ajv-keywords": {
       "version": "3.5.2",
-      "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz",
+      "resolved": "https://registry.facebook.net/ajv-keywords/-/ajv-keywords-3.5.2.tgz",
       "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==",
       "license": "MIT",
       "peerDependencies": {
@@ -17478,13 +16619,13 @@
     },
     "node_modules/url-loader/node_modules/json-schema-traverse": {
       "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "resolved": "https://registry.facebook.net/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
       "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
       "license": "MIT"
     },
     "node_modules/url-loader/node_modules/schema-utils": {
       "version": "3.3.0",
-      "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.3.0.tgz",
+      "resolved": "https://registry.facebook.net/schema-utils/-/schema-utils-3.3.0.tgz",
       "integrity": "sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==",
       "license": "MIT",
       "dependencies": {
@@ -17502,19 +16643,19 @@
     },
     "node_modules/util-deprecate": {
       "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "resolved": "https://registry.facebook.net/util-deprecate/-/util-deprecate-1.0.2.tgz",
       "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
       "license": "MIT"
     },
     "node_modules/utila": {
       "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/utila/-/utila-0.4.0.tgz",
+      "resolved": "https://registry.facebook.net/utila/-/utila-0.4.0.tgz",
       "integrity": "sha512-Z0DbgELS9/L/75wZbro8xAnT50pBVFQZ+hUEueGDU5FN51YSCYM+jdxsfCiHjwNP/4LCDD0i/graKpeBnOXKRA==",
       "license": "MIT"
     },
     "node_modules/utility-types": {
       "version": "3.11.0",
-      "resolved": "https://registry.npmjs.org/utility-types/-/utility-types-3.11.0.tgz",
+      "resolved": "https://registry.facebook.net/utility-types/-/utility-types-3.11.0.tgz",
       "integrity": "sha512-6Z7Ma2aVEWisaL6TvBCy7P8rm2LQoPv6dJ7ecIaIixHcwfbJ0x7mWdbcwlIM5IGQxPZSFYeqRCqlOOeKoJYMkw==",
       "license": "MIT",
       "engines": {
@@ -17523,7 +16664,7 @@
     },
     "node_modules/utils-merge": {
       "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
+      "resolved": "https://registry.facebook.net/utils-merge/-/utils-merge-1.0.1.tgz",
       "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==",
       "license": "MIT",
       "engines": {
@@ -17532,7 +16673,7 @@
     },
     "node_modules/uuid": {
       "version": "8.3.2",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
+      "resolved": "https://registry.facebook.net/uuid/-/uuid-8.3.2.tgz",
       "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==",
       "license": "MIT",
       "bin": {
@@ -17541,13 +16682,13 @@
     },
     "node_modules/value-equal": {
       "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/value-equal/-/value-equal-1.0.1.tgz",
+      "resolved": "https://registry.facebook.net/value-equal/-/value-equal-1.0.1.tgz",
       "integrity": "sha512-NOJ6JZCAWr0zlxZt+xqCHNTEKOsrks2HQd4MqhP1qy4z1SkbEP467eNx6TgDKXMvUOb+OENfJCZwM+16n7fRfw==",
       "license": "MIT"
     },
     "node_modules/vary": {
       "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "resolved": "https://registry.facebook.net/vary/-/vary-1.1.2.tgz",
       "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
       "license": "MIT",
       "engines": {
@@ -17556,7 +16697,7 @@
     },
     "node_modules/vfile": {
       "version": "6.0.3",
-      "resolved": "https://registry.npmjs.org/vfile/-/vfile-6.0.3.tgz",
+      "resolved": "https://registry.facebook.net/vfile/-/vfile-6.0.3.tgz",
       "integrity": "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==",
       "license": "MIT",
       "dependencies": {
@@ -17570,7 +16711,7 @@
     },
     "node_modules/vfile-location": {
       "version": "5.0.3",
-      "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-5.0.3.tgz",
+      "resolved": "https://registry.facebook.net/vfile-location/-/vfile-location-5.0.3.tgz",
       "integrity": "sha512-5yXvWDEgqeiYiBe1lbxYF7UMAIm/IcopxMHrMQDq3nvKcjPKIhZklUKL+AE7J7uApI4kwe2snsK+eI6UTj9EHg==",
       "license": "MIT",
       "dependencies": {
@@ -17583,9 +16724,9 @@
       }
     },
     "node_modules/vfile-message": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-4.0.2.tgz",
-      "integrity": "sha512-jRDZ1IMLttGj41KcZvlrYAaI3CfqpLpfpf+Mfig13viT6NKvRzWZ+lXz0Y5D60w6uJIBAOGq9mSHf0gktF0duw==",
+      "version": "4.0.3",
+      "resolved": "https://registry.facebook.net/vfile-message/-/vfile-message-4.0.3.tgz",
+      "integrity": "sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw==",
       "license": "MIT",
       "dependencies": {
         "@types/unist": "^3.0.0",
@@ -17597,9 +16738,9 @@
       }
     },
     "node_modules/watchpack": {
-      "version": "2.4.2",
-      "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.2.tgz",
-      "integrity": "sha512-TnbFSbcOCcDgjZ4piURLCbJ3nJhznVh9kw6F6iokjiFPl8ONxe9A6nMDVXDiNbrSfLILs6vB07F7wLBrwPYzJw==",
+      "version": "2.5.1",
+      "resolved": "https://registry.facebook.net/watchpack/-/watchpack-2.5.1.tgz",
+      "integrity": "sha512-Zn5uXdcFNIA1+1Ei5McRd+iRzfhENPCe7LeABkJtNulSxjma+l7ltNx55BWZkRlwRnpOgHqxnjyaDgJnNXnqzg==",
       "license": "MIT",
       "dependencies": {
         "glob-to-regexp": "^0.4.1",
@@ -17611,7 +16752,7 @@
     },
     "node_modules/wbuf": {
       "version": "1.7.3",
-      "resolved": "https://registry.npmjs.org/wbuf/-/wbuf-1.7.3.tgz",
+      "resolved": "https://registry.facebook.net/wbuf/-/wbuf-1.7.3.tgz",
       "integrity": "sha512-O84QOnr0icsbFGLS0O3bI5FswxzRr8/gHwWkDlQFskhSPryQXvrTMxjxGP4+iWYoauLoBvfDpkrOauZ+0iZpDA==",
       "license": "MIT",
       "dependencies": {
@@ -17620,7 +16761,7 @@
     },
     "node_modules/web-namespaces": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/web-namespaces/-/web-namespaces-2.0.1.tgz",
+      "resolved": "https://registry.facebook.net/web-namespaces/-/web-namespaces-2.0.1.tgz",
       "integrity": "sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ==",
       "license": "MIT",
       "funding": {
@@ -17629,34 +16770,35 @@
       }
     },
     "node_modules/webpack": {
-      "version": "5.97.1",
-      "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.97.1.tgz",
-      "integrity": "sha512-EksG6gFY3L1eFMROS/7Wzgrii5mBAFe4rIr3r2BTfo7bcc+DWwFZ4OJ/miOuHJO/A85HwyI4eQ0F6IKXesO7Fg==",
+      "version": "5.106.2",
+      "resolved": "https://registry.facebook.net/webpack/-/webpack-5.106.2.tgz",
+      "integrity": "sha512-wGN3qcrBQIFmQ/c0AiOAQBvrZ5lmY8vbbMv4Mxfgzqd/B6+9pXtLo73WuS1dSGXM5QYY3hZnIbvx+K1xxe6FyA==",
       "license": "MIT",
       "dependencies": {
         "@types/eslint-scope": "^3.7.7",
-        "@types/estree": "^1.0.6",
+        "@types/estree": "^1.0.8",
+        "@types/json-schema": "^7.0.15",
         "@webassemblyjs/ast": "^1.14.1",
         "@webassemblyjs/wasm-edit": "^1.14.1",
         "@webassemblyjs/wasm-parser": "^1.14.1",
-        "acorn": "^8.14.0",
-        "browserslist": "^4.24.0",
+        "acorn": "^8.16.0",
+        "acorn-import-phases": "^1.0.3",
+        "browserslist": "^4.28.1",
         "chrome-trace-event": "^1.0.2",
-        "enhanced-resolve": "^5.17.1",
-        "es-module-lexer": "^1.2.1",
+        "enhanced-resolve": "^5.20.0",
+        "es-module-lexer": "^2.0.0",
         "eslint-scope": "5.1.1",
         "events": "^3.2.0",
         "glob-to-regexp": "^0.4.1",
         "graceful-fs": "^4.2.11",
-        "json-parse-even-better-errors": "^2.3.1",
-        "loader-runner": "^4.2.0",
-        "mime-types": "^2.1.27",
+        "loader-runner": "^4.3.1",
+        "mime-db": "^1.54.0",
         "neo-async": "^2.6.2",
-        "schema-utils": "^3.2.0",
-        "tapable": "^2.1.1",
-        "terser-webpack-plugin": "^5.3.10",
-        "watchpack": "^2.4.1",
-        "webpack-sources": "^3.2.3"
+        "schema-utils": "^4.3.3",
+        "tapable": "^2.3.0",
+        "terser-webpack-plugin": "^5.3.17",
+        "watchpack": "^2.5.1",
+        "webpack-sources": "^3.3.4"
       },
       "bin": {
         "webpack": "bin/webpack.js"
@@ -17676,7 +16818,7 @@
     },
     "node_modules/webpack-bundle-analyzer": {
       "version": "4.10.2",
-      "resolved": "https://registry.npmjs.org/webpack-bundle-analyzer/-/webpack-bundle-analyzer-4.10.2.tgz",
+      "resolved": "https://registry.facebook.net/webpack-bundle-analyzer/-/webpack-bundle-analyzer-4.10.2.tgz",
       "integrity": "sha512-vJptkMm9pk5si4Bv922ZbKLV8UTT4zib4FPgXMhgzUny0bfDDkLXAVQs3ly3fS4/TN9ROFtb0NFrm04UXFE/Vw==",
       "license": "MIT",
       "dependencies": {
@@ -17702,7 +16844,7 @@
     },
     "node_modules/webpack-bundle-analyzer/node_modules/commander": {
       "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/commander/-/commander-7.2.0.tgz",
+      "resolved": "https://registry.facebook.net/commander/-/commander-7.2.0.tgz",
       "integrity": "sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==",
       "license": "MIT",
       "engines": {
@@ -17710,86 +16852,97 @@
       }
     },
     "node_modules/webpack-dev-middleware": {
-      "version": "5.3.4",
-      "resolved": "https://registry.npmjs.org/webpack-dev-middleware/-/webpack-dev-middleware-5.3.4.tgz",
-      "integrity": "sha512-BVdTqhhs+0IfoeAf7EoH5WE+exCmqGerHfDM0IL096Px60Tq2Mn9MAbnaGUe6HiMa41KMCYF19gyzZmBcq/o4Q==",
+      "version": "7.4.5",
+      "resolved": "https://registry.facebook.net/webpack-dev-middleware/-/webpack-dev-middleware-7.4.5.tgz",
+      "integrity": "sha512-uxQ6YqGdE4hgDKNf7hUiPXOdtkXvBJXrfEGYSx7P7LC8hnUYGK70X6xQXUvXeNyBDDcsiQXpG2m3G9vxowaEuA==",
       "license": "MIT",
       "dependencies": {
         "colorette": "^2.0.10",
-        "memfs": "^3.4.3",
-        "mime-types": "^2.1.31",
+        "memfs": "^4.43.1",
+        "mime-types": "^3.0.1",
+        "on-finished": "^2.4.1",
         "range-parser": "^1.2.1",
         "schema-utils": "^4.0.0"
       },
       "engines": {
-        "node": ">= 12.13.0"
+        "node": ">= 18.12.0"
       },
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/webpack"
       },
       "peerDependencies": {
-        "webpack": "^4.0.0 || ^5.0.0"
+        "webpack": "^5.0.0"
+      },
+      "peerDependenciesMeta": {
+        "webpack": {
+          "optional": true
+        }
       }
     },
-    "node_modules/webpack-dev-middleware/node_modules/range-parser": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
-      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+    "node_modules/webpack-dev-middleware/node_modules/mime-types": {
+      "version": "3.0.2",
+      "resolved": "https://registry.facebook.net/mime-types/-/mime-types-3.0.2.tgz",
+      "integrity": "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==",
       "license": "MIT",
+      "dependencies": {
+        "mime-db": "^1.54.0"
+      },
       "engines": {
-        "node": ">= 0.6"
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
       }
     },
     "node_modules/webpack-dev-server": {
-      "version": "4.15.2",
-      "resolved": "https://registry.npmjs.org/webpack-dev-server/-/webpack-dev-server-4.15.2.tgz",
-      "integrity": "sha512-0XavAZbNJ5sDrCbkpWL8mia0o5WPOd2YGtxrEiZkBK9FjLppIUK2TgxK6qGD2P3hUXTJNNPVibrerKcx5WkR1g==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/bonjour": "^3.5.9",
-        "@types/connect-history-api-fallback": "^1.3.5",
-        "@types/express": "^4.17.13",
-        "@types/serve-index": "^1.9.1",
-        "@types/serve-static": "^1.13.10",
-        "@types/sockjs": "^0.3.33",
-        "@types/ws": "^8.5.5",
+      "version": "5.2.3",
+      "resolved": "https://registry.facebook.net/webpack-dev-server/-/webpack-dev-server-5.2.3.tgz",
+      "integrity": "sha512-9Gyu2F7+bg4Vv+pjbovuYDhHX+mqdqITykfzdM9UyKqKHlsE5aAjRhR+oOEfXW5vBeu8tarzlJFIZva4ZjAdrQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/bonjour": "^3.5.13",
+        "@types/connect-history-api-fallback": "^1.5.4",
+        "@types/express": "^4.17.25",
+        "@types/express-serve-static-core": "^4.17.21",
+        "@types/serve-index": "^1.9.4",
+        "@types/serve-static": "^1.15.5",
+        "@types/sockjs": "^0.3.36",
+        "@types/ws": "^8.5.10",
         "ansi-html-community": "^0.0.8",
-        "bonjour-service": "^1.0.11",
-        "chokidar": "^3.5.3",
+        "bonjour-service": "^1.2.1",
+        "chokidar": "^3.6.0",
         "colorette": "^2.0.10",
-        "compression": "^1.7.4",
+        "compression": "^1.8.1",
         "connect-history-api-fallback": "^2.0.0",
-        "default-gateway": "^6.0.3",
-        "express": "^4.17.3",
+        "express": "^4.22.1",
         "graceful-fs": "^4.2.6",
-        "html-entities": "^2.3.2",
-        "http-proxy-middleware": "^2.0.3",
-        "ipaddr.js": "^2.0.1",
-        "launch-editor": "^2.6.0",
-        "open": "^8.0.9",
-        "p-retry": "^4.5.0",
-        "rimraf": "^3.0.2",
-        "schema-utils": "^4.0.0",
-        "selfsigned": "^2.1.1",
+        "http-proxy-middleware": "^2.0.9",
+        "ipaddr.js": "^2.1.0",
+        "launch-editor": "^2.6.1",
+        "open": "^10.0.3",
+        "p-retry": "^6.2.0",
+        "schema-utils": "^4.2.0",
+        "selfsigned": "^5.5.0",
         "serve-index": "^1.9.1",
         "sockjs": "^0.3.24",
         "spdy": "^4.0.2",
-        "webpack-dev-middleware": "^5.3.4",
-        "ws": "^8.13.0"
+        "webpack-dev-middleware": "^7.4.2",
+        "ws": "^8.18.0"
       },
       "bin": {
         "webpack-dev-server": "bin/webpack-dev-server.js"
       },
       "engines": {
-        "node": ">= 12.13.0"
+        "node": ">= 18.12.0"
       },
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/webpack"
       },
       "peerDependencies": {
-        "webpack": "^4.37.0 || ^5.0.0"
+        "webpack": "^5.0.0"
       },
       "peerDependenciesMeta": {
         "webpack": {
@@ -17800,10 +16953,40 @@
         }
       }
     },
+    "node_modules/webpack-dev-server/node_modules/define-lazy-prop": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz",
+      "integrity": "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/webpack-dev-server/node_modules/open": {
+      "version": "10.2.0",
+      "resolved": "https://registry.facebook.net/open/-/open-10.2.0.tgz",
+      "integrity": "sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA==",
+      "license": "MIT",
+      "dependencies": {
+        "default-browser": "^5.2.1",
+        "define-lazy-prop": "^3.0.0",
+        "is-inside-container": "^1.0.0",
+        "wsl-utils": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/webpack-dev-server/node_modules/ws": {
-      "version": "8.18.0",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.0.tgz",
-      "integrity": "sha512-8VbfWfHLbbwu3+N6OKsOMpBdT4kXPDDB9cJk2bJ6mh9ucxdlnNvH1e+roYkKmN9Nxw2yjz7VzeO9oOz2zJ04Pw==",
+      "version": "8.20.0",
+      "resolved": "https://registry.facebook.net/ws/-/ws-8.20.0.tgz",
+      "integrity": "sha512-sAt8BhgNbzCtgGbt2OxmpuryO63ZoDk/sqaB/znQm94T4fCEsy/yV+7CdC1kJhOU9lboAEU7R3kquuycDoibVA==",
       "license": "MIT",
       "engines": {
         "node": ">=10.0.0"
@@ -17823,7 +17006,7 @@
     },
     "node_modules/webpack-merge": {
       "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/webpack-merge/-/webpack-merge-6.0.1.tgz",
+      "resolved": "https://registry.facebook.net/webpack-merge/-/webpack-merge-6.0.1.tgz",
       "integrity": "sha512-hXXvrjtx2PLYx4qruKl+kyRSLc52V+cCvMxRjmKwoA+CBbbF5GfIBtR6kCvl0fYGqTUPKB+1ktVmTHqMOzgCBg==",
       "license": "MIT",
       "dependencies": {
@@ -17836,349 +17019,10696 @@
       }
     },
     "node_modules/webpack-sources": {
-      "version": "3.2.3",
-      "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.2.3.tgz",
-      "integrity": "sha512-/DyMEOrDgLKKIG0fmvtz+4dUX/3Ghozwgm6iPp8KRhvn+eQf9+Q7GWxVNMk3+uCPWfdXYC4ExGBckIXdFEfH1w==",
+      "version": "3.4.0",
+      "resolved": "https://registry.facebook.net/webpack-sources/-/webpack-sources-3.4.0.tgz",
+      "integrity": "sha512-gHwIe1cgBvvfLeu1Yz/dcFpmHfKDVxxyqI+kzqmuxZED81z2ChxpyqPaWcNqigPywhaEke7AjSGga+kxY55gjQ==",
       "license": "MIT",
       "engines": {
         "node": ">=10.13.0"
       }
     },
-    "node_modules/webpack/node_modules/ajv": {
-      "version": "6.12.6",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
-      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+    "node_modules/websocket-driver": {
+      "version": "0.7.4",
+      "resolved": "https://registry.facebook.net/websocket-driver/-/websocket-driver-0.7.4.tgz",
+      "integrity": "sha512-b17KeDIQVjvb0ssuSDF2cYXSg2iztliJ4B9WdsuB6J952qCPKmnVq4DyW5motImXHDC1cBT/1UezrJVsKw5zjg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "http-parser-js": ">=0.5.1",
+        "safe-buffer": ">=5.1.0",
+        "websocket-extensions": ">=0.1.1"
+      },
+      "engines": {
+        "node": ">=0.8.0"
+      }
+    },
+    "node_modules/websocket-extensions": {
+      "version": "0.1.4",
+      "resolved": "https://registry.facebook.net/websocket-extensions/-/websocket-extensions-0.1.4.tgz",
+      "integrity": "sha512-OqedPIGOfsDlo31UNwYbCFMSaO9m9G/0faIHj5/dZFDMFqPTcx6UwqyOy3COEaEOg/9VsGIpdqn62W5KhoKSpg==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=0.8.0"
+      }
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.facebook.net/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/widest-line": {
+      "version": "4.0.1",
+      "resolved": "https://registry.facebook.net/widest-line/-/widest-line-4.0.1.tgz",
+      "integrity": "sha512-o0cyEG0e8GPzT4iGHphIOh0cJOV8fivsXxddQasHPHfoZf1ZexrfeA21w2NaEN1RHE+fXlfISmOE8R9N3u3Qig==",
       "license": "MIT",
       "dependencies": {
-        "fast-deep-equal": "^3.1.1",
-        "fast-json-stable-stringify": "^2.0.0",
-        "json-schema-traverse": "^0.4.1",
-        "uri-js": "^4.2.2"
+        "string-width": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=12"
       },
       "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/epoberezkin"
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/webpack/node_modules/ajv-keywords": {
-      "version": "3.5.2",
-      "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz",
-      "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==",
+    "node_modules/wildcard": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/wildcard/-/wildcard-2.0.1.tgz",
+      "integrity": "sha512-CC1bOL87PIWSBhDcTrdeLo6eGT7mCFtrg0uIJtqJUFyK+eJnzl8A1niH56uu7KMa5XFrtiV+AQuHO3n7DsHnLQ==",
+      "license": "MIT"
+    },
+    "node_modules/wrap-ansi": {
+      "version": "8.1.0",
+      "resolved": "https://registry.facebook.net/wrap-ansi/-/wrap-ansi-8.1.0.tgz",
+      "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^6.1.0",
+        "string-width": "^5.0.1",
+        "strip-ansi": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/wrap-ansi/node_modules/ansi-regex": {
+      "version": "6.2.2",
+      "resolved": "https://registry.facebook.net/ansi-regex/-/ansi-regex-6.2.2.tgz",
+      "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
+      }
+    },
+    "node_modules/wrap-ansi/node_modules/ansi-styles": {
+      "version": "6.2.3",
+      "resolved": "https://registry.facebook.net/ansi-styles/-/ansi-styles-6.2.3.tgz",
+      "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/wrap-ansi/node_modules/strip-ansi": {
+      "version": "7.2.0",
+      "resolved": "https://registry.facebook.net/strip-ansi/-/strip-ansi-7.2.0.tgz",
+      "integrity": "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^6.2.2"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
+      }
+    },
+    "node_modules/write-file-atomic": {
+      "version": "3.0.3",
+      "resolved": "https://registry.facebook.net/write-file-atomic/-/write-file-atomic-3.0.3.tgz",
+      "integrity": "sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q==",
+      "license": "ISC",
+      "dependencies": {
+        "imurmurhash": "^0.1.4",
+        "is-typedarray": "^1.0.0",
+        "signal-exit": "^3.0.2",
+        "typedarray-to-buffer": "^3.1.5"
+      }
+    },
+    "node_modules/ws": {
+      "version": "7.5.10",
+      "resolved": "https://registry.facebook.net/ws/-/ws-7.5.10.tgz",
+      "integrity": "sha512-+dbF1tHwZpXcbOJdVOkzLDxZP1ailvSxM6ZweXTegylPny803bFhA+vqBYw4s31NSAk4S2Qz+AKXK9a4wkdjcQ==",
       "license": "MIT",
+      "engines": {
+        "node": ">=8.3.0"
+      },
       "peerDependencies": {
-        "ajv": "^6.9.1"
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": "^5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
       }
     },
-    "node_modules/webpack/node_modules/json-schema-traverse": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
-      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
-      "license": "MIT"
+    "node_modules/wsl-utils": {
+      "version": "0.1.0",
+      "resolved": "https://registry.facebook.net/wsl-utils/-/wsl-utils-0.1.0.tgz",
+      "integrity": "sha512-h3Fbisa2nKGPxCpm89Hk33lBLsnaGBvctQopaBSOW/uIs6FTe1ATyAnKFJrzVs9vpGdsTe73WF3V4lIsk4Gacw==",
+      "license": "MIT",
+      "dependencies": {
+        "is-wsl": "^3.1.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
     },
-    "node_modules/webpack/node_modules/schema-utils": {
-      "version": "3.3.0",
-      "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.3.0.tgz",
-      "integrity": "sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==",
+    "node_modules/wsl-utils/node_modules/is-wsl": {
+      "version": "3.1.1",
+      "resolved": "https://registry.facebook.net/is-wsl/-/is-wsl-3.1.1.tgz",
+      "integrity": "sha512-e6rvdUCiQCAuumZslxRJWR/Doq4VpPR82kqclvcS0efgt430SlGIk05vdCN58+VrzgtIcfNODjozVielycD4Sw==",
       "license": "MIT",
       "dependencies": {
-        "@types/json-schema": "^7.0.8",
-        "ajv": "^6.12.5",
-        "ajv-keywords": "^3.5.2"
+        "is-inside-container": "^1.0.0"
       },
       "engines": {
-        "node": ">= 10.13.0"
+        "node": ">=16"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/webpack"
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/xdg-basedir": {
+      "version": "5.1.0",
+      "resolved": "https://registry.facebook.net/xdg-basedir/-/xdg-basedir-5.1.0.tgz",
+      "integrity": "sha512-GCPAHLvrIH13+c0SuacwvRYj2SxJXQ4kaVTT5xgL3kPrz56XxkF21IGhjSE1+W0aw7gpBWRGXLCPnPby6lSpmQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/xml-js": {
+      "version": "1.6.11",
+      "resolved": "https://registry.facebook.net/xml-js/-/xml-js-1.6.11.tgz",
+      "integrity": "sha512-7rVi2KMfwfWFl+GpPg6m80IVMWXLRjO+PxTq7V2CDhoGak0wzYzFgUY2m4XJ47OGdXd8eLE8EmwfAmdjw7lC1g==",
+      "license": "MIT",
+      "dependencies": {
+        "sax": "^1.2.4"
+      },
+      "bin": {
+        "xml-js": "bin/cli.js"
+      }
+    },
+    "node_modules/yallist": {
+      "version": "3.1.1",
+      "resolved": "https://registry.facebook.net/yallist/-/yallist-3.1.1.tgz",
+      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+      "license": "ISC"
+    },
+    "node_modules/yocto-queue": {
+      "version": "1.2.2",
+      "resolved": "https://registry.facebook.net/yocto-queue/-/yocto-queue-1.2.2.tgz",
+      "integrity": "sha512-4LCcse/U2MHZ63HAJVE+v71o7yOdIe4cZ70Wpf8D/IyjDKYQLV5GD46B+hSTjJsvV5PztjvHoU580EftxjDZFQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/zwitch": {
+      "version": "2.0.4",
+      "resolved": "https://registry.facebook.net/zwitch/-/zwitch-2.0.4.tgz",
+      "integrity": "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    }
+  },
+  "dependencies": {
+    "@algolia/abtesting": {
+      "version": "1.17.0",
+      "resolved": "https://registry.facebook.net/@algolia/abtesting/-/abtesting-1.17.0.tgz",
+      "integrity": "sha512-nuhHZdTiCtRzJEe9VSNzyqE9cOQMt01UWBzymFnjbgwrxxZpbGHQde6Oa/y9zyspTCjbUtb7Q5HQek1CLiLyeg==",
+      "requires": {
+        "@algolia/client-common": "5.51.0",
+        "@algolia/requester-browser-xhr": "5.51.0",
+        "@algolia/requester-fetch": "5.51.0",
+        "@algolia/requester-node-http": "5.51.0"
+      }
+    },
+    "@algolia/autocomplete-core": {
+      "version": "1.19.8",
+      "resolved": "https://registry.facebook.net/@algolia/autocomplete-core/-/autocomplete-core-1.19.8.tgz",
+      "integrity": "sha512-3YEorYg44niXcm7gkft3nXYItHd44e8tmh4D33CTszPgP0QWkaLEaFywiNyJBo7UL/mqObA/G9RYuU7R8tN1IA==",
+      "requires": {
+        "@algolia/autocomplete-plugin-algolia-insights": "1.19.8",
+        "@algolia/autocomplete-shared": "1.19.8"
+      },
+      "dependencies": {
+        "@algolia/autocomplete-shared": {
+          "version": "1.19.8",
+          "resolved": "https://registry.facebook.net/@algolia/autocomplete-shared/-/autocomplete-shared-1.19.8.tgz",
+          "integrity": "sha512-h5hf2t8ejF6vlOgvLaZzQbWs5SyH2z4PAWygNAvvD/2RI29hdQ54ldUGwqVuj9Srs+n8XUKTPUqb7fvhBhQrnQ==",
+          "requires": {}
+        }
+      }
+    },
+    "@algolia/autocomplete-plugin-algolia-insights": {
+      "version": "1.19.8",
+      "resolved": "https://registry.facebook.net/@algolia/autocomplete-plugin-algolia-insights/-/autocomplete-plugin-algolia-insights-1.19.8.tgz",
+      "integrity": "sha512-ZvJWO8ZZJDpc1LNM2TTBdmQsZBLMR4rU5iNR2OYvEeFBiaf/0ESnRSSLQbryarJY4SVxtoz6A2ZtDMNM+iQEAA==",
+      "requires": {
+        "@algolia/autocomplete-shared": "1.19.8"
+      },
+      "dependencies": {
+        "@algolia/autocomplete-shared": {
+          "version": "1.19.8",
+          "resolved": "https://registry.facebook.net/@algolia/autocomplete-shared/-/autocomplete-shared-1.19.8.tgz",
+          "integrity": "sha512-h5hf2t8ejF6vlOgvLaZzQbWs5SyH2z4PAWygNAvvD/2RI29hdQ54ldUGwqVuj9Srs+n8XUKTPUqb7fvhBhQrnQ==",
+          "requires": {}
+        }
+      }
+    },
+    "@algolia/autocomplete-shared": {
+      "version": "1.19.2",
+      "resolved": "https://registry.facebook.net/@algolia/autocomplete-shared/-/autocomplete-shared-1.19.2.tgz",
+      "integrity": "sha512-jEazxZTVD2nLrC+wYlVHQgpBoBB5KPStrJxLzsIFl6Kqd1AlG9sIAGl39V5tECLpIQzB3Qa2T6ZPJ1ChkwMK/w==",
+      "requires": {}
+    },
+    "@algolia/client-abtesting": {
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/client-abtesting/-/client-abtesting-5.51.0.tgz",
+      "integrity": "sha512-PKrKlIla1U2J7mFcIQn6N3pWP4oySmkxShnbbDsj/H7818gKbET5KsUwsVoNjWIxHKTJMCTcQ7ekAJ8Ea23NMg==",
+      "requires": {
+        "@algolia/client-common": "5.51.0",
+        "@algolia/requester-browser-xhr": "5.51.0",
+        "@algolia/requester-fetch": "5.51.0",
+        "@algolia/requester-node-http": "5.51.0"
+      }
+    },
+    "@algolia/client-analytics": {
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/client-analytics/-/client-analytics-5.51.0.tgz",
+      "integrity": "sha512-U+HCY1K16Km91pIRL1kN6bW6BbGFAF/WhkRSCx4wyl1aFpbrlhSFQs/dAwWbmyBiHWwVWhl7stWHQ1pum5EfMw==",
+      "requires": {
+        "@algolia/client-common": "5.51.0",
+        "@algolia/requester-browser-xhr": "5.51.0",
+        "@algolia/requester-fetch": "5.51.0",
+        "@algolia/requester-node-http": "5.51.0"
+      }
+    },
+    "@algolia/client-common": {
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/client-common/-/client-common-5.51.0.tgz",
+      "integrity": "sha512-YPJ3dEuZLCRp846Az94t6Z2gwSNRazP+SmBco7p6SCa4fYrtIE820PDXYZshbNrj2Z8Qfbmv7BQ1Lecl5L3G/w=="
+    },
+    "@algolia/client-insights": {
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/client-insights/-/client-insights-5.51.0.tgz",
+      "integrity": "sha512-/gEwLlR7fQ7YjOW+ADRZ0NxLDtpTC61FSzlZ01Gdl1kTJfU0Rq3Y/TYqwxGxlQGcUiXtGzrpjxXWh3Y0TZD6NA==",
+      "requires": {
+        "@algolia/client-common": "5.51.0",
+        "@algolia/requester-browser-xhr": "5.51.0",
+        "@algolia/requester-fetch": "5.51.0",
+        "@algolia/requester-node-http": "5.51.0"
+      }
+    },
+    "@algolia/client-personalization": {
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/client-personalization/-/client-personalization-5.51.0.tgz",
+      "integrity": "sha512-nRwUN1Y2cKyOAFZyIBagkEfZSIhP05nWhT4Rjwl84lcjECssYggftrAODrZ4leakXxSGjhxs/AdaAFEIBqwVFA==",
+      "requires": {
+        "@algolia/client-common": "5.51.0",
+        "@algolia/requester-browser-xhr": "5.51.0",
+        "@algolia/requester-fetch": "5.51.0",
+        "@algolia/requester-node-http": "5.51.0"
+      }
+    },
+    "@algolia/client-query-suggestions": {
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/client-query-suggestions/-/client-query-suggestions-5.51.0.tgz",
+      "integrity": "sha512-pybzYCG7VoQKppo+z5iZOKpW8XqtFxhsAIRgEaNboCnfypKukiBHJAwB+pmr7vMZXBsOHwklGYWwCG82e8qshA==",
+      "requires": {
+        "@algolia/client-common": "5.51.0",
+        "@algolia/requester-browser-xhr": "5.51.0",
+        "@algolia/requester-fetch": "5.51.0",
+        "@algolia/requester-node-http": "5.51.0"
+      }
+    },
+    "@algolia/client-search": {
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/client-search/-/client-search-5.51.0.tgz",
+      "integrity": "sha512-DWVIlj6RqcvdhwP0gBU9OpOQPnHdcAk9jlT+z8rsNb2+liWv4eUlfQZ7saGBraFsnygEHD3PtdppIHvqwBAb5w==",
+      "requires": {
+        "@algolia/client-common": "5.51.0",
+        "@algolia/requester-browser-xhr": "5.51.0",
+        "@algolia/requester-fetch": "5.51.0",
+        "@algolia/requester-node-http": "5.51.0"
+      }
+    },
+    "@algolia/events": {
+      "version": "4.0.1",
+      "resolved": "https://registry.facebook.net/@algolia/events/-/events-4.0.1.tgz",
+      "integrity": "sha512-FQzvOCgoFXAbf5Y6mYozw2aj5KCJoA3m4heImceldzPSMbdyS4atVjJzXKMsfX3wnZTFYwkkt8/z8UesLHlSBQ=="
+    },
+    "@algolia/ingestion": {
+      "version": "1.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/ingestion/-/ingestion-1.51.0.tgz",
+      "integrity": "sha512-bA25s12iUDJi/X8M7tWlPRT8GeOhls/yDbdoUqinz27lNqsOlcM1UrAxIKdIZ6lm3sXit+ewPIz1pS2x6rXu8g==",
+      "requires": {
+        "@algolia/client-common": "5.51.0",
+        "@algolia/requester-browser-xhr": "5.51.0",
+        "@algolia/requester-fetch": "5.51.0",
+        "@algolia/requester-node-http": "5.51.0"
+      }
+    },
+    "@algolia/monitoring": {
+      "version": "1.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/monitoring/-/monitoring-1.51.0.tgz",
+      "integrity": "sha512-zj+RcE5e0NE0/ew6oEOTgOplPHry+w2oi7h0Y87lhdq4E0d7xLS31KVB8kKfCGkrG7AYtZvrcyvLOKS5d0no4Q==",
+      "requires": {
+        "@algolia/client-common": "5.51.0",
+        "@algolia/requester-browser-xhr": "5.51.0",
+        "@algolia/requester-fetch": "5.51.0",
+        "@algolia/requester-node-http": "5.51.0"
+      }
+    },
+    "@algolia/recommend": {
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/recommend/-/recommend-5.51.0.tgz",
+      "integrity": "sha512-/HDgccfye1Rq3bPxaSCsvSEBHzSMmtpM9ZRGRtAuC62Cv+ql/76IWnxjGTDXtqIJ+/j7ZlFYAzq9fkp95wF2SQ==",
+      "requires": {
+        "@algolia/client-common": "5.51.0",
+        "@algolia/requester-browser-xhr": "5.51.0",
+        "@algolia/requester-fetch": "5.51.0",
+        "@algolia/requester-node-http": "5.51.0"
+      }
+    },
+    "@algolia/requester-browser-xhr": {
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/requester-browser-xhr/-/requester-browser-xhr-5.51.0.tgz",
+      "integrity": "sha512-nJdW+WBwGlXWMJbxxB7/AJPvNq0lLJSudXmIQCJbmH8jsOXQhRpAtoCD4ceLyJKv3ze9JbQu4Gqu5JDLckuFcw==",
+      "requires": {
+        "@algolia/client-common": "5.51.0"
+      }
+    },
+    "@algolia/requester-fetch": {
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/requester-fetch/-/requester-fetch-5.51.0.tgz",
+      "integrity": "sha512-bsBgRI/1h1mjS3eCyfGau78yGZVmiDLmT1aU6dMnk75/T0SgKqnSKNpQ53xKoDYVChGDcNnpHXWpoUSo8MH1+w==",
+      "requires": {
+        "@algolia/client-common": "5.51.0"
+      }
+    },
+    "@algolia/requester-node-http": {
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/@algolia/requester-node-http/-/requester-node-http-5.51.0.tgz",
+      "integrity": "sha512-zPrIDVPpmKWgrjmWOqpqrhqAhNjvVkjoj+mqw2NBPxEOuKNzP0H+Qz5NJLLTOepBVj1UFedFaF3AUgxLsB9ukQ==",
+      "requires": {
+        "@algolia/client-common": "5.51.0"
+      }
+    },
+    "@babel/code-frame": {
+      "version": "7.29.0",
+      "resolved": "https://registry.facebook.net/@babel/code-frame/-/code-frame-7.29.0.tgz",
+      "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==",
+      "requires": {
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      }
+    },
+    "@babel/compat-data": {
+      "version": "7.29.0",
+      "resolved": "https://registry.facebook.net/@babel/compat-data/-/compat-data-7.29.0.tgz",
+      "integrity": "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg=="
+    },
+    "@babel/core": {
+      "version": "7.29.0",
+      "resolved": "https://registry.facebook.net/@babel/core/-/core-7.29.0.tgz",
+      "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==",
+      "requires": {
+        "@babel/code-frame": "^7.29.0",
+        "@babel/generator": "^7.29.0",
+        "@babel/helper-compilation-targets": "^7.28.6",
+        "@babel/helper-module-transforms": "^7.28.6",
+        "@babel/helpers": "^7.28.6",
+        "@babel/parser": "^7.29.0",
+        "@babel/template": "^7.28.6",
+        "@babel/traverse": "^7.29.0",
+        "@babel/types": "^7.29.0",
+        "@jridgewell/remapping": "^2.3.5",
+        "convert-source-map": "^2.0.0",
+        "debug": "^4.1.0",
+        "gensync": "^1.0.0-beta.2",
+        "json5": "^2.2.3",
+        "semver": "^6.3.1"
+      }
+    },
+    "@babel/generator": {
+      "version": "7.29.1",
+      "resolved": "https://registry.facebook.net/@babel/generator/-/generator-7.29.1.tgz",
+      "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==",
+      "requires": {
+        "@babel/parser": "^7.29.0",
+        "@babel/types": "^7.29.0",
+        "@jridgewell/gen-mapping": "^0.3.12",
+        "@jridgewell/trace-mapping": "^0.3.28",
+        "jsesc": "^3.0.2"
+      }
+    },
+    "@babel/helper-annotate-as-pure": {
+      "version": "7.27.3",
+      "resolved": "https://registry.facebook.net/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.27.3.tgz",
+      "integrity": "sha512-fXSwMQqitTGeHLBC08Eq5yXz2m37E4pJX1qAU1+2cNedz/ifv/bVXft90VeSav5nFO61EcNgwr0aJxbyPaWBPg==",
+      "requires": {
+        "@babel/types": "^7.27.3"
+      }
+    },
+    "@babel/helper-compilation-targets": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz",
+      "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==",
+      "requires": {
+        "@babel/compat-data": "^7.28.6",
+        "@babel/helper-validator-option": "^7.27.1",
+        "browserslist": "^4.24.0",
+        "lru-cache": "^5.1.1",
+        "semver": "^6.3.1"
+      }
+    },
+    "@babel/helper-create-class-features-plugin": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.28.6.tgz",
+      "integrity": "sha512-dTOdvsjnG3xNT9Y0AUg1wAl38y+4Rl4sf9caSQZOXdNqVn+H+HbbJ4IyyHaIqNR6SW9oJpA/RuRjsjCw2IdIow==",
+      "requires": {
+        "@babel/helper-annotate-as-pure": "^7.27.3",
+        "@babel/helper-member-expression-to-functions": "^7.28.5",
+        "@babel/helper-optimise-call-expression": "^7.27.1",
+        "@babel/helper-replace-supers": "^7.28.6",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1",
+        "@babel/traverse": "^7.28.6",
+        "semver": "^6.3.1"
+      }
+    },
+    "@babel/helper-create-regexp-features-plugin": {
+      "version": "7.28.5",
+      "resolved": "https://registry.facebook.net/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.28.5.tgz",
+      "integrity": "sha512-N1EhvLtHzOvj7QQOUCCS3NrPJP8c5W6ZXCHDn7Yialuy1iu4r5EmIYkXlKNqT99Ciw+W0mDqWoR6HWMZlFP3hw==",
+      "requires": {
+        "@babel/helper-annotate-as-pure": "^7.27.3",
+        "regexpu-core": "^6.3.1",
+        "semver": "^6.3.1"
+      }
+    },
+    "@babel/helper-define-polyfill-provider": {
+      "version": "0.6.8",
+      "resolved": "https://registry.facebook.net/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.6.8.tgz",
+      "integrity": "sha512-47UwBLPpQi1NoWzLuHNjRoHlYXMwIJoBf7MFou6viC/sIHWYygpvr0B6IAyh5sBdA2nr2LPIRww8lfaUVQINBA==",
+      "requires": {
+        "@babel/helper-compilation-targets": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "debug": "^4.4.3",
+        "lodash.debounce": "^4.0.8",
+        "resolve": "^1.22.11"
+      }
+    },
+    "@babel/helper-globals": {
+      "version": "7.28.0",
+      "resolved": "https://registry.facebook.net/@babel/helper-globals/-/helper-globals-7.28.0.tgz",
+      "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw=="
+    },
+    "@babel/helper-member-expression-to-functions": {
+      "version": "7.28.5",
+      "resolved": "https://registry.facebook.net/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.28.5.tgz",
+      "integrity": "sha512-cwM7SBRZcPCLgl8a7cY0soT1SptSzAlMH39vwiRpOQkJlh53r5hdHwLSCZpQdVLT39sZt+CRpNwYG4Y2v77atg==",
+      "requires": {
+        "@babel/traverse": "^7.28.5",
+        "@babel/types": "^7.28.5"
+      }
+    },
+    "@babel/helper-module-imports": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz",
+      "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==",
+      "requires": {
+        "@babel/traverse": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      }
+    },
+    "@babel/helper-module-transforms": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz",
+      "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==",
+      "requires": {
+        "@babel/helper-module-imports": "^7.28.6",
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "@babel/traverse": "^7.28.6"
+      }
+    },
+    "@babel/helper-optimise-call-expression": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.27.1.tgz",
+      "integrity": "sha512-URMGH08NzYFhubNSGJrpUEphGKQwMQYBySzat5cAByY1/YgIRkULnIy3tAMeszlL/so2HbeilYloUmSpd7GdVw==",
+      "requires": {
+        "@babel/types": "^7.27.1"
+      }
+    },
+    "@babel/helper-plugin-utils": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz",
+      "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug=="
+    },
+    "@babel/helper-remap-async-to-generator": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.27.1.tgz",
+      "integrity": "sha512-7fiA521aVw8lSPeI4ZOD3vRFkoqkJcS+z4hFo82bFSH/2tNd6eJ5qCVMS5OzDmZh/kaHQeBaeyxK6wljcPtveA==",
+      "requires": {
+        "@babel/helper-annotate-as-pure": "^7.27.1",
+        "@babel/helper-wrap-function": "^7.27.1",
+        "@babel/traverse": "^7.27.1"
+      }
+    },
+    "@babel/helper-replace-supers": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/helper-replace-supers/-/helper-replace-supers-7.28.6.tgz",
+      "integrity": "sha512-mq8e+laIk94/yFec3DxSjCRD2Z0TAjhVbEJY3UQrlwVo15Lmt7C2wAUbK4bjnTs4APkwsYLTahXRraQXhb1WCg==",
+      "requires": {
+        "@babel/helper-member-expression-to-functions": "^7.28.5",
+        "@babel/helper-optimise-call-expression": "^7.27.1",
+        "@babel/traverse": "^7.28.6"
+      }
+    },
+    "@babel/helper-skip-transparent-expression-wrappers": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.27.1.tgz",
+      "integrity": "sha512-Tub4ZKEXqbPjXgWLl2+3JpQAYBJ8+ikpQ2Ocj/q/r0LwE3UhENh7EUabyHjz2kCEsrRY83ew2DQdHluuiDQFzg==",
+      "requires": {
+        "@babel/traverse": "^7.27.1",
+        "@babel/types": "^7.27.1"
+      }
+    },
+    "@babel/helper-string-parser": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA=="
+    },
+    "@babel/helper-validator-identifier": {
+      "version": "7.28.5",
+      "resolved": "https://registry.facebook.net/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
+      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q=="
+    },
+    "@babel/helper-validator-option": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
+      "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg=="
+    },
+    "@babel/helper-wrap-function": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/helper-wrap-function/-/helper-wrap-function-7.28.6.tgz",
+      "integrity": "sha512-z+PwLziMNBeSQJonizz2AGnndLsP2DeGHIxDAn+wdHOGuo4Fo1x1HBPPXeE9TAOPHNNWQKCSlA2VZyYyyibDnQ==",
+      "requires": {
+        "@babel/template": "^7.28.6",
+        "@babel/traverse": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      }
+    },
+    "@babel/helpers": {
+      "version": "7.29.2",
+      "resolved": "https://registry.facebook.net/@babel/helpers/-/helpers-7.29.2.tgz",
+      "integrity": "sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw==",
+      "requires": {
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.29.0"
+      }
+    },
+    "@babel/parser": {
+      "version": "7.29.2",
+      "resolved": "https://registry.facebook.net/@babel/parser/-/parser-7.29.2.tgz",
+      "integrity": "sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA==",
+      "requires": {
+        "@babel/types": "^7.29.0"
+      }
+    },
+    "@babel/plugin-bugfix-firefox-class-in-computed-class-key": {
+      "version": "7.28.5",
+      "resolved": "https://registry.facebook.net/@babel/plugin-bugfix-firefox-class-in-computed-class-key/-/plugin-bugfix-firefox-class-in-computed-class-key-7.28.5.tgz",
+      "integrity": "sha512-87GDMS3tsmMSi/3bWOte1UblL+YUTFMV8SZPZ2eSEL17s74Cw/l63rR6NmGVKMYW2GYi85nE+/d6Hw5N0bEk2Q==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1",
+        "@babel/traverse": "^7.28.5"
+      }
+    },
+    "@babel/plugin-bugfix-safari-class-field-initializer-scope": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-bugfix-safari-class-field-initializer-scope/-/plugin-bugfix-safari-class-field-initializer-scope-7.27.1.tgz",
+      "integrity": "sha512-qNeq3bCKnGgLkEXUuFry6dPlGfCdQNZbn7yUAPCInwAJHMU7THJfrBSozkcWq5sNM6RcF3S8XyQL2A52KNR9IA==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.27.1.tgz",
+      "integrity": "sha512-g4L7OYun04N1WyqMNjldFwlfPCLVkgB54A/YCXICZYBsvJJE3kByKv9c9+R/nAfmIfjl2rKYLNyMHboYbZaWaA==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.27.1.tgz",
+      "integrity": "sha512-oO02gcONcD5O1iTLi/6frMJBIwWEHceWGSGqrpCmEL8nogiS6J9PBlE48CaK20/Jx1LuRml9aDftLgdjXT8+Cw==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1",
+        "@babel/plugin-transform-optional-chaining": "^7.27.1"
+      }
+    },
+    "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.28.6.tgz",
+      "integrity": "sha512-a0aBScVTlNaiUe35UtfxAN7A/tehvvG4/ByO6+46VPKTRSlfnAFsgKy0FUh+qAkQrDTmhDkT+IBOKlOoMUxQ0g==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/traverse": "^7.28.6"
+      }
+    },
+    "@babel/plugin-proposal-private-property-in-object": {
+      "version": "7.21.0-placeholder-for-preset-env.2",
+      "resolved": "https://registry.facebook.net/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.21.0-placeholder-for-preset-env.2.tgz",
+      "integrity": "sha512-SOSkfJDddaM7mak6cPEpswyTRnuRltl429hMraQEglW+OkovnCzsiszTmsrlY//qLFjCpQDFRvjdm2wA5pPm9w==",
+      "requires": {}
+    },
+    "@babel/plugin-syntax-dynamic-import": {
+      "version": "7.8.3",
+      "resolved": "https://registry.facebook.net/@babel/plugin-syntax-dynamic-import/-/plugin-syntax-dynamic-import-7.8.3.tgz",
+      "integrity": "sha512-5gdGbFon+PszYzqs83S3E5mpi7/y/8M9eC90MRTZfduQOYW76ig6SOSPNe41IG5LoP3FGBn2N0RjVDSQiS94kQ==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.8.0"
+      }
+    },
+    "@babel/plugin-syntax-import-assertions": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.28.6.tgz",
+      "integrity": "sha512-pSJUpFHdx9z5nqTSirOCMtYVP2wFgoWhP0p3g8ONK/4IHhLIBd0B9NYqAvIUAhq+OkhO4VM1tENCt0cjlsNShw==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.28.6"
+      }
+    },
+    "@babel/plugin-syntax-import-attributes": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.28.6.tgz",
+      "integrity": "sha512-jiLC0ma9XkQT3TKJ9uYvlakm66Pamywo+qwL+oL8HJOvc6TWdZXVfhqJr8CCzbSGUAbDOzlGHJC1U+vRfLQDvw==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.28.6"
+      }
+    },
+    "@babel/plugin-syntax-jsx": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.28.6.tgz",
+      "integrity": "sha512-wgEmr06G6sIpqr8YDwA2dSRTE3bJ+V0IfpzfSY3Lfgd7YWOaAdlykvJi13ZKBt8cZHfgH1IXN+CL656W3uUa4w==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.28.6"
+      }
+    },
+    "@babel/plugin-syntax-typescript": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.28.6.tgz",
+      "integrity": "sha512-+nDNmQye7nlnuuHDboPbGm00Vqg3oO8niRRL27/4LYHUsHYh0zJ1xWOz0uRwNFmM1Avzk8wZbc6rdiYhomzv/A==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.28.6"
+      }
+    },
+    "@babel/plugin-syntax-unicode-sets-regex": {
+      "version": "7.18.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-syntax-unicode-sets-regex/-/plugin-syntax-unicode-sets-regex-7.18.6.tgz",
+      "integrity": "sha512-727YkEAPwSIQTv5im8QHz3upqp92JTWhidIC81Tdx4VJYIte/VndKf1qKrfnnhPLiPghStWfvC/iFaMCQu7Nqg==",
+      "requires": {
+        "@babel/helper-create-regexp-features-plugin": "^7.18.6",
+        "@babel/helper-plugin-utils": "^7.18.6"
+      }
+    },
+    "@babel/plugin-transform-arrow-functions": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.27.1.tgz",
+      "integrity": "sha512-8Z4TGic6xW70FKThA5HYEKKyBpOOsucTOD1DjU3fZxDg+K3zBJcXMFnt/4yQiZnf5+MiOMSXQ9PaEK/Ilh1DeA==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-async-generator-functions": {
+      "version": "7.29.0",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.29.0.tgz",
+      "integrity": "sha512-va0VdWro4zlBr2JsXC+ofCPB2iG12wPtVGTWFx2WLDOM3nYQZZIGP82qku2eW/JR83sD+k2k+CsNtyEbUqhU6w==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/helper-remap-async-to-generator": "^7.27.1",
+        "@babel/traverse": "^7.29.0"
+      }
+    },
+    "@babel/plugin-transform-async-to-generator": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.28.6.tgz",
+      "integrity": "sha512-ilTRcmbuXjsMmcZ3HASTe4caH5Tpo93PkTxF9oG2VZsSWsahydmcEHhix9Ik122RcTnZnUzPbmux4wh1swfv7g==",
+      "requires": {
+        "@babel/helper-module-imports": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/helper-remap-async-to-generator": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-block-scoped-functions": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.27.1.tgz",
+      "integrity": "sha512-cnqkuOtZLapWYZUYM5rVIdv1nXYuFVIltZ6ZJ7nIj585QsjKM5dhL2Fu/lICXZ1OyIAFc7Qy+bvDAtTXqGrlhg==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-block-scoping": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.28.6.tgz",
+      "integrity": "sha512-tt/7wOtBmwHPNMPu7ax4pdPz6shjFrmHDghvNC+FG9Qvj7D6mJcoRQIF5dy4njmxR941l6rgtvfSB2zX3VlUIw==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.28.6"
+      }
+    },
+    "@babel/plugin-transform-class-properties": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.28.6.tgz",
+      "integrity": "sha512-dY2wS3I2G7D697VHndN91TJr8/AAfXQNt5ynCTI/MpxMsSzHp+52uNivYT5wCPax3whc47DR8Ba7cmlQMg24bw==",
+      "requires": {
+        "@babel/helper-create-class-features-plugin": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6"
+      }
+    },
+    "@babel/plugin-transform-class-static-block": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.28.6.tgz",
+      "integrity": "sha512-rfQ++ghVwTWTqQ7w8qyDxL1XGihjBss4CmTgGRCTAC9RIbhVpyp4fOeZtta0Lbf+dTNIVJer6ych2ibHwkZqsQ==",
+      "requires": {
+        "@babel/helper-create-class-features-plugin": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6"
+      }
+    },
+    "@babel/plugin-transform-classes": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-classes/-/plugin-transform-classes-7.28.6.tgz",
+      "integrity": "sha512-EF5KONAqC5zAqT783iMGuM2ZtmEBy+mJMOKl2BCvPZ2lVrwvXnB6o+OBWCS+CoeCCpVRF2sA2RBKUxvT8tQT5Q==",
+      "requires": {
+        "@babel/helper-annotate-as-pure": "^7.27.3",
+        "@babel/helper-compilation-targets": "^7.28.6",
+        "@babel/helper-globals": "^7.28.0",
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/helper-replace-supers": "^7.28.6",
+        "@babel/traverse": "^7.28.6"
+      }
+    },
+    "@babel/plugin-transform-computed-properties": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.28.6.tgz",
+      "integrity": "sha512-bcc3k0ijhHbc2lEfpFHgx7eYw9KNXqOerKWfzbxEHUGKnS3sz9C4CNL9OiFN1297bDNfUiSO7DaLzbvHQQQ1BQ==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/template": "^7.28.6"
+      }
+    },
+    "@babel/plugin-transform-destructuring": {
+      "version": "7.28.5",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.28.5.tgz",
+      "integrity": "sha512-Kl9Bc6D0zTUcFUvkNuQh4eGXPKKNDOJQXVyyM4ZAQPMveniJdxi8XMJwLo+xSoW3MIq81bD33lcUe9kZpl0MCw==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1",
+        "@babel/traverse": "^7.28.5"
+      }
+    },
+    "@babel/plugin-transform-dotall-regex": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.28.6.tgz",
+      "integrity": "sha512-SljjowuNKB7q5Oayv4FoPzeB74g3QgLt8IVJw9ADvWy3QnUb/01aw8I4AVv8wYnPvQz2GDDZ/g3GhcNyDBI4Bg==",
+      "requires": {
+        "@babel/helper-create-regexp-features-plugin": "^7.28.5",
+        "@babel/helper-plugin-utils": "^7.28.6"
+      }
+    },
+    "@babel/plugin-transform-duplicate-keys": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.27.1.tgz",
+      "integrity": "sha512-MTyJk98sHvSs+cvZ4nOauwTTG1JeonDjSGvGGUNHreGQns+Mpt6WX/dVzWBHgg+dYZhkC4X+zTDfkTU+Vy9y7Q==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-duplicate-named-capturing-groups-regex": {
+      "version": "7.29.0",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-duplicate-named-capturing-groups-regex/-/plugin-transform-duplicate-named-capturing-groups-regex-7.29.0.tgz",
+      "integrity": "sha512-zBPcW2lFGxdiD8PUnPwJjag2J9otbcLQzvbiOzDxpYXyCuYX9agOwMPGn1prVH0a4qzhCKu24rlH4c1f7yA8rw==",
+      "requires": {
+        "@babel/helper-create-regexp-features-plugin": "^7.28.5",
+        "@babel/helper-plugin-utils": "^7.28.6"
+      }
+    },
+    "@babel/plugin-transform-dynamic-import": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-dynamic-import/-/plugin-transform-dynamic-import-7.27.1.tgz",
+      "integrity": "sha512-MHzkWQcEmjzzVW9j2q8LGjwGWpG2mjwaaB0BNQwst3FIjqsg8Ct/mIZlvSPJvfi9y2AC8mi/ktxbFVL9pZ1I4A==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-explicit-resource-management": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-explicit-resource-management/-/plugin-transform-explicit-resource-management-7.28.6.tgz",
+      "integrity": "sha512-Iao5Konzx2b6g7EPqTy40UZbcdXE126tTxVFr/nAIj+WItNxjKSYTEw3RC+A2/ZetmdJsgueL1KhaMCQHkLPIg==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/plugin-transform-destructuring": "^7.28.5"
+      }
+    },
+    "@babel/plugin-transform-exponentiation-operator": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.28.6.tgz",
+      "integrity": "sha512-WitabqiGjV/vJ0aPOLSFfNY1u9U3R7W36B03r5I2KoNix+a3sOhJ3pKFB3R5It9/UiK78NiO0KE9P21cMhlPkw==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.28.6"
+      }
+    },
+    "@babel/plugin-transform-export-namespace-from": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-export-namespace-from/-/plugin-transform-export-namespace-from-7.27.1.tgz",
+      "integrity": "sha512-tQvHWSZ3/jH2xuq/vZDy0jNn+ZdXJeM8gHvX4lnJmsc3+50yPlWdZXIc5ay+umX+2/tJIqHqiEqcJvxlmIvRvQ==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-for-of": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.27.1.tgz",
+      "integrity": "sha512-BfbWFFEJFQzLCQ5N8VocnCtA8J1CLkNTe2Ms2wocj75dd6VpiqS5Z5quTYcUoo4Yq+DN0rtikODccuv7RU81sw==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-function-name": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.27.1.tgz",
+      "integrity": "sha512-1bQeydJF9Nr1eBCMMbC+hdwmRlsv5XYOMu03YSWFwNs0HsAmtSxxF1fyuYPqemVldVyFmlCU7w8UE14LupUSZQ==",
+      "requires": {
+        "@babel/helper-compilation-targets": "^7.27.1",
+        "@babel/helper-plugin-utils": "^7.27.1",
+        "@babel/traverse": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-json-strings": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.28.6.tgz",
+      "integrity": "sha512-Nr+hEN+0geQkzhbdgQVPoqr47lZbm+5fCUmO70722xJZd0Mvb59+33QLImGj6F+DkK3xgDi1YVysP8whD6FQAw==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.28.6"
+      }
+    },
+    "@babel/plugin-transform-literals": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-literals/-/plugin-transform-literals-7.27.1.tgz",
+      "integrity": "sha512-0HCFSepIpLTkLcsi86GG3mTUzxV5jpmbv97hTETW3yzrAij8aqlD36toB1D0daVFJM8NK6GvKO0gslVQmm+zZA==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-logical-assignment-operators": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.28.6.tgz",
+      "integrity": "sha512-+anKKair6gpi8VsM/95kmomGNMD0eLz1NQ8+Pfw5sAwWH9fGYXT50E55ZpV0pHUHWf6IUTWPM+f/7AAff+wr9A==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.28.6"
+      }
+    },
+    "@babel/plugin-transform-member-expression-literals": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.27.1.tgz",
+      "integrity": "sha512-hqoBX4dcZ1I33jCSWcXrP+1Ku7kdqXf1oeah7ooKOIiAdKQ+uqftgCFNOSzA5AMS2XIHEYeGFg4cKRCdpxzVOQ==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-modules-amd": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.27.1.tgz",
+      "integrity": "sha512-iCsytMg/N9/oFq6n+gFTvUYDZQOMK5kEdeYxmxt91fcJGycfxVP9CnrxoliM0oumFERba2i8ZtwRUCMhvP1LnA==",
+      "requires": {
+        "@babel/helper-module-transforms": "^7.27.1",
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-modules-commonjs": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.28.6.tgz",
+      "integrity": "sha512-jppVbf8IV9iWWwWTQIxJMAJCWBuuKx71475wHwYytrRGQ2CWiDvYlADQno3tcYpS/T2UUWFQp3nVtYfK/YBQrA==",
+      "requires": {
+        "@babel/helper-module-transforms": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6"
+      }
+    },
+    "@babel/plugin-transform-modules-systemjs": {
+      "version": "7.29.0",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.29.0.tgz",
+      "integrity": "sha512-PrujnVFbOdUpw4UHiVwKvKRLMMic8+eC0CuNlxjsyZUiBjhFdPsewdXCkveh2KqBA9/waD0W1b4hXSOBQJezpQ==",
+      "requires": {
+        "@babel/helper-module-transforms": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "@babel/traverse": "^7.29.0"
+      }
+    },
+    "@babel/plugin-transform-modules-umd": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.27.1.tgz",
+      "integrity": "sha512-iQBE/xC5BV1OxJbp6WG7jq9IWiD+xxlZhLrdwpPkTX3ydmXdvoCpyfJN7acaIBZaOqTfr76pgzqBJflNbeRK+w==",
+      "requires": {
+        "@babel/helper-module-transforms": "^7.27.1",
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-named-capturing-groups-regex": {
+      "version": "7.29.0",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.29.0.tgz",
+      "integrity": "sha512-1CZQA5KNAD6ZYQLPw7oi5ewtDNxH/2vuCh+6SmvgDfhumForvs8a1o9n0UrEoBD8HU4djO2yWngTQlXl1NDVEQ==",
+      "requires": {
+        "@babel/helper-create-regexp-features-plugin": "^7.28.5",
+        "@babel/helper-plugin-utils": "^7.28.6"
+      }
+    },
+    "@babel/plugin-transform-new-target": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.27.1.tgz",
+      "integrity": "sha512-f6PiYeqXQ05lYq3TIfIDu/MtliKUbNwkGApPUvyo6+tc7uaR4cPjPe7DFPr15Uyycg2lZU6btZ575CuQoYh7MQ==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-nullish-coalescing-operator": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.28.6.tgz",
+      "integrity": "sha512-3wKbRgmzYbw24mDJXT7N+ADXw8BC/imU9yo9c9X9NKaLF1fW+e5H1U5QjMUBe4Qo4Ox/o++IyUkl1sVCLgevKg==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.28.6"
+      }
+    },
+    "@babel/plugin-transform-numeric-separator": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.28.6.tgz",
+      "integrity": "sha512-SJR8hPynj8outz+SlStQSwvziMN4+Bq99it4tMIf5/Caq+3iOc0JtKyse8puvyXkk3eFRIA5ID/XfunGgO5i6w==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.28.6"
+      }
+    },
+    "@babel/plugin-transform-object-rest-spread": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.28.6.tgz",
+      "integrity": "sha512-5rh+JR4JBC4pGkXLAcYdLHZjXudVxWMXbB6u6+E9lRL5TrGVbHt1TjxGbZ8CkmYw9zjkB7jutzOROArsqtncEA==",
+      "requires": {
+        "@babel/helper-compilation-targets": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/plugin-transform-destructuring": "^7.28.5",
+        "@babel/plugin-transform-parameters": "^7.27.7",
+        "@babel/traverse": "^7.28.6"
+      }
+    },
+    "@babel/plugin-transform-object-super": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.27.1.tgz",
+      "integrity": "sha512-SFy8S9plRPbIcxlJ8A6mT/CxFdJx/c04JEctz4jf8YZaVS2px34j7NXRrlGlHkN/M2gnpL37ZpGRGVFLd3l8Ng==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1",
+        "@babel/helper-replace-supers": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-optional-catch-binding": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.28.6.tgz",
+      "integrity": "sha512-R8ja/Pyrv0OGAvAXQhSTmWyPJPml+0TMqXlO5w+AsMEiwb2fg3WkOvob7UxFSL3OIttFSGSRFKQsOhJ/X6HQdQ==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.28.6"
+      }
+    },
+    "@babel/plugin-transform-optional-chaining": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.28.6.tgz",
+      "integrity": "sha512-A4zobikRGJTsX9uqVFdafzGkqD30t26ck2LmOzAuLL8b2x6k3TIqRiT2xVvA9fNmFeTX484VpsdgmKNA0bS23w==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-parameters": {
+      "version": "7.27.7",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.27.7.tgz",
+      "integrity": "sha512-qBkYTYCb76RRxUM6CcZA5KRu8K4SM8ajzVeUgVdMVO9NN9uI/GaVmBg/WKJJGnNokV9SY8FxNOVWGXzqzUidBg==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-private-methods": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.28.6.tgz",
+      "integrity": "sha512-piiuapX9CRv7+0st8lmuUlRSmX6mBcVeNQ1b4AYzJxfCMuBfB0vBXDiGSmm03pKJw1v6cZ8KSeM+oUnM6yAExg==",
+      "requires": {
+        "@babel/helper-create-class-features-plugin": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6"
+      }
+    },
+    "@babel/plugin-transform-private-property-in-object": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.28.6.tgz",
+      "integrity": "sha512-b97jvNSOb5+ehyQmBpmhOCiUC5oVK4PMnpRvO7+ymFBoqYjeDHIU9jnrNUuwHOiL9RpGDoKBpSViarV+BU+eVA==",
+      "requires": {
+        "@babel/helper-annotate-as-pure": "^7.27.3",
+        "@babel/helper-create-class-features-plugin": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6"
+      }
+    },
+    "@babel/plugin-transform-property-literals": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.27.1.tgz",
+      "integrity": "sha512-oThy3BCuCha8kDZ8ZkgOg2exvPYUlprMukKQXI1r1pJ47NCvxfkEy8vK+r/hT9nF0Aa4H1WUPZZjHTFtAhGfmQ==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-react-constant-elements": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-react-constant-elements/-/plugin-transform-react-constant-elements-7.27.1.tgz",
+      "integrity": "sha512-edoidOjl/ZxvYo4lSBOQGDSyToYVkTAwyVoa2tkuYTSmjrB1+uAedoL5iROVLXkxH+vRgA7uP4tMg2pUJpZ3Ug==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-react-display-name": {
+      "version": "7.28.0",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-react-display-name/-/plugin-transform-react-display-name-7.28.0.tgz",
+      "integrity": "sha512-D6Eujc2zMxKjfa4Zxl4GHMsmhKKZ9VpcqIchJLvwTxad9zWIYulwYItBovpDOoNLISpcZSXoDJ5gaGbQUDqViA==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-react-jsx": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.28.6.tgz",
+      "integrity": "sha512-61bxqhiRfAACulXSLd/GxqmAedUSrRZIu/cbaT18T1CetkTmtDN15it7i80ru4DVqRK1WMxQhXs+Lf9kajm5Ow==",
+      "requires": {
+        "@babel/helper-annotate-as-pure": "^7.27.3",
+        "@babel/helper-module-imports": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/plugin-syntax-jsx": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      }
+    },
+    "@babel/plugin-transform-react-jsx-development": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-react-jsx-development/-/plugin-transform-react-jsx-development-7.27.1.tgz",
+      "integrity": "sha512-ykDdF5yI4f1WrAolLqeF3hmYU12j9ntLQl/AOG1HAS21jxyg1Q0/J/tpREuYLfatGdGmXp/3yS0ZA76kOlVq9Q==",
+      "requires": {
+        "@babel/plugin-transform-react-jsx": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-react-pure-annotations": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-react-pure-annotations/-/plugin-transform-react-pure-annotations-7.27.1.tgz",
+      "integrity": "sha512-JfuinvDOsD9FVMTHpzA/pBLisxpv1aSf+OIV8lgH3MuWrks19R27e6a6DipIg4aX1Zm9Wpb04p8wljfKrVSnPA==",
+      "requires": {
+        "@babel/helper-annotate-as-pure": "^7.27.1",
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-regenerator": {
+      "version": "7.29.0",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.29.0.tgz",
+      "integrity": "sha512-FijqlqMA7DmRdg/aINBSs04y8XNTYw/lr1gJ2WsmBnnaNw1iS43EPkJW+zK7z65auG3AWRFXWj+NcTQwYptUog==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.28.6"
+      }
+    },
+    "@babel/plugin-transform-regexp-modifiers": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-regexp-modifiers/-/plugin-transform-regexp-modifiers-7.28.6.tgz",
+      "integrity": "sha512-QGWAepm9qxpaIs7UM9FvUSnCGlb8Ua1RhyM4/veAxLwt3gMat/LSGrZixyuj4I6+Kn9iwvqCyPTtbdxanYoWYg==",
+      "requires": {
+        "@babel/helper-create-regexp-features-plugin": "^7.28.5",
+        "@babel/helper-plugin-utils": "^7.28.6"
+      }
+    },
+    "@babel/plugin-transform-reserved-words": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.27.1.tgz",
+      "integrity": "sha512-V2ABPHIJX4kC7HegLkYoDpfg9PVmuWy/i6vUM5eGK22bx4YVFD3M5F0QQnWQoDs6AGsUWTVOopBiMFQgHaSkVw==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-runtime": {
+      "version": "7.29.0",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-runtime/-/plugin-transform-runtime-7.29.0.tgz",
+      "integrity": "sha512-jlaRT5dJtMaMCV6fAuLbsQMSwz/QkvaHOHOSXRitGGwSpR1blCY4KUKoyP2tYO8vJcqYe8cEj96cqSztv3uF9w==",
+      "requires": {
+        "@babel/helper-module-imports": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "babel-plugin-polyfill-corejs2": "^0.4.14",
+        "babel-plugin-polyfill-corejs3": "^0.13.0",
+        "babel-plugin-polyfill-regenerator": "^0.6.5",
+        "semver": "^6.3.1"
+      }
+    },
+    "@babel/plugin-transform-shorthand-properties": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.27.1.tgz",
+      "integrity": "sha512-N/wH1vcn4oYawbJ13Y/FxcQrWk63jhfNa7jef0ih7PHSIHX2LB7GWE1rkPrOnka9kwMxb6hMl19p7lidA+EHmQ==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-spread": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-spread/-/plugin-transform-spread-7.28.6.tgz",
+      "integrity": "sha512-9U4QObUC0FtJl05AsUcodau/RWDytrU6uKgkxu09mLR9HLDAtUMoPuuskm5huQsoktmsYpI+bGmq+iapDcriKA==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-sticky-regex": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.27.1.tgz",
+      "integrity": "sha512-lhInBO5bi/Kowe2/aLdBAawijx+q1pQzicSgnkB6dUPc1+RC8QmJHKf2OjvU+NZWitguJHEaEmbV6VWEouT58g==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-template-literals": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.27.1.tgz",
+      "integrity": "sha512-fBJKiV7F2DxZUkg5EtHKXQdbsbURW3DZKQUWphDum0uRP6eHGGa/He9mc0mypL680pb+e/lDIthRohlv8NCHkg==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-typeof-symbol": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.27.1.tgz",
+      "integrity": "sha512-RiSILC+nRJM7FY5srIyc4/fGIwUhyDuuBSdWn4y6yT6gm652DpCHZjIipgn6B7MQ1ITOUnAKWixEUjQRIBIcLw==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-typescript": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.28.6.tgz",
+      "integrity": "sha512-0YWL2RFxOqEm9Efk5PvreamxPME8OyY0wM5wh5lHjF+VtVhdneCWGzZeSqzOfiobVqQaNCd2z0tQvnI9DaPWPw==",
+      "requires": {
+        "@babel/helper-annotate-as-pure": "^7.27.3",
+        "@babel/helper-create-class-features-plugin": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1",
+        "@babel/plugin-syntax-typescript": "^7.28.6"
+      }
+    },
+    "@babel/plugin-transform-unicode-escapes": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.27.1.tgz",
+      "integrity": "sha512-Ysg4v6AmF26k9vpfFuTZg8HRfVWzsh1kVfowA23y9j/Gu6dOuahdUVhkLqpObp3JIv27MLSii6noRnuKN8H0Mg==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-unicode-property-regex": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.28.6.tgz",
+      "integrity": "sha512-4Wlbdl/sIZjzi/8St0evF0gEZrgOswVO6aOzqxh1kDZOl9WmLrHq2HtGhnOJZmHZYKP8WZ1MDLCt5DAWwRo57A==",
+      "requires": {
+        "@babel/helper-create-regexp-features-plugin": "^7.28.5",
+        "@babel/helper-plugin-utils": "^7.28.6"
+      }
+    },
+    "@babel/plugin-transform-unicode-regex": {
+      "version": "7.27.1",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.27.1.tgz",
+      "integrity": "sha512-xvINq24TRojDuyt6JGtHmkVkrfVV3FPT16uytxImLeBZqW3/H52yN+kM1MGuyPkIQxrzKwPHs5U/MP3qKyzkGw==",
+      "requires": {
+        "@babel/helper-create-regexp-features-plugin": "^7.27.1",
+        "@babel/helper-plugin-utils": "^7.27.1"
+      }
+    },
+    "@babel/plugin-transform-unicode-sets-regex": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.28.6.tgz",
+      "integrity": "sha512-/wHc/paTUmsDYN7SZkpWxogTOBNnlx7nBQYfy6JJlCT7G3mVhltk3e++N7zV0XfgGsrqBxd4rJQt9H16I21Y1Q==",
+      "requires": {
+        "@babel/helper-create-regexp-features-plugin": "^7.28.5",
+        "@babel/helper-plugin-utils": "^7.28.6"
+      }
+    },
+    "@babel/preset-env": {
+      "version": "7.29.2",
+      "resolved": "https://registry.facebook.net/@babel/preset-env/-/preset-env-7.29.2.tgz",
+      "integrity": "sha512-DYD23veRYGvBFhcTY1iUvJnDNpuqNd/BzBwCvzOTKUnJjKg5kpUBh3/u9585Agdkgj+QuygG7jLfOPWMa2KVNw==",
+      "requires": {
+        "@babel/compat-data": "^7.29.0",
+        "@babel/helper-compilation-targets": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "@babel/helper-validator-option": "^7.27.1",
+        "@babel/plugin-bugfix-firefox-class-in-computed-class-key": "^7.28.5",
+        "@babel/plugin-bugfix-safari-class-field-initializer-scope": "^7.27.1",
+        "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": "^7.27.1",
+        "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.27.1",
+        "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": "^7.28.6",
+        "@babel/plugin-proposal-private-property-in-object": "7.21.0-placeholder-for-preset-env.2",
+        "@babel/plugin-syntax-import-assertions": "^7.28.6",
+        "@babel/plugin-syntax-import-attributes": "^7.28.6",
+        "@babel/plugin-syntax-unicode-sets-regex": "^7.18.6",
+        "@babel/plugin-transform-arrow-functions": "^7.27.1",
+        "@babel/plugin-transform-async-generator-functions": "^7.29.0",
+        "@babel/plugin-transform-async-to-generator": "^7.28.6",
+        "@babel/plugin-transform-block-scoped-functions": "^7.27.1",
+        "@babel/plugin-transform-block-scoping": "^7.28.6",
+        "@babel/plugin-transform-class-properties": "^7.28.6",
+        "@babel/plugin-transform-class-static-block": "^7.28.6",
+        "@babel/plugin-transform-classes": "^7.28.6",
+        "@babel/plugin-transform-computed-properties": "^7.28.6",
+        "@babel/plugin-transform-destructuring": "^7.28.5",
+        "@babel/plugin-transform-dotall-regex": "^7.28.6",
+        "@babel/plugin-transform-duplicate-keys": "^7.27.1",
+        "@babel/plugin-transform-duplicate-named-capturing-groups-regex": "^7.29.0",
+        "@babel/plugin-transform-dynamic-import": "^7.27.1",
+        "@babel/plugin-transform-explicit-resource-management": "^7.28.6",
+        "@babel/plugin-transform-exponentiation-operator": "^7.28.6",
+        "@babel/plugin-transform-export-namespace-from": "^7.27.1",
+        "@babel/plugin-transform-for-of": "^7.27.1",
+        "@babel/plugin-transform-function-name": "^7.27.1",
+        "@babel/plugin-transform-json-strings": "^7.28.6",
+        "@babel/plugin-transform-literals": "^7.27.1",
+        "@babel/plugin-transform-logical-assignment-operators": "^7.28.6",
+        "@babel/plugin-transform-member-expression-literals": "^7.27.1",
+        "@babel/plugin-transform-modules-amd": "^7.27.1",
+        "@babel/plugin-transform-modules-commonjs": "^7.28.6",
+        "@babel/plugin-transform-modules-systemjs": "^7.29.0",
+        "@babel/plugin-transform-modules-umd": "^7.27.1",
+        "@babel/plugin-transform-named-capturing-groups-regex": "^7.29.0",
+        "@babel/plugin-transform-new-target": "^7.27.1",
+        "@babel/plugin-transform-nullish-coalescing-operator": "^7.28.6",
+        "@babel/plugin-transform-numeric-separator": "^7.28.6",
+        "@babel/plugin-transform-object-rest-spread": "^7.28.6",
+        "@babel/plugin-transform-object-super": "^7.27.1",
+        "@babel/plugin-transform-optional-catch-binding": "^7.28.6",
+        "@babel/plugin-transform-optional-chaining": "^7.28.6",
+        "@babel/plugin-transform-parameters": "^7.27.7",
+        "@babel/plugin-transform-private-methods": "^7.28.6",
+        "@babel/plugin-transform-private-property-in-object": "^7.28.6",
+        "@babel/plugin-transform-property-literals": "^7.27.1",
+        "@babel/plugin-transform-regenerator": "^7.29.0",
+        "@babel/plugin-transform-regexp-modifiers": "^7.28.6",
+        "@babel/plugin-transform-reserved-words": "^7.27.1",
+        "@babel/plugin-transform-shorthand-properties": "^7.27.1",
+        "@babel/plugin-transform-spread": "^7.28.6",
+        "@babel/plugin-transform-sticky-regex": "^7.27.1",
+        "@babel/plugin-transform-template-literals": "^7.27.1",
+        "@babel/plugin-transform-typeof-symbol": "^7.27.1",
+        "@babel/plugin-transform-unicode-escapes": "^7.27.1",
+        "@babel/plugin-transform-unicode-property-regex": "^7.28.6",
+        "@babel/plugin-transform-unicode-regex": "^7.27.1",
+        "@babel/plugin-transform-unicode-sets-regex": "^7.28.6",
+        "@babel/preset-modules": "0.1.6-no-external-plugins",
+        "babel-plugin-polyfill-corejs2": "^0.4.15",
+        "babel-plugin-polyfill-corejs3": "^0.14.0",
+        "babel-plugin-polyfill-regenerator": "^0.6.6",
+        "core-js-compat": "^3.48.0",
+        "semver": "^6.3.1"
+      },
+      "dependencies": {
+        "babel-plugin-polyfill-corejs3": {
+          "version": "0.14.2",
+          "resolved": "https://registry.facebook.net/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.14.2.tgz",
+          "integrity": "sha512-coWpDLJ410R781Npmn/SIBZEsAetR4xVi0SxLMXPaMO4lSf1MwnkGYMtkFxew0Dn8B3/CpbpYxN0JCgg8mn67g==",
+          "requires": {
+            "@babel/helper-define-polyfill-provider": "^0.6.8",
+            "core-js-compat": "^3.48.0"
+          }
+        }
+      }
+    },
+    "@babel/preset-modules": {
+      "version": "0.1.6-no-external-plugins",
+      "resolved": "https://registry.facebook.net/@babel/preset-modules/-/preset-modules-0.1.6-no-external-plugins.tgz",
+      "integrity": "sha512-HrcgcIESLm9aIR842yhJ5RWan/gebQUJ6E/E5+rf0y9o6oj7w0Br+sWuL6kEQ/o/AdfvR1Je9jG18/gnpwjEyA==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.0.0",
+        "@babel/types": "^7.4.4",
+        "esutils": "^2.0.2"
+      }
+    },
+    "@babel/preset-react": {
+      "version": "7.28.5",
+      "resolved": "https://registry.facebook.net/@babel/preset-react/-/preset-react-7.28.5.tgz",
+      "integrity": "sha512-Z3J8vhRq7CeLjdC58jLv4lnZ5RKFUJWqH5emvxmv9Hv3BD1T9R/Im713R4MTKwvFaV74ejZ3sM01LyEKk4ugNQ==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1",
+        "@babel/helper-validator-option": "^7.27.1",
+        "@babel/plugin-transform-react-display-name": "^7.28.0",
+        "@babel/plugin-transform-react-jsx": "^7.27.1",
+        "@babel/plugin-transform-react-jsx-development": "^7.27.1",
+        "@babel/plugin-transform-react-pure-annotations": "^7.27.1"
+      }
+    },
+    "@babel/preset-typescript": {
+      "version": "7.28.5",
+      "resolved": "https://registry.facebook.net/@babel/preset-typescript/-/preset-typescript-7.28.5.tgz",
+      "integrity": "sha512-+bQy5WOI2V6LJZpPVxY+yp66XdZ2yifu0Mc1aP5CQKgjn4QM5IN2i5fAZ4xKop47pr8rpVhiAeu+nDQa12C8+g==",
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.27.1",
+        "@babel/helper-validator-option": "^7.27.1",
+        "@babel/plugin-syntax-jsx": "^7.27.1",
+        "@babel/plugin-transform-modules-commonjs": "^7.27.1",
+        "@babel/plugin-transform-typescript": "^7.28.5"
+      }
+    },
+    "@babel/runtime": {
+      "version": "7.29.2",
+      "resolved": "https://registry.facebook.net/@babel/runtime/-/runtime-7.29.2.tgz",
+      "integrity": "sha512-JiDShH45zKHWyGe4ZNVRrCjBz8Nh9TMmZG1kh4QTK8hCBTWBi8Da+i7s1fJw7/lYpM4ccepSNfqzZ/QvABBi5g=="
+    },
+    "@babel/template": {
+      "version": "7.28.6",
+      "resolved": "https://registry.facebook.net/@babel/template/-/template-7.28.6.tgz",
+      "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==",
+      "requires": {
+        "@babel/code-frame": "^7.28.6",
+        "@babel/parser": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      }
+    },
+    "@babel/traverse": {
+      "version": "7.29.0",
+      "resolved": "https://registry.facebook.net/@babel/traverse/-/traverse-7.29.0.tgz",
+      "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==",
+      "requires": {
+        "@babel/code-frame": "^7.29.0",
+        "@babel/generator": "^7.29.0",
+        "@babel/helper-globals": "^7.28.0",
+        "@babel/parser": "^7.29.0",
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.29.0",
+        "debug": "^4.3.1"
+      }
+    },
+    "@babel/types": {
+      "version": "7.29.0",
+      "resolved": "https://registry.facebook.net/@babel/types/-/types-7.29.0.tgz",
+      "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==",
+      "requires": {
+        "@babel/helper-string-parser": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.28.5"
+      }
+    },
+    "@colors/colors": {
+      "version": "1.5.0",
+      "resolved": "https://registry.facebook.net/@colors/colors/-/colors-1.5.0.tgz",
+      "integrity": "sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==",
+      "optional": true
+    },
+    "@csstools/cascade-layer-name-parser": {
+      "version": "2.0.5",
+      "resolved": "https://registry.facebook.net/@csstools/cascade-layer-name-parser/-/cascade-layer-name-parser-2.0.5.tgz",
+      "integrity": "sha512-p1ko5eHgV+MgXFVa4STPKpvPxr6ReS8oS2jzTukjR74i5zJNyWO1ZM1m8YKBXnzDKWfBN1ztLYlHxbVemDD88A==",
+      "requires": {}
+    },
+    "@csstools/color-helpers": {
+      "version": "5.1.0",
+      "resolved": "https://registry.facebook.net/@csstools/color-helpers/-/color-helpers-5.1.0.tgz",
+      "integrity": "sha512-S11EXWJyy0Mz5SYvRmY8nJYTFFd1LCNV+7cXyAgQtOOuzb4EsgfqDufL+9esx72/eLhsRdGZwaldu/h+E4t4BA=="
+    },
+    "@csstools/css-calc": {
+      "version": "2.1.4",
+      "resolved": "https://registry.facebook.net/@csstools/css-calc/-/css-calc-2.1.4.tgz",
+      "integrity": "sha512-3N8oaj+0juUw/1H3YwmDDJXCgTB1gKU6Hc/bB502u9zR0q2vd786XJH9QfrKIEgFlZmhZiq6epXl4rHqhzsIgQ==",
+      "requires": {}
+    },
+    "@csstools/css-color-parser": {
+      "version": "3.1.0",
+      "resolved": "https://registry.facebook.net/@csstools/css-color-parser/-/css-color-parser-3.1.0.tgz",
+      "integrity": "sha512-nbtKwh3a6xNVIp/VRuXV64yTKnb1IjTAEEh3irzS+HkKjAOYLTGNb9pmVNntZ8iVBHcWDA2Dof0QtPgFI1BaTA==",
+      "requires": {
+        "@csstools/color-helpers": "^5.1.0",
+        "@csstools/css-calc": "^2.1.4"
+      }
+    },
+    "@csstools/css-parser-algorithms": {
+      "version": "3.0.5",
+      "resolved": "https://registry.facebook.net/@csstools/css-parser-algorithms/-/css-parser-algorithms-3.0.5.tgz",
+      "integrity": "sha512-DaDeUkXZKjdGhgYaHNJTV9pV7Y9B3b644jCLs9Upc3VeNGg6LWARAT6O+Q+/COo+2gg/bM5rhpMAtf70WqfBdQ==",
+      "requires": {}
+    },
+    "@csstools/css-tokenizer": {
+      "version": "3.0.4",
+      "resolved": "https://registry.facebook.net/@csstools/css-tokenizer/-/css-tokenizer-3.0.4.tgz",
+      "integrity": "sha512-Vd/9EVDiu6PPJt9yAh6roZP6El1xHrdvIVGjyBsHR0RYwNHgL7FJPyIIW4fANJNG6FtyZfvlRPpFI4ZM/lubvw=="
+    },
+    "@csstools/media-query-list-parser": {
+      "version": "4.0.3",
+      "resolved": "https://registry.facebook.net/@csstools/media-query-list-parser/-/media-query-list-parser-4.0.3.tgz",
+      "integrity": "sha512-HAYH7d3TLRHDOUQK4mZKf9k9Ph/m8Akstg66ywKR4SFAigjs3yBiUeZtFxywiTm5moZMAp/5W/ZuFnNXXYLuuQ==",
+      "requires": {}
+    },
+    "@csstools/postcss-alpha-function": {
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-alpha-function/-/postcss-alpha-function-1.0.1.tgz",
+      "integrity": "sha512-isfLLwksH3yHkFXfCI2Gcaqg7wGGHZZwunoJzEZk0yKYIokgre6hYVFibKL3SYAoR1kBXova8LB+JoO5vZzi9w==",
+      "requires": {
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/utilities": "^2.0.0"
+      }
+    },
+    "@csstools/postcss-cascade-layers": {
+      "version": "5.0.2",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-cascade-layers/-/postcss-cascade-layers-5.0.2.tgz",
+      "integrity": "sha512-nWBE08nhO8uWl6kSAeCx4im7QfVko3zLrtgWZY4/bP87zrSPpSyN/3W3TDqz1jJuH+kbKOHXg5rJnK+ZVYcFFg==",
+      "requires": {
+        "@csstools/selector-specificity": "^5.0.0",
+        "postcss-selector-parser": "^7.0.0"
+      }
+    },
+    "@csstools/postcss-color-function": {
+      "version": "4.0.12",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-color-function/-/postcss-color-function-4.0.12.tgz",
+      "integrity": "sha512-yx3cljQKRaSBc2hfh8rMZFZzChaFgwmO2JfFgFr1vMcF3C/uyy5I4RFIBOIWGq1D+XbKCG789CGkG6zzkLpagA==",
+      "requires": {
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/utilities": "^2.0.0"
+      }
+    },
+    "@csstools/postcss-color-function-display-p3-linear": {
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-color-function-display-p3-linear/-/postcss-color-function-display-p3-linear-1.0.1.tgz",
+      "integrity": "sha512-E5qusdzhlmO1TztYzDIi8XPdPoYOjoTY6HBYBCYSj+Gn4gQRBlvjgPQXzfzuPQqt8EhkC/SzPKObg4Mbn8/xMg==",
+      "requires": {
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/utilities": "^2.0.0"
+      }
+    },
+    "@csstools/postcss-color-mix-function": {
+      "version": "3.0.12",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-color-mix-function/-/postcss-color-mix-function-3.0.12.tgz",
+      "integrity": "sha512-4STERZfCP5Jcs13P1U5pTvI9SkgLgfMUMhdXW8IlJWkzOOOqhZIjcNhWtNJZes2nkBDsIKJ0CJtFtuaZ00moag==",
+      "requires": {
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/utilities": "^2.0.0"
+      }
+    },
+    "@csstools/postcss-color-mix-variadic-function-arguments": {
+      "version": "1.0.2",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-color-mix-variadic-function-arguments/-/postcss-color-mix-variadic-function-arguments-1.0.2.tgz",
+      "integrity": "sha512-rM67Gp9lRAkTo+X31DUqMEq+iK+EFqsidfecmhrteErxJZb6tUoJBVQca1Vn1GpDql1s1rD1pKcuYzMsg7Z1KQ==",
+      "requires": {
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/utilities": "^2.0.0"
+      }
+    },
+    "@csstools/postcss-content-alt-text": {
+      "version": "2.0.8",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-content-alt-text/-/postcss-content-alt-text-2.0.8.tgz",
+      "integrity": "sha512-9SfEW9QCxEpTlNMnpSqFaHyzsiRpZ5J5+KqCu1u5/eEJAWsMhzT40qf0FIbeeglEvrGRMdDzAxMIz3wqoGSb+Q==",
+      "requires": {
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/utilities": "^2.0.0"
+      }
+    },
+    "@csstools/postcss-contrast-color-function": {
+      "version": "2.0.12",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-contrast-color-function/-/postcss-contrast-color-function-2.0.12.tgz",
+      "integrity": "sha512-YbwWckjK3qwKjeYz/CijgcS7WDUCtKTd8ShLztm3/i5dhh4NaqzsbYnhm4bjrpFpnLZ31jVcbK8YL77z3GBPzA==",
+      "requires": {
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/utilities": "^2.0.0"
+      }
+    },
+    "@csstools/postcss-exponential-functions": {
+      "version": "2.0.9",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-exponential-functions/-/postcss-exponential-functions-2.0.9.tgz",
+      "integrity": "sha512-abg2W/PI3HXwS/CZshSa79kNWNZHdJPMBXeZNyPQFbbj8sKO3jXxOt/wF7juJVjyDTc6JrvaUZYFcSBZBhaxjw==",
+      "requires": {
+        "@csstools/css-calc": "^2.1.4",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "@csstools/postcss-font-format-keywords": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-font-format-keywords/-/postcss-font-format-keywords-4.0.0.tgz",
+      "integrity": "sha512-usBzw9aCRDvchpok6C+4TXC57btc4bJtmKQWOHQxOVKen1ZfVqBUuCZ/wuqdX5GHsD0NRSr9XTP+5ID1ZZQBXw==",
+      "requires": {
+        "@csstools/utilities": "^2.0.0",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "@csstools/postcss-gamut-mapping": {
+      "version": "2.0.11",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-gamut-mapping/-/postcss-gamut-mapping-2.0.11.tgz",
+      "integrity": "sha512-fCpCUgZNE2piVJKC76zFsgVW1apF6dpYsqGyH8SIeCcM4pTEsRTWTLCaJIMKFEundsCKwY1rwfhtrio04RJ4Dw==",
+      "requires": {
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "@csstools/postcss-gradients-interpolation-method": {
+      "version": "5.0.12",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-gradients-interpolation-method/-/postcss-gradients-interpolation-method-5.0.12.tgz",
+      "integrity": "sha512-jugzjwkUY0wtNrZlFeyXzimUL3hN4xMvoPnIXxoZqxDvjZRiSh+itgHcVUWzJ2VwD/VAMEgCLvtaJHX+4Vj3Ow==",
+      "requires": {
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/utilities": "^2.0.0"
+      }
+    },
+    "@csstools/postcss-hwb-function": {
+      "version": "4.0.12",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-hwb-function/-/postcss-hwb-function-4.0.12.tgz",
+      "integrity": "sha512-mL/+88Z53KrE4JdePYFJAQWFrcADEqsLprExCM04GDNgHIztwFzj0Mbhd/yxMBngq0NIlz58VVxjt5abNs1VhA==",
+      "requires": {
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/utilities": "^2.0.0"
+      }
+    },
+    "@csstools/postcss-ic-unit": {
+      "version": "4.0.4",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-ic-unit/-/postcss-ic-unit-4.0.4.tgz",
+      "integrity": "sha512-yQ4VmossuOAql65sCPppVO1yfb7hDscf4GseF0VCA/DTDaBc0Wtf8MTqVPfjGYlT5+2buokG0Gp7y0atYZpwjg==",
+      "requires": {
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/utilities": "^2.0.0",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "@csstools/postcss-initial": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-initial/-/postcss-initial-2.0.1.tgz",
+      "integrity": "sha512-L1wLVMSAZ4wovznquK0xmC7QSctzO4D0Is590bxpGqhqjboLXYA16dWZpfwImkdOgACdQ9PqXsuRroW6qPlEsg==",
+      "requires": {}
+    },
+    "@csstools/postcss-is-pseudo-class": {
+      "version": "5.0.3",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-is-pseudo-class/-/postcss-is-pseudo-class-5.0.3.tgz",
+      "integrity": "sha512-jS/TY4SpG4gszAtIg7Qnf3AS2pjcUM5SzxpApOrlndMeGhIbaTzWBzzP/IApXoNWEW7OhcjkRT48jnAUIFXhAQ==",
+      "requires": {
+        "@csstools/selector-specificity": "^5.0.0",
+        "postcss-selector-parser": "^7.0.0"
+      }
+    },
+    "@csstools/postcss-light-dark-function": {
+      "version": "2.0.11",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-light-dark-function/-/postcss-light-dark-function-2.0.11.tgz",
+      "integrity": "sha512-fNJcKXJdPM3Lyrbmgw2OBbaioU7yuKZtiXClf4sGdQttitijYlZMD5K7HrC/eF83VRWRrYq6OZ0Lx92leV2LFA==",
+      "requires": {
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/utilities": "^2.0.0"
+      }
+    },
+    "@csstools/postcss-logical-float-and-clear": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-logical-float-and-clear/-/postcss-logical-float-and-clear-3.0.0.tgz",
+      "integrity": "sha512-SEmaHMszwakI2rqKRJgE+8rpotFfne1ZS6bZqBoQIicFyV+xT1UF42eORPxJkVJVrH9C0ctUgwMSn3BLOIZldQ==",
+      "requires": {}
+    },
+    "@csstools/postcss-logical-overflow": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-logical-overflow/-/postcss-logical-overflow-2.0.0.tgz",
+      "integrity": "sha512-spzR1MInxPuXKEX2csMamshR4LRaSZ3UXVaRGjeQxl70ySxOhMpP2252RAFsg8QyyBXBzuVOOdx1+bVO5bPIzA==",
+      "requires": {}
+    },
+    "@csstools/postcss-logical-overscroll-behavior": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-logical-overscroll-behavior/-/postcss-logical-overscroll-behavior-2.0.0.tgz",
+      "integrity": "sha512-e/webMjoGOSYfqLunyzByZj5KKe5oyVg/YSbie99VEaSDE2kimFm0q1f6t/6Jo+VVCQ/jbe2Xy+uX+C4xzWs4w==",
+      "requires": {}
+    },
+    "@csstools/postcss-logical-resize": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-logical-resize/-/postcss-logical-resize-3.0.0.tgz",
+      "integrity": "sha512-DFbHQOFW/+I+MY4Ycd/QN6Dg4Hcbb50elIJCfnwkRTCX05G11SwViI5BbBlg9iHRl4ytB7pmY5ieAFk3ws7yyg==",
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "@csstools/postcss-logical-viewport-units": {
+      "version": "3.0.4",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-logical-viewport-units/-/postcss-logical-viewport-units-3.0.4.tgz",
+      "integrity": "sha512-q+eHV1haXA4w9xBwZLKjVKAWn3W2CMqmpNpZUk5kRprvSiBEGMgrNH3/sJZ8UA3JgyHaOt3jwT9uFa4wLX4EqQ==",
+      "requires": {
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/utilities": "^2.0.0"
+      }
+    },
+    "@csstools/postcss-media-minmax": {
+      "version": "2.0.9",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-media-minmax/-/postcss-media-minmax-2.0.9.tgz",
+      "integrity": "sha512-af9Qw3uS3JhYLnCbqtZ9crTvvkR+0Se+bBqSr7ykAnl9yKhk6895z9rf+2F4dClIDJWxgn0iZZ1PSdkhrbs2ig==",
+      "requires": {
+        "@csstools/css-calc": "^2.1.4",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/media-query-list-parser": "^4.0.3"
+      }
+    },
+    "@csstools/postcss-media-queries-aspect-ratio-number-values": {
+      "version": "3.0.5",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-media-queries-aspect-ratio-number-values/-/postcss-media-queries-aspect-ratio-number-values-3.0.5.tgz",
+      "integrity": "sha512-zhAe31xaaXOY2Px8IYfoVTB3wglbJUVigGphFLj6exb7cjZRH9A6adyE22XfFK3P2PzwRk0VDeTJmaxpluyrDg==",
+      "requires": {
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/media-query-list-parser": "^4.0.3"
+      }
+    },
+    "@csstools/postcss-nested-calc": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-nested-calc/-/postcss-nested-calc-4.0.0.tgz",
+      "integrity": "sha512-jMYDdqrQQxE7k9+KjstC3NbsmC063n1FTPLCgCRS2/qHUbHM0mNy9pIn4QIiQGs9I/Bg98vMqw7mJXBxa0N88A==",
+      "requires": {
+        "@csstools/utilities": "^2.0.0",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "@csstools/postcss-normalize-display-values": {
+      "version": "4.0.1",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-normalize-display-values/-/postcss-normalize-display-values-4.0.1.tgz",
+      "integrity": "sha512-TQUGBuRvxdc7TgNSTevYqrL8oItxiwPDixk20qCB5me/W8uF7BPbhRrAvFuhEoywQp/woRsUZ6SJ+sU5idZAIA==",
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "@csstools/postcss-oklab-function": {
+      "version": "4.0.12",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-oklab-function/-/postcss-oklab-function-4.0.12.tgz",
+      "integrity": "sha512-HhlSmnE1NKBhXsTnNGjxvhryKtO7tJd1w42DKOGFD6jSHtYOrsJTQDKPMwvOfrzUAk8t7GcpIfRyM7ssqHpFjg==",
+      "requires": {
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/utilities": "^2.0.0"
+      }
+    },
+    "@csstools/postcss-position-area-property": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-position-area-property/-/postcss-position-area-property-1.0.0.tgz",
+      "integrity": "sha512-fUP6KR8qV2NuUZV3Cw8itx0Ep90aRjAZxAEzC3vrl6yjFv+pFsQbR18UuQctEKmA72K9O27CoYiKEgXxkqjg8Q==",
+      "requires": {}
+    },
+    "@csstools/postcss-progressive-custom-properties": {
+      "version": "4.2.1",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-progressive-custom-properties/-/postcss-progressive-custom-properties-4.2.1.tgz",
+      "integrity": "sha512-uPiiXf7IEKtUQXsxu6uWtOlRMXd2QWWy5fhxHDnPdXKCQckPP3E34ZgDoZ62r2iT+UOgWsSbM4NvHE5m3mAEdw==",
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "@csstools/postcss-property-rule-prelude-list": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-property-rule-prelude-list/-/postcss-property-rule-prelude-list-1.0.0.tgz",
+      "integrity": "sha512-IxuQjUXq19fobgmSSvUDO7fVwijDJaZMvWQugxfEUxmjBeDCVaDuMpsZ31MsTm5xbnhA+ElDi0+rQ7sQQGisFA==",
+      "requires": {
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "@csstools/postcss-random-function": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-random-function/-/postcss-random-function-2.0.1.tgz",
+      "integrity": "sha512-q+FQaNiRBhnoSNo+GzqGOIBKoHQ43lYz0ICrV+UudfWnEF6ksS6DsBIJSISKQT2Bvu3g4k6r7t0zYrk5pDlo8w==",
+      "requires": {
+        "@csstools/css-calc": "^2.1.4",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "@csstools/postcss-relative-color-syntax": {
+      "version": "3.0.12",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-relative-color-syntax/-/postcss-relative-color-syntax-3.0.12.tgz",
+      "integrity": "sha512-0RLIeONxu/mtxRtf3o41Lq2ghLimw0w9ByLWnnEVuy89exmEEq8bynveBxNW3nyHqLAFEeNtVEmC1QK9MZ8Huw==",
+      "requires": {
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/utilities": "^2.0.0"
+      }
+    },
+    "@csstools/postcss-scope-pseudo-class": {
+      "version": "4.0.1",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-scope-pseudo-class/-/postcss-scope-pseudo-class-4.0.1.tgz",
+      "integrity": "sha512-IMi9FwtH6LMNuLea1bjVMQAsUhFxJnyLSgOp/cpv5hrzWmrUYU5fm0EguNDIIOHUqzXode8F/1qkC/tEo/qN8Q==",
+      "requires": {
+        "postcss-selector-parser": "^7.0.0"
+      }
+    },
+    "@csstools/postcss-sign-functions": {
+      "version": "1.1.4",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-sign-functions/-/postcss-sign-functions-1.1.4.tgz",
+      "integrity": "sha512-P97h1XqRPcfcJndFdG95Gv/6ZzxUBBISem0IDqPZ7WMvc/wlO+yU0c5D/OCpZ5TJoTt63Ok3knGk64N+o6L2Pg==",
+      "requires": {
+        "@csstools/css-calc": "^2.1.4",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "@csstools/postcss-stepped-value-functions": {
+      "version": "4.0.9",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-stepped-value-functions/-/postcss-stepped-value-functions-4.0.9.tgz",
+      "integrity": "sha512-h9btycWrsex4dNLeQfyU3y3w40LMQooJWFMm/SK9lrKguHDcFl4VMkncKKoXi2z5rM9YGWbUQABI8BT2UydIcA==",
+      "requires": {
+        "@csstools/css-calc": "^2.1.4",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "@csstools/postcss-syntax-descriptor-syntax-production": {
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-syntax-descriptor-syntax-production/-/postcss-syntax-descriptor-syntax-production-1.0.1.tgz",
+      "integrity": "sha512-GneqQWefjM//f4hJ/Kbox0C6f2T7+pi4/fqTqOFGTL3EjnvOReTqO1qUQ30CaUjkwjYq9qZ41hzarrAxCc4gow==",
+      "requires": {
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "@csstools/postcss-system-ui-font-family": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-system-ui-font-family/-/postcss-system-ui-font-family-1.0.0.tgz",
+      "integrity": "sha512-s3xdBvfWYfoPSBsikDXbuorcMG1nN1M6GdU0qBsGfcmNR0A/qhloQZpTxjA3Xsyrk1VJvwb2pOfiOT3at/DuIQ==",
+      "requires": {
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "@csstools/postcss-text-decoration-shorthand": {
+      "version": "4.0.3",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-text-decoration-shorthand/-/postcss-text-decoration-shorthand-4.0.3.tgz",
+      "integrity": "sha512-KSkGgZfx0kQjRIYnpsD7X2Om9BUXX/Kii77VBifQW9Ih929hK0KNjVngHDH0bFB9GmfWcR9vJYJJRvw/NQjkrA==",
+      "requires": {
+        "@csstools/color-helpers": "^5.1.0",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "@csstools/postcss-trigonometric-functions": {
+      "version": "4.0.9",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-trigonometric-functions/-/postcss-trigonometric-functions-4.0.9.tgz",
+      "integrity": "sha512-Hnh5zJUdpNrJqK9v1/E3BbrQhaDTj5YiX7P61TOvUhoDHnUmsNNxcDAgkQ32RrcWx9GVUvfUNPcUkn8R3vIX6A==",
+      "requires": {
+        "@csstools/css-calc": "^2.1.4",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "@csstools/postcss-unset-value": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/@csstools/postcss-unset-value/-/postcss-unset-value-4.0.0.tgz",
+      "integrity": "sha512-cBz3tOCI5Fw6NIFEwU3RiwK6mn3nKegjpJuzCndoGq3BZPkUjnsq7uQmIeMNeMbMk7YD2MfKcgCpZwX5jyXqCA==",
+      "requires": {}
+    },
+    "@csstools/selector-resolve-nested": {
+      "version": "3.1.0",
+      "resolved": "https://registry.facebook.net/@csstools/selector-resolve-nested/-/selector-resolve-nested-3.1.0.tgz",
+      "integrity": "sha512-mf1LEW0tJLKfWyvn5KdDrhpxHyuxpbNwTIwOYLIvsTffeyOf85j5oIzfG0yosxDgx/sswlqBnESYUcQH0vgZ0g==",
+      "requires": {}
+    },
+    "@csstools/selector-specificity": {
+      "version": "5.0.0",
+      "resolved": "https://registry.facebook.net/@csstools/selector-specificity/-/selector-specificity-5.0.0.tgz",
+      "integrity": "sha512-PCqQV3c4CoVm3kdPhyeZ07VmBRdH2EpMFA/pd9OASpOEC3aXNGoqPDAZ80D0cLpMBxnmk0+yNhGsEx31hq7Gtw==",
+      "requires": {}
+    },
+    "@csstools/utilities": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/@csstools/utilities/-/utilities-2.0.0.tgz",
+      "integrity": "sha512-5VdOr0Z71u+Yp3ozOx8T11N703wIFGVRgOWbOZMKgglPJsWA54MRIoMNVMa7shUToIhx5J8vX4sOZgD2XiihiQ==",
+      "requires": {}
+    },
+    "@discoveryjs/json-ext": {
+      "version": "0.5.7",
+      "resolved": "https://registry.facebook.net/@discoveryjs/json-ext/-/json-ext-0.5.7.tgz",
+      "integrity": "sha512-dBVuXR082gk3jsFp7Rd/JI4kytwGHecnCoTtXFb7DB6CNHp4rg5k1bhg0nWdLGLnOV71lmDzGQaLMy8iPLY0pw=="
+    },
+    "@docsearch/core": {
+      "version": "4.6.3",
+      "resolved": "https://registry.facebook.net/@docsearch/core/-/core-4.6.3.tgz",
+      "integrity": "sha512-rUOujwIpxJRgD7+kicVsI3D5sqBvdiRTquzWBpTEXZs8ZXfGbfzpus5HqumaNYTppN2HvH8E2yNuRwYdHJeOlA==",
+      "requires": {}
+    },
+    "@docsearch/css": {
+      "version": "4.6.3",
+      "resolved": "https://registry.facebook.net/@docsearch/css/-/css-4.6.3.tgz",
+      "integrity": "sha512-nlOwcXcsNAptQl4vlL4MA78qNJKO0Qlds5GuBjCoePgkebTXLSf8Qt1oyZ3YBshYupKXG9VRGEsk1zr23d+bzQ=="
+    },
+    "@docsearch/react": {
+      "version": "4.6.3",
+      "resolved": "https://registry.facebook.net/@docsearch/react/-/react-4.6.3.tgz",
+      "integrity": "sha512-Bg2wdDsoQVlNCcEKuEJAU04tvHCqgx8rIu+uIoM4pRtcx3TBKJuXutJik3LTA8LRc9YEyHkrYUrmcC0D7BYf+g==",
+      "requires": {
+        "@algolia/autocomplete-core": "1.19.2",
+        "@docsearch/core": "4.6.3",
+        "@docsearch/css": "4.6.3"
+      },
+      "dependencies": {
+        "@algolia/autocomplete-core": {
+          "version": "1.19.2",
+          "resolved": "https://registry.facebook.net/@algolia/autocomplete-core/-/autocomplete-core-1.19.2.tgz",
+          "integrity": "sha512-mKv7RyuAzXvwmq+0XRK8HqZXt9iZ5Kkm2huLjgn5JoCPtDy+oh9yxUMfDDaVCw0oyzZ1isdJBc7l9nuCyyR7Nw==",
+          "requires": {
+            "@algolia/autocomplete-plugin-algolia-insights": "1.19.2",
+            "@algolia/autocomplete-shared": "1.19.2"
+          }
+        },
+        "@algolia/autocomplete-plugin-algolia-insights": {
+          "version": "1.19.2",
+          "resolved": "https://registry.facebook.net/@algolia/autocomplete-plugin-algolia-insights/-/autocomplete-plugin-algolia-insights-1.19.2.tgz",
+          "integrity": "sha512-TjxbcC/r4vwmnZaPwrHtkXNeqvlpdyR+oR9Wi2XyfORkiGkLTVhX2j+O9SaCCINbKoDfc+c2PB8NjfOnz7+oKg==",
+          "requires": {
+            "@algolia/autocomplete-shared": "1.19.2"
+          }
+        }
+      }
+    },
+    "@docusaurus/babel": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/babel/-/babel-3.10.0.tgz",
+      "integrity": "sha512-mqCJhCZNZUDg0zgDEaPTM4DnRsisa24HdqTy/qn/MQlbwhTb4WVaZg6ZyX6yIVKqTz8fS1hBMgM+98z+BeJJDg==",
+      "requires": {
+        "@babel/core": "^7.25.9",
+        "@babel/generator": "^7.25.9",
+        "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+        "@babel/plugin-transform-runtime": "^7.25.9",
+        "@babel/preset-env": "^7.25.9",
+        "@babel/preset-react": "^7.25.9",
+        "@babel/preset-typescript": "^7.25.9",
+        "@babel/runtime": "^7.25.9",
+        "@babel/traverse": "^7.25.9",
+        "@docusaurus/logger": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "babel-plugin-dynamic-import-node": "^2.3.3",
+        "fs-extra": "^11.1.1",
+        "tslib": "^2.6.0"
+      }
+    },
+    "@docusaurus/bundler": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/bundler/-/bundler-3.10.0.tgz",
+      "integrity": "sha512-iONUGZGgp+lAkw/cJZH6irONcF4p8+278IsdRlq8lYhxGjkoNUs0w7F4gVXBYSNChq5KG5/JleTSsdJySShxow==",
+      "requires": {
+        "@babel/core": "^7.25.9",
+        "@docusaurus/babel": "3.10.0",
+        "@docusaurus/cssnano-preset": "3.10.0",
+        "@docusaurus/logger": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "babel-loader": "^9.2.1",
+        "clean-css": "^5.3.3",
+        "copy-webpack-plugin": "^11.0.0",
+        "css-loader": "^6.11.0",
+        "css-minimizer-webpack-plugin": "^5.0.1",
+        "cssnano": "^6.1.2",
+        "file-loader": "^6.2.0",
+        "html-minifier-terser": "^7.2.0",
+        "mini-css-extract-plugin": "^2.9.2",
+        "null-loader": "^4.0.1",
+        "postcss": "^8.5.4",
+        "postcss-loader": "^7.3.4",
+        "postcss-preset-env": "^10.2.1",
+        "terser-webpack-plugin": "^5.3.9",
+        "tslib": "^2.6.0",
+        "url-loader": "^4.1.1",
+        "webpack": "^5.95.0",
+        "webpackbar": "^6.0.1"
+      },
+      "dependencies": {
+        "commander": {
+          "version": "10.0.1",
+          "resolved": "https://registry.facebook.net/commander/-/commander-10.0.1.tgz",
+          "integrity": "sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug=="
+        },
+        "emoji-regex": {
+          "version": "8.0.0",
+          "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+          "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="
+        },
+        "html-minifier-terser": {
+          "version": "7.2.0",
+          "resolved": "https://registry.facebook.net/html-minifier-terser/-/html-minifier-terser-7.2.0.tgz",
+          "integrity": "sha512-tXgn3QfqPIpGl9o+K5tpcj3/MN4SfLtsx2GWwBC3SSd0tXQGyF3gsSqad8loJgKZGM3ZxbYDd5yhiBIdWpmvLA==",
+          "requires": {
+            "camel-case": "^4.1.2",
+            "clean-css": "~5.3.2",
+            "commander": "^10.0.0",
+            "entities": "^4.4.0",
+            "param-case": "^3.0.4",
+            "relateurl": "^0.2.7",
+            "terser": "^5.15.1"
+          }
+        },
+        "markdown-table": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-2.0.0.tgz",
+          "integrity": "sha512-Ezda85ToJUBhM6WGaG6veasyym+Tbs3cMAw/ZhOPqXiYsr0jgocBV3j3nx+4lk47plLlIqjwuTm/ywVI+zjJ/A==",
+          "requires": {
+            "repeat-string": "^1.0.0"
+          }
+        },
+        "string-width": {
+          "version": "4.2.3",
+          "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+          "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+          "requires": {
+            "emoji-regex": "^8.0.0",
+            "is-fullwidth-code-point": "^3.0.0",
+            "strip-ansi": "^6.0.1"
+          }
+        },
+        "webpackbar": {
+          "version": "6.0.1",
+          "resolved": "https://registry.npmjs.org/webpackbar/-/webpackbar-6.0.1.tgz",
+          "integrity": "sha512-TnErZpmuKdwWBdMoexjio3KKX6ZtoKHRVvLIU0A47R0VVBDtx3ZyOJDktgYixhoJokZTYTt1Z37OkO9pnGJa9Q==",
+          "requires": {
+            "ansi-escapes": "^4.3.2",
+            "chalk": "^4.1.2",
+            "consola": "^3.2.3",
+            "figures": "^3.2.0",
+            "markdown-table": "^2.0.0",
+            "pretty-time": "^1.1.0",
+            "std-env": "^3.7.0",
+            "wrap-ansi": "^7.0.0"
+          }
+        },
+        "wrap-ansi": {
+          "version": "7.0.0",
+          "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+          "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+          "requires": {
+            "ansi-styles": "^4.0.0",
+            "string-width": "^4.1.0",
+            "strip-ansi": "^6.0.0"
+          }
+        }
+      }
+    },
+    "@docusaurus/core": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/core/-/core-3.10.0.tgz",
+      "integrity": "sha512-mgLdQsO8xppnQZc3LPi+Mf+PkPeyxJeIx11AXAq/14fsaMefInQiMEZUUmrc7J+956G/f7MwE7tn8KZgi3iRcA==",
+      "requires": {
+        "@docusaurus/babel": "3.10.0",
+        "@docusaurus/bundler": "3.10.0",
+        "@docusaurus/logger": "3.10.0",
+        "@docusaurus/mdx-loader": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-common": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
+        "boxen": "^6.2.1",
+        "chalk": "^4.1.2",
+        "chokidar": "^3.5.3",
+        "cli-table3": "^0.6.3",
+        "combine-promises": "^1.1.0",
+        "commander": "^5.1.0",
+        "core-js": "^3.31.1",
+        "detect-port": "^1.5.1",
+        "escape-html": "^1.0.3",
+        "eta": "^2.2.0",
+        "eval": "^0.1.8",
+        "execa": "^5.1.1",
+        "fs-extra": "^11.1.1",
+        "html-tags": "^3.3.1",
+        "html-webpack-plugin": "^5.6.0",
+        "leven": "^3.1.0",
+        "lodash": "^4.17.21",
+        "open": "^8.4.0",
+        "p-map": "^4.0.0",
+        "prompts": "^2.4.2",
+        "react-helmet-async": "npm:@slorber/react-helmet-async@1.3.0",
+        "react-loadable": "npm:@docusaurus/react-loadable@6.0.0",
+        "react-loadable-ssr-addon-v5-slorber": "^1.0.3",
+        "react-router": "^5.3.4",
+        "react-router-config": "^5.1.1",
+        "react-router-dom": "^5.3.4",
+        "semver": "^7.5.4",
+        "serve-handler": "^6.1.7",
+        "tinypool": "^1.0.2",
+        "tslib": "^2.6.0",
+        "update-notifier": "^6.0.2",
+        "webpack": "^5.95.0",
+        "webpack-bundle-analyzer": "^4.10.2",
+        "webpack-dev-server": "^5.2.2",
+        "webpack-merge": "^6.0.1"
+      },
+      "dependencies": {
+        "semver": {
+          "version": "7.7.4",
+          "resolved": "https://registry.facebook.net/semver/-/semver-7.7.4.tgz",
+          "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA=="
+        }
+      }
+    },
+    "@docusaurus/cssnano-preset": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/cssnano-preset/-/cssnano-preset-3.10.0.tgz",
+      "integrity": "sha512-qzSshTO1DB3TYW+dPUal5KHM7XPc5YQfzF3Kdb2NDACJUyGbNcFtw3tGkCJlYwhNCRKbZcmwraKUS1i5dcHdGg==",
+      "requires": {
+        "cssnano-preset-advanced": "^6.1.2",
+        "postcss": "^8.5.4",
+        "postcss-sort-media-queries": "^5.2.0",
+        "tslib": "^2.6.0"
+      }
+    },
+    "@docusaurus/logger": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/logger/-/logger-3.10.0.tgz",
+      "integrity": "sha512-9jrZzFuBH1LDRlZ7cznAhCLmAZ3HSDqgwdrSSZdGHq9SPUOQgXXu8mnxe2ZRB9NS1PCpMTIOVUqDtZPIhMafZg==",
+      "requires": {
+        "chalk": "^4.1.2",
+        "tslib": "^2.6.0"
+      }
+    },
+    "@docusaurus/mdx-loader": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/mdx-loader/-/mdx-loader-3.10.0.tgz",
+      "integrity": "sha512-mQQV97080AH4PYNs087l202NMDqRopZA4mg5W76ZZyTFrmWhJ3mHg+8A+drJVENxw5/Q+wHMHLgsx+9z1nEs0A==",
+      "requires": {
+        "@docusaurus/logger": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
+        "@mdx-js/mdx": "^3.0.0",
+        "@slorber/remark-comment": "^1.0.0",
+        "escape-html": "^1.0.3",
+        "estree-util-value-to-estree": "^3.0.1",
+        "file-loader": "^6.2.0",
+        "fs-extra": "^11.1.1",
+        "image-size": "^2.0.2",
+        "mdast-util-mdx": "^3.0.0",
+        "mdast-util-to-string": "^4.0.0",
+        "rehype-raw": "^7.0.0",
+        "remark-directive": "^3.0.0",
+        "remark-emoji": "^4.0.0",
+        "remark-frontmatter": "^5.0.0",
+        "remark-gfm": "^4.0.0",
+        "stringify-object": "^3.3.0",
+        "tslib": "^2.6.0",
+        "unified": "^11.0.3",
+        "unist-util-visit": "^5.0.0",
+        "url-loader": "^4.1.1",
+        "vfile": "^6.0.1",
+        "webpack": "^5.88.1"
+      }
+    },
+    "@docusaurus/module-type-aliases": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/module-type-aliases/-/module-type-aliases-3.10.0.tgz",
+      "integrity": "sha512-/1O0Zg8w3DFrYX/I6Fbss7OJrtZw1QoyjDhegiFNHVi9A9Y0gQ3jUAytVxF6ywpAWpLyLxch8nN8H/V3XfzdJQ==",
+      "requires": {
+        "@docusaurus/types": "3.10.0",
+        "@types/history": "^4.7.11",
+        "@types/react": "*",
+        "@types/react-router-config": "*",
+        "@types/react-router-dom": "*",
+        "react-helmet-async": "npm:@slorber/react-helmet-async@1.3.0",
+        "react-loadable": "npm:@docusaurus/react-loadable@6.0.0"
+      }
+    },
+    "@docusaurus/plugin-content-blog": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/plugin-content-blog/-/plugin-content-blog-3.10.0.tgz",
+      "integrity": "sha512-RuTz68DhB7CL96QO5UsFbciD7GPYq6QV+YMfF9V0+N4ZgLhJIBgpVAr8GobrKF6NRe5cyWWETU5z5T834piG9g==",
+      "requires": {
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/logger": "3.10.0",
+        "@docusaurus/mdx-loader": "3.10.0",
+        "@docusaurus/theme-common": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-common": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
+        "cheerio": "1.0.0-rc.12",
+        "combine-promises": "^1.1.0",
+        "feed": "^4.2.2",
+        "fs-extra": "^11.1.1",
+        "lodash": "^4.17.21",
+        "schema-dts": "^1.1.2",
+        "srcset": "^4.0.0",
+        "tslib": "^2.6.0",
+        "unist-util-visit": "^5.0.0",
+        "utility-types": "^3.10.0",
+        "webpack": "^5.88.1"
+      }
+    },
+    "@docusaurus/plugin-content-docs": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/plugin-content-docs/-/plugin-content-docs-3.10.0.tgz",
+      "integrity": "sha512-9BjHhf15ct8Z7TThTC0xRndKDVvMKmVsAGAN7W9FpNRzfMdScOGcXtLmcCWtJGvAezjOJIm6CxOYCy3Io5+RnQ==",
+      "requires": {
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/logger": "3.10.0",
+        "@docusaurus/mdx-loader": "3.10.0",
+        "@docusaurus/module-type-aliases": "3.10.0",
+        "@docusaurus/theme-common": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-common": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
+        "@types/react-router-config": "^5.0.7",
+        "combine-promises": "^1.1.0",
+        "fs-extra": "^11.1.1",
+        "js-yaml": "^4.1.0",
+        "lodash": "^4.17.21",
+        "schema-dts": "^1.1.2",
+        "tslib": "^2.6.0",
+        "utility-types": "^3.10.0",
+        "webpack": "^5.88.1"
+      }
+    },
+    "@docusaurus/plugin-content-pages": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/plugin-content-pages/-/plugin-content-pages-3.10.0.tgz",
+      "integrity": "sha512-5amX8kEJI+nIGtuLVjYk59Y5utEJ3CHETFOPEE4cooIRLA4xM4iBsA6zFgu4ljcopeYwvBzFEWf5g2I6Yb9SkA==",
+      "requires": {
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/mdx-loader": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
+        "fs-extra": "^11.1.1",
+        "tslib": "^2.6.0",
+        "webpack": "^5.88.1"
+      }
+    },
+    "@docusaurus/plugin-css-cascade-layers": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/plugin-css-cascade-layers/-/plugin-css-cascade-layers-3.10.0.tgz",
+      "integrity": "sha512-6q1vtt5FJcg5osgkHeM1euErECNqEZ5Z1j69yiNx2luEBIso+nxCkS9nqj8w+MK5X7rvKEToGhFfOFWncs51pQ==",
+      "requires": {
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
+        "tslib": "^2.6.0"
+      }
+    },
+    "@docusaurus/plugin-debug": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/plugin-debug/-/plugin-debug-3.10.0.tgz",
+      "integrity": "sha512-XcljKN+G+nmmK69uQA1d9BlYU3ZftG3T3zpK8/7Hf/wrOlV7TA4Ampdrdwkg0jElKdKAoSnPhCO0/U3bQGsVQQ==",
+      "requires": {
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "fs-extra": "^11.1.1",
+        "react-json-view-lite": "^2.3.0",
+        "tslib": "^2.6.0"
+      }
+    },
+    "@docusaurus/plugin-google-analytics": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/plugin-google-analytics/-/plugin-google-analytics-3.10.0.tgz",
+      "integrity": "sha512-hTEoodatpBZnUat5nFExbuTGA1lhWGy7vZGuTew5Q3QDtGKFpSJLYmZJhdTjvCFwv1+qQ67hgAVlKdJOB8TXow==",
+      "requires": {
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
+        "tslib": "^2.6.0"
+      }
+    },
+    "@docusaurus/plugin-google-gtag": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/plugin-google-gtag/-/plugin-google-gtag-3.10.0.tgz",
+      "integrity": "sha512-iB/Zzjv/eelJRbdULZqzWCbgMgJ7ht4ONVjXtN3+BI/muil6S87gQ1OJyPwlXD+ELdKkitC7bWv5eJdYOZLhrQ==",
+      "requires": {
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
+        "@types/gtag.js": "^0.0.20",
+        "tslib": "^2.6.0"
+      }
+    },
+    "@docusaurus/plugin-google-tag-manager": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/plugin-google-tag-manager/-/plugin-google-tag-manager-3.10.0.tgz",
+      "integrity": "sha512-FEjZxqKgLHa+Wez/EgKxRwvArNCWIScfyEQD95rot7jkxp6nonjI5XIbGfO/iYhM5Qinwe8aIEQHP2KZtpqVuA==",
+      "requires": {
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
+        "tslib": "^2.6.0"
+      }
+    },
+    "@docusaurus/plugin-sitemap": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/plugin-sitemap/-/plugin-sitemap-3.10.0.tgz",
+      "integrity": "sha512-DVTSLjB97hIjmayGnGcBfognCeI7ZuUKgEnU7Oz81JYqXtVg94mVTthDjq3QHTylYNeCUbkaW8VF0FDLcc8pPw==",
+      "requires": {
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/logger": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-common": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
+        "fs-extra": "^11.1.1",
+        "sitemap": "^7.1.1",
+        "tslib": "^2.6.0"
+      }
+    },
+    "@docusaurus/plugin-svgr": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/plugin-svgr/-/plugin-svgr-3.10.0.tgz",
+      "integrity": "sha512-lNljBESaETZqVBMPqkrGchr+UPT1eZzEPLmJhz8I76BxbjqgsUnRvrq6lQJ9sYjgmgX52KB7kkgczqd2yzoswQ==",
+      "requires": {
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
+        "@svgr/core": "8.1.0",
+        "@svgr/webpack": "^8.1.0",
+        "tslib": "^2.6.0",
+        "webpack": "^5.88.1"
+      }
+    },
+    "@docusaurus/preset-classic": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/preset-classic/-/preset-classic-3.10.0.tgz",
+      "integrity": "sha512-kw/Ye02Hc6xP1OdTswy8yxQEHg0fdPpyWAQRxr5b2x3h7LlG2Zgbb5BDFROnXDDMpUxB7YejlocJIE5HIEfpNA==",
+      "requires": {
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/plugin-content-blog": "3.10.0",
+        "@docusaurus/plugin-content-docs": "3.10.0",
+        "@docusaurus/plugin-content-pages": "3.10.0",
+        "@docusaurus/plugin-css-cascade-layers": "3.10.0",
+        "@docusaurus/plugin-debug": "3.10.0",
+        "@docusaurus/plugin-google-analytics": "3.10.0",
+        "@docusaurus/plugin-google-gtag": "3.10.0",
+        "@docusaurus/plugin-google-tag-manager": "3.10.0",
+        "@docusaurus/plugin-sitemap": "3.10.0",
+        "@docusaurus/plugin-svgr": "3.10.0",
+        "@docusaurus/theme-classic": "3.10.0",
+        "@docusaurus/theme-common": "3.10.0",
+        "@docusaurus/theme-search-algolia": "3.10.0",
+        "@docusaurus/types": "3.10.0"
+      }
+    },
+    "@docusaurus/theme-classic": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/theme-classic/-/theme-classic-3.10.0.tgz",
+      "integrity": "sha512-9msCAsRdN+UG+RwPwCFb0uKy4tGoPh5YfBozXeGUtIeAgsMdn6f3G/oY861luZ3t8S2ET8S9Y/1GnpJAGWytww==",
+      "requires": {
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/logger": "3.10.0",
+        "@docusaurus/mdx-loader": "3.10.0",
+        "@docusaurus/module-type-aliases": "3.10.0",
+        "@docusaurus/plugin-content-blog": "3.10.0",
+        "@docusaurus/plugin-content-docs": "3.10.0",
+        "@docusaurus/plugin-content-pages": "3.10.0",
+        "@docusaurus/theme-common": "3.10.0",
+        "@docusaurus/theme-translations": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-common": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
+        "@mdx-js/react": "^3.0.0",
+        "clsx": "^2.0.0",
+        "copy-text-to-clipboard": "^3.2.0",
+        "infima": "0.2.0-alpha.45",
+        "lodash": "^4.17.21",
+        "nprogress": "^0.2.0",
+        "postcss": "^8.5.4",
+        "prism-react-renderer": "^2.3.0",
+        "prismjs": "^1.29.0",
+        "react-router-dom": "^5.3.4",
+        "rtlcss": "^4.1.0",
+        "tslib": "^2.6.0",
+        "utility-types": "^3.10.0"
+      }
+    },
+    "@docusaurus/theme-common": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/theme-common/-/theme-common-3.10.0.tgz",
+      "integrity": "sha512-Dkp1YXKn16ByCJAdIjbDIOpVb4Z66MsVD694/ilX1vAAHaVEMrVsf/NPd9VgreyFx08rJ9GqV1MtzsbTcU73Kg==",
+      "requires": {
+        "@docusaurus/mdx-loader": "3.10.0",
+        "@docusaurus/module-type-aliases": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-common": "3.10.0",
+        "@types/history": "^4.7.11",
+        "@types/react": "*",
+        "@types/react-router-config": "*",
+        "clsx": "^2.0.0",
+        "parse-numeric-range": "^1.3.0",
+        "prism-react-renderer": "^2.3.0",
+        "tslib": "^2.6.0",
+        "utility-types": "^3.10.0"
+      }
+    },
+    "@docusaurus/theme-search-algolia": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/theme-search-algolia/-/theme-search-algolia-3.10.0.tgz",
+      "integrity": "sha512-f5FPKI08e3JRG63vR/o4qeuUVHUHzFzM0nnF+AkB67soAZgNsKJRf2qmUZvlQkGwlV+QFkKe4D0ANMh1jToU3g==",
+      "requires": {
+        "@algolia/autocomplete-core": "^1.19.2",
+        "@docsearch/react": "^3.9.0 || ^4.3.2",
+        "@docusaurus/core": "3.10.0",
+        "@docusaurus/logger": "3.10.0",
+        "@docusaurus/plugin-content-docs": "3.10.0",
+        "@docusaurus/theme-common": "3.10.0",
+        "@docusaurus/theme-translations": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-validation": "3.10.0",
+        "algoliasearch": "^5.37.0",
+        "algoliasearch-helper": "^3.26.0",
+        "clsx": "^2.0.0",
+        "eta": "^2.2.0",
+        "fs-extra": "^11.1.1",
+        "lodash": "^4.17.21",
+        "tslib": "^2.6.0",
+        "utility-types": "^3.10.0"
+      }
+    },
+    "@docusaurus/theme-translations": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/theme-translations/-/theme-translations-3.10.0.tgz",
+      "integrity": "sha512-L9IbFLwTc5+XdgH45iQYufLn0SVZd6BUNelDbKIFlH+E4hhjuj/XHWAFMX/w2K59rfy8wak9McOaei7BSUfRPA==",
+      "requires": {
+        "fs-extra": "^11.1.1",
+        "tslib": "^2.6.0"
+      }
+    },
+    "@docusaurus/types": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/types/-/types-3.10.0.tgz",
+      "integrity": "sha512-F0dOt3FOoO20rRaFK7whGFQZ3ggyrWEdQc/c8/UiRuzhtg4y1w9FspXH5zpCT07uMnJKBPGh+qNazbNlCQqvSw==",
+      "requires": {
+        "@mdx-js/mdx": "^3.0.0",
+        "@types/history": "^4.7.11",
+        "@types/mdast": "^4.0.2",
+        "@types/react": "*",
+        "commander": "^5.1.0",
+        "joi": "^17.9.2",
+        "react-helmet-async": "npm:@slorber/react-helmet-async@1.3.0",
+        "utility-types": "^3.10.0",
+        "webpack": "^5.95.0",
+        "webpack-merge": "^5.9.0"
+      },
+      "dependencies": {
+        "webpack-merge": {
+          "version": "5.10.0",
+          "resolved": "https://registry.facebook.net/webpack-merge/-/webpack-merge-5.10.0.tgz",
+          "integrity": "sha512-+4zXKdx7UnO+1jaN4l2lHVD+mFvnlZQP/6ljaJVb4SZiwIKeUnrT5l0gkT8z+n4hKpC+jpOv6O9R+gLtag7pSA==",
+          "requires": {
+            "clone-deep": "^4.0.1",
+            "flat": "^5.0.2",
+            "wildcard": "^2.0.0"
+          }
+        }
+      }
+    },
+    "@docusaurus/utils": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/utils/-/utils-3.10.0.tgz",
+      "integrity": "sha512-T3B0WTigsIthe0D4LQa2k+7bJY+c3WS+Wq2JhcznOSpn1lSN64yNtHQXboCj3QnUs1EuAZszQG1SHKu5w5ZrlA==",
+      "requires": {
+        "@docusaurus/logger": "3.10.0",
+        "@docusaurus/types": "3.10.0",
+        "@docusaurus/utils-common": "3.10.0",
+        "escape-string-regexp": "^4.0.0",
+        "execa": "^5.1.1",
+        "file-loader": "^6.2.0",
+        "fs-extra": "^11.1.1",
+        "github-slugger": "^1.5.0",
+        "globby": "^11.1.0",
+        "gray-matter": "^4.0.3",
+        "jiti": "^1.20.0",
+        "js-yaml": "^4.1.0",
+        "lodash": "^4.17.21",
+        "micromatch": "^4.0.5",
+        "p-queue": "^6.6.2",
+        "prompts": "^2.4.2",
+        "resolve-pathname": "^3.0.0",
+        "tslib": "^2.6.0",
+        "url-loader": "^4.1.1",
+        "utility-types": "^3.10.0",
+        "webpack": "^5.88.1"
+      }
+    },
+    "@docusaurus/utils-common": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/utils-common/-/utils-common-3.10.0.tgz",
+      "integrity": "sha512-JyL7sb9QVDgYvudIS81Dv0lsWm7le0vGZSDwsztxWam1SPBqrnkvBy9UYL/amh6pbybkyYTd3CMTkO24oMlCSw==",
+      "requires": {
+        "@docusaurus/types": "3.10.0",
+        "tslib": "^2.6.0"
+      }
+    },
+    "@docusaurus/utils-validation": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/utils-validation/-/utils-validation-3.10.0.tgz",
+      "integrity": "sha512-c+6n2+ZPOJtWWc8Bb/EYdpSDfjYEScdCu9fB/SNjOmSCf1IdVnGf2T53o0tsz0gDRtCL90tifTL0JE/oMuP1Mw==",
+      "requires": {
+        "@docusaurus/logger": "3.10.0",
+        "@docusaurus/utils": "3.10.0",
+        "@docusaurus/utils-common": "3.10.0",
+        "fs-extra": "^11.2.0",
+        "joi": "^17.9.2",
+        "js-yaml": "^4.1.0",
+        "lodash": "^4.17.21",
+        "tslib": "^2.6.0"
+      }
+    },
+    "@hapi/hoek": {
+      "version": "9.3.0",
+      "resolved": "https://registry.facebook.net/@hapi/hoek/-/hoek-9.3.0.tgz",
+      "integrity": "sha512-/c6rf4UJlmHlC9b5BaNvzAcFv7HZ2QHaV0D4/HNlBdvFnvQq8RI4kYdhyPCl7Xj+oWvTWQ8ujhqS53LIgAe6KQ=="
+    },
+    "@hapi/topo": {
+      "version": "5.1.0",
+      "resolved": "https://registry.facebook.net/@hapi/topo/-/topo-5.1.0.tgz",
+      "integrity": "sha512-foQZKJig7Ob0BMAYBfcJk8d77QtOe7Wo4ox7ff1lQYoNNAb6jwcY1ncdoy2e9wQZzvNy7ODZCYJkK8kzmcAnAg==",
+      "requires": {
+        "@hapi/hoek": "^9.0.0"
+      }
+    },
+    "@jest/schemas": {
+      "version": "29.6.3",
+      "resolved": "https://registry.facebook.net/@jest/schemas/-/schemas-29.6.3.tgz",
+      "integrity": "sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==",
+      "requires": {
+        "@sinclair/typebox": "^0.27.8"
+      }
+    },
+    "@jest/types": {
+      "version": "29.6.3",
+      "resolved": "https://registry.facebook.net/@jest/types/-/types-29.6.3.tgz",
+      "integrity": "sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw==",
+      "requires": {
+        "@jest/schemas": "^29.6.3",
+        "@types/istanbul-lib-coverage": "^2.0.0",
+        "@types/istanbul-reports": "^3.0.0",
+        "@types/node": "*",
+        "@types/yargs": "^17.0.8",
+        "chalk": "^4.0.0"
+      }
+    },
+    "@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.facebook.net/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "requires": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.facebook.net/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "requires": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.facebook.net/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw=="
+    },
+    "@jridgewell/source-map": {
+      "version": "0.3.11",
+      "resolved": "https://registry.facebook.net/@jridgewell/source-map/-/source-map-0.3.11.tgz",
+      "integrity": "sha512-ZMp1V8ZFcPG5dIWnQLr3NSI1MiCU7UETdS/A0G8V/XWHvJv3ZsFqutJn1Y5RPmAPX6F3BiE397OqveU/9NCuIA==",
+      "requires": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.25"
+      }
+    },
+    "@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.facebook.net/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og=="
+    },
+    "@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.facebook.net/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "requires": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "@jsonjoy.com/base64": {
+      "version": "1.1.2",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/base64/-/base64-1.1.2.tgz",
+      "integrity": "sha512-q6XAnWQDIMA3+FTiOYajoYqySkO+JSat0ytXGSuRdq9uXE7o92gzuQwQM14xaCRlBLGq3v5miDGC4vkVTn54xA==",
+      "requires": {}
+    },
+    "@jsonjoy.com/buffers": {
+      "version": "17.67.0",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/buffers/-/buffers-17.67.0.tgz",
+      "integrity": "sha512-tfExRpYxBvi32vPs9ZHaTjSP4fHAfzSmcahOfNxtvGHcyJel+aibkPlGeBB+7AoC6hL7lXIE++8okecBxx7lcw==",
+      "requires": {}
+    },
+    "@jsonjoy.com/codegen": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/codegen/-/codegen-1.0.0.tgz",
+      "integrity": "sha512-E8Oy+08cmCf0EK/NMxpaJZmOxPqM+6iSe2S4nlSBrPZOORoDJILxtbSUEDKQyTamm/BVAhIGllOBNU79/dwf0g==",
+      "requires": {}
+    },
+    "@jsonjoy.com/fs-core": {
+      "version": "4.57.2",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/fs-core/-/fs-core-4.57.2.tgz",
+      "integrity": "sha512-SVjwklkpIV5wrynpYtuYnfYH1QF4/nDuLBX7VXdb+3miglcAgBVZb/5y0cOsehRV/9Vb+3UqhkMq3/NR3ztdkQ==",
+      "requires": {
+        "@jsonjoy.com/fs-node-builtins": "4.57.2",
+        "@jsonjoy.com/fs-node-utils": "4.57.2",
+        "thingies": "^2.5.0"
+      }
+    },
+    "@jsonjoy.com/fs-fsa": {
+      "version": "4.57.2",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/fs-fsa/-/fs-fsa-4.57.2.tgz",
+      "integrity": "sha512-fhO8+iR2I+OCw668ISDJdn1aArc9zx033sWejIyzQ8RBeXa9bDSaUeA3ix0poYOfrj1KdOzytmYNv2/uLDfV6g==",
+      "requires": {
+        "@jsonjoy.com/fs-core": "4.57.2",
+        "@jsonjoy.com/fs-node-builtins": "4.57.2",
+        "@jsonjoy.com/fs-node-utils": "4.57.2",
+        "thingies": "^2.5.0"
+      }
+    },
+    "@jsonjoy.com/fs-node": {
+      "version": "4.57.2",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/fs-node/-/fs-node-4.57.2.tgz",
+      "integrity": "sha512-nX2AdL6cOFwLdju9G4/nbRnYevmCJbh7N7hvR3gGm97Cs60uEjyd0rpR+YBS7cTg175zzl22pGKXR5USaQMvKg==",
+      "requires": {
+        "@jsonjoy.com/fs-core": "4.57.2",
+        "@jsonjoy.com/fs-node-builtins": "4.57.2",
+        "@jsonjoy.com/fs-node-utils": "4.57.2",
+        "@jsonjoy.com/fs-print": "4.57.2",
+        "@jsonjoy.com/fs-snapshot": "4.57.2",
+        "glob-to-regex.js": "^1.0.0",
+        "thingies": "^2.5.0"
+      }
+    },
+    "@jsonjoy.com/fs-node-builtins": {
+      "version": "4.57.2",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/fs-node-builtins/-/fs-node-builtins-4.57.2.tgz",
+      "integrity": "sha512-xhiegylRmhw43Ki2HO1ZBL7DQ5ja/qpRsL29VtQ2xuUHiuDGbgf2uD4p9Qd8hJI5P6RCtGYD50IXHXVq/Ocjcg==",
+      "requires": {}
+    },
+    "@jsonjoy.com/fs-node-to-fsa": {
+      "version": "4.57.2",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/fs-node-to-fsa/-/fs-node-to-fsa-4.57.2.tgz",
+      "integrity": "sha512-18LmWTSONhoAPW+IWRuf8w/+zRolPFGPeGwMxlAhhfY11EKzX+5XHDBPAw67dBF5dxDErHJbl40U+3IXSDRXSQ==",
+      "requires": {
+        "@jsonjoy.com/fs-fsa": "4.57.2",
+        "@jsonjoy.com/fs-node-builtins": "4.57.2",
+        "@jsonjoy.com/fs-node-utils": "4.57.2"
+      }
+    },
+    "@jsonjoy.com/fs-node-utils": {
+      "version": "4.57.2",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/fs-node-utils/-/fs-node-utils-4.57.2.tgz",
+      "integrity": "sha512-rsPSJgekz43IlNbLyAM/Ab+ouYLWGp5DDBfYBNNEqDaSpsbXfthBn29Q4muFA9L0F+Z3mKo+CWlgSCXrf+mOyQ==",
+      "requires": {
+        "@jsonjoy.com/fs-node-builtins": "4.57.2"
+      }
+    },
+    "@jsonjoy.com/fs-print": {
+      "version": "4.57.2",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/fs-print/-/fs-print-4.57.2.tgz",
+      "integrity": "sha512-wK9NSow48i4DbDl9F1CQE5TqnyZOJ04elU3WFG5aJ76p+YxO/ulyBBQvKsessPxdo381Bc2pcEoyPujMOhcRqQ==",
+      "requires": {
+        "@jsonjoy.com/fs-node-utils": "4.57.2",
+        "tree-dump": "^1.1.0"
+      }
+    },
+    "@jsonjoy.com/fs-snapshot": {
+      "version": "4.57.2",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/fs-snapshot/-/fs-snapshot-4.57.2.tgz",
+      "integrity": "sha512-GdduDZuoP5V/QCgJkx9+BZ6SC0EZ/smXAdTS7PfMqgMTGXLlt/bH/FqMYaqB9JmLf05sJPtO0XRbAwwkEEPbVw==",
+      "requires": {
+        "@jsonjoy.com/buffers": "^17.65.0",
+        "@jsonjoy.com/fs-node-utils": "4.57.2",
+        "@jsonjoy.com/json-pack": "^17.65.0",
+        "@jsonjoy.com/util": "^17.65.0"
+      },
+      "dependencies": {
+        "@jsonjoy.com/base64": {
+          "version": "17.67.0",
+          "resolved": "https://registry.facebook.net/@jsonjoy.com/base64/-/base64-17.67.0.tgz",
+          "integrity": "sha512-5SEsJGsm15aP8TQGkDfJvz9axgPwAEm98S5DxOuYe8e1EbfajcDmgeXXzccEjh+mLnjqEKrkBdjHWS5vFNwDdw==",
+          "requires": {}
+        },
+        "@jsonjoy.com/codegen": {
+          "version": "17.67.0",
+          "resolved": "https://registry.facebook.net/@jsonjoy.com/codegen/-/codegen-17.67.0.tgz",
+          "integrity": "sha512-idnkUplROpdBOV0HMcwhsCUS5TRUi9poagdGs70A6S4ux9+/aPuKbh8+UYRTLYQHtXvAdNfQWXDqZEx5k4Dj2Q==",
+          "requires": {}
+        },
+        "@jsonjoy.com/json-pack": {
+          "version": "17.67.0",
+          "resolved": "https://registry.facebook.net/@jsonjoy.com/json-pack/-/json-pack-17.67.0.tgz",
+          "integrity": "sha512-t0ejURcGaZsn1ClbJ/3kFqSOjlryd92eQY465IYrezsXmPcfHPE/av4twRSxf6WE+TkZgLY+71vCZbiIiFKA/w==",
+          "requires": {
+            "@jsonjoy.com/base64": "17.67.0",
+            "@jsonjoy.com/buffers": "17.67.0",
+            "@jsonjoy.com/codegen": "17.67.0",
+            "@jsonjoy.com/json-pointer": "17.67.0",
+            "@jsonjoy.com/util": "17.67.0",
+            "hyperdyperid": "^1.2.0",
+            "thingies": "^2.5.0",
+            "tree-dump": "^1.1.0"
+          }
+        },
+        "@jsonjoy.com/json-pointer": {
+          "version": "17.67.0",
+          "resolved": "https://registry.facebook.net/@jsonjoy.com/json-pointer/-/json-pointer-17.67.0.tgz",
+          "integrity": "sha512-+iqOFInH+QZGmSuaybBUNdh7yvNrXvqR+h3wjXm0N/3JK1EyyFAeGJvqnmQL61d1ARLlk/wJdFKSL+LHJ1eaUA==",
+          "requires": {
+            "@jsonjoy.com/util": "17.67.0"
+          }
+        },
+        "@jsonjoy.com/util": {
+          "version": "17.67.0",
+          "resolved": "https://registry.facebook.net/@jsonjoy.com/util/-/util-17.67.0.tgz",
+          "integrity": "sha512-6+8xBaz1rLSohlGh68D1pdw3AwDi9xydm8QNlAFkvnavCJYSze+pxoW2VKP8p308jtlMRLs5NTHfPlZLd4w7ew==",
+          "requires": {
+            "@jsonjoy.com/buffers": "17.67.0",
+            "@jsonjoy.com/codegen": "17.67.0"
+          }
+        }
+      }
+    },
+    "@jsonjoy.com/json-pack": {
+      "version": "1.21.0",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/json-pack/-/json-pack-1.21.0.tgz",
+      "integrity": "sha512-+AKG+R2cfZMShzrF2uQw34v3zbeDYUqnQ+jg7ORic3BGtfw9p/+N6RJbq/kkV8JmYZaINknaEQ2m0/f693ZPpg==",
+      "requires": {
+        "@jsonjoy.com/base64": "^1.1.2",
+        "@jsonjoy.com/buffers": "^1.2.0",
+        "@jsonjoy.com/codegen": "^1.0.0",
+        "@jsonjoy.com/json-pointer": "^1.0.2",
+        "@jsonjoy.com/util": "^1.9.0",
+        "hyperdyperid": "^1.2.0",
+        "thingies": "^2.5.0",
+        "tree-dump": "^1.1.0"
+      },
+      "dependencies": {
+        "@jsonjoy.com/buffers": {
+          "version": "1.2.1",
+          "resolved": "https://registry.facebook.net/@jsonjoy.com/buffers/-/buffers-1.2.1.tgz",
+          "integrity": "sha512-12cdlDwX4RUM3QxmUbVJWqZ/mrK6dFQH4Zxq6+r1YXKXYBNgZXndx2qbCJwh3+WWkCSn67IjnlG3XYTvmvYtgA==",
+          "requires": {}
+        }
+      }
+    },
+    "@jsonjoy.com/json-pointer": {
+      "version": "1.0.2",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/json-pointer/-/json-pointer-1.0.2.tgz",
+      "integrity": "sha512-Fsn6wM2zlDzY1U+v4Nc8bo3bVqgfNTGcn6dMgs6FjrEnt4ZCe60o6ByKRjOGlI2gow0aE/Q41QOigdTqkyK5fg==",
+      "requires": {
+        "@jsonjoy.com/codegen": "^1.0.0",
+        "@jsonjoy.com/util": "^1.9.0"
+      }
+    },
+    "@jsonjoy.com/util": {
+      "version": "1.9.0",
+      "resolved": "https://registry.facebook.net/@jsonjoy.com/util/-/util-1.9.0.tgz",
+      "integrity": "sha512-pLuQo+VPRnN8hfPqUTLTHk126wuYdXVxE6aDmjSeV4NCAgyxWbiOIeNJVtID3h1Vzpoi9m4jXezf73I6LgabgQ==",
+      "requires": {
+        "@jsonjoy.com/buffers": "^1.0.0",
+        "@jsonjoy.com/codegen": "^1.0.0"
+      },
+      "dependencies": {
+        "@jsonjoy.com/buffers": {
+          "version": "1.2.1",
+          "resolved": "https://registry.facebook.net/@jsonjoy.com/buffers/-/buffers-1.2.1.tgz",
+          "integrity": "sha512-12cdlDwX4RUM3QxmUbVJWqZ/mrK6dFQH4Zxq6+r1YXKXYBNgZXndx2qbCJwh3+WWkCSn67IjnlG3XYTvmvYtgA==",
+          "requires": {}
+        }
+      }
+    },
+    "@leichtgewicht/ip-codec": {
+      "version": "2.0.5",
+      "resolved": "https://registry.facebook.net/@leichtgewicht/ip-codec/-/ip-codec-2.0.5.tgz",
+      "integrity": "sha512-Vo+PSpZG2/fmgmiNzYK9qWRh8h/CHrwD0mo1h1DzL4yzHNSfWYujGTYsWGreD000gcgmZ7K4Ys6Tx9TxtsKdDw=="
+    },
+    "@mdx-js/mdx": {
+      "version": "3.1.1",
+      "resolved": "https://registry.facebook.net/@mdx-js/mdx/-/mdx-3.1.1.tgz",
+      "integrity": "sha512-f6ZO2ifpwAQIpzGWaBQT2TXxPv6z3RBzQKpVftEWN78Vl/YweF1uwussDx8ECAXVtr3Rs89fKyG9YlzUs9DyGQ==",
+      "requires": {
+        "@types/estree": "^1.0.0",
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/mdx": "^2.0.0",
+        "acorn": "^8.0.0",
+        "collapse-white-space": "^2.0.0",
+        "devlop": "^1.0.0",
+        "estree-util-is-identifier-name": "^3.0.0",
+        "estree-util-scope": "^1.0.0",
+        "estree-walker": "^3.0.0",
+        "hast-util-to-jsx-runtime": "^2.0.0",
+        "markdown-extensions": "^2.0.0",
+        "recma-build-jsx": "^1.0.0",
+        "recma-jsx": "^1.0.0",
+        "recma-stringify": "^1.0.0",
+        "rehype-recma": "^1.0.0",
+        "remark-mdx": "^3.0.0",
+        "remark-parse": "^11.0.0",
+        "remark-rehype": "^11.0.0",
+        "source-map": "^0.7.0",
+        "unified": "^11.0.0",
+        "unist-util-position-from-estree": "^2.0.0",
+        "unist-util-stringify-position": "^4.0.0",
+        "unist-util-visit": "^5.0.0",
+        "vfile": "^6.0.0"
+      },
+      "dependencies": {
+        "source-map": {
+          "version": "0.7.6",
+          "resolved": "https://registry.facebook.net/source-map/-/source-map-0.7.6.tgz",
+          "integrity": "sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ=="
+        }
+      }
+    },
+    "@mdx-js/react": {
+      "version": "3.1.1",
+      "resolved": "https://registry.facebook.net/@mdx-js/react/-/react-3.1.1.tgz",
+      "integrity": "sha512-f++rKLQgUVYDAtECQ6fn/is15GkEH9+nZPM3MS0RcxVqoTfawHvDlSCH7JbMhAM6uJ32v3eXLvLmLvjGu7PTQw==",
+      "requires": {
+        "@types/mdx": "^2.0.0"
+      }
+    },
+    "@noble/hashes": {
+      "version": "1.4.0",
+      "resolved": "https://registry.facebook.net/@noble/hashes/-/hashes-1.4.0.tgz",
+      "integrity": "sha512-V1JJ1WTRUqHHrOSh597hURcMqVKVGL/ea3kv0gSnEdsEZ0/+VyPghM1lMNGc00z7CIQorSvbKpuJkxvuHbvdbg=="
+    },
+    "@nodelib/fs.scandir": {
+      "version": "2.1.5",
+      "resolved": "https://registry.facebook.net/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
+      "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
+      "requires": {
+        "@nodelib/fs.stat": "2.0.5",
+        "run-parallel": "^1.1.9"
+      }
+    },
+    "@nodelib/fs.stat": {
+      "version": "2.0.5",
+      "resolved": "https://registry.facebook.net/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
+      "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A=="
+    },
+    "@nodelib/fs.walk": {
+      "version": "1.2.8",
+      "resolved": "https://registry.facebook.net/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
+      "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
+      "requires": {
+        "@nodelib/fs.scandir": "2.1.5",
+        "fastq": "^1.6.0"
+      }
+    },
+    "@peculiar/asn1-cms": {
+      "version": "2.6.1",
+      "resolved": "https://registry.facebook.net/@peculiar/asn1-cms/-/asn1-cms-2.6.1.tgz",
+      "integrity": "sha512-vdG4fBF6Lkirkcl53q6eOdn3XYKt+kJTG59edgRZORlg/3atWWEReRCx5rYE1ZzTTX6vLK5zDMjHh7vbrcXGtw==",
+      "requires": {
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.1",
+        "@peculiar/asn1-x509-attr": "^2.6.1",
+        "asn1js": "^3.0.6",
+        "tslib": "^2.8.1"
+      }
+    },
+    "@peculiar/asn1-csr": {
+      "version": "2.6.1",
+      "resolved": "https://registry.facebook.net/@peculiar/asn1-csr/-/asn1-csr-2.6.1.tgz",
+      "integrity": "sha512-WRWnKfIocHyzFYQTka8O/tXCiBquAPSrRjXbOkHbO4qdmS6loffCEGs+rby6WxxGdJCuunnhS2duHURhjyio6w==",
+      "requires": {
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.1",
+        "asn1js": "^3.0.6",
+        "tslib": "^2.8.1"
+      }
+    },
+    "@peculiar/asn1-ecc": {
+      "version": "2.6.1",
+      "resolved": "https://registry.facebook.net/@peculiar/asn1-ecc/-/asn1-ecc-2.6.1.tgz",
+      "integrity": "sha512-+Vqw8WFxrtDIN5ehUdvlN2m73exS2JVG0UAyfVB31gIfor3zWEAQPD+K9ydCxaj3MLen9k0JhKpu9LqviuCE1g==",
+      "requires": {
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.1",
+        "asn1js": "^3.0.6",
+        "tslib": "^2.8.1"
+      }
+    },
+    "@peculiar/asn1-pfx": {
+      "version": "2.6.1",
+      "resolved": "https://registry.facebook.net/@peculiar/asn1-pfx/-/asn1-pfx-2.6.1.tgz",
+      "integrity": "sha512-nB5jVQy3MAAWvq0KY0R2JUZG8bO/bTLpnwyOzXyEh/e54ynGTatAR+csOnXkkVD9AFZ2uL8Z7EV918+qB1qDvw==",
+      "requires": {
+        "@peculiar/asn1-cms": "^2.6.1",
+        "@peculiar/asn1-pkcs8": "^2.6.1",
+        "@peculiar/asn1-rsa": "^2.6.1",
+        "@peculiar/asn1-schema": "^2.6.0",
+        "asn1js": "^3.0.6",
+        "tslib": "^2.8.1"
+      }
+    },
+    "@peculiar/asn1-pkcs8": {
+      "version": "2.6.1",
+      "resolved": "https://registry.facebook.net/@peculiar/asn1-pkcs8/-/asn1-pkcs8-2.6.1.tgz",
+      "integrity": "sha512-JB5iQ9Izn5yGMw3ZG4Nw3Xn/hb/G38GYF3lf7WmJb8JZUydhVGEjK/ZlFSWhnlB7K/4oqEs8HnfFIKklhR58Tw==",
+      "requires": {
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.1",
+        "asn1js": "^3.0.6",
+        "tslib": "^2.8.1"
+      }
+    },
+    "@peculiar/asn1-pkcs9": {
+      "version": "2.6.1",
+      "resolved": "https://registry.facebook.net/@peculiar/asn1-pkcs9/-/asn1-pkcs9-2.6.1.tgz",
+      "integrity": "sha512-5EV8nZoMSxeWmcxWmmcolg22ojZRgJg+Y9MX2fnE2bGRo5KQLqV5IL9kdSQDZxlHz95tHvIq9F//bvL1OeNILw==",
+      "requires": {
+        "@peculiar/asn1-cms": "^2.6.1",
+        "@peculiar/asn1-pfx": "^2.6.1",
+        "@peculiar/asn1-pkcs8": "^2.6.1",
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.1",
+        "@peculiar/asn1-x509-attr": "^2.6.1",
+        "asn1js": "^3.0.6",
+        "tslib": "^2.8.1"
+      }
+    },
+    "@peculiar/asn1-rsa": {
+      "version": "2.6.1",
+      "resolved": "https://registry.facebook.net/@peculiar/asn1-rsa/-/asn1-rsa-2.6.1.tgz",
+      "integrity": "sha512-1nVMEh46SElUt5CB3RUTV4EG/z7iYc7EoaDY5ECwganibQPkZ/Y2eMsTKB/LeyrUJ+W/tKoD9WUqIy8vB+CEdA==",
+      "requires": {
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.1",
+        "asn1js": "^3.0.6",
+        "tslib": "^2.8.1"
+      }
+    },
+    "@peculiar/asn1-schema": {
+      "version": "2.6.0",
+      "resolved": "https://registry.facebook.net/@peculiar/asn1-schema/-/asn1-schema-2.6.0.tgz",
+      "integrity": "sha512-xNLYLBFTBKkCzEZIw842BxytQQATQv+lDTCEMZ8C196iJcJJMBUZxrhSTxLaohMyKK8QlzRNTRkUmanucnDSqg==",
+      "requires": {
+        "asn1js": "^3.0.6",
+        "pvtsutils": "^1.3.6",
+        "tslib": "^2.8.1"
+      }
+    },
+    "@peculiar/asn1-x509": {
+      "version": "2.6.1",
+      "resolved": "https://registry.facebook.net/@peculiar/asn1-x509/-/asn1-x509-2.6.1.tgz",
+      "integrity": "sha512-O9jT5F1A2+t3r7C4VT7LYGXqkGLK7Kj1xFpz7U0isPrubwU5PbDoyYtx6MiGst29yq7pXN5vZbQFKRCP+lLZlA==",
+      "requires": {
+        "@peculiar/asn1-schema": "^2.6.0",
+        "asn1js": "^3.0.6",
+        "pvtsutils": "^1.3.6",
+        "tslib": "^2.8.1"
+      }
+    },
+    "@peculiar/asn1-x509-attr": {
+      "version": "2.6.1",
+      "resolved": "https://registry.facebook.net/@peculiar/asn1-x509-attr/-/asn1-x509-attr-2.6.1.tgz",
+      "integrity": "sha512-tlW6cxoHwgcQghnJwv3YS+9OO1737zgPogZ+CgWRUK4roEwIPzRH4JEiG770xe5HX2ATfCpmX60gurfWIF9dcQ==",
+      "requires": {
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.1",
+        "asn1js": "^3.0.6",
+        "tslib": "^2.8.1"
+      }
+    },
+    "@peculiar/x509": {
+      "version": "1.14.3",
+      "resolved": "https://registry.facebook.net/@peculiar/x509/-/x509-1.14.3.tgz",
+      "integrity": "sha512-C2Xj8FZ0uHWeCXXqX5B4/gVFQmtSkiuOolzAgutjTfseNOHT3pUjljDZsTSxXFGgio54bCzVFqmEOUrIVk8RDA==",
+      "requires": {
+        "@peculiar/asn1-cms": "^2.6.0",
+        "@peculiar/asn1-csr": "^2.6.0",
+        "@peculiar/asn1-ecc": "^2.6.0",
+        "@peculiar/asn1-pkcs9": "^2.6.0",
+        "@peculiar/asn1-rsa": "^2.6.0",
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.0",
+        "pvtsutils": "^1.3.6",
+        "reflect-metadata": "^0.2.2",
+        "tslib": "^2.8.1",
+        "tsyringe": "^4.10.0"
+      }
+    },
+    "@pnpm/config.env-replace": {
+      "version": "1.1.0",
+      "resolved": "https://registry.facebook.net/@pnpm/config.env-replace/-/config.env-replace-1.1.0.tgz",
+      "integrity": "sha512-htyl8TWnKL7K/ESFa1oW2UB5lVDxuF5DpM7tBi6Hu2LNL3mWkIzNLG6N4zoCUP1lCKNxWy/3iu8mS8MvToGd6w=="
+    },
+    "@pnpm/network.ca-file": {
+      "version": "1.0.2",
+      "resolved": "https://registry.facebook.net/@pnpm/network.ca-file/-/network.ca-file-1.0.2.tgz",
+      "integrity": "sha512-YcPQ8a0jwYU9bTdJDpXjMi7Brhkr1mXsXrUJvjqM2mQDgkRiz8jFaQGOdaLxgjtUfQgZhKy/O3cG/YwmgKaxLA==",
+      "requires": {
+        "graceful-fs": "4.2.10"
+      },
+      "dependencies": {
+        "graceful-fs": {
+          "version": "4.2.10",
+          "resolved": "https://registry.facebook.net/graceful-fs/-/graceful-fs-4.2.10.tgz",
+          "integrity": "sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA=="
+        }
+      }
+    },
+    "@pnpm/npm-conf": {
+      "version": "3.0.2",
+      "resolved": "https://registry.facebook.net/@pnpm/npm-conf/-/npm-conf-3.0.2.tgz",
+      "integrity": "sha512-h104Kh26rR8tm+a3Qkc5S4VLYint3FE48as7+/5oCEcKR2idC/pF1G6AhIXKI+eHPJa/3J9i5z0Al47IeGHPkA==",
+      "requires": {
+        "@pnpm/config.env-replace": "^1.1.0",
+        "@pnpm/network.ca-file": "^1.0.1",
+        "config-chain": "^1.1.11"
+      }
+    },
+    "@polka/url": {
+      "version": "1.0.0-next.29",
+      "resolved": "https://registry.facebook.net/@polka/url/-/url-1.0.0-next.29.tgz",
+      "integrity": "sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww=="
+    },
+    "@sideway/address": {
+      "version": "4.1.5",
+      "resolved": "https://registry.facebook.net/@sideway/address/-/address-4.1.5.tgz",
+      "integrity": "sha512-IqO/DUQHUkPeixNQ8n0JA6102hT9CmaljNTPmQ1u8MEhBo/R4Q8eKLN/vGZxuebwOroDB4cbpjheD4+/sKFK4Q==",
+      "requires": {
+        "@hapi/hoek": "^9.0.0"
+      }
+    },
+    "@sideway/formula": {
+      "version": "3.0.1",
+      "resolved": "https://registry.facebook.net/@sideway/formula/-/formula-3.0.1.tgz",
+      "integrity": "sha512-/poHZJJVjx3L+zVD6g9KgHfYnb443oi7wLu/XKojDviHy6HOEOA6z1Trk5aR1dGcmPenJEgb2sK2I80LeS3MIg=="
+    },
+    "@sideway/pinpoint": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/@sideway/pinpoint/-/pinpoint-2.0.0.tgz",
+      "integrity": "sha512-RNiOoTPkptFtSVzQevY/yWtZwf/RxyVnPy/OcA9HBM3MlGDnBEYL5B41H0MTn0Uec8Hi+2qUtTfG2WWZBmMejQ=="
+    },
+    "@sinclair/typebox": {
+      "version": "0.27.10",
+      "resolved": "https://registry.facebook.net/@sinclair/typebox/-/typebox-0.27.10.tgz",
+      "integrity": "sha512-MTBk/3jGLNB2tVxv6uLlFh1iu64iYOQ2PbdOSK3NW8JZsmlaOh2q6sdtKowBhfw8QFLmYNzTW4/oK4uATIi6ZA=="
+    },
+    "@sindresorhus/is": {
+      "version": "4.6.0",
+      "resolved": "https://registry.facebook.net/@sindresorhus/is/-/is-4.6.0.tgz",
+      "integrity": "sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw=="
+    },
+    "@slorber/remark-comment": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/@slorber/remark-comment/-/remark-comment-1.0.0.tgz",
+      "integrity": "sha512-RCE24n7jsOj1M0UPvIQCHTe7fI0sFL4S2nwKVWwHyVr/wI/H8GosgsJGyhnsZoGFnD/P2hLf1mSbrrgSLN93NA==",
+      "requires": {
+        "micromark-factory-space": "^1.0.0",
+        "micromark-util-character": "^1.1.0",
+        "micromark-util-symbol": "^1.0.1"
+      },
+      "dependencies": {
+        "micromark-factory-space": {
+          "version": "1.1.0",
+          "resolved": "https://registry.facebook.net/micromark-factory-space/-/micromark-factory-space-1.1.0.tgz",
+          "integrity": "sha512-cRzEj7c0OL4Mw2v6nwzttyOZe8XY/Z8G0rzmWQZTBi/jjwyw/U4uqKtUORXQrR5bAZZnbTI/feRV/R7hc4jQYQ==",
+          "requires": {
+            "micromark-util-character": "^1.0.0",
+            "micromark-util-types": "^1.0.0"
+          }
+        },
+        "micromark-util-character": {
+          "version": "1.2.0",
+          "resolved": "https://registry.facebook.net/micromark-util-character/-/micromark-util-character-1.2.0.tgz",
+          "integrity": "sha512-lXraTwcX3yH/vMDaFWCQJP1uIszLVebzUa3ZHdrgxr7KEU/9mL4mVgCpGbyhvNLNlauROiNUq7WN5u7ndbY6xg==",
+          "requires": {
+            "micromark-util-symbol": "^1.0.0",
+            "micromark-util-types": "^1.0.0"
+          }
+        },
+        "micromark-util-symbol": {
+          "version": "1.1.0",
+          "resolved": "https://registry.facebook.net/micromark-util-symbol/-/micromark-util-symbol-1.1.0.tgz",
+          "integrity": "sha512-uEjpEYY6KMs1g7QfJ2eX1SQEV+ZT4rUD3UcF6l57acZvLNK7PBZL+ty82Z1qhK1/yXIY4bdx04FKMgR0g4IAag=="
+        },
+        "micromark-util-types": {
+          "version": "1.1.0",
+          "resolved": "https://registry.facebook.net/micromark-util-types/-/micromark-util-types-1.1.0.tgz",
+          "integrity": "sha512-ukRBgie8TIAcacscVHSiddHjO4k/q3pnedmzMQ4iwDcK0FtFCohKOlFbaOL/mPgfnPsL3C1ZyxJa4sbWrBl3jg=="
+        }
+      }
+    },
+    "@svgr/babel-plugin-add-jsx-attribute": {
+      "version": "8.0.0",
+      "resolved": "https://registry.facebook.net/@svgr/babel-plugin-add-jsx-attribute/-/babel-plugin-add-jsx-attribute-8.0.0.tgz",
+      "integrity": "sha512-b9MIk7yhdS1pMCZM8VeNfUlSKVRhsHZNMl5O9SfaX0l0t5wjdgu4IDzGB8bpnGBBOjGST3rRFVsaaEtI4W6f7g==",
+      "requires": {}
+    },
+    "@svgr/babel-plugin-remove-jsx-attribute": {
+      "version": "8.0.0",
+      "resolved": "https://registry.facebook.net/@svgr/babel-plugin-remove-jsx-attribute/-/babel-plugin-remove-jsx-attribute-8.0.0.tgz",
+      "integrity": "sha512-BcCkm/STipKvbCl6b7QFrMh/vx00vIP63k2eM66MfHJzPr6O2U0jYEViXkHJWqXqQYjdeA9cuCl5KWmlwjDvbA==",
+      "requires": {}
+    },
+    "@svgr/babel-plugin-remove-jsx-empty-expression": {
+      "version": "8.0.0",
+      "resolved": "https://registry.facebook.net/@svgr/babel-plugin-remove-jsx-empty-expression/-/babel-plugin-remove-jsx-empty-expression-8.0.0.tgz",
+      "integrity": "sha512-5BcGCBfBxB5+XSDSWnhTThfI9jcO5f0Ai2V24gZpG+wXF14BzwxxdDb4g6trdOux0rhibGs385BeFMSmxtS3uA==",
+      "requires": {}
+    },
+    "@svgr/babel-plugin-replace-jsx-attribute-value": {
+      "version": "8.0.0",
+      "resolved": "https://registry.facebook.net/@svgr/babel-plugin-replace-jsx-attribute-value/-/babel-plugin-replace-jsx-attribute-value-8.0.0.tgz",
+      "integrity": "sha512-KVQ+PtIjb1BuYT3ht8M5KbzWBhdAjjUPdlMtpuw/VjT8coTrItWX6Qafl9+ji831JaJcu6PJNKCV0bp01lBNzQ==",
+      "requires": {}
+    },
+    "@svgr/babel-plugin-svg-dynamic-title": {
+      "version": "8.0.0",
+      "resolved": "https://registry.facebook.net/@svgr/babel-plugin-svg-dynamic-title/-/babel-plugin-svg-dynamic-title-8.0.0.tgz",
+      "integrity": "sha512-omNiKqwjNmOQJ2v6ge4SErBbkooV2aAWwaPFs2vUY7p7GhVkzRkJ00kILXQvRhA6miHnNpXv7MRnnSjdRjK8og==",
+      "requires": {}
+    },
+    "@svgr/babel-plugin-svg-em-dimensions": {
+      "version": "8.0.0",
+      "resolved": "https://registry.facebook.net/@svgr/babel-plugin-svg-em-dimensions/-/babel-plugin-svg-em-dimensions-8.0.0.tgz",
+      "integrity": "sha512-mURHYnu6Iw3UBTbhGwE/vsngtCIbHE43xCRK7kCw4t01xyGqb2Pd+WXekRRoFOBIY29ZoOhUCTEweDMdrjfi9g==",
+      "requires": {}
+    },
+    "@svgr/babel-plugin-transform-react-native-svg": {
+      "version": "8.1.0",
+      "resolved": "https://registry.facebook.net/@svgr/babel-plugin-transform-react-native-svg/-/babel-plugin-transform-react-native-svg-8.1.0.tgz",
+      "integrity": "sha512-Tx8T58CHo+7nwJ+EhUwx3LfdNSG9R2OKfaIXXs5soiy5HtgoAEkDay9LIimLOcG8dJQH1wPZp/cnAv6S9CrR1Q==",
+      "requires": {}
+    },
+    "@svgr/babel-plugin-transform-svg-component": {
+      "version": "8.0.0",
+      "resolved": "https://registry.facebook.net/@svgr/babel-plugin-transform-svg-component/-/babel-plugin-transform-svg-component-8.0.0.tgz",
+      "integrity": "sha512-DFx8xa3cZXTdb/k3kfPeaixecQLgKh5NVBMwD0AQxOzcZawK4oo1Jh9LbrcACUivsCA7TLG8eeWgrDXjTMhRmw==",
+      "requires": {}
+    },
+    "@svgr/babel-preset": {
+      "version": "8.1.0",
+      "resolved": "https://registry.facebook.net/@svgr/babel-preset/-/babel-preset-8.1.0.tgz",
+      "integrity": "sha512-7EYDbHE7MxHpv4sxvnVPngw5fuR6pw79SkcrILHJ/iMpuKySNCl5W1qcwPEpU+LgyRXOaAFgH0KhwD18wwg6ug==",
+      "requires": {
+        "@svgr/babel-plugin-add-jsx-attribute": "8.0.0",
+        "@svgr/babel-plugin-remove-jsx-attribute": "8.0.0",
+        "@svgr/babel-plugin-remove-jsx-empty-expression": "8.0.0",
+        "@svgr/babel-plugin-replace-jsx-attribute-value": "8.0.0",
+        "@svgr/babel-plugin-svg-dynamic-title": "8.0.0",
+        "@svgr/babel-plugin-svg-em-dimensions": "8.0.0",
+        "@svgr/babel-plugin-transform-react-native-svg": "8.1.0",
+        "@svgr/babel-plugin-transform-svg-component": "8.0.0"
+      }
+    },
+    "@svgr/core": {
+      "version": "8.1.0",
+      "resolved": "https://registry.facebook.net/@svgr/core/-/core-8.1.0.tgz",
+      "integrity": "sha512-8QqtOQT5ACVlmsvKOJNEaWmRPmcojMOzCz4Hs2BGG/toAp/K38LcsMRyLp349glq5AzJbCEeimEoxaX6v/fLrA==",
+      "requires": {
+        "@babel/core": "^7.21.3",
+        "@svgr/babel-preset": "8.1.0",
+        "camelcase": "^6.2.0",
+        "cosmiconfig": "^8.1.3",
+        "snake-case": "^3.0.4"
+      }
+    },
+    "@svgr/hast-util-to-babel-ast": {
+      "version": "8.0.0",
+      "resolved": "https://registry.facebook.net/@svgr/hast-util-to-babel-ast/-/hast-util-to-babel-ast-8.0.0.tgz",
+      "integrity": "sha512-EbDKwO9GpfWP4jN9sGdYwPBU0kdomaPIL2Eu4YwmgP+sJeXT+L7bMwJUBnhzfH8Q2qMBqZ4fJwpCyYsAN3mt2Q==",
+      "requires": {
+        "@babel/types": "^7.21.3",
+        "entities": "^4.4.0"
+      }
+    },
+    "@svgr/plugin-jsx": {
+      "version": "8.1.0",
+      "resolved": "https://registry.facebook.net/@svgr/plugin-jsx/-/plugin-jsx-8.1.0.tgz",
+      "integrity": "sha512-0xiIyBsLlr8quN+WyuxooNW9RJ0Dpr8uOnH/xrCVO8GLUcwHISwj1AG0k+LFzteTkAA0GbX0kj9q6Dk70PTiPA==",
+      "requires": {
+        "@babel/core": "^7.21.3",
+        "@svgr/babel-preset": "8.1.0",
+        "@svgr/hast-util-to-babel-ast": "8.0.0",
+        "svg-parser": "^2.0.4"
+      }
+    },
+    "@svgr/plugin-svgo": {
+      "version": "8.1.0",
+      "resolved": "https://registry.facebook.net/@svgr/plugin-svgo/-/plugin-svgo-8.1.0.tgz",
+      "integrity": "sha512-Ywtl837OGO9pTLIN/onoWLmDQ4zFUycI1g76vuKGEz6evR/ZTJlJuz3G/fIkb6OVBJ2g0o6CGJzaEjfmEo3AHA==",
+      "requires": {
+        "cosmiconfig": "^8.1.3",
+        "deepmerge": "^4.3.1",
+        "svgo": "^3.0.2"
+      }
+    },
+    "@svgr/webpack": {
+      "version": "8.1.0",
+      "resolved": "https://registry.facebook.net/@svgr/webpack/-/webpack-8.1.0.tgz",
+      "integrity": "sha512-LnhVjMWyMQV9ZmeEy26maJk+8HTIbd59cH4F2MJ439k9DqejRisfFNGAPvRYlKETuh9LrImlS8aKsBgKjMA8WA==",
+      "requires": {
+        "@babel/core": "^7.21.3",
+        "@babel/plugin-transform-react-constant-elements": "^7.21.3",
+        "@babel/preset-env": "^7.20.2",
+        "@babel/preset-react": "^7.18.6",
+        "@babel/preset-typescript": "^7.21.0",
+        "@svgr/core": "8.1.0",
+        "@svgr/plugin-jsx": "8.1.0",
+        "@svgr/plugin-svgo": "8.1.0"
+      }
+    },
+    "@szmarczak/http-timer": {
+      "version": "5.0.1",
+      "resolved": "https://registry.facebook.net/@szmarczak/http-timer/-/http-timer-5.0.1.tgz",
+      "integrity": "sha512-+PmQX0PiAYPMeVYe237LJAYvOMYW1j2rH5YROyS3b4CTVJum34HfRvKvAzozHAQG0TnHNdUfY9nCeUyRAs//cw==",
+      "requires": {
+        "defer-to-connect": "^2.0.1"
+      }
+    },
+    "@types/body-parser": {
+      "version": "1.19.6",
+      "resolved": "https://registry.facebook.net/@types/body-parser/-/body-parser-1.19.6.tgz",
+      "integrity": "sha512-HLFeCYgz89uk22N5Qg3dvGvsv46B8GLvKKo1zKG4NybA8U2DiEO3w9lqGg29t/tfLRJpJ6iQxnVw4OnB7MoM9g==",
+      "requires": {
+        "@types/connect": "*",
+        "@types/node": "*"
+      }
+    },
+    "@types/bonjour": {
+      "version": "3.5.13",
+      "resolved": "https://registry.facebook.net/@types/bonjour/-/bonjour-3.5.13.tgz",
+      "integrity": "sha512-z9fJ5Im06zvUL548KvYNecEVlA7cVDkGUi6kZusb04mpyEFKCIZJvloCcmpmLaIahDpOQGHaHmG6imtPMmPXGQ==",
+      "requires": {
+        "@types/node": "*"
+      }
+    },
+    "@types/connect": {
+      "version": "3.4.38",
+      "resolved": "https://registry.facebook.net/@types/connect/-/connect-3.4.38.tgz",
+      "integrity": "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==",
+      "requires": {
+        "@types/node": "*"
+      }
+    },
+    "@types/connect-history-api-fallback": {
+      "version": "1.5.4",
+      "resolved": "https://registry.facebook.net/@types/connect-history-api-fallback/-/connect-history-api-fallback-1.5.4.tgz",
+      "integrity": "sha512-n6Cr2xS1h4uAulPRdlw6Jl6s1oG8KrVilPN2yUITEs+K48EzMJJ3W1xy8K5eWuFvjp3R74AOIGSmp2UfBJ8HFw==",
+      "requires": {
+        "@types/express-serve-static-core": "*",
+        "@types/node": "*"
+      },
+      "dependencies": {
+        "@types/express-serve-static-core": {
+          "version": "5.1.1",
+          "resolved": "https://registry.facebook.net/@types/express-serve-static-core/-/express-serve-static-core-5.1.1.tgz",
+          "integrity": "sha512-v4zIMr/cX7/d2BpAEX3KNKL/JrT1s43s96lLvvdTmza1oEvDudCqK9aF/djc/SWgy8Yh0h30TZx5VpzqFCxk5A==",
+          "requires": {
+            "@types/node": "*",
+            "@types/qs": "*",
+            "@types/range-parser": "*",
+            "@types/send": "*"
+          }
+        }
+      }
+    },
+    "@types/debug": {
+      "version": "4.1.13",
+      "resolved": "https://registry.facebook.net/@types/debug/-/debug-4.1.13.tgz",
+      "integrity": "sha512-KSVgmQmzMwPlmtljOomayoR89W4FynCAi3E8PPs7vmDVPe84hT+vGPKkJfThkmXs0x0jAaa9U8uW8bbfyS2fWw==",
+      "requires": {
+        "@types/ms": "*"
+      }
+    },
+    "@types/eslint": {
+      "version": "9.6.1",
+      "resolved": "https://registry.facebook.net/@types/eslint/-/eslint-9.6.1.tgz",
+      "integrity": "sha512-FXx2pKgId/WyYo2jXw63kk7/+TY7u7AziEJxJAnSFzHlqTAS3Ync6SvgYAN/k4/PQpnnVuzoMuVnByKK2qp0ag==",
+      "requires": {
+        "@types/estree": "*",
+        "@types/json-schema": "*"
+      }
+    },
+    "@types/eslint-scope": {
+      "version": "3.7.7",
+      "resolved": "https://registry.facebook.net/@types/eslint-scope/-/eslint-scope-3.7.7.tgz",
+      "integrity": "sha512-MzMFlSLBqNF2gcHWO0G1vP/YQyfvrxZ0bF+u7mzUdZ1/xK4A4sru+nraZz5i3iEIk1l1uyicaDVTB4QbbEkAYg==",
+      "requires": {
+        "@types/eslint": "*",
+        "@types/estree": "*"
+      }
+    },
+    "@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.facebook.net/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w=="
+    },
+    "@types/estree-jsx": {
+      "version": "1.0.5",
+      "resolved": "https://registry.facebook.net/@types/estree-jsx/-/estree-jsx-1.0.5.tgz",
+      "integrity": "sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg==",
+      "requires": {
+        "@types/estree": "*"
+      }
+    },
+    "@types/express": {
+      "version": "4.17.25",
+      "resolved": "https://registry.facebook.net/@types/express/-/express-4.17.25.tgz",
+      "integrity": "sha512-dVd04UKsfpINUnK0yBoYHDF3xu7xVH4BuDotC/xGuycx4CgbP48X/KF/586bcObxT0HENHXEU8Nqtu6NR+eKhw==",
+      "requires": {
+        "@types/body-parser": "*",
+        "@types/express-serve-static-core": "^4.17.33",
+        "@types/qs": "*",
+        "@types/serve-static": "^1"
+      }
+    },
+    "@types/express-serve-static-core": {
+      "version": "4.19.8",
+      "resolved": "https://registry.facebook.net/@types/express-serve-static-core/-/express-serve-static-core-4.19.8.tgz",
+      "integrity": "sha512-02S5fmqeoKzVZCHPZid4b8JH2eM5HzQLZWN2FohQEy/0eXTq8VXZfSN6Pcr3F6N9R/vNrj7cpgbhjie6m/1tCA==",
+      "requires": {
+        "@types/node": "*",
+        "@types/qs": "*",
+        "@types/range-parser": "*",
+        "@types/send": "*"
+      }
+    },
+    "@types/gtag.js": {
+      "version": "0.0.20",
+      "resolved": "https://registry.facebook.net/@types/gtag.js/-/gtag.js-0.0.20.tgz",
+      "integrity": "sha512-wwAbk3SA2QeU67unN7zPxjEHmPmlXwZXZvQEpbEUQuMCRGgKyE1m6XDuTUA9b6pCGb/GqJmdfMOY5LuDjJSbbg=="
+    },
+    "@types/hast": {
+      "version": "3.0.4",
+      "resolved": "https://registry.facebook.net/@types/hast/-/hast-3.0.4.tgz",
+      "integrity": "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==",
+      "requires": {
+        "@types/unist": "*"
+      }
+    },
+    "@types/history": {
+      "version": "4.7.11",
+      "resolved": "https://registry.facebook.net/@types/history/-/history-4.7.11.tgz",
+      "integrity": "sha512-qjDJRrmvBMiTx+jyLxvLfJU7UznFuokDv4f3WRuriHKERccVpFU+8XMQUAbDzoiJCsmexxRExQeMwwCdamSKDA=="
+    },
+    "@types/html-minifier-terser": {
+      "version": "6.1.0",
+      "resolved": "https://registry.facebook.net/@types/html-minifier-terser/-/html-minifier-terser-6.1.0.tgz",
+      "integrity": "sha512-oh/6byDPnL1zeNXFrDXFLyZjkr1MsBG667IM792caf1L2UPOOMf65NFzjUH/ltyfwjAGfs1rsX1eftK0jC/KIg=="
+    },
+    "@types/http-cache-semantics": {
+      "version": "4.2.0",
+      "resolved": "https://registry.facebook.net/@types/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz",
+      "integrity": "sha512-L3LgimLHXtGkWikKnsPg0/VFx9OGZaC+eN1u4r+OB1XRqH3meBIAVC2zr1WdMH+RHmnRkqliQAOHNJ/E0j/e0Q=="
+    },
+    "@types/http-errors": {
+      "version": "2.0.5",
+      "resolved": "https://registry.facebook.net/@types/http-errors/-/http-errors-2.0.5.tgz",
+      "integrity": "sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg=="
+    },
+    "@types/http-proxy": {
+      "version": "1.17.17",
+      "resolved": "https://registry.facebook.net/@types/http-proxy/-/http-proxy-1.17.17.tgz",
+      "integrity": "sha512-ED6LB+Z1AVylNTu7hdzuBqOgMnvG/ld6wGCG8wFnAzKX5uyW2K3WD52v0gnLCTK/VLpXtKckgWuyScYK6cSPaw==",
+      "requires": {
+        "@types/node": "*"
+      }
+    },
+    "@types/istanbul-lib-coverage": {
+      "version": "2.0.6",
+      "resolved": "https://registry.facebook.net/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz",
+      "integrity": "sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w=="
+    },
+    "@types/istanbul-lib-report": {
+      "version": "3.0.3",
+      "resolved": "https://registry.facebook.net/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.3.tgz",
+      "integrity": "sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA==",
+      "requires": {
+        "@types/istanbul-lib-coverage": "*"
+      }
+    },
+    "@types/istanbul-reports": {
+      "version": "3.0.4",
+      "resolved": "https://registry.facebook.net/@types/istanbul-reports/-/istanbul-reports-3.0.4.tgz",
+      "integrity": "sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==",
+      "requires": {
+        "@types/istanbul-lib-report": "*"
+      }
+    },
+    "@types/json-schema": {
+      "version": "7.0.15",
+      "resolved": "https://registry.facebook.net/@types/json-schema/-/json-schema-7.0.15.tgz",
+      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA=="
+    },
+    "@types/mdast": {
+      "version": "4.0.4",
+      "resolved": "https://registry.facebook.net/@types/mdast/-/mdast-4.0.4.tgz",
+      "integrity": "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==",
+      "requires": {
+        "@types/unist": "*"
+      }
+    },
+    "@types/mdx": {
+      "version": "2.0.13",
+      "resolved": "https://registry.facebook.net/@types/mdx/-/mdx-2.0.13.tgz",
+      "integrity": "sha512-+OWZQfAYyio6YkJb3HLxDrvnx6SWWDbC0zVPfBRzUk0/nqoDyf6dNxQi3eArPe8rJ473nobTMQ/8Zk+LxJ+Yuw=="
+    },
+    "@types/mime": {
+      "version": "1.3.5",
+      "resolved": "https://registry.facebook.net/@types/mime/-/mime-1.3.5.tgz",
+      "integrity": "sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w=="
+    },
+    "@types/ms": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/@types/ms/-/ms-2.1.0.tgz",
+      "integrity": "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA=="
+    },
+    "@types/node": {
+      "version": "25.6.0",
+      "resolved": "https://registry.facebook.net/@types/node/-/node-25.6.0.tgz",
+      "integrity": "sha512-+qIYRKdNYJwY3vRCZMdJbPLJAtGjQBudzZzdzwQYkEPQd+PJGixUL5QfvCLDaULoLv+RhT3LDkwEfKaAkgSmNQ==",
+      "requires": {
+        "undici-types": "~7.19.0"
+      }
+    },
+    "@types/prismjs": {
+      "version": "1.26.6",
+      "resolved": "https://registry.facebook.net/@types/prismjs/-/prismjs-1.26.6.tgz",
+      "integrity": "sha512-vqlvI7qlMvcCBbVe0AKAb4f97//Hy0EBTaiW8AalRnG/xAN5zOiWWyrNqNXeq8+KAuvRewjCVY1+IPxk4RdNYw=="
+    },
+    "@types/qs": {
+      "version": "6.15.0",
+      "resolved": "https://registry.facebook.net/@types/qs/-/qs-6.15.0.tgz",
+      "integrity": "sha512-JawvT8iBVWpzTrz3EGw9BTQFg3BQNmwERdKE22vlTxawwtbyUSlMppvZYKLZzB5zgACXdXxbD3m1bXaMqP/9ow=="
+    },
+    "@types/range-parser": {
+      "version": "1.2.7",
+      "resolved": "https://registry.facebook.net/@types/range-parser/-/range-parser-1.2.7.tgz",
+      "integrity": "sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ=="
+    },
+    "@types/react": {
+      "version": "19.2.14",
+      "resolved": "https://registry.facebook.net/@types/react/-/react-19.2.14.tgz",
+      "integrity": "sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==",
+      "requires": {
+        "csstype": "^3.2.2"
+      }
+    },
+    "@types/react-router": {
+      "version": "5.1.20",
+      "resolved": "https://registry.facebook.net/@types/react-router/-/react-router-5.1.20.tgz",
+      "integrity": "sha512-jGjmu/ZqS7FjSH6owMcD5qpq19+1RS9DeVRqfl1FeBMxTDQAGwlMWOcs52NDoXaNKyG3d1cYQFMs9rCrb88o9Q==",
+      "requires": {
+        "@types/history": "^4.7.11",
+        "@types/react": "*"
+      }
+    },
+    "@types/react-router-config": {
+      "version": "5.0.11",
+      "resolved": "https://registry.facebook.net/@types/react-router-config/-/react-router-config-5.0.11.tgz",
+      "integrity": "sha512-WmSAg7WgqW7m4x8Mt4N6ZyKz0BubSj/2tVUMsAHp+Yd2AMwcSbeFq9WympT19p5heCFmF97R9eD5uUR/t4HEqw==",
+      "requires": {
+        "@types/history": "^4.7.11",
+        "@types/react": "*",
+        "@types/react-router": "^5.1.0"
+      }
+    },
+    "@types/react-router-dom": {
+      "version": "5.3.3",
+      "resolved": "https://registry.facebook.net/@types/react-router-dom/-/react-router-dom-5.3.3.tgz",
+      "integrity": "sha512-kpqnYK4wcdm5UaWI3fLcELopqLrHgLqNsdpHauzlQktfkHL3npOSwtj1Uz9oKBAzs7lFtVkV8j83voAz2D8fhw==",
+      "requires": {
+        "@types/history": "^4.7.11",
+        "@types/react": "*",
+        "@types/react-router": "*"
+      }
+    },
+    "@types/retry": {
+      "version": "0.12.2",
+      "resolved": "https://registry.facebook.net/@types/retry/-/retry-0.12.2.tgz",
+      "integrity": "sha512-XISRgDJ2Tc5q4TRqvgJtzsRkFYNJzZrhTdtMoGVBttwzzQJkPnS3WWTFc7kuDRoPtPakl+T+OfdEUjYJj7Jbow=="
+    },
+    "@types/sax": {
+      "version": "1.2.7",
+      "resolved": "https://registry.facebook.net/@types/sax/-/sax-1.2.7.tgz",
+      "integrity": "sha512-rO73L89PJxeYM3s3pPPjiPgVVcymqU490g0YO5n5By0k2Erzj6tay/4lr1CHAAU4JyOWd1rpQ8bCf6cZfHU96A==",
+      "requires": {
+        "@types/node": "*"
+      }
+    },
+    "@types/send": {
+      "version": "1.2.1",
+      "resolved": "https://registry.facebook.net/@types/send/-/send-1.2.1.tgz",
+      "integrity": "sha512-arsCikDvlU99zl1g69TcAB3mzZPpxgw0UQnaHeC1Nwb015xp8bknZv5rIfri9xTOcMuaVgvabfIRA7PSZVuZIQ==",
+      "requires": {
+        "@types/node": "*"
+      }
+    },
+    "@types/serve-index": {
+      "version": "1.9.4",
+      "resolved": "https://registry.facebook.net/@types/serve-index/-/serve-index-1.9.4.tgz",
+      "integrity": "sha512-qLpGZ/c2fhSs5gnYsQxtDEq3Oy8SXPClIXkW5ghvAvsNuVSA8k+gCONcUCS/UjLEYvYps+e8uBtfgXgvhwfNug==",
+      "requires": {
+        "@types/express": "*"
+      },
+      "dependencies": {
+        "@types/express": {
+          "version": "5.0.6",
+          "resolved": "https://registry.facebook.net/@types/express/-/express-5.0.6.tgz",
+          "integrity": "sha512-sKYVuV7Sv9fbPIt/442koC7+IIwK5olP1KWeD88e/idgoJqDm3JV/YUiPwkoKK92ylff2MGxSz1CSjsXelx0YA==",
+          "requires": {
+            "@types/body-parser": "*",
+            "@types/express-serve-static-core": "^5.0.0",
+            "@types/serve-static": "^2"
+          }
+        },
+        "@types/express-serve-static-core": {
+          "version": "5.1.1",
+          "resolved": "https://registry.facebook.net/@types/express-serve-static-core/-/express-serve-static-core-5.1.1.tgz",
+          "integrity": "sha512-v4zIMr/cX7/d2BpAEX3KNKL/JrT1s43s96lLvvdTmza1oEvDudCqK9aF/djc/SWgy8Yh0h30TZx5VpzqFCxk5A==",
+          "requires": {
+            "@types/node": "*",
+            "@types/qs": "*",
+            "@types/range-parser": "*",
+            "@types/send": "*"
+          }
+        },
+        "@types/serve-static": {
+          "version": "2.2.0",
+          "resolved": "https://registry.facebook.net/@types/serve-static/-/serve-static-2.2.0.tgz",
+          "integrity": "sha512-8mam4H1NHLtu7nmtalF7eyBH14QyOASmcxHhSfEoRyr0nP/YdoesEtU+uSRvMe96TW/HPTtkoKqQLl53N7UXMQ==",
+          "requires": {
+            "@types/http-errors": "*",
+            "@types/node": "*"
+          }
+        }
+      }
+    },
+    "@types/serve-static": {
+      "version": "1.15.10",
+      "resolved": "https://registry.facebook.net/@types/serve-static/-/serve-static-1.15.10.tgz",
+      "integrity": "sha512-tRs1dB+g8Itk72rlSI2ZrW6vZg0YrLI81iQSTkMmOqnqCaNr/8Ek4VwWcN5vZgCYWbg/JJSGBlUaYGAOP73qBw==",
+      "requires": {
+        "@types/http-errors": "*",
+        "@types/node": "*",
+        "@types/send": "<1"
+      },
+      "dependencies": {
+        "@types/send": {
+          "version": "0.17.6",
+          "resolved": "https://registry.facebook.net/@types/send/-/send-0.17.6.tgz",
+          "integrity": "sha512-Uqt8rPBE8SY0RK8JB1EzVOIZ32uqy8HwdxCnoCOsYrvnswqmFZ/k+9Ikidlk/ImhsdvBsloHbAlewb2IEBV/Og==",
+          "requires": {
+            "@types/mime": "^1",
+            "@types/node": "*"
+          }
+        }
+      }
+    },
+    "@types/sockjs": {
+      "version": "0.3.36",
+      "resolved": "https://registry.facebook.net/@types/sockjs/-/sockjs-0.3.36.tgz",
+      "integrity": "sha512-MK9V6NzAS1+Ud7JV9lJLFqW85VbC9dq3LmwZCuBe4wBDgKC0Kj/jd8Xl+nSviU+Qc3+m7umHHyHg//2KSa0a0Q==",
+      "requires": {
+        "@types/node": "*"
+      }
+    },
+    "@types/unist": {
+      "version": "3.0.3",
+      "resolved": "https://registry.facebook.net/@types/unist/-/unist-3.0.3.tgz",
+      "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q=="
+    },
+    "@types/ws": {
+      "version": "8.18.1",
+      "resolved": "https://registry.facebook.net/@types/ws/-/ws-8.18.1.tgz",
+      "integrity": "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==",
+      "requires": {
+        "@types/node": "*"
+      }
+    },
+    "@types/yargs": {
+      "version": "17.0.35",
+      "resolved": "https://registry.facebook.net/@types/yargs/-/yargs-17.0.35.tgz",
+      "integrity": "sha512-qUHkeCyQFxMXg79wQfTtfndEC+N9ZZg76HJftDJp+qH2tV7Gj4OJi7l+PiWwJ+pWtW8GwSmqsDj/oymhrTWXjg==",
+      "requires": {
+        "@types/yargs-parser": "*"
+      }
+    },
+    "@types/yargs-parser": {
+      "version": "21.0.3",
+      "resolved": "https://registry.facebook.net/@types/yargs-parser/-/yargs-parser-21.0.3.tgz",
+      "integrity": "sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ=="
+    },
+    "@ungap/structured-clone": {
+      "version": "1.3.0",
+      "resolved": "https://registry.facebook.net/@ungap/structured-clone/-/structured-clone-1.3.0.tgz",
+      "integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g=="
+    },
+    "@webassemblyjs/ast": {
+      "version": "1.14.1",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/ast/-/ast-1.14.1.tgz",
+      "integrity": "sha512-nuBEDgQfm1ccRp/8bCQrx1frohyufl4JlbMMZ4P1wpeOfDhF6FQkxZJ1b/e+PLwr6X1Nhw6OLme5usuBWYBvuQ==",
+      "requires": {
+        "@webassemblyjs/helper-numbers": "1.13.2",
+        "@webassemblyjs/helper-wasm-bytecode": "1.13.2"
+      }
+    },
+    "@webassemblyjs/floating-point-hex-parser": {
+      "version": "1.13.2",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.13.2.tgz",
+      "integrity": "sha512-6oXyTOzbKxGH4steLbLNOu71Oj+C8Lg34n6CqRvqfS2O71BxY6ByfMDRhBytzknj9yGUPVJ1qIKhRlAwO1AovA=="
+    },
+    "@webassemblyjs/helper-api-error": {
+      "version": "1.13.2",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/helper-api-error/-/helper-api-error-1.13.2.tgz",
+      "integrity": "sha512-U56GMYxy4ZQCbDZd6JuvvNV/WFildOjsaWD3Tzzvmw/mas3cXzRJPMjP83JqEsgSbyrmaGjBfDtV7KDXV9UzFQ=="
+    },
+    "@webassemblyjs/helper-buffer": {
+      "version": "1.14.1",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/helper-buffer/-/helper-buffer-1.14.1.tgz",
+      "integrity": "sha512-jyH7wtcHiKssDtFPRB+iQdxlDf96m0E39yb0k5uJVhFGleZFoNw1c4aeIcVUPPbXUVJ94wwnMOAqUHyzoEPVMA=="
+    },
+    "@webassemblyjs/helper-numbers": {
+      "version": "1.13.2",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/helper-numbers/-/helper-numbers-1.13.2.tgz",
+      "integrity": "sha512-FE8aCmS5Q6eQYcV3gI35O4J789wlQA+7JrqTTpJqn5emA4U2hvwJmvFRC0HODS+3Ye6WioDklgd6scJ3+PLnEA==",
+      "requires": {
+        "@webassemblyjs/floating-point-hex-parser": "1.13.2",
+        "@webassemblyjs/helper-api-error": "1.13.2",
+        "@xtuc/long": "4.2.2"
+      }
+    },
+    "@webassemblyjs/helper-wasm-bytecode": {
+      "version": "1.13.2",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.13.2.tgz",
+      "integrity": "sha512-3QbLKy93F0EAIXLh0ogEVR6rOubA9AoZ+WRYhNbFyuB70j3dRdwH9g+qXhLAO0kiYGlg3TxDV+I4rQTr/YNXkA=="
+    },
+    "@webassemblyjs/helper-wasm-section": {
+      "version": "1.14.1",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.14.1.tgz",
+      "integrity": "sha512-ds5mXEqTJ6oxRoqjhWDU83OgzAYjwsCV8Lo/N+oRsNDmx/ZDpqalmrtgOMkHwxsG0iI//3BwWAErYRHtgn0dZw==",
+      "requires": {
+        "@webassemblyjs/ast": "1.14.1",
+        "@webassemblyjs/helper-buffer": "1.14.1",
+        "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+        "@webassemblyjs/wasm-gen": "1.14.1"
+      }
+    },
+    "@webassemblyjs/ieee754": {
+      "version": "1.13.2",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/ieee754/-/ieee754-1.13.2.tgz",
+      "integrity": "sha512-4LtOzh58S/5lX4ITKxnAK2USuNEvpdVV9AlgGQb8rJDHaLeHciwG4zlGr0j/SNWlr7x3vO1lDEsuePvtcDNCkw==",
+      "requires": {
+        "@xtuc/ieee754": "^1.2.0"
+      }
+    },
+    "@webassemblyjs/leb128": {
+      "version": "1.13.2",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/leb128/-/leb128-1.13.2.tgz",
+      "integrity": "sha512-Lde1oNoIdzVzdkNEAWZ1dZ5orIbff80YPdHx20mrHwHrVNNTjNr8E3xz9BdpcGqRQbAEa+fkrCb+fRFTl/6sQw==",
+      "requires": {
+        "@xtuc/long": "4.2.2"
+      }
+    },
+    "@webassemblyjs/utf8": {
+      "version": "1.13.2",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/utf8/-/utf8-1.13.2.tgz",
+      "integrity": "sha512-3NQWGjKTASY1xV5m7Hr0iPeXD9+RDobLll3T9d2AO+g3my8xy5peVyjSag4I50mR1bBSN/Ct12lo+R9tJk0NZQ=="
+    },
+    "@webassemblyjs/wasm-edit": {
+      "version": "1.14.1",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/wasm-edit/-/wasm-edit-1.14.1.tgz",
+      "integrity": "sha512-RNJUIQH/J8iA/1NzlE4N7KtyZNHi3w7at7hDjvRNm5rcUXa00z1vRz3glZoULfJ5mpvYhLybmVcwcjGrC1pRrQ==",
+      "requires": {
+        "@webassemblyjs/ast": "1.14.1",
+        "@webassemblyjs/helper-buffer": "1.14.1",
+        "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+        "@webassemblyjs/helper-wasm-section": "1.14.1",
+        "@webassemblyjs/wasm-gen": "1.14.1",
+        "@webassemblyjs/wasm-opt": "1.14.1",
+        "@webassemblyjs/wasm-parser": "1.14.1",
+        "@webassemblyjs/wast-printer": "1.14.1"
+      }
+    },
+    "@webassemblyjs/wasm-gen": {
+      "version": "1.14.1",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/wasm-gen/-/wasm-gen-1.14.1.tgz",
+      "integrity": "sha512-AmomSIjP8ZbfGQhumkNvgC33AY7qtMCXnN6bL2u2Js4gVCg8fp735aEiMSBbDR7UQIj90n4wKAFUSEd0QN2Ukg==",
+      "requires": {
+        "@webassemblyjs/ast": "1.14.1",
+        "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+        "@webassemblyjs/ieee754": "1.13.2",
+        "@webassemblyjs/leb128": "1.13.2",
+        "@webassemblyjs/utf8": "1.13.2"
+      }
+    },
+    "@webassemblyjs/wasm-opt": {
+      "version": "1.14.1",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/wasm-opt/-/wasm-opt-1.14.1.tgz",
+      "integrity": "sha512-PTcKLUNvBqnY2U6E5bdOQcSM+oVP/PmrDY9NzowJjislEjwP/C4an2303MCVS2Mg9d3AJpIGdUFIQQWbPds0Sw==",
+      "requires": {
+        "@webassemblyjs/ast": "1.14.1",
+        "@webassemblyjs/helper-buffer": "1.14.1",
+        "@webassemblyjs/wasm-gen": "1.14.1",
+        "@webassemblyjs/wasm-parser": "1.14.1"
+      }
+    },
+    "@webassemblyjs/wasm-parser": {
+      "version": "1.14.1",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/wasm-parser/-/wasm-parser-1.14.1.tgz",
+      "integrity": "sha512-JLBl+KZ0R5qB7mCnud/yyX08jWFw5MsoalJ1pQ4EdFlgj9VdXKGuENGsiCIjegI1W7p91rUlcB/LB5yRJKNTcQ==",
+      "requires": {
+        "@webassemblyjs/ast": "1.14.1",
+        "@webassemblyjs/helper-api-error": "1.13.2",
+        "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+        "@webassemblyjs/ieee754": "1.13.2",
+        "@webassemblyjs/leb128": "1.13.2",
+        "@webassemblyjs/utf8": "1.13.2"
+      }
+    },
+    "@webassemblyjs/wast-printer": {
+      "version": "1.14.1",
+      "resolved": "https://registry.facebook.net/@webassemblyjs/wast-printer/-/wast-printer-1.14.1.tgz",
+      "integrity": "sha512-kPSSXE6De1XOR820C90RIo2ogvZG+c3KiHzqUoO/F34Y2shGzesfqv7o57xrxovZJH/MetF5UjroJ/R/3isoiw==",
+      "requires": {
+        "@webassemblyjs/ast": "1.14.1",
+        "@xtuc/long": "4.2.2"
+      }
+    },
+    "@xtuc/ieee754": {
+      "version": "1.2.0",
+      "resolved": "https://registry.facebook.net/@xtuc/ieee754/-/ieee754-1.2.0.tgz",
+      "integrity": "sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA=="
+    },
+    "@xtuc/long": {
+      "version": "4.2.2",
+      "resolved": "https://registry.facebook.net/@xtuc/long/-/long-4.2.2.tgz",
+      "integrity": "sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ=="
+    },
+    "accepts": {
+      "version": "1.3.8",
+      "resolved": "https://registry.facebook.net/accepts/-/accepts-1.3.8.tgz",
+      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
+      "requires": {
+        "mime-types": "~2.1.34",
+        "negotiator": "0.6.3"
+      },
+      "dependencies": {
+        "negotiator": {
+          "version": "0.6.3",
+          "resolved": "https://registry.facebook.net/negotiator/-/negotiator-0.6.3.tgz",
+          "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg=="
+        }
+      }
+    },
+    "acorn": {
+      "version": "8.16.0",
+      "resolved": "https://registry.facebook.net/acorn/-/acorn-8.16.0.tgz",
+      "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw=="
+    },
+    "acorn-import-phases": {
+      "version": "1.0.4",
+      "resolved": "https://registry.facebook.net/acorn-import-phases/-/acorn-import-phases-1.0.4.tgz",
+      "integrity": "sha512-wKmbr/DDiIXzEOiWrTTUcDm24kQ2vGfZQvM2fwg2vXqR5uW6aapr7ObPtj1th32b9u90/Pf4AItvdTh42fBmVQ==",
+      "requires": {}
+    },
+    "acorn-jsx": {
+      "version": "5.3.2",
+      "resolved": "https://registry.facebook.net/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
+      "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
+      "requires": {}
+    },
+    "acorn-walk": {
+      "version": "8.3.5",
+      "resolved": "https://registry.facebook.net/acorn-walk/-/acorn-walk-8.3.5.tgz",
+      "integrity": "sha512-HEHNfbars9v4pgpW6SO1KSPkfoS0xVOM/9UzkJltjlsHZmJasxg8aXkuZa7SMf8vKGIBhpUsPluQSqhJFCqebw==",
+      "requires": {
+        "acorn": "^8.11.0"
+      }
+    },
+    "address": {
+      "version": "1.2.2",
+      "resolved": "https://registry.facebook.net/address/-/address-1.2.2.tgz",
+      "integrity": "sha512-4B/qKCfeE/ODUaAUpSwfzazo5x29WD4r3vXiWsB7I2mSDAihwEqKO+g8GELZUQSSAo5e1XTYh3ZVfLyxBc12nA=="
+    },
+    "aggregate-error": {
+      "version": "3.1.0",
+      "resolved": "https://registry.facebook.net/aggregate-error/-/aggregate-error-3.1.0.tgz",
+      "integrity": "sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==",
+      "requires": {
+        "clean-stack": "^2.0.0",
+        "indent-string": "^4.0.0"
+      }
+    },
+    "ajv": {
+      "version": "8.20.0",
+      "resolved": "https://registry.facebook.net/ajv/-/ajv-8.20.0.tgz",
+      "integrity": "sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==",
+      "requires": {
+        "fast-deep-equal": "^3.1.3",
+        "fast-uri": "^3.0.1",
+        "json-schema-traverse": "^1.0.0",
+        "require-from-string": "^2.0.2"
+      }
+    },
+    "ajv-formats": {
+      "version": "2.1.1",
+      "resolved": "https://registry.facebook.net/ajv-formats/-/ajv-formats-2.1.1.tgz",
+      "integrity": "sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA==",
+      "requires": {
+        "ajv": "^8.0.0"
+      }
+    },
+    "ajv-keywords": {
+      "version": "5.1.0",
+      "resolved": "https://registry.facebook.net/ajv-keywords/-/ajv-keywords-5.1.0.tgz",
+      "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==",
+      "requires": {
+        "fast-deep-equal": "^3.1.3"
+      }
+    },
+    "algoliasearch": {
+      "version": "5.51.0",
+      "resolved": "https://registry.facebook.net/algoliasearch/-/algoliasearch-5.51.0.tgz",
+      "integrity": "sha512-u3XS8HaTzt5YN90KPsOXMRjYJUMVD1dtr6yi4NXQluMbZ5IjQNBu1MEabdAxFhYtEuexqomPMSmRIhQJUd3QSg==",
+      "requires": {
+        "@algolia/abtesting": "1.17.0",
+        "@algolia/client-abtesting": "5.51.0",
+        "@algolia/client-analytics": "5.51.0",
+        "@algolia/client-common": "5.51.0",
+        "@algolia/client-insights": "5.51.0",
+        "@algolia/client-personalization": "5.51.0",
+        "@algolia/client-query-suggestions": "5.51.0",
+        "@algolia/client-search": "5.51.0",
+        "@algolia/ingestion": "1.51.0",
+        "@algolia/monitoring": "1.51.0",
+        "@algolia/recommend": "5.51.0",
+        "@algolia/requester-browser-xhr": "5.51.0",
+        "@algolia/requester-fetch": "5.51.0",
+        "@algolia/requester-node-http": "5.51.0"
+      }
+    },
+    "algoliasearch-helper": {
+      "version": "3.28.2",
+      "resolved": "https://registry.facebook.net/algoliasearch-helper/-/algoliasearch-helper-3.28.2.tgz",
+      "integrity": "sha512-sexVcXLHrJN54+S0wXD52xV3ySeGZA5T6HMDkb84wT+3UcXCd8af/k2vU5qJTbHv7DoBb4mISJHdyQ2JOo3Aig==",
+      "requires": {
+        "@algolia/events": "^4.0.1"
+      }
+    },
+    "ansi-align": {
+      "version": "3.0.1",
+      "resolved": "https://registry.facebook.net/ansi-align/-/ansi-align-3.0.1.tgz",
+      "integrity": "sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==",
+      "requires": {
+        "string-width": "^4.1.0"
+      },
+      "dependencies": {
+        "emoji-regex": {
+          "version": "8.0.0",
+          "resolved": "https://registry.facebook.net/emoji-regex/-/emoji-regex-8.0.0.tgz",
+          "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="
+        },
+        "string-width": {
+          "version": "4.2.3",
+          "resolved": "https://registry.facebook.net/string-width/-/string-width-4.2.3.tgz",
+          "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+          "requires": {
+            "emoji-regex": "^8.0.0",
+            "is-fullwidth-code-point": "^3.0.0",
+            "strip-ansi": "^6.0.1"
+          }
+        }
+      }
+    },
+    "ansi-escapes": {
+      "version": "4.3.2",
+      "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz",
+      "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==",
+      "requires": {
+        "type-fest": "^0.21.3"
+      },
+      "dependencies": {
+        "type-fest": {
+          "version": "0.21.3",
+          "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz",
+          "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w=="
+        }
+      }
+    },
+    "ansi-html-community": {
+      "version": "0.0.8",
+      "resolved": "https://registry.facebook.net/ansi-html-community/-/ansi-html-community-0.0.8.tgz",
+      "integrity": "sha512-1APHAyr3+PCamwNw3bXCPp4HFLONZt/yIH0sZp0/469KWNTEy+qN5jQ3GVX6DMZ1UXAi34yVwtTeaG/HpBuuzw=="
+    },
+    "ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.facebook.net/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="
+    },
+    "ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.facebook.net/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "requires": {
+        "color-convert": "^2.0.1"
+      }
+    },
+    "anymatch": {
+      "version": "3.1.3",
+      "resolved": "https://registry.facebook.net/anymatch/-/anymatch-3.1.3.tgz",
+      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+      "requires": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      }
+    },
+    "arg": {
+      "version": "5.0.2",
+      "resolved": "https://registry.facebook.net/arg/-/arg-5.0.2.tgz",
+      "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg=="
+    },
+    "argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="
+    },
+    "array-flatten": {
+      "version": "1.1.1",
+      "resolved": "https://registry.facebook.net/array-flatten/-/array-flatten-1.1.1.tgz",
+      "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg=="
+    },
+    "array-union": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/array-union/-/array-union-2.1.0.tgz",
+      "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw=="
+    },
+    "asn1js": {
+      "version": "3.0.10",
+      "resolved": "https://registry.facebook.net/asn1js/-/asn1js-3.0.10.tgz",
+      "integrity": "sha512-S2s3aOytiKdFRdulw2qPE51MzjzVOisppcVv7jVFR+Kw0kxwvFrDcYA0h7Ndqbmj0HkMIXYWaoj7fli8kgx1eg==",
+      "requires": {
+        "pvtsutils": "^1.3.6",
+        "pvutils": "^1.1.5",
+        "tslib": "^2.8.1"
+      }
+    },
+    "astring": {
+      "version": "1.9.0",
+      "resolved": "https://registry.facebook.net/astring/-/astring-1.9.0.tgz",
+      "integrity": "sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg=="
+    },
+    "asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.facebook.net/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="
+    },
+    "autoprefixer": {
+      "version": "10.5.0",
+      "resolved": "https://registry.facebook.net/autoprefixer/-/autoprefixer-10.5.0.tgz",
+      "integrity": "sha512-FMhOoZV4+qR6aTUALKX2rEqGG+oyATvwBt9IIzVR5rMa2HRWPkxf+P+PAJLD1I/H5/II+HuZcBJYEFBpq39ong==",
+      "requires": {
+        "browserslist": "^4.28.2",
+        "caniuse-lite": "^1.0.30001787",
+        "fraction.js": "^5.3.4",
+        "picocolors": "^1.1.1",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "axios": {
+      "version": "1.15.2",
+      "resolved": "https://registry.facebook.net/axios/-/axios-1.15.2.tgz",
+      "integrity": "sha512-wLrXxPtcrPTsNlJmKjkPnNPK2Ihe0hn0wGSaTEiHRPxwjvJwT3hKmXF4dpqxmPO9SoNb2FsYXj/xEo0gHN+D5A==",
+      "requires": {
+        "follow-redirects": "^1.15.11",
+        "form-data": "^4.0.5",
+        "proxy-from-env": "^2.1.0"
+      }
+    },
+    "babel-loader": {
+      "version": "9.2.1",
+      "resolved": "https://registry.facebook.net/babel-loader/-/babel-loader-9.2.1.tgz",
+      "integrity": "sha512-fqe8naHt46e0yIdkjUZYqddSXfej3AHajX+CSO5X7oy0EmPc6o5Xh+RClNoHjnieWz9AW4kZxW9yyFMhVB1QLA==",
+      "requires": {
+        "find-cache-dir": "^4.0.0",
+        "schema-utils": "^4.0.0"
+      }
+    },
+    "babel-plugin-dynamic-import-node": {
+      "version": "2.3.3",
+      "resolved": "https://registry.facebook.net/babel-plugin-dynamic-import-node/-/babel-plugin-dynamic-import-node-2.3.3.tgz",
+      "integrity": "sha512-jZVI+s9Zg3IqA/kdi0i6UDCybUI3aSBLnglhYbSSjKlV7yF1F/5LWv8MakQmvYpnbJDS6fcBL2KzHSxNCMtWSQ==",
+      "requires": {
+        "object.assign": "^4.1.0"
+      }
+    },
+    "babel-plugin-polyfill-corejs2": {
+      "version": "0.4.17",
+      "resolved": "https://registry.facebook.net/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.17.tgz",
+      "integrity": "sha512-aTyf30K/rqAsNwN76zYrdtx8obu0E4KoUME29B1xj+B3WxgvWkp943vYQ+z8Mv3lw9xHXMHpvSPOBxzAkIa94w==",
+      "requires": {
+        "@babel/compat-data": "^7.28.6",
+        "@babel/helper-define-polyfill-provider": "^0.6.8",
+        "semver": "^6.3.1"
+      }
+    },
+    "babel-plugin-polyfill-corejs3": {
+      "version": "0.13.0",
+      "resolved": "https://registry.facebook.net/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.13.0.tgz",
+      "integrity": "sha512-U+GNwMdSFgzVmfhNm8GJUX88AadB3uo9KpJqS3FaqNIPKgySuvMb+bHPsOmmuWyIcuqZj/pzt1RUIUZns4y2+A==",
+      "requires": {
+        "@babel/helper-define-polyfill-provider": "^0.6.5",
+        "core-js-compat": "^3.43.0"
+      }
+    },
+    "babel-plugin-polyfill-regenerator": {
+      "version": "0.6.8",
+      "resolved": "https://registry.facebook.net/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.6.8.tgz",
+      "integrity": "sha512-M762rNHfSF1EV3SLtnCJXFoQbbIIz0OyRwnCmV0KPC7qosSfCO0QLTSuJX3ayAebubhE6oYBAYPrBA5ljowaZg==",
+      "requires": {
+        "@babel/helper-define-polyfill-provider": "^0.6.8"
+      }
+    },
+    "bail": {
+      "version": "2.0.2",
+      "resolved": "https://registry.facebook.net/bail/-/bail-2.0.2.tgz",
+      "integrity": "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw=="
+    },
+    "balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.facebook.net/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="
+    },
+    "baseline-browser-mapping": {
+      "version": "2.10.24",
+      "resolved": "https://registry.facebook.net/baseline-browser-mapping/-/baseline-browser-mapping-2.10.24.tgz",
+      "integrity": "sha512-I2NkZOOrj2XuguvWCK6OVh9GavsNjZjK908Rq3mIBK25+GD8vPX5w2WdxVqnQ7xx3SrZJiCiZFu+/Oz50oSYSA=="
+    },
+    "batch": {
+      "version": "0.6.1",
+      "resolved": "https://registry.facebook.net/batch/-/batch-0.6.1.tgz",
+      "integrity": "sha512-x+VAiMRL6UPkx+kudNvxTl6hB2XNNCG2r+7wixVfIYwu/2HKRXimwQyaumLjMveWvT2Hkd/cAJw+QBMfJ/EKVw=="
+    },
+    "big.js": {
+      "version": "5.2.2",
+      "resolved": "https://registry.facebook.net/big.js/-/big.js-5.2.2.tgz",
+      "integrity": "sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ=="
+    },
+    "binary-extensions": {
+      "version": "2.3.0",
+      "resolved": "https://registry.facebook.net/binary-extensions/-/binary-extensions-2.3.0.tgz",
+      "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw=="
+    },
+    "body-parser": {
+      "version": "1.20.5",
+      "resolved": "https://registry.facebook.net/body-parser/-/body-parser-1.20.5.tgz",
+      "integrity": "sha512-3grm+/2tUOvu2cjJkvsIxrv/wVpfXQW4PsQHYm7yk4vfpu7Ekl6nEsYBoJUL6qDwZUx8wUhQ8tR2qz+ad9c9OA==",
+      "requires": {
+        "bytes": "~3.1.2",
+        "content-type": "~1.0.5",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "~1.2.0",
+        "http-errors": "~2.0.1",
+        "iconv-lite": "~0.4.24",
+        "on-finished": "~2.4.1",
+        "qs": "~6.15.1",
+        "raw-body": "~2.5.3",
+        "type-is": "~1.6.18",
+        "unpipe": "~1.0.0"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "2.6.9",
+          "resolved": "https://registry.facebook.net/debug/-/debug-2.6.9.tgz",
+          "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+          "requires": {
+            "ms": "2.0.0"
+          }
+        },
+        "ms": {
+          "version": "2.0.0",
+          "resolved": "https://registry.facebook.net/ms/-/ms-2.0.0.tgz",
+          "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A=="
+        },
+        "qs": {
+          "version": "6.15.1",
+          "resolved": "https://registry.facebook.net/qs/-/qs-6.15.1.tgz",
+          "integrity": "sha512-6YHEFRL9mfgcAvql/XhwTvf5jKcOiiupt2FiJxHkiX1z4j7WL8J/jRHYLluORvc1XxB5rV20KoeK00gVJamspg==",
+          "requires": {
+            "side-channel": "^1.1.0"
+          }
+        }
+      }
+    },
+    "bonjour-service": {
+      "version": "1.3.0",
+      "resolved": "https://registry.facebook.net/bonjour-service/-/bonjour-service-1.3.0.tgz",
+      "integrity": "sha512-3YuAUiSkWykd+2Azjgyxei8OWf8thdn8AITIog2M4UICzoqfjlqr64WIjEXZllf/W6vK1goqleSR6brGomxQqA==",
+      "requires": {
+        "fast-deep-equal": "^3.1.3",
+        "multicast-dns": "^7.2.5"
+      }
+    },
+    "boolbase": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/boolbase/-/boolbase-1.0.0.tgz",
+      "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww=="
+    },
+    "boxen": {
+      "version": "6.2.1",
+      "resolved": "https://registry.facebook.net/boxen/-/boxen-6.2.1.tgz",
+      "integrity": "sha512-H4PEsJXfFI/Pt8sjDWbHlQPx4zL/bvSQjcilJmaulGt5mLDorHOHpmdXAJcBcmru7PhYSp/cDMWRko4ZUMFkSw==",
+      "requires": {
+        "ansi-align": "^3.0.1",
+        "camelcase": "^6.2.0",
+        "chalk": "^4.1.2",
+        "cli-boxes": "^3.0.0",
+        "string-width": "^5.0.1",
+        "type-fest": "^2.5.0",
+        "widest-line": "^4.0.1",
+        "wrap-ansi": "^8.0.1"
+      }
+    },
+    "brace-expansion": {
+      "version": "1.1.14",
+      "resolved": "https://registry.facebook.net/brace-expansion/-/brace-expansion-1.1.14.tgz",
+      "integrity": "sha512-MWPGfDxnyzKU7rNOW9SP/c50vi3xrmrua/+6hfPbCS2ABNWfx24vPidzvC7krjU/RTo235sV776ymlsMtGKj8g==",
+      "requires": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "braces": {
+      "version": "3.0.3",
+      "resolved": "https://registry.facebook.net/braces/-/braces-3.0.3.tgz",
+      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+      "requires": {
+        "fill-range": "^7.1.1"
+      }
+    },
+    "browserslist": {
+      "version": "4.28.2",
+      "resolved": "https://registry.facebook.net/browserslist/-/browserslist-4.28.2.tgz",
+      "integrity": "sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==",
+      "requires": {
+        "baseline-browser-mapping": "^2.10.12",
+        "caniuse-lite": "^1.0.30001782",
+        "electron-to-chromium": "^1.5.328",
+        "node-releases": "^2.0.36",
+        "update-browserslist-db": "^1.2.3"
+      }
+    },
+    "buffer-from": {
+      "version": "1.1.2",
+      "resolved": "https://registry.facebook.net/buffer-from/-/buffer-from-1.1.2.tgz",
+      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ=="
+    },
+    "bundle-name": {
+      "version": "4.1.0",
+      "resolved": "https://registry.facebook.net/bundle-name/-/bundle-name-4.1.0.tgz",
+      "integrity": "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==",
+      "requires": {
+        "run-applescript": "^7.0.0"
+      }
+    },
+    "bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.facebook.net/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg=="
+    },
+    "bytestreamjs": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/bytestreamjs/-/bytestreamjs-2.0.1.tgz",
+      "integrity": "sha512-U1Z/ob71V/bXfVABvNr/Kumf5VyeQRBEm6Txb0PQ6S7V5GpBM3w4Cbqz/xPDicR5tN0uvDifng8C+5qECeGwyQ=="
+    },
+    "cacheable-lookup": {
+      "version": "7.0.0",
+      "resolved": "https://registry.facebook.net/cacheable-lookup/-/cacheable-lookup-7.0.0.tgz",
+      "integrity": "sha512-+qJyx4xiKra8mZrcwhjMRMUhD5NR1R8esPkzIYxX96JiecFoxAXFuz/GpR3+ev4PE1WamHip78wV0vcmPQtp8w=="
+    },
+    "cacheable-request": {
+      "version": "10.2.14",
+      "resolved": "https://registry.facebook.net/cacheable-request/-/cacheable-request-10.2.14.tgz",
+      "integrity": "sha512-zkDT5WAF4hSSoUgyfg5tFIxz8XQK+25W/TLVojJTMKBaxevLBBtLxgqguAuVQB8PVW79FVjHcU+GJ9tVbDZ9mQ==",
+      "requires": {
+        "@types/http-cache-semantics": "^4.0.2",
+        "get-stream": "^6.0.1",
+        "http-cache-semantics": "^4.1.1",
+        "keyv": "^4.5.3",
+        "mimic-response": "^4.0.0",
+        "normalize-url": "^8.0.0",
+        "responselike": "^3.0.0"
+      },
+      "dependencies": {
+        "mimic-response": {
+          "version": "4.0.0",
+          "resolved": "https://registry.facebook.net/mimic-response/-/mimic-response-4.0.0.tgz",
+          "integrity": "sha512-e5ISH9xMYU0DzrT+jl8q2ze9D6eWBto+I8CNpe+VI+K2J/F/k3PdkdTdz4wvGVH4NTpo+NRYTVIuMQEMMcsLqg=="
+        }
+      }
+    },
+    "call-bind": {
+      "version": "1.0.9",
+      "resolved": "https://registry.facebook.net/call-bind/-/call-bind-1.0.9.tgz",
+      "integrity": "sha512-a/hy+pNsFUTR+Iz8TCJvXudKVLAnz/DyeSUo10I5yvFDQJBFU2s9uqQpoSrJlroHUKoKqzg+epxyP9lqFdzfBQ==",
+      "requires": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "get-intrinsic": "^1.3.0",
+        "set-function-length": "^1.2.2"
+      }
+    },
+    "call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.facebook.net/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "requires": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      }
+    },
+    "call-bound": {
+      "version": "1.0.4",
+      "resolved": "https://registry.facebook.net/call-bound/-/call-bound-1.0.4.tgz",
+      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
+      "requires": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "get-intrinsic": "^1.3.0"
+      }
+    },
+    "callsites": {
+      "version": "3.1.0",
+      "resolved": "https://registry.facebook.net/callsites/-/callsites-3.1.0.tgz",
+      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ=="
+    },
+    "camel-case": {
+      "version": "4.1.2",
+      "resolved": "https://registry.facebook.net/camel-case/-/camel-case-4.1.2.tgz",
+      "integrity": "sha512-gxGWBrTT1JuMx6R+o5PTXMmUnhnVzLQ9SNutD4YqKtI6ap897t3tKECYla6gCWEkplXnlNybEkZg9GEGxKFCgw==",
+      "requires": {
+        "pascal-case": "^3.1.2",
+        "tslib": "^2.0.3"
+      }
+    },
+    "camelcase": {
+      "version": "6.3.0",
+      "resolved": "https://registry.facebook.net/camelcase/-/camelcase-6.3.0.tgz",
+      "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA=="
+    },
+    "caniuse-api": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/caniuse-api/-/caniuse-api-3.0.0.tgz",
+      "integrity": "sha512-bsTwuIg/BZZK/vreVTYYbSWoe2F+71P7K5QGEX+pT250DZbfU1MQ5prOKpPR+LL6uWKK3KMwMCAS74QB3Um1uw==",
+      "requires": {
+        "browserslist": "^4.0.0",
+        "caniuse-lite": "^1.0.0",
+        "lodash.memoize": "^4.1.2",
+        "lodash.uniq": "^4.5.0"
+      }
+    },
+    "caniuse-lite": {
+      "version": "1.0.30001791",
+      "resolved": "https://registry.facebook.net/caniuse-lite/-/caniuse-lite-1.0.30001791.tgz",
+      "integrity": "sha512-yk0l/YSrOnFZk3UROpDLQD9+kC1l4meK/wed583AXrzoarMGJcbRi2Q4RaUYbKxYAsZ8sWmaSa/DsLmdBeI1vQ=="
+    },
+    "ccount": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/ccount/-/ccount-2.0.1.tgz",
+      "integrity": "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg=="
+    },
+    "chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.facebook.net/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "requires": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "dependencies": {
+        "supports-color": {
+          "version": "7.2.0",
+          "resolved": "https://registry.facebook.net/supports-color/-/supports-color-7.2.0.tgz",
+          "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+          "requires": {
+            "has-flag": "^4.0.0"
+          }
+        }
+      }
+    },
+    "char-regex": {
+      "version": "1.0.2",
+      "resolved": "https://registry.facebook.net/char-regex/-/char-regex-1.0.2.tgz",
+      "integrity": "sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw=="
+    },
+    "character-entities": {
+      "version": "2.0.2",
+      "resolved": "https://registry.facebook.net/character-entities/-/character-entities-2.0.2.tgz",
+      "integrity": "sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ=="
+    },
+    "character-entities-html4": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/character-entities-html4/-/character-entities-html4-2.1.0.tgz",
+      "integrity": "sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA=="
+    },
+    "character-entities-legacy": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz",
+      "integrity": "sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ=="
+    },
+    "character-reference-invalid": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/character-reference-invalid/-/character-reference-invalid-2.0.1.tgz",
+      "integrity": "sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw=="
+    },
+    "cheerio": {
+      "version": "1.0.0-rc.12",
+      "resolved": "https://registry.facebook.net/cheerio/-/cheerio-1.0.0-rc.12.tgz",
+      "integrity": "sha512-VqR8m68vM46BNnuZ5NtnGBKIE/DfN0cRIzg9n40EIq9NOv90ayxLBXA8fXC5gquFRGJSTRqBq25Jt2ECLR431Q==",
+      "requires": {
+        "cheerio-select": "^2.1.0",
+        "dom-serializer": "^2.0.0",
+        "domhandler": "^5.0.3",
+        "domutils": "^3.0.1",
+        "htmlparser2": "^8.0.1",
+        "parse5": "^7.0.0",
+        "parse5-htmlparser2-tree-adapter": "^7.0.0"
+      }
+    },
+    "cheerio-select": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/cheerio-select/-/cheerio-select-2.1.0.tgz",
+      "integrity": "sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==",
+      "requires": {
+        "boolbase": "^1.0.0",
+        "css-select": "^5.1.0",
+        "css-what": "^6.1.0",
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.3",
+        "domutils": "^3.0.1"
+      }
+    },
+    "chokidar": {
+      "version": "3.6.0",
+      "resolved": "https://registry.facebook.net/chokidar/-/chokidar-3.6.0.tgz",
+      "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
+      "requires": {
+        "anymatch": "~3.1.2",
+        "braces": "~3.0.2",
+        "fsevents": "~2.3.2",
+        "glob-parent": "~5.1.2",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.6.0"
+      }
+    },
+    "chrome-trace-event": {
+      "version": "1.0.4",
+      "resolved": "https://registry.facebook.net/chrome-trace-event/-/chrome-trace-event-1.0.4.tgz",
+      "integrity": "sha512-rNjApaLzuwaOTjCiT8lSDdGN1APCiqkChLMJxJPWLunPAt5fy8xgU9/jNOchV84wfIxrA0lRQB7oCT8jrn/wrQ=="
+    },
+    "ci-info": {
+      "version": "3.9.0",
+      "resolved": "https://registry.facebook.net/ci-info/-/ci-info-3.9.0.tgz",
+      "integrity": "sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ=="
+    },
+    "clean-css": {
+      "version": "5.3.3",
+      "resolved": "https://registry.facebook.net/clean-css/-/clean-css-5.3.3.tgz",
+      "integrity": "sha512-D5J+kHaVb/wKSFcyyV75uCn8fiY4sV38XJoe4CUyGQ+mOU/fMVYUdH1hJC+CJQ5uY3EnW27SbJYS4X8BiLrAFg==",
+      "requires": {
+        "source-map": "~0.6.0"
+      }
+    },
+    "clean-stack": {
+      "version": "2.2.0",
+      "resolved": "https://registry.facebook.net/clean-stack/-/clean-stack-2.2.0.tgz",
+      "integrity": "sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A=="
+    },
+    "cli-boxes": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/cli-boxes/-/cli-boxes-3.0.0.tgz",
+      "integrity": "sha512-/lzGpEWL/8PfI0BmBOPRwp0c/wFNX1RdUML3jK/RcSBA9T8mZDdQpqYBKtCFTOfQbwPqWEOpjqW+Fnayc0969g=="
+    },
+    "cli-table3": {
+      "version": "0.6.5",
+      "resolved": "https://registry.facebook.net/cli-table3/-/cli-table3-0.6.5.tgz",
+      "integrity": "sha512-+W/5efTR7y5HRD7gACw9yQjqMVvEMLBHmboM/kPWam+H+Hmyrgjh6YncVKK122YZkXrLudzTuAukUw9FnMf7IQ==",
+      "requires": {
+        "@colors/colors": "1.5.0",
+        "string-width": "^4.2.0"
+      },
+      "dependencies": {
+        "emoji-regex": {
+          "version": "8.0.0",
+          "resolved": "https://registry.facebook.net/emoji-regex/-/emoji-regex-8.0.0.tgz",
+          "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="
+        },
+        "string-width": {
+          "version": "4.2.3",
+          "resolved": "https://registry.facebook.net/string-width/-/string-width-4.2.3.tgz",
+          "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+          "requires": {
+            "emoji-regex": "^8.0.0",
+            "is-fullwidth-code-point": "^3.0.0",
+            "strip-ansi": "^6.0.1"
+          }
+        }
+      }
+    },
+    "clone-deep": {
+      "version": "4.0.1",
+      "resolved": "https://registry.facebook.net/clone-deep/-/clone-deep-4.0.1.tgz",
+      "integrity": "sha512-neHB9xuzh/wk0dIHweyAXv2aPGZIVk3pLMe+/RNzINf17fe0OG96QroktYAUm7SM1PBnzTabaLboqqxDyMU+SQ==",
+      "requires": {
+        "is-plain-object": "^2.0.4",
+        "kind-of": "^6.0.2",
+        "shallow-clone": "^3.0.0"
+      }
+    },
+    "clsx": {
+      "version": "2.1.1",
+      "resolved": "https://registry.facebook.net/clsx/-/clsx-2.1.1.tgz",
+      "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA=="
+    },
+    "collapse-white-space": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/collapse-white-space/-/collapse-white-space-2.1.0.tgz",
+      "integrity": "sha512-loKTxY1zCOuG4j9f6EPnuyyYkf58RnhhWTvRoZEokgB+WbdXehfjFviyOVYkqzEWz1Q5kRiZdBYS5SwxbQYwzw=="
+    },
+    "color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "requires": {
+        "color-name": "~1.1.4"
+      }
+    },
+    "color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.facebook.net/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="
+    },
+    "colord": {
+      "version": "2.9.3",
+      "resolved": "https://registry.facebook.net/colord/-/colord-2.9.3.tgz",
+      "integrity": "sha512-jeC1axXpnb0/2nn/Y1LPuLdgXBLH7aDcHu4KEKfqw3CUhX7ZpfBSlPKyqXE6btIgEzfWtrX3/tyBCaCvXvMkOw=="
+    },
+    "colorette": {
+      "version": "2.0.20",
+      "resolved": "https://registry.facebook.net/colorette/-/colorette-2.0.20.tgz",
+      "integrity": "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w=="
+    },
+    "combine-promises": {
+      "version": "1.2.0",
+      "resolved": "https://registry.facebook.net/combine-promises/-/combine-promises-1.2.0.tgz",
+      "integrity": "sha512-VcQB1ziGD0NXrhKxiwyNbCDmRzs/OShMs2GqW2DlU2A/Sd0nQxE1oWDAE5O0ygSx5mgQOn9eIFh7yKPgFRVkPQ=="
+    },
+    "combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.facebook.net/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "requires": {
+        "delayed-stream": "~1.0.0"
+      }
+    },
+    "comma-separated-tokens": {
+      "version": "2.0.3",
+      "resolved": "https://registry.facebook.net/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz",
+      "integrity": "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg=="
+    },
+    "commander": {
+      "version": "5.1.0",
+      "resolved": "https://registry.facebook.net/commander/-/commander-5.1.0.tgz",
+      "integrity": "sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg=="
+    },
+    "common-path-prefix": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/common-path-prefix/-/common-path-prefix-3.0.0.tgz",
+      "integrity": "sha512-QE33hToZseCH3jS0qN96O/bSh3kaw/h+Tq7ngyY9eWDUnTlTNUyqfqvCXioLe5Na5jFsL78ra/wuBU4iuEgd4w=="
+    },
+    "compressible": {
+      "version": "2.0.18",
+      "resolved": "https://registry.facebook.net/compressible/-/compressible-2.0.18.tgz",
+      "integrity": "sha512-AF3r7P5dWxL8MxyITRMlORQNaOA2IkAFaTr4k7BUumjPtRpGDTZpl0Pb1XCO6JeDCBdp126Cgs9sMxqSjgYyRg==",
+      "requires": {
+        "mime-db": ">= 1.43.0 < 2"
+      }
+    },
+    "compression": {
+      "version": "1.8.1",
+      "resolved": "https://registry.facebook.net/compression/-/compression-1.8.1.tgz",
+      "integrity": "sha512-9mAqGPHLakhCLeNyxPkK4xVo746zQ/czLH1Ky+vkitMnWfWZps8r0qXuwhwizagCRttsL4lfG4pIOvaWLpAP0w==",
+      "requires": {
+        "bytes": "3.1.2",
+        "compressible": "~2.0.18",
+        "debug": "2.6.9",
+        "negotiator": "~0.6.4",
+        "on-headers": "~1.1.0",
+        "safe-buffer": "5.2.1",
+        "vary": "~1.1.2"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "2.6.9",
+          "resolved": "https://registry.facebook.net/debug/-/debug-2.6.9.tgz",
+          "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+          "requires": {
+            "ms": "2.0.0"
+          }
+        },
+        "ms": {
+          "version": "2.0.0",
+          "resolved": "https://registry.facebook.net/ms/-/ms-2.0.0.tgz",
+          "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A=="
+        }
+      }
+    },
+    "concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.facebook.net/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg=="
+    },
+    "config-chain": {
+      "version": "1.1.13",
+      "resolved": "https://registry.facebook.net/config-chain/-/config-chain-1.1.13.tgz",
+      "integrity": "sha512-qj+f8APARXHrM0hraqXYb2/bOVSV4PvJQlNZ/DVj0QrmNM2q2euizkeuVckQ57J+W0mRH6Hvi+k50M4Jul2VRQ==",
+      "requires": {
+        "ini": "^1.3.4",
+        "proto-list": "~1.2.1"
+      }
+    },
+    "configstore": {
+      "version": "6.0.0",
+      "resolved": "https://registry.facebook.net/configstore/-/configstore-6.0.0.tgz",
+      "integrity": "sha512-cD31W1v3GqUlQvbBCGcXmd2Nj9SvLDOP1oQ0YFuLETufzSPaKp11rYBsSOm7rCsW3OnIRAFM3OxRhceaXNYHkA==",
+      "requires": {
+        "dot-prop": "^6.0.1",
+        "graceful-fs": "^4.2.6",
+        "unique-string": "^3.0.0",
+        "write-file-atomic": "^3.0.3",
+        "xdg-basedir": "^5.0.1"
+      }
+    },
+    "connect-history-api-fallback": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/connect-history-api-fallback/-/connect-history-api-fallback-2.0.0.tgz",
+      "integrity": "sha512-U73+6lQFmfiNPrYbXqr6kZ1i1wiRqXnp2nhMsINseWXO8lDau0LGEffJ8kQi4EjLZympVgRdvqjAgiZ1tgzDDA=="
+    },
+    "consola": {
+      "version": "3.4.2",
+      "resolved": "https://registry.facebook.net/consola/-/consola-3.4.2.tgz",
+      "integrity": "sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA=="
+    },
+    "content-disposition": {
+      "version": "0.5.2",
+      "resolved": "https://registry.facebook.net/content-disposition/-/content-disposition-0.5.2.tgz",
+      "integrity": "sha512-kRGRZw3bLlFISDBgwTSA1TMBFN6J6GWDeubmDE3AF+3+yXL8hTWv8r5rkLbqYXY4RjPk/EzHnClI3zQf1cFmHA=="
+    },
+    "content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.facebook.net/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA=="
+    },
+    "convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg=="
+    },
+    "cookie": {
+      "version": "0.7.2",
+      "resolved": "https://registry.facebook.net/cookie/-/cookie-0.7.2.tgz",
+      "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w=="
+    },
+    "cookie-signature": {
+      "version": "1.0.7",
+      "resolved": "https://registry.facebook.net/cookie-signature/-/cookie-signature-1.0.7.tgz",
+      "integrity": "sha512-NXdYc3dLr47pBkpUCHtKSwIOQXLVn8dZEuywboCOJY/osA0wFSLlSawr3KN8qXJEyX66FcONTH8EIlVuK0yyFA=="
+    },
+    "copy-text-to-clipboard": {
+      "version": "3.2.2",
+      "resolved": "https://registry.facebook.net/copy-text-to-clipboard/-/copy-text-to-clipboard-3.2.2.tgz",
+      "integrity": "sha512-T6SqyLd1iLuqPA90J5N4cTalrtovCySh58iiZDGJ6FGznbclKh4UI+FGacQSgFzwKG77W7XT5gwbVEbd9cIH1A=="
+    },
+    "copy-webpack-plugin": {
+      "version": "11.0.0",
+      "resolved": "https://registry.facebook.net/copy-webpack-plugin/-/copy-webpack-plugin-11.0.0.tgz",
+      "integrity": "sha512-fX2MWpamkW0hZxMEg0+mYnA40LTosOSa5TqZ9GYIBzyJa9C3QUaMPSE2xAi/buNr8u89SfD9wHSQVBzrRa/SOQ==",
+      "requires": {
+        "fast-glob": "^3.2.11",
+        "glob-parent": "^6.0.1",
+        "globby": "^13.1.1",
+        "normalize-path": "^3.0.0",
+        "schema-utils": "^4.0.0",
+        "serialize-javascript": "^6.0.0"
+      },
+      "dependencies": {
+        "glob-parent": {
+          "version": "6.0.2",
+          "resolved": "https://registry.facebook.net/glob-parent/-/glob-parent-6.0.2.tgz",
+          "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+          "requires": {
+            "is-glob": "^4.0.3"
+          }
+        },
+        "globby": {
+          "version": "13.2.2",
+          "resolved": "https://registry.facebook.net/globby/-/globby-13.2.2.tgz",
+          "integrity": "sha512-Y1zNGV+pzQdh7H39l9zgB4PJqjRNqydvdYCDG4HFXM4XuvSaQQlEc91IU1yALL8gUTDomgBAfz3XJdmUS+oo0w==",
+          "requires": {
+            "dir-glob": "^3.0.1",
+            "fast-glob": "^3.3.0",
+            "ignore": "^5.2.4",
+            "merge2": "^1.4.1",
+            "slash": "^4.0.0"
+          }
+        },
+        "slash": {
+          "version": "4.0.0",
+          "resolved": "https://registry.facebook.net/slash/-/slash-4.0.0.tgz",
+          "integrity": "sha512-3dOsAHXXUkQTpOYcoAxLIorMTp4gIQr5IW3iVb7A7lFIp0VHhnynm9izx6TssdrIcVIESAlVjtnO2K8bg+Coew=="
+        }
+      }
+    },
+    "core-js": {
+      "version": "3.49.0",
+      "resolved": "https://registry.facebook.net/core-js/-/core-js-3.49.0.tgz",
+      "integrity": "sha512-es1U2+YTtzpwkxVLwAFdSpaIMyQaq0PBgm3YD1W3Qpsn1NAmO3KSgZfu+oGSWVu6NvLHoHCV/aYcsE5wiB7ALg=="
+    },
+    "core-js-compat": {
+      "version": "3.49.0",
+      "resolved": "https://registry.facebook.net/core-js-compat/-/core-js-compat-3.49.0.tgz",
+      "integrity": "sha512-VQXt1jr9cBz03b331DFDCCP90b3fanciLkgiOoy8SBHy06gNf+vQ1A3WFLqG7I8TipYIKeYK9wxd0tUrvHcOZA==",
+      "requires": {
+        "browserslist": "^4.28.1"
+      }
+    },
+    "core-util-is": {
+      "version": "1.0.3",
+      "resolved": "https://registry.facebook.net/core-util-is/-/core-util-is-1.0.3.tgz",
+      "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ=="
+    },
+    "cosmiconfig": {
+      "version": "8.3.6",
+      "resolved": "https://registry.facebook.net/cosmiconfig/-/cosmiconfig-8.3.6.tgz",
+      "integrity": "sha512-kcZ6+W5QzcJ3P1Mt+83OUv/oHFqZHIx8DuxG6eZ5RGMERoLqp4BuGjhHLYGK+Kf5XVkQvqBSmAy/nGWN3qDgEA==",
+      "requires": {
+        "import-fresh": "^3.3.0",
+        "js-yaml": "^4.1.0",
+        "parse-json": "^5.2.0",
+        "path-type": "^4.0.0"
+      }
+    },
+    "cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.facebook.net/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "requires": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      }
+    },
+    "crypto-random-string": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/crypto-random-string/-/crypto-random-string-4.0.0.tgz",
+      "integrity": "sha512-x8dy3RnvYdlUcPOjkEHqozhiwzKNSq7GcPuXFbnyMOCHxX8V3OgIg/pYuabl2sbUPfIJaeAQB7PMOK8DFIdoRA==",
+      "requires": {
+        "type-fest": "^1.0.1"
+      },
+      "dependencies": {
+        "type-fest": {
+          "version": "1.4.0",
+          "resolved": "https://registry.facebook.net/type-fest/-/type-fest-1.4.0.tgz",
+          "integrity": "sha512-yGSza74xk0UG8k+pLh5oeoYirvIiWo5t0/o3zHHAO2tRDiZcxWP7fywNlXhqb6/r6sWvwi+RsyQMWhVLe4BVuA=="
+        }
+      }
+    },
+    "css-blank-pseudo": {
+      "version": "7.0.1",
+      "resolved": "https://registry.facebook.net/css-blank-pseudo/-/css-blank-pseudo-7.0.1.tgz",
+      "integrity": "sha512-jf+twWGDf6LDoXDUode+nc7ZlrqfaNphrBIBrcmeP3D8yw1uPaix1gCC8LUQUGQ6CycuK2opkbFFWFuq/a94ag==",
+      "requires": {
+        "postcss-selector-parser": "^7.0.0"
+      }
+    },
+    "css-declaration-sorter": {
+      "version": "7.4.0",
+      "resolved": "https://registry.facebook.net/css-declaration-sorter/-/css-declaration-sorter-7.4.0.tgz",
+      "integrity": "sha512-LTuzjPoyA2vMGKKcaOqKSp7Ub2eGrNfKiZH4LpezxpNrsICGCSFvsQOI29psISxNZtaXibkC2CXzrQ5enMeGGw==",
+      "requires": {}
+    },
+    "css-has-pseudo": {
+      "version": "7.0.3",
+      "resolved": "https://registry.facebook.net/css-has-pseudo/-/css-has-pseudo-7.0.3.tgz",
+      "integrity": "sha512-oG+vKuGyqe/xvEMoxAQrhi7uY16deJR3i7wwhBerVrGQKSqUC5GiOVxTpM9F9B9hw0J+eKeOWLH7E9gZ1Dr5rA==",
+      "requires": {
+        "@csstools/selector-specificity": "^5.0.0",
+        "postcss-selector-parser": "^7.0.0",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "css-loader": {
+      "version": "6.11.0",
+      "resolved": "https://registry.facebook.net/css-loader/-/css-loader-6.11.0.tgz",
+      "integrity": "sha512-CTJ+AEQJjq5NzLga5pE39qdiSV56F8ywCIsqNIRF0r7BDgWsN25aazToqAFg7ZrtA/U016xudB3ffgweORxX7g==",
+      "requires": {
+        "icss-utils": "^5.1.0",
+        "postcss": "^8.4.33",
+        "postcss-modules-extract-imports": "^3.1.0",
+        "postcss-modules-local-by-default": "^4.0.5",
+        "postcss-modules-scope": "^3.2.0",
+        "postcss-modules-values": "^4.0.0",
+        "postcss-value-parser": "^4.2.0",
+        "semver": "^7.5.4"
+      },
+      "dependencies": {
+        "semver": {
+          "version": "7.7.4",
+          "resolved": "https://registry.facebook.net/semver/-/semver-7.7.4.tgz",
+          "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA=="
+        }
+      }
+    },
+    "css-minimizer-webpack-plugin": {
+      "version": "5.0.1",
+      "resolved": "https://registry.facebook.net/css-minimizer-webpack-plugin/-/css-minimizer-webpack-plugin-5.0.1.tgz",
+      "integrity": "sha512-3caImjKFQkS+ws1TGcFn0V1HyDJFq1Euy589JlD6/3rV2kj+w7r5G9WDMgSHvpvXHNZ2calVypZWuEDQd9wfLg==",
+      "requires": {
+        "@jridgewell/trace-mapping": "^0.3.18",
+        "cssnano": "^6.0.1",
+        "jest-worker": "^29.4.3",
+        "postcss": "^8.4.24",
+        "schema-utils": "^4.0.1",
+        "serialize-javascript": "^6.0.1"
+      },
+      "dependencies": {
+        "jest-worker": {
+          "version": "29.7.0",
+          "resolved": "https://registry.facebook.net/jest-worker/-/jest-worker-29.7.0.tgz",
+          "integrity": "sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw==",
+          "requires": {
+            "@types/node": "*",
+            "jest-util": "^29.7.0",
+            "merge-stream": "^2.0.0",
+            "supports-color": "^8.0.0"
+          }
+        }
+      }
+    },
+    "css-prefers-color-scheme": {
+      "version": "10.0.0",
+      "resolved": "https://registry.facebook.net/css-prefers-color-scheme/-/css-prefers-color-scheme-10.0.0.tgz",
+      "integrity": "sha512-VCtXZAWivRglTZditUfB4StnsWr6YVZ2PRtuxQLKTNRdtAf8tpzaVPE9zXIF3VaSc7O70iK/j1+NXxyQCqdPjQ==",
+      "requires": {}
+    },
+    "css-select": {
+      "version": "5.2.2",
+      "resolved": "https://registry.facebook.net/css-select/-/css-select-5.2.2.tgz",
+      "integrity": "sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw==",
+      "requires": {
+        "boolbase": "^1.0.0",
+        "css-what": "^6.1.0",
+        "domhandler": "^5.0.2",
+        "domutils": "^3.0.1",
+        "nth-check": "^2.0.1"
+      }
+    },
+    "css-tree": {
+      "version": "2.3.1",
+      "resolved": "https://registry.facebook.net/css-tree/-/css-tree-2.3.1.tgz",
+      "integrity": "sha512-6Fv1DV/TYw//QF5IzQdqsNDjx/wc8TrMBZsqjL9eW01tWb7R7k/mq+/VXfJCl7SoD5emsJop9cOByJZfs8hYIw==",
+      "requires": {
+        "mdn-data": "2.0.30",
+        "source-map-js": "^1.0.1"
+      }
+    },
+    "css-what": {
+      "version": "6.2.2",
+      "resolved": "https://registry.facebook.net/css-what/-/css-what-6.2.2.tgz",
+      "integrity": "sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA=="
+    },
+    "cssdb": {
+      "version": "8.8.0",
+      "resolved": "https://registry.facebook.net/cssdb/-/cssdb-8.8.0.tgz",
+      "integrity": "sha512-QbLeyz2Bgso1iRlh7IpWk6OKa3lLNGXsujVjDMPl9rOZpxKeiG69icLpbLCFxeURwmcdIfZqQyhlooKJYM4f8Q=="
+    },
+    "cssesc": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/cssesc/-/cssesc-3.0.0.tgz",
+      "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg=="
+    },
+    "cssnano": {
+      "version": "6.1.2",
+      "resolved": "https://registry.facebook.net/cssnano/-/cssnano-6.1.2.tgz",
+      "integrity": "sha512-rYk5UeX7VAM/u0lNqewCdasdtPK81CgX8wJFLEIXHbV2oldWRgJAsZrdhRXkV1NJzA2g850KiFm9mMU2HxNxMA==",
+      "requires": {
+        "cssnano-preset-default": "^6.1.2",
+        "lilconfig": "^3.1.1"
+      }
+    },
+    "cssnano-preset-advanced": {
+      "version": "6.1.2",
+      "resolved": "https://registry.facebook.net/cssnano-preset-advanced/-/cssnano-preset-advanced-6.1.2.tgz",
+      "integrity": "sha512-Nhao7eD8ph2DoHolEzQs5CfRpiEP0xa1HBdnFZ82kvqdmbwVBUr2r1QuQ4t1pi+D1ZpqpcO4T+wy/7RxzJ/WPQ==",
+      "requires": {
+        "autoprefixer": "^10.4.19",
+        "browserslist": "^4.23.0",
+        "cssnano-preset-default": "^6.1.2",
+        "postcss-discard-unused": "^6.0.5",
+        "postcss-merge-idents": "^6.0.3",
+        "postcss-reduce-idents": "^6.0.3",
+        "postcss-zindex": "^6.0.2"
+      }
+    },
+    "cssnano-preset-default": {
+      "version": "6.1.2",
+      "resolved": "https://registry.facebook.net/cssnano-preset-default/-/cssnano-preset-default-6.1.2.tgz",
+      "integrity": "sha512-1C0C+eNaeN8OcHQa193aRgYexyJtU8XwbdieEjClw+J9d94E41LwT6ivKH0WT+fYwYWB0Zp3I3IZ7tI/BbUbrg==",
+      "requires": {
+        "browserslist": "^4.23.0",
+        "css-declaration-sorter": "^7.2.0",
+        "cssnano-utils": "^4.0.2",
+        "postcss-calc": "^9.0.1",
+        "postcss-colormin": "^6.1.0",
+        "postcss-convert-values": "^6.1.0",
+        "postcss-discard-comments": "^6.0.2",
+        "postcss-discard-duplicates": "^6.0.3",
+        "postcss-discard-empty": "^6.0.3",
+        "postcss-discard-overridden": "^6.0.2",
+        "postcss-merge-longhand": "^6.0.5",
+        "postcss-merge-rules": "^6.1.1",
+        "postcss-minify-font-values": "^6.1.0",
+        "postcss-minify-gradients": "^6.0.3",
+        "postcss-minify-params": "^6.1.0",
+        "postcss-minify-selectors": "^6.0.4",
+        "postcss-normalize-charset": "^6.0.2",
+        "postcss-normalize-display-values": "^6.0.2",
+        "postcss-normalize-positions": "^6.0.2",
+        "postcss-normalize-repeat-style": "^6.0.2",
+        "postcss-normalize-string": "^6.0.2",
+        "postcss-normalize-timing-functions": "^6.0.2",
+        "postcss-normalize-unicode": "^6.1.0",
+        "postcss-normalize-url": "^6.0.2",
+        "postcss-normalize-whitespace": "^6.0.2",
+        "postcss-ordered-values": "^6.0.2",
+        "postcss-reduce-initial": "^6.1.0",
+        "postcss-reduce-transforms": "^6.0.2",
+        "postcss-svgo": "^6.0.3",
+        "postcss-unique-selectors": "^6.0.4"
+      }
+    },
+    "cssnano-utils": {
+      "version": "4.0.2",
+      "resolved": "https://registry.facebook.net/cssnano-utils/-/cssnano-utils-4.0.2.tgz",
+      "integrity": "sha512-ZR1jHg+wZ8o4c3zqf1SIUSTIvm/9mU343FMR6Obe/unskbvpGhZOo1J6d/r8D1pzkRQYuwbcH3hToOuoA2G7oQ==",
+      "requires": {}
+    },
+    "csso": {
+      "version": "5.0.5",
+      "resolved": "https://registry.facebook.net/csso/-/csso-5.0.5.tgz",
+      "integrity": "sha512-0LrrStPOdJj+SPCCrGhzryycLjwcgUSHBtxNA8aIDxf0GLsRh1cKYhB00Gd1lDOS4yGH69+SNn13+TWbVHETFQ==",
+      "requires": {
+        "css-tree": "~2.2.0"
+      },
+      "dependencies": {
+        "css-tree": {
+          "version": "2.2.1",
+          "resolved": "https://registry.facebook.net/css-tree/-/css-tree-2.2.1.tgz",
+          "integrity": "sha512-OA0mILzGc1kCOCSJerOeqDxDQ4HOh+G8NbOJFOTgOCzpw7fCBubk0fEyxp8AgOL/jvLgYA/uV0cMbe43ElF1JA==",
+          "requires": {
+            "mdn-data": "2.0.28",
+            "source-map-js": "^1.0.1"
+          }
+        },
+        "mdn-data": {
+          "version": "2.0.28",
+          "resolved": "https://registry.facebook.net/mdn-data/-/mdn-data-2.0.28.tgz",
+          "integrity": "sha512-aylIc7Z9y4yzHYAJNuESG3hfhC+0Ibp/MAMiaOZgNv4pmEdFyfZhhhny4MNiAfWdBQ1RQ2mfDWmM1x8SvGyp8g=="
+        }
+      }
+    },
+    "csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.facebook.net/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ=="
+    },
+    "debounce": {
+      "version": "1.2.1",
+      "resolved": "https://registry.facebook.net/debounce/-/debounce-1.2.1.tgz",
+      "integrity": "sha512-XRRe6Glud4rd/ZGQfiV1ruXSfbvfJedlV9Y6zOlP+2K04vBYiJEte6stfFkCP03aMnY5tsipamumUjL14fofug=="
+    },
+    "debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.facebook.net/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "requires": {
+        "ms": "^2.1.3"
+      }
+    },
+    "decode-named-character-reference": {
+      "version": "1.3.0",
+      "resolved": "https://registry.facebook.net/decode-named-character-reference/-/decode-named-character-reference-1.3.0.tgz",
+      "integrity": "sha512-GtpQYB283KrPp6nRw50q3U9/VfOutZOe103qlN7BPP6Ad27xYnOIWv4lPzo8HCAL+mMZofJ9KEy30fq6MfaK6Q==",
+      "requires": {
+        "character-entities": "^2.0.0"
+      }
+    },
+    "decompress-response": {
+      "version": "6.0.0",
+      "resolved": "https://registry.facebook.net/decompress-response/-/decompress-response-6.0.0.tgz",
+      "integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==",
+      "requires": {
+        "mimic-response": "^3.1.0"
+      }
+    },
+    "deep-extend": {
+      "version": "0.6.0",
+      "resolved": "https://registry.facebook.net/deep-extend/-/deep-extend-0.6.0.tgz",
+      "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA=="
+    },
+    "deepmerge": {
+      "version": "4.3.1",
+      "resolved": "https://registry.facebook.net/deepmerge/-/deepmerge-4.3.1.tgz",
+      "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A=="
+    },
+    "default-browser": {
+      "version": "5.5.0",
+      "resolved": "https://registry.facebook.net/default-browser/-/default-browser-5.5.0.tgz",
+      "integrity": "sha512-H9LMLr5zwIbSxrmvikGuI/5KGhZ8E2zH3stkMgM5LpOWDutGM2JZaj460Udnf1a+946zc7YBgrqEWwbk7zHvGw==",
+      "requires": {
+        "bundle-name": "^4.1.0",
+        "default-browser-id": "^5.0.0"
+      }
+    },
+    "default-browser-id": {
+      "version": "5.0.1",
+      "resolved": "https://registry.facebook.net/default-browser-id/-/default-browser-id-5.0.1.tgz",
+      "integrity": "sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q=="
+    },
+    "defer-to-connect": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/defer-to-connect/-/defer-to-connect-2.0.1.tgz",
+      "integrity": "sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg=="
+    },
+    "define-data-property": {
+      "version": "1.1.4",
+      "resolved": "https://registry.facebook.net/define-data-property/-/define-data-property-1.1.4.tgz",
+      "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
+      "requires": {
+        "es-define-property": "^1.0.0",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.0.1"
+      }
+    },
+    "define-lazy-prop": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/define-lazy-prop/-/define-lazy-prop-2.0.0.tgz",
+      "integrity": "sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og=="
+    },
+    "define-properties": {
+      "version": "1.2.1",
+      "resolved": "https://registry.facebook.net/define-properties/-/define-properties-1.2.1.tgz",
+      "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==",
+      "requires": {
+        "define-data-property": "^1.0.1",
+        "has-property-descriptors": "^1.0.0",
+        "object-keys": "^1.1.1"
+      }
+    },
+    "delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ=="
+    },
+    "depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw=="
+    },
+    "dequal": {
+      "version": "2.0.3",
+      "resolved": "https://registry.facebook.net/dequal/-/dequal-2.0.3.tgz",
+      "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA=="
+    },
+    "destroy": {
+      "version": "1.2.0",
+      "resolved": "https://registry.facebook.net/destroy/-/destroy-1.2.0.tgz",
+      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg=="
+    },
+    "detect-node": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/detect-node/-/detect-node-2.1.0.tgz",
+      "integrity": "sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g=="
+    },
+    "detect-port": {
+      "version": "1.6.1",
+      "resolved": "https://registry.facebook.net/detect-port/-/detect-port-1.6.1.tgz",
+      "integrity": "sha512-CmnVc+Hek2egPx1PeTFVta2W78xy2K/9Rkf6cC4T59S50tVnzKj+tnx5mmx5lwvCkujZ4uRrpRSuV+IVs3f90Q==",
+      "requires": {
+        "address": "^1.0.1",
+        "debug": "4"
+      }
+    },
+    "devlop": {
+      "version": "1.1.0",
+      "resolved": "https://registry.facebook.net/devlop/-/devlop-1.1.0.tgz",
+      "integrity": "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==",
+      "requires": {
+        "dequal": "^2.0.0"
+      }
+    },
+    "dir-glob": {
+      "version": "3.0.1",
+      "resolved": "https://registry.facebook.net/dir-glob/-/dir-glob-3.0.1.tgz",
+      "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==",
+      "requires": {
+        "path-type": "^4.0.0"
+      }
+    },
+    "dns-packet": {
+      "version": "5.6.1",
+      "resolved": "https://registry.facebook.net/dns-packet/-/dns-packet-5.6.1.tgz",
+      "integrity": "sha512-l4gcSouhcgIKRvyy99RNVOgxXiicE+2jZoNmaNmZ6JXiGajBOJAesk1OBlJuM5k2c+eudGdLxDqXuPCKIj6kpw==",
+      "requires": {
+        "@leichtgewicht/ip-codec": "^2.0.1"
+      }
+    },
+    "dom-converter": {
+      "version": "0.2.0",
+      "resolved": "https://registry.facebook.net/dom-converter/-/dom-converter-0.2.0.tgz",
+      "integrity": "sha512-gd3ypIPfOMr9h5jIKq8E3sHOTCjeirnl0WK5ZdS1AW0Odt0b1PaWaHdJ4Qk4klv+YB9aJBS7mESXjFoDQPu6DA==",
+      "requires": {
+        "utila": "~0.4"
+      }
+    },
+    "dom-serializer": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/dom-serializer/-/dom-serializer-2.0.0.tgz",
+      "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==",
+      "requires": {
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.2",
+        "entities": "^4.2.0"
+      }
+    },
+    "domelementtype": {
+      "version": "2.3.0",
+      "resolved": "https://registry.facebook.net/domelementtype/-/domelementtype-2.3.0.tgz",
+      "integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw=="
+    },
+    "domhandler": {
+      "version": "5.0.3",
+      "resolved": "https://registry.facebook.net/domhandler/-/domhandler-5.0.3.tgz",
+      "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==",
+      "requires": {
+        "domelementtype": "^2.3.0"
+      }
+    },
+    "domutils": {
+      "version": "3.2.2",
+      "resolved": "https://registry.facebook.net/domutils/-/domutils-3.2.2.tgz",
+      "integrity": "sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==",
+      "requires": {
+        "dom-serializer": "^2.0.0",
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.3"
+      }
+    },
+    "dot-case": {
+      "version": "3.0.4",
+      "resolved": "https://registry.facebook.net/dot-case/-/dot-case-3.0.4.tgz",
+      "integrity": "sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w==",
+      "requires": {
+        "no-case": "^3.0.4",
+        "tslib": "^2.0.3"
+      }
+    },
+    "dot-prop": {
+      "version": "6.0.1",
+      "resolved": "https://registry.facebook.net/dot-prop/-/dot-prop-6.0.1.tgz",
+      "integrity": "sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA==",
+      "requires": {
+        "is-obj": "^2.0.0"
+      },
+      "dependencies": {
+        "is-obj": {
+          "version": "2.0.0",
+          "resolved": "https://registry.facebook.net/is-obj/-/is-obj-2.0.0.tgz",
+          "integrity": "sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w=="
+        }
+      }
+    },
+    "dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "requires": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      }
+    },
+    "duplexer": {
+      "version": "0.1.2",
+      "resolved": "https://registry.facebook.net/duplexer/-/duplexer-0.1.2.tgz",
+      "integrity": "sha512-jtD6YG370ZCIi/9GTaJKQxWTZD045+4R4hTk/x1UyoqadyJ9x9CgSi1RlVDQF8U2sxLLSnFkCaMihqljHIWgMg=="
+    },
+    "eastasianwidth": {
+      "version": "0.2.0",
+      "resolved": "https://registry.facebook.net/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
+      "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA=="
+    },
+    "ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.facebook.net/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow=="
+    },
+    "electron-to-chromium": {
+      "version": "1.5.344",
+      "resolved": "https://registry.facebook.net/electron-to-chromium/-/electron-to-chromium-1.5.344.tgz",
+      "integrity": "sha512-4MxfbmNDm+KPh066EZy+eUnkcDPcZ35wNmOWzFuh/ijvHsve6kbLTLURy88uCNK5FbpN+yk2nQY6BYh1GEt+wg=="
+    },
+    "emoji-regex": {
+      "version": "9.2.2",
+      "resolved": "https://registry.facebook.net/emoji-regex/-/emoji-regex-9.2.2.tgz",
+      "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="
+    },
+    "emojilib": {
+      "version": "2.4.0",
+      "resolved": "https://registry.facebook.net/emojilib/-/emojilib-2.4.0.tgz",
+      "integrity": "sha512-5U0rVMU5Y2n2+ykNLQqMoqklN9ICBT/KsvC1Gz6vqHbz2AXXGkG+Pm5rMWk/8Vjrr/mY9985Hi8DYzn1F09Nyw=="
+    },
+    "emojis-list": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/emojis-list/-/emojis-list-3.0.0.tgz",
+      "integrity": "sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q=="
+    },
+    "emoticon": {
+      "version": "4.1.0",
+      "resolved": "https://registry.facebook.net/emoticon/-/emoticon-4.1.0.tgz",
+      "integrity": "sha512-VWZfnxqwNcc51hIy/sbOdEem6D+cVtpPzEEtVAFdaas30+1dgkyaOQ4sQ6Bp0tOMqWO1v+HQfYaoodOkdhK6SQ=="
+    },
+    "encodeurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/encodeurl/-/encodeurl-2.0.0.tgz",
+      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg=="
+    },
+    "enhanced-resolve": {
+      "version": "5.21.0",
+      "resolved": "https://registry.facebook.net/enhanced-resolve/-/enhanced-resolve-5.21.0.tgz",
+      "integrity": "sha512-otxSQPw4lkOZWkHpB3zaEQs6gWYEsmX4xQF68ElXC/TWvGxGMSGOvoNbaLXm6/cS/fSfHtsEdw90y20PCd+sCA==",
+      "requires": {
+        "graceful-fs": "^4.2.4",
+        "tapable": "^2.3.3"
+      }
+    },
+    "entities": {
+      "version": "4.5.0",
+      "resolved": "https://registry.facebook.net/entities/-/entities-4.5.0.tgz",
+      "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw=="
+    },
+    "error-ex": {
+      "version": "1.3.4",
+      "resolved": "https://registry.facebook.net/error-ex/-/error-ex-1.3.4.tgz",
+      "integrity": "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ==",
+      "requires": {
+        "is-arrayish": "^0.2.1"
+      }
+    },
+    "es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g=="
+    },
+    "es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.facebook.net/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="
+    },
+    "es-module-lexer": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/es-module-lexer/-/es-module-lexer-2.1.0.tgz",
+      "integrity": "sha512-n27zTYMjYu1aj4MjCWzSP7G9r75utsaoc8m61weK+W8JMBGGQybd43GstCXZ3WNmSFtGT9wi59qQTW6mhTR5LQ=="
+    },
+    "es-object-atoms": {
+      "version": "1.1.1",
+      "resolved": "https://registry.facebook.net/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+      "requires": {
+        "es-errors": "^1.3.0"
+      }
+    },
+    "es-set-tostringtag": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+      "requires": {
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6",
+        "has-tostringtag": "^1.0.2",
+        "hasown": "^2.0.2"
+      }
+    },
+    "esast-util-from-estree": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/esast-util-from-estree/-/esast-util-from-estree-2.0.0.tgz",
+      "integrity": "sha512-4CyanoAudUSBAn5K13H4JhsMH6L9ZP7XbLVe/dKybkxMO7eDyLsT8UHl9TRNrU2Gr9nz+FovfSIjuXWJ81uVwQ==",
+      "requires": {
+        "@types/estree-jsx": "^1.0.0",
+        "devlop": "^1.0.0",
+        "estree-util-visit": "^2.0.0",
+        "unist-util-position-from-estree": "^2.0.0"
+      }
+    },
+    "esast-util-from-js": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/esast-util-from-js/-/esast-util-from-js-2.0.1.tgz",
+      "integrity": "sha512-8Ja+rNJ0Lt56Pcf3TAmpBZjmx8ZcK5Ts4cAzIOjsjevg9oSXJnl6SUQ2EevU8tv3h6ZLWmoKL5H4fgWvdvfETw==",
+      "requires": {
+        "@types/estree-jsx": "^1.0.0",
+        "acorn": "^8.0.0",
+        "esast-util-from-estree": "^2.0.0",
+        "vfile-message": "^4.0.0"
+      }
+    },
+    "escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.facebook.net/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA=="
+    },
+    "escape-goat": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/escape-goat/-/escape-goat-4.0.0.tgz",
+      "integrity": "sha512-2Sd4ShcWxbx6OY1IHyla/CVNwvg7XwZVoXZHcSu9w9SReNP1EzzD5T8NWKIR38fIqEns9kDWKUQTXXAmlDrdPg=="
+    },
+    "escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.facebook.net/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow=="
+    },
+    "escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA=="
+    },
+    "eslint-scope": {
+      "version": "5.1.1",
+      "resolved": "https://registry.facebook.net/eslint-scope/-/eslint-scope-5.1.1.tgz",
+      "integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==",
+      "requires": {
+        "esrecurse": "^4.3.0",
+        "estraverse": "^4.1.1"
+      }
+    },
+    "esprima": {
+      "version": "4.0.1",
+      "resolved": "https://registry.facebook.net/esprima/-/esprima-4.0.1.tgz",
+      "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A=="
+    },
+    "esrecurse": {
+      "version": "4.3.0",
+      "resolved": "https://registry.facebook.net/esrecurse/-/esrecurse-4.3.0.tgz",
+      "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
+      "requires": {
+        "estraverse": "^5.2.0"
+      },
+      "dependencies": {
+        "estraverse": {
+          "version": "5.3.0",
+          "resolved": "https://registry.facebook.net/estraverse/-/estraverse-5.3.0.tgz",
+          "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA=="
+        }
+      }
+    },
+    "estraverse": {
+      "version": "4.3.0",
+      "resolved": "https://registry.facebook.net/estraverse/-/estraverse-4.3.0.tgz",
+      "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw=="
+    },
+    "estree-util-attach-comments": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/estree-util-attach-comments/-/estree-util-attach-comments-3.0.0.tgz",
+      "integrity": "sha512-cKUwm/HUcTDsYh/9FgnuFqpfquUbwIqwKM26BVCGDPVgvaCl/nDCCjUfiLlx6lsEZ3Z4RFxNbOQ60pkaEwFxGw==",
+      "requires": {
+        "@types/estree": "^1.0.0"
+      }
+    },
+    "estree-util-build-jsx": {
+      "version": "3.0.1",
+      "resolved": "https://registry.facebook.net/estree-util-build-jsx/-/estree-util-build-jsx-3.0.1.tgz",
+      "integrity": "sha512-8U5eiL6BTrPxp/CHbs2yMgP8ftMhR5ww1eIKoWRMlqvltHF8fZn5LRDvTKuxD3DUn+shRbLGqXemcP51oFCsGQ==",
+      "requires": {
+        "@types/estree-jsx": "^1.0.0",
+        "devlop": "^1.0.0",
+        "estree-util-is-identifier-name": "^3.0.0",
+        "estree-walker": "^3.0.0"
+      }
+    },
+    "estree-util-is-identifier-name": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/estree-util-is-identifier-name/-/estree-util-is-identifier-name-3.0.0.tgz",
+      "integrity": "sha512-hFtqIDZTIUZ9BXLb8y4pYGyk6+wekIivNVTcmvk8NoOh+VeRn5y6cEHzbURrWbfp1fIqdVipilzj+lfaadNZmg=="
+    },
+    "estree-util-scope": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/estree-util-scope/-/estree-util-scope-1.0.0.tgz",
+      "integrity": "sha512-2CAASclonf+JFWBNJPndcOpA8EMJwa0Q8LUFJEKqXLW6+qBvbFZuF5gItbQOs/umBUkjviCSDCbBwU2cXbmrhQ==",
+      "requires": {
+        "@types/estree": "^1.0.0",
+        "devlop": "^1.0.0"
+      }
+    },
+    "estree-util-to-js": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/estree-util-to-js/-/estree-util-to-js-2.0.0.tgz",
+      "integrity": "sha512-WDF+xj5rRWmD5tj6bIqRi6CkLIXbbNQUcxQHzGysQzvHmdYG2G7p/Tf0J0gpxGgkeMZNTIjT/AoSvC9Xehcgdg==",
+      "requires": {
+        "@types/estree-jsx": "^1.0.0",
+        "astring": "^1.8.0",
+        "source-map": "^0.7.0"
+      },
+      "dependencies": {
+        "source-map": {
+          "version": "0.7.6",
+          "resolved": "https://registry.facebook.net/source-map/-/source-map-0.7.6.tgz",
+          "integrity": "sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ=="
+        }
+      }
+    },
+    "estree-util-value-to-estree": {
+      "version": "3.5.0",
+      "resolved": "https://registry.facebook.net/estree-util-value-to-estree/-/estree-util-value-to-estree-3.5.0.tgz",
+      "integrity": "sha512-aMV56R27Gv3QmfmF1MY12GWkGzzeAezAX+UplqHVASfjc9wNzI/X6hC0S9oxq61WT4aQesLGslWP9tKk6ghRZQ==",
+      "requires": {
+        "@types/estree": "^1.0.0"
+      }
+    },
+    "estree-util-visit": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/estree-util-visit/-/estree-util-visit-2.0.0.tgz",
+      "integrity": "sha512-m5KgiH85xAhhW8Wta0vShLcUvOsh3LLPI2YVwcbio1l7E09NTLL1EyMZFM1OyWowoH0skScNbhOPl4kcBgzTww==",
+      "requires": {
+        "@types/estree-jsx": "^1.0.0",
+        "@types/unist": "^3.0.0"
+      }
+    },
+    "estree-walker": {
+      "version": "3.0.3",
+      "resolved": "https://registry.facebook.net/estree-walker/-/estree-walker-3.0.3.tgz",
+      "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
+      "requires": {
+        "@types/estree": "^1.0.0"
+      }
+    },
+    "esutils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.facebook.net/esutils/-/esutils-2.0.3.tgz",
+      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g=="
+    },
+    "eta": {
+      "version": "2.2.0",
+      "resolved": "https://registry.facebook.net/eta/-/eta-2.2.0.tgz",
+      "integrity": "sha512-UVQ72Rqjy/ZKQalzV5dCCJP80GrmPrMxh6NlNf+erV6ObL0ZFkhCstWRawS85z3smdr3d2wXPsZEY7rDPfGd2g=="
+    },
+    "etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.facebook.net/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg=="
+    },
+    "eval": {
+      "version": "0.1.8",
+      "resolved": "https://registry.facebook.net/eval/-/eval-0.1.8.tgz",
+      "integrity": "sha512-EzV94NYKoO09GLXGjXj9JIlXijVck4ONSr5wiCWDvhsvj5jxSrzTmRU/9C1DyB6uToszLs8aifA6NQ7lEQdvFw==",
+      "requires": {
+        "@types/node": "*",
+        "require-like": ">= 0.1.1"
+      }
+    },
+    "eventemitter3": {
+      "version": "4.0.7",
+      "resolved": "https://registry.facebook.net/eventemitter3/-/eventemitter3-4.0.7.tgz",
+      "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw=="
+    },
+    "events": {
+      "version": "3.3.0",
+      "resolved": "https://registry.facebook.net/events/-/events-3.3.0.tgz",
+      "integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q=="
+    },
+    "execa": {
+      "version": "5.1.1",
+      "resolved": "https://registry.facebook.net/execa/-/execa-5.1.1.tgz",
+      "integrity": "sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==",
+      "requires": {
+        "cross-spawn": "^7.0.3",
+        "get-stream": "^6.0.0",
+        "human-signals": "^2.1.0",
+        "is-stream": "^2.0.0",
+        "merge-stream": "^2.0.0",
+        "npm-run-path": "^4.0.1",
+        "onetime": "^5.1.2",
+        "signal-exit": "^3.0.3",
+        "strip-final-newline": "^2.0.0"
+      }
+    },
+    "express": {
+      "version": "4.22.1",
+      "resolved": "https://registry.facebook.net/express/-/express-4.22.1.tgz",
+      "integrity": "sha512-F2X8g9P1X7uCPZMA3MVf9wcTqlyNp7IhH5qPCI0izhaOIYXaW9L535tGA3qmjRzpH+bZczqq7hVKxTR4NWnu+g==",
+      "requires": {
+        "accepts": "~1.3.8",
+        "array-flatten": "1.1.1",
+        "body-parser": "~1.20.3",
+        "content-disposition": "~0.5.4",
+        "content-type": "~1.0.4",
+        "cookie": "~0.7.1",
+        "cookie-signature": "~1.0.6",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "finalhandler": "~1.3.1",
+        "fresh": "~0.5.2",
+        "http-errors": "~2.0.0",
+        "merge-descriptors": "1.0.3",
+        "methods": "~1.1.2",
+        "on-finished": "~2.4.1",
+        "parseurl": "~1.3.3",
+        "path-to-regexp": "~0.1.12",
+        "proxy-addr": "~2.0.7",
+        "qs": "~6.14.0",
+        "range-parser": "~1.2.1",
+        "safe-buffer": "5.2.1",
+        "send": "~0.19.0",
+        "serve-static": "~1.16.2",
+        "setprototypeof": "1.2.0",
+        "statuses": "~2.0.1",
+        "type-is": "~1.6.18",
+        "utils-merge": "1.0.1",
+        "vary": "~1.1.2"
+      },
+      "dependencies": {
+        "content-disposition": {
+          "version": "0.5.4",
+          "resolved": "https://registry.facebook.net/content-disposition/-/content-disposition-0.5.4.tgz",
+          "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
+          "requires": {
+            "safe-buffer": "5.2.1"
+          }
+        },
+        "debug": {
+          "version": "2.6.9",
+          "resolved": "https://registry.facebook.net/debug/-/debug-2.6.9.tgz",
+          "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+          "requires": {
+            "ms": "2.0.0"
+          }
+        },
+        "ms": {
+          "version": "2.0.0",
+          "resolved": "https://registry.facebook.net/ms/-/ms-2.0.0.tgz",
+          "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A=="
+        },
+        "path-to-regexp": {
+          "version": "0.1.13",
+          "resolved": "https://registry.facebook.net/path-to-regexp/-/path-to-regexp-0.1.13.tgz",
+          "integrity": "sha512-A/AGNMFN3c8bOlvV9RreMdrv7jsmF9XIfDeCd87+I8RNg6s78BhJxMu69NEMHBSJFxKidViTEdruRwEk/WIKqA=="
+        }
+      }
+    },
+    "extend": {
+      "version": "3.0.2",
+      "resolved": "https://registry.facebook.net/extend/-/extend-3.0.2.tgz",
+      "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g=="
+    },
+    "extend-shallow": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/extend-shallow/-/extend-shallow-2.0.1.tgz",
+      "integrity": "sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==",
+      "requires": {
+        "is-extendable": "^0.1.0"
+      }
+    },
+    "fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.facebook.net/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="
+    },
+    "fast-glob": {
+      "version": "3.3.3",
+      "resolved": "https://registry.facebook.net/fast-glob/-/fast-glob-3.3.3.tgz",
+      "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==",
+      "requires": {
+        "@nodelib/fs.stat": "^2.0.2",
+        "@nodelib/fs.walk": "^1.2.3",
+        "glob-parent": "^5.1.2",
+        "merge2": "^1.3.0",
+        "micromatch": "^4.0.8"
+      }
+    },
+    "fast-json-stable-stringify": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw=="
+    },
+    "fast-uri": {
+      "version": "3.1.0",
+      "resolved": "https://registry.facebook.net/fast-uri/-/fast-uri-3.1.0.tgz",
+      "integrity": "sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA=="
+    },
+    "fastq": {
+      "version": "1.20.1",
+      "resolved": "https://registry.facebook.net/fastq/-/fastq-1.20.1.tgz",
+      "integrity": "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==",
+      "requires": {
+        "reusify": "^1.0.4"
+      }
+    },
+    "fault": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/fault/-/fault-2.0.1.tgz",
+      "integrity": "sha512-WtySTkS4OKev5JtpHXnib4Gxiurzh5NCGvWrFaZ34m6JehfTUhKZvn9njTfw48t6JumVQOmrKqpmGcdwxnhqBQ==",
+      "requires": {
+        "format": "^0.2.0"
+      }
+    },
+    "faye-websocket": {
+      "version": "0.11.4",
+      "resolved": "https://registry.facebook.net/faye-websocket/-/faye-websocket-0.11.4.tgz",
+      "integrity": "sha512-CzbClwlXAuiRQAlUyfqPgvPoNKTckTPGfwZV4ZdAhVcP2lh9KUxJg2b5GkE7XbjKQ3YJnQ9z6D9ntLAlB+tP8g==",
+      "requires": {
+        "websocket-driver": ">=0.5.1"
+      }
+    },
+    "feed": {
+      "version": "4.2.2",
+      "resolved": "https://registry.facebook.net/feed/-/feed-4.2.2.tgz",
+      "integrity": "sha512-u5/sxGfiMfZNtJ3OvQpXcvotFpYkL0n9u9mM2vkui2nGo8b4wvDkJ8gAkYqbA8QpGyFCv3RK0Z+Iv+9veCS9bQ==",
+      "requires": {
+        "xml-js": "^1.6.11"
+      }
+    },
+    "figures": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/figures/-/figures-3.2.0.tgz",
+      "integrity": "sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg==",
+      "requires": {
+        "escape-string-regexp": "^1.0.5"
+      },
+      "dependencies": {
+        "escape-string-regexp": {
+          "version": "1.0.5",
+          "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
+          "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg=="
+        }
+      }
+    },
+    "file-loader": {
+      "version": "6.2.0",
+      "resolved": "https://registry.facebook.net/file-loader/-/file-loader-6.2.0.tgz",
+      "integrity": "sha512-qo3glqyTa61Ytg4u73GultjHGjdRyig3tG6lPtyX/jOEJvHif9uB0/OCI2Kif6ctF3caQTW2G5gym21oAsI4pw==",
+      "requires": {
+        "loader-utils": "^2.0.0",
+        "schema-utils": "^3.0.0"
+      },
+      "dependencies": {
+        "ajv": {
+          "version": "6.15.0",
+          "resolved": "https://registry.facebook.net/ajv/-/ajv-6.15.0.tgz",
+          "integrity": "sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==",
+          "requires": {
+            "fast-deep-equal": "^3.1.1",
+            "fast-json-stable-stringify": "^2.0.0",
+            "json-schema-traverse": "^0.4.1",
+            "uri-js": "^4.2.2"
+          }
+        },
+        "ajv-keywords": {
+          "version": "3.5.2",
+          "resolved": "https://registry.facebook.net/ajv-keywords/-/ajv-keywords-3.5.2.tgz",
+          "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==",
+          "requires": {}
+        },
+        "json-schema-traverse": {
+          "version": "0.4.1",
+          "resolved": "https://registry.facebook.net/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+          "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="
+        },
+        "schema-utils": {
+          "version": "3.3.0",
+          "resolved": "https://registry.facebook.net/schema-utils/-/schema-utils-3.3.0.tgz",
+          "integrity": "sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==",
+          "requires": {
+            "@types/json-schema": "^7.0.8",
+            "ajv": "^6.12.5",
+            "ajv-keywords": "^3.5.2"
+          }
+        }
+      }
+    },
+    "fill-range": {
+      "version": "7.1.1",
+      "resolved": "https://registry.facebook.net/fill-range/-/fill-range-7.1.1.tgz",
+      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+      "requires": {
+        "to-regex-range": "^5.0.1"
+      }
+    },
+    "finalhandler": {
+      "version": "1.3.2",
+      "resolved": "https://registry.facebook.net/finalhandler/-/finalhandler-1.3.2.tgz",
+      "integrity": "sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg==",
+      "requires": {
+        "debug": "2.6.9",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "on-finished": "~2.4.1",
+        "parseurl": "~1.3.3",
+        "statuses": "~2.0.2",
+        "unpipe": "~1.0.0"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "2.6.9",
+          "resolved": "https://registry.facebook.net/debug/-/debug-2.6.9.tgz",
+          "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+          "requires": {
+            "ms": "2.0.0"
+          }
+        },
+        "ms": {
+          "version": "2.0.0",
+          "resolved": "https://registry.facebook.net/ms/-/ms-2.0.0.tgz",
+          "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A=="
+        }
+      }
+    },
+    "find-cache-dir": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/find-cache-dir/-/find-cache-dir-4.0.0.tgz",
+      "integrity": "sha512-9ZonPT4ZAK4a+1pUPVPZJapbi7O5qbbJPdYw/NOQWZZbVLdDTYM3A4R9z/DpAM08IDaFGsvPgiGZ82WEwUDWjg==",
+      "requires": {
+        "common-path-prefix": "^3.0.0",
+        "pkg-dir": "^7.0.0"
+      }
+    },
+    "find-up": {
+      "version": "6.3.0",
+      "resolved": "https://registry.facebook.net/find-up/-/find-up-6.3.0.tgz",
+      "integrity": "sha512-v2ZsoEuVHYy8ZIlYqwPe/39Cy+cFDzp4dXPaxNvkEuouymu+2Jbz0PxpKarJHYJTmv2HWT3O382qY8l4jMWthw==",
+      "requires": {
+        "locate-path": "^7.1.0",
+        "path-exists": "^5.0.0"
+      }
+    },
+    "flat": {
+      "version": "5.0.2",
+      "resolved": "https://registry.facebook.net/flat/-/flat-5.0.2.tgz",
+      "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ=="
+    },
+    "follow-redirects": {
+      "version": "1.16.0",
+      "resolved": "https://registry.facebook.net/follow-redirects/-/follow-redirects-1.16.0.tgz",
+      "integrity": "sha512-y5rN/uOsadFT/JfYwhxRS5R7Qce+g3zG97+JrtFZlC9klX/W5hD7iiLzScI4nZqUS7DNUdhPgw4xI8W2LuXlUw=="
+    },
+    "form-data": {
+      "version": "4.0.5",
+      "resolved": "https://registry.facebook.net/form-data/-/form-data-4.0.5.tgz",
+      "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
+      "requires": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "es-set-tostringtag": "^2.1.0",
+        "hasown": "^2.0.2",
+        "mime-types": "^2.1.12"
+      }
+    },
+    "form-data-encoder": {
+      "version": "2.1.4",
+      "resolved": "https://registry.facebook.net/form-data-encoder/-/form-data-encoder-2.1.4.tgz",
+      "integrity": "sha512-yDYSgNMraqvnxiEXO4hi88+YZxaHC6QKzb5N84iRCTDeRO7ZALpir/lVmf/uXUhnwUr2O4HU8s/n6x+yNjQkHw=="
+    },
+    "format": {
+      "version": "0.2.2",
+      "resolved": "https://registry.facebook.net/format/-/format-0.2.2.tgz",
+      "integrity": "sha512-wzsgA6WOq+09wrU1tsJ09udeR/YZRaeArL9e1wPbFg3GG2yDnC2ldKpxs4xunpFF9DgqCqOIra3bc1HWrJ37Ww=="
+    },
+    "forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.facebook.net/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow=="
+    },
+    "fraction.js": {
+      "version": "5.3.4",
+      "resolved": "https://registry.facebook.net/fraction.js/-/fraction.js-5.3.4.tgz",
+      "integrity": "sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ=="
+    },
+    "fresh": {
+      "version": "0.5.2",
+      "resolved": "https://registry.facebook.net/fresh/-/fresh-0.5.2.tgz",
+      "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q=="
+    },
+    "fs-extra": {
+      "version": "11.3.4",
+      "resolved": "https://registry.facebook.net/fs-extra/-/fs-extra-11.3.4.tgz",
+      "integrity": "sha512-CTXd6rk/M3/ULNQj8FBqBWHYBVYybQ3VPBw0xGKFe3tuH7ytT6ACnvzpIQ3UZtB8yvUKC2cXn1a+x+5EVQLovA==",
+      "requires": {
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
+      }
+    },
+    "function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.facebook.net/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="
+    },
+    "gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.facebook.net/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg=="
+    },
+    "get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.facebook.net/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "requires": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      }
+    },
+    "get-own-enumerable-property-symbols": {
+      "version": "3.0.2",
+      "resolved": "https://registry.facebook.net/get-own-enumerable-property-symbols/-/get-own-enumerable-property-symbols-3.0.2.tgz",
+      "integrity": "sha512-I0UBV/XOz1XkIJHEUDMZAbzCThU/H8DxmSfmdGcKPnVhu2VfFqr34jr9777IyaTYvxjedWhqVIilEDsCdP5G6g=="
+    },
+    "get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "requires": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      }
+    },
+    "get-stream": {
+      "version": "6.0.1",
+      "resolved": "https://registry.facebook.net/get-stream/-/get-stream-6.0.1.tgz",
+      "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg=="
+    },
+    "github-slugger": {
+      "version": "1.5.0",
+      "resolved": "https://registry.facebook.net/github-slugger/-/github-slugger-1.5.0.tgz",
+      "integrity": "sha512-wIh+gKBI9Nshz2o46B0B3f5k/W+WI9ZAv6y5Dn5WJ5SK1t0TnDimB4WE5rmTD05ZAIn8HALCZVmCsvj0w0v0lw=="
+    },
+    "glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://registry.facebook.net/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "requires": {
+        "is-glob": "^4.0.1"
+      }
+    },
+    "glob-to-regex.js": {
+      "version": "1.2.0",
+      "resolved": "https://registry.facebook.net/glob-to-regex.js/-/glob-to-regex.js-1.2.0.tgz",
+      "integrity": "sha512-QMwlOQKU/IzqMUOAZWubUOT8Qft+Y0KQWnX9nK3ch0CJg0tTp4TvGZsTfudYKv2NzoQSyPcnA6TYeIQ3jGichQ==",
+      "requires": {}
+    },
+    "glob-to-regexp": {
+      "version": "0.4.1",
+      "resolved": "https://registry.facebook.net/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz",
+      "integrity": "sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw=="
+    },
+    "global-dirs": {
+      "version": "3.0.1",
+      "resolved": "https://registry.facebook.net/global-dirs/-/global-dirs-3.0.1.tgz",
+      "integrity": "sha512-NBcGGFbBA9s1VzD41QXDG+3++t9Mn5t1FpLdhESY6oKY4gYTFpX4wO3sqGUa0Srjtbfj3szX0RnemmrVRUdULA==",
+      "requires": {
+        "ini": "2.0.0"
+      },
+      "dependencies": {
+        "ini": {
+          "version": "2.0.0",
+          "resolved": "https://registry.facebook.net/ini/-/ini-2.0.0.tgz",
+          "integrity": "sha512-7PnF4oN3CvZF23ADhA5wRaYEQpJ8qygSkbtTXWBeXWXmEVRXK+1ITciHWwHhsjv1TmW0MgacIv6hEi5pX5NQdA=="
+        }
+      }
+    },
+    "globby": {
+      "version": "11.1.0",
+      "resolved": "https://registry.facebook.net/globby/-/globby-11.1.0.tgz",
+      "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==",
+      "requires": {
+        "array-union": "^2.1.0",
+        "dir-glob": "^3.0.1",
+        "fast-glob": "^3.2.9",
+        "ignore": "^5.2.0",
+        "merge2": "^1.4.1",
+        "slash": "^3.0.0"
+      }
+    },
+    "gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.facebook.net/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="
+    },
+    "got": {
+      "version": "12.6.1",
+      "resolved": "https://registry.facebook.net/got/-/got-12.6.1.tgz",
+      "integrity": "sha512-mThBblvlAF1d4O5oqyvN+ZxLAYwIJK7bpMxgYqPD9okW0C3qm5FFn7k811QrcuEBwaogR3ngOFoCfs6mRv7teQ==",
+      "requires": {
+        "@sindresorhus/is": "^5.2.0",
+        "@szmarczak/http-timer": "^5.0.1",
+        "cacheable-lookup": "^7.0.0",
+        "cacheable-request": "^10.2.8",
+        "decompress-response": "^6.0.0",
+        "form-data-encoder": "^2.1.2",
+        "get-stream": "^6.0.1",
+        "http2-wrapper": "^2.1.10",
+        "lowercase-keys": "^3.0.0",
+        "p-cancelable": "^3.0.0",
+        "responselike": "^3.0.0"
+      },
+      "dependencies": {
+        "@sindresorhus/is": {
+          "version": "5.6.0",
+          "resolved": "https://registry.facebook.net/@sindresorhus/is/-/is-5.6.0.tgz",
+          "integrity": "sha512-TV7t8GKYaJWsn00tFDqBw8+Uqmr8A0fRU1tvTQhyZzGv0sJCGRQL3JGMI3ucuKo3XIZdUP+Lx7/gh2t3lewy7g=="
+        }
+      }
+    },
+    "graceful-fs": {
+      "version": "4.2.11",
+      "resolved": "https://registry.facebook.net/graceful-fs/-/graceful-fs-4.2.11.tgz",
+      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="
+    },
+    "gray-matter": {
+      "version": "4.0.3",
+      "resolved": "https://registry.facebook.net/gray-matter/-/gray-matter-4.0.3.tgz",
+      "integrity": "sha512-5v6yZd4JK3eMI3FqqCouswVqwugaA9r4dNZB1wwcmrD02QkV5H0y7XBQW8QwQqEaZY1pM9aqORSORhJRdNK44Q==",
+      "requires": {
+        "js-yaml": "^3.13.1",
+        "kind-of": "^6.0.2",
+        "section-matter": "^1.0.0",
+        "strip-bom-string": "^1.0.0"
+      },
+      "dependencies": {
+        "argparse": {
+          "version": "1.0.10",
+          "resolved": "https://registry.facebook.net/argparse/-/argparse-1.0.10.tgz",
+          "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
+          "requires": {
+            "sprintf-js": "~1.0.2"
+          }
+        },
+        "js-yaml": {
+          "version": "3.14.2",
+          "resolved": "https://registry.facebook.net/js-yaml/-/js-yaml-3.14.2.tgz",
+          "integrity": "sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==",
+          "requires": {
+            "argparse": "^1.0.7",
+            "esprima": "^4.0.0"
+          }
+        }
+      }
+    },
+    "gzip-size": {
+      "version": "6.0.0",
+      "resolved": "https://registry.facebook.net/gzip-size/-/gzip-size-6.0.0.tgz",
+      "integrity": "sha512-ax7ZYomf6jqPTQ4+XCpUGyXKHk5WweS+e05MBO4/y3WJ5RkmPXNKvX+bx1behVILVwr6JSQvZAku021CHPXG3Q==",
+      "requires": {
+        "duplexer": "^0.1.2"
+      }
+    },
+    "handle-thing": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/handle-thing/-/handle-thing-2.0.1.tgz",
+      "integrity": "sha512-9Qn4yBxelxoh2Ow62nP+Ka/kMnOXRi8BXnRaUwezLNhqelnN49xKz4F/dPP8OYLxLxq6JDtZb2i9XznUQbNPTg=="
+    },
+    "has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="
+    },
+    "has-property-descriptors": {
+      "version": "1.0.2",
+      "resolved": "https://registry.facebook.net/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
+      "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
+      "requires": {
+        "es-define-property": "^1.0.0"
+      }
+    },
+    "has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.facebook.net/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="
+    },
+    "has-tostringtag": {
+      "version": "1.0.2",
+      "resolved": "https://registry.facebook.net/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+      "requires": {
+        "has-symbols": "^1.0.3"
+      }
+    },
+    "has-yarn": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/has-yarn/-/has-yarn-3.0.0.tgz",
+      "integrity": "sha512-IrsVwUHhEULx3R8f/aA8AHuEzAorplsab/v8HBzEiIukwq5i/EC+xmOW+HfP1OaDP+2JkgT1yILHN2O3UFIbcA=="
+    },
+    "hasown": {
+      "version": "2.0.3",
+      "resolved": "https://registry.facebook.net/hasown/-/hasown-2.0.3.tgz",
+      "integrity": "sha512-ej4AhfhfL2Q2zpMmLo7U1Uv9+PyhIZpgQLGT1F9miIGmiCJIoCgSmczFdrc97mWT4kVY72KA+WnnhJ5pghSvSg==",
+      "requires": {
+        "function-bind": "^1.1.2"
+      }
+    },
+    "hast-util-from-parse5": {
+      "version": "8.0.3",
+      "resolved": "https://registry.facebook.net/hast-util-from-parse5/-/hast-util-from-parse5-8.0.3.tgz",
+      "integrity": "sha512-3kxEVkEKt0zvcZ3hCRYI8rqrgwtlIOFMWkbclACvjlDw8Li9S2hk/d51OI0nr/gIpdMHNepwgOKqZ/sy0Clpyg==",
+      "requires": {
+        "@types/hast": "^3.0.0",
+        "@types/unist": "^3.0.0",
+        "devlop": "^1.0.0",
+        "hastscript": "^9.0.0",
+        "property-information": "^7.0.0",
+        "vfile": "^6.0.0",
+        "vfile-location": "^5.0.0",
+        "web-namespaces": "^2.0.0"
+      }
+    },
+    "hast-util-parse-selector": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/hast-util-parse-selector/-/hast-util-parse-selector-4.0.0.tgz",
+      "integrity": "sha512-wkQCkSYoOGCRKERFWcxMVMOcYE2K1AaNLU8DXS9arxnLOUEWbOXKXiJUNzEpqZ3JOKpnha3jkFrumEjVliDe7A==",
+      "requires": {
+        "@types/hast": "^3.0.0"
+      }
+    },
+    "hast-util-raw": {
+      "version": "9.1.0",
+      "resolved": "https://registry.facebook.net/hast-util-raw/-/hast-util-raw-9.1.0.tgz",
+      "integrity": "sha512-Y8/SBAHkZGoNkpzqqfCldijcuUKh7/su31kEBp67cFY09Wy0mTRgtsLYsiIxMJxlu0f6AA5SUTbDR8K0rxnbUw==",
+      "requires": {
+        "@types/hast": "^3.0.0",
+        "@types/unist": "^3.0.0",
+        "@ungap/structured-clone": "^1.0.0",
+        "hast-util-from-parse5": "^8.0.0",
+        "hast-util-to-parse5": "^8.0.0",
+        "html-void-elements": "^3.0.0",
+        "mdast-util-to-hast": "^13.0.0",
+        "parse5": "^7.0.0",
+        "unist-util-position": "^5.0.0",
+        "unist-util-visit": "^5.0.0",
+        "vfile": "^6.0.0",
+        "web-namespaces": "^2.0.0",
+        "zwitch": "^2.0.0"
+      }
+    },
+    "hast-util-to-estree": {
+      "version": "3.1.3",
+      "resolved": "https://registry.facebook.net/hast-util-to-estree/-/hast-util-to-estree-3.1.3.tgz",
+      "integrity": "sha512-48+B/rJWAp0jamNbAAf9M7Uf//UVqAoMmgXhBdxTDJLGKY+LRnZ99qcG+Qjl5HfMpYNzS5v4EAwVEF34LeAj7w==",
+      "requires": {
+        "@types/estree": "^1.0.0",
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "comma-separated-tokens": "^2.0.0",
+        "devlop": "^1.0.0",
+        "estree-util-attach-comments": "^3.0.0",
+        "estree-util-is-identifier-name": "^3.0.0",
+        "hast-util-whitespace": "^3.0.0",
+        "mdast-util-mdx-expression": "^2.0.0",
+        "mdast-util-mdx-jsx": "^3.0.0",
+        "mdast-util-mdxjs-esm": "^2.0.0",
+        "property-information": "^7.0.0",
+        "space-separated-tokens": "^2.0.0",
+        "style-to-js": "^1.0.0",
+        "unist-util-position": "^5.0.0",
+        "zwitch": "^2.0.0"
+      }
+    },
+    "hast-util-to-jsx-runtime": {
+      "version": "2.3.6",
+      "resolved": "https://registry.facebook.net/hast-util-to-jsx-runtime/-/hast-util-to-jsx-runtime-2.3.6.tgz",
+      "integrity": "sha512-zl6s8LwNyo1P9uw+XJGvZtdFF1GdAkOg8ujOw+4Pyb76874fLps4ueHXDhXWdk6YHQ6OgUtinliG7RsYvCbbBg==",
+      "requires": {
+        "@types/estree": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/unist": "^3.0.0",
+        "comma-separated-tokens": "^2.0.0",
+        "devlop": "^1.0.0",
+        "estree-util-is-identifier-name": "^3.0.0",
+        "hast-util-whitespace": "^3.0.0",
+        "mdast-util-mdx-expression": "^2.0.0",
+        "mdast-util-mdx-jsx": "^3.0.0",
+        "mdast-util-mdxjs-esm": "^2.0.0",
+        "property-information": "^7.0.0",
+        "space-separated-tokens": "^2.0.0",
+        "style-to-js": "^1.0.0",
+        "unist-util-position": "^5.0.0",
+        "vfile-message": "^4.0.0"
+      }
+    },
+    "hast-util-to-parse5": {
+      "version": "8.0.1",
+      "resolved": "https://registry.facebook.net/hast-util-to-parse5/-/hast-util-to-parse5-8.0.1.tgz",
+      "integrity": "sha512-MlWT6Pjt4CG9lFCjiz4BH7l9wmrMkfkJYCxFwKQic8+RTZgWPuWxwAfjJElsXkex7DJjfSJsQIt931ilUgmwdA==",
+      "requires": {
+        "@types/hast": "^3.0.0",
+        "comma-separated-tokens": "^2.0.0",
+        "devlop": "^1.0.0",
+        "property-information": "^7.0.0",
+        "space-separated-tokens": "^2.0.0",
+        "web-namespaces": "^2.0.0",
+        "zwitch": "^2.0.0"
+      }
+    },
+    "hast-util-whitespace": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz",
+      "integrity": "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==",
+      "requires": {
+        "@types/hast": "^3.0.0"
+      }
+    },
+    "hastscript": {
+      "version": "9.0.1",
+      "resolved": "https://registry.facebook.net/hastscript/-/hastscript-9.0.1.tgz",
+      "integrity": "sha512-g7df9rMFX/SPi34tyGCyUBREQoKkapwdY/T04Qn9TDWfHhAYt4/I0gMVirzK5wEzeUqIjEB+LXC/ypb7Aqno5w==",
+      "requires": {
+        "@types/hast": "^3.0.0",
+        "comma-separated-tokens": "^2.0.0",
+        "hast-util-parse-selector": "^4.0.0",
+        "property-information": "^7.0.0",
+        "space-separated-tokens": "^2.0.0"
+      }
+    },
+    "he": {
+      "version": "1.2.0",
+      "resolved": "https://registry.facebook.net/he/-/he-1.2.0.tgz",
+      "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw=="
+    },
+    "history": {
+      "version": "4.10.1",
+      "resolved": "https://registry.facebook.net/history/-/history-4.10.1.tgz",
+      "integrity": "sha512-36nwAD620w12kuzPAsyINPWJqlNbij+hpK1k9XRloDtym8mxzGYl2c17LnV6IAGB2Dmg4tEa7G7DlawS0+qjew==",
+      "requires": {
+        "@babel/runtime": "^7.1.2",
+        "loose-envify": "^1.2.0",
+        "resolve-pathname": "^3.0.0",
+        "tiny-invariant": "^1.0.2",
+        "tiny-warning": "^1.0.0",
+        "value-equal": "^1.0.1"
+      }
+    },
+    "hoist-non-react-statics": {
+      "version": "3.3.2",
+      "resolved": "https://registry.facebook.net/hoist-non-react-statics/-/hoist-non-react-statics-3.3.2.tgz",
+      "integrity": "sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==",
+      "requires": {
+        "react-is": "^16.7.0"
+      }
+    },
+    "hpack.js": {
+      "version": "2.1.6",
+      "resolved": "https://registry.facebook.net/hpack.js/-/hpack.js-2.1.6.tgz",
+      "integrity": "sha512-zJxVehUdMGIKsRaNt7apO2Gqp0BdqW5yaiGHXXmbpvxgBYVZnAql+BJb4RO5ad2MgpbZKn5G6nMnegrH1FcNYQ==",
+      "requires": {
+        "inherits": "^2.0.1",
+        "obuf": "^1.0.0",
+        "readable-stream": "^2.0.1",
+        "wbuf": "^1.1.0"
+      },
+      "dependencies": {
+        "isarray": {
+          "version": "1.0.0",
+          "resolved": "https://registry.facebook.net/isarray/-/isarray-1.0.0.tgz",
+          "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ=="
+        },
+        "readable-stream": {
+          "version": "2.3.8",
+          "resolved": "https://registry.facebook.net/readable-stream/-/readable-stream-2.3.8.tgz",
+          "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
+          "requires": {
+            "core-util-is": "~1.0.0",
+            "inherits": "~2.0.3",
+            "isarray": "~1.0.0",
+            "process-nextick-args": "~2.0.0",
+            "safe-buffer": "~5.1.1",
+            "string_decoder": "~1.1.1",
+            "util-deprecate": "~1.0.1"
+          }
+        },
+        "safe-buffer": {
+          "version": "5.1.2",
+          "resolved": "https://registry.facebook.net/safe-buffer/-/safe-buffer-5.1.2.tgz",
+          "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="
+        },
+        "string_decoder": {
+          "version": "1.1.1",
+          "resolved": "https://registry.facebook.net/string_decoder/-/string_decoder-1.1.1.tgz",
+          "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+          "requires": {
+            "safe-buffer": "~5.1.0"
+          }
+        }
+      }
+    },
+    "html-escaper": {
+      "version": "2.0.2",
+      "resolved": "https://registry.facebook.net/html-escaper/-/html-escaper-2.0.2.tgz",
+      "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg=="
+    },
+    "html-minifier-terser": {
+      "version": "6.1.0",
+      "resolved": "https://registry.facebook.net/html-minifier-terser/-/html-minifier-terser-6.1.0.tgz",
+      "integrity": "sha512-YXxSlJBZTP7RS3tWnQw74ooKa6L9b9i9QYXY21eUEvhZ3u9XLfv6OnFsQq6RxkhHygsaUMvYsZRV5rU/OVNZxw==",
+      "requires": {
+        "camel-case": "^4.1.2",
+        "clean-css": "^5.2.2",
+        "commander": "^8.3.0",
+        "he": "^1.2.0",
+        "param-case": "^3.0.4",
+        "relateurl": "^0.2.7",
+        "terser": "^5.10.0"
+      },
+      "dependencies": {
+        "commander": {
+          "version": "8.3.0",
+          "resolved": "https://registry.facebook.net/commander/-/commander-8.3.0.tgz",
+          "integrity": "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww=="
+        }
+      }
+    },
+    "html-tags": {
+      "version": "3.3.1",
+      "resolved": "https://registry.facebook.net/html-tags/-/html-tags-3.3.1.tgz",
+      "integrity": "sha512-ztqyC3kLto0e9WbNp0aeP+M3kTt+nbaIveGmUxAtZa+8iFgKLUOD4YKM5j+f3QD89bra7UeumolZHKuOXnTmeQ=="
+    },
+    "html-void-elements": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/html-void-elements/-/html-void-elements-3.0.0.tgz",
+      "integrity": "sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg=="
+    },
+    "html-webpack-plugin": {
+      "version": "5.6.7",
+      "resolved": "https://registry.facebook.net/html-webpack-plugin/-/html-webpack-plugin-5.6.7.tgz",
+      "integrity": "sha512-md+vXtdCAe60s1k6AU3dUyMJnDxUyQAwfwPKoLisvgUF1IXjtlLsk2se54+qfL9Mdm26bbwvjJybpNx48NKRLw==",
+      "requires": {
+        "@types/html-minifier-terser": "^6.0.0",
+        "html-minifier-terser": "^6.0.2",
+        "lodash": "^4.17.21",
+        "pretty-error": "^4.0.0",
+        "tapable": "^2.0.0"
+      }
+    },
+    "htmlparser2": {
+      "version": "8.0.2",
+      "resolved": "https://registry.facebook.net/htmlparser2/-/htmlparser2-8.0.2.tgz",
+      "integrity": "sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA==",
+      "requires": {
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.3",
+        "domutils": "^3.0.1",
+        "entities": "^4.4.0"
+      }
+    },
+    "http-cache-semantics": {
+      "version": "4.2.0",
+      "resolved": "https://registry.facebook.net/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz",
+      "integrity": "sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ=="
+    },
+    "http-deceiver": {
+      "version": "1.2.7",
+      "resolved": "https://registry.facebook.net/http-deceiver/-/http-deceiver-1.2.7.tgz",
+      "integrity": "sha512-LmpOGxTfbpgtGVxJrj5k7asXHCgNZp5nLfp+hWc8QQRqtb7fUy6kRY3BO1h9ddF6yIPYUARgxGOwB42DnxIaNw=="
+    },
+    "http-errors": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/http-errors/-/http-errors-2.0.1.tgz",
+      "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==",
+      "requires": {
+        "depd": "~2.0.0",
+        "inherits": "~2.0.4",
+        "setprototypeof": "~1.2.0",
+        "statuses": "~2.0.2",
+        "toidentifier": "~1.0.1"
+      }
+    },
+    "http-parser-js": {
+      "version": "0.5.10",
+      "resolved": "https://registry.facebook.net/http-parser-js/-/http-parser-js-0.5.10.tgz",
+      "integrity": "sha512-Pysuw9XpUq5dVc/2SMHpuTY01RFl8fttgcyunjL7eEMhGM3cI4eOmiCycJDVCo/7O7ClfQD3SaI6ftDzqOXYMA=="
+    },
+    "http-proxy": {
+      "version": "1.18.1",
+      "resolved": "https://registry.facebook.net/http-proxy/-/http-proxy-1.18.1.tgz",
+      "integrity": "sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==",
+      "requires": {
+        "eventemitter3": "^4.0.0",
+        "follow-redirects": "^1.0.0",
+        "requires-port": "^1.0.0"
+      }
+    },
+    "http-proxy-middleware": {
+      "version": "2.0.9",
+      "resolved": "https://registry.facebook.net/http-proxy-middleware/-/http-proxy-middleware-2.0.9.tgz",
+      "integrity": "sha512-c1IyJYLYppU574+YI7R4QyX2ystMtVXZwIdzazUIPIJsHuWNd+mho2j+bKoHftndicGj9yh+xjd+l0yj7VeT1Q==",
+      "requires": {
+        "@types/http-proxy": "^1.17.8",
+        "http-proxy": "^1.18.1",
+        "is-glob": "^4.0.1",
+        "is-plain-obj": "^3.0.0",
+        "micromatch": "^4.0.2"
+      }
+    },
+    "http2-wrapper": {
+      "version": "2.2.1",
+      "resolved": "https://registry.facebook.net/http2-wrapper/-/http2-wrapper-2.2.1.tgz",
+      "integrity": "sha512-V5nVw1PAOgfI3Lmeaj2Exmeg7fenjhRUgz1lPSezy1CuhPYbgQtbQj4jZfEAEMlaL+vupsvhjqCyjzob0yxsmQ==",
+      "requires": {
+        "quick-lru": "^5.1.1",
+        "resolve-alpn": "^1.2.0"
+      }
+    },
+    "human-signals": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/human-signals/-/human-signals-2.1.0.tgz",
+      "integrity": "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw=="
+    },
+    "hyperdyperid": {
+      "version": "1.2.0",
+      "resolved": "https://registry.facebook.net/hyperdyperid/-/hyperdyperid-1.2.0.tgz",
+      "integrity": "sha512-Y93lCzHYgGWdrJ66yIktxiaGULYc6oGiABxhcO5AufBeOyoIdZF7bIfLaOrbM0iGIOXQQgxxRrFEnb+Y6w1n4A=="
+    },
+    "iconv-lite": {
+      "version": "0.4.24",
+      "resolved": "https://registry.facebook.net/iconv-lite/-/iconv-lite-0.4.24.tgz",
+      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+      "requires": {
+        "safer-buffer": ">= 2.1.2 < 3"
+      }
+    },
+    "icss-utils": {
+      "version": "5.1.0",
+      "resolved": "https://registry.facebook.net/icss-utils/-/icss-utils-5.1.0.tgz",
+      "integrity": "sha512-soFhflCVWLfRNOPU3iv5Z9VUdT44xFRbzjLsEzSr5AQmgqPMTHdU3PMT1Cf1ssx8fLNJDA1juftYl+PUcv3MqA==",
+      "requires": {}
+    },
+    "ignore": {
+      "version": "5.3.2",
+      "resolved": "https://registry.facebook.net/ignore/-/ignore-5.3.2.tgz",
+      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g=="
+    },
+    "image-size": {
+      "version": "2.0.2",
+      "resolved": "https://registry.facebook.net/image-size/-/image-size-2.0.2.tgz",
+      "integrity": "sha512-IRqXKlaXwgSMAMtpNzZa1ZAe8m+Sa1770Dhk8VkSsP9LS+iHD62Zd8FQKs8fbPiagBE7BzoFX23cxFnwshpV6w=="
+    },
+    "import-fresh": {
+      "version": "3.3.1",
+      "resolved": "https://registry.facebook.net/import-fresh/-/import-fresh-3.3.1.tgz",
+      "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
+      "requires": {
+        "parent-module": "^1.0.0",
+        "resolve-from": "^4.0.0"
+      }
+    },
+    "import-lazy": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/import-lazy/-/import-lazy-4.0.0.tgz",
+      "integrity": "sha512-rKtvo6a868b5Hu3heneU+L4yEQ4jYKLtjpnPeUdK7h0yzXGmyBTypknlkCvHFBqfX9YlorEiMM6Dnq/5atfHkw=="
+    },
+    "imurmurhash": {
+      "version": "0.1.4",
+      "resolved": "https://registry.facebook.net/imurmurhash/-/imurmurhash-0.1.4.tgz",
+      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA=="
+    },
+    "indent-string": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/indent-string/-/indent-string-4.0.0.tgz",
+      "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg=="
+    },
+    "infima": {
+      "version": "0.2.0-alpha.45",
+      "resolved": "https://registry.facebook.net/infima/-/infima-0.2.0-alpha.45.tgz",
+      "integrity": "sha512-uyH0zfr1erU1OohLk0fT4Rrb94AOhguWNOcD9uGrSpRvNB+6gZXUoJX5J0NtvzBO10YZ9PgvA4NFgt+fYg8ojw=="
+    },
+    "inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.facebook.net/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
+    },
+    "ini": {
+      "version": "1.3.8",
+      "resolved": "https://registry.facebook.net/ini/-/ini-1.3.8.tgz",
+      "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew=="
+    },
+    "inline-style-parser": {
+      "version": "0.2.7",
+      "resolved": "https://registry.facebook.net/inline-style-parser/-/inline-style-parser-0.2.7.tgz",
+      "integrity": "sha512-Nb2ctOyNR8DqQoR0OwRG95uNWIC0C1lCgf5Naz5H6Ji72KZ8OcFZLz2P5sNgwlyoJ8Yif11oMuYs5pBQa86csA=="
+    },
+    "invariant": {
+      "version": "2.2.4",
+      "resolved": "https://registry.facebook.net/invariant/-/invariant-2.2.4.tgz",
+      "integrity": "sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==",
+      "requires": {
+        "loose-envify": "^1.0.0"
+      }
+    },
+    "ipaddr.js": {
+      "version": "2.3.0",
+      "resolved": "https://registry.facebook.net/ipaddr.js/-/ipaddr.js-2.3.0.tgz",
+      "integrity": "sha512-Zv/pA+ciVFbCSBBjGfaKUya/CcGmUHzTydLMaTwrUUEM2DIEO3iZvueGxmacvmN50fGpGVKeTXpb2LcYQxeVdg=="
+    },
+    "is-alphabetical": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/is-alphabetical/-/is-alphabetical-2.0.1.tgz",
+      "integrity": "sha512-FWyyY60MeTNyeSRpkM2Iry0G9hpr7/9kD40mD/cGQEuilcZYS4okz8SN2Q6rLCJ8gbCt6fN+rC+6tMGS99LaxQ=="
+    },
+    "is-alphanumerical": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/is-alphanumerical/-/is-alphanumerical-2.0.1.tgz",
+      "integrity": "sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw==",
+      "requires": {
+        "is-alphabetical": "^2.0.0",
+        "is-decimal": "^2.0.0"
+      }
+    },
+    "is-arrayish": {
+      "version": "0.2.1",
+      "resolved": "https://registry.facebook.net/is-arrayish/-/is-arrayish-0.2.1.tgz",
+      "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg=="
+    },
+    "is-binary-path": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/is-binary-path/-/is-binary-path-2.1.0.tgz",
+      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+      "requires": {
+        "binary-extensions": "^2.0.0"
+      }
+    },
+    "is-ci": {
+      "version": "3.0.1",
+      "resolved": "https://registry.facebook.net/is-ci/-/is-ci-3.0.1.tgz",
+      "integrity": "sha512-ZYvCgrefwqoQ6yTyYUbQu64HsITZ3NfKX1lzaEYdkTDcfKzzCI/wthRRYKkdjHKFVgNiXKAKm65Zo1pk2as/QQ==",
+      "requires": {
+        "ci-info": "^3.2.0"
+      }
+    },
+    "is-core-module": {
+      "version": "2.16.1",
+      "resolved": "https://registry.facebook.net/is-core-module/-/is-core-module-2.16.1.tgz",
+      "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==",
+      "requires": {
+        "hasown": "^2.0.2"
+      }
+    },
+    "is-decimal": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/is-decimal/-/is-decimal-2.0.1.tgz",
+      "integrity": "sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A=="
+    },
+    "is-docker": {
+      "version": "2.2.1",
+      "resolved": "https://registry.facebook.net/is-docker/-/is-docker-2.2.1.tgz",
+      "integrity": "sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ=="
+    },
+    "is-extendable": {
+      "version": "0.1.1",
+      "resolved": "https://registry.facebook.net/is-extendable/-/is-extendable-0.1.1.tgz",
+      "integrity": "sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw=="
+    },
+    "is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.facebook.net/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ=="
+    },
+    "is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="
+    },
+    "is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.facebook.net/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "requires": {
+        "is-extglob": "^2.1.1"
+      }
+    },
+    "is-hexadecimal": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/is-hexadecimal/-/is-hexadecimal-2.0.1.tgz",
+      "integrity": "sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg=="
+    },
+    "is-inside-container": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/is-inside-container/-/is-inside-container-1.0.0.tgz",
+      "integrity": "sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA==",
+      "requires": {
+        "is-docker": "^3.0.0"
+      },
+      "dependencies": {
+        "is-docker": {
+          "version": "3.0.0",
+          "resolved": "https://registry.facebook.net/is-docker/-/is-docker-3.0.0.tgz",
+          "integrity": "sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ=="
+        }
+      }
+    },
+    "is-installed-globally": {
+      "version": "0.4.0",
+      "resolved": "https://registry.facebook.net/is-installed-globally/-/is-installed-globally-0.4.0.tgz",
+      "integrity": "sha512-iwGqO3J21aaSkC7jWnHP/difazwS7SFeIqxv6wEtLU8Y5KlzFTjyqcSIT0d8s4+dDhKytsk9PJZ2BkS5eZwQRQ==",
+      "requires": {
+        "global-dirs": "^3.0.0",
+        "is-path-inside": "^3.0.2"
+      }
+    },
+    "is-network-error": {
+      "version": "1.3.1",
+      "resolved": "https://registry.facebook.net/is-network-error/-/is-network-error-1.3.1.tgz",
+      "integrity": "sha512-6QCxa49rQbmUWLfk0nuGqzql9U8uaV2H6279bRErPBHe/109hCzsLUBUHfbEtvLIHBd6hyXbgedBSHevm43Edw=="
+    },
+    "is-npm": {
+      "version": "6.1.0",
+      "resolved": "https://registry.facebook.net/is-npm/-/is-npm-6.1.0.tgz",
+      "integrity": "sha512-O2z4/kNgyjhQwVR1Wpkbfc19JIhggF97NZNCpWTnjH7kVcZMUrnut9XSN7txI7VdyIYk5ZatOq3zvSuWpU8hoA=="
+    },
+    "is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.facebook.net/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng=="
+    },
+    "is-obj": {
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/is-obj/-/is-obj-1.0.1.tgz",
+      "integrity": "sha512-l4RyHgRqGN4Y3+9JHVrNqO+tN0rV5My76uW5/nuO4K1b6vw5G8d/cmFjP9tRfEsdhZNt0IFdZuK/c2Vr4Nb+Qg=="
+    },
+    "is-path-inside": {
+      "version": "3.0.3",
+      "resolved": "https://registry.facebook.net/is-path-inside/-/is-path-inside-3.0.3.tgz",
+      "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ=="
+    },
+    "is-plain-obj": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/is-plain-obj/-/is-plain-obj-3.0.0.tgz",
+      "integrity": "sha512-gwsOE28k+23GP1B6vFl1oVh/WOzmawBrKwo5Ev6wMKzPkaXaCDIQKzLnvsA42DRlbVTWorkgTKIviAKCWkfUwA=="
+    },
+    "is-plain-object": {
+      "version": "2.0.4",
+      "resolved": "https://registry.facebook.net/is-plain-object/-/is-plain-object-2.0.4.tgz",
+      "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==",
+      "requires": {
+        "isobject": "^3.0.1"
+      }
+    },
+    "is-regexp": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/is-regexp/-/is-regexp-1.0.0.tgz",
+      "integrity": "sha512-7zjFAPO4/gwyQAAgRRmqeEeyIICSdmCqa3tsVHMdBzaXXRiqopZL4Cyghg/XulGWrtABTpbnYYzzIRffLkP4oA=="
+    },
+    "is-stream": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/is-stream/-/is-stream-2.0.1.tgz",
+      "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg=="
+    },
+    "is-typedarray": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/is-typedarray/-/is-typedarray-1.0.0.tgz",
+      "integrity": "sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA=="
+    },
+    "is-wsl": {
+      "version": "2.2.0",
+      "resolved": "https://registry.facebook.net/is-wsl/-/is-wsl-2.2.0.tgz",
+      "integrity": "sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==",
+      "requires": {
+        "is-docker": "^2.0.0"
+      }
+    },
+    "is-yarn-global": {
+      "version": "0.4.1",
+      "resolved": "https://registry.facebook.net/is-yarn-global/-/is-yarn-global-0.4.1.tgz",
+      "integrity": "sha512-/kppl+R+LO5VmhYSEWARUFjodS25D68gvj8W7z0I7OWhUla5xWu8KL6CtB2V0R6yqhnRgbcaREMr4EEM6htLPQ=="
+    },
+    "isarray": {
+      "version": "0.0.1",
+      "resolved": "https://registry.facebook.net/isarray/-/isarray-0.0.1.tgz",
+      "integrity": "sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ=="
+    },
+    "isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="
+    },
+    "isobject": {
+      "version": "3.0.1",
+      "resolved": "https://registry.facebook.net/isobject/-/isobject-3.0.1.tgz",
+      "integrity": "sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg=="
+    },
+    "jest-util": {
+      "version": "29.7.0",
+      "resolved": "https://registry.facebook.net/jest-util/-/jest-util-29.7.0.tgz",
+      "integrity": "sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA==",
+      "requires": {
+        "@jest/types": "^29.6.3",
+        "@types/node": "*",
+        "chalk": "^4.0.0",
+        "ci-info": "^3.2.0",
+        "graceful-fs": "^4.2.9",
+        "picomatch": "^2.2.3"
+      }
+    },
+    "jest-worker": {
+      "version": "27.5.1",
+      "resolved": "https://registry.facebook.net/jest-worker/-/jest-worker-27.5.1.tgz",
+      "integrity": "sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg==",
+      "requires": {
+        "@types/node": "*",
+        "merge-stream": "^2.0.0",
+        "supports-color": "^8.0.0"
+      }
+    },
+    "jiti": {
+      "version": "1.21.7",
+      "resolved": "https://registry.facebook.net/jiti/-/jiti-1.21.7.tgz",
+      "integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A=="
+    },
+    "joi": {
+      "version": "17.13.3",
+      "resolved": "https://registry.facebook.net/joi/-/joi-17.13.3.tgz",
+      "integrity": "sha512-otDA4ldcIx+ZXsKHWmp0YizCweVRZG96J10b0FevjfuncLO1oX59THoAmHkNubYJ+9gWsYsp5k8v4ib6oDv1fA==",
+      "requires": {
+        "@hapi/hoek": "^9.3.0",
+        "@hapi/topo": "^5.1.0",
+        "@sideway/address": "^4.1.5",
+        "@sideway/formula": "^3.0.1",
+        "@sideway/pinpoint": "^2.0.0"
+      }
+    },
+    "js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="
+    },
+    "js-yaml": {
+      "version": "4.1.1",
+      "resolved": "https://registry.facebook.net/js-yaml/-/js-yaml-4.1.1.tgz",
+      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
+      "requires": {
+        "argparse": "^2.0.1"
+      }
+    },
+    "jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.facebook.net/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA=="
+    },
+    "json-buffer": {
+      "version": "3.0.1",
+      "resolved": "https://registry.facebook.net/json-buffer/-/json-buffer-3.0.1.tgz",
+      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ=="
+    },
+    "json-parse-even-better-errors": {
+      "version": "2.3.1",
+      "resolved": "https://registry.facebook.net/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
+      "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w=="
+    },
+    "json-schema-traverse": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+      "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug=="
+    },
+    "json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.facebook.net/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg=="
+    },
+    "jsonfile": {
+      "version": "6.2.1",
+      "resolved": "https://registry.facebook.net/jsonfile/-/jsonfile-6.2.1.tgz",
+      "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+      "requires": {
+        "graceful-fs": "^4.1.6",
+        "universalify": "^2.0.0"
+      }
+    },
+    "keyv": {
+      "version": "4.5.4",
+      "resolved": "https://registry.facebook.net/keyv/-/keyv-4.5.4.tgz",
+      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
+      "requires": {
+        "json-buffer": "3.0.1"
+      }
+    },
+    "kind-of": {
+      "version": "6.0.3",
+      "resolved": "https://registry.facebook.net/kind-of/-/kind-of-6.0.3.tgz",
+      "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw=="
+    },
+    "kleur": {
+      "version": "3.0.3",
+      "resolved": "https://registry.facebook.net/kleur/-/kleur-3.0.3.tgz",
+      "integrity": "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w=="
+    },
+    "latest-version": {
+      "version": "7.0.0",
+      "resolved": "https://registry.facebook.net/latest-version/-/latest-version-7.0.0.tgz",
+      "integrity": "sha512-KvNT4XqAMzdcL6ka6Tl3i2lYeFDgXNCuIX+xNx6ZMVR1dFq+idXd9FLKNMOIx0t9mJ9/HudyX4oZWXZQ0UJHeg==",
+      "requires": {
+        "package-json": "^8.1.0"
+      }
+    },
+    "launch-editor": {
+      "version": "2.13.2",
+      "resolved": "https://registry.facebook.net/launch-editor/-/launch-editor-2.13.2.tgz",
+      "integrity": "sha512-4VVDnbOpLXy/s8rdRCSXb+zfMeFR0WlJWpET1iA9CQdlZDfwyLjUuGQzXU4VeOoey6AicSAluWan7Etga6Kcmg==",
+      "requires": {
+        "picocolors": "^1.1.1",
+        "shell-quote": "^1.8.3"
+      }
+    },
+    "leven": {
+      "version": "3.1.0",
+      "resolved": "https://registry.facebook.net/leven/-/leven-3.1.0.tgz",
+      "integrity": "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A=="
+    },
+    "lilconfig": {
+      "version": "3.1.3",
+      "resolved": "https://registry.facebook.net/lilconfig/-/lilconfig-3.1.3.tgz",
+      "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw=="
+    },
+    "lines-and-columns": {
+      "version": "1.2.4",
+      "resolved": "https://registry.facebook.net/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
+      "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg=="
+    },
+    "loader-runner": {
+      "version": "4.3.2",
+      "resolved": "https://registry.facebook.net/loader-runner/-/loader-runner-4.3.2.tgz",
+      "integrity": "sha512-DFEqQ3ihfS9blba08cLfYf1NRAIEm+dDjic073DRDc3/JspI/8wYmtDsHwd3+4hwvdxSK7PGaElfTmm0awWJ4w=="
+    },
+    "loader-utils": {
+      "version": "2.0.4",
+      "resolved": "https://registry.facebook.net/loader-utils/-/loader-utils-2.0.4.tgz",
+      "integrity": "sha512-xXqpXoINfFhgua9xiqD8fPFHgkoq1mmmpE92WlDbm9rNRd/EbRb+Gqf908T2DMfuHjjJlksiK2RbHVOdD/MqSw==",
+      "requires": {
+        "big.js": "^5.2.2",
+        "emojis-list": "^3.0.0",
+        "json5": "^2.1.2"
+      }
+    },
+    "locate-path": {
+      "version": "7.2.0",
+      "resolved": "https://registry.facebook.net/locate-path/-/locate-path-7.2.0.tgz",
+      "integrity": "sha512-gvVijfZvn7R+2qyPX8mAuKcFGDf6Nc61GdvGafQsHL0sBIxfKzA+usWn4GFC/bk+QdwPUD4kWFJLhElipq+0VA==",
+      "requires": {
+        "p-locate": "^6.0.0"
+      }
+    },
+    "lodash": {
+      "version": "4.18.1",
+      "resolved": "https://registry.facebook.net/lodash/-/lodash-4.18.1.tgz",
+      "integrity": "sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q=="
+    },
+    "lodash.debounce": {
+      "version": "4.0.8",
+      "resolved": "https://registry.facebook.net/lodash.debounce/-/lodash.debounce-4.0.8.tgz",
+      "integrity": "sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow=="
+    },
+    "lodash.memoize": {
+      "version": "4.1.2",
+      "resolved": "https://registry.facebook.net/lodash.memoize/-/lodash.memoize-4.1.2.tgz",
+      "integrity": "sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag=="
+    },
+    "lodash.uniq": {
+      "version": "4.5.0",
+      "resolved": "https://registry.facebook.net/lodash.uniq/-/lodash.uniq-4.5.0.tgz",
+      "integrity": "sha512-xfBaXQd9ryd9dlSDvnvI0lvxfLJlYAZzXomUYzLKtUeOQvOP5piqAWuGtrhWeqaXK9hhoM/iyJc5AV+XfsX3HQ=="
+    },
+    "longest-streak": {
+      "version": "3.1.0",
+      "resolved": "https://registry.facebook.net/longest-streak/-/longest-streak-3.1.0.tgz",
+      "integrity": "sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g=="
+    },
+    "loose-envify": {
+      "version": "1.4.0",
+      "resolved": "https://registry.facebook.net/loose-envify/-/loose-envify-1.4.0.tgz",
+      "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
+      "requires": {
+        "js-tokens": "^3.0.0 || ^4.0.0"
+      }
+    },
+    "lower-case": {
+      "version": "2.0.2",
+      "resolved": "https://registry.facebook.net/lower-case/-/lower-case-2.0.2.tgz",
+      "integrity": "sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==",
+      "requires": {
+        "tslib": "^2.0.3"
+      }
+    },
+    "lowercase-keys": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/lowercase-keys/-/lowercase-keys-3.0.0.tgz",
+      "integrity": "sha512-ozCC6gdQ+glXOQsveKD0YsDy8DSQFjDTz4zyzEHNV5+JP5D62LmfDZ6o1cycFx9ouG940M5dE8C8CTewdj2YWQ=="
+    },
+    "lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.facebook.net/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "requires": {
+        "yallist": "^3.0.2"
+      }
+    },
+    "markdown-extensions": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/markdown-extensions/-/markdown-extensions-2.0.0.tgz",
+      "integrity": "sha512-o5vL7aDWatOTX8LzaS1WMoaoxIiLRQJuIKKe2wAw6IeULDHaqbiqiggmx+pKvZDb1Sj+pE46Sn1T7lCqfFtg1Q=="
+    },
+    "markdown-table": {
+      "version": "3.0.4",
+      "resolved": "https://registry.facebook.net/markdown-table/-/markdown-table-3.0.4.tgz",
+      "integrity": "sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw=="
+    },
+    "math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.facebook.net/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="
+    },
+    "mdast-util-directive": {
+      "version": "3.1.0",
+      "resolved": "https://registry.facebook.net/mdast-util-directive/-/mdast-util-directive-3.1.0.tgz",
+      "integrity": "sha512-I3fNFt+DHmpWCYAT7quoM6lHf9wuqtI+oCOfvILnoicNIqjh5E3dEJWiXuYME2gNe8vl1iMQwyUHa7bgFmak6Q==",
+      "requires": {
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "ccount": "^2.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0",
+        "parse-entities": "^4.0.0",
+        "stringify-entities": "^4.0.0",
+        "unist-util-visit-parents": "^6.0.0"
+      }
+    },
+    "mdast-util-find-and-replace": {
+      "version": "3.0.2",
+      "resolved": "https://registry.facebook.net/mdast-util-find-and-replace/-/mdast-util-find-and-replace-3.0.2.tgz",
+      "integrity": "sha512-Tmd1Vg/m3Xz43afeNxDIhWRtFZgM2VLyaf4vSTYwudTyeuTneoL3qtWMA5jeLyz/O1vDJmmV4QuScFCA2tBPwg==",
+      "requires": {
+        "@types/mdast": "^4.0.0",
+        "escape-string-regexp": "^5.0.0",
+        "unist-util-is": "^6.0.0",
+        "unist-util-visit-parents": "^6.0.0"
+      },
+      "dependencies": {
+        "escape-string-regexp": {
+          "version": "5.0.0",
+          "resolved": "https://registry.facebook.net/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz",
+          "integrity": "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw=="
+        }
+      }
+    },
+    "mdast-util-from-markdown": {
+      "version": "2.0.3",
+      "resolved": "https://registry.facebook.net/mdast-util-from-markdown/-/mdast-util-from-markdown-2.0.3.tgz",
+      "integrity": "sha512-W4mAWTvSlKvf8L6J+VN9yLSqQ9AOAAvHuoDAmPkz4dHf553m5gVj2ejadHJhoJmcmxEnOv6Pa8XJhpxE93kb8Q==",
+      "requires": {
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "decode-named-character-reference": "^1.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-to-string": "^4.0.0",
+        "micromark": "^4.0.0",
+        "micromark-util-decode-numeric-character-reference": "^2.0.0",
+        "micromark-util-decode-string": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0",
+        "unist-util-stringify-position": "^4.0.0"
+      }
+    },
+    "mdast-util-frontmatter": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/mdast-util-frontmatter/-/mdast-util-frontmatter-2.0.1.tgz",
+      "integrity": "sha512-LRqI9+wdgC25P0URIJY9vwocIzCcksduHQ9OF2joxQoyTNVduwLAFUzjoopuRJbJAReaKrNQKAZKL3uCMugWJA==",
+      "requires": {
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "escape-string-regexp": "^5.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0",
+        "micromark-extension-frontmatter": "^2.0.0"
+      },
+      "dependencies": {
+        "escape-string-regexp": {
+          "version": "5.0.0",
+          "resolved": "https://registry.facebook.net/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz",
+          "integrity": "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw=="
+        }
+      }
+    },
+    "mdast-util-gfm": {
+      "version": "3.1.0",
+      "resolved": "https://registry.facebook.net/mdast-util-gfm/-/mdast-util-gfm-3.1.0.tgz",
+      "integrity": "sha512-0ulfdQOM3ysHhCJ1p06l0b0VKlhU0wuQs3thxZQagjcjPrlFRqY215uZGHHJan9GEAXd9MbfPjFJz+qMkVR6zQ==",
+      "requires": {
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-gfm-autolink-literal": "^2.0.0",
+        "mdast-util-gfm-footnote": "^2.0.0",
+        "mdast-util-gfm-strikethrough": "^2.0.0",
+        "mdast-util-gfm-table": "^2.0.0",
+        "mdast-util-gfm-task-list-item": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
+      }
+    },
+    "mdast-util-gfm-autolink-literal": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/mdast-util-gfm-autolink-literal/-/mdast-util-gfm-autolink-literal-2.0.1.tgz",
+      "integrity": "sha512-5HVP2MKaP6L+G6YaxPNjuL0BPrq9orG3TsrZ9YXbA3vDw/ACI4MEsnoDpn6ZNm7GnZgtAcONJyPhOP8tNJQavQ==",
+      "requires": {
+        "@types/mdast": "^4.0.0",
+        "ccount": "^2.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-find-and-replace": "^3.0.0",
+        "micromark-util-character": "^2.0.0"
+      }
+    },
+    "mdast-util-gfm-footnote": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/mdast-util-gfm-footnote/-/mdast-util-gfm-footnote-2.1.0.tgz",
+      "integrity": "sha512-sqpDWlsHn7Ac9GNZQMeUzPQSMzR6Wv0WKRNvQRg0KqHh02fpTz69Qc1QSseNX29bhz1ROIyNyxExfawVKTm1GQ==",
+      "requires": {
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.1.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0"
+      }
+    },
+    "mdast-util-gfm-strikethrough": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/mdast-util-gfm-strikethrough/-/mdast-util-gfm-strikethrough-2.0.0.tgz",
+      "integrity": "sha512-mKKb915TF+OC5ptj5bJ7WFRPdYtuHv0yTRxK2tJvi+BDqbkiG7h7u/9SI89nRAYcmap2xHQL9D+QG/6wSrTtXg==",
+      "requires": {
+        "@types/mdast": "^4.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
+      }
+    },
+    "mdast-util-gfm-table": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/mdast-util-gfm-table/-/mdast-util-gfm-table-2.0.0.tgz",
+      "integrity": "sha512-78UEvebzz/rJIxLvE7ZtDd/vIQ0RHv+3Mh5DR96p7cS7HsBhYIICDBCu8csTNWNO6tBWfqXPWekRuj2FNOGOZg==",
+      "requires": {
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "markdown-table": "^3.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
+      }
+    },
+    "mdast-util-gfm-task-list-item": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/mdast-util-gfm-task-list-item/-/mdast-util-gfm-task-list-item-2.0.0.tgz",
+      "integrity": "sha512-IrtvNvjxC1o06taBAVJznEnkiHxLFTzgonUdy8hzFVeDun0uTjxxrRGVaNFqkU1wJR3RBPEfsxmU6jDWPofrTQ==",
+      "requires": {
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
+      }
+    },
+    "mdast-util-mdx": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/mdast-util-mdx/-/mdast-util-mdx-3.0.0.tgz",
+      "integrity": "sha512-JfbYLAW7XnYTTbUsmpu0kdBUVe+yKVJZBItEjwyYJiDJuZ9w4eeaqks4HQO+R7objWgS2ymV60GYpI14Ug554w==",
+      "requires": {
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-mdx-expression": "^2.0.0",
+        "mdast-util-mdx-jsx": "^3.0.0",
+        "mdast-util-mdxjs-esm": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
+      }
+    },
+    "mdast-util-mdx-expression": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/mdast-util-mdx-expression/-/mdast-util-mdx-expression-2.0.1.tgz",
+      "integrity": "sha512-J6f+9hUp+ldTZqKRSg7Vw5V6MqjATc+3E4gf3CFNcuZNWD8XdyI6zQ8GqH7f8169MM6P7hMBRDVGnn7oHB9kXQ==",
+      "requires": {
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
+      }
+    },
+    "mdast-util-mdx-jsx": {
+      "version": "3.2.0",
+      "resolved": "https://registry.facebook.net/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.2.0.tgz",
+      "integrity": "sha512-lj/z8v0r6ZtsN/cGNNtemmmfoLAFZnjMbNyLzBafjzikOM+glrjNHPlf6lQDOTccj9n5b0PPihEBbhneMyGs1Q==",
+      "requires": {
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "ccount": "^2.0.0",
+        "devlop": "^1.1.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0",
+        "parse-entities": "^4.0.0",
+        "stringify-entities": "^4.0.0",
+        "unist-util-stringify-position": "^4.0.0",
+        "vfile-message": "^4.0.0"
+      }
+    },
+    "mdast-util-mdxjs-esm": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/mdast-util-mdxjs-esm/-/mdast-util-mdxjs-esm-2.0.1.tgz",
+      "integrity": "sha512-EcmOpxsZ96CvlP03NghtH1EsLtr0n9Tm4lPUJUBccV9RwUOneqSycg19n5HGzCf+10LozMRSObtVr3ee1WoHtg==",
+      "requires": {
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
+      }
+    },
+    "mdast-util-phrasing": {
+      "version": "4.1.0",
+      "resolved": "https://registry.facebook.net/mdast-util-phrasing/-/mdast-util-phrasing-4.1.0.tgz",
+      "integrity": "sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w==",
+      "requires": {
+        "@types/mdast": "^4.0.0",
+        "unist-util-is": "^6.0.0"
+      }
+    },
+    "mdast-util-to-hast": {
+      "version": "13.2.1",
+      "resolved": "https://registry.facebook.net/mdast-util-to-hast/-/mdast-util-to-hast-13.2.1.tgz",
+      "integrity": "sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA==",
+      "requires": {
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "@ungap/structured-clone": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "trim-lines": "^3.0.0",
+        "unist-util-position": "^5.0.0",
+        "unist-util-visit": "^5.0.0",
+        "vfile": "^6.0.0"
+      }
+    },
+    "mdast-util-to-markdown": {
+      "version": "2.1.2",
+      "resolved": "https://registry.facebook.net/mdast-util-to-markdown/-/mdast-util-to-markdown-2.1.2.tgz",
+      "integrity": "sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA==",
+      "requires": {
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "longest-streak": "^3.0.0",
+        "mdast-util-phrasing": "^4.0.0",
+        "mdast-util-to-string": "^4.0.0",
+        "micromark-util-classify-character": "^2.0.0",
+        "micromark-util-decode-string": "^2.0.0",
+        "unist-util-visit": "^5.0.0",
+        "zwitch": "^2.0.0"
+      }
+    },
+    "mdast-util-to-string": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/mdast-util-to-string/-/mdast-util-to-string-4.0.0.tgz",
+      "integrity": "sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg==",
+      "requires": {
+        "@types/mdast": "^4.0.0"
+      }
+    },
+    "mdn-data": {
+      "version": "2.0.30",
+      "resolved": "https://registry.facebook.net/mdn-data/-/mdn-data-2.0.30.tgz",
+      "integrity": "sha512-GaqWWShW4kv/G9IEucWScBx9G1/vsFZZJUO+tD26M8J8z3Kw5RDQjaoZe03YAClgeS/SWPOcb4nkFBTEi5DUEA=="
+    },
+    "media-typer": {
+      "version": "0.3.0",
+      "resolved": "https://registry.facebook.net/media-typer/-/media-typer-0.3.0.tgz",
+      "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ=="
+    },
+    "memfs": {
+      "version": "4.57.2",
+      "resolved": "https://registry.facebook.net/memfs/-/memfs-4.57.2.tgz",
+      "integrity": "sha512-2nWzSsJzrukurSDna4Z0WywuScK4Id3tSKejgu74u8KCdW4uNrseKRSIDg75C6Yw5ZRqBe0F0EtMNlTbUq8bAQ==",
+      "requires": {
+        "@jsonjoy.com/fs-core": "4.57.2",
+        "@jsonjoy.com/fs-fsa": "4.57.2",
+        "@jsonjoy.com/fs-node": "4.57.2",
+        "@jsonjoy.com/fs-node-builtins": "4.57.2",
+        "@jsonjoy.com/fs-node-to-fsa": "4.57.2",
+        "@jsonjoy.com/fs-node-utils": "4.57.2",
+        "@jsonjoy.com/fs-print": "4.57.2",
+        "@jsonjoy.com/fs-snapshot": "4.57.2",
+        "@jsonjoy.com/json-pack": "^1.11.0",
+        "@jsonjoy.com/util": "^1.9.0",
+        "glob-to-regex.js": "^1.0.1",
+        "thingies": "^2.5.0",
+        "tree-dump": "^1.0.3",
+        "tslib": "^2.0.0"
+      }
+    },
+    "merge-descriptors": {
+      "version": "1.0.3",
+      "resolved": "https://registry.facebook.net/merge-descriptors/-/merge-descriptors-1.0.3.tgz",
+      "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ=="
+    },
+    "merge-stream": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/merge-stream/-/merge-stream-2.0.0.tgz",
+      "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w=="
+    },
+    "merge2": {
+      "version": "1.4.1",
+      "resolved": "https://registry.facebook.net/merge2/-/merge2-1.4.1.tgz",
+      "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg=="
+    },
+    "methods": {
+      "version": "1.1.2",
+      "resolved": "https://registry.facebook.net/methods/-/methods-1.1.2.tgz",
+      "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w=="
+    },
+    "micromark": {
+      "version": "4.0.2",
+      "resolved": "https://registry.facebook.net/micromark/-/micromark-4.0.2.tgz",
+      "integrity": "sha512-zpe98Q6kvavpCr1NPVSCMebCKfD7CA2NqZ+rykeNhONIJBpc1tFKt9hucLGwha3jNTNI8lHpctWJWoimVF4PfA==",
+      "requires": {
+        "@types/debug": "^4.0.0",
+        "debug": "^4.0.0",
+        "decode-named-character-reference": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-core-commonmark": "^2.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-combine-extensions": "^2.0.0",
+        "micromark-util-decode-numeric-character-reference": "^2.0.0",
+        "micromark-util-encode": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-resolve-all": "^2.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "micromark-util-subtokenize": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "micromark-core-commonmark": {
+      "version": "2.0.3",
+      "resolved": "https://registry.facebook.net/micromark-core-commonmark/-/micromark-core-commonmark-2.0.3.tgz",
+      "integrity": "sha512-RDBrHEMSxVFLg6xvnXmb1Ayr2WzLAWjeSATAoxwKYJV94TeNavgoIdA0a9ytzDSVzBy2YKFK+emCPOEibLeCrg==",
+      "requires": {
+        "decode-named-character-reference": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-factory-destination": "^2.0.0",
+        "micromark-factory-label": "^2.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-factory-title": "^2.0.0",
+        "micromark-factory-whitespace": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-classify-character": "^2.0.0",
+        "micromark-util-html-tag-name": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-resolve-all": "^2.0.0",
+        "micromark-util-subtokenize": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "micromark-extension-directive": {
+      "version": "3.0.2",
+      "resolved": "https://registry.facebook.net/micromark-extension-directive/-/micromark-extension-directive-3.0.2.tgz",
+      "integrity": "sha512-wjcXHgk+PPdmvR58Le9d7zQYWy+vKEU9Se44p2CrCDPiLr2FMyiT4Fyb5UFKFC66wGB3kPlgD7q3TnoqPS7SZA==",
+      "requires": {
+        "devlop": "^1.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-factory-whitespace": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0",
+        "parse-entities": "^4.0.0"
+      }
+    },
+    "micromark-extension-frontmatter": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/micromark-extension-frontmatter/-/micromark-extension-frontmatter-2.0.0.tgz",
+      "integrity": "sha512-C4AkuM3dA58cgZha7zVnuVxBhDsbttIMiytjgsM2XbHAB2faRVaHRle40558FBN+DJcrLNCoqG5mlrpdU4cRtg==",
+      "requires": {
+        "fault": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "micromark-extension-gfm": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/micromark-extension-gfm/-/micromark-extension-gfm-3.0.0.tgz",
+      "integrity": "sha512-vsKArQsicm7t0z2GugkCKtZehqUm31oeGBV/KVSorWSy8ZlNAv7ytjFhvaryUiCUJYqs+NoE6AFhpQvBTM6Q4w==",
+      "requires": {
+        "micromark-extension-gfm-autolink-literal": "^2.0.0",
+        "micromark-extension-gfm-footnote": "^2.0.0",
+        "micromark-extension-gfm-strikethrough": "^2.0.0",
+        "micromark-extension-gfm-table": "^2.0.0",
+        "micromark-extension-gfm-tagfilter": "^2.0.0",
+        "micromark-extension-gfm-task-list-item": "^2.0.0",
+        "micromark-util-combine-extensions": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "micromark-extension-gfm-autolink-literal": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/micromark-extension-gfm-autolink-literal/-/micromark-extension-gfm-autolink-literal-2.1.0.tgz",
+      "integrity": "sha512-oOg7knzhicgQ3t4QCjCWgTmfNhvQbDDnJeVu9v81r7NltNCVmhPy1fJRX27pISafdjL+SVc4d3l48Gb6pbRypw==",
+      "requires": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "micromark-extension-gfm-footnote": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/micromark-extension-gfm-footnote/-/micromark-extension-gfm-footnote-2.1.0.tgz",
+      "integrity": "sha512-/yPhxI1ntnDNsiHtzLKYnE3vf9JZ6cAisqVDauhp4CEHxlb4uoOTxOCJ+9s51bIB8U1N1FJ1RXOKTIlD5B/gqw==",
+      "requires": {
+        "devlop": "^1.0.0",
+        "micromark-core-commonmark": "^2.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "micromark-extension-gfm-strikethrough": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/micromark-extension-gfm-strikethrough/-/micromark-extension-gfm-strikethrough-2.1.0.tgz",
+      "integrity": "sha512-ADVjpOOkjz1hhkZLlBiYA9cR2Anf8F4HqZUO6e5eDcPQd0Txw5fxLzzxnEkSkfnD0wziSGiv7sYhk/ktvbf1uw==",
+      "requires": {
+        "devlop": "^1.0.0",
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-classify-character": "^2.0.0",
+        "micromark-util-resolve-all": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "micromark-extension-gfm-table": {
+      "version": "2.1.1",
+      "resolved": "https://registry.facebook.net/micromark-extension-gfm-table/-/micromark-extension-gfm-table-2.1.1.tgz",
+      "integrity": "sha512-t2OU/dXXioARrC6yWfJ4hqB7rct14e8f7m0cbI5hUmDyyIlwv5vEtooptH8INkbLzOatzKuVbQmAYcbWoyz6Dg==",
+      "requires": {
+        "devlop": "^1.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "micromark-extension-gfm-tagfilter": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/micromark-extension-gfm-tagfilter/-/micromark-extension-gfm-tagfilter-2.0.0.tgz",
+      "integrity": "sha512-xHlTOmuCSotIA8TW1mDIM6X2O1SiX5P9IuDtqGonFhEK0qgRI4yeC6vMxEV2dgyr2TiD+2PQ10o+cOhdVAcwfg==",
+      "requires": {
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "micromark-extension-gfm-task-list-item": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/micromark-extension-gfm-task-list-item/-/micromark-extension-gfm-task-list-item-2.1.0.tgz",
+      "integrity": "sha512-qIBZhqxqI6fjLDYFTBIa4eivDMnP+OZqsNwmQ3xNLE4Cxwc+zfQEfbs6tzAo2Hjq+bh6q5F+Z8/cksrLFYWQQw==",
+      "requires": {
+        "devlop": "^1.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "micromark-extension-mdx-expression": {
+      "version": "3.0.1",
+      "resolved": "https://registry.facebook.net/micromark-extension-mdx-expression/-/micromark-extension-mdx-expression-3.0.1.tgz",
+      "integrity": "sha512-dD/ADLJ1AeMvSAKBwO22zG22N4ybhe7kFIZ3LsDI0GlsNr2A3KYxb0LdC1u5rj4Nw+CHKY0RVdnHX8vj8ejm4Q==",
+      "requires": {
+        "@types/estree": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-factory-mdx-expression": "^2.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-events-to-acorn": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "micromark-extension-mdx-jsx": {
+      "version": "3.0.2",
+      "resolved": "https://registry.facebook.net/micromark-extension-mdx-jsx/-/micromark-extension-mdx-jsx-3.0.2.tgz",
+      "integrity": "sha512-e5+q1DjMh62LZAJOnDraSSbDMvGJ8x3cbjygy2qFEi7HCeUT4BDKCvMozPozcD6WmOt6sVvYDNBKhFSz3kjOVQ==",
+      "requires": {
+        "@types/estree": "^1.0.0",
+        "devlop": "^1.0.0",
+        "estree-util-is-identifier-name": "^3.0.0",
+        "micromark-factory-mdx-expression": "^2.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-events-to-acorn": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0",
+        "vfile-message": "^4.0.0"
+      }
+    },
+    "micromark-extension-mdx-md": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/micromark-extension-mdx-md/-/micromark-extension-mdx-md-2.0.0.tgz",
+      "integrity": "sha512-EpAiszsB3blw4Rpba7xTOUptcFeBFi+6PY8VnJ2hhimH+vCQDirWgsMpz7w1XcZE7LVrSAUGb9VJpG9ghlYvYQ==",
+      "requires": {
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "micromark-extension-mdxjs": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/micromark-extension-mdxjs/-/micromark-extension-mdxjs-3.0.0.tgz",
+      "integrity": "sha512-A873fJfhnJ2siZyUrJ31l34Uqwy4xIFmvPY1oj+Ean5PHcPBYzEsvqvWGaWcfEIr11O5Dlw3p2y0tZWpKHDejQ==",
+      "requires": {
+        "acorn": "^8.0.0",
+        "acorn-jsx": "^5.0.0",
+        "micromark-extension-mdx-expression": "^3.0.0",
+        "micromark-extension-mdx-jsx": "^3.0.0",
+        "micromark-extension-mdx-md": "^2.0.0",
+        "micromark-extension-mdxjs-esm": "^3.0.0",
+        "micromark-util-combine-extensions": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "micromark-extension-mdxjs-esm": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/micromark-extension-mdxjs-esm/-/micromark-extension-mdxjs-esm-3.0.0.tgz",
+      "integrity": "sha512-DJFl4ZqkErRpq/dAPyeWp15tGrcrrJho1hKK5uBS70BCtfrIFg81sqcTVu3Ta+KD1Tk5vAtBNElWxtAa+m8K9A==",
+      "requires": {
+        "@types/estree": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-core-commonmark": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-events-to-acorn": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0",
+        "unist-util-position-from-estree": "^2.0.0",
+        "vfile-message": "^4.0.0"
+      }
+    },
+    "micromark-factory-destination": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/micromark-factory-destination/-/micromark-factory-destination-2.0.1.tgz",
+      "integrity": "sha512-Xe6rDdJlkmbFRExpTOmRj9N3MaWmbAgdpSrBQvCFqhezUn4AHqJHbaEnfbVYYiexVSs//tqOdY/DxhjdCiJnIA==",
+      "requires": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "micromark-factory-label": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/micromark-factory-label/-/micromark-factory-label-2.0.1.tgz",
+      "integrity": "sha512-VFMekyQExqIW7xIChcXn4ok29YE3rnuyveW3wZQWWqF4Nv9Wk5rgJ99KzPvHjkmPXF93FXIbBp6YdW3t71/7Vg==",
+      "requires": {
+        "devlop": "^1.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "micromark-factory-mdx-expression": {
+      "version": "2.0.3",
+      "resolved": "https://registry.facebook.net/micromark-factory-mdx-expression/-/micromark-factory-mdx-expression-2.0.3.tgz",
+      "integrity": "sha512-kQnEtA3vzucU2BkrIa8/VaSAsP+EJ3CKOvhMuJgOEGg9KDC6OAY6nSnNDVRiVNRqj7Y4SlSzcStaH/5jge8JdQ==",
+      "requires": {
+        "@types/estree": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-events-to-acorn": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0",
+        "unist-util-position-from-estree": "^2.0.0",
+        "vfile-message": "^4.0.0"
+      }
+    },
+    "micromark-factory-space": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz",
+      "integrity": "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==",
+      "requires": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "micromark-factory-title": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/micromark-factory-title/-/micromark-factory-title-2.0.1.tgz",
+      "integrity": "sha512-5bZ+3CjhAd9eChYTHsjy6TGxpOFSKgKKJPJxr293jTbfry2KDoWkhBb6TcPVB4NmzaPhMs1Frm9AZH7OD4Cjzw==",
+      "requires": {
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "micromark-factory-whitespace": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/micromark-factory-whitespace/-/micromark-factory-whitespace-2.0.1.tgz",
+      "integrity": "sha512-Ob0nuZ3PKt/n0hORHyvoD9uZhr+Za8sFoP+OnMcnWK5lngSzALgQYKMr9RJVOWLqQYuyn6ulqGWSXdwf6F80lQ==",
+      "requires": {
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "micromark-util-character": {
+      "version": "2.1.1",
+      "resolved": "https://registry.facebook.net/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
+      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
+      "requires": {
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "micromark-util-chunked": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/micromark-util-chunked/-/micromark-util-chunked-2.0.1.tgz",
+      "integrity": "sha512-QUNFEOPELfmvv+4xiNg2sRYeS/P84pTW0TCgP5zc9FpXetHY0ab7SxKyAQCNCc1eK0459uoLI1y5oO5Vc1dbhA==",
+      "requires": {
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "micromark-util-classify-character": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/micromark-util-classify-character/-/micromark-util-classify-character-2.0.1.tgz",
+      "integrity": "sha512-K0kHzM6afW/MbeWYWLjoHQv1sgg2Q9EccHEDzSkxiP/EaagNzCm7T/WMKZ3rjMbvIpvBiZgwR3dKMygtA4mG1Q==",
+      "requires": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "micromark-util-combine-extensions": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/micromark-util-combine-extensions/-/micromark-util-combine-extensions-2.0.1.tgz",
+      "integrity": "sha512-OnAnH8Ujmy59JcyZw8JSbK9cGpdVY44NKgSM7E9Eh7DiLS2E9RNQf0dONaGDzEG9yjEl5hcqeIsj4hfRkLH/Bg==",
+      "requires": {
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "micromark-util-decode-numeric-character-reference": {
+      "version": "2.0.2",
+      "resolved": "https://registry.facebook.net/micromark-util-decode-numeric-character-reference/-/micromark-util-decode-numeric-character-reference-2.0.2.tgz",
+      "integrity": "sha512-ccUbYk6CwVdkmCQMyr64dXz42EfHGkPQlBj5p7YVGzq8I7CtjXZJrubAYezf7Rp+bjPseiROqe7G6foFd+lEuw==",
+      "requires": {
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "micromark-util-decode-string": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/micromark-util-decode-string/-/micromark-util-decode-string-2.0.1.tgz",
+      "integrity": "sha512-nDV/77Fj6eH1ynwscYTOsbK7rR//Uj0bZXBwJZRfaLEJ1iGBR6kIfNmlNqaqJf649EP0F3NWNdeJi03elllNUQ==",
+      "requires": {
+        "decode-named-character-reference": "^1.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-decode-numeric-character-reference": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "micromark-util-encode": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/micromark-util-encode/-/micromark-util-encode-2.0.1.tgz",
+      "integrity": "sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw=="
+    },
+    "micromark-util-events-to-acorn": {
+      "version": "2.0.3",
+      "resolved": "https://registry.facebook.net/micromark-util-events-to-acorn/-/micromark-util-events-to-acorn-2.0.3.tgz",
+      "integrity": "sha512-jmsiEIiZ1n7X1Rr5k8wVExBQCg5jy4UXVADItHmNk1zkwEVhBuIUKRu3fqv+hs4nxLISi2DQGlqIOGiFxgbfHg==",
+      "requires": {
+        "@types/estree": "^1.0.0",
+        "@types/unist": "^3.0.0",
+        "devlop": "^1.0.0",
+        "estree-util-visit": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0",
+        "vfile-message": "^4.0.0"
+      }
+    },
+    "micromark-util-html-tag-name": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/micromark-util-html-tag-name/-/micromark-util-html-tag-name-2.0.1.tgz",
+      "integrity": "sha512-2cNEiYDhCWKI+Gs9T0Tiysk136SnR13hhO8yW6BGNyhOC4qYFnwF1nKfD3HFAIXA5c45RrIG1ub11GiXeYd1xA=="
+    },
+    "micromark-util-normalize-identifier": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/micromark-util-normalize-identifier/-/micromark-util-normalize-identifier-2.0.1.tgz",
+      "integrity": "sha512-sxPqmo70LyARJs0w2UclACPUUEqltCkJ6PhKdMIDuJ3gSf/Q+/GIe3WKl0Ijb/GyH9lOpUkRAO2wp0GVkLvS9Q==",
+      "requires": {
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "micromark-util-resolve-all": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/micromark-util-resolve-all/-/micromark-util-resolve-all-2.0.1.tgz",
+      "integrity": "sha512-VdQyxFWFT2/FGJgwQnJYbe1jjQoNTS4RjglmSjTUlpUMa95Htx9NHeYW4rGDJzbjvCsl9eLjMQwGeElsqmzcHg==",
+      "requires": {
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "micromark-util-sanitize-uri": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.1.tgz",
+      "integrity": "sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==",
+      "requires": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-encode": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "micromark-util-subtokenize": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/micromark-util-subtokenize/-/micromark-util-subtokenize-2.1.0.tgz",
+      "integrity": "sha512-XQLu552iSctvnEcgXw6+Sx75GflAPNED1qx7eBJ+wydBb2KCbRZe+NwvIEEMM83uml1+2WSXpBAcp9IUCgCYWA==",
+      "requires": {
+        "devlop": "^1.0.0",
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "micromark-util-symbol": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
+      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q=="
+    },
+    "micromark-util-types": {
+      "version": "2.0.2",
+      "resolved": "https://registry.facebook.net/micromark-util-types/-/micromark-util-types-2.0.2.tgz",
+      "integrity": "sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA=="
+    },
+    "micromatch": {
+      "version": "4.0.8",
+      "resolved": "https://registry.facebook.net/micromatch/-/micromatch-4.0.8.tgz",
+      "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
+      "requires": {
+        "braces": "^3.0.3",
+        "picomatch": "^2.3.1"
+      }
+    },
+    "mime": {
+      "version": "1.6.0",
+      "resolved": "https://registry.facebook.net/mime/-/mime-1.6.0.tgz",
+      "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg=="
+    },
+    "mime-db": {
+      "version": "1.54.0",
+      "resolved": "https://registry.facebook.net/mime-db/-/mime-db-1.54.0.tgz",
+      "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ=="
+    },
+    "mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.facebook.net/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "requires": {
+        "mime-db": "1.52.0"
+      },
+      "dependencies": {
+        "mime-db": {
+          "version": "1.52.0",
+          "resolved": "https://registry.facebook.net/mime-db/-/mime-db-1.52.0.tgz",
+          "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg=="
+        }
+      }
+    },
+    "mimic-fn": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/mimic-fn/-/mimic-fn-2.1.0.tgz",
+      "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg=="
+    },
+    "mimic-response": {
+      "version": "3.1.0",
+      "resolved": "https://registry.facebook.net/mimic-response/-/mimic-response-3.1.0.tgz",
+      "integrity": "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ=="
+    },
+    "mini-css-extract-plugin": {
+      "version": "2.10.2",
+      "resolved": "https://registry.facebook.net/mini-css-extract-plugin/-/mini-css-extract-plugin-2.10.2.tgz",
+      "integrity": "sha512-AOSS0IdEB95ayVkxn5oGzNQwqAi2J0Jb/kKm43t7H73s8+f5873g0yuj0PNvK4dO75mu5DHg4nlgp4k6Kga8eg==",
+      "requires": {
+        "schema-utils": "^4.0.0",
+        "tapable": "^2.2.1"
+      }
+    },
+    "minimalistic-assert": {
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz",
+      "integrity": "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A=="
+    },
+    "minimatch": {
+      "version": "3.1.5",
+      "resolved": "https://registry.facebook.net/minimatch/-/minimatch-3.1.5.tgz",
+      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+      "requires": {
+        "brace-expansion": "^1.1.7"
+      }
+    },
+    "minimist": {
+      "version": "1.2.8",
+      "resolved": "https://registry.facebook.net/minimist/-/minimist-1.2.8.tgz",
+      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA=="
+    },
+    "mrmime": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/mrmime/-/mrmime-2.0.1.tgz",
+      "integrity": "sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ=="
+    },
+    "ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.facebook.net/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+    },
+    "multicast-dns": {
+      "version": "7.2.5",
+      "resolved": "https://registry.facebook.net/multicast-dns/-/multicast-dns-7.2.5.tgz",
+      "integrity": "sha512-2eznPJP8z2BFLX50tf0LuODrpINqP1RVIm/CObbTcBRITQgmC/TjcREF1NeTBzIcR5XO/ukWo+YHOjBbFwIupg==",
+      "requires": {
+        "dns-packet": "^5.2.2",
+        "thunky": "^1.0.2"
+      }
+    },
+    "nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.facebook.net/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w=="
+    },
+    "negotiator": {
+      "version": "0.6.4",
+      "resolved": "https://registry.facebook.net/negotiator/-/negotiator-0.6.4.tgz",
+      "integrity": "sha512-myRT3DiWPHqho5PrJaIRyaMv2kgYf0mUVgBNOYMuCH5Ki1yEiQaf/ZJuQ62nvpc44wL5WDbTX7yGJi1Neevw8w=="
+    },
+    "neo-async": {
+      "version": "2.6.2",
+      "resolved": "https://registry.facebook.net/neo-async/-/neo-async-2.6.2.tgz",
+      "integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw=="
+    },
+    "no-case": {
+      "version": "3.0.4",
+      "resolved": "https://registry.facebook.net/no-case/-/no-case-3.0.4.tgz",
+      "integrity": "sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==",
+      "requires": {
+        "lower-case": "^2.0.2",
+        "tslib": "^2.0.3"
+      }
+    },
+    "node-emoji": {
+      "version": "2.2.0",
+      "resolved": "https://registry.facebook.net/node-emoji/-/node-emoji-2.2.0.tgz",
+      "integrity": "sha512-Z3lTE9pLaJF47NyMhd4ww1yFTAP8YhYI8SleJiHzM46Fgpm5cnNzSl9XfzFNqbaz+VlJrIj3fXQ4DeN1Rjm6cw==",
+      "requires": {
+        "@sindresorhus/is": "^4.6.0",
+        "char-regex": "^1.0.2",
+        "emojilib": "^2.4.0",
+        "skin-tone": "^2.0.0"
+      }
+    },
+    "node-releases": {
+      "version": "2.0.38",
+      "resolved": "https://registry.facebook.net/node-releases/-/node-releases-2.0.38.tgz",
+      "integrity": "sha512-3qT/88Y3FbH/Kx4szpQQ4HzUbVrHPKTLVpVocKiLfoYvw9XSGOX2FmD2d6DrXbVYyAQTF2HeF6My8jmzx7/CRw=="
+    },
+    "normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA=="
+    },
+    "normalize-url": {
+      "version": "8.1.1",
+      "resolved": "https://registry.facebook.net/normalize-url/-/normalize-url-8.1.1.tgz",
+      "integrity": "sha512-JYc0DPlpGWB40kH5g07gGTrYuMqV653k3uBKY6uITPWds3M0ov3GaWGp9lbE3Bzngx8+XkfzgvASb9vk9JDFXQ=="
+    },
+    "npm-run-path": {
+      "version": "4.0.1",
+      "resolved": "https://registry.facebook.net/npm-run-path/-/npm-run-path-4.0.1.tgz",
+      "integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==",
+      "requires": {
+        "path-key": "^3.0.0"
+      }
+    },
+    "nprogress": {
+      "version": "0.2.0",
+      "resolved": "https://registry.facebook.net/nprogress/-/nprogress-0.2.0.tgz",
+      "integrity": "sha512-I19aIingLgR1fmhftnbWWO3dXc0hSxqHQHQb3H8m+K3TnEn/iSeTZZOyvKXWqQESMwuUVnatlCnZdLBZZt2VSA=="
+    },
+    "nth-check": {
+      "version": "2.1.1",
+      "resolved": "https://registry.facebook.net/nth-check/-/nth-check-2.1.1.tgz",
+      "integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==",
+      "requires": {
+        "boolbase": "^1.0.0"
+      }
+    },
+    "null-loader": {
+      "version": "4.0.1",
+      "resolved": "https://registry.facebook.net/null-loader/-/null-loader-4.0.1.tgz",
+      "integrity": "sha512-pxqVbi4U6N26lq+LmgIbB5XATP0VdZKOG25DhHi8btMmJJefGArFyDg1yc4U3hWCJbMqSrw0qyrz1UQX+qYXqg==",
+      "requires": {
+        "loader-utils": "^2.0.0",
+        "schema-utils": "^3.0.0"
+      },
+      "dependencies": {
+        "ajv": {
+          "version": "6.15.0",
+          "resolved": "https://registry.facebook.net/ajv/-/ajv-6.15.0.tgz",
+          "integrity": "sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==",
+          "requires": {
+            "fast-deep-equal": "^3.1.1",
+            "fast-json-stable-stringify": "^2.0.0",
+            "json-schema-traverse": "^0.4.1",
+            "uri-js": "^4.2.2"
+          }
+        },
+        "ajv-keywords": {
+          "version": "3.5.2",
+          "resolved": "https://registry.facebook.net/ajv-keywords/-/ajv-keywords-3.5.2.tgz",
+          "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==",
+          "requires": {}
+        },
+        "json-schema-traverse": {
+          "version": "0.4.1",
+          "resolved": "https://registry.facebook.net/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+          "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="
+        },
+        "schema-utils": {
+          "version": "3.3.0",
+          "resolved": "https://registry.facebook.net/schema-utils/-/schema-utils-3.3.0.tgz",
+          "integrity": "sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==",
+          "requires": {
+            "@types/json-schema": "^7.0.8",
+            "ajv": "^6.12.5",
+            "ajv-keywords": "^3.5.2"
+          }
+        }
+      }
+    },
+    "object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.facebook.net/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg=="
+    },
+    "object-inspect": {
+      "version": "1.13.4",
+      "resolved": "https://registry.facebook.net/object-inspect/-/object-inspect-1.13.4.tgz",
+      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew=="
+    },
+    "object-keys": {
+      "version": "1.1.1",
+      "resolved": "https://registry.facebook.net/object-keys/-/object-keys-1.1.1.tgz",
+      "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA=="
+    },
+    "object.assign": {
+      "version": "4.1.7",
+      "resolved": "https://registry.facebook.net/object.assign/-/object.assign-4.1.7.tgz",
+      "integrity": "sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==",
+      "requires": {
+        "call-bind": "^1.0.8",
+        "call-bound": "^1.0.3",
+        "define-properties": "^1.2.1",
+        "es-object-atoms": "^1.0.0",
+        "has-symbols": "^1.1.0",
+        "object-keys": "^1.1.1"
+      }
+    },
+    "obuf": {
+      "version": "1.1.2",
+      "resolved": "https://registry.facebook.net/obuf/-/obuf-1.1.2.tgz",
+      "integrity": "sha512-PX1wu0AmAdPqOL1mWhqmlOd8kOIZQwGZw6rh7uby9fTc5lhaOWFLX3I6R1hrF9k3zUY40e6igsLGkDXK92LJNg=="
+    },
+    "on-finished": {
+      "version": "2.4.1",
+      "resolved": "https://registry.facebook.net/on-finished/-/on-finished-2.4.1.tgz",
+      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
+      "requires": {
+        "ee-first": "1.1.1"
+      }
+    },
+    "on-headers": {
+      "version": "1.1.0",
+      "resolved": "https://registry.facebook.net/on-headers/-/on-headers-1.1.0.tgz",
+      "integrity": "sha512-737ZY3yNnXy37FHkQxPzt4UZ2UWPWiCZWLvFZ4fu5cueciegX0zGPnrlY6bwRg4FdQOe9YU8MkmJwGhoMybl8A=="
+    },
+    "onetime": {
+      "version": "5.1.2",
+      "resolved": "https://registry.facebook.net/onetime/-/onetime-5.1.2.tgz",
+      "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==",
+      "requires": {
+        "mimic-fn": "^2.1.0"
+      }
+    },
+    "open": {
+      "version": "8.4.2",
+      "resolved": "https://registry.facebook.net/open/-/open-8.4.2.tgz",
+      "integrity": "sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==",
+      "requires": {
+        "define-lazy-prop": "^2.0.0",
+        "is-docker": "^2.1.1",
+        "is-wsl": "^2.2.0"
+      }
+    },
+    "opener": {
+      "version": "1.5.2",
+      "resolved": "https://registry.facebook.net/opener/-/opener-1.5.2.tgz",
+      "integrity": "sha512-ur5UIdyw5Y7yEj9wLzhqXiy6GZ3Mwx0yGI+5sMn2r0N0v3cKJvUmFH5yPP+WXh9e0xfyzyJX95D8l088DNFj7A=="
+    },
+    "p-cancelable": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/p-cancelable/-/p-cancelable-3.0.0.tgz",
+      "integrity": "sha512-mlVgR3PGuzlo0MmTdk4cXqXWlwQDLnONTAg6sm62XkMJEiRxN3GL3SffkYvqwonbkJBcrI7Uvv5Zh9yjvn2iUw=="
+    },
+    "p-finally": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/p-finally/-/p-finally-1.0.0.tgz",
+      "integrity": "sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow=="
+    },
+    "p-limit": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/p-limit/-/p-limit-4.0.0.tgz",
+      "integrity": "sha512-5b0R4txpzjPWVw/cXXUResoD4hb6U/x9BH08L7nw+GN1sezDzPdxeRvpc9c433fZhBan/wusjbCsqwqm4EIBIQ==",
+      "requires": {
+        "yocto-queue": "^1.0.0"
+      }
+    },
+    "p-locate": {
+      "version": "6.0.0",
+      "resolved": "https://registry.facebook.net/p-locate/-/p-locate-6.0.0.tgz",
+      "integrity": "sha512-wPrq66Llhl7/4AGC6I+cqxT07LhXvWL08LNXz1fENOw0Ap4sRZZ/gZpTTJ5jpurzzzfS2W/Ge9BY3LgLjCShcw==",
+      "requires": {
+        "p-limit": "^4.0.0"
+      }
+    },
+    "p-map": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/p-map/-/p-map-4.0.0.tgz",
+      "integrity": "sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==",
+      "requires": {
+        "aggregate-error": "^3.0.0"
+      }
+    },
+    "p-queue": {
+      "version": "6.6.2",
+      "resolved": "https://registry.facebook.net/p-queue/-/p-queue-6.6.2.tgz",
+      "integrity": "sha512-RwFpb72c/BhQLEXIZ5K2e+AhgNVmIejGlTgiB9MzZ0e93GRvqZ7uSi0dvRF7/XIXDeNkra2fNHBxTyPDGySpjQ==",
+      "requires": {
+        "eventemitter3": "^4.0.4",
+        "p-timeout": "^3.2.0"
+      }
+    },
+    "p-retry": {
+      "version": "6.2.1",
+      "resolved": "https://registry.facebook.net/p-retry/-/p-retry-6.2.1.tgz",
+      "integrity": "sha512-hEt02O4hUct5wtwg4H4KcWgDdm+l1bOaEy/hWzd8xtXB9BqxTWBBhb+2ImAtH4Cv4rPjV76xN3Zumqk3k3AhhQ==",
+      "requires": {
+        "@types/retry": "0.12.2",
+        "is-network-error": "^1.0.0",
+        "retry": "^0.13.1"
+      }
+    },
+    "p-timeout": {
+      "version": "3.2.0",
+      "resolved": "https://registry.facebook.net/p-timeout/-/p-timeout-3.2.0.tgz",
+      "integrity": "sha512-rhIwUycgwwKcP9yTOOFK/AKsAopjjCakVqLHePO3CC6Mir1Z99xT+R63jZxAT5lFZLa2inS5h+ZS2GvR99/FBg==",
+      "requires": {
+        "p-finally": "^1.0.0"
+      }
+    },
+    "package-json": {
+      "version": "8.1.1",
+      "resolved": "https://registry.facebook.net/package-json/-/package-json-8.1.1.tgz",
+      "integrity": "sha512-cbH9IAIJHNj9uXi196JVsRlt7cHKak6u/e6AkL/bkRelZ7rlL3X1YKxsZwa36xipOEKAsdtmaG6aAJoM1fx2zA==",
+      "requires": {
+        "got": "^12.1.0",
+        "registry-auth-token": "^5.0.1",
+        "registry-url": "^6.0.0",
+        "semver": "^7.3.7"
+      },
+      "dependencies": {
+        "semver": {
+          "version": "7.7.4",
+          "resolved": "https://registry.facebook.net/semver/-/semver-7.7.4.tgz",
+          "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA=="
+        }
+      }
+    },
+    "param-case": {
+      "version": "3.0.4",
+      "resolved": "https://registry.facebook.net/param-case/-/param-case-3.0.4.tgz",
+      "integrity": "sha512-RXlj7zCYokReqWpOPH9oYivUzLYZ5vAPIfEmCTNViosC78F8F0H9y7T7gG2M39ymgutxF5gcFEsyZQSph9Bp3A==",
+      "requires": {
+        "dot-case": "^3.0.4",
+        "tslib": "^2.0.3"
+      }
+    },
+    "parent-module": {
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/parent-module/-/parent-module-1.0.1.tgz",
+      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+      "requires": {
+        "callsites": "^3.0.0"
+      }
+    },
+    "parse-entities": {
+      "version": "4.0.2",
+      "resolved": "https://registry.facebook.net/parse-entities/-/parse-entities-4.0.2.tgz",
+      "integrity": "sha512-GG2AQYWoLgL877gQIKeRPGO1xF9+eG1ujIb5soS5gPvLQ1y2o8FL90w2QWNdf9I361Mpp7726c+lj3U0qK1uGw==",
+      "requires": {
+        "@types/unist": "^2.0.0",
+        "character-entities-legacy": "^3.0.0",
+        "character-reference-invalid": "^2.0.0",
+        "decode-named-character-reference": "^1.0.0",
+        "is-alphanumerical": "^2.0.0",
+        "is-decimal": "^2.0.0",
+        "is-hexadecimal": "^2.0.0"
+      },
+      "dependencies": {
+        "@types/unist": {
+          "version": "2.0.11",
+          "resolved": "https://registry.facebook.net/@types/unist/-/unist-2.0.11.tgz",
+          "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA=="
+        }
+      }
+    },
+    "parse-json": {
+      "version": "5.2.0",
+      "resolved": "https://registry.facebook.net/parse-json/-/parse-json-5.2.0.tgz",
+      "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==",
+      "requires": {
+        "@babel/code-frame": "^7.0.0",
+        "error-ex": "^1.3.1",
+        "json-parse-even-better-errors": "^2.3.0",
+        "lines-and-columns": "^1.1.6"
+      }
+    },
+    "parse-numeric-range": {
+      "version": "1.3.0",
+      "resolved": "https://registry.facebook.net/parse-numeric-range/-/parse-numeric-range-1.3.0.tgz",
+      "integrity": "sha512-twN+njEipszzlMJd4ONUYgSfZPDxgHhT9Ahed5uTigpQn90FggW4SA/AIPq/6a149fTbE9qBEcSwE3FAEp6wQQ=="
+    },
+    "parse5": {
+      "version": "7.3.0",
+      "resolved": "https://registry.facebook.net/parse5/-/parse5-7.3.0.tgz",
+      "integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==",
+      "requires": {
+        "entities": "^6.0.0"
+      },
+      "dependencies": {
+        "entities": {
+          "version": "6.0.1",
+          "resolved": "https://registry.facebook.net/entities/-/entities-6.0.1.tgz",
+          "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g=="
+        }
+      }
+    },
+    "parse5-htmlparser2-tree-adapter": {
+      "version": "7.1.0",
+      "resolved": "https://registry.facebook.net/parse5-htmlparser2-tree-adapter/-/parse5-htmlparser2-tree-adapter-7.1.0.tgz",
+      "integrity": "sha512-ruw5xyKs6lrpo9x9rCZqZZnIUntICjQAd0Wsmp396Ul9lN/h+ifgVV1x1gZHi8euej6wTfpqX8j+BFQxF0NS/g==",
+      "requires": {
+        "domhandler": "^5.0.3",
+        "parse5": "^7.0.0"
+      }
+    },
+    "parseurl": {
+      "version": "1.3.3",
+      "resolved": "https://registry.facebook.net/parseurl/-/parseurl-1.3.3.tgz",
+      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ=="
+    },
+    "pascal-case": {
+      "version": "3.1.2",
+      "resolved": "https://registry.facebook.net/pascal-case/-/pascal-case-3.1.2.tgz",
+      "integrity": "sha512-uWlGT3YSnK9x3BQJaOdcZwrnV6hPpd8jFH1/ucpiLRPh/2zCVJKS19E4GvYHvaCcACn3foXZ0cLB9Wrx1KGe5g==",
+      "requires": {
+        "no-case": "^3.0.4",
+        "tslib": "^2.0.3"
+      }
+    },
+    "path-exists": {
+      "version": "5.0.0",
+      "resolved": "https://registry.facebook.net/path-exists/-/path-exists-5.0.0.tgz",
+      "integrity": "sha512-RjhtfwJOxzcFmNOi6ltcbcu4Iu+FL3zEj83dk4kAS+fVpTxXLO1b38RvJgT/0QwvV/L3aY9TAnyv0EOqW4GoMQ=="
+    },
+    "path-is-inside": {
+      "version": "1.0.2",
+      "resolved": "https://registry.facebook.net/path-is-inside/-/path-is-inside-1.0.2.tgz",
+      "integrity": "sha512-DUWJr3+ULp4zXmol/SZkFf3JGsS9/SIv+Y3Rt93/UjPpDpklB5f1er4O3POIbUuUJ3FXgqte2Q7SrU6zAqwk8w=="
+    },
+    "path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.facebook.net/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="
+    },
+    "path-parse": {
+      "version": "1.0.7",
+      "resolved": "https://registry.facebook.net/path-parse/-/path-parse-1.0.7.tgz",
+      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw=="
+    },
+    "path-to-regexp": {
+      "version": "3.3.0",
+      "resolved": "https://registry.facebook.net/path-to-regexp/-/path-to-regexp-3.3.0.tgz",
+      "integrity": "sha512-qyCH421YQPS2WFDxDjftfc1ZR5WKQzVzqsp4n9M2kQhVOo/ByahFoUNJfl58kOcEGfQ//7weFTDhm+ss8Ecxgw=="
+    },
+    "path-type": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/path-type/-/path-type-4.0.0.tgz",
+      "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw=="
+    },
+    "picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.facebook.net/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="
+    },
+    "picomatch": {
+      "version": "2.3.2",
+      "resolved": "https://registry.facebook.net/picomatch/-/picomatch-2.3.2.tgz",
+      "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA=="
+    },
+    "pkg-dir": {
+      "version": "7.0.0",
+      "resolved": "https://registry.facebook.net/pkg-dir/-/pkg-dir-7.0.0.tgz",
+      "integrity": "sha512-Ie9z/WINcxxLp27BKOCHGde4ITq9UklYKDzVo1nhk5sqGEXU3FpkwP5GM2voTGJkGd9B3Otl+Q4uwSOeSUtOBA==",
+      "requires": {
+        "find-up": "^6.3.0"
+      }
+    },
+    "pkijs": {
+      "version": "3.4.0",
+      "resolved": "https://registry.facebook.net/pkijs/-/pkijs-3.4.0.tgz",
+      "integrity": "sha512-emEcLuomt2j03vxD54giVB4SxTjnsqkU692xZOZXHDVoYyypEm+b3jpiTcc+Cf+myooc+/Ly0z01jqeNHVgJGw==",
+      "requires": {
+        "@noble/hashes": "1.4.0",
+        "asn1js": "^3.0.6",
+        "bytestreamjs": "^2.0.1",
+        "pvtsutils": "^1.3.6",
+        "pvutils": "^1.1.3",
+        "tslib": "^2.8.1"
+      }
+    },
+    "postcss": {
+      "version": "8.5.12",
+      "resolved": "https://registry.facebook.net/postcss/-/postcss-8.5.12.tgz",
+      "integrity": "sha512-W62t/Se6rA0Az3DfCL0AqJwXuKwBeYg6nOaIgzP+xZ7N5BFCI7DYi1qs6ygUYT6rvfi6t9k65UMLJC+PHZpDAA==",
+      "requires": {
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      }
+    },
+    "postcss-attribute-case-insensitive": {
+      "version": "7.0.1",
+      "resolved": "https://registry.facebook.net/postcss-attribute-case-insensitive/-/postcss-attribute-case-insensitive-7.0.1.tgz",
+      "integrity": "sha512-Uai+SupNSqzlschRyNx3kbCTWgY/2hcwtHEI/ej2LJWc9JJ77qKgGptd8DHwY1mXtZ7Aoh4z4yxfwMBue9eNgw==",
+      "requires": {
+        "postcss-selector-parser": "^7.0.0"
+      }
+    },
+    "postcss-calc": {
+      "version": "9.0.1",
+      "resolved": "https://registry.facebook.net/postcss-calc/-/postcss-calc-9.0.1.tgz",
+      "integrity": "sha512-TipgjGyzP5QzEhsOZUaIkeO5mKeMFpebWzRogWG/ysonUlnHcq5aJe0jOjpfzUU8PeSaBQnrE8ehR0QA5vs8PQ==",
+      "requires": {
+        "postcss-selector-parser": "^6.0.11",
+        "postcss-value-parser": "^4.2.0"
+      },
+      "dependencies": {
+        "postcss-selector-parser": {
+          "version": "6.1.2",
+          "resolved": "https://registry.facebook.net/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
+          "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
+          "requires": {
+            "cssesc": "^3.0.0",
+            "util-deprecate": "^1.0.2"
+          }
+        }
+      }
+    },
+    "postcss-clamp": {
+      "version": "4.1.0",
+      "resolved": "https://registry.facebook.net/postcss-clamp/-/postcss-clamp-4.1.0.tgz",
+      "integrity": "sha512-ry4b1Llo/9zz+PKC+030KUnPITTJAHeOwjfAyyB60eT0AorGLdzp52s31OsPRHRf8NchkgFoG2y6fCfn1IV1Ow==",
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-color-functional-notation": {
+      "version": "7.0.12",
+      "resolved": "https://registry.facebook.net/postcss-color-functional-notation/-/postcss-color-functional-notation-7.0.12.tgz",
+      "integrity": "sha512-TLCW9fN5kvO/u38/uesdpbx3e8AkTYhMvDZYa9JpmImWuTE99bDQ7GU7hdOADIZsiI9/zuxfAJxny/khknp1Zw==",
+      "requires": {
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/utilities": "^2.0.0"
+      }
+    },
+    "postcss-color-hex-alpha": {
+      "version": "10.0.0",
+      "resolved": "https://registry.facebook.net/postcss-color-hex-alpha/-/postcss-color-hex-alpha-10.0.0.tgz",
+      "integrity": "sha512-1kervM2cnlgPs2a8Vt/Qbe5cQ++N7rkYo/2rz2BkqJZIHQwaVuJgQH38REHrAi4uM0b1fqxMkWYmese94iMp3w==",
+      "requires": {
+        "@csstools/utilities": "^2.0.0",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-color-rebeccapurple": {
+      "version": "10.0.0",
+      "resolved": "https://registry.facebook.net/postcss-color-rebeccapurple/-/postcss-color-rebeccapurple-10.0.0.tgz",
+      "integrity": "sha512-JFta737jSP+hdAIEhk1Vs0q0YF5P8fFcj+09pweS8ktuGuZ8pPlykHsk6mPxZ8awDl4TrcxUqJo9l1IhVr/OjQ==",
+      "requires": {
+        "@csstools/utilities": "^2.0.0",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-colormin": {
+      "version": "6.1.0",
+      "resolved": "https://registry.facebook.net/postcss-colormin/-/postcss-colormin-6.1.0.tgz",
+      "integrity": "sha512-x9yX7DOxeMAR+BgGVnNSAxmAj98NX/YxEMNFP+SDCEeNLb2r3i6Hh1ksMsnW8Ub5SLCpbescQqn9YEbE9554Sw==",
+      "requires": {
+        "browserslist": "^4.23.0",
+        "caniuse-api": "^3.0.0",
+        "colord": "^2.9.3",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-convert-values": {
+      "version": "6.1.0",
+      "resolved": "https://registry.facebook.net/postcss-convert-values/-/postcss-convert-values-6.1.0.tgz",
+      "integrity": "sha512-zx8IwP/ts9WvUM6NkVSkiU902QZL1bwPhaVaLynPtCsOTqp+ZKbNi+s6XJg3rfqpKGA/oc7Oxk5t8pOQJcwl/w==",
+      "requires": {
+        "browserslist": "^4.23.0",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-custom-media": {
+      "version": "11.0.6",
+      "resolved": "https://registry.facebook.net/postcss-custom-media/-/postcss-custom-media-11.0.6.tgz",
+      "integrity": "sha512-C4lD4b7mUIw+RZhtY7qUbf4eADmb7Ey8BFA2px9jUbwg7pjTZDl4KY4bvlUV+/vXQvzQRfiGEVJyAbtOsCMInw==",
+      "requires": {
+        "@csstools/cascade-layer-name-parser": "^2.0.5",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/media-query-list-parser": "^4.0.3"
+      }
+    },
+    "postcss-custom-properties": {
+      "version": "14.0.6",
+      "resolved": "https://registry.facebook.net/postcss-custom-properties/-/postcss-custom-properties-14.0.6.tgz",
+      "integrity": "sha512-fTYSp3xuk4BUeVhxCSJdIPhDLpJfNakZKoiTDx7yRGCdlZrSJR7mWKVOBS4sBF+5poPQFMj2YdXx1VHItBGihQ==",
+      "requires": {
+        "@csstools/cascade-layer-name-parser": "^2.0.5",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/utilities": "^2.0.0",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-custom-selectors": {
+      "version": "8.0.5",
+      "resolved": "https://registry.facebook.net/postcss-custom-selectors/-/postcss-custom-selectors-8.0.5.tgz",
+      "integrity": "sha512-9PGmckHQswiB2usSO6XMSswO2yFWVoCAuih1yl9FVcwkscLjRKjwsjM3t+NIWpSU2Jx3eOiK2+t4vVTQaoCHHg==",
+      "requires": {
+        "@csstools/cascade-layer-name-parser": "^2.0.5",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "postcss-selector-parser": "^7.0.0"
+      }
+    },
+    "postcss-dir-pseudo-class": {
+      "version": "9.0.1",
+      "resolved": "https://registry.facebook.net/postcss-dir-pseudo-class/-/postcss-dir-pseudo-class-9.0.1.tgz",
+      "integrity": "sha512-tRBEK0MHYvcMUrAuYMEOa0zg9APqirBcgzi6P21OhxtJyJADo/SWBwY1CAwEohQ/6HDaa9jCjLRG7K3PVQYHEA==",
+      "requires": {
+        "postcss-selector-parser": "^7.0.0"
+      }
+    },
+    "postcss-discard-comments": {
+      "version": "6.0.2",
+      "resolved": "https://registry.facebook.net/postcss-discard-comments/-/postcss-discard-comments-6.0.2.tgz",
+      "integrity": "sha512-65w/uIqhSBBfQmYnG92FO1mWZjJ4GL5b8atm5Yw2UgrwD7HiNiSSNwJor1eCFGzUgYnN/iIknhNRVqjrrpuglw==",
+      "requires": {}
+    },
+    "postcss-discard-duplicates": {
+      "version": "6.0.3",
+      "resolved": "https://registry.facebook.net/postcss-discard-duplicates/-/postcss-discard-duplicates-6.0.3.tgz",
+      "integrity": "sha512-+JA0DCvc5XvFAxwx6f/e68gQu/7Z9ud584VLmcgto28eB8FqSFZwtrLwB5Kcp70eIoWP/HXqz4wpo8rD8gpsTw==",
+      "requires": {}
+    },
+    "postcss-discard-empty": {
+      "version": "6.0.3",
+      "resolved": "https://registry.facebook.net/postcss-discard-empty/-/postcss-discard-empty-6.0.3.tgz",
+      "integrity": "sha512-znyno9cHKQsK6PtxL5D19Fj9uwSzC2mB74cpT66fhgOadEUPyXFkbgwm5tvc3bt3NAy8ltE5MrghxovZRVnOjQ==",
+      "requires": {}
+    },
+    "postcss-discard-overridden": {
+      "version": "6.0.2",
+      "resolved": "https://registry.facebook.net/postcss-discard-overridden/-/postcss-discard-overridden-6.0.2.tgz",
+      "integrity": "sha512-j87xzI4LUggC5zND7KdjsI25APtyMuynXZSujByMaav2roV6OZX+8AaCUcZSWqckZpjAjRyFDdpqybgjFO0HJQ==",
+      "requires": {}
+    },
+    "postcss-discard-unused": {
+      "version": "6.0.5",
+      "resolved": "https://registry.facebook.net/postcss-discard-unused/-/postcss-discard-unused-6.0.5.tgz",
+      "integrity": "sha512-wHalBlRHkaNnNwfC8z+ppX57VhvS+HWgjW508esjdaEYr3Mx7Gnn2xA4R/CKf5+Z9S5qsqC+Uzh4ueENWwCVUA==",
+      "requires": {
+        "postcss-selector-parser": "^6.0.16"
+      },
+      "dependencies": {
+        "postcss-selector-parser": {
+          "version": "6.1.2",
+          "resolved": "https://registry.facebook.net/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
+          "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
+          "requires": {
+            "cssesc": "^3.0.0",
+            "util-deprecate": "^1.0.2"
+          }
+        }
+      }
+    },
+    "postcss-double-position-gradients": {
+      "version": "6.0.4",
+      "resolved": "https://registry.facebook.net/postcss-double-position-gradients/-/postcss-double-position-gradients-6.0.4.tgz",
+      "integrity": "sha512-m6IKmxo7FxSP5nF2l63QbCC3r+bWpFUWmZXZf096WxG0m7Vl1Q1+ruFOhpdDRmKrRS+S3Jtk+TVk/7z0+BVK6g==",
+      "requires": {
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/utilities": "^2.0.0",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-focus-visible": {
+      "version": "10.0.1",
+      "resolved": "https://registry.facebook.net/postcss-focus-visible/-/postcss-focus-visible-10.0.1.tgz",
+      "integrity": "sha512-U58wyjS/I1GZgjRok33aE8juW9qQgQUNwTSdxQGuShHzwuYdcklnvK/+qOWX1Q9kr7ysbraQ6ht6r+udansalA==",
+      "requires": {
+        "postcss-selector-parser": "^7.0.0"
+      }
+    },
+    "postcss-focus-within": {
+      "version": "9.0.1",
+      "resolved": "https://registry.facebook.net/postcss-focus-within/-/postcss-focus-within-9.0.1.tgz",
+      "integrity": "sha512-fzNUyS1yOYa7mOjpci/bR+u+ESvdar6hk8XNK/TRR0fiGTp2QT5N+ducP0n3rfH/m9I7H/EQU6lsa2BrgxkEjw==",
+      "requires": {
+        "postcss-selector-parser": "^7.0.0"
+      }
+    },
+    "postcss-font-variant": {
+      "version": "5.0.0",
+      "resolved": "https://registry.facebook.net/postcss-font-variant/-/postcss-font-variant-5.0.0.tgz",
+      "integrity": "sha512-1fmkBaCALD72CK2a9i468mA/+tr9/1cBxRRMXOUaZqO43oWPR5imcyPjXwuv7PXbCid4ndlP5zWhidQVVa3hmA==",
+      "requires": {}
+    },
+    "postcss-gap-properties": {
+      "version": "6.0.0",
+      "resolved": "https://registry.facebook.net/postcss-gap-properties/-/postcss-gap-properties-6.0.0.tgz",
+      "integrity": "sha512-Om0WPjEwiM9Ru+VhfEDPZJAKWUd0mV1HmNXqp2C29z80aQ2uP9UVhLc7e3aYMIor/S5cVhoPgYQ7RtfeZpYTRw==",
+      "requires": {}
+    },
+    "postcss-image-set-function": {
+      "version": "7.0.0",
+      "resolved": "https://registry.facebook.net/postcss-image-set-function/-/postcss-image-set-function-7.0.0.tgz",
+      "integrity": "sha512-QL7W7QNlZuzOwBTeXEmbVckNt1FSmhQtbMRvGGqqU4Nf4xk6KUEQhAoWuMzwbSv5jxiRiSZ5Tv7eiDB9U87znA==",
+      "requires": {
+        "@csstools/utilities": "^2.0.0",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-lab-function": {
+      "version": "7.0.12",
+      "resolved": "https://registry.facebook.net/postcss-lab-function/-/postcss-lab-function-7.0.12.tgz",
+      "integrity": "sha512-tUcyRk1ZTPec3OuKFsqtRzW2Go5lehW29XA21lZ65XmzQkz43VY2tyWEC202F7W3mILOjw0voOiuxRGTsN+J9w==",
+      "requires": {
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/utilities": "^2.0.0"
+      }
+    },
+    "postcss-loader": {
+      "version": "7.3.4",
+      "resolved": "https://registry.facebook.net/postcss-loader/-/postcss-loader-7.3.4.tgz",
+      "integrity": "sha512-iW5WTTBSC5BfsBJ9daFMPVrLT36MrNiC6fqOZTTaHjBNX6Pfd5p+hSBqe/fEeNd7pc13QiAyGt7VdGMw4eRC4A==",
+      "requires": {
+        "cosmiconfig": "^8.3.5",
+        "jiti": "^1.20.0",
+        "semver": "^7.5.4"
+      },
+      "dependencies": {
+        "semver": {
+          "version": "7.7.4",
+          "resolved": "https://registry.facebook.net/semver/-/semver-7.7.4.tgz",
+          "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA=="
+        }
+      }
+    },
+    "postcss-logical": {
+      "version": "8.1.0",
+      "resolved": "https://registry.facebook.net/postcss-logical/-/postcss-logical-8.1.0.tgz",
+      "integrity": "sha512-pL1hXFQ2fEXNKiNiAgtfA005T9FBxky5zkX6s4GZM2D8RkVgRqz3f4g1JUoq925zXv495qk8UNldDwh8uGEDoA==",
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-merge-idents": {
+      "version": "6.0.3",
+      "resolved": "https://registry.facebook.net/postcss-merge-idents/-/postcss-merge-idents-6.0.3.tgz",
+      "integrity": "sha512-1oIoAsODUs6IHQZkLQGO15uGEbK3EAl5wi9SS8hs45VgsxQfMnxvt+L+zIr7ifZFIH14cfAeVe2uCTa+SPRa3g==",
+      "requires": {
+        "cssnano-utils": "^4.0.2",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-merge-longhand": {
+      "version": "6.0.5",
+      "resolved": "https://registry.facebook.net/postcss-merge-longhand/-/postcss-merge-longhand-6.0.5.tgz",
+      "integrity": "sha512-5LOiordeTfi64QhICp07nzzuTDjNSO8g5Ksdibt44d+uvIIAE1oZdRn8y/W5ZtYgRH/lnLDlvi9F8btZcVzu3w==",
+      "requires": {
+        "postcss-value-parser": "^4.2.0",
+        "stylehacks": "^6.1.1"
+      }
+    },
+    "postcss-merge-rules": {
+      "version": "6.1.1",
+      "resolved": "https://registry.facebook.net/postcss-merge-rules/-/postcss-merge-rules-6.1.1.tgz",
+      "integrity": "sha512-KOdWF0gju31AQPZiD+2Ar9Qjowz1LTChSjFFbS+e2sFgc4uHOp3ZvVX4sNeTlk0w2O31ecFGgrFzhO0RSWbWwQ==",
+      "requires": {
+        "browserslist": "^4.23.0",
+        "caniuse-api": "^3.0.0",
+        "cssnano-utils": "^4.0.2",
+        "postcss-selector-parser": "^6.0.16"
+      },
+      "dependencies": {
+        "postcss-selector-parser": {
+          "version": "6.1.2",
+          "resolved": "https://registry.facebook.net/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
+          "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
+          "requires": {
+            "cssesc": "^3.0.0",
+            "util-deprecate": "^1.0.2"
+          }
+        }
+      }
+    },
+    "postcss-minify-font-values": {
+      "version": "6.1.0",
+      "resolved": "https://registry.facebook.net/postcss-minify-font-values/-/postcss-minify-font-values-6.1.0.tgz",
+      "integrity": "sha512-gklfI/n+9rTh8nYaSJXlCo3nOKqMNkxuGpTn/Qm0gstL3ywTr9/WRKznE+oy6fvfolH6dF+QM4nCo8yPLdvGJg==",
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-minify-gradients": {
+      "version": "6.0.3",
+      "resolved": "https://registry.facebook.net/postcss-minify-gradients/-/postcss-minify-gradients-6.0.3.tgz",
+      "integrity": "sha512-4KXAHrYlzF0Rr7uc4VrfwDJ2ajrtNEpNEuLxFgwkhFZ56/7gaE4Nr49nLsQDZyUe+ds+kEhf+YAUolJiYXF8+Q==",
+      "requires": {
+        "colord": "^2.9.3",
+        "cssnano-utils": "^4.0.2",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-minify-params": {
+      "version": "6.1.0",
+      "resolved": "https://registry.facebook.net/postcss-minify-params/-/postcss-minify-params-6.1.0.tgz",
+      "integrity": "sha512-bmSKnDtyyE8ujHQK0RQJDIKhQ20Jq1LYiez54WiaOoBtcSuflfK3Nm596LvbtlFcpipMjgClQGyGr7GAs+H1uA==",
+      "requires": {
+        "browserslist": "^4.23.0",
+        "cssnano-utils": "^4.0.2",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-minify-selectors": {
+      "version": "6.0.4",
+      "resolved": "https://registry.facebook.net/postcss-minify-selectors/-/postcss-minify-selectors-6.0.4.tgz",
+      "integrity": "sha512-L8dZSwNLgK7pjTto9PzWRoMbnLq5vsZSTu8+j1P/2GB8qdtGQfn+K1uSvFgYvgh83cbyxT5m43ZZhUMTJDSClQ==",
+      "requires": {
+        "postcss-selector-parser": "^6.0.16"
+      },
+      "dependencies": {
+        "postcss-selector-parser": {
+          "version": "6.1.2",
+          "resolved": "https://registry.facebook.net/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
+          "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
+          "requires": {
+            "cssesc": "^3.0.0",
+            "util-deprecate": "^1.0.2"
+          }
+        }
+      }
+    },
+    "postcss-modules-extract-imports": {
+      "version": "3.1.0",
+      "resolved": "https://registry.facebook.net/postcss-modules-extract-imports/-/postcss-modules-extract-imports-3.1.0.tgz",
+      "integrity": "sha512-k3kNe0aNFQDAZGbin48pL2VNidTF0w4/eASDsxlyspobzU3wZQLOGj7L9gfRe0Jo9/4uud09DsjFNH7winGv8Q==",
+      "requires": {}
+    },
+    "postcss-modules-local-by-default": {
+      "version": "4.2.0",
+      "resolved": "https://registry.facebook.net/postcss-modules-local-by-default/-/postcss-modules-local-by-default-4.2.0.tgz",
+      "integrity": "sha512-5kcJm/zk+GJDSfw+V/42fJ5fhjL5YbFDl8nVdXkJPLLW+Vf9mTD5Xe0wqIaDnLuL2U6cDNpTr+UQ+v2HWIBhzw==",
+      "requires": {
+        "icss-utils": "^5.0.0",
+        "postcss-selector-parser": "^7.0.0",
+        "postcss-value-parser": "^4.1.0"
+      }
+    },
+    "postcss-modules-scope": {
+      "version": "3.2.1",
+      "resolved": "https://registry.facebook.net/postcss-modules-scope/-/postcss-modules-scope-3.2.1.tgz",
+      "integrity": "sha512-m9jZstCVaqGjTAuny8MdgE88scJnCiQSlSrOWcTQgM2t32UBe+MUmFSO5t7VMSfAf/FJKImAxBav8ooCHJXCJA==",
+      "requires": {
+        "postcss-selector-parser": "^7.0.0"
+      }
+    },
+    "postcss-modules-values": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/postcss-modules-values/-/postcss-modules-values-4.0.0.tgz",
+      "integrity": "sha512-RDxHkAiEGI78gS2ofyvCsu7iycRv7oqw5xMWn9iMoR0N/7mf9D50ecQqUo5BZ9Zh2vH4bCUR/ktCqbB9m8vJjQ==",
+      "requires": {
+        "icss-utils": "^5.0.0"
+      }
+    },
+    "postcss-nesting": {
+      "version": "13.0.2",
+      "resolved": "https://registry.facebook.net/postcss-nesting/-/postcss-nesting-13.0.2.tgz",
+      "integrity": "sha512-1YCI290TX+VP0U/K/aFxzHzQWHWURL+CtHMSbex1lCdpXD1SoR2sYuxDu5aNI9lPoXpKTCggFZiDJbwylU0LEQ==",
+      "requires": {
+        "@csstools/selector-resolve-nested": "^3.1.0",
+        "@csstools/selector-specificity": "^5.0.0",
+        "postcss-selector-parser": "^7.0.0"
+      }
+    },
+    "postcss-normalize-charset": {
+      "version": "6.0.2",
+      "resolved": "https://registry.facebook.net/postcss-normalize-charset/-/postcss-normalize-charset-6.0.2.tgz",
+      "integrity": "sha512-a8N9czmdnrjPHa3DeFlwqst5eaL5W8jYu3EBbTTkI5FHkfMhFZh1EGbku6jhHhIzTA6tquI2P42NtZ59M/H/kQ==",
+      "requires": {}
+    },
+    "postcss-normalize-display-values": {
+      "version": "6.0.2",
+      "resolved": "https://registry.facebook.net/postcss-normalize-display-values/-/postcss-normalize-display-values-6.0.2.tgz",
+      "integrity": "sha512-8H04Mxsb82ON/aAkPeq8kcBbAtI5Q2a64X/mnRRfPXBq7XeogoQvReqxEfc0B4WPq1KimjezNC8flUtC3Qz6jg==",
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-normalize-positions": {
+      "version": "6.0.2",
+      "resolved": "https://registry.facebook.net/postcss-normalize-positions/-/postcss-normalize-positions-6.0.2.tgz",
+      "integrity": "sha512-/JFzI441OAB9O7VnLA+RtSNZvQ0NCFZDOtp6QPFo1iIyawyXg0YI3CYM9HBy1WvwCRHnPep/BvI1+dGPKoXx/Q==",
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-normalize-repeat-style": {
+      "version": "6.0.2",
+      "resolved": "https://registry.facebook.net/postcss-normalize-repeat-style/-/postcss-normalize-repeat-style-6.0.2.tgz",
+      "integrity": "sha512-YdCgsfHkJ2jEXwR4RR3Tm/iOxSfdRt7jplS6XRh9Js9PyCR/aka/FCb6TuHT2U8gQubbm/mPmF6L7FY9d79VwQ==",
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-normalize-string": {
+      "version": "6.0.2",
+      "resolved": "https://registry.facebook.net/postcss-normalize-string/-/postcss-normalize-string-6.0.2.tgz",
+      "integrity": "sha512-vQZIivlxlfqqMp4L9PZsFE4YUkWniziKjQWUtsxUiVsSSPelQydwS8Wwcuw0+83ZjPWNTl02oxlIvXsmmG+CiQ==",
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-normalize-timing-functions": {
+      "version": "6.0.2",
+      "resolved": "https://registry.facebook.net/postcss-normalize-timing-functions/-/postcss-normalize-timing-functions-6.0.2.tgz",
+      "integrity": "sha512-a+YrtMox4TBtId/AEwbA03VcJgtyW4dGBizPl7e88cTFULYsprgHWTbfyjSLyHeBcK/Q9JhXkt2ZXiwaVHoMzA==",
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-normalize-unicode": {
+      "version": "6.1.0",
+      "resolved": "https://registry.facebook.net/postcss-normalize-unicode/-/postcss-normalize-unicode-6.1.0.tgz",
+      "integrity": "sha512-QVC5TQHsVj33otj8/JD869Ndr5Xcc/+fwRh4HAsFsAeygQQXm+0PySrKbr/8tkDKzW+EVT3QkqZMfFrGiossDg==",
+      "requires": {
+        "browserslist": "^4.23.0",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-normalize-url": {
+      "version": "6.0.2",
+      "resolved": "https://registry.facebook.net/postcss-normalize-url/-/postcss-normalize-url-6.0.2.tgz",
+      "integrity": "sha512-kVNcWhCeKAzZ8B4pv/DnrU1wNh458zBNp8dh4y5hhxih5RZQ12QWMuQrDgPRw3LRl8mN9vOVfHl7uhvHYMoXsQ==",
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-normalize-whitespace": {
+      "version": "6.0.2",
+      "resolved": "https://registry.facebook.net/postcss-normalize-whitespace/-/postcss-normalize-whitespace-6.0.2.tgz",
+      "integrity": "sha512-sXZ2Nj1icbJOKmdjXVT9pnyHQKiSAyuNQHSgRCUgThn2388Y9cGVDR+E9J9iAYbSbLHI+UUwLVl1Wzco/zgv0Q==",
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-opacity-percentage": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/postcss-opacity-percentage/-/postcss-opacity-percentage-3.0.0.tgz",
+      "integrity": "sha512-K6HGVzyxUxd/VgZdX04DCtdwWJ4NGLG212US4/LA1TLAbHgmAsTWVR86o+gGIbFtnTkfOpb9sCRBx8K7HO66qQ==",
+      "requires": {}
+    },
+    "postcss-ordered-values": {
+      "version": "6.0.2",
+      "resolved": "https://registry.facebook.net/postcss-ordered-values/-/postcss-ordered-values-6.0.2.tgz",
+      "integrity": "sha512-VRZSOB+JU32RsEAQrO94QPkClGPKJEL/Z9PCBImXMhIeK5KAYo6slP/hBYlLgrCjFxyqvn5VC81tycFEDBLG1Q==",
+      "requires": {
+        "cssnano-utils": "^4.0.2",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-overflow-shorthand": {
+      "version": "6.0.0",
+      "resolved": "https://registry.facebook.net/postcss-overflow-shorthand/-/postcss-overflow-shorthand-6.0.0.tgz",
+      "integrity": "sha512-BdDl/AbVkDjoTofzDQnwDdm/Ym6oS9KgmO7Gr+LHYjNWJ6ExORe4+3pcLQsLA9gIROMkiGVjjwZNoL/mpXHd5Q==",
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-page-break": {
+      "version": "3.0.4",
+      "resolved": "https://registry.facebook.net/postcss-page-break/-/postcss-page-break-3.0.4.tgz",
+      "integrity": "sha512-1JGu8oCjVXLa9q9rFTo4MbeeA5FMe00/9C7lN4va606Rdb+HkxXtXsmEDrIraQ11fGz/WvKWa8gMuCKkrXpTsQ==",
+      "requires": {}
+    },
+    "postcss-place": {
+      "version": "10.0.0",
+      "resolved": "https://registry.facebook.net/postcss-place/-/postcss-place-10.0.0.tgz",
+      "integrity": "sha512-5EBrMzat2pPAxQNWYavwAfoKfYcTADJ8AXGVPcUZ2UkNloUTWzJQExgrzrDkh3EKzmAx1evfTAzF9I8NGcc+qw==",
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-preset-env": {
+      "version": "10.6.1",
+      "resolved": "https://registry.facebook.net/postcss-preset-env/-/postcss-preset-env-10.6.1.tgz",
+      "integrity": "sha512-yrk74d9EvY+W7+lO9Aj1QmjWY9q5NsKjK2V9drkOPZB/X6KZ0B3igKsHUYakb7oYVhnioWypQX3xGuePf89f3g==",
+      "requires": {
+        "@csstools/postcss-alpha-function": "^1.0.1",
+        "@csstools/postcss-cascade-layers": "^5.0.2",
+        "@csstools/postcss-color-function": "^4.0.12",
+        "@csstools/postcss-color-function-display-p3-linear": "^1.0.1",
+        "@csstools/postcss-color-mix-function": "^3.0.12",
+        "@csstools/postcss-color-mix-variadic-function-arguments": "^1.0.2",
+        "@csstools/postcss-content-alt-text": "^2.0.8",
+        "@csstools/postcss-contrast-color-function": "^2.0.12",
+        "@csstools/postcss-exponential-functions": "^2.0.9",
+        "@csstools/postcss-font-format-keywords": "^4.0.0",
+        "@csstools/postcss-gamut-mapping": "^2.0.11",
+        "@csstools/postcss-gradients-interpolation-method": "^5.0.12",
+        "@csstools/postcss-hwb-function": "^4.0.12",
+        "@csstools/postcss-ic-unit": "^4.0.4",
+        "@csstools/postcss-initial": "^2.0.1",
+        "@csstools/postcss-is-pseudo-class": "^5.0.3",
+        "@csstools/postcss-light-dark-function": "^2.0.11",
+        "@csstools/postcss-logical-float-and-clear": "^3.0.0",
+        "@csstools/postcss-logical-overflow": "^2.0.0",
+        "@csstools/postcss-logical-overscroll-behavior": "^2.0.0",
+        "@csstools/postcss-logical-resize": "^3.0.0",
+        "@csstools/postcss-logical-viewport-units": "^3.0.4",
+        "@csstools/postcss-media-minmax": "^2.0.9",
+        "@csstools/postcss-media-queries-aspect-ratio-number-values": "^3.0.5",
+        "@csstools/postcss-nested-calc": "^4.0.0",
+        "@csstools/postcss-normalize-display-values": "^4.0.1",
+        "@csstools/postcss-oklab-function": "^4.0.12",
+        "@csstools/postcss-position-area-property": "^1.0.0",
+        "@csstools/postcss-progressive-custom-properties": "^4.2.1",
+        "@csstools/postcss-property-rule-prelude-list": "^1.0.0",
+        "@csstools/postcss-random-function": "^2.0.1",
+        "@csstools/postcss-relative-color-syntax": "^3.0.12",
+        "@csstools/postcss-scope-pseudo-class": "^4.0.1",
+        "@csstools/postcss-sign-functions": "^1.1.4",
+        "@csstools/postcss-stepped-value-functions": "^4.0.9",
+        "@csstools/postcss-syntax-descriptor-syntax-production": "^1.0.1",
+        "@csstools/postcss-system-ui-font-family": "^1.0.0",
+        "@csstools/postcss-text-decoration-shorthand": "^4.0.3",
+        "@csstools/postcss-trigonometric-functions": "^4.0.9",
+        "@csstools/postcss-unset-value": "^4.0.0",
+        "autoprefixer": "^10.4.23",
+        "browserslist": "^4.28.1",
+        "css-blank-pseudo": "^7.0.1",
+        "css-has-pseudo": "^7.0.3",
+        "css-prefers-color-scheme": "^10.0.0",
+        "cssdb": "^8.6.0",
+        "postcss-attribute-case-insensitive": "^7.0.1",
+        "postcss-clamp": "^4.1.0",
+        "postcss-color-functional-notation": "^7.0.12",
+        "postcss-color-hex-alpha": "^10.0.0",
+        "postcss-color-rebeccapurple": "^10.0.0",
+        "postcss-custom-media": "^11.0.6",
+        "postcss-custom-properties": "^14.0.6",
+        "postcss-custom-selectors": "^8.0.5",
+        "postcss-dir-pseudo-class": "^9.0.1",
+        "postcss-double-position-gradients": "^6.0.4",
+        "postcss-focus-visible": "^10.0.1",
+        "postcss-focus-within": "^9.0.1",
+        "postcss-font-variant": "^5.0.0",
+        "postcss-gap-properties": "^6.0.0",
+        "postcss-image-set-function": "^7.0.0",
+        "postcss-lab-function": "^7.0.12",
+        "postcss-logical": "^8.1.0",
+        "postcss-nesting": "^13.0.2",
+        "postcss-opacity-percentage": "^3.0.0",
+        "postcss-overflow-shorthand": "^6.0.0",
+        "postcss-page-break": "^3.0.4",
+        "postcss-place": "^10.0.0",
+        "postcss-pseudo-class-any-link": "^10.0.1",
+        "postcss-replace-overflow-wrap": "^4.0.0",
+        "postcss-selector-not": "^8.0.1"
+      }
+    },
+    "postcss-pseudo-class-any-link": {
+      "version": "10.0.1",
+      "resolved": "https://registry.facebook.net/postcss-pseudo-class-any-link/-/postcss-pseudo-class-any-link-10.0.1.tgz",
+      "integrity": "sha512-3el9rXlBOqTFaMFkWDOkHUTQekFIYnaQY55Rsp8As8QQkpiSgIYEcF/6Ond93oHiDsGb4kad8zjt+NPlOC1H0Q==",
+      "requires": {
+        "postcss-selector-parser": "^7.0.0"
+      }
+    },
+    "postcss-reduce-idents": {
+      "version": "6.0.3",
+      "resolved": "https://registry.facebook.net/postcss-reduce-idents/-/postcss-reduce-idents-6.0.3.tgz",
+      "integrity": "sha512-G3yCqZDpsNPoQgbDUy3T0E6hqOQ5xigUtBQyrmq3tn2GxlyiL0yyl7H+T8ulQR6kOcHJ9t7/9H4/R2tv8tJbMA==",
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-reduce-initial": {
+      "version": "6.1.0",
+      "resolved": "https://registry.facebook.net/postcss-reduce-initial/-/postcss-reduce-initial-6.1.0.tgz",
+      "integrity": "sha512-RarLgBK/CrL1qZags04oKbVbrrVK2wcxhvta3GCxrZO4zveibqbRPmm2VI8sSgCXwoUHEliRSbOfpR0b/VIoiw==",
+      "requires": {
+        "browserslist": "^4.23.0",
+        "caniuse-api": "^3.0.0"
+      }
+    },
+    "postcss-reduce-transforms": {
+      "version": "6.0.2",
+      "resolved": "https://registry.facebook.net/postcss-reduce-transforms/-/postcss-reduce-transforms-6.0.2.tgz",
+      "integrity": "sha512-sB+Ya++3Xj1WaT9+5LOOdirAxP7dJZms3GRcYheSPi1PiTMigsxHAdkrbItHxwYHr4kt1zL7mmcHstgMYT+aiA==",
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-replace-overflow-wrap": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/postcss-replace-overflow-wrap/-/postcss-replace-overflow-wrap-4.0.0.tgz",
+      "integrity": "sha512-KmF7SBPphT4gPPcKZc7aDkweHiKEEO8cla/GjcBK+ckKxiZslIu3C4GCRW3DNfL0o7yW7kMQu9xlZ1kXRXLXtw==",
+      "requires": {}
+    },
+    "postcss-selector-not": {
+      "version": "8.0.1",
+      "resolved": "https://registry.facebook.net/postcss-selector-not/-/postcss-selector-not-8.0.1.tgz",
+      "integrity": "sha512-kmVy/5PYVb2UOhy0+LqUYAhKj7DUGDpSWa5LZqlkWJaaAV+dxxsOG3+St0yNLu6vsKD7Dmqx+nWQt0iil89+WA==",
+      "requires": {
+        "postcss-selector-parser": "^7.0.0"
+      }
+    },
+    "postcss-selector-parser": {
+      "version": "7.1.1",
+      "resolved": "https://registry.facebook.net/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz",
+      "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==",
+      "requires": {
+        "cssesc": "^3.0.0",
+        "util-deprecate": "^1.0.2"
+      }
+    },
+    "postcss-sort-media-queries": {
+      "version": "5.2.0",
+      "resolved": "https://registry.facebook.net/postcss-sort-media-queries/-/postcss-sort-media-queries-5.2.0.tgz",
+      "integrity": "sha512-AZ5fDMLD8SldlAYlvi8NIqo0+Z8xnXU2ia0jxmuhxAU+Lqt9K+AlmLNJ/zWEnE9x+Zx3qL3+1K20ATgNOr3fAA==",
+      "requires": {
+        "sort-css-media-queries": "2.2.0"
+      }
+    },
+    "postcss-svgo": {
+      "version": "6.0.3",
+      "resolved": "https://registry.facebook.net/postcss-svgo/-/postcss-svgo-6.0.3.tgz",
+      "integrity": "sha512-dlrahRmxP22bX6iKEjOM+c8/1p+81asjKT+V5lrgOH944ryx/OHpclnIbGsKVd3uWOXFLYJwCVf0eEkJGvO96g==",
+      "requires": {
+        "postcss-value-parser": "^4.2.0",
+        "svgo": "^3.2.0"
+      }
+    },
+    "postcss-unique-selectors": {
+      "version": "6.0.4",
+      "resolved": "https://registry.facebook.net/postcss-unique-selectors/-/postcss-unique-selectors-6.0.4.tgz",
+      "integrity": "sha512-K38OCaIrO8+PzpArzkLKB42dSARtC2tmG6PvD4b1o1Q2E9Os8jzfWFfSy/rixsHwohtsDdFtAWGjFVFUdwYaMg==",
+      "requires": {
+        "postcss-selector-parser": "^6.0.16"
+      },
+      "dependencies": {
+        "postcss-selector-parser": {
+          "version": "6.1.2",
+          "resolved": "https://registry.facebook.net/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
+          "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
+          "requires": {
+            "cssesc": "^3.0.0",
+            "util-deprecate": "^1.0.2"
+          }
+        }
+      }
+    },
+    "postcss-value-parser": {
+      "version": "4.2.0",
+      "resolved": "https://registry.facebook.net/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz",
+      "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ=="
+    },
+    "postcss-zindex": {
+      "version": "6.0.2",
+      "resolved": "https://registry.facebook.net/postcss-zindex/-/postcss-zindex-6.0.2.tgz",
+      "integrity": "sha512-5BxW9l1evPB/4ZIc+2GobEBoKC+h8gPGCMi+jxsYvd2x0mjq7wazk6DrP71pStqxE9Foxh5TVnonbWpFZzXaYg==",
+      "requires": {}
+    },
+    "pretty-error": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/pretty-error/-/pretty-error-4.0.0.tgz",
+      "integrity": "sha512-AoJ5YMAcXKYxKhuJGdcvse+Voc6v1RgnsR3nWcYU7q4t6z0Q6T86sv5Zq8VIRbOWWFpvdGE83LtdSMNd+6Y0xw==",
+      "requires": {
+        "lodash": "^4.17.20",
+        "renderkid": "^3.0.0"
+      }
+    },
+    "pretty-time": {
+      "version": "1.1.0",
+      "resolved": "https://registry.facebook.net/pretty-time/-/pretty-time-1.1.0.tgz",
+      "integrity": "sha512-28iF6xPQrP8Oa6uxE6a1biz+lWeTOAPKggvjB8HAs6nVMKZwf5bG++632Dx614hIWgUPkgivRfG+a8uAXGTIbA=="
+    },
+    "prism-react-renderer": {
+      "version": "2.4.1",
+      "resolved": "https://registry.facebook.net/prism-react-renderer/-/prism-react-renderer-2.4.1.tgz",
+      "integrity": "sha512-ey8Ls/+Di31eqzUxC46h8MksNuGx/n0AAC8uKpwFau4RPDYLuE3EXTp8N8G2vX2N7UC/+IXeNUnlWBGGcAG+Ig==",
+      "requires": {
+        "@types/prismjs": "^1.26.0",
+        "clsx": "^2.0.0"
+      }
+    },
+    "prismjs": {
+      "version": "1.30.0",
+      "resolved": "https://registry.facebook.net/prismjs/-/prismjs-1.30.0.tgz",
+      "integrity": "sha512-DEvV2ZF2r2/63V+tK8hQvrR2ZGn10srHbXviTlcv7Kpzw8jWiNTqbVgjO3IY8RxrrOUF8VPMQQFysYYYv0YZxw=="
+    },
+    "process-nextick-args": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
+      "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag=="
+    },
+    "prompts": {
+      "version": "2.4.2",
+      "resolved": "https://registry.facebook.net/prompts/-/prompts-2.4.2.tgz",
+      "integrity": "sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==",
+      "requires": {
+        "kleur": "^3.0.3",
+        "sisteransi": "^1.0.5"
+      }
+    },
+    "prop-types": {
+      "version": "15.8.1",
+      "resolved": "https://registry.facebook.net/prop-types/-/prop-types-15.8.1.tgz",
+      "integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==",
+      "requires": {
+        "loose-envify": "^1.4.0",
+        "object-assign": "^4.1.1",
+        "react-is": "^16.13.1"
+      }
+    },
+    "property-information": {
+      "version": "7.1.0",
+      "resolved": "https://registry.facebook.net/property-information/-/property-information-7.1.0.tgz",
+      "integrity": "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ=="
+    },
+    "proto-list": {
+      "version": "1.2.4",
+      "resolved": "https://registry.facebook.net/proto-list/-/proto-list-1.2.4.tgz",
+      "integrity": "sha512-vtK/94akxsTMhe0/cbfpR+syPuszcuwhqVjJq26CuNDgFGj682oRBXOP5MJpv2r7JtE8MsiepGIqvvOTBwn2vA=="
+    },
+    "proxy-addr": {
+      "version": "2.0.7",
+      "resolved": "https://registry.facebook.net/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+      "requires": {
+        "forwarded": "0.2.0",
+        "ipaddr.js": "1.9.1"
+      },
+      "dependencies": {
+        "ipaddr.js": {
+          "version": "1.9.1",
+          "resolved": "https://registry.facebook.net/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+          "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g=="
+        }
+      }
+    },
+    "proxy-from-env": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/proxy-from-env/-/proxy-from-env-2.1.0.tgz",
+      "integrity": "sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA=="
+    },
+    "punycode": {
+      "version": "2.3.1",
+      "resolved": "https://registry.facebook.net/punycode/-/punycode-2.3.1.tgz",
+      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg=="
+    },
+    "pupa": {
+      "version": "3.3.0",
+      "resolved": "https://registry.facebook.net/pupa/-/pupa-3.3.0.tgz",
+      "integrity": "sha512-LjgDO2zPtoXP2wJpDjZrGdojii1uqO0cnwKoIoUzkfS98HDmbeiGmYiXo3lXeFlq2xvne1QFQhwYXSUCLKtEuA==",
+      "requires": {
+        "escape-goat": "^4.0.0"
+      }
+    },
+    "pvtsutils": {
+      "version": "1.3.6",
+      "resolved": "https://registry.facebook.net/pvtsutils/-/pvtsutils-1.3.6.tgz",
+      "integrity": "sha512-PLgQXQ6H2FWCaeRak8vvk1GW462lMxB5s3Jm673N82zI4vqtVUPuZdffdZbPDFRoU8kAhItWFtPCWiPpp4/EDg==",
+      "requires": {
+        "tslib": "^2.8.1"
+      }
+    },
+    "pvutils": {
+      "version": "1.1.5",
+      "resolved": "https://registry.facebook.net/pvutils/-/pvutils-1.1.5.tgz",
+      "integrity": "sha512-KTqnxsgGiQ6ZAzZCVlJH5eOjSnvlyEgx1m8bkRJfOhmGRqfo5KLvmAlACQkrjEtOQ4B7wF9TdSLIs9O90MX9xA=="
+    },
+    "qs": {
+      "version": "6.14.2",
+      "resolved": "https://registry.facebook.net/qs/-/qs-6.14.2.tgz",
+      "integrity": "sha512-V/yCWTTF7VJ9hIh18Ugr2zhJMP01MY7c5kh4J870L7imm6/DIzBsNLTXzMwUA3yZ5b/KBqLx8Kp3uRvd7xSe3Q==",
+      "requires": {
+        "side-channel": "^1.1.0"
+      }
+    },
+    "queue-microtask": {
+      "version": "1.2.3",
+      "resolved": "https://registry.facebook.net/queue-microtask/-/queue-microtask-1.2.3.tgz",
+      "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A=="
+    },
+    "quick-lru": {
+      "version": "5.1.1",
+      "resolved": "https://registry.facebook.net/quick-lru/-/quick-lru-5.1.1.tgz",
+      "integrity": "sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA=="
+    },
+    "randombytes": {
+      "version": "2.1.0",
+      "resolved": "https://registry.facebook.net/randombytes/-/randombytes-2.1.0.tgz",
+      "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==",
+      "requires": {
+        "safe-buffer": "^5.1.0"
+      }
+    },
+    "range-parser": {
+      "version": "1.2.1",
+      "resolved": "https://registry.facebook.net/range-parser/-/range-parser-1.2.1.tgz",
+      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg=="
+    },
+    "raw-body": {
+      "version": "2.5.3",
+      "resolved": "https://registry.facebook.net/raw-body/-/raw-body-2.5.3.tgz",
+      "integrity": "sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA==",
+      "requires": {
+        "bytes": "~3.1.2",
+        "http-errors": "~2.0.1",
+        "iconv-lite": "~0.4.24",
+        "unpipe": "~1.0.0"
+      }
+    },
+    "rc": {
+      "version": "1.2.8",
+      "resolved": "https://registry.facebook.net/rc/-/rc-1.2.8.tgz",
+      "integrity": "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==",
+      "requires": {
+        "deep-extend": "^0.6.0",
+        "ini": "~1.3.0",
+        "minimist": "^1.2.0",
+        "strip-json-comments": "~2.0.1"
+      },
+      "dependencies": {
+        "strip-json-comments": {
+          "version": "2.0.1",
+          "resolved": "https://registry.facebook.net/strip-json-comments/-/strip-json-comments-2.0.1.tgz",
+          "integrity": "sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ=="
+        }
+      }
+    },
+    "react": {
+      "version": "18.3.1",
+      "resolved": "https://registry.facebook.net/react/-/react-18.3.1.tgz",
+      "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
+      "requires": {
+        "loose-envify": "^1.1.0"
+      }
+    },
+    "react-dom": {
+      "version": "18.3.1",
+      "resolved": "https://registry.facebook.net/react-dom/-/react-dom-18.3.1.tgz",
+      "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
+      "requires": {
+        "loose-envify": "^1.1.0",
+        "scheduler": "^0.23.2"
+      }
+    },
+    "react-fast-compare": {
+      "version": "3.2.2",
+      "resolved": "https://registry.facebook.net/react-fast-compare/-/react-fast-compare-3.2.2.tgz",
+      "integrity": "sha512-nsO+KSNgo1SbJqJEYRE9ERzo7YtYbou/OqjSQKxV7jcKox7+usiUVZOAC+XnDOABXggQTno0Y1CpVnuWEc1boQ=="
+    },
+    "react-helmet-async": {
+      "version": "npm:@slorber/react-helmet-async@1.3.0",
+      "resolved": "https://registry.facebook.net/@slorber/react-helmet-async/-/react-helmet-async-1.3.0.tgz",
+      "integrity": "sha512-e9/OK8VhwUSc67diWI8Rb3I0YgI9/SBQtnhe9aEuK6MhZm7ntZZimXgwXnd8W96YTmSOb9M4d8LwhRZyhWr/1A==",
+      "requires": {
+        "@babel/runtime": "^7.12.5",
+        "invariant": "^2.2.4",
+        "prop-types": "^15.7.2",
+        "react-fast-compare": "^3.2.0",
+        "shallowequal": "^1.1.0"
+      }
+    },
+    "react-is": {
+      "version": "16.13.1",
+      "resolved": "https://registry.facebook.net/react-is/-/react-is-16.13.1.tgz",
+      "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ=="
+    },
+    "react-json-view-lite": {
+      "version": "2.5.0",
+      "resolved": "https://registry.facebook.net/react-json-view-lite/-/react-json-view-lite-2.5.0.tgz",
+      "integrity": "sha512-tk7o7QG9oYyELWHL8xiMQ8x4WzjCzbWNyig3uexmkLb54r8jO0yH3WCWx8UZS0c49eSA4QUmG5caiRJ8fAn58g==",
+      "requires": {}
+    },
+    "react-loadable": {
+      "version": "npm:@docusaurus/react-loadable@6.0.0",
+      "resolved": "https://registry.facebook.net/@docusaurus/react-loadable/-/react-loadable-6.0.0.tgz",
+      "integrity": "sha512-YMMxTUQV/QFSnbgrP3tjDzLHRg7vsbMn8e9HAa8o/1iXoiomo48b7sk/kkmWEuWNDPJVlKSJRB6Y2fHqdJk+SQ==",
+      "requires": {
+        "@types/react": "*"
+      }
+    },
+    "react-loadable-ssr-addon-v5-slorber": {
+      "version": "1.0.3",
+      "resolved": "https://registry.facebook.net/react-loadable-ssr-addon-v5-slorber/-/react-loadable-ssr-addon-v5-slorber-1.0.3.tgz",
+      "integrity": "sha512-GXfh9VLwB5ERaCsU6RULh7tkemeX15aNh6wuMEBtfdyMa7fFG8TXrhXlx1SoEK2Ty/l6XIkzzYIQmyaWW3JgdQ==",
+      "requires": {
+        "@babel/runtime": "^7.10.3"
+      }
+    },
+    "react-router": {
+      "version": "5.3.4",
+      "resolved": "https://registry.facebook.net/react-router/-/react-router-5.3.4.tgz",
+      "integrity": "sha512-Ys9K+ppnJah3QuaRiLxk+jDWOR1MekYQrlytiXxC1RyfbdsZkS5pvKAzCCr031xHixZwpnsYNT5xysdFHQaYsA==",
+      "requires": {
+        "@babel/runtime": "^7.12.13",
+        "history": "^4.9.0",
+        "hoist-non-react-statics": "^3.1.0",
+        "loose-envify": "^1.3.1",
+        "path-to-regexp": "^1.7.0",
+        "prop-types": "^15.6.2",
+        "react-is": "^16.6.0",
+        "tiny-invariant": "^1.0.2",
+        "tiny-warning": "^1.0.0"
+      },
+      "dependencies": {
+        "path-to-regexp": {
+          "version": "1.9.0",
+          "resolved": "https://registry.facebook.net/path-to-regexp/-/path-to-regexp-1.9.0.tgz",
+          "integrity": "sha512-xIp7/apCFJuUHdDLWe8O1HIkb0kQrOMb/0u6FXQjemHn/ii5LrIzU6bdECnsiTF/GjZkMEKg1xdiZwNqDYlZ6g==",
+          "requires": {
+            "isarray": "0.0.1"
+          }
+        }
+      }
+    },
+    "react-router-config": {
+      "version": "5.1.1",
+      "resolved": "https://registry.facebook.net/react-router-config/-/react-router-config-5.1.1.tgz",
+      "integrity": "sha512-DuanZjaD8mQp1ppHjgnnUnyOlqYXZVjnov/JzFhjLEwd3Z4dYjMSnqrEzzGThH47vpCOqPPwJM2FtthLeJ8Pbg==",
+      "requires": {
+        "@babel/runtime": "^7.1.2"
+      }
+    },
+    "react-router-dom": {
+      "version": "5.3.4",
+      "resolved": "https://registry.facebook.net/react-router-dom/-/react-router-dom-5.3.4.tgz",
+      "integrity": "sha512-m4EqFMHv/Ih4kpcBCONHbkT68KoAeHN4p3lAGoNryfHi0dMy0kCzEZakiKRsvg5wHZ/JLrLW8o8KomWiz/qbYQ==",
+      "requires": {
+        "@babel/runtime": "^7.12.13",
+        "history": "^4.9.0",
+        "loose-envify": "^1.3.1",
+        "prop-types": "^15.6.2",
+        "react-router": "5.3.4",
+        "tiny-invariant": "^1.0.2",
+        "tiny-warning": "^1.0.0"
+      }
+    },
+    "readable-stream": {
+      "version": "3.6.2",
+      "resolved": "https://registry.facebook.net/readable-stream/-/readable-stream-3.6.2.tgz",
+      "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
+      "requires": {
+        "inherits": "^2.0.3",
+        "string_decoder": "^1.1.1",
+        "util-deprecate": "^1.0.1"
+      }
+    },
+    "readdirp": {
+      "version": "3.6.0",
+      "resolved": "https://registry.facebook.net/readdirp/-/readdirp-3.6.0.tgz",
+      "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
+      "requires": {
+        "picomatch": "^2.2.1"
+      }
+    },
+    "recma-build-jsx": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/recma-build-jsx/-/recma-build-jsx-1.0.0.tgz",
+      "integrity": "sha512-8GtdyqaBcDfva+GUKDr3nev3VpKAhup1+RvkMvUxURHpW7QyIvk9F5wz7Vzo06CEMSilw6uArgRqhpiUcWp8ew==",
+      "requires": {
+        "@types/estree": "^1.0.0",
+        "estree-util-build-jsx": "^3.0.0",
+        "vfile": "^6.0.0"
+      }
+    },
+    "recma-jsx": {
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/recma-jsx/-/recma-jsx-1.0.1.tgz",
+      "integrity": "sha512-huSIy7VU2Z5OLv6oFLosQGGDqPqdO1iq6bWNAdhzMxSJP7RAso4fCZ1cKu8j9YHCZf3TPrq4dw3okhrylgcd7w==",
+      "requires": {
+        "acorn-jsx": "^5.0.0",
+        "estree-util-to-js": "^2.0.0",
+        "recma-parse": "^1.0.0",
+        "recma-stringify": "^1.0.0",
+        "unified": "^11.0.0"
+      }
+    },
+    "recma-parse": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/recma-parse/-/recma-parse-1.0.0.tgz",
+      "integrity": "sha512-OYLsIGBB5Y5wjnSnQW6t3Xg7q3fQ7FWbw/vcXtORTnyaSFscOtABg+7Pnz6YZ6c27fG1/aN8CjfwoUEUIdwqWQ==",
+      "requires": {
+        "@types/estree": "^1.0.0",
+        "esast-util-from-js": "^2.0.0",
+        "unified": "^11.0.0",
+        "vfile": "^6.0.0"
+      }
+    },
+    "recma-stringify": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/recma-stringify/-/recma-stringify-1.0.0.tgz",
+      "integrity": "sha512-cjwII1MdIIVloKvC9ErQ+OgAtwHBmcZ0Bg4ciz78FtbT8In39aAYbaA7zvxQ61xVMSPE8WxhLwLbhif4Js2C+g==",
+      "requires": {
+        "@types/estree": "^1.0.0",
+        "estree-util-to-js": "^2.0.0",
+        "unified": "^11.0.0",
+        "vfile": "^6.0.0"
+      }
+    },
+    "reflect-metadata": {
+      "version": "0.2.2",
+      "resolved": "https://registry.facebook.net/reflect-metadata/-/reflect-metadata-0.2.2.tgz",
+      "integrity": "sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q=="
+    },
+    "regenerate": {
+      "version": "1.4.2",
+      "resolved": "https://registry.facebook.net/regenerate/-/regenerate-1.4.2.tgz",
+      "integrity": "sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A=="
+    },
+    "regenerate-unicode-properties": {
+      "version": "10.2.2",
+      "resolved": "https://registry.facebook.net/regenerate-unicode-properties/-/regenerate-unicode-properties-10.2.2.tgz",
+      "integrity": "sha512-m03P+zhBeQd1RGnYxrGyDAPpWX/epKirLrp8e3qevZdVkKtnCrjjWczIbYc8+xd6vcTStVlqfycTx1KR4LOr0g==",
+      "requires": {
+        "regenerate": "^1.4.2"
+      }
+    },
+    "regexpu-core": {
+      "version": "6.4.0",
+      "resolved": "https://registry.facebook.net/regexpu-core/-/regexpu-core-6.4.0.tgz",
+      "integrity": "sha512-0ghuzq67LI9bLXpOX/ISfve/Mq33a4aFRzoQYhnnok1JOFpmE/A2TBGkNVenOGEeSBCjIiWcc6MVOG5HEQv0sA==",
+      "requires": {
+        "regenerate": "^1.4.2",
+        "regenerate-unicode-properties": "^10.2.2",
+        "regjsgen": "^0.8.0",
+        "regjsparser": "^0.13.0",
+        "unicode-match-property-ecmascript": "^2.0.0",
+        "unicode-match-property-value-ecmascript": "^2.2.1"
+      }
+    },
+    "registry-auth-token": {
+      "version": "5.1.1",
+      "resolved": "https://registry.facebook.net/registry-auth-token/-/registry-auth-token-5.1.1.tgz",
+      "integrity": "sha512-P7B4+jq8DeD2nMsAcdfaqHbssgHtZ7Z5+++a5ask90fvmJ8p5je4mOa+wzu+DB4vQ5tdJV/xywY+UnVFeQLV5Q==",
+      "requires": {
+        "@pnpm/npm-conf": "^3.0.2"
+      }
+    },
+    "registry-url": {
+      "version": "6.0.1",
+      "resolved": "https://registry.facebook.net/registry-url/-/registry-url-6.0.1.tgz",
+      "integrity": "sha512-+crtS5QjFRqFCoQmvGduwYWEBng99ZvmFvF+cUJkGYF1L1BfU8C6Zp9T7f5vPAwyLkUExpvK+ANVZmGU49qi4Q==",
+      "requires": {
+        "rc": "1.2.8"
+      }
+    },
+    "regjsgen": {
+      "version": "0.8.0",
+      "resolved": "https://registry.facebook.net/regjsgen/-/regjsgen-0.8.0.tgz",
+      "integrity": "sha512-RvwtGe3d7LvWiDQXeQw8p5asZUmfU1G/l6WbUXeHta7Y2PEIvBTwH6E2EfmYUK8pxcxEdEmaomqyp0vZZ7C+3Q=="
+    },
+    "regjsparser": {
+      "version": "0.13.1",
+      "resolved": "https://registry.facebook.net/regjsparser/-/regjsparser-0.13.1.tgz",
+      "integrity": "sha512-dLsljMd9sqwRkby8zhO1gSg3PnJIBFid8f4CQj/sXx+7cKx+E7u0PKhZ+U4wmhx7EfmtvnA318oVaIkAB1lRJw==",
+      "requires": {
+        "jsesc": "~3.1.0"
+      }
+    },
+    "rehype-raw": {
+      "version": "7.0.0",
+      "resolved": "https://registry.facebook.net/rehype-raw/-/rehype-raw-7.0.0.tgz",
+      "integrity": "sha512-/aE8hCfKlQeA8LmyeyQvQF3eBiLRGNlfBJEvWH7ivp9sBqs7TNqBL5X3v157rM4IFETqDnIOO+z5M/biZbo9Ww==",
+      "requires": {
+        "@types/hast": "^3.0.0",
+        "hast-util-raw": "^9.0.0",
+        "vfile": "^6.0.0"
+      }
+    },
+    "rehype-recma": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/rehype-recma/-/rehype-recma-1.0.0.tgz",
+      "integrity": "sha512-lqA4rGUf1JmacCNWWZx0Wv1dHqMwxzsDWYMTowuplHF3xH0N/MmrZ/G3BDZnzAkRmxDadujCjaKM2hqYdCBOGw==",
+      "requires": {
+        "@types/estree": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "hast-util-to-estree": "^3.0.0"
+      }
+    },
+    "relateurl": {
+      "version": "0.2.7",
+      "resolved": "https://registry.facebook.net/relateurl/-/relateurl-0.2.7.tgz",
+      "integrity": "sha512-G08Dxvm4iDN3MLM0EsP62EDV9IuhXPR6blNz6Utcp7zyV3tr4HVNINt6MpaRWbxoOHT3Q7YN2P+jaHX8vUbgog=="
+    },
+    "remark-directive": {
+      "version": "3.0.1",
+      "resolved": "https://registry.facebook.net/remark-directive/-/remark-directive-3.0.1.tgz",
+      "integrity": "sha512-gwglrEQEZcZYgVyG1tQuA+h58EZfq5CSULw7J90AFuCTyib1thgHPoqQ+h9iFvU6R+vnZ5oNFQR5QKgGpk741A==",
+      "requires": {
+        "@types/mdast": "^4.0.0",
+        "mdast-util-directive": "^3.0.0",
+        "micromark-extension-directive": "^3.0.0",
+        "unified": "^11.0.0"
+      }
+    },
+    "remark-emoji": {
+      "version": "4.0.1",
+      "resolved": "https://registry.facebook.net/remark-emoji/-/remark-emoji-4.0.1.tgz",
+      "integrity": "sha512-fHdvsTR1dHkWKev9eNyhTo4EFwbUvJ8ka9SgeWkMPYFX4WoI7ViVBms3PjlQYgw5TLvNQso3GUB/b/8t3yo+dg==",
+      "requires": {
+        "@types/mdast": "^4.0.2",
+        "emoticon": "^4.0.1",
+        "mdast-util-find-and-replace": "^3.0.1",
+        "node-emoji": "^2.1.0",
+        "unified": "^11.0.4"
+      }
+    },
+    "remark-frontmatter": {
+      "version": "5.0.0",
+      "resolved": "https://registry.facebook.net/remark-frontmatter/-/remark-frontmatter-5.0.0.tgz",
+      "integrity": "sha512-XTFYvNASMe5iPN0719nPrdItC9aU0ssC4v14mH1BCi1u0n1gAocqcujWUrByftZTbLhRtiKRyjYTSIOcr69UVQ==",
+      "requires": {
+        "@types/mdast": "^4.0.0",
+        "mdast-util-frontmatter": "^2.0.0",
+        "micromark-extension-frontmatter": "^2.0.0",
+        "unified": "^11.0.0"
+      }
+    },
+    "remark-gfm": {
+      "version": "4.0.1",
+      "resolved": "https://registry.facebook.net/remark-gfm/-/remark-gfm-4.0.1.tgz",
+      "integrity": "sha512-1quofZ2RQ9EWdeN34S79+KExV1764+wCUGop5CPL1WGdD0ocPpu91lzPGbwWMECpEpd42kJGQwzRfyov9j4yNg==",
+      "requires": {
+        "@types/mdast": "^4.0.0",
+        "mdast-util-gfm": "^3.0.0",
+        "micromark-extension-gfm": "^3.0.0",
+        "remark-parse": "^11.0.0",
+        "remark-stringify": "^11.0.0",
+        "unified": "^11.0.0"
+      }
+    },
+    "remark-mdx": {
+      "version": "3.1.1",
+      "resolved": "https://registry.facebook.net/remark-mdx/-/remark-mdx-3.1.1.tgz",
+      "integrity": "sha512-Pjj2IYlUY3+D8x00UJsIOg5BEvfMyeI+2uLPn9VO9Wg4MEtN/VTIq2NEJQfde9PnX15KgtHyl9S0BcTnWrIuWg==",
+      "requires": {
+        "mdast-util-mdx": "^3.0.0",
+        "micromark-extension-mdxjs": "^3.0.0"
+      }
+    },
+    "remark-parse": {
+      "version": "11.0.0",
+      "resolved": "https://registry.facebook.net/remark-parse/-/remark-parse-11.0.0.tgz",
+      "integrity": "sha512-FCxlKLNGknS5ba/1lmpYijMUzX2esxW5xQqjWxw2eHFfS2MSdaHVINFmhjo+qN1WhZhNimq0dZATN9pH0IDrpA==",
+      "requires": {
+        "@types/mdast": "^4.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "micromark-util-types": "^2.0.0",
+        "unified": "^11.0.0"
+      }
+    },
+    "remark-rehype": {
+      "version": "11.1.2",
+      "resolved": "https://registry.facebook.net/remark-rehype/-/remark-rehype-11.1.2.tgz",
+      "integrity": "sha512-Dh7l57ianaEoIpzbp0PC9UKAdCSVklD8E5Rpw7ETfbTl3FqcOOgq5q2LVDhgGCkaBv7p24JXikPdvhhmHvKMsw==",
+      "requires": {
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "mdast-util-to-hast": "^13.0.0",
+        "unified": "^11.0.0",
+        "vfile": "^6.0.0"
+      }
+    },
+    "remark-stringify": {
+      "version": "11.0.0",
+      "resolved": "https://registry.facebook.net/remark-stringify/-/remark-stringify-11.0.0.tgz",
+      "integrity": "sha512-1OSmLd3awB/t8qdoEOMazZkNsfVTeY4fTsgzcQFdXNq8ToTN4ZGwrMnlda4K6smTFKD+GRV6O48i6Z4iKgPPpw==",
+      "requires": {
+        "@types/mdast": "^4.0.0",
+        "mdast-util-to-markdown": "^2.0.0",
+        "unified": "^11.0.0"
+      }
+    },
+    "renderkid": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/renderkid/-/renderkid-3.0.0.tgz",
+      "integrity": "sha512-q/7VIQA8lmM1hF+jn+sFSPWGlMkSAeNYcPLmDQx2zzuiDfaLrOmumR8iaUKlenFgh0XRPIUeSPlH3A+AW3Z5pg==",
+      "requires": {
+        "css-select": "^4.1.3",
+        "dom-converter": "^0.2.0",
+        "htmlparser2": "^6.1.0",
+        "lodash": "^4.17.21",
+        "strip-ansi": "^6.0.1"
+      },
+      "dependencies": {
+        "css-select": {
+          "version": "4.3.0",
+          "resolved": "https://registry.facebook.net/css-select/-/css-select-4.3.0.tgz",
+          "integrity": "sha512-wPpOYtnsVontu2mODhA19JrqWxNsfdatRKd64kmpRbQgh1KtItko5sTnEpPdpSaJszTOhEMlF/RPz28qj4HqhQ==",
+          "requires": {
+            "boolbase": "^1.0.0",
+            "css-what": "^6.0.1",
+            "domhandler": "^4.3.1",
+            "domutils": "^2.8.0",
+            "nth-check": "^2.0.1"
+          }
+        },
+        "dom-serializer": {
+          "version": "1.4.1",
+          "resolved": "https://registry.facebook.net/dom-serializer/-/dom-serializer-1.4.1.tgz",
+          "integrity": "sha512-VHwB3KfrcOOkelEG2ZOfxqLZdfkil8PtJi4P8N2MMXucZq2yLp75ClViUlOVwyoHEDjYU433Aq+5zWP61+RGag==",
+          "requires": {
+            "domelementtype": "^2.0.1",
+            "domhandler": "^4.2.0",
+            "entities": "^2.0.0"
+          }
+        },
+        "domhandler": {
+          "version": "4.3.1",
+          "resolved": "https://registry.facebook.net/domhandler/-/domhandler-4.3.1.tgz",
+          "integrity": "sha512-GrwoxYN+uWlzO8uhUXRl0P+kHE4GtVPfYzVLcUxPL7KNdHKj66vvlhiweIHqYYXWlw+T8iLMp42Lm67ghw4WMQ==",
+          "requires": {
+            "domelementtype": "^2.2.0"
+          }
+        },
+        "domutils": {
+          "version": "2.8.0",
+          "resolved": "https://registry.facebook.net/domutils/-/domutils-2.8.0.tgz",
+          "integrity": "sha512-w96Cjofp72M5IIhpjgobBimYEfoPjx1Vx0BSX9P30WBdZW2WIKU0T1Bd0kz2eNZ9ikjKgHbEyKx8BB6H1L3h3A==",
+          "requires": {
+            "dom-serializer": "^1.0.1",
+            "domelementtype": "^2.2.0",
+            "domhandler": "^4.2.0"
+          }
+        },
+        "entities": {
+          "version": "2.2.0",
+          "resolved": "https://registry.facebook.net/entities/-/entities-2.2.0.tgz",
+          "integrity": "sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A=="
+        },
+        "htmlparser2": {
+          "version": "6.1.0",
+          "resolved": "https://registry.facebook.net/htmlparser2/-/htmlparser2-6.1.0.tgz",
+          "integrity": "sha512-gyyPk6rgonLFEDGoeRgQNaEUvdJ4ktTmmUh/h2t7s+M8oPpIPxgNACWa+6ESR57kXstwqPiCut0V8NRpcwgU7A==",
+          "requires": {
+            "domelementtype": "^2.0.1",
+            "domhandler": "^4.0.0",
+            "domutils": "^2.5.2",
+            "entities": "^2.0.0"
+          }
+        }
+      }
+    },
+    "repeat-string": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz",
+      "integrity": "sha512-PV0dzCYDNfRi1jCDbJzpW7jNNDRuCOG/jI5ctQcGKt/clZD+YcPS3yIlWuTJMmESC8aevCFmWJy5wjAFgNqN6w=="
+    },
+    "require-from-string": {
+      "version": "2.0.2",
+      "resolved": "https://registry.facebook.net/require-from-string/-/require-from-string-2.0.2.tgz",
+      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw=="
+    },
+    "require-like": {
+      "version": "0.1.2",
+      "resolved": "https://registry.facebook.net/require-like/-/require-like-0.1.2.tgz",
+      "integrity": "sha512-oyrU88skkMtDdauHDuKVrgR+zuItqr6/c//FXzvmxRGMexSDc6hNvJInGW3LL46n+8b50RykrvwSUIIQH2LQ5A=="
+    },
+    "requires-port": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/requires-port/-/requires-port-1.0.0.tgz",
+      "integrity": "sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ=="
+    },
+    "resolve": {
+      "version": "1.22.12",
+      "resolved": "https://registry.facebook.net/resolve/-/resolve-1.22.12.tgz",
+      "integrity": "sha512-TyeJ1zif53BPfHootBGwPRYT1RUt6oGWsaQr8UyZW/eAm9bKoijtvruSDEmZHm92CwS9nj7/fWttqPCgzep8CA==",
+      "requires": {
+        "es-errors": "^1.3.0",
+        "is-core-module": "^2.16.1",
+        "path-parse": "^1.0.7",
+        "supports-preserve-symlinks-flag": "^1.0.0"
+      }
+    },
+    "resolve-alpn": {
+      "version": "1.2.1",
+      "resolved": "https://registry.facebook.net/resolve-alpn/-/resolve-alpn-1.2.1.tgz",
+      "integrity": "sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g=="
+    },
+    "resolve-from": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/resolve-from/-/resolve-from-4.0.0.tgz",
+      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g=="
+    },
+    "resolve-pathname": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/resolve-pathname/-/resolve-pathname-3.0.0.tgz",
+      "integrity": "sha512-C7rARubxI8bXFNB/hqcp/4iUeIXJhJZvFPFPiSPRnhU5UPxzMFIl+2E6yY6c4k9giDJAhtV+enfA+G89N6Csng=="
+    },
+    "responselike": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/responselike/-/responselike-3.0.0.tgz",
+      "integrity": "sha512-40yHxbNcl2+rzXvZuVkrYohathsSJlMTXKryG5y8uciHv1+xDLHQpgjG64JUO9nrEq2jGLH6IZ8BcZyw3wrweg==",
+      "requires": {
+        "lowercase-keys": "^3.0.0"
+      }
+    },
+    "retry": {
+      "version": "0.13.1",
+      "resolved": "https://registry.facebook.net/retry/-/retry-0.13.1.tgz",
+      "integrity": "sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg=="
+    },
+    "reusify": {
+      "version": "1.1.0",
+      "resolved": "https://registry.facebook.net/reusify/-/reusify-1.1.0.tgz",
+      "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw=="
+    },
+    "rtlcss": {
+      "version": "4.3.0",
+      "resolved": "https://registry.facebook.net/rtlcss/-/rtlcss-4.3.0.tgz",
+      "integrity": "sha512-FI+pHEn7Wc4NqKXMXFM+VAYKEj/mRIcW4h24YVwVtyjI+EqGrLc2Hx/Ny0lrZ21cBWU2goLy36eqMcNj3AQJig==",
+      "requires": {
+        "escalade": "^3.1.1",
+        "picocolors": "^1.0.0",
+        "postcss": "^8.4.21",
+        "strip-json-comments": "^3.1.1"
+      }
+    },
+    "run-applescript": {
+      "version": "7.1.0",
+      "resolved": "https://registry.facebook.net/run-applescript/-/run-applescript-7.1.0.tgz",
+      "integrity": "sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q=="
+    },
+    "run-parallel": {
+      "version": "1.2.0",
+      "resolved": "https://registry.facebook.net/run-parallel/-/run-parallel-1.2.0.tgz",
+      "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
+      "requires": {
+        "queue-microtask": "^1.2.2"
+      }
+    },
+    "safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.facebook.net/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="
+    },
+    "safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.facebook.net/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="
+    },
+    "sax": {
+      "version": "1.6.0",
+      "resolved": "https://registry.facebook.net/sax/-/sax-1.6.0.tgz",
+      "integrity": "sha512-6R3J5M4AcbtLUdZmRv2SygeVaM7IhrLXu9BmnOGmmACak8fiUtOsYNWUS4uK7upbmHIBbLBeFeI//477BKLBzA=="
+    },
+    "scheduler": {
+      "version": "0.23.2",
+      "resolved": "https://registry.facebook.net/scheduler/-/scheduler-0.23.2.tgz",
+      "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
+      "requires": {
+        "loose-envify": "^1.1.0"
+      }
+    },
+    "schema-dts": {
+      "version": "1.1.5",
+      "resolved": "https://registry.facebook.net/schema-dts/-/schema-dts-1.1.5.tgz",
+      "integrity": "sha512-RJr9EaCmsLzBX2NDiO5Z3ux2BVosNZN5jo0gWgsyKvxKIUL5R3swNvoorulAeL9kLB0iTSX7V6aokhla2m7xbg=="
+    },
+    "schema-utils": {
+      "version": "4.3.3",
+      "resolved": "https://registry.facebook.net/schema-utils/-/schema-utils-4.3.3.tgz",
+      "integrity": "sha512-eflK8wEtyOE6+hsaRVPxvUKYCpRgzLqDTb8krvAsRIwOGlHoSgYLgBXoubGgLd2fT41/OUYdb48v4k4WWHQurA==",
+      "requires": {
+        "@types/json-schema": "^7.0.9",
+        "ajv": "^8.9.0",
+        "ajv-formats": "^2.1.1",
+        "ajv-keywords": "^5.1.0"
+      }
+    },
+    "search-insights": {
+      "version": "2.17.3",
+      "resolved": "https://registry.npmjs.org/search-insights/-/search-insights-2.17.3.tgz",
+      "integrity": "sha512-RQPdCYTa8A68uM2jwxoY842xDhvx3E5LFL1LxvxCNMev4o5mLuokczhzjAgGwUZBAmOKZknArSxLKmXtIi2AxQ==",
+      "peer": true
+    },
+    "section-matter": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/section-matter/-/section-matter-1.0.0.tgz",
+      "integrity": "sha512-vfD3pmTzGpufjScBh50YHKzEu2lxBWhVEHsNGoEXmCmn2hKGfeNLYMzCJpe8cD7gqX7TJluOVpBkAequ6dgMmA==",
+      "requires": {
+        "extend-shallow": "^2.0.1",
+        "kind-of": "^6.0.0"
+      }
+    },
+    "select-hose": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/select-hose/-/select-hose-2.0.0.tgz",
+      "integrity": "sha512-mEugaLK+YfkijB4fx0e6kImuJdCIt2LxCRcbEYPqRGCs4F2ogyfZU5IAZRdjCP8JPq2AtdNoC/Dux63d9Kiryg=="
+    },
+    "selfsigned": {
+      "version": "5.5.0",
+      "resolved": "https://registry.facebook.net/selfsigned/-/selfsigned-5.5.0.tgz",
+      "integrity": "sha512-ftnu3TW4+3eBfLRFnDEkzGxSF/10BJBkaLJuBHZX0kiPS7bRdlpZGu6YGt4KngMkdTwJE6MbjavFpqHvqVt+Ew==",
+      "requires": {
+        "@peculiar/x509": "^1.14.2",
+        "pkijs": "^3.3.3"
+      }
+    },
+    "semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.facebook.net/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="
+    },
+    "semver-diff": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/semver-diff/-/semver-diff-4.0.0.tgz",
+      "integrity": "sha512-0Ju4+6A8iOnpL/Thra7dZsSlOHYAHIeMxfhWQRI1/VLcT3WDBZKKtQt/QkBOsiIN9ZpuvHE6cGZ0x4glCMmfiA==",
+      "requires": {
+        "semver": "^7.3.5"
+      },
+      "dependencies": {
+        "semver": {
+          "version": "7.7.4",
+          "resolved": "https://registry.facebook.net/semver/-/semver-7.7.4.tgz",
+          "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA=="
+        }
+      }
+    },
+    "send": {
+      "version": "0.19.2",
+      "resolved": "https://registry.facebook.net/send/-/send-0.19.2.tgz",
+      "integrity": "sha512-VMbMxbDeehAxpOtWJXlcUS5E8iXh6QmN+BkRX1GARS3wRaXEEgzCcB10gTQazO42tpNIya8xIyNx8fll1OFPrg==",
+      "requires": {
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "fresh": "~0.5.2",
+        "http-errors": "~2.0.1",
+        "mime": "1.6.0",
+        "ms": "2.1.3",
+        "on-finished": "~2.4.1",
+        "range-parser": "~1.2.1",
+        "statuses": "~2.0.2"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "2.6.9",
+          "resolved": "https://registry.facebook.net/debug/-/debug-2.6.9.tgz",
+          "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+          "requires": {
+            "ms": "2.0.0"
+          },
+          "dependencies": {
+            "ms": {
+              "version": "2.0.0",
+              "resolved": "https://registry.facebook.net/ms/-/ms-2.0.0.tgz",
+              "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A=="
+            }
+          }
+        }
+      }
+    },
+    "serialize-javascript": {
+      "version": "6.0.2",
+      "resolved": "https://registry.facebook.net/serialize-javascript/-/serialize-javascript-6.0.2.tgz",
+      "integrity": "sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==",
+      "requires": {
+        "randombytes": "^2.1.0"
+      }
+    },
+    "serve-handler": {
+      "version": "6.1.7",
+      "resolved": "https://registry.facebook.net/serve-handler/-/serve-handler-6.1.7.tgz",
+      "integrity": "sha512-CinAq1xWb0vR3twAv9evEU8cNWkXCb9kd5ePAHUKJBkOsUpR1wt/CvGdeca7vqumL1U5cSaeVQ6zZMxiJ3yWsg==",
+      "requires": {
+        "bytes": "3.0.0",
+        "content-disposition": "0.5.2",
+        "mime-types": "2.1.18",
+        "minimatch": "3.1.5",
+        "path-is-inside": "1.0.2",
+        "path-to-regexp": "3.3.0",
+        "range-parser": "1.2.0"
+      },
+      "dependencies": {
+        "bytes": {
+          "version": "3.0.0",
+          "resolved": "https://registry.facebook.net/bytes/-/bytes-3.0.0.tgz",
+          "integrity": "sha512-pMhOfFDPiv9t5jjIXkHosWmkSyQbvsgEVNkz0ERHbuLh2T/7j4Mqqpz523Fe8MVY89KC6Sh/QfS2sM+SjgFDcw=="
+        },
+        "mime-db": {
+          "version": "1.33.0",
+          "resolved": "https://registry.facebook.net/mime-db/-/mime-db-1.33.0.tgz",
+          "integrity": "sha512-BHJ/EKruNIqJf/QahvxwQZXKygOQ256myeN/Ew+THcAa5q+PjyTTMMeNQC4DZw5AwfvelsUrA6B67NKMqXDbzQ=="
+        },
+        "mime-types": {
+          "version": "2.1.18",
+          "resolved": "https://registry.facebook.net/mime-types/-/mime-types-2.1.18.tgz",
+          "integrity": "sha512-lc/aahn+t4/SWV/qcmumYjymLsWfN3ELhpmVuUFjgsORruuZPVSwAQryq+HHGvO/SI2KVX26bx+En+zhM8g8hQ==",
+          "requires": {
+            "mime-db": "~1.33.0"
+          }
+        },
+        "range-parser": {
+          "version": "1.2.0",
+          "resolved": "https://registry.facebook.net/range-parser/-/range-parser-1.2.0.tgz",
+          "integrity": "sha512-kA5WQoNVo4t9lNx2kQNFCxKeBl5IbbSNBl1M/tLkw9WCn+hxNBAW5Qh8gdhs63CJnhjJ2zQWFoqPJP2sK1AV5A=="
+        }
+      }
+    },
+    "serve-index": {
+      "version": "1.9.2",
+      "resolved": "https://registry.facebook.net/serve-index/-/serve-index-1.9.2.tgz",
+      "integrity": "sha512-KDj11HScOaLmrPxl70KYNW1PksP4Nb/CLL2yvC+Qd2kHMPEEpfc4Re2e4FOay+bC/+XQl/7zAcWON3JVo5v3KQ==",
+      "requires": {
+        "accepts": "~1.3.8",
+        "batch": "0.6.1",
+        "debug": "2.6.9",
+        "escape-html": "~1.0.3",
+        "http-errors": "~1.8.0",
+        "mime-types": "~2.1.35",
+        "parseurl": "~1.3.3"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "2.6.9",
+          "resolved": "https://registry.facebook.net/debug/-/debug-2.6.9.tgz",
+          "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+          "requires": {
+            "ms": "2.0.0"
+          }
+        },
+        "depd": {
+          "version": "1.1.2",
+          "resolved": "https://registry.facebook.net/depd/-/depd-1.1.2.tgz",
+          "integrity": "sha512-7emPTl6Dpo6JRXOXjLRxck+FlLRX5847cLKEn00PLAgc3g2hTZZgr+e4c2v6QpSmLeFP3n5yUo7ft6avBK/5jQ=="
+        },
+        "http-errors": {
+          "version": "1.8.1",
+          "resolved": "https://registry.facebook.net/http-errors/-/http-errors-1.8.1.tgz",
+          "integrity": "sha512-Kpk9Sm7NmI+RHhnj6OIWDI1d6fIoFAtFt9RLaTMRlg/8w49juAStsrBgp0Dp4OdxdVbRIeKhtCUvoi/RuAhO4g==",
+          "requires": {
+            "depd": "~1.1.2",
+            "inherits": "2.0.4",
+            "setprototypeof": "1.2.0",
+            "statuses": ">= 1.5.0 < 2",
+            "toidentifier": "1.0.1"
+          }
+        },
+        "ms": {
+          "version": "2.0.0",
+          "resolved": "https://registry.facebook.net/ms/-/ms-2.0.0.tgz",
+          "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A=="
+        },
+        "statuses": {
+          "version": "1.5.0",
+          "resolved": "https://registry.facebook.net/statuses/-/statuses-1.5.0.tgz",
+          "integrity": "sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA=="
+        }
+      }
+    },
+    "serve-static": {
+      "version": "1.16.3",
+      "resolved": "https://registry.facebook.net/serve-static/-/serve-static-1.16.3.tgz",
+      "integrity": "sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==",
+      "requires": {
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "parseurl": "~1.3.3",
+        "send": "~0.19.1"
+      }
+    },
+    "set-function-length": {
+      "version": "1.2.2",
+      "resolved": "https://registry.facebook.net/set-function-length/-/set-function-length-1.2.2.tgz",
+      "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==",
+      "requires": {
+        "define-data-property": "^1.1.4",
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2",
+        "get-intrinsic": "^1.2.4",
+        "gopd": "^1.0.1",
+        "has-property-descriptors": "^1.0.2"
+      }
+    },
+    "setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.facebook.net/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw=="
+    },
+    "shallow-clone": {
+      "version": "3.0.1",
+      "resolved": "https://registry.facebook.net/shallow-clone/-/shallow-clone-3.0.1.tgz",
+      "integrity": "sha512-/6KqX+GVUdqPuPPd2LxDDxzX6CAbjJehAAOKlNpqqUpAqPM6HeL8f+o3a+JsyGjn2lv0WY8UsTgUJjU9Ok55NA==",
+      "requires": {
+        "kind-of": "^6.0.2"
+      }
+    },
+    "shallowequal": {
+      "version": "1.1.0",
+      "resolved": "https://registry.facebook.net/shallowequal/-/shallowequal-1.1.0.tgz",
+      "integrity": "sha512-y0m1JoUZSlPAjXVtPPW70aZWfIL/dSP7AFkRnniLCrK/8MDKog3TySTBmckD+RObVxH0v4Tox67+F14PdED2oQ=="
+    },
+    "shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "requires": {
+        "shebang-regex": "^3.0.0"
+      }
+    },
+    "shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="
+    },
+    "shell-quote": {
+      "version": "1.8.3",
+      "resolved": "https://registry.facebook.net/shell-quote/-/shell-quote-1.8.3.tgz",
+      "integrity": "sha512-ObmnIF4hXNg1BqhnHmgbDETF8dLPCggZWBjkQfhZpbszZnYur5DUljTcCHii5LC3J5E0yeO/1LIMyH+UvHQgyw=="
+    },
+    "side-channel": {
+      "version": "1.1.0",
+      "resolved": "https://registry.facebook.net/side-channel/-/side-channel-1.1.0.tgz",
+      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
+      "requires": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3",
+        "side-channel-list": "^1.0.0",
+        "side-channel-map": "^1.0.1",
+        "side-channel-weakmap": "^1.0.2"
+      }
+    },
+    "side-channel-list": {
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/side-channel-list/-/side-channel-list-1.0.1.tgz",
+      "integrity": "sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==",
+      "requires": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.4"
+      }
+    },
+    "side-channel-map": {
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/side-channel-map/-/side-channel-map-1.0.1.tgz",
+      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
+      "requires": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3"
+      }
+    },
+    "side-channel-weakmap": {
+      "version": "1.0.2",
+      "resolved": "https://registry.facebook.net/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+      "requires": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3",
+        "side-channel-map": "^1.0.1"
+      }
+    },
+    "signal-exit": {
+      "version": "3.0.7",
+      "resolved": "https://registry.facebook.net/signal-exit/-/signal-exit-3.0.7.tgz",
+      "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ=="
+    },
+    "sirv": {
+      "version": "2.0.4",
+      "resolved": "https://registry.facebook.net/sirv/-/sirv-2.0.4.tgz",
+      "integrity": "sha512-94Bdh3cC2PKrbgSOUqTiGPWVZeSiXfKOVZNJniWoqrWrRkB1CJzBU3NEbiTsPcYy1lDsANA/THzS+9WBiy5nfQ==",
+      "requires": {
+        "@polka/url": "^1.0.0-next.24",
+        "mrmime": "^2.0.0",
+        "totalist": "^3.0.0"
+      }
+    },
+    "sisteransi": {
+      "version": "1.0.5",
+      "resolved": "https://registry.facebook.net/sisteransi/-/sisteransi-1.0.5.tgz",
+      "integrity": "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg=="
+    },
+    "sitemap": {
+      "version": "7.1.3",
+      "resolved": "https://registry.facebook.net/sitemap/-/sitemap-7.1.3.tgz",
+      "integrity": "sha512-tAjEd+wt/YwnEbfNB2ht51ybBJxbEWwe5ki/Z//Wh0rpBFTCUSj46GnxUKEWzhfuJTsee8x3lybHxFgUMig2hw==",
+      "requires": {
+        "@types/node": "^17.0.5",
+        "@types/sax": "^1.2.1",
+        "arg": "^5.0.0",
+        "sax": "^1.2.4"
+      },
+      "dependencies": {
+        "@types/node": {
+          "version": "17.0.45",
+          "resolved": "https://registry.facebook.net/@types/node/-/node-17.0.45.tgz",
+          "integrity": "sha512-w+tIMs3rq2afQdsPJlODhoUEKzFP1ayaoyl1CcnwtIlsVe7K7bA1NGm4s3PraqTLlXnbIN84zuBlxBWo1u9BLw=="
+        }
+      }
+    },
+    "skin-tone": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/skin-tone/-/skin-tone-2.0.0.tgz",
+      "integrity": "sha512-kUMbT1oBJCpgrnKoSr0o6wPtvRWT9W9UKvGLwfJYO2WuahZRHOpEyL1ckyMGgMWh0UdpmaoFqKKD29WTomNEGA==",
+      "requires": {
+        "unicode-emoji-modifier-base": "^1.0.0"
+      }
+    },
+    "slash": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/slash/-/slash-3.0.0.tgz",
+      "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q=="
+    },
+    "snake-case": {
+      "version": "3.0.4",
+      "resolved": "https://registry.facebook.net/snake-case/-/snake-case-3.0.4.tgz",
+      "integrity": "sha512-LAOh4z89bGQvl9pFfNF8V146i7o7/CqFPbqzYgP+yYzDIDeS9HaNFtXABamRW+AQzEVODcvE79ljJ+8a9YSdMg==",
+      "requires": {
+        "dot-case": "^3.0.4",
+        "tslib": "^2.0.3"
+      }
+    },
+    "sockjs": {
+      "version": "0.3.24",
+      "resolved": "https://registry.facebook.net/sockjs/-/sockjs-0.3.24.tgz",
+      "integrity": "sha512-GJgLTZ7vYb/JtPSSZ10hsOYIvEYsjbNU+zPdIHcUaWVNUEPivzxku31865sSSud0Da0W4lEeOPlmw93zLQchuQ==",
+      "requires": {
+        "faye-websocket": "^0.11.3",
+        "uuid": "^8.3.2",
+        "websocket-driver": "^0.7.4"
+      }
+    },
+    "sort-css-media-queries": {
+      "version": "2.2.0",
+      "resolved": "https://registry.facebook.net/sort-css-media-queries/-/sort-css-media-queries-2.2.0.tgz",
+      "integrity": "sha512-0xtkGhWCC9MGt/EzgnvbbbKhqWjl1+/rncmhTh5qCpbYguXh6S/qwePfv/JQ8jePXXmqingylxoC49pCkSPIbA=="
+    },
+    "source-map": {
+      "version": "0.6.1",
+      "resolved": "https://registry.facebook.net/source-map/-/source-map-0.6.1.tgz",
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g=="
+    },
+    "source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.facebook.net/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA=="
+    },
+    "source-map-support": {
+      "version": "0.5.21",
+      "resolved": "https://registry.facebook.net/source-map-support/-/source-map-support-0.5.21.tgz",
+      "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==",
+      "requires": {
+        "buffer-from": "^1.0.0",
+        "source-map": "^0.6.0"
+      }
+    },
+    "space-separated-tokens": {
+      "version": "2.0.2",
+      "resolved": "https://registry.facebook.net/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz",
+      "integrity": "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q=="
+    },
+    "spdy": {
+      "version": "4.0.2",
+      "resolved": "https://registry.facebook.net/spdy/-/spdy-4.0.2.tgz",
+      "integrity": "sha512-r46gZQZQV+Kl9oItvl1JZZqJKGr+oEkB08A6BzkiR7593/7IbtuncXHd2YoYeTsG4157ZssMu9KYvUHLcjcDoA==",
+      "requires": {
+        "debug": "^4.1.0",
+        "handle-thing": "^2.0.0",
+        "http-deceiver": "^1.2.7",
+        "select-hose": "^2.0.0",
+        "spdy-transport": "^3.0.0"
+      }
+    },
+    "spdy-transport": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/spdy-transport/-/spdy-transport-3.0.0.tgz",
+      "integrity": "sha512-hsLVFE5SjA6TCisWeJXFKniGGOpBgMLmerfO2aCyCU5s7nJ/rpAepqmFifv/GCbSbueEeAJJnmSQ2rKC/g8Fcw==",
+      "requires": {
+        "debug": "^4.1.0",
+        "detect-node": "^2.0.4",
+        "hpack.js": "^2.1.6",
+        "obuf": "^1.1.2",
+        "readable-stream": "^3.0.6",
+        "wbuf": "^1.7.3"
+      }
+    },
+    "sprintf-js": {
+      "version": "1.0.3",
+      "resolved": "https://registry.facebook.net/sprintf-js/-/sprintf-js-1.0.3.tgz",
+      "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g=="
+    },
+    "srcset": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/srcset/-/srcset-4.0.0.tgz",
+      "integrity": "sha512-wvLeHgcVHKO8Sc/H/5lkGreJQVeYMm9rlmt8PuR1xE31rIuXhuzznUUqAt8MqLhB3MqJdFzlNAfpcWnxiFUcPw=="
+    },
+    "statuses": {
+      "version": "2.0.2",
+      "resolved": "https://registry.facebook.net/statuses/-/statuses-2.0.2.tgz",
+      "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw=="
+    },
+    "std-env": {
+      "version": "3.10.0",
+      "resolved": "https://registry.facebook.net/std-env/-/std-env-3.10.0.tgz",
+      "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg=="
+    },
+    "string_decoder": {
+      "version": "1.3.0",
+      "resolved": "https://registry.facebook.net/string_decoder/-/string_decoder-1.3.0.tgz",
+      "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+      "requires": {
+        "safe-buffer": "~5.2.0"
+      }
+    },
+    "string-width": {
+      "version": "5.1.2",
+      "resolved": "https://registry.facebook.net/string-width/-/string-width-5.1.2.tgz",
+      "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==",
+      "requires": {
+        "eastasianwidth": "^0.2.0",
+        "emoji-regex": "^9.2.2",
+        "strip-ansi": "^7.0.1"
+      },
+      "dependencies": {
+        "ansi-regex": {
+          "version": "6.2.2",
+          "resolved": "https://registry.facebook.net/ansi-regex/-/ansi-regex-6.2.2.tgz",
+          "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg=="
+        },
+        "strip-ansi": {
+          "version": "7.2.0",
+          "resolved": "https://registry.facebook.net/strip-ansi/-/strip-ansi-7.2.0.tgz",
+          "integrity": "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==",
+          "requires": {
+            "ansi-regex": "^6.2.2"
+          }
+        }
+      }
+    },
+    "stringify-entities": {
+      "version": "4.0.4",
+      "resolved": "https://registry.facebook.net/stringify-entities/-/stringify-entities-4.0.4.tgz",
+      "integrity": "sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==",
+      "requires": {
+        "character-entities-html4": "^2.0.0",
+        "character-entities-legacy": "^3.0.0"
+      }
+    },
+    "stringify-object": {
+      "version": "3.3.0",
+      "resolved": "https://registry.facebook.net/stringify-object/-/stringify-object-3.3.0.tgz",
+      "integrity": "sha512-rHqiFh1elqCQ9WPLIC8I0Q/g/wj5J1eMkyoiD6eoQApWHP0FtlK7rqnhmabL5VUY9JQCcqwwvlOaSuutekgyrw==",
+      "requires": {
+        "get-own-enumerable-property-symbols": "^3.0.0",
+        "is-obj": "^1.0.1",
+        "is-regexp": "^1.0.0"
+      }
+    },
+    "strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.facebook.net/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "requires": {
+        "ansi-regex": "^5.0.1"
+      }
+    },
+    "strip-bom-string": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/strip-bom-string/-/strip-bom-string-1.0.0.tgz",
+      "integrity": "sha512-uCC2VHvQRYu+lMh4My/sFNmF2klFymLX1wHJeXnbEJERpV/ZsVuonzerjfrGpIGF7LBVa1O7i9kjiWvJiFck8g=="
+    },
+    "strip-final-newline": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/strip-final-newline/-/strip-final-newline-2.0.0.tgz",
+      "integrity": "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA=="
+    },
+    "strip-json-comments": {
+      "version": "3.1.1",
+      "resolved": "https://registry.facebook.net/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
+      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig=="
+    },
+    "style-to-js": {
+      "version": "1.1.21",
+      "resolved": "https://registry.facebook.net/style-to-js/-/style-to-js-1.1.21.tgz",
+      "integrity": "sha512-RjQetxJrrUJLQPHbLku6U/ocGtzyjbJMP9lCNK7Ag0CNh690nSH8woqWH9u16nMjYBAok+i7JO1NP2pOy8IsPQ==",
+      "requires": {
+        "style-to-object": "1.0.14"
+      }
+    },
+    "style-to-object": {
+      "version": "1.0.14",
+      "resolved": "https://registry.facebook.net/style-to-object/-/style-to-object-1.0.14.tgz",
+      "integrity": "sha512-LIN7rULI0jBscWQYaSswptyderlarFkjQ+t79nzty8tcIAceVomEVlLzH5VP4Cmsv6MtKhs7qaAiwlcp+Mgaxw==",
+      "requires": {
+        "inline-style-parser": "0.2.7"
+      }
+    },
+    "stylehacks": {
+      "version": "6.1.1",
+      "resolved": "https://registry.facebook.net/stylehacks/-/stylehacks-6.1.1.tgz",
+      "integrity": "sha512-gSTTEQ670cJNoaeIp9KX6lZmm8LJ3jPB5yJmX8Zq/wQxOsAFXV3qjWzHas3YYk1qesuVIyYWWUpZ0vSE/dTSGg==",
+      "requires": {
+        "browserslist": "^4.23.0",
+        "postcss-selector-parser": "^6.0.16"
+      },
+      "dependencies": {
+        "postcss-selector-parser": {
+          "version": "6.1.2",
+          "resolved": "https://registry.facebook.net/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
+          "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
+          "requires": {
+            "cssesc": "^3.0.0",
+            "util-deprecate": "^1.0.2"
+          }
+        }
+      }
+    },
+    "supports-color": {
+      "version": "8.1.1",
+      "resolved": "https://registry.facebook.net/supports-color/-/supports-color-8.1.1.tgz",
+      "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==",
+      "requires": {
+        "has-flag": "^4.0.0"
+      }
+    },
+    "supports-preserve-symlinks-flag": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
+      "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w=="
+    },
+    "svg-parser": {
+      "version": "2.0.4",
+      "resolved": "https://registry.facebook.net/svg-parser/-/svg-parser-2.0.4.tgz",
+      "integrity": "sha512-e4hG1hRwoOdRb37cIMSgzNsxyzKfayW6VOflrwvR+/bzrkyxY/31WkbgnQpgtrNp1SdpJvpUAGTa/ZoiPNDuRQ=="
+    },
+    "svgo": {
+      "version": "3.3.3",
+      "resolved": "https://registry.facebook.net/svgo/-/svgo-3.3.3.tgz",
+      "integrity": "sha512-+wn7I4p7YgJhHs38k2TNjy1vCfPIfLIJWR5MnCStsN8WuuTcBnRKcMHQLMM2ijxGZmDoZwNv8ipl5aTTen62ng==",
+      "requires": {
+        "commander": "^7.2.0",
+        "css-select": "^5.1.0",
+        "css-tree": "^2.3.1",
+        "css-what": "^6.1.0",
+        "csso": "^5.0.5",
+        "picocolors": "^1.0.0",
+        "sax": "^1.5.0"
+      },
+      "dependencies": {
+        "commander": {
+          "version": "7.2.0",
+          "resolved": "https://registry.facebook.net/commander/-/commander-7.2.0.tgz",
+          "integrity": "sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw=="
+        }
+      }
+    },
+    "tapable": {
+      "version": "2.3.3",
+      "resolved": "https://registry.facebook.net/tapable/-/tapable-2.3.3.tgz",
+      "integrity": "sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A=="
+    },
+    "terser": {
+      "version": "5.46.2",
+      "resolved": "https://registry.facebook.net/terser/-/terser-5.46.2.tgz",
+      "integrity": "sha512-uxfo9fPcSgLDYob/w1FuL0c99MWiJDnv+5qXSQc5+Ki5NjVNsYi66INnMFBjf6uFz6OnX12piJQPF4IpjJTNTw==",
+      "requires": {
+        "@jridgewell/source-map": "^0.3.3",
+        "acorn": "^8.15.0",
+        "commander": "^2.20.0",
+        "source-map-support": "~0.5.20"
+      },
+      "dependencies": {
+        "commander": {
+          "version": "2.20.3",
+          "resolved": "https://registry.facebook.net/commander/-/commander-2.20.3.tgz",
+          "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ=="
+        }
+      }
+    },
+    "terser-webpack-plugin": {
+      "version": "5.5.0",
+      "resolved": "https://registry.facebook.net/terser-webpack-plugin/-/terser-webpack-plugin-5.5.0.tgz",
+      "integrity": "sha512-UYhptBwhWvfIjKd/UuFo6D8uq9xpGLDK+z8EDsj/zWhrTaH34cKEbrkMKfV5YWqGBvAYA3tlzZbs2R+qYrbQJA==",
+      "requires": {
+        "@jridgewell/trace-mapping": "^0.3.25",
+        "jest-worker": "^27.4.5",
+        "schema-utils": "^4.3.0",
+        "terser": "^5.31.1"
+      }
+    },
+    "thingies": {
+      "version": "2.6.0",
+      "resolved": "https://registry.facebook.net/thingies/-/thingies-2.6.0.tgz",
+      "integrity": "sha512-rMHRjmlFLM1R96UYPvpmnc3LYtdFrT33JIB7L9hetGue1qAPfn1N2LJeEjxUSidu1Iku+haLZXDuEXUHNGO/lg==",
+      "requires": {}
+    },
+    "thunky": {
+      "version": "1.1.0",
+      "resolved": "https://registry.facebook.net/thunky/-/thunky-1.1.0.tgz",
+      "integrity": "sha512-eHY7nBftgThBqOyHGVN+l8gF0BucP09fMo0oO/Lb0w1OF80dJv+lDVpXG60WMQvkcxAkNybKsrEIE3ZtKGmPrA=="
+    },
+    "tiny-invariant": {
+      "version": "1.3.3",
+      "resolved": "https://registry.facebook.net/tiny-invariant/-/tiny-invariant-1.3.3.tgz",
+      "integrity": "sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg=="
+    },
+    "tiny-warning": {
+      "version": "1.0.3",
+      "resolved": "https://registry.facebook.net/tiny-warning/-/tiny-warning-1.0.3.tgz",
+      "integrity": "sha512-lBN9zLN/oAf68o3zNXYrdCt1kP8WsiGW8Oo2ka41b2IM5JL/S1CTyX1rW0mb/zSuJun0ZUrDxx4sqvYS2FWzPA=="
+    },
+    "tinypool": {
+      "version": "1.1.1",
+      "resolved": "https://registry.facebook.net/tinypool/-/tinypool-1.1.1.tgz",
+      "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg=="
+    },
+    "to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.facebook.net/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "requires": {
+        "is-number": "^7.0.0"
+      }
+    },
+    "toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA=="
+    },
+    "totalist": {
+      "version": "3.0.1",
+      "resolved": "https://registry.facebook.net/totalist/-/totalist-3.0.1.tgz",
+      "integrity": "sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ=="
+    },
+    "tree-dump": {
+      "version": "1.1.0",
+      "resolved": "https://registry.facebook.net/tree-dump/-/tree-dump-1.1.0.tgz",
+      "integrity": "sha512-rMuvhU4MCDbcbnleZTFezWsaZXRFemSqAM+7jPnzUl1fo9w3YEKOxAeui0fz3OI4EU4hf23iyA7uQRVko+UaBA==",
+      "requires": {}
+    },
+    "trim-lines": {
+      "version": "3.0.1",
+      "resolved": "https://registry.facebook.net/trim-lines/-/trim-lines-3.0.1.tgz",
+      "integrity": "sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg=="
+    },
+    "trough": {
+      "version": "2.2.0",
+      "resolved": "https://registry.facebook.net/trough/-/trough-2.2.0.tgz",
+      "integrity": "sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw=="
+    },
+    "tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.facebook.net/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="
+    },
+    "tsyringe": {
+      "version": "4.10.0",
+      "resolved": "https://registry.facebook.net/tsyringe/-/tsyringe-4.10.0.tgz",
+      "integrity": "sha512-axr3IdNuVIxnaK5XGEUFTu3YmAQ6lllgrvqfEoR16g/HGnYY/6We4oWENtAnzK6/LpJ2ur9PAb80RBt7/U4ugw==",
+      "requires": {
+        "tslib": "^1.9.3"
+      },
+      "dependencies": {
+        "tslib": {
+          "version": "1.14.1",
+          "resolved": "https://registry.facebook.net/tslib/-/tslib-1.14.1.tgz",
+          "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg=="
+        }
+      }
+    },
+    "type-fest": {
+      "version": "2.19.0",
+      "resolved": "https://registry.facebook.net/type-fest/-/type-fest-2.19.0.tgz",
+      "integrity": "sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA=="
+    },
+    "type-is": {
+      "version": "1.6.18",
+      "resolved": "https://registry.facebook.net/type-is/-/type-is-1.6.18.tgz",
+      "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==",
+      "requires": {
+        "media-typer": "0.3.0",
+        "mime-types": "~2.1.24"
+      }
+    },
+    "typedarray-to-buffer": {
+      "version": "3.1.5",
+      "resolved": "https://registry.facebook.net/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz",
+      "integrity": "sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==",
+      "requires": {
+        "is-typedarray": "^1.0.0"
+      }
+    },
+    "undici-types": {
+      "version": "7.19.2",
+      "resolved": "https://registry.facebook.net/undici-types/-/undici-types-7.19.2.tgz",
+      "integrity": "sha512-qYVnV5OEm2AW8cJMCpdV20CDyaN3g0AjDlOGf1OW4iaDEx8MwdtChUp4zu4H0VP3nDRF/8RKWH+IPp9uW0YGZg=="
+    },
+    "unicode-canonical-property-names-ecmascript": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.1.tgz",
+      "integrity": "sha512-dA8WbNeb2a6oQzAQ55YlT5vQAWGV9WXOsi3SskE3bcCdM0P4SDd+24zS/OCacdRq5BkdsRj9q3Pg6YyQoxIGqg=="
+    },
+    "unicode-emoji-modifier-base": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/unicode-emoji-modifier-base/-/unicode-emoji-modifier-base-1.0.0.tgz",
+      "integrity": "sha512-yLSH4py7oFH3oG/9K+XWrz1pSi3dfUrWEnInbxMfArOfc1+33BlGPQtLsOYwvdMy11AwUBetYuaRxSPqgkq+8g=="
+    },
+    "unicode-match-property-ecmascript": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-2.0.0.tgz",
+      "integrity": "sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q==",
+      "requires": {
+        "unicode-canonical-property-names-ecmascript": "^2.0.0",
+        "unicode-property-aliases-ecmascript": "^2.0.0"
+      }
+    },
+    "unicode-match-property-value-ecmascript": {
+      "version": "2.2.1",
+      "resolved": "https://registry.facebook.net/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.2.1.tgz",
+      "integrity": "sha512-JQ84qTuMg4nVkx8ga4A16a1epI9H6uTXAknqxkGF/aFfRLw1xC/Bp24HNLaZhHSkWd3+84t8iXnp1J0kYcZHhg=="
+    },
+    "unicode-property-aliases-ecmascript": {
+      "version": "2.2.0",
+      "resolved": "https://registry.facebook.net/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.2.0.tgz",
+      "integrity": "sha512-hpbDzxUY9BFwX+UeBnxv3Sh1q7HFxj48DTmXchNgRa46lO8uj3/1iEn3MiNUYTg1g9ctIqXCCERn8gYZhHC5lQ=="
+    },
+    "unified": {
+      "version": "11.0.5",
+      "resolved": "https://registry.facebook.net/unified/-/unified-11.0.5.tgz",
+      "integrity": "sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA==",
+      "requires": {
+        "@types/unist": "^3.0.0",
+        "bail": "^2.0.0",
+        "devlop": "^1.0.0",
+        "extend": "^3.0.0",
+        "is-plain-obj": "^4.0.0",
+        "trough": "^2.0.0",
+        "vfile": "^6.0.0"
+      },
+      "dependencies": {
+        "is-plain-obj": {
+          "version": "4.1.0",
+          "resolved": "https://registry.facebook.net/is-plain-obj/-/is-plain-obj-4.1.0.tgz",
+          "integrity": "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg=="
+        }
+      }
+    },
+    "unique-string": {
+      "version": "3.0.0",
+      "resolved": "https://registry.facebook.net/unique-string/-/unique-string-3.0.0.tgz",
+      "integrity": "sha512-VGXBUVwxKMBUznyffQweQABPRRW1vHZAbadFZud4pLFAqRGvv/96vafgjWFqzourzr8YonlQiPgH0YCJfawoGQ==",
+      "requires": {
+        "crypto-random-string": "^4.0.0"
+      }
+    },
+    "unist-util-is": {
+      "version": "6.0.1",
+      "resolved": "https://registry.facebook.net/unist-util-is/-/unist-util-is-6.0.1.tgz",
+      "integrity": "sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==",
+      "requires": {
+        "@types/unist": "^3.0.0"
+      }
+    },
+    "unist-util-position": {
+      "version": "5.0.0",
+      "resolved": "https://registry.facebook.net/unist-util-position/-/unist-util-position-5.0.0.tgz",
+      "integrity": "sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==",
+      "requires": {
+        "@types/unist": "^3.0.0"
+      }
+    },
+    "unist-util-position-from-estree": {
+      "version": "2.0.0",
+      "resolved": "https://registry.facebook.net/unist-util-position-from-estree/-/unist-util-position-from-estree-2.0.0.tgz",
+      "integrity": "sha512-KaFVRjoqLyF6YXCbVLNad/eS4+OfPQQn2yOd7zF/h5T/CSL2v8NpN6a5TPvtbXthAGw5nG+PuTtq+DdIZr+cRQ==",
+      "requires": {
+        "@types/unist": "^3.0.0"
+      }
+    },
+    "unist-util-stringify-position": {
+      "version": "4.0.0",
+      "resolved": "https://registry.facebook.net/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz",
+      "integrity": "sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==",
+      "requires": {
+        "@types/unist": "^3.0.0"
+      }
+    },
+    "unist-util-visit": {
+      "version": "5.1.0",
+      "resolved": "https://registry.facebook.net/unist-util-visit/-/unist-util-visit-5.1.0.tgz",
+      "integrity": "sha512-m+vIdyeCOpdr/QeQCu2EzxX/ohgS8KbnPDgFni4dQsfSCtpz8UqDyY5GjRru8PDKuYn7Fq19j1CQ+nJSsGKOzg==",
+      "requires": {
+        "@types/unist": "^3.0.0",
+        "unist-util-is": "^6.0.0",
+        "unist-util-visit-parents": "^6.0.0"
+      }
+    },
+    "unist-util-visit-parents": {
+      "version": "6.0.2",
+      "resolved": "https://registry.facebook.net/unist-util-visit-parents/-/unist-util-visit-parents-6.0.2.tgz",
+      "integrity": "sha512-goh1s1TBrqSqukSc8wrjwWhL0hiJxgA8m4kFxGlQ+8FYQ3C/m11FcTs4YYem7V664AhHVvgoQLk890Ssdsr2IQ==",
+      "requires": {
+        "@types/unist": "^3.0.0",
+        "unist-util-is": "^6.0.0"
+      }
+    },
+    "universalify": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/universalify/-/universalify-2.0.1.tgz",
+      "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw=="
+    },
+    "unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.facebook.net/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ=="
+    },
+    "update-browserslist-db": {
+      "version": "1.2.3",
+      "resolved": "https://registry.facebook.net/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
+      "requires": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      }
+    },
+    "update-notifier": {
+      "version": "6.0.2",
+      "resolved": "https://registry.facebook.net/update-notifier/-/update-notifier-6.0.2.tgz",
+      "integrity": "sha512-EDxhTEVPZZRLWYcJ4ZXjGFN0oP7qYvbXWzEgRm/Yql4dHX5wDbvh89YHP6PK1lzZJYrMtXUuZZz8XGK+U6U1og==",
+      "requires": {
+        "boxen": "^7.0.0",
+        "chalk": "^5.0.1",
+        "configstore": "^6.0.0",
+        "has-yarn": "^3.0.0",
+        "import-lazy": "^4.0.0",
+        "is-ci": "^3.0.1",
+        "is-installed-globally": "^0.4.0",
+        "is-npm": "^6.0.0",
+        "is-yarn-global": "^0.4.0",
+        "latest-version": "^7.0.0",
+        "pupa": "^3.1.0",
+        "semver": "^7.3.7",
+        "semver-diff": "^4.0.0",
+        "xdg-basedir": "^5.1.0"
+      },
+      "dependencies": {
+        "boxen": {
+          "version": "7.1.1",
+          "resolved": "https://registry.facebook.net/boxen/-/boxen-7.1.1.tgz",
+          "integrity": "sha512-2hCgjEmP8YLWQ130n2FerGv7rYpfBmnmp9Uy2Le1vge6X3gZIfSmEzP5QTDElFxcvVcXlEn8Aq6MU/PZygIOog==",
+          "requires": {
+            "ansi-align": "^3.0.1",
+            "camelcase": "^7.0.1",
+            "chalk": "^5.2.0",
+            "cli-boxes": "^3.0.0",
+            "string-width": "^5.1.2",
+            "type-fest": "^2.13.0",
+            "widest-line": "^4.0.1",
+            "wrap-ansi": "^8.1.0"
+          }
+        },
+        "camelcase": {
+          "version": "7.0.1",
+          "resolved": "https://registry.facebook.net/camelcase/-/camelcase-7.0.1.tgz",
+          "integrity": "sha512-xlx1yCK2Oc1APsPXDL2LdlNP6+uu8OCDdhOBSVT279M/S+y75O30C2VuD8T2ogdePBBl7PfPF4504tnLgX3zfw=="
+        },
+        "chalk": {
+          "version": "5.6.2",
+          "resolved": "https://registry.facebook.net/chalk/-/chalk-5.6.2.tgz",
+          "integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA=="
+        },
+        "semver": {
+          "version": "7.7.4",
+          "resolved": "https://registry.facebook.net/semver/-/semver-7.7.4.tgz",
+          "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA=="
+        }
+      }
+    },
+    "uri-js": {
+      "version": "4.4.1",
+      "resolved": "https://registry.facebook.net/uri-js/-/uri-js-4.4.1.tgz",
+      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
+      "requires": {
+        "punycode": "^2.1.0"
+      }
+    },
+    "url-loader": {
+      "version": "4.1.1",
+      "resolved": "https://registry.facebook.net/url-loader/-/url-loader-4.1.1.tgz",
+      "integrity": "sha512-3BTV812+AVHHOJQO8O5MkWgZ5aosP7GnROJwvzLS9hWDj00lZ6Z0wNak423Lp9PBZN05N+Jk/N5Si8jRAlGyWA==",
+      "requires": {
+        "loader-utils": "^2.0.0",
+        "mime-types": "^2.1.27",
+        "schema-utils": "^3.0.0"
+      },
+      "dependencies": {
+        "ajv": {
+          "version": "6.15.0",
+          "resolved": "https://registry.facebook.net/ajv/-/ajv-6.15.0.tgz",
+          "integrity": "sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==",
+          "requires": {
+            "fast-deep-equal": "^3.1.1",
+            "fast-json-stable-stringify": "^2.0.0",
+            "json-schema-traverse": "^0.4.1",
+            "uri-js": "^4.2.2"
+          }
+        },
+        "ajv-keywords": {
+          "version": "3.5.2",
+          "resolved": "https://registry.facebook.net/ajv-keywords/-/ajv-keywords-3.5.2.tgz",
+          "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==",
+          "requires": {}
+        },
+        "json-schema-traverse": {
+          "version": "0.4.1",
+          "resolved": "https://registry.facebook.net/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+          "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="
+        },
+        "schema-utils": {
+          "version": "3.3.0",
+          "resolved": "https://registry.facebook.net/schema-utils/-/schema-utils-3.3.0.tgz",
+          "integrity": "sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==",
+          "requires": {
+            "@types/json-schema": "^7.0.8",
+            "ajv": "^6.12.5",
+            "ajv-keywords": "^3.5.2"
+          }
+        }
+      }
+    },
+    "util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.facebook.net/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="
+    },
+    "utila": {
+      "version": "0.4.0",
+      "resolved": "https://registry.facebook.net/utila/-/utila-0.4.0.tgz",
+      "integrity": "sha512-Z0DbgELS9/L/75wZbro8xAnT50pBVFQZ+hUEueGDU5FN51YSCYM+jdxsfCiHjwNP/4LCDD0i/graKpeBnOXKRA=="
+    },
+    "utility-types": {
+      "version": "3.11.0",
+      "resolved": "https://registry.facebook.net/utility-types/-/utility-types-3.11.0.tgz",
+      "integrity": "sha512-6Z7Ma2aVEWisaL6TvBCy7P8rm2LQoPv6dJ7ecIaIixHcwfbJ0x7mWdbcwlIM5IGQxPZSFYeqRCqlOOeKoJYMkw=="
+    },
+    "utils-merge": {
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/utils-merge/-/utils-merge-1.0.1.tgz",
+      "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA=="
+    },
+    "uuid": {
+      "version": "8.3.2",
+      "resolved": "https://registry.facebook.net/uuid/-/uuid-8.3.2.tgz",
+      "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg=="
+    },
+    "value-equal": {
+      "version": "1.0.1",
+      "resolved": "https://registry.facebook.net/value-equal/-/value-equal-1.0.1.tgz",
+      "integrity": "sha512-NOJ6JZCAWr0zlxZt+xqCHNTEKOsrks2HQd4MqhP1qy4z1SkbEP467eNx6TgDKXMvUOb+OENfJCZwM+16n7fRfw=="
+    },
+    "vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.facebook.net/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg=="
+    },
+    "vfile": {
+      "version": "6.0.3",
+      "resolved": "https://registry.facebook.net/vfile/-/vfile-6.0.3.tgz",
+      "integrity": "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==",
+      "requires": {
+        "@types/unist": "^3.0.0",
+        "vfile-message": "^4.0.0"
+      }
+    },
+    "vfile-location": {
+      "version": "5.0.3",
+      "resolved": "https://registry.facebook.net/vfile-location/-/vfile-location-5.0.3.tgz",
+      "integrity": "sha512-5yXvWDEgqeiYiBe1lbxYF7UMAIm/IcopxMHrMQDq3nvKcjPKIhZklUKL+AE7J7uApI4kwe2snsK+eI6UTj9EHg==",
+      "requires": {
+        "@types/unist": "^3.0.0",
+        "vfile": "^6.0.0"
+      }
+    },
+    "vfile-message": {
+      "version": "4.0.3",
+      "resolved": "https://registry.facebook.net/vfile-message/-/vfile-message-4.0.3.tgz",
+      "integrity": "sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw==",
+      "requires": {
+        "@types/unist": "^3.0.0",
+        "unist-util-stringify-position": "^4.0.0"
       }
     },
-    "node_modules/webpackbar": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/webpackbar/-/webpackbar-6.0.1.tgz",
-      "integrity": "sha512-TnErZpmuKdwWBdMoexjio3KKX6ZtoKHRVvLIU0A47R0VVBDtx3ZyOJDktgYixhoJokZTYTt1Z37OkO9pnGJa9Q==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-escapes": "^4.3.2",
-        "chalk": "^4.1.2",
-        "consola": "^3.2.3",
-        "figures": "^3.2.0",
-        "markdown-table": "^2.0.0",
-        "pretty-time": "^1.1.0",
-        "std-env": "^3.7.0",
-        "wrap-ansi": "^7.0.0"
-      },
-      "engines": {
-        "node": ">=14.21.3"
-      },
-      "peerDependencies": {
-        "webpack": "3 || 4 || 5"
+    "watchpack": {
+      "version": "2.5.1",
+      "resolved": "https://registry.facebook.net/watchpack/-/watchpack-2.5.1.tgz",
+      "integrity": "sha512-Zn5uXdcFNIA1+1Ei5McRd+iRzfhENPCe7LeABkJtNulSxjma+l7ltNx55BWZkRlwRnpOgHqxnjyaDgJnNXnqzg==",
+      "requires": {
+        "glob-to-regexp": "^0.4.1",
+        "graceful-fs": "^4.1.2"
       }
     },
-    "node_modules/webpackbar/node_modules/emoji-regex": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
-      "license": "MIT"
+    "wbuf": {
+      "version": "1.7.3",
+      "resolved": "https://registry.facebook.net/wbuf/-/wbuf-1.7.3.tgz",
+      "integrity": "sha512-O84QOnr0icsbFGLS0O3bI5FswxzRr8/gHwWkDlQFskhSPryQXvrTMxjxGP4+iWYoauLoBvfDpkrOauZ+0iZpDA==",
+      "requires": {
+        "minimalistic-assert": "^1.0.0"
+      }
     },
-    "node_modules/webpackbar/node_modules/markdown-table": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-2.0.0.tgz",
-      "integrity": "sha512-Ezda85ToJUBhM6WGaG6veasyym+Tbs3cMAw/ZhOPqXiYsr0jgocBV3j3nx+4lk47plLlIqjwuTm/ywVI+zjJ/A==",
-      "license": "MIT",
-      "dependencies": {
-        "repeat-string": "^1.0.0"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/wooorm"
+    "web-namespaces": {
+      "version": "2.0.1",
+      "resolved": "https://registry.facebook.net/web-namespaces/-/web-namespaces-2.0.1.tgz",
+      "integrity": "sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ=="
+    },
+    "webpack": {
+      "version": "5.106.2",
+      "resolved": "https://registry.facebook.net/webpack/-/webpack-5.106.2.tgz",
+      "integrity": "sha512-wGN3qcrBQIFmQ/c0AiOAQBvrZ5lmY8vbbMv4Mxfgzqd/B6+9pXtLo73WuS1dSGXM5QYY3hZnIbvx+K1xxe6FyA==",
+      "requires": {
+        "@types/eslint-scope": "^3.7.7",
+        "@types/estree": "^1.0.8",
+        "@types/json-schema": "^7.0.15",
+        "@webassemblyjs/ast": "^1.14.1",
+        "@webassemblyjs/wasm-edit": "^1.14.1",
+        "@webassemblyjs/wasm-parser": "^1.14.1",
+        "acorn": "^8.16.0",
+        "acorn-import-phases": "^1.0.3",
+        "browserslist": "^4.28.1",
+        "chrome-trace-event": "^1.0.2",
+        "enhanced-resolve": "^5.20.0",
+        "es-module-lexer": "^2.0.0",
+        "eslint-scope": "5.1.1",
+        "events": "^3.2.0",
+        "glob-to-regexp": "^0.4.1",
+        "graceful-fs": "^4.2.11",
+        "loader-runner": "^4.3.1",
+        "mime-db": "^1.54.0",
+        "neo-async": "^2.6.2",
+        "schema-utils": "^4.3.3",
+        "tapable": "^2.3.0",
+        "terser-webpack-plugin": "^5.3.17",
+        "watchpack": "^2.5.1",
+        "webpack-sources": "^3.3.4"
       }
     },
-    "node_modules/webpackbar/node_modules/string-width": {
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
+    "webpack-bundle-analyzer": {
+      "version": "4.10.2",
+      "resolved": "https://registry.facebook.net/webpack-bundle-analyzer/-/webpack-bundle-analyzer-4.10.2.tgz",
+      "integrity": "sha512-vJptkMm9pk5si4Bv922ZbKLV8UTT4zib4FPgXMhgzUny0bfDDkLXAVQs3ly3fS4/TN9ROFtb0NFrm04UXFE/Vw==",
+      "requires": {
+        "@discoveryjs/json-ext": "0.5.7",
+        "acorn": "^8.0.4",
+        "acorn-walk": "^8.0.0",
+        "commander": "^7.2.0",
+        "debounce": "^1.2.1",
+        "escape-string-regexp": "^4.0.0",
+        "gzip-size": "^6.0.0",
+        "html-escaper": "^2.0.2",
+        "opener": "^1.5.2",
+        "picocolors": "^1.0.0",
+        "sirv": "^2.0.3",
+        "ws": "^7.3.1"
       },
-      "engines": {
-        "node": ">=8"
+      "dependencies": {
+        "commander": {
+          "version": "7.2.0",
+          "resolved": "https://registry.facebook.net/commander/-/commander-7.2.0.tgz",
+          "integrity": "sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw=="
+        }
       }
     },
-    "node_modules/webpackbar/node_modules/wrap-ansi": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
-      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.0.0",
-        "string-width": "^4.1.0",
-        "strip-ansi": "^6.0.0"
+    "webpack-dev-middleware": {
+      "version": "7.4.5",
+      "resolved": "https://registry.facebook.net/webpack-dev-middleware/-/webpack-dev-middleware-7.4.5.tgz",
+      "integrity": "sha512-uxQ6YqGdE4hgDKNf7hUiPXOdtkXvBJXrfEGYSx7P7LC8hnUYGK70X6xQXUvXeNyBDDcsiQXpG2m3G9vxowaEuA==",
+      "requires": {
+        "colorette": "^2.0.10",
+        "memfs": "^4.43.1",
+        "mime-types": "^3.0.1",
+        "on-finished": "^2.4.1",
+        "range-parser": "^1.2.1",
+        "schema-utils": "^4.0.0"
       },
-      "engines": {
-        "node": ">=10"
+      "dependencies": {
+        "mime-types": {
+          "version": "3.0.2",
+          "resolved": "https://registry.facebook.net/mime-types/-/mime-types-3.0.2.tgz",
+          "integrity": "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==",
+          "requires": {
+            "mime-db": "^1.54.0"
+          }
+        }
+      }
+    },
+    "webpack-dev-server": {
+      "version": "5.2.3",
+      "resolved": "https://registry.facebook.net/webpack-dev-server/-/webpack-dev-server-5.2.3.tgz",
+      "integrity": "sha512-9Gyu2F7+bg4Vv+pjbovuYDhHX+mqdqITykfzdM9UyKqKHlsE5aAjRhR+oOEfXW5vBeu8tarzlJFIZva4ZjAdrQ==",
+      "requires": {
+        "@types/bonjour": "^3.5.13",
+        "@types/connect-history-api-fallback": "^1.5.4",
+        "@types/express": "^4.17.25",
+        "@types/express-serve-static-core": "^4.17.21",
+        "@types/serve-index": "^1.9.4",
+        "@types/serve-static": "^1.15.5",
+        "@types/sockjs": "^0.3.36",
+        "@types/ws": "^8.5.10",
+        "ansi-html-community": "^0.0.8",
+        "bonjour-service": "^1.2.1",
+        "chokidar": "^3.6.0",
+        "colorette": "^2.0.10",
+        "compression": "^1.8.1",
+        "connect-history-api-fallback": "^2.0.0",
+        "express": "^4.22.1",
+        "graceful-fs": "^4.2.6",
+        "http-proxy-middleware": "^2.0.9",
+        "ipaddr.js": "^2.1.0",
+        "launch-editor": "^2.6.1",
+        "open": "^10.0.3",
+        "p-retry": "^6.2.0",
+        "schema-utils": "^4.2.0",
+        "selfsigned": "^5.5.0",
+        "serve-index": "^1.9.1",
+        "sockjs": "^0.3.24",
+        "spdy": "^4.0.2",
+        "webpack-dev-middleware": "^7.4.2",
+        "ws": "^8.18.0"
       },
-      "funding": {
-        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      "dependencies": {
+        "define-lazy-prop": {
+          "version": "3.0.0",
+          "resolved": "https://registry.facebook.net/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz",
+          "integrity": "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg=="
+        },
+        "open": {
+          "version": "10.2.0",
+          "resolved": "https://registry.facebook.net/open/-/open-10.2.0.tgz",
+          "integrity": "sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA==",
+          "requires": {
+            "default-browser": "^5.2.1",
+            "define-lazy-prop": "^3.0.0",
+            "is-inside-container": "^1.0.0",
+            "wsl-utils": "^0.1.0"
+          }
+        },
+        "ws": {
+          "version": "8.20.0",
+          "resolved": "https://registry.facebook.net/ws/-/ws-8.20.0.tgz",
+          "integrity": "sha512-sAt8BhgNbzCtgGbt2OxmpuryO63ZoDk/sqaB/znQm94T4fCEsy/yV+7CdC1kJhOU9lboAEU7R3kquuycDoibVA==",
+          "requires": {}
+        }
       }
     },
-    "node_modules/websocket-driver": {
+    "webpack-merge": {
+      "version": "6.0.1",
+      "resolved": "https://registry.facebook.net/webpack-merge/-/webpack-merge-6.0.1.tgz",
+      "integrity": "sha512-hXXvrjtx2PLYx4qruKl+kyRSLc52V+cCvMxRjmKwoA+CBbbF5GfIBtR6kCvl0fYGqTUPKB+1ktVmTHqMOzgCBg==",
+      "requires": {
+        "clone-deep": "^4.0.1",
+        "flat": "^5.0.2",
+        "wildcard": "^2.0.1"
+      }
+    },
+    "webpack-sources": {
+      "version": "3.4.0",
+      "resolved": "https://registry.facebook.net/webpack-sources/-/webpack-sources-3.4.0.tgz",
+      "integrity": "sha512-gHwIe1cgBvvfLeu1Yz/dcFpmHfKDVxxyqI+kzqmuxZED81z2ChxpyqPaWcNqigPywhaEke7AjSGga+kxY55gjQ=="
+    },
+    "websocket-driver": {
       "version": "0.7.4",
-      "resolved": "https://registry.npmjs.org/websocket-driver/-/websocket-driver-0.7.4.tgz",
+      "resolved": "https://registry.facebook.net/websocket-driver/-/websocket-driver-0.7.4.tgz",
       "integrity": "sha512-b17KeDIQVjvb0ssuSDF2cYXSg2iztliJ4B9WdsuB6J952qCPKmnVq4DyW5motImXHDC1cBT/1UezrJVsKw5zjg==",
-      "license": "Apache-2.0",
-      "dependencies": {
+      "requires": {
         "http-parser-js": ">=0.5.1",
         "safe-buffer": ">=5.1.0",
         "websocket-extensions": ">=0.1.1"
-      },
-      "engines": {
-        "node": ">=0.8.0"
       }
     },
-    "node_modules/websocket-extensions": {
+    "websocket-extensions": {
       "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/websocket-extensions/-/websocket-extensions-0.1.4.tgz",
-      "integrity": "sha512-OqedPIGOfsDlo31UNwYbCFMSaO9m9G/0faIHj5/dZFDMFqPTcx6UwqyOy3COEaEOg/9VsGIpdqn62W5KhoKSpg==",
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=0.8.0"
-      }
+      "resolved": "https://registry.facebook.net/websocket-extensions/-/websocket-extensions-0.1.4.tgz",
+      "integrity": "sha512-OqedPIGOfsDlo31UNwYbCFMSaO9m9G/0faIHj5/dZFDMFqPTcx6UwqyOy3COEaEOg/9VsGIpdqn62W5KhoKSpg=="
     },
-    "node_modules/which": {
+    "which": {
       "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "resolved": "https://registry.facebook.net/which/-/which-2.0.2.tgz",
       "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
-      "license": "ISC",
-      "dependencies": {
+      "requires": {
         "isexe": "^2.0.0"
-      },
-      "bin": {
-        "node-which": "bin/node-which"
-      },
-      "engines": {
-        "node": ">= 8"
       }
     },
-    "node_modules/widest-line": {
+    "widest-line": {
       "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/widest-line/-/widest-line-4.0.1.tgz",
+      "resolved": "https://registry.facebook.net/widest-line/-/widest-line-4.0.1.tgz",
       "integrity": "sha512-o0cyEG0e8GPzT4iGHphIOh0cJOV8fivsXxddQasHPHfoZf1ZexrfeA21w2NaEN1RHE+fXlfISmOE8R9N3u3Qig==",
-      "license": "MIT",
-      "dependencies": {
+      "requires": {
         "string-width": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/wildcard": {
+    "wildcard": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/wildcard/-/wildcard-2.0.1.tgz",
-      "integrity": "sha512-CC1bOL87PIWSBhDcTrdeLo6eGT7mCFtrg0uIJtqJUFyK+eJnzl8A1niH56uu7KMa5XFrtiV+AQuHO3n7DsHnLQ==",
-      "license": "MIT"
+      "resolved": "https://registry.facebook.net/wildcard/-/wildcard-2.0.1.tgz",
+      "integrity": "sha512-CC1bOL87PIWSBhDcTrdeLo6eGT7mCFtrg0uIJtqJUFyK+eJnzl8A1niH56uu7KMa5XFrtiV+AQuHO3n7DsHnLQ=="
     },
-    "node_modules/wrap-ansi": {
+    "wrap-ansi": {
       "version": "8.1.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz",
+      "resolved": "https://registry.facebook.net/wrap-ansi/-/wrap-ansi-8.1.0.tgz",
       "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==",
-      "license": "MIT",
-      "dependencies": {
+      "requires": {
         "ansi-styles": "^6.1.0",
         "string-width": "^5.0.1",
         "strip-ansi": "^7.0.1"
       },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
-      }
-    },
-    "node_modules/wrap-ansi/node_modules/ansi-regex": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz",
-      "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
-      }
-    },
-    "node_modules/wrap-ansi/node_modules/ansi-styles": {
-      "version": "6.2.1",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz",
-      "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/wrap-ansi/node_modules/strip-ansi": {
-      "version": "7.1.0",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz",
-      "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==",
-      "license": "MIT",
       "dependencies": {
-        "ansi-regex": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
+        "ansi-regex": {
+          "version": "6.2.2",
+          "resolved": "https://registry.facebook.net/ansi-regex/-/ansi-regex-6.2.2.tgz",
+          "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg=="
+        },
+        "ansi-styles": {
+          "version": "6.2.3",
+          "resolved": "https://registry.facebook.net/ansi-styles/-/ansi-styles-6.2.3.tgz",
+          "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg=="
+        },
+        "strip-ansi": {
+          "version": "7.2.0",
+          "resolved": "https://registry.facebook.net/strip-ansi/-/strip-ansi-7.2.0.tgz",
+          "integrity": "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==",
+          "requires": {
+            "ansi-regex": "^6.2.2"
+          }
+        }
       }
     },
-    "node_modules/wrappy": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
-      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
-      "license": "ISC"
-    },
-    "node_modules/write-file-atomic": {
+    "write-file-atomic": {
       "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-3.0.3.tgz",
+      "resolved": "https://registry.facebook.net/write-file-atomic/-/write-file-atomic-3.0.3.tgz",
       "integrity": "sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q==",
-      "license": "ISC",
-      "dependencies": {
+      "requires": {
         "imurmurhash": "^0.1.4",
         "is-typedarray": "^1.0.0",
         "signal-exit": "^3.0.2",
         "typedarray-to-buffer": "^3.1.5"
       }
     },
-    "node_modules/ws": {
+    "ws": {
       "version": "7.5.10",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-7.5.10.tgz",
+      "resolved": "https://registry.facebook.net/ws/-/ws-7.5.10.tgz",
       "integrity": "sha512-+dbF1tHwZpXcbOJdVOkzLDxZP1ailvSxM6ZweXTegylPny803bFhA+vqBYw4s31NSAk4S2Qz+AKXK9a4wkdjcQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8.3.0"
-      },
-      "peerDependencies": {
-        "bufferutil": "^4.0.1",
-        "utf-8-validate": "^5.0.2"
-      },
-      "peerDependenciesMeta": {
-        "bufferutil": {
-          "optional": true
-        },
-        "utf-8-validate": {
-          "optional": true
+      "requires": {}
+    },
+    "wsl-utils": {
+      "version": "0.1.0",
+      "resolved": "https://registry.facebook.net/wsl-utils/-/wsl-utils-0.1.0.tgz",
+      "integrity": "sha512-h3Fbisa2nKGPxCpm89Hk33lBLsnaGBvctQopaBSOW/uIs6FTe1ATyAnKFJrzVs9vpGdsTe73WF3V4lIsk4Gacw==",
+      "requires": {
+        "is-wsl": "^3.1.0"
+      },
+      "dependencies": {
+        "is-wsl": {
+          "version": "3.1.1",
+          "resolved": "https://registry.facebook.net/is-wsl/-/is-wsl-3.1.1.tgz",
+          "integrity": "sha512-e6rvdUCiQCAuumZslxRJWR/Doq4VpPR82kqclvcS0efgt430SlGIk05vdCN58+VrzgtIcfNODjozVielycD4Sw==",
+          "requires": {
+            "is-inside-container": "^1.0.0"
+          }
         }
       }
     },
-    "node_modules/xdg-basedir": {
+    "xdg-basedir": {
       "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/xdg-basedir/-/xdg-basedir-5.1.0.tgz",
-      "integrity": "sha512-GCPAHLvrIH13+c0SuacwvRYj2SxJXQ4kaVTT5xgL3kPrz56XxkF21IGhjSE1+W0aw7gpBWRGXLCPnPby6lSpmQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
+      "resolved": "https://registry.facebook.net/xdg-basedir/-/xdg-basedir-5.1.0.tgz",
+      "integrity": "sha512-GCPAHLvrIH13+c0SuacwvRYj2SxJXQ4kaVTT5xgL3kPrz56XxkF21IGhjSE1+W0aw7gpBWRGXLCPnPby6lSpmQ=="
     },
-    "node_modules/xml-js": {
+    "xml-js": {
       "version": "1.6.11",
-      "resolved": "https://registry.npmjs.org/xml-js/-/xml-js-1.6.11.tgz",
+      "resolved": "https://registry.facebook.net/xml-js/-/xml-js-1.6.11.tgz",
       "integrity": "sha512-7rVi2KMfwfWFl+GpPg6m80IVMWXLRjO+PxTq7V2CDhoGak0wzYzFgUY2m4XJ47OGdXd8eLE8EmwfAmdjw7lC1g==",
-      "license": "MIT",
-      "dependencies": {
+      "requires": {
         "sax": "^1.2.4"
-      },
-      "bin": {
-        "xml-js": "bin/cli.js"
       }
     },
-    "node_modules/yallist": {
+    "yallist": {
       "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
-      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
-      "license": "ISC"
-    },
-    "node_modules/yaml": {
-      "version": "1.10.2",
-      "resolved": "https://registry.npmjs.org/yaml/-/yaml-1.10.2.tgz",
-      "integrity": "sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==",
-      "license": "ISC",
-      "engines": {
-        "node": ">= 6"
-      }
+      "resolved": "https://registry.facebook.net/yallist/-/yallist-3.1.1.tgz",
+      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g=="
     },
-    "node_modules/yocto-queue": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-1.1.1.tgz",
-      "integrity": "sha512-b4JR1PFR10y1mKjhHY9LaGo6tmrgjit7hxVIeAmyMw3jegXR4dhYqLaQF5zMXZxY7tLpMyJeLjr1C4rLmkVe8g==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=12.20"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
+    "yocto-queue": {
+      "version": "1.2.2",
+      "resolved": "https://registry.facebook.net/yocto-queue/-/yocto-queue-1.2.2.tgz",
+      "integrity": "sha512-4LCcse/U2MHZ63HAJVE+v71o7yOdIe4cZ70Wpf8D/IyjDKYQLV5GD46B+hSTjJsvV5PztjvHoU580EftxjDZFQ=="
     },
-    "node_modules/zwitch": {
+    "zwitch": {
       "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz",
-      "integrity": "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==",
-      "license": "MIT",
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/wooorm"
-      }
+      "resolved": "https://registry.facebook.net/zwitch/-/zwitch-2.0.4.tgz",
+      "integrity": "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A=="
     }
   }
 }
diff --git a/website/package.json b/website/package.json
index 99f488fdb8e..05319a5afc9 100644
--- a/website/package.json
+++ b/website/package.json
@@ -14,9 +14,9 @@
     "write-heading-ids": "docusaurus write-heading-ids"
   },
   "dependencies": {
-    "@docusaurus/core": "3.6.3",
-    "@docusaurus/plugin-google-gtag": "^3.6.3",
-    "@docusaurus/preset-classic": "3.6.3",
+    "@docusaurus/core": "3.10.0",
+    "@docusaurus/plugin-google-gtag": "3.10.0",
+    "@docusaurus/preset-classic": "3.10.0",
     "@mdx-js/react": "^3.1.0",
     "axios": "^1.7.9",
     "clsx": "^2.1.1",
@@ -25,7 +25,10 @@
     "react-dom": "^18.3.1"
   },
   "devDependencies": {
-    "@docusaurus/module-type-aliases": "3.6.3"
+    "@docusaurus/module-type-aliases": "3.10.0"
+  },
+  "resolutions": {
+    "webpackbar": "^7.0.0"
   },
   "browserslist": {
     "production": [
diff --git a/website/src/components/VeloxConBanner/index.js b/website/src/components/VeloxConBanner/index.js
index 78dce089f33..5ccb7374a28 100644
--- a/website/src/components/VeloxConBanner/index.js
+++ b/website/src/components/VeloxConBanner/index.js
@@ -1,27 +1,25 @@
 import React from 'react';
-import clsx from 'clsx';
 import styles from './styles.module.css';
-import useBaseUrl from "@docusaurus/useBaseUrl";
+import Link from '@docusaurus/Link';
 
 export default function VeloxConBanner() {
   return (
-    <section className={styles.banner}>
-      <div className="container">
-        <div className="row">
-          <div className="col col--9">
-            <h2>VeloxCon 2025 Sessions Are Now Available On-Demand</h2>
-          </div>
-          <div className="col col--3">
-            <a
-              className="button button--info button--lg"
-              href="https://www.youtube.com/playlist?list=PLJvBe8nQAEsE0dT7XVIrD8QE-gmuX3Fe6"
-              target="_blank"
-              rel="noopener noreferrer"
-            >
-              Watch Now
-            </a>
-          </div>
+    <section className={styles.banner} role="region" aria-label="VeloxCon announcement">
+      <div className={styles.container}>
+        <div className={styles.text}>
+          <h2 className={styles.title}>Announcing VeloxCon 2026</h2>
+          <p className={styles.subtitle}>Meta HQ, Bay Area</p>
+          <p className={styles.date}>April 29–30, 2026</p>
         </div>
+
+        <Link
+          className={styles.button}
+          to="https://veloxcon.io/"
+          target="_blank"
+          rel="noopener noreferrer"
+        >
+          Register Now →
+        </Link>
       </div>
     </section>
   );
diff --git a/website/src/components/VeloxConBanner/styles.module.css b/website/src/components/VeloxConBanner/styles.module.css
index f670fe2fc7d..17a543a2ca3 100644
--- a/website/src/components/VeloxConBanner/styles.module.css
+++ b/website/src/components/VeloxConBanner/styles.module.css
@@ -1,20 +1,76 @@
 .banner {
+  position: relative;
+  overflow: hidden;
+  color: #ffffff;
+  padding: 24px 16px;
+  border-top: 1px solid rgba(255,255,255,0.08);
+  border-bottom: 1px solid rgba(0,0,0,0.12);
+
+  background:
+    radial-gradient(circle at 20% 30%, rgba(76,201,240,0.22), transparent 35%),
+    radial-gradient(circle at 80% 20%, rgba(67,97,238,0.20), transparent 35%),
+    linear-gradient(135deg, #0b1426 0%, #10203f 55%, #132a52 100%);
+}
+
+.banner::before {
+  content: "";
+  position: absolute;
+  inset: 0;
+  background-image:
+    linear-gradient(rgba(255,255,255,0.05) 1px, transparent 1px),
+    linear-gradient(90deg, rgba(255,255,255,0.05) 1px, transparent 1px);
+  background-size: 28px 28px;
+  opacity: 0.45;
+  pointer-events: none;
+}
+
+.container {
+  position: relative;
+  z-index: 1;
+  max-width: 900px;
+  margin: 0 auto;
   display: flex;
+  flex-direction: column;
   align-items: center;
-  padding: 1rem 0;
-  width: 100%;
-  background: url("/static/img/banner-pattern.svg") center center #143d99;
-  color: #fff;
+  text-align: center;
 }
 
-.banner >div>div {
-  max-width: 600px;
-  justify-content: space-around;
-  align-items: center;
-  margin: 0 auto;
-  text-align:center;
+.text {
+  text-align: center;
+  margin-bottom: 10px;
+}
+
+.title {
+  font-size: 1.7rem;
+  font-weight: 700;
+  margin: 0;
+  line-height: 1.2;
+}
+
+.subtitle {
+  font-size: 1rem;
+  margin: 4px 0 0;
+  opacity: 0.95;
+}
+
+.date {
+  font-size: 0.95rem;
+  margin: 2px 0 14px;
+  opacity: 0.8;
+}
+
+.button {
+  display: inline-block;
+  background: linear-gradient(135deg,#6ee7ff,#60a5fa);
+  color: #081220;
+  padding: 8px 18px;
+  border-radius: 999px;
+  font-weight: 700;
+  text-decoration: none;
+  transition: transform 0.15s ease, box-shadow 0.15s ease;
 }
 
-.banner h2, .banner p {
-  margin-bottom: 5px;
+.button:hover {
+  transform: translateY(-1px);
+  box-shadow: 0 8px 20px rgba(96,165,250,0.35);
 }
diff --git a/website/src/pages/index.js b/website/src/pages/index.js
index c97d5d25c6b..3beabc10cd0 100644
--- a/website/src/pages/index.js
+++ b/website/src/pages/index.js
@@ -239,6 +239,83 @@ function LatestCommunityNews() {
 
           <div className={styles.tileScroll} ref={scrollRef}>
             {/* Each tile is boxed */}
+            <a href="https://veloxcon.io/" className={styles.newsTile} target="_blank" rel="noopener">
+  <span className={styles.newsTag}>Event</span>
+  <h3>VeloxCon 2026</h3>
+  <p>Join us at Meta HQ in the Bay Area, April 29-30 for in-person VeloxCon.</p>
+  <span className={styles.newsDate}>April 2026</span>
+</a>
+
+            <a href="https://velox-lib.io/blog/regex-hidden-traps" className={styles.newsTile} target="_blank" rel="noopener">
+  <span className={styles.newsTag}>Blog</span>
+  <h3>The hidden traps of regex in LIKE and split</h3>
+  <p>Both LIKE and Spark's split can silently produce wrong results when used with column values instead of constants.</p>
+  <span className={styles.newsDate}>March 2026</span>
+</a>
+
+            <a href="https://velox-lib.io/blog/stringview-api-changes/" className={styles.newsTile} target="_blank" rel="noopener">
+  <span className={styles.newsTag}>Blog</span>
+  <h3>velox::StringView API Changes and Best Practices</h3>
+  <p>This post describes in more detail how Velox handles columns of strings.</p>
+  <span className={styles.newsDate}>February 2026</span>
+</a>
+
+<a href="https://velox-lib.io/blog/task-barrier/" className={styles.newsTile} target="_blank" rel="noopener">
+  <span className={styles.newsTag}>Blog</span>
+  <h3>Task Barrier: Efficient Task Reuse and Streaming Checkpoints in Velox</h3>
+  <p>How Velox Task Barriers provide a synchronization mechanism.</p>
+  <span className={styles.newsDate}>January 2026</span>
+</a>
+
+<a href="https://velox-lib.io/blog/why-row-based-sort/" className={styles.newsTile} target="_blank" rel="noopener">
+  <span className={styles.newsTag}>Blog</span>
+  <h3>Why Sort is row-based in Velox — A Quantitative Assessment</h3>
+  <p>Rationale behind this design decision and provide experimental evidence for its implementation.</p>
+  <span className={styles.newsDate}>December 2025</span>
+</a>
+
+<a href="https://veloxcon.io/veloxcon-china/" className={styles.newsTile} target="_blank" rel="noopener">
+  <span className={styles.newsTag}>Event</span>
+  <h3>VeloxCon China 2025</h3>
+  <p>Join us in Beijing on December 13 for our first community event in China.</p>
+  <span className={styles.newsDate}>December 2025</span>
+</a>
+
+<a href="https://velox-lib.io/blog/multi-round-local-merge" className={styles.newsTile} target="_blank" rel="noopener">
+  <span className={styles.newsTag}>Blog</span>
+  <h3>Multi-Round Lazy Start Merge</h3>
+  <p>The latest Velox update introduces a multi-round spill merge with lazy-start activation.</p>
+  <span className={styles.newsDate}>November 2025</span>
+</a>
+
+<a href="https://velox-lib.io/blog/shared-build" className={styles.newsTile} target="_blank" rel="noopener">
+  <span className={styles.newsTag}>Blog</span>
+  <h3>Enabling Shared Library Builds in Velox</h3>
+  <p>Learn how we unblocked shared library builds in Velox.</p>
+  <span className={styles.newsDate}>November 2025</span>
+</a>
+
+<a href="https://velox-lib.io/blog/cpp20-standard" className={styles.newsTile} target="_blank" rel="noopener">
+  <span className={styles.newsTag}>Blog</span>
+  <h3>Velox switches to C++20 standard</h3>
+  <p>Going forward Velox is looking to enhance the codebase by making use of newer compiler functionalities.</p>
+  <span className={styles.newsDate}>August 2025</span>
+</a>
+
+<a href="https://velox-lib.io/blog/extending-velox-with-cudf" className={styles.newsTile} target="_blank" rel="noopener">
+  <span className={styles.newsTag}>Blog</span>
+  <h3>Extending Velox – GPU Acceleration with cuDF</h3>
+  <p>This post describes the design principles and software components for extending Velox with hardware acceleration using NVIDIA's cuDF.</p>
+  <span className={styles.newsDate}>July 2025</span>
+</a>
+
+<a href="https://velox-lib.io/blog/segfault-dependency-update" className={styles.newsTile} target="_blank" rel="noopener">
+  <span className={styles.newsTag}>Blog</span>
+  <h3>SEGFAULT due to Dependency Update</h3>
+  <p>How upgrading Folly and Facebook Thrift revealed a surprising issue with coroutine compile flags and vtable structures.</p>
+  <span className={styles.newsDate}>July 2025</span>
+</a>
+
             <a href="https://velox-lib.io/blog/velox-primer-part-3" className={styles.newsTile} target="_blank" rel="noopener">
               <span className={styles.newsTag}>Blog</span>
               <h3>Velox Primer: Part 3</h3>
diff --git a/website/static/img/axiom-architecture.png b/website/static/img/axiom-architecture.png
new file mode 100644
index 00000000000..a3d9479ce30
Binary files /dev/null and b/website/static/img/axiom-architecture.png differ
diff --git a/website/static/img/axiom-split-architectures.png b/website/static/img/axiom-split-architectures.png
new file mode 100644
index 00000000000..600d80194d3
Binary files /dev/null and b/website/static/img/axiom-split-architectures.png differ
diff --git a/website/static/img/bm-report.png b/website/static/img/bm-report.png
new file mode 100644
index 00000000000..4e493cf4db0
Binary files /dev/null and b/website/static/img/bm-report.png differ
diff --git a/website/static/img/column-sort.png b/website/static/img/column-sort.png
new file mode 100644
index 00000000000..36a047854dd
Binary files /dev/null and b/website/static/img/column-sort.png differ
diff --git a/website/static/img/columnar-mem.png b/website/static/img/columnar-mem.png
new file mode 100644
index 00000000000..05044b89ec2
Binary files /dev/null and b/website/static/img/columnar-mem.png differ
diff --git a/website/static/img/flatmapvector-flatmap-map-layout.png b/website/static/img/flatmapvector-flatmap-map-layout.png
new file mode 100644
index 00000000000..ceb202bcc90
Binary files /dev/null and b/website/static/img/flatmapvector-flatmap-map-layout.png differ
diff --git a/website/static/img/flatmapvector-tradtional-map-layout.png b/website/static/img/flatmapvector-tradtional-map-layout.png
new file mode 100644
index 00000000000..e7692cb4117
Binary files /dev/null and b/website/static/img/flatmapvector-tradtional-map-layout.png differ
diff --git a/website/static/img/merge.png b/website/static/img/merge.png
new file mode 100644
index 00000000000..3c075138a37
Binary files /dev/null and b/website/static/img/merge.png differ
diff --git a/website/static/img/nimble-cluster-index-architecture.png b/website/static/img/nimble-cluster-index-architecture.png
new file mode 100644
index 00000000000..71a51dcaad0
Binary files /dev/null and b/website/static/img/nimble-cluster-index-architecture.png differ
diff --git a/website/static/img/nimble-cluster-index-file-layout.png b/website/static/img/nimble-cluster-index-file-layout.png
new file mode 100644
index 00000000000..aa2ab9e5e56
Binary files /dev/null and b/website/static/img/nimble-cluster-index-file-layout.png differ
diff --git a/website/static/img/row-mem.png b/website/static/img/row-mem.png
new file mode 100644
index 00000000000..06e2c2e4ed8
Binary files /dev/null and b/website/static/img/row-mem.png differ
diff --git a/website/static/img/row-sort.png b/website/static/img/row-sort.png
new file mode 100644
index 00000000000..b50410109e6
Binary files /dev/null and b/website/static/img/row-sort.png differ
diff --git a/website/static/img/spill.merge.png b/website/static/img/spill.merge.png
new file mode 100644
index 00000000000..d8e74cc7702
Binary files /dev/null and b/website/static/img/spill.merge.png differ
diff --git a/website/yarn.lock b/website/yarn.lock
index f5ee9d96a08..4e829c44a45 100644
--- a/website/yarn.lock
+++ b/website/yarn.lock
@@ -2,1097 +2,1007 @@
 # yarn lockfile v1
 
 
-"@algolia/autocomplete-core@1.17.7":
-  version "1.17.7"
-  resolved "https://registry.npmjs.org/@algolia/autocomplete-core/-/autocomplete-core-1.17.7.tgz"
-  integrity sha512-BjiPOW6ks90UKl7TwMv7oNQMnzU+t/wk9mgIDi6b1tXpUek7MW0lbNOUHpvam9pe3lVCf4xPFT+lK7s+e+fs7Q==
-  dependencies:
-    "@algolia/autocomplete-plugin-algolia-insights" "1.17.7"
-    "@algolia/autocomplete-shared" "1.17.7"
-
-"@algolia/autocomplete-plugin-algolia-insights@1.17.7":
-  version "1.17.7"
-  resolved "https://registry.npmjs.org/@algolia/autocomplete-plugin-algolia-insights/-/autocomplete-plugin-algolia-insights-1.17.7.tgz"
-  integrity sha512-Jca5Ude6yUOuyzjnz57og7Et3aXjbwCSDf/8onLHSQgw1qW3ALl9mrMWaXb5FmPVkV3EtkD2F/+NkT6VHyPu9A==
-  dependencies:
-    "@algolia/autocomplete-shared" "1.17.7"
-
-"@algolia/autocomplete-preset-algolia@1.17.7":
-  version "1.17.7"
-  resolved "https://registry.npmjs.org/@algolia/autocomplete-preset-algolia/-/autocomplete-preset-algolia-1.17.7.tgz"
-  integrity sha512-ggOQ950+nwbWROq2MOCIL71RE0DdQZsceqrg32UqnhDz8FlO9rL8ONHNsI2R1MH0tkgVIDKI/D0sMiUchsFdWA==
-  dependencies:
-    "@algolia/autocomplete-shared" "1.17.7"
-
-"@algolia/autocomplete-shared@1.17.7":
-  version "1.17.7"
-  resolved "https://registry.npmjs.org/@algolia/autocomplete-shared/-/autocomplete-shared-1.17.7.tgz"
-  integrity sha512-o/1Vurr42U/qskRSuhBH+VKxMvkkUVTLU6WZQr+L5lGZZLYWyhdzWjW0iGXY7EkwRTjBqvN2EsR81yCTGV/kmg==
-
-"@algolia/cache-browser-local-storage@4.24.0":
-  version "4.24.0"
-  resolved "https://registry.npmjs.org/@algolia/cache-browser-local-storage/-/cache-browser-local-storage-4.24.0.tgz"
-  integrity sha512-t63W9BnoXVrGy9iYHBgObNXqYXM3tYXCjDSHeNwnsc324r4o5UiVKUiAB4THQ5z9U5hTj6qUvwg/Ez43ZD85ww==
-  dependencies:
-    "@algolia/cache-common" "4.24.0"
-
-"@algolia/cache-common@4.24.0":
-  version "4.24.0"
-  resolved "https://registry.npmjs.org/@algolia/cache-common/-/cache-common-4.24.0.tgz"
-  integrity sha512-emi+v+DmVLpMGhp0V9q9h5CdkURsNmFC+cOS6uK9ndeJm9J4TiqSvPYVu+THUP8P/S08rxf5x2P+p3CfID0Y4g==
-
-"@algolia/cache-in-memory@4.24.0":
-  version "4.24.0"
-  resolved "https://registry.npmjs.org/@algolia/cache-in-memory/-/cache-in-memory-4.24.0.tgz"
-  integrity sha512-gDrt2so19jW26jY3/MkFg5mEypFIPbPoXsQGQWAi6TrCPsNOSEYepBMPlucqWigsmEy/prp5ug2jy/N3PVG/8w==
-  dependencies:
-    "@algolia/cache-common" "4.24.0"
-
-"@algolia/client-abtesting@5.18.0":
-  version "5.18.0"
-  resolved "https://registry.npmjs.org/@algolia/client-abtesting/-/client-abtesting-5.18.0.tgz"
-  integrity sha512-DLIrAukjsSrdMNNDx1ZTks72o4RH/1kOn8Wx5zZm8nnqFexG+JzY4SANnCNEjnFQPJTTvC+KpgiNW/CP2lumng==
-  dependencies:
-    "@algolia/client-common" "5.18.0"
-    "@algolia/requester-browser-xhr" "5.18.0"
-    "@algolia/requester-fetch" "5.18.0"
-    "@algolia/requester-node-http" "5.18.0"
-
-"@algolia/client-account@4.24.0":
-  version "4.24.0"
-  resolved "https://registry.npmjs.org/@algolia/client-account/-/client-account-4.24.0.tgz"
-  integrity sha512-adcvyJ3KjPZFDybxlqnf+5KgxJtBjwTPTeyG2aOyoJvx0Y8dUQAEOEVOJ/GBxX0WWNbmaSrhDURMhc+QeevDsA==
-  dependencies:
-    "@algolia/client-common" "4.24.0"
-    "@algolia/client-search" "4.24.0"
-    "@algolia/transporter" "4.24.0"
-
-"@algolia/client-analytics@4.24.0":
-  version "4.24.0"
-  resolved "https://registry.npmjs.org/@algolia/client-analytics/-/client-analytics-4.24.0.tgz"
-  integrity sha512-y8jOZt1OjwWU4N2qr8G4AxXAzaa8DBvyHTWlHzX/7Me1LX8OayfgHexqrsL4vSBcoMmVw2XnVW9MhL+Y2ZDJXg==
-  dependencies:
-    "@algolia/client-common" "4.24.0"
-    "@algolia/client-search" "4.24.0"
-    "@algolia/requester-common" "4.24.0"
-    "@algolia/transporter" "4.24.0"
-
-"@algolia/client-analytics@5.18.0":
-  version "5.18.0"
-  resolved "https://registry.npmjs.org/@algolia/client-analytics/-/client-analytics-5.18.0.tgz"
-  integrity sha512-0VpGG2uQW+h2aejxbG8VbnMCQ9ary9/ot7OASXi6OjE0SRkYQ/+pkW+q09+IScif3pmsVVYggmlMPtAsmYWHng==
-  dependencies:
-    "@algolia/client-common" "5.18.0"
-    "@algolia/requester-browser-xhr" "5.18.0"
-    "@algolia/requester-fetch" "5.18.0"
-    "@algolia/requester-node-http" "5.18.0"
-
-"@algolia/client-common@4.24.0":
-  version "4.24.0"
-  resolved "https://registry.npmjs.org/@algolia/client-common/-/client-common-4.24.0.tgz"
-  integrity sha512-bc2ROsNL6w6rqpl5jj/UywlIYC21TwSSoFHKl01lYirGMW+9Eek6r02Tocg4gZ8HAw3iBvu6XQiM3BEbmEMoiA==
-  dependencies:
-    "@algolia/requester-common" "4.24.0"
-    "@algolia/transporter" "4.24.0"
-
-"@algolia/client-common@5.18.0":
-  version "5.18.0"
-  resolved "https://registry.npmjs.org/@algolia/client-common/-/client-common-5.18.0.tgz"
-  integrity sha512-X1WMSC+1ve2qlMsemyTF5bIjwipOT+m99Ng1Tyl36ZjQKTa54oajBKE0BrmM8LD8jGdtukAgkUhFoYOaRbMcmQ==
-
-"@algolia/client-insights@5.18.0":
-  version "5.18.0"
-  resolved "https://registry.npmjs.org/@algolia/client-insights/-/client-insights-5.18.0.tgz"
-  integrity sha512-FAJRNANUOSs/FgYOJ/Njqp+YTe4TMz2GkeZtfsw1TMiA5mVNRS/nnMpxas9771aJz7KTEWvK9GwqPs0K6RMYWg==
-  dependencies:
-    "@algolia/client-common" "5.18.0"
-    "@algolia/requester-browser-xhr" "5.18.0"
-    "@algolia/requester-fetch" "5.18.0"
-    "@algolia/requester-node-http" "5.18.0"
-
-"@algolia/client-personalization@4.24.0":
-  version "4.24.0"
-  resolved "https://registry.npmjs.org/@algolia/client-personalization/-/client-personalization-4.24.0.tgz"
-  integrity sha512-l5FRFm/yngztweU0HdUzz1rC4yoWCFo3IF+dVIVTfEPg906eZg5BOd1k0K6rZx5JzyyoP4LdmOikfkfGsKVE9w==
-  dependencies:
-    "@algolia/client-common" "4.24.0"
-    "@algolia/requester-common" "4.24.0"
-    "@algolia/transporter" "4.24.0"
-
-"@algolia/client-personalization@5.18.0":
-  version "5.18.0"
-  resolved "https://registry.npmjs.org/@algolia/client-personalization/-/client-personalization-5.18.0.tgz"
-  integrity sha512-I2dc94Oiwic3SEbrRp8kvTZtYpJjGtg5y5XnqubgnA15AgX59YIY8frKsFG8SOH1n2rIhUClcuDkxYQNXJLg+w==
-  dependencies:
-    "@algolia/client-common" "5.18.0"
-    "@algolia/requester-browser-xhr" "5.18.0"
-    "@algolia/requester-fetch" "5.18.0"
-    "@algolia/requester-node-http" "5.18.0"
-
-"@algolia/client-query-suggestions@5.18.0":
-  version "5.18.0"
-  resolved "https://registry.npmjs.org/@algolia/client-query-suggestions/-/client-query-suggestions-5.18.0.tgz"
-  integrity sha512-x6XKIQgKFTgK/bMasXhghoEjHhmgoP61pFPb9+TaUJ32aKOGc65b12usiGJ9A84yS73UDkXS452NjyP50Knh/g==
-  dependencies:
-    "@algolia/client-common" "5.18.0"
-    "@algolia/requester-browser-xhr" "5.18.0"
-    "@algolia/requester-fetch" "5.18.0"
-    "@algolia/requester-node-http" "5.18.0"
-
-"@algolia/client-search@4.24.0":
-  version "4.24.0"
-  resolved "https://registry.npmjs.org/@algolia/client-search/-/client-search-4.24.0.tgz"
-  integrity sha512-uRW6EpNapmLAD0mW47OXqTP8eiIx5F6qN9/x/7HHO6owL3N1IXqydGwW5nhDFBrV+ldouro2W1VX3XlcUXEFCA==
-  dependencies:
-    "@algolia/client-common" "4.24.0"
-    "@algolia/requester-common" "4.24.0"
-    "@algolia/transporter" "4.24.0"
-
-"@algolia/client-search@5.18.0":
-  version "5.18.0"
-  resolved "https://registry.npmjs.org/@algolia/client-search/-/client-search-5.18.0.tgz"
-  integrity sha512-qI3LcFsVgtvpsBGR7aNSJYxhsR+Zl46+958ODzg8aCxIcdxiK7QEVLMJMZAR57jGqW0Lg/vrjtuLFDMfSE53qA==
-  dependencies:
-    "@algolia/client-common" "5.18.0"
-    "@algolia/requester-browser-xhr" "5.18.0"
-    "@algolia/requester-fetch" "5.18.0"
-    "@algolia/requester-node-http" "5.18.0"
+"@algolia/abtesting@1.17.0":
+  version "1.17.0"
+  resolved "https://registry.yarnpkg.com/@algolia/abtesting/-/abtesting-1.17.0.tgz"
+  integrity sha512-nuhHZdTiCtRzJEe9VSNzyqE9cOQMt01UWBzymFnjbgwrxxZpbGHQde6Oa/y9zyspTCjbUtb7Q5HQek1CLiLyeg==
+  dependencies:
+    "@algolia/client-common" "5.51.0"
+    "@algolia/requester-browser-xhr" "5.51.0"
+    "@algolia/requester-fetch" "5.51.0"
+    "@algolia/requester-node-http" "5.51.0"
+
+"@algolia/autocomplete-core@1.19.2":
+  version "1.19.2"
+  resolved "https://registry.yarnpkg.com/@algolia/autocomplete-core/-/autocomplete-core-1.19.2.tgz"
+  integrity sha512-mKv7RyuAzXvwmq+0XRK8HqZXt9iZ5Kkm2huLjgn5JoCPtDy+oh9yxUMfDDaVCw0oyzZ1isdJBc7l9nuCyyR7Nw==
+  dependencies:
+    "@algolia/autocomplete-plugin-algolia-insights" "1.19.2"
+    "@algolia/autocomplete-shared" "1.19.2"
+
+"@algolia/autocomplete-core@^1.19.2":
+  version "1.19.8"
+  resolved "https://registry.yarnpkg.com/@algolia/autocomplete-core/-/autocomplete-core-1.19.8.tgz"
+  integrity sha512-3YEorYg44niXcm7gkft3nXYItHd44e8tmh4D33CTszPgP0QWkaLEaFywiNyJBo7UL/mqObA/G9RYuU7R8tN1IA==
+  dependencies:
+    "@algolia/autocomplete-plugin-algolia-insights" "1.19.8"
+    "@algolia/autocomplete-shared" "1.19.8"
+
+"@algolia/autocomplete-plugin-algolia-insights@1.19.2":
+  version "1.19.2"
+  resolved "https://registry.yarnpkg.com/@algolia/autocomplete-plugin-algolia-insights/-/autocomplete-plugin-algolia-insights-1.19.2.tgz"
+  integrity sha512-TjxbcC/r4vwmnZaPwrHtkXNeqvlpdyR+oR9Wi2XyfORkiGkLTVhX2j+O9SaCCINbKoDfc+c2PB8NjfOnz7+oKg==
+  dependencies:
+    "@algolia/autocomplete-shared" "1.19.2"
+
+"@algolia/autocomplete-plugin-algolia-insights@1.19.8":
+  version "1.19.8"
+  resolved "https://registry.yarnpkg.com/@algolia/autocomplete-plugin-algolia-insights/-/autocomplete-plugin-algolia-insights-1.19.8.tgz"
+  integrity sha512-ZvJWO8ZZJDpc1LNM2TTBdmQsZBLMR4rU5iNR2OYvEeFBiaf/0ESnRSSLQbryarJY4SVxtoz6A2ZtDMNM+iQEAA==
+  dependencies:
+    "@algolia/autocomplete-shared" "1.19.8"
+
+"@algolia/autocomplete-shared@1.19.2":
+  version "1.19.2"
+  resolved "https://registry.yarnpkg.com/@algolia/autocomplete-shared/-/autocomplete-shared-1.19.2.tgz"
+  integrity sha512-jEazxZTVD2nLrC+wYlVHQgpBoBB5KPStrJxLzsIFl6Kqd1AlG9sIAGl39V5tECLpIQzB3Qa2T6ZPJ1ChkwMK/w==
+
+"@algolia/autocomplete-shared@1.19.8":
+  version "1.19.8"
+  resolved "https://registry.yarnpkg.com/@algolia/autocomplete-shared/-/autocomplete-shared-1.19.8.tgz"
+  integrity sha512-h5hf2t8ejF6vlOgvLaZzQbWs5SyH2z4PAWygNAvvD/2RI29hdQ54ldUGwqVuj9Srs+n8XUKTPUqb7fvhBhQrnQ==
+
+"@algolia/client-abtesting@5.51.0":
+  version "5.51.0"
+  resolved "https://registry.yarnpkg.com/@algolia/client-abtesting/-/client-abtesting-5.51.0.tgz"
+  integrity sha512-PKrKlIla1U2J7mFcIQn6N3pWP4oySmkxShnbbDsj/H7818gKbET5KsUwsVoNjWIxHKTJMCTcQ7ekAJ8Ea23NMg==
+  dependencies:
+    "@algolia/client-common" "5.51.0"
+    "@algolia/requester-browser-xhr" "5.51.0"
+    "@algolia/requester-fetch" "5.51.0"
+    "@algolia/requester-node-http" "5.51.0"
+
+"@algolia/client-analytics@5.51.0":
+  version "5.51.0"
+  resolved "https://registry.yarnpkg.com/@algolia/client-analytics/-/client-analytics-5.51.0.tgz"
+  integrity sha512-U+HCY1K16Km91pIRL1kN6bW6BbGFAF/WhkRSCx4wyl1aFpbrlhSFQs/dAwWbmyBiHWwVWhl7stWHQ1pum5EfMw==
+  dependencies:
+    "@algolia/client-common" "5.51.0"
+    "@algolia/requester-browser-xhr" "5.51.0"
+    "@algolia/requester-fetch" "5.51.0"
+    "@algolia/requester-node-http" "5.51.0"
+
+"@algolia/client-common@5.51.0":
+  version "5.51.0"
+  resolved "https://registry.yarnpkg.com/@algolia/client-common/-/client-common-5.51.0.tgz"
+  integrity sha512-YPJ3dEuZLCRp846Az94t6Z2gwSNRazP+SmBco7p6SCa4fYrtIE820PDXYZshbNrj2Z8Qfbmv7BQ1Lecl5L3G/w==
+
+"@algolia/client-insights@5.51.0":
+  version "5.51.0"
+  resolved "https://registry.yarnpkg.com/@algolia/client-insights/-/client-insights-5.51.0.tgz"
+  integrity sha512-/gEwLlR7fQ7YjOW+ADRZ0NxLDtpTC61FSzlZ01Gdl1kTJfU0Rq3Y/TYqwxGxlQGcUiXtGzrpjxXWh3Y0TZD6NA==
+  dependencies:
+    "@algolia/client-common" "5.51.0"
+    "@algolia/requester-browser-xhr" "5.51.0"
+    "@algolia/requester-fetch" "5.51.0"
+    "@algolia/requester-node-http" "5.51.0"
+
+"@algolia/client-personalization@5.51.0":
+  version "5.51.0"
+  resolved "https://registry.yarnpkg.com/@algolia/client-personalization/-/client-personalization-5.51.0.tgz"
+  integrity sha512-nRwUN1Y2cKyOAFZyIBagkEfZSIhP05nWhT4Rjwl84lcjECssYggftrAODrZ4leakXxSGjhxs/AdaAFEIBqwVFA==
+  dependencies:
+    "@algolia/client-common" "5.51.0"
+    "@algolia/requester-browser-xhr" "5.51.0"
+    "@algolia/requester-fetch" "5.51.0"
+    "@algolia/requester-node-http" "5.51.0"
+
+"@algolia/client-query-suggestions@5.51.0":
+  version "5.51.0"
+  resolved "https://registry.yarnpkg.com/@algolia/client-query-suggestions/-/client-query-suggestions-5.51.0.tgz"
+  integrity sha512-pybzYCG7VoQKppo+z5iZOKpW8XqtFxhsAIRgEaNboCnfypKukiBHJAwB+pmr7vMZXBsOHwklGYWwCG82e8qshA==
+  dependencies:
+    "@algolia/client-common" "5.51.0"
+    "@algolia/requester-browser-xhr" "5.51.0"
+    "@algolia/requester-fetch" "5.51.0"
+    "@algolia/requester-node-http" "5.51.0"
+
+"@algolia/client-search@5.51.0":
+  version "5.51.0"
+  resolved "https://registry.yarnpkg.com/@algolia/client-search/-/client-search-5.51.0.tgz"
+  integrity sha512-DWVIlj6RqcvdhwP0gBU9OpOQPnHdcAk9jlT+z8rsNb2+liWv4eUlfQZ7saGBraFsnygEHD3PtdppIHvqwBAb5w==
+  dependencies:
+    "@algolia/client-common" "5.51.0"
+    "@algolia/requester-browser-xhr" "5.51.0"
+    "@algolia/requester-fetch" "5.51.0"
+    "@algolia/requester-node-http" "5.51.0"
 
 "@algolia/events@^4.0.1":
   version "4.0.1"
-  resolved "https://registry.npmjs.org/@algolia/events/-/events-4.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/@algolia/events/-/events-4.0.1.tgz"
   integrity sha512-FQzvOCgoFXAbf5Y6mYozw2aj5KCJoA3m4heImceldzPSMbdyS4atVjJzXKMsfX3wnZTFYwkkt8/z8UesLHlSBQ==
 
-"@algolia/ingestion@1.18.0":
-  version "1.18.0"
-  resolved "https://registry.npmjs.org/@algolia/ingestion/-/ingestion-1.18.0.tgz"
-  integrity sha512-bGvJg7HnGGm+XWYMDruZXWgMDPVt4yCbBqq8DM6EoaMBK71SYC4WMfIdJaw+ABqttjBhe6aKNRkWf/bbvYOGyw==
-  dependencies:
-    "@algolia/client-common" "5.18.0"
-    "@algolia/requester-browser-xhr" "5.18.0"
-    "@algolia/requester-fetch" "5.18.0"
-    "@algolia/requester-node-http" "5.18.0"
-
-"@algolia/logger-common@4.24.0":
-  version "4.24.0"
-  resolved "https://registry.npmjs.org/@algolia/logger-common/-/logger-common-4.24.0.tgz"
-  integrity sha512-LLUNjkahj9KtKYrQhFKCzMx0BY3RnNP4FEtO+sBybCjJ73E8jNdaKJ/Dd8A/VA4imVHP5tADZ8pn5B8Ga/wTMA==
-
-"@algolia/logger-console@4.24.0":
-  version "4.24.0"
-  resolved "https://registry.npmjs.org/@algolia/logger-console/-/logger-console-4.24.0.tgz"
-  integrity sha512-X4C8IoHgHfiUROfoRCV+lzSy+LHMgkoEEU1BbKcsfnV0i0S20zyy0NLww9dwVHUWNfPPxdMU+/wKmLGYf96yTg==
-  dependencies:
-    "@algolia/logger-common" "4.24.0"
-
-"@algolia/monitoring@1.18.0":
-  version "1.18.0"
-  resolved "https://registry.npmjs.org/@algolia/monitoring/-/monitoring-1.18.0.tgz"
-  integrity sha512-lBssglINIeGIR+8KyzH05NAgAmn1BCrm5D2T6pMtr/8kbTHvvrm1Zvcltc5dKUQEFyyx3J5+MhNc7kfi8LdjVw==
-  dependencies:
-    "@algolia/client-common" "5.18.0"
-    "@algolia/requester-browser-xhr" "5.18.0"
-    "@algolia/requester-fetch" "5.18.0"
-    "@algolia/requester-node-http" "5.18.0"
-
-"@algolia/recommend@4.24.0":
-  version "4.24.0"
-  resolved "https://registry.npmjs.org/@algolia/recommend/-/recommend-4.24.0.tgz"
-  integrity sha512-P9kcgerfVBpfYHDfVZDvvdJv0lEoCvzNlOy2nykyt5bK8TyieYyiD0lguIJdRZZYGre03WIAFf14pgE+V+IBlw==
-  dependencies:
-    "@algolia/cache-browser-local-storage" "4.24.0"
-    "@algolia/cache-common" "4.24.0"
-    "@algolia/cache-in-memory" "4.24.0"
-    "@algolia/client-common" "4.24.0"
-    "@algolia/client-search" "4.24.0"
-    "@algolia/logger-common" "4.24.0"
-    "@algolia/logger-console" "4.24.0"
-    "@algolia/requester-browser-xhr" "4.24.0"
-    "@algolia/requester-common" "4.24.0"
-    "@algolia/requester-node-http" "4.24.0"
-    "@algolia/transporter" "4.24.0"
-
-"@algolia/recommend@5.18.0":
-  version "5.18.0"
-  resolved "https://registry.npmjs.org/@algolia/recommend/-/recommend-5.18.0.tgz"
-  integrity sha512-uSnkm0cdAuFwdMp4pGT5vHVQ84T6AYpTZ3I0b3k/M3wg4zXDhl3aCiY8NzokEyRLezz/kHLEEcgb/tTTobOYVw==
-  dependencies:
-    "@algolia/client-common" "5.18.0"
-    "@algolia/requester-browser-xhr" "5.18.0"
-    "@algolia/requester-fetch" "5.18.0"
-    "@algolia/requester-node-http" "5.18.0"
-
-"@algolia/requester-browser-xhr@4.24.0":
-  version "4.24.0"
-  resolved "https://registry.npmjs.org/@algolia/requester-browser-xhr/-/requester-browser-xhr-4.24.0.tgz"
-  integrity sha512-Z2NxZMb6+nVXSjF13YpjYTdvV3032YTBSGm2vnYvYPA6mMxzM3v5rsCiSspndn9rzIW4Qp1lPHBvuoKJV6jnAA==
-  dependencies:
-    "@algolia/requester-common" "4.24.0"
-
-"@algolia/requester-browser-xhr@5.18.0":
-  version "5.18.0"
-  resolved "https://registry.npmjs.org/@algolia/requester-browser-xhr/-/requester-browser-xhr-5.18.0.tgz"
-  integrity sha512-1XFjW0C3pV0dS/9zXbV44cKI+QM4ZIz9cpatXpsjRlq6SUCpLID3DZHsXyE6sTb8IhyPaUjk78GEJT8/3hviqg==
-  dependencies:
-    "@algolia/client-common" "5.18.0"
-
-"@algolia/requester-common@4.24.0":
-  version "4.24.0"
-  resolved "https://registry.npmjs.org/@algolia/requester-common/-/requester-common-4.24.0.tgz"
-  integrity sha512-k3CXJ2OVnvgE3HMwcojpvY6d9kgKMPRxs/kVohrwF5WMr2fnqojnycZkxPoEg+bXm8fi5BBfFmOqgYztRtHsQA==
-
-"@algolia/requester-fetch@5.18.0":
-  version "5.18.0"
-  resolved "https://registry.npmjs.org/@algolia/requester-fetch/-/requester-fetch-5.18.0.tgz"
-  integrity sha512-0uodeNdAHz1YbzJh6C5xeQ4T6x5WGiUxUq3GOaT/R4njh5t78dq+Rb187elr7KtnjUmETVVuCvmEYaThfTHzNg==
-  dependencies:
-    "@algolia/client-common" "5.18.0"
-
-"@algolia/requester-node-http@4.24.0":
-  version "4.24.0"
-  resolved "https://registry.npmjs.org/@algolia/requester-node-http/-/requester-node-http-4.24.0.tgz"
-  integrity sha512-JF18yTjNOVYvU/L3UosRcvbPMGT9B+/GQWNWnenIImglzNVGpyzChkXLnrSf6uxwVNO6ESGu6oN8MqcGQcjQJw==
-  dependencies:
-    "@algolia/requester-common" "4.24.0"
-
-"@algolia/requester-node-http@5.18.0":
-  version "5.18.0"
-  resolved "https://registry.npmjs.org/@algolia/requester-node-http/-/requester-node-http-5.18.0.tgz"
-  integrity sha512-tZCqDrqJ2YE2I5ukCQrYN8oiF6u3JIdCxrtKq+eniuLkjkO78TKRnXrVcKZTmfFJyyDK8q47SfDcHzAA3nHi6w==
-  dependencies:
-    "@algolia/client-common" "5.18.0"
-
-"@algolia/transporter@4.24.0":
-  version "4.24.0"
-  resolved "https://registry.npmjs.org/@algolia/transporter/-/transporter-4.24.0.tgz"
-  integrity sha512-86nI7w6NzWxd1Zp9q3413dRshDqAzSbsQjhcDhPIatEFiZrL1/TjnHL8S7jVKFePlIMzDsZWXAXwXzcok9c5oA==
-  dependencies:
-    "@algolia/cache-common" "4.24.0"
-    "@algolia/logger-common" "4.24.0"
-    "@algolia/requester-common" "4.24.0"
-
-"@ampproject/remapping@^2.2.0":
-  version "2.3.0"
-  resolved "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.3.0.tgz"
-  integrity sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==
+"@algolia/ingestion@1.51.0":
+  version "1.51.0"
+  resolved "https://registry.yarnpkg.com/@algolia/ingestion/-/ingestion-1.51.0.tgz"
+  integrity sha512-bA25s12iUDJi/X8M7tWlPRT8GeOhls/yDbdoUqinz27lNqsOlcM1UrAxIKdIZ6lm3sXit+ewPIz1pS2x6rXu8g==
   dependencies:
-    "@jridgewell/gen-mapping" "^0.3.5"
-    "@jridgewell/trace-mapping" "^0.3.24"
+    "@algolia/client-common" "5.51.0"
+    "@algolia/requester-browser-xhr" "5.51.0"
+    "@algolia/requester-fetch" "5.51.0"
+    "@algolia/requester-node-http" "5.51.0"
+
+"@algolia/monitoring@1.51.0":
+  version "1.51.0"
+  resolved "https://registry.yarnpkg.com/@algolia/monitoring/-/monitoring-1.51.0.tgz"
+  integrity sha512-zj+RcE5e0NE0/ew6oEOTgOplPHry+w2oi7h0Y87lhdq4E0d7xLS31KVB8kKfCGkrG7AYtZvrcyvLOKS5d0no4Q==
+  dependencies:
+    "@algolia/client-common" "5.51.0"
+    "@algolia/requester-browser-xhr" "5.51.0"
+    "@algolia/requester-fetch" "5.51.0"
+    "@algolia/requester-node-http" "5.51.0"
+
+"@algolia/recommend@5.51.0":
+  version "5.51.0"
+  resolved "https://registry.yarnpkg.com/@algolia/recommend/-/recommend-5.51.0.tgz"
+  integrity sha512-/HDgccfye1Rq3bPxaSCsvSEBHzSMmtpM9ZRGRtAuC62Cv+ql/76IWnxjGTDXtqIJ+/j7ZlFYAzq9fkp95wF2SQ==
+  dependencies:
+    "@algolia/client-common" "5.51.0"
+    "@algolia/requester-browser-xhr" "5.51.0"
+    "@algolia/requester-fetch" "5.51.0"
+    "@algolia/requester-node-http" "5.51.0"
+
+"@algolia/requester-browser-xhr@5.51.0":
+  version "5.51.0"
+  resolved "https://registry.yarnpkg.com/@algolia/requester-browser-xhr/-/requester-browser-xhr-5.51.0.tgz"
+  integrity sha512-nJdW+WBwGlXWMJbxxB7/AJPvNq0lLJSudXmIQCJbmH8jsOXQhRpAtoCD4ceLyJKv3ze9JbQu4Gqu5JDLckuFcw==
+  dependencies:
+    "@algolia/client-common" "5.51.0"
+
+"@algolia/requester-fetch@5.51.0":
+  version "5.51.0"
+  resolved "https://registry.yarnpkg.com/@algolia/requester-fetch/-/requester-fetch-5.51.0.tgz"
+  integrity sha512-bsBgRI/1h1mjS3eCyfGau78yGZVmiDLmT1aU6dMnk75/T0SgKqnSKNpQ53xKoDYVChGDcNnpHXWpoUSo8MH1+w==
+  dependencies:
+    "@algolia/client-common" "5.51.0"
+
+"@algolia/requester-node-http@5.51.0":
+  version "5.51.0"
+  resolved "https://registry.yarnpkg.com/@algolia/requester-node-http/-/requester-node-http-5.51.0.tgz"
+  integrity sha512-zPrIDVPpmKWgrjmWOqpqrhqAhNjvVkjoj+mqw2NBPxEOuKNzP0H+Qz5NJLLTOepBVj1UFedFaF3AUgxLsB9ukQ==
+  dependencies:
+    "@algolia/client-common" "5.51.0"
 
-"@babel/code-frame@^7.0.0", "@babel/code-frame@^7.16.0", "@babel/code-frame@^7.25.9", "@babel/code-frame@^7.26.0", "@babel/code-frame@^7.26.2", "@babel/code-frame@^7.8.3":
-  version "7.26.2"
-  resolved "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.26.2.tgz"
-  integrity sha512-RJlIHRueQgwWitWgF8OdFYGZX328Ax5BCemNGlqHfplnRT9ESi8JkFlvaVYbS+UubVY6dpv87Fs2u5M29iNFVQ==
+"@babel/code-frame@^7.0.0", "@babel/code-frame@^7.28.6", "@babel/code-frame@^7.29.0":
+  version "7.29.0"
+  resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.29.0.tgz"
+  integrity sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==
   dependencies:
-    "@babel/helper-validator-identifier" "^7.25.9"
+    "@babel/helper-validator-identifier" "^7.28.5"
     js-tokens "^4.0.0"
-    picocolors "^1.0.0"
+    picocolors "^1.1.1"
 
-"@babel/compat-data@^7.22.6", "@babel/compat-data@^7.25.9", "@babel/compat-data@^7.26.0":
-  version "7.26.3"
-  resolved "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.26.3.tgz"
-  integrity sha512-nHIxvKPniQXpmQLb0vhY3VaFb3S0YrTAwpOWJZh1wn3oJPjJk9Asva204PsBdmAE8vpzfHudT8DB0scYvy9q0g==
+"@babel/compat-data@^7.28.6", "@babel/compat-data@^7.29.0":
+  version "7.29.0"
+  resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.29.0.tgz"
+  integrity sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==
 
 "@babel/core@^7.21.3", "@babel/core@^7.25.9":
-  version "7.26.0"
-  resolved "https://registry.npmjs.org/@babel/core/-/core-7.26.0.tgz"
-  integrity sha512-i1SLeK+DzNnQ3LL/CswPCa/E5u4lh1k6IAEphON8F+cXt0t9euTshDru0q7/IqMa1PMPz5RnHuHscF8/ZJsStg==
-  dependencies:
-    "@ampproject/remapping" "^2.2.0"
-    "@babel/code-frame" "^7.26.0"
-    "@babel/generator" "^7.26.0"
-    "@babel/helper-compilation-targets" "^7.25.9"
-    "@babel/helper-module-transforms" "^7.26.0"
-    "@babel/helpers" "^7.26.0"
-    "@babel/parser" "^7.26.0"
-    "@babel/template" "^7.25.9"
-    "@babel/traverse" "^7.25.9"
-    "@babel/types" "^7.26.0"
+  version "7.29.0"
+  resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.29.0.tgz"
+  integrity sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==
+  dependencies:
+    "@babel/code-frame" "^7.29.0"
+    "@babel/generator" "^7.29.0"
+    "@babel/helper-compilation-targets" "^7.28.6"
+    "@babel/helper-module-transforms" "^7.28.6"
+    "@babel/helpers" "^7.28.6"
+    "@babel/parser" "^7.29.0"
+    "@babel/template" "^7.28.6"
+    "@babel/traverse" "^7.29.0"
+    "@babel/types" "^7.29.0"
+    "@jridgewell/remapping" "^2.3.5"
     convert-source-map "^2.0.0"
     debug "^4.1.0"
     gensync "^1.0.0-beta.2"
     json5 "^2.2.3"
     semver "^6.3.1"
 
-"@babel/generator@^7.25.9", "@babel/generator@^7.26.0", "@babel/generator@^7.26.3":
-  version "7.26.3"
-  resolved "https://registry.npmjs.org/@babel/generator/-/generator-7.26.3.tgz"
-  integrity sha512-6FF/urZvD0sTeO7k6/B15pMLC4CHUv1426lzr3N01aHJTl046uCAh9LXW/fzeXXjPNCJ6iABW5XaWOsIZB93aQ==
+"@babel/generator@^7.25.9", "@babel/generator@^7.29.0":
+  version "7.29.1"
+  resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.29.1.tgz"
+  integrity sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==
   dependencies:
-    "@babel/parser" "^7.26.3"
-    "@babel/types" "^7.26.3"
-    "@jridgewell/gen-mapping" "^0.3.5"
-    "@jridgewell/trace-mapping" "^0.3.25"
+    "@babel/parser" "^7.29.0"
+    "@babel/types" "^7.29.0"
+    "@jridgewell/gen-mapping" "^0.3.12"
+    "@jridgewell/trace-mapping" "^0.3.28"
     jsesc "^3.0.2"
 
-"@babel/helper-annotate-as-pure@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.25.9.tgz"
-  integrity sha512-gv7320KBUFJz1RnylIg5WWYPRXKZ884AGkYpgpWW02TH66Dl+HaC1t1CKd0z3R4b6hdYEcmrNZHUmfCP+1u3/g==
+"@babel/helper-annotate-as-pure@^7.27.1", "@babel/helper-annotate-as-pure@^7.27.3":
+  version "7.27.3"
+  resolved "https://registry.yarnpkg.com/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.27.3.tgz"
+  integrity sha512-fXSwMQqitTGeHLBC08Eq5yXz2m37E4pJX1qAU1+2cNedz/ifv/bVXft90VeSav5nFO61EcNgwr0aJxbyPaWBPg==
   dependencies:
-    "@babel/types" "^7.25.9"
+    "@babel/types" "^7.27.3"
 
-"@babel/helper-compilation-targets@^7.22.6", "@babel/helper-compilation-targets@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.25.9.tgz"
-  integrity sha512-j9Db8Suy6yV/VHa4qzrj9yZfZxhLWQdVnRlXxmKLYlhWUVB1sB2G5sxuWYXk/whHD9iW76PmNzxZ4UCnTQTVEQ==
+"@babel/helper-compilation-targets@^7.27.1", "@babel/helper-compilation-targets@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz"
+  integrity sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==
   dependencies:
-    "@babel/compat-data" "^7.25.9"
-    "@babel/helper-validator-option" "^7.25.9"
+    "@babel/compat-data" "^7.28.6"
+    "@babel/helper-validator-option" "^7.27.1"
     browserslist "^4.24.0"
     lru-cache "^5.1.1"
     semver "^6.3.1"
 
-"@babel/helper-create-class-features-plugin@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.25.9.tgz"
-  integrity sha512-UTZQMvt0d/rSz6KI+qdu7GQze5TIajwTS++GUozlw8VBJDEOAqSXwm1WvmYEZwqdqSGQshRocPDqrt4HBZB3fQ==
-  dependencies:
-    "@babel/helper-annotate-as-pure" "^7.25.9"
-    "@babel/helper-member-expression-to-functions" "^7.25.9"
-    "@babel/helper-optimise-call-expression" "^7.25.9"
-    "@babel/helper-replace-supers" "^7.25.9"
-    "@babel/helper-skip-transparent-expression-wrappers" "^7.25.9"
-    "@babel/traverse" "^7.25.9"
+"@babel/helper-create-class-features-plugin@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.28.6.tgz"
+  integrity sha512-dTOdvsjnG3xNT9Y0AUg1wAl38y+4Rl4sf9caSQZOXdNqVn+H+HbbJ4IyyHaIqNR6SW9oJpA/RuRjsjCw2IdIow==
+  dependencies:
+    "@babel/helper-annotate-as-pure" "^7.27.3"
+    "@babel/helper-member-expression-to-functions" "^7.28.5"
+    "@babel/helper-optimise-call-expression" "^7.27.1"
+    "@babel/helper-replace-supers" "^7.28.6"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.27.1"
+    "@babel/traverse" "^7.28.6"
     semver "^6.3.1"
 
-"@babel/helper-create-regexp-features-plugin@^7.18.6", "@babel/helper-create-regexp-features-plugin@^7.25.9":
-  version "7.26.3"
-  resolved "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.26.3.tgz"
-  integrity sha512-G7ZRb40uUgdKOQqPLjfD12ZmGA54PzqDFUv2BKImnC9QIfGhIHKvVML0oN8IUiDq4iRqpq74ABpvOaerfWdong==
+"@babel/helper-create-regexp-features-plugin@^7.18.6", "@babel/helper-create-regexp-features-plugin@^7.27.1", "@babel/helper-create-regexp-features-plugin@^7.28.5":
+  version "7.28.5"
+  resolved "https://registry.yarnpkg.com/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.28.5.tgz"
+  integrity sha512-N1EhvLtHzOvj7QQOUCCS3NrPJP8c5W6ZXCHDn7Yialuy1iu4r5EmIYkXlKNqT99Ciw+W0mDqWoR6HWMZlFP3hw==
   dependencies:
-    "@babel/helper-annotate-as-pure" "^7.25.9"
-    regexpu-core "^6.2.0"
+    "@babel/helper-annotate-as-pure" "^7.27.3"
+    regexpu-core "^6.3.1"
     semver "^6.3.1"
 
-"@babel/helper-define-polyfill-provider@^0.6.2", "@babel/helper-define-polyfill-provider@^0.6.3":
-  version "0.6.3"
-  resolved "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.6.3.tgz"
-  integrity sha512-HK7Bi+Hj6H+VTHA3ZvBis7V/6hu9QuTrnMXNybfUf2iiuU/N97I8VjB+KbhFF8Rld/Lx5MzoCwPCpPjfK+n8Cg==
+"@babel/helper-define-polyfill-provider@^0.6.5", "@babel/helper-define-polyfill-provider@^0.6.8":
+  version "0.6.8"
+  resolved "https://registry.yarnpkg.com/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.6.8.tgz"
+  integrity sha512-47UwBLPpQi1NoWzLuHNjRoHlYXMwIJoBf7MFou6viC/sIHWYygpvr0B6IAyh5sBdA2nr2LPIRww8lfaUVQINBA==
   dependencies:
-    "@babel/helper-compilation-targets" "^7.22.6"
-    "@babel/helper-plugin-utils" "^7.22.5"
-    debug "^4.1.1"
+    "@babel/helper-compilation-targets" "^7.28.6"
+    "@babel/helper-plugin-utils" "^7.28.6"
+    debug "^4.4.3"
     lodash.debounce "^4.0.8"
-    resolve "^1.14.2"
-
-"@babel/helper-member-expression-to-functions@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.25.9.tgz"
-  integrity sha512-wbfdZ9w5vk0C0oyHqAJbc62+vet5prjj01jjJ8sKn3j9h3MQQlflEdXYvuqRWjHnM12coDEqiC1IRCi0U/EKwQ==
-  dependencies:
-    "@babel/traverse" "^7.25.9"
-    "@babel/types" "^7.25.9"
-
-"@babel/helper-module-imports@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.25.9.tgz"
-  integrity sha512-tnUA4RsrmflIM6W6RFTLFSXITtl0wKjgpnLgXyowocVPrbYrLUXSBXDgTs8BlbmIzIdlBySRQjINYs2BAkiLtw==
-  dependencies:
-    "@babel/traverse" "^7.25.9"
-    "@babel/types" "^7.25.9"
-
-"@babel/helper-module-transforms@^7.25.9", "@babel/helper-module-transforms@^7.26.0":
-  version "7.26.0"
-  resolved "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.26.0.tgz"
-  integrity sha512-xO+xu6B5K2czEnQye6BHA7DolFFmS3LB7stHZFaOLb1pAwO1HWLS8fXA+eh0A2yIvltPVmx3eNNDBJA2SLHXFw==
-  dependencies:
-    "@babel/helper-module-imports" "^7.25.9"
-    "@babel/helper-validator-identifier" "^7.25.9"
-    "@babel/traverse" "^7.25.9"
-
-"@babel/helper-optimise-call-expression@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.25.9.tgz"
-  integrity sha512-FIpuNaz5ow8VyrYcnXQTDRGvV6tTjkNtCK/RYNDXGSLlUD6cBuQTSw43CShGxjvfBTfcUA/r6UhUCbtYqkhcuQ==
-  dependencies:
-    "@babel/types" "^7.25.9"
-
-"@babel/helper-plugin-utils@^7.0.0", "@babel/helper-plugin-utils@^7.18.6", "@babel/helper-plugin-utils@^7.22.5", "@babel/helper-plugin-utils@^7.25.9", "@babel/helper-plugin-utils@^7.8.0":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.25.9.tgz"
-  integrity sha512-kSMlyUVdWe25rEsRGviIgOWnoT/nfABVWlqt9N19/dIPWViAOW2s9wznP5tURbs/IDuNk4gPy3YdYRgH3uxhBw==
-
-"@babel/helper-remap-async-to-generator@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.25.9.tgz"
-  integrity sha512-IZtukuUeBbhgOcaW2s06OXTzVNJR0ybm4W5xC1opWFFJMZbwRj5LCk+ByYH7WdZPZTt8KnFwA8pvjN2yqcPlgw==
-  dependencies:
-    "@babel/helper-annotate-as-pure" "^7.25.9"
-    "@babel/helper-wrap-function" "^7.25.9"
-    "@babel/traverse" "^7.25.9"
-
-"@babel/helper-replace-supers@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.25.9.tgz"
-  integrity sha512-IiDqTOTBQy0sWyeXyGSC5TBJpGFXBkRynjBeXsvbhQFKj2viwJC76Epz35YLU1fpe/Am6Vppb7W7zM4fPQzLsQ==
-  dependencies:
-    "@babel/helper-member-expression-to-functions" "^7.25.9"
-    "@babel/helper-optimise-call-expression" "^7.25.9"
-    "@babel/traverse" "^7.25.9"
+    resolve "^1.22.11"
+
+"@babel/helper-globals@^7.28.0":
+  version "7.28.0"
+  resolved "https://registry.yarnpkg.com/@babel/helper-globals/-/helper-globals-7.28.0.tgz"
+  integrity sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==
+
+"@babel/helper-member-expression-to-functions@^7.28.5":
+  version "7.28.5"
+  resolved "https://registry.yarnpkg.com/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.28.5.tgz"
+  integrity sha512-cwM7SBRZcPCLgl8a7cY0soT1SptSzAlMH39vwiRpOQkJlh53r5hdHwLSCZpQdVLT39sZt+CRpNwYG4Y2v77atg==
+  dependencies:
+    "@babel/traverse" "^7.28.5"
+    "@babel/types" "^7.28.5"
+
+"@babel/helper-module-imports@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz"
+  integrity sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==
+  dependencies:
+    "@babel/traverse" "^7.28.6"
+    "@babel/types" "^7.28.6"
+
+"@babel/helper-module-transforms@^7.27.1", "@babel/helper-module-transforms@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz"
+  integrity sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==
+  dependencies:
+    "@babel/helper-module-imports" "^7.28.6"
+    "@babel/helper-validator-identifier" "^7.28.5"
+    "@babel/traverse" "^7.28.6"
+
+"@babel/helper-optimise-call-expression@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.27.1.tgz"
+  integrity sha512-URMGH08NzYFhubNSGJrpUEphGKQwMQYBySzat5cAByY1/YgIRkULnIy3tAMeszlL/so2HbeilYloUmSpd7GdVw==
+  dependencies:
+    "@babel/types" "^7.27.1"
+
+"@babel/helper-plugin-utils@^7.0.0", "@babel/helper-plugin-utils@^7.18.6", "@babel/helper-plugin-utils@^7.27.1", "@babel/helper-plugin-utils@^7.28.6", "@babel/helper-plugin-utils@^7.8.0":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz"
+  integrity sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==
+
+"@babel/helper-remap-async-to-generator@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.27.1.tgz"
+  integrity sha512-7fiA521aVw8lSPeI4ZOD3vRFkoqkJcS+z4hFo82bFSH/2tNd6eJ5qCVMS5OzDmZh/kaHQeBaeyxK6wljcPtveA==
+  dependencies:
+    "@babel/helper-annotate-as-pure" "^7.27.1"
+    "@babel/helper-wrap-function" "^7.27.1"
+    "@babel/traverse" "^7.27.1"
+
+"@babel/helper-replace-supers@^7.27.1", "@babel/helper-replace-supers@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-replace-supers/-/helper-replace-supers-7.28.6.tgz"
+  integrity sha512-mq8e+laIk94/yFec3DxSjCRD2Z0TAjhVbEJY3UQrlwVo15Lmt7C2wAUbK4bjnTs4APkwsYLTahXRraQXhb1WCg==
+  dependencies:
+    "@babel/helper-member-expression-to-functions" "^7.28.5"
+    "@babel/helper-optimise-call-expression" "^7.27.1"
+    "@babel/traverse" "^7.28.6"
+
+"@babel/helper-skip-transparent-expression-wrappers@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.27.1.tgz"
+  integrity sha512-Tub4ZKEXqbPjXgWLl2+3JpQAYBJ8+ikpQ2Ocj/q/r0LwE3UhENh7EUabyHjz2kCEsrRY83ew2DQdHluuiDQFzg==
+  dependencies:
+    "@babel/traverse" "^7.27.1"
+    "@babel/types" "^7.27.1"
+
+"@babel/helper-string-parser@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz"
+  integrity sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==
+
+"@babel/helper-validator-identifier@^7.28.5":
+  version "7.28.5"
+  resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz"
+  integrity sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==
+
+"@babel/helper-validator-option@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz"
+  integrity sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==
+
+"@babel/helper-wrap-function@^7.27.1":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-wrap-function/-/helper-wrap-function-7.28.6.tgz"
+  integrity sha512-z+PwLziMNBeSQJonizz2AGnndLsP2DeGHIxDAn+wdHOGuo4Fo1x1HBPPXeE9TAOPHNNWQKCSlA2VZyYyyibDnQ==
+  dependencies:
+    "@babel/template" "^7.28.6"
+    "@babel/traverse" "^7.28.6"
+    "@babel/types" "^7.28.6"
+
+"@babel/helpers@^7.28.6":
+  version "7.29.2"
+  resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.29.2.tgz"
+  integrity sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw==
+  dependencies:
+    "@babel/template" "^7.28.6"
+    "@babel/types" "^7.29.0"
 
-"@babel/helper-skip-transparent-expression-wrappers@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.25.9.tgz"
-  integrity sha512-K4Du3BFa3gvyhzgPcntrkDgZzQaq6uozzcpGbOO1OEJaI+EJdqWIMTLgFgQf6lrfiDFo5FU+BxKepI9RmZqahA==
+"@babel/parser@^7.28.6", "@babel/parser@^7.29.0":
+  version "7.29.2"
+  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.29.2.tgz"
+  integrity sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA==
   dependencies:
-    "@babel/traverse" "^7.25.9"
-    "@babel/types" "^7.25.9"
-
-"@babel/helper-string-parser@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.25.9.tgz"
-  integrity sha512-4A/SCr/2KLd5jrtOMFzaKjVtAei3+2r/NChoBNoZ3EyP/+GlhoaEGoWOZUmFmoITP7zOJyHIMm+DYRd8o3PvHA==
-
-"@babel/helper-validator-identifier@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.25.9.tgz"
-  integrity sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ==
-
-"@babel/helper-validator-option@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.25.9.tgz"
-  integrity sha512-e/zv1co8pp55dNdEcCynfj9X7nyUKUXoUEwfXqaZt0omVOmDe9oOTdKStH4GmAw6zxMFs50ZayuMfHDKlO7Tfw==
-
-"@babel/helper-wrap-function@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.25.9.tgz"
-  integrity sha512-ETzz9UTjQSTmw39GboatdymDq4XIQbR8ySgVrylRhPOFpsd+JrKHIuF0de7GCWmem+T4uC5z7EZguod7Wj4A4g==
+    "@babel/types" "^7.29.0"
+
+"@babel/plugin-bugfix-firefox-class-in-computed-class-key@^7.28.5":
+  version "7.28.5"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-firefox-class-in-computed-class-key/-/plugin-bugfix-firefox-class-in-computed-class-key-7.28.5.tgz"
+  integrity sha512-87GDMS3tsmMSi/3bWOte1UblL+YUTFMV8SZPZ2eSEL17s74Cw/l63rR6NmGVKMYW2GYi85nE+/d6Hw5N0bEk2Q==
   dependencies:
-    "@babel/template" "^7.25.9"
-    "@babel/traverse" "^7.25.9"
-    "@babel/types" "^7.25.9"
-
-"@babel/helpers@^7.26.0":
-  version "7.26.0"
-  resolved "https://registry.npmjs.org/@babel/helpers/-/helpers-7.26.0.tgz"
-  integrity sha512-tbhNuIxNcVb21pInl3ZSjksLCvgdZy9KwJ8brv993QtIVKJBBkYXz4q4ZbAv31GdnC+R90np23L5FbEBlthAEw==
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/traverse" "^7.28.5"
+
+"@babel/plugin-bugfix-safari-class-field-initializer-scope@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-safari-class-field-initializer-scope/-/plugin-bugfix-safari-class-field-initializer-scope-7.27.1.tgz"
+  integrity sha512-qNeq3bCKnGgLkEXUuFry6dPlGfCdQNZbn7yUAPCInwAJHMU7THJfrBSozkcWq5sNM6RcF3S8XyQL2A52KNR9IA==
   dependencies:
-    "@babel/template" "^7.25.9"
-    "@babel/types" "^7.26.0"
+    "@babel/helper-plugin-utils" "^7.27.1"
+
+"@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.27.1.tgz"
+  integrity sha512-g4L7OYun04N1WyqMNjldFwlfPCLVkgB54A/YCXICZYBsvJJE3kByKv9c9+R/nAfmIfjl2rKYLNyMHboYbZaWaA==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/parser@^7.25.9", "@babel/parser@^7.26.0", "@babel/parser@^7.26.3":
-  version "7.26.3"
-  resolved "https://registry.npmjs.org/@babel/parser/-/parser-7.26.3.tgz"
-  integrity sha512-WJ/CvmY8Mea8iDXo6a7RK2wbmJITT5fN3BEkRuFlxVyNx8jOKIIhmC4fSkTcPcf8JyavbBwIe6OpiCOBXt/IcA==
+"@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.27.1.tgz"
+  integrity sha512-oO02gcONcD5O1iTLi/6frMJBIwWEHceWGSGqrpCmEL8nogiS6J9PBlE48CaK20/Jx1LuRml9aDftLgdjXT8+Cw==
   dependencies:
-    "@babel/types" "^7.26.3"
-
-"@babel/plugin-bugfix-firefox-class-in-computed-class-key@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-bugfix-firefox-class-in-computed-class-key/-/plugin-bugfix-firefox-class-in-computed-class-key-7.25.9.tgz"
-  integrity sha512-ZkRyVkThtxQ/J6nv3JFYv1RYY+JT5BvU0y3k5bWrmuG4woXypRa4PXmm9RhOwodRkYFWqC0C0cqcJ4OqR7kW+g==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
-    "@babel/traverse" "^7.25.9"
-
-"@babel/plugin-bugfix-safari-class-field-initializer-scope@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-bugfix-safari-class-field-initializer-scope/-/plugin-bugfix-safari-class-field-initializer-scope-7.25.9.tgz"
-  integrity sha512-MrGRLZxLD/Zjj0gdU15dfs+HH/OXvnw/U4jJD8vpcP2CJQapPEv1IWwjc/qMg7ItBlPwSv1hRBbb7LeuANdcnw==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
-
-"@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.25.9.tgz"
-  integrity sha512-2qUwwfAFpJLZqxd02YW9btUCZHl+RFvdDkNfZwaIJrvB8Tesjsk8pEQkTvGwZXLqXUx/2oyY3ySRhm6HOXuCug==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
-
-"@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.25.9.tgz"
-  integrity sha512-6xWgLZTJXwilVjlnV7ospI3xi+sl8lN8rXXbBD6vYn3UYDlGsag8wrZkKcSI8G6KgqKP7vNFaDgeDnfAABq61g==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
-    "@babel/helper-skip-transparent-expression-wrappers" "^7.25.9"
-    "@babel/plugin-transform-optional-chaining" "^7.25.9"
-
-"@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.25.9.tgz"
-  integrity sha512-aLnMXYPnzwwqhYSCyXfKkIkYgJ8zv9RK+roo9DkTXz38ynIhd9XCbN08s3MGvqL2MYGVUGdRQLL/JqBIeJhJBg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
-    "@babel/traverse" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.27.1"
+    "@babel/plugin-transform-optional-chaining" "^7.27.1"
+
+"@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.28.6.tgz"
+  integrity sha512-a0aBScVTlNaiUe35UtfxAN7A/tehvvG4/ByO6+46VPKTRSlfnAFsgKy0FUh+qAkQrDTmhDkT+IBOKlOoMUxQ0g==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.28.6"
+    "@babel/traverse" "^7.28.6"
 
 "@babel/plugin-proposal-private-property-in-object@7.21.0-placeholder-for-preset-env.2":
   version "7.21.0-placeholder-for-preset-env.2"
-  resolved "https://registry.npmjs.org/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.21.0-placeholder-for-preset-env.2.tgz"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.21.0-placeholder-for-preset-env.2.tgz"
   integrity sha512-SOSkfJDddaM7mak6cPEpswyTRnuRltl429hMraQEglW+OkovnCzsiszTmsrlY//qLFjCpQDFRvjdm2wA5pPm9w==
 
 "@babel/plugin-syntax-dynamic-import@^7.8.3":
   version "7.8.3"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-dynamic-import/-/plugin-syntax-dynamic-import-7.8.3.tgz"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-dynamic-import/-/plugin-syntax-dynamic-import-7.8.3.tgz"
   integrity sha512-5gdGbFon+PszYzqs83S3E5mpi7/y/8M9eC90MRTZfduQOYW76ig6SOSPNe41IG5LoP3FGBn2N0RjVDSQiS94kQ==
   dependencies:
     "@babel/helper-plugin-utils" "^7.8.0"
 
-"@babel/plugin-syntax-import-assertions@^7.26.0":
-  version "7.26.0"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.26.0.tgz"
-  integrity sha512-QCWT5Hh830hK5EQa7XzuqIkQU9tT/whqbDz7kuaZMHFl1inRRg7JnuAEOQ0Ur0QUl0NufCk1msK2BeY79Aj/eg==
+"@babel/plugin-syntax-import-assertions@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.28.6.tgz"
+  integrity sha512-pSJUpFHdx9z5nqTSirOCMtYVP2wFgoWhP0p3g8ONK/4IHhLIBd0B9NYqAvIUAhq+OkhO4VM1tENCt0cjlsNShw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.28.6"
 
-"@babel/plugin-syntax-import-attributes@^7.26.0":
-  version "7.26.0"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.26.0.tgz"
-  integrity sha512-e2dttdsJ1ZTpi3B9UYGLw41hifAubg19AtCu/2I/F1QNVclOBr1dYpTdmdyZ84Xiz43BS/tCUkMAZNLv12Pi+A==
+"@babel/plugin-syntax-import-attributes@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.28.6.tgz"
+  integrity sha512-jiLC0ma9XkQT3TKJ9uYvlakm66Pamywo+qwL+oL8HJOvc6TWdZXVfhqJr8CCzbSGUAbDOzlGHJC1U+vRfLQDvw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.28.6"
 
-"@babel/plugin-syntax-jsx@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.25.9.tgz"
-  integrity sha512-ld6oezHQMZsZfp6pWtbjaNDF2tiiCYYDqQszHt5VV437lewP9aSi2Of99CK0D0XB21k7FLgnLcmQKyKzynfeAA==
+"@babel/plugin-syntax-jsx@^7.27.1", "@babel/plugin-syntax-jsx@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.28.6.tgz"
+  integrity sha512-wgEmr06G6sIpqr8YDwA2dSRTE3bJ+V0IfpzfSY3Lfgd7YWOaAdlykvJi13ZKBt8cZHfgH1IXN+CL656W3uUa4w==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.28.6"
 
-"@babel/plugin-syntax-typescript@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.25.9.tgz"
-  integrity sha512-hjMgRy5hb8uJJjUcdWunWVcoi9bGpJp8p5Ol1229PoN6aytsLwNMgmdftO23wnCLMfVmTwZDWMPNq/D1SY60JQ==
+"@babel/plugin-syntax-typescript@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.28.6.tgz"
+  integrity sha512-+nDNmQye7nlnuuHDboPbGm00Vqg3oO8niRRL27/4LYHUsHYh0zJ1xWOz0uRwNFmM1Avzk8wZbc6rdiYhomzv/A==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.28.6"
 
 "@babel/plugin-syntax-unicode-sets-regex@^7.18.6":
   version "7.18.6"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-unicode-sets-regex/-/plugin-syntax-unicode-sets-regex-7.18.6.tgz"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-unicode-sets-regex/-/plugin-syntax-unicode-sets-regex-7.18.6.tgz"
   integrity sha512-727YkEAPwSIQTv5im8QHz3upqp92JTWhidIC81Tdx4VJYIte/VndKf1qKrfnnhPLiPghStWfvC/iFaMCQu7Nqg==
   dependencies:
     "@babel/helper-create-regexp-features-plugin" "^7.18.6"
     "@babel/helper-plugin-utils" "^7.18.6"
 
-"@babel/plugin-transform-arrow-functions@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.25.9.tgz"
-  integrity sha512-6jmooXYIwn9ca5/RylZADJ+EnSxVUS5sjeJ9UPk6RWRzXCmOJCy6dqItPJFpw2cuCangPK4OYr5uhGKcmrm5Qg==
+"@babel/plugin-transform-arrow-functions@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.27.1.tgz"
+  integrity sha512-8Z4TGic6xW70FKThA5HYEKKyBpOOsucTOD1DjU3fZxDg+K3zBJcXMFnt/4yQiZnf5+MiOMSXQ9PaEK/Ilh1DeA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-async-generator-functions@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.25.9.tgz"
-  integrity sha512-RXV6QAzTBbhDMO9fWwOmwwTuYaiPbggWQ9INdZqAYeSHyG7FzQ+nOZaUUjNwKv9pV3aE4WFqFm1Hnbci5tBCAw==
+"@babel/plugin-transform-async-generator-functions@^7.29.0":
+  version "7.29.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.29.0.tgz"
+  integrity sha512-va0VdWro4zlBr2JsXC+ofCPB2iG12wPtVGTWFx2WLDOM3nYQZZIGP82qku2eW/JR83sD+k2k+CsNtyEbUqhU6w==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
-    "@babel/helper-remap-async-to-generator" "^7.25.9"
-    "@babel/traverse" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.28.6"
+    "@babel/helper-remap-async-to-generator" "^7.27.1"
+    "@babel/traverse" "^7.29.0"
 
-"@babel/plugin-transform-async-to-generator@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.25.9.tgz"
-  integrity sha512-NT7Ejn7Z/LjUH0Gv5KsBCxh7BH3fbLTV0ptHvpeMvrt3cPThHfJfst9Wrb7S8EvJ7vRTFI7z+VAvFVEQn/m5zQ==
+"@babel/plugin-transform-async-to-generator@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.28.6.tgz"
+  integrity sha512-ilTRcmbuXjsMmcZ3HASTe4caH5Tpo93PkTxF9oG2VZsSWsahydmcEHhix9Ik122RcTnZnUzPbmux4wh1swfv7g==
   dependencies:
-    "@babel/helper-module-imports" "^7.25.9"
-    "@babel/helper-plugin-utils" "^7.25.9"
-    "@babel/helper-remap-async-to-generator" "^7.25.9"
+    "@babel/helper-module-imports" "^7.28.6"
+    "@babel/helper-plugin-utils" "^7.28.6"
+    "@babel/helper-remap-async-to-generator" "^7.27.1"
 
-"@babel/plugin-transform-block-scoped-functions@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.25.9.tgz"
-  integrity sha512-toHc9fzab0ZfenFpsyYinOX0J/5dgJVA2fm64xPewu7CoYHWEivIWKxkK2rMi4r3yQqLnVmheMXRdG+k239CgA==
+"@babel/plugin-transform-block-scoped-functions@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.27.1.tgz"
+  integrity sha512-cnqkuOtZLapWYZUYM5rVIdv1nXYuFVIltZ6ZJ7nIj585QsjKM5dhL2Fu/lICXZ1OyIAFc7Qy+bvDAtTXqGrlhg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-block-scoping@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.25.9.tgz"
-  integrity sha512-1F05O7AYjymAtqbsFETboN1NvBdcnzMerO+zlMyJBEz6WkMdejvGWw9p05iTSjC85RLlBseHHQpYaM4gzJkBGg==
+"@babel/plugin-transform-block-scoping@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.28.6.tgz"
+  integrity sha512-tt/7wOtBmwHPNMPu7ax4pdPz6shjFrmHDghvNC+FG9Qvj7D6mJcoRQIF5dy4njmxR941l6rgtvfSB2zX3VlUIw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.28.6"
 
-"@babel/plugin-transform-class-properties@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.25.9.tgz"
-  integrity sha512-bbMAII8GRSkcd0h0b4X+36GksxuheLFjP65ul9w6C3KgAamI3JqErNgSrosX6ZPj+Mpim5VvEbawXxJCyEUV3Q==
+"@babel/plugin-transform-class-properties@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.28.6.tgz"
+  integrity sha512-dY2wS3I2G7D697VHndN91TJr8/AAfXQNt5ynCTI/MpxMsSzHp+52uNivYT5wCPax3whc47DR8Ba7cmlQMg24bw==
   dependencies:
-    "@babel/helper-create-class-features-plugin" "^7.25.9"
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-create-class-features-plugin" "^7.28.6"
+    "@babel/helper-plugin-utils" "^7.28.6"
 
-"@babel/plugin-transform-class-static-block@^7.26.0":
-  version "7.26.0"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.26.0.tgz"
-  integrity sha512-6J2APTs7BDDm+UMqP1useWqhcRAXo0WIoVj26N7kPFB6S73Lgvyka4KTZYIxtgYXiN5HTyRObA72N2iu628iTQ==
+"@babel/plugin-transform-class-static-block@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.28.6.tgz"
+  integrity sha512-rfQ++ghVwTWTqQ7w8qyDxL1XGihjBss4CmTgGRCTAC9RIbhVpyp4fOeZtta0Lbf+dTNIVJer6ych2ibHwkZqsQ==
   dependencies:
-    "@babel/helper-create-class-features-plugin" "^7.25.9"
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-create-class-features-plugin" "^7.28.6"
+    "@babel/helper-plugin-utils" "^7.28.6"
 
-"@babel/plugin-transform-classes@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.25.9.tgz"
-  integrity sha512-mD8APIXmseE7oZvZgGABDyM34GUmK45Um2TXiBUt7PnuAxrgoSVf123qUzPxEr/+/BHrRn5NMZCdE2m/1F8DGg==
+"@babel/plugin-transform-classes@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-classes/-/plugin-transform-classes-7.28.6.tgz"
+  integrity sha512-EF5KONAqC5zAqT783iMGuM2ZtmEBy+mJMOKl2BCvPZ2lVrwvXnB6o+OBWCS+CoeCCpVRF2sA2RBKUxvT8tQT5Q==
   dependencies:
-    "@babel/helper-annotate-as-pure" "^7.25.9"
-    "@babel/helper-compilation-targets" "^7.25.9"
-    "@babel/helper-plugin-utils" "^7.25.9"
-    "@babel/helper-replace-supers" "^7.25.9"
-    "@babel/traverse" "^7.25.9"
-    globals "^11.1.0"
+    "@babel/helper-annotate-as-pure" "^7.27.3"
+    "@babel/helper-compilation-targets" "^7.28.6"
+    "@babel/helper-globals" "^7.28.0"
+    "@babel/helper-plugin-utils" "^7.28.6"
+    "@babel/helper-replace-supers" "^7.28.6"
+    "@babel/traverse" "^7.28.6"
 
-"@babel/plugin-transform-computed-properties@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.25.9.tgz"
-  integrity sha512-HnBegGqXZR12xbcTHlJ9HGxw1OniltT26J5YpfruGqtUHlz/xKf/G2ak9e+t0rVqrjXa9WOhvYPz1ERfMj23AA==
+"@babel/plugin-transform-computed-properties@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.28.6.tgz"
+  integrity sha512-bcc3k0ijhHbc2lEfpFHgx7eYw9KNXqOerKWfzbxEHUGKnS3sz9C4CNL9OiFN1297bDNfUiSO7DaLzbvHQQQ1BQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
-    "@babel/template" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.28.6"
+    "@babel/template" "^7.28.6"
 
-"@babel/plugin-transform-destructuring@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.25.9.tgz"
-  integrity sha512-WkCGb/3ZxXepmMiX101nnGiU+1CAdut8oHyEOHxkKuS1qKpU2SMXE2uSvfz8PBuLd49V6LEsbtyPhWC7fnkgvQ==
+"@babel/plugin-transform-destructuring@^7.28.5":
+  version "7.28.5"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.28.5.tgz"
+  integrity sha512-Kl9Bc6D0zTUcFUvkNuQh4eGXPKKNDOJQXVyyM4ZAQPMveniJdxi8XMJwLo+xSoW3MIq81bD33lcUe9kZpl0MCw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/traverse" "^7.28.5"
 
-"@babel/plugin-transform-dotall-regex@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.25.9.tgz"
-  integrity sha512-t7ZQ7g5trIgSRYhI9pIJtRl64KHotutUJsh4Eze5l7olJv+mRSg4/MmbZ0tv1eeqRbdvo/+trvJD/Oc5DmW2cA==
+"@babel/plugin-transform-dotall-regex@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.28.6.tgz"
+  integrity sha512-SljjowuNKB7q5Oayv4FoPzeB74g3QgLt8IVJw9ADvWy3QnUb/01aw8I4AVv8wYnPvQz2GDDZ/g3GhcNyDBI4Bg==
   dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.25.9"
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-create-regexp-features-plugin" "^7.28.5"
+    "@babel/helper-plugin-utils" "^7.28.6"
 
-"@babel/plugin-transform-duplicate-keys@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.25.9.tgz"
-  integrity sha512-LZxhJ6dvBb/f3x8xwWIuyiAHy56nrRG3PeYTpBkkzkYRRQ6tJLu68lEF5VIqMUZiAV7a8+Tb78nEoMCMcqjXBw==
+"@babel/plugin-transform-duplicate-keys@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.27.1.tgz"
+  integrity sha512-MTyJk98sHvSs+cvZ4nOauwTTG1JeonDjSGvGGUNHreGQns+Mpt6WX/dVzWBHgg+dYZhkC4X+zTDfkTU+Vy9y7Q==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-duplicate-named-capturing-groups-regex@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-duplicate-named-capturing-groups-regex/-/plugin-transform-duplicate-named-capturing-groups-regex-7.25.9.tgz"
-  integrity sha512-0UfuJS0EsXbRvKnwcLjFtJy/Sxc5J5jhLHnFhy7u4zih97Hz6tJkLU+O+FMMrNZrosUPxDi6sYxJ/EA8jDiAog==
+"@babel/plugin-transform-duplicate-named-capturing-groups-regex@^7.29.0":
+  version "7.29.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-duplicate-named-capturing-groups-regex/-/plugin-transform-duplicate-named-capturing-groups-regex-7.29.0.tgz"
+  integrity sha512-zBPcW2lFGxdiD8PUnPwJjag2J9otbcLQzvbiOzDxpYXyCuYX9agOwMPGn1prVH0a4qzhCKu24rlH4c1f7yA8rw==
   dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.25.9"
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-create-regexp-features-plugin" "^7.28.5"
+    "@babel/helper-plugin-utils" "^7.28.6"
 
-"@babel/plugin-transform-dynamic-import@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-dynamic-import/-/plugin-transform-dynamic-import-7.25.9.tgz"
-  integrity sha512-GCggjexbmSLaFhqsojeugBpeaRIgWNTcgKVq/0qIteFEqY2A+b9QidYadrWlnbWQUrW5fn+mCvf3tr7OeBFTyg==
+"@babel/plugin-transform-dynamic-import@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-dynamic-import/-/plugin-transform-dynamic-import-7.27.1.tgz"
+  integrity sha512-MHzkWQcEmjzzVW9j2q8LGjwGWpG2mjwaaB0BNQwst3FIjqsg8Ct/mIZlvSPJvfi9y2AC8mi/ktxbFVL9pZ1I4A==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-exponentiation-operator@^7.25.9":
-  version "7.26.3"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.26.3.tgz"
-  integrity sha512-7CAHcQ58z2chuXPWblnn1K6rLDnDWieghSOEmqQsrBenH0P9InCUtOJYD89pvngljmZlJcz3fcmgYsXFNGa1ZQ==
+"@babel/plugin-transform-explicit-resource-management@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-explicit-resource-management/-/plugin-transform-explicit-resource-management-7.28.6.tgz"
+  integrity sha512-Iao5Konzx2b6g7EPqTy40UZbcdXE126tTxVFr/nAIj+WItNxjKSYTEw3RC+A2/ZetmdJsgueL1KhaMCQHkLPIg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.28.6"
+    "@babel/plugin-transform-destructuring" "^7.28.5"
 
-"@babel/plugin-transform-export-namespace-from@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-export-namespace-from/-/plugin-transform-export-namespace-from-7.25.9.tgz"
-  integrity sha512-2NsEz+CxzJIVOPx2o9UsW1rXLqtChtLoVnwYHHiB04wS5sgn7mrV45fWMBX0Kk+ub9uXytVYfNP2HjbVbCB3Ww==
+"@babel/plugin-transform-exponentiation-operator@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.28.6.tgz"
+  integrity sha512-WitabqiGjV/vJ0aPOLSFfNY1u9U3R7W36B03r5I2KoNix+a3sOhJ3pKFB3R5It9/UiK78NiO0KE9P21cMhlPkw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.28.6"
 
-"@babel/plugin-transform-for-of@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.25.9.tgz"
-  integrity sha512-LqHxduHoaGELJl2uhImHwRQudhCM50pT46rIBNvtT/Oql3nqiS3wOwP+5ten7NpYSXrrVLgtZU3DZmPtWZo16A==
+"@babel/plugin-transform-export-namespace-from@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-export-namespace-from/-/plugin-transform-export-namespace-from-7.27.1.tgz"
+  integrity sha512-tQvHWSZ3/jH2xuq/vZDy0jNn+ZdXJeM8gHvX4lnJmsc3+50yPlWdZXIc5ay+umX+2/tJIqHqiEqcJvxlmIvRvQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
-    "@babel/helper-skip-transparent-expression-wrappers" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-function-name@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.25.9.tgz"
-  integrity sha512-8lP+Yxjv14Vc5MuWBpJsoUCd3hD6V9DgBon2FVYL4jJgbnVQ9fTgYmonchzZJOVNgzEgbxp4OwAf6xz6M/14XA==
+"@babel/plugin-transform-for-of@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.27.1.tgz"
+  integrity sha512-BfbWFFEJFQzLCQ5N8VocnCtA8J1CLkNTe2Ms2wocj75dd6VpiqS5Z5quTYcUoo4Yq+DN0rtikODccuv7RU81sw==
   dependencies:
-    "@babel/helper-compilation-targets" "^7.25.9"
-    "@babel/helper-plugin-utils" "^7.25.9"
-    "@babel/traverse" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.27.1"
 
-"@babel/plugin-transform-json-strings@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.25.9.tgz"
-  integrity sha512-xoTMk0WXceiiIvsaquQQUaLLXSW1KJ159KP87VilruQm0LNNGxWzahxSS6T6i4Zg3ezp4vA4zuwiNUR53qmQAw==
+"@babel/plugin-transform-function-name@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.27.1.tgz"
+  integrity sha512-1bQeydJF9Nr1eBCMMbC+hdwmRlsv5XYOMu03YSWFwNs0HsAmtSxxF1fyuYPqemVldVyFmlCU7w8UE14LupUSZQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-compilation-targets" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/traverse" "^7.27.1"
 
-"@babel/plugin-transform-literals@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.25.9.tgz"
-  integrity sha512-9N7+2lFziW8W9pBl2TzaNht3+pgMIRP74zizeCSrtnSKVdUl8mAjjOP2OOVQAfZ881P2cNjDj1uAMEdeD50nuQ==
+"@babel/plugin-transform-json-strings@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.28.6.tgz"
+  integrity sha512-Nr+hEN+0geQkzhbdgQVPoqr47lZbm+5fCUmO70722xJZd0Mvb59+33QLImGj6F+DkK3xgDi1YVysP8whD6FQAw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.28.6"
 
-"@babel/plugin-transform-logical-assignment-operators@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.25.9.tgz"
-  integrity sha512-wI4wRAzGko551Y8eVf6iOY9EouIDTtPb0ByZx+ktDGHwv6bHFimrgJM/2T021txPZ2s4c7bqvHbd+vXG6K948Q==
+"@babel/plugin-transform-literals@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-literals/-/plugin-transform-literals-7.27.1.tgz"
+  integrity sha512-0HCFSepIpLTkLcsi86GG3mTUzxV5jpmbv97hTETW3yzrAij8aqlD36toB1D0daVFJM8NK6GvKO0gslVQmm+zZA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-member-expression-literals@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.25.9.tgz"
-  integrity sha512-PYazBVfofCQkkMzh2P6IdIUaCEWni3iYEerAsRWuVd8+jlM1S9S9cz1dF9hIzyoZ8IA3+OwVYIp9v9e+GbgZhA==
+"@babel/plugin-transform-logical-assignment-operators@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.28.6.tgz"
+  integrity sha512-+anKKair6gpi8VsM/95kmomGNMD0eLz1NQ8+Pfw5sAwWH9fGYXT50E55ZpV0pHUHWf6IUTWPM+f/7AAff+wr9A==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.28.6"
 
-"@babel/plugin-transform-modules-amd@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.25.9.tgz"
-  integrity sha512-g5T11tnI36jVClQlMlt4qKDLlWnG5pP9CSM4GhdRciTNMRgkfpo5cR6b4rGIOYPgRRuFAvwjPQ/Yk+ql4dyhbw==
+"@babel/plugin-transform-member-expression-literals@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.27.1.tgz"
+  integrity sha512-hqoBX4dcZ1I33jCSWcXrP+1Ku7kdqXf1oeah7ooKOIiAdKQ+uqftgCFNOSzA5AMS2XIHEYeGFg4cKRCdpxzVOQ==
   dependencies:
-    "@babel/helper-module-transforms" "^7.25.9"
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-modules-commonjs@^7.25.9":
-  version "7.26.3"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.26.3.tgz"
-  integrity sha512-MgR55l4q9KddUDITEzEFYn5ZsGDXMSsU9E+kh7fjRXTIC3RHqfCo8RPRbyReYJh44HQ/yomFkqbOFohXvDCiIQ==
+"@babel/plugin-transform-modules-amd@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.27.1.tgz"
+  integrity sha512-iCsytMg/N9/oFq6n+gFTvUYDZQOMK5kEdeYxmxt91fcJGycfxVP9CnrxoliM0oumFERba2i8ZtwRUCMhvP1LnA==
   dependencies:
-    "@babel/helper-module-transforms" "^7.26.0"
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-module-transforms" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-modules-systemjs@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.25.9.tgz"
-  integrity sha512-hyss7iIlH/zLHaehT+xwiymtPOpsiwIIRlCAOwBB04ta5Tt+lNItADdlXw3jAWZ96VJ2jlhl/c+PNIQPKNfvcA==
+"@babel/plugin-transform-modules-commonjs@^7.27.1", "@babel/plugin-transform-modules-commonjs@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.28.6.tgz"
+  integrity sha512-jppVbf8IV9iWWwWTQIxJMAJCWBuuKx71475wHwYytrRGQ2CWiDvYlADQno3tcYpS/T2UUWFQp3nVtYfK/YBQrA==
   dependencies:
-    "@babel/helper-module-transforms" "^7.25.9"
-    "@babel/helper-plugin-utils" "^7.25.9"
-    "@babel/helper-validator-identifier" "^7.25.9"
-    "@babel/traverse" "^7.25.9"
+    "@babel/helper-module-transforms" "^7.28.6"
+    "@babel/helper-plugin-utils" "^7.28.6"
 
-"@babel/plugin-transform-modules-umd@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.25.9.tgz"
-  integrity sha512-bS9MVObUgE7ww36HEfwe6g9WakQ0KF07mQF74uuXdkoziUPfKyu/nIm663kz//e5O1nPInPFx36z7WJmJ4yNEw==
+"@babel/plugin-transform-modules-systemjs@^7.29.0":
+  version "7.29.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.29.0.tgz"
+  integrity sha512-PrujnVFbOdUpw4UHiVwKvKRLMMic8+eC0CuNlxjsyZUiBjhFdPsewdXCkveh2KqBA9/waD0W1b4hXSOBQJezpQ==
   dependencies:
-    "@babel/helper-module-transforms" "^7.25.9"
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-module-transforms" "^7.28.6"
+    "@babel/helper-plugin-utils" "^7.28.6"
+    "@babel/helper-validator-identifier" "^7.28.5"
+    "@babel/traverse" "^7.29.0"
 
-"@babel/plugin-transform-named-capturing-groups-regex@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.25.9.tgz"
-  integrity sha512-oqB6WHdKTGl3q/ItQhpLSnWWOpjUJLsOCLVyeFgeTktkBSCiurvPOsyt93gibI9CmuKvTUEtWmG5VhZD+5T/KA==
+"@babel/plugin-transform-modules-umd@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.27.1.tgz"
+  integrity sha512-iQBE/xC5BV1OxJbp6WG7jq9IWiD+xxlZhLrdwpPkTX3ydmXdvoCpyfJN7acaIBZaOqTfr76pgzqBJflNbeRK+w==
   dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.25.9"
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-module-transforms" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-new-target@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.25.9.tgz"
-  integrity sha512-U/3p8X1yCSoKyUj2eOBIx3FOn6pElFOKvAAGf8HTtItuPyB+ZeOqfn+mvTtg9ZlOAjsPdK3ayQEjqHjU/yLeVQ==
+"@babel/plugin-transform-named-capturing-groups-regex@^7.29.0":
+  version "7.29.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.29.0.tgz"
+  integrity sha512-1CZQA5KNAD6ZYQLPw7oi5ewtDNxH/2vuCh+6SmvgDfhumForvs8a1o9n0UrEoBD8HU4djO2yWngTQlXl1NDVEQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-create-regexp-features-plugin" "^7.28.5"
+    "@babel/helper-plugin-utils" "^7.28.6"
 
-"@babel/plugin-transform-nullish-coalescing-operator@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.25.9.tgz"
-  integrity sha512-ENfftpLZw5EItALAD4WsY/KUWvhUlZndm5GC7G3evUsVeSJB6p0pBeLQUnRnBCBx7zV0RKQjR9kCuwrsIrjWog==
+"@babel/plugin-transform-new-target@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.27.1.tgz"
+  integrity sha512-f6PiYeqXQ05lYq3TIfIDu/MtliKUbNwkGApPUvyo6+tc7uaR4cPjPe7DFPr15Uyycg2lZU6btZ575CuQoYh7MQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-numeric-separator@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.25.9.tgz"
-  integrity sha512-TlprrJ1GBZ3r6s96Yq8gEQv82s8/5HnCVHtEJScUj90thHQbwe+E5MLhi2bbNHBEJuzrvltXSru+BUxHDoog7Q==
+"@babel/plugin-transform-nullish-coalescing-operator@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.28.6.tgz"
+  integrity sha512-3wKbRgmzYbw24mDJXT7N+ADXw8BC/imU9yo9c9X9NKaLF1fW+e5H1U5QjMUBe4Qo4Ox/o++IyUkl1sVCLgevKg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.28.6"
 
-"@babel/plugin-transform-object-rest-spread@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.25.9.tgz"
-  integrity sha512-fSaXafEE9CVHPweLYw4J0emp1t8zYTXyzN3UuG+lylqkvYd7RMrsOQ8TYx5RF231be0vqtFC6jnx3UmpJmKBYg==
+"@babel/plugin-transform-numeric-separator@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.28.6.tgz"
+  integrity sha512-SJR8hPynj8outz+SlStQSwvziMN4+Bq99it4tMIf5/Caq+3iOc0JtKyse8puvyXkk3eFRIA5ID/XfunGgO5i6w==
   dependencies:
-    "@babel/helper-compilation-targets" "^7.25.9"
-    "@babel/helper-plugin-utils" "^7.25.9"
-    "@babel/plugin-transform-parameters" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.28.6"
 
-"@babel/plugin-transform-object-super@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.25.9.tgz"
-  integrity sha512-Kj/Gh+Rw2RNLbCK1VAWj2U48yxxqL2x0k10nPtSdRa0O2xnHXalD0s+o1A6a0W43gJ00ANo38jxkQreckOzv5A==
+"@babel/plugin-transform-object-rest-spread@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.28.6.tgz"
+  integrity sha512-5rh+JR4JBC4pGkXLAcYdLHZjXudVxWMXbB6u6+E9lRL5TrGVbHt1TjxGbZ8CkmYw9zjkB7jutzOROArsqtncEA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
-    "@babel/helper-replace-supers" "^7.25.9"
+    "@babel/helper-compilation-targets" "^7.28.6"
+    "@babel/helper-plugin-utils" "^7.28.6"
+    "@babel/plugin-transform-destructuring" "^7.28.5"
+    "@babel/plugin-transform-parameters" "^7.27.7"
+    "@babel/traverse" "^7.28.6"
 
-"@babel/plugin-transform-optional-catch-binding@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.25.9.tgz"
-  integrity sha512-qM/6m6hQZzDcZF3onzIhZeDHDO43bkNNlOX0i8n3lR6zLbu0GN2d8qfM/IERJZYauhAHSLHy39NF0Ctdvcid7g==
+"@babel/plugin-transform-object-super@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.27.1.tgz"
+  integrity sha512-SFy8S9plRPbIcxlJ8A6mT/CxFdJx/c04JEctz4jf8YZaVS2px34j7NXRrlGlHkN/M2gnpL37ZpGRGVFLd3l8Ng==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/helper-replace-supers" "^7.27.1"
 
-"@babel/plugin-transform-optional-chaining@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.25.9.tgz"
-  integrity sha512-6AvV0FsLULbpnXeBjrY4dmWF8F7gf8QnvTEoO/wX/5xm/xE1Xo8oPuD3MPS+KS9f9XBEAWN7X1aWr4z9HdOr7A==
+"@babel/plugin-transform-optional-catch-binding@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.28.6.tgz"
+  integrity sha512-R8ja/Pyrv0OGAvAXQhSTmWyPJPml+0TMqXlO5w+AsMEiwb2fg3WkOvob7UxFSL3OIttFSGSRFKQsOhJ/X6HQdQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
-    "@babel/helper-skip-transparent-expression-wrappers" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.28.6"
 
-"@babel/plugin-transform-parameters@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.25.9.tgz"
-  integrity sha512-wzz6MKwpnshBAiRmn4jR8LYz/g8Ksg0o80XmwZDlordjwEk9SxBzTWC7F5ef1jhbrbOW2DJ5J6ayRukrJmnr0g==
+"@babel/plugin-transform-optional-chaining@^7.27.1", "@babel/plugin-transform-optional-chaining@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.28.6.tgz"
+  integrity sha512-A4zobikRGJTsX9uqVFdafzGkqD30t26ck2LmOzAuLL8b2x6k3TIqRiT2xVvA9fNmFeTX484VpsdgmKNA0bS23w==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.28.6"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.27.1"
 
-"@babel/plugin-transform-private-methods@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.25.9.tgz"
-  integrity sha512-D/JUozNpQLAPUVusvqMxyvjzllRaF8/nSrP1s2YGQT/W4LHK4xxsMcHjhOGTS01mp9Hda8nswb+FblLdJornQw==
+"@babel/plugin-transform-parameters@^7.27.7":
+  version "7.27.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.27.7.tgz"
+  integrity sha512-qBkYTYCb76RRxUM6CcZA5KRu8K4SM8ajzVeUgVdMVO9NN9uI/GaVmBg/WKJJGnNokV9SY8FxNOVWGXzqzUidBg==
   dependencies:
-    "@babel/helper-create-class-features-plugin" "^7.25.9"
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-private-property-in-object@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.25.9.tgz"
-  integrity sha512-Evf3kcMqzXA3xfYJmZ9Pg1OvKdtqsDMSWBDzZOPLvHiTt36E75jLDQo5w1gtRU95Q4E5PDttrTf25Fw8d/uWLw==
+"@babel/plugin-transform-private-methods@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.28.6.tgz"
+  integrity sha512-piiuapX9CRv7+0st8lmuUlRSmX6mBcVeNQ1b4AYzJxfCMuBfB0vBXDiGSmm03pKJw1v6cZ8KSeM+oUnM6yAExg==
   dependencies:
-    "@babel/helper-annotate-as-pure" "^7.25.9"
-    "@babel/helper-create-class-features-plugin" "^7.25.9"
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-create-class-features-plugin" "^7.28.6"
+    "@babel/helper-plugin-utils" "^7.28.6"
 
-"@babel/plugin-transform-property-literals@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.25.9.tgz"
-  integrity sha512-IvIUeV5KrS/VPavfSM/Iu+RE6llrHrYIKY1yfCzyO/lMXHQ+p7uGhonmGVisv6tSBSVgWzMBohTcvkC9vQcQFA==
+"@babel/plugin-transform-private-property-in-object@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.28.6.tgz"
+  integrity sha512-b97jvNSOb5+ehyQmBpmhOCiUC5oVK4PMnpRvO7+ymFBoqYjeDHIU9jnrNUuwHOiL9RpGDoKBpSViarV+BU+eVA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-annotate-as-pure" "^7.27.3"
+    "@babel/helper-create-class-features-plugin" "^7.28.6"
+    "@babel/helper-plugin-utils" "^7.28.6"
+
+"@babel/plugin-transform-property-literals@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.27.1.tgz"
+  integrity sha512-oThy3BCuCha8kDZ8ZkgOg2exvPYUlprMukKQXI1r1pJ47NCvxfkEy8vK+r/hT9nF0Aa4H1WUPZZjHTFtAhGfmQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.27.1"
 
 "@babel/plugin-transform-react-constant-elements@^7.21.3":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-react-constant-elements/-/plugin-transform-react-constant-elements-7.25.9.tgz"
-  integrity sha512-Ncw2JFsJVuvfRsa2lSHiC55kETQVLSnsYGQ1JDDwkUeWGTL/8Tom8aLTnlqgoeuopWrbbGndrc9AlLYrIosrow==
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-react-constant-elements/-/plugin-transform-react-constant-elements-7.27.1.tgz"
+  integrity sha512-edoidOjl/ZxvYo4lSBOQGDSyToYVkTAwyVoa2tkuYTSmjrB1+uAedoL5iROVLXkxH+vRgA7uP4tMg2pUJpZ3Ug==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-react-display-name@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-react-display-name/-/plugin-transform-react-display-name-7.25.9.tgz"
-  integrity sha512-KJfMlYIUxQB1CJfO3e0+h0ZHWOTLCPP115Awhaz8U0Zpq36Gl/cXlpoyMRnUWlhNUBAzldnCiAZNvCDj7CrKxQ==
+"@babel/plugin-transform-react-display-name@^7.28.0":
+  version "7.28.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-react-display-name/-/plugin-transform-react-display-name-7.28.0.tgz"
+  integrity sha512-D6Eujc2zMxKjfa4Zxl4GHMsmhKKZ9VpcqIchJLvwTxad9zWIYulwYItBovpDOoNLISpcZSXoDJ5gaGbQUDqViA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-react-jsx-development@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-development/-/plugin-transform-react-jsx-development-7.25.9.tgz"
-  integrity sha512-9mj6rm7XVYs4mdLIpbZnHOYdpW42uoiBCTVowg7sP1thUOiANgMb4UtpRivR0pp5iL+ocvUv7X4mZgFRpJEzGw==
+"@babel/plugin-transform-react-jsx-development@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-react-jsx-development/-/plugin-transform-react-jsx-development-7.27.1.tgz"
+  integrity sha512-ykDdF5yI4f1WrAolLqeF3hmYU12j9ntLQl/AOG1HAS21jxyg1Q0/J/tpREuYLfatGdGmXp/3yS0ZA76kOlVq9Q==
   dependencies:
-    "@babel/plugin-transform-react-jsx" "^7.25.9"
+    "@babel/plugin-transform-react-jsx" "^7.27.1"
 
-"@babel/plugin-transform-react-jsx@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.25.9.tgz"
-  integrity sha512-s5XwpQYCqGerXl+Pu6VDL3x0j2d82eiV77UJ8a2mDHAW7j9SWRqQ2y1fNo1Z74CdcYipl5Z41zvjj4Nfzq36rw==
+"@babel/plugin-transform-react-jsx@^7.27.1":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.28.6.tgz"
+  integrity sha512-61bxqhiRfAACulXSLd/GxqmAedUSrRZIu/cbaT18T1CetkTmtDN15it7i80ru4DVqRK1WMxQhXs+Lf9kajm5Ow==
   dependencies:
-    "@babel/helper-annotate-as-pure" "^7.25.9"
-    "@babel/helper-module-imports" "^7.25.9"
-    "@babel/helper-plugin-utils" "^7.25.9"
-    "@babel/plugin-syntax-jsx" "^7.25.9"
-    "@babel/types" "^7.25.9"
+    "@babel/helper-annotate-as-pure" "^7.27.3"
+    "@babel/helper-module-imports" "^7.28.6"
+    "@babel/helper-plugin-utils" "^7.28.6"
+    "@babel/plugin-syntax-jsx" "^7.28.6"
+    "@babel/types" "^7.28.6"
 
-"@babel/plugin-transform-react-pure-annotations@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-react-pure-annotations/-/plugin-transform-react-pure-annotations-7.25.9.tgz"
-  integrity sha512-KQ/Takk3T8Qzj5TppkS1be588lkbTp5uj7w6a0LeQaTMSckU/wK0oJ/pih+T690tkgI5jfmg2TqDJvd41Sj1Cg==
+"@babel/plugin-transform-react-pure-annotations@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-react-pure-annotations/-/plugin-transform-react-pure-annotations-7.27.1.tgz"
+  integrity sha512-JfuinvDOsD9FVMTHpzA/pBLisxpv1aSf+OIV8lgH3MuWrks19R27e6a6DipIg4aX1Zm9Wpb04p8wljfKrVSnPA==
   dependencies:
-    "@babel/helper-annotate-as-pure" "^7.25.9"
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-annotate-as-pure" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-regenerator@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.25.9.tgz"
-  integrity sha512-vwDcDNsgMPDGP0nMqzahDWE5/MLcX8sv96+wfX7as7LoF/kr97Bo/7fI00lXY4wUXYfVmwIIyG80fGZ1uvt2qg==
+"@babel/plugin-transform-regenerator@^7.29.0":
+  version "7.29.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.29.0.tgz"
+  integrity sha512-FijqlqMA7DmRdg/aINBSs04y8XNTYw/lr1gJ2WsmBnnaNw1iS43EPkJW+zK7z65auG3AWRFXWj+NcTQwYptUog==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
-    regenerator-transform "^0.15.2"
+    "@babel/helper-plugin-utils" "^7.28.6"
 
-"@babel/plugin-transform-regexp-modifiers@^7.26.0":
-  version "7.26.0"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-regexp-modifiers/-/plugin-transform-regexp-modifiers-7.26.0.tgz"
-  integrity sha512-vN6saax7lrA2yA/Pak3sCxuD6F5InBjn9IcrIKQPjpsLvuHYLVroTxjdlVRHjjBWxKOqIwpTXDkOssYT4BFdRw==
+"@babel/plugin-transform-regexp-modifiers@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-regexp-modifiers/-/plugin-transform-regexp-modifiers-7.28.6.tgz"
+  integrity sha512-QGWAepm9qxpaIs7UM9FvUSnCGlb8Ua1RhyM4/veAxLwt3gMat/LSGrZixyuj4I6+Kn9iwvqCyPTtbdxanYoWYg==
   dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.25.9"
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-create-regexp-features-plugin" "^7.28.5"
+    "@babel/helper-plugin-utils" "^7.28.6"
 
-"@babel/plugin-transform-reserved-words@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.25.9.tgz"
-  integrity sha512-7DL7DKYjn5Su++4RXu8puKZm2XBPHyjWLUidaPEkCUBbE7IPcsrkRHggAOOKydH1dASWdcUBxrkOGNxUv5P3Jg==
+"@babel/plugin-transform-reserved-words@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.27.1.tgz"
+  integrity sha512-V2ABPHIJX4kC7HegLkYoDpfg9PVmuWy/i6vUM5eGK22bx4YVFD3M5F0QQnWQoDs6AGsUWTVOopBiMFQgHaSkVw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
 "@babel/plugin-transform-runtime@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-runtime/-/plugin-transform-runtime-7.25.9.tgz"
-  integrity sha512-nZp7GlEl+yULJrClz0SwHPqir3lc0zsPrDHQUcxGspSL7AKrexNSEfTbfqnDNJUO13bgKyfuOLMF8Xqtu8j3YQ==
-  dependencies:
-    "@babel/helper-module-imports" "^7.25.9"
-    "@babel/helper-plugin-utils" "^7.25.9"
-    babel-plugin-polyfill-corejs2 "^0.4.10"
-    babel-plugin-polyfill-corejs3 "^0.10.6"
-    babel-plugin-polyfill-regenerator "^0.6.1"
+  version "7.29.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-runtime/-/plugin-transform-runtime-7.29.0.tgz"
+  integrity sha512-jlaRT5dJtMaMCV6fAuLbsQMSwz/QkvaHOHOSXRitGGwSpR1blCY4KUKoyP2tYO8vJcqYe8cEj96cqSztv3uF9w==
+  dependencies:
+    "@babel/helper-module-imports" "^7.28.6"
+    "@babel/helper-plugin-utils" "^7.28.6"
+    babel-plugin-polyfill-corejs2 "^0.4.14"
+    babel-plugin-polyfill-corejs3 "^0.13.0"
+    babel-plugin-polyfill-regenerator "^0.6.5"
     semver "^6.3.1"
 
-"@babel/plugin-transform-shorthand-properties@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.25.9.tgz"
-  integrity sha512-MUv6t0FhO5qHnS/W8XCbHmiRWOphNufpE1IVxhK5kuN3Td9FT1x4rx4K42s3RYdMXCXpfWkGSbCSd0Z64xA7Ng==
+"@babel/plugin-transform-shorthand-properties@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.27.1.tgz"
+  integrity sha512-N/wH1vcn4oYawbJ13Y/FxcQrWk63jhfNa7jef0ih7PHSIHX2LB7GWE1rkPrOnka9kwMxb6hMl19p7lidA+EHmQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-spread@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.25.9.tgz"
-  integrity sha512-oNknIB0TbURU5pqJFVbOOFspVlrpVwo2H1+HUIsVDvp5VauGGDP1ZEvO8Nn5xyMEs3dakajOxlmkNW7kNgSm6A==
+"@babel/plugin-transform-spread@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-spread/-/plugin-transform-spread-7.28.6.tgz"
+  integrity sha512-9U4QObUC0FtJl05AsUcodau/RWDytrU6uKgkxu09mLR9HLDAtUMoPuuskm5huQsoktmsYpI+bGmq+iapDcriKA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
-    "@babel/helper-skip-transparent-expression-wrappers" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.28.6"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.27.1"
 
-"@babel/plugin-transform-sticky-regex@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.25.9.tgz"
-  integrity sha512-WqBUSgeVwucYDP9U/xNRQam7xV8W5Zf+6Eo7T2SRVUFlhRiMNFdFz58u0KZmCVVqs2i7SHgpRnAhzRNmKfi2uA==
+"@babel/plugin-transform-sticky-regex@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.27.1.tgz"
+  integrity sha512-lhInBO5bi/Kowe2/aLdBAawijx+q1pQzicSgnkB6dUPc1+RC8QmJHKf2OjvU+NZWitguJHEaEmbV6VWEouT58g==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-template-literals@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.25.9.tgz"
-  integrity sha512-o97AE4syN71M/lxrCtQByzphAdlYluKPDBzDVzMmfCobUjjhAryZV0AIpRPrxN0eAkxXO6ZLEScmt+PNhj2OTw==
+"@babel/plugin-transform-template-literals@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.27.1.tgz"
+  integrity sha512-fBJKiV7F2DxZUkg5EtHKXQdbsbURW3DZKQUWphDum0uRP6eHGGa/He9mc0mypL680pb+e/lDIthRohlv8NCHkg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-typeof-symbol@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.25.9.tgz"
-  integrity sha512-v61XqUMiueJROUv66BVIOi0Fv/CUuZuZMl5NkRoCVxLAnMexZ0A3kMe7vvZ0nulxMuMp0Mk6S5hNh48yki08ZA==
+"@babel/plugin-transform-typeof-symbol@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.27.1.tgz"
+  integrity sha512-RiSILC+nRJM7FY5srIyc4/fGIwUhyDuuBSdWn4y6yT6gm652DpCHZjIipgn6B7MQ1ITOUnAKWixEUjQRIBIcLw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-typescript@^7.25.9":
-  version "7.26.3"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.26.3.tgz"
-  integrity sha512-6+5hpdr6mETwSKjmJUdYw0EIkATiQhnELWlE3kJFBwSg/BGIVwVaVbX+gOXBCdc7Ln1RXZxyWGecIXhUfnl7oA==
+"@babel/plugin-transform-typescript@^7.28.5":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.28.6.tgz"
+  integrity sha512-0YWL2RFxOqEm9Efk5PvreamxPME8OyY0wM5wh5lHjF+VtVhdneCWGzZeSqzOfiobVqQaNCd2z0tQvnI9DaPWPw==
   dependencies:
-    "@babel/helper-annotate-as-pure" "^7.25.9"
-    "@babel/helper-create-class-features-plugin" "^7.25.9"
-    "@babel/helper-plugin-utils" "^7.25.9"
-    "@babel/helper-skip-transparent-expression-wrappers" "^7.25.9"
-    "@babel/plugin-syntax-typescript" "^7.25.9"
+    "@babel/helper-annotate-as-pure" "^7.27.3"
+    "@babel/helper-create-class-features-plugin" "^7.28.6"
+    "@babel/helper-plugin-utils" "^7.28.6"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.27.1"
+    "@babel/plugin-syntax-typescript" "^7.28.6"
 
-"@babel/plugin-transform-unicode-escapes@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.25.9.tgz"
-  integrity sha512-s5EDrE6bW97LtxOcGj1Khcx5AaXwiMmi4toFWRDP9/y0Woo6pXC+iyPu/KuhKtfSrNFd7jJB+/fkOtZy6aIC6Q==
+"@babel/plugin-transform-unicode-escapes@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.27.1.tgz"
+  integrity sha512-Ysg4v6AmF26k9vpfFuTZg8HRfVWzsh1kVfowA23y9j/Gu6dOuahdUVhkLqpObp3JIv27MLSii6noRnuKN8H0Mg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-unicode-property-regex@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.25.9.tgz"
-  integrity sha512-Jt2d8Ga+QwRluxRQ307Vlxa6dMrYEMZCgGxoPR8V52rxPyldHu3hdlHspxaqYmE7oID5+kB+UKUB/eWS+DkkWg==
+"@babel/plugin-transform-unicode-property-regex@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.28.6.tgz"
+  integrity sha512-4Wlbdl/sIZjzi/8St0evF0gEZrgOswVO6aOzqxh1kDZOl9WmLrHq2HtGhnOJZmHZYKP8WZ1MDLCt5DAWwRo57A==
   dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.25.9"
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-create-regexp-features-plugin" "^7.28.5"
+    "@babel/helper-plugin-utils" "^7.28.6"
 
-"@babel/plugin-transform-unicode-regex@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.25.9.tgz"
-  integrity sha512-yoxstj7Rg9dlNn9UQxzk4fcNivwv4nUYz7fYXBaKxvw/lnmPuOm/ikoELygbYq68Bls3D/D+NBPHiLwZdZZ4HA==
+"@babel/plugin-transform-unicode-regex@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.27.1.tgz"
+  integrity sha512-xvINq24TRojDuyt6JGtHmkVkrfVV3FPT16uytxImLeBZqW3/H52yN+kM1MGuyPkIQxrzKwPHs5U/MP3qKyzkGw==
   dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.25.9"
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-create-regexp-features-plugin" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-unicode-sets-regex@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.25.9.tgz"
-  integrity sha512-8BYqO3GeVNHtx69fdPshN3fnzUNLrWdHhk/icSwigksJGczKSizZ+Z6SBCxTs723Fr5VSNorTIK7a+R2tISvwQ==
+"@babel/plugin-transform-unicode-sets-regex@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.28.6.tgz"
+  integrity sha512-/wHc/paTUmsDYN7SZkpWxogTOBNnlx7nBQYfy6JJlCT7G3mVhltk3e++N7zV0XfgGsrqBxd4rJQt9H16I21Y1Q==
   dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.25.9"
-    "@babel/helper-plugin-utils" "^7.25.9"
+    "@babel/helper-create-regexp-features-plugin" "^7.28.5"
+    "@babel/helper-plugin-utils" "^7.28.6"
 
 "@babel/preset-env@^7.20.2", "@babel/preset-env@^7.25.9":
-  version "7.26.0"
-  resolved "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.26.0.tgz"
-  integrity sha512-H84Fxq0CQJNdPFT2DrfnylZ3cf5K43rGfWK4LJGPpjKHiZlk0/RzwEus3PDDZZg+/Er7lCA03MVacueUuXdzfw==
-  dependencies:
-    "@babel/compat-data" "^7.26.0"
-    "@babel/helper-compilation-targets" "^7.25.9"
-    "@babel/helper-plugin-utils" "^7.25.9"
-    "@babel/helper-validator-option" "^7.25.9"
-    "@babel/plugin-bugfix-firefox-class-in-computed-class-key" "^7.25.9"
-    "@babel/plugin-bugfix-safari-class-field-initializer-scope" "^7.25.9"
-    "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression" "^7.25.9"
-    "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining" "^7.25.9"
-    "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly" "^7.25.9"
+  version "7.29.2"
+  resolved "https://registry.yarnpkg.com/@babel/preset-env/-/preset-env-7.29.2.tgz"
+  integrity sha512-DYD23veRYGvBFhcTY1iUvJnDNpuqNd/BzBwCvzOTKUnJjKg5kpUBh3/u9585Agdkgj+QuygG7jLfOPWMa2KVNw==
+  dependencies:
+    "@babel/compat-data" "^7.29.0"
+    "@babel/helper-compilation-targets" "^7.28.6"
+    "@babel/helper-plugin-utils" "^7.28.6"
+    "@babel/helper-validator-option" "^7.27.1"
+    "@babel/plugin-bugfix-firefox-class-in-computed-class-key" "^7.28.5"
+    "@babel/plugin-bugfix-safari-class-field-initializer-scope" "^7.27.1"
+    "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression" "^7.27.1"
+    "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining" "^7.27.1"
+    "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly" "^7.28.6"
     "@babel/plugin-proposal-private-property-in-object" "7.21.0-placeholder-for-preset-env.2"
-    "@babel/plugin-syntax-import-assertions" "^7.26.0"
-    "@babel/plugin-syntax-import-attributes" "^7.26.0"
+    "@babel/plugin-syntax-import-assertions" "^7.28.6"
+    "@babel/plugin-syntax-import-attributes" "^7.28.6"
     "@babel/plugin-syntax-unicode-sets-regex" "^7.18.6"
-    "@babel/plugin-transform-arrow-functions" "^7.25.9"
-    "@babel/plugin-transform-async-generator-functions" "^7.25.9"
-    "@babel/plugin-transform-async-to-generator" "^7.25.9"
-    "@babel/plugin-transform-block-scoped-functions" "^7.25.9"
-    "@babel/plugin-transform-block-scoping" "^7.25.9"
-    "@babel/plugin-transform-class-properties" "^7.25.9"
-    "@babel/plugin-transform-class-static-block" "^7.26.0"
-    "@babel/plugin-transform-classes" "^7.25.9"
-    "@babel/plugin-transform-computed-properties" "^7.25.9"
-    "@babel/plugin-transform-destructuring" "^7.25.9"
-    "@babel/plugin-transform-dotall-regex" "^7.25.9"
-    "@babel/plugin-transform-duplicate-keys" "^7.25.9"
-    "@babel/plugin-transform-duplicate-named-capturing-groups-regex" "^7.25.9"
-    "@babel/plugin-transform-dynamic-import" "^7.25.9"
-    "@babel/plugin-transform-exponentiation-operator" "^7.25.9"
-    "@babel/plugin-transform-export-namespace-from" "^7.25.9"
-    "@babel/plugin-transform-for-of" "^7.25.9"
-    "@babel/plugin-transform-function-name" "^7.25.9"
-    "@babel/plugin-transform-json-strings" "^7.25.9"
-    "@babel/plugin-transform-literals" "^7.25.9"
-    "@babel/plugin-transform-logical-assignment-operators" "^7.25.9"
-    "@babel/plugin-transform-member-expression-literals" "^7.25.9"
-    "@babel/plugin-transform-modules-amd" "^7.25.9"
-    "@babel/plugin-transform-modules-commonjs" "^7.25.9"
-    "@babel/plugin-transform-modules-systemjs" "^7.25.9"
-    "@babel/plugin-transform-modules-umd" "^7.25.9"
-    "@babel/plugin-transform-named-capturing-groups-regex" "^7.25.9"
-    "@babel/plugin-transform-new-target" "^7.25.9"
-    "@babel/plugin-transform-nullish-coalescing-operator" "^7.25.9"
-    "@babel/plugin-transform-numeric-separator" "^7.25.9"
-    "@babel/plugin-transform-object-rest-spread" "^7.25.9"
-    "@babel/plugin-transform-object-super" "^7.25.9"
-    "@babel/plugin-transform-optional-catch-binding" "^7.25.9"
-    "@babel/plugin-transform-optional-chaining" "^7.25.9"
-    "@babel/plugin-transform-parameters" "^7.25.9"
-    "@babel/plugin-transform-private-methods" "^7.25.9"
-    "@babel/plugin-transform-private-property-in-object" "^7.25.9"
-    "@babel/plugin-transform-property-literals" "^7.25.9"
-    "@babel/plugin-transform-regenerator" "^7.25.9"
-    "@babel/plugin-transform-regexp-modifiers" "^7.26.0"
-    "@babel/plugin-transform-reserved-words" "^7.25.9"
-    "@babel/plugin-transform-shorthand-properties" "^7.25.9"
-    "@babel/plugin-transform-spread" "^7.25.9"
-    "@babel/plugin-transform-sticky-regex" "^7.25.9"
-    "@babel/plugin-transform-template-literals" "^7.25.9"
-    "@babel/plugin-transform-typeof-symbol" "^7.25.9"
-    "@babel/plugin-transform-unicode-escapes" "^7.25.9"
-    "@babel/plugin-transform-unicode-property-regex" "^7.25.9"
-    "@babel/plugin-transform-unicode-regex" "^7.25.9"
-    "@babel/plugin-transform-unicode-sets-regex" "^7.25.9"
+    "@babel/plugin-transform-arrow-functions" "^7.27.1"
+    "@babel/plugin-transform-async-generator-functions" "^7.29.0"
+    "@babel/plugin-transform-async-to-generator" "^7.28.6"
+    "@babel/plugin-transform-block-scoped-functions" "^7.27.1"
+    "@babel/plugin-transform-block-scoping" "^7.28.6"
+    "@babel/plugin-transform-class-properties" "^7.28.6"
+    "@babel/plugin-transform-class-static-block" "^7.28.6"
+    "@babel/plugin-transform-classes" "^7.28.6"
+    "@babel/plugin-transform-computed-properties" "^7.28.6"
+    "@babel/plugin-transform-destructuring" "^7.28.5"
+    "@babel/plugin-transform-dotall-regex" "^7.28.6"
+    "@babel/plugin-transform-duplicate-keys" "^7.27.1"
+    "@babel/plugin-transform-duplicate-named-capturing-groups-regex" "^7.29.0"
+    "@babel/plugin-transform-dynamic-import" "^7.27.1"
+    "@babel/plugin-transform-explicit-resource-management" "^7.28.6"
+    "@babel/plugin-transform-exponentiation-operator" "^7.28.6"
+    "@babel/plugin-transform-export-namespace-from" "^7.27.1"
+    "@babel/plugin-transform-for-of" "^7.27.1"
+    "@babel/plugin-transform-function-name" "^7.27.1"
+    "@babel/plugin-transform-json-strings" "^7.28.6"
+    "@babel/plugin-transform-literals" "^7.27.1"
+    "@babel/plugin-transform-logical-assignment-operators" "^7.28.6"
+    "@babel/plugin-transform-member-expression-literals" "^7.27.1"
+    "@babel/plugin-transform-modules-amd" "^7.27.1"
+    "@babel/plugin-transform-modules-commonjs" "^7.28.6"
+    "@babel/plugin-transform-modules-systemjs" "^7.29.0"
+    "@babel/plugin-transform-modules-umd" "^7.27.1"
+    "@babel/plugin-transform-named-capturing-groups-regex" "^7.29.0"
+    "@babel/plugin-transform-new-target" "^7.27.1"
+    "@babel/plugin-transform-nullish-coalescing-operator" "^7.28.6"
+    "@babel/plugin-transform-numeric-separator" "^7.28.6"
+    "@babel/plugin-transform-object-rest-spread" "^7.28.6"
+    "@babel/plugin-transform-object-super" "^7.27.1"
+    "@babel/plugin-transform-optional-catch-binding" "^7.28.6"
+    "@babel/plugin-transform-optional-chaining" "^7.28.6"
+    "@babel/plugin-transform-parameters" "^7.27.7"
+    "@babel/plugin-transform-private-methods" "^7.28.6"
+    "@babel/plugin-transform-private-property-in-object" "^7.28.6"
+    "@babel/plugin-transform-property-literals" "^7.27.1"
+    "@babel/plugin-transform-regenerator" "^7.29.0"
+    "@babel/plugin-transform-regexp-modifiers" "^7.28.6"
+    "@babel/plugin-transform-reserved-words" "^7.27.1"
+    "@babel/plugin-transform-shorthand-properties" "^7.27.1"
+    "@babel/plugin-transform-spread" "^7.28.6"
+    "@babel/plugin-transform-sticky-regex" "^7.27.1"
+    "@babel/plugin-transform-template-literals" "^7.27.1"
+    "@babel/plugin-transform-typeof-symbol" "^7.27.1"
+    "@babel/plugin-transform-unicode-escapes" "^7.27.1"
+    "@babel/plugin-transform-unicode-property-regex" "^7.28.6"
+    "@babel/plugin-transform-unicode-regex" "^7.27.1"
+    "@babel/plugin-transform-unicode-sets-regex" "^7.28.6"
     "@babel/preset-modules" "0.1.6-no-external-plugins"
-    babel-plugin-polyfill-corejs2 "^0.4.10"
-    babel-plugin-polyfill-corejs3 "^0.10.6"
-    babel-plugin-polyfill-regenerator "^0.6.1"
-    core-js-compat "^3.38.1"
+    babel-plugin-polyfill-corejs2 "^0.4.15"
+    babel-plugin-polyfill-corejs3 "^0.14.0"
+    babel-plugin-polyfill-regenerator "^0.6.6"
+    core-js-compat "^3.48.0"
     semver "^6.3.1"
 
 "@babel/preset-modules@0.1.6-no-external-plugins":
   version "0.1.6-no-external-plugins"
-  resolved "https://registry.npmjs.org/@babel/preset-modules/-/preset-modules-0.1.6-no-external-plugins.tgz"
+  resolved "https://registry.yarnpkg.com/@babel/preset-modules/-/preset-modules-0.1.6-no-external-plugins.tgz"
   integrity sha512-HrcgcIESLm9aIR842yhJ5RWan/gebQUJ6E/E5+rf0y9o6oj7w0Br+sWuL6kEQ/o/AdfvR1Je9jG18/gnpwjEyA==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
@@ -1100,424 +1010,490 @@
     esutils "^2.0.2"
 
 "@babel/preset-react@^7.18.6", "@babel/preset-react@^7.25.9":
-  version "7.26.3"
-  resolved "https://registry.npmjs.org/@babel/preset-react/-/preset-react-7.26.3.tgz"
-  integrity sha512-Nl03d6T9ky516DGK2YMxrTqvnpUW63TnJMOMonj+Zae0JiPC5BC9xPMSL6L8fiSpA5vP88qfygavVQvnLp+6Cw==
+  version "7.28.5"
+  resolved "https://registry.yarnpkg.com/@babel/preset-react/-/preset-react-7.28.5.tgz"
+  integrity sha512-Z3J8vhRq7CeLjdC58jLv4lnZ5RKFUJWqH5emvxmv9Hv3BD1T9R/Im713R4MTKwvFaV74ejZ3sM01LyEKk4ugNQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
-    "@babel/helper-validator-option" "^7.25.9"
-    "@babel/plugin-transform-react-display-name" "^7.25.9"
-    "@babel/plugin-transform-react-jsx" "^7.25.9"
-    "@babel/plugin-transform-react-jsx-development" "^7.25.9"
-    "@babel/plugin-transform-react-pure-annotations" "^7.25.9"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/helper-validator-option" "^7.27.1"
+    "@babel/plugin-transform-react-display-name" "^7.28.0"
+    "@babel/plugin-transform-react-jsx" "^7.27.1"
+    "@babel/plugin-transform-react-jsx-development" "^7.27.1"
+    "@babel/plugin-transform-react-pure-annotations" "^7.27.1"
 
 "@babel/preset-typescript@^7.21.0", "@babel/preset-typescript@^7.25.9":
-  version "7.26.0"
-  resolved "https://registry.npmjs.org/@babel/preset-typescript/-/preset-typescript-7.26.0.tgz"
-  integrity sha512-NMk1IGZ5I/oHhoXEElcm+xUnL/szL6xflkFZmoEU9xj1qSJXpiS7rsspYo92B4DRCDvZn2erT5LdsCeXAKNCkg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.25.9"
-    "@babel/helper-validator-option" "^7.25.9"
-    "@babel/plugin-syntax-jsx" "^7.25.9"
-    "@babel/plugin-transform-modules-commonjs" "^7.25.9"
-    "@babel/plugin-transform-typescript" "^7.25.9"
-
-"@babel/runtime-corejs3@^7.25.9":
-  version "7.26.0"
-  resolved "https://registry.npmjs.org/@babel/runtime-corejs3/-/runtime-corejs3-7.26.0.tgz"
-  integrity sha512-YXHu5lN8kJCb1LOb9PgV6pvak43X2h4HvRApcN5SdWeaItQOzfn1hgP6jasD6KWQyJDBxrVmA9o9OivlnNJK/w==
-  dependencies:
-    core-js-pure "^3.30.2"
-    regenerator-runtime "^0.14.0"
-
-"@babel/runtime@^7.1.2", "@babel/runtime@^7.10.3", "@babel/runtime@^7.12.13", "@babel/runtime@^7.12.5", "@babel/runtime@^7.25.9", "@babel/runtime@^7.8.4":
-  version "7.26.0"
-  resolved "https://registry.npmjs.org/@babel/runtime/-/runtime-7.26.0.tgz"
-  integrity sha512-FDSOghenHTiToteC/QRlv2q3DhPZ/oOXTBoirfWNx1Cx3TMVcGWQtMMmQcSvb/JjpNeGzx8Pq/b4fKEJuWm1sw==
-  dependencies:
-    regenerator-runtime "^0.14.0"
-
-"@babel/template@^7.25.9":
-  version "7.25.9"
-  resolved "https://registry.npmjs.org/@babel/template/-/template-7.25.9.tgz"
-  integrity sha512-9DGttpmPvIxBb/2uwpVo3dqJ+O6RooAFOS+lB+xDqoE2PVCE8nfoHMdZLpfCQRLwvohzXISPZcgxt80xLfsuwg==
-  dependencies:
-    "@babel/code-frame" "^7.25.9"
-    "@babel/parser" "^7.25.9"
-    "@babel/types" "^7.25.9"
-
-"@babel/traverse@^7.25.9":
-  version "7.26.4"
-  resolved "https://registry.npmjs.org/@babel/traverse/-/traverse-7.26.4.tgz"
-  integrity sha512-fH+b7Y4p3yqvApJALCPJcwb0/XaOSgtK4pzV6WVjPR5GLFQBRI7pfoX2V2iM48NXvX07NUxxm1Vw98YjqTcU5w==
-  dependencies:
-    "@babel/code-frame" "^7.26.2"
-    "@babel/generator" "^7.26.3"
-    "@babel/parser" "^7.26.3"
-    "@babel/template" "^7.25.9"
-    "@babel/types" "^7.26.3"
+  version "7.28.5"
+  resolved "https://registry.yarnpkg.com/@babel/preset-typescript/-/preset-typescript-7.28.5.tgz"
+  integrity sha512-+bQy5WOI2V6LJZpPVxY+yp66XdZ2yifu0Mc1aP5CQKgjn4QM5IN2i5fAZ4xKop47pr8rpVhiAeu+nDQa12C8+g==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/helper-validator-option" "^7.27.1"
+    "@babel/plugin-syntax-jsx" "^7.27.1"
+    "@babel/plugin-transform-modules-commonjs" "^7.27.1"
+    "@babel/plugin-transform-typescript" "^7.28.5"
+
+"@babel/runtime@^7.1.2", "@babel/runtime@^7.10.3", "@babel/runtime@^7.12.13", "@babel/runtime@^7.12.5", "@babel/runtime@^7.25.9":
+  version "7.29.2"
+  resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.29.2.tgz"
+  integrity sha512-JiDShH45zKHWyGe4ZNVRrCjBz8Nh9TMmZG1kh4QTK8hCBTWBi8Da+i7s1fJw7/lYpM4ccepSNfqzZ/QvABBi5g==
+
+"@babel/template@^7.28.6":
+  version "7.28.6"
+  resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.28.6.tgz"
+  integrity sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==
+  dependencies:
+    "@babel/code-frame" "^7.28.6"
+    "@babel/parser" "^7.28.6"
+    "@babel/types" "^7.28.6"
+
+"@babel/traverse@^7.25.9", "@babel/traverse@^7.27.1", "@babel/traverse@^7.28.5", "@babel/traverse@^7.28.6", "@babel/traverse@^7.29.0":
+  version "7.29.0"
+  resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.29.0.tgz"
+  integrity sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==
+  dependencies:
+    "@babel/code-frame" "^7.29.0"
+    "@babel/generator" "^7.29.0"
+    "@babel/helper-globals" "^7.28.0"
+    "@babel/parser" "^7.29.0"
+    "@babel/template" "^7.28.6"
+    "@babel/types" "^7.29.0"
     debug "^4.3.1"
-    globals "^11.1.0"
 
-"@babel/types@^7.21.3", "@babel/types@^7.25.9", "@babel/types@^7.26.0", "@babel/types@^7.26.3", "@babel/types@^7.4.4":
-  version "7.26.3"
-  resolved "https://registry.npmjs.org/@babel/types/-/types-7.26.3.tgz"
-  integrity sha512-vN5p+1kl59GVKMvTHt55NzzmYVxprfJD+ql7U9NFIfKCBkYE55LYtS+WtPlaYOyzydrKI8Nezd+aZextrd+FMA==
+"@babel/types@^7.21.3", "@babel/types@^7.27.1", "@babel/types@^7.27.3", "@babel/types@^7.28.5", "@babel/types@^7.28.6", "@babel/types@^7.29.0", "@babel/types@^7.4.4":
+  version "7.29.0"
+  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.29.0.tgz"
+  integrity sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==
   dependencies:
-    "@babel/helper-string-parser" "^7.25.9"
-    "@babel/helper-validator-identifier" "^7.25.9"
+    "@babel/helper-string-parser" "^7.27.1"
+    "@babel/helper-validator-identifier" "^7.28.5"
 
 "@colors/colors@1.5.0":
   version "1.5.0"
-  resolved "https://registry.npmjs.org/@colors/colors/-/colors-1.5.0.tgz"
+  resolved "https://registry.yarnpkg.com/@colors/colors/-/colors-1.5.0.tgz"
   integrity sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==
 
-"@csstools/cascade-layer-name-parser@^2.0.4":
-  version "2.0.4"
-  resolved "https://registry.npmjs.org/@csstools/cascade-layer-name-parser/-/cascade-layer-name-parser-2.0.4.tgz"
-  integrity sha512-7DFHlPuIxviKYZrOiwVU/PiHLm3lLUR23OMuEEtfEOQTOp9hzQ2JjdY6X5H18RVuUPJqSCI+qNnD5iOLMVE0bA==
+"@csstools/cascade-layer-name-parser@^2.0.5":
+  version "2.0.5"
+  resolved "https://registry.yarnpkg.com/@csstools/cascade-layer-name-parser/-/cascade-layer-name-parser-2.0.5.tgz"
+  integrity sha512-p1ko5eHgV+MgXFVa4STPKpvPxr6ReS8oS2jzTukjR74i5zJNyWO1ZM1m8YKBXnzDKWfBN1ztLYlHxbVemDD88A==
 
-"@csstools/color-helpers@^5.0.1":
-  version "5.0.1"
-  resolved "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-5.0.1.tgz"
-  integrity sha512-MKtmkA0BX87PKaO1NFRTFH+UnkgnmySQOvNxJubsadusqPEC2aJ9MOQiMceZJJ6oitUl/i0L6u0M1IrmAOmgBA==
+"@csstools/color-helpers@^5.1.0":
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/@csstools/color-helpers/-/color-helpers-5.1.0.tgz"
+  integrity sha512-S11EXWJyy0Mz5SYvRmY8nJYTFFd1LCNV+7cXyAgQtOOuzb4EsgfqDufL+9esx72/eLhsRdGZwaldu/h+E4t4BA==
 
-"@csstools/css-calc@^2.1.1":
-  version "2.1.1"
-  resolved "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-2.1.1.tgz"
-  integrity sha512-rL7kaUnTkL9K+Cvo2pnCieqNpTKgQzy5f+N+5Iuko9HAoasP+xgprVh7KN/MaJVvVL1l0EzQq2MoqBHKSrDrag==
+"@csstools/css-calc@^2.1.4":
+  version "2.1.4"
+  resolved "https://registry.yarnpkg.com/@csstools/css-calc/-/css-calc-2.1.4.tgz"
+  integrity sha512-3N8oaj+0juUw/1H3YwmDDJXCgTB1gKU6Hc/bB502u9zR0q2vd786XJH9QfrKIEgFlZmhZiq6epXl4rHqhzsIgQ==
 
-"@csstools/css-color-parser@^3.0.7":
-  version "3.0.7"
-  resolved "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-3.0.7.tgz"
-  integrity sha512-nkMp2mTICw32uE5NN+EsJ4f5N+IGFeCFu4bGpiKgb2Pq/7J/MpyLBeQ5ry4KKtRFZaYs6sTmcMYrSRIyj5DFKA==
+"@csstools/css-color-parser@^3.1.0":
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/@csstools/css-color-parser/-/css-color-parser-3.1.0.tgz"
+  integrity sha512-nbtKwh3a6xNVIp/VRuXV64yTKnb1IjTAEEh3irzS+HkKjAOYLTGNb9pmVNntZ8iVBHcWDA2Dof0QtPgFI1BaTA==
   dependencies:
-    "@csstools/color-helpers" "^5.0.1"
-    "@csstools/css-calc" "^2.1.1"
+    "@csstools/color-helpers" "^5.1.0"
+    "@csstools/css-calc" "^2.1.4"
 
-"@csstools/css-parser-algorithms@^3.0.4":
+"@csstools/css-parser-algorithms@^3.0.5":
+  version "3.0.5"
+  resolved "https://registry.yarnpkg.com/@csstools/css-parser-algorithms/-/css-parser-algorithms-3.0.5.tgz"
+  integrity sha512-DaDeUkXZKjdGhgYaHNJTV9pV7Y9B3b644jCLs9Upc3VeNGg6LWARAT6O+Q+/COo+2gg/bM5rhpMAtf70WqfBdQ==
+
+"@csstools/css-tokenizer@^3.0.4":
   version "3.0.4"
-  resolved "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-3.0.4.tgz"
-  integrity sha512-Up7rBoV77rv29d3uKHUIVubz1BTcgyUK72IvCQAbfbMv584xHcGKCKbWh7i8hPrRJ7qU4Y8IO3IY9m+iTB7P3A==
+  resolved "https://registry.yarnpkg.com/@csstools/css-tokenizer/-/css-tokenizer-3.0.4.tgz"
+  integrity sha512-Vd/9EVDiu6PPJt9yAh6roZP6El1xHrdvIVGjyBsHR0RYwNHgL7FJPyIIW4fANJNG6FtyZfvlRPpFI4ZM/lubvw==
 
-"@csstools/css-tokenizer@^3.0.3":
-  version "3.0.3"
-  resolved "https://registry.npmjs.org/@csstools/css-tokenizer/-/css-tokenizer-3.0.3.tgz"
-  integrity sha512-UJnjoFsmxfKUdNYdWgOB0mWUypuLvAfQPH1+pyvRJs6euowbFkFC6P13w1l8mJyi3vxYMxc9kld5jZEGRQs6bw==
+"@csstools/media-query-list-parser@^4.0.3":
+  version "4.0.3"
+  resolved "https://registry.yarnpkg.com/@csstools/media-query-list-parser/-/media-query-list-parser-4.0.3.tgz"
+  integrity sha512-HAYH7d3TLRHDOUQK4mZKf9k9Ph/m8Akstg66ywKR4SFAigjs3yBiUeZtFxywiTm5moZMAp/5W/ZuFnNXXYLuuQ==
 
-"@csstools/media-query-list-parser@^4.0.2":
-  version "4.0.2"
-  resolved "https://registry.npmjs.org/@csstools/media-query-list-parser/-/media-query-list-parser-4.0.2.tgz"
-  integrity sha512-EUos465uvVvMJehckATTlNqGj4UJWkTmdWuDMjqvSUkjGpmOyFZBVwb4knxCm/k2GMTXY+c/5RkdndzFYWeX5A==
+"@csstools/postcss-alpha-function@^1.0.1":
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-alpha-function/-/postcss-alpha-function-1.0.1.tgz"
+  integrity sha512-isfLLwksH3yHkFXfCI2Gcaqg7wGGHZZwunoJzEZk0yKYIokgre6hYVFibKL3SYAoR1kBXova8LB+JoO5vZzi9w==
+  dependencies:
+    "@csstools/css-color-parser" "^3.1.0"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
+    "@csstools/postcss-progressive-custom-properties" "^4.2.1"
+    "@csstools/utilities" "^2.0.0"
 
-"@csstools/postcss-cascade-layers@^5.0.1":
-  version "5.0.1"
-  resolved "https://registry.npmjs.org/@csstools/postcss-cascade-layers/-/postcss-cascade-layers-5.0.1.tgz"
-  integrity sha512-XOfhI7GShVcKiKwmPAnWSqd2tBR0uxt+runAxttbSp/LY2U16yAVPmAf7e9q4JJ0d+xMNmpwNDLBXnmRCl3HMQ==
+"@csstools/postcss-cascade-layers@^5.0.2":
+  version "5.0.2"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-cascade-layers/-/postcss-cascade-layers-5.0.2.tgz"
+  integrity sha512-nWBE08nhO8uWl6kSAeCx4im7QfVko3zLrtgWZY4/bP87zrSPpSyN/3W3TDqz1jJuH+kbKOHXg5rJnK+ZVYcFFg==
   dependencies:
     "@csstools/selector-specificity" "^5.0.0"
     postcss-selector-parser "^7.0.0"
 
-"@csstools/postcss-color-function@^4.0.7":
-  version "4.0.7"
-  resolved "https://registry.npmjs.org/@csstools/postcss-color-function/-/postcss-color-function-4.0.7.tgz"
-  integrity sha512-aDHYmhNIHR6iLw4ElWhf+tRqqaXwKnMl0YsQ/X105Zc4dQwe6yJpMrTN6BwOoESrkDjOYMOfORviSSLeDTJkdQ==
+"@csstools/postcss-color-function-display-p3-linear@^1.0.1":
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-color-function-display-p3-linear/-/postcss-color-function-display-p3-linear-1.0.1.tgz"
+  integrity sha512-E5qusdzhlmO1TztYzDIi8XPdPoYOjoTY6HBYBCYSj+Gn4gQRBlvjgPQXzfzuPQqt8EhkC/SzPKObg4Mbn8/xMg==
   dependencies:
-    "@csstools/css-color-parser" "^3.0.7"
-    "@csstools/css-parser-algorithms" "^3.0.4"
-    "@csstools/css-tokenizer" "^3.0.3"
-    "@csstools/postcss-progressive-custom-properties" "^4.0.0"
+    "@csstools/css-color-parser" "^3.1.0"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
+    "@csstools/postcss-progressive-custom-properties" "^4.2.1"
     "@csstools/utilities" "^2.0.0"
 
-"@csstools/postcss-color-mix-function@^3.0.7":
-  version "3.0.7"
-  resolved "https://registry.npmjs.org/@csstools/postcss-color-mix-function/-/postcss-color-mix-function-3.0.7.tgz"
-  integrity sha512-e68Nev4CxZYCLcrfWhHH4u/N1YocOfTmw67/kVX5Rb7rnguqqLyxPjhHWjSBX8o4bmyuukmNf3wrUSU3//kT7g==
+"@csstools/postcss-color-function@^4.0.12":
+  version "4.0.12"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-color-function/-/postcss-color-function-4.0.12.tgz"
+  integrity sha512-yx3cljQKRaSBc2hfh8rMZFZzChaFgwmO2JfFgFr1vMcF3C/uyy5I4RFIBOIWGq1D+XbKCG789CGkG6zzkLpagA==
   dependencies:
-    "@csstools/css-color-parser" "^3.0.7"
-    "@csstools/css-parser-algorithms" "^3.0.4"
-    "@csstools/css-tokenizer" "^3.0.3"
-    "@csstools/postcss-progressive-custom-properties" "^4.0.0"
+    "@csstools/css-color-parser" "^3.1.0"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
+    "@csstools/postcss-progressive-custom-properties" "^4.2.1"
     "@csstools/utilities" "^2.0.0"
 
-"@csstools/postcss-content-alt-text@^2.0.4":
-  version "2.0.4"
-  resolved "https://registry.npmjs.org/@csstools/postcss-content-alt-text/-/postcss-content-alt-text-2.0.4.tgz"
-  integrity sha512-YItlZUOuZJCBlRaCf8Aucc1lgN41qYGALMly0qQllrxYJhiyzlI6RxOTMUvtWk+KhS8GphMDsDhKQ7KTPfEMSw==
+"@csstools/postcss-color-mix-function@^3.0.12":
+  version "3.0.12"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-color-mix-function/-/postcss-color-mix-function-3.0.12.tgz"
+  integrity sha512-4STERZfCP5Jcs13P1U5pTvI9SkgLgfMUMhdXW8IlJWkzOOOqhZIjcNhWtNJZes2nkBDsIKJ0CJtFtuaZ00moag==
   dependencies:
-    "@csstools/css-parser-algorithms" "^3.0.4"
-    "@csstools/css-tokenizer" "^3.0.3"
-    "@csstools/postcss-progressive-custom-properties" "^4.0.0"
+    "@csstools/css-color-parser" "^3.1.0"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
+    "@csstools/postcss-progressive-custom-properties" "^4.2.1"
     "@csstools/utilities" "^2.0.0"
 
-"@csstools/postcss-exponential-functions@^2.0.6":
-  version "2.0.6"
-  resolved "https://registry.npmjs.org/@csstools/postcss-exponential-functions/-/postcss-exponential-functions-2.0.6.tgz"
-  integrity sha512-IgJA5DQsQLu/upA3HcdvC6xEMR051ufebBTIXZ5E9/9iiaA7juXWz1ceYj814lnDYP/7eWjZnw0grRJlX4eI6g==
+"@csstools/postcss-color-mix-variadic-function-arguments@^1.0.2":
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-color-mix-variadic-function-arguments/-/postcss-color-mix-variadic-function-arguments-1.0.2.tgz"
+  integrity sha512-rM67Gp9lRAkTo+X31DUqMEq+iK+EFqsidfecmhrteErxJZb6tUoJBVQca1Vn1GpDql1s1rD1pKcuYzMsg7Z1KQ==
+  dependencies:
+    "@csstools/css-color-parser" "^3.1.0"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
+    "@csstools/postcss-progressive-custom-properties" "^4.2.1"
+    "@csstools/utilities" "^2.0.0"
+
+"@csstools/postcss-content-alt-text@^2.0.8":
+  version "2.0.8"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-content-alt-text/-/postcss-content-alt-text-2.0.8.tgz"
+  integrity sha512-9SfEW9QCxEpTlNMnpSqFaHyzsiRpZ5J5+KqCu1u5/eEJAWsMhzT40qf0FIbeeglEvrGRMdDzAxMIz3wqoGSb+Q==
   dependencies:
-    "@csstools/css-calc" "^2.1.1"
-    "@csstools/css-parser-algorithms" "^3.0.4"
-    "@csstools/css-tokenizer" "^3.0.3"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
+    "@csstools/postcss-progressive-custom-properties" "^4.2.1"
+    "@csstools/utilities" "^2.0.0"
+
+"@csstools/postcss-contrast-color-function@^2.0.12":
+  version "2.0.12"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-contrast-color-function/-/postcss-contrast-color-function-2.0.12.tgz"
+  integrity sha512-YbwWckjK3qwKjeYz/CijgcS7WDUCtKTd8ShLztm3/i5dhh4NaqzsbYnhm4bjrpFpnLZ31jVcbK8YL77z3GBPzA==
+  dependencies:
+    "@csstools/css-color-parser" "^3.1.0"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
+    "@csstools/postcss-progressive-custom-properties" "^4.2.1"
+    "@csstools/utilities" "^2.0.0"
+
+"@csstools/postcss-exponential-functions@^2.0.9":
+  version "2.0.9"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-exponential-functions/-/postcss-exponential-functions-2.0.9.tgz"
+  integrity sha512-abg2W/PI3HXwS/CZshSa79kNWNZHdJPMBXeZNyPQFbbj8sKO3jXxOt/wF7juJVjyDTc6JrvaUZYFcSBZBhaxjw==
+  dependencies:
+    "@csstools/css-calc" "^2.1.4"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
 
 "@csstools/postcss-font-format-keywords@^4.0.0":
   version "4.0.0"
-  resolved "https://registry.npmjs.org/@csstools/postcss-font-format-keywords/-/postcss-font-format-keywords-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-font-format-keywords/-/postcss-font-format-keywords-4.0.0.tgz"
   integrity sha512-usBzw9aCRDvchpok6C+4TXC57btc4bJtmKQWOHQxOVKen1ZfVqBUuCZ/wuqdX5GHsD0NRSr9XTP+5ID1ZZQBXw==
   dependencies:
     "@csstools/utilities" "^2.0.0"
     postcss-value-parser "^4.2.0"
 
-"@csstools/postcss-gamut-mapping@^2.0.7":
-  version "2.0.7"
-  resolved "https://registry.npmjs.org/@csstools/postcss-gamut-mapping/-/postcss-gamut-mapping-2.0.7.tgz"
-  integrity sha512-gzFEZPoOkY0HqGdyeBXR3JP218Owr683u7KOZazTK7tQZBE8s2yhg06W1tshOqk7R7SWvw9gkw2TQogKpIW8Xw==
-  dependencies:
-    "@csstools/css-color-parser" "^3.0.7"
-    "@csstools/css-parser-algorithms" "^3.0.4"
-    "@csstools/css-tokenizer" "^3.0.3"
-
-"@csstools/postcss-gradients-interpolation-method@^5.0.7":
-  version "5.0.7"
-  resolved "https://registry.npmjs.org/@csstools/postcss-gradients-interpolation-method/-/postcss-gradients-interpolation-method-5.0.7.tgz"
-  integrity sha512-WgEyBeg6glUeTdS2XT7qeTFBthTJuXlS9GFro/DVomj7W7WMTamAwpoP4oQCq/0Ki2gvfRYFi/uZtmRE14/DFA==
-  dependencies:
-    "@csstools/css-color-parser" "^3.0.7"
-    "@csstools/css-parser-algorithms" "^3.0.4"
-    "@csstools/css-tokenizer" "^3.0.3"
-    "@csstools/postcss-progressive-custom-properties" "^4.0.0"
+"@csstools/postcss-gamut-mapping@^2.0.11":
+  version "2.0.11"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-gamut-mapping/-/postcss-gamut-mapping-2.0.11.tgz"
+  integrity sha512-fCpCUgZNE2piVJKC76zFsgVW1apF6dpYsqGyH8SIeCcM4pTEsRTWTLCaJIMKFEundsCKwY1rwfhtrio04RJ4Dw==
+  dependencies:
+    "@csstools/css-color-parser" "^3.1.0"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
+
+"@csstools/postcss-gradients-interpolation-method@^5.0.12":
+  version "5.0.12"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-gradients-interpolation-method/-/postcss-gradients-interpolation-method-5.0.12.tgz"
+  integrity sha512-jugzjwkUY0wtNrZlFeyXzimUL3hN4xMvoPnIXxoZqxDvjZRiSh+itgHcVUWzJ2VwD/VAMEgCLvtaJHX+4Vj3Ow==
+  dependencies:
+    "@csstools/css-color-parser" "^3.1.0"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
+    "@csstools/postcss-progressive-custom-properties" "^4.2.1"
     "@csstools/utilities" "^2.0.0"
 
-"@csstools/postcss-hwb-function@^4.0.7":
-  version "4.0.7"
-  resolved "https://registry.npmjs.org/@csstools/postcss-hwb-function/-/postcss-hwb-function-4.0.7.tgz"
-  integrity sha512-LKYqjO+wGwDCfNIEllessCBWfR4MS/sS1WXO+j00KKyOjm7jDW2L6jzUmqASEiv/kkJO39GcoIOvTTfB3yeBUA==
+"@csstools/postcss-hwb-function@^4.0.12":
+  version "4.0.12"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-hwb-function/-/postcss-hwb-function-4.0.12.tgz"
+  integrity sha512-mL/+88Z53KrE4JdePYFJAQWFrcADEqsLprExCM04GDNgHIztwFzj0Mbhd/yxMBngq0NIlz58VVxjt5abNs1VhA==
   dependencies:
-    "@csstools/css-color-parser" "^3.0.7"
-    "@csstools/css-parser-algorithms" "^3.0.4"
-    "@csstools/css-tokenizer" "^3.0.3"
-    "@csstools/postcss-progressive-custom-properties" "^4.0.0"
+    "@csstools/css-color-parser" "^3.1.0"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
+    "@csstools/postcss-progressive-custom-properties" "^4.2.1"
     "@csstools/utilities" "^2.0.0"
 
-"@csstools/postcss-ic-unit@^4.0.0":
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/@csstools/postcss-ic-unit/-/postcss-ic-unit-4.0.0.tgz"
-  integrity sha512-9QT5TDGgx7wD3EEMN3BSUG6ckb6Eh5gSPT5kZoVtUuAonfPmLDJyPhqR4ntPpMYhUKAMVKAg3I/AgzqHMSeLhA==
+"@csstools/postcss-ic-unit@^4.0.4":
+  version "4.0.4"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-ic-unit/-/postcss-ic-unit-4.0.4.tgz"
+  integrity sha512-yQ4VmossuOAql65sCPppVO1yfb7hDscf4GseF0VCA/DTDaBc0Wtf8MTqVPfjGYlT5+2buokG0Gp7y0atYZpwjg==
   dependencies:
-    "@csstools/postcss-progressive-custom-properties" "^4.0.0"
+    "@csstools/postcss-progressive-custom-properties" "^4.2.1"
     "@csstools/utilities" "^2.0.0"
     postcss-value-parser "^4.2.0"
 
-"@csstools/postcss-initial@^2.0.0":
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/@csstools/postcss-initial/-/postcss-initial-2.0.0.tgz"
-  integrity sha512-dv2lNUKR+JV+OOhZm9paWzYBXOCi+rJPqJ2cJuhh9xd8USVrd0cBEPczla81HNOyThMQWeCcdln3gZkQV2kYxA==
+"@csstools/postcss-initial@^2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-initial/-/postcss-initial-2.0.1.tgz"
+  integrity sha512-L1wLVMSAZ4wovznquK0xmC7QSctzO4D0Is590bxpGqhqjboLXYA16dWZpfwImkdOgACdQ9PqXsuRroW6qPlEsg==
 
-"@csstools/postcss-is-pseudo-class@^5.0.1":
-  version "5.0.1"
-  resolved "https://registry.npmjs.org/@csstools/postcss-is-pseudo-class/-/postcss-is-pseudo-class-5.0.1.tgz"
-  integrity sha512-JLp3POui4S1auhDR0n8wHd/zTOWmMsmK3nQd3hhL6FhWPaox5W7j1se6zXOG/aP07wV2ww0lxbKYGwbBszOtfQ==
+"@csstools/postcss-is-pseudo-class@^5.0.3":
+  version "5.0.3"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-is-pseudo-class/-/postcss-is-pseudo-class-5.0.3.tgz"
+  integrity sha512-jS/TY4SpG4gszAtIg7Qnf3AS2pjcUM5SzxpApOrlndMeGhIbaTzWBzzP/IApXoNWEW7OhcjkRT48jnAUIFXhAQ==
   dependencies:
     "@csstools/selector-specificity" "^5.0.0"
     postcss-selector-parser "^7.0.0"
 
-"@csstools/postcss-light-dark-function@^2.0.7":
-  version "2.0.7"
-  resolved "https://registry.npmjs.org/@csstools/postcss-light-dark-function/-/postcss-light-dark-function-2.0.7.tgz"
-  integrity sha512-ZZ0rwlanYKOHekyIPaU+sVm3BEHCe+Ha0/px+bmHe62n0Uc1lL34vbwrLYn6ote8PHlsqzKeTQdIejQCJ05tfw==
+"@csstools/postcss-light-dark-function@^2.0.11":
+  version "2.0.11"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-light-dark-function/-/postcss-light-dark-function-2.0.11.tgz"
+  integrity sha512-fNJcKXJdPM3Lyrbmgw2OBbaioU7yuKZtiXClf4sGdQttitijYlZMD5K7HrC/eF83VRWRrYq6OZ0Lx92leV2LFA==
   dependencies:
-    "@csstools/css-parser-algorithms" "^3.0.4"
-    "@csstools/css-tokenizer" "^3.0.3"
-    "@csstools/postcss-progressive-custom-properties" "^4.0.0"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
+    "@csstools/postcss-progressive-custom-properties" "^4.2.1"
     "@csstools/utilities" "^2.0.0"
 
 "@csstools/postcss-logical-float-and-clear@^3.0.0":
   version "3.0.0"
-  resolved "https://registry.npmjs.org/@csstools/postcss-logical-float-and-clear/-/postcss-logical-float-and-clear-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-logical-float-and-clear/-/postcss-logical-float-and-clear-3.0.0.tgz"
   integrity sha512-SEmaHMszwakI2rqKRJgE+8rpotFfne1ZS6bZqBoQIicFyV+xT1UF42eORPxJkVJVrH9C0ctUgwMSn3BLOIZldQ==
 
 "@csstools/postcss-logical-overflow@^2.0.0":
   version "2.0.0"
-  resolved "https://registry.npmjs.org/@csstools/postcss-logical-overflow/-/postcss-logical-overflow-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-logical-overflow/-/postcss-logical-overflow-2.0.0.tgz"
   integrity sha512-spzR1MInxPuXKEX2csMamshR4LRaSZ3UXVaRGjeQxl70ySxOhMpP2252RAFsg8QyyBXBzuVOOdx1+bVO5bPIzA==
 
 "@csstools/postcss-logical-overscroll-behavior@^2.0.0":
   version "2.0.0"
-  resolved "https://registry.npmjs.org/@csstools/postcss-logical-overscroll-behavior/-/postcss-logical-overscroll-behavior-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-logical-overscroll-behavior/-/postcss-logical-overscroll-behavior-2.0.0.tgz"
   integrity sha512-e/webMjoGOSYfqLunyzByZj5KKe5oyVg/YSbie99VEaSDE2kimFm0q1f6t/6Jo+VVCQ/jbe2Xy+uX+C4xzWs4w==
 
 "@csstools/postcss-logical-resize@^3.0.0":
   version "3.0.0"
-  resolved "https://registry.npmjs.org/@csstools/postcss-logical-resize/-/postcss-logical-resize-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-logical-resize/-/postcss-logical-resize-3.0.0.tgz"
   integrity sha512-DFbHQOFW/+I+MY4Ycd/QN6Dg4Hcbb50elIJCfnwkRTCX05G11SwViI5BbBlg9iHRl4ytB7pmY5ieAFk3ws7yyg==
   dependencies:
     postcss-value-parser "^4.2.0"
 
-"@csstools/postcss-logical-viewport-units@^3.0.3":
-  version "3.0.3"
-  resolved "https://registry.npmjs.org/@csstools/postcss-logical-viewport-units/-/postcss-logical-viewport-units-3.0.3.tgz"
-  integrity sha512-OC1IlG/yoGJdi0Y+7duz/kU/beCwO+Gua01sD6GtOtLi7ByQUpcIqs7UE/xuRPay4cHgOMatWdnDdsIDjnWpPw==
+"@csstools/postcss-logical-viewport-units@^3.0.4":
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-logical-viewport-units/-/postcss-logical-viewport-units-3.0.4.tgz"
+  integrity sha512-q+eHV1haXA4w9xBwZLKjVKAWn3W2CMqmpNpZUk5kRprvSiBEGMgrNH3/sJZ8UA3JgyHaOt3jwT9uFa4wLX4EqQ==
   dependencies:
-    "@csstools/css-tokenizer" "^3.0.3"
+    "@csstools/css-tokenizer" "^3.0.4"
     "@csstools/utilities" "^2.0.0"
 
-"@csstools/postcss-media-minmax@^2.0.6":
-  version "2.0.6"
-  resolved "https://registry.npmjs.org/@csstools/postcss-media-minmax/-/postcss-media-minmax-2.0.6.tgz"
-  integrity sha512-J1+4Fr2W3pLZsfxkFazK+9kr96LhEYqoeBszLmFjb6AjYs+g9oDAw3J5oQignLKk3rC9XHW+ebPTZ9FaW5u5pg==
+"@csstools/postcss-media-minmax@^2.0.9":
+  version "2.0.9"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-media-minmax/-/postcss-media-minmax-2.0.9.tgz"
+  integrity sha512-af9Qw3uS3JhYLnCbqtZ9crTvvkR+0Se+bBqSr7ykAnl9yKhk6895z9rf+2F4dClIDJWxgn0iZZ1PSdkhrbs2ig==
   dependencies:
-    "@csstools/css-calc" "^2.1.1"
-    "@csstools/css-parser-algorithms" "^3.0.4"
-    "@csstools/css-tokenizer" "^3.0.3"
-    "@csstools/media-query-list-parser" "^4.0.2"
+    "@csstools/css-calc" "^2.1.4"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
+    "@csstools/media-query-list-parser" "^4.0.3"
 
-"@csstools/postcss-media-queries-aspect-ratio-number-values@^3.0.4":
-  version "3.0.4"
-  resolved "https://registry.npmjs.org/@csstools/postcss-media-queries-aspect-ratio-number-values/-/postcss-media-queries-aspect-ratio-number-values-3.0.4.tgz"
-  integrity sha512-AnGjVslHMm5xw9keusQYvjVWvuS7KWK+OJagaG0+m9QnIjZsrysD2kJP/tr/UJIyYtMCtu8OkUd+Rajb4DqtIQ==
+"@csstools/postcss-media-queries-aspect-ratio-number-values@^3.0.5":
+  version "3.0.5"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-media-queries-aspect-ratio-number-values/-/postcss-media-queries-aspect-ratio-number-values-3.0.5.tgz"
+  integrity sha512-zhAe31xaaXOY2Px8IYfoVTB3wglbJUVigGphFLj6exb7cjZRH9A6adyE22XfFK3P2PzwRk0VDeTJmaxpluyrDg==
   dependencies:
-    "@csstools/css-parser-algorithms" "^3.0.4"
-    "@csstools/css-tokenizer" "^3.0.3"
-    "@csstools/media-query-list-parser" "^4.0.2"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
+    "@csstools/media-query-list-parser" "^4.0.3"
 
 "@csstools/postcss-nested-calc@^4.0.0":
   version "4.0.0"
-  resolved "https://registry.npmjs.org/@csstools/postcss-nested-calc/-/postcss-nested-calc-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-nested-calc/-/postcss-nested-calc-4.0.0.tgz"
   integrity sha512-jMYDdqrQQxE7k9+KjstC3NbsmC063n1FTPLCgCRS2/qHUbHM0mNy9pIn4QIiQGs9I/Bg98vMqw7mJXBxa0N88A==
   dependencies:
     "@csstools/utilities" "^2.0.0"
     postcss-value-parser "^4.2.0"
 
-"@csstools/postcss-normalize-display-values@^4.0.0":
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/@csstools/postcss-normalize-display-values/-/postcss-normalize-display-values-4.0.0.tgz"
-  integrity sha512-HlEoG0IDRoHXzXnkV4in47dzsxdsjdz6+j7MLjaACABX2NfvjFS6XVAnpaDyGesz9gK2SC7MbNwdCHusObKJ9Q==
+"@csstools/postcss-normalize-display-values@^4.0.1":
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-normalize-display-values/-/postcss-normalize-display-values-4.0.1.tgz"
+  integrity sha512-TQUGBuRvxdc7TgNSTevYqrL8oItxiwPDixk20qCB5me/W8uF7BPbhRrAvFuhEoywQp/woRsUZ6SJ+sU5idZAIA==
   dependencies:
     postcss-value-parser "^4.2.0"
 
-"@csstools/postcss-oklab-function@^4.0.7":
-  version "4.0.7"
-  resolved "https://registry.npmjs.org/@csstools/postcss-oklab-function/-/postcss-oklab-function-4.0.7.tgz"
-  integrity sha512-I6WFQIbEKG2IO3vhaMGZDkucbCaUSXMxvHNzDdnfsTCF5tc0UlV3Oe2AhamatQoKFjBi75dSEMrgWq3+RegsOQ==
+"@csstools/postcss-oklab-function@^4.0.12":
+  version "4.0.12"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-oklab-function/-/postcss-oklab-function-4.0.12.tgz"
+  integrity sha512-HhlSmnE1NKBhXsTnNGjxvhryKtO7tJd1w42DKOGFD6jSHtYOrsJTQDKPMwvOfrzUAk8t7GcpIfRyM7ssqHpFjg==
   dependencies:
-    "@csstools/css-color-parser" "^3.0.7"
-    "@csstools/css-parser-algorithms" "^3.0.4"
-    "@csstools/css-tokenizer" "^3.0.3"
-    "@csstools/postcss-progressive-custom-properties" "^4.0.0"
+    "@csstools/css-color-parser" "^3.1.0"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
+    "@csstools/postcss-progressive-custom-properties" "^4.2.1"
     "@csstools/utilities" "^2.0.0"
 
-"@csstools/postcss-progressive-custom-properties@^4.0.0":
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/@csstools/postcss-progressive-custom-properties/-/postcss-progressive-custom-properties-4.0.0.tgz"
-  integrity sha512-XQPtROaQjomnvLUSy/bALTR5VCtTVUFwYs1SblvYgLSeTo2a/bMNwUwo2piXw5rTv/FEYiy5yPSXBqg9OKUx7Q==
+"@csstools/postcss-position-area-property@^1.0.0":
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-position-area-property/-/postcss-position-area-property-1.0.0.tgz"
+  integrity sha512-fUP6KR8qV2NuUZV3Cw8itx0Ep90aRjAZxAEzC3vrl6yjFv+pFsQbR18UuQctEKmA72K9O27CoYiKEgXxkqjg8Q==
+
+"@csstools/postcss-progressive-custom-properties@^4.2.1":
+  version "4.2.1"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-progressive-custom-properties/-/postcss-progressive-custom-properties-4.2.1.tgz"
+  integrity sha512-uPiiXf7IEKtUQXsxu6uWtOlRMXd2QWWy5fhxHDnPdXKCQckPP3E34ZgDoZ62r2iT+UOgWsSbM4NvHE5m3mAEdw==
   dependencies:
     postcss-value-parser "^4.2.0"
 
-"@csstools/postcss-random-function@^1.0.2":
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/@csstools/postcss-random-function/-/postcss-random-function-1.0.2.tgz"
-  integrity sha512-vBCT6JvgdEkvRc91NFoNrLjgGtkLWt47GKT6E2UDn3nd8ZkMBiziQ1Md1OiKoSsgzxsSnGKG3RVdhlbdZEkHjA==
+"@csstools/postcss-property-rule-prelude-list@^1.0.0":
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-property-rule-prelude-list/-/postcss-property-rule-prelude-list-1.0.0.tgz"
+  integrity sha512-IxuQjUXq19fobgmSSvUDO7fVwijDJaZMvWQugxfEUxmjBeDCVaDuMpsZ31MsTm5xbnhA+ElDi0+rQ7sQQGisFA==
   dependencies:
-    "@csstools/css-calc" "^2.1.1"
-    "@csstools/css-parser-algorithms" "^3.0.4"
-    "@csstools/css-tokenizer" "^3.0.3"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
 
-"@csstools/postcss-relative-color-syntax@^3.0.7":
-  version "3.0.7"
-  resolved "https://registry.npmjs.org/@csstools/postcss-relative-color-syntax/-/postcss-relative-color-syntax-3.0.7.tgz"
-  integrity sha512-apbT31vsJVd18MabfPOnE977xgct5B1I+Jpf+Munw3n6kKb1MMuUmGGH+PT9Hm/fFs6fe61Q/EWnkrb4bNoNQw==
-  dependencies:
-    "@csstools/css-color-parser" "^3.0.7"
-    "@csstools/css-parser-algorithms" "^3.0.4"
-    "@csstools/css-tokenizer" "^3.0.3"
-    "@csstools/postcss-progressive-custom-properties" "^4.0.0"
+"@csstools/postcss-random-function@^2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-random-function/-/postcss-random-function-2.0.1.tgz"
+  integrity sha512-q+FQaNiRBhnoSNo+GzqGOIBKoHQ43lYz0ICrV+UudfWnEF6ksS6DsBIJSISKQT2Bvu3g4k6r7t0zYrk5pDlo8w==
+  dependencies:
+    "@csstools/css-calc" "^2.1.4"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
+
+"@csstools/postcss-relative-color-syntax@^3.0.12":
+  version "3.0.12"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-relative-color-syntax/-/postcss-relative-color-syntax-3.0.12.tgz"
+  integrity sha512-0RLIeONxu/mtxRtf3o41Lq2ghLimw0w9ByLWnnEVuy89exmEEq8bynveBxNW3nyHqLAFEeNtVEmC1QK9MZ8Huw==
+  dependencies:
+    "@csstools/css-color-parser" "^3.1.0"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
+    "@csstools/postcss-progressive-custom-properties" "^4.2.1"
     "@csstools/utilities" "^2.0.0"
 
 "@csstools/postcss-scope-pseudo-class@^4.0.1":
   version "4.0.1"
-  resolved "https://registry.npmjs.org/@csstools/postcss-scope-pseudo-class/-/postcss-scope-pseudo-class-4.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-scope-pseudo-class/-/postcss-scope-pseudo-class-4.0.1.tgz"
   integrity sha512-IMi9FwtH6LMNuLea1bjVMQAsUhFxJnyLSgOp/cpv5hrzWmrUYU5fm0EguNDIIOHUqzXode8F/1qkC/tEo/qN8Q==
   dependencies:
     postcss-selector-parser "^7.0.0"
 
-"@csstools/postcss-sign-functions@^1.1.1":
-  version "1.1.1"
-  resolved "https://registry.npmjs.org/@csstools/postcss-sign-functions/-/postcss-sign-functions-1.1.1.tgz"
-  integrity sha512-MslYkZCeMQDxetNkfmmQYgKCy4c+w9pPDfgOBCJOo/RI1RveEUdZQYtOfrC6cIZB7sD7/PHr2VGOcMXlZawrnA==
+"@csstools/postcss-sign-functions@^1.1.4":
+  version "1.1.4"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-sign-functions/-/postcss-sign-functions-1.1.4.tgz"
+  integrity sha512-P97h1XqRPcfcJndFdG95Gv/6ZzxUBBISem0IDqPZ7WMvc/wlO+yU0c5D/OCpZ5TJoTt63Ok3knGk64N+o6L2Pg==
   dependencies:
-    "@csstools/css-calc" "^2.1.1"
-    "@csstools/css-parser-algorithms" "^3.0.4"
-    "@csstools/css-tokenizer" "^3.0.3"
+    "@csstools/css-calc" "^2.1.4"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
 
-"@csstools/postcss-stepped-value-functions@^4.0.6":
-  version "4.0.6"
-  resolved "https://registry.npmjs.org/@csstools/postcss-stepped-value-functions/-/postcss-stepped-value-functions-4.0.6.tgz"
-  integrity sha512-/dwlO9w8vfKgiADxpxUbZOWlL5zKoRIsCymYoh1IPuBsXODKanKnfuZRr32DEqT0//3Av1VjfNZU9yhxtEfIeA==
+"@csstools/postcss-stepped-value-functions@^4.0.9":
+  version "4.0.9"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-stepped-value-functions/-/postcss-stepped-value-functions-4.0.9.tgz"
+  integrity sha512-h9btycWrsex4dNLeQfyU3y3w40LMQooJWFMm/SK9lrKguHDcFl4VMkncKKoXi2z5rM9YGWbUQABI8BT2UydIcA==
   dependencies:
-    "@csstools/css-calc" "^2.1.1"
-    "@csstools/css-parser-algorithms" "^3.0.4"
-    "@csstools/css-tokenizer" "^3.0.3"
+    "@csstools/css-calc" "^2.1.4"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
 
-"@csstools/postcss-text-decoration-shorthand@^4.0.1":
-  version "4.0.1"
-  resolved "https://registry.npmjs.org/@csstools/postcss-text-decoration-shorthand/-/postcss-text-decoration-shorthand-4.0.1.tgz"
-  integrity sha512-xPZIikbx6jyzWvhms27uugIc0I4ykH4keRvoa3rxX5K7lEhkbd54rjj/dv60qOCTisoS+3bmwJTeyV1VNBrXaw==
+"@csstools/postcss-syntax-descriptor-syntax-production@^1.0.1":
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-syntax-descriptor-syntax-production/-/postcss-syntax-descriptor-syntax-production-1.0.1.tgz"
+  integrity sha512-GneqQWefjM//f4hJ/Kbox0C6f2T7+pi4/fqTqOFGTL3EjnvOReTqO1qUQ30CaUjkwjYq9qZ41hzarrAxCc4gow==
   dependencies:
-    "@csstools/color-helpers" "^5.0.1"
+    "@csstools/css-tokenizer" "^3.0.4"
+
+"@csstools/postcss-system-ui-font-family@^1.0.0":
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-system-ui-font-family/-/postcss-system-ui-font-family-1.0.0.tgz"
+  integrity sha512-s3xdBvfWYfoPSBsikDXbuorcMG1nN1M6GdU0qBsGfcmNR0A/qhloQZpTxjA3Xsyrk1VJvwb2pOfiOT3at/DuIQ==
+  dependencies:
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
+
+"@csstools/postcss-text-decoration-shorthand@^4.0.3":
+  version "4.0.3"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-text-decoration-shorthand/-/postcss-text-decoration-shorthand-4.0.3.tgz"
+  integrity sha512-KSkGgZfx0kQjRIYnpsD7X2Om9BUXX/Kii77VBifQW9Ih929hK0KNjVngHDH0bFB9GmfWcR9vJYJJRvw/NQjkrA==
+  dependencies:
+    "@csstools/color-helpers" "^5.1.0"
     postcss-value-parser "^4.2.0"
 
-"@csstools/postcss-trigonometric-functions@^4.0.6":
-  version "4.0.6"
-  resolved "https://registry.npmjs.org/@csstools/postcss-trigonometric-functions/-/postcss-trigonometric-functions-4.0.6.tgz"
-  integrity sha512-c4Y1D2Why/PeccaSouXnTt6WcNHJkoJRidV2VW9s5gJ97cNxnLgQ4Qj8qOqkIR9VmTQKJyNcbF4hy79ZQnWD7A==
+"@csstools/postcss-trigonometric-functions@^4.0.9":
+  version "4.0.9"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-trigonometric-functions/-/postcss-trigonometric-functions-4.0.9.tgz"
+  integrity sha512-Hnh5zJUdpNrJqK9v1/E3BbrQhaDTj5YiX7P61TOvUhoDHnUmsNNxcDAgkQ32RrcWx9GVUvfUNPcUkn8R3vIX6A==
   dependencies:
-    "@csstools/css-calc" "^2.1.1"
-    "@csstools/css-parser-algorithms" "^3.0.4"
-    "@csstools/css-tokenizer" "^3.0.3"
+    "@csstools/css-calc" "^2.1.4"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
 
 "@csstools/postcss-unset-value@^4.0.0":
   version "4.0.0"
-  resolved "https://registry.npmjs.org/@csstools/postcss-unset-value/-/postcss-unset-value-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@csstools/postcss-unset-value/-/postcss-unset-value-4.0.0.tgz"
   integrity sha512-cBz3tOCI5Fw6NIFEwU3RiwK6mn3nKegjpJuzCndoGq3BZPkUjnsq7uQmIeMNeMbMk7YD2MfKcgCpZwX5jyXqCA==
 
-"@csstools/selector-resolve-nested@^3.0.0":
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/@csstools/selector-resolve-nested/-/selector-resolve-nested-3.0.0.tgz"
-  integrity sha512-ZoK24Yku6VJU1gS79a5PFmC8yn3wIapiKmPgun0hZgEI5AOqgH2kiPRsPz1qkGv4HL+wuDLH83yQyk6inMYrJQ==
+"@csstools/selector-resolve-nested@^3.1.0":
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/@csstools/selector-resolve-nested/-/selector-resolve-nested-3.1.0.tgz"
+  integrity sha512-mf1LEW0tJLKfWyvn5KdDrhpxHyuxpbNwTIwOYLIvsTffeyOf85j5oIzfG0yosxDgx/sswlqBnESYUcQH0vgZ0g==
 
 "@csstools/selector-specificity@^5.0.0":
   version "5.0.0"
-  resolved "https://registry.npmjs.org/@csstools/selector-specificity/-/selector-specificity-5.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@csstools/selector-specificity/-/selector-specificity-5.0.0.tgz"
   integrity sha512-PCqQV3c4CoVm3kdPhyeZ07VmBRdH2EpMFA/pd9OASpOEC3aXNGoqPDAZ80D0cLpMBxnmk0+yNhGsEx31hq7Gtw==
 
 "@csstools/utilities@^2.0.0":
   version "2.0.0"
-  resolved "https://registry.npmjs.org/@csstools/utilities/-/utilities-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@csstools/utilities/-/utilities-2.0.0.tgz"
   integrity sha512-5VdOr0Z71u+Yp3ozOx8T11N703wIFGVRgOWbOZMKgglPJsWA54MRIoMNVMa7shUToIhx5J8vX4sOZgD2XiihiQ==
 
 "@discoveryjs/json-ext@0.5.7":
   version "0.5.7"
-  resolved "https://registry.npmjs.org/@discoveryjs/json-ext/-/json-ext-0.5.7.tgz"
+  resolved "https://registry.yarnpkg.com/@discoveryjs/json-ext/-/json-ext-0.5.7.tgz"
   integrity sha512-dBVuXR082gk3jsFp7Rd/JI4kytwGHecnCoTtXFb7DB6CNHp4rg5k1bhg0nWdLGLnOV71lmDzGQaLMy8iPLY0pw==
 
-"@docsearch/css@3.8.2":
-  version "3.8.2"
-  resolved "https://registry.npmjs.org/@docsearch/css/-/css-3.8.2.tgz"
-  integrity sha512-y05ayQFyUmCXze79+56v/4HpycYF3uFqB78pLPrSV5ZKAlDuIAAJNhaRi8tTdRNXh05yxX/TyNnzD6LwSM89vQ==
+"@docsearch/core@4.6.3":
+  version "4.6.3"
+  resolved "https://registry.yarnpkg.com/@docsearch/core/-/core-4.6.3.tgz"
+  integrity sha512-rUOujwIpxJRgD7+kicVsI3D5sqBvdiRTquzWBpTEXZs8ZXfGbfzpus5HqumaNYTppN2HvH8E2yNuRwYdHJeOlA==
 
-"@docsearch/react@^3.5.2":
-  version "3.8.2"
-  resolved "https://registry.npmjs.org/@docsearch/react/-/react-3.8.2.tgz"
-  integrity sha512-xCRrJQlTt8N9GU0DG4ptwHRkfnSnD/YpdeaXe02iKfqs97TkZJv60yE+1eq/tjPcVnTW8dP5qLP7itifFVV5eg==
+"@docsearch/css@4.6.3":
+  version "4.6.3"
+  resolved "https://registry.yarnpkg.com/@docsearch/css/-/css-4.6.3.tgz"
+  integrity sha512-nlOwcXcsNAptQl4vlL4MA78qNJKO0Qlds5GuBjCoePgkebTXLSf8Qt1oyZ3YBshYupKXG9VRGEsk1zr23d+bzQ==
+
+"@docsearch/react@^3.9.0 || ^4.3.2":
+  version "4.6.3"
+  resolved "https://registry.yarnpkg.com/@docsearch/react/-/react-4.6.3.tgz"
+  integrity sha512-Bg2wdDsoQVlNCcEKuEJAU04tvHCqgx8rIu+uIoM4pRtcx3TBKJuXutJik3LTA8LRc9YEyHkrYUrmcC0D7BYf+g==
   dependencies:
-    "@algolia/autocomplete-core" "1.17.7"
-    "@algolia/autocomplete-preset-algolia" "1.17.7"
-    "@docsearch/css" "3.8.2"
-    algoliasearch "^5.14.2"
+    "@algolia/autocomplete-core" "1.19.2"
+    "@docsearch/core" "4.6.3"
+    "@docsearch/css" "4.6.3"
 
-"@docusaurus/babel@3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/babel/-/babel-3.6.3.tgz"
-  integrity sha512-7dW9Hat9EHYCVicFXYA4hjxBY38+hPuCURL8oRF9fySRm7vzNWuEOghA1TXcykuXZp0HLG2td4RhDxCvGG7tNw==
+"@docusaurus/babel@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/babel/-/babel-3.10.0.tgz"
+  integrity sha512-mqCJhCZNZUDg0zgDEaPTM4DnRsisa24HdqTy/qn/MQlbwhTb4WVaZg6ZyX6yIVKqTz8fS1hBMgM+98z+BeJJDg==
   dependencies:
     "@babel/core" "^7.25.9"
     "@babel/generator" "^7.25.9"
@@ -1527,57 +1503,55 @@
     "@babel/preset-react" "^7.25.9"
     "@babel/preset-typescript" "^7.25.9"
     "@babel/runtime" "^7.25.9"
-    "@babel/runtime-corejs3" "^7.25.9"
     "@babel/traverse" "^7.25.9"
-    "@docusaurus/logger" "3.6.3"
-    "@docusaurus/utils" "3.6.3"
+    "@docusaurus/logger" "3.10.0"
+    "@docusaurus/utils" "3.10.0"
     babel-plugin-dynamic-import-node "^2.3.3"
     fs-extra "^11.1.1"
     tslib "^2.6.0"
 
-"@docusaurus/bundler@3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/bundler/-/bundler-3.6.3.tgz"
-  integrity sha512-47JLuc8D4wA+6VOvmMd5fUC9rFppBQpQOnxDYiVXffm/DeV/wmm3sbpNd5Y+O+G2+nevLTRnvCm/qyancv0Y3A==
+"@docusaurus/bundler@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/bundler/-/bundler-3.10.0.tgz"
+  integrity sha512-iONUGZGgp+lAkw/cJZH6irONcF4p8+278IsdRlq8lYhxGjkoNUs0w7F4gVXBYSNChq5KG5/JleTSsdJySShxow==
   dependencies:
     "@babel/core" "^7.25.9"
-    "@docusaurus/babel" "3.6.3"
-    "@docusaurus/cssnano-preset" "3.6.3"
-    "@docusaurus/logger" "3.6.3"
-    "@docusaurus/types" "3.6.3"
-    "@docusaurus/utils" "3.6.3"
+    "@docusaurus/babel" "3.10.0"
+    "@docusaurus/cssnano-preset" "3.10.0"
+    "@docusaurus/logger" "3.10.0"
+    "@docusaurus/types" "3.10.0"
+    "@docusaurus/utils" "3.10.0"
     babel-loader "^9.2.1"
-    clean-css "^5.3.2"
+    clean-css "^5.3.3"
     copy-webpack-plugin "^11.0.0"
-    css-loader "^6.8.1"
+    css-loader "^6.11.0"
     css-minimizer-webpack-plugin "^5.0.1"
     cssnano "^6.1.2"
     file-loader "^6.2.0"
     html-minifier-terser "^7.2.0"
-    mini-css-extract-plugin "^2.9.1"
+    mini-css-extract-plugin "^2.9.2"
     null-loader "^4.0.1"
-    postcss "^8.4.26"
-    postcss-loader "^7.3.3"
-    postcss-preset-env "^10.1.0"
-    react-dev-utils "^12.0.1"
+    postcss "^8.5.4"
+    postcss-loader "^7.3.4"
+    postcss-preset-env "^10.2.1"
     terser-webpack-plugin "^5.3.9"
     tslib "^2.6.0"
     url-loader "^4.1.1"
     webpack "^5.95.0"
     webpackbar "^6.0.1"
 
-"@docusaurus/core@3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/core/-/core-3.6.3.tgz"
-  integrity sha512-xL7FRY9Jr5DWqB6pEnqgKqcMPJOX5V0pgWXi5lCiih11sUBmcFKM7c3+GyxcVeeWFxyYSDP3grLTWqJoP4P9Vw==
-  dependencies:
-    "@docusaurus/babel" "3.6.3"
-    "@docusaurus/bundler" "3.6.3"
-    "@docusaurus/logger" "3.6.3"
-    "@docusaurus/mdx-loader" "3.6.3"
-    "@docusaurus/utils" "3.6.3"
-    "@docusaurus/utils-common" "3.6.3"
-    "@docusaurus/utils-validation" "3.6.3"
+"@docusaurus/core@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/core/-/core-3.10.0.tgz"
+  integrity sha512-mgLdQsO8xppnQZc3LPi+Mf+PkPeyxJeIx11AXAq/14fsaMefInQiMEZUUmrc7J+956G/f7MwE7tn8KZgi3iRcA==
+  dependencies:
+    "@docusaurus/babel" "3.10.0"
+    "@docusaurus/bundler" "3.10.0"
+    "@docusaurus/logger" "3.10.0"
+    "@docusaurus/mdx-loader" "3.10.0"
+    "@docusaurus/utils" "3.10.0"
+    "@docusaurus/utils-common" "3.10.0"
+    "@docusaurus/utils-validation" "3.10.0"
     boxen "^6.2.1"
     chalk "^4.1.2"
     chokidar "^3.5.3"
@@ -1585,69 +1559,68 @@
     combine-promises "^1.1.0"
     commander "^5.1.0"
     core-js "^3.31.1"
-    del "^6.1.1"
     detect-port "^1.5.1"
     escape-html "^1.0.3"
     eta "^2.2.0"
     eval "^0.1.8"
+    execa "^5.1.1"
     fs-extra "^11.1.1"
     html-tags "^3.3.1"
     html-webpack-plugin "^5.6.0"
     leven "^3.1.0"
     lodash "^4.17.21"
+    open "^8.4.0"
     p-map "^4.0.0"
     prompts "^2.4.2"
-    react-dev-utils "^12.0.1"
-    react-helmet-async "^1.3.0"
+    react-helmet-async "npm:@slorber/react-helmet-async@1.3.0"
     react-loadable "npm:@docusaurus/react-loadable@6.0.0"
-    react-loadable-ssr-addon-v5-slorber "^1.0.1"
+    react-loadable-ssr-addon-v5-slorber "^1.0.3"
     react-router "^5.3.4"
     react-router-config "^5.1.1"
     react-router-dom "^5.3.4"
-    rtl-detect "^1.0.4"
     semver "^7.5.4"
-    serve-handler "^6.1.6"
-    shelljs "^0.8.5"
+    serve-handler "^6.1.7"
+    tinypool "^1.0.2"
     tslib "^2.6.0"
     update-notifier "^6.0.2"
     webpack "^5.95.0"
     webpack-bundle-analyzer "^4.10.2"
-    webpack-dev-server "^4.15.2"
+    webpack-dev-server "^5.2.2"
     webpack-merge "^6.0.1"
 
-"@docusaurus/cssnano-preset@3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/cssnano-preset/-/cssnano-preset-3.6.3.tgz"
-  integrity sha512-qP7SXrwZ+23GFJdPN4aIHQrZW+oH/7tzwEuc/RNL0+BdZdmIjYQqUxdXsjE4lFxLNZjj0eUrSNYIS6xwfij+5Q==
+"@docusaurus/cssnano-preset@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/cssnano-preset/-/cssnano-preset-3.10.0.tgz"
+  integrity sha512-qzSshTO1DB3TYW+dPUal5KHM7XPc5YQfzF3Kdb2NDACJUyGbNcFtw3tGkCJlYwhNCRKbZcmwraKUS1i5dcHdGg==
   dependencies:
     cssnano-preset-advanced "^6.1.2"
-    postcss "^8.4.38"
+    postcss "^8.5.4"
     postcss-sort-media-queries "^5.2.0"
     tslib "^2.6.0"
 
-"@docusaurus/logger@3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/logger/-/logger-3.6.3.tgz"
-  integrity sha512-xSubJixcNyMV9wMV4q0s47CBz3Rlc5jbcCCuij8pfQP8qn/DIpt0ks8W6hQWzHAedg/J/EwxxUOUrnEoKzJo8g==
+"@docusaurus/logger@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/logger/-/logger-3.10.0.tgz"
+  integrity sha512-9jrZzFuBH1LDRlZ7cznAhCLmAZ3HSDqgwdrSSZdGHq9SPUOQgXXu8mnxe2ZRB9NS1PCpMTIOVUqDtZPIhMafZg==
   dependencies:
     chalk "^4.1.2"
     tslib "^2.6.0"
 
-"@docusaurus/mdx-loader@3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/mdx-loader/-/mdx-loader-3.6.3.tgz"
-  integrity sha512-3iJdiDz9540ppBseeI93tWTDtUGVkxzh59nMq4ignylxMuXBLK8dFqVeaEor23v1vx6TrGKZ2FuLaTB+U7C0QQ==
+"@docusaurus/mdx-loader@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/mdx-loader/-/mdx-loader-3.10.0.tgz"
+  integrity sha512-mQQV97080AH4PYNs087l202NMDqRopZA4mg5W76ZZyTFrmWhJ3mHg+8A+drJVENxw5/Q+wHMHLgsx+9z1nEs0A==
   dependencies:
-    "@docusaurus/logger" "3.6.3"
-    "@docusaurus/utils" "3.6.3"
-    "@docusaurus/utils-validation" "3.6.3"
+    "@docusaurus/logger" "3.10.0"
+    "@docusaurus/utils" "3.10.0"
+    "@docusaurus/utils-validation" "3.10.0"
     "@mdx-js/mdx" "^3.0.0"
     "@slorber/remark-comment" "^1.0.0"
     escape-html "^1.0.3"
     estree-util-value-to-estree "^3.0.1"
     file-loader "^6.2.0"
     fs-extra "^11.1.1"
-    image-size "^1.0.2"
+    image-size "^2.0.2"
     mdast-util-mdx "^3.0.0"
     mdast-util-to-string "^4.0.0"
     rehype-raw "^7.0.0"
@@ -1663,182 +1636,211 @@
     vfile "^6.0.1"
     webpack "^5.88.1"
 
-"@docusaurus/module-type-aliases@3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/module-type-aliases/-/module-type-aliases-3.6.3.tgz"
-  integrity sha512-MjaXX9PN/k5ugNvfRZdWyKWq4FsrhN4LEXaj0pEmMebJuBNlFeGyKQUa9DRhJHpadNaiMLrbo9m3U7Ig5YlsZg==
+"@docusaurus/module-type-aliases@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/module-type-aliases/-/module-type-aliases-3.10.0.tgz"
+  integrity sha512-/1O0Zg8w3DFrYX/I6Fbss7OJrtZw1QoyjDhegiFNHVi9A9Y0gQ3jUAytVxF6ywpAWpLyLxch8nN8H/V3XfzdJQ==
   dependencies:
-    "@docusaurus/types" "3.6.3"
+    "@docusaurus/types" "3.10.0"
     "@types/history" "^4.7.11"
     "@types/react" "*"
     "@types/react-router-config" "*"
     "@types/react-router-dom" "*"
-    react-helmet-async "*"
+    react-helmet-async "npm:@slorber/react-helmet-async@1.3.0"
     react-loadable "npm:@docusaurus/react-loadable@6.0.0"
 
-"@docusaurus/plugin-content-blog@3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/plugin-content-blog/-/plugin-content-blog-3.6.3.tgz"
-  integrity sha512-k0ogWwwJU3pFRFfvW1kRVHxzf2DutLGaaLjAnHVEU6ju+aRP0Z5ap/13DHyPOfHeE4WKpn/M0TqjdwZAcY3kAw==
-  dependencies:
-    "@docusaurus/core" "3.6.3"
-    "@docusaurus/logger" "3.6.3"
-    "@docusaurus/mdx-loader" "3.6.3"
-    "@docusaurus/theme-common" "3.6.3"
-    "@docusaurus/types" "3.6.3"
-    "@docusaurus/utils" "3.6.3"
-    "@docusaurus/utils-common" "3.6.3"
-    "@docusaurus/utils-validation" "3.6.3"
+"@docusaurus/plugin-content-blog@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/plugin-content-blog/-/plugin-content-blog-3.10.0.tgz"
+  integrity sha512-RuTz68DhB7CL96QO5UsFbciD7GPYq6QV+YMfF9V0+N4ZgLhJIBgpVAr8GobrKF6NRe5cyWWETU5z5T834piG9g==
+  dependencies:
+    "@docusaurus/core" "3.10.0"
+    "@docusaurus/logger" "3.10.0"
+    "@docusaurus/mdx-loader" "3.10.0"
+    "@docusaurus/theme-common" "3.10.0"
+    "@docusaurus/types" "3.10.0"
+    "@docusaurus/utils" "3.10.0"
+    "@docusaurus/utils-common" "3.10.0"
+    "@docusaurus/utils-validation" "3.10.0"
     cheerio "1.0.0-rc.12"
+    combine-promises "^1.1.0"
     feed "^4.2.2"
     fs-extra "^11.1.1"
     lodash "^4.17.21"
-    reading-time "^1.5.0"
+    schema-dts "^1.1.2"
     srcset "^4.0.0"
     tslib "^2.6.0"
     unist-util-visit "^5.0.0"
     utility-types "^3.10.0"
     webpack "^5.88.1"
 
-"@docusaurus/plugin-content-docs@3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/plugin-content-docs/-/plugin-content-docs-3.6.3.tgz"
-  integrity sha512-r2wS8y/fsaDcxkm20W5bbYJFPzdWdEaTWVYjNxlHlcmX086eqQR1Fomlg9BHTJ0dLXPzAlbC8EN4XqMr3QzNCQ==
-  dependencies:
-    "@docusaurus/core" "3.6.3"
-    "@docusaurus/logger" "3.6.3"
-    "@docusaurus/mdx-loader" "3.6.3"
-    "@docusaurus/module-type-aliases" "3.6.3"
-    "@docusaurus/theme-common" "3.6.3"
-    "@docusaurus/types" "3.6.3"
-    "@docusaurus/utils" "3.6.3"
-    "@docusaurus/utils-common" "3.6.3"
-    "@docusaurus/utils-validation" "3.6.3"
+"@docusaurus/plugin-content-docs@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/plugin-content-docs/-/plugin-content-docs-3.10.0.tgz"
+  integrity sha512-9BjHhf15ct8Z7TThTC0xRndKDVvMKmVsAGAN7W9FpNRzfMdScOGcXtLmcCWtJGvAezjOJIm6CxOYCy3Io5+RnQ==
+  dependencies:
+    "@docusaurus/core" "3.10.0"
+    "@docusaurus/logger" "3.10.0"
+    "@docusaurus/mdx-loader" "3.10.0"
+    "@docusaurus/module-type-aliases" "3.10.0"
+    "@docusaurus/theme-common" "3.10.0"
+    "@docusaurus/types" "3.10.0"
+    "@docusaurus/utils" "3.10.0"
+    "@docusaurus/utils-common" "3.10.0"
+    "@docusaurus/utils-validation" "3.10.0"
     "@types/react-router-config" "^5.0.7"
     combine-promises "^1.1.0"
     fs-extra "^11.1.1"
     js-yaml "^4.1.0"
     lodash "^4.17.21"
+    schema-dts "^1.1.2"
     tslib "^2.6.0"
     utility-types "^3.10.0"
     webpack "^5.88.1"
 
-"@docusaurus/plugin-content-pages@3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/plugin-content-pages/-/plugin-content-pages-3.6.3.tgz"
-  integrity sha512-eHrmTgjgLZsuqfsYr5X2xEwyIcck0wseSofWrjTwT9FLOWp+KDmMAuVK+wRo7sFImWXZk3oV/xX/g9aZrhD7OA==
+"@docusaurus/plugin-content-pages@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/plugin-content-pages/-/plugin-content-pages-3.10.0.tgz"
+  integrity sha512-5amX8kEJI+nIGtuLVjYk59Y5utEJ3CHETFOPEE4cooIRLA4xM4iBsA6zFgu4ljcopeYwvBzFEWf5g2I6Yb9SkA==
   dependencies:
-    "@docusaurus/core" "3.6.3"
-    "@docusaurus/mdx-loader" "3.6.3"
-    "@docusaurus/types" "3.6.3"
-    "@docusaurus/utils" "3.6.3"
-    "@docusaurus/utils-validation" "3.6.3"
+    "@docusaurus/core" "3.10.0"
+    "@docusaurus/mdx-loader" "3.10.0"
+    "@docusaurus/types" "3.10.0"
+    "@docusaurus/utils" "3.10.0"
+    "@docusaurus/utils-validation" "3.10.0"
     fs-extra "^11.1.1"
     tslib "^2.6.0"
     webpack "^5.88.1"
 
-"@docusaurus/plugin-debug@3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/plugin-debug/-/plugin-debug-3.6.3.tgz"
-  integrity sha512-zB9GXfIZNPRfzKnNjU6xGVrqn9bPXuGhpjgsuc/YtcTDjnjhasg38NdYd5LEqXex5G/zIorQgWB3n6x/Ut62vQ==
+"@docusaurus/plugin-css-cascade-layers@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/plugin-css-cascade-layers/-/plugin-css-cascade-layers-3.10.0.tgz"
+  integrity sha512-6q1vtt5FJcg5osgkHeM1euErECNqEZ5Z1j69yiNx2luEBIso+nxCkS9nqj8w+MK5X7rvKEToGhFfOFWncs51pQ==
+  dependencies:
+    "@docusaurus/core" "3.10.0"
+    "@docusaurus/types" "3.10.0"
+    "@docusaurus/utils" "3.10.0"
+    "@docusaurus/utils-validation" "3.10.0"
+    tslib "^2.6.0"
+
+"@docusaurus/plugin-debug@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/plugin-debug/-/plugin-debug-3.10.0.tgz"
+  integrity sha512-XcljKN+G+nmmK69uQA1d9BlYU3ZftG3T3zpK8/7Hf/wrOlV7TA4Ampdrdwkg0jElKdKAoSnPhCO0/U3bQGsVQQ==
   dependencies:
-    "@docusaurus/core" "3.6.3"
-    "@docusaurus/types" "3.6.3"
-    "@docusaurus/utils" "3.6.3"
+    "@docusaurus/core" "3.10.0"
+    "@docusaurus/types" "3.10.0"
+    "@docusaurus/utils" "3.10.0"
     fs-extra "^11.1.1"
-    react-json-view-lite "^1.2.0"
+    react-json-view-lite "^2.3.0"
     tslib "^2.6.0"
 
-"@docusaurus/plugin-google-analytics@3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/plugin-google-analytics/-/plugin-google-analytics-3.6.3.tgz"
-  integrity sha512-rCDNy1QW8Dag7nZq67pcum0bpFLrwvxJhYuVprhFh8BMBDxV0bY+bAkGHbSf68P3Bk9C3hNOAXX1srGLIDvcTA==
+"@docusaurus/plugin-google-analytics@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/plugin-google-analytics/-/plugin-google-analytics-3.10.0.tgz"
+  integrity sha512-hTEoodatpBZnUat5nFExbuTGA1lhWGy7vZGuTew5Q3QDtGKFpSJLYmZJhdTjvCFwv1+qQ67hgAVlKdJOB8TXow==
   dependencies:
-    "@docusaurus/core" "3.6.3"
-    "@docusaurus/types" "3.6.3"
-    "@docusaurus/utils-validation" "3.6.3"
+    "@docusaurus/core" "3.10.0"
+    "@docusaurus/types" "3.10.0"
+    "@docusaurus/utils-validation" "3.10.0"
     tslib "^2.6.0"
 
-"@docusaurus/plugin-google-gtag@3.6.3", "@docusaurus/plugin-google-gtag@^3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/plugin-google-gtag/-/plugin-google-gtag-3.6.3.tgz"
-  integrity sha512-+OyDvhM6rqVkQOmLVkQWVJAizEEfkPzVWtIHXlWPOCFGK9X4/AWeBSrU0WG4iMg9Z4zD4YDRrU+lvI4s6DSC+w==
+"@docusaurus/plugin-google-gtag@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/plugin-google-gtag/-/plugin-google-gtag-3.10.0.tgz"
+  integrity sha512-iB/Zzjv/eelJRbdULZqzWCbgMgJ7ht4ONVjXtN3+BI/muil6S87gQ1OJyPwlXD+ELdKkitC7bWv5eJdYOZLhrQ==
   dependencies:
-    "@docusaurus/core" "3.6.3"
-    "@docusaurus/types" "3.6.3"
-    "@docusaurus/utils-validation" "3.6.3"
-    "@types/gtag.js" "^0.0.12"
+    "@docusaurus/core" "3.10.0"
+    "@docusaurus/types" "3.10.0"
+    "@docusaurus/utils-validation" "3.10.0"
+    "@types/gtag.js" "^0.0.20"
     tslib "^2.6.0"
 
-"@docusaurus/plugin-google-tag-manager@3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/plugin-google-tag-manager/-/plugin-google-tag-manager-3.6.3.tgz"
-  integrity sha512-1M6UPB13gWUtN2UHX083/beTn85PlRI9ABItTl/JL1FJ5dJTWWFXXsHf9WW/6hrVwthwTeV/AGbGKvLKV+IlCA==
+"@docusaurus/plugin-google-tag-manager@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/plugin-google-tag-manager/-/plugin-google-tag-manager-3.10.0.tgz"
+  integrity sha512-FEjZxqKgLHa+Wez/EgKxRwvArNCWIScfyEQD95rot7jkxp6nonjI5XIbGfO/iYhM5Qinwe8aIEQHP2KZtpqVuA==
   dependencies:
-    "@docusaurus/core" "3.6.3"
-    "@docusaurus/types" "3.6.3"
-    "@docusaurus/utils-validation" "3.6.3"
+    "@docusaurus/core" "3.10.0"
+    "@docusaurus/types" "3.10.0"
+    "@docusaurus/utils-validation" "3.10.0"
     tslib "^2.6.0"
 
-"@docusaurus/plugin-sitemap@3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/plugin-sitemap/-/plugin-sitemap-3.6.3.tgz"
-  integrity sha512-94qOO4M9Fwv9KfVQJsgbe91k+fPJ4byf1L3Ez8TUa6TAFPo/BrLwQ80zclHkENlL1824TuxkcMKv33u6eydQCg==
-  dependencies:
-    "@docusaurus/core" "3.6.3"
-    "@docusaurus/logger" "3.6.3"
-    "@docusaurus/types" "3.6.3"
-    "@docusaurus/utils" "3.6.3"
-    "@docusaurus/utils-common" "3.6.3"
-    "@docusaurus/utils-validation" "3.6.3"
+"@docusaurus/plugin-sitemap@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/plugin-sitemap/-/plugin-sitemap-3.10.0.tgz"
+  integrity sha512-DVTSLjB97hIjmayGnGcBfognCeI7ZuUKgEnU7Oz81JYqXtVg94mVTthDjq3QHTylYNeCUbkaW8VF0FDLcc8pPw==
+  dependencies:
+    "@docusaurus/core" "3.10.0"
+    "@docusaurus/logger" "3.10.0"
+    "@docusaurus/types" "3.10.0"
+    "@docusaurus/utils" "3.10.0"
+    "@docusaurus/utils-common" "3.10.0"
+    "@docusaurus/utils-validation" "3.10.0"
     fs-extra "^11.1.1"
     sitemap "^7.1.1"
     tslib "^2.6.0"
 
-"@docusaurus/preset-classic@3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/preset-classic/-/preset-classic-3.6.3.tgz"
-  integrity sha512-VHSYWROT3flvNNI1SrnMOtW1EsjeHNK9dhU6s9eY5hryZe79lUqnZJyze/ymDe2LXAqzyj6y5oYvyBoZZk6ErA==
-  dependencies:
-    "@docusaurus/core" "3.6.3"
-    "@docusaurus/plugin-content-blog" "3.6.3"
-    "@docusaurus/plugin-content-docs" "3.6.3"
-    "@docusaurus/plugin-content-pages" "3.6.3"
-    "@docusaurus/plugin-debug" "3.6.3"
-    "@docusaurus/plugin-google-analytics" "3.6.3"
-    "@docusaurus/plugin-google-gtag" "3.6.3"
-    "@docusaurus/plugin-google-tag-manager" "3.6.3"
-    "@docusaurus/plugin-sitemap" "3.6.3"
-    "@docusaurus/theme-classic" "3.6.3"
-    "@docusaurus/theme-common" "3.6.3"
-    "@docusaurus/theme-search-algolia" "3.6.3"
-    "@docusaurus/types" "3.6.3"
-
-"@docusaurus/theme-classic@3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/theme-classic/-/theme-classic-3.6.3.tgz"
-  integrity sha512-1RRLK1tSArI2c00qugWYO3jRocjOZwGF1mBzPPylDVRwWCS/rnWWR91ChdbbaxIupRJ+hX8ZBYrwr5bbU0oztQ==
-  dependencies:
-    "@docusaurus/core" "3.6.3"
-    "@docusaurus/logger" "3.6.3"
-    "@docusaurus/mdx-loader" "3.6.3"
-    "@docusaurus/module-type-aliases" "3.6.3"
-    "@docusaurus/plugin-content-blog" "3.6.3"
-    "@docusaurus/plugin-content-docs" "3.6.3"
-    "@docusaurus/plugin-content-pages" "3.6.3"
-    "@docusaurus/theme-common" "3.6.3"
-    "@docusaurus/theme-translations" "3.6.3"
-    "@docusaurus/types" "3.6.3"
-    "@docusaurus/utils" "3.6.3"
-    "@docusaurus/utils-common" "3.6.3"
-    "@docusaurus/utils-validation" "3.6.3"
+"@docusaurus/plugin-svgr@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/plugin-svgr/-/plugin-svgr-3.10.0.tgz"
+  integrity sha512-lNljBESaETZqVBMPqkrGchr+UPT1eZzEPLmJhz8I76BxbjqgsUnRvrq6lQJ9sYjgmgX52KB7kkgczqd2yzoswQ==
+  dependencies:
+    "@docusaurus/core" "3.10.0"
+    "@docusaurus/types" "3.10.0"
+    "@docusaurus/utils" "3.10.0"
+    "@docusaurus/utils-validation" "3.10.0"
+    "@svgr/core" "8.1.0"
+    "@svgr/webpack" "^8.1.0"
+    tslib "^2.6.0"
+    webpack "^5.88.1"
+
+"@docusaurus/preset-classic@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/preset-classic/-/preset-classic-3.10.0.tgz"
+  integrity sha512-kw/Ye02Hc6xP1OdTswy8yxQEHg0fdPpyWAQRxr5b2x3h7LlG2Zgbb5BDFROnXDDMpUxB7YejlocJIE5HIEfpNA==
+  dependencies:
+    "@docusaurus/core" "3.10.0"
+    "@docusaurus/plugin-content-blog" "3.10.0"
+    "@docusaurus/plugin-content-docs" "3.10.0"
+    "@docusaurus/plugin-content-pages" "3.10.0"
+    "@docusaurus/plugin-css-cascade-layers" "3.10.0"
+    "@docusaurus/plugin-debug" "3.10.0"
+    "@docusaurus/plugin-google-analytics" "3.10.0"
+    "@docusaurus/plugin-google-gtag" "3.10.0"
+    "@docusaurus/plugin-google-tag-manager" "3.10.0"
+    "@docusaurus/plugin-sitemap" "3.10.0"
+    "@docusaurus/plugin-svgr" "3.10.0"
+    "@docusaurus/theme-classic" "3.10.0"
+    "@docusaurus/theme-common" "3.10.0"
+    "@docusaurus/theme-search-algolia" "3.10.0"
+    "@docusaurus/types" "3.10.0"
+
+"@docusaurus/theme-classic@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/theme-classic/-/theme-classic-3.10.0.tgz"
+  integrity sha512-9msCAsRdN+UG+RwPwCFb0uKy4tGoPh5YfBozXeGUtIeAgsMdn6f3G/oY861luZ3t8S2ET8S9Y/1GnpJAGWytww==
+  dependencies:
+    "@docusaurus/core" "3.10.0"
+    "@docusaurus/logger" "3.10.0"
+    "@docusaurus/mdx-loader" "3.10.0"
+    "@docusaurus/module-type-aliases" "3.10.0"
+    "@docusaurus/plugin-content-blog" "3.10.0"
+    "@docusaurus/plugin-content-docs" "3.10.0"
+    "@docusaurus/plugin-content-pages" "3.10.0"
+    "@docusaurus/theme-common" "3.10.0"
+    "@docusaurus/theme-translations" "3.10.0"
+    "@docusaurus/types" "3.10.0"
+    "@docusaurus/utils" "3.10.0"
+    "@docusaurus/utils-common" "3.10.0"
+    "@docusaurus/utils-validation" "3.10.0"
     "@mdx-js/react" "^3.0.0"
     clsx "^2.0.0"
     copy-text-to-clipboard "^3.2.0"
     infima "0.2.0-alpha.45"
     lodash "^4.17.21"
     nprogress "^0.2.0"
-    postcss "^8.4.26"
+    postcss "^8.5.4"
     prism-react-renderer "^2.3.0"
     prismjs "^1.29.0"
     react-router-dom "^5.3.4"
@@ -1846,15 +1848,15 @@
     tslib "^2.6.0"
     utility-types "^3.10.0"
 
-"@docusaurus/theme-common@3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/theme-common/-/theme-common-3.6.3.tgz"
-  integrity sha512-b8ZkhczXHDxWWyvz+YJy4t/PlPbEogTTbgnHoflYnH7rmRtyoodTsu8WVM12la5LmlMJBclBXFl29OH8kPE7gg==
+"@docusaurus/theme-common@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/theme-common/-/theme-common-3.10.0.tgz"
+  integrity sha512-Dkp1YXKn16ByCJAdIjbDIOpVb4Z66MsVD694/ilX1vAAHaVEMrVsf/NPd9VgreyFx08rJ9GqV1MtzsbTcU73Kg==
   dependencies:
-    "@docusaurus/mdx-loader" "3.6.3"
-    "@docusaurus/module-type-aliases" "3.6.3"
-    "@docusaurus/utils" "3.6.3"
-    "@docusaurus/utils-common" "3.6.3"
+    "@docusaurus/mdx-loader" "3.10.0"
+    "@docusaurus/module-type-aliases" "3.10.0"
+    "@docusaurus/utils" "3.10.0"
+    "@docusaurus/utils-common" "3.10.0"
     "@types/history" "^4.7.11"
     "@types/react" "*"
     "@types/react-router-config" "*"
@@ -1864,21 +1866,22 @@
     tslib "^2.6.0"
     utility-types "^3.10.0"
 
-"@docusaurus/theme-search-algolia@3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/theme-search-algolia/-/theme-search-algolia-3.6.3.tgz"
-  integrity sha512-rt+MGCCpYgPyWCGXtbxlwFbTSobu15jWBTPI2LHsHNa5B0zSmOISX6FWYAPt5X1rNDOqMGM0FATnh7TBHRohVA==
-  dependencies:
-    "@docsearch/react" "^3.5.2"
-    "@docusaurus/core" "3.6.3"
-    "@docusaurus/logger" "3.6.3"
-    "@docusaurus/plugin-content-docs" "3.6.3"
-    "@docusaurus/theme-common" "3.6.3"
-    "@docusaurus/theme-translations" "3.6.3"
-    "@docusaurus/utils" "3.6.3"
-    "@docusaurus/utils-validation" "3.6.3"
-    algoliasearch "^4.18.0"
-    algoliasearch-helper "^3.13.3"
+"@docusaurus/theme-search-algolia@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/theme-search-algolia/-/theme-search-algolia-3.10.0.tgz"
+  integrity sha512-f5FPKI08e3JRG63vR/o4qeuUVHUHzFzM0nnF+AkB67soAZgNsKJRf2qmUZvlQkGwlV+QFkKe4D0ANMh1jToU3g==
+  dependencies:
+    "@algolia/autocomplete-core" "^1.19.2"
+    "@docsearch/react" "^3.9.0 || ^4.3.2"
+    "@docusaurus/core" "3.10.0"
+    "@docusaurus/logger" "3.10.0"
+    "@docusaurus/plugin-content-docs" "3.10.0"
+    "@docusaurus/theme-common" "3.10.0"
+    "@docusaurus/theme-translations" "3.10.0"
+    "@docusaurus/utils" "3.10.0"
+    "@docusaurus/utils-validation" "3.10.0"
+    algoliasearch "^5.37.0"
+    algoliasearch-helper "^3.26.0"
     clsx "^2.0.0"
     eta "^2.2.0"
     fs-extra "^11.1.1"
@@ -1886,61 +1889,62 @@
     tslib "^2.6.0"
     utility-types "^3.10.0"
 
-"@docusaurus/theme-translations@3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/theme-translations/-/theme-translations-3.6.3.tgz"
-  integrity sha512-Gb0regclToVlngSIIwUCtBMQBq48qVUaN1XQNKW4XwlsgUyk0vP01LULdqbem7czSwIeBAFXFoORJ0RPX7ht/w==
+"@docusaurus/theme-translations@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/theme-translations/-/theme-translations-3.10.0.tgz"
+  integrity sha512-L9IbFLwTc5+XdgH45iQYufLn0SVZd6BUNelDbKIFlH+E4hhjuj/XHWAFMX/w2K59rfy8wak9McOaei7BSUfRPA==
   dependencies:
     fs-extra "^11.1.1"
     tslib "^2.6.0"
 
-"@docusaurus/types@3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/types/-/types-3.6.3.tgz"
-  integrity sha512-xD9oTGDrouWzefkhe9ogB2fDV96/82cRpNGx2HIvI5L87JHNhQVIWimQ/3JIiiX/TEd5S9s+VO6FFguwKNRVow==
+"@docusaurus/types@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/types/-/types-3.10.0.tgz"
+  integrity sha512-F0dOt3FOoO20rRaFK7whGFQZ3ggyrWEdQc/c8/UiRuzhtg4y1w9FspXH5zpCT07uMnJKBPGh+qNazbNlCQqvSw==
   dependencies:
     "@mdx-js/mdx" "^3.0.0"
     "@types/history" "^4.7.11"
+    "@types/mdast" "^4.0.2"
     "@types/react" "*"
     commander "^5.1.0"
     joi "^17.9.2"
-    react-helmet-async "^1.3.0"
+    react-helmet-async "npm:@slorber/react-helmet-async@1.3.0"
     utility-types "^3.10.0"
     webpack "^5.95.0"
     webpack-merge "^5.9.0"
 
-"@docusaurus/utils-common@3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/utils-common/-/utils-common-3.6.3.tgz"
-  integrity sha512-v4nKDaANLgT3pMBewHYEMAl/ufY0LkXao1QkFWzI5huWFOmNQ2UFzv2BiKeHX5Ownis0/w6cAyoxPhVdDonlSQ==
+"@docusaurus/utils-common@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/utils-common/-/utils-common-3.10.0.tgz"
+  integrity sha512-JyL7sb9QVDgYvudIS81Dv0lsWm7le0vGZSDwsztxWam1SPBqrnkvBy9UYL/amh6pbybkyYTd3CMTkO24oMlCSw==
   dependencies:
-    "@docusaurus/types" "3.6.3"
+    "@docusaurus/types" "3.10.0"
     tslib "^2.6.0"
 
-"@docusaurus/utils-validation@3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/utils-validation/-/utils-validation-3.6.3.tgz"
-  integrity sha512-bhEGGiN5BE38h21vjqD70Gxg++j+PfYVddDUE5UFvLDup68QOcpD33CLr+2knPorlxRbEaNfz6HQDUMQ3HuqKw==
+"@docusaurus/utils-validation@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/utils-validation/-/utils-validation-3.10.0.tgz"
+  integrity sha512-c+6n2+ZPOJtWWc8Bb/EYdpSDfjYEScdCu9fB/SNjOmSCf1IdVnGf2T53o0tsz0gDRtCL90tifTL0JE/oMuP1Mw==
   dependencies:
-    "@docusaurus/logger" "3.6.3"
-    "@docusaurus/utils" "3.6.3"
-    "@docusaurus/utils-common" "3.6.3"
+    "@docusaurus/logger" "3.10.0"
+    "@docusaurus/utils" "3.10.0"
+    "@docusaurus/utils-common" "3.10.0"
     fs-extra "^11.2.0"
     joi "^17.9.2"
     js-yaml "^4.1.0"
     lodash "^4.17.21"
     tslib "^2.6.0"
 
-"@docusaurus/utils@3.6.3":
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/@docusaurus/utils/-/utils-3.6.3.tgz"
-  integrity sha512-0R/FR3bKVl4yl8QwbL4TYFfR+OXBRpVUaTJdENapBGR3YMwfM6/JnhGilWQO8AOwPJGtGoDK7ib8+8UF9f3OZQ==
+"@docusaurus/utils@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@docusaurus/utils/-/utils-3.10.0.tgz"
+  integrity sha512-T3B0WTigsIthe0D4LQa2k+7bJY+c3WS+Wq2JhcznOSpn1lSN64yNtHQXboCj3QnUs1EuAZszQG1SHKu5w5ZrlA==
   dependencies:
-    "@docusaurus/logger" "3.6.3"
-    "@docusaurus/types" "3.6.3"
-    "@docusaurus/utils-common" "3.6.3"
-    "@svgr/webpack" "^8.1.0"
+    "@docusaurus/logger" "3.10.0"
+    "@docusaurus/types" "3.10.0"
+    "@docusaurus/utils-common" "3.10.0"
     escape-string-regexp "^4.0.0"
+    execa "^5.1.1"
     file-loader "^6.2.0"
     fs-extra "^11.1.1"
     github-slugger "^1.5.0"
@@ -1950,9 +1954,9 @@
     js-yaml "^4.1.0"
     lodash "^4.17.21"
     micromatch "^4.0.5"
+    p-queue "^6.6.2"
     prompts "^2.4.2"
     resolve-pathname "^3.0.0"
-    shelljs "^0.8.5"
     tslib "^2.6.0"
     url-loader "^4.1.1"
     utility-types "^3.10.0"
@@ -1960,26 +1964,26 @@
 
 "@hapi/hoek@^9.0.0", "@hapi/hoek@^9.3.0":
   version "9.3.0"
-  resolved "https://registry.npmjs.org/@hapi/hoek/-/hoek-9.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/@hapi/hoek/-/hoek-9.3.0.tgz"
   integrity sha512-/c6rf4UJlmHlC9b5BaNvzAcFv7HZ2QHaV0D4/HNlBdvFnvQq8RI4kYdhyPCl7Xj+oWvTWQ8ujhqS53LIgAe6KQ==
 
 "@hapi/topo@^5.1.0":
   version "5.1.0"
-  resolved "https://registry.npmjs.org/@hapi/topo/-/topo-5.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/@hapi/topo/-/topo-5.1.0.tgz"
   integrity sha512-foQZKJig7Ob0BMAYBfcJk8d77QtOe7Wo4ox7ff1lQYoNNAb6jwcY1ncdoy2e9wQZzvNy7ODZCYJkK8kzmcAnAg==
   dependencies:
     "@hapi/hoek" "^9.0.0"
 
 "@jest/schemas@^29.6.3":
   version "29.6.3"
-  resolved "https://registry.npmjs.org/@jest/schemas/-/schemas-29.6.3.tgz"
+  resolved "https://registry.yarnpkg.com/@jest/schemas/-/schemas-29.6.3.tgz"
   integrity sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==
   dependencies:
     "@sinclair/typebox" "^0.27.8"
 
 "@jest/types@^29.6.3":
   version "29.6.3"
-  resolved "https://registry.npmjs.org/@jest/types/-/types-29.6.3.tgz"
+  resolved "https://registry.yarnpkg.com/@jest/types/-/types-29.6.3.tgz"
   integrity sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw==
   dependencies:
     "@jest/schemas" "^29.6.3"
@@ -1989,60 +1993,223 @@
     "@types/yargs" "^17.0.8"
     chalk "^4.0.0"
 
-"@jridgewell/gen-mapping@^0.3.5":
-  version "0.3.8"
-  resolved "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.8.tgz"
-  integrity sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA==
+"@jridgewell/gen-mapping@^0.3.12", "@jridgewell/gen-mapping@^0.3.5":
+  version "0.3.13"
+  resolved "https://registry.yarnpkg.com/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz"
+  integrity sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==
+  dependencies:
+    "@jridgewell/sourcemap-codec" "^1.5.0"
+    "@jridgewell/trace-mapping" "^0.3.24"
+
+"@jridgewell/remapping@^2.3.5":
+  version "2.3.5"
+  resolved "https://registry.yarnpkg.com/@jridgewell/remapping/-/remapping-2.3.5.tgz"
+  integrity sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==
   dependencies:
-    "@jridgewell/set-array" "^1.2.1"
-    "@jridgewell/sourcemap-codec" "^1.4.10"
+    "@jridgewell/gen-mapping" "^0.3.5"
     "@jridgewell/trace-mapping" "^0.3.24"
 
 "@jridgewell/resolve-uri@^3.1.0":
   version "3.1.2"
-  resolved "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz"
   integrity sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==
 
-"@jridgewell/set-array@^1.2.1":
-  version "1.2.1"
-  resolved "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.2.1.tgz"
-  integrity sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==
-
 "@jridgewell/source-map@^0.3.3":
-  version "0.3.6"
-  resolved "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.6.tgz"
-  integrity sha512-1ZJTZebgqllO79ue2bm3rIGud/bOe0pP5BjSRCRxxYkEZS8STV7zN84UBbiYu7jy+eCKSnVIUgoWWE/tt+shMQ==
+  version "0.3.11"
+  resolved "https://registry.yarnpkg.com/@jridgewell/source-map/-/source-map-0.3.11.tgz"
+  integrity sha512-ZMp1V8ZFcPG5dIWnQLr3NSI1MiCU7UETdS/A0G8V/XWHvJv3ZsFqutJn1Y5RPmAPX6F3BiE397OqveU/9NCuIA==
   dependencies:
     "@jridgewell/gen-mapping" "^0.3.5"
     "@jridgewell/trace-mapping" "^0.3.25"
 
-"@jridgewell/sourcemap-codec@^1.4.10", "@jridgewell/sourcemap-codec@^1.4.14":
-  version "1.5.0"
-  resolved "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz"
-  integrity sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==
+"@jridgewell/sourcemap-codec@^1.4.14", "@jridgewell/sourcemap-codec@^1.5.0":
+  version "1.5.5"
+  resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz"
+  integrity sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==
 
-"@jridgewell/trace-mapping@^0.3.18", "@jridgewell/trace-mapping@^0.3.24", "@jridgewell/trace-mapping@^0.3.25":
-  version "0.3.25"
-  resolved "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz"
-  integrity sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==
+"@jridgewell/trace-mapping@^0.3.18", "@jridgewell/trace-mapping@^0.3.24", "@jridgewell/trace-mapping@^0.3.25", "@jridgewell/trace-mapping@^0.3.28":
+  version "0.3.31"
+  resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz"
+  integrity sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==
   dependencies:
     "@jridgewell/resolve-uri" "^3.1.0"
     "@jridgewell/sourcemap-codec" "^1.4.14"
 
+"@jsonjoy.com/base64@17.67.0":
+  version "17.67.0"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/base64/-/base64-17.67.0.tgz"
+  integrity sha512-5SEsJGsm15aP8TQGkDfJvz9axgPwAEm98S5DxOuYe8e1EbfajcDmgeXXzccEjh+mLnjqEKrkBdjHWS5vFNwDdw==
+
+"@jsonjoy.com/base64@^1.1.2":
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/base64/-/base64-1.1.2.tgz"
+  integrity sha512-q6XAnWQDIMA3+FTiOYajoYqySkO+JSat0ytXGSuRdq9uXE7o92gzuQwQM14xaCRlBLGq3v5miDGC4vkVTn54xA==
+
+"@jsonjoy.com/buffers@17.67.0", "@jsonjoy.com/buffers@^17.65.0":
+  version "17.67.0"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/buffers/-/buffers-17.67.0.tgz"
+  integrity sha512-tfExRpYxBvi32vPs9ZHaTjSP4fHAfzSmcahOfNxtvGHcyJel+aibkPlGeBB+7AoC6hL7lXIE++8okecBxx7lcw==
+
+"@jsonjoy.com/buffers@^1.0.0", "@jsonjoy.com/buffers@^1.2.0":
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/buffers/-/buffers-1.2.1.tgz"
+  integrity sha512-12cdlDwX4RUM3QxmUbVJWqZ/mrK6dFQH4Zxq6+r1YXKXYBNgZXndx2qbCJwh3+WWkCSn67IjnlG3XYTvmvYtgA==
+
+"@jsonjoy.com/codegen@17.67.0":
+  version "17.67.0"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/codegen/-/codegen-17.67.0.tgz"
+  integrity sha512-idnkUplROpdBOV0HMcwhsCUS5TRUi9poagdGs70A6S4ux9+/aPuKbh8+UYRTLYQHtXvAdNfQWXDqZEx5k4Dj2Q==
+
+"@jsonjoy.com/codegen@^1.0.0":
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/codegen/-/codegen-1.0.0.tgz"
+  integrity sha512-E8Oy+08cmCf0EK/NMxpaJZmOxPqM+6iSe2S4nlSBrPZOORoDJILxtbSUEDKQyTamm/BVAhIGllOBNU79/dwf0g==
+
+"@jsonjoy.com/fs-core@4.57.2":
+  version "4.57.2"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/fs-core/-/fs-core-4.57.2.tgz"
+  integrity sha512-SVjwklkpIV5wrynpYtuYnfYH1QF4/nDuLBX7VXdb+3miglcAgBVZb/5y0cOsehRV/9Vb+3UqhkMq3/NR3ztdkQ==
+  dependencies:
+    "@jsonjoy.com/fs-node-builtins" "4.57.2"
+    "@jsonjoy.com/fs-node-utils" "4.57.2"
+    thingies "^2.5.0"
+
+"@jsonjoy.com/fs-fsa@4.57.2":
+  version "4.57.2"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/fs-fsa/-/fs-fsa-4.57.2.tgz"
+  integrity sha512-fhO8+iR2I+OCw668ISDJdn1aArc9zx033sWejIyzQ8RBeXa9bDSaUeA3ix0poYOfrj1KdOzytmYNv2/uLDfV6g==
+  dependencies:
+    "@jsonjoy.com/fs-core" "4.57.2"
+    "@jsonjoy.com/fs-node-builtins" "4.57.2"
+    "@jsonjoy.com/fs-node-utils" "4.57.2"
+    thingies "^2.5.0"
+
+"@jsonjoy.com/fs-node-builtins@4.57.2":
+  version "4.57.2"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/fs-node-builtins/-/fs-node-builtins-4.57.2.tgz"
+  integrity sha512-xhiegylRmhw43Ki2HO1ZBL7DQ5ja/qpRsL29VtQ2xuUHiuDGbgf2uD4p9Qd8hJI5P6RCtGYD50IXHXVq/Ocjcg==
+
+"@jsonjoy.com/fs-node-to-fsa@4.57.2":
+  version "4.57.2"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/fs-node-to-fsa/-/fs-node-to-fsa-4.57.2.tgz"
+  integrity sha512-18LmWTSONhoAPW+IWRuf8w/+zRolPFGPeGwMxlAhhfY11EKzX+5XHDBPAw67dBF5dxDErHJbl40U+3IXSDRXSQ==
+  dependencies:
+    "@jsonjoy.com/fs-fsa" "4.57.2"
+    "@jsonjoy.com/fs-node-builtins" "4.57.2"
+    "@jsonjoy.com/fs-node-utils" "4.57.2"
+
+"@jsonjoy.com/fs-node-utils@4.57.2":
+  version "4.57.2"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/fs-node-utils/-/fs-node-utils-4.57.2.tgz"
+  integrity sha512-rsPSJgekz43IlNbLyAM/Ab+ouYLWGp5DDBfYBNNEqDaSpsbXfthBn29Q4muFA9L0F+Z3mKo+CWlgSCXrf+mOyQ==
+  dependencies:
+    "@jsonjoy.com/fs-node-builtins" "4.57.2"
+
+"@jsonjoy.com/fs-node@4.57.2":
+  version "4.57.2"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/fs-node/-/fs-node-4.57.2.tgz"
+  integrity sha512-nX2AdL6cOFwLdju9G4/nbRnYevmCJbh7N7hvR3gGm97Cs60uEjyd0rpR+YBS7cTg175zzl22pGKXR5USaQMvKg==
+  dependencies:
+    "@jsonjoy.com/fs-core" "4.57.2"
+    "@jsonjoy.com/fs-node-builtins" "4.57.2"
+    "@jsonjoy.com/fs-node-utils" "4.57.2"
+    "@jsonjoy.com/fs-print" "4.57.2"
+    "@jsonjoy.com/fs-snapshot" "4.57.2"
+    glob-to-regex.js "^1.0.0"
+    thingies "^2.5.0"
+
+"@jsonjoy.com/fs-print@4.57.2":
+  version "4.57.2"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/fs-print/-/fs-print-4.57.2.tgz"
+  integrity sha512-wK9NSow48i4DbDl9F1CQE5TqnyZOJ04elU3WFG5aJ76p+YxO/ulyBBQvKsessPxdo381Bc2pcEoyPujMOhcRqQ==
+  dependencies:
+    "@jsonjoy.com/fs-node-utils" "4.57.2"
+    tree-dump "^1.1.0"
+
+"@jsonjoy.com/fs-snapshot@4.57.2":
+  version "4.57.2"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/fs-snapshot/-/fs-snapshot-4.57.2.tgz"
+  integrity sha512-GdduDZuoP5V/QCgJkx9+BZ6SC0EZ/smXAdTS7PfMqgMTGXLlt/bH/FqMYaqB9JmLf05sJPtO0XRbAwwkEEPbVw==
+  dependencies:
+    "@jsonjoy.com/buffers" "^17.65.0"
+    "@jsonjoy.com/fs-node-utils" "4.57.2"
+    "@jsonjoy.com/json-pack" "^17.65.0"
+    "@jsonjoy.com/util" "^17.65.0"
+
+"@jsonjoy.com/json-pack@^1.11.0":
+  version "1.21.0"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/json-pack/-/json-pack-1.21.0.tgz"
+  integrity sha512-+AKG+R2cfZMShzrF2uQw34v3zbeDYUqnQ+jg7ORic3BGtfw9p/+N6RJbq/kkV8JmYZaINknaEQ2m0/f693ZPpg==
+  dependencies:
+    "@jsonjoy.com/base64" "^1.1.2"
+    "@jsonjoy.com/buffers" "^1.2.0"
+    "@jsonjoy.com/codegen" "^1.0.0"
+    "@jsonjoy.com/json-pointer" "^1.0.2"
+    "@jsonjoy.com/util" "^1.9.0"
+    hyperdyperid "^1.2.0"
+    thingies "^2.5.0"
+    tree-dump "^1.1.0"
+
+"@jsonjoy.com/json-pack@^17.65.0":
+  version "17.67.0"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/json-pack/-/json-pack-17.67.0.tgz"
+  integrity sha512-t0ejURcGaZsn1ClbJ/3kFqSOjlryd92eQY465IYrezsXmPcfHPE/av4twRSxf6WE+TkZgLY+71vCZbiIiFKA/w==
+  dependencies:
+    "@jsonjoy.com/base64" "17.67.0"
+    "@jsonjoy.com/buffers" "17.67.0"
+    "@jsonjoy.com/codegen" "17.67.0"
+    "@jsonjoy.com/json-pointer" "17.67.0"
+    "@jsonjoy.com/util" "17.67.0"
+    hyperdyperid "^1.2.0"
+    thingies "^2.5.0"
+    tree-dump "^1.1.0"
+
+"@jsonjoy.com/json-pointer@17.67.0":
+  version "17.67.0"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/json-pointer/-/json-pointer-17.67.0.tgz"
+  integrity sha512-+iqOFInH+QZGmSuaybBUNdh7yvNrXvqR+h3wjXm0N/3JK1EyyFAeGJvqnmQL61d1ARLlk/wJdFKSL+LHJ1eaUA==
+  dependencies:
+    "@jsonjoy.com/util" "17.67.0"
+
+"@jsonjoy.com/json-pointer@^1.0.2":
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/json-pointer/-/json-pointer-1.0.2.tgz"
+  integrity sha512-Fsn6wM2zlDzY1U+v4Nc8bo3bVqgfNTGcn6dMgs6FjrEnt4ZCe60o6ByKRjOGlI2gow0aE/Q41QOigdTqkyK5fg==
+  dependencies:
+    "@jsonjoy.com/codegen" "^1.0.0"
+    "@jsonjoy.com/util" "^1.9.0"
+
+"@jsonjoy.com/util@17.67.0", "@jsonjoy.com/util@^17.65.0":
+  version "17.67.0"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/util/-/util-17.67.0.tgz"
+  integrity sha512-6+8xBaz1rLSohlGh68D1pdw3AwDi9xydm8QNlAFkvnavCJYSze+pxoW2VKP8p308jtlMRLs5NTHfPlZLd4w7ew==
+  dependencies:
+    "@jsonjoy.com/buffers" "17.67.0"
+    "@jsonjoy.com/codegen" "17.67.0"
+
+"@jsonjoy.com/util@^1.9.0":
+  version "1.9.0"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/util/-/util-1.9.0.tgz"
+  integrity sha512-pLuQo+VPRnN8hfPqUTLTHk126wuYdXVxE6aDmjSeV4NCAgyxWbiOIeNJVtID3h1Vzpoi9m4jXezf73I6LgabgQ==
+  dependencies:
+    "@jsonjoy.com/buffers" "^1.0.0"
+    "@jsonjoy.com/codegen" "^1.0.0"
+
 "@leichtgewicht/ip-codec@^2.0.1":
   version "2.0.5"
-  resolved "https://registry.npmjs.org/@leichtgewicht/ip-codec/-/ip-codec-2.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/@leichtgewicht/ip-codec/-/ip-codec-2.0.5.tgz"
   integrity sha512-Vo+PSpZG2/fmgmiNzYK9qWRh8h/CHrwD0mo1h1DzL4yzHNSfWYujGTYsWGreD000gcgmZ7K4Ys6Tx9TxtsKdDw==
 
 "@mdx-js/mdx@^3.0.0":
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/@mdx-js/mdx/-/mdx-3.1.0.tgz"
-  integrity sha512-/QxEhPAvGwbQmy1Px8F899L5Uc2KZ6JtXwlCgJmjSTBedwOZkByYcBG4GceIGPXRDsmfxhHazuS+hlOShRLeDw==
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/@mdx-js/mdx/-/mdx-3.1.1.tgz"
+  integrity sha512-f6ZO2ifpwAQIpzGWaBQT2TXxPv6z3RBzQKpVftEWN78Vl/YweF1uwussDx8ECAXVtr3Rs89fKyG9YlzUs9DyGQ==
   dependencies:
     "@types/estree" "^1.0.0"
     "@types/estree-jsx" "^1.0.0"
     "@types/hast" "^3.0.0"
     "@types/mdx" "^2.0.0"
+    acorn "^8.0.0"
     collapse-white-space "^2.0.0"
     devlop "^1.0.0"
     estree-util-is-identifier-name "^3.0.0"
@@ -2065,15 +2232,20 @@
     vfile "^6.0.0"
 
 "@mdx-js/react@^3.0.0", "@mdx-js/react@^3.1.0":
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/@mdx-js/react/-/react-3.1.0.tgz"
-  integrity sha512-QjHtSaoameoalGnKDT3FoIl4+9RwyTmo9ZJGBdLOks/YOiWHoRDI3PUwEzOE7kEmGcV3AFcp9K6dYu9rEuKLAQ==
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/@mdx-js/react/-/react-3.1.1.tgz"
+  integrity sha512-f++rKLQgUVYDAtECQ6fn/is15GkEH9+nZPM3MS0RcxVqoTfawHvDlSCH7JbMhAM6uJ32v3eXLvLmLvjGu7PTQw==
   dependencies:
     "@types/mdx" "^2.0.0"
 
+"@noble/hashes@1.4.0":
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/@noble/hashes/-/hashes-1.4.0.tgz"
+  integrity sha512-V1JJ1WTRUqHHrOSh597hURcMqVKVGL/ea3kv0gSnEdsEZ0/+VyPghM1lMNGc00z7CIQorSvbKpuJkxvuHbvdbg==
+
 "@nodelib/fs.scandir@2.1.5":
   version "2.1.5"
-  resolved "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz"
+  resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz"
   integrity sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==
   dependencies:
     "@nodelib/fs.stat" "2.0.5"
@@ -2081,78 +2253,201 @@
 
 "@nodelib/fs.stat@2.0.5", "@nodelib/fs.stat@^2.0.2":
   version "2.0.5"
-  resolved "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz"
   integrity sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==
 
 "@nodelib/fs.walk@^1.2.3":
   version "1.2.8"
-  resolved "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz"
+  resolved "https://registry.yarnpkg.com/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz"
   integrity sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==
   dependencies:
     "@nodelib/fs.scandir" "2.1.5"
     fastq "^1.6.0"
 
+"@peculiar/asn1-cms@^2.6.0", "@peculiar/asn1-cms@^2.6.1":
+  version "2.6.1"
+  resolved "https://registry.yarnpkg.com/@peculiar/asn1-cms/-/asn1-cms-2.6.1.tgz"
+  integrity sha512-vdG4fBF6Lkirkcl53q6eOdn3XYKt+kJTG59edgRZORlg/3atWWEReRCx5rYE1ZzTTX6vLK5zDMjHh7vbrcXGtw==
+  dependencies:
+    "@peculiar/asn1-schema" "^2.6.0"
+    "@peculiar/asn1-x509" "^2.6.1"
+    "@peculiar/asn1-x509-attr" "^2.6.1"
+    asn1js "^3.0.6"
+    tslib "^2.8.1"
+
+"@peculiar/asn1-csr@^2.6.0":
+  version "2.6.1"
+  resolved "https://registry.yarnpkg.com/@peculiar/asn1-csr/-/asn1-csr-2.6.1.tgz"
+  integrity sha512-WRWnKfIocHyzFYQTka8O/tXCiBquAPSrRjXbOkHbO4qdmS6loffCEGs+rby6WxxGdJCuunnhS2duHURhjyio6w==
+  dependencies:
+    "@peculiar/asn1-schema" "^2.6.0"
+    "@peculiar/asn1-x509" "^2.6.1"
+    asn1js "^3.0.6"
+    tslib "^2.8.1"
+
+"@peculiar/asn1-ecc@^2.6.0":
+  version "2.6.1"
+  resolved "https://registry.yarnpkg.com/@peculiar/asn1-ecc/-/asn1-ecc-2.6.1.tgz"
+  integrity sha512-+Vqw8WFxrtDIN5ehUdvlN2m73exS2JVG0UAyfVB31gIfor3zWEAQPD+K9ydCxaj3MLen9k0JhKpu9LqviuCE1g==
+  dependencies:
+    "@peculiar/asn1-schema" "^2.6.0"
+    "@peculiar/asn1-x509" "^2.6.1"
+    asn1js "^3.0.6"
+    tslib "^2.8.1"
+
+"@peculiar/asn1-pfx@^2.6.1":
+  version "2.6.1"
+  resolved "https://registry.yarnpkg.com/@peculiar/asn1-pfx/-/asn1-pfx-2.6.1.tgz"
+  integrity sha512-nB5jVQy3MAAWvq0KY0R2JUZG8bO/bTLpnwyOzXyEh/e54ynGTatAR+csOnXkkVD9AFZ2uL8Z7EV918+qB1qDvw==
+  dependencies:
+    "@peculiar/asn1-cms" "^2.6.1"
+    "@peculiar/asn1-pkcs8" "^2.6.1"
+    "@peculiar/asn1-rsa" "^2.6.1"
+    "@peculiar/asn1-schema" "^2.6.0"
+    asn1js "^3.0.6"
+    tslib "^2.8.1"
+
+"@peculiar/asn1-pkcs8@^2.6.1":
+  version "2.6.1"
+  resolved "https://registry.yarnpkg.com/@peculiar/asn1-pkcs8/-/asn1-pkcs8-2.6.1.tgz"
+  integrity sha512-JB5iQ9Izn5yGMw3ZG4Nw3Xn/hb/G38GYF3lf7WmJb8JZUydhVGEjK/ZlFSWhnlB7K/4oqEs8HnfFIKklhR58Tw==
+  dependencies:
+    "@peculiar/asn1-schema" "^2.6.0"
+    "@peculiar/asn1-x509" "^2.6.1"
+    asn1js "^3.0.6"
+    tslib "^2.8.1"
+
+"@peculiar/asn1-pkcs9@^2.6.0":
+  version "2.6.1"
+  resolved "https://registry.yarnpkg.com/@peculiar/asn1-pkcs9/-/asn1-pkcs9-2.6.1.tgz"
+  integrity sha512-5EV8nZoMSxeWmcxWmmcolg22ojZRgJg+Y9MX2fnE2bGRo5KQLqV5IL9kdSQDZxlHz95tHvIq9F//bvL1OeNILw==
+  dependencies:
+    "@peculiar/asn1-cms" "^2.6.1"
+    "@peculiar/asn1-pfx" "^2.6.1"
+    "@peculiar/asn1-pkcs8" "^2.6.1"
+    "@peculiar/asn1-schema" "^2.6.0"
+    "@peculiar/asn1-x509" "^2.6.1"
+    "@peculiar/asn1-x509-attr" "^2.6.1"
+    asn1js "^3.0.6"
+    tslib "^2.8.1"
+
+"@peculiar/asn1-rsa@^2.6.0", "@peculiar/asn1-rsa@^2.6.1":
+  version "2.6.1"
+  resolved "https://registry.yarnpkg.com/@peculiar/asn1-rsa/-/asn1-rsa-2.6.1.tgz"
+  integrity sha512-1nVMEh46SElUt5CB3RUTV4EG/z7iYc7EoaDY5ECwganibQPkZ/Y2eMsTKB/LeyrUJ+W/tKoD9WUqIy8vB+CEdA==
+  dependencies:
+    "@peculiar/asn1-schema" "^2.6.0"
+    "@peculiar/asn1-x509" "^2.6.1"
+    asn1js "^3.0.6"
+    tslib "^2.8.1"
+
+"@peculiar/asn1-schema@^2.6.0":
+  version "2.6.0"
+  resolved "https://registry.yarnpkg.com/@peculiar/asn1-schema/-/asn1-schema-2.6.0.tgz"
+  integrity sha512-xNLYLBFTBKkCzEZIw842BxytQQATQv+lDTCEMZ8C196iJcJJMBUZxrhSTxLaohMyKK8QlzRNTRkUmanucnDSqg==
+  dependencies:
+    asn1js "^3.0.6"
+    pvtsutils "^1.3.6"
+    tslib "^2.8.1"
+
+"@peculiar/asn1-x509-attr@^2.6.1":
+  version "2.6.1"
+  resolved "https://registry.yarnpkg.com/@peculiar/asn1-x509-attr/-/asn1-x509-attr-2.6.1.tgz"
+  integrity sha512-tlW6cxoHwgcQghnJwv3YS+9OO1737zgPogZ+CgWRUK4roEwIPzRH4JEiG770xe5HX2ATfCpmX60gurfWIF9dcQ==
+  dependencies:
+    "@peculiar/asn1-schema" "^2.6.0"
+    "@peculiar/asn1-x509" "^2.6.1"
+    asn1js "^3.0.6"
+    tslib "^2.8.1"
+
+"@peculiar/asn1-x509@^2.6.0", "@peculiar/asn1-x509@^2.6.1":
+  version "2.6.1"
+  resolved "https://registry.yarnpkg.com/@peculiar/asn1-x509/-/asn1-x509-2.6.1.tgz"
+  integrity sha512-O9jT5F1A2+t3r7C4VT7LYGXqkGLK7Kj1xFpz7U0isPrubwU5PbDoyYtx6MiGst29yq7pXN5vZbQFKRCP+lLZlA==
+  dependencies:
+    "@peculiar/asn1-schema" "^2.6.0"
+    asn1js "^3.0.6"
+    pvtsutils "^1.3.6"
+    tslib "^2.8.1"
+
+"@peculiar/x509@^1.14.2":
+  version "1.14.3"
+  resolved "https://registry.yarnpkg.com/@peculiar/x509/-/x509-1.14.3.tgz"
+  integrity sha512-C2Xj8FZ0uHWeCXXqX5B4/gVFQmtSkiuOolzAgutjTfseNOHT3pUjljDZsTSxXFGgio54bCzVFqmEOUrIVk8RDA==
+  dependencies:
+    "@peculiar/asn1-cms" "^2.6.0"
+    "@peculiar/asn1-csr" "^2.6.0"
+    "@peculiar/asn1-ecc" "^2.6.0"
+    "@peculiar/asn1-pkcs9" "^2.6.0"
+    "@peculiar/asn1-rsa" "^2.6.0"
+    "@peculiar/asn1-schema" "^2.6.0"
+    "@peculiar/asn1-x509" "^2.6.0"
+    pvtsutils "^1.3.6"
+    reflect-metadata "^0.2.2"
+    tslib "^2.8.1"
+    tsyringe "^4.10.0"
+
 "@pnpm/config.env-replace@^1.1.0":
   version "1.1.0"
-  resolved "https://registry.npmjs.org/@pnpm/config.env-replace/-/config.env-replace-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/@pnpm/config.env-replace/-/config.env-replace-1.1.0.tgz"
   integrity sha512-htyl8TWnKL7K/ESFa1oW2UB5lVDxuF5DpM7tBi6Hu2LNL3mWkIzNLG6N4zoCUP1lCKNxWy/3iu8mS8MvToGd6w==
 
 "@pnpm/network.ca-file@^1.0.1":
   version "1.0.2"
-  resolved "https://registry.npmjs.org/@pnpm/network.ca-file/-/network.ca-file-1.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/@pnpm/network.ca-file/-/network.ca-file-1.0.2.tgz"
   integrity sha512-YcPQ8a0jwYU9bTdJDpXjMi7Brhkr1mXsXrUJvjqM2mQDgkRiz8jFaQGOdaLxgjtUfQgZhKy/O3cG/YwmgKaxLA==
   dependencies:
     graceful-fs "4.2.10"
 
-"@pnpm/npm-conf@^2.1.0":
-  version "2.3.1"
-  resolved "https://registry.npmjs.org/@pnpm/npm-conf/-/npm-conf-2.3.1.tgz"
-  integrity sha512-c83qWb22rNRuB0UaVCI0uRPNRr8Z0FWnEIvT47jiHAmOIUHbBOg5XvV7pM5x+rKn9HRpjxquDbXYSXr3fAKFcw==
+"@pnpm/npm-conf@^3.0.2":
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/@pnpm/npm-conf/-/npm-conf-3.0.2.tgz"
+  integrity sha512-h104Kh26rR8tm+a3Qkc5S4VLYint3FE48as7+/5oCEcKR2idC/pF1G6AhIXKI+eHPJa/3J9i5z0Al47IeGHPkA==
   dependencies:
     "@pnpm/config.env-replace" "^1.1.0"
     "@pnpm/network.ca-file" "^1.0.1"
     config-chain "^1.1.11"
 
 "@polka/url@^1.0.0-next.24":
-  version "1.0.0-next.28"
-  resolved "https://registry.npmjs.org/@polka/url/-/url-1.0.0-next.28.tgz"
-  integrity sha512-8LduaNlMZGwdZ6qWrKlfa+2M4gahzFkprZiAt2TF8uS0qQgBizKXpXURqvTJ4WtmupWxaLqjRb2UCTe72mu+Aw==
+  version "1.0.0-next.29"
+  resolved "https://registry.yarnpkg.com/@polka/url/-/url-1.0.0-next.29.tgz"
+  integrity sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww==
 
 "@sideway/address@^4.1.5":
   version "4.1.5"
-  resolved "https://registry.npmjs.org/@sideway/address/-/address-4.1.5.tgz"
+  resolved "https://registry.yarnpkg.com/@sideway/address/-/address-4.1.5.tgz"
   integrity sha512-IqO/DUQHUkPeixNQ8n0JA6102hT9CmaljNTPmQ1u8MEhBo/R4Q8eKLN/vGZxuebwOroDB4cbpjheD4+/sKFK4Q==
   dependencies:
     "@hapi/hoek" "^9.0.0"
 
 "@sideway/formula@^3.0.1":
   version "3.0.1"
-  resolved "https://registry.npmjs.org/@sideway/formula/-/formula-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/@sideway/formula/-/formula-3.0.1.tgz"
   integrity sha512-/poHZJJVjx3L+zVD6g9KgHfYnb443oi7wLu/XKojDviHy6HOEOA6z1Trk5aR1dGcmPenJEgb2sK2I80LeS3MIg==
 
 "@sideway/pinpoint@^2.0.0":
   version "2.0.0"
-  resolved "https://registry.npmjs.org/@sideway/pinpoint/-/pinpoint-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@sideway/pinpoint/-/pinpoint-2.0.0.tgz"
   integrity sha512-RNiOoTPkptFtSVzQevY/yWtZwf/RxyVnPy/OcA9HBM3MlGDnBEYL5B41H0MTn0Uec8Hi+2qUtTfG2WWZBmMejQ==
 
 "@sinclair/typebox@^0.27.8":
-  version "0.27.8"
-  resolved "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.8.tgz"
-  integrity sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==
+  version "0.27.10"
+  resolved "https://registry.yarnpkg.com/@sinclair/typebox/-/typebox-0.27.10.tgz"
+  integrity sha512-MTBk/3jGLNB2tVxv6uLlFh1iu64iYOQ2PbdOSK3NW8JZsmlaOh2q6sdtKowBhfw8QFLmYNzTW4/oK4uATIi6ZA==
 
 "@sindresorhus/is@^4.6.0":
   version "4.6.0"
-  resolved "https://registry.npmjs.org/@sindresorhus/is/-/is-4.6.0.tgz"
+  resolved "https://registry.yarnpkg.com/@sindresorhus/is/-/is-4.6.0.tgz"
   integrity sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==
 
 "@sindresorhus/is@^5.2.0":
   version "5.6.0"
-  resolved "https://registry.npmjs.org/@sindresorhus/is/-/is-5.6.0.tgz"
+  resolved "https://registry.yarnpkg.com/@sindresorhus/is/-/is-5.6.0.tgz"
   integrity sha512-TV7t8GKYaJWsn00tFDqBw8+Uqmr8A0fRU1tvTQhyZzGv0sJCGRQL3JGMI3ucuKo3XIZdUP+Lx7/gh2t3lewy7g==
 
 "@slorber/remark-comment@^1.0.0":
   version "1.0.0"
-  resolved "https://registry.npmjs.org/@slorber/remark-comment/-/remark-comment-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@slorber/remark-comment/-/remark-comment-1.0.0.tgz"
   integrity sha512-RCE24n7jsOj1M0UPvIQCHTe7fI0sFL4S2nwKVWwHyVr/wI/H8GosgsJGyhnsZoGFnD/P2hLf1mSbrrgSLN93NA==
   dependencies:
     micromark-factory-space "^1.0.0"
@@ -2161,47 +2456,47 @@
 
 "@svgr/babel-plugin-add-jsx-attribute@8.0.0":
   version "8.0.0"
-  resolved "https://registry.npmjs.org/@svgr/babel-plugin-add-jsx-attribute/-/babel-plugin-add-jsx-attribute-8.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-add-jsx-attribute/-/babel-plugin-add-jsx-attribute-8.0.0.tgz"
   integrity sha512-b9MIk7yhdS1pMCZM8VeNfUlSKVRhsHZNMl5O9SfaX0l0t5wjdgu4IDzGB8bpnGBBOjGST3rRFVsaaEtI4W6f7g==
 
 "@svgr/babel-plugin-remove-jsx-attribute@8.0.0":
   version "8.0.0"
-  resolved "https://registry.npmjs.org/@svgr/babel-plugin-remove-jsx-attribute/-/babel-plugin-remove-jsx-attribute-8.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-remove-jsx-attribute/-/babel-plugin-remove-jsx-attribute-8.0.0.tgz"
   integrity sha512-BcCkm/STipKvbCl6b7QFrMh/vx00vIP63k2eM66MfHJzPr6O2U0jYEViXkHJWqXqQYjdeA9cuCl5KWmlwjDvbA==
 
 "@svgr/babel-plugin-remove-jsx-empty-expression@8.0.0":
   version "8.0.0"
-  resolved "https://registry.npmjs.org/@svgr/babel-plugin-remove-jsx-empty-expression/-/babel-plugin-remove-jsx-empty-expression-8.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-remove-jsx-empty-expression/-/babel-plugin-remove-jsx-empty-expression-8.0.0.tgz"
   integrity sha512-5BcGCBfBxB5+XSDSWnhTThfI9jcO5f0Ai2V24gZpG+wXF14BzwxxdDb4g6trdOux0rhibGs385BeFMSmxtS3uA==
 
 "@svgr/babel-plugin-replace-jsx-attribute-value@8.0.0":
   version "8.0.0"
-  resolved "https://registry.npmjs.org/@svgr/babel-plugin-replace-jsx-attribute-value/-/babel-plugin-replace-jsx-attribute-value-8.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-replace-jsx-attribute-value/-/babel-plugin-replace-jsx-attribute-value-8.0.0.tgz"
   integrity sha512-KVQ+PtIjb1BuYT3ht8M5KbzWBhdAjjUPdlMtpuw/VjT8coTrItWX6Qafl9+ji831JaJcu6PJNKCV0bp01lBNzQ==
 
 "@svgr/babel-plugin-svg-dynamic-title@8.0.0":
   version "8.0.0"
-  resolved "https://registry.npmjs.org/@svgr/babel-plugin-svg-dynamic-title/-/babel-plugin-svg-dynamic-title-8.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-svg-dynamic-title/-/babel-plugin-svg-dynamic-title-8.0.0.tgz"
   integrity sha512-omNiKqwjNmOQJ2v6ge4SErBbkooV2aAWwaPFs2vUY7p7GhVkzRkJ00kILXQvRhA6miHnNpXv7MRnnSjdRjK8og==
 
 "@svgr/babel-plugin-svg-em-dimensions@8.0.0":
   version "8.0.0"
-  resolved "https://registry.npmjs.org/@svgr/babel-plugin-svg-em-dimensions/-/babel-plugin-svg-em-dimensions-8.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-svg-em-dimensions/-/babel-plugin-svg-em-dimensions-8.0.0.tgz"
   integrity sha512-mURHYnu6Iw3UBTbhGwE/vsngtCIbHE43xCRK7kCw4t01xyGqb2Pd+WXekRRoFOBIY29ZoOhUCTEweDMdrjfi9g==
 
 "@svgr/babel-plugin-transform-react-native-svg@8.1.0":
   version "8.1.0"
-  resolved "https://registry.npmjs.org/@svgr/babel-plugin-transform-react-native-svg/-/babel-plugin-transform-react-native-svg-8.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-transform-react-native-svg/-/babel-plugin-transform-react-native-svg-8.1.0.tgz"
   integrity sha512-Tx8T58CHo+7nwJ+EhUwx3LfdNSG9R2OKfaIXXs5soiy5HtgoAEkDay9LIimLOcG8dJQH1wPZp/cnAv6S9CrR1Q==
 
 "@svgr/babel-plugin-transform-svg-component@8.0.0":
   version "8.0.0"
-  resolved "https://registry.npmjs.org/@svgr/babel-plugin-transform-svg-component/-/babel-plugin-transform-svg-component-8.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-transform-svg-component/-/babel-plugin-transform-svg-component-8.0.0.tgz"
   integrity sha512-DFx8xa3cZXTdb/k3kfPeaixecQLgKh5NVBMwD0AQxOzcZawK4oo1Jh9LbrcACUivsCA7TLG8eeWgrDXjTMhRmw==
 
 "@svgr/babel-preset@8.1.0":
   version "8.1.0"
-  resolved "https://registry.npmjs.org/@svgr/babel-preset/-/babel-preset-8.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-preset/-/babel-preset-8.1.0.tgz"
   integrity sha512-7EYDbHE7MxHpv4sxvnVPngw5fuR6pw79SkcrILHJ/iMpuKySNCl5W1qcwPEpU+LgyRXOaAFgH0KhwD18wwg6ug==
   dependencies:
     "@svgr/babel-plugin-add-jsx-attribute" "8.0.0"
@@ -2215,7 +2510,7 @@
 
 "@svgr/core@8.1.0":
   version "8.1.0"
-  resolved "https://registry.npmjs.org/@svgr/core/-/core-8.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/core/-/core-8.1.0.tgz"
   integrity sha512-8QqtOQT5ACVlmsvKOJNEaWmRPmcojMOzCz4Hs2BGG/toAp/K38LcsMRyLp349glq5AzJbCEeimEoxaX6v/fLrA==
   dependencies:
     "@babel/core" "^7.21.3"
@@ -2226,7 +2521,7 @@
 
 "@svgr/hast-util-to-babel-ast@8.0.0":
   version "8.0.0"
-  resolved "https://registry.npmjs.org/@svgr/hast-util-to-babel-ast/-/hast-util-to-babel-ast-8.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/hast-util-to-babel-ast/-/hast-util-to-babel-ast-8.0.0.tgz"
   integrity sha512-EbDKwO9GpfWP4jN9sGdYwPBU0kdomaPIL2Eu4YwmgP+sJeXT+L7bMwJUBnhzfH8Q2qMBqZ4fJwpCyYsAN3mt2Q==
   dependencies:
     "@babel/types" "^7.21.3"
@@ -2234,7 +2529,7 @@
 
 "@svgr/plugin-jsx@8.1.0":
   version "8.1.0"
-  resolved "https://registry.npmjs.org/@svgr/plugin-jsx/-/plugin-jsx-8.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/plugin-jsx/-/plugin-jsx-8.1.0.tgz"
   integrity sha512-0xiIyBsLlr8quN+WyuxooNW9RJ0Dpr8uOnH/xrCVO8GLUcwHISwj1AG0k+LFzteTkAA0GbX0kj9q6Dk70PTiPA==
   dependencies:
     "@babel/core" "^7.21.3"
@@ -2244,7 +2539,7 @@
 
 "@svgr/plugin-svgo@8.1.0":
   version "8.1.0"
-  resolved "https://registry.npmjs.org/@svgr/plugin-svgo/-/plugin-svgo-8.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/plugin-svgo/-/plugin-svgo-8.1.0.tgz"
   integrity sha512-Ywtl837OGO9pTLIN/onoWLmDQ4zFUycI1g76vuKGEz6evR/ZTJlJuz3G/fIkb6OVBJ2g0o6CGJzaEjfmEo3AHA==
   dependencies:
     cosmiconfig "^8.1.3"
@@ -2253,7 +2548,7 @@
 
 "@svgr/webpack@^8.1.0":
   version "8.1.0"
-  resolved "https://registry.npmjs.org/@svgr/webpack/-/webpack-8.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/webpack/-/webpack-8.1.0.tgz"
   integrity sha512-LnhVjMWyMQV9ZmeEy26maJk+8HTIbd59cH4F2MJ439k9DqejRisfFNGAPvRYlKETuh9LrImlS8aKsBgKjMA8WA==
   dependencies:
     "@babel/core" "^7.21.3"
@@ -2267,41 +2562,29 @@
 
 "@szmarczak/http-timer@^5.0.1":
   version "5.0.1"
-  resolved "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-5.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/@szmarczak/http-timer/-/http-timer-5.0.1.tgz"
   integrity sha512-+PmQX0PiAYPMeVYe237LJAYvOMYW1j2rH5YROyS3b4CTVJum34HfRvKvAzozHAQG0TnHNdUfY9nCeUyRAs//cw==
   dependencies:
     defer-to-connect "^2.0.1"
 
-"@trysound/sax@0.2.0":
-  version "0.2.0"
-  resolved "https://registry.npmjs.org/@trysound/sax/-/sax-0.2.0.tgz"
-  integrity sha512-L7z9BgrNEcYyUYtF+HaEfiS5ebkh9jXqbszz7pC0hRBPaatV0XjSD3+eHrpqFemQfgwiFF0QPIarnIihIDn7OA==
-
-"@types/acorn@^4.0.0":
-  version "4.0.6"
-  resolved "https://registry.npmjs.org/@types/acorn/-/acorn-4.0.6.tgz"
-  integrity sha512-veQTnWP+1D/xbxVrPC3zHnCZRjSrKfhbMUlEA43iMZLu7EsnTtkJklIuwrCPbOi8YkvDQAiW05VQQFvvz9oieQ==
-  dependencies:
-    "@types/estree" "*"
-
 "@types/body-parser@*":
-  version "1.19.5"
-  resolved "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.5.tgz"
-  integrity sha512-fB3Zu92ucau0iQ0JMCFQE7b/dv8Ot07NI3KaZIkIUNXq82k4eBAqUaneXfleGY9JWskeS9y+u0nXMyspcuQrCg==
+  version "1.19.6"
+  resolved "https://registry.yarnpkg.com/@types/body-parser/-/body-parser-1.19.6.tgz"
+  integrity sha512-HLFeCYgz89uk22N5Qg3dvGvsv46B8GLvKKo1zKG4NybA8U2DiEO3w9lqGg29t/tfLRJpJ6iQxnVw4OnB7MoM9g==
   dependencies:
     "@types/connect" "*"
     "@types/node" "*"
 
-"@types/bonjour@^3.5.9":
+"@types/bonjour@^3.5.13":
   version "3.5.13"
-  resolved "https://registry.npmjs.org/@types/bonjour/-/bonjour-3.5.13.tgz"
+  resolved "https://registry.yarnpkg.com/@types/bonjour/-/bonjour-3.5.13.tgz"
   integrity sha512-z9fJ5Im06zvUL548KvYNecEVlA7cVDkGUi6kZusb04mpyEFKCIZJvloCcmpmLaIahDpOQGHaHmG6imtPMmPXGQ==
   dependencies:
     "@types/node" "*"
 
-"@types/connect-history-api-fallback@^1.3.5":
+"@types/connect-history-api-fallback@^1.5.4":
   version "1.5.4"
-  resolved "https://registry.npmjs.org/@types/connect-history-api-fallback/-/connect-history-api-fallback-1.5.4.tgz"
+  resolved "https://registry.yarnpkg.com/@types/connect-history-api-fallback/-/connect-history-api-fallback-1.5.4.tgz"
   integrity sha512-n6Cr2xS1h4uAulPRdlw6Jl6s1oG8KrVilPN2yUITEs+K48EzMJJ3W1xy8K5eWuFvjp3R74AOIGSmp2UfBJ8HFw==
   dependencies:
     "@types/express-serve-static-core" "*"
@@ -2309,21 +2592,21 @@
 
 "@types/connect@*":
   version "3.4.38"
-  resolved "https://registry.npmjs.org/@types/connect/-/connect-3.4.38.tgz"
+  resolved "https://registry.yarnpkg.com/@types/connect/-/connect-3.4.38.tgz"
   integrity sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==
   dependencies:
     "@types/node" "*"
 
 "@types/debug@^4.0.0":
-  version "4.1.12"
-  resolved "https://registry.npmjs.org/@types/debug/-/debug-4.1.12.tgz"
-  integrity sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ==
+  version "4.1.13"
+  resolved "https://registry.yarnpkg.com/@types/debug/-/debug-4.1.13.tgz"
+  integrity sha512-KSVgmQmzMwPlmtljOomayoR89W4FynCAi3E8PPs7vmDVPe84hT+vGPKkJfThkmXs0x0jAaa9U8uW8bbfyS2fWw==
   dependencies:
     "@types/ms" "*"
 
 "@types/eslint-scope@^3.7.7":
   version "3.7.7"
-  resolved "https://registry.npmjs.org/@types/eslint-scope/-/eslint-scope-3.7.7.tgz"
+  resolved "https://registry.yarnpkg.com/@types/eslint-scope/-/eslint-scope-3.7.7.tgz"
   integrity sha512-MzMFlSLBqNF2gcHWO0G1vP/YQyfvrxZ0bF+u7mzUdZ1/xK4A4sru+nraZz5i3iEIk1l1uyicaDVTB4QbbEkAYg==
   dependencies:
     "@types/eslint" "*"
@@ -2331,7 +2614,7 @@
 
 "@types/eslint@*":
   version "9.6.1"
-  resolved "https://registry.npmjs.org/@types/eslint/-/eslint-9.6.1.tgz"
+  resolved "https://registry.yarnpkg.com/@types/eslint/-/eslint-9.6.1.tgz"
   integrity sha512-FXx2pKgId/WyYo2jXw63kk7/+TY7u7AziEJxJAnSFzHlqTAS3Ync6SvgYAN/k4/PQpnnVuzoMuVnByKK2qp0ag==
   dependencies:
     "@types/estree" "*"
@@ -2339,178 +2622,170 @@
 
 "@types/estree-jsx@^1.0.0":
   version "1.0.5"
-  resolved "https://registry.npmjs.org/@types/estree-jsx/-/estree-jsx-1.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/@types/estree-jsx/-/estree-jsx-1.0.5.tgz"
   integrity sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg==
   dependencies:
     "@types/estree" "*"
 
-"@types/estree@*", "@types/estree@^1.0.0", "@types/estree@^1.0.6":
-  version "1.0.6"
-  resolved "https://registry.npmjs.org/@types/estree/-/estree-1.0.6.tgz"
-  integrity sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==
+"@types/estree@*", "@types/estree@^1.0.0", "@types/estree@^1.0.8":
+  version "1.0.8"
+  resolved "https://registry.yarnpkg.com/@types/estree/-/estree-1.0.8.tgz"
+  integrity sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==
 
-"@types/express-serve-static-core@*":
-  version "5.0.3"
-  resolved "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-5.0.3.tgz"
-  integrity sha512-JEhMNwUJt7bw728CydvYzntD0XJeTmDnvwLlbfbAhE7Tbslm/ax6bdIiUwTgeVlZTsJQPwZwKpAkyDtIjsvx3g==
+"@types/express-serve-static-core@*", "@types/express-serve-static-core@^5.0.0":
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/@types/express-serve-static-core/-/express-serve-static-core-5.1.1.tgz"
+  integrity sha512-v4zIMr/cX7/d2BpAEX3KNKL/JrT1s43s96lLvvdTmza1oEvDudCqK9aF/djc/SWgy8Yh0h30TZx5VpzqFCxk5A==
   dependencies:
     "@types/node" "*"
     "@types/qs" "*"
     "@types/range-parser" "*"
     "@types/send" "*"
 
-"@types/express-serve-static-core@^4.17.33":
-  version "4.19.6"
-  resolved "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-4.19.6.tgz"
-  integrity sha512-N4LZ2xG7DatVqhCZzOGb1Yi5lMbXSZcmdLDe9EzSndPV2HpWYWzRbaerl2n27irrm94EPpprqa8KpskPT085+A==
+"@types/express-serve-static-core@^4.17.21", "@types/express-serve-static-core@^4.17.33":
+  version "4.19.8"
+  resolved "https://registry.yarnpkg.com/@types/express-serve-static-core/-/express-serve-static-core-4.19.8.tgz"
+  integrity sha512-02S5fmqeoKzVZCHPZid4b8JH2eM5HzQLZWN2FohQEy/0eXTq8VXZfSN6Pcr3F6N9R/vNrj7cpgbhjie6m/1tCA==
   dependencies:
     "@types/node" "*"
     "@types/qs" "*"
     "@types/range-parser" "*"
     "@types/send" "*"
 
-"@types/express@*", "@types/express@^4.17.13":
-  version "4.17.21"
-  resolved "https://registry.npmjs.org/@types/express/-/express-4.17.21.tgz"
-  integrity sha512-ejlPM315qwLpaQlQDTjPdsUFSc6ZsP4AN6AlWnogPjQ7CVi7PYF3YVz+CY3jE2pwYf7E/7HlDAN0rV2GxTG0HQ==
+"@types/express@*":
+  version "5.0.6"
+  resolved "https://registry.yarnpkg.com/@types/express/-/express-5.0.6.tgz"
+  integrity sha512-sKYVuV7Sv9fbPIt/442koC7+IIwK5olP1KWeD88e/idgoJqDm3JV/YUiPwkoKK92ylff2MGxSz1CSjsXelx0YA==
+  dependencies:
+    "@types/body-parser" "*"
+    "@types/express-serve-static-core" "^5.0.0"
+    "@types/serve-static" "^2"
+
+"@types/express@^4.17.25":
+  version "4.17.25"
+  resolved "https://registry.yarnpkg.com/@types/express/-/express-4.17.25.tgz"
+  integrity sha512-dVd04UKsfpINUnK0yBoYHDF3xu7xVH4BuDotC/xGuycx4CgbP48X/KF/586bcObxT0HENHXEU8Nqtu6NR+eKhw==
   dependencies:
     "@types/body-parser" "*"
     "@types/express-serve-static-core" "^4.17.33"
     "@types/qs" "*"
-    "@types/serve-static" "*"
+    "@types/serve-static" "^1"
 
-"@types/gtag.js@^0.0.12":
-  version "0.0.12"
-  resolved "https://registry.npmjs.org/@types/gtag.js/-/gtag.js-0.0.12.tgz"
-  integrity sha512-YQV9bUsemkzG81Ea295/nF/5GijnD2Af7QhEofh7xu+kvCN6RdodgNwwGWXB5GMI3NoyvQo0odNctoH/qLMIpg==
+"@types/gtag.js@^0.0.20":
+  version "0.0.20"
+  resolved "https://registry.yarnpkg.com/@types/gtag.js/-/gtag.js-0.0.20.tgz"
+  integrity sha512-wwAbk3SA2QeU67unN7zPxjEHmPmlXwZXZvQEpbEUQuMCRGgKyE1m6XDuTUA9b6pCGb/GqJmdfMOY5LuDjJSbbg==
 
 "@types/hast@^3.0.0":
   version "3.0.4"
-  resolved "https://registry.npmjs.org/@types/hast/-/hast-3.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/@types/hast/-/hast-3.0.4.tgz"
   integrity sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==
   dependencies:
     "@types/unist" "*"
 
 "@types/history@^4.7.11":
   version "4.7.11"
-  resolved "https://registry.npmjs.org/@types/history/-/history-4.7.11.tgz"
+  resolved "https://registry.yarnpkg.com/@types/history/-/history-4.7.11.tgz"
   integrity sha512-qjDJRrmvBMiTx+jyLxvLfJU7UznFuokDv4f3WRuriHKERccVpFU+8XMQUAbDzoiJCsmexxRExQeMwwCdamSKDA==
 
 "@types/html-minifier-terser@^6.0.0":
   version "6.1.0"
-  resolved "https://registry.npmjs.org/@types/html-minifier-terser/-/html-minifier-terser-6.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/@types/html-minifier-terser/-/html-minifier-terser-6.1.0.tgz"
   integrity sha512-oh/6byDPnL1zeNXFrDXFLyZjkr1MsBG667IM792caf1L2UPOOMf65NFzjUH/ltyfwjAGfs1rsX1eftK0jC/KIg==
 
 "@types/http-cache-semantics@^4.0.2":
-  version "4.0.4"
-  resolved "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.0.4.tgz"
-  integrity sha512-1m0bIFVc7eJWyve9S0RnuRgcQqF/Xd5QsUZAZeQFr1Q3/p9JWoQQEqmVy+DPTNpGXwhgIetAoYF8JSc33q29QA==
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/@types/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz"
+  integrity sha512-L3LgimLHXtGkWikKnsPg0/VFx9OGZaC+eN1u4r+OB1XRqH3meBIAVC2zr1WdMH+RHmnRkqliQAOHNJ/E0j/e0Q==
 
 "@types/http-errors@*":
-  version "2.0.4"
-  resolved "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.4.tgz"
-  integrity sha512-D0CFMMtydbJAegzOyHjtiKPLlvnm3iTZyZRSZoLq2mRhDdmLfIWOCYPfQJ4cu2erKghU++QvjcUjp/5h7hESpA==
+  version "2.0.5"
+  resolved "https://registry.yarnpkg.com/@types/http-errors/-/http-errors-2.0.5.tgz"
+  integrity sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg==
 
 "@types/http-proxy@^1.17.8":
-  version "1.17.15"
-  resolved "https://registry.npmjs.org/@types/http-proxy/-/http-proxy-1.17.15.tgz"
-  integrity sha512-25g5atgiVNTIv0LBDTg1H74Hvayx0ajtJPLLcYE3whFv75J0pWNtOBzaXJQgDTmrX1bx5U9YC2w/n65BN1HwRQ==
+  version "1.17.17"
+  resolved "https://registry.yarnpkg.com/@types/http-proxy/-/http-proxy-1.17.17.tgz"
+  integrity sha512-ED6LB+Z1AVylNTu7hdzuBqOgMnvG/ld6wGCG8wFnAzKX5uyW2K3WD52v0gnLCTK/VLpXtKckgWuyScYK6cSPaw==
   dependencies:
     "@types/node" "*"
 
 "@types/istanbul-lib-coverage@*", "@types/istanbul-lib-coverage@^2.0.0":
   version "2.0.6"
-  resolved "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz"
+  resolved "https://registry.yarnpkg.com/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz"
   integrity sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==
 
 "@types/istanbul-lib-report@*":
   version "3.0.3"
-  resolved "https://registry.npmjs.org/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.3.tgz"
   integrity sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA==
   dependencies:
     "@types/istanbul-lib-coverage" "*"
 
 "@types/istanbul-reports@^3.0.0":
   version "3.0.4"
-  resolved "https://registry.npmjs.org/@types/istanbul-reports/-/istanbul-reports-3.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/@types/istanbul-reports/-/istanbul-reports-3.0.4.tgz"
   integrity sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==
   dependencies:
     "@types/istanbul-lib-report" "*"
 
-"@types/json-schema@*", "@types/json-schema@^7.0.4", "@types/json-schema@^7.0.5", "@types/json-schema@^7.0.8", "@types/json-schema@^7.0.9":
+"@types/json-schema@*", "@types/json-schema@^7.0.15", "@types/json-schema@^7.0.8", "@types/json-schema@^7.0.9":
   version "7.0.15"
-  resolved "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz"
+  resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.15.tgz"
   integrity sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==
 
 "@types/mdast@^4.0.0", "@types/mdast@^4.0.2":
   version "4.0.4"
-  resolved "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/@types/mdast/-/mdast-4.0.4.tgz"
   integrity sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==
   dependencies:
     "@types/unist" "*"
 
 "@types/mdx@^2.0.0":
   version "2.0.13"
-  resolved "https://registry.npmjs.org/@types/mdx/-/mdx-2.0.13.tgz"
+  resolved "https://registry.yarnpkg.com/@types/mdx/-/mdx-2.0.13.tgz"
   integrity sha512-+OWZQfAYyio6YkJb3HLxDrvnx6SWWDbC0zVPfBRzUk0/nqoDyf6dNxQi3eArPe8rJ473nobTMQ/8Zk+LxJ+Yuw==
 
 "@types/mime@^1":
   version "1.3.5"
-  resolved "https://registry.npmjs.org/@types/mime/-/mime-1.3.5.tgz"
+  resolved "https://registry.yarnpkg.com/@types/mime/-/mime-1.3.5.tgz"
   integrity sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==
 
 "@types/ms@*":
-  version "0.7.34"
-  resolved "https://registry.npmjs.org/@types/ms/-/ms-0.7.34.tgz"
-  integrity sha512-nG96G3Wp6acyAgJqGasjODb+acrI7KltPiRxzHPXnP3NgI28bpQDRv53olbqGXbfcgF5aiiHmO3xpwEpS5Ld9g==
-
-"@types/node-forge@^1.3.0":
-  version "1.3.11"
-  resolved "https://registry.npmjs.org/@types/node-forge/-/node-forge-1.3.11.tgz"
-  integrity sha512-FQx220y22OKNTqaByeBGqHWYz4cl94tpcxeFdvBo3wjG6XPBuZ0BNgNZRV5J5TFmmcsJ4IzsLkmGRiQbnYsBEQ==
-  dependencies:
-    "@types/node" "*"
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/@types/ms/-/ms-2.1.0.tgz"
+  integrity sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==
 
 "@types/node@*":
-  version "22.10.4"
-  resolved "https://registry.npmjs.org/@types/node/-/node-22.10.4.tgz"
-  integrity sha512-99l6wv4HEzBQhvaU/UGoeBoCK61SCROQaCCGyQSgX2tEQ3rKkNZ2S7CEWnS/4s1LV+8ODdK21UeyR1fHP2mXug==
+  version "25.6.0"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-25.6.0.tgz"
+  integrity sha512-+qIYRKdNYJwY3vRCZMdJbPLJAtGjQBudzZzdzwQYkEPQd+PJGixUL5QfvCLDaULoLv+RhT3LDkwEfKaAkgSmNQ==
   dependencies:
-    undici-types "~6.20.0"
+    undici-types "~7.19.0"
 
 "@types/node@^17.0.5":
   version "17.0.45"
-  resolved "https://registry.npmjs.org/@types/node/-/node-17.0.45.tgz"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-17.0.45.tgz"
   integrity sha512-w+tIMs3rq2afQdsPJlODhoUEKzFP1ayaoyl1CcnwtIlsVe7K7bA1NGm4s3PraqTLlXnbIN84zuBlxBWo1u9BLw==
 
-"@types/parse-json@^4.0.0":
-  version "4.0.2"
-  resolved "https://registry.npmjs.org/@types/parse-json/-/parse-json-4.0.2.tgz"
-  integrity sha512-dISoDXWWQwUquiKsyZ4Ng+HX2KsPL7LyHKHQwgGFEA3IaKac4Obd+h2a/a6waisAoepJlBcx9paWqjA8/HVjCw==
-
 "@types/prismjs@^1.26.0":
-  version "1.26.5"
-  resolved "https://registry.npmjs.org/@types/prismjs/-/prismjs-1.26.5.tgz"
-  integrity sha512-AUZTa7hQ2KY5L7AmtSiqxlhWxb4ina0yd8hNbl4TWuqnv/pFP0nDMb3YrfSBf4hJVGLh2YEIBfKaBW/9UEl6IQ==
-
-"@types/prop-types@*":
-  version "15.7.14"
-  resolved "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.14.tgz"
-  integrity sha512-gNMvNH49DJ7OJYv+KAKn0Xp45p8PLl6zo2YnvDIbTd4J6MER2BmWN49TG7n9LvkyihINxeKW8+3bfS2yDC9dzQ==
+  version "1.26.6"
+  resolved "https://registry.yarnpkg.com/@types/prismjs/-/prismjs-1.26.6.tgz"
+  integrity sha512-vqlvI7qlMvcCBbVe0AKAb4f97//Hy0EBTaiW8AalRnG/xAN5zOiWWyrNqNXeq8+KAuvRewjCVY1+IPxk4RdNYw==
 
 "@types/qs@*":
-  version "6.9.17"
-  resolved "https://registry.npmjs.org/@types/qs/-/qs-6.9.17.tgz"
-  integrity sha512-rX4/bPcfmvxHDv0XjfJELTTr+iB+tn032nPILqHm5wbthUUUuVtNGGqzhya9XUxjTP8Fpr0qYgSZZKxGY++svQ==
+  version "6.15.0"
+  resolved "https://registry.yarnpkg.com/@types/qs/-/qs-6.15.0.tgz"
+  integrity sha512-JawvT8iBVWpzTrz3EGw9BTQFg3BQNmwERdKE22vlTxawwtbyUSlMppvZYKLZzB5zgACXdXxbD3m1bXaMqP/9ow==
 
 "@types/range-parser@*":
   version "1.2.7"
-  resolved "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.7.tgz"
+  resolved "https://registry.yarnpkg.com/@types/range-parser/-/range-parser-1.2.7.tgz"
   integrity sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==
 
 "@types/react-router-config@*", "@types/react-router-config@^5.0.7":
   version "5.0.11"
-  resolved "https://registry.npmjs.org/@types/react-router-config/-/react-router-config-5.0.11.tgz"
+  resolved "https://registry.yarnpkg.com/@types/react-router-config/-/react-router-config-5.0.11.tgz"
   integrity sha512-WmSAg7WgqW7m4x8Mt4N6ZyKz0BubSj/2tVUMsAHp+Yd2AMwcSbeFq9WympT19p5heCFmF97R9eD5uUR/t4HEqw==
   dependencies:
     "@types/history" "^4.7.11"
@@ -2519,7 +2794,7 @@
 
 "@types/react-router-dom@*":
   version "5.3.3"
-  resolved "https://registry.npmjs.org/@types/react-router-dom/-/react-router-dom-5.3.3.tgz"
+  resolved "https://registry.yarnpkg.com/@types/react-router-dom/-/react-router-dom-5.3.3.tgz"
   integrity sha512-kpqnYK4wcdm5UaWI3fLcELopqLrHgLqNsdpHauzlQktfkHL3npOSwtj1Uz9oKBAzs7lFtVkV8j83voAz2D8fhw==
   dependencies:
     "@types/history" "^4.7.11"
@@ -2528,100 +2803,114 @@
 
 "@types/react-router@*", "@types/react-router@^5.1.0":
   version "5.1.20"
-  resolved "https://registry.npmjs.org/@types/react-router/-/react-router-5.1.20.tgz"
+  resolved "https://registry.yarnpkg.com/@types/react-router/-/react-router-5.1.20.tgz"
   integrity sha512-jGjmu/ZqS7FjSH6owMcD5qpq19+1RS9DeVRqfl1FeBMxTDQAGwlMWOcs52NDoXaNKyG3d1cYQFMs9rCrb88o9Q==
   dependencies:
     "@types/history" "^4.7.11"
     "@types/react" "*"
 
 "@types/react@*":
-  version "18.3.18"
-  resolved "https://registry.npmjs.org/@types/react/-/react-18.3.18.tgz"
-  integrity sha512-t4yC+vtgnkYjNSKlFx1jkAhH8LgTo2N/7Qvi83kdEaUtMDiwpbLAktKDaAMlRcJ5eSxZkH74eEGt1ky31d7kfQ==
+  version "19.2.14"
+  resolved "https://registry.yarnpkg.com/@types/react/-/react-19.2.14.tgz"
+  integrity sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==
   dependencies:
-    "@types/prop-types" "*"
-    csstype "^3.0.2"
+    csstype "^3.2.2"
 
-"@types/retry@0.12.0":
-  version "0.12.0"
-  resolved "https://registry.npmjs.org/@types/retry/-/retry-0.12.0.tgz"
-  integrity sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA==
+"@types/retry@0.12.2":
+  version "0.12.2"
+  resolved "https://registry.yarnpkg.com/@types/retry/-/retry-0.12.2.tgz"
+  integrity sha512-XISRgDJ2Tc5q4TRqvgJtzsRkFYNJzZrhTdtMoGVBttwzzQJkPnS3WWTFc7kuDRoPtPakl+T+OfdEUjYJj7Jbow==
 
 "@types/sax@^1.2.1":
   version "1.2.7"
-  resolved "https://registry.npmjs.org/@types/sax/-/sax-1.2.7.tgz"
+  resolved "https://registry.yarnpkg.com/@types/sax/-/sax-1.2.7.tgz"
   integrity sha512-rO73L89PJxeYM3s3pPPjiPgVVcymqU490g0YO5n5By0k2Erzj6tay/4lr1CHAAU4JyOWd1rpQ8bCf6cZfHU96A==
   dependencies:
     "@types/node" "*"
 
 "@types/send@*":
-  version "0.17.4"
-  resolved "https://registry.npmjs.org/@types/send/-/send-0.17.4.tgz"
-  integrity sha512-x2EM6TJOybec7c52BX0ZspPodMsQUd5L6PRwOunVyVUhXiBSKf3AezDL8Dgvgt5o0UfKNfuA0eMLr2wLT4AiBA==
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/@types/send/-/send-1.2.1.tgz"
+  integrity sha512-arsCikDvlU99zl1g69TcAB3mzZPpxgw0UQnaHeC1Nwb015xp8bknZv5rIfri9xTOcMuaVgvabfIRA7PSZVuZIQ==
+  dependencies:
+    "@types/node" "*"
+
+"@types/send@<1":
+  version "0.17.6"
+  resolved "https://registry.yarnpkg.com/@types/send/-/send-0.17.6.tgz"
+  integrity sha512-Uqt8rPBE8SY0RK8JB1EzVOIZ32uqy8HwdxCnoCOsYrvnswqmFZ/k+9Ikidlk/ImhsdvBsloHbAlewb2IEBV/Og==
   dependencies:
     "@types/mime" "^1"
     "@types/node" "*"
 
-"@types/serve-index@^1.9.1":
+"@types/serve-index@^1.9.4":
   version "1.9.4"
-  resolved "https://registry.npmjs.org/@types/serve-index/-/serve-index-1.9.4.tgz"
+  resolved "https://registry.yarnpkg.com/@types/serve-index/-/serve-index-1.9.4.tgz"
   integrity sha512-qLpGZ/c2fhSs5gnYsQxtDEq3Oy8SXPClIXkW5ghvAvsNuVSA8k+gCONcUCS/UjLEYvYps+e8uBtfgXgvhwfNug==
   dependencies:
     "@types/express" "*"
 
-"@types/serve-static@*", "@types/serve-static@^1.13.10":
-  version "1.15.7"
-  resolved "https://registry.npmjs.org/@types/serve-static/-/serve-static-1.15.7.tgz"
-  integrity sha512-W8Ym+h8nhuRwaKPaDw34QUkwsGi6Rc4yYqvKFo5rm2FUEhCFbzVWrxXUxuKK8TASjWsysJY0nsmNCGhCOIsrOw==
+"@types/serve-static@^1", "@types/serve-static@^1.15.5":
+  version "1.15.10"
+  resolved "https://registry.yarnpkg.com/@types/serve-static/-/serve-static-1.15.10.tgz"
+  integrity sha512-tRs1dB+g8Itk72rlSI2ZrW6vZg0YrLI81iQSTkMmOqnqCaNr/8Ek4VwWcN5vZgCYWbg/JJSGBlUaYGAOP73qBw==
   dependencies:
     "@types/http-errors" "*"
     "@types/node" "*"
-    "@types/send" "*"
+    "@types/send" "<1"
 
-"@types/sockjs@^0.3.33":
+"@types/serve-static@^2":
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/@types/serve-static/-/serve-static-2.2.0.tgz"
+  integrity sha512-8mam4H1NHLtu7nmtalF7eyBH14QyOASmcxHhSfEoRyr0nP/YdoesEtU+uSRvMe96TW/HPTtkoKqQLl53N7UXMQ==
+  dependencies:
+    "@types/http-errors" "*"
+    "@types/node" "*"
+
+"@types/sockjs@^0.3.36":
   version "0.3.36"
-  resolved "https://registry.npmjs.org/@types/sockjs/-/sockjs-0.3.36.tgz"
+  resolved "https://registry.yarnpkg.com/@types/sockjs/-/sockjs-0.3.36.tgz"
   integrity sha512-MK9V6NzAS1+Ud7JV9lJLFqW85VbC9dq3LmwZCuBe4wBDgKC0Kj/jd8Xl+nSviU+Qc3+m7umHHyHg//2KSa0a0Q==
   dependencies:
     "@types/node" "*"
 
 "@types/unist@*", "@types/unist@^3.0.0":
   version "3.0.3"
-  resolved "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/@types/unist/-/unist-3.0.3.tgz"
   integrity sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==
 
 "@types/unist@^2.0.0":
   version "2.0.11"
-  resolved "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz"
+  resolved "https://registry.yarnpkg.com/@types/unist/-/unist-2.0.11.tgz"
   integrity sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==
 
-"@types/ws@^8.5.5":
-  version "8.5.13"
-  resolved "https://registry.npmjs.org/@types/ws/-/ws-8.5.13.tgz"
-  integrity sha512-osM/gWBTPKgHV8XkTunnegTRIsvF6owmf5w+JtAfOw472dptdm0dlGv4xCt6GwQRcC2XVOvvRE/0bAoQcL2QkA==
+"@types/ws@^8.5.10":
+  version "8.18.1"
+  resolved "https://registry.yarnpkg.com/@types/ws/-/ws-8.18.1.tgz"
+  integrity sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==
   dependencies:
     "@types/node" "*"
 
 "@types/yargs-parser@*":
   version "21.0.3"
-  resolved "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-21.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/@types/yargs-parser/-/yargs-parser-21.0.3.tgz"
   integrity sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==
 
 "@types/yargs@^17.0.8":
-  version "17.0.33"
-  resolved "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.33.tgz"
-  integrity sha512-WpxBCKWPLr4xSsHgz511rFJAM+wS28w2zEO1QDNY5zM/S8ok70NNfztH0xwhqKyaK0OHCbN98LDAZuy1ctxDkA==
+  version "17.0.35"
+  resolved "https://registry.yarnpkg.com/@types/yargs/-/yargs-17.0.35.tgz"
+  integrity sha512-qUHkeCyQFxMXg79wQfTtfndEC+N9ZZg76HJftDJp+qH2tV7Gj4OJi7l+PiWwJ+pWtW8GwSmqsDj/oymhrTWXjg==
   dependencies:
     "@types/yargs-parser" "*"
 
 "@ungap/structured-clone@^1.0.0":
-  version "1.2.1"
-  resolved "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.2.1.tgz"
-  integrity sha512-fEzPV3hSkSMltkw152tJKNARhOupqbH96MZWyRjNaYZOMIzbrTeQDG+MTc6Mr2pgzFQzFxAfmhGDNP5QK++2ZA==
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/@ungap/structured-clone/-/structured-clone-1.3.0.tgz"
+  integrity sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==
 
 "@webassemblyjs/ast@1.14.1", "@webassemblyjs/ast@^1.14.1":
   version "1.14.1"
-  resolved "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.14.1.tgz"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/ast/-/ast-1.14.1.tgz"
   integrity sha512-nuBEDgQfm1ccRp/8bCQrx1frohyufl4JlbMMZ4P1wpeOfDhF6FQkxZJ1b/e+PLwr6X1Nhw6OLme5usuBWYBvuQ==
   dependencies:
     "@webassemblyjs/helper-numbers" "1.13.2"
@@ -2629,22 +2918,22 @@
 
 "@webassemblyjs/floating-point-hex-parser@1.13.2":
   version "1.13.2"
-  resolved "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.13.2.tgz"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.13.2.tgz"
   integrity sha512-6oXyTOzbKxGH4steLbLNOu71Oj+C8Lg34n6CqRvqfS2O71BxY6ByfMDRhBytzknj9yGUPVJ1qIKhRlAwO1AovA==
 
 "@webassemblyjs/helper-api-error@1.13.2":
   version "1.13.2"
-  resolved "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.13.2.tgz"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-api-error/-/helper-api-error-1.13.2.tgz"
   integrity sha512-U56GMYxy4ZQCbDZd6JuvvNV/WFildOjsaWD3Tzzvmw/mas3cXzRJPMjP83JqEsgSbyrmaGjBfDtV7KDXV9UzFQ==
 
 "@webassemblyjs/helper-buffer@1.14.1":
   version "1.14.1"
-  resolved "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.14.1.tgz"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-buffer/-/helper-buffer-1.14.1.tgz"
   integrity sha512-jyH7wtcHiKssDtFPRB+iQdxlDf96m0E39yb0k5uJVhFGleZFoNw1c4aeIcVUPPbXUVJ94wwnMOAqUHyzoEPVMA==
 
 "@webassemblyjs/helper-numbers@1.13.2":
   version "1.13.2"
-  resolved "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.13.2.tgz"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-numbers/-/helper-numbers-1.13.2.tgz"
   integrity sha512-FE8aCmS5Q6eQYcV3gI35O4J789wlQA+7JrqTTpJqn5emA4U2hvwJmvFRC0HODS+3Ye6WioDklgd6scJ3+PLnEA==
   dependencies:
     "@webassemblyjs/floating-point-hex-parser" "1.13.2"
@@ -2653,12 +2942,12 @@
 
 "@webassemblyjs/helper-wasm-bytecode@1.13.2":
   version "1.13.2"
-  resolved "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.13.2.tgz"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.13.2.tgz"
   integrity sha512-3QbLKy93F0EAIXLh0ogEVR6rOubA9AoZ+WRYhNbFyuB70j3dRdwH9g+qXhLAO0kiYGlg3TxDV+I4rQTr/YNXkA==
 
 "@webassemblyjs/helper-wasm-section@1.14.1":
   version "1.14.1"
-  resolved "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.14.1.tgz"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.14.1.tgz"
   integrity sha512-ds5mXEqTJ6oxRoqjhWDU83OgzAYjwsCV8Lo/N+oRsNDmx/ZDpqalmrtgOMkHwxsG0iI//3BwWAErYRHtgn0dZw==
   dependencies:
     "@webassemblyjs/ast" "1.14.1"
@@ -2668,26 +2957,26 @@
 
 "@webassemblyjs/ieee754@1.13.2":
   version "1.13.2"
-  resolved "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.13.2.tgz"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/ieee754/-/ieee754-1.13.2.tgz"
   integrity sha512-4LtOzh58S/5lX4ITKxnAK2USuNEvpdVV9AlgGQb8rJDHaLeHciwG4zlGr0j/SNWlr7x3vO1lDEsuePvtcDNCkw==
   dependencies:
     "@xtuc/ieee754" "^1.2.0"
 
 "@webassemblyjs/leb128@1.13.2":
   version "1.13.2"
-  resolved "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.13.2.tgz"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/leb128/-/leb128-1.13.2.tgz"
   integrity sha512-Lde1oNoIdzVzdkNEAWZ1dZ5orIbff80YPdHx20mrHwHrVNNTjNr8E3xz9BdpcGqRQbAEa+fkrCb+fRFTl/6sQw==
   dependencies:
     "@xtuc/long" "4.2.2"
 
 "@webassemblyjs/utf8@1.13.2":
   version "1.13.2"
-  resolved "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.13.2.tgz"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/utf8/-/utf8-1.13.2.tgz"
   integrity sha512-3NQWGjKTASY1xV5m7Hr0iPeXD9+RDobLll3T9d2AO+g3my8xy5peVyjSag4I50mR1bBSN/Ct12lo+R9tJk0NZQ==
 
 "@webassemblyjs/wasm-edit@^1.14.1":
   version "1.14.1"
-  resolved "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.14.1.tgz"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-edit/-/wasm-edit-1.14.1.tgz"
   integrity sha512-RNJUIQH/J8iA/1NzlE4N7KtyZNHi3w7at7hDjvRNm5rcUXa00z1vRz3glZoULfJ5mpvYhLybmVcwcjGrC1pRrQ==
   dependencies:
     "@webassemblyjs/ast" "1.14.1"
@@ -2701,7 +2990,7 @@
 
 "@webassemblyjs/wasm-gen@1.14.1":
   version "1.14.1"
-  resolved "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.14.1.tgz"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-gen/-/wasm-gen-1.14.1.tgz"
   integrity sha512-AmomSIjP8ZbfGQhumkNvgC33AY7qtMCXnN6bL2u2Js4gVCg8fp735aEiMSBbDR7UQIj90n4wKAFUSEd0QN2Ukg==
   dependencies:
     "@webassemblyjs/ast" "1.14.1"
@@ -2712,7 +3001,7 @@
 
 "@webassemblyjs/wasm-opt@1.14.1":
   version "1.14.1"
-  resolved "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.14.1.tgz"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-opt/-/wasm-opt-1.14.1.tgz"
   integrity sha512-PTcKLUNvBqnY2U6E5bdOQcSM+oVP/PmrDY9NzowJjislEjwP/C4an2303MCVS2Mg9d3AJpIGdUFIQQWbPds0Sw==
   dependencies:
     "@webassemblyjs/ast" "1.14.1"
@@ -2722,7 +3011,7 @@
 
 "@webassemblyjs/wasm-parser@1.14.1", "@webassemblyjs/wasm-parser@^1.14.1":
   version "1.14.1"
-  resolved "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.14.1.tgz"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-parser/-/wasm-parser-1.14.1.tgz"
   integrity sha512-JLBl+KZ0R5qB7mCnud/yyX08jWFw5MsoalJ1pQ4EdFlgj9VdXKGuENGsiCIjegI1W7p91rUlcB/LB5yRJKNTcQ==
   dependencies:
     "@webassemblyjs/ast" "1.14.1"
@@ -2734,7 +3023,7 @@
 
 "@webassemblyjs/wast-printer@1.14.1":
   version "1.14.1"
-  resolved "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.14.1.tgz"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wast-printer/-/wast-printer-1.14.1.tgz"
   integrity sha512-kPSSXE6De1XOR820C90RIo2ogvZG+c3KiHzqUoO/F34Y2shGzesfqv7o57xrxovZJH/MetF5UjroJ/R/3isoiw==
   dependencies:
     "@webassemblyjs/ast" "1.14.1"
@@ -2742,47 +3031,52 @@
 
 "@xtuc/ieee754@^1.2.0":
   version "1.2.0"
-  resolved "https://registry.npmjs.org/@xtuc/ieee754/-/ieee754-1.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/@xtuc/ieee754/-/ieee754-1.2.0.tgz"
   integrity sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA==
 
 "@xtuc/long@4.2.2":
   version "4.2.2"
-  resolved "https://registry.npmjs.org/@xtuc/long/-/long-4.2.2.tgz"
+  resolved "https://registry.yarnpkg.com/@xtuc/long/-/long-4.2.2.tgz"
   integrity sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==
 
-accepts@~1.3.4, accepts@~1.3.8:
+accepts@~1.3.8:
   version "1.3.8"
-  resolved "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz"
+  resolved "https://registry.yarnpkg.com/accepts/-/accepts-1.3.8.tgz"
   integrity sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==
   dependencies:
     mime-types "~2.1.34"
     negotiator "0.6.3"
 
+acorn-import-phases@^1.0.3:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/acorn-import-phases/-/acorn-import-phases-1.0.4.tgz"
+  integrity sha512-wKmbr/DDiIXzEOiWrTTUcDm24kQ2vGfZQvM2fwg2vXqR5uW6aapr7ObPtj1th32b9u90/Pf4AItvdTh42fBmVQ==
+
 acorn-jsx@^5.0.0:
   version "5.3.2"
-  resolved "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz"
+  resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.2.tgz"
   integrity sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==
 
 acorn-walk@^8.0.0:
-  version "8.3.4"
-  resolved "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.4.tgz"
-  integrity sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==
+  version "8.3.5"
+  resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-8.3.5.tgz"
+  integrity sha512-HEHNfbars9v4pgpW6SO1KSPkfoS0xVOM/9UzkJltjlsHZmJasxg8aXkuZa7SMf8vKGIBhpUsPluQSqhJFCqebw==
   dependencies:
     acorn "^8.11.0"
 
-acorn@^8.0.0, acorn@^8.0.4, acorn@^8.11.0, acorn@^8.14.0, acorn@^8.8.2:
-  version "8.14.0"
-  resolved "https://registry.npmjs.org/acorn/-/acorn-8.14.0.tgz"
-  integrity sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==
+acorn@^8.0.0, acorn@^8.0.4, acorn@^8.11.0, acorn@^8.15.0, acorn@^8.16.0:
+  version "8.16.0"
+  resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.16.0.tgz"
+  integrity sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==
 
-address@^1.0.1, address@^1.1.2:
+address@^1.0.1:
   version "1.2.2"
-  resolved "https://registry.npmjs.org/address/-/address-1.2.2.tgz"
+  resolved "https://registry.yarnpkg.com/address/-/address-1.2.2.tgz"
   integrity sha512-4B/qKCfeE/ODUaAUpSwfzazo5x29WD4r3vXiWsB7I2mSDAihwEqKO+g8GELZUQSSAo5e1XTYh3ZVfLyxBc12nA==
 
 aggregate-error@^3.0.0:
   version "3.1.0"
-  resolved "https://registry.npmjs.org/aggregate-error/-/aggregate-error-3.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/aggregate-error/-/aggregate-error-3.1.0.tgz"
   integrity sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==
   dependencies:
     clean-stack "^2.0.0"
@@ -2790,27 +3084,27 @@ aggregate-error@^3.0.0:
 
 ajv-formats@^2.1.1:
   version "2.1.1"
-  resolved "https://registry.npmjs.org/ajv-formats/-/ajv-formats-2.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/ajv-formats/-/ajv-formats-2.1.1.tgz"
   integrity sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA==
   dependencies:
     ajv "^8.0.0"
 
-ajv-keywords@^3.4.1, ajv-keywords@^3.5.2:
+ajv-keywords@^3.5.2:
   version "3.5.2"
-  resolved "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz"
+  resolved "https://registry.yarnpkg.com/ajv-keywords/-/ajv-keywords-3.5.2.tgz"
   integrity sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==
 
 ajv-keywords@^5.1.0:
   version "5.1.0"
-  resolved "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/ajv-keywords/-/ajv-keywords-5.1.0.tgz"
   integrity sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==
   dependencies:
     fast-deep-equal "^3.1.3"
 
-ajv@^6.12.2, ajv@^6.12.5:
-  version "6.12.6"
-  resolved "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz"
-  integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==
+ajv@^6.12.5:
+  version "6.15.0"
+  resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.15.0.tgz"
+  integrity sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==
   dependencies:
     fast-deep-equal "^3.1.1"
     fast-json-stable-stringify "^2.0.0"
@@ -2818,106 +3112,84 @@ ajv@^6.12.2, ajv@^6.12.5:
     uri-js "^4.2.2"
 
 ajv@^8.0.0, ajv@^8.9.0:
-  version "8.17.1"
-  resolved "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz"
-  integrity sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==
+  version "8.20.0"
+  resolved "https://registry.yarnpkg.com/ajv/-/ajv-8.20.0.tgz"
+  integrity sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==
   dependencies:
     fast-deep-equal "^3.1.3"
     fast-uri "^3.0.1"
     json-schema-traverse "^1.0.0"
     require-from-string "^2.0.2"
 
-algoliasearch-helper@^3.13.3:
-  version "3.22.6"
-  resolved "https://registry.npmjs.org/algoliasearch-helper/-/algoliasearch-helper-3.22.6.tgz"
-  integrity sha512-F2gSb43QHyvZmvH/2hxIjbk/uFdO2MguQYTFP7J+RowMW1csjIODMobEnpLI8nbLQuzZnGZdIxl5Bpy1k9+CFQ==
+algoliasearch-helper@^3.26.0:
+  version "3.28.2"
+  resolved "https://registry.yarnpkg.com/algoliasearch-helper/-/algoliasearch-helper-3.28.2.tgz"
+  integrity sha512-sexVcXLHrJN54+S0wXD52xV3ySeGZA5T6HMDkb84wT+3UcXCd8af/k2vU5qJTbHv7DoBb4mISJHdyQ2JOo3Aig==
   dependencies:
     "@algolia/events" "^4.0.1"
 
-algoliasearch@^4.18.0:
-  version "4.24.0"
-  resolved "https://registry.npmjs.org/algoliasearch/-/algoliasearch-4.24.0.tgz"
-  integrity sha512-bf0QV/9jVejssFBmz2HQLxUadxk574t4iwjCKp5E7NBzwKkrDEhKPISIIjAU/p6K5qDx3qoeh4+26zWN1jmw3g==
-  dependencies:
-    "@algolia/cache-browser-local-storage" "4.24.0"
-    "@algolia/cache-common" "4.24.0"
-    "@algolia/cache-in-memory" "4.24.0"
-    "@algolia/client-account" "4.24.0"
-    "@algolia/client-analytics" "4.24.0"
-    "@algolia/client-common" "4.24.0"
-    "@algolia/client-personalization" "4.24.0"
-    "@algolia/client-search" "4.24.0"
-    "@algolia/logger-common" "4.24.0"
-    "@algolia/logger-console" "4.24.0"
-    "@algolia/recommend" "4.24.0"
-    "@algolia/requester-browser-xhr" "4.24.0"
-    "@algolia/requester-common" "4.24.0"
-    "@algolia/requester-node-http" "4.24.0"
-    "@algolia/transporter" "4.24.0"
-
-algoliasearch@^5.14.2:
-  version "5.18.0"
-  resolved "https://registry.npmjs.org/algoliasearch/-/algoliasearch-5.18.0.tgz"
-  integrity sha512-/tfpK2A4FpS0o+S78o3YSdlqXr0MavJIDlFK3XZrlXLy7vaRXJvW5jYg3v5e/wCaF8y0IpMjkYLhoV6QqfpOgw==
-  dependencies:
-    "@algolia/client-abtesting" "5.18.0"
-    "@algolia/client-analytics" "5.18.0"
-    "@algolia/client-common" "5.18.0"
-    "@algolia/client-insights" "5.18.0"
-    "@algolia/client-personalization" "5.18.0"
-    "@algolia/client-query-suggestions" "5.18.0"
-    "@algolia/client-search" "5.18.0"
-    "@algolia/ingestion" "1.18.0"
-    "@algolia/monitoring" "1.18.0"
-    "@algolia/recommend" "5.18.0"
-    "@algolia/requester-browser-xhr" "5.18.0"
-    "@algolia/requester-fetch" "5.18.0"
-    "@algolia/requester-node-http" "5.18.0"
+algoliasearch@^5.37.0:
+  version "5.51.0"
+  resolved "https://registry.yarnpkg.com/algoliasearch/-/algoliasearch-5.51.0.tgz"
+  integrity sha512-u3XS8HaTzt5YN90KPsOXMRjYJUMVD1dtr6yi4NXQluMbZ5IjQNBu1MEabdAxFhYtEuexqomPMSmRIhQJUd3QSg==
+  dependencies:
+    "@algolia/abtesting" "1.17.0"
+    "@algolia/client-abtesting" "5.51.0"
+    "@algolia/client-analytics" "5.51.0"
+    "@algolia/client-common" "5.51.0"
+    "@algolia/client-insights" "5.51.0"
+    "@algolia/client-personalization" "5.51.0"
+    "@algolia/client-query-suggestions" "5.51.0"
+    "@algolia/client-search" "5.51.0"
+    "@algolia/ingestion" "1.51.0"
+    "@algolia/monitoring" "1.51.0"
+    "@algolia/recommend" "5.51.0"
+    "@algolia/requester-browser-xhr" "5.51.0"
+    "@algolia/requester-fetch" "5.51.0"
+    "@algolia/requester-node-http" "5.51.0"
 
 ansi-align@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/ansi-align/-/ansi-align-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/ansi-align/-/ansi-align-3.0.1.tgz"
   integrity sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==
   dependencies:
     string-width "^4.1.0"
 
-ansi-escapes@^4.3.2:
-  version "4.3.2"
-  resolved "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz"
-  integrity sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==
-  dependencies:
-    type-fest "^0.21.3"
-
 ansi-html-community@^0.0.8:
   version "0.0.8"
-  resolved "https://registry.npmjs.org/ansi-html-community/-/ansi-html-community-0.0.8.tgz"
+  resolved "https://registry.yarnpkg.com/ansi-html-community/-/ansi-html-community-0.0.8.tgz"
   integrity sha512-1APHAyr3+PCamwNw3bXCPp4HFLONZt/yIH0sZp0/469KWNTEy+qN5jQ3GVX6DMZ1UXAi34yVwtTeaG/HpBuuzw==
 
 ansi-regex@^5.0.1:
   version "5.0.1"
-  resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.1.tgz"
   integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==
 
-ansi-regex@^6.0.1:
-  version "6.1.0"
-  resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz"
-  integrity sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==
+ansi-regex@^6.2.2:
+  version "6.2.2"
+  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-6.2.2.tgz"
+  integrity sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==
 
-ansi-styles@^4.0.0, ansi-styles@^4.1.0:
+ansi-styles@^4.1.0:
   version "4.3.0"
-  resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz"
   integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==
   dependencies:
     color-convert "^2.0.1"
 
 ansi-styles@^6.1.0:
-  version "6.2.1"
-  resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz"
-  integrity sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==
+  version "6.2.3"
+  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-6.2.3.tgz"
+  integrity sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==
+
+ansis@^3.2.0:
+  version "3.17.0"
+  resolved "https://registry.yarnpkg.com/ansis/-/ansis-3.17.0.tgz#fa8d9c2a93fe7d1177e0c17f9eeb562a58a832d7"
+  integrity sha512-0qWUglt9JEqLFr3w1I1pbrChn1grhaiAR2ocX1PP/flRmxgtwTzPFFFnfIlD6aMOLQZgSuCRlidD70lvx8yhzg==
 
 anymatch@~3.1.2:
   version "3.1.3"
-  resolved "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz"
+  resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-3.1.3.tgz"
   integrity sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==
   dependencies:
     normalize-path "^3.0.0"
@@ -2925,70 +3197,73 @@ anymatch@~3.1.2:
 
 arg@^5.0.0:
   version "5.0.2"
-  resolved "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/arg/-/arg-5.0.2.tgz"
   integrity sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==
 
 argparse@^1.0.7:
   version "1.0.10"
-  resolved "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz"
+  resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.10.tgz"
   integrity sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==
   dependencies:
     sprintf-js "~1.0.2"
 
 argparse@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/argparse/-/argparse-2.0.1.tgz"
   integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==
 
 array-flatten@1.1.1:
   version "1.1.1"
-  resolved "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/array-flatten/-/array-flatten-1.1.1.tgz"
   integrity sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==
 
 array-union@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/array-union/-/array-union-2.1.0.tgz"
   integrity sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==
 
+asn1js@^3.0.6:
+  version "3.0.10"
+  resolved "https://registry.yarnpkg.com/asn1js/-/asn1js-3.0.10.tgz"
+  integrity sha512-S2s3aOytiKdFRdulw2qPE51MzjzVOisppcVv7jVFR+Kw0kxwvFrDcYA0h7Ndqbmj0HkMIXYWaoj7fli8kgx1eg==
+  dependencies:
+    pvtsutils "^1.3.6"
+    pvutils "^1.1.5"
+    tslib "^2.8.1"
+
 astring@^1.8.0:
   version "1.9.0"
-  resolved "https://registry.npmjs.org/astring/-/astring-1.9.0.tgz"
+  resolved "https://registry.yarnpkg.com/astring/-/astring-1.9.0.tgz"
   integrity sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg==
 
 asynckit@^0.4.0:
   version "0.4.0"
-  resolved "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz"
+  resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz"
   integrity sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==
 
-at-least-node@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz"
-  integrity sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==
-
-autoprefixer@^10.4.19:
-  version "10.4.20"
-  resolved "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.20.tgz"
-  integrity sha512-XY25y5xSv/wEoqzDyXXME4AFfkZI0P23z6Fs3YgymDnKJkCGOnkL0iTxCa85UTqaSgfcqyf3UA6+c7wUvx/16g==
-  dependencies:
-    browserslist "^4.23.3"
-    caniuse-lite "^1.0.30001646"
-    fraction.js "^4.3.7"
-    normalize-range "^0.1.2"
-    picocolors "^1.0.1"
+autoprefixer@^10.4.19, autoprefixer@^10.4.23:
+  version "10.5.0"
+  resolved "https://registry.yarnpkg.com/autoprefixer/-/autoprefixer-10.5.0.tgz"
+  integrity sha512-FMhOoZV4+qR6aTUALKX2rEqGG+oyATvwBt9IIzVR5rMa2HRWPkxf+P+PAJLD1I/H5/II+HuZcBJYEFBpq39ong==
+  dependencies:
+    browserslist "^4.28.2"
+    caniuse-lite "^1.0.30001787"
+    fraction.js "^5.3.4"
+    picocolors "^1.1.1"
     postcss-value-parser "^4.2.0"
 
 axios@^1.7.9:
-  version "1.7.9"
-  resolved "https://registry.npmjs.org/axios/-/axios-1.7.9.tgz"
-  integrity sha512-LhLcE7Hbiryz8oMDdDptSrWowmB4Bl6RCt6sIJKpRB4XtVf0iEgewX3au/pJqm+Py1kCASkb/FFKjxQaLtxJvw==
+  version "1.15.2"
+  resolved "https://registry.yarnpkg.com/axios/-/axios-1.15.2.tgz"
+  integrity sha512-wLrXxPtcrPTsNlJmKjkPnNPK2Ihe0hn0wGSaTEiHRPxwjvJwT3hKmXF4dpqxmPO9SoNb2FsYXj/xEo0gHN+D5A==
   dependencies:
-    follow-redirects "^1.15.6"
-    form-data "^4.0.0"
-    proxy-from-env "^1.1.0"
+    follow-redirects "^1.15.11"
+    form-data "^4.0.5"
+    proxy-from-env "^2.1.0"
 
 babel-loader@^9.2.1:
   version "9.2.1"
-  resolved "https://registry.npmjs.org/babel-loader/-/babel-loader-9.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/babel-loader/-/babel-loader-9.2.1.tgz"
   integrity sha512-fqe8naHt46e0yIdkjUZYqddSXfej3AHajX+CSO5X7oy0EmPc6o5Xh+RClNoHjnieWz9AW4kZxW9yyFMhVB1QLA==
   dependencies:
     find-cache-dir "^4.0.0"
@@ -2996,81 +3271,94 @@ babel-loader@^9.2.1:
 
 babel-plugin-dynamic-import-node@^2.3.3:
   version "2.3.3"
-  resolved "https://registry.npmjs.org/babel-plugin-dynamic-import-node/-/babel-plugin-dynamic-import-node-2.3.3.tgz"
+  resolved "https://registry.yarnpkg.com/babel-plugin-dynamic-import-node/-/babel-plugin-dynamic-import-node-2.3.3.tgz"
   integrity sha512-jZVI+s9Zg3IqA/kdi0i6UDCybUI3aSBLnglhYbSSjKlV7yF1F/5LWv8MakQmvYpnbJDS6fcBL2KzHSxNCMtWSQ==
   dependencies:
     object.assign "^4.1.0"
 
-babel-plugin-polyfill-corejs2@^0.4.10:
-  version "0.4.12"
-  resolved "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.12.tgz"
-  integrity sha512-CPWT6BwvhrTO2d8QVorhTCQw9Y43zOu7G9HigcfxvepOU6b8o3tcWad6oVgZIsZCTt42FFv97aA7ZJsbM4+8og==
+babel-plugin-polyfill-corejs2@^0.4.14, babel-plugin-polyfill-corejs2@^0.4.15:
+  version "0.4.17"
+  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.17.tgz"
+  integrity sha512-aTyf30K/rqAsNwN76zYrdtx8obu0E4KoUME29B1xj+B3WxgvWkp943vYQ+z8Mv3lw9xHXMHpvSPOBxzAkIa94w==
   dependencies:
-    "@babel/compat-data" "^7.22.6"
-    "@babel/helper-define-polyfill-provider" "^0.6.3"
+    "@babel/compat-data" "^7.28.6"
+    "@babel/helper-define-polyfill-provider" "^0.6.8"
     semver "^6.3.1"
 
-babel-plugin-polyfill-corejs3@^0.10.6:
-  version "0.10.6"
-  resolved "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.10.6.tgz"
-  integrity sha512-b37+KR2i/khY5sKmWNVQAnitvquQbNdWy6lJdsr0kmquCKEEUgMKK4SboVM3HtfnZilfjr4MMQ7vY58FVWDtIA==
+babel-plugin-polyfill-corejs3@^0.13.0:
+  version "0.13.0"
+  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.13.0.tgz"
+  integrity sha512-U+GNwMdSFgzVmfhNm8GJUX88AadB3uo9KpJqS3FaqNIPKgySuvMb+bHPsOmmuWyIcuqZj/pzt1RUIUZns4y2+A==
   dependencies:
-    "@babel/helper-define-polyfill-provider" "^0.6.2"
-    core-js-compat "^3.38.0"
+    "@babel/helper-define-polyfill-provider" "^0.6.5"
+    core-js-compat "^3.43.0"
 
-babel-plugin-polyfill-regenerator@^0.6.1:
-  version "0.6.3"
-  resolved "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.6.3.tgz"
-  integrity sha512-LiWSbl4CRSIa5x/JAU6jZiG9eit9w6mz+yVMFwDE83LAWvt0AfGBoZ7HS/mkhrKuh2ZlzfVZYKoLjXdqw6Yt7Q==
+babel-plugin-polyfill-corejs3@^0.14.0:
+  version "0.14.2"
+  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.14.2.tgz"
+  integrity sha512-coWpDLJ410R781Npmn/SIBZEsAetR4xVi0SxLMXPaMO4lSf1MwnkGYMtkFxew0Dn8B3/CpbpYxN0JCgg8mn67g==
   dependencies:
-    "@babel/helper-define-polyfill-provider" "^0.6.3"
+    "@babel/helper-define-polyfill-provider" "^0.6.8"
+    core-js-compat "^3.48.0"
+
+babel-plugin-polyfill-regenerator@^0.6.5, babel-plugin-polyfill-regenerator@^0.6.6:
+  version "0.6.8"
+  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.6.8.tgz"
+  integrity sha512-M762rNHfSF1EV3SLtnCJXFoQbbIIz0OyRwnCmV0KPC7qosSfCO0QLTSuJX3ayAebubhE6oYBAYPrBA5ljowaZg==
+  dependencies:
+    "@babel/helper-define-polyfill-provider" "^0.6.8"
 
 bail@^2.0.0:
   version "2.0.2"
-  resolved "https://registry.npmjs.org/bail/-/bail-2.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/bail/-/bail-2.0.2.tgz"
   integrity sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==
 
 balanced-match@^1.0.0:
   version "1.0.2"
-  resolved "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz"
   integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==
 
+baseline-browser-mapping@^2.10.12:
+  version "2.10.24"
+  resolved "https://registry.yarnpkg.com/baseline-browser-mapping/-/baseline-browser-mapping-2.10.24.tgz"
+  integrity sha512-I2NkZOOrj2XuguvWCK6OVh9GavsNjZjK908Rq3mIBK25+GD8vPX5w2WdxVqnQ7xx3SrZJiCiZFu+/Oz50oSYSA==
+
 batch@0.6.1:
   version "0.6.1"
-  resolved "https://registry.npmjs.org/batch/-/batch-0.6.1.tgz"
+  resolved "https://registry.yarnpkg.com/batch/-/batch-0.6.1.tgz"
   integrity sha512-x+VAiMRL6UPkx+kudNvxTl6hB2XNNCG2r+7wixVfIYwu/2HKRXimwQyaumLjMveWvT2Hkd/cAJw+QBMfJ/EKVw==
 
 big.js@^5.2.2:
   version "5.2.2"
-  resolved "https://registry.npmjs.org/big.js/-/big.js-5.2.2.tgz"
+  resolved "https://registry.yarnpkg.com/big.js/-/big.js-5.2.2.tgz"
   integrity sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==
 
 binary-extensions@^2.0.0:
   version "2.3.0"
-  resolved "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-2.3.0.tgz"
   integrity sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==
 
-body-parser@1.20.3:
-  version "1.20.3"
-  resolved "https://registry.npmjs.org/body-parser/-/body-parser-1.20.3.tgz"
-  integrity sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==
+body-parser@~1.20.3:
+  version "1.20.5"
+  resolved "https://registry.yarnpkg.com/body-parser/-/body-parser-1.20.5.tgz"
+  integrity sha512-3grm+/2tUOvu2cjJkvsIxrv/wVpfXQW4PsQHYm7yk4vfpu7Ekl6nEsYBoJUL6qDwZUx8wUhQ8tR2qz+ad9c9OA==
   dependencies:
-    bytes "3.1.2"
+    bytes "~3.1.2"
     content-type "~1.0.5"
     debug "2.6.9"
     depd "2.0.0"
-    destroy "1.2.0"
-    http-errors "2.0.0"
-    iconv-lite "0.4.24"
-    on-finished "2.4.1"
-    qs "6.13.0"
-    raw-body "2.5.2"
+    destroy "~1.2.0"
+    http-errors "~2.0.1"
+    iconv-lite "~0.4.24"
+    on-finished "~2.4.1"
+    qs "~6.15.1"
+    raw-body "~2.5.3"
     type-is "~1.6.18"
-    unpipe "1.0.0"
+    unpipe "~1.0.0"
 
-bonjour-service@^1.0.11:
+bonjour-service@^1.2.1:
   version "1.3.0"
-  resolved "https://registry.npmjs.org/bonjour-service/-/bonjour-service-1.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/bonjour-service/-/bonjour-service-1.3.0.tgz"
   integrity sha512-3YuAUiSkWykd+2Azjgyxei8OWf8thdn8AITIog2M4UICzoqfjlqr64WIjEXZllf/W6vK1goqleSR6brGomxQqA==
   dependencies:
     fast-deep-equal "^3.1.3"
@@ -3078,12 +3366,12 @@ bonjour-service@^1.0.11:
 
 boolbase@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/boolbase/-/boolbase-1.0.0.tgz"
   integrity sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==
 
 boxen@^6.2.1:
   version "6.2.1"
-  resolved "https://registry.npmjs.org/boxen/-/boxen-6.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/boxen/-/boxen-6.2.1.tgz"
   integrity sha512-H4PEsJXfFI/Pt8sjDWbHlQPx4zL/bvSQjcilJmaulGt5mLDorHOHpmdXAJcBcmru7PhYSp/cDMWRko4ZUMFkSw==
   dependencies:
     ansi-align "^3.0.1"
@@ -3097,7 +3385,7 @@ boxen@^6.2.1:
 
 boxen@^7.0.0:
   version "7.1.1"
-  resolved "https://registry.npmjs.org/boxen/-/boxen-7.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/boxen/-/boxen-7.1.1.tgz"
   integrity sha512-2hCgjEmP8YLWQ130n2FerGv7rYpfBmnmp9Uy2Le1vge6X3gZIfSmEzP5QTDElFxcvVcXlEn8Aq6MU/PZygIOog==
   dependencies:
     ansi-align "^3.0.1"
@@ -3110,53 +3398,66 @@ boxen@^7.0.0:
     wrap-ansi "^8.1.0"
 
 brace-expansion@^1.1.7:
-  version "1.1.12"
-  resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.12.tgz#ab9b454466e5a8cc3a187beaad580412a9c5b843"
-  integrity sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==
+  version "1.1.14"
+  resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.14.tgz"
+  integrity sha512-MWPGfDxnyzKU7rNOW9SP/c50vi3xrmrua/+6hfPbCS2ABNWfx24vPidzvC7krjU/RTo235sV776ymlsMtGKj8g==
   dependencies:
     balanced-match "^1.0.0"
     concat-map "0.0.1"
 
 braces@^3.0.3, braces@~3.0.2:
   version "3.0.3"
-  resolved "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.3.tgz"
   integrity sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==
   dependencies:
     fill-range "^7.1.1"
 
-browserslist@^4.0.0, browserslist@^4.18.1, browserslist@^4.23.0, browserslist@^4.23.1, browserslist@^4.23.3, browserslist@^4.24.0, browserslist@^4.24.2:
-  version "4.24.3"
-  resolved "https://registry.npmjs.org/browserslist/-/browserslist-4.24.3.tgz"
-  integrity sha512-1CPmv8iobE2fyRMV97dAcMVegvvWKxmq94hkLiAkUGwKVTyDLw33K+ZxiFrREKmmps4rIw6grcCFCnTMSZ/YiA==
+browserslist@^4.0.0, browserslist@^4.23.0, browserslist@^4.24.0, browserslist@^4.28.1, browserslist@^4.28.2:
+  version "4.28.2"
+  resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.28.2.tgz"
+  integrity sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==
   dependencies:
-    caniuse-lite "^1.0.30001688"
-    electron-to-chromium "^1.5.73"
-    node-releases "^2.0.19"
-    update-browserslist-db "^1.1.1"
+    baseline-browser-mapping "^2.10.12"
+    caniuse-lite "^1.0.30001782"
+    electron-to-chromium "^1.5.328"
+    node-releases "^2.0.36"
+    update-browserslist-db "^1.2.3"
 
 buffer-from@^1.0.0:
   version "1.1.2"
-  resolved "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.2.tgz"
   integrity sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==
 
+bundle-name@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/bundle-name/-/bundle-name-4.1.0.tgz"
+  integrity sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==
+  dependencies:
+    run-applescript "^7.0.0"
+
 bytes@3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/bytes/-/bytes-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/bytes/-/bytes-3.0.0.tgz"
   integrity sha512-pMhOfFDPiv9t5jjIXkHosWmkSyQbvsgEVNkz0ERHbuLh2T/7j4Mqqpz523Fe8MVY89KC6Sh/QfS2sM+SjgFDcw==
 
-bytes@3.1.2:
+bytes@3.1.2, bytes@~3.1.2:
   version "3.1.2"
-  resolved "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/bytes/-/bytes-3.1.2.tgz"
   integrity sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==
 
+bytestreamjs@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/bytestreamjs/-/bytestreamjs-2.0.1.tgz"
+  integrity sha512-U1Z/ob71V/bXfVABvNr/Kumf5VyeQRBEm6Txb0PQ6S7V5GpBM3w4Cbqz/xPDicR5tN0uvDifng8C+5qECeGwyQ==
+
 cacheable-lookup@^7.0.0:
   version "7.0.0"
-  resolved "https://registry.npmjs.org/cacheable-lookup/-/cacheable-lookup-7.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/cacheable-lookup/-/cacheable-lookup-7.0.0.tgz"
   integrity sha512-+qJyx4xiKra8mZrcwhjMRMUhD5NR1R8esPkzIYxX96JiecFoxAXFuz/GpR3+ev4PE1WamHip78wV0vcmPQtp8w==
 
 cacheable-request@^10.2.8:
   version "10.2.14"
-  resolved "https://registry.npmjs.org/cacheable-request/-/cacheable-request-10.2.14.tgz"
+  resolved "https://registry.yarnpkg.com/cacheable-request/-/cacheable-request-10.2.14.tgz"
   integrity sha512-zkDT5WAF4hSSoUgyfg5tFIxz8XQK+25W/TLVojJTMKBaxevLBBtLxgqguAuVQB8PVW79FVjHcU+GJ9tVbDZ9mQ==
   dependencies:
     "@types/http-cache-semantics" "^4.0.2"
@@ -3167,40 +3468,40 @@ cacheable-request@^10.2.8:
     normalize-url "^8.0.0"
     responselike "^3.0.0"
 
-call-bind-apply-helpers@^1.0.0, call-bind-apply-helpers@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.1.tgz"
-  integrity sha512-BhYE+WDaywFg2TBWYNXAE+8B1ATnThNBqXHP5nQu0jWJdVvY2hvkpyB3qOmtmDePiS5/BDQ8wASEWGMWRG148g==
+call-bind-apply-helpers@^1.0.1, call-bind-apply-helpers@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz"
+  integrity sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==
   dependencies:
     es-errors "^1.3.0"
     function-bind "^1.1.2"
 
 call-bind@^1.0.8:
-  version "1.0.8"
-  resolved "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz"
-  integrity sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==
+  version "1.0.9"
+  resolved "https://registry.yarnpkg.com/call-bind/-/call-bind-1.0.9.tgz"
+  integrity sha512-a/hy+pNsFUTR+Iz8TCJvXudKVLAnz/DyeSUo10I5yvFDQJBFU2s9uqQpoSrJlroHUKoKqzg+epxyP9lqFdzfBQ==
   dependencies:
-    call-bind-apply-helpers "^1.0.0"
-    es-define-property "^1.0.0"
-    get-intrinsic "^1.2.4"
+    call-bind-apply-helpers "^1.0.2"
+    es-define-property "^1.0.1"
+    get-intrinsic "^1.3.0"
     set-function-length "^1.2.2"
 
 call-bound@^1.0.2, call-bound@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.npmjs.org/call-bound/-/call-bound-1.0.3.tgz"
-  integrity sha512-YTd+6wGlNlPxSuri7Y6X8tY2dmm12UMH66RpKMhiX6rsk5wXXnYgbUcOt8kiS31/AjfoTOvCsE+w8nZQLQnzHA==
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/call-bound/-/call-bound-1.0.4.tgz"
+  integrity sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==
   dependencies:
-    call-bind-apply-helpers "^1.0.1"
-    get-intrinsic "^1.2.6"
+    call-bind-apply-helpers "^1.0.2"
+    get-intrinsic "^1.3.0"
 
 callsites@^3.0.0:
   version "3.1.0"
-  resolved "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/callsites/-/callsites-3.1.0.tgz"
   integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==
 
 camel-case@^4.1.2:
   version "4.1.2"
-  resolved "https://registry.npmjs.org/camel-case/-/camel-case-4.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/camel-case/-/camel-case-4.1.2.tgz"
   integrity sha512-gxGWBrTT1JuMx6R+o5PTXMmUnhnVzLQ9SNutD4YqKtI6ap897t3tKECYla6gCWEkplXnlNybEkZg9GEGxKFCgw==
   dependencies:
     pascal-case "^3.1.2"
@@ -3208,17 +3509,17 @@ camel-case@^4.1.2:
 
 camelcase@^6.2.0:
   version "6.3.0"
-  resolved "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-6.3.0.tgz"
   integrity sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==
 
 camelcase@^7.0.1:
   version "7.0.1"
-  resolved "https://registry.npmjs.org/camelcase/-/camelcase-7.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-7.0.1.tgz"
   integrity sha512-xlx1yCK2Oc1APsPXDL2LdlNP6+uu8OCDdhOBSVT279M/S+y75O30C2VuD8T2ogdePBBl7PfPF4504tnLgX3zfw==
 
 caniuse-api@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/caniuse-api/-/caniuse-api-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/caniuse-api/-/caniuse-api-3.0.0.tgz"
   integrity sha512-bsTwuIg/BZZK/vreVTYYbSWoe2F+71P7K5QGEX+pT250DZbfU1MQ5prOKpPR+LL6uWKK3KMwMCAS74QB3Um1uw==
   dependencies:
     browserslist "^4.0.0"
@@ -3226,57 +3527,57 @@ caniuse-api@^3.0.0:
     lodash.memoize "^4.1.2"
     lodash.uniq "^4.5.0"
 
-caniuse-lite@^1.0.0, caniuse-lite@^1.0.30001646, caniuse-lite@^1.0.30001688:
-  version "1.0.30001690"
-  resolved "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001690.tgz"
-  integrity sha512-5ExiE3qQN6oF8Clf8ifIDcMRCRE/dMGcETG/XGMD8/XiXm6HXQgQTh1yZYLXXpSOsEUlJm1Xr7kGULZTuGtP/w==
+caniuse-lite@^1.0.0, caniuse-lite@^1.0.30001782, caniuse-lite@^1.0.30001787:
+  version "1.0.30001791"
+  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001791.tgz"
+  integrity sha512-yk0l/YSrOnFZk3UROpDLQD9+kC1l4meK/wed583AXrzoarMGJcbRi2Q4RaUYbKxYAsZ8sWmaSa/DsLmdBeI1vQ==
 
 ccount@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/ccount/-/ccount-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/ccount/-/ccount-2.0.1.tgz"
   integrity sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==
 
-chalk@^4.0.0, chalk@^4.1.0, chalk@^4.1.2:
+chalk@^4.0.0, chalk@^4.1.2:
   version "4.1.2"
-  resolved "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.2.tgz"
   integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==
   dependencies:
     ansi-styles "^4.1.0"
     supports-color "^7.1.0"
 
 chalk@^5.0.1, chalk@^5.2.0:
-  version "5.4.1"
-  resolved "https://registry.npmjs.org/chalk/-/chalk-5.4.1.tgz"
-  integrity sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w==
+  version "5.6.2"
+  resolved "https://registry.yarnpkg.com/chalk/-/chalk-5.6.2.tgz"
+  integrity sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==
 
 char-regex@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.npmjs.org/char-regex/-/char-regex-1.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/char-regex/-/char-regex-1.0.2.tgz"
   integrity sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==
 
 character-entities-html4@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/character-entities-html4/-/character-entities-html4-2.1.0.tgz"
   integrity sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==
 
 character-entities-legacy@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz"
   integrity sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==
 
 character-entities@^2.0.0:
   version "2.0.2"
-  resolved "https://registry.npmjs.org/character-entities/-/character-entities-2.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/character-entities/-/character-entities-2.0.2.tgz"
   integrity sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ==
 
 character-reference-invalid@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/character-reference-invalid/-/character-reference-invalid-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/character-reference-invalid/-/character-reference-invalid-2.0.1.tgz"
   integrity sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw==
 
 cheerio-select@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/cheerio-select/-/cheerio-select-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/cheerio-select/-/cheerio-select-2.1.0.tgz"
   integrity sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==
   dependencies:
     boolbase "^1.0.0"
@@ -3288,7 +3589,7 @@ cheerio-select@^2.1.0:
 
 cheerio@1.0.0-rc.12:
   version "1.0.0-rc.12"
-  resolved "https://registry.npmjs.org/cheerio/-/cheerio-1.0.0-rc.12.tgz"
+  resolved "https://registry.yarnpkg.com/cheerio/-/cheerio-1.0.0-rc.12.tgz"
   integrity sha512-VqR8m68vM46BNnuZ5NtnGBKIE/DfN0cRIzg9n40EIq9NOv90ayxLBXA8fXC5gquFRGJSTRqBq25Jt2ECLR431Q==
   dependencies:
     cheerio-select "^2.1.0"
@@ -3299,9 +3600,9 @@ cheerio@1.0.0-rc.12:
     parse5 "^7.0.0"
     parse5-htmlparser2-tree-adapter "^7.0.0"
 
-chokidar@^3.4.2, chokidar@^3.5.3:
+chokidar@^3.5.3, chokidar@^3.6.0:
   version "3.6.0"
-  resolved "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz"
+  resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-3.6.0.tgz"
   integrity sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==
   dependencies:
     anymatch "~3.1.2"
@@ -3316,34 +3617,34 @@ chokidar@^3.4.2, chokidar@^3.5.3:
 
 chrome-trace-event@^1.0.2:
   version "1.0.4"
-  resolved "https://registry.npmjs.org/chrome-trace-event/-/chrome-trace-event-1.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/chrome-trace-event/-/chrome-trace-event-1.0.4.tgz"
   integrity sha512-rNjApaLzuwaOTjCiT8lSDdGN1APCiqkChLMJxJPWLunPAt5fy8xgU9/jNOchV84wfIxrA0lRQB7oCT8jrn/wrQ==
 
 ci-info@^3.2.0:
   version "3.9.0"
-  resolved "https://registry.npmjs.org/ci-info/-/ci-info-3.9.0.tgz"
+  resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-3.9.0.tgz"
   integrity sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==
 
-clean-css@^5.2.2, clean-css@^5.3.2, clean-css@~5.3.2:
+clean-css@^5.2.2, clean-css@^5.3.3, clean-css@~5.3.2:
   version "5.3.3"
-  resolved "https://registry.npmjs.org/clean-css/-/clean-css-5.3.3.tgz"
+  resolved "https://registry.yarnpkg.com/clean-css/-/clean-css-5.3.3.tgz"
   integrity sha512-D5J+kHaVb/wKSFcyyV75uCn8fiY4sV38XJoe4CUyGQ+mOU/fMVYUdH1hJC+CJQ5uY3EnW27SbJYS4X8BiLrAFg==
   dependencies:
     source-map "~0.6.0"
 
 clean-stack@^2.0.0:
   version "2.2.0"
-  resolved "https://registry.npmjs.org/clean-stack/-/clean-stack-2.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/clean-stack/-/clean-stack-2.2.0.tgz"
   integrity sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==
 
 cli-boxes@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/cli-boxes/-/cli-boxes-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/cli-boxes/-/cli-boxes-3.0.0.tgz"
   integrity sha512-/lzGpEWL/8PfI0BmBOPRwp0c/wFNX1RdUML3jK/RcSBA9T8mZDdQpqYBKtCFTOfQbwPqWEOpjqW+Fnayc0969g==
 
 cli-table3@^0.6.3:
   version "0.6.5"
-  resolved "https://registry.npmjs.org/cli-table3/-/cli-table3-0.6.5.tgz"
+  resolved "https://registry.yarnpkg.com/cli-table3/-/cli-table3-0.6.5.tgz"
   integrity sha512-+W/5efTR7y5HRD7gACw9yQjqMVvEMLBHmboM/kPWam+H+Hmyrgjh6YncVKK122YZkXrLudzTuAukUw9FnMf7IQ==
   dependencies:
     string-width "^4.2.0"
@@ -3352,7 +3653,7 @@ cli-table3@^0.6.3:
 
 clone-deep@^4.0.1:
   version "4.0.1"
-  resolved "https://registry.npmjs.org/clone-deep/-/clone-deep-4.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/clone-deep/-/clone-deep-4.0.1.tgz"
   integrity sha512-neHB9xuzh/wk0dIHweyAXv2aPGZIVk3pLMe+/RNzINf17fe0OG96QroktYAUm7SM1PBnzTabaLboqqxDyMU+SQ==
   dependencies:
     is-plain-object "^2.0.4"
@@ -3361,93 +3662,93 @@ clone-deep@^4.0.1:
 
 clsx@^2.0.0, clsx@^2.1.1:
   version "2.1.1"
-  resolved "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/clsx/-/clsx-2.1.1.tgz"
   integrity sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==
 
 collapse-white-space@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/collapse-white-space/-/collapse-white-space-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/collapse-white-space/-/collapse-white-space-2.1.0.tgz"
   integrity sha512-loKTxY1zCOuG4j9f6EPnuyyYkf58RnhhWTvRoZEokgB+WbdXehfjFviyOVYkqzEWz1Q5kRiZdBYS5SwxbQYwzw==
 
 color-convert@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz"
   integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==
   dependencies:
     color-name "~1.1.4"
 
 color-name@~1.1.4:
   version "1.1.4"
-  resolved "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz"
+  resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz"
   integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==
 
 colord@^2.9.3:
   version "2.9.3"
-  resolved "https://registry.npmjs.org/colord/-/colord-2.9.3.tgz"
+  resolved "https://registry.yarnpkg.com/colord/-/colord-2.9.3.tgz"
   integrity sha512-jeC1axXpnb0/2nn/Y1LPuLdgXBLH7aDcHu4KEKfqw3CUhX7ZpfBSlPKyqXE6btIgEzfWtrX3/tyBCaCvXvMkOw==
 
 colorette@^2.0.10:
   version "2.0.20"
-  resolved "https://registry.npmjs.org/colorette/-/colorette-2.0.20.tgz"
+  resolved "https://registry.yarnpkg.com/colorette/-/colorette-2.0.20.tgz"
   integrity sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==
 
 combine-promises@^1.1.0:
   version "1.2.0"
-  resolved "https://registry.npmjs.org/combine-promises/-/combine-promises-1.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/combine-promises/-/combine-promises-1.2.0.tgz"
   integrity sha512-VcQB1ziGD0NXrhKxiwyNbCDmRzs/OShMs2GqW2DlU2A/Sd0nQxE1oWDAE5O0ygSx5mgQOn9eIFh7yKPgFRVkPQ==
 
 combined-stream@^1.0.8:
   version "1.0.8"
-  resolved "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz"
+  resolved "https://registry.yarnpkg.com/combined-stream/-/combined-stream-1.0.8.tgz"
   integrity sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==
   dependencies:
     delayed-stream "~1.0.0"
 
 comma-separated-tokens@^2.0.0:
   version "2.0.3"
-  resolved "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz"
   integrity sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==
 
 commander@^10.0.0:
   version "10.0.1"
-  resolved "https://registry.npmjs.org/commander/-/commander-10.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-10.0.1.tgz"
   integrity sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==
 
 commander@^2.20.0:
   version "2.20.3"
-  resolved "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-2.20.3.tgz"
   integrity sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==
 
 commander@^5.1.0:
   version "5.1.0"
-  resolved "https://registry.npmjs.org/commander/-/commander-5.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-5.1.0.tgz"
   integrity sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg==
 
 commander@^7.2.0:
   version "7.2.0"
-  resolved "https://registry.npmjs.org/commander/-/commander-7.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-7.2.0.tgz"
   integrity sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==
 
 commander@^8.3.0:
   version "8.3.0"
-  resolved "https://registry.npmjs.org/commander/-/commander-8.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-8.3.0.tgz"
   integrity sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==
 
 common-path-prefix@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/common-path-prefix/-/common-path-prefix-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/common-path-prefix/-/common-path-prefix-3.0.0.tgz"
   integrity sha512-QE33hToZseCH3jS0qN96O/bSh3kaw/h+Tq7ngyY9eWDUnTlTNUyqfqvCXioLe5Na5jFsL78ra/wuBU4iuEgd4w==
 
 compressible@~2.0.18:
   version "2.0.18"
-  resolved "https://registry.npmjs.org/compressible/-/compressible-2.0.18.tgz"
+  resolved "https://registry.yarnpkg.com/compressible/-/compressible-2.0.18.tgz"
   integrity sha512-AF3r7P5dWxL8MxyITRMlORQNaOA2IkAFaTr4k7BUumjPtRpGDTZpl0Pb1XCO6JeDCBdp126Cgs9sMxqSjgYyRg==
   dependencies:
     mime-db ">= 1.43.0 < 2"
 
-compression@^1.7.4:
+compression@^1.8.1:
   version "1.8.1"
-  resolved "https://registry.yarnpkg.com/compression/-/compression-1.8.1.tgz#4a45d909ac16509195a9a28bd91094889c180d79"
+  resolved "https://registry.yarnpkg.com/compression/-/compression-1.8.1.tgz"
   integrity sha512-9mAqGPHLakhCLeNyxPkK4xVo746zQ/czLH1Ky+vkitMnWfWZps8r0qXuwhwizagCRttsL4lfG4pIOvaWLpAP0w==
   dependencies:
     bytes "3.1.2"
@@ -3460,12 +3761,12 @@ compression@^1.7.4:
 
 concat-map@0.0.1:
   version "0.0.1"
-  resolved "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz"
   integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==
 
 config-chain@^1.1.11:
   version "1.1.13"
-  resolved "https://registry.npmjs.org/config-chain/-/config-chain-1.1.13.tgz"
+  resolved "https://registry.yarnpkg.com/config-chain/-/config-chain-1.1.13.tgz"
   integrity sha512-qj+f8APARXHrM0hraqXYb2/bOVSV4PvJQlNZ/DVj0QrmNM2q2euizkeuVckQ57J+W0mRH6Hvi+k50M4Jul2VRQ==
   dependencies:
     ini "^1.3.4"
@@ -3473,7 +3774,7 @@ config-chain@^1.1.11:
 
 configstore@^6.0.0:
   version "6.0.0"
-  resolved "https://registry.npmjs.org/configstore/-/configstore-6.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/configstore/-/configstore-6.0.0.tgz"
   integrity sha512-cD31W1v3GqUlQvbBCGcXmd2Nj9SvLDOP1oQ0YFuLETufzSPaKp11rYBsSOm7rCsW3OnIRAFM3OxRhceaXNYHkA==
   dependencies:
     dot-prop "^6.0.1"
@@ -3484,54 +3785,54 @@ configstore@^6.0.0:
 
 connect-history-api-fallback@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/connect-history-api-fallback/-/connect-history-api-fallback-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/connect-history-api-fallback/-/connect-history-api-fallback-2.0.0.tgz"
   integrity sha512-U73+6lQFmfiNPrYbXqr6kZ1i1wiRqXnp2nhMsINseWXO8lDau0LGEffJ8kQi4EjLZympVgRdvqjAgiZ1tgzDDA==
 
 consola@^3.2.3:
-  version "3.3.3"
-  resolved "https://registry.npmjs.org/consola/-/consola-3.3.3.tgz"
-  integrity sha512-Qil5KwghMzlqd51UXM0b6fyaGHtOC22scxrwrz4A2882LyUMwQjnvaedN1HAeXzphspQ6CpHkzMAWxBTUruDLg==
+  version "3.4.2"
+  resolved "https://registry.yarnpkg.com/consola/-/consola-3.4.2.tgz"
+  integrity sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA==
 
 content-disposition@0.5.2:
   version "0.5.2"
-  resolved "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.2.tgz"
+  resolved "https://registry.yarnpkg.com/content-disposition/-/content-disposition-0.5.2.tgz"
   integrity sha512-kRGRZw3bLlFISDBgwTSA1TMBFN6J6GWDeubmDE3AF+3+yXL8hTWv8r5rkLbqYXY4RjPk/EzHnClI3zQf1cFmHA==
 
-content-disposition@0.5.4:
+content-disposition@~0.5.4:
   version "0.5.4"
-  resolved "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz"
+  resolved "https://registry.yarnpkg.com/content-disposition/-/content-disposition-0.5.4.tgz"
   integrity sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==
   dependencies:
     safe-buffer "5.2.1"
 
 content-type@~1.0.4, content-type@~1.0.5:
   version "1.0.5"
-  resolved "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/content-type/-/content-type-1.0.5.tgz"
   integrity sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==
 
 convert-source-map@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-2.0.0.tgz"
   integrity sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==
 
-cookie-signature@1.0.6:
-  version "1.0.6"
-  resolved "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz"
-  integrity sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==
+cookie-signature@~1.0.6:
+  version "1.0.7"
+  resolved "https://registry.yarnpkg.com/cookie-signature/-/cookie-signature-1.0.7.tgz"
+  integrity sha512-NXdYc3dLr47pBkpUCHtKSwIOQXLVn8dZEuywboCOJY/osA0wFSLlSawr3KN8qXJEyX66FcONTH8EIlVuK0yyFA==
 
-cookie@0.7.1:
-  version "0.7.1"
-  resolved "https://registry.npmjs.org/cookie/-/cookie-0.7.1.tgz"
-  integrity sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==
+cookie@~0.7.1:
+  version "0.7.2"
+  resolved "https://registry.yarnpkg.com/cookie/-/cookie-0.7.2.tgz"
+  integrity sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==
 
 copy-text-to-clipboard@^3.2.0:
-  version "3.2.0"
-  resolved "https://registry.npmjs.org/copy-text-to-clipboard/-/copy-text-to-clipboard-3.2.0.tgz"
-  integrity sha512-RnJFp1XR/LOBDckxTib5Qjr/PMfkatD0MUCQgdpqS8MdKiNUzBjAQBEN6oUy+jW7LI93BBG3DtMB2KOOKpGs2Q==
+  version "3.2.2"
+  resolved "https://registry.yarnpkg.com/copy-text-to-clipboard/-/copy-text-to-clipboard-3.2.2.tgz"
+  integrity sha512-T6SqyLd1iLuqPA90J5N4cTalrtovCySh58iiZDGJ6FGznbclKh4UI+FGacQSgFzwKG77W7XT5gwbVEbd9cIH1A==
 
 copy-webpack-plugin@^11.0.0:
   version "11.0.0"
-  resolved "https://registry.npmjs.org/copy-webpack-plugin/-/copy-webpack-plugin-11.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/copy-webpack-plugin/-/copy-webpack-plugin-11.0.0.tgz"
   integrity sha512-fX2MWpamkW0hZxMEg0+mYnA40LTosOSa5TqZ9GYIBzyJa9C3QUaMPSE2xAi/buNr8u89SfD9wHSQVBzrRa/SOQ==
   dependencies:
     fast-glob "^3.2.11"
@@ -3541,42 +3842,26 @@ copy-webpack-plugin@^11.0.0:
     schema-utils "^4.0.0"
     serialize-javascript "^6.0.0"
 
-core-js-compat@^3.38.0, core-js-compat@^3.38.1:
-  version "3.39.0"
-  resolved "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.39.0.tgz"
-  integrity sha512-VgEUx3VwlExr5no0tXlBt+silBvhTryPwCXRI2Id1PN8WTKu7MreethvddqOubrYxkFdv/RnYrqlv1sFNAUelw==
+core-js-compat@^3.43.0, core-js-compat@^3.48.0:
+  version "3.49.0"
+  resolved "https://registry.yarnpkg.com/core-js-compat/-/core-js-compat-3.49.0.tgz"
+  integrity sha512-VQXt1jr9cBz03b331DFDCCP90b3fanciLkgiOoy8SBHy06gNf+vQ1A3WFLqG7I8TipYIKeYK9wxd0tUrvHcOZA==
   dependencies:
-    browserslist "^4.24.2"
-
-core-js-pure@^3.30.2:
-  version "3.39.0"
-  resolved "https://registry.npmjs.org/core-js-pure/-/core-js-pure-3.39.0.tgz"
-  integrity sha512-7fEcWwKI4rJinnK+wLTezeg2smbFFdSBP6E2kQZNbnzM2s1rpKQ6aaRteZSSg7FLU3P0HGGVo/gbpfanU36urg==
+    browserslist "^4.28.1"
 
 core-js@^3.31.1:
-  version "3.39.0"
-  resolved "https://registry.npmjs.org/core-js/-/core-js-3.39.0.tgz"
-  integrity sha512-raM0ew0/jJUqkJ0E6e8UDtl+y/7ktFivgWvqw8dNSQeNWoSDLvQ1H/RN3aPXB9tBd4/FhyR4RDPGhsNIMsAn7g==
+  version "3.49.0"
+  resolved "https://registry.yarnpkg.com/core-js/-/core-js-3.49.0.tgz"
+  integrity sha512-es1U2+YTtzpwkxVLwAFdSpaIMyQaq0PBgm3YD1W3Qpsn1NAmO3KSgZfu+oGSWVu6NvLHoHCV/aYcsE5wiB7ALg==
 
 core-util-is@~1.0.0:
   version "1.0.3"
-  resolved "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.3.tgz"
   integrity sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==
 
-cosmiconfig@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-6.0.0.tgz"
-  integrity sha512-xb3ZL6+L8b9JLLCx3ZdoZy4+2ECphCMo2PwqgP1tlfVq6M6YReyzBJtvWWtbDSpNr9hn96pkCiZqUcFEc+54Qg==
-  dependencies:
-    "@types/parse-json" "^4.0.0"
-    import-fresh "^3.1.0"
-    parse-json "^5.0.0"
-    path-type "^4.0.0"
-    yaml "^1.7.2"
-
 cosmiconfig@^8.1.3, cosmiconfig@^8.3.5:
   version "8.3.6"
-  resolved "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-8.3.6.tgz"
+  resolved "https://registry.yarnpkg.com/cosmiconfig/-/cosmiconfig-8.3.6.tgz"
   integrity sha512-kcZ6+W5QzcJ3P1Mt+83OUv/oHFqZHIx8DuxG6eZ5RGMERoLqp4BuGjhHLYGK+Kf5XVkQvqBSmAy/nGWN3qDgEA==
   dependencies:
     import-fresh "^3.3.0"
@@ -3586,7 +3871,7 @@ cosmiconfig@^8.1.3, cosmiconfig@^8.3.5:
 
 cross-spawn@^7.0.3:
   version "7.0.6"
-  resolved "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz"
+  resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-7.0.6.tgz"
   integrity sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==
   dependencies:
     path-key "^3.1.0"
@@ -3595,35 +3880,35 @@ cross-spawn@^7.0.3:
 
 crypto-random-string@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/crypto-random-string/-/crypto-random-string-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/crypto-random-string/-/crypto-random-string-4.0.0.tgz"
   integrity sha512-x8dy3RnvYdlUcPOjkEHqozhiwzKNSq7GcPuXFbnyMOCHxX8V3OgIg/pYuabl2sbUPfIJaeAQB7PMOK8DFIdoRA==
   dependencies:
     type-fest "^1.0.1"
 
 css-blank-pseudo@^7.0.1:
   version "7.0.1"
-  resolved "https://registry.npmjs.org/css-blank-pseudo/-/css-blank-pseudo-7.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/css-blank-pseudo/-/css-blank-pseudo-7.0.1.tgz"
   integrity sha512-jf+twWGDf6LDoXDUode+nc7ZlrqfaNphrBIBrcmeP3D8yw1uPaix1gCC8LUQUGQ6CycuK2opkbFFWFuq/a94ag==
   dependencies:
     postcss-selector-parser "^7.0.0"
 
 css-declaration-sorter@^7.2.0:
-  version "7.2.0"
-  resolved "https://registry.npmjs.org/css-declaration-sorter/-/css-declaration-sorter-7.2.0.tgz"
-  integrity sha512-h70rUM+3PNFuaBDTLe8wF/cdWu+dOZmb7pJt8Z2sedYbAcQVQV/tEchueg3GWxwqS0cxtbxmaHEdkNACqcvsow==
+  version "7.4.0"
+  resolved "https://registry.yarnpkg.com/css-declaration-sorter/-/css-declaration-sorter-7.4.0.tgz"
+  integrity sha512-LTuzjPoyA2vMGKKcaOqKSp7Ub2eGrNfKiZH4LpezxpNrsICGCSFvsQOI29psISxNZtaXibkC2CXzrQ5enMeGGw==
 
-css-has-pseudo@^7.0.2:
-  version "7.0.2"
-  resolved "https://registry.npmjs.org/css-has-pseudo/-/css-has-pseudo-7.0.2.tgz"
-  integrity sha512-nzol/h+E0bId46Kn2dQH5VElaknX2Sr0hFuB/1EomdC7j+OISt2ZzK7EHX9DZDY53WbIVAR7FYKSO2XnSf07MQ==
+css-has-pseudo@^7.0.3:
+  version "7.0.3"
+  resolved "https://registry.yarnpkg.com/css-has-pseudo/-/css-has-pseudo-7.0.3.tgz"
+  integrity sha512-oG+vKuGyqe/xvEMoxAQrhi7uY16deJR3i7wwhBerVrGQKSqUC5GiOVxTpM9F9B9hw0J+eKeOWLH7E9gZ1Dr5rA==
   dependencies:
     "@csstools/selector-specificity" "^5.0.0"
     postcss-selector-parser "^7.0.0"
     postcss-value-parser "^4.2.0"
 
-css-loader@^6.8.1:
+css-loader@^6.11.0:
   version "6.11.0"
-  resolved "https://registry.npmjs.org/css-loader/-/css-loader-6.11.0.tgz"
+  resolved "https://registry.yarnpkg.com/css-loader/-/css-loader-6.11.0.tgz"
   integrity sha512-CTJ+AEQJjq5NzLga5pE39qdiSV56F8ywCIsqNIRF0r7BDgWsN25aazToqAFg7ZrtA/U016xudB3ffgweORxX7g==
   dependencies:
     icss-utils "^5.1.0"
@@ -3637,7 +3922,7 @@ css-loader@^6.8.1:
 
 css-minimizer-webpack-plugin@^5.0.1:
   version "5.0.1"
-  resolved "https://registry.npmjs.org/css-minimizer-webpack-plugin/-/css-minimizer-webpack-plugin-5.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/css-minimizer-webpack-plugin/-/css-minimizer-webpack-plugin-5.0.1.tgz"
   integrity sha512-3caImjKFQkS+ws1TGcFn0V1HyDJFq1Euy589JlD6/3rV2kj+w7r5G9WDMgSHvpvXHNZ2calVypZWuEDQd9wfLg==
   dependencies:
     "@jridgewell/trace-mapping" "^0.3.18"
@@ -3649,12 +3934,12 @@ css-minimizer-webpack-plugin@^5.0.1:
 
 css-prefers-color-scheme@^10.0.0:
   version "10.0.0"
-  resolved "https://registry.npmjs.org/css-prefers-color-scheme/-/css-prefers-color-scheme-10.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/css-prefers-color-scheme/-/css-prefers-color-scheme-10.0.0.tgz"
   integrity sha512-VCtXZAWivRglTZditUfB4StnsWr6YVZ2PRtuxQLKTNRdtAf8tpzaVPE9zXIF3VaSc7O70iK/j1+NXxyQCqdPjQ==
 
 css-select@^4.1.3:
   version "4.3.0"
-  resolved "https://registry.npmjs.org/css-select/-/css-select-4.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/css-select/-/css-select-4.3.0.tgz"
   integrity sha512-wPpOYtnsVontu2mODhA19JrqWxNsfdatRKd64kmpRbQgh1KtItko5sTnEpPdpSaJszTOhEMlF/RPz28qj4HqhQ==
   dependencies:
     boolbase "^1.0.0"
@@ -3664,9 +3949,9 @@ css-select@^4.1.3:
     nth-check "^2.0.1"
 
 css-select@^5.1.0:
-  version "5.1.0"
-  resolved "https://registry.npmjs.org/css-select/-/css-select-5.1.0.tgz"
-  integrity sha512-nwoRF1rvRRnnCqqY7updORDsuqKzqYJ28+oSMaJMMgOauh3fvwHqMS7EZpIPqK8GL+g9mKxF1vP/ZjSeNjEVHg==
+  version "5.2.2"
+  resolved "https://registry.yarnpkg.com/css-select/-/css-select-5.2.2.tgz"
+  integrity sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw==
   dependencies:
     boolbase "^1.0.0"
     css-what "^6.1.0"
@@ -3676,7 +3961,7 @@ css-select@^5.1.0:
 
 css-tree@^2.3.1:
   version "2.3.1"
-  resolved "https://registry.npmjs.org/css-tree/-/css-tree-2.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/css-tree/-/css-tree-2.3.1.tgz"
   integrity sha512-6Fv1DV/TYw//QF5IzQdqsNDjx/wc8TrMBZsqjL9eW01tWb7R7k/mq+/VXfJCl7SoD5emsJop9cOByJZfs8hYIw==
   dependencies:
     mdn-data "2.0.30"
@@ -3684,30 +3969,30 @@ css-tree@^2.3.1:
 
 css-tree@~2.2.0:
   version "2.2.1"
-  resolved "https://registry.npmjs.org/css-tree/-/css-tree-2.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/css-tree/-/css-tree-2.2.1.tgz"
   integrity sha512-OA0mILzGc1kCOCSJerOeqDxDQ4HOh+G8NbOJFOTgOCzpw7fCBubk0fEyxp8AgOL/jvLgYA/uV0cMbe43ElF1JA==
   dependencies:
     mdn-data "2.0.28"
     source-map-js "^1.0.1"
 
 css-what@^6.0.1, css-what@^6.1.0:
-  version "6.1.0"
-  resolved "https://registry.npmjs.org/css-what/-/css-what-6.1.0.tgz"
-  integrity sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==
+  version "6.2.2"
+  resolved "https://registry.yarnpkg.com/css-what/-/css-what-6.2.2.tgz"
+  integrity sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==
 
-cssdb@^8.2.3:
-  version "8.2.3"
-  resolved "https://registry.npmjs.org/cssdb/-/cssdb-8.2.3.tgz"
-  integrity sha512-9BDG5XmJrJQQnJ51VFxXCAtpZ5ebDlAREmO8sxMOVU0aSxN/gocbctjIG5LMh3WBUq+xTlb/jw2LoljBEqraTA==
+cssdb@^8.6.0:
+  version "8.8.0"
+  resolved "https://registry.yarnpkg.com/cssdb/-/cssdb-8.8.0.tgz"
+  integrity sha512-QbLeyz2Bgso1iRlh7IpWk6OKa3lLNGXsujVjDMPl9rOZpxKeiG69icLpbLCFxeURwmcdIfZqQyhlooKJYM4f8Q==
 
 cssesc@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/cssesc/-/cssesc-3.0.0.tgz"
   integrity sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==
 
 cssnano-preset-advanced@^6.1.2:
   version "6.1.2"
-  resolved "https://registry.npmjs.org/cssnano-preset-advanced/-/cssnano-preset-advanced-6.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/cssnano-preset-advanced/-/cssnano-preset-advanced-6.1.2.tgz"
   integrity sha512-Nhao7eD8ph2DoHolEzQs5CfRpiEP0xa1HBdnFZ82kvqdmbwVBUr2r1QuQ4t1pi+D1ZpqpcO4T+wy/7RxzJ/WPQ==
   dependencies:
     autoprefixer "^10.4.19"
@@ -3720,7 +4005,7 @@ cssnano-preset-advanced@^6.1.2:
 
 cssnano-preset-default@^6.1.2:
   version "6.1.2"
-  resolved "https://registry.npmjs.org/cssnano-preset-default/-/cssnano-preset-default-6.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/cssnano-preset-default/-/cssnano-preset-default-6.1.2.tgz"
   integrity sha512-1C0C+eNaeN8OcHQa193aRgYexyJtU8XwbdieEjClw+J9d94E41LwT6ivKH0WT+fYwYWB0Zp3I3IZ7tI/BbUbrg==
   dependencies:
     browserslist "^4.23.0"
@@ -3756,12 +4041,12 @@ cssnano-preset-default@^6.1.2:
 
 cssnano-utils@^4.0.2:
   version "4.0.2"
-  resolved "https://registry.npmjs.org/cssnano-utils/-/cssnano-utils-4.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/cssnano-utils/-/cssnano-utils-4.0.2.tgz"
   integrity sha512-ZR1jHg+wZ8o4c3zqf1SIUSTIvm/9mU343FMR6Obe/unskbvpGhZOo1J6d/r8D1pzkRQYuwbcH3hToOuoA2G7oQ==
 
 cssnano@^6.0.1, cssnano@^6.1.2:
   version "6.1.2"
-  resolved "https://registry.npmjs.org/cssnano/-/cssnano-6.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/cssnano/-/cssnano-6.1.2.tgz"
   integrity sha512-rYk5UeX7VAM/u0lNqewCdasdtPK81CgX8wJFLEIXHbV2oldWRgJAsZrdhRXkV1NJzA2g850KiFm9mMU2HxNxMA==
   dependencies:
     cssnano-preset-default "^6.1.2"
@@ -3769,74 +4054,80 @@ cssnano@^6.0.1, cssnano@^6.1.2:
 
 csso@^5.0.5:
   version "5.0.5"
-  resolved "https://registry.npmjs.org/csso/-/csso-5.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/csso/-/csso-5.0.5.tgz"
   integrity sha512-0LrrStPOdJj+SPCCrGhzryycLjwcgUSHBtxNA8aIDxf0GLsRh1cKYhB00Gd1lDOS4yGH69+SNn13+TWbVHETFQ==
   dependencies:
     css-tree "~2.2.0"
 
-csstype@^3.0.2:
-  version "3.1.3"
-  resolved "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz"
-  integrity sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==
+csstype@^3.2.2:
+  version "3.2.3"
+  resolved "https://registry.yarnpkg.com/csstype/-/csstype-3.2.3.tgz"
+  integrity sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==
 
 debounce@^1.2.1:
   version "1.2.1"
-  resolved "https://registry.npmjs.org/debounce/-/debounce-1.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/debounce/-/debounce-1.2.1.tgz"
   integrity sha512-XRRe6Glud4rd/ZGQfiV1ruXSfbvfJedlV9Y6zOlP+2K04vBYiJEte6stfFkCP03aMnY5tsipamumUjL14fofug==
 
-debug@2.6.9, debug@^2.6.0:
+debug@2.6.9:
   version "2.6.9"
-  resolved "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz"
+  resolved "https://registry.yarnpkg.com/debug/-/debug-2.6.9.tgz"
   integrity sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==
   dependencies:
     ms "2.0.0"
 
-debug@4, debug@^4.0.0, debug@^4.1.0, debug@^4.1.1, debug@^4.3.1:
-  version "4.4.0"
-  resolved "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz"
-  integrity sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==
+debug@4, debug@^4.0.0, debug@^4.1.0, debug@^4.3.1, debug@^4.4.3:
+  version "4.4.3"
+  resolved "https://registry.yarnpkg.com/debug/-/debug-4.4.3.tgz"
+  integrity sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==
   dependencies:
     ms "^2.1.3"
 
 decode-named-character-reference@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/decode-named-character-reference/-/decode-named-character-reference-1.0.2.tgz"
-  integrity sha512-O8x12RzrUF8xyVcY0KJowWsmaJxQbmy0/EtnNtHRpsOcT7dFk5W598coHqBVpmWo1oQQfsCqfCmkZN5DJrZVdg==
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/decode-named-character-reference/-/decode-named-character-reference-1.3.0.tgz"
+  integrity sha512-GtpQYB283KrPp6nRw50q3U9/VfOutZOe103qlN7BPP6Ad27xYnOIWv4lPzo8HCAL+mMZofJ9KEy30fq6MfaK6Q==
   dependencies:
     character-entities "^2.0.0"
 
 decompress-response@^6.0.0:
   version "6.0.0"
-  resolved "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/decompress-response/-/decompress-response-6.0.0.tgz"
   integrity sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==
   dependencies:
     mimic-response "^3.1.0"
 
 deep-extend@^0.6.0:
   version "0.6.0"
-  resolved "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz"
+  resolved "https://registry.yarnpkg.com/deep-extend/-/deep-extend-0.6.0.tgz"
   integrity sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==
 
-deepmerge@^4.2.2, deepmerge@^4.3.1:
+deepmerge@^4.3.1:
   version "4.3.1"
-  resolved "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/deepmerge/-/deepmerge-4.3.1.tgz"
   integrity sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==
 
-default-gateway@^6.0.3:
-  version "6.0.3"
-  resolved "https://registry.npmjs.org/default-gateway/-/default-gateway-6.0.3.tgz"
-  integrity sha512-fwSOJsbbNzZ/CUFpqFBqYfYNLj1NbMPm8MMCIzHjC83iSJRBEGmDUxU+WP661BaBQImeC2yHwXtz+P/O9o+XEg==
+default-browser-id@^5.0.0:
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/default-browser-id/-/default-browser-id-5.0.1.tgz"
+  integrity sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q==
+
+default-browser@^5.2.1:
+  version "5.5.0"
+  resolved "https://registry.yarnpkg.com/default-browser/-/default-browser-5.5.0.tgz"
+  integrity sha512-H9LMLr5zwIbSxrmvikGuI/5KGhZ8E2zH3stkMgM5LpOWDutGM2JZaj460Udnf1a+946zc7YBgrqEWwbk7zHvGw==
   dependencies:
-    execa "^5.0.0"
+    bundle-name "^4.1.0"
+    default-browser-id "^5.0.0"
 
 defer-to-connect@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/defer-to-connect/-/defer-to-connect-2.0.1.tgz"
   integrity sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==
 
 define-data-property@^1.0.1, define-data-property@^1.1.4:
   version "1.1.4"
-  resolved "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz"
+  resolved "https://registry.yarnpkg.com/define-data-property/-/define-data-property-1.1.4.tgz"
   integrity sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==
   dependencies:
     es-define-property "^1.0.0"
@@ -3845,73 +4136,56 @@ define-data-property@^1.0.1, define-data-property@^1.1.4:
 
 define-lazy-prop@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/define-lazy-prop/-/define-lazy-prop-2.0.0.tgz"
   integrity sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==
 
+define-lazy-prop@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz"
+  integrity sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==
+
 define-properties@^1.2.1:
   version "1.2.1"
-  resolved "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.2.1.tgz"
   integrity sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==
   dependencies:
     define-data-property "^1.0.1"
     has-property-descriptors "^1.0.0"
     object-keys "^1.1.1"
 
-del@^6.1.1:
-  version "6.1.1"
-  resolved "https://registry.npmjs.org/del/-/del-6.1.1.tgz"
-  integrity sha512-ua8BhapfP0JUJKC/zV9yHHDW/rDoDxP4Zhn3AkA6/xT6gY7jYXJiaeyBZznYVujhZZET+UgcbZiQ7sN3WqcImg==
-  dependencies:
-    globby "^11.0.1"
-    graceful-fs "^4.2.4"
-    is-glob "^4.0.1"
-    is-path-cwd "^2.2.0"
-    is-path-inside "^3.0.2"
-    p-map "^4.0.0"
-    rimraf "^3.0.2"
-    slash "^3.0.0"
-
 delayed-stream@~1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz"
   integrity sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==
 
-depd@2.0.0:
+depd@2.0.0, depd@~2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/depd/-/depd-2.0.0.tgz"
   integrity sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==
 
 depd@~1.1.2:
   version "1.1.2"
-  resolved "https://registry.npmjs.org/depd/-/depd-1.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/depd/-/depd-1.1.2.tgz"
   integrity sha512-7emPTl6Dpo6JRXOXjLRxck+FlLRX5847cLKEn00PLAgc3g2hTZZgr+e4c2v6QpSmLeFP3n5yUo7ft6avBK/5jQ==
 
 dequal@^2.0.0:
   version "2.0.3"
-  resolved "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/dequal/-/dequal-2.0.3.tgz"
   integrity sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==
 
-destroy@1.2.0:
+destroy@1.2.0, destroy@~1.2.0:
   version "1.2.0"
-  resolved "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/destroy/-/destroy-1.2.0.tgz"
   integrity sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==
 
 detect-node@^2.0.4:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/detect-node/-/detect-node-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/detect-node/-/detect-node-2.1.0.tgz"
   integrity sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==
 
-detect-port-alt@^1.1.6:
-  version "1.1.6"
-  resolved "https://registry.npmjs.org/detect-port-alt/-/detect-port-alt-1.1.6.tgz"
-  integrity sha512-5tQykt+LqfJFBEYaDITx7S7cR7mJ/zQmLXZ2qt5w04ainYZw6tBf9dBunMjVeVOdYVRUzUOE4HkY5J7+uttb5Q==
-  dependencies:
-    address "^1.0.1"
-    debug "^2.6.0"
-
 detect-port@^1.5.1:
   version "1.6.1"
-  resolved "https://registry.npmjs.org/detect-port/-/detect-port-1.6.1.tgz"
+  resolved "https://registry.yarnpkg.com/detect-port/-/detect-port-1.6.1.tgz"
   integrity sha512-CmnVc+Hek2egPx1PeTFVta2W78xy2K/9Rkf6cC4T59S50tVnzKj+tnx5mmx5lwvCkujZ4uRrpRSuV+IVs3f90Q==
   dependencies:
     address "^1.0.1"
@@ -3919,35 +4193,35 @@ detect-port@^1.5.1:
 
 devlop@^1.0.0, devlop@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.npmjs.org/devlop/-/devlop-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/devlop/-/devlop-1.1.0.tgz"
   integrity sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==
   dependencies:
     dequal "^2.0.0"
 
 dir-glob@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/dir-glob/-/dir-glob-3.0.1.tgz"
   integrity sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==
   dependencies:
     path-type "^4.0.0"
 
 dns-packet@^5.2.2:
   version "5.6.1"
-  resolved "https://registry.npmjs.org/dns-packet/-/dns-packet-5.6.1.tgz"
+  resolved "https://registry.yarnpkg.com/dns-packet/-/dns-packet-5.6.1.tgz"
   integrity sha512-l4gcSouhcgIKRvyy99RNVOgxXiicE+2jZoNmaNmZ6JXiGajBOJAesk1OBlJuM5k2c+eudGdLxDqXuPCKIj6kpw==
   dependencies:
     "@leichtgewicht/ip-codec" "^2.0.1"
 
 dom-converter@^0.2.0:
   version "0.2.0"
-  resolved "https://registry.npmjs.org/dom-converter/-/dom-converter-0.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/dom-converter/-/dom-converter-0.2.0.tgz"
   integrity sha512-gd3ypIPfOMr9h5jIKq8E3sHOTCjeirnl0WK5ZdS1AW0Odt0b1PaWaHdJ4Qk4klv+YB9aJBS7mESXjFoDQPu6DA==
   dependencies:
     utila "~0.4"
 
 dom-serializer@^1.0.1:
   version "1.4.1"
-  resolved "https://registry.npmjs.org/dom-serializer/-/dom-serializer-1.4.1.tgz"
+  resolved "https://registry.yarnpkg.com/dom-serializer/-/dom-serializer-1.4.1.tgz"
   integrity sha512-VHwB3KfrcOOkelEG2ZOfxqLZdfkil8PtJi4P8N2MMXucZq2yLp75ClViUlOVwyoHEDjYU433Aq+5zWP61+RGag==
   dependencies:
     domelementtype "^2.0.1"
@@ -3956,7 +4230,7 @@ dom-serializer@^1.0.1:
 
 dom-serializer@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/dom-serializer/-/dom-serializer-2.0.0.tgz"
   integrity sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==
   dependencies:
     domelementtype "^2.3.0"
@@ -3965,26 +4239,26 @@ dom-serializer@^2.0.0:
 
 domelementtype@^2.0.1, domelementtype@^2.2.0, domelementtype@^2.3.0:
   version "2.3.0"
-  resolved "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/domelementtype/-/domelementtype-2.3.0.tgz"
   integrity sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==
 
 domhandler@^4.0.0, domhandler@^4.2.0, domhandler@^4.3.1:
   version "4.3.1"
-  resolved "https://registry.npmjs.org/domhandler/-/domhandler-4.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/domhandler/-/domhandler-4.3.1.tgz"
   integrity sha512-GrwoxYN+uWlzO8uhUXRl0P+kHE4GtVPfYzVLcUxPL7KNdHKj66vvlhiweIHqYYXWlw+T8iLMp42Lm67ghw4WMQ==
   dependencies:
     domelementtype "^2.2.0"
 
 domhandler@^5.0.2, domhandler@^5.0.3:
   version "5.0.3"
-  resolved "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/domhandler/-/domhandler-5.0.3.tgz"
   integrity sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==
   dependencies:
     domelementtype "^2.3.0"
 
 domutils@^2.5.2, domutils@^2.8.0:
   version "2.8.0"
-  resolved "https://registry.npmjs.org/domutils/-/domutils-2.8.0.tgz"
+  resolved "https://registry.yarnpkg.com/domutils/-/domutils-2.8.0.tgz"
   integrity sha512-w96Cjofp72M5IIhpjgobBimYEfoPjx1Vx0BSX9P30WBdZW2WIKU0T1Bd0kz2eNZ9ikjKgHbEyKx8BB6H1L3h3A==
   dependencies:
     dom-serializer "^1.0.1"
@@ -3992,9 +4266,9 @@ domutils@^2.5.2, domutils@^2.8.0:
     domhandler "^4.2.0"
 
 domutils@^3.0.1:
-  version "3.2.1"
-  resolved "https://registry.npmjs.org/domutils/-/domutils-3.2.1.tgz"
-  integrity sha512-xWXmuRnN9OMP6ptPd2+H0cCbcYBULa5YDTbMm/2lvkWvNA3O4wcW+GvzooqBuNM8yy6pl3VIAeJTUUWUbfI5Fw==
+  version "3.2.2"
+  resolved "https://registry.yarnpkg.com/domutils/-/domutils-3.2.2.tgz"
+  integrity sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==
   dependencies:
     dom-serializer "^2.0.0"
     domelementtype "^2.3.0"
@@ -4002,7 +4276,7 @@ domutils@^3.0.1:
 
 dot-case@^3.0.4:
   version "3.0.4"
-  resolved "https://registry.npmjs.org/dot-case/-/dot-case-3.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/dot-case/-/dot-case-3.0.4.tgz"
   integrity sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w==
   dependencies:
     no-case "^3.0.4"
@@ -4010,14 +4284,14 @@ dot-case@^3.0.4:
 
 dot-prop@^6.0.1:
   version "6.0.1"
-  resolved "https://registry.npmjs.org/dot-prop/-/dot-prop-6.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/dot-prop/-/dot-prop-6.0.1.tgz"
   integrity sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA==
   dependencies:
     is-obj "^2.0.0"
 
 dunder-proto@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/dunder-proto/-/dunder-proto-1.0.1.tgz"
   integrity sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==
   dependencies:
     call-bind-apply-helpers "^1.0.1"
@@ -4026,109 +4300,119 @@ dunder-proto@^1.0.1:
 
 duplexer@^0.1.2:
   version "0.1.2"
-  resolved "https://registry.npmjs.org/duplexer/-/duplexer-0.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/duplexer/-/duplexer-0.1.2.tgz"
   integrity sha512-jtD6YG370ZCIi/9GTaJKQxWTZD045+4R4hTk/x1UyoqadyJ9x9CgSi1RlVDQF8U2sxLLSnFkCaMihqljHIWgMg==
 
 eastasianwidth@^0.2.0:
   version "0.2.0"
-  resolved "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/eastasianwidth/-/eastasianwidth-0.2.0.tgz"
   integrity sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==
 
 ee-first@1.1.1:
   version "1.1.1"
-  resolved "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/ee-first/-/ee-first-1.1.1.tgz"
   integrity sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==
 
-electron-to-chromium@^1.5.73:
-  version "1.5.76"
-  resolved "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.76.tgz"
-  integrity sha512-CjVQyG7n7Sr+eBXE86HIulnL5N8xZY1sgmOPGuq/F0Rr0FJq63lg0kEtOIDfZBk44FnDLf6FUJ+dsJcuiUDdDQ==
+electron-to-chromium@^1.5.328:
+  version "1.5.344"
+  resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.5.344.tgz"
+  integrity sha512-4MxfbmNDm+KPh066EZy+eUnkcDPcZ35wNmOWzFuh/ijvHsve6kbLTLURy88uCNK5FbpN+yk2nQY6BYh1GEt+wg==
 
 emoji-regex@^8.0.0:
   version "8.0.0"
-  resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz"
   integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==
 
 emoji-regex@^9.2.2:
   version "9.2.2"
-  resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz"
+  resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-9.2.2.tgz"
   integrity sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==
 
 emojilib@^2.4.0:
   version "2.4.0"
-  resolved "https://registry.npmjs.org/emojilib/-/emojilib-2.4.0.tgz"
+  resolved "https://registry.yarnpkg.com/emojilib/-/emojilib-2.4.0.tgz"
   integrity sha512-5U0rVMU5Y2n2+ykNLQqMoqklN9ICBT/KsvC1Gz6vqHbz2AXXGkG+Pm5rMWk/8Vjrr/mY9985Hi8DYzn1F09Nyw==
 
 emojis-list@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/emojis-list/-/emojis-list-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/emojis-list/-/emojis-list-3.0.0.tgz"
   integrity sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q==
 
 emoticon@^4.0.1:
   version "4.1.0"
-  resolved "https://registry.npmjs.org/emoticon/-/emoticon-4.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/emoticon/-/emoticon-4.1.0.tgz"
   integrity sha512-VWZfnxqwNcc51hIy/sbOdEem6D+cVtpPzEEtVAFdaas30+1dgkyaOQ4sQ6Bp0tOMqWO1v+HQfYaoodOkdhK6SQ==
 
-encodeurl@~1.0.2:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz"
-  integrity sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==
-
 encodeurl@~2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/encodeurl/-/encodeurl-2.0.0.tgz"
   integrity sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==
 
-enhanced-resolve@^5.17.1:
-  version "5.18.0"
-  resolved "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.18.0.tgz"
-  integrity sha512-0/r0MySGYG8YqlayBZ6MuCfECmHFdJ5qyPh8s8wa5Hnm6SaFLSK1VYCbj+NKp090Nm1caZhD+QTnmxO7esYGyQ==
+enhanced-resolve@^5.20.0:
+  version "5.21.0"
+  resolved "https://registry.yarnpkg.com/enhanced-resolve/-/enhanced-resolve-5.21.0.tgz"
+  integrity sha512-otxSQPw4lkOZWkHpB3zaEQs6gWYEsmX4xQF68ElXC/TWvGxGMSGOvoNbaLXm6/cS/fSfHtsEdw90y20PCd+sCA==
   dependencies:
     graceful-fs "^4.2.4"
-    tapable "^2.2.0"
+    tapable "^2.3.3"
 
 entities@^2.0.0:
   version "2.2.0"
-  resolved "https://registry.npmjs.org/entities/-/entities-2.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/entities/-/entities-2.2.0.tgz"
   integrity sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==
 
-entities@^4.2.0, entities@^4.4.0, entities@^4.5.0:
+entities@^4.2.0, entities@^4.4.0:
   version "4.5.0"
-  resolved "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz"
+  resolved "https://registry.yarnpkg.com/entities/-/entities-4.5.0.tgz"
   integrity sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==
 
+entities@^6.0.0:
+  version "6.0.1"
+  resolved "https://registry.yarnpkg.com/entities/-/entities-6.0.1.tgz"
+  integrity sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==
+
 error-ex@^1.3.1:
-  version "1.3.2"
-  resolved "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz"
-  integrity sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==
+  version "1.3.4"
+  resolved "https://registry.yarnpkg.com/error-ex/-/error-ex-1.3.4.tgz"
+  integrity sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ==
   dependencies:
     is-arrayish "^0.2.1"
 
 es-define-property@^1.0.0, es-define-property@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/es-define-property/-/es-define-property-1.0.1.tgz"
   integrity sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==
 
 es-errors@^1.3.0:
   version "1.3.0"
-  resolved "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/es-errors/-/es-errors-1.3.0.tgz"
   integrity sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==
 
-es-module-lexer@^1.2.1:
-  version "1.6.0"
-  resolved "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.6.0.tgz"
-  integrity sha512-qqnD1yMU6tk/jnaMosogGySTZP8YtUgAffA9nMN+E/rjxcfRQ6IEk7IiozUjgxKoFHBGjTLnrHB/YC45r/59EQ==
+es-module-lexer@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/es-module-lexer/-/es-module-lexer-2.1.0.tgz"
+  integrity sha512-n27zTYMjYu1aj4MjCWzSP7G9r75utsaoc8m61weK+W8JMBGGQybd43GstCXZ3WNmSFtGT9wi59qQTW6mhTR5LQ==
 
-es-object-atoms@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.0.0.tgz"
-  integrity sha512-MZ4iQ6JwHOBQjahnjwaC1ZtIBH+2ohjamzAO3oaHcXYup7qxjF2fixyH+Q71voWHeOkI2q/TnJao/KfXYIZWbw==
+es-object-atoms@^1.0.0, es-object-atoms@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/es-object-atoms/-/es-object-atoms-1.1.1.tgz"
+  integrity sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==
+  dependencies:
+    es-errors "^1.3.0"
+
+es-set-tostringtag@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz"
+  integrity sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==
   dependencies:
     es-errors "^1.3.0"
+    get-intrinsic "^1.2.6"
+    has-tostringtag "^1.0.2"
+    hasown "^2.0.2"
 
 esast-util-from-estree@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/esast-util-from-estree/-/esast-util-from-estree-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/esast-util-from-estree/-/esast-util-from-estree-2.0.0.tgz"
   integrity sha512-4CyanoAudUSBAn5K13H4JhsMH6L9ZP7XbLVe/dKybkxMO7eDyLsT8UHl9TRNrU2Gr9nz+FovfSIjuXWJ81uVwQ==
   dependencies:
     "@types/estree-jsx" "^1.0.0"
@@ -4138,7 +4422,7 @@ esast-util-from-estree@^2.0.0:
 
 esast-util-from-js@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/esast-util-from-js/-/esast-util-from-js-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/esast-util-from-js/-/esast-util-from-js-2.0.1.tgz"
   integrity sha512-8Ja+rNJ0Lt56Pcf3TAmpBZjmx8ZcK5Ts4cAzIOjsjevg9oSXJnl6SUQ2EevU8tv3h6ZLWmoKL5H4fgWvdvfETw==
   dependencies:
     "@types/estree-jsx" "^1.0.0"
@@ -4148,37 +4432,32 @@ esast-util-from-js@^2.0.0:
 
 escalade@^3.1.1, escalade@^3.2.0:
   version "3.2.0"
-  resolved "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/escalade/-/escalade-3.2.0.tgz"
   integrity sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==
 
 escape-goat@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/escape-goat/-/escape-goat-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/escape-goat/-/escape-goat-4.0.0.tgz"
   integrity sha512-2Sd4ShcWxbx6OY1IHyla/CVNwvg7XwZVoXZHcSu9w9SReNP1EzzD5T8NWKIR38fIqEns9kDWKUQTXXAmlDrdPg==
 
 escape-html@^1.0.3, escape-html@~1.0.3:
   version "1.0.3"
-  resolved "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/escape-html/-/escape-html-1.0.3.tgz"
   integrity sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==
 
-escape-string-regexp@^1.0.5:
-  version "1.0.5"
-  resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz"
-  integrity sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==
-
 escape-string-regexp@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz"
   integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==
 
 escape-string-regexp@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz"
   integrity sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==
 
 eslint-scope@5.1.1:
   version "5.1.1"
-  resolved "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-5.1.1.tgz"
   integrity sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==
   dependencies:
     esrecurse "^4.3.0"
@@ -4186,36 +4465,36 @@ eslint-scope@5.1.1:
 
 esprima@^4.0.0:
   version "4.0.1"
-  resolved "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz"
   integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==
 
 esrecurse@^4.3.0:
   version "4.3.0"
-  resolved "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.3.0.tgz"
   integrity sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==
   dependencies:
     estraverse "^5.2.0"
 
 estraverse@^4.1.1:
   version "4.3.0"
-  resolved "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.3.0.tgz"
   integrity sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==
 
 estraverse@^5.2.0:
   version "5.3.0"
-  resolved "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-5.3.0.tgz"
   integrity sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==
 
 estree-util-attach-comments@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/estree-util-attach-comments/-/estree-util-attach-comments-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/estree-util-attach-comments/-/estree-util-attach-comments-3.0.0.tgz"
   integrity sha512-cKUwm/HUcTDsYh/9FgnuFqpfquUbwIqwKM26BVCGDPVgvaCl/nDCCjUfiLlx6lsEZ3Z4RFxNbOQ60pkaEwFxGw==
   dependencies:
     "@types/estree" "^1.0.0"
 
 estree-util-build-jsx@^3.0.0:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/estree-util-build-jsx/-/estree-util-build-jsx-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/estree-util-build-jsx/-/estree-util-build-jsx-3.0.1.tgz"
   integrity sha512-8U5eiL6BTrPxp/CHbs2yMgP8ftMhR5ww1eIKoWRMlqvltHF8fZn5LRDvTKuxD3DUn+shRbLGqXemcP51oFCsGQ==
   dependencies:
     "@types/estree-jsx" "^1.0.0"
@@ -4225,12 +4504,12 @@ estree-util-build-jsx@^3.0.0:
 
 estree-util-is-identifier-name@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/estree-util-is-identifier-name/-/estree-util-is-identifier-name-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/estree-util-is-identifier-name/-/estree-util-is-identifier-name-3.0.0.tgz"
   integrity sha512-hFtqIDZTIUZ9BXLb8y4pYGyk6+wekIivNVTcmvk8NoOh+VeRn5y6cEHzbURrWbfp1fIqdVipilzj+lfaadNZmg==
 
 estree-util-scope@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/estree-util-scope/-/estree-util-scope-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/estree-util-scope/-/estree-util-scope-1.0.0.tgz"
   integrity sha512-2CAASclonf+JFWBNJPndcOpA8EMJwa0Q8LUFJEKqXLW6+qBvbFZuF5gItbQOs/umBUkjviCSDCbBwU2cXbmrhQ==
   dependencies:
     "@types/estree" "^1.0.0"
@@ -4238,7 +4517,7 @@ estree-util-scope@^1.0.0:
 
 estree-util-to-js@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/estree-util-to-js/-/estree-util-to-js-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/estree-util-to-js/-/estree-util-to-js-2.0.0.tgz"
   integrity sha512-WDF+xj5rRWmD5tj6bIqRi6CkLIXbbNQUcxQHzGysQzvHmdYG2G7p/Tf0J0gpxGgkeMZNTIjT/AoSvC9Xehcgdg==
   dependencies:
     "@types/estree-jsx" "^1.0.0"
@@ -4246,15 +4525,15 @@ estree-util-to-js@^2.0.0:
     source-map "^0.7.0"
 
 estree-util-value-to-estree@^3.0.1:
-  version "3.2.1"
-  resolved "https://registry.npmjs.org/estree-util-value-to-estree/-/estree-util-value-to-estree-3.2.1.tgz"
-  integrity sha512-Vt2UOjyPbNQQgT5eJh+K5aATti0OjCIAGc9SgMdOFYbohuifsWclR74l0iZTJwePMgWYdX1hlVS+dedH9XV8kw==
+  version "3.5.0"
+  resolved "https://registry.yarnpkg.com/estree-util-value-to-estree/-/estree-util-value-to-estree-3.5.0.tgz"
+  integrity sha512-aMV56R27Gv3QmfmF1MY12GWkGzzeAezAX+UplqHVASfjc9wNzI/X6hC0S9oxq61WT4aQesLGslWP9tKk6ghRZQ==
   dependencies:
     "@types/estree" "^1.0.0"
 
 estree-util-visit@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/estree-util-visit/-/estree-util-visit-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/estree-util-visit/-/estree-util-visit-2.0.0.tgz"
   integrity sha512-m5KgiH85xAhhW8Wta0vShLcUvOsh3LLPI2YVwcbio1l7E09NTLL1EyMZFM1OyWowoH0skScNbhOPl4kcBgzTww==
   dependencies:
     "@types/estree-jsx" "^1.0.0"
@@ -4262,47 +4541,47 @@ estree-util-visit@^2.0.0:
 
 estree-walker@^3.0.0:
   version "3.0.3"
-  resolved "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-3.0.3.tgz"
   integrity sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==
   dependencies:
     "@types/estree" "^1.0.0"
 
 esutils@^2.0.2:
   version "2.0.3"
-  resolved "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.3.tgz"
   integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==
 
 eta@^2.2.0:
   version "2.2.0"
-  resolved "https://registry.npmjs.org/eta/-/eta-2.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/eta/-/eta-2.2.0.tgz"
   integrity sha512-UVQ72Rqjy/ZKQalzV5dCCJP80GrmPrMxh6NlNf+erV6ObL0ZFkhCstWRawS85z3smdr3d2wXPsZEY7rDPfGd2g==
 
 etag@~1.8.1:
   version "1.8.1"
-  resolved "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/etag/-/etag-1.8.1.tgz"
   integrity sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==
 
 eval@^0.1.8:
   version "0.1.8"
-  resolved "https://registry.npmjs.org/eval/-/eval-0.1.8.tgz"
+  resolved "https://registry.yarnpkg.com/eval/-/eval-0.1.8.tgz"
   integrity sha512-EzV94NYKoO09GLXGjXj9JIlXijVck4ONSr5wiCWDvhsvj5jxSrzTmRU/9C1DyB6uToszLs8aifA6NQ7lEQdvFw==
   dependencies:
     "@types/node" "*"
     require-like ">= 0.1.1"
 
-eventemitter3@^4.0.0:
+eventemitter3@^4.0.0, eventemitter3@^4.0.4:
   version "4.0.7"
-  resolved "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz"
+  resolved "https://registry.yarnpkg.com/eventemitter3/-/eventemitter3-4.0.7.tgz"
   integrity sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==
 
 events@^3.2.0:
   version "3.3.0"
-  resolved "https://registry.npmjs.org/events/-/events-3.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/events/-/events-3.3.0.tgz"
   integrity sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==
 
-execa@^5.0.0:
+execa@^5.1.1:
   version "5.1.1"
-  resolved "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/execa/-/execa-5.1.1.tgz"
   integrity sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==
   dependencies:
     cross-spawn "^7.0.3"
@@ -4315,175 +4594,148 @@ execa@^5.0.0:
     signal-exit "^3.0.3"
     strip-final-newline "^2.0.0"
 
-express@^4.17.3:
-  version "4.21.2"
-  resolved "https://registry.npmjs.org/express/-/express-4.21.2.tgz"
-  integrity sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA==
+express@^4.22.1:
+  version "4.22.1"
+  resolved "https://registry.yarnpkg.com/express/-/express-4.22.1.tgz"
+  integrity sha512-F2X8g9P1X7uCPZMA3MVf9wcTqlyNp7IhH5qPCI0izhaOIYXaW9L535tGA3qmjRzpH+bZczqq7hVKxTR4NWnu+g==
   dependencies:
     accepts "~1.3.8"
     array-flatten "1.1.1"
-    body-parser "1.20.3"
-    content-disposition "0.5.4"
+    body-parser "~1.20.3"
+    content-disposition "~0.5.4"
     content-type "~1.0.4"
-    cookie "0.7.1"
-    cookie-signature "1.0.6"
+    cookie "~0.7.1"
+    cookie-signature "~1.0.6"
     debug "2.6.9"
     depd "2.0.0"
     encodeurl "~2.0.0"
     escape-html "~1.0.3"
     etag "~1.8.1"
-    finalhandler "1.3.1"
-    fresh "0.5.2"
-    http-errors "2.0.0"
+    finalhandler "~1.3.1"
+    fresh "~0.5.2"
+    http-errors "~2.0.0"
     merge-descriptors "1.0.3"
     methods "~1.1.2"
-    on-finished "2.4.1"
+    on-finished "~2.4.1"
     parseurl "~1.3.3"
-    path-to-regexp "0.1.12"
+    path-to-regexp "~0.1.12"
     proxy-addr "~2.0.7"
-    qs "6.13.0"
+    qs "~6.14.0"
     range-parser "~1.2.1"
     safe-buffer "5.2.1"
-    send "0.19.0"
-    serve-static "1.16.2"
+    send "~0.19.0"
+    serve-static "~1.16.2"
     setprototypeof "1.2.0"
-    statuses "2.0.1"
+    statuses "~2.0.1"
     type-is "~1.6.18"
     utils-merge "1.0.1"
     vary "~1.1.2"
 
 extend-shallow@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/extend-shallow/-/extend-shallow-2.0.1.tgz"
   integrity sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==
   dependencies:
     is-extendable "^0.1.0"
 
 extend@^3.0.0:
   version "3.0.2"
-  resolved "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/extend/-/extend-3.0.2.tgz"
   integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==
 
 fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3:
   version "3.1.3"
-  resolved "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz"
+  resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz"
   integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==
 
 fast-glob@^3.2.11, fast-glob@^3.2.9, fast-glob@^3.3.0:
-  version "3.3.2"
-  resolved "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.2.tgz"
-  integrity sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow==
+  version "3.3.3"
+  resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.3.3.tgz"
+  integrity sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==
   dependencies:
     "@nodelib/fs.stat" "^2.0.2"
     "@nodelib/fs.walk" "^1.2.3"
     glob-parent "^5.1.2"
     merge2 "^1.3.0"
-    micromatch "^4.0.4"
+    micromatch "^4.0.8"
 
 fast-json-stable-stringify@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz"
   integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==
 
 fast-uri@^3.0.1:
-  version "3.0.3"
-  resolved "https://registry.npmjs.org/fast-uri/-/fast-uri-3.0.3.tgz"
-  integrity sha512-aLrHthzCjH5He4Z2H9YZ+v6Ujb9ocRuW6ZzkJQOrTxleEijANq4v1TsaPaVG1PZcuurEzrLcWRyYBYXD5cEiaw==
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/fast-uri/-/fast-uri-3.1.0.tgz"
+  integrity sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==
 
 fastq@^1.6.0:
-  version "1.18.0"
-  resolved "https://registry.npmjs.org/fastq/-/fastq-1.18.0.tgz"
-  integrity sha512-QKHXPW0hD8g4UET03SdOdunzSouc9N4AuHdsX8XNcTsuz+yYFILVNIX4l9yHABMhiEI9Db0JTTIpu0wB+Y1QQw==
+  version "1.20.1"
+  resolved "https://registry.yarnpkg.com/fastq/-/fastq-1.20.1.tgz"
+  integrity sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==
   dependencies:
     reusify "^1.0.4"
 
 fault@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/fault/-/fault-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/fault/-/fault-2.0.1.tgz"
   integrity sha512-WtySTkS4OKev5JtpHXnib4Gxiurzh5NCGvWrFaZ34m6JehfTUhKZvn9njTfw48t6JumVQOmrKqpmGcdwxnhqBQ==
   dependencies:
     format "^0.2.0"
 
 faye-websocket@^0.11.3:
   version "0.11.4"
-  resolved "https://registry.npmjs.org/faye-websocket/-/faye-websocket-0.11.4.tgz"
+  resolved "https://registry.yarnpkg.com/faye-websocket/-/faye-websocket-0.11.4.tgz"
   integrity sha512-CzbClwlXAuiRQAlUyfqPgvPoNKTckTPGfwZV4ZdAhVcP2lh9KUxJg2b5GkE7XbjKQ3YJnQ9z6D9ntLAlB+tP8g==
   dependencies:
     websocket-driver ">=0.5.1"
 
 feed@^4.2.2:
   version "4.2.2"
-  resolved "https://registry.npmjs.org/feed/-/feed-4.2.2.tgz"
+  resolved "https://registry.yarnpkg.com/feed/-/feed-4.2.2.tgz"
   integrity sha512-u5/sxGfiMfZNtJ3OvQpXcvotFpYkL0n9u9mM2vkui2nGo8b4wvDkJ8gAkYqbA8QpGyFCv3RK0Z+Iv+9veCS9bQ==
   dependencies:
     xml-js "^1.6.11"
 
-figures@^3.2.0:
-  version "3.2.0"
-  resolved "https://registry.npmjs.org/figures/-/figures-3.2.0.tgz"
-  integrity sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg==
-  dependencies:
-    escape-string-regexp "^1.0.5"
-
 file-loader@^6.2.0:
   version "6.2.0"
-  resolved "https://registry.npmjs.org/file-loader/-/file-loader-6.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/file-loader/-/file-loader-6.2.0.tgz"
   integrity sha512-qo3glqyTa61Ytg4u73GultjHGjdRyig3tG6lPtyX/jOEJvHif9uB0/OCI2Kif6ctF3caQTW2G5gym21oAsI4pw==
   dependencies:
     loader-utils "^2.0.0"
     schema-utils "^3.0.0"
 
-filesize@^8.0.6:
-  version "8.0.7"
-  resolved "https://registry.npmjs.org/filesize/-/filesize-8.0.7.tgz"
-  integrity sha512-pjmC+bkIF8XI7fWaH8KxHcZL3DPybs1roSKP4rKDvy20tAWwIObE4+JIseG2byfGKhud5ZnM4YSGKBz7Sh0ndQ==
-
 fill-range@^7.1.1:
   version "7.1.1"
-  resolved "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-7.1.1.tgz"
   integrity sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==
   dependencies:
     to-regex-range "^5.0.1"
 
-finalhandler@1.3.1:
-  version "1.3.1"
-  resolved "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.1.tgz"
-  integrity sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==
+finalhandler@~1.3.1:
+  version "1.3.2"
+  resolved "https://registry.yarnpkg.com/finalhandler/-/finalhandler-1.3.2.tgz"
+  integrity sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg==
   dependencies:
     debug "2.6.9"
     encodeurl "~2.0.0"
     escape-html "~1.0.3"
-    on-finished "2.4.1"
+    on-finished "~2.4.1"
     parseurl "~1.3.3"
-    statuses "2.0.1"
+    statuses "~2.0.2"
     unpipe "~1.0.0"
 
 find-cache-dir@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/find-cache-dir/-/find-cache-dir-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/find-cache-dir/-/find-cache-dir-4.0.0.tgz"
   integrity sha512-9ZonPT4ZAK4a+1pUPVPZJapbi7O5qbbJPdYw/NOQWZZbVLdDTYM3A4R9z/DpAM08IDaFGsvPgiGZ82WEwUDWjg==
   dependencies:
     common-path-prefix "^3.0.0"
     pkg-dir "^7.0.0"
 
-find-up@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz"
-  integrity sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==
-  dependencies:
-    locate-path "^3.0.0"
-
-find-up@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz"
-  integrity sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==
-  dependencies:
-    locate-path "^6.0.0"
-    path-exists "^4.0.0"
-
 find-up@^6.3.0:
   version "6.3.0"
-  resolved "https://registry.npmjs.org/find-up/-/find-up-6.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/find-up/-/find-up-6.3.0.tgz"
   integrity sha512-v2ZsoEuVHYy8ZIlYqwPe/39Cy+cFDzp4dXPaxNvkEuouymu+2Jbz0PxpKarJHYJTmv2HWT3O382qY8l4jMWthw==
   dependencies:
     locate-path "^7.1.0"
@@ -4491,122 +4743,85 @@ find-up@^6.3.0:
 
 flat@^5.0.2:
   version "5.0.2"
-  resolved "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/flat/-/flat-5.0.2.tgz"
   integrity sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==
 
-follow-redirects@^1.0.0, follow-redirects@^1.15.6:
-  version "1.15.9"
-  resolved "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.9.tgz"
-  integrity sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==
-
-fork-ts-checker-webpack-plugin@^6.5.0:
-  version "6.5.3"
-  resolved "https://registry.npmjs.org/fork-ts-checker-webpack-plugin/-/fork-ts-checker-webpack-plugin-6.5.3.tgz"
-  integrity sha512-SbH/l9ikmMWycd5puHJKTkZJKddF4iRLyW3DeZ08HTI7NGyLS38MXd/KGgeWumQO7YNQbW2u/NtPT2YowbPaGQ==
-  dependencies:
-    "@babel/code-frame" "^7.8.3"
-    "@types/json-schema" "^7.0.5"
-    chalk "^4.1.0"
-    chokidar "^3.4.2"
-    cosmiconfig "^6.0.0"
-    deepmerge "^4.2.2"
-    fs-extra "^9.0.0"
-    glob "^7.1.6"
-    memfs "^3.1.2"
-    minimatch "^3.0.4"
-    schema-utils "2.7.0"
-    semver "^7.3.2"
-    tapable "^1.0.0"
+follow-redirects@^1.0.0, follow-redirects@^1.15.11:
+  version "1.16.0"
+  resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.16.0.tgz"
+  integrity sha512-y5rN/uOsadFT/JfYwhxRS5R7Qce+g3zG97+JrtFZlC9klX/W5hD7iiLzScI4nZqUS7DNUdhPgw4xI8W2LuXlUw==
 
 form-data-encoder@^2.1.2:
   version "2.1.4"
-  resolved "https://registry.npmjs.org/form-data-encoder/-/form-data-encoder-2.1.4.tgz"
+  resolved "https://registry.yarnpkg.com/form-data-encoder/-/form-data-encoder-2.1.4.tgz"
   integrity sha512-yDYSgNMraqvnxiEXO4hi88+YZxaHC6QKzb5N84iRCTDeRO7ZALpir/lVmf/uXUhnwUr2O4HU8s/n6x+yNjQkHw==
 
-form-data@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.npmjs.org/form-data/-/form-data-4.0.1.tgz"
-  integrity sha512-tzN8e4TX8+kkxGPK8D5u0FNmjPUjw3lwC9lSLxxoB/+GtsJG91CO8bSWy73APlgAZzZbXEYZJuxjkHH2w+Ezhw==
+form-data@^4.0.5:
+  version "4.0.5"
+  resolved "https://registry.yarnpkg.com/form-data/-/form-data-4.0.5.tgz"
+  integrity sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==
   dependencies:
     asynckit "^0.4.0"
     combined-stream "^1.0.8"
+    es-set-tostringtag "^2.1.0"
+    hasown "^2.0.2"
     mime-types "^2.1.12"
 
 format@^0.2.0:
   version "0.2.2"
-  resolved "https://registry.npmjs.org/format/-/format-0.2.2.tgz"
+  resolved "https://registry.yarnpkg.com/format/-/format-0.2.2.tgz"
   integrity sha512-wzsgA6WOq+09wrU1tsJ09udeR/YZRaeArL9e1wPbFg3GG2yDnC2ldKpxs4xunpFF9DgqCqOIra3bc1HWrJ37Ww==
 
 forwarded@0.2.0:
   version "0.2.0"
-  resolved "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/forwarded/-/forwarded-0.2.0.tgz"
   integrity sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==
 
-fraction.js@^4.3.7:
-  version "4.3.7"
-  resolved "https://registry.npmjs.org/fraction.js/-/fraction.js-4.3.7.tgz"
-  integrity sha512-ZsDfxO51wGAXREY55a7la9LScWpwv9RxIrYABrlvOFBlH/ShPnrtsXeuUIfXKKOVicNxQ+o8JTbJvjS4M89yew==
+fraction.js@^5.3.4:
+  version "5.3.4"
+  resolved "https://registry.yarnpkg.com/fraction.js/-/fraction.js-5.3.4.tgz"
+  integrity sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ==
 
-fresh@0.5.2:
+fresh@~0.5.2:
   version "0.5.2"
-  resolved "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz"
+  resolved "https://registry.yarnpkg.com/fresh/-/fresh-0.5.2.tgz"
   integrity sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==
 
 fs-extra@^11.1.1, fs-extra@^11.2.0:
-  version "11.2.0"
-  resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-11.2.0.tgz"
-  integrity sha512-PmDi3uwK5nFuXh7XDTlVnS17xJS7vW36is2+w3xcv8SVxiB4NyATf4ctkVY5bkSjX0Y4nbvZCq1/EjtEyr9ktw==
+  version "11.3.4"
+  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-11.3.4.tgz"
+  integrity sha512-CTXd6rk/M3/ULNQj8FBqBWHYBVYybQ3VPBw0xGKFe3tuH7ytT6ACnvzpIQ3UZtB8yvUKC2cXn1a+x+5EVQLovA==
   dependencies:
     graceful-fs "^4.2.0"
     jsonfile "^6.0.1"
     universalify "^2.0.0"
 
-fs-extra@^9.0.0:
-  version "9.1.0"
-  resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz"
-  integrity sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==
-  dependencies:
-    at-least-node "^1.0.0"
-    graceful-fs "^4.2.0"
-    jsonfile "^6.0.1"
-    universalify "^2.0.0"
-
-fs-monkey@^1.0.4:
-  version "1.0.6"
-  resolved "https://registry.npmjs.org/fs-monkey/-/fs-monkey-1.0.6.tgz"
-  integrity sha512-b1FMfwetIKymC0eioW7mTywihSQE4oLzQn1dB6rZB5fx/3NpNEdAWeCSMB+60/AeT0TCXsxzAlcYVEFCTAksWg==
-
-fs.realpath@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz"
-  integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==
-
 fsevents@~2.3.2:
   version "2.3.3"
-  resolved "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz"
+  resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.3.tgz#cac6407785d03675a2a5e1a5305c697b347d90d6"
   integrity sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==
 
 function-bind@^1.1.2:
   version "1.1.2"
-  resolved "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.2.tgz"
   integrity sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==
 
 gensync@^1.0.0-beta.2:
   version "1.0.0-beta.2"
-  resolved "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz"
+  resolved "https://registry.yarnpkg.com/gensync/-/gensync-1.0.0-beta.2.tgz"
   integrity sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==
 
-get-intrinsic@^1.2.4, get-intrinsic@^1.2.5, get-intrinsic@^1.2.6:
-  version "1.2.7"
-  resolved "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.7.tgz"
-  integrity sha512-VW6Pxhsrk0KAOqs3WEd0klDiF/+V7gQOpAvY1jVU/LHmaD/kQO4523aiJuikX/QAKYiW6x8Jh+RJej1almdtCA==
+get-intrinsic@^1.2.4, get-intrinsic@^1.2.5, get-intrinsic@^1.2.6, get-intrinsic@^1.3.0:
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/get-intrinsic/-/get-intrinsic-1.3.0.tgz"
+  integrity sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==
   dependencies:
-    call-bind-apply-helpers "^1.0.1"
+    call-bind-apply-helpers "^1.0.2"
     es-define-property "^1.0.1"
     es-errors "^1.3.0"
-    es-object-atoms "^1.0.0"
+    es-object-atoms "^1.1.1"
     function-bind "^1.1.2"
-    get-proto "^1.0.0"
+    get-proto "^1.0.1"
     gopd "^1.2.0"
     has-symbols "^1.1.0"
     hasown "^2.0.2"
@@ -4614,89 +4829,61 @@ get-intrinsic@^1.2.4, get-intrinsic@^1.2.5, get-intrinsic@^1.2.6:
 
 get-own-enumerable-property-symbols@^3.0.0:
   version "3.0.2"
-  resolved "https://registry.npmjs.org/get-own-enumerable-property-symbols/-/get-own-enumerable-property-symbols-3.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/get-own-enumerable-property-symbols/-/get-own-enumerable-property-symbols-3.0.2.tgz"
   integrity sha512-I0UBV/XOz1XkIJHEUDMZAbzCThU/H8DxmSfmdGcKPnVhu2VfFqr34jr9777IyaTYvxjedWhqVIilEDsCdP5G6g==
 
-get-proto@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/get-proto/-/get-proto-1.0.0.tgz"
-  integrity sha512-TtLgOcKaF1nMP2ijJnITkE4nRhbpshHhmzKiuhmSniiwWzovoqwqQ8rNuhf0mXJOqIY5iU+QkUe0CkJYrLsG9w==
+get-proto@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/get-proto/-/get-proto-1.0.1.tgz"
+  integrity sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==
   dependencies:
     dunder-proto "^1.0.1"
     es-object-atoms "^1.0.0"
 
 get-stream@^6.0.0, get-stream@^6.0.1:
   version "6.0.1"
-  resolved "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-6.0.1.tgz"
   integrity sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==
 
 github-slugger@^1.5.0:
   version "1.5.0"
-  resolved "https://registry.npmjs.org/github-slugger/-/github-slugger-1.5.0.tgz"
+  resolved "https://registry.yarnpkg.com/github-slugger/-/github-slugger-1.5.0.tgz"
   integrity sha512-wIh+gKBI9Nshz2o46B0B3f5k/W+WI9ZAv6y5Dn5WJ5SK1t0TnDimB4WE5rmTD05ZAIn8HALCZVmCsvj0w0v0lw==
 
 glob-parent@^5.1.2, glob-parent@~5.1.2:
   version "5.1.2"
-  resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz"
   integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==
   dependencies:
     is-glob "^4.0.1"
 
 glob-parent@^6.0.1:
   version "6.0.2"
-  resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-6.0.2.tgz"
   integrity sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==
   dependencies:
     is-glob "^4.0.3"
 
+glob-to-regex.js@^1.0.0, glob-to-regex.js@^1.0.1:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/glob-to-regex.js/-/glob-to-regex.js-1.2.0.tgz"
+  integrity sha512-QMwlOQKU/IzqMUOAZWubUOT8Qft+Y0KQWnX9nK3ch0CJg0tTp4TvGZsTfudYKv2NzoQSyPcnA6TYeIQ3jGichQ==
+
 glob-to-regexp@^0.4.1:
   version "0.4.1"
-  resolved "https://registry.npmjs.org/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz"
+  resolved "https://registry.yarnpkg.com/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz"
   integrity sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==
 
-glob@^7.0.0, glob@^7.1.3, glob@^7.1.6:
-  version "7.2.3"
-  resolved "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz"
-  integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==
-  dependencies:
-    fs.realpath "^1.0.0"
-    inflight "^1.0.4"
-    inherits "2"
-    minimatch "^3.1.1"
-    once "^1.3.0"
-    path-is-absolute "^1.0.0"
-
 global-dirs@^3.0.0:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/global-dirs/-/global-dirs-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/global-dirs/-/global-dirs-3.0.1.tgz"
   integrity sha512-NBcGGFbBA9s1VzD41QXDG+3++t9Mn5t1FpLdhESY6oKY4gYTFpX4wO3sqGUa0Srjtbfj3szX0RnemmrVRUdULA==
   dependencies:
     ini "2.0.0"
 
-global-modules@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/global-modules/-/global-modules-2.0.0.tgz"
-  integrity sha512-NGbfmJBp9x8IxyJSd1P+otYK8vonoJactOogrVfFRIAEY1ukil8RSKDz2Yo7wh1oihl51l/r6W4epkeKJHqL8A==
-  dependencies:
-    global-prefix "^3.0.0"
-
-global-prefix@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/global-prefix/-/global-prefix-3.0.0.tgz"
-  integrity sha512-awConJSVCHVGND6x3tmMaKcQvwXLhjdkmomy2W+Goaui8YPgYgXJZewhg3fWC+DlfqqQuWg8AwqjGTD2nAPVWg==
-  dependencies:
-    ini "^1.3.5"
-    kind-of "^6.0.2"
-    which "^1.3.1"
-
-globals@^11.1.0:
-  version "11.12.0"
-  resolved "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz"
-  integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==
-
-globby@^11.0.1, globby@^11.0.4, globby@^11.1.0:
+globby@^11.1.0:
   version "11.1.0"
-  resolved "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/globby/-/globby-11.1.0.tgz"
   integrity sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==
   dependencies:
     array-union "^2.1.0"
@@ -4708,7 +4895,7 @@ globby@^11.0.1, globby@^11.0.4, globby@^11.1.0:
 
 globby@^13.1.1:
   version "13.2.2"
-  resolved "https://registry.npmjs.org/globby/-/globby-13.2.2.tgz"
+  resolved "https://registry.yarnpkg.com/globby/-/globby-13.2.2.tgz"
   integrity sha512-Y1zNGV+pzQdh7H39l9zgB4PJqjRNqydvdYCDG4HFXM4XuvSaQQlEc91IU1yALL8gUTDomgBAfz3XJdmUS+oo0w==
   dependencies:
     dir-glob "^3.0.1"
@@ -4719,12 +4906,12 @@ globby@^13.1.1:
 
 gopd@^1.0.1, gopd@^1.2.0:
   version "1.2.0"
-  resolved "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/gopd/-/gopd-1.2.0.tgz"
   integrity sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==
 
 got@^12.1.0:
   version "12.6.1"
-  resolved "https://registry.npmjs.org/got/-/got-12.6.1.tgz"
+  resolved "https://registry.yarnpkg.com/got/-/got-12.6.1.tgz"
   integrity sha512-mThBblvlAF1d4O5oqyvN+ZxLAYwIJK7bpMxgYqPD9okW0C3qm5FFn7k811QrcuEBwaogR3ngOFoCfs6mRv7teQ==
   dependencies:
     "@sindresorhus/is" "^5.2.0"
@@ -4741,17 +4928,17 @@ got@^12.1.0:
 
 graceful-fs@4.2.10:
   version "4.2.10"
-  resolved "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz"
+  resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.10.tgz"
   integrity sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==
 
 graceful-fs@^4.1.2, graceful-fs@^4.1.6, graceful-fs@^4.2.0, graceful-fs@^4.2.11, graceful-fs@^4.2.4, graceful-fs@^4.2.6, graceful-fs@^4.2.9:
   version "4.2.11"
-  resolved "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz"
+  resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.11.tgz"
   integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==
 
 gray-matter@^4.0.3:
   version "4.0.3"
-  resolved "https://registry.npmjs.org/gray-matter/-/gray-matter-4.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/gray-matter/-/gray-matter-4.0.3.tgz"
   integrity sha512-5v6yZd4JK3eMI3FqqCouswVqwugaA9r4dNZB1wwcmrD02QkV5H0y7XBQW8QwQqEaZY1pM9aqORSORhJRdNK44Q==
   dependencies:
     js-yaml "^3.13.1"
@@ -4761,69 +4948,76 @@ gray-matter@^4.0.3:
 
 gzip-size@^6.0.0:
   version "6.0.0"
-  resolved "https://registry.npmjs.org/gzip-size/-/gzip-size-6.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/gzip-size/-/gzip-size-6.0.0.tgz"
   integrity sha512-ax7ZYomf6jqPTQ4+XCpUGyXKHk5WweS+e05MBO4/y3WJ5RkmPXNKvX+bx1behVILVwr6JSQvZAku021CHPXG3Q==
   dependencies:
     duplexer "^0.1.2"
 
 handle-thing@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/handle-thing/-/handle-thing-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/handle-thing/-/handle-thing-2.0.1.tgz"
   integrity sha512-9Qn4yBxelxoh2Ow62nP+Ka/kMnOXRi8BXnRaUwezLNhqelnN49xKz4F/dPP8OYLxLxq6JDtZb2i9XznUQbNPTg==
 
 has-flag@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz"
   integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==
 
 has-property-descriptors@^1.0.0, has-property-descriptors@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz"
   integrity sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==
   dependencies:
     es-define-property "^1.0.0"
 
-has-symbols@^1.1.0:
+has-symbols@^1.0.3, has-symbols@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.1.0.tgz"
   integrity sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==
 
+has-tostringtag@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/has-tostringtag/-/has-tostringtag-1.0.2.tgz"
+  integrity sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==
+  dependencies:
+    has-symbols "^1.0.3"
+
 has-yarn@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/has-yarn/-/has-yarn-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/has-yarn/-/has-yarn-3.0.0.tgz"
   integrity sha512-IrsVwUHhEULx3R8f/aA8AHuEzAorplsab/v8HBzEiIukwq5i/EC+xmOW+HfP1OaDP+2JkgT1yILHN2O3UFIbcA==
 
 hasown@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz"
-  integrity sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/hasown/-/hasown-2.0.3.tgz"
+  integrity sha512-ej4AhfhfL2Q2zpMmLo7U1Uv9+PyhIZpgQLGT1F9miIGmiCJIoCgSmczFdrc97mWT4kVY72KA+WnnhJ5pghSvSg==
   dependencies:
     function-bind "^1.1.2"
 
 hast-util-from-parse5@^8.0.0:
-  version "8.0.2"
-  resolved "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-8.0.2.tgz"
-  integrity sha512-SfMzfdAi/zAoZ1KkFEyyeXBn7u/ShQrfd675ZEE9M3qj+PMFX05xubzRyF76CCSJu8au9jgVxDV1+okFvgZU4A==
+  version "8.0.3"
+  resolved "https://registry.yarnpkg.com/hast-util-from-parse5/-/hast-util-from-parse5-8.0.3.tgz"
+  integrity sha512-3kxEVkEKt0zvcZ3hCRYI8rqrgwtlIOFMWkbclACvjlDw8Li9S2hk/d51OI0nr/gIpdMHNepwgOKqZ/sy0Clpyg==
   dependencies:
     "@types/hast" "^3.0.0"
     "@types/unist" "^3.0.0"
     devlop "^1.0.0"
     hastscript "^9.0.0"
-    property-information "^6.0.0"
+    property-information "^7.0.0"
     vfile "^6.0.0"
     vfile-location "^5.0.0"
     web-namespaces "^2.0.0"
 
 hast-util-parse-selector@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/hast-util-parse-selector/-/hast-util-parse-selector-4.0.0.tgz"
   integrity sha512-wkQCkSYoOGCRKERFWcxMVMOcYE2K1AaNLU8DXS9arxnLOUEWbOXKXiJUNzEpqZ3JOKpnha3jkFrumEjVliDe7A==
   dependencies:
     "@types/hast" "^3.0.0"
 
 hast-util-raw@^9.0.0:
   version "9.1.0"
-  resolved "https://registry.npmjs.org/hast-util-raw/-/hast-util-raw-9.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/hast-util-raw/-/hast-util-raw-9.1.0.tgz"
   integrity sha512-Y8/SBAHkZGoNkpzqqfCldijcuUKh7/su31kEBp67cFY09Wy0mTRgtsLYsiIxMJxlu0f6AA5SUTbDR8K0rxnbUw==
   dependencies:
     "@types/hast" "^3.0.0"
@@ -4841,9 +5035,9 @@ hast-util-raw@^9.0.0:
     zwitch "^2.0.0"
 
 hast-util-to-estree@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/hast-util-to-estree/-/hast-util-to-estree-3.1.0.tgz"
-  integrity sha512-lfX5g6hqVh9kjS/B9E2gSkvHH4SZNiQFiqWS0x9fENzEl+8W12RqdRxX6d/Cwxi30tPQs3bIO+aolQJNp1bIyw==
+  version "3.1.3"
+  resolved "https://registry.yarnpkg.com/hast-util-to-estree/-/hast-util-to-estree-3.1.3.tgz"
+  integrity sha512-48+B/rJWAp0jamNbAAf9M7Uf//UVqAoMmgXhBdxTDJLGKY+LRnZ99qcG+Qjl5HfMpYNzS5v4EAwVEF34LeAj7w==
   dependencies:
     "@types/estree" "^1.0.0"
     "@types/estree-jsx" "^1.0.0"
@@ -4856,16 +5050,16 @@ hast-util-to-estree@^3.0.0:
     mdast-util-mdx-expression "^2.0.0"
     mdast-util-mdx-jsx "^3.0.0"
     mdast-util-mdxjs-esm "^2.0.0"
-    property-information "^6.0.0"
+    property-information "^7.0.0"
     space-separated-tokens "^2.0.0"
-    style-to-object "^0.4.0"
+    style-to-js "^1.0.0"
     unist-util-position "^5.0.0"
     zwitch "^2.0.0"
 
 hast-util-to-jsx-runtime@^2.0.0:
-  version "2.3.2"
-  resolved "https://registry.npmjs.org/hast-util-to-jsx-runtime/-/hast-util-to-jsx-runtime-2.3.2.tgz"
-  integrity sha512-1ngXYb+V9UT5h+PxNRa1O1FYguZK/XL+gkeqvp7EdHlB9oHUG0eYRo/vY5inBdcqo3RkPMC58/H94HvkbfGdyg==
+  version "2.3.6"
+  resolved "https://registry.yarnpkg.com/hast-util-to-jsx-runtime/-/hast-util-to-jsx-runtime-2.3.6.tgz"
+  integrity sha512-zl6s8LwNyo1P9uw+XJGvZtdFF1GdAkOg8ujOw+4Pyb76874fLps4ueHXDhXWdk6YHQ6OgUtinliG7RsYvCbbBg==
   dependencies:
     "@types/estree" "^1.0.0"
     "@types/hast" "^3.0.0"
@@ -4877,51 +5071,51 @@ hast-util-to-jsx-runtime@^2.0.0:
     mdast-util-mdx-expression "^2.0.0"
     mdast-util-mdx-jsx "^3.0.0"
     mdast-util-mdxjs-esm "^2.0.0"
-    property-information "^6.0.0"
+    property-information "^7.0.0"
     space-separated-tokens "^2.0.0"
-    style-to-object "^1.0.0"
+    style-to-js "^1.0.0"
     unist-util-position "^5.0.0"
     vfile-message "^4.0.0"
 
 hast-util-to-parse5@^8.0.0:
-  version "8.0.0"
-  resolved "https://registry.npmjs.org/hast-util-to-parse5/-/hast-util-to-parse5-8.0.0.tgz"
-  integrity sha512-3KKrV5ZVI8if87DVSi1vDeByYrkGzg4mEfeu4alwgmmIeARiBLKCZS2uw5Gb6nU9x9Yufyj3iudm6i7nl52PFw==
+  version "8.0.1"
+  resolved "https://registry.yarnpkg.com/hast-util-to-parse5/-/hast-util-to-parse5-8.0.1.tgz"
+  integrity sha512-MlWT6Pjt4CG9lFCjiz4BH7l9wmrMkfkJYCxFwKQic8+RTZgWPuWxwAfjJElsXkex7DJjfSJsQIt931ilUgmwdA==
   dependencies:
     "@types/hast" "^3.0.0"
     comma-separated-tokens "^2.0.0"
     devlop "^1.0.0"
-    property-information "^6.0.0"
+    property-information "^7.0.0"
     space-separated-tokens "^2.0.0"
     web-namespaces "^2.0.0"
     zwitch "^2.0.0"
 
 hast-util-whitespace@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz"
   integrity sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==
   dependencies:
     "@types/hast" "^3.0.0"
 
 hastscript@^9.0.0:
-  version "9.0.0"
-  resolved "https://registry.npmjs.org/hastscript/-/hastscript-9.0.0.tgz"
-  integrity sha512-jzaLBGavEDKHrc5EfFImKN7nZKKBdSLIdGvCwDZ9TfzbF2ffXiov8CKE445L2Z1Ek2t/m4SKQ2j6Ipv7NyUolw==
+  version "9.0.1"
+  resolved "https://registry.yarnpkg.com/hastscript/-/hastscript-9.0.1.tgz"
+  integrity sha512-g7df9rMFX/SPi34tyGCyUBREQoKkapwdY/T04Qn9TDWfHhAYt4/I0gMVirzK5wEzeUqIjEB+LXC/ypb7Aqno5w==
   dependencies:
     "@types/hast" "^3.0.0"
     comma-separated-tokens "^2.0.0"
     hast-util-parse-selector "^4.0.0"
-    property-information "^6.0.0"
+    property-information "^7.0.0"
     space-separated-tokens "^2.0.0"
 
 he@^1.2.0:
   version "1.2.0"
-  resolved "https://registry.npmjs.org/he/-/he-1.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/he/-/he-1.2.0.tgz"
   integrity sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==
 
 history@^4.9.0:
   version "4.10.1"
-  resolved "https://registry.npmjs.org/history/-/history-4.10.1.tgz"
+  resolved "https://registry.yarnpkg.com/history/-/history-4.10.1.tgz"
   integrity sha512-36nwAD620w12kuzPAsyINPWJqlNbij+hpK1k9XRloDtym8mxzGYl2c17LnV6IAGB2Dmg4tEa7G7DlawS0+qjew==
   dependencies:
     "@babel/runtime" "^7.1.2"
@@ -4933,14 +5127,14 @@ history@^4.9.0:
 
 hoist-non-react-statics@^3.1.0:
   version "3.3.2"
-  resolved "https://registry.npmjs.org/hoist-non-react-statics/-/hoist-non-react-statics-3.3.2.tgz"
+  resolved "https://registry.yarnpkg.com/hoist-non-react-statics/-/hoist-non-react-statics-3.3.2.tgz"
   integrity sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==
   dependencies:
     react-is "^16.7.0"
 
 hpack.js@^2.1.6:
   version "2.1.6"
-  resolved "https://registry.npmjs.org/hpack.js/-/hpack.js-2.1.6.tgz"
+  resolved "https://registry.yarnpkg.com/hpack.js/-/hpack.js-2.1.6.tgz"
   integrity sha512-zJxVehUdMGIKsRaNt7apO2Gqp0BdqW5yaiGHXXmbpvxgBYVZnAql+BJb4RO5ad2MgpbZKn5G6nMnegrH1FcNYQ==
   dependencies:
     inherits "^2.0.1"
@@ -4948,19 +5142,14 @@ hpack.js@^2.1.6:
     readable-stream "^2.0.1"
     wbuf "^1.1.0"
 
-html-entities@^2.3.2:
-  version "2.5.2"
-  resolved "https://registry.npmjs.org/html-entities/-/html-entities-2.5.2.tgz"
-  integrity sha512-K//PSRMQk4FZ78Kyau+mZurHn3FH0Vwr+H36eE0rPbeYkRRi9YxceYPhuN60UwWorxyKHhqoAJl2OFKa4BVtaA==
-
 html-escaper@^2.0.2:
   version "2.0.2"
-  resolved "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/html-escaper/-/html-escaper-2.0.2.tgz"
   integrity sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==
 
 html-minifier-terser@^6.0.2:
   version "6.1.0"
-  resolved "https://registry.npmjs.org/html-minifier-terser/-/html-minifier-terser-6.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/html-minifier-terser/-/html-minifier-terser-6.1.0.tgz"
   integrity sha512-YXxSlJBZTP7RS3tWnQw74ooKa6L9b9i9QYXY21eUEvhZ3u9XLfv6OnFsQq6RxkhHygsaUMvYsZRV5rU/OVNZxw==
   dependencies:
     camel-case "^4.1.2"
@@ -4973,7 +5162,7 @@ html-minifier-terser@^6.0.2:
 
 html-minifier-terser@^7.2.0:
   version "7.2.0"
-  resolved "https://registry.npmjs.org/html-minifier-terser/-/html-minifier-terser-7.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/html-minifier-terser/-/html-minifier-terser-7.2.0.tgz"
   integrity sha512-tXgn3QfqPIpGl9o+K5tpcj3/MN4SfLtsx2GWwBC3SSd0tXQGyF3gsSqad8loJgKZGM3ZxbYDd5yhiBIdWpmvLA==
   dependencies:
     camel-case "^4.1.2"
@@ -4986,18 +5175,18 @@ html-minifier-terser@^7.2.0:
 
 html-tags@^3.3.1:
   version "3.3.1"
-  resolved "https://registry.npmjs.org/html-tags/-/html-tags-3.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/html-tags/-/html-tags-3.3.1.tgz"
   integrity sha512-ztqyC3kLto0e9WbNp0aeP+M3kTt+nbaIveGmUxAtZa+8iFgKLUOD4YKM5j+f3QD89bra7UeumolZHKuOXnTmeQ==
 
 html-void-elements@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/html-void-elements/-/html-void-elements-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/html-void-elements/-/html-void-elements-3.0.0.tgz"
   integrity sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==
 
 html-webpack-plugin@^5.6.0:
-  version "5.6.3"
-  resolved "https://registry.npmjs.org/html-webpack-plugin/-/html-webpack-plugin-5.6.3.tgz"
-  integrity sha512-QSf1yjtSAsmf7rYBV7XX86uua4W/vkhIt0xNXKbsi2foEeW7vjJQz4bhnpL3xH+l1ryl1680uNv968Z+X6jSYg==
+  version "5.6.7"
+  resolved "https://registry.yarnpkg.com/html-webpack-plugin/-/html-webpack-plugin-5.6.7.tgz"
+  integrity sha512-md+vXtdCAe60s1k6AU3dUyMJnDxUyQAwfwPKoLisvgUF1IXjtlLsk2se54+qfL9Mdm26bbwvjJybpNx48NKRLw==
   dependencies:
     "@types/html-minifier-terser" "^6.0.0"
     html-minifier-terser "^6.0.2"
@@ -5007,7 +5196,7 @@ html-webpack-plugin@^5.6.0:
 
 htmlparser2@^6.1.0:
   version "6.1.0"
-  resolved "https://registry.npmjs.org/htmlparser2/-/htmlparser2-6.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/htmlparser2/-/htmlparser2-6.1.0.tgz"
   integrity sha512-gyyPk6rgonLFEDGoeRgQNaEUvdJ4ktTmmUh/h2t7s+M8oPpIPxgNACWa+6ESR57kXstwqPiCut0V8NRpcwgU7A==
   dependencies:
     domelementtype "^2.0.1"
@@ -5017,7 +5206,7 @@ htmlparser2@^6.1.0:
 
 htmlparser2@^8.0.1:
   version "8.0.2"
-  resolved "https://registry.npmjs.org/htmlparser2/-/htmlparser2-8.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/htmlparser2/-/htmlparser2-8.0.2.tgz"
   integrity sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA==
   dependencies:
     domelementtype "^2.3.0"
@@ -5026,44 +5215,45 @@ htmlparser2@^8.0.1:
     entities "^4.4.0"
 
 http-cache-semantics@^4.1.1:
-  version "4.1.1"
-  resolved "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.1.1.tgz"
-  integrity sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ==
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz"
+  integrity sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==
 
 http-deceiver@^1.2.7:
   version "1.2.7"
-  resolved "https://registry.npmjs.org/http-deceiver/-/http-deceiver-1.2.7.tgz"
+  resolved "https://registry.yarnpkg.com/http-deceiver/-/http-deceiver-1.2.7.tgz"
   integrity sha512-LmpOGxTfbpgtGVxJrj5k7asXHCgNZp5nLfp+hWc8QQRqtb7fUy6kRY3BO1h9ddF6yIPYUARgxGOwB42DnxIaNw==
 
-http-errors@2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz"
-  integrity sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==
+http-errors@~1.8.0:
+  version "1.8.1"
+  resolved "https://registry.yarnpkg.com/http-errors/-/http-errors-1.8.1.tgz"
+  integrity sha512-Kpk9Sm7NmI+RHhnj6OIWDI1d6fIoFAtFt9RLaTMRlg/8w49juAStsrBgp0Dp4OdxdVbRIeKhtCUvoi/RuAhO4g==
   dependencies:
-    depd "2.0.0"
+    depd "~1.1.2"
     inherits "2.0.4"
     setprototypeof "1.2.0"
-    statuses "2.0.1"
+    statuses ">= 1.5.0 < 2"
     toidentifier "1.0.1"
 
-http-errors@~1.6.2:
-  version "1.6.3"
-  resolved "https://registry.npmjs.org/http-errors/-/http-errors-1.6.3.tgz"
-  integrity sha512-lks+lVC8dgGyh97jxvxeYTWQFvh4uw4yC12gVl63Cg30sjPX4wuGcdkICVXDAESr6OJGjqGA8Iz5mkeN6zlD7A==
+http-errors@~2.0.0, http-errors@~2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/http-errors/-/http-errors-2.0.1.tgz"
+  integrity sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==
   dependencies:
-    depd "~1.1.2"
-    inherits "2.0.3"
-    setprototypeof "1.1.0"
-    statuses ">= 1.4.0 < 2"
+    depd "~2.0.0"
+    inherits "~2.0.4"
+    setprototypeof "~1.2.0"
+    statuses "~2.0.2"
+    toidentifier "~1.0.1"
 
 http-parser-js@>=0.5.1:
-  version "0.5.8"
-  resolved "https://registry.npmjs.org/http-parser-js/-/http-parser-js-0.5.8.tgz"
-  integrity sha512-SGeBX54F94Wgu5RH3X5jsDtf4eHyRogWX1XGT3b4HuW3tQPM4AaBzoUji/4AAJNXCEOWZ5O0DgZmJw1947gD5Q==
+  version "0.5.10"
+  resolved "https://registry.yarnpkg.com/http-parser-js/-/http-parser-js-0.5.10.tgz"
+  integrity sha512-Pysuw9XpUq5dVc/2SMHpuTY01RFl8fttgcyunjL7eEMhGM3cI4eOmiCycJDVCo/7O7ClfQD3SaI6ftDzqOXYMA==
 
-http-proxy-middleware@^2.0.3:
+http-proxy-middleware@^2.0.9:
   version "2.0.9"
-  resolved "https://registry.yarnpkg.com/http-proxy-middleware/-/http-proxy-middleware-2.0.9.tgz#e9e63d68afaa4eee3d147f39149ab84c0c2815ef"
+  resolved "https://registry.yarnpkg.com/http-proxy-middleware/-/http-proxy-middleware-2.0.9.tgz"
   integrity sha512-c1IyJYLYppU574+YI7R4QyX2ystMtVXZwIdzazUIPIJsHuWNd+mho2j+bKoHftndicGj9yh+xjd+l0yj7VeT1Q==
   dependencies:
     "@types/http-proxy" "^1.17.8"
@@ -5074,7 +5264,7 @@ http-proxy-middleware@^2.0.3:
 
 http-proxy@^1.18.1:
   version "1.18.1"
-  resolved "https://registry.npmjs.org/http-proxy/-/http-proxy-1.18.1.tgz"
+  resolved "https://registry.yarnpkg.com/http-proxy/-/http-proxy-1.18.1.tgz"
   integrity sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==
   dependencies:
     eventemitter3 "^4.0.0"
@@ -5083,7 +5273,7 @@ http-proxy@^1.18.1:
 
 http2-wrapper@^2.1.10:
   version "2.2.1"
-  resolved "https://registry.npmjs.org/http2-wrapper/-/http2-wrapper-2.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/http2-wrapper/-/http2-wrapper-2.2.1.tgz"
   integrity sha512-V5nVw1PAOgfI3Lmeaj2Exmeg7fenjhRUgz1lPSezy1CuhPYbgQtbQj4jZfEAEMlaL+vupsvhjqCyjzob0yxsmQ==
   dependencies:
     quick-lru "^5.1.1"
@@ -5091,134 +5281,109 @@ http2-wrapper@^2.1.10:
 
 human-signals@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/human-signals/-/human-signals-2.1.0.tgz"
   integrity sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==
 
-iconv-lite@0.4.24:
+hyperdyperid@^1.2.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/hyperdyperid/-/hyperdyperid-1.2.0.tgz"
+  integrity sha512-Y93lCzHYgGWdrJ66yIktxiaGULYc6oGiABxhcO5AufBeOyoIdZF7bIfLaOrbM0iGIOXQQgxxRrFEnb+Y6w1n4A==
+
+iconv-lite@~0.4.24:
   version "0.4.24"
-  resolved "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz"
+  resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.24.tgz"
   integrity sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==
   dependencies:
     safer-buffer ">= 2.1.2 < 3"
 
 icss-utils@^5.0.0, icss-utils@^5.1.0:
   version "5.1.0"
-  resolved "https://registry.npmjs.org/icss-utils/-/icss-utils-5.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/icss-utils/-/icss-utils-5.1.0.tgz"
   integrity sha512-soFhflCVWLfRNOPU3iv5Z9VUdT44xFRbzjLsEzSr5AQmgqPMTHdU3PMT1Cf1ssx8fLNJDA1juftYl+PUcv3MqA==
 
 ignore@^5.2.0, ignore@^5.2.4:
   version "5.3.2"
-  resolved "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz"
+  resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.3.2.tgz"
   integrity sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==
 
-image-size@^1.0.2:
-  version "1.2.0"
-  resolved "https://registry.npmjs.org/image-size/-/image-size-1.2.0.tgz"
-  integrity sha512-4S8fwbO6w3GeCVN6OPtA9I5IGKkcDMPcKndtUlpJuCwu7JLjtj7JZpwqLuyY2nrmQT3AWsCJLSKPsc2mPBSl3w==
-  dependencies:
-    queue "6.0.2"
-
-immer@^9.0.7:
-  version "9.0.21"
-  resolved "https://registry.npmjs.org/immer/-/immer-9.0.21.tgz"
-  integrity sha512-bc4NBHqOqSfRW7POMkHd51LvClaeMXpm8dx0e8oE2GORbq5aRK7Bxl4FyzVLdGtLmvLKL7BTDBG5ACQm4HWjTA==
+image-size@^2.0.2:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/image-size/-/image-size-2.0.2.tgz"
+  integrity sha512-IRqXKlaXwgSMAMtpNzZa1ZAe8m+Sa1770Dhk8VkSsP9LS+iHD62Zd8FQKs8fbPiagBE7BzoFX23cxFnwshpV6w==
 
-import-fresh@^3.1.0, import-fresh@^3.3.0:
-  version "3.3.0"
-  resolved "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz"
-  integrity sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==
+import-fresh@^3.3.0:
+  version "3.3.1"
+  resolved "https://registry.yarnpkg.com/import-fresh/-/import-fresh-3.3.1.tgz"
+  integrity sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==
   dependencies:
     parent-module "^1.0.0"
     resolve-from "^4.0.0"
 
 import-lazy@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/import-lazy/-/import-lazy-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/import-lazy/-/import-lazy-4.0.0.tgz"
   integrity sha512-rKtvo6a868b5Hu3heneU+L4yEQ4jYKLtjpnPeUdK7h0yzXGmyBTypknlkCvHFBqfX9YlorEiMM6Dnq/5atfHkw==
 
 imurmurhash@^0.1.4:
   version "0.1.4"
-  resolved "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz"
+  resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz"
   integrity sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==
 
 indent-string@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/indent-string/-/indent-string-4.0.0.tgz"
   integrity sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==
 
 infima@0.2.0-alpha.45:
   version "0.2.0-alpha.45"
-  resolved "https://registry.npmjs.org/infima/-/infima-0.2.0-alpha.45.tgz"
+  resolved "https://registry.yarnpkg.com/infima/-/infima-0.2.0-alpha.45.tgz"
   integrity sha512-uyH0zfr1erU1OohLk0fT4Rrb94AOhguWNOcD9uGrSpRvNB+6gZXUoJX5J0NtvzBO10YZ9PgvA4NFgt+fYg8ojw==
 
-inflight@^1.0.4:
-  version "1.0.6"
-  resolved "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz"
-  integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==
-  dependencies:
-    once "^1.3.0"
-    wrappy "1"
-
-inherits@2, inherits@2.0.4, inherits@^2.0.1, inherits@^2.0.3, inherits@~2.0.3:
+inherits@2.0.4, inherits@^2.0.1, inherits@^2.0.3, inherits@~2.0.3, inherits@~2.0.4:
   version "2.0.4"
-  resolved "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz"
   integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
 
-inherits@2.0.3:
-  version "2.0.3"
-  resolved "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz"
-  integrity sha512-x00IRNXNy63jwGkJmzPigoySHbaqpNuzKbBOmzK+g2OdZpQ9w+sxCN+VSB3ja7IAge2OP2qpfxTjeNcyjmW1uw==
-
 ini@2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/ini/-/ini-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/ini/-/ini-2.0.0.tgz"
   integrity sha512-7PnF4oN3CvZF23ADhA5wRaYEQpJ8qygSkbtTXWBeXWXmEVRXK+1ITciHWwHhsjv1TmW0MgacIv6hEi5pX5NQdA==
 
-ini@^1.3.4, ini@^1.3.5, ini@~1.3.0:
+ini@^1.3.4, ini@~1.3.0:
   version "1.3.8"
-  resolved "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz"
+  resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.8.tgz"
   integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==
 
-inline-style-parser@0.1.1:
-  version "0.1.1"
-  resolved "https://registry.npmjs.org/inline-style-parser/-/inline-style-parser-0.1.1.tgz"
-  integrity sha512-7NXolsK4CAS5+xvdj5OMMbI962hU/wvwoxk+LWR9Ek9bVtyuuYScDN6eS0rUm6TxApFpw7CX1o4uJzcd4AyD3Q==
-
-inline-style-parser@0.2.4:
-  version "0.2.4"
-  resolved "https://registry.npmjs.org/inline-style-parser/-/inline-style-parser-0.2.4.tgz"
-  integrity sha512-0aO8FkhNZlj/ZIbNi7Lxxr12obT7cL1moPfE4tg1LkX7LlLfC6DeX4l2ZEud1ukP9jNQyNnfzQVqwbwmAATY4Q==
-
-interpret@^1.0.0:
-  version "1.4.0"
-  resolved "https://registry.npmjs.org/interpret/-/interpret-1.4.0.tgz"
-  integrity sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==
+inline-style-parser@0.2.7:
+  version "0.2.7"
+  resolved "https://registry.yarnpkg.com/inline-style-parser/-/inline-style-parser-0.2.7.tgz"
+  integrity sha512-Nb2ctOyNR8DqQoR0OwRG95uNWIC0C1lCgf5Naz5H6Ji72KZ8OcFZLz2P5sNgwlyoJ8Yif11oMuYs5pBQa86csA==
 
 invariant@^2.2.4:
   version "2.2.4"
-  resolved "https://registry.npmjs.org/invariant/-/invariant-2.2.4.tgz"
+  resolved "https://registry.yarnpkg.com/invariant/-/invariant-2.2.4.tgz"
   integrity sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==
   dependencies:
     loose-envify "^1.0.0"
 
 ipaddr.js@1.9.1:
   version "1.9.1"
-  resolved "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz"
+  resolved "https://registry.yarnpkg.com/ipaddr.js/-/ipaddr.js-1.9.1.tgz"
   integrity sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==
 
-ipaddr.js@^2.0.1:
-  version "2.2.0"
-  resolved "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-2.2.0.tgz"
-  integrity sha512-Ag3wB2o37wslZS19hZqorUnrnzSkpOVy+IiiDEiTqNubEYpYuHWIf6K4psgN2ZWKExS4xhVCrRVfb/wfW8fWJA==
+ipaddr.js@^2.1.0:
+  version "2.3.0"
+  resolved "https://registry.yarnpkg.com/ipaddr.js/-/ipaddr.js-2.3.0.tgz"
+  integrity sha512-Zv/pA+ciVFbCSBBjGfaKUya/CcGmUHzTydLMaTwrUUEM2DIEO3iZvueGxmacvmN50fGpGVKeTXpb2LcYQxeVdg==
 
 is-alphabetical@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/is-alphabetical/-/is-alphabetical-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-alphabetical/-/is-alphabetical-2.0.1.tgz"
   integrity sha512-FWyyY60MeTNyeSRpkM2Iry0G9hpr7/9kD40mD/cGQEuilcZYS4okz8SN2Q6rLCJ8gbCt6fN+rC+6tMGS99LaxQ==
 
 is-alphanumerical@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/is-alphanumerical/-/is-alphanumerical-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-alphanumerical/-/is-alphanumerical-2.0.1.tgz"
   integrity sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw==
   dependencies:
     is-alphabetical "^2.0.0"
@@ -5226,177 +5391,191 @@ is-alphanumerical@^2.0.0:
 
 is-arrayish@^0.2.1:
   version "0.2.1"
-  resolved "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-arrayish/-/is-arrayish-0.2.1.tgz"
   integrity sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==
 
 is-binary-path@~2.1.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-2.1.0.tgz"
   integrity sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==
   dependencies:
     binary-extensions "^2.0.0"
 
 is-ci@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/is-ci/-/is-ci-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-ci/-/is-ci-3.0.1.tgz"
   integrity sha512-ZYvCgrefwqoQ6yTyYUbQu64HsITZ3NfKX1lzaEYdkTDcfKzzCI/wthRRYKkdjHKFVgNiXKAKm65Zo1pk2as/QQ==
   dependencies:
     ci-info "^3.2.0"
 
-is-core-module@^2.16.0:
+is-core-module@^2.16.1:
   version "2.16.1"
-  resolved "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.16.1.tgz"
   integrity sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==
   dependencies:
     hasown "^2.0.2"
 
 is-decimal@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/is-decimal/-/is-decimal-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-decimal/-/is-decimal-2.0.1.tgz"
   integrity sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A==
 
 is-docker@^2.0.0, is-docker@^2.1.1:
   version "2.2.1"
-  resolved "https://registry.npmjs.org/is-docker/-/is-docker-2.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-docker/-/is-docker-2.2.1.tgz"
   integrity sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==
 
+is-docker@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/is-docker/-/is-docker-3.0.0.tgz"
+  integrity sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ==
+
 is-extendable@^0.1.0:
   version "0.1.1"
-  resolved "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-0.1.1.tgz"
   integrity sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==
 
 is-extglob@^2.1.1:
   version "2.1.1"
-  resolved "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-2.1.1.tgz"
   integrity sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==
 
 is-fullwidth-code-point@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz"
   integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==
 
 is-glob@^4.0.1, is-glob@^4.0.3, is-glob@~4.0.1:
   version "4.0.3"
-  resolved "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.3.tgz"
   integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==
   dependencies:
     is-extglob "^2.1.1"
 
 is-hexadecimal@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/is-hexadecimal/-/is-hexadecimal-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-hexadecimal/-/is-hexadecimal-2.0.1.tgz"
   integrity sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg==
 
+is-inside-container@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/is-inside-container/-/is-inside-container-1.0.0.tgz"
+  integrity sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA==
+  dependencies:
+    is-docker "^3.0.0"
+
 is-installed-globally@^0.4.0:
   version "0.4.0"
-  resolved "https://registry.npmjs.org/is-installed-globally/-/is-installed-globally-0.4.0.tgz"
+  resolved "https://registry.yarnpkg.com/is-installed-globally/-/is-installed-globally-0.4.0.tgz"
   integrity sha512-iwGqO3J21aaSkC7jWnHP/difazwS7SFeIqxv6wEtLU8Y5KlzFTjyqcSIT0d8s4+dDhKytsk9PJZ2BkS5eZwQRQ==
   dependencies:
     global-dirs "^3.0.0"
     is-path-inside "^3.0.2"
 
+is-network-error@^1.0.0:
+  version "1.3.1"
+  resolved "https://registry.yarnpkg.com/is-network-error/-/is-network-error-1.3.1.tgz"
+  integrity sha512-6QCxa49rQbmUWLfk0nuGqzql9U8uaV2H6279bRErPBHe/109hCzsLUBUHfbEtvLIHBd6hyXbgedBSHevm43Edw==
+
 is-npm@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.npmjs.org/is-npm/-/is-npm-6.0.0.tgz"
-  integrity sha512-JEjxbSmtPSt1c8XTkVrlujcXdKV1/tvuQ7GwKcAlyiVLeYFQ2VHat8xfrDJsIkhCdF/tZ7CiIR3sy141c6+gPQ==
+  version "6.1.0"
+  resolved "https://registry.yarnpkg.com/is-npm/-/is-npm-6.1.0.tgz"
+  integrity sha512-O2z4/kNgyjhQwVR1Wpkbfc19JIhggF97NZNCpWTnjH7kVcZMUrnut9XSN7txI7VdyIYk5ZatOq3zvSuWpU8hoA==
 
 is-number@^7.0.0:
   version "7.0.0"
-  resolved "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz"
   integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==
 
 is-obj@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/is-obj/-/is-obj-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-obj/-/is-obj-1.0.1.tgz"
   integrity sha512-l4RyHgRqGN4Y3+9JHVrNqO+tN0rV5My76uW5/nuO4K1b6vw5G8d/cmFjP9tRfEsdhZNt0IFdZuK/c2Vr4Nb+Qg==
 
 is-obj@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/is-obj/-/is-obj-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/is-obj/-/is-obj-2.0.0.tgz"
   integrity sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==
 
-is-path-cwd@^2.2.0:
-  version "2.2.0"
-  resolved "https://registry.npmjs.org/is-path-cwd/-/is-path-cwd-2.2.0.tgz"
-  integrity sha512-w942bTcih8fdJPJmQHFzkS76NEP8Kzzvmw92cXsazb8intwLqPibPPdXf4ANdKV3rYMuuQYGIWtvz9JilB3NFQ==
-
 is-path-inside@^3.0.2:
   version "3.0.3"
-  resolved "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/is-path-inside/-/is-path-inside-3.0.3.tgz"
   integrity sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==
 
 is-plain-obj@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-3.0.0.tgz"
   integrity sha512-gwsOE28k+23GP1B6vFl1oVh/WOzmawBrKwo5Ev6wMKzPkaXaCDIQKzLnvsA42DRlbVTWorkgTKIviAKCWkfUwA==
 
 is-plain-obj@^4.0.0:
   version "4.1.0"
-  resolved "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-4.1.0.tgz"
   integrity sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==
 
 is-plain-object@^2.0.4:
   version "2.0.4"
-  resolved "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/is-plain-object/-/is-plain-object-2.0.4.tgz"
   integrity sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==
   dependencies:
     isobject "^3.0.1"
 
 is-regexp@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/is-regexp/-/is-regexp-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/is-regexp/-/is-regexp-1.0.0.tgz"
   integrity sha512-7zjFAPO4/gwyQAAgRRmqeEeyIICSdmCqa3tsVHMdBzaXXRiqopZL4Cyghg/XulGWrtABTpbnYYzzIRffLkP4oA==
 
-is-root@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/is-root/-/is-root-2.1.0.tgz"
-  integrity sha512-AGOriNp96vNBd3HtU+RzFEc75FfR5ymiYv8E553I71SCeXBiMsVDUtdio1OEFvrPyLIQ9tVR5RxXIFe5PUFjMg==
-
 is-stream@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-2.0.1.tgz"
   integrity sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==
 
 is-typedarray@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/is-typedarray/-/is-typedarray-1.0.0.tgz"
   integrity sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==
 
 is-wsl@^2.2.0:
   version "2.2.0"
-  resolved "https://registry.npmjs.org/is-wsl/-/is-wsl-2.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/is-wsl/-/is-wsl-2.2.0.tgz"
   integrity sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==
   dependencies:
     is-docker "^2.0.0"
 
+is-wsl@^3.1.0:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/is-wsl/-/is-wsl-3.1.1.tgz"
+  integrity sha512-e6rvdUCiQCAuumZslxRJWR/Doq4VpPR82kqclvcS0efgt430SlGIk05vdCN58+VrzgtIcfNODjozVielycD4Sw==
+  dependencies:
+    is-inside-container "^1.0.0"
+
 is-yarn-global@^0.4.0:
   version "0.4.1"
-  resolved "https://registry.npmjs.org/is-yarn-global/-/is-yarn-global-0.4.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-yarn-global/-/is-yarn-global-0.4.1.tgz"
   integrity sha512-/kppl+R+LO5VmhYSEWARUFjodS25D68gvj8W7z0I7OWhUla5xWu8KL6CtB2V0R6yqhnRgbcaREMr4EEM6htLPQ==
 
 isarray@0.0.1:
   version "0.0.1"
-  resolved "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/isarray/-/isarray-0.0.1.tgz"
   integrity sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==
 
 isarray@~1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz"
   integrity sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==
 
 isexe@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz"
   integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==
 
 isobject@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/isobject/-/isobject-3.0.1.tgz"
   integrity sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==
 
 jest-util@^29.7.0:
   version "29.7.0"
-  resolved "https://registry.npmjs.org/jest-util/-/jest-util-29.7.0.tgz"
+  resolved "https://registry.yarnpkg.com/jest-util/-/jest-util-29.7.0.tgz"
   integrity sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA==
   dependencies:
     "@jest/types" "^29.6.3"
@@ -5408,7 +5587,7 @@ jest-util@^29.7.0:
 
 jest-worker@^27.4.5:
   version "27.5.1"
-  resolved "https://registry.npmjs.org/jest-worker/-/jest-worker-27.5.1.tgz"
+  resolved "https://registry.yarnpkg.com/jest-worker/-/jest-worker-27.5.1.tgz"
   integrity sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg==
   dependencies:
     "@types/node" "*"
@@ -5417,7 +5596,7 @@ jest-worker@^27.4.5:
 
 jest-worker@^29.4.3:
   version "29.7.0"
-  resolved "https://registry.npmjs.org/jest-worker/-/jest-worker-29.7.0.tgz"
+  resolved "https://registry.yarnpkg.com/jest-worker/-/jest-worker-29.7.0.tgz"
   integrity sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw==
   dependencies:
     "@types/node" "*"
@@ -5427,12 +5606,12 @@ jest-worker@^29.4.3:
 
 jiti@^1.20.0:
   version "1.21.7"
-  resolved "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz"
+  resolved "https://registry.yarnpkg.com/jiti/-/jiti-1.21.7.tgz"
   integrity sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==
 
 joi@^17.9.2:
   version "17.13.3"
-  resolved "https://registry.npmjs.org/joi/-/joi-17.13.3.tgz"
+  resolved "https://registry.yarnpkg.com/joi/-/joi-17.13.3.tgz"
   integrity sha512-otDA4ldcIx+ZXsKHWmp0YizCweVRZG96J10b0FevjfuncLO1oX59THoAmHkNubYJ+9gWsYsp5k8v4ib6oDv1fA==
   dependencies:
     "@hapi/hoek" "^9.3.0"
@@ -5443,63 +5622,58 @@ joi@^17.9.2:
 
 "js-tokens@^3.0.0 || ^4.0.0", js-tokens@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz"
   integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==
 
 js-yaml@^3.13.1:
-  version "3.14.1"
-  resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz"
-  integrity sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==
+  version "3.14.2"
+  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.14.2.tgz"
+  integrity sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==
   dependencies:
     argparse "^1.0.7"
     esprima "^4.0.0"
 
 js-yaml@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz"
-  integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-4.1.1.tgz"
+  integrity sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==
   dependencies:
     argparse "^2.0.1"
 
-jsesc@^3.0.2:
+jsesc@^3.0.2, jsesc@~3.1.0:
   version "3.1.0"
-  resolved "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-3.1.0.tgz"
   integrity sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==
 
-jsesc@~3.0.2:
-  version "3.0.2"
-  resolved "https://registry.npmjs.org/jsesc/-/jsesc-3.0.2.tgz"
-  integrity sha512-xKqzzWXDttJuOcawBt4KnKHHIf5oQ/Cxax+0PWFG+DFDgHNAdi+TXECADI+RYiFUMmx8792xsMbbgXj4CwnP4g==
-
 json-buffer@3.0.1:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/json-buffer/-/json-buffer-3.0.1.tgz"
   integrity sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==
 
-json-parse-even-better-errors@^2.3.0, json-parse-even-better-errors@^2.3.1:
+json-parse-even-better-errors@^2.3.0:
   version "2.3.1"
-  resolved "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz"
   integrity sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==
 
 json-schema-traverse@^0.4.1:
   version "0.4.1"
-  resolved "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz"
+  resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz"
   integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==
 
 json-schema-traverse@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz"
   integrity sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==
 
 json5@^2.1.2, json5@^2.2.3:
   version "2.2.3"
-  resolved "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz"
+  resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.3.tgz"
   integrity sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==
 
 jsonfile@^6.0.1:
-  version "6.1.0"
-  resolved "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz"
-  integrity sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==
+  version "6.2.1"
+  resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-6.2.1.tgz"
+  integrity sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==
   dependencies:
     universalify "^2.0.0"
   optionalDependencies:
@@ -5507,172 +5681,146 @@ jsonfile@^6.0.1:
 
 keyv@^4.5.3:
   version "4.5.4"
-  resolved "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz"
+  resolved "https://registry.yarnpkg.com/keyv/-/keyv-4.5.4.tgz"
   integrity sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==
   dependencies:
     json-buffer "3.0.1"
 
 kind-of@^6.0.0, kind-of@^6.0.2:
   version "6.0.3"
-  resolved "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-6.0.3.tgz"
   integrity sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==
 
 kleur@^3.0.3:
   version "3.0.3"
-  resolved "https://registry.npmjs.org/kleur/-/kleur-3.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/kleur/-/kleur-3.0.3.tgz"
   integrity sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==
 
 latest-version@^7.0.0:
   version "7.0.0"
-  resolved "https://registry.npmjs.org/latest-version/-/latest-version-7.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/latest-version/-/latest-version-7.0.0.tgz"
   integrity sha512-KvNT4XqAMzdcL6ka6Tl3i2lYeFDgXNCuIX+xNx6ZMVR1dFq+idXd9FLKNMOIx0t9mJ9/HudyX4oZWXZQ0UJHeg==
   dependencies:
     package-json "^8.1.0"
 
-launch-editor@^2.6.0:
-  version "2.9.1"
-  resolved "https://registry.npmjs.org/launch-editor/-/launch-editor-2.9.1.tgz"
-  integrity sha512-Gcnl4Bd+hRO9P9icCP/RVVT2o8SFlPXofuCxvA2SaZuH45whSvf5p8x5oih5ftLiVhEI4sp5xDY+R+b3zJBh5w==
+launch-editor@^2.6.1:
+  version "2.13.2"
+  resolved "https://registry.yarnpkg.com/launch-editor/-/launch-editor-2.13.2.tgz"
+  integrity sha512-4VVDnbOpLXy/s8rdRCSXb+zfMeFR0WlJWpET1iA9CQdlZDfwyLjUuGQzXU4VeOoey6AicSAluWan7Etga6Kcmg==
   dependencies:
-    picocolors "^1.0.0"
-    shell-quote "^1.8.1"
+    picocolors "^1.1.1"
+    shell-quote "^1.8.3"
 
 leven@^3.1.0:
   version "3.1.0"
-  resolved "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/leven/-/leven-3.1.0.tgz"
   integrity sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==
 
 lilconfig@^3.1.1:
   version "3.1.3"
-  resolved "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz"
+  resolved "https://registry.yarnpkg.com/lilconfig/-/lilconfig-3.1.3.tgz"
   integrity sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==
 
 lines-and-columns@^1.1.6:
   version "1.2.4"
-  resolved "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz"
+  resolved "https://registry.yarnpkg.com/lines-and-columns/-/lines-and-columns-1.2.4.tgz"
   integrity sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==
 
-loader-runner@^4.2.0:
-  version "4.3.0"
-  resolved "https://registry.npmjs.org/loader-runner/-/loader-runner-4.3.0.tgz"
-  integrity sha512-3R/1M+yS3j5ou80Me59j7F9IMs4PXs3VqRrm0TU3AbKPxlmpoY1TNscJV/oGJXo8qCatFGTfDbY6W6ipGOYXfg==
+loader-runner@^4.3.1:
+  version "4.3.2"
+  resolved "https://registry.yarnpkg.com/loader-runner/-/loader-runner-4.3.2.tgz"
+  integrity sha512-DFEqQ3ihfS9blba08cLfYf1NRAIEm+dDjic073DRDc3/JspI/8wYmtDsHwd3+4hwvdxSK7PGaElfTmm0awWJ4w==
 
 loader-utils@^2.0.0:
   version "2.0.4"
-  resolved "https://registry.npmjs.org/loader-utils/-/loader-utils-2.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/loader-utils/-/loader-utils-2.0.4.tgz"
   integrity sha512-xXqpXoINfFhgua9xiqD8fPFHgkoq1mmmpE92WlDbm9rNRd/EbRb+Gqf908T2DMfuHjjJlksiK2RbHVOdD/MqSw==
   dependencies:
     big.js "^5.2.2"
     emojis-list "^3.0.0"
     json5 "^2.1.2"
 
-loader-utils@^3.2.0:
-  version "3.3.1"
-  resolved "https://registry.npmjs.org/loader-utils/-/loader-utils-3.3.1.tgz"
-  integrity sha512-FMJTLMXfCLMLfJxcX9PFqX5qD88Z5MRGaZCVzfuqeZSPsyiBzs+pahDQjbIWz2QIzPZz0NX9Zy4FX3lmK6YHIg==
-
-locate-path@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz"
-  integrity sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==
-  dependencies:
-    p-locate "^3.0.0"
-    path-exists "^3.0.0"
-
-locate-path@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz"
-  integrity sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==
-  dependencies:
-    p-locate "^5.0.0"
-
 locate-path@^7.1.0:
   version "7.2.0"
-  resolved "https://registry.npmjs.org/locate-path/-/locate-path-7.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-7.2.0.tgz"
   integrity sha512-gvVijfZvn7R+2qyPX8mAuKcFGDf6Nc61GdvGafQsHL0sBIxfKzA+usWn4GFC/bk+QdwPUD4kWFJLhElipq+0VA==
   dependencies:
     p-locate "^6.0.0"
 
 lodash.debounce@^4.0.8:
   version "4.0.8"
-  resolved "https://registry.npmjs.org/lodash.debounce/-/lodash.debounce-4.0.8.tgz"
+  resolved "https://registry.yarnpkg.com/lodash.debounce/-/lodash.debounce-4.0.8.tgz"
   integrity sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==
 
 lodash.memoize@^4.1.2:
   version "4.1.2"
-  resolved "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/lodash.memoize/-/lodash.memoize-4.1.2.tgz"
   integrity sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==
 
 lodash.uniq@^4.5.0:
   version "4.5.0"
-  resolved "https://registry.npmjs.org/lodash.uniq/-/lodash.uniq-4.5.0.tgz"
+  resolved "https://registry.yarnpkg.com/lodash.uniq/-/lodash.uniq-4.5.0.tgz"
   integrity sha512-xfBaXQd9ryd9dlSDvnvI0lvxfLJlYAZzXomUYzLKtUeOQvOP5piqAWuGtrhWeqaXK9hhoM/iyJc5AV+XfsX3HQ==
 
 lodash@^4.17.20, lodash@^4.17.21:
-  version "4.17.21"
-  resolved "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz"
-  integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
+  version "4.18.1"
+  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.18.1.tgz"
+  integrity sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==
 
 longest-streak@^3.0.0:
   version "3.1.0"
-  resolved "https://registry.npmjs.org/longest-streak/-/longest-streak-3.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/longest-streak/-/longest-streak-3.1.0.tgz"
   integrity sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==
 
 loose-envify@^1.0.0, loose-envify@^1.1.0, loose-envify@^1.2.0, loose-envify@^1.3.1, loose-envify@^1.4.0:
   version "1.4.0"
-  resolved "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz"
+  resolved "https://registry.yarnpkg.com/loose-envify/-/loose-envify-1.4.0.tgz"
   integrity sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==
   dependencies:
     js-tokens "^3.0.0 || ^4.0.0"
 
 lower-case@^2.0.2:
   version "2.0.2"
-  resolved "https://registry.npmjs.org/lower-case/-/lower-case-2.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/lower-case/-/lower-case-2.0.2.tgz"
   integrity sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==
   dependencies:
     tslib "^2.0.3"
 
 lowercase-keys@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/lowercase-keys/-/lowercase-keys-3.0.0.tgz"
   integrity sha512-ozCC6gdQ+glXOQsveKD0YsDy8DSQFjDTz4zyzEHNV5+JP5D62LmfDZ6o1cycFx9ouG940M5dE8C8CTewdj2YWQ==
 
 lru-cache@^5.1.1:
   version "5.1.1"
-  resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-5.1.1.tgz"
   integrity sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==
   dependencies:
     yallist "^3.0.2"
 
 markdown-extensions@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/markdown-extensions/-/markdown-extensions-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/markdown-extensions/-/markdown-extensions-2.0.0.tgz"
   integrity sha512-o5vL7aDWatOTX8LzaS1WMoaoxIiLRQJuIKKe2wAw6IeULDHaqbiqiggmx+pKvZDb1Sj+pE46Sn1T7lCqfFtg1Q==
 
-markdown-table@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/markdown-table/-/markdown-table-2.0.0.tgz"
-  integrity sha512-Ezda85ToJUBhM6WGaG6veasyym+Tbs3cMAw/ZhOPqXiYsr0jgocBV3j3nx+4lk47plLlIqjwuTm/ywVI+zjJ/A==
-  dependencies:
-    repeat-string "^1.0.0"
-
 markdown-table@^3.0.0:
   version "3.0.4"
-  resolved "https://registry.npmjs.org/markdown-table/-/markdown-table-3.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/markdown-table/-/markdown-table-3.0.4.tgz"
   integrity sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw==
 
 math-intrinsics@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/math-intrinsics/-/math-intrinsics-1.1.0.tgz"
   integrity sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==
 
 mdast-util-directive@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/mdast-util-directive/-/mdast-util-directive-3.0.0.tgz"
-  integrity sha512-JUpYOqKI4mM3sZcNxmF/ox04XYFFkNwr0CFlrQIkCwbvH0xzMCqkMqAde9wRd80VAhaUrwFwKm2nxretdT1h7Q==
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/mdast-util-directive/-/mdast-util-directive-3.1.0.tgz"
+  integrity sha512-I3fNFt+DHmpWCYAT7quoM6lHf9wuqtI+oCOfvILnoicNIqjh5E3dEJWiXuYME2gNe8vl1iMQwyUHa7bgFmak6Q==
   dependencies:
     "@types/mdast" "^4.0.0"
     "@types/unist" "^3.0.0"
+    ccount "^2.0.0"
     devlop "^1.0.0"
     mdast-util-from-markdown "^2.0.0"
     mdast-util-to-markdown "^2.0.0"
@@ -5681,9 +5829,9 @@ mdast-util-directive@^3.0.0:
     unist-util-visit-parents "^6.0.0"
 
 mdast-util-find-and-replace@^3.0.0, mdast-util-find-and-replace@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.npmjs.org/mdast-util-find-and-replace/-/mdast-util-find-and-replace-3.0.1.tgz"
-  integrity sha512-SG21kZHGC3XRTSUhtofZkBzZTJNM5ecCi0SK2IMKmSXR8vO3peL+kb1O0z7Zl83jKtutG4k5Wv/W7V3/YHvzPA==
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/mdast-util-find-and-replace/-/mdast-util-find-and-replace-3.0.2.tgz"
+  integrity sha512-Tmd1Vg/m3Xz43afeNxDIhWRtFZgM2VLyaf4vSTYwudTyeuTneoL3qtWMA5jeLyz/O1vDJmmV4QuScFCA2tBPwg==
   dependencies:
     "@types/mdast" "^4.0.0"
     escape-string-regexp "^5.0.0"
@@ -5691,9 +5839,9 @@ mdast-util-find-and-replace@^3.0.0, mdast-util-find-and-replace@^3.0.1:
     unist-util-visit-parents "^6.0.0"
 
 mdast-util-from-markdown@^2.0.0:
-  version "2.0.2"
-  resolved "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-2.0.2.tgz"
-  integrity sha512-uZhTV/8NBuw0WHkPTrCqDOl0zVe1BIng5ZtHoDk49ME1qqcjYmmLmOf0gELgcRMxN4w2iuIeVso5/6QymSrgmA==
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/mdast-util-from-markdown/-/mdast-util-from-markdown-2.0.3.tgz"
+  integrity sha512-W4mAWTvSlKvf8L6J+VN9yLSqQ9AOAAvHuoDAmPkz4dHf553m5gVj2ejadHJhoJmcmxEnOv6Pa8XJhpxE93kb8Q==
   dependencies:
     "@types/mdast" "^4.0.0"
     "@types/unist" "^3.0.0"
@@ -5710,7 +5858,7 @@ mdast-util-from-markdown@^2.0.0:
 
 mdast-util-frontmatter@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/mdast-util-frontmatter/-/mdast-util-frontmatter-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-frontmatter/-/mdast-util-frontmatter-2.0.1.tgz"
   integrity sha512-LRqI9+wdgC25P0URIJY9vwocIzCcksduHQ9OF2joxQoyTNVduwLAFUzjoopuRJbJAReaKrNQKAZKL3uCMugWJA==
   dependencies:
     "@types/mdast" "^4.0.0"
@@ -5722,7 +5870,7 @@ mdast-util-frontmatter@^2.0.0:
 
 mdast-util-gfm-autolink-literal@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/mdast-util-gfm-autolink-literal/-/mdast-util-gfm-autolink-literal-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-gfm-autolink-literal/-/mdast-util-gfm-autolink-literal-2.0.1.tgz"
   integrity sha512-5HVP2MKaP6L+G6YaxPNjuL0BPrq9orG3TsrZ9YXbA3vDw/ACI4MEsnoDpn6ZNm7GnZgtAcONJyPhOP8tNJQavQ==
   dependencies:
     "@types/mdast" "^4.0.0"
@@ -5732,9 +5880,9 @@ mdast-util-gfm-autolink-literal@^2.0.0:
     micromark-util-character "^2.0.0"
 
 mdast-util-gfm-footnote@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/mdast-util-gfm-footnote/-/mdast-util-gfm-footnote-2.0.0.tgz"
-  integrity sha512-5jOT2boTSVkMnQ7LTrd6n/18kqwjmuYqo7JUPe+tRCY6O7dAuTFMtTPauYYrMPpox9hlN0uOx/FL8XvEfG9/mQ==
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/mdast-util-gfm-footnote/-/mdast-util-gfm-footnote-2.1.0.tgz"
+  integrity sha512-sqpDWlsHn7Ac9GNZQMeUzPQSMzR6Wv0WKRNvQRg0KqHh02fpTz69Qc1QSseNX29bhz1ROIyNyxExfawVKTm1GQ==
   dependencies:
     "@types/mdast" "^4.0.0"
     devlop "^1.1.0"
@@ -5744,7 +5892,7 @@ mdast-util-gfm-footnote@^2.0.0:
 
 mdast-util-gfm-strikethrough@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/mdast-util-gfm-strikethrough/-/mdast-util-gfm-strikethrough-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-gfm-strikethrough/-/mdast-util-gfm-strikethrough-2.0.0.tgz"
   integrity sha512-mKKb915TF+OC5ptj5bJ7WFRPdYtuHv0yTRxK2tJvi+BDqbkiG7h7u/9SI89nRAYcmap2xHQL9D+QG/6wSrTtXg==
   dependencies:
     "@types/mdast" "^4.0.0"
@@ -5753,7 +5901,7 @@ mdast-util-gfm-strikethrough@^2.0.0:
 
 mdast-util-gfm-table@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/mdast-util-gfm-table/-/mdast-util-gfm-table-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-gfm-table/-/mdast-util-gfm-table-2.0.0.tgz"
   integrity sha512-78UEvebzz/rJIxLvE7ZtDd/vIQ0RHv+3Mh5DR96p7cS7HsBhYIICDBCu8csTNWNO6tBWfqXPWekRuj2FNOGOZg==
   dependencies:
     "@types/mdast" "^4.0.0"
@@ -5764,7 +5912,7 @@ mdast-util-gfm-table@^2.0.0:
 
 mdast-util-gfm-task-list-item@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/mdast-util-gfm-task-list-item/-/mdast-util-gfm-task-list-item-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-gfm-task-list-item/-/mdast-util-gfm-task-list-item-2.0.0.tgz"
   integrity sha512-IrtvNvjxC1o06taBAVJznEnkiHxLFTzgonUdy8hzFVeDun0uTjxxrRGVaNFqkU1wJR3RBPEfsxmU6jDWPofrTQ==
   dependencies:
     "@types/mdast" "^4.0.0"
@@ -5773,9 +5921,9 @@ mdast-util-gfm-task-list-item@^2.0.0:
     mdast-util-to-markdown "^2.0.0"
 
 mdast-util-gfm@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/mdast-util-gfm/-/mdast-util-gfm-3.0.0.tgz"
-  integrity sha512-dgQEX5Amaq+DuUqf26jJqSK9qgixgd6rYDHAv4aTBuA92cTknZlKpPfa86Z/s8Dj8xsAQpFfBmPUHWJBWqS4Bw==
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/mdast-util-gfm/-/mdast-util-gfm-3.1.0.tgz"
+  integrity sha512-0ulfdQOM3ysHhCJ1p06l0b0VKlhU0wuQs3thxZQagjcjPrlFRqY215uZGHHJan9GEAXd9MbfPjFJz+qMkVR6zQ==
   dependencies:
     mdast-util-from-markdown "^2.0.0"
     mdast-util-gfm-autolink-literal "^2.0.0"
@@ -5787,7 +5935,7 @@ mdast-util-gfm@^3.0.0:
 
 mdast-util-mdx-expression@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/mdast-util-mdx-expression/-/mdast-util-mdx-expression-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-mdx-expression/-/mdast-util-mdx-expression-2.0.1.tgz"
   integrity sha512-J6f+9hUp+ldTZqKRSg7Vw5V6MqjATc+3E4gf3CFNcuZNWD8XdyI6zQ8GqH7f8169MM6P7hMBRDVGnn7oHB9kXQ==
   dependencies:
     "@types/estree-jsx" "^1.0.0"
@@ -5798,9 +5946,9 @@ mdast-util-mdx-expression@^2.0.0:
     mdast-util-to-markdown "^2.0.0"
 
 mdast-util-mdx-jsx@^3.0.0:
-  version "3.1.3"
-  resolved "https://registry.npmjs.org/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.1.3.tgz"
-  integrity sha512-bfOjvNt+1AcbPLTFMFWY149nJz0OjmewJs3LQQ5pIyVGxP4CdOqNVJL6kTaM5c68p8q82Xv3nCyFfUnuEcH3UQ==
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.2.0.tgz"
+  integrity sha512-lj/z8v0r6ZtsN/cGNNtemmmfoLAFZnjMbNyLzBafjzikOM+glrjNHPlf6lQDOTccj9n5b0PPihEBbhneMyGs1Q==
   dependencies:
     "@types/estree-jsx" "^1.0.0"
     "@types/hast" "^3.0.0"
@@ -5817,7 +5965,7 @@ mdast-util-mdx-jsx@^3.0.0:
 
 mdast-util-mdx@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/mdast-util-mdx/-/mdast-util-mdx-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-mdx/-/mdast-util-mdx-3.0.0.tgz"
   integrity sha512-JfbYLAW7XnYTTbUsmpu0kdBUVe+yKVJZBItEjwyYJiDJuZ9w4eeaqks4HQO+R7objWgS2ymV60GYpI14Ug554w==
   dependencies:
     mdast-util-from-markdown "^2.0.0"
@@ -5828,7 +5976,7 @@ mdast-util-mdx@^3.0.0:
 
 mdast-util-mdxjs-esm@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/mdast-util-mdxjs-esm/-/mdast-util-mdxjs-esm-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-mdxjs-esm/-/mdast-util-mdxjs-esm-2.0.1.tgz"
   integrity sha512-EcmOpxsZ96CvlP03NghtH1EsLtr0n9Tm4lPUJUBccV9RwUOneqSycg19n5HGzCf+10LozMRSObtVr3ee1WoHtg==
   dependencies:
     "@types/estree-jsx" "^1.0.0"
@@ -5840,16 +5988,16 @@ mdast-util-mdxjs-esm@^2.0.0:
 
 mdast-util-phrasing@^4.0.0:
   version "4.1.0"
-  resolved "https://registry.npmjs.org/mdast-util-phrasing/-/mdast-util-phrasing-4.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-phrasing/-/mdast-util-phrasing-4.1.0.tgz"
   integrity sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w==
   dependencies:
     "@types/mdast" "^4.0.0"
     unist-util-is "^6.0.0"
 
 mdast-util-to-hast@^13.0.0:
-  version "13.2.0"
-  resolved "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-13.2.0.tgz"
-  integrity sha512-QGYKEuUsYT9ykKBCMOEDLsU5JRObWQusAolFMeko/tYPufNkRffBAQjIE+99jbA87xv6FgmjLtwjh9wBWajwAA==
+  version "13.2.1"
+  resolved "https://registry.yarnpkg.com/mdast-util-to-hast/-/mdast-util-to-hast-13.2.1.tgz"
+  integrity sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA==
   dependencies:
     "@types/hast" "^3.0.0"
     "@types/mdast" "^4.0.0"
@@ -5863,7 +6011,7 @@ mdast-util-to-hast@^13.0.0:
 
 mdast-util-to-markdown@^2.0.0:
   version "2.1.2"
-  resolved "https://registry.npmjs.org/mdast-util-to-markdown/-/mdast-util-to-markdown-2.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-to-markdown/-/mdast-util-to-markdown-2.1.2.tgz"
   integrity sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA==
   dependencies:
     "@types/mdast" "^4.0.0"
@@ -5878,57 +6026,70 @@ mdast-util-to-markdown@^2.0.0:
 
 mdast-util-to-string@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-to-string/-/mdast-util-to-string-4.0.0.tgz"
   integrity sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg==
   dependencies:
     "@types/mdast" "^4.0.0"
 
 mdn-data@2.0.28:
   version "2.0.28"
-  resolved "https://registry.npmjs.org/mdn-data/-/mdn-data-2.0.28.tgz"
+  resolved "https://registry.yarnpkg.com/mdn-data/-/mdn-data-2.0.28.tgz"
   integrity sha512-aylIc7Z9y4yzHYAJNuESG3hfhC+0Ibp/MAMiaOZgNv4pmEdFyfZhhhny4MNiAfWdBQ1RQ2mfDWmM1x8SvGyp8g==
 
 mdn-data@2.0.30:
   version "2.0.30"
-  resolved "https://registry.npmjs.org/mdn-data/-/mdn-data-2.0.30.tgz"
+  resolved "https://registry.yarnpkg.com/mdn-data/-/mdn-data-2.0.30.tgz"
   integrity sha512-GaqWWShW4kv/G9IEucWScBx9G1/vsFZZJUO+tD26M8J8z3Kw5RDQjaoZe03YAClgeS/SWPOcb4nkFBTEi5DUEA==
 
 media-typer@0.3.0:
   version "0.3.0"
-  resolved "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/media-typer/-/media-typer-0.3.0.tgz"
   integrity sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==
 
-memfs@^3.1.2, memfs@^3.4.3:
-  version "3.5.3"
-  resolved "https://registry.npmjs.org/memfs/-/memfs-3.5.3.tgz"
-  integrity sha512-UERzLsxzllchadvbPs5aolHh65ISpKpM+ccLbOJ8/vvpBKmAWf+la7dXFy7Mr0ySHbdHrFv5kGFCUHHe6GFEmw==
-  dependencies:
-    fs-monkey "^1.0.4"
+memfs@^4.43.1:
+  version "4.57.2"
+  resolved "https://registry.yarnpkg.com/memfs/-/memfs-4.57.2.tgz"
+  integrity sha512-2nWzSsJzrukurSDna4Z0WywuScK4Id3tSKejgu74u8KCdW4uNrseKRSIDg75C6Yw5ZRqBe0F0EtMNlTbUq8bAQ==
+  dependencies:
+    "@jsonjoy.com/fs-core" "4.57.2"
+    "@jsonjoy.com/fs-fsa" "4.57.2"
+    "@jsonjoy.com/fs-node" "4.57.2"
+    "@jsonjoy.com/fs-node-builtins" "4.57.2"
+    "@jsonjoy.com/fs-node-to-fsa" "4.57.2"
+    "@jsonjoy.com/fs-node-utils" "4.57.2"
+    "@jsonjoy.com/fs-print" "4.57.2"
+    "@jsonjoy.com/fs-snapshot" "4.57.2"
+    "@jsonjoy.com/json-pack" "^1.11.0"
+    "@jsonjoy.com/util" "^1.9.0"
+    glob-to-regex.js "^1.0.1"
+    thingies "^2.5.0"
+    tree-dump "^1.0.3"
+    tslib "^2.0.0"
 
 merge-descriptors@1.0.3:
   version "1.0.3"
-  resolved "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/merge-descriptors/-/merge-descriptors-1.0.3.tgz"
   integrity sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==
 
 merge-stream@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/merge-stream/-/merge-stream-2.0.0.tgz"
   integrity sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==
 
 merge2@^1.3.0, merge2@^1.4.1:
   version "1.4.1"
-  resolved "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz"
+  resolved "https://registry.yarnpkg.com/merge2/-/merge2-1.4.1.tgz"
   integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==
 
 methods@~1.1.2:
   version "1.1.2"
-  resolved "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/methods/-/methods-1.1.2.tgz"
   integrity sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==
 
 micromark-core-commonmark@^2.0.0:
-  version "2.0.2"
-  resolved "https://registry.npmjs.org/micromark-core-commonmark/-/micromark-core-commonmark-2.0.2.tgz"
-  integrity sha512-FKjQKbxd1cibWMM1P9N+H8TwlgGgSkWZMmfuVucLCHaYqeSvJ0hFeHsIa65pA2nYbes0f8LDHPMrd9X7Ujxg9w==
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/micromark-core-commonmark/-/micromark-core-commonmark-2.0.3.tgz"
+  integrity sha512-RDBrHEMSxVFLg6xvnXmb1Ayr2WzLAWjeSATAoxwKYJV94TeNavgoIdA0a9ytzDSVzBy2YKFK+emCPOEibLeCrg==
   dependencies:
     decode-named-character-reference "^1.0.0"
     devlop "^1.0.0"
@@ -5949,7 +6110,7 @@ micromark-core-commonmark@^2.0.0:
 
 micromark-extension-directive@^3.0.0:
   version "3.0.2"
-  resolved "https://registry.npmjs.org/micromark-extension-directive/-/micromark-extension-directive-3.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-directive/-/micromark-extension-directive-3.0.2.tgz"
   integrity sha512-wjcXHgk+PPdmvR58Le9d7zQYWy+vKEU9Se44p2CrCDPiLr2FMyiT4Fyb5UFKFC66wGB3kPlgD7q3TnoqPS7SZA==
   dependencies:
     devlop "^1.0.0"
@@ -5962,7 +6123,7 @@ micromark-extension-directive@^3.0.0:
 
 micromark-extension-frontmatter@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/micromark-extension-frontmatter/-/micromark-extension-frontmatter-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-frontmatter/-/micromark-extension-frontmatter-2.0.0.tgz"
   integrity sha512-C4AkuM3dA58cgZha7zVnuVxBhDsbttIMiytjgsM2XbHAB2faRVaHRle40558FBN+DJcrLNCoqG5mlrpdU4cRtg==
   dependencies:
     fault "^2.0.0"
@@ -5972,7 +6133,7 @@ micromark-extension-frontmatter@^2.0.0:
 
 micromark-extension-gfm-autolink-literal@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/micromark-extension-gfm-autolink-literal/-/micromark-extension-gfm-autolink-literal-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-gfm-autolink-literal/-/micromark-extension-gfm-autolink-literal-2.1.0.tgz"
   integrity sha512-oOg7knzhicgQ3t4QCjCWgTmfNhvQbDDnJeVu9v81r7NltNCVmhPy1fJRX27pISafdjL+SVc4d3l48Gb6pbRypw==
   dependencies:
     micromark-util-character "^2.0.0"
@@ -5982,7 +6143,7 @@ micromark-extension-gfm-autolink-literal@^2.0.0:
 
 micromark-extension-gfm-footnote@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/micromark-extension-gfm-footnote/-/micromark-extension-gfm-footnote-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-gfm-footnote/-/micromark-extension-gfm-footnote-2.1.0.tgz"
   integrity sha512-/yPhxI1ntnDNsiHtzLKYnE3vf9JZ6cAisqVDauhp4CEHxlb4uoOTxOCJ+9s51bIB8U1N1FJ1RXOKTIlD5B/gqw==
   dependencies:
     devlop "^1.0.0"
@@ -5996,7 +6157,7 @@ micromark-extension-gfm-footnote@^2.0.0:
 
 micromark-extension-gfm-strikethrough@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/micromark-extension-gfm-strikethrough/-/micromark-extension-gfm-strikethrough-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-gfm-strikethrough/-/micromark-extension-gfm-strikethrough-2.1.0.tgz"
   integrity sha512-ADVjpOOkjz1hhkZLlBiYA9cR2Anf8F4HqZUO6e5eDcPQd0Txw5fxLzzxnEkSkfnD0wziSGiv7sYhk/ktvbf1uw==
   dependencies:
     devlop "^1.0.0"
@@ -6007,9 +6168,9 @@ micromark-extension-gfm-strikethrough@^2.0.0:
     micromark-util-types "^2.0.0"
 
 micromark-extension-gfm-table@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/micromark-extension-gfm-table/-/micromark-extension-gfm-table-2.1.0.tgz"
-  integrity sha512-Ub2ncQv+fwD70/l4ou27b4YzfNaCJOvyX4HxXU15m7mpYY+rjuWzsLIPZHJL253Z643RpbcP1oeIJlQ/SKW67g==
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/micromark-extension-gfm-table/-/micromark-extension-gfm-table-2.1.1.tgz"
+  integrity sha512-t2OU/dXXioARrC6yWfJ4hqB7rct14e8f7m0cbI5hUmDyyIlwv5vEtooptH8INkbLzOatzKuVbQmAYcbWoyz6Dg==
   dependencies:
     devlop "^1.0.0"
     micromark-factory-space "^2.0.0"
@@ -6019,14 +6180,14 @@ micromark-extension-gfm-table@^2.0.0:
 
 micromark-extension-gfm-tagfilter@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/micromark-extension-gfm-tagfilter/-/micromark-extension-gfm-tagfilter-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-gfm-tagfilter/-/micromark-extension-gfm-tagfilter-2.0.0.tgz"
   integrity sha512-xHlTOmuCSotIA8TW1mDIM6X2O1SiX5P9IuDtqGonFhEK0qgRI4yeC6vMxEV2dgyr2TiD+2PQ10o+cOhdVAcwfg==
   dependencies:
     micromark-util-types "^2.0.0"
 
 micromark-extension-gfm-task-list-item@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/micromark-extension-gfm-task-list-item/-/micromark-extension-gfm-task-list-item-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-gfm-task-list-item/-/micromark-extension-gfm-task-list-item-2.1.0.tgz"
   integrity sha512-qIBZhqxqI6fjLDYFTBIa4eivDMnP+OZqsNwmQ3xNLE4Cxwc+zfQEfbs6tzAo2Hjq+bh6q5F+Z8/cksrLFYWQQw==
   dependencies:
     devlop "^1.0.0"
@@ -6037,7 +6198,7 @@ micromark-extension-gfm-task-list-item@^2.0.0:
 
 micromark-extension-gfm@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/micromark-extension-gfm/-/micromark-extension-gfm-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-gfm/-/micromark-extension-gfm-3.0.0.tgz"
   integrity sha512-vsKArQsicm7t0z2GugkCKtZehqUm31oeGBV/KVSorWSy8ZlNAv7ytjFhvaryUiCUJYqs+NoE6AFhpQvBTM6Q4w==
   dependencies:
     micromark-extension-gfm-autolink-literal "^2.0.0"
@@ -6050,9 +6211,9 @@ micromark-extension-gfm@^3.0.0:
     micromark-util-types "^2.0.0"
 
 micromark-extension-mdx-expression@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/micromark-extension-mdx-expression/-/micromark-extension-mdx-expression-3.0.0.tgz"
-  integrity sha512-sI0nwhUDz97xyzqJAbHQhp5TfaxEvZZZ2JDqUo+7NvyIYG6BZ5CPPqj2ogUoPJlmXHBnyZUzISg9+oUmU6tUjQ==
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/micromark-extension-mdx-expression/-/micromark-extension-mdx-expression-3.0.1.tgz"
+  integrity sha512-dD/ADLJ1AeMvSAKBwO22zG22N4ybhe7kFIZ3LsDI0GlsNr2A3KYxb0LdC1u5rj4Nw+CHKY0RVdnHX8vj8ejm4Q==
   dependencies:
     "@types/estree" "^1.0.0"
     devlop "^1.0.0"
@@ -6064,11 +6225,10 @@ micromark-extension-mdx-expression@^3.0.0:
     micromark-util-types "^2.0.0"
 
 micromark-extension-mdx-jsx@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.npmjs.org/micromark-extension-mdx-jsx/-/micromark-extension-mdx-jsx-3.0.1.tgz"
-  integrity sha512-vNuFb9czP8QCtAQcEJn0UJQJZA8Dk6DXKBqx+bg/w0WGuSxDxNr7hErW89tHUY31dUW4NqEOWwmEUNhjTFmHkg==
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/micromark-extension-mdx-jsx/-/micromark-extension-mdx-jsx-3.0.2.tgz"
+  integrity sha512-e5+q1DjMh62LZAJOnDraSSbDMvGJ8x3cbjygy2qFEi7HCeUT4BDKCvMozPozcD6WmOt6sVvYDNBKhFSz3kjOVQ==
   dependencies:
-    "@types/acorn" "^4.0.0"
     "@types/estree" "^1.0.0"
     devlop "^1.0.0"
     estree-util-is-identifier-name "^3.0.0"
@@ -6082,14 +6242,14 @@ micromark-extension-mdx-jsx@^3.0.0:
 
 micromark-extension-mdx-md@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/micromark-extension-mdx-md/-/micromark-extension-mdx-md-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-mdx-md/-/micromark-extension-mdx-md-2.0.0.tgz"
   integrity sha512-EpAiszsB3blw4Rpba7xTOUptcFeBFi+6PY8VnJ2hhimH+vCQDirWgsMpz7w1XcZE7LVrSAUGb9VJpG9ghlYvYQ==
   dependencies:
     micromark-util-types "^2.0.0"
 
 micromark-extension-mdxjs-esm@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/micromark-extension-mdxjs-esm/-/micromark-extension-mdxjs-esm-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-mdxjs-esm/-/micromark-extension-mdxjs-esm-3.0.0.tgz"
   integrity sha512-DJFl4ZqkErRpq/dAPyeWp15tGrcrrJho1hKK5uBS70BCtfrIFg81sqcTVu3Ta+KD1Tk5vAtBNElWxtAa+m8K9A==
   dependencies:
     "@types/estree" "^1.0.0"
@@ -6104,7 +6264,7 @@ micromark-extension-mdxjs-esm@^3.0.0:
 
 micromark-extension-mdxjs@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/micromark-extension-mdxjs/-/micromark-extension-mdxjs-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-mdxjs/-/micromark-extension-mdxjs-3.0.0.tgz"
   integrity sha512-A873fJfhnJ2siZyUrJ31l34Uqwy4xIFmvPY1oj+Ean5PHcPBYzEsvqvWGaWcfEIr11O5Dlw3p2y0tZWpKHDejQ==
   dependencies:
     acorn "^8.0.0"
@@ -6118,7 +6278,7 @@ micromark-extension-mdxjs@^3.0.0:
 
 micromark-factory-destination@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/micromark-factory-destination/-/micromark-factory-destination-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-factory-destination/-/micromark-factory-destination-2.0.1.tgz"
   integrity sha512-Xe6rDdJlkmbFRExpTOmRj9N3MaWmbAgdpSrBQvCFqhezUn4AHqJHbaEnfbVYYiexVSs//tqOdY/DxhjdCiJnIA==
   dependencies:
     micromark-util-character "^2.0.0"
@@ -6127,7 +6287,7 @@ micromark-factory-destination@^2.0.0:
 
 micromark-factory-label@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/micromark-factory-label/-/micromark-factory-label-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-factory-label/-/micromark-factory-label-2.0.1.tgz"
   integrity sha512-VFMekyQExqIW7xIChcXn4ok29YE3rnuyveW3wZQWWqF4Nv9Wk5rgJ99KzPvHjkmPXF93FXIbBp6YdW3t71/7Vg==
   dependencies:
     devlop "^1.0.0"
@@ -6136,9 +6296,9 @@ micromark-factory-label@^2.0.0:
     micromark-util-types "^2.0.0"
 
 micromark-factory-mdx-expression@^2.0.0:
-  version "2.0.2"
-  resolved "https://registry.npmjs.org/micromark-factory-mdx-expression/-/micromark-factory-mdx-expression-2.0.2.tgz"
-  integrity sha512-5E5I2pFzJyg2CtemqAbcyCktpHXuJbABnsb32wX2U8IQKhhVFBqkcZR5LRm1WVoFqa4kTueZK4abep7wdo9nrw==
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/micromark-factory-mdx-expression/-/micromark-factory-mdx-expression-2.0.3.tgz"
+  integrity sha512-kQnEtA3vzucU2BkrIa8/VaSAsP+EJ3CKOvhMuJgOEGg9KDC6OAY6nSnNDVRiVNRqj7Y4SlSzcStaH/5jge8JdQ==
   dependencies:
     "@types/estree" "^1.0.0"
     devlop "^1.0.0"
@@ -6152,7 +6312,7 @@ micromark-factory-mdx-expression@^2.0.0:
 
 micromark-factory-space@^1.0.0:
   version "1.1.0"
-  resolved "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-factory-space/-/micromark-factory-space-1.1.0.tgz"
   integrity sha512-cRzEj7c0OL4Mw2v6nwzttyOZe8XY/Z8G0rzmWQZTBi/jjwyw/U4uqKtUORXQrR5bAZZnbTI/feRV/R7hc4jQYQ==
   dependencies:
     micromark-util-character "^1.0.0"
@@ -6160,7 +6320,7 @@ micromark-factory-space@^1.0.0:
 
 micromark-factory-space@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz"
   integrity sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==
   dependencies:
     micromark-util-character "^2.0.0"
@@ -6168,7 +6328,7 @@ micromark-factory-space@^2.0.0:
 
 micromark-factory-title@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/micromark-factory-title/-/micromark-factory-title-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-factory-title/-/micromark-factory-title-2.0.1.tgz"
   integrity sha512-5bZ+3CjhAd9eChYTHsjy6TGxpOFSKgKKJPJxr293jTbfry2KDoWkhBb6TcPVB4NmzaPhMs1Frm9AZH7OD4Cjzw==
   dependencies:
     micromark-factory-space "^2.0.0"
@@ -6178,7 +6338,7 @@ micromark-factory-title@^2.0.0:
 
 micromark-factory-whitespace@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/micromark-factory-whitespace/-/micromark-factory-whitespace-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-factory-whitespace/-/micromark-factory-whitespace-2.0.1.tgz"
   integrity sha512-Ob0nuZ3PKt/n0hORHyvoD9uZhr+Za8sFoP+OnMcnWK5lngSzALgQYKMr9RJVOWLqQYuyn6ulqGWSXdwf6F80lQ==
   dependencies:
     micromark-factory-space "^2.0.0"
@@ -6188,7 +6348,7 @@ micromark-factory-whitespace@^2.0.0:
 
 micromark-util-character@^1.0.0, micromark-util-character@^1.1.0:
   version "1.2.0"
-  resolved "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-1.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-util-character/-/micromark-util-character-1.2.0.tgz"
   integrity sha512-lXraTwcX3yH/vMDaFWCQJP1uIszLVebzUa3ZHdrgxr7KEU/9mL4mVgCpGbyhvNLNlauROiNUq7WN5u7ndbY6xg==
   dependencies:
     micromark-util-symbol "^1.0.0"
@@ -6196,7 +6356,7 @@ micromark-util-character@^1.0.0, micromark-util-character@^1.1.0:
 
 micromark-util-character@^2.0.0:
   version "2.1.1"
-  resolved "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-util-character/-/micromark-util-character-2.1.1.tgz"
   integrity sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==
   dependencies:
     micromark-util-symbol "^2.0.0"
@@ -6204,14 +6364,14 @@ micromark-util-character@^2.0.0:
 
 micromark-util-chunked@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/micromark-util-chunked/-/micromark-util-chunked-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-util-chunked/-/micromark-util-chunked-2.0.1.tgz"
   integrity sha512-QUNFEOPELfmvv+4xiNg2sRYeS/P84pTW0TCgP5zc9FpXetHY0ab7SxKyAQCNCc1eK0459uoLI1y5oO5Vc1dbhA==
   dependencies:
     micromark-util-symbol "^2.0.0"
 
 micromark-util-classify-character@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/micromark-util-classify-character/-/micromark-util-classify-character-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-util-classify-character/-/micromark-util-classify-character-2.0.1.tgz"
   integrity sha512-K0kHzM6afW/MbeWYWLjoHQv1sgg2Q9EccHEDzSkxiP/EaagNzCm7T/WMKZ3rjMbvIpvBiZgwR3dKMygtA4mG1Q==
   dependencies:
     micromark-util-character "^2.0.0"
@@ -6220,7 +6380,7 @@ micromark-util-classify-character@^2.0.0:
 
 micromark-util-combine-extensions@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/micromark-util-combine-extensions/-/micromark-util-combine-extensions-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-util-combine-extensions/-/micromark-util-combine-extensions-2.0.1.tgz"
   integrity sha512-OnAnH8Ujmy59JcyZw8JSbK9cGpdVY44NKgSM7E9Eh7DiLS2E9RNQf0dONaGDzEG9yjEl5hcqeIsj4hfRkLH/Bg==
   dependencies:
     micromark-util-chunked "^2.0.0"
@@ -6228,14 +6388,14 @@ micromark-util-combine-extensions@^2.0.0:
 
 micromark-util-decode-numeric-character-reference@^2.0.0:
   version "2.0.2"
-  resolved "https://registry.npmjs.org/micromark-util-decode-numeric-character-reference/-/micromark-util-decode-numeric-character-reference-2.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-util-decode-numeric-character-reference/-/micromark-util-decode-numeric-character-reference-2.0.2.tgz"
   integrity sha512-ccUbYk6CwVdkmCQMyr64dXz42EfHGkPQlBj5p7YVGzq8I7CtjXZJrubAYezf7Rp+bjPseiROqe7G6foFd+lEuw==
   dependencies:
     micromark-util-symbol "^2.0.0"
 
 micromark-util-decode-string@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/micromark-util-decode-string/-/micromark-util-decode-string-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-util-decode-string/-/micromark-util-decode-string-2.0.1.tgz"
   integrity sha512-nDV/77Fj6eH1ynwscYTOsbK7rR//Uj0bZXBwJZRfaLEJ1iGBR6kIfNmlNqaqJf649EP0F3NWNdeJi03elllNUQ==
   dependencies:
     decode-named-character-reference "^1.0.0"
@@ -6245,15 +6405,14 @@ micromark-util-decode-string@^2.0.0:
 
 micromark-util-encode@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/micromark-util-encode/-/micromark-util-encode-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-util-encode/-/micromark-util-encode-2.0.1.tgz"
   integrity sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==
 
 micromark-util-events-to-acorn@^2.0.0:
-  version "2.0.2"
-  resolved "https://registry.npmjs.org/micromark-util-events-to-acorn/-/micromark-util-events-to-acorn-2.0.2.tgz"
-  integrity sha512-Fk+xmBrOv9QZnEDguL9OI9/NQQp6Hz4FuQ4YmCb/5V7+9eAh1s6AYSvL20kHkD67YIg7EpE54TiSlcsf3vyZgA==
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/micromark-util-events-to-acorn/-/micromark-util-events-to-acorn-2.0.3.tgz"
+  integrity sha512-jmsiEIiZ1n7X1Rr5k8wVExBQCg5jy4UXVADItHmNk1zkwEVhBuIUKRu3fqv+hs4nxLISi2DQGlqIOGiFxgbfHg==
   dependencies:
-    "@types/acorn" "^4.0.0"
     "@types/estree" "^1.0.0"
     "@types/unist" "^3.0.0"
     devlop "^1.0.0"
@@ -6264,26 +6423,26 @@ micromark-util-events-to-acorn@^2.0.0:
 
 micromark-util-html-tag-name@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/micromark-util-html-tag-name/-/micromark-util-html-tag-name-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-util-html-tag-name/-/micromark-util-html-tag-name-2.0.1.tgz"
   integrity sha512-2cNEiYDhCWKI+Gs9T0Tiysk136SnR13hhO8yW6BGNyhOC4qYFnwF1nKfD3HFAIXA5c45RrIG1ub11GiXeYd1xA==
 
 micromark-util-normalize-identifier@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/micromark-util-normalize-identifier/-/micromark-util-normalize-identifier-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-util-normalize-identifier/-/micromark-util-normalize-identifier-2.0.1.tgz"
   integrity sha512-sxPqmo70LyARJs0w2UclACPUUEqltCkJ6PhKdMIDuJ3gSf/Q+/GIe3WKl0Ijb/GyH9lOpUkRAO2wp0GVkLvS9Q==
   dependencies:
     micromark-util-symbol "^2.0.0"
 
 micromark-util-resolve-all@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/micromark-util-resolve-all/-/micromark-util-resolve-all-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-util-resolve-all/-/micromark-util-resolve-all-2.0.1.tgz"
   integrity sha512-VdQyxFWFT2/FGJgwQnJYbe1jjQoNTS4RjglmSjTUlpUMa95Htx9NHeYW4rGDJzbjvCsl9eLjMQwGeElsqmzcHg==
   dependencies:
     micromark-util-types "^2.0.0"
 
 micromark-util-sanitize-uri@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.1.tgz"
   integrity sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==
   dependencies:
     micromark-util-character "^2.0.0"
@@ -6291,9 +6450,9 @@ micromark-util-sanitize-uri@^2.0.0:
     micromark-util-symbol "^2.0.0"
 
 micromark-util-subtokenize@^2.0.0:
-  version "2.0.3"
-  resolved "https://registry.npmjs.org/micromark-util-subtokenize/-/micromark-util-subtokenize-2.0.3.tgz"
-  integrity sha512-VXJJuNxYWSoYL6AJ6OQECCFGhIU2GGHMw8tahogePBrjkG8aCCas3ibkp7RnVOSTClg2is05/R7maAhF1XyQMg==
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/micromark-util-subtokenize/-/micromark-util-subtokenize-2.1.0.tgz"
+  integrity sha512-XQLu552iSctvnEcgXw6+Sx75GflAPNED1qx7eBJ+wydBb2KCbRZe+NwvIEEMM83uml1+2WSXpBAcp9IUCgCYWA==
   dependencies:
     devlop "^1.0.0"
     micromark-util-chunked "^2.0.0"
@@ -6302,28 +6461,28 @@ micromark-util-subtokenize@^2.0.0:
 
 micromark-util-symbol@^1.0.0, micromark-util-symbol@^1.0.1:
   version "1.1.0"
-  resolved "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-util-symbol/-/micromark-util-symbol-1.1.0.tgz"
   integrity sha512-uEjpEYY6KMs1g7QfJ2eX1SQEV+ZT4rUD3UcF6l57acZvLNK7PBZL+ty82Z1qhK1/yXIY4bdx04FKMgR0g4IAag==
 
 micromark-util-symbol@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz"
   integrity sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==
 
 micromark-util-types@^1.0.0:
   version "1.1.0"
-  resolved "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-util-types/-/micromark-util-types-1.1.0.tgz"
   integrity sha512-ukRBgie8TIAcacscVHSiddHjO4k/q3pnedmzMQ4iwDcK0FtFCohKOlFbaOL/mPgfnPsL3C1ZyxJa4sbWrBl3jg==
 
 micromark-util-types@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-2.0.1.tgz"
-  integrity sha512-534m2WhVTddrcKVepwmVEVnUAmtrx9bfIjNoQHRqfnvdaHQiFytEhJoTgpWJvDEXCO5gLTQh3wYC1PgOJA4NSQ==
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/micromark-util-types/-/micromark-util-types-2.0.2.tgz"
+  integrity sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA==
 
 micromark@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.npmjs.org/micromark/-/micromark-4.0.1.tgz"
-  integrity sha512-eBPdkcoCNvYcxQOAKAlceo5SNdzZWfF+FcSupREAzdAh9rRmE239CEQAiTwIgblwnoM8zzj35sZ5ZwvSEOF6Kw==
+  version "4.0.2"
+  resolved "https://registry.yarnpkg.com/micromark/-/micromark-4.0.2.tgz"
+  integrity sha512-zpe98Q6kvavpCr1NPVSCMebCKfD7CA2NqZ+rykeNhONIJBpc1tFKt9hucLGwha3jNTNI8lHpctWJWoimVF4PfA==
   dependencies:
     "@types/debug" "^4.0.0"
     debug "^4.0.0"
@@ -6343,129 +6502,141 @@ micromark@^4.0.0:
     micromark-util-symbol "^2.0.0"
     micromark-util-types "^2.0.0"
 
-micromatch@^4.0.2, micromatch@^4.0.4, micromatch@^4.0.5:
+micromatch@^4.0.2, micromatch@^4.0.5, micromatch@^4.0.8:
   version "4.0.8"
-  resolved "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz"
+  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.8.tgz"
   integrity sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==
   dependencies:
     braces "^3.0.3"
     picomatch "^2.3.1"
 
-mime-db@1.52.0, "mime-db@>= 1.43.0 < 2":
+mime-db@1.52.0:
   version "1.52.0"
-  resolved "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz"
+  resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.52.0.tgz"
   integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==
 
+"mime-db@>= 1.43.0 < 2", mime-db@^1.54.0:
+  version "1.54.0"
+  resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.54.0.tgz"
+  integrity sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==
+
 mime-db@~1.33.0:
   version "1.33.0"
-  resolved "https://registry.npmjs.org/mime-db/-/mime-db-1.33.0.tgz"
+  resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.33.0.tgz"
   integrity sha512-BHJ/EKruNIqJf/QahvxwQZXKygOQ256myeN/Ew+THcAa5q+PjyTTMMeNQC4DZw5AwfvelsUrA6B67NKMqXDbzQ==
 
 mime-types@2.1.18:
   version "2.1.18"
-  resolved "https://registry.npmjs.org/mime-types/-/mime-types-2.1.18.tgz"
+  resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.18.tgz"
   integrity sha512-lc/aahn+t4/SWV/qcmumYjymLsWfN3ELhpmVuUFjgsORruuZPVSwAQryq+HHGvO/SI2KVX26bx+En+zhM8g8hQ==
   dependencies:
     mime-db "~1.33.0"
 
-mime-types@^2.1.12, mime-types@^2.1.27, mime-types@^2.1.31, mime-types@~2.1.17, mime-types@~2.1.24, mime-types@~2.1.34:
+mime-types@^2.1.12, mime-types@^2.1.27, mime-types@~2.1.24, mime-types@~2.1.34, mime-types@~2.1.35:
   version "2.1.35"
-  resolved "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz"
+  resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.35.tgz"
   integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==
   dependencies:
     mime-db "1.52.0"
 
+mime-types@^3.0.1:
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-3.0.2.tgz"
+  integrity sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==
+  dependencies:
+    mime-db "^1.54.0"
+
 mime@1.6.0:
   version "1.6.0"
-  resolved "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz"
+  resolved "https://registry.yarnpkg.com/mime/-/mime-1.6.0.tgz"
   integrity sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==
 
 mimic-fn@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-2.1.0.tgz"
   integrity sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==
 
 mimic-response@^3.1.0:
   version "3.1.0"
-  resolved "https://registry.npmjs.org/mimic-response/-/mimic-response-3.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/mimic-response/-/mimic-response-3.1.0.tgz"
   integrity sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==
 
 mimic-response@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/mimic-response/-/mimic-response-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/mimic-response/-/mimic-response-4.0.0.tgz"
   integrity sha512-e5ISH9xMYU0DzrT+jl8q2ze9D6eWBto+I8CNpe+VI+K2J/F/k3PdkdTdz4wvGVH4NTpo+NRYTVIuMQEMMcsLqg==
 
-mini-css-extract-plugin@^2.9.1:
-  version "2.9.2"
-  resolved "https://registry.npmjs.org/mini-css-extract-plugin/-/mini-css-extract-plugin-2.9.2.tgz"
-  integrity sha512-GJuACcS//jtq4kCtd5ii/M0SZf7OZRH+BxdqXZHaJfb8TJiVl+NgQRPwiYt2EuqeSkNydn/7vP+bcE27C5mb9w==
+mini-css-extract-plugin@^2.9.2:
+  version "2.10.2"
+  resolved "https://registry.yarnpkg.com/mini-css-extract-plugin/-/mini-css-extract-plugin-2.10.2.tgz"
+  integrity sha512-AOSS0IdEB95ayVkxn5oGzNQwqAi2J0Jb/kKm43t7H73s8+f5873g0yuj0PNvK4dO75mu5DHg4nlgp4k6Kga8eg==
   dependencies:
     schema-utils "^4.0.0"
     tapable "^2.2.1"
 
 minimalistic-assert@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz"
   integrity sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==
 
-minimatch@3.1.2, minimatch@^3.0.4, minimatch@^3.0.5, minimatch@^3.1.1:
-  version "3.1.2"
-  resolved "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz"
-  integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==
+minimatch@3.1.5:
+  version "3.1.5"
+  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.1.5.tgz"
+  integrity sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==
   dependencies:
     brace-expansion "^1.1.7"
 
 minimist@^1.2.0:
   version "1.2.8"
-  resolved "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz"
+  resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.8.tgz"
   integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==
 
 mrmime@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/mrmime/-/mrmime-2.0.0.tgz"
-  integrity sha512-eu38+hdgojoyq63s+yTpN4XMBdt5l8HhMhc4VKLO9KM5caLIBvUm4thi7fFaxyTmCKeNnXZ5pAlBwCUnhA09uw==
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/mrmime/-/mrmime-2.0.1.tgz"
+  integrity sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ==
 
 ms@2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/ms/-/ms-2.0.0.tgz"
   integrity sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==
 
 ms@2.1.3, ms@^2.1.3:
   version "2.1.3"
-  resolved "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz"
+  resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.3.tgz"
   integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==
 
 multicast-dns@^7.2.5:
   version "7.2.5"
-  resolved "https://registry.npmjs.org/multicast-dns/-/multicast-dns-7.2.5.tgz"
+  resolved "https://registry.yarnpkg.com/multicast-dns/-/multicast-dns-7.2.5.tgz"
   integrity sha512-2eznPJP8z2BFLX50tf0LuODrpINqP1RVIm/CObbTcBRITQgmC/TjcREF1NeTBzIcR5XO/ukWo+YHOjBbFwIupg==
   dependencies:
     dns-packet "^5.2.2"
     thunky "^1.0.2"
 
-nanoid@^3.3.7:
-  version "3.3.8"
-  resolved "https://registry.npmjs.org/nanoid/-/nanoid-3.3.8.tgz"
-  integrity sha512-WNLf5Sd8oZxOm+TzppcYk8gVOgP+l58xNy58D0nbUnOxOWRWvlcCV4kUF7ltmI6PsrLl/BgKEyS4mqsGChFN0w==
+nanoid@^3.3.11:
+  version "3.3.11"
+  resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-3.3.11.tgz"
+  integrity sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==
 
 negotiator@0.6.3:
   version "0.6.3"
-  resolved "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz"
+  resolved "https://registry.yarnpkg.com/negotiator/-/negotiator-0.6.3.tgz"
   integrity sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==
 
 negotiator@~0.6.4:
   version "0.6.4"
-  resolved "https://registry.npmjs.org/negotiator/-/negotiator-0.6.4.tgz"
+  resolved "https://registry.yarnpkg.com/negotiator/-/negotiator-0.6.4.tgz"
   integrity sha512-myRT3DiWPHqho5PrJaIRyaMv2kgYf0mUVgBNOYMuCH5Ki1yEiQaf/ZJuQ62nvpc44wL5WDbTX7yGJi1Neevw8w==
 
 neo-async@^2.6.2:
   version "2.6.2"
-  resolved "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz"
+  resolved "https://registry.yarnpkg.com/neo-async/-/neo-async-2.6.2.tgz"
   integrity sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==
 
 no-case@^3.0.4:
   version "3.0.4"
-  resolved "https://registry.npmjs.org/no-case/-/no-case-3.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/no-case/-/no-case-3.0.4.tgz"
   integrity sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==
   dependencies:
     lower-case "^2.0.2"
@@ -6473,7 +6644,7 @@ no-case@^3.0.4:
 
 node-emoji@^2.1.0:
   version "2.2.0"
-  resolved "https://registry.npmjs.org/node-emoji/-/node-emoji-2.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/node-emoji/-/node-emoji-2.2.0.tgz"
   integrity sha512-Z3lTE9pLaJF47NyMhd4ww1yFTAP8YhYI8SleJiHzM46Fgpm5cnNzSl9XfzFNqbaz+VlJrIj3fXQ4DeN1Rjm6cw==
   dependencies:
     "@sindresorhus/is" "^4.6.0"
@@ -6481,53 +6652,43 @@ node-emoji@^2.1.0:
     emojilib "^2.4.0"
     skin-tone "^2.0.0"
 
-node-forge@^1:
-  version "1.3.1"
-  resolved "https://registry.npmjs.org/node-forge/-/node-forge-1.3.1.tgz"
-  integrity sha512-dPEtOeMvF9VMcYV/1Wb8CPoVAXtp6MKMlcbAt4ddqmGqUJ6fQZFXkNZNkNlfevtNkGtaSoXf/vNNNSvgrdXwtA==
-
-node-releases@^2.0.19:
-  version "2.0.19"
-  resolved "https://registry.npmjs.org/node-releases/-/node-releases-2.0.19.tgz"
-  integrity sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==
+node-releases@^2.0.36:
+  version "2.0.38"
+  resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-2.0.38.tgz"
+  integrity sha512-3qT/88Y3FbH/Kx4szpQQ4HzUbVrHPKTLVpVocKiLfoYvw9XSGOX2FmD2d6DrXbVYyAQTF2HeF6My8jmzx7/CRw==
 
 normalize-path@^3.0.0, normalize-path@~3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz"
   integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==
 
-normalize-range@^0.1.2:
-  version "0.1.2"
-  resolved "https://registry.npmjs.org/normalize-range/-/normalize-range-0.1.2.tgz"
-  integrity sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA==
-
 normalize-url@^8.0.0:
-  version "8.0.1"
-  resolved "https://registry.npmjs.org/normalize-url/-/normalize-url-8.0.1.tgz"
-  integrity sha512-IO9QvjUMWxPQQhs60oOu10CRkWCiZzSUkzbXGGV9pviYl1fXYcvkzQ5jV9z8Y6un8ARoVRl4EtC6v6jNqbaJ/w==
+  version "8.1.1"
+  resolved "https://registry.yarnpkg.com/normalize-url/-/normalize-url-8.1.1.tgz"
+  integrity sha512-JYc0DPlpGWB40kH5g07gGTrYuMqV653k3uBKY6uITPWds3M0ov3GaWGp9lbE3Bzngx8+XkfzgvASb9vk9JDFXQ==
 
 npm-run-path@^4.0.1:
   version "4.0.1"
-  resolved "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-4.0.1.tgz"
   integrity sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==
   dependencies:
     path-key "^3.0.0"
 
 nprogress@^0.2.0:
   version "0.2.0"
-  resolved "https://registry.npmjs.org/nprogress/-/nprogress-0.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/nprogress/-/nprogress-0.2.0.tgz"
   integrity sha512-I19aIingLgR1fmhftnbWWO3dXc0hSxqHQHQb3H8m+K3TnEn/iSeTZZOyvKXWqQESMwuUVnatlCnZdLBZZt2VSA==
 
 nth-check@^2.0.1:
   version "2.1.1"
-  resolved "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/nth-check/-/nth-check-2.1.1.tgz"
   integrity sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==
   dependencies:
     boolbase "^1.0.0"
 
 null-loader@^4.0.1:
   version "4.0.1"
-  resolved "https://registry.npmjs.org/null-loader/-/null-loader-4.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/null-loader/-/null-loader-4.0.1.tgz"
   integrity sha512-pxqVbi4U6N26lq+LmgIbB5XATP0VdZKOG25DhHi8btMmJJefGArFyDg1yc4U3hWCJbMqSrw0qyrz1UQX+qYXqg==
   dependencies:
     loader-utils "^2.0.0"
@@ -6535,22 +6696,22 @@ null-loader@^4.0.1:
 
 object-assign@^4.1.1:
   version "4.1.1"
-  resolved "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz"
   integrity sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==
 
-object-inspect@^1.13.3:
-  version "1.13.3"
-  resolved "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.3.tgz"
-  integrity sha512-kDCGIbxkDSXE3euJZZXzc6to7fCrKHNI/hSRQnRuQ+BWjFNzZwiFF8fj/6o2t2G9/jTj8PSIYTfCLelLZEeRpA==
+object-inspect@^1.13.3, object-inspect@^1.13.4:
+  version "1.13.4"
+  resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.13.4.tgz"
+  integrity sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==
 
 object-keys@^1.1.1:
   version "1.1.1"
-  resolved "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.1.1.tgz"
   integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==
 
 object.assign@^4.1.0:
   version "4.1.7"
-  resolved "https://registry.npmjs.org/object.assign/-/object.assign-4.1.7.tgz"
+  resolved "https://registry.yarnpkg.com/object.assign/-/object.assign-4.1.7.tgz"
   integrity sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==
   dependencies:
     call-bind "^1.0.8"
@@ -6562,38 +6723,41 @@ object.assign@^4.1.0:
 
 obuf@^1.0.0, obuf@^1.1.2:
   version "1.1.2"
-  resolved "https://registry.npmjs.org/obuf/-/obuf-1.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/obuf/-/obuf-1.1.2.tgz"
   integrity sha512-PX1wu0AmAdPqOL1mWhqmlOd8kOIZQwGZw6rh7uby9fTc5lhaOWFLX3I6R1hrF9k3zUY40e6igsLGkDXK92LJNg==
 
-on-finished@2.4.1:
+on-finished@^2.4.1, on-finished@~2.4.1:
   version "2.4.1"
-  resolved "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz"
+  resolved "https://registry.yarnpkg.com/on-finished/-/on-finished-2.4.1.tgz"
   integrity sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==
   dependencies:
     ee-first "1.1.1"
 
 on-headers@~1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/on-headers/-/on-headers-1.1.0.tgz#59da4f91c45f5f989c6e4bcedc5a3b0aed70ff65"
+  resolved "https://registry.yarnpkg.com/on-headers/-/on-headers-1.1.0.tgz"
   integrity sha512-737ZY3yNnXy37FHkQxPzt4UZ2UWPWiCZWLvFZ4fu5cueciegX0zGPnrlY6bwRg4FdQOe9YU8MkmJwGhoMybl8A==
 
-once@^1.3.0:
-  version "1.4.0"
-  resolved "https://registry.npmjs.org/once/-/once-1.4.0.tgz"
-  integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==
-  dependencies:
-    wrappy "1"
-
 onetime@^5.1.2:
   version "5.1.2"
-  resolved "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/onetime/-/onetime-5.1.2.tgz"
   integrity sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==
   dependencies:
     mimic-fn "^2.1.0"
 
-open@^8.0.9, open@^8.4.0:
+open@^10.0.3:
+  version "10.2.0"
+  resolved "https://registry.yarnpkg.com/open/-/open-10.2.0.tgz"
+  integrity sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA==
+  dependencies:
+    default-browser "^5.2.1"
+    define-lazy-prop "^3.0.0"
+    is-inside-container "^1.0.0"
+    wsl-utils "^0.1.0"
+
+open@^8.4.0:
   version "8.4.2"
-  resolved "https://registry.npmjs.org/open/-/open-8.4.2.tgz"
+  resolved "https://registry.yarnpkg.com/open/-/open-8.4.2.tgz"
   integrity sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==
   dependencies:
     define-lazy-prop "^2.0.0"
@@ -6602,79 +6766,67 @@ open@^8.0.9, open@^8.4.0:
 
 opener@^1.5.2:
   version "1.5.2"
-  resolved "https://registry.npmjs.org/opener/-/opener-1.5.2.tgz"
+  resolved "https://registry.yarnpkg.com/opener/-/opener-1.5.2.tgz"
   integrity sha512-ur5UIdyw5Y7yEj9wLzhqXiy6GZ3Mwx0yGI+5sMn2r0N0v3cKJvUmFH5yPP+WXh9e0xfyzyJX95D8l088DNFj7A==
 
 p-cancelable@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/p-cancelable/-/p-cancelable-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/p-cancelable/-/p-cancelable-3.0.0.tgz"
   integrity sha512-mlVgR3PGuzlo0MmTdk4cXqXWlwQDLnONTAg6sm62XkMJEiRxN3GL3SffkYvqwonbkJBcrI7Uvv5Zh9yjvn2iUw==
 
-p-limit@^2.0.0:
-  version "2.3.0"
-  resolved "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz"
-  integrity sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==
-  dependencies:
-    p-try "^2.0.0"
-
-p-limit@^3.0.2:
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz"
-  integrity sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==
-  dependencies:
-    yocto-queue "^0.1.0"
+p-finally@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/p-finally/-/p-finally-1.0.0.tgz"
+  integrity sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow==
 
 p-limit@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/p-limit/-/p-limit-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-4.0.0.tgz"
   integrity sha512-5b0R4txpzjPWVw/cXXUResoD4hb6U/x9BH08L7nw+GN1sezDzPdxeRvpc9c433fZhBan/wusjbCsqwqm4EIBIQ==
   dependencies:
     yocto-queue "^1.0.0"
 
-p-locate@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz"
-  integrity sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==
-  dependencies:
-    p-limit "^2.0.0"
-
-p-locate@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz"
-  integrity sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==
-  dependencies:
-    p-limit "^3.0.2"
-
 p-locate@^6.0.0:
   version "6.0.0"
-  resolved "https://registry.npmjs.org/p-locate/-/p-locate-6.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-6.0.0.tgz"
   integrity sha512-wPrq66Llhl7/4AGC6I+cqxT07LhXvWL08LNXz1fENOw0Ap4sRZZ/gZpTTJ5jpurzzzfS2W/Ge9BY3LgLjCShcw==
   dependencies:
     p-limit "^4.0.0"
 
 p-map@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/p-map/-/p-map-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/p-map/-/p-map-4.0.0.tgz"
   integrity sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==
   dependencies:
     aggregate-error "^3.0.0"
 
-p-retry@^4.5.0:
-  version "4.6.2"
-  resolved "https://registry.npmjs.org/p-retry/-/p-retry-4.6.2.tgz"
-  integrity sha512-312Id396EbJdvRONlngUx0NydfrIQ5lsYu0znKVUzVvArzEIt08V1qhtyESbGVd1FGX7UKtiFp5uwKZdM8wIuQ==
+p-queue@^6.6.2:
+  version "6.6.2"
+  resolved "https://registry.yarnpkg.com/p-queue/-/p-queue-6.6.2.tgz"
+  integrity sha512-RwFpb72c/BhQLEXIZ5K2e+AhgNVmIejGlTgiB9MzZ0e93GRvqZ7uSi0dvRF7/XIXDeNkra2fNHBxTyPDGySpjQ==
+  dependencies:
+    eventemitter3 "^4.0.4"
+    p-timeout "^3.2.0"
+
+p-retry@^6.2.0:
+  version "6.2.1"
+  resolved "https://registry.yarnpkg.com/p-retry/-/p-retry-6.2.1.tgz"
+  integrity sha512-hEt02O4hUct5wtwg4H4KcWgDdm+l1bOaEy/hWzd8xtXB9BqxTWBBhb+2ImAtH4Cv4rPjV76xN3Zumqk3k3AhhQ==
   dependencies:
-    "@types/retry" "0.12.0"
+    "@types/retry" "0.12.2"
+    is-network-error "^1.0.0"
     retry "^0.13.1"
 
-p-try@^2.0.0:
-  version "2.2.0"
-  resolved "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz"
-  integrity sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==
+p-timeout@^3.2.0:
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/p-timeout/-/p-timeout-3.2.0.tgz"
+  integrity sha512-rhIwUycgwwKcP9yTOOFK/AKsAopjjCakVqLHePO3CC6Mir1Z99xT+R63jZxAT5lFZLa2inS5h+ZS2GvR99/FBg==
+  dependencies:
+    p-finally "^1.0.0"
 
 package-json@^8.1.0:
   version "8.1.1"
-  resolved "https://registry.npmjs.org/package-json/-/package-json-8.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/package-json/-/package-json-8.1.1.tgz"
   integrity sha512-cbH9IAIJHNj9uXi196JVsRlt7cHKak6u/e6AkL/bkRelZ7rlL3X1YKxsZwa36xipOEKAsdtmaG6aAJoM1fx2zA==
   dependencies:
     got "^12.1.0"
@@ -6684,7 +6836,7 @@ package-json@^8.1.0:
 
 param-case@^3.0.4:
   version "3.0.4"
-  resolved "https://registry.npmjs.org/param-case/-/param-case-3.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/param-case/-/param-case-3.0.4.tgz"
   integrity sha512-RXlj7zCYokReqWpOPH9oYivUzLYZ5vAPIfEmCTNViosC78F8F0H9y7T7gG2M39ymgutxF5gcFEsyZQSph9Bp3A==
   dependencies:
     dot-case "^3.0.4"
@@ -6692,14 +6844,14 @@ param-case@^3.0.4:
 
 parent-module@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/parent-module/-/parent-module-1.0.1.tgz"
   integrity sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==
   dependencies:
     callsites "^3.0.0"
 
 parse-entities@^4.0.0:
   version "4.0.2"
-  resolved "https://registry.npmjs.org/parse-entities/-/parse-entities-4.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/parse-entities/-/parse-entities-4.0.2.tgz"
   integrity sha512-GG2AQYWoLgL877gQIKeRPGO1xF9+eG1ujIb5soS5gPvLQ1y2o8FL90w2QWNdf9I361Mpp7726c+lj3U0qK1uGw==
   dependencies:
     "@types/unist" "^2.0.0"
@@ -6710,9 +6862,9 @@ parse-entities@^4.0.0:
     is-decimal "^2.0.0"
     is-hexadecimal "^2.0.0"
 
-parse-json@^5.0.0, parse-json@^5.2.0:
+parse-json@^5.2.0:
   version "5.2.0"
-  resolved "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-5.2.0.tgz"
   integrity sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==
   dependencies:
     "@babel/code-frame" "^7.0.0"
@@ -6722,128 +6874,118 @@ parse-json@^5.0.0, parse-json@^5.2.0:
 
 parse-numeric-range@^1.3.0:
   version "1.3.0"
-  resolved "https://registry.npmjs.org/parse-numeric-range/-/parse-numeric-range-1.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/parse-numeric-range/-/parse-numeric-range-1.3.0.tgz"
   integrity sha512-twN+njEipszzlMJd4ONUYgSfZPDxgHhT9Ahed5uTigpQn90FggW4SA/AIPq/6a149fTbE9qBEcSwE3FAEp6wQQ==
 
 parse5-htmlparser2-tree-adapter@^7.0.0:
   version "7.1.0"
-  resolved "https://registry.npmjs.org/parse5-htmlparser2-tree-adapter/-/parse5-htmlparser2-tree-adapter-7.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/parse5-htmlparser2-tree-adapter/-/parse5-htmlparser2-tree-adapter-7.1.0.tgz"
   integrity sha512-ruw5xyKs6lrpo9x9rCZqZZnIUntICjQAd0Wsmp396Ul9lN/h+ifgVV1x1gZHi8euej6wTfpqX8j+BFQxF0NS/g==
   dependencies:
     domhandler "^5.0.3"
     parse5 "^7.0.0"
 
 parse5@^7.0.0:
-  version "7.2.1"
-  resolved "https://registry.npmjs.org/parse5/-/parse5-7.2.1.tgz"
-  integrity sha512-BuBYQYlv1ckiPdQi/ohiivi9Sagc9JG+Ozs0r7b/0iK3sKmrb0b9FdWdBbOdx6hBCM/F9Ir82ofnBhtZOjCRPQ==
+  version "7.3.0"
+  resolved "https://registry.yarnpkg.com/parse5/-/parse5-7.3.0.tgz"
+  integrity sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==
   dependencies:
-    entities "^4.5.0"
+    entities "^6.0.0"
 
-parseurl@~1.3.2, parseurl@~1.3.3:
+parseurl@~1.3.3:
   version "1.3.3"
-  resolved "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz"
+  resolved "https://registry.yarnpkg.com/parseurl/-/parseurl-1.3.3.tgz"
   integrity sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==
 
 pascal-case@^3.1.2:
   version "3.1.2"
-  resolved "https://registry.npmjs.org/pascal-case/-/pascal-case-3.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/pascal-case/-/pascal-case-3.1.2.tgz"
   integrity sha512-uWlGT3YSnK9x3BQJaOdcZwrnV6hPpd8jFH1/ucpiLRPh/2zCVJKS19E4GvYHvaCcACn3foXZ0cLB9Wrx1KGe5g==
   dependencies:
     no-case "^3.0.4"
     tslib "^2.0.3"
 
-path-exists@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz"
-  integrity sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==
-
-path-exists@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz"
-  integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==
-
 path-exists@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.npmjs.org/path-exists/-/path-exists-5.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-5.0.0.tgz"
   integrity sha512-RjhtfwJOxzcFmNOi6ltcbcu4Iu+FL3zEj83dk4kAS+fVpTxXLO1b38RvJgT/0QwvV/L3aY9TAnyv0EOqW4GoMQ==
 
-path-is-absolute@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz"
-  integrity sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==
-
 path-is-inside@1.0.2:
   version "1.0.2"
-  resolved "https://registry.npmjs.org/path-is-inside/-/path-is-inside-1.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/path-is-inside/-/path-is-inside-1.0.2.tgz"
   integrity sha512-DUWJr3+ULp4zXmol/SZkFf3JGsS9/SIv+Y3Rt93/UjPpDpklB5f1er4O3POIbUuUJ3FXgqte2Q7SrU6zAqwk8w==
 
 path-key@^3.0.0, path-key@^3.1.0:
   version "3.1.1"
-  resolved "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/path-key/-/path-key-3.1.1.tgz"
   integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==
 
 path-parse@^1.0.7:
   version "1.0.7"
-  resolved "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz"
+  resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz"
   integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==
 
-path-to-regexp@0.1.12:
-  version "0.1.12"
-  resolved "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz"
-  integrity sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==
-
 path-to-regexp@3.3.0:
   version "3.3.0"
-  resolved "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-3.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/path-to-regexp/-/path-to-regexp-3.3.0.tgz"
   integrity sha512-qyCH421YQPS2WFDxDjftfc1ZR5WKQzVzqsp4n9M2kQhVOo/ByahFoUNJfl58kOcEGfQ//7weFTDhm+ss8Ecxgw==
 
 path-to-regexp@^1.7.0:
   version "1.9.0"
-  resolved "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-1.9.0.tgz"
+  resolved "https://registry.yarnpkg.com/path-to-regexp/-/path-to-regexp-1.9.0.tgz"
   integrity sha512-xIp7/apCFJuUHdDLWe8O1HIkb0kQrOMb/0u6FXQjemHn/ii5LrIzU6bdECnsiTF/GjZkMEKg1xdiZwNqDYlZ6g==
   dependencies:
     isarray "0.0.1"
 
+path-to-regexp@~0.1.12:
+  version "0.1.13"
+  resolved "https://registry.yarnpkg.com/path-to-regexp/-/path-to-regexp-0.1.13.tgz"
+  integrity sha512-A/AGNMFN3c8bOlvV9RreMdrv7jsmF9XIfDeCd87+I8RNg6s78BhJxMu69NEMHBSJFxKidViTEdruRwEk/WIKqA==
+
 path-type@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/path-type/-/path-type-4.0.0.tgz"
   integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==
 
-picocolors@^1.0.0, picocolors@^1.0.1, picocolors@^1.1.0, picocolors@^1.1.1:
+picocolors@^1.0.0, picocolors@^1.1.1:
   version "1.1.1"
-  resolved "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/picocolors/-/picocolors-1.1.1.tgz"
   integrity sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==
 
 picomatch@^2.0.4, picomatch@^2.2.1, picomatch@^2.2.3, picomatch@^2.3.1:
-  version "2.3.1"
-  resolved "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz"
-  integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==
+  version "2.3.2"
+  resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.2.tgz"
+  integrity sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==
 
 pkg-dir@^7.0.0:
   version "7.0.0"
-  resolved "https://registry.npmjs.org/pkg-dir/-/pkg-dir-7.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-7.0.0.tgz"
   integrity sha512-Ie9z/WINcxxLp27BKOCHGde4ITq9UklYKDzVo1nhk5sqGEXU3FpkwP5GM2voTGJkGd9B3Otl+Q4uwSOeSUtOBA==
   dependencies:
     find-up "^6.3.0"
 
-pkg-up@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/pkg-up/-/pkg-up-3.1.0.tgz"
-  integrity sha512-nDywThFk1i4BQK4twPQ6TA4RT8bDY96yeuCVBWL3ePARCiEKDRSrNGbFIgUJpLp+XeIR65v8ra7WuJOFUBtkMA==
+pkijs@^3.3.3:
+  version "3.4.0"
+  resolved "https://registry.yarnpkg.com/pkijs/-/pkijs-3.4.0.tgz"
+  integrity sha512-emEcLuomt2j03vxD54giVB4SxTjnsqkU692xZOZXHDVoYyypEm+b3jpiTcc+Cf+myooc+/Ly0z01jqeNHVgJGw==
   dependencies:
-    find-up "^3.0.0"
+    "@noble/hashes" "1.4.0"
+    asn1js "^3.0.6"
+    bytestreamjs "^2.0.1"
+    pvtsutils "^1.3.6"
+    pvutils "^1.1.3"
+    tslib "^2.8.1"
 
 postcss-attribute-case-insensitive@^7.0.1:
   version "7.0.1"
-  resolved "https://registry.npmjs.org/postcss-attribute-case-insensitive/-/postcss-attribute-case-insensitive-7.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-attribute-case-insensitive/-/postcss-attribute-case-insensitive-7.0.1.tgz"
   integrity sha512-Uai+SupNSqzlschRyNx3kbCTWgY/2hcwtHEI/ej2LJWc9JJ77qKgGptd8DHwY1mXtZ7Aoh4z4yxfwMBue9eNgw==
   dependencies:
     postcss-selector-parser "^7.0.0"
 
 postcss-calc@^9.0.1:
   version "9.0.1"
-  resolved "https://registry.npmjs.org/postcss-calc/-/postcss-calc-9.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-calc/-/postcss-calc-9.0.1.tgz"
   integrity sha512-TipgjGyzP5QzEhsOZUaIkeO5mKeMFpebWzRogWG/ysonUlnHcq5aJe0jOjpfzUU8PeSaBQnrE8ehR0QA5vs8PQ==
   dependencies:
     postcss-selector-parser "^6.0.11"
@@ -6851,25 +6993,25 @@ postcss-calc@^9.0.1:
 
 postcss-clamp@^4.1.0:
   version "4.1.0"
-  resolved "https://registry.npmjs.org/postcss-clamp/-/postcss-clamp-4.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-clamp/-/postcss-clamp-4.1.0.tgz"
   integrity sha512-ry4b1Llo/9zz+PKC+030KUnPITTJAHeOwjfAyyB60eT0AorGLdzp52s31OsPRHRf8NchkgFoG2y6fCfn1IV1Ow==
   dependencies:
     postcss-value-parser "^4.2.0"
 
-postcss-color-functional-notation@^7.0.7:
-  version "7.0.7"
-  resolved "https://registry.npmjs.org/postcss-color-functional-notation/-/postcss-color-functional-notation-7.0.7.tgz"
-  integrity sha512-EZvAHsvyASX63vXnyXOIynkxhaHRSsdb7z6yiXKIovGXAolW4cMZ3qoh7k3VdTsLBS6VGdksGfIo3r6+waLoOw==
+postcss-color-functional-notation@^7.0.12:
+  version "7.0.12"
+  resolved "https://registry.yarnpkg.com/postcss-color-functional-notation/-/postcss-color-functional-notation-7.0.12.tgz"
+  integrity sha512-TLCW9fN5kvO/u38/uesdpbx3e8AkTYhMvDZYa9JpmImWuTE99bDQ7GU7hdOADIZsiI9/zuxfAJxny/khknp1Zw==
   dependencies:
-    "@csstools/css-color-parser" "^3.0.7"
-    "@csstools/css-parser-algorithms" "^3.0.4"
-    "@csstools/css-tokenizer" "^3.0.3"
-    "@csstools/postcss-progressive-custom-properties" "^4.0.0"
+    "@csstools/css-color-parser" "^3.1.0"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
+    "@csstools/postcss-progressive-custom-properties" "^4.2.1"
     "@csstools/utilities" "^2.0.0"
 
 postcss-color-hex-alpha@^10.0.0:
   version "10.0.0"
-  resolved "https://registry.npmjs.org/postcss-color-hex-alpha/-/postcss-color-hex-alpha-10.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-color-hex-alpha/-/postcss-color-hex-alpha-10.0.0.tgz"
   integrity sha512-1kervM2cnlgPs2a8Vt/Qbe5cQ++N7rkYo/2rz2BkqJZIHQwaVuJgQH38REHrAi4uM0b1fqxMkWYmese94iMp3w==
   dependencies:
     "@csstools/utilities" "^2.0.0"
@@ -6877,7 +7019,7 @@ postcss-color-hex-alpha@^10.0.0:
 
 postcss-color-rebeccapurple@^10.0.0:
   version "10.0.0"
-  resolved "https://registry.npmjs.org/postcss-color-rebeccapurple/-/postcss-color-rebeccapurple-10.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-color-rebeccapurple/-/postcss-color-rebeccapurple-10.0.0.tgz"
   integrity sha512-JFta737jSP+hdAIEhk1Vs0q0YF5P8fFcj+09pweS8ktuGuZ8pPlykHsk6mPxZ8awDl4TrcxUqJo9l1IhVr/OjQ==
   dependencies:
     "@csstools/utilities" "^2.0.0"
@@ -6885,7 +7027,7 @@ postcss-color-rebeccapurple@^10.0.0:
 
 postcss-colormin@^6.1.0:
   version "6.1.0"
-  resolved "https://registry.npmjs.org/postcss-colormin/-/postcss-colormin-6.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-colormin/-/postcss-colormin-6.1.0.tgz"
   integrity sha512-x9yX7DOxeMAR+BgGVnNSAxmAj98NX/YxEMNFP+SDCEeNLb2r3i6Hh1ksMsnW8Ub5SLCpbescQqn9YEbE9554Sw==
   dependencies:
     browserslist "^4.23.0"
@@ -6895,148 +7037,148 @@ postcss-colormin@^6.1.0:
 
 postcss-convert-values@^6.1.0:
   version "6.1.0"
-  resolved "https://registry.npmjs.org/postcss-convert-values/-/postcss-convert-values-6.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-convert-values/-/postcss-convert-values-6.1.0.tgz"
   integrity sha512-zx8IwP/ts9WvUM6NkVSkiU902QZL1bwPhaVaLynPtCsOTqp+ZKbNi+s6XJg3rfqpKGA/oc7Oxk5t8pOQJcwl/w==
   dependencies:
     browserslist "^4.23.0"
     postcss-value-parser "^4.2.0"
 
-postcss-custom-media@^11.0.5:
-  version "11.0.5"
-  resolved "https://registry.npmjs.org/postcss-custom-media/-/postcss-custom-media-11.0.5.tgz"
-  integrity sha512-SQHhayVNgDvSAdX9NQ/ygcDQGEY+aSF4b/96z7QUX6mqL5yl/JgG/DywcF6fW9XbnCRE+aVYk+9/nqGuzOPWeQ==
-  dependencies:
-    "@csstools/cascade-layer-name-parser" "^2.0.4"
-    "@csstools/css-parser-algorithms" "^3.0.4"
-    "@csstools/css-tokenizer" "^3.0.3"
-    "@csstools/media-query-list-parser" "^4.0.2"
-
-postcss-custom-properties@^14.0.4:
-  version "14.0.4"
-  resolved "https://registry.npmjs.org/postcss-custom-properties/-/postcss-custom-properties-14.0.4.tgz"
-  integrity sha512-QnW8FCCK6q+4ierwjnmXF9Y9KF8q0JkbgVfvQEMa93x1GT8FvOiUevWCN2YLaOWyByeDX8S6VFbZEeWoAoXs2A==
-  dependencies:
-    "@csstools/cascade-layer-name-parser" "^2.0.4"
-    "@csstools/css-parser-algorithms" "^3.0.4"
-    "@csstools/css-tokenizer" "^3.0.3"
+postcss-custom-media@^11.0.6:
+  version "11.0.6"
+  resolved "https://registry.yarnpkg.com/postcss-custom-media/-/postcss-custom-media-11.0.6.tgz"
+  integrity sha512-C4lD4b7mUIw+RZhtY7qUbf4eADmb7Ey8BFA2px9jUbwg7pjTZDl4KY4bvlUV+/vXQvzQRfiGEVJyAbtOsCMInw==
+  dependencies:
+    "@csstools/cascade-layer-name-parser" "^2.0.5"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
+    "@csstools/media-query-list-parser" "^4.0.3"
+
+postcss-custom-properties@^14.0.6:
+  version "14.0.6"
+  resolved "https://registry.yarnpkg.com/postcss-custom-properties/-/postcss-custom-properties-14.0.6.tgz"
+  integrity sha512-fTYSp3xuk4BUeVhxCSJdIPhDLpJfNakZKoiTDx7yRGCdlZrSJR7mWKVOBS4sBF+5poPQFMj2YdXx1VHItBGihQ==
+  dependencies:
+    "@csstools/cascade-layer-name-parser" "^2.0.5"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
     "@csstools/utilities" "^2.0.0"
     postcss-value-parser "^4.2.0"
 
-postcss-custom-selectors@^8.0.4:
-  version "8.0.4"
-  resolved "https://registry.npmjs.org/postcss-custom-selectors/-/postcss-custom-selectors-8.0.4.tgz"
-  integrity sha512-ASOXqNvDCE0dAJ/5qixxPeL1aOVGHGW2JwSy7HyjWNbnWTQCl+fDc968HY1jCmZI0+BaYT5CxsOiUhavpG/7eg==
+postcss-custom-selectors@^8.0.5:
+  version "8.0.5"
+  resolved "https://registry.yarnpkg.com/postcss-custom-selectors/-/postcss-custom-selectors-8.0.5.tgz"
+  integrity sha512-9PGmckHQswiB2usSO6XMSswO2yFWVoCAuih1yl9FVcwkscLjRKjwsjM3t+NIWpSU2Jx3eOiK2+t4vVTQaoCHHg==
   dependencies:
-    "@csstools/cascade-layer-name-parser" "^2.0.4"
-    "@csstools/css-parser-algorithms" "^3.0.4"
-    "@csstools/css-tokenizer" "^3.0.3"
+    "@csstools/cascade-layer-name-parser" "^2.0.5"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
     postcss-selector-parser "^7.0.0"
 
 postcss-dir-pseudo-class@^9.0.1:
   version "9.0.1"
-  resolved "https://registry.npmjs.org/postcss-dir-pseudo-class/-/postcss-dir-pseudo-class-9.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-dir-pseudo-class/-/postcss-dir-pseudo-class-9.0.1.tgz"
   integrity sha512-tRBEK0MHYvcMUrAuYMEOa0zg9APqirBcgzi6P21OhxtJyJADo/SWBwY1CAwEohQ/6HDaa9jCjLRG7K3PVQYHEA==
   dependencies:
     postcss-selector-parser "^7.0.0"
 
 postcss-discard-comments@^6.0.2:
   version "6.0.2"
-  resolved "https://registry.npmjs.org/postcss-discard-comments/-/postcss-discard-comments-6.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-discard-comments/-/postcss-discard-comments-6.0.2.tgz"
   integrity sha512-65w/uIqhSBBfQmYnG92FO1mWZjJ4GL5b8atm5Yw2UgrwD7HiNiSSNwJor1eCFGzUgYnN/iIknhNRVqjrrpuglw==
 
 postcss-discard-duplicates@^6.0.3:
   version "6.0.3"
-  resolved "https://registry.npmjs.org/postcss-discard-duplicates/-/postcss-discard-duplicates-6.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-discard-duplicates/-/postcss-discard-duplicates-6.0.3.tgz"
   integrity sha512-+JA0DCvc5XvFAxwx6f/e68gQu/7Z9ud584VLmcgto28eB8FqSFZwtrLwB5Kcp70eIoWP/HXqz4wpo8rD8gpsTw==
 
 postcss-discard-empty@^6.0.3:
   version "6.0.3"
-  resolved "https://registry.npmjs.org/postcss-discard-empty/-/postcss-discard-empty-6.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-discard-empty/-/postcss-discard-empty-6.0.3.tgz"
   integrity sha512-znyno9cHKQsK6PtxL5D19Fj9uwSzC2mB74cpT66fhgOadEUPyXFkbgwm5tvc3bt3NAy8ltE5MrghxovZRVnOjQ==
 
 postcss-discard-overridden@^6.0.2:
   version "6.0.2"
-  resolved "https://registry.npmjs.org/postcss-discard-overridden/-/postcss-discard-overridden-6.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-discard-overridden/-/postcss-discard-overridden-6.0.2.tgz"
   integrity sha512-j87xzI4LUggC5zND7KdjsI25APtyMuynXZSujByMaav2roV6OZX+8AaCUcZSWqckZpjAjRyFDdpqybgjFO0HJQ==
 
 postcss-discard-unused@^6.0.5:
   version "6.0.5"
-  resolved "https://registry.npmjs.org/postcss-discard-unused/-/postcss-discard-unused-6.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-discard-unused/-/postcss-discard-unused-6.0.5.tgz"
   integrity sha512-wHalBlRHkaNnNwfC8z+ppX57VhvS+HWgjW508esjdaEYr3Mx7Gnn2xA4R/CKf5+Z9S5qsqC+Uzh4ueENWwCVUA==
   dependencies:
     postcss-selector-parser "^6.0.16"
 
-postcss-double-position-gradients@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.npmjs.org/postcss-double-position-gradients/-/postcss-double-position-gradients-6.0.0.tgz"
-  integrity sha512-JkIGah3RVbdSEIrcobqj4Gzq0h53GG4uqDPsho88SgY84WnpkTpI0k50MFK/sX7XqVisZ6OqUfFnoUO6m1WWdg==
+postcss-double-position-gradients@^6.0.4:
+  version "6.0.4"
+  resolved "https://registry.yarnpkg.com/postcss-double-position-gradients/-/postcss-double-position-gradients-6.0.4.tgz"
+  integrity sha512-m6IKmxo7FxSP5nF2l63QbCC3r+bWpFUWmZXZf096WxG0m7Vl1Q1+ruFOhpdDRmKrRS+S3Jtk+TVk/7z0+BVK6g==
   dependencies:
-    "@csstools/postcss-progressive-custom-properties" "^4.0.0"
+    "@csstools/postcss-progressive-custom-properties" "^4.2.1"
     "@csstools/utilities" "^2.0.0"
     postcss-value-parser "^4.2.0"
 
 postcss-focus-visible@^10.0.1:
   version "10.0.1"
-  resolved "https://registry.npmjs.org/postcss-focus-visible/-/postcss-focus-visible-10.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-focus-visible/-/postcss-focus-visible-10.0.1.tgz"
   integrity sha512-U58wyjS/I1GZgjRok33aE8juW9qQgQUNwTSdxQGuShHzwuYdcklnvK/+qOWX1Q9kr7ysbraQ6ht6r+udansalA==
   dependencies:
     postcss-selector-parser "^7.0.0"
 
 postcss-focus-within@^9.0.1:
   version "9.0.1"
-  resolved "https://registry.npmjs.org/postcss-focus-within/-/postcss-focus-within-9.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-focus-within/-/postcss-focus-within-9.0.1.tgz"
   integrity sha512-fzNUyS1yOYa7mOjpci/bR+u+ESvdar6hk8XNK/TRR0fiGTp2QT5N+ducP0n3rfH/m9I7H/EQU6lsa2BrgxkEjw==
   dependencies:
     postcss-selector-parser "^7.0.0"
 
 postcss-font-variant@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.npmjs.org/postcss-font-variant/-/postcss-font-variant-5.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-font-variant/-/postcss-font-variant-5.0.0.tgz"
   integrity sha512-1fmkBaCALD72CK2a9i468mA/+tr9/1cBxRRMXOUaZqO43oWPR5imcyPjXwuv7PXbCid4ndlP5zWhidQVVa3hmA==
 
 postcss-gap-properties@^6.0.0:
   version "6.0.0"
-  resolved "https://registry.npmjs.org/postcss-gap-properties/-/postcss-gap-properties-6.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-gap-properties/-/postcss-gap-properties-6.0.0.tgz"
   integrity sha512-Om0WPjEwiM9Ru+VhfEDPZJAKWUd0mV1HmNXqp2C29z80aQ2uP9UVhLc7e3aYMIor/S5cVhoPgYQ7RtfeZpYTRw==
 
 postcss-image-set-function@^7.0.0:
   version "7.0.0"
-  resolved "https://registry.npmjs.org/postcss-image-set-function/-/postcss-image-set-function-7.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-image-set-function/-/postcss-image-set-function-7.0.0.tgz"
   integrity sha512-QL7W7QNlZuzOwBTeXEmbVckNt1FSmhQtbMRvGGqqU4Nf4xk6KUEQhAoWuMzwbSv5jxiRiSZ5Tv7eiDB9U87znA==
   dependencies:
     "@csstools/utilities" "^2.0.0"
     postcss-value-parser "^4.2.0"
 
-postcss-lab-function@^7.0.7:
-  version "7.0.7"
-  resolved "https://registry.npmjs.org/postcss-lab-function/-/postcss-lab-function-7.0.7.tgz"
-  integrity sha512-+ONj2bpOQfsCKZE2T9VGMyVVdGcGUpr7u3SVfvkJlvhTRmDCfY25k4Jc8fubB9DclAPR4+w8uVtDZmdRgdAHig==
+postcss-lab-function@^7.0.12:
+  version "7.0.12"
+  resolved "https://registry.yarnpkg.com/postcss-lab-function/-/postcss-lab-function-7.0.12.tgz"
+  integrity sha512-tUcyRk1ZTPec3OuKFsqtRzW2Go5lehW29XA21lZ65XmzQkz43VY2tyWEC202F7W3mILOjw0voOiuxRGTsN+J9w==
   dependencies:
-    "@csstools/css-color-parser" "^3.0.7"
-    "@csstools/css-parser-algorithms" "^3.0.4"
-    "@csstools/css-tokenizer" "^3.0.3"
-    "@csstools/postcss-progressive-custom-properties" "^4.0.0"
+    "@csstools/css-color-parser" "^3.1.0"
+    "@csstools/css-parser-algorithms" "^3.0.5"
+    "@csstools/css-tokenizer" "^3.0.4"
+    "@csstools/postcss-progressive-custom-properties" "^4.2.1"
     "@csstools/utilities" "^2.0.0"
 
-postcss-loader@^7.3.3:
+postcss-loader@^7.3.4:
   version "7.3.4"
-  resolved "https://registry.npmjs.org/postcss-loader/-/postcss-loader-7.3.4.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-loader/-/postcss-loader-7.3.4.tgz"
   integrity sha512-iW5WTTBSC5BfsBJ9daFMPVrLT36MrNiC6fqOZTTaHjBNX6Pfd5p+hSBqe/fEeNd7pc13QiAyGt7VdGMw4eRC4A==
   dependencies:
     cosmiconfig "^8.3.5"
     jiti "^1.20.0"
     semver "^7.5.4"
 
-postcss-logical@^8.0.0:
-  version "8.0.0"
-  resolved "https://registry.npmjs.org/postcss-logical/-/postcss-logical-8.0.0.tgz"
-  integrity sha512-HpIdsdieClTjXLOyYdUPAX/XQASNIwdKt5hoZW08ZOAiI+tbV0ta1oclkpVkW5ANU+xJvk3KkA0FejkjGLXUkg==
+postcss-logical@^8.1.0:
+  version "8.1.0"
+  resolved "https://registry.yarnpkg.com/postcss-logical/-/postcss-logical-8.1.0.tgz"
+  integrity sha512-pL1hXFQ2fEXNKiNiAgtfA005T9FBxky5zkX6s4GZM2D8RkVgRqz3f4g1JUoq925zXv495qk8UNldDwh8uGEDoA==
   dependencies:
     postcss-value-parser "^4.2.0"
 
 postcss-merge-idents@^6.0.3:
   version "6.0.3"
-  resolved "https://registry.npmjs.org/postcss-merge-idents/-/postcss-merge-idents-6.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-merge-idents/-/postcss-merge-idents-6.0.3.tgz"
   integrity sha512-1oIoAsODUs6IHQZkLQGO15uGEbK3EAl5wi9SS8hs45VgsxQfMnxvt+L+zIr7ifZFIH14cfAeVe2uCTa+SPRa3g==
   dependencies:
     cssnano-utils "^4.0.2"
@@ -7044,7 +7186,7 @@ postcss-merge-idents@^6.0.3:
 
 postcss-merge-longhand@^6.0.5:
   version "6.0.5"
-  resolved "https://registry.npmjs.org/postcss-merge-longhand/-/postcss-merge-longhand-6.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-merge-longhand/-/postcss-merge-longhand-6.0.5.tgz"
   integrity sha512-5LOiordeTfi64QhICp07nzzuTDjNSO8g5Ksdibt44d+uvIIAE1oZdRn8y/W5ZtYgRH/lnLDlvi9F8btZcVzu3w==
   dependencies:
     postcss-value-parser "^4.2.0"
@@ -7052,7 +7194,7 @@ postcss-merge-longhand@^6.0.5:
 
 postcss-merge-rules@^6.1.1:
   version "6.1.1"
-  resolved "https://registry.npmjs.org/postcss-merge-rules/-/postcss-merge-rules-6.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-merge-rules/-/postcss-merge-rules-6.1.1.tgz"
   integrity sha512-KOdWF0gju31AQPZiD+2Ar9Qjowz1LTChSjFFbS+e2sFgc4uHOp3ZvVX4sNeTlk0w2O31ecFGgrFzhO0RSWbWwQ==
   dependencies:
     browserslist "^4.23.0"
@@ -7062,14 +7204,14 @@ postcss-merge-rules@^6.1.1:
 
 postcss-minify-font-values@^6.1.0:
   version "6.1.0"
-  resolved "https://registry.npmjs.org/postcss-minify-font-values/-/postcss-minify-font-values-6.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-minify-font-values/-/postcss-minify-font-values-6.1.0.tgz"
   integrity sha512-gklfI/n+9rTh8nYaSJXlCo3nOKqMNkxuGpTn/Qm0gstL3ywTr9/WRKznE+oy6fvfolH6dF+QM4nCo8yPLdvGJg==
   dependencies:
     postcss-value-parser "^4.2.0"
 
 postcss-minify-gradients@^6.0.3:
   version "6.0.3"
-  resolved "https://registry.npmjs.org/postcss-minify-gradients/-/postcss-minify-gradients-6.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-minify-gradients/-/postcss-minify-gradients-6.0.3.tgz"
   integrity sha512-4KXAHrYlzF0Rr7uc4VrfwDJ2ajrtNEpNEuLxFgwkhFZ56/7gaE4Nr49nLsQDZyUe+ds+kEhf+YAUolJiYXF8+Q==
   dependencies:
     colord "^2.9.3"
@@ -7078,7 +7220,7 @@ postcss-minify-gradients@^6.0.3:
 
 postcss-minify-params@^6.1.0:
   version "6.1.0"
-  resolved "https://registry.npmjs.org/postcss-minify-params/-/postcss-minify-params-6.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-minify-params/-/postcss-minify-params-6.1.0.tgz"
   integrity sha512-bmSKnDtyyE8ujHQK0RQJDIKhQ20Jq1LYiez54WiaOoBtcSuflfK3Nm596LvbtlFcpipMjgClQGyGr7GAs+H1uA==
   dependencies:
     browserslist "^4.23.0"
@@ -7087,19 +7229,19 @@ postcss-minify-params@^6.1.0:
 
 postcss-minify-selectors@^6.0.4:
   version "6.0.4"
-  resolved "https://registry.npmjs.org/postcss-minify-selectors/-/postcss-minify-selectors-6.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-minify-selectors/-/postcss-minify-selectors-6.0.4.tgz"
   integrity sha512-L8dZSwNLgK7pjTto9PzWRoMbnLq5vsZSTu8+j1P/2GB8qdtGQfn+K1uSvFgYvgh83cbyxT5m43ZZhUMTJDSClQ==
   dependencies:
     postcss-selector-parser "^6.0.16"
 
 postcss-modules-extract-imports@^3.1.0:
   version "3.1.0"
-  resolved "https://registry.npmjs.org/postcss-modules-extract-imports/-/postcss-modules-extract-imports-3.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-modules-extract-imports/-/postcss-modules-extract-imports-3.1.0.tgz"
   integrity sha512-k3kNe0aNFQDAZGbin48pL2VNidTF0w4/eASDsxlyspobzU3wZQLOGj7L9gfRe0Jo9/4uud09DsjFNH7winGv8Q==
 
 postcss-modules-local-by-default@^4.0.5:
   version "4.2.0"
-  resolved "https://registry.npmjs.org/postcss-modules-local-by-default/-/postcss-modules-local-by-default-4.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-modules-local-by-default/-/postcss-modules-local-by-default-4.2.0.tgz"
   integrity sha512-5kcJm/zk+GJDSfw+V/42fJ5fhjL5YbFDl8nVdXkJPLLW+Vf9mTD5Xe0wqIaDnLuL2U6cDNpTr+UQ+v2HWIBhzw==
   dependencies:
     icss-utils "^5.0.0"
@@ -7108,70 +7250,70 @@ postcss-modules-local-by-default@^4.0.5:
 
 postcss-modules-scope@^3.2.0:
   version "3.2.1"
-  resolved "https://registry.npmjs.org/postcss-modules-scope/-/postcss-modules-scope-3.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-modules-scope/-/postcss-modules-scope-3.2.1.tgz"
   integrity sha512-m9jZstCVaqGjTAuny8MdgE88scJnCiQSlSrOWcTQgM2t32UBe+MUmFSO5t7VMSfAf/FJKImAxBav8ooCHJXCJA==
   dependencies:
     postcss-selector-parser "^7.0.0"
 
 postcss-modules-values@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/postcss-modules-values/-/postcss-modules-values-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-modules-values/-/postcss-modules-values-4.0.0.tgz"
   integrity sha512-RDxHkAiEGI78gS2ofyvCsu7iycRv7oqw5xMWn9iMoR0N/7mf9D50ecQqUo5BZ9Zh2vH4bCUR/ktCqbB9m8vJjQ==
   dependencies:
     icss-utils "^5.0.0"
 
-postcss-nesting@^13.0.1:
-  version "13.0.1"
-  resolved "https://registry.npmjs.org/postcss-nesting/-/postcss-nesting-13.0.1.tgz"
-  integrity sha512-VbqqHkOBOt4Uu3G8Dm8n6lU5+9cJFxiuty9+4rcoyRPO9zZS1JIs6td49VIoix3qYqELHlJIn46Oih9SAKo+yQ==
+postcss-nesting@^13.0.2:
+  version "13.0.2"
+  resolved "https://registry.yarnpkg.com/postcss-nesting/-/postcss-nesting-13.0.2.tgz"
+  integrity sha512-1YCI290TX+VP0U/K/aFxzHzQWHWURL+CtHMSbex1lCdpXD1SoR2sYuxDu5aNI9lPoXpKTCggFZiDJbwylU0LEQ==
   dependencies:
-    "@csstools/selector-resolve-nested" "^3.0.0"
+    "@csstools/selector-resolve-nested" "^3.1.0"
     "@csstools/selector-specificity" "^5.0.0"
     postcss-selector-parser "^7.0.0"
 
 postcss-normalize-charset@^6.0.2:
   version "6.0.2"
-  resolved "https://registry.npmjs.org/postcss-normalize-charset/-/postcss-normalize-charset-6.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-normalize-charset/-/postcss-normalize-charset-6.0.2.tgz"
   integrity sha512-a8N9czmdnrjPHa3DeFlwqst5eaL5W8jYu3EBbTTkI5FHkfMhFZh1EGbku6jhHhIzTA6tquI2P42NtZ59M/H/kQ==
 
 postcss-normalize-display-values@^6.0.2:
   version "6.0.2"
-  resolved "https://registry.npmjs.org/postcss-normalize-display-values/-/postcss-normalize-display-values-6.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-normalize-display-values/-/postcss-normalize-display-values-6.0.2.tgz"
   integrity sha512-8H04Mxsb82ON/aAkPeq8kcBbAtI5Q2a64X/mnRRfPXBq7XeogoQvReqxEfc0B4WPq1KimjezNC8flUtC3Qz6jg==
   dependencies:
     postcss-value-parser "^4.2.0"
 
 postcss-normalize-positions@^6.0.2:
   version "6.0.2"
-  resolved "https://registry.npmjs.org/postcss-normalize-positions/-/postcss-normalize-positions-6.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-normalize-positions/-/postcss-normalize-positions-6.0.2.tgz"
   integrity sha512-/JFzI441OAB9O7VnLA+RtSNZvQ0NCFZDOtp6QPFo1iIyawyXg0YI3CYM9HBy1WvwCRHnPep/BvI1+dGPKoXx/Q==
   dependencies:
     postcss-value-parser "^4.2.0"
 
 postcss-normalize-repeat-style@^6.0.2:
   version "6.0.2"
-  resolved "https://registry.npmjs.org/postcss-normalize-repeat-style/-/postcss-normalize-repeat-style-6.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-normalize-repeat-style/-/postcss-normalize-repeat-style-6.0.2.tgz"
   integrity sha512-YdCgsfHkJ2jEXwR4RR3Tm/iOxSfdRt7jplS6XRh9Js9PyCR/aka/FCb6TuHT2U8gQubbm/mPmF6L7FY9d79VwQ==
   dependencies:
     postcss-value-parser "^4.2.0"
 
 postcss-normalize-string@^6.0.2:
   version "6.0.2"
-  resolved "https://registry.npmjs.org/postcss-normalize-string/-/postcss-normalize-string-6.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-normalize-string/-/postcss-normalize-string-6.0.2.tgz"
   integrity sha512-vQZIivlxlfqqMp4L9PZsFE4YUkWniziKjQWUtsxUiVsSSPelQydwS8Wwcuw0+83ZjPWNTl02oxlIvXsmmG+CiQ==
   dependencies:
     postcss-value-parser "^4.2.0"
 
 postcss-normalize-timing-functions@^6.0.2:
   version "6.0.2"
-  resolved "https://registry.npmjs.org/postcss-normalize-timing-functions/-/postcss-normalize-timing-functions-6.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-normalize-timing-functions/-/postcss-normalize-timing-functions-6.0.2.tgz"
   integrity sha512-a+YrtMox4TBtId/AEwbA03VcJgtyW4dGBizPl7e88cTFULYsprgHWTbfyjSLyHeBcK/Q9JhXkt2ZXiwaVHoMzA==
   dependencies:
     postcss-value-parser "^4.2.0"
 
 postcss-normalize-unicode@^6.1.0:
   version "6.1.0"
-  resolved "https://registry.npmjs.org/postcss-normalize-unicode/-/postcss-normalize-unicode-6.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-normalize-unicode/-/postcss-normalize-unicode-6.1.0.tgz"
   integrity sha512-QVC5TQHsVj33otj8/JD869Ndr5Xcc/+fwRh4HAsFsAeygQQXm+0PySrKbr/8tkDKzW+EVT3QkqZMfFrGiossDg==
   dependencies:
     browserslist "^4.23.0"
@@ -7179,26 +7321,26 @@ postcss-normalize-unicode@^6.1.0:
 
 postcss-normalize-url@^6.0.2:
   version "6.0.2"
-  resolved "https://registry.npmjs.org/postcss-normalize-url/-/postcss-normalize-url-6.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-normalize-url/-/postcss-normalize-url-6.0.2.tgz"
   integrity sha512-kVNcWhCeKAzZ8B4pv/DnrU1wNh458zBNp8dh4y5hhxih5RZQ12QWMuQrDgPRw3LRl8mN9vOVfHl7uhvHYMoXsQ==
   dependencies:
     postcss-value-parser "^4.2.0"
 
 postcss-normalize-whitespace@^6.0.2:
   version "6.0.2"
-  resolved "https://registry.npmjs.org/postcss-normalize-whitespace/-/postcss-normalize-whitespace-6.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-normalize-whitespace/-/postcss-normalize-whitespace-6.0.2.tgz"
   integrity sha512-sXZ2Nj1icbJOKmdjXVT9pnyHQKiSAyuNQHSgRCUgThn2388Y9cGVDR+E9J9iAYbSbLHI+UUwLVl1Wzco/zgv0Q==
   dependencies:
     postcss-value-parser "^4.2.0"
 
 postcss-opacity-percentage@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/postcss-opacity-percentage/-/postcss-opacity-percentage-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-opacity-percentage/-/postcss-opacity-percentage-3.0.0.tgz"
   integrity sha512-K6HGVzyxUxd/VgZdX04DCtdwWJ4NGLG212US4/LA1TLAbHgmAsTWVR86o+gGIbFtnTkfOpb9sCRBx8K7HO66qQ==
 
 postcss-ordered-values@^6.0.2:
   version "6.0.2"
-  resolved "https://registry.npmjs.org/postcss-ordered-values/-/postcss-ordered-values-6.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-ordered-values/-/postcss-ordered-values-6.0.2.tgz"
   integrity sha512-VRZSOB+JU32RsEAQrO94QPkClGPKJEL/Z9PCBImXMhIeK5KAYo6slP/hBYlLgrCjFxyqvn5VC81tycFEDBLG1Q==
   dependencies:
     cssnano-utils "^4.0.2"
@@ -7206,84 +7348,92 @@ postcss-ordered-values@^6.0.2:
 
 postcss-overflow-shorthand@^6.0.0:
   version "6.0.0"
-  resolved "https://registry.npmjs.org/postcss-overflow-shorthand/-/postcss-overflow-shorthand-6.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-overflow-shorthand/-/postcss-overflow-shorthand-6.0.0.tgz"
   integrity sha512-BdDl/AbVkDjoTofzDQnwDdm/Ym6oS9KgmO7Gr+LHYjNWJ6ExORe4+3pcLQsLA9gIROMkiGVjjwZNoL/mpXHd5Q==
   dependencies:
     postcss-value-parser "^4.2.0"
 
 postcss-page-break@^3.0.4:
   version "3.0.4"
-  resolved "https://registry.npmjs.org/postcss-page-break/-/postcss-page-break-3.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-page-break/-/postcss-page-break-3.0.4.tgz"
   integrity sha512-1JGu8oCjVXLa9q9rFTo4MbeeA5FMe00/9C7lN4va606Rdb+HkxXtXsmEDrIraQ11fGz/WvKWa8gMuCKkrXpTsQ==
 
 postcss-place@^10.0.0:
   version "10.0.0"
-  resolved "https://registry.npmjs.org/postcss-place/-/postcss-place-10.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-place/-/postcss-place-10.0.0.tgz"
   integrity sha512-5EBrMzat2pPAxQNWYavwAfoKfYcTADJ8AXGVPcUZ2UkNloUTWzJQExgrzrDkh3EKzmAx1evfTAzF9I8NGcc+qw==
   dependencies:
     postcss-value-parser "^4.2.0"
 
-postcss-preset-env@^10.1.0:
-  version "10.1.3"
-  resolved "https://registry.npmjs.org/postcss-preset-env/-/postcss-preset-env-10.1.3.tgz"
-  integrity sha512-9qzVhcMFU/MnwYHyYpJz4JhGku/4+xEiPTmhn0hj3IxnUYlEF9vbh7OC1KoLAnenS6Fgg43TKNp9xcuMeAi4Zw==
-  dependencies:
-    "@csstools/postcss-cascade-layers" "^5.0.1"
-    "@csstools/postcss-color-function" "^4.0.7"
-    "@csstools/postcss-color-mix-function" "^3.0.7"
-    "@csstools/postcss-content-alt-text" "^2.0.4"
-    "@csstools/postcss-exponential-functions" "^2.0.6"
+postcss-preset-env@^10.2.1:
+  version "10.6.1"
+  resolved "https://registry.yarnpkg.com/postcss-preset-env/-/postcss-preset-env-10.6.1.tgz"
+  integrity sha512-yrk74d9EvY+W7+lO9Aj1QmjWY9q5NsKjK2V9drkOPZB/X6KZ0B3igKsHUYakb7oYVhnioWypQX3xGuePf89f3g==
+  dependencies:
+    "@csstools/postcss-alpha-function" "^1.0.1"
+    "@csstools/postcss-cascade-layers" "^5.0.2"
+    "@csstools/postcss-color-function" "^4.0.12"
+    "@csstools/postcss-color-function-display-p3-linear" "^1.0.1"
+    "@csstools/postcss-color-mix-function" "^3.0.12"
+    "@csstools/postcss-color-mix-variadic-function-arguments" "^1.0.2"
+    "@csstools/postcss-content-alt-text" "^2.0.8"
+    "@csstools/postcss-contrast-color-function" "^2.0.12"
+    "@csstools/postcss-exponential-functions" "^2.0.9"
     "@csstools/postcss-font-format-keywords" "^4.0.0"
-    "@csstools/postcss-gamut-mapping" "^2.0.7"
-    "@csstools/postcss-gradients-interpolation-method" "^5.0.7"
-    "@csstools/postcss-hwb-function" "^4.0.7"
-    "@csstools/postcss-ic-unit" "^4.0.0"
-    "@csstools/postcss-initial" "^2.0.0"
-    "@csstools/postcss-is-pseudo-class" "^5.0.1"
-    "@csstools/postcss-light-dark-function" "^2.0.7"
+    "@csstools/postcss-gamut-mapping" "^2.0.11"
+    "@csstools/postcss-gradients-interpolation-method" "^5.0.12"
+    "@csstools/postcss-hwb-function" "^4.0.12"
+    "@csstools/postcss-ic-unit" "^4.0.4"
+    "@csstools/postcss-initial" "^2.0.1"
+    "@csstools/postcss-is-pseudo-class" "^5.0.3"
+    "@csstools/postcss-light-dark-function" "^2.0.11"
     "@csstools/postcss-logical-float-and-clear" "^3.0.0"
     "@csstools/postcss-logical-overflow" "^2.0.0"
     "@csstools/postcss-logical-overscroll-behavior" "^2.0.0"
     "@csstools/postcss-logical-resize" "^3.0.0"
-    "@csstools/postcss-logical-viewport-units" "^3.0.3"
-    "@csstools/postcss-media-minmax" "^2.0.6"
-    "@csstools/postcss-media-queries-aspect-ratio-number-values" "^3.0.4"
+    "@csstools/postcss-logical-viewport-units" "^3.0.4"
+    "@csstools/postcss-media-minmax" "^2.0.9"
+    "@csstools/postcss-media-queries-aspect-ratio-number-values" "^3.0.5"
     "@csstools/postcss-nested-calc" "^4.0.0"
-    "@csstools/postcss-normalize-display-values" "^4.0.0"
-    "@csstools/postcss-oklab-function" "^4.0.7"
-    "@csstools/postcss-progressive-custom-properties" "^4.0.0"
-    "@csstools/postcss-random-function" "^1.0.2"
-    "@csstools/postcss-relative-color-syntax" "^3.0.7"
+    "@csstools/postcss-normalize-display-values" "^4.0.1"
+    "@csstools/postcss-oklab-function" "^4.0.12"
+    "@csstools/postcss-position-area-property" "^1.0.0"
+    "@csstools/postcss-progressive-custom-properties" "^4.2.1"
+    "@csstools/postcss-property-rule-prelude-list" "^1.0.0"
+    "@csstools/postcss-random-function" "^2.0.1"
+    "@csstools/postcss-relative-color-syntax" "^3.0.12"
     "@csstools/postcss-scope-pseudo-class" "^4.0.1"
-    "@csstools/postcss-sign-functions" "^1.1.1"
-    "@csstools/postcss-stepped-value-functions" "^4.0.6"
-    "@csstools/postcss-text-decoration-shorthand" "^4.0.1"
-    "@csstools/postcss-trigonometric-functions" "^4.0.6"
+    "@csstools/postcss-sign-functions" "^1.1.4"
+    "@csstools/postcss-stepped-value-functions" "^4.0.9"
+    "@csstools/postcss-syntax-descriptor-syntax-production" "^1.0.1"
+    "@csstools/postcss-system-ui-font-family" "^1.0.0"
+    "@csstools/postcss-text-decoration-shorthand" "^4.0.3"
+    "@csstools/postcss-trigonometric-functions" "^4.0.9"
     "@csstools/postcss-unset-value" "^4.0.0"
-    autoprefixer "^10.4.19"
-    browserslist "^4.23.1"
+    autoprefixer "^10.4.23"
+    browserslist "^4.28.1"
     css-blank-pseudo "^7.0.1"
-    css-has-pseudo "^7.0.2"
+    css-has-pseudo "^7.0.3"
     css-prefers-color-scheme "^10.0.0"
-    cssdb "^8.2.3"
+    cssdb "^8.6.0"
     postcss-attribute-case-insensitive "^7.0.1"
     postcss-clamp "^4.1.0"
-    postcss-color-functional-notation "^7.0.7"
+    postcss-color-functional-notation "^7.0.12"
     postcss-color-hex-alpha "^10.0.0"
     postcss-color-rebeccapurple "^10.0.0"
-    postcss-custom-media "^11.0.5"
-    postcss-custom-properties "^14.0.4"
-    postcss-custom-selectors "^8.0.4"
+    postcss-custom-media "^11.0.6"
+    postcss-custom-properties "^14.0.6"
+    postcss-custom-selectors "^8.0.5"
     postcss-dir-pseudo-class "^9.0.1"
-    postcss-double-position-gradients "^6.0.0"
+    postcss-double-position-gradients "^6.0.4"
     postcss-focus-visible "^10.0.1"
     postcss-focus-within "^9.0.1"
     postcss-font-variant "^5.0.0"
     postcss-gap-properties "^6.0.0"
     postcss-image-set-function "^7.0.0"
-    postcss-lab-function "^7.0.7"
-    postcss-logical "^8.0.0"
-    postcss-nesting "^13.0.1"
+    postcss-lab-function "^7.0.12"
+    postcss-logical "^8.1.0"
+    postcss-nesting "^13.0.2"
     postcss-opacity-percentage "^3.0.0"
     postcss-overflow-shorthand "^6.0.0"
     postcss-page-break "^3.0.4"
@@ -7294,21 +7444,21 @@ postcss-preset-env@^10.1.0:
 
 postcss-pseudo-class-any-link@^10.0.1:
   version "10.0.1"
-  resolved "https://registry.npmjs.org/postcss-pseudo-class-any-link/-/postcss-pseudo-class-any-link-10.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-pseudo-class-any-link/-/postcss-pseudo-class-any-link-10.0.1.tgz"
   integrity sha512-3el9rXlBOqTFaMFkWDOkHUTQekFIYnaQY55Rsp8As8QQkpiSgIYEcF/6Ond93oHiDsGb4kad8zjt+NPlOC1H0Q==
   dependencies:
     postcss-selector-parser "^7.0.0"
 
 postcss-reduce-idents@^6.0.3:
   version "6.0.3"
-  resolved "https://registry.npmjs.org/postcss-reduce-idents/-/postcss-reduce-idents-6.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-reduce-idents/-/postcss-reduce-idents-6.0.3.tgz"
   integrity sha512-G3yCqZDpsNPoQgbDUy3T0E6hqOQ5xigUtBQyrmq3tn2GxlyiL0yyl7H+T8ulQR6kOcHJ9t7/9H4/R2tv8tJbMA==
   dependencies:
     postcss-value-parser "^4.2.0"
 
 postcss-reduce-initial@^6.1.0:
   version "6.1.0"
-  resolved "https://registry.npmjs.org/postcss-reduce-initial/-/postcss-reduce-initial-6.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-reduce-initial/-/postcss-reduce-initial-6.1.0.tgz"
   integrity sha512-RarLgBK/CrL1qZags04oKbVbrrVK2wcxhvta3GCxrZO4zveibqbRPmm2VI8sSgCXwoUHEliRSbOfpR0b/VIoiw==
   dependencies:
     browserslist "^4.23.0"
@@ -7316,49 +7466,49 @@ postcss-reduce-initial@^6.1.0:
 
 postcss-reduce-transforms@^6.0.2:
   version "6.0.2"
-  resolved "https://registry.npmjs.org/postcss-reduce-transforms/-/postcss-reduce-transforms-6.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-reduce-transforms/-/postcss-reduce-transforms-6.0.2.tgz"
   integrity sha512-sB+Ya++3Xj1WaT9+5LOOdirAxP7dJZms3GRcYheSPi1PiTMigsxHAdkrbItHxwYHr4kt1zL7mmcHstgMYT+aiA==
   dependencies:
     postcss-value-parser "^4.2.0"
 
 postcss-replace-overflow-wrap@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/postcss-replace-overflow-wrap/-/postcss-replace-overflow-wrap-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-replace-overflow-wrap/-/postcss-replace-overflow-wrap-4.0.0.tgz"
   integrity sha512-KmF7SBPphT4gPPcKZc7aDkweHiKEEO8cla/GjcBK+ckKxiZslIu3C4GCRW3DNfL0o7yW7kMQu9xlZ1kXRXLXtw==
 
 postcss-selector-not@^8.0.1:
   version "8.0.1"
-  resolved "https://registry.npmjs.org/postcss-selector-not/-/postcss-selector-not-8.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-selector-not/-/postcss-selector-not-8.0.1.tgz"
   integrity sha512-kmVy/5PYVb2UOhy0+LqUYAhKj7DUGDpSWa5LZqlkWJaaAV+dxxsOG3+St0yNLu6vsKD7Dmqx+nWQt0iil89+WA==
   dependencies:
     postcss-selector-parser "^7.0.0"
 
 postcss-selector-parser@^6.0.11, postcss-selector-parser@^6.0.16:
   version "6.1.2"
-  resolved "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz"
   integrity sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==
   dependencies:
     cssesc "^3.0.0"
     util-deprecate "^1.0.2"
 
 postcss-selector-parser@^7.0.0:
-  version "7.0.0"
-  resolved "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.0.0.tgz"
-  integrity sha512-9RbEr1Y7FFfptd/1eEdntyjMwLeghW1bHX9GWjXo19vx4ytPQhANltvVxDggzJl7mnWM+dX28kb6cyS/4iQjlQ==
+  version "7.1.1"
+  resolved "https://registry.yarnpkg.com/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz"
+  integrity sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==
   dependencies:
     cssesc "^3.0.0"
     util-deprecate "^1.0.2"
 
 postcss-sort-media-queries@^5.2.0:
   version "5.2.0"
-  resolved "https://registry.npmjs.org/postcss-sort-media-queries/-/postcss-sort-media-queries-5.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-sort-media-queries/-/postcss-sort-media-queries-5.2.0.tgz"
   integrity sha512-AZ5fDMLD8SldlAYlvi8NIqo0+Z8xnXU2ia0jxmuhxAU+Lqt9K+AlmLNJ/zWEnE9x+Zx3qL3+1K20ATgNOr3fAA==
   dependencies:
     sort-css-media-queries "2.2.0"
 
 postcss-svgo@^6.0.3:
   version "6.0.3"
-  resolved "https://registry.npmjs.org/postcss-svgo/-/postcss-svgo-6.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-svgo/-/postcss-svgo-6.0.3.tgz"
   integrity sha512-dlrahRmxP22bX6iKEjOM+c8/1p+81asjKT+V5lrgOH944ryx/OHpclnIbGsKVd3uWOXFLYJwCVf0eEkJGvO96g==
   dependencies:
     postcss-value-parser "^4.2.0"
@@ -7366,33 +7516,33 @@ postcss-svgo@^6.0.3:
 
 postcss-unique-selectors@^6.0.4:
   version "6.0.4"
-  resolved "https://registry.npmjs.org/postcss-unique-selectors/-/postcss-unique-selectors-6.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-unique-selectors/-/postcss-unique-selectors-6.0.4.tgz"
   integrity sha512-K38OCaIrO8+PzpArzkLKB42dSARtC2tmG6PvD4b1o1Q2E9Os8jzfWFfSy/rixsHwohtsDdFtAWGjFVFUdwYaMg==
   dependencies:
     postcss-selector-parser "^6.0.16"
 
 postcss-value-parser@^4.1.0, postcss-value-parser@^4.2.0:
   version "4.2.0"
-  resolved "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz"
   integrity sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==
 
 postcss-zindex@^6.0.2:
   version "6.0.2"
-  resolved "https://registry.npmjs.org/postcss-zindex/-/postcss-zindex-6.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-zindex/-/postcss-zindex-6.0.2.tgz"
   integrity sha512-5BxW9l1evPB/4ZIc+2GobEBoKC+h8gPGCMi+jxsYvd2x0mjq7wazk6DrP71pStqxE9Foxh5TVnonbWpFZzXaYg==
 
-postcss@^8.4.21, postcss@^8.4.24, postcss@^8.4.26, postcss@^8.4.33, postcss@^8.4.38:
-  version "8.4.49"
-  resolved "https://registry.npmjs.org/postcss/-/postcss-8.4.49.tgz"
-  integrity sha512-OCVPnIObs4N29kxTjzLfUryOkvZEq+pf8jTF0lg8E7uETuWHA+v7j3c/xJmiqpX450191LlmZfUKkXxkTry7nA==
+postcss@^8.4.21, postcss@^8.4.24, postcss@^8.4.33, postcss@^8.5.4:
+  version "8.5.12"
+  resolved "https://registry.yarnpkg.com/postcss/-/postcss-8.5.12.tgz"
+  integrity sha512-W62t/Se6rA0Az3DfCL0AqJwXuKwBeYg6nOaIgzP+xZ7N5BFCI7DYi1qs6ygUYT6rvfi6t9k65UMLJC+PHZpDAA==
   dependencies:
-    nanoid "^3.3.7"
+    nanoid "^3.3.11"
     picocolors "^1.1.1"
     source-map-js "^1.2.1"
 
 pretty-error@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/pretty-error/-/pretty-error-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/pretty-error/-/pretty-error-4.0.0.tgz"
   integrity sha512-AoJ5YMAcXKYxKhuJGdcvse+Voc6v1RgnsR3nWcYU7q4t6z0Q6T86sv5Zq8VIRbOWWFpvdGE83LtdSMNd+6Y0xw==
   dependencies:
     lodash "^4.17.20"
@@ -7400,30 +7550,30 @@ pretty-error@^4.0.0:
 
 pretty-time@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.npmjs.org/pretty-time/-/pretty-time-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/pretty-time/-/pretty-time-1.1.0.tgz"
   integrity sha512-28iF6xPQrP8Oa6uxE6a1biz+lWeTOAPKggvjB8HAs6nVMKZwf5bG++632Dx614hIWgUPkgivRfG+a8uAXGTIbA==
 
 prism-react-renderer@^2.3.0, prism-react-renderer@^2.4.1:
   version "2.4.1"
-  resolved "https://registry.npmjs.org/prism-react-renderer/-/prism-react-renderer-2.4.1.tgz"
+  resolved "https://registry.yarnpkg.com/prism-react-renderer/-/prism-react-renderer-2.4.1.tgz"
   integrity sha512-ey8Ls/+Di31eqzUxC46h8MksNuGx/n0AAC8uKpwFau4RPDYLuE3EXTp8N8G2vX2N7UC/+IXeNUnlWBGGcAG+Ig==
   dependencies:
     "@types/prismjs" "^1.26.0"
     clsx "^2.0.0"
 
 prismjs@^1.29.0:
-  version "1.29.0"
-  resolved "https://registry.npmjs.org/prismjs/-/prismjs-1.29.0.tgz"
-  integrity sha512-Kx/1w86q/epKcmte75LNrEoT+lX8pBpavuAbvJWRXar7Hz8jrtF+e3vY751p0R8H9HdArwaCTNDDzHg/ScJK1Q==
+  version "1.30.0"
+  resolved "https://registry.yarnpkg.com/prismjs/-/prismjs-1.30.0.tgz"
+  integrity sha512-DEvV2ZF2r2/63V+tK8hQvrR2ZGn10srHbXviTlcv7Kpzw8jWiNTqbVgjO3IY8RxrrOUF8VPMQQFysYYYv0YZxw==
 
 process-nextick-args@~2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-2.0.1.tgz"
   integrity sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==
 
 prompts@^2.4.2:
   version "2.4.2"
-  resolved "https://registry.npmjs.org/prompts/-/prompts-2.4.2.tgz"
+  resolved "https://registry.yarnpkg.com/prompts/-/prompts-2.4.2.tgz"
   integrity sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==
   dependencies:
     kleur "^3.0.3"
@@ -7431,102 +7581,114 @@ prompts@^2.4.2:
 
 prop-types@^15.6.2, prop-types@^15.7.2:
   version "15.8.1"
-  resolved "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/prop-types/-/prop-types-15.8.1.tgz"
   integrity sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==
   dependencies:
     loose-envify "^1.4.0"
     object-assign "^4.1.1"
     react-is "^16.13.1"
 
-property-information@^6.0.0:
-  version "6.5.0"
-  resolved "https://registry.npmjs.org/property-information/-/property-information-6.5.0.tgz"
-  integrity sha512-PgTgs/BlvHxOu8QuEN7wi5A0OmXaBcHpmCSTehcs6Uuu9IkDIEo13Hy7n898RHfrQ49vKCoGeWZSaAK01nwVig==
+property-information@^7.0.0:
+  version "7.1.0"
+  resolved "https://registry.yarnpkg.com/property-information/-/property-information-7.1.0.tgz"
+  integrity sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ==
 
 proto-list@~1.2.1:
   version "1.2.4"
-  resolved "https://registry.npmjs.org/proto-list/-/proto-list-1.2.4.tgz"
+  resolved "https://registry.yarnpkg.com/proto-list/-/proto-list-1.2.4.tgz"
   integrity sha512-vtK/94akxsTMhe0/cbfpR+syPuszcuwhqVjJq26CuNDgFGj682oRBXOP5MJpv2r7JtE8MsiepGIqvvOTBwn2vA==
 
 proxy-addr@~2.0.7:
   version "2.0.7"
-  resolved "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz"
+  resolved "https://registry.yarnpkg.com/proxy-addr/-/proxy-addr-2.0.7.tgz"
   integrity sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==
   dependencies:
     forwarded "0.2.0"
     ipaddr.js "1.9.1"
 
-proxy-from-env@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz"
-  integrity sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==
+proxy-from-env@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/proxy-from-env/-/proxy-from-env-2.1.0.tgz"
+  integrity sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA==
 
 punycode@^2.1.0:
   version "2.3.1"
-  resolved "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.3.1.tgz"
   integrity sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==
 
 pupa@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/pupa/-/pupa-3.1.0.tgz"
-  integrity sha512-FLpr4flz5xZTSJxSeaheeMKN/EDzMdK7b8PTOC6a5PYFKTucWbdqjgqaEyH0shFiSJrVB1+Qqi4Tk19ccU6Aug==
+  version "3.3.0"
+  resolved "https://registry.yarnpkg.com/pupa/-/pupa-3.3.0.tgz"
+  integrity sha512-LjgDO2zPtoXP2wJpDjZrGdojii1uqO0cnwKoIoUzkfS98HDmbeiGmYiXo3lXeFlq2xvne1QFQhwYXSUCLKtEuA==
   dependencies:
     escape-goat "^4.0.0"
 
-qs@6.13.0:
-  version "6.13.0"
-  resolved "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz"
-  integrity sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==
+pvtsutils@^1.3.6:
+  version "1.3.6"
+  resolved "https://registry.yarnpkg.com/pvtsutils/-/pvtsutils-1.3.6.tgz"
+  integrity sha512-PLgQXQ6H2FWCaeRak8vvk1GW462lMxB5s3Jm673N82zI4vqtVUPuZdffdZbPDFRoU8kAhItWFtPCWiPpp4/EDg==
+  dependencies:
+    tslib "^2.8.1"
+
+pvutils@^1.1.3, pvutils@^1.1.5:
+  version "1.1.5"
+  resolved "https://registry.yarnpkg.com/pvutils/-/pvutils-1.1.5.tgz"
+  integrity sha512-KTqnxsgGiQ6ZAzZCVlJH5eOjSnvlyEgx1m8bkRJfOhmGRqfo5KLvmAlACQkrjEtOQ4B7wF9TdSLIs9O90MX9xA==
+
+qs@~6.14.0:
+  version "6.14.2"
+  resolved "https://registry.yarnpkg.com/qs/-/qs-6.14.2.tgz"
+  integrity sha512-V/yCWTTF7VJ9hIh18Ugr2zhJMP01MY7c5kh4J870L7imm6/DIzBsNLTXzMwUA3yZ5b/KBqLx8Kp3uRvd7xSe3Q==
   dependencies:
-    side-channel "^1.0.6"
+    side-channel "^1.1.0"
+
+qs@~6.15.1:
+  version "6.15.1"
+  resolved "https://registry.yarnpkg.com/qs/-/qs-6.15.1.tgz"
+  integrity sha512-6YHEFRL9mfgcAvql/XhwTvf5jKcOiiupt2FiJxHkiX1z4j7WL8J/jRHYLluORvc1XxB5rV20KoeK00gVJamspg==
+  dependencies:
+    side-channel "^1.1.0"
 
 queue-microtask@^1.2.2:
   version "1.2.3"
-  resolved "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz"
+  resolved "https://registry.yarnpkg.com/queue-microtask/-/queue-microtask-1.2.3.tgz"
   integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==
 
-queue@6.0.2:
-  version "6.0.2"
-  resolved "https://registry.npmjs.org/queue/-/queue-6.0.2.tgz"
-  integrity sha512-iHZWu+q3IdFZFX36ro/lKBkSvfkztY5Y7HMiPlOUjhupPcG2JMfst2KKEpu5XndviX/3UhFbRngUPNKtgvtZiA==
-  dependencies:
-    inherits "~2.0.3"
-
 quick-lru@^5.1.1:
   version "5.1.1"
-  resolved "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/quick-lru/-/quick-lru-5.1.1.tgz"
   integrity sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==
 
 randombytes@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/randombytes/-/randombytes-2.1.0.tgz"
   integrity sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==
   dependencies:
     safe-buffer "^5.1.0"
 
 range-parser@1.2.0:
   version "1.2.0"
-  resolved "https://registry.npmjs.org/range-parser/-/range-parser-1.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/range-parser/-/range-parser-1.2.0.tgz"
   integrity sha512-kA5WQoNVo4t9lNx2kQNFCxKeBl5IbbSNBl1M/tLkw9WCn+hxNBAW5Qh8gdhs63CJnhjJ2zQWFoqPJP2sK1AV5A==
 
 range-parser@^1.2.1, range-parser@~1.2.1:
   version "1.2.1"
-  resolved "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/range-parser/-/range-parser-1.2.1.tgz"
   integrity sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==
 
-raw-body@2.5.2:
-  version "2.5.2"
-  resolved "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz"
-  integrity sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==
+raw-body@~2.5.3:
+  version "2.5.3"
+  resolved "https://registry.yarnpkg.com/raw-body/-/raw-body-2.5.3.tgz"
+  integrity sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA==
   dependencies:
-    bytes "3.1.2"
-    http-errors "2.0.0"
-    iconv-lite "0.4.24"
-    unpipe "1.0.0"
+    bytes "~3.1.2"
+    http-errors "~2.0.1"
+    iconv-lite "~0.4.24"
+    unpipe "~1.0.0"
 
 rc@1.2.8:
   version "1.2.8"
-  resolved "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz"
+  resolved "https://registry.yarnpkg.com/rc/-/rc-1.2.8.tgz"
   integrity sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==
   dependencies:
     deep-extend "^0.6.0"
@@ -7534,58 +7696,23 @@ rc@1.2.8:
     minimist "^1.2.0"
     strip-json-comments "~2.0.1"
 
-react-dev-utils@^12.0.1:
-  version "12.0.1"
-  resolved "https://registry.npmjs.org/react-dev-utils/-/react-dev-utils-12.0.1.tgz"
-  integrity sha512-84Ivxmr17KjUupyqzFode6xKhjwuEJDROWKJy/BthkL7Wn6NJ8h4WE6k/exAv6ImS+0oZLRRW5j/aINMHyeGeQ==
-  dependencies:
-    "@babel/code-frame" "^7.16.0"
-    address "^1.1.2"
-    browserslist "^4.18.1"
-    chalk "^4.1.2"
-    cross-spawn "^7.0.3"
-    detect-port-alt "^1.1.6"
-    escape-string-regexp "^4.0.0"
-    filesize "^8.0.6"
-    find-up "^5.0.0"
-    fork-ts-checker-webpack-plugin "^6.5.0"
-    global-modules "^2.0.0"
-    globby "^11.0.4"
-    gzip-size "^6.0.0"
-    immer "^9.0.7"
-    is-root "^2.1.0"
-    loader-utils "^3.2.0"
-    open "^8.4.0"
-    pkg-up "^3.1.0"
-    prompts "^2.4.2"
-    react-error-overlay "^6.0.11"
-    recursive-readdir "^2.2.2"
-    shell-quote "^1.7.3"
-    strip-ansi "^6.0.1"
-    text-table "^0.2.0"
-
 react-dom@^18.3.1:
   version "18.3.1"
-  resolved "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/react-dom/-/react-dom-18.3.1.tgz"
   integrity sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==
   dependencies:
     loose-envify "^1.1.0"
     scheduler "^0.23.2"
 
-react-error-overlay@^6.0.11:
-  version "6.0.11"
-  resolved "https://registry.npmjs.org/react-error-overlay/-/react-error-overlay-6.0.11.tgz"
-  integrity sha512-/6UZ2qgEyH2aqzYZgQPxEnz33NJ2gNsnHA2o5+o4wW9bLM/JYQitNP9xPhsXwC08hMMovfGe/8retsdDsczPRg==
-
 react-fast-compare@^3.2.0:
   version "3.2.2"
-  resolved "https://registry.npmjs.org/react-fast-compare/-/react-fast-compare-3.2.2.tgz"
+  resolved "https://registry.yarnpkg.com/react-fast-compare/-/react-fast-compare-3.2.2.tgz"
   integrity sha512-nsO+KSNgo1SbJqJEYRE9ERzo7YtYbou/OqjSQKxV7jcKox7+usiUVZOAC+XnDOABXggQTno0Y1CpVnuWEc1boQ==
 
-react-helmet-async@*, react-helmet-async@^1.3.0:
+"react-helmet-async@npm:@slorber/react-helmet-async@1.3.0":
   version "1.3.0"
-  resolved "https://registry.npmjs.org/react-helmet-async/-/react-helmet-async-1.3.0.tgz"
-  integrity sha512-9jZ57/dAn9t3q6hneQS0wukqC2ENOBgMNVEhb/ZG9ZSxUetzVIw4iAmEU38IaVg3QGYauQPhSeUTuIUtFglWpg==
+  resolved "https://registry.yarnpkg.com/@slorber/react-helmet-async/-/react-helmet-async-1.3.0.tgz"
+  integrity sha512-e9/OK8VhwUSc67diWI8Rb3I0YgI9/SBQtnhe9aEuK6MhZm7ntZZimXgwXnd8W96YTmSOb9M4d8LwhRZyhWr/1A==
   dependencies:
     "@babel/runtime" "^7.12.5"
     invariant "^2.2.4"
@@ -7595,38 +7722,38 @@ react-helmet-async@*, react-helmet-async@^1.3.0:
 
 react-is@^16.13.1, react-is@^16.6.0, react-is@^16.7.0:
   version "16.13.1"
-  resolved "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz"
+  resolved "https://registry.yarnpkg.com/react-is/-/react-is-16.13.1.tgz"
   integrity sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==
 
-react-json-view-lite@^1.2.0:
-  version "1.5.0"
-  resolved "https://registry.npmjs.org/react-json-view-lite/-/react-json-view-lite-1.5.0.tgz"
-  integrity sha512-nWqA1E4jKPklL2jvHWs6s+7Na0qNgw9HCP6xehdQJeg6nPBTFZgGwyko9Q0oj+jQWKTTVRS30u0toM5wiuL3iw==
+react-json-view-lite@^2.3.0:
+  version "2.5.0"
+  resolved "https://registry.yarnpkg.com/react-json-view-lite/-/react-json-view-lite-2.5.0.tgz"
+  integrity sha512-tk7o7QG9oYyELWHL8xiMQ8x4WzjCzbWNyig3uexmkLb54r8jO0yH3WCWx8UZS0c49eSA4QUmG5caiRJ8fAn58g==
 
-react-loadable-ssr-addon-v5-slorber@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/react-loadable-ssr-addon-v5-slorber/-/react-loadable-ssr-addon-v5-slorber-1.0.1.tgz"
-  integrity sha512-lq3Lyw1lGku8zUEJPDxsNm1AfYHBrO9Y1+olAYwpUJ2IGFBskM0DMKok97A6LWUpHm+o7IvQBOWu9MLenp9Z+A==
+react-loadable-ssr-addon-v5-slorber@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/react-loadable-ssr-addon-v5-slorber/-/react-loadable-ssr-addon-v5-slorber-1.0.3.tgz"
+  integrity sha512-GXfh9VLwB5ERaCsU6RULh7tkemeX15aNh6wuMEBtfdyMa7fFG8TXrhXlx1SoEK2Ty/l6XIkzzYIQmyaWW3JgdQ==
   dependencies:
     "@babel/runtime" "^7.10.3"
 
 "react-loadable@npm:@docusaurus/react-loadable@6.0.0":
   version "6.0.0"
-  resolved "https://registry.npmjs.org/@docusaurus/react-loadable/-/react-loadable-6.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@docusaurus/react-loadable/-/react-loadable-6.0.0.tgz"
   integrity sha512-YMMxTUQV/QFSnbgrP3tjDzLHRg7vsbMn8e9HAa8o/1iXoiomo48b7sk/kkmWEuWNDPJVlKSJRB6Y2fHqdJk+SQ==
   dependencies:
     "@types/react" "*"
 
 react-router-config@^5.1.1:
   version "5.1.1"
-  resolved "https://registry.npmjs.org/react-router-config/-/react-router-config-5.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/react-router-config/-/react-router-config-5.1.1.tgz"
   integrity sha512-DuanZjaD8mQp1ppHjgnnUnyOlqYXZVjnov/JzFhjLEwd3Z4dYjMSnqrEzzGThH47vpCOqPPwJM2FtthLeJ8Pbg==
   dependencies:
     "@babel/runtime" "^7.1.2"
 
 react-router-dom@^5.3.4:
   version "5.3.4"
-  resolved "https://registry.npmjs.org/react-router-dom/-/react-router-dom-5.3.4.tgz"
+  resolved "https://registry.yarnpkg.com/react-router-dom/-/react-router-dom-5.3.4.tgz"
   integrity sha512-m4EqFMHv/Ih4kpcBCONHbkT68KoAeHN4p3lAGoNryfHi0dMy0kCzEZakiKRsvg5wHZ/JLrLW8o8KomWiz/qbYQ==
   dependencies:
     "@babel/runtime" "^7.12.13"
@@ -7639,7 +7766,7 @@ react-router-dom@^5.3.4:
 
 react-router@5.3.4, react-router@^5.3.4:
   version "5.3.4"
-  resolved "https://registry.npmjs.org/react-router/-/react-router-5.3.4.tgz"
+  resolved "https://registry.yarnpkg.com/react-router/-/react-router-5.3.4.tgz"
   integrity sha512-Ys9K+ppnJah3QuaRiLxk+jDWOR1MekYQrlytiXxC1RyfbdsZkS5pvKAzCCr031xHixZwpnsYNT5xysdFHQaYsA==
   dependencies:
     "@babel/runtime" "^7.12.13"
@@ -7654,14 +7781,14 @@ react-router@5.3.4, react-router@^5.3.4:
 
 react@^18.3.1:
   version "18.3.1"
-  resolved "https://registry.npmjs.org/react/-/react-18.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/react/-/react-18.3.1.tgz"
   integrity sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==
   dependencies:
     loose-envify "^1.1.0"
 
 readable-stream@^2.0.1:
   version "2.3.8"
-  resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz"
+  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.3.8.tgz"
   integrity sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==
   dependencies:
     core-util-is "~1.0.0"
@@ -7674,7 +7801,7 @@ readable-stream@^2.0.1:
 
 readable-stream@^3.0.6:
   version "3.6.2"
-  resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz"
+  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-3.6.2.tgz"
   integrity sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==
   dependencies:
     inherits "^2.0.3"
@@ -7683,26 +7810,14 @@ readable-stream@^3.0.6:
 
 readdirp@~3.6.0:
   version "3.6.0"
-  resolved "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz"
+  resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-3.6.0.tgz"
   integrity sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==
   dependencies:
     picomatch "^2.2.1"
 
-reading-time@^1.5.0:
-  version "1.5.0"
-  resolved "https://registry.npmjs.org/reading-time/-/reading-time-1.5.0.tgz"
-  integrity sha512-onYyVhBNr4CmAxFsKS7bz+uTLRakypIe4R+5A824vBSkQy/hB3fZepoVEf8OVAxzLvK+H/jm9TzpI3ETSm64Kg==
-
-rechoir@^0.6.2:
-  version "0.6.2"
-  resolved "https://registry.npmjs.org/rechoir/-/rechoir-0.6.2.tgz"
-  integrity sha512-HFM8rkZ+i3zrV+4LQjwQ0W+ez98pApMGM3HUrN04j3CqzPOzl9nmP15Y8YXNm8QHGv/eacOVEjqhmWpkRV0NAw==
-  dependencies:
-    resolve "^1.1.6"
-
 recma-build-jsx@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/recma-build-jsx/-/recma-build-jsx-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/recma-build-jsx/-/recma-build-jsx-1.0.0.tgz"
   integrity sha512-8GtdyqaBcDfva+GUKDr3nev3VpKAhup1+RvkMvUxURHpW7QyIvk9F5wz7Vzo06CEMSilw6uArgRqhpiUcWp8ew==
   dependencies:
     "@types/estree" "^1.0.0"
@@ -7710,9 +7825,9 @@ recma-build-jsx@^1.0.0:
     vfile "^6.0.0"
 
 recma-jsx@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/recma-jsx/-/recma-jsx-1.0.0.tgz"
-  integrity sha512-5vwkv65qWwYxg+Atz95acp8DMu1JDSqdGkA2Of1j6rCreyFUE/gp15fC8MnGEuG1W68UKjM6x6+YTWIh7hZM/Q==
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/recma-jsx/-/recma-jsx-1.0.1.tgz"
+  integrity sha512-huSIy7VU2Z5OLv6oFLosQGGDqPqdO1iq6bWNAdhzMxSJP7RAso4fCZ1cKu8j9YHCZf3TPrq4dw3okhrylgcd7w==
   dependencies:
     acorn-jsx "^5.0.0"
     estree-util-to-js "^2.0.0"
@@ -7722,7 +7837,7 @@ recma-jsx@^1.0.0:
 
 recma-parse@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/recma-parse/-/recma-parse-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/recma-parse/-/recma-parse-1.0.0.tgz"
   integrity sha512-OYLsIGBB5Y5wjnSnQW6t3Xg7q3fQ7FWbw/vcXtORTnyaSFscOtABg+7Pnz6YZ6c27fG1/aN8CjfwoUEUIdwqWQ==
   dependencies:
     "@types/estree" "^1.0.0"
@@ -7732,7 +7847,7 @@ recma-parse@^1.0.0:
 
 recma-stringify@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/recma-stringify/-/recma-stringify-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/recma-stringify/-/recma-stringify-1.0.0.tgz"
   integrity sha512-cjwII1MdIIVloKvC9ErQ+OgAtwHBmcZ0Bg4ciz78FtbT8In39aAYbaA7zvxQ61xVMSPE8WxhLwLbhif4Js2C+g==
   dependencies:
     "@types/estree" "^1.0.0"
@@ -7740,78 +7855,64 @@ recma-stringify@^1.0.0:
     unified "^11.0.0"
     vfile "^6.0.0"
 
-recursive-readdir@^2.2.2:
-  version "2.2.3"
-  resolved "https://registry.npmjs.org/recursive-readdir/-/recursive-readdir-2.2.3.tgz"
-  integrity sha512-8HrF5ZsXk5FAH9dgsx3BlUer73nIhuj+9OrQwEbLTPOBzGkL1lsFCR01am+v+0m2Cmbs1nP12hLDl5FA7EszKA==
-  dependencies:
-    minimatch "^3.0.5"
+reflect-metadata@^0.2.2:
+  version "0.2.2"
+  resolved "https://registry.yarnpkg.com/reflect-metadata/-/reflect-metadata-0.2.2.tgz"
+  integrity sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==
 
-regenerate-unicode-properties@^10.2.0:
-  version "10.2.0"
-  resolved "https://registry.npmjs.org/regenerate-unicode-properties/-/regenerate-unicode-properties-10.2.0.tgz"
-  integrity sha512-DqHn3DwbmmPVzeKj9woBadqmXxLvQoQIwu7nopMc72ztvxVmVk2SBhSnx67zuye5TP+lJsb/TBQsjLKhnDf3MA==
+regenerate-unicode-properties@^10.2.2:
+  version "10.2.2"
+  resolved "https://registry.yarnpkg.com/regenerate-unicode-properties/-/regenerate-unicode-properties-10.2.2.tgz"
+  integrity sha512-m03P+zhBeQd1RGnYxrGyDAPpWX/epKirLrp8e3qevZdVkKtnCrjjWczIbYc8+xd6vcTStVlqfycTx1KR4LOr0g==
   dependencies:
     regenerate "^1.4.2"
 
 regenerate@^1.4.2:
   version "1.4.2"
-  resolved "https://registry.npmjs.org/regenerate/-/regenerate-1.4.2.tgz"
+  resolved "https://registry.yarnpkg.com/regenerate/-/regenerate-1.4.2.tgz"
   integrity sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==
 
-regenerator-runtime@^0.14.0:
-  version "0.14.1"
-  resolved "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.14.1.tgz"
-  integrity sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==
-
-regenerator-transform@^0.15.2:
-  version "0.15.2"
-  resolved "https://registry.npmjs.org/regenerator-transform/-/regenerator-transform-0.15.2.tgz"
-  integrity sha512-hfMp2BoF0qOk3uc5V20ALGDS2ddjQaLrdl7xrGXvAIow7qeWRM2VA2HuCHkUKk9slq3VwEwLNK3DFBqDfPGYtg==
-  dependencies:
-    "@babel/runtime" "^7.8.4"
-
-regexpu-core@^6.2.0:
-  version "6.2.0"
-  resolved "https://registry.npmjs.org/regexpu-core/-/regexpu-core-6.2.0.tgz"
-  integrity sha512-H66BPQMrv+V16t8xtmq+UC0CBpiTBA60V8ibS1QVReIp8T1z8hwFxqcGzm9K6lgsN7sB5edVH8a+ze6Fqm4weA==
+regexpu-core@^6.3.1:
+  version "6.4.0"
+  resolved "https://registry.yarnpkg.com/regexpu-core/-/regexpu-core-6.4.0.tgz"
+  integrity sha512-0ghuzq67LI9bLXpOX/ISfve/Mq33a4aFRzoQYhnnok1JOFpmE/A2TBGkNVenOGEeSBCjIiWcc6MVOG5HEQv0sA==
   dependencies:
     regenerate "^1.4.2"
-    regenerate-unicode-properties "^10.2.0"
+    regenerate-unicode-properties "^10.2.2"
     regjsgen "^0.8.0"
-    regjsparser "^0.12.0"
+    regjsparser "^0.13.0"
     unicode-match-property-ecmascript "^2.0.0"
-    unicode-match-property-value-ecmascript "^2.1.0"
+    unicode-match-property-value-ecmascript "^2.2.1"
 
 registry-auth-token@^5.0.1:
-  version "5.0.3"
-  resolved "https://registry.npmjs.org/registry-auth-token/-/registry-auth-token-5.0.3.tgz"
-  integrity sha512-1bpc9IyC+e+CNFRaWyn77tk4xGG4PPUyfakSmA6F6cvUDjrm58dfyJ3II+9yb10EDkHoy1LaPSmHaWLOH3m6HA==
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/registry-auth-token/-/registry-auth-token-5.1.1.tgz"
+  integrity sha512-P7B4+jq8DeD2nMsAcdfaqHbssgHtZ7Z5+++a5ask90fvmJ8p5je4mOa+wzu+DB4vQ5tdJV/xywY+UnVFeQLV5Q==
   dependencies:
-    "@pnpm/npm-conf" "^2.1.0"
+    "@pnpm/npm-conf" "^3.0.2"
 
 registry-url@^6.0.0:
   version "6.0.1"
-  resolved "https://registry.npmjs.org/registry-url/-/registry-url-6.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/registry-url/-/registry-url-6.0.1.tgz"
   integrity sha512-+crtS5QjFRqFCoQmvGduwYWEBng99ZvmFvF+cUJkGYF1L1BfU8C6Zp9T7f5vPAwyLkUExpvK+ANVZmGU49qi4Q==
   dependencies:
     rc "1.2.8"
 
 regjsgen@^0.8.0:
   version "0.8.0"
-  resolved "https://registry.npmjs.org/regjsgen/-/regjsgen-0.8.0.tgz"
+  resolved "https://registry.yarnpkg.com/regjsgen/-/regjsgen-0.8.0.tgz"
   integrity sha512-RvwtGe3d7LvWiDQXeQw8p5asZUmfU1G/l6WbUXeHta7Y2PEIvBTwH6E2EfmYUK8pxcxEdEmaomqyp0vZZ7C+3Q==
 
-regjsparser@^0.12.0:
-  version "0.12.0"
-  resolved "https://registry.npmjs.org/regjsparser/-/regjsparser-0.12.0.tgz"
-  integrity sha512-cnE+y8bz4NhMjISKbgeVJtqNbtf5QpjZP+Bslo+UqkIt9QPnX9q095eiRRASJG1/tz6dlNr6Z5NsBiWYokp6EQ==
+regjsparser@^0.13.0:
+  version "0.13.1"
+  resolved "https://registry.yarnpkg.com/regjsparser/-/regjsparser-0.13.1.tgz"
+  integrity sha512-dLsljMd9sqwRkby8zhO1gSg3PnJIBFid8f4CQj/sXx+7cKx+E7u0PKhZ+U4wmhx7EfmtvnA318oVaIkAB1lRJw==
   dependencies:
-    jsesc "~3.0.2"
+    jsesc "~3.1.0"
 
 rehype-raw@^7.0.0:
   version "7.0.0"
-  resolved "https://registry.npmjs.org/rehype-raw/-/rehype-raw-7.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/rehype-raw/-/rehype-raw-7.0.0.tgz"
   integrity sha512-/aE8hCfKlQeA8LmyeyQvQF3eBiLRGNlfBJEvWH7ivp9sBqs7TNqBL5X3v157rM4IFETqDnIOO+z5M/biZbo9Ww==
   dependencies:
     "@types/hast" "^3.0.0"
@@ -7820,7 +7921,7 @@ rehype-raw@^7.0.0:
 
 rehype-recma@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/rehype-recma/-/rehype-recma-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/rehype-recma/-/rehype-recma-1.0.0.tgz"
   integrity sha512-lqA4rGUf1JmacCNWWZx0Wv1dHqMwxzsDWYMTowuplHF3xH0N/MmrZ/G3BDZnzAkRmxDadujCjaKM2hqYdCBOGw==
   dependencies:
     "@types/estree" "^1.0.0"
@@ -7829,13 +7930,13 @@ rehype-recma@^1.0.0:
 
 relateurl@^0.2.7:
   version "0.2.7"
-  resolved "https://registry.npmjs.org/relateurl/-/relateurl-0.2.7.tgz"
+  resolved "https://registry.yarnpkg.com/relateurl/-/relateurl-0.2.7.tgz"
   integrity sha512-G08Dxvm4iDN3MLM0EsP62EDV9IuhXPR6blNz6Utcp7zyV3tr4HVNINt6MpaRWbxoOHT3Q7YN2P+jaHX8vUbgog==
 
 remark-directive@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/remark-directive/-/remark-directive-3.0.0.tgz"
-  integrity sha512-l1UyWJ6Eg1VPU7Hm/9tt0zKtReJQNOA4+iDMAxTyZNWnJnFlbS/7zhiel/rogTLQ2vMYwDzSJa4BiVNqGlqIMA==
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/remark-directive/-/remark-directive-3.0.1.tgz"
+  integrity sha512-gwglrEQEZcZYgVyG1tQuA+h58EZfq5CSULw7J90AFuCTyib1thgHPoqQ+h9iFvU6R+vnZ5oNFQR5QKgGpk741A==
   dependencies:
     "@types/mdast" "^4.0.0"
     mdast-util-directive "^3.0.0"
@@ -7844,7 +7945,7 @@ remark-directive@^3.0.0:
 
 remark-emoji@^4.0.0:
   version "4.0.1"
-  resolved "https://registry.npmjs.org/remark-emoji/-/remark-emoji-4.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/remark-emoji/-/remark-emoji-4.0.1.tgz"
   integrity sha512-fHdvsTR1dHkWKev9eNyhTo4EFwbUvJ8ka9SgeWkMPYFX4WoI7ViVBms3PjlQYgw5TLvNQso3GUB/b/8t3yo+dg==
   dependencies:
     "@types/mdast" "^4.0.2"
@@ -7855,7 +7956,7 @@ remark-emoji@^4.0.0:
 
 remark-frontmatter@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.npmjs.org/remark-frontmatter/-/remark-frontmatter-5.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/remark-frontmatter/-/remark-frontmatter-5.0.0.tgz"
   integrity sha512-XTFYvNASMe5iPN0719nPrdItC9aU0ssC4v14mH1BCi1u0n1gAocqcujWUrByftZTbLhRtiKRyjYTSIOcr69UVQ==
   dependencies:
     "@types/mdast" "^4.0.0"
@@ -7864,9 +7965,9 @@ remark-frontmatter@^5.0.0:
     unified "^11.0.0"
 
 remark-gfm@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/remark-gfm/-/remark-gfm-4.0.0.tgz"
-  integrity sha512-U92vJgBPkbw4Zfu/IiW2oTZLSL3Zpv+uI7My2eq8JxKgqraFdU8YUGicEJCEgSbeaG+QDFqIcwwfMTOEelPxuA==
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/remark-gfm/-/remark-gfm-4.0.1.tgz"
+  integrity sha512-1quofZ2RQ9EWdeN34S79+KExV1764+wCUGop5CPL1WGdD0ocPpu91lzPGbwWMECpEpd42kJGQwzRfyov9j4yNg==
   dependencies:
     "@types/mdast" "^4.0.0"
     mdast-util-gfm "^3.0.0"
@@ -7876,16 +7977,16 @@ remark-gfm@^4.0.0:
     unified "^11.0.0"
 
 remark-mdx@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/remark-mdx/-/remark-mdx-3.1.0.tgz"
-  integrity sha512-Ngl/H3YXyBV9RcRNdlYsZujAmhsxwzxpDzpDEhFBVAGthS4GDgnctpDjgFl/ULx5UEDzqtW1cyBSNKqYYrqLBA==
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/remark-mdx/-/remark-mdx-3.1.1.tgz"
+  integrity sha512-Pjj2IYlUY3+D8x00UJsIOg5BEvfMyeI+2uLPn9VO9Wg4MEtN/VTIq2NEJQfde9PnX15KgtHyl9S0BcTnWrIuWg==
   dependencies:
     mdast-util-mdx "^3.0.0"
     micromark-extension-mdxjs "^3.0.0"
 
 remark-parse@^11.0.0:
   version "11.0.0"
-  resolved "https://registry.npmjs.org/remark-parse/-/remark-parse-11.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/remark-parse/-/remark-parse-11.0.0.tgz"
   integrity sha512-FCxlKLNGknS5ba/1lmpYijMUzX2esxW5xQqjWxw2eHFfS2MSdaHVINFmhjo+qN1WhZhNimq0dZATN9pH0IDrpA==
   dependencies:
     "@types/mdast" "^4.0.0"
@@ -7894,9 +7995,9 @@ remark-parse@^11.0.0:
     unified "^11.0.0"
 
 remark-rehype@^11.0.0:
-  version "11.1.1"
-  resolved "https://registry.npmjs.org/remark-rehype/-/remark-rehype-11.1.1.tgz"
-  integrity sha512-g/osARvjkBXb6Wo0XvAeXQohVta8i84ACbenPpoSsxTOQH/Ae0/RGP4WZgnMH5pMLpsj4FG7OHmcIcXxpza8eQ==
+  version "11.1.2"
+  resolved "https://registry.yarnpkg.com/remark-rehype/-/remark-rehype-11.1.2.tgz"
+  integrity sha512-Dh7l57ianaEoIpzbp0PC9UKAdCSVklD8E5Rpw7ETfbTl3FqcOOgq5q2LVDhgGCkaBv7p24JXikPdvhhmHvKMsw==
   dependencies:
     "@types/hast" "^3.0.0"
     "@types/mdast" "^4.0.0"
@@ -7906,7 +8007,7 @@ remark-rehype@^11.0.0:
 
 remark-stringify@^11.0.0:
   version "11.0.0"
-  resolved "https://registry.npmjs.org/remark-stringify/-/remark-stringify-11.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/remark-stringify/-/remark-stringify-11.0.0.tgz"
   integrity sha512-1OSmLd3awB/t8qdoEOMazZkNsfVTeY4fTsgzcQFdXNq8ToTN4ZGwrMnlda4K6smTFKD+GRV6O48i6Z4iKgPPpw==
   dependencies:
     "@types/mdast" "^4.0.0"
@@ -7915,7 +8016,7 @@ remark-stringify@^11.0.0:
 
 renderkid@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/renderkid/-/renderkid-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/renderkid/-/renderkid-3.0.0.tgz"
   integrity sha512-q/7VIQA8lmM1hF+jn+sFSPWGlMkSAeNYcPLmDQx2zzuiDfaLrOmumR8iaUKlenFgh0XRPIUeSPlH3A+AW3Z5pg==
   dependencies:
     css-select "^4.1.3"
@@ -7924,82 +8025,66 @@ renderkid@^3.0.0:
     lodash "^4.17.21"
     strip-ansi "^6.0.1"
 
-repeat-string@^1.0.0:
-  version "1.6.1"
-  resolved "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz"
-  integrity sha512-PV0dzCYDNfRi1jCDbJzpW7jNNDRuCOG/jI5ctQcGKt/clZD+YcPS3yIlWuTJMmESC8aevCFmWJy5wjAFgNqN6w==
-
 require-from-string@^2.0.2:
   version "2.0.2"
-  resolved "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/require-from-string/-/require-from-string-2.0.2.tgz"
   integrity sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==
 
 "require-like@>= 0.1.1":
   version "0.1.2"
-  resolved "https://registry.npmjs.org/require-like/-/require-like-0.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/require-like/-/require-like-0.1.2.tgz"
   integrity sha512-oyrU88skkMtDdauHDuKVrgR+zuItqr6/c//FXzvmxRGMexSDc6hNvJInGW3LL46n+8b50RykrvwSUIIQH2LQ5A==
 
 requires-port@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/requires-port/-/requires-port-1.0.0.tgz"
   integrity sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==
 
 resolve-alpn@^1.2.0:
   version "1.2.1"
-  resolved "https://registry.npmjs.org/resolve-alpn/-/resolve-alpn-1.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/resolve-alpn/-/resolve-alpn-1.2.1.tgz"
   integrity sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==
 
 resolve-from@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-4.0.0.tgz"
   integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==
 
 resolve-pathname@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/resolve-pathname/-/resolve-pathname-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/resolve-pathname/-/resolve-pathname-3.0.0.tgz"
   integrity sha512-C7rARubxI8bXFNB/hqcp/4iUeIXJhJZvFPFPiSPRnhU5UPxzMFIl+2E6yY6c4k9giDJAhtV+enfA+G89N6Csng==
 
-resolve@^1.1.6, resolve@^1.14.2:
-  version "1.22.10"
-  resolved "https://registry.npmjs.org/resolve/-/resolve-1.22.10.tgz"
-  integrity sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==
+resolve@^1.22.11:
+  version "1.22.12"
+  resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.22.12.tgz"
+  integrity sha512-TyeJ1zif53BPfHootBGwPRYT1RUt6oGWsaQr8UyZW/eAm9bKoijtvruSDEmZHm92CwS9nj7/fWttqPCgzep8CA==
   dependencies:
-    is-core-module "^2.16.0"
+    es-errors "^1.3.0"
+    is-core-module "^2.16.1"
     path-parse "^1.0.7"
     supports-preserve-symlinks-flag "^1.0.0"
 
 responselike@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/responselike/-/responselike-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/responselike/-/responselike-3.0.0.tgz"
   integrity sha512-40yHxbNcl2+rzXvZuVkrYohathsSJlMTXKryG5y8uciHv1+xDLHQpgjG64JUO9nrEq2jGLH6IZ8BcZyw3wrweg==
   dependencies:
     lowercase-keys "^3.0.0"
 
 retry@^0.13.1:
   version "0.13.1"
-  resolved "https://registry.npmjs.org/retry/-/retry-0.13.1.tgz"
+  resolved "https://registry.yarnpkg.com/retry/-/retry-0.13.1.tgz"
   integrity sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==
 
 reusify@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz"
-  integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==
-
-rimraf@^3.0.2:
-  version "3.0.2"
-  resolved "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz"
-  integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==
-  dependencies:
-    glob "^7.1.3"
-
-rtl-detect@^1.0.4:
-  version "1.1.2"
-  resolved "https://registry.npmjs.org/rtl-detect/-/rtl-detect-1.1.2.tgz"
-  integrity sha512-PGMBq03+TTG/p/cRB7HCLKJ1MgDIi07+QU1faSjiYRfmY5UsAttV9Hs08jDAHVwcOwmVLcSJkpwyfXszVjWfIQ==
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/reusify/-/reusify-1.1.0.tgz"
+  integrity sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==
 
 rtlcss@^4.1.0:
   version "4.3.0"
-  resolved "https://registry.npmjs.org/rtlcss/-/rtlcss-4.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/rtlcss/-/rtlcss-4.3.0.tgz"
   integrity sha512-FI+pHEn7Wc4NqKXMXFM+VAYKEj/mRIcW4h24YVwVtyjI+EqGrLc2Hx/Ny0lrZ21cBWU2goLy36eqMcNj3AQJig==
   dependencies:
     escalade "^3.1.1"
@@ -8007,62 +8092,63 @@ rtlcss@^4.1.0:
     postcss "^8.4.21"
     strip-json-comments "^3.1.1"
 
+run-applescript@^7.0.0:
+  version "7.1.0"
+  resolved "https://registry.yarnpkg.com/run-applescript/-/run-applescript-7.1.0.tgz"
+  integrity sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q==
+
 run-parallel@^1.1.9:
   version "1.2.0"
-  resolved "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/run-parallel/-/run-parallel-1.2.0.tgz"
   integrity sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==
   dependencies:
     queue-microtask "^1.2.2"
 
 safe-buffer@5.2.1, safe-buffer@>=5.1.0, safe-buffer@^5.1.0, safe-buffer@~5.2.0:
   version "5.2.1"
-  resolved "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz"
   integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
 
 safe-buffer@~5.1.0, safe-buffer@~5.1.1:
   version "5.1.2"
-  resolved "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.1.2.tgz"
   integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==
 
 "safer-buffer@>= 2.1.2 < 3":
   version "2.1.2"
-  resolved "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz"
   integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==
 
-sax@^1.2.4:
-  version "1.4.1"
-  resolved "https://registry.npmjs.org/sax/-/sax-1.4.1.tgz"
-  integrity sha512-+aWOz7yVScEGoKNd4PA10LZ8sk0A/z5+nXQG5giUO5rprX9jgYsTdov9qCchZiPIZezbZH+jRut8nPodFAX4Jg==
+sax@^1.2.4, sax@^1.5.0:
+  version "1.6.0"
+  resolved "https://registry.yarnpkg.com/sax/-/sax-1.6.0.tgz"
+  integrity sha512-6R3J5M4AcbtLUdZmRv2SygeVaM7IhrLXu9BmnOGmmACak8fiUtOsYNWUS4uK7upbmHIBbLBeFeI//477BKLBzA==
 
 scheduler@^0.23.2:
   version "0.23.2"
-  resolved "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz"
+  resolved "https://registry.yarnpkg.com/scheduler/-/scheduler-0.23.2.tgz"
   integrity sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==
   dependencies:
     loose-envify "^1.1.0"
 
-schema-utils@2.7.0:
-  version "2.7.0"
-  resolved "https://registry.npmjs.org/schema-utils/-/schema-utils-2.7.0.tgz"
-  integrity sha512-0ilKFI6QQF5nxDZLFn2dMjvc4hjg/Wkg7rHd3jK6/A4a1Hl9VFdQWvgB1UMGoU94pad1P/8N7fMcEnLnSiju8A==
-  dependencies:
-    "@types/json-schema" "^7.0.4"
-    ajv "^6.12.2"
-    ajv-keywords "^3.4.1"
+schema-dts@^1.1.2:
+  version "1.1.5"
+  resolved "https://registry.yarnpkg.com/schema-dts/-/schema-dts-1.1.5.tgz"
+  integrity sha512-RJr9EaCmsLzBX2NDiO5Z3ux2BVosNZN5jo0gWgsyKvxKIUL5R3swNvoorulAeL9kLB0iTSX7V6aokhla2m7xbg==
 
-schema-utils@^3.0.0, schema-utils@^3.2.0:
+schema-utils@^3.0.0:
   version "3.3.0"
-  resolved "https://registry.npmjs.org/schema-utils/-/schema-utils-3.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/schema-utils/-/schema-utils-3.3.0.tgz"
   integrity sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==
   dependencies:
     "@types/json-schema" "^7.0.8"
     ajv "^6.12.5"
     ajv-keywords "^3.5.2"
 
-schema-utils@^4.0.0, schema-utils@^4.0.1, schema-utils@^4.3.0:
-  version "4.3.0"
-  resolved "https://registry.npmjs.org/schema-utils/-/schema-utils-4.3.0.tgz"
-  integrity sha512-Gf9qqc58SpCA/xdziiHz35F4GNIWYWZrEshUc/G/r5BnLph6xpKuLeoJoQuj5WfBIx/eQLf+hmVPYHaxJu7V2g==
+schema-utils@^4.0.0, schema-utils@^4.0.1, schema-utils@^4.2.0, schema-utils@^4.3.0, schema-utils@^4.3.3:
+  version "4.3.3"
+  resolved "https://registry.yarnpkg.com/schema-utils/-/schema-utils-4.3.3.tgz"
+  integrity sha512-eflK8wEtyOE6+hsaRVPxvUKYCpRgzLqDTb8krvAsRIwOGlHoSgYLgBXoubGgLd2fT41/OUYdb48v4k4WWHQurA==
   dependencies:
     "@types/json-schema" "^7.0.9"
     ajv "^8.9.0"
@@ -8071,7 +8157,7 @@ schema-utils@^4.0.0, schema-utils@^4.0.1, schema-utils@^4.3.0:
 
 section-matter@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/section-matter/-/section-matter-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/section-matter/-/section-matter-1.0.0.tgz"
   integrity sha512-vfD3pmTzGpufjScBh50YHKzEu2lxBWhVEHsNGoEXmCmn2hKGfeNLYMzCJpe8cD7gqX7TJluOVpBkAequ6dgMmA==
   dependencies:
     extend-shallow "^2.0.1"
@@ -8079,99 +8165,99 @@ section-matter@^1.0.0:
 
 select-hose@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/select-hose/-/select-hose-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/select-hose/-/select-hose-2.0.0.tgz"
   integrity sha512-mEugaLK+YfkijB4fx0e6kImuJdCIt2LxCRcbEYPqRGCs4F2ogyfZU5IAZRdjCP8JPq2AtdNoC/Dux63d9Kiryg==
 
-selfsigned@^2.1.1:
-  version "2.4.1"
-  resolved "https://registry.npmjs.org/selfsigned/-/selfsigned-2.4.1.tgz"
-  integrity sha512-th5B4L2U+eGLq1TVh7zNRGBapioSORUeymIydxgFpwww9d2qyKvtuPU2jJuHvYAwwqi2Y596QBL3eEqcPEYL8Q==
+selfsigned@^5.5.0:
+  version "5.5.0"
+  resolved "https://registry.yarnpkg.com/selfsigned/-/selfsigned-5.5.0.tgz"
+  integrity sha512-ftnu3TW4+3eBfLRFnDEkzGxSF/10BJBkaLJuBHZX0kiPS7bRdlpZGu6YGt4KngMkdTwJE6MbjavFpqHvqVt+Ew==
   dependencies:
-    "@types/node-forge" "^1.3.0"
-    node-forge "^1"
+    "@peculiar/x509" "^1.14.2"
+    pkijs "^3.3.3"
 
 semver-diff@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/semver-diff/-/semver-diff-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/semver-diff/-/semver-diff-4.0.0.tgz"
   integrity sha512-0Ju4+6A8iOnpL/Thra7dZsSlOHYAHIeMxfhWQRI1/VLcT3WDBZKKtQt/QkBOsiIN9ZpuvHE6cGZ0x4glCMmfiA==
   dependencies:
     semver "^7.3.5"
 
 semver@^6.3.1:
   version "6.3.1"
-  resolved "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.1.tgz"
   integrity sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==
 
-semver@^7.3.2, semver@^7.3.5, semver@^7.3.7, semver@^7.5.4:
-  version "7.6.3"
-  resolved "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz"
-  integrity sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==
+semver@^7.3.5, semver@^7.3.7, semver@^7.5.4:
+  version "7.7.4"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-7.7.4.tgz"
+  integrity sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==
 
-send@0.19.0:
-  version "0.19.0"
-  resolved "https://registry.npmjs.org/send/-/send-0.19.0.tgz"
-  integrity sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==
+send@~0.19.0, send@~0.19.1:
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/send/-/send-0.19.2.tgz"
+  integrity sha512-VMbMxbDeehAxpOtWJXlcUS5E8iXh6QmN+BkRX1GARS3wRaXEEgzCcB10gTQazO42tpNIya8xIyNx8fll1OFPrg==
   dependencies:
     debug "2.6.9"
     depd "2.0.0"
     destroy "1.2.0"
-    encodeurl "~1.0.2"
+    encodeurl "~2.0.0"
     escape-html "~1.0.3"
     etag "~1.8.1"
-    fresh "0.5.2"
-    http-errors "2.0.0"
+    fresh "~0.5.2"
+    http-errors "~2.0.1"
     mime "1.6.0"
     ms "2.1.3"
-    on-finished "2.4.1"
+    on-finished "~2.4.1"
     range-parser "~1.2.1"
-    statuses "2.0.1"
+    statuses "~2.0.2"
 
-serialize-javascript@^6.0.0, serialize-javascript@^6.0.1, serialize-javascript@^6.0.2:
+serialize-javascript@^6.0.0, serialize-javascript@^6.0.1:
   version "6.0.2"
-  resolved "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/serialize-javascript/-/serialize-javascript-6.0.2.tgz"
   integrity sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==
   dependencies:
     randombytes "^2.1.0"
 
-serve-handler@^6.1.6:
-  version "6.1.6"
-  resolved "https://registry.npmjs.org/serve-handler/-/serve-handler-6.1.6.tgz"
-  integrity sha512-x5RL9Y2p5+Sh3D38Fh9i/iQ5ZK+e4xuXRd/pGbM4D13tgo/MGwbttUk8emytcr1YYzBYs+apnUngBDFYfpjPuQ==
+serve-handler@^6.1.7:
+  version "6.1.7"
+  resolved "https://registry.yarnpkg.com/serve-handler/-/serve-handler-6.1.7.tgz"
+  integrity sha512-CinAq1xWb0vR3twAv9evEU8cNWkXCb9kd5ePAHUKJBkOsUpR1wt/CvGdeca7vqumL1U5cSaeVQ6zZMxiJ3yWsg==
   dependencies:
     bytes "3.0.0"
     content-disposition "0.5.2"
     mime-types "2.1.18"
-    minimatch "3.1.2"
+    minimatch "3.1.5"
     path-is-inside "1.0.2"
     path-to-regexp "3.3.0"
     range-parser "1.2.0"
 
 serve-index@^1.9.1:
-  version "1.9.1"
-  resolved "https://registry.npmjs.org/serve-index/-/serve-index-1.9.1.tgz"
-  integrity sha512-pXHfKNP4qujrtteMrSBb0rc8HJ9Ms/GrXwcUtUtD5s4ewDJI8bT3Cz2zTVRMKtri49pLx2e0Ya8ziP5Ya2pZZw==
+  version "1.9.2"
+  resolved "https://registry.yarnpkg.com/serve-index/-/serve-index-1.9.2.tgz"
+  integrity sha512-KDj11HScOaLmrPxl70KYNW1PksP4Nb/CLL2yvC+Qd2kHMPEEpfc4Re2e4FOay+bC/+XQl/7zAcWON3JVo5v3KQ==
   dependencies:
-    accepts "~1.3.4"
+    accepts "~1.3.8"
     batch "0.6.1"
     debug "2.6.9"
     escape-html "~1.0.3"
-    http-errors "~1.6.2"
-    mime-types "~2.1.17"
-    parseurl "~1.3.2"
+    http-errors "~1.8.0"
+    mime-types "~2.1.35"
+    parseurl "~1.3.3"
 
-serve-static@1.16.2:
-  version "1.16.2"
-  resolved "https://registry.npmjs.org/serve-static/-/serve-static-1.16.2.tgz"
-  integrity sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==
+serve-static@~1.16.2:
+  version "1.16.3"
+  resolved "https://registry.yarnpkg.com/serve-static/-/serve-static-1.16.3.tgz"
+  integrity sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==
   dependencies:
     encodeurl "~2.0.0"
     escape-html "~1.0.3"
     parseurl "~1.3.3"
-    send "0.19.0"
+    send "~0.19.1"
 
 set-function-length@^1.2.2:
   version "1.2.2"
-  resolved "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz"
+  resolved "https://registry.yarnpkg.com/set-function-length/-/set-function-length-1.2.2.tgz"
   integrity sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==
   dependencies:
     define-data-property "^1.1.4"
@@ -8181,65 +8267,51 @@ set-function-length@^1.2.2:
     gopd "^1.0.1"
     has-property-descriptors "^1.0.2"
 
-setprototypeof@1.1.0:
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.1.0.tgz"
-  integrity sha512-BvE/TwpZX4FXExxOxZyRGQQv651MSwmWKZGqvmPcRIjDqWub67kTKuIMx43cZZrS/cBBzwBcNDWoFxt2XEFIpQ==
-
-setprototypeof@1.2.0:
+setprototypeof@1.2.0, setprototypeof@~1.2.0:
   version "1.2.0"
-  resolved "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/setprototypeof/-/setprototypeof-1.2.0.tgz"
   integrity sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==
 
 shallow-clone@^3.0.0:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/shallow-clone/-/shallow-clone-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/shallow-clone/-/shallow-clone-3.0.1.tgz"
   integrity sha512-/6KqX+GVUdqPuPPd2LxDDxzX6CAbjJehAAOKlNpqqUpAqPM6HeL8f+o3a+JsyGjn2lv0WY8UsTgUJjU9Ok55NA==
   dependencies:
     kind-of "^6.0.2"
 
 shallowequal@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.npmjs.org/shallowequal/-/shallowequal-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/shallowequal/-/shallowequal-1.1.0.tgz"
   integrity sha512-y0m1JoUZSlPAjXVtPPW70aZWfIL/dSP7AFkRnniLCrK/8MDKog3TySTBmckD+RObVxH0v4Tox67+F14PdED2oQ==
 
 shebang-command@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-2.0.0.tgz"
   integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==
   dependencies:
     shebang-regex "^3.0.0"
 
 shebang-regex@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz"
   integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==
 
-shell-quote@^1.7.3, shell-quote@^1.8.1:
-  version "1.8.2"
-  resolved "https://registry.npmjs.org/shell-quote/-/shell-quote-1.8.2.tgz"
-  integrity sha512-AzqKpGKjrj7EM6rKVQEPpB288oCfnrEIuyoT9cyF4nmGa7V8Zk6f7RRqYisX8X9m+Q7bd632aZW4ky7EhbQztA==
-
-shelljs@^0.8.5:
-  version "0.8.5"
-  resolved "https://registry.npmjs.org/shelljs/-/shelljs-0.8.5.tgz"
-  integrity sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow==
-  dependencies:
-    glob "^7.0.0"
-    interpret "^1.0.0"
-    rechoir "^0.6.2"
+shell-quote@^1.8.3:
+  version "1.8.3"
+  resolved "https://registry.yarnpkg.com/shell-quote/-/shell-quote-1.8.3.tgz"
+  integrity sha512-ObmnIF4hXNg1BqhnHmgbDETF8dLPCggZWBjkQfhZpbszZnYur5DUljTcCHii5LC3J5E0yeO/1LIMyH+UvHQgyw==
 
 side-channel-list@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz"
-  integrity sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/side-channel-list/-/side-channel-list-1.0.1.tgz"
+  integrity sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==
   dependencies:
     es-errors "^1.3.0"
-    object-inspect "^1.13.3"
+    object-inspect "^1.13.4"
 
 side-channel-map@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/side-channel-map/-/side-channel-map-1.0.1.tgz"
   integrity sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==
   dependencies:
     call-bound "^1.0.2"
@@ -8249,7 +8321,7 @@ side-channel-map@^1.0.1:
 
 side-channel-weakmap@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz"
   integrity sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==
   dependencies:
     call-bound "^1.0.2"
@@ -8258,9 +8330,9 @@ side-channel-weakmap@^1.0.2:
     object-inspect "^1.13.3"
     side-channel-map "^1.0.1"
 
-side-channel@^1.0.6:
+side-channel@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/side-channel/-/side-channel-1.1.0.tgz"
   integrity sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==
   dependencies:
     es-errors "^1.3.0"
@@ -8271,12 +8343,12 @@ side-channel@^1.0.6:
 
 signal-exit@^3.0.2, signal-exit@^3.0.3:
   version "3.0.7"
-  resolved "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz"
+  resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.7.tgz"
   integrity sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==
 
 sirv@^2.0.3:
   version "2.0.4"
-  resolved "https://registry.npmjs.org/sirv/-/sirv-2.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/sirv/-/sirv-2.0.4.tgz"
   integrity sha512-94Bdh3cC2PKrbgSOUqTiGPWVZeSiXfKOVZNJniWoqrWrRkB1CJzBU3NEbiTsPcYy1lDsANA/THzS+9WBiy5nfQ==
   dependencies:
     "@polka/url" "^1.0.0-next.24"
@@ -8285,13 +8357,13 @@ sirv@^2.0.3:
 
 sisteransi@^1.0.5:
   version "1.0.5"
-  resolved "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/sisteransi/-/sisteransi-1.0.5.tgz"
   integrity sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==
 
 sitemap@^7.1.1:
-  version "7.1.2"
-  resolved "https://registry.npmjs.org/sitemap/-/sitemap-7.1.2.tgz"
-  integrity sha512-ARCqzHJ0p4gWt+j7NlU5eDlIO9+Rkr/JhPFZKKQ1l5GCus7rJH4UdrlVAh0xC/gDS/Qir2UMxqYNHtsKr2rpCw==
+  version "7.1.3"
+  resolved "https://registry.yarnpkg.com/sitemap/-/sitemap-7.1.3.tgz"
+  integrity sha512-tAjEd+wt/YwnEbfNB2ht51ybBJxbEWwe5ki/Z//Wh0rpBFTCUSj46GnxUKEWzhfuJTsee8x3lybHxFgUMig2hw==
   dependencies:
     "@types/node" "^17.0.5"
     "@types/sax" "^1.2.1"
@@ -8300,24 +8372,24 @@ sitemap@^7.1.1:
 
 skin-tone@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/skin-tone/-/skin-tone-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/skin-tone/-/skin-tone-2.0.0.tgz"
   integrity sha512-kUMbT1oBJCpgrnKoSr0o6wPtvRWT9W9UKvGLwfJYO2WuahZRHOpEyL1ckyMGgMWh0UdpmaoFqKKD29WTomNEGA==
   dependencies:
     unicode-emoji-modifier-base "^1.0.0"
 
 slash@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/slash/-/slash-3.0.0.tgz"
   integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==
 
 slash@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/slash/-/slash-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/slash/-/slash-4.0.0.tgz"
   integrity sha512-3dOsAHXXUkQTpOYcoAxLIorMTp4gIQr5IW3iVb7A7lFIp0VHhnynm9izx6TssdrIcVIESAlVjtnO2K8bg+Coew==
 
 snake-case@^3.0.4:
   version "3.0.4"
-  resolved "https://registry.npmjs.org/snake-case/-/snake-case-3.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/snake-case/-/snake-case-3.0.4.tgz"
   integrity sha512-LAOh4z89bGQvl9pFfNF8V146i7o7/CqFPbqzYgP+yYzDIDeS9HaNFtXABamRW+AQzEVODcvE79ljJ+8a9YSdMg==
   dependencies:
     dot-case "^3.0.4"
@@ -8325,7 +8397,7 @@ snake-case@^3.0.4:
 
 sockjs@^0.3.24:
   version "0.3.24"
-  resolved "https://registry.npmjs.org/sockjs/-/sockjs-0.3.24.tgz"
+  resolved "https://registry.yarnpkg.com/sockjs/-/sockjs-0.3.24.tgz"
   integrity sha512-GJgLTZ7vYb/JtPSSZ10hsOYIvEYsjbNU+zPdIHcUaWVNUEPivzxku31865sSSud0Da0W4lEeOPlmw93zLQchuQ==
   dependencies:
     faye-websocket "^0.11.3"
@@ -8334,17 +8406,17 @@ sockjs@^0.3.24:
 
 sort-css-media-queries@2.2.0:
   version "2.2.0"
-  resolved "https://registry.npmjs.org/sort-css-media-queries/-/sort-css-media-queries-2.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/sort-css-media-queries/-/sort-css-media-queries-2.2.0.tgz"
   integrity sha512-0xtkGhWCC9MGt/EzgnvbbbKhqWjl1+/rncmhTh5qCpbYguXh6S/qwePfv/JQ8jePXXmqingylxoC49pCkSPIbA==
 
 source-map-js@^1.0.1, source-map-js@^1.2.1:
   version "1.2.1"
-  resolved "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/source-map-js/-/source-map-js-1.2.1.tgz"
   integrity sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==
 
 source-map-support@~0.5.20:
   version "0.5.21"
-  resolved "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz"
+  resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.21.tgz"
   integrity sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==
   dependencies:
     buffer-from "^1.0.0"
@@ -8352,22 +8424,22 @@ source-map-support@~0.5.20:
 
 source-map@^0.6.0, source-map@~0.6.0:
   version "0.6.1"
-  resolved "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz"
+  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz"
   integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
 
 source-map@^0.7.0:
-  version "0.7.4"
-  resolved "https://registry.npmjs.org/source-map/-/source-map-0.7.4.tgz"
-  integrity sha512-l3BikUxvPOcn5E74dZiq5BGsTb5yEwhaTSzccU6t4sDOH8NWJCstKO5QT2CvtFoK6F0saL7p9xHAqHOlCPJygA==
+  version "0.7.6"
+  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.7.6.tgz"
+  integrity sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ==
 
 space-separated-tokens@^2.0.0:
   version "2.0.2"
-  resolved "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz"
   integrity sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==
 
 spdy-transport@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/spdy-transport/-/spdy-transport-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/spdy-transport/-/spdy-transport-3.0.0.tgz"
   integrity sha512-hsLVFE5SjA6TCisWeJXFKniGGOpBgMLmerfO2aCyCU5s7nJ/rpAepqmFifv/GCbSbueEeAJJnmSQ2rKC/g8Fcw==
   dependencies:
     debug "^4.1.0"
@@ -8379,7 +8451,7 @@ spdy-transport@^3.0.0:
 
 spdy@^4.0.2:
   version "4.0.2"
-  resolved "https://registry.npmjs.org/spdy/-/spdy-4.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/spdy/-/spdy-4.0.2.tgz"
   integrity sha512-r46gZQZQV+Kl9oItvl1JZZqJKGr+oEkB08A6BzkiR7593/7IbtuncXHd2YoYeTsG4157ZssMu9KYvUHLcjcDoA==
   dependencies:
     debug "^4.1.0"
@@ -8390,32 +8462,32 @@ spdy@^4.0.2:
 
 sprintf-js@~1.0.2:
   version "1.0.3"
-  resolved "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz"
   integrity sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==
 
 srcset@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/srcset/-/srcset-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/srcset/-/srcset-4.0.0.tgz"
   integrity sha512-wvLeHgcVHKO8Sc/H/5lkGreJQVeYMm9rlmt8PuR1xE31rIuXhuzznUUqAt8MqLhB3MqJdFzlNAfpcWnxiFUcPw==
 
-statuses@2.0.1:
-  version "2.0.1"
-  resolved "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz"
-  integrity sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==
-
-"statuses@>= 1.4.0 < 2":
+"statuses@>= 1.5.0 < 2":
   version "1.5.0"
-  resolved "https://registry.npmjs.org/statuses/-/statuses-1.5.0.tgz"
+  resolved "https://registry.yarnpkg.com/statuses/-/statuses-1.5.0.tgz"
   integrity sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA==
 
+statuses@~2.0.1, statuses@~2.0.2:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/statuses/-/statuses-2.0.2.tgz"
+  integrity sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==
+
 std-env@^3.7.0:
-  version "3.8.0"
-  resolved "https://registry.npmjs.org/std-env/-/std-env-3.8.0.tgz"
-  integrity sha512-Bc3YwwCB+OzldMxOXJIIvC6cPRWr/LxOp48CdQTOkPyk/t4JWWJbrilwBd7RJzKV8QW7tJkcgAmeuLLJugl5/w==
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/std-env/-/std-env-3.10.0.tgz"
+  integrity sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==
 
 string-width@^4.1.0, string-width@^4.2.0:
   version "4.2.3"
-  resolved "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz"
+  resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz"
   integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==
   dependencies:
     emoji-regex "^8.0.0"
@@ -8424,7 +8496,7 @@ string-width@^4.1.0, string-width@^4.2.0:
 
 string-width@^5.0.1, string-width@^5.1.2:
   version "5.1.2"
-  resolved "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/string-width/-/string-width-5.1.2.tgz"
   integrity sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==
   dependencies:
     eastasianwidth "^0.2.0"
@@ -8433,21 +8505,21 @@ string-width@^5.0.1, string-width@^5.1.2:
 
 string_decoder@^1.1.1:
   version "1.3.0"
-  resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.3.0.tgz"
   integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==
   dependencies:
     safe-buffer "~5.2.0"
 
 string_decoder@~1.1.1:
   version "1.1.1"
-  resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.1.1.tgz"
   integrity sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==
   dependencies:
     safe-buffer "~5.1.0"
 
 stringify-entities@^4.0.0:
   version "4.0.4"
-  resolved "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/stringify-entities/-/stringify-entities-4.0.4.tgz"
   integrity sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==
   dependencies:
     character-entities-html4 "^2.0.0"
@@ -8455,64 +8527,64 @@ stringify-entities@^4.0.0:
 
 stringify-object@^3.3.0:
   version "3.3.0"
-  resolved "https://registry.npmjs.org/stringify-object/-/stringify-object-3.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/stringify-object/-/stringify-object-3.3.0.tgz"
   integrity sha512-rHqiFh1elqCQ9WPLIC8I0Q/g/wj5J1eMkyoiD6eoQApWHP0FtlK7rqnhmabL5VUY9JQCcqwwvlOaSuutekgyrw==
   dependencies:
     get-own-enumerable-property-symbols "^3.0.0"
     is-obj "^1.0.1"
     is-regexp "^1.0.0"
 
-strip-ansi@^6.0.0, strip-ansi@^6.0.1:
+strip-ansi@^6.0.1:
   version "6.0.1"
-  resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz"
   integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
   dependencies:
     ansi-regex "^5.0.1"
 
 strip-ansi@^7.0.1:
-  version "7.1.0"
-  resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz"
-  integrity sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-7.2.0.tgz"
+  integrity sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==
   dependencies:
-    ansi-regex "^6.0.1"
+    ansi-regex "^6.2.2"
 
 strip-bom-string@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/strip-bom-string/-/strip-bom-string-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/strip-bom-string/-/strip-bom-string-1.0.0.tgz"
   integrity sha512-uCC2VHvQRYu+lMh4My/sFNmF2klFymLX1wHJeXnbEJERpV/ZsVuonzerjfrGpIGF7LBVa1O7i9kjiWvJiFck8g==
 
 strip-final-newline@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/strip-final-newline/-/strip-final-newline-2.0.0.tgz"
   integrity sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==
 
 strip-json-comments@^3.1.1:
   version "3.1.1"
-  resolved "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-3.1.1.tgz"
   integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==
 
 strip-json-comments@~2.0.1:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-2.0.1.tgz"
   integrity sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==
 
-style-to-object@^0.4.0:
-  version "0.4.4"
-  resolved "https://registry.npmjs.org/style-to-object/-/style-to-object-0.4.4.tgz"
-  integrity sha512-HYNoHZa2GorYNyqiCaBgsxvcJIn7OHq6inEga+E6Ke3m5JkoqpQbnFssk4jwe+K7AhGa2fcha4wSOf1Kn01dMg==
+style-to-js@^1.0.0:
+  version "1.1.21"
+  resolved "https://registry.yarnpkg.com/style-to-js/-/style-to-js-1.1.21.tgz"
+  integrity sha512-RjQetxJrrUJLQPHbLku6U/ocGtzyjbJMP9lCNK7Ag0CNh690nSH8woqWH9u16nMjYBAok+i7JO1NP2pOy8IsPQ==
   dependencies:
-    inline-style-parser "0.1.1"
+    style-to-object "1.0.14"
 
-style-to-object@^1.0.0:
-  version "1.0.8"
-  resolved "https://registry.npmjs.org/style-to-object/-/style-to-object-1.0.8.tgz"
-  integrity sha512-xT47I/Eo0rwJmaXC4oilDGDWLohVhR6o/xAQcPQN8q6QBuZVL8qMYL85kLmST5cPjAorwvqIA4qXTRQoYHaL6g==
+style-to-object@1.0.14:
+  version "1.0.14"
+  resolved "https://registry.yarnpkg.com/style-to-object/-/style-to-object-1.0.14.tgz"
+  integrity sha512-LIN7rULI0jBscWQYaSswptyderlarFkjQ+t79nzty8tcIAceVomEVlLzH5VP4Cmsv6MtKhs7qaAiwlcp+Mgaxw==
   dependencies:
-    inline-style-parser "0.2.4"
+    inline-style-parser "0.2.7"
 
 stylehacks@^6.1.1:
   version "6.1.1"
-  resolved "https://registry.npmjs.org/stylehacks/-/stylehacks-6.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/stylehacks/-/stylehacks-6.1.1.tgz"
   integrity sha512-gSTTEQ670cJNoaeIp9KX6lZmm8LJ3jPB5yJmX8Zq/wQxOsAFXV3qjWzHas3YYk1qesuVIyYWWUpZ0vSE/dTSGg==
   dependencies:
     browserslist "^4.23.0"
@@ -8520,142 +8592,153 @@ stylehacks@^6.1.1:
 
 supports-color@^7.1.0:
   version "7.2.0"
-  resolved "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-7.2.0.tgz"
   integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==
   dependencies:
     has-flag "^4.0.0"
 
 supports-color@^8.0.0:
   version "8.1.1"
-  resolved "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-8.1.1.tgz"
   integrity sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==
   dependencies:
     has-flag "^4.0.0"
 
 supports-preserve-symlinks-flag@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz"
   integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==
 
 svg-parser@^2.0.4:
   version "2.0.4"
-  resolved "https://registry.npmjs.org/svg-parser/-/svg-parser-2.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/svg-parser/-/svg-parser-2.0.4.tgz"
   integrity sha512-e4hG1hRwoOdRb37cIMSgzNsxyzKfayW6VOflrwvR+/bzrkyxY/31WkbgnQpgtrNp1SdpJvpUAGTa/ZoiPNDuRQ==
 
 svgo@^3.0.2, svgo@^3.2.0:
-  version "3.3.2"
-  resolved "https://registry.npmjs.org/svgo/-/svgo-3.3.2.tgz"
-  integrity sha512-OoohrmuUlBs8B8o6MB2Aevn+pRIH9zDALSR+6hhqVfa6fRwG/Qw9VUMSMW9VNg2CFc/MTIfabtdOVl9ODIJjpw==
+  version "3.3.3"
+  resolved "https://registry.yarnpkg.com/svgo/-/svgo-3.3.3.tgz"
+  integrity sha512-+wn7I4p7YgJhHs38k2TNjy1vCfPIfLIJWR5MnCStsN8WuuTcBnRKcMHQLMM2ijxGZmDoZwNv8ipl5aTTen62ng==
   dependencies:
-    "@trysound/sax" "0.2.0"
     commander "^7.2.0"
     css-select "^5.1.0"
     css-tree "^2.3.1"
     css-what "^6.1.0"
     csso "^5.0.5"
     picocolors "^1.0.0"
+    sax "^1.5.0"
 
-tapable@^1.0.0:
-  version "1.1.3"
-  resolved "https://registry.npmjs.org/tapable/-/tapable-1.1.3.tgz"
-  integrity sha512-4WK/bYZmj8xLr+HUCODHGF1ZFzsYffasLUgEiMBY4fgtltdO6B4WJtlSbPaDTLpYTcGVwM2qLnFTICEcNxs3kA==
-
-tapable@^2.0.0, tapable@^2.1.1, tapable@^2.2.0, tapable@^2.2.1:
-  version "2.2.1"
-  resolved "https://registry.npmjs.org/tapable/-/tapable-2.2.1.tgz"
-  integrity sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==
+tapable@^2.0.0, tapable@^2.2.1, tapable@^2.3.0, tapable@^2.3.3:
+  version "2.3.3"
+  resolved "https://registry.yarnpkg.com/tapable/-/tapable-2.3.3.tgz"
+  integrity sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A==
 
-terser-webpack-plugin@^5.3.10, terser-webpack-plugin@^5.3.9:
-  version "5.3.11"
-  resolved "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.11.tgz"
-  integrity sha512-RVCsMfuD0+cTt3EwX8hSl2Ks56EbFHWmhluwcqoPKtBnfjiT6olaq7PRIRfhyU8nnC2MrnDrBLfrD/RGE+cVXQ==
+terser-webpack-plugin@^5.3.17, terser-webpack-plugin@^5.3.9:
+  version "5.5.0"
+  resolved "https://registry.yarnpkg.com/terser-webpack-plugin/-/terser-webpack-plugin-5.5.0.tgz"
+  integrity sha512-UYhptBwhWvfIjKd/UuFo6D8uq9xpGLDK+z8EDsj/zWhrTaH34cKEbrkMKfV5YWqGBvAYA3tlzZbs2R+qYrbQJA==
   dependencies:
     "@jridgewell/trace-mapping" "^0.3.25"
     jest-worker "^27.4.5"
     schema-utils "^4.3.0"
-    serialize-javascript "^6.0.2"
     terser "^5.31.1"
 
 terser@^5.10.0, terser@^5.15.1, terser@^5.31.1:
-  version "5.37.0"
-  resolved "https://registry.npmjs.org/terser/-/terser-5.37.0.tgz"
-  integrity sha512-B8wRRkmre4ERucLM/uXx4MOV5cbnOlVAqUst+1+iLKPI0dOgFO28f84ptoQt9HEI537PMzfYa/d+GEPKTRXmYA==
+  version "5.46.2"
+  resolved "https://registry.yarnpkg.com/terser/-/terser-5.46.2.tgz"
+  integrity sha512-uxfo9fPcSgLDYob/w1FuL0c99MWiJDnv+5qXSQc5+Ki5NjVNsYi66INnMFBjf6uFz6OnX12piJQPF4IpjJTNTw==
   dependencies:
     "@jridgewell/source-map" "^0.3.3"
-    acorn "^8.8.2"
+    acorn "^8.15.0"
     commander "^2.20.0"
     source-map-support "~0.5.20"
 
-text-table@^0.2.0:
-  version "0.2.0"
-  resolved "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz"
-  integrity sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==
+thingies@^2.5.0:
+  version "2.6.0"
+  resolved "https://registry.yarnpkg.com/thingies/-/thingies-2.6.0.tgz"
+  integrity sha512-rMHRjmlFLM1R96UYPvpmnc3LYtdFrT33JIB7L9hetGue1qAPfn1N2LJeEjxUSidu1Iku+haLZXDuEXUHNGO/lg==
 
 thunky@^1.0.2:
   version "1.1.0"
-  resolved "https://registry.npmjs.org/thunky/-/thunky-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/thunky/-/thunky-1.1.0.tgz"
   integrity sha512-eHY7nBftgThBqOyHGVN+l8gF0BucP09fMo0oO/Lb0w1OF80dJv+lDVpXG60WMQvkcxAkNybKsrEIE3ZtKGmPrA==
 
 tiny-invariant@^1.0.2:
   version "1.3.3"
-  resolved "https://registry.npmjs.org/tiny-invariant/-/tiny-invariant-1.3.3.tgz"
+  resolved "https://registry.yarnpkg.com/tiny-invariant/-/tiny-invariant-1.3.3.tgz"
   integrity sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==
 
 tiny-warning@^1.0.0:
   version "1.0.3"
-  resolved "https://registry.npmjs.org/tiny-warning/-/tiny-warning-1.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/tiny-warning/-/tiny-warning-1.0.3.tgz"
   integrity sha512-lBN9zLN/oAf68o3zNXYrdCt1kP8WsiGW8Oo2ka41b2IM5JL/S1CTyX1rW0mb/zSuJun0ZUrDxx4sqvYS2FWzPA==
 
+tinypool@^1.0.2:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/tinypool/-/tinypool-1.1.1.tgz"
+  integrity sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==
+
 to-regex-range@^5.0.1:
   version "5.0.1"
-  resolved "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz"
   integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==
   dependencies:
     is-number "^7.0.0"
 
-toidentifier@1.0.1:
+toidentifier@1.0.1, toidentifier@~1.0.1:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/toidentifier/-/toidentifier-1.0.1.tgz"
   integrity sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==
 
 totalist@^3.0.0:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/totalist/-/totalist-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/totalist/-/totalist-3.0.1.tgz"
   integrity sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==
 
+tree-dump@^1.0.3, tree-dump@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/tree-dump/-/tree-dump-1.1.0.tgz"
+  integrity sha512-rMuvhU4MCDbcbnleZTFezWsaZXRFemSqAM+7jPnzUl1fo9w3YEKOxAeui0fz3OI4EU4hf23iyA7uQRVko+UaBA==
+
 trim-lines@^3.0.0:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/trim-lines/-/trim-lines-3.0.1.tgz"
   integrity sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==
 
 trough@^2.0.0:
   version "2.2.0"
-  resolved "https://registry.npmjs.org/trough/-/trough-2.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/trough/-/trough-2.2.0.tgz"
   integrity sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw==
 
-tslib@^2.0.3, tslib@^2.6.0:
+tslib@^1.9.3:
+  version "1.14.1"
+  resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.14.1.tgz"
+  integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==
+
+tslib@^2.0.0, tslib@^2.0.3, tslib@^2.6.0, tslib@^2.8.1:
   version "2.8.1"
-  resolved "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.8.1.tgz"
   integrity sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==
 
-type-fest@^0.21.3:
-  version "0.21.3"
-  resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz"
-  integrity sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==
+tsyringe@^4.10.0:
+  version "4.10.0"
+  resolved "https://registry.yarnpkg.com/tsyringe/-/tsyringe-4.10.0.tgz"
+  integrity sha512-axr3IdNuVIxnaK5XGEUFTu3YmAQ6lllgrvqfEoR16g/HGnYY/6We4oWENtAnzK6/LpJ2ur9PAb80RBt7/U4ugw==
+  dependencies:
+    tslib "^1.9.3"
 
 type-fest@^1.0.1:
   version "1.4.0"
-  resolved "https://registry.npmjs.org/type-fest/-/type-fest-1.4.0.tgz"
+  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-1.4.0.tgz"
   integrity sha512-yGSza74xk0UG8k+pLh5oeoYirvIiWo5t0/o3zHHAO2tRDiZcxWP7fywNlXhqb6/r6sWvwi+RsyQMWhVLe4BVuA==
 
 type-fest@^2.13.0, type-fest@^2.5.0:
   version "2.19.0"
-  resolved "https://registry.npmjs.org/type-fest/-/type-fest-2.19.0.tgz"
+  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-2.19.0.tgz"
   integrity sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA==
 
 type-is@~1.6.18:
   version "1.6.18"
-  resolved "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz"
+  resolved "https://registry.yarnpkg.com/type-is/-/type-is-1.6.18.tgz"
   integrity sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==
   dependencies:
     media-typer "0.3.0"
@@ -8663,47 +8746,47 @@ type-is@~1.6.18:
 
 typedarray-to-buffer@^3.1.5:
   version "3.1.5"
-  resolved "https://registry.npmjs.org/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz"
+  resolved "https://registry.yarnpkg.com/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz"
   integrity sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==
   dependencies:
     is-typedarray "^1.0.0"
 
-undici-types@~6.20.0:
-  version "6.20.0"
-  resolved "https://registry.npmjs.org/undici-types/-/undici-types-6.20.0.tgz"
-  integrity sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==
+undici-types@~7.19.0:
+  version "7.19.2"
+  resolved "https://registry.yarnpkg.com/undici-types/-/undici-types-7.19.2.tgz"
+  integrity sha512-qYVnV5OEm2AW8cJMCpdV20CDyaN3g0AjDlOGf1OW4iaDEx8MwdtChUp4zu4H0VP3nDRF/8RKWH+IPp9uW0YGZg==
 
 unicode-canonical-property-names-ecmascript@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.1.tgz"
   integrity sha512-dA8WbNeb2a6oQzAQ55YlT5vQAWGV9WXOsi3SskE3bcCdM0P4SDd+24zS/OCacdRq5BkdsRj9q3Pg6YyQoxIGqg==
 
 unicode-emoji-modifier-base@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/unicode-emoji-modifier-base/-/unicode-emoji-modifier-base-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/unicode-emoji-modifier-base/-/unicode-emoji-modifier-base-1.0.0.tgz"
   integrity sha512-yLSH4py7oFH3oG/9K+XWrz1pSi3dfUrWEnInbxMfArOfc1+33BlGPQtLsOYwvdMy11AwUBetYuaRxSPqgkq+8g==
 
 unicode-match-property-ecmascript@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-2.0.0.tgz"
   integrity sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q==
   dependencies:
     unicode-canonical-property-names-ecmascript "^2.0.0"
     unicode-property-aliases-ecmascript "^2.0.0"
 
-unicode-match-property-value-ecmascript@^2.1.0:
-  version "2.2.0"
-  resolved "https://registry.npmjs.org/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.2.0.tgz"
-  integrity sha512-4IehN3V/+kkr5YeSSDDQG8QLqO26XpL2XP3GQtqwlT/QYSECAwFztxVHjlbh0+gjJ3XmNLS0zDsbgs9jWKExLg==
+unicode-match-property-value-ecmascript@^2.2.1:
+  version "2.2.1"
+  resolved "https://registry.yarnpkg.com/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.2.1.tgz"
+  integrity sha512-JQ84qTuMg4nVkx8ga4A16a1epI9H6uTXAknqxkGF/aFfRLw1xC/Bp24HNLaZhHSkWd3+84t8iXnp1J0kYcZHhg==
 
 unicode-property-aliases-ecmascript@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.1.0.tgz"
-  integrity sha512-6t3foTQI9qne+OZoVQB/8x8rk2k1eVy1gRXhV3oFQ5T6R1dqQ1xtin3XqSlx3+ATBkliTaR/hHyJBm+LVPNM8w==
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.2.0.tgz"
+  integrity sha512-hpbDzxUY9BFwX+UeBnxv3Sh1q7HFxj48DTmXchNgRa46lO8uj3/1iEn3MiNUYTg1g9ctIqXCCERn8gYZhHC5lQ==
 
 unified@^11.0.0, unified@^11.0.3, unified@^11.0.4:
   version "11.0.5"
-  resolved "https://registry.npmjs.org/unified/-/unified-11.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/unified/-/unified-11.0.5.tgz"
   integrity sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA==
   dependencies:
     "@types/unist" "^3.0.0"
@@ -8716,51 +8799,51 @@ unified@^11.0.0, unified@^11.0.3, unified@^11.0.4:
 
 unique-string@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/unique-string/-/unique-string-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/unique-string/-/unique-string-3.0.0.tgz"
   integrity sha512-VGXBUVwxKMBUznyffQweQABPRRW1vHZAbadFZud4pLFAqRGvv/96vafgjWFqzourzr8YonlQiPgH0YCJfawoGQ==
   dependencies:
     crypto-random-string "^4.0.0"
 
 unist-util-is@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.0.tgz"
-  integrity sha512-2qCTHimwdxLfz+YzdGfkqNlH0tLi9xjTnHddPmJwtIG9MGsdbutfTc4P+haPD7l7Cjxf/WZj+we5qfVPvvxfYw==
+  version "6.0.1"
+  resolved "https://registry.yarnpkg.com/unist-util-is/-/unist-util-is-6.0.1.tgz"
+  integrity sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==
   dependencies:
     "@types/unist" "^3.0.0"
 
 unist-util-position-from-estree@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/unist-util-position-from-estree/-/unist-util-position-from-estree-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/unist-util-position-from-estree/-/unist-util-position-from-estree-2.0.0.tgz"
   integrity sha512-KaFVRjoqLyF6YXCbVLNad/eS4+OfPQQn2yOd7zF/h5T/CSL2v8NpN6a5TPvtbXthAGw5nG+PuTtq+DdIZr+cRQ==
   dependencies:
     "@types/unist" "^3.0.0"
 
 unist-util-position@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.npmjs.org/unist-util-position/-/unist-util-position-5.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/unist-util-position/-/unist-util-position-5.0.0.tgz"
   integrity sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==
   dependencies:
     "@types/unist" "^3.0.0"
 
 unist-util-stringify-position@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz"
   integrity sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==
   dependencies:
     "@types/unist" "^3.0.0"
 
 unist-util-visit-parents@^6.0.0:
-  version "6.0.1"
-  resolved "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-6.0.1.tgz"
-  integrity sha512-L/PqWzfTP9lzzEa6CKs0k2nARxTdZduw3zyh8d2NVBnsyvHjSX4TWse388YrrQKbvI8w20fGjGlhgT96WwKykw==
+  version "6.0.2"
+  resolved "https://registry.yarnpkg.com/unist-util-visit-parents/-/unist-util-visit-parents-6.0.2.tgz"
+  integrity sha512-goh1s1TBrqSqukSc8wrjwWhL0hiJxgA8m4kFxGlQ+8FYQ3C/m11FcTs4YYem7V664AhHVvgoQLk890Ssdsr2IQ==
   dependencies:
     "@types/unist" "^3.0.0"
     unist-util-is "^6.0.0"
 
 unist-util-visit@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.0.0.tgz"
-  integrity sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg==
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/unist-util-visit/-/unist-util-visit-5.1.0.tgz"
+  integrity sha512-m+vIdyeCOpdr/QeQCu2EzxX/ohgS8KbnPDgFni4dQsfSCtpz8UqDyY5GjRru8PDKuYn7Fq19j1CQ+nJSsGKOzg==
   dependencies:
     "@types/unist" "^3.0.0"
     unist-util-is "^6.0.0"
@@ -8768,25 +8851,25 @@ unist-util-visit@^5.0.0:
 
 universalify@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/universalify/-/universalify-2.0.1.tgz"
   integrity sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==
 
-unpipe@1.0.0, unpipe@~1.0.0:
+unpipe@~1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/unpipe/-/unpipe-1.0.0.tgz"
   integrity sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==
 
-update-browserslist-db@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.1.tgz"
-  integrity sha512-R8UzCaa9Az+38REPiJ1tXlImTJXlVfgHZsglwBD/k6nj76ctsH1E3q4doGrukiLQd3sGQYu56r5+lo5r94l29A==
+update-browserslist-db@^1.2.3:
+  version "1.2.3"
+  resolved "https://registry.yarnpkg.com/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz"
+  integrity sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==
   dependencies:
     escalade "^3.2.0"
-    picocolors "^1.1.0"
+    picocolors "^1.1.1"
 
 update-notifier@^6.0.2:
   version "6.0.2"
-  resolved "https://registry.npmjs.org/update-notifier/-/update-notifier-6.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/update-notifier/-/update-notifier-6.0.2.tgz"
   integrity sha512-EDxhTEVPZZRLWYcJ4ZXjGFN0oP7qYvbXWzEgRm/Yql4dHX5wDbvh89YHP6PK1lzZJYrMtXUuZZz8XGK+U6U1og==
   dependencies:
     boxen "^7.0.0"
@@ -8806,14 +8889,14 @@ update-notifier@^6.0.2:
 
 uri-js@^4.2.2:
   version "4.4.1"
-  resolved "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz"
+  resolved "https://registry.yarnpkg.com/uri-js/-/uri-js-4.4.1.tgz"
   integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==
   dependencies:
     punycode "^2.1.0"
 
 url-loader@^4.1.1:
   version "4.1.1"
-  resolved "https://registry.npmjs.org/url-loader/-/url-loader-4.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/url-loader/-/url-loader-4.1.1.tgz"
   integrity sha512-3BTV812+AVHHOJQO8O5MkWgZ5aosP7GnROJwvzLS9hWDj00lZ6Z0wNak423Lp9PBZN05N+Jk/N5Si8jRAlGyWA==
   dependencies:
     loader-utils "^2.0.0"
@@ -8822,86 +8905,86 @@ url-loader@^4.1.1:
 
 util-deprecate@^1.0.1, util-deprecate@^1.0.2, util-deprecate@~1.0.1:
   version "1.0.2"
-  resolved "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz"
   integrity sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==
 
 utila@~0.4:
   version "0.4.0"
-  resolved "https://registry.npmjs.org/utila/-/utila-0.4.0.tgz"
+  resolved "https://registry.yarnpkg.com/utila/-/utila-0.4.0.tgz"
   integrity sha512-Z0DbgELS9/L/75wZbro8xAnT50pBVFQZ+hUEueGDU5FN51YSCYM+jdxsfCiHjwNP/4LCDD0i/graKpeBnOXKRA==
 
 utility-types@^3.10.0:
   version "3.11.0"
-  resolved "https://registry.npmjs.org/utility-types/-/utility-types-3.11.0.tgz"
+  resolved "https://registry.yarnpkg.com/utility-types/-/utility-types-3.11.0.tgz"
   integrity sha512-6Z7Ma2aVEWisaL6TvBCy7P8rm2LQoPv6dJ7ecIaIixHcwfbJ0x7mWdbcwlIM5IGQxPZSFYeqRCqlOOeKoJYMkw==
 
 utils-merge@1.0.1:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/utils-merge/-/utils-merge-1.0.1.tgz"
   integrity sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==
 
 uuid@^8.3.2:
   version "8.3.2"
-  resolved "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz"
+  resolved "https://registry.yarnpkg.com/uuid/-/uuid-8.3.2.tgz"
   integrity sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==
 
 value-equal@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/value-equal/-/value-equal-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/value-equal/-/value-equal-1.0.1.tgz"
   integrity sha512-NOJ6JZCAWr0zlxZt+xqCHNTEKOsrks2HQd4MqhP1qy4z1SkbEP467eNx6TgDKXMvUOb+OENfJCZwM+16n7fRfw==
 
 vary@~1.1.2:
   version "1.1.2"
-  resolved "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/vary/-/vary-1.1.2.tgz"
   integrity sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==
 
 vfile-location@^5.0.0:
   version "5.0.3"
-  resolved "https://registry.npmjs.org/vfile-location/-/vfile-location-5.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/vfile-location/-/vfile-location-5.0.3.tgz"
   integrity sha512-5yXvWDEgqeiYiBe1lbxYF7UMAIm/IcopxMHrMQDq3nvKcjPKIhZklUKL+AE7J7uApI4kwe2snsK+eI6UTj9EHg==
   dependencies:
     "@types/unist" "^3.0.0"
     vfile "^6.0.0"
 
 vfile-message@^4.0.0:
-  version "4.0.2"
-  resolved "https://registry.npmjs.org/vfile-message/-/vfile-message-4.0.2.tgz"
-  integrity sha512-jRDZ1IMLttGj41KcZvlrYAaI3CfqpLpfpf+Mfig13viT6NKvRzWZ+lXz0Y5D60w6uJIBAOGq9mSHf0gktF0duw==
+  version "4.0.3"
+  resolved "https://registry.yarnpkg.com/vfile-message/-/vfile-message-4.0.3.tgz"
+  integrity sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw==
   dependencies:
     "@types/unist" "^3.0.0"
     unist-util-stringify-position "^4.0.0"
 
 vfile@^6.0.0, vfile@^6.0.1:
   version "6.0.3"
-  resolved "https://registry.npmjs.org/vfile/-/vfile-6.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/vfile/-/vfile-6.0.3.tgz"
   integrity sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==
   dependencies:
     "@types/unist" "^3.0.0"
     vfile-message "^4.0.0"
 
-watchpack@^2.4.1:
-  version "2.4.2"
-  resolved "https://registry.npmjs.org/watchpack/-/watchpack-2.4.2.tgz"
-  integrity sha512-TnbFSbcOCcDgjZ4piURLCbJ3nJhznVh9kw6F6iokjiFPl8ONxe9A6nMDVXDiNbrSfLILs6vB07F7wLBrwPYzJw==
+watchpack@^2.5.1:
+  version "2.5.1"
+  resolved "https://registry.yarnpkg.com/watchpack/-/watchpack-2.5.1.tgz"
+  integrity sha512-Zn5uXdcFNIA1+1Ei5McRd+iRzfhENPCe7LeABkJtNulSxjma+l7ltNx55BWZkRlwRnpOgHqxnjyaDgJnNXnqzg==
   dependencies:
     glob-to-regexp "^0.4.1"
     graceful-fs "^4.1.2"
 
 wbuf@^1.1.0, wbuf@^1.7.3:
   version "1.7.3"
-  resolved "https://registry.npmjs.org/wbuf/-/wbuf-1.7.3.tgz"
+  resolved "https://registry.yarnpkg.com/wbuf/-/wbuf-1.7.3.tgz"
   integrity sha512-O84QOnr0icsbFGLS0O3bI5FswxzRr8/gHwWkDlQFskhSPryQXvrTMxjxGP4+iWYoauLoBvfDpkrOauZ+0iZpDA==
   dependencies:
     minimalistic-assert "^1.0.0"
 
 web-namespaces@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/web-namespaces/-/web-namespaces-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/web-namespaces/-/web-namespaces-2.0.1.tgz"
   integrity sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ==
 
 webpack-bundle-analyzer@^4.10.2:
   version "4.10.2"
-  resolved "https://registry.npmjs.org/webpack-bundle-analyzer/-/webpack-bundle-analyzer-4.10.2.tgz"
+  resolved "https://registry.yarnpkg.com/webpack-bundle-analyzer/-/webpack-bundle-analyzer-4.10.2.tgz"
   integrity sha512-vJptkMm9pk5si4Bv922ZbKLV8UTT4zib4FPgXMhgzUny0bfDDkLXAVQs3ly3fS4/TN9ROFtb0NFrm04UXFE/Vw==
   dependencies:
     "@discoveryjs/json-ext" "0.5.7"
@@ -8917,56 +9000,55 @@ webpack-bundle-analyzer@^4.10.2:
     sirv "^2.0.3"
     ws "^7.3.1"
 
-webpack-dev-middleware@^5.3.4:
-  version "5.3.4"
-  resolved "https://registry.npmjs.org/webpack-dev-middleware/-/webpack-dev-middleware-5.3.4.tgz"
-  integrity sha512-BVdTqhhs+0IfoeAf7EoH5WE+exCmqGerHfDM0IL096Px60Tq2Mn9MAbnaGUe6HiMa41KMCYF19gyzZmBcq/o4Q==
+webpack-dev-middleware@^7.4.2:
+  version "7.4.5"
+  resolved "https://registry.yarnpkg.com/webpack-dev-middleware/-/webpack-dev-middleware-7.4.5.tgz"
+  integrity sha512-uxQ6YqGdE4hgDKNf7hUiPXOdtkXvBJXrfEGYSx7P7LC8hnUYGK70X6xQXUvXeNyBDDcsiQXpG2m3G9vxowaEuA==
   dependencies:
     colorette "^2.0.10"
-    memfs "^3.4.3"
-    mime-types "^2.1.31"
+    memfs "^4.43.1"
+    mime-types "^3.0.1"
+    on-finished "^2.4.1"
     range-parser "^1.2.1"
     schema-utils "^4.0.0"
 
-webpack-dev-server@^4.15.2:
-  version "4.15.2"
-  resolved "https://registry.npmjs.org/webpack-dev-server/-/webpack-dev-server-4.15.2.tgz"
-  integrity sha512-0XavAZbNJ5sDrCbkpWL8mia0o5WPOd2YGtxrEiZkBK9FjLppIUK2TgxK6qGD2P3hUXTJNNPVibrerKcx5WkR1g==
-  dependencies:
-    "@types/bonjour" "^3.5.9"
-    "@types/connect-history-api-fallback" "^1.3.5"
-    "@types/express" "^4.17.13"
-    "@types/serve-index" "^1.9.1"
-    "@types/serve-static" "^1.13.10"
-    "@types/sockjs" "^0.3.33"
-    "@types/ws" "^8.5.5"
+webpack-dev-server@^5.2.2:
+  version "5.2.3"
+  resolved "https://registry.yarnpkg.com/webpack-dev-server/-/webpack-dev-server-5.2.3.tgz"
+  integrity sha512-9Gyu2F7+bg4Vv+pjbovuYDhHX+mqdqITykfzdM9UyKqKHlsE5aAjRhR+oOEfXW5vBeu8tarzlJFIZva4ZjAdrQ==
+  dependencies:
+    "@types/bonjour" "^3.5.13"
+    "@types/connect-history-api-fallback" "^1.5.4"
+    "@types/express" "^4.17.25"
+    "@types/express-serve-static-core" "^4.17.21"
+    "@types/serve-index" "^1.9.4"
+    "@types/serve-static" "^1.15.5"
+    "@types/sockjs" "^0.3.36"
+    "@types/ws" "^8.5.10"
     ansi-html-community "^0.0.8"
-    bonjour-service "^1.0.11"
-    chokidar "^3.5.3"
+    bonjour-service "^1.2.1"
+    chokidar "^3.6.0"
     colorette "^2.0.10"
-    compression "^1.7.4"
+    compression "^1.8.1"
     connect-history-api-fallback "^2.0.0"
-    default-gateway "^6.0.3"
-    express "^4.17.3"
+    express "^4.22.1"
     graceful-fs "^4.2.6"
-    html-entities "^2.3.2"
-    http-proxy-middleware "^2.0.3"
-    ipaddr.js "^2.0.1"
-    launch-editor "^2.6.0"
-    open "^8.0.9"
-    p-retry "^4.5.0"
-    rimraf "^3.0.2"
-    schema-utils "^4.0.0"
-    selfsigned "^2.1.1"
+    http-proxy-middleware "^2.0.9"
+    ipaddr.js "^2.1.0"
+    launch-editor "^2.6.1"
+    open "^10.0.3"
+    p-retry "^6.2.0"
+    schema-utils "^4.2.0"
+    selfsigned "^5.5.0"
     serve-index "^1.9.1"
     sockjs "^0.3.24"
     spdy "^4.0.2"
-    webpack-dev-middleware "^5.3.4"
-    ws "^8.13.0"
+    webpack-dev-middleware "^7.4.2"
+    ws "^8.18.0"
 
 webpack-merge@^5.9.0:
   version "5.10.0"
-  resolved "https://registry.npmjs.org/webpack-merge/-/webpack-merge-5.10.0.tgz"
+  resolved "https://registry.yarnpkg.com/webpack-merge/-/webpack-merge-5.10.0.tgz"
   integrity sha512-+4zXKdx7UnO+1jaN4l2lHVD+mFvnlZQP/6ljaJVb4SZiwIKeUnrT5l0gkT8z+n4hKpC+jpOv6O9R+gLtag7pSA==
   dependencies:
     clone-deep "^4.0.1"
@@ -8975,64 +9057,61 @@ webpack-merge@^5.9.0:
 
 webpack-merge@^6.0.1:
   version "6.0.1"
-  resolved "https://registry.npmjs.org/webpack-merge/-/webpack-merge-6.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/webpack-merge/-/webpack-merge-6.0.1.tgz"
   integrity sha512-hXXvrjtx2PLYx4qruKl+kyRSLc52V+cCvMxRjmKwoA+CBbbF5GfIBtR6kCvl0fYGqTUPKB+1ktVmTHqMOzgCBg==
   dependencies:
     clone-deep "^4.0.1"
     flat "^5.0.2"
     wildcard "^2.0.1"
 
-webpack-sources@^3.2.3:
-  version "3.2.3"
-  resolved "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.2.3.tgz"
-  integrity sha512-/DyMEOrDgLKKIG0fmvtz+4dUX/3Ghozwgm6iPp8KRhvn+eQf9+Q7GWxVNMk3+uCPWfdXYC4ExGBckIXdFEfH1w==
+webpack-sources@^3.3.4:
+  version "3.4.0"
+  resolved "https://registry.yarnpkg.com/webpack-sources/-/webpack-sources-3.4.0.tgz"
+  integrity sha512-gHwIe1cgBvvfLeu1Yz/dcFpmHfKDVxxyqI+kzqmuxZED81z2ChxpyqPaWcNqigPywhaEke7AjSGga+kxY55gjQ==
 
 webpack@^5.88.1, webpack@^5.95.0:
-  version "5.97.1"
-  resolved "https://registry.npmjs.org/webpack/-/webpack-5.97.1.tgz"
-  integrity sha512-EksG6gFY3L1eFMROS/7Wzgrii5mBAFe4rIr3r2BTfo7bcc+DWwFZ4OJ/miOuHJO/A85HwyI4eQ0F6IKXesO7Fg==
+  version "5.106.2"
+  resolved "https://registry.yarnpkg.com/webpack/-/webpack-5.106.2.tgz"
+  integrity sha512-wGN3qcrBQIFmQ/c0AiOAQBvrZ5lmY8vbbMv4Mxfgzqd/B6+9pXtLo73WuS1dSGXM5QYY3hZnIbvx+K1xxe6FyA==
   dependencies:
     "@types/eslint-scope" "^3.7.7"
-    "@types/estree" "^1.0.6"
+    "@types/estree" "^1.0.8"
+    "@types/json-schema" "^7.0.15"
     "@webassemblyjs/ast" "^1.14.1"
     "@webassemblyjs/wasm-edit" "^1.14.1"
     "@webassemblyjs/wasm-parser" "^1.14.1"
-    acorn "^8.14.0"
-    browserslist "^4.24.0"
+    acorn "^8.16.0"
+    acorn-import-phases "^1.0.3"
+    browserslist "^4.28.1"
     chrome-trace-event "^1.0.2"
-    enhanced-resolve "^5.17.1"
-    es-module-lexer "^1.2.1"
+    enhanced-resolve "^5.20.0"
+    es-module-lexer "^2.0.0"
     eslint-scope "5.1.1"
     events "^3.2.0"
     glob-to-regexp "^0.4.1"
     graceful-fs "^4.2.11"
-    json-parse-even-better-errors "^2.3.1"
-    loader-runner "^4.2.0"
-    mime-types "^2.1.27"
+    loader-runner "^4.3.1"
+    mime-db "^1.54.0"
     neo-async "^2.6.2"
-    schema-utils "^3.2.0"
-    tapable "^2.1.1"
-    terser-webpack-plugin "^5.3.10"
-    watchpack "^2.4.1"
-    webpack-sources "^3.2.3"
+    schema-utils "^4.3.3"
+    tapable "^2.3.0"
+    terser-webpack-plugin "^5.3.17"
+    watchpack "^2.5.1"
+    webpack-sources "^3.3.4"
 
-webpackbar@^6.0.1:
-  version "6.0.1"
-  resolved "https://registry.npmjs.org/webpackbar/-/webpackbar-6.0.1.tgz"
-  integrity sha512-TnErZpmuKdwWBdMoexjio3KKX6ZtoKHRVvLIU0A47R0VVBDtx3ZyOJDktgYixhoJokZTYTt1Z37OkO9pnGJa9Q==
+webpackbar@^6.0.1, webpackbar@^7.0.0:
+  version "7.0.0"
+  resolved "https://registry.yarnpkg.com/webpackbar/-/webpackbar-7.0.0.tgz#7228d32881af2392381b6514499ddea73cdf218a"
+  integrity sha512-aS9soqSO2iCHgqHoCrj4LbfGQUboDCYJPSFOAchEK+9psIjNrfSWW4Y0YEz67MKURNvMmfo0ycOg9d/+OOf9/Q==
   dependencies:
-    ansi-escapes "^4.3.2"
-    chalk "^4.1.2"
+    ansis "^3.2.0"
     consola "^3.2.3"
-    figures "^3.2.0"
-    markdown-table "^2.0.0"
     pretty-time "^1.1.0"
     std-env "^3.7.0"
-    wrap-ansi "^7.0.0"
 
 websocket-driver@>=0.5.1, websocket-driver@^0.7.4:
   version "0.7.4"
-  resolved "https://registry.npmjs.org/websocket-driver/-/websocket-driver-0.7.4.tgz"
+  resolved "https://registry.yarnpkg.com/websocket-driver/-/websocket-driver-0.7.4.tgz"
   integrity sha512-b17KeDIQVjvb0ssuSDF2cYXSg2iztliJ4B9WdsuB6J952qCPKmnVq4DyW5motImXHDC1cBT/1UezrJVsKw5zjg==
   dependencies:
     http-parser-js ">=0.5.1"
@@ -9041,61 +9120,40 @@ websocket-driver@>=0.5.1, websocket-driver@^0.7.4:
 
 websocket-extensions@>=0.1.1:
   version "0.1.4"
-  resolved "https://registry.npmjs.org/websocket-extensions/-/websocket-extensions-0.1.4.tgz"
+  resolved "https://registry.yarnpkg.com/websocket-extensions/-/websocket-extensions-0.1.4.tgz"
   integrity sha512-OqedPIGOfsDlo31UNwYbCFMSaO9m9G/0faIHj5/dZFDMFqPTcx6UwqyOy3COEaEOg/9VsGIpdqn62W5KhoKSpg==
 
-which@^1.3.1:
-  version "1.3.1"
-  resolved "https://registry.npmjs.org/which/-/which-1.3.1.tgz"
-  integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==
-  dependencies:
-    isexe "^2.0.0"
-
 which@^2.0.1:
   version "2.0.2"
-  resolved "https://registry.npmjs.org/which/-/which-2.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/which/-/which-2.0.2.tgz"
   integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==
   dependencies:
     isexe "^2.0.0"
 
 widest-line@^4.0.1:
   version "4.0.1"
-  resolved "https://registry.npmjs.org/widest-line/-/widest-line-4.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/widest-line/-/widest-line-4.0.1.tgz"
   integrity sha512-o0cyEG0e8GPzT4iGHphIOh0cJOV8fivsXxddQasHPHfoZf1ZexrfeA21w2NaEN1RHE+fXlfISmOE8R9N3u3Qig==
   dependencies:
     string-width "^5.0.1"
 
 wildcard@^2.0.0, wildcard@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/wildcard/-/wildcard-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/wildcard/-/wildcard-2.0.1.tgz"
   integrity sha512-CC1bOL87PIWSBhDcTrdeLo6eGT7mCFtrg0uIJtqJUFyK+eJnzl8A1niH56uu7KMa5XFrtiV+AQuHO3n7DsHnLQ==
 
-wrap-ansi@^7.0.0:
-  version "7.0.0"
-  resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz"
-  integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==
-  dependencies:
-    ansi-styles "^4.0.0"
-    string-width "^4.1.0"
-    strip-ansi "^6.0.0"
-
 wrap-ansi@^8.0.1, wrap-ansi@^8.1.0:
   version "8.1.0"
-  resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-8.1.0.tgz"
   integrity sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==
   dependencies:
     ansi-styles "^6.1.0"
     string-width "^5.0.1"
     strip-ansi "^7.0.1"
 
-wrappy@1:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz"
-  integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==
-
 write-file-atomic@^3.0.3:
   version "3.0.3"
-  resolved "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-3.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/write-file-atomic/-/write-file-atomic-3.0.3.tgz"
   integrity sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q==
   dependencies:
     imurmurhash "^0.1.4"
@@ -9105,47 +9163,44 @@ write-file-atomic@^3.0.3:
 
 ws@^7.3.1:
   version "7.5.10"
-  resolved "https://registry.npmjs.org/ws/-/ws-7.5.10.tgz"
+  resolved "https://registry.yarnpkg.com/ws/-/ws-7.5.10.tgz"
   integrity sha512-+dbF1tHwZpXcbOJdVOkzLDxZP1ailvSxM6ZweXTegylPny803bFhA+vqBYw4s31NSAk4S2Qz+AKXK9a4wkdjcQ==
 
-ws@^8.13.0:
-  version "8.18.0"
-  resolved "https://registry.npmjs.org/ws/-/ws-8.18.0.tgz"
-  integrity sha512-8VbfWfHLbbwu3+N6OKsOMpBdT4kXPDDB9cJk2bJ6mh9ucxdlnNvH1e+roYkKmN9Nxw2yjz7VzeO9oOz2zJ04Pw==
+ws@^8.18.0:
+  version "8.20.0"
+  resolved "https://registry.yarnpkg.com/ws/-/ws-8.20.0.tgz"
+  integrity sha512-sAt8BhgNbzCtgGbt2OxmpuryO63ZoDk/sqaB/znQm94T4fCEsy/yV+7CdC1kJhOU9lboAEU7R3kquuycDoibVA==
+
+wsl-utils@^0.1.0:
+  version "0.1.0"
+  resolved "https://registry.yarnpkg.com/wsl-utils/-/wsl-utils-0.1.0.tgz"
+  integrity sha512-h3Fbisa2nKGPxCpm89Hk33lBLsnaGBvctQopaBSOW/uIs6FTe1ATyAnKFJrzVs9vpGdsTe73WF3V4lIsk4Gacw==
+  dependencies:
+    is-wsl "^3.1.0"
 
 xdg-basedir@^5.0.1, xdg-basedir@^5.1.0:
   version "5.1.0"
-  resolved "https://registry.npmjs.org/xdg-basedir/-/xdg-basedir-5.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/xdg-basedir/-/xdg-basedir-5.1.0.tgz"
   integrity sha512-GCPAHLvrIH13+c0SuacwvRYj2SxJXQ4kaVTT5xgL3kPrz56XxkF21IGhjSE1+W0aw7gpBWRGXLCPnPby6lSpmQ==
 
 xml-js@^1.6.11:
   version "1.6.11"
-  resolved "https://registry.npmjs.org/xml-js/-/xml-js-1.6.11.tgz"
+  resolved "https://registry.yarnpkg.com/xml-js/-/xml-js-1.6.11.tgz"
   integrity sha512-7rVi2KMfwfWFl+GpPg6m80IVMWXLRjO+PxTq7V2CDhoGak0wzYzFgUY2m4XJ47OGdXd8eLE8EmwfAmdjw7lC1g==
   dependencies:
     sax "^1.2.4"
 
 yallist@^3.0.2:
   version "3.1.1"
-  resolved "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/yallist/-/yallist-3.1.1.tgz"
   integrity sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==
 
-yaml@^1.7.2:
-  version "1.10.2"
-  resolved "https://registry.npmjs.org/yaml/-/yaml-1.10.2.tgz"
-  integrity sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==
-
-yocto-queue@^0.1.0:
-  version "0.1.0"
-  resolved "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz"
-  integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==
-
 yocto-queue@^1.0.0:
-  version "1.1.1"
-  resolved "https://registry.npmjs.org/yocto-queue/-/yocto-queue-1.1.1.tgz"
-  integrity sha512-b4JR1PFR10y1mKjhHY9LaGo6tmrgjit7hxVIeAmyMw3jegXR4dhYqLaQF5zMXZxY7tLpMyJeLjr1C4rLmkVe8g==
+  version "1.2.2"
+  resolved "https://registry.yarnpkg.com/yocto-queue/-/yocto-queue-1.2.2.tgz"
+  integrity sha512-4LCcse/U2MHZ63HAJVE+v71o7yOdIe4cZ70Wpf8D/IyjDKYQLV5GD46B+hSTjJsvV5PztjvHoU580EftxjDZFQ==
 
 zwitch@^2.0.0:
   version "2.0.4"
-  resolved "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/zwitch/-/zwitch-2.0.4.tgz"
   integrity sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==